From 337ed96d8651991f6d212accc4725850c745e034 Mon Sep 17 00:00:00 2001
From: Lukas Rohde <lukas.rohde@silupe.de>
Date: Sat, 5 Apr 2025 23:56:55 +0200
Subject: [PATCH 001/153] feat: infer types for constant expressions

---
 src/typing/type-inferencer.ts                 | 35 +++++++++++++++++++
 .../typing/constant-type-inference.test.ts    | 33 +++++++++++++++++
 2 files changed, 68 insertions(+)
 create mode 100644 src/typing/type-inferencer.ts
 create mode 100644 test/functionality/typing/constant-type-inference.test.ts

diff --git a/src/typing/type-inferencer.ts b/src/typing/type-inferencer.ts
new file mode 100644
index 00000000000..00cc8c0d1da
--- /dev/null
+++ b/src/typing/type-inferencer.ts
@@ -0,0 +1,35 @@
+import { DefaultNormalizedAstFold } from "../abstract-interpretation/normalized-ast-fold";
+import { RLogical } from "../r-bridge/lang-4.x/ast/model/nodes/r-logical";
+import { RNumber } from "../r-bridge/lang-4.x/ast/model/nodes/r-number";
+import { RString } from "../r-bridge/lang-4.x/ast/model/nodes/r-string";
+
+export enum RDataType {
+    Logical = "LogicalType",
+    Numeric = "NumericType",
+    String = "StringType",
+}
+
+export type TypingInfo = RDataType | undefined;
+
+export class TypeInferencer<Info> extends DefaultNormalizedAstFold<TypingInfo, Info> {
+    constructor() {
+        super(undefined);
+    }
+
+    protected override concat(a: TypingInfo, b: TypingInfo): TypingInfo {
+        // Do not combine typing information for now
+        return b;
+    }
+
+    override foldRLogical(_node: RLogical<Info>): TypingInfo {
+        return RDataType.Logical;
+    }
+
+    override foldRNumber(_node: RNumber<Info>): TypingInfo {
+        return RDataType.Numeric;
+    }
+
+    override foldRString(_node: RString<Info>): TypingInfo {
+        return RDataType.String;
+    }
+}
\ No newline at end of file
diff --git a/test/functionality/typing/constant-type-inference.test.ts b/test/functionality/typing/constant-type-inference.test.ts
new file mode 100644
index 00000000000..0c2b56c8e33
--- /dev/null
+++ b/test/functionality/typing/constant-type-inference.test.ts
@@ -0,0 +1,33 @@
+import { beforeAll, describe, expect, test } from 'vitest';
+import { retrieveNormalizedAst, withShell } from '../_helper/shell';
+import type { NormalizedAst } from '../../../src/r-bridge/lang-4.x/ast/model/processing/decorate';
+import { RDataType, TypeInferencer } from '../../../src/typing/type-inferencer';
+
+describe.sequential('Infer types for constant expressions', withShell(shell => {
+	let logicalAst: NormalizedAst | undefined;
+	let numberAst: NormalizedAst | undefined;
+	let stringAst: NormalizedAst | undefined;
+    let inferencer = new TypeInferencer();
+
+	beforeAll(async() => {
+		logicalAst = await retrieveNormalizedAst(shell, 'TRUE');
+		numberAst  = await retrieveNormalizedAst(shell, '42');
+		stringAst  = await retrieveNormalizedAst(shell, '"Hello, world!"');
+
+	});
+
+	test(`Infer ${RDataType.Logical} for logical constants`, () => {
+		let inferredType = inferencer.fold(logicalAst?.ast);
+		expect(inferredType).toBe(RDataType.Logical);
+	});
+	
+    test(`Infer ${RDataType.Numeric} for numeric constants`, () => {
+		let inferredType = inferencer.fold(numberAst?.ast);
+		expect(inferredType).toBe(RDataType.Numeric);
+	});
+	
+    test(`Infer ${RDataType.String} for string constants`, () => {
+		let inferredType = inferencer.fold(stringAst?.ast);
+		expect(inferredType).toBe(RDataType.String);
+	});
+}));
\ No newline at end of file

From 4ef98113793bcea604c3292a8be6f7a953e7117c Mon Sep 17 00:00:00 2001
From: Lukas Rohde <lukas.rohde@silupe.de>
Date: Sun, 6 Apr 2025 12:38:19 +0200
Subject: [PATCH 002/153] style: make stylistic changes to satisfy ESLint

---
 src/typing/type-inferencer.ts                 | 46 +++++++++----------
 .../typing/constant-type-inference.test.ts    | 12 ++---
 2 files changed, 29 insertions(+), 29 deletions(-)

diff --git a/src/typing/type-inferencer.ts b/src/typing/type-inferencer.ts
index 00cc8c0d1da..1e9c8253fcd 100644
--- a/src/typing/type-inferencer.ts
+++ b/src/typing/type-inferencer.ts
@@ -1,35 +1,35 @@
-import { DefaultNormalizedAstFold } from "../abstract-interpretation/normalized-ast-fold";
-import { RLogical } from "../r-bridge/lang-4.x/ast/model/nodes/r-logical";
-import { RNumber } from "../r-bridge/lang-4.x/ast/model/nodes/r-number";
-import { RString } from "../r-bridge/lang-4.x/ast/model/nodes/r-string";
+import { DefaultNormalizedAstFold } from '../abstract-interpretation/normalized-ast-fold';
+import type { RLogical } from '../r-bridge/lang-4.x/ast/model/nodes/r-logical';
+import type { RNumber } from '../r-bridge/lang-4.x/ast/model/nodes/r-number';
+import type { RString } from '../r-bridge/lang-4.x/ast/model/nodes/r-string';
 
 export enum RDataType {
-    Logical = "LogicalType",
-    Numeric = "NumericType",
-    String = "StringType",
+    Logical = 'LogicalType',
+    Numeric = 'NumericType',
+    String = 'StringType',
 }
 
 export type TypingInfo = RDataType | undefined;
 
 export class TypeInferencer<Info> extends DefaultNormalizedAstFold<TypingInfo, Info> {
-    constructor() {
-        super(undefined);
-    }
+	constructor() {
+		super(undefined);
+	}
 
-    protected override concat(a: TypingInfo, b: TypingInfo): TypingInfo {
-        // Do not combine typing information for now
-        return b;
-    }
+	protected override concat(a: TypingInfo, b: TypingInfo): TypingInfo {
+		// Do not combine typing information for now
+		return b;
+	}
 
-    override foldRLogical(_node: RLogical<Info>): TypingInfo {
-        return RDataType.Logical;
-    }
+	override foldRLogical(_node: RLogical<Info>): TypingInfo {
+		return RDataType.Logical;
+	}
 
-    override foldRNumber(_node: RNumber<Info>): TypingInfo {
-        return RDataType.Numeric;
-    }
+	override foldRNumber(_node: RNumber<Info>): TypingInfo {
+		return RDataType.Numeric;
+	}
 
-    override foldRString(_node: RString<Info>): TypingInfo {
-        return RDataType.String;
-    }
+	override foldRString(_node: RString<Info>): TypingInfo {
+		return RDataType.String;
+	}
 }
\ No newline at end of file
diff --git a/test/functionality/typing/constant-type-inference.test.ts b/test/functionality/typing/constant-type-inference.test.ts
index 0c2b56c8e33..31a38c7286e 100644
--- a/test/functionality/typing/constant-type-inference.test.ts
+++ b/test/functionality/typing/constant-type-inference.test.ts
@@ -7,7 +7,7 @@ describe.sequential('Infer types for constant expressions', withShell(shell => {
 	let logicalAst: NormalizedAst | undefined;
 	let numberAst: NormalizedAst | undefined;
 	let stringAst: NormalizedAst | undefined;
-    let inferencer = new TypeInferencer();
+	const inferencer = new TypeInferencer();
 
 	beforeAll(async() => {
 		logicalAst = await retrieveNormalizedAst(shell, 'TRUE');
@@ -17,17 +17,17 @@ describe.sequential('Infer types for constant expressions', withShell(shell => {
 	});
 
 	test(`Infer ${RDataType.Logical} for logical constants`, () => {
-		let inferredType = inferencer.fold(logicalAst?.ast);
+		const inferredType = inferencer.fold(logicalAst?.ast);
 		expect(inferredType).toBe(RDataType.Logical);
 	});
 	
-    test(`Infer ${RDataType.Numeric} for numeric constants`, () => {
-		let inferredType = inferencer.fold(numberAst?.ast);
+	test(`Infer ${RDataType.Numeric} for numeric constants`, () => {
+		const inferredType = inferencer.fold(numberAst?.ast);
 		expect(inferredType).toBe(RDataType.Numeric);
 	});
 	
-    test(`Infer ${RDataType.String} for string constants`, () => {
-		let inferredType = inferencer.fold(stringAst?.ast);
+	test(`Infer ${RDataType.String} for string constants`, () => {
+		const inferredType = inferencer.fold(stringAst?.ast);
 		expect(inferredType).toBe(RDataType.String);
 	});
 }));
\ No newline at end of file

From 746596b9018aa11da387732eb7188a21a3afca56 Mon Sep 17 00:00:00 2001
From: Lukas Rohde <lukas.rohde@silupe.de>
Date: Mon, 7 Apr 2025 17:35:30 +0200
Subject: [PATCH 003/153] test(typing): streamline the type inferencer tests
 using `describe.each`

---
 .../typing/constant-type-inference.test.ts    | 38 ++++++-------------
 1 file changed, 12 insertions(+), 26 deletions(-)

diff --git a/test/functionality/typing/constant-type-inference.test.ts b/test/functionality/typing/constant-type-inference.test.ts
index 31a38c7286e..62fcdb9b2a8 100644
--- a/test/functionality/typing/constant-type-inference.test.ts
+++ b/test/functionality/typing/constant-type-inference.test.ts
@@ -1,33 +1,19 @@
-import { beforeAll, describe, expect, test } from 'vitest';
+import { describe, expect, test } from 'vitest';
 import { retrieveNormalizedAst, withShell } from '../_helper/shell';
-import type { NormalizedAst } from '../../../src/r-bridge/lang-4.x/ast/model/processing/decorate';
 import { RDataType, TypeInferencer } from '../../../src/typing/type-inferencer';
 
-describe.sequential('Infer types for constant expressions', withShell(shell => {
-	let logicalAst: NormalizedAst | undefined;
-	let numberAst: NormalizedAst | undefined;
-	let stringAst: NormalizedAst | undefined;
+describe.sequential('Infer types for R expressions', withShell(shell => {
 	const inferencer = new TypeInferencer();
-
-	beforeAll(async() => {
-		logicalAst = await retrieveNormalizedAst(shell, 'TRUE');
-		numberAst  = await retrieveNormalizedAst(shell, '42');
-		stringAst  = await retrieveNormalizedAst(shell, '"Hello, world!"');
-
-	});
-
-	test(`Infer ${RDataType.Logical} for logical constants`, () => {
-		const inferredType = inferencer.fold(logicalAst?.ast);
-		expect(inferredType).toBe(RDataType.Logical);
-	});
-	
-	test(`Infer ${RDataType.Numeric} for numeric constants`, () => {
-		const inferredType = inferencer.fold(numberAst?.ast);
-		expect(inferredType).toBe(RDataType.Numeric);
-	});
 	
-	test(`Infer ${RDataType.String} for string constants`, () => {
-		const inferredType = inferencer.fold(stringAst?.ast);
-		expect(inferredType).toBe(RDataType.String);
+	describe.each([
+		{ description: 'logical constant', input: 'TRUE',            expectedType: RDataType.Logical },
+		{ description: 'numeric constant', input: '42',              expectedType: RDataType.Numeric },
+		{ description: 'string constant',  input: '"Hello, world!"', expectedType: RDataType.String },
+	])('Infer $expectedType for $description', ({ input, expectedType }) => {
+		test(`Infer ${expectedType} for ${input}`, async() => {
+			const ast = await retrieveNormalizedAst(shell, input).then(promise => promise.ast);
+			const inferredType = inferencer.fold(ast);
+			expect(inferredType).toBe(expectedType);
+		});
 	});
 }));
\ No newline at end of file

From e53e00327467e6e428c736ce768c3e98c868070f Mon Sep 17 00:00:00 2001
From: Lukas Rohde <lukas.rohde@silupe.de>
Date: Mon, 7 Apr 2025 17:42:34 +0200
Subject: [PATCH 004/153] feat(typing): add preliminary support for expression
 lists and `NULL`

---
 src/typing/type-inferencer.ts | 20 ++++++++++++++++----
 1 file changed, 16 insertions(+), 4 deletions(-)

diff --git a/src/typing/type-inferencer.ts b/src/typing/type-inferencer.ts
index 1e9c8253fcd..4788093d965 100644
--- a/src/typing/type-inferencer.ts
+++ b/src/typing/type-inferencer.ts
@@ -1,4 +1,5 @@
 import { DefaultNormalizedAstFold } from '../abstract-interpretation/normalized-ast-fold';
+import type { RExpressionList } from '../r-bridge/lang-4.x/ast/model/nodes/r-expression-list';
 import type { RLogical } from '../r-bridge/lang-4.x/ast/model/nodes/r-logical';
 import type { RNumber } from '../r-bridge/lang-4.x/ast/model/nodes/r-number';
 import type { RString } from '../r-bridge/lang-4.x/ast/model/nodes/r-string';
@@ -6,19 +7,21 @@ import type { RString } from '../r-bridge/lang-4.x/ast/model/nodes/r-string';
 export enum RDataType {
     Logical = 'LogicalType',
     Numeric = 'NumericType',
-    String = 'StringType',
+    String  = 'StringType',
+	Null    = 'NullType',
 }
 
-export type TypingInfo = RDataType | undefined;
+export type TypingInfo = RDataType
+					   | undefined; // Represents missing type information
 
 export class TypeInferencer<Info> extends DefaultNormalizedAstFold<TypingInfo, Info> {
 	constructor() {
 		super(undefined);
 	}
 
-	protected override concat(a: TypingInfo, b: TypingInfo): TypingInfo {
+	protected override concat(_a: TypingInfo, _b: TypingInfo): TypingInfo {
 		// Do not combine typing information for now
-		return b;
+		return undefined;
 	}
 
 	override foldRLogical(_node: RLogical<Info>): TypingInfo {
@@ -32,4 +35,13 @@ export class TypeInferencer<Info> extends DefaultNormalizedAstFold<TypingInfo, I
 	override foldRString(_node: RString<Info>): TypingInfo {
 		return RDataType.String;
 	}
+
+	override foldRExpressionList(exprList: RExpressionList<Info>): TypingInfo {
+		if(exprList.children.length === 0) {
+			return RDataType.Null;
+		} else {
+			// Do not handle early returns for now
+			return this.fold(exprList.children[exprList.children.length - 1]);
+		}
+	}
 }
\ No newline at end of file

From 8072fe6d1de0ae207508ec9eaf3a0f37ccf83be2 Mon Sep 17 00:00:00 2001
From: Lukas Rohde <lukas.rohde@silupe.de>
Date: Mon, 7 Apr 2025 17:52:27 +0200
Subject: [PATCH 005/153] test(typing): add tests for unsupported expression
 types

---
 .../typing/constant-type-inference.test.ts       | 16 +++++++++++++++-
 1 file changed, 15 insertions(+), 1 deletion(-)

diff --git a/test/functionality/typing/constant-type-inference.test.ts b/test/functionality/typing/constant-type-inference.test.ts
index 62fcdb9b2a8..aab5771a9b5 100644
--- a/test/functionality/typing/constant-type-inference.test.ts
+++ b/test/functionality/typing/constant-type-inference.test.ts
@@ -2,7 +2,7 @@ import { describe, expect, test } from 'vitest';
 import { retrieveNormalizedAst, withShell } from '../_helper/shell';
 import { RDataType, TypeInferencer } from '../../../src/typing/type-inferencer';
 
-describe.sequential('Infer types for R expressions', withShell(shell => {
+describe.sequential('Infer types for currently supported R expressions', withShell(shell => {
 	const inferencer = new TypeInferencer();
 	
 	describe.each([
@@ -16,4 +16,18 @@ describe.sequential('Infer types for R expressions', withShell(shell => {
 			expect(inferredType).toBe(expectedType);
 		});
 	});
+
+	describe('Infer no type information for currently unsupported R expressions', () => {
+		test('Infer no type information for binary operations', async() => {
+			const ast = await retrieveNormalizedAst(shell, '1 + 2').then(promise => promise.ast);
+			const inferredType = inferencer.fold(ast);
+			expect(inferredType).toBe(undefined);
+		});
+
+		test('Infer no type information for function calls', async() => {
+			const ast = await retrieveNormalizedAst(shell, 'print("foo")').then(promise => promise.ast);
+			const inferredType = inferencer.fold(ast);
+			expect(inferredType).toBe(undefined);
+		});
+	});
 }));
\ No newline at end of file

From ce1fc8cd8fba858779fca3d31e22fb2ca9967b63 Mon Sep 17 00:00:00 2001
From: Lukas Rohde <lukas.rohde@silupe.de>
Date: Mon, 7 Apr 2025 17:54:03 +0200
Subject: [PATCH 006/153] test: add a test for empty expression lists

---
 test/functionality/typing/constant-type-inference.test.ts | 7 ++++---
 1 file changed, 4 insertions(+), 3 deletions(-)

diff --git a/test/functionality/typing/constant-type-inference.test.ts b/test/functionality/typing/constant-type-inference.test.ts
index aab5771a9b5..7f827770462 100644
--- a/test/functionality/typing/constant-type-inference.test.ts
+++ b/test/functionality/typing/constant-type-inference.test.ts
@@ -6,9 +6,10 @@ describe.sequential('Infer types for currently supported R expressions', withShe
 	const inferencer = new TypeInferencer();
 	
 	describe.each([
-		{ description: 'logical constant', input: 'TRUE',            expectedType: RDataType.Logical },
-		{ description: 'numeric constant', input: '42',              expectedType: RDataType.Numeric },
-		{ description: 'string constant',  input: '"Hello, world!"', expectedType: RDataType.String },
+		{ description: 'logical constant',       input: 'TRUE',            expectedType: RDataType.Logical },
+		{ description: 'numeric constant',       input: '42',              expectedType: RDataType.Numeric },
+		{ description: 'string constant',        input: '"Hello, world!"', expectedType: RDataType.String },
+		{ description: 'empty expression list',  input: '{}',              expectedType: RDataType.Null },
 	])('Infer $expectedType for $description', ({ input, expectedType }) => {
 		test(`Infer ${expectedType} for ${input}`, async() => {
 			const ast = await retrieveNormalizedAst(shell, input).then(promise => promise.ast);

From 53fe22fd425ea97ce8b256a5bdc78279f3e693c9 Mon Sep 17 00:00:00 2001
From: Lukas Rohde <lukas.rohde@silupe.de>
Date: Mon, 7 Apr 2025 17:59:21 +0200
Subject: [PATCH 007/153] feat(typing): add support for complex number literals

---
 src/typing/type-inferencer.ts                            | 6 +++++-
 .../functionality/typing/constant-type-inference.test.ts | 9 +++++----
 2 files changed, 10 insertions(+), 5 deletions(-)

diff --git a/src/typing/type-inferencer.ts b/src/typing/type-inferencer.ts
index 4788093d965..9955828ea4b 100644
--- a/src/typing/type-inferencer.ts
+++ b/src/typing/type-inferencer.ts
@@ -7,6 +7,7 @@ import type { RString } from '../r-bridge/lang-4.x/ast/model/nodes/r-string';
 export enum RDataType {
     Logical = 'LogicalType',
     Numeric = 'NumericType',
+	Complex = 'ComplexType',
     String  = 'StringType',
 	Null    = 'NullType',
 }
@@ -28,7 +29,10 @@ export class TypeInferencer<Info> extends DefaultNormalizedAstFold<TypingInfo, I
 		return RDataType.Logical;
 	}
 
-	override foldRNumber(_node: RNumber<Info>): TypingInfo {
+	override foldRNumber(node: RNumber<Info>): TypingInfo {
+		if(node.content.complexNumber) {
+			return RDataType.Complex;
+		}
 		return RDataType.Numeric;
 	}
 
diff --git a/test/functionality/typing/constant-type-inference.test.ts b/test/functionality/typing/constant-type-inference.test.ts
index 7f827770462..83b334e664f 100644
--- a/test/functionality/typing/constant-type-inference.test.ts
+++ b/test/functionality/typing/constant-type-inference.test.ts
@@ -6,10 +6,11 @@ describe.sequential('Infer types for currently supported R expressions', withShe
 	const inferencer = new TypeInferencer();
 	
 	describe.each([
-		{ description: 'logical constant',       input: 'TRUE',            expectedType: RDataType.Logical },
-		{ description: 'numeric constant',       input: '42',              expectedType: RDataType.Numeric },
-		{ description: 'string constant',        input: '"Hello, world!"', expectedType: RDataType.String },
-		{ description: 'empty expression list',  input: '{}',              expectedType: RDataType.Null },
+		{ description: 'logical constant',        input: 'TRUE',            expectedType: RDataType.Logical },
+		{ description: 'numeric constant',        input: '42',              expectedType: RDataType.Numeric },
+		{ description: 'complex number constant', input: '42i',             expectedType: RDataType.Complex },
+		{ description: 'string constant',         input: '"Hello, world!"', expectedType: RDataType.String },
+		{ description: 'empty expression list',   input: '{}',              expectedType: RDataType.Null },
 	])('Infer $expectedType for $description', ({ input, expectedType }) => {
 		test(`Infer ${expectedType} for ${input}`, async() => {
 			const ast = await retrieveNormalizedAst(shell, input).then(promise => promise.ast);

From 18ec199b1f8ae8838a07287f3a239695d3452940 Mon Sep 17 00:00:00 2001
From: Lukas Rohde <lukas.rohde@silupe.de>
Date: Mon, 7 Apr 2025 20:01:52 +0200
Subject: [PATCH 008/153] test(types): refactor tests to use tree-sitter

---
 .../_helper/typing/assert-inferred-type.ts    | 20 +++++++++++++
 .../typing/constant-type-inference.test.ts    | 30 +++++--------------
 2 files changed, 28 insertions(+), 22 deletions(-)
 create mode 100644 test/functionality/_helper/typing/assert-inferred-type.ts

diff --git a/test/functionality/_helper/typing/assert-inferred-type.ts b/test/functionality/_helper/typing/assert-inferred-type.ts
new file mode 100644
index 00000000000..8dfbc8ee0c6
--- /dev/null
+++ b/test/functionality/_helper/typing/assert-inferred-type.ts
@@ -0,0 +1,20 @@
+import { expect, test } from 'vitest';
+import { TreeSitterExecutor } from '../../../../src/r-bridge/lang-4.x/tree-sitter/tree-sitter-executor';
+import type { TypeInferencer, TypingInfo } from '../../../../src/typing/type-inferencer';
+import { createNormalizePipeline } from '../../../../src/core/steps/pipeline/default-pipelines';
+import { requestFromInput } from '../../../../src/r-bridge/retriever';
+
+export function assertInferredType(
+	input: string,
+	expectedType: TypingInfo,
+	inferencer: TypeInferencer<unknown>,
+): void {
+	test(`Infer ${expectedType} for ${input}`, async() => {
+		const executor = new TreeSitterExecutor();
+		const ast = await createNormalizePipeline(executor, { request: requestFromInput(input) })
+			.allRemainingSteps()
+			.then(promise => promise.normalize.ast);
+		const inferredType = inferencer.fold(ast);
+		expect(inferredType).toBe(expectedType);
+	});
+}
\ No newline at end of file
diff --git a/test/functionality/typing/constant-type-inference.test.ts b/test/functionality/typing/constant-type-inference.test.ts
index 83b334e664f..8db5b645673 100644
--- a/test/functionality/typing/constant-type-inference.test.ts
+++ b/test/functionality/typing/constant-type-inference.test.ts
@@ -1,8 +1,8 @@
-import { describe, expect, test } from 'vitest';
-import { retrieveNormalizedAst, withShell } from '../_helper/shell';
+import { describe } from 'vitest';
 import { RDataType, TypeInferencer } from '../../../src/typing/type-inferencer';
+import { assertInferredType } from '../_helper/typing/assert-inferred-type';
 
-describe.sequential('Infer types for currently supported R expressions', withShell(shell => {
+describe('Infer types for currently supported R expressions', () => {
 	const inferencer = new TypeInferencer();
 	
 	describe.each([
@@ -11,25 +11,11 @@ describe.sequential('Infer types for currently supported R expressions', withShe
 		{ description: 'complex number constant', input: '42i',             expectedType: RDataType.Complex },
 		{ description: 'string constant',         input: '"Hello, world!"', expectedType: RDataType.String },
 		{ description: 'empty expression list',   input: '{}',              expectedType: RDataType.Null },
-	])('Infer $expectedType for $description', ({ input, expectedType }) => {
-		test(`Infer ${expectedType} for ${input}`, async() => {
-			const ast = await retrieveNormalizedAst(shell, input).then(promise => promise.ast);
-			const inferredType = inferencer.fold(ast);
-			expect(inferredType).toBe(expectedType);
-		});
-	});
+	])('Infer $expectedType for $description', ({ input, expectedType }) => assertInferredType(input, expectedType, inferencer));
 
 	describe('Infer no type information for currently unsupported R expressions', () => {
-		test('Infer no type information for binary operations', async() => {
-			const ast = await retrieveNormalizedAst(shell, '1 + 2').then(promise => promise.ast);
-			const inferredType = inferencer.fold(ast);
-			expect(inferredType).toBe(undefined);
-		});
-
-		test('Infer no type information for function calls', async() => {
-			const ast = await retrieveNormalizedAst(shell, 'print("foo")').then(promise => promise.ast);
-			const inferredType = inferencer.fold(ast);
-			expect(inferredType).toBe(undefined);
-		});
+		assertInferredType('1 + 2', undefined, inferencer);
+		assertInferredType('x <- 42', undefined, inferencer);
+		assertInferredType('print("Hello, world!")', undefined, inferencer);
 	});
-}));
\ No newline at end of file
+});
\ No newline at end of file

From bb514bfe5faacd016e27a1acd7467f718a75d913 Mon Sep 17 00:00:00 2001
From: Lukas Rohde <lukas.rohde@silupe.de>
Date: Sat, 3 May 2025 12:29:34 +0200
Subject: [PATCH 009/153] refactor: refactor the type representation of R data
 types

---
 src/typing/type-inferencer.ts                 |  41 +++----
 src/typing/types.ts                           | 105 ++++++++++++++++++
 .../_helper/typing/assert-inferred-type.ts    |   9 +-
 .../typing/constant-type-inference.test.ts    |  20 ++--
 4 files changed, 138 insertions(+), 37 deletions(-)
 create mode 100644 src/typing/types.ts

diff --git a/src/typing/type-inferencer.ts b/src/typing/type-inferencer.ts
index 9955828ea4b..e832afc41c2 100644
--- a/src/typing/type-inferencer.ts
+++ b/src/typing/type-inferencer.ts
@@ -3,46 +3,39 @@ import type { RExpressionList } from '../r-bridge/lang-4.x/ast/model/nodes/r-exp
 import type { RLogical } from '../r-bridge/lang-4.x/ast/model/nodes/r-logical';
 import type { RNumber } from '../r-bridge/lang-4.x/ast/model/nodes/r-number';
 import type { RString } from '../r-bridge/lang-4.x/ast/model/nodes/r-string';
+import { type RDataType, RDataTypeTag } from './types';
 
-export enum RDataType {
-    Logical = 'LogicalType',
-    Numeric = 'NumericType',
-	Complex = 'ComplexType',
-    String  = 'StringType',
-	Null    = 'NullType',
-}
-
-export type TypingInfo = RDataType
-					   | undefined; // Represents missing type information
-
-export class TypeInferencer<Info> extends DefaultNormalizedAstFold<TypingInfo, Info> {
+export class TypeInferencer<Info> extends DefaultNormalizedAstFold<RDataType, Info> {
 	constructor() {
-		super(undefined);
+		super({ tag: RDataTypeTag.Any });
 	}
 
-	protected override concat(_a: TypingInfo, _b: TypingInfo): TypingInfo {
+	protected override concat(_a: RDataType, _b: RDataType): RDataType {
 		// Do not combine typing information for now
-		return undefined;
+		return { tag: RDataTypeTag.Any };
 	}
 
-	override foldRLogical(_node: RLogical<Info>): TypingInfo {
-		return RDataType.Logical;
+	override foldRLogical(_node: RLogical<Info>): RDataType {
+		return { tag: RDataTypeTag.Logical };
 	}
 
-	override foldRNumber(node: RNumber<Info>): TypingInfo {
+	override foldRNumber(node: RNumber<Info>): RDataType {
 		if(node.content.complexNumber) {
-			return RDataType.Complex;
+			return { tag: RDataTypeTag.Complex };
+		}
+		if(Number.isInteger(node.content.num)) {
+			return { tag: RDataTypeTag.Integer };
 		}
-		return RDataType.Numeric;
+		return { tag: RDataTypeTag.Double };
 	}
 
-	override foldRString(_node: RString<Info>): TypingInfo {
-		return RDataType.String;
+	override foldRString(_node: RString<Info>): RDataType {
+		return { tag: RDataTypeTag.String };
 	}
 
-	override foldRExpressionList(exprList: RExpressionList<Info>): TypingInfo {
+	override foldRExpressionList(exprList: RExpressionList<Info>): RDataType {
 		if(exprList.children.length === 0) {
-			return RDataType.Null;
+			return { tag: RDataTypeTag.Null };
 		} else {
 			// Do not handle early returns for now
 			return this.fold(exprList.children[exprList.children.length - 1]);
diff --git a/src/typing/types.ts b/src/typing/types.ts
new file mode 100644
index 00000000000..14dcf9a2abd
--- /dev/null
+++ b/src/typing/types.ts
@@ -0,0 +1,105 @@
+/**
+ * This enum lists a tag for each of the possible R data types inferred by the
+ * type inferencer. It is mainly used to identify subtypes of {@link RDataType}.
+ */
+export enum RDataTypeTag {
+    /** {@link RAnyType} */
+    Any = 'AnyType',
+    /** {@link RLogicalType} */
+    Logical = 'RLogicalType',
+    /** {@link RIntegerType} */
+    Integer = 'RIntegerType',
+    /** {@link RDoubleType} */
+    Double = 'RDoubleType',
+    /** {@link RComplexType} */
+	Complex = 'RComplexType',
+    /** {@link RStringType} */
+    String = 'RStringType',
+    /** {@link RRawType} */
+    Raw = 'RRawType',
+    /** {@link RNullType} */
+	Null = 'RNullType',
+    /** {@link RFunctionType} */
+    Function = 'RFunctionType',
+    /** {@link RListType} */
+    List = 'RListType',
+    /** {@link REnvironmentType} */
+    Environment = 'REnvironmentType',
+    /** {@link RSpecialType} */
+    Special = 'RSpecialType',
+    /** {@link RBuiltinType} */
+    Builtin = 'RBuiltinType',
+}
+
+export interface RAnyType {
+    readonly tag: RDataTypeTag.Any;
+}
+
+export interface RLogicalType {
+    readonly tag: RDataTypeTag.Logical;
+}
+
+export interface RIntegerType {
+    readonly tag: RDataTypeTag.Integer;
+}
+
+export interface RDoubleType {
+    readonly tag: RDataTypeTag.Double;
+}
+
+export interface RComplexType {
+    readonly tag: RDataTypeTag.Complex;
+}
+
+export interface RStringType {
+    readonly tag: RDataTypeTag.String;
+}
+
+export interface RRawType {
+    readonly tag: RDataTypeTag.Raw;
+}
+
+export interface RNullType {
+    readonly tag: RDataTypeTag.Null;
+}
+
+export interface RFunctionType {
+    readonly tag: RDataTypeTag.Function;
+}
+
+export interface RListType {
+    readonly tag: RDataTypeTag.List;
+}
+
+export interface REnvironmentType {
+    readonly tag: RDataTypeTag.Environment;
+}
+
+export interface RSpecialType {
+    readonly tag: RDataTypeTag.Special;
+}
+
+export interface RBuiltinType {
+    readonly tag: RDataTypeTag.Builtin;
+}
+
+/**
+ * The `RDataType` type is the union of all possible types that can be inferred
+ * by the type inferencer for R objects.
+ * It should be used whenever you either not care what kind of
+ * type you are dealing with or if you want to handle all possible types.
+ */
+export type RDataType
+    = RAnyType
+    | RLogicalType
+    | RIntegerType
+    | RDoubleType
+    | RComplexType
+    | RStringType
+    | RRawType
+    | RNullType
+    | RFunctionType
+    | RListType
+    | REnvironmentType
+    | RSpecialType
+    | RBuiltinType
\ No newline at end of file
diff --git a/test/functionality/_helper/typing/assert-inferred-type.ts b/test/functionality/_helper/typing/assert-inferred-type.ts
index 8dfbc8ee0c6..06e24dae443 100644
--- a/test/functionality/_helper/typing/assert-inferred-type.ts
+++ b/test/functionality/_helper/typing/assert-inferred-type.ts
@@ -1,20 +1,21 @@
 import { expect, test } from 'vitest';
 import { TreeSitterExecutor } from '../../../../src/r-bridge/lang-4.x/tree-sitter/tree-sitter-executor';
-import type { TypeInferencer, TypingInfo } from '../../../../src/typing/type-inferencer';
+import type { TypeInferencer } from '../../../../src/typing/type-inferencer';
 import { createNormalizePipeline } from '../../../../src/core/steps/pipeline/default-pipelines';
 import { requestFromInput } from '../../../../src/r-bridge/retriever';
+import type { RDataType } from '../../../../src/typing/types';
 
 export function assertInferredType(
 	input: string,
-	expectedType: TypingInfo,
+	expectedType: RDataType,
 	inferencer: TypeInferencer<unknown>,
 ): void {
-	test(`Infer ${expectedType} for ${input}`, async() => {
+	test(`Infer ${expectedType.tag} for ${input}`, async() => {
 		const executor = new TreeSitterExecutor();
 		const ast = await createNormalizePipeline(executor, { request: requestFromInput(input) })
 			.allRemainingSteps()
 			.then(promise => promise.normalize.ast);
 		const inferredType = inferencer.fold(ast);
-		expect(inferredType).toBe(expectedType);
+		expect(inferredType).toEqual(expectedType);
 	});
 }
\ No newline at end of file
diff --git a/test/functionality/typing/constant-type-inference.test.ts b/test/functionality/typing/constant-type-inference.test.ts
index 8db5b645673..cc3e126c2a4 100644
--- a/test/functionality/typing/constant-type-inference.test.ts
+++ b/test/functionality/typing/constant-type-inference.test.ts
@@ -1,21 +1,23 @@
 import { describe } from 'vitest';
-import { RDataType, TypeInferencer } from '../../../src/typing/type-inferencer';
+import { TypeInferencer } from '../../../src/typing/type-inferencer';
+import { RDataTypeTag } from '../../../src/typing/types';
 import { assertInferredType } from '../_helper/typing/assert-inferred-type';
 
 describe('Infer types for currently supported R expressions', () => {
 	const inferencer = new TypeInferencer();
 	
 	describe.each([
-		{ description: 'logical constant',        input: 'TRUE',            expectedType: RDataType.Logical },
-		{ description: 'numeric constant',        input: '42',              expectedType: RDataType.Numeric },
-		{ description: 'complex number constant', input: '42i',             expectedType: RDataType.Complex },
-		{ description: 'string constant',         input: '"Hello, world!"', expectedType: RDataType.String },
-		{ description: 'empty expression list',   input: '{}',              expectedType: RDataType.Null },
+		{ description: 'logical constant',        input: 'TRUE',            expectedType: { tag: RDataTypeTag.Logical } },
+		{ description: 'integer constant',        input: '42',              expectedType: { tag: RDataTypeTag.Integer } },
+		{ description: 'double constant',         input: '42.5',            expectedType: { tag: RDataTypeTag.Double } },
+		{ description: 'complex number constant', input: '42i',             expectedType: { tag: RDataTypeTag.Complex } },
+		{ description: 'string constant',         input: '"Hello, world!"', expectedType: { tag: RDataTypeTag.String } },
+		{ description: 'empty expression list',   input: '{}',              expectedType: { tag: RDataTypeTag.Null } },
 	])('Infer $expectedType for $description', ({ input, expectedType }) => assertInferredType(input, expectedType, inferencer));
 
 	describe('Infer no type information for currently unsupported R expressions', () => {
-		assertInferredType('1 + 2', undefined, inferencer);
-		assertInferredType('x <- 42', undefined, inferencer);
-		assertInferredType('print("Hello, world!")', undefined, inferencer);
+		assertInferredType('1 + 2', { tag: RDataTypeTag.Any }, inferencer);
+		assertInferredType('x <- 42', { tag: RDataTypeTag.Any }, inferencer);
+		assertInferredType('print("Hello, world!")', { tag: RDataTypeTag.Any }, inferencer);
 	});
 });
\ No newline at end of file

From ebcff1e218c8bbfcfb71e91454671cbc69fa7ba1 Mon Sep 17 00:00:00 2001
From: Lukas Rohde <lukas.rohde@silupe.de>
Date: Sat, 10 May 2025 13:03:57 +0200
Subject: [PATCH 010/153] feat(ast): add `mapAstInfo` for transforming metadata
 attached to nodes

---
 src/r-bridge/lang-4.x/ast/model/model.ts      |  2 +-
 .../lang-4.x/ast/model/processing/decorate.ts | 94 ++++++++++++++++++-
 2 files changed, 92 insertions(+), 4 deletions(-)

diff --git a/src/r-bridge/lang-4.x/ast/model/model.ts b/src/r-bridge/lang-4.x/ast/model/model.ts
index 78e08db983a..d9111b893a0 100644
--- a/src/r-bridge/lang-4.x/ast/model/model.ts
+++ b/src/r-bridge/lang-4.x/ast/model/model.ts
@@ -31,7 +31,7 @@ export type NoInfo = object;
  * Will be used to reconstruct the source of the given element in the R-ast.
  * This will not be part of most comparisons as it is mainly of interest to the reconstruction of R code.
  */
-interface Source {
+export interface Source {
 	/**
    * The range is different from the assigned {@link Location} as it refers to the complete source range covered by the given
    * element.
diff --git a/src/r-bridge/lang-4.x/ast/model/processing/decorate.ts b/src/r-bridge/lang-4.x/ast/model/processing/decorate.ts
index 26ac2dbcb28..35f08006f5e 100644
--- a/src/r-bridge/lang-4.x/ast/model/processing/decorate.ts
+++ b/src/r-bridge/lang-4.x/ast/model/processing/decorate.ts
@@ -9,7 +9,7 @@
  * @module
  */
 
-import type { NoInfo, RNode } from '../model';
+import type { NoInfo, RNode, Source } from '../model';
 import { guard } from '../../../../../util/assert';
 import type { SourceRange } from '../../../../../util/range';
 import { BiMap } from '../../../../../util/collections/bimap';
@@ -21,11 +21,12 @@ import type { NodeId } from './node-id';
 import type { RDelimiter } from '../nodes/info/r-delimiter';
 import type { RBinaryOp } from '../nodes/r-binary-op';
 import type { RPipe } from '../nodes/r-pipe';
-import type { RFunctionCall, RNamedFunctionCall, RUnnamedFunctionCall } from '../nodes/r-function-call';
+import type { RFunctionArgument, RFunctionCall, RNamedFunctionCall, RUnnamedFunctionCall } from '../nodes/r-function-call';
 import { EmptyArgument } from '../nodes/r-function-call';
 import type { RExpressionList } from '../nodes/r-expression-list';
 import type { RParameter } from '../nodes/r-parameter';
-import type { RArgument } from '../nodes/r-argument';
+import type { RArgument, RUnnamedArgument } from '../nodes/r-argument';
+import type { RSymbol } from '../nodes/r-symbol';
 
 /**
  * A function that given an RNode returns a (guaranteed) unique id for it
@@ -463,3 +464,90 @@ function createFoldForFunctionArgument<OtherInfo>(info: FoldInfo<OtherInfo>) {
 		return decorated;
 	};
 }
+
+
+export function mapAstInfo<OldInfo, Down, NewInfo>(ast: RNode<OldInfo>, down: Down, infoMapper: (node: RNode<OldInfo>, down: Down) => NewInfo, downUpdater: (node: RNode<OldInfo>, down: Down) => Down): RNode<NewInfo> {
+	const fullInfoMapper = (node: RNode<OldInfo>, down: Down): NewInfo & Source => {
+		const sourceInfo = {
+			...(node.info.fullRange !== undefined ? { fullRange: node.info.fullRange } : {}),
+			...(node.info.fullLexeme !== undefined ? { fullLexeme: node.info.fullLexeme } : {}),
+			...(node.info.additionalTokens !== undefined ? { additionalTokens: node.info.additionalTokens } : {}),
+			...(node.info.file !== undefined ? { file: node.info.file } : {})
+		};
+		const info = infoMapper(node, down);
+		return { ...sourceInfo, ...info };
+	};
+
+	return foldAstStateful(ast, down, {
+		down:        downUpdater,
+		foldNumber:  (num, down) => ({ ...num, info: fullInfoMapper(num, down) } as RNode<NewInfo>),
+		foldString:  (str, down) => ({ ...str, info: fullInfoMapper(str, down) }),
+		foldLogical: (logical, down) => ({ ...logical, info: fullInfoMapper(logical, down) }),
+		foldSymbol:  (symbol, down) => ({ ...symbol, info: fullInfoMapper(symbol, down) }),
+		foldAccess:  (node, name, access, down) => ({
+			...node,
+			info:     fullInfoMapper(node, down),
+			accessed: name,
+			access:   access as [RUnnamedArgument<NewInfo>]
+		}),
+		foldBinaryOp: (op, lhs, rhs, down) => ({ ...op, info: fullInfoMapper(op, down), lhs, rhs }),
+		foldPipe:     (op, lhs, rhs, down) => ({ ...op, info: fullInfoMapper(op, down), lhs, rhs }),
+		foldUnaryOp:  (op, operand, down) => ({ ...op, info: fullInfoMapper(op, down), operand }),
+		loop:         {
+			foldFor: (loop, variable, vector, body, down) => ({
+				...loop,
+				info:     fullInfoMapper(loop, down),
+				variable: variable as RSymbol<NewInfo>,
+				vector,
+				body:     body as RExpressionList<NewInfo>
+			}),
+			foldWhile:  (loop, condition, body, down) => ({ ...loop, info: fullInfoMapper(loop, down), condition, body: body as RExpressionList<NewInfo> }),
+			foldRepeat: (loop, body, down) => ({ ...loop, info: fullInfoMapper(loop, down), body: body as RExpressionList<NewInfo> }),
+			foldNext:   (next, down) => ({ ...next, info: fullInfoMapper(next, down) }),
+			foldBreak:  (next, down) => ({ ...next, info: fullInfoMapper(next, down) }),
+		},
+		other: {
+			foldComment:       (comment, down) => ({ ...comment, info: fullInfoMapper(comment, down) }),
+			foldLineDirective: (comment, down) => ({ ...comment, info: fullInfoMapper(comment, down) }),
+		},
+		foldIfThenElse: (ifThenExpr, condition, then, otherwise, down ) => ({ ...ifThenExpr, info: fullInfoMapper(ifThenExpr, down), condition, then: then as RExpressionList<NewInfo>, otherwise: otherwise as RExpressionList<NewInfo> }),
+		foldExprList:   (exprList, grouping, expressions, down) => ({
+			...exprList,
+			info:     fullInfoMapper(exprList, down),
+			grouping: grouping as [start: RSymbol<NewInfo>, end: RSymbol<NewInfo>] | undefined,
+			children: expressions
+		}),
+		functions: {
+			foldFunctionDefinition: (definition, parameters, body, down) => ({
+				...definition,
+				info:       fullInfoMapper(definition, down),
+				parameters: parameters as RParameter<NewInfo>[],
+				body
+			}),
+			/** folds named and unnamed function calls */
+			foldFunctionCall: (call, functionNameOrExpression, args, down) => {
+				const { functionName: _name, calledFunction: _fun, ...rest } = call;
+				return {
+					...rest,
+					info:      fullInfoMapper(call, down),
+					...(call.named ? { functionName: functionNameOrExpression as RSymbol<NewInfo> } : { calledFunction: functionNameOrExpression }),
+					arguments: args as readonly RFunctionArgument<NewInfo>[]
+				} as RNamedFunctionCall<NewInfo> | RUnnamedFunctionCall<NewInfo>;
+			},
+			/** The `name` is `undefined` if the argument is unnamed, the value, if we have something like `x=,...` */
+			foldArgument: (argument, name, value, down) => ({
+				...argument,
+				info: fullInfoMapper(argument, down),
+				name: name as RSymbol<NewInfo> | undefined,
+				value
+			}),
+			/** The `defaultValue` is `undefined` if the argument was not initialized with a default value */
+			foldParameter: (parameter, name, defaultValue, down) => ({
+				...parameter,
+				info: fullInfoMapper(parameter, down),
+				name: name as RSymbol<NewInfo, string>,
+				defaultValue
+			}),
+		}
+	});
+}
\ No newline at end of file

From e8f02a27304fc65c7d192c890fcd2ff0bad52e45 Mon Sep 17 00:00:00 2001
From: Lukas Rohde <lukas.rohde@silupe.de>
Date: Sat, 10 May 2025 19:01:46 +0200
Subject: [PATCH 011/153] wip(typing): rework type inference to use type
 variables and constraints

---
 src/typing/infer.ts                           |  87 +++++++++++
 src/typing/type-inferencer.ts                 |  44 ------
 src/typing/types.ts                           | 147 +++++++++++++-----
 .../_helper/typing/assert-inferred-type.ts    |  13 +-
 .../typing/constant-type-inference.test.ts    |  23 ++-
 5 files changed, 209 insertions(+), 105 deletions(-)
 create mode 100644 src/typing/infer.ts
 delete mode 100644 src/typing/type-inferencer.ts

diff --git a/src/typing/infer.ts b/src/typing/infer.ts
new file mode 100644
index 00000000000..a345402369e
--- /dev/null
+++ b/src/typing/infer.ts
@@ -0,0 +1,87 @@
+import { extractCFG } from '../control-flow/extract-cfg';
+import { SemanticCfgGuidedVisitor } from '../control-flow/semantic-cfg-guided-visitor';
+import type { DataflowGraphVertexFunctionCall, DataflowGraphVertexValue } from '../dataflow/graph/vertex';
+import type { DataflowInformation } from '../dataflow/info';
+import type { RNode } from '../r-bridge/lang-4.x/ast/model/model';
+import type { RLogical } from '../r-bridge/lang-4.x/ast/model/nodes/r-logical';
+import type { RNumber } from '../r-bridge/lang-4.x/ast/model/nodes/r-number';
+import type { RString } from '../r-bridge/lang-4.x/ast/model/nodes/r-string';
+import type { ParentInformation } from '../r-bridge/lang-4.x/ast/model/processing/decorate';
+import { decorateAst, mapAstInfo } from '../r-bridge/lang-4.x/ast/model/processing/decorate';
+import type { RDataType } from './types';
+import { RTypeVariable , RComplexType, RDoubleType, RIntegerType, RLogicalType, RStringType, resolveType, RNullType } from './types';
+
+export function inferDataTypes<Info>(ast: RNode<Info>, dataFlowInfo: DataflowInformation): RNode<Omit<Info & ParentInformation, keyof UnresolvedTypeInfo> & DataTypeInfo> {
+	const decoratedAst = decorateTypeVariables(ast);
+	const normalizedAst = decorateAst(decoratedAst, {});
+	const controlFlowInfo = extractCFG(normalizedAst);
+	const config = {
+		normalizedAst:        normalizedAst,
+		controlFlow:          controlFlowInfo,
+		dataflow:             dataFlowInfo,
+		defaultVisitingOrder: 'forward' as const,
+	};
+	const visitor = new TypeInferingCfgGuidedVisitor(config);
+	visitor.start();
+
+	const typedAst = resolveTypeVariables(normalizedAst.ast);
+	return typedAst;
+}
+
+type UnresolvedTypeInfo = {
+	typeVariable: RTypeVariable;
+};
+
+export type DataTypeInfo = {
+	inferredType: RDataType;
+}
+
+function decorateTypeVariables<OtherInfo>(ast: RNode<OtherInfo>): RNode<OtherInfo & UnresolvedTypeInfo> {
+	return mapAstInfo(ast, {}, (node, _down) => ({ ...node.info, typeVariable: new RTypeVariable() }), (_node, _down) => ({}));
+}
+
+function resolveTypeVariables<Info extends UnresolvedTypeInfo>(ast: RNode<Info>): RNode<Omit<Info, keyof UnresolvedTypeInfo> & DataTypeInfo> {
+	return mapAstInfo(
+		ast,
+		{},
+		(node, _down) => {
+			const { typeVariable, ...rest } = node.info;
+			return { ...rest, inferredType: resolveType(typeVariable) };
+		},
+		(_node, _down) => ({})
+	);
+}
+
+class TypeInferingCfgGuidedVisitor extends SemanticCfgGuidedVisitor<UnresolvedTypeInfo>{
+	override onLogicalConstant(_vertex: DataflowGraphVertexValue, node: RLogical<UnresolvedTypeInfo>): void {
+		node.info.typeVariable.unify(new RLogicalType());
+	}
+
+	override onNumberConstant(_vertex: DataflowGraphVertexValue, node: RNumber<UnresolvedTypeInfo>): void {
+		if(node.content.complexNumber) {
+			node.info.typeVariable.unify(new RComplexType());
+		} else if(Number.isInteger(node.content.num)) {
+			node.info.typeVariable.unify(new RIntegerType());
+		} else {
+			node.info.typeVariable.unify(new RDoubleType());
+		}
+	}
+
+	override onStringConstant(_vertex: DataflowGraphVertexValue, node: RString<UnresolvedTypeInfo>): void {
+		node.info.typeVariable.unify(new RStringType());
+	}
+
+	override onExpressionList(data: { call: DataflowGraphVertexFunctionCall }) {
+		const node = this.getNormalizedAst(data.call.id);
+		if(node === undefined) {
+			return;
+		}
+		const lastElement = data.call.args.at(-1);
+		const lastElementNode = lastElement !== undefined && lastElement !== '<>' ? this.getNormalizedAst(lastElement.nodeId) : undefined;
+		if(lastElementNode !== undefined) {
+			node.info.typeVariable.unify(lastElementNode.info.typeVariable);
+		} else {
+			node.info.typeVariable.unify(new RNullType());
+		}
+	}
+}
\ No newline at end of file
diff --git a/src/typing/type-inferencer.ts b/src/typing/type-inferencer.ts
deleted file mode 100644
index e832afc41c2..00000000000
--- a/src/typing/type-inferencer.ts
+++ /dev/null
@@ -1,44 +0,0 @@
-import { DefaultNormalizedAstFold } from '../abstract-interpretation/normalized-ast-fold';
-import type { RExpressionList } from '../r-bridge/lang-4.x/ast/model/nodes/r-expression-list';
-import type { RLogical } from '../r-bridge/lang-4.x/ast/model/nodes/r-logical';
-import type { RNumber } from '../r-bridge/lang-4.x/ast/model/nodes/r-number';
-import type { RString } from '../r-bridge/lang-4.x/ast/model/nodes/r-string';
-import { type RDataType, RDataTypeTag } from './types';
-
-export class TypeInferencer<Info> extends DefaultNormalizedAstFold<RDataType, Info> {
-	constructor() {
-		super({ tag: RDataTypeTag.Any });
-	}
-
-	protected override concat(_a: RDataType, _b: RDataType): RDataType {
-		// Do not combine typing information for now
-		return { tag: RDataTypeTag.Any };
-	}
-
-	override foldRLogical(_node: RLogical<Info>): RDataType {
-		return { tag: RDataTypeTag.Logical };
-	}
-
-	override foldRNumber(node: RNumber<Info>): RDataType {
-		if(node.content.complexNumber) {
-			return { tag: RDataTypeTag.Complex };
-		}
-		if(Number.isInteger(node.content.num)) {
-			return { tag: RDataTypeTag.Integer };
-		}
-		return { tag: RDataTypeTag.Double };
-	}
-
-	override foldRString(_node: RString<Info>): RDataType {
-		return { tag: RDataTypeTag.String };
-	}
-
-	override foldRExpressionList(exprList: RExpressionList<Info>): RDataType {
-		if(exprList.children.length === 0) {
-			return { tag: RDataTypeTag.Null };
-		} else {
-			// Do not handle early returns for now
-			return this.fold(exprList.children[exprList.children.length - 1]);
-		}
-	}
-}
\ No newline at end of file
diff --git a/src/typing/types.ts b/src/typing/types.ts
index 14dcf9a2abd..25f797c72e1 100644
--- a/src/typing/types.ts
+++ b/src/typing/types.ts
@@ -1,3 +1,18 @@
+// import type { NodeId } from '../r-bridge/lang-4.x/ast/model/processing/node-id';
+
+// export type TypeId<T extends string | number = string | number> = T & { __brand?: 'type-id' };
+// export function typeIdFromNodeId(nodeId: NodeId): TypeId {
+// 	return nodeId as TypeId;
+// }
+
+// interface UnificationError extends Error {
+// 	__brand: 'unification-error';
+// }
+// function isUnificationError(error: unknown): error is UnificationError {
+// 	return typeof error === 'object' && error !== null && '__brand' in error && error.__brand === 'unification-error';
+// }
+
+
 /**
  * This enum lists a tag for each of the possible R data types inferred by the
  * type inferencer. It is mainly used to identify subtypes of {@link RDataType}.
@@ -29,77 +44,129 @@ export enum RDataTypeTag {
     Special = 'RSpecialType',
     /** {@link RBuiltinType} */
     Builtin = 'RBuiltinType',
+    /** {@link RTypeVariable} */
+    Variable = 'RTypeVariable',
 }
 
-export interface RAnyType {
-    readonly tag: RDataTypeTag.Any;
+export class RAnyType {
+	readonly tag = RDataTypeTag.Any;
 }
 
-export interface RLogicalType {
-    readonly tag: RDataTypeTag.Logical;
+export class RLogicalType {
+	readonly tag = RDataTypeTag.Logical;
 }
 
-export interface RIntegerType {
-    readonly tag: RDataTypeTag.Integer;
+export class RIntegerType {
+	readonly tag = RDataTypeTag.Integer;
 }
 
-export interface RDoubleType {
-    readonly tag: RDataTypeTag.Double;
+export class RDoubleType {
+	readonly tag = RDataTypeTag.Double;
 }
 
-export interface RComplexType {
-    readonly tag: RDataTypeTag.Complex;
+export class RComplexType {
+	readonly tag = RDataTypeTag.Complex;
 }
 
-export interface RStringType {
-    readonly tag: RDataTypeTag.String;
+export class RStringType {
+	readonly tag = RDataTypeTag.String;
 }
 
-export interface RRawType {
-    readonly tag: RDataTypeTag.Raw;
+export class RRawType {
+	readonly tag =  RDataTypeTag.Raw;
 }
 
-export interface RNullType {
-    readonly tag: RDataTypeTag.Null;
+export class RNullType {
+	readonly tag = RDataTypeTag.Null;
 }
 
-export interface RFunctionType {
-    readonly tag: RDataTypeTag.Function;
+export class RFunctionType {
+	readonly tag = RDataTypeTag.Function;
 }
 
-export interface RListType {
-    readonly tag: RDataTypeTag.List;
+export class RListType {
+	readonly tag = RDataTypeTag.List;
 }
 
-export interface REnvironmentType {
-    readonly tag: RDataTypeTag.Environment;
+export class REnvironmentType {
+	readonly tag = RDataTypeTag.Environment;
 }
 
-export interface RSpecialType {
-    readonly tag: RDataTypeTag.Special;
+export class RSpecialType {
+	readonly tag = RDataTypeTag.Special;
+}
+
+export class RBuiltinType {
+	readonly tag = RDataTypeTag.Builtin;
+}
+
+export class RTypeVariable {
+	readonly tag = RDataTypeTag.Variable;
+	private boundType: UnresolvedRDataType | undefined;
+
+	find(): UnresolvedRDataType {
+		if(this.boundType instanceof RTypeVariable) {
+			this.boundType = this.boundType.find();
+		}
+		return this.boundType ?? this;
+	}
+
+	unify(other: UnresolvedRDataType): void {
+		const thisRep = this.find();
+		const otherRep = other instanceof RTypeVariable ? other.find() : other;
+
+		if(thisRep === otherRep) {
+			return;
+		}
+
+		if(thisRep instanceof RTypeVariable) {
+			thisRep.boundType = otherRep;
+		} else if(otherRep instanceof RTypeVariable) {
+			otherRep.boundType = thisRep;
+		} else if(thisRep.tag !== otherRep.tag) {
+			this.boundType = new RAnyType();
+		}
+	}
 }
 
-export interface RBuiltinType {
-    readonly tag: RDataTypeTag.Builtin;
+
+export function resolveType(type: UnresolvedRDataType): RDataType {
+	if(type instanceof RTypeVariable) {
+		const typeRep = type.find();
+		return typeRep !== type ? resolveType(typeRep) : { tag: RDataTypeTag.Any };
+	}
+	return type;
 }
 
+
+export type PrimitiveRDataType
+	= RAnyType
+	| RLogicalType
+	| RIntegerType
+	| RDoubleType
+	| RComplexType
+	| RStringType
+	| RRawType
+	| RNullType
+	| RFunctionType
+	| RListType
+	| REnvironmentType
+	| RSpecialType
+	| RBuiltinType;
+
+export type CompoundRDataType = never;
+
 /**
  * The `RDataType` type is the union of all possible types that can be inferred
  * by the type inferencer for R objects.
  * It should be used whenever you either not care what kind of
  * type you are dealing with or if you want to handle all possible types.
  */
-export type RDataType
-    = RAnyType
-    | RLogicalType
-    | RIntegerType
-    | RDoubleType
-    | RComplexType
-    | RStringType
-    | RRawType
-    | RNullType
-    | RFunctionType
-    | RListType
-    | REnvironmentType
-    | RSpecialType
-    | RBuiltinType
\ No newline at end of file
+export type RDataType = PrimitiveRDataType | CompoundRDataType;
+
+export type UnresolvedCompoundRDataType = never;
+
+export type UnresolvedRDataType
+	= PrimitiveRDataType
+	| UnresolvedCompoundRDataType
+	| RTypeVariable;
\ No newline at end of file
diff --git a/test/functionality/_helper/typing/assert-inferred-type.ts b/test/functionality/_helper/typing/assert-inferred-type.ts
index 06e24dae443..33cb5812a31 100644
--- a/test/functionality/_helper/typing/assert-inferred-type.ts
+++ b/test/functionality/_helper/typing/assert-inferred-type.ts
@@ -1,21 +1,18 @@
 import { expect, test } from 'vitest';
 import { TreeSitterExecutor } from '../../../../src/r-bridge/lang-4.x/tree-sitter/tree-sitter-executor';
-import type { TypeInferencer } from '../../../../src/typing/type-inferencer';
-import { createNormalizePipeline } from '../../../../src/core/steps/pipeline/default-pipelines';
+import { createDataflowPipeline } from '../../../../src/core/steps/pipeline/default-pipelines';
 import { requestFromInput } from '../../../../src/r-bridge/retriever';
 import type { RDataType } from '../../../../src/typing/types';
+import { inferDataTypes } from '../../../../src/typing/infer';
 
 export function assertInferredType(
 	input: string,
 	expectedType: RDataType,
-	inferencer: TypeInferencer<unknown>,
 ): void {
 	test(`Infer ${expectedType.tag} for ${input}`, async() => {
 		const executor = new TreeSitterExecutor();
-		const ast = await createNormalizePipeline(executor, { request: requestFromInput(input) })
-			.allRemainingSteps()
-			.then(promise => promise.normalize.ast);
-		const inferredType = inferencer.fold(ast);
-		expect(inferredType).toEqual(expectedType);
+		const result = await createDataflowPipeline(executor, { request: requestFromInput(input) }).allRemainingSteps();
+		const typedAst = inferDataTypes(result.normalize.ast, result.dataflow);
+		expect(typedAst.inferredType).toEqual(expectedType);
 	});
 }
\ No newline at end of file
diff --git a/test/functionality/typing/constant-type-inference.test.ts b/test/functionality/typing/constant-type-inference.test.ts
index cc3e126c2a4..51c42ddf696 100644
--- a/test/functionality/typing/constant-type-inference.test.ts
+++ b/test/functionality/typing/constant-type-inference.test.ts
@@ -1,23 +1,20 @@
 import { describe } from 'vitest';
-import { TypeInferencer } from '../../../src/typing/type-inferencer';
 import { RDataTypeTag } from '../../../src/typing/types';
 import { assertInferredType } from '../_helper/typing/assert-inferred-type';
 
 describe('Infer types for currently supported R expressions', () => {
-	const inferencer = new TypeInferencer();
-	
 	describe.each([
-		{ description: 'logical constant',        input: 'TRUE',            expectedType: { tag: RDataTypeTag.Logical } },
-		{ description: 'integer constant',        input: '42',              expectedType: { tag: RDataTypeTag.Integer } },
-		{ description: 'double constant',         input: '42.5',            expectedType: { tag: RDataTypeTag.Double } },
-		{ description: 'complex number constant', input: '42i',             expectedType: { tag: RDataTypeTag.Complex } },
-		{ description: 'string constant',         input: '"Hello, world!"', expectedType: { tag: RDataTypeTag.String } },
-		{ description: 'empty expression list',   input: '{}',              expectedType: { tag: RDataTypeTag.Null } },
-	])('Infer $expectedType for $description', ({ input, expectedType }) => assertInferredType(input, expectedType, inferencer));
+		{ description: 'logical constant',        input: 'TRUE',            expectedType: { tag: RDataTypeTag.Logical as const } },
+		{ description: 'integer constant',        input: '42',              expectedType: { tag: RDataTypeTag.Integer as const } },
+		{ description: 'double constant',         input: '42.5',            expectedType: { tag: RDataTypeTag.Double as const } },
+		{ description: 'complex number constant', input: '42i',             expectedType: { tag: RDataTypeTag.Complex as const } },
+		{ description: 'string constant',         input: '"Hello, world!"', expectedType: { tag: RDataTypeTag.String as const } },
+		{ description: 'empty expression list',   input: '{}',              expectedType: { tag: RDataTypeTag.Null as const } },
+	])('Infer $expectedType for $description', ({ input, expectedType }) => assertInferredType(input, expectedType));
 
 	describe('Infer no type information for currently unsupported R expressions', () => {
-		assertInferredType('1 + 2', { tag: RDataTypeTag.Any }, inferencer);
-		assertInferredType('x <- 42', { tag: RDataTypeTag.Any }, inferencer);
-		assertInferredType('print("Hello, world!")', { tag: RDataTypeTag.Any }, inferencer);
+		assertInferredType('1 + 2', { tag: RDataTypeTag.Any });
+		assertInferredType('x <- 42', { tag: RDataTypeTag.Any });
+		assertInferredType('print("Hello, world!")', { tag: RDataTypeTag.Any });
 	});
 });
\ No newline at end of file

From 9b7e136f75a998a151ab08352f78fb5dcf5d7105 Mon Sep 17 00:00:00 2001
From: Lukas Rohde <lukas.rohde@silupe.de>
Date: Sun, 11 May 2025 10:26:28 +0200
Subject: [PATCH 012/153] refactor(typing):  replace '<>' with `EmptyArgument`
 constant

---
 src/typing/infer.ts | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/src/typing/infer.ts b/src/typing/infer.ts
index a345402369e..7b1d6bb0810 100644
--- a/src/typing/infer.ts
+++ b/src/typing/infer.ts
@@ -3,6 +3,7 @@ import { SemanticCfgGuidedVisitor } from '../control-flow/semantic-cfg-guided-vi
 import type { DataflowGraphVertexFunctionCall, DataflowGraphVertexValue } from '../dataflow/graph/vertex';
 import type { DataflowInformation } from '../dataflow/info';
 import type { RNode } from '../r-bridge/lang-4.x/ast/model/model';
+import { EmptyArgument } from '../r-bridge/lang-4.x/ast/model/nodes/r-function-call';
 import type { RLogical } from '../r-bridge/lang-4.x/ast/model/nodes/r-logical';
 import type { RNumber } from '../r-bridge/lang-4.x/ast/model/nodes/r-number';
 import type { RString } from '../r-bridge/lang-4.x/ast/model/nodes/r-string';
@@ -77,7 +78,7 @@ class TypeInferingCfgGuidedVisitor extends SemanticCfgGuidedVisitor<UnresolvedTy
 			return;
 		}
 		const lastElement = data.call.args.at(-1);
-		const lastElementNode = lastElement !== undefined && lastElement !== '<>' ? this.getNormalizedAst(lastElement.nodeId) : undefined;
+		const lastElementNode = lastElement !== undefined && lastElement !== EmptyArgument ? this.getNormalizedAst(lastElement.nodeId) : undefined;
 		if(lastElementNode !== undefined) {
 			node.info.typeVariable.unify(lastElementNode.info.typeVariable);
 		} else {

From d936697289dc6e5a4e27c50928939b0b4c6cfd13 Mon Sep 17 00:00:00 2001
From: Lukas Rohde <lukas.rohde@silupe.de>
Date: Sun, 11 May 2025 10:27:57 +0200
Subject: [PATCH 013/153] refactor(typing): rename string representation of
 `RDataTypeTag.Any`

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

diff --git a/src/typing/types.ts b/src/typing/types.ts
index 25f797c72e1..1fe2654b047 100644
--- a/src/typing/types.ts
+++ b/src/typing/types.ts
@@ -19,7 +19,7 @@
  */
 export enum RDataTypeTag {
     /** {@link RAnyType} */
-    Any = 'AnyType',
+    Any = 'RAnyType',
     /** {@link RLogicalType} */
     Logical = 'RLogicalType',
     /** {@link RIntegerType} */

From ac3b105daa29bcdfbcc64eb2ecd17d86357f32a3 Mon Sep 17 00:00:00 2001
From: Lukas Rohde <lukas.rohde@silupe.de>
Date: Sun, 11 May 2025 10:30:10 +0200
Subject: [PATCH 014/153] feat-fix(typing): fix erroneous property access of
 `inferredType`

---
 test/functionality/_helper/typing/assert-inferred-type.ts | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/test/functionality/_helper/typing/assert-inferred-type.ts b/test/functionality/_helper/typing/assert-inferred-type.ts
index 33cb5812a31..e04b881b7d5 100644
--- a/test/functionality/_helper/typing/assert-inferred-type.ts
+++ b/test/functionality/_helper/typing/assert-inferred-type.ts
@@ -13,6 +13,6 @@ export function assertInferredType(
 		const executor = new TreeSitterExecutor();
 		const result = await createDataflowPipeline(executor, { request: requestFromInput(input) }).allRemainingSteps();
 		const typedAst = inferDataTypes(result.normalize.ast, result.dataflow);
-		expect(typedAst.inferredType).toEqual(expectedType);
+		expect(typedAst.info.inferredType).toEqual(expectedType);
 	});
 }
\ No newline at end of file

From 9710138b9f6b7956001af9e01404fbbe824a5c94 Mon Sep 17 00:00:00 2001
From: Florian Sihler <florian.sihler@uni-ulm.de>
Date: Sun, 11 May 2025 11:27:33 +0200
Subject: [PATCH 015/153] feat-fix(semantic-cfg): explicit onProgram visitor

and in-place ast mapping/type decoration
---
 src/control-flow/dfg-cfg-guided-visitor.ts    |  7 ++
 .../semantic-cfg-guided-visitor.ts            | 14 ++-
 .../lang-4.x/ast/model/processing/decorate.ts | 96 ++++++-------------
 src/typing/infer.ts                           | 40 +++++---
 .../_helper/typing/assert-inferred-type.ts    |  2 +-
 5 files changed, 80 insertions(+), 79 deletions(-)

diff --git a/src/control-flow/dfg-cfg-guided-visitor.ts b/src/control-flow/dfg-cfg-guided-visitor.ts
index 47bd315bfc2..eb33574b4a5 100644
--- a/src/control-flow/dfg-cfg-guided-visitor.ts
+++ b/src/control-flow/dfg-cfg-guided-visitor.ts
@@ -51,6 +51,7 @@ export class DataflowAwareCfgGuidedVisitor<
 	private onExprOrStmtNode(node: CfgStatementVertex | CfgExpressionVertex): void {
 		const dfgVertex = this.getDataflowGraph(node.id);
 		if(!dfgVertex) {
+			this.visitUnknown(node);
 			return;
 		}
 
@@ -76,6 +77,12 @@ export class DataflowAwareCfgGuidedVisitor<
 		}
 	}
 
+	/**
+	 * called for every cfg vertex that has no corresponding dataflow vertex.
+	 */
+	protected visitUnknown(_vertex: CfgStatementVertex | CfgExpressionVertex): void {
+	}
+
 	protected visitValue(_val: DataflowGraphVertexValue): void {
 	}
 
diff --git a/src/control-flow/semantic-cfg-guided-visitor.ts b/src/control-flow/semantic-cfg-guided-visitor.ts
index ef2986fae10..dd851f872d2 100644
--- a/src/control-flow/semantic-cfg-guided-visitor.ts
+++ b/src/control-flow/semantic-cfg-guided-visitor.ts
@@ -1,4 +1,4 @@
-import type { ControlFlowInformation } from './control-flow-graph';
+import type { CfgExpressionVertex, CfgStatementVertex, ControlFlowInformation } from './control-flow-graph';
 
 import type { DataflowInformation } from '../dataflow/info';
 
@@ -28,6 +28,7 @@ import type { FunctionArgument } from '../dataflow/graph/graph';
 import { edgeIncludesType, EdgeType } from '../dataflow/graph/edge';
 import { guard } from '../util/assert';
 import type { NoInfo, RNode } from '../r-bridge/lang-4.x/ast/model/model';
+import type { RExpressionList } from '../r-bridge/lang-4.x/ast/model/nodes/r-expression-list';
 
 
 
@@ -115,6 +116,14 @@ export class SemanticCfgGuidedVisitor<
 		}
 	}
 
+	protected override visitUnknown(vertex: CfgStatementVertex | CfgExpressionVertex) {
+		super.visitUnknown(vertex);
+		const ast = this.getNormalizedAst(vertex.id);
+		if(ast && ast.type === RType.ExpressionList && ast.info.parent === undefined) {
+			this.onProgram(ast);
+		}
+	}
+
 	protected onDispatchFunctionCallOrigins(call: DataflowGraphVertexFunctionCall, origins: readonly string[]) {
 		for(const origin of origins) {
 			this.onDispatchFunctionCallOrigin(call, origin);
@@ -182,6 +191,9 @@ export class SemanticCfgGuidedVisitor<
 		}
 	}
 
+	protected onProgram(_data: RExpressionList<OtherInfo>) {
+	}
+
 
 	/**
 	 * Requests the {@link getOriginInDfg|origins} of the given node.
diff --git a/src/r-bridge/lang-4.x/ast/model/processing/decorate.ts b/src/r-bridge/lang-4.x/ast/model/processing/decorate.ts
index 35f08006f5e..f1f0a29770f 100644
--- a/src/r-bridge/lang-4.x/ast/model/processing/decorate.ts
+++ b/src/r-bridge/lang-4.x/ast/model/processing/decorate.ts
@@ -21,12 +21,11 @@ import type { NodeId } from './node-id';
 import type { RDelimiter } from '../nodes/info/r-delimiter';
 import type { RBinaryOp } from '../nodes/r-binary-op';
 import type { RPipe } from '../nodes/r-pipe';
-import type { RFunctionArgument, RFunctionCall, RNamedFunctionCall, RUnnamedFunctionCall } from '../nodes/r-function-call';
+import type { RFunctionCall, RNamedFunctionCall, RUnnamedFunctionCall } from '../nodes/r-function-call';
 import { EmptyArgument } from '../nodes/r-function-call';
 import type { RExpressionList } from '../nodes/r-expression-list';
 import type { RParameter } from '../nodes/r-parameter';
-import type { RArgument, RUnnamedArgument } from '../nodes/r-argument';
-import type { RSymbol } from '../nodes/r-symbol';
+import type { RArgument } from '../nodes/r-argument';
 
 /**
  * A function that given an RNode returns a (guaranteed) unique id for it
@@ -478,76 +477,43 @@ export function mapAstInfo<OldInfo, Down, NewInfo>(ast: RNode<OldInfo>, down: Do
 		return { ...sourceInfo, ...info };
 	};
 
+	function updateInfo(n: RNode<OldInfo>, down: Down): RNode<NewInfo> {
+		(n.info as NewInfo) = fullInfoMapper(n, down);
+		return n as unknown as RNode<NewInfo>;
+	}
+
 	return foldAstStateful(ast, down, {
-		down:        downUpdater,
-		foldNumber:  (num, down) => ({ ...num, info: fullInfoMapper(num, down) } as RNode<NewInfo>),
-		foldString:  (str, down) => ({ ...str, info: fullInfoMapper(str, down) }),
-		foldLogical: (logical, down) => ({ ...logical, info: fullInfoMapper(logical, down) }),
-		foldSymbol:  (symbol, down) => ({ ...symbol, info: fullInfoMapper(symbol, down) }),
-		foldAccess:  (node, name, access, down) => ({
-			...node,
-			info:     fullInfoMapper(node, down),
-			accessed: name,
-			access:   access as [RUnnamedArgument<NewInfo>]
-		}),
-		foldBinaryOp: (op, lhs, rhs, down) => ({ ...op, info: fullInfoMapper(op, down), lhs, rhs }),
-		foldPipe:     (op, lhs, rhs, down) => ({ ...op, info: fullInfoMapper(op, down), lhs, rhs }),
-		foldUnaryOp:  (op, operand, down) => ({ ...op, info: fullInfoMapper(op, down), operand }),
+		down:         downUpdater,
+		foldNumber:   updateInfo,
+		foldString:   updateInfo,
+		foldLogical:  updateInfo,
+		foldSymbol:   updateInfo,
+		foldAccess:   (node, _name, _access, down) => updateInfo(node, down),
+		foldBinaryOp: (op, _lhs, _rhs, down) => updateInfo(op, down),
+		foldPipe:     (op, _lhs, _rhs, down) => updateInfo(op, down),
+		foldUnaryOp:  (op, _operand, down) => updateInfo(op, down),
 		loop:         {
-			foldFor: (loop, variable, vector, body, down) => ({
-				...loop,
-				info:     fullInfoMapper(loop, down),
-				variable: variable as RSymbol<NewInfo>,
-				vector,
-				body:     body as RExpressionList<NewInfo>
-			}),
-			foldWhile:  (loop, condition, body, down) => ({ ...loop, info: fullInfoMapper(loop, down), condition, body: body as RExpressionList<NewInfo> }),
-			foldRepeat: (loop, body, down) => ({ ...loop, info: fullInfoMapper(loop, down), body: body as RExpressionList<NewInfo> }),
-			foldNext:   (next, down) => ({ ...next, info: fullInfoMapper(next, down) }),
-			foldBreak:  (next, down) => ({ ...next, info: fullInfoMapper(next, down) }),
+			foldFor:    (loop, _variable, _vector, _body, down) => updateInfo(loop, down),
+			foldWhile:  (loop, _condition, _body, down) => updateInfo(loop, down),
+			foldRepeat: (loop, _body, down) => updateInfo(loop, down),
+			foldNext:   (next, down) => updateInfo(next, down),
+			foldBreak:  (next, down) => updateInfo(next, down),
 		},
 		other: {
-			foldComment:       (comment, down) => ({ ...comment, info: fullInfoMapper(comment, down) }),
-			foldLineDirective: (comment, down) => ({ ...comment, info: fullInfoMapper(comment, down) }),
+			foldComment:       (comment, down) => updateInfo(comment, down),
+			foldLineDirective: (comment, down) => updateInfo(comment, down),
 		},
-		foldIfThenElse: (ifThenExpr, condition, then, otherwise, down ) => ({ ...ifThenExpr, info: fullInfoMapper(ifThenExpr, down), condition, then: then as RExpressionList<NewInfo>, otherwise: otherwise as RExpressionList<NewInfo> }),
-		foldExprList:   (exprList, grouping, expressions, down) => ({
-			...exprList,
-			info:     fullInfoMapper(exprList, down),
-			grouping: grouping as [start: RSymbol<NewInfo>, end: RSymbol<NewInfo>] | undefined,
-			children: expressions
-		}),
-		functions: {
-			foldFunctionDefinition: (definition, parameters, body, down) => ({
-				...definition,
-				info:       fullInfoMapper(definition, down),
-				parameters: parameters as RParameter<NewInfo>[],
-				body
-			}),
+		foldIfThenElse: (ifThenExpr, _condition, _then, _otherwise, down ) =>
+			updateInfo(ifThenExpr, down),
+		foldExprList: (exprList, _grouping, _expressions, down) => updateInfo(exprList, down),
+		functions:    {
+			foldFunctionDefinition: (definition, _parameters, _body, down) => updateInfo(definition, down),
 			/** folds named and unnamed function calls */
-			foldFunctionCall: (call, functionNameOrExpression, args, down) => {
-				const { functionName: _name, calledFunction: _fun, ...rest } = call;
-				return {
-					...rest,
-					info:      fullInfoMapper(call, down),
-					...(call.named ? { functionName: functionNameOrExpression as RSymbol<NewInfo> } : { calledFunction: functionNameOrExpression }),
-					arguments: args as readonly RFunctionArgument<NewInfo>[]
-				} as RNamedFunctionCall<NewInfo> | RUnnamedFunctionCall<NewInfo>;
-			},
+			foldFunctionCall:       (call, _functionNameOrExpression, _args, down) => updateInfo(call, down),
 			/** The `name` is `undefined` if the argument is unnamed, the value, if we have something like `x=,...` */
-			foldArgument: (argument, name, value, down) => ({
-				...argument,
-				info: fullInfoMapper(argument, down),
-				name: name as RSymbol<NewInfo> | undefined,
-				value
-			}),
+			foldArgument:           (argument, _name, _value, down) => updateInfo(argument, down),
 			/** The `defaultValue` is `undefined` if the argument was not initialized with a default value */
-			foldParameter: (parameter, name, defaultValue, down) => ({
-				...parameter,
-				info: fullInfoMapper(parameter, down),
-				name: name as RSymbol<NewInfo, string>,
-				defaultValue
-			}),
+			foldParameter:          (parameter, _name, _defaultValue, down) => updateInfo(parameter, down)
 		}
 	});
 }
\ No newline at end of file
diff --git a/src/typing/infer.ts b/src/typing/infer.ts
index 7b1d6bb0810..23c9eadde17 100644
--- a/src/typing/infer.ts
+++ b/src/typing/infer.ts
@@ -7,17 +7,18 @@ import { EmptyArgument } from '../r-bridge/lang-4.x/ast/model/nodes/r-function-c
 import type { RLogical } from '../r-bridge/lang-4.x/ast/model/nodes/r-logical';
 import type { RNumber } from '../r-bridge/lang-4.x/ast/model/nodes/r-number';
 import type { RString } from '../r-bridge/lang-4.x/ast/model/nodes/r-string';
-import type { ParentInformation } from '../r-bridge/lang-4.x/ast/model/processing/decorate';
-import { decorateAst, mapAstInfo } from '../r-bridge/lang-4.x/ast/model/processing/decorate';
+import type { NormalizedAst, ParentInformation } from '../r-bridge/lang-4.x/ast/model/processing/decorate';
+import { mapAstInfo } from '../r-bridge/lang-4.x/ast/model/processing/decorate';
 import type { RDataType } from './types';
 import { RTypeVariable , RComplexType, RDoubleType, RIntegerType, RLogicalType, RStringType, resolveType, RNullType } from './types';
+import type { RExpressionList } from '../r-bridge/lang-4.x/ast/model/nodes/r-expression-list';
+import { RType } from '../r-bridge/lang-4.x/ast/model/type';
 
-export function inferDataTypes<Info>(ast: RNode<Info>, dataFlowInfo: DataflowInformation): RNode<Omit<Info & ParentInformation, keyof UnresolvedTypeInfo> & DataTypeInfo> {
-	const decoratedAst = decorateTypeVariables(ast);
-	const normalizedAst = decorateAst(decoratedAst, {});
-	const controlFlowInfo = extractCFG(normalizedAst);
+export function inferDataTypes<Info>(normalizedAst: NormalizedAst<Info>, dataFlowInfo: DataflowInformation): RNode<Omit<Info & ParentInformation, keyof UnresolvedTypeInfo> & DataTypeInfo> {
+	const withTypesAst = decorateTypeVariables(normalizedAst);
+	const controlFlowInfo = extractCFG(withTypesAst);
 	const config = {
-		normalizedAst:        normalizedAst,
+		normalizedAst:        withTypesAst,
 		controlFlow:          controlFlowInfo,
 		dataflow:             dataFlowInfo,
 		defaultVisitingOrder: 'forward' as const,
@@ -25,8 +26,7 @@ export function inferDataTypes<Info>(ast: RNode<Info>, dataFlowInfo: DataflowInf
 	const visitor = new TypeInferingCfgGuidedVisitor(config);
 	visitor.start();
 
-	const typedAst = resolveTypeVariables(normalizedAst.ast);
-	return typedAst;
+	return resolveTypeVariables(withTypesAst.ast);
 }
 
 type UnresolvedTypeInfo = {
@@ -37,8 +37,15 @@ export type DataTypeInfo = {
 	inferredType: RDataType;
 }
 
-function decorateTypeVariables<OtherInfo>(ast: RNode<OtherInfo>): RNode<OtherInfo & UnresolvedTypeInfo> {
-	return mapAstInfo(ast, {}, (node, _down) => ({ ...node.info, typeVariable: new RTypeVariable() }), (_node, _down) => ({}));
+function decorateTypeVariables<OtherInfo>(normalizedAst: NormalizedAst<OtherInfo>): NormalizedAst<OtherInfo & UnresolvedTypeInfo> {
+	mapAstInfo(normalizedAst.ast, {},
+		(node, _down) => {
+			(node.info as unknown as UnresolvedTypeInfo).typeVariable = new RTypeVariable();
+			return node.info;
+		},
+		(_node, _down) => ({})
+	);
+	return normalizedAst as NormalizedAst<OtherInfo & UnresolvedTypeInfo>;
 }
 
 function resolveTypeVariables<Info extends UnresolvedTypeInfo>(ast: RNode<Info>): RNode<Omit<Info, keyof UnresolvedTypeInfo> & DataTypeInfo> {
@@ -72,9 +79,18 @@ class TypeInferingCfgGuidedVisitor extends SemanticCfgGuidedVisitor<UnresolvedTy
 		node.info.typeVariable.unify(new RStringType());
 	}
 
+	override onProgram(node: RExpressionList<UnresolvedTypeInfo>) {
+		const lastElement = node.children.at(-1);
+		if(lastElement !== undefined) {
+			node.info.typeVariable.unify(lastElement.info.typeVariable);
+		} else {
+			node.info.typeVariable.unify(new RNullType());
+		}
+	}
+
 	override onExpressionList(data: { call: DataflowGraphVertexFunctionCall }) {
 		const node = this.getNormalizedAst(data.call.id);
-		if(node === undefined) {
+		if(node === undefined || node.type !== RType.ExpressionList) {
 			return;
 		}
 		const lastElement = data.call.args.at(-1);
diff --git a/test/functionality/_helper/typing/assert-inferred-type.ts b/test/functionality/_helper/typing/assert-inferred-type.ts
index e04b881b7d5..268fb64b427 100644
--- a/test/functionality/_helper/typing/assert-inferred-type.ts
+++ b/test/functionality/_helper/typing/assert-inferred-type.ts
@@ -12,7 +12,7 @@ export function assertInferredType(
 	test(`Infer ${expectedType.tag} for ${input}`, async() => {
 		const executor = new TreeSitterExecutor();
 		const result = await createDataflowPipeline(executor, { request: requestFromInput(input) }).allRemainingSteps();
-		const typedAst = inferDataTypes(result.normalize.ast, result.dataflow);
+		const typedAst = inferDataTypes(result.normalize, result.dataflow);
 		expect(typedAst.info.inferredType).toEqual(expectedType);
 	});
 }
\ No newline at end of file

From 14913c48df2eedfee50d48c98a779db6d9b98b88 Mon Sep 17 00:00:00 2001
From: Lukas Rohde <lukas.rohde@silupe.de>
Date: Mon, 12 May 2025 12:15:21 +0200
Subject: [PATCH 016/153] refactor(ast): rework `mapAstInfo` to mutate the AST
 nodes in place

---
 .../lang-4.x/ast/model/processing/decorate.ts | 91 ++++++-------------
 1 file changed, 29 insertions(+), 62 deletions(-)

diff --git a/src/r-bridge/lang-4.x/ast/model/processing/decorate.ts b/src/r-bridge/lang-4.x/ast/model/processing/decorate.ts
index 35f08006f5e..dafd57ff737 100644
--- a/src/r-bridge/lang-4.x/ast/model/processing/decorate.ts
+++ b/src/r-bridge/lang-4.x/ast/model/processing/decorate.ts
@@ -478,76 +478,43 @@ export function mapAstInfo<OldInfo, Down, NewInfo>(ast: RNode<OldInfo>, down: Do
 		return { ...sourceInfo, ...info };
 	};
 
+	function updateInfo(n: RNode<OldInfo>, down: Down): RNode<NewInfo> {
+		(n.info as NewInfo) = fullInfoMapper(n, down);
+		return n as unknown as RNode<NewInfo>;
+	}
+
 	return foldAstStateful(ast, down, {
-		down:        downUpdater,
-		foldNumber:  (num, down) => ({ ...num, info: fullInfoMapper(num, down) } as RNode<NewInfo>),
-		foldString:  (str, down) => ({ ...str, info: fullInfoMapper(str, down) }),
-		foldLogical: (logical, down) => ({ ...logical, info: fullInfoMapper(logical, down) }),
-		foldSymbol:  (symbol, down) => ({ ...symbol, info: fullInfoMapper(symbol, down) }),
-		foldAccess:  (node, name, access, down) => ({
-			...node,
-			info:     fullInfoMapper(node, down),
-			accessed: name,
-			access:   access as [RUnnamedArgument<NewInfo>]
-		}),
-		foldBinaryOp: (op, lhs, rhs, down) => ({ ...op, info: fullInfoMapper(op, down), lhs, rhs }),
-		foldPipe:     (op, lhs, rhs, down) => ({ ...op, info: fullInfoMapper(op, down), lhs, rhs }),
-		foldUnaryOp:  (op, operand, down) => ({ ...op, info: fullInfoMapper(op, down), operand }),
+		down:         downUpdater,
+		foldNumber:   updateInfo,
+		foldString:   updateInfo,
+		foldLogical:  updateInfo,
+		foldSymbol:   updateInfo,
+		foldAccess:   (node, _name, _access, down) => updateInfo(node, down),
+		foldBinaryOp: (op, _lhs, _rhs, down) => updateInfo(op, down),
+		foldPipe:     (op, _lhs, _rhs, down) => updateInfo(op, down),
+		foldUnaryOp:  (op, _operand, down) => updateInfo(op, down),
 		loop:         {
-			foldFor: (loop, variable, vector, body, down) => ({
-				...loop,
-				info:     fullInfoMapper(loop, down),
-				variable: variable as RSymbol<NewInfo>,
-				vector,
-				body:     body as RExpressionList<NewInfo>
-			}),
-			foldWhile:  (loop, condition, body, down) => ({ ...loop, info: fullInfoMapper(loop, down), condition, body: body as RExpressionList<NewInfo> }),
-			foldRepeat: (loop, body, down) => ({ ...loop, info: fullInfoMapper(loop, down), body: body as RExpressionList<NewInfo> }),
-			foldNext:   (next, down) => ({ ...next, info: fullInfoMapper(next, down) }),
-			foldBreak:  (next, down) => ({ ...next, info: fullInfoMapper(next, down) }),
+			foldFor:    (loop, _variable, _vector, _body, down) => updateInfo(loop, down),
+			foldWhile:  (loop, _condition, _body, down) => updateInfo(loop, down),
+			foldRepeat: (loop, _body, down) => updateInfo(loop, down),
+			foldNext:   (next, down) => updateInfo(next, down),
+			foldBreak:  (next, down) => updateInfo(next, down),
 		},
 		other: {
-			foldComment:       (comment, down) => ({ ...comment, info: fullInfoMapper(comment, down) }),
-			foldLineDirective: (comment, down) => ({ ...comment, info: fullInfoMapper(comment, down) }),
+			foldComment:       (comment, down) => updateInfo(comment, down),
+			foldLineDirective: (comment, down) => updateInfo(comment, down),
 		},
-		foldIfThenElse: (ifThenExpr, condition, then, otherwise, down ) => ({ ...ifThenExpr, info: fullInfoMapper(ifThenExpr, down), condition, then: then as RExpressionList<NewInfo>, otherwise: otherwise as RExpressionList<NewInfo> }),
-		foldExprList:   (exprList, grouping, expressions, down) => ({
-			...exprList,
-			info:     fullInfoMapper(exprList, down),
-			grouping: grouping as [start: RSymbol<NewInfo>, end: RSymbol<NewInfo>] | undefined,
-			children: expressions
-		}),
-		functions: {
-			foldFunctionDefinition: (definition, parameters, body, down) => ({
-				...definition,
-				info:       fullInfoMapper(definition, down),
-				parameters: parameters as RParameter<NewInfo>[],
-				body
-			}),
+		foldIfThenElse: (ifThenExpr, _condition, _then, _otherwise, down ) =>
+			updateInfo(ifThenExpr, down),
+		foldExprList: (exprList, _grouping, _expressions, down) => updateInfo(exprList, down),
+		functions:    {
+			foldFunctionDefinition: (definition, _parameters, _body, down) => updateInfo(definition, down),
 			/** folds named and unnamed function calls */
-			foldFunctionCall: (call, functionNameOrExpression, args, down) => {
-				const { functionName: _name, calledFunction: _fun, ...rest } = call;
-				return {
-					...rest,
-					info:      fullInfoMapper(call, down),
-					...(call.named ? { functionName: functionNameOrExpression as RSymbol<NewInfo> } : { calledFunction: functionNameOrExpression }),
-					arguments: args as readonly RFunctionArgument<NewInfo>[]
-				} as RNamedFunctionCall<NewInfo> | RUnnamedFunctionCall<NewInfo>;
-			},
+			foldFunctionCall:       (call, _functionNameOrExpression, _args, down) => updateInfo(call, down),
 			/** The `name` is `undefined` if the argument is unnamed, the value, if we have something like `x=,...` */
-			foldArgument: (argument, name, value, down) => ({
-				...argument,
-				info: fullInfoMapper(argument, down),
-				name: name as RSymbol<NewInfo> | undefined,
-				value
-			}),
+			foldArgument:           (argument, _name, _value, down) => updateInfo(argument, down),
 			/** The `defaultValue` is `undefined` if the argument was not initialized with a default value */
-			foldParameter: (parameter, name, defaultValue, down) => ({
-				...parameter,
-				info: fullInfoMapper(parameter, down),
-				name: name as RSymbol<NewInfo, string>,
-				defaultValue
-			}),
+			foldParameter:          (parameter, _name, _defaultValue, down) => updateInfo(parameter, down)
 		}
 	});
 }
\ No newline at end of file

From 5339c1a5ea9aca082f84fc88c034848ba3b97b17 Mon Sep 17 00:00:00 2001
From: Lukas Rohde <lukas.rohde@silupe.de>
Date: Mon, 12 May 2025 12:18:55 +0200
Subject: [PATCH 017/153] refactor(ast): define default for `downUpdater`
 argument of `mapAstInfo`

---
 src/r-bridge/lang-4.x/ast/model/processing/decorate.ts | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/r-bridge/lang-4.x/ast/model/processing/decorate.ts b/src/r-bridge/lang-4.x/ast/model/processing/decorate.ts
index dafd57ff737..14c6f324ce4 100644
--- a/src/r-bridge/lang-4.x/ast/model/processing/decorate.ts
+++ b/src/r-bridge/lang-4.x/ast/model/processing/decorate.ts
@@ -466,7 +466,7 @@ function createFoldForFunctionArgument<OtherInfo>(info: FoldInfo<OtherInfo>) {
 }
 
 
-export function mapAstInfo<OldInfo, Down, NewInfo>(ast: RNode<OldInfo>, down: Down, infoMapper: (node: RNode<OldInfo>, down: Down) => NewInfo, downUpdater: (node: RNode<OldInfo>, down: Down) => Down): RNode<NewInfo> {
+export function mapAstInfo<OldInfo, Down, NewInfo>(ast: RNode<OldInfo>, down: Down, infoMapper: (node: RNode<OldInfo>, down: Down) => NewInfo, downUpdater: (node: RNode<OldInfo>, down: Down) => Down = (_node, down) => down): RNode<NewInfo> {
 	const fullInfoMapper = (node: RNode<OldInfo>, down: Down): NewInfo & Source => {
 		const sourceInfo = {
 			...(node.info.fullRange !== undefined ? { fullRange: node.info.fullRange } : {}),

From d00ccedf75c58e158d26570b8fb09a8da0380008 Mon Sep 17 00:00:00 2001
From: Lukas Rohde <lukas.rohde@silupe.de>
Date: Mon, 12 May 2025 12:41:42 +0200
Subject: [PATCH 018/153] feat(ast): add wrapper of `mapAstInfo` for normalized
 ASTs

---
 .../lang-4.x/ast/model/processing/decorate.ts | 25 +++++++++++++++----
 1 file changed, 20 insertions(+), 5 deletions(-)

diff --git a/src/r-bridge/lang-4.x/ast/model/processing/decorate.ts b/src/r-bridge/lang-4.x/ast/model/processing/decorate.ts
index 14c6f324ce4..b15e5da13c2 100644
--- a/src/r-bridge/lang-4.x/ast/model/processing/decorate.ts
+++ b/src/r-bridge/lang-4.x/ast/model/processing/decorate.ts
@@ -21,12 +21,11 @@ import type { NodeId } from './node-id';
 import type { RDelimiter } from '../nodes/info/r-delimiter';
 import type { RBinaryOp } from '../nodes/r-binary-op';
 import type { RPipe } from '../nodes/r-pipe';
-import type { RFunctionArgument, RFunctionCall, RNamedFunctionCall, RUnnamedFunctionCall } from '../nodes/r-function-call';
+import type { RFunctionCall, RNamedFunctionCall, RUnnamedFunctionCall } from '../nodes/r-function-call';
 import { EmptyArgument } from '../nodes/r-function-call';
 import type { RExpressionList } from '../nodes/r-expression-list';
 import type { RParameter } from '../nodes/r-parameter';
-import type { RArgument, RUnnamedArgument } from '../nodes/r-argument';
-import type { RSymbol } from '../nodes/r-symbol';
+import type { RArgument } from '../nodes/r-argument';
 
 /**
  * A function that given an RNode returns a (guaranteed) unique id for it
@@ -474,8 +473,8 @@ export function mapAstInfo<OldInfo, Down, NewInfo>(ast: RNode<OldInfo>, down: Do
 			...(node.info.additionalTokens !== undefined ? { additionalTokens: node.info.additionalTokens } : {}),
 			...(node.info.file !== undefined ? { file: node.info.file } : {})
 		};
-		const info = infoMapper(node, down);
-		return { ...sourceInfo, ...info };
+		const mappedInfo = infoMapper(node, down);
+		return { ...sourceInfo, ...mappedInfo };
 	};
 
 	function updateInfo(n: RNode<OldInfo>, down: Down): RNode<NewInfo> {
@@ -517,4 +516,20 @@ export function mapAstInfo<OldInfo, Down, NewInfo>(ast: RNode<OldInfo>, down: Do
 			foldParameter:          (parameter, _name, _defaultValue, down) => updateInfo(parameter, down)
 		}
 	});
+}
+
+export function mapNormalizedAstInfo<OldInfo, Down, NewInfo>(normalizedAst: NormalizedAst<OldInfo>, down: Down, infoMapper: (node: RNode<OldInfo & ParentInformation>, down: Down) => NewInfo, downUpdater: (node: RNode<OldInfo>, down: Down) => Down = (_node, down) => down): NormalizedAst<NewInfo> {
+	const parentInfoPreservingMapper = (node: RNode<OldInfo & ParentInformation>, down: Down): NewInfo & ParentInformation => {
+		const parentInfo = {
+			id:      node.info.id,
+			parent:  node.info.parent,
+			role:    node.info.role,
+			nesting: node.info.nesting,
+			index:   node.info.index
+		};
+		const mappedInfo = infoMapper(node, down);
+		return { ...parentInfo, ...mappedInfo };
+	};
+	mapAstInfo(normalizedAst.ast, down, parentInfoPreservingMapper, downUpdater);
+	return normalizedAst as unknown as NormalizedAst<NewInfo>;
 }
\ No newline at end of file

From b1b5963db9b5c29e26cd039d733a089271c768e8 Mon Sep 17 00:00:00 2001
From: Lukas Rohde <lukas.rohde@silupe.de>
Date: Mon, 12 May 2025 13:02:56 +0200
Subject: [PATCH 019/153] refactor(typing): infer types directly on the
 normalized AST

---
 src/typing/infer.ts                           | 41 +++++++------------
 .../_helper/typing/assert-inferred-type.ts    |  2 +-
 2 files changed, 15 insertions(+), 28 deletions(-)

diff --git a/src/typing/infer.ts b/src/typing/infer.ts
index 23c9eadde17..521cd42c506 100644
--- a/src/typing/infer.ts
+++ b/src/typing/infer.ts
@@ -2,23 +2,22 @@ import { extractCFG } from '../control-flow/extract-cfg';
 import { SemanticCfgGuidedVisitor } from '../control-flow/semantic-cfg-guided-visitor';
 import type { DataflowGraphVertexFunctionCall, DataflowGraphVertexValue } from '../dataflow/graph/vertex';
 import type { DataflowInformation } from '../dataflow/info';
-import type { RNode } from '../r-bridge/lang-4.x/ast/model/model';
 import { EmptyArgument } from '../r-bridge/lang-4.x/ast/model/nodes/r-function-call';
 import type { RLogical } from '../r-bridge/lang-4.x/ast/model/nodes/r-logical';
 import type { RNumber } from '../r-bridge/lang-4.x/ast/model/nodes/r-number';
 import type { RString } from '../r-bridge/lang-4.x/ast/model/nodes/r-string';
-import type { NormalizedAst, ParentInformation } from '../r-bridge/lang-4.x/ast/model/processing/decorate';
-import { mapAstInfo } from '../r-bridge/lang-4.x/ast/model/processing/decorate';
+import type { NormalizedAst } from '../r-bridge/lang-4.x/ast/model/processing/decorate';
+import { mapNormalizedAstInfo } from '../r-bridge/lang-4.x/ast/model/processing/decorate';
 import type { RDataType } from './types';
 import { RTypeVariable , RComplexType, RDoubleType, RIntegerType, RLogicalType, RStringType, resolveType, RNullType } from './types';
 import type { RExpressionList } from '../r-bridge/lang-4.x/ast/model/nodes/r-expression-list';
 import { RType } from '../r-bridge/lang-4.x/ast/model/type';
 
-export function inferDataTypes<Info>(normalizedAst: NormalizedAst<Info>, dataFlowInfo: DataflowInformation): RNode<Omit<Info & ParentInformation, keyof UnresolvedTypeInfo> & DataTypeInfo> {
-	const withTypesAst = decorateTypeVariables(normalizedAst);
-	const controlFlowInfo = extractCFG(withTypesAst);
+export function inferDataTypes<Info extends { typeVariable?: undefined }>(ast: NormalizedAst<Info>, dataFlowInfo: DataflowInformation): NormalizedAst<Info & DataTypeInfo> {
+	const astWithTypeVars = decorateTypeVariables(ast);
+	const controlFlowInfo = extractCFG(astWithTypeVars);
 	const config = {
-		normalizedAst:        withTypesAst,
+		normalizedAst:        astWithTypeVars,
 		controlFlow:          controlFlowInfo,
 		dataflow:             dataFlowInfo,
 		defaultVisitingOrder: 'forward' as const,
@@ -26,7 +25,7 @@ export function inferDataTypes<Info>(normalizedAst: NormalizedAst<Info>, dataFlo
 	const visitor = new TypeInferingCfgGuidedVisitor(config);
 	visitor.start();
 
-	return resolveTypeVariables(withTypesAst.ast);
+	return resolveTypeVariables(astWithTypeVars);
 }
 
 type UnresolvedTypeInfo = {
@@ -37,27 +36,15 @@ export type DataTypeInfo = {
 	inferredType: RDataType;
 }
 
-function decorateTypeVariables<OtherInfo>(normalizedAst: NormalizedAst<OtherInfo>): NormalizedAst<OtherInfo & UnresolvedTypeInfo> {
-	mapAstInfo(normalizedAst.ast, {},
-		(node, _down) => {
-			(node.info as unknown as UnresolvedTypeInfo).typeVariable = new RTypeVariable();
-			return node.info;
-		},
-		(_node, _down) => ({})
-	);
-	return normalizedAst as NormalizedAst<OtherInfo & UnresolvedTypeInfo>;
+function decorateTypeVariables<OtherInfo>(ast: NormalizedAst<OtherInfo>): NormalizedAst<OtherInfo & UnresolvedTypeInfo> {
+	return mapNormalizedAstInfo(ast, {}, (node, _down) => ({ ...node.info, typeVariable: new RTypeVariable() }));
 }
 
-function resolveTypeVariables<Info extends UnresolvedTypeInfo>(ast: RNode<Info>): RNode<Omit<Info, keyof UnresolvedTypeInfo> & DataTypeInfo> {
-	return mapAstInfo(
-		ast,
-		{},
-		(node, _down) => {
-			const { typeVariable, ...rest } = node.info;
-			return { ...rest, inferredType: resolveType(typeVariable) };
-		},
-		(_node, _down) => ({})
-	);
+function resolveTypeVariables<Info extends UnresolvedTypeInfo>(ast: NormalizedAst<Info>): NormalizedAst<Omit<Info, keyof UnresolvedTypeInfo> & DataTypeInfo> {
+	return mapNormalizedAstInfo(ast, {}, (node, _down) => {
+		const { typeVariable, ...rest } = node.info;
+		return { ...rest, inferredType: resolveType(typeVariable) };
+	});
 }
 
 class TypeInferingCfgGuidedVisitor extends SemanticCfgGuidedVisitor<UnresolvedTypeInfo>{
diff --git a/test/functionality/_helper/typing/assert-inferred-type.ts b/test/functionality/_helper/typing/assert-inferred-type.ts
index 268fb64b427..c86a3b84db4 100644
--- a/test/functionality/_helper/typing/assert-inferred-type.ts
+++ b/test/functionality/_helper/typing/assert-inferred-type.ts
@@ -13,6 +13,6 @@ export function assertInferredType(
 		const executor = new TreeSitterExecutor();
 		const result = await createDataflowPipeline(executor, { request: requestFromInput(input) }).allRemainingSteps();
 		const typedAst = inferDataTypes(result.normalize, result.dataflow);
-		expect(typedAst.info.inferredType).toEqual(expectedType);
+		expect(typedAst.ast.info.inferredType).toEqual(expectedType);
 	});
 }
\ No newline at end of file

From a9bbff0724503783438405b2e0cc809c67db4dc8 Mon Sep 17 00:00:00 2001
From: Lukas Rohde <lukas.rohde@silupe.de>
Date: Wed, 14 May 2025 18:12:29 +0200
Subject: [PATCH 020/153] test(typing): add test helper for asserting types of
 queried subnodes

---
 .../_helper/typing/assert-inferred-type.ts    | 32 +++++++++++++++----
 .../typing/constant-type-inference.test.ts    |  7 ++--
 2 files changed, 30 insertions(+), 9 deletions(-)

diff --git a/test/functionality/_helper/typing/assert-inferred-type.ts b/test/functionality/_helper/typing/assert-inferred-type.ts
index c86a3b84db4..368808eb3da 100644
--- a/test/functionality/_helper/typing/assert-inferred-type.ts
+++ b/test/functionality/_helper/typing/assert-inferred-type.ts
@@ -1,18 +1,38 @@
-import { expect, test } from 'vitest';
+import { describe, expect, test } from 'vitest';
 import { TreeSitterExecutor } from '../../../../src/r-bridge/lang-4.x/tree-sitter/tree-sitter-executor';
 import { createDataflowPipeline } from '../../../../src/core/steps/pipeline/default-pipelines';
 import { requestFromInput } from '../../../../src/r-bridge/retriever';
 import type { RDataType } from '../../../../src/typing/types';
 import { inferDataTypes } from '../../../../src/typing/infer';
+import type { FlowrSearch } from '../../../../src/search/flowr-search-builder';
+import { runSearch } from '../../../../src/search/flowr-search-executor';
 
-export function assertInferredType(
-	input: string,
-	expectedType: RDataType,
-): void {
+export function assertInferredType(input: string, expectedType: RDataType): void {
 	test(`Infer ${expectedType.tag} for ${input}`, async() => {
 		const executor = new TreeSitterExecutor();
 		const result = await createDataflowPipeline(executor, { request: requestFromInput(input) }).allRemainingSteps();
 		const typedAst = inferDataTypes(result.normalize, result.dataflow);
-		expect(typedAst.ast.info.inferredType).toEqual(expectedType);
+		const rootNode = typedAst.ast;
+		expect(rootNode.info.inferredType).toEqual(expectedType);
+	});
+}
+export function assertInferredTypes(
+	input: string,
+	...expectations: { query: FlowrSearch, expectedType: RDataType }[]
+): void {
+	describe(`Infer types for ${input}`, async() => {
+		const executor = new TreeSitterExecutor();
+		const result = await createDataflowPipeline(executor, { request: requestFromInput(input) }).allRemainingSteps();
+		inferDataTypes(result.normalize, result.dataflow);
+
+		describe.each(expectations)('Infer $expectedType.tag for query $query', ({ query, expectedType }) => {
+			const searchResult = runSearch(query, result);
+			expect(searchResult).toHaveLength(1);
+			const node = searchResult[0].node;
+
+			test(`Infer ${expectedType.tag} for ${node.lexeme}`, () => {
+				expect(node.info.inferredType).toEqual(expectedType);
+			});
+		});
 	});
 }
\ No newline at end of file
diff --git a/test/functionality/typing/constant-type-inference.test.ts b/test/functionality/typing/constant-type-inference.test.ts
index 51c42ddf696..a6587519a7c 100644
--- a/test/functionality/typing/constant-type-inference.test.ts
+++ b/test/functionality/typing/constant-type-inference.test.ts
@@ -1,6 +1,7 @@
 import { describe } from 'vitest';
 import { RDataTypeTag } from '../../../src/typing/types';
-import { assertInferredType } from '../_helper/typing/assert-inferred-type';
+import { assertInferredType, assertInferredTypes } from '../_helper/typing/assert-inferred-type';
+import { Q } from '../../../src/search/flowr-search-builder';
 
 describe('Infer types for currently supported R expressions', () => {
 	describe.each([
@@ -13,8 +14,8 @@ describe('Infer types for currently supported R expressions', () => {
 	])('Infer $expectedType for $description', ({ input, expectedType }) => assertInferredType(input, expectedType));
 
 	describe('Infer no type information for currently unsupported R expressions', () => {
-		assertInferredType('1 + 2', { tag: RDataTypeTag.Any });
-		assertInferredType('x <- 42', { tag: RDataTypeTag.Any });
+		assertInferredType('1 + 2',                  { tag: RDataTypeTag.Any });
+		assertInferredTypes('x <- 42',               { query: Q.var('x').build(), expectedType: { tag: RDataTypeTag.Any } });
 		assertInferredType('print("Hello, world!")', { tag: RDataTypeTag.Any });
 	});
 });
\ No newline at end of file

From d65e243cebf6b15f9540fa99799bae7e6db6d173 Mon Sep 17 00:00:00 2001
From: Lukas Rohde <lukas.rohde@silupe.de>
Date: Thu, 15 May 2025 11:42:54 +0200
Subject: [PATCH 021/153] meta(typing): rename test file to better reflect its
 testing domain

---
 ...-inference.test.ts => basic-expression-type-inference.test.ts} | 0
 1 file changed, 0 insertions(+), 0 deletions(-)
 rename test/functionality/typing/{constant-type-inference.test.ts => basic-expression-type-inference.test.ts} (100%)

diff --git a/test/functionality/typing/constant-type-inference.test.ts b/test/functionality/typing/basic-expression-type-inference.test.ts
similarity index 100%
rename from test/functionality/typing/constant-type-inference.test.ts
rename to test/functionality/typing/basic-expression-type-inference.test.ts

From 2427695a856fdd968db46dc3056f341660e5325a Mon Sep 17 00:00:00 2001
From: Lukas Rohde <lukas.rohde@silupe.de>
Date: Thu, 15 May 2025 12:09:37 +0200
Subject: [PATCH 022/153] feat(typing): add support for variables

---
 src/typing/infer.ts                           | 33 ++++++++++++++++++-
 .../basic-expression-type-inference.test.ts   | 16 +++++++--
 2 files changed, 46 insertions(+), 3 deletions(-)

diff --git a/src/typing/infer.ts b/src/typing/infer.ts
index 521cd42c506..1e76f7e047a 100644
--- a/src/typing/infer.ts
+++ b/src/typing/infer.ts
@@ -1,6 +1,6 @@
 import { extractCFG } from '../control-flow/extract-cfg';
 import { SemanticCfgGuidedVisitor } from '../control-flow/semantic-cfg-guided-visitor';
-import type { DataflowGraphVertexFunctionCall, DataflowGraphVertexValue } from '../dataflow/graph/vertex';
+import type { DataflowGraphVertexFunctionCall, DataflowGraphVertexUse, DataflowGraphVertexValue } from '../dataflow/graph/vertex';
 import type { DataflowInformation } from '../dataflow/info';
 import { EmptyArgument } from '../r-bridge/lang-4.x/ast/model/nodes/r-function-call';
 import type { RLogical } from '../r-bridge/lang-4.x/ast/model/nodes/r-logical';
@@ -12,6 +12,9 @@ import type { RDataType } from './types';
 import { RTypeVariable , RComplexType, RDoubleType, RIntegerType, RLogicalType, RStringType, resolveType, RNullType } from './types';
 import type { RExpressionList } from '../r-bridge/lang-4.x/ast/model/nodes/r-expression-list';
 import { RType } from '../r-bridge/lang-4.x/ast/model/type';
+import { guard } from '../util/assert';
+import { OriginType } from '../dataflow/origin/dfg-get-origin';
+import type { NodeId } from '../r-bridge/lang-4.x/ast/model/processing/node-id';
 
 export function inferDataTypes<Info extends { typeVariable?: undefined }>(ast: NormalizedAst<Info>, dataFlowInfo: DataflowInformation): NormalizedAst<Info & DataTypeInfo> {
 	const astWithTypeVars = decorateTypeVariables(ast);
@@ -66,6 +69,34 @@ class TypeInferingCfgGuidedVisitor extends SemanticCfgGuidedVisitor<UnresolvedTy
 		node.info.typeVariable.unify(new RStringType());
 	}
 
+	override onVariableUse(vertex: DataflowGraphVertexUse): void {
+		const node = this.getNormalizedAst(vertex.id);
+		guard(node !== undefined && node.type === RType.Symbol, 'Expected Symbol node');
+		const origins = this.getOrigins(vertex.id) ?? [];
+		const readOrigins = origins.filter((origin) => origin.type === OriginType.ReadVariableOrigin);
+		if(readOrigins.length === 0) {
+			node.info.typeVariable.unify(new RNullType());
+			return;
+		}
+		for(const readOrigin of readOrigins) {
+			const readNode = this.getNormalizedAst(readOrigin.id);
+			guard(readNode !== undefined, 'Expected read node');
+			node.info.typeVariable.unify(readNode.info.typeVariable);
+		}
+	}
+
+	override onAssignmentCall(data: { call: DataflowGraphVertexFunctionCall; target?: NodeId; source?: NodeId; }): void {
+		if(data.target === undefined || data.source === undefined) {
+			return;
+		}
+		const variableNode = this.getNormalizedAst(data.target);
+		const valueNode = this.getNormalizedAst(data.source);
+		const assignmentNode = this.getNormalizedAst(data.call.id);
+		guard(variableNode !== undefined && valueNode !== undefined && assignmentNode !== undefined);
+		variableNode.info.typeVariable.unify(valueNode.info.typeVariable);
+		assignmentNode.info.typeVariable.unify(variableNode.info.typeVariable);
+	}
+
 	override onProgram(node: RExpressionList<UnresolvedTypeInfo>) {
 		const lastElement = node.children.at(-1);
 		if(lastElement !== undefined) {
diff --git a/test/functionality/typing/basic-expression-type-inference.test.ts b/test/functionality/typing/basic-expression-type-inference.test.ts
index a6587519a7c..e278225a6db 100644
--- a/test/functionality/typing/basic-expression-type-inference.test.ts
+++ b/test/functionality/typing/basic-expression-type-inference.test.ts
@@ -4,18 +4,30 @@ import { assertInferredType, assertInferredTypes } from '../_helper/typing/asser
 import { Q } from '../../../src/search/flowr-search-builder';
 
 describe('Infer types for currently supported R expressions', () => {
+	// Test type inference for constants
 	describe.each([
 		{ description: 'logical constant',        input: 'TRUE',            expectedType: { tag: RDataTypeTag.Logical as const } },
 		{ description: 'integer constant',        input: '42',              expectedType: { tag: RDataTypeTag.Integer as const } },
 		{ description: 'double constant',         input: '42.5',            expectedType: { tag: RDataTypeTag.Double as const } },
 		{ description: 'complex number constant', input: '42i',             expectedType: { tag: RDataTypeTag.Complex as const } },
 		{ description: 'string constant',         input: '"Hello, world!"', expectedType: { tag: RDataTypeTag.String as const } },
-		{ description: 'empty expression list',   input: '{}',              expectedType: { tag: RDataTypeTag.Null as const } },
+		{ description: 'empty expression list',   input: '{}',              expectedType: { tag: RDataTypeTag.Null as const } }
 	])('Infer $expectedType for $description', ({ input, expectedType }) => assertInferredType(input, expectedType));
 
+	// Test type inference for variables
+	describe('Infer types for variables', () => {
+		assertInferredTypes(
+			'x <- 42; x',
+			{ query: Q.var('x').first().build(), expectedType: { tag: RDataTypeTag.Integer as const } },
+			{ query: Q.criterion('1@<-').build(), expectedType: { tag: RDataTypeTag.Integer as const } },
+			{ query: Q.var('x').last().build(), expectedType: { tag: RDataTypeTag.Integer as const } }
+		);
+		assertInferredType('y', { tag: RDataTypeTag.Null });
+	});
+
+	// Test type inference for currently unsupported R expressions
 	describe('Infer no type information for currently unsupported R expressions', () => {
 		assertInferredType('1 + 2',                  { tag: RDataTypeTag.Any });
-		assertInferredTypes('x <- 42',               { query: Q.var('x').build(), expectedType: { tag: RDataTypeTag.Any } });
 		assertInferredType('print("Hello, world!")', { tag: RDataTypeTag.Any });
 	});
 });
\ No newline at end of file

From 45a417de1df0be1fd1a9ab6c48bc8941d75bd0e5 Mon Sep 17 00:00:00 2001
From: Lukas Rohde <lukas.rohde@silupe.de>
Date: Mon, 19 May 2025 15:25:17 +0200
Subject: [PATCH 023/153] refactor(typing): handle expression lists more
 robustly via return edges

---
 src/typing/infer.ts | 24 ++++++++++++++++--------
 1 file changed, 16 insertions(+), 8 deletions(-)

diff --git a/src/typing/infer.ts b/src/typing/infer.ts
index 1e76f7e047a..0f2851d170a 100644
--- a/src/typing/infer.ts
+++ b/src/typing/infer.ts
@@ -2,7 +2,6 @@ import { extractCFG } from '../control-flow/extract-cfg';
 import { SemanticCfgGuidedVisitor } from '../control-flow/semantic-cfg-guided-visitor';
 import type { DataflowGraphVertexFunctionCall, DataflowGraphVertexUse, DataflowGraphVertexValue } from '../dataflow/graph/vertex';
 import type { DataflowInformation } from '../dataflow/info';
-import { EmptyArgument } from '../r-bridge/lang-4.x/ast/model/nodes/r-function-call';
 import type { RLogical } from '../r-bridge/lang-4.x/ast/model/nodes/r-logical';
 import type { RNumber } from '../r-bridge/lang-4.x/ast/model/nodes/r-number';
 import type { RString } from '../r-bridge/lang-4.x/ast/model/nodes/r-string';
@@ -15,6 +14,7 @@ import { RType } from '../r-bridge/lang-4.x/ast/model/type';
 import { guard } from '../util/assert';
 import { OriginType } from '../dataflow/origin/dfg-get-origin';
 import type { NodeId } from '../r-bridge/lang-4.x/ast/model/processing/node-id';
+import { edgeIncludesType, EdgeType } from '../dataflow/graph/edge';
 
 export function inferDataTypes<Info extends { typeVariable?: undefined }>(ast: NormalizedAst<Info>, dataFlowInfo: DataflowInformation): NormalizedAst<Info & DataTypeInfo> {
 	const astWithTypeVars = decorateTypeVariables(ast);
@@ -108,15 +108,23 @@ class TypeInferingCfgGuidedVisitor extends SemanticCfgGuidedVisitor<UnresolvedTy
 
 	override onExpressionList(data: { call: DataflowGraphVertexFunctionCall }) {
 		const node = this.getNormalizedAst(data.call.id);
-		if(node === undefined || node.type !== RType.ExpressionList) {
+		guard(node !== undefined, 'Expected AST node to be defined');
+
+		const outgoing = this.config.dataflow.graph.outgoingEdges(data.call.id);
+		const returnCandidates = outgoing?.entries()
+			.filter(([_target, edge]) => edgeIncludesType(edge.types, EdgeType.Returns))
+			.map(([target, _edge]) => target)
+			.toArray();
+
+		if(returnCandidates === undefined || returnCandidates.length === 0) {
+			node.info.typeVariable.unify(new RNullType());
 			return;
 		}
-		const lastElement = data.call.args.at(-1);
-		const lastElementNode = lastElement !== undefined && lastElement !== EmptyArgument ? this.getNormalizedAst(lastElement.nodeId) : undefined;
-		if(lastElementNode !== undefined) {
-			node.info.typeVariable.unify(lastElementNode.info.typeVariable);
-		} else {
-			node.info.typeVariable.unify(new RNullType());
+
+		for(const targetId of returnCandidates) {
+			const target = this.getNormalizedAst(targetId);
+			guard(target !== undefined, 'Expected target node to be defined');
+			node.info.typeVariable.unify(target.info.typeVariable);
 		}
 	}
 }
\ No newline at end of file

From 5d631fcd66db7b6d327549ea4938a31f5504c79c Mon Sep 17 00:00:00 2001
From: Lukas Rohde <lukas.rohde@silupe.de>
Date: Mon, 19 May 2025 15:38:13 +0200
Subject: [PATCH 024/153] refactor(typing): handle variables more robustly

---
 src/typing/infer.ts | 22 +++++++++++++---------
 1 file changed, 13 insertions(+), 9 deletions(-)

diff --git a/src/typing/infer.ts b/src/typing/infer.ts
index 0f2851d170a..7fd6f52f93d 100644
--- a/src/typing/infer.ts
+++ b/src/typing/infer.ts
@@ -10,7 +10,6 @@ import { mapNormalizedAstInfo } from '../r-bridge/lang-4.x/ast/model/processing/
 import type { RDataType } from './types';
 import { RTypeVariable , RComplexType, RDoubleType, RIntegerType, RLogicalType, RStringType, resolveType, RNullType } from './types';
 import type { RExpressionList } from '../r-bridge/lang-4.x/ast/model/nodes/r-expression-list';
-import { RType } from '../r-bridge/lang-4.x/ast/model/type';
 import { guard } from '../util/assert';
 import { OriginType } from '../dataflow/origin/dfg-get-origin';
 import type { NodeId } from '../r-bridge/lang-4.x/ast/model/processing/node-id';
@@ -71,28 +70,33 @@ class TypeInferingCfgGuidedVisitor extends SemanticCfgGuidedVisitor<UnresolvedTy
 
 	override onVariableUse(vertex: DataflowGraphVertexUse): void {
 		const node = this.getNormalizedAst(vertex.id);
-		guard(node !== undefined && node.type === RType.Symbol, 'Expected Symbol node');
-		const origins = this.getOrigins(vertex.id) ?? [];
-		const readOrigins = origins.filter((origin) => origin.type === OriginType.ReadVariableOrigin);
-		if(readOrigins.length === 0) {
+		guard(node !== undefined, 'Expected AST node to be defined');
+		
+		const origins = this.getOrigins(vertex.id);
+		const readOrigins = origins?.filter((origin) => origin.type === OriginType.ReadVariableOrigin);
+
+		if(readOrigins === undefined || readOrigins.length === 0) {
 			node.info.typeVariable.unify(new RNullType());
 			return;
 		}
+
 		for(const readOrigin of readOrigins) {
 			const readNode = this.getNormalizedAst(readOrigin.id);
-			guard(readNode !== undefined, 'Expected read node');
+			guard(readNode !== undefined, 'Expected read node to be defined');
 			node.info.typeVariable.unify(readNode.info.typeVariable);
 		}
 	}
 
-	override onAssignmentCall(data: { call: DataflowGraphVertexFunctionCall; target?: NodeId; source?: NodeId; }): void {
+	override onAssignmentCall(data: { call: DataflowGraphVertexFunctionCall, target?: NodeId, source?: NodeId }): void {
 		if(data.target === undefined || data.source === undefined) {
-			return;
+			return; // Malformed assignment
 		}
+		
 		const variableNode = this.getNormalizedAst(data.target);
 		const valueNode = this.getNormalizedAst(data.source);
 		const assignmentNode = this.getNormalizedAst(data.call.id);
-		guard(variableNode !== undefined && valueNode !== undefined && assignmentNode !== undefined);
+		guard(variableNode !== undefined && valueNode !== undefined && assignmentNode !== undefined, 'Expected AST nodes to be defined');
+		
 		variableNode.info.typeVariable.unify(valueNode.info.typeVariable);
 		assignmentNode.info.typeVariable.unify(variableNode.info.typeVariable);
 	}

From 76c5c1bbc83aecd402f6cc034e5a36dbd1e8011e Mon Sep 17 00:00:00 2001
From: Lukas Rohde <lukas.rohde@silupe.de>
Date: Mon, 19 May 2025 15:39:23 +0200
Subject: [PATCH 025/153] feat(typing): add preliminary support for functions

---
 src/typing/infer.ts | 34 ++++++++++++++++++++++++++++++++--
 1 file changed, 32 insertions(+), 2 deletions(-)

diff --git a/src/typing/infer.ts b/src/typing/infer.ts
index 7fd6f52f93d..027fbdaba8a 100644
--- a/src/typing/infer.ts
+++ b/src/typing/infer.ts
@@ -1,6 +1,6 @@
 import { extractCFG } from '../control-flow/extract-cfg';
 import { SemanticCfgGuidedVisitor } from '../control-flow/semantic-cfg-guided-visitor';
-import type { DataflowGraphVertexFunctionCall, DataflowGraphVertexUse, DataflowGraphVertexValue } from '../dataflow/graph/vertex';
+import type { DataflowGraphVertexFunctionCall, DataflowGraphVertexFunctionDefinition, DataflowGraphVertexUse, DataflowGraphVertexValue } from '../dataflow/graph/vertex';
 import type { DataflowInformation } from '../dataflow/info';
 import type { RLogical } from '../r-bridge/lang-4.x/ast/model/nodes/r-logical';
 import type { RNumber } from '../r-bridge/lang-4.x/ast/model/nodes/r-number';
@@ -8,7 +8,7 @@ import type { RString } from '../r-bridge/lang-4.x/ast/model/nodes/r-string';
 import type { NormalizedAst } from '../r-bridge/lang-4.x/ast/model/processing/decorate';
 import { mapNormalizedAstInfo } from '../r-bridge/lang-4.x/ast/model/processing/decorate';
 import type { RDataType } from './types';
-import { RTypeVariable , RComplexType, RDoubleType, RIntegerType, RLogicalType, RStringType, resolveType, RNullType } from './types';
+import { RTypeVariable , RComplexType, RDoubleType, RIntegerType, RLogicalType, RStringType, resolveType, RNullType, RFunctionType } from './types';
 import type { RExpressionList } from '../r-bridge/lang-4.x/ast/model/nodes/r-expression-list';
 import { guard } from '../util/assert';
 import { OriginType } from '../dataflow/origin/dfg-get-origin';
@@ -101,6 +101,36 @@ class TypeInferingCfgGuidedVisitor extends SemanticCfgGuidedVisitor<UnresolvedTy
 		assignmentNode.info.typeVariable.unify(variableNode.info.typeVariable);
 	}
 
+	override onDefaultFunctionCall(data: { call: DataflowGraphVertexFunctionCall }): void {
+		const node = this.getNormalizedAst(data.call.id);
+		guard(node !== undefined, 'Expected AST node to be defined');
+
+		const outgoing = this.config.dataflow.graph.outgoingEdges(data.call.id);
+		const callsTargets = outgoing?.entries()
+			.filter(([_target, edge]) => edgeIncludesType(edge.types, EdgeType.Calls))
+			.map(([target, _edge]) => target)
+			.toArray();
+
+		guard(callsTargets === undefined || callsTargets.length <= 1, 'Expected at most one call edge');
+
+		if(callsTargets === undefined || callsTargets.length === 0) {
+			// TODO: Handle builtin functions
+			return;
+		}
+
+		const target = this.getNormalizedAst(callsTargets[0]);
+		guard(target !== undefined, 'Expected target node to be defined');
+
+		target.info.typeVariable.unify(new RFunctionType());
+	}
+
+	override onFunctionDefinition(vertex: DataflowGraphVertexFunctionDefinition): void {
+		const node = this.getNormalizedAst(vertex.id);
+		guard(node !== undefined, 'Expected AST node to be defined');
+		
+		node.info.typeVariable.unify(new RFunctionType());
+	}
+
 	override onProgram(node: RExpressionList<UnresolvedTypeInfo>) {
 		const lastElement = node.children.at(-1);
 		if(lastElement !== undefined) {

From fa736e2c22cc4fd112a6cee3b6f7f067d57fcc07 Mon Sep 17 00:00:00 2001
From: Lukas Rohde <lukas.rohde@silupe.de>
Date: Mon, 19 May 2025 19:37:15 +0200
Subject: [PATCH 026/153] refactor(typing): handle program expression lists
 more robustly

---
 src/typing/infer.ts | 29 ++++++++++++++++++-----------
 1 file changed, 18 insertions(+), 11 deletions(-)

diff --git a/src/typing/infer.ts b/src/typing/infer.ts
index 027fbdaba8a..a1770d2472c 100644
--- a/src/typing/infer.ts
+++ b/src/typing/infer.ts
@@ -127,16 +127,23 @@ class TypeInferingCfgGuidedVisitor extends SemanticCfgGuidedVisitor<UnresolvedTy
 	override onFunctionDefinition(vertex: DataflowGraphVertexFunctionDefinition): void {
 		const node = this.getNormalizedAst(vertex.id);
 		guard(node !== undefined, 'Expected AST node to be defined');
-		
+
 		node.info.typeVariable.unify(new RFunctionType());
 	}
 
 	override onProgram(node: RExpressionList<UnresolvedTypeInfo>) {
-		const lastElement = node.children.at(-1);
-		if(lastElement !== undefined) {
-			node.info.typeVariable.unify(lastElement.info.typeVariable);
-		} else {
+		const exitPoints = this.config.dataflow.exitPoints;
+		const evalCandidates = exitPoints.map((exitPoint) => exitPoint.nodeId);
+
+		if(evalCandidates.length === 0) {
 			node.info.typeVariable.unify(new RNullType());
+			return;
+		}
+
+		for(const candidateId of evalCandidates) {
+			const candidate = this.getNormalizedAst(candidateId);
+			guard(candidate !== undefined, 'Expected target node to be defined');
+			node.info.typeVariable.unify(candidate.info.typeVariable);
 		}
 	}
 
@@ -145,20 +152,20 @@ class TypeInferingCfgGuidedVisitor extends SemanticCfgGuidedVisitor<UnresolvedTy
 		guard(node !== undefined, 'Expected AST node to be defined');
 
 		const outgoing = this.config.dataflow.graph.outgoingEdges(data.call.id);
-		const returnCandidates = outgoing?.entries()
+		const evalCandidates = outgoing?.entries()
 			.filter(([_target, edge]) => edgeIncludesType(edge.types, EdgeType.Returns))
 			.map(([target, _edge]) => target)
 			.toArray();
 
-		if(returnCandidates === undefined || returnCandidates.length === 0) {
+		if(evalCandidates === undefined || evalCandidates.length === 0) {
 			node.info.typeVariable.unify(new RNullType());
 			return;
 		}
 
-		for(const targetId of returnCandidates) {
-			const target = this.getNormalizedAst(targetId);
-			guard(target !== undefined, 'Expected target node to be defined');
-			node.info.typeVariable.unify(target.info.typeVariable);
+		for(const candidateId of evalCandidates) {
+			const candidate = this.getNormalizedAst(candidateId);
+			guard(candidate !== undefined, 'Expected target node to be defined');
+			node.info.typeVariable.unify(candidate.info.typeVariable);
 		}
 	}
 }
\ No newline at end of file

From 919172d1c6ad13ec03b072c22eab009c1fab11ae Mon Sep 17 00:00:00 2001
From: Lukas Rohde <lukas.rohde@silupe.de>
Date: Wed, 21 May 2025 09:24:58 +0200
Subject: [PATCH 027/153] feat(typing): split role of `Any` into `Any`, `Never`
 and `Error` types

---
 src/typing/types.ts | 42 +++++++++++++++++++++---------------------
 1 file changed, 21 insertions(+), 21 deletions(-)

diff --git a/src/typing/types.ts b/src/typing/types.ts
index 1fe2654b047..8b90a219270 100644
--- a/src/typing/types.ts
+++ b/src/typing/types.ts
@@ -1,18 +1,3 @@
-// import type { NodeId } from '../r-bridge/lang-4.x/ast/model/processing/node-id';
-
-// export type TypeId<T extends string | number = string | number> = T & { __brand?: 'type-id' };
-// export function typeIdFromNodeId(nodeId: NodeId): TypeId {
-// 	return nodeId as TypeId;
-// }
-
-// interface UnificationError extends Error {
-// 	__brand: 'unification-error';
-// }
-// function isUnificationError(error: unknown): error is UnificationError {
-// 	return typeof error === 'object' && error !== null && '__brand' in error && error.__brand === 'unification-error';
-// }
-
-
 /**
  * This enum lists a tag for each of the possible R data types inferred by the
  * type inferencer. It is mainly used to identify subtypes of {@link RDataType}.
@@ -44,8 +29,12 @@ export enum RDataTypeTag {
     Special = 'RSpecialType',
     /** {@link RBuiltinType} */
     Builtin = 'RBuiltinType',
+	/** {@link RNeverType} */
+	Never = 'RNeverType',
     /** {@link RTypeVariable} */
     Variable = 'RTypeVariable',
+	/** {@link RErrorType} */
+	Error = 'RErrorType',
 }
 
 export class RAnyType {
@@ -100,6 +89,10 @@ export class RBuiltinType {
 	readonly tag = RDataTypeTag.Builtin;
 }
 
+export class RNeverType {
+	readonly tag = RDataTypeTag.Never;
+}
+
 export class RTypeVariable {
 	readonly tag = RDataTypeTag.Variable;
 	private boundType: UnresolvedRDataType | undefined;
@@ -124,11 +117,16 @@ export class RTypeVariable {
 		} else if(otherRep instanceof RTypeVariable) {
 			otherRep.boundType = thisRep;
 		} else if(thisRep.tag !== otherRep.tag) {
-			this.boundType = new RAnyType();
+			this.boundType = new RErrorType();
 		}
 	}
 }
 
+export class RErrorType {
+	readonly tag = RDataTypeTag.Error;
+	conflicingTypes: RDataType[] = [];
+}
+
 
 export function resolveType(type: UnresolvedRDataType): RDataType {
 	if(type instanceof RTypeVariable) {
@@ -140,8 +138,7 @@ export function resolveType(type: UnresolvedRDataType): RDataType {
 
 
 export type PrimitiveRDataType
-	= RAnyType
-	| RLogicalType
+	= RLogicalType
 	| RIntegerType
 	| RDoubleType
 	| RComplexType
@@ -162,11 +159,14 @@ export type CompoundRDataType = never;
  * It should be used whenever you either not care what kind of
  * type you are dealing with or if you want to handle all possible types.
  */
-export type RDataType = PrimitiveRDataType | CompoundRDataType;
+export type RDataType = RAnyType | RNeverType | PrimitiveRDataType | CompoundRDataType | RErrorType;
 
 export type UnresolvedCompoundRDataType = never;
 
 export type UnresolvedRDataType
-	= PrimitiveRDataType
+	= RAnyType
+	| RNeverType
+	| PrimitiveRDataType
 	| UnresolvedCompoundRDataType
-	| RTypeVariable;
\ No newline at end of file
+	| RTypeVariable
+	| RErrorType;
\ No newline at end of file

From 31bb5067d79b00709b4001d116d7700786dbb749 Mon Sep 17 00:00:00 2001
From: Lukas Rohde <lukas.rohde@silupe.de>
Date: Sat, 24 May 2025 12:45:46 +0200
Subject: [PATCH 028/153] refactor(typing): remove `Special` and `Builtin` and
 add `Language` type

---
 src/typing/types.ts | 17 +++++------------
 1 file changed, 5 insertions(+), 12 deletions(-)

diff --git a/src/typing/types.ts b/src/typing/types.ts
index 8b90a219270..b37917923c8 100644
--- a/src/typing/types.ts
+++ b/src/typing/types.ts
@@ -25,10 +25,8 @@ export enum RDataTypeTag {
     List = 'RListType',
     /** {@link REnvironmentType} */
     Environment = 'REnvironmentType',
-    /** {@link RSpecialType} */
-    Special = 'RSpecialType',
-    /** {@link RBuiltinType} */
-    Builtin = 'RBuiltinType',
+    /** {@link RLanguageType} */
+    Language = 'RLanguageType',
 	/** {@link RNeverType} */
 	Never = 'RNeverType',
     /** {@link RTypeVariable} */
@@ -81,12 +79,8 @@ export class REnvironmentType {
 	readonly tag = RDataTypeTag.Environment;
 }
 
-export class RSpecialType {
-	readonly tag = RDataTypeTag.Special;
-}
-
-export class RBuiltinType {
-	readonly tag = RDataTypeTag.Builtin;
+export class RLanguageType {
+	readonly tag = RDataTypeTag.Language;
 }
 
 export class RNeverType {
@@ -148,8 +142,7 @@ export type PrimitiveRDataType
 	| RFunctionType
 	| RListType
 	| REnvironmentType
-	| RSpecialType
-	| RBuiltinType;
+	| RLanguageType
 
 export type CompoundRDataType = never;
 

From 58e1bb4087ade0fc88791bec83844a512f8a312a Mon Sep 17 00:00:00 2001
From: Lukas Rohde <lukas.rohde@silupe.de>
Date: Sat, 24 May 2025 13:12:12 +0200
Subject: [PATCH 029/153] feat(typing): infer types for `get` and `rm` calls

---
 src/typing/infer.ts | 18 ++++++++++++++++++
 1 file changed, 18 insertions(+)

diff --git a/src/typing/infer.ts b/src/typing/infer.ts
index a1770d2472c..0006b27a810 100644
--- a/src/typing/infer.ts
+++ b/src/typing/infer.ts
@@ -14,6 +14,7 @@ import { guard } from '../util/assert';
 import { OriginType } from '../dataflow/origin/dfg-get-origin';
 import type { NodeId } from '../r-bridge/lang-4.x/ast/model/processing/node-id';
 import { edgeIncludesType, EdgeType } from '../dataflow/graph/edge';
+import { EmptyArgument } from '../r-bridge/lang-4.x/ast/model/nodes/r-function-call';
 
 export function inferDataTypes<Info extends { typeVariable?: undefined }>(ast: NormalizedAst<Info>, dataFlowInfo: DataflowInformation): NormalizedAst<Info & DataTypeInfo> {
 	const astWithTypeVars = decorateTypeVariables(ast);
@@ -124,6 +125,23 @@ class TypeInferingCfgGuidedVisitor extends SemanticCfgGuidedVisitor<UnresolvedTy
 		target.info.typeVariable.unify(new RFunctionType());
 	}
 
+	override onGetCall(data: { call: DataflowGraphVertexFunctionCall }) {
+		guard(data.call.args.length == 1, 'Expected exactly one argument for get call');
+		const varName = data.call.args.at(0);
+		
+		guard(varName !== undefined && varName !== EmptyArgument, 'Expected argument of get call to be defined');
+		const varNameNode = this.getNormalizedAst(varName.nodeId);
+
+		guard(varNameNode !== undefined, 'Expected variable name node to be defined');
+		varNameNode.info.typeVariable.unify(new RStringType());
+	}
+
+	override onRmCall(data: { call: DataflowGraphVertexFunctionCall }) {
+		const node = this.getNormalizedAst(data.call.id);
+		guard(node !== undefined, 'Expected AST node to be defined');
+		node.info.typeVariable.unify(new RNullType());
+	}
+
 	override onFunctionDefinition(vertex: DataflowGraphVertexFunctionDefinition): void {
 		const node = this.getNormalizedAst(vertex.id);
 		guard(node !== undefined, 'Expected AST node to be defined');

From 7303d55094fd8d4df5ff2dba1f857ddc33f051ba Mon Sep 17 00:00:00 2001
From: Lukas Rohde <lukas.rohde@silupe.de>
Date: Sat, 24 May 2025 13:44:26 +0200
Subject: [PATCH 030/153] feat(typing): infer types for loops

---
 src/typing/infer.ts | 44 +++++++++++++++++++++++++++++++++++++++++++-
 1 file changed, 43 insertions(+), 1 deletion(-)

diff --git a/src/typing/infer.ts b/src/typing/infer.ts
index 0006b27a810..b789448b6f9 100644
--- a/src/typing/infer.ts
+++ b/src/typing/infer.ts
@@ -8,13 +8,15 @@ import type { RString } from '../r-bridge/lang-4.x/ast/model/nodes/r-string';
 import type { NormalizedAst } from '../r-bridge/lang-4.x/ast/model/processing/decorate';
 import { mapNormalizedAstInfo } from '../r-bridge/lang-4.x/ast/model/processing/decorate';
 import type { RDataType } from './types';
-import { RTypeVariable , RComplexType, RDoubleType, RIntegerType, RLogicalType, RStringType, resolveType, RNullType, RFunctionType } from './types';
+import { RTypeVariable , RComplexType, RDoubleType, RIntegerType, RLogicalType, RStringType, resolveType, RNullType, RFunctionType, RNeverType } from './types';
 import type { RExpressionList } from '../r-bridge/lang-4.x/ast/model/nodes/r-expression-list';
 import { guard } from '../util/assert';
 import { OriginType } from '../dataflow/origin/dfg-get-origin';
 import type { NodeId } from '../r-bridge/lang-4.x/ast/model/processing/node-id';
 import { edgeIncludesType, EdgeType } from '../dataflow/graph/edge';
 import { EmptyArgument } from '../r-bridge/lang-4.x/ast/model/nodes/r-function-call';
+import type { FunctionArgument } from '../dataflow/graph/graph';
+import { CfgVertexType } from '../control-flow/control-flow-graph';
 
 export function inferDataTypes<Info extends { typeVariable?: undefined }>(ast: NormalizedAst<Info>, dataFlowInfo: DataflowInformation): NormalizedAst<Info & DataTypeInfo> {
 	const astWithTypeVars = decorateTypeVariables(ast);
@@ -142,6 +144,46 @@ class TypeInferingCfgGuidedVisitor extends SemanticCfgGuidedVisitor<UnresolvedTy
 		node.info.typeVariable.unify(new RNullType());
 	}
 
+	override onForLoopCall(data: { call: DataflowGraphVertexFunctionCall, variable: FunctionArgument, vector: FunctionArgument, body: FunctionArgument }) {
+		guard(data.variable !== EmptyArgument && data.vector !== EmptyArgument, 'Expected variable and vector arguments to be defined');
+		const variableNode = this.getNormalizedAst(data.variable.nodeId);
+		const vectorNode = this.getNormalizedAst(data.vector.nodeId);
+		
+		guard(variableNode !== undefined && vectorNode !== undefined, 'Expected variable and vector nodes to be defined');
+		variableNode.info.typeVariable.unify(vectorNode.info.typeVariable);
+
+		this.onLoopCall(data);
+	}
+
+	override onWhileLoopCall(data: { call: DataflowGraphVertexFunctionCall, condition: FunctionArgument, body: FunctionArgument }) {
+		guard(data.condition !== EmptyArgument, 'Expected condition argument to be defined');
+		const conditionNode = this.getNormalizedAst(data.condition.nodeId);
+		
+		guard(conditionNode !== undefined, 'Expected condition node to be defined');
+		conditionNode.info.typeVariable.unify(new RLogicalType());
+
+		this.onLoopCall(data);
+	}
+
+	override onRepeatLoopCall(data: { call: DataflowGraphVertexFunctionCall, body: FunctionArgument }) {
+		this.onLoopCall(data);
+	}
+
+	protected onLoopCall(data: { call: DataflowGraphVertexFunctionCall, body: FunctionArgument }) {
+		const node = this.getNormalizedAst(data.call.id);
+		guard(node !== undefined, 'Expected AST node to be defined');
+
+		const cfgVertex = this.config.controlFlow.graph.getVertex(data.call.id);
+		guard(cfgVertex !== undefined && cfgVertex.type === CfgVertexType.Statement, 'Expected statement vertex for loop');
+		const isInfinite = (cfgVertex.end ?? []).flatMap((id) => this.config.controlFlow.graph.ingoing(id) ?? []).length === 0;
+
+		if(isInfinite) {
+			node.info.typeVariable.unify(new RNeverType());
+		} else {
+			node.info.typeVariable.unify(new RNullType());
+		}
+	}
+
 	override onFunctionDefinition(vertex: DataflowGraphVertexFunctionDefinition): void {
 		const node = this.getNormalizedAst(vertex.id);
 		guard(node !== undefined, 'Expected AST node to be defined');

From 31616e15ebe6ffd9e1b13fa4ab6e77be2e064397 Mon Sep 17 00:00:00 2001
From: Lukas Rohde <lukas.rohde@silupe.de>
Date: Sat, 24 May 2025 14:00:30 +0200
Subject: [PATCH 031/153] feat(typing): infer types for if-then-else calls

---
 src/typing/infer.ts | 36 ++++++++++++++++++++++++++++++++++++
 1 file changed, 36 insertions(+)

diff --git a/src/typing/infer.ts b/src/typing/infer.ts
index b789448b6f9..341c81d9982 100644
--- a/src/typing/infer.ts
+++ b/src/typing/infer.ts
@@ -184,6 +184,42 @@ class TypeInferingCfgGuidedVisitor extends SemanticCfgGuidedVisitor<UnresolvedTy
 		}
 	}
 
+	override onIfThenElseCall(data: { call: DataflowGraphVertexFunctionCall, condition: FunctionArgument, then: FunctionArgument, else: FunctionArgument | undefined }) {
+		guard(data.condition !== EmptyArgument, 'Expected condition argument to be defined');
+		const conditionNode = this.getNormalizedAst(data.condition.nodeId);
+		
+		guard(conditionNode !== undefined, 'Expected condition node to be defined');
+		conditionNode.info.typeVariable.unify(new RLogicalType());
+
+		const node = this.getNormalizedAst(data.call.id);
+		guard(node !== undefined, 'Expected AST node to be defined');
+
+		guard(data.then !== EmptyArgument, 'Expected then argument to be defined');
+		const isThenBranchReachable = (this.config.controlFlow.graph.ingoing(data.then.nodeId)?.size ?? 0) > 0;
+		
+		const thenNode = this.getNormalizedAst(data.then.nodeId);
+		guard(thenNode !== undefined, 'Expected then node to be defined');
+
+		if(isThenBranchReachable) {
+			node.info.typeVariable.unify(thenNode.info.typeVariable);
+		} else {
+			node.info.typeVariable.unify(new RNeverType());
+		}
+
+		if(data.else !== undefined && data.else !== EmptyArgument) {
+			const isElseBranchReachable = (this.config.controlFlow.graph.ingoing(data.else.nodeId)?.size ?? 0) > 0;
+
+			const elseNode = this.getNormalizedAst(data.else.nodeId);
+			guard(elseNode !== undefined, 'Expected else node to be defined');
+
+			if(isElseBranchReachable) {
+				node.info.typeVariable.unify(elseNode.info.typeVariable);
+			} else {
+				node.info.typeVariable.unify(new RNeverType());
+			}
+		}
+	}
+
 	override onFunctionDefinition(vertex: DataflowGraphVertexFunctionDefinition): void {
 		const node = this.getNormalizedAst(vertex.id);
 		guard(node !== undefined, 'Expected AST node to be defined');

From 09bd3f96991fe4212423487e392f712715055527 Mon Sep 17 00:00:00 2001
From: Lukas Rohde <lukas.rohde@silupe.de>
Date: Sat, 24 May 2025 14:06:07 +0200
Subject: [PATCH 032/153] feat(typing): infer types for list and vector
 constructors

---
 src/typing/infer.ts | 24 +++++++++++++++++++++++-
 1 file changed, 23 insertions(+), 1 deletion(-)

diff --git a/src/typing/infer.ts b/src/typing/infer.ts
index 341c81d9982..331f256ae73 100644
--- a/src/typing/infer.ts
+++ b/src/typing/infer.ts
@@ -8,7 +8,7 @@ import type { RString } from '../r-bridge/lang-4.x/ast/model/nodes/r-string';
 import type { NormalizedAst } from '../r-bridge/lang-4.x/ast/model/processing/decorate';
 import { mapNormalizedAstInfo } from '../r-bridge/lang-4.x/ast/model/processing/decorate';
 import type { RDataType } from './types';
-import { RTypeVariable , RComplexType, RDoubleType, RIntegerType, RLogicalType, RStringType, resolveType, RNullType, RFunctionType, RNeverType } from './types';
+import { RTypeVariable , RComplexType, RDoubleType, RIntegerType, RLogicalType, RStringType, resolveType, RNullType, RFunctionType, RNeverType, RListType } from './types';
 import type { RExpressionList } from '../r-bridge/lang-4.x/ast/model/nodes/r-expression-list';
 import { guard } from '../util/assert';
 import { OriginType } from '../dataflow/origin/dfg-get-origin';
@@ -220,6 +220,28 @@ class TypeInferingCfgGuidedVisitor extends SemanticCfgGuidedVisitor<UnresolvedTy
 		}
 	}
 
+	override onListCall(data: { call: DataflowGraphVertexFunctionCall }) {
+		const node = this.getNormalizedAst(data.call.id);
+		guard(node !== undefined, 'Expected AST node to be defined');
+		node.info.typeVariable.unify(new RListType());
+	}
+
+	override onVectorCall(data: { call: DataflowGraphVertexFunctionCall }) {
+		const node = this.getNormalizedAst(data.call.id);
+		guard(node !== undefined, 'Expected AST node to be defined');
+		
+		const args = data.call.args.filter((arg) => arg !== EmptyArgument);
+		if(args.length === 0) {
+			node.info.typeVariable.unify(new RNullType());
+			return;
+		}
+		for(const arg of args) {
+			const argNode = this.getNormalizedAst(arg.nodeId);
+			guard(argNode !== undefined, 'Expected argument node to be defined');
+			node.info.typeVariable.unify(argNode.info.typeVariable);
+		}
+	}
+
 	override onFunctionDefinition(vertex: DataflowGraphVertexFunctionDefinition): void {
 		const node = this.getNormalizedAst(vertex.id);
 		guard(node !== undefined, 'Expected AST node to be defined');

From a3d6f4e15d12f75b98701d8387f1b62fe59cb90d Mon Sep 17 00:00:00 2001
From: Lukas Rohde <lukas.rohde@silupe.de>
Date: Sat, 24 May 2025 14:16:57 +0200
Subject: [PATCH 033/153] feat(typing): infer types for `quote` and `eval`
 calls

---
 src/typing/infer.ts | 32 +++++++++++++++++++++++++++++++-
 1 file changed, 31 insertions(+), 1 deletion(-)

diff --git a/src/typing/infer.ts b/src/typing/infer.ts
index 331f256ae73..7378f7cf18b 100644
--- a/src/typing/infer.ts
+++ b/src/typing/infer.ts
@@ -8,7 +8,7 @@ import type { RString } from '../r-bridge/lang-4.x/ast/model/nodes/r-string';
 import type { NormalizedAst } from '../r-bridge/lang-4.x/ast/model/processing/decorate';
 import { mapNormalizedAstInfo } from '../r-bridge/lang-4.x/ast/model/processing/decorate';
 import type { RDataType } from './types';
-import { RTypeVariable , RComplexType, RDoubleType, RIntegerType, RLogicalType, RStringType, resolveType, RNullType, RFunctionType, RNeverType, RListType } from './types';
+import { RTypeVariable , RComplexType, RDoubleType, RIntegerType, RLogicalType, RStringType, resolveType, RNullType, RFunctionType, RNeverType, RListType, RLanguageType, RAnyType } from './types';
 import type { RExpressionList } from '../r-bridge/lang-4.x/ast/model/nodes/r-expression-list';
 import { guard } from '../util/assert';
 import { OriginType } from '../dataflow/origin/dfg-get-origin';
@@ -219,6 +219,36 @@ class TypeInferingCfgGuidedVisitor extends SemanticCfgGuidedVisitor<UnresolvedTy
 			}
 		}
 	}
+	
+	override onQuoteCall(data: { call: DataflowGraphVertexFunctionCall }) {
+		guard(data.call.args.length === 1, 'Expected exactly one argument for quote call');
+		const arg = data.call.args.at(0);
+		
+		guard(arg !== undefined && arg !== EmptyArgument, 'Expected argument of quote call to be defined');
+		const argNode = this.getNormalizedAst(arg.nodeId);
+		
+		guard(argNode !== undefined, 'Expected argument node to be defined');
+		argNode.info.typeVariable.unify(new RStringType());
+
+		const node = this.getNormalizedAst(data.call.id);
+		guard(node !== undefined, 'Expected AST node to be defined');
+		node.info.typeVariable.unify(new RLanguageType());
+	}
+
+	override onEvalFunctionCall(data: { call: DataflowGraphVertexFunctionCall }) {
+		guard(data.call.args.length === 1, 'Expected exactly one argument for eval call');
+		const arg = data.call.args.at(0);
+		
+		guard(arg !== undefined && arg !== EmptyArgument, 'Expected argument of eval call to be defined');
+		const argNode = this.getNormalizedAst(arg.nodeId);
+		
+		guard(argNode !== undefined, 'Expected argument node to be defined');
+		argNode.info.typeVariable.unify(new RLanguageType());
+
+		const node = this.getNormalizedAst(data.call.id);
+		guard(node !== undefined, 'Expected AST node to be defined');
+		node.info.typeVariable.unify(new RAnyType()); // TODO: Infer a more specific type based on the argument if possible
+	}
 
 	override onListCall(data: { call: DataflowGraphVertexFunctionCall }) {
 		const node = this.getNormalizedAst(data.call.id);

From 5b1734d685d2378b516a0b9523af9c5344ecb973 Mon Sep 17 00:00:00 2001
From: Lukas Rohde <lukas.rohde@silupe.de>
Date: Sat, 24 May 2025 14:24:36 +0200
Subject: [PATCH 034/153] test(typing): split up tests into multiple test files

---
 .../basic-expression-type-inference.test.ts   | 33 -------------------
 ...constant-expression-type-inference.test.ts | 12 +++++++
 ...upported-expression-type-inference.test.ts |  8 +++++
 .../typing/variable-type-inference.test.ts    | 14 ++++++++
 4 files changed, 34 insertions(+), 33 deletions(-)
 delete mode 100644 test/functionality/typing/basic-expression-type-inference.test.ts
 create mode 100644 test/functionality/typing/constant-expression-type-inference.test.ts
 create mode 100644 test/functionality/typing/unsupported-expression-type-inference.test.ts
 create mode 100644 test/functionality/typing/variable-type-inference.test.ts

diff --git a/test/functionality/typing/basic-expression-type-inference.test.ts b/test/functionality/typing/basic-expression-type-inference.test.ts
deleted file mode 100644
index e278225a6db..00000000000
--- a/test/functionality/typing/basic-expression-type-inference.test.ts
+++ /dev/null
@@ -1,33 +0,0 @@
-import { describe } from 'vitest';
-import { RDataTypeTag } from '../../../src/typing/types';
-import { assertInferredType, assertInferredTypes } from '../_helper/typing/assert-inferred-type';
-import { Q } from '../../../src/search/flowr-search-builder';
-
-describe('Infer types for currently supported R expressions', () => {
-	// Test type inference for constants
-	describe.each([
-		{ description: 'logical constant',        input: 'TRUE',            expectedType: { tag: RDataTypeTag.Logical as const } },
-		{ description: 'integer constant',        input: '42',              expectedType: { tag: RDataTypeTag.Integer as const } },
-		{ description: 'double constant',         input: '42.5',            expectedType: { tag: RDataTypeTag.Double as const } },
-		{ description: 'complex number constant', input: '42i',             expectedType: { tag: RDataTypeTag.Complex as const } },
-		{ description: 'string constant',         input: '"Hello, world!"', expectedType: { tag: RDataTypeTag.String as const } },
-		{ description: 'empty expression list',   input: '{}',              expectedType: { tag: RDataTypeTag.Null as const } }
-	])('Infer $expectedType for $description', ({ input, expectedType }) => assertInferredType(input, expectedType));
-
-	// Test type inference for variables
-	describe('Infer types for variables', () => {
-		assertInferredTypes(
-			'x <- 42; x',
-			{ query: Q.var('x').first().build(), expectedType: { tag: RDataTypeTag.Integer as const } },
-			{ query: Q.criterion('1@<-').build(), expectedType: { tag: RDataTypeTag.Integer as const } },
-			{ query: Q.var('x').last().build(), expectedType: { tag: RDataTypeTag.Integer as const } }
-		);
-		assertInferredType('y', { tag: RDataTypeTag.Null });
-	});
-
-	// Test type inference for currently unsupported R expressions
-	describe('Infer no type information for currently unsupported R expressions', () => {
-		assertInferredType('1 + 2',                  { tag: RDataTypeTag.Any });
-		assertInferredType('print("Hello, world!")', { tag: RDataTypeTag.Any });
-	});
-});
\ No newline at end of file
diff --git a/test/functionality/typing/constant-expression-type-inference.test.ts b/test/functionality/typing/constant-expression-type-inference.test.ts
new file mode 100644
index 00000000000..d26d8b91778
--- /dev/null
+++ b/test/functionality/typing/constant-expression-type-inference.test.ts
@@ -0,0 +1,12 @@
+import { describe } from 'vitest';
+import { RDataTypeTag } from '../../../src/typing/types';
+import { assertInferredType } from '../_helper/typing/assert-inferred-type';
+
+describe.each([
+	{ description: 'logical constant',        input: 'TRUE',            expectedType: { tag: RDataTypeTag.Logical as const } },
+	{ description: 'integer constant',        input: '42',              expectedType: { tag: RDataTypeTag.Integer as const } },
+	{ description: 'double constant',         input: '42.5',            expectedType: { tag: RDataTypeTag.Double as const } },
+	{ description: 'complex number constant', input: '42i',             expectedType: { tag: RDataTypeTag.Complex as const } },
+	{ description: 'string constant',         input: '"Hello, world!"', expectedType: { tag: RDataTypeTag.String as const } },
+	{ description: 'empty expression list',   input: '{}',              expectedType: { tag: RDataTypeTag.Null as const } }
+])('Infer $expectedType for $description', ({ input, expectedType }) => assertInferredType(input, expectedType));
\ No newline at end of file
diff --git a/test/functionality/typing/unsupported-expression-type-inference.test.ts b/test/functionality/typing/unsupported-expression-type-inference.test.ts
new file mode 100644
index 00000000000..936aacab809
--- /dev/null
+++ b/test/functionality/typing/unsupported-expression-type-inference.test.ts
@@ -0,0 +1,8 @@
+import { describe } from 'vitest';
+import { RDataTypeTag } from '../../../src/typing/types';
+import { assertInferredType } from '../_helper/typing/assert-inferred-type';
+
+describe('Infer no type information for currently unsupported R expressions', () => {
+	assertInferredType('1 + 2',                  { tag: RDataTypeTag.Any });
+	assertInferredType('print("Hello, world!")', { tag: RDataTypeTag.Any });
+});
\ No newline at end of file
diff --git a/test/functionality/typing/variable-type-inference.test.ts b/test/functionality/typing/variable-type-inference.test.ts
new file mode 100644
index 00000000000..1cf52ed03b5
--- /dev/null
+++ b/test/functionality/typing/variable-type-inference.test.ts
@@ -0,0 +1,14 @@
+import { describe } from 'vitest';
+import { RDataTypeTag } from '../../../src/typing/types';
+import { assertInferredType, assertInferredTypes } from '../_helper/typing/assert-inferred-type';
+import { Q } from '../../../src/search/flowr-search-builder';
+
+describe('Infer types for variables', () => {
+	assertInferredTypes(
+		'x <- 42; x',
+		{ query: Q.var('x').first().build(), expectedType: { tag: RDataTypeTag.Integer as const } },
+		{ query: Q.criterion('1@<-').build(), expectedType: { tag: RDataTypeTag.Integer as const } },
+		{ query: Q.var('x').last().build(), expectedType: { tag: RDataTypeTag.Integer as const } }
+	);
+	assertInferredType('y', { tag: RDataTypeTag.Null });
+});
\ No newline at end of file

From 3c88cfaa1c290b9a9eade64576173772ec12cfb3 Mon Sep 17 00:00:00 2001
From: Lukas Rohde <lukas.rohde@silupe.de>
Date: Sat, 24 May 2025 23:35:31 +0200
Subject: [PATCH 035/153] refactor(typing): refactor counting of vertices
 flowing into loop exits

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

diff --git a/src/typing/infer.ts b/src/typing/infer.ts
index 7378f7cf18b..ec695f134de 100644
--- a/src/typing/infer.ts
+++ b/src/typing/infer.ts
@@ -175,7 +175,7 @@ class TypeInferingCfgGuidedVisitor extends SemanticCfgGuidedVisitor<UnresolvedTy
 
 		const cfgVertex = this.config.controlFlow.graph.getVertex(data.call.id);
 		guard(cfgVertex !== undefined && cfgVertex.type === CfgVertexType.Statement, 'Expected statement vertex for loop');
-		const isInfinite = (cfgVertex.end ?? []).flatMap((id) => this.config.controlFlow.graph.ingoing(id) ?? []).length === 0;
+		const isInfinite = (cfgVertex.end ?? []).reduce((prevCount, id) => prevCount + (this.config.controlFlow.graph.outgoing(id)?.size ?? 0), 0) === 0;
 
 		if(isInfinite) {
 			node.info.typeVariable.unify(new RNeverType());

From c36973e7559096cfbe52138eb449b89ea55603f5 Mon Sep 17 00:00:00 2001
From: Lukas Rohde <lukas.rohde@silupe.de>
Date: Sat, 24 May 2025 23:50:50 +0200
Subject: [PATCH 036/153] feat-fix(cfg): correct spelling of origin id for
 repeat loops

---
 src/control-flow/semantic-cfg-guided-visitor.ts | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/control-flow/semantic-cfg-guided-visitor.ts b/src/control-flow/semantic-cfg-guided-visitor.ts
index 5adff783358..af1c1af4573 100644
--- a/src/control-flow/semantic-cfg-guided-visitor.ts
+++ b/src/control-flow/semantic-cfg-guided-visitor.ts
@@ -168,7 +168,7 @@ export class SemanticCfgGuidedVisitor<
 				return this.onQuoteCall({ call });
 			case 'builtin:for-loop':
 				return this.onForLoopCall({ call, variable: call.args[0], vector: call.args[1], body: call.args[2] });
-			case 'builtin:builtin:repeat-loop':
+			case 'builtin:repeat-loop':
 				return this.onRepeatLoopCall({ call, body: call.args[0] });
 			case 'builtin:while-loop':
 				return this.onWhileLoopCall({ call, condition: call.args[0], body: call.args[1] });

From 9cd59e9f6c1a83354f36ed669cb2053ad0d81b0d Mon Sep 17 00:00:00 2001
From: Lukas Rohde <lukas.rohde@silupe.de>
Date: Sun, 25 May 2025 00:07:18 +0200
Subject: [PATCH 037/153] feat-fix(cfg): link for loop cfg exits using `end`
 instead of `exit`

---
 src/control-flow/extract-cfg.ts | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/control-flow/extract-cfg.ts b/src/control-flow/extract-cfg.ts
index 8ee3ddba444..eca5b27d531 100644
--- a/src/control-flow/extract-cfg.ts
+++ b/src/control-flow/extract-cfg.ts
@@ -220,7 +220,7 @@ function cfgWhile(whileLoop: RWhileLoop<ParentInformation>, condition: ControlFl
 
 function cfgFor(forLoop: RForLoop<ParentInformation>, variable: ControlFlowInformation, vector: ControlFlowInformation, body: ControlFlowInformation): ControlFlowInformation {
 	const graph = variable.graph;
-	graph.addVertex({ id: forLoop.info.id, type: identifyMayStatementType(forLoop), exit: [forLoop.info.id + '-exit'], mid: [forLoop.info.id + '-head'] });
+	graph.addVertex({ id: forLoop.info.id, type: identifyMayStatementType(forLoop), end: [forLoop.info.id + '-exit'], mid: [forLoop.info.id + '-head'] });
 
 	graph.merge(vector.graph);
 	graph.merge(body.graph);

From 38238af2701e772b7560e3f97098bae9b841fcd8 Mon Sep 17 00:00:00 2001
From: Lukas Rohde <lukas.rohde@silupe.de>
Date: Sun, 25 May 2025 01:20:32 +0200
Subject: [PATCH 038/153] build-fix(typing): fix merge issues

---
 src/typing/infer.ts | 34 +++++++++++++++++-----------------
 1 file changed, 17 insertions(+), 17 deletions(-)

diff --git a/src/typing/infer.ts b/src/typing/infer.ts
index ec695f134de..a0d4a5df39d 100644
--- a/src/typing/infer.ts
+++ b/src/typing/infer.ts
@@ -53,29 +53,29 @@ function resolveTypeVariables<Info extends UnresolvedTypeInfo>(ast: NormalizedAs
 }
 
 class TypeInferingCfgGuidedVisitor extends SemanticCfgGuidedVisitor<UnresolvedTypeInfo>{
-	override onLogicalConstant(_vertex: DataflowGraphVertexValue, node: RLogical<UnresolvedTypeInfo>): void {
-		node.info.typeVariable.unify(new RLogicalType());
+	override onLogicalConstant(data: { vertex: DataflowGraphVertexValue, node: RLogical<UnresolvedTypeInfo> }): void {
+		data.node.info.typeVariable.unify(new RLogicalType());
 	}
 
-	override onNumberConstant(_vertex: DataflowGraphVertexValue, node: RNumber<UnresolvedTypeInfo>): void {
-		if(node.content.complexNumber) {
-			node.info.typeVariable.unify(new RComplexType());
-		} else if(Number.isInteger(node.content.num)) {
-			node.info.typeVariable.unify(new RIntegerType());
+	override onNumberConstant(data: { vertex: DataflowGraphVertexValue, node: RNumber<UnresolvedTypeInfo> }): void {
+		if(data.node.content.complexNumber) {
+			data.node.info.typeVariable.unify(new RComplexType());
+		} else if(Number.isInteger(data.node.content.num)) {
+			data.node.info.typeVariable.unify(new RIntegerType());
 		} else {
-			node.info.typeVariable.unify(new RDoubleType());
+			data.node.info.typeVariable.unify(new RDoubleType());
 		}
 	}
 
-	override onStringConstant(_vertex: DataflowGraphVertexValue, node: RString<UnresolvedTypeInfo>): void {
-		node.info.typeVariable.unify(new RStringType());
+	override onStringConstant(data: { vertex: DataflowGraphVertexValue, node: RString<UnresolvedTypeInfo> }): void {
+		data.node.info.typeVariable.unify(new RStringType());
 	}
 
-	override onVariableUse(vertex: DataflowGraphVertexUse): void {
-		const node = this.getNormalizedAst(vertex.id);
+	override onVariableUse(data: { vertex: DataflowGraphVertexUse }): void {
+		const node = this.getNormalizedAst(data.vertex.id);
 		guard(node !== undefined, 'Expected AST node to be defined');
 		
-		const origins = this.getOrigins(vertex.id);
+		const origins = this.getOrigins(data.vertex.id);
 		const readOrigins = origins?.filter((origin) => origin.type === OriginType.ReadVariableOrigin);
 
 		if(readOrigins === undefined || readOrigins.length === 0) {
@@ -105,8 +105,8 @@ class TypeInferingCfgGuidedVisitor extends SemanticCfgGuidedVisitor<UnresolvedTy
 	}
 
 	override onDefaultFunctionCall(data: { call: DataflowGraphVertexFunctionCall }): void {
-		const node = this.getNormalizedAst(data.call.id);
-		guard(node !== undefined, 'Expected AST node to be defined');
+		// const node = this.getNormalizedAst(data.call.id);
+		// guard(node !== undefined, 'Expected AST node to be defined');
 
 		const outgoing = this.config.dataflow.graph.outgoingEdges(data.call.id);
 		const callsTargets = outgoing?.entries()
@@ -272,8 +272,8 @@ class TypeInferingCfgGuidedVisitor extends SemanticCfgGuidedVisitor<UnresolvedTy
 		}
 	}
 
-	override onFunctionDefinition(vertex: DataflowGraphVertexFunctionDefinition): void {
-		const node = this.getNormalizedAst(vertex.id);
+	override onFunctionDefinition(data: { vertex: DataflowGraphVertexFunctionDefinition }): void {
+		const node = this.getNormalizedAst(data.vertex.id);
 		guard(node !== undefined, 'Expected AST node to be defined');
 
 		node.info.typeVariable.unify(new RFunctionType());

From 5aad303eb5f8f3c26814da78cbd1b717abee1d1f Mon Sep 17 00:00:00 2001
From: Lukas Rohde <lukas.rohde@silupe.de>
Date: Sun, 25 May 2025 01:20:52 +0200
Subject: [PATCH 039/153] test(typing): test type inference for loops

---
 .../typing/loop-type-inference.test.ts        | 19 +++++++++++++++++++
 1 file changed, 19 insertions(+)
 create mode 100644 test/functionality/typing/loop-type-inference.test.ts

diff --git a/test/functionality/typing/loop-type-inference.test.ts b/test/functionality/typing/loop-type-inference.test.ts
new file mode 100644
index 00000000000..a7c9ca1ad50
--- /dev/null
+++ b/test/functionality/typing/loop-type-inference.test.ts
@@ -0,0 +1,19 @@
+import { describe } from 'vitest';
+import { RDataTypeTag } from '../../../src/typing/types';
+import { assertInferredType, assertInferredTypes } from '../_helper/typing/assert-inferred-type';
+import { Q } from '../../../src/search/flowr-search-builder';
+import { RType } from '../../../src/r-bridge/lang-4.x/ast/model/type';
+
+describe('Infer types for loops', () => {
+	describe.each([
+		{ input: 'while(FALSE) { print("Testing is fun!") }', expectedType: { tag: RDataTypeTag.Null as const } },
+		{ input: 'while(TRUE) { break }',                     expectedType: { tag: RDataTypeTag.Null as const } },
+		{ input: 'for(i in 1:10) { print(i) }',   expectedType: { tag: RDataTypeTag.Null as const } },
+		{ input: 'repeat { print("I love testing!") }',       expectedType: { tag: RDataTypeTag.Never as const } },
+	])('Infer $expectedType for $input', ({ input, expectedType }) => assertInferredType(input, expectedType));
+
+	assertInferredTypes(
+		'while(1 > 2) { print("No more testing!") }',
+		{ query: Q.all().filter(RType.BinaryOp).build(), expectedType: { tag: RDataTypeTag.Logical as const } }
+	);
+});
\ No newline at end of file

From 3222f31464dcf93caeaf51d3fae0f60c6ebdf326 Mon Sep 17 00:00:00 2001
From: Lukas Rohde <lukas.rohde@silupe.de>
Date: Mon, 26 May 2025 13:59:18 +0200
Subject: [PATCH 040/153] refactor(typing): refactor `onDefaultFunctionCall`

---
 src/typing/infer.ts | 22 +++++++++-------------
 1 file changed, 9 insertions(+), 13 deletions(-)

diff --git a/src/typing/infer.ts b/src/typing/infer.ts
index a0d4a5df39d..e2dcadd4f41 100644
--- a/src/typing/infer.ts
+++ b/src/typing/infer.ts
@@ -105,26 +105,22 @@ class TypeInferingCfgGuidedVisitor extends SemanticCfgGuidedVisitor<UnresolvedTy
 	}
 
 	override onDefaultFunctionCall(data: { call: DataflowGraphVertexFunctionCall }): void {
-		// const node = this.getNormalizedAst(data.call.id);
-		// guard(node !== undefined, 'Expected AST node to be defined');
-
 		const outgoing = this.config.dataflow.graph.outgoingEdges(data.call.id);
-		const callsTargets = outgoing?.entries()
+		const callTargets = outgoing?.entries()
 			.filter(([_target, edge]) => edgeIncludesType(edge.types, EdgeType.Calls))
 			.map(([target, _edge]) => target)
 			.toArray();
 
-		guard(callsTargets === undefined || callsTargets.length <= 1, 'Expected at most one call edge');
+		guard(callTargets !== undefined && callTargets.length >= 1, 'Expected at least one target for default function call');
 
-		if(callsTargets === undefined || callsTargets.length === 0) {
-			// TODO: Handle builtin functions
-			return;
+		for(const target of callTargets) {
+			const targetNode = this.getNormalizedAst(target);
+			if(targetNode !== undefined) {
+				targetNode.info.typeVariable.unify(new RFunctionType());
+			} else {
+				// TODO: Handle builtin functions that are not represented in the AST
+			}
 		}
-
-		const target = this.getNormalizedAst(callsTargets[0]);
-		guard(target !== undefined, 'Expected target node to be defined');
-
-		target.info.typeVariable.unify(new RFunctionType());
 	}
 
 	override onGetCall(data: { call: DataflowGraphVertexFunctionCall }) {

From 41b166c9a03581fad7456fa747e6d736c8babe1e Mon Sep 17 00:00:00 2001
From: Lukas Rohde <lukas.rohde@silupe.de>
Date: Mon, 26 May 2025 14:17:00 +0200
Subject: [PATCH 041/153] feat(typing): add support for NULL constants

---
 src/typing/infer.ts                                   |  7 ++++++-
 test/functionality/typing/loop-type-inference.test.ts | 11 ++++++-----
 2 files changed, 12 insertions(+), 6 deletions(-)

diff --git a/src/typing/infer.ts b/src/typing/infer.ts
index e2dcadd4f41..3b005e4a501 100644
--- a/src/typing/infer.ts
+++ b/src/typing/infer.ts
@@ -5,7 +5,7 @@ import type { DataflowInformation } from '../dataflow/info';
 import type { RLogical } from '../r-bridge/lang-4.x/ast/model/nodes/r-logical';
 import type { RNumber } from '../r-bridge/lang-4.x/ast/model/nodes/r-number';
 import type { RString } from '../r-bridge/lang-4.x/ast/model/nodes/r-string';
-import type { NormalizedAst } from '../r-bridge/lang-4.x/ast/model/processing/decorate';
+import type { NormalizedAst, ParentInformation } from '../r-bridge/lang-4.x/ast/model/processing/decorate';
 import { mapNormalizedAstInfo } from '../r-bridge/lang-4.x/ast/model/processing/decorate';
 import type { RDataType } from './types';
 import { RTypeVariable , RComplexType, RDoubleType, RIntegerType, RLogicalType, RStringType, resolveType, RNullType, RFunctionType, RNeverType, RListType, RLanguageType, RAnyType } from './types';
@@ -17,6 +17,7 @@ import { edgeIncludesType, EdgeType } from '../dataflow/graph/edge';
 import { EmptyArgument } from '../r-bridge/lang-4.x/ast/model/nodes/r-function-call';
 import type { FunctionArgument } from '../dataflow/graph/graph';
 import { CfgVertexType } from '../control-flow/control-flow-graph';
+import type { RSymbol } from '../r-bridge/lang-4.x/ast/model/nodes/r-symbol';
 
 export function inferDataTypes<Info extends { typeVariable?: undefined }>(ast: NormalizedAst<Info>, dataFlowInfo: DataflowInformation): NormalizedAst<Info & DataTypeInfo> {
 	const astWithTypeVars = decorateTypeVariables(ast);
@@ -53,6 +54,10 @@ function resolveTypeVariables<Info extends UnresolvedTypeInfo>(ast: NormalizedAs
 }
 
 class TypeInferingCfgGuidedVisitor extends SemanticCfgGuidedVisitor<UnresolvedTypeInfo>{
+	protected override onNullConstant(data: { vertex: DataflowGraphVertexValue; node: RSymbol<UnresolvedTypeInfo & ParentInformation, 'NULL'>; }): void {
+		data.node.info.typeVariable.unify(new RNullType());
+	}
+
 	override onLogicalConstant(data: { vertex: DataflowGraphVertexValue, node: RLogical<UnresolvedTypeInfo> }): void {
 		data.node.info.typeVariable.unify(new RLogicalType());
 	}
diff --git a/test/functionality/typing/loop-type-inference.test.ts b/test/functionality/typing/loop-type-inference.test.ts
index a7c9ca1ad50..14ac00805b0 100644
--- a/test/functionality/typing/loop-type-inference.test.ts
+++ b/test/functionality/typing/loop-type-inference.test.ts
@@ -6,14 +6,15 @@ import { RType } from '../../../src/r-bridge/lang-4.x/ast/model/type';
 
 describe('Infer types for loops', () => {
 	describe.each([
-		{ input: 'while(FALSE) { print("Testing is fun!") }', expectedType: { tag: RDataTypeTag.Null as const } },
-		{ input: 'while(TRUE) { break }',                     expectedType: { tag: RDataTypeTag.Null as const } },
-		{ input: 'for(i in 1:10) { print(i) }',   expectedType: { tag: RDataTypeTag.Null as const } },
-		{ input: 'repeat { print("I love testing!") }',       expectedType: { tag: RDataTypeTag.Never as const } },
+		{ input: 'while(FALSE) { print("Testing is fun!") }',                         expectedType: { tag: RDataTypeTag.Null as const } },
+		{ input: 'while(TRUE) { break }',                                             expectedType: { tag: RDataTypeTag.Null as const } },
+		{ input: 'for(i in NULL) { print("I would like to write a test for that") }', expectedType: { tag: RDataTypeTag.Null as const } },
+		{ input: 'for(i in 1:10) { print(i) }',                                       expectedType: { tag: RDataTypeTag.Null as const } },
+		{ input: 'repeat { print("I love testing!") }',                               expectedType: { tag: RDataTypeTag.Never as const } },
 	])('Infer $expectedType for $input', ({ input, expectedType }) => assertInferredType(input, expectedType));
 
 	assertInferredTypes(
-		'while(1 > 2) { print("No more testing!") }',
+		'while(1 > 2) { print("Testing is done!") }',
 		{ query: Q.all().filter(RType.BinaryOp).build(), expectedType: { tag: RDataTypeTag.Logical as const } }
 	);
 });
\ No newline at end of file

From 24a4e33e3ff0f1b1c512d9022de0c642b0ab24d9 Mon Sep 17 00:00:00 2001
From: Lukas Rohde <lukas.rohde@silupe.de>
Date: Mon, 26 May 2025 15:34:31 +0200
Subject: [PATCH 042/153] test(typing): add tests for currently inferrable
 builtin functions

---
 .../builtin-function-type-inference.test.ts   | 30 +++++++++++++++++++
 1 file changed, 30 insertions(+)
 create mode 100644 test/functionality/typing/builtin-function-type-inference.test.ts

diff --git a/test/functionality/typing/builtin-function-type-inference.test.ts b/test/functionality/typing/builtin-function-type-inference.test.ts
new file mode 100644
index 00000000000..ed68af19ff4
--- /dev/null
+++ b/test/functionality/typing/builtin-function-type-inference.test.ts
@@ -0,0 +1,30 @@
+import { describe } from 'vitest';
+import { RDataTypeTag } from '../../../src/typing/types';
+import { assertInferredType, assertInferredTypes } from '../_helper/typing/assert-inferred-type';
+import { Q } from '../../../src/search/flowr-search-builder';
+
+describe('Infer types for builtin functions', () => {
+	assertInferredType('rm(x)', { tag: RDataTypeTag.Null as const });
+
+	assertInferredTypes(
+		'x <- 42\nget("x")',
+		{ query: Q.criterion('1@x').build(), expectedType: { tag: RDataTypeTag.Integer as const } },
+		{ query: Q.criterion('2@get').build(), expectedType: { tag: RDataTypeTag.Integer as const } },
+		{ query: Q.criterion('2@"x"').build(), expectedType: { tag: RDataTypeTag.String as const } }
+	);
+
+	assertInferredTypes(
+		'eval(quote(TRUE))',
+		{ query: Q.criterion('1@eval').build(), expectedType: { tag: RDataTypeTag.Any as const } },
+		{ query: Q.criterion('1@quote').build(), expectedType: { tag: RDataTypeTag.Language as const } },
+		{ query: Q.criterion('1@TRUE').build(), expectedType: { tag: RDataTypeTag.Logical as const } }
+	);
+	
+	assertInferredType('list(1, 2, 3)', { tag: RDataTypeTag.List as const });
+
+	assertInferredTypes(
+		'c("Hello", "Flo", "!")',
+		{ query: Q.criterion('1@c').build(), expectedType: { tag: RDataTypeTag.String as const } },
+		{ query: Q.criterion('1@"Hello"').build(), expectedType: { tag: RDataTypeTag.String as const } }
+	);
+});
\ No newline at end of file

From 8720315f41a13ac6f4b19d16cf5e0e70da2e0d2e Mon Sep 17 00:00:00 2001
From: Lukas Rohde <lukas.rohde@silupe.de>
Date: Mon, 26 May 2025 15:35:11 +0200
Subject: [PATCH 043/153] feat-fix(typing): fix type inference for `quote`
 calls

---
 src/typing/infer.ts | 5 -----
 1 file changed, 5 deletions(-)

diff --git a/src/typing/infer.ts b/src/typing/infer.ts
index 3b005e4a501..f482b4eaaf6 100644
--- a/src/typing/infer.ts
+++ b/src/typing/infer.ts
@@ -224,12 +224,7 @@ class TypeInferingCfgGuidedVisitor extends SemanticCfgGuidedVisitor<UnresolvedTy
 	override onQuoteCall(data: { call: DataflowGraphVertexFunctionCall }) {
 		guard(data.call.args.length === 1, 'Expected exactly one argument for quote call');
 		const arg = data.call.args.at(0);
-		
 		guard(arg !== undefined && arg !== EmptyArgument, 'Expected argument of quote call to be defined');
-		const argNode = this.getNormalizedAst(arg.nodeId);
-		
-		guard(argNode !== undefined, 'Expected argument node to be defined');
-		argNode.info.typeVariable.unify(new RStringType());
 
 		const node = this.getNormalizedAst(data.call.id);
 		guard(node !== undefined, 'Expected AST node to be defined');

From 0b15bddbce3fc20976b6c6ed2a3112cbaf91082f Mon Sep 17 00:00:00 2001
From: Lukas Rohde <lukas.rohde@silupe.de>
Date: Thu, 29 May 2025 14:52:00 +0200
Subject: [PATCH 044/153] feat-fix(typing): fix merge issues

---
 src/typing/infer.ts | 10 +++++-----
 1 file changed, 5 insertions(+), 5 deletions(-)

diff --git a/src/typing/infer.ts b/src/typing/infer.ts
index f482b4eaaf6..1c0ec0abb99 100644
--- a/src/typing/infer.ts
+++ b/src/typing/infer.ts
@@ -1,4 +1,4 @@
-import { extractCFG } from '../control-flow/extract-cfg';
+import { extractCfg } from '../control-flow/extract-cfg';
 import { SemanticCfgGuidedVisitor } from '../control-flow/semantic-cfg-guided-visitor';
 import type { DataflowGraphVertexFunctionCall, DataflowGraphVertexFunctionDefinition, DataflowGraphVertexUse, DataflowGraphVertexValue } from '../dataflow/graph/vertex';
 import type { DataflowInformation } from '../dataflow/info';
@@ -21,7 +21,7 @@ import type { RSymbol } from '../r-bridge/lang-4.x/ast/model/nodes/r-symbol';
 
 export function inferDataTypes<Info extends { typeVariable?: undefined }>(ast: NormalizedAst<Info>, dataFlowInfo: DataflowInformation): NormalizedAst<Info & DataTypeInfo> {
 	const astWithTypeVars = decorateTypeVariables(ast);
-	const controlFlowInfo = extractCFG(astWithTypeVars);
+	const controlFlowInfo = extractCfg(astWithTypeVars);
 	const config = {
 		normalizedAst:        astWithTypeVars,
 		controlFlow:          controlFlowInfo,
@@ -176,7 +176,7 @@ class TypeInferingCfgGuidedVisitor extends SemanticCfgGuidedVisitor<UnresolvedTy
 
 		const cfgVertex = this.config.controlFlow.graph.getVertex(data.call.id);
 		guard(cfgVertex !== undefined && cfgVertex.type === CfgVertexType.Statement, 'Expected statement vertex for loop');
-		const isInfinite = (cfgVertex.end ?? []).reduce((prevCount, id) => prevCount + (this.config.controlFlow.graph.outgoing(id)?.size ?? 0), 0) === 0;
+		const isInfinite = (cfgVertex.end ?? []).reduce((prevCount, id) => prevCount + (this.config.controlFlow.graph.outgoingEdges(id)?.size ?? 0), 0) === 0;
 
 		if(isInfinite) {
 			node.info.typeVariable.unify(new RNeverType());
@@ -196,7 +196,7 @@ class TypeInferingCfgGuidedVisitor extends SemanticCfgGuidedVisitor<UnresolvedTy
 		guard(node !== undefined, 'Expected AST node to be defined');
 
 		guard(data.then !== EmptyArgument, 'Expected then argument to be defined');
-		const isThenBranchReachable = (this.config.controlFlow.graph.ingoing(data.then.nodeId)?.size ?? 0) > 0;
+		const isThenBranchReachable = (this.config.controlFlow.graph.ingoingEdges(data.then.nodeId)?.size ?? 0) > 0;
 		
 		const thenNode = this.getNormalizedAst(data.then.nodeId);
 		guard(thenNode !== undefined, 'Expected then node to be defined');
@@ -208,7 +208,7 @@ class TypeInferingCfgGuidedVisitor extends SemanticCfgGuidedVisitor<UnresolvedTy
 		}
 
 		if(data.else !== undefined && data.else !== EmptyArgument) {
-			const isElseBranchReachable = (this.config.controlFlow.graph.ingoing(data.else.nodeId)?.size ?? 0) > 0;
+			const isElseBranchReachable = (this.config.controlFlow.graph.ingoingEdges(data.else.nodeId)?.size ?? 0) > 0;
 
 			const elseNode = this.getNormalizedAst(data.else.nodeId);
 			guard(elseNode !== undefined, 'Expected else node to be defined');

From 40e47cf0b9cdb1f98cdfe892c60574ea03af7218 Mon Sep 17 00:00:00 2001
From: Lukas Rohde <lukas.rohde@silupe.de>
Date: Thu, 29 May 2025 15:02:35 +0200
Subject: [PATCH 045/153] refactor(typing): handle missing arguments in `if`
 calls more robustly

---
 src/typing/infer.ts | 25 ++++++++++++++++---------
 1 file changed, 16 insertions(+), 9 deletions(-)

diff --git a/src/typing/infer.ts b/src/typing/infer.ts
index 1c0ec0abb99..bccb3b0838c 100644
--- a/src/typing/infer.ts
+++ b/src/typing/infer.ts
@@ -195,16 +195,20 @@ class TypeInferingCfgGuidedVisitor extends SemanticCfgGuidedVisitor<UnresolvedTy
 		const node = this.getNormalizedAst(data.call.id);
 		guard(node !== undefined, 'Expected AST node to be defined');
 
-		guard(data.then !== EmptyArgument, 'Expected then argument to be defined');
-		const isThenBranchReachable = (this.config.controlFlow.graph.ingoingEdges(data.then.nodeId)?.size ?? 0) > 0;
-		
-		const thenNode = this.getNormalizedAst(data.then.nodeId);
-		guard(thenNode !== undefined, 'Expected then node to be defined');
-
-		if(isThenBranchReachable) {
-			node.info.typeVariable.unify(thenNode.info.typeVariable);
+		if(data.then !== EmptyArgument) {
+			const isThenBranchReachable = (this.config.controlFlow.graph.ingoingEdges(data.then.nodeId)?.size ?? 0) > 0;
+			
+			const thenNode = this.getNormalizedAst(data.then.nodeId);
+			guard(thenNode !== undefined, 'Expected then node to be defined');
+
+			if(isThenBranchReachable) {
+				node.info.typeVariable.unify(thenNode.info.typeVariable);
+			} else {
+				node.info.typeVariable.unify(new RNeverType());
+			}
 		} else {
-			node.info.typeVariable.unify(new RNeverType());
+			// If there is no then branch, we can assume that the type is null
+			node.info.typeVariable.unify(new RNullType());
 		}
 
 		if(data.else !== undefined && data.else !== EmptyArgument) {
@@ -218,6 +222,9 @@ class TypeInferingCfgGuidedVisitor extends SemanticCfgGuidedVisitor<UnresolvedTy
 			} else {
 				node.info.typeVariable.unify(new RNeverType());
 			}
+		} else {
+			// If there is no else branch, we can assume that the type is null
+			node.info.typeVariable.unify(new RNullType());
 		}
 	}
 	

From 526ffe342ee4a1fddd2fd2fa8da252a4be35a01a Mon Sep 17 00:00:00 2001
From: Lukas Rohde <lukas.rohde@silupe.de>
Date: Thu, 29 May 2025 15:02:54 +0200
Subject: [PATCH 046/153] test(typing): add tests for typing of `if` calls

---
 .../typing/if-else-type-inference.test.ts     | 19 +++++++++++++++++++
 1 file changed, 19 insertions(+)
 create mode 100644 test/functionality/typing/if-else-type-inference.test.ts

diff --git a/test/functionality/typing/if-else-type-inference.test.ts b/test/functionality/typing/if-else-type-inference.test.ts
new file mode 100644
index 00000000000..c6fd9735dca
--- /dev/null
+++ b/test/functionality/typing/if-else-type-inference.test.ts
@@ -0,0 +1,19 @@
+import { describe } from 'vitest';
+import { RDataTypeTag } from '../../../src/typing/types';
+import { assertInferredType, assertInferredTypes } from '../_helper/typing/assert-inferred-type';
+import { Q } from '../../../src/search/flowr-search-builder';
+import { RType } from '../../../src/r-bridge/lang-4.x/ast/model/type';
+
+describe('Infer types for if statements', () => {
+	describe.each([
+		{ input: 'if(FALSE) { TRUE }',           expectedType: { tag: RDataTypeTag.Null as const } },
+		{ input: 'if(TRUE) { 1 } else { NULL }', expectedType: { tag: RDataTypeTag.Integer as const } },
+		// { input: 'if(return()) { 1 } else { NULL }', expectedType: { tag: RDataTypeTag.Never as const } },
+	])('Infer $expectedType for $input', ({ input, expectedType }) => assertInferredType(input, expectedType));
+
+	assertInferredTypes(
+		'a <- if(1 > 2) { "Yes" } else { "Nope" }',
+		{ query: Q.all().filter(RType.BinaryOp).first().build(), expectedType: { tag: RDataTypeTag.String as const } },
+		{ query: Q.all().filter(RType.BinaryOp).last().build(),  expectedType: { tag: RDataTypeTag.Logical as const } }
+	);
+});
\ No newline at end of file

From fa66032da94ddb2fd6410f087fee6f10d1d9d3dc Mon Sep 17 00:00:00 2001
From: Lukas Rohde <lukas.rohde@silupe.de>
Date: Thu, 29 May 2025 22:19:18 +0200
Subject: [PATCH 047/153] feat(typing): add support for function argument and
 return types

---
 src/typing/infer.ts | 12 ++++++------
 src/typing/types.ts | 42 +++++++++++++++++++++++++++++++++++++++---
 2 files changed, 45 insertions(+), 9 deletions(-)

diff --git a/src/typing/infer.ts b/src/typing/infer.ts
index bccb3b0838c..5bb82b060c6 100644
--- a/src/typing/infer.ts
+++ b/src/typing/infer.ts
@@ -8,7 +8,7 @@ import type { RString } from '../r-bridge/lang-4.x/ast/model/nodes/r-string';
 import type { NormalizedAst, ParentInformation } from '../r-bridge/lang-4.x/ast/model/processing/decorate';
 import { mapNormalizedAstInfo } from '../r-bridge/lang-4.x/ast/model/processing/decorate';
 import type { RDataType } from './types';
-import { RTypeVariable , RComplexType, RDoubleType, RIntegerType, RLogicalType, RStringType, resolveType, RNullType, RFunctionType, RNeverType, RListType, RLanguageType, RAnyType } from './types';
+import { RTypeVariable , RComplexType, RDoubleType, RIntegerType, RLogicalType, RStringType, resolveType, RNullType, RNeverType, RListType, RLanguageType, RAnyType, UnresolvedRFunctionType } from './types';
 import type { RExpressionList } from '../r-bridge/lang-4.x/ast/model/nodes/r-expression-list';
 import { guard } from '../util/assert';
 import { OriginType } from '../dataflow/origin/dfg-get-origin';
@@ -18,6 +18,7 @@ import { EmptyArgument } from '../r-bridge/lang-4.x/ast/model/nodes/r-function-c
 import type { FunctionArgument } from '../dataflow/graph/graph';
 import { CfgVertexType } from '../control-flow/control-flow-graph';
 import type { RSymbol } from '../r-bridge/lang-4.x/ast/model/nodes/r-symbol';
+import { RType } from '../r-bridge/lang-4.x/ast/model/type';
 
 export function inferDataTypes<Info extends { typeVariable?: undefined }>(ast: NormalizedAst<Info>, dataFlowInfo: DataflowInformation): NormalizedAst<Info & DataTypeInfo> {
 	const astWithTypeVars = decorateTypeVariables(ast);
@@ -115,13 +116,12 @@ class TypeInferingCfgGuidedVisitor extends SemanticCfgGuidedVisitor<UnresolvedTy
 			.filter(([_target, edge]) => edgeIncludesType(edge.types, EdgeType.Calls))
 			.map(([target, _edge]) => target)
 			.toArray();
-
+			
 		guard(callTargets !== undefined && callTargets.length >= 1, 'Expected at least one target for default function call');
-
 		for(const target of callTargets) {
 			const targetNode = this.getNormalizedAst(target);
 			if(targetNode !== undefined) {
-				targetNode.info.typeVariable.unify(new RFunctionType());
+				targetNode.info.typeVariable.unify(new UnresolvedRFunctionType(data.call.args.length));
 			} else {
 				// TODO: Handle builtin functions that are not represented in the AST
 			}
@@ -277,9 +277,9 @@ class TypeInferingCfgGuidedVisitor extends SemanticCfgGuidedVisitor<UnresolvedTy
 
 	override onFunctionDefinition(data: { vertex: DataflowGraphVertexFunctionDefinition }): void {
 		const node = this.getNormalizedAst(data.vertex.id);
-		guard(node !== undefined, 'Expected AST node to be defined');
+		guard(node !== undefined && node.type === RType.FunctionDefinition, 'Expected AST node to be a function definition');
 
-		node.info.typeVariable.unify(new RFunctionType());
+		node.info.typeVariable.unify(new UnresolvedRFunctionType(node.parameters.length));
 	}
 
 	override onProgram(node: RExpressionList<UnresolvedTypeInfo>) {
diff --git a/src/typing/types.ts b/src/typing/types.ts
index b37917923c8..566c9d487de 100644
--- a/src/typing/types.ts
+++ b/src/typing/types.ts
@@ -1,3 +1,5 @@
+import { guard } from '../util/assert';
+
 /**
  * This enum lists a tag for each of the possible R data types inferred by the
  * type inferencer. It is mainly used to identify subtypes of {@link RDataType}.
@@ -67,8 +69,37 @@ export class RNullType {
 	readonly tag = RDataTypeTag.Null;
 }
 
+export class UnresolvedRFunctionType {
+	readonly tag = RDataTypeTag.Function;
+
+	constructor(argumentCount: number) {
+		this.parameterTypes = Array.from({ length: argumentCount }, () => new RTypeVariable());
+		this.returnType = new RTypeVariable();
+	}
+
+	parameterTypes: RTypeVariable[];
+	returnType:     RTypeVariable;
+
+	unify(other: UnresolvedRFunctionType): void {
+		guard(this.parameterTypes.length === other.parameterTypes.length, 'Expected the same number of parameters for function types to unify');
+
+		for(let i = 0; i < this.parameterTypes.length; i++) {
+			this.parameterTypes[i].unify(other.parameterTypes[i]);
+		}
+		this.returnType.unify(other.returnType);
+	}
+}
+
 export class RFunctionType {
 	readonly tag = RDataTypeTag.Function;
+
+	constructor(parameterTypes: RDataType[], returnType: RDataType) {
+		this.parameterTypes = parameterTypes;
+		this.returnType = returnType;
+	}
+
+	readonly parameterTypes: RDataType[];
+	readonly returnType:     RDataType;
 }
 
 export class RListType {
@@ -110,6 +141,8 @@ export class RTypeVariable {
 			thisRep.boundType = otherRep;
 		} else if(otherRep instanceof RTypeVariable) {
 			otherRep.boundType = thisRep;
+		} else if(thisRep instanceof UnresolvedRFunctionType && otherRep instanceof UnresolvedRFunctionType && thisRep.parameterTypes.length === otherRep.parameterTypes.length) {
+			thisRep.unify(otherRep);
 		} else if(thisRep.tag !== otherRep.tag) {
 			this.boundType = new RErrorType();
 		}
@@ -126,6 +159,10 @@ export function resolveType(type: UnresolvedRDataType): RDataType {
 	if(type instanceof RTypeVariable) {
 		const typeRep = type.find();
 		return typeRep !== type ? resolveType(typeRep) : { tag: RDataTypeTag.Any };
+	} else if(type instanceof UnresolvedRFunctionType) {
+		const resolvedParameterTypes = type.parameterTypes.map(resolveType);
+		const resolvedReturnType = resolveType(type.returnType);
+		return new RFunctionType(resolvedParameterTypes, resolvedReturnType);
 	}
 	return type;
 }
@@ -139,12 +176,11 @@ export type PrimitiveRDataType
 	| RStringType
 	| RRawType
 	| RNullType
-	| RFunctionType
 	| RListType
 	| REnvironmentType
 	| RLanguageType
 
-export type CompoundRDataType = never;
+export type CompoundRDataType = RFunctionType;
 
 /**
  * The `RDataType` type is the union of all possible types that can be inferred
@@ -154,7 +190,7 @@ export type CompoundRDataType = never;
  */
 export type RDataType = RAnyType | RNeverType | PrimitiveRDataType | CompoundRDataType | RErrorType;
 
-export type UnresolvedCompoundRDataType = never;
+export type UnresolvedCompoundRDataType = UnresolvedRFunctionType;
 
 export type UnresolvedRDataType
 	= RAnyType

From 7fcd64fde42eb2a1772f5bf6494ef5731128f640 Mon Sep 17 00:00:00 2001
From: Lukas Rohde <lukas.rohde@silupe.de>
Date: Sun, 1 Jun 2025 13:51:28 +0200
Subject: [PATCH 048/153] build-fix(typing): resolve merge issues

---
 src/typing/infer.ts | 54 +++++++++++++++++++++++++++++++--------------
 1 file changed, 38 insertions(+), 16 deletions(-)

diff --git a/src/typing/infer.ts b/src/typing/infer.ts
index 5bb82b060c6..990afb0931f 100644
--- a/src/typing/infer.ts
+++ b/src/typing/infer.ts
@@ -1,4 +1,5 @@
 import { extractCfg } from '../control-flow/extract-cfg';
+import type { SemanticCfgGuidedVisitorConfiguration } from '../control-flow/semantic-cfg-guided-visitor';
 import { SemanticCfgGuidedVisitor } from '../control-flow/semantic-cfg-guided-visitor';
 import type { DataflowGraphVertexFunctionCall, DataflowGraphVertexFunctionDefinition, DataflowGraphVertexUse, DataflowGraphVertexValue } from '../dataflow/graph/vertex';
 import type { DataflowInformation } from '../dataflow/info';
@@ -16,20 +17,22 @@ import type { NodeId } from '../r-bridge/lang-4.x/ast/model/processing/node-id';
 import { edgeIncludesType, EdgeType } from '../dataflow/graph/edge';
 import { EmptyArgument } from '../r-bridge/lang-4.x/ast/model/nodes/r-function-call';
 import type { FunctionArgument } from '../dataflow/graph/graph';
+import type { ControlFlowInformation } from '../control-flow/control-flow-graph';
 import { CfgVertexType } from '../control-flow/control-flow-graph';
 import type { RSymbol } from '../r-bridge/lang-4.x/ast/model/nodes/r-symbol';
 import { RType } from '../r-bridge/lang-4.x/ast/model/type';
+import type { NoInfo } from '../r-bridge/lang-4.x/ast/model/model';
 
-export function inferDataTypes<Info extends { typeVariable?: undefined }>(ast: NormalizedAst<Info>, dataFlowInfo: DataflowInformation): NormalizedAst<Info & DataTypeInfo> {
+export function inferDataTypes<Info extends { typeVariable?: undefined }>(ast: NormalizedAst<Info>, dataflowInfo: DataflowInformation): NormalizedAst<Info & DataTypeInfo> {
 	const astWithTypeVars = decorateTypeVariables(ast);
 	const controlFlowInfo = extractCfg(astWithTypeVars);
 	const config = {
 		normalizedAst:        astWithTypeVars,
 		controlFlow:          controlFlowInfo,
-		dataflow:             dataFlowInfo,
+		dataflowInfo:         dataflowInfo,
 		defaultVisitingOrder: 'forward' as const,
 	};
-	const visitor = new TypeInferingCfgGuidedVisitor(config);
+	const visitor = new TypeInferringCfgGuidedVisitor(config);
 	visitor.start();
 
 	return resolveTypeVariables(astWithTypeVars);
@@ -54,7 +57,26 @@ function resolveTypeVariables<Info extends UnresolvedTypeInfo>(ast: NormalizedAs
 	});
 }
 
-class TypeInferingCfgGuidedVisitor extends SemanticCfgGuidedVisitor<UnresolvedTypeInfo>{
+export interface TypeInferringCfgGuidedVisitorConfiguration<
+	OtherInfo                                                 = NoInfo,
+	ControlFlow extends ControlFlowInformation                = ControlFlowInformation,
+	Ast extends NormalizedAst<UnresolvedTypeInfo & OtherInfo> = NormalizedAst<UnresolvedTypeInfo & OtherInfo>,
+	Dataflow extends DataflowInformation                      = DataflowInformation
+> extends Omit<SemanticCfgGuidedVisitorConfiguration<UnresolvedTypeInfo & OtherInfo, ControlFlow, Ast>, 'dataflow'> {
+	dataflowInfo: Dataflow;
+}
+
+class TypeInferringCfgGuidedVisitor<
+	OtherInfo                                                 = NoInfo,
+	ControlFlow extends ControlFlowInformation                = ControlFlowInformation,
+	Ast extends NormalizedAst<UnresolvedTypeInfo & OtherInfo> = NormalizedAst<UnresolvedTypeInfo & OtherInfo>,
+	Dataflow extends DataflowInformation                      = DataflowInformation,
+	Config extends TypeInferringCfgGuidedVisitorConfiguration<OtherInfo, ControlFlow, Ast, Dataflow> = TypeInferringCfgGuidedVisitorConfiguration<OtherInfo, ControlFlow, Ast, Dataflow>
+> extends SemanticCfgGuidedVisitor<UnresolvedTypeInfo & OtherInfo, ControlFlow, Ast, Dataflow['graph'], Config & { dataflow: Dataflow['graph'] }> {
+	constructor(config: Config) {
+		super({ dataflow: config.dataflowInfo.graph, ...config });
+	}
+
 	protected override onNullConstant(data: { vertex: DataflowGraphVertexValue; node: RSymbol<UnresolvedTypeInfo & ParentInformation, 'NULL'>; }): void {
 		data.node.info.typeVariable.unify(new RNullType());
 	}
@@ -111,7 +133,7 @@ class TypeInferingCfgGuidedVisitor extends SemanticCfgGuidedVisitor<UnresolvedTy
 	}
 
 	override onDefaultFunctionCall(data: { call: DataflowGraphVertexFunctionCall }): void {
-		const outgoing = this.config.dataflow.graph.outgoingEdges(data.call.id);
+		const outgoing = this.config.dataflowInfo.graph.outgoingEdges(data.call.id);
 		const callTargets = outgoing?.entries()
 			.filter(([_target, edge]) => edgeIncludesType(edge.types, EdgeType.Calls))
 			.map(([target, _edge]) => target)
@@ -185,9 +207,9 @@ class TypeInferingCfgGuidedVisitor extends SemanticCfgGuidedVisitor<UnresolvedTy
 		}
 	}
 
-	override onIfThenElseCall(data: { call: DataflowGraphVertexFunctionCall, condition: FunctionArgument, then: FunctionArgument, else: FunctionArgument | undefined }) {
-		guard(data.condition !== EmptyArgument, 'Expected condition argument to be defined');
-		const conditionNode = this.getNormalizedAst(data.condition.nodeId);
+	override onIfThenElseCall(data: { call: DataflowGraphVertexFunctionCall, condition: NodeId | undefined, then: NodeId | undefined, else: NodeId | undefined }) {
+		guard(data.condition !== undefined, 'Expected condition argument to be defined');
+		const conditionNode = this.getNormalizedAst(data.condition);
 		
 		guard(conditionNode !== undefined, 'Expected condition node to be defined');
 		conditionNode.info.typeVariable.unify(new RLogicalType());
@@ -195,10 +217,10 @@ class TypeInferingCfgGuidedVisitor extends SemanticCfgGuidedVisitor<UnresolvedTy
 		const node = this.getNormalizedAst(data.call.id);
 		guard(node !== undefined, 'Expected AST node to be defined');
 
-		if(data.then !== EmptyArgument) {
-			const isThenBranchReachable = (this.config.controlFlow.graph.ingoingEdges(data.then.nodeId)?.size ?? 0) > 0;
+		if(data.then !== undefined) {
+			const isThenBranchReachable = (this.config.controlFlow.graph.ingoingEdges(data.then)?.size ?? 0) > 0;
 			
-			const thenNode = this.getNormalizedAst(data.then.nodeId);
+			const thenNode = this.getNormalizedAst(data.then);
 			guard(thenNode !== undefined, 'Expected then node to be defined');
 
 			if(isThenBranchReachable) {
@@ -211,10 +233,10 @@ class TypeInferingCfgGuidedVisitor extends SemanticCfgGuidedVisitor<UnresolvedTy
 			node.info.typeVariable.unify(new RNullType());
 		}
 
-		if(data.else !== undefined && data.else !== EmptyArgument) {
-			const isElseBranchReachable = (this.config.controlFlow.graph.ingoingEdges(data.else.nodeId)?.size ?? 0) > 0;
+		if(data.else !== undefined) {
+			const isElseBranchReachable = (this.config.controlFlow.graph.ingoingEdges(data.else)?.size ?? 0) > 0;
 
-			const elseNode = this.getNormalizedAst(data.else.nodeId);
+			const elseNode = this.getNormalizedAst(data.else);
 			guard(elseNode !== undefined, 'Expected else node to be defined');
 
 			if(isElseBranchReachable) {
@@ -283,7 +305,7 @@ class TypeInferingCfgGuidedVisitor extends SemanticCfgGuidedVisitor<UnresolvedTy
 	}
 
 	override onProgram(node: RExpressionList<UnresolvedTypeInfo>) {
-		const exitPoints = this.config.dataflow.exitPoints;
+		const exitPoints = this.config.dataflowInfo.exitPoints;
 		const evalCandidates = exitPoints.map((exitPoint) => exitPoint.nodeId);
 
 		if(evalCandidates.length === 0) {
@@ -302,7 +324,7 @@ class TypeInferingCfgGuidedVisitor extends SemanticCfgGuidedVisitor<UnresolvedTy
 		const node = this.getNormalizedAst(data.call.id);
 		guard(node !== undefined, 'Expected AST node to be defined');
 
-		const outgoing = this.config.dataflow.graph.outgoingEdges(data.call.id);
+		const outgoing = this.config.dataflowInfo.graph.outgoingEdges(data.call.id);
 		const evalCandidates = outgoing?.entries()
 			.filter(([_target, edge]) => edgeIncludesType(edge.types, EdgeType.Returns))
 			.map(([target, _edge]) => target)

From b660b7b84493f7bcaeeb13346e4e8c3fdf68f172 Mon Sep 17 00:00:00 2001
From: Lukas Rohde <lukas.rohde@silupe.de>
Date: Sun, 1 Jun 2025 14:18:32 +0200
Subject: [PATCH 049/153] test(typing): update test cases for loops and
 conditionals

---
 test/functionality/typing/if-else-type-inference.test.ts | 2 +-
 test/functionality/typing/loop-type-inference.test.ts    | 3 +++
 2 files changed, 4 insertions(+), 1 deletion(-)

diff --git a/test/functionality/typing/if-else-type-inference.test.ts b/test/functionality/typing/if-else-type-inference.test.ts
index c6fd9735dca..e27b2b98963 100644
--- a/test/functionality/typing/if-else-type-inference.test.ts
+++ b/test/functionality/typing/if-else-type-inference.test.ts
@@ -8,7 +8,7 @@ describe('Infer types for if statements', () => {
 	describe.each([
 		{ input: 'if(FALSE) { TRUE }',           expectedType: { tag: RDataTypeTag.Null as const } },
 		{ input: 'if(TRUE) { 1 } else { NULL }', expectedType: { tag: RDataTypeTag.Integer as const } },
-		// { input: 'if(return()) { 1 } else { NULL }', expectedType: { tag: RDataTypeTag.Never as const } },
+		{ input: 'if(stop("stop here")) { 1 } else { 2 }', expectedType: { tag: RDataTypeTag.Never as const } },
 	])('Infer $expectedType for $input', ({ input, expectedType }) => assertInferredType(input, expectedType));
 
 	assertInferredTypes(
diff --git a/test/functionality/typing/loop-type-inference.test.ts b/test/functionality/typing/loop-type-inference.test.ts
index 14ac00805b0..159cab3c5fb 100644
--- a/test/functionality/typing/loop-type-inference.test.ts
+++ b/test/functionality/typing/loop-type-inference.test.ts
@@ -7,10 +7,13 @@ import { RType } from '../../../src/r-bridge/lang-4.x/ast/model/type';
 describe('Infer types for loops', () => {
 	describe.each([
 		{ input: 'while(FALSE) { print("Testing is fun!") }',                         expectedType: { tag: RDataTypeTag.Null as const } },
+		{ input: 'while(TRUE) { next }',                                              expectedType: { tag: RDataTypeTag.Never as const } },
+		{ input: 'while(1 < 2) { print("Hi Flo!") }',                                 expectedType: { tag: RDataTypeTag.Never as const } },
 		{ input: 'while(TRUE) { break }',                                             expectedType: { tag: RDataTypeTag.Null as const } },
 		{ input: 'for(i in NULL) { print("I would like to write a test for that") }', expectedType: { tag: RDataTypeTag.Null as const } },
 		{ input: 'for(i in 1:10) { print(i) }',                                       expectedType: { tag: RDataTypeTag.Null as const } },
 		{ input: 'repeat { print("I love testing!") }',                               expectedType: { tag: RDataTypeTag.Never as const } },
+		{ input: 'repeat { break }',                                                  expectedType: { tag: RDataTypeTag.Null as const } }
 	])('Infer $expectedType for $input', ({ input, expectedType }) => assertInferredType(input, expectedType));
 
 	assertInferredTypes(

From 92f3f717fc3d10e1b6317a0bfe647c03c4e9d340 Mon Sep 17 00:00:00 2001
From: Lukas Rohde <86918771+loki259@users.noreply.github.com>
Date: Sun, 1 Jun 2025 21:25:12 +0200
Subject: [PATCH 050/153] Add A Query Type For Querying Data Types (#1707)

* feat(cli): add repl command for extracting inferred types from ast nodes

* feat(query-api): implement 'datatype' query

* refactor(repl): remove datatype repl command in favor of related query

* feat(query-api): make criterion in datatype query optional

* refactor(query-api): simplify datatype query implementation

* doc(datatype-query): add to wiki

* refactor(query): supply flatting op

* doc(query): bum pquery api wiki

---------

Co-authored-by: Florian Sihler <florian.sihler@uni-ulm.de>
---
 src/documentation/print-query-wiki.ts         |  25 ++
 .../datatype-query/datatype-query-executor.ts |  29 ++
 .../datatype-query/datatype-query-format.ts   |  42 +++
 src/queries/query-print.ts                    |   9 +
 src/queries/query.ts                          |   3 +
 wiki/Query API.md                             | 262 ++++++++++++------
 6 files changed, 286 insertions(+), 84 deletions(-)
 create mode 100644 src/queries/catalog/datatype-query/datatype-query-executor.ts
 create mode 100644 src/queries/catalog/datatype-query/datatype-query-format.ts

diff --git a/src/documentation/print-query-wiki.ts b/src/documentation/print-query-wiki.ts
index d7445ff931d..76325ef767b 100644
--- a/src/documentation/print-query-wiki.ts
+++ b/src/documentation/print-query-wiki.ts
@@ -36,6 +36,7 @@ import { Q } from '../search/flowr-search-builder';
 import { VertexType } from '../dataflow/graph/vertex';
 import { getTypesFromFolderAsMermaid, shortLink } from './doc-util/doc-types';
 import path from 'path';
+import { executeDatatypeQuery } from '../queries/catalog/datatype-query/datatype-query-executor';
 
 
 registerQueryDocumentation('call-context', {
@@ -481,6 +482,30 @@ This query replaces the old [\`request-slice\`](${FlowrWikiBaseRef}/Interface#me
 	}
 });
 
+
+registerQueryDocumentation('datatype', {
+	name:             'Datatype Query',
+	type:             'active',
+	shortDescription: 'Returns all datatypes for syntactic elements (or the type for a criterion).',
+	functionName:     executeDatatypeQuery.name,
+	functionFile:     '../queries/catalog/datatype-query/datatype-query-executor.ts',
+	buildExplanation: async(shell: RShell) => {
+		const exampleCode = 'x <- 1\ny <- 2\nx';
+		return `
+This query returns the datatypes of syntactic elements in the code.
+To exemplify the capabilities, consider the following code:
+${codeBlock('r', exampleCode)}
+To see the type of the variable \`x\`, you can use the following query:
+${
+	await showQuery(shell, exampleCode, [{
+		type:      'datatype',
+		criterion: '3@x'
+	}], { showCode: false })
+}
+`;
+	}
+});
+
 registerQueryDocumentation('dependencies', {
 	name:             'Dependencies Query',
 	type:             'active',
diff --git a/src/queries/catalog/datatype-query/datatype-query-executor.ts b/src/queries/catalog/datatype-query/datatype-query-executor.ts
new file mode 100644
index 00000000000..adfbc2c7ec9
--- /dev/null
+++ b/src/queries/catalog/datatype-query/datatype-query-executor.ts
@@ -0,0 +1,29 @@
+import type { DatatypeQuery, DatatypeQueryResult } from './datatype-query-format';
+import { log } from '../../../util/log';
+import type { BasicQueryData } from '../../base-query-format';
+import type { NormalizedAst } from '../../../r-bridge/lang-4.x/ast/model/processing/decorate';
+import { slicingCriterionToId } from '../../../slicing/criterion/parse';
+import { inferDataTypes } from '../../../typing/infer';
+
+export function executeDatatypeQuery({ dataflow, ast }: BasicQueryData, queries: readonly DatatypeQuery[]): DatatypeQueryResult {
+	const start = Date.now();
+	const result: DatatypeQueryResult['inferredTypes'] = {};
+	for(const { criterion } of queries) {
+		if(result[criterion ?? '1:1'] !== undefined) {
+			log.warn('Duplicate criterion in datatype query:', criterion);
+			continue;
+		}
+		const typedAst = inferDataTypes(ast as NormalizedAst<{ typeVariable?: undefined }>, dataflow);
+		const node = criterion !== undefined ? typedAst.idMap.get(slicingCriterionToId(criterion, typedAst.idMap)) : typedAst.ast;
+		if(node === undefined) {
+			log.warn('Criterion not found in normalized AST:', criterion);
+			continue;
+		}
+		result[criterion ?? '1:1'] = node.info.inferredType;
+	}
+
+	return {
+		'.meta':       { timing: Date.now() - start },
+		inferredTypes: result
+	};
+}
diff --git a/src/queries/catalog/datatype-query/datatype-query-format.ts b/src/queries/catalog/datatype-query/datatype-query-format.ts
new file mode 100644
index 00000000000..1254ef03fc2
--- /dev/null
+++ b/src/queries/catalog/datatype-query/datatype-query-format.ts
@@ -0,0 +1,42 @@
+import type { BaseQueryFormat, BaseQueryResult } from '../../base-query-format';
+import type { SingleSlicingCriterion } from '../../../slicing/criterion/parse';
+import type { QueryResults, SupportedQuery } from '../../query';
+import { bold } from '../../../util/text/ansi';
+import { printAsMs } from '../../../util/text/time';
+import Joi from 'joi';
+import { executeDatatypeQuery } from './datatype-query-executor';
+
+import { asciiDataType } from '../../query-print';
+import type { RDataType } from '../../../typing/types';
+
+/**
+ * Calculates the inferred data type for the given criterion.
+ */
+export interface DatatypeQuery extends BaseQueryFormat {
+	readonly type:       'datatype';
+	readonly criterion?: SingleSlicingCriterion;
+}
+
+export interface DatatypeQueryResult extends BaseQueryResult {
+	/** Maps each criterion to the inferred data type, duplicates are ignored. */
+	readonly inferredTypes: Record<SingleSlicingCriterion, RDataType>;
+}
+
+export const DatatypeQueryDefinition = {
+	executor:        executeDatatypeQuery,
+	asciiSummarizer: (formatter, _processed, queryResults, result) => {
+		const out = queryResults as QueryResults<'datatype'>['datatype'];
+		result.push(`Query: ${bold('datatype', formatter)} (${printAsMs(out['.meta'].timing, 0)})`);
+		for(const [criterion, inferredType] of Object.entries(out.inferredTypes)) {
+			result.push(`   ╰ ${criterion}: {${asciiDataType(inferredType)}}`);
+		}
+		return true;
+	},
+	flattenInvolvedNodes: () => {
+		return [];
+	},
+	schema: Joi.object({
+		type:      Joi.string().valid('datatype').required().description('The type of the query.'),
+		criterion: Joi.string().optional().description('The slicing criterion of the node to get the inferred data type for.')
+	}).description('Datatype query used to extract the inferred data type for a node in the normalized AST')
+} as const satisfies SupportedQuery<'datatype'>;
diff --git a/src/queries/query-print.ts b/src/queries/query-print.ts
index ff6eabb951f..bda6df1dfdd 100644
--- a/src/queries/query-print.ts
+++ b/src/queries/query-print.ts
@@ -10,6 +10,7 @@ import type { CallContextQuerySubKindResult } from './catalog/call-context-query
 import type { BaseQueryMeta, BaseQueryResult } from './base-query-format';
 import { printAsMs } from '../util/text/time';
 import { isBuiltIn } from '../dataflow/environments/built-in';
+import { RDataTypeTag, type RDataType } from '../typing/types';
 
 function nodeString(nodeId: NodeId | { id: NodeId, info?: object}, formatter: OutputFormatter, processed: PipelineOutput<typeof DEFAULT_DATAFLOW_PIPELINE>): string {
 	const isObj = typeof nodeId === 'object' && nodeId !== null && 'id' in nodeId;
@@ -76,6 +77,14 @@ export function summarizeIdsIfTooLong(formatter: OutputFormatter, ids: readonly
 	return formatter === markdownFormatter ? textWithTooltip(acc, JSON.stringify(ids)) : acc;
 }
 
+export function asciiDataType(type: RDataType): string {
+	if(type.tag === RDataTypeTag.Function) {
+		return `Function(${type.parameterTypes.map(t => asciiDataType(t)).join(', ')}) -> ${asciiDataType(type.returnType)}`;
+	} else {
+		return type.tag;
+	}
+}
+
 export function asciiSummaryOfQueryResult(formatter: OutputFormatter, totalInMs: number, results: QueryResults<SupportedQueryTypes>, processed: PipelineOutput<typeof DEFAULT_DATAFLOW_PIPELINE>): string {
 	const result: string[] = [];
 
diff --git a/src/queries/query.ts b/src/queries/query.ts
index 4bdf88ac02b..7e25f94cced 100644
--- a/src/queries/query.ts
+++ b/src/queries/query.ts
@@ -46,6 +46,7 @@ import { OriginQueryDefinition } from './catalog/origin-query/origin-query-forma
 import type { LinterQuery } from './catalog/linter-query/linter-query-format';
 import { LinterQueryDefinition } from './catalog/linter-query/linter-query-format';
 import type { NodeId } from '../r-bridge/lang-4.x/ast/model/processing/node-id';
+import { DatatypeQueryDefinition, type DatatypeQuery } from './catalog/datatype-query/datatype-query-format';
 
 export type Query = CallContextQuery
 	| ConfigQuery
@@ -57,6 +58,7 @@ export type Query = CallContextQuery
 	| DataflowClusterQuery
 	| StaticSliceQuery
 	| LineageQuery
+	| DatatypeQuery
 	| DependenciesQuery
 	| LocationMapQuery
 	| HappensBeforeQuery
@@ -96,6 +98,7 @@ export const SupportedQueries = {
 	'dataflow-cluster': ClusterQueryDefinition,
 	'static-slice':     StaticSliceQueryDefinition,
 	'lineage':          LineageQueryDefinition,
+	'datatype':         DatatypeQueryDefinition,
 	'dependencies':     DependenciesQueryDefinition,
 	'location-map':     LocationMapQueryDefinition,
 	'search':           SearchQueryDefinition,
diff --git a/wiki/Query API.md b/wiki/Query API.md
index 5406310c995..1b9a53cb7f0 100644
--- a/wiki/Query API.md	
+++ b/wiki/Query API.md	
@@ -1,4 +1,4 @@
-_This document was generated from '[src/documentation/print-query-wiki.ts](https://github.com/flowr-analysis/flowr/tree/main//src/documentation/print-query-wiki.ts)' on 2025-05-31, 15:34:04 UTC presenting an overview of flowR's query API (v2.2.13, using R v4.4.3). Please do not edit this file/wiki page directly._
+_This document was generated from '[src/documentation/print-query-wiki.ts](https://github.com/flowr-analysis/flowr/tree/main//src/documentation/print-query-wiki.ts)' on 2025-06-01, 19:20:45 UTC presenting an overview of flowR's query API (v2.2.14, using R v4.5.0). Please do not edit this file/wiki page directly._
 
 This page briefly summarizes flowR's query API, represented by the executeQueries function in [`./src/queries/query.ts`](https://github.com/flowr-analysis/flowr/tree/main/./src/queries/query.ts).
 Please see the [Interface](https://github.com/flowr-analysis/flowr/wiki/Interface) wiki page for more information on how to access this API.
@@ -29,6 +29,8 @@ For now, we support the following **active** queries (which we will refer to sim
     Calculates and returns all the clusters present in the dataflow graph.
 1. [Dataflow Query](#dataflow-query) (`dataflow`):\
     Returns the dataflow graph of the given code.
+1. [Datatype Query](#datatype-query) (`datatype`):\
+    Returns all datatypes for syntactic elements (or the type for a criterion).
 1. [Dependencies Query](#dependencies-query) (`dependencies`):\
     Returns all direct dependencies (in- and outputs) of a given R script
 1. [Happens-Before Query](#happens-before-query) (`happens-before`):\
@@ -175,6 +177,13 @@ Valid item types:
                     Allows only the values: 'lineage'
                 - **criterion** string [required]
                     _The slicing criterion of the node to get the lineage of._
+            - **.** object 
+                _Datatype query used to extract the inferred data type for a node in the normalized AST_
+                - **type** string [required]
+                    _The type of the query._
+                    Allows only the values: 'datatype'
+                - **criterion** string [optional]
+                    _The slicing criterion of the node to get the inferred data type for._
             - **.** object 
                 _The dependencies query retrieves and returns the set of all dependencies in the dataflow graph, which includes libraries, sourced files, read data, and written data._
                 - **type** string [required]
@@ -665,7 +674,7 @@ points`"]
 ```
 
 	
-(The analysis required _26.9 ms_ (including parse and normalize, using the [r-shell](https://github.com/flowr-analysis/flowr/wiki/Engines) engine) within the generation environment.)
+(The analysis required _11.8 ms_ (including parse and normalize, using the [r-shell](https://github.com/flowr-analysis/flowr/wiki/Engines) engine) within the generation environment.)
 
 
 
@@ -706,14 +715,14 @@ Just as an example, the following [Call-Context Query](#call-context-query) find
 
 _Results (prettified and summarized):_
 
-Query: **call-context** (1 ms)\
+Query: **call-context** (0 ms)\
 &nbsp;&nbsp;&nbsp;╰ **input**\
 &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;╰ **csv-file**: _`read_csv`_ (L.6), _`read_csv`_ (L.7)\
-_All queries together required ≈1 ms (1ms accuracy, total 10 ms)_
+_All queries together required ≈0 ms (1ms accuracy, total 4 ms)_
 
 <details> <summary style="color:gray">Show Detailed Results as Json</summary>
 
-The analysis required _9.8 ms_ (including parsing and normalization and the query) within the generation environment.	
+The analysis required _4.1 ms_ (including parsing and normalization and the query) within the generation environment.	
 
 In general, the JSON contains the Ids of the nodes in question as they are present in the normalized AST or the dataflow graph of flowR.
 Please consult the [Interface](https://github.com/flowr-analysis/flowr/wiki/Interface) wiki page for more information on how to get those.
@@ -725,7 +734,7 @@ Please consult the [Interface](https://github.com/flowr-analysis/flowr/wiki/Inte
 {
   "call-context": {
     ".meta": {
-      "timing": 1
+      "timing": 0
     },
     "kinds": {
       "input": {
@@ -747,7 +756,7 @@ Please consult the [Interface](https://github.com/flowr-analysis/flowr/wiki/Inte
     }
   },
   ".meta": {
-    "timing": 1
+    "timing": 0
   }
 }
 ```
@@ -827,17 +836,17 @@ all calls that start with `read_` to the kind `input` but only if they are not l
 
 _Results (prettified and summarized):_
 
-Query: **call-context** (2 ms)\
+Query: **call-context** (1 ms)\
 &nbsp;&nbsp;&nbsp;╰ **input**\
 &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;╰ **csv-file**: _`read_csv`_ (L.6), _`read_csv`_ (L.7)\
 &nbsp;&nbsp;&nbsp;╰ **visualize**\
 &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;╰ **text**: _`mean`_ (L.9), _`mean`_ (L.19)\
 &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;╰ **plot**: _`points`_ (L.17) with 1 link (_`plot`_ (L.16))\
-_All queries together required ≈2 ms (1ms accuracy, total 13 ms)_
+_All queries together required ≈1 ms (1ms accuracy, total 7 ms)_
 
 <details> <summary style="color:gray">Show Detailed Results as Json</summary>
 
-The analysis required _13.0 ms_ (including parsing and normalization and the query) within the generation environment.	
+The analysis required _7.5 ms_ (including parsing and normalization and the query) within the generation environment.	
 
 In general, the JSON contains the Ids of the nodes in question as they are present in the normalized AST or the dataflow graph of flowR.
 Please consult the [Interface](https://github.com/flowr-analysis/flowr/wiki/Interface) wiki page for more information on how to get those.
@@ -849,7 +858,7 @@ Please consult the [Interface](https://github.com/flowr-analysis/flowr/wiki/Inte
 {
   "call-context": {
     ".meta": {
-      "timing": 2
+      "timing": 1
     },
     "kinds": {
       "input": {
@@ -894,7 +903,7 @@ Please consult the [Interface](https://github.com/flowr-analysis/flowr/wiki/Inte
     }
   },
   ".meta": {
-    "timing": 2
+    "timing": 1
   }
 }
 ```
@@ -943,14 +952,14 @@ Now let's say we want to query _all_ uses of the `my_test_function`:
 
 _Results (prettified and summarized):_
 
-Query: **call-context** (1 ms)\
+Query: **call-context** (0 ms)\
 &nbsp;&nbsp;&nbsp;╰ **.**\
 &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;╰ **.**: _`foo`_ (L.2) with 1 alias root (_`my_test_function`_ (L.1)), _`bar`_ (L.4) with 1 alias root (_`my_test_function`_ (L.1))\
-_All queries together required ≈1 ms (1ms accuracy, total 5 ms)_
+_All queries together required ≈0 ms (1ms accuracy, total 3 ms)_
 
 <details> <summary style="color:gray">Show Detailed Results as Json</summary>
 
-The analysis required _4.8 ms_ (including parsing and normalization and the query) within the generation environment.	
+The analysis required _2.9 ms_ (including parsing and normalization and the query) within the generation environment.	
 
 In general, the JSON contains the Ids of the nodes in question as they are present in the normalized AST or the dataflow graph of flowR.
 Please consult the [Interface](https://github.com/flowr-analysis/flowr/wiki/Interface) wiki page for more information on how to get those.
@@ -962,7 +971,7 @@ Please consult the [Interface](https://github.com/flowr-analysis/flowr/wiki/Inte
 {
   "call-context": {
     ".meta": {
-      "timing": 1
+      "timing": 0
     },
     "kinds": {
       ".": {
@@ -988,7 +997,7 @@ Please consult the [Interface](https://github.com/flowr-analysis/flowr/wiki/Inte
     }
   },
   ".meta": {
-    "timing": 1
+    "timing": 0
   }
 }
 ```
@@ -1068,11 +1077,11 @@ _Results (prettified and summarized):_
 Query: **dataflow-cluster** (0ms)\
 &nbsp;&nbsp;&nbsp;╰ Found 1 cluster\
 &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;╰  {3, 0, 1, 2} ([marked](https://mermaid.live/view#base64:eyJjb2RlIjoiZmxvd2NoYXJ0IEJUXG4gICAgMXt7XCJgIzkxO1JOdW1iZXIjOTM7IDFcbiAgICAgICgxKVxuICAgICAgKjEuNipgXCJ9fVxuICAgIDBbXCJgIzkxO1JTeW1ib2wjOTM7IHhcbiAgICAgICgwKVxuICAgICAgKjEuMSpgXCJdXG4gICAgMltbXCJgIzkxO1JCaW5hcnlPcCM5MzsgIzYwOyM0NTtcbiAgICAgICgyKVxuICAgICAgKjEuMS02KlxuICAgICgwLCAxKWBcIl1dXG4gICAgYnVpbHQtaW46Xy1bXCJgQnVpbHQtSW46XG4jNjA7IzQ1O2BcIl1cbiAgICBzdHlsZSBidWlsdC1pbjpfLSBzdHJva2U6Z3JheSxmaWxsOmxpZ2h0Z3JheSxzdHJva2Utd2lkdGg6MnB4LG9wYWNpdHk6Ljg7XG4gICAgMyhbXCJgIzkxO1JTeW1ib2wjOTM7IHhcbiAgICAgICgzKVxuICAgICAgKjEuOSpgXCJdKVxuICAgIDAgLS0+fFwiZGVmaW5lZC1ieVwifCAxXG4gICAgMCAtLT58XCJkZWZpbmVkLWJ5XCJ8IDJcbiAgICAyIC0tPnxcImFyZ3VtZW50XCJ8IDFcbiAgICAyIC0tPnxcInJldHVybnMsIGFyZ3VtZW50XCJ8IDBcbiAgICAyIC0uLT58XCJyZWFkcywgY2FsbHNcInwgYnVpbHQtaW46Xy1cbiAgICBsaW5rU3R5bGUgNCBzdHJva2U6Z3JheTtcbiAgICAzIC0tPnxcInJlYWRzXCJ8IDAiLCJtZXJtYWlkIjp7ImF1dG9TeW5jIjp0cnVlfX0=))\
-_All queries together required ≈0 ms (1ms accuracy, total 2 ms)_
+_All queries together required ≈0 ms (1ms accuracy, total 1 ms)_
 
 <details> <summary style="color:gray">Show Detailed Results as Json</summary>
 
-The analysis required _2.1 ms_ (including parsing and normalization and the query) within the generation environment.	
+The analysis required _1.1 ms_ (including parsing and normalization and the query) within the generation environment.	
 
 In general, the JSON contains the Ids of the nodes in question as they are present in the normalized AST or the dataflow graph of flowR.
 Please consult the [Interface](https://github.com/flowr-analysis/flowr/wiki/Interface) wiki page for more information on how to get those.
@@ -1140,11 +1149,11 @@ Query: **dataflow-cluster** (0ms)\
 &nbsp;&nbsp;&nbsp;╰ Found 2 clusters\
 &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;╰  {3} ([marked](https://mermaid.live/view#base64:eyJjb2RlIjoiZmxvd2NoYXJ0IEJUXG4gICAgMXt7XCJgIzkxO1JOdW1iZXIjOTM7IDFcbiAgICAgICgxKVxuICAgICAgKjEuNipgXCJ9fVxuICAgIDBbXCJgIzkxO1JTeW1ib2wjOTM7IHhcbiAgICAgICgwKVxuICAgICAgKjEuMSpgXCJdXG4gICAgMltbXCJgIzkxO1JCaW5hcnlPcCM5MzsgIzYwOyM0NTtcbiAgICAgICgyKVxuICAgICAgKjEuMS02KlxuICAgICgwLCAxKWBcIl1dXG4gICAgYnVpbHQtaW46Xy1bXCJgQnVpbHQtSW46XG4jNjA7IzQ1O2BcIl1cbiAgICBzdHlsZSBidWlsdC1pbjpfLSBzdHJva2U6Z3JheSxmaWxsOmxpZ2h0Z3JheSxzdHJva2Utd2lkdGg6MnB4LG9wYWNpdHk6Ljg7XG4gICAgMyhbXCJgIzkxO1JTeW1ib2wjOTM7IHlcbiAgICAgICgzKVxuICAgICAgKjEuOSpgXCJdKVxuICAgIDAgLS0+fFwiZGVmaW5lZC1ieVwifCAxXG4gICAgMCAtLT58XCJkZWZpbmVkLWJ5XCJ8IDJcbiAgICAyIC0tPnxcImFyZ3VtZW50XCJ8IDFcbiAgICAyIC0tPnxcInJldHVybnMsIGFyZ3VtZW50XCJ8IDBcbiAgICAyIC0uLT58XCJyZWFkcywgY2FsbHNcInwgYnVpbHQtaW46Xy1cbiAgICBsaW5rU3R5bGUgNCBzdHJva2U6Z3JheTsiLCJtZXJtYWlkIjp7ImF1dG9TeW5jIjp0cnVlfX0=))\
 &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;╰  {2, 1, 0} ([marked](https://mermaid.live/view#base64:eyJjb2RlIjoiZmxvd2NoYXJ0IEJUXG4gICAgMXt7XCJgIzkxO1JOdW1iZXIjOTM7IDFcbiAgICAgICgxKVxuICAgICAgKjEuNipgXCJ9fVxuICAgIDBbXCJgIzkxO1JTeW1ib2wjOTM7IHhcbiAgICAgICgwKVxuICAgICAgKjEuMSpgXCJdXG4gICAgMltbXCJgIzkxO1JCaW5hcnlPcCM5MzsgIzYwOyM0NTtcbiAgICAgICgyKVxuICAgICAgKjEuMS02KlxuICAgICgwLCAxKWBcIl1dXG4gICAgYnVpbHQtaW46Xy1bXCJgQnVpbHQtSW46XG4jNjA7IzQ1O2BcIl1cbiAgICBzdHlsZSBidWlsdC1pbjpfLSBzdHJva2U6Z3JheSxmaWxsOmxpZ2h0Z3JheSxzdHJva2Utd2lkdGg6MnB4LG9wYWNpdHk6Ljg7XG4gICAgMyhbXCJgIzkxO1JTeW1ib2wjOTM7IHlcbiAgICAgICgzKVxuICAgICAgKjEuOSpgXCJdKVxuICAgIDAgLS0+fFwiZGVmaW5lZC1ieVwifCAxXG4gICAgMCAtLT58XCJkZWZpbmVkLWJ5XCJ8IDJcbiAgICAyIC0tPnxcImFyZ3VtZW50XCJ8IDFcbiAgICAyIC0tPnxcInJldHVybnMsIGFyZ3VtZW50XCJ8IDBcbiAgICAyIC0uLT58XCJyZWFkcywgY2FsbHNcInwgYnVpbHQtaW46Xy1cbiAgICBsaW5rU3R5bGUgNCBzdHJva2U6Z3JheTsiLCJtZXJtYWlkIjp7ImF1dG9TeW5jIjp0cnVlfX0=))\
-_All queries together required ≈0 ms (1ms accuracy, total 2 ms)_
+_All queries together required ≈0 ms (1ms accuracy, total 1 ms)_
 
 <details> <summary style="color:gray">Show Detailed Results as Json</summary>
 
-The analysis required _1.6 ms_ (including parsing and normalization and the query) within the generation environment.	
+The analysis required _0.9 ms_ (including parsing and normalization and the query) within the generation environment.	
 
 In general, the JSON contains the Ids of the nodes in question as they are present in the normalized AST or the dataflow graph of flowR.
 Please consult the [Interface](https://github.com/flowr-analysis/flowr/wiki/Interface) wiki page for more information on how to get those.
@@ -1216,11 +1225,11 @@ Query: **dataflow-cluster** (0ms)\
 &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;╰ (has unknown side effect) {11, 9} ([marked](https://mermaid.live/view#base64:{"code":"flowchart BT\n    1{{\"`#91;RSymbol#93; ggplot\n      (1)\n      *1.9-14*`\"}}\n    3[[\"`#91;RFunctionCall#93; library\n      (3)\n      *1.1-15*\n    (1)`\"]]\n    style 3 stroke:red,stroke-width:5px; \n    built-in:library[\"`Built-In:\nlibrary`\"]\n    style built-in:library stroke:gray,fill:lightgray,stroke-width:2px,opacity:.8;\n    5{{\"`#91;RSymbol#93; dplyr\n      (5)\n      *2.9-13*`\"}}\n    7[[\"`#91;RFunctionCall#93; library\n      (7)\n      *2.1-14*\n    (5)`\"]]\n    style 7 stroke:red,stroke-width:5px; \n    9{{\"`#91;RSymbol#93; readr\n      (9)\n      *3.9-13*`\"}}\n    11[[\"`#91;RFunctionCall#93; library\n      (11)\n      *3.1-14*\n    (9)`\"]]\n    style 11 stroke:red,stroke-width:5px; \n    14{{\"`#91;RString#93; #39;data.csv#39;\n      (14)\n      *6.18-27*`\"}}\n    16[[\"`#91;RFunctionCall#93; read#95;csv\n      (16)\n      *6.9-28*\n    (14)`\"]]\n    12[\"`#91;RSymbol#93; data\n      (12)\n      *6.1-4*`\"]\n    17[[\"`#91;RBinaryOp#93; #60;#45;\n      (17)\n      *6.1-28*\n    (12, 16)`\"]]\n    built-in:_-[\"`Built-In:\n#60;#45;`\"]\n    style built-in:_- stroke:gray,fill:lightgray,stroke-width:2px,opacity:.8;\n    20{{\"`#91;RString#93; #39;data2.csv#39;\n      (20)\n      *7.19-29*`\"}}\n    22[[\"`#91;RFunctionCall#93; read#95;csv\n      (22)\n      *7.10-30*\n    (20)`\"]]\n    18[\"`#91;RSymbol#93; data2\n      (18)\n      *7.1-5*`\"]\n    23[[\"`#91;RBinaryOp#93; #60;#45;\n      (23)\n      *7.1-30*\n    (18, 22)`\"]]\n    26([\"`#91;RSymbol#93; data\n      (26)\n      *9.11-14*`\"])\n    27{{\"`#91;RSymbol#93; x\n      (27)\n      *9.11-16*`\"}}\n    29[[\"`#91;RAccess#93; $\n      (29)\n      *9.11-16*\n    (26, 27)`\"]]\n    built-in:_[\"`Built-In:\n$`\"]\n    style built-in:_ stroke:gray,fill:lightgray,stroke-width:2px,opacity:.8;\n    31[[\"`#91;RFunctionCall#93; mean\n      (31)\n      *9.6-17*\n    (29)`\"]]\n    built-in:mean[\"`Built-In:\nmean`\"]\n    style built-in:mean stroke:gray,fill:lightgray,stroke-width:2px,opacity:.8;\n    24[\"`#91;RSymbol#93; m\n      (24)\n      *9.1*`\"]\n    32[[\"`#91;RBinaryOp#93; #60;#45;\n      (32)\n      *9.1-17*\n    (24, 31)`\"]]\n    34([\"`#91;RSymbol#93; m\n      (34)\n      *10.7*`\"])\n    36[[\"`#91;RFunctionCall#93; print\n      (36)\n      *10.1-8*\n    (34)`\"]]\n    built-in:print[\"`Built-In:\nprint`\"]\n    style built-in:print stroke:gray,fill:lightgray,stroke-width:2px,opacity:.8;\n    38([\"`#91;RSymbol#93; data\n      (38)\n      *12.1-4*`\"])\n    43([\"`#91;RSymbol#93; x\n      (43)\n      *13.24*`\"])\n    44([\"`#91;RArgument#93; x\n      (44)\n      *13.20*`\"])\n    46([\"`#91;RSymbol#93; y\n      (46)\n      *13.31*`\"])\n    47([\"`#91;RArgument#93; y\n      (47)\n      *13.27*`\"])\n    48[[\"`#91;RFunctionCall#93; aes\n      (48)\n      *13.16-32*\n    (x (44), y (47))`\"]]\n    50[[\"`#91;RFunctionCall#93; ggplot\n      (50)\n      *13.9-33*\n    (38, 48)`\"]]\n    built-in:ggplot[\"`Built-In:\nggplot`\"]\n    style built-in:ggplot stroke:gray,fill:lightgray,stroke-width:2px,opacity:.8;\n    52[[\"`#91;RFunctionCall#93; data %#62;%\n\tggplot(aes(x = x, y = y))\n      (52)\n      *12.6-8*\n    (38, 50)`\"]]\n    built-in:___[\"`Built-In:\n%#62;%`\"]\n    style built-in:___ stroke:gray,fill:lightgray,stroke-width:2px,opacity:.8;\n    54[[\"`#91;RFunctionCall#93; geom#95;point\n      (54)\n      *14.9-20*`\"]]\n    built-in:geom_point[\"`Built-In:\ngeom#95;point`\"]\n    style built-in:geom_point stroke:gray,fill:lightgray,stroke-width:2px,opacity:.8;\n    55[[\"`#91;RBinaryOp#93; #43;\n      (55)\n      *12.1-14.20*\n    (52, 54)`\"]]\n    57([\"`#91;RSymbol#93; data2\n      (57)\n      *16.6-10*`\"])\n    58{{\"`#91;RSymbol#93; x\n      (58)\n      *16.6-12*`\"}}\n    60[[\"`#91;RAccess#93; $\n      (60)\n      *16.6-12*\n    (57, 58)`\"]]\n    62([\"`#91;RSymbol#93; data2\n      (62)\n      *16.15-19*`\"])\n    63{{\"`#91;RSymbol#93; y\n      (63)\n      *16.15-21*`\"}}\n    65[[\"`#91;RAccess#93; $\n      (65)\n      *16.15-21*\n    (62, 63)`\"]]\n    67[[\"`#91;RFunctionCall#93; plot\n      (67)\n      *16.1-22*\n    (60, 65)`\"]]\n    built-in:plot[\"`Built-In:\nplot`\"]\n    style built-in:plot stroke:gray,fill:lightgray,stroke-width:2px,opacity:.8;\n    69([\"`#91;RSymbol#93; data2\n      (69)\n      *17.8-12*`\"])\n    70{{\"`#91;RSymbol#93; x\n      (70)\n      *17.8-14*`\"}}\n    72[[\"`#91;RAccess#93; $\n      (72)\n      *17.8-14*\n    (69, 70)`\"]]\n    74([\"`#91;RSymbol#93; data2\n      (74)\n      *17.17-21*`\"])\n    75{{\"`#91;RSymbol#93; y\n      (75)\n      *17.17-23*`\"}}\n    77[[\"`#91;RAccess#93; $\n      (77)\n      *17.17-23*\n    (74, 75)`\"]]\n    79[[\"`#91;RFunctionCall#93; points\n      (79)\n      *17.1-24*\n    (72, 77)`\"]]\n    built-in:points[\"`Built-In:\npoints`\"]\n    style built-in:points stroke:gray,fill:lightgray,stroke-width:2px,opacity:.8;\n    82([\"`#91;RSymbol#93; data2\n      (82)\n      *19.12-16*`\"])\n    83{{\"`#91;RSymbol#93; k\n      (83)\n      *19.12-18*`\"}}\n    85[[\"`#91;RAccess#93; $\n      (85)\n      *19.12-18*\n    (82, 83)`\"]]\n    87[[\"`#91;RFunctionCall#93; mean\n      (87)\n      *19.7-19*\n    (85)`\"]]\n    89[[\"`#91;RFunctionCall#93; print\n      (89)\n      *19.1-20*\n    (87)`\"]]\n    3 -->|\"argument\"| 1\n    3 -.->|\"reads, calls\"| built-in:library\n    linkStyle 1 stroke:gray;\n    7 -->|\"argument\"| 5\n    7 -.->|\"reads, calls\"| built-in:library\n    linkStyle 3 stroke:gray;\n    11 -->|\"argument\"| 9\n    11 -.->|\"reads, calls\"| built-in:library\n    linkStyle 5 stroke:gray;\n    16 -->|\"argument\"| 14\n    12 -->|\"defined-by\"| 16\n    12 -->|\"defined-by\"| 17\n    17 -->|\"argument\"| 16\n    17 -->|\"returns, argument\"| 12\n    17 -.->|\"reads, calls\"| built-in:_-\n    linkStyle 11 stroke:gray;\n    22 -->|\"argument\"| 20\n    18 -->|\"defined-by\"| 22\n    18 -->|\"defined-by\"| 23\n    23 -->|\"argument\"| 22\n    23 -->|\"returns, argument\"| 18\n    23 -.->|\"reads, calls\"| built-in:_-\n    linkStyle 17 stroke:gray;\n    26 -->|\"reads\"| 12\n    29 -->|\"reads, returns, argument\"| 26\n    29 -->|\"reads, argument\"| 27\n    29 -.->|\"reads, calls\"| built-in:_\n    linkStyle 21 stroke:gray;\n    31 -->|\"reads, argument\"| 29\n    31 -.->|\"reads, calls\"| built-in:mean\n    linkStyle 23 stroke:gray;\n    24 -->|\"defined-by\"| 31\n    24 -->|\"defined-by\"| 32\n    32 -->|\"argument\"| 31\n    32 -->|\"returns, argument\"| 24\n    32 -.->|\"reads, calls\"| built-in:_-\n    linkStyle 28 stroke:gray;\n    34 -->|\"reads\"| 24\n    36 -->|\"reads, returns, argument\"| 34\n    36 -.->|\"reads, calls\"| built-in:print\n    linkStyle 31 stroke:gray;\n    38 -->|\"reads\"| 12\n    44 -->|\"reads\"| 43\n    47 -->|\"reads\"| 46\n    48 -->|\"reads\"| 43\n    48 -->|\"argument\"| 44\n    48 -->|\"reads\"| 46\n    48 -->|\"argument\"| 47\n    50 -->|\"reads, argument\"| 48\n    50 -.->|\"reads, calls\"| built-in:ggplot\n    linkStyle 40 stroke:gray;\n    50 -->|\"reads, argument\"| 38\n    52 -->|\"argument\"| 38\n    52 -->|\"argument\"| 50\n    52 -.->|\"reads, calls\"| built-in:___\n    linkStyle 44 stroke:gray;\n    54 -.->|\"reads, calls\"| built-in:geom_point\n    linkStyle 45 stroke:gray;\n    54 -->|\"reads\"| 50\n    55 -->|\"reads, argument\"| 52\n    55 -->|\"reads, argument\"| 54\n    55 -.->|\"reads, calls\"| built-in:_\n    linkStyle 49 stroke:gray;\n    57 -->|\"reads\"| 18\n    60 -->|\"reads, returns, argument\"| 57\n    60 -->|\"reads, argument\"| 58\n    60 -.->|\"reads, calls\"| built-in:_\n    linkStyle 53 stroke:gray;\n    62 -->|\"reads\"| 18\n    65 -->|\"reads, returns, argument\"| 62\n    65 -->|\"reads, argument\"| 63\n    65 -.->|\"reads, calls\"| built-in:_\n    linkStyle 57 stroke:gray;\n    67 -->|\"reads, argument\"| 60\n    67 -->|\"reads, argument\"| 65\n    67 -.->|\"reads, calls\"| built-in:plot\n    linkStyle 60 stroke:gray;\n    69 -->|\"reads\"| 18\n    72 -->|\"reads, returns, argument\"| 69\n    72 -->|\"reads, argument\"| 70\n    72 -.->|\"reads, calls\"| built-in:_\n    linkStyle 64 stroke:gray;\n    74 -->|\"reads\"| 18\n    77 -->|\"reads, returns, argument\"| 74\n    77 -->|\"reads, argument\"| 75\n    77 -.->|\"reads, calls\"| built-in:_\n    linkStyle 68 stroke:gray;\n    79 -->|\"reads, argument\"| 72\n    79 -->|\"reads, argument\"| 77\n    79 -.->|\"reads, calls\"| built-in:points\n    linkStyle 71 stroke:gray;\n    79 -->|\"reads\"| 67\n    82 -->|\"reads\"| 18\n    85 -->|\"reads, returns, argument\"| 82\n    85 -->|\"reads, argument\"| 83\n    85 -.->|\"reads, calls\"| built-in:_\n    linkStyle 76 stroke:gray;\n    87 -->|\"reads, argument\"| 85\n    87 -.->|\"reads, calls\"| built-in:mean\n    linkStyle 78 stroke:gray;\n    89 -->|\"reads, returns, argument\"| 87\n    89 -.->|\"reads, calls\"| built-in:print\n    linkStyle 80 stroke:gray;","mermaid":{"autoSync":true}}))\
 &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;╰ (has unknown side effect) {7, 5} ([marked](https://mermaid.live/view#base64:{"code":"flowchart BT\n    1{{\"`#91;RSymbol#93; ggplot\n      (1)\n      *1.9-14*`\"}}\n    3[[\"`#91;RFunctionCall#93; library\n      (3)\n      *1.1-15*\n    (1)`\"]]\n    style 3 stroke:red,stroke-width:5px; \n    built-in:library[\"`Built-In:\nlibrary`\"]\n    style built-in:library stroke:gray,fill:lightgray,stroke-width:2px,opacity:.8;\n    5{{\"`#91;RSymbol#93; dplyr\n      (5)\n      *2.9-13*`\"}}\n    7[[\"`#91;RFunctionCall#93; library\n      (7)\n      *2.1-14*\n    (5)`\"]]\n    style 7 stroke:red,stroke-width:5px; \n    9{{\"`#91;RSymbol#93; readr\n      (9)\n      *3.9-13*`\"}}\n    11[[\"`#91;RFunctionCall#93; library\n      (11)\n      *3.1-14*\n    (9)`\"]]\n    style 11 stroke:red,stroke-width:5px; \n    14{{\"`#91;RString#93; #39;data.csv#39;\n      (14)\n      *6.18-27*`\"}}\n    16[[\"`#91;RFunctionCall#93; read#95;csv\n      (16)\n      *6.9-28*\n    (14)`\"]]\n    12[\"`#91;RSymbol#93; data\n      (12)\n      *6.1-4*`\"]\n    17[[\"`#91;RBinaryOp#93; #60;#45;\n      (17)\n      *6.1-28*\n    (12, 16)`\"]]\n    built-in:_-[\"`Built-In:\n#60;#45;`\"]\n    style built-in:_- stroke:gray,fill:lightgray,stroke-width:2px,opacity:.8;\n    20{{\"`#91;RString#93; #39;data2.csv#39;\n      (20)\n      *7.19-29*`\"}}\n    22[[\"`#91;RFunctionCall#93; read#95;csv\n      (22)\n      *7.10-30*\n    (20)`\"]]\n    18[\"`#91;RSymbol#93; data2\n      (18)\n      *7.1-5*`\"]\n    23[[\"`#91;RBinaryOp#93; #60;#45;\n      (23)\n      *7.1-30*\n    (18, 22)`\"]]\n    26([\"`#91;RSymbol#93; data\n      (26)\n      *9.11-14*`\"])\n    27{{\"`#91;RSymbol#93; x\n      (27)\n      *9.11-16*`\"}}\n    29[[\"`#91;RAccess#93; $\n      (29)\n      *9.11-16*\n    (26, 27)`\"]]\n    built-in:_[\"`Built-In:\n$`\"]\n    style built-in:_ stroke:gray,fill:lightgray,stroke-width:2px,opacity:.8;\n    31[[\"`#91;RFunctionCall#93; mean\n      (31)\n      *9.6-17*\n    (29)`\"]]\n    built-in:mean[\"`Built-In:\nmean`\"]\n    style built-in:mean stroke:gray,fill:lightgray,stroke-width:2px,opacity:.8;\n    24[\"`#91;RSymbol#93; m\n      (24)\n      *9.1*`\"]\n    32[[\"`#91;RBinaryOp#93; #60;#45;\n      (32)\n      *9.1-17*\n    (24, 31)`\"]]\n    34([\"`#91;RSymbol#93; m\n      (34)\n      *10.7*`\"])\n    36[[\"`#91;RFunctionCall#93; print\n      (36)\n      *10.1-8*\n    (34)`\"]]\n    built-in:print[\"`Built-In:\nprint`\"]\n    style built-in:print stroke:gray,fill:lightgray,stroke-width:2px,opacity:.8;\n    38([\"`#91;RSymbol#93; data\n      (38)\n      *12.1-4*`\"])\n    43([\"`#91;RSymbol#93; x\n      (43)\n      *13.24*`\"])\n    44([\"`#91;RArgument#93; x\n      (44)\n      *13.20*`\"])\n    46([\"`#91;RSymbol#93; y\n      (46)\n      *13.31*`\"])\n    47([\"`#91;RArgument#93; y\n      (47)\n      *13.27*`\"])\n    48[[\"`#91;RFunctionCall#93; aes\n      (48)\n      *13.16-32*\n    (x (44), y (47))`\"]]\n    50[[\"`#91;RFunctionCall#93; ggplot\n      (50)\n      *13.9-33*\n    (38, 48)`\"]]\n    built-in:ggplot[\"`Built-In:\nggplot`\"]\n    style built-in:ggplot stroke:gray,fill:lightgray,stroke-width:2px,opacity:.8;\n    52[[\"`#91;RFunctionCall#93; data %#62;%\n\tggplot(aes(x = x, y = y))\n      (52)\n      *12.6-8*\n    (38, 50)`\"]]\n    built-in:___[\"`Built-In:\n%#62;%`\"]\n    style built-in:___ stroke:gray,fill:lightgray,stroke-width:2px,opacity:.8;\n    54[[\"`#91;RFunctionCall#93; geom#95;point\n      (54)\n      *14.9-20*`\"]]\n    built-in:geom_point[\"`Built-In:\ngeom#95;point`\"]\n    style built-in:geom_point stroke:gray,fill:lightgray,stroke-width:2px,opacity:.8;\n    55[[\"`#91;RBinaryOp#93; #43;\n      (55)\n      *12.1-14.20*\n    (52, 54)`\"]]\n    57([\"`#91;RSymbol#93; data2\n      (57)\n      *16.6-10*`\"])\n    58{{\"`#91;RSymbol#93; x\n      (58)\n      *16.6-12*`\"}}\n    60[[\"`#91;RAccess#93; $\n      (60)\n      *16.6-12*\n    (57, 58)`\"]]\n    62([\"`#91;RSymbol#93; data2\n      (62)\n      *16.15-19*`\"])\n    63{{\"`#91;RSymbol#93; y\n      (63)\n      *16.15-21*`\"}}\n    65[[\"`#91;RAccess#93; $\n      (65)\n      *16.15-21*\n    (62, 63)`\"]]\n    67[[\"`#91;RFunctionCall#93; plot\n      (67)\n      *16.1-22*\n    (60, 65)`\"]]\n    built-in:plot[\"`Built-In:\nplot`\"]\n    style built-in:plot stroke:gray,fill:lightgray,stroke-width:2px,opacity:.8;\n    69([\"`#91;RSymbol#93; data2\n      (69)\n      *17.8-12*`\"])\n    70{{\"`#91;RSymbol#93; x\n      (70)\n      *17.8-14*`\"}}\n    72[[\"`#91;RAccess#93; $\n      (72)\n      *17.8-14*\n    (69, 70)`\"]]\n    74([\"`#91;RSymbol#93; data2\n      (74)\n      *17.17-21*`\"])\n    75{{\"`#91;RSymbol#93; y\n      (75)\n      *17.17-23*`\"}}\n    77[[\"`#91;RAccess#93; $\n      (77)\n      *17.17-23*\n    (74, 75)`\"]]\n    79[[\"`#91;RFunctionCall#93; points\n      (79)\n      *17.1-24*\n    (72, 77)`\"]]\n    built-in:points[\"`Built-In:\npoints`\"]\n    style built-in:points stroke:gray,fill:lightgray,stroke-width:2px,opacity:.8;\n    82([\"`#91;RSymbol#93; data2\n      (82)\n      *19.12-16*`\"])\n    83{{\"`#91;RSymbol#93; k\n      (83)\n      *19.12-18*`\"}}\n    85[[\"`#91;RAccess#93; $\n      (85)\n      *19.12-18*\n    (82, 83)`\"]]\n    87[[\"`#91;RFunctionCall#93; mean\n      (87)\n      *19.7-19*\n    (85)`\"]]\n    89[[\"`#91;RFunctionCall#93; print\n      (89)\n      *19.1-20*\n    (87)`\"]]\n    3 -->|\"argument\"| 1\n    3 -.->|\"reads, calls\"| built-in:library\n    linkStyle 1 stroke:gray;\n    7 -->|\"argument\"| 5\n    7 -.->|\"reads, calls\"| built-in:library\n    linkStyle 3 stroke:gray;\n    11 -->|\"argument\"| 9\n    11 -.->|\"reads, calls\"| built-in:library\n    linkStyle 5 stroke:gray;\n    16 -->|\"argument\"| 14\n    12 -->|\"defined-by\"| 16\n    12 -->|\"defined-by\"| 17\n    17 -->|\"argument\"| 16\n    17 -->|\"returns, argument\"| 12\n    17 -.->|\"reads, calls\"| built-in:_-\n    linkStyle 11 stroke:gray;\n    22 -->|\"argument\"| 20\n    18 -->|\"defined-by\"| 22\n    18 -->|\"defined-by\"| 23\n    23 -->|\"argument\"| 22\n    23 -->|\"returns, argument\"| 18\n    23 -.->|\"reads, calls\"| built-in:_-\n    linkStyle 17 stroke:gray;\n    26 -->|\"reads\"| 12\n    29 -->|\"reads, returns, argument\"| 26\n    29 -->|\"reads, argument\"| 27\n    29 -.->|\"reads, calls\"| built-in:_\n    linkStyle 21 stroke:gray;\n    31 -->|\"reads, argument\"| 29\n    31 -.->|\"reads, calls\"| built-in:mean\n    linkStyle 23 stroke:gray;\n    24 -->|\"defined-by\"| 31\n    24 -->|\"defined-by\"| 32\n    32 -->|\"argument\"| 31\n    32 -->|\"returns, argument\"| 24\n    32 -.->|\"reads, calls\"| built-in:_-\n    linkStyle 28 stroke:gray;\n    34 -->|\"reads\"| 24\n    36 -->|\"reads, returns, argument\"| 34\n    36 -.->|\"reads, calls\"| built-in:print\n    linkStyle 31 stroke:gray;\n    38 -->|\"reads\"| 12\n    44 -->|\"reads\"| 43\n    47 -->|\"reads\"| 46\n    48 -->|\"reads\"| 43\n    48 -->|\"argument\"| 44\n    48 -->|\"reads\"| 46\n    48 -->|\"argument\"| 47\n    50 -->|\"reads, argument\"| 48\n    50 -.->|\"reads, calls\"| built-in:ggplot\n    linkStyle 40 stroke:gray;\n    50 -->|\"reads, argument\"| 38\n    52 -->|\"argument\"| 38\n    52 -->|\"argument\"| 50\n    52 -.->|\"reads, calls\"| built-in:___\n    linkStyle 44 stroke:gray;\n    54 -.->|\"reads, calls\"| built-in:geom_point\n    linkStyle 45 stroke:gray;\n    54 -->|\"reads\"| 50\n    55 -->|\"reads, argument\"| 52\n    55 -->|\"reads, argument\"| 54\n    55 -.->|\"reads, calls\"| built-in:_\n    linkStyle 49 stroke:gray;\n    57 -->|\"reads\"| 18\n    60 -->|\"reads, returns, argument\"| 57\n    60 -->|\"reads, argument\"| 58\n    60 -.->|\"reads, calls\"| built-in:_\n    linkStyle 53 stroke:gray;\n    62 -->|\"reads\"| 18\n    65 -->|\"reads, returns, argument\"| 62\n    65 -->|\"reads, argument\"| 63\n    65 -.->|\"reads, calls\"| built-in:_\n    linkStyle 57 stroke:gray;\n    67 -->|\"reads, argument\"| 60\n    67 -->|\"reads, argument\"| 65\n    67 -.->|\"reads, calls\"| built-in:plot\n    linkStyle 60 stroke:gray;\n    69 -->|\"reads\"| 18\n    72 -->|\"reads, returns, argument\"| 69\n    72 -->|\"reads, argument\"| 70\n    72 -.->|\"reads, calls\"| built-in:_\n    linkStyle 64 stroke:gray;\n    74 -->|\"reads\"| 18\n    77 -->|\"reads, returns, argument\"| 74\n    77 -->|\"reads, argument\"| 75\n    77 -.->|\"reads, calls\"| built-in:_\n    linkStyle 68 stroke:gray;\n    79 -->|\"reads, argument\"| 72\n    79 -->|\"reads, argument\"| 77\n    79 -.->|\"reads, calls\"| built-in:points\n    linkStyle 71 stroke:gray;\n    79 -->|\"reads\"| 67\n    82 -->|\"reads\"| 18\n    85 -->|\"reads, returns, argument\"| 82\n    85 -->|\"reads, argument\"| 83\n    85 -.->|\"reads, calls\"| built-in:_\n    linkStyle 76 stroke:gray;\n    87 -->|\"reads, argument\"| 85\n    87 -.->|\"reads, calls\"| built-in:mean\n    linkStyle 78 stroke:gray;\n    89 -->|\"reads, returns, argument\"| 87\n    89 -.->|\"reads, calls\"| built-in:print\n    linkStyle 80 stroke:gray;","mermaid":{"autoSync":true}}))\
 &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;╰ (has unknown side effect) {3, 1} ([marked](https://mermaid.live/view#base64:{"code":"flowchart BT\n    1{{\"`#91;RSymbol#93; ggplot\n      (1)\n      *1.9-14*`\"}}\n    3[[\"`#91;RFunctionCall#93; library\n      (3)\n      *1.1-15*\n    (1)`\"]]\n    style 3 stroke:red,stroke-width:5px; \n    built-in:library[\"`Built-In:\nlibrary`\"]\n    style built-in:library stroke:gray,fill:lightgray,stroke-width:2px,opacity:.8;\n    5{{\"`#91;RSymbol#93; dplyr\n      (5)\n      *2.9-13*`\"}}\n    7[[\"`#91;RFunctionCall#93; library\n      (7)\n      *2.1-14*\n    (5)`\"]]\n    style 7 stroke:red,stroke-width:5px; \n    9{{\"`#91;RSymbol#93; readr\n      (9)\n      *3.9-13*`\"}}\n    11[[\"`#91;RFunctionCall#93; library\n      (11)\n      *3.1-14*\n    (9)`\"]]\n    style 11 stroke:red,stroke-width:5px; \n    14{{\"`#91;RString#93; #39;data.csv#39;\n      (14)\n      *6.18-27*`\"}}\n    16[[\"`#91;RFunctionCall#93; read#95;csv\n      (16)\n      *6.9-28*\n    (14)`\"]]\n    12[\"`#91;RSymbol#93; data\n      (12)\n      *6.1-4*`\"]\n    17[[\"`#91;RBinaryOp#93; #60;#45;\n      (17)\n      *6.1-28*\n    (12, 16)`\"]]\n    built-in:_-[\"`Built-In:\n#60;#45;`\"]\n    style built-in:_- stroke:gray,fill:lightgray,stroke-width:2px,opacity:.8;\n    20{{\"`#91;RString#93; #39;data2.csv#39;\n      (20)\n      *7.19-29*`\"}}\n    22[[\"`#91;RFunctionCall#93; read#95;csv\n      (22)\n      *7.10-30*\n    (20)`\"]]\n    18[\"`#91;RSymbol#93; data2\n      (18)\n      *7.1-5*`\"]\n    23[[\"`#91;RBinaryOp#93; #60;#45;\n      (23)\n      *7.1-30*\n    (18, 22)`\"]]\n    26([\"`#91;RSymbol#93; data\n      (26)\n      *9.11-14*`\"])\n    27{{\"`#91;RSymbol#93; x\n      (27)\n      *9.11-16*`\"}}\n    29[[\"`#91;RAccess#93; $\n      (29)\n      *9.11-16*\n    (26, 27)`\"]]\n    built-in:_[\"`Built-In:\n$`\"]\n    style built-in:_ stroke:gray,fill:lightgray,stroke-width:2px,opacity:.8;\n    31[[\"`#91;RFunctionCall#93; mean\n      (31)\n      *9.6-17*\n    (29)`\"]]\n    built-in:mean[\"`Built-In:\nmean`\"]\n    style built-in:mean stroke:gray,fill:lightgray,stroke-width:2px,opacity:.8;\n    24[\"`#91;RSymbol#93; m\n      (24)\n      *9.1*`\"]\n    32[[\"`#91;RBinaryOp#93; #60;#45;\n      (32)\n      *9.1-17*\n    (24, 31)`\"]]\n    34([\"`#91;RSymbol#93; m\n      (34)\n      *10.7*`\"])\n    36[[\"`#91;RFunctionCall#93; print\n      (36)\n      *10.1-8*\n    (34)`\"]]\n    built-in:print[\"`Built-In:\nprint`\"]\n    style built-in:print stroke:gray,fill:lightgray,stroke-width:2px,opacity:.8;\n    38([\"`#91;RSymbol#93; data\n      (38)\n      *12.1-4*`\"])\n    43([\"`#91;RSymbol#93; x\n      (43)\n      *13.24*`\"])\n    44([\"`#91;RArgument#93; x\n      (44)\n      *13.20*`\"])\n    46([\"`#91;RSymbol#93; y\n      (46)\n      *13.31*`\"])\n    47([\"`#91;RArgument#93; y\n      (47)\n      *13.27*`\"])\n    48[[\"`#91;RFunctionCall#93; aes\n      (48)\n      *13.16-32*\n    (x (44), y (47))`\"]]\n    50[[\"`#91;RFunctionCall#93; ggplot\n      (50)\n      *13.9-33*\n    (38, 48)`\"]]\n    built-in:ggplot[\"`Built-In:\nggplot`\"]\n    style built-in:ggplot stroke:gray,fill:lightgray,stroke-width:2px,opacity:.8;\n    52[[\"`#91;RFunctionCall#93; data %#62;%\n\tggplot(aes(x = x, y = y))\n      (52)\n      *12.6-8*\n    (38, 50)`\"]]\n    built-in:___[\"`Built-In:\n%#62;%`\"]\n    style built-in:___ stroke:gray,fill:lightgray,stroke-width:2px,opacity:.8;\n    54[[\"`#91;RFunctionCall#93; geom#95;point\n      (54)\n      *14.9-20*`\"]]\n    built-in:geom_point[\"`Built-In:\ngeom#95;point`\"]\n    style built-in:geom_point stroke:gray,fill:lightgray,stroke-width:2px,opacity:.8;\n    55[[\"`#91;RBinaryOp#93; #43;\n      (55)\n      *12.1-14.20*\n    (52, 54)`\"]]\n    57([\"`#91;RSymbol#93; data2\n      (57)\n      *16.6-10*`\"])\n    58{{\"`#91;RSymbol#93; x\n      (58)\n      *16.6-12*`\"}}\n    60[[\"`#91;RAccess#93; $\n      (60)\n      *16.6-12*\n    (57, 58)`\"]]\n    62([\"`#91;RSymbol#93; data2\n      (62)\n      *16.15-19*`\"])\n    63{{\"`#91;RSymbol#93; y\n      (63)\n      *16.15-21*`\"}}\n    65[[\"`#91;RAccess#93; $\n      (65)\n      *16.15-21*\n    (62, 63)`\"]]\n    67[[\"`#91;RFunctionCall#93; plot\n      (67)\n      *16.1-22*\n    (60, 65)`\"]]\n    built-in:plot[\"`Built-In:\nplot`\"]\n    style built-in:plot stroke:gray,fill:lightgray,stroke-width:2px,opacity:.8;\n    69([\"`#91;RSymbol#93; data2\n      (69)\n      *17.8-12*`\"])\n    70{{\"`#91;RSymbol#93; x\n      (70)\n      *17.8-14*`\"}}\n    72[[\"`#91;RAccess#93; $\n      (72)\n      *17.8-14*\n    (69, 70)`\"]]\n    74([\"`#91;RSymbol#93; data2\n      (74)\n      *17.17-21*`\"])\n    75{{\"`#91;RSymbol#93; y\n      (75)\n      *17.17-23*`\"}}\n    77[[\"`#91;RAccess#93; $\n      (77)\n      *17.17-23*\n    (74, 75)`\"]]\n    79[[\"`#91;RFunctionCall#93; points\n      (79)\n      *17.1-24*\n    (72, 77)`\"]]\n    built-in:points[\"`Built-In:\npoints`\"]\n    style built-in:points stroke:gray,fill:lightgray,stroke-width:2px,opacity:.8;\n    82([\"`#91;RSymbol#93; data2\n      (82)\n      *19.12-16*`\"])\n    83{{\"`#91;RSymbol#93; k\n      (83)\n      *19.12-18*`\"}}\n    85[[\"`#91;RAccess#93; $\n      (85)\n      *19.12-18*\n    (82, 83)`\"]]\n    87[[\"`#91;RFunctionCall#93; mean\n      (87)\n      *19.7-19*\n    (85)`\"]]\n    89[[\"`#91;RFunctionCall#93; print\n      (89)\n      *19.1-20*\n    (87)`\"]]\n    3 -->|\"argument\"| 1\n    3 -.->|\"reads, calls\"| built-in:library\n    linkStyle 1 stroke:gray;\n    7 -->|\"argument\"| 5\n    7 -.->|\"reads, calls\"| built-in:library\n    linkStyle 3 stroke:gray;\n    11 -->|\"argument\"| 9\n    11 -.->|\"reads, calls\"| built-in:library\n    linkStyle 5 stroke:gray;\n    16 -->|\"argument\"| 14\n    12 -->|\"defined-by\"| 16\n    12 -->|\"defined-by\"| 17\n    17 -->|\"argument\"| 16\n    17 -->|\"returns, argument\"| 12\n    17 -.->|\"reads, calls\"| built-in:_-\n    linkStyle 11 stroke:gray;\n    22 -->|\"argument\"| 20\n    18 -->|\"defined-by\"| 22\n    18 -->|\"defined-by\"| 23\n    23 -->|\"argument\"| 22\n    23 -->|\"returns, argument\"| 18\n    23 -.->|\"reads, calls\"| built-in:_-\n    linkStyle 17 stroke:gray;\n    26 -->|\"reads\"| 12\n    29 -->|\"reads, returns, argument\"| 26\n    29 -->|\"reads, argument\"| 27\n    29 -.->|\"reads, calls\"| built-in:_\n    linkStyle 21 stroke:gray;\n    31 -->|\"reads, argument\"| 29\n    31 -.->|\"reads, calls\"| built-in:mean\n    linkStyle 23 stroke:gray;\n    24 -->|\"defined-by\"| 31\n    24 -->|\"defined-by\"| 32\n    32 -->|\"argument\"| 31\n    32 -->|\"returns, argument\"| 24\n    32 -.->|\"reads, calls\"| built-in:_-\n    linkStyle 28 stroke:gray;\n    34 -->|\"reads\"| 24\n    36 -->|\"reads, returns, argument\"| 34\n    36 -.->|\"reads, calls\"| built-in:print\n    linkStyle 31 stroke:gray;\n    38 -->|\"reads\"| 12\n    44 -->|\"reads\"| 43\n    47 -->|\"reads\"| 46\n    48 -->|\"reads\"| 43\n    48 -->|\"argument\"| 44\n    48 -->|\"reads\"| 46\n    48 -->|\"argument\"| 47\n    50 -->|\"reads, argument\"| 48\n    50 -.->|\"reads, calls\"| built-in:ggplot\n    linkStyle 40 stroke:gray;\n    50 -->|\"reads, argument\"| 38\n    52 -->|\"argument\"| 38\n    52 -->|\"argument\"| 50\n    52 -.->|\"reads, calls\"| built-in:___\n    linkStyle 44 stroke:gray;\n    54 -.->|\"reads, calls\"| built-in:geom_point\n    linkStyle 45 stroke:gray;\n    54 -->|\"reads\"| 50\n    55 -->|\"reads, argument\"| 52\n    55 -->|\"reads, argument\"| 54\n    55 -.->|\"reads, calls\"| built-in:_\n    linkStyle 49 stroke:gray;\n    57 -->|\"reads\"| 18\n    60 -->|\"reads, returns, argument\"| 57\n    60 -->|\"reads, argument\"| 58\n    60 -.->|\"reads, calls\"| built-in:_\n    linkStyle 53 stroke:gray;\n    62 -->|\"reads\"| 18\n    65 -->|\"reads, returns, argument\"| 62\n    65 -->|\"reads, argument\"| 63\n    65 -.->|\"reads, calls\"| built-in:_\n    linkStyle 57 stroke:gray;\n    67 -->|\"reads, argument\"| 60\n    67 -->|\"reads, argument\"| 65\n    67 -.->|\"reads, calls\"| built-in:plot\n    linkStyle 60 stroke:gray;\n    69 -->|\"reads\"| 18\n    72 -->|\"reads, returns, argument\"| 69\n    72 -->|\"reads, argument\"| 70\n    72 -.->|\"reads, calls\"| built-in:_\n    linkStyle 64 stroke:gray;\n    74 -->|\"reads\"| 18\n    77 -->|\"reads, returns, argument\"| 74\n    77 -->|\"reads, argument\"| 75\n    77 -.->|\"reads, calls\"| built-in:_\n    linkStyle 68 stroke:gray;\n    79 -->|\"reads, argument\"| 72\n    79 -->|\"reads, argument\"| 77\n    79 -.->|\"reads, calls\"| built-in:points\n    linkStyle 71 stroke:gray;\n    79 -->|\"reads\"| 67\n    82 -->|\"reads\"| 18\n    85 -->|\"reads, returns, argument\"| 82\n    85 -->|\"reads, argument\"| 83\n    85 -.->|\"reads, calls\"| built-in:_\n    linkStyle 76 stroke:gray;\n    87 -->|\"reads, argument\"| 85\n    87 -.->|\"reads, calls\"| built-in:mean\n    linkStyle 78 stroke:gray;\n    89 -->|\"reads, returns, argument\"| 87\n    89 -.->|\"reads, calls\"| built-in:print\n    linkStyle 80 stroke:gray;","mermaid":{"autoSync":true}}))\
-_All queries together required ≈0 ms (1ms accuracy, total 7 ms)_
+_All queries together required ≈0 ms (1ms accuracy, total 3 ms)_
 
 <details> <summary style="color:gray">Show Detailed Results as Json</summary>
 
-The analysis required _6.7 ms_ (including parsing and normalization and the query) within the generation environment.	
+The analysis required _3.0 ms_ (including parsing and normalization and the query) within the generation environment.	
 
 In general, the JSON contains the Ids of the nodes in question as they are present in the normalized AST or the dataflow graph of flowR.
 Please consult the [Interface](https://github.com/flowr-analysis/flowr/wiki/Interface) wiki page for more information on how to get those.
@@ -1368,11 +1377,11 @@ _Results (prettified and summarized):_
 
 Query: **dataflow** (0 ms)\
 &nbsp;&nbsp;&nbsp;╰ [Dataflow Graph](https://mermaid.live/view#base64:eyJjb2RlIjoiZmxvd2NoYXJ0IEJUXG4gICAgMChbXCJgIzkxO1JTeW1ib2wjOTM7IHhcbiAgICAgICgwKVxuICAgICAgKjEuMSpgXCJdKVxuICAgIDF7e1wiYCM5MTtSTnVtYmVyIzkzOyAxXG4gICAgICAoMSlcbiAgICAgICoxLjUqYFwifX1cbiAgICAyW1tcImAjOTE7UkJpbmFyeU9wIzkzOyAjNDM7XG4gICAgICAoMilcbiAgICAgICoxLjEtNSpcbiAgICAoMCwgMSlgXCJdXVxuICAgIGJ1aWx0LWluOl9bXCJgQnVpbHQtSW46XG4jNDM7YFwiXVxuICAgIHN0eWxlIGJ1aWx0LWluOl8gc3Ryb2tlOmdyYXksZmlsbDpsaWdodGdyYXksc3Ryb2tlLXdpZHRoOjJweCxvcGFjaXR5Oi44O1xuICAgIDIgLS0+fFwicmVhZHMsIGFyZ3VtZW50XCJ8IDBcbiAgICAyIC0tPnxcInJlYWRzLCBhcmd1bWVudFwifCAxXG4gICAgMiAtLi0+fFwicmVhZHMsIGNhbGxzXCJ8IGJ1aWx0LWluOl9cbiAgICBsaW5rU3R5bGUgMiBzdHJva2U6Z3JheTsiLCJtZXJtYWlkIjp7ImF1dG9TeW5jIjp0cnVlfX0=)\
-_All queries together required ≈0 ms (1ms accuracy, total 2 ms)_
+_All queries together required ≈0 ms (1ms accuracy, total 1 ms)_
 
 <details> <summary style="color:gray">Show Detailed Results as Json</summary>
 
-The analysis required _1.7 ms_ (including parsing and normalization and the query) within the generation environment.	
+The analysis required _0.7 ms_ (including parsing and normalization and the query) within the generation environment.	
 
 In general, the JSON contains the Ids of the nodes in question as they are present in the normalized AST or the dataflow graph of flowR.
 Please consult the [Interface](https://github.com/flowr-analysis/flowr/wiki/Interface) wiki page for more information on how to get those.
@@ -1402,7 +1411,7 @@ x + 1
 
 <summary style="color:gray">Dataflow Graph of the R Code</summary>
 
-The analysis required _1.6 ms_ (including parse and normalize, using the [r-shell](https://github.com/flowr-analysis/flowr/wiki/Engines) engine) within the generation environment. 
+The analysis required _0.6 ms_ (including parse and normalize, using the [r-shell](https://github.com/flowr-analysis/flowr/wiki/Engines) engine) within the generation environment. 
 We encountered no unknown side effects during the analysis.
 
 
@@ -1455,6 +1464,91 @@ Responsible for the execution of the Dataflow Query query is `executeDataflowQue
 -----
 
 
+### Datatype Query
+
+
+This query returns the datatypes of syntactic elements in the code.
+To exemplify the capabilities, consider the following code:
+
+```r
+x <- 1
+y <- 2
+x
+```
+
+To see the type of the variable `x`, you can use the following query:
+
+
+
+```json
+[
+  {
+    "type": "datatype",
+    "criterion": "3@x"
+  }
+]
+```
+
+
+
+
+_Results (prettified and summarized):_
+
+Query: **datatype** (1 ms)\
+&nbsp;&nbsp;&nbsp;╰ 3@x: {RIntegerType}\
+_All queries together required ≈1 ms (1ms accuracy, total 2 ms)_
+
+<details> <summary style="color:gray">Show Detailed Results as Json</summary>
+
+The analysis required _1.7 ms_ (including parsing and normalization and the query) within the generation environment.	
+
+In general, the JSON contains the Ids of the nodes in question as they are present in the normalized AST or the dataflow graph of flowR.
+Please consult the [Interface](https://github.com/flowr-analysis/flowr/wiki/Interface) wiki page for more information on how to get those.
+
+
+
+
+```json
+{
+  "datatype": {
+    ".meta": {
+      "timing": 1
+    },
+    "inferredTypes": {
+      "3@x": {
+        "tag": "RIntegerType"
+      }
+    }
+  },
+  ".meta": {
+    "timing": 1
+  }
+}
+```
+
+
+
+</details>
+
+
+
+
+
+	
+
+
+<details> 
+
+<summary style="color:gray">Implementation Details</summary>
+
+Responsible for the execution of the Datatype Query query is `executeDatatypeQuery` in [`./src/queries/catalog/datatype-query/datatype-query-executor.ts`](https://github.com/flowr-analysis/flowr/tree/main/./src/queries/catalog/datatype-query/datatype-query-executor.ts).
+
+</details>	
+
+
+-----
+
+
 ### Dependencies Query
 
 
@@ -1474,15 +1568,15 @@ In other words, if you have a script simply reading: `library(x)`, the following
 
 _Results (prettified and summarized):_
 
-Query: **dependencies** (2 ms)\
+Query: **dependencies** (1 ms)\
 &nbsp;&nbsp;&nbsp;╰ Libraries\
 &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;╰ `library`\
 &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;╰ Node Id: 3, `x`\
-_All queries together required ≈2 ms (1ms accuracy, total 4 ms)_
+_All queries together required ≈2 ms (1ms accuracy, total 2 ms)_
 
 <details> <summary style="color:gray">Show Detailed Results as Json</summary>
 
-The analysis required _3.7 ms_ (including parsing and normalization and the query) within the generation environment.	
+The analysis required _1.6 ms_ (including parsing and normalization and the query) within the generation environment.	
 
 In general, the JSON contains the Ids of the nodes in question as they are present in the normalized AST or the dataflow graph of flowR.
 Please consult the [Interface](https://github.com/flowr-analysis/flowr/wiki/Interface) wiki page for more information on how to get those.
@@ -1494,7 +1588,7 @@ Please consult the [Interface](https://github.com/flowr-analysis/flowr/wiki/Inte
 {
   "dependencies": {
     ".meta": {
-      "timing": 2
+      "timing": 1
     },
     "libraries": [
       {
@@ -1552,7 +1646,7 @@ The following query returns the dependencies of the script.
 
 _Results (prettified and summarized):_
 
-Query: **dependencies** (2 ms)\
+Query: **dependencies** (1 ms)\
 &nbsp;&nbsp;&nbsp;╰ Libraries\
 &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;╰ `loadNamespace`\
 &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;╰ Node Id: 8, `bar`\
@@ -1569,11 +1663,11 @@ Query: **dependencies** (2 ms)\
 &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;╰ Node Id: 37, `data2.csv`\
 &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;╰ `print`\
 &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;╰ Node Id: 41, `stdout`\
-_All queries together required ≈2 ms (1ms accuracy, total 7 ms)_
+_All queries together required ≈1 ms (1ms accuracy, total 3 ms)_
 
 <details> <summary style="color:gray">Show Detailed Results as Json</summary>
 
-The analysis required _6.7 ms_ (including parsing and normalization and the query) within the generation environment.	
+The analysis required _3.5 ms_ (including parsing and normalization and the query) within the generation environment.	
 
 In general, the JSON contains the Ids of the nodes in question as they are present in the normalized AST or the dataflow graph of flowR.
 Please consult the [Interface](https://github.com/flowr-analysis/flowr/wiki/Interface) wiki page for more information on how to get those.
@@ -1585,7 +1679,7 @@ Please consult the [Interface](https://github.com/flowr-analysis/flowr/wiki/Inte
 {
   "dependencies": {
     ".meta": {
-      "timing": 2
+      "timing": 1
     },
     "libraries": [
       {
@@ -1627,7 +1721,7 @@ Please consult the [Interface](https://github.com/flowr-analysis/flowr/wiki/Inte
     ]
   },
   ".meta": {
-    "timing": 2
+    "timing": 1
   }
 }
 ```
@@ -1680,11 +1774,11 @@ Query: **dependencies** (0 ms)\
 &nbsp;&nbsp;&nbsp;╰ Libraries\
 &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;╰ `print`\
 &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;╰ Node Id: 41, `hello world!`\
-_All queries together required ≈0 ms (1ms accuracy, total 4 ms)_
+_All queries together required ≈0 ms (1ms accuracy, total 2 ms)_
 
 <details> <summary style="color:gray">Show Detailed Results as Json</summary>
 
-The analysis required _3.8 ms_ (including parsing and normalization and the query) within the generation environment.	
+The analysis required _1.7 ms_ (including parsing and normalization and the query) within the generation environment.	
 
 In general, the JSON contains the Ids of the nodes in question as they are present in the normalized AST or the dataflow graph of flowR.
 Please consult the [Interface](https://github.com/flowr-analysis/flowr/wiki/Interface) wiki page for more information on how to get those.
@@ -1773,13 +1867,13 @@ the following query returns that the first assignment happens always before the
 
 _Results (prettified and summarized):_
 
-Query: **happens-before** (1 ms)\
+Query: **happens-before** (0 ms)\
 &nbsp;&nbsp;&nbsp;╰ 1@x<2@y: always\
-_All queries together required ≈1 ms (1ms accuracy, total 2 ms)_
+_All queries together required ≈0 ms (1ms accuracy, total 1 ms)_
 
 <details> <summary style="color:gray">Show Detailed Results as Json</summary>
 
-The analysis required _2.1 ms_ (including parsing and normalization and the query) within the generation environment.	
+The analysis required _0.9 ms_ (including parsing and normalization and the query) within the generation environment.	
 
 In general, the JSON contains the Ids of the nodes in question as they are present in the normalized AST or the dataflow graph of flowR.
 Please consult the [Interface](https://github.com/flowr-analysis/flowr/wiki/Interface) wiki page for more information on how to get those.
@@ -1791,14 +1885,14 @@ Please consult the [Interface](https://github.com/flowr-analysis/flowr/wiki/Inte
 {
   "happens-before": {
     ".meta": {
-      "timing": 1
+      "timing": 0
     },
     "results": {
       "1@x<2@y": "always"
     }
   },
   ".meta": {
-    "timing": 1
+    "timing": 0
   }
 }
 ```
@@ -1822,7 +1916,7 @@ y <- 2
 
 <summary style="color:gray">Dataflow Graph of the R Code</summary>
 
-The analysis required _1.6 ms_ (including parse and normalize, using the [r-shell](https://github.com/flowr-analysis/flowr/wiki/Engines) engine) within the generation environment. 
+The analysis required _0.7 ms_ (including parse and normalize, using the [r-shell](https://github.com/flowr-analysis/flowr/wiki/Engines) engine) within the generation environment. 
 We encountered no unknown side effects during the analysis.
 
 
@@ -1917,7 +2011,7 @@ _All queries together required ≈0 ms (1ms accuracy, total 1 ms)_
 
 <details> <summary style="color:gray">Show Detailed Results as Json</summary>
 
-The analysis required _1.3 ms_ (including parsing and normalization and the query) within the generation environment.	
+The analysis required _0.5 ms_ (including parsing and normalization and the query) within the generation environment.	
 
 In general, the JSON contains the Ids of the nodes in question as they are present in the normalized AST or the dataflow graph of flowR.
 Please consult the [Interface](https://github.com/flowr-analysis/flowr/wiki/Interface) wiki page for more information on how to get those.
@@ -1947,7 +2041,7 @@ x + 1
 
 <summary style="color:gray">Dataflow Graph of the R Code</summary>
 
-The analysis required _1.2 ms_ (including parse and normalize, using the [r-shell](https://github.com/flowr-analysis/flowr/wiki/Engines) engine) within the generation environment. 
+The analysis required _0.5 ms_ (including parse and normalize, using the [r-shell](https://github.com/flowr-analysis/flowr/wiki/Engines) engine) within the generation environment. 
 We encountered no unknown side effects during the analysis.
 
 
@@ -2035,11 +2129,11 @@ _Results (prettified and summarized):_
 
 Query: **lineage** (0 ms)\
 &nbsp;&nbsp;&nbsp;╰ 2@x: {<span title="[3,0,1,2,'built-in:<-']">3, 0, 1, 2, built-in:<-, </span>}\
-_All queries together required ≈0 ms (1ms accuracy, total 2 ms)_
+_All queries together required ≈0 ms (1ms accuracy, total 1 ms)_
 
 <details> <summary style="color:gray">Show Detailed Results as Json</summary>
 
-The analysis required _1.5 ms_ (including parsing and normalization and the query) within the generation environment.	
+The analysis required _0.6 ms_ (including parsing and normalization and the query) within the generation environment.	
 
 In general, the JSON contains the Ids of the nodes in question as they are present in the normalized AST or the dataflow graph of flowR.
 Please consult the [Interface](https://github.com/flowr-analysis/flowr/wiki/Interface) wiki page for more information on how to get those.
@@ -2132,11 +2226,11 @@ Query: **location-map** (0 ms)\
 &nbsp;&nbsp;&nbsp;╰ File List:\
 &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;╰ 0: `<inline>`\
 &nbsp;&nbsp;&nbsp;╰ Id List: {<span title="['0','1','2','3','4','5','2-arg','5-arg','0-arg','1-arg','3-arg','4-arg']">0, 1, 2, 3, 4, 5, 2-arg, ... (see JSON)</span>}\
-_All queries together required ≈0 ms (1ms accuracy, total 14 ms)_
+_All queries together required ≈0 ms (1ms accuracy, total 3 ms)_
 
 <details> <summary style="color:gray">Show Detailed Results as Json</summary>
 
-The analysis required _14.4 ms_ (including parsing and normalization and the query) within the generation environment.	
+The analysis required _3.1 ms_ (including parsing and normalization and the query) within the generation environment.	
 
 In general, the JSON contains the Ids of the nodes in question as they are present in the normalized AST or the dataflow graph of flowR.
 Please consult the [Interface](https://github.com/flowr-analysis/flowr/wiki/Interface) wiki page for more information on how to get those.
@@ -2319,11 +2413,11 @@ _Results (prettified and summarized):_
 
 Query: **normalized-ast** (0 ms)\
 &nbsp;&nbsp;&nbsp;╰ [Normalized AST](https://mermaid.live/view#base64:eyJjb2RlIjoiZmxvd2NoYXJ0IFREXG4gICAgbjMoW1wiUkV4cHJlc3Npb25MaXN0ICgzKVxuIFwiXSlcbiAgICBuMihbXCJSQmluYXJ5T3AgKDIpXG4jNDM7XCJdKVxuICAgIG4zIC0tPnxcImV4cHItbGlzdC1jaGlsZC0wXCJ8IG4yXG4gICAgbjAoW1wiUlN5bWJvbCAoMClcbnhcIl0pXG4gICAgbjIgLS0+fFwiYmlub3AtbGhzXCJ8IG4wXG4gICAgbjEoW1wiUk51bWJlciAoMSlcbjFcIl0pXG4gICAgbjIgLS0+fFwiYmlub3AtcmhzXCJ8IG4xXG4iLCJtZXJtYWlkIjp7ImF1dG9TeW5jIjp0cnVlfX0=)\
-_All queries together required ≈1 ms (1ms accuracy, total 15 ms)_
+_All queries together required ≈0 ms (1ms accuracy, total 1 ms)_
 
 <details> <summary style="color:gray">Show Detailed Results as Json</summary>
 
-The analysis required _14.5 ms_ (including parsing and normalization and the query) within the generation environment.	
+The analysis required _1.1 ms_ (including parsing and normalization and the query) within the generation environment.	
 
 In general, the JSON contains the Ids of the nodes in question as they are present in the normalized AST or the dataflow graph of flowR.
 Please consult the [Interface](https://github.com/flowr-analysis/flowr/wiki/Interface) wiki page for more information on how to get those.
@@ -2332,7 +2426,7 @@ Please consult the [Interface](https://github.com/flowr-analysis/flowr/wiki/Inte
 _As the code is pretty long, we inhibit pretty printing and syntax highlighting (JSON, hiding built-in):_
 
 ```text
-{"normalized-ast":{".meta":{"timing":0},"normalized":{"ast":{"type":"RExpressionList","children":[{"type":"RBinaryOp","location":[1,3,1,3],"lhs":{"type":"RSymbol","location":[1,1,1,1],"content":"x","lexeme":"x","info":{"fullRange":[1,1,1,1],"additionalTokens":[],"id":0,"parent":2,"role":"binop-lhs","index":0,"nesting":0}},"rhs":{"location":[1,5,1,5],"lexeme":"1","info":{"fullRange":[1,5,1,5],"additionalTokens":[],"id":1,"parent":2,"role":"binop-rhs","index":1,"nesting":0},"type":"RNumber","content":{"num":1,"complexNumber":false,"markedAsInt":false}},"operator":"+","lexeme":"+","info":{"fullRange":[1,1,1,5],"additionalTokens":[],"id":2,"parent":3,"nesting":0,"index":0,"role":"expr-list-child"}}],"info":{"additionalTokens":[],"id":3,"nesting":0,"role":"root","index":0}},"idMap":{"size":7,"k2v":[[0,{"type":"RSymbol","location":[1,1,1,1],"content":"x","lexeme":"x","info":{"fullRange":[1,1,1,1],"additionalTokens":[],"id":0,"parent":2,"role":"binop-lhs","index":0,"nesting":0}}],[1,{"location":[1,5,1,5],"lexeme":"1","info":{"fullRange":[1,5,1,5],"additionalTokens":[],"id":1,"parent":2,"role":"binop-rhs","index":1,"nesting":0},"type":"RNumber","content":{"num":1,"complexNumber":false,"markedAsInt":false}}],[2,{"type":"RBinaryOp","location":[1,3,1,3],"lhs":{"type":"RSymbol","location":[1,1,1,1],"content":"x","lexeme":"x","info":{"fullRange":[1,1,1,1],"additionalTokens":[],"id":0,"parent":2,"role":"binop-lhs","index":0,"nesting":0}},"rhs":{"location":[1,5,1,5],"lexeme":"1","info":{"fullRange":[1,5,1,5],"additionalTokens":[],"id":1,"parent":2,"role":"binop-rhs","index":1,"nesting":0},"type":"RNumber","content":{"num":1,"complexNumber":false,"markedAsInt":false}},"operator":"+","lexeme":"+","info":{"fullRange":[1,1,1,5],"additionalTokens":[],"id":2,"parent":3,"nesting":0,"index":0,"role":"expr-list-child"}}],[3,{"type":"RExpressionList","children":[{"type":"RBinaryOp","location":[1,3,1,3],"lhs":{"type":"RSymbol","location":[1,1,1,1],"content":"x","lexeme":"x","info":{"fullRange":[1,1,1,1],"additionalTokens":[],"id":0,"parent":2,"role":"binop-lhs","index":0,"nesting":0}},"rhs":{"location":[1,5,1,5],"lexeme":"1","info":{"fullRange":[1,5,1,5],"additionalTokens":[],"id":1,"parent":2,"role":"binop-rhs","index":1,"nesting":0},"type":"RNumber","content":{"num":1,"complexNumber":false,"markedAsInt":false}},"operator":"+","lexeme":"+","info":{"fullRange":[1,1,1,5],"additionalTokens":[],"id":2,"parent":3,"nesting":0,"index":0,"role":"expr-list-child"}}],"info":{"additionalTokens":[],"id":3,"nesting":0,"role":"root","index":0}}],["2-arg",{"type":"RBinaryOp","location":[1,3,1,3],"lhs":{"type":"RSymbol","location":[1,1,1,1],"content":"x","lexeme":"x","info":{"fullRange":[1,1,1,1],"additionalTokens":[],"id":0,"parent":2,"role":"binop-lhs","index":0,"nesting":0}},"rhs":{"location":[1,5,1,5],"lexeme":"1","info":{"fullRange":[1,5,1,5],"additionalTokens":[],"id":1,"parent":2,"role":"binop-rhs","index":1,"nesting":0},"type":"RNumber","content":{"num":1,"complexNumber":false,"markedAsInt":false}},"operator":"+","lexeme":"+","info":{"fullRange":[1,1,1,5],"additionalTokens":[],"id":2,"parent":3,"nesting":0,"index":0,"role":"expr-list-child"}}],["0-arg",{"type":"RSymbol","location":[1,1,1,1],"content":"x","lexeme":"x","info":{"fullRange":[1,1,1,1],"additionalTokens":[],"id":0,"parent":2,"role":"binop-lhs","index":0,"nesting":0}}],["1-arg",{"location":[1,5,1,5],"lexeme":"1","info":{"fullRange":[1,5,1,5],"additionalTokens":[],"id":1,"parent":2,"role":"binop-rhs","index":1,"nesting":0},"type":"RNumber","content":{"num":1,"complexNumber":false,"markedAsInt":false}}]],"v2k":{}},".meta":{"timing":0}}},".meta":{"timing":1}}
+{"normalized-ast":{".meta":{"timing":0},"normalized":{"ast":{"type":"RExpressionList","children":[{"type":"RBinaryOp","location":[1,3,1,3],"lhs":{"type":"RSymbol","location":[1,1,1,1],"content":"x","lexeme":"x","info":{"fullRange":[1,1,1,1],"additionalTokens":[],"id":0,"parent":2,"role":"binop-lhs","index":0,"nesting":0}},"rhs":{"location":[1,5,1,5],"lexeme":"1","info":{"fullRange":[1,5,1,5],"additionalTokens":[],"id":1,"parent":2,"role":"binop-rhs","index":1,"nesting":0},"type":"RNumber","content":{"num":1,"complexNumber":false,"markedAsInt":false}},"operator":"+","lexeme":"+","info":{"fullRange":[1,1,1,5],"additionalTokens":[],"id":2,"parent":3,"nesting":0,"index":0,"role":"expr-list-child"}}],"info":{"additionalTokens":[],"id":3,"nesting":0,"role":"root","index":0}},"idMap":{"size":7,"k2v":[[0,{"type":"RSymbol","location":[1,1,1,1],"content":"x","lexeme":"x","info":{"fullRange":[1,1,1,1],"additionalTokens":[],"id":0,"parent":2,"role":"binop-lhs","index":0,"nesting":0}}],[1,{"location":[1,5,1,5],"lexeme":"1","info":{"fullRange":[1,5,1,5],"additionalTokens":[],"id":1,"parent":2,"role":"binop-rhs","index":1,"nesting":0},"type":"RNumber","content":{"num":1,"complexNumber":false,"markedAsInt":false}}],[2,{"type":"RBinaryOp","location":[1,3,1,3],"lhs":{"type":"RSymbol","location":[1,1,1,1],"content":"x","lexeme":"x","info":{"fullRange":[1,1,1,1],"additionalTokens":[],"id":0,"parent":2,"role":"binop-lhs","index":0,"nesting":0}},"rhs":{"location":[1,5,1,5],"lexeme":"1","info":{"fullRange":[1,5,1,5],"additionalTokens":[],"id":1,"parent":2,"role":"binop-rhs","index":1,"nesting":0},"type":"RNumber","content":{"num":1,"complexNumber":false,"markedAsInt":false}},"operator":"+","lexeme":"+","info":{"fullRange":[1,1,1,5],"additionalTokens":[],"id":2,"parent":3,"nesting":0,"index":0,"role":"expr-list-child"}}],[3,{"type":"RExpressionList","children":[{"type":"RBinaryOp","location":[1,3,1,3],"lhs":{"type":"RSymbol","location":[1,1,1,1],"content":"x","lexeme":"x","info":{"fullRange":[1,1,1,1],"additionalTokens":[],"id":0,"parent":2,"role":"binop-lhs","index":0,"nesting":0}},"rhs":{"location":[1,5,1,5],"lexeme":"1","info":{"fullRange":[1,5,1,5],"additionalTokens":[],"id":1,"parent":2,"role":"binop-rhs","index":1,"nesting":0},"type":"RNumber","content":{"num":1,"complexNumber":false,"markedAsInt":false}},"operator":"+","lexeme":"+","info":{"fullRange":[1,1,1,5],"additionalTokens":[],"id":2,"parent":3,"nesting":0,"index":0,"role":"expr-list-child"}}],"info":{"additionalTokens":[],"id":3,"nesting":0,"role":"root","index":0}}],["2-arg",{"type":"RBinaryOp","location":[1,3,1,3],"lhs":{"type":"RSymbol","location":[1,1,1,1],"content":"x","lexeme":"x","info":{"fullRange":[1,1,1,1],"additionalTokens":[],"id":0,"parent":2,"role":"binop-lhs","index":0,"nesting":0}},"rhs":{"location":[1,5,1,5],"lexeme":"1","info":{"fullRange":[1,5,1,5],"additionalTokens":[],"id":1,"parent":2,"role":"binop-rhs","index":1,"nesting":0},"type":"RNumber","content":{"num":1,"complexNumber":false,"markedAsInt":false}},"operator":"+","lexeme":"+","info":{"fullRange":[1,1,1,5],"additionalTokens":[],"id":2,"parent":3,"nesting":0,"index":0,"role":"expr-list-child"}}],["0-arg",{"type":"RSymbol","location":[1,1,1,1],"content":"x","lexeme":"x","info":{"fullRange":[1,1,1,1],"additionalTokens":[],"id":0,"parent":2,"role":"binop-lhs","index":0,"nesting":0}}],["1-arg",{"location":[1,5,1,5],"lexeme":"1","info":{"fullRange":[1,5,1,5],"additionalTokens":[],"id":1,"parent":2,"role":"binop-rhs","index":1,"nesting":0},"type":"RNumber","content":{"num":1,"complexNumber":false,"markedAsInt":false}}]],"v2k":{}},".meta":{"timing":0}}},".meta":{"timing":0}}
 ```
 
 
@@ -2353,7 +2447,7 @@ x + 1
 
 <summary style="color:gray">Dataflow Graph of the R Code</summary>
 
-The analysis required _19.3 ms_ (including parse and normalize, using the [r-shell](https://github.com/flowr-analysis/flowr/wiki/Engines) engine) within the generation environment. 
+The analysis required _0.6 ms_ (including parse and normalize, using the [r-shell](https://github.com/flowr-analysis/flowr/wiki/Engines) engine) within the generation environment. 
 We encountered no unknown side effects during the analysis.
 
 
@@ -2434,11 +2528,11 @@ _Results (prettified and summarized):_
 Query: **origin** (0 ms)\
 &nbsp;&nbsp;&nbsp;╰ Origins for {2@x}\
 &nbsp;&nbsp;&nbsp;	╰ {"type":0,"id":0}\
-_All queries together required ≈0 ms (1ms accuracy, total 7 ms)_
+_All queries together required ≈0 ms (1ms accuracy, total 1 ms)_
 
 <details> <summary style="color:gray">Show Detailed Results as Json</summary>
 
-The analysis required _6.6 ms_ (including parsing and normalization and the query) within the generation environment.	
+The analysis required _0.9 ms_ (including parsing and normalization and the query) within the generation environment.	
 
 In general, the JSON contains the Ids of the nodes in question as they are present in the normalized AST or the dataflow graph of flowR.
 Please consult the [Interface](https://github.com/flowr-analysis/flowr/wiki/Interface) wiki page for more information on how to get those.
@@ -2486,7 +2580,7 @@ print(x)
 
 <summary style="color:gray">Dataflow Graph of the R Code</summary>
 
-The analysis required _7.5 ms_ (including parse and normalize, using the [r-shell](https://github.com/flowr-analysis/flowr/wiki/Engines) engine) within the generation environment. 
+The analysis required _0.6 ms_ (including parse and normalize, using the [r-shell](https://github.com/flowr-analysis/flowr/wiki/Engines) engine) within the generation environment. 
 We encountered unknown side effects (with ids: 6 (linked)) during the analysis.
 
 
@@ -2576,11 +2670,11 @@ _Results (prettified and summarized):_
 Query: **project** (0 ms)\
 &nbsp;&nbsp;&nbsp;╰ Contains 1 file\
 &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;╰ `<inline>`\
-_All queries together required ≈1 ms (1ms accuracy, total 15 ms)_
+_All queries together required ≈0 ms (1ms accuracy, total 0 ms)_
 
 <details> <summary style="color:gray">Show Detailed Results as Json</summary>
 
-The analysis required _15.5 ms_ (including parsing and normalization and the query) within the generation environment.	
+The analysis required _0.5 ms_ (including parsing and normalization and the query) within the generation environment.	
 
 In general, the JSON contains the Ids of the nodes in question as they are present in the normalized AST or the dataflow graph of flowR.
 Please consult the [Interface](https://github.com/flowr-analysis/flowr/wiki/Interface) wiki page for more information on how to get those.
@@ -2599,7 +2693,7 @@ Please consult the [Interface](https://github.com/flowr-analysis/flowr/wiki/Inte
     ]
   },
   ".meta": {
-    "timing": 1
+    "timing": 0
   }
 }
 ```
@@ -2622,7 +2716,7 @@ x + 1
 
 <summary style="color:gray">Dataflow Graph of the R Code</summary>
 
-The analysis required _2.6 ms_ (including parse and normalize, using the [r-shell](https://github.com/flowr-analysis/flowr/wiki/Engines) engine) within the generation environment. 
+The analysis required _0.4 ms_ (including parse and normalize, using the [r-shell](https://github.com/flowr-analysis/flowr/wiki/Engines) engine) within the generation environment. 
 We encountered no unknown side effects during the analysis.
 
 
@@ -2702,14 +2796,14 @@ print(x)` (with the `print(x)` in the second line), the following query returns
 
 _Results (prettified and summarized):_
 
-Query: **resolve-value** (5 ms)\
+Query: **resolve-value** (1 ms)\
 &nbsp;&nbsp;&nbsp;╰ Values for {2@x}\
 &nbsp;&nbsp;&nbsp;	╰ 1\
-_All queries together required ≈5 ms (1ms accuracy, total 18 ms)_
+_All queries together required ≈1 ms (1ms accuracy, total 1 ms)_
 
 <details> <summary style="color:gray">Show Detailed Results as Json</summary>
 
-The analysis required _17.8 ms_ (including parsing and normalization and the query) within the generation environment.	
+The analysis required _1.4 ms_ (including parsing and normalization and the query) within the generation environment.	
 
 In general, the JSON contains the Ids of the nodes in question as they are present in the normalized AST or the dataflow graph of flowR.
 Please consult the [Interface](https://github.com/flowr-analysis/flowr/wiki/Interface) wiki page for more information on how to get those.
@@ -2721,7 +2815,7 @@ Please consult the [Interface](https://github.com/flowr-analysis/flowr/wiki/Inte
 {
   "resolve-value": {
     ".meta": {
-      "timing": 5
+      "timing": 1
     },
     "results": {
       "{\"type\":\"resolve-value\",\"criteria\":[\"2@x\"]}": {
@@ -2736,7 +2830,7 @@ Please consult the [Interface](https://github.com/flowr-analysis/flowr/wiki/Inte
     }
   },
   ".meta": {
-    "timing": 5
+    "timing": 1
   }
 }
 ```
@@ -2760,7 +2854,7 @@ print(x)
 
 <summary style="color:gray">Dataflow Graph of the R Code</summary>
 
-The analysis required _3.0 ms_ (including parse and normalize, using the [r-shell](https://github.com/flowr-analysis/flowr/wiki/Engines) engine) within the generation environment. 
+The analysis required _0.6 ms_ (including parse and normalize, using the [r-shell](https://github.com/flowr-analysis/flowr/wiki/Engines) engine) within the generation environment. 
 We encountered unknown side effects (with ids: 6 (linked)) during the analysis.
 
 
@@ -2873,11 +2967,11 @@ _Results (prettified and summarized):_
 
 Query: **search** (0 ms)\
 &nbsp;&nbsp;&nbsp;╰ [query](https://mermaid.live/view#base64:eyJjb2RlIjoiZmxvd2NoYXJ0IExSXG4wKFwiPGI+Z2V0PC9iPihmaWx0ZXI6ICMxMjM7IzM0O25hbWUjMzQ7IzU4OyMzNDt4IzM0OyMxMjU7KTxici8+X2dlbmVyYXRvcl9cIikgLS0+IDFbXCI8Yj5maWx0ZXI8L2I+KGZpbHRlcjogIzM0O3VzZSMzNDspPGJyLz5fdHJhbnNmb3JtZXJfXCJdIiwibWVybWFpZCI6eyJhdXRvU3luYyI6dHJ1ZX19): {0}\
-_All queries together required ≈0 ms (1ms accuracy, total 3 ms)_
+_All queries together required ≈0 ms (1ms accuracy, total 1 ms)_
 
 <details> <summary style="color:gray">Show Detailed Results as Json</summary>
 
-The analysis required _3.3 ms_ (including parsing and normalization and the query) within the generation environment.	
+The analysis required _0.7 ms_ (including parsing and normalization and the query) within the generation environment.	
 
 In general, the JSON contains the Ids of the nodes in question as they are present in the normalized AST or the dataflow graph of flowR.
 Please consult the [Interface](https://github.com/flowr-analysis/flowr/wiki/Interface) wiki page for more information on how to get those.
@@ -2943,7 +3037,7 @@ x + 1
 
 <summary style="color:gray">Dataflow Graph of the R Code</summary>
 
-The analysis required _6.3 ms_ (including parse and normalize, using the [r-shell](https://github.com/flowr-analysis/flowr/wiki/Engines) engine) within the generation environment. 
+The analysis required _0.4 ms_ (including parse and normalize, using the [r-shell](https://github.com/flowr-analysis/flowr/wiki/Engines) engine) within the generation environment. 
 We encountered no unknown side effects during the analysis.
 
 
@@ -3033,14 +3127,14 @@ If you are interested in the parts required for the use of `x` in the last line,
 
 _Results (prettified and summarized):_
 
-Query: **static-slice** (2 ms)\
+Query: **static-slice** (0 ms)\
 &nbsp;&nbsp;&nbsp;╰ Slice for {3@x} \
 &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;╰ Code (newline as <code>&#92;n</code>): <code>x <- 1\\nx</code>\
-_All queries together required ≈2 ms (1ms accuracy, total 5 ms)_
+_All queries together required ≈0 ms (1ms accuracy, total 1 ms)_
 
 <details> <summary style="color:gray">Show Detailed Results as Json</summary>
 
-The analysis required _5.0 ms_ (including parsing and normalization and the query) within the generation environment.	
+The analysis required _1.3 ms_ (including parsing and normalization and the query) within the generation environment.	
 
 In general, the JSON contains the Ids of the nodes in question as they are present in the normalized AST or the dataflow graph of flowR.
 Please consult the [Interface](https://github.com/flowr-analysis/flowr/wiki/Interface) wiki page for more information on how to get those.
@@ -3052,7 +3146,7 @@ Please consult the [Interface](https://github.com/flowr-analysis/flowr/wiki/Inte
 {
   "static-slice": {
     ".meta": {
-      "timing": 2
+      "timing": 0
     },
     "results": {
       "{\"type\":\"static-slice\",\"criteria\":[\"3@x\"]}": {
@@ -3072,21 +3166,21 @@ Please consult the [Interface](https://github.com/flowr-analysis/flowr/wiki/Inte
             }
           ],
           ".meta": {
-            "timing": 1
+            "timing": 0
           }
         },
         "reconstruct": {
           "code": "x <- 1\nx",
           "linesWithAutoSelected": 0,
           ".meta": {
-            "timing": 1
+            "timing": 0
           }
         }
       }
     }
   },
   ".meta": {
-    "timing": 2
+    "timing": 0
   }
 }
 ```
@@ -3130,11 +3224,11 @@ _Results (prettified and summarized):_
 Query: **static-slice** (0 ms)\
 &nbsp;&nbsp;&nbsp;╰ Slice for {3@x} no reconstruction\
 &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;╰ Id List: {<span title="[6,0,1,2,'built-in:<-']">6, 0, 1, 2, built-in:<-, </span>}\
-_All queries together required ≈0 ms (1ms accuracy, total 2 ms)_
+_All queries together required ≈0 ms (1ms accuracy, total 1 ms)_
 
 <details> <summary style="color:gray">Show Detailed Results as Json</summary>
 
-The analysis required _2.2 ms_ (including parsing and normalization and the query) within the generation environment.	
+The analysis required _0.8 ms_ (including parsing and normalization and the query) within the generation environment.	
 
 In general, the JSON contains the Ids of the nodes in question as they are present in the normalized AST or the dataflow graph of flowR.
 Please consult the [Interface](https://github.com/flowr-analysis/flowr/wiki/Interface) wiki page for more information on how to get those.
@@ -3251,11 +3345,11 @@ _Results (prettified and summarized):_
 Query: **call-context** (0 ms)\
 &nbsp;&nbsp;&nbsp;╰ **visualize**\
 &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;╰ **text**: _`mean`_ (L.9), _`print`_ (L.10), _`mean`_ (L.19), _`print`_ (L.19)\
-_All queries together required ≈0 ms (1ms accuracy, total 6 ms)_
+_All queries together required ≈0 ms (1ms accuracy, total 3 ms)_
 
 <details> <summary style="color:gray">Show Detailed Results as Json</summary>
 
-The analysis required _6.3 ms_ (including parsing and normalization and the query) within the generation environment.	
+The analysis required _2.7 ms_ (including parsing and normalization and the query) within the generation environment.	
 
 In general, the JSON contains the Ids of the nodes in question as they are present in the normalized AST or the dataflow graph of flowR.
 Please consult the [Interface](https://github.com/flowr-analysis/flowr/wiki/Interface) wiki page for more information on how to get those.
@@ -3334,11 +3428,11 @@ _Results (prettified and summarized):_
 Query: **call-context** (0 ms)\
 &nbsp;&nbsp;&nbsp;╰ **visualize**\
 &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;╰ **text**: _`mean`_ (L.9), _`print`_ (L.10), _`mean`_ (L.19), _`print`_ (L.19)\
-_All queries together required ≈0 ms (1ms accuracy, total 8 ms)_
+_All queries together required ≈0 ms (1ms accuracy, total 4 ms)_
 
 <details> <summary style="color:gray">Show Detailed Results as Json</summary>
 
-The analysis required _7.7 ms_ (including parsing and normalization and the query) within the generation environment.	
+The analysis required _3.8 ms_ (including parsing and normalization and the query) within the generation environment.	
 
 In general, the JSON contains the Ids of the nodes in question as they are present in the normalized AST or the dataflow graph of flowR.
 Please consult the [Interface](https://github.com/flowr-analysis/flowr/wiki/Interface) wiki page for more information on how to get those.
@@ -3432,11 +3526,11 @@ _Results (prettified and summarized):_
 Query: **call-context** (0 ms)\
 &nbsp;&nbsp;&nbsp;╰ **visualize**\
 &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;╰ **text**: _`mean`_ (L.9) with 1 call (UNKNOWN: built-in (info: undefined)), _`mean`_ (L.19) with 1 call (UNKNOWN: built-in (info: undefined))\
-_All queries together required ≈0 ms (1ms accuracy, total 6 ms)_
+_All queries together required ≈0 ms (1ms accuracy, total 3 ms)_
 
 <details> <summary style="color:gray">Show Detailed Results as Json</summary>
 
-The analysis required _6.0 ms_ (including parsing and normalization and the query) within the generation environment.	
+The analysis required _2.7 ms_ (including parsing and normalization and the query) within the generation environment.	
 
 In general, the JSON contains the Ids of the nodes in question as they are present in the normalized AST or the dataflow graph of flowR.
 Please consult the [Interface](https://github.com/flowr-analysis/flowr/wiki/Interface) wiki page for more information on how to get those.

From 9693b40a4e0ebe7c9f68eb172f2ed9c98149609c Mon Sep 17 00:00:00 2001
From: Lukas Rohde <lukas.rohde@silupe.de>
Date: Sun, 1 Jun 2025 21:33:14 +0200
Subject: [PATCH 051/153] feat(typing): include dead code analysis passes when
 extracting the cfg

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

diff --git a/src/typing/infer.ts b/src/typing/infer.ts
index 990afb0931f..217916de62a 100644
--- a/src/typing/infer.ts
+++ b/src/typing/infer.ts
@@ -25,7 +25,7 @@ import type { NoInfo } from '../r-bridge/lang-4.x/ast/model/model';
 
 export function inferDataTypes<Info extends { typeVariable?: undefined }>(ast: NormalizedAst<Info>, dataflowInfo: DataflowInformation): NormalizedAst<Info & DataTypeInfo> {
 	const astWithTypeVars = decorateTypeVariables(ast);
-	const controlFlowInfo = extractCfg(astWithTypeVars);
+	const controlFlowInfo = extractCfg(astWithTypeVars, dataflowInfo.graph, ['unique-cf-sets', 'analyze-dead-code', 'remove-dead-code']);
 	const config = {
 		normalizedAst:        astWithTypeVars,
 		controlFlow:          controlFlowInfo,

From 6dab576d646f2a6773358cf4a21d2c42bbba61ff Mon Sep 17 00:00:00 2001
From: Lukas Rohde <lukas.rohde@silupe.de>
Date: Thu, 5 Jun 2025 18:34:18 +0200
Subject: [PATCH 052/153] test(typing): edit tests

---
 test/functionality/typing/if-else-type-inference.test.ts | 6 +++---
 test/functionality/typing/loop-type-inference.test.ts    | 2 +-
 2 files changed, 4 insertions(+), 4 deletions(-)

diff --git a/test/functionality/typing/if-else-type-inference.test.ts b/test/functionality/typing/if-else-type-inference.test.ts
index e27b2b98963..23992a842df 100644
--- a/test/functionality/typing/if-else-type-inference.test.ts
+++ b/test/functionality/typing/if-else-type-inference.test.ts
@@ -6,9 +6,9 @@ import { RType } from '../../../src/r-bridge/lang-4.x/ast/model/type';
 
 describe('Infer types for if statements', () => {
 	describe.each([
-		{ input: 'if(FALSE) { TRUE }',           expectedType: { tag: RDataTypeTag.Null as const } },
-		{ input: 'if(TRUE) { 1 } else { NULL }', expectedType: { tag: RDataTypeTag.Integer as const } },
-		{ input: 'if(stop("stop here")) { 1 } else { 2 }', expectedType: { tag: RDataTypeTag.Never as const } },
+		{ input: 'if(FALSE) { TRUE }',                     expectedType: { tag: RDataTypeTag.Null as const } },
+		{ input: 'if(TRUE) { 1 } else { NULL }',           expectedType: { tag: RDataTypeTag.Integer as const } },
+		{ input: 'if(stop("stop here")) { 1 } else { 2 }', expectedType: { tag: RDataTypeTag.Integer as const } },
 	])('Infer $expectedType for $input', ({ input, expectedType }) => assertInferredType(input, expectedType));
 
 	assertInferredTypes(
diff --git a/test/functionality/typing/loop-type-inference.test.ts b/test/functionality/typing/loop-type-inference.test.ts
index 159cab3c5fb..2d1dc49732e 100644
--- a/test/functionality/typing/loop-type-inference.test.ts
+++ b/test/functionality/typing/loop-type-inference.test.ts
@@ -8,7 +8,7 @@ describe('Infer types for loops', () => {
 	describe.each([
 		{ input: 'while(FALSE) { print("Testing is fun!") }',                         expectedType: { tag: RDataTypeTag.Null as const } },
 		{ input: 'while(TRUE) { next }',                                              expectedType: { tag: RDataTypeTag.Never as const } },
-		{ input: 'while(1 < 2) { print("Hi Flo!") }',                                 expectedType: { tag: RDataTypeTag.Never as const } },
+		{ input: 'while(1 < 2) { print("Hi Flo!") }',                                 expectedType: { tag: RDataTypeTag.Null as const } },
 		{ input: 'while(TRUE) { break }',                                             expectedType: { tag: RDataTypeTag.Null as const } },
 		{ input: 'for(i in NULL) { print("I would like to write a test for that") }', expectedType: { tag: RDataTypeTag.Null as const } },
 		{ input: 'for(i in 1:10) { print(i) }',                                       expectedType: { tag: RDataTypeTag.Null as const } },

From a676aad0d8f5adeb05191f5fffd7f9de65c67fa3 Mon Sep 17 00:00:00 2001
From: Lukas Rohde <lukas.rohde@silupe.de>
Date: Thu, 5 Jun 2025 19:24:00 +0200
Subject: [PATCH 053/153] feat(typing): properly track conflicting types within
 `RErrorType`

---
 src/typing/types.ts | 19 +++++++++++++++++--
 1 file changed, 17 insertions(+), 2 deletions(-)

diff --git a/src/typing/types.ts b/src/typing/types.ts
index 566c9d487de..fb855c11c88 100644
--- a/src/typing/types.ts
+++ b/src/typing/types.ts
@@ -143,15 +143,30 @@ export class RTypeVariable {
 			otherRep.boundType = thisRep;
 		} else if(thisRep instanceof UnresolvedRFunctionType && otherRep instanceof UnresolvedRFunctionType && thisRep.parameterTypes.length === otherRep.parameterTypes.length) {
 			thisRep.unify(otherRep);
+		} else if(thisRep instanceof RErrorType && otherRep instanceof RErrorType) {
+			otherRep.conflictingTypes.push(...thisRep.conflictingTypes);
+			this.boundType = otherRep;
 		} else if(thisRep.tag !== otherRep.tag) {
-			this.boundType = new RErrorType();
+			if(thisRep instanceof RErrorType) {
+				thisRep.conflictingTypes.push(otherRep);
+			} else if(otherRep instanceof RErrorType) {
+				otherRep.conflictingTypes.push(thisRep);
+				this.boundType = otherRep;
+			} else {
+				this.boundType = new RErrorType([thisRep, otherRep]);
+			}
 		}
 	}
 }
 
 export class RErrorType {
 	readonly tag = RDataTypeTag.Error;
-	conflicingTypes: RDataType[] = [];
+
+	constructor(conflictingTypes: UnresolvedRDataType[]) {
+		this.conflictingTypes = conflictingTypes;
+	}	
+
+	conflictingTypes: UnresolvedRDataType[];
 }
 
 

From 6f65c7e1e91af55f53c462dc941c5cbdacf3bcb8 Mon Sep 17 00:00:00 2001
From: Lukas Rohde <lukas.rohde@silupe.de>
Date: Fri, 6 Jun 2025 15:08:16 +0200
Subject: [PATCH 054/153] refactor(typing): refactor typing of if-then-else
 calls

---
 src/typing/infer.ts | 53 +++++++++++++++++++++++++--------------------
 1 file changed, 30 insertions(+), 23 deletions(-)

diff --git a/src/typing/infer.ts b/src/typing/infer.ts
index a586c4c7459..01644dbabbb 100644
--- a/src/typing/infer.ts
+++ b/src/typing/infer.ts
@@ -18,10 +18,11 @@ import { edgeIncludesType, EdgeType } from '../dataflow/graph/edge';
 import { EmptyArgument } from '../r-bridge/lang-4.x/ast/model/nodes/r-function-call';
 import type { FunctionArgument } from '../dataflow/graph/graph';
 import type { ControlFlowInformation } from '../control-flow/control-flow-graph';
-import { CfgVertexType } from '../control-flow/control-flow-graph';
+import { CfgEdgeType, CfgVertexType } from '../control-flow/control-flow-graph';
 import type { RSymbol } from '../r-bridge/lang-4.x/ast/model/nodes/r-symbol';
 import { RType } from '../r-bridge/lang-4.x/ast/model/type';
 import type { NoInfo } from '../r-bridge/lang-4.x/ast/model/model';
+import { RFalse, RTrue } from '../r-bridge/lang-4.x/convert-values';
 
 export function inferDataTypes<Info extends { typeVariable?: undefined }>(ast: NormalizedAst<Info>, dataflowInfo: DataflowInformation): NormalizedAst<Info & DataTypeInfo> {
 	const astWithTypeVars = decorateTypeVariables(ast);
@@ -214,40 +215,46 @@ class TypeInferringCfgGuidedVisitor<
 		
 		guard(conditionNode !== undefined, 'Expected condition node to be defined');
 		conditionNode.info.typeVariable.unify(new RLogicalType());
+		
+		const cfgVertex = this.config.controlFlow.graph.getVertex(data.call.id);
+		guard(cfgVertex !== undefined && (cfgVertex.type === CfgVertexType.Statement || cfgVertex.type === CfgVertexType.Expression),
+			'Expected statement or expression vertex for if-then-else');
+		const cfgEndVertexId = cfgVertex.end?.at(0);
+		guard(cfgEndVertexId !== undefined && cfgVertex.end?.length === 1, 'Expected exactly one end vertex for if-then-else');
+		
+		const isThenBranchReachable = this.config.controlFlow.graph.outgoingEdges(data.then ?? cfgEndVertexId)?.values().some((edge) => {
+			return edge.label === CfgEdgeType.Cd && edge.when === RTrue;
+		}) ?? false;
+		const isElseBranchReachable = this.config.controlFlow.graph.outgoingEdges(data.else ?? cfgEndVertexId)?.values().some((edge) =>{
+			return edge.label === CfgEdgeType.Cd && edge.when === RFalse;
+		}) ?? false;
 
 		const node = this.getNormalizedAst(data.call.id);
 		guard(node !== undefined, 'Expected AST node to be defined');
-
-		if(data.then !== undefined) {
-			const isThenBranchReachable = (this.config.controlFlow.graph.ingoingEdges(data.then)?.size ?? 0) > 0;
-			
-			const thenNode = this.getNormalizedAst(data.then);
-			guard(thenNode !== undefined, 'Expected then node to be defined');
-
-			if(isThenBranchReachable) {
+		
+		if(isThenBranchReachable) {
+			if(data.then !== undefined) {	
+				const thenNode = this.getNormalizedAst(data.then);
+				guard(thenNode !== undefined, 'Expected then node to be defined');
 				node.info.typeVariable.unify(thenNode.info.typeVariable);
 			} else {
-				node.info.typeVariable.unify(new RNeverType());
+				// If there is no then branch, we can assume that the type is null
+				node.info.typeVariable.unify(new RNullType());
 			}
 		} else {
-			// If there is no then branch, we can assume that the type is null
-			node.info.typeVariable.unify(new RNullType());
+			node.info.typeVariable.unify(new RNeverType());
 		}
-
-		if(data.else !== undefined) {
-			const isElseBranchReachable = (this.config.controlFlow.graph.ingoingEdges(data.else)?.size ?? 0) > 0;
-
-			const elseNode = this.getNormalizedAst(data.else);
-			guard(elseNode !== undefined, 'Expected else node to be defined');
-
-			if(isElseBranchReachable) {
+		if(isElseBranchReachable) {
+			if(data.else !== undefined) {
+				const elseNode = this.getNormalizedAst(data.else);
+				guard(elseNode !== undefined, 'Expected else node to be defined');
 				node.info.typeVariable.unify(elseNode.info.typeVariable);
 			} else {
-				node.info.typeVariable.unify(new RNeverType());
+				// If there is no else branch, we can assume that the type is null
+				node.info.typeVariable.unify(new RNullType());
 			}
 		} else {
-			// If there is no else branch, we can assume that the type is null
-			node.info.typeVariable.unify(new RNullType());
+			node.info.typeVariable.unify(new RNeverType());
 		}
 	}
 	

From f7bb39d5ece9ce208fc0ad43293d67501e8f0dc2 Mon Sep 17 00:00:00 2001
From: Lukas Rohde <lukas.rohde@silupe.de>
Date: Sun, 8 Jun 2025 12:53:04 +0200
Subject: [PATCH 055/153] refactor(typing): remove `Any` and `Never` and
 introduce `Unknown` type

`Any` and `Never` are incompatible with the current unification-based approach of the type inference system and will be reintroduced for implementing a system with support for subtyping in the future.
---
 src/typing/infer.ts                           | 16 ++--------
 src/typing/types.ts                           | 29 +++++++------------
 .../builtin-function-type-inference.test.ts   |  2 +-
 .../typing/loop-type-inference.test.ts        |  4 +--
 ...upported-expression-type-inference.test.ts |  4 +--
 5 files changed, 19 insertions(+), 36 deletions(-)

diff --git a/src/typing/infer.ts b/src/typing/infer.ts
index 01644dbabbb..bf3713c13da 100644
--- a/src/typing/infer.ts
+++ b/src/typing/infer.ts
@@ -9,7 +9,7 @@ import type { RString } from '../r-bridge/lang-4.x/ast/model/nodes/r-string';
 import type { NormalizedAst, ParentInformation } from '../r-bridge/lang-4.x/ast/model/processing/decorate';
 import { mapNormalizedAstInfo } from '../r-bridge/lang-4.x/ast/model/processing/decorate';
 import type { RDataType } from './types';
-import { RTypeVariable , RComplexType, RDoubleType, RIntegerType, RLogicalType, RStringType, resolveType, RNullType, RNeverType, RListType, RLanguageType, RAnyType, UnresolvedRFunctionType } from './types';
+import { RTypeVariable , RComplexType, RDoubleType, RIntegerType, RLogicalType, RStringType, resolveType, RNullType, RListType, RLanguageType, UnresolvedRFunctionType } from './types';
 import type { RExpressionList } from '../r-bridge/lang-4.x/ast/model/nodes/r-expression-list';
 import { guard } from '../util/assert';
 import { OriginType } from '../dataflow/origin/dfg-get-origin';
@@ -200,11 +200,9 @@ class TypeInferringCfgGuidedVisitor<
 
 		const cfgVertex = this.config.controlFlow.graph.getVertex(data.call.id);
 		guard(cfgVertex !== undefined && cfgVertex.type === CfgVertexType.Statement, 'Expected statement vertex for loop');
-		const isInfinite = (cfgVertex.end ?? []).reduce((prevCount, id) => prevCount + (this.config.controlFlow.graph.outgoingEdges(id)?.size ?? 0), 0) === 0;
+		const isFinite = (cfgVertex.end ?? []).reduce((prevCount, id) => prevCount + (this.config.controlFlow.graph.outgoingEdges(id)?.size ?? 0), 0) > 0;
 
-		if(isInfinite) {
-			node.info.typeVariable.unify(new RNeverType());
-		} else {
+		if(isFinite) {
 			node.info.typeVariable.unify(new RNullType());
 		}
 	}
@@ -241,8 +239,6 @@ class TypeInferringCfgGuidedVisitor<
 				// If there is no then branch, we can assume that the type is null
 				node.info.typeVariable.unify(new RNullType());
 			}
-		} else {
-			node.info.typeVariable.unify(new RNeverType());
 		}
 		if(isElseBranchReachable) {
 			if(data.else !== undefined) {
@@ -253,8 +249,6 @@ class TypeInferringCfgGuidedVisitor<
 				// If there is no else branch, we can assume that the type is null
 				node.info.typeVariable.unify(new RNullType());
 			}
-		} else {
-			node.info.typeVariable.unify(new RNeverType());
 		}
 	}
 	
@@ -277,10 +271,6 @@ class TypeInferringCfgGuidedVisitor<
 		
 		guard(argNode !== undefined, 'Expected argument node to be defined');
 		argNode.info.typeVariable.unify(new RLanguageType());
-
-		const node = this.getNormalizedAst(data.call.id);
-		guard(node !== undefined, 'Expected AST node to be defined');
-		node.info.typeVariable.unify(new RAnyType()); // TODO: Infer a more specific type based on the argument if possible
 	}
 
 	override onListCall(data: { call: DataflowGraphVertexFunctionCall }) {
diff --git a/src/typing/types.ts b/src/typing/types.ts
index fb855c11c88..236068ba156 100644
--- a/src/typing/types.ts
+++ b/src/typing/types.ts
@@ -5,8 +5,6 @@ import { guard } from '../util/assert';
  * type inferencer. It is mainly used to identify subtypes of {@link RDataType}.
  */
 export enum RDataTypeTag {
-    /** {@link RAnyType} */
-    Any = 'RAnyType',
     /** {@link RLogicalType} */
     Logical = 'RLogicalType',
     /** {@link RIntegerType} */
@@ -30,15 +28,11 @@ export enum RDataTypeTag {
     /** {@link RLanguageType} */
     Language = 'RLanguageType',
 	/** {@link RNeverType} */
-	Never = 'RNeverType',
-    /** {@link RTypeVariable} */
     Variable = 'RTypeVariable',
 	/** {@link RErrorType} */
 	Error = 'RErrorType',
-}
-
-export class RAnyType {
-	readonly tag = RDataTypeTag.Any;
+	/** {@link RUnknownType} */
+	Unknown = 'RUnknownType',
 }
 
 export class RLogicalType {
@@ -114,10 +108,6 @@ export class RLanguageType {
 	readonly tag = RDataTypeTag.Language;
 }
 
-export class RNeverType {
-	readonly tag = RDataTypeTag.Never;
-}
-
 export class RTypeVariable {
 	readonly tag = RDataTypeTag.Variable;
 	private boundType: UnresolvedRDataType | undefined;
@@ -169,11 +159,15 @@ export class RErrorType {
 	conflictingTypes: UnresolvedRDataType[];
 }
 
+export class RUnknownType {
+	readonly tag = RDataTypeTag.Unknown;
+}
+
 
 export function resolveType(type: UnresolvedRDataType): RDataType {
 	if(type instanceof RTypeVariable) {
 		const typeRep = type.find();
-		return typeRep !== type ? resolveType(typeRep) : { tag: RDataTypeTag.Any };
+		return typeRep !== type ? resolveType(typeRep) : { tag: RDataTypeTag.Unknown };
 	} else if(type instanceof UnresolvedRFunctionType) {
 		const resolvedParameterTypes = type.parameterTypes.map(resolveType);
 		const resolvedReturnType = resolveType(type.returnType);
@@ -203,14 +197,13 @@ export type CompoundRDataType = RFunctionType;
  * It should be used whenever you either not care what kind of
  * type you are dealing with or if you want to handle all possible types.
  */
-export type RDataType = RAnyType | RNeverType | PrimitiveRDataType | CompoundRDataType | RErrorType;
+export type RDataType = PrimitiveRDataType | CompoundRDataType | RErrorType | RUnknownType;
 
 export type UnresolvedCompoundRDataType = UnresolvedRFunctionType;
 
 export type UnresolvedRDataType
-	= RAnyType
-	| RNeverType
-	| PrimitiveRDataType
+	= PrimitiveRDataType
 	| UnresolvedCompoundRDataType
 	| RTypeVariable
-	| RErrorType;
\ No newline at end of file
+	| RErrorType
+	| RUnknownType;
\ No newline at end of file
diff --git a/test/functionality/typing/builtin-function-type-inference.test.ts b/test/functionality/typing/builtin-function-type-inference.test.ts
index ed68af19ff4..c083ead2d6c 100644
--- a/test/functionality/typing/builtin-function-type-inference.test.ts
+++ b/test/functionality/typing/builtin-function-type-inference.test.ts
@@ -15,7 +15,7 @@ describe('Infer types for builtin functions', () => {
 
 	assertInferredTypes(
 		'eval(quote(TRUE))',
-		{ query: Q.criterion('1@eval').build(), expectedType: { tag: RDataTypeTag.Any as const } },
+		{ query: Q.criterion('1@eval').build(), expectedType: { tag: RDataTypeTag.Unknown as const } },
 		{ query: Q.criterion('1@quote').build(), expectedType: { tag: RDataTypeTag.Language as const } },
 		{ query: Q.criterion('1@TRUE').build(), expectedType: { tag: RDataTypeTag.Logical as const } }
 	);
diff --git a/test/functionality/typing/loop-type-inference.test.ts b/test/functionality/typing/loop-type-inference.test.ts
index 2d1dc49732e..cb184643aba 100644
--- a/test/functionality/typing/loop-type-inference.test.ts
+++ b/test/functionality/typing/loop-type-inference.test.ts
@@ -7,12 +7,12 @@ import { RType } from '../../../src/r-bridge/lang-4.x/ast/model/type';
 describe('Infer types for loops', () => {
 	describe.each([
 		{ input: 'while(FALSE) { print("Testing is fun!") }',                         expectedType: { tag: RDataTypeTag.Null as const } },
-		{ input: 'while(TRUE) { next }',                                              expectedType: { tag: RDataTypeTag.Never as const } },
+		{ input: 'while(TRUE) { next }',                                              expectedType: { tag: RDataTypeTag.Unknown as const } },
 		{ input: 'while(1 < 2) { print("Hi Flo!") }',                                 expectedType: { tag: RDataTypeTag.Null as const } },
 		{ input: 'while(TRUE) { break }',                                             expectedType: { tag: RDataTypeTag.Null as const } },
 		{ input: 'for(i in NULL) { print("I would like to write a test for that") }', expectedType: { tag: RDataTypeTag.Null as const } },
 		{ input: 'for(i in 1:10) { print(i) }',                                       expectedType: { tag: RDataTypeTag.Null as const } },
-		{ input: 'repeat { print("I love testing!") }',                               expectedType: { tag: RDataTypeTag.Never as const } },
+		{ input: 'repeat { print("I love testing!") }',                               expectedType: { tag: RDataTypeTag.Unknown as const } },
 		{ input: 'repeat { break }',                                                  expectedType: { tag: RDataTypeTag.Null as const } }
 	])('Infer $expectedType for $input', ({ input, expectedType }) => assertInferredType(input, expectedType));
 
diff --git a/test/functionality/typing/unsupported-expression-type-inference.test.ts b/test/functionality/typing/unsupported-expression-type-inference.test.ts
index 936aacab809..295bc06ae5f 100644
--- a/test/functionality/typing/unsupported-expression-type-inference.test.ts
+++ b/test/functionality/typing/unsupported-expression-type-inference.test.ts
@@ -3,6 +3,6 @@ import { RDataTypeTag } from '../../../src/typing/types';
 import { assertInferredType } from '../_helper/typing/assert-inferred-type';
 
 describe('Infer no type information for currently unsupported R expressions', () => {
-	assertInferredType('1 + 2',                  { tag: RDataTypeTag.Any });
-	assertInferredType('print("Hello, world!")', { tag: RDataTypeTag.Any });
+	assertInferredType('1 + 2',                  { tag: RDataTypeTag.Unknown });
+	assertInferredType('print("Hello, world!")', { tag: RDataTypeTag.Unknown });
 });
\ No newline at end of file

From 8565e11c279ae87a9d38e80bf4ad84cf2a5169e5 Mon Sep 17 00:00:00 2001
From: Lukas Rohde <lukas.rohde@silupe.de>
Date: Sun, 8 Jun 2025 13:37:02 +0200
Subject: [PATCH 056/153] feat-fix(typing): fix typing of `get` calls

---
 src/typing/infer.ts | 30 +++++++++++++++++++++++++-----
 1 file changed, 25 insertions(+), 5 deletions(-)

diff --git a/src/typing/infer.ts b/src/typing/infer.ts
index bf3713c13da..e573e279803 100644
--- a/src/typing/infer.ts
+++ b/src/typing/infer.ts
@@ -102,17 +102,23 @@ class TypeInferringCfgGuidedVisitor<
 	}
 
 	override onVariableUse(data: { vertex: DataflowGraphVertexUse }): void {
-		const node = this.getNormalizedAst(data.vertex.id);
-		guard(node !== undefined, 'Expected AST node to be defined');
+		const isArgumentOfGetCall = this.config.dfg.ingoingEdges(data.vertex.id)?.entries().some(([source, edge]) => {
+			return edgeIncludesType(edge.types, EdgeType.Argument) &&
+				(this.config.dfg.getVertex(source)?.origin as string[] | undefined)?.includes('builtin:get');
+		}) ?? false;
+		if(isArgumentOfGetCall) {
+			// If the variable use occurs through a `get` call, it is already handled by the `onGetCall` method
+			return;
+		}
 		
-		const origins = this.getOrigins(data.vertex.id);
-		const readOrigins = origins?.filter((origin) => origin.type === OriginType.ReadVariableOrigin);
+		const node = this.getNormalizedAst(data.vertex.id);
+		guard(node !== undefined, 'Expected AST node to be defined');		
 
+		const readOrigins = this.getOrigins(data.vertex.id)?.filter((origin) => origin.type === OriginType.ReadVariableOrigin);
 		if(readOrigins === undefined || readOrigins.length === 0) {
 			node.info.typeVariable.unify(new RNullType());
 			return;
 		}
-
 		for(const readOrigin of readOrigins) {
 			const readNode = this.getNormalizedAst(readOrigin.id);
 			guard(readNode !== undefined, 'Expected read node to be defined');
@@ -161,6 +167,20 @@ class TypeInferringCfgGuidedVisitor<
 
 		guard(varNameNode !== undefined, 'Expected variable name node to be defined');
 		varNameNode.info.typeVariable.unify(new RStringType());
+
+		const node = this.getNormalizedAst(data.call.id);
+		guard(node !== undefined, 'Expected AST node to be defined');
+
+		const varReadOrigins = this.getOrigins(varName.nodeId)?.filter((origin) => origin.type === OriginType.ReadVariableOrigin);
+		if(varReadOrigins === undefined || varReadOrigins.length === 0) {
+			node.info.typeVariable.unify(new RNullType());
+			return;
+		}
+		for(const readOrigin of varReadOrigins) {
+			const readNode = this.getNormalizedAst(readOrigin.id);
+			guard(readNode !== undefined, 'Expected read node to be defined');
+			node.info.typeVariable.unify(readNode.info.typeVariable);
+		}
 	}
 
 	override onRmCall(data: { call: DataflowGraphVertexFunctionCall }) {

From d21fe032705a0388616a95a0bff132f248119a59 Mon Sep 17 00:00:00 2001
From: Lukas Rohde <lukas.rohde@silupe.de>
Date: Thu, 12 Jun 2025 11:57:58 +0200
Subject: [PATCH 057/153] feat(typing): make list datatypes more sophisticated

---
 src/typing/infer.ts |  4 ++--
 src/typing/types.ts | 53 ++++++++++++++++++++++++++++++++++++++-------
 2 files changed, 47 insertions(+), 10 deletions(-)

diff --git a/src/typing/infer.ts b/src/typing/infer.ts
index e573e279803..94897c08807 100644
--- a/src/typing/infer.ts
+++ b/src/typing/infer.ts
@@ -9,7 +9,7 @@ import type { RString } from '../r-bridge/lang-4.x/ast/model/nodes/r-string';
 import type { NormalizedAst, ParentInformation } from '../r-bridge/lang-4.x/ast/model/processing/decorate';
 import { mapNormalizedAstInfo } from '../r-bridge/lang-4.x/ast/model/processing/decorate';
 import type { RDataType } from './types';
-import { RTypeVariable , RComplexType, RDoubleType, RIntegerType, RLogicalType, RStringType, resolveType, RNullType, RListType, RLanguageType, UnresolvedRFunctionType } from './types';
+import { RTypeVariable , RComplexType, RDoubleType, RIntegerType, RLogicalType, RStringType, resolveType, RNullType, UnresolvedRListType, RLanguageType, UnresolvedRFunctionType } from './types';
 import type { RExpressionList } from '../r-bridge/lang-4.x/ast/model/nodes/r-expression-list';
 import { guard } from '../util/assert';
 import { OriginType } from '../dataflow/origin/dfg-get-origin';
@@ -296,7 +296,7 @@ class TypeInferringCfgGuidedVisitor<
 	override onListCall(data: { call: DataflowGraphVertexFunctionCall }) {
 		const node = this.getNormalizedAst(data.call.id);
 		guard(node !== undefined, 'Expected AST node to be defined');
-		node.info.typeVariable.unify(new RListType());
+		node.info.typeVariable.unify(new UnresolvedRListType());
 	}
 
 	override onVectorCall(data: { call: DataflowGraphVertexFunctionCall }) {
diff --git a/src/typing/types.ts b/src/typing/types.ts
index 236068ba156..a0bc8de7bf6 100644
--- a/src/typing/types.ts
+++ b/src/typing/types.ts
@@ -71,8 +71,8 @@ export class UnresolvedRFunctionType {
 		this.returnType = new RTypeVariable();
 	}
 
-	parameterTypes: RTypeVariable[];
-	returnType:     RTypeVariable;
+	readonly parameterTypes: RTypeVariable[];
+	readonly returnType:     RTypeVariable;
 
 	unify(other: UnresolvedRFunctionType): void {
 		guard(this.parameterTypes.length === other.parameterTypes.length, 'Expected the same number of parameters for function types to unify');
@@ -86,18 +86,50 @@ export class UnresolvedRFunctionType {
 
 export class RFunctionType {
 	readonly tag = RDataTypeTag.Function;
+	readonly parameterTypes: RDataType[];
+	readonly returnType:     RDataType;
 
 	constructor(parameterTypes: RDataType[], returnType: RDataType) {
 		this.parameterTypes = parameterTypes;
 		this.returnType = returnType;
 	}
+}
 
-	readonly parameterTypes: RDataType[];
-	readonly returnType:     RDataType;
+export class UnresolvedRListType {
+	readonly tag = RDataTypeTag.List;
+	readonly elementType:       RTypeVariable;
+	readonly namedElementTypes: Map<string, RTypeVariable>;
+
+	constructor(elementType?: UnresolvedRDataType) {
+		this.elementType = new RTypeVariable();
+		this.namedElementTypes = new Map<string, RTypeVariable>();
+		if(elementType !== undefined) {
+			this.elementType.unify(elementType);
+		}
+	}
+
+	constrainTypeForName(name: string, type: UnresolvedRDataType): void {
+		const existingType = this.namedElementTypes.get(name) ?? new RTypeVariable();
+		existingType.unify(type);
+
+		this.elementType.unify(type);
+	}
+	
+	unify(other: UnresolvedRListType): void {
+		this.elementType.unify(other.elementType);
+		for(const [name, type] of other.namedElementTypes) {
+			this.constrainTypeForName(name, type);
+		}
+	}
 }
 
 export class RListType {
 	readonly tag = RDataTypeTag.List;
+	readonly elementType: RDataType;
+
+	constructor(elementType: RDataType) {
+		this.elementType = elementType;
+	}
 }
 
 export class REnvironmentType {
@@ -133,6 +165,8 @@ export class RTypeVariable {
 			otherRep.boundType = thisRep;
 		} else if(thisRep instanceof UnresolvedRFunctionType && otherRep instanceof UnresolvedRFunctionType && thisRep.parameterTypes.length === otherRep.parameterTypes.length) {
 			thisRep.unify(otherRep);
+		} else if(thisRep instanceof UnresolvedRListType && otherRep instanceof UnresolvedRListType) {
+			thisRep.unify(otherRep);
 		} else if(thisRep instanceof RErrorType && otherRep instanceof RErrorType) {
 			otherRep.conflictingTypes.push(...thisRep.conflictingTypes);
 			this.boundType = otherRep;
@@ -172,8 +206,12 @@ export function resolveType(type: UnresolvedRDataType): RDataType {
 		const resolvedParameterTypes = type.parameterTypes.map(resolveType);
 		const resolvedReturnType = resolveType(type.returnType);
 		return new RFunctionType(resolvedParameterTypes, resolvedReturnType);
+	} else if(type instanceof UnresolvedRListType) {
+		const resolvedElementType = resolveType(type.elementType);
+		return new RListType(resolvedElementType);
+	} else {
+		return type;
 	}
-	return type;
 }
 
 
@@ -185,11 +223,10 @@ export type PrimitiveRDataType
 	| RStringType
 	| RRawType
 	| RNullType
-	| RListType
 	| REnvironmentType
 	| RLanguageType
 
-export type CompoundRDataType = RFunctionType;
+export type CompoundRDataType = RFunctionType | RListType;
 
 /**
  * The `RDataType` type is the union of all possible types that can be inferred
@@ -199,7 +236,7 @@ export type CompoundRDataType = RFunctionType;
  */
 export type RDataType = PrimitiveRDataType | CompoundRDataType | RErrorType | RUnknownType;
 
-export type UnresolvedCompoundRDataType = UnresolvedRFunctionType;
+export type UnresolvedCompoundRDataType = UnresolvedRFunctionType | UnresolvedRListType;
 
 export type UnresolvedRDataType
 	= PrimitiveRDataType

From ef3e14ddaba074844d36e6bf317c3c6ac2dee24a Mon Sep 17 00:00:00 2001
From: Lukas Rohde <lukas.rohde@silupe.de>
Date: Thu, 12 Jun 2025 15:18:44 +0200
Subject: [PATCH 058/153] feat(typing): infer types for list elements

---
 src/typing/infer.ts | 17 ++++++++++++++++-
 1 file changed, 16 insertions(+), 1 deletion(-)

diff --git a/src/typing/infer.ts b/src/typing/infer.ts
index 94897c08807..c2c0c7c3a6a 100644
--- a/src/typing/infer.ts
+++ b/src/typing/infer.ts
@@ -296,7 +296,22 @@ class TypeInferringCfgGuidedVisitor<
 	override onListCall(data: { call: DataflowGraphVertexFunctionCall }) {
 		const node = this.getNormalizedAst(data.call.id);
 		guard(node !== undefined, 'Expected AST node to be defined');
-		node.info.typeVariable.unify(new UnresolvedRListType());
+		const listType = new UnresolvedRListType();
+		node.info.typeVariable.unify(listType);
+
+		for(const arg of data.call.args) {
+			if(arg === EmptyArgument) {
+				continue; // Skip empty arguments
+			}
+
+			const argNode = this.getNormalizedAst(arg.nodeId);
+			guard(argNode !== undefined, 'Expected argument node to be defined');
+			if(arg.name !== undefined) {
+				listType.constrainTypeForName(arg.name, argNode.info.typeVariable);
+			} else {
+				listType.elementType.unify(argNode.info.typeVariable);
+			}
+		}
 	}
 
 	override onVectorCall(data: { call: DataflowGraphVertexFunctionCall }) {

From 03f255160da22df4a6ec58113a9d0ac8bcb38ce9 Mon Sep 17 00:00:00 2001
From: Lukas Rohde <lukas.rohde@silupe.de>
Date: Thu, 12 Jun 2025 17:33:49 +0200
Subject: [PATCH 059/153] feat(typing): make function and list type inference
 more sophisticated

---
 src/queries/query-print.ts |  2 +-
 src/typing/infer.ts        | 43 ++++++++++++++++++++++++---
 src/typing/types.ts        | 59 +++++++++++++++++++-------------------
 3 files changed, 70 insertions(+), 34 deletions(-)

diff --git a/src/queries/query-print.ts b/src/queries/query-print.ts
index bda6df1dfdd..dbbc4d41c37 100644
--- a/src/queries/query-print.ts
+++ b/src/queries/query-print.ts
@@ -79,7 +79,7 @@ export function summarizeIdsIfTooLong(formatter: OutputFormatter, ids: readonly
 
 export function asciiDataType(type: RDataType): string {
 	if(type.tag === RDataTypeTag.Function) {
-		return `Function(${type.parameterTypes.map(t => asciiDataType(t)).join(', ')}) -> ${asciiDataType(type.returnType)}`;
+		return `Function(${type.parameterTypes.entries().toArray().map(([key, type]) => `${key}: ${asciiDataType(type)}`).join(', ')}) -> ${asciiDataType(type.returnType)}`;
 	} else {
 		return type.tag;
 	}
diff --git a/src/typing/infer.ts b/src/typing/infer.ts
index c2c0c7c3a6a..3354a8450c4 100644
--- a/src/typing/infer.ts
+++ b/src/typing/infer.ts
@@ -146,12 +146,33 @@ class TypeInferringCfgGuidedVisitor<
 			.filter(([_target, edge]) => edgeIncludesType(edge.types, EdgeType.Calls))
 			.map(([target, _edge]) => target)
 			.toArray();
-			
 		guard(callTargets !== undefined && callTargets.length >= 1, 'Expected at least one target for default function call');
+		
+		const node = this.getNormalizedAst(data.call.id);
+		guard(node !== undefined, 'Expected AST node to be defined');
+
 		for(const target of callTargets) {
 			const targetNode = this.getNormalizedAst(target);
 			if(targetNode !== undefined) {
-				targetNode.info.typeVariable.unify(new UnresolvedRFunctionType(data.call.args.length));
+				const functionType = new UnresolvedRFunctionType();
+				targetNode.info.typeVariable.unify(functionType);
+
+				for(const [index, arg] of data.call.args.entries()) {
+					if(arg === EmptyArgument) {
+						continue; // Skip empty arguments
+					}
+
+					const argNode = this.getNormalizedAst(arg.nodeId);
+					guard(argNode !== undefined, 'Expected argument node to be defined');
+
+					if(arg.name !== undefined) {
+						functionType.constrainParameterType(arg.name, argNode.info.typeVariable);
+					} else {
+						functionType.constrainParameterType(index, argNode.info.typeVariable);
+					}
+				}
+
+				node.info.typeVariable.unify(functionType.returnType);
 			} else {
 				// TODO: Handle builtin functions that are not represented in the AST
 			}
@@ -307,7 +328,7 @@ class TypeInferringCfgGuidedVisitor<
 			const argNode = this.getNormalizedAst(arg.nodeId);
 			guard(argNode !== undefined, 'Expected argument node to be defined');
 			if(arg.name !== undefined) {
-				listType.constrainTypeForName(arg.name, argNode.info.typeVariable);
+				listType.constrainElementTypeForName(arg.name, argNode.info.typeVariable);
 			} else {
 				listType.elementType.unify(argNode.info.typeVariable);
 			}
@@ -334,7 +355,21 @@ class TypeInferringCfgGuidedVisitor<
 		const node = this.getNormalizedAst(data.vertex.id);
 		guard(node !== undefined && node.type === RType.FunctionDefinition, 'Expected AST node to be a function definition');
 
-		node.info.typeVariable.unify(new UnresolvedRFunctionType(node.parameters.length));
+		const functionType = new UnresolvedRFunctionType();
+		node.info.typeVariable.unify(functionType);
+
+		for(const [index, param] of node.parameters.entries()) {
+			if(param.special) {
+				continue; // Skip `...` parameters
+			}
+
+			functionType.constrainParameterType(index, param.info.typeVariable);
+			functionType.constrainParameterType(param.name.lexeme, param.info.typeVariable);
+			
+			if(param.defaultValue !== undefined) {
+				param.info.typeVariable.unify(param.defaultValue.info.typeVariable);
+			}
+		}
 	}
 
 	override onProgram(node: RExpressionList<UnresolvedTypeInfo>) {
diff --git a/src/typing/types.ts b/src/typing/types.ts
index a0bc8de7bf6..9320e1cabad 100644
--- a/src/typing/types.ts
+++ b/src/typing/types.ts
@@ -1,5 +1,3 @@
-import { guard } from '../util/assert';
-
 /**
  * This enum lists a tag for each of the possible R data types inferred by the
  * type inferencer. It is mainly used to identify subtypes of {@link RDataType}.
@@ -56,7 +54,7 @@ export class RStringType {
 }
 
 export class RRawType {
-	readonly tag =  RDataTypeTag.Raw;
+	readonly tag = RDataTypeTag.Raw;
 }
 
 export class RNullType {
@@ -65,20 +63,20 @@ export class RNullType {
 
 export class UnresolvedRFunctionType {
 	readonly tag = RDataTypeTag.Function;
+	readonly parameterTypes = new Map<number | string, RTypeVariable>();
+	readonly returnType = new RTypeVariable();
 
-	constructor(argumentCount: number) {
-		this.parameterTypes = Array.from({ length: argumentCount }, () => new RTypeVariable());
-		this.returnType = new RTypeVariable();
+	constrainParameterType(indexOrName: number | string, type: UnresolvedRDataType): void {
+		if(!this.parameterTypes.has(indexOrName)) {
+			this.parameterTypes.set(indexOrName, new RTypeVariable());
+		}
+		// eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+		this.parameterTypes.get(indexOrName)!.unify(type);
 	}
 
-	readonly parameterTypes: RTypeVariable[];
-	readonly returnType:     RTypeVariable;
-
 	unify(other: UnresolvedRFunctionType): void {
-		guard(this.parameterTypes.length === other.parameterTypes.length, 'Expected the same number of parameters for function types to unify');
-
-		for(let i = 0; i < this.parameterTypes.length; i++) {
-			this.parameterTypes[i].unify(other.parameterTypes[i]);
+		for(const [key, type] of other.parameterTypes) {
+			this.constrainParameterType(key, type);
 		}
 		this.returnType.unify(other.returnType);
 	}
@@ -86,10 +84,10 @@ export class UnresolvedRFunctionType {
 
 export class RFunctionType {
 	readonly tag = RDataTypeTag.Function;
-	readonly parameterTypes: RDataType[];
+	readonly parameterTypes: Map<number | string, RDataType>;
 	readonly returnType:     RDataType;
 
-	constructor(parameterTypes: RDataType[], returnType: RDataType) {
+	constructor(parameterTypes: Map<number | string, RDataType>, returnType: RDataType) {
 		this.parameterTypes = parameterTypes;
 		this.returnType = returnType;
 	}
@@ -97,38 +95,40 @@ export class RFunctionType {
 
 export class UnresolvedRListType {
 	readonly tag = RDataTypeTag.List;
-	readonly elementType:       RTypeVariable;
-	readonly namedElementTypes: Map<string, RTypeVariable>;
+	readonly elementType = new RTypeVariable();
+	readonly namedElementTypes = new Map<string, RTypeVariable>();
 
 	constructor(elementType?: UnresolvedRDataType) {
-		this.elementType = new RTypeVariable();
-		this.namedElementTypes = new Map<string, RTypeVariable>();
 		if(elementType !== undefined) {
 			this.elementType.unify(elementType);
 		}
 	}
 
-	constrainTypeForName(name: string, type: UnresolvedRDataType): void {
-		const existingType = this.namedElementTypes.get(name) ?? new RTypeVariable();
-		existingType.unify(type);
-
+	constrainElementTypeForName(name: string, type: UnresolvedRDataType): void {
+		if(!this.namedElementTypes.has(name)) {
+			this.namedElementTypes.set(name, new RTypeVariable());
+		}
+		// eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+		this.namedElementTypes.get(name)!.unify(type);
 		this.elementType.unify(type);
 	}
 	
 	unify(other: UnresolvedRListType): void {
 		this.elementType.unify(other.elementType);
 		for(const [name, type] of other.namedElementTypes) {
-			this.constrainTypeForName(name, type);
+			this.constrainElementTypeForName(name, type);
 		}
 	}
 }
 
 export class RListType {
 	readonly tag = RDataTypeTag.List;
-	readonly elementType: RDataType;
+	readonly elementType:       RDataType;
+	readonly namedElementTypes: Map<string, RDataType>;
 
-	constructor(elementType: RDataType) {
+	constructor(elementType: RDataType, namedElementTypes?: Map<string, RDataType>) {
 		this.elementType = elementType;
+		this.namedElementTypes = namedElementTypes ?? new Map<string, RDataType>();
 	}
 }
 
@@ -163,7 +163,7 @@ export class RTypeVariable {
 			thisRep.boundType = otherRep;
 		} else if(otherRep instanceof RTypeVariable) {
 			otherRep.boundType = thisRep;
-		} else if(thisRep instanceof UnresolvedRFunctionType && otherRep instanceof UnresolvedRFunctionType && thisRep.parameterTypes.length === otherRep.parameterTypes.length) {
+		} else if(thisRep instanceof UnresolvedRFunctionType && otherRep instanceof UnresolvedRFunctionType) {
 			thisRep.unify(otherRep);
 		} else if(thisRep instanceof UnresolvedRListType && otherRep instanceof UnresolvedRListType) {
 			thisRep.unify(otherRep);
@@ -203,12 +203,13 @@ export function resolveType(type: UnresolvedRDataType): RDataType {
 		const typeRep = type.find();
 		return typeRep !== type ? resolveType(typeRep) : { tag: RDataTypeTag.Unknown };
 	} else if(type instanceof UnresolvedRFunctionType) {
-		const resolvedParameterTypes = type.parameterTypes.map(resolveType);
+		const resolvedParameterTypes = new Map(type.parameterTypes.entries().toArray().map(([key, type]) => [key, resolveType(type)]));
 		const resolvedReturnType = resolveType(type.returnType);
 		return new RFunctionType(resolvedParameterTypes, resolvedReturnType);
 	} else if(type instanceof UnresolvedRListType) {
 		const resolvedElementType = resolveType(type.elementType);
-		return new RListType(resolvedElementType);
+		const resolvedNamedElementTypes = new Map(type.namedElementTypes.entries().toArray().map(([name, type]) => [name, resolveType(type)]));
+		return new RListType(resolvedElementType, resolvedNamedElementTypes);
 	} else {
 		return type;
 	}

From fe95551cf5e16d5d017463a8f61a1850e22b23ff Mon Sep 17 00:00:00 2001
From: Lukas Rohde <lukas.rohde@silupe.de>
Date: Thu, 12 Jun 2025 17:34:27 +0200
Subject: [PATCH 060/153] test-fix(typing): fix list typing test

---
 .../builtin-function-type-inference.test.ts   | 22 +++++++++----------
 1 file changed, 11 insertions(+), 11 deletions(-)

diff --git a/test/functionality/typing/builtin-function-type-inference.test.ts b/test/functionality/typing/builtin-function-type-inference.test.ts
index c083ead2d6c..b74c406352e 100644
--- a/test/functionality/typing/builtin-function-type-inference.test.ts
+++ b/test/functionality/typing/builtin-function-type-inference.test.ts
@@ -1,30 +1,30 @@
 import { describe } from 'vitest';
-import { RDataTypeTag } from '../../../src/typing/types';
+import { RIntegerType, RLanguageType, RListType, RLogicalType, RNullType, RStringType, RUnknownType } from '../../../src/typing/types';
 import { assertInferredType, assertInferredTypes } from '../_helper/typing/assert-inferred-type';
 import { Q } from '../../../src/search/flowr-search-builder';
 
 describe('Infer types for builtin functions', () => {
-	assertInferredType('rm(x)', { tag: RDataTypeTag.Null as const });
+	assertInferredType('rm(x)', new RNullType());
 
 	assertInferredTypes(
 		'x <- 42\nget("x")',
-		{ query: Q.criterion('1@x').build(), expectedType: { tag: RDataTypeTag.Integer as const } },
-		{ query: Q.criterion('2@get').build(), expectedType: { tag: RDataTypeTag.Integer as const } },
-		{ query: Q.criterion('2@"x"').build(), expectedType: { tag: RDataTypeTag.String as const } }
+		{ query: Q.criterion('1@x').build(),   expectedType: new RIntegerType() },
+		{ query: Q.criterion('2@get').build(), expectedType: new RIntegerType() },
+		{ query: Q.criterion('2@"x"').build(), expectedType: new RStringType() }
 	);
 
 	assertInferredTypes(
 		'eval(quote(TRUE))',
-		{ query: Q.criterion('1@eval').build(), expectedType: { tag: RDataTypeTag.Unknown as const } },
-		{ query: Q.criterion('1@quote').build(), expectedType: { tag: RDataTypeTag.Language as const } },
-		{ query: Q.criterion('1@TRUE').build(), expectedType: { tag: RDataTypeTag.Logical as const } }
+		{ query: Q.criterion('1@eval').build(),  expectedType: new RUnknownType() },
+		{ query: Q.criterion('1@quote').build(), expectedType: new RLanguageType() },
+		{ query: Q.criterion('1@TRUE').build(),  expectedType: new RLogicalType() }
 	);
 	
-	assertInferredType('list(1, 2, 3)', { tag: RDataTypeTag.List as const });
+	assertInferredType('list(1, 2, 3)', new RListType(new RIntegerType()));
 
 	assertInferredTypes(
 		'c("Hello", "Flo", "!")',
-		{ query: Q.criterion('1@c').build(), expectedType: { tag: RDataTypeTag.String as const } },
-		{ query: Q.criterion('1@"Hello"').build(), expectedType: { tag: RDataTypeTag.String as const } }
+		{ query: Q.criterion('1@c').build(),       expectedType: new RStringType() },
+		{ query: Q.criterion('1@"Hello"').build(), expectedType: new RStringType() },
 	);
 });
\ No newline at end of file

From 5e57e4cd13d1a96d3ffda1684e9398cd9f44cab5 Mon Sep 17 00:00:00 2001
From: Lukas Rohde <lukas.rohde@silupe.de>
Date: Thu, 12 Jun 2025 19:54:46 +0200
Subject: [PATCH 061/153] feat-fix(typing): ignore positional parameters
 occuring after `...`

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

diff --git a/src/typing/infer.ts b/src/typing/infer.ts
index 3354a8450c4..1379af277c1 100644
--- a/src/typing/infer.ts
+++ b/src/typing/infer.ts
@@ -358,12 +358,17 @@ class TypeInferringCfgGuidedVisitor<
 		const functionType = new UnresolvedRFunctionType();
 		node.info.typeVariable.unify(functionType);
 
+		let dotsEncountered = false;
 		for(const [index, param] of node.parameters.entries()) {
 			if(param.special) {
+				dotsEncountered = true;
 				continue; // Skip `...` parameters
 			}
 
-			functionType.constrainParameterType(index, param.info.typeVariable);
+			if(!dotsEncountered) {
+				// Only constrain the parameter type positionally if no `...` has been encountered yet
+				functionType.constrainParameterType(index, param.info.typeVariable);
+			}
 			functionType.constrainParameterType(param.name.lexeme, param.info.typeVariable);
 			
 			if(param.defaultValue !== undefined) {

From 2d6ad1ccaf1501ffe7f1440d3a4cc76543338292 Mon Sep 17 00:00:00 2001
From: Lukas Rohde <lukas.rohde@silupe.de>
Date: Fri, 13 Jun 2025 11:36:07 +0200
Subject: [PATCH 062/153] feat(typing): pretty-print list types

---
 src/queries/query-print.ts | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/src/queries/query-print.ts b/src/queries/query-print.ts
index dbbc4d41c37..fef054b7fa0 100644
--- a/src/queries/query-print.ts
+++ b/src/queries/query-print.ts
@@ -80,6 +80,8 @@ export function summarizeIdsIfTooLong(formatter: OutputFormatter, ids: readonly
 export function asciiDataType(type: RDataType): string {
 	if(type.tag === RDataTypeTag.Function) {
 		return `Function(${type.parameterTypes.entries().toArray().map(([key, type]) => `${key}: ${asciiDataType(type)}`).join(', ')}) -> ${asciiDataType(type.returnType)}`;
+	} else if(type.tag === RDataTypeTag.List) {
+		return `List(${asciiDataType(type.elementType)})`;
 	} else {
 		return type.tag;
 	}

From 920f7540073c197c7fe4681686eebcac0d2b8f7a Mon Sep 17 00:00:00 2001
From: Lukas Rohde <lukas.rohde@silupe.de>
Date: Fri, 13 Jun 2025 12:58:11 +0200
Subject: [PATCH 063/153] feat(typing): add discriminator functions for vector
 and compound types

---
 src/typing/types.ts | 40 +++++++++++++++++++++++++++++++---------
 1 file changed, 31 insertions(+), 9 deletions(-)

diff --git a/src/typing/types.ts b/src/typing/types.ts
index 9320e1cabad..28c2d6f52f2 100644
--- a/src/typing/types.ts
+++ b/src/typing/types.ts
@@ -216,31 +216,53 @@ export function resolveType(type: UnresolvedRDataType): RDataType {
 }
 
 
-export type PrimitiveRDataType
+export type RVectorType
 	= RLogicalType
 	| RIntegerType
 	| RDoubleType
 	| RComplexType
 	| RStringType
 	| RRawType
-	| RNullType
-	| REnvironmentType
-	| RLanguageType
 
+export function isVectorType(type: RDataType | UnresolvedRDataType): type is RVectorType {
+	return type.tag === RDataTypeTag.Logical
+		|| type.tag === RDataTypeTag.Integer
+		|| type.tag === RDataTypeTag.Double
+		|| type.tag === RDataTypeTag.Complex
+		|| type.tag === RDataTypeTag.String
+		|| type.tag === RDataTypeTag.Raw;
+}
+	
 export type CompoundRDataType = RFunctionType | RListType;
 
+export function isCompoundType(type: UnresolvedRDataType): type is UnresolvedCompoundRDataType
+export function isCompoundType(type: RDataType): type is CompoundRDataType
+export function isCompoundType(type: RDataType | UnresolvedRDataType): type is CompoundRDataType | UnresolvedCompoundRDataType {
+	return type.tag === RDataTypeTag.Function || type.tag === RDataTypeTag.List;
+}
+
 /**
  * The `RDataType` type is the union of all possible types that can be inferred
  * by the type inferencer for R objects.
  * It should be used whenever you either not care what kind of
  * type you are dealing with or if you want to handle all possible types.
- */
-export type RDataType = PrimitiveRDataType | CompoundRDataType | RErrorType | RUnknownType;
-
+*/
+export type RDataType
+	= RVectorType
+	| RNullType
+	| REnvironmentType
+	| RLanguageType
+	| CompoundRDataType
+	| RErrorType
+	| RUnknownType;
+	
 export type UnresolvedCompoundRDataType = UnresolvedRFunctionType | UnresolvedRListType;
-
+	
 export type UnresolvedRDataType
-	= PrimitiveRDataType
+	= RVectorType
+	| RNullType
+	| REnvironmentType
+	| RLanguageType
 	| UnresolvedCompoundRDataType
 	| RTypeVariable
 	| RErrorType

From 609820166b688d207de3ab0adbe140d0b3d20115 Mon Sep 17 00:00:00 2001
From: Lukas Rohde <lukas.rohde@silupe.de>
Date: Fri, 13 Jun 2025 13:01:47 +0200
Subject: [PATCH 064/153] feat(typing): implement preliminary inference for
 access calls

---
 src/typing/infer.ts | 44 +++++++++++++++++++++++++++++++++++++++++---
 1 file changed, 41 insertions(+), 3 deletions(-)

diff --git a/src/typing/infer.ts b/src/typing/infer.ts
index 1379af277c1..ad0f7b482bb 100644
--- a/src/typing/infer.ts
+++ b/src/typing/infer.ts
@@ -5,18 +5,18 @@ import type { DataflowGraphVertexFunctionCall, DataflowGraphVertexFunctionDefini
 import type { DataflowInformation } from '../dataflow/info';
 import type { RLogical } from '../r-bridge/lang-4.x/ast/model/nodes/r-logical';
 import type { RNumber } from '../r-bridge/lang-4.x/ast/model/nodes/r-number';
-import type { RString } from '../r-bridge/lang-4.x/ast/model/nodes/r-string';
+import { isRString, type RString } from '../r-bridge/lang-4.x/ast/model/nodes/r-string';
 import type { NormalizedAst, ParentInformation } from '../r-bridge/lang-4.x/ast/model/processing/decorate';
 import { mapNormalizedAstInfo } from '../r-bridge/lang-4.x/ast/model/processing/decorate';
 import type { RDataType } from './types';
-import { RTypeVariable , RComplexType, RDoubleType, RIntegerType, RLogicalType, RStringType, resolveType, RNullType, UnresolvedRListType, RLanguageType, UnresolvedRFunctionType } from './types';
+import { RTypeVariable, RComplexType, RDoubleType, RIntegerType, RLogicalType, RStringType, resolveType, RNullType, UnresolvedRListType, RLanguageType, UnresolvedRFunctionType, RVectorType, isVectorType } from './types';
 import type { RExpressionList } from '../r-bridge/lang-4.x/ast/model/nodes/r-expression-list';
 import { guard } from '../util/assert';
 import { OriginType } from '../dataflow/origin/dfg-get-origin';
 import type { NodeId } from '../r-bridge/lang-4.x/ast/model/processing/node-id';
 import { edgeIncludesType, EdgeType } from '../dataflow/graph/edge';
 import { EmptyArgument } from '../r-bridge/lang-4.x/ast/model/nodes/r-function-call';
-import type { FunctionArgument } from '../dataflow/graph/graph';
+import { isPositionalArgument, type FunctionArgument } from '../dataflow/graph/graph';
 import type { ControlFlowInformation } from '../control-flow/control-flow-graph';
 import { CfgEdgeType, CfgVertexType } from '../control-flow/control-flow-graph';
 import type { RSymbol } from '../r-bridge/lang-4.x/ast/model/nodes/r-symbol';
@@ -414,4 +414,42 @@ class TypeInferringCfgGuidedVisitor<
 			node.info.typeVariable.unify(candidate.info.typeVariable);
 		}
 	}
+
+	override onAccessCall(data: { call: DataflowGraphVertexFunctionCall; }): void {
+		const node = this.getNormalizedAst(data.call.id);
+		guard(node !== undefined, 'Expected AST node to be defined');
+
+		const firstArg = data.call.args.at(0);
+		guard(firstArg !== undefined && firstArg !== EmptyArgument, 'Expected first argument of access call to be defined');
+		const firstArgNode = this.getNormalizedAst(firstArg.nodeId);
+		guard(firstArgNode !== undefined, 'Expected first argument node to be defined');
+		const firstArgType = firstArgNode.info.typeVariable;
+		const firstArgBoundType = firstArgType.find();
+
+		const secondArg = data.call.args.at(1);
+		const secondArgNode = secondArg !== undefined && isPositionalArgument(secondArg) ? this.getNormalizedAst(secondArg.nodeId) : undefined;
+		
+		console.log('Access call origin:', data.call.origin);
+		switch(data.call.origin) {
+			case ['builtin:[']:
+				// If the access call is a `[` operation, we can assume that the it returns a subset
+				// of the first argument's elements as another instance of the same container type
+				node.info.typeVariable.unify(firstArgNode.info.typeVariable);
+				break;
+			case ['builtin:[[']:
+				if(firstArgBoundType instanceof UnresolvedRListType) {
+					const retrievedElementType = (isRString(secondArgNode) ? firstArgBoundType.namedElementTypes.get(secondArgNode.content.str) : undefined) ?? firstArgBoundType.elementType;
+					node.info.typeVariable.unify(retrievedElementType);
+				} else if(isVectorType(firstArgBoundType) || firstArgBoundType instanceof RNullType) {
+					node.info.typeVariable.unify(firstArgType);
+				}
+				break;
+			case ['builtin:$']:
+				if(firstArgBoundType instanceof UnresolvedRListType) {
+					const retrievedElementType = (secondArgNode !== undefined && secondArgNode.type === RType.Symbol ? firstArgBoundType.namedElementTypes.get(secondArgNode.content) : undefined) ?? firstArgBoundType.elementType;
+					node.info.typeVariable.unify(retrievedElementType);
+				}
+				break;
+		}
+	}
 }
\ No newline at end of file

From ae89b421963761fc188271f7d8222ad9c8386172 Mon Sep 17 00:00:00 2001
From: Lukas Rohde <lukas.rohde@silupe.de>
Date: Fri, 13 Jun 2025 13:28:57 +0200
Subject: [PATCH 065/153] refactor(typing): only infer `RIntegerType` for
 marked number constants

---
 src/typing/infer.ts                               |  4 ++--
 .../builtin-function-type-inference.test.ts       |  8 ++++----
 .../constant-expression-type-inference.test.ts    | 15 ++++++++-------
 .../typing/if-else-type-inference.test.ts         | 12 ++++++------
 .../typing/variable-type-inference.test.ts        | 10 +++++-----
 5 files changed, 25 insertions(+), 24 deletions(-)

diff --git a/src/typing/infer.ts b/src/typing/infer.ts
index ad0f7b482bb..45327a559b7 100644
--- a/src/typing/infer.ts
+++ b/src/typing/infer.ts
@@ -9,7 +9,7 @@ import { isRString, type RString } from '../r-bridge/lang-4.x/ast/model/nodes/r-
 import type { NormalizedAst, ParentInformation } from '../r-bridge/lang-4.x/ast/model/processing/decorate';
 import { mapNormalizedAstInfo } from '../r-bridge/lang-4.x/ast/model/processing/decorate';
 import type { RDataType } from './types';
-import { RTypeVariable, RComplexType, RDoubleType, RIntegerType, RLogicalType, RStringType, resolveType, RNullType, UnresolvedRListType, RLanguageType, UnresolvedRFunctionType, RVectorType, isVectorType } from './types';
+import { RTypeVariable, RComplexType, RDoubleType, RIntegerType, RLogicalType, RStringType, resolveType, RNullType, UnresolvedRListType, RLanguageType, UnresolvedRFunctionType, isVectorType } from './types';
 import type { RExpressionList } from '../r-bridge/lang-4.x/ast/model/nodes/r-expression-list';
 import { guard } from '../util/assert';
 import { OriginType } from '../dataflow/origin/dfg-get-origin';
@@ -90,7 +90,7 @@ class TypeInferringCfgGuidedVisitor<
 	override onNumberConstant(data: { vertex: DataflowGraphVertexValue, node: RNumber<UnresolvedTypeInfo> }): void {
 		if(data.node.content.complexNumber) {
 			data.node.info.typeVariable.unify(new RComplexType());
-		} else if(Number.isInteger(data.node.content.num)) {
+		} else if(data.node.content.markedAsInt) {
 			data.node.info.typeVariable.unify(new RIntegerType());
 		} else {
 			data.node.info.typeVariable.unify(new RDoubleType());
diff --git a/test/functionality/typing/builtin-function-type-inference.test.ts b/test/functionality/typing/builtin-function-type-inference.test.ts
index b74c406352e..d8b97d6f720 100644
--- a/test/functionality/typing/builtin-function-type-inference.test.ts
+++ b/test/functionality/typing/builtin-function-type-inference.test.ts
@@ -1,5 +1,5 @@
 import { describe } from 'vitest';
-import { RIntegerType, RLanguageType, RListType, RLogicalType, RNullType, RStringType, RUnknownType } from '../../../src/typing/types';
+import { RDoubleType, RLanguageType, RListType, RLogicalType, RNullType, RStringType, RUnknownType } from '../../../src/typing/types';
 import { assertInferredType, assertInferredTypes } from '../_helper/typing/assert-inferred-type';
 import { Q } from '../../../src/search/flowr-search-builder';
 
@@ -8,8 +8,8 @@ describe('Infer types for builtin functions', () => {
 
 	assertInferredTypes(
 		'x <- 42\nget("x")',
-		{ query: Q.criterion('1@x').build(),   expectedType: new RIntegerType() },
-		{ query: Q.criterion('2@get').build(), expectedType: new RIntegerType() },
+		{ query: Q.criterion('1@x').build(),   expectedType: new RDoubleType() },
+		{ query: Q.criterion('2@get').build(), expectedType: new RDoubleType() },
 		{ query: Q.criterion('2@"x"').build(), expectedType: new RStringType() }
 	);
 
@@ -20,7 +20,7 @@ describe('Infer types for builtin functions', () => {
 		{ query: Q.criterion('1@TRUE').build(),  expectedType: new RLogicalType() }
 	);
 	
-	assertInferredType('list(1, 2, 3)', new RListType(new RIntegerType()));
+	assertInferredType('list(1, 2, 3)', new RListType(new RDoubleType()));
 
 	assertInferredTypes(
 		'c("Hello", "Flo", "!")',
diff --git a/test/functionality/typing/constant-expression-type-inference.test.ts b/test/functionality/typing/constant-expression-type-inference.test.ts
index d26d8b91778..589b46440aa 100644
--- a/test/functionality/typing/constant-expression-type-inference.test.ts
+++ b/test/functionality/typing/constant-expression-type-inference.test.ts
@@ -1,12 +1,13 @@
 import { describe } from 'vitest';
-import { RDataTypeTag } from '../../../src/typing/types';
+import { RComplexType, RDoubleType, RIntegerType, RLogicalType, RNullType, RStringType } from '../../../src/typing/types';
 import { assertInferredType } from '../_helper/typing/assert-inferred-type';
 
 describe.each([
-	{ description: 'logical constant',        input: 'TRUE',            expectedType: { tag: RDataTypeTag.Logical as const } },
-	{ description: 'integer constant',        input: '42',              expectedType: { tag: RDataTypeTag.Integer as const } },
-	{ description: 'double constant',         input: '42.5',            expectedType: { tag: RDataTypeTag.Double as const } },
-	{ description: 'complex number constant', input: '42i',             expectedType: { tag: RDataTypeTag.Complex as const } },
-	{ description: 'string constant',         input: '"Hello, world!"', expectedType: { tag: RDataTypeTag.String as const } },
-	{ description: 'empty expression list',   input: '{}',              expectedType: { tag: RDataTypeTag.Null as const } }
+	{ description: 'logical constant',        input: 'TRUE',            expectedType: new RLogicalType() },
+	{ description: 'integer constant',        input: '42',              expectedType: new RDoubleType() },
+	{ description: 'integer constant',        input: '42L',             expectedType: new RIntegerType() },
+	{ description: 'double constant',         input: '42.5',            expectedType: new RDoubleType() },
+	{ description: 'complex number constant', input: '42i',             expectedType: new RComplexType() },
+	{ description: 'string constant',         input: '"Hello, world!"', expectedType: new RStringType() },
+	{ description: 'empty expression list',   input: '{}',              expectedType: new RNullType() }
 ])('Infer $expectedType for $description', ({ input, expectedType }) => assertInferredType(input, expectedType));
\ No newline at end of file
diff --git a/test/functionality/typing/if-else-type-inference.test.ts b/test/functionality/typing/if-else-type-inference.test.ts
index 23992a842df..b1ebbf0b22e 100644
--- a/test/functionality/typing/if-else-type-inference.test.ts
+++ b/test/functionality/typing/if-else-type-inference.test.ts
@@ -1,19 +1,19 @@
 import { describe } from 'vitest';
-import { RDataTypeTag } from '../../../src/typing/types';
+import { RDoubleType, RLogicalType, RNullType, RStringType } from '../../../src/typing/types';
 import { assertInferredType, assertInferredTypes } from '../_helper/typing/assert-inferred-type';
 import { Q } from '../../../src/search/flowr-search-builder';
 import { RType } from '../../../src/r-bridge/lang-4.x/ast/model/type';
 
 describe('Infer types for if statements', () => {
 	describe.each([
-		{ input: 'if(FALSE) { TRUE }',                     expectedType: { tag: RDataTypeTag.Null as const } },
-		{ input: 'if(TRUE) { 1 } else { NULL }',           expectedType: { tag: RDataTypeTag.Integer as const } },
-		{ input: 'if(stop("stop here")) { 1 } else { 2 }', expectedType: { tag: RDataTypeTag.Integer as const } },
+		{ input: 'if(FALSE) { TRUE }',                     expectedType: new RNullType() },
+		{ input: 'if(TRUE) { 1 } else { NULL }',           expectedType: new RDoubleType() },
+		{ input: 'if(stop("stop here")) { 1 } else { 2 }', expectedType: new RDoubleType() },
 	])('Infer $expectedType for $input', ({ input, expectedType }) => assertInferredType(input, expectedType));
 
 	assertInferredTypes(
 		'a <- if(1 > 2) { "Yes" } else { "Nope" }',
-		{ query: Q.all().filter(RType.BinaryOp).first().build(), expectedType: { tag: RDataTypeTag.String as const } },
-		{ query: Q.all().filter(RType.BinaryOp).last().build(),  expectedType: { tag: RDataTypeTag.Logical as const } }
+		{ query: Q.all().filter(RType.BinaryOp).first().build(), expectedType: new RStringType() },
+		{ query: Q.all().filter(RType.BinaryOp).last().build(),  expectedType: new RLogicalType() },
 	);
 });
\ No newline at end of file
diff --git a/test/functionality/typing/variable-type-inference.test.ts b/test/functionality/typing/variable-type-inference.test.ts
index 1cf52ed03b5..2c1ccb90723 100644
--- a/test/functionality/typing/variable-type-inference.test.ts
+++ b/test/functionality/typing/variable-type-inference.test.ts
@@ -1,14 +1,14 @@
 import { describe } from 'vitest';
-import { RDataTypeTag } from '../../../src/typing/types';
+import { RDoubleType, RNullType } from '../../../src/typing/types';
 import { assertInferredType, assertInferredTypes } from '../_helper/typing/assert-inferred-type';
 import { Q } from '../../../src/search/flowr-search-builder';
 
 describe('Infer types for variables', () => {
 	assertInferredTypes(
 		'x <- 42; x',
-		{ query: Q.var('x').first().build(), expectedType: { tag: RDataTypeTag.Integer as const } },
-		{ query: Q.criterion('1@<-').build(), expectedType: { tag: RDataTypeTag.Integer as const } },
-		{ query: Q.var('x').last().build(), expectedType: { tag: RDataTypeTag.Integer as const } }
+		{ query: Q.var('x').first().build(),  expectedType: new RDoubleType() },
+		{ query: Q.criterion('1@<-').build(), expectedType: new RDoubleType() },
+		{ query: Q.var('x').last().build(),   expectedType: new RDoubleType() }
 	);
-	assertInferredType('y', { tag: RDataTypeTag.Null });
+	assertInferredType('y', new RNullType());
 });
\ No newline at end of file

From f47447367065052217a055f920b38a7fa3960f90 Mon Sep 17 00:00:00 2001
From: Lukas Rohde <lukas.rohde@silupe.de>
Date: Fri, 13 Jun 2025 13:42:18 +0200
Subject: [PATCH 066/153] refactor(typing): refactor test files

---
 ...ence.test.ts => builtin-functions.test.ts} |  0
 ...inference.test.ts => conditionals.test.ts} |  0
 ...pe-inference.test.ts => constants.test.ts} |  0
 ...p-type-inference.test.ts => loops.test.ts} | 20 +++++++++----------
 ...upported-expression-type-inference.test.ts |  8 --------
 .../typing/unsupported-expressions.test.ts    |  8 ++++++++
 ...pe-inference.test.ts => variables.test.ts} |  0
 7 files changed, 18 insertions(+), 18 deletions(-)
 rename test/functionality/typing/{builtin-function-type-inference.test.ts => builtin-functions.test.ts} (100%)
 rename test/functionality/typing/{if-else-type-inference.test.ts => conditionals.test.ts} (100%)
 rename test/functionality/typing/{constant-expression-type-inference.test.ts => constants.test.ts} (100%)
 rename test/functionality/typing/{loop-type-inference.test.ts => loops.test.ts} (62%)
 delete mode 100644 test/functionality/typing/unsupported-expression-type-inference.test.ts
 create mode 100644 test/functionality/typing/unsupported-expressions.test.ts
 rename test/functionality/typing/{variable-type-inference.test.ts => variables.test.ts} (100%)

diff --git a/test/functionality/typing/builtin-function-type-inference.test.ts b/test/functionality/typing/builtin-functions.test.ts
similarity index 100%
rename from test/functionality/typing/builtin-function-type-inference.test.ts
rename to test/functionality/typing/builtin-functions.test.ts
diff --git a/test/functionality/typing/if-else-type-inference.test.ts b/test/functionality/typing/conditionals.test.ts
similarity index 100%
rename from test/functionality/typing/if-else-type-inference.test.ts
rename to test/functionality/typing/conditionals.test.ts
diff --git a/test/functionality/typing/constant-expression-type-inference.test.ts b/test/functionality/typing/constants.test.ts
similarity index 100%
rename from test/functionality/typing/constant-expression-type-inference.test.ts
rename to test/functionality/typing/constants.test.ts
diff --git a/test/functionality/typing/loop-type-inference.test.ts b/test/functionality/typing/loops.test.ts
similarity index 62%
rename from test/functionality/typing/loop-type-inference.test.ts
rename to test/functionality/typing/loops.test.ts
index cb184643aba..d65b9ce0f49 100644
--- a/test/functionality/typing/loop-type-inference.test.ts
+++ b/test/functionality/typing/loops.test.ts
@@ -1,23 +1,23 @@
 import { describe } from 'vitest';
-import { RDataTypeTag } from '../../../src/typing/types';
+import { RLogicalType, RNullType, RUnknownType } from '../../../src/typing/types';
 import { assertInferredType, assertInferredTypes } from '../_helper/typing/assert-inferred-type';
 import { Q } from '../../../src/search/flowr-search-builder';
 import { RType } from '../../../src/r-bridge/lang-4.x/ast/model/type';
 
 describe('Infer types for loops', () => {
 	describe.each([
-		{ input: 'while(FALSE) { print("Testing is fun!") }',                         expectedType: { tag: RDataTypeTag.Null as const } },
-		{ input: 'while(TRUE) { next }',                                              expectedType: { tag: RDataTypeTag.Unknown as const } },
-		{ input: 'while(1 < 2) { print("Hi Flo!") }',                                 expectedType: { tag: RDataTypeTag.Null as const } },
-		{ input: 'while(TRUE) { break }',                                             expectedType: { tag: RDataTypeTag.Null as const } },
-		{ input: 'for(i in NULL) { print("I would like to write a test for that") }', expectedType: { tag: RDataTypeTag.Null as const } },
-		{ input: 'for(i in 1:10) { print(i) }',                                       expectedType: { tag: RDataTypeTag.Null as const } },
-		{ input: 'repeat { print("I love testing!") }',                               expectedType: { tag: RDataTypeTag.Unknown as const } },
-		{ input: 'repeat { break }',                                                  expectedType: { tag: RDataTypeTag.Null as const } }
+		{ input: 'while(FALSE) { print("Testing is fun!") }',                         expectedType: new RNullType() },
+		{ input: 'while(TRUE) { next }',                                              expectedType: new RUnknownType() },
+		{ input: 'while(1 < 2) { print("Hi Flo!") }',                                 expectedType: new RNullType() },
+		{ input: 'while(TRUE) { break }',                                             expectedType: new RNullType() },
+		{ input: 'for(i in NULL) { print("I would like to write a test for that") }', expectedType: new RNullType() },
+		{ input: 'for(i in 1:10) { print(i) }',                                       expectedType: new RNullType() },
+		{ input: 'repeat { print("I love testing!") }',                               expectedType: new RUnknownType() },
+		{ input: 'repeat { break }',                                                  expectedType: new RNullType() },
 	])('Infer $expectedType for $input', ({ input, expectedType }) => assertInferredType(input, expectedType));
 
 	assertInferredTypes(
 		'while(1 > 2) { print("Testing is done!") }',
-		{ query: Q.all().filter(RType.BinaryOp).build(), expectedType: { tag: RDataTypeTag.Logical as const } }
+		{ query: Q.all().filter(RType.BinaryOp).build(), expectedType: new RLogicalType() },
 	);
 });
\ No newline at end of file
diff --git a/test/functionality/typing/unsupported-expression-type-inference.test.ts b/test/functionality/typing/unsupported-expression-type-inference.test.ts
deleted file mode 100644
index 295bc06ae5f..00000000000
--- a/test/functionality/typing/unsupported-expression-type-inference.test.ts
+++ /dev/null
@@ -1,8 +0,0 @@
-import { describe } from 'vitest';
-import { RDataTypeTag } from '../../../src/typing/types';
-import { assertInferredType } from '../_helper/typing/assert-inferred-type';
-
-describe('Infer no type information for currently unsupported R expressions', () => {
-	assertInferredType('1 + 2',                  { tag: RDataTypeTag.Unknown });
-	assertInferredType('print("Hello, world!")', { tag: RDataTypeTag.Unknown });
-});
\ No newline at end of file
diff --git a/test/functionality/typing/unsupported-expressions.test.ts b/test/functionality/typing/unsupported-expressions.test.ts
new file mode 100644
index 00000000000..88520d93483
--- /dev/null
+++ b/test/functionality/typing/unsupported-expressions.test.ts
@@ -0,0 +1,8 @@
+import { describe } from 'vitest';
+import { RUnknownType } from '../../../src/typing/types';
+import { assertInferredType } from '../_helper/typing/assert-inferred-type';
+
+describe('Infer no type information for currently unsupported R expressions', () => {
+	assertInferredType('1 + 2',                  new RUnknownType());
+	assertInferredType('print("Hello, world!")', new RUnknownType());
+});
\ No newline at end of file
diff --git a/test/functionality/typing/variable-type-inference.test.ts b/test/functionality/typing/variables.test.ts
similarity index 100%
rename from test/functionality/typing/variable-type-inference.test.ts
rename to test/functionality/typing/variables.test.ts

From 263309de2c1c448ffa5a5dfcc00c579694f3f0bf Mon Sep 17 00:00:00 2001
From: Lukas Rohde <lukas.rohde@silupe.de>
Date: Tue, 17 Jun 2025 11:41:56 +0200
Subject: [PATCH 067/153] refactor(typing): simplify list types due to
 constraints of unification

---
 src/typing/infer.ts                          | 30 +++++-----
 src/typing/types.ts                          | 23 ++------
 test/functionality/typing/subsetting.test.ts | 61 ++++++++++++++++++++
 3 files changed, 79 insertions(+), 35 deletions(-)
 create mode 100644 test/functionality/typing/subsetting.test.ts

diff --git a/src/typing/infer.ts b/src/typing/infer.ts
index 45327a559b7..d778f90454f 100644
--- a/src/typing/infer.ts
+++ b/src/typing/infer.ts
@@ -5,7 +5,7 @@ import type { DataflowGraphVertexFunctionCall, DataflowGraphVertexFunctionDefini
 import type { DataflowInformation } from '../dataflow/info';
 import type { RLogical } from '../r-bridge/lang-4.x/ast/model/nodes/r-logical';
 import type { RNumber } from '../r-bridge/lang-4.x/ast/model/nodes/r-number';
-import { isRString, type RString } from '../r-bridge/lang-4.x/ast/model/nodes/r-string';
+import type { RString } from '../r-bridge/lang-4.x/ast/model/nodes/r-string';
 import type { NormalizedAst, ParentInformation } from '../r-bridge/lang-4.x/ast/model/processing/decorate';
 import { mapNormalizedAstInfo } from '../r-bridge/lang-4.x/ast/model/processing/decorate';
 import type { RDataType } from './types';
@@ -16,7 +16,7 @@ import { OriginType } from '../dataflow/origin/dfg-get-origin';
 import type { NodeId } from '../r-bridge/lang-4.x/ast/model/processing/node-id';
 import { edgeIncludesType, EdgeType } from '../dataflow/graph/edge';
 import { EmptyArgument } from '../r-bridge/lang-4.x/ast/model/nodes/r-function-call';
-import { isPositionalArgument, type FunctionArgument } from '../dataflow/graph/graph';
+import type { FunctionArgument } from '../dataflow/graph/graph';
 import type { ControlFlowInformation } from '../control-flow/control-flow-graph';
 import { CfgEdgeType, CfgVertexType } from '../control-flow/control-flow-graph';
 import type { RSymbol } from '../r-bridge/lang-4.x/ast/model/nodes/r-symbol';
@@ -327,8 +327,12 @@ class TypeInferringCfgGuidedVisitor<
 
 			const argNode = this.getNormalizedAst(arg.nodeId);
 			guard(argNode !== undefined, 'Expected argument node to be defined');
-			if(arg.name !== undefined) {
-				listType.constrainElementTypeForName(arg.name, argNode.info.typeVariable);
+			if(argNode.type === RType.Argument) {
+				if(argNode.value === undefined) {
+					continue; // Skip arguments without a value
+				}
+
+				listType.elementType.unify(argNode.value.info.typeVariable);
 			} else {
 				listType.elementType.unify(argNode.info.typeVariable);
 			}
@@ -425,29 +429,23 @@ class TypeInferringCfgGuidedVisitor<
 		guard(firstArgNode !== undefined, 'Expected first argument node to be defined');
 		const firstArgType = firstArgNode.info.typeVariable;
 		const firstArgBoundType = firstArgType.find();
-
-		const secondArg = data.call.args.at(1);
-		const secondArgNode = secondArg !== undefined && isPositionalArgument(secondArg) ? this.getNormalizedAst(secondArg.nodeId) : undefined;
 		
-		console.log('Access call origin:', data.call.origin);
-		switch(data.call.origin) {
-			case ['builtin:[']:
+		switch(data.call.name) {
+			case '[':
 				// If the access call is a `[` operation, we can assume that the it returns a subset
 				// of the first argument's elements as another instance of the same container type
 				node.info.typeVariable.unify(firstArgNode.info.typeVariable);
 				break;
-			case ['builtin:[[']:
+			case '[[':
 				if(firstArgBoundType instanceof UnresolvedRListType) {
-					const retrievedElementType = (isRString(secondArgNode) ? firstArgBoundType.namedElementTypes.get(secondArgNode.content.str) : undefined) ?? firstArgBoundType.elementType;
-					node.info.typeVariable.unify(retrievedElementType);
+					node.info.typeVariable.unify(firstArgBoundType.elementType);
 				} else if(isVectorType(firstArgBoundType) || firstArgBoundType instanceof RNullType) {
 					node.info.typeVariable.unify(firstArgType);
 				}
 				break;
-			case ['builtin:$']:
+			case '$':
 				if(firstArgBoundType instanceof UnresolvedRListType) {
-					const retrievedElementType = (secondArgNode !== undefined && secondArgNode.type === RType.Symbol ? firstArgBoundType.namedElementTypes.get(secondArgNode.content) : undefined) ?? firstArgBoundType.elementType;
-					node.info.typeVariable.unify(retrievedElementType);
+					node.info.typeVariable.unify(firstArgBoundType.elementType);
 				}
 				break;
 		}
diff --git a/src/typing/types.ts b/src/typing/types.ts
index 28c2d6f52f2..08044da7d8f 100644
--- a/src/typing/types.ts
+++ b/src/typing/types.ts
@@ -96,39 +96,24 @@ export class RFunctionType {
 export class UnresolvedRListType {
 	readonly tag = RDataTypeTag.List;
 	readonly elementType = new RTypeVariable();
-	readonly namedElementTypes = new Map<string, RTypeVariable>();
 
 	constructor(elementType?: UnresolvedRDataType) {
 		if(elementType !== undefined) {
 			this.elementType.unify(elementType);
 		}
 	}
-
-	constrainElementTypeForName(name: string, type: UnresolvedRDataType): void {
-		if(!this.namedElementTypes.has(name)) {
-			this.namedElementTypes.set(name, new RTypeVariable());
-		}
-		// eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-		this.namedElementTypes.get(name)!.unify(type);
-		this.elementType.unify(type);
-	}
 	
 	unify(other: UnresolvedRListType): void {
 		this.elementType.unify(other.elementType);
-		for(const [name, type] of other.namedElementTypes) {
-			this.constrainElementTypeForName(name, type);
-		}
 	}
 }
 
 export class RListType {
 	readonly tag = RDataTypeTag.List;
-	readonly elementType:       RDataType;
-	readonly namedElementTypes: Map<string, RDataType>;
+	readonly elementType: RDataType;
 
-	constructor(elementType: RDataType, namedElementTypes?: Map<string, RDataType>) {
+	constructor(elementType: RDataType) {
 		this.elementType = elementType;
-		this.namedElementTypes = namedElementTypes ?? new Map<string, RDataType>();
 	}
 }
 
@@ -151,6 +136,7 @@ export class RTypeVariable {
 		return this.boundType ?? this;
 	}
 
+	// TODO: Improve handling of error types
 	unify(other: UnresolvedRDataType): void {
 		const thisRep = this.find();
 		const otherRep = other instanceof RTypeVariable ? other.find() : other;
@@ -208,8 +194,7 @@ export function resolveType(type: UnresolvedRDataType): RDataType {
 		return new RFunctionType(resolvedParameterTypes, resolvedReturnType);
 	} else if(type instanceof UnresolvedRListType) {
 		const resolvedElementType = resolveType(type.elementType);
-		const resolvedNamedElementTypes = new Map(type.namedElementTypes.entries().toArray().map(([name, type]) => [name, resolveType(type)]));
-		return new RListType(resolvedElementType, resolvedNamedElementTypes);
+		return new RListType(resolvedElementType);
 	} else {
 		return type;
 	}
diff --git a/test/functionality/typing/subsetting.test.ts b/test/functionality/typing/subsetting.test.ts
new file mode 100644
index 00000000000..dfb37d94da6
--- /dev/null
+++ b/test/functionality/typing/subsetting.test.ts
@@ -0,0 +1,61 @@
+import { describe } from 'vitest';
+import { RDoubleType, RErrorType, RListType, RLogicalType, RNullType } from '../../../src/typing/types';
+import { assertInferredTypes } from '../_helper/typing/assert-inferred-type';
+import { Q } from '../../../src/search/flowr-search-builder';
+import { RType } from '../../../src/r-bridge/lang-4.x/ast/model/type';
+
+describe('Infer types for subsetting expressions', () => {
+	assertInferredTypes(
+		'v <- c(1, 2, 3); v[2]',
+		{ query: Q.var('v').last().build(),                    expectedType: new RDoubleType() },
+		{ query: Q.all().filter(RType.Access).first().build(), expectedType: new RDoubleType() },
+	);
+	
+	assertInferredTypes(
+		'l <- list(1, 2, 3); l[2]',
+		{ query: Q.var('l').last().build(),                    expectedType: new RListType(new RDoubleType()) },
+		{ query: Q.all().filter(RType.Access).first().build(), expectedType: new RListType(new RDoubleType()) },
+	);
+	
+	assertInferredTypes(
+		'v <- c(1, 2, 3); v[]',
+		{ query: Q.var('v').last().build(),                    expectedType: new RDoubleType() },
+		{ query: Q.all().filter(RType.Access).first().build(), expectedType: new RDoubleType() },
+	);
+	
+	assertInferredTypes(
+		'l <- list(1, 2, 3); l[]',
+		{ query: Q.var('l').last().build(),                    expectedType: new RListType(new RDoubleType()) },
+		{ query: Q.all().filter(RType.Access).first().build(), expectedType: new RListType(new RDoubleType()) },
+	);
+	
+	assertInferredTypes(
+		'v <- c(1, 2, 3); v[[2]]',
+		{ query: Q.var('v').last().build(),                    expectedType: new RDoubleType() },
+		{ query: Q.all().filter(RType.Access).first().build(), expectedType: new RDoubleType() },
+	);
+	
+	assertInferredTypes(
+		'l <- list(1, 2, 3); l[[2]]',
+		{ query: Q.var('l').last().build(),                    expectedType: new RListType(new RDoubleType()) },
+		{ query: Q.all().filter(RType.Access).first().build(), expectedType: new RDoubleType() },
+	);
+	
+	assertInferredTypes(
+		'l <- list(1, x = 2, 3); l$x',
+		{ query: Q.var('l').last().build(),                    expectedType: new RListType(new RDoubleType()) },
+		{ query: Q.all().filter(RType.Access).first().build(), expectedType: new RDoubleType() },
+	);
+	
+	assertInferredTypes(
+		'l <- list(1, 2, 3); l$a',
+		{ query: Q.var('l').last().build(),                    expectedType: new RListType(new RDoubleType()) },
+		{ query: Q.all().filter(RType.Access).first().build(), expectedType: new RDoubleType() },
+	);
+	
+	assertInferredTypes(
+		'l <- list(TRUE, a = 42, NULL); l$a',
+		{ query: Q.var('l').last().build(),                    expectedType: new RListType(new RErrorType([new RLogicalType(), new RDoubleType(), new RNullType()])) },
+		{ query: Q.all().filter(RType.Access).first().build(), expectedType: new RDoubleType() },
+	);
+});
\ No newline at end of file

From 77682293d1bfc0870a877831edd21c327a3416f8 Mon Sep 17 00:00:00 2001
From: Lukas Rohde <lukas.rohde@silupe.de>
Date: Thu, 19 Jun 2025 02:12:42 +0200
Subject: [PATCH 068/153] refactor(typing): refactor handling of argument nodes

---
 src/typing/infer.ts | 19 ++++++++-----------
 1 file changed, 8 insertions(+), 11 deletions(-)

diff --git a/src/typing/infer.ts b/src/typing/infer.ts
index d778f90454f..0afc6fee011 100644
--- a/src/typing/infer.ts
+++ b/src/typing/infer.ts
@@ -112,7 +112,13 @@ class TypeInferringCfgGuidedVisitor<
 		}
 		
 		const node = this.getNormalizedAst(data.vertex.id);
-		guard(node !== undefined, 'Expected AST node to be defined');		
+		guard(node !== undefined, 'Expected AST node to be defined');
+		if(node.type === RType.Argument) {
+			if(node.value !== undefined) {
+				node.info.typeVariable.unify(node.value.info.typeVariable);
+			}
+			return;
+		}
 
 		const readOrigins = this.getOrigins(data.vertex.id)?.filter((origin) => origin.type === OriginType.ReadVariableOrigin);
 		if(readOrigins === undefined || readOrigins.length === 0) {
@@ -324,18 +330,9 @@ class TypeInferringCfgGuidedVisitor<
 			if(arg === EmptyArgument) {
 				continue; // Skip empty arguments
 			}
-
 			const argNode = this.getNormalizedAst(arg.nodeId);
 			guard(argNode !== undefined, 'Expected argument node to be defined');
-			if(argNode.type === RType.Argument) {
-				if(argNode.value === undefined) {
-					continue; // Skip arguments without a value
-				}
-
-				listType.elementType.unify(argNode.value.info.typeVariable);
-			} else {
-				listType.elementType.unify(argNode.info.typeVariable);
-			}
+			listType.elementType.unify(argNode.info.typeVariable);
 		}
 	}
 

From 9e2cff41d891173246e55bb84d0ac154a2d6243c Mon Sep 17 00:00:00 2001
From: Lukas Rohde <lukas.rohde@silupe.de>
Date: Thu, 19 Jun 2025 02:17:31 +0200
Subject: [PATCH 069/153] refactor(typing): change traversal order to visit
 call arguments first

---
 src/typing/infer.ts                          | 43 ++++++++++++++++++++
 test/functionality/typing/constants.test.ts  |  2 +
 test/functionality/typing/subsetting.test.ts |  2 +-
 3 files changed, 46 insertions(+), 1 deletion(-)

diff --git a/src/typing/infer.ts b/src/typing/infer.ts
index 0afc6fee011..08e40403031 100644
--- a/src/typing/infer.ts
+++ b/src/typing/infer.ts
@@ -75,10 +75,53 @@ class TypeInferringCfgGuidedVisitor<
 	Dataflow extends DataflowInformation                      = DataflowInformation,
 	Config extends TypeInferringCfgGuidedVisitorConfiguration<OtherInfo, ControlFlow, Ast, Dataflow> = TypeInferringCfgGuidedVisitorConfiguration<OtherInfo, ControlFlow, Ast, Dataflow>
 > extends SemanticCfgGuidedVisitor<UnresolvedTypeInfo & OtherInfo, ControlFlow, Ast, Dataflow['graph'], Config & { dataflow: Dataflow['graph'] }> {
+	protected visitedEventTriggered = new Map<NodeId, boolean>();
+
 	constructor(config: Config) {
 		super({ dataflow: config.dataflowInfo.graph, ...config });
 	}
 
+
+	protected override visitNode(node: NodeId): boolean {
+		if(this.visited.has(node)) {
+			return false;
+		}
+		// Override the order of the following two lines to ensure that the node is only marked as visited after it has actually been processed
+		this.onVisitNode(node);
+		this.visited.set(node, 1);
+		return true;
+	}
+
+	protected override onVisitNode(node: NodeId): void {
+		// Check if the node has already been visited to prevent duplicate processing due to the modification of the `visitFunctionCall` method
+		if(this.visitedEventTriggered.has(node)) {
+			return;
+		}
+		super.onVisitNode(node);
+		this.visitedEventTriggered.set(node, true);
+	}
+
+	protected override visitFunctionCall(vertex: DataflowGraphVertexFunctionCall) {
+		for(const arg of vertex.args.filter(arg => arg !== EmptyArgument)) {
+			this.onVisitNode(arg.nodeId);
+		}
+		super.visitFunctionCall(vertex);
+	}
+
+	protected override visitVariableUse(vertex: DataflowGraphVertexUse): void {
+		for(const origin of this.getOrigins(vertex.id)?.filter(origin => origin.type === OriginType.ReadVariableOrigin) ?? []) {
+			this.onVisitNode(origin.id);
+		}
+		const node = this.getNormalizedAst(vertex.id);
+		if(node?.type === RType.Argument) {
+			if(node.value !== undefined) {
+				this.onVisitNode(node.value.info.id);
+			}
+		}
+		super.visitVariableUse(vertex);
+	}
+
+
 	protected override onNullConstant(data: { vertex: DataflowGraphVertexValue; node: RSymbol<UnresolvedTypeInfo & ParentInformation, 'NULL'>; }): void {
 		data.node.info.typeVariable.unify(new RNullType());
 	}
diff --git a/test/functionality/typing/constants.test.ts b/test/functionality/typing/constants.test.ts
index 589b46440aa..4f8bad33046 100644
--- a/test/functionality/typing/constants.test.ts
+++ b/test/functionality/typing/constants.test.ts
@@ -4,6 +4,8 @@ import { assertInferredType } from '../_helper/typing/assert-inferred-type';
 
 describe.each([
 	{ description: 'logical constant',        input: 'TRUE',            expectedType: new RLogicalType() },
+	{ description: 'logical constant',        input: 'FALSE',           expectedType: new RLogicalType() },
+	{ description: 'null constant',           input: 'NULL',            expectedType: new RNullType() },
 	{ description: 'integer constant',        input: '42',              expectedType: new RDoubleType() },
 	{ description: 'integer constant',        input: '42L',             expectedType: new RIntegerType() },
 	{ description: 'double constant',         input: '42.5',            expectedType: new RDoubleType() },
diff --git a/test/functionality/typing/subsetting.test.ts b/test/functionality/typing/subsetting.test.ts
index dfb37d94da6..8074717598e 100644
--- a/test/functionality/typing/subsetting.test.ts
+++ b/test/functionality/typing/subsetting.test.ts
@@ -56,6 +56,6 @@ describe('Infer types for subsetting expressions', () => {
 	assertInferredTypes(
 		'l <- list(TRUE, a = 42, NULL); l$a',
 		{ query: Q.var('l').last().build(),                    expectedType: new RListType(new RErrorType([new RLogicalType(), new RDoubleType(), new RNullType()])) },
-		{ query: Q.all().filter(RType.Access).first().build(), expectedType: new RDoubleType() },
+		{ query: Q.all().filter(RType.Access).first().build(), expectedType: new RErrorType([new RLogicalType(), new RDoubleType(), new RNullType()]) },
 	);
 });
\ No newline at end of file

From 3b1519e331e68c08bfb50f578f92b8cd6cdcebc5 Mon Sep 17 00:00:00 2001
From: Lukas Rohde <lukas.rohde@silupe.de>
Date: Thu, 19 Jun 2025 11:35:42 +0200
Subject: [PATCH 070/153] refactor(typing): use sets to track conflicting types
 in error types

---
 src/typing/types.ts                          | 19 +++++++++++--------
 test/functionality/typing/subsetting.test.ts |  4 ++--
 2 files changed, 13 insertions(+), 10 deletions(-)

diff --git a/src/typing/types.ts b/src/typing/types.ts
index 08044da7d8f..5a25c584a9d 100644
--- a/src/typing/types.ts
+++ b/src/typing/types.ts
@@ -136,7 +136,6 @@ export class RTypeVariable {
 		return this.boundType ?? this;
 	}
 
-	// TODO: Improve handling of error types
 	unify(other: UnresolvedRDataType): void {
 		const thisRep = this.find();
 		const otherRep = other instanceof RTypeVariable ? other.find() : other;
@@ -154,16 +153,18 @@ export class RTypeVariable {
 		} else if(thisRep instanceof UnresolvedRListType && otherRep instanceof UnresolvedRListType) {
 			thisRep.unify(otherRep);
 		} else if(thisRep instanceof RErrorType && otherRep instanceof RErrorType) {
-			otherRep.conflictingTypes.push(...thisRep.conflictingTypes);
+			for(const type of otherRep.conflictingTypes) {
+				otherRep.conflictingTypes.add(type);
+			}
 			this.boundType = otherRep;
 		} else if(thisRep.tag !== otherRep.tag) {
 			if(thisRep instanceof RErrorType) {
-				thisRep.conflictingTypes.push(otherRep);
+				thisRep.conflictingTypes.add(otherRep);
 			} else if(otherRep instanceof RErrorType) {
-				otherRep.conflictingTypes.push(thisRep);
+				otherRep.conflictingTypes.add(thisRep);
 				this.boundType = otherRep;
 			} else {
-				this.boundType = new RErrorType([thisRep, otherRep]);
+				this.boundType = new RErrorType(thisRep, otherRep);
 			}
 		}
 	}
@@ -171,12 +172,14 @@ export class RTypeVariable {
 
 export class RErrorType {
 	readonly tag = RDataTypeTag.Error;
+	conflictingTypes = new Set<UnresolvedRDataType>();
 
-	constructor(conflictingTypes: UnresolvedRDataType[]) {
-		this.conflictingTypes = conflictingTypes;
+	constructor(...conflictingTypes: UnresolvedRDataType[]) {
+		for(const type of conflictingTypes) {
+			this.conflictingTypes.add(type);
+		}
 	}	
 
-	conflictingTypes: UnresolvedRDataType[];
 }
 
 export class RUnknownType {
diff --git a/test/functionality/typing/subsetting.test.ts b/test/functionality/typing/subsetting.test.ts
index 8074717598e..49c18711b05 100644
--- a/test/functionality/typing/subsetting.test.ts
+++ b/test/functionality/typing/subsetting.test.ts
@@ -55,7 +55,7 @@ describe('Infer types for subsetting expressions', () => {
 	
 	assertInferredTypes(
 		'l <- list(TRUE, a = 42, NULL); l$a',
-		{ query: Q.var('l').last().build(),                    expectedType: new RListType(new RErrorType([new RLogicalType(), new RDoubleType(), new RNullType()])) },
-		{ query: Q.all().filter(RType.Access).first().build(), expectedType: new RErrorType([new RLogicalType(), new RDoubleType(), new RNullType()]) },
+		{ query: Q.var('l').last().build(),                    expectedType: new RListType(new RErrorType(new RLogicalType(), new RDoubleType(), new RNullType())) },
+		{ query: Q.all().filter(RType.Access).first().build(), expectedType: new RErrorType(new RLogicalType(), new RDoubleType(), new RNullType()) },
 	);
 });
\ No newline at end of file

From d2c1ea5232034475dace44ed801d0227f7f2b249 Mon Sep 17 00:00:00 2001
From: Lukas Rohde <lukas.rohde@silupe.de>
Date: Thu, 19 Jun 2025 11:37:19 +0200
Subject: [PATCH 071/153] wip(typing): add an enumeration of R's base types

---
 src/typing/base-types.ts | 56 ++++++++++++++++++++++++++++++++++++++++
 1 file changed, 56 insertions(+)
 create mode 100644 src/typing/base-types.ts

diff --git a/src/typing/base-types.ts b/src/typing/base-types.ts
new file mode 100644
index 00000000000..e1eda3caa32
--- /dev/null
+++ b/src/typing/base-types.ts
@@ -0,0 +1,56 @@
+import { RDataTypeTag } from './types';
+
+/* eslint-disable @typescript-eslint/naming-convention */
+export enum RBaseType {
+    NILSXP     = 'NULL',
+	LGLSXP     = 'logical',
+    INTSXP     = 'integer',
+    REALSXP    = 'double',
+	CPLXSXP    = 'complex',
+    STRSXP     = 'character',
+    VECSXP     = 'list',
+    RAWSXP     = 'raw',
+    CLOSXP     = 'closure',
+    SPECIALSXP = 'special',
+    BUILTINSXP = 'builtin',
+    ENVSXP     = 'environment',
+    // S4SXP      = 'S4',
+    SYMSXP     = 'symbol',
+    LANGSXP    = 'language',
+    // LISTSXP    = 'pairlist',
+    EXPRSXP    = 'expression',
+    // EXTPTRSXP  = 'externalptr',
+    // WEAKREFSXP = 'weakref',
+    // BCODESXP   = 'bytecode',
+    // PROMSXP    = 'promise',
+    // DOTSXP     = '...',
+    // ANYSXP     = 'any',
+}
+
+export function baseTypeToDataTypeTag(baseType: RBaseType): RDataTypeTag {
+	switch(baseType) {
+		case RBaseType.NILSXP:     return RDataTypeTag.Null;
+		case RBaseType.LGLSXP:     return RDataTypeTag.Logical;
+		case RBaseType.INTSXP:     return RDataTypeTag.Integer;
+		case RBaseType.REALSXP:    return RDataTypeTag.Double;
+		case RBaseType.CPLXSXP:    return RDataTypeTag.Complex;
+		case RBaseType.STRSXP:     return RDataTypeTag.String;
+		case RBaseType.VECSXP:     return RDataTypeTag.List;
+		case RBaseType.RAWSXP:     return RDataTypeTag.Raw;
+		case RBaseType.CLOSXP:     return RDataTypeTag.Function;
+		case RBaseType.SPECIALSXP: return RDataTypeTag.Function; // Special functions are a kind of function
+		case RBaseType.BUILTINSXP: return RDataTypeTag.Function; // Builtin functions are a kind of function
+		case RBaseType.ENVSXP:     return RDataTypeTag.Environment;
+		// case RBaseType.S4SXP:      return RDataTypeTag.Unknown; // Not yet supported
+		case RBaseType.SYMSXP:     return RDataTypeTag.Language; // Symbols are a kind of language object
+		case RBaseType.LANGSXP:    return RDataTypeTag.Language;
+		// case RBaseType.LISTSXP:    return RDataTypeTag.List; // Not supported
+		case RBaseType.EXPRSXP:    return RDataTypeTag.Language; // Expressions are a kind of language object
+		// case RBaseType.EXTPTRSXP:  return RDataTypeTag.Unknown; // Not supported
+		// case RBaseType.WEAKREFSXP: return RDataTypeTag.Unknown; // Not supported
+		// case RBaseType.BCODESXP:   return RDataTypeTag.Unknown; // Not supported
+		// case RBaseType.PROMSXP:    return RDataTypeTag.Unknown; // Not supported
+		// case RBaseType.DOTSXP:     return RDataTypeTag.Language; // Not included in the type system
+		// case RBaseType.ANYSXP:     return RDataTypeTag.Unknown; // Not supported
+	}
+}
\ No newline at end of file

From 9ca8deadc016c9eb2b893130f2101543c456e849 Mon Sep 17 00:00:00 2001
From: Lukas Rohde <lukas.rohde@silupe.de>
Date: Thu, 19 Jun 2025 14:07:11 +0200
Subject: [PATCH 072/153] feat-fix(typing): remove failing guard disallowing
 calls without targets

---
 src/typing/infer.ts | 3 +--
 1 file changed, 1 insertion(+), 2 deletions(-)

diff --git a/src/typing/infer.ts b/src/typing/infer.ts
index 08e40403031..59adaaba393 100644
--- a/src/typing/infer.ts
+++ b/src/typing/infer.ts
@@ -195,12 +195,11 @@ class TypeInferringCfgGuidedVisitor<
 			.filter(([_target, edge]) => edgeIncludesType(edge.types, EdgeType.Calls))
 			.map(([target, _edge]) => target)
 			.toArray();
-		guard(callTargets !== undefined && callTargets.length >= 1, 'Expected at least one target for default function call');
 		
 		const node = this.getNormalizedAst(data.call.id);
 		guard(node !== undefined, 'Expected AST node to be defined');
 
-		for(const target of callTargets) {
+		for(const target of callTargets ?? []) {
 			const targetNode = this.getNormalizedAst(target);
 			if(targetNode !== undefined) {
 				const functionType = new UnresolvedRFunctionType();

From 730fa560672de5502d4cdbbbf400f1997a707a72 Mon Sep 17 00:00:00 2001
From: Lukas Rohde <lukas.rohde@silupe.de>
Date: Thu, 19 Jun 2025 15:22:49 +0200
Subject: [PATCH 073/153] refactor(ast): refactor mapNormalizedAstInfo to use
 NormalizedAst.idMap

---
 .../lang-4.x/ast/model/processing/decorate.ts | 20 ++++++++++++++-----
 1 file changed, 15 insertions(+), 5 deletions(-)

diff --git a/src/r-bridge/lang-4.x/ast/model/processing/decorate.ts b/src/r-bridge/lang-4.x/ast/model/processing/decorate.ts
index b15e5da13c2..5e0cba5d4f6 100644
--- a/src/r-bridge/lang-4.x/ast/model/processing/decorate.ts
+++ b/src/r-bridge/lang-4.x/ast/model/processing/decorate.ts
@@ -518,8 +518,14 @@ export function mapAstInfo<OldInfo, Down, NewInfo>(ast: RNode<OldInfo>, down: Do
 	});
 }
 
-export function mapNormalizedAstInfo<OldInfo, Down, NewInfo>(normalizedAst: NormalizedAst<OldInfo>, down: Down, infoMapper: (node: RNode<OldInfo & ParentInformation>, down: Down) => NewInfo, downUpdater: (node: RNode<OldInfo>, down: Down) => Down = (_node, down) => down): NormalizedAst<NewInfo> {
-	const parentInfoPreservingMapper = (node: RNode<OldInfo & ParentInformation>, down: Down): NewInfo & ParentInformation => {
+export function mapNormalizedAstInfo<OldInfo, NewInfo>(normalizedAst: NormalizedAst<OldInfo>, infoMapper: (node: RNode<OldInfo & ParentInformation>) => NewInfo): NormalizedAst<NewInfo> {
+	const fullInfoMapper = (node: RNode<OldInfo & ParentInformation>): NewInfo & Source => {
+		const sourceInfo = {
+			...(node.info.fullRange !== undefined ? { fullRange: node.info.fullRange } : {}),
+			...(node.info.fullLexeme !== undefined ? { fullLexeme: node.info.fullLexeme } : {}),
+			...(node.info.additionalTokens !== undefined ? { additionalTokens: node.info.additionalTokens } : {}),
+			...(node.info.file !== undefined ? { file: node.info.file } : {})
+		};
 		const parentInfo = {
 			id:      node.info.id,
 			parent:  node.info.parent,
@@ -527,9 +533,13 @@ export function mapNormalizedAstInfo<OldInfo, Down, NewInfo>(normalizedAst: Norm
 			nesting: node.info.nesting,
 			index:   node.info.index
 		};
-		const mappedInfo = infoMapper(node, down);
-		return { ...parentInfo, ...mappedInfo };
+		const mappedInfo = infoMapper(node);
+		return { ...sourceInfo, ...parentInfo, ...mappedInfo };
 	};
-	mapAstInfo(normalizedAst.ast, down, parentInfoPreservingMapper, downUpdater);
+	
+	for(const node of normalizedAst.idMap.values()) {
+		(node.info as NewInfo) = fullInfoMapper(node);
+	}
+	
 	return normalizedAst as unknown as NormalizedAst<NewInfo>;
 }
\ No newline at end of file

From 1a7599941e0e3e0fbbfc62453f3f300b59af8af9 Mon Sep 17 00:00:00 2001
From: Lukas Rohde <lukas.rohde@silupe.de>
Date: Thu, 19 Jun 2025 15:47:36 +0200
Subject: [PATCH 074/153] feat-fix(typing): fix merge issues

---
 src/r-bridge/lang-4.x/ast/model/processing/decorate.ts | 4 ++--
 src/typing/infer.ts                                    | 4 ++--
 2 files changed, 4 insertions(+), 4 deletions(-)

diff --git a/src/r-bridge/lang-4.x/ast/model/processing/decorate.ts b/src/r-bridge/lang-4.x/ast/model/processing/decorate.ts
index 5e0cba5d4f6..a07671a814f 100644
--- a/src/r-bridge/lang-4.x/ast/model/processing/decorate.ts
+++ b/src/r-bridge/lang-4.x/ast/model/processing/decorate.ts
@@ -519,7 +519,7 @@ export function mapAstInfo<OldInfo, Down, NewInfo>(ast: RNode<OldInfo>, down: Do
 }
 
 export function mapNormalizedAstInfo<OldInfo, NewInfo>(normalizedAst: NormalizedAst<OldInfo>, infoMapper: (node: RNode<OldInfo & ParentInformation>) => NewInfo): NormalizedAst<NewInfo> {
-	const fullInfoMapper = (node: RNode<OldInfo & ParentInformation>): NewInfo & Source => {
+	const fullInfoMapper = (node: RNode<OldInfo & ParentInformation>): NewInfo & ParentInformation & Source => {
 		const sourceInfo = {
 			...(node.info.fullRange !== undefined ? { fullRange: node.info.fullRange } : {}),
 			...(node.info.fullLexeme !== undefined ? { fullLexeme: node.info.fullLexeme } : {}),
@@ -538,7 +538,7 @@ export function mapNormalizedAstInfo<OldInfo, NewInfo>(normalizedAst: Normalized
 	};
 	
 	for(const node of normalizedAst.idMap.values()) {
-		(node.info as NewInfo) = fullInfoMapper(node);
+		(node.info as unknown as NewInfo & ParentInformation & Source) = fullInfoMapper(node);
 	}
 	
 	return normalizedAst as unknown as NormalizedAst<NewInfo>;
diff --git a/src/typing/infer.ts b/src/typing/infer.ts
index 59adaaba393..be111c3eaea 100644
--- a/src/typing/infer.ts
+++ b/src/typing/infer.ts
@@ -49,11 +49,11 @@ export type DataTypeInfo = {
 }
 
 function decorateTypeVariables<OtherInfo>(ast: NormalizedAst<OtherInfo>): NormalizedAst<OtherInfo & UnresolvedTypeInfo> {
-	return mapNormalizedAstInfo(ast, {}, (node, _down) => ({ ...node.info, typeVariable: new RTypeVariable() }));
+	return mapNormalizedAstInfo(ast, node => ({ ...node.info, typeVariable: new RTypeVariable() }));
 }
 
 function resolveTypeVariables<Info extends UnresolvedTypeInfo>(ast: NormalizedAst<Info>): NormalizedAst<Omit<Info, keyof UnresolvedTypeInfo> & DataTypeInfo> {
-	return mapNormalizedAstInfo(ast, {}, (node, _down) => {
+	return mapNormalizedAstInfo(ast, node => {
 		const { typeVariable, ...rest } = node.info;
 		return { ...rest, inferredType: resolveType(typeVariable) };
 	});

From 83b316930ae6dc416fddbb9ef56d5994cdff642a Mon Sep 17 00:00:00 2001
From: Florian Sihler <florian.sihler@uni-ulm.de>
Date: Thu, 19 Jun 2025 21:27:22 +0200
Subject: [PATCH 075/153] feat-fix(ast-map): do not map virtual nodes

---
 .../datatype-query/datatype-query-executor.ts |  4 +--
 .../lang-4.x/ast/model/processing/decorate.ts | 28 ++++---------------
 src/typing/infer.ts                           |  6 ++--
 test/functionality/typing/variables.test.ts   |  8 +++---
 4 files changed, 15 insertions(+), 31 deletions(-)

diff --git a/src/queries/catalog/datatype-query/datatype-query-executor.ts b/src/queries/catalog/datatype-query/datatype-query-executor.ts
index adfbc2c7ec9..1be10954061 100644
--- a/src/queries/catalog/datatype-query/datatype-query-executor.ts
+++ b/src/queries/catalog/datatype-query/datatype-query-executor.ts
@@ -1,7 +1,7 @@
 import type { DatatypeQuery, DatatypeQueryResult } from './datatype-query-format';
 import { log } from '../../../util/log';
 import type { BasicQueryData } from '../../base-query-format';
-import type { NormalizedAst } from '../../../r-bridge/lang-4.x/ast/model/processing/decorate';
+import type { NormalizedAst, ParentInformation } from '../../../r-bridge/lang-4.x/ast/model/processing/decorate';
 import { slicingCriterionToId } from '../../../slicing/criterion/parse';
 import { inferDataTypes } from '../../../typing/infer';
 
@@ -13,7 +13,7 @@ export function executeDatatypeQuery({ dataflow, ast }: BasicQueryData, queries:
 			log.warn('Duplicate criterion in datatype query:', criterion);
 			continue;
 		}
-		const typedAst = inferDataTypes(ast as NormalizedAst<{ typeVariable?: undefined }>, dataflow);
+		const typedAst = inferDataTypes(ast as NormalizedAst< ParentInformation & { typeVariable?: undefined }>, dataflow);
 		const node = criterion !== undefined ? typedAst.idMap.get(slicingCriterionToId(criterion, typedAst.idMap)) : typedAst.ast;
 		if(node === undefined) {
 			log.warn('Criterion not found in normalized AST:', criterion);
diff --git a/src/r-bridge/lang-4.x/ast/model/processing/decorate.ts b/src/r-bridge/lang-4.x/ast/model/processing/decorate.ts
index a07671a814f..130259cf404 100644
--- a/src/r-bridge/lang-4.x/ast/model/processing/decorate.ts
+++ b/src/r-bridge/lang-4.x/ast/model/processing/decorate.ts
@@ -518,28 +518,12 @@ export function mapAstInfo<OldInfo, Down, NewInfo>(ast: RNode<OldInfo>, down: Do
 	});
 }
 
-export function mapNormalizedAstInfo<OldInfo, NewInfo>(normalizedAst: NormalizedAst<OldInfo>, infoMapper: (node: RNode<OldInfo & ParentInformation>) => NewInfo): NormalizedAst<NewInfo> {
-	const fullInfoMapper = (node: RNode<OldInfo & ParentInformation>): NewInfo & ParentInformation & Source => {
-		const sourceInfo = {
-			...(node.info.fullRange !== undefined ? { fullRange: node.info.fullRange } : {}),
-			...(node.info.fullLexeme !== undefined ? { fullLexeme: node.info.fullLexeme } : {}),
-			...(node.info.additionalTokens !== undefined ? { additionalTokens: node.info.additionalTokens } : {}),
-			...(node.info.file !== undefined ? { file: node.info.file } : {})
-		};
-		const parentInfo = {
-			id:      node.info.id,
-			parent:  node.info.parent,
-			role:    node.info.role,
-			nesting: node.info.nesting,
-			index:   node.info.index
-		};
-		const mappedInfo = infoMapper(node);
-		return { ...sourceInfo, ...parentInfo, ...mappedInfo };
-	};
-	
-	for(const node of normalizedAst.idMap.values()) {
-		(node.info as unknown as NewInfo & ParentInformation & Source) = fullInfoMapper(node);
+export function mapNormalizedAstInfo<OldInfo extends ParentInformation, NewInfo>(normalizedAst: NormalizedAst<OldInfo>, infoMapper: (node: RNode<OldInfo>) => NewInfo): NormalizedAst<NewInfo> {
+	for(const [id, node] of normalizedAst.idMap.entries()) {
+		if(id === node.info.id) { // we skip virtual nodes
+			(node.info as unknown as NewInfo) = infoMapper(node);
+		}
 	}
-	
+
 	return normalizedAst as unknown as NormalizedAst<NewInfo>;
 }
\ No newline at end of file
diff --git a/src/typing/infer.ts b/src/typing/infer.ts
index be111c3eaea..8cea5b3a951 100644
--- a/src/typing/infer.ts
+++ b/src/typing/infer.ts
@@ -24,7 +24,7 @@ import { RType } from '../r-bridge/lang-4.x/ast/model/type';
 import type { NoInfo } from '../r-bridge/lang-4.x/ast/model/model';
 import { RFalse, RTrue } from '../r-bridge/lang-4.x/convert-values';
 
-export function inferDataTypes<Info extends { typeVariable?: undefined }>(ast: NormalizedAst<Info>, dataflowInfo: DataflowInformation): NormalizedAst<Info & DataTypeInfo> {
+export function inferDataTypes<Info extends ParentInformation & { typeVariable?: undefined }>(ast: NormalizedAst<ParentInformation & Info>, dataflowInfo: DataflowInformation): NormalizedAst<Info & DataTypeInfo> {
 	const astWithTypeVars = decorateTypeVariables(ast);
 	const controlFlowInfo = extractCfg(astWithTypeVars, dataflowInfo.graph, ['unique-cf-sets', 'analyze-dead-code', 'remove-dead-code']);
 	const config = {
@@ -48,11 +48,11 @@ export type DataTypeInfo = {
 	inferredType: RDataType;
 }
 
-function decorateTypeVariables<OtherInfo>(ast: NormalizedAst<OtherInfo>): NormalizedAst<OtherInfo & UnresolvedTypeInfo> {
+function decorateTypeVariables<Info extends ParentInformation>(ast: NormalizedAst<Info>): NormalizedAst<Info & UnresolvedTypeInfo> {
 	return mapNormalizedAstInfo(ast, node => ({ ...node.info, typeVariable: new RTypeVariable() }));
 }
 
-function resolveTypeVariables<Info extends UnresolvedTypeInfo>(ast: NormalizedAst<Info>): NormalizedAst<Omit<Info, keyof UnresolvedTypeInfo> & DataTypeInfo> {
+function resolveTypeVariables<Info extends ParentInformation & UnresolvedTypeInfo>(ast: NormalizedAst<Info>): NormalizedAst<Omit<Info, keyof UnresolvedTypeInfo> & DataTypeInfo> {
 	return mapNormalizedAstInfo(ast, node => {
 		const { typeVariable, ...rest } = node.info;
 		return { ...rest, inferredType: resolveType(typeVariable) };
diff --git a/test/functionality/typing/variables.test.ts b/test/functionality/typing/variables.test.ts
index 2c1ccb90723..9fbf4982dfa 100644
--- a/test/functionality/typing/variables.test.ts
+++ b/test/functionality/typing/variables.test.ts
@@ -1,14 +1,14 @@
 import { describe } from 'vitest';
-import { RDoubleType, RNullType } from '../../../src/typing/types';
-import { assertInferredType, assertInferredTypes } from '../_helper/typing/assert-inferred-type';
+import { RDoubleType } from '../../../src/typing/types';
+import { assertInferredTypes } from '../_helper/typing/assert-inferred-type';
 import { Q } from '../../../src/search/flowr-search-builder';
 
-describe('Infer types for variables', () => {
+describe.only('Infer types for variables', () => {
 	assertInferredTypes(
 		'x <- 42; x',
 		{ query: Q.var('x').first().build(),  expectedType: new RDoubleType() },
 		{ query: Q.criterion('1@<-').build(), expectedType: new RDoubleType() },
 		{ query: Q.var('x').last().build(),   expectedType: new RDoubleType() }
 	);
-	assertInferredType('y', new RNullType());
+	/* assertInferredType('y', new RNullType()); */
 });
\ No newline at end of file

From 0f394cbafc69ac86be9b63b4d3ebbfb75c2acaff Mon Sep 17 00:00:00 2001
From: Florian Sihler <florian.sihler@uni-ulm.de>
Date: Thu, 19 Jun 2025 21:29:36 +0200
Subject: [PATCH 076/153] refactor: add test that i commented out

---
 test/functionality/typing/variables.test.ts | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/test/functionality/typing/variables.test.ts b/test/functionality/typing/variables.test.ts
index 9fbf4982dfa..ba3360fc76b 100644
--- a/test/functionality/typing/variables.test.ts
+++ b/test/functionality/typing/variables.test.ts
@@ -1,6 +1,6 @@
 import { describe } from 'vitest';
-import { RDoubleType } from '../../../src/typing/types';
-import { assertInferredTypes } from '../_helper/typing/assert-inferred-type';
+import { RDoubleType, RNullType } from '../../../src/typing/types';
+import { assertInferredType, assertInferredTypes } from '../_helper/typing/assert-inferred-type';
 import { Q } from '../../../src/search/flowr-search-builder';
 
 describe.only('Infer types for variables', () => {
@@ -10,5 +10,5 @@ describe.only('Infer types for variables', () => {
 		{ query: Q.criterion('1@<-').build(), expectedType: new RDoubleType() },
 		{ query: Q.var('x').last().build(),   expectedType: new RDoubleType() }
 	);
-	/* assertInferredType('y', new RNullType()); */
+	assertInferredType('y', new RNullType());
 });
\ No newline at end of file

From b58071cad1c1fef55fd73549fc0c940fa5e553a0 Mon Sep 17 00:00:00 2001
From: Lukas Rohde <lukas.rohde@silupe.de>
Date: Thu, 19 Jun 2025 21:57:51 +0200
Subject: [PATCH 077/153] test-fix(typing): fix expected type due to dead code
 elimination updates

---
 test/functionality/typing/conditionals.test.ts | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/test/functionality/typing/conditionals.test.ts b/test/functionality/typing/conditionals.test.ts
index b1ebbf0b22e..d509da47843 100644
--- a/test/functionality/typing/conditionals.test.ts
+++ b/test/functionality/typing/conditionals.test.ts
@@ -1,5 +1,5 @@
 import { describe } from 'vitest';
-import { RDoubleType, RLogicalType, RNullType, RStringType } from '../../../src/typing/types';
+import { RDoubleType, RLogicalType, RNullType, RStringType, RUnknownType } from '../../../src/typing/types';
 import { assertInferredType, assertInferredTypes } from '../_helper/typing/assert-inferred-type';
 import { Q } from '../../../src/search/flowr-search-builder';
 import { RType } from '../../../src/r-bridge/lang-4.x/ast/model/type';
@@ -8,7 +8,7 @@ describe('Infer types for if statements', () => {
 	describe.each([
 		{ input: 'if(FALSE) { TRUE }',                     expectedType: new RNullType() },
 		{ input: 'if(TRUE) { 1 } else { NULL }',           expectedType: new RDoubleType() },
-		{ input: 'if(stop("stop here")) { 1 } else { 2 }', expectedType: new RDoubleType() },
+		{ input: 'if(stop("stop here")) { 1 } else { 2 }', expectedType: new RUnknownType() },
 	])('Infer $expectedType for $input', ({ input, expectedType }) => assertInferredType(input, expectedType));
 
 	assertInferredTypes(

From 340d2031631b62595ac2f8e74af3510c465239a9 Mon Sep 17 00:00:00 2001
From: Lukas Rohde <lukas.rohde@silupe.de>
Date: Thu, 19 Jun 2025 23:08:15 +0200
Subject: [PATCH 078/153] refactor(datatype-query): reuse typed AST for all
 criteria

---
 src/queries/catalog/datatype-query/datatype-query-executor.ts | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/src/queries/catalog/datatype-query/datatype-query-executor.ts b/src/queries/catalog/datatype-query/datatype-query-executor.ts
index 1be10954061..d400b13d156 100644
--- a/src/queries/catalog/datatype-query/datatype-query-executor.ts
+++ b/src/queries/catalog/datatype-query/datatype-query-executor.ts
@@ -8,12 +8,13 @@ import { inferDataTypes } from '../../../typing/infer';
 export function executeDatatypeQuery({ dataflow, ast }: BasicQueryData, queries: readonly DatatypeQuery[]): DatatypeQueryResult {
 	const start = Date.now();
 	const result: DatatypeQueryResult['inferredTypes'] = {};
+	const typedAst = inferDataTypes(ast as NormalizedAst< ParentInformation & { typeVariable?: undefined }>, dataflow);
+	
 	for(const { criterion } of queries) {
 		if(result[criterion ?? '1:1'] !== undefined) {
 			log.warn('Duplicate criterion in datatype query:', criterion);
 			continue;
 		}
-		const typedAst = inferDataTypes(ast as NormalizedAst< ParentInformation & { typeVariable?: undefined }>, dataflow);
 		const node = criterion !== undefined ? typedAst.idMap.get(slicingCriterionToId(criterion, typedAst.idMap)) : typedAst.ast;
 		if(node === undefined) {
 			log.warn('Criterion not found in normalized AST:', criterion);

From be5e30dda26b0a09e81ad3f800f9c1efaf77cdba Mon Sep 17 00:00:00 2001
From: Lukas Rohde <86918771+loki259@users.noreply.github.com>
Date: Thu, 19 Jun 2025 23:19:41 +0200
Subject: [PATCH 079/153] lint-fix(datatype-query): remove redundant space

Co-authored-by: Florian Sihler <florian.sihler@uni-ulm.de>
---
 src/queries/catalog/datatype-query/datatype-query-executor.ts | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/queries/catalog/datatype-query/datatype-query-executor.ts b/src/queries/catalog/datatype-query/datatype-query-executor.ts
index d400b13d156..a6739d0d225 100644
--- a/src/queries/catalog/datatype-query/datatype-query-executor.ts
+++ b/src/queries/catalog/datatype-query/datatype-query-executor.ts
@@ -8,7 +8,7 @@ import { inferDataTypes } from '../../../typing/infer';
 export function executeDatatypeQuery({ dataflow, ast }: BasicQueryData, queries: readonly DatatypeQuery[]): DatatypeQueryResult {
 	const start = Date.now();
 	const result: DatatypeQueryResult['inferredTypes'] = {};
-	const typedAst = inferDataTypes(ast as NormalizedAst< ParentInformation & { typeVariable?: undefined }>, dataflow);
+	const typedAst = inferDataTypes(ast as NormalizedAst<ParentInformation & { typeVariable?: undefined }>, dataflow);
 	
 	for(const { criterion } of queries) {
 		if(result[criterion ?? '1:1'] !== undefined) {

From 63177c9311dd4389c8c3f52afd606807b9068abe Mon Sep 17 00:00:00 2001
From: Lukas Rohde <lukas.rohde@silupe.de>
Date: Thu, 19 Jun 2025 23:23:03 +0200
Subject: [PATCH 080/153] test-fix(typing): remove `only` specifier from test

---
 test/functionality/typing/variables.test.ts | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/test/functionality/typing/variables.test.ts b/test/functionality/typing/variables.test.ts
index ba3360fc76b..2c1ccb90723 100644
--- a/test/functionality/typing/variables.test.ts
+++ b/test/functionality/typing/variables.test.ts
@@ -3,7 +3,7 @@ import { RDoubleType, RNullType } from '../../../src/typing/types';
 import { assertInferredType, assertInferredTypes } from '../_helper/typing/assert-inferred-type';
 import { Q } from '../../../src/search/flowr-search-builder';
 
-describe.only('Infer types for variables', () => {
+describe('Infer types for variables', () => {
 	assertInferredTypes(
 		'x <- 42; x',
 		{ query: Q.var('x').first().build(),  expectedType: new RDoubleType() },

From d19bcc16ec28673444770c13bc7481a0d7e001e0 Mon Sep 17 00:00:00 2001
From: Lukas Rohde <lukas.rohde@silupe.de>
Date: Tue, 24 Jun 2025 09:49:49 +0200
Subject: [PATCH 081/153] feat-fix(typing): remove invalid inference rule for
 undefined variables

---
 src/typing/infer.ts                         | 6 +-----
 test/functionality/typing/variables.test.ts | 5 ++---
 2 files changed, 3 insertions(+), 8 deletions(-)

diff --git a/src/typing/infer.ts b/src/typing/infer.ts
index 8cea5b3a951..34869bf7237 100644
--- a/src/typing/infer.ts
+++ b/src/typing/infer.ts
@@ -164,11 +164,7 @@ class TypeInferringCfgGuidedVisitor<
 		}
 
 		const readOrigins = this.getOrigins(data.vertex.id)?.filter((origin) => origin.type === OriginType.ReadVariableOrigin);
-		if(readOrigins === undefined || readOrigins.length === 0) {
-			node.info.typeVariable.unify(new RNullType());
-			return;
-		}
-		for(const readOrigin of readOrigins) {
+		for(const readOrigin of readOrigins ?? []) {
 			const readNode = this.getNormalizedAst(readOrigin.id);
 			guard(readNode !== undefined, 'Expected read node to be defined');
 			node.info.typeVariable.unify(readNode.info.typeVariable);
diff --git a/test/functionality/typing/variables.test.ts b/test/functionality/typing/variables.test.ts
index 2c1ccb90723..212ffb6467e 100644
--- a/test/functionality/typing/variables.test.ts
+++ b/test/functionality/typing/variables.test.ts
@@ -1,6 +1,6 @@
 import { describe } from 'vitest';
-import { RDoubleType, RNullType } from '../../../src/typing/types';
-import { assertInferredType, assertInferredTypes } from '../_helper/typing/assert-inferred-type';
+import { RDoubleType } from '../../../src/typing/types';
+import { assertInferredTypes } from '../_helper/typing/assert-inferred-type';
 import { Q } from '../../../src/search/flowr-search-builder';
 
 describe('Infer types for variables', () => {
@@ -10,5 +10,4 @@ describe('Infer types for variables', () => {
 		{ query: Q.criterion('1@<-').build(), expectedType: new RDoubleType() },
 		{ query: Q.var('x').last().build(),   expectedType: new RDoubleType() }
 	);
-	assertInferredType('y', new RNullType());
 });
\ No newline at end of file

From 114263cd9b904ea2b4a0efcc86825ac18b1d7012 Mon Sep 17 00:00:00 2001
From: Lukas Rohde <lukas.rohde@silupe.de>
Date: Fri, 4 Jul 2025 20:12:13 +0200
Subject: [PATCH 082/153] refactor(typing): refactor representation of types

---
 src/typing/types.ts | 16 ++++++++--------
 1 file changed, 8 insertions(+), 8 deletions(-)

diff --git a/src/typing/types.ts b/src/typing/types.ts
index 5a25c584a9d..67ae4edf0c0 100644
--- a/src/typing/types.ts
+++ b/src/typing/types.ts
@@ -25,7 +25,7 @@ export enum RDataTypeTag {
     Environment = 'REnvironmentType',
     /** {@link RLanguageType} */
     Language = 'RLanguageType',
-	/** {@link RNeverType} */
+	/** {@link RTypeVariable} */
     Variable = 'RTypeVariable',
 	/** {@link RErrorType} */
 	Error = 'RErrorType',
@@ -127,13 +127,13 @@ export class RLanguageType {
 
 export class RTypeVariable {
 	readonly tag = RDataTypeTag.Variable;
-	private boundType: UnresolvedRDataType | undefined;
+	private boundType: UnresolvedRDataType = new RUnknownType();
 
 	find(): UnresolvedRDataType {
 		if(this.boundType instanceof RTypeVariable) {
 			this.boundType = this.boundType.find();
 		}
-		return this.boundType ?? this;
+		return this.boundType.tag !== RDataTypeTag.Unknown ? this.boundType : this;
 	}
 
 	unify(other: UnresolvedRDataType): void {
@@ -159,12 +159,12 @@ export class RTypeVariable {
 			this.boundType = otherRep;
 		} else if(thisRep.tag !== otherRep.tag) {
 			if(thisRep instanceof RErrorType) {
-				thisRep.conflictingTypes.add(otherRep);
+				thisRep.conflictingTypes.add(resolveType(otherRep));
 			} else if(otherRep instanceof RErrorType) {
-				otherRep.conflictingTypes.add(thisRep);
+				otherRep.conflictingTypes.add(resolveType(thisRep));
 				this.boundType = otherRep;
 			} else {
-				this.boundType = new RErrorType(thisRep, otherRep);
+				this.boundType = new RErrorType(resolveType(thisRep), resolveType(otherRep));
 			}
 		}
 	}
@@ -172,9 +172,9 @@ export class RTypeVariable {
 
 export class RErrorType {
 	readonly tag = RDataTypeTag.Error;
-	conflictingTypes = new Set<UnresolvedRDataType>();
+	conflictingTypes = new Set<RDataType>();
 
-	constructor(...conflictingTypes: UnresolvedRDataType[]) {
+	constructor(...conflictingTypes: RDataType[]) {
 		for(const type of conflictingTypes) {
 			this.conflictingTypes.add(type);
 		}

From af1fb14f0f59597266421019c26719260c009b5f Mon Sep 17 00:00:00 2001
From: Lukas Rohde <lukas.rohde@silupe.de>
Date: Fri, 4 Jul 2025 21:23:14 +0200
Subject: [PATCH 083/153] feat-fix(typing): remove invalid inference rule for
 `get` calls

---
 src/typing/infer.ts | 6 +-----
 1 file changed, 1 insertion(+), 5 deletions(-)

diff --git a/src/typing/infer.ts b/src/typing/infer.ts
index 34869bf7237..af5576e6cce 100644
--- a/src/typing/infer.ts
+++ b/src/typing/infer.ts
@@ -237,11 +237,7 @@ class TypeInferringCfgGuidedVisitor<
 		guard(node !== undefined, 'Expected AST node to be defined');
 
 		const varReadOrigins = this.getOrigins(varName.nodeId)?.filter((origin) => origin.type === OriginType.ReadVariableOrigin);
-		if(varReadOrigins === undefined || varReadOrigins.length === 0) {
-			node.info.typeVariable.unify(new RNullType());
-			return;
-		}
-		for(const readOrigin of varReadOrigins) {
+		for(const readOrigin of varReadOrigins ?? []) {
 			const readNode = this.getNormalizedAst(readOrigin.id);
 			guard(readNode !== undefined, 'Expected read node to be defined');
 			node.info.typeVariable.unify(readNode.info.typeVariable);

From 6e749e6afc09ba43fddd2b5cddf4d4421b55444f Mon Sep 17 00:00:00 2001
From: Lukas Rohde <lukas.rohde@silupe.de>
Date: Sat, 5 Jul 2025 18:04:20 +0200
Subject: [PATCH 084/153] feat(typing): add basic subtyping support :sparkles:

---
 src/subtyping/infer.ts                        | 513 ++++++++++++++++++
 src/subtyping/types.ts                        | 392 +++++++++++++
 .../_helper/subtyping/assert-inferred-type.ts |  47 ++
 .../subtyping/builtin-functions.test.ts       |  30 +
 .../subtyping/conditionals.test.ts            |  19 +
 .../functionality/subtyping/constants.test.ts |  15 +
 test/functionality/subtyping/loops.test.ts    |  23 +
 .../subtyping/unsupported-expressions.test.ts |   8 +
 .../functionality/subtyping/variables.test.ts |  13 +
 9 files changed, 1060 insertions(+)
 create mode 100644 src/subtyping/infer.ts
 create mode 100644 src/subtyping/types.ts
 create mode 100644 test/functionality/_helper/subtyping/assert-inferred-type.ts
 create mode 100644 test/functionality/subtyping/builtin-functions.test.ts
 create mode 100644 test/functionality/subtyping/conditionals.test.ts
 create mode 100644 test/functionality/subtyping/constants.test.ts
 create mode 100644 test/functionality/subtyping/loops.test.ts
 create mode 100644 test/functionality/subtyping/unsupported-expressions.test.ts
 create mode 100644 test/functionality/subtyping/variables.test.ts

diff --git a/src/subtyping/infer.ts b/src/subtyping/infer.ts
new file mode 100644
index 00000000000..9fa84a70df5
--- /dev/null
+++ b/src/subtyping/infer.ts
@@ -0,0 +1,513 @@
+import { extractCfg } from '../control-flow/extract-cfg';
+import type { SemanticCfgGuidedVisitorConfiguration } from '../control-flow/semantic-cfg-guided-visitor';
+import { SemanticCfgGuidedVisitor } from '../control-flow/semantic-cfg-guided-visitor';
+import type { DataflowGraphVertexFunctionCall, DataflowGraphVertexFunctionDefinition, DataflowGraphVertexUse, DataflowGraphVertexValue } from '../dataflow/graph/vertex';
+import type { DataflowInformation } from '../dataflow/info';
+import type { RLogical } from '../r-bridge/lang-4.x/ast/model/nodes/r-logical';
+import type { RNumber } from '../r-bridge/lang-4.x/ast/model/nodes/r-number';
+import type { RString } from '../r-bridge/lang-4.x/ast/model/nodes/r-string';
+import type { NormalizedAst, ParentInformation } from '../r-bridge/lang-4.x/ast/model/processing/decorate';
+import { mapNormalizedAstInfo } from '../r-bridge/lang-4.x/ast/model/processing/decorate';
+import type { RDataType, UnresolvedRDataType } from './types';
+import { UnresolvedRTypeVariable, RComplexType, RDoubleType, RIntegerType, RLogicalType, RStringType, resolveType, RNullType, UnresolvedRListType, RLanguageType, UnresolvedRFunctionType, RNoneType } from './types';
+import type { RExpressionList } from '../r-bridge/lang-4.x/ast/model/nodes/r-expression-list';
+import { guard } from '../util/assert';
+import { OriginType } from '../dataflow/origin/dfg-get-origin';
+import type { NodeId } from '../r-bridge/lang-4.x/ast/model/processing/node-id';
+import { edgeIncludesType, EdgeType } from '../dataflow/graph/edge';
+import { EmptyArgument } from '../r-bridge/lang-4.x/ast/model/nodes/r-function-call';
+import type { FunctionArgument } from '../dataflow/graph/graph';
+import type { ControlFlowInformation } from '../control-flow/control-flow-graph';
+import { CfgEdgeType, CfgVertexType } from '../control-flow/control-flow-graph';
+import type { RSymbol } from '../r-bridge/lang-4.x/ast/model/nodes/r-symbol';
+import { RType } from '../r-bridge/lang-4.x/ast/model/type';
+import type { NoInfo } from '../r-bridge/lang-4.x/ast/model/model';
+import { RFalse, RTrue } from '../r-bridge/lang-4.x/convert-values';
+
+export function inferDataTypes<Info extends ParentInformation & { typeVariable?: undefined }>(ast: NormalizedAst<ParentInformation & Info>, dataflowInfo: DataflowInformation): NormalizedAst<Info & DataTypeInfo> {
+	const astWithTypeVars = decorateTypeVariables(ast);
+	const controlFlowInfo = extractCfg(astWithTypeVars, dataflowInfo.graph, ['unique-cf-sets', 'analyze-dead-code', 'remove-dead-code']);
+	const config = {
+		normalizedAst:        astWithTypeVars,
+		controlFlow:          controlFlowInfo,
+		dataflowInfo:         dataflowInfo,
+		dfg:                  dataflowInfo.graph,
+		defaultVisitingOrder: 'forward' as const,
+	};
+	const visitor = new TypeInferringCfgGuidedVisitor(config);
+	visitor.start();
+
+	return resolveTypeVariables(astWithTypeVars);
+}
+
+type UnresolvedTypeInfo = {
+	typeVariable: UnresolvedRTypeVariable;
+};
+
+export type DataTypeInfo = {
+	inferredType: RDataType;
+}
+
+function decorateTypeVariables<Info extends ParentInformation>(ast: NormalizedAst<Info>): NormalizedAst<Info & UnresolvedTypeInfo> {
+	return mapNormalizedAstInfo(ast, node => ({ ...node.info, typeVariable: new UnresolvedRTypeVariable() }));
+}
+
+function resolveTypeVariables<Info extends ParentInformation & UnresolvedTypeInfo>(ast: NormalizedAst<Info>): NormalizedAst<Omit<Info, keyof UnresolvedTypeInfo> & DataTypeInfo> {
+	return mapNormalizedAstInfo(ast, node => {
+		const { typeVariable, ...rest } = node.info;
+		return { ...rest, inferredType: resolveType(typeVariable) };
+	});
+}
+
+export interface TypeInferringCfgGuidedVisitorConfiguration<
+	OtherInfo                                                 = NoInfo,
+	ControlFlow extends ControlFlowInformation                = ControlFlowInformation,
+	Ast extends NormalizedAst<UnresolvedTypeInfo & OtherInfo> = NormalizedAst<UnresolvedTypeInfo & OtherInfo>,
+	Dataflow extends DataflowInformation                      = DataflowInformation
+> extends Omit<SemanticCfgGuidedVisitorConfiguration<UnresolvedTypeInfo & OtherInfo, ControlFlow, Ast>, 'dataflow'> {
+	dataflowInfo: Dataflow;
+}
+
+class TypeInferringCfgGuidedVisitor<
+	OtherInfo                                                 = NoInfo,
+	ControlFlow extends ControlFlowInformation                = ControlFlowInformation,
+	Ast extends NormalizedAst<UnresolvedTypeInfo & OtherInfo> = NormalizedAst<UnresolvedTypeInfo & OtherInfo>,
+	Dataflow extends DataflowInformation                      = DataflowInformation,
+	Config extends TypeInferringCfgGuidedVisitorConfiguration<OtherInfo, ControlFlow, Ast, Dataflow> = TypeInferringCfgGuidedVisitorConfiguration<OtherInfo, ControlFlow, Ast, Dataflow>
+> extends SemanticCfgGuidedVisitor<UnresolvedTypeInfo & OtherInfo, ControlFlow, Ast, Dataflow['graph'], Config & { dataflow: Dataflow['graph'] }> {
+	protected visitedEventTriggered = new Map<NodeId, boolean>();
+
+	constructor(config: Config) {
+		super({ dataflow: config.dataflowInfo.graph, ...config });
+	}
+
+
+	protected constrainNodeTypeWithUpperBound(id: NodeId, upperBound: UnresolvedRDataType): void {
+		const node = this.getNormalizedAst(id);
+		guard(node !== undefined, 'Expected AST node to be defined');
+		node.info.typeVariable.constrainWithUpperBound(upperBound);
+	}
+
+
+	protected override visitNode(node: NodeId): boolean {
+		if(this.visited.has(node)) {
+			return false;
+		}
+		// Override the order of the following two lines to ensure that the node is only marked as visited after it has actually been processed
+		this.onVisitNode(node);
+		this.visited.set(node, 1);
+		return true;
+	}
+
+	protected override onVisitNode(node: NodeId): void {
+		// Check if the node has already been visited to prevent duplicate processing due to the modification of the `visitFunctionCall` method
+		if(this.visitedEventTriggered.has(node)) {
+			return;
+		}
+		super.onVisitNode(node);
+		this.visitedEventTriggered.set(node, true);
+	}
+
+	protected override visitFunctionCall(vertex: DataflowGraphVertexFunctionCall) {
+		for(const arg of vertex.args.filter(arg => arg !== EmptyArgument)) {
+			this.onVisitNode(arg.nodeId);
+		}
+		super.visitFunctionCall(vertex);
+	}
+
+	protected override visitVariableUse(vertex: DataflowGraphVertexUse): void {
+		for(const origin of this.getOrigins(vertex.id)?.filter(origin => origin.type === OriginType.ReadVariableOrigin) ?? []) {
+			this.onVisitNode(origin.id);
+		}
+		const node = this.getNormalizedAst(vertex.id);
+		if(node?.type === RType.Argument) {
+			if(node.value !== undefined) {
+				this.onVisitNode(node.value.info.id);
+			}
+		}
+		super.visitVariableUse(vertex);
+	}
+
+
+	protected override onNullConstant(data: { vertex: DataflowGraphVertexValue; node: RSymbol<UnresolvedTypeInfo & ParentInformation, 'NULL'>; }): void {
+		data.node.info.typeVariable.constrainFromBothSides(new RNullType());
+	}
+
+	override onLogicalConstant(data: { vertex: DataflowGraphVertexValue, node: RLogical<UnresolvedTypeInfo> }): void {
+		data.node.info.typeVariable.constrainFromBothSides(new RLogicalType());
+	}
+
+	override onNumberConstant(data: { vertex: DataflowGraphVertexValue, node: RNumber<UnresolvedTypeInfo> }): void {
+		if(data.node.content.complexNumber) {
+			data.node.info.typeVariable.constrainFromBothSides(new RComplexType());
+		} else if(data.node.content.markedAsInt) {
+			data.node.info.typeVariable.constrainFromBothSides(new RIntegerType());
+		} else if(data.node.content.num % 1 === 0) {
+			data.node.info.typeVariable.constrainWithLowerBound(new RIntegerType());
+			data.node.info.typeVariable.constrainWithUpperBound(new RComplexType());
+		} else {
+			data.node.info.typeVariable.constrainWithLowerBound(new RDoubleType());
+			data.node.info.typeVariable.constrainWithUpperBound(new RComplexType());
+		}
+	}
+
+	override onStringConstant(data: { vertex: DataflowGraphVertexValue, node: RString<UnresolvedTypeInfo> }): void {
+		data.node.info.typeVariable.constrainFromBothSides(new RStringType());
+	}
+
+	override onVariableUse(data: { vertex: DataflowGraphVertexUse }): void {
+		const isArgumentOfGetCall = this.config.dfg.ingoingEdges(data.vertex.id)?.entries().some(([source, edge]) => {
+			return edgeIncludesType(edge.types, EdgeType.Argument) &&
+				(this.config.dfg.getVertex(source)?.origin as string[] | undefined)?.includes('builtin:get');
+		}) ?? false;
+		if(isArgumentOfGetCall) {
+			// If the variable use occurs through a `get` call, it is already handled by the `onGetCall` method
+			return;
+		}
+		
+		const node = this.getNormalizedAst(data.vertex.id);
+		guard(node !== undefined, 'Expected AST node to be defined');
+		if(node.type === RType.Argument) {
+			if(node.value !== undefined) {
+				node.info.typeVariable.constrainWithLowerBound(node.value.info.typeVariable);
+			}
+			return;
+		}
+
+		const readOrigins = this.getOrigins(data.vertex.id)?.filter((origin) => origin.type === OriginType.ReadVariableOrigin);
+		for(const readOrigin of readOrigins ?? []) {
+			const readNode = this.getNormalizedAst(readOrigin.id);
+			guard(readNode !== undefined, 'Expected read node to be defined');
+			node.info.typeVariable.constrainWithLowerBound(readNode.info.typeVariable);
+		}
+	}
+
+	override onAssignmentCall(data: { call: DataflowGraphVertexFunctionCall, target?: NodeId, source?: NodeId }): void {
+		if(data.target === undefined || data.source === undefined) {
+			return; // Malformed assignment
+		}
+		
+		const variableNode = this.getNormalizedAst(data.target);
+		const valueNode = this.getNormalizedAst(data.source);
+		const assignmentNode = this.getNormalizedAst(data.call.id);
+		guard(variableNode !== undefined && valueNode !== undefined && assignmentNode !== undefined, 'Expected AST nodes to be defined');
+		
+		variableNode.info.typeVariable.constrainWithLowerBound(valueNode.info.typeVariable);
+		assignmentNode.info.typeVariable.constrainWithLowerBound(variableNode.info.typeVariable);
+	}
+
+	override onDefaultFunctionCall(data: { call: DataflowGraphVertexFunctionCall }): void {
+		const outgoing = this.config.dataflowInfo.graph.outgoingEdges(data.call.id);
+		const callTargets = outgoing?.entries()
+			.filter(([_target, edge]) => edgeIncludesType(edge.types, EdgeType.Calls))
+			.map(([target, _edge]) => target)
+			.toArray();
+		
+		const node = this.getNormalizedAst(data.call.id);
+		guard(node !== undefined, 'Expected AST node to be defined');
+
+		for(const target of callTargets ?? []) {
+			const targetNode = this.getNormalizedAst(target);
+			if(targetNode !== undefined) {
+				const functionType = new UnresolvedRFunctionType();
+				targetNode.info.typeVariable.constrainWithLowerBound(functionType);
+
+				for(const [index, arg] of data.call.args.entries()) {
+					if(arg === EmptyArgument) {
+						continue; // Skip empty arguments
+					}
+
+					const argNode = this.getNormalizedAst(arg.nodeId);
+					guard(argNode !== undefined, 'Expected argument node to be defined');
+
+					if(arg.name !== undefined) {
+						functionType.getParameterType(arg.name).constrainWithLowerBound(argNode.info.typeVariable);
+					} else {
+						functionType.getParameterType(index).constrainWithLowerBound(argNode.info.typeVariable);
+					}
+				}
+
+				node.info.typeVariable.constrainFromBothSides(functionType.returnType);
+			} else {
+				// TODO: Handle builtin functions that are not represented in the AST
+			}
+		}
+	}
+
+	override onGetCall(data: { call: DataflowGraphVertexFunctionCall }) {
+		guard(data.call.args.length == 1, 'Expected exactly one argument for get call');
+		const varName = data.call.args.at(0);
+		
+		guard(varName !== undefined && varName !== EmptyArgument, 'Expected argument of get call to be defined');
+		const varNameNode = this.getNormalizedAst(varName.nodeId);
+
+		guard(varNameNode !== undefined, 'Expected variable name node to be defined');
+		varNameNode.info.typeVariable.constrainWithUpperBound(new RStringType());
+
+		const node = this.getNormalizedAst(data.call.id);
+		guard(node !== undefined, 'Expected AST node to be defined');
+
+		const varReadOrigins = this.getOrigins(varName.nodeId)?.filter((origin) => origin.type === OriginType.ReadVariableOrigin);
+		for(const readOrigin of varReadOrigins ?? []) {
+			const readNode = this.getNormalizedAst(readOrigin.id);
+			guard(readNode !== undefined, 'Expected read node to be defined');
+			node.info.typeVariable.constrainWithLowerBound(readNode.info.typeVariable);
+		}
+	}
+
+	override onRmCall(data: { call: DataflowGraphVertexFunctionCall }) {
+		const node = this.getNormalizedAst(data.call.id);
+		guard(node !== undefined, 'Expected AST node to be defined');
+		node.info.typeVariable.constrainFromBothSides(new RNullType());
+	}
+
+	override onForLoopCall(data: { call: DataflowGraphVertexFunctionCall, variable: FunctionArgument, vector: FunctionArgument, body: FunctionArgument }) {
+		guard(data.variable !== EmptyArgument && data.vector !== EmptyArgument, 'Expected variable and vector arguments to be defined');
+		const variableNode = this.getNormalizedAst(data.variable.nodeId);
+		const vectorNode = this.getNormalizedAst(data.vector.nodeId);
+		
+		guard(variableNode !== undefined && vectorNode !== undefined, 'Expected variable and vector nodes to be defined');
+		variableNode.info.typeVariable.constrainWithLowerBound(vectorNode.info.typeVariable);
+
+		this.onLoopCall(data);
+	}
+
+	override onWhileLoopCall(data: { call: DataflowGraphVertexFunctionCall, condition: FunctionArgument, body: FunctionArgument }) {
+		guard(data.condition !== EmptyArgument, 'Expected condition argument to be defined');
+		const conditionNode = this.getNormalizedAst(data.condition.nodeId);
+		
+		guard(conditionNode !== undefined, 'Expected condition node to be defined');
+		conditionNode.info.typeVariable.constrainWithUpperBound(new RLogicalType());
+
+		this.onLoopCall(data);
+	}
+
+	override onRepeatLoopCall(data: { call: DataflowGraphVertexFunctionCall, body: FunctionArgument }) {
+		this.onLoopCall(data);
+	}
+
+	protected onLoopCall(data: { call: DataflowGraphVertexFunctionCall, body: FunctionArgument }) {
+		const node = this.getNormalizedAst(data.call.id);
+		guard(node !== undefined, 'Expected AST node to be defined');
+
+		const cfgVertex = this.config.controlFlow.graph.getVertex(data.call.id);
+		guard(cfgVertex !== undefined && cfgVertex.type === CfgVertexType.Statement, 'Expected statement vertex for loop');
+		const isInfinite = (cfgVertex.end ?? []).reduce((prevCount, id) => prevCount + (this.config.controlFlow.graph.outgoingEdges(id)?.size ?? 0), 0) === 0;
+
+		if(isInfinite) {
+			node.info.typeVariable.constrainFromBothSides(new RNoneType());
+		} else {
+			node.info.typeVariable.constrainFromBothSides(new RNullType());
+		}
+	}
+
+	override onIfThenElseCall(data: { call: DataflowGraphVertexFunctionCall, condition: NodeId | undefined, then: NodeId | undefined, else: NodeId | undefined }) {
+		guard(data.condition !== undefined, 'Expected condition argument to be defined');
+		const conditionNode = this.getNormalizedAst(data.condition);
+		
+		guard(conditionNode !== undefined, 'Expected condition node to be defined');
+		conditionNode.info.typeVariable.constrainWithUpperBound(new RLogicalType());
+		
+		const cfgVertex = this.config.controlFlow.graph.getVertex(data.call.id);
+		guard(cfgVertex !== undefined && (cfgVertex.type === CfgVertexType.Statement || cfgVertex.type === CfgVertexType.Expression),
+			'Expected statement or expression vertex for if-then-else');
+		const cfgEndVertexId = cfgVertex.end?.at(0);
+		guard(cfgEndVertexId !== undefined && cfgVertex.end?.length === 1, 'Expected exactly one end vertex for if-then-else');
+		
+		const isThenBranchReachable = this.config.controlFlow.graph.outgoingEdges(data.then ?? cfgEndVertexId)?.values().some((edge) => {
+			return edge.label === CfgEdgeType.Cd && edge.when === RTrue;
+		}) ?? false;
+		const isElseBranchReachable = this.config.controlFlow.graph.outgoingEdges(data.else ?? cfgEndVertexId)?.values().some((edge) =>{
+			return edge.label === CfgEdgeType.Cd && edge.when === RFalse;
+		}) ?? false;
+
+		const node = this.getNormalizedAst(data.call.id);
+		guard(node !== undefined, 'Expected AST node to be defined');
+		
+		if(isThenBranchReachable) {
+			if(data.then !== undefined) {	
+				const thenNode = this.getNormalizedAst(data.then);
+				guard(thenNode !== undefined, 'Expected then node to be defined');
+				node.info.typeVariable.constrainWithLowerBound(thenNode.info.typeVariable);
+				if(!isElseBranchReachable) {
+					node.info.typeVariable.constrainWithUpperBound(thenNode.info.typeVariable);
+				}
+			} else {
+				// If there is no then branch, we can assume that the type is null
+				node.info.typeVariable.constrainWithLowerBound(new RNullType());
+				if(!isElseBranchReachable) {
+					node.info.typeVariable.constrainWithUpperBound(new RNullType());
+				}
+			}
+		}
+		if(isElseBranchReachable) {
+			if(data.else !== undefined) {
+				const elseNode = this.getNormalizedAst(data.else);
+				guard(elseNode !== undefined, 'Expected else node to be defined');
+				node.info.typeVariable.constrainWithLowerBound(elseNode.info.typeVariable);
+				if(!isThenBranchReachable) {
+					node.info.typeVariable.constrainWithUpperBound(elseNode.info.typeVariable);
+				}
+			} else {
+				// If there is no else branch, we can assume that the type is null
+				node.info.typeVariable.constrainWithLowerBound(new RNullType());
+				if(!isThenBranchReachable) {
+					node.info.typeVariable.constrainWithUpperBound(new RNullType());
+				}
+			}
+		}
+		if(!isThenBranchReachable && !isElseBranchReachable) {
+			// If neither branch is reachable, we can assume that the type is none
+			node.info.typeVariable.constrainFromBothSides(new RNoneType());
+		}	
+	}
+	
+	override onQuoteCall(data: { call: DataflowGraphVertexFunctionCall }) {
+		guard(data.call.args.length === 1, 'Expected exactly one argument for quote call');
+		const arg = data.call.args.at(0);
+		guard(arg !== undefined && arg !== EmptyArgument, 'Expected argument of quote call to be defined');
+
+		const node = this.getNormalizedAst(data.call.id);
+		guard(node !== undefined, 'Expected AST node to be defined');
+		node.info.typeVariable.constrainFromBothSides(new RLanguageType());
+	}
+
+	override onEvalFunctionCall(data: { call: DataflowGraphVertexFunctionCall }) {
+		guard(data.call.args.length === 1, 'Expected exactly one argument for eval call');
+		const arg = data.call.args.at(0);
+		
+		guard(arg !== undefined && arg !== EmptyArgument, 'Expected argument of eval call to be defined');
+		const argNode = this.getNormalizedAst(arg.nodeId);
+		
+		guard(argNode !== undefined, 'Expected argument node to be defined');
+		argNode.info.typeVariable.constrainWithUpperBound(new RLanguageType());
+	}
+
+	override onListCall(data: { call: DataflowGraphVertexFunctionCall }) {
+		const node = this.getNormalizedAst(data.call.id);
+		guard(node !== undefined, 'Expected AST node to be defined');
+		const listType = new UnresolvedRListType();
+		node.info.typeVariable.constrainFromBothSides(listType);
+
+		for(const arg of data.call.args) {
+			if(arg === EmptyArgument) {
+				continue; // Skip empty arguments
+			}
+			const argNode = this.getNormalizedAst(arg.nodeId);
+			guard(argNode !== undefined, 'Expected argument node to be defined');
+			listType.elementType.constrainWithLowerBound(argNode.info.typeVariable);
+		}
+	}
+
+	override onVectorCall(data: { call: DataflowGraphVertexFunctionCall }) {
+		const node = this.getNormalizedAst(data.call.id);
+		guard(node !== undefined, 'Expected AST node to be defined');
+		
+		const args = data.call.args.filter((arg) => arg !== EmptyArgument);
+		if(args.length === 0) {
+			node.info.typeVariable.constrainFromBothSides(new RNullType());
+			return;
+		}
+		for(const arg of args) {
+			const argNode = this.getNormalizedAst(arg.nodeId);
+			guard(argNode !== undefined, 'Expected argument node to be defined');
+			node.info.typeVariable.constrainWithLowerBound(argNode.info.typeVariable);
+		}
+	}
+
+	override onFunctionDefinition(data: { vertex: DataflowGraphVertexFunctionDefinition }): void {
+		const node = this.getNormalizedAst(data.vertex.id);
+		guard(node !== undefined && node.type === RType.FunctionDefinition, 'Expected AST node to be a function definition');
+
+		const functionType = new UnresolvedRFunctionType();
+		node.info.typeVariable.constrainWithLowerBound(functionType);
+
+		let dotsEncountered = false;
+		for(const [index, param] of node.parameters.entries()) {
+			if(param.special) {
+				dotsEncountered = true;
+				continue; // Skip `...` parameters
+			}
+
+			if(!dotsEncountered) {
+				// Only constrain the parameter type positionally if no `...` has been encountered yet
+				functionType.getParameterType(index).constrainWithUpperBound(param.info.typeVariable);
+			}
+			functionType.getParameterType(param.name.lexeme).constrainWithUpperBound(param.info.typeVariable);
+			
+			if(param.defaultValue !== undefined) {
+				param.info.typeVariable.constrainWithLowerBound(param.defaultValue.info.typeVariable);
+			}
+		}
+	}
+
+	override onProgram(node: RExpressionList<UnresolvedTypeInfo>) {
+		const exitPoints = this.config.dataflowInfo.exitPoints;
+		const evalCandidates = exitPoints.map((exitPoint) => exitPoint.nodeId);
+
+		if(evalCandidates.length === 0) {
+			node.info.typeVariable.constrainFromBothSides(new RNullType());
+			return;
+		}
+
+		for(const candidateId of evalCandidates) {
+			const candidate = this.getNormalizedAst(candidateId);
+			guard(candidate !== undefined, 'Expected target node to be defined');
+			node.info.typeVariable.constrainWithLowerBound(candidate.info.typeVariable);
+		}
+	}
+
+	override onExpressionList(data: { call: DataflowGraphVertexFunctionCall }) {
+		const node = this.getNormalizedAst(data.call.id);
+		guard(node !== undefined, 'Expected AST node to be defined');
+
+		const outgoing = this.config.dataflowInfo.graph.outgoingEdges(data.call.id);
+		const evalCandidates = outgoing?.entries()
+			.filter(([_target, edge]) => edgeIncludesType(edge.types, EdgeType.Returns))
+			.map(([target, _edge]) => target)
+			.toArray();
+
+		if(evalCandidates === undefined || evalCandidates.length === 0) {
+			node.info.typeVariable.constrainFromBothSides(new RNullType());
+			return;
+		}
+
+		for(const candidateId of evalCandidates) {
+			const candidate = this.getNormalizedAst(candidateId);
+			guard(candidate !== undefined, 'Expected target node to be defined');
+			node.info.typeVariable.constrainWithLowerBound(candidate.info.typeVariable);
+		}
+	}
+
+	// override onAccessCall(data: { call: DataflowGraphVertexFunctionCall; }): void {
+	// 	const node = this.getNormalizedAst(data.call.id);
+	// 	guard(node !== undefined, 'Expected AST node to be defined');
+
+	// 	const firstArg = data.call.args.at(0);
+	// 	guard(firstArg !== undefined && firstArg !== EmptyArgument, 'Expected first argument of access call to be defined');
+	// 	const firstArgNode = this.getNormalizedAst(firstArg.nodeId);
+	// 	guard(firstArgNode !== undefined, 'Expected first argument node to be defined');
+	// 	const firstArgType = firstArgNode.info.typeVariable;
+	// 	const firstArgBoundType = firstArgType.find();
+		
+	// 	switch(data.call.name) {
+	// 		case '[':
+	// 			// If the access call is a `[` operation, we can assume that the it returns a subset
+	// 			// of the first argument's elements as another instance of the same container type
+	// 			node.info.typeVariable.constrainWithLowerBound(firstArgNode.info.typeVariable);
+	// 			break;
+	// 		case '[[':
+	// 			if(firstArgBoundType instanceof UnresolvedRListType) {
+	// 				node.info.typeVariable.constrainWithLowerBound(firstArgBoundType.elementType);
+	// 			} else if(isVectorType(firstArgBoundType) || firstArgBoundType instanceof RNullType) {
+	// 				node.info.typeVariable.constrainWithLowerBound(firstArgType);
+	// 			}
+	// 			break;
+	// 		case '$':
+	// 			if(firstArgBoundType instanceof UnresolvedRListType) {
+	// 				node.info.typeVariable.constrainWithLowerBound(firstArgBoundType.elementType);
+	// 			}
+	// 			break;
+	// 	}
+	// }
+}
\ No newline at end of file
diff --git a/src/subtyping/types.ts b/src/subtyping/types.ts
new file mode 100644
index 00000000000..ac7e396b63e
--- /dev/null
+++ b/src/subtyping/types.ts
@@ -0,0 +1,392 @@
+/**
+ * This enum lists a tag for each of the possible R data types inferred by the
+ * type inferencer. It is mainly used to identify subtypes of {@link RDataType}.
+ */
+export enum RDataTypeTag {
+    /** {@link RLogicalType} */
+    Logical = 'RLogicalType',
+    /** {@link RIntegerType} */
+    Integer = 'RIntegerType',
+    /** {@link RDoubleType} */
+    Double = 'RDoubleType',
+    /** {@link RComplexType} */
+	Complex = 'RComplexType',
+    /** {@link RStringType} */
+    String = 'RStringType',
+    /** {@link RRawType} */
+    Raw = 'RRawType',
+    /** {@link RNullType} */
+	Null = 'RNullType',
+    /** {@link RFunctionType} */
+    Function = 'RFunctionType',
+    /** {@link RListType} */
+    List = 'RListType',
+    /** {@link REnvironmentType} */
+    Environment = 'REnvironmentType',
+    /** {@link RLanguageType} */
+    Language = 'RLanguageType',
+	/** {@link UnresolvedRTypeVariable} */
+    Variable = 'RTypeVariable',
+	/** {@link RErrorType} */
+	Error = 'RErrorType',
+	/** {@link RAnyType} */
+	Any = 'RAnyType',
+	/** {@link RNoneType} */
+	None = 'RNoneType',
+}
+
+export class RLogicalType {
+	readonly tag = RDataTypeTag.Logical;
+}
+
+export class RIntegerType {
+	readonly tag = RDataTypeTag.Integer;
+}
+
+export class RDoubleType {
+	readonly tag = RDataTypeTag.Double;
+}
+
+export class RComplexType {
+	readonly tag = RDataTypeTag.Complex;
+}
+
+export class RStringType {
+	readonly tag = RDataTypeTag.String;
+}
+
+export class RRawType {
+	readonly tag = RDataTypeTag.Raw;
+}
+
+export class RNullType {
+	readonly tag = RDataTypeTag.Null;
+}
+
+export class UnresolvedRFunctionType {
+	readonly tag = RDataTypeTag.Function;
+	readonly parameterTypes = new Map<number | string, UnresolvedRTypeVariable>();
+	readonly returnType = new UnresolvedRTypeVariable();
+
+	getParameterType(indexOrName: number | string): UnresolvedRTypeVariable {
+		if(!this.parameterTypes.has(indexOrName)) {
+			this.parameterTypes.set(indexOrName, new UnresolvedRTypeVariable());
+		}
+		// eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+		return this.parameterTypes.get(indexOrName)!;
+	}
+
+	constrainWithLowerBound(bound: UnresolvedRFunctionType): void {
+		for(const [key, type] of bound.parameterTypes) {
+			this.getParameterType(key).constrainWithUpperBound(type);
+		}
+		this.returnType.constrainWithLowerBound(bound.returnType);
+	}
+
+	constrainWithUpperBound(bound: UnresolvedRFunctionType): void {
+		for(const [key, type] of bound.parameterTypes) {
+			this.getParameterType(key).constrainWithLowerBound(type);
+		}
+		this.returnType.constrainWithUpperBound(bound.returnType);
+	}
+}
+
+export class RFunctionType {
+	readonly tag = RDataTypeTag.Function;
+	readonly parameterTypes: Map<number | string, RDataType>;
+	readonly returnType:     RDataType;
+
+	constructor(parameterTypes: Map<number | string, RDataType>, returnType: RDataType) {
+		this.parameterTypes = parameterTypes;
+		this.returnType = returnType;
+	}
+}
+
+export class UnresolvedRListType {
+	readonly tag = RDataTypeTag.List;
+	readonly elementType = new UnresolvedRTypeVariable();
+
+	constructor(elementType?: UnresolvedRDataType) {
+		if(elementType !== undefined) {
+			this.elementType.constrainWithLowerBound(elementType);
+		}
+	}
+	
+	constrainWithLowerBound(bound: UnresolvedRListType): void {
+		this.elementType.constrainWithLowerBound(bound.elementType);
+	}
+
+	constrainWithUpperBound(bound: UnresolvedRListType): void {
+		this.elementType.constrainWithUpperBound(bound.elementType);
+	}
+}
+
+export class RListType {
+	readonly tag = RDataTypeTag.List;
+	readonly elementType: RDataType;
+
+	constructor(elementType: RDataType) {
+		this.elementType = elementType;
+	}
+}
+
+export class REnvironmentType {
+	readonly tag = RDataTypeTag.Environment;
+}
+
+export class RLanguageType {
+	readonly tag = RDataTypeTag.Language;
+}
+
+export class UnresolvedRTypeVariable {
+	readonly tag = RDataTypeTag.Variable;
+	readonly lowerBounds: Set<UnresolvedRDataType> = new Set();
+	readonly upperBounds: Set<UnresolvedRDataType> = new Set();
+
+	constrainWithLowerBound(bound: UnresolvedRDataType): void {
+		this.lowerBounds.add(bound);
+		
+		for(const upperBound of this.upperBounds) {
+			if(upperBound instanceof UnresolvedRTypeVariable && upperBound !== bound) {
+				upperBound.constrainWithLowerBound(bound);
+			} else if(bound instanceof UnresolvedRTypeVariable && bound !== upperBound) {
+				bound.constrainWithUpperBound(upperBound);
+			} else if(upperBound instanceof UnresolvedRFunctionType && bound instanceof UnresolvedRFunctionType && upperBound !== bound) {
+				upperBound.constrainWithLowerBound(bound);
+			} else if(upperBound instanceof UnresolvedRListType && bound instanceof UnresolvedRListType && upperBound !== bound) {
+				upperBound.constrainWithLowerBound(bound);
+			}
+		}
+	}
+
+	constrainWithUpperBound(bound: UnresolvedRDataType): void {
+		this.upperBounds.add(bound);
+
+		for(const lowerBound of this.lowerBounds) {
+			if(lowerBound instanceof UnresolvedRTypeVariable && lowerBound !== bound) {
+				lowerBound.constrainWithUpperBound(bound);
+			} else if(bound instanceof UnresolvedRTypeVariable && bound !== lowerBound) {
+				bound.constrainWithLowerBound(lowerBound);
+			} else if(lowerBound instanceof UnresolvedRFunctionType && bound instanceof UnresolvedRFunctionType && lowerBound !== bound) {
+				lowerBound.constrainWithUpperBound(bound);
+			} else if(lowerBound instanceof UnresolvedRListType && bound instanceof UnresolvedRListType && lowerBound !== bound) {
+				lowerBound.constrainWithUpperBound(bound);
+			}
+		}
+	}
+
+	constrainFromBothSides(other: UnresolvedRDataType): void {
+		this.constrainWithLowerBound(other);
+		this.constrainWithUpperBound(other);
+	}
+}
+
+export class RTypeVariable {
+	readonly tag = RDataTypeTag.Variable;
+	readonly lowerBound: RDataType;
+	readonly upperBound: RDataType;
+	
+	constructor(lowerBound: RDataType, upperBound: RDataType) {
+		this.lowerBound = lowerBound;
+		this.upperBound = upperBound;
+	}
+}
+
+export class RErrorType {
+	readonly tag = RDataTypeTag.Error;
+	conflictingBounds: [RDataType, RDataType];
+
+	constructor(...conflictingBounds: [RDataType, RDataType]) {
+		this.conflictingBounds = conflictingBounds;
+	}
+}
+
+export class RAnyType {
+	readonly tag = RDataTypeTag.Any;
+}
+
+export class RNoneType {
+	readonly tag = RDataTypeTag.None;
+}
+
+
+export function resolveType(type: UnresolvedRDataType): RDataType {
+	if(type instanceof UnresolvedRTypeVariable) {
+		let lowerBound: RDataType = new RNoneType();
+		for(const bound of type.lowerBounds) {
+			const resolvedBound = resolveType(bound);
+			lowerBound = union(lowerBound, resolvedBound);
+		}
+		let upperBound: RDataType = new RAnyType();
+		for(const bound of type.upperBounds) {
+			const resolvedBound = resolveType(bound);
+			upperBound = intersection(upperBound, resolvedBound);
+		}
+
+		if(!subsumes(lowerBound, upperBound)) {
+			return new RErrorType(lowerBound, upperBound);
+		} else if(subsumes(lowerBound, upperBound) && subsumes(upperBound, lowerBound)) {
+			return lowerBound; // If both bounds are equal, return one of them
+		} else {
+			return new RTypeVariable(
+				lowerBound instanceof RTypeVariable ? lowerBound.lowerBound : lowerBound,
+				upperBound instanceof RTypeVariable ? upperBound.upperBound : upperBound
+			);
+		}
+	} else if(type instanceof UnresolvedRFunctionType) {
+		const resolvedParameterTypes = new Map(type.parameterTypes.entries().toArray().map(([key, type]) => [key, resolveType(type)]));
+		const resolvedReturnType = resolveType(type.returnType);
+		return new RFunctionType(resolvedParameterTypes, resolvedReturnType);
+	} else if(type instanceof UnresolvedRListType) {
+		const resolvedElementType = resolveType(type.elementType);
+		return new RListType(resolvedElementType);
+	} else {
+		return type;
+	}
+}
+
+function subsumes(subtype: RDataType, supertype: RDataType): boolean {
+	if(subtype === supertype) {
+		return true;
+	} else if(subtype instanceof RErrorType || supertype instanceof RErrorType) {
+		return false; // Error types do not subsume and are not subsumed by any other type
+	} else if(subtype instanceof RNoneType || supertype instanceof RAnyType) {
+		return true; // None subsumes any type, Any is subsumed by any type
+	} else if(subtype instanceof RTypeVariable) {
+		return subsumes(subtype.lowerBound, supertype) && subsumes(subtype.upperBound, supertype);
+	} else if(supertype instanceof RTypeVariable) {
+		return subsumes(supertype.lowerBound, subtype) && subsumes(subtype, supertype.upperBound);
+	} else if(subtype instanceof RListType && supertype instanceof RListType) {
+		return subsumes(subtype.elementType, supertype.elementType);
+	} else if(subtype instanceof RFunctionType && supertype instanceof RFunctionType) {
+		return subsumes(subtype.returnType, supertype.returnType) && subtype.parameterTypes.entries().every(([key, type]) => {
+			const supertypeParameter = supertype.parameterTypes.get(key);
+			if(supertypeParameter === undefined) {
+				return false; // supertype does not have a parameter with this key
+			}
+			return subsumes(supertypeParameter, type);
+		});
+	} else {
+		return subsumesByTag(subtype.tag, supertype.tag);
+	}
+}
+
+function subsumesByTag(subtype: RDataTypeTag, supertype: RDataTypeTag): boolean {
+	return subtype === supertype && subtype !== RDataTypeTag.Error
+		|| subtype === RDataTypeTag.Logical && supertype === RDataTypeTag.Integer
+		|| subtype === RDataTypeTag.Logical && supertype === RDataTypeTag.Double
+		|| subtype === RDataTypeTag.Logical && supertype === RDataTypeTag.Complex
+		|| subtype === RDataTypeTag.Integer && supertype === RDataTypeTag.Double
+		|| subtype === RDataTypeTag.Integer && supertype === RDataTypeTag.Complex
+		|| subtype === RDataTypeTag.Double && supertype === RDataTypeTag.Complex
+		|| subtype === RDataTypeTag.None || supertype === RDataTypeTag.Any
+		|| subtype === RDataTypeTag.Variable || supertype === RDataTypeTag.Variable;
+}
+
+function union(type1: RDataType, type2: RDataType): RDataType {
+	if(type1 instanceof RErrorType) {
+		return type1;
+	} else if(type2 instanceof RErrorType) {
+		return type2;
+	} else if(type1 instanceof RFunctionType && type2 instanceof RFunctionType) {
+		const parameterTypes = new Map<number | string, RDataType>();
+		const keys1 = new Set(type1.parameterTypes.keys());
+		const keys2 = new Set(type2.parameterTypes.keys());
+		for(const key of keys1.union(keys2)) {
+			const parameterType1 = type1.parameterTypes.get(key) ?? new RNoneType();
+			const parameterType2 = type2.parameterTypes.get(key) ?? new RNoneType();
+			parameterTypes.set(key, intersection(parameterType1, parameterType2));
+		}
+		const returnType = union(type1.returnType, type2.returnType);
+		return new RFunctionType(parameterTypes, returnType);
+	} else if(type1 instanceof RListType && type2 instanceof RListType) {
+		return new RListType(union(type1.elementType, type2.elementType));
+	} else if(subsumesByTag(type1.tag, type2.tag)) {
+		return type2;
+	} else if(subsumesByTag(type2.tag, type1.tag)) {
+		return type1;
+	}
+	return new RAnyType();
+}
+
+function intersection(type1: RDataType, type2: RDataType): RDataType {
+	if(type1 instanceof RErrorType) {
+		return type1;
+	} else if(type2 instanceof RErrorType) {
+		return type2;
+	} else if(type1 instanceof RFunctionType && type2 instanceof RFunctionType) {
+		const parameterTypes = new Map<number | string, RDataType>();
+		const keys1 = new Set(type1.parameterTypes.keys());
+		const keys2 = new Set(type2.parameterTypes.keys());
+		for(const key of keys1.intersection(keys2)) {
+			const parameterType1 = type1.parameterTypes.get(key) ?? new RAnyType();
+			const parameterType2 = type2.parameterTypes.get(key) ?? new RAnyType();
+			parameterTypes.set(key, union(parameterType1, parameterType2));
+		}
+		const returnType = intersection(type1.returnType, type2.returnType);
+		return new RFunctionType(parameterTypes, returnType);
+	} else if(type1 instanceof RListType && type2 instanceof RListType) {
+		return new RListType(intersection(type1.elementType, type2.elementType));
+	} else if(subsumesByTag(type1.tag, type2.tag)) {
+		return type1;
+	} else if(subsumesByTag(type2.tag, type1.tag)) {
+		return type2;
+	}
+	return new RNoneType();
+}
+
+
+export type RVectorType
+	= RLogicalType
+	| RIntegerType
+	| RDoubleType
+	| RComplexType
+	| RStringType
+	| RRawType
+
+export function isVectorType(type: RDataType | UnresolvedRDataType): type is RVectorType {
+	return type.tag === RDataTypeTag.Logical
+		|| type.tag === RDataTypeTag.Integer
+		|| type.tag === RDataTypeTag.Double
+		|| type.tag === RDataTypeTag.Complex
+		|| type.tag === RDataTypeTag.String
+		|| type.tag === RDataTypeTag.Raw;
+}
+	
+export type CompoundRDataType = RFunctionType | RListType;
+
+export function isCompoundType(type: UnresolvedRDataType): type is UnresolvedCompoundRDataType
+export function isCompoundType(type: RDataType): type is CompoundRDataType
+export function isCompoundType(type: RDataType | UnresolvedRDataType): type is CompoundRDataType | UnresolvedCompoundRDataType {
+	return type.tag === RDataTypeTag.Function || type.tag === RDataTypeTag.List;
+}
+
+/**
+ * The `RDataType` type is the union of all possible types that can be inferred
+ * by the type inferencer for R objects.
+ * It should be used whenever you either not care what kind of
+ * type you are dealing with or if you want to handle all possible types.
+*/
+export type RDataType
+	= RVectorType
+	| RNullType
+	| REnvironmentType
+	| RLanguageType
+	| CompoundRDataType
+	| RTypeVariable
+	| RErrorType
+	| RAnyType
+	| RNoneType;
+	
+export type UnresolvedCompoundRDataType = UnresolvedRFunctionType | UnresolvedRListType;
+	
+export type UnresolvedRDataType
+	= RVectorType
+	| RNullType
+	| REnvironmentType
+	| RLanguageType
+	| UnresolvedCompoundRDataType
+	| UnresolvedRTypeVariable
+	// | RErrorType
+	| RAnyType
+	| RNoneType;
\ No newline at end of file
diff --git a/test/functionality/_helper/subtyping/assert-inferred-type.ts b/test/functionality/_helper/subtyping/assert-inferred-type.ts
new file mode 100644
index 00000000000..2749b335a35
--- /dev/null
+++ b/test/functionality/_helper/subtyping/assert-inferred-type.ts
@@ -0,0 +1,47 @@
+import { describe, expect, test } from 'vitest';
+import { TreeSitterExecutor } from '../../../../src/r-bridge/lang-4.x/tree-sitter/tree-sitter-executor';
+import { createDataflowPipeline } from '../../../../src/core/steps/pipeline/default-pipelines';
+import { requestFromInput } from '../../../../src/r-bridge/retriever';
+import { RAnyType, RNoneType, RTypeVariable, type RDataType } from '../../../../src/subtyping/types';
+import type { DataTypeInfo } from '../../../../src/subtyping/infer';
+import { inferDataTypes } from '../../../../src/subtyping/infer';
+import { type FlowrSearch } from '../../../../src/search/flowr-search-builder';
+import { runSearch } from '../../../../src/search/flowr-search-executor';
+import type { ParentInformation } from '../../../../src/r-bridge/lang-4.x/ast/model/processing/decorate';
+import type { RNode } from '../../../../src/r-bridge/lang-4.x/ast/model/model';
+
+export function assertInferredType(input: string, expectedType: { expectedType: RDataType } | { lowerBound?: RDataType, upperBound?: RDataType }): void {
+	assertInferredTypes(input, expectedType);
+}
+export function assertInferredTypes(
+	input: string,
+	...expectations: ({ query?: FlowrSearch } & ({ expectedType: RDataType } | { lowerBound?: RDataType, upperBound?: RDataType }))[]
+): void {
+	describe(`Infer types for ${input}`, async() => {
+		const executor = new TreeSitterExecutor();
+		const result = await createDataflowPipeline(executor, { request: requestFromInput(input) }).allRemainingSteps();
+		inferDataTypes(result.normalize, result.dataflow);
+
+		const expectedTypes = expectations.map(({ query, ...rest }) => ({
+			query,
+			expectedType: 'expectedType' in rest
+				? rest.expectedType
+				: new RTypeVariable(rest.lowerBound ?? new RNoneType(), rest.upperBound ?? new RAnyType())
+		}));
+
+		describe.each(expectedTypes)('Infer $expectedType.tag for query $query', ({ query, expectedType }) => {
+			let node: RNode<ParentInformation & DataTypeInfo>;
+			if(query !== undefined) {
+				const searchResult = runSearch(query, result);
+				expect(searchResult).toHaveLength(1);
+				node = searchResult[0].node as RNode<ParentInformation & DataTypeInfo>;
+			} else {
+				node = result.normalize.idMap.get(result.dataflow.exitPoints[0].nodeId) as RNode<ParentInformation & DataTypeInfo>;
+			}
+
+			test(`Infer ${expectedType.tag} for ${node.lexeme}`, () => {
+				expect(node.info.inferredType).toEqual(expectedType);
+			});
+		});
+	});
+}
\ No newline at end of file
diff --git a/test/functionality/subtyping/builtin-functions.test.ts b/test/functionality/subtyping/builtin-functions.test.ts
new file mode 100644
index 00000000000..55fd01fc47c
--- /dev/null
+++ b/test/functionality/subtyping/builtin-functions.test.ts
@@ -0,0 +1,30 @@
+import { describe } from 'vitest';
+import { RAnyType, RIntegerType, RLanguageType, RListType, RLogicalType, RNoneType, RNullType, RStringType, RTypeVariable } from '../../../src/subtyping/types';
+import { assertInferredType, assertInferredTypes } from '../_helper/subtyping/assert-inferred-type';
+import { Q } from '../../../src/search/flowr-search-builder';
+
+describe('Infer types for builtin functions', () => {
+	assertInferredType('rm(x)', { expectedType: new RNullType() });
+
+	assertInferredTypes(
+		'x <- 42\nget("x")',
+		{ query: Q.criterion('1@x').build(),   lowerBound: new RIntegerType() },
+		{ query: Q.criterion('2@get').build(), lowerBound: new RIntegerType() },
+		{ query: Q.criterion('2@"x"').build(), upperBound: new RStringType() }
+	);
+
+	assertInferredTypes(
+		'eval(quote(TRUE))',
+		{ query: Q.criterion('1@eval').build(),  lowerBound: new RNoneType(), upperBound: new RAnyType() },
+		{ query: Q.criterion('1@quote').build(), expectedType: new RLanguageType() },
+		{ query: Q.criterion('1@TRUE').build(),  expectedType: new RLogicalType() }
+	);
+	
+	assertInferredType('list(1, 2, 3)', { expectedType: new RListType(new RTypeVariable(new RIntegerType(), new RAnyType())) });
+
+	assertInferredTypes(
+		'c("Hello", "Flo", "!")',
+		{ query: Q.criterion('1@c').build(),       lowerBound: new RStringType() },
+		{ query: Q.criterion('1@"Hello"').build(), expectedType: new RStringType() },
+	);
+});
\ No newline at end of file
diff --git a/test/functionality/subtyping/conditionals.test.ts b/test/functionality/subtyping/conditionals.test.ts
new file mode 100644
index 00000000000..61b50ad4f23
--- /dev/null
+++ b/test/functionality/subtyping/conditionals.test.ts
@@ -0,0 +1,19 @@
+import { describe } from 'vitest';
+import { RLogicalType, RNoneType, RNullType, RStringType } from '../../../src/subtyping/types';
+import { assertInferredType, assertInferredTypes } from '../_helper/subtyping/assert-inferred-type';
+import { Q } from '../../../src/search/flowr-search-builder';
+import { RType } from '../../../src/r-bridge/lang-4.x/ast/model/type';
+
+describe('Infer types for if statements', () => {
+	describe.each([
+		{ input: 'if(FALSE) { TRUE }',                     expectedType: new RNullType() },
+		{ input: 'if(TRUE) { "Hi" } else { NULL }',        lowerBound: new RStringType() },
+		{ input: 'if(stop("stop here")) { 1 } else { 2 }', expectedType: new RNoneType() },
+	])('Infer $expectedType for $input', ({ input, ...expectedType }) => assertInferredType(input, expectedType));
+
+	assertInferredTypes(
+		'a <- if(1 > 2) { "Yes" } else { "Nope" }',
+		{ query: Q.all().filter(RType.BinaryOp).first().build(), lowerBound: new RStringType() },
+		{ query: Q.all().filter(RType.BinaryOp).last().build(),  upperBound: new RLogicalType() },
+	);
+});
\ No newline at end of file
diff --git a/test/functionality/subtyping/constants.test.ts b/test/functionality/subtyping/constants.test.ts
new file mode 100644
index 00000000000..df02b87acfe
--- /dev/null
+++ b/test/functionality/subtyping/constants.test.ts
@@ -0,0 +1,15 @@
+import { describe } from 'vitest';
+import { RComplexType, RDoubleType, RIntegerType, RLogicalType, RNullType, RStringType } from '../../../src/subtyping/types';
+import { assertInferredType } from '../_helper/subtyping/assert-inferred-type';
+
+describe.each([
+	{ description: 'logical constant',        input: 'TRUE',            expectedType: new RLogicalType() },
+	{ description: 'logical constant',        input: 'FALSE',           expectedType: new RLogicalType() },
+	{ description: 'null constant',           input: 'NULL',            expectedType: new RNullType() },
+	{ description: 'integer constant',        input: '42',              lowerBound: new RIntegerType(), upperBound: new RComplexType() },
+	{ description: 'integer constant',        input: '42L',             expectedType: new RIntegerType() },
+	{ description: 'double constant',         input: '42.5',            lowerBound: new RDoubleType(), upperBound: new RComplexType() },
+	{ description: 'complex number constant', input: '42i',             expectedType: new RComplexType() },
+	{ description: 'string constant',         input: '"Hello, world!"', expectedType: new RStringType() },
+	{ description: 'empty expression list',   input: '{}',              expectedType: new RNullType() }
+])('Infer $expectedType for $description', ({ input, ...expectedType }) => assertInferredType(input, expectedType));
\ No newline at end of file
diff --git a/test/functionality/subtyping/loops.test.ts b/test/functionality/subtyping/loops.test.ts
new file mode 100644
index 00000000000..1f8a2ac4f1e
--- /dev/null
+++ b/test/functionality/subtyping/loops.test.ts
@@ -0,0 +1,23 @@
+import { describe } from 'vitest';
+import { RLogicalType, RNoneType, RNullType } from '../../../src/subtyping/types';
+import { assertInferredType, assertInferredTypes } from '../_helper/subtyping/assert-inferred-type';
+import { Q } from '../../../src/search/flowr-search-builder';
+import { RType } from '../../../src/r-bridge/lang-4.x/ast/model/type';
+
+describe('Infer types for loops', () => {
+	describe.each([
+		{ input: 'while(FALSE) { print("Testing is fun!") }',                         expectedType: new RNullType() },
+		{ input: 'while(TRUE) { next }',                                              expectedType: new RNoneType() },
+		{ input: 'while(1 < 2) { print("Hi Flo!") }',                                 expectedType: new RNullType() },
+		{ input: 'while(TRUE) { break }',                                             expectedType: new RNullType() },
+		{ input: 'for(i in NULL) { print("I would like to write a test for that") }', expectedType: new RNullType() },
+		{ input: 'for(i in 1:10) { print(i) }',                                       expectedType: new RNullType() },
+		{ input: 'repeat { print("I love testing!") }',                               expectedType: new RNoneType() },
+		{ input: 'repeat { break }',                                                  expectedType: new RNullType() },
+	])('Infer $expectedType for $input', ({ input, ...expectedType }) => assertInferredType(input, expectedType));
+
+	assertInferredTypes(
+		'while(1 > 2) { print("Testing is done!") }',
+		{ query: Q.all().filter(RType.BinaryOp).build(), upperBound: new RLogicalType() },
+	);
+});
\ No newline at end of file
diff --git a/test/functionality/subtyping/unsupported-expressions.test.ts b/test/functionality/subtyping/unsupported-expressions.test.ts
new file mode 100644
index 00000000000..b81572c970a
--- /dev/null
+++ b/test/functionality/subtyping/unsupported-expressions.test.ts
@@ -0,0 +1,8 @@
+import { describe } from 'vitest';
+import { RAnyType, RNoneType, RTypeVariable } from '../../../src/subtyping/types';
+import { assertInferredType } from '../_helper/subtyping/assert-inferred-type';
+
+describe('Infer no type information for currently unsupported R expressions', () => {
+	assertInferredType('1 + 2',                  new RTypeVariable(new RNoneType(), new RAnyType()));
+	assertInferredType('print("Hello, world!")', new RTypeVariable(new RNoneType(), new RAnyType()));
+});
\ No newline at end of file
diff --git a/test/functionality/subtyping/variables.test.ts b/test/functionality/subtyping/variables.test.ts
new file mode 100644
index 00000000000..c791315219f
--- /dev/null
+++ b/test/functionality/subtyping/variables.test.ts
@@ -0,0 +1,13 @@
+import { describe } from 'vitest';
+import { RIntegerType } from '../../../src/subtyping/types';
+import { assertInferredTypes } from '../_helper/subtyping/assert-inferred-type';
+import { Q } from '../../../src/search/flowr-search-builder';
+
+describe('Infer types for variables', () => {
+	assertInferredTypes(
+		'x <- 42; x',
+		{ query: Q.var('x').first().build(),  lowerBound: new RIntegerType() },
+		{ query: Q.criterion('1@<-').build(), lowerBound: new RIntegerType() },
+		{ query: Q.var('x').last().build(),   lowerBound: new RIntegerType() }
+	);
+});
\ No newline at end of file

From 2f1882095b85ee8f840f03a5ec6c2c99d28f946c Mon Sep 17 00:00:00 2001
From: Lukas Rohde <lukas.rohde@silupe.de>
Date: Tue, 8 Jul 2025 18:46:32 +0200
Subject: [PATCH 085/153] wip(typing): distinguish scalars from vectors of
 arbitrary length

---
 src/subtyping/infer.ts                        | 19 +++---
 src/subtyping/types.ts                        | 60 ++++++++++++++++---
 .../subtyping/builtin-functions.test.ts       |  4 +-
 3 files changed, 67 insertions(+), 16 deletions(-)

diff --git a/src/subtyping/infer.ts b/src/subtyping/infer.ts
index 9fa84a70df5..e92f8b5a4c0 100644
--- a/src/subtyping/infer.ts
+++ b/src/subtyping/infer.ts
@@ -9,7 +9,7 @@ import type { RString } from '../r-bridge/lang-4.x/ast/model/nodes/r-string';
 import type { NormalizedAst, ParentInformation } from '../r-bridge/lang-4.x/ast/model/processing/decorate';
 import { mapNormalizedAstInfo } from '../r-bridge/lang-4.x/ast/model/processing/decorate';
 import type { RDataType, UnresolvedRDataType } from './types';
-import { UnresolvedRTypeVariable, RComplexType, RDoubleType, RIntegerType, RLogicalType, RStringType, resolveType, RNullType, UnresolvedRListType, RLanguageType, UnresolvedRFunctionType, RNoneType } from './types';
+import { UnresolvedRTypeVariable, RComplexType, RDoubleType, RIntegerType, RLogicalType, RStringType, resolveType, RNullType, UnresolvedRListType, RLanguageType, UnresolvedRFunctionType, RNoneType, UnresolvedRVectorType } from './types';
 import type { RExpressionList } from '../r-bridge/lang-4.x/ast/model/nodes/r-expression-list';
 import { guard } from '../util/assert';
 import { OriginType } from '../dataflow/origin/dfg-get-origin';
@@ -262,12 +262,12 @@ class TypeInferringCfgGuidedVisitor<
 	}
 
 	override onForLoopCall(data: { call: DataflowGraphVertexFunctionCall, variable: FunctionArgument, vector: FunctionArgument, body: FunctionArgument }) {
-		guard(data.variable !== EmptyArgument && data.vector !== EmptyArgument, 'Expected variable and vector arguments to be defined');
-		const variableNode = this.getNormalizedAst(data.variable.nodeId);
-		const vectorNode = this.getNormalizedAst(data.vector.nodeId);
+		// guard(data.variable !== EmptyArgument && data.vector !== EmptyArgument, 'Expected variable and vector arguments to be defined');
+		// const variableNode = this.getNormalizedAst(data.variable.nodeId);
+		// const vectorNode = this.getNormalizedAst(data.vector.nodeId);
 		
-		guard(variableNode !== undefined && vectorNode !== undefined, 'Expected variable and vector nodes to be defined');
-		variableNode.info.typeVariable.constrainWithLowerBound(vectorNode.info.typeVariable);
+		// guard(variableNode !== undefined && vectorNode !== undefined, 'Expected variable and vector nodes to be defined');
+		// variableNode.info.typeVariable.constrainWithLowerBound(vectorNode.info.typeVariable);
 
 		this.onLoopCall(data);
 	}
@@ -386,6 +386,7 @@ class TypeInferringCfgGuidedVisitor<
 	override onListCall(data: { call: DataflowGraphVertexFunctionCall }) {
 		const node = this.getNormalizedAst(data.call.id);
 		guard(node !== undefined, 'Expected AST node to be defined');
+		
 		const listType = new UnresolvedRListType();
 		node.info.typeVariable.constrainFromBothSides(listType);
 
@@ -408,10 +409,14 @@ class TypeInferringCfgGuidedVisitor<
 			node.info.typeVariable.constrainFromBothSides(new RNullType());
 			return;
 		}
+		
+		const vectorType = new UnresolvedRVectorType();
+		node.info.typeVariable.constrainFromBothSides(vectorType);
+		
 		for(const arg of args) {
 			const argNode = this.getNormalizedAst(arg.nodeId);
 			guard(argNode !== undefined, 'Expected argument node to be defined');
-			node.info.typeVariable.constrainWithLowerBound(argNode.info.typeVariable);
+			vectorType.elementType.constrainWithLowerBound(argNode.info.typeVariable);
 		}
 	}
 
diff --git a/src/subtyping/types.ts b/src/subtyping/types.ts
index ac7e396b63e..7b88d0dfe6d 100644
--- a/src/subtyping/types.ts
+++ b/src/subtyping/types.ts
@@ -15,6 +15,8 @@ export enum RDataTypeTag {
     String = 'RStringType',
     /** {@link RRawType} */
     Raw = 'RRawType',
+	/** {@link RVectorType} */
+	Vector = 'RVectorType',
     /** {@link RNullType} */
 	Null = 'RNullType',
     /** {@link RFunctionType} */
@@ -59,6 +61,34 @@ export class RRawType {
 	readonly tag = RDataTypeTag.Raw;
 }
 
+export class UnresolvedRVectorType {
+	readonly tag = RDataTypeTag.Vector;
+	readonly elementType = new UnresolvedRTypeVariable();
+
+	constructor(elementType?: UnresolvedRDataType) {
+		if(elementType !== undefined) {
+			this.elementType.constrainWithLowerBound(elementType);
+		}
+	}
+
+	constrainWithLowerBound(bound: UnresolvedRVectorType): void {
+		this.elementType.constrainWithLowerBound(bound.elementType);
+	}
+
+	constrainWithUpperBound(bound: UnresolvedRVectorType): void {
+		this.elementType.constrainWithUpperBound(bound.elementType);
+	}
+}
+
+export class RVectorType {
+	readonly tag = RDataTypeTag.Vector;
+	readonly elementType: RDataType;
+
+	constructor(elementType: RDataType) {
+		this.elementType = elementType;
+	}
+}
+
 export class RNullType {
 	readonly tag = RDataTypeTag.Null;
 }
@@ -155,6 +185,8 @@ export class UnresolvedRTypeVariable {
 				upperBound.constrainWithLowerBound(bound);
 			} else if(upperBound instanceof UnresolvedRListType && bound instanceof UnresolvedRListType && upperBound !== bound) {
 				upperBound.constrainWithLowerBound(bound);
+			} else if(upperBound instanceof UnresolvedRVectorType && bound instanceof UnresolvedRVectorType && upperBound !== bound) {
+				upperBound.constrainWithLowerBound(bound);
 			}
 		}
 	}
@@ -171,6 +203,8 @@ export class UnresolvedRTypeVariable {
 				lowerBound.constrainWithUpperBound(bound);
 			} else if(lowerBound instanceof UnresolvedRListType && bound instanceof UnresolvedRListType && lowerBound !== bound) {
 				lowerBound.constrainWithUpperBound(bound);
+			} else if(lowerBound instanceof UnresolvedRVectorType && bound instanceof UnresolvedRVectorType && lowerBound !== bound) {
+				lowerBound.constrainWithUpperBound(bound);
 			}
 		}
 	}
@@ -240,6 +274,9 @@ export function resolveType(type: UnresolvedRDataType): RDataType {
 	} else if(type instanceof UnresolvedRListType) {
 		const resolvedElementType = resolveType(type.elementType);
 		return new RListType(resolvedElementType);
+	} else if(type instanceof UnresolvedRVectorType) {
+		const resolvedElementType = resolveType(type.elementType);
+		return new RVectorType(resolvedElementType);
 	} else {
 		return type;
 	}
@@ -258,6 +295,15 @@ function subsumes(subtype: RDataType, supertype: RDataType): boolean {
 		return subsumes(supertype.lowerBound, subtype) && subsumes(subtype, supertype.upperBound);
 	} else if(subtype instanceof RListType && supertype instanceof RListType) {
 		return subsumes(subtype.elementType, supertype.elementType);
+	} else if(supertype instanceof RVectorType) {
+		if(subtype instanceof RVectorType) {
+			return subsumes(subtype.elementType, supertype.elementType);
+		} else if(subtype instanceof RLogicalType || subtype instanceof RIntegerType || subtype instanceof RDoubleType || subtype instanceof RComplexType || subtype instanceof RStringType || subtype instanceof RRawType) {
+			// A scalar subsumes a vector type if it subsumes the element type of the vector
+			return subsumes(subtype, supertype.elementType);
+		} else {
+			return false; // A non-vector type cannot subsume a vector type
+		}
 	} else if(subtype instanceof RFunctionType && supertype instanceof RFunctionType) {
 		return subsumes(subtype.returnType, supertype.returnType) && subtype.parameterTypes.entries().every(([key, type]) => {
 			const supertypeParameter = supertype.parameterTypes.get(key);
@@ -336,7 +382,7 @@ function intersection(type1: RDataType, type2: RDataType): RDataType {
 }
 
 
-export type RVectorType
+export type RVectorElementType
 	= RLogicalType
 	| RIntegerType
 	| RDoubleType
@@ -344,7 +390,7 @@ export type RVectorType
 	| RStringType
 	| RRawType
 
-export function isVectorType(type: RDataType | UnresolvedRDataType): type is RVectorType {
+export function isVectorType(type: RDataType | UnresolvedRDataType): type is RVectorElementType {
 	return type.tag === RDataTypeTag.Logical
 		|| type.tag === RDataTypeTag.Integer
 		|| type.tag === RDataTypeTag.Double
@@ -353,12 +399,12 @@ export function isVectorType(type: RDataType | UnresolvedRDataType): type is RVe
 		|| type.tag === RDataTypeTag.Raw;
 }
 	
-export type CompoundRDataType = RFunctionType | RListType;
+export type CompoundRDataType = RVectorType | RFunctionType | RListType;
 
 export function isCompoundType(type: UnresolvedRDataType): type is UnresolvedCompoundRDataType
 export function isCompoundType(type: RDataType): type is CompoundRDataType
 export function isCompoundType(type: RDataType | UnresolvedRDataType): type is CompoundRDataType | UnresolvedCompoundRDataType {
-	return type.tag === RDataTypeTag.Function || type.tag === RDataTypeTag.List;
+	return type.tag === RDataTypeTag.Vector || type.tag === RDataTypeTag.Function || type.tag === RDataTypeTag.List;
 }
 
 /**
@@ -368,7 +414,7 @@ export function isCompoundType(type: RDataType | UnresolvedRDataType): type is C
  * type you are dealing with or if you want to handle all possible types.
 */
 export type RDataType
-	= RVectorType
+	= RVectorElementType
 	| RNullType
 	| REnvironmentType
 	| RLanguageType
@@ -378,10 +424,10 @@ export type RDataType
 	| RAnyType
 	| RNoneType;
 	
-export type UnresolvedCompoundRDataType = UnresolvedRFunctionType | UnresolvedRListType;
+export type UnresolvedCompoundRDataType = UnresolvedRVectorType | UnresolvedRFunctionType | UnresolvedRListType;
 	
 export type UnresolvedRDataType
-	= RVectorType
+	= RVectorElementType
 	| RNullType
 	| REnvironmentType
 	| RLanguageType
diff --git a/test/functionality/subtyping/builtin-functions.test.ts b/test/functionality/subtyping/builtin-functions.test.ts
index 55fd01fc47c..6d31d4ce2a8 100644
--- a/test/functionality/subtyping/builtin-functions.test.ts
+++ b/test/functionality/subtyping/builtin-functions.test.ts
@@ -1,5 +1,5 @@
 import { describe } from 'vitest';
-import { RAnyType, RIntegerType, RLanguageType, RListType, RLogicalType, RNoneType, RNullType, RStringType, RTypeVariable } from '../../../src/subtyping/types';
+import { RAnyType, RIntegerType, RLanguageType, RListType, RLogicalType, RNoneType, RNullType, RStringType, RTypeVariable, RVectorType } from '../../../src/subtyping/types';
 import { assertInferredType, assertInferredTypes } from '../_helper/subtyping/assert-inferred-type';
 import { Q } from '../../../src/search/flowr-search-builder';
 
@@ -24,7 +24,7 @@ describe('Infer types for builtin functions', () => {
 
 	assertInferredTypes(
 		'c("Hello", "Flo", "!")',
-		{ query: Q.criterion('1@c').build(),       lowerBound: new RStringType() },
+		{ query: Q.criterion('1@c').build(),       expectedType: new RVectorType(new RTypeVariable(new RStringType(), new RAnyType())) },
 		{ query: Q.criterion('1@"Hello"').build(), expectedType: new RStringType() },
 	);
 });
\ No newline at end of file

From b98b3ec65e62f32d580010d32405e51acbaeb719 Mon Sep 17 00:00:00 2001
From: Lukas Rohde <lukas.rohde@silupe.de>
Date: Tue, 8 Jul 2025 20:35:32 +0200
Subject: [PATCH 086/153] wip(typing): introduce `RVectorType` as join of list
 and atomic vector

---
 src/subtyping/infer.ts                        |  23 +-
 src/subtyping/types.ts                        | 252 +++++++++++-------
 .../_helper/subtyping/assert-inferred-type.ts |   6 +-
 .../subtyping/builtin-functions.test.ts       |   4 +-
 4 files changed, 173 insertions(+), 112 deletions(-)

diff --git a/src/subtyping/infer.ts b/src/subtyping/infer.ts
index e92f8b5a4c0..1737dc7415d 100644
--- a/src/subtyping/infer.ts
+++ b/src/subtyping/infer.ts
@@ -8,8 +8,8 @@ import type { RNumber } from '../r-bridge/lang-4.x/ast/model/nodes/r-number';
 import type { RString } from '../r-bridge/lang-4.x/ast/model/nodes/r-string';
 import type { NormalizedAst, ParentInformation } from '../r-bridge/lang-4.x/ast/model/processing/decorate';
 import { mapNormalizedAstInfo } from '../r-bridge/lang-4.x/ast/model/processing/decorate';
-import type { RDataType, UnresolvedRDataType } from './types';
-import { UnresolvedRTypeVariable, RComplexType, RDoubleType, RIntegerType, RLogicalType, RStringType, resolveType, RNullType, UnresolvedRListType, RLanguageType, UnresolvedRFunctionType, RNoneType, UnresolvedRVectorType } from './types';
+import type { DataType, UnresolvedDataType } from './types';
+import { UnresolvedRTypeVariable, RComplexType, RDoubleType, RIntegerType, RLogicalType, RStringType, resolveType, RNullType, UnresolvedRListType, RLanguageType, UnresolvedRFunctionType, RNoneType, UnresolvedRAtomicVectorType, UnresolvedRVectorType } from './types';
 import type { RExpressionList } from '../r-bridge/lang-4.x/ast/model/nodes/r-expression-list';
 import { guard } from '../util/assert';
 import { OriginType } from '../dataflow/origin/dfg-get-origin';
@@ -45,7 +45,7 @@ type UnresolvedTypeInfo = {
 };
 
 export type DataTypeInfo = {
-	inferredType: RDataType;
+	inferredType: DataType;
 }
 
 function decorateTypeVariables<Info extends ParentInformation>(ast: NormalizedAst<Info>): NormalizedAst<Info & UnresolvedTypeInfo> {
@@ -82,7 +82,7 @@ class TypeInferringCfgGuidedVisitor<
 	}
 
 
-	protected constrainNodeTypeWithUpperBound(id: NodeId, upperBound: UnresolvedRDataType): void {
+	protected constrainNodeTypeWithUpperBound(id: NodeId, upperBound: UnresolvedDataType): void {
 		const node = this.getNormalizedAst(id);
 		guard(node !== undefined, 'Expected AST node to be defined');
 		node.info.typeVariable.constrainWithUpperBound(upperBound);
@@ -262,12 +262,14 @@ class TypeInferringCfgGuidedVisitor<
 	}
 
 	override onForLoopCall(data: { call: DataflowGraphVertexFunctionCall, variable: FunctionArgument, vector: FunctionArgument, body: FunctionArgument }) {
-		// guard(data.variable !== EmptyArgument && data.vector !== EmptyArgument, 'Expected variable and vector arguments to be defined');
-		// const variableNode = this.getNormalizedAst(data.variable.nodeId);
-		// const vectorNode = this.getNormalizedAst(data.vector.nodeId);
+		guard(data.variable !== EmptyArgument && data.vector !== EmptyArgument, 'Expected variable and vector arguments to be defined');
+		const variableNode = this.getNormalizedAst(data.variable.nodeId);
+		const vectorNode = this.getNormalizedAst(data.vector.nodeId);
+		guard(variableNode !== undefined && vectorNode !== undefined, 'Expected variable and vector nodes to be defined');
 		
-		// guard(variableNode !== undefined && vectorNode !== undefined, 'Expected variable and vector nodes to be defined');
-		// variableNode.info.typeVariable.constrainWithLowerBound(vectorNode.info.typeVariable);
+		const vectorType = new UnresolvedRVectorType();
+		vectorNode.info.typeVariable.constrainWithUpperBound(vectorType);
+		variableNode.info.typeVariable.constrainWithLowerBound(vectorType.elementType);
 
 		this.onLoopCall(data);
 	}
@@ -410,7 +412,8 @@ class TypeInferringCfgGuidedVisitor<
 			return;
 		}
 		
-		const vectorType = new UnresolvedRVectorType();
+		// TODO: Handle flattening behavior of `c` function
+		const vectorType = new UnresolvedRAtomicVectorType();
 		node.info.typeVariable.constrainFromBothSides(vectorType);
 		
 		for(const arg of args) {
diff --git a/src/subtyping/types.ts b/src/subtyping/types.ts
index 7b88d0dfe6d..cbdffe44a1d 100644
--- a/src/subtyping/types.ts
+++ b/src/subtyping/types.ts
@@ -1,8 +1,12 @@
 /**
  * This enum lists a tag for each of the possible R data types inferred by the
- * type inferencer. It is mainly used to identify subtypes of {@link RDataType}.
+ * type inferencer. It is mainly used to identify subtypes of {@link DataType}.
  */
 export enum RDataTypeTag {
+	/** {@link RAtomicVectorType} */
+	Vector = 'RVectorType',
+	/** {@link RAtomicVectorType} */
+	AtomicVector = 'RAtomicVectorType',
     /** {@link RLogicalType} */
     Logical = 'RLogicalType',
     /** {@link RIntegerType} */
@@ -15,14 +19,12 @@ export enum RDataTypeTag {
     String = 'RStringType',
     /** {@link RRawType} */
     Raw = 'RRawType',
-	/** {@link RVectorType} */
-	Vector = 'RVectorType',
+    /** {@link RListType} */
+    List = 'RListType',
     /** {@link RNullType} */
 	Null = 'RNullType',
     /** {@link RFunctionType} */
     Function = 'RFunctionType',
-    /** {@link RListType} */
-    List = 'RListType',
     /** {@link REnvironmentType} */
     Environment = 'REnvironmentType',
     /** {@link RLanguageType} */
@@ -37,6 +39,62 @@ export enum RDataTypeTag {
 	None = 'RNoneType',
 }
 
+export class UnresolvedRVectorType {
+	readonly tag = RDataTypeTag.Vector;
+	readonly elementType = new UnresolvedRTypeVariable();
+
+	constructor(elementType?: UnresolvedDataType) {
+		if(elementType !== undefined) {
+			this.elementType.constrainWithLowerBound(elementType);
+		}
+	}
+
+	constrainWithLowerBound(bound: UnresolvedRAtomicVectorType): void {
+		this.elementType.constrainWithLowerBound(bound.elementType);
+	}
+
+	constrainWithUpperBound(bound: UnresolvedRAtomicVectorType): void {
+		this.elementType.constrainWithUpperBound(bound.elementType);
+	}
+}
+
+export class RVectorType {
+	readonly tag = RDataTypeTag.Vector;
+	readonly elementType: DataType;
+
+	constructor(elementType: DataType) {
+		this.elementType = elementType;
+	}
+}
+
+export class UnresolvedRAtomicVectorType /*extends UnresolvedRVectorType*/ {
+	readonly tag = RDataTypeTag.AtomicVector;
+	readonly elementType = new UnresolvedRTypeVariable();
+
+	constructor(elementType?: UnresolvedDataType) {
+		if(elementType !== undefined) {
+			this.elementType.constrainWithLowerBound(elementType);
+		}
+	}
+
+	constrainWithLowerBound(bound: UnresolvedRAtomicVectorType): void {
+		this.elementType.constrainWithLowerBound(bound.elementType);
+	}
+
+	constrainWithUpperBound(bound: UnresolvedRAtomicVectorType): void {
+		this.elementType.constrainWithUpperBound(bound.elementType);
+	}
+}
+
+export class RAtomicVectorType {
+	readonly tag = RDataTypeTag.AtomicVector;
+	readonly elementType: DataType;
+
+	constructor(elementType: DataType) {
+		this.elementType = elementType;
+	}
+}
+
 export class RLogicalType {
 	readonly tag = RDataTypeTag.Logical;
 }
@@ -61,30 +119,30 @@ export class RRawType {
 	readonly tag = RDataTypeTag.Raw;
 }
 
-export class UnresolvedRVectorType {
-	readonly tag = RDataTypeTag.Vector;
+export class UnresolvedRListType {
+	readonly tag = RDataTypeTag.List;
 	readonly elementType = new UnresolvedRTypeVariable();
 
-	constructor(elementType?: UnresolvedRDataType) {
+	constructor(elementType?: UnresolvedDataType) {
 		if(elementType !== undefined) {
 			this.elementType.constrainWithLowerBound(elementType);
 		}
 	}
-
-	constrainWithLowerBound(bound: UnresolvedRVectorType): void {
+	
+	constrainWithLowerBound(bound: UnresolvedRListType): void {
 		this.elementType.constrainWithLowerBound(bound.elementType);
 	}
 
-	constrainWithUpperBound(bound: UnresolvedRVectorType): void {
+	constrainWithUpperBound(bound: UnresolvedRListType): void {
 		this.elementType.constrainWithUpperBound(bound.elementType);
 	}
 }
 
-export class RVectorType {
-	readonly tag = RDataTypeTag.Vector;
-	readonly elementType: RDataType;
+export class RListType {
+	readonly tag = RDataTypeTag.List;
+	readonly elementType: DataType;
 
-	constructor(elementType: RDataType) {
+	constructor(elementType: DataType) {
 		this.elementType = elementType;
 	}
 }
@@ -123,43 +181,15 @@ export class UnresolvedRFunctionType {
 
 export class RFunctionType {
 	readonly tag = RDataTypeTag.Function;
-	readonly parameterTypes: Map<number | string, RDataType>;
-	readonly returnType:     RDataType;
+	readonly parameterTypes: Map<number | string, DataType>;
+	readonly returnType:     DataType;
 
-	constructor(parameterTypes: Map<number | string, RDataType>, returnType: RDataType) {
+	constructor(parameterTypes: Map<number | string, DataType>, returnType: DataType) {
 		this.parameterTypes = parameterTypes;
 		this.returnType = returnType;
 	}
 }
 
-export class UnresolvedRListType {
-	readonly tag = RDataTypeTag.List;
-	readonly elementType = new UnresolvedRTypeVariable();
-
-	constructor(elementType?: UnresolvedRDataType) {
-		if(elementType !== undefined) {
-			this.elementType.constrainWithLowerBound(elementType);
-		}
-	}
-	
-	constrainWithLowerBound(bound: UnresolvedRListType): void {
-		this.elementType.constrainWithLowerBound(bound.elementType);
-	}
-
-	constrainWithUpperBound(bound: UnresolvedRListType): void {
-		this.elementType.constrainWithUpperBound(bound.elementType);
-	}
-}
-
-export class RListType {
-	readonly tag = RDataTypeTag.List;
-	readonly elementType: RDataType;
-
-	constructor(elementType: RDataType) {
-		this.elementType = elementType;
-	}
-}
-
 export class REnvironmentType {
 	readonly tag = RDataTypeTag.Environment;
 }
@@ -170,10 +200,10 @@ export class RLanguageType {
 
 export class UnresolvedRTypeVariable {
 	readonly tag = RDataTypeTag.Variable;
-	readonly lowerBounds: Set<UnresolvedRDataType> = new Set();
-	readonly upperBounds: Set<UnresolvedRDataType> = new Set();
+	readonly lowerBounds: Set<UnresolvedDataType> = new Set();
+	readonly upperBounds: Set<UnresolvedDataType> = new Set();
 
-	constrainWithLowerBound(bound: UnresolvedRDataType): void {
+	constrainWithLowerBound(bound: UnresolvedDataType): void {
 		this.lowerBounds.add(bound);
 		
 		for(const upperBound of this.upperBounds) {
@@ -185,13 +215,13 @@ export class UnresolvedRTypeVariable {
 				upperBound.constrainWithLowerBound(bound);
 			} else if(upperBound instanceof UnresolvedRListType && bound instanceof UnresolvedRListType && upperBound !== bound) {
 				upperBound.constrainWithLowerBound(bound);
-			} else if(upperBound instanceof UnresolvedRVectorType && bound instanceof UnresolvedRVectorType && upperBound !== bound) {
+			} else if(upperBound instanceof UnresolvedRAtomicVectorType && bound instanceof UnresolvedRAtomicVectorType && upperBound !== bound) {
 				upperBound.constrainWithLowerBound(bound);
 			}
 		}
 	}
 
-	constrainWithUpperBound(bound: UnresolvedRDataType): void {
+	constrainWithUpperBound(bound: UnresolvedDataType): void {
 		this.upperBounds.add(bound);
 
 		for(const lowerBound of this.lowerBounds) {
@@ -203,13 +233,13 @@ export class UnresolvedRTypeVariable {
 				lowerBound.constrainWithUpperBound(bound);
 			} else if(lowerBound instanceof UnresolvedRListType && bound instanceof UnresolvedRListType && lowerBound !== bound) {
 				lowerBound.constrainWithUpperBound(bound);
-			} else if(lowerBound instanceof UnresolvedRVectorType && bound instanceof UnresolvedRVectorType && lowerBound !== bound) {
+			} else if(lowerBound instanceof UnresolvedRAtomicVectorType && bound instanceof UnresolvedRAtomicVectorType && lowerBound !== bound) {
 				lowerBound.constrainWithUpperBound(bound);
 			}
 		}
 	}
 
-	constrainFromBothSides(other: UnresolvedRDataType): void {
+	constrainFromBothSides(other: UnresolvedDataType): void {
 		this.constrainWithLowerBound(other);
 		this.constrainWithUpperBound(other);
 	}
@@ -217,10 +247,10 @@ export class UnresolvedRTypeVariable {
 
 export class RTypeVariable {
 	readonly tag = RDataTypeTag.Variable;
-	readonly lowerBound: RDataType;
-	readonly upperBound: RDataType;
+	readonly lowerBound: DataType;
+	readonly upperBound: DataType;
 	
-	constructor(lowerBound: RDataType, upperBound: RDataType) {
+	constructor(lowerBound: DataType, upperBound: DataType) {
 		this.lowerBound = lowerBound;
 		this.upperBound = upperBound;
 	}
@@ -228,9 +258,9 @@ export class RTypeVariable {
 
 export class RErrorType {
 	readonly tag = RDataTypeTag.Error;
-	conflictingBounds: [RDataType, RDataType];
+	conflictingBounds: [DataType, DataType];
 
-	constructor(...conflictingBounds: [RDataType, RDataType]) {
+	constructor(...conflictingBounds: [DataType, DataType]) {
 		this.conflictingBounds = conflictingBounds;
 	}
 }
@@ -244,14 +274,14 @@ export class RNoneType {
 }
 
 
-export function resolveType(type: UnresolvedRDataType): RDataType {
+export function resolveType(type: UnresolvedDataType): DataType {
 	if(type instanceof UnresolvedRTypeVariable) {
-		let lowerBound: RDataType = new RNoneType();
+		let lowerBound: DataType = new RNoneType();
 		for(const bound of type.lowerBounds) {
 			const resolvedBound = resolveType(bound);
 			lowerBound = union(lowerBound, resolvedBound);
 		}
-		let upperBound: RDataType = new RAnyType();
+		let upperBound: DataType = new RAnyType();
 		for(const bound of type.upperBounds) {
 			const resolvedBound = resolveType(bound);
 			upperBound = intersection(upperBound, resolvedBound);
@@ -271,18 +301,21 @@ export function resolveType(type: UnresolvedRDataType): RDataType {
 		const resolvedParameterTypes = new Map(type.parameterTypes.entries().toArray().map(([key, type]) => [key, resolveType(type)]));
 		const resolvedReturnType = resolveType(type.returnType);
 		return new RFunctionType(resolvedParameterTypes, resolvedReturnType);
-	} else if(type instanceof UnresolvedRListType) {
-		const resolvedElementType = resolveType(type.elementType);
-		return new RListType(resolvedElementType);
 	} else if(type instanceof UnresolvedRVectorType) {
 		const resolvedElementType = resolveType(type.elementType);
 		return new RVectorType(resolvedElementType);
+	} else if(type instanceof UnresolvedRAtomicVectorType) {
+		const resolvedElementType = resolveType(type.elementType);
+		return new RAtomicVectorType(resolvedElementType);
+	} else if(type instanceof UnresolvedRListType) {
+		const resolvedElementType = resolveType(type.elementType);
+		return new RListType(resolvedElementType);
 	} else {
 		return type;
 	}
 }
 
-function subsumes(subtype: RDataType, supertype: RDataType): boolean {
+function subsumes(subtype: DataType, supertype: DataType): boolean {
 	if(subtype === supertype) {
 		return true;
 	} else if(subtype instanceof RErrorType || supertype instanceof RErrorType) {
@@ -293,17 +326,13 @@ function subsumes(subtype: RDataType, supertype: RDataType): boolean {
 		return subsumes(subtype.lowerBound, supertype) && subsumes(subtype.upperBound, supertype);
 	} else if(supertype instanceof RTypeVariable) {
 		return subsumes(supertype.lowerBound, subtype) && subsumes(subtype, supertype.upperBound);
-	} else if(subtype instanceof RListType && supertype instanceof RListType) {
+	} else if(subtype instanceof RListType && (supertype instanceof RListType || supertype instanceof RVectorType)) {
 		return subsumes(subtype.elementType, supertype.elementType);
-	} else if(supertype instanceof RVectorType) {
-		if(subtype instanceof RVectorType) {
-			return subsumes(subtype.elementType, supertype.elementType);
-		} else if(subtype instanceof RLogicalType || subtype instanceof RIntegerType || subtype instanceof RDoubleType || subtype instanceof RComplexType || subtype instanceof RStringType || subtype instanceof RRawType) {
-			// A scalar subsumes a vector type if it subsumes the element type of the vector
-			return subsumes(subtype, supertype.elementType);
-		} else {
-			return false; // A non-vector type cannot subsume a vector type
-		}
+	} else if(subtype instanceof RAtomicVectorType && (supertype instanceof RAtomicVectorType || supertype instanceof RVectorType)) {
+		return subsumes(subtype.elementType, supertype.elementType);
+	} else if(isAtomicVectorElementType(subtype) && (supertype instanceof RAtomicVectorType || supertype instanceof RVectorType)) {
+		// A scalar subsumes a vector type if it subsumes the element type of the vector
+		return subsumes(subtype, supertype.elementType);
 	} else if(subtype instanceof RFunctionType && supertype instanceof RFunctionType) {
 		return subsumes(subtype.returnType, supertype.returnType) && subtype.parameterTypes.entries().every(([key, type]) => {
 			const supertypeParameter = supertype.parameterTypes.get(key);
@@ -326,16 +355,19 @@ function subsumesByTag(subtype: RDataTypeTag, supertype: RDataTypeTag): boolean
 		|| subtype === RDataTypeTag.Integer && supertype === RDataTypeTag.Complex
 		|| subtype === RDataTypeTag.Double && supertype === RDataTypeTag.Complex
 		|| subtype === RDataTypeTag.None || supertype === RDataTypeTag.Any
-		|| subtype === RDataTypeTag.Variable || supertype === RDataTypeTag.Variable;
+		|| subtype === RDataTypeTag.Variable || supertype === RDataTypeTag.Variable
+		|| [RDataTypeTag.Logical, RDataTypeTag.Integer, RDataTypeTag.Double, RDataTypeTag.Complex, RDataTypeTag.String, RDataTypeTag.Raw].includes(subtype) && (supertype === RDataTypeTag.AtomicVector || supertype === RDataTypeTag.Vector)
+		|| subtype === RDataTypeTag.AtomicVector && supertype === RDataTypeTag.Vector
+		|| subtype === RDataTypeTag.List && supertype === RDataTypeTag.Vector;
 }
 
-function union(type1: RDataType, type2: RDataType): RDataType {
+function union(type1: DataType, type2: DataType): DataType {
 	if(type1 instanceof RErrorType) {
 		return type1;
 	} else if(type2 instanceof RErrorType) {
 		return type2;
 	} else if(type1 instanceof RFunctionType && type2 instanceof RFunctionType) {
-		const parameterTypes = new Map<number | string, RDataType>();
+		const parameterTypes = new Map<number | string, DataType>();
 		const keys1 = new Set(type1.parameterTypes.keys());
 		const keys2 = new Set(type2.parameterTypes.keys());
 		for(const key of keys1.union(keys2)) {
@@ -347,6 +379,22 @@ function union(type1: RDataType, type2: RDataType): RDataType {
 		return new RFunctionType(parameterTypes, returnType);
 	} else if(type1 instanceof RListType && type2 instanceof RListType) {
 		return new RListType(union(type1.elementType, type2.elementType));
+	} else if(type1 instanceof RAtomicVectorType && type2 instanceof RAtomicVectorType) {
+		return new RAtomicVectorType(union(type1.elementType, type2.elementType));
+	} else if(isVectorType(type1) && isVectorType(type2)) {
+		return new RVectorType(union(type1.elementType, type2.elementType));
+	} else if(isAtomicVectorElementType(type1) && (type2.tag === RDataTypeTag.AtomicVector || type2.tag === RDataTypeTag.Vector)) {
+		if(type2 instanceof RAtomicVectorType) {
+			return new RAtomicVectorType(union(type1, type2.elementType));
+		} else {
+			return new RVectorType(union(type1, type2.elementType));
+		}
+	} else if(isAtomicVectorElementType(type2) && (type1.tag === RDataTypeTag.AtomicVector || type1.tag === RDataTypeTag.Vector)) {
+		if(type1 instanceof RAtomicVectorType) {
+			return new RAtomicVectorType(union(type2, type1.elementType));
+		} else {
+			return new RVectorType(union(type2, type1.elementType));
+		}
 	} else if(subsumesByTag(type1.tag, type2.tag)) {
 		return type2;
 	} else if(subsumesByTag(type2.tag, type1.tag)) {
@@ -355,13 +403,13 @@ function union(type1: RDataType, type2: RDataType): RDataType {
 	return new RAnyType();
 }
 
-function intersection(type1: RDataType, type2: RDataType): RDataType {
+function intersection(type1: DataType, type2: DataType): DataType {
 	if(type1 instanceof RErrorType) {
 		return type1;
 	} else if(type2 instanceof RErrorType) {
 		return type2;
 	} else if(type1 instanceof RFunctionType && type2 instanceof RFunctionType) {
-		const parameterTypes = new Map<number | string, RDataType>();
+		const parameterTypes = new Map<number | string, DataType>();
 		const keys1 = new Set(type1.parameterTypes.keys());
 		const keys2 = new Set(type2.parameterTypes.keys());
 		for(const key of keys1.intersection(keys2)) {
@@ -371,8 +419,16 @@ function intersection(type1: RDataType, type2: RDataType): RDataType {
 		}
 		const returnType = intersection(type1.returnType, type2.returnType);
 		return new RFunctionType(parameterTypes, returnType);
-	} else if(type1 instanceof RListType && type2 instanceof RListType) {
+	} else if(isVectorType(type1) && isVectorType(type2) && (type1 instanceof RListType || type2 instanceof RListType)) {
 		return new RListType(intersection(type1.elementType, type2.elementType));
+	} else if(isVectorType(type1) && isVectorType(type2) && (type1 instanceof RAtomicVectorType || type2 instanceof RAtomicVectorType)) {
+		return new RAtomicVectorType(intersection(type1.elementType, type2.elementType));
+	} else if(type1 instanceof RVectorType && type2 instanceof RVectorType) {
+		return new RVectorType(intersection(type1.elementType, type2.elementType));
+	} else if(isAtomicVectorElementType(type1) && (type2.tag === RDataTypeTag.AtomicVector || type2.tag === RDataTypeTag.Vector)) {
+		return intersection(type1, type2.elementType);
+	} else if(isAtomicVectorElementType(type2) && (type1.tag === RDataTypeTag.AtomicVector || type1.tag === RDataTypeTag.Vector)) {
+		return intersection(type2, type1.elementType);
 	} else if(subsumesByTag(type1.tag, type2.tag)) {
 		return type1;
 	} else if(subsumesByTag(type2.tag, type1.tag)) {
@@ -382,7 +438,7 @@ function intersection(type1: RDataType, type2: RDataType): RDataType {
 }
 
 
-export type RVectorElementType
+export type AtomicVectorElementType
 	= RLogicalType
 	| RIntegerType
 	| RDoubleType
@@ -390,7 +446,7 @@ export type RVectorElementType
 	| RStringType
 	| RRawType
 
-export function isVectorType(type: RDataType | UnresolvedRDataType): type is RVectorElementType {
+export function isAtomicVectorElementType(type: DataType | UnresolvedDataType): type is AtomicVectorElementType {
 	return type.tag === RDataTypeTag.Logical
 		|| type.tag === RDataTypeTag.Integer
 		|| type.tag === RDataTypeTag.Double
@@ -399,12 +455,14 @@ export function isVectorType(type: RDataType | UnresolvedRDataType): type is RVe
 		|| type.tag === RDataTypeTag.Raw;
 }
 	
-export type CompoundRDataType = RVectorType | RFunctionType | RListType;
+export type VectorType = RVectorType | RAtomicVectorType | RListType;
+
+export type UnresolvedVectorType = UnresolvedRVectorType | UnresolvedRAtomicVectorType | UnresolvedRListType;
 
-export function isCompoundType(type: UnresolvedRDataType): type is UnresolvedCompoundRDataType
-export function isCompoundType(type: RDataType): type is CompoundRDataType
-export function isCompoundType(type: RDataType | UnresolvedRDataType): type is CompoundRDataType | UnresolvedCompoundRDataType {
-	return type.tag === RDataTypeTag.Vector || type.tag === RDataTypeTag.Function || type.tag === RDataTypeTag.List;
+export function isVectorType(type: UnresolvedDataType): type is UnresolvedVectorType
+export function isVectorType(type: DataType): type is VectorType
+export function isVectorType(type: DataType | UnresolvedDataType): type is VectorType | UnresolvedVectorType {
+	return type.tag === RDataTypeTag.Vector || type.tag === RDataTypeTag.AtomicVector || type.tag === RDataTypeTag.List;
 }
 
 /**
@@ -413,25 +471,25 @@ export function isCompoundType(type: RDataType | UnresolvedRDataType): type is C
  * It should be used whenever you either not care what kind of
  * type you are dealing with or if you want to handle all possible types.
 */
-export type RDataType
-	= RVectorElementType
+export type DataType
+	= AtomicVectorElementType
+	| VectorType
 	| RNullType
 	| REnvironmentType
 	| RLanguageType
-	| CompoundRDataType
+	| RFunctionType
 	| RTypeVariable
 	| RErrorType
 	| RAnyType
 	| RNoneType;
-	
-export type UnresolvedCompoundRDataType = UnresolvedRVectorType | UnresolvedRFunctionType | UnresolvedRListType;
-	
-export type UnresolvedRDataType
-	= RVectorElementType
+
+export type UnresolvedDataType
+	= AtomicVectorElementType
+	| UnresolvedVectorType
 	| RNullType
 	| REnvironmentType
 	| RLanguageType
-	| UnresolvedCompoundRDataType
+	| UnresolvedRFunctionType
 	| UnresolvedRTypeVariable
 	// | RErrorType
 	| RAnyType
diff --git a/test/functionality/_helper/subtyping/assert-inferred-type.ts b/test/functionality/_helper/subtyping/assert-inferred-type.ts
index 2749b335a35..8212fb946d1 100644
--- a/test/functionality/_helper/subtyping/assert-inferred-type.ts
+++ b/test/functionality/_helper/subtyping/assert-inferred-type.ts
@@ -2,7 +2,7 @@ import { describe, expect, test } from 'vitest';
 import { TreeSitterExecutor } from '../../../../src/r-bridge/lang-4.x/tree-sitter/tree-sitter-executor';
 import { createDataflowPipeline } from '../../../../src/core/steps/pipeline/default-pipelines';
 import { requestFromInput } from '../../../../src/r-bridge/retriever';
-import { RAnyType, RNoneType, RTypeVariable, type RDataType } from '../../../../src/subtyping/types';
+import { RAnyType, RNoneType, RTypeVariable, type DataType } from '../../../../src/subtyping/types';
 import type { DataTypeInfo } from '../../../../src/subtyping/infer';
 import { inferDataTypes } from '../../../../src/subtyping/infer';
 import { type FlowrSearch } from '../../../../src/search/flowr-search-builder';
@@ -10,12 +10,12 @@ import { runSearch } from '../../../../src/search/flowr-search-executor';
 import type { ParentInformation } from '../../../../src/r-bridge/lang-4.x/ast/model/processing/decorate';
 import type { RNode } from '../../../../src/r-bridge/lang-4.x/ast/model/model';
 
-export function assertInferredType(input: string, expectedType: { expectedType: RDataType } | { lowerBound?: RDataType, upperBound?: RDataType }): void {
+export function assertInferredType(input: string, expectedType: { expectedType: DataType } | { lowerBound?: DataType, upperBound?: DataType }): void {
 	assertInferredTypes(input, expectedType);
 }
 export function assertInferredTypes(
 	input: string,
-	...expectations: ({ query?: FlowrSearch } & ({ expectedType: RDataType } | { lowerBound?: RDataType, upperBound?: RDataType }))[]
+	...expectations: ({ query?: FlowrSearch } & ({ expectedType: DataType } | { lowerBound?: DataType, upperBound?: DataType }))[]
 ): void {
 	describe(`Infer types for ${input}`, async() => {
 		const executor = new TreeSitterExecutor();
diff --git a/test/functionality/subtyping/builtin-functions.test.ts b/test/functionality/subtyping/builtin-functions.test.ts
index 6d31d4ce2a8..dbb84dea0f8 100644
--- a/test/functionality/subtyping/builtin-functions.test.ts
+++ b/test/functionality/subtyping/builtin-functions.test.ts
@@ -1,5 +1,5 @@
 import { describe } from 'vitest';
-import { RAnyType, RIntegerType, RLanguageType, RListType, RLogicalType, RNoneType, RNullType, RStringType, RTypeVariable, RVectorType } from '../../../src/subtyping/types';
+import { RAnyType, RIntegerType, RLanguageType, RListType, RLogicalType, RNoneType, RNullType, RStringType, RTypeVariable, RAtomicVectorType } from '../../../src/subtyping/types';
 import { assertInferredType, assertInferredTypes } from '../_helper/subtyping/assert-inferred-type';
 import { Q } from '../../../src/search/flowr-search-builder';
 
@@ -24,7 +24,7 @@ describe('Infer types for builtin functions', () => {
 
 	assertInferredTypes(
 		'c("Hello", "Flo", "!")',
-		{ query: Q.criterion('1@c').build(),       expectedType: new RVectorType(new RTypeVariable(new RStringType(), new RAnyType())) },
+		{ query: Q.criterion('1@c').build(),       expectedType: new RAtomicVectorType(new RTypeVariable(new RStringType(), new RAnyType())) },
 		{ query: Q.criterion('1@"Hello"').build(), expectedType: new RStringType() },
 	);
 });
\ No newline at end of file

From 8b812583e7727649f4f705918695be359ad21e8f Mon Sep 17 00:00:00 2001
From: Lukas Rohde <lukas.rohde@silupe.de>
Date: Thu, 10 Jul 2025 16:31:42 +0200
Subject: [PATCH 087/153] feat(typing): fix errors and add subsetting support
 for vector types

---
 src/subtyping/infer.ts                        | 58 +++++++++---------
 src/subtyping/types.ts                        | 42 +++++++++----
 .../subtyping/subsetting.test.ts              | 61 +++++++++++++++++++
 3 files changed, 120 insertions(+), 41 deletions(-)
 create mode 100644 test/functionality/subtyping/subsetting.test.ts

diff --git a/src/subtyping/infer.ts b/src/subtyping/infer.ts
index 1737dc7415d..4fb325da7af 100644
--- a/src/subtyping/infer.ts
+++ b/src/subtyping/infer.ts
@@ -487,35 +487,33 @@ class TypeInferringCfgGuidedVisitor<
 		}
 	}
 
-	// override onAccessCall(data: { call: DataflowGraphVertexFunctionCall; }): void {
-	// 	const node = this.getNormalizedAst(data.call.id);
-	// 	guard(node !== undefined, 'Expected AST node to be defined');
-
-	// 	const firstArg = data.call.args.at(0);
-	// 	guard(firstArg !== undefined && firstArg !== EmptyArgument, 'Expected first argument of access call to be defined');
-	// 	const firstArgNode = this.getNormalizedAst(firstArg.nodeId);
-	// 	guard(firstArgNode !== undefined, 'Expected first argument node to be defined');
-	// 	const firstArgType = firstArgNode.info.typeVariable;
-	// 	const firstArgBoundType = firstArgType.find();
+	override onAccessCall(data: { call: DataflowGraphVertexFunctionCall; }): void {
+		const node = this.getNormalizedAst(data.call.id);
+		guard(node !== undefined, 'Expected AST node to be defined');
+
+		const firstArg = data.call.args.at(0);
+		guard(firstArg !== undefined && firstArg !== EmptyArgument, 'Expected first argument of access call to be defined');
+		const firstArgNode = this.getNormalizedAst(firstArg.nodeId);
+		guard(firstArgNode !== undefined, 'Expected first argument node to be defined');
+
+		// TODO: Handle subsetting for other operand types, in particular for scalars and null
+		const vectorType = new UnresolvedRVectorType();
+		firstArgNode.info.typeVariable.constrainWithUpperBound(vectorType);
 		
-	// 	switch(data.call.name) {
-	// 		case '[':
-	// 			// If the access call is a `[` operation, we can assume that the it returns a subset
-	// 			// of the first argument's elements as another instance of the same container type
-	// 			node.info.typeVariable.constrainWithLowerBound(firstArgNode.info.typeVariable);
-	// 			break;
-	// 		case '[[':
-	// 			if(firstArgBoundType instanceof UnresolvedRListType) {
-	// 				node.info.typeVariable.constrainWithLowerBound(firstArgBoundType.elementType);
-	// 			} else if(isVectorType(firstArgBoundType) || firstArgBoundType instanceof RNullType) {
-	// 				node.info.typeVariable.constrainWithLowerBound(firstArgType);
-	// 			}
-	// 			break;
-	// 		case '$':
-	// 			if(firstArgBoundType instanceof UnresolvedRListType) {
-	// 				node.info.typeVariable.constrainWithLowerBound(firstArgBoundType.elementType);
-	// 			}
-	// 			break;
-	// 	}
-	// }
+		switch(data.call.name) {
+			case '[':
+				// If the access call is a `[` operation, we can assume that the it returns a subset
+				// of the first argument's elements as another instance of the same container type
+				node.info.typeVariable.constrainWithLowerBound(firstArgNode.info.typeVariable);
+				break;
+			case '[[':
+				node.info.typeVariable.constrainWithLowerBound(vectorType.elementType);
+				break;
+			case '$': {
+				firstArgNode.info.typeVariable.constrainWithUpperBound(new UnresolvedRListType(vectorType.elementType));
+				node.info.typeVariable.constrainWithLowerBound(vectorType.elementType);
+				break;
+			}
+		}
+	}
 }
\ No newline at end of file
diff --git a/src/subtyping/types.ts b/src/subtyping/types.ts
index cbdffe44a1d..39b1eb61d80 100644
--- a/src/subtyping/types.ts
+++ b/src/subtyping/types.ts
@@ -49,11 +49,15 @@ export class UnresolvedRVectorType {
 		}
 	}
 
-	constrainWithLowerBound(bound: UnresolvedRAtomicVectorType): void {
-		this.elementType.constrainWithLowerBound(bound.elementType);
+	constrainWithLowerBound(bound: UnresolvedVectorType | AtomicVectorElementType): void {
+		if(isVectorType(bound)) {
+			this.elementType.constrainWithLowerBound(bound.elementType);
+		} else {
+			this.elementType.constrainWithLowerBound(bound);
+		}
 	}
 
-	constrainWithUpperBound(bound: UnresolvedRAtomicVectorType): void {
+	constrainWithUpperBound(bound: UnresolvedRVectorType): void {
 		this.elementType.constrainWithUpperBound(bound.elementType);
 	}
 }
@@ -77,11 +81,15 @@ export class UnresolvedRAtomicVectorType /*extends UnresolvedRVectorType*/ {
 		}
 	}
 
-	constrainWithLowerBound(bound: UnresolvedRAtomicVectorType): void {
-		this.elementType.constrainWithLowerBound(bound.elementType);
+	constrainWithLowerBound(bound: UnresolvedRAtomicVectorType | AtomicVectorElementType): void {
+		if(bound instanceof UnresolvedRAtomicVectorType) {
+			this.elementType.constrainWithLowerBound(bound.elementType);
+		} else {
+			this.elementType.constrainWithLowerBound(bound);
+		}
 	}
 
-	constrainWithUpperBound(bound: UnresolvedRAtomicVectorType): void {
+	constrainWithUpperBound(bound: UnresolvedRAtomicVectorType | UnresolvedRVectorType): void {
 		this.elementType.constrainWithUpperBound(bound.elementType);
 	}
 }
@@ -133,7 +141,7 @@ export class UnresolvedRListType {
 		this.elementType.constrainWithLowerBound(bound.elementType);
 	}
 
-	constrainWithUpperBound(bound: UnresolvedRListType): void {
+	constrainWithUpperBound(bound: UnresolvedRListType | UnresolvedRVectorType): void {
 		this.elementType.constrainWithUpperBound(bound.elementType);
 	}
 }
@@ -213,9 +221,11 @@ export class UnresolvedRTypeVariable {
 				bound.constrainWithUpperBound(upperBound);
 			} else if(upperBound instanceof UnresolvedRFunctionType && bound instanceof UnresolvedRFunctionType && upperBound !== bound) {
 				upperBound.constrainWithLowerBound(bound);
-			} else if(upperBound instanceof UnresolvedRListType && bound instanceof UnresolvedRListType && upperBound !== bound) {
+			} else if(upperBound instanceof UnresolvedRVectorType && (isVectorType(bound) || isAtomicVectorElementType(bound)) && upperBound !== bound) {
 				upperBound.constrainWithLowerBound(bound);
-			} else if(upperBound instanceof UnresolvedRAtomicVectorType && bound instanceof UnresolvedRAtomicVectorType && upperBound !== bound) {
+			} else if(upperBound instanceof UnresolvedRAtomicVectorType && (bound instanceof UnresolvedRAtomicVectorType || isAtomicVectorElementType(bound)) && upperBound !== bound) {
+				upperBound.constrainWithLowerBound(bound);
+			} else if(upperBound instanceof UnresolvedRListType && bound instanceof UnresolvedRListType && upperBound !== bound) {
 				upperBound.constrainWithLowerBound(bound);
 			}
 		}
@@ -231,9 +241,11 @@ export class UnresolvedRTypeVariable {
 				bound.constrainWithLowerBound(lowerBound);
 			} else if(lowerBound instanceof UnresolvedRFunctionType && bound instanceof UnresolvedRFunctionType && lowerBound !== bound) {
 				lowerBound.constrainWithUpperBound(bound);
-			} else if(lowerBound instanceof UnresolvedRListType && bound instanceof UnresolvedRListType && lowerBound !== bound) {
+			} else if(lowerBound instanceof UnresolvedRVectorType && bound instanceof UnresolvedRVectorType && lowerBound !== bound) {
+				lowerBound.constrainWithUpperBound(bound);
+			} else if(lowerBound instanceof UnresolvedRAtomicVectorType && (bound instanceof UnresolvedRAtomicVectorType || bound instanceof UnresolvedRVectorType) && lowerBound !== bound) {
 				lowerBound.constrainWithUpperBound(bound);
-			} else if(lowerBound instanceof UnresolvedRAtomicVectorType && bound instanceof UnresolvedRAtomicVectorType && lowerBound !== bound) {
+			} else if(lowerBound instanceof UnresolvedRListType && (bound instanceof UnresolvedRListType || bound instanceof UnresolvedRVectorType) && lowerBound !== bound) {
 				lowerBound.constrainWithUpperBound(bound);
 			}
 		}
@@ -366,6 +378,10 @@ function union(type1: DataType, type2: DataType): DataType {
 		return type1;
 	} else if(type2 instanceof RErrorType) {
 		return type2;
+	} else if(type1 instanceof RTypeVariable) {
+		return union(type1.lowerBound, type2);
+	} else if(type2 instanceof RTypeVariable) {
+		return union(type1, type2.lowerBound);
 	} else if(type1 instanceof RFunctionType && type2 instanceof RFunctionType) {
 		const parameterTypes = new Map<number | string, DataType>();
 		const keys1 = new Set(type1.parameterTypes.keys());
@@ -408,6 +424,10 @@ function intersection(type1: DataType, type2: DataType): DataType {
 		return type1;
 	} else if(type2 instanceof RErrorType) {
 		return type2;
+	} else if(type1 instanceof RTypeVariable) {
+		return intersection(type1.upperBound, type2);
+	} else if(type2 instanceof RTypeVariable) {
+		return intersection(type1, type2.upperBound);
 	} else if(type1 instanceof RFunctionType && type2 instanceof RFunctionType) {
 		const parameterTypes = new Map<number | string, DataType>();
 		const keys1 = new Set(type1.parameterTypes.keys());
diff --git a/test/functionality/subtyping/subsetting.test.ts b/test/functionality/subtyping/subsetting.test.ts
new file mode 100644
index 00000000000..b67345ddcd8
--- /dev/null
+++ b/test/functionality/subtyping/subsetting.test.ts
@@ -0,0 +1,61 @@
+import { describe } from 'vitest';
+import { RAnyType, RAtomicVectorType, RIntegerType, RListType, RTypeVariable, RVectorType } from '../../../src/subtyping/types';
+import { assertInferredTypes } from '../_helper/subtyping/assert-inferred-type';
+import { Q } from '../../../src/search/flowr-search-builder';
+import { RType } from '../../../src/r-bridge/lang-4.x/ast/model/type';
+
+describe.only('Infer types for subsetting expressions', () => {
+	assertInferredTypes(
+		'v <- c(1, 2, 3); v[2]',
+		{ query: Q.var('v').last().build(),                    lowerBound: new RAtomicVectorType(new RTypeVariable(new RIntegerType(), new RAnyType())), upperBound: new RVectorType(new RTypeVariable(new RIntegerType(), new RAnyType())) },
+		{ query: Q.all().filter(RType.Access).first().build(), lowerBound: new RAtomicVectorType(new RTypeVariable(new RIntegerType(), new RAnyType())) },
+	);
+	
+	assertInferredTypes(
+		'l <- list(1, 2, 3); l[2]',
+		{ query: Q.var('l').last().build(),                    lowerBound: new RListType(new RTypeVariable(new RIntegerType(), new RAnyType())), upperBound: new RVectorType(new RTypeVariable(new RIntegerType(), new RAnyType())) },
+		{ query: Q.all().filter(RType.Access).first().build(), lowerBound: new RListType(new RTypeVariable(new RIntegerType(), new RAnyType())) },
+	);
+	
+	assertInferredTypes(
+		'v <- c(1, 2, 3); v[]',
+		{ query: Q.var('v').last().build(),                    lowerBound: new RAtomicVectorType(new RTypeVariable(new RIntegerType(), new RAnyType())), upperBound: new RVectorType(new RTypeVariable(new RIntegerType(), new RAnyType())) },
+		{ query: Q.all().filter(RType.Access).first().build(), lowerBound: new RAtomicVectorType(new RTypeVariable(new RIntegerType(), new RAnyType())) },
+	);
+	
+	assertInferredTypes(
+		'l <- list(1, 2, 3); l[]',
+		{ query: Q.var('l').last().build(),                    lowerBound: new RListType(new RTypeVariable(new RIntegerType(), new RAnyType())), upperBound: new RVectorType(new RTypeVariable(new RIntegerType(), new RAnyType())) },
+		{ query: Q.all().filter(RType.Access).first().build(), lowerBound: new RListType(new RTypeVariable(new RIntegerType(), new RAnyType())) },
+	);
+	
+	assertInferredTypes(
+		'v <- c(1, 2, 3); v[[2]]',
+		{ query: Q.var('v').last().build(),                    lowerBound: new RAtomicVectorType(new RTypeVariable(new RIntegerType(), new RAnyType())), upperBound: new RVectorType(new RTypeVariable(new RIntegerType(), new RAnyType())) },
+		{ query: Q.all().filter(RType.Access).first().build(), lowerBound: new RIntegerType() },
+	);
+	
+	assertInferredTypes(
+		'l <- list(1, 2, 3); l[[2]]',
+		{ query: Q.var('l').last().build(),                    lowerBound: new RListType(new RTypeVariable(new RIntegerType(), new RAnyType())), upperBound: new RVectorType(new RTypeVariable(new RIntegerType(), new RAnyType())) },
+		{ query: Q.all().filter(RType.Access).first().build(), lowerBound: new RIntegerType() },
+	);
+	
+	assertInferredTypes(
+		'l <- list(1, x = 2, 3); l$x',
+		{ query: Q.var('l').last().build(),                    expectedType: new RListType(new RTypeVariable(new RIntegerType(), new RAnyType())) },
+		{ query: Q.all().filter(RType.Access).first().build(), lowerBound: new RIntegerType() },
+	);
+	
+	assertInferredTypes(
+		'l <- list(1, 2, 3); l$a',
+		{ query: Q.var('l').last().build(),                    expectedType: new RListType(new RTypeVariable(new RIntegerType(), new RAnyType())) },
+		{ query: Q.all().filter(RType.Access).first().build(), lowerBound: new RIntegerType() },
+	);
+	
+	assertInferredTypes(
+		'l <- list(TRUE, a = 42, NULL); l$a',
+		{ query: Q.var('l').last().build(),                    expectedType: new RListType(new RAnyType()) },
+		{ query: Q.all().filter(RType.Access).first().build(), expectedType: new RAnyType() },
+	);
+});
\ No newline at end of file

From 626266c4f4799a34f818d4de6949d84b45f8269f Mon Sep 17 00:00:00 2001
From: Lukas Rohde <lukas.rohde@silupe.de>
Date: Sat, 12 Jul 2025 12:40:19 +0200
Subject: [PATCH 088/153] feat(typing): implement support for type unions and
 intersections

---
 src/subtyping/infer.ts                        |  20 +-
 src/subtyping/types.ts                        | 531 +++++++++++-------
 .../_helper/subtyping/assert-inferred-type.ts |   4 +-
 .../subtyping/builtin-functions.test.ts       |   8 +-
 .../subtyping/conditionals.test.ts            |   4 +-
 .../functionality/subtyping/constants.test.ts |  24 +-
 test/functionality/subtyping/loops.test.ts    |   6 +-
 .../subtyping/subsetting.test.ts              |  30 +-
 .../subtyping/unsupported-expressions.test.ts |   6 +-
 9 files changed, 385 insertions(+), 248 deletions(-)

diff --git a/src/subtyping/infer.ts b/src/subtyping/infer.ts
index 4fb325da7af..fcfb179a9b4 100644
--- a/src/subtyping/infer.ts
+++ b/src/subtyping/infer.ts
@@ -9,7 +9,7 @@ import type { RString } from '../r-bridge/lang-4.x/ast/model/nodes/r-string';
 import type { NormalizedAst, ParentInformation } from '../r-bridge/lang-4.x/ast/model/processing/decorate';
 import { mapNormalizedAstInfo } from '../r-bridge/lang-4.x/ast/model/processing/decorate';
 import type { DataType, UnresolvedDataType } from './types';
-import { UnresolvedRTypeVariable, RComplexType, RDoubleType, RIntegerType, RLogicalType, RStringType, resolveType, RNullType, UnresolvedRListType, RLanguageType, UnresolvedRFunctionType, RNoneType, UnresolvedRAtomicVectorType, UnresolvedRVectorType } from './types';
+import { UnresolvedRTypeVariable, RComplexType, RDoubleType, RIntegerType, RLogicalType, RStringType, resolveType, RNullType, UnresolvedRListType, RLanguageType, UnresolvedRFunctionType, UnresolvedRAtomicVectorType, UnresolvedRTypeUnion } from './types';
 import type { RExpressionList } from '../r-bridge/lang-4.x/ast/model/nodes/r-expression-list';
 import { guard } from '../util/assert';
 import { OriginType } from '../dataflow/origin/dfg-get-origin';
@@ -267,9 +267,10 @@ class TypeInferringCfgGuidedVisitor<
 		const vectorNode = this.getNormalizedAst(data.vector.nodeId);
 		guard(variableNode !== undefined && vectorNode !== undefined, 'Expected variable and vector nodes to be defined');
 		
-		const vectorType = new UnresolvedRVectorType();
+		const elementType = new UnresolvedRTypeVariable();
+		const vectorType = new UnresolvedRTypeUnion(new UnresolvedRAtomicVectorType(elementType), new UnresolvedRListType(elementType));
 		vectorNode.info.typeVariable.constrainWithUpperBound(vectorType);
-		variableNode.info.typeVariable.constrainWithLowerBound(vectorType.elementType);
+		variableNode.info.typeVariable.constrainWithLowerBound(elementType);
 
 		this.onLoopCall(data);
 	}
@@ -297,7 +298,7 @@ class TypeInferringCfgGuidedVisitor<
 		const isInfinite = (cfgVertex.end ?? []).reduce((prevCount, id) => prevCount + (this.config.controlFlow.graph.outgoingEdges(id)?.size ?? 0), 0) === 0;
 
 		if(isInfinite) {
-			node.info.typeVariable.constrainFromBothSides(new RNoneType());
+			node.info.typeVariable.constrainFromBothSides(new UnresolvedRTypeUnion());
 		} else {
 			node.info.typeVariable.constrainFromBothSides(new RNullType());
 		}
@@ -360,7 +361,7 @@ class TypeInferringCfgGuidedVisitor<
 		}
 		if(!isThenBranchReachable && !isElseBranchReachable) {
 			// If neither branch is reachable, we can assume that the type is none
-			node.info.typeVariable.constrainFromBothSides(new RNoneType());
+			node.info.typeVariable.constrainFromBothSides(new UnresolvedRTypeUnion());
 		}	
 	}
 	
@@ -497,7 +498,8 @@ class TypeInferringCfgGuidedVisitor<
 		guard(firstArgNode !== undefined, 'Expected first argument node to be defined');
 
 		// TODO: Handle subsetting for other operand types, in particular for scalars and null
-		const vectorType = new UnresolvedRVectorType();
+		const elementType = new UnresolvedRTypeVariable();
+		const vectorType = new UnresolvedRTypeUnion(new UnresolvedRAtomicVectorType(elementType), new UnresolvedRListType(elementType));
 		firstArgNode.info.typeVariable.constrainWithUpperBound(vectorType);
 		
 		switch(data.call.name) {
@@ -507,11 +509,11 @@ class TypeInferringCfgGuidedVisitor<
 				node.info.typeVariable.constrainWithLowerBound(firstArgNode.info.typeVariable);
 				break;
 			case '[[':
-				node.info.typeVariable.constrainWithLowerBound(vectorType.elementType);
+				node.info.typeVariable.constrainWithLowerBound(elementType);
 				break;
 			case '$': {
-				firstArgNode.info.typeVariable.constrainWithUpperBound(new UnresolvedRListType(vectorType.elementType));
-				node.info.typeVariable.constrainWithLowerBound(vectorType.elementType);
+				firstArgNode.info.typeVariable.constrainWithUpperBound(new UnresolvedRListType(elementType));
+				node.info.typeVariable.constrainWithLowerBound(elementType);
 				break;
 			}
 		}
diff --git a/src/subtyping/types.ts b/src/subtyping/types.ts
index 39b1eb61d80..3dfea6105c9 100644
--- a/src/subtyping/types.ts
+++ b/src/subtyping/types.ts
@@ -1,10 +1,10 @@
+import { guard } from '../util/assert';
+
 /**
  * This enum lists a tag for each of the possible R data types inferred by the
  * type inferencer. It is mainly used to identify subtypes of {@link DataType}.
  */
 export enum RDataTypeTag {
-	/** {@link RAtomicVectorType} */
-	Vector = 'RVectorType',
 	/** {@link RAtomicVectorType} */
 	AtomicVector = 'RAtomicVectorType',
     /** {@link RLogicalType} */
@@ -29,69 +29,25 @@ export enum RDataTypeTag {
     Environment = 'REnvironmentType',
     /** {@link RLanguageType} */
     Language = 'RLanguageType',
+	/** {@link UnresolvedRTypeUnion} */
+	Union = 'RTypeUnion',
+	/** {@link UnresolvedRTypeIntersection} */
+	Intersection = 'RTypeIntersection',
 	/** {@link UnresolvedRTypeVariable} */
     Variable = 'RTypeVariable',
 	/** {@link RErrorType} */
 	Error = 'RErrorType',
-	/** {@link RAnyType} */
-	Any = 'RAnyType',
-	/** {@link RNoneType} */
-	None = 'RNoneType',
-}
-
-export class UnresolvedRVectorType {
-	readonly tag = RDataTypeTag.Vector;
-	readonly elementType = new UnresolvedRTypeVariable();
-
-	constructor(elementType?: UnresolvedDataType) {
-		if(elementType !== undefined) {
-			this.elementType.constrainWithLowerBound(elementType);
-		}
-	}
-
-	constrainWithLowerBound(bound: UnresolvedVectorType | AtomicVectorElementType): void {
-		if(isVectorType(bound)) {
-			this.elementType.constrainWithLowerBound(bound.elementType);
-		} else {
-			this.elementType.constrainWithLowerBound(bound);
-		}
-	}
-
-	constrainWithUpperBound(bound: UnresolvedRVectorType): void {
-		this.elementType.constrainWithUpperBound(bound.elementType);
-	}
 }
 
-export class RVectorType {
-	readonly tag = RDataTypeTag.Vector;
-	readonly elementType: DataType;
-
-	constructor(elementType: DataType) {
-		this.elementType = elementType;
-	}
-}
-
-export class UnresolvedRAtomicVectorType /*extends UnresolvedRVectorType*/ {
+export class UnresolvedRAtomicVectorType {
 	readonly tag = RDataTypeTag.AtomicVector;
 	readonly elementType = new UnresolvedRTypeVariable();
 
-	constructor(elementType?: UnresolvedDataType) {
+	constructor(elementType?: UnresolvedRTypeVariable) {
 		if(elementType !== undefined) {
-			this.elementType.constrainWithLowerBound(elementType);
+			this.elementType = elementType;
 		}
 	}
-
-	constrainWithLowerBound(bound: UnresolvedRAtomicVectorType | AtomicVectorElementType): void {
-		if(bound instanceof UnresolvedRAtomicVectorType) {
-			this.elementType.constrainWithLowerBound(bound.elementType);
-		} else {
-			this.elementType.constrainWithLowerBound(bound);
-		}
-	}
-
-	constrainWithUpperBound(bound: UnresolvedRAtomicVectorType | UnresolvedRVectorType): void {
-		this.elementType.constrainWithUpperBound(bound.elementType);
-	}
 }
 
 export class RAtomicVectorType {
@@ -131,19 +87,11 @@ export class UnresolvedRListType {
 	readonly tag = RDataTypeTag.List;
 	readonly elementType = new UnresolvedRTypeVariable();
 
-	constructor(elementType?: UnresolvedDataType) {
+	constructor(elementType?: UnresolvedRTypeVariable) {
 		if(elementType !== undefined) {
-			this.elementType.constrainWithLowerBound(elementType);
+			this.elementType = elementType;
 		}
 	}
-	
-	constrainWithLowerBound(bound: UnresolvedRListType): void {
-		this.elementType.constrainWithLowerBound(bound.elementType);
-	}
-
-	constrainWithUpperBound(bound: UnresolvedRListType | UnresolvedRVectorType): void {
-		this.elementType.constrainWithUpperBound(bound.elementType);
-	}
 }
 
 export class RListType {
@@ -171,20 +119,6 @@ export class UnresolvedRFunctionType {
 		// eslint-disable-next-line @typescript-eslint/no-non-null-assertion
 		return this.parameterTypes.get(indexOrName)!;
 	}
-
-	constrainWithLowerBound(bound: UnresolvedRFunctionType): void {
-		for(const [key, type] of bound.parameterTypes) {
-			this.getParameterType(key).constrainWithUpperBound(type);
-		}
-		this.returnType.constrainWithLowerBound(bound.returnType);
-	}
-
-	constrainWithUpperBound(bound: UnresolvedRFunctionType): void {
-		for(const [key, type] of bound.parameterTypes) {
-			this.getParameterType(key).constrainWithLowerBound(type);
-		}
-		this.returnType.constrainWithUpperBound(bound.returnType);
-	}
 }
 
 export class RFunctionType {
@@ -206,49 +140,67 @@ export class RLanguageType {
 	readonly tag = RDataTypeTag.Language;
 }
 
+export class UnresolvedRTypeUnion {
+	readonly tag = RDataTypeTag.Union;
+	readonly types: Set<UnresolvedDataType> = new Set();
+
+	constructor(...types: UnresolvedDataType[]) {
+		for(const type of types) {
+			guard(type !== this, 'Union cannot contain itself');
+			this.types.add(type);
+		}
+	}
+}
+
+export class RTypeUnion {
+	readonly tag = RDataTypeTag.Union;
+	readonly types: Set<DataType> = new Set();
+
+	constructor(...types: DataType[]) {
+		for(const type of types) {
+			guard(type !== this, 'Union cannot contain itself');
+			this.types.add(type);
+		}
+	}
+}
+
+export class UnresolvedRTypeIntersection {
+	readonly tag = RDataTypeTag.Intersection;
+	readonly types: Set<UnresolvedDataType> = new Set();
+
+	constructor(...types: UnresolvedDataType[]) {
+		for(const type of types) {
+			guard(type !== this, 'Intersection cannot contain itself');
+			this.types.add(type);
+		}
+	}
+}
+
+export class RTypeIntersection {
+	readonly tag = RDataTypeTag.Intersection;
+	readonly types: Set<DataType> = new Set();
+
+	constructor(...types: DataType[]) {
+		for(const type of types) {
+			guard(type !== this, 'Intersection cannot contain itself');
+			this.types.add(type);
+		}
+	}
+}
+
 export class UnresolvedRTypeVariable {
 	readonly tag = RDataTypeTag.Variable;
-	readonly lowerBounds: Set<UnresolvedDataType> = new Set();
-	readonly upperBounds: Set<UnresolvedDataType> = new Set();
+	readonly lowerBound = new UnresolvedRTypeUnion();
+	readonly upperBound = new UnresolvedRTypeIntersection();
 
 	constrainWithLowerBound(bound: UnresolvedDataType): void {
-		this.lowerBounds.add(bound);
-		
-		for(const upperBound of this.upperBounds) {
-			if(upperBound instanceof UnresolvedRTypeVariable && upperBound !== bound) {
-				upperBound.constrainWithLowerBound(bound);
-			} else if(bound instanceof UnresolvedRTypeVariable && bound !== upperBound) {
-				bound.constrainWithUpperBound(upperBound);
-			} else if(upperBound instanceof UnresolvedRFunctionType && bound instanceof UnresolvedRFunctionType && upperBound !== bound) {
-				upperBound.constrainWithLowerBound(bound);
-			} else if(upperBound instanceof UnresolvedRVectorType && (isVectorType(bound) || isAtomicVectorElementType(bound)) && upperBound !== bound) {
-				upperBound.constrainWithLowerBound(bound);
-			} else if(upperBound instanceof UnresolvedRAtomicVectorType && (bound instanceof UnresolvedRAtomicVectorType || isAtomicVectorElementType(bound)) && upperBound !== bound) {
-				upperBound.constrainWithLowerBound(bound);
-			} else if(upperBound instanceof UnresolvedRListType && bound instanceof UnresolvedRListType && upperBound !== bound) {
-				upperBound.constrainWithLowerBound(bound);
-			}
-		}
+		guard(bound !== this, 'Lower bound cannot be the type variable itself');
+		constrainWithLowerBound(this, bound);
 	}
 
 	constrainWithUpperBound(bound: UnresolvedDataType): void {
-		this.upperBounds.add(bound);
-
-		for(const lowerBound of this.lowerBounds) {
-			if(lowerBound instanceof UnresolvedRTypeVariable && lowerBound !== bound) {
-				lowerBound.constrainWithUpperBound(bound);
-			} else if(bound instanceof UnresolvedRTypeVariable && bound !== lowerBound) {
-				bound.constrainWithLowerBound(lowerBound);
-			} else if(lowerBound instanceof UnresolvedRFunctionType && bound instanceof UnresolvedRFunctionType && lowerBound !== bound) {
-				lowerBound.constrainWithUpperBound(bound);
-			} else if(lowerBound instanceof UnresolvedRVectorType && bound instanceof UnresolvedRVectorType && lowerBound !== bound) {
-				lowerBound.constrainWithUpperBound(bound);
-			} else if(lowerBound instanceof UnresolvedRAtomicVectorType && (bound instanceof UnresolvedRAtomicVectorType || bound instanceof UnresolvedRVectorType) && lowerBound !== bound) {
-				lowerBound.constrainWithUpperBound(bound);
-			} else if(lowerBound instanceof UnresolvedRListType && (bound instanceof UnresolvedRListType || bound instanceof UnresolvedRVectorType) && lowerBound !== bound) {
-				lowerBound.constrainWithUpperBound(bound);
-			}
-		}
+		guard(bound !== this, 'Upper bound cannot be the type variable itself');
+		constrainWithUpperBound(this, bound);
 	}
 
 	constrainFromBothSides(other: UnresolvedDataType): void {
@@ -263,7 +215,9 @@ export class RTypeVariable {
 	readonly upperBound: DataType;
 	
 	constructor(lowerBound: DataType, upperBound: DataType) {
+		guard(lowerBound !== this, 'Lower bound cannot be the type variable itself');
 		this.lowerBound = lowerBound;
+		guard(upperBound !== this, 'Upper bound cannot be the type variable itself');
 		this.upperBound = upperBound;
 	}
 }
@@ -277,45 +231,160 @@ export class RErrorType {
 	}
 }
 
-export class RAnyType {
-	readonly tag = RDataTypeTag.Any;
-}
 
-export class RNoneType {
-	readonly tag = RDataTypeTag.None;
+export function constrainWithLowerBound(type: UnresolvedDataType, bound: UnresolvedDataType): void {
+	// console.debug('constraining', type, 'with lower bound', bound);
+
+	if(type === bound) {
+		return; // No need to constrain if both types are the same
+	}
+
+	if(type instanceof UnresolvedRTypeVariable) {
+		type.lowerBound.types.add(bound);
+		for(const upperBound of type.upperBound.types) {
+			constrainWithLowerBound(upperBound, bound);
+		}
+	} else if(bound instanceof UnresolvedRTypeVariable) {
+		// constrainWithUpperBound(bound, type);
+		bound.upperBound.types.add(type);
+		for(const lowerBound of bound.lowerBound.types) {
+			constrainWithLowerBound(type, lowerBound);
+		}
+	} else if(type instanceof UnresolvedRTypeUnion) {
+		for(const subtype of type.types.values()) {
+			if(!subsumes(bound, subtype)) {
+				type.types.delete(subtype);
+			} else {
+				constrainWithLowerBound(subtype, bound);
+			}
+		}
+	} else if(bound instanceof UnresolvedRTypeUnion) {
+		// constrainWithUpperBound(bound, type);
+		for(const subtype of bound.types) {
+			constrainWithLowerBound(type, subtype);
+		}
+	} else if(type instanceof UnresolvedRTypeIntersection) {
+		for(const subtype of type.types) {
+			constrainWithLowerBound(subtype, bound);
+		}
+	} else if(bound instanceof UnresolvedRTypeIntersection) {
+		// constrainWithUpperBound(bound, type);
+		for(const subtype of bound.types.values()) {
+			if(!subsumes(subtype, type)) {
+				bound.types.delete(subtype);
+			} else {
+				constrainWithLowerBound(type, subtype);
+			}
+		}
+	} else if(type instanceof UnresolvedRFunctionType && bound instanceof UnresolvedRFunctionType) {
+		for(const [key, paramType] of bound.parameterTypes) {
+			constrainWithUpperBound(type.getParameterType(key), paramType);
+		}
+		constrainWithLowerBound(type.returnType, bound.returnType);
+	} else if(type instanceof UnresolvedRAtomicVectorType && bound instanceof UnresolvedRAtomicVectorType) {
+		constrainWithLowerBound(type.elementType, bound.elementType);
+	} else if(type instanceof UnresolvedRAtomicVectorType && isAtomicVectorElementType(bound)) {
+		constrainWithLowerBound(type.elementType, bound);
+	} else if(type instanceof UnresolvedRListType && bound instanceof UnresolvedRListType) {
+		constrainWithLowerBound(type.elementType, bound.elementType);
+	}
 }
 
+export function constrainWithUpperBound(type: UnresolvedDataType, bound: UnresolvedDataType): void {
+	// console.debug('constraining', type, 'with upper bound', bound);
+
+	if(type === bound) {
+		return; // No need to constrain if both types are the same
+	}
 
-export function resolveType(type: UnresolvedDataType): DataType {
 	if(type instanceof UnresolvedRTypeVariable) {
-		let lowerBound: DataType = new RNoneType();
-		for(const bound of type.lowerBounds) {
-			const resolvedBound = resolveType(bound);
-			lowerBound = union(lowerBound, resolvedBound);
+		type.upperBound.types.add(bound);
+		for(const lowerBound of type.lowerBound.types) {
+			constrainWithUpperBound(lowerBound, bound);
+		}
+	} else if(bound instanceof UnresolvedRTypeVariable) {
+		// constrainWithLowerBound(bound, type);
+		bound.lowerBound.types.add(type);
+		for(const upperBound of bound.upperBound.types) {
+			constrainWithUpperBound(type, upperBound);
 		}
-		let upperBound: DataType = new RAnyType();
-		for(const bound of type.upperBounds) {
-			const resolvedBound = resolveType(bound);
-			upperBound = intersection(upperBound, resolvedBound);
+	} else if(type instanceof UnresolvedRTypeUnion) {
+		for(const subtype of type.types) {
+			constrainWithUpperBound(subtype, bound);
 		}
+	} else if(bound instanceof UnresolvedRTypeUnion) {
+		// constrainWithLowerBound(bound, type);
+		for(const subtype of bound.types.values()) {
+			if(!subsumes(type, subtype)) {
+				bound.types.delete(subtype);
+			} else {
+				constrainWithUpperBound(type, subtype);
+			}
+		}
+	} else if(type instanceof UnresolvedRTypeIntersection) {
+		for(const subtype of type.types.values()) {
+			if(!subsumes(subtype, bound)) {
+				type.types.delete(subtype);
+			} else {
+				constrainWithUpperBound(subtype, bound);
+			}
+		}
+	} else if(bound instanceof UnresolvedRTypeIntersection) {
+		// constrainWithLowerBound(bound, type);
+		for(const subtype of bound.types) {
+			constrainWithUpperBound(type, subtype);
+		}
+	} else if(type instanceof UnresolvedRFunctionType && bound instanceof UnresolvedRFunctionType) {
+		for(const [key, paramType] of bound.parameterTypes) {
+			constrainWithLowerBound(type.getParameterType(key), paramType);
+		}
+		constrainWithUpperBound(type.returnType, bound.returnType);
+	} else if(type instanceof UnresolvedRAtomicVectorType && bound instanceof UnresolvedRAtomicVectorType) {
+		constrainWithUpperBound(type.elementType, bound.elementType);
+	} else if(type instanceof UnresolvedRListType && bound instanceof UnresolvedRListType) {
+		constrainWithUpperBound(type.elementType, bound.elementType);
+	}
+}
+
+
+export function resolveType(type: UnresolvedDataType): DataType {
+	if(type instanceof UnresolvedRTypeVariable) {
+		const lowerBound = resolveType(type.lowerBound);
+		const upperBound = resolveType(type.upperBound);
 
 		if(!subsumes(lowerBound, upperBound)) {
 			return new RErrorType(lowerBound, upperBound);
-		} else if(subsumes(lowerBound, upperBound) && subsumes(upperBound, lowerBound)) {
+		}
+		
+		if(subsumes(lowerBound, upperBound) && subsumes(upperBound, lowerBound)) {
 			return lowerBound; // If both bounds are equal, return one of them
-		} else {
-			return new RTypeVariable(
-				lowerBound instanceof RTypeVariable ? lowerBound.lowerBound : lowerBound,
-				upperBound instanceof RTypeVariable ? upperBound.upperBound : upperBound
-			);
 		}
+		
+		return new RTypeVariable(
+			lowerBound instanceof RTypeVariable ? lowerBound.lowerBound : lowerBound,
+			upperBound instanceof RTypeVariable ? upperBound.upperBound : upperBound
+		);
+	} else if(type instanceof UnresolvedRTypeUnion) {
+		let resolvedType: DataType = new RTypeUnion();
+		for(const subtype of type.types) {
+			const resolvedSubtype = resolveType(subtype);
+			// console.debug('Resolved subtype', subtype, 'to', resolvedSubtype);
+			// console.debug('Joining type', resolvedType, 'with subtype', resolvedSubtype);
+			resolvedType = join(resolvedType, resolvedSubtype);
+			// console.debug('Joined type is now', resolvedType);
+		}
+		return resolvedType;
+	} else if(type instanceof UnresolvedRTypeIntersection) {
+		let resolvedType: DataType = new RTypeIntersection();
+		for(const subtype of type.types) {
+			const resolvedSubtype = resolveType(subtype);
+			resolvedType = meet(resolvedType, resolvedSubtype);
+		}
+		return resolvedType;
 	} else if(type instanceof UnresolvedRFunctionType) {
 		const resolvedParameterTypes = new Map(type.parameterTypes.entries().toArray().map(([key, type]) => [key, resolveType(type)]));
 		const resolvedReturnType = resolveType(type.returnType);
 		return new RFunctionType(resolvedParameterTypes, resolvedReturnType);
-	} else if(type instanceof UnresolvedRVectorType) {
-		const resolvedElementType = resolveType(type.elementType);
-		return new RVectorType(resolvedElementType);
 	} else if(type instanceof UnresolvedRAtomicVectorType) {
 		const resolvedElementType = resolveType(type.elementType);
 		return new RAtomicVectorType(resolvedElementType);
@@ -332,17 +401,23 @@ function subsumes(subtype: DataType, supertype: DataType): boolean {
 		return true;
 	} else if(subtype instanceof RErrorType || supertype instanceof RErrorType) {
 		return false; // Error types do not subsume and are not subsumed by any other type
-	} else if(subtype instanceof RNoneType || supertype instanceof RAnyType) {
-		return true; // None subsumes any type, Any is subsumed by any type
 	} else if(subtype instanceof RTypeVariable) {
 		return subsumes(subtype.lowerBound, supertype) && subsumes(subtype.upperBound, supertype);
 	} else if(supertype instanceof RTypeVariable) {
 		return subsumes(supertype.lowerBound, subtype) && subsumes(subtype, supertype.upperBound);
-	} else if(subtype instanceof RListType && (supertype instanceof RListType || supertype instanceof RVectorType)) {
+	} else if(subtype instanceof RTypeUnion) {
+		return subtype.types.values().every(subtype => subsumes(subtype, supertype));
+	} else if(supertype instanceof RTypeUnion) {
+		return supertype.types.values().some(supertype => subsumes(subtype, supertype));
+	} else if(supertype instanceof RTypeIntersection) {
+		return supertype.types.values().every(supertype => subsumes(subtype, supertype));
+	} else if(subtype instanceof RTypeIntersection) {
+		return subtype.types.values().some(subtype => subsumes(subtype, supertype));
+	} else if(subtype instanceof RListType && supertype instanceof RListType) {
 		return subsumes(subtype.elementType, supertype.elementType);
-	} else if(subtype instanceof RAtomicVectorType && (supertype instanceof RAtomicVectorType || supertype instanceof RVectorType)) {
+	} else if(subtype instanceof RAtomicVectorType && supertype instanceof RAtomicVectorType) {
 		return subsumes(subtype.elementType, supertype.elementType);
-	} else if(isAtomicVectorElementType(subtype) && (supertype instanceof RAtomicVectorType || supertype instanceof RVectorType)) {
+	} else if(isAtomicVectorElementType(subtype) && supertype instanceof RAtomicVectorType) {
 		// A scalar subsumes a vector type if it subsumes the element type of the vector
 		return subsumes(subtype, supertype.elementType);
 	} else if(subtype instanceof RFunctionType && supertype instanceof RFunctionType) {
@@ -366,95 +441,151 @@ function subsumesByTag(subtype: RDataTypeTag, supertype: RDataTypeTag): boolean
 		|| subtype === RDataTypeTag.Integer && supertype === RDataTypeTag.Double
 		|| subtype === RDataTypeTag.Integer && supertype === RDataTypeTag.Complex
 		|| subtype === RDataTypeTag.Double && supertype === RDataTypeTag.Complex
-		|| subtype === RDataTypeTag.None || supertype === RDataTypeTag.Any
-		|| subtype === RDataTypeTag.Variable || supertype === RDataTypeTag.Variable
-		|| [RDataTypeTag.Logical, RDataTypeTag.Integer, RDataTypeTag.Double, RDataTypeTag.Complex, RDataTypeTag.String, RDataTypeTag.Raw].includes(subtype) && (supertype === RDataTypeTag.AtomicVector || supertype === RDataTypeTag.Vector)
-		|| subtype === RDataTypeTag.AtomicVector && supertype === RDataTypeTag.Vector
-		|| subtype === RDataTypeTag.List && supertype === RDataTypeTag.Vector;
+		|| [RDataTypeTag.Logical, RDataTypeTag.Integer, RDataTypeTag.Double, RDataTypeTag.Complex, RDataTypeTag.String, RDataTypeTag.Raw].includes(subtype) && supertype === RDataTypeTag.AtomicVector;
 }
 
-function union(type1: DataType, type2: DataType): DataType {
+function join(type1: DataType, type2: DataType): DataType {
 	if(type1 instanceof RErrorType) {
 		return type1;
 	} else if(type2 instanceof RErrorType) {
 		return type2;
 	} else if(type1 instanceof RTypeVariable) {
-		return union(type1.lowerBound, type2);
+		return join(type1.lowerBound, type2);
 	} else if(type2 instanceof RTypeVariable) {
-		return union(type1, type2.lowerBound);
+		return join(type1, type2.lowerBound);
+	} else if(type1 instanceof RTypeUnion) {
+		if(type1.types.size === 0) {
+			return type2; // If type1 is an empty union, return type2
+		}
+
+		// ? Use type1.types.values().flatMap(...); instead?
+		const types = new Set<DataType>();
+		for(const subtype of type1.types) {
+			const joinedType = join(subtype, type2);
+			if(joinedType instanceof RErrorType) {
+				return joinedType; // If any subtype resolves to an error, return the error
+			} else if(joinedType instanceof RTypeUnion) {
+				joinedType.types.forEach(type => types.add(type));
+			} else {
+				types.add(joinedType);
+			}
+		}
+		return types.size === 1 ? [...types][0] : new RTypeUnion(...types);
+	} else if(type2 instanceof RTypeUnion) {
+		return join(type2, type1);
+	// } else if(type1 instanceof RTypeIntersection) {
+	// 	// ? Use type1.types.values().flatMap(...); instead?
+	// 	const types = new Set<DataType>();
+	// 	for(const subtype of type1.types) {
+	// 		const joinedType = join(subtype, type2);
+	// 		if(joinedType instanceof RErrorType) {
+	// 			return joinedType; // If any subtype resolves to an error, return the error
+	// 		} else if(joinedType instanceof RTypeIntersection) {
+	// 			joinedType.types.forEach(type => types.add(type));
+	// 		} else {
+	// 			types.add(joinedType);
+	// 		}
+	// 	}
+	// 	return types.size === 1 ? [...types][0] : new RTypeIntersection(...types);
+	// } else if(type2 instanceof RTypeIntersection) {
+	// 	return join(type2, type1);
 	} else if(type1 instanceof RFunctionType && type2 instanceof RFunctionType) {
 		const parameterTypes = new Map<number | string, DataType>();
 		const keys1 = new Set(type1.parameterTypes.keys());
 		const keys2 = new Set(type2.parameterTypes.keys());
 		for(const key of keys1.union(keys2)) {
-			const parameterType1 = type1.parameterTypes.get(key) ?? new RNoneType();
-			const parameterType2 = type2.parameterTypes.get(key) ?? new RNoneType();
-			parameterTypes.set(key, intersection(parameterType1, parameterType2));
+			const parameterType1 = type1.parameterTypes.get(key) ?? new RTypeUnion();
+			const parameterType2 = type2.parameterTypes.get(key) ?? new RTypeUnion();
+			parameterTypes.set(key, meet(parameterType1, parameterType2));
 		}
-		const returnType = union(type1.returnType, type2.returnType);
+		const returnType = join(type1.returnType, type2.returnType);
 		return new RFunctionType(parameterTypes, returnType);
 	} else if(type1 instanceof RListType && type2 instanceof RListType) {
-		return new RListType(union(type1.elementType, type2.elementType));
+		return new RListType(join(type1.elementType, type2.elementType));
 	} else if(type1 instanceof RAtomicVectorType && type2 instanceof RAtomicVectorType) {
-		return new RAtomicVectorType(union(type1.elementType, type2.elementType));
-	} else if(isVectorType(type1) && isVectorType(type2)) {
-		return new RVectorType(union(type1.elementType, type2.elementType));
-	} else if(isAtomicVectorElementType(type1) && (type2.tag === RDataTypeTag.AtomicVector || type2.tag === RDataTypeTag.Vector)) {
-		if(type2 instanceof RAtomicVectorType) {
-			return new RAtomicVectorType(union(type1, type2.elementType));
-		} else {
-			return new RVectorType(union(type1, type2.elementType));
-		}
-	} else if(isAtomicVectorElementType(type2) && (type1.tag === RDataTypeTag.AtomicVector || type1.tag === RDataTypeTag.Vector)) {
-		if(type1 instanceof RAtomicVectorType) {
-			return new RAtomicVectorType(union(type2, type1.elementType));
-		} else {
-			return new RVectorType(union(type2, type1.elementType));
-		}
+		return new RAtomicVectorType(join(type1.elementType, type2.elementType));
+	} else if(isAtomicVectorElementType(type1) && type2.tag === RDataTypeTag.AtomicVector) {
+		return new RAtomicVectorType(join(type1, type2.elementType));
+	} else if(isAtomicVectorElementType(type2) && type1.tag === RDataTypeTag.AtomicVector) {
+		return new RAtomicVectorType(join(type2, type1.elementType));
 	} else if(subsumesByTag(type1.tag, type2.tag)) {
 		return type2;
 	} else if(subsumesByTag(type2.tag, type1.tag)) {
 		return type1;
 	}
-	return new RAnyType();
+	return new RTypeUnion(type1, type2);
 }
 
-function intersection(type1: DataType, type2: DataType): DataType {
+function meet(type1: DataType, type2: DataType): DataType {
 	if(type1 instanceof RErrorType) {
 		return type1;
 	} else if(type2 instanceof RErrorType) {
 		return type2;
 	} else if(type1 instanceof RTypeVariable) {
-		return intersection(type1.upperBound, type2);
+		return meet(type1.upperBound, type2);
 	} else if(type2 instanceof RTypeVariable) {
-		return intersection(type1, type2.upperBound);
+		return meet(type1, type2.upperBound);
+	// } else if(type1 instanceof RTypeUnion) {
+	// 	// ? Use type1.types.values().flatMap(...); instead?
+	// 	const types = new Set<DataType>();
+	// 	for(const subtype of type1.types) {
+	// 		const metType = meet(subtype, type2);
+	// 		if(metType instanceof RErrorType) {
+	// 			return metType; // If any subtype resolves to an error, return the error
+	// 		} else if(metType instanceof RTypeUnion) {
+	// 			metType.types.forEach(type => types.add(type));
+	// 		} else {
+	// 			types.add(metType);
+	// 		}
+	// 	}
+	// 	return types.size === 1 ? [...types][0] : new RTypeUnion(...types);
+	// } else if(type2 instanceof RTypeUnion) {
+	// 	return meet(type2, type1);
+	} else if(type1 instanceof RTypeIntersection) {
+		if(type1.types.size === 0) {
+			return type2; // If type1 is an empty intersection, return type2
+		}
+
+		// ? Use type1.types.values().flatMap(...); instead?
+		const types = new Set<DataType>();
+		for(const subtype of type1.types) {
+			const metType = meet(subtype, type2);
+			if(metType instanceof RErrorType) {
+				return metType; // If any subtype resolves to an error, return the error
+			} else if(metType instanceof RTypeIntersection) {
+				metType.types.forEach(type => types.add(type));
+			} else {
+				types.add(metType);
+			}
+		}
+		return types.size === 1 ? [...types][0] : new RTypeIntersection(...types);
+	} else if(type2 instanceof RTypeIntersection) {
+		return meet(type2, type1);
 	} else if(type1 instanceof RFunctionType && type2 instanceof RFunctionType) {
 		const parameterTypes = new Map<number | string, DataType>();
 		const keys1 = new Set(type1.parameterTypes.keys());
 		const keys2 = new Set(type2.parameterTypes.keys());
 		for(const key of keys1.intersection(keys2)) {
-			const parameterType1 = type1.parameterTypes.get(key) ?? new RAnyType();
-			const parameterType2 = type2.parameterTypes.get(key) ?? new RAnyType();
-			parameterTypes.set(key, union(parameterType1, parameterType2));
+			const parameterType1 = type1.parameterTypes.get(key) ?? new RTypeIntersection();
+			const parameterType2 = type2.parameterTypes.get(key) ?? new RTypeIntersection();
+			parameterTypes.set(key, join(parameterType1, parameterType2));
 		}
-		const returnType = intersection(type1.returnType, type2.returnType);
+		const returnType = meet(type1.returnType, type2.returnType);
 		return new RFunctionType(parameterTypes, returnType);
-	} else if(isVectorType(type1) && isVectorType(type2) && (type1 instanceof RListType || type2 instanceof RListType)) {
-		return new RListType(intersection(type1.elementType, type2.elementType));
-	} else if(isVectorType(type1) && isVectorType(type2) && (type1 instanceof RAtomicVectorType || type2 instanceof RAtomicVectorType)) {
-		return new RAtomicVectorType(intersection(type1.elementType, type2.elementType));
-	} else if(type1 instanceof RVectorType && type2 instanceof RVectorType) {
-		return new RVectorType(intersection(type1.elementType, type2.elementType));
-	} else if(isAtomicVectorElementType(type1) && (type2.tag === RDataTypeTag.AtomicVector || type2.tag === RDataTypeTag.Vector)) {
-		return intersection(type1, type2.elementType);
-	} else if(isAtomicVectorElementType(type2) && (type1.tag === RDataTypeTag.AtomicVector || type1.tag === RDataTypeTag.Vector)) {
-		return intersection(type2, type1.elementType);
+	} else if(type1 instanceof RListType && type2 instanceof RListType) {
+		return new RListType(meet(type1.elementType, type2.elementType));
+	} else if(type1 instanceof RAtomicVectorType && type2 instanceof RAtomicVectorType) {
+		return new RAtomicVectorType(meet(type1.elementType, type2.elementType));
+	} else if(isAtomicVectorElementType(type1) && type2.tag === RDataTypeTag.AtomicVector) {
+		return meet(type1, type2.elementType);
+	} else if(isAtomicVectorElementType(type2) && type1.tag === RDataTypeTag.AtomicVector) {
+		return meet(type2, type1.elementType);
 	} else if(subsumesByTag(type1.tag, type2.tag)) {
 		return type1;
 	} else if(subsumesByTag(type2.tag, type1.tag)) {
 		return type2;
 	}
-	return new RNoneType();
+	return new RTypeIntersection(type1, type2);
 }
 
 
@@ -475,14 +606,14 @@ export function isAtomicVectorElementType(type: DataType | UnresolvedDataType):
 		|| type.tag === RDataTypeTag.Raw;
 }
 	
-export type VectorType = RVectorType | RAtomicVectorType | RListType;
+export type VectorType = RAtomicVectorType | RListType;
 
-export type UnresolvedVectorType = UnresolvedRVectorType | UnresolvedRAtomicVectorType | UnresolvedRListType;
+export type UnresolvedVectorType = UnresolvedRAtomicVectorType | UnresolvedRListType;
 
 export function isVectorType(type: UnresolvedDataType): type is UnresolvedVectorType
 export function isVectorType(type: DataType): type is VectorType
 export function isVectorType(type: DataType | UnresolvedDataType): type is VectorType | UnresolvedVectorType {
-	return type.tag === RDataTypeTag.Vector || type.tag === RDataTypeTag.AtomicVector || type.tag === RDataTypeTag.List;
+	return type.tag === RDataTypeTag.AtomicVector || type.tag === RDataTypeTag.List;
 }
 
 /**
@@ -493,24 +624,26 @@ export function isVectorType(type: DataType | UnresolvedDataType): type is Vecto
 */
 export type DataType
 	= AtomicVectorElementType
-	| VectorType
+	| RAtomicVectorType
+	| RListType
 	| RNullType
 	| REnvironmentType
 	| RLanguageType
 	| RFunctionType
+	| RTypeUnion
+	| RTypeIntersection
 	| RTypeVariable
-	| RErrorType
-	| RAnyType
-	| RNoneType;
+	| RErrorType;
 
 export type UnresolvedDataType
 	= AtomicVectorElementType
-	| UnresolvedVectorType
+	| UnresolvedRAtomicVectorType
+	| UnresolvedRListType
 	| RNullType
 	| REnvironmentType
 	| RLanguageType
 	| UnresolvedRFunctionType
+	| UnresolvedRTypeUnion
+	| UnresolvedRTypeIntersection
 	| UnresolvedRTypeVariable
-	// | RErrorType
-	| RAnyType
-	| RNoneType;
\ No newline at end of file
+	| RErrorType;
\ No newline at end of file
diff --git a/test/functionality/_helper/subtyping/assert-inferred-type.ts b/test/functionality/_helper/subtyping/assert-inferred-type.ts
index 8212fb946d1..0b5a9d4aa2a 100644
--- a/test/functionality/_helper/subtyping/assert-inferred-type.ts
+++ b/test/functionality/_helper/subtyping/assert-inferred-type.ts
@@ -2,7 +2,7 @@ import { describe, expect, test } from 'vitest';
 import { TreeSitterExecutor } from '../../../../src/r-bridge/lang-4.x/tree-sitter/tree-sitter-executor';
 import { createDataflowPipeline } from '../../../../src/core/steps/pipeline/default-pipelines';
 import { requestFromInput } from '../../../../src/r-bridge/retriever';
-import { RAnyType, RNoneType, RTypeVariable, type DataType } from '../../../../src/subtyping/types';
+import { RTypeIntersection, RTypeUnion, RTypeVariable, type DataType } from '../../../../src/subtyping/types';
 import type { DataTypeInfo } from '../../../../src/subtyping/infer';
 import { inferDataTypes } from '../../../../src/subtyping/infer';
 import { type FlowrSearch } from '../../../../src/search/flowr-search-builder';
@@ -26,7 +26,7 @@ export function assertInferredTypes(
 			query,
 			expectedType: 'expectedType' in rest
 				? rest.expectedType
-				: new RTypeVariable(rest.lowerBound ?? new RNoneType(), rest.upperBound ?? new RAnyType())
+				: new RTypeVariable(rest.lowerBound ?? new RTypeUnion(), rest.upperBound ?? new RTypeIntersection())
 		}));
 
 		describe.each(expectedTypes)('Infer $expectedType.tag for query $query', ({ query, expectedType }) => {
diff --git a/test/functionality/subtyping/builtin-functions.test.ts b/test/functionality/subtyping/builtin-functions.test.ts
index dbb84dea0f8..c12163f6583 100644
--- a/test/functionality/subtyping/builtin-functions.test.ts
+++ b/test/functionality/subtyping/builtin-functions.test.ts
@@ -1,5 +1,5 @@
 import { describe } from 'vitest';
-import { RAnyType, RIntegerType, RLanguageType, RListType, RLogicalType, RNoneType, RNullType, RStringType, RTypeVariable, RAtomicVectorType } from '../../../src/subtyping/types';
+import { RTypeIntersection, RIntegerType, RLanguageType, RListType, RLogicalType, RTypeUnion, RNullType, RStringType, RTypeVariable, RAtomicVectorType } from '../../../src/subtyping/types';
 import { assertInferredType, assertInferredTypes } from '../_helper/subtyping/assert-inferred-type';
 import { Q } from '../../../src/search/flowr-search-builder';
 
@@ -15,16 +15,16 @@ describe('Infer types for builtin functions', () => {
 
 	assertInferredTypes(
 		'eval(quote(TRUE))',
-		{ query: Q.criterion('1@eval').build(),  lowerBound: new RNoneType(), upperBound: new RAnyType() },
+		{ query: Q.criterion('1@eval').build(),  lowerBound: new RTypeUnion(), upperBound: new RTypeIntersection() },
 		{ query: Q.criterion('1@quote').build(), expectedType: new RLanguageType() },
 		{ query: Q.criterion('1@TRUE').build(),  expectedType: new RLogicalType() }
 	);
 	
-	assertInferredType('list(1, 2, 3)', { expectedType: new RListType(new RTypeVariable(new RIntegerType(), new RAnyType())) });
+	assertInferredType('list(1, 2, 3)', { expectedType: new RListType(new RTypeVariable(new RIntegerType(), new RTypeIntersection())) });
 
 	assertInferredTypes(
 		'c("Hello", "Flo", "!")',
-		{ query: Q.criterion('1@c').build(),       expectedType: new RAtomicVectorType(new RTypeVariable(new RStringType(), new RAnyType())) },
+		{ query: Q.criterion('1@c').build(),       expectedType: new RAtomicVectorType(new RTypeVariable(new RStringType(), new RTypeIntersection())) },
 		{ query: Q.criterion('1@"Hello"').build(), expectedType: new RStringType() },
 	);
 });
\ No newline at end of file
diff --git a/test/functionality/subtyping/conditionals.test.ts b/test/functionality/subtyping/conditionals.test.ts
index 61b50ad4f23..1b5a7b20c7c 100644
--- a/test/functionality/subtyping/conditionals.test.ts
+++ b/test/functionality/subtyping/conditionals.test.ts
@@ -1,5 +1,5 @@
 import { describe } from 'vitest';
-import { RLogicalType, RNoneType, RNullType, RStringType } from '../../../src/subtyping/types';
+import { RLogicalType, RTypeUnion, RNullType, RStringType } from '../../../src/subtyping/types';
 import { assertInferredType, assertInferredTypes } from '../_helper/subtyping/assert-inferred-type';
 import { Q } from '../../../src/search/flowr-search-builder';
 import { RType } from '../../../src/r-bridge/lang-4.x/ast/model/type';
@@ -8,7 +8,7 @@ describe('Infer types for if statements', () => {
 	describe.each([
 		{ input: 'if(FALSE) { TRUE }',                     expectedType: new RNullType() },
 		{ input: 'if(TRUE) { "Hi" } else { NULL }',        lowerBound: new RStringType() },
-		{ input: 'if(stop("stop here")) { 1 } else { 2 }', expectedType: new RNoneType() },
+		{ input: 'if(stop("stop here")) { 1 } else { 2 }', expectedType: new RTypeUnion() },
 	])('Infer $expectedType for $input', ({ input, ...expectedType }) => assertInferredType(input, expectedType));
 
 	assertInferredTypes(
diff --git a/test/functionality/subtyping/constants.test.ts b/test/functionality/subtyping/constants.test.ts
index df02b87acfe..d4a16ad1afd 100644
--- a/test/functionality/subtyping/constants.test.ts
+++ b/test/functionality/subtyping/constants.test.ts
@@ -2,14 +2,16 @@ import { describe } from 'vitest';
 import { RComplexType, RDoubleType, RIntegerType, RLogicalType, RNullType, RStringType } from '../../../src/subtyping/types';
 import { assertInferredType } from '../_helper/subtyping/assert-inferred-type';
 
-describe.each([
-	{ description: 'logical constant',        input: 'TRUE',            expectedType: new RLogicalType() },
-	{ description: 'logical constant',        input: 'FALSE',           expectedType: new RLogicalType() },
-	{ description: 'null constant',           input: 'NULL',            expectedType: new RNullType() },
-	{ description: 'integer constant',        input: '42',              lowerBound: new RIntegerType(), upperBound: new RComplexType() },
-	{ description: 'integer constant',        input: '42L',             expectedType: new RIntegerType() },
-	{ description: 'double constant',         input: '42.5',            lowerBound: new RDoubleType(), upperBound: new RComplexType() },
-	{ description: 'complex number constant', input: '42i',             expectedType: new RComplexType() },
-	{ description: 'string constant',         input: '"Hello, world!"', expectedType: new RStringType() },
-	{ description: 'empty expression list',   input: '{}',              expectedType: new RNullType() }
-])('Infer $expectedType for $description', ({ input, ...expectedType }) => assertInferredType(input, expectedType));
\ No newline at end of file
+describe('Infer types for constants', () => {
+	describe.each([
+		{ description: 'logical constant',        input: 'TRUE',            expectedType: new RLogicalType() },
+		{ description: 'logical constant',        input: 'FALSE',           expectedType: new RLogicalType() },
+		{ description: 'null constant',           input: 'NULL',            expectedType: new RNullType() },
+		{ description: 'integer constant',        input: '42',              lowerBound: new RIntegerType(), upperBound: new RComplexType() },
+		{ description: 'integer constant',        input: '42L',             expectedType: new RIntegerType() },
+		{ description: 'double constant',         input: '42.5',            lowerBound: new RDoubleType(), upperBound: new RComplexType() },
+		{ description: 'complex number constant', input: '42i',             expectedType: new RComplexType() },
+		{ description: 'string constant',         input: '"Hello, world!"', expectedType: new RStringType() },
+		{ description: 'empty expression list',   input: '{}',              expectedType: new RNullType() }
+	])('Infer $expectedType for $description', ({ input, ...expectedType }) => assertInferredType(input, expectedType));
+});
\ No newline at end of file
diff --git a/test/functionality/subtyping/loops.test.ts b/test/functionality/subtyping/loops.test.ts
index 1f8a2ac4f1e..fee0208ab9b 100644
--- a/test/functionality/subtyping/loops.test.ts
+++ b/test/functionality/subtyping/loops.test.ts
@@ -1,5 +1,5 @@
 import { describe } from 'vitest';
-import { RLogicalType, RNoneType, RNullType } from '../../../src/subtyping/types';
+import { RLogicalType, RTypeUnion, RNullType } from '../../../src/subtyping/types';
 import { assertInferredType, assertInferredTypes } from '../_helper/subtyping/assert-inferred-type';
 import { Q } from '../../../src/search/flowr-search-builder';
 import { RType } from '../../../src/r-bridge/lang-4.x/ast/model/type';
@@ -7,12 +7,12 @@ import { RType } from '../../../src/r-bridge/lang-4.x/ast/model/type';
 describe('Infer types for loops', () => {
 	describe.each([
 		{ input: 'while(FALSE) { print("Testing is fun!") }',                         expectedType: new RNullType() },
-		{ input: 'while(TRUE) { next }',                                              expectedType: new RNoneType() },
+		{ input: 'while(TRUE) { next }',                                              expectedType: new RTypeUnion() },
 		{ input: 'while(1 < 2) { print("Hi Flo!") }',                                 expectedType: new RNullType() },
 		{ input: 'while(TRUE) { break }',                                             expectedType: new RNullType() },
 		{ input: 'for(i in NULL) { print("I would like to write a test for that") }', expectedType: new RNullType() },
 		{ input: 'for(i in 1:10) { print(i) }',                                       expectedType: new RNullType() },
-		{ input: 'repeat { print("I love testing!") }',                               expectedType: new RNoneType() },
+		{ input: 'repeat { print("I love testing!") }',                               expectedType: new RTypeUnion() },
 		{ input: 'repeat { break }',                                                  expectedType: new RNullType() },
 	])('Infer $expectedType for $input', ({ input, ...expectedType }) => assertInferredType(input, expectedType));
 
diff --git a/test/functionality/subtyping/subsetting.test.ts b/test/functionality/subtyping/subsetting.test.ts
index b67345ddcd8..0e4ff4e4ab0 100644
--- a/test/functionality/subtyping/subsetting.test.ts
+++ b/test/functionality/subtyping/subsetting.test.ts
@@ -1,5 +1,5 @@
 import { describe } from 'vitest';
-import { RAnyType, RAtomicVectorType, RIntegerType, RListType, RTypeVariable, RVectorType } from '../../../src/subtyping/types';
+import { RTypeIntersection, RAtomicVectorType, RIntegerType, RListType, RTypeVariable, RTypeUnion, RNullType } from '../../../src/subtyping/types';
 import { assertInferredTypes } from '../_helper/subtyping/assert-inferred-type';
 import { Q } from '../../../src/search/flowr-search-builder';
 import { RType } from '../../../src/r-bridge/lang-4.x/ast/model/type';
@@ -7,55 +7,55 @@ import { RType } from '../../../src/r-bridge/lang-4.x/ast/model/type';
 describe.only('Infer types for subsetting expressions', () => {
 	assertInferredTypes(
 		'v <- c(1, 2, 3); v[2]',
-		{ query: Q.var('v').last().build(),                    lowerBound: new RAtomicVectorType(new RTypeVariable(new RIntegerType(), new RAnyType())), upperBound: new RVectorType(new RTypeVariable(new RIntegerType(), new RAnyType())) },
-		{ query: Q.all().filter(RType.Access).first().build(), lowerBound: new RAtomicVectorType(new RTypeVariable(new RIntegerType(), new RAnyType())) },
+		{ query: Q.var('v').last().build(),                    expectedType: new RAtomicVectorType(new RTypeVariable(new RIntegerType(), new RTypeIntersection())) },
+		{ query: Q.all().filter(RType.Access).first().build(), lowerBound: new RAtomicVectorType(new RTypeVariable(new RIntegerType(), new RTypeIntersection())) },
 	);
 	
 	assertInferredTypes(
 		'l <- list(1, 2, 3); l[2]',
-		{ query: Q.var('l').last().build(),                    lowerBound: new RListType(new RTypeVariable(new RIntegerType(), new RAnyType())), upperBound: new RVectorType(new RTypeVariable(new RIntegerType(), new RAnyType())) },
-		{ query: Q.all().filter(RType.Access).first().build(), lowerBound: new RListType(new RTypeVariable(new RIntegerType(), new RAnyType())) },
+		{ query: Q.var('l').last().build(),                    expectedType: new RListType(new RTypeVariable(new RIntegerType(), new RTypeIntersection())) },
+		{ query: Q.all().filter(RType.Access).first().build(), lowerBound: new RListType(new RTypeVariable(new RIntegerType(), new RTypeIntersection())) },
 	);
 	
 	assertInferredTypes(
 		'v <- c(1, 2, 3); v[]',
-		{ query: Q.var('v').last().build(),                    lowerBound: new RAtomicVectorType(new RTypeVariable(new RIntegerType(), new RAnyType())), upperBound: new RVectorType(new RTypeVariable(new RIntegerType(), new RAnyType())) },
-		{ query: Q.all().filter(RType.Access).first().build(), lowerBound: new RAtomicVectorType(new RTypeVariable(new RIntegerType(), new RAnyType())) },
+		{ query: Q.var('v').last().build(),                    expectedType: new RAtomicVectorType(new RTypeVariable(new RIntegerType(), new RTypeIntersection())) },
+		{ query: Q.all().filter(RType.Access).first().build(), lowerBound: new RAtomicVectorType(new RTypeVariable(new RIntegerType(), new RTypeIntersection())) },
 	);
 	
 	assertInferredTypes(
 		'l <- list(1, 2, 3); l[]',
-		{ query: Q.var('l').last().build(),                    lowerBound: new RListType(new RTypeVariable(new RIntegerType(), new RAnyType())), upperBound: new RVectorType(new RTypeVariable(new RIntegerType(), new RAnyType())) },
-		{ query: Q.all().filter(RType.Access).first().build(), lowerBound: new RListType(new RTypeVariable(new RIntegerType(), new RAnyType())) },
+		{ query: Q.var('l').last().build(),                    expectedType: new RListType(new RTypeVariable(new RIntegerType(), new RTypeIntersection())) },
+		{ query: Q.all().filter(RType.Access).first().build(), lowerBound: new RListType(new RTypeVariable(new RIntegerType(), new RTypeIntersection())) },
 	);
 	
 	assertInferredTypes(
 		'v <- c(1, 2, 3); v[[2]]',
-		{ query: Q.var('v').last().build(),                    lowerBound: new RAtomicVectorType(new RTypeVariable(new RIntegerType(), new RAnyType())), upperBound: new RVectorType(new RTypeVariable(new RIntegerType(), new RAnyType())) },
+		{ query: Q.var('v').last().build(),                    expectedType: new RAtomicVectorType(new RTypeVariable(new RIntegerType(), new RTypeIntersection())) },
 		{ query: Q.all().filter(RType.Access).first().build(), lowerBound: new RIntegerType() },
 	);
 	
 	assertInferredTypes(
 		'l <- list(1, 2, 3); l[[2]]',
-		{ query: Q.var('l').last().build(),                    lowerBound: new RListType(new RTypeVariable(new RIntegerType(), new RAnyType())), upperBound: new RVectorType(new RTypeVariable(new RIntegerType(), new RAnyType())) },
+		{ query: Q.var('l').last().build(),                    expectedType: new RListType(new RTypeVariable(new RIntegerType(), new RTypeIntersection())) },
 		{ query: Q.all().filter(RType.Access).first().build(), lowerBound: new RIntegerType() },
 	);
 	
 	assertInferredTypes(
 		'l <- list(1, x = 2, 3); l$x',
-		{ query: Q.var('l').last().build(),                    expectedType: new RListType(new RTypeVariable(new RIntegerType(), new RAnyType())) },
+		{ query: Q.var('l').last().build(),                    expectedType: new RListType(new RTypeVariable(new RIntegerType(), new RTypeIntersection())) },
 		{ query: Q.all().filter(RType.Access).first().build(), lowerBound: new RIntegerType() },
 	);
 	
 	assertInferredTypes(
 		'l <- list(1, 2, 3); l$a',
-		{ query: Q.var('l').last().build(),                    expectedType: new RListType(new RTypeVariable(new RIntegerType(), new RAnyType())) },
+		{ query: Q.var('l').last().build(),                    expectedType: new RListType(new RTypeVariable(new RIntegerType(), new RTypeIntersection())) },
 		{ query: Q.all().filter(RType.Access).first().build(), lowerBound: new RIntegerType() },
 	);
 	
 	assertInferredTypes(
 		'l <- list(TRUE, a = 42, NULL); l$a',
-		{ query: Q.var('l').last().build(),                    expectedType: new RListType(new RAnyType()) },
-		{ query: Q.all().filter(RType.Access).first().build(), expectedType: new RAnyType() },
+		{ query: Q.var('l').last().build(),                    expectedType: new RListType(new RTypeVariable(new RTypeUnion(new RIntegerType(), new RNullType()), new RTypeIntersection())) },
+		{ query: Q.all().filter(RType.Access).first().build(), lowerBound: new RTypeUnion(new RIntegerType(), new RNullType()), upperBound: new RTypeIntersection() },
 	);
 });
\ No newline at end of file
diff --git a/test/functionality/subtyping/unsupported-expressions.test.ts b/test/functionality/subtyping/unsupported-expressions.test.ts
index b81572c970a..a0965700b3d 100644
--- a/test/functionality/subtyping/unsupported-expressions.test.ts
+++ b/test/functionality/subtyping/unsupported-expressions.test.ts
@@ -1,8 +1,8 @@
 import { describe } from 'vitest';
-import { RAnyType, RNoneType, RTypeVariable } from '../../../src/subtyping/types';
+import { RTypeIntersection, RTypeUnion, RTypeVariable } from '../../../src/subtyping/types';
 import { assertInferredType } from '../_helper/subtyping/assert-inferred-type';
 
 describe('Infer no type information for currently unsupported R expressions', () => {
-	assertInferredType('1 + 2',                  new RTypeVariable(new RNoneType(), new RAnyType()));
-	assertInferredType('print("Hello, world!")', new RTypeVariable(new RNoneType(), new RAnyType()));
+	assertInferredType('1 + 2',                  new RTypeVariable(new RTypeUnion(), new RTypeIntersection()));
+	assertInferredType('print("Hello, world!")', new RTypeVariable(new RTypeUnion(), new RTypeIntersection()));
 });
\ No newline at end of file

From 1c6e0b8b20f664035936e21beea5a1ed13298df7 Mon Sep 17 00:00:00 2001
From: Lukas Rohde <lukas.rohde@silupe.de>
Date: Sat, 12 Jul 2025 12:40:56 +0200
Subject: [PATCH 089/153] test(typing): add tests for constraint handling

---
 .../functionality/subtyping/constrain.test.ts | 61 +++++++++++++++++++
 1 file changed, 61 insertions(+)
 create mode 100644 test/functionality/subtyping/constrain.test.ts

diff --git a/test/functionality/subtyping/constrain.test.ts b/test/functionality/subtyping/constrain.test.ts
new file mode 100644
index 00000000000..ca6167c3195
--- /dev/null
+++ b/test/functionality/subtyping/constrain.test.ts
@@ -0,0 +1,61 @@
+import { describe, expect, test } from 'vitest';
+import { constrainWithLowerBound, constrainWithUpperBound, RComplexType, RDoubleType, resolveType, RIntegerType, RListType, RStringType, RTypeIntersection, RTypeVariable, UnresolvedRAtomicVectorType, UnresolvedRListType, UnresolvedRTypeUnion, UnresolvedRTypeVariable } from '../../../src/subtyping/types';
+
+describe.only('Constrain types with lower and upper bounds', () => {
+	test('Constrain with numeric bounds', () => {
+		const typeVar = new UnresolvedRTypeVariable();
+		constrainWithLowerBound(typeVar, new RIntegerType());
+		constrainWithUpperBound(typeVar, new RComplexType());
+		
+		expect(resolveType(typeVar)).toEqual(new RTypeVariable(new RIntegerType(), new RComplexType()));
+	});
+
+	test('Constrain with multiple bounds', () => {
+		const typeVar = new UnresolvedRTypeVariable();
+		constrainWithLowerBound(typeVar, new RIntegerType());
+		constrainWithLowerBound(typeVar, new RDoubleType());
+		constrainWithUpperBound(typeVar, new UnresolvedRTypeUnion(new RComplexType(), new RStringType()));
+		
+		expect(resolveType(typeVar)).toEqual(new RTypeVariable(new RDoubleType(), new RComplexType()));
+	});
+
+	test('Constrain with compound bounds', () => {
+		const typeVar = new UnresolvedRTypeVariable();
+		const listType1 = new UnresolvedRListType();
+		constrainWithLowerBound(listType1.elementType, new RIntegerType());
+		constrainWithLowerBound(typeVar, listType1);
+		const listType2 = new UnresolvedRListType();
+		constrainWithUpperBound(listType2.elementType, new RComplexType());
+		constrainWithUpperBound(typeVar, listType2);
+		
+		expect(resolveType(typeVar)).toEqual(new RListType(new RTypeVariable(new RIntegerType(), new RComplexType())));
+	});
+
+	test('Constraint propagation', () => {
+		const typeVar = new UnresolvedRTypeVariable();
+		const listType1 = new UnresolvedRListType();
+		constrainWithLowerBound(listType1.elementType, new RIntegerType());
+		constrainWithLowerBound(typeVar, listType1);
+		
+		const elementType = new UnresolvedRTypeVariable();
+		const listType2 = new UnresolvedRListType(elementType);
+		constrainWithUpperBound(typeVar, listType2);
+		
+		expect(resolveType(typeVar)).toEqual(new RListType(new RTypeVariable(new RIntegerType(), new RTypeIntersection())));
+		expect(resolveType(elementType)).toEqual(new RTypeVariable(new RIntegerType(), new RTypeIntersection()));
+	});
+
+	test('Advanced constraint propagation', () => {
+		const typeVar = new UnresolvedRTypeVariable();
+		const listType1 = new UnresolvedRListType();
+		constrainWithLowerBound(listType1.elementType, new RIntegerType());
+		constrainWithLowerBound(typeVar, listType1);
+		
+		const elementType = new UnresolvedRTypeVariable();
+		const vectorType = new UnresolvedRTypeUnion(new UnresolvedRAtomicVectorType(elementType), new UnresolvedRListType(elementType));
+		constrainWithUpperBound(typeVar, vectorType);
+		
+		expect(resolveType(typeVar)).toEqual(new RListType(new RTypeVariable(new RIntegerType(), new RTypeIntersection())));
+		expect(resolveType(elementType)).toEqual(new RTypeVariable(new RIntegerType(), new RTypeIntersection()));
+	});
+});
\ No newline at end of file

From 97e5a39c16990c010cda503645cb9975ba5262ad Mon Sep 17 00:00:00 2001
From: Lukas Rohde <lukas.rohde@silupe.de>
Date: Sat, 12 Jul 2025 12:42:50 +0200
Subject: [PATCH 090/153] refactor(typing): remove unnecessary cfg traversal
 modification

---
 src/subtyping/infer.ts | 42 ------------------------------------------
 1 file changed, 42 deletions(-)

diff --git a/src/subtyping/infer.ts b/src/subtyping/infer.ts
index fcfb179a9b4..c62e23661d6 100644
--- a/src/subtyping/infer.ts
+++ b/src/subtyping/infer.ts
@@ -75,8 +75,6 @@ class TypeInferringCfgGuidedVisitor<
 	Dataflow extends DataflowInformation                      = DataflowInformation,
 	Config extends TypeInferringCfgGuidedVisitorConfiguration<OtherInfo, ControlFlow, Ast, Dataflow> = TypeInferringCfgGuidedVisitorConfiguration<OtherInfo, ControlFlow, Ast, Dataflow>
 > extends SemanticCfgGuidedVisitor<UnresolvedTypeInfo & OtherInfo, ControlFlow, Ast, Dataflow['graph'], Config & { dataflow: Dataflow['graph'] }> {
-	protected visitedEventTriggered = new Map<NodeId, boolean>();
-
 	constructor(config: Config) {
 		super({ dataflow: config.dataflowInfo.graph, ...config });
 	}
@@ -89,46 +87,6 @@ class TypeInferringCfgGuidedVisitor<
 	}
 
 
-	protected override visitNode(node: NodeId): boolean {
-		if(this.visited.has(node)) {
-			return false;
-		}
-		// Override the order of the following two lines to ensure that the node is only marked as visited after it has actually been processed
-		this.onVisitNode(node);
-		this.visited.set(node, 1);
-		return true;
-	}
-
-	protected override onVisitNode(node: NodeId): void {
-		// Check if the node has already been visited to prevent duplicate processing due to the modification of the `visitFunctionCall` method
-		if(this.visitedEventTriggered.has(node)) {
-			return;
-		}
-		super.onVisitNode(node);
-		this.visitedEventTriggered.set(node, true);
-	}
-
-	protected override visitFunctionCall(vertex: DataflowGraphVertexFunctionCall) {
-		for(const arg of vertex.args.filter(arg => arg !== EmptyArgument)) {
-			this.onVisitNode(arg.nodeId);
-		}
-		super.visitFunctionCall(vertex);
-	}
-
-	protected override visitVariableUse(vertex: DataflowGraphVertexUse): void {
-		for(const origin of this.getOrigins(vertex.id)?.filter(origin => origin.type === OriginType.ReadVariableOrigin) ?? []) {
-			this.onVisitNode(origin.id);
-		}
-		const node = this.getNormalizedAst(vertex.id);
-		if(node?.type === RType.Argument) {
-			if(node.value !== undefined) {
-				this.onVisitNode(node.value.info.id);
-			}
-		}
-		super.visitVariableUse(vertex);
-	}
-
-
 	protected override onNullConstant(data: { vertex: DataflowGraphVertexValue; node: RSymbol<UnresolvedTypeInfo & ParentInformation, 'NULL'>; }): void {
 		data.node.info.typeVariable.constrainFromBothSides(new RNullType());
 	}

From eaf2d07682ae7e46c4d350db6dc9d121eb22511e Mon Sep 17 00:00:00 2001
From: Lukas Rohde <lukas.rohde@silupe.de>
Date: Mon, 14 Jul 2025 10:26:38 +0200
Subject: [PATCH 091/153] test-fix(typing): remove `only` modifier from test
 suites

---
 test/functionality/subtyping/constrain.test.ts  | 2 +-
 test/functionality/subtyping/subsetting.test.ts | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/test/functionality/subtyping/constrain.test.ts b/test/functionality/subtyping/constrain.test.ts
index ca6167c3195..24425046578 100644
--- a/test/functionality/subtyping/constrain.test.ts
+++ b/test/functionality/subtyping/constrain.test.ts
@@ -1,7 +1,7 @@
 import { describe, expect, test } from 'vitest';
 import { constrainWithLowerBound, constrainWithUpperBound, RComplexType, RDoubleType, resolveType, RIntegerType, RListType, RStringType, RTypeIntersection, RTypeVariable, UnresolvedRAtomicVectorType, UnresolvedRListType, UnresolvedRTypeUnion, UnresolvedRTypeVariable } from '../../../src/subtyping/types';
 
-describe.only('Constrain types with lower and upper bounds', () => {
+describe('Constrain types with lower and upper bounds', () => {
 	test('Constrain with numeric bounds', () => {
 		const typeVar = new UnresolvedRTypeVariable();
 		constrainWithLowerBound(typeVar, new RIntegerType());
diff --git a/test/functionality/subtyping/subsetting.test.ts b/test/functionality/subtyping/subsetting.test.ts
index 0e4ff4e4ab0..55550a76f02 100644
--- a/test/functionality/subtyping/subsetting.test.ts
+++ b/test/functionality/subtyping/subsetting.test.ts
@@ -4,7 +4,7 @@ import { assertInferredTypes } from '../_helper/subtyping/assert-inferred-type';
 import { Q } from '../../../src/search/flowr-search-builder';
 import { RType } from '../../../src/r-bridge/lang-4.x/ast/model/type';
 
-describe.only('Infer types for subsetting expressions', () => {
+describe('Infer types for subsetting expressions', () => {
 	assertInferredTypes(
 		'v <- c(1, 2, 3); v[2]',
 		{ query: Q.var('v').last().build(),                    expectedType: new RAtomicVectorType(new RTypeVariable(new RIntegerType(), new RTypeIntersection())) },

From 98f557dc4b39e0e9910eb4e2fcd3d537c600b658 Mon Sep 17 00:00:00 2001
From: Lukas Rohde <lukas.rohde@silupe.de>
Date: Mon, 14 Jul 2025 11:45:11 +0200
Subject: [PATCH 092/153] feat-fix(typing): also match unresolved datatypes in
 `subsumes` function

---
 src/subtyping/types.ts | 30 ++++++++++++++++++------------
 1 file changed, 18 insertions(+), 12 deletions(-)

diff --git a/src/subtyping/types.ts b/src/subtyping/types.ts
index 3dfea6105c9..29a1a7c1f5e 100644
--- a/src/subtyping/types.ts
+++ b/src/subtyping/types.ts
@@ -253,6 +253,7 @@ export function constrainWithLowerBound(type: UnresolvedDataType, bound: Unresol
 	} else if(type instanceof UnresolvedRTypeUnion) {
 		for(const subtype of type.types.values()) {
 			if(!subsumes(bound, subtype)) {
+				// console.debug('Removing subtype', subtype, 'from union', type, 'because it does not subsume the bound', bound);
 				type.types.delete(subtype);
 			} else {
 				constrainWithLowerBound(subtype, bound);
@@ -271,6 +272,7 @@ export function constrainWithLowerBound(type: UnresolvedDataType, bound: Unresol
 		// constrainWithUpperBound(bound, type);
 		for(const subtype of bound.types.values()) {
 			if(!subsumes(subtype, type)) {
+				// console.debug('Removing subtype', subtype, 'from intersection', bound, 'because it does not subsume the type', type);
 				bound.types.delete(subtype);
 			} else {
 				constrainWithLowerBound(type, subtype);
@@ -316,6 +318,7 @@ export function constrainWithUpperBound(type: UnresolvedDataType, bound: Unresol
 		// constrainWithLowerBound(bound, type);
 		for(const subtype of bound.types.values()) {
 			if(!subsumes(type, subtype)) {
+				// console.debug('Removing subtype', subtype, 'from union', bound, 'because it does not subsume the type', type);
 				bound.types.delete(subtype);
 			} else {
 				constrainWithUpperBound(type, subtype);
@@ -324,6 +327,7 @@ export function constrainWithUpperBound(type: UnresolvedDataType, bound: Unresol
 	} else if(type instanceof UnresolvedRTypeIntersection) {
 		for(const subtype of type.types.values()) {
 			if(!subsumes(subtype, bound)) {
+				// console.debug('Removing subtype', subtype, 'from intersection', type, 'because it does not subsume the bound', bound);
 				type.types.delete(subtype);
 			} else {
 				constrainWithUpperBound(subtype, bound);
@@ -396,31 +400,33 @@ export function resolveType(type: UnresolvedDataType): DataType {
 	}
 }
 
-function subsumes(subtype: DataType, supertype: DataType): boolean {
+function subsumes(subtype: DataType | UnresolvedDataType, supertype: DataType | UnresolvedDataType): boolean {
+	// console.debug('Checking if', subtype, 'subsumes', supertype);
+
 	if(subtype === supertype) {
 		return true;
-	} else if(subtype instanceof RErrorType || supertype instanceof RErrorType) {
+	} else if(subtype.tag === RDataTypeTag.Error || supertype.tag === RDataTypeTag.Error) {
 		return false; // Error types do not subsume and are not subsumed by any other type
-	} else if(subtype instanceof RTypeVariable) {
+	} else if(subtype.tag === RDataTypeTag.Variable) {
 		return subsumes(subtype.lowerBound, supertype) && subsumes(subtype.upperBound, supertype);
-	} else if(supertype instanceof RTypeVariable) {
+	} else if(supertype.tag === RDataTypeTag.Variable) {
 		return subsumes(supertype.lowerBound, subtype) && subsumes(subtype, supertype.upperBound);
-	} else if(subtype instanceof RTypeUnion) {
+	} else if(subtype.tag === RDataTypeTag.Union) {
 		return subtype.types.values().every(subtype => subsumes(subtype, supertype));
-	} else if(supertype instanceof RTypeUnion) {
+	} else if(supertype.tag === RDataTypeTag.Union) {
 		return supertype.types.values().some(supertype => subsumes(subtype, supertype));
-	} else if(supertype instanceof RTypeIntersection) {
+	} else if(supertype.tag === RDataTypeTag.Intersection) {
 		return supertype.types.values().every(supertype => subsumes(subtype, supertype));
-	} else if(subtype instanceof RTypeIntersection) {
+	} else if(subtype.tag === RDataTypeTag.Intersection) {
 		return subtype.types.values().some(subtype => subsumes(subtype, supertype));
-	} else if(subtype instanceof RListType && supertype instanceof RListType) {
+	} else if(subtype.tag === RDataTypeTag.List && supertype.tag === RDataTypeTag.List) {
 		return subsumes(subtype.elementType, supertype.elementType);
-	} else if(subtype instanceof RAtomicVectorType && supertype instanceof RAtomicVectorType) {
+	} else if(subtype.tag === RDataTypeTag.AtomicVector && supertype.tag === RDataTypeTag.AtomicVector) {
 		return subsumes(subtype.elementType, supertype.elementType);
-	} else if(isAtomicVectorElementType(subtype) && supertype instanceof RAtomicVectorType) {
+	} else if(isAtomicVectorElementType(subtype) && supertype.tag === RDataTypeTag.AtomicVector) {
 		// A scalar subsumes a vector type if it subsumes the element type of the vector
 		return subsumes(subtype, supertype.elementType);
-	} else if(subtype instanceof RFunctionType && supertype instanceof RFunctionType) {
+	} else if(subtype.tag === RDataTypeTag.Function && supertype.tag === RDataTypeTag.Function) {
 		return subsumes(subtype.returnType, supertype.returnType) && subtype.parameterTypes.entries().every(([key, type]) => {
 			const supertypeParameter = supertype.parameterTypes.get(key);
 			if(supertypeParameter === undefined) {

From c5a3acdf729aa0423b3cdd95e04286ea8ccffce4 Mon Sep 17 00:00:00 2001
From: Lukas Rohde <lukas.rohde@silupe.de>
Date: Mon, 14 Jul 2025 11:46:13 +0200
Subject: [PATCH 093/153] test(typing): add test for function overloading (it
 works! :D)

---
 .../functionality/subtyping/constrain.test.ts | 43 ++++++++++++++++++-
 1 file changed, 42 insertions(+), 1 deletion(-)

diff --git a/test/functionality/subtyping/constrain.test.ts b/test/functionality/subtyping/constrain.test.ts
index 24425046578..4eaf8f8fbdf 100644
--- a/test/functionality/subtyping/constrain.test.ts
+++ b/test/functionality/subtyping/constrain.test.ts
@@ -1,5 +1,5 @@
 import { describe, expect, test } from 'vitest';
-import { constrainWithLowerBound, constrainWithUpperBound, RComplexType, RDoubleType, resolveType, RIntegerType, RListType, RStringType, RTypeIntersection, RTypeVariable, UnresolvedRAtomicVectorType, UnresolvedRListType, UnresolvedRTypeUnion, UnresolvedRTypeVariable } from '../../../src/subtyping/types';
+import { constrainWithLowerBound, constrainWithUpperBound, RComplexType, RDoubleType, resolveType, RIntegerType, RListType, RStringType, RTypeIntersection, RTypeVariable, UnresolvedRAtomicVectorType, UnresolvedRFunctionType, UnresolvedRListType, UnresolvedRTypeIntersection, UnresolvedRTypeUnion, UnresolvedRTypeVariable } from '../../../src/subtyping/types';
 
 describe('Constrain types with lower and upper bounds', () => {
 	test('Constrain with numeric bounds', () => {
@@ -58,4 +58,45 @@ describe('Constrain types with lower and upper bounds', () => {
 		expect(resolveType(typeVar)).toEqual(new RListType(new RTypeVariable(new RIntegerType(), new RTypeIntersection())));
 		expect(resolveType(elementType)).toEqual(new RTypeVariable(new RIntegerType(), new RTypeIntersection()));
 	});
+
+	test('Function overloading', () => {
+		// Predetermined types in context
+		const funcType1 = new UnresolvedRFunctionType();
+		const paramType1 = new UnresolvedRTypeVariable();
+		funcType1.parameterTypes.set(0, paramType1);
+		paramType1.constrainFromBothSides(new RIntegerType());
+		funcType1.returnType.constrainFromBothSides(new RIntegerType());
+
+		const funcType2 = new UnresolvedRFunctionType();
+		const paramType2 = new UnresolvedRTypeVariable();
+		funcType2.parameterTypes.set(0, paramType2);
+		paramType2.constrainFromBothSides(new RDoubleType());
+		funcType2.returnType.constrainFromBothSides(new RDoubleType());
+
+		const overloadedFuncType1 = new UnresolvedRTypeIntersection(funcType1, funcType2);
+		const overloadedFuncType2 = new UnresolvedRTypeIntersection(funcType1, funcType2);
+
+		// Typing of called function
+		const calledFuncType1 = new UnresolvedRTypeVariable();
+		const calledFuncType2 = new UnresolvedRTypeVariable();
+		calledFuncType1.constrainWithLowerBound(overloadedFuncType1);
+		calledFuncType2.constrainWithLowerBound(overloadedFuncType2);
+
+		// Typing of function call
+		const argType1 = new UnresolvedRTypeVariable();
+		const argType2 = new UnresolvedRTypeVariable();
+		argType1.constrainFromBothSides(new RIntegerType());
+		argType2.constrainFromBothSides(new RDoubleType());
+		const templateFuncType1 = new UnresolvedRFunctionType();
+		templateFuncType1.parameterTypes.set(0, argType1);
+		const returnType1 = templateFuncType1.returnType;
+		const templateFuncType2 = new UnresolvedRFunctionType();
+		templateFuncType2.parameterTypes.set(0, argType2);
+		const returnType2 = templateFuncType2.returnType;
+		calledFuncType1.constrainWithUpperBound(templateFuncType1);
+		calledFuncType2.constrainWithUpperBound(templateFuncType2);
+
+		expect(resolveType(returnType1)).toEqual(new RTypeVariable(new RIntegerType(), new RTypeIntersection()));
+		expect(resolveType(returnType2)).toEqual(new RTypeVariable(new RDoubleType(), new RTypeIntersection()));
+	});
 });
\ No newline at end of file

From 232fc619753349da63d9b72243c7c2afde216128 Mon Sep 17 00:00:00 2001
From: Lukas Rohde <lukas.rohde@silupe.de>
Date: Mon, 14 Jul 2025 13:11:42 +0200
Subject: [PATCH 094/153] feat(typing): infer types for indexed elements of
 lists

---
 src/subtyping/infer.ts                        | 12 +++-
 src/subtyping/types.ts                        | 56 ++++++++++++++++---
 .../subtyping/builtin-functions.test.ts       |  3 +-
 .../subtyping/subsetting.test.ts              | 31 +++++++---
 4 files changed, 80 insertions(+), 22 deletions(-)

diff --git a/src/subtyping/infer.ts b/src/subtyping/infer.ts
index c62e23661d6..f6902546bdc 100644
--- a/src/subtyping/infer.ts
+++ b/src/subtyping/infer.ts
@@ -127,7 +127,7 @@ class TypeInferringCfgGuidedVisitor<
 		guard(node !== undefined, 'Expected AST node to be defined');
 		if(node.type === RType.Argument) {
 			if(node.value !== undefined) {
-				node.info.typeVariable.constrainWithLowerBound(node.value.info.typeVariable);
+				node.info.typeVariable.constrainFromBothSides(node.value.info.typeVariable);
 			}
 			return;
 		}
@@ -351,13 +351,19 @@ class TypeInferringCfgGuidedVisitor<
 		const listType = new UnresolvedRListType();
 		node.info.typeVariable.constrainFromBothSides(listType);
 
-		for(const arg of data.call.args) {
+		// TODO: Handle flattening behavior of `list` function
+		for(const [index, arg] of data.call.args.entries()) {
 			if(arg === EmptyArgument) {
 				continue; // Skip empty arguments
 			}
+			
 			const argNode = this.getNormalizedAst(arg.nodeId);
 			guard(argNode !== undefined, 'Expected argument node to be defined');
-			listType.elementType.constrainWithLowerBound(argNode.info.typeVariable);
+			listType.getIndexedElementType(index).constrainWithLowerBound(argNode.info.typeVariable);
+
+			if(arg.name !== undefined) {
+				listType.getIndexedElementType(arg.name).constrainWithLowerBound(argNode.info.typeVariable);
+			}
 		}
 	}
 
diff --git a/src/subtyping/types.ts b/src/subtyping/types.ts
index 29a1a7c1f5e..ec6871a2c9f 100644
--- a/src/subtyping/types.ts
+++ b/src/subtyping/types.ts
@@ -86,20 +86,34 @@ export class RRawType {
 export class UnresolvedRListType {
 	readonly tag = RDataTypeTag.List;
 	readonly elementType = new UnresolvedRTypeVariable();
+	readonly indexedElementTypes = new Map<number | string, UnresolvedRTypeVariable>();
 
 	constructor(elementType?: UnresolvedRTypeVariable) {
 		if(elementType !== undefined) {
 			this.elementType = elementType;
 		}
 	}
+
+	getIndexedElementType(indexOrName: number | string): UnresolvedRTypeVariable {
+		let elementType = this.indexedElementTypes.get(indexOrName);
+		if(elementType === undefined) {
+			elementType = new UnresolvedRTypeVariable();
+			elementType.constrainWithUpperBound(this.elementType.upperBound);
+			this.indexedElementTypes.set(indexOrName, elementType);
+			this.elementType.constrainWithLowerBound(elementType);
+		}
+		return elementType;
+	}
 }
 
 export class RListType {
 	readonly tag = RDataTypeTag.List;
-	readonly elementType: DataType;
+	readonly elementType:         DataType;
+	readonly indexedElementTypes: ReadonlyMap<number | string, DataType>;
 
-	constructor(elementType: DataType) {
+	constructor(elementType: DataType, indexedElementTypes: Map<number | string, DataType> = new Map()) {
 		this.elementType = elementType;
+		this.indexedElementTypes = indexedElementTypes;
 	}
 }
 
@@ -112,12 +126,19 @@ export class UnresolvedRFunctionType {
 	readonly parameterTypes = new Map<number | string, UnresolvedRTypeVariable>();
 	readonly returnType = new UnresolvedRTypeVariable();
 
+	constructor(returnType?: UnresolvedRTypeVariable) {
+		if(returnType !== undefined) {
+			this.returnType = returnType;
+		}
+	}
+
 	getParameterType(indexOrName: number | string): UnresolvedRTypeVariable {
-		if(!this.parameterTypes.has(indexOrName)) {
-			this.parameterTypes.set(indexOrName, new UnresolvedRTypeVariable());
+		let parameterType = this.parameterTypes.get(indexOrName);
+		if(parameterType === undefined) {
+			parameterType = new UnresolvedRTypeVariable();
+			this.parameterTypes.set(indexOrName, parameterType);
 		}
-		// eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-		return this.parameterTypes.get(indexOrName)!;
+		return parameterType;
 	}
 }
 
@@ -394,7 +415,8 @@ export function resolveType(type: UnresolvedDataType): DataType {
 		return new RAtomicVectorType(resolvedElementType);
 	} else if(type instanceof UnresolvedRListType) {
 		const resolvedElementType = resolveType(type.elementType);
-		return new RListType(resolvedElementType);
+		const resolvedIndexedElementTypes = new Map(type.indexedElementTypes.entries().map(([indexOrName, elementType]) => [indexOrName, resolveType(elementType)]));
+		return new RListType(resolvedElementType, resolvedIndexedElementTypes);
 	} else {
 		return type;
 	}
@@ -507,7 +529,15 @@ function join(type1: DataType, type2: DataType): DataType {
 		const returnType = join(type1.returnType, type2.returnType);
 		return new RFunctionType(parameterTypes, returnType);
 	} else if(type1 instanceof RListType && type2 instanceof RListType) {
-		return new RListType(join(type1.elementType, type2.elementType));
+		const indexedElementTypes = new Map<number | string, DataType>();
+		const keys1 = new Set(type1.indexedElementTypes.keys());
+		const keys2 = new Set(type2.indexedElementTypes.keys());
+		for(const key of keys1.intersection(keys2)) {
+			const elementType1 = type1.indexedElementTypes.get(key) ?? new RTypeIntersection();
+			const elementType2 = type2.indexedElementTypes.get(key) ?? new RTypeIntersection();
+			indexedElementTypes.set(key, join(elementType1, elementType2));
+		}
+		return new RListType(join(type1.elementType, type2.elementType), indexedElementTypes);
 	} else if(type1 instanceof RAtomicVectorType && type2 instanceof RAtomicVectorType) {
 		return new RAtomicVectorType(join(type1.elementType, type2.elementType));
 	} else if(isAtomicVectorElementType(type1) && type2.tag === RDataTypeTag.AtomicVector) {
@@ -579,7 +609,15 @@ function meet(type1: DataType, type2: DataType): DataType {
 		const returnType = meet(type1.returnType, type2.returnType);
 		return new RFunctionType(parameterTypes, returnType);
 	} else if(type1 instanceof RListType && type2 instanceof RListType) {
-		return new RListType(meet(type1.elementType, type2.elementType));
+		const indexedElementTypes = new Map<number | string, DataType>();
+		const keys1 = new Set(type1.indexedElementTypes.keys());
+		const keys2 = new Set(type2.indexedElementTypes.keys());
+		for(const key of keys1.union(keys2)) {
+			const elementType1 = type1.indexedElementTypes.get(key) ?? new RTypeUnion();
+			const elementType2 = type2.indexedElementTypes.get(key) ?? new RTypeUnion();
+			indexedElementTypes.set(key, meet(elementType1, elementType2));
+		}
+		return new RListType(meet(type1.elementType, type2.elementType), indexedElementTypes);
 	} else if(type1 instanceof RAtomicVectorType && type2 instanceof RAtomicVectorType) {
 		return new RAtomicVectorType(meet(type1.elementType, type2.elementType));
 	} else if(isAtomicVectorElementType(type1) && type2.tag === RDataTypeTag.AtomicVector) {
diff --git a/test/functionality/subtyping/builtin-functions.test.ts b/test/functionality/subtyping/builtin-functions.test.ts
index c12163f6583..90f7c1ed9b9 100644
--- a/test/functionality/subtyping/builtin-functions.test.ts
+++ b/test/functionality/subtyping/builtin-functions.test.ts
@@ -20,7 +20,8 @@ describe('Infer types for builtin functions', () => {
 		{ query: Q.criterion('1@TRUE').build(),  expectedType: new RLogicalType() }
 	);
 	
-	assertInferredType('list(1, 2, 3)', { expectedType: new RListType(new RTypeVariable(new RIntegerType(), new RTypeIntersection())) });
+	const elementType = new RTypeVariable(new RIntegerType(), new RTypeIntersection());
+	assertInferredType('list(1, 2, 3)', { expectedType: new RListType(elementType, new Map([[0, elementType], [1, elementType], [2, elementType]])) });
 
 	assertInferredTypes(
 		'c("Hello", "Flo", "!")',
diff --git a/test/functionality/subtyping/subsetting.test.ts b/test/functionality/subtyping/subsetting.test.ts
index 55550a76f02..412bdf49eec 100644
--- a/test/functionality/subtyping/subsetting.test.ts
+++ b/test/functionality/subtyping/subsetting.test.ts
@@ -1,5 +1,6 @@
 import { describe } from 'vitest';
-import { RTypeIntersection, RAtomicVectorType, RIntegerType, RListType, RTypeVariable, RTypeUnion, RNullType } from '../../../src/subtyping/types';
+import type { DataType } from '../../../src/subtyping/types';
+import { RTypeIntersection, RAtomicVectorType, RIntegerType, RListType, RTypeVariable, RTypeUnion, RNullType, RLogicalType } from '../../../src/subtyping/types';
 import { assertInferredTypes } from '../_helper/subtyping/assert-inferred-type';
 import { Q } from '../../../src/search/flowr-search-builder';
 import { RType } from '../../../src/r-bridge/lang-4.x/ast/model/type';
@@ -11,10 +12,11 @@ describe('Infer types for subsetting expressions', () => {
 		{ query: Q.all().filter(RType.Access).first().build(), lowerBound: new RAtomicVectorType(new RTypeVariable(new RIntegerType(), new RTypeIntersection())) },
 	);
 	
+	const elementType1 = new RTypeVariable(new RIntegerType(), new RTypeIntersection());
 	assertInferredTypes(
 		'l <- list(1, 2, 3); l[2]',
-		{ query: Q.var('l').last().build(),                    expectedType: new RListType(new RTypeVariable(new RIntegerType(), new RTypeIntersection())) },
-		{ query: Q.all().filter(RType.Access).first().build(), lowerBound: new RListType(new RTypeVariable(new RIntegerType(), new RTypeIntersection())) },
+		{ query: Q.var('l').last().build(),                    expectedType: new RListType(elementType1, new Map([[0, elementType1], [1, elementType1], [2, elementType1]])) },
+		{ query: Q.all().filter(RType.Access).first().build(), lowerBound: new RListType(elementType1, new Map([[0, elementType1], [1, elementType1], [2, elementType1]])) },
 	);
 	
 	assertInferredTypes(
@@ -23,10 +25,11 @@ describe('Infer types for subsetting expressions', () => {
 		{ query: Q.all().filter(RType.Access).first().build(), lowerBound: new RAtomicVectorType(new RTypeVariable(new RIntegerType(), new RTypeIntersection())) },
 	);
 	
+	const elementType2 = new RTypeVariable(new RIntegerType(), new RTypeIntersection());
 	assertInferredTypes(
 		'l <- list(1, 2, 3); l[]',
-		{ query: Q.var('l').last().build(),                    expectedType: new RListType(new RTypeVariable(new RIntegerType(), new RTypeIntersection())) },
-		{ query: Q.all().filter(RType.Access).first().build(), lowerBound: new RListType(new RTypeVariable(new RIntegerType(), new RTypeIntersection())) },
+		{ query: Q.var('l').last().build(),                    expectedType: new RListType(elementType2, new Map([[0, elementType2], [1, elementType2], [2, elementType2]])) },
+		{ query: Q.all().filter(RType.Access).first().build(), lowerBound: new RListType(elementType2, new Map([[0, elementType2], [1, elementType2], [2, elementType2]])) },
 	);
 	
 	assertInferredTypes(
@@ -35,27 +38,37 @@ describe('Infer types for subsetting expressions', () => {
 		{ query: Q.all().filter(RType.Access).first().build(), lowerBound: new RIntegerType() },
 	);
 	
+	const elementType3 = new RTypeVariable(new RIntegerType(), new RTypeIntersection());
 	assertInferredTypes(
 		'l <- list(1, 2, 3); l[[2]]',
-		{ query: Q.var('l').last().build(),                    expectedType: new RListType(new RTypeVariable(new RIntegerType(), new RTypeIntersection())) },
+		{ query: Q.var('l').last().build(),                    expectedType: new RListType(elementType1, new Map([[0, elementType3], [1, elementType3], [2, elementType3]])) },
 		{ query: Q.all().filter(RType.Access).first().build(), lowerBound: new RIntegerType() },
 	);
 	
+	const elementType4 = new RTypeVariable(new RIntegerType(), new RTypeIntersection());
 	assertInferredTypes(
 		'l <- list(1, x = 2, 3); l$x',
-		{ query: Q.var('l').last().build(),                    expectedType: new RListType(new RTypeVariable(new RIntegerType(), new RTypeIntersection())) },
+		{ query: Q.var('l').last().build(),                    expectedType: new RListType(elementType4, new Map<number | string, DataType>([[0, elementType4], [1, elementType4], [2, elementType4], ['x', elementType4]])) },
 		{ query: Q.all().filter(RType.Access).first().build(), lowerBound: new RIntegerType() },
 	);
 	
+	const elementType5 = new RTypeVariable(new RIntegerType(), new RTypeIntersection());
 	assertInferredTypes(
 		'l <- list(1, 2, 3); l$a',
-		{ query: Q.var('l').last().build(),                    expectedType: new RListType(new RTypeVariable(new RIntegerType(), new RTypeIntersection())) },
+		{ query: Q.var('l').last().build(),                    expectedType: new RListType(elementType5, new Map([[0, elementType5], [1, elementType5], [2, elementType5]])) },
 		{ query: Q.all().filter(RType.Access).first().build(), lowerBound: new RIntegerType() },
 	);
 	
+	const elementType6 = new RTypeVariable(new RTypeUnion(new RIntegerType(), new RNullType()), new RTypeIntersection());
+	// eslint-disable-next-line @typescript-eslint/naming-convention
+	const elementType6_0 = new RTypeVariable(new RLogicalType(), new RTypeIntersection());
+	// eslint-disable-next-line @typescript-eslint/naming-convention
+	const elementType6_1 = new RTypeVariable(new RIntegerType(), new RTypeIntersection());
+	// eslint-disable-next-line @typescript-eslint/naming-convention
+	const elementType6_2 = new RTypeVariable(new RNullType(), new RTypeIntersection());
 	assertInferredTypes(
 		'l <- list(TRUE, a = 42, NULL); l$a',
-		{ query: Q.var('l').last().build(),                    expectedType: new RListType(new RTypeVariable(new RTypeUnion(new RIntegerType(), new RNullType()), new RTypeIntersection())) },
+		{ query: Q.var('l').last().build(),                    expectedType: new RListType(elementType6, new Map<number | string, DataType>([[0, elementType6_0], [1, elementType6_1], [2, elementType6_2], ['a', elementType6_1]])) },
 		{ query: Q.all().filter(RType.Access).first().build(), lowerBound: new RTypeUnion(new RIntegerType(), new RNullType()), upperBound: new RTypeIntersection() },
 	);
 });
\ No newline at end of file

From e229b7857b25d501b7744ba0cbf0918816850ded Mon Sep 17 00:00:00 2001
From: Lukas Rohde <lukas.rohde@silupe.de>
Date: Tue, 15 Jul 2025 15:10:06 +0200
Subject: [PATCH 095/153] refactor(typing): change project structure

---
 .../datatype-query/datatype-query-executor.ts |  2 +-
 .../datatype-query/datatype-query-format.ts   |  2 +-
 src/queries/query-print.ts                    |  2 +-
 src/typing/base-types.ts                      |  2 +-
 src/{ => typing}/subtyping/infer.ts           | 46 +++++++++----------
 src/{ => typing}/subtyping/types.ts           |  2 +-
 src/typing/{ => unification}/infer.ts         | 46 +++++++++----------
 src/typing/{ => unification}/types.ts         |  0
 .../_helper/subtyping/assert-inferred-type.ts |  6 +--
 .../_helper/typing/assert-inferred-type.ts    |  4 +-
 .../subtyping/builtin-functions.test.ts       |  2 +-
 .../subtyping/conditionals.test.ts            |  2 +-
 .../functionality/subtyping/constants.test.ts |  2 +-
 .../functionality/subtyping/constrain.test.ts |  2 +-
 test/functionality/subtyping/loops.test.ts    |  2 +-
 .../subtyping/subsetting.test.ts              |  4 +-
 .../subtyping/unsupported-expressions.test.ts |  2 +-
 .../functionality/subtyping/variables.test.ts |  2 +-
 .../typing/builtin-functions.test.ts          |  2 +-
 .../functionality/typing/conditionals.test.ts |  2 +-
 test/functionality/typing/constants.test.ts   |  2 +-
 test/functionality/typing/loops.test.ts       |  2 +-
 test/functionality/typing/subsetting.test.ts  |  2 +-
 .../typing/unsupported-expressions.test.ts    |  2 +-
 test/functionality/typing/variables.test.ts   |  2 +-
 25 files changed, 72 insertions(+), 72 deletions(-)
 rename src/{ => typing}/subtyping/infer.ts (92%)
 rename src/{ => typing}/subtyping/types.ts (99%)
 rename src/typing/{ => unification}/infer.ts (91%)
 rename src/typing/{ => unification}/types.ts (100%)

diff --git a/src/queries/catalog/datatype-query/datatype-query-executor.ts b/src/queries/catalog/datatype-query/datatype-query-executor.ts
index a6739d0d225..d9652b2a9d3 100644
--- a/src/queries/catalog/datatype-query/datatype-query-executor.ts
+++ b/src/queries/catalog/datatype-query/datatype-query-executor.ts
@@ -3,7 +3,7 @@ import { log } from '../../../util/log';
 import type { BasicQueryData } from '../../base-query-format';
 import type { NormalizedAst, ParentInformation } from '../../../r-bridge/lang-4.x/ast/model/processing/decorate';
 import { slicingCriterionToId } from '../../../slicing/criterion/parse';
-import { inferDataTypes } from '../../../typing/infer';
+import { inferDataTypes } from '../../../typing/unification/infer';
 
 export function executeDatatypeQuery({ dataflow, ast }: BasicQueryData, queries: readonly DatatypeQuery[]): DatatypeQueryResult {
 	const start = Date.now();
diff --git a/src/queries/catalog/datatype-query/datatype-query-format.ts b/src/queries/catalog/datatype-query/datatype-query-format.ts
index 1254ef03fc2..7a9bc214e2b 100644
--- a/src/queries/catalog/datatype-query/datatype-query-format.ts
+++ b/src/queries/catalog/datatype-query/datatype-query-format.ts
@@ -7,7 +7,7 @@ import Joi from 'joi';
 import { executeDatatypeQuery } from './datatype-query-executor';
 
 import { asciiDataType } from '../../query-print';
-import type { RDataType } from '../../../typing/types';
+import type { RDataType } from '../../../typing/unification/types';
 
 /**
  * Calculates the inferred data type for the given criterion.
diff --git a/src/queries/query-print.ts b/src/queries/query-print.ts
index fef054b7fa0..57316640e3c 100644
--- a/src/queries/query-print.ts
+++ b/src/queries/query-print.ts
@@ -10,7 +10,7 @@ import type { CallContextQuerySubKindResult } from './catalog/call-context-query
 import type { BaseQueryMeta, BaseQueryResult } from './base-query-format';
 import { printAsMs } from '../util/text/time';
 import { isBuiltIn } from '../dataflow/environments/built-in';
-import { RDataTypeTag, type RDataType } from '../typing/types';
+import { RDataTypeTag, type RDataType } from '../typing/unification/types';
 
 function nodeString(nodeId: NodeId | { id: NodeId, info?: object}, formatter: OutputFormatter, processed: PipelineOutput<typeof DEFAULT_DATAFLOW_PIPELINE>): string {
 	const isObj = typeof nodeId === 'object' && nodeId !== null && 'id' in nodeId;
diff --git a/src/typing/base-types.ts b/src/typing/base-types.ts
index e1eda3caa32..cb500a36dea 100644
--- a/src/typing/base-types.ts
+++ b/src/typing/base-types.ts
@@ -1,4 +1,4 @@
-import { RDataTypeTag } from './types';
+import { RDataTypeTag } from './unification/types';
 
 /* eslint-disable @typescript-eslint/naming-convention */
 export enum RBaseType {
diff --git a/src/subtyping/infer.ts b/src/typing/subtyping/infer.ts
similarity index 92%
rename from src/subtyping/infer.ts
rename to src/typing/subtyping/infer.ts
index f6902546bdc..74710407c3d 100644
--- a/src/subtyping/infer.ts
+++ b/src/typing/subtyping/infer.ts
@@ -1,28 +1,28 @@
-import { extractCfg } from '../control-flow/extract-cfg';
-import type { SemanticCfgGuidedVisitorConfiguration } from '../control-flow/semantic-cfg-guided-visitor';
-import { SemanticCfgGuidedVisitor } from '../control-flow/semantic-cfg-guided-visitor';
-import type { DataflowGraphVertexFunctionCall, DataflowGraphVertexFunctionDefinition, DataflowGraphVertexUse, DataflowGraphVertexValue } from '../dataflow/graph/vertex';
-import type { DataflowInformation } from '../dataflow/info';
-import type { RLogical } from '../r-bridge/lang-4.x/ast/model/nodes/r-logical';
-import type { RNumber } from '../r-bridge/lang-4.x/ast/model/nodes/r-number';
-import type { RString } from '../r-bridge/lang-4.x/ast/model/nodes/r-string';
-import type { NormalizedAst, ParentInformation } from '../r-bridge/lang-4.x/ast/model/processing/decorate';
-import { mapNormalizedAstInfo } from '../r-bridge/lang-4.x/ast/model/processing/decorate';
+import { extractCfg } from '../../control-flow/extract-cfg';
+import type { SemanticCfgGuidedVisitorConfiguration } from '../../control-flow/semantic-cfg-guided-visitor';
+import { SemanticCfgGuidedVisitor } from '../../control-flow/semantic-cfg-guided-visitor';
+import type { DataflowGraphVertexFunctionCall, DataflowGraphVertexFunctionDefinition, DataflowGraphVertexUse, DataflowGraphVertexValue } from '../../dataflow/graph/vertex';
+import type { DataflowInformation } from '../../dataflow/info';
+import type { RLogical } from '../../r-bridge/lang-4.x/ast/model/nodes/r-logical';
+import type { RNumber } from '../../r-bridge/lang-4.x/ast/model/nodes/r-number';
+import type { RString } from '../../r-bridge/lang-4.x/ast/model/nodes/r-string';
+import type { NormalizedAst, ParentInformation } from '../../r-bridge/lang-4.x/ast/model/processing/decorate';
+import { mapNormalizedAstInfo } from '../../r-bridge/lang-4.x/ast/model/processing/decorate';
 import type { DataType, UnresolvedDataType } from './types';
 import { UnresolvedRTypeVariable, RComplexType, RDoubleType, RIntegerType, RLogicalType, RStringType, resolveType, RNullType, UnresolvedRListType, RLanguageType, UnresolvedRFunctionType, UnresolvedRAtomicVectorType, UnresolvedRTypeUnion } from './types';
-import type { RExpressionList } from '../r-bridge/lang-4.x/ast/model/nodes/r-expression-list';
-import { guard } from '../util/assert';
-import { OriginType } from '../dataflow/origin/dfg-get-origin';
-import type { NodeId } from '../r-bridge/lang-4.x/ast/model/processing/node-id';
-import { edgeIncludesType, EdgeType } from '../dataflow/graph/edge';
-import { EmptyArgument } from '../r-bridge/lang-4.x/ast/model/nodes/r-function-call';
-import type { FunctionArgument } from '../dataflow/graph/graph';
-import type { ControlFlowInformation } from '../control-flow/control-flow-graph';
-import { CfgEdgeType, CfgVertexType } from '../control-flow/control-flow-graph';
-import type { RSymbol } from '../r-bridge/lang-4.x/ast/model/nodes/r-symbol';
-import { RType } from '../r-bridge/lang-4.x/ast/model/type';
-import type { NoInfo } from '../r-bridge/lang-4.x/ast/model/model';
-import { RFalse, RTrue } from '../r-bridge/lang-4.x/convert-values';
+import type { RExpressionList } from '../../r-bridge/lang-4.x/ast/model/nodes/r-expression-list';
+import { guard } from '../../util/assert';
+import { OriginType } from '../../dataflow/origin/dfg-get-origin';
+import type { NodeId } from '../../r-bridge/lang-4.x/ast/model/processing/node-id';
+import { edgeIncludesType, EdgeType } from '../../dataflow/graph/edge';
+import { EmptyArgument } from '../../r-bridge/lang-4.x/ast/model/nodes/r-function-call';
+import type { FunctionArgument } from '../../dataflow/graph/graph';
+import type { ControlFlowInformation } from '../../control-flow/control-flow-graph';
+import { CfgEdgeType, CfgVertexType } from '../../control-flow/control-flow-graph';
+import type { RSymbol } from '../../r-bridge/lang-4.x/ast/model/nodes/r-symbol';
+import { RType } from '../../r-bridge/lang-4.x/ast/model/type';
+import type { NoInfo } from '../../r-bridge/lang-4.x/ast/model/model';
+import { RFalse, RTrue } from '../../r-bridge/lang-4.x/convert-values';
 
 export function inferDataTypes<Info extends ParentInformation & { typeVariable?: undefined }>(ast: NormalizedAst<ParentInformation & Info>, dataflowInfo: DataflowInformation): NormalizedAst<Info & DataTypeInfo> {
 	const astWithTypeVars = decorateTypeVariables(ast);
diff --git a/src/subtyping/types.ts b/src/typing/subtyping/types.ts
similarity index 99%
rename from src/subtyping/types.ts
rename to src/typing/subtyping/types.ts
index ec6871a2c9f..f231f3de61a 100644
--- a/src/subtyping/types.ts
+++ b/src/typing/subtyping/types.ts
@@ -1,4 +1,4 @@
-import { guard } from '../util/assert';
+import { guard } from '../../util/assert';
 
 /**
  * This enum lists a tag for each of the possible R data types inferred by the
diff --git a/src/typing/infer.ts b/src/typing/unification/infer.ts
similarity index 91%
rename from src/typing/infer.ts
rename to src/typing/unification/infer.ts
index af5576e6cce..ba5253ec8f8 100644
--- a/src/typing/infer.ts
+++ b/src/typing/unification/infer.ts
@@ -1,28 +1,28 @@
-import { extractCfg } from '../control-flow/extract-cfg';
-import type { SemanticCfgGuidedVisitorConfiguration } from '../control-flow/semantic-cfg-guided-visitor';
-import { SemanticCfgGuidedVisitor } from '../control-flow/semantic-cfg-guided-visitor';
-import type { DataflowGraphVertexFunctionCall, DataflowGraphVertexFunctionDefinition, DataflowGraphVertexUse, DataflowGraphVertexValue } from '../dataflow/graph/vertex';
-import type { DataflowInformation } from '../dataflow/info';
-import type { RLogical } from '../r-bridge/lang-4.x/ast/model/nodes/r-logical';
-import type { RNumber } from '../r-bridge/lang-4.x/ast/model/nodes/r-number';
-import type { RString } from '../r-bridge/lang-4.x/ast/model/nodes/r-string';
-import type { NormalizedAst, ParentInformation } from '../r-bridge/lang-4.x/ast/model/processing/decorate';
-import { mapNormalizedAstInfo } from '../r-bridge/lang-4.x/ast/model/processing/decorate';
+import { extractCfg } from '../../control-flow/extract-cfg';
+import type { SemanticCfgGuidedVisitorConfiguration } from '../../control-flow/semantic-cfg-guided-visitor';
+import { SemanticCfgGuidedVisitor } from '../../control-flow/semantic-cfg-guided-visitor';
+import type { DataflowGraphVertexFunctionCall, DataflowGraphVertexFunctionDefinition, DataflowGraphVertexUse, DataflowGraphVertexValue } from '../../dataflow/graph/vertex';
+import type { DataflowInformation } from '../../dataflow/info';
+import type { RLogical } from '../../r-bridge/lang-4.x/ast/model/nodes/r-logical';
+import type { RNumber } from '../../r-bridge/lang-4.x/ast/model/nodes/r-number';
+import type { RString } from '../../r-bridge/lang-4.x/ast/model/nodes/r-string';
+import type { NormalizedAst, ParentInformation } from '../../r-bridge/lang-4.x/ast/model/processing/decorate';
+import { mapNormalizedAstInfo } from '../../r-bridge/lang-4.x/ast/model/processing/decorate';
 import type { RDataType } from './types';
 import { RTypeVariable, RComplexType, RDoubleType, RIntegerType, RLogicalType, RStringType, resolveType, RNullType, UnresolvedRListType, RLanguageType, UnresolvedRFunctionType, isVectorType } from './types';
-import type { RExpressionList } from '../r-bridge/lang-4.x/ast/model/nodes/r-expression-list';
-import { guard } from '../util/assert';
-import { OriginType } from '../dataflow/origin/dfg-get-origin';
-import type { NodeId } from '../r-bridge/lang-4.x/ast/model/processing/node-id';
-import { edgeIncludesType, EdgeType } from '../dataflow/graph/edge';
-import { EmptyArgument } from '../r-bridge/lang-4.x/ast/model/nodes/r-function-call';
-import type { FunctionArgument } from '../dataflow/graph/graph';
-import type { ControlFlowInformation } from '../control-flow/control-flow-graph';
-import { CfgEdgeType, CfgVertexType } from '../control-flow/control-flow-graph';
-import type { RSymbol } from '../r-bridge/lang-4.x/ast/model/nodes/r-symbol';
-import { RType } from '../r-bridge/lang-4.x/ast/model/type';
-import type { NoInfo } from '../r-bridge/lang-4.x/ast/model/model';
-import { RFalse, RTrue } from '../r-bridge/lang-4.x/convert-values';
+import type { RExpressionList } from '../../r-bridge/lang-4.x/ast/model/nodes/r-expression-list';
+import { guard } from '../../util/assert';
+import { OriginType } from '../../dataflow/origin/dfg-get-origin';
+import type { NodeId } from '../../r-bridge/lang-4.x/ast/model/processing/node-id';
+import { edgeIncludesType, EdgeType } from '../../dataflow/graph/edge';
+import { EmptyArgument } from '../../r-bridge/lang-4.x/ast/model/nodes/r-function-call';
+import type { FunctionArgument } from '../../dataflow/graph/graph';
+import type { ControlFlowInformation } from '../../control-flow/control-flow-graph';
+import { CfgEdgeType, CfgVertexType } from '../../control-flow/control-flow-graph';
+import type { RSymbol } from '../../r-bridge/lang-4.x/ast/model/nodes/r-symbol';
+import { RType } from '../../r-bridge/lang-4.x/ast/model/type';
+import type { NoInfo } from '../../r-bridge/lang-4.x/ast/model/model';
+import { RFalse, RTrue } from '../../r-bridge/lang-4.x/convert-values';
 
 export function inferDataTypes<Info extends ParentInformation & { typeVariable?: undefined }>(ast: NormalizedAst<ParentInformation & Info>, dataflowInfo: DataflowInformation): NormalizedAst<Info & DataTypeInfo> {
 	const astWithTypeVars = decorateTypeVariables(ast);
diff --git a/src/typing/types.ts b/src/typing/unification/types.ts
similarity index 100%
rename from src/typing/types.ts
rename to src/typing/unification/types.ts
diff --git a/test/functionality/_helper/subtyping/assert-inferred-type.ts b/test/functionality/_helper/subtyping/assert-inferred-type.ts
index 0b5a9d4aa2a..9107bd35d84 100644
--- a/test/functionality/_helper/subtyping/assert-inferred-type.ts
+++ b/test/functionality/_helper/subtyping/assert-inferred-type.ts
@@ -2,9 +2,9 @@ import { describe, expect, test } from 'vitest';
 import { TreeSitterExecutor } from '../../../../src/r-bridge/lang-4.x/tree-sitter/tree-sitter-executor';
 import { createDataflowPipeline } from '../../../../src/core/steps/pipeline/default-pipelines';
 import { requestFromInput } from '../../../../src/r-bridge/retriever';
-import { RTypeIntersection, RTypeUnion, RTypeVariable, type DataType } from '../../../../src/subtyping/types';
-import type { DataTypeInfo } from '../../../../src/subtyping/infer';
-import { inferDataTypes } from '../../../../src/subtyping/infer';
+import { RTypeIntersection, RTypeUnion, RTypeVariable, type DataType } from '../../../../src/typing/subtyping/types';
+import type { DataTypeInfo } from '../../../../src/typing/subtyping/infer';
+import { inferDataTypes } from '../../../../src/typing/subtyping/infer';
 import { type FlowrSearch } from '../../../../src/search/flowr-search-builder';
 import { runSearch } from '../../../../src/search/flowr-search-executor';
 import type { ParentInformation } from '../../../../src/r-bridge/lang-4.x/ast/model/processing/decorate';
diff --git a/test/functionality/_helper/typing/assert-inferred-type.ts b/test/functionality/_helper/typing/assert-inferred-type.ts
index 368808eb3da..cec8098fda2 100644
--- a/test/functionality/_helper/typing/assert-inferred-type.ts
+++ b/test/functionality/_helper/typing/assert-inferred-type.ts
@@ -2,8 +2,8 @@ import { describe, expect, test } from 'vitest';
 import { TreeSitterExecutor } from '../../../../src/r-bridge/lang-4.x/tree-sitter/tree-sitter-executor';
 import { createDataflowPipeline } from '../../../../src/core/steps/pipeline/default-pipelines';
 import { requestFromInput } from '../../../../src/r-bridge/retriever';
-import type { RDataType } from '../../../../src/typing/types';
-import { inferDataTypes } from '../../../../src/typing/infer';
+import type { RDataType } from '../../../../src/typing/unification/types';
+import { inferDataTypes } from '../../../../src/typing/unification/infer';
 import type { FlowrSearch } from '../../../../src/search/flowr-search-builder';
 import { runSearch } from '../../../../src/search/flowr-search-executor';
 
diff --git a/test/functionality/subtyping/builtin-functions.test.ts b/test/functionality/subtyping/builtin-functions.test.ts
index 90f7c1ed9b9..ccebc83dd84 100644
--- a/test/functionality/subtyping/builtin-functions.test.ts
+++ b/test/functionality/subtyping/builtin-functions.test.ts
@@ -1,5 +1,5 @@
 import { describe } from 'vitest';
-import { RTypeIntersection, RIntegerType, RLanguageType, RListType, RLogicalType, RTypeUnion, RNullType, RStringType, RTypeVariable, RAtomicVectorType } from '../../../src/subtyping/types';
+import { RTypeIntersection, RIntegerType, RLanguageType, RListType, RLogicalType, RTypeUnion, RNullType, RStringType, RTypeVariable, RAtomicVectorType } from '../../../src/typing/subtyping/types';
 import { assertInferredType, assertInferredTypes } from '../_helper/subtyping/assert-inferred-type';
 import { Q } from '../../../src/search/flowr-search-builder';
 
diff --git a/test/functionality/subtyping/conditionals.test.ts b/test/functionality/subtyping/conditionals.test.ts
index 1b5a7b20c7c..b0f1cbfca8d 100644
--- a/test/functionality/subtyping/conditionals.test.ts
+++ b/test/functionality/subtyping/conditionals.test.ts
@@ -1,5 +1,5 @@
 import { describe } from 'vitest';
-import { RLogicalType, RTypeUnion, RNullType, RStringType } from '../../../src/subtyping/types';
+import { RLogicalType, RTypeUnion, RNullType, RStringType } from '../../../src/typing/subtyping/types';
 import { assertInferredType, assertInferredTypes } from '../_helper/subtyping/assert-inferred-type';
 import { Q } from '../../../src/search/flowr-search-builder';
 import { RType } from '../../../src/r-bridge/lang-4.x/ast/model/type';
diff --git a/test/functionality/subtyping/constants.test.ts b/test/functionality/subtyping/constants.test.ts
index d4a16ad1afd..7fc97fc4b51 100644
--- a/test/functionality/subtyping/constants.test.ts
+++ b/test/functionality/subtyping/constants.test.ts
@@ -1,5 +1,5 @@
 import { describe } from 'vitest';
-import { RComplexType, RDoubleType, RIntegerType, RLogicalType, RNullType, RStringType } from '../../../src/subtyping/types';
+import { RComplexType, RDoubleType, RIntegerType, RLogicalType, RNullType, RStringType } from '../../../src/typing/subtyping/types';
 import { assertInferredType } from '../_helper/subtyping/assert-inferred-type';
 
 describe('Infer types for constants', () => {
diff --git a/test/functionality/subtyping/constrain.test.ts b/test/functionality/subtyping/constrain.test.ts
index 4eaf8f8fbdf..4595431a288 100644
--- a/test/functionality/subtyping/constrain.test.ts
+++ b/test/functionality/subtyping/constrain.test.ts
@@ -1,5 +1,5 @@
 import { describe, expect, test } from 'vitest';
-import { constrainWithLowerBound, constrainWithUpperBound, RComplexType, RDoubleType, resolveType, RIntegerType, RListType, RStringType, RTypeIntersection, RTypeVariable, UnresolvedRAtomicVectorType, UnresolvedRFunctionType, UnresolvedRListType, UnresolvedRTypeIntersection, UnresolvedRTypeUnion, UnresolvedRTypeVariable } from '../../../src/subtyping/types';
+import { constrainWithLowerBound, constrainWithUpperBound, RComplexType, RDoubleType, resolveType, RIntegerType, RListType, RStringType, RTypeIntersection, RTypeVariable, UnresolvedRAtomicVectorType, UnresolvedRFunctionType, UnresolvedRListType, UnresolvedRTypeIntersection, UnresolvedRTypeUnion, UnresolvedRTypeVariable } from '../../../src/typing/subtyping/types';
 
 describe('Constrain types with lower and upper bounds', () => {
 	test('Constrain with numeric bounds', () => {
diff --git a/test/functionality/subtyping/loops.test.ts b/test/functionality/subtyping/loops.test.ts
index fee0208ab9b..3f614c5c2e4 100644
--- a/test/functionality/subtyping/loops.test.ts
+++ b/test/functionality/subtyping/loops.test.ts
@@ -1,5 +1,5 @@
 import { describe } from 'vitest';
-import { RLogicalType, RTypeUnion, RNullType } from '../../../src/subtyping/types';
+import { RLogicalType, RTypeUnion, RNullType } from '../../../src/typing/subtyping/types';
 import { assertInferredType, assertInferredTypes } from '../_helper/subtyping/assert-inferred-type';
 import { Q } from '../../../src/search/flowr-search-builder';
 import { RType } from '../../../src/r-bridge/lang-4.x/ast/model/type';
diff --git a/test/functionality/subtyping/subsetting.test.ts b/test/functionality/subtyping/subsetting.test.ts
index 412bdf49eec..2dc8e864a44 100644
--- a/test/functionality/subtyping/subsetting.test.ts
+++ b/test/functionality/subtyping/subsetting.test.ts
@@ -1,6 +1,6 @@
 import { describe } from 'vitest';
-import type { DataType } from '../../../src/subtyping/types';
-import { RTypeIntersection, RAtomicVectorType, RIntegerType, RListType, RTypeVariable, RTypeUnion, RNullType, RLogicalType } from '../../../src/subtyping/types';
+import type { DataType } from '../../../src/typing/subtyping/types';
+import { RTypeIntersection, RAtomicVectorType, RIntegerType, RListType, RTypeVariable, RTypeUnion, RNullType, RLogicalType } from '../../../src/typing/subtyping/types';
 import { assertInferredTypes } from '../_helper/subtyping/assert-inferred-type';
 import { Q } from '../../../src/search/flowr-search-builder';
 import { RType } from '../../../src/r-bridge/lang-4.x/ast/model/type';
diff --git a/test/functionality/subtyping/unsupported-expressions.test.ts b/test/functionality/subtyping/unsupported-expressions.test.ts
index a0965700b3d..0a40ad36bed 100644
--- a/test/functionality/subtyping/unsupported-expressions.test.ts
+++ b/test/functionality/subtyping/unsupported-expressions.test.ts
@@ -1,5 +1,5 @@
 import { describe } from 'vitest';
-import { RTypeIntersection, RTypeUnion, RTypeVariable } from '../../../src/subtyping/types';
+import { RTypeIntersection, RTypeUnion, RTypeVariable } from '../../../src/typing/subtyping/types';
 import { assertInferredType } from '../_helper/subtyping/assert-inferred-type';
 
 describe('Infer no type information for currently unsupported R expressions', () => {
diff --git a/test/functionality/subtyping/variables.test.ts b/test/functionality/subtyping/variables.test.ts
index c791315219f..8ee2dbe72d4 100644
--- a/test/functionality/subtyping/variables.test.ts
+++ b/test/functionality/subtyping/variables.test.ts
@@ -1,5 +1,5 @@
 import { describe } from 'vitest';
-import { RIntegerType } from '../../../src/subtyping/types';
+import { RIntegerType } from '../../../src/typing/subtyping/types';
 import { assertInferredTypes } from '../_helper/subtyping/assert-inferred-type';
 import { Q } from '../../../src/search/flowr-search-builder';
 
diff --git a/test/functionality/typing/builtin-functions.test.ts b/test/functionality/typing/builtin-functions.test.ts
index d8b97d6f720..e57163bbe2f 100644
--- a/test/functionality/typing/builtin-functions.test.ts
+++ b/test/functionality/typing/builtin-functions.test.ts
@@ -1,5 +1,5 @@
 import { describe } from 'vitest';
-import { RDoubleType, RLanguageType, RListType, RLogicalType, RNullType, RStringType, RUnknownType } from '../../../src/typing/types';
+import { RDoubleType, RLanguageType, RListType, RLogicalType, RNullType, RStringType, RUnknownType } from '../../../src/typing/unification/types';
 import { assertInferredType, assertInferredTypes } from '../_helper/typing/assert-inferred-type';
 import { Q } from '../../../src/search/flowr-search-builder';
 
diff --git a/test/functionality/typing/conditionals.test.ts b/test/functionality/typing/conditionals.test.ts
index d509da47843..dfbf6e27af6 100644
--- a/test/functionality/typing/conditionals.test.ts
+++ b/test/functionality/typing/conditionals.test.ts
@@ -1,5 +1,5 @@
 import { describe } from 'vitest';
-import { RDoubleType, RLogicalType, RNullType, RStringType, RUnknownType } from '../../../src/typing/types';
+import { RDoubleType, RLogicalType, RNullType, RStringType, RUnknownType } from '../../../src/typing/unification/types';
 import { assertInferredType, assertInferredTypes } from '../_helper/typing/assert-inferred-type';
 import { Q } from '../../../src/search/flowr-search-builder';
 import { RType } from '../../../src/r-bridge/lang-4.x/ast/model/type';
diff --git a/test/functionality/typing/constants.test.ts b/test/functionality/typing/constants.test.ts
index 4f8bad33046..97835e4cb89 100644
--- a/test/functionality/typing/constants.test.ts
+++ b/test/functionality/typing/constants.test.ts
@@ -1,5 +1,5 @@
 import { describe } from 'vitest';
-import { RComplexType, RDoubleType, RIntegerType, RLogicalType, RNullType, RStringType } from '../../../src/typing/types';
+import { RComplexType, RDoubleType, RIntegerType, RLogicalType, RNullType, RStringType } from '../../../src/typing/unification/types';
 import { assertInferredType } from '../_helper/typing/assert-inferred-type';
 
 describe.each([
diff --git a/test/functionality/typing/loops.test.ts b/test/functionality/typing/loops.test.ts
index d65b9ce0f49..b3e8d247dc8 100644
--- a/test/functionality/typing/loops.test.ts
+++ b/test/functionality/typing/loops.test.ts
@@ -1,5 +1,5 @@
 import { describe } from 'vitest';
-import { RLogicalType, RNullType, RUnknownType } from '../../../src/typing/types';
+import { RLogicalType, RNullType, RUnknownType } from '../../../src/typing/unification/types';
 import { assertInferredType, assertInferredTypes } from '../_helper/typing/assert-inferred-type';
 import { Q } from '../../../src/search/flowr-search-builder';
 import { RType } from '../../../src/r-bridge/lang-4.x/ast/model/type';
diff --git a/test/functionality/typing/subsetting.test.ts b/test/functionality/typing/subsetting.test.ts
index 49c18711b05..6c61cd20fbb 100644
--- a/test/functionality/typing/subsetting.test.ts
+++ b/test/functionality/typing/subsetting.test.ts
@@ -1,5 +1,5 @@
 import { describe } from 'vitest';
-import { RDoubleType, RErrorType, RListType, RLogicalType, RNullType } from '../../../src/typing/types';
+import { RDoubleType, RErrorType, RListType, RLogicalType, RNullType } from '../../../src/typing/unification/types';
 import { assertInferredTypes } from '../_helper/typing/assert-inferred-type';
 import { Q } from '../../../src/search/flowr-search-builder';
 import { RType } from '../../../src/r-bridge/lang-4.x/ast/model/type';
diff --git a/test/functionality/typing/unsupported-expressions.test.ts b/test/functionality/typing/unsupported-expressions.test.ts
index 88520d93483..0beedf03666 100644
--- a/test/functionality/typing/unsupported-expressions.test.ts
+++ b/test/functionality/typing/unsupported-expressions.test.ts
@@ -1,5 +1,5 @@
 import { describe } from 'vitest';
-import { RUnknownType } from '../../../src/typing/types';
+import { RUnknownType } from '../../../src/typing/unification/types';
 import { assertInferredType } from '../_helper/typing/assert-inferred-type';
 
 describe('Infer no type information for currently unsupported R expressions', () => {
diff --git a/test/functionality/typing/variables.test.ts b/test/functionality/typing/variables.test.ts
index 212ffb6467e..249e75ad2ea 100644
--- a/test/functionality/typing/variables.test.ts
+++ b/test/functionality/typing/variables.test.ts
@@ -1,5 +1,5 @@
 import { describe } from 'vitest';
-import { RDoubleType } from '../../../src/typing/types';
+import { RDoubleType } from '../../../src/typing/unification/types';
 import { assertInferredTypes } from '../_helper/typing/assert-inferred-type';
 import { Q } from '../../../src/search/flowr-search-builder';
 

From f6fbdf4d75e84de587744888ca3a130109a02199 Mon Sep 17 00:00:00 2001
From: Lukas Rohde <lukas.rohde@silupe.de>
Date: Tue, 15 Jul 2025 15:17:30 +0200
Subject: [PATCH 096/153] refactor(typing): change test file organization

---
 .../subtyping/assert-inferred-type.ts         | 20 +++++++++----------
 .../{ => unification}/assert-inferred-type.ts | 14 ++++++-------
 .../subtyping/builtin-functions.test.ts       |  6 +++---
 .../subtyping/conditionals.test.ts            |  8 ++++----
 .../{ => typing}/subtyping/constants.test.ts  |  4 ++--
 .../{ => typing}/subtyping/constrain.test.ts  |  2 +-
 .../{ => typing}/subtyping/loops.test.ts      |  8 ++++----
 .../{ => typing}/subtyping/subsetting.test.ts | 10 +++++-----
 .../subtyping/unsupported-expressions.test.ts |  4 ++--
 .../{ => typing}/subtyping/variables.test.ts  |  6 +++---
 .../builtin-functions.test.ts                 |  6 +++---
 .../{ => unification}/conditionals.test.ts    |  8 ++++----
 .../{ => unification}/constants.test.ts       |  4 ++--
 .../typing/{ => unification}/loops.test.ts    |  8 ++++----
 .../{ => unification}/subsetting.test.ts      |  8 ++++----
 .../unsupported-expressions.test.ts           |  4 ++--
 .../{ => unification}/variables.test.ts       |  6 +++---
 17 files changed, 63 insertions(+), 63 deletions(-)
 rename test/functionality/_helper/{ => typing}/subtyping/assert-inferred-type.ts (66%)
 rename test/functionality/_helper/typing/{ => unification}/assert-inferred-type.ts (68%)
 rename test/functionality/{ => typing}/subtyping/builtin-functions.test.ts (84%)
 rename test/functionality/{ => typing}/subtyping/conditionals.test.ts (73%)
 rename test/functionality/{ => typing}/subtyping/constants.test.ts (88%)
 rename test/functionality/{ => typing}/subtyping/constrain.test.ts (99%)
 rename test/functionality/{ => typing}/subtyping/loops.test.ts (78%)
 rename test/functionality/{ => typing}/subtyping/subsetting.test.ts (92%)
 rename test/functionality/{ => typing}/subtyping/unsupported-expressions.test.ts (75%)
 rename test/functionality/{ => typing}/subtyping/variables.test.ts (60%)
 rename test/functionality/typing/{ => unification}/builtin-functions.test.ts (80%)
 rename test/functionality/typing/{ => unification}/conditionals.test.ts (72%)
 rename test/functionality/typing/{ => unification}/constants.test.ts (87%)
 rename test/functionality/typing/{ => unification}/loops.test.ts (82%)
 rename test/functionality/typing/{ => unification}/subsetting.test.ts (89%)
 rename test/functionality/typing/{ => unification}/unsupported-expressions.test.ts (61%)
 rename test/functionality/typing/{ => unification}/variables.test.ts (60%)

diff --git a/test/functionality/_helper/subtyping/assert-inferred-type.ts b/test/functionality/_helper/typing/subtyping/assert-inferred-type.ts
similarity index 66%
rename from test/functionality/_helper/subtyping/assert-inferred-type.ts
rename to test/functionality/_helper/typing/subtyping/assert-inferred-type.ts
index 9107bd35d84..9c6febc5715 100644
--- a/test/functionality/_helper/subtyping/assert-inferred-type.ts
+++ b/test/functionality/_helper/typing/subtyping/assert-inferred-type.ts
@@ -1,14 +1,14 @@
 import { describe, expect, test } from 'vitest';
-import { TreeSitterExecutor } from '../../../../src/r-bridge/lang-4.x/tree-sitter/tree-sitter-executor';
-import { createDataflowPipeline } from '../../../../src/core/steps/pipeline/default-pipelines';
-import { requestFromInput } from '../../../../src/r-bridge/retriever';
-import { RTypeIntersection, RTypeUnion, RTypeVariable, type DataType } from '../../../../src/typing/subtyping/types';
-import type { DataTypeInfo } from '../../../../src/typing/subtyping/infer';
-import { inferDataTypes } from '../../../../src/typing/subtyping/infer';
-import { type FlowrSearch } from '../../../../src/search/flowr-search-builder';
-import { runSearch } from '../../../../src/search/flowr-search-executor';
-import type { ParentInformation } from '../../../../src/r-bridge/lang-4.x/ast/model/processing/decorate';
-import type { RNode } from '../../../../src/r-bridge/lang-4.x/ast/model/model';
+import { TreeSitterExecutor } from '../../../../../src/r-bridge/lang-4.x/tree-sitter/tree-sitter-executor';
+import { createDataflowPipeline } from '../../../../../src/core/steps/pipeline/default-pipelines';
+import { requestFromInput } from '../../../../../src/r-bridge/retriever';
+import { RTypeIntersection, RTypeUnion, RTypeVariable, type DataType } from '../../../../../src/typing/subtyping/types';
+import type { DataTypeInfo } from '../../../../../src/typing/subtyping/infer';
+import { inferDataTypes } from '../../../../../src/typing/subtyping/infer';
+import { type FlowrSearch } from '../../../../../src/search/flowr-search-builder';
+import { runSearch } from '../../../../../src/search/flowr-search-executor';
+import type { ParentInformation } from '../../../../../src/r-bridge/lang-4.x/ast/model/processing/decorate';
+import type { RNode } from '../../../../../src/r-bridge/lang-4.x/ast/model/model';
 
 export function assertInferredType(input: string, expectedType: { expectedType: DataType } | { lowerBound?: DataType, upperBound?: DataType }): void {
 	assertInferredTypes(input, expectedType);
diff --git a/test/functionality/_helper/typing/assert-inferred-type.ts b/test/functionality/_helper/typing/unification/assert-inferred-type.ts
similarity index 68%
rename from test/functionality/_helper/typing/assert-inferred-type.ts
rename to test/functionality/_helper/typing/unification/assert-inferred-type.ts
index cec8098fda2..463a497e2b9 100644
--- a/test/functionality/_helper/typing/assert-inferred-type.ts
+++ b/test/functionality/_helper/typing/unification/assert-inferred-type.ts
@@ -1,11 +1,11 @@
 import { describe, expect, test } from 'vitest';
-import { TreeSitterExecutor } from '../../../../src/r-bridge/lang-4.x/tree-sitter/tree-sitter-executor';
-import { createDataflowPipeline } from '../../../../src/core/steps/pipeline/default-pipelines';
-import { requestFromInput } from '../../../../src/r-bridge/retriever';
-import type { RDataType } from '../../../../src/typing/unification/types';
-import { inferDataTypes } from '../../../../src/typing/unification/infer';
-import type { FlowrSearch } from '../../../../src/search/flowr-search-builder';
-import { runSearch } from '../../../../src/search/flowr-search-executor';
+import { TreeSitterExecutor } from '../../../../../src/r-bridge/lang-4.x/tree-sitter/tree-sitter-executor';
+import { createDataflowPipeline } from '../../../../../src/core/steps/pipeline/default-pipelines';
+import { requestFromInput } from '../../../../../src/r-bridge/retriever';
+import type { RDataType } from '../../../../../src/typing/unification/types';
+import { inferDataTypes } from '../../../../../src/typing/unification/infer';
+import type { FlowrSearch } from '../../../../../src/search/flowr-search-builder';
+import { runSearch } from '../../../../../src/search/flowr-search-executor';
 
 export function assertInferredType(input: string, expectedType: RDataType): void {
 	test(`Infer ${expectedType.tag} for ${input}`, async() => {
diff --git a/test/functionality/subtyping/builtin-functions.test.ts b/test/functionality/typing/subtyping/builtin-functions.test.ts
similarity index 84%
rename from test/functionality/subtyping/builtin-functions.test.ts
rename to test/functionality/typing/subtyping/builtin-functions.test.ts
index ccebc83dd84..7a7004d86ad 100644
--- a/test/functionality/subtyping/builtin-functions.test.ts
+++ b/test/functionality/typing/subtyping/builtin-functions.test.ts
@@ -1,7 +1,7 @@
 import { describe } from 'vitest';
-import { RTypeIntersection, RIntegerType, RLanguageType, RListType, RLogicalType, RTypeUnion, RNullType, RStringType, RTypeVariable, RAtomicVectorType } from '../../../src/typing/subtyping/types';
-import { assertInferredType, assertInferredTypes } from '../_helper/subtyping/assert-inferred-type';
-import { Q } from '../../../src/search/flowr-search-builder';
+import { RTypeIntersection, RIntegerType, RLanguageType, RListType, RLogicalType, RTypeUnion, RNullType, RStringType, RTypeVariable, RAtomicVectorType } from '../../../../src/typing/subtyping/types';
+import { assertInferredType, assertInferredTypes } from '../../_helper/typing/subtyping/assert-inferred-type';
+import { Q } from '../../../../src/search/flowr-search-builder';
 
 describe('Infer types for builtin functions', () => {
 	assertInferredType('rm(x)', { expectedType: new RNullType() });
diff --git a/test/functionality/subtyping/conditionals.test.ts b/test/functionality/typing/subtyping/conditionals.test.ts
similarity index 73%
rename from test/functionality/subtyping/conditionals.test.ts
rename to test/functionality/typing/subtyping/conditionals.test.ts
index b0f1cbfca8d..f7c49366e4b 100644
--- a/test/functionality/subtyping/conditionals.test.ts
+++ b/test/functionality/typing/subtyping/conditionals.test.ts
@@ -1,8 +1,8 @@
 import { describe } from 'vitest';
-import { RLogicalType, RTypeUnion, RNullType, RStringType } from '../../../src/typing/subtyping/types';
-import { assertInferredType, assertInferredTypes } from '../_helper/subtyping/assert-inferred-type';
-import { Q } from '../../../src/search/flowr-search-builder';
-import { RType } from '../../../src/r-bridge/lang-4.x/ast/model/type';
+import { RLogicalType, RTypeUnion, RNullType, RStringType } from '../../../../src/typing/subtyping/types';
+import { assertInferredType, assertInferredTypes } from '../../_helper/typing/subtyping/assert-inferred-type';
+import { Q } from '../../../../src/search/flowr-search-builder';
+import { RType } from '../../../../src/r-bridge/lang-4.x/ast/model/type';
 
 describe('Infer types for if statements', () => {
 	describe.each([
diff --git a/test/functionality/subtyping/constants.test.ts b/test/functionality/typing/subtyping/constants.test.ts
similarity index 88%
rename from test/functionality/subtyping/constants.test.ts
rename to test/functionality/typing/subtyping/constants.test.ts
index 7fc97fc4b51..f8fbf568597 100644
--- a/test/functionality/subtyping/constants.test.ts
+++ b/test/functionality/typing/subtyping/constants.test.ts
@@ -1,6 +1,6 @@
 import { describe } from 'vitest';
-import { RComplexType, RDoubleType, RIntegerType, RLogicalType, RNullType, RStringType } from '../../../src/typing/subtyping/types';
-import { assertInferredType } from '../_helper/subtyping/assert-inferred-type';
+import { RComplexType, RDoubleType, RIntegerType, RLogicalType, RNullType, RStringType } from '../../../../src/typing/subtyping/types';
+import { assertInferredType } from '../../_helper/typing/subtyping/assert-inferred-type';
 
 describe('Infer types for constants', () => {
 	describe.each([
diff --git a/test/functionality/subtyping/constrain.test.ts b/test/functionality/typing/subtyping/constrain.test.ts
similarity index 99%
rename from test/functionality/subtyping/constrain.test.ts
rename to test/functionality/typing/subtyping/constrain.test.ts
index 4595431a288..bfd21e63d46 100644
--- a/test/functionality/subtyping/constrain.test.ts
+++ b/test/functionality/typing/subtyping/constrain.test.ts
@@ -1,5 +1,5 @@
 import { describe, expect, test } from 'vitest';
-import { constrainWithLowerBound, constrainWithUpperBound, RComplexType, RDoubleType, resolveType, RIntegerType, RListType, RStringType, RTypeIntersection, RTypeVariable, UnresolvedRAtomicVectorType, UnresolvedRFunctionType, UnresolvedRListType, UnresolvedRTypeIntersection, UnresolvedRTypeUnion, UnresolvedRTypeVariable } from '../../../src/typing/subtyping/types';
+import { constrainWithLowerBound, constrainWithUpperBound, RComplexType, RDoubleType, resolveType, RIntegerType, RListType, RStringType, RTypeIntersection, RTypeVariable, UnresolvedRAtomicVectorType, UnresolvedRFunctionType, UnresolvedRListType, UnresolvedRTypeIntersection, UnresolvedRTypeUnion, UnresolvedRTypeVariable } from '../../../../src/typing/subtyping/types';
 
 describe('Constrain types with lower and upper bounds', () => {
 	test('Constrain with numeric bounds', () => {
diff --git a/test/functionality/subtyping/loops.test.ts b/test/functionality/typing/subtyping/loops.test.ts
similarity index 78%
rename from test/functionality/subtyping/loops.test.ts
rename to test/functionality/typing/subtyping/loops.test.ts
index 3f614c5c2e4..83420891424 100644
--- a/test/functionality/subtyping/loops.test.ts
+++ b/test/functionality/typing/subtyping/loops.test.ts
@@ -1,8 +1,8 @@
 import { describe } from 'vitest';
-import { RLogicalType, RTypeUnion, RNullType } from '../../../src/typing/subtyping/types';
-import { assertInferredType, assertInferredTypes } from '../_helper/subtyping/assert-inferred-type';
-import { Q } from '../../../src/search/flowr-search-builder';
-import { RType } from '../../../src/r-bridge/lang-4.x/ast/model/type';
+import { RLogicalType, RTypeUnion, RNullType } from '../../../../src/typing/subtyping/types';
+import { assertInferredType, assertInferredTypes } from '../../_helper/typing/subtyping/assert-inferred-type';
+import { Q } from '../../../../src/search/flowr-search-builder';
+import { RType } from '../../../../src/r-bridge/lang-4.x/ast/model/type';
 
 describe('Infer types for loops', () => {
 	describe.each([
diff --git a/test/functionality/subtyping/subsetting.test.ts b/test/functionality/typing/subtyping/subsetting.test.ts
similarity index 92%
rename from test/functionality/subtyping/subsetting.test.ts
rename to test/functionality/typing/subtyping/subsetting.test.ts
index 2dc8e864a44..30678b95713 100644
--- a/test/functionality/subtyping/subsetting.test.ts
+++ b/test/functionality/typing/subtyping/subsetting.test.ts
@@ -1,9 +1,9 @@
 import { describe } from 'vitest';
-import type { DataType } from '../../../src/typing/subtyping/types';
-import { RTypeIntersection, RAtomicVectorType, RIntegerType, RListType, RTypeVariable, RTypeUnion, RNullType, RLogicalType } from '../../../src/typing/subtyping/types';
-import { assertInferredTypes } from '../_helper/subtyping/assert-inferred-type';
-import { Q } from '../../../src/search/flowr-search-builder';
-import { RType } from '../../../src/r-bridge/lang-4.x/ast/model/type';
+import type { DataType } from '../../../../src/typing/subtyping/types';
+import { RTypeIntersection, RAtomicVectorType, RIntegerType, RListType, RTypeVariable, RTypeUnion, RNullType, RLogicalType } from '../../../../src/typing/subtyping/types';
+import { assertInferredTypes } from '../../_helper/typing/subtyping/assert-inferred-type';
+import { Q } from '../../../../src/search/flowr-search-builder';
+import { RType } from '../../../../src/r-bridge/lang-4.x/ast/model/type';
 
 describe('Infer types for subsetting expressions', () => {
 	assertInferredTypes(
diff --git a/test/functionality/subtyping/unsupported-expressions.test.ts b/test/functionality/typing/subtyping/unsupported-expressions.test.ts
similarity index 75%
rename from test/functionality/subtyping/unsupported-expressions.test.ts
rename to test/functionality/typing/subtyping/unsupported-expressions.test.ts
index 0a40ad36bed..05a01b244d6 100644
--- a/test/functionality/subtyping/unsupported-expressions.test.ts
+++ b/test/functionality/typing/subtyping/unsupported-expressions.test.ts
@@ -1,6 +1,6 @@
 import { describe } from 'vitest';
-import { RTypeIntersection, RTypeUnion, RTypeVariable } from '../../../src/typing/subtyping/types';
-import { assertInferredType } from '../_helper/subtyping/assert-inferred-type';
+import { RTypeIntersection, RTypeUnion, RTypeVariable } from '../../../../src/typing/subtyping/types';
+import { assertInferredType } from '../../_helper/typing/subtyping/assert-inferred-type';
 
 describe('Infer no type information for currently unsupported R expressions', () => {
 	assertInferredType('1 + 2',                  new RTypeVariable(new RTypeUnion(), new RTypeIntersection()));
diff --git a/test/functionality/subtyping/variables.test.ts b/test/functionality/typing/subtyping/variables.test.ts
similarity index 60%
rename from test/functionality/subtyping/variables.test.ts
rename to test/functionality/typing/subtyping/variables.test.ts
index 8ee2dbe72d4..a4723def0ea 100644
--- a/test/functionality/subtyping/variables.test.ts
+++ b/test/functionality/typing/subtyping/variables.test.ts
@@ -1,7 +1,7 @@
 import { describe } from 'vitest';
-import { RIntegerType } from '../../../src/typing/subtyping/types';
-import { assertInferredTypes } from '../_helper/subtyping/assert-inferred-type';
-import { Q } from '../../../src/search/flowr-search-builder';
+import { RIntegerType } from '../../../../src/typing/subtyping/types';
+import { assertInferredTypes } from '../../_helper/typing/subtyping/assert-inferred-type';
+import { Q } from '../../../../src/search/flowr-search-builder';
 
 describe('Infer types for variables', () => {
 	assertInferredTypes(
diff --git a/test/functionality/typing/builtin-functions.test.ts b/test/functionality/typing/unification/builtin-functions.test.ts
similarity index 80%
rename from test/functionality/typing/builtin-functions.test.ts
rename to test/functionality/typing/unification/builtin-functions.test.ts
index e57163bbe2f..a3d5cbff7dc 100644
--- a/test/functionality/typing/builtin-functions.test.ts
+++ b/test/functionality/typing/unification/builtin-functions.test.ts
@@ -1,7 +1,7 @@
 import { describe } from 'vitest';
-import { RDoubleType, RLanguageType, RListType, RLogicalType, RNullType, RStringType, RUnknownType } from '../../../src/typing/unification/types';
-import { assertInferredType, assertInferredTypes } from '../_helper/typing/assert-inferred-type';
-import { Q } from '../../../src/search/flowr-search-builder';
+import { RDoubleType, RLanguageType, RListType, RLogicalType, RNullType, RStringType, RUnknownType } from '../../../../src/typing/unification/types';
+import { assertInferredType, assertInferredTypes } from '../../_helper/typing/unification/assert-inferred-type';
+import { Q } from '../../../../src/search/flowr-search-builder';
 
 describe('Infer types for builtin functions', () => {
 	assertInferredType('rm(x)', new RNullType());
diff --git a/test/functionality/typing/conditionals.test.ts b/test/functionality/typing/unification/conditionals.test.ts
similarity index 72%
rename from test/functionality/typing/conditionals.test.ts
rename to test/functionality/typing/unification/conditionals.test.ts
index dfbf6e27af6..c9ce4ba2583 100644
--- a/test/functionality/typing/conditionals.test.ts
+++ b/test/functionality/typing/unification/conditionals.test.ts
@@ -1,8 +1,8 @@
 import { describe } from 'vitest';
-import { RDoubleType, RLogicalType, RNullType, RStringType, RUnknownType } from '../../../src/typing/unification/types';
-import { assertInferredType, assertInferredTypes } from '../_helper/typing/assert-inferred-type';
-import { Q } from '../../../src/search/flowr-search-builder';
-import { RType } from '../../../src/r-bridge/lang-4.x/ast/model/type';
+import { RDoubleType, RLogicalType, RNullType, RStringType, RUnknownType } from '../../../../src/typing/unification/types';
+import { assertInferredType, assertInferredTypes } from '../../_helper/typing/unification/assert-inferred-type';
+import { Q } from '../../../../src/search/flowr-search-builder';
+import { RType } from '../../../../src/r-bridge/lang-4.x/ast/model/type';
 
 describe('Infer types for if statements', () => {
 	describe.each([
diff --git a/test/functionality/typing/constants.test.ts b/test/functionality/typing/unification/constants.test.ts
similarity index 87%
rename from test/functionality/typing/constants.test.ts
rename to test/functionality/typing/unification/constants.test.ts
index 97835e4cb89..58e0390f764 100644
--- a/test/functionality/typing/constants.test.ts
+++ b/test/functionality/typing/unification/constants.test.ts
@@ -1,6 +1,6 @@
 import { describe } from 'vitest';
-import { RComplexType, RDoubleType, RIntegerType, RLogicalType, RNullType, RStringType } from '../../../src/typing/unification/types';
-import { assertInferredType } from '../_helper/typing/assert-inferred-type';
+import { RComplexType, RDoubleType, RIntegerType, RLogicalType, RNullType, RStringType } from '../../../../src/typing/unification/types';
+import { assertInferredType } from '../../_helper/typing/unification/assert-inferred-type';
 
 describe.each([
 	{ description: 'logical constant',        input: 'TRUE',            expectedType: new RLogicalType() },
diff --git a/test/functionality/typing/loops.test.ts b/test/functionality/typing/unification/loops.test.ts
similarity index 82%
rename from test/functionality/typing/loops.test.ts
rename to test/functionality/typing/unification/loops.test.ts
index b3e8d247dc8..2a71eb884f1 100644
--- a/test/functionality/typing/loops.test.ts
+++ b/test/functionality/typing/unification/loops.test.ts
@@ -1,8 +1,8 @@
 import { describe } from 'vitest';
-import { RLogicalType, RNullType, RUnknownType } from '../../../src/typing/unification/types';
-import { assertInferredType, assertInferredTypes } from '../_helper/typing/assert-inferred-type';
-import { Q } from '../../../src/search/flowr-search-builder';
-import { RType } from '../../../src/r-bridge/lang-4.x/ast/model/type';
+import { RLogicalType, RNullType, RUnknownType } from '../../../../src/typing/unification/types';
+import { assertInferredType, assertInferredTypes } from '../../_helper/typing/unification/assert-inferred-type';
+import { Q } from '../../../../src/search/flowr-search-builder';
+import { RType } from '../../../../src/r-bridge/lang-4.x/ast/model/type';
 
 describe('Infer types for loops', () => {
 	describe.each([
diff --git a/test/functionality/typing/subsetting.test.ts b/test/functionality/typing/unification/subsetting.test.ts
similarity index 89%
rename from test/functionality/typing/subsetting.test.ts
rename to test/functionality/typing/unification/subsetting.test.ts
index 6c61cd20fbb..ab6da232749 100644
--- a/test/functionality/typing/subsetting.test.ts
+++ b/test/functionality/typing/unification/subsetting.test.ts
@@ -1,8 +1,8 @@
 import { describe } from 'vitest';
-import { RDoubleType, RErrorType, RListType, RLogicalType, RNullType } from '../../../src/typing/unification/types';
-import { assertInferredTypes } from '../_helper/typing/assert-inferred-type';
-import { Q } from '../../../src/search/flowr-search-builder';
-import { RType } from '../../../src/r-bridge/lang-4.x/ast/model/type';
+import { RDoubleType, RErrorType, RListType, RLogicalType, RNullType } from '../../../../src/typing/unification/types';
+import { assertInferredTypes } from '../../_helper/typing/unification/assert-inferred-type';
+import { Q } from '../../../../src/search/flowr-search-builder';
+import { RType } from '../../../../src/r-bridge/lang-4.x/ast/model/type';
 
 describe('Infer types for subsetting expressions', () => {
 	assertInferredTypes(
diff --git a/test/functionality/typing/unsupported-expressions.test.ts b/test/functionality/typing/unification/unsupported-expressions.test.ts
similarity index 61%
rename from test/functionality/typing/unsupported-expressions.test.ts
rename to test/functionality/typing/unification/unsupported-expressions.test.ts
index 0beedf03666..286b5296894 100644
--- a/test/functionality/typing/unsupported-expressions.test.ts
+++ b/test/functionality/typing/unification/unsupported-expressions.test.ts
@@ -1,6 +1,6 @@
 import { describe } from 'vitest';
-import { RUnknownType } from '../../../src/typing/unification/types';
-import { assertInferredType } from '../_helper/typing/assert-inferred-type';
+import { RUnknownType } from '../../../../src/typing/unification/types';
+import { assertInferredType } from '../../_helper/typing/unification/assert-inferred-type';
 
 describe('Infer no type information for currently unsupported R expressions', () => {
 	assertInferredType('1 + 2',                  new RUnknownType());
diff --git a/test/functionality/typing/variables.test.ts b/test/functionality/typing/unification/variables.test.ts
similarity index 60%
rename from test/functionality/typing/variables.test.ts
rename to test/functionality/typing/unification/variables.test.ts
index 249e75ad2ea..00fa3dbdca9 100644
--- a/test/functionality/typing/variables.test.ts
+++ b/test/functionality/typing/unification/variables.test.ts
@@ -1,7 +1,7 @@
 import { describe } from 'vitest';
-import { RDoubleType } from '../../../src/typing/unification/types';
-import { assertInferredTypes } from '../_helper/typing/assert-inferred-type';
-import { Q } from '../../../src/search/flowr-search-builder';
+import { RDoubleType } from '../../../../src/typing/unification/types';
+import { assertInferredTypes } from '../../_helper/typing/unification/assert-inferred-type';
+import { Q } from '../../../../src/search/flowr-search-builder';
 
 describe('Infer types for variables', () => {
 	assertInferredTypes(

From 63937ee585cc42f7d1d07b4a5fcb9bc4e4c95258 Mon Sep 17 00:00:00 2001
From: Lukas Rohde <lukas.rohde@silupe.de>
Date: Tue, 15 Jul 2025 17:10:38 +0200
Subject: [PATCH 097/153] refactor(typing): unify error handling between
 unification and suptyping

---
 src/typing/unification/types.ts               | 27 +++++--------------
 .../typing/unification/subsetting.test.ts     |  4 +--
 2 files changed, 8 insertions(+), 23 deletions(-)

diff --git a/src/typing/unification/types.ts b/src/typing/unification/types.ts
index 67ae4edf0c0..45dac79b639 100644
--- a/src/typing/unification/types.ts
+++ b/src/typing/unification/types.ts
@@ -152,34 +152,19 @@ export class RTypeVariable {
 			thisRep.unify(otherRep);
 		} else if(thisRep instanceof UnresolvedRListType && otherRep instanceof UnresolvedRListType) {
 			thisRep.unify(otherRep);
-		} else if(thisRep instanceof RErrorType && otherRep instanceof RErrorType) {
-			for(const type of otherRep.conflictingTypes) {
-				otherRep.conflictingTypes.add(type);
-			}
-			this.boundType = otherRep;
-		} else if(thisRep.tag !== otherRep.tag) {
-			if(thisRep instanceof RErrorType) {
-				thisRep.conflictingTypes.add(resolveType(otherRep));
-			} else if(otherRep instanceof RErrorType) {
-				otherRep.conflictingTypes.add(resolveType(thisRep));
-				this.boundType = otherRep;
-			} else {
-				this.boundType = new RErrorType(resolveType(thisRep), resolveType(otherRep));
-			}
+		} else if(thisRep instanceof RErrorType || thisRep.tag !== otherRep.tag) {
+			this.boundType = new RErrorType(resolveType(thisRep), resolveType(otherRep));
 		}
 	}
 }
 
 export class RErrorType {
 	readonly tag = RDataTypeTag.Error;
-	conflictingTypes = new Set<RDataType>();
-
-	constructor(...conflictingTypes: RDataType[]) {
-		for(const type of conflictingTypes) {
-			this.conflictingTypes.add(type);
-		}
-	}	
+	conflictingBounds: [RDataType, RDataType];
 
+	constructor(...conflictingBounds: [RDataType, RDataType]) {
+		this.conflictingBounds = conflictingBounds;
+	}
 }
 
 export class RUnknownType {
diff --git a/test/functionality/typing/unification/subsetting.test.ts b/test/functionality/typing/unification/subsetting.test.ts
index ab6da232749..16c0bbe9e43 100644
--- a/test/functionality/typing/unification/subsetting.test.ts
+++ b/test/functionality/typing/unification/subsetting.test.ts
@@ -55,7 +55,7 @@ describe('Infer types for subsetting expressions', () => {
 	
 	assertInferredTypes(
 		'l <- list(TRUE, a = 42, NULL); l$a',
-		{ query: Q.var('l').last().build(),                    expectedType: new RListType(new RErrorType(new RLogicalType(), new RDoubleType(), new RNullType())) },
-		{ query: Q.all().filter(RType.Access).first().build(), expectedType: new RErrorType(new RLogicalType(), new RDoubleType(), new RNullType()) },
+		{ query: Q.var('l').last().build(),                    expectedType: new RListType(new RErrorType(new RErrorType(new RLogicalType(), new RDoubleType()), new RNullType())) },
+		{ query: Q.all().filter(RType.Access).first().build(), expectedType: new RErrorType(new RErrorType(new RLogicalType(), new RDoubleType()), new RNullType()) },
 	);
 });
\ No newline at end of file

From 4d5a3207d0bcfd749be74643190b1e5296cc8acf Mon Sep 17 00:00:00 2001
From: Lukas Rohde <lukas.rohde@silupe.de>
Date: Tue, 15 Jul 2025 18:24:45 +0200
Subject: [PATCH 098/153] refactor(typing): share types between unification and
 subtyping

---
 .../datatype-query/datatype-query-format.ts   |   4 +-
 src/queries/query-print.ts                    |   8 +-
 src/typing/base-types.ts                      |  34 +--
 src/typing/subtyping/infer.ts                 |  10 +-
 src/typing/subtyping/types.ts                 | 284 +++---------------
 src/typing/types.ts                           | 195 ++++++++++++
 src/typing/unification/infer.ts               |  23 +-
 src/typing/unification/types.ts               | 221 +++-----------
 .../typing/subtyping/assert-inferred-type.ts  |   4 +-
 .../unification/assert-inferred-type.ts       |   6 +-
 .../subtyping/builtin-functions.test.ts       |   2 +-
 .../typing/subtyping/conditionals.test.ts     |   2 +-
 .../typing/subtyping/constants.test.ts        |   2 +-
 .../typing/subtyping/constrain.test.ts        |   3 +-
 .../typing/subtyping/loops.test.ts            |   2 +-
 .../typing/subtyping/subsetting.test.ts       |   4 +-
 .../subtyping/unsupported-expressions.test.ts |   2 +-
 .../typing/subtyping/variables.test.ts        |   2 +-
 .../unification/builtin-functions.test.ts     |   4 +-
 .../typing/unification/conditionals.test.ts   |   4 +-
 .../typing/unification/constants.test.ts      |   2 +-
 .../typing/unification/loops.test.ts          |   6 +-
 .../typing/unification/subsetting.test.ts     |   6 +-
 .../unsupported-expressions.test.ts           |   6 +-
 .../typing/unification/variables.test.ts      |   2 +-
 25 files changed, 345 insertions(+), 493 deletions(-)
 create mode 100644 src/typing/types.ts

diff --git a/src/queries/catalog/datatype-query/datatype-query-format.ts b/src/queries/catalog/datatype-query/datatype-query-format.ts
index 7a9bc214e2b..46e270565ae 100644
--- a/src/queries/catalog/datatype-query/datatype-query-format.ts
+++ b/src/queries/catalog/datatype-query/datatype-query-format.ts
@@ -7,7 +7,7 @@ import Joi from 'joi';
 import { executeDatatypeQuery } from './datatype-query-executor';
 
 import { asciiDataType } from '../../query-print';
-import type { RDataType } from '../../../typing/unification/types';
+import type { DataType } from '../../../typing/types';
 
 /**
  * Calculates the inferred data type for the given criterion.
@@ -19,7 +19,7 @@ export interface DatatypeQuery extends BaseQueryFormat {
 
 export interface DatatypeQueryResult extends BaseQueryResult {
 	/** Maps each criterion to the inferred data type, duplicates are ignored. */
-	readonly inferredTypes: Record<SingleSlicingCriterion, RDataType>;
+	readonly inferredTypes: Record<SingleSlicingCriterion, DataType>;
 }
 
 export const DatatypeQueryDefinition = {
diff --git a/src/queries/query-print.ts b/src/queries/query-print.ts
index 57316640e3c..a9e04cd9b86 100644
--- a/src/queries/query-print.ts
+++ b/src/queries/query-print.ts
@@ -10,7 +10,7 @@ import type { CallContextQuerySubKindResult } from './catalog/call-context-query
 import type { BaseQueryMeta, BaseQueryResult } from './base-query-format';
 import { printAsMs } from '../util/text/time';
 import { isBuiltIn } from '../dataflow/environments/built-in';
-import { RDataTypeTag, type RDataType } from '../typing/unification/types';
+import { DataTypeTag, type DataType } from '../typing/types';
 
 function nodeString(nodeId: NodeId | { id: NodeId, info?: object}, formatter: OutputFormatter, processed: PipelineOutput<typeof DEFAULT_DATAFLOW_PIPELINE>): string {
 	const isObj = typeof nodeId === 'object' && nodeId !== null && 'id' in nodeId;
@@ -77,10 +77,10 @@ export function summarizeIdsIfTooLong(formatter: OutputFormatter, ids: readonly
 	return formatter === markdownFormatter ? textWithTooltip(acc, JSON.stringify(ids)) : acc;
 }
 
-export function asciiDataType(type: RDataType): string {
-	if(type.tag === RDataTypeTag.Function) {
+export function asciiDataType(type: DataType): string {
+	if(type.tag === DataTypeTag.Function) {
 		return `Function(${type.parameterTypes.entries().toArray().map(([key, type]) => `${key}: ${asciiDataType(type)}`).join(', ')}) -> ${asciiDataType(type.returnType)}`;
-	} else if(type.tag === RDataTypeTag.List) {
+	} else if(type.tag === DataTypeTag.List) {
 		return `List(${asciiDataType(type.elementType)})`;
 	} else {
 		return type.tag;
diff --git a/src/typing/base-types.ts b/src/typing/base-types.ts
index cb500a36dea..d04c9c830f6 100644
--- a/src/typing/base-types.ts
+++ b/src/typing/base-types.ts
@@ -1,4 +1,4 @@
-import { RDataTypeTag } from './unification/types';
+import { DataTypeTag } from './types';
 
 /* eslint-disable @typescript-eslint/naming-convention */
 export enum RBaseType {
@@ -27,25 +27,25 @@ export enum RBaseType {
     // ANYSXP     = 'any',
 }
 
-export function baseTypeToDataTypeTag(baseType: RBaseType): RDataTypeTag {
+export function baseTypeToDataTypeTag(baseType: RBaseType): DataTypeTag {
 	switch(baseType) {
-		case RBaseType.NILSXP:     return RDataTypeTag.Null;
-		case RBaseType.LGLSXP:     return RDataTypeTag.Logical;
-		case RBaseType.INTSXP:     return RDataTypeTag.Integer;
-		case RBaseType.REALSXP:    return RDataTypeTag.Double;
-		case RBaseType.CPLXSXP:    return RDataTypeTag.Complex;
-		case RBaseType.STRSXP:     return RDataTypeTag.String;
-		case RBaseType.VECSXP:     return RDataTypeTag.List;
-		case RBaseType.RAWSXP:     return RDataTypeTag.Raw;
-		case RBaseType.CLOSXP:     return RDataTypeTag.Function;
-		case RBaseType.SPECIALSXP: return RDataTypeTag.Function; // Special functions are a kind of function
-		case RBaseType.BUILTINSXP: return RDataTypeTag.Function; // Builtin functions are a kind of function
-		case RBaseType.ENVSXP:     return RDataTypeTag.Environment;
+		case RBaseType.NILSXP:     return DataTypeTag.Null;
+		case RBaseType.LGLSXP:     return DataTypeTag.Logical;
+		case RBaseType.INTSXP:     return DataTypeTag.Integer;
+		case RBaseType.REALSXP:    return DataTypeTag.Double;
+		case RBaseType.CPLXSXP:    return DataTypeTag.Complex;
+		case RBaseType.STRSXP:     return DataTypeTag.String;
+		case RBaseType.VECSXP:     return DataTypeTag.List;
+		case RBaseType.RAWSXP:     return DataTypeTag.Raw;
+		case RBaseType.CLOSXP:     return DataTypeTag.Function;
+		case RBaseType.SPECIALSXP: return DataTypeTag.Function; // Special functions are a kind of function
+		case RBaseType.BUILTINSXP: return DataTypeTag.Function; // Builtin functions are a kind of function
+		case RBaseType.ENVSXP:     return DataTypeTag.Environment;
 		// case RBaseType.S4SXP:      return RDataTypeTag.Unknown; // Not yet supported
-		case RBaseType.SYMSXP:     return RDataTypeTag.Language; // Symbols are a kind of language object
-		case RBaseType.LANGSXP:    return RDataTypeTag.Language;
+		case RBaseType.SYMSXP:     return DataTypeTag.Language; // Symbols are a kind of language object
+		case RBaseType.LANGSXP:    return DataTypeTag.Language;
 		// case RBaseType.LISTSXP:    return RDataTypeTag.List; // Not supported
-		case RBaseType.EXPRSXP:    return RDataTypeTag.Language; // Expressions are a kind of language object
+		case RBaseType.EXPRSXP:    return DataTypeTag.Language; // Expressions are a kind of language object
 		// case RBaseType.EXTPTRSXP:  return RDataTypeTag.Unknown; // Not supported
 		// case RBaseType.WEAKREFSXP: return RDataTypeTag.Unknown; // Not supported
 		// case RBaseType.BCODESXP:   return RDataTypeTag.Unknown; // Not supported
diff --git a/src/typing/subtyping/infer.ts b/src/typing/subtyping/infer.ts
index 74710407c3d..3a14f6ee27b 100644
--- a/src/typing/subtyping/infer.ts
+++ b/src/typing/subtyping/infer.ts
@@ -8,8 +8,8 @@ import type { RNumber } from '../../r-bridge/lang-4.x/ast/model/nodes/r-number';
 import type { RString } from '../../r-bridge/lang-4.x/ast/model/nodes/r-string';
 import type { NormalizedAst, ParentInformation } from '../../r-bridge/lang-4.x/ast/model/processing/decorate';
 import { mapNormalizedAstInfo } from '../../r-bridge/lang-4.x/ast/model/processing/decorate';
-import type { DataType, UnresolvedDataType } from './types';
-import { UnresolvedRTypeVariable, RComplexType, RDoubleType, RIntegerType, RLogicalType, RStringType, resolveType, RNullType, UnresolvedRListType, RLanguageType, UnresolvedRFunctionType, UnresolvedRAtomicVectorType, UnresolvedRTypeUnion } from './types';
+import type { DataTypeInfo } from '../types';
+import { RComplexType, RDoubleType, RIntegerType, RLogicalType, RStringType, RNullType, RLanguageType } from '../types';
 import type { RExpressionList } from '../../r-bridge/lang-4.x/ast/model/nodes/r-expression-list';
 import { guard } from '../../util/assert';
 import { OriginType } from '../../dataflow/origin/dfg-get-origin';
@@ -23,6 +23,8 @@ import type { RSymbol } from '../../r-bridge/lang-4.x/ast/model/nodes/r-symbol';
 import { RType } from '../../r-bridge/lang-4.x/ast/model/type';
 import type { NoInfo } from '../../r-bridge/lang-4.x/ast/model/model';
 import { RFalse, RTrue } from '../../r-bridge/lang-4.x/convert-values';
+import type { UnresolvedDataType } from './types';
+import { resolveType, UnresolvedRAtomicVectorType, UnresolvedRFunctionType, UnresolvedRListType, UnresolvedRTypeUnion, UnresolvedRTypeVariable } from './types';
 
 export function inferDataTypes<Info extends ParentInformation & { typeVariable?: undefined }>(ast: NormalizedAst<ParentInformation & Info>, dataflowInfo: DataflowInformation): NormalizedAst<Info & DataTypeInfo> {
 	const astWithTypeVars = decorateTypeVariables(ast);
@@ -44,10 +46,6 @@ type UnresolvedTypeInfo = {
 	typeVariable: UnresolvedRTypeVariable;
 };
 
-export type DataTypeInfo = {
-	inferredType: DataType;
-}
-
 function decorateTypeVariables<Info extends ParentInformation>(ast: NormalizedAst<Info>): NormalizedAst<Info & UnresolvedTypeInfo> {
 	return mapNormalizedAstInfo(ast, node => ({ ...node.info, typeVariable: new UnresolvedRTypeVariable() }));
 }
diff --git a/src/typing/subtyping/types.ts b/src/typing/subtyping/types.ts
index f231f3de61a..8bcb0cc4512 100644
--- a/src/typing/subtyping/types.ts
+++ b/src/typing/subtyping/types.ts
@@ -1,46 +1,9 @@
 import { guard } from '../../util/assert';
-
-/**
- * This enum lists a tag for each of the possible R data types inferred by the
- * type inferencer. It is mainly used to identify subtypes of {@link DataType}.
- */
-export enum RDataTypeTag {
-	/** {@link RAtomicVectorType} */
-	AtomicVector = 'RAtomicVectorType',
-    /** {@link RLogicalType} */
-    Logical = 'RLogicalType',
-    /** {@link RIntegerType} */
-    Integer = 'RIntegerType',
-    /** {@link RDoubleType} */
-    Double = 'RDoubleType',
-    /** {@link RComplexType} */
-	Complex = 'RComplexType',
-    /** {@link RStringType} */
-    String = 'RStringType',
-    /** {@link RRawType} */
-    Raw = 'RRawType',
-    /** {@link RListType} */
-    List = 'RListType',
-    /** {@link RNullType} */
-	Null = 'RNullType',
-    /** {@link RFunctionType} */
-    Function = 'RFunctionType',
-    /** {@link REnvironmentType} */
-    Environment = 'REnvironmentType',
-    /** {@link RLanguageType} */
-    Language = 'RLanguageType',
-	/** {@link UnresolvedRTypeUnion} */
-	Union = 'RTypeUnion',
-	/** {@link UnresolvedRTypeIntersection} */
-	Intersection = 'RTypeIntersection',
-	/** {@link UnresolvedRTypeVariable} */
-    Variable = 'RTypeVariable',
-	/** {@link RErrorType} */
-	Error = 'RErrorType',
-}
+import type { DataType , AtomicVectorBaseType, REnvironmentType, RLanguageType, RNullType } from '../types';
+import { DataTypeTag, isAtomicVectorBaseType, RAtomicVectorType, RFunctionType, RListType, RTypeError, RTypeIntersection, RTypeUnion, RTypeVariable } from '../types';
 
 export class UnresolvedRAtomicVectorType {
-	readonly tag = RDataTypeTag.AtomicVector;
+	readonly tag = DataTypeTag.AtomicVector;
 	readonly elementType = new UnresolvedRTypeVariable();
 
 	constructor(elementType?: UnresolvedRTypeVariable) {
@@ -50,41 +13,8 @@ export class UnresolvedRAtomicVectorType {
 	}
 }
 
-export class RAtomicVectorType {
-	readonly tag = RDataTypeTag.AtomicVector;
-	readonly elementType: DataType;
-
-	constructor(elementType: DataType) {
-		this.elementType = elementType;
-	}
-}
-
-export class RLogicalType {
-	readonly tag = RDataTypeTag.Logical;
-}
-
-export class RIntegerType {
-	readonly tag = RDataTypeTag.Integer;
-}
-
-export class RDoubleType {
-	readonly tag = RDataTypeTag.Double;
-}
-
-export class RComplexType {
-	readonly tag = RDataTypeTag.Complex;
-}
-
-export class RStringType {
-	readonly tag = RDataTypeTag.String;
-}
-
-export class RRawType {
-	readonly tag = RDataTypeTag.Raw;
-}
-
 export class UnresolvedRListType {
-	readonly tag = RDataTypeTag.List;
+	readonly tag = DataTypeTag.List;
 	readonly elementType = new UnresolvedRTypeVariable();
 	readonly indexedElementTypes = new Map<number | string, UnresolvedRTypeVariable>();
 
@@ -106,23 +36,8 @@ export class UnresolvedRListType {
 	}
 }
 
-export class RListType {
-	readonly tag = RDataTypeTag.List;
-	readonly elementType:         DataType;
-	readonly indexedElementTypes: ReadonlyMap<number | string, DataType>;
-
-	constructor(elementType: DataType, indexedElementTypes: Map<number | string, DataType> = new Map()) {
-		this.elementType = elementType;
-		this.indexedElementTypes = indexedElementTypes;
-	}
-}
-
-export class RNullType {
-	readonly tag = RDataTypeTag.Null;
-}
-
 export class UnresolvedRFunctionType {
-	readonly tag = RDataTypeTag.Function;
+	readonly tag = DataTypeTag.Function;
 	readonly parameterTypes = new Map<number | string, UnresolvedRTypeVariable>();
 	readonly returnType = new UnresolvedRTypeVariable();
 
@@ -142,27 +57,8 @@ export class UnresolvedRFunctionType {
 	}
 }
 
-export class RFunctionType {
-	readonly tag = RDataTypeTag.Function;
-	readonly parameterTypes: Map<number | string, DataType>;
-	readonly returnType:     DataType;
-
-	constructor(parameterTypes: Map<number | string, DataType>, returnType: DataType) {
-		this.parameterTypes = parameterTypes;
-		this.returnType = returnType;
-	}
-}
-
-export class REnvironmentType {
-	readonly tag = RDataTypeTag.Environment;
-}
-
-export class RLanguageType {
-	readonly tag = RDataTypeTag.Language;
-}
-
 export class UnresolvedRTypeUnion {
-	readonly tag = RDataTypeTag.Union;
+	readonly tag = DataTypeTag.Union;
 	readonly types: Set<UnresolvedDataType> = new Set();
 
 	constructor(...types: UnresolvedDataType[]) {
@@ -173,20 +69,8 @@ export class UnresolvedRTypeUnion {
 	}
 }
 
-export class RTypeUnion {
-	readonly tag = RDataTypeTag.Union;
-	readonly types: Set<DataType> = new Set();
-
-	constructor(...types: DataType[]) {
-		for(const type of types) {
-			guard(type !== this, 'Union cannot contain itself');
-			this.types.add(type);
-		}
-	}
-}
-
 export class UnresolvedRTypeIntersection {
-	readonly tag = RDataTypeTag.Intersection;
+	readonly tag = DataTypeTag.Intersection;
 	readonly types: Set<UnresolvedDataType> = new Set();
 
 	constructor(...types: UnresolvedDataType[]) {
@@ -197,20 +81,8 @@ export class UnresolvedRTypeIntersection {
 	}
 }
 
-export class RTypeIntersection {
-	readonly tag = RDataTypeTag.Intersection;
-	readonly types: Set<DataType> = new Set();
-
-	constructor(...types: DataType[]) {
-		for(const type of types) {
-			guard(type !== this, 'Intersection cannot contain itself');
-			this.types.add(type);
-		}
-	}
-}
-
 export class UnresolvedRTypeVariable {
-	readonly tag = RDataTypeTag.Variable;
+	readonly tag = DataTypeTag.Variable;
 	readonly lowerBound = new UnresolvedRTypeUnion();
 	readonly upperBound = new UnresolvedRTypeIntersection();
 
@@ -230,28 +102,6 @@ export class UnresolvedRTypeVariable {
 	}
 }
 
-export class RTypeVariable {
-	readonly tag = RDataTypeTag.Variable;
-	readonly lowerBound: DataType;
-	readonly upperBound: DataType;
-	
-	constructor(lowerBound: DataType, upperBound: DataType) {
-		guard(lowerBound !== this, 'Lower bound cannot be the type variable itself');
-		this.lowerBound = lowerBound;
-		guard(upperBound !== this, 'Upper bound cannot be the type variable itself');
-		this.upperBound = upperBound;
-	}
-}
-
-export class RErrorType {
-	readonly tag = RDataTypeTag.Error;
-	conflictingBounds: [DataType, DataType];
-
-	constructor(...conflictingBounds: [DataType, DataType]) {
-		this.conflictingBounds = conflictingBounds;
-	}
-}
-
 
 export function constrainWithLowerBound(type: UnresolvedDataType, bound: UnresolvedDataType): void {
 	// console.debug('constraining', type, 'with lower bound', bound);
@@ -306,7 +156,7 @@ export function constrainWithLowerBound(type: UnresolvedDataType, bound: Unresol
 		constrainWithLowerBound(type.returnType, bound.returnType);
 	} else if(type instanceof UnresolvedRAtomicVectorType && bound instanceof UnresolvedRAtomicVectorType) {
 		constrainWithLowerBound(type.elementType, bound.elementType);
-	} else if(type instanceof UnresolvedRAtomicVectorType && isAtomicVectorElementType(bound)) {
+	} else if(type instanceof UnresolvedRAtomicVectorType && isAtomicVectorBaseType(bound)) {
 		constrainWithLowerBound(type.elementType, bound);
 	} else if(type instanceof UnresolvedRListType && bound instanceof UnresolvedRListType) {
 		constrainWithLowerBound(type.elementType, bound.elementType);
@@ -378,7 +228,7 @@ export function resolveType(type: UnresolvedDataType): DataType {
 		const upperBound = resolveType(type.upperBound);
 
 		if(!subsumes(lowerBound, upperBound)) {
-			return new RErrorType(lowerBound, upperBound);
+			return new RTypeError(lowerBound, upperBound);
 		}
 		
 		if(subsumes(lowerBound, upperBound) && subsumes(upperBound, lowerBound)) {
@@ -427,28 +277,28 @@ function subsumes(subtype: DataType | UnresolvedDataType, supertype: DataType |
 
 	if(subtype === supertype) {
 		return true;
-	} else if(subtype.tag === RDataTypeTag.Error || supertype.tag === RDataTypeTag.Error) {
+	} else if(subtype.tag === DataTypeTag.Error || supertype.tag === DataTypeTag.Error) {
 		return false; // Error types do not subsume and are not subsumed by any other type
-	} else if(subtype.tag === RDataTypeTag.Variable) {
+	} else if(subtype.tag === DataTypeTag.Variable) {
 		return subsumes(subtype.lowerBound, supertype) && subsumes(subtype.upperBound, supertype);
-	} else if(supertype.tag === RDataTypeTag.Variable) {
+	} else if(supertype.tag === DataTypeTag.Variable) {
 		return subsumes(supertype.lowerBound, subtype) && subsumes(subtype, supertype.upperBound);
-	} else if(subtype.tag === RDataTypeTag.Union) {
+	} else if(subtype.tag === DataTypeTag.Union) {
 		return subtype.types.values().every(subtype => subsumes(subtype, supertype));
-	} else if(supertype.tag === RDataTypeTag.Union) {
+	} else if(supertype.tag === DataTypeTag.Union) {
 		return supertype.types.values().some(supertype => subsumes(subtype, supertype));
-	} else if(supertype.tag === RDataTypeTag.Intersection) {
+	} else if(supertype.tag === DataTypeTag.Intersection) {
 		return supertype.types.values().every(supertype => subsumes(subtype, supertype));
-	} else if(subtype.tag === RDataTypeTag.Intersection) {
+	} else if(subtype.tag === DataTypeTag.Intersection) {
 		return subtype.types.values().some(subtype => subsumes(subtype, supertype));
-	} else if(subtype.tag === RDataTypeTag.List && supertype.tag === RDataTypeTag.List) {
+	} else if(subtype.tag === DataTypeTag.List && supertype.tag === DataTypeTag.List) {
 		return subsumes(subtype.elementType, supertype.elementType);
-	} else if(subtype.tag === RDataTypeTag.AtomicVector && supertype.tag === RDataTypeTag.AtomicVector) {
+	} else if(subtype.tag === DataTypeTag.AtomicVector && supertype.tag === DataTypeTag.AtomicVector) {
 		return subsumes(subtype.elementType, supertype.elementType);
-	} else if(isAtomicVectorElementType(subtype) && supertype.tag === RDataTypeTag.AtomicVector) {
+	} else if(isAtomicVectorBaseType(subtype) && supertype.tag === DataTypeTag.AtomicVector) {
 		// A scalar subsumes a vector type if it subsumes the element type of the vector
 		return subsumes(subtype, supertype.elementType);
-	} else if(subtype.tag === RDataTypeTag.Function && supertype.tag === RDataTypeTag.Function) {
+	} else if(subtype.tag === DataTypeTag.Function && supertype.tag === DataTypeTag.Function) {
 		return subsumes(subtype.returnType, supertype.returnType) && subtype.parameterTypes.entries().every(([key, type]) => {
 			const supertypeParameter = supertype.parameterTypes.get(key);
 			if(supertypeParameter === undefined) {
@@ -461,21 +311,21 @@ function subsumes(subtype: DataType | UnresolvedDataType, supertype: DataType |
 	}
 }
 
-function subsumesByTag(subtype: RDataTypeTag, supertype: RDataTypeTag): boolean {
-	return subtype === supertype && subtype !== RDataTypeTag.Error
-		|| subtype === RDataTypeTag.Logical && supertype === RDataTypeTag.Integer
-		|| subtype === RDataTypeTag.Logical && supertype === RDataTypeTag.Double
-		|| subtype === RDataTypeTag.Logical && supertype === RDataTypeTag.Complex
-		|| subtype === RDataTypeTag.Integer && supertype === RDataTypeTag.Double
-		|| subtype === RDataTypeTag.Integer && supertype === RDataTypeTag.Complex
-		|| subtype === RDataTypeTag.Double && supertype === RDataTypeTag.Complex
-		|| [RDataTypeTag.Logical, RDataTypeTag.Integer, RDataTypeTag.Double, RDataTypeTag.Complex, RDataTypeTag.String, RDataTypeTag.Raw].includes(subtype) && supertype === RDataTypeTag.AtomicVector;
+function subsumesByTag(subtype: DataTypeTag, supertype: DataTypeTag): boolean {
+	return subtype === supertype && subtype !== DataTypeTag.Error
+		|| subtype === DataTypeTag.Logical && supertype === DataTypeTag.Integer
+		|| subtype === DataTypeTag.Logical && supertype === DataTypeTag.Double
+		|| subtype === DataTypeTag.Logical && supertype === DataTypeTag.Complex
+		|| subtype === DataTypeTag.Integer && supertype === DataTypeTag.Double
+		|| subtype === DataTypeTag.Integer && supertype === DataTypeTag.Complex
+		|| subtype === DataTypeTag.Double && supertype === DataTypeTag.Complex
+		|| [DataTypeTag.Logical, DataTypeTag.Integer, DataTypeTag.Double, DataTypeTag.Complex, DataTypeTag.String, DataTypeTag.Raw].includes(subtype) && supertype === DataTypeTag.AtomicVector;
 }
 
 function join(type1: DataType, type2: DataType): DataType {
-	if(type1 instanceof RErrorType) {
+	if(type1 instanceof RTypeError) {
 		return type1;
-	} else if(type2 instanceof RErrorType) {
+	} else if(type2 instanceof RTypeError) {
 		return type2;
 	} else if(type1 instanceof RTypeVariable) {
 		return join(type1.lowerBound, type2);
@@ -490,7 +340,7 @@ function join(type1: DataType, type2: DataType): DataType {
 		const types = new Set<DataType>();
 		for(const subtype of type1.types) {
 			const joinedType = join(subtype, type2);
-			if(joinedType instanceof RErrorType) {
+			if(joinedType instanceof RTypeError) {
 				return joinedType; // If any subtype resolves to an error, return the error
 			} else if(joinedType instanceof RTypeUnion) {
 				joinedType.types.forEach(type => types.add(type));
@@ -540,9 +390,9 @@ function join(type1: DataType, type2: DataType): DataType {
 		return new RListType(join(type1.elementType, type2.elementType), indexedElementTypes);
 	} else if(type1 instanceof RAtomicVectorType && type2 instanceof RAtomicVectorType) {
 		return new RAtomicVectorType(join(type1.elementType, type2.elementType));
-	} else if(isAtomicVectorElementType(type1) && type2.tag === RDataTypeTag.AtomicVector) {
+	} else if(isAtomicVectorBaseType(type1) && type2.tag === DataTypeTag.AtomicVector) {
 		return new RAtomicVectorType(join(type1, type2.elementType));
-	} else if(isAtomicVectorElementType(type2) && type1.tag === RDataTypeTag.AtomicVector) {
+	} else if(isAtomicVectorBaseType(type2) && type1.tag === DataTypeTag.AtomicVector) {
 		return new RAtomicVectorType(join(type2, type1.elementType));
 	} else if(subsumesByTag(type1.tag, type2.tag)) {
 		return type2;
@@ -553,9 +403,9 @@ function join(type1: DataType, type2: DataType): DataType {
 }
 
 function meet(type1: DataType, type2: DataType): DataType {
-	if(type1 instanceof RErrorType) {
+	if(type1 instanceof RTypeError) {
 		return type1;
-	} else if(type2 instanceof RErrorType) {
+	} else if(type2 instanceof RTypeError) {
 		return type2;
 	} else if(type1 instanceof RTypeVariable) {
 		return meet(type1.upperBound, type2);
@@ -586,7 +436,7 @@ function meet(type1: DataType, type2: DataType): DataType {
 		const types = new Set<DataType>();
 		for(const subtype of type1.types) {
 			const metType = meet(subtype, type2);
-			if(metType instanceof RErrorType) {
+			if(metType instanceof RTypeError) {
 				return metType; // If any subtype resolves to an error, return the error
 			} else if(metType instanceof RTypeIntersection) {
 				metType.types.forEach(type => types.add(type));
@@ -620,9 +470,9 @@ function meet(type1: DataType, type2: DataType): DataType {
 		return new RListType(meet(type1.elementType, type2.elementType), indexedElementTypes);
 	} else if(type1 instanceof RAtomicVectorType && type2 instanceof RAtomicVectorType) {
 		return new RAtomicVectorType(meet(type1.elementType, type2.elementType));
-	} else if(isAtomicVectorElementType(type1) && type2.tag === RDataTypeTag.AtomicVector) {
+	} else if(isAtomicVectorBaseType(type1) && type2.tag === DataTypeTag.AtomicVector) {
 		return meet(type1, type2.elementType);
-	} else if(isAtomicVectorElementType(type2) && type1.tag === RDataTypeTag.AtomicVector) {
+	} else if(isAtomicVectorBaseType(type2) && type1.tag === DataTypeTag.AtomicVector) {
 		return meet(type2, type1.elementType);
 	} else if(subsumesByTag(type1.tag, type2.tag)) {
 		return type1;
@@ -633,61 +483,15 @@ function meet(type1: DataType, type2: DataType): DataType {
 }
 
 
-export type AtomicVectorElementType
-	= RLogicalType
-	| RIntegerType
-	| RDoubleType
-	| RComplexType
-	| RStringType
-	| RRawType
-
-export function isAtomicVectorElementType(type: DataType | UnresolvedDataType): type is AtomicVectorElementType {
-	return type.tag === RDataTypeTag.Logical
-		|| type.tag === RDataTypeTag.Integer
-		|| type.tag === RDataTypeTag.Double
-		|| type.tag === RDataTypeTag.Complex
-		|| type.tag === RDataTypeTag.String
-		|| type.tag === RDataTypeTag.Raw;
-}
-	
-export type VectorType = RAtomicVectorType | RListType;
-
-export type UnresolvedVectorType = UnresolvedRAtomicVectorType | UnresolvedRListType;
-
-export function isVectorType(type: UnresolvedDataType): type is UnresolvedVectorType
-export function isVectorType(type: DataType): type is VectorType
-export function isVectorType(type: DataType | UnresolvedDataType): type is VectorType | UnresolvedVectorType {
-	return type.tag === RDataTypeTag.AtomicVector || type.tag === RDataTypeTag.List;
-}
-
-/**
- * The `RDataType` type is the union of all possible types that can be inferred
- * by the type inferencer for R objects.
- * It should be used whenever you either not care what kind of
- * type you are dealing with or if you want to handle all possible types.
-*/
-export type DataType
-	= AtomicVectorElementType
-	| RAtomicVectorType
-	| RListType
-	| RNullType
-	| REnvironmentType
-	| RLanguageType
-	| RFunctionType
-	| RTypeUnion
-	| RTypeIntersection
-	| RTypeVariable
-	| RErrorType;
-
 export type UnresolvedDataType
-	= AtomicVectorElementType
-	| UnresolvedRAtomicVectorType
+	= UnresolvedRAtomicVectorType
+	| AtomicVectorBaseType
 	| UnresolvedRListType
 	| RNullType
+	| UnresolvedRFunctionType
 	| REnvironmentType
 	| RLanguageType
-	| UnresolvedRFunctionType
 	| UnresolvedRTypeUnion
 	| UnresolvedRTypeIntersection
 	| UnresolvedRTypeVariable
-	| RErrorType;
\ No newline at end of file
+	| RTypeError;
\ No newline at end of file
diff --git a/src/typing/types.ts b/src/typing/types.ts
new file mode 100644
index 00000000000..4cadf6477f4
--- /dev/null
+++ b/src/typing/types.ts
@@ -0,0 +1,195 @@
+import { guard } from '../util/assert';
+
+/**
+ * This enum lists a tag for each of the possible R data types inferred by the
+ * type inferencer. It is mainly used to identify subtypes of {@link DataType}.
+ */
+export enum DataTypeTag {
+	/** {@link RAtomicVectorType} */
+	AtomicVector = 'RAtomicVectorType',
+	/** {@link RLogicalType} */
+	Logical = 'RLogicalType',
+	/** {@link RIntegerType} */
+	Integer = 'RIntegerType',
+	/** {@link RDoubleType} */
+	Double = 'RDoubleType',
+	/** {@link RComplexType} */
+	Complex = 'RComplexType',
+	/** {@link RStringType} */
+	String = 'RStringType',
+	/** {@link RRawType} */
+	Raw = 'RRawType',
+	/** {@link RListType} */
+	List = 'RListType',
+	/** {@link RNullType} */
+	Null = 'RNullType',
+	/** {@link RFunctionType} */
+	Function = 'RFunctionType',
+	/** {@link REnvironmentType} */
+	Environment = 'REnvironmentType',
+	/** {@link RLanguageType} */
+	Language = 'RLanguageType',
+	/** {@link RTypeUnion} */
+	Union = 'RTypeUnion',
+	/** {@link RTypeIntersection} */
+	Intersection = 'RTypeIntersection',
+	/** {@link RTypeVariable} */
+	Variable = 'RTypeVariable',
+	/** {@link RTypeError} */
+	Error = 'RTypeError',
+}
+
+
+export class RAtomicVectorType {
+	readonly tag = DataTypeTag.AtomicVector;
+	readonly elementType: DataType;
+
+	constructor(elementType: DataType) {
+		this.elementType = elementType;
+	}
+}
+
+export class RLogicalType {
+	readonly tag = DataTypeTag.Logical;
+}
+
+export class RIntegerType {
+	readonly tag = DataTypeTag.Integer;
+}
+
+export class RDoubleType {
+	readonly tag = DataTypeTag.Double;
+}
+
+export class RComplexType {
+	readonly tag = DataTypeTag.Complex;
+}
+
+export class RStringType {
+	readonly tag = DataTypeTag.String;
+}
+
+export class RRawType {
+	readonly tag = DataTypeTag.Raw;
+}
+
+export class RListType {
+	readonly tag = DataTypeTag.List;
+	readonly elementType:         DataType;
+	readonly indexedElementTypes: ReadonlyMap<number | string, DataType>;
+
+	constructor(elementType: DataType, indexedElementTypes: Map<number | string, DataType> = new Map()) {
+		this.elementType = elementType;
+		this.indexedElementTypes = indexedElementTypes;
+	}
+}
+
+export class RNullType {
+	readonly tag = DataTypeTag.Null;
+}
+
+export class RFunctionType {
+	readonly tag = DataTypeTag.Function;
+	readonly parameterTypes: Map<number | string, DataType>;
+	readonly returnType:     DataType;
+
+	constructor(parameterTypes: Map<number | string, DataType>, returnType: DataType) {
+		this.parameterTypes = parameterTypes;
+		this.returnType = returnType;
+	}
+}
+
+export class REnvironmentType {
+	readonly tag = DataTypeTag.Environment;
+}
+
+export class RLanguageType {
+	readonly tag = DataTypeTag.Language;
+}
+
+export class RTypeUnion {
+	readonly tag = DataTypeTag.Union;
+	readonly types: Set<DataType> = new Set();
+
+	constructor(...types: DataType[]) {
+		for(const type of types) {
+			guard(type !== this, 'Union cannot contain itself');
+			this.types.add(type);
+		}
+	}
+}
+
+export class RTypeIntersection {
+	readonly tag = DataTypeTag.Intersection;
+	readonly types: Set<DataType> = new Set();
+
+	constructor(...types: DataType[]) {
+		for(const type of types) {
+			guard(type !== this, 'Intersection cannot contain itself');
+			this.types.add(type);
+		}
+	}
+}
+
+export class RTypeVariable {
+	readonly tag = DataTypeTag.Variable;
+	readonly lowerBound: DataType;
+	readonly upperBound: DataType;
+	
+	constructor(lowerBound: DataType = new RTypeUnion(), upperBound: DataType = new RTypeIntersection()) {
+		guard(lowerBound !== this, 'Lower bound cannot be the type variable itself');
+		this.lowerBound = lowerBound;
+		guard(upperBound !== this, 'Upper bound cannot be the type variable itself');
+		this.upperBound = upperBound;
+	}
+}
+
+export class RTypeError {
+	readonly tag = DataTypeTag.Error;
+	conflictingBounds: [DataType, DataType];
+
+	constructor(...conflictingBounds: [DataType, DataType]) {
+		this.conflictingBounds = conflictingBounds;
+	}
+}
+
+
+export type AtomicVectorBaseType
+	= RLogicalType
+	| RIntegerType
+	| RDoubleType
+	| RComplexType
+	| RStringType
+	| RRawType
+
+export function isAtomicVectorBaseType(type: DataType): type is AtomicVectorBaseType {
+	return type.tag === DataTypeTag.Logical
+		|| type.tag === DataTypeTag.Integer
+		|| type.tag === DataTypeTag.Double
+		|| type.tag === DataTypeTag.Complex
+		|| type.tag === DataTypeTag.String
+		|| type.tag === DataTypeTag.Raw;
+}
+
+/**
+ * The `RDataType` type is the union of all possible types that can be inferred
+ * by the type inferencer for R objects.
+ * It should be used whenever you either not care what kind of
+ * type you are dealing with or if you want to handle all possible types.
+*/
+export type DataType
+	= RAtomicVectorType
+	| AtomicVectorBaseType
+	| RListType
+	| RNullType
+	| RFunctionType
+	| REnvironmentType
+	| RLanguageType
+	| RTypeUnion
+	| RTypeIntersection
+	| RTypeVariable
+	| RTypeError;
+
+export type DataTypeInfo = {
+	inferredType: DataType;
+}
\ No newline at end of file
diff --git a/src/typing/unification/infer.ts b/src/typing/unification/infer.ts
index ba5253ec8f8..b12383b44b2 100644
--- a/src/typing/unification/infer.ts
+++ b/src/typing/unification/infer.ts
@@ -8,8 +8,8 @@ import type { RNumber } from '../../r-bridge/lang-4.x/ast/model/nodes/r-number';
 import type { RString } from '../../r-bridge/lang-4.x/ast/model/nodes/r-string';
 import type { NormalizedAst, ParentInformation } from '../../r-bridge/lang-4.x/ast/model/processing/decorate';
 import { mapNormalizedAstInfo } from '../../r-bridge/lang-4.x/ast/model/processing/decorate';
-import type { RDataType } from './types';
-import { RTypeVariable, RComplexType, RDoubleType, RIntegerType, RLogicalType, RStringType, resolveType, RNullType, UnresolvedRListType, RLanguageType, UnresolvedRFunctionType, isVectorType } from './types';
+import type { DataType, DataTypeInfo } from '../types';
+import { RComplexType, RDoubleType, RIntegerType, RLogicalType, RStringType, RNullType, RLanguageType, isAtomicVectorBaseType } from '../types';
 import type { RExpressionList } from '../../r-bridge/lang-4.x/ast/model/nodes/r-expression-list';
 import { guard } from '../../util/assert';
 import { OriginType } from '../../dataflow/origin/dfg-get-origin';
@@ -23,6 +23,7 @@ import type { RSymbol } from '../../r-bridge/lang-4.x/ast/model/nodes/r-symbol';
 import { RType } from '../../r-bridge/lang-4.x/ast/model/type';
 import type { NoInfo } from '../../r-bridge/lang-4.x/ast/model/model';
 import { RFalse, RTrue } from '../../r-bridge/lang-4.x/convert-values';
+import { resolveType, UnresolvedRFunctionType, UnresolvedRListType, UnresolvedRTypeVariable } from './types';
 
 export function inferDataTypes<Info extends ParentInformation & { typeVariable?: undefined }>(ast: NormalizedAst<ParentInformation & Info>, dataflowInfo: DataflowInformation): NormalizedAst<Info & DataTypeInfo> {
 	const astWithTypeVars = decorateTypeVariables(ast);
@@ -41,15 +42,11 @@ export function inferDataTypes<Info extends ParentInformation & { typeVariable?:
 }
 
 type UnresolvedTypeInfo = {
-	typeVariable: RTypeVariable;
+	typeVariable: UnresolvedRTypeVariable;
 };
 
-export type DataTypeInfo = {
-	inferredType: RDataType;
-}
-
 function decorateTypeVariables<Info extends ParentInformation>(ast: NormalizedAst<Info>): NormalizedAst<Info & UnresolvedTypeInfo> {
-	return mapNormalizedAstInfo(ast, node => ({ ...node.info, typeVariable: new RTypeVariable() }));
+	return mapNormalizedAstInfo(ast, node => ({ ...node.info, typeVariable: new UnresolvedRTypeVariable() }));
 }
 
 function resolveTypeVariables<Info extends ParentInformation & UnresolvedTypeInfo>(ast: NormalizedAst<Info>): NormalizedAst<Omit<Info, keyof UnresolvedTypeInfo> & DataTypeInfo> {
@@ -210,9 +207,9 @@ class TypeInferringCfgGuidedVisitor<
 					guard(argNode !== undefined, 'Expected argument node to be defined');
 
 					if(arg.name !== undefined) {
-						functionType.constrainParameterType(arg.name, argNode.info.typeVariable);
+						functionType.getParameterType(arg.name).unify(argNode.info.typeVariable);
 					} else {
-						functionType.constrainParameterType(index, argNode.info.typeVariable);
+						functionType.getParameterType(index).unify(argNode.info.typeVariable);
 					}
 				}
 
@@ -402,9 +399,9 @@ class TypeInferringCfgGuidedVisitor<
 
 			if(!dotsEncountered) {
 				// Only constrain the parameter type positionally if no `...` has been encountered yet
-				functionType.constrainParameterType(index, param.info.typeVariable);
+				functionType.getParameterType(index).unify(param.info.typeVariable);
 			}
-			functionType.constrainParameterType(param.name.lexeme, param.info.typeVariable);
+			functionType.getParameterType(param.name.lexeme).unify(param.info.typeVariable);
 			
 			if(param.defaultValue !== undefined) {
 				param.info.typeVariable.unify(param.defaultValue.info.typeVariable);
@@ -470,7 +467,7 @@ class TypeInferringCfgGuidedVisitor<
 			case '[[':
 				if(firstArgBoundType instanceof UnresolvedRListType) {
 					node.info.typeVariable.unify(firstArgBoundType.elementType);
-				} else if(isVectorType(firstArgBoundType) || firstArgBoundType instanceof RNullType) {
+				} else if(isAtomicVectorBaseType(firstArgBoundType as DataType) || firstArgBoundType instanceof RNullType) {
 					node.info.typeVariable.unify(firstArgType);
 				}
 				break;
diff --git a/src/typing/unification/types.ts b/src/typing/unification/types.ts
index 45dac79b639..8f6ad5a3ae1 100644
--- a/src/typing/unification/types.ts
+++ b/src/typing/unification/types.ts
@@ -1,101 +1,9 @@
-/**
- * This enum lists a tag for each of the possible R data types inferred by the
- * type inferencer. It is mainly used to identify subtypes of {@link RDataType}.
- */
-export enum RDataTypeTag {
-    /** {@link RLogicalType} */
-    Logical = 'RLogicalType',
-    /** {@link RIntegerType} */
-    Integer = 'RIntegerType',
-    /** {@link RDoubleType} */
-    Double = 'RDoubleType',
-    /** {@link RComplexType} */
-	Complex = 'RComplexType',
-    /** {@link RStringType} */
-    String = 'RStringType',
-    /** {@link RRawType} */
-    Raw = 'RRawType',
-    /** {@link RNullType} */
-	Null = 'RNullType',
-    /** {@link RFunctionType} */
-    Function = 'RFunctionType',
-    /** {@link RListType} */
-    List = 'RListType',
-    /** {@link REnvironmentType} */
-    Environment = 'REnvironmentType',
-    /** {@link RLanguageType} */
-    Language = 'RLanguageType',
-	/** {@link RTypeVariable} */
-    Variable = 'RTypeVariable',
-	/** {@link RErrorType} */
-	Error = 'RErrorType',
-	/** {@link RUnknownType} */
-	Unknown = 'RUnknownType',
-}
-
-export class RLogicalType {
-	readonly tag = RDataTypeTag.Logical;
-}
-
-export class RIntegerType {
-	readonly tag = RDataTypeTag.Integer;
-}
-
-export class RDoubleType {
-	readonly tag = RDataTypeTag.Double;
-}
-
-export class RComplexType {
-	readonly tag = RDataTypeTag.Complex;
-}
-
-export class RStringType {
-	readonly tag = RDataTypeTag.String;
-}
-
-export class RRawType {
-	readonly tag = RDataTypeTag.Raw;
-}
-
-export class RNullType {
-	readonly tag = RDataTypeTag.Null;
-}
-
-export class UnresolvedRFunctionType {
-	readonly tag = RDataTypeTag.Function;
-	readonly parameterTypes = new Map<number | string, RTypeVariable>();
-	readonly returnType = new RTypeVariable();
-
-	constrainParameterType(indexOrName: number | string, type: UnresolvedRDataType): void {
-		if(!this.parameterTypes.has(indexOrName)) {
-			this.parameterTypes.set(indexOrName, new RTypeVariable());
-		}
-		// eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-		this.parameterTypes.get(indexOrName)!.unify(type);
-	}
-
-	unify(other: UnresolvedRFunctionType): void {
-		for(const [key, type] of other.parameterTypes) {
-			this.constrainParameterType(key, type);
-		}
-		this.returnType.unify(other.returnType);
-	}
-}
-
-export class RFunctionType {
-	readonly tag = RDataTypeTag.Function;
-	readonly parameterTypes: Map<number | string, RDataType>;
-	readonly returnType:     RDataType;
-
-	constructor(parameterTypes: Map<number | string, RDataType>, returnType: RDataType) {
-		this.parameterTypes = parameterTypes;
-		this.returnType = returnType;
-	}
-}
+import type { AtomicVectorBaseType, DataType, REnvironmentType, RLanguageType, RNullType } from '../types';
+import { DataTypeTag, RFunctionType, RListType, RTypeError, RTypeVariable } from '../types';
 
 export class UnresolvedRListType {
-	readonly tag = RDataTypeTag.List;
-	readonly elementType = new RTypeVariable();
+	readonly tag = DataTypeTag.List;
+	readonly elementType = new UnresolvedRTypeVariable();
 
 	constructor(elementType?: UnresolvedRDataType) {
 		if(elementType !== undefined) {
@@ -108,74 +16,66 @@ export class UnresolvedRListType {
 	}
 }
 
-export class RListType {
-	readonly tag = RDataTypeTag.List;
-	readonly elementType: RDataType;
+export class UnresolvedRFunctionType {
+	readonly tag = DataTypeTag.Function;
+	readonly parameterTypes = new Map<number | string, UnresolvedRTypeVariable>();
+	readonly returnType = new UnresolvedRTypeVariable();
 
-	constructor(elementType: RDataType) {
-		this.elementType = elementType;
+	unify(other: UnresolvedRFunctionType): void {
+		for(const [key, type] of other.parameterTypes) {
+			this.getParameterType(key).unify(type);
+		}
+		this.returnType.unify(other.returnType);
 	}
-}
 
-export class REnvironmentType {
-	readonly tag = RDataTypeTag.Environment;
-}
-
-export class RLanguageType {
-	readonly tag = RDataTypeTag.Language;
+	getParameterType(indexOrName: number | string): UnresolvedRTypeVariable {
+		let parameterType = this.parameterTypes.get(indexOrName);
+		if(parameterType === undefined) {
+			parameterType = new UnresolvedRTypeVariable();
+			this.parameterTypes.set(indexOrName, parameterType);
+		}
+		return parameterType;
+	}
 }
 
-export class RTypeVariable {
-	readonly tag = RDataTypeTag.Variable;
-	private boundType: UnresolvedRDataType = new RUnknownType();
+export class UnresolvedRTypeVariable {
+	readonly tag = DataTypeTag.Variable;
+	private boundType: UnresolvedRDataType | undefined;
 
 	find(): UnresolvedRDataType {
-		if(this.boundType instanceof RTypeVariable) {
+		if(this.boundType instanceof UnresolvedRTypeVariable) {
 			this.boundType = this.boundType.find();
 		}
-		return this.boundType.tag !== RDataTypeTag.Unknown ? this.boundType : this;
+		return this.boundType ?? this;
 	}
 
 	unify(other: UnresolvedRDataType): void {
 		const thisRep = this.find();
-		const otherRep = other instanceof RTypeVariable ? other.find() : other;
+		const otherRep = other instanceof UnresolvedRTypeVariable ? other.find() : other;
 
 		if(thisRep === otherRep) {
 			return;
 		}
 
-		if(thisRep instanceof RTypeVariable) {
+		if(thisRep instanceof UnresolvedRTypeVariable) {
 			thisRep.boundType = otherRep;
-		} else if(otherRep instanceof RTypeVariable) {
+		} else if(otherRep instanceof UnresolvedRTypeVariable) {
 			otherRep.boundType = thisRep;
 		} else if(thisRep instanceof UnresolvedRFunctionType && otherRep instanceof UnresolvedRFunctionType) {
 			thisRep.unify(otherRep);
 		} else if(thisRep instanceof UnresolvedRListType && otherRep instanceof UnresolvedRListType) {
 			thisRep.unify(otherRep);
-		} else if(thisRep instanceof RErrorType || thisRep.tag !== otherRep.tag) {
-			this.boundType = new RErrorType(resolveType(thisRep), resolveType(otherRep));
+		} else if(thisRep instanceof RTypeError || thisRep.tag !== otherRep.tag) {
+			this.boundType = new RTypeError(resolveType(thisRep), resolveType(otherRep));
 		}
 	}
 }
 
-export class RErrorType {
-	readonly tag = RDataTypeTag.Error;
-	conflictingBounds: [RDataType, RDataType];
 
-	constructor(...conflictingBounds: [RDataType, RDataType]) {
-		this.conflictingBounds = conflictingBounds;
-	}
-}
-
-export class RUnknownType {
-	readonly tag = RDataTypeTag.Unknown;
-}
-
-
-export function resolveType(type: UnresolvedRDataType): RDataType {
-	if(type instanceof RTypeVariable) {
+export function resolveType(type: UnresolvedRDataType): DataType {
+	if(type instanceof UnresolvedRTypeVariable) {
 		const typeRep = type.find();
-		return typeRep !== type ? resolveType(typeRep) : { tag: RDataTypeTag.Unknown };
+		return typeRep !== type ? resolveType(typeRep) : new RTypeVariable();
 	} else if(type instanceof UnresolvedRFunctionType) {
 		const resolvedParameterTypes = new Map(type.parameterTypes.entries().toArray().map(([key, type]) => [key, resolveType(type)]));
 		const resolvedReturnType = resolveType(type.returnType);
@@ -187,56 +87,13 @@ export function resolveType(type: UnresolvedRDataType): RDataType {
 		return type;
 	}
 }
-
-
-export type RVectorType
-	= RLogicalType
-	| RIntegerType
-	| RDoubleType
-	| RComplexType
-	| RStringType
-	| RRawType
-
-export function isVectorType(type: RDataType | UnresolvedRDataType): type is RVectorType {
-	return type.tag === RDataTypeTag.Logical
-		|| type.tag === RDataTypeTag.Integer
-		|| type.tag === RDataTypeTag.Double
-		|| type.tag === RDataTypeTag.Complex
-		|| type.tag === RDataTypeTag.String
-		|| type.tag === RDataTypeTag.Raw;
-}
-	
-export type CompoundRDataType = RFunctionType | RListType;
-
-export function isCompoundType(type: UnresolvedRDataType): type is UnresolvedCompoundRDataType
-export function isCompoundType(type: RDataType): type is CompoundRDataType
-export function isCompoundType(type: RDataType | UnresolvedRDataType): type is CompoundRDataType | UnresolvedCompoundRDataType {
-	return type.tag === RDataTypeTag.Function || type.tag === RDataTypeTag.List;
-}
-
-/**
- * The `RDataType` type is the union of all possible types that can be inferred
- * by the type inferencer for R objects.
- * It should be used whenever you either not care what kind of
- * type you are dealing with or if you want to handle all possible types.
-*/
-export type RDataType
-	= RVectorType
-	| RNullType
-	| REnvironmentType
-	| RLanguageType
-	| CompoundRDataType
-	| RErrorType
-	| RUnknownType;
-	
-export type UnresolvedCompoundRDataType = UnresolvedRFunctionType | UnresolvedRListType;
 	
 export type UnresolvedRDataType
-	= RVectorType
+	= AtomicVectorBaseType
+	| UnresolvedRListType
 	| RNullType
+	| UnresolvedRFunctionType
 	| REnvironmentType
 	| RLanguageType
-	| UnresolvedCompoundRDataType
-	| RTypeVariable
-	| RErrorType
-	| RUnknownType;
\ No newline at end of file
+	| UnresolvedRTypeVariable
+	| RTypeError;
\ No newline at end of file
diff --git a/test/functionality/_helper/typing/subtyping/assert-inferred-type.ts b/test/functionality/_helper/typing/subtyping/assert-inferred-type.ts
index 9c6febc5715..c2dbc738199 100644
--- a/test/functionality/_helper/typing/subtyping/assert-inferred-type.ts
+++ b/test/functionality/_helper/typing/subtyping/assert-inferred-type.ts
@@ -2,8 +2,8 @@ import { describe, expect, test } from 'vitest';
 import { TreeSitterExecutor } from '../../../../../src/r-bridge/lang-4.x/tree-sitter/tree-sitter-executor';
 import { createDataflowPipeline } from '../../../../../src/core/steps/pipeline/default-pipelines';
 import { requestFromInput } from '../../../../../src/r-bridge/retriever';
-import { RTypeIntersection, RTypeUnion, RTypeVariable, type DataType } from '../../../../../src/typing/subtyping/types';
-import type { DataTypeInfo } from '../../../../../src/typing/subtyping/infer';
+import type { DataType, DataTypeInfo } from '../../../../../src/typing/types';
+import { RTypeIntersection, RTypeUnion, RTypeVariable } from '../../../../../src/typing/types';
 import { inferDataTypes } from '../../../../../src/typing/subtyping/infer';
 import { type FlowrSearch } from '../../../../../src/search/flowr-search-builder';
 import { runSearch } from '../../../../../src/search/flowr-search-executor';
diff --git a/test/functionality/_helper/typing/unification/assert-inferred-type.ts b/test/functionality/_helper/typing/unification/assert-inferred-type.ts
index 463a497e2b9..7dfb698e4e8 100644
--- a/test/functionality/_helper/typing/unification/assert-inferred-type.ts
+++ b/test/functionality/_helper/typing/unification/assert-inferred-type.ts
@@ -2,12 +2,12 @@ import { describe, expect, test } from 'vitest';
 import { TreeSitterExecutor } from '../../../../../src/r-bridge/lang-4.x/tree-sitter/tree-sitter-executor';
 import { createDataflowPipeline } from '../../../../../src/core/steps/pipeline/default-pipelines';
 import { requestFromInput } from '../../../../../src/r-bridge/retriever';
-import type { RDataType } from '../../../../../src/typing/unification/types';
+import type { DataType } from '../../../../../src/typing/types';
 import { inferDataTypes } from '../../../../../src/typing/unification/infer';
 import type { FlowrSearch } from '../../../../../src/search/flowr-search-builder';
 import { runSearch } from '../../../../../src/search/flowr-search-executor';
 
-export function assertInferredType(input: string, expectedType: RDataType): void {
+export function assertInferredType(input: string, expectedType: DataType): void {
 	test(`Infer ${expectedType.tag} for ${input}`, async() => {
 		const executor = new TreeSitterExecutor();
 		const result = await createDataflowPipeline(executor, { request: requestFromInput(input) }).allRemainingSteps();
@@ -18,7 +18,7 @@ export function assertInferredType(input: string, expectedType: RDataType): void
 }
 export function assertInferredTypes(
 	input: string,
-	...expectations: { query: FlowrSearch, expectedType: RDataType }[]
+	...expectations: { query: FlowrSearch, expectedType: DataType }[]
 ): void {
 	describe(`Infer types for ${input}`, async() => {
 		const executor = new TreeSitterExecutor();
diff --git a/test/functionality/typing/subtyping/builtin-functions.test.ts b/test/functionality/typing/subtyping/builtin-functions.test.ts
index 7a7004d86ad..b6521e7e2bf 100644
--- a/test/functionality/typing/subtyping/builtin-functions.test.ts
+++ b/test/functionality/typing/subtyping/builtin-functions.test.ts
@@ -1,5 +1,5 @@
 import { describe } from 'vitest';
-import { RTypeIntersection, RIntegerType, RLanguageType, RListType, RLogicalType, RTypeUnion, RNullType, RStringType, RTypeVariable, RAtomicVectorType } from '../../../../src/typing/subtyping/types';
+import { RTypeIntersection, RIntegerType, RLanguageType, RListType, RLogicalType, RTypeUnion, RNullType, RStringType, RTypeVariable, RAtomicVectorType } from '../../../../src/typing/types';
 import { assertInferredType, assertInferredTypes } from '../../_helper/typing/subtyping/assert-inferred-type';
 import { Q } from '../../../../src/search/flowr-search-builder';
 
diff --git a/test/functionality/typing/subtyping/conditionals.test.ts b/test/functionality/typing/subtyping/conditionals.test.ts
index f7c49366e4b..340cdce4fe2 100644
--- a/test/functionality/typing/subtyping/conditionals.test.ts
+++ b/test/functionality/typing/subtyping/conditionals.test.ts
@@ -1,5 +1,5 @@
 import { describe } from 'vitest';
-import { RLogicalType, RTypeUnion, RNullType, RStringType } from '../../../../src/typing/subtyping/types';
+import { RLogicalType, RTypeUnion, RNullType, RStringType } from '../../../../src/typing/types';
 import { assertInferredType, assertInferredTypes } from '../../_helper/typing/subtyping/assert-inferred-type';
 import { Q } from '../../../../src/search/flowr-search-builder';
 import { RType } from '../../../../src/r-bridge/lang-4.x/ast/model/type';
diff --git a/test/functionality/typing/subtyping/constants.test.ts b/test/functionality/typing/subtyping/constants.test.ts
index f8fbf568597..83eb19f504f 100644
--- a/test/functionality/typing/subtyping/constants.test.ts
+++ b/test/functionality/typing/subtyping/constants.test.ts
@@ -1,5 +1,5 @@
 import { describe } from 'vitest';
-import { RComplexType, RDoubleType, RIntegerType, RLogicalType, RNullType, RStringType } from '../../../../src/typing/subtyping/types';
+import { RComplexType, RDoubleType, RIntegerType, RLogicalType, RNullType, RStringType } from '../../../../src/typing/types';
 import { assertInferredType } from '../../_helper/typing/subtyping/assert-inferred-type';
 
 describe('Infer types for constants', () => {
diff --git a/test/functionality/typing/subtyping/constrain.test.ts b/test/functionality/typing/subtyping/constrain.test.ts
index bfd21e63d46..18e41fe7fbb 100644
--- a/test/functionality/typing/subtyping/constrain.test.ts
+++ b/test/functionality/typing/subtyping/constrain.test.ts
@@ -1,5 +1,6 @@
 import { describe, expect, test } from 'vitest';
-import { constrainWithLowerBound, constrainWithUpperBound, RComplexType, RDoubleType, resolveType, RIntegerType, RListType, RStringType, RTypeIntersection, RTypeVariable, UnresolvedRAtomicVectorType, UnresolvedRFunctionType, UnresolvedRListType, UnresolvedRTypeIntersection, UnresolvedRTypeUnion, UnresolvedRTypeVariable } from '../../../../src/typing/subtyping/types';
+import { constrainWithLowerBound, constrainWithUpperBound, resolveType, UnresolvedRAtomicVectorType, UnresolvedRFunctionType, UnresolvedRListType, UnresolvedRTypeIntersection, UnresolvedRTypeUnion, UnresolvedRTypeVariable } from '../../../../src/typing/subtyping/types';
+import { RIntegerType, RComplexType, RTypeVariable, RDoubleType, RStringType, RListType, RTypeIntersection } from '../../../../src/typing/types';
 
 describe('Constrain types with lower and upper bounds', () => {
 	test('Constrain with numeric bounds', () => {
diff --git a/test/functionality/typing/subtyping/loops.test.ts b/test/functionality/typing/subtyping/loops.test.ts
index 83420891424..e48fbc6545f 100644
--- a/test/functionality/typing/subtyping/loops.test.ts
+++ b/test/functionality/typing/subtyping/loops.test.ts
@@ -1,5 +1,5 @@
 import { describe } from 'vitest';
-import { RLogicalType, RTypeUnion, RNullType } from '../../../../src/typing/subtyping/types';
+import { RLogicalType, RTypeUnion, RNullType } from '../../../../src/typing/types';
 import { assertInferredType, assertInferredTypes } from '../../_helper/typing/subtyping/assert-inferred-type';
 import { Q } from '../../../../src/search/flowr-search-builder';
 import { RType } from '../../../../src/r-bridge/lang-4.x/ast/model/type';
diff --git a/test/functionality/typing/subtyping/subsetting.test.ts b/test/functionality/typing/subtyping/subsetting.test.ts
index 30678b95713..44fa1adfd6b 100644
--- a/test/functionality/typing/subtyping/subsetting.test.ts
+++ b/test/functionality/typing/subtyping/subsetting.test.ts
@@ -1,6 +1,6 @@
 import { describe } from 'vitest';
-import type { DataType } from '../../../../src/typing/subtyping/types';
-import { RTypeIntersection, RAtomicVectorType, RIntegerType, RListType, RTypeVariable, RTypeUnion, RNullType, RLogicalType } from '../../../../src/typing/subtyping/types';
+import type { DataType } from '../../../../src/typing/types';
+import { RTypeIntersection, RAtomicVectorType, RIntegerType, RListType, RTypeVariable, RTypeUnion, RNullType, RLogicalType } from '../../../../src/typing/types';
 import { assertInferredTypes } from '../../_helper/typing/subtyping/assert-inferred-type';
 import { Q } from '../../../../src/search/flowr-search-builder';
 import { RType } from '../../../../src/r-bridge/lang-4.x/ast/model/type';
diff --git a/test/functionality/typing/subtyping/unsupported-expressions.test.ts b/test/functionality/typing/subtyping/unsupported-expressions.test.ts
index 05a01b244d6..090b671232b 100644
--- a/test/functionality/typing/subtyping/unsupported-expressions.test.ts
+++ b/test/functionality/typing/subtyping/unsupported-expressions.test.ts
@@ -1,5 +1,5 @@
 import { describe } from 'vitest';
-import { RTypeIntersection, RTypeUnion, RTypeVariable } from '../../../../src/typing/subtyping/types';
+import { RTypeIntersection, RTypeUnion, RTypeVariable } from '../../../../src/typing/types';
 import { assertInferredType } from '../../_helper/typing/subtyping/assert-inferred-type';
 
 describe('Infer no type information for currently unsupported R expressions', () => {
diff --git a/test/functionality/typing/subtyping/variables.test.ts b/test/functionality/typing/subtyping/variables.test.ts
index a4723def0ea..1a603dc8cf0 100644
--- a/test/functionality/typing/subtyping/variables.test.ts
+++ b/test/functionality/typing/subtyping/variables.test.ts
@@ -1,5 +1,5 @@
 import { describe } from 'vitest';
-import { RIntegerType } from '../../../../src/typing/subtyping/types';
+import { RIntegerType } from '../../../../src/typing/types';
 import { assertInferredTypes } from '../../_helper/typing/subtyping/assert-inferred-type';
 import { Q } from '../../../../src/search/flowr-search-builder';
 
diff --git a/test/functionality/typing/unification/builtin-functions.test.ts b/test/functionality/typing/unification/builtin-functions.test.ts
index a3d5cbff7dc..3788083e8e5 100644
--- a/test/functionality/typing/unification/builtin-functions.test.ts
+++ b/test/functionality/typing/unification/builtin-functions.test.ts
@@ -1,5 +1,5 @@
 import { describe } from 'vitest';
-import { RDoubleType, RLanguageType, RListType, RLogicalType, RNullType, RStringType, RUnknownType } from '../../../../src/typing/unification/types';
+import { RDoubleType, RLanguageType, RListType, RLogicalType, RNullType, RStringType, RTypeVariable } from '../../../../src/typing/types';
 import { assertInferredType, assertInferredTypes } from '../../_helper/typing/unification/assert-inferred-type';
 import { Q } from '../../../../src/search/flowr-search-builder';
 
@@ -15,7 +15,7 @@ describe('Infer types for builtin functions', () => {
 
 	assertInferredTypes(
 		'eval(quote(TRUE))',
-		{ query: Q.criterion('1@eval').build(),  expectedType: new RUnknownType() },
+		{ query: Q.criterion('1@eval').build(),  expectedType: new RTypeVariable() },
 		{ query: Q.criterion('1@quote').build(), expectedType: new RLanguageType() },
 		{ query: Q.criterion('1@TRUE').build(),  expectedType: new RLogicalType() }
 	);
diff --git a/test/functionality/typing/unification/conditionals.test.ts b/test/functionality/typing/unification/conditionals.test.ts
index c9ce4ba2583..98a1af27bee 100644
--- a/test/functionality/typing/unification/conditionals.test.ts
+++ b/test/functionality/typing/unification/conditionals.test.ts
@@ -1,5 +1,5 @@
 import { describe } from 'vitest';
-import { RDoubleType, RLogicalType, RNullType, RStringType, RUnknownType } from '../../../../src/typing/unification/types';
+import { RDoubleType, RLogicalType, RNullType, RStringType, RTypeVariable } from '../../../../src/typing/types';
 import { assertInferredType, assertInferredTypes } from '../../_helper/typing/unification/assert-inferred-type';
 import { Q } from '../../../../src/search/flowr-search-builder';
 import { RType } from '../../../../src/r-bridge/lang-4.x/ast/model/type';
@@ -8,7 +8,7 @@ describe('Infer types for if statements', () => {
 	describe.each([
 		{ input: 'if(FALSE) { TRUE }',                     expectedType: new RNullType() },
 		{ input: 'if(TRUE) { 1 } else { NULL }',           expectedType: new RDoubleType() },
-		{ input: 'if(stop("stop here")) { 1 } else { 2 }', expectedType: new RUnknownType() },
+		{ input: 'if(stop("stop here")) { 1 } else { 2 }', expectedType: new RTypeVariable() },
 	])('Infer $expectedType for $input', ({ input, expectedType }) => assertInferredType(input, expectedType));
 
 	assertInferredTypes(
diff --git a/test/functionality/typing/unification/constants.test.ts b/test/functionality/typing/unification/constants.test.ts
index 58e0390f764..6ea477023a5 100644
--- a/test/functionality/typing/unification/constants.test.ts
+++ b/test/functionality/typing/unification/constants.test.ts
@@ -1,5 +1,5 @@
 import { describe } from 'vitest';
-import { RComplexType, RDoubleType, RIntegerType, RLogicalType, RNullType, RStringType } from '../../../../src/typing/unification/types';
+import { RComplexType, RDoubleType, RIntegerType, RLogicalType, RNullType, RStringType } from '../../../../src/typing/types';
 import { assertInferredType } from '../../_helper/typing/unification/assert-inferred-type';
 
 describe.each([
diff --git a/test/functionality/typing/unification/loops.test.ts b/test/functionality/typing/unification/loops.test.ts
index 2a71eb884f1..576bc9949de 100644
--- a/test/functionality/typing/unification/loops.test.ts
+++ b/test/functionality/typing/unification/loops.test.ts
@@ -1,5 +1,5 @@
 import { describe } from 'vitest';
-import { RLogicalType, RNullType, RUnknownType } from '../../../../src/typing/unification/types';
+import { RLogicalType, RNullType, RTypeVariable } from '../../../../src/typing/types';
 import { assertInferredType, assertInferredTypes } from '../../_helper/typing/unification/assert-inferred-type';
 import { Q } from '../../../../src/search/flowr-search-builder';
 import { RType } from '../../../../src/r-bridge/lang-4.x/ast/model/type';
@@ -7,12 +7,12 @@ import { RType } from '../../../../src/r-bridge/lang-4.x/ast/model/type';
 describe('Infer types for loops', () => {
 	describe.each([
 		{ input: 'while(FALSE) { print("Testing is fun!") }',                         expectedType: new RNullType() },
-		{ input: 'while(TRUE) { next }',                                              expectedType: new RUnknownType() },
+		{ input: 'while(TRUE) { next }',                                              expectedType: new RTypeVariable() },
 		{ input: 'while(1 < 2) { print("Hi Flo!") }',                                 expectedType: new RNullType() },
 		{ input: 'while(TRUE) { break }',                                             expectedType: new RNullType() },
 		{ input: 'for(i in NULL) { print("I would like to write a test for that") }', expectedType: new RNullType() },
 		{ input: 'for(i in 1:10) { print(i) }',                                       expectedType: new RNullType() },
-		{ input: 'repeat { print("I love testing!") }',                               expectedType: new RUnknownType() },
+		{ input: 'repeat { print("I love testing!") }',                               expectedType: new RTypeVariable() },
 		{ input: 'repeat { break }',                                                  expectedType: new RNullType() },
 	])('Infer $expectedType for $input', ({ input, expectedType }) => assertInferredType(input, expectedType));
 
diff --git a/test/functionality/typing/unification/subsetting.test.ts b/test/functionality/typing/unification/subsetting.test.ts
index 16c0bbe9e43..099bbb2c4ae 100644
--- a/test/functionality/typing/unification/subsetting.test.ts
+++ b/test/functionality/typing/unification/subsetting.test.ts
@@ -1,5 +1,5 @@
 import { describe } from 'vitest';
-import { RDoubleType, RErrorType, RListType, RLogicalType, RNullType } from '../../../../src/typing/unification/types';
+import { RDoubleType, RTypeError, RListType, RLogicalType, RNullType } from '../../../../src/typing/types';
 import { assertInferredTypes } from '../../_helper/typing/unification/assert-inferred-type';
 import { Q } from '../../../../src/search/flowr-search-builder';
 import { RType } from '../../../../src/r-bridge/lang-4.x/ast/model/type';
@@ -55,7 +55,7 @@ describe('Infer types for subsetting expressions', () => {
 	
 	assertInferredTypes(
 		'l <- list(TRUE, a = 42, NULL); l$a',
-		{ query: Q.var('l').last().build(),                    expectedType: new RListType(new RErrorType(new RErrorType(new RLogicalType(), new RDoubleType()), new RNullType())) },
-		{ query: Q.all().filter(RType.Access).first().build(), expectedType: new RErrorType(new RErrorType(new RLogicalType(), new RDoubleType()), new RNullType()) },
+		{ query: Q.var('l').last().build(),                    expectedType: new RListType(new RTypeError(new RTypeError(new RLogicalType(), new RDoubleType()), new RNullType())) },
+		{ query: Q.all().filter(RType.Access).first().build(), expectedType: new RTypeError(new RTypeError(new RLogicalType(), new RDoubleType()), new RNullType()) },
 	);
 });
\ No newline at end of file
diff --git a/test/functionality/typing/unification/unsupported-expressions.test.ts b/test/functionality/typing/unification/unsupported-expressions.test.ts
index 286b5296894..c376842bd80 100644
--- a/test/functionality/typing/unification/unsupported-expressions.test.ts
+++ b/test/functionality/typing/unification/unsupported-expressions.test.ts
@@ -1,8 +1,8 @@
 import { describe } from 'vitest';
-import { RUnknownType } from '../../../../src/typing/unification/types';
+import { RTypeVariable } from '../../../../src/typing/types';
 import { assertInferredType } from '../../_helper/typing/unification/assert-inferred-type';
 
 describe('Infer no type information for currently unsupported R expressions', () => {
-	assertInferredType('1 + 2',                  new RUnknownType());
-	assertInferredType('print("Hello, world!")', new RUnknownType());
+	assertInferredType('1 + 2',                  new RTypeVariable());
+	assertInferredType('print("Hello, world!")', new RTypeVariable());
 });
\ No newline at end of file
diff --git a/test/functionality/typing/unification/variables.test.ts b/test/functionality/typing/unification/variables.test.ts
index 00fa3dbdca9..5c1793b7524 100644
--- a/test/functionality/typing/unification/variables.test.ts
+++ b/test/functionality/typing/unification/variables.test.ts
@@ -1,5 +1,5 @@
 import { describe } from 'vitest';
-import { RDoubleType } from '../../../../src/typing/unification/types';
+import { RDoubleType } from '../../../../src/typing/types';
 import { assertInferredTypes } from '../../_helper/typing/unification/assert-inferred-type';
 import { Q } from '../../../../src/search/flowr-search-builder';
 

From ddeaf326cc8ea86391e0bda93026f6231ddd0739 Mon Sep 17 00:00:00 2001
From: Lukas Rohde <lukas.rohde@silupe.de>
Date: Wed, 16 Jul 2025 15:29:44 +0200
Subject: [PATCH 099/153] feat(typing): add support for using subtyping in
 datatype queries

---
 .../datatype-query/datatype-query-executor.ts | 43 +++++++++++++------
 .../datatype-query/datatype-query-format.ts   | 11 ++---
 2 files changed, 36 insertions(+), 18 deletions(-)

diff --git a/src/queries/catalog/datatype-query/datatype-query-executor.ts b/src/queries/catalog/datatype-query/datatype-query-executor.ts
index d9652b2a9d3..2984c6f526a 100644
--- a/src/queries/catalog/datatype-query/datatype-query-executor.ts
+++ b/src/queries/catalog/datatype-query/datatype-query-executor.ts
@@ -2,25 +2,42 @@ import type { DatatypeQuery, DatatypeQueryResult } from './datatype-query-format
 import { log } from '../../../util/log';
 import type { BasicQueryData } from '../../base-query-format';
 import type { NormalizedAst, ParentInformation } from '../../../r-bridge/lang-4.x/ast/model/processing/decorate';
+import type { SingleSlicingCriterion } from '../../../slicing/criterion/parse';
 import { slicingCriterionToId } from '../../../slicing/criterion/parse';
 import { inferDataTypes } from '../../../typing/unification/infer';
+import { inferDataTypes as inferDataTypesUsingSubtyping } from '../../../typing/subtyping/infer';
+import type { DataTypeInfo } from '../../../typing/types';
 
 export function executeDatatypeQuery({ dataflow, ast }: BasicQueryData, queries: readonly DatatypeQuery[]): DatatypeQueryResult {
-	const start = Date.now();
 	const result: DatatypeQueryResult['inferredTypes'] = {};
-	const typedAst = inferDataTypes(ast as NormalizedAst<ParentInformation & { typeVariable?: undefined }>, dataflow);
-	
-	for(const { criterion } of queries) {
-		if(result[criterion ?? '1:1'] !== undefined) {
-			log.warn('Duplicate criterion in datatype query:', criterion);
-			continue;
-		}
-		const node = criterion !== undefined ? typedAst.idMap.get(slicingCriterionToId(criterion, typedAst.idMap)) : typedAst.ast;
-		if(node === undefined) {
-			log.warn('Criterion not found in normalized AST:', criterion);
-			continue;
+	const extractInferredTypeFromAst = (typedAst: NormalizedAst<DataTypeInfo>, criteria: SingleSlicingCriterion[]): void => {
+		for(const criterion of criteria) {
+			if(result[criterion] !== undefined) {
+				log.warn('Duplicate criterion in datatype query:', criterion);
+				continue;
+			}
+			
+			const node = criterion !== undefined ? typedAst.idMap.get(slicingCriterionToId(criterion, typedAst.idMap)) : typedAst.ast;
+			if(node === undefined) {
+				log.warn('Criterion not found in normalized AST:', criterion);
+				continue;
+			}
+			
+			result[criterion] = node.info.inferredType;
 		}
-		result[criterion ?? '1:1'] = node.info.inferredType;
+	};
+	const [queriesWithoutSubtyping, queriesUsingSubtyping] = queries.reduce(([unificationGroup, subtypingGroup], query) => query.useSubtyping ? [unificationGroup, [...subtypingGroup, query]] : [[...unificationGroup, query], subtypingGroup], [[], []] as [DatatypeQuery[], DatatypeQuery[]]);
+
+	const start = Date.now();
+
+	if(queriesWithoutSubtyping.length > 0) {
+		const typedAst = inferDataTypes(ast as NormalizedAst<ParentInformation & { typeVariable?: undefined }>, dataflow);
+		extractInferredTypeFromAst(typedAst, queriesWithoutSubtyping.map(query => query.criterion ?? '1:1'));
+	}
+
+	if(queriesUsingSubtyping.length > 0) {
+		const typedAst = inferDataTypesUsingSubtyping(ast as NormalizedAst<ParentInformation & { typeVariable?: undefined }>, dataflow);
+		extractInferredTypeFromAst(typedAst, queriesUsingSubtyping.map(query => query.criterion ?? '1:1'));
 	}
 
 	return {
diff --git a/src/queries/catalog/datatype-query/datatype-query-format.ts b/src/queries/catalog/datatype-query/datatype-query-format.ts
index 46e270565ae..27ce823a246 100644
--- a/src/queries/catalog/datatype-query/datatype-query-format.ts
+++ b/src/queries/catalog/datatype-query/datatype-query-format.ts
@@ -5,7 +5,6 @@ import { bold } from '../../../util/text/ansi';
 import { printAsMs } from '../../../util/text/time';
 import Joi from 'joi';
 import { executeDatatypeQuery } from './datatype-query-executor';
-
 import { asciiDataType } from '../../query-print';
 import type { DataType } from '../../../typing/types';
 
@@ -13,8 +12,9 @@ import type { DataType } from '../../../typing/types';
  * Calculates the inferred data type for the given criterion.
  */
 export interface DatatypeQuery extends BaseQueryFormat {
-	readonly type:       'datatype';
-	readonly criterion?: SingleSlicingCriterion;
+	readonly type:          'datatype';
+	readonly criterion?:    SingleSlicingCriterion;
+	readonly useSubtyping?: boolean;
 }
 
 export interface DatatypeQueryResult extends BaseQueryResult {
@@ -36,7 +36,8 @@ export const DatatypeQueryDefinition = {
 		return [];
 	},
 	schema: Joi.object({
-		type:      Joi.string().valid('datatype').required().description('The type of the query.'),
-		criterion: Joi.string().optional().description('The slicing criterion of the node to get the inferred data type for.')
+		type:         Joi.string().valid('datatype').required().description('The type of the query.'),
+		criterion:    Joi.string().optional().description('The slicing criterion of the node to get the inferred data type for.'),
+		useSubtyping: Joi.boolean().optional().default(false).description('Whether to use subtyping to infer the data type.'),
 	}).description('Datatype query used to extract the inferred data type for a node in the normalized AST')
 } as const satisfies SupportedQuery<'datatype'>;

From 2327a7c7b109a5739f51c71f64a2b4d0403f8301 Mon Sep 17 00:00:00 2001
From: Lukas Rohde <lukas.rohde@silupe.de>
Date: Fri, 18 Jul 2025 16:52:56 +0200
Subject: [PATCH 100/153] feat-fix(typing): add constraint caching to prevent
 infinite recursion

---
 src/typing/subtyping/infer.ts                 | 204 +++++++-----------
 src/typing/subtyping/types.ts                 | 171 ++++++++-------
 .../typing/subtyping/constrain.test.ts        |  81 ++++---
 3 files changed, 231 insertions(+), 225 deletions(-)

diff --git a/src/typing/subtyping/infer.ts b/src/typing/subtyping/infer.ts
index 3a14f6ee27b..a0bbed3195f 100644
--- a/src/typing/subtyping/infer.ts
+++ b/src/typing/subtyping/infer.ts
@@ -8,7 +8,7 @@ import type { RNumber } from '../../r-bridge/lang-4.x/ast/model/nodes/r-number';
 import type { RString } from '../../r-bridge/lang-4.x/ast/model/nodes/r-string';
 import type { NormalizedAst, ParentInformation } from '../../r-bridge/lang-4.x/ast/model/processing/decorate';
 import { mapNormalizedAstInfo } from '../../r-bridge/lang-4.x/ast/model/processing/decorate';
-import type { DataTypeInfo } from '../types';
+import type { DataType, DataTypeInfo } from '../types';
 import { RComplexType, RDoubleType, RIntegerType, RLogicalType, RStringType, RNullType, RLanguageType } from '../types';
 import type { RExpressionList } from '../../r-bridge/lang-4.x/ast/model/nodes/r-expression-list';
 import { guard } from '../../util/assert';
@@ -21,10 +21,10 @@ import type { ControlFlowInformation } from '../../control-flow/control-flow-gra
 import { CfgEdgeType, CfgVertexType } from '../../control-flow/control-flow-graph';
 import type { RSymbol } from '../../r-bridge/lang-4.x/ast/model/nodes/r-symbol';
 import { RType } from '../../r-bridge/lang-4.x/ast/model/type';
-import type { NoInfo } from '../../r-bridge/lang-4.x/ast/model/model';
+import type { NoInfo, RNode } from '../../r-bridge/lang-4.x/ast/model/model';
 import { RFalse, RTrue } from '../../r-bridge/lang-4.x/convert-values';
 import type { UnresolvedDataType } from './types';
-import { resolveType, UnresolvedRAtomicVectorType, UnresolvedRFunctionType, UnresolvedRListType, UnresolvedRTypeUnion, UnresolvedRTypeVariable } from './types';
+import { constrainWithLowerBound, constrainWithUpperBound, getIndexedElementTypeFromList, getParameterTypeFromFunction, resolveType, UnresolvedRAtomicVectorType, UnresolvedRFunctionType, UnresolvedRListType, UnresolvedRTypeUnion, UnresolvedRTypeVariable } from './types';
 
 export function inferDataTypes<Info extends ParentInformation & { typeVariable?: undefined }>(ast: NormalizedAst<ParentInformation & Info>, dataflowInfo: DataflowInformation): NormalizedAst<Info & DataTypeInfo> {
 	const astWithTypeVars = decorateTypeVariables(ast);
@@ -51,9 +51,10 @@ function decorateTypeVariables<Info extends ParentInformation>(ast: NormalizedAs
 }
 
 function resolveTypeVariables<Info extends ParentInformation & UnresolvedTypeInfo>(ast: NormalizedAst<Info>): NormalizedAst<Omit<Info, keyof UnresolvedTypeInfo> & DataTypeInfo> {
+	const cache = new Map<UnresolvedDataType, DataType>();
 	return mapNormalizedAstInfo(ast, node => {
 		const { typeVariable, ...rest } = node.info;
-		return { ...rest, inferredType: resolveType(typeVariable) };
+		return { ...rest, inferredType: resolveType(typeVariable, cache) };
 	});
 }
 
@@ -77,38 +78,47 @@ class TypeInferringCfgGuidedVisitor<
 		super({ dataflow: config.dataflowInfo.graph, ...config });
 	}
 
+	protected constraintCache: Map<UnresolvedDataType, { lowerBounds: Set<UnresolvedDataType>, upperBounds: Set<UnresolvedDataType> }> = new Map();
 
-	protected constrainNodeTypeWithUpperBound(id: NodeId, upperBound: UnresolvedDataType): void {
-		const node = this.getNormalizedAst(id);
+
+	protected constrainNodeType(nodeOrId: RNode<UnresolvedTypeInfo> | NodeId, constraint: UnresolvedDataType | { lowerBound?: UnresolvedDataType, upperBound?: UnresolvedDataType }): void {
+		const node = typeof nodeOrId === 'object' ? nodeOrId : this.getNormalizedAst(nodeOrId);
 		guard(node !== undefined, 'Expected AST node to be defined');
-		node.info.typeVariable.constrainWithUpperBound(upperBound);
+
+		const lowerBound = 'tag' in constraint ? constraint : constraint.lowerBound;
+		const upperBound = 'tag' in constraint ? constraint : constraint.upperBound;
+
+		if(lowerBound !== undefined) {
+			constrainWithLowerBound(node.info.typeVariable, lowerBound, this.constraintCache);
+		}
+		if(upperBound !== undefined) {
+			constrainWithUpperBound(node.info.typeVariable, upperBound, this.constraintCache);
+		}
 	}
 
 
-	protected override onNullConstant(data: { vertex: DataflowGraphVertexValue; node: RSymbol<UnresolvedTypeInfo & ParentInformation, 'NULL'>; }): void {
-		data.node.info.typeVariable.constrainFromBothSides(new RNullType());
+	protected override onNullConstant(data: { vertex: DataflowGraphVertexValue, node: RSymbol<UnresolvedTypeInfo, 'NULL'>; }): void {
+		this.constrainNodeType(data.node, new RNullType());
 	}
 
 	override onLogicalConstant(data: { vertex: DataflowGraphVertexValue, node: RLogical<UnresolvedTypeInfo> }): void {
-		data.node.info.typeVariable.constrainFromBothSides(new RLogicalType());
+		this.constrainNodeType(data.node, new RLogicalType());
 	}
 
 	override onNumberConstant(data: { vertex: DataflowGraphVertexValue, node: RNumber<UnresolvedTypeInfo> }): void {
 		if(data.node.content.complexNumber) {
-			data.node.info.typeVariable.constrainFromBothSides(new RComplexType());
+			this.constrainNodeType(data.node, new RComplexType());
 		} else if(data.node.content.markedAsInt) {
-			data.node.info.typeVariable.constrainFromBothSides(new RIntegerType());
+			this.constrainNodeType(data.node, new RIntegerType());
 		} else if(data.node.content.num % 1 === 0) {
-			data.node.info.typeVariable.constrainWithLowerBound(new RIntegerType());
-			data.node.info.typeVariable.constrainWithUpperBound(new RComplexType());
+			this.constrainNodeType(data.node, { lowerBound: new RIntegerType(), upperBound: new RComplexType() });
 		} else {
-			data.node.info.typeVariable.constrainWithLowerBound(new RDoubleType());
-			data.node.info.typeVariable.constrainWithUpperBound(new RComplexType());
+			this.constrainNodeType(data.node, { lowerBound: new RDoubleType(), upperBound: new RComplexType() });
 		}
 	}
 
 	override onStringConstant(data: { vertex: DataflowGraphVertexValue, node: RString<UnresolvedTypeInfo> }): void {
-		data.node.info.typeVariable.constrainFromBothSides(new RStringType());
+		this.constrainNodeType(data.node, new RStringType());
 	}
 
 	override onVariableUse(data: { vertex: DataflowGraphVertexUse }): void {
@@ -125,7 +135,7 @@ class TypeInferringCfgGuidedVisitor<
 		guard(node !== undefined, 'Expected AST node to be defined');
 		if(node.type === RType.Argument) {
 			if(node.value !== undefined) {
-				node.info.typeVariable.constrainFromBothSides(node.value.info.typeVariable);
+				this.constrainNodeType(data.vertex.id, node.value.info.typeVariable);
 			}
 			return;
 		}
@@ -134,7 +144,7 @@ class TypeInferringCfgGuidedVisitor<
 		for(const readOrigin of readOrigins ?? []) {
 			const readNode = this.getNormalizedAst(readOrigin.id);
 			guard(readNode !== undefined, 'Expected read node to be defined');
-			node.info.typeVariable.constrainWithLowerBound(readNode.info.typeVariable);
+			this.constrainNodeType(data.vertex.id, { lowerBound: readNode.info.typeVariable });
 		}
 	}
 
@@ -143,13 +153,11 @@ class TypeInferringCfgGuidedVisitor<
 			return; // Malformed assignment
 		}
 		
-		const variableNode = this.getNormalizedAst(data.target);
 		const valueNode = this.getNormalizedAst(data.source);
-		const assignmentNode = this.getNormalizedAst(data.call.id);
-		guard(variableNode !== undefined && valueNode !== undefined && assignmentNode !== undefined, 'Expected AST nodes to be defined');
-		
-		variableNode.info.typeVariable.constrainWithLowerBound(valueNode.info.typeVariable);
-		assignmentNode.info.typeVariable.constrainWithLowerBound(variableNode.info.typeVariable);
+		guard(valueNode !== undefined, 'Expected AST node to be defined');
+
+		this.constrainNodeType(data.target, { lowerBound: valueNode.info.typeVariable });
+		this.constrainNodeType(data.call.id, { lowerBound: valueNode.info.typeVariable });
 	}
 
 	override onDefaultFunctionCall(data: { call: DataflowGraphVertexFunctionCall }): void {
@@ -158,15 +166,12 @@ class TypeInferringCfgGuidedVisitor<
 			.filter(([_target, edge]) => edgeIncludesType(edge.types, EdgeType.Calls))
 			.map(([target, _edge]) => target)
 			.toArray();
-		
-		const node = this.getNormalizedAst(data.call.id);
-		guard(node !== undefined, 'Expected AST node to be defined');
 
 		for(const target of callTargets ?? []) {
 			const targetNode = this.getNormalizedAst(target);
 			if(targetNode !== undefined) {
 				const functionType = new UnresolvedRFunctionType();
-				targetNode.info.typeVariable.constrainWithLowerBound(functionType);
+				this.constrainNodeType(targetNode, { lowerBound: functionType });
 
 				for(const [index, arg] of data.call.args.entries()) {
 					if(arg === EmptyArgument) {
@@ -177,13 +182,13 @@ class TypeInferringCfgGuidedVisitor<
 					guard(argNode !== undefined, 'Expected argument node to be defined');
 
 					if(arg.name !== undefined) {
-						functionType.getParameterType(arg.name).constrainWithLowerBound(argNode.info.typeVariable);
+						constrainWithLowerBound(getParameterTypeFromFunction(functionType, arg.name), argNode.info.typeVariable, this.constraintCache);
 					} else {
-						functionType.getParameterType(index).constrainWithLowerBound(argNode.info.typeVariable);
+						constrainWithLowerBound(getParameterTypeFromFunction(functionType, index), argNode.info.typeVariable, this.constraintCache);
 					}
 				}
 
-				node.info.typeVariable.constrainFromBothSides(functionType.returnType);
+				this.constrainNodeType(data.call.id, functionType.returnType);
 			} else {
 				// TODO: Handle builtin functions that are not represented in the AST
 			}
@@ -195,48 +200,33 @@ class TypeInferringCfgGuidedVisitor<
 		const varName = data.call.args.at(0);
 		
 		guard(varName !== undefined && varName !== EmptyArgument, 'Expected argument of get call to be defined');
-		const varNameNode = this.getNormalizedAst(varName.nodeId);
-
-		guard(varNameNode !== undefined, 'Expected variable name node to be defined');
-		varNameNode.info.typeVariable.constrainWithUpperBound(new RStringType());
-
-		const node = this.getNormalizedAst(data.call.id);
-		guard(node !== undefined, 'Expected AST node to be defined');
+		this.constrainNodeType(varName.nodeId, { upperBound: new RStringType() });
 
 		const varReadOrigins = this.getOrigins(varName.nodeId)?.filter((origin) => origin.type === OriginType.ReadVariableOrigin);
 		for(const readOrigin of varReadOrigins ?? []) {
 			const readNode = this.getNormalizedAst(readOrigin.id);
 			guard(readNode !== undefined, 'Expected read node to be defined');
-			node.info.typeVariable.constrainWithLowerBound(readNode.info.typeVariable);
+			this.constrainNodeType(data.call.id, { lowerBound: readNode.info.typeVariable });
 		}
 	}
 
 	override onRmCall(data: { call: DataflowGraphVertexFunctionCall }) {
-		const node = this.getNormalizedAst(data.call.id);
-		guard(node !== undefined, 'Expected AST node to be defined');
-		node.info.typeVariable.constrainFromBothSides(new RNullType());
+		this.constrainNodeType(data.call.id, new RNullType());
 	}
 
 	override onForLoopCall(data: { call: DataflowGraphVertexFunctionCall, variable: FunctionArgument, vector: FunctionArgument, body: FunctionArgument }) {
 		guard(data.variable !== EmptyArgument && data.vector !== EmptyArgument, 'Expected variable and vector arguments to be defined');
-		const variableNode = this.getNormalizedAst(data.variable.nodeId);
-		const vectorNode = this.getNormalizedAst(data.vector.nodeId);
-		guard(variableNode !== undefined && vectorNode !== undefined, 'Expected variable and vector nodes to be defined');
-		
 		const elementType = new UnresolvedRTypeVariable();
 		const vectorType = new UnresolvedRTypeUnion(new UnresolvedRAtomicVectorType(elementType), new UnresolvedRListType(elementType));
-		vectorNode.info.typeVariable.constrainWithUpperBound(vectorType);
-		variableNode.info.typeVariable.constrainWithLowerBound(elementType);
+		this.constrainNodeType(data.vector.nodeId, { upperBound: vectorType });
+		this.constrainNodeType(data.variable.nodeId, { lowerBound: elementType });
 
 		this.onLoopCall(data);
 	}
 
 	override onWhileLoopCall(data: { call: DataflowGraphVertexFunctionCall, condition: FunctionArgument, body: FunctionArgument }) {
 		guard(data.condition !== EmptyArgument, 'Expected condition argument to be defined');
-		const conditionNode = this.getNormalizedAst(data.condition.nodeId);
-		
-		guard(conditionNode !== undefined, 'Expected condition node to be defined');
-		conditionNode.info.typeVariable.constrainWithUpperBound(new RLogicalType());
+		this.constrainNodeType(data.condition.nodeId, { upperBound: new RLogicalType() });
 
 		this.onLoopCall(data);
 	}
@@ -246,27 +236,21 @@ class TypeInferringCfgGuidedVisitor<
 	}
 
 	protected onLoopCall(data: { call: DataflowGraphVertexFunctionCall, body: FunctionArgument }) {
-		const node = this.getNormalizedAst(data.call.id);
-		guard(node !== undefined, 'Expected AST node to be defined');
-
 		const cfgVertex = this.config.controlFlow.graph.getVertex(data.call.id);
 		guard(cfgVertex !== undefined && cfgVertex.type === CfgVertexType.Statement, 'Expected statement vertex for loop');
 		const isInfinite = (cfgVertex.end ?? []).reduce((prevCount, id) => prevCount + (this.config.controlFlow.graph.outgoingEdges(id)?.size ?? 0), 0) === 0;
 
 		if(isInfinite) {
-			node.info.typeVariable.constrainFromBothSides(new UnresolvedRTypeUnion());
+			this.constrainNodeType(data.call.id, new UnresolvedRTypeUnion());
 		} else {
-			node.info.typeVariable.constrainFromBothSides(new RNullType());
+			this.constrainNodeType(data.call.id, new RNullType());
 		}
 	}
 
 	override onIfThenElseCall(data: { call: DataflowGraphVertexFunctionCall, condition: NodeId | undefined, then: NodeId | undefined, else: NodeId | undefined }) {
 		guard(data.condition !== undefined, 'Expected condition argument to be defined');
-		const conditionNode = this.getNormalizedAst(data.condition);
-		
-		guard(conditionNode !== undefined, 'Expected condition node to be defined');
-		conditionNode.info.typeVariable.constrainWithUpperBound(new RLogicalType());
-		
+		this.constrainNodeType(data.condition, { upperBound: new RLogicalType() });
+
 		const cfgVertex = this.config.controlFlow.graph.getVertex(data.call.id);
 		guard(cfgVertex !== undefined && (cfgVertex.type === CfgVertexType.Statement || cfgVertex.type === CfgVertexType.Expression),
 			'Expected statement or expression vertex for if-then-else');
@@ -279,23 +263,20 @@ class TypeInferringCfgGuidedVisitor<
 		const isElseBranchReachable = this.config.controlFlow.graph.outgoingEdges(data.else ?? cfgEndVertexId)?.values().some((edge) =>{
 			return edge.label === CfgEdgeType.Cd && edge.when === RFalse;
 		}) ?? false;
-
-		const node = this.getNormalizedAst(data.call.id);
-		guard(node !== undefined, 'Expected AST node to be defined');
 		
 		if(isThenBranchReachable) {
 			if(data.then !== undefined) {	
 				const thenNode = this.getNormalizedAst(data.then);
 				guard(thenNode !== undefined, 'Expected then node to be defined');
-				node.info.typeVariable.constrainWithLowerBound(thenNode.info.typeVariable);
+				this.constrainNodeType(data.call.id, { lowerBound: thenNode.info.typeVariable });
 				if(!isElseBranchReachable) {
-					node.info.typeVariable.constrainWithUpperBound(thenNode.info.typeVariable);
+					this.constrainNodeType(data.call.id, { upperBound: thenNode.info.typeVariable });
 				}
 			} else {
 				// If there is no then branch, we can assume that the type is null
-				node.info.typeVariable.constrainWithLowerBound(new RNullType());
+				this.constrainNodeType(data.call.id, { lowerBound: new RNullType() });
 				if(!isElseBranchReachable) {
-					node.info.typeVariable.constrainWithUpperBound(new RNullType());
+					this.constrainNodeType(data.call.id, { upperBound: new RNullType() });
 				}
 			}
 		}
@@ -303,51 +284,38 @@ class TypeInferringCfgGuidedVisitor<
 			if(data.else !== undefined) {
 				const elseNode = this.getNormalizedAst(data.else);
 				guard(elseNode !== undefined, 'Expected else node to be defined');
-				node.info.typeVariable.constrainWithLowerBound(elseNode.info.typeVariable);
+				this.constrainNodeType(data.call.id, { lowerBound: elseNode.info.typeVariable });
 				if(!isThenBranchReachable) {
-					node.info.typeVariable.constrainWithUpperBound(elseNode.info.typeVariable);
+					this.constrainNodeType(data.call.id, { upperBound: elseNode.info.typeVariable });
 				}
 			} else {
 				// If there is no else branch, we can assume that the type is null
-				node.info.typeVariable.constrainWithLowerBound(new RNullType());
+				this.constrainNodeType(data.call.id, { lowerBound: new RNullType() });
 				if(!isThenBranchReachable) {
-					node.info.typeVariable.constrainWithUpperBound(new RNullType());
+					this.constrainNodeType(data.call.id, { upperBound: new RNullType() });
 				}
 			}
 		}
 		if(!isThenBranchReachable && !isElseBranchReachable) {
 			// If neither branch is reachable, we can assume that the type is none
-			node.info.typeVariable.constrainFromBothSides(new UnresolvedRTypeUnion());
-		}	
+			this.constrainNodeType(data.call.id, new UnresolvedRTypeUnion());
+		}
 	}
 	
 	override onQuoteCall(data: { call: DataflowGraphVertexFunctionCall }) {
-		guard(data.call.args.length === 1, 'Expected exactly one argument for quote call');
-		const arg = data.call.args.at(0);
-		guard(arg !== undefined && arg !== EmptyArgument, 'Expected argument of quote call to be defined');
-
-		const node = this.getNormalizedAst(data.call.id);
-		guard(node !== undefined, 'Expected AST node to be defined');
-		node.info.typeVariable.constrainFromBothSides(new RLanguageType());
+		this.constrainNodeType(data.call.id, new RLanguageType());
 	}
 
 	override onEvalFunctionCall(data: { call: DataflowGraphVertexFunctionCall }) {
 		guard(data.call.args.length === 1, 'Expected exactly one argument for eval call');
 		const arg = data.call.args.at(0);
-		
 		guard(arg !== undefined && arg !== EmptyArgument, 'Expected argument of eval call to be defined');
-		const argNode = this.getNormalizedAst(arg.nodeId);
-		
-		guard(argNode !== undefined, 'Expected argument node to be defined');
-		argNode.info.typeVariable.constrainWithUpperBound(new RLanguageType());
+		this.constrainNodeType(arg.nodeId, { upperBound: new RLanguageType() });
 	}
 
 	override onListCall(data: { call: DataflowGraphVertexFunctionCall }) {
-		const node = this.getNormalizedAst(data.call.id);
-		guard(node !== undefined, 'Expected AST node to be defined');
-		
 		const listType = new UnresolvedRListType();
-		node.info.typeVariable.constrainFromBothSides(listType);
+		this.constrainNodeType(data.call.id, listType);
 
 		// TODO: Handle flattening behavior of `list` function
 		for(const [index, arg] of data.call.args.entries()) {
@@ -357,32 +325,30 @@ class TypeInferringCfgGuidedVisitor<
 			
 			const argNode = this.getNormalizedAst(arg.nodeId);
 			guard(argNode !== undefined, 'Expected argument node to be defined');
-			listType.getIndexedElementType(index).constrainWithLowerBound(argNode.info.typeVariable);
+
+			constrainWithLowerBound(getIndexedElementTypeFromList(listType, index, this.constraintCache), argNode.info.typeVariable, this.constraintCache);
 
 			if(arg.name !== undefined) {
-				listType.getIndexedElementType(arg.name).constrainWithLowerBound(argNode.info.typeVariable);
+				constrainWithLowerBound(getIndexedElementTypeFromList(listType, arg.name, this.constraintCache), argNode.info.typeVariable, this.constraintCache);
 			}
 		}
 	}
 
 	override onVectorCall(data: { call: DataflowGraphVertexFunctionCall }) {
-		const node = this.getNormalizedAst(data.call.id);
-		guard(node !== undefined, 'Expected AST node to be defined');
-		
 		const args = data.call.args.filter((arg) => arg !== EmptyArgument);
 		if(args.length === 0) {
-			node.info.typeVariable.constrainFromBothSides(new RNullType());
+			this.constrainNodeType(data.call.id, new RNullType());
 			return;
 		}
 		
 		// TODO: Handle flattening behavior of `c` function
 		const vectorType = new UnresolvedRAtomicVectorType();
-		node.info.typeVariable.constrainFromBothSides(vectorType);
-		
+		this.constrainNodeType(data.call.id, vectorType);
+
 		for(const arg of args) {
 			const argNode = this.getNormalizedAst(arg.nodeId);
 			guard(argNode !== undefined, 'Expected argument node to be defined');
-			vectorType.elementType.constrainWithLowerBound(argNode.info.typeVariable);
+			constrainWithLowerBound(vectorType.elementType, argNode.info.typeVariable, this.constraintCache);
 		}
 	}
 
@@ -391,7 +357,7 @@ class TypeInferringCfgGuidedVisitor<
 		guard(node !== undefined && node.type === RType.FunctionDefinition, 'Expected AST node to be a function definition');
 
 		const functionType = new UnresolvedRFunctionType();
-		node.info.typeVariable.constrainWithLowerBound(functionType);
+		this.constrainNodeType(node, { lowerBound: functionType });
 
 		let dotsEncountered = false;
 		for(const [index, param] of node.parameters.entries()) {
@@ -402,12 +368,12 @@ class TypeInferringCfgGuidedVisitor<
 
 			if(!dotsEncountered) {
 				// Only constrain the parameter type positionally if no `...` has been encountered yet
-				functionType.getParameterType(index).constrainWithUpperBound(param.info.typeVariable);
+				constrainWithUpperBound(getParameterTypeFromFunction(functionType, index), param.info.typeVariable, this.constraintCache);
 			}
-			functionType.getParameterType(param.name.lexeme).constrainWithUpperBound(param.info.typeVariable);
-			
+			constrainWithUpperBound(getParameterTypeFromFunction(functionType, param.name.lexeme), param.info.typeVariable, this.constraintCache);
+
 			if(param.defaultValue !== undefined) {
-				param.info.typeVariable.constrainWithLowerBound(param.defaultValue.info.typeVariable);
+				this.constrainNodeType(param, { lowerBound: param.defaultValue.info.typeVariable });
 			}
 		}
 	}
@@ -417,21 +383,18 @@ class TypeInferringCfgGuidedVisitor<
 		const evalCandidates = exitPoints.map((exitPoint) => exitPoint.nodeId);
 
 		if(evalCandidates.length === 0) {
-			node.info.typeVariable.constrainFromBothSides(new RNullType());
+			this.constrainNodeType(node, new RNullType());
 			return;
 		}
 
 		for(const candidateId of evalCandidates) {
 			const candidate = this.getNormalizedAst(candidateId);
 			guard(candidate !== undefined, 'Expected target node to be defined');
-			node.info.typeVariable.constrainWithLowerBound(candidate.info.typeVariable);
+			this.constrainNodeType(node, { lowerBound: candidate.info.typeVariable });
 		}
 	}
 
 	override onExpressionList(data: { call: DataflowGraphVertexFunctionCall }) {
-		const node = this.getNormalizedAst(data.call.id);
-		guard(node !== undefined, 'Expected AST node to be defined');
-
 		const outgoing = this.config.dataflowInfo.graph.outgoingEdges(data.call.id);
 		const evalCandidates = outgoing?.entries()
 			.filter(([_target, edge]) => edgeIncludesType(edge.types, EdgeType.Returns))
@@ -439,21 +402,18 @@ class TypeInferringCfgGuidedVisitor<
 			.toArray();
 
 		if(evalCandidates === undefined || evalCandidates.length === 0) {
-			node.info.typeVariable.constrainFromBothSides(new RNullType());
+			this.constrainNodeType(data.call.id, new RNullType());
 			return;
 		}
 
 		for(const candidateId of evalCandidates) {
 			const candidate = this.getNormalizedAst(candidateId);
 			guard(candidate !== undefined, 'Expected target node to be defined');
-			node.info.typeVariable.constrainWithLowerBound(candidate.info.typeVariable);
+			this.constrainNodeType(data.call.id, { lowerBound: candidate.info.typeVariable });
 		}
 	}
 
 	override onAccessCall(data: { call: DataflowGraphVertexFunctionCall; }): void {
-		const node = this.getNormalizedAst(data.call.id);
-		guard(node !== undefined, 'Expected AST node to be defined');
-
 		const firstArg = data.call.args.at(0);
 		guard(firstArg !== undefined && firstArg !== EmptyArgument, 'Expected first argument of access call to be defined');
 		const firstArgNode = this.getNormalizedAst(firstArg.nodeId);
@@ -462,20 +422,20 @@ class TypeInferringCfgGuidedVisitor<
 		// TODO: Handle subsetting for other operand types, in particular for scalars and null
 		const elementType = new UnresolvedRTypeVariable();
 		const vectorType = new UnresolvedRTypeUnion(new UnresolvedRAtomicVectorType(elementType), new UnresolvedRListType(elementType));
-		firstArgNode.info.typeVariable.constrainWithUpperBound(vectorType);
-		
+		this.constrainNodeType(firstArgNode, { upperBound: vectorType });
+
 		switch(data.call.name) {
 			case '[':
 				// If the access call is a `[` operation, we can assume that the it returns a subset
 				// of the first argument's elements as another instance of the same container type
-				node.info.typeVariable.constrainWithLowerBound(firstArgNode.info.typeVariable);
+				this.constrainNodeType(data.call.id, { lowerBound: firstArgNode.info.typeVariable });
 				break;
 			case '[[':
-				node.info.typeVariable.constrainWithLowerBound(elementType);
+				this.constrainNodeType(data.call.id, { lowerBound: elementType });
 				break;
 			case '$': {
-				firstArgNode.info.typeVariable.constrainWithUpperBound(new UnresolvedRListType(elementType));
-				node.info.typeVariable.constrainWithLowerBound(elementType);
+				this.constrainNodeType(firstArgNode, { upperBound: new UnresolvedRListType(elementType) });
+				this.constrainNodeType(data.call.id, { lowerBound: elementType });
 				break;
 			}
 		}
diff --git a/src/typing/subtyping/types.ts b/src/typing/subtyping/types.ts
index 8bcb0cc4512..4b3314724e6 100644
--- a/src/typing/subtyping/types.ts
+++ b/src/typing/subtyping/types.ts
@@ -23,17 +23,17 @@ export class UnresolvedRListType {
 			this.elementType = elementType;
 		}
 	}
+}
 
-	getIndexedElementType(indexOrName: number | string): UnresolvedRTypeVariable {
-		let elementType = this.indexedElementTypes.get(indexOrName);
-		if(elementType === undefined) {
-			elementType = new UnresolvedRTypeVariable();
-			elementType.constrainWithUpperBound(this.elementType.upperBound);
-			this.indexedElementTypes.set(indexOrName, elementType);
-			this.elementType.constrainWithLowerBound(elementType);
-		}
-		return elementType;
+export function getIndexedElementTypeFromList(list: UnresolvedRListType, indexOrName: number | string, constraintCache: Map<UnresolvedDataType, { lowerBounds: Set<UnresolvedDataType>, upperBounds: Set<UnresolvedDataType> }>): UnresolvedRTypeVariable {
+	let elementType = list.indexedElementTypes.get(indexOrName);
+	if(elementType === undefined) {
+		elementType = new UnresolvedRTypeVariable();
+		constrainWithUpperBound(elementType, list.elementType.upperBound, constraintCache);
+		list.indexedElementTypes.set(indexOrName, elementType);
+		constrainWithLowerBound(list.elementType, elementType, constraintCache);
 	}
+	return elementType;
 }
 
 export class UnresolvedRFunctionType {
@@ -46,15 +46,15 @@ export class UnresolvedRFunctionType {
 			this.returnType = returnType;
 		}
 	}
+}
 
-	getParameterType(indexOrName: number | string): UnresolvedRTypeVariable {
-		let parameterType = this.parameterTypes.get(indexOrName);
-		if(parameterType === undefined) {
-			parameterType = new UnresolvedRTypeVariable();
-			this.parameterTypes.set(indexOrName, parameterType);
-		}
-		return parameterType;
+export function getParameterTypeFromFunction(func: UnresolvedRFunctionType, indexOrName: number | string): UnresolvedRTypeVariable {
+	let parameterType = func.parameterTypes.get(indexOrName);
+	if(parameterType === undefined) {
+		parameterType = new UnresolvedRTypeVariable();
+		func.parameterTypes.set(indexOrName, parameterType);
 	}
+	return parameterType;
 }
 
 export class UnresolvedRTypeUnion {
@@ -85,41 +85,36 @@ export class UnresolvedRTypeVariable {
 	readonly tag = DataTypeTag.Variable;
 	readonly lowerBound = new UnresolvedRTypeUnion();
 	readonly upperBound = new UnresolvedRTypeIntersection();
-
-	constrainWithLowerBound(bound: UnresolvedDataType): void {
-		guard(bound !== this, 'Lower bound cannot be the type variable itself');
-		constrainWithLowerBound(this, bound);
-	}
-
-	constrainWithUpperBound(bound: UnresolvedDataType): void {
-		guard(bound !== this, 'Upper bound cannot be the type variable itself');
-		constrainWithUpperBound(this, bound);
-	}
-
-	constrainFromBothSides(other: UnresolvedDataType): void {
-		this.constrainWithLowerBound(other);
-		this.constrainWithUpperBound(other);
-	}
 }
 
 
-export function constrainWithLowerBound(type: UnresolvedDataType, bound: UnresolvedDataType): void {
+export function constrainWithLowerBound(type: UnresolvedDataType, bound: UnresolvedDataType, cache: Map<UnresolvedDataType, { lowerBounds: Set<UnresolvedDataType>, upperBounds: Set<UnresolvedDataType> }>): void {
 	// console.debug('constraining', type, 'with lower bound', bound);
 
 	if(type === bound) {
 		return; // No need to constrain if both types are the same
 	}
 
+	const cachedConstraints = cache.get(type);
+	if(cachedConstraints?.lowerBounds.has(bound)) {
+		return; // Avoid infinite recursion
+	}
+	if(cachedConstraints !== undefined) {
+		cachedConstraints.lowerBounds.add(bound);
+	} else {
+		cache.set(type, { lowerBounds: new Set([bound]), upperBounds: new Set() });
+	}
+
 	if(type instanceof UnresolvedRTypeVariable) {
 		type.lowerBound.types.add(bound);
 		for(const upperBound of type.upperBound.types) {
-			constrainWithLowerBound(upperBound, bound);
+			constrainWithLowerBound(upperBound, bound, cache);
 		}
 	} else if(bound instanceof UnresolvedRTypeVariable) {
 		// constrainWithUpperBound(bound, type);
 		bound.upperBound.types.add(type);
 		for(const lowerBound of bound.lowerBound.types) {
-			constrainWithLowerBound(type, lowerBound);
+			constrainWithLowerBound(type, lowerBound, cache);
 		}
 	} else if(type instanceof UnresolvedRTypeUnion) {
 		for(const subtype of type.types.values()) {
@@ -127,17 +122,17 @@ export function constrainWithLowerBound(type: UnresolvedDataType, bound: Unresol
 				// console.debug('Removing subtype', subtype, 'from union', type, 'because it does not subsume the bound', bound);
 				type.types.delete(subtype);
 			} else {
-				constrainWithLowerBound(subtype, bound);
+				constrainWithLowerBound(subtype, bound, cache);
 			}
 		}
 	} else if(bound instanceof UnresolvedRTypeUnion) {
 		// constrainWithUpperBound(bound, type);
 		for(const subtype of bound.types) {
-			constrainWithLowerBound(type, subtype);
+			constrainWithLowerBound(type, subtype, cache);
 		}
 	} else if(type instanceof UnresolvedRTypeIntersection) {
 		for(const subtype of type.types) {
-			constrainWithLowerBound(subtype, bound);
+			constrainWithLowerBound(subtype, bound, cache);
 		}
 	} else if(bound instanceof UnresolvedRTypeIntersection) {
 		// constrainWithUpperBound(bound, type);
@@ -146,44 +141,54 @@ export function constrainWithLowerBound(type: UnresolvedDataType, bound: Unresol
 				// console.debug('Removing subtype', subtype, 'from intersection', bound, 'because it does not subsume the type', type);
 				bound.types.delete(subtype);
 			} else {
-				constrainWithLowerBound(type, subtype);
+				constrainWithLowerBound(type, subtype, cache);
 			}
 		}
 	} else if(type instanceof UnresolvedRFunctionType && bound instanceof UnresolvedRFunctionType) {
 		for(const [key, paramType] of bound.parameterTypes) {
-			constrainWithUpperBound(type.getParameterType(key), paramType);
+			constrainWithUpperBound(getParameterTypeFromFunction(type, key), paramType, cache);
 		}
-		constrainWithLowerBound(type.returnType, bound.returnType);
+		constrainWithLowerBound(type.returnType, bound.returnType, cache);
 	} else if(type instanceof UnresolvedRAtomicVectorType && bound instanceof UnresolvedRAtomicVectorType) {
-		constrainWithLowerBound(type.elementType, bound.elementType);
+		constrainWithLowerBound(type.elementType, bound.elementType, cache);
 	} else if(type instanceof UnresolvedRAtomicVectorType && isAtomicVectorBaseType(bound)) {
-		constrainWithLowerBound(type.elementType, bound);
+		constrainWithLowerBound(type.elementType, bound, cache);
 	} else if(type instanceof UnresolvedRListType && bound instanceof UnresolvedRListType) {
-		constrainWithLowerBound(type.elementType, bound.elementType);
+		constrainWithLowerBound(type.elementType, bound.elementType, cache);
 	}
 }
 
-export function constrainWithUpperBound(type: UnresolvedDataType, bound: UnresolvedDataType): void {
+export function constrainWithUpperBound(type: UnresolvedDataType, bound: UnresolvedDataType, cache: Map<UnresolvedDataType, { lowerBounds: Set<UnresolvedDataType>, upperBounds: Set<UnresolvedDataType> }>): void {
 	// console.debug('constraining', type, 'with upper bound', bound);
 
 	if(type === bound) {
 		return; // No need to constrain if both types are the same
 	}
 
+	const cachedConstraints = cache.get(type);
+	if(cachedConstraints?.upperBounds.has(bound)) {
+		return; // Avoid infinite recursion
+	}
+	if(cachedConstraints !== undefined) {
+		cachedConstraints.upperBounds.add(bound);
+	} else {
+		cache.set(type, { lowerBounds: new Set(), upperBounds: new Set([bound]) });
+	}
+
 	if(type instanceof UnresolvedRTypeVariable) {
 		type.upperBound.types.add(bound);
 		for(const lowerBound of type.lowerBound.types) {
-			constrainWithUpperBound(lowerBound, bound);
+			constrainWithUpperBound(lowerBound, bound, cache);
 		}
 	} else if(bound instanceof UnresolvedRTypeVariable) {
 		// constrainWithLowerBound(bound, type);
 		bound.lowerBound.types.add(type);
 		for(const upperBound of bound.upperBound.types) {
-			constrainWithUpperBound(type, upperBound);
+			constrainWithUpperBound(type, upperBound, cache);
 		}
 	} else if(type instanceof UnresolvedRTypeUnion) {
 		for(const subtype of type.types) {
-			constrainWithUpperBound(subtype, bound);
+			constrainWithUpperBound(subtype, bound, cache);
 		}
 	} else if(bound instanceof UnresolvedRTypeUnion) {
 		// constrainWithLowerBound(bound, type);
@@ -192,7 +197,7 @@ export function constrainWithUpperBound(type: UnresolvedDataType, bound: Unresol
 				// console.debug('Removing subtype', subtype, 'from union', bound, 'because it does not subsume the type', type);
 				bound.types.delete(subtype);
 			} else {
-				constrainWithUpperBound(type, subtype);
+				constrainWithUpperBound(type, subtype, cache);
 			}
 		}
 	} else if(type instanceof UnresolvedRTypeIntersection) {
@@ -201,73 +206,95 @@ export function constrainWithUpperBound(type: UnresolvedDataType, bound: Unresol
 				// console.debug('Removing subtype', subtype, 'from intersection', type, 'because it does not subsume the bound', bound);
 				type.types.delete(subtype);
 			} else {
-				constrainWithUpperBound(subtype, bound);
+				constrainWithUpperBound(subtype, bound, cache);
 			}
 		}
 	} else if(bound instanceof UnresolvedRTypeIntersection) {
 		// constrainWithLowerBound(bound, type);
 		for(const subtype of bound.types) {
-			constrainWithUpperBound(type, subtype);
+			constrainWithUpperBound(type, subtype, cache);
 		}
 	} else if(type instanceof UnresolvedRFunctionType && bound instanceof UnresolvedRFunctionType) {
 		for(const [key, paramType] of bound.parameterTypes) {
-			constrainWithLowerBound(type.getParameterType(key), paramType);
+			constrainWithLowerBound(getParameterTypeFromFunction(type, key), paramType, cache);
 		}
-		constrainWithUpperBound(type.returnType, bound.returnType);
+		constrainWithUpperBound(type.returnType, bound.returnType, cache);
 	} else if(type instanceof UnresolvedRAtomicVectorType && bound instanceof UnresolvedRAtomicVectorType) {
-		constrainWithUpperBound(type.elementType, bound.elementType);
+		constrainWithUpperBound(type.elementType, bound.elementType, cache);
 	} else if(type instanceof UnresolvedRListType && bound instanceof UnresolvedRListType) {
-		constrainWithUpperBound(type.elementType, bound.elementType);
+		constrainWithUpperBound(type.elementType, bound.elementType, cache);
 	}
 }
 
 
-export function resolveType(type: UnresolvedDataType): DataType {
+export function resolveType(type: UnresolvedDataType, cache: Map<UnresolvedDataType, DataType> = new Map()): DataType {
+	const cachedType = cache.get(type);
+	if(cachedType !== undefined) {
+		return cachedType;
+	}
+
 	if(type instanceof UnresolvedRTypeVariable) {
-		const lowerBound = resolveType(type.lowerBound);
-		const upperBound = resolveType(type.upperBound);
+		cache.set(type, new RTypeVariable()); // Prevent infinite recursion
+
+		const lowerBound = resolveType(type.lowerBound, cache);
+		const upperBound = resolveType(type.upperBound, cache);
 
 		if(!subsumes(lowerBound, upperBound)) {
-			return new RTypeError(lowerBound, upperBound);
+			const errorType = new RTypeError(lowerBound, upperBound);
+			cache.set(type, errorType);
+			return errorType;
 		}
 		
 		if(subsumes(lowerBound, upperBound) && subsumes(upperBound, lowerBound)) {
+			cache.set(type, lowerBound);
 			return lowerBound; // If both bounds are equal, return one of them
 		}
 		
-		return new RTypeVariable(
+		const resolvedType = new RTypeVariable(
 			lowerBound instanceof RTypeVariable ? lowerBound.lowerBound : lowerBound,
 			upperBound instanceof RTypeVariable ? upperBound.upperBound : upperBound
 		);
+		cache.set(type, resolvedType);
+		return resolvedType;
 	} else if(type instanceof UnresolvedRTypeUnion) {
+		cache.set(type, new RTypeUnion()); // Prevent infinite recursion
+
 		let resolvedType: DataType = new RTypeUnion();
 		for(const subtype of type.types) {
-			const resolvedSubtype = resolveType(subtype);
-			// console.debug('Resolved subtype', subtype, 'to', resolvedSubtype);
-			// console.debug('Joining type', resolvedType, 'with subtype', resolvedSubtype);
+			const resolvedSubtype = resolveType(subtype, cache);
 			resolvedType = join(resolvedType, resolvedSubtype);
-			// console.debug('Joined type is now', resolvedType);
 		}
+		cache.set(type, resolvedType);
 		return resolvedType;
 	} else if(type instanceof UnresolvedRTypeIntersection) {
+		cache.set(type, new RTypeIntersection()); // Prevent infinite recursion
+
 		let resolvedType: DataType = new RTypeIntersection();
 		for(const subtype of type.types) {
-			const resolvedSubtype = resolveType(subtype);
+			const resolvedSubtype = resolveType(subtype, cache);
 			resolvedType = meet(resolvedType, resolvedSubtype);
 		}
+		cache.set(type, resolvedType);
 		return resolvedType;
 	} else if(type instanceof UnresolvedRFunctionType) {
-		const resolvedParameterTypes = new Map(type.parameterTypes.entries().toArray().map(([key, type]) => [key, resolveType(type)]));
-		const resolvedReturnType = resolveType(type.returnType);
-		return new RFunctionType(resolvedParameterTypes, resolvedReturnType);
+		const resolvedParameterTypes = new Map(type.parameterTypes.entries().toArray().map(([key, type]) => [key, resolveType(type, cache)]));
+		const resolvedReturnType = resolveType(type.returnType, cache);
+		const resolvedType = new RFunctionType(resolvedParameterTypes, resolvedReturnType);
+		cache.set(type, resolvedType);
+		return resolvedType;
 	} else if(type instanceof UnresolvedRAtomicVectorType) {
-		const resolvedElementType = resolveType(type.elementType);
-		return new RAtomicVectorType(resolvedElementType);
+		const resolvedElementType = resolveType(type.elementType, cache);
+		const resolvedType = new RAtomicVectorType(resolvedElementType);
+		cache.set(type, resolvedType);
+		return resolvedType;
 	} else if(type instanceof UnresolvedRListType) {
-		const resolvedElementType = resolveType(type.elementType);
-		const resolvedIndexedElementTypes = new Map(type.indexedElementTypes.entries().map(([indexOrName, elementType]) => [indexOrName, resolveType(elementType)]));
-		return new RListType(resolvedElementType, resolvedIndexedElementTypes);
+		const resolvedElementType = resolveType(type.elementType, cache);
+		const resolvedIndexedElementTypes = new Map(type.indexedElementTypes.entries().map(([indexOrName, elementType]) => [indexOrName, resolveType(elementType, cache)]));
+		const resolvedType = new RListType(resolvedElementType, resolvedIndexedElementTypes);
+		cache.set(type, resolvedType);
+		return resolvedType;
 	} else {
+		cache.set(type, type);
 		return type;
 	}
 }
diff --git a/test/functionality/typing/subtyping/constrain.test.ts b/test/functionality/typing/subtyping/constrain.test.ts
index 18e41fe7fbb..83228a231ef 100644
--- a/test/functionality/typing/subtyping/constrain.test.ts
+++ b/test/functionality/typing/subtyping/constrain.test.ts
@@ -1,78 +1,95 @@
 import { describe, expect, test } from 'vitest';
+import type { UnresolvedDataType } from '../../../../src/typing/subtyping/types';
 import { constrainWithLowerBound, constrainWithUpperBound, resolveType, UnresolvedRAtomicVectorType, UnresolvedRFunctionType, UnresolvedRListType, UnresolvedRTypeIntersection, UnresolvedRTypeUnion, UnresolvedRTypeVariable } from '../../../../src/typing/subtyping/types';
 import { RIntegerType, RComplexType, RTypeVariable, RDoubleType, RStringType, RListType, RTypeIntersection } from '../../../../src/typing/types';
 
 describe('Constrain types with lower and upper bounds', () => {
 	test('Constrain with numeric bounds', () => {
+		const cache = new Map<UnresolvedDataType, { lowerBounds: Set<UnresolvedDataType>, upperBounds: Set<UnresolvedDataType> }>();
+
 		const typeVar = new UnresolvedRTypeVariable();
-		constrainWithLowerBound(typeVar, new RIntegerType());
-		constrainWithUpperBound(typeVar, new RComplexType());
+		constrainWithLowerBound(typeVar, new RIntegerType(), cache);
+		constrainWithUpperBound(typeVar, new RComplexType(), cache);
 		
 		expect(resolveType(typeVar)).toEqual(new RTypeVariable(new RIntegerType(), new RComplexType()));
 	});
 
 	test('Constrain with multiple bounds', () => {
+		const cache = new Map<UnresolvedDataType, { lowerBounds: Set<UnresolvedDataType>, upperBounds: Set<UnresolvedDataType> }>();
+
 		const typeVar = new UnresolvedRTypeVariable();
-		constrainWithLowerBound(typeVar, new RIntegerType());
-		constrainWithLowerBound(typeVar, new RDoubleType());
-		constrainWithUpperBound(typeVar, new UnresolvedRTypeUnion(new RComplexType(), new RStringType()));
-		
+		constrainWithLowerBound(typeVar, new RIntegerType(), cache);
+		constrainWithLowerBound(typeVar, new RDoubleType(), cache);
+		constrainWithUpperBound(typeVar, new UnresolvedRTypeUnion(new RComplexType(), new RStringType()), cache);
+
 		expect(resolveType(typeVar)).toEqual(new RTypeVariable(new RDoubleType(), new RComplexType()));
 	});
 
 	test('Constrain with compound bounds', () => {
+		const cache = new Map<UnresolvedDataType, { lowerBounds: Set<UnresolvedDataType>, upperBounds: Set<UnresolvedDataType> }>();
+
 		const typeVar = new UnresolvedRTypeVariable();
 		const listType1 = new UnresolvedRListType();
-		constrainWithLowerBound(listType1.elementType, new RIntegerType());
-		constrainWithLowerBound(typeVar, listType1);
+		constrainWithLowerBound(listType1.elementType, new RIntegerType(), cache);
+		constrainWithLowerBound(typeVar, listType1, cache);
 		const listType2 = new UnresolvedRListType();
-		constrainWithUpperBound(listType2.elementType, new RComplexType());
-		constrainWithUpperBound(typeVar, listType2);
-		
+		constrainWithUpperBound(listType2.elementType, new RComplexType(), cache);
+		constrainWithUpperBound(typeVar, listType2, cache);
+
 		expect(resolveType(typeVar)).toEqual(new RListType(new RTypeVariable(new RIntegerType(), new RComplexType())));
 	});
 
 	test('Constraint propagation', () => {
+		const cache = new Map<UnresolvedDataType, { lowerBounds: Set<UnresolvedDataType>, upperBounds: Set<UnresolvedDataType> }>();
+
 		const typeVar = new UnresolvedRTypeVariable();
 		const listType1 = new UnresolvedRListType();
-		constrainWithLowerBound(listType1.elementType, new RIntegerType());
-		constrainWithLowerBound(typeVar, listType1);
-		
+		constrainWithLowerBound(listType1.elementType, new RIntegerType(), cache);
+		constrainWithLowerBound(typeVar, listType1, cache);
+
 		const elementType = new UnresolvedRTypeVariable();
 		const listType2 = new UnresolvedRListType(elementType);
-		constrainWithUpperBound(typeVar, listType2);
-		
+		constrainWithUpperBound(typeVar, listType2, cache);
+
 		expect(resolveType(typeVar)).toEqual(new RListType(new RTypeVariable(new RIntegerType(), new RTypeIntersection())));
 		expect(resolveType(elementType)).toEqual(new RTypeVariable(new RIntegerType(), new RTypeIntersection()));
 	});
 
 	test('Advanced constraint propagation', () => {
+		const cache = new Map<UnresolvedDataType, { lowerBounds: Set<UnresolvedDataType>, upperBounds: Set<UnresolvedDataType> }>();
+
 		const typeVar = new UnresolvedRTypeVariable();
 		const listType1 = new UnresolvedRListType();
-		constrainWithLowerBound(listType1.elementType, new RIntegerType());
-		constrainWithLowerBound(typeVar, listType1);
-		
+		constrainWithLowerBound(listType1.elementType, new RIntegerType(), cache);
+		constrainWithLowerBound(typeVar, listType1, cache);
+
 		const elementType = new UnresolvedRTypeVariable();
 		const vectorType = new UnresolvedRTypeUnion(new UnresolvedRAtomicVectorType(elementType), new UnresolvedRListType(elementType));
-		constrainWithUpperBound(typeVar, vectorType);
-		
+		constrainWithUpperBound(typeVar, vectorType, cache);
+
 		expect(resolveType(typeVar)).toEqual(new RListType(new RTypeVariable(new RIntegerType(), new RTypeIntersection())));
 		expect(resolveType(elementType)).toEqual(new RTypeVariable(new RIntegerType(), new RTypeIntersection()));
 	});
 
 	test('Function overloading', () => {
+		const cache = new Map<UnresolvedDataType, { lowerBounds: Set<UnresolvedDataType>, upperBounds: Set<UnresolvedDataType> }>();
+
 		// Predetermined types in context
 		const funcType1 = new UnresolvedRFunctionType();
 		const paramType1 = new UnresolvedRTypeVariable();
 		funcType1.parameterTypes.set(0, paramType1);
-		paramType1.constrainFromBothSides(new RIntegerType());
-		funcType1.returnType.constrainFromBothSides(new RIntegerType());
+		constrainWithLowerBound(paramType1, new RIntegerType(), cache);
+		constrainWithUpperBound(paramType1, new RIntegerType(), cache);
+		constrainWithLowerBound(funcType1.returnType, new RIntegerType(), cache);
+		constrainWithUpperBound(funcType1.returnType, new RIntegerType(), cache);
 
 		const funcType2 = new UnresolvedRFunctionType();
 		const paramType2 = new UnresolvedRTypeVariable();
 		funcType2.parameterTypes.set(0, paramType2);
-		paramType2.constrainFromBothSides(new RDoubleType());
-		funcType2.returnType.constrainFromBothSides(new RDoubleType());
+		constrainWithLowerBound(paramType2, new RDoubleType(), cache);
+		constrainWithUpperBound(paramType2, new RDoubleType(), cache);
+		constrainWithLowerBound(funcType2.returnType, new RDoubleType(), cache);
+		constrainWithUpperBound(funcType2.returnType, new RDoubleType(), cache);
 
 		const overloadedFuncType1 = new UnresolvedRTypeIntersection(funcType1, funcType2);
 		const overloadedFuncType2 = new UnresolvedRTypeIntersection(funcType1, funcType2);
@@ -80,22 +97,24 @@ describe('Constrain types with lower and upper bounds', () => {
 		// Typing of called function
 		const calledFuncType1 = new UnresolvedRTypeVariable();
 		const calledFuncType2 = new UnresolvedRTypeVariable();
-		calledFuncType1.constrainWithLowerBound(overloadedFuncType1);
-		calledFuncType2.constrainWithLowerBound(overloadedFuncType2);
+		constrainWithLowerBound(calledFuncType1, overloadedFuncType1, cache);
+		constrainWithLowerBound(calledFuncType2, overloadedFuncType2, cache);
 
 		// Typing of function call
 		const argType1 = new UnresolvedRTypeVariable();
 		const argType2 = new UnresolvedRTypeVariable();
-		argType1.constrainFromBothSides(new RIntegerType());
-		argType2.constrainFromBothSides(new RDoubleType());
+		constrainWithLowerBound(argType1, new RIntegerType(), cache);
+		constrainWithUpperBound(argType1, new RIntegerType(), cache);
+		constrainWithLowerBound(argType2, new RDoubleType(), cache);
+		constrainWithUpperBound(argType2, new RDoubleType(), cache);
 		const templateFuncType1 = new UnresolvedRFunctionType();
 		templateFuncType1.parameterTypes.set(0, argType1);
 		const returnType1 = templateFuncType1.returnType;
 		const templateFuncType2 = new UnresolvedRFunctionType();
 		templateFuncType2.parameterTypes.set(0, argType2);
 		const returnType2 = templateFuncType2.returnType;
-		calledFuncType1.constrainWithUpperBound(templateFuncType1);
-		calledFuncType2.constrainWithUpperBound(templateFuncType2);
+		constrainWithUpperBound(calledFuncType1, templateFuncType1, cache);
+		constrainWithUpperBound(calledFuncType2, templateFuncType2, cache);
 
 		expect(resolveType(returnType1)).toEqual(new RTypeVariable(new RIntegerType(), new RTypeIntersection()));
 		expect(resolveType(returnType2)).toEqual(new RTypeVariable(new RDoubleType(), new RTypeIntersection()));

From 53a98c52de2d7bba44a97c4bf3a0ffd3a08081ac Mon Sep 17 00:00:00 2001
From: Lukas Rohde <lukas.rohde@silupe.de>
Date: Fri, 18 Jul 2025 17:00:35 +0200
Subject: [PATCH 101/153] feat-fix(typing): improve handling of `c` function
 calls with flattening

---
 src/typing/subtyping/infer.ts | 7 ++++---
 1 file changed, 4 insertions(+), 3 deletions(-)

diff --git a/src/typing/subtyping/infer.ts b/src/typing/subtyping/infer.ts
index a0bbed3195f..77e7ed326f5 100644
--- a/src/typing/subtyping/infer.ts
+++ b/src/typing/subtyping/infer.ts
@@ -317,7 +317,7 @@ class TypeInferringCfgGuidedVisitor<
 		const listType = new UnresolvedRListType();
 		this.constrainNodeType(data.call.id, listType);
 
-		// TODO: Handle flattening behavior of `list` function
+		// TODO: Handle flattening behavior of `list` function (?)
 		for(const [index, arg] of data.call.args.entries()) {
 			if(arg === EmptyArgument) {
 				continue; // Skip empty arguments
@@ -341,14 +341,15 @@ class TypeInferringCfgGuidedVisitor<
 			return;
 		}
 		
-		// TODO: Handle flattening behavior of `c` function
+		// TODO: Handle behavior of `c` function for non-vector arguments
 		const vectorType = new UnresolvedRAtomicVectorType();
 		this.constrainNodeType(data.call.id, vectorType);
 
 		for(const arg of args) {
 			const argNode = this.getNormalizedAst(arg.nodeId);
 			guard(argNode !== undefined, 'Expected argument node to be defined');
-			constrainWithLowerBound(vectorType.elementType, argNode.info.typeVariable, this.constraintCache);
+			this.constrainNodeType(argNode, { upperBound: new UnresolvedRAtomicVectorType() });
+			constrainWithLowerBound(vectorType, argNode.info.typeVariable, this.constraintCache);
 		}
 	}
 

From a24bab34a98738e2bd338c5d1d6914479b609517 Mon Sep 17 00:00:00 2001
From: Florian Sihler <florian.sihler@uni-ulm.de>
Date: Fri, 25 Jul 2025 18:17:13 +0200
Subject: [PATCH 102/153] feat: #hopetomakerohdehappy

---
 package-lock.json                             |     13 +
 package.json                                  |      1 +
 src/cli/repl/commands/repl-commands.ts        |     38 +-
 .../repl/commands/repl-turcotte-type-parse.ts |    304 +
 src/typing/subtyping/pretty-print.ts          |     74 +
 src/typing/subtyping/types.ts                 |      2 +-
 turcotte-types.csv                            | 119818 +++++++++++++++
 7 files changed, 120231 insertions(+), 19 deletions(-)
 create mode 100644 src/cli/repl/commands/repl-turcotte-type-parse.ts
 create mode 100644 src/typing/subtyping/pretty-print.ts
 create mode 100644 turcotte-types.csv

diff --git a/package-lock.json b/package-lock.json
index 3bae34f1868..e3e72730fa6 100644
--- a/package-lock.json
+++ b/package-lock.json
@@ -14,6 +14,7 @@
         "clipboardy": "^4.0.0",
         "command-line-args": "^6.0.1",
         "command-line-usage": "^7.0.3",
+        "csv-parser": "^3.2.0",
         "joi": "^17.13.3",
         "lz-string": "^1.5.0",
         "n-readlines": "^1.0.1",
@@ -4065,6 +4066,18 @@
         "node": ">= 8"
       }
     },
+    "node_modules/csv-parser": {
+      "version": "3.2.0",
+      "resolved": "https://registry.npmjs.org/csv-parser/-/csv-parser-3.2.0.tgz",
+      "integrity": "sha512-fgKbp+AJbn1h2dcAHKIdKNSSjfp43BZZykXsCjzALjKy80VXQNHPFJ6T9Afwdzoj24aMkq8GwDS7KGcDPpejrA==",
+      "license": "MIT",
+      "bin": {
+        "csv-parser": "bin/csv-parser"
+      },
+      "engines": {
+        "node": ">= 10"
+      }
+    },
     "node_modules/dargs": {
       "version": "8.1.0",
       "resolved": "https://registry.npmjs.org/dargs/-/dargs-8.1.0.tgz",
diff --git a/package.json b/package.json
index cceeeb84e55..20566b70fc0 100644
--- a/package.json
+++ b/package.json
@@ -208,6 +208,7 @@
     "clipboardy": "^4.0.0",
     "command-line-args": "^6.0.1",
     "command-line-usage": "^7.0.3",
+    "csv-parser": "^3.2.0",
     "joi": "^17.13.3",
     "lz-string": "^1.5.0",
     "n-readlines": "^1.0.1",
diff --git a/src/cli/repl/commands/repl-commands.ts b/src/cli/repl/commands/repl-commands.ts
index c71863088d7..5697609ccee 100644
--- a/src/cli/repl/commands/repl-commands.ts
+++ b/src/cli/repl/commands/repl-commands.ts
@@ -20,6 +20,7 @@ import { guard } from '../../../util/assert';
 import { scripts } from '../../common/scripts-info';
 import { lineageCommand } from './repl-lineage';
 import { queryCommand, queryStarCommand } from './repl-query';
+import { replTurcotteTypeParseCommand } from './repl-turcotte-type-parse';
 
 function printHelpForScript(script: [string, ReplCommand], f: OutputFormatter, starredVersion?: ReplCommand): string {
 	let base = `  ${bold(padCmd(':' + script[0] + (starredVersion ? '[*]' : '')), f)}${script[1].description}`;
@@ -80,24 +81,25 @@ You can combine commands by separating them with a semicolon ${bold(';',output.f
  * All commands that should be available in the REPL.
  */
 const _commands: Record<string, ReplCommand> = {
-	'help':            helpCommand,
-	'quit':            quitCommand,
-	'version':         versionCommand,
-	'execute':         executeCommand,
-	'parse':           parseCommand,
-	'normalize':       normalizeCommand,
-	'normalize*':      normalizeStarCommand,
-	'dataflow':        dataflowCommand,
-	'dataflow*':       dataflowStarCommand,
-	'dataflowsimple':  dataflowSimplifiedCommand,
-	'dataflowsimple*': dataflowSimpleStarCommand,
-	'controlflow':     controlflowCommand,
-	'controlflow*':    controlflowStarCommand,
-	'controlflowbb':   controlflowBbCommand,
-	'controlflowbb*':  controlflowBbStarCommand,
-	'lineage':         lineageCommand,
-	'query':           queryCommand,
-	'query*':          queryStarCommand
+	'help':                helpCommand,
+	'quit':                quitCommand,
+	'version':             versionCommand,
+	'turcotte-type-parse': replTurcotteTypeParseCommand,
+	'execute':             executeCommand,
+	'parse':               parseCommand,
+	'normalize':           normalizeCommand,
+	'normalize*':          normalizeStarCommand,
+	'dataflow':            dataflowCommand,
+	'dataflow*':           dataflowStarCommand,
+	'dataflowsimple':      dataflowSimplifiedCommand,
+	'dataflowsimple*':     dataflowSimpleStarCommand,
+	'controlflow':         controlflowCommand,
+	'controlflow*':        controlflowStarCommand,
+	'controlflowbb':       controlflowBbCommand,
+	'controlflowbb*':      controlflowBbStarCommand,
+	'lineage':             lineageCommand,
+	'query':               queryCommand,
+	'query*':              queryStarCommand
 };
 let commandsInitialized = false;
 
diff --git a/src/cli/repl/commands/repl-turcotte-type-parse.ts b/src/cli/repl/commands/repl-turcotte-type-parse.ts
new file mode 100644
index 00000000000..1425ca82d4e
--- /dev/null
+++ b/src/cli/repl/commands/repl-turcotte-type-parse.ts
@@ -0,0 +1,304 @@
+import type { ReplCommand } from './repl-main';
+import { findSource } from '../../../dataflow/internal/process/functions/call/built-in/built-in-source';
+import type {
+	RFunctionType } from '../../../typing/types';
+import {
+	DataTypeTag, RComplexType, RDoubleType, REnvironmentType, RIntegerType, RLanguageType,
+	RLogicalType,
+	RNullType, RRawType, RStringType
+} from '../../../typing/types';
+import fs from 'fs';
+import csvParser from 'csv-parser';
+import { guard } from '../../../util/assert';
+import type {
+	UnresolvedDataType } from '../../../typing/subtyping/types';
+import {
+	constrainWithLowerBound, constrainWithUpperBound, getParameterTypeFromFunction, UnresolvedRAtomicVectorType, UnresolvedRFunctionType, UnresolvedRListType,
+	UnresolvedRTypeUnion,
+	UnresolvedRTypeVariable
+} from '../../../typing/subtyping/types';
+import { prettyPrint } from '../../../typing/subtyping/pretty-print';
+import { ColorEffect, Colors } from '../../../util/text/ansi';
+
+interface FunctionTypeInformation {
+	readonly name:    string;
+	readonly package: string;
+	readonly type:    readonly RFunctionType[]
+}
+
+interface RohdeTypes {
+	readonly info: FunctionTypeInformation[];
+}
+
+interface TurcotteCsvRow {
+	readonly package_name:       string;
+	readonly function_name:      string;
+	readonly parameter_position: string;
+	readonly outer_alternative:  string;
+	readonly inner_alternative:  string;
+	readonly type:               string;
+	readonly count:              string;
+}
+
+
+export const replTurcotteTypeParseCommand: ReplCommand = {
+	description:  'Give me a file to read from and I will happily print you the types in the Rohde System!',
+	usageExample: ':turcotte-type-parse foo.csv',
+	aliases:      [ 'ttp',],
+	script:       false,
+	fn:           async(output, shell, remainingLine) => {
+		if(!remainingLine.trim()) {
+			output.stderr('Please provide a file to read from. You do not need a prefix, just the file path.');
+			return;
+		}
+		const file = findSource(remainingLine.trim(), { referenceChain: [] });
+		if(file?.length !== 1) {
+			output.stderr(`Could not find a single file to read from. Got: ${JSON.stringify(file)}`);
+			return;
+		}
+
+		const data: TurcotteCsvRow[] = [];
+		await new Promise(resolve => {
+			fs.createReadStream(file[0], { encoding: 'utf-8' })
+				.pipe(csvParser({ separator: ',' }))
+				.on('data', (row: TurcotteCsvRow) => {
+					data.push(row);
+				})
+				.on('end', () => resolve(null));
+		});
+		const rohdeTypes: RohdeTypes = turcotte2RohdeTypes(data);
+		for(const info of rohdeTypes.info) {
+			if(info.type.length <= 1) {
+				output.stdout(output.formatter.format(`${info.package}::${info.name} :: `, { color: Colors.White, effect: ColorEffect.Foreground }) + prettyPrint(info.type[0]));
+				continue;
+			}
+			output.stdout(`${info.package}::${info.name} has ${info.type.length} alternatives`);
+			for(const type of info.type) {
+				output.stdout('  :: ' + prettyPrint(type));
+			}
+		}
+		output.stdout(`Parsed ${rohdeTypes.info.length} functions from ${file[0]}.`);
+	}
+};
+
+function groupTurcotteData<T>(data: readonly TurcotteCsvRow[], makeKey: (d: TurcotteCsvRow) => T): Map<T, TurcotteCsvRow[]> {
+	const grouped: Map<T, TurcotteCsvRow[]> = new Map();
+	for(const row of data) {
+		const key = makeKey(row);
+		if(!grouped.has(key)) {
+			grouped.set(key, []);
+		}
+		grouped.get(key)?.push(row);
+	}
+	return grouped;
+}
+
+function convertTurcotteFunction2RohdeType(fingerprint: string, rows: TurcotteCsvRow[]): FunctionTypeInformation {
+	guard(rows.length > 0, `No rows found for fingerprint ${fingerprint}`);
+
+	const anyRow = rows[0];
+
+	// now we group them by their outer_alternative so that we can get the alternatives in order
+	const groupedByOuter = groupTurcotteData(rows, row => row.outer_alternative);
+
+	const type = [];
+	for(const [, innerRows] of groupedByOuter.entries()) {
+		type.push(convertSingleTurcotteFunctionAlternative2RohdeType(fingerprint, innerRows));
+	}
+
+	return {
+		package: anyRow.package_name,
+		name:    anyRow.function_name,
+		type
+	};
+}
+const globalCache: Map<UnresolvedDataType, { lowerBounds: Set<UnresolvedDataType>, upperBounds: Set<UnresolvedDataType> }> = new Map();
+
+function constrainLowerAndUpperBound(type: UnresolvedDataType, lowerBound: UnresolvedDataType, upperBound: UnresolvedDataType = lowerBound) {
+	constrainWithLowerBound(type, lowerBound, globalCache);
+	constrainWithUpperBound(type, upperBound, globalCache);
+	return type;
+}
+
+function convertSingleTurcotteFunctionAlternative2RohdeType(fingerprint: string, rows: TurcotteCsvRow[]): RFunctionType {
+	const groupedByParameterPos = groupTurcotteData(rows, row => row.parameter_position);
+	const fn = new UnresolvedRFunctionType();
+
+	for(const [parameterPosition, parameterRows] of groupedByParameterPos.entries()) {
+		// convert the rows to a single type
+		const type = convertSingleTurcotteParameter2RohdeType(fingerprint, parameterRows);
+		if(parameterPosition === '-1') {
+			constrainLowerAndUpperBound(fn.returnType, type);
+		} else {
+			// we get the type to create a new one if not already there
+			getParameterTypeFromFunction(fn, Number(parameterPosition));
+			// now we can set the type
+			constrainLowerAndUpperBound(fn.parameterTypes.get(Number(parameterPosition)) as UnresolvedDataType, type);
+		}
+	}
+
+	return fn;
+}
+
+function convertSingleTurcotteParameter2RohdeType(fingerprint: string, rows: TurcotteCsvRow[]): UnresolvedDataType {
+	// every row here is an alternative for a single parameter position
+	guard(rows.length > 0, `No rows found for fingerprint ${fingerprint}`);
+	const anyRow = rows[0];
+	guard(rows.every(r =>
+		r.parameter_position === anyRow.parameter_position &&
+		r.package_name === anyRow.package_name &&
+		r.outer_alternative === anyRow.outer_alternative &&
+		r.function_name === anyRow.function_name), 'Just for my sanity, please!');
+
+	// now we convert all types in the list to the rohde System
+	return new UnresolvedRTypeUnion(
+		...rows.map(r => turcotteType2RohdeType(r.type))
+	);
+}
+
+
+function turcotteType2RohdeType(type: string): UnresolvedDataType {
+	const isArray = type.endsWith('[]');
+	if(isArray) {
+		type = type.slice(0, -2); // remove the []
+	}
+	// it may contain NAs, currently untracked by the Rohde System
+	if(type.startsWith('^')) {
+		type = type.slice(1); // remove the ^
+	}
+	let r: UnresolvedDataType | undefined = undefined;
+	switch(type) {
+		case 'any':         r = new UnresolvedRTypeVariable(); break;
+		case 'null':        r = new RNullType(); break;
+		case 'logical':     r = new RLogicalType(); break;
+		case 'integer':     r = new RIntegerType(); break;
+		case 'double':      r = new RDoubleType(); break;
+		case 'character':   r = new RStringType(); break;
+		case 'complex':     r = new RComplexType(); break;
+		case 'environment': r = new REnvironmentType(); break;
+		case 'raw':         r = new RRawType(); break;
+		case 'expression':  r = new RLanguageType(); break;
+		case 'externalptr': r = new UnresolvedRTypeVariable(); break;
+		case 'pairlist':    r = new UnresolvedRListType(); break;
+		default:
+			r = parseComplicatedTurcotteType(type);
+	}
+
+	guard(r !== undefined, `Unknown type ${JSON.stringify(type)} in Turcotte data!`);
+
+	if(r.tag !== DataTypeTag.Variable) {
+		if(isArray) {
+			const variable = new UnresolvedRTypeVariable();
+			constrainLowerAndUpperBound(variable, r);
+			r = new UnresolvedRAtomicVectorType(variable);
+		}
+	} else if(isArray) {
+		r = new UnresolvedRAtomicVectorType(r);
+	}
+
+	return r;
+}
+
+function alternativeTurcotteType2RohdeType(type: string[]): UnresolvedDataType {
+	if(type.length === 0) {
+		return new UnresolvedRTypeVariable();
+	}
+	if(type.length === 1) {
+		return turcotteType2RohdeType(type[0]);
+	}
+	const types = type.map(t => turcotteType2RohdeType(t));
+	return new UnresolvedRTypeUnion(...types);
+}
+
+
+function turcotte2RohdeTypes(data: TurcotteCsvRow[]): RohdeTypes {
+	// why even?
+	guard(data.every(d => d.count === '1'), 'What the count?');
+
+	// first we group the data by package::function name to get the alternatives in order!
+	const groupedData = groupTurcotteData(data, row => `${row.package_name}::${row.function_name}`);
+
+	const info: FunctionTypeInformation[] = [];
+	for(const [fingerprint, rows] of groupedData.entries()) {
+		info.push(convertTurcotteFunction2RohdeType(fingerprint, rows));
+	}
+
+	return { info };
+}
+
+
+
+function parseComplicatedTurcotteType(type: string): UnresolvedDataType | undefined{
+	// everything up until the first parse <1, 2 | 3, 4 & 5> etc. recursively!
+	const [prefix, main] = type.split(/<(.*)/, 2);
+
+	// no can do's
+	switch(prefix) {
+		case 'class':
+			// Rohde currently does not support classes, so we just return a variable type
+			return new UnresolvedRTypeVariable();
+		case '...':
+			// there may be arbitrary more parameters - we do not know their type
+			return new UnresolvedRTypeVariable();
+	}
+
+	guard(main.endsWith('>'), `Invalid Turcotte type ${JSON.stringify(type)}!`);
+
+	const argString = main.slice(0, -1);
+
+	const params = collectParams(argString);
+
+	switch(prefix) {
+		case 'list': {
+			guard(params.length === 1, `List type ${JSON.stringify(type)} must have exactly one parameter!`);
+			const v = new UnresolvedRTypeVariable();
+			constrainLowerAndUpperBound(v, alternativeTurcotteType2RohdeType(params[0]));
+			return new UnresolvedRListType(v);
+		}
+
+	}
+
+	return undefined;
+}
+
+// collect params, splitting on alternatives '|'
+function collectParams(argString: string): string[][] {
+	// split at comma but respect nestings with <>
+	const params: string[][] = [];
+	const currentParams: string[] = [];
+	let current = '';
+	let depth = 0;
+	let quoted = false;
+	for(const char of argString) {
+		if(char === '"' || char === "'" || char === '`') {
+			quoted = !quoted; // toggle quoted state
+			current += char;
+			continue;
+		}
+		if(char === '<' && !quoted) {
+			depth++;
+		} else if(char === '>' && !quoted) {
+			depth--;
+		} else if(!quoted && char === ',' && depth === 0) {
+			params.push([...currentParams, current.trim()]);
+			current = '';
+			continue;
+		} else if(char === '|' && !quoted && depth === 0) {
+			// split on alternatives
+			if(current.trim().length > 0) {
+				currentParams.push(current.trim());
+			}
+			current = '';
+			continue;
+		}
+		current += char;
+	}
+
+	if(current.trim().length > 0) {
+		currentParams.push(current.trim());
+	}
+	if(currentParams.length > 0) {
+		params.push(currentParams);
+	}
+	return params;
+}
\ No newline at end of file
diff --git a/src/typing/subtyping/pretty-print.ts b/src/typing/subtyping/pretty-print.ts
new file mode 100644
index 00000000000..ff5e149777c
--- /dev/null
+++ b/src/typing/subtyping/pretty-print.ts
@@ -0,0 +1,74 @@
+import type { DataType } from '../types';
+import { DataTypeTag } from '../types';
+import { assertUnreachable } from '../../util/assert';
+
+function isAny(t: DataType): boolean {
+	return t.tag === DataTypeTag.Variable &&
+        t.lowerBound.tag === DataTypeTag.Union && t.lowerBound.types.size === 0 &&
+        t.upperBound.tag === DataTypeTag.Intersection && t.upperBound.types.size === 0;
+}
+
+export function prettyPrint(t: DataType | undefined, shorten = true): string {
+	if(t === undefined) {
+		return '$$undefined';
+	}
+	const tag = t.tag;
+	if(isAny(t)) {
+		return 'any';
+	}
+	switch(tag) {
+		case DataTypeTag.String:
+		case DataTypeTag.Integer:
+		case DataTypeTag.Double:
+		case DataTypeTag.Complex:
+		case DataTypeTag.Logical:
+		case DataTypeTag.Null:
+		case DataTypeTag.Raw:
+		case DataTypeTag.Environment:
+		case DataTypeTag.Language:
+			return shorten && tag.startsWith('R') && tag.endsWith('Type') ? tag.slice(1, -4): tag;
+		case DataTypeTag.Function:
+			return `${shorten ? 'fn' : 'function'}(${[...t.parameterTypes.entries()].map(([k, v]) => 
+				k ? `${k}: ${prettyPrint(v, shorten)}` : prettyPrint(v, shorten)
+			).join(', ')}) ${shorten ? '→' : '->'} ${prettyPrint(t.returnType, shorten)}`;
+		case DataTypeTag.List: {
+			const type = prettyPrint(t.elementType, shorten);
+			const indexed = t.indexedElementTypes.size > 0 ? `, idx: {${[...t.indexedElementTypes.entries()].map(([k, v]) => 
+				k ? `${k}: ${prettyPrint(v, shorten)}` : prettyPrint(v, shorten)).join(', ')}}` : '';
+			if(shorten && indexed === '' && type === 'any' || type === '$(any)') {
+				return 'list';
+			}
+			return `list<${type}${indexed}>`;
+		} case DataTypeTag.Variable: {
+			const prefix = shorten ? '$' : 'var(';
+			// subsumes didn't work :/
+			const lower = prettyPrint(t.lowerBound, shorten);
+			const upper = prettyPrint(t.upperBound, shorten);
+			if(shorten && lower === upper) {
+				return `${prefix}(${prettyPrint(t.lowerBound, shorten)})`;
+			}
+			return `${prefix}(${lower}, ${upper})`;
+		}
+		case DataTypeTag.Union: {
+			if(shorten && t.types.size === 1) {
+				return prettyPrint([...t.types][0], shorten);
+			}
+			const types = [...t.types].map(d => prettyPrint(d, shorten));
+			if(shorten && types.some(t => t === 'any' || t === '$(any)')) {
+				return '⋃(any*)';
+			}
+			return `${shorten ? '⋃' : 'union'}(${types.join(', ')}))`;
+		}
+		case DataTypeTag.Intersection:
+			if(shorten && t.types.size === 1) {
+				return prettyPrint([...t.types][0], shorten);
+			}
+			return `${shorten ? '⋂' : 'intersection'}(${[...t.types].map(d => prettyPrint(d, shorten)).join(', ')})`;
+		case DataTypeTag.AtomicVector:
+			return `${shorten ? 'c' : 'vector'}<${prettyPrint(t.elementType, shorten)}>`;
+		case DataTypeTag.Error:
+			return `error(${JSON.stringify(t.conflictingBounds)})`;
+		default:
+			assertUnreachable(tag);
+	}
+}
\ No newline at end of file
diff --git a/src/typing/subtyping/types.ts b/src/typing/subtyping/types.ts
index 4b3314724e6..b39e5c11041 100644
--- a/src/typing/subtyping/types.ts
+++ b/src/typing/subtyping/types.ts
@@ -299,7 +299,7 @@ export function resolveType(type: UnresolvedDataType, cache: Map<UnresolvedDataT
 	}
 }
 
-function subsumes(subtype: DataType | UnresolvedDataType, supertype: DataType | UnresolvedDataType): boolean {
+export function subsumes(subtype: DataType | UnresolvedDataType, supertype: DataType | UnresolvedDataType): boolean {
 	// console.debug('Checking if', subtype, 'subsumes', supertype);
 
 	if(subtype === supertype) {
diff --git a/turcotte-types.csv b/turcotte-types.csv
new file mode 100644
index 00000000000..946ac5e2df8
--- /dev/null
+++ b/turcotte-types.csv
@@ -0,0 +1,119818 @@
+package_name,function_name,parameter_position,outer_alternative,inner_alternative,type,count
+ADGofTest,ad.test,-1,0,0,class<`htest`>,1
+ADGofTest,ad.test,0,0,0,double[],1
+ADGofTest,ad.test,1,0,0,any,1
+ADGofTest,ad.test,2,0,0,...,1
+ADGofTest,ad.test.pvalue,-1,0,0,double,1
+ADGofTest,ad.test.pvalue,0,0,0,double,1
+ADGofTest,ad.test.pvalue,1,0,0,integer,1
+ADGofTest,ad.test.statistic,-1,0,0,double,1
+ADGofTest,ad.test.statistic,0,0,0,double[],1
+AUC,accuracy,-1,0,0,"class<`AUC`, `accuracy`>",1
+AUC,accuracy,0,0,0,double[],1
+AUC,accuracy,1,0,0,class<`factor`>,1
+AUC,accuracy,2,0,0,logical,1
+AUC,auc,-1,0,0,double,1
+AUC,auc,0,0,0,"class<`AUC`, `accuracy`>",1
+AUC,auc,0,0,1,"class<`AUC`, `roc`>",1
+AUC,auc,0,0,2,"class<`AUC`, `sensitivity`>",1
+AUC,auc,0,0,3,"class<`AUC`, `specificity`>",1
+AUC,auc,1,0,0,double,1
+AUC,auc,2,0,0,double,1
+AUC,.confusionMatrix,-1,0,0,list<double[]>,1
+AUC,.confusionMatrix,0,0,0,double[],1
+AUC,.confusionMatrix,1,0,0,class<`factor`>,1
+AUC,.confusionMatrix,2,0,0,logical,1
+AUC,.confusionMatrix,3,0,0,character,1
+AUC,plot.AUC,-1,0,0,null,1
+AUC,plot.AUC,0,0,0,"class<`AUC`, `accuracy`>",1
+AUC,plot.AUC,0,0,1,"class<`AUC`, `roc`>",1
+AUC,plot.AUC,0,0,2,"class<`AUC`, `sensitivity`>",1
+AUC,plot.AUC,0,0,3,"class<`AUC`, `specificity`>",1
+AUC,plot.AUC,1,0,0,null,1
+AUC,plot.AUC,2,0,0,...,1
+AUC,plot.AUC,3,0,0,character,1
+AUC,plot.AUC,4,0,0,logical,1
+AUC,plot.AUC,5,0,0,double,1
+AUC,plot.AUC,6,0,0,double,1
+AUC,roc,-1,0,0,"class<`AUC`, `roc`>",1
+AUC,roc,0,0,0,double[],1
+AUC,roc,1,0,0,class<`factor`>,1
+AUC,sensitivity,-1,0,0,"class<`AUC`, `sensitivity`>",1
+AUC,sensitivity,0,0,0,double[],1
+AUC,sensitivity,1,0,0,class<`factor`>,1
+AUC,sensitivity,2,0,0,logical,1
+AUC,specificity,-1,0,0,"class<`AUC`, `specificity`>",1
+AUC,specificity,0,0,0,double[],1
+AUC,specificity,1,0,0,class<`factor`>,1
+AUC,specificity,2,0,0,logical,1
+AlgDesign,efficient.rounding,-1,0,0,double[],1
+AlgDesign,efficient.rounding,0,0,0,double[],1
+AlgDesign,efficient.rounding,1,0,0,double,1
+AlgDesign,efficient.rounding,2,0,0,logical,1
+AlgDesign,expand.formula,-1,0,0,class<`formula`>,1
+AlgDesign,expand.formula,0,0,0,class<`formula`>,1
+AlgDesign,expand.formula,1,0,0,any,1
+AlgDesign,expand.formula,2,0,0,logical,1
+AlgDesign,expand.formula,3,0,0,any,1
+AlgDesign,gen.factorial,-1,0,0,class<`data.frame`>,1
+AlgDesign,gen.factorial,0,0,0,double[],1
+AlgDesign,gen.factorial,1,0,0,double,1
+AlgDesign,gen.factorial,2,0,0,logical,1
+AlgDesign,gen.factorial,3,0,0,character,1
+AlgDesign,gen.factorial,3,0,1,integer[],1
+AlgDesign,gen.factorial,4,0,0,null,1
+AlgDesign,gen.factorial,4,0,1,character[],1
+AlgDesign,gen.mixture,-1,0,0,class<`data.frame`>,1
+AlgDesign,gen.mixture,0,0,0,double,1
+AlgDesign,gen.mixture,1,0,0,double,1
+AlgDesign,model.matrix.formula,-1,0,0,class<`matrix`>,1
+AlgDesign,model.matrix.formula,0,0,0,class<`formula`>,1
+AlgDesign,model.matrix.formula,1,0,0,class<`data.frame`>,1
+AlgDesign,model.matrix.formula,2,0,0,...,1
+AlgDesign,optBlock,-1,0,0,list<class<`data.frame`> | double[] | list<class<`data.frame`>>>,1
+AlgDesign,optBlock,0,0,0,class<`formula`>,1
+AlgDesign,optBlock,1,0,0,class<`data.frame`>,1
+AlgDesign,optBlock,1,0,1,class<`factor`>,1
+AlgDesign,optBlock,2,0,0,double[],1
+AlgDesign,optBlock,3,0,0,null,1
+AlgDesign,optBlock,4,0,0,class<`data.frame`>,1
+AlgDesign,optBlock,4,0,1,null,1
+AlgDesign,optBlock,5,0,0,logical,1
+AlgDesign,optBlock,6,0,0,double,1
+AlgDesign,optBlock,7,0,0,character,1
+AlgDesign,optBlock,8,0,0,logical,1
+AlgDesign,optFederov,-1,0,0,list<class<`data.frame`> | double[]>,1
+AlgDesign,optFederov,-1,0,1,list<double | class<`data.frame`> | integer[]>,1
+AlgDesign,optFederov,0,0,0,class<`formula`>,1
+AlgDesign,optFederov,1,0,0,class<`data.frame`>,1
+AlgDesign,optFederov,1,0,1,class<`matrix`>,1
+AlgDesign,optFederov,2,0,0,any,1
+AlgDesign,optFederov,3,0,0,logical,1
+AlgDesign,optFederov,4,0,0,logical,1
+AlgDesign,optFederov,5,0,0,character,1
+AlgDesign,optFederov,6,0,0,logical,1
+AlgDesign,optFederov,7,0,0,any,1
+AlgDesign,optFederov,8,0,0,logical,1
+AlgDesign,optFederov,9,0,0,double[],1
+AlgDesign,optFederov,9,0,1,null,1
+AlgDesign,optFederov,10,0,0,double,1
+AlgDesign,optFederov,11,0,0,double,1
+AlgDesign,optFederov,12,0,0,double,1
+AlgDesign,optFederov,13,0,0,double,1
+AlgDesign,optFederov,14,0,0,double,1
+AlgDesign,optFederov,15,0,0,logical,1
+AlgDesign,optMonteCarlo,-1,0,0,list<double | class<`data.frame`>>,1
+AlgDesign,optMonteCarlo,0,0,0,class<`formula`>,1
+AlgDesign,optMonteCarlo,1,0,0,class<`data.frame`>,1
+AlgDesign,optMonteCarlo,2,0,0,any,1
+AlgDesign,optMonteCarlo,3,0,0,logical,1
+AlgDesign,optMonteCarlo,4,0,0,character,1
+AlgDesign,optMonteCarlo,5,0,0,logical,1
+AlgDesign,optMonteCarlo,6,0,0,null,1
+AlgDesign,optMonteCarlo,7,0,0,double,1
+AlgDesign,optMonteCarlo,8,0,0,null,1
+AlgDesign,optMonteCarlo,8,0,1,class<`function`>,1
+AlgDesign,optMonteCarlo,9,0,0,logical,1
+AlgDesign,optMonteCarlo,10,0,0,double,1
+AlgDesign,optMonteCarlo,11,0,0,any,1
+AlgDesign,optMonteCarlo,12,0,0,any,1
+AlgDesign,optMonteCarlo,13,0,0,double,1
+AlgDesign,optMonteCarlo,14,0,0,double,1
+AlgDesign,optMonteCarlo,15,0,0,logical,1
+BBmisc,addClasses,-1,0,0,"class<`foo1`, `foo2`, `list`>",1
+BBmisc,addClasses,0,0,0,list<any>,1
+BBmisc,addClasses,1,0,0,character[],1
+BBmisc,argsAsNamedList,-1,0,0,list<double>,1
+BBmisc,argsAsNamedList,0,0,0,...,1
+BBmisc,asQuoted,-1,0,0,class<`call`>,1
+BBmisc,asQuoted,0,0,0,character,1
+BBmisc,asQuoted,1,0,0,environment,1
+BBmisc,binPack,-1,0,0,integer[],1
+BBmisc,binPack,0,0,0,integer[],1
+BBmisc,binPack,1,0,0,double,1
+BBmisc,%btwn%,-1,0,0,logical,1
+BBmisc,%btwn%,0,0,0,double,1
+BBmisc,%btwn%,1,0,0,double[],1
+BBmisc,capitalizeStrings,-1,0,0,character[],1
+BBmisc,capitalizeStrings,0,0,0,character[],1
+BBmisc,capitalizeStrings,1,0,0,logical,1
+BBmisc,capitalizeStrings,2,0,0,logical,1
+BBmisc,catf,-1,0,0,null,1
+BBmisc,catf,0,0,0,...,1
+BBmisc,catf,1,0,0,character,1
+BBmisc,catf,2,0,0,logical,1
+BBmisc,catf,3,0,0,logical,1
+BBmisc,cFactor,-1,0,0,class<`factor`>,1
+BBmisc,cFactor,0,0,0,...,1
+BBmisc,checkListElementClass,-1,0,0,null,1
+BBmisc,checkListElementClass,0,0,0,list<integer>,1
+BBmisc,checkListElementClass,1,0,0,character,1
+BBmisc,chunk,-1,0,0,list<integer[]>,1
+BBmisc,chunk,0,0,0,integer[],1
+BBmisc,chunk,1,0,0,any,1
+BBmisc,chunk,2,0,0,any,1
+BBmisc,chunk,3,0,0,any,1
+BBmisc,chunk,4,0,0,logical,1
+BBmisc,clipString,-1,0,0,character,1
+BBmisc,clipString,0,0,0,character,1
+BBmisc,clipString,1,0,0,double,1
+BBmisc,clipString,2,0,0,character,1
+BBmisc,coalesce,-1,0,0,double,1
+BBmisc,coalesce,0,0,0,...,1
+BBmisc,collapse,-1,0,0,character,1
+BBmisc,collapse,0,0,0,character[],1
+BBmisc,collapse,1,0,0,character,1
+BBmisc,computeMode,-1,0,0,double,1
+BBmisc,computeMode,0,0,0,double[],1
+BBmisc,computeMode,1,0,0,character,1
+BBmisc,computeMode,2,0,0,logical,1
+BBmisc,convertInteger,-1,0,0,character,1
+BBmisc,convertInteger,-1,0,1,double[],1
+BBmisc,convertInteger,0,0,0,character,1
+BBmisc,convertInteger,0,0,1,double[],1
+BBmisc,convertIntegers,-1,0,0,character,1
+BBmisc,convertIntegers,-1,0,1,double,1
+BBmisc,convertIntegers,-1,0,2,integer[],1
+BBmisc,convertIntegers,0,0,0,character,1
+BBmisc,convertIntegers,0,0,1,double[],1
+BBmisc,convertListOfRowsToDataFrame,-1,0,0,class<`data.frame`>,1
+BBmisc,convertListOfRowsToDataFrame,0,0,0,list<list<double | character>>,1
+BBmisc,convertListOfRowsToDataFrame,1,0,0,logical,1
+BBmisc,convertListOfRowsToDataFrame,2,0,0,any,1
+BBmisc,convertListOfRowsToDataFrame,3,0,0,any,1
+BBmisc,convertToShortString,-1,0,0,character,1
+BBmisc,convertToShortString,0,0,0,list<any>,1
+BBmisc,convertToShortString,1,0,0,character,1
+BBmisc,convertToShortString,2,0,0,integer,1
+BBmisc,explode,-1,0,0,character[],1
+BBmisc,explode,0,0,0,character,1
+BBmisc,explode,1,0,0,character,1
+BBmisc,extractSubList,-1,0,0,double[],1
+BBmisc,extractSubList,-1,0,1,list<double>,1
+BBmisc,extractSubList,0,0,0,list<list<double>>,1
+BBmisc,extractSubList,1,0,0,character,1
+BBmisc,extractSubList,2,0,0,any,1
+BBmisc,extractSubList,3,0,0,logical,1
+BBmisc,extractSubList,4,0,0,logical,1
+BBmisc,getClass1,-1,0,0,character,1
+BBmisc,getClass1,0,0,0,character,1
+BBmisc,getClass1,0,0,1,double,1
+BBmisc,getClass1,0,0,2,integer[],1
+BBmisc,getClass1,0,0,3,null,1
+BBmisc,getClass1,0,0,4,list<any>,1
+BBmisc,getMaxIndexOfRows,-1,0,0,integer[],1
+BBmisc,getMaxIndexOfRows,0,0,0,class<`matrix`>,1
+BBmisc,getMaxIndexOfRows,1,0,0,character,1
+BBmisc,getMaxIndexOfRows,2,0,0,logical,1
+BBmisc,getMinIndexOfRows,-1,0,0,integer[],1
+BBmisc,getMinIndexOfRows,0,0,0,class<`matrix`>,1
+BBmisc,getMinIndexOfRows,1,0,0,character,1
+BBmisc,getMinIndexOfRows,2,0,0,logical,1
+BBmisc,getNChunks,-1,0,0,integer[],1
+BBmisc,getNChunks,0,0,0,integer,1
+BBmisc,getNChunks,1,0,0,integer,1
+BBmisc,getNChunks,2,0,0,logical,1
+BBmisc,insert,-1,0,0,list<double>,1
+BBmisc,insert,0,0,0,list<double>,1
+BBmisc,insert,1,0,0,list<double>,1
+BBmisc,insert,2,0,0,any,1
+BBmisc,isDirectory,-1,0,0,logical,1
+BBmisc,isDirectory,0,0,0,...,1
+BBmisc,isEmptyDirectory,-1,0,0,logical,1
+BBmisc,isEmptyDirectory,0,0,0,...,1
+BBmisc,is.error,-1,0,0,logical,1
+BBmisc,is.error,0,0,0,class<`try-error`>,1
+BBmisc,is.error,0,0,1,double,1
+BBmisc,isExpensiveExampleOk,-1,0,0,logical,1
+BBmisc,isFALSE,-1,0,0,logical,1
+BBmisc,isFALSE,0,0,0,double,1
+BBmisc,isProperlyNamed,-1,0,0,logical,1
+BBmisc,isProperlyNamed,0,0,0,list<double>,1
+BBmisc,isScalarValue,-1,0,0,logical,1
+BBmisc,isScalarValue,0,0,0,double,1
+BBmisc,isScalarValue,1,0,0,logical,1
+BBmisc,isScalarValue,2,0,0,logical,1
+BBmisc,isScalarValue,3,0,0,character,1
+BBmisc,itostr,-1,0,0,character[],1
+BBmisc,itostr,0,0,0,integer[],1
+BBmisc,itostr,0,0,1,double,1
+BBmisc,itostr,1,0,0,double,1
+BBmisc,load2,-1,0,0,double,1
+BBmisc,load2,-1,0,1,list<double>,1
+BBmisc,load2,0,0,0,character,1
+BBmisc,load2,1,0,0,character[],1
+BBmisc,load2,2,0,0,logical,1
+BBmisc,load2,3,0,0,any,1
+BBmisc,load2,4,0,0,any,1
+BBmisc,makeDataFrame,-1,0,0,class<`data.frame`>,1
+BBmisc,makeDataFrame,0,0,0,double,1
+BBmisc,makeDataFrame,1,0,0,double,1
+BBmisc,makeDataFrame,2,0,0,any,1
+BBmisc,makeDataFrame,3,0,0,any,1
+BBmisc,makeDataFrame,4,0,0,null,1
+BBmisc,makeDataFrame,5,0,0,character[],1
+BBmisc,makeProgressBar,-1,0,0,class<`ProgressBar`>,1
+BBmisc,makeProgressBar,0,0,0,double,1
+BBmisc,makeProgressBar,1,0,0,double,1
+BBmisc,makeProgressBar,2,0,0,character,1
+BBmisc,makeProgressBar,3,0,0,character,1
+BBmisc,makeProgressBar,4,0,0,character,1
+BBmisc,makeProgressBar,5,0,0,integer,1
+BBmisc,makeProgressBar,6,0,0,character,1
+BBmisc,makeS3Obj,-1,0,0,class<`car`>,1
+BBmisc,makeS3Obj,-1,0,1,class<`ProgressBar`>,1
+BBmisc,makeS3Obj,0,0,0,character,1
+BBmisc,makeS3Obj,1,0,0,...,1
+BBmisc,mapValues,-1,0,0,class<`factor`>,1
+BBmisc,mapValues,-1,0,1,double[],1
+BBmisc,mapValues,0,0,0,class<`factor`>,1
+BBmisc,mapValues,0,0,1,integer[],1
+BBmisc,mapValues,1,0,0,character,1
+BBmisc,mapValues,1,0,1,double[],1
+BBmisc,mapValues,2,0,0,character,1
+BBmisc,mapValues,2,0,1,double[],1
+BBmisc,mapValues,3,0,0,logical,1
+BBmisc,mapValues,4,0,0,logical,1
+BBmisc,mapValues,5,0,0,logical,1
+BBmisc,mapValues,6,0,0,logical,1
+BBmisc,namedList,-1,0,0,list<double>,1
+BBmisc,namedList,-1,0,1,list<null>,1
+BBmisc,namedList,0,0,0,character[],1
+BBmisc,namedList,1,0,0,any,1
+BBmisc,names2,-1,0,0,^character[],1
+BBmisc,names2,-1,0,1,null,1
+BBmisc,names2,0,0,0,integer[],1
+BBmisc,names2,0,0,1,list<any>,1
+BBmisc,names2,1,0,0,null,1
+BBmisc,names2,1,0,1,character,1
+BBmisc,printStrToChar,-1,0,0,character,1
+BBmisc,printStrToChar,0,0,0,class<`data.frame`>,1
+BBmisc,printStrToChar,1,0,0,character,1
+BBmisc,printToChar,-1,0,0,character[],1
+BBmisc,printToChar,0,0,0,null,1
+BBmisc,printToChar,0,0,1,class<`data.frame`>,1
+BBmisc,printToChar,1,0,0,null,1
+BBmisc,printToChar,1,0,1,character,1
+BBmisc,requirePackages,-1,0,0,logical[],1
+BBmisc,requirePackages,0,0,0,character[],1
+BBmisc,requirePackages,1,0,0,null,1
+BBmisc,requirePackages,2,0,0,character,1
+BBmisc,requirePackages,3,0,0,logical,1
+BBmisc,requirePackages,4,0,0,logical,1
+BBmisc,requirePackages,5,0,0,character,1
+BBmisc,rowLapply,-1,0,0,list<double>,1
+BBmisc,rowLapply,0,0,0,class<`data.frame`>,1
+BBmisc,rowLapply,1,0,0,class<`function`>,1
+BBmisc,rowLapply,2,0,0,...,1
+BBmisc,rowLapply,3,0,0,logical,1
+BBmisc,save2,-1,0,0,null,1
+BBmisc,save2,0,0,0,character,1
+BBmisc,save2,1,0,0,...,1
+BBmisc,save2,2,0,0,logical,1
+BBmisc,save2,3,0,0,null,1
+BBmisc,save2,4,0,0,logical,1
+BBmisc,save2,5,0,0,any,1
+BBmisc,save2,6,0,0,logical,1
+BBmisc,save2,7,0,0,logical,1
+BBmisc,seq_col,-1,0,0,integer[],1
+BBmisc,seq_col,0,0,0,class<`data.frame`>,1
+BBmisc,seq_row,-1,0,0,integer[],1
+BBmisc,seq_row,0,0,0,class<`data.frame`>,1
+BBmisc,setAttribute,-1,0,0,list<any>,1
+BBmisc,setAttribute,0,0,0,list<any>,1
+BBmisc,setAttribute,1,0,0,character,1
+BBmisc,setAttribute,2,0,0,double,1
+BBmisc,setClasses,-1,0,0,class<`car`>,1
+BBmisc,setClasses,-1,0,1,class<`factor`>,1
+BBmisc,setClasses,-1,0,2,"class<`foo1`, `foo2`>",1
+BBmisc,setClasses,-1,0,3,class<`ProgressBar`>,1
+BBmisc,setClasses,0,0,0,integer[],1
+BBmisc,setClasses,0,0,1,list<any>,1
+BBmisc,setClasses,1,0,0,character[],1
+BBmisc,setColNames,-1,0,0,class<`matrix`>,1
+BBmisc,setColNames,0,0,0,class<`matrix`>,1
+BBmisc,setColNames,1,0,0,character[],1
+BBmisc,splitTime,-1,0,0,^integer[],1
+BBmisc,splitTime,0,0,0,double,1
+BBmisc,splitTime,1,0,0,character,1
+BBmisc,stopf,-1,0,0,list<any>,1
+BBmisc,stopf,0,0,0,...,1
+BBmisc,stopf,1,0,0,integer,1
+BBmisc,strrepeat,-1,0,0,character,1
+BBmisc,strrepeat,0,0,0,character,1
+BBmisc,strrepeat,1,0,0,double,1
+BBmisc,strrepeat,2,0,0,character,1
+BBmisc,suppressAll,-1,0,0,character,1
+BBmisc,suppressAll,0,0,0,character,1
+BBmisc,toRangeStr,-1,0,0,character,1
+BBmisc,toRangeStr,0,0,0,integer[],1
+BBmisc,toRangeStr,1,0,0,character,1
+BBmisc,toRangeStr,2,0,0,character,1
+BBmisc,viapply,-1,0,0,^integer[],1
+BBmisc,viapply,0,0,0,list<character>,1
+BBmisc,viapply,0,0,1,list<double>,1
+BBmisc,viapply,0,0,2,^double[],1
+BBmisc,viapply,1,0,0,class<`function`>,1
+BBmisc,viapply,2,0,0,...,1
+BBmisc,viapply,3,0,0,logical,1
+BBmisc,vlapply,-1,0,0,logical[],1
+BBmisc,vlapply,0,0,0,list<character>,1
+BBmisc,vlapply,0,0,1,list<double>,1
+BBmisc,vlapply,1,0,0,class<`function`>,1
+BBmisc,vlapply,2,0,0,...,1
+BBmisc,vlapply,3,0,0,logical,1
+BBmisc,warningf,-1,0,0,character,1
+BBmisc,warningf,0,0,0,...,1
+BBmisc,warningf,1,0,0,logical,1
+BBmisc,warningf,2,0,0,integer,1
+BBmisc,which.first,-1,0,0,integer[],1
+BBmisc,which.first,0,0,0,logical[],1
+BBmisc,which.first,1,0,0,logical,1
+BBmisc,which.last,-1,0,0,integer[],1
+BBmisc,which.last,0,0,0,logical[],1
+BBmisc,which.last,1,0,0,logical,1
+CTT,cttICC,-1,0,0,null,1
+CTT,cttICC,0,0,0,double[],1
+CTT,cttICC,1,0,0,double[],1
+CTT,cttICC,2,0,0,any,1
+CTT,cttICC,3,0,0,any,1
+CTT,cttICC,4,0,0,any,1
+CTT,cttICC,5,0,0,any,1
+CTT,cttICC,6,0,0,any,1
+CTT,cttICC,7,0,0,any,1
+CTT,cttICC,8,0,0,character,1
+CTT,cttICC,9,0,0,any,1
+CTT,cttICC,10,0,0,any,1
+CTT,cttICC,11,0,0,...,1
+CTT,disattenuated.cor,-1,0,0,class<`matrix`>,1
+CTT,disattenuated.cor,0,0,0,class<`matrix`>,1
+CTT,disattenuated.cor,0,0,1,double,1
+CTT,disattenuated.cor,1,0,0,double[],1
+CTT,disattenuated.cor,2,0,0,double[],1
+CTT,distractor.analysis,-1,0,0,"list<class<`table`, `xtabs`>>",1
+CTT,distractor.analysis,0,0,0,class<`data.frame`>,1
+CTT,distractor.analysis,1,0,0,character[],1
+CTT,distractor.analysis,2,0,0,any,1
+CTT,distractor.analysis,3,0,0,logical,1
+CTT,distractor.analysis,4,0,0,any,1
+CTT,distractorAnalysis,-1,0,0,list<class<`data.frame`>>,1
+CTT,distractorAnalysis,0,0,0,class<`data.frame`>,1
+CTT,distractorAnalysis,1,0,0,character[],1
+CTT,distractorAnalysis,2,0,0,any,1
+CTT,distractorAnalysis,3,0,0,double,1
+CTT,distractorAnalysis,4,0,0,any,1
+CTT,distractorAnalysis,5,0,0,character,1
+CTT,distractorAnalysis,6,0,0,character[],1
+CTT,distractorAnalysis,7,0,0,any,1
+CTT,distractorAnalysis,8,0,0,any,1
+CTT,distractorAnalysis,9,0,0,logical,1
+CTT,distractorAnalysis,10,0,0,any,1
+CTT,itemAnalysis,-1,0,0,class<`itemAnalysis`>,1
+CTT,itemAnalysis,0,0,0,class<`data.frame`>,1
+CTT,itemAnalysis,1,0,0,logical,1
+CTT,itemAnalysis,2,0,0,logical,1
+CTT,itemAnalysis,3,0,0,logical,1
+CTT,itemAnalysis,4,0,0,any,1
+CTT,itemAnalysis,5,0,0,any,1
+CTT,itemAnalysis,6,0,0,any,1
+CTT,itemAnalysis,7,0,0,any,1
+CTT,itemAnalysis,8,0,0,any,1
+CTT,polyserial,-1,0,0,double,1
+CTT,polyserial,0,0,0,double[],1
+CTT,polyserial,1,0,0,double[],1
+CTT,polyserial,2,0,0,logical,1
+CTT,reliability,-1,0,0,class<`reliability`>,1
+CTT,reliability,0,0,0,class<`data.frame`>,1
+CTT,reliability,0,0,1,class<`matrix`>,1
+CTT,reliability,1,0,0,logical,1
+CTT,reliability,2,0,0,logical,1
+CTT,reliability,3,0,0,logical,1
+CTT,score,-1,0,0,list<double[]>,1
+CTT,score,-1,0,1,list<double[] | class<`reliability`> | class<`matrix`>>,1
+CTT,score,-1,0,2,list<double[] | class<`matrix`>>,1
+CTT,score,0,0,0,class<`data.frame`>,1
+CTT,score,1,0,0,any,1
+CTT,score,2,0,0,logical,1
+CTT,score,3,0,0,null,1
+CTT,score,4,0,0,logical,1
+CTT,score,5,0,0,character,1
+CTT,score,6,0,0,any,1
+CTT,score.transform,-1,0,0,list<double[]>,1
+CTT,score.transform,0,0,0,double[],1
+CTT,score.transform,1,0,0,double,1
+CTT,score.transform,2,0,0,double,1
+CTT,score.transform,3,0,0,logical,1
+CTT,spearman.brown,-1,0,0,list<double>,1
+CTT,spearman.brown,0,0,0,double,1
+CTT,spearman.brown,1,0,0,double,1
+CTT,spearman.brown,2,0,0,character,1
+CTT,subscales,-1,0,0,list<list<double[] | class<`reliability`> | class<`matrix`>>>,1
+CTT,subscales,0,0,0,class<`data.frame`>,1
+CTT,subscales,1,0,0,class<`matrix`>,1
+CTT,subscales,2,0,0,character[],1
+CTT,subscales,3,0,0,logical,1
+CTT,subscales,4,0,0,logical,1
+CTT,subscales,5,0,0,character[],1
+CircStats,A1inv,-1,0,0,double,1
+CircStats,A1inv,0,0,0,double,1
+CircStats,circ.cor,-1,0,0,class<`data.frame`>,1
+CircStats,circ.cor,0,0,0,double[],1
+CircStats,circ.cor,1,0,0,double[],1
+CircStats,circ.cor,2,0,0,logical,1
+CircStats,circ.mean,-1,0,0,double,1
+CircStats,circ.mean,0,0,0,double[],1
+CircStats,circ.plot,-1,0,0,null,1
+CircStats,circ.plot,0,0,0,double[],1
+CircStats,circ.plot,1,0,0,character,1
+CircStats,circ.plot,2,0,0,double,1
+CircStats,circ.plot,3,0,0,logical,1
+CircStats,circ.plot,4,0,0,double,1
+CircStats,circ.plot,5,0,0,double,1
+CircStats,circ.plot,6,0,0,double,1
+CircStats,circ.plot,7,0,0,double,1
+CircStats,circ.range,-1,0,0,class<`data.frame`>,1
+CircStats,circ.range,0,0,0,double[],1
+CircStats,circ.range,1,0,0,logical,1
+CircStats,circ.reg,-1,0,0,list<class<`matrix`> | double[] | character>,1
+CircStats,circ.reg,0,0,0,double[],1
+CircStats,circ.reg,1,0,0,double[],1
+CircStats,circ.reg,2,0,0,double,1
+CircStats,circ.reg,3,0,0,double,1
+CircStats,circ.summary,-1,0,0,class<`data.frame`>,1
+CircStats,circ.summary,0,0,0,double[],1
+CircStats,dwrpnorm,-1,0,0,double,1
+CircStats,dwrpnorm,0,0,0,double,1
+CircStats,dwrpnorm,1,0,0,double,1
+CircStats,dwrpnorm,2,0,0,double,1
+CircStats,dwrpnorm,3,0,0,double,1
+CircStats,dwrpnorm,4,0,0,double,1
+CircStats,dwrpnorm,5,0,0,double,1
+CircStats,est.kappa,-1,0,0,double,1
+CircStats,est.kappa,0,0,0,double[],1
+CircStats,est.kappa,1,0,0,logical,1
+CircStats,est.rho,-1,0,0,double,1
+CircStats,est.rho,0,0,0,double[],1
+CircStats,kuiper,-1,0,0,null,1
+CircStats,kuiper,0,0,0,double[],1
+CircStats,kuiper,1,0,0,double,1
+CircStats,nCk,-1,0,0,double[],1
+CircStats,nCk,0,0,0,integer,1
+CircStats,nCk,1,0,0,integer[],1
+CircStats,plotedf,-1,0,0,null,1
+CircStats,plotedf,0,0,0,double[],1
+CircStats,plotedf,1,0,0,...,1
+CircStats,pp.plot,-1,0,0,class<`data.frame`>,1
+CircStats,pp.plot,0,0,0,double[],1
+CircStats,pp.plot,1,0,0,logical,1
+CircStats,pvm,-1,0,0,double,1
+CircStats,pvm,0,0,0,double,1
+CircStats,pvm,1,0,0,double,1
+CircStats,pvm,2,0,0,double,1
+CircStats,pvm,3,0,0,double,1
+CircStats,rose.diag,-1,0,0,null,1
+CircStats,rose.diag,0,0,0,double[],1
+CircStats,rose.diag,1,0,0,double,1
+CircStats,rose.diag,2,0,0,character,1
+CircStats,rose.diag,3,0,0,double,1
+CircStats,rose.diag,4,0,0,logical,1
+CircStats,rose.diag,5,0,0,double,1
+CircStats,rose.diag,6,0,0,double,1
+CircStats,rose.diag,7,0,0,double,1
+CircStats,rose.diag,8,0,0,double,1
+CircStats,rstable,-1,0,0,double[],1
+CircStats,rstable,0,0,0,double,1
+CircStats,rstable,1,0,0,double,1
+CircStats,rstable,2,0,0,double,1
+CircStats,rstable,3,0,0,double,1
+CircStats,r.test,-1,0,0,list<double>,1
+CircStats,r.test,0,0,0,double[],1
+CircStats,r.test,1,0,0,logical,1
+CircStats,rvm,-1,0,0,double[],1
+CircStats,rvm,0,0,0,double,1
+CircStats,rvm,1,0,0,double,1
+CircStats,rvm,2,0,0,double,1
+CircStats,rwrpcauchy,-1,0,0,double[],1
+CircStats,rwrpcauchy,0,0,0,double,1
+CircStats,rwrpcauchy,1,0,0,double,1
+CircStats,rwrpcauchy,2,0,0,double,1
+CircStats,v0.test,-1,0,0,list<double>,1
+CircStats,v0.test,0,0,0,double[],1
+CircStats,v0.test,1,0,0,double,1
+CircStats,v0.test,2,0,0,logical,1
+CircStats,vm.bootstrap.ci,-1,0,0,list<double[]>,1
+CircStats,vm.bootstrap.ci,0,0,0,double[],1
+CircStats,vm.bootstrap.ci,1,0,0,logical,1
+CircStats,vm.bootstrap.ci,2,0,0,double,1
+CircStats,vm.bootstrap.ci,3,0,0,double,1
+CircStats,vm.bootstrap.ci,4,0,0,logical,1
+CircStats,watson,-1,0,0,null,1
+CircStats,watson,0,0,0,double[],1
+CircStats,watson,1,0,0,double,1
+CircStats,watson,2,0,0,character,1
+CircStats,watson.two,-1,0,0,null,1
+CircStats,watson.two,0,0,0,double[],1
+CircStats,watson.two,1,0,0,double[],1
+CircStats,watson.two,2,0,0,double,1
+CircStats,watson.two,3,0,0,logical,1
+CircStats,wrpcauchy.ml,-1,0,0,class<`data.frame`>,1
+CircStats,wrpcauchy.ml,0,0,0,double[],1
+CircStats,wrpcauchy.ml,1,0,0,double,1
+CircStats,wrpcauchy.ml,2,0,0,double,1
+CircStats,wrpcauchy.ml,3,0,0,double,1
+CompQuadForm,davies,-1,0,0,list<double[]>,1
+CompQuadForm,davies,0,0,0,double,1
+CompQuadForm,davies,1,0,0,double[],1
+CompQuadForm,davies,2,0,0,double[],1
+CompQuadForm,davies,3,0,0,double[],1
+CompQuadForm,davies,4,0,0,double,1
+CompQuadForm,davies,5,0,0,double,1
+CompQuadForm,davies,6,0,0,double,1
+CompQuadForm,farebrother,-1,0,0,list<double>,1
+CompQuadForm,farebrother,0,0,0,double,1
+CompQuadForm,farebrother,1,0,0,double[],1
+CompQuadForm,farebrother,2,0,0,double[],1
+CompQuadForm,farebrother,3,0,0,double[],1
+CompQuadForm,farebrother,4,0,0,double,1
+CompQuadForm,farebrother,5,0,0,double,1
+CompQuadForm,farebrother,6,0,0,double,1
+CompQuadForm,imhof,-1,0,0,list<double>,1
+CompQuadForm,imhof,0,0,0,double,1
+CompQuadForm,imhof,1,0,0,double[],1
+CompQuadForm,imhof,2,0,0,double[],1
+CompQuadForm,imhof,3,0,0,double[],1
+CompQuadForm,imhof,4,0,0,double,1
+CompQuadForm,imhof,5,0,0,double,1
+CompQuadForm,imhof,6,0,0,double,1
+CompQuadForm,liu,-1,0,0,double,1
+CompQuadForm,liu,0,0,0,double,1
+CompQuadForm,liu,1,0,0,double[],1
+CompQuadForm,liu,2,0,0,double[],1
+CompQuadForm,liu,3,0,0,double[],1
+DALEX,colors_discrete_drwhy,-1,0,0,character,1
+DALEX,colors_discrete_drwhy,0,0,0,integer,1
+DALEX,explain,-1,0,0,class<`explainer`>,1
+DALEX,explain,0,0,0,"class<`glm`, `lm`>",1
+DALEX,explain,0,0,1,class<`lm`>,1
+DALEX,explain,0,0,2,class<`ranger`>,1
+DALEX,explain,1,0,0,class<`data.frame`>,1
+DALEX,explain,1,0,1,null,1
+DALEX,explain,2,0,0,null,1
+DALEX,explain,2,0,1,double[],1
+DALEX,explain,3,0,0,class<`function`>,1
+DALEX,explain,3,0,1,null,1
+DALEX,explain,4,0,0,null,1
+DALEX,explain,5,0,0,null,1
+DALEX,explain,6,0,0,...,1
+DALEX,explain,7,0,0,null,1
+DALEX,explain,7,0,1,character,1
+DALEX,get_pkg_ver_safe,-1,0,0,character,1
+DALEX,get_pkg_ver_safe,0,0,0,character,1
+DALEX,is_y_in_data,-1,0,0,logical,1
+DALEX,is_y_in_data,0,0,0,class<`data.frame`>,1
+DALEX,is_y_in_data,1,0,0,double[],1
+DALEX,model_diagnostics,-1,0,0,"class<`data.frame`, `model_diagnostics`>",1
+DALEX,model_diagnostics,0,0,0,class<`explainer`>,1
+DALEX,model_diagnostics,1,0,0,null,1
+DALEX,model_diagnostics,2,0,0,...,1
+DALEX,model_info,-1,0,0,class<`model_info`>,1
+DALEX,model_info,0,0,0,"class<`glm`, `lm`>",1
+DALEX,model_info,0,0,1,class<`lm`>,1
+DALEX,model_info,0,0,2,class<`ranger`>,1
+DALEX,model_info,1,0,0,...,1
+DALEX,model_info.glm,-1,0,0,class<`model_info`>,1
+DALEX,model_info.glm,0,0,0,"class<`glm`, `lm`>",1
+DALEX,model_info.glm,1,0,0,...,1
+DALEX,model_info.lm,-1,0,0,class<`model_info`>,1
+DALEX,model_info.lm,0,0,0,class<`lm`>,1
+DALEX,model_info.lm,1,0,0,...,1
+DALEX,model_info.ranger,-1,0,0,class<`model_info`>,1
+DALEX,model_info.ranger,0,0,0,class<`ranger`>,1
+DALEX,model_info.ranger,1,0,0,...,1
+DALEX,model_profile,-1,0,0,class<`model_profile`>,1
+DALEX,model_profile,0,0,0,class<`explainer`>,1
+DALEX,model_profile,1,0,0,character,1
+DALEX,model_profile,2,0,0,double,1
+DALEX,model_profile,3,0,0,...,1
+DALEX,model_profile,4,0,0,null,1
+DALEX,model_profile,5,0,0,null,1
+DALEX,model_profile,6,0,0,logical,1
+DALEX,model_profile,7,0,0,character,1
+DALEX,plot.model_diagnostics,-1,0,0,"class<`gg`, `ggplot`>",1
+DALEX,plot.model_diagnostics,0,0,0,"class<`data.frame`, `model_diagnostics`>",1
+DALEX,plot.model_diagnostics,1,0,0,...,1
+DALEX,plot.model_diagnostics,2,0,0,character,1
+DALEX,plot.model_diagnostics,3,0,0,character,1
+DALEX,plot.model_diagnostics,4,0,0,logical,1
+DALEX,plot.model_profile,-1,0,0,"class<`gg`, `ggplot`>",1
+DALEX,plot.model_profile,0,0,0,class<`model_profile`>,1
+DALEX,plot.model_profile,1,0,0,...,1
+DALEX,plot.model_profile,2,0,0,character,1
+DALEX,plot.model_profile_aggregates,-1,0,0,"class<`gg`, `ggplot`>",1
+DALEX,plot.model_profile_aggregates,0,0,0,class<`model_profile`>,1
+DALEX,plot.model_profile_aggregates,1,0,0,...,1
+DALEX,plot.predict_profile,-1,0,0,"class<`gg`, `ggplot`>",1
+DALEX,plot.predict_profile,0,0,0,"class<`ceteris_paribus_explainer`, `data.frame`, `predict_profile`>",1
+DALEX,plot.predict_profile,1,0,0,...,1
+DALEX,predict.explainer,-1,0,0,double[],1
+DALEX,predict.explainer,0,0,0,class<`explainer`>,1
+DALEX,predict.explainer,1,0,0,class<`data.frame`>,1
+DALEX,predict.explainer,2,0,0,...,1
+DALEX,predict_parts_break_down,-1,0,0,"class<`break_down`, `data.frame`>",1
+DALEX,predict_parts_break_down,0,0,0,class<`explainer`>,1
+DALEX,predict_parts_break_down,1,0,0,class<`data.frame`>,1
+DALEX,predict_parts_break_down,2,0,0,...,1
+DALEX,predict_profile,-1,0,0,"class<`ceteris_paribus_explainer`, `data.frame`, `predict_profile`>",1
+DALEX,predict_profile,0,0,0,class<`explainer`>,1
+DALEX,predict_profile,1,0,0,class<`data.frame`>,1
+DALEX,predict_profile,2,0,0,character[],1
+DALEX,predict_profile,3,0,0,...,1
+DALEX,predict_profile,4,0,0,character,1
+DALEX,quick.installed.packages,-1,0,0,character[],1
+DALEX,test_explainer,-1,0,0,logical,1
+DALEX,test_explainer,0,0,0,class<`explainer`>,1
+DALEX,test_explainer,1,0,0,logical,1
+DALEX,test_explainer,2,0,0,logical,1
+DALEX,test_explainer,3,0,0,character,1
+DALEX,theme_drwhy,-1,0,0,"class<`gg`, `theme`>",1
+DALEX,theme_drwhy_vertical,-1,0,0,"class<`gg`, `theme`>",1
+DALEX,update_data,-1,0,0,class<`explainer`>,1
+DALEX,update_data,0,0,0,class<`explainer`>,1
+DALEX,update_data,1,0,0,class<`data.frame`>,1
+DALEX,update_data,2,0,0,double[],1
+DALEX,update_data,3,0,0,logical,1
+DALEX,update_label,-1,0,0,class<`explainer`>,1
+DALEX,update_label,0,0,0,class<`explainer`>,1
+DALEX,update_label,1,0,0,character,1
+DALEX,update_label,2,0,0,logical,1
+DALEX,variable_effect,-1,0,0,"class<`aggregated_profiles_explainer`, `data.frame`, `partial_dependence_explainer`>",1
+DALEX,variable_effect,0,0,0,class<`explainer`>,1
+DALEX,variable_effect,1,0,0,character,1
+DALEX,variable_effect,2,0,0,...,1
+DALEX,variable_effect,3,0,0,character,1
+DALEX,variable_effect_partial_dependency,-1,0,0,"class<`aggregated_profiles_explainer`, `data.frame`, `partial_dependence_explainer`>",1
+DALEX,variable_effect_partial_dependency,0,0,0,class<`explainer`>,1
+DALEX,variable_effect_partial_dependency,1,0,0,character,1
+DALEX,variable_effect_partial_dependency,2,0,0,...,1
+DALEX,verbose_cat,-1,0,0,null,1
+DALEX,verbose_cat,0,0,0,...,1
+DALEX,verbose_cat,1,0,0,logical,1
+DALEX,yhat.glm,-1,0,0,double[],1
+DALEX,yhat.glm,0,0,0,"class<`glm`, `lm`>",1
+DALEX,yhat.glm,1,0,0,class<`data.frame`>,1
+DALEX,yhat.glm,2,0,0,...,1
+DALEX,yhat.lm,-1,0,0,double[],1
+DALEX,yhat.lm,0,0,0,class<`lm`>,1
+DALEX,yhat.lm,1,0,0,class<`data.frame`>,1
+DALEX,yhat.lm,2,0,0,...,1
+DALEX,yhat.ranger,-1,0,0,double[],1
+DALEX,yhat.ranger,0,0,0,class<`ranger`>,1
+DALEX,yhat.ranger,1,0,0,class<`data.frame`>,1
+DALEX,yhat.ranger,2,0,0,...,1
+DBI,ANSI,-1,0,0,class<`AnsiConnection`>,1
+DBI,check_raw_list,-1,0,0,null,1
+DBI,check_raw_list,0,0,0,list<raw[]>,1
+DBI,dbAppendTable,-1,0,0,integer,1
+DBI,dbAppendTable,0,0,0,class<`SQLiteConnection`>,1
+DBI,dbAppendTable,1,0,0,character,1
+DBI,dbAppendTable,2,0,0,class<`data.frame`>,1
+DBI,dbAppendTable,3,0,0,...,1
+DBI,dbAppendTable,4,0,0,null,1
+DBI,dbAppendTable,-1,1,0,integer,1
+DBI,dbAppendTable,0,1,0,class<`SQLiteConnection`>,1
+DBI,dbAppendTable,1,1,0,character,1
+DBI,dbAppendTable,2,1,0,class<`data.frame`>,1
+DBI,dbAppendTable,3,1,0,...,1
+DBI,dbAppendTable,4,1,0,null,1
+DBI,dbBegin,-1,0,0,logical,1
+DBI,dbBegin,0,0,0,class<`SQLiteConnection`>,1
+DBI,dbBegin,1,0,0,...,1
+DBI,dbBind,-1,0,0,class<`SQLiteResult`>,1
+DBI,dbBind,0,0,0,class<`SQLiteResult`>,1
+DBI,dbBind,1,0,0,list<double[] | character[]>,1
+DBI,dbBind,1,0,1,list<double[] | class<`factor`>>,1
+DBI,dbBind,1,0,2,list<double[]>,1
+DBI,dbBind,1,0,3,list<character[]>,1
+DBI,dbBind,2,0,0,...,1
+DBI,dbBreak,-1,0,0,any,1
+DBI,dbCanConnect,-1,0,0,logical,1
+DBI,dbCanConnect,0,0,0,class<`SQLiteDriver`>,1
+DBI,dbCanConnect,1,0,0,...,1
+DBI,dbCanConnect,-1,1,0,logical,1
+DBI,dbCanConnect,0,1,0,class<`SQLiteDriver`>,1
+DBI,dbCanConnect,1,1,0,...,1
+DBI,dbClearResult,-1,0,0,logical,1
+DBI,dbClearResult,0,0,0,class<`SQLiteResult`>,1
+DBI,dbClearResult,1,0,0,...,1
+DBI,dbColumnInfo,-1,0,0,class<`data.frame`>,1
+DBI,dbColumnInfo,0,0,0,class<`SQLiteResult`>,1
+DBI,dbColumnInfo,1,0,0,...,1
+DBI,dbCommit,-1,0,0,logical,1
+DBI,dbCommit,0,0,0,class<`SQLiteConnection`>,1
+DBI,dbCommit,1,0,0,...,1
+DBI,dbConnect,-1,0,0,class<`SQLiteConnection`>,1
+DBI,dbConnect,0,0,0,class<`DBIConnector`>,1
+DBI,dbConnect,1,0,0,...,1
+DBI,dbConnect,-1,1,0,class<`SQLiteConnection`>,1
+DBI,dbConnect,0,1,0,class<`DBIConnector`>,1
+DBI,dbConnect,0,1,1,class<`SQLiteDriver`>,1
+DBI,dbConnect,1,1,0,...,1
+DBI,dbCreateTable,-1,0,0,logical,1
+DBI,dbCreateTable,0,0,0,class<`SQLiteConnection`>,1
+DBI,dbCreateTable,1,0,0,character,1
+DBI,dbCreateTable,2,0,0,character[],1
+DBI,dbCreateTable,2,0,1,class<`data.frame`>,1
+DBI,dbCreateTable,3,0,0,...,1
+DBI,dbCreateTable,4,0,0,null,1
+DBI,dbCreateTable,5,0,0,logical,1
+DBI,dbCreateTable,-1,1,0,logical,1
+DBI,dbCreateTable,0,1,0,class<`SQLiteConnection`>,1
+DBI,dbCreateTable,1,1,0,character,1
+DBI,dbCreateTable,2,1,0,character[],1
+DBI,dbCreateTable,2,1,1,class<`data.frame`>,1
+DBI,dbCreateTable,3,1,0,...,1
+DBI,dbCreateTable,4,1,0,null,1
+DBI,dbCreateTable,5,1,0,logical,1
+DBI,dbDataType,-1,0,0,character[],1
+DBI,dbDataType,0,0,0,class<`SQLiteConnection`>,1
+DBI,dbDataType,0,0,1,class<`AnsiConnection`>,1
+DBI,dbDataType,0,0,2,class<`SQLiteDriver`>,1
+DBI,dbDataType,1,0,0,class<`factor`>,1
+DBI,dbDataType,1,0,1,double[],1
+DBI,dbDataType,1,0,2,character[],1
+DBI,dbDataType,1,0,3,class<`AsIs`>,1
+DBI,dbDataType,1,0,4,class<`Date`>,1
+DBI,dbDataType,1,0,5,class<`difftime`>,1
+DBI,dbDataType,1,0,6,"class<`POSIXct`, `POSIXt`>",1
+DBI,dbDataType,1,0,7,list<raw[]>,1
+DBI,dbDataType,1,0,8,class<`data.frame`>,1
+DBI,dbDataType,2,0,0,...,1
+DBI,dbDataType,-1,1,0,character[],1
+DBI,dbDataType,0,1,0,class<`AnsiConnection`>,1
+DBI,dbDataType,1,1,0,character[],1
+DBI,dbDataType,1,1,1,class<`AsIs`>,1
+DBI,dbDataType,1,1,2,class<`Date`>,1
+DBI,dbDataType,1,1,3,class<`difftime`>,1
+DBI,dbDataType,1,1,4,"class<`POSIXct`, `POSIXt`>",1
+DBI,dbDataType,1,1,5,double,1
+DBI,dbDataType,1,1,6,integer[],1
+DBI,dbDataType,1,1,7,list<raw[]>,1
+DBI,dbDataType,1,1,8,class<`data.frame`>,1
+DBI,dbDataType,2,1,0,...,1
+DBI,dbDisconnect,-1,0,0,logical,1
+DBI,dbDisconnect,0,0,0,class<`SQLiteConnection`>,1
+DBI,dbDisconnect,1,0,0,...,1
+DBI,dbDriver,-1,0,0,any,1
+DBI,dbDriver,0,0,0,character,1
+DBI,dbDriver,1,0,0,...,1
+DBI,dbDriver,-1,1,0,any,1
+DBI,dbDriver,0,1,0,character,1
+DBI,dbDriver,1,1,0,...,1
+DBI,dbExecute,-1,0,0,integer,1
+DBI,dbExecute,0,0,0,class<`SQLiteConnection`>,1
+DBI,dbExecute,1,0,0,class<`SQL`>,1
+DBI,dbExecute,2,0,0,...,1
+DBI,dbExecute,-1,1,0,integer,1
+DBI,dbExecute,0,1,0,class<`SQLiteConnection`>,1
+DBI,dbExecute,1,1,0,character,1
+DBI,dbExecute,1,1,1,class<`SQL`>,1
+DBI,dbExecute,2,1,0,...,1
+DBI,dbExecute,-1,2,0,integer,1
+DBI,dbExecute,0,2,0,class<`SQLiteConnection`>,1
+DBI,dbExecute,1,2,0,character,1
+DBI,dbExecute,2,2,0,...,1
+DBI,dbExistsTable,-1,0,0,logical,1
+DBI,dbExistsTable,0,0,0,class<`SQLiteConnection`>,1
+DBI,dbExistsTable,1,0,0,character,1
+DBI,dbExistsTable,2,0,0,...,1
+DBI,dbFetch,-1,0,0,class<`data.frame`>,1
+DBI,dbFetch,0,0,0,class<`SQLiteResult`>,1
+DBI,dbFetch,1,0,0,double,1
+DBI,dbFetch,2,0,0,...,1
+DBI,dbGetConnectArgs,-1,0,0,list<character>,1
+DBI,dbGetConnectArgs,-1,0,1,list<character | class<`function`>>,1
+DBI,dbGetConnectArgs,0,0,0,class<`DBIConnector`>,1
+DBI,dbGetConnectArgs,1,0,0,logical,1
+DBI,dbGetConnectArgs,2,0,0,...,1
+DBI,dbGetConnectArgs,-1,1,0,list<character>,1
+DBI,dbGetConnectArgs,-1,1,1,list<character | class<`function`>>,1
+DBI,dbGetConnectArgs,0,1,0,class<`DBIConnector`>,1
+DBI,dbGetConnectArgs,1,1,0,logical,1
+DBI,dbGetConnectArgs,2,1,0,...,1
+DBI,dbGetQuery,-1,0,0,class<`data.frame`>,1
+DBI,dbGetQuery,0,0,0,class<`SQLiteConnection`>,1
+DBI,dbGetQuery,1,0,0,character,1
+DBI,dbGetQuery,2,0,0,...,1
+DBI,dbGetQuery,-1,1,0,class<`data.frame`>,1
+DBI,dbGetQuery,0,1,0,class<`SQLiteConnection`>,1
+DBI,dbGetQuery,1,1,0,class<`SQL`>,1
+DBI,dbGetQuery,2,1,0,...,1
+DBI,dbGetQuery,-1,2,0,class<`data.frame`>,1
+DBI,dbGetQuery,0,2,0,class<`SQLiteConnection`>,1
+DBI,dbGetQuery,1,2,0,character,1
+DBI,dbGetQuery,1,2,1,class<`SQL`>,1
+DBI,dbGetQuery,2,2,0,...,1
+DBI,dbGetRowCount,-1,0,0,integer,1
+DBI,dbGetRowCount,0,0,0,class<`SQLiteResult`>,1
+DBI,dbGetRowCount,1,0,0,...,1
+DBI,dbGetRowsAffected,-1,0,0,integer,1
+DBI,dbGetRowsAffected,0,0,0,class<`SQLiteResult`>,1
+DBI,dbGetRowsAffected,1,0,0,...,1
+DBI,dbGetStatement,-1,0,0,character,1
+DBI,dbGetStatement,0,0,0,class<`SQLiteResult`>,1
+DBI,dbGetStatement,1,0,0,...,1
+DBI,dbHasCompleted,-1,0,0,logical,1
+DBI,dbHasCompleted,0,0,0,class<`SQLiteResult`>,1
+DBI,dbHasCompleted,1,0,0,...,1
+DBI,dbiDataType,-1,0,0,character,1
+DBI,dbiDataType,0,0,0,double[],1
+DBI,dbiDataType,1,0,0,...,1
+DBI,dbiDataType,-1,1,0,character[],1
+DBI,dbiDataType,0,1,0,class<`data.frame`>,1
+DBI,dbiDataType,1,1,0,...,1
+DBI,dbiDataType,-1,2,0,character,1
+DBI,dbiDataType,0,2,0,logical,1
+DBI,dbiDataType,1,2,0,...,1
+DBI,dbiDataType,-1,3,0,character,1
+DBI,dbiDataType,0,3,0,class<`Date`>,1
+DBI,dbiDataType,1,3,0,...,1
+DBI,dbiDataType,-1,4,0,character,1
+DBI,dbiDataType,0,4,0,"class<`POSIXct`, `POSIXt`>",1
+DBI,dbiDataType,1,4,0,...,1
+DBI,dbiDataType,-1,5,0,character,1
+DBI,dbiDataType,0,5,0,list<raw[]>,1
+DBI,dbiDataType,1,5,0,...,1
+DBI,dbiDataType,-1,6,0,character,1
+DBI,dbiDataType,0,6,0,character[],1
+DBI,dbiDataType,1,6,0,...,1
+DBI,dbiDataType,-1,7,0,character,1
+DBI,dbiDataType,0,7,0,integer[],1
+DBI,dbiDataType,1,7,0,...,1
+DBI,dbiDataType,-1,8,0,character[],1
+DBI,dbiDataType,0,8,0,character[],1
+DBI,dbiDataType,0,8,1,class<`AsIs`>,1
+DBI,dbiDataType,0,8,2,class<`Date`>,1
+DBI,dbiDataType,0,8,3,class<`difftime`>,1
+DBI,dbiDataType,0,8,4,class<`factor`>,1
+DBI,dbiDataType,0,8,5,"class<`POSIXct`, `POSIXt`>",1
+DBI,dbiDataType,0,8,6,double[],1
+DBI,dbiDataType,0,8,7,list<raw[]>,1
+DBI,dbiDataType,0,8,8,class<`data.frame`>,1
+DBI,dbiDataType,1,8,0,...,1
+DBI,dbiDataType,-1,9,0,character,1
+DBI,dbiDataType,0,9,0,class<`AsIs`>,1
+DBI,dbiDataType,1,9,0,...,1
+DBI,dbiDataType,-1,10,0,character,1
+DBI,dbiDataType,0,10,0,class<`difftime`>,1
+DBI,dbiDataType,1,10,0,...,1
+DBI,dbiDataType,-1,11,0,character,1
+DBI,dbiDataType,0,11,0,class<`factor`>,1
+DBI,dbiDataType,1,11,0,...,1
+DBI,dbIsReadOnly,-1,0,0,logical,1
+DBI,dbIsReadOnly,0,0,0,class<`AnsiConnection`>,1
+DBI,dbIsReadOnly,1,0,0,...,1
+DBI,dbIsReadOnly,-1,1,0,logical,1
+DBI,dbIsReadOnly,0,1,0,class<`AnsiConnection`>,1
+DBI,dbIsReadOnly,1,1,0,...,1
+DBI,dbIsValid,-1,0,0,logical,1
+DBI,dbIsValid,0,0,0,class<`SQLiteConnection`>,1
+DBI,dbIsValid,0,0,1,class<`SQLiteDriver`>,1
+DBI,dbIsValid,0,0,2,class<`SQLiteResult`>,1
+DBI,dbIsValid,1,0,0,...,1
+DBI,dbListFields,-1,0,0,character[],1
+DBI,dbListFields,0,0,0,class<`SQLiteConnection`>,1
+DBI,dbListFields,1,0,0,character,1
+DBI,dbListFields,2,0,0,...,1
+DBI,dbListFields,-1,1,0,character[],1
+DBI,dbListFields,0,1,0,class<`SQLiteConnection`>,1
+DBI,dbListFields,1,1,0,character,1
+DBI,dbListFields,2,1,0,...,1
+DBI,dbListObjects,-1,0,0,class<`data.frame`>,1
+DBI,dbListObjects,0,0,0,class<`SQLiteConnection`>,1
+DBI,dbListObjects,1,0,0,null,1
+DBI,dbListObjects,2,0,0,...,1
+DBI,dbListObjects,-1,1,0,class<`data.frame`>,1
+DBI,dbListObjects,0,1,0,class<`SQLiteConnection`>,1
+DBI,dbListObjects,1,1,0,null,1
+DBI,dbListObjects,2,1,0,...,1
+DBI,dbListTables,-1,0,0,character[],1
+DBI,dbListTables,0,0,0,class<`SQLiteConnection`>,1
+DBI,dbListTables,1,0,0,...,1
+DBI,dbQuoteIdentifier,-1,0,0,class<`SQL`>,1
+DBI,dbQuoteIdentifier,0,0,0,class<`AnsiConnection`>,1
+DBI,dbQuoteIdentifier,1,0,0,class<`Id`>,1
+DBI,dbQuoteIdentifier,2,0,0,...,1
+DBI,dbQuoteIdentifier,-1,1,0,class<`SQL`>,1
+DBI,dbQuoteIdentifier,0,1,0,class<`AnsiConnection`>,1
+DBI,dbQuoteIdentifier,1,1,0,character[],1
+DBI,dbQuoteIdentifier,2,1,0,...,1
+DBI,dbQuoteIdentifier,-1,2,0,class<`SQL`>,1
+DBI,dbQuoteIdentifier,0,2,0,class<`AnsiConnection`>,1
+DBI,dbQuoteIdentifier,0,2,1,class<`SQLiteConnection`>,1
+DBI,dbQuoteIdentifier,1,2,0,character[],1
+DBI,dbQuoteIdentifier,1,2,1,class<`Id`>,1
+DBI,dbQuoteIdentifier,1,2,2,class<`SQL`>,1
+DBI,dbQuoteIdentifier,2,2,0,...,1
+DBI,dbQuoteIdentifier,-1,3,0,class<`SQL`>,1
+DBI,dbQuoteIdentifier,0,3,0,class<`AnsiConnection`>,1
+DBI,dbQuoteIdentifier,1,3,0,class<`SQL`>,1
+DBI,dbQuoteIdentifier,2,3,0,...,1
+DBI,dbQuoteLiteral,-1,0,0,class<`SQL`>,1
+DBI,dbQuoteLiteral,0,0,0,class<`AnsiConnection`>,1
+DBI,dbQuoteLiteral,0,0,1,class<`SQLiteConnection`>,1
+DBI,dbQuoteLiteral,1,0,0,character,1
+DBI,dbQuoteLiteral,1,0,1,class<`SQL`>,1
+DBI,dbQuoteLiteral,1,0,2,^integer[],1
+DBI,dbQuoteLiteral,1,0,3,list<raw[] | null>,1
+DBI,dbQuoteLiteral,1,0,4,double,1
+DBI,dbQuoteLiteral,2,0,0,...,1
+DBI,dbQuoteLiteral,-1,1,0,class<`SQL`>,1
+DBI,dbQuoteLiteral,0,1,0,class<`AnsiConnection`>,1
+DBI,dbQuoteLiteral,1,1,0,character,1
+DBI,dbQuoteLiteral,1,1,1,class<`SQL`>,1
+DBI,dbQuoteLiteral,1,1,2,^integer[],1
+DBI,dbQuoteLiteral,1,1,3,list<raw[] | null>,1
+DBI,dbQuoteLiteral,2,1,0,...,1
+DBI,dbQuoteLiteral,-1,2,0,class<`SQL`>,1
+DBI,dbQuoteLiteral,0,2,0,class<`SQLiteConnection`>,1
+DBI,dbQuoteLiteral,1,2,0,double,1
+DBI,dbQuoteLiteral,2,2,0,...,1
+DBI,dbQuoteString,-1,0,0,class<`SQL`>,1
+DBI,dbQuoteString,0,0,0,class<`AnsiConnection`>,1
+DBI,dbQuoteString,0,0,1,class<`SQLiteConnection`>,1
+DBI,dbQuoteString,1,0,0,^character[],1
+DBI,dbQuoteString,1,0,1,class<`SQL`>,1
+DBI,dbQuoteString,2,0,0,...,1
+DBI,dbQuoteString,-1,1,0,class<`SQL`>,1
+DBI,dbQuoteString,0,1,0,class<`AnsiConnection`>,1
+DBI,dbQuoteString,1,1,0,class<`SQL`>,1
+DBI,dbQuoteString,2,1,0,...,1
+DBI,dbQuoteString,-1,2,0,class<`SQL`>,1
+DBI,dbQuoteString,0,2,0,class<`SQLiteConnection`>,1
+DBI,dbQuoteString,1,2,0,class<`SQL`>,1
+DBI,dbQuoteString,2,2,0,...,1
+DBI,dbQuoteString,-1,3,0,class<`SQL`>,1
+DBI,dbQuoteString,0,3,0,class<`AnsiConnection`>,1
+DBI,dbQuoteString,1,3,0,^character[],1
+DBI,dbQuoteString,2,3,0,...,1
+DBI,dbReadTable,-1,0,0,class<`data.frame`>,1
+DBI,dbReadTable,0,0,0,class<`SQLiteConnection`>,1
+DBI,dbReadTable,1,0,0,character,1
+DBI,dbReadTable,2,0,0,...,1
+DBI,dbRemoveTable,-1,0,0,logical,1
+DBI,dbRemoveTable,0,0,0,class<`SQLiteConnection`>,1
+DBI,dbRemoveTable,1,0,0,character,1
+DBI,dbRemoveTable,2,0,0,...,1
+DBI,dbRollback,-1,0,0,logical,1
+DBI,dbRollback,0,0,0,class<`SQLiteConnection`>,1
+DBI,dbRollback,1,0,0,...,1
+DBI,dbSendQuery,-1,0,0,class<`SQLiteResult`>,1
+DBI,dbSendQuery,0,0,0,class<`SQLiteConnection`>,1
+DBI,dbSendQuery,1,0,0,character,1
+DBI,dbSendQuery,1,0,1,class<`SQL`>,1
+DBI,dbSendQuery,2,0,0,...,1
+DBI,dbSendStatement,-1,0,0,class<`SQLiteResult`>,1
+DBI,dbSendStatement,0,0,0,class<`SQLiteConnection`>,1
+DBI,dbSendStatement,1,0,0,class<`SQL`>,1
+DBI,dbSendStatement,2,0,0,...,1
+DBI,dbSendStatement,-1,1,0,class<`SQLiteResult`>,1
+DBI,dbSendStatement,0,1,0,class<`SQLiteConnection`>,1
+DBI,dbSendStatement,1,1,0,character,1
+DBI,dbSendStatement,2,1,0,...,1
+DBI,dbSendStatement,-1,2,0,class<`SQLiteResult`>,1
+DBI,dbSendStatement,0,2,0,class<`SQLiteConnection`>,1
+DBI,dbSendStatement,1,2,0,character,1
+DBI,dbSendStatement,1,2,1,class<`SQL`>,1
+DBI,dbSendStatement,2,2,0,...,1
+DBI,dbUnquoteIdentifier,-1,0,0,list<class<`Id`>>,1
+DBI,dbUnquoteIdentifier,0,0,0,class<`AnsiConnection`>,1
+DBI,dbUnquoteIdentifier,0,0,1,class<`SQLiteConnection`>,1
+DBI,dbUnquoteIdentifier,1,0,0,class<`SQL`>,1
+DBI,dbUnquoteIdentifier,1,0,1,class<`Id`>,1
+DBI,dbUnquoteIdentifier,2,0,0,...,1
+DBI,dbUnquoteIdentifier,-1,1,0,list<class<`Id`>>,1
+DBI,dbUnquoteIdentifier,0,1,0,class<`AnsiConnection`>,1
+DBI,dbUnquoteIdentifier,1,1,0,class<`SQL`>,1
+DBI,dbUnquoteIdentifier,1,1,1,class<`Id`>,1
+DBI,dbUnquoteIdentifier,2,1,0,...,1
+DBI,dbWithTransaction,-1,0,0,integer,1
+DBI,dbWithTransaction,-1,0,1,null,1
+DBI,dbWithTransaction,0,0,0,class<`SQLiteConnection`>,1
+DBI,dbWithTransaction,1,0,0,any,1
+DBI,dbWithTransaction,2,0,0,...,1
+DBI,dbWithTransaction,-1,1,0,integer,1
+DBI,dbWithTransaction,-1,1,1,null,1
+DBI,dbWithTransaction,0,1,0,class<`SQLiteConnection`>,1
+DBI,dbWithTransaction,1,1,0,any,1
+DBI,dbWithTransaction,2,1,0,...,1
+DBI,dbWriteTable,-1,0,0,logical,1
+DBI,dbWriteTable,0,0,0,class<`SQLiteConnection`>,1
+DBI,dbWriteTable,1,0,0,character,1
+DBI,dbWriteTable,2,0,0,class<`data.frame`>,1
+DBI,dbWriteTable,3,0,0,...,1
+DBI,findDriver,-1,0,0,any,1
+DBI,findDriver,0,0,0,character,1
+DBI,get2,-1,0,0,null,1
+DBI,get2,0,0,0,character,1
+DBI,get2,1,0,0,environment,1
+DBI,guessColName,-1,0,0,null,1
+DBI,guessColName,0,0,0,any,1
+DBI,guessColName,1,0,0,logical,1
+DBI,guessRowName,-1,0,0,character,1
+DBI,guessRowName,-1,0,1,null,1
+DBI,guessRowName,0,0,0,any,1
+DBI,guessRowName,1,0,0,character,1
+DBI,guessRowName,1,0,1,logical,1
+DBI,guessRowName,1,0,2,null,1
+DBI,Id,-1,0,0,class<`Id`>,1
+DBI,Id,0,0,0,...,1
+DBI,is_attached,-1,0,0,logical,1
+DBI,is_attached,0,0,0,character,1
+DBI,list_fields,-1,0,0,character[],1
+DBI,list_fields,0,0,0,class<`SQLiteConnection`>,1
+DBI,list_fields,1,0,0,character,1
+DBI,names2,-1,0,0,character[],1
+DBI,names2,0,0,0,list<any>,1
+DBI,SQL,-1,0,0,class<`SQL`>,1
+DBI,SQL,0,0,0,character[],1
+DBI,SQL,1,0,0,...,1
+DBI,SQL,2,0,0,null,1
+DBI,SQL,2,0,1,character[],1
+DBI,[[.SQL,-1,0,0,class<`SQL`>,1
+DBI,[[.SQL,0,0,0,class<`SQL`>,1
+DBI,[[.SQL,1,0,0,...,1
+DBI,sqlAppendTable,-1,0,0,class<`SQL`>,1
+DBI,sqlAppendTable,0,0,0,class<`AnsiConnection`>,1
+DBI,sqlAppendTable,0,0,1,class<`SQLiteConnection`>,1
+DBI,sqlAppendTable,1,0,0,character,1
+DBI,sqlAppendTable,1,0,1,class<`SQL`>,1
+DBI,sqlAppendTable,2,0,0,class<`data.frame`>,1
+DBI,sqlAppendTable,2,0,1,list<class<`SQL`>>,1
+DBI,sqlAppendTable,3,0,0,logical,1
+DBI,sqlAppendTable,3,0,1,null,1
+DBI,sqlAppendTable,4,0,0,...,1
+DBI,sqlAppendTable,-1,1,0,class<`SQL`>,1
+DBI,sqlAppendTable,0,1,0,class<`SQLiteConnection`>,1
+DBI,sqlAppendTable,1,1,0,class<`SQL`>,1
+DBI,sqlAppendTable,2,1,0,list<class<`SQL`>>,1
+DBI,sqlAppendTable,3,1,0,null,1
+DBI,sqlAppendTable,4,1,0,...,1
+DBI,sqlAppendTable,-1,2,0,class<`SQL`>,1
+DBI,sqlAppendTable,0,2,0,class<`AnsiConnection`>,1
+DBI,sqlAppendTable,1,2,0,character,1
+DBI,sqlAppendTable,1,2,1,class<`SQL`>,1
+DBI,sqlAppendTable,2,2,0,class<`data.frame`>,1
+DBI,sqlAppendTable,2,2,1,list<class<`SQL`>>,1
+DBI,sqlAppendTable,3,2,0,logical,1
+DBI,sqlAppendTable,3,2,1,null,1
+DBI,sqlAppendTable,4,2,0,...,1
+DBI,sqlAppendTableTemplate,-1,0,0,class<`SQL`>,1
+DBI,sqlAppendTableTemplate,0,0,0,class<`AnsiConnection`>,1
+DBI,sqlAppendTableTemplate,0,0,1,class<`SQLiteConnection`>,1
+DBI,sqlAppendTableTemplate,1,0,0,character,1
+DBI,sqlAppendTableTemplate,2,0,0,class<`data.frame`>,1
+DBI,sqlAppendTableTemplate,3,0,0,null,1
+DBI,sqlAppendTableTemplate,3,0,1,logical,1
+DBI,sqlAppendTableTemplate,4,0,0,character,1
+DBI,sqlAppendTableTemplate,5,0,0,...,1
+DBI,sqlAppendTableTemplate,6,0,0,character,1
+DBI,sqlColumnToRownames,-1,0,0,class<`data.frame`>,1
+DBI,sqlColumnToRownames,0,0,0,class<`data.frame`>,1
+DBI,sqlColumnToRownames,1,0,0,logical,1
+DBI,sqlCommentSpec,-1,0,0,list<character | logical>,1
+DBI,sqlCommentSpec,0,0,0,character,1
+DBI,sqlCommentSpec,1,0,0,character,1
+DBI,sqlCommentSpec,2,0,0,logical,1
+DBI,sqlCreateTable,-1,0,0,class<`SQL`>,1
+DBI,sqlCreateTable,0,0,0,class<`SQLiteConnection`>,1
+DBI,sqlCreateTable,1,0,0,character,1
+DBI,sqlCreateTable,2,0,0,character[],1
+DBI,sqlCreateTable,2,0,1,class<`data.frame`>,1
+DBI,sqlCreateTable,3,0,0,any,1
+DBI,sqlCreateTable,4,0,0,logical,1
+DBI,sqlCreateTable,5,0,0,...,1
+DBI,sqlCreateTable,-1,1,0,class<`SQL`>,1
+DBI,sqlCreateTable,0,1,0,class<`AnsiConnection`>,1
+DBI,sqlCreateTable,0,1,1,class<`SQLiteConnection`>,1
+DBI,sqlCreateTable,1,1,0,character,1
+DBI,sqlCreateTable,2,1,0,character[],1
+DBI,sqlCreateTable,2,1,1,class<`data.frame`>,1
+DBI,sqlCreateTable,3,1,0,any,1
+DBI,sqlCreateTable,4,1,0,logical,1
+DBI,sqlCreateTable,5,1,0,...,1
+DBI,sqlCreateTable,-1,2,0,class<`SQL`>,1
+DBI,sqlCreateTable,0,2,0,class<`AnsiConnection`>,1
+DBI,sqlCreateTable,1,2,0,character,1
+DBI,sqlCreateTable,2,2,0,character[],1
+DBI,sqlCreateTable,2,2,1,class<`data.frame`>,1
+DBI,sqlCreateTable,3,2,0,null,1
+DBI,sqlCreateTable,3,2,1,logical,1
+DBI,sqlCreateTable,4,2,0,logical,1
+DBI,sqlCreateTable,5,2,0,...,1
+DBI,sqlData,-1,0,0,class<`data.frame`>,1
+DBI,sqlData,-1,0,1,list<character>,1
+DBI,sqlData,0,0,0,class<`AnsiConnection`>,1
+DBI,sqlData,1,0,0,class<`data.frame`>,1
+DBI,sqlData,1,0,1,list<class<`SQL`>>,1
+DBI,sqlData,2,0,0,logical,1
+DBI,sqlData,2,0,1,null,1
+DBI,sqlData,3,0,0,...,1
+DBI,sqlData,-1,1,0,class<`data.frame`>,1
+DBI,sqlData,-1,1,1,list<class<`SQL`>>,1
+DBI,sqlData,-1,1,2,list<character>,1
+DBI,sqlData,0,1,0,class<`AnsiConnection`>,1
+DBI,sqlData,0,1,1,class<`SQLiteConnection`>,1
+DBI,sqlData,1,1,0,class<`data.frame`>,1
+DBI,sqlData,1,1,1,list<class<`SQL`>>,1
+DBI,sqlData,2,1,0,logical,1
+DBI,sqlData,2,1,1,null,1
+DBI,sqlData,3,1,0,...,1
+DBI,sqlInterpolate,-1,0,0,class<`SQL`>,1
+DBI,sqlInterpolate,0,0,0,class<`SQLiteConnection`>,1
+DBI,sqlInterpolate,1,0,0,character,1
+DBI,sqlInterpolate,2,0,0,...,1
+DBI,sqlInterpolate,3,0,0,list<any>,1
+DBI,sqlInterpolate,-1,1,0,class<`SQL`>,1
+DBI,sqlInterpolate,0,1,0,class<`AnsiConnection`>,1
+DBI,sqlInterpolate,0,1,1,class<`SQLiteConnection`>,1
+DBI,sqlInterpolate,1,1,0,character,1
+DBI,sqlInterpolate,2,1,0,...,1
+DBI,sqlInterpolate,3,1,0,list<any>,1
+DBI,sqlInterpolate,-1,2,0,class<`SQL`>,1
+DBI,sqlInterpolate,0,2,0,class<`AnsiConnection`>,1
+DBI,sqlInterpolate,1,2,0,character,1
+DBI,sqlInterpolate,2,2,0,...,1
+DBI,sqlInterpolate,3,2,0,list<any>,1
+DBI,sqlParseVariables,-1,0,0,list<integer[]>,1
+DBI,sqlParseVariables,0,0,0,class<`AnsiConnection`>,1
+DBI,sqlParseVariables,1,0,0,character,1
+DBI,sqlParseVariables,2,0,0,...,1
+DBI,sqlParseVariables,-1,1,0,list<integer>,1
+DBI,sqlParseVariables,0,1,0,class<`SQLiteConnection`>,1
+DBI,sqlParseVariables,1,1,0,character,1
+DBI,sqlParseVariables,2,1,0,...,1
+DBI,sqlParseVariables,-1,2,0,list<integer[]>,1
+DBI,sqlParseVariables,0,2,0,class<`AnsiConnection`>,1
+DBI,sqlParseVariables,0,2,1,class<`SQLiteConnection`>,1
+DBI,sqlParseVariables,1,2,0,character,1
+DBI,sqlParseVariables,2,2,0,...,1
+DBI,sqlParseVariablesImpl,-1,0,0,list<integer[]>,1
+DBI,sqlParseVariablesImpl,0,0,0,character,1
+DBI,sqlParseVariablesImpl,1,0,0,list<list<character | logical>>,1
+DBI,sqlParseVariablesImpl,2,0,0,list<any>,1
+DBI,sqlQuoteSpec,-1,0,0,list<character | logical>,1
+DBI,sqlQuoteSpec,0,0,0,character,1
+DBI,sqlQuoteSpec,1,0,0,character,1
+DBI,sqlQuoteSpec,2,0,0,character,1
+DBI,sqlQuoteSpec,3,0,0,logical,1
+DBI,sqlRownamesToColumn,-1,0,0,class<`data.frame`>,1
+DBI,sqlRownamesToColumn,-1,0,1,list<class<`SQL`>>,1
+DBI,sqlRownamesToColumn,0,0,0,class<`data.frame`>,1
+DBI,sqlRownamesToColumn,0,0,1,list<class<`SQL`>>,1
+DBI,sqlRownamesToColumn,1,0,0,logical,1
+DBI,sqlRownamesToColumn,1,0,1,null,1
+DBI,sqlRownamesToColumn,1,0,2,character,1
+DEoptim,DEoptim,-1,0,0,class<`DEoptim`>,1
+DEoptim,DEoptim,0,0,0,class<`function`>,1
+DEoptim,DEoptim,1,0,0,double[],1
+DEoptim,DEoptim,2,0,0,double[],1
+DEoptim,DEoptim,3,0,0,list<double>,1
+DEoptim,DEoptim,3,0,1,list<double | null | list<any>>,1
+DEoptim,DEoptim,4,0,0,...,1
+DEoptim,DEoptim,5,0,0,null,1
+DEoptim,DEoptim.control,-1,0,0,list<double | null | list<any>>,1
+DEoptim,DEoptim.control,0,0,0,double,1
+DEoptim,DEoptim.control,1,0,0,double,1
+DEoptim,DEoptim.control,2,0,0,logical,1
+DEoptim,DEoptim.control,3,0,0,double,1
+DEoptim,DEoptim.control,3,0,1,null,1
+DEoptim,DEoptim.control,4,0,0,double,1
+DEoptim,DEoptim.control,5,0,0,double,1
+DEoptim,DEoptim.control,6,0,0,double,1
+DEoptim,DEoptim.control,7,0,0,logical,1
+DEoptim,DEoptim.control,8,0,0,null,1
+DEoptim,DEoptim.control,9,0,0,double,1
+DEoptim,DEoptim.control,10,0,0,double,1
+DEoptim,DEoptim.control,11,0,0,double,1
+DEoptim,DEoptim.control,12,0,0,double,1
+DEoptim,DEoptim.control,13,0,0,any,1
+DEoptim,DEoptim.control,14,0,0,any,1
+DEoptim,DEoptim.control,15,0,0,double,1
+DEoptim,plot.DEoptim,-1,0,0,null,1
+DEoptim,plot.DEoptim,0,0,0,class<`DEoptim`>,1
+DEoptim,plot.DEoptim,1,0,0,character[],1
+DEoptim,plot.DEoptim,2,0,0,...,1
+DEoptim,summary.DEoptim,-1,0,0,class<`DEoptim`>,1
+DEoptim,summary.DEoptim,0,0,0,class<`DEoptim`>,1
+DEoptim,summary.DEoptim,1,0,0,...,1
+Deriv,Cache,-1,0,0,class<`call`>,1
+Deriv,Cache,0,0,0,class<`call`>,1
+Deriv,Cache,1,0,0,environment,1
+Deriv,Cache,2,0,0,character,1
+Deriv,deCache,-1,0,0,class<`call`>,1
+Deriv,deCache,-1,0,1,class<`name`>,1
+Deriv,deCache,-1,0,2,double,1
+Deriv,deCache,0,0,0,class<`call`>,1
+Deriv,deCache,0,0,1,class<`name`>,1
+Deriv,deCache,0,0,2,double,1
+Deriv,Deriv,-1,0,0,character,1
+Deriv,Deriv,0,0,0,character,1
+Deriv,Deriv,1,0,0,character[],1
+Deriv,Deriv,2,0,0,environment,1
+Deriv,Deriv,3,0,0,logical,1
+Deriv,Deriv,4,0,0,logical,1
+Deriv,Deriv,5,0,0,null,1
+Deriv,Deriv,6,0,0,character,1
+Deriv,Deriv_,-1,0,0,class<`call`>,1
+Deriv,Deriv_,-1,0,1,class<`if`>,1
+Deriv,Deriv_,-1,0,2,double,1
+Deriv,Deriv_,0,0,0,class<`call`>,1
+Deriv,Deriv_,0,0,1,class<`if`>,1
+Deriv,Deriv_,0,0,2,class<`name`>,1
+Deriv,Deriv_,0,0,3,double,1
+Deriv,Deriv_,1,0,0,character[],1
+Deriv,Deriv_,2,0,0,any,1
+Deriv,Deriv_,3,0,0,any,1
+Deriv,Deriv_,4,0,0,any,1
+Deriv,Deriv_,5,0,0,any,1
+Deriv,Deriv_,6,0,0,any,1
+Deriv,format1,-1,0,0,character,1
+Deriv,format1,0,0,0,class<`(`>,1
+Deriv,format1,0,0,1,class<`call`>,1
+Deriv,format1,0,0,2,class<`if`>,1
+Deriv,format1,0,0,3,class<`name`>,1
+Deriv,format1,0,0,4,double,1
+Deriv,is.conuloch,-1,0,0,logical,1
+Deriv,is.conuloch,0,0,0,class<`call`>,1
+Deriv,is.conuloch,0,0,1,class<`name`>,1
+Deriv,is.conuloch,0,0,2,double,1
+Deriv,is.conuloch,0,0,3,class<`if`>,1
+Deriv,is.neg.expr,-1,0,0,logical,1
+Deriv,is.neg.expr,0,0,0,double,1
+Deriv,is.numconst,-1,0,0,logical,1
+Deriv,is.numconst,0,0,0,class<`call`>,1
+Deriv,is.numconst,0,0,1,class<`name`>,1
+Deriv,is.numconst,0,0,2,double,1
+Deriv,is.numconst,1,0,0,double,1
+Deriv,is.numconst,1,0,1,null,1
+Deriv,is.subindex,-1,0,0,logical,1
+Deriv,is.subindex,0,0,0,class<`call`>,1
+Deriv,is.uminus,-1,0,0,logical,1
+Deriv,is.uminus,0,0,0,class<`call`>,1
+Deriv,is.uminus,0,0,1,class<`if`>,1
+Deriv,is.uminus,0,0,2,class<`name`>,1
+Deriv,is.uminus,0,0,3,double,1
+Deriv,is.uplus,-1,0,0,logical,1
+Deriv,is.uplus,0,0,0,class<`call`>,1
+Deriv,is.uplus,0,0,1,class<`name`>,1
+Deriv,is.uplus,0,0,2,double,1
+Deriv,lc2expr,-1,0,0,class<`call`>,1
+Deriv,lc2expr,0,0,0,list<list<logical | list<double | list<class<`call`> | double>> | logical | list<null | double | list<class<`name`> | double>>>>,1
+Deriv,lc2expr,1,0,0,environment,1
+Deriv,Leaves,-1,0,0,environment,1
+Deriv,Leaves,0,0,0,class<`call`>,1
+Deriv,Leaves,0,0,1,class<`name`>,1
+Deriv,Leaves,0,0,2,double,1
+Deriv,Leaves,1,0,0,any,1
+Deriv,Leaves,2,0,0,environment,1
+Deriv,li2sum,-1,0,0,class<`call`>,1
+Deriv,li2sum,0,0,0,list<class<`call`>>,1
+Deriv,li2sum,0,0,1,list<double>,1
+Deriv,Lincomb,-1,0,0,list<list<logical | list<double | list<class<`call`> | double>>>>,1
+Deriv,Lincomb,-1,0,1,list<list<logical | list<null | double | list<class<`name`> | double>>>>,1
+Deriv,Lincomb,0,0,0,class<`call`>,1
+Deriv,nd2expr,-1,0,0,class<`call`>,1
+Deriv,nd2expr,0,0,0,list<logical | list<double | list<class<`call`> | double>>>,1
+Deriv,nd2expr,0,0,1,list<logical | list<null | double | list<class<`name`> | double>>>,1
+Deriv,nd2expr,0,0,2,list<logical | list<null | double | list<class<`name`> | class<`call`> | double>>>,1
+Deriv,nd2expr,0,0,3,list<logical | list<double | list<class<`name`> | double>>>,1
+Deriv,nd2expr,1,0,0,any,1
+Deriv,nd2expr,2,0,0,null,1
+Deriv,nd2expr,2,0,1,logical,1
+Deriv,negate.expr,-1,0,0,double,1
+Deriv,negate.expr,0,0,0,double,1
+Deriv,Numden,-1,0,0,list<logical | list<double>>,1
+Deriv,Numden,-1,0,1,list<logical | list<double | list<class<`call`> | double>>>,1
+Deriv,Numden,-1,0,2,list<logical | list<null | double | list<class<`name`> | class<`call`> | double>>>,1
+Deriv,Numden,-1,0,3,list<logical | list<null | double | list<class<`name`> | double>>>,1
+Deriv,Numden,-1,0,4,list<logical | list<double | list<class<`name`> | double>>>,1
+Deriv,Numden,0,0,0,double,1
+Deriv,Numden,0,0,1,class<`call`>,1
+Deriv,Numden,0,0,2,class<`name`>,1
+Deriv,Simplify,-1,0,0,class<`call`>,1
+Deriv,Simplify,-1,0,1,class<`if`>,1
+Deriv,Simplify,0,0,0,class<`call`>,1
+Deriv,Simplify,0,0,1,class<`if`>,1
+Deriv,Simplify,1,0,0,any,1
+Deriv,Simplify,2,0,0,environment,1
+Deriv,Simplify_,-1,0,0,class<`call`>,1
+Deriv,Simplify_,-1,0,1,class<`name`>,1
+Deriv,Simplify_,-1,0,2,double,1
+Deriv,Simplify_,-1,0,3,class<`if`>,1
+Deriv,Simplify_,0,0,0,class<`(`>,1
+Deriv,Simplify_,0,0,1,class<`call`>,1
+Deriv,Simplify_,0,0,2,class<`name`>,1
+Deriv,Simplify_,0,0,3,double,1
+Deriv,Simplify_,0,0,4,class<`if`>,1
+Deriv,Simplify_,1,0,0,any,1
+Deriv,Simplify.*,-1,0,0,class<`call`>,1
+Deriv,Simplify.*,0,0,0,class<`call`>,1
+Deriv,Simplify.*,1,0,0,logical,1
+Deriv,Simplify.*,2,0,0,any,1
+Deriv,Simplify.+,-1,0,0,class<`call`>,1
+Deriv,Simplify.+,0,0,0,class<`call`>,1
+Deriv,Simplify.+,1,0,0,logical,1
+Deriv,Simplify.+,2,0,0,any,1
+DiceKriging,branin,-1,0,0,class<`data.frame`>,1
+DiceKriging,branin,0,0,0,class<`data.frame`>,1
+DiceKriging,checkNames,-1,0,0,class<`matrix`>,1
+DiceKriging,checkNames,0,0,0,class<`matrix`>,1
+DiceKriging,checkNames,1,0,0,class<`data.frame`>,1
+DiceKriging,checkNames,1,0,1,class<`matrix`>,1
+DiceKriging,checkNames,2,0,0,character,1
+DiceKriging,checkNames,3,0,0,character,1
+DiceKriging,checkNamesList,-1,0,0,list<double[]>,1
+DiceKriging,checkNamesList,0,0,0,class<`matrix`>,1
+DiceKriging,checkNamesList,1,0,0,list<double[]>,1
+DiceKriging,checkNamesList,2,0,0,character,1
+DiceKriging,checkNamesList,3,0,0,character,1
+DiceKriging,computeAuxVariables,-1,0,0,class<`km`>,1
+DiceKriging,computeAuxVariables,0,0,0,class<`km`>,1
+DiceKriging,compute.beta.hat,-1,0,0,double[],1
+DiceKriging,compute.beta.hat,0,0,0,class<`matrix`>,1
+DiceKriging,compute.beta.hat,1,0,0,class<`matrix`>,1
+DiceKriging,compute.sigma2.hat,-1,0,0,double,1
+DiceKriging,compute.sigma2.hat,0,0,0,double[],1
+DiceKriging,compute.z,-1,0,0,double[],1
+DiceKriging,compute.z,0,0,0,class<`matrix`>,1
+DiceKriging,compute.z,1,0,0,class<`matrix`>,1
+DiceKriging,compute.z,2,0,0,double[],1
+DiceKriging,compute.z,2,0,1,null,1
+DiceKriging,covMat1Mat2,-1,0,0,class<`matrix`>,1
+DiceKriging,covMat1Mat2,0,0,0,class<`covIso`>,1
+DiceKriging,covMat1Mat2,1,0,0,class<`matrix`>,1
+DiceKriging,covMat1Mat2,2,0,0,class<`matrix`>,1
+DiceKriging,covMat1Mat2,3,0,0,logical,1
+DiceKriging,covMat1Mat2,-1,1,0,class<`matrix`>,1
+DiceKriging,covMat1Mat2,0,1,0,class<`covIso`>,1
+DiceKriging,covMat1Mat2,0,1,1,class<`covScaling`>,1
+DiceKriging,covMat1Mat2,0,1,2,class<`covTensorProduct`>,1
+DiceKriging,covMat1Mat2,0,1,3,class<`covUser`>,1
+DiceKriging,covMat1Mat2,1,1,0,class<`matrix`>,1
+DiceKriging,covMat1Mat2,2,1,0,class<`matrix`>,1
+DiceKriging,covMat1Mat2,3,1,0,logical,1
+DiceKriging,covMat1Mat2,-1,2,0,class<`matrix`>,1
+DiceKriging,covMat1Mat2,0,2,0,class<`covTensorProduct`>,1
+DiceKriging,covMat1Mat2,1,2,0,class<`matrix`>,1
+DiceKriging,covMat1Mat2,2,2,0,class<`matrix`>,1
+DiceKriging,covMat1Mat2,3,2,0,logical,1
+DiceKriging,covMat1Mat2,-1,3,0,class<`matrix`>,1
+DiceKriging,covMat1Mat2,0,3,0,class<`covScaling`>,1
+DiceKriging,covMat1Mat2,1,3,0,class<`matrix`>,1
+DiceKriging,covMat1Mat2,2,3,0,class<`matrix`>,1
+DiceKriging,covMat1Mat2,3,3,0,logical,1
+DiceKriging,covMat1Mat2,-1,4,0,class<`matrix`>,1
+DiceKriging,covMat1Mat2,0,4,0,class<`covUser`>,1
+DiceKriging,covMat1Mat2,1,4,0,class<`matrix`>,1
+DiceKriging,covMat1Mat2,2,4,0,class<`matrix`>,1
+DiceKriging,covMat1Mat2,3,4,0,logical,1
+DiceKriging,covMat1Mat2.covTensorProduct,-1,0,0,class<`matrix`>,1
+DiceKriging,covMat1Mat2.covTensorProduct,0,0,0,class<`covTensorProduct`>,1
+DiceKriging,covMat1Mat2.covTensorProduct,1,0,0,class<`matrix`>,1
+DiceKriging,covMat1Mat2.covTensorProduct,2,0,0,class<`matrix`>,1
+DiceKriging,covMat1Mat2.covTensorProduct,3,0,0,logical,1
+DiceKriging,covMat1Mat2.covUser,-1,0,0,class<`matrix`>,1
+DiceKriging,covMat1Mat2.covUser,0,0,0,class<`covUser`>,1
+DiceKriging,covMat1Mat2.covUser,1,0,0,class<`matrix`>,1
+DiceKriging,covMat1Mat2.covUser,2,0,0,class<`matrix`>,1
+DiceKriging,covMatrix,-1,0,0,list<class<`matrix`> | double[]>,1
+DiceKriging,covMatrix,0,0,0,class<`covIso`>,1
+DiceKriging,covMatrix,0,0,1,class<`covScaling`>,1
+DiceKriging,covMatrix,0,0,2,class<`covTensorProduct`>,1
+DiceKriging,covMatrix,0,0,3,class<`covUser`>,1
+DiceKriging,covMatrix,1,0,0,class<`matrix`>,1
+DiceKriging,covMatrix,2,0,0,any,1
+DiceKriging,covMatrix,-1,1,0,list<class<`matrix`> | double[]>,1
+DiceKriging,covMatrix,0,1,0,class<`covTensorProduct`>,1
+DiceKriging,covMatrix,1,1,0,class<`matrix`>,1
+DiceKriging,covMatrix,2,1,0,any,1
+DiceKriging,covMatrix,-1,2,0,list<class<`matrix`> | double[]>,1
+DiceKriging,covMatrix,0,2,0,class<`covIso`>,1
+DiceKriging,covMatrix,1,2,0,class<`matrix`>,1
+DiceKriging,covMatrix,2,2,0,null,1
+DiceKriging,covMatrix,-1,3,0,list<class<`matrix`> | double[]>,1
+DiceKriging,covMatrix,0,3,0,class<`covScaling`>,1
+DiceKriging,covMatrix,1,3,0,class<`matrix`>,1
+DiceKriging,covMatrix,2,3,0,null,1
+DiceKriging,covMatrix,-1,4,0,list<class<`matrix`> | double[]>,1
+DiceKriging,covMatrix,0,4,0,class<`covUser`>,1
+DiceKriging,covMatrix,1,4,0,class<`matrix`>,1
+DiceKriging,covMatrix,2,4,0,double[],1
+DiceKriging,covMatrix,2,4,1,null,1
+DiceKriging,covMatrix.covTensorProduct,-1,0,0,list<class<`matrix`> | double[]>,1
+DiceKriging,covMatrix.covTensorProduct,0,0,0,class<`covTensorProduct`>,1
+DiceKriging,covMatrix.covTensorProduct,1,0,0,class<`matrix`>,1
+DiceKriging,covMatrix.covTensorProduct,2,0,0,any,1
+DiceKriging,covMatrixcovUser,-1,0,0,list<class<`matrix`> | double[]>,1
+DiceKriging,covMatrixcovUser,0,0,0,class<`covUser`>,1
+DiceKriging,covMatrixcovUser,1,0,0,class<`matrix`>,1
+DiceKriging,covMatrixcovUser,2,0,0,double[],1
+DiceKriging,covMatrixcovUser,2,0,1,null,1
+DiceKriging,covMatrixDerivative,-1,0,0,class<`matrix`>,1
+DiceKriging,covMatrixDerivative,0,0,0,class<`covTensorProduct`>,1
+DiceKriging,covMatrixDerivative,1,0,0,class<`matrix`>,1
+DiceKriging,covMatrixDerivative,2,0,0,class<`matrix`>,1
+DiceKriging,covMatrixDerivative,3,0,0,integer,1
+DiceKriging,covMatrixDerivative,4,0,0,...,1
+DiceKriging,covMatrixDerivative,-1,1,0,class<`matrix`>,1
+DiceKriging,covMatrixDerivative,0,1,0,class<`covScaling`>,1
+DiceKriging,covMatrixDerivative,0,1,1,class<`covTensorProduct`>,1
+DiceKriging,covMatrixDerivative,1,1,0,class<`matrix`>,1
+DiceKriging,covMatrixDerivative,2,1,0,any,1
+DiceKriging,covMatrixDerivative,3,1,0,integer,1
+DiceKriging,covMatrixDerivative,4,1,0,...,1
+DiceKriging,covMatrixDerivative,-1,2,0,class<`matrix`>,1
+DiceKriging,covMatrixDerivative,0,2,0,class<`covScaling`>,1
+DiceKriging,covMatrixDerivative,1,2,0,class<`matrix`>,1
+DiceKriging,covMatrixDerivative,2,2,0,any,1
+DiceKriging,covMatrixDerivative,3,2,0,integer,1
+DiceKriging,covMatrixDerivative,4,2,0,...,1
+DiceKriging,covMatrixDerivative.covTensorProduct,-1,0,0,class<`matrix`>,1
+DiceKriging,covMatrixDerivative.covTensorProduct,0,0,0,class<`covTensorProduct`>,1
+DiceKriging,covMatrixDerivative.covTensorProduct,1,0,0,class<`matrix`>,1
+DiceKriging,covMatrixDerivative.covTensorProduct,2,0,0,class<`matrix`>,1
+DiceKriging,covMatrixDerivative.covTensorProduct,3,0,0,integer,1
+DiceKriging,covMatrixDerivative.dx.covTensorProduct,-1,0,0,class<`matrix`>,1
+DiceKriging,covMatrixDerivative.dx.covTensorProduct,0,0,0,class<`covTensorProduct`>,1
+DiceKriging,covMatrixDerivative.dx.covTensorProduct,1,0,0,class<`matrix`>,1
+DiceKriging,covMatrixDerivative.dx.covTensorProduct,2,0,0,class<`matrix`>,1
+DiceKriging,covMatrixDerivative.dx.covTensorProduct,3,0,0,integer,1
+DiceKriging,covparam2vect,-1,0,0,double[],1
+DiceKriging,covparam2vect,0,0,0,class<`covTensorProduct`>,1
+DiceKriging,covparam2vect,-1,1,0,double[],1
+DiceKriging,covparam2vect,0,1,0,class<`covTensorProduct`>,1
+DiceKriging,covParametersBounds,-1,0,0,list<double[]>,1
+DiceKriging,covParametersBounds,0,0,0,class<`covScaling`>,1
+DiceKriging,covParametersBounds,0,0,1,class<`covTensorProduct`>,1
+DiceKriging,covParametersBounds,1,0,0,class<`data.frame`>,1
+DiceKriging,covParametersBounds,-1,1,0,list<double[]>,1
+DiceKriging,covParametersBounds,0,1,0,class<`covScaling`>,1
+DiceKriging,covParametersBounds,1,1,0,class<`data.frame`>,1
+DiceKriging,covParametersBounds,-1,2,0,list<double[]>,1
+DiceKriging,covParametersBounds,0,2,0,class<`covTensorProduct`>,1
+DiceKriging,covParametersBounds,1,2,0,class<`data.frame`>,1
+DiceKriging,covStruct.create,-1,0,0,class<`covScaling`>,1
+DiceKriging,covStruct.create,-1,0,1,class<`covTensorProduct`>,1
+DiceKriging,covStruct.create,-1,0,2,class<`covUser`>,1
+DiceKriging,covStruct.create,0,0,0,character,1
+DiceKriging,covStruct.create,1,0,0,any,1
+DiceKriging,covStruct.create,2,0,0,any,1
+DiceKriging,covStruct.create,3,0,0,any,1
+DiceKriging,covStruct.create,4,0,0,any,1
+DiceKriging,covStruct.create,5,0,0,any,1
+DiceKriging,covStruct.create,6,0,0,null,1
+DiceKriging,covStruct.create,6,0,1,double,1
+DiceKriging,covStruct.create,7,0,0,any,1
+DiceKriging,covStruct.create,8,0,0,any,1
+DiceKriging,covStruct.create,9,0,0,any,1
+DiceKriging,covStruct.create,10,0,0,any,1
+DiceKriging,covStruct.create,11,0,0,any,1
+DiceKriging,covStruct.create,12,0,0,any,1
+DiceKriging,drop.response,-1,0,0,class<`formula`>,1
+DiceKriging,drop.response,0,0,0,class<`formula`>,1
+DiceKriging,drop.response,1,0,0,class<`data.frame`>,1
+DiceKriging,extract.covIso,-1,0,0,class<`covIso`>,1
+DiceKriging,extract.covIso,0,0,0,class<`covScaling`>,1
+DiceKriging,km,-1,0,0,class<`km`>,1
+DiceKriging,km,0,0,0,class<`formula`>,1
+DiceKriging,km,1,0,0,class<`data.frame`>,1
+DiceKriging,km,1,0,1,class<`matrix`>,1
+DiceKriging,km,2,0,0,class<`data.frame`>,1
+DiceKriging,km,2,0,1,double[],1
+DiceKriging,km,2,0,2,class<`matrix`>,1
+DiceKriging,km,3,0,0,character,1
+DiceKriging,km,4,0,0,double[],1
+DiceKriging,km,4,0,1,null,1
+DiceKriging,km,5,0,0,null,1
+DiceKriging,km,5,0,1,double[],1
+DiceKriging,km,6,0,0,double,1
+DiceKriging,km,6,0,1,null,1
+DiceKriging,km,7,0,0,null,1
+DiceKriging,km,7,0,1,double,1
+DiceKriging,km,8,0,0,logical,1
+DiceKriging,km,9,0,0,null,1
+DiceKriging,km,9,0,1,double[],1
+DiceKriging,km,10,0,0,character,1
+DiceKriging,km,11,0,0,null,1
+DiceKriging,km,11,0,1,list<any>,1
+DiceKriging,km,12,0,0,character,1
+DiceKriging,km,13,0,0,null,1
+DiceKriging,km,13,0,1,double[],1
+DiceKriging,km,14,0,0,null,1
+DiceKriging,km,14,0,1,double[],1
+DiceKriging,km,15,0,0,null,1
+DiceKriging,kmData,-1,0,0,class<`km`>,1
+DiceKriging,kmData,0,0,0,class<`formula`>,1
+DiceKriging,kmData,1,0,0,class<`data.frame`>,1
+DiceKriging,kmData,2,0,0,character[],1
+DiceKriging,kmData,2,0,1,null,1
+DiceKriging,kmData,3,0,0,...,1
+DiceKriging,kmNoNugget.init,-1,0,0,list<class<`matrix`> | double[] | list<class<`covScaling`>>>,1
+DiceKriging,kmNoNugget.init,-1,0,1,list<class<`matrix`> | double[] | list<class<`covTensorProduct`>>>,1
+DiceKriging,kmNoNugget.init,-1,0,2,list<class<`matrix`> | double | list<class<`covTensorProduct`>>>,1
+DiceKriging,kmNoNugget.init,0,0,0,class<`km`>,1
+DiceKriging,kmNoNugget.init,1,0,0,class<`function`>,1
+DiceKriging,kmNoNugget.init,2,0,0,double,1
+DiceKriging,kmNuggets.init,-1,0,0,list<class<`matrix`> | double[] | list<class<`covTensorProduct`>>>,1
+DiceKriging,kmNuggets.init,0,0,0,class<`km`>,1
+DiceKriging,leaveOneOut.km,-1,0,0,list<double[]>,1
+DiceKriging,leaveOneOut.km,0,0,0,class<`km`>,1
+DiceKriging,leaveOneOut.km,1,0,0,character,1
+DiceKriging,leaveOneOut.km,2,0,0,logical,1
+DiceKriging,paramSample,-1,0,0,class<`matrix`>,1
+DiceKriging,paramSample,0,0,0,class<`covScaling`>,1
+DiceKriging,paramSample,0,0,1,class<`covTensorProduct`>,1
+DiceKriging,paramSample,1,0,0,double,1
+DiceKriging,paramSample,2,0,0,...,1
+DiceKriging,paramSample,-1,1,0,class<`matrix`>,1
+DiceKriging,paramSample,0,1,0,class<`covTensorProduct`>,1
+DiceKriging,paramSample,1,1,0,double,1
+DiceKriging,paramSample,2,1,0,...,1
+DiceKriging,paramSample,-1,2,0,class<`matrix`>,1
+DiceKriging,paramSample,0,2,0,class<`covScaling`>,1
+DiceKriging,paramSample,1,2,0,double,1
+DiceKriging,paramSample,2,2,0,...,1
+DiceKriging,plot,-1,0,0,list<double[]>,1
+DiceKriging,plot,0,0,0,class<`km`>,1
+DiceKriging,plot,1,0,0,any,1
+DiceKriging,plot,2,0,0,...,1
+DiceKriging,plot.km,-1,0,0,list<double[]>,1
+DiceKriging,plot.km,0,0,0,class<`km`>,1
+DiceKriging,plot.km,1,0,0,character,1
+DiceKriging,plot.km,2,0,0,logical,1
+DiceKriging,plot.km,3,0,0,...,1
+DiceKriging,predict,-1,0,0,list<class<`matrix`> | double[]>,1
+DiceKriging,predict,0,0,0,class<`km`>,1
+DiceKriging,predict,1,0,0,...,1
+DiceKriging,predict.km,-1,0,0,list<class<`matrix`> | double[]>,1
+DiceKriging,predict.km,0,0,0,class<`km`>,1
+DiceKriging,predict.km,1,0,0,class<`data.frame`>,1
+DiceKriging,predict.km,2,0,0,character,1
+DiceKriging,predict.km,3,0,0,logical,1
+DiceKriging,predict.km,4,0,0,logical,1
+DiceKriging,predict.km,5,0,0,logical,1
+DiceKriging,predict.km,6,0,0,any,1
+DiceKriging,predict.km,7,0,0,logical,1
+DiceKriging,predict.km,8,0,0,...,1
+DiceKriging,SCAD,-1,0,0,double[],1
+DiceKriging,SCAD,0,0,0,double[],1
+DiceKriging,SCAD,1,0,0,double,1
+DiceKriging,scalingFun,-1,0,0,class<`matrix`>,1
+DiceKriging,scalingFun,0,0,0,class<`matrix`>,1
+DiceKriging,scalingFun,1,0,0,list<double[]>,1
+DiceKriging,scalingFun,2,0,0,list<double[]>,1
+DiceKriging,scalingFun,2,0,1,class<`data.frame`>,1
+DiceKriging,scalingFun,3,0,0,logical,1
+DiceKriging,scalingFun1d,-1,0,0,double[],1
+DiceKriging,scalingFun1d,0,0,0,class<`matrix`>,1
+DiceKriging,scalingFun1d,0,0,1,double[],1
+DiceKriging,scalingFun1d,1,0,0,double[],1
+DiceKriging,scalingFun1d,2,0,0,double[],1
+DiceKriging,scalingFun1d.inside,-1,0,0,double[],1
+DiceKriging,scalingFun1d.inside,0,0,0,double[],1
+DiceKriging,scalingFun1d.inside,1,0,0,double[],1
+DiceKriging,scalingFun1d.inside,2,0,0,double[],1
+DiceKriging,scalingGrad,-1,0,0,class<`matrix`>,1
+DiceKriging,scalingGrad,0,0,0,class<`matrix`>,1
+DiceKriging,scalingGrad,1,0,0,list<double[]>,1
+DiceKriging,scalingGrad,2,0,0,integer,1
+DiceKriging,scalingGrad1d,-1,0,0,class<`matrix`>,1
+DiceKriging,scalingGrad1d,0,0,0,double[],1
+DiceKriging,scalingGrad1d,1,0,0,double[],1
+DiceKriging,scalingGrad1d,2,0,0,logical,1
+DiceKriging,simulate,-1,0,0,class<`matrix`>,1
+DiceKriging,simulate,0,0,0,class<`km`>,1
+DiceKriging,simulate,1,0,0,double,1
+DiceKriging,simulate,2,0,0,null,1
+DiceKriging,simulate,3,0,0,...,1
+DiceKriging,simulate.km,-1,0,0,class<`matrix`>,1
+DiceKriging,simulate.km,0,0,0,class<`km`>,1
+DiceKriging,simulate.km,1,0,0,double,1
+DiceKriging,simulate.km,2,0,0,null,1
+DiceKriging,simulate.km,3,0,0,class<`data.frame`>,1
+DiceKriging,simulate.km,3,0,1,null,1
+DiceKriging,simulate.km,4,0,0,logical,1
+DiceKriging,simulate.km,5,0,0,double,1
+DiceKriging,simulate.km,6,0,0,any,1
+DiceKriging,simulate.km,7,0,0,...,1
+DiceKriging,trend.deltax,-1,0,0,class<`matrix`>,1
+DiceKriging,trend.deltax,0,0,0,double[],1
+DiceKriging,trend.deltax,1,0,0,class<`km`>,1
+DiceKriging,trend.deltax,2,0,0,any,1
+DiceKriging,update,-1,0,0,class<`km`>,1
+DiceKriging,update,0,0,0,class<`km`>,1
+DiceKriging,update,1,0,0,...,1
+DiceKriging,update.km,-1,0,0,class<`km`>,1
+DiceKriging,update.km,0,0,0,class<`km`>,1
+DiceKriging,update.km,1,0,0,class<`matrix`>,1
+DiceKriging,update.km,2,0,0,double,1
+DiceKriging,update.km,3,0,0,logical,1
+DiceKriging,update.km,4,0,0,logical,1
+DiceKriging,update.km,5,0,0,logical,1
+DiceKriging,update.km,6,0,0,logical,1
+DiceKriging,update.km,7,0,0,null,1
+DiceKriging,update.km,8,0,0,null,1
+DiceKriging,update.km,9,0,0,any,1
+DiceKriging,vect2covparam,-1,0,0,class<`covScaling`>,1
+DiceKriging,vect2covparam,0,0,0,class<`covScaling`>,1
+DiceKriging,vect2covparam,1,0,0,double[],1
+DiceKriging,vect2covparam,-1,1,0,class<`covTensorProduct`>,1
+DiceKriging,vect2covparam,0,1,0,class<`covTensorProduct`>,1
+DiceKriging,vect2covparam,1,1,0,double[],1
+DiceKriging,vect2covparam,-1,2,0,class<`covScaling`>,1
+DiceKriging,vect2covparam,-1,2,1,class<`covTensorProduct`>,1
+DiceKriging,vect2covparam,0,2,0,class<`covScaling`>,1
+DiceKriging,vect2covparam,0,2,1,class<`covTensorProduct`>,1
+DiceKriging,vect2covparam,1,2,0,double[],1
+DistributionUtils,besselRatio,-1,0,0,double,1
+DistributionUtils,besselRatio,0,0,0,double,1
+DistributionUtils,besselRatio,1,0,0,double,1
+DistributionUtils,besselRatio,2,0,0,double,1
+DistributionUtils,besselRatio,3,0,0,double,1
+DistributionUtils,distCalcRange,-1,0,0,double[],1
+DistributionUtils,distCalcRange,0,0,0,character,1
+DistributionUtils,distCalcRange,1,0,0,double[],1
+DistributionUtils,distCalcRange,1,0,1,null,1
+DistributionUtils,distCalcRange,2,0,0,double,1
+DistributionUtils,distCalcRange,3,0,0,...,1
+DistributionUtils,distIneqMassart,-1,0,0,list<double>,1
+DistributionUtils,distIneqMassart,0,0,0,character,1
+DistributionUtils,distIneqMassart,1,0,0,double,1
+DistributionUtils,distIneqMassart,2,0,0,double,1
+DistributionUtils,distIneqMassart,3,0,0,...,1
+DistributionUtils,distMode,-1,0,0,double,1
+DistributionUtils,distMode,0,0,0,character,1
+DistributionUtils,distMode,1,0,0,double[],1
+DistributionUtils,distMode,1,0,1,null,1
+DistributionUtils,distMode,2,0,0,...,1
+DistributionUtils,distStepSize,-1,0,0,double[],1
+DistributionUtils,distStepSize,0,0,0,character,1
+DistributionUtils,distStepSize,1,0,0,any,1
+DistributionUtils,distStepSize,2,0,0,null,1
+DistributionUtils,distStepSize,2,0,1,double[],1
+DistributionUtils,distStepSize,3,0,0,character,1
+DistributionUtils,distStepSize,4,0,0,...,1
+DistributionUtils,gammaTailPlotLine,-1,0,0,null,1
+DistributionUtils,gammaTailPlotLine,0,0,0,double[],1
+DistributionUtils,gammaTailPlotLine,1,0,0,double,1
+DistributionUtils,gammaTailPlotLine,2,0,0,double,1
+DistributionUtils,gammaTailPlotLine,3,0,0,double,1
+DistributionUtils,gammaTailPlotLine,4,0,0,character[],1
+DistributionUtils,gammaTailPlotLine,5,0,0,...,1
+DistributionUtils,incompleteBesselK,-1,0,0,double,1
+DistributionUtils,incompleteBesselK,0,0,0,double,1
+DistributionUtils,incompleteBesselK,1,0,0,double,1
+DistributionUtils,incompleteBesselK,2,0,0,double,1
+DistributionUtils,incompleteBesselK,3,0,0,double,1
+DistributionUtils,incompleteBesselK,4,0,0,double,1
+DistributionUtils,integrateDens,-1,0,0,class<`integrate`>,1
+DistributionUtils,integrateDens,0,0,0,character,1
+DistributionUtils,integrateDens,1,0,0,double,1
+DistributionUtils,integrateDens,2,0,0,double,1
+DistributionUtils,integrateDens,3,0,0,double,1
+DistributionUtils,integrateDens,4,0,0,...,1
+DistributionUtils,inversionTestpq,-1,0,0,list<double[]>,1
+DistributionUtils,inversionTestpq,0,0,0,character,1
+DistributionUtils,inversionTestpq,1,0,0,double,1
+DistributionUtils,inversionTestpq,2,0,0,double,1
+DistributionUtils,inversionTestpq,3,0,0,double,1
+DistributionUtils,inversionTestpq,4,0,0,null,1
+DistributionUtils,inversionTestpq,5,0,0,character,1
+DistributionUtils,inversionTestpq,6,0,0,...,1
+DistributionUtils,inversionTestqp,-1,0,0,list<double[]>,1
+DistributionUtils,inversionTestqp,0,0,0,character,1
+DistributionUtils,inversionTestqp,1,0,0,double[],1
+DistributionUtils,inversionTestqp,2,0,0,double,1
+DistributionUtils,inversionTestqp,3,0,0,double,1
+DistributionUtils,inversionTestqp,4,0,0,character,1
+DistributionUtils,inversionTestqp,5,0,0,...,1
+DistributionUtils,is.wholenumber,-1,0,0,logical,1
+DistributionUtils,is.wholenumber,0,0,0,character[],1
+DistributionUtils,is.wholenumber,0,0,1,class<`matrix`>,1
+DistributionUtils,is.wholenumber,0,0,2,complex[],1
+DistributionUtils,is.wholenumber,0,0,3,list<integer[]>,1
+DistributionUtils,is.wholenumber,1,0,0,any,1
+DistributionUtils,kurtosis,-1,0,0,double,1
+DistributionUtils,kurtosis,0,0,0,double[],1
+DistributionUtils,kurtosis,1,0,0,logical,1
+DistributionUtils,logHist,-1,0,0,list<double[] | character>,1
+DistributionUtils,logHist,0,0,0,double[],1
+DistributionUtils,logHist,1,0,0,character,1
+DistributionUtils,logHist,2,0,0,logical,1
+DistributionUtils,logHist,3,0,0,logical,1
+DistributionUtils,logHist,4,0,0,character,1
+DistributionUtils,logHist,5,0,0,double[],1
+DistributionUtils,logHist,6,0,0,null,1
+DistributionUtils,logHist,7,0,0,character,1
+DistributionUtils,logHist,8,0,0,character,1
+DistributionUtils,logHist,9,0,0,null,1
+DistributionUtils,logHist,10,0,0,character,1
+DistributionUtils,logHist,11,0,0,...,1
+DistributionUtils,momChangeAbout,-1,0,0,double[],1
+DistributionUtils,momChangeAbout,0,0,0,character,1
+DistributionUtils,momChangeAbout,0,0,1,double,1
+DistributionUtils,momChangeAbout,1,0,0,double[],1
+DistributionUtils,momChangeAbout,2,0,0,double,1
+DistributionUtils,momChangeAbout,3,0,0,double,1
+DistributionUtils,momIntegrated,-1,0,0,double,1
+DistributionUtils,momIntegrated,0,0,0,character,1
+DistributionUtils,momIntegrated,1,0,0,double[],1
+DistributionUtils,momIntegrated,2,0,0,double,1
+DistributionUtils,momIntegrated,3,0,0,double,1
+DistributionUtils,momIntegrated,4,0,0,logical,1
+DistributionUtils,momIntegrated,5,0,0,...,1
+DistributionUtils,momSE,-1,0,0,double,1
+DistributionUtils,momSE,0,0,0,double,1
+DistributionUtils,momSE,1,0,0,double,1
+DistributionUtils,momSE,2,0,0,double[],1
+DistributionUtils,moranTest,-1,0,0,class<`htest`>,1
+DistributionUtils,moranTest,0,0,0,double[],1
+DistributionUtils,moranTest,1,0,0,character,1
+DistributionUtils,moranTest,2,0,0,null,1
+DistributionUtils,moranTest,3,0,0,...,1
+DistributionUtils,normTailPlotLine,-1,0,0,null,1
+DistributionUtils,normTailPlotLine,0,0,0,double[],1
+DistributionUtils,normTailPlotLine,1,0,0,double,1
+DistributionUtils,normTailPlotLine,2,0,0,double,1
+DistributionUtils,normTailPlotLine,3,0,0,character[],1
+DistributionUtils,normTailPlotLine,4,0,0,...,1
+DistributionUtils,pDist,-1,0,0,double[],1
+DistributionUtils,pDist,0,0,0,character,1
+DistributionUtils,pDist,1,0,0,double[],1
+DistributionUtils,pDist,2,0,0,double[],1
+DistributionUtils,pDist,2,0,1,null,1
+DistributionUtils,pDist,3,0,0,double,1
+DistributionUtils,pDist,4,0,0,logical,1
+DistributionUtils,pDist,5,0,0,double,1
+DistributionUtils,pDist,6,0,0,logical,1
+DistributionUtils,pDist,7,0,0,...,1
+DistributionUtils,qDist,-1,0,0,double[],1
+DistributionUtils,qDist,0,0,0,character,1
+DistributionUtils,qDist,1,0,0,double[],1
+DistributionUtils,qDist,2,0,0,null,1
+DistributionUtils,qDist,2,0,1,double[],1
+DistributionUtils,qDist,3,0,0,logical,1
+DistributionUtils,qDist,4,0,0,character,1
+DistributionUtils,qDist,5,0,0,double,1
+DistributionUtils,qDist,6,0,0,double,1
+DistributionUtils,qDist,7,0,0,double,1
+DistributionUtils,qDist,8,0,0,double,1
+DistributionUtils,qDist,9,0,0,...,1
+DistributionUtils,safeIntegrate,-1,0,0,class<`integrate`>,1
+DistributionUtils,safeIntegrate,0,0,0,class<`function`>,1
+DistributionUtils,safeIntegrate,1,0,0,double,1
+DistributionUtils,safeIntegrate,2,0,0,double,1
+DistributionUtils,safeIntegrate,3,0,0,any,1
+DistributionUtils,safeIntegrate,4,0,0,any,1
+DistributionUtils,safeIntegrate,5,0,0,any,1
+DistributionUtils,safeIntegrate,6,0,0,logical,1
+DistributionUtils,safeIntegrate,7,0,0,logical,1
+DistributionUtils,safeIntegrate,8,0,0,null,1
+DistributionUtils,safeIntegrate,9,0,0,...,1
+DistributionUtils,skewness,-1,0,0,double,1
+DistributionUtils,skewness,0,0,0,double[],1
+DistributionUtils,skewness,1,0,0,logical,1
+DistributionUtils,tailPlot,-1,0,0,null,1
+DistributionUtils,tailPlot,0,0,0,double[],1
+DistributionUtils,tailPlot,1,0,0,character,1
+DistributionUtils,tailPlot,2,0,0,character[],1
+DistributionUtils,tailPlot,3,0,0,null,1
+DistributionUtils,tailPlot,4,0,0,null,1
+DistributionUtils,tailPlot,5,0,0,null,1
+DistributionUtils,tailPlot,6,0,0,...,1
+DistributionUtils,tailPlotLine,-1,0,0,null,1
+DistributionUtils,tailPlotLine,0,0,0,double[],1
+DistributionUtils,tailPlotLine,1,0,0,character,1
+DistributionUtils,tailPlotLine,2,0,0,double[],1
+DistributionUtils,tailPlotLine,2,0,1,null,1
+DistributionUtils,tailPlotLine,3,0,0,character[],1
+DistributionUtils,tailPlotLine,4,0,0,...,1
+DistributionUtils,tsHessian,-1,0,0,class<`matrix`>,1
+DistributionUtils,tsHessian,0,0,0,double[],1
+DistributionUtils,tsHessian,1,0,0,class<`function`>,1
+DistributionUtils,tsHessian,2,0,0,...,1
+DistributionUtils,tTailPlotLine,-1,0,0,null,1
+DistributionUtils,tTailPlotLine,0,0,0,double[],1
+DistributionUtils,tTailPlotLine,1,0,0,double,1
+DistributionUtils,tTailPlotLine,2,0,0,character[],1
+DistributionUtils,tTailPlotLine,3,0,0,...,1
+DoseFinding,AIC.DRMod,-1,0,0,double,1
+DoseFinding,AIC.DRMod,0,0,0,class<`DRMod`>,1
+DoseFinding,AIC.DRMod,1,0,0,...,1
+DoseFinding,AIC.DRMod,2,0,0,double,1
+DoseFinding,betaMod,-1,0,0,double[],1
+DoseFinding,betaMod,0,0,0,double[],1
+DoseFinding,betaMod,1,0,0,double,1
+DoseFinding,betaMod,2,0,0,class<`AsIs`>,1
+DoseFinding,betaMod,2,0,1,double,1
+DoseFinding,betaMod,3,0,0,double,1
+DoseFinding,betaMod,4,0,0,double,1
+DoseFinding,betaMod,5,0,0,double,1
+DoseFinding,betaModGrad,-1,0,0,class<`matrix`>,1
+DoseFinding,betaModGrad,0,0,0,double[],1
+DoseFinding,betaModGrad,1,0,0,double,1
+DoseFinding,betaModGrad,2,0,0,double,1
+DoseFinding,betaModGrad,3,0,0,double,1
+DoseFinding,betaModGrad,4,0,0,double,1
+DoseFinding,betaModGrad,5,0,0,...,1
+DoseFinding,bFitMod,-1,0,0,class<`bFitMod`>,1
+DoseFinding,bFitMod,0,0,0,double[],1
+DoseFinding,bFitMod,1,0,0,double[],1
+DoseFinding,bFitMod,2,0,0,character,1
+DoseFinding,bFitMod,3,0,0,class<`matrix`>,1
+DoseFinding,bFitMod,4,0,0,logical,1
+DoseFinding,bFitMod,5,0,0,character[],1
+DoseFinding,bFitMod,6,0,0,any,1
+DoseFinding,bFitMod,7,0,0,null,1
+DoseFinding,bFitMod,7,0,1,list<double[]>,1
+DoseFinding,bFitMod.Bayes,-1,0,0,double[],1
+DoseFinding,bFitMod.Bayes,0,0,0,double[],1
+DoseFinding,bFitMod.Bayes,1,0,0,double[],1
+DoseFinding,bFitMod.Bayes,2,0,0,class<`matrix`>,1
+DoseFinding,bFitMod.Bayes,3,0,0,character,1
+DoseFinding,bFitMod.Bayes,4,0,0,logical,1
+DoseFinding,bFitMod.Bayes,5,0,0,double[],1
+DoseFinding,bFitMod.Bayes,5,0,1,null,1
+DoseFinding,bFitMod.Bayes,6,0,0,list<double[]>,1
+DoseFinding,bFitMod.Bayes,7,0,0,double,1
+DoseFinding,bFitMod.bootstrap,-1,0,0,class<`matrix`>,1
+DoseFinding,bFitMod.bootstrap,0,0,0,double[],1
+DoseFinding,bFitMod.bootstrap,1,0,0,double[],1
+DoseFinding,bFitMod.bootstrap,2,0,0,class<`matrix`>,1
+DoseFinding,bFitMod.bootstrap,3,0,0,character,1
+DoseFinding,bFitMod.bootstrap,4,0,0,logical,1
+DoseFinding,bFitMod.bootstrap,5,0,0,double,1
+DoseFinding,bFitMod.bootstrap,6,0,0,any,1
+DoseFinding,bFitMod.bootstrap,7,0,0,any,1
+DoseFinding,calcCrit,-1,0,0,^double[],1
+DoseFinding,calcCrit,0,0,0,class<`matrix`>,1
+DoseFinding,calcCrit,0,0,1,double[],1
+DoseFinding,calcCrit,1,0,0,class<`Mods`>,1
+DoseFinding,calcCrit,2,0,0,double[],1
+DoseFinding,calcCrit,3,0,0,double[],1
+DoseFinding,calcCrit,4,0,0,character,1
+DoseFinding,calcCrit,5,0,0,any,1
+DoseFinding,calcCrit,6,0,0,logical,1
+DoseFinding,calcCrit,7,0,0,any,1
+DoseFinding,calcED,-1,0,0,double,1
+DoseFinding,calcED,-1,0,1,null,1
+DoseFinding,calcED,0,0,0,character,1
+DoseFinding,calcED,1,0,0,double[],1
+DoseFinding,calcED,2,0,0,any,1
+DoseFinding,calcED,3,0,0,any,1
+DoseFinding,calcED,4,0,0,character[],1
+DoseFinding,calcED,5,0,0,any,1
+DoseFinding,calcED,6,0,0,any,1
+DoseFinding,calcED,7,0,0,any,1
+DoseFinding,calcGrads,-1,0,0,list<double[]>,1
+DoseFinding,calcGrads,-1,0,1,list<double[] | null>,1
+DoseFinding,calcGrads,0,0,0,class<`Mods`>,1
+DoseFinding,calcGrads,1,0,0,double[],1
+DoseFinding,calcGrads,2,0,0,double[],1
+DoseFinding,calcGrads,3,0,0,any,1
+DoseFinding,calcGrads,4,0,0,any,1
+DoseFinding,calcGrads,5,0,0,any,1
+DoseFinding,calcGrads,6,0,0,any,1
+DoseFinding,calcGrads,7,0,0,character,1
+DoseFinding,calcResp,-1,0,0,class<`matrix`>,1
+DoseFinding,calcResp,0,0,0,class<`Mods`>,1
+DoseFinding,calcResp,0,0,1,list<double[] | class<`matrix`>>,1
+DoseFinding,calcResp,1,0,0,double[],1
+DoseFinding,calcResp,2,0,0,any,1
+DoseFinding,calcResp,3,0,0,any,1
+DoseFinding,calcResp,4,0,0,any,1
+DoseFinding,calcTD,-1,0,0,double,1
+DoseFinding,calcTD,-1,0,1,null,1
+DoseFinding,calcTD,0,0,0,character,1
+DoseFinding,calcTD,1,0,0,double[],1
+DoseFinding,calcTD,2,0,0,double,1
+DoseFinding,calcTD,3,0,0,character[],1
+DoseFinding,calcTD,4,0,0,character[],1
+DoseFinding,calcTD,5,0,0,any,1
+DoseFinding,calcTD,6,0,0,any,1
+DoseFinding,calcTD,7,0,0,any,1
+DoseFinding,calcTDgrad,-1,0,0,double[],1
+DoseFinding,calcTDgrad,0,0,0,character,1
+DoseFinding,calcTDgrad,1,0,0,double[],1
+DoseFinding,calcTDgrad,2,0,0,double,1
+DoseFinding,calcTDgrad,3,0,0,character,1
+DoseFinding,calcTDgrad,4,0,0,any,1
+DoseFinding,calcTDgrad,5,0,0,any,1
+DoseFinding,calcTDgrad,6,0,0,any,1
+DoseFinding,callOptim,-1,0,0,list<any>,1
+DoseFinding,callOptim,0,0,0,class<`function`>,1
+DoseFinding,callOptim,1,0,0,character,1
+DoseFinding,callOptim,2,0,0,integer,1
+DoseFinding,callOptim,3,0,0,list<any>,1
+DoseFinding,callOptim,4,0,0,any,1
+DoseFinding,callOptim,5,0,0,any,1
+DoseFinding,checkAnalyArgs,-1,0,0,list<any>,1
+DoseFinding,checkAnalyArgs,0,0,0,any,1
+DoseFinding,checkAnalyArgs,1,0,0,any,1
+DoseFinding,checkAnalyArgs,2,0,0,null,1
+DoseFinding,checkAnalyArgs,2,0,1,class<`data.frame`>,1
+DoseFinding,checkAnalyArgs,3,0,0,class<`matrix`>,1
+DoseFinding,checkAnalyArgs,3,0,1,null,1
+DoseFinding,checkAnalyArgs,4,0,0,character,1
+DoseFinding,checkAnalyArgs,5,0,0,class<`formula`>,1
+DoseFinding,checkAnalyArgs,6,0,0,logical,1
+DoseFinding,checkAnalyArgs,7,0,0,class<`function`>,1
+DoseFinding,checkEntries,-1,0,0,list<null>,1
+DoseFinding,checkEntries,0,0,0,list<class<`matrix`>>,1
+DoseFinding,checkEntries,0,0,1,list<double[]>,1
+DoseFinding,checkEntries,0,0,2,list<null>,1
+DoseFinding,checkEntries,0,0,3,list<class<`matrix`> | null>,1
+DoseFinding,checkEntries,0,0,4,list<double[] | class<`matrix`>>,1
+DoseFinding,checkEntries,0,0,5,list<null | double[]>,1
+DoseFinding,checkEntries,0,0,6,list<null | double>,1
+DoseFinding,checkEntries,0,0,7,list<double[] | null>,1
+DoseFinding,checkEntries,0,0,8,list<null | class<`matrix`> | double>,1
+DoseFinding,checkEntries,0,0,9,list<null | double[] | class<`matrix`>>,1
+DoseFinding,checkEntries,1,0,0,any,1
+DoseFinding,checkEntries,2,0,0,logical,1
+DoseFinding,checkPrior,-1,0,0,null,1
+DoseFinding,checkPrior,0,0,0,list<double[]>,1
+DoseFinding,coef.DRMod,-1,0,0,double[],1
+DoseFinding,coef.DRMod,0,0,0,class<`DRMod`>,1
+DoseFinding,coef.DRMod,1,0,0,logical,1
+DoseFinding,coef.DRMod,2,0,0,...,1
+DoseFinding,critVal,-1,0,0,double,1
+DoseFinding,critVal,0,0,0,class<`matrix`>,1
+DoseFinding,critVal,1,0,0,double,1
+DoseFinding,critVal,2,0,0,double,1
+DoseFinding,critVal,3,0,0,character,1
+DoseFinding,critVal,4,0,0,class<`GenzBretz`>,1
+DoseFinding,defBnds,-1,0,0,list<double[] | class<`matrix`>>,1
+DoseFinding,defBnds,0,0,0,double,1
+DoseFinding,defBnds,1,0,0,double[],1
+DoseFinding,defBnds,2,0,0,double[],1
+DoseFinding,defBnds,3,0,0,class<`matrix`>,1
+DoseFinding,defBnds,4,0,0,class<`matrix`>,1
+DoseFinding,defBnds,5,0,0,class<`matrix`>,1
+DoseFinding,ED,-1,0,0,^double[],1
+DoseFinding,ED,0,0,0,class<`bFitMod`>,1
+DoseFinding,ED,0,0,1,class<`DRMod`>,1
+DoseFinding,ED,0,0,2,class<`Mods`>,1
+DoseFinding,ED,1,0,0,double,1
+DoseFinding,ED,2,0,0,character[],1
+DoseFinding,ED,3,0,0,any,1
+DoseFinding,emax,-1,0,0,double[],1
+DoseFinding,emax,0,0,0,double[],1
+DoseFinding,emax,1,0,0,double,1
+DoseFinding,emax,2,0,0,double,1
+DoseFinding,emax,3,0,0,double,1
+DoseFinding,emaxGrad,-1,0,0,class<`matrix`>,1
+DoseFinding,emaxGrad,0,0,0,double[],1
+DoseFinding,emaxGrad,1,0,0,double,1
+DoseFinding,emaxGrad,2,0,0,double,1
+DoseFinding,emaxGrad,3,0,0,...,1
+DoseFinding,exponential,-1,0,0,double[],1
+DoseFinding,exponential,0,0,0,double[],1
+DoseFinding,exponential,1,0,0,double,1
+DoseFinding,exponential,2,0,0,double,1
+DoseFinding,exponential,3,0,0,double,1
+DoseFinding,exponentialGrad,-1,0,0,class<`matrix`>,1
+DoseFinding,exponentialGrad,0,0,0,double[],1
+DoseFinding,exponentialGrad,1,0,0,double,1
+DoseFinding,exponentialGrad,2,0,0,double,1
+DoseFinding,exponentialGrad,3,0,0,...,1
+DoseFinding,fit.control,-1,0,0,list<double | list<any>>,1
+DoseFinding,fit.control,0,0,0,null,1
+DoseFinding,fitMod,-1,0,0,class<`DRMod`>,1
+DoseFinding,fitMod,0,0,0,any,1
+DoseFinding,fitMod,1,0,0,any,1
+DoseFinding,fitMod,2,0,0,class<`data.frame`>,1
+DoseFinding,fitMod,2,0,1,null,1
+DoseFinding,fitMod,3,0,0,character,1
+DoseFinding,fitMod,4,0,0,null,1
+DoseFinding,fitMod,4,0,1,class<`matrix`>,1
+DoseFinding,fitMod,5,0,0,character[],1
+DoseFinding,fitMod,6,0,0,class<`formula`>,1
+DoseFinding,fitMod,7,0,0,logical,1
+DoseFinding,fitModel.bndnls,-1,0,0,list<double[]>,1
+DoseFinding,fitModel.bndnls,0,0,0,class<`data.frame`>,1
+DoseFinding,fitModel.bndnls,1,0,0,character,1
+DoseFinding,fitModel.bndnls,2,0,0,class<`formula`>,1
+DoseFinding,fitModel.bndnls,3,0,0,character,1
+DoseFinding,fitModel.bndnls,4,0,0,double[],1
+DoseFinding,fitModel.bndnls,4,0,1,class<`matrix`>,1
+DoseFinding,fitModel.bndnls,5,0,0,null,1
+DoseFinding,fitModel.bndnls,6,0,0,null,1
+DoseFinding,fitModel.bndnls,6,0,1,double[],1
+DoseFinding,fitModel.bndnls,7,0,0,any,1
+DoseFinding,fitModel.lin,-1,0,0,list<double[] | null>,1
+DoseFinding,fitModel.lin,-1,0,1,list<double[]>,1
+DoseFinding,fitModel.lin,-1,0,2,list<double | null>,1
+DoseFinding,fitModel.lin,0,0,0,class<`data.frame`>,1
+DoseFinding,fitModel.lin,1,0,0,character,1
+DoseFinding,fitModel.lin,2,0,0,class<`formula`>,1
+DoseFinding,fitModel.lin,3,0,0,any,1
+DoseFinding,fitModel.lin,4,0,0,character,1
+DoseFinding,fitModel.lin,5,0,0,any,1
+DoseFinding,fitModel.lin,6,0,0,logical,1
+DoseFinding,fitModel.lin,7,0,0,any,1
+DoseFinding,fitMod.raw,-1,0,0,class<`DRMod`>,1
+DoseFinding,fitMod.raw,0,0,0,any,1
+DoseFinding,fitMod.raw,1,0,0,any,1
+DoseFinding,fitMod.raw,2,0,0,any,1
+DoseFinding,fitMod.raw,3,0,0,character,1
+DoseFinding,fitMod.raw,4,0,0,any,1
+DoseFinding,fitMod.raw,5,0,0,character,1
+DoseFinding,fitMod.raw,6,0,0,class<`formula`>,1
+DoseFinding,fitMod.raw,7,0,0,logical,1
+DoseFinding,fullMod,-1,0,0,list<class<`matrix`>>,1
+DoseFinding,fullMod,-1,0,1,list<double[]>,1
+DoseFinding,fullMod,-1,0,2,list<class<`matrix`> | double[]>,1
+DoseFinding,fullMod,-1,0,3,list<double[] | class<`matrix`>>,1
+DoseFinding,fullMod,0,0,0,list<class<`matrix`>>,1
+DoseFinding,fullMod,0,0,1,list<double[]>,1
+DoseFinding,fullMod,0,0,2,list<double[] | null>,1
+DoseFinding,fullMod,0,0,3,list<null | double[]>,1
+DoseFinding,fullMod,0,0,4,list<null | double[] | class<`matrix`>>,1
+DoseFinding,fullMod,0,0,5,list<null | double>,1
+DoseFinding,fullMod,0,0,6,list<null>,1
+DoseFinding,fullMod,0,0,7,list<null | class<`matrix`> | double>,1
+DoseFinding,fullMod,0,0,8,list<class<`matrix`> | null>,1
+DoseFinding,fullMod,1,0,0,double[],1
+DoseFinding,fullMod,2,0,0,double,1
+DoseFinding,fullMod,3,0,0,double,1
+DoseFinding,fullMod,4,0,0,any,1
+DoseFinding,fullMod,5,0,0,any,1
+DoseFinding,gAIC,-1,0,0,double,1
+DoseFinding,gAIC,0,0,0,class<`DRMod`>,1
+DoseFinding,gAIC,1,0,0,...,1
+DoseFinding,gAIC,2,0,0,double,1
+DoseFinding,gAIC.DRMod,-1,0,0,double,1
+DoseFinding,gAIC.DRMod,0,0,0,class<`DRMod`>,1
+DoseFinding,gAIC.DRMod,1,0,0,...,1
+DoseFinding,gAIC.DRMod,2,0,0,double,1
+DoseFinding,getAddArgs,-1,0,0,list<double>,1
+DoseFinding,getAddArgs,0,0,0,null,1
+DoseFinding,getAddArgs,0,0,1,list<double>,1
+DoseFinding,getAddArgs,1,0,0,double[],1
+DoseFinding,getCompositions,-1,0,0,class<`matrix`>,1
+DoseFinding,getCompositions,0,0,0,double,1
+DoseFinding,getCompositions,1,0,0,integer,1
+DoseFinding,getDesMat,-1,0,0,class<`matrix`>,1
+DoseFinding,getDesMat,0,0,0,double,1
+DoseFinding,getDesMat,1,0,0,integer,1
+DoseFinding,getDesMat,2,0,0,double[],1
+DoseFinding,getDesMat,3,0,0,double[],1
+DoseFinding,getDesMat,4,0,0,double,1
+DoseFinding,getDesMat,5,0,0,double,1
+DoseFinding,getDesMat,6,0,0,double,1
+DoseFinding,getGrid,-1,0,0,class<`matrix`>,1
+DoseFinding,getGrid,0,0,0,double,1
+DoseFinding,getGrid,1,0,0,class<`matrix`>,1
+DoseFinding,getGrid,2,0,0,double,1
+DoseFinding,getLinPars,-1,0,0,double[],1
+DoseFinding,getLinPars,0,0,0,character,1
+DoseFinding,getLinPars,1,0,0,any,1
+DoseFinding,getLinPars,2,0,0,double[],1
+DoseFinding,getLinPars,2,0,1,null,1
+DoseFinding,getLinPars,3,0,0,double,1
+DoseFinding,getLinPars,4,0,0,double,1
+DoseFinding,getLinPars,5,0,0,any,1
+DoseFinding,getLinPars,6,0,0,any,1
+DoseFinding,getPrBnds,-1,0,0,class<`matrix`>,1
+DoseFinding,getPrBnds,0,0,0,list<double[]>,1
+DoseFinding,getResp,-1,0,0,class<`matrix`>,1
+DoseFinding,getResp,0,0,0,class<`Mods`>,1
+DoseFinding,getResp,1,0,0,any,1
+DoseFinding,getStandDR,-1,0,0,double[],1
+DoseFinding,getStandDR,0,0,0,character,1
+DoseFinding,getStandDR,1,0,0,double[],1
+DoseFinding,getStandDR,2,0,0,double[],1
+DoseFinding,getStandDR,3,0,0,any,1
+DoseFinding,getStart,-1,0,0,double[],1
+DoseFinding,getStart,0,0,0,integer,1
+DoseFinding,getZmat,-1,0,0,class<`matrix`>,1
+DoseFinding,getZmat,0,0,0,double[],1
+DoseFinding,getZmat,1,0,0,class<`matrix`>,1
+DoseFinding,getZmat,2,0,0,character,1
+DoseFinding,getZmat,3,0,0,any,1
+DoseFinding,getZmat,4,0,0,any,1
+DoseFinding,getZmat.weighted,-1,0,0,class<`matrix`>,1
+DoseFinding,getZmat.weighted,0,0,0,double[],1
+DoseFinding,getZmat.weighted,1,0,0,class<`matrix`>,1
+DoseFinding,getZmat.weighted,2,0,0,character,1
+DoseFinding,getZmat.weighted,3,0,0,any,1
+DoseFinding,getZmat.weighted,4,0,0,any,1
+DoseFinding,gradCalc,-1,0,0,class<`matrix`>,1
+DoseFinding,gradCalc,0,0,0,character,1
+DoseFinding,gradCalc,1,0,0,any,1
+DoseFinding,gradCalc,2,0,0,double[],1
+DoseFinding,gradCalc,3,0,0,any,1
+DoseFinding,gradCalc,4,0,0,any,1
+DoseFinding,gradCalc,5,0,0,any,1
+DoseFinding,guesst,-1,0,0,double[],1
+DoseFinding,guesst,0,0,0,double[],1
+DoseFinding,guesst,1,0,0,double[],1
+DoseFinding,guesst,2,0,0,character,1
+DoseFinding,guesst,3,0,0,logical,1
+DoseFinding,guesst,4,0,0,logical,1
+DoseFinding,guesst,5,0,0,any,1
+DoseFinding,guesst,6,0,0,any,1
+DoseFinding,guesst,7,0,0,any,1
+DoseFinding,linear,-1,0,0,double[],1
+DoseFinding,linear,0,0,0,double[],1
+DoseFinding,linear,1,0,0,double,1
+DoseFinding,linear,2,0,0,double,1
+DoseFinding,linearGrad,-1,0,0,class<`matrix`>,1
+DoseFinding,linearGrad,0,0,0,double[],1
+DoseFinding,linearGrad,1,0,0,...,1
+DoseFinding,linInt,-1,0,0,double[],1
+DoseFinding,linInt,0,0,0,double[],1
+DoseFinding,linInt,1,0,0,double[],1
+DoseFinding,linInt,2,0,0,double[],1
+DoseFinding,linIntGrad,-1,0,0,class<`matrix`>,1
+DoseFinding,linIntGrad,0,0,0,double[],1
+DoseFinding,linIntGrad,1,0,0,any,1
+DoseFinding,linIntGrad,2,0,0,double[],1
+DoseFinding,linIntGrad,3,0,0,...,1
+DoseFinding,linlog,-1,0,0,double[],1
+DoseFinding,linlog,0,0,0,double[],1
+DoseFinding,linlog,1,0,0,double,1
+DoseFinding,linlog,2,0,0,double,1
+DoseFinding,linlog,3,0,0,double,1
+DoseFinding,linlogGrad,-1,0,0,class<`matrix`>,1
+DoseFinding,linlogGrad,0,0,0,double[],1
+DoseFinding,linlogGrad,1,0,0,double,1
+DoseFinding,linlogGrad,2,0,0,...,1
+DoseFinding,logistic,-1,0,0,double[],1
+DoseFinding,logistic,0,0,0,double[],1
+DoseFinding,logistic,1,0,0,double,1
+DoseFinding,logistic,2,0,0,class<`AsIs`>,1
+DoseFinding,logistic,2,0,1,double,1
+DoseFinding,logistic,3,0,0,double,1
+DoseFinding,logistic,4,0,0,double,1
+DoseFinding,logisticGrad,-1,0,0,class<`matrix`>,1
+DoseFinding,logisticGrad,0,0,0,double[],1
+DoseFinding,logisticGrad,1,0,0,double,1
+DoseFinding,logisticGrad,2,0,0,double,1
+DoseFinding,logisticGrad,3,0,0,double,1
+DoseFinding,logisticGrad,4,0,0,...,1
+DoseFinding,logLik.DRMod,-1,0,0,class<`logLik`>,1
+DoseFinding,logLik.DRMod,0,0,0,class<`DRMod`>,1
+DoseFinding,logLik.DRMod,1,0,0,...,1
+DoseFinding,MCPMod,-1,0,0,class<`MCPMod`>,1
+DoseFinding,MCPMod,0,0,0,any,1
+DoseFinding,MCPMod,1,0,0,any,1
+DoseFinding,MCPMod,2,0,0,class<`data.frame`>,1
+DoseFinding,MCPMod,2,0,1,null,1
+DoseFinding,MCPMod,3,0,0,class<`Mods`>,1
+DoseFinding,MCPMod,4,0,0,null,1
+DoseFinding,MCPMod,4,0,1,class<`matrix`>,1
+DoseFinding,MCPMod,5,0,0,character[],1
+DoseFinding,MCPMod,6,0,0,class<`formula`>,1
+DoseFinding,MCPMod,7,0,0,logical,1
+DoseFinding,MCTtest,-1,0,0,class<`MCTtest`>,1
+DoseFinding,MCTtest,0,0,0,any,1
+DoseFinding,MCTtest,1,0,0,any,1
+DoseFinding,MCTtest,2,0,0,class<`data.frame`>,1
+DoseFinding,MCTtest,2,0,1,null,1
+DoseFinding,MCTtest,3,0,0,any,1
+DoseFinding,MCTtest,4,0,0,null,1
+DoseFinding,MCTtest,4,0,1,class<`matrix`>,1
+DoseFinding,MCTtest,5,0,0,character[],1
+DoseFinding,MCTtest,6,0,0,class<`formula`>,1
+DoseFinding,MCTtest,7,0,0,logical,1
+DoseFinding,modContr,-1,0,0,class<`matrix`>,1
+DoseFinding,modContr,0,0,0,class<`matrix`>,1
+DoseFinding,modContr,1,0,0,null,1
+DoseFinding,modContr,2,0,0,class<`matrix`>,1
+DoseFinding,modContr,3,0,0,logical,1
+DoseFinding,modContr,4,0,0,character,1
+DoseFinding,modContr,5,0,0,any,1
+DoseFinding,modCount,-1,0,0,double,1
+DoseFinding,modCount,0,0,0,class<`Mods`>,1
+DoseFinding,modCount,0,0,1,list<class<`matrix`>>,1
+DoseFinding,modCount,0,0,2,list<double[]>,1
+DoseFinding,modCount,0,0,3,list<double[] | class<`matrix`>>,1
+DoseFinding,modCount,0,0,4,list<null | double[]>,1
+DoseFinding,modCount,0,0,5,list<double[] | null>,1
+DoseFinding,modCount,0,0,6,list<null>,1
+DoseFinding,modCount,0,0,7,list<null | double[] | class<`matrix`>>,1
+DoseFinding,modCount,0,0,8,list<null | double>,1
+DoseFinding,modCount,0,0,9,list<null | class<`matrix`> | double>,1
+DoseFinding,modCount,0,0,10,list<class<`matrix`> | null>,1
+DoseFinding,modCount,1,0,0,logical,1
+DoseFinding,Mods,-1,0,0,class<`Mods`>,1
+DoseFinding,Mods,0,0,0,...,1
+DoseFinding,Mods,1,0,0,double[],1
+DoseFinding,Mods,2,0,0,double,1
+DoseFinding,Mods,3,0,0,any,1
+DoseFinding,Mods,4,0,0,any,1
+DoseFinding,Mods,5,0,0,null,1
+DoseFinding,Mods,5,0,1,list<double>,1
+DoseFinding,Mods,6,0,0,logical,1
+DoseFinding,mvtnorm.control,-1,0,0,class<`GenzBretz`>,1
+DoseFinding,mvtnorm.control,0,0,0,double,1
+DoseFinding,mvtnorm.control,1,0,0,double,1
+DoseFinding,mvtnorm.control,2,0,0,double,1
+DoseFinding,mvtnorm.control,3,0,0,null,1
+DoseFinding,nPars,-1,0,0,double[],1
+DoseFinding,nPars,0,0,0,character[],1
+DoseFinding,optContr,-1,0,0,class<`optContr`>,1
+DoseFinding,optContr,0,0,0,class<`Mods`>,1
+DoseFinding,optContr,1,0,0,any,1
+DoseFinding,optContr,2,0,0,any,1
+DoseFinding,optContr,3,0,0,any,1
+DoseFinding,optContr,4,0,0,logical,1
+DoseFinding,optContr,5,0,0,character[],1
+DoseFinding,optDesign,-1,0,0,class<`DRdesign`>,1
+DoseFinding,optDesign,0,0,0,any,1
+DoseFinding,optDesign,1,0,0,any,1
+DoseFinding,optDesign,2,0,0,any,1
+DoseFinding,optDesign,3,0,0,character[],1
+DoseFinding,optDesign,4,0,0,any,1
+DoseFinding,optDesign,5,0,0,logical,1
+DoseFinding,optDesign,6,0,0,any,1
+DoseFinding,optDesign,7,0,0,double[],1
+DoseFinding,optFunc,-1,0,0,double,1
+DoseFinding,optFunc,0,0,0,double[],1
+DoseFinding,optFunc,1,0,0,double[],1
+DoseFinding,optFunc,2,0,0,integer[],1
+DoseFinding,optFunc,3,0,0,integer,1
+DoseFinding,optFunc,4,0,0,double[],1
+DoseFinding,optFunc,5,0,0,integer,1
+DoseFinding,optFunc,6,0,0,double,1
+DoseFinding,optFunc,7,0,0,double[],1
+DoseFinding,optGrid,-1,0,0,list<double[]>,1
+DoseFinding,optGrid,0,0,0,character,1
+DoseFinding,optGrid,1,0,0,double,1
+DoseFinding,optGrid,2,0,0,class<`matrix`>,1
+DoseFinding,optGrid,3,0,0,list<double>,1
+DoseFinding,optGrid,4,0,0,double[],1
+DoseFinding,optGrid,5,0,0,character,1
+DoseFinding,optGrid,6,0,0,any,1
+DoseFinding,optGrid,7,0,0,double[],1
+DoseFinding,optLoc,-1,0,0,list<double[]>,1
+DoseFinding,optLoc,0,0,0,character,1
+DoseFinding,optLoc,1,0,0,double,1
+DoseFinding,optLoc,2,0,0,class<`matrix`>,1
+DoseFinding,optLoc,3,0,0,double[],1
+DoseFinding,optLoc,4,0,0,any,1
+DoseFinding,optLoc,5,0,0,double[],1
+DoseFinding,optLoc,6,0,0,any,1
+DoseFinding,optLoc,7,0,0,any,1
+DoseFinding,plot.bFitMod,-1,0,0,list<double[] | class<`matrix`>>,1
+DoseFinding,plot.bFitMod,0,0,0,class<`bFitMod`>,1
+DoseFinding,plot.bFitMod,1,0,0,character[],1
+DoseFinding,plot.bFitMod,2,0,0,double[],1
+DoseFinding,plot.bFitMod,3,0,0,character[],1
+DoseFinding,plot.bFitMod,4,0,0,double,1
+DoseFinding,plot.bFitMod,5,0,0,double,1
+DoseFinding,plot.bFitMod,6,0,0,...,1
+DoseFinding,plot.DRdesign,-1,0,0,null,1
+DoseFinding,plot.DRdesign,0,0,0,class<`DRdesign`>,1
+DoseFinding,plot.DRdesign,1,0,0,class<`Mods`>,1
+DoseFinding,plot.DRdesign,2,0,0,double,1
+DoseFinding,plot.DRdesign,3,0,0,character,1
+DoseFinding,plot.DRdesign,4,0,0,...,1
+DoseFinding,plot.DRMod,-1,0,0,class<`trellis`>,1
+DoseFinding,plot.DRMod,0,0,0,class<`DRMod`>,1
+DoseFinding,plot.DRMod,1,0,0,logical,1
+DoseFinding,plot.DRMod,2,0,0,double,1
+DoseFinding,plot.DRMod,3,0,0,character[],1
+DoseFinding,plot.DRMod,4,0,0,logical,1
+DoseFinding,plot.DRMod,5,0,0,double,1
+DoseFinding,plot.DRMod,6,0,0,double,1
+DoseFinding,plot.DRMod,7,0,0,...,1
+DoseFinding,plotFunc,-1,0,0,class<`trellis`>,1
+DoseFinding,plotFunc,0,0,0,class<`DRMod`>,1
+DoseFinding,plotFunc,0,0,1,class<`MCPMod`>,1
+DoseFinding,plotFunc,1,0,0,logical,1
+DoseFinding,plotFunc,2,0,0,any,1
+DoseFinding,plotFunc,3,0,0,character[],1
+DoseFinding,plotFunc,4,0,0,logical,1
+DoseFinding,plotFunc,5,0,0,double,1
+DoseFinding,plotFunc,6,0,0,double,1
+DoseFinding,plotFunc,7,0,0,...,1
+DoseFinding,plot.MCPMod,-1,0,0,class<`trellis`>,1
+DoseFinding,plot.MCPMod,0,0,0,class<`MCPMod`>,1
+DoseFinding,plot.MCPMod,1,0,0,logical,1
+DoseFinding,plot.MCPMod,2,0,0,double,1
+DoseFinding,plot.MCPMod,3,0,0,character,1
+DoseFinding,plot.MCPMod,4,0,0,logical,1
+DoseFinding,plot.MCPMod,5,0,0,double,1
+DoseFinding,plot.MCPMod,6,0,0,double,1
+DoseFinding,plot.MCPMod,7,0,0,...,1
+DoseFinding,plotModels,-1,0,0,class<`trellis`>,1
+DoseFinding,plotModels,0,0,0,class<`Mods`>,1
+DoseFinding,plotModels,1,0,0,double,1
+DoseFinding,plotModels,2,0,0,logical,1
+DoseFinding,plotModels,3,0,0,character,1
+DoseFinding,plotModels,4,0,0,character,1
+DoseFinding,plotModels,5,0,0,character[],1
+DoseFinding,plotModels,5,0,1,null,1
+DoseFinding,plotModels,6,0,0,logical,1
+DoseFinding,plotModels,7,0,0,any,1
+DoseFinding,plot.Mods,-1,0,0,class<`trellis`>,1
+DoseFinding,plot.Mods,0,0,0,class<`Mods`>,1
+DoseFinding,plot.Mods,1,0,0,double,1
+DoseFinding,plot.Mods,2,0,0,logical,1
+DoseFinding,plot.Mods,3,0,0,character,1
+DoseFinding,plot.Mods,4,0,0,character,1
+DoseFinding,plot.Mods,5,0,0,character[],1
+DoseFinding,plot.Mods,5,0,1,null,1
+DoseFinding,plot.Mods,6,0,0,logical,1
+DoseFinding,plot.Mods,7,0,0,any,1
+DoseFinding,plot.optContr,-1,0,0,class<`trellis`>,1
+DoseFinding,plot.optContr,0,0,0,class<`optContr`>,1
+DoseFinding,plot.optContr,1,0,0,logical,1
+DoseFinding,plot.optContr,2,0,0,character,1
+DoseFinding,plot.optContr,3,0,0,null,1
+DoseFinding,plot.optContr,4,0,0,character[],1
+DoseFinding,plot.optContr,5,0,0,...,1
+DoseFinding,powCalc,-1,0,0,double[],1
+DoseFinding,powCalc,0,0,0,character,1
+DoseFinding,powCalc,1,0,0,double,1
+DoseFinding,powCalc,2,0,0,double,1
+DoseFinding,powCalc,3,0,0,class<`matrix`>,1
+DoseFinding,powCalc,4,0,0,class<`matrix`>,1
+DoseFinding,powCalc,5,0,0,class<`GenzBretz`>,1
+DoseFinding,powMCT,-1,0,0,double[],1
+DoseFinding,powMCT,0,0,0,class<`optContr`>,1
+DoseFinding,powMCT,1,0,0,double,1
+DoseFinding,powMCT,2,0,0,class<`Mods`>,1
+DoseFinding,powMCT,3,0,0,double,1
+DoseFinding,powMCT,4,0,0,double,1
+DoseFinding,powMCT,5,0,0,any,1
+DoseFinding,powMCT,6,0,0,logical,1
+DoseFinding,powMCT,7,0,0,character[],1
+DoseFinding,predict.bFitMod,-1,0,0,class<`matrix`>,1
+DoseFinding,predict.bFitMod,0,0,0,class<`bFitMod`>,1
+DoseFinding,predict.bFitMod,1,0,0,character[],1
+DoseFinding,predict.bFitMod,2,0,0,class<`function`>,1
+DoseFinding,predict.bFitMod,3,0,0,double[],1
+DoseFinding,predict.bFitMod,4,0,0,double,1
+DoseFinding,predict.bFitMod,5,0,0,...,1
+DoseFinding,predict.DRMod,-1,0,0,double[],1
+DoseFinding,predict.DRMod,-1,0,1,list<double[]>,1
+DoseFinding,predict.DRMod,0,0,0,class<`summary.DRMod`>,1
+DoseFinding,predict.DRMod,0,0,1,class<`DRMod`>,1
+DoseFinding,predict.DRMod,1,0,0,character,1
+DoseFinding,predict.DRMod,2,0,0,null,1
+DoseFinding,predict.DRMod,2,0,1,class<`data.frame`>,1
+DoseFinding,predict.DRMod,3,0,0,null,1
+DoseFinding,predict.DRMod,3,0,1,double[],1
+DoseFinding,predict.DRMod,4,0,0,logical,1
+DoseFinding,predict.DRMod,5,0,0,...,1
+DoseFinding,predict.MCPMod,-1,0,0,list<double[]>,1
+DoseFinding,predict.MCPMod,-1,0,1,list<list<double[]>>,1
+DoseFinding,predict.MCPMod,0,0,0,class<`MCPMod`>,1
+DoseFinding,predict.MCPMod,1,0,0,character,1
+DoseFinding,predict.MCPMod,2,0,0,null,1
+DoseFinding,predict.MCPMod,3,0,0,double[],1
+DoseFinding,predict.MCPMod,4,0,0,logical,1
+DoseFinding,predict.MCPMod,5,0,0,...,1
+DoseFinding,predSamples,-1,0,0,class<`matrix`>,1
+DoseFinding,predSamples,0,0,0,class<`matrix`>,1
+DoseFinding,predSamples,1,0,0,logical,1
+DoseFinding,predSamples,2,0,0,double[],1
+DoseFinding,predSamples,3,0,0,logical,1
+DoseFinding,predSamples,4,0,0,character,1
+DoseFinding,predSamples,5,0,0,any,1
+DoseFinding,predSamples,6,0,0,any,1
+DoseFinding,predSamples,7,0,0,any,1
+DoseFinding,print.MCTtest,-1,0,0,null,1
+DoseFinding,print.MCTtest,0,0,0,class<`MCTtest`>,1
+DoseFinding,print.MCTtest,1,0,0,double,1
+DoseFinding,print.MCTtest,2,0,0,double,1
+DoseFinding,print.MCTtest,3,0,0,...,1
+DoseFinding,print.summary.DRMod,-1,0,0,class<`matrix`>,1
+DoseFinding,print.summary.DRMod,-1,0,1,null,1
+DoseFinding,print.summary.DRMod,0,0,0,class<`summary.DRMod`>,1
+DoseFinding,print.summary.DRMod,1,0,0,double,1
+DoseFinding,print.summary.DRMod,2,0,0,any,1
+DoseFinding,print.summary.DRMod,3,0,0,...,1
+DoseFinding,print.summary.MCPMod,-1,0,0,double[],1
+DoseFinding,print.summary.MCPMod,0,0,0,class<`summary.MCPMod`>,1
+DoseFinding,print.summary.MCPMod,1,0,0,...,1
+DoseFinding,projPrBnds,-1,0,0,double,1
+DoseFinding,projPrBnds,0,0,0,double,1
+DoseFinding,projPrBnds,1,0,0,double,1
+DoseFinding,projPrBnds,2,0,0,double,1
+DoseFinding,pValues,-1,0,0,^double[],1
+DoseFinding,pValues,0,0,0,class<`matrix`>,1
+DoseFinding,pValues,1,0,0,class<`matrix`>,1
+DoseFinding,pValues,2,0,0,double,1
+DoseFinding,pValues,3,0,0,double[],1
+DoseFinding,pValues,4,0,0,character,1
+DoseFinding,pValues,5,0,0,class<`GenzBretz`>,1
+DoseFinding,quadratic,-1,0,0,double[],1
+DoseFinding,quadratic,0,0,0,double[],1
+DoseFinding,quadratic,1,0,0,double,1
+DoseFinding,quadratic,2,0,0,double,1
+DoseFinding,quadratic,3,0,0,double,1
+DoseFinding,quadraticGrad,-1,0,0,class<`matrix`>,1
+DoseFinding,quadraticGrad,0,0,0,double[],1
+DoseFinding,quadraticGrad,1,0,0,...,1
+DoseFinding,rndDesign,-1,0,0,double[],1
+DoseFinding,rndDesign,0,0,0,class<`DRdesign`>,1
+DoseFinding,rndDesign,1,0,0,double,1
+DoseFinding,rndDesign,2,0,0,double,1
+DoseFinding,sepCoef,-1,0,0,list<double[]>,1
+DoseFinding,sepCoef,0,0,0,class<`DRMod`>,1
+DoseFinding,sepCoef,0,0,1,class<`summary.DRMod`>,1
+DoseFinding,sigEmax,-1,0,0,double[],1
+DoseFinding,sigEmax,0,0,0,double[],1
+DoseFinding,sigEmax,1,0,0,double,1
+DoseFinding,sigEmax,2,0,0,double,1
+DoseFinding,sigEmax,3,0,0,double,1
+DoseFinding,sigEmax,4,0,0,double,1
+DoseFinding,sigEmaxGrad,-1,0,0,class<`matrix`>,1
+DoseFinding,sigEmaxGrad,0,0,0,double[],1
+DoseFinding,sigEmaxGrad,1,0,0,double,1
+DoseFinding,sigEmaxGrad,2,0,0,double,1
+DoseFinding,sigEmaxGrad,3,0,0,double,1
+DoseFinding,sigEmaxGrad,4,0,0,...,1
+DoseFinding,summary.DRMod,-1,0,0,class<`matrix`>,1
+DoseFinding,summary.DRMod,-1,0,1,null,1
+DoseFinding,summary.DRMod,0,0,0,class<`DRMod`>,1
+DoseFinding,summary.DRMod,1,0,0,double,1
+DoseFinding,summary.DRMod,2,0,0,...,1
+DoseFinding,summary.MCPMod,-1,0,0,double[],1
+DoseFinding,summary.MCPMod,0,0,0,class<`MCPMod`>,1
+DoseFinding,summary.MCPMod,1,0,0,...,1
+DoseFinding,TD,-1,0,0,^double[],1
+DoseFinding,TD,-1,0,1,null,1
+DoseFinding,TD,0,0,0,class<`bFitMod`>,1
+DoseFinding,TD,0,0,1,class<`DRMod`>,1
+DoseFinding,TD,0,0,2,class<`Mods`>,1
+DoseFinding,TD,1,0,0,double,1
+DoseFinding,TD,2,0,0,character[],1
+DoseFinding,TD,3,0,0,character[],1
+DoseFinding,TD,4,0,0,any,1
+DoseFinding,transTrig,-1,0,0,double[],1
+DoseFinding,transTrig,0,0,0,double[],1
+DoseFinding,transTrig,1,0,0,integer,1
+DoseFinding,vcov.DRMod,-1,0,0,class<`matrix`>,1
+DoseFinding,vcov.DRMod,0,0,0,class<`summary.DRMod`>,1
+DoseFinding,vcov.DRMod,0,0,1,class<`DRMod`>,1
+DoseFinding,vcov.DRMod,1,0,0,...,1
+DoseFinding,which.is.max,-1,0,0,integer,1
+DoseFinding,which.is.max,0,0,0,double[],1
+FME,collFun,-1,0,0,class<`matrix`>,1
+FME,collFun,0,0,0,class<`matrix`>,1
+FME,collFun,1,0,0,class<`matrix`>,1
+FME,collFun,2,0,0,integer,1
+FME,collFun,3,0,0,double,1
+FME,collin,-1,0,0,"class<`collin`, `data.frame`>",1
+FME,collin,0,0,0,"class<`data.frame`, `sensFun`>",1
+FME,collin,0,0,1,class<`matrix`>,1
+FME,collin,1,0,0,character[],1
+FME,collin,1,0,1,double[],1
+FME,collin,1,0,2,null,1
+FME,collin,2,0,0,null,1
+FME,collin,2,0,1,double,1
+FME,collin,3,0,0,null,1
+FME,collin,4,0,0,double,1
+FME,combin,-1,0,0,class<`matrix`>,1
+FME,combin,0,0,0,double,1
+FME,combin,1,0,0,integer[],1
+FME,convert2wide,-1,0,0,class<`data.frame`>,1
+FME,convert2wide,0,0,0,class<`data.frame`>,1
+FME,cross2long,-1,0,0,class<`data.frame`>,1
+FME,cross2long,0,0,0,class<`data.frame`>,1
+FME,cross2long,1,0,0,any,1
+FME,cross2long,2,0,0,any,1
+FME,cross2long,3,0,0,any,1
+FME,cross2long,4,0,0,logical,1
+FME,cross2long,5,0,0,logical,1
+FME,expanddots,-1,0,0,character[],1
+FME,expanddots,-1,0,1,integer[],1
+FME,expanddots,0,0,0,character,1
+FME,expanddots,0,0,1,null,1
+FME,expanddots,1,0,0,any,1
+FME,expanddots,2,0,0,integer,1
+FME,expanddotslist,-1,0,0,list<double[]>,1
+FME,expanddotslist,-1,0,1,null,1
+FME,expanddotslist,0,0,0,list<double[]>,1
+FME,expanddotslist,0,0,1,null,1
+FME,expanddotslist,1,0,0,any,1
+FME,extractdots,-1,0,0,list<any>,1
+FME,extractdots,0,0,0,list<any>,1
+FME,extractdots,1,0,0,any,1
+FME,findvar,-1,0,0,integer[],1
+FME,findvar,0,0,0,double[],1
+FME,findvar,0,0,1,list<double>,1
+FME,findvar,1,0,0,character[],1
+FME,findvar,2,0,0,character,1
+FME,gaussianWeights,-1,0,0,class<`data.frame`>,1
+FME,gaussianWeights,0,0,0,class<`data.frame`>,1
+FME,gaussianWeights,1,0,0,any,1
+FME,gaussianWeights,2,0,0,any,1
+FME,gaussianWeights,3,0,0,double[],1
+FME,gaussianWeights,4,0,0,double,1
+FME,gaussianWeights,5,0,0,character,1
+FME,gaussianWeights,6,0,0,any,1
+FME,gaussianWeights,7,0,0,any,1
+FME,Grid,-1,0,0,class<`matrix`>,1
+FME,Grid,0,0,0,class<`data.frame`>,1
+FME,Grid,1,0,0,double,1
+FME,Latinhyper,-1,0,0,class<`matrix`>,1
+FME,Latinhyper,0,0,0,class<`data.frame`>,1
+FME,Latinhyper,1,0,0,double,1
+FME,mergeObs,-1,0,0,class<`data.frame`>,1
+FME,mergeObs,0,0,0,class<`data.frame`>,1
+FME,mergeObs,1,0,0,class<`matrix`>,1
+FME,mergeObs,1,0,1,class<`data.frame`>,1
+FME,modCost,-1,0,0,class<`modCost`>,1
+FME,modCost,0,0,0,class<`data.frame`>,1
+FME,modCost,0,0,1,"class<`deSolve`, `matrix`>",1
+FME,modCost,0,0,2,class<`matrix`>,1
+FME,modCost,1,0,0,class<`matrix`>,1
+FME,modCost,1,0,1,class<`data.frame`>,1
+FME,modCost,2,0,0,character,1
+FME,modCost,3,0,0,null,1
+FME,modCost,3,0,1,character,1
+FME,modCost,4,0,0,null,1
+FME,modCost,4,0,1,character,1
+FME,modCost,5,0,0,character,1
+FME,modCost,6,0,0,logical,1
+FME,modCost,7,0,0,class<`modCost`>,1
+FME,modCost,7,0,1,null,1
+FME,modCost,8,0,0,...,1
+FME,modCRL,-1,0,0,"class<`data.frame`, `modCRL`>",1
+FME,modCRL,0,0,0,class<`function`>,1
+FME,modCRL,1,0,0,null,1
+FME,modCRL,2,0,0,null,1
+FME,modCRL,3,0,0,character,1
+FME,modCRL,4,0,0,null,1
+FME,modCRL,5,0,0,class<`matrix`>,1
+FME,modCRL,6,0,0,null,1
+FME,modCRL,7,0,0,null,1
+FME,modCRL,8,0,0,double,1
+FME,modCRL,9,0,0,...,1
+FME,modFit,-1,0,0,class<`modFit`>,1
+FME,modFit,0,0,0,class<`function`>,1
+FME,modFit,1,0,0,double[],1
+FME,modFit,2,0,0,...,1
+FME,modFit,3,0,0,double[],1
+FME,modFit,4,0,0,double[],1
+FME,modFit,5,0,0,character[],1
+FME,modFit,6,0,0,class<`function`>,1
+FME,modFit,6,0,1,null,1
+FME,modFit,7,0,0,list<any>,1
+FME,modFit,8,0,0,logical,1
+FME,Norm,-1,0,0,class<`matrix`>,1
+FME,Norm,0,0,0,integer[],1
+FME,Norm,1,0,0,class<`matrix`>,1
+FME,Norm,2,0,0,class<`data.frame`>,1
+FME,Norm,2,0,1,null,1
+FME,Norm,3,0,0,double,1
+FME,obsplot,-1,0,0,null,1
+FME,obsplot,0,0,0,class<`data.frame`>,1
+FME,obsplot,1,0,0,...,1
+FME,obsplot,2,0,0,character[],1
+FME,obsplot,2,0,1,integer[],1
+FME,obsplot,2,0,2,null,1
+FME,obsplot,3,0,0,logical[],1
+FME,obsplot,4,0,0,null,1
+FME,pairs.sensFun,-1,0,0,null,1
+FME,pairs.sensFun,0,0,0,"class<`data.frame`, `sensFun`>",1
+FME,pairs.sensFun,1,0,0,character[],1
+FME,pairs.sensFun,1,0,1,null,1
+FME,pairs.sensFun,2,0,0,...,1
+FME,plot.collin,-1,0,0,null,1
+FME,plot.collin,0,0,0,"class<`collin`, `data.frame`>",1
+FME,plot.collin,1,0,0,...,1
+FME,plot.modCRL,-1,0,0,null,1
+FME,plot.modCRL,0,0,0,"class<`data.frame`, `modCRL`>",1
+FME,plot.modCRL,1,0,0,character[],1
+FME,plot.modCRL,1,0,1,null,1
+FME,plot.modCRL,2,0,0,logical,1
+FME,plot.modCRL,3,0,0,null,1
+FME,plot.modCRL,4,0,0,...,1
+FME,plot.sensFun,-1,0,0,list<list<double[]>>,1
+FME,plot.sensFun,0,0,0,"class<`data.frame`, `sensFun`>",1
+FME,plot.sensFun,1,0,0,character[],1
+FME,plot.sensFun,1,0,1,null,1
+FME,plot.sensFun,2,0,0,character,1
+FME,plot.sensFun,3,0,0,null,1
+FME,plot.sensFun,4,0,0,...,1
+FME,plot.summary.sensFun,-1,0,0,list<integer[]>,1
+FME,plot.summary.sensFun,0,0,0,"class<`data.frame`, `summary.sensFun`>",1
+FME,plot.summary.sensFun,1,0,0,integer[],1
+FME,plot.summary.sensFun,2,0,0,...,1
+FME,plot.summary.sensRange,-1,0,0,list<list<double[]>>,1
+FME,plot.summary.sensRange,0,0,0,"class<`data.frame`, `summary.sensRange`>",1
+FME,plot.summary.sensRange,1,0,0,logical,1
+FME,plot.summary.sensRange,2,0,0,character,1
+FME,plot.summary.sensRange,2,0,1,null,1
+FME,plot.summary.sensRange,3,0,0,character,1
+FME,plot.summary.sensRange,4,0,0,character[],1
+FME,plot.summary.sensRange,5,0,0,logical,1
+FME,plot.summary.sensRange,6,0,0,null,1
+FME,plot.summary.sensRange,7,0,0,null,1
+FME,plot.summary.sensRange,7,0,1,class<`matrix`>,1
+FME,plot.summary.sensRange,8,0,0,any,1
+FME,plot.summary.sensRange,9,0,0,...,1
+FME,pseudoOptim,-1,0,0,list<double[] | class<`matrix`>>,1
+FME,pseudoOptim,0,0,0,class<`function`>,1
+FME,pseudoOptim,1,0,0,double[],1
+FME,pseudoOptim,2,0,0,...,1
+FME,pseudoOptim,3,0,0,double[],1
+FME,pseudoOptim,4,0,0,double[],1
+FME,pseudoOptim,5,0,0,double[],1
+FME,Range,-1,0,0,double[],1
+FME,Range,0,0,0,null,1
+FME,Range,1,0,0,^double[],1
+FME,Range,2,0,0,integer,1
+FME,residuals.modFit,-1,0,0,double[],1
+FME,residuals.modFit,0,0,0,class<`modFit`>,1
+FME,residuals.modFit,1,0,0,...,1
+FME,selectvar,-1,0,0,double[],1
+FME,selectvar,0,0,0,double[],1
+FME,selectvar,0,0,1,character[],1
+FME,selectvar,0,0,2,null,1
+FME,selectvar,1,0,0,character[],1
+FME,selectvar,2,0,0,character,1
+FME,selectvar,3,0,0,logical,1
+FME,selectvar,4,0,0,logical,1
+FME,sensFun,-1,0,0,"class<`data.frame`, `sensFun`>",1
+FME,sensFun,0,0,0,class<`function`>,1
+FME,sensFun,1,0,0,list<double>,1
+FME,sensFun,2,0,0,character[],1
+FME,sensFun,2,0,1,null,1
+FME,sensFun,3,0,0,character[],1
+FME,sensFun,4,0,0,double,1
+FME,sensFun,5,0,0,null,1
+FME,sensFun,6,0,0,double,1
+FME,sensFun,7,0,0,double,1
+FME,sensFun,8,0,0,...,1
+FME,sensRange,-1,0,0,"class<`data.frame`, `sensRange`>",1
+FME,sensRange,0,0,0,class<`function`>,1
+FME,sensRange,1,0,0,double,1
+FME,sensRange,1,0,1,list<double>,1
+FME,sensRange,2,0,0,null,1
+FME,sensRange,2,0,1,character[],1
+FME,sensRange,3,0,0,character,1
+FME,sensRange,4,0,0,null,1
+FME,sensRange,5,0,0,class<`matrix`>,1
+FME,sensRange,5,0,1,class<`data.frame`>,1
+FME,sensRange,6,0,0,null,1
+FME,sensRange,7,0,0,null,1
+FME,sensRange,8,0,0,null,1
+FME,sensRange,8,0,1,double,1
+FME,sensRange,9,0,0,double,1
+FME,sensRange,10,0,0,...,1
+FME,setdots,-1,0,0,list<any>,1
+FME,setdots,0,0,0,list<any>,1
+FME,setdots,1,0,0,any,1
+FME,setplotpar,-1,0,0,logical,1
+FME,setplotpar,0,0,0,character[],1
+FME,setplotpar,0,0,1,null,1
+FME,setplotpar,1,0,0,any,1
+FME,setplotpar,2,0,0,integer,1
+FME,setplotpar,3,0,0,null,1
+FME,summary.modFit,-1,0,0,class<`summary.modFit`>,1
+FME,summary.modFit,0,0,0,class<`modFit`>,1
+FME,summary.modFit,1,0,0,logical,1
+FME,summary.modFit,2,0,0,...,1
+FME,summary.sensFun,-1,0,0,"class<`data.frame`, `summary.sensFun`>",1
+FME,summary.sensFun,0,0,0,"class<`data.frame`, `sensFun`>",1
+FME,summary.sensFun,1,0,0,logical,1
+FME,summary.sensFun,2,0,0,...,1
+FME,summary.sensRange,-1,0,0,"class<`data.frame`, `summary.sensRange`>",1
+FME,summary.sensRange,0,0,0,"class<`data.frame`, `sensRange`>",1
+FME,summary.sensRange,1,0,0,...,1
+FME,Unif,-1,0,0,class<`matrix`>,1
+FME,Unif,0,0,0,class<`data.frame`>,1
+FME,Unif,0,0,1,class<`matrix`>,1
+FME,Unif,1,0,0,double,1
+Formula,as.Formula,-1,0,0,"class<`Formula`, `formula`>",1
+Formula,as.Formula,0,0,0,class<`formula`>,1
+Formula,as.Formula,1,0,0,...,1
+Formula,as.Formula.formula,-1,0,0,"class<`Formula`, `formula`>",1
+Formula,as.Formula.formula,0,0,0,class<`formula`>,1
+Formula,as.Formula.formula,1,0,0,...,1
+Formula,as.Formula.formula,2,0,0,any,1
+Formula,c_formula,-1,0,0,class<`call`>,1
+Formula,c_formula,-1,0,1,class<`formula`>,1
+Formula,c_formula,0,0,0,class<`call`>,1
+Formula,c_formula,0,0,1,class<`name`>,1
+Formula,c_formula,0,0,2,null,1
+Formula,c_formula,1,0,0,class<`call`>,1
+Formula,c_formula,1,0,1,class<`name`>,1
+Formula,c_formula,1,0,2,double,1
+Formula,c_formula,2,0,0,character,1
+Formula,Formula,-1,0,0,"class<`Formula`, `formula`>",1
+Formula,Formula,0,0,0,class<`formula`>,1
+Formula,formula.Formula,-1,0,0,class<`formula`>,1
+Formula,formula.Formula,0,0,0,"class<`Formula`, `formula`>",1
+Formula,formula.Formula,1,0,0,double,1
+Formula,formula.Formula,1,0,1,logical[],1
+Formula,formula.Formula,1,0,2,null,1
+Formula,formula.Formula,2,0,0,double,1
+Formula,formula.Formula,2,0,1,integer[],1
+Formula,formula.Formula,2,0,2,null,1
+Formula,formula.Formula,3,0,0,logical[],1
+Formula,formula.Formula,4,0,0,logical,1
+Formula,formula.Formula,5,0,0,logical,1
+Formula,formula.Formula,6,0,0,...,1
+Formula,has_dot,-1,0,0,logical,1
+Formula,has_dot,0,0,0,class<`formula`>,1
+Formula,has_dot,0,0,1,"class<`Formula`, `formula`>",1
+Formula,length.Formula,-1,0,0,integer[],1
+Formula,length.Formula,0,0,0,"class<`Formula`, `formula`>",1
+Formula,model.frame.Formula,-1,0,0,class<`data.frame`>,1
+Formula,model.frame.Formula,0,0,0,"class<`Formula`, `formula`>",1
+Formula,model.frame.Formula,1,0,0,class<`data.frame`>,1
+Formula,model.frame.Formula,2,0,0,...,1
+Formula,model.frame.Formula,3,0,0,null,1
+Formula,model.frame.Formula,4,0,0,null,1
+Formula,model.frame.Formula,5,0,0,character,1
+Formula,model.matrix.Formula,-1,0,0,class<`matrix`>,1
+Formula,model.matrix.Formula,0,0,0,"class<`Formula`, `formula`>",1
+Formula,model.matrix.Formula,1,0,0,class<`data.frame`>,1
+Formula,model.matrix.Formula,2,0,0,...,1
+Formula,model.matrix.Formula,3,0,0,null,1
+Formula,model.matrix.Formula,3,0,1,double,1
+Formula,model.matrix.Formula,4,0,0,double,1
+Formula,model.matrix.Formula,5,0,0,character,1
+Formula,model.part,-1,0,0,class<`data.frame`>,1
+Formula,model.part,-1,0,1,double[],1
+Formula,model.part,0,0,0,"class<`Formula`, `formula`>",1
+Formula,model.part,1,0,0,...,1
+Formula,model.part.Formula,-1,0,0,class<`data.frame`>,1
+Formula,model.part.Formula,-1,0,1,double[],1
+Formula,model.part.Formula,0,0,0,"class<`Formula`, `formula`>",1
+Formula,model.part.Formula,1,0,0,class<`data.frame`>,1
+Formula,model.part.Formula,2,0,0,double,1
+Formula,model.part.Formula,3,0,0,double,1
+Formula,model.part.Formula,4,0,0,logical,1
+Formula,model.part.Formula,5,0,0,logical,1
+Formula,model.part.Formula,6,0,0,null,1
+Formula,model.part.Formula,7,0,0,...,1
+Formula,paste_formula,-1,0,0,class<`formula`>,1
+Formula,paste_formula,0,0,0,class<`call`>,1
+Formula,paste_formula,0,0,1,list<any>,1
+Formula,paste_formula,0,0,2,null,1
+Formula,paste_formula,1,0,0,class<`call`>,1
+Formula,paste_formula,1,0,1,class<`name`>,1
+Formula,paste_formula,1,0,2,list<any>,1
+Formula,paste_formula,2,0,0,character,1
+Formula,paste_formula,3,0,0,character,1
+Formula,simplify_to_formula,-1,0,0,class<`formula`>,1
+Formula,simplify_to_formula,0,0,0,"class<`Formula`, `formula`>",1
+Formula,simplify_to_formula,1,0,0,double,1
+Formula,simplify_to_formula,1,0,1,logical[],1
+Formula,simplify_to_formula,1,0,2,null,1
+Formula,simplify_to_formula,2,0,0,double,1
+Formula,simplify_to_formula,2,0,1,null,1
+Formula,split_formula,-1,0,0,list<list<class<`name`> | class<`call`>>>,1
+Formula,split_formula,-1,0,1,list<list<class<`name`>>>,1
+Formula,split_formula,-1,0,2,list<null | list<class<`call`>>>,1
+Formula,split_formula,-1,0,3,list<null | list<class<`name`>>>,1
+Formula,split_formula,-1,0,4,list<list<class<`call`>>>,1
+Formula,split_formula,-1,0,5,list<list<class<`call`> | class<`name`> | class<`call`>>>,1
+Formula,split_formula,-1,0,6,list<list<class<`call`> | class<`name`> | class<`name`>>>,1
+Formula,split_formula,-1,0,7,list<list<class<`call`> | class<`name`>>>,1
+Formula,split_formula,-1,0,8,list<list<class<`call`> | double>>,1
+Formula,split_formula,-1,0,9,list<list<class<`name`> | class<`call`> | class<`call`>>>,1
+Formula,split_formula,-1,0,10,list<list<class<`name`> | class<`call`> | class<`name`>>>,1
+Formula,split_formula,-1,0,11,list<list<class<`name`> | class<`call`> | class<`call`> | class<`name`>>>,1
+Formula,split_formula,0,0,0,class<`formula`>,1
+Formula,terms.Formula,-1,0,0,any,1
+Formula,terms.Formula,0,0,0,"class<`Formula`, `formula`>",1
+Formula,terms.Formula,1,0,0,...,1
+Formula,terms.Formula,2,0,0,double,1
+Formula,terms.Formula,2,0,1,logical[],1
+Formula,terms.Formula,2,0,2,null,1
+Formula,terms.Formula,3,0,0,double,1
+Formula,terms.Formula,3,0,1,null,1
+Formula,terms.Formula,4,0,0,any,1
+Formula,update.Formula,-1,0,0,"class<`Formula`, `formula`>",1
+Formula,update.Formula,0,0,0,"class<`Formula`, `formula`>",1
+Formula,update.Formula,1,0,0,class<`formula`>,1
+Formula,update.Formula,2,0,0,...,1
+GGally,add_and_overwrite_aes,-1,0,0,class<`uneval`>,1
+GGally,add_and_overwrite_aes,0,0,0,class<`uneval`>,1
+GGally,add_and_overwrite_aes,1,0,0,class<`uneval`>,1
+GGally,add_and_overwrite_aes,1,0,1,null,1
+GGally,add_bottom_axis,-1,0,0,"class<`gDesc`, `gTree`, `grob`, `gtable`>",1
+GGally,add_bottom_axis,0,0,0,"class<`gDesc`, `gTree`, `grob`, `gtable`>",1
+GGally,add_bottom_axis,1,0,0,"class<`gDesc`, `gTree`, `grob`, `gtable`>",1
+GGally,add_bottom_axis,2,0,0,logical,1
+GGally,add_bottom_axis,3,0,0,integer,1
+GGally,add_gg_info,-1,0,0,"class<`gg`, `ggplot`>",1
+GGally,add_gg_info,0,0,0,"class<`gg`, `ggplot`>",1
+GGally,add_gg_info,1,0,0,null,1
+GGally,add_labels_to_ggmatrix,-1,0,0,"class<`gg`, `ggmatrix`>",1
+GGally,add_labels_to_ggmatrix,0,0,0,"class<`gg`, `ggmatrix`>",1
+GGally,add_labels_to_ggmatrix,1,0,0,class<`labels`>,1
+GGally,add_left_axis,-1,0,0,"class<`gDesc`, `gTree`, `grob`, `gtable`>",1
+GGally,add_left_axis,0,0,0,"class<`gDesc`, `gTree`, `grob`, `gtable`>",1
+GGally,add_left_axis,1,0,0,"class<`gDesc`, `gTree`, `grob`, `gtable`>",1
+GGally,add_left_axis,2,0,0,logical,1
+GGally,add_left_axis,3,0,0,integer,1
+GGally,add_list_to_ggmatrix,-1,0,0,"class<`gg`, `ggmatrix`>",1
+GGally,add_list_to_ggmatrix,0,0,0,"class<`gg`, `ggmatrix`>",1
+GGally,add_list_to_ggmatrix,1,0,0,"list<class<`gg`, `theme`> | class<`labels`>>",1
+GGally,add_ref_boxes,-1,0,0,"class<`Layer`, `LayerInstance`, `gg`, `ggproto`>",1
+GGally,add_ref_boxes,0,0,0,"class<`data.frame`, `glyphplot`>",1
+GGally,add_ref_boxes,1,0,0,null,1
+GGally,add_ref_boxes,2,0,0,character,1
+GGally,add_ref_boxes,3,0,0,double,1
+GGally,add_ref_boxes,4,0,0,null,1
+GGally,add_ref_boxes,5,0,0,...,1
+GGally,add_ref_lines,-1,0,0,"class<`Layer`, `LayerInstance`, `gg`, `ggproto`>",1
+GGally,add_ref_lines,0,0,0,"class<`data.frame`, `glyphplot`>",1
+GGally,add_ref_lines,1,0,0,character,1
+GGally,add_ref_lines,2,0,0,double,1
+GGally,add_ref_lines,3,0,0,...,1
+GGally,add_theme_to_ggmatrix,-1,0,0,"class<`gg`, `ggmatrix`>",1
+GGally,add_theme_to_ggmatrix,0,0,0,"class<`gg`, `ggmatrix`>",1
+GGally,add_theme_to_ggmatrix,1,0,0,"class<`gg`, `theme`>",1
+GGally,as.character.ggmatrix_fn_with_params,-1,0,0,character,1
+GGally,as.character.ggmatrix_fn_with_params,0,0,0,class<`ggmatrix_fn_with_params`>,1
+GGally,as.character.ggmatrix_fn_with_params,1,0,0,...,1
+GGally,as.character.ggmatrix_plot_obj,-1,0,0,character,1
+GGally,as.character.ggmatrix_plot_obj,0,0,0,class<`ggmatrix_plot_obj`>,1
+GGally,as.character.ggmatrix_plot_obj,1,0,0,...,1
+GGally,as_ggmatrix_progress,-1,0,0,class<`function`>,1
+GGally,as_ggmatrix_progress,-1,0,1,logical,1
+GGally,as_ggmatrix_progress,0,0,0,class<`function`>,1
+GGally,as_ggmatrix_progress,0,0,1,null,1
+GGally,as_ggmatrix_progress,1,0,0,any,1
+GGally,as_ggmatrix_progress,2,0,0,...,1
+GGally,axis_size_bottom,-1,0,0,double,1
+GGally,axis_size_bottom,0,0,0,"class<`gDesc`, `gTree`, `grob`, `gtable`>",1
+GGally,axis_size_left,-1,0,0,double,1
+GGally,axis_size_left,0,0,0,"class<`gDesc`, `gTree`, `grob`, `gtable`>",1
+GGally,beta_stars,-1,0,0,character[],1
+GGally,beta_stars,0,0,0,double[],1
+GGally,brew_colors,-1,0,0,character,1
+GGally,brew_colors,0,0,0,character,1
+GGally,broom_columns,-1,0,0,character[],1
+GGally,broomify,-1,0,0,"class<`broomify`, `data.frame`, `tbl`, `tbl_df`>",1
+GGally,broomify,0,0,0,class<`lm`>,1
+GGally,broomify,1,0,0,logical,1
+GGally,check_and_set_ggpairs_defaults,-1,0,0,list<character>,1
+GGally,check_and_set_ggpairs_defaults,-1,0,1,list<class<`ggmatrix_fn_with_params`> | character>,1
+GGally,check_and_set_ggpairs_defaults,-1,0,2,list<character | class<`uneval`>>,1
+GGally,check_and_set_ggpairs_defaults,-1,0,3,list<class<`function`> | character>,1
+GGally,check_and_set_ggpairs_defaults,0,0,0,character,1
+GGally,check_and_set_ggpairs_defaults,1,0,0,list<character>,1
+GGally,check_and_set_ggpairs_defaults,1,0,1,list<class<`ggmatrix_fn_with_params`>>,1
+GGally,check_and_set_ggpairs_defaults,1,0,2,character,1
+GGally,check_and_set_ggpairs_defaults,1,0,3,list<character | class<`uneval`>>,1
+GGally,check_and_set_ggpairs_defaults,1,0,4,list<class<`function`>>,1
+GGally,check_and_set_ggpairs_defaults,1,0,5,list<class<`ggmatrix_fn_with_params`> | character>,1
+GGally,check_and_set_ggpairs_defaults,2,0,0,character,1
+GGally,check_and_set_ggpairs_defaults,3,0,0,character,1
+GGally,check_and_set_ggpairs_defaults,3,0,1,null,1
+GGally,check_and_set_ggpairs_defaults,4,0,0,character,1
+GGally,check_and_set_ggpairs_defaults,5,0,0,character,1
+GGally,check_and_set_ggpairs_defaults,6,0,0,logical,1
+GGally,check_and_set_ggpairs_defaults,7,0,0,logical,1
+GGally,check_and_set_nostic_types,-1,0,0,list<class<`function`>>,1
+GGally,check_and_set_nostic_types,-1,0,1,list<class<`ggmatrix_fn_with_params`> | class<`function`>>,1
+GGally,check_and_set_nostic_types,0,0,0,list<class<`function`>>,1
+GGally,check_and_set_nostic_types,0,0,1,list<class<`ggmatrix_fn_with_params`>>,1
+GGally,check_and_set_nostic_types,1,0,0,any,1
+GGally,check_and_set_nostic_types,2,0,0,any,1
+GGally,check_and_set_nostic_types,3,0,0,any,1
+GGally,check_and_set_nostic_types,4,0,0,any,1
+GGally,check_and_set_nostic_types,5,0,0,any,1
+GGally,check_and_set_nostic_types,6,0,0,any,1
+GGally,check_and_set_nostic_types,7,0,0,any,1
+GGally,check_i_j,-1,0,0,null,1
+GGally,check_i_j,0,0,0,"class<`gg`, `ggmatrix`>",1
+GGally,check_i_j,1,0,0,double,1
+GGally,check_i_j,2,0,0,double,1
+GGally,check_nrow_ncol,-1,0,0,null,1
+GGally,check_nrow_ncol,0,0,0,double,1
+GGally,check_nrow_ncol,1,0,0,character,1
+GGally,column_is_character,-1,0,0,character[],1
+GGally,column_is_character,0,0,0,class<`data.frame`>,1
+GGally,column_is_factor,-1,0,0,character[],1
+GGally,column_is_factor,0,0,0,class<`data.frame`>,1
+GGally,eval_data_col,-1,0,0,class<`factor`>,1
+GGally,eval_data_col,-1,0,1,double[],1
+GGally,eval_data_col,-1,0,2,null,1
+GGally,eval_data_col,0,0,0,class<`data.frame`>,1
+GGally,eval_data_col,0,0,1,"class<`broomify`, `data.frame`, `tbl`, `tbl_df`>",1
+GGally,eval_data_col,1,0,0,"class<`formula`, `quosure`>",1
+GGally,eval_data_col,1,0,1,null,1
+GGally,find_plot_type,-1,0,0,character,1
+GGally,find_plot_type,0,0,0,character,1
+GGally,find_plot_type,1,0,0,character,1
+GGally,find_plot_type,2,0,0,list<character>,1
+GGally,find_plot_type,3,0,0,any,1
+GGally,find_plot_type,4,0,0,any,1
+GGally,find_plot_type,5,0,0,any,1
+GGally,fix_axis_label_choice,-1,0,0,character,1
+GGally,fix_axis_label_choice,0,0,0,character[],1
+GGally,fix_axis_label_choice,1,0,0,character[],1
+GGally,fix_column_values,-1,0,0,double[],1
+GGally,fix_column_values,0,0,0,class<`data.frame`>,1
+GGally,fix_column_values,1,0,0,double[],1
+GGally,fix_column_values,1,0,1,character[],1
+GGally,fix_column_values,2,0,0,character[],1
+GGally,fix_column_values,2,0,1,null,1
+GGally,fix_column_values,3,0,0,character,1
+GGally,fix_column_values,4,0,0,character,1
+GGally,fix_column_values,5,0,0,logical,1
+GGally,fix_data,-1,0,0,class<`data.frame`>,1
+GGally,fix_data,0,0,0,"class<`data.frame`, `tbl`, `tbl_df`>",1
+GGally,fix_data,0,0,1,class<`data.frame`>,1
+GGally,fix_data,0,0,2,"class<`broomify`, `data.frame`, `tbl`, `tbl_df`>",1
+GGally,fix_data_slim,-1,0,0,class<`data.frame`>,1
+GGally,fix_data_slim,0,0,0,class<`data.frame`>,1
+GGally,fix_data_slim,1,0,0,logical,1
+GGally,fn_switch,-1,0,0,class<`function`>,1
+GGally,fn_switch,0,0,0,any,1
+GGally,fn_switch,1,0,0,character,1
+GGally,get_legend_from_gtable,-1,0,0,"class<`gDesc`, `gTree`, `grob`, `gtable`, `legend_guide_box`>",1
+GGally,get_legend_from_gtable,0,0,0,"class<`gDesc`, `gTree`, `grob`, `gtable`>",1
+GGally,getPlot,-1,0,0,"class<`gg`, `ggplot`>",1
+GGally,getPlot,0,0,0,"class<`gg`, `ggmatrix`>",1
+GGally,getPlot,1,0,0,double,1
+GGally,getPlot,2,0,0,double,1
+GGally,get_pos,-1,0,0,double,1
+GGally,get_pos,0,0,0,"class<`gg`, `ggmatrix`>",1
+GGally,get_pos,1,0,0,double,1
+GGally,get_pos,2,0,0,double,1
+GGally,get_subtype_name,-1,0,0,character,1
+GGally,get_subtype_name,0,0,0,character,1
+GGally,get_subtype_name,0,0,1,class<`function`>,1
+GGally,get_subtype_name,0,0,2,class<`ggmatrix_fn_with_params`>,1
+GGally,get_x_axis_labels,-1,0,0,class<`data.frame`>,1
+GGally,get_x_axis_labels,0,0,0,"class<`gg`, `ggplot`>",1
+GGally,get_x_axis_labels,1,0,0,double[],1
+GGally,+.gg,-1,0,0,"class<`gg`, `ggmatrix`>",1
+GGally,+.gg,-1,0,1,"class<`gg`, `ggplot`>",1
+GGally,+.gg,0,0,0,"class<`gg`, `ggmatrix`>",1
+GGally,+.gg,0,0,1,"class<`gg`, `ggplot`>",1
+GGally,+.gg,1,0,0,"class<`gg`, `theme`>",1
+GGally,+.gg,1,0,1,class<`labels`>,1
+GGally,+.gg,1,0,2,"list<class<`gg`, `theme`> | class<`labels`>>",1
+GGally,+.gg,1,0,3,"class<`Coord`, `CoordCartesian`, `CoordFixed`, `gg`, `ggproto`>",1
+GGally,+.gg,1,0,4,"class<`Coord`, `CoordCartesian`, `CoordFlip`, `gg`, `ggproto`>",1
+GGally,+.gg,1,0,5,"class<`Coord`, `CoordCartesian`, `gg`, `ggproto`>",1
+GGally,+.gg,1,0,6,"class<`Coord`, `CoordMap`, `gg`, `ggproto`>",1
+GGally,+.gg,1,0,7,"class<`Facet`, `FacetGrid`, `gg`, `ggproto`>",1
+GGally,+.gg,1,0,8,class<`guides`>,1
+GGally,+.gg,1,0,9,"class<`Layer`, `LayerInstance`, `gg`, `ggproto`>",1
+GGally,+.gg,1,0,10,"class<`Scale`, `ScaleContinuous`, `gg`, `ggproto`>",1
+GGally,+.gg,1,0,11,"class<`Scale`, `ScaleContinuous`, `ScaleContinuousIdentity`, `gg`, `ggproto`>",1
+GGally,+.gg,1,0,12,"class<`Scale`, `ScaleContinuous`, `ScaleContinuousPosition`, `gg`, `ggproto`>",1
+GGally,+.gg,1,0,13,"class<`Scale`, `ScaleDiscrete`, `gg`, `ggproto`>",1
+GGally,+.gg,1,0,14,"class<`Scale`, `ScaleDiscrete`, `ScaleDiscreteIdentity`, `gg`, `ggproto`>",1
+GGally,+.gg,1,0,15,"class<`Scale`, `ScaleDiscrete`, `ScaleDiscretePosition`, `gg`, `ggproto`>",1
+GGally,+.gg,1,0,16,class<`uneval`>,1
+GGally,ggally_barDiag,-1,0,0,"class<`gg`, `ggplot`>",1
+GGally,ggally_barDiag,0,0,0,class<`data.frame`>,1
+GGally,ggally_barDiag,1,0,0,class<`uneval`>,1
+GGally,ggally_barDiag,2,0,0,...,1
+GGally,ggally_barDiag,3,0,0,logical,1
+GGally,ggally_blank,-1,0,0,"class<`gg`, `ggmatrix_blank`, `ggplot`>",1
+GGally,ggally_blank,0,0,0,...,1
+GGally,ggally_box,-1,0,0,"class<`gg`, `ggplot`>",1
+GGally,ggally_box,0,0,0,class<`data.frame`>,1
+GGally,ggally_box,1,0,0,class<`uneval`>,1
+GGally,ggally_box,2,0,0,...,1
+GGally,ggally_cor,-1,0,0,"class<`gg`, `ggplot`>",1
+GGally,ggally_cor,0,0,0,class<`data.frame`>,1
+GGally,ggally_cor,1,0,0,class<`uneval`>,1
+GGally,ggally_cor,2,0,0,double,1
+GGally,ggally_cor,3,0,0,character,1
+GGally,ggally_cor,4,0,0,character,1
+GGally,ggally_cor,5,0,0,null,1
+GGally,ggally_cor,6,0,0,null,1
+GGally,ggally_cor,7,0,0,null,1
+GGally,ggally_density,-1,0,0,"class<`gg`, `ggplot`>",1
+GGally,ggally_density,0,0,0,class<`data.frame`>,1
+GGally,ggally_density,1,0,0,class<`uneval`>,1
+GGally,ggally_density,2,0,0,...,1
+GGally,ggally_densityDiag,-1,0,0,"class<`gg`, `ggplot`>",1
+GGally,ggally_densityDiag,0,0,0,class<`data.frame`>,1
+GGally,ggally_densityDiag,1,0,0,class<`uneval`>,1
+GGally,ggally_densityDiag,2,0,0,...,1
+GGally,ggally_densityDiag,3,0,0,logical,1
+GGally,ggally_denstrip,-1,0,0,"class<`gg`, `ggplot`>",1
+GGally,ggally_denstrip,0,0,0,class<`data.frame`>,1
+GGally,ggally_denstrip,1,0,0,class<`uneval`>,1
+GGally,ggally_denstrip,2,0,0,...,1
+GGally,ggally_diagAxis,-1,0,0,"class<`gg`, `ggplot`>",1
+GGally,ggally_diagAxis,0,0,0,class<`data.frame`>,1
+GGally,ggally_diagAxis,1,0,0,class<`uneval`>,1
+GGally,ggally_diagAxis,2,0,0,"class<`formula`, `quosure`>",1
+GGally,ggally_diagAxis,3,0,0,double,1
+GGally,ggally_diagAxis,4,0,0,double,1
+GGally,ggally_diagAxis,5,0,0,double,1
+GGally,ggally_diagAxis,6,0,0,double,1
+GGally,ggally_diagAxis,7,0,0,double,1
+GGally,ggally_dot,-1,0,0,"class<`gg`, `ggplot`>",1
+GGally,ggally_dot,0,0,0,class<`data.frame`>,1
+GGally,ggally_dot,1,0,0,class<`uneval`>,1
+GGally,ggally_dot,2,0,0,...,1
+GGally,ggally_dot_and_box,-1,0,0,"class<`gg`, `ggplot`>",1
+GGally,ggally_dot_and_box,0,0,0,class<`data.frame`>,1
+GGally,ggally_dot_and_box,1,0,0,class<`uneval`>,1
+GGally,ggally_dot_and_box,2,0,0,...,1
+GGally,ggally_dot_and_box,3,0,0,logical,1
+GGally,ggally_dot_and_box_no_facet,-1,0,0,"class<`gg`, `ggplot`>",1
+GGally,ggally_dot_and_box_no_facet,0,0,0,class<`data.frame`>,1
+GGally,ggally_dot_and_box_no_facet,1,0,0,class<`uneval`>,1
+GGally,ggally_dot_and_box_no_facet,2,0,0,...,1
+GGally,ggally_dot_and_box_no_facet,3,0,0,logical,1
+GGally,ggally_facetbar,-1,0,0,"class<`gg`, `ggplot`>",1
+GGally,ggally_facetbar,0,0,0,class<`data.frame`>,1
+GGally,ggally_facetbar,1,0,0,class<`uneval`>,1
+GGally,ggally_facetbar,2,0,0,...,1
+GGally,ggally_facetdensity,-1,0,0,"class<`gg`, `ggplot`>",1
+GGally,ggally_facetdensity,0,0,0,class<`data.frame`>,1
+GGally,ggally_facetdensity,1,0,0,class<`uneval`>,1
+GGally,ggally_facetdensity,2,0,0,...,1
+GGally,ggally_facetdensitystrip,-1,0,0,"class<`gg`, `ggplot`>",1
+GGally,ggally_facetdensitystrip,0,0,0,class<`data.frame`>,1
+GGally,ggally_facetdensitystrip,1,0,0,class<`uneval`>,1
+GGally,ggally_facetdensitystrip,2,0,0,...,1
+GGally,ggally_facetdensitystrip,3,0,0,logical,1
+GGally,ggally_facethist,-1,0,0,"class<`gg`, `ggplot`>",1
+GGally,ggally_facethist,0,0,0,class<`data.frame`>,1
+GGally,ggally_facethist,1,0,0,class<`uneval`>,1
+GGally,ggally_facethist,2,0,0,...,1
+GGally,ggally_nostic_cooksd,-1,0,0,"class<`gg`, `ggplot`>",1
+GGally,ggally_nostic_cooksd,0,0,0,"class<`broomify`, `data.frame`, `tbl`, `tbl_df`>",1
+GGally,ggally_nostic_cooksd,1,0,0,class<`uneval`>,1
+GGally,ggally_nostic_cooksd,2,0,0,...,1
+GGally,ggally_nostic_cooksd,3,0,0,double,1
+GGally,ggally_nostic_cooksd,4,0,0,character,1
+GGally,ggally_nostic_cooksd,5,0,0,double,1
+GGally,ggally_nostic_hat,-1,0,0,"class<`gg`, `ggplot`>",1
+GGally,ggally_nostic_hat,0,0,0,"class<`broomify`, `data.frame`, `tbl`, `tbl_df`>",1
+GGally,ggally_nostic_hat,1,0,0,class<`uneval`>,1
+GGally,ggally_nostic_hat,2,0,0,...,1
+GGally,ggally_nostic_hat,3,0,0,double,1
+GGally,ggally_nostic_hat,4,0,0,character,1
+GGally,ggally_nostic_hat,5,0,0,double,1
+GGally,ggally_nostic_hat,6,0,0,double,1
+GGally,ggally_nostic_hat,7,0,0,double,1
+GGally,ggally_nostic_line,-1,0,0,"class<`gg`, `ggplot`>",1
+GGally,ggally_nostic_line,0,0,0,"class<`broomify`, `data.frame`, `tbl`, `tbl_df`>",1
+GGally,ggally_nostic_line,1,0,0,class<`uneval`>,1
+GGally,ggally_nostic_line,2,0,0,...,1
+GGally,ggally_nostic_line,3,0,0,double[],1
+GGally,ggally_nostic_line,3,0,1,null,1
+GGally,ggally_nostic_line,4,0,0,any,1
+GGally,ggally_nostic_line,5,0,0,double[],1
+GGally,ggally_nostic_line,6,0,0,double[],1
+GGally,ggally_nostic_line,7,0,0,double[],1
+GGally,ggally_nostic_resid,-1,0,0,"class<`gg`, `ggplot`>",1
+GGally,ggally_nostic_resid,0,0,0,"class<`broomify`, `data.frame`, `tbl`, `tbl_df`>",1
+GGally,ggally_nostic_resid,1,0,0,class<`uneval`>,1
+GGally,ggally_nostic_resid,2,0,0,...,1
+GGally,ggally_nostic_resid,3,0,0,double,1
+GGally,ggally_nostic_resid,4,0,0,character,1
+GGally,ggally_nostic_resid,5,0,0,double,1
+GGally,ggally_nostic_resid,6,0,0,double,1
+GGally,ggally_nostic_resid,7,0,0,double,1
+GGally,ggally_nostic_se_fit,-1,0,0,"class<`gg`, `ggplot`>",1
+GGally,ggally_nostic_se_fit,0,0,0,"class<`broomify`, `data.frame`, `tbl`, `tbl_df`>",1
+GGally,ggally_nostic_se_fit,1,0,0,class<`uneval`>,1
+GGally,ggally_nostic_se_fit,2,0,0,...,1
+GGally,ggally_nostic_se_fit,3,0,0,any,1
+GGally,ggally_nostic_se_fit,4,0,0,null,1
+GGally,ggally_nostic_sigma,-1,0,0,"class<`gg`, `ggplot`>",1
+GGally,ggally_nostic_sigma,0,0,0,"class<`broomify`, `data.frame`, `tbl`, `tbl_df`>",1
+GGally,ggally_nostic_sigma,1,0,0,class<`uneval`>,1
+GGally,ggally_nostic_sigma,2,0,0,...,1
+GGally,ggally_nostic_sigma,3,0,0,character,1
+GGally,ggally_nostic_sigma,4,0,0,double,1
+GGally,ggally_nostic_std_resid,-1,0,0,"class<`gg`, `ggplot`>",1
+GGally,ggally_nostic_std_resid,0,0,0,"class<`broomify`, `data.frame`, `tbl`, `tbl_df`>",1
+GGally,ggally_nostic_std_resid,1,0,0,class<`uneval`>,1
+GGally,ggally_nostic_std_resid,2,0,0,...,1
+GGally,ggally_nostic_std_resid,3,0,0,double,1
+GGally,ggally_points,-1,0,0,"class<`gg`, `ggplot`>",1
+GGally,ggally_points,0,0,0,class<`data.frame`>,1
+GGally,ggally_points,1,0,0,class<`uneval`>,1
+GGally,ggally_points,2,0,0,...,1
+GGally,ggally_ratio,-1,0,0,"class<`gg`, `ggplot`>",1
+GGally,ggally_ratio,0,0,0,class<`data.frame`>,1
+GGally,ggally_ratio,1,0,0,class<`uneval`>,1
+GGally,ggally_ratio,2,0,0,...,1
+GGally,ggally_ratio,3,0,0,double,1
+GGally,ggally_ratio,4,0,0,double,1
+GGally,ggally_ratio,4,0,1,null,1
+GGally,ggally_smooth,-1,0,0,"class<`gg`, `ggplot`>",1
+GGally,ggally_smooth,0,0,0,class<`data.frame`>,1
+GGally,ggally_smooth,1,0,0,class<`uneval`>,1
+GGally,ggally_smooth,2,0,0,...,1
+GGally,ggally_smooth,3,0,0,character,1
+GGally,ggally_smooth,4,0,0,logical,1
+GGally,ggally_smooth,5,0,0,logical,1
+GGally,ggally_text,-1,0,0,"class<`gg`, `ggplot`>",1
+GGally,ggally_text,0,0,0,character,1
+GGally,ggally_text,1,0,0,class<`uneval`>,1
+GGally,ggally_text,2,0,0,double,1
+GGally,ggally_text,3,0,0,double,1
+GGally,ggally_text,4,0,0,double[],1
+GGally,ggally_text,5,0,0,double[],1
+GGally,ggally_text,6,0,0,...,1
+GGally,ggcoef,-1,0,0,"class<`gg`, `ggplot`>",1
+GGally,ggcoef,0,0,0,"class<`glm`, `lm`>",1
+GGally,ggcoef,0,0,1,class<`lm`>,1
+GGally,ggcoef,1,0,0,class<`uneval`>,1
+GGally,ggcoef,2,0,0,logical,1
+GGally,ggcoef,3,0,0,double,1
+GGally,ggcoef,4,0,0,logical,1
+GGally,ggcoef,5,0,0,logical,1
+GGally,ggcoef,6,0,0,logical,1
+GGally,ggcoef,7,0,0,character,1
+GGally,ggcorr,-1,0,0,"class<`gg`, `ggplot`>",1
+GGally,ggcorr,0,0,0,class<`data.frame`>,1
+GGally,ggcorr,0,0,1,null,1
+GGally,ggcorr,1,0,0,character[],1
+GGally,ggcorr,2,0,0,null,1
+GGally,ggcorr,2,0,1,class<`matrix`>,1
+GGally,ggcorr,3,0,0,double,1
+GGally,ggcorr,3,0,1,null,1
+GGally,ggcorr,4,0,0,double,1
+GGally,ggcorr,5,0,0,expression,1
+GGally,ggcorr,5,0,1,character,1
+GGally,ggcorr,6,0,0,character,1
+GGally,ggcorr,7,0,0,character,1
+GGally,ggduo,-1,0,0,"class<`gg`, `ggmatrix`>",1
+GGally,ggduo,0,0,0,"class<`broomify`, `data.frame`, `tbl`, `tbl_df`>",1
+GGally,ggduo,0,0,1,class<`data.frame`>,1
+GGally,ggduo,1,0,0,class<`uneval`>,1
+GGally,ggduo,1,0,1,null,1
+GGally,ggduo,1,0,2,character[],1
+GGally,ggduo,2,0,0,character[],1
+GGally,ggduo,3,0,0,any,1
+GGally,ggduo,4,0,0,character,1
+GGally,ggduo,4,0,1,null,1
+GGally,ggduo,5,0,0,list<class<`function`>>,1
+GGally,ggduo,5,0,1,list<character>,1
+GGally,ggduo,5,0,2,list<class<`ggmatrix_fn_with_params`>>,1
+GGally,ggduo,6,0,0,character[],1
+GGally,ggduo,7,0,0,character[],1
+GGally,ggduo,7,0,1,null,1
+GGally,ggfacet,-1,0,0,"class<`gg`, `ggplot`>",1
+GGally,ggfacet,0,0,0,class<`data.frame`>,1
+GGally,ggfacet,1,0,0,character[],1
+GGally,ggfacet,2,0,0,character[],1
+GGally,ggfacet,3,0,0,any,1
+GGally,ggfacet,4,0,0,character,1
+GGally,ggfacet,4,0,1,class<`function`>,1
+GGally,ggfacet,5,0,0,...,1
+GGally,ggfacet,6,0,0,character[],1
+GGally,ggfacet,7,0,0,character[],1
+GGally,gglegend,-1,0,0,class<`function`>,1
+GGally,gglegend,0,0,0,character,1
+GGally,gglegend,0,0,1,class<`function`>,1
+GGally,ggmatrix,-1,0,0,"class<`gg`, `ggmatrix`>",1
+GGally,ggmatrix,0,0,0,"list<class<`gg`, `ggplot`>>",1
+GGally,ggmatrix,0,0,1,list<class<`ggmatrix_plot_obj`>>,1
+GGally,ggmatrix,1,0,0,double,1
+GGally,ggmatrix,2,0,0,double,1
+GGally,ggmatrix,3,0,0,character[],1
+GGally,ggmatrix,3,0,1,null,1
+GGally,ggmatrix,4,0,0,character[],1
+GGally,ggmatrix,4,0,1,null,1
+GGally,ggmatrix,5,0,0,null,1
+GGally,ggmatrix,5,0,1,character,1
+GGally,ggmatrix,6,0,0,null,1
+GGally,ggmatrix,6,0,1,character,1
+GGally,ggmatrix,7,0,0,null,1
+GGally,ggmatrix,7,0,1,character,1
+GGally,[<-.ggmatrix,-1,0,0,"class<`gg`, `ggmatrix`>",1
+GGally,[<-.ggmatrix,0,0,0,"class<`gg`, `ggmatrix`>",1
+GGally,[<-.ggmatrix,1,0,0,double,1
+GGally,[<-.ggmatrix,2,0,0,double,1
+GGally,[<-.ggmatrix,3,0,0,...,1
+GGally,[<-.ggmatrix,4,0,0,character,1
+GGally,[<-.ggmatrix,4,0,1,"class<`gDesc`, `gTree`, `grob`, `gtable`, `legend_guide_box`>",1
+GGally,[<-.ggmatrix,4,0,2,"class<`gg`, `ggplot`>",1
+GGally,[<-.ggmatrix,4,0,3,null,1
+GGally,[.ggmatrix,-1,0,0,"class<`gg`, `ggplot`>",1
+GGally,[.ggmatrix,0,0,0,"class<`gg`, `ggmatrix`>",1
+GGally,[.ggmatrix,1,0,0,double,1
+GGally,[.ggmatrix,2,0,0,double,1
+GGally,[.ggmatrix,3,0,0,...,1
+GGally,ggmatrix_gtable,-1,0,0,"class<`gDesc`, `gTree`, `grob`, `gtable`>",1
+GGally,ggmatrix_gtable,0,0,0,"class<`gg`, `ggmatrix`>",1
+GGally,ggmatrix_gtable,1,0,0,...,1
+GGally,ggmatrix_gtable,2,0,0,null,1
+GGally,ggmatrix_gtable,3,0,0,any,1
+GGally,ggmatrix_plot_list,-1,0,0,class<`function`>,1
+GGally,ggmatrix_plot_list,0,0,0,character,1
+GGally,ggmatrix_progress,-1,0,0,class<`function`>,1
+GGally,ggmatrix_progress,0,0,0,character,1
+GGally,ggmatrix_progress,1,0,0,logical,1
+GGally,ggmatrix_progress,2,0,0,double,1
+GGally,ggmatrix_progress,3,0,0,...,1
+GGally,ggnet,-1,0,0,"class<`gg`, `ggplot`>",1
+GGally,ggnet,0,0,0,class<`network`>,1
+GGally,ggnet,1,0,0,character,1
+GGally,ggnet,2,0,0,null,1
+GGally,ggnet,3,0,0,double,1
+GGally,ggnet,4,0,0,double,1
+GGally,ggnet,5,0,0,double,1
+GGally,ggnet,6,0,0,character,1
+GGally,ggnet,7,0,0,null,1
+GGally,ggnet2,-1,0,0,"class<`gg`, `ggplot`>",1
+GGally,ggnet2,0,0,0,class<`matrix`>,1
+GGally,ggnet2,0,0,1,class<`network`>,1
+GGally,ggnet2,1,0,0,character,1
+GGally,ggnet2,2,0,0,null,1
+GGally,ggnet2,3,0,0,double,1
+GGally,ggnet2,4,0,0,double,1
+GGally,ggnet2,5,0,0,character,1
+GGally,ggnet2,5,0,1,double,1
+GGally,ggnet2,6,0,0,double,1
+GGally,ggnet2,6,0,1,character,1
+GGally,ggnet2,7,0,0,double,1
+GGally,ggnetworkmap,-1,0,0,"class<`gg`, `ggplot`>",1
+GGally,ggnetworkmap,0,0,0,any,1
+GGally,ggnetworkmap,1,0,0,class<`network`>,1
+GGally,ggnetworkmap,2,0,0,double,1
+GGally,ggnetworkmap,3,0,0,double,1
+GGally,ggnetworkmap,4,0,0,any,1
+GGally,ggnetworkmap,5,0,0,any,1
+GGally,ggnetworkmap,6,0,0,null,1
+GGally,ggnetworkmap,7,0,0,null,1
+GGally,ggnostic,-1,0,0,"class<`gg`, `ggmatrix`>",1
+GGally,ggnostic,0,0,0,class<`lm`>,1
+GGally,ggnostic,1,0,0,...,1
+GGally,ggnostic,2,0,0,character[],1
+GGally,ggnostic,3,0,0,character[],1
+GGally,ggnostic,4,0,0,character[],1
+GGally,ggnostic,5,0,0,character[],1
+GGally,ggnostic,6,0,0,character,1
+GGally,ggnostic,7,0,0,character,1
+GGally,ggpairs,-1,0,0,"class<`gg`, `ggmatrix`>",1
+GGally,ggpairs,0,0,0,"class<`broomify`, `data.frame`, `tbl`, `tbl_df`>",1
+GGally,ggpairs,0,0,1,class<`data.frame`>,1
+GGally,ggpairs,0,0,2,"class<`data.frame`, `tbl`, `tbl_df`>",1
+GGally,ggpairs,1,0,0,character[],1
+GGally,ggpairs,1,0,1,class<`uneval`>,1
+GGally,ggpairs,1,0,2,integer[],1
+GGally,ggpairs,1,0,3,null,1
+GGally,ggpairs,2,0,0,any,1
+GGally,ggpairs,3,0,0,null,1
+GGally,ggpairs,3,0,1,character,1
+GGally,ggpairs,4,0,0,list<character>,1
+GGally,ggpairs,4,0,1,list<class<`function`>>,1
+GGally,ggpairs,4,0,2,character,1
+GGally,ggpairs,4,0,3,list<character | class<`uneval`>>,1
+GGally,ggpairs,4,0,4,list<class<`ggmatrix_fn_with_params`> | character>,1
+GGally,ggpairs,5,0,0,list<class<`function`>>,1
+GGally,ggpairs,5,0,1,list<character>,1
+GGally,ggpairs,5,0,2,list<class<`ggmatrix_fn_with_params`>>,1
+GGally,ggpairs,5,0,3,list<character | class<`uneval`>>,1
+GGally,ggpairs,6,0,0,list<character>,1
+GGally,ggpairs,7,0,0,null,1
+GGally,ggparcoord,-1,0,0,"class<`gg`, `ggplot`>",1
+GGally,ggparcoord,0,0,0,class<`data.frame`>,1
+GGally,ggparcoord,0,0,1,"class<`data.frame`, `tbl`, `tbl_df`>",1
+GGally,ggparcoord,1,0,0,double[],1
+GGally,ggparcoord,2,0,0,double,1
+GGally,ggparcoord,2,0,1,null,1
+GGally,ggparcoord,2,0,2,character,1
+GGally,ggparcoord,3,0,0,character,1
+GGally,ggparcoord,4,0,0,character,1
+GGally,ggparcoord,5,0,0,double,1
+GGally,ggparcoord,6,0,0,character,1
+GGally,ggparcoord,7,0,0,character,1
+GGally,ggparcoord,7,0,1,double[],1
+GGally,ggscatmat,-1,0,0,"class<`gg`, `ggplot`>",1
+GGally,ggscatmat,0,0,0,class<`data.frame`>,1
+GGally,ggscatmat,1,0,0,integer[],1
+GGally,ggscatmat,2,0,0,character,1
+GGally,ggscatmat,2,0,1,null,1
+GGally,ggscatmat,3,0,0,double,1
+GGally,ggscatmat,4,0,0,character,1
+GGally,ggsurv,-1,0,0,"class<`gg`, `ggplot`>",1
+GGally,ggsurv,0,0,0,class<`survfit`>,1
+GGally,ggsurv,1,0,0,character,1
+GGally,ggsurv,2,0,0,logical,1
+GGally,ggsurv,3,0,0,character,1
+GGally,ggsurv,4,0,0,character,1
+GGally,ggsurv,5,0,0,double,1
+GGally,ggsurv,6,0,0,double,1
+GGally,ggsurv,7,0,0,double,1
+GGally,ggts,-1,0,0,"class<`gg`, `ggmatrix`>",1
+GGally,ggts,0,0,0,...,1
+GGally,ggts,1,0,0,null,1
+GGally,ggts,2,0,0,character,1
+GGally,glyphplot,-1,0,0,"class<`data.frame`, `glyphplot`>",1
+GGally,glyphplot,0,0,0,"class<`data.frame`, `glyphplot`>",1
+GGally,glyphplot,1,0,0,double,1
+GGally,glyphplot,2,0,0,double,1
+GGally,glyphplot,3,0,0,logical,1
+GGally,glyphplot,4,0,0,character,1
+GGally,glyphplot,5,0,0,character,1
+GGally,[.glyphplot,-1,0,0,"class<`data.frame`, `glyphplot`>",1
+GGally,[.glyphplot,0,0,0,"class<`data.frame`, `glyphplot`>",1
+GGally,[.glyphplot,1,0,0,...,1
+GGally,glyphs,-1,0,0,"class<`data.frame`, `glyphplot`>",1
+GGally,glyphs,0,0,0,class<`data.frame`>,1
+GGally,glyphs,1,0,0,character,1
+GGally,glyphs,2,0,0,character,1
+GGally,glyphs,3,0,0,character,1
+GGally,glyphs,4,0,0,character,1
+GGally,glyphs,5,0,0,logical,1
+GGally,glyphs,6,0,0,double,1
+GGally,glyphs,7,0,0,class<`rel`>,1
+GGally,grab_legend,-1,0,0,"class<`gDesc`, `gTree`, `grob`, `gtable`, `legend_guide_box`>",1
+GGally,grab_legend,0,0,0,"class<`gg`, `ggplot`>",1
+GGally,ifnull,-1,0,0,character[],1
+GGally,ifnull,-1,0,1,list<any>,1
+GGally,ifnull,0,0,0,character[],1
+GGally,ifnull,0,0,1,null,1
+GGally,ifnull,0,0,2,list<double>,1
+GGally,ifnull,0,0,3,list<double | character>,1
+GGally,ifnull,1,0,0,any,1
+GGally,is_blank_plot,-1,0,0,logical,1
+GGally,is_blank_plot,0,0,0,"class<`gg`, `ggplot`>",1
+GGally,is_character_column,-1,0,0,logical,1
+GGally,is_character_column,0,0,0,"class<`broomify`, `data.frame`, `tbl`, `tbl_df`>",1
+GGally,is_character_column,0,0,1,class<`data.frame`>,1
+GGally,is_character_column,1,0,0,class<`uneval`>,1
+GGally,is_character_column,2,0,0,character,1
+GGally,is_date,-1,0,0,logical,1
+GGally,is_date,0,0,0,class<`factor`>,1
+GGally,is_date,0,0,1,"class<`factor`, `ordered`>",1
+GGally,is_date,0,0,2,double[],1
+GGally,isFALSE,-1,0,0,logical,1
+GGally,isFALSE,0,0,0,class<`function`>,1
+GGally,isFALSE,0,0,1,logical,1
+GGally,isFALSE,0,0,2,null,1
+GGally,is.ggmatrix,-1,0,0,logical,1
+GGally,is.ggmatrix,0,0,0,"class<`gg`, `ggmatrix`>",1
+GGally,is.ggmatrix,0,0,1,"class<`gg`, `ggplot`>",1
+GGally,is.glyphplot,-1,0,0,logical,1
+GGally,is.glyphplot,0,0,0,"class<`data.frame`, `glyphplot`>",1
+GGally,is_horizontal,-1,0,0,logical,1
+GGally,is_horizontal,0,0,0,"class<`broomify`, `data.frame`, `tbl`, `tbl_df`>",1
+GGally,is_horizontal,0,0,1,class<`data.frame`>,1
+GGally,is_horizontal,1,0,0,class<`uneval`>,1
+GGally,is_horizontal,2,0,0,character,1
+GGally,lowertriangle,-1,0,0,class<`data.frame`>,1
+GGally,lowertriangle,0,0,0,class<`data.frame`>,1
+GGally,lowertriangle,1,0,0,integer[],1
+GGally,lowertriangle,2,0,0,character,1
+GGally,lowertriangle,2,0,1,null,1
+GGally,make_ggmatrix_plot_obj,-1,0,0,class<`ggmatrix_plot_obj`>,1
+GGally,make_ggmatrix_plot_obj,0,0,0,class<`ggmatrix_fn_with_params`>,1
+GGally,make_ggmatrix_plot_obj,1,0,0,class<`uneval`>,1
+GGally,make_ggmatrix_plot_obj,2,0,0,double,1
+GGally,make_ggmatrix_plot_obj,3,0,0,null,1
+GGally,mapping_as_string,-1,0,0,character,1
+GGally,mapping_as_string,0,0,0,class<`uneval`>,1
+GGally,mapping_color_to_fill,-1,0,0,class<`uneval`>,1
+GGally,mapping_color_to_fill,0,0,0,class<`uneval`>,1
+GGally,mapping_string,-1,0,0,character,1
+GGally,mapping_string,0,0,0,"class<`formula`, `quosure`>",1
+GGally,mapping_swap_x_y,-1,0,0,class<`uneval`>,1
+GGally,mapping_swap_x_y,0,0,0,class<`uneval`>,1
+GGally,match_nostic_columns,-1,0,0,character[],1
+GGally,match_nostic_columns,0,0,0,character[],1
+GGally,match_nostic_columns,1,0,0,character[],1
+GGally,match_nostic_columns,2,0,0,character,1
+GGally,model_beta_label,-1,0,0,character[],1
+GGally,model_beta_label,0,0,0,class<`lm`>,1
+GGally,model_beta_label,1,0,0,"class<`data.frame`, `tbl`, `tbl_df`>",1
+GGally,model_beta_label,2,0,0,logical,1
+GGally,model_beta_variables,-1,0,0,character[],1
+GGally,model_beta_variables,0,0,0,any,1
+GGally,model_beta_variables,1,0,0,"class<`data.frame`, `tbl`, `tbl_df`>",1
+GGally,model_response_variables,-1,0,0,character,1
+GGally,model_response_variables,0,0,0,any,1
+GGally,model_response_variables,1,0,0,"class<`data.frame`, `tbl`, `tbl_df`>",1
+GGally,model_variables,-1,0,0,character[],1
+GGally,model_variables,0,0,0,any,1
+GGally,model_variables,1,0,0,"class<`data.frame`, `tbl`, `tbl_df`>",1
+GGally,plot_gtable,-1,0,0,"class<`gDesc`, `gTree`, `grob`, `gtable`>",1
+GGally,plot_gtable,0,0,0,"class<`gg`, `ggplot`>",1
+GGally,plot_panel,-1,0,0,"class<`gDesc`, `gTree`, `grob`, `gtable`>",1
+GGally,plot_panel,0,0,0,"class<`gDesc`, `gTree`, `grob`, `gtable`>",1
+GGally,plot_panel,1,0,0,integer,1
+GGally,plot_panel,2,0,0,integer,1
+GGally,plot_panel,3,0,0,null,1
+GGally,plot_panel,4,0,0,integer,1
+GGally,plot_panel,5,0,0,null,1
+GGally,plotting_data_type,-1,0,0,character,1
+GGally,plotting_data_type,0,0,0,class<`factor`>,1
+GGally,plotting_data_type,0,0,1,double[],1
+GGally,plot_types,-1,0,0,class<`data.frame`>,1
+GGally,plot_types,0,0,0,class<`data.frame`>,1
+GGally,plot_types,1,0,0,double[],1
+GGally,plot_types,2,0,0,double[],1
+GGally,plot_types,3,0,0,logical,1
+GGally,putPlot,-1,0,0,"class<`gg`, `ggmatrix`>",1
+GGally,putPlot,0,0,0,"class<`gg`, `ggmatrix`>",1
+GGally,putPlot,1,0,0,character,1
+GGally,putPlot,1,0,1,"class<`gDesc`, `gTree`, `grob`, `gtable`, `legend_guide_box`>",1
+GGally,putPlot,1,0,2,"class<`gg`, `ggplot`>",1
+GGally,putPlot,1,0,3,null,1
+GGally,putPlot,2,0,0,double,1
+GGally,putPlot,3,0,0,double,1
+GGally,ref_boxes,-1,0,0,class<`data.frame`>,1
+GGally,ref_boxes,0,0,0,"class<`data.frame`, `glyphplot`>",1
+GGally,ref_boxes,1,0,0,null,1
+GGally,ref_lines,-1,0,0,class<`data.frame`>,1
+GGally,ref_lines,0,0,0,"class<`data.frame`, `glyphplot`>",1
+GGally,require_namespaces,-1,0,0,null,1
+GGally,require_namespaces,0,0,0,character[],1
+GGally,rescale01,-1,0,0,double[],1
+GGally,rescale01,0,0,0,double[],1
+GGally,rescale01,1,0,0,null,1
+GGally,rescale11,-1,0,0,double[],1
+GGally,rescale11,0,0,0,double[],1
+GGally,rescale11,1,0,0,null,1
+GGally,scatmat,-1,0,0,"class<`gg`, `ggplot`>",1
+GGally,scatmat,0,0,0,class<`data.frame`>,1
+GGally,scatmat,1,0,0,integer[],1
+GGally,scatmat,2,0,0,character,1
+GGally,scatmat,2,0,1,null,1
+GGally,scatmat,3,0,0,double,1
+GGally,set_max_axis_size,-1,0,0,"class<`gDesc`, `gTree`, `grob`, `gtable`>",1
+GGally,set_max_axis_size,0,0,0,"class<`gDesc`, `gTree`, `grob`, `gtable`>",1
+GGally,set_max_axis_size,1,0,0,double[],1
+GGally,set_max_axis_size,2,0,0,character,1
+GGally,set_max_axis_size,3,0,0,character[],1
+GGally,set_max_axis_size,4,0,0,character,1
+GGally,set_to_blank_list_if_blank,-1,0,0,list<character>,1
+GGally,set_to_blank_list_if_blank,-1,0,1,list<class<`ggmatrix_fn_with_params`>>,1
+GGally,set_to_blank_list_if_blank,-1,0,2,list<character | class<`uneval`>>,1
+GGally,set_to_blank_list_if_blank,-1,0,3,list<class<`function`>>,1
+GGally,set_to_blank_list_if_blank,-1,0,4,list<class<`ggmatrix_fn_with_params`> | character>,1
+GGally,set_to_blank_list_if_blank,0,0,0,list<character>,1
+GGally,set_to_blank_list_if_blank,0,0,1,list<class<`ggmatrix_fn_with_params`>>,1
+GGally,set_to_blank_list_if_blank,0,0,2,character,1
+GGally,set_to_blank_list_if_blank,0,0,3,list<character | class<`uneval`>>,1
+GGally,set_to_blank_list_if_blank,0,0,4,list<class<`function`>>,1
+GGally,set_to_blank_list_if_blank,0,0,5,list<class<`ggmatrix_fn_with_params`> | character>,1
+GGally,set_to_blank_list_if_blank,1,0,0,any,1
+GGally,set_to_blank_list_if_blank,2,0,0,any,1
+GGally,set_to_blank_list_if_blank,3,0,0,any,1
+GGally,singleClassOrder,-1,0,0,character[],1
+GGally,singleClassOrder,0,0,0,class<`factor`>,1
+GGally,singleClassOrder,1,0,0,class<`data.frame`>,1
+GGally,singleClassOrder,2,0,0,null,1
+GGally,stop_if_bad_mapping,-1,0,0,null,1
+GGally,stop_if_bad_mapping,0,0,0,class<`uneval`>,1
+GGally,stop_if_bad_mapping,0,0,1,null,1
+GGally,stop_if_high_cardinality,-1,0,0,null,1
+GGally,stop_if_high_cardinality,0,0,0,class<`data.frame`>,1
+GGally,stop_if_high_cardinality,1,0,0,double[],1
+GGally,stop_if_high_cardinality,2,0,0,double,1
+GGally,stop_if_params_exist,-1,0,0,null,1
+GGally,stop_if_params_exist,0,0,0,null,1
+GGally,str_c,-1,0,0,character[],1
+GGally,str_c,0,0,0,...,1
+GGally,str_c,1,0,0,character,1
+GGally,str_c,2,0,0,null,1
+GGally,str_c,2,0,1,character,1
+GGally,str_detect,-1,0,0,logical[],1
+GGally,str_detect,0,0,0,character[],1
+GGally,str_detect,1,0,0,character,1
+GGally,str_detect,2,0,0,...,1
+GGally,str.ggmatrix,-1,0,0,null,1
+GGally,str.ggmatrix,0,0,0,"class<`gg`, `ggmatrix`>",1
+GGally,str.ggmatrix,1,0,0,...,1
+GGally,str.ggmatrix,2,0,0,logical,1
+GGally,upgrade_scatmat_data,-1,0,0,class<`data.frame`>,1
+GGally,upgrade_scatmat_data,0,0,0,class<`data.frame`>,1
+GGally,uppertriangle,-1,0,0,class<`data.frame`>,1
+GGally,uppertriangle,0,0,0,class<`data.frame`>,1
+GGally,uppertriangle,1,0,0,integer[],1
+GGally,uppertriangle,2,0,0,character,1
+GGally,uppertriangle,2,0,1,null,1
+GGally,uppertriangle,3,0,0,character,1
+GGally,v1_ggmatrix_theme,-1,0,0,"class<`gg`, `theme`>",1
+GGally,warn_deprecated,-1,0,0,null,1
+GGally,warn_deprecated,0,0,0,logical,1
+GGally,warn_deprecated,1,0,0,character,1
+GGally,warn_if_args_exist,-1,0,0,null,1
+GGally,warn_if_args_exist,0,0,0,list<any>,1
+GGally,wrap,-1,0,0,class<`ggmatrix_fn_with_params`>,1
+GGally,wrap,0,0,0,character,1
+GGally,wrap,0,0,1,class<`function`>,1
+GGally,wrap,1,0,0,...,1
+GGally,wrap,2,0,0,any,1
+GGally,wrap_fn_with_param_arg,-1,0,0,class<`ggmatrix_fn_with_params`>,1
+GGally,wrap_fn_with_param_arg,0,0,0,character,1
+GGally,wrap_fn_with_param_arg,0,0,1,class<`function`>,1
+GGally,wrap_fn_with_param_arg,0,0,2,class<`ggmatrix_fn_with_params`>,1
+GGally,wrap_fn_with_param_arg,1,0,0,list<any>,1
+GGally,wrap_fn_with_param_arg,1,0,1,character,1
+GGally,wrap_fn_with_param_arg,1,0,2,null,1
+GGally,wrap_fn_with_param_arg,2,0,0,any,1
+GGally,wrapp,-1,0,0,class<`ggmatrix_fn_with_params`>,1
+GGally,wrapp,0,0,0,character,1
+GGally,wrapp,0,0,1,class<`function`>,1
+GGally,wrapp,0,0,2,class<`ggmatrix_fn_with_params`>,1
+GGally,wrapp,1,0,0,list<any>,1
+GGally,wrapp,1,0,1,character,1
+GGally,wrapp,1,0,2,null,1
+GGally,wrapp,2,0,0,any,1
+GIGrvg,dgig,-1,0,0,double[],1
+GIGrvg,dgig,-1,0,1,null,1
+GIGrvg,dgig,0,0,0,double[],1
+GIGrvg,dgig,0,0,1,null,1
+GIGrvg,dgig,1,0,0,double,1
+GIGrvg,dgig,1,0,1,null,1
+GIGrvg,dgig,2,0,0,double,1
+GIGrvg,dgig,2,0,1,null,1
+GIGrvg,dgig,3,0,0,double,1
+GIGrvg,dgig,3,0,1,null,1
+GIGrvg,dgig,4,0,0,logical,1
+GIGrvg,rgig,-1,0,0,any,1
+GIGrvg,rgig,0,0,0,double,1
+GIGrvg,rgig,1,0,0,double,1
+GIGrvg,rgig,2,0,0,double,1
+GIGrvg,rgig,3,0,0,double,1
+GPArotation,bentlerQ,-1,0,0,class<`GPArotation`>,1
+GPArotation,bentlerQ,0,0,0,class<`loadings`>,1
+GPArotation,bentlerQ,1,0,0,class<`matrix`>,1
+GPArotation,bentlerQ,2,0,0,logical,1
+GPArotation,bentlerQ,3,0,0,double,1
+GPArotation,bentlerQ,4,0,0,double,1
+GPArotation,bentlerT,-1,0,0,class<`GPArotation`>,1
+GPArotation,bentlerT,0,0,0,class<`loadings`>,1
+GPArotation,bentlerT,1,0,0,class<`matrix`>,1
+GPArotation,bentlerT,2,0,0,logical,1
+GPArotation,bentlerT,3,0,0,double,1
+GPArotation,bentlerT,4,0,0,double,1
+GPArotation,cfQ,-1,0,0,class<`GPArotation`>,1
+GPArotation,cfQ,0,0,0,class<`loadings`>,1
+GPArotation,cfQ,1,0,0,class<`matrix`>,1
+GPArotation,cfQ,2,0,0,double,1
+GPArotation,cfQ,3,0,0,logical,1
+GPArotation,cfQ,4,0,0,double,1
+GPArotation,cfQ,5,0,0,double,1
+GPArotation,cfT,-1,0,0,class<`GPArotation`>,1
+GPArotation,cfT,0,0,0,class<`loadings`>,1
+GPArotation,cfT,1,0,0,class<`matrix`>,1
+GPArotation,cfT,2,0,0,double,1
+GPArotation,cfT,3,0,0,logical,1
+GPArotation,cfT,4,0,0,double,1
+GPArotation,cfT,5,0,0,double,1
+GPArotation,echelon,-1,0,0,list<class<`matrix`> | character | logical>,1
+GPArotation,echelon,0,0,0,class<`loadings`>,1
+GPArotation,echelon,1,0,0,integer[],1
+GPArotation,echelon,2,0,0,...,1
+GPArotation,eiv,-1,0,0,list<class<`matrix`> | character | logical>,1
+GPArotation,eiv,0,0,0,class<`loadings`>,1
+GPArotation,eiv,1,0,0,integer[],1
+GPArotation,eiv,2,0,0,...,1
+GPArotation,entropy,-1,0,0,class<`GPArotation`>,1
+GPArotation,entropy,0,0,0,class<`loadings`>,1
+GPArotation,entropy,1,0,0,class<`matrix`>,1
+GPArotation,entropy,2,0,0,logical,1
+GPArotation,entropy,3,0,0,double,1
+GPArotation,entropy,4,0,0,double,1
+GPArotation,geominQ,-1,0,0,class<`GPArotation`>,1
+GPArotation,geominQ,0,0,0,class<`loadings`>,1
+GPArotation,geominQ,1,0,0,class<`matrix`>,1
+GPArotation,geominQ,2,0,0,double,1
+GPArotation,geominQ,3,0,0,logical,1
+GPArotation,geominQ,4,0,0,double,1
+GPArotation,geominQ,5,0,0,double,1
+GPArotation,geominT,-1,0,0,class<`GPArotation`>,1
+GPArotation,geominT,0,0,0,class<`loadings`>,1
+GPArotation,geominT,1,0,0,class<`matrix`>,1
+GPArotation,geominT,2,0,0,double,1
+GPArotation,geominT,3,0,0,logical,1
+GPArotation,geominT,4,0,0,double,1
+GPArotation,geominT,5,0,0,double,1
+GPArotation,GPFoblq,-1,0,0,class<`GPArotation`>,1
+GPArotation,GPFoblq,0,0,0,class<`loadings`>,1
+GPArotation,GPFoblq,0,0,1,class<`matrix`>,1
+GPArotation,GPFoblq,1,0,0,class<`matrix`>,1
+GPArotation,GPFoblq,2,0,0,logical,1
+GPArotation,GPFoblq,3,0,0,double,1
+GPArotation,GPFoblq,4,0,0,double,1
+GPArotation,GPFoblq,5,0,0,character,1
+GPArotation,GPFoblq,6,0,0,null,1
+GPArotation,GPFoblq,6,0,1,list<double>,1
+GPArotation,GPFoblq,6,0,2,list<class<`matrix`>>,1
+GPArotation,GPForth,-1,0,0,class<`GPArotation`>,1
+GPArotation,GPForth,0,0,0,class<`loadings`>,1
+GPArotation,GPForth,0,0,1,class<`matrix`>,1
+GPArotation,GPForth,1,0,0,class<`matrix`>,1
+GPArotation,GPForth,2,0,0,logical,1
+GPArotation,GPForth,3,0,0,double,1
+GPArotation,GPForth,4,0,0,double,1
+GPArotation,GPForth,5,0,0,character,1
+GPArotation,GPForth,6,0,0,null,1
+GPArotation,GPForth,6,0,1,list<double>,1
+GPArotation,GPForth,6,0,2,list<class<`matrix`>>,1
+GPArotation,infomaxQ,-1,0,0,class<`GPArotation`>,1
+GPArotation,infomaxQ,0,0,0,class<`loadings`>,1
+GPArotation,infomaxQ,1,0,0,class<`matrix`>,1
+GPArotation,infomaxQ,2,0,0,logical,1
+GPArotation,infomaxQ,3,0,0,double,1
+GPArotation,infomaxQ,4,0,0,double,1
+GPArotation,infomaxT,-1,0,0,class<`GPArotation`>,1
+GPArotation,infomaxT,0,0,0,class<`loadings`>,1
+GPArotation,infomaxT,1,0,0,class<`matrix`>,1
+GPArotation,infomaxT,2,0,0,logical,1
+GPArotation,infomaxT,3,0,0,double,1
+GPArotation,infomaxT,4,0,0,double,1
+GPArotation,mccammon,-1,0,0,class<`GPArotation`>,1
+GPArotation,mccammon,0,0,0,class<`loadings`>,1
+GPArotation,mccammon,1,0,0,class<`matrix`>,1
+GPArotation,mccammon,2,0,0,logical,1
+GPArotation,mccammon,3,0,0,double,1
+GPArotation,mccammon,4,0,0,double,1
+GPArotation,NormalizingWeight,-1,0,0,class<`matrix`>,1
+GPArotation,NormalizingWeight,0,0,0,class<`loadings`>,1
+GPArotation,NormalizingWeight,1,0,0,logical,1
+GPArotation,oblimin,-1,0,0,class<`GPArotation`>,1
+GPArotation,oblimin,0,0,0,class<`loadings`>,1
+GPArotation,oblimin,1,0,0,class<`matrix`>,1
+GPArotation,oblimin,2,0,0,double,1
+GPArotation,oblimin,3,0,0,logical,1
+GPArotation,oblimin,4,0,0,double,1
+GPArotation,oblimin,5,0,0,double,1
+GPArotation,print.GPArotation,-1,0,0,class<`GPArotation`>,1
+GPArotation,print.GPArotation,0,0,0,class<`GPArotation`>,1
+GPArotation,print.GPArotation,1,0,0,double,1
+GPArotation,print.GPArotation,2,0,0,logical,1
+GPArotation,print.GPArotation,3,0,0,...,1
+GPArotation,pstQ,-1,0,0,class<`GPArotation`>,1
+GPArotation,pstQ,0,0,0,class<`loadings`>,1
+GPArotation,pstQ,1,0,0,class<`matrix`>,1
+GPArotation,pstQ,2,0,0,class<`matrix`>,1
+GPArotation,pstQ,3,0,0,class<`matrix`>,1
+GPArotation,pstQ,4,0,0,logical,1
+GPArotation,pstQ,5,0,0,double,1
+GPArotation,pstQ,6,0,0,double,1
+GPArotation,pstT,-1,0,0,class<`GPArotation`>,1
+GPArotation,pstT,0,0,0,class<`loadings`>,1
+GPArotation,pstT,1,0,0,class<`matrix`>,1
+GPArotation,pstT,2,0,0,class<`matrix`>,1
+GPArotation,pstT,3,0,0,class<`matrix`>,1
+GPArotation,pstT,4,0,0,logical,1
+GPArotation,pstT,5,0,0,double,1
+GPArotation,pstT,6,0,0,double,1
+GPArotation,quartimax,-1,0,0,class<`GPArotation`>,1
+GPArotation,quartimax,0,0,0,class<`loadings`>,1
+GPArotation,quartimax,0,0,1,class<`matrix`>,1
+GPArotation,quartimax,1,0,0,class<`matrix`>,1
+GPArotation,quartimax,2,0,0,logical,1
+GPArotation,quartimax,3,0,0,double,1
+GPArotation,quartimax,4,0,0,double,1
+GPArotation,quartimin,-1,0,0,class<`GPArotation`>,1
+GPArotation,quartimin,0,0,0,class<`loadings`>,1
+GPArotation,quartimin,0,0,1,class<`matrix`>,1
+GPArotation,quartimin,1,0,0,class<`matrix`>,1
+GPArotation,quartimin,2,0,0,logical,1
+GPArotation,quartimin,3,0,0,double,1
+GPArotation,quartimin,4,0,0,double,1
+GPArotation,Random.Start,-1,0,0,class<`matrix`>,1
+GPArotation,Random.Start,0,0,0,integer,1
+GPArotation,simplimax,-1,0,0,class<`GPArotation`>,1
+GPArotation,simplimax,0,0,0,class<`loadings`>,1
+GPArotation,simplimax,1,0,0,class<`matrix`>,1
+GPArotation,simplimax,2,0,0,integer,1
+GPArotation,simplimax,3,0,0,logical,1
+GPArotation,simplimax,4,0,0,double,1
+GPArotation,simplimax,5,0,0,double,1
+GPArotation,summary.GPArotation,-1,0,0,class<`summary.GPArotation`>,1
+GPArotation,summary.GPArotation,0,0,0,class<`GPArotation`>,1
+GPArotation,summary.GPArotation,1,0,0,...,1
+GPArotation,tandemI,-1,0,0,class<`GPArotation`>,1
+GPArotation,tandemI,0,0,0,class<`loadings`>,1
+GPArotation,tandemI,1,0,0,class<`matrix`>,1
+GPArotation,tandemI,2,0,0,logical,1
+GPArotation,tandemI,3,0,0,double,1
+GPArotation,tandemI,4,0,0,double,1
+GPArotation,tandemII,-1,0,0,class<`GPArotation`>,1
+GPArotation,tandemII,0,0,0,class<`loadings`>,1
+GPArotation,tandemII,1,0,0,class<`matrix`>,1
+GPArotation,tandemII,2,0,0,logical,1
+GPArotation,tandemII,3,0,0,double,1
+GPArotation,tandemII,4,0,0,double,1
+GPArotation,targetQ,-1,0,0,class<`GPArotation`>,1
+GPArotation,targetQ,0,0,0,class<`loadings`>,1
+GPArotation,targetQ,0,0,1,class<`matrix`>,1
+GPArotation,targetQ,1,0,0,class<`matrix`>,1
+GPArotation,targetQ,2,0,0,class<`matrix`>,1
+GPArotation,targetQ,3,0,0,logical,1
+GPArotation,targetQ,4,0,0,double,1
+GPArotation,targetQ,5,0,0,double,1
+GPArotation,targetT,-1,0,0,class<`GPArotation`>,1
+GPArotation,targetT,0,0,0,class<`loadings`>,1
+GPArotation,targetT,1,0,0,class<`matrix`>,1
+GPArotation,targetT,2,0,0,class<`matrix`>,1
+GPArotation,targetT,3,0,0,logical,1
+GPArotation,targetT,4,0,0,double,1
+GPArotation,targetT,5,0,0,double,1
+GPArotation,Varimax,-1,0,0,class<`GPArotation`>,1
+GPArotation,Varimax,0,0,0,class<`loadings`>,1
+GPArotation,Varimax,0,0,1,class<`matrix`>,1
+GPArotation,Varimax,1,0,0,class<`matrix`>,1
+GPArotation,Varimax,2,0,0,logical,1
+GPArotation,Varimax,3,0,0,double,1
+GPArotation,Varimax,4,0,0,double,1
+GPArotation,vgQ.bentler,-1,0,0,list<class<`matrix`> | double | character>,1
+GPArotation,vgQ.bentler,0,0,0,class<`matrix`>,1
+GPArotation,vgQ.cf,-1,0,0,list<class<`matrix`> | double | character>,1
+GPArotation,vgQ.cf,0,0,0,class<`matrix`>,1
+GPArotation,vgQ.cf,1,0,0,double,1
+GPArotation,vgQ.entropy,-1,0,0,list<class<`matrix`> | double | character>,1
+GPArotation,vgQ.entropy,0,0,0,class<`matrix`>,1
+GPArotation,vgQ.geomin,-1,0,0,list<class<`matrix`> | double | character>,1
+GPArotation,vgQ.geomin,0,0,0,class<`matrix`>,1
+GPArotation,vgQ.geomin,1,0,0,double,1
+GPArotation,vgQ.infomax,-1,0,0,list<class<`matrix`> | double | character>,1
+GPArotation,vgQ.infomax,0,0,0,class<`matrix`>,1
+GPArotation,vgQ.mccammon,-1,0,0,list<class<`matrix`> | double | character>,1
+GPArotation,vgQ.mccammon,0,0,0,class<`matrix`>,1
+GPArotation,vgQ.oblimin,-1,0,0,list<class<`matrix`> | double | character>,1
+GPArotation,vgQ.oblimin,0,0,0,class<`matrix`>,1
+GPArotation,vgQ.oblimin,1,0,0,double,1
+GPArotation,vgQ.pst,-1,0,0,list<class<`matrix`> | double | character>,1
+GPArotation,vgQ.pst,0,0,0,class<`matrix`>,1
+GPArotation,vgQ.pst,1,0,0,class<`matrix`>,1
+GPArotation,vgQ.pst,2,0,0,class<`matrix`>,1
+GPArotation,vgQ.quartimax,-1,0,0,list<class<`matrix`> | double | character>,1
+GPArotation,vgQ.quartimax,0,0,0,class<`matrix`>,1
+GPArotation,vgQ.quartimin,-1,0,0,list<class<`matrix`> | double | character>,1
+GPArotation,vgQ.quartimin,0,0,0,class<`matrix`>,1
+GPArotation,vgQ.simplimax,-1,0,0,list<class<`matrix`> | double | character>,1
+GPArotation,vgQ.simplimax,0,0,0,class<`matrix`>,1
+GPArotation,vgQ.simplimax,1,0,0,integer,1
+GPArotation,vgQ.tandemI,-1,0,0,list<class<`matrix`> | double | character>,1
+GPArotation,vgQ.tandemI,0,0,0,class<`matrix`>,1
+GPArotation,vgQ.tandemII,-1,0,0,list<class<`matrix`> | double | character>,1
+GPArotation,vgQ.tandemII,0,0,0,class<`matrix`>,1
+GPArotation,vgQ.target,-1,0,0,list<class<`matrix`> | double | character>,1
+GPArotation,vgQ.target,0,0,0,class<`matrix`>,1
+GPArotation,vgQ.target,1,0,0,class<`matrix`>,1
+GPArotation,vgQ.varimax,-1,0,0,list<class<`matrix`> | double | character>,1
+GPArotation,vgQ.varimax,0,0,0,class<`matrix`>,1
+GenOrd,contord,-1,0,0,class<`matrix`>,1
+GenOrd,contord,0,0,0,list<double[]>,1
+GenOrd,contord,1,0,0,class<`matrix`>,1
+GenOrd,contord,2,0,0,list<any>,1
+GenOrd,contord,3,0,0,logical,1
+GenOrd,corrcheck,-1,0,0,list<class<`dsyMatrix`>>,1
+GenOrd,corrcheck,0,0,0,list<double[]>,1
+GenOrd,corrcheck,1,0,0,list<any>,1
+GenOrd,corrcheck,2,0,0,logical,1
+GenOrd,ordcont,-1,0,0,list<class<`matrix`> | double>,1
+GenOrd,ordcont,0,0,0,list<double[]>,1
+GenOrd,ordcont,1,0,0,class<`matrix`>,1
+GenOrd,ordcont,2,0,0,list<any>,1
+GenOrd,ordcont,3,0,0,logical,1
+GenOrd,ordcont,4,0,0,double,1
+GenOrd,ordcont,5,0,0,double,1
+GenOrd,ordsample,-1,0,0,class<`matrix`>,1
+GenOrd,ordsample,0,0,0,double,1
+GenOrd,ordsample,1,0,0,list<double[]>,1
+GenOrd,ordsample,2,0,0,class<`matrix`>,1
+GenOrd,ordsample,3,0,0,list<any>,1
+GenOrd,ordsample,4,0,0,logical,1
+GenOrd,ordsample,5,0,0,character,1
+GenSA,GenSA,-1,0,0,list<double[] | class<`matrix`>>,1
+GenSA,GenSA,0,0,0,null,1
+GenSA,GenSA,1,0,0,class<`function`>,1
+GenSA,GenSA,2,0,0,double[],1
+GenSA,GenSA,3,0,0,double[],1
+GenSA,GenSA,4,0,0,list<double>,1
+GenSA,GenSA,5,0,0,...,1
+HDInterval,checkCredMass,-1,0,0,null,1
+HDInterval,checkCredMass,0,0,0,double,1
+HDInterval,hdi,-1,0,0,class<`matrix`>,1
+HDInterval,hdi,-1,0,1,double[],1
+HDInterval,hdi,0,0,0,class<`data.frame`>,1
+HDInterval,hdi,0,0,1,class<`density`>,1
+HDInterval,hdi,0,0,2,class<`function`>,1
+HDInterval,hdi,0,0,3,double[],1
+HDInterval,hdi,1,0,0,double,1
+HDInterval,hdi,2,0,0,...,1
+HDInterval,hdi.data.frame,-1,0,0,class<`matrix`>,1
+HDInterval,hdi.data.frame,0,0,0,class<`data.frame`>,1
+HDInterval,hdi.data.frame,1,0,0,double,1
+HDInterval,hdi.data.frame,2,0,0,...,1
+HDInterval,hdi.default,-1,0,0,double[],1
+HDInterval,hdi.default,0,0,0,double[],1
+HDInterval,hdi.default,1,0,0,double,1
+HDInterval,hdi.default,2,0,0,...,1
+HDInterval,hdi.density,-1,0,0,class<`matrix`>,1
+HDInterval,hdi.density,-1,0,1,double[],1
+HDInterval,hdi.density,0,0,0,class<`density`>,1
+HDInterval,hdi.density,1,0,0,double,1
+HDInterval,hdi.density,2,0,0,logical,1
+HDInterval,hdi.density,3,0,0,...,1
+HDInterval,hdi.function,-1,0,0,double[],1
+HDInterval,hdi.function,0,0,0,class<`function`>,1
+HDInterval,hdi.function,1,0,0,double,1
+HDInterval,hdi.function,2,0,0,any,1
+HDInterval,hdi.function,3,0,0,...,1
+HDInterval,hdiVector,-1,0,0,^double[],1
+HDInterval,hdiVector,0,0,0,character[],1
+HDInterval,hdiVector,0,0,1,double[],1
+HDInterval,hdiVector,1,0,0,double,1
+HDInterval,hdiVector,2,0,0,...,1
+HDInterval,inverseCDF,-1,0,0,double[],1
+HDInterval,inverseCDF,0,0,0,double[],1
+HDInterval,inverseCDF,1,0,0,class<`function`>,1
+HDInterval,inverseCDF,2,0,0,...,1
+ICS,.alg3,-1,0,0,list<double[] | class<`matrix`>>,1
+ICS,.alg3,0,0,0,class<`matrix`>,1
+ICS,.alg3,1,0,0,double[],1
+ICS,.alg3,2,0,0,class<`matrix`>,1
+ICS,.alg3,3,0,0,double,1
+ICS,.alg3,4,0,0,double,1
+ICS,.alg3,5,0,0,double,1
+ICS,coef,-1,0,0,class<`matrix`>,1
+ICS,coef,0,0,0,class<`ics`>,1
+ICS,coef,1,0,0,...,1
+ICS,cov4,-1,0,0,class<`matrix`>,1
+ICS,cov4,0,0,0,class<`matrix`>,1
+ICS,cov4,1,0,0,character,1
+ICS,cov4,2,0,0,class<`function`>,1
+ICS,.cov4moments.mean,-1,0,0,class<`matrix`>,1
+ICS,.cov4moments.mean,0,0,0,class<`matrix`>,1
+ICS,.cov4moments.origin,-1,0,0,class<`matrix`>,1
+ICS,.cov4moments.origin,0,0,0,class<`matrix`>,1
+ICS,cov4.wt,-1,0,0,class<`matrix`>,1
+ICS,cov4.wt,0,0,0,class<`matrix`>,1
+ICS,cov4.wt,1,0,0,double[],1
+ICS,cov4.wt,2,0,0,logical,1
+ICS,cov4.wt,3,0,0,character,1
+ICS,cov4.wt,4,0,0,class<`function`>,1
+ICS,covOrigin,-1,0,0,class<`matrix`>,1
+ICS,covOrigin,0,0,0,class<`matrix`>,1
+ICS,covOrigin,1,0,0,null,1
+ICS,covOrigin,2,0,0,class<`function`>,1
+ICS,fitted,-1,0,0,class<`data.frame`>,1
+ICS,fitted,0,0,0,class<`ics`>,1
+ICS,fitted,1,0,0,...,1
+ICS,frobenius.norm,-1,0,0,double,1
+ICS,frobenius.norm,0,0,0,class<`matrix`>,1
+ICS,ics,-1,0,0,class<`ics`>,1
+ICS,ics,0,0,0,class<`data.frame`>,1
+ICS,ics,0,0,1,class<`matrix`>,1
+ICS,ics,1,0,0,class<`function`>,1
+ICS,ics,1,0,1,class<`matrix`>,1
+ICS,ics,2,0,0,class<`function`>,1
+ICS,ics,2,0,1,class<`matrix`>,1
+ICS,ics,3,0,0,any,1
+ICS,ics,4,0,0,any,1
+ICS,ics,5,0,0,character,1
+ICS,ics,6,0,0,logical,1
+ICS,ics,7,0,0,class<`function`>,1
+ICS,ics2,-1,0,0,class<`ics2`>,1
+ICS,ics2,0,0,0,class<`matrix`>,1
+ICS,ics2,1,0,0,class<`function`>,1
+ICS,ics2,2,0,0,class<`function`>,1
+ICS,ics2,2,0,1,list<double[] | class<`matrix`>>,1
+ICS,ics2,3,0,0,list<any>,1
+ICS,ics2,4,0,0,list<any>,1
+ICS,ics2,5,0,0,class<`function`>,1
+ICS,ics.components,-1,0,0,class<`data.frame`>,1
+ICS,ics.components,0,0,0,class<`ics`>,1
+ICS,mat.sqrt,-1,0,0,class<`matrix`>,1
+ICS,mat.sqrt,0,0,0,class<`matrix`>,1
+ICS,mean3,-1,0,0,double[],1
+ICS,mean3,0,0,0,class<`matrix`>,1
+ICS,mean3,0,0,1,class<`data.frame`>,1
+ICS,mean3,1,0,0,class<`function`>,1
+ICS,Mean3Cov4,-1,0,0,list<double[] | class<`matrix`>>,1
+ICS,Mean3Cov4,0,0,0,class<`matrix`>,1
+ICS,MeanCov,-1,0,0,list<double[] | class<`matrix`>>,1
+ICS,MeanCov,0,0,0,class<`matrix`>,1
+ICS,mvnorm.kur.test,-1,0,0,class<`htest`>,1
+ICS,mvnorm.kur.test,0,0,0,class<`matrix`>,1
+ICS,mvnorm.kur.test,1,0,0,character,1
+ICS,mvnorm.kur.test,2,0,0,double,1
+ICS,mvnorm.kur.test,3,0,0,class<`function`>,1
+ICS,mvnorm.skew.test,-1,0,0,class<`htest`>,1
+ICS,mvnorm.skew.test,0,0,0,class<`matrix`>,1
+ICS,mvnorm.skew.test,1,0,0,class<`function`>,1
+ICS,.norm.mu.V,-1,0,0,double,1
+ICS,.norm.mu.V,0,0,0,double[],1
+ICS,.norm.mu.V,1,0,0,class<`matrix`>,1
+ICS,.norm.mu.V,2,0,0,class<`matrix`>,1
+ICS,plot,-1,0,0,null,1
+ICS,plot,0,0,0,class<`ics`>,1
+ICS,plot,1,0,0,any,1
+ICS,plot,2,0,0,...,1
+ICS,plot,-1,1,0,null,1
+ICS,plot,0,1,0,class<`ics2`>,1
+ICS,plot,1,1,0,any,1
+ICS,plot,2,1,0,...,1
+ICS,screeplot.ics,-1,0,0,null,1
+ICS,screeplot.ics,0,0,0,class<`ics`>,1
+ICS,screeplot.ics,1,0,0,null,1
+ICS,screeplot.ics,2,0,0,character,1
+ICS,screeplot.ics,3,0,0,character,1
+ICS,screeplot.ics,4,0,0,character,1
+ICS,screeplot.ics,5,0,0,character,1
+ICS,screeplot.ics,6,0,0,integer[],1
+ICS,screeplot.ics,7,0,0,logical,1
+ICS,screeplot.ics,8,0,0,...,1
+ICS,summary,-1,0,0,class<`ics`>,1
+ICS,summary,0,0,0,class<`ics`>,1
+ICS,summary,1,0,0,...,1
+ICS,summary,-1,1,0,class<`ics2`>,1
+ICS,summary,0,1,0,class<`ics2`>,1
+ICS,summary,1,1,0,...,1
+ICS,tM,-1,0,0,list<double[] | class<`matrix`>>,1
+ICS,tM,0,0,0,class<`matrix`>,1
+ICS,tM,0,0,1,class<`data.frame`>,1
+ICS,tM,1,0,0,double,1
+ICS,tM,2,0,0,character,1
+ICS,tM,3,0,0,null,1
+ICS,tM,4,0,0,null,1
+ICS,tM,5,0,0,null,1
+ICS,tM,6,0,0,double,1
+ICS,tM,7,0,0,double,1
+ICS,tM,8,0,0,class<`function`>,1
+ICSNP,frobenius.norm,-1,0,0,double,1
+ICSNP,frobenius.norm,0,0,0,class<`matrix`>,1
+ICSNP,MaRaTe.internal,-1,0,0,list<double | class<`matrix`>>,1
+ICSNP,MaRaTe.internal,-1,0,1,list<double>,1
+ICSNP,MaRaTe.internal,0,0,0,class<`matrix`>,1
+ICSNP,MaRaTe.internal,1,0,0,class<`matrix`>,1
+ICSNP,MaRaTe.internal,1,0,1,null,1
+ICSNP,MaRaTe.internal,2,0,0,character,1
+ICSNP,MaRaTe.internal.csample,-1,0,0,list<double | class<`matrix`>>,1
+ICSNP,MaRaTe.internal.csample,0,0,0,class<`matrix`>,1
+ICSNP,MaRaTe.internal.csample,1,0,0,class<`factor`>,1
+ICSNP,MaRaTe.internal.csample,2,0,0,character,1
+ICSNP,MaRaTe.internal.csample,3,0,0,...,1
+ICSNP,mat.sqrt,-1,0,0,class<`matrix`>,1
+ICSNP,mat.sqrt,0,0,0,class<`matrix`>,1
+ICSNP,mycolMeans,-1,0,0,double[],1
+ICSNP,mycolMeans,0,0,0,class<`data.frame`>,1
+ICSNP,mycolMeans,0,0,1,class<`matrix`>,1
+ICSNP,mycolMeans,0,0,2,double[],1
+ICSNP,pair.diff,-1,0,0,class<`matrix`>,1
+ICSNP,pair.diff,0,0,0,class<`matrix`>,1
+ICSNP,pair.prod,-1,0,0,class<`matrix`>,1
+ICSNP,pair.prod,0,0,0,class<`matrix`>,1
+ICSNP,pair.sum,-1,0,0,class<`matrix`>,1
+ICSNP,pair.sum,0,0,0,class<`matrix`>,1
+ICSNP,rank.ctest,-1,0,0,class<`htest`>,1
+ICSNP,rank.ctest,0,0,0,class<`data.frame`>,1
+ICSNP,rank.ctest,0,0,1,class<`formula`>,1
+ICSNP,rank.ctest,0,0,2,class<`ics`>,1
+ICSNP,rank.ctest,0,0,3,class<`matrix`>,1
+ICSNP,rank.ctest,1,0,0,...,1
+ICSNP,rank.ctest.default,-1,0,0,class<`htest`>,1
+ICSNP,rank.ctest.default,0,0,0,class<`data.frame`>,1
+ICSNP,rank.ctest.default,0,0,1,class<`matrix`>,1
+ICSNP,rank.ctest.default,1,0,0,class<`data.frame`>,1
+ICSNP,rank.ctest.default,1,0,1,null,1
+ICSNP,rank.ctest.default,1,0,2,class<`matrix`>,1
+ICSNP,rank.ctest.default,2,0,0,double[],1
+ICSNP,rank.ctest.default,2,0,1,null,1
+ICSNP,rank.ctest.default,3,0,0,character,1
+ICSNP,rank.ctest.default,4,0,0,class<`function`>,1
+ICSNP,rank.ctest.default,5,0,0,...,1
+ICSNP,rank.ctest.formula,-1,0,0,class<`htest`>,1
+ICSNP,rank.ctest.formula,0,0,0,class<`formula`>,1
+ICSNP,rank.ctest.formula,1,0,0,any,1
+ICSNP,rank.ctest.formula,2,0,0,...,1
+ICSNP,rank.ctest.ics,-1,0,0,class<`htest`>,1
+ICSNP,rank.ctest.ics,0,0,0,class<`ics`>,1
+ICSNP,rank.ctest.ics,1,0,0,class<`factor`>,1
+ICSNP,rank.ctest.ics,1,0,1,null,1
+ICSNP,rank.ctest.ics,2,0,0,double[],1
+ICSNP,rank.ctest.ics,3,0,0,any,1
+ICSNP,rank.ctest.ics,4,0,0,...,1
+ICSNP,sumsignout,-1,0,0,class<`matrix`>,1
+ICSNP,sumsignout,0,0,0,class<`matrix`>,1
+ICSNP,T.vdw.loc,-1,0,0,double,1
+ICSNP,T.vdw.loc,0,0,0,double,1
+ICSNP,T.vdw.loc,1,0,0,double[],1
+ICSNP,tyler.shape,-1,0,0,class<`matrix`>,1
+ICSNP,tyler.shape,0,0,0,class<`matrix`>,1
+ICSNP,tyler.shape,1,0,0,double,1
+ICSNP,tyler.shape,1,0,1,null,1
+ICSNP,tyler.shape,2,0,0,null,1
+ICSNP,tyler.shape,3,0,0,double,1
+ICSNP,tyler.shape,4,0,0,double,1
+ICSNP,tyler.shape,5,0,0,double,1
+ICSNP,tyler.shape,6,0,0,logical,1
+ICSNP,tyler.shape,7,0,0,logical,1
+ICSNP,vdw.loc,-1,0,0,double,1
+ICSNP,vdw.loc,0,0,0,double[],1
+ICSNP,vdw.loc,1,0,0,double,1
+ICSNP,vdw.loc,2,0,0,double,1
+ICSNP,vdw.loc,3,0,0,class<`function`>,1
+JADE,amari.error,-1,0,0,double,1
+JADE,amari.error,0,0,0,class<`matrix`>,1
+JADE,amari.error,1,0,0,class<`matrix`>,1
+JADE,amari.error,2,0,0,logical,1
+JADE,AMUSE,-1,0,0,class<`bss`>,1
+JADE,AMUSE,0,0,0,class<`matrix`>,1
+JADE,AMUSE,0,0,1,"class<`matrix`, `mts`, `ts`>",1
+JADE,AMUSE,1,0,0,...,1
+JADE,AMUSE.default,-1,0,0,class<`bss`>,1
+JADE,AMUSE.default,0,0,0,"class<`matrix`, `mts`, `ts`>",1
+JADE,AMUSE.default,0,0,1,class<`matrix`>,1
+JADE,AMUSE.default,1,0,0,double,1
+JADE,AMUSE.default,2,0,0,...,1
+JADE,AMUSE.ts,-1,0,0,class<`bss`>,1
+JADE,AMUSE.ts,0,0,0,"class<`matrix`, `mts`, `ts`>",1
+JADE,AMUSE.ts,1,0,0,...,1
+JADE,bss.components,-1,0,0,"class<`matrix`, `mts`, `ts`>",1
+JADE,bss.components,0,0,0,class<`bss`>,1
+JADE,cjd,-1,0,0,list<class<`matrix`> | class<`array`>>,1
+JADE,cjd,-1,0,1,list<class<`matrix`>>,1
+JADE,cjd,0,0,0,class<`array`>,1
+JADE,cjd,0,0,1,class<`matrix`>,1
+JADE,cjd,1,0,0,double,1
+JADE,cjd,2,0,0,double,1
+JADE,coef.bss,-1,0,0,class<`matrix`>,1
+JADE,coef.bss,0,0,0,class<`bss`>,1
+JADE,coef.bss,1,0,0,...,1
+JADE,ComonGAP,-1,0,0,double,1
+JADE,ComonGAP,0,0,0,class<`matrix`>,1
+JADE,ComonGAP,1,0,0,class<`matrix`>,1
+JADE,djd,-1,0,0,class<`matrix`>,1
+JADE,djd,0,0,0,class<`array`>,1
+JADE,djd,1,0,0,character,1
+JADE,djd,2,0,0,double,1
+JADE,djd,3,0,0,double,1
+JADE,djd,4,0,0,double,1
+JADE,djd.log,-1,0,0,class<`matrix`>,1
+JADE,djd.log,0,0,0,class<`array`>,1
+JADE,djd.log,1,0,0,class<`matrix`>,1
+JADE,djd.log,2,0,0,class<`matrix`>,1
+JADE,djd.log,3,0,0,integer,1
+JADE,djd.log,4,0,0,integer,1
+JADE,djd.log,5,0,0,double,1
+JADE,djd.log,6,0,0,double,1
+JADE,djd.max,-1,0,0,class<`matrix`>,1
+JADE,djd.max,0,0,0,class<`array`>,1
+JADE,djd.max,1,0,0,class<`matrix`>,1
+JADE,djd.max,2,0,0,double,1
+JADE,djd.max,3,0,0,integer,1
+JADE,djd.max,4,0,0,integer,1
+JADE,djd.max,5,0,0,double,1
+JADE,djd.max,6,0,0,double,1
+JADE,djd.max,7,0,0,double,1
+JADE,FOBI,-1,0,0,class<`bss`>,1
+JADE,FOBI,0,0,0,class<`matrix`>,1
+JADE,FOBI,1,0,0,class<`function`>,1
+JADE,frjd,-1,0,0,list<class<`matrix`> | class<`array`> | double>,1
+JADE,frjd,-1,0,1,list<class<`matrix`> | double>,1
+JADE,frjd,0,0,0,class<`array`>,1
+JADE,frjd,0,0,1,class<`matrix`>,1
+JADE,frjd,1,0,0,null,1
+JADE,frjd,2,0,0,double,1
+JADE,frjd,3,0,0,double,1
+JADE,frjd,4,0,0,class<`function`>,1
+JADE,frjd.int,-1,0,0,list<class<`matrix`> | class<`array`> | double>,1
+JADE,frjd.int,0,0,0,class<`array`>,1
+JADE,frjd.int,1,0,0,double,1
+JADE,frjd.int,2,0,0,double,1
+JADE,JADE,-1,0,0,class<`bss`>,1
+JADE,JADE,0,0,0,class<`matrix`>,1
+JADE,JADE,1,0,0,double,1
+JADE,JADE,1,0,1,null,1
+JADE,JADE,2,0,0,double,1
+JADE,JADE,3,0,0,double,1
+JADE,JADE,4,0,0,class<`function`>,1
+JADE,k_JADE,-1,0,0,class<`bss`>,1
+JADE,k_JADE,0,0,0,class<`matrix`>,1
+JADE,k_JADE,1,0,0,double,1
+JADE,k_JADE,2,0,0,double,1
+JADE,k_JADE,3,0,0,double,1
+JADE,k_JADE,4,0,0,class<`function`>,1
+JADE,MD,-1,0,0,double,1
+JADE,MD,0,0,0,class<`matrix`>,1
+JADE,MD,1,0,0,class<`matrix`>,1
+JADE,multscatter,-1,0,0,class<`array`>,1
+JADE,multscatter,0,0,0,character[],1
+JADE,multscatter,1,0,0,class<`matrix`>,1
+JADE,multscatter,2,0,0,logical,1
+JADE,M.x,-1,0,0,class<`matrix`>,1
+JADE,M.x,0,0,0,class<`matrix`>,1
+JADE,M.x,1,0,0,double,1
+JADE,NSS.JD,-1,0,0,class<`bss`>,1
+JADE,NSS.JD,0,0,0,class<`matrix`>,1
+JADE,NSS.JD,1,0,0,...,1
+JADE,NSS.JD.default,-1,0,0,class<`bss`>,1
+JADE,NSS.JD.default,0,0,0,class<`matrix`>,1
+JADE,NSS.JD.default,1,0,0,double,1
+JADE,NSS.JD.default,2,0,0,double,1
+JADE,NSS.JD.default,3,0,0,double[],1
+JADE,NSS.JD.default,3,0,1,null,1
+JADE,NSS.JD.default,4,0,0,double,1
+JADE,NSS.JD.default,5,0,0,double,1
+JADE,NSS.JD.default,6,0,0,...,1
+JADE,NSS.SD,-1,0,0,class<`bss`>,1
+JADE,NSS.SD,0,0,0,class<`matrix`>,1
+JADE,NSS.SD,1,0,0,...,1
+JADE,NSS.SD.default,-1,0,0,class<`bss`>,1
+JADE,NSS.SD.default,0,0,0,class<`matrix`>,1
+JADE,NSS.SD.default,1,0,0,double[],1
+JADE,NSS.SD.default,1,0,1,null,1
+JADE,NSS.SD.default,2,0,0,...,1
+JADE,NSS.TD.JD,-1,0,0,class<`bss`>,1
+JADE,NSS.TD.JD,0,0,0,class<`matrix`>,1
+JADE,NSS.TD.JD,1,0,0,...,1
+JADE,NSS.TD.JD.default,-1,0,0,class<`bss`>,1
+JADE,NSS.TD.JD.default,0,0,0,class<`matrix`>,1
+JADE,NSS.TD.JD.default,1,0,0,double,1
+JADE,NSS.TD.JD.default,2,0,0,double[],1
+JADE,NSS.TD.JD.default,3,0,0,null,1
+JADE,NSS.TD.JD.default,3,0,1,double[],1
+JADE,NSS.TD.JD.default,4,0,0,double,1
+JADE,NSS.TD.JD.default,5,0,0,double,1
+JADE,NSS.TD.JD.default,6,0,0,...,1
+JADE,plot.bss,-1,0,0,null,1
+JADE,plot.bss,0,0,0,class<`bss`>,1
+JADE,plot.bss,1,0,0,...,1
+JADE,pMatrix.min,-1,0,0,list<class<`matrix`> | double[]>,1
+JADE,pMatrix.min,0,0,0,class<`matrix`>,1
+JADE,rand_orth,-1,0,0,class<`matrix`>,1
+JADE,rand_orth,0,0,0,double,1
+JADE,rand_orth,1,0,0,null,1
+JADE,rand_orth,1,0,1,class<`matrix`>,1
+JADE,rjd,-1,0,0,list<class<`matrix`> | class<`array`>>,1
+JADE,rjd,-1,0,1,list<class<`matrix`>>,1
+JADE,rjd,0,0,0,class<`array`>,1
+JADE,rjd,0,0,1,class<`matrix`>,1
+JADE,rjd,1,0,0,double,1
+JADE,rjd,2,0,0,double,1
+JADE,rjd,3,0,0,class<`function`>,1
+JADE,SIR,-1,0,0,double,1
+JADE,SIR,0,0,0,class<`matrix`>,1
+JADE,SIR,1,0,0,class<`matrix`>,1
+JADE,SOBI,-1,0,0,class<`bss`>,1
+JADE,SOBI,0,0,0,class<`matrix`>,1
+JADE,SOBI,0,0,1,"class<`matrix`, `mts`, `ts`>",1
+JADE,SOBI,1,0,0,...,1
+JADE,SOBI.default,-1,0,0,class<`bss`>,1
+JADE,SOBI.default,0,0,0,"class<`matrix`, `mts`, `ts`>",1
+JADE,SOBI.default,0,0,1,class<`matrix`>,1
+JADE,SOBI.default,1,0,0,double[],1
+JADE,SOBI.default,2,0,0,character,1
+JADE,SOBI.default,3,0,0,double,1
+JADE,SOBI.default,4,0,0,double,1
+JADE,SOBI.default,5,0,0,...,1
+JADE,SOBI.ts,-1,0,0,class<`bss`>,1
+JADE,SOBI.ts,0,0,0,"class<`matrix`, `mts`, `ts`>",1
+JADE,SOBI.ts,1,0,0,...,1
+JADE,.standard.B,-1,0,0,class<`matrix`>,1
+JADE,.standard.B,0,0,0,class<`matrix`>,1
+KFAS,approxSSM,-1,0,0,"class<`SSModel`, `approxSSM`>",1
+KFAS,approxSSM,0,0,0,class<`SSModel`>,1
+KFAS,approxSSM,1,0,0,any,1
+KFAS,approxSSM,2,0,0,double,1
+KFAS,approxSSM,3,0,0,double,1
+KFAS,artransform,-1,0,0,double[],1
+KFAS,artransform,0,0,0,double[],1
+KFAS,coef.KFS,-1,0,0,"class<`matrix`, `mts`, `ts`>",1
+KFAS,coef.KFS,-1,0,1,class<`ts`>,1
+KFAS,coef.KFS,-1,0,2,double[],1
+KFAS,coef.KFS,0,0,0,class<`KFS`>,1
+KFAS,coef.KFS,1,0,0,any,1
+KFAS,coef.KFS,2,0,0,double[],1
+KFAS,coef.KFS,2,0,1,null,1
+KFAS,coef.KFS,3,0,0,logical,1
+KFAS,coef.KFS,4,0,0,character[],1
+KFAS,coef.KFS,5,0,0,logical,1
+KFAS,coef.KFS,6,0,0,...,1
+KFAS,coef.SSModel,-1,0,0,"class<`matrix`, `mts`, `ts`>",1
+KFAS,coef.SSModel,-1,0,1,double[],1
+KFAS,coef.SSModel,0,0,0,class<`SSModel`>,1
+KFAS,coef.SSModel,1,0,0,double[],1
+KFAS,coef.SSModel,1,0,1,null,1
+KFAS,coef.SSModel,2,0,0,double[],1
+KFAS,coef.SSModel,2,0,1,null,1
+KFAS,coef.SSModel,3,0,0,logical,1
+KFAS,coef.SSModel,4,0,0,character,1
+KFAS,coef.SSModel,5,0,0,logical,1
+KFAS,coef.SSModel,6,0,0,double,1
+KFAS,coef.SSModel,7,0,0,...,1
+KFAS,fitSSM,-1,0,0,list<class<`SSModel`> | list<double[] | ^integer[] | null>>,1
+KFAS,fitSSM,-1,0,1,list<class<`SSModel`> | list<double[] | character>>,1
+KFAS,fitSSM,-1,0,2,list<class<`SSModel`> | list<any>>,1
+KFAS,fitSSM,-1,0,3,list<class<`SSModel`> | list<double[] | null>>,1
+KFAS,fitSSM,-1,0,4,list<class<`SSModel`> | list<double | integer[] | null>>,1
+KFAS,fitSSM,0,0,0,class<`SSModel`>,1
+KFAS,fitSSM,1,0,0,double[],1
+KFAS,fitSSM,2,0,0,any,1
+KFAS,fitSSM,3,0,0,any,1
+KFAS,fitSSM,4,0,0,null,1
+KFAS,fitSSM,5,0,0,...,1
+KFAS,fitted.KFS,-1,0,0,class<`ts`>,1
+KFAS,fitted.KFS,-1,0,1,double[],1
+KFAS,fitted.KFS,0,0,0,class<`KFS`>,1
+KFAS,fitted.KFS,1,0,0,null,1
+KFAS,fitted.KFS,2,0,0,null,1
+KFAS,fitted.KFS,3,0,0,logical,1
+KFAS,fitted.KFS,4,0,0,...,1
+KFAS,fitted.SSModel,-1,0,0,double[],1
+KFAS,fitted.SSModel,0,0,0,class<`SSModel`>,1
+KFAS,fitted.SSModel,1,0,0,null,1
+KFAS,fitted.SSModel,2,0,0,null,1
+KFAS,fitted.SSModel,3,0,0,logical,1
+KFAS,fitted.SSModel,4,0,0,double,1
+KFAS,fitted.SSModel,5,0,0,...,1
+KFAS,hatvalues.KFS,-1,0,0,class<`ts`>,1
+KFAS,hatvalues.KFS,0,0,0,class<`KFS`>,1
+KFAS,hatvalues.KFS,1,0,0,...,1
+KFAS,importanceSSM,-1,0,0,list<class<`array`> | double[]>,1
+KFAS,importanceSSM,0,0,0,class<`SSModel`>,1
+KFAS,importanceSSM,1,0,0,character[],1
+KFAS,importanceSSM,2,0,0,logical,1
+KFAS,importanceSSM,3,0,0,double,1
+KFAS,importanceSSM,4,0,0,logical,1
+KFAS,importanceSSM,5,0,0,any,1
+KFAS,importanceSSM,6,0,0,logical,1
+KFAS,importanceSSM,7,0,0,double,1
+KFAS,initTheta,-1,0,0,class<`matrix`>,1
+KFAS,initTheta,0,0,0,"class<`matrix`, `mts`, `ts`>",1
+KFAS,initTheta,0,0,1,class<`ts`>,1
+KFAS,initTheta,1,0,0,"class<`matrix`, `mts`, `ts`>",1
+KFAS,initTheta,1,0,1,class<`matrix`>,1
+KFAS,initTheta,1,0,2,class<`ts`>,1
+KFAS,initTheta,2,0,0,character[],1
+KFAS,interval,-1,0,0,list<class<`matrix`>>,1
+KFAS,interval,0,0,0,class<`SSModel`>,1
+KFAS,interval,1,0,0,character,1
+KFAS,interval,2,0,0,double,1
+KFAS,interval,3,0,0,character,1
+KFAS,interval,4,0,0,integer[],1
+KFAS,interval,5,0,0,double,1
+KFAS,interval,6,0,0,logical,1
+KFAS,interval,7,0,0,integer[],1
+KFAS,is.SSModel,-1,0,0,logical,1
+KFAS,is.SSModel,-1,0,1,null,1
+KFAS,is.SSModel,0,0,0,class<`SSModel`>,1
+KFAS,is.SSModel,0,0,1,"class<`SSModel`, `approxSSM`>",1
+KFAS,is.SSModel,1,0,0,logical,1
+KFAS,is.SSModel,2,0,0,logical,1
+KFAS,KFS,-1,0,0,class<`KFS`>,1
+KFAS,KFS,0,0,0,class<`SSModel`>,1
+KFAS,KFS,0,0,1,"class<`SSModel`, `approxSSM`>",1
+KFAS,KFS,1,0,0,any,1
+KFAS,KFS,2,0,0,any,1
+KFAS,KFS,3,0,0,logical,1
+KFAS,KFS,4,0,0,any,1
+KFAS,KFS,5,0,0,any,1
+KFAS,KFS,6,0,0,any,1
+KFAS,KFS,7,0,0,double,1
+KFAS,ldl,-1,0,0,class<`matrix`>,1
+KFAS,ldl,0,0,0,class<`matrix`>,1
+KFAS,ldl,1,0,0,any,1
+KFAS,logLik.SSModel,-1,0,0,double,1
+KFAS,logLik.SSModel,0,0,0,class<`SSModel`>,1
+KFAS,logLik.SSModel,1,0,0,logical,1
+KFAS,logLik.SSModel,2,0,0,double,1
+KFAS,logLik.SSModel,3,0,0,logical,1
+KFAS,logLik.SSModel,4,0,0,any,1
+KFAS,logLik.SSModel,5,0,0,logical,1
+KFAS,logLik.SSModel,6,0,0,any,1
+KFAS,logLik.SSModel,7,0,0,double,1
+KFAS,pearson_standardized,-1,0,0,class<`ts`>,1
+KFAS,pearson_standardized,0,0,0,class<`KFS`>,1
+KFAS,pearson_standardized,1,0,0,character,1
+KFAS,pearson_standardized,2,0,0,double,1
+KFAS,predict.SSModel,-1,0,0,"class<`matrix`, `mts`, `ts`>",1
+KFAS,predict.SSModel,-1,0,1,"list<class<`matrix`, `mts`, `ts`>>",1
+KFAS,predict.SSModel,0,0,0,class<`SSModel`>,1
+KFAS,predict.SSModel,1,0,0,any,1
+KFAS,predict.SSModel,2,0,0,any,1
+KFAS,predict.SSModel,3,0,0,character,1
+KFAS,predict.SSModel,4,0,0,double,1
+KFAS,predict.SSModel,5,0,0,character[],1
+KFAS,predict.SSModel,6,0,0,null,1
+KFAS,predict.SSModel,7,0,0,logical,1
+KFAS,recursive_standardized,-1,0,0,"class<`matrix`, `mts`, `ts`>",1
+KFAS,recursive_standardized,-1,0,1,class<`ts`>,1
+KFAS,recursive_standardized,0,0,0,class<`KFS`>,1
+KFAS,recursive_standardized,1,0,0,character,1
+KFAS,recursive_standardized,2,0,0,double,1
+KFAS,rename_states,-1,0,0,class<`SSModel`>,1
+KFAS,rename_states,0,0,0,class<`SSModel`>,1
+KFAS,rename_states,1,0,0,character,1
+KFAS,rstandard.KFS,-1,0,0,"class<`matrix`, `mts`, `ts`>",1
+KFAS,rstandard.KFS,-1,0,1,class<`ts`>,1
+KFAS,rstandard.KFS,0,0,0,class<`KFS`>,1
+KFAS,rstandard.KFS,1,0,0,character[],1
+KFAS,rstandard.KFS,2,0,0,character[],1
+KFAS,rstandard.KFS,3,0,0,double,1
+KFAS,rstandard.KFS,4,0,0,...,1
+KFAS,signal,-1,0,0,"list<class<`matrix`, `mts`, `ts`> | class<`array`>>",1
+KFAS,signal,-1,0,1,list<class<`ts`> | class<`array`>>,1
+KFAS,signal,0,0,0,class<`KFS`>,1
+KFAS,signal,1,0,0,character[],1
+KFAS,signal,2,0,0,logical,1
+KFAS,simHelper,-1,0,0,list<class<`array`> | class<`matrix`> | double[]>,1
+KFAS,simHelper,0,0,0,class<`SSModel`>,1
+KFAS,simHelper,1,0,0,double,1
+KFAS,simHelper,2,0,0,logical,1
+KFAS,simulateSSM,-1,0,0,class<`array`>,1
+KFAS,simulateSSM,0,0,0,class<`SSModel`>,1
+KFAS,simulateSSM,1,0,0,character[],1
+KFAS,simulateSSM,2,0,0,logical,1
+KFAS,simulateSSM,3,0,0,double,1
+KFAS,simulateSSM,4,0,0,logical,1
+KFAS,simulateSSM,5,0,0,logical,1
+KFAS,SSMarima,-1,0,0,any,1
+KFAS,SSMarima,0,0,0,double[],1
+KFAS,SSMarima,0,0,1,null,1
+KFAS,SSMarima,1,0,0,any,1
+KFAS,SSMarima,2,0,0,double,1
+KFAS,SSMarima,3,0,0,any,1
+KFAS,SSMarima,4,0,0,logical,1
+KFAS,SSMarima,5,0,0,any,1
+KFAS,SSMarima,6,0,0,double,1
+KFAS,SSMarima,7,0,0,null,1
+KFAS,SSMcustom,-1,0,0,list<any>,1
+KFAS,SSMcustom,0,0,0,double,1
+KFAS,SSMcustom,0,0,1,class<`matrix`>,1
+KFAS,SSMcustom,0,0,2,class<`array`>,1
+KFAS,SSMcustom,1,0,0,double,1
+KFAS,SSMcustom,1,0,1,class<`matrix`>,1
+KFAS,SSMcustom,1,0,2,class<`array`>,1
+KFAS,SSMcustom,2,0,0,any,1
+KFAS,SSMcustom,3,0,0,double,1
+KFAS,SSMcustom,3,0,1,null,1
+KFAS,SSMcustom,3,0,2,class<`matrix`>,1
+KFAS,SSMcustom,3,0,3,class<`array`>,1
+KFAS,SSMcustom,4,0,0,any,1
+KFAS,SSMcustom,5,0,0,any,1
+KFAS,SSMcustom,6,0,0,any,1
+KFAS,SSMcustom,7,0,0,integer[],1
+KFAS,SSModel,-1,0,0,class<`SSModel`>,1
+KFAS,SSModel,0,0,0,class<`formula`>,1
+KFAS,SSModel,1,0,0,any,1
+KFAS,SSModel,2,0,0,any,1
+KFAS,SSModel,3,0,0,any,1
+KFAS,SSModel,4,0,0,any,1
+KFAS,SSModel,5,0,0,double,1
+KFAS,[<-.SSModel,-1,0,0,class<`SSModel`>,1
+KFAS,[<-.SSModel,0,0,0,class<`SSModel`>,1
+KFAS,[<-.SSModel,1,0,0,character,1
+KFAS,[<-.SSModel,2,0,0,any,1
+KFAS,[<-.SSModel,3,0,0,any,1
+KFAS,[<-.SSModel,4,0,0,any,1
+KFAS,[<-.SSModel,5,0,0,any,1
+KFAS,[<-.SSModel,6,0,0,...,1
+KFAS,[<-.SSModel,7,0,0,class<`matrix`>,1
+KFAS,[<-.SSModel,7,0,1,double[],1
+KFAS,[.SSModel,-1,0,0,class<`array`>,1
+KFAS,[.SSModel,-1,0,1,class<`matrix`>,1
+KFAS,[.SSModel,-1,0,2,double[],1
+KFAS,[.SSModel,-1,0,3,list<class<`ts`> | class<`array`> | class<`matrix`>>,1
+KFAS,[.SSModel,0,0,0,class<`SSModel`>,1
+KFAS,[.SSModel,1,0,0,character[],1
+KFAS,[.SSModel,2,0,0,any,1
+KFAS,[.SSModel,3,0,0,any,1
+KFAS,[.SSModel,4,0,0,any,1
+KFAS,[.SSModel,5,0,0,any,1
+KFAS,[.SSModel,6,0,0,logical,1
+KFAS,[.SSModel,7,0,0,...,1
+KFAS,SSMregression,-1,0,0,list<any>,1
+KFAS,SSMregression,0,0,0,class<`formula`>,1
+KFAS,SSMregression,0,0,1,list<class<`formula`>>,1
+KFAS,SSMregression,1,0,0,any,1
+KFAS,SSMregression,2,0,0,any,1
+KFAS,SSMregression,3,0,0,any,1
+KFAS,SSMregression,4,0,0,integer[],1
+KFAS,SSMregression,5,0,0,any,1
+KFAS,SSMregression,6,0,0,any,1
+KFAS,SSMregression,7,0,0,any,1
+KFAS,SSMseasonal,-1,0,0,list<any>,1
+KFAS,SSMseasonal,0,0,0,double,1
+KFAS,SSMseasonal,1,0,0,any,1
+KFAS,SSMseasonal,2,0,0,character,1
+KFAS,SSMseasonal,3,0,0,any,1
+KFAS,SSMseasonal,4,0,0,integer,1
+KFAS,SSMseasonal,5,0,0,any,1
+KFAS,SSMseasonal,6,0,0,any,1
+KFAS,SSMseasonal,7,0,0,any,1
+KFAS,SSMtrend,-1,0,0,list<any>,1
+KFAS,SSMtrend,0,0,0,double,1
+KFAS,SSMtrend,1,0,0,list<class<`matrix`>>,1
+KFAS,SSMtrend,1,0,1,list<double>,1
+KFAS,SSMtrend,1,0,2,list<null | double>,1
+KFAS,SSMtrend,1,0,3,double,1
+KFAS,SSMtrend,1,0,4,list<class<`array`>>,1
+KFAS,SSMtrend,1,0,5,list<null>,1
+KFAS,SSMtrend,1,0,6,null,1
+KFAS,SSMtrend,2,0,0,any,1
+KFAS,SSMtrend,3,0,0,integer[],1
+KFAS,SSMtrend,4,0,0,any,1
+KFAS,SSMtrend,5,0,0,any,1
+KFAS,SSMtrend,6,0,0,any,1
+KFAS,SSMtrend,7,0,0,integer,1
+KFAS,state_standardized,-1,0,0,class<`ts`>,1
+KFAS,state_standardized,0,0,0,class<`KFS`>,1
+KFAS,state_standardized,1,0,0,character,1
+KFAS,state_standardized,2,0,0,double,1
+KFAS,transformSSM,-1,0,0,class<`SSModel`>,1
+KFAS,transformSSM,0,0,0,class<`SSModel`>,1
+KFAS,transformSSM,1,0,0,character,1
+KFAS,varianceFilter,-1,0,0,"class<`matrix`, `mts`, `ts`>",1
+KFAS,varianceFilter,0,0,0,class<`KFS`>,1
+Kendall,Kendall,-1,0,0,class<`Kendall`>,1
+Kendall,Kendall,0,0,0,double[],1
+Kendall,Kendall,1,0,0,double[],1
+Kendall,Kendall,1,0,1,class<`ts`>,1
+Kendall,MannKendall,-1,0,0,class<`Kendall`>,1
+Kendall,MannKendall,0,0,0,class<`ts`>,1
+Kendall,MannKendall,0,0,1,double[],1
+Kendall,print.Kendall,-1,0,0,null,1
+Kendall,print.Kendall,0,0,0,class<`Kendall`>,1
+Kendall,print.Kendall,1,0,0,...,1
+Kendall,SeasonalMannKendall,-1,0,0,class<`Kendall`>,1
+Kendall,SeasonalMannKendall,0,0,0,class<`ts`>,1
+Kendall,summary.Kendall,-1,0,0,null,1
+Kendall,summary.Kendall,0,0,0,class<`Kendall`>,1
+Kendall,summary.Kendall,1,0,0,...,1
+KernSmooth,bkde,-1,0,0,list<double[]>,1
+KernSmooth,bkde,0,0,0,double[],1
+KernSmooth,bkde,1,0,0,character,1
+KernSmooth,bkde,2,0,0,logical,1
+KernSmooth,bkde,3,0,0,any,1
+KernSmooth,bkde,4,0,0,double,1
+KernSmooth,bkde,5,0,0,any,1
+KernSmooth,bkde,6,0,0,logical,1
+KernSmooth,bkde2D,-1,0,0,list<double[] | class<`matrix`>>,1
+KernSmooth,bkde2D,0,0,0,class<`matrix`>,1
+KernSmooth,bkde2D,1,0,0,double[],1
+KernSmooth,bkde2D,2,0,0,integer[],1
+KernSmooth,bkde2D,3,0,0,any,1
+KernSmooth,bkde2D,4,0,0,logical,1
+KernSmooth,bkfe,-1,0,0,double,1
+KernSmooth,bkfe,0,0,0,double[],1
+KernSmooth,bkfe,1,0,0,double,1
+KernSmooth,bkfe,2,0,0,double,1
+KernSmooth,bkfe,3,0,0,integer,1
+KernSmooth,bkfe,4,0,0,any,1
+KernSmooth,bkfe,5,0,0,logical,1
+KernSmooth,bkfe,6,0,0,logical,1
+KernSmooth,blkest,-1,0,0,list<double>,1
+KernSmooth,blkest,0,0,0,double[],1
+KernSmooth,blkest,1,0,0,double[],1
+KernSmooth,blkest,2,0,0,integer,1
+KernSmooth,blkest,3,0,0,double,1
+KernSmooth,cpblock,-1,0,0,integer,1
+KernSmooth,cpblock,0,0,0,double[],1
+KernSmooth,cpblock,1,0,0,double[],1
+KernSmooth,cpblock,2,0,0,double,1
+KernSmooth,cpblock,3,0,0,double,1
+KernSmooth,dpih,-1,0,0,double,1
+KernSmooth,dpih,0,0,0,double[],1
+KernSmooth,dpih,1,0,0,character,1
+KernSmooth,dpih,2,0,0,integer,1
+KernSmooth,dpih,3,0,0,integer,1
+KernSmooth,dpih,4,0,0,double[],1
+KernSmooth,dpih,5,0,0,logical,1
+KernSmooth,dpik,-1,0,0,double,1
+KernSmooth,dpik,0,0,0,double[],1
+KernSmooth,dpik,1,0,0,character,1
+KernSmooth,dpik,2,0,0,integer,1
+KernSmooth,dpik,3,0,0,character,1
+KernSmooth,dpik,4,0,0,logical,1
+KernSmooth,dpik,5,0,0,double,1
+KernSmooth,dpik,6,0,0,double[],1
+KernSmooth,dpik,7,0,0,logical,1
+KernSmooth,dpill,-1,0,0,double,1
+KernSmooth,dpill,0,0,0,double[],1
+KernSmooth,dpill,1,0,0,double[],1
+KernSmooth,dpill,2,0,0,double,1
+KernSmooth,dpill,3,0,0,double,1
+KernSmooth,dpill,4,0,0,double,1
+KernSmooth,dpill,5,0,0,double,1
+KernSmooth,dpill,6,0,0,integer,1
+KernSmooth,dpill,7,0,0,double[],1
+KernSmooth,dpill,8,0,0,logical,1
+KernSmooth,linbin,-1,0,0,double[],1
+KernSmooth,linbin,0,0,0,double[],1
+KernSmooth,linbin,1,0,0,double[],1
+KernSmooth,linbin,2,0,0,logical,1
+KernSmooth,linbin2D,-1,0,0,class<`matrix`>,1
+KernSmooth,linbin2D,0,0,0,class<`matrix`>,1
+KernSmooth,linbin2D,1,0,0,double[],1
+KernSmooth,linbin2D,2,0,0,double[],1
+KernSmooth,locpoly,-1,0,0,list<double[]>,1
+KernSmooth,locpoly,0,0,0,double[],1
+KernSmooth,locpoly,1,0,0,any,1
+KernSmooth,locpoly,2,0,0,integer,1
+KernSmooth,locpoly,3,0,0,any,1
+KernSmooth,locpoly,4,0,0,character,1
+KernSmooth,locpoly,5,0,0,double,1
+KernSmooth,locpoly,6,0,0,integer,1
+KernSmooth,locpoly,7,0,0,double,1
+KernSmooth,locpoly,8,0,0,any,1
+KernSmooth,locpoly,9,0,0,logical,1
+KernSmooth,locpoly,10,0,0,logical,1
+KernSmooth,rlbin,-1,0,0,list<double[]>,1
+KernSmooth,rlbin,0,0,0,double[],1
+KernSmooth,rlbin,1,0,0,double[],1
+KernSmooth,rlbin,2,0,0,double[],1
+KernSmooth,rlbin,3,0,0,logical,1
+KernSmooth,sdiag,-1,0,0,list<double[]>,1
+KernSmooth,sdiag,0,0,0,double[],1
+KernSmooth,sdiag,1,0,0,integer,1
+KernSmooth,sdiag,2,0,0,integer,1
+KernSmooth,sdiag,3,0,0,character,1
+KernSmooth,sdiag,4,0,0,double,1
+KernSmooth,sdiag,5,0,0,integer,1
+KernSmooth,sdiag,6,0,0,double,1
+KernSmooth,sdiag,7,0,0,double[],1
+KernSmooth,sdiag,8,0,0,logical,1
+KernSmooth,sdiag,9,0,0,logical,1
+KernSmooth,sstdiag,-1,0,0,list<double[]>,1
+KernSmooth,sstdiag,0,0,0,double[],1
+KernSmooth,sstdiag,1,0,0,integer,1
+KernSmooth,sstdiag,2,0,0,integer,1
+KernSmooth,sstdiag,3,0,0,character,1
+KernSmooth,sstdiag,4,0,0,double,1
+KernSmooth,sstdiag,5,0,0,integer,1
+KernSmooth,sstdiag,6,0,0,double,1
+KernSmooth,sstdiag,7,0,0,double[],1
+KernSmooth,sstdiag,8,0,0,logical,1
+KernSmooth,sstdiag,9,0,0,logical,1
+LearnBayes,bayes.influence,-1,0,0,list<double[] | class<`matrix`>>,1
+LearnBayes,bayes.influence,0,0,0,class<`matrix`>,1
+LearnBayes,bayes.influence,1,0,0,class<`data.frame`>,1
+LearnBayes,bayes.model.selection,-1,0,0,list<class<`data.frame`> | logical[]>,1
+LearnBayes,bayes.model.selection,0,0,0,double[],1
+LearnBayes,bayes.model.selection,1,0,0,class<`matrix`>,1
+LearnBayes,bayes.model.selection,2,0,0,double,1
+LearnBayes,bayes.model.selection,3,0,0,logical,1
+LearnBayes,bayes.probit,-1,0,0,list<class<`matrix`> | double>,1
+LearnBayes,bayes.probit,-1,0,1,list<class<`matrix`> | null>,1
+LearnBayes,bayes.probit,0,0,0,double[],1
+LearnBayes,bayes.probit,1,0,0,class<`matrix`>,1
+LearnBayes,bayes.probit,2,0,0,double,1
+LearnBayes,bayes.probit,3,0,0,list<double[] | class<`matrix`>>,1
+LearnBayes,bayes.probit,3,0,1,list<double>,1
+LearnBayes,bayesresiduals,-1,0,0,double[],1
+LearnBayes,bayesresiduals,0,0,0,class<`lm`>,1
+LearnBayes,bayesresiduals,1,0,0,list<class<`matrix`> | double[]>,1
+LearnBayes,bayesresiduals,2,0,0,double,1
+LearnBayes,betabinexch,-1,0,0,double,1
+LearnBayes,betabinexch,0,0,0,double[],1
+LearnBayes,betabinexch,1,0,0,class<`matrix`>,1
+LearnBayes,betabinexch0,-1,0,0,double,1
+LearnBayes,betabinexch0,0,0,0,double[],1
+LearnBayes,betabinexch0,1,0,0,class<`matrix`>,1
+LearnBayes,beta.select,-1,0,0,double[],1
+LearnBayes,beta.select,0,0,0,list<double>,1
+LearnBayes,beta.select,1,0,0,list<double>,1
+LearnBayes,bfexch,-1,0,0,double,1
+LearnBayes,bfexch,0,0,0,double,1
+LearnBayes,bfexch,1,0,0,list<class<`matrix`> | double>,1
+LearnBayes,bfindep,-1,0,0,list<double>,1
+LearnBayes,bfindep,0,0,0,class<`matrix`>,1
+LearnBayes,bfindep,1,0,0,double,1
+LearnBayes,bfindep,2,0,0,double,1
+LearnBayes,binomial.beta.mix,-1,0,0,list<double[] | class<`matrix`>>,1
+LearnBayes,binomial.beta.mix,0,0,0,double[],1
+LearnBayes,binomial.beta.mix,1,0,0,class<`matrix`>,1
+LearnBayes,binomial.beta.mix,2,0,0,double[],1
+LearnBayes,blinreg,-1,0,0,list<class<`matrix`> | double[]>,1
+LearnBayes,blinreg,0,0,0,double[],1
+LearnBayes,blinreg,1,0,0,class<`matrix`>,1
+LearnBayes,blinreg,2,0,0,double,1
+LearnBayes,blinreg,3,0,0,null,1
+LearnBayes,blinregexpected,-1,0,0,class<`matrix`>,1
+LearnBayes,blinregexpected,0,0,0,class<`matrix`>,1
+LearnBayes,blinregexpected,1,0,0,list<class<`matrix`> | double[]>,1
+LearnBayes,blinregpred,-1,0,0,class<`matrix`>,1
+LearnBayes,blinregpred,0,0,0,class<`matrix`>,1
+LearnBayes,blinregpred,1,0,0,list<class<`matrix`> | double[]>,1
+LearnBayes,bprobit.probs,-1,0,0,class<`matrix`>,1
+LearnBayes,bprobit.probs,0,0,0,class<`matrix`>,1
+LearnBayes,bprobit.probs,1,0,0,class<`matrix`>,1
+LearnBayes,bradley.terry.post,-1,0,0,double,1
+LearnBayes,bradley.terry.post,0,0,0,double[],1
+LearnBayes,bradley.terry.post,1,0,0,class<`data.frame`>,1
+LearnBayes,careertraj.setup,-1,0,0,list<character[] | class<`matrix`> | double[]>,1
+LearnBayes,careertraj.setup,0,0,0,class<`data.frame`>,1
+LearnBayes,cauchyerrorpost,-1,0,0,double,1
+LearnBayes,cauchyerrorpost,0,0,0,double[],1
+LearnBayes,cauchyerrorpost,1,0,0,double[],1
+LearnBayes,ctable,-1,0,0,double,1
+LearnBayes,ctable,0,0,0,class<`matrix`>,1
+LearnBayes,ctable,1,0,0,class<`matrix`>,1
+LearnBayes,discint,-1,0,0,list<double[]>,1
+LearnBayes,discint,0,0,0,class<`matrix`>,1
+LearnBayes,discint,1,0,0,double,1
+LearnBayes,discrete.bayes,-1,0,0,class<`bayes`>,1
+LearnBayes,discrete.bayes,0,0,0,class<`function`>,1
+LearnBayes,discrete.bayes,1,0,0,double[],1
+LearnBayes,discrete.bayes,2,0,0,double[],1
+LearnBayes,discrete.bayes,3,0,0,...,1
+LearnBayes,discrete.bayes.2,-1,0,0,class<`bayes2`>,1
+LearnBayes,discrete.bayes.2,0,0,0,any,1
+LearnBayes,discrete.bayes.2,1,0,0,class<`matrix`>,1
+LearnBayes,discrete.bayes.2,2,0,0,null,1
+LearnBayes,discrete.bayes.2,3,0,0,...,1
+LearnBayes,dmnorm,-1,0,0,double,1
+LearnBayes,dmnorm,0,0,0,double[],1
+LearnBayes,dmnorm,1,0,0,double[],1
+LearnBayes,dmnorm,1,0,1,class<`matrix`>,1
+LearnBayes,dmnorm,2,0,0,class<`matrix`>,1
+LearnBayes,dmnorm,3,0,0,logical,1
+LearnBayes,dmt,-1,0,0,double[],1
+LearnBayes,dmt,0,0,0,class<`matrix`>,1
+LearnBayes,dmt,0,0,1,double[],1
+LearnBayes,dmt,1,0,0,double[],1
+LearnBayes,dmt,2,0,0,class<`matrix`>,1
+LearnBayes,dmt,3,0,0,double,1
+LearnBayes,dmt,4,0,0,logical,1
+LearnBayes,gibbs,-1,0,0,list<class<`matrix`>>,1
+LearnBayes,gibbs,0,0,0,class<`function`>,1
+LearnBayes,gibbs,1,0,0,class<`matrix`>,1
+LearnBayes,gibbs,2,0,0,double,1
+LearnBayes,gibbs,3,0,0,double[],1
+LearnBayes,gibbs,4,0,0,...,1
+LearnBayes,groupeddatapost,-1,0,0,double,1
+LearnBayes,groupeddatapost,0,0,0,double[],1
+LearnBayes,groupeddatapost,1,0,0,list<double[]>,1
+LearnBayes,hiergibbs,-1,0,0,list<class<`matrix`>>,1
+LearnBayes,hiergibbs,0,0,0,class<`data.frame`>,1
+LearnBayes,hiergibbs,1,0,0,double,1
+LearnBayes,histprior,-1,0,0,double[],1
+LearnBayes,histprior,0,0,0,double[],1
+LearnBayes,histprior,1,0,0,double[],1
+LearnBayes,histprior,2,0,0,double[],1
+LearnBayes,howardprior,-1,0,0,double,1
+LearnBayes,howardprior,0,0,0,double[],1
+LearnBayes,howardprior,1,0,0,double[],1
+LearnBayes,impsampling,-1,0,0,list<double | class<`matrix`>>,1
+LearnBayes,impsampling,0,0,0,class<`function`>,1
+LearnBayes,impsampling,1,0,0,list<double[] | class<`matrix`>>,1
+LearnBayes,impsampling,2,0,0,class<`function`>,1
+LearnBayes,impsampling,3,0,0,double,1
+LearnBayes,impsampling,4,0,0,class<`data.frame`>,1
+LearnBayes,indepmetrop,-1,0,0,list<class<`matrix`>>,1
+LearnBayes,indepmetrop,0,0,0,class<`function`>,1
+LearnBayes,indepmetrop,1,0,0,list<class<`matrix`>>,1
+LearnBayes,indepmetrop,2,0,0,class<`matrix`>,1
+LearnBayes,indepmetrop,3,0,0,double,1
+LearnBayes,indepmetrop,4,0,0,...,1
+LearnBayes,laplace,-1,0,0,list<class<`matrix`> | double>,1
+LearnBayes,laplace,-1,0,1,list<double[] | class<`matrix`>>,1
+LearnBayes,laplace,-1,0,2,list<double | class<`matrix`>>,1
+LearnBayes,laplace,0,0,0,class<`function`>,1
+LearnBayes,laplace,1,0,0,class<`matrix`>,1
+LearnBayes,laplace,1,0,1,double[],1
+LearnBayes,laplace,2,0,0,...,1
+LearnBayes,lbinorm,-1,0,0,double,1
+LearnBayes,lbinorm,0,0,0,double[],1
+LearnBayes,lbinorm,1,0,0,list<double[] | class<`matrix`>>,1
+LearnBayes,logctablepost,-1,0,0,double,1
+LearnBayes,logctablepost,0,0,0,double[],1
+LearnBayes,logctablepost,1,0,0,double[],1
+LearnBayes,logisticpost,-1,0,0,double,1
+LearnBayes,logisticpost,0,0,0,double[],1
+LearnBayes,logisticpost,1,0,0,class<`matrix`>,1
+LearnBayes,logpoissgamma,-1,0,0,double[],1
+LearnBayes,logpoissgamma,0,0,0,double[],1
+LearnBayes,logpoissgamma,1,0,0,list<double[]>,1
+LearnBayes,logpoissnormal,-1,0,0,double[],1
+LearnBayes,logpoissnormal,0,0,0,double[],1
+LearnBayes,logpoissnormal,1,0,0,list<double[]>,1
+LearnBayes,mnormt.onesided,-1,0,0,list<double>,1
+LearnBayes,mnormt.onesided,0,0,0,double,1
+LearnBayes,mnormt.onesided,1,0,0,double[],1
+LearnBayes,mnormt.onesided,2,0,0,double[],1
+LearnBayes,mnormt.twosided,-1,0,0,list<double[]>,1
+LearnBayes,mnormt.twosided,0,0,0,double,1
+LearnBayes,mnormt.twosided,1,0,0,double,1
+LearnBayes,mnormt.twosided,2,0,0,double[],1
+LearnBayes,mnormt.twosided,3,0,0,double[],1
+LearnBayes,mycontour,-1,0,0,null,1
+LearnBayes,mycontour,0,0,0,class<`function`>,1
+LearnBayes,mycontour,1,0,0,double[],1
+LearnBayes,mycontour,2,0,0,list<double>,1
+LearnBayes,mycontour,2,0,1,class<`data.frame`>,1
+LearnBayes,mycontour,2,0,2,list<class<`matrix`>>,1
+LearnBayes,mycontour,2,0,3,list<double[] | class<`matrix`>>,1
+LearnBayes,mycontour,3,0,0,...,1
+LearnBayes,normal.normal.mix,-1,0,0,list<double[] | class<`matrix`>>,1
+LearnBayes,normal.normal.mix,0,0,0,double[],1
+LearnBayes,normal.normal.mix,1,0,0,class<`matrix`>,1
+LearnBayes,normal.normal.mix,2,0,0,double[],1
+LearnBayes,normal.select,-1,0,0,list<double>,1
+LearnBayes,normal.select,0,0,0,list<double>,1
+LearnBayes,normal.select,1,0,0,list<double>,1
+LearnBayes,normchi2post,-1,0,0,double,1
+LearnBayes,normchi2post,0,0,0,double[],1
+LearnBayes,normchi2post,1,0,0,double[],1
+LearnBayes,normnormexch,-1,0,0,double,1
+LearnBayes,normnormexch,0,0,0,double[],1
+LearnBayes,normnormexch,1,0,0,class<`matrix`>,1
+LearnBayes,normpostpred,-1,0,0,double[],1
+LearnBayes,normpostpred,0,0,0,list<double[]>,1
+LearnBayes,normpostpred,1,0,0,double,1
+LearnBayes,normpostpred,2,0,0,class<`function`>,1
+LearnBayes,normpostsim,-1,0,0,list<double[]>,1
+LearnBayes,normpostsim,0,0,0,integer[],1
+LearnBayes,normpostsim,1,0,0,null,1
+LearnBayes,normpostsim,2,0,0,double,1
+LearnBayes,ordergibbs,-1,0,0,class<`matrix`>,1
+LearnBayes,ordergibbs,0,0,0,class<`data.frame`>,1
+LearnBayes,ordergibbs,1,0,0,double,1
+LearnBayes,pbetap,-1,0,0,double[],1
+LearnBayes,pbetap,0,0,0,double[],1
+LearnBayes,pbetap,1,0,0,double,1
+LearnBayes,pbetap,2,0,0,integer[],1
+LearnBayes,pbetat,-1,0,0,list<double>,1
+LearnBayes,pbetat,0,0,0,double,1
+LearnBayes,pbetat,1,0,0,double,1
+LearnBayes,pbetat,2,0,0,double[],1
+LearnBayes,pbetat,3,0,0,double[],1
+LearnBayes,pdisc,-1,0,0,double[],1
+LearnBayes,pdisc,0,0,0,double[],1
+LearnBayes,pdisc,1,0,0,double[],1
+LearnBayes,pdisc,2,0,0,double[],1
+LearnBayes,pdiscp,-1,0,0,double[],1
+LearnBayes,pdiscp,0,0,0,double[],1
+LearnBayes,pdiscp,1,0,0,double[],1
+LearnBayes,pdiscp,2,0,0,double,1
+LearnBayes,pdiscp,3,0,0,integer[],1
+LearnBayes,plot.bayes,-1,0,0,class<`matrix`>,1
+LearnBayes,plot.bayes,0,0,0,class<`bayes`>,1
+LearnBayes,plot.bayes,1,0,0,...,1
+LearnBayes,poissgamexch,-1,0,0,double,1
+LearnBayes,poissgamexch,0,0,0,double[],1
+LearnBayes,poissgamexch,1,0,0,list<class<`matrix`> | double>,1
+LearnBayes,poisson.gamma.mix,-1,0,0,list<double[] | class<`matrix`>>,1
+LearnBayes,poisson.gamma.mix,0,0,0,double[],1
+LearnBayes,poisson.gamma.mix,1,0,0,class<`matrix`>,1
+LearnBayes,poisson.gamma.mix,2,0,0,list<double[]>,1
+LearnBayes,predplot,-1,0,0,null,1
+LearnBayes,predplot,0,0,0,double[],1
+LearnBayes,predplot,1,0,0,double,1
+LearnBayes,predplot,2,0,0,double,1
+LearnBayes,print.bayes,-1,0,0,double[],1
+LearnBayes,print.bayes,0,0,0,class<`bayes`>,1
+LearnBayes,print.bayes,1,0,0,...,1
+LearnBayes,prior.two.parameters,-1,0,0,class<`matrix`>,1
+LearnBayes,prior.two.parameters,0,0,0,double[],1
+LearnBayes,prior.two.parameters,1,0,0,double[],1
+LearnBayes,rdirichlet,-1,0,0,class<`matrix`>,1
+LearnBayes,rdirichlet,0,0,0,double,1
+LearnBayes,rdirichlet,1,0,0,double[],1
+LearnBayes,rdirichlet,-1,1,0,class<`matrix`>,1
+LearnBayes,rdirichlet,0,1,0,double,1
+LearnBayes,rdirichlet,1,1,0,double[],1
+LearnBayes,reg.gprior.post,-1,0,0,double,1
+LearnBayes,reg.gprior.post,0,0,0,double[],1
+LearnBayes,reg.gprior.post,1,0,0,list<list<integer[] | class<`matrix`> | double[]>>,1
+LearnBayes,regroup,-1,0,0,class<`matrix`>,1
+LearnBayes,regroup,0,0,0,class<`matrix`>,1
+LearnBayes,regroup,1,0,0,double,1
+LearnBayes,rejectsampling,-1,0,0,class<`matrix`>,1
+LearnBayes,rejectsampling,0,0,0,class<`function`>,1
+LearnBayes,rejectsampling,1,0,0,list<double[] | class<`matrix`>>,1
+LearnBayes,rejectsampling,2,0,0,double,1
+LearnBayes,rejectsampling,3,0,0,double,1
+LearnBayes,rejectsampling,4,0,0,class<`data.frame`>,1
+LearnBayes,rigamma,-1,0,0,double[],1
+LearnBayes,rigamma,0,0,0,double,1
+LearnBayes,rigamma,1,0,0,double,1
+LearnBayes,rigamma,2,0,0,double,1
+LearnBayes,rigamma,-1,1,0,double,1
+LearnBayes,rigamma,0,1,0,double,1
+LearnBayes,rigamma,1,1,0,double,1
+LearnBayes,rigamma,2,1,0,double,1
+LearnBayes,rmnorm,-1,0,0,class<`matrix`>,1
+LearnBayes,rmnorm,0,0,0,double,1
+LearnBayes,rmnorm,1,0,0,double[],1
+LearnBayes,rmnorm,2,0,0,class<`matrix`>,1
+LearnBayes,rmt,-1,0,0,class<`matrix`>,1
+LearnBayes,rmt,0,0,0,double,1
+LearnBayes,rmt,1,0,0,double[],1
+LearnBayes,rmt,2,0,0,class<`matrix`>,1
+LearnBayes,rmt,3,0,0,double,1
+LearnBayes,robustt,-1,0,0,list<class<`matrix`>>,1
+LearnBayes,robustt,0,0,0,double[],1
+LearnBayes,robustt,1,0,0,double,1
+LearnBayes,robustt,2,0,0,double,1
+LearnBayes,rtruncated,-1,0,0,double[],1
+LearnBayes,rtruncated,0,0,0,integer,1
+LearnBayes,rtruncated,1,0,0,double[],1
+LearnBayes,rtruncated,2,0,0,double[],1
+LearnBayes,rtruncated,3,0,0,class<`function`>,1
+LearnBayes,rtruncated,4,0,0,class<`function`>,1
+LearnBayes,rtruncated,5,0,0,...,1
+LearnBayes,rtruncated,-1,1,0,double[],1
+LearnBayes,rtruncated,0,1,0,double,1
+LearnBayes,rtruncated,1,1,0,double,1
+LearnBayes,rtruncated,2,1,0,double,1
+LearnBayes,rtruncated,3,1,0,class<`function`>,1
+LearnBayes,rtruncated,4,1,0,class<`function`>,1
+LearnBayes,rtruncated,5,1,0,...,1
+LearnBayes,rwmetrop,-1,0,0,list<class<`matrix`> | double>,1
+LearnBayes,rwmetrop,0,0,0,class<`function`>,1
+LearnBayes,rwmetrop,1,0,0,list<class<`matrix`> | double>,1
+LearnBayes,rwmetrop,2,0,0,double[],1
+LearnBayes,rwmetrop,2,0,1,class<`matrix`>,1
+LearnBayes,rwmetrop,3,0,0,double,1
+LearnBayes,rwmetrop,4,0,0,...,1
+LearnBayes,simcontour,-1,0,0,list<double[]>,1
+LearnBayes,simcontour,0,0,0,class<`function`>,1
+LearnBayes,simcontour,1,0,0,double[],1
+LearnBayes,simcontour,2,0,0,list<class<`matrix`>>,1
+LearnBayes,simcontour,3,0,0,double,1
+LearnBayes,sir,-1,0,0,class<`matrix`>,1
+LearnBayes,sir,0,0,0,class<`function`>,1
+LearnBayes,sir,1,0,0,list<class<`matrix`> | double>,1
+LearnBayes,sir,1,0,1,list<double[] | class<`matrix`>>,1
+LearnBayes,sir,2,0,0,double,1
+LearnBayes,sir,3,0,0,class<`data.frame`>,1
+LearnBayes,summary.bayes,-1,0,0,list<double[]>,1
+LearnBayes,summary.bayes,0,0,0,class<`bayes`>,1
+LearnBayes,summary.bayes,1,0,0,double,1
+LearnBayes,summary.bayes,2,0,0,...,1
+LearnBayes,transplantpost,-1,0,0,double,1
+LearnBayes,transplantpost,0,0,0,double[],1
+LearnBayes,transplantpost,1,0,0,class<`data.frame`>,1
+LearnBayes,triplot,-1,0,0,list<list<double[]>>,1
+LearnBayes,triplot,0,0,0,double[],1
+LearnBayes,triplot,1,0,0,double[],1
+LearnBayes,triplot,2,0,0,character,1
+LearnBayes,weibullregpost,-1,0,0,double,1
+LearnBayes,weibullregpost,0,0,0,double[],1
+LearnBayes,weibullregpost,1,0,0,class<`matrix`>,1
+MASS,addterm,-1,0,0,"class<`anova`, `data.frame`>",1
+MASS,addterm,0,0,0,"class<`aov`, `lm`>",1
+MASS,addterm,0,0,1,"class<`glm`, `lm`>",1
+MASS,addterm,0,0,2,class<`lme`>,1
+MASS,addterm,0,0,3,class<`polr`>,1
+MASS,addterm,1,0,0,...,1
+MASS,addterm.default,-1,0,0,"class<`anova`, `data.frame`>",1
+MASS,addterm.default,0,0,0,class<`lme`>,1
+MASS,addterm.default,0,0,1,class<`polr`>,1
+MASS,addterm.default,1,0,0,character[],1
+MASS,addterm.default,1,0,1,class<`formula`>,1
+MASS,addterm.default,2,0,0,double,1
+MASS,addterm.default,3,0,0,character[],1
+MASS,addterm.default,4,0,0,double,1
+MASS,addterm.default,5,0,0,logical,1
+MASS,addterm.default,6,0,0,double,1
+MASS,addterm.default,7,0,0,...,1
+MASS,addterm.glm,-1,0,0,"class<`anova`, `data.frame`>",1
+MASS,addterm.glm,0,0,0,"class<`glm`, `lm`>",1
+MASS,addterm.glm,1,0,0,character[],1
+MASS,addterm.glm,1,0,1,class<`formula`>,1
+MASS,addterm.glm,2,0,0,double,1
+MASS,addterm.glm,3,0,0,character[],1
+MASS,addterm.glm,4,0,0,double,1
+MASS,addterm.glm,5,0,0,logical,1
+MASS,addterm.glm,6,0,0,double,1
+MASS,addterm.glm,7,0,0,...,1
+MASS,addterm.lm,-1,0,0,"class<`anova`, `data.frame`>",1
+MASS,addterm.lm,0,0,0,"class<`aov`, `lm`>",1
+MASS,addterm.lm,1,0,0,character[],1
+MASS,addterm.lm,1,0,1,"class<`aov`, `lm`>",1
+MASS,addterm.lm,2,0,0,double,1
+MASS,addterm.lm,3,0,0,character[],1
+MASS,addterm.lm,4,0,0,double,1
+MASS,addterm.lm,5,0,0,logical,1
+MASS,addterm.lm,6,0,0,...,1
+MASS,anova.loglm,-1,0,0,class<`anova.loglm`>,1
+MASS,anova.loglm,0,0,0,class<`loglm`>,1
+MASS,anova.loglm,1,0,0,...,1
+MASS,anova.loglm,2,0,0,character[],1
+MASS,anova.negbin,-1,0,0,"class<`anova`, `data.frame`>",1
+MASS,anova.negbin,-1,0,1,"class<`Anova`, `data.frame`>",1
+MASS,anova.negbin,0,0,0,"class<`glm`, `lm`, `negbin`>",1
+MASS,anova.negbin,1,0,0,...,1
+MASS,anova.negbin,2,0,0,character,1
+MASS,anova.polr,-1,0,0,"class<`Anova`, `data.frame`>",1
+MASS,anova.polr,0,0,0,class<`polr`>,1
+MASS,anova.polr,1,0,0,...,1
+MASS,anova.polr,2,0,0,character[],1
+MASS,area,-1,0,0,double,1
+MASS,area,0,0,0,class<`function`>,1
+MASS,area,1,0,0,double,1
+MASS,area,2,0,0,double,1
+MASS,area,3,0,0,...,1
+MASS,area,4,0,0,double,1
+MASS,area,5,0,0,double,1
+MASS,area,6,0,0,any,1
+MASS,area,7,0,0,double,1
+MASS,bandwidth.nrd,-1,0,0,double,1
+MASS,bandwidth.nrd,0,0,0,double[],1
+MASS,bcv,-1,0,0,double,1
+MASS,bcv,0,0,0,double[],1
+MASS,bcv,1,0,0,double,1
+MASS,bcv,2,0,0,double,1
+MASS,bcv,3,0,0,double,1
+MASS,biplot.bdr,-1,0,0,null,1
+MASS,biplot.bdr,0,0,0,class<`matrix`>,1
+MASS,biplot.bdr,1,0,0,class<`matrix`>,1
+MASS,biplot.bdr,2,0,0,any,1
+MASS,biplot.bdr,3,0,0,double[],1
+MASS,biplot.bdr,4,0,0,null,1
+MASS,biplot.bdr,5,0,0,null,1
+MASS,biplot.bdr,6,0,0,null,1
+MASS,biplot.bdr,7,0,0,null,1
+MASS,biplot.correspondence,-1,0,0,null,1
+MASS,biplot.correspondence,0,0,0,class<`correspondence`>,1
+MASS,biplot.correspondence,1,0,0,character[],1
+MASS,biplot.correspondence,2,0,0,...,1
+MASS,boxcox,-1,0,0,list<double[]>,1
+MASS,boxcox,0,0,0,class<`formula`>,1
+MASS,boxcox,1,0,0,...,1
+MASS,boxcox.default,-1,0,0,list<double[]>,1
+MASS,boxcox.default,0,0,0,class<`lm`>,1
+MASS,boxcox.default,1,0,0,double[],1
+MASS,boxcox.default,2,0,0,logical,1
+MASS,boxcox.default,3,0,0,logical,1
+MASS,boxcox.default,4,0,0,double,1
+MASS,boxcox.default,5,0,0,expression,1
+MASS,boxcox.default,6,0,0,character,1
+MASS,boxcox.default,7,0,0,...,1
+MASS,boxcox.formula,-1,0,0,list<double[]>,1
+MASS,boxcox.formula,0,0,0,class<`formula`>,1
+MASS,boxcox.formula,1,0,0,double[],1
+MASS,boxcox.formula,2,0,0,logical,1
+MASS,boxcox.formula,3,0,0,any,1
+MASS,boxcox.formula,4,0,0,any,1
+MASS,boxcox.formula,5,0,0,any,1
+MASS,boxcox.formula,6,0,0,character,1
+MASS,boxcox.formula,7,0,0,...,1
+MASS,confint.glm,-1,0,0,class<`matrix`>,1
+MASS,confint.glm,-1,0,1,double[],1
+MASS,confint.glm,0,0,0,"class<`glm`, `lm`>",1
+MASS,confint.glm,1,0,0,any,1
+MASS,confint.glm,2,0,0,double,1
+MASS,confint.glm,3,0,0,logical,1
+MASS,confint.glm,4,0,0,...,1
+MASS,confint.nls,-1,0,0,double[],1
+MASS,confint.nls,0,0,0,class<`nls`>,1
+MASS,confint.nls,1,0,0,character,1
+MASS,confint.nls,2,0,0,double,1
+MASS,confint.nls,3,0,0,...,1
+MASS,confint.profile.glm,-1,0,0,class<`matrix`>,1
+MASS,confint.profile.glm,-1,0,1,double[],1
+MASS,confint.profile.glm,0,0,0,"class<`profile`, `profile.glm`>",1
+MASS,confint.profile.glm,1,0,0,integer[],1
+MASS,confint.profile.glm,2,0,0,double,1
+MASS,confint.profile.glm,3,0,0,...,1
+MASS,confint.profile.nls,-1,0,0,double[],1
+MASS,confint.profile.nls,0,0,0,"class<`profile`, `profile.nls`>",1
+MASS,confint.profile.nls,1,0,0,character,1
+MASS,confint.profile.nls,2,0,0,double,1
+MASS,confint.profile.nls,3,0,0,...,1
+MASS,confint.profile.polr,-1,0,0,class<`matrix`>,1
+MASS,confint.profile.polr,0,0,0,"class<`profile`, `profile.polr`>",1
+MASS,confint.profile.polr,1,0,0,integer[],1
+MASS,confint.profile.polr,2,0,0,double,1
+MASS,confint.profile.polr,3,0,0,...,1
+MASS,contr.sdif,-1,0,0,class<`matrix`>,1
+MASS,contr.sdif,0,0,0,double,1
+MASS,contr.sdif,1,0,0,logical,1
+MASS,contr.sdif,2,0,0,logical,1
+MASS,corresp,-1,0,0,class<`correspondence`>,1
+MASS,corresp,0,0,0,class<`data.frame`>,1
+MASS,corresp,0,0,1,class<`formula`>,1
+MASS,corresp,1,0,0,...,1
+MASS,corresp.data.frame,-1,0,0,class<`correspondence`>,1
+MASS,corresp.data.frame,0,0,0,class<`data.frame`>,1
+MASS,corresp.data.frame,1,0,0,...,1
+MASS,corresp.formula,-1,0,0,class<`correspondence`>,1
+MASS,corresp.formula,0,0,0,class<`formula`>,1
+MASS,corresp.formula,1,0,0,class<`data.frame`>,1
+MASS,corresp.formula,2,0,0,...,1
+MASS,corresp.matrix,-1,0,0,class<`correspondence`>,1
+MASS,corresp.matrix,0,0,0,class<`matrix`>,1
+MASS,corresp.matrix,0,0,1,class<`table`>,1
+MASS,corresp.matrix,1,0,0,double,1
+MASS,corresp.matrix,2,0,0,...,1
+MASS,cov.rob,-1,0,0,list<double[] | class<`matrix`> | character>,1
+MASS,cov.rob,0,0,0,class<`matrix`>,1
+MASS,cov.rob,0,0,1,class<`data.frame`>,1
+MASS,cov.rob,1,0,0,logical,1
+MASS,cov.rob,2,0,0,double,1
+MASS,cov.rob,3,0,0,character[],1
+MASS,cov.rob,4,0,0,character,1
+MASS,cov.rob,5,0,0,any,1
+MASS,cov.trob,-1,0,0,list<class<`matrix`> | double[] | class<`call`>>,1
+MASS,cov.trob,0,0,0,class<`data.frame`>,1
+MASS,cov.trob,1,0,0,double[],1
+MASS,cov.trob,2,0,0,logical,1
+MASS,cov.trob,3,0,0,logical,1
+MASS,cov.trob,4,0,0,double,1
+MASS,cov.trob,5,0,0,double,1
+MASS,cov.trob,6,0,0,double,1
+MASS,denumerate,-1,0,0,class<`formula`>,1
+MASS,denumerate,-1,0,1,"class<`formula`, `terms`>",1
+MASS,denumerate,0,0,0,class<`formula`>,1
+MASS,denumerate,0,0,1,"class<`formula`, `terms`>",1
+MASS,denumerate.formula,-1,0,0,class<`(`>,1
+MASS,denumerate.formula,-1,0,1,class<`call`>,1
+MASS,denumerate.formula,-1,0,2,class<`name`>,1
+MASS,denumerate.formula,-1,0,3,class<`formula`>,1
+MASS,denumerate.formula,-1,0,4,"class<`formula`, `terms`>",1
+MASS,denumerate.formula,0,0,0,class<`(`>,1
+MASS,denumerate.formula,0,0,1,class<`call`>,1
+MASS,denumerate.formula,0,0,2,class<`name`>,1
+MASS,denumerate.formula,0,0,3,double,1
+MASS,denumerate.formula,0,0,4,class<`formula`>,1
+MASS,denumerate.formula,0,0,5,"class<`formula`, `terms`>",1
+MASS,dose.p,-1,0,0,class<`glm.dose`>,1
+MASS,dose.p,0,0,0,"class<`glm`, `lm`>",1
+MASS,dose.p,1,0,0,double[],1
+MASS,dose.p,2,0,0,double[],1
+MASS,dropterm,-1,0,0,"class<`anova`, `data.frame`>",1
+MASS,dropterm,0,0,0,"class<`aov`, `lm`>",1
+MASS,dropterm,0,0,1,"class<`glm`, `lm`>",1
+MASS,dropterm,0,0,2,"class<`glm`, `lm`, `negbin`>",1
+MASS,dropterm,0,0,3,class<`gls`>,1
+MASS,dropterm,0,0,4,class<`lm`>,1
+MASS,dropterm,0,0,5,class<`lme`>,1
+MASS,dropterm,0,0,6,class<`polr`>,1
+MASS,dropterm,1,0,0,...,1
+MASS,dropterm.default,-1,0,0,"class<`anova`, `data.frame`>",1
+MASS,dropterm.default,0,0,0,"class<`glm`, `lm`, `negbin`>",1
+MASS,dropterm.default,0,0,1,class<`gls`>,1
+MASS,dropterm.default,0,0,2,class<`lme`>,1
+MASS,dropterm.default,0,0,3,class<`polr`>,1
+MASS,dropterm.default,1,0,0,character[],1
+MASS,dropterm.default,2,0,0,double,1
+MASS,dropterm.default,3,0,0,character[],1
+MASS,dropterm.default,4,0,0,double,1
+MASS,dropterm.default,5,0,0,logical,1
+MASS,dropterm.default,6,0,0,double,1
+MASS,dropterm.default,7,0,0,...,1
+MASS,dropterm.glm,-1,0,0,"class<`anova`, `data.frame`>",1
+MASS,dropterm.glm,0,0,0,"class<`glm`, `lm`>",1
+MASS,dropterm.glm,1,0,0,any,1
+MASS,dropterm.glm,2,0,0,double,1
+MASS,dropterm.glm,3,0,0,character[],1
+MASS,dropterm.glm,4,0,0,double,1
+MASS,dropterm.glm,5,0,0,logical,1
+MASS,dropterm.glm,6,0,0,double,1
+MASS,dropterm.glm,7,0,0,...,1
+MASS,dropterm.lm,-1,0,0,"class<`anova`, `data.frame`>",1
+MASS,dropterm.lm,0,0,0,"class<`aov`, `lm`>",1
+MASS,dropterm.lm,0,0,1,class<`lm`>,1
+MASS,dropterm.lm,1,0,0,character[],1
+MASS,dropterm.lm,2,0,0,double,1
+MASS,dropterm.lm,3,0,0,character[],1
+MASS,dropterm.lm,4,0,0,double,1
+MASS,dropterm.lm,5,0,0,logical,1
+MASS,dropterm.lm,6,0,0,...,1
+MASS,dropterm.negbin,-1,0,0,"class<`anova`, `data.frame`>",1
+MASS,dropterm.negbin,0,0,0,"class<`glm`, `lm`, `negbin`>",1
+MASS,dropterm.negbin,1,0,0,...,1
+MASS,eqscplot,-1,0,0,null,1
+MASS,eqscplot,0,0,0,class<`matrix`>,1
+MASS,eqscplot,1,0,0,any,1
+MASS,eqscplot,2,0,0,double,1
+MASS,eqscplot,3,0,0,double,1
+MASS,eqscplot,4,0,0,any,1
+MASS,eqscplot,5,0,0,...,1
+MASS,extractAIC.polr,-1,0,0,double[],1
+MASS,extractAIC.polr,0,0,0,class<`polr`>,1
+MASS,extractAIC.polr,1,0,0,any,1
+MASS,extractAIC.polr,2,0,0,double,1
+MASS,extractAIC.polr,3,0,0,...,1
+MASS,fitdistr,-1,0,0,class<`fitdistr`>,1
+MASS,fitdistr,0,0,0,double[],1
+MASS,fitdistr,1,0,0,character,1
+MASS,fitdistr,1,0,1,class<`function`>,1
+MASS,fitdistr,2,0,0,any,1
+MASS,fitdistr,3,0,0,...,1
+MASS,fractions,-1,0,0,"class<`fractions`, `matrix`>",1
+MASS,fractions,0,0,0,class<`matrix`>,1
+MASS,fractions,1,0,0,double,1
+MASS,fractions,2,0,0,double,1
+MASS,fractions,3,0,0,...,1
+MASS,gamma.dispersion,-1,0,0,double,1
+MASS,gamma.dispersion,0,0,0,"class<`glm`, `lm`>",1
+MASS,gamma.dispersion,1,0,0,...,1
+MASS,gamma.shape,-1,0,0,class<`gamma.shape`>,1
+MASS,gamma.shape,0,0,0,"class<`glm`, `lm`>",1
+MASS,gamma.shape,1,0,0,...,1
+MASS,gamma.shape.glm,-1,0,0,class<`gamma.shape`>,1
+MASS,gamma.shape.glm,0,0,0,"class<`glm`, `lm`>",1
+MASS,gamma.shape.glm,1,0,0,double,1
+MASS,gamma.shape.glm,2,0,0,double,1
+MASS,gamma.shape.glm,3,0,0,logical,1
+MASS,gamma.shape.glm,4,0,0,...,1
+MASS,ginv,-1,0,0,class<`matrix`>,1
+MASS,ginv,0,0,0,class<`matrix`>,1
+MASS,ginv,1,0,0,double,1
+MASS,glm.convert,-1,0,0,"class<`glm`, `lm`>",1
+MASS,glm.convert,0,0,0,"class<`glm`, `lm`, `negbin`>",1
+MASS,glmmPQL,-1,0,0,"class<`glmmPQL`, `lme`>",1
+MASS,glmmPQL,0,0,0,class<`formula`>,1
+MASS,glmmPQL,1,0,0,class<`formula`>,1
+MASS,glmmPQL,2,0,0,class<`function`>,1
+MASS,glmmPQL,3,0,0,class<`data.frame`>,1
+MASS,glmmPQL,4,0,0,any,1
+MASS,glmmPQL,5,0,0,any,1
+MASS,glmmPQL,6,0,0,any,1
+MASS,glmmPQL,7,0,0,double,1
+MASS,glm.nb,-1,0,0,any,1
+MASS,glm.nb,0,0,0,any,1
+MASS,glm.nb,1,0,0,any,1
+MASS,glm.nb,2,0,0,any,1
+MASS,glm.nb,3,0,0,any,1
+MASS,glm.nb,4,0,0,any,1
+MASS,glm.nb,5,0,0,null,1
+MASS,glm.nb,5,0,1,double[],1
+MASS,glm.nb,6,0,0,any,1
+MASS,glm.nb,7,0,0,any,1
+MASS,huber,-1,0,0,list<double>,1
+MASS,huber,0,0,0,double[],1
+MASS,huber,1,0,0,double,1
+MASS,huber,2,0,0,double,1
+MASS,hubers,-1,0,0,list<double>,1
+MASS,hubers,0,0,0,double[],1
+MASS,hubers,1,0,0,double,1
+MASS,hubers,2,0,0,any,1
+MASS,hubers,3,0,0,any,1
+MASS,hubers,4,0,0,any,1
+MASS,hubers,5,0,0,double,1
+MASS,isoMDS,-1,0,0,list<class<`matrix`> | double>,1
+MASS,isoMDS,0,0,0,class<`dist`>,1
+MASS,isoMDS,1,0,0,class<`matrix`>,1
+MASS,isoMDS,2,0,0,double,1
+MASS,isoMDS,3,0,0,double,1
+MASS,isoMDS,4,0,0,logical,1
+MASS,isoMDS,5,0,0,double,1
+MASS,isoMDS,6,0,0,double,1
+MASS,kde2d,-1,0,0,list<double[] | class<`matrix`>>,1
+MASS,kde2d,0,0,0,double[],1
+MASS,kde2d,1,0,0,double[],1
+MASS,kde2d,2,0,0,any,1
+MASS,kde2d,3,0,0,double,1
+MASS,kde2d,4,0,0,double[],1
+MASS,lda,-1,0,0,class<`lda`>,1
+MASS,lda,0,0,0,any,1
+MASS,lda,1,0,0,...,1
+MASS,lda.default,-1,0,0,class<`lda`>,1
+MASS,lda.default,0,0,0,class<`matrix`>,1
+MASS,lda.default,1,0,0,class<`factor`>,1
+MASS,lda.default,2,0,0,double[],1
+MASS,lda.default,3,0,0,double,1
+MASS,lda.default,4,0,0,character[],1
+MASS,lda.default,5,0,0,logical,1
+MASS,lda.default,6,0,0,double,1
+MASS,lda.default,7,0,0,...,1
+MASS,lda.formula,-1,0,0,class<`lda`>,1
+MASS,lda.formula,0,0,0,class<`formula`>,1
+MASS,lda.formula,1,0,0,any,1
+MASS,lda.formula,2,0,0,...,1
+MASS,lda.formula,3,0,0,any,1
+MASS,lda.formula,4,0,0,any,1
+MASS,lda.matrix,-1,0,0,class<`lda`>,1
+MASS,lda.matrix,0,0,0,class<`matrix`>,1
+MASS,lda.matrix,1,0,0,class<`factor`>,1
+MASS,lda.matrix,2,0,0,...,1
+MASS,lda.matrix,3,0,0,any,1
+MASS,lda.matrix,4,0,0,any,1
+MASS,lm.ridge,-1,0,0,class<`ridgelm`>,1
+MASS,lm.ridge,0,0,0,any,1
+MASS,lm.ridge,1,0,0,any,1
+MASS,lm.ridge,2,0,0,any,1
+MASS,lm.ridge,3,0,0,any,1
+MASS,lm.ridge,4,0,0,double[],1
+MASS,lm.ridge,5,0,0,logical,1
+MASS,lm.ridge,6,0,0,logical,1
+MASS,lm.ridge,7,0,0,logical,1
+MASS,lmwork,-1,0,0,list<double[]>,1
+MASS,lmwork,0,0,0,"class<`aov`, `lm`>",1
+MASS,logLik.glmmPQL,-1,0,0,class<`logLik`>,1
+MASS,logLik.glmmPQL,0,0,0,"class<`glmmPQL`, `lme`>",1
+MASS,logLik.glmmPQL,1,0,0,...,1
+MASS,loglm,-1,0,0,class<`loglm`>,1
+MASS,loglm,0,0,0,any,1
+MASS,loglm,1,0,0,class<`data.frame`>,1
+MASS,loglm,1,0,1,"class<`table`, `xtabs`>",1
+MASS,loglm,2,0,0,any,1
+MASS,loglm,3,0,0,any,1
+MASS,loglm,4,0,0,...,1
+MASS,loglm1,-1,0,0,class<`loglm`>,1
+MASS,loglm1,0,0,0,any,1
+MASS,loglm1,1,0,0,class<`data.frame`>,1
+MASS,loglm1,1,0,1,"class<`table`, `xtabs`>",1
+MASS,loglm1,2,0,0,...,1
+MASS,loglm1.data.frame,-1,0,0,class<`loglm`>,1
+MASS,loglm1.data.frame,0,0,0,any,1
+MASS,loglm1.data.frame,1,0,0,class<`data.frame`>,1
+MASS,loglm1.data.frame,2,0,0,...,1
+MASS,loglm1.default,-1,0,0,class<`loglm`>,1
+MASS,loglm1.default,0,0,0,any,1
+MASS,loglm1.default,1,0,0,class<`array`>,1
+MASS,loglm1.default,1,0,1,class<`matrix`>,1
+MASS,loglm1.default,2,0,0,class<`array`>,1
+MASS,loglm1.default,2,0,1,double[],1
+MASS,loglm1.default,3,0,0,logical,1
+MASS,loglm1.default,4,0,0,logical,1
+MASS,loglm1.default,5,0,0,logical,1
+MASS,loglm1.default,6,0,0,double,1
+MASS,loglm1.default,7,0,0,double,1
+MASS,loglm1.xtabs,-1,0,0,class<`loglm`>,1
+MASS,loglm1.xtabs,0,0,0,any,1
+MASS,loglm1.xtabs,1,0,0,"class<`table`, `xtabs`>",1
+MASS,loglm1.xtabs,2,0,0,...,1
+MASS,logtrans,-1,0,0,list<double[]>,1
+MASS,logtrans,0,0,0,class<`formula`>,1
+MASS,logtrans,1,0,0,...,1
+MASS,logtrans.default,-1,0,0,list<double[]>,1
+MASS,logtrans.default,0,0,0,"class<`aov`, `lm`>",1
+MASS,logtrans.default,1,0,0,...,1
+MASS,logtrans.default,2,0,0,double[],1
+MASS,logtrans.default,3,0,0,logical,1
+MASS,logtrans.default,4,0,0,logical,1
+MASS,logtrans.default,5,0,0,character,1
+MASS,logtrans.default,6,0,0,character,1
+MASS,logtrans.formula,-1,0,0,list<double[]>,1
+MASS,logtrans.formula,0,0,0,class<`formula`>,1
+MASS,logtrans.formula,1,0,0,class<`data.frame`>,1
+MASS,logtrans.formula,2,0,0,...,1
+MASS,lqs,-1,0,0,class<`lqs`>,1
+MASS,lqs,0,0,0,class<`formula`>,1
+MASS,lqs,0,0,1,class<`matrix`>,1
+MASS,lqs,1,0,0,...,1
+MASS,lqs.default,-1,0,0,class<`lqs`>,1
+MASS,lqs.default,0,0,0,class<`matrix`>,1
+MASS,lqs.default,1,0,0,double[],1
+MASS,lqs.default,2,0,0,logical,1
+MASS,lqs.default,3,0,0,character[],1
+MASS,lqs.default,4,0,0,any,1
+MASS,lqs.default,5,0,0,list<null | character | logical>,1
+MASS,lqs.default,5,0,1,list<null | integer>,1
+MASS,lqs.default,6,0,0,double,1
+MASS,lqs.default,7,0,0,any,1
+MASS,lqs.formula,-1,0,0,class<`lqs`>,1
+MASS,lqs.formula,0,0,0,class<`formula`>,1
+MASS,lqs.formula,1,0,0,any,1
+MASS,lqs.formula,2,0,0,...,1
+MASS,lqs.formula,3,0,0,character[],1
+MASS,lqs.formula,4,0,0,any,1
+MASS,lqs.formula,5,0,0,any,1
+MASS,lqs.formula,6,0,0,logical,1
+MASS,lqs.formula,7,0,0,logical,1
+MASS,mca,-1,0,0,class<`mca`>,1
+MASS,mca,0,0,0,class<`data.frame`>,1
+MASS,mca,1,0,0,double,1
+MASS,mca,2,0,0,logical,1
+MASS,model.frame.polr,-1,0,0,class<`data.frame`>,1
+MASS,model.frame.polr,0,0,0,class<`polr`>,1
+MASS,model.frame.polr,1,0,0,...,1
+MASS,mvrnorm,-1,0,0,class<`matrix`>,1
+MASS,mvrnorm,0,0,0,double,1
+MASS,mvrnorm,1,0,0,double[],1
+MASS,mvrnorm,2,0,0,class<`matrix`>,1
+MASS,mvrnorm,3,0,0,double,1
+MASS,mvrnorm,4,0,0,logical,1
+MASS,mvrnorm,5,0,0,logical,1
+MASS,negative.binomial,-1,0,0,class<`family`>,1
+MASS,negative.binomial,0,0,0,double,1
+MASS,negative.binomial,1,0,0,any,1
+MASS,nobs.polr,-1,0,0,integer,1
+MASS,nobs.polr,0,0,0,class<`polr`>,1
+MASS,nobs.polr,1,0,0,...,1
+MASS,Ops.fractions,-1,0,0,"class<`fractions`, `matrix`>",1
+MASS,Ops.fractions,0,0,0,"class<`fractions`, `matrix`>",1
+MASS,Ops.fractions,1,0,0,double,1
+MASS,pairs.profile,-1,0,0,double[],1
+MASS,pairs.profile,0,0,0,"class<`profile`, `profile.glm`>",1
+MASS,pairs.profile,0,0,1,"class<`profile`, `profile.nls`>",1
+MASS,pairs.profile,0,0,2,"class<`profile`, `profile.polr`>",1
+MASS,pairs.profile,1,0,0,integer[],1
+MASS,pairs.profile,2,0,0,...,1
+MASS,parcoord,-1,0,0,null,1
+MASS,parcoord,0,0,0,class<`matrix`>,1
+MASS,parcoord,1,0,0,double[],1
+MASS,parcoord,2,0,0,double,1
+MASS,parcoord,3,0,0,logical,1
+MASS,parcoord,4,0,0,...,1
+MASS,plot.correspondence,-1,0,0,null,1
+MASS,plot.correspondence,0,0,0,class<`correspondence`>,1
+MASS,plot.correspondence,1,0,0,double,1
+MASS,plot.correspondence,2,0,0,...,1
+MASS,plot.mca,-1,0,0,class<`mca`>,1
+MASS,plot.mca,0,0,0,class<`mca`>,1
+MASS,plot.mca,1,0,0,logical,1
+MASS,plot.mca,2,0,0,any,1
+MASS,plot.mca,3,0,0,double,1
+MASS,plot.mca,4,0,0,...,1
+MASS,plot.profile,-1,0,0,null,1
+MASS,plot.profile,0,0,0,"class<`profile`, `profile.glm`>",1
+MASS,plot.profile,0,0,1,"class<`profile`, `profile.polr`>",1
+MASS,plot.profile,1,0,0,...,1
+MASS,plot.ridgelm,-1,0,0,null,1
+MASS,plot.ridgelm,0,0,0,class<`ridgelm`>,1
+MASS,plot.ridgelm,1,0,0,...,1
+MASS,polr,-1,0,0,class<`polr`>,1
+MASS,polr,0,0,0,any,1
+MASS,polr,1,0,0,any,1
+MASS,polr,2,0,0,any,1
+MASS,polr,3,0,0,any,1
+MASS,polr,4,0,0,...,1
+MASS,polr,5,0,0,any,1
+MASS,polr,6,0,0,any,1
+MASS,polr,7,0,0,null,1
+MASS,polr.fit,-1,0,0,list<double[] | list<double[] | null>>,1
+MASS,polr.fit,-1,0,1,list<double[] | list<double[] | null | class<`matrix`>>>,1
+MASS,polr.fit,0,0,0,class<`matrix`>,1
+MASS,polr.fit,1,0,0,"class<`factor`, `ordered`>",1
+MASS,polr.fit,1,0,1,integer[],1
+MASS,polr.fit,2,0,0,integer[],1
+MASS,polr.fit,3,0,0,double[],1
+MASS,polr.fit,4,0,0,double[],1
+MASS,polr.fit,5,0,0,character,1
+MASS,polr.fit,6,0,0,...,1
+MASS,predict.glmmPQL,-1,0,0,double[],1
+MASS,predict.glmmPQL,0,0,0,"class<`glmmPQL`, `lme`>",1
+MASS,predict.glmmPQL,1,0,0,class<`data.frame`>,1
+MASS,predict.glmmPQL,2,0,0,character,1
+MASS,predict.glmmPQL,3,0,0,double,1
+MASS,predict.glmmPQL,4,0,0,class<`function`>,1
+MASS,predict.glmmPQL,5,0,0,...,1
+MASS,predict.lda,-1,0,0,list<class<`factor`> | class<`matrix`>>,1
+MASS,predict.lda,0,0,0,class<`lda`>,1
+MASS,predict.lda,1,0,0,class<`data.frame`>,1
+MASS,predict.lda,1,0,1,class<`matrix`>,1
+MASS,predict.lda,2,0,0,double[],1
+MASS,predict.lda,3,0,0,any,1
+MASS,predict.lda,4,0,0,character[],1
+MASS,predict.lda,5,0,0,...,1
+MASS,predict.lqs,-1,0,0,double[],1
+MASS,predict.lqs,0,0,0,class<`lqs`>,1
+MASS,predict.lqs,1,0,0,any,1
+MASS,predict.lqs,2,0,0,any,1
+MASS,predict.lqs,3,0,0,...,1
+MASS,predict.polr,-1,0,0,class<`matrix`>,1
+MASS,predict.polr,0,0,0,class<`polr`>,1
+MASS,predict.polr,1,0,0,class<`data.frame`>,1
+MASS,predict.polr,2,0,0,character,1
+MASS,predict.polr,3,0,0,...,1
+MASS,predict.qda,-1,0,0,list<class<`factor`> | class<`matrix`>>,1
+MASS,predict.qda,0,0,0,class<`qda`>,1
+MASS,predict.qda,1,0,0,class<`matrix`>,1
+MASS,predict.qda,2,0,0,double[],1
+MASS,predict.qda,3,0,0,character[],1
+MASS,predict.qda,4,0,0,...,1
+MASS,profile.glm,-1,0,0,"class<`profile`, `profile.glm`>",1
+MASS,profile.glm,0,0,0,"class<`glm`, `lm`>",1
+MASS,profile.glm,1,0,0,integer[],1
+MASS,profile.glm,2,0,0,double,1
+MASS,profile.glm,3,0,0,double,1
+MASS,profile.glm,4,0,0,double,1
+MASS,profile.glm,5,0,0,logical,1
+MASS,profile.glm,6,0,0,...,1
+MASS,profile.polr,-1,0,0,"class<`profile`, `profile.polr`>",1
+MASS,profile.polr,0,0,0,class<`polr`>,1
+MASS,profile.polr,1,0,0,integer[],1
+MASS,profile.polr,2,0,0,double,1
+MASS,profile.polr,3,0,0,double,1
+MASS,profile.polr,4,0,0,double,1
+MASS,profile.polr,5,0,0,logical,1
+MASS,profile.polr,6,0,0,...,1
+MASS,qda,-1,0,0,class<`qda`>,1
+MASS,qda,0,0,0,class<`matrix`>,1
+MASS,qda,1,0,0,...,1
+MASS,qda.default,-1,0,0,class<`qda`>,1
+MASS,qda.default,0,0,0,class<`matrix`>,1
+MASS,qda.default,1,0,0,class<`factor`>,1
+MASS,qda.default,2,0,0,double[],1
+MASS,qda.default,3,0,0,character[],1
+MASS,qda.default,4,0,0,logical,1
+MASS,qda.default,5,0,0,double,1
+MASS,qda.default,6,0,0,...,1
+MASS,qda.matrix,-1,0,0,class<`qda`>,1
+MASS,qda.matrix,0,0,0,class<`matrix`>,1
+MASS,qda.matrix,1,0,0,class<`factor`>,1
+MASS,qda.matrix,2,0,0,...,1
+MASS,qda.matrix,3,0,0,any,1
+MASS,qda.matrix,4,0,0,any,1
+MASS,.rat,-1,0,0,list<class<`matrix`>>,1
+MASS,.rat,0,0,0,class<`matrix`>,1
+MASS,.rat,1,0,0,double,1
+MASS,.rat,2,0,0,double,1
+MASS,rational,-1,0,0,class<`matrix`>,1
+MASS,rational,0,0,0,class<`matrix`>,1
+MASS,rational,1,0,0,double,1
+MASS,rational,2,0,0,double,1
+MASS,rational,3,0,0,...,1
+MASS,renumerate,-1,0,0,any,1
+MASS,renumerate,0,0,0,class<`formula`>,1
+MASS,renumerate,0,0,1,"class<`formula`, `terms`>",1
+MASS,renumerate,0,0,2,null,1
+MASS,renumerate.formula,-1,0,0,class<`call`>,1
+MASS,renumerate.formula,-1,0,1,class<`name`>,1
+MASS,renumerate.formula,-1,0,2,class<`formula`>,1
+MASS,renumerate.formula,-1,0,3,"class<`formula`, `terms`>",1
+MASS,renumerate.formula,0,0,0,class<`call`>,1
+MASS,renumerate.formula,0,0,1,class<`name`>,1
+MASS,renumerate.formula,0,0,2,class<`formula`>,1
+MASS,renumerate.formula,0,0,3,"class<`formula`, `terms`>",1
+MASS,rlm,-1,0,0,"class<`lm`, `rlm`>",1
+MASS,rlm,0,0,0,class<`formula`>,1
+MASS,rlm,0,0,1,class<`matrix`>,1
+MASS,rlm,1,0,0,...,1
+MASS,rlm.default,-1,0,0,"class<`lm`, `rlm`>",1
+MASS,rlm.default,0,0,0,class<`matrix`>,1
+MASS,rlm.default,1,0,0,double[],1
+MASS,rlm.default,1,0,1,class<`matrix`>,1
+MASS,rlm.default,2,0,0,any,1
+MASS,rlm.default,3,0,0,...,1
+MASS,rlm.default,4,0,0,any,1
+MASS,rlm.default,5,0,0,character,1
+MASS,rlm.default,5,0,1,double[],1
+MASS,rlm.default,6,0,0,any,1
+MASS,rlm.default,7,0,0,any,1
+MASS,rlm.formula,-1,0,0,"class<`lm`, `rlm`>",1
+MASS,rlm.formula,0,0,0,class<`formula`>,1
+MASS,rlm.formula,1,0,0,any,1
+MASS,rlm.formula,2,0,0,any,1
+MASS,rlm.formula,3,0,0,...,1
+MASS,rlm.formula,4,0,0,any,1
+MASS,rlm.formula,5,0,0,any,1
+MASS,rlm.formula,6,0,0,character[],1
+MASS,rlm.formula,7,0,0,character[],1
+MASS,rms.curv,-1,0,0,class<`rms.curv`>,1
+MASS,rms.curv,0,0,0,class<`nls`>,1
+MASS,rnegbin,-1,0,0,integer[],1
+MASS,rnegbin,0,0,0,double[],1
+MASS,rnegbin,1,0,0,double[],1
+MASS,rnegbin,2,0,0,double,1
+MASS,safe_pchisq,-1,0,0,double[],1
+MASS,safe_pchisq,0,0,0,double[],1
+MASS,safe_pchisq,1,0,0,double[],1
+MASS,safe_pchisq,2,0,0,...,1
+MASS,safe_pf,-1,0,0,double[],1
+MASS,safe_pf,0,0,0,double[],1
+MASS,safe_pf,1,0,0,double[],1
+MASS,safe_pf,2,0,0,...,1
+MASS,sammon,-1,0,0,list<class<`matrix`> | double | class<`call`>>,1
+MASS,sammon,0,0,0,class<`dist`>,1
+MASS,sammon,1,0,0,class<`matrix`>,1
+MASS,sammon,2,0,0,double,1
+MASS,sammon,3,0,0,double,1
+MASS,sammon,4,0,0,logical,1
+MASS,sammon,5,0,0,double,1
+MASS,sammon,6,0,0,double,1
+MASS,select,-1,0,0,null,1
+MASS,select,0,0,0,class<`ridgelm`>,1
+MASS,select.ridgelm,-1,0,0,null,1
+MASS,select.ridgelm,0,0,0,class<`ridgelm`>,1
+MASS,Shepard,-1,0,0,list<double[]>,1
+MASS,Shepard,0,0,0,class<`dist`>,1
+MASS,Shepard,1,0,0,class<`matrix`>,1
+MASS,Shepard,2,0,0,double,1
+MASS,simulate.negbin,-1,0,0,class<`data.frame`>,1
+MASS,simulate.negbin,0,0,0,"class<`glm`, `lm`, `negbin`>",1
+MASS,simulate.negbin,1,0,0,double,1
+MASS,simulate.negbin,2,0,0,null,1
+MASS,simulate.negbin,3,0,0,...,1
+MASS,stepAIC,-1,0,0,"class<`aov`, `lm`>",1
+MASS,stepAIC,-1,0,1,"class<`glm`, `lm`>",1
+MASS,stepAIC,-1,0,2,"class<`glm`, `lm`, `negbin`>",1
+MASS,stepAIC,-1,0,3,class<`gls`>,1
+MASS,stepAIC,-1,0,4,class<`lm`>,1
+MASS,stepAIC,-1,0,5,class<`lme`>,1
+MASS,stepAIC,-1,0,6,class<`polr`>,1
+MASS,stepAIC,0,0,0,"class<`aov`, `lm`>",1
+MASS,stepAIC,0,0,1,"class<`glm`, `lm`>",1
+MASS,stepAIC,0,0,2,"class<`glm`, `lm`, `negbin`>",1
+MASS,stepAIC,0,0,3,class<`gls`>,1
+MASS,stepAIC,0,0,4,class<`lm`>,1
+MASS,stepAIC,0,0,5,class<`lme`>,1
+MASS,stepAIC,0,0,6,class<`polr`>,1
+MASS,stepAIC,1,0,0,any,1
+MASS,stepAIC,2,0,0,double,1
+MASS,stepAIC,3,0,0,character[],1
+MASS,stepAIC,4,0,0,double,1
+MASS,stepAIC,5,0,0,null,1
+MASS,stepAIC,6,0,0,double,1
+MASS,stepAIC,7,0,0,logical,1
+MASS,studres,-1,0,0,double[],1
+MASS,studres,0,0,0,"class<`aov`, `lm`>",1
+MASS,summary.negbin,-1,0,0,"class<`summary.glm`, `summary.negbin`>",1
+MASS,summary.negbin,0,0,0,"class<`glm`, `lm`, `negbin`>",1
+MASS,summary.negbin,1,0,0,double,1
+MASS,summary.negbin,1,0,1,null,1
+MASS,summary.negbin,2,0,0,logical,1
+MASS,summary.negbin,3,0,0,...,1
+MASS,summary.polr,-1,0,0,class<`summary.polr`>,1
+MASS,summary.polr,0,0,0,class<`polr`>,1
+MASS,summary.polr,1,0,0,double,1
+MASS,summary.polr,2,0,0,logical,1
+MASS,summary.polr,3,0,0,...,1
+MASS,summary.rlm,-1,0,0,class<`summary.rlm`>,1
+MASS,summary.rlm,0,0,0,"class<`lm`, `rlm`>",1
+MASS,summary.rlm,1,0,0,character[],1
+MASS,summary.rlm,2,0,0,logical,1
+MASS,summary.rlm,3,0,0,...,1
+MASS,theta.md,-1,0,0,double,1
+MASS,theta.md,0,0,0,double[],1
+MASS,theta.md,1,0,0,double[],1
+MASS,theta.md,2,0,0,double,1
+MASS,theta.md,3,0,0,any,1
+MASS,theta.md,4,0,0,double,1
+MASS,theta.md,5,0,0,double,1
+MASS,theta.ml,-1,0,0,double,1
+MASS,theta.ml,0,0,0,double[],1
+MASS,theta.ml,1,0,0,double[],1
+MASS,theta.ml,2,0,0,double,1
+MASS,theta.ml,3,0,0,any,1
+MASS,theta.ml,4,0,0,double,1
+MASS,theta.ml,5,0,0,double,1
+MASS,theta.ml,6,0,0,logical,1
+MASS,theta.mm,-1,0,0,double,1
+MASS,theta.mm,0,0,0,double[],1
+MASS,theta.mm,1,0,0,double[],1
+MASS,theta.mm,2,0,0,double,1
+MASS,theta.mm,3,0,0,any,1
+MASS,theta.mm,4,0,0,double,1
+MASS,theta.mm,5,0,0,double,1
+MASS,ucv,-1,0,0,double,1
+MASS,ucv,0,0,0,double[],1
+MASS,ucv,1,0,0,double,1
+MASS,ucv,2,0,0,double,1
+MASS,ucv,3,0,0,double,1
+MASS,update.loglm,-1,0,0,class<`loglm`>,1
+MASS,update.loglm,0,0,0,class<`loglm`>,1
+MASS,update.loglm,1,0,0,class<`formula`>,1
+MASS,update.loglm,2,0,0,...,1
+MASS,vcov.fitdistr,-1,0,0,class<`matrix`>,1
+MASS,vcov.fitdistr,0,0,0,class<`fitdistr`>,1
+MASS,vcov.fitdistr,1,0,0,...,1
+MASS,vcov.polr,-1,0,0,class<`matrix`>,1
+MASS,vcov.polr,0,0,0,class<`polr`>,1
+MASS,vcov.polr,1,0,0,...,1
+MASS,width.SJ,-1,0,0,double,1
+MASS,width.SJ,0,0,0,double[],1
+MASS,width.SJ,1,0,0,double,1
+MASS,width.SJ,2,0,0,any,1
+MASS,width.SJ,3,0,0,any,1
+MASS,width.SJ,4,0,0,character[],1
+MHadaptive,BCI,-1,0,0,class<`matrix`>,1
+MHadaptive,BCI,0,0,0,list<class<`matrix`> | character[] | double>,1
+MHadaptive,BCI,1,0,0,double[],1
+MHadaptive,.is.positive.definite,-1,0,0,logical,1
+MHadaptive,.is.positive.definite,0,0,0,class<`matrix`>,1
+MHadaptive,.is.positive.definite,1,0,0,any,1
+MHadaptive,.is.positive.definite,2,0,0,character[],1
+MHadaptive,isPositiveDefinite,-1,0,0,logical,1
+MHadaptive,isPositiveDefinite,0,0,0,class<`matrix`>,1
+MHadaptive,mcmc_thin,-1,0,0,list<class<`matrix`> | character[] | double>,1
+MHadaptive,mcmc_thin,0,0,0,list<class<`matrix`> | character[] | double>,1
+MHadaptive,mcmc_thin,1,0,0,double,1
+MHadaptive,plotMH,-1,0,0,list<logical>,1
+MHadaptive,plotMH,0,0,0,list<class<`matrix`> | character[] | double>,1
+MHadaptive,plotMH,1,0,0,logical,1
+Metrics,accuracy,-1,0,0,double,1
+Metrics,accuracy,0,0,0,character[],1
+Metrics,accuracy,1,0,0,character[],1
+Metrics,ae,-1,0,0,double[],1
+Metrics,ae,0,0,0,double[],1
+Metrics,ae,1,0,0,double[],1
+Metrics,ape,-1,0,0,double[],1
+Metrics,ape,0,0,0,double[],1
+Metrics,ape,1,0,0,double[],1
+Metrics,apk,-1,0,0,double,1
+Metrics,apk,0,0,0,double,1
+Metrics,apk,1,0,0,character[],1
+Metrics,apk,1,0,1,double[],1
+Metrics,apk,2,0,0,character[],1
+Metrics,apk,2,0,1,double[],1
+Metrics,auc,-1,0,0,double,1
+Metrics,auc,0,0,0,double[],1
+Metrics,auc,1,0,0,double[],1
+Metrics,bias,-1,0,0,double,1
+Metrics,bias,0,0,0,double[],1
+Metrics,bias,1,0,0,double[],1
+Metrics,ce,-1,0,0,double,1
+Metrics,ce,0,0,0,character[],1
+Metrics,ce,1,0,0,character[],1
+Metrics,f1,-1,0,0,double,1
+Metrics,f1,0,0,0,character[],1
+Metrics,f1,1,0,0,character[],1
+Metrics,ll,-1,0,0,double[],1
+Metrics,ll,0,0,0,double[],1
+Metrics,ll,1,0,0,double[],1
+Metrics,logLoss,-1,0,0,double,1
+Metrics,logLoss,0,0,0,double[],1
+Metrics,logLoss,1,0,0,double[],1
+Metrics,mae,-1,0,0,double,1
+Metrics,mae,0,0,0,double[],1
+Metrics,mae,1,0,0,double[],1
+Metrics,mape,-1,0,0,double,1
+Metrics,mape,0,0,0,double[],1
+Metrics,mape,1,0,0,double[],1
+Metrics,mapk,-1,0,0,double,1
+Metrics,mapk,0,0,0,double,1
+Metrics,mapk,1,0,0,list<character[]>,1
+Metrics,mapk,1,0,1,list<double[]>,1
+Metrics,mapk,2,0,0,list<character[]>,1
+Metrics,mapk,2,0,1,list<double[]>,1
+Metrics,mase,-1,0,0,double,1
+Metrics,mase,0,0,0,double[],1
+Metrics,mase,1,0,0,double[],1
+Metrics,mase,2,0,0,double,1
+Metrics,mdae,-1,0,0,double,1
+Metrics,mdae,0,0,0,double[],1
+Metrics,mdae,1,0,0,double[],1
+Metrics,MeanQuadraticWeightedKappa,-1,0,0,double,1
+Metrics,MeanQuadraticWeightedKappa,0,0,0,double[],1
+Metrics,MeanQuadraticWeightedKappa,1,0,0,double[],1
+Metrics,mse,-1,0,0,double,1
+Metrics,mse,0,0,0,double[],1
+Metrics,mse,1,0,0,double[],1
+Metrics,msle,-1,0,0,double,1
+Metrics,msle,0,0,0,double[],1
+Metrics,msle,1,0,0,double[],1
+Metrics,percent_bias,-1,0,0,double,1
+Metrics,percent_bias,0,0,0,double[],1
+Metrics,percent_bias,1,0,0,double[],1
+Metrics,precision,-1,0,0,double,1
+Metrics,precision,0,0,0,double[],1
+Metrics,precision,1,0,0,double[],1
+Metrics,recall,-1,0,0,double,1
+Metrics,recall,0,0,0,double[],1
+Metrics,recall,1,0,0,double[],1
+Metrics,rmse,-1,0,0,double,1
+Metrics,rmse,0,0,0,double[],1
+Metrics,rmse,1,0,0,double[],1
+Metrics,rmsle,-1,0,0,double,1
+Metrics,rmsle,0,0,0,double[],1
+Metrics,rmsle,1,0,0,double[],1
+Metrics,rrse,-1,0,0,double,1
+Metrics,rrse,0,0,0,double[],1
+Metrics,rrse,1,0,0,double[],1
+Metrics,rse,-1,0,0,double,1
+Metrics,rse,0,0,0,double[],1
+Metrics,rse,1,0,0,double[],1
+Metrics,ScoreQuadraticWeightedKappa,-1,0,0,double,1
+Metrics,ScoreQuadraticWeightedKappa,0,0,0,double[],1
+Metrics,ScoreQuadraticWeightedKappa,1,0,0,double[],1
+Metrics,ScoreQuadraticWeightedKappa,2,0,0,double,1
+Metrics,ScoreQuadraticWeightedKappa,3,0,0,double,1
+Metrics,se,-1,0,0,double[],1
+Metrics,se,0,0,0,double[],1
+Metrics,se,1,0,0,double[],1
+Metrics,sle,-1,0,0,double[],1
+Metrics,sle,0,0,0,double[],1
+Metrics,sle,1,0,0,double[],1
+Metrics,smape,-1,0,0,double,1
+Metrics,smape,0,0,0,double[],1
+Metrics,smape,1,0,0,double[],1
+Metrics,sse,-1,0,0,double,1
+Metrics,sse,0,0,0,double[],1
+Metrics,sse,1,0,0,double[],1
+NbClust,NbClust,-1,0,0,list<class<`matrix`> | integer[]>,1
+NbClust,NbClust,-1,0,1,list<double[]>,1
+NbClust,NbClust,0,0,0,class<`data.frame`>,1
+NbClust,NbClust,0,0,1,class<`matrix`>,1
+NbClust,NbClust,0,0,2,null,1
+NbClust,NbClust,1,0,0,class<`dist`>,1
+NbClust,NbClust,1,0,1,null,1
+NbClust,NbClust,2,0,0,null,1
+NbClust,NbClust,2,0,1,character,1
+NbClust,NbClust,3,0,0,double,1
+NbClust,NbClust,4,0,0,double,1
+NbClust,NbClust,5,0,0,character,1
+NbClust,NbClust,6,0,0,character,1
+NbClust,NbClust,7,0,0,double,1
+ParamHelpers,addOptPathEl,-1,0,0,null,1
+ParamHelpers,addOptPathEl,0,0,0,"class<`OptPath`, `OptPathDF`>",1
+ParamHelpers,addOptPathEl,1,0,0,list<double[] | character>,1
+ParamHelpers,addOptPathEl,1,0,1,list<double | character>,1
+ParamHelpers,addOptPathEl,1,0,2,list<double>,1
+ParamHelpers,addOptPathEl,2,0,0,double[],1
+ParamHelpers,addOptPathEl,3,0,0,any,1
+ParamHelpers,addOptPathEl,4,0,0,any,1
+ParamHelpers,addOptPathEl,5,0,0,null,1
+ParamHelpers,addOptPathEl,6,0,0,null,1
+ParamHelpers,addOptPathEl,7,0,0,null,1
+ParamHelpers,addOptPathEl.OptPathDF,-1,0,0,null,1
+ParamHelpers,addOptPathEl.OptPathDF,0,0,0,"class<`OptPath`, `OptPathDF`>",1
+ParamHelpers,addOptPathEl.OptPathDF,1,0,0,list<double[] | character>,1
+ParamHelpers,addOptPathEl.OptPathDF,1,0,1,list<double | character>,1
+ParamHelpers,addOptPathEl.OptPathDF,1,0,2,list<double>,1
+ParamHelpers,addOptPathEl.OptPathDF,2,0,0,double[],1
+ParamHelpers,addOptPathEl.OptPathDF,3,0,0,double,1
+ParamHelpers,addOptPathEl.OptPathDF,4,0,0,double,1
+ParamHelpers,addOptPathEl.OptPathDF,4,0,1,null,1
+ParamHelpers,addOptPathEl.OptPathDF,5,0,0,null,1
+ParamHelpers,addOptPathEl.OptPathDF,6,0,0,null,1
+ParamHelpers,addOptPathEl.OptPathDF,7,0,0,null,1
+ParamHelpers,applyTrafos,-1,0,0,class<`data.frame`>,1
+ParamHelpers,applyTrafos,0,0,0,class<`data.frame`>,1
+ParamHelpers,applyTrafos,1,0,0,list<class<`Param`>>,1
+ParamHelpers,as.data.frame.OptPathDF,-1,0,0,class<`data.frame`>,1
+ParamHelpers,as.data.frame.OptPathDF,0,0,0,"class<`OptPath`, `OptPathDF`>",1
+ParamHelpers,as.data.frame.OptPathDF,1,0,0,null,1
+ParamHelpers,as.data.frame.OptPathDF,2,0,0,logical,1
+ParamHelpers,as.data.frame.OptPathDF,3,0,0,logical,1
+ParamHelpers,as.data.frame.OptPathDF,4,0,0,logical,1
+ParamHelpers,as.data.frame.OptPathDF,5,0,0,logical,1
+ParamHelpers,as.data.frame.OptPathDF,6,0,0,integer[],1
+ParamHelpers,as.data.frame.OptPathDF,7,0,0,^integer[],1
+ParamHelpers,checkExpressionFeasibility,-1,0,0,logical,1
+ParamHelpers,checkExpressionFeasibility,0,0,0,"class<`LearnerParamSet`, `ParamSet`>",1
+ParamHelpers,checkExpressionFeasibility,0,0,1,class<`ParamSet`>,1
+ParamHelpers,checkExpressionFeasibility,1,0,0,character[],1
+ParamHelpers,checkLength,-1,0,0,logical,1
+ParamHelpers,checkLength,0,0,0,class<`Param`>,1
+ParamHelpers,checkLength,1,0,0,double[],1
+ParamHelpers,checkParamSet,-1,0,0,logical,1
+ParamHelpers,checkParamSet,0,0,0,class<`ParamSet`>,1
+ParamHelpers,checkParamSet,1,0,0,list<double | character>,1
+ParamHelpers,checkValuesForDiscreteParam,-1,0,0,list<integer>,1
+ParamHelpers,checkValuesForDiscreteParam,-1,0,1,list<character>,1
+ParamHelpers,checkValuesForDiscreteParam,-1,0,2,list<null | list<any>>,1
+ParamHelpers,checkValuesForDiscreteParam,-1,0,3,list<null | double>,1
+ParamHelpers,checkValuesForDiscreteParam,0,0,0,any,1
+ParamHelpers,checkValuesForDiscreteParam,1,0,0,integer[],1
+ParamHelpers,checkValuesForDiscreteParam,1,0,1,character[],1
+ParamHelpers,checkValuesForDiscreteParam,1,0,2,list<null | list<any>>,1
+ParamHelpers,checkValuesForDiscreteParam,1,0,3,list<null | double>,1
+ParamHelpers,checkValuesForDiscreteParam,1,0,4,list<logical>,1
+ParamHelpers,constraintsOkParam,-1,0,0,logical,1
+ParamHelpers,constraintsOkParam,0,0,0,class<`Param`>,1
+ParamHelpers,constraintsOkParam,1,0,0,character,1
+ParamHelpers,constraintsOkParam,1,0,1,double[],1
+ParamHelpers,convertTypesToCInts,-1,0,0,integer[],1
+ParamHelpers,convertTypesToCInts,0,0,0,character[],1
+ParamHelpers,determineReqVectorized,-1,0,0,logical[],1
+ParamHelpers,determineReqVectorized,0,0,0,list<class<`Param`>>,1
+ParamHelpers,dfRowsToList,-1,0,0,list<list<double[] | character>>,1
+ParamHelpers,dfRowsToList,0,0,0,class<`data.frame`>,1
+ParamHelpers,dfRowsToList,1,0,0,class<`ParamSet`>,1
+ParamHelpers,dfRowsToList,2,0,0,logical,1
+ParamHelpers,dfRowsToList,3,0,0,...,1
+ParamHelpers,dfRowToList,-1,0,0,list<double[] | character>,1
+ParamHelpers,dfRowToList,0,0,0,class<`data.frame`>,1
+ParamHelpers,dfRowToList,1,0,0,class<`ParamSet`>,1
+ParamHelpers,dfRowToList,2,0,0,integer,1
+ParamHelpers,dfRowToList,3,0,0,logical,1
+ParamHelpers,dfRowToList,4,0,0,...,1
+ParamHelpers,discreteNameToValue,-1,0,0,character,1
+ParamHelpers,discreteNameToValue,0,0,0,class<`Param`>,1
+ParamHelpers,discreteNameToValue,1,0,0,character,1
+ParamHelpers,discreteValueToName,-1,0,0,character,1
+ParamHelpers,discreteValueToName,0,0,0,class<`Param`>,1
+ParamHelpers,discreteValueToName,1,0,0,character,1
+ParamHelpers,discreteValueToName,1,0,1,null,1
+ParamHelpers,doBasicGenDesignChecks,-1,0,0,list<double[]>,1
+ParamHelpers,doBasicGenDesignChecks,0,0,0,class<`ParamSet`>,1
+ParamHelpers,evaluateParamExpressions,-1,0,0,class<`Param`>,1
+ParamHelpers,evaluateParamExpressions,-1,0,1,class<`ParamSet`>,1
+ParamHelpers,evaluateParamExpressions,-1,0,2,list<double>,1
+ParamHelpers,evaluateParamExpressions,0,0,0,class<`Param`>,1
+ParamHelpers,evaluateParamExpressions,0,0,1,class<`ParamSet`>,1
+ParamHelpers,evaluateParamExpressions,0,0,2,list<expression | double>,1
+ParamHelpers,evaluateParamExpressions,1,0,0,any,1
+ParamHelpers,evaluateParamExpressions.list,-1,0,0,list<double>,1
+ParamHelpers,evaluateParamExpressions.list,0,0,0,list<expression | double>,1
+ParamHelpers,evaluateParamExpressions.list,1,0,0,list<double>,1
+ParamHelpers,evaluateParamExpressions.Param,-1,0,0,class<`Param`>,1
+ParamHelpers,evaluateParamExpressions.Param,0,0,0,class<`Param`>,1
+ParamHelpers,evaluateParamExpressions.Param,1,0,0,any,1
+ParamHelpers,evaluateParamExpressions.ParamSet,-1,0,0,class<`ParamSet`>,1
+ParamHelpers,evaluateParamExpressions.ParamSet,0,0,0,class<`ParamSet`>,1
+ParamHelpers,evaluateParamExpressions.ParamSet,1,0,0,list<class<`data.frame`>>,1
+ParamHelpers,evaluateParamExpressions.ParamSet,1,0,1,list<double>,1
+ParamHelpers,evaluateParamExpressions.ParamSet,1,0,2,list<double | character>,1
+ParamHelpers,filterParams,-1,0,0,class<`ParamSet`>,1
+ParamHelpers,filterParams,0,0,0,class<`ParamSet`>,1
+ParamHelpers,filterParams,1,0,0,character[],1
+ParamHelpers,filterParams,1,0,1,null,1
+ParamHelpers,filterParams,2,0,0,character[],1
+ParamHelpers,filterParams,3,0,0,logical[],1
+ParamHelpers,filterParams,4,0,0,logical,1
+ParamHelpers,filterParamsNumeric,-1,0,0,class<`ParamSet`>,1
+ParamHelpers,filterParamsNumeric,0,0,0,class<`ParamSet`>,1
+ParamHelpers,filterParamsNumeric,1,0,0,null,1
+ParamHelpers,filterParamsNumeric,2,0,0,logical[],1
+ParamHelpers,filterParamsNumeric,3,0,0,logical,1
+ParamHelpers,fixDesignFactors,-1,0,0,class<`data.frame`>,1
+ParamHelpers,fixDesignFactors,0,0,0,class<`data.frame`>,1
+ParamHelpers,fixDesignFactors,1,0,0,class<`ParamSet`>,1
+ParamHelpers,generateDesign,-1,0,0,class<`data.frame`>,1
+ParamHelpers,generateDesign,0,0,0,double,1
+ParamHelpers,generateDesign,1,0,0,class<`ParamSet`>,1
+ParamHelpers,generateDesign,2,0,0,any,1
+ParamHelpers,generateDesign,3,0,0,list<any>,1
+ParamHelpers,generateDesign,4,0,0,logical,1
+ParamHelpers,generateDesign,5,0,0,integer,1
+ParamHelpers,generateGridDesign,-1,0,0,class<`data.frame`>,1
+ParamHelpers,generateGridDesign,0,0,0,class<`ParamSet`>,1
+ParamHelpers,generateGridDesign,1,0,0,double[],1
+ParamHelpers,generateGridDesign,2,0,0,logical,1
+ParamHelpers,getBounds,-1,0,0,double[],1
+ParamHelpers,getBounds,0,0,0,class<`Param`>,1
+ParamHelpers,getBounds,0,0,1,class<`ParamSet`>,1
+ParamHelpers,getBounds,0,0,2,list<class<`Param`>>,1
+ParamHelpers,getBounds,1,0,0,character,1
+ParamHelpers,getBounds,2,0,0,logical,1
+ParamHelpers,getBounds,3,0,0,null,1
+ParamHelpers,getBounds,3,0,1,list<double>,1
+ParamHelpers,getBounds,3,0,2,list<double | character>,1
+ParamHelpers,getBounds,3,0,3,list<class<`data.frame`>>,1
+ParamHelpers,getBounds.list,-1,0,0,double[],1
+ParamHelpers,getBounds.list,0,0,0,list<class<`Param`>>,1
+ParamHelpers,getBounds.list,1,0,0,character,1
+ParamHelpers,getBounds.list,2,0,0,logical,1
+ParamHelpers,getBounds.list,3,0,0,null,1
+ParamHelpers,getBounds.list,3,0,1,list<double>,1
+ParamHelpers,getBounds.Param,-1,0,0,double[],1
+ParamHelpers,getBounds.Param,0,0,0,class<`Param`>,1
+ParamHelpers,getBounds.Param,1,0,0,character,1
+ParamHelpers,getBounds.Param,2,0,0,logical,1
+ParamHelpers,getBounds.Param,3,0,0,null,1
+ParamHelpers,getBounds.Param,3,0,1,list<double>,1
+ParamHelpers,getBounds.Param,3,0,2,list<double | character>,1
+ParamHelpers,getBounds.Param,3,0,3,list<class<`data.frame`>>,1
+ParamHelpers,getBounds.ParamSet,-1,0,0,double[],1
+ParamHelpers,getBounds.ParamSet,0,0,0,class<`ParamSet`>,1
+ParamHelpers,getBounds.ParamSet,1,0,0,character,1
+ParamHelpers,getBounds.ParamSet,2,0,0,logical,1
+ParamHelpers,getBounds.ParamSet,3,0,0,null,1
+ParamHelpers,getBounds.ParamSet,3,0,1,list<double>,1
+ParamHelpers,getDefaults,-1,0,0,character,1
+ParamHelpers,getDefaults,-1,0,1,double[],1
+ParamHelpers,getDefaults,-1,0,2,null,1
+ParamHelpers,getDefaults,-1,0,3,list<double[]>,1
+ParamHelpers,getDefaults,-1,0,4,list<character>,1
+ParamHelpers,getDefaults,-1,0,5,list<character | null | double>,1
+ParamHelpers,getDefaults,0,0,0,class<`Param`>,1
+ParamHelpers,getDefaults,0,0,1,class<`ParamSet`>,1
+ParamHelpers,getDefaults,1,0,0,logical,1
+ParamHelpers,getDefaults,2,0,0,null,1
+ParamHelpers,getDefaults,2,0,1,list<double>,1
+ParamHelpers,getDefaults,2,0,2,list<double | character>,1
+ParamHelpers,getDefaults,2,0,3,list<class<`data.frame`>>,1
+ParamHelpers,getDefaults.Param,-1,0,0,character,1
+ParamHelpers,getDefaults.Param,-1,0,1,double[],1
+ParamHelpers,getDefaults.Param,-1,0,2,null,1
+ParamHelpers,getDefaults.Param,0,0,0,class<`Param`>,1
+ParamHelpers,getDefaults.Param,1,0,0,logical,1
+ParamHelpers,getDefaults.Param,2,0,0,null,1
+ParamHelpers,getDefaults.Param,2,0,1,list<double | character>,1
+ParamHelpers,getDefaults.Param,2,0,2,list<double>,1
+ParamHelpers,getDefaults.Param,2,0,3,list<class<`data.frame`>>,1
+ParamHelpers,getDefaults.ParamSet,-1,0,0,list<double[]>,1
+ParamHelpers,getDefaults.ParamSet,-1,0,1,list<character>,1
+ParamHelpers,getDefaults.ParamSet,-1,0,2,list<character | null | double>,1
+ParamHelpers,getDefaults.ParamSet,0,0,0,class<`ParamSet`>,1
+ParamHelpers,getDefaults.ParamSet,1,0,0,logical,1
+ParamHelpers,getDefaults.ParamSet,2,0,0,list<double>,1
+ParamHelpers,getDefaults.ParamSet,2,0,1,null,1
+ParamHelpers,getLower,-1,0,0,double[],1
+ParamHelpers,getLower,0,0,0,class<`Param`>,1
+ParamHelpers,getLower,0,0,1,class<`ParamSet`>,1
+ParamHelpers,getLower,0,0,2,list<class<`Param`>>,1
+ParamHelpers,getLower,1,0,0,logical,1
+ParamHelpers,getLower,2,0,0,list<double | character>,1
+ParamHelpers,getLower,2,0,1,null,1
+ParamHelpers,getLower,2,0,2,list<double>,1
+ParamHelpers,getLower,2,0,3,list<class<`data.frame`>>,1
+ParamHelpers,getOptPathBestIndex,-1,0,0,integer,1
+ParamHelpers,getOptPathBestIndex,0,0,0,"class<`OptPath`, `OptPathDF`>",1
+ParamHelpers,getOptPathBestIndex,1,0,0,character,1
+ParamHelpers,getOptPathBestIndex,2,0,0,integer[],1
+ParamHelpers,getOptPathBestIndex,3,0,0,^integer[],1
+ParamHelpers,getOptPathBestIndex,4,0,0,character,1
+ParamHelpers,getOptPathDobAndEolIndex,-1,0,0,logical[],1
+ParamHelpers,getOptPathDobAndEolIndex,0,0,0,"class<`OptPath`, `OptPathDF`>",1
+ParamHelpers,getOptPathDobAndEolIndex,1,0,0,integer[],1
+ParamHelpers,getOptPathDobAndEolIndex,2,0,0,^integer[],1
+ParamHelpers,getOptPathEl,-1,0,0,list<double | list<double[] | character>>,1
+ParamHelpers,getOptPathEl,0,0,0,"class<`OptPath`, `OptPathDF`>",1
+ParamHelpers,getOptPathEl,1,0,0,integer,1
+ParamHelpers,getOptPathEl.OptPathDF,-1,0,0,list<double | list<double[] | character>>,1
+ParamHelpers,getOptPathEl.OptPathDF,0,0,0,"class<`OptPath`, `OptPathDF`>",1
+ParamHelpers,getOptPathEl.OptPathDF,1,0,0,integer,1
+ParamHelpers,getOptPathLength,-1,0,0,integer,1
+ParamHelpers,getOptPathLength,0,0,0,"class<`OptPath`, `OptPathDF`>",1
+ParamHelpers,getOptPathLength.OptPathDF,-1,0,0,integer,1
+ParamHelpers,getOptPathLength.OptPathDF,0,0,0,"class<`OptPath`, `OptPathDF`>",1
+ParamHelpers,getOptPathParetoFront,-1,0,0,class<`matrix`>,1
+ParamHelpers,getOptPathParetoFront,-1,0,1,integer[],1
+ParamHelpers,getOptPathParetoFront,0,0,0,"class<`OptPath`, `OptPathDF`>",1
+ParamHelpers,getOptPathParetoFront,1,0,0,character[],1
+ParamHelpers,getOptPathParetoFront,2,0,0,integer[],1
+ParamHelpers,getOptPathParetoFront,3,0,0,^integer[],1
+ParamHelpers,getOptPathParetoFront,4,0,0,logical,1
+ParamHelpers,getOptPathY,-1,0,0,class<`matrix`>,1
+ParamHelpers,getOptPathY,-1,0,1,double[],1
+ParamHelpers,getOptPathY,0,0,0,"class<`OptPath`, `OptPathDF`>",1
+ParamHelpers,getOptPathY,1,0,0,character[],1
+ParamHelpers,getOptPathY,2,0,0,any,1
+ParamHelpers,getOptPathY,3,0,0,any,1
+ParamHelpers,getOptPathY,4,0,0,logical,1
+ParamHelpers,getOptPathY.OptPathDF,-1,0,0,class<`matrix`>,1
+ParamHelpers,getOptPathY.OptPathDF,-1,0,1,double[],1
+ParamHelpers,getOptPathY.OptPathDF,0,0,0,"class<`OptPath`, `OptPathDF`>",1
+ParamHelpers,getOptPathY.OptPathDF,1,0,0,character[],1
+ParamHelpers,getOptPathY.OptPathDF,2,0,0,integer[],1
+ParamHelpers,getOptPathY.OptPathDF,3,0,0,^integer[],1
+ParamHelpers,getOptPathY.OptPathDF,4,0,0,logical,1
+ParamHelpers,getParamIds,-1,0,0,character[],1
+ParamHelpers,getParamIds,0,0,0,class<`Param`>,1
+ParamHelpers,getParamIds,0,0,1,class<`ParamSet`>,1
+ParamHelpers,getParamIds,1,0,0,logical,1
+ParamHelpers,getParamIds,2,0,0,logical,1
+ParamHelpers,getParamIds.Param,-1,0,0,character[],1
+ParamHelpers,getParamIds.Param,0,0,0,class<`Param`>,1
+ParamHelpers,getParamIds.Param,1,0,0,logical,1
+ParamHelpers,getParamIds.Param,2,0,0,logical,1
+ParamHelpers,getParamIds.ParamSet,-1,0,0,character[],1
+ParamHelpers,getParamIds.ParamSet,0,0,0,class<`ParamSet`>,1
+ParamHelpers,getParamIds.ParamSet,1,0,0,logical,1
+ParamHelpers,getParamIds.ParamSet,2,0,0,logical,1
+ParamHelpers,getParamLengths,-1,0,0,integer[],1
+ParamHelpers,getParamLengths,0,0,0,class<`Param`>,1
+ParamHelpers,getParamLengths,0,0,1,class<`ParamSet`>,1
+ParamHelpers,getParamLengths,1,0,0,list<class<`data.frame`>>,1
+ParamHelpers,getParamLengths,1,0,1,list<double>,1
+ParamHelpers,getParamLengths,1,0,2,list<double | character>,1
+ParamHelpers,getParamLengths,1,0,3,null,1
+ParamHelpers,getParamLengths.Param,-1,0,0,integer,1
+ParamHelpers,getParamLengths.Param,0,0,0,class<`Param`>,1
+ParamHelpers,getParamLengths.Param,1,0,0,list<class<`data.frame`>>,1
+ParamHelpers,getParamLengths.Param,1,0,1,list<double>,1
+ParamHelpers,getParamLengths.Param,1,0,2,list<double | character>,1
+ParamHelpers,getParamLengths.ParamSet,-1,0,0,integer[],1
+ParamHelpers,getParamLengths.ParamSet,0,0,0,class<`ParamSet`>,1
+ParamHelpers,getParamLengths.ParamSet,1,0,0,null,1
+ParamHelpers,getParamNr,-1,0,0,integer,1
+ParamHelpers,getParamNr,0,0,0,class<`ParamSet`>,1
+ParamHelpers,getParamNr,1,0,0,logical,1
+ParamHelpers,getParamSetValues,-1,0,0,list<null | character[]>,1
+ParamHelpers,getParamSetValues,-1,0,1,list<null>,1
+ParamHelpers,getParamSetValues,0,0,0,class<`ParamSet`>,1
+ParamHelpers,getParamTypes,-1,0,0,character[],1
+ParamHelpers,getParamTypes,0,0,0,class<`ParamSet`>,1
+ParamHelpers,getParamTypes,1,0,0,logical,1
+ParamHelpers,getParamTypes,2,0,0,logical,1
+ParamHelpers,getParamTypes,3,0,0,logical,1
+ParamHelpers,getParamTypes,4,0,0,logical,1
+ParamHelpers,getRequiredParamNames,-1,0,0,character[],1
+ParamHelpers,getRequiredParamNames,0,0,0,class<`ParamSet`>,1
+ParamHelpers,getRequiredParamNames.ParamSet,-1,0,0,character[],1
+ParamHelpers,getRequiredParamNames.ParamSet,0,0,0,class<`ParamSet`>,1
+ParamHelpers,getTypeStringsAll,-1,0,0,character[],1
+ParamHelpers,getTypeStringsDiscrete,-1,0,0,character[],1
+ParamHelpers,getTypeStringsDiscrete,0,0,0,logical,1
+ParamHelpers,getTypeStringsInteger,-1,0,0,character[],1
+ParamHelpers,getTypeStringsLogical,-1,0,0,character[],1
+ParamHelpers,getTypeStringsNumeric,-1,0,0,character[],1
+ParamHelpers,getTypeStringsNumeric,0,0,0,logical,1
+ParamHelpers,getUpper,-1,0,0,double[],1
+ParamHelpers,getUpper,0,0,0,class<`Param`>,1
+ParamHelpers,getUpper,0,0,1,class<`ParamSet`>,1
+ParamHelpers,getUpper,0,0,2,list<class<`Param`>>,1
+ParamHelpers,getUpper,1,0,0,logical,1
+ParamHelpers,getUpper,2,0,0,list<double | character>,1
+ParamHelpers,getUpper,2,0,1,null,1
+ParamHelpers,getUpper,2,0,2,list<double>,1
+ParamHelpers,getUpper,2,0,3,list<class<`data.frame`>>,1
+ParamHelpers,getValues,-1,0,0,list<any>,1
+ParamHelpers,getValues,0,0,0,class<`ParamSet`>,1
+ParamHelpers,getValues,0,0,1,class<`Param`>,1
+ParamHelpers,getValues,1,0,0,null,1
+ParamHelpers,getValues,1,0,1,list<double | character>,1
+ParamHelpers,getValues.Param,-1,0,0,list<character>,1
+ParamHelpers,getValues.Param,0,0,0,class<`Param`>,1
+ParamHelpers,getValues.Param,1,0,0,list<double | character>,1
+ParamHelpers,getValues.ParamSet,-1,0,0,list<any>,1
+ParamHelpers,getValues.ParamSet,0,0,0,class<`ParamSet`>,1
+ParamHelpers,getValues.ParamSet,1,0,0,null,1
+ParamHelpers,hasExpression,-1,0,0,logical,1
+ParamHelpers,hasExpression,0,0,0,"class<`LearnerParam`, `Param`>",1
+ParamHelpers,hasExpression,0,0,1,class<`Param`>,1
+ParamHelpers,hasExpression,0,0,2,"class<`LearnerParamSet`, `ParamSet`>",1
+ParamHelpers,hasExpression,0,0,3,class<`ParamSet`>,1
+ParamHelpers,hasExpression.LearnerParam,-1,0,0,logical,1
+ParamHelpers,hasExpression.LearnerParam,0,0,0,"class<`LearnerParam`, `Param`>",1
+ParamHelpers,hasExpression.LearnerParam,0,0,1,class<`Param`>,1
+ParamHelpers,hasExpression.LearnerParamSet,-1,0,0,logical,1
+ParamHelpers,hasExpression.LearnerParamSet,0,0,0,"class<`LearnerParamSet`, `ParamSet`>",1
+ParamHelpers,hasExpression.LearnerParamSet,0,0,1,class<`ParamSet`>,1
+ParamHelpers,hasExpression.Param,-1,0,0,logical,1
+ParamHelpers,hasExpression.Param,0,0,0,"class<`LearnerParam`, `Param`>",1
+ParamHelpers,hasExpression.Param,0,0,1,class<`Param`>,1
+ParamHelpers,hasExpression.ParamSet,-1,0,0,logical,1
+ParamHelpers,hasExpression.ParamSet,0,0,0,"class<`LearnerParamSet`, `ParamSet`>",1
+ParamHelpers,hasExpression.ParamSet,0,0,1,class<`ParamSet`>,1
+ParamHelpers,hasForbidden,-1,0,0,logical,1
+ParamHelpers,hasForbidden,0,0,0,class<`ParamSet`>,1
+ParamHelpers,hasNumeric,-1,0,0,logical,1
+ParamHelpers,hasNumeric,0,0,0,class<`ParamSet`>,1
+ParamHelpers,hasNumeric,1,0,0,logical,1
+ParamHelpers,hasRequires,-1,0,0,logical,1
+ParamHelpers,hasRequires,0,0,0,class<`Param`>,1
+ParamHelpers,hasRequires,0,0,1,class<`ParamSet`>,1
+ParamHelpers,hasRequires.Param,-1,0,0,logical,1
+ParamHelpers,hasRequires.Param,0,0,0,class<`Param`>,1
+ParamHelpers,hasRequires.ParamSet,-1,0,0,logical,1
+ParamHelpers,hasRequires.ParamSet,0,0,0,class<`ParamSet`>,1
+ParamHelpers,hasSomeParamsOfTypes,-1,0,0,logical,1
+ParamHelpers,hasSomeParamsOfTypes,0,0,0,class<`ParamSet`>,1
+ParamHelpers,hasSomeParamsOfTypes,1,0,0,character[],1
+ParamHelpers,inBoundsOrExpr,-1,0,0,logical,1
+ParamHelpers,inBoundsOrExpr,0,0,0,class<`Param`>,1
+ParamHelpers,inBoundsOrExpr,1,0,0,double[],1
+ParamHelpers,isDiscrete,-1,0,0,logical,1
+ParamHelpers,isDiscrete,0,0,0,class<`Param`>,1
+ParamHelpers,isDiscrete,1,0,0,logical,1
+ParamHelpers,isDiscrete.Param,-1,0,0,logical,1
+ParamHelpers,isDiscrete.Param,0,0,0,class<`Param`>,1
+ParamHelpers,isDiscrete.Param,1,0,0,logical,1
+ParamHelpers,isDiscreteTypeString,-1,0,0,logical,1
+ParamHelpers,isDiscreteTypeString,0,0,0,character,1
+ParamHelpers,isDiscreteTypeString,1,0,0,logical,1
+ParamHelpers,isEmpty,-1,0,0,logical,1
+ParamHelpers,isEmpty,0,0,0,class<`ParamSet`>,1
+ParamHelpers,isEmpty.ParamSet,-1,0,0,logical,1
+ParamHelpers,isEmpty.ParamSet,0,0,0,class<`ParamSet`>,1
+ParamHelpers,isFeasible,-1,0,0,logical,1
+ParamHelpers,isFeasible,0,0,0,class<`Param`>,1
+ParamHelpers,isFeasible,0,0,1,class<`ParamSet`>,1
+ParamHelpers,isFeasible,1,0,0,character,1
+ParamHelpers,isFeasible,1,0,1,double[],1
+ParamHelpers,isFeasible,1,0,2,list<double | character>,1
+ParamHelpers,isFeasible,1,0,3,list<double[] | character>,1
+ParamHelpers,isFeasible,1,0,4,list<double>,1
+ParamHelpers,isFeasible,1,0,5,list<character | double>,1
+ParamHelpers,isFeasible,2,0,0,logical,1
+ParamHelpers,isFeasible,3,0,0,logical,1
+ParamHelpers,isFeasible.Param,-1,0,0,logical,1
+ParamHelpers,isFeasible.Param,0,0,0,class<`Param`>,1
+ParamHelpers,isFeasible.Param,1,0,0,character,1
+ParamHelpers,isFeasible.Param,1,0,1,double[],1
+ParamHelpers,isFeasible.Param,2,0,0,logical,1
+ParamHelpers,isFeasible.Param,3,0,0,logical,1
+ParamHelpers,isFeasible.ParamSet,-1,0,0,logical,1
+ParamHelpers,isFeasible.ParamSet,0,0,0,class<`ParamSet`>,1
+ParamHelpers,isFeasible.ParamSet,1,0,0,list<double | character>,1
+ParamHelpers,isFeasible.ParamSet,1,0,1,list<double[] | character>,1
+ParamHelpers,isFeasible.ParamSet,1,0,2,list<double>,1
+ParamHelpers,isFeasible.ParamSet,1,0,3,list<character | double>,1
+ParamHelpers,isFeasible.ParamSet,2,0,0,logical,1
+ParamHelpers,isFeasible.ParamSet,3,0,0,logical,1
+ParamHelpers,isForbidden,-1,0,0,logical,1
+ParamHelpers,isForbidden,0,0,0,class<`ParamSet`>,1
+ParamHelpers,isForbidden,1,0,0,list<character | double>,1
+ParamHelpers,isForbidden,1,0,1,list<double | character>,1
+ParamHelpers,isForbidden,1,0,2,list<double[] | character>,1
+ParamHelpers,isForbidden,1,0,3,list<double>,1
+ParamHelpers,isInteger,-1,0,0,logical,1
+ParamHelpers,isInteger,0,0,0,class<`Param`>,1
+ParamHelpers,isInteger.Param,-1,0,0,logical,1
+ParamHelpers,isInteger.Param,0,0,0,class<`Param`>,1
+ParamHelpers,isIntegerTypeString,-1,0,0,logical,1
+ParamHelpers,isIntegerTypeString,0,0,0,character,1
+ParamHelpers,isLogical,-1,0,0,logical,1
+ParamHelpers,isLogical,0,0,0,class<`Param`>,1
+ParamHelpers,isLogical.Param,-1,0,0,logical,1
+ParamHelpers,isLogical.Param,0,0,0,class<`Param`>,1
+ParamHelpers,isLogicalTypeString,-1,0,0,logical,1
+ParamHelpers,isLogicalTypeString,0,0,0,character,1
+ParamHelpers,isNumeric,-1,0,0,logical,1
+ParamHelpers,isNumeric,0,0,0,class<`Param`>,1
+ParamHelpers,isNumeric,1,0,0,logical,1
+ParamHelpers,isNumeric.Param,-1,0,0,logical,1
+ParamHelpers,isNumeric.Param,0,0,0,class<`Param`>,1
+ParamHelpers,isNumeric.Param,1,0,0,logical,1
+ParamHelpers,isNumericTypeString,-1,0,0,logical,1
+ParamHelpers,isNumericTypeString,0,0,0,character,1
+ParamHelpers,isNumericTypeString,1,0,0,logical,1
+ParamHelpers,isSpecialValue,-1,0,0,logical,1
+ParamHelpers,isSpecialValue,0,0,0,class<`Param`>,1
+ParamHelpers,isSpecialValue,1,0,0,any,1
+ParamHelpers,isVector,-1,0,0,logical,1
+ParamHelpers,isVector,0,0,0,class<`Param`>,1
+ParamHelpers,isVector.Param,-1,0,0,logical,1
+ParamHelpers,isVector.Param,0,0,0,class<`Param`>,1
+ParamHelpers,isVectorTypeString,-1,0,0,logical,1
+ParamHelpers,isVectorTypeString,0,0,0,character,1
+ParamHelpers,makeCharacterParam,-1,0,0,class<`Param`>,1
+ParamHelpers,makeCharacterParam,0,0,0,character,1
+ParamHelpers,makeCharacterParam,1,0,0,any,1
+ParamHelpers,makeCharacterParam,2,0,0,null,1
+ParamHelpers,makeCharacterParam,3,0,0,list<any>,1
+ParamHelpers,makeDiscreteParam,-1,0,0,class<`Param`>,1
+ParamHelpers,makeDiscreteParam,0,0,0,character,1
+ParamHelpers,makeDiscreteParam,1,0,0,character[],1
+ParamHelpers,makeDiscreteParam,1,0,1,integer[],1
+ParamHelpers,makeDiscreteParam,1,0,2,list<null | list<any>>,1
+ParamHelpers,makeDiscreteParam,1,0,3,list<null | double>,1
+ParamHelpers,makeDiscreteParam,2,0,0,null,1
+ParamHelpers,makeDiscreteParam,3,0,0,any,1
+ParamHelpers,makeDiscreteParam,4,0,0,null,1
+ParamHelpers,makeDiscreteParam,5,0,0,logical,1
+ParamHelpers,makeDiscreteParam,6,0,0,list<any>,1
+ParamHelpers,makeDiscreteVectorParam,-1,0,0,class<`Param`>,1
+ParamHelpers,makeDiscreteVectorParam,0,0,0,character,1
+ParamHelpers,makeDiscreteVectorParam,1,0,0,double,1
+ParamHelpers,makeDiscreteVectorParam,2,0,0,character[],1
+ParamHelpers,makeDiscreteVectorParam,3,0,0,null,1
+ParamHelpers,makeDiscreteVectorParam,4,0,0,any,1
+ParamHelpers,makeDiscreteVectorParam,5,0,0,null,1
+ParamHelpers,makeDiscreteVectorParam,6,0,0,logical,1
+ParamHelpers,makeDiscreteVectorParam,7,0,0,list<any>,1
+ParamHelpers,makeIntegerParam,-1,0,0,class<`Param`>,1
+ParamHelpers,makeIntegerParam,0,0,0,character,1
+ParamHelpers,makeIntegerParam,1,0,0,double,1
+ParamHelpers,makeIntegerParam,1,0,1,expression,1
+ParamHelpers,makeIntegerParam,2,0,0,double,1
+ParamHelpers,makeIntegerParam,2,0,1,expression,1
+ParamHelpers,makeIntegerParam,3,0,0,any,1
+ParamHelpers,makeIntegerParam,4,0,0,null,1
+ParamHelpers,makeIntegerParam,4,0,1,class<`function`>,1
+ParamHelpers,makeIntegerParam,5,0,0,null,1
+ParamHelpers,makeIntegerParam,6,0,0,logical,1
+ParamHelpers,makeIntegerParam,7,0,0,list<any>,1
+ParamHelpers,makeIntegerVectorParam,-1,0,0,class<`Param`>,1
+ParamHelpers,makeIntegerVectorParam,0,0,0,character,1
+ParamHelpers,makeIntegerVectorParam,1,0,0,double,1
+ParamHelpers,makeIntegerVectorParam,2,0,0,double,1
+ParamHelpers,makeIntegerVectorParam,3,0,0,double,1
+ParamHelpers,makeIntegerVectorParam,4,0,0,null,1
+ParamHelpers,makeIntegerVectorParam,5,0,0,any,1
+ParamHelpers,makeIntegerVectorParam,6,0,0,null,1
+ParamHelpers,makeIntegerVectorParam,7,0,0,null,1
+ParamHelpers,makeLearnerParam,-1,0,0,"class<`LearnerParam`, `Param`>",1
+ParamHelpers,makeLearnerParam,0,0,0,class<`Param`>,1
+ParamHelpers,makeLearnerParam,1,0,0,character,1
+ParamHelpers,makeLogicalParam,-1,0,0,class<`Param`>,1
+ParamHelpers,makeLogicalParam,0,0,0,character,1
+ParamHelpers,makeLogicalParam,1,0,0,any,1
+ParamHelpers,makeLogicalParam,2,0,0,null,1
+ParamHelpers,makeLogicalParam,3,0,0,logical,1
+ParamHelpers,makeLogicalParam,4,0,0,list<any>,1
+ParamHelpers,makeNumericLearnerParam,-1,0,0,"class<`LearnerParam`, `Param`>",1
+ParamHelpers,makeNumericLearnerParam,0,0,0,character,1
+ParamHelpers,makeNumericLearnerParam,1,0,0,double,1
+ParamHelpers,makeNumericLearnerParam,2,0,0,double,1
+ParamHelpers,makeNumericLearnerParam,2,0,1,expression,1
+ParamHelpers,makeNumericLearnerParam,3,0,0,logical,1
+ParamHelpers,makeNumericLearnerParam,4,0,0,any,1
+ParamHelpers,makeNumericLearnerParam,5,0,0,character,1
+ParamHelpers,makeNumericLearnerParam,6,0,0,null,1
+ParamHelpers,makeNumericLearnerParam,7,0,0,logical,1
+ParamHelpers,makeNumericParam,-1,0,0,class<`Param`>,1
+ParamHelpers,makeNumericParam,0,0,0,character,1
+ParamHelpers,makeNumericParam,1,0,0,double,1
+ParamHelpers,makeNumericParam,1,0,1,expression,1
+ParamHelpers,makeNumericParam,2,0,0,double,1
+ParamHelpers,makeNumericParam,2,0,1,expression,1
+ParamHelpers,makeNumericParam,3,0,0,logical,1
+ParamHelpers,makeNumericParam,4,0,0,any,1
+ParamHelpers,makeNumericParam,5,0,0,null,1
+ParamHelpers,makeNumericParam,5,0,1,class<`function`>,1
+ParamHelpers,makeNumericParam,6,0,0,null,1
+ParamHelpers,makeNumericParam,7,0,0,logical,1
+ParamHelpers,makeNumericVectorParam,-1,0,0,class<`Param`>,1
+ParamHelpers,makeNumericVectorParam,0,0,0,character,1
+ParamHelpers,makeNumericVectorParam,1,0,0,double,1
+ParamHelpers,makeNumericVectorParam,1,0,1,expression,1
+ParamHelpers,makeNumericVectorParam,2,0,0,double[],1
+ParamHelpers,makeNumericVectorParam,3,0,0,double[],1
+ParamHelpers,makeNumericVectorParam,3,0,1,expression,1
+ParamHelpers,makeNumericVectorParam,4,0,0,null,1
+ParamHelpers,makeNumericVectorParam,5,0,0,logical,1
+ParamHelpers,makeNumericVectorParam,6,0,0,any,1
+ParamHelpers,makeNumericVectorParam,7,0,0,null,1
+ParamHelpers,makeNumericVectorParam,7,0,1,class<`function`>,1
+ParamHelpers,makeOptPath,-1,0,0,class<`OptPath`>,1
+ParamHelpers,makeOptPath,0,0,0,class<`ParamSet`>,1
+ParamHelpers,makeOptPath,1,0,0,character[],1
+ParamHelpers,makeOptPath,2,0,0,logical[],1
+ParamHelpers,makeOptPath,3,0,0,logical,1
+ParamHelpers,makeOptPath,4,0,0,logical,1
+ParamHelpers,makeOptPath,5,0,0,logical,1
+ParamHelpers,makeOptPath,6,0,0,logical,1
+ParamHelpers,makeOptPathDF,-1,0,0,"class<`OptPath`, `OptPathDF`>",1
+ParamHelpers,makeOptPathDF,0,0,0,class<`ParamSet`>,1
+ParamHelpers,makeOptPathDF,1,0,0,character[],1
+ParamHelpers,makeOptPathDF,2,0,0,logical[],1
+ParamHelpers,makeOptPathDF,3,0,0,logical,1
+ParamHelpers,makeOptPathDF,4,0,0,logical,1
+ParamHelpers,makeOptPathDF,5,0,0,logical,1
+ParamHelpers,makeOptPathDF,6,0,0,logical,1
+ParamHelpers,makeParam,-1,0,0,"class<`LearnerParam`, `Param`>",1
+ParamHelpers,makeParam,-1,0,1,class<`Param`>,1
+ParamHelpers,makeParam,0,0,0,character,1
+ParamHelpers,makeParam,1,0,0,character,1
+ParamHelpers,makeParam,2,0,0,logical,1
+ParamHelpers,makeParam,3,0,0,double,1
+ParamHelpers,makeParam,3,0,1,expression,1
+ParamHelpers,makeParam,4,0,0,double[],1
+ParamHelpers,makeParam,4,0,1,null,1
+ParamHelpers,makeParam,4,0,2,expression,1
+ParamHelpers,makeParam,5,0,0,expression,1
+ParamHelpers,makeParam,5,0,1,double[],1
+ParamHelpers,makeParam,5,0,2,null,1
+ParamHelpers,makeParam,6,0,0,null,1
+ParamHelpers,makeParam,6,0,1,character[],1
+ParamHelpers,makeParam,6,0,2,integer[],1
+ParamHelpers,makeParam,6,0,3,list<null | list<any>>,1
+ParamHelpers,makeParam,6,0,4,list<null | double>,1
+ParamHelpers,makeParam,6,0,5,list<logical>,1
+ParamHelpers,makeParam,7,0,0,null,1
+ParamHelpers,makeParamSet,-1,0,0,"class<`LearnerParamSet`, `ParamSet`>",1
+ParamHelpers,makeParamSet,-1,0,1,class<`ParamSet`>,1
+ParamHelpers,makeParamSet,0,0,0,...,1
+ParamHelpers,makeParamSet,1,0,0,null,1
+ParamHelpers,makeParamSet,2,0,0,null,1
+ParamHelpers,makeParamSet,2,0,1,expression,1
+ParamHelpers,makeParamSet,3,0,0,null,1
+ParamHelpers,makeParamSet,3,0,1,character[],1
+ParamHelpers,mapDfc,-1,0,0,class<`data.frame`>,1
+ParamHelpers,mapDfc,0,0,0,integer[],1
+ParamHelpers,mapDfc,1,0,0,class<`function`>,1
+ParamHelpers,mapDfc,2,0,0,...,1
+ParamHelpers,paramValueToString,-1,0,0,character,1
+ParamHelpers,paramValueToString,0,0,0,class<`Param`>,1
+ParamHelpers,paramValueToString,0,0,1,class<`ParamSet`>,1
+ParamHelpers,paramValueToString,1,0,0,double[],1
+ParamHelpers,paramValueToString,1,0,1,null,1
+ParamHelpers,paramValueToString,1,0,2,list<double[] | null>,1
+ParamHelpers,paramValueToString,2,0,0,logical,1
+ParamHelpers,paramValueToString,3,0,0,character,1
+ParamHelpers,paramValueToString.Param,-1,0,0,character,1
+ParamHelpers,paramValueToString.Param,0,0,0,class<`Param`>,1
+ParamHelpers,paramValueToString.Param,1,0,0,double[],1
+ParamHelpers,paramValueToString.Param,1,0,1,null,1
+ParamHelpers,paramValueToString.Param,2,0,0,logical,1
+ParamHelpers,paramValueToString.Param,3,0,0,character,1
+ParamHelpers,paramValueToString.ParamSet,-1,0,0,character,1
+ParamHelpers,paramValueToString.ParamSet,0,0,0,class<`ParamSet`>,1
+ParamHelpers,paramValueToString.ParamSet,1,0,0,list<double[] | null>,1
+ParamHelpers,paramValueToString.ParamSet,2,0,0,logical,1
+ParamHelpers,paramValueToString.ParamSet,3,0,0,character,1
+ParamHelpers,requiresOk,-1,0,0,logical,1
+ParamHelpers,requiresOk,0,0,0,class<`Param`>,1
+ParamHelpers,requiresOk,1,0,0,any,1
+ParamHelpers,sampleValue,-1,0,0,double,1
+ParamHelpers,sampleValue,-1,0,1,character,1
+ParamHelpers,sampleValue,-1,0,2,integer[],1
+ParamHelpers,sampleValue,-1,0,3,list<double>,1
+ParamHelpers,sampleValue,0,0,0,class<`Param`>,1
+ParamHelpers,sampleValue,0,0,1,class<`ParamSet`>,1
+ParamHelpers,sampleValue,1,0,0,logical,1
+ParamHelpers,sampleValue,2,0,0,logical,1
+ParamHelpers,sampleValue.Param,-1,0,0,character,1
+ParamHelpers,sampleValue.Param,-1,0,1,double,1
+ParamHelpers,sampleValue.Param,-1,0,2,integer[],1
+ParamHelpers,sampleValue.Param,0,0,0,class<`Param`>,1
+ParamHelpers,sampleValue.Param,1,0,0,logical,1
+ParamHelpers,sampleValue.Param,2,0,0,logical,1
+ParamHelpers,sampleValue.ParamSet,-1,0,0,list<double>,1
+ParamHelpers,sampleValue.ParamSet,0,0,0,class<`ParamSet`>,1
+ParamHelpers,sampleValue.ParamSet,1,0,0,logical,1
+ParamHelpers,sampleValue.ParamSet,2,0,0,logical,1
+ParamHelpers,sampleValues,-1,0,0,list<double>,1
+ParamHelpers,sampleValues,-1,0,1,list<list<double>>,1
+ParamHelpers,sampleValues,0,0,0,class<`Param`>,1
+ParamHelpers,sampleValues,0,0,1,class<`ParamSet`>,1
+ParamHelpers,sampleValues,1,0,0,double,1
+ParamHelpers,sampleValues,2,0,0,logical,1
+ParamHelpers,sampleValues,3,0,0,logical,1
+ParamHelpers,setRequiresToNA,-1,0,0,class<`data.frame`>,1
+ParamHelpers,setRequiresToNA,0,0,0,class<`data.frame`>,1
+ParamHelpers,setRequiresToNA,1,0,0,list<class<`Param`>>,1
+ParamHelpers,setRequiresToNA,2,0,0,list<character[]>,1
+ParamHelpers,setRequiresToNA,3,0,0,list<null>,1
+ParamHelpers,setRequiresToNA,4,0,0,logical[],1
+ParamHelpers,stopIfFunOrUntypedParams,-1,0,0,null,1
+ParamHelpers,stopIfFunOrUntypedParams,0,0,0,class<`ParamSet`>,1
+ParamHelpers,stopIfLearnerParams,-1,0,0,null,1
+ParamHelpers,stopIfLearnerParams,0,0,0,class<`ParamSet`>,1
+ParamHelpers,trafoOptPath,-1,0,0,"class<`OptPath`, `OptPathDF`>",1
+ParamHelpers,trafoOptPath,0,0,0,"class<`OptPath`, `OptPathDF`>",1
+ParamHelpers,trafoValue,-1,0,0,list<double[] | character>,1
+ParamHelpers,trafoValue,-1,0,1,character,1
+ParamHelpers,trafoValue,-1,0,2,double[],1
+ParamHelpers,trafoValue,0,0,0,class<`Param`>,1
+ParamHelpers,trafoValue,0,0,1,class<`ParamSet`>,1
+ParamHelpers,trafoValue,1,0,0,list<double[] | character>,1
+ParamHelpers,trafoValue,1,0,1,character,1
+ParamHelpers,trafoValue,1,0,2,double[],1
+R.cache,addMemoization,-1,0,0,any,1
+R.cache,addMemoization,0,0,0,...,1
+R.cache,addMemoization.default,-1,0,0,any,1
+R.cache,addMemoization.default,0,0,0,character,1
+R.cache,addMemoization.default,0,0,1,class<`function`>,1
+R.cache,addMemoization.default,0,0,2,"class<`MemoizedFunction`, `function`>",1
+R.cache,addMemoization.default,0,0,3,null,1
+R.cache,addMemoization.default,1,0,0,any,1
+R.cache,addMemoization.default,2,0,0,...,1
+R.cache,.addREADME,-1,0,0,logical,1
+R.cache,.addREADME,-1,0,1,null,1
+R.cache,.addREADME,0,0,0,character,1
+R.cache,.addREADME,1,0,0,...,1
+R.cache,.baseLoad,-1,0,0,pairlist,1
+R.cache,.baseLoad,0,0,0,"class<`connection`, `gzfile`>",1
+R.cache,.baseLoad,1,0,0,any,1
+R.cache,clearCache.default,-1,0,0,character[],1
+R.cache,clearCache.default,-1,0,1,null,1
+R.cache,clearCache.default,0,0,0,character,1
+R.cache,clearCache.default,1,0,0,...,1
+R.cache,clearCache.default,2,0,0,logical,1
+R.cache,clearCache.default,3,0,0,logical,1
+R.cache,evalWithMemoization,-1,0,0,double,1
+R.cache,evalWithMemoization,0,0,0,any,1
+R.cache,evalWithMemoization,1,0,0,null,1
+R.cache,evalWithMemoization,1,0,1,list<integer>,1
+R.cache,evalWithMemoization,2,0,0,...,1
+R.cache,evalWithMemoization,3,0,0,environment,1
+R.cache,evalWithMemoization,4,0,0,character[],1
+R.cache,evalWithMemoization,5,0,0,logical,1
+R.cache,findCache,-1,0,0,any,1
+R.cache,findCache,0,0,0,...,1
+R.cache,findCache.default,-1,0,0,any,1
+R.cache,findCache.default,0,0,0,list<double>,1
+R.cache,findCache.default,0,0,1,list<class<`{`> | integer>,1
+R.cache,findCache.default,0,0,2,list<class<`{`>>,1
+R.cache,findCache.default,0,0,3,null,1
+R.cache,findCache.default,1,0,0,...,1
+R.cache,generateCache,-1,0,0,any,1
+R.cache,generateCache,0,0,0,...,1
+R.cache,generateCache.default,-1,0,0,any,1
+R.cache,generateCache.default,0,0,0,list<character>,1
+R.cache,generateCache.default,0,0,1,list<double>,1
+R.cache,generateCache.default,0,0,2,list<class<`{`> | integer>,1
+R.cache,generateCache.default,0,0,3,list<class<`{`>>,1
+R.cache,generateCache.default,0,0,4,list<class<`function`> | double>,1
+R.cache,generateCache.default,0,0,5,null,1
+R.cache,generateCache.default,1,0,0,character,1
+R.cache,generateCache.default,2,0,0,...,1
+R.cache,getCachePath,-1,0,0,character,1
+R.cache,getCachePath,0,0,0,...,1
+R.cache,getCachePath.default,-1,0,0,character,1
+R.cache,getCachePath.default,0,0,0,character[],1
+R.cache,getCachePath.default,0,0,1,integer[],1
+R.cache,getCachePath.default,0,0,2,null,1
+R.cache,getCachePath.default,1,0,0,character,1
+R.cache,getCachePath.default,1,0,1,null,1
+R.cache,getCachePath.default,2,0,0,character,1
+R.cache,getCachePath.default,3,0,0,...,1
+R.cache,getCacheRootPath,-1,0,0,any,1
+R.cache,getCacheRootPath,0,0,0,...,1
+R.cache,getCacheRootPath.default,-1,0,0,any,1
+R.cache,getCacheRootPath.default,0,0,0,null,1
+R.cache,getCacheRootPath.default,1,0,0,...,1
+R.cache,getChecksum,-1,0,0,character,1
+R.cache,getChecksum,0,0,0,...,1
+R.cache,getChecksum.default,-1,0,0,character,1
+R.cache,getChecksum.default,0,0,0,class<`Object`>,1
+R.cache,getChecksum.default,0,0,1,list<character>,1
+R.cache,getChecksum.default,0,0,2,list<double>,1
+R.cache,getChecksum.default,0,0,3,list<class<`{`> | integer>,1
+R.cache,getChecksum.default,0,0,4,list<class<`{`>>,1
+R.cache,getChecksum.default,0,0,5,list<class<`function`> | double>,1
+R.cache,getChecksum.default,1,0,0,...,1
+R.cache,getChecksum.Object,-1,0,0,character,1
+R.cache,getChecksum.Object,0,0,0,class<`Object`>,1
+R.cache,getChecksum.Object,1,0,0,...,1
+R.cache,getDefaultCacheRootPath,-1,0,0,character,1
+R.cache,getDefaultCacheRootPath,0,0,0,character,1
+R.cache,getDefaultCacheRootPath,0,0,1,null,1
+R.cache,inRCmdCheck,-1,0,0,logical,1
+R.cache,loadCache,-1,0,0,double[],1
+R.cache,loadCache,-1,0,1,null,1
+R.cache,loadCache,-1,0,2,list<environment | double>,1
+R.cache,loadCache,-1,0,3,list<environment | integer>,1
+R.cache,loadCache,0,0,0,...,1
+R.cache,loadCache.default,-1,0,0,double[],1
+R.cache,loadCache.default,-1,0,1,null,1
+R.cache,loadCache.default,-1,0,2,list<environment | double>,1
+R.cache,loadCache.default,-1,0,3,list<environment | integer>,1
+R.cache,loadCache.default,0,0,0,list<double>,1
+R.cache,loadCache.default,0,0,1,null,1
+R.cache,loadCache.default,0,0,2,list<class<`{`>>,1
+R.cache,loadCache.default,0,0,3,list<class<`{`> | integer>,1
+R.cache,loadCache.default,1,0,0,any,1
+R.cache,loadCache.default,2,0,0,character,1
+R.cache,loadCache.default,3,0,0,logical,1
+R.cache,loadCache.default,4,0,0,null,1
+R.cache,loadCache.default,4,0,1,character,1
+R.cache,loadCache.default,5,0,0,null,1
+R.cache,loadCache.default,6,0,0,...,1
+R.cache,loadCache.default,7,0,0,character[],1
+R.cache,memoizedCall,-1,0,0,double,1
+R.cache,memoizedCall,0,0,0,...,1
+R.cache,memoizedCall.default,-1,0,0,double,1
+R.cache,memoizedCall.default,0,0,0,class<`function`>,1
+R.cache,memoizedCall.default,1,0,0,...,1
+R.cache,memoizedCall.default,2,0,0,any,1
+R.cache,memoizedCall.default,3,0,0,logical,1
+R.cache,memoizedCall.default,4,0,0,null,1
+R.cache,memoizedCall.default,5,0,0,character[],1
+R.cache,memoizedCall.default,5,0,1,null,1
+R.cache,queryRCmdCheck,-1,0,0,character,1
+R.cache,queryRCmdCheck,0,0,0,...,1
+R.cache,readCacheHeader,-1,0,0,"list<character | class<`POSIXct`, `POSIXt`>>",1
+R.cache,readCacheHeader,0,0,0,...,1
+R.cache,readCacheHeader.default,-1,0,0,"list<character | class<`POSIXct`, `POSIXt`>>",1
+R.cache,readCacheHeader.default,0,0,0,character,1
+R.cache,readCacheHeader.default,0,0,1,"class<`connection`, `gzfile`>",1
+R.cache,readCacheHeader.default,1,0,0,...,1
+R.cache,saveCache,-1,0,0,character,1
+R.cache,saveCache,0,0,0,...,1
+R.cache,saveCache.default,-1,0,0,character,1
+R.cache,saveCache.default,0,0,0,double[],1
+R.cache,saveCache.default,1,0,0,list<double>,1
+R.cache,saveCache.default,1,0,1,list<character>,1
+R.cache,saveCache.default,1,0,2,null,1
+R.cache,saveCache.default,2,0,0,null,1
+R.cache,saveCache.default,3,0,0,character,1
+R.cache,saveCache.default,4,0,0,character,1
+R.cache,saveCache.default,4,0,1,null,1
+R.cache,saveCache.default,5,0,0,null,1
+R.cache,saveCache.default,5,0,1,character,1
+R.cache,saveCache.default,6,0,0,null,1
+R.cache,saveCache.default,6,0,1,character[],1
+R.cache,saveCache.default,7,0,0,null,1
+R.cache,saveCache.default,7,0,1,logical,1
+R.cache,saveCache.default,8,0,0,...,1
+R.cache,setCachePath,-1,0,0,list<null>,1
+R.cache,setCachePath,0,0,0,...,1
+R.cache,setCachePath.default,-1,0,0,list<null>,1
+R.cache,setCachePath.default,0,0,0,character[],1
+R.cache,setCachePath.default,1,0,0,character,1
+R.cache,setCachePath.default,2,0,0,...,1
+R.cache,setCacheRootPath,-1,0,0,list<character>,1
+R.cache,setCacheRootPath,-1,0,1,list<null>,1
+R.cache,setCacheRootPath,0,0,0,...,1
+R.cache,setCacheRootPath.default,-1,0,0,list<character>,1
+R.cache,setCacheRootPath.default,-1,0,1,list<null>,1
+R.cache,setCacheRootPath.default,0,0,0,character,1
+R.cache,setCacheRootPath.default,1,0,0,...,1
+R.cache,setupCacheRootPath,-1,0,0,character,1
+R.cache,setupCacheRootPath,0,0,0,...,1
+R.cache,setupCacheRootPath.default,-1,0,0,character,1
+R.cache,setupCacheRootPath.default,0,0,0,character,1
+R.cache,setupCacheRootPath.default,0,0,1,null,1
+R.cache,setupCacheRootPath.default,1,0,0,...,1
+R.matlab,as.character.Matlab,-1,0,0,character,1
+R.matlab,as.character.Matlab,0,0,0,"class<`Matlab`, `Object`>",1
+R.matlab,as.character.Matlab,1,0,0,...,1
+R.matlab,close.Matlab,-1,0,0,null,1
+R.matlab,close.Matlab,0,0,0,"class<`Matlab`, `Object`>",1
+R.matlab,close.Matlab,1,0,0,...,1
+R.matlab,evaluate,-1,0,0,any,1
+R.matlab,evaluate,0,0,0,...,1
+R.matlab,evaluate.Matlab,-1,0,0,any,1
+R.matlab,evaluate.Matlab,0,0,0,"class<`Matlab`, `Object`>",1
+R.matlab,evaluate.Matlab,1,0,0,...,1
+R.matlab,evaluate.Matlab,2,0,0,character,1
+R.matlab,evaluate.Matlab,3,0,0,logical,1
+R.matlab,finalize.Matlab,-1,0,0,null,1
+R.matlab,finalize.Matlab,0,0,0,"class<`Matlab`, `Object`>",1
+R.matlab,finalize.Matlab,1,0,0,...,1
+R.matlab,getOption.Matlab,-1,0,0,double,1
+R.matlab,getOption.Matlab,-1,0,1,null,1
+R.matlab,getOption.Matlab,0,0,0,"class<`Matlab`, `Object`>",1
+R.matlab,getOption.Matlab,1,0,0,...,1
+R.matlab,getVariable,-1,0,0,any,1
+R.matlab,getVariable,0,0,0,...,1
+R.matlab,getVariable.Matlab,-1,0,0,any,1
+R.matlab,getVariable.Matlab,0,0,0,"class<`Matlab`, `Object`>",1
+R.matlab,getVariable.Matlab,1,0,0,character,1
+R.matlab,getVariable.Matlab,2,0,0,any,1
+R.matlab,getVariable.Matlab,3,0,0,...,1
+R.matlab,isOpen,-1,0,0,logical,1
+R.matlab,isOpen,0,0,0,...,1
+R.matlab,isOpen.default,-1,0,0,logical,1
+R.matlab,isOpen.default,0,0,0,...,1
+R.matlab,isOpen.Matlab,-1,0,0,logical,1
+R.matlab,isOpen.Matlab,0,0,0,"class<`Matlab`, `Object`>",1
+R.matlab,isOpen.Matlab,1,0,0,...,1
+R.matlab,Matlab,-1,0,0,"class<`Matlab`, `Object`>",1
+R.matlab,Matlab,0,0,0,character,1
+R.matlab,Matlab,1,0,0,double,1
+R.matlab,Matlab,2,0,0,logical,1
+R.matlab,.onAttach,-1,0,0,null,1
+R.matlab,.onAttach,0,0,0,any,1
+R.matlab,.onAttach,1,0,0,character,1
+R.matlab,.onLoad,-1,0,0,any,1
+R.matlab,.onLoad,0,0,0,any,1
+R.matlab,.onLoad,1,0,0,character,1
+R.matlab,.onUnload,-1,0,0,class<`matrix`>,1
+R.matlab,.onUnload,0,0,0,any,1
+R.matlab,open.Matlab,-1,0,0,list<any>,1
+R.matlab,open.Matlab,0,0,0,"class<`Matlab`, `Object`>",1
+R.matlab,open.Matlab,1,0,0,integer,1
+R.matlab,open.Matlab,2,0,0,double,1
+R.matlab,open.Matlab,3,0,0,double,1
+R.matlab,open.Matlab,4,0,0,...,1
+R.matlab,readMat,-1,0,0,any,1
+R.matlab,readMat,0,0,0,...,1
+R.matlab,readMat.default,-1,0,0,list<any>,1
+R.matlab,readMat.default,0,0,0,character,1
+R.matlab,readMat.default,0,0,1,"class<`connection`, `file`>",1
+R.matlab,readMat.default,0,0,2,raw[],1
+R.matlab,readMat.default,1,0,0,null,1
+R.matlab,readMat.default,2,0,0,logical,1
+R.matlab,readMat.default,3,0,0,character,1
+R.matlab,readMat.default,4,0,0,character[],1
+R.matlab,readMat.default,5,0,0,double,1
+R.matlab,readMat.default,6,0,0,...,1
+R.matlab,readResult,-1,0,0,any,1
+R.matlab,readResult,0,0,0,...,1
+R.matlab,readResult.Matlab,-1,0,0,any,1
+R.matlab,readResult.Matlab,0,0,0,"class<`Matlab`, `Object`>",1
+R.matlab,readResult.Matlab,1,0,0,...,1
+R.matlab,setFunction,-1,0,0,any,1
+R.matlab,setFunction,0,0,0,...,1
+R.matlab,setFunction.Matlab,-1,0,0,list<any>,1
+R.matlab,setFunction.Matlab,0,0,0,"class<`Matlab`, `Object`>",1
+R.matlab,setFunction.Matlab,1,0,0,character,1
+R.matlab,setFunction.Matlab,2,0,0,null,1
+R.matlab,setFunction.Matlab,3,0,0,character,1
+R.matlab,setFunction.Matlab,4,0,0,...,1
+R.matlab,setOption.Matlab,-1,0,0,null,1
+R.matlab,setOption.Matlab,0,0,0,"class<`Matlab`, `Object`>",1
+R.matlab,setOption.Matlab,1,0,0,...,1
+R.matlab,setVariable,-1,0,0,any,1
+R.matlab,setVariable,0,0,0,...,1
+R.matlab,setVariable.Matlab,-1,0,0,list<any>,1
+R.matlab,setVariable.Matlab,0,0,0,"class<`Matlab`, `Object`>",1
+R.matlab,setVariable.Matlab,1,0,0,...,1
+R.matlab,setVariable.Matlab,2,0,0,logical,1
+R.matlab,setVerbose,-1,0,0,double,1
+R.matlab,setVerbose,0,0,0,...,1
+R.matlab,setVerbose.Matlab,-1,0,0,double,1
+R.matlab,setVerbose.Matlab,0,0,0,"class<`Matlab`, `Object`>",1
+R.matlab,setVerbose.Matlab,1,0,0,double,1
+R.matlab,setVerbose.Matlab,2,0,0,...,1
+R.matlab,startServer,-1,0,0,integer,1
+R.matlab,startServer,0,0,0,...,1
+R.matlab,startServer.Matlab,-1,0,0,integer,1
+R.matlab,startServer.Matlab,0,0,0,"class<`Matlab`, `Object`>",1
+R.matlab,startServer.Matlab,1,0,0,null,1
+R.matlab,startServer.Matlab,2,0,0,double,1
+R.matlab,startServer.Matlab,3,0,0,logical,1
+R.matlab,startServer.Matlab,4,0,0,character[],1
+R.matlab,startServer.Matlab,5,0,0,character,1
+R.matlab,startServer.Matlab,6,0,0,...,1
+R.matlab,stop_if_not,-1,0,0,null,1
+R.matlab,stop_if_not,0,0,0,...,1
+R.matlab,writeCommand,-1,0,0,any,1
+R.matlab,writeCommand,0,0,0,...,1
+R.matlab,writeCommand.Matlab,-1,0,0,any,1
+R.matlab,writeCommand.Matlab,0,0,0,"class<`Matlab`, `Object`>",1
+R.matlab,writeCommand.Matlab,1,0,0,character,1
+R.matlab,writeCommand.Matlab,2,0,0,...,1
+R.matlab,writeMat,-1,0,0,any,1
+R.matlab,writeMat,0,0,0,...,1
+R.matlab,writeMat.default,-1,0,0,any,1
+R.matlab,writeMat.default,0,0,0,character,1
+R.matlab,writeMat.default,0,0,1,"class<`connection`, `file`>",1
+R.matlab,writeMat.default,1,0,0,...,1
+R.matlab,writeMat.default,2,0,0,logical,1
+R.matlab,writeMat.default,3,0,0,character,1
+R.matlab,writeMat.default,4,0,0,class<`function`>,1
+R.matlab,writeMat.default,4,0,1,null,1
+R.matlab,writeMat.default,5,0,0,any,1
+R.methodsS3,appendVarArgs,-1,0,0,class<`function`>,1
+R.methodsS3,appendVarArgs,0,0,0,...,1
+R.methodsS3,appendVarArgs.function,-1,0,0,class<`function`>,1
+R.methodsS3,appendVarArgs.function,0,0,0,class<`function`>,1
+R.methodsS3,appendVarArgs.function,1,0,0,...,1
+R.methodsS3,export,-1,0,0,class<`function`>,1
+R.methodsS3,export,0,0,0,class<`function`>,1
+R.methodsS3,export<-,-1,0,0,class<`function`>,1
+R.methodsS3,export<-,0,0,0,class<`function`>,1
+R.methodsS3,export<-,1,0,0,logical,1
+R.methodsS3,findDispatchMethodsS3,-1,0,0,list<any>,1
+R.methodsS3,findDispatchMethodsS3,0,0,0,...,1
+R.methodsS3,findDispatchMethodsS3.default,-1,0,0,list<any>,1
+R.methodsS3,findDispatchMethodsS3.default,0,0,0,character,1
+R.methodsS3,findDispatchMethodsS3.default,1,0,0,character,1
+R.methodsS3,findDispatchMethodsS3.default,2,0,0,logical,1
+R.methodsS3,findDispatchMethodsS3.default,3,0,0,...,1
+R.methodsS3,.findFunction,-1,0,0,list<class<`function`> | character>,1
+R.methodsS3,.findFunction,-1,0,1,list<class<`standardGeneric`> | character>,1
+R.methodsS3,.findFunction,-1,0,2,list<null>,1
+R.methodsS3,.findFunction,0,0,0,character,1
+R.methodsS3,.findFunction,1,0,0,environment,1
+R.methodsS3,.findFunction,1,0,1,list<environment>,1
+R.methodsS3,.findFunction,2,0,0,logical[],1
+R.methodsS3,getDispatchMethodS3,-1,0,0,any,1
+R.methodsS3,getDispatchMethodS3,0,0,0,...,1
+R.methodsS3,getDispatchMethodS3.default,-1,0,0,any,1
+R.methodsS3,getDispatchMethodS3.default,0,0,0,character,1
+R.methodsS3,getDispatchMethodS3.default,1,0,0,character,1
+R.methodsS3,getDispatchMethodS3.default,2,0,0,...,1
+R.methodsS3,getGenericS3,-1,0,0,class<`function`>,1
+R.methodsS3,getGenericS3,0,0,0,...,1
+R.methodsS3,getGenericS3.default,-1,0,0,class<`function`>,1
+R.methodsS3,getGenericS3.default,0,0,0,character,1
+R.methodsS3,getGenericS3.default,1,0,0,environment,1
+R.methodsS3,getGenericS3.default,2,0,0,logical,1
+R.methodsS3,getGenericS3.default,3,0,0,...,1
+R.methodsS3,getMethodS3,-1,0,0,class<`function`>,1
+R.methodsS3,getMethodS3,0,0,0,...,1
+R.methodsS3,getMethodS3.default,-1,0,0,class<`function`>,1
+R.methodsS3,getMethodS3.default,0,0,0,character,1
+R.methodsS3,getMethodS3.default,1,0,0,character,1
+R.methodsS3,getMethodS3.default,2,0,0,environment,1
+R.methodsS3,getMethodS3.default,3,0,0,...,1
+R.methodsS3,hasVarArgs,-1,0,0,logical,1
+R.methodsS3,hasVarArgs,0,0,0,...,1
+R.methodsS3,hasVarArgs.function,-1,0,0,logical,1
+R.methodsS3,hasVarArgs.function,0,0,0,class<`function`>,1
+R.methodsS3,hasVarArgs.function,1,0,0,...,1
+R.methodsS3,isGenericS3,-1,0,0,logical,1
+R.methodsS3,isGenericS3,0,0,0,...,1
+R.methodsS3,isGenericS3.default,-1,0,0,logical,1
+R.methodsS3,isGenericS3.default,0,0,0,character,1
+R.methodsS3,isGenericS3.default,0,0,1,class<`function`>,1
+R.methodsS3,isGenericS3.default,1,0,0,any,1
+R.methodsS3,isGenericS3.default,2,0,0,...,1
+R.methodsS3,isGenericS4,-1,0,0,logical,1
+R.methodsS3,isGenericS4,0,0,0,...,1
+R.methodsS3,isGenericS4.default,-1,0,0,logical,1
+R.methodsS3,isGenericS4.default,0,0,0,character,1
+R.methodsS3,isGenericS4.default,0,0,1,class<`function`>,1
+R.methodsS3,isGenericS4.default,1,0,0,any,1
+R.methodsS3,isGenericS4.default,2,0,0,...,1
+R.methodsS3,noexport,-1,0,0,class<`function`>,1
+R.methodsS3,noexport,0,0,0,class<`function`>,1
+R.methodsS3,pkgStartupMessage,-1,0,0,null,1
+R.methodsS3,pkgStartupMessage,0,0,0,...,1
+R.methodsS3,pkgStartupMessage.default,-1,0,0,null,1
+R.methodsS3,pkgStartupMessage.default,0,0,0,...,1
+R.methodsS3,pkgStartupMessage.default,1,0,0,logical,1
+R.methodsS3,pkgStartupMessage.default,1,0,1,null,1
+R.methodsS3,rccValidateFunctionName,-1,0,0,null,1
+R.methodsS3,rccValidateFunctionName,0,0,0,character,1
+R.methodsS3,rccValidateFunctionName,1,0,0,...,1
+R.methodsS3,S3class<-,-1,0,0,class<`function`>,1
+R.methodsS3,S3class<-,0,0,0,class<`function`>,1
+R.methodsS3,S3class<-,1,0,0,character,1
+R.methodsS3,setGenericS3,-1,0,0,any,1
+R.methodsS3,setGenericS3,0,0,0,...,1
+R.methodsS3,setGenericS3.default,-1,0,0,any,1
+R.methodsS3,setGenericS3.default,0,0,0,character,1
+R.methodsS3,setGenericS3.default,1,0,0,any,1
+R.methodsS3,setGenericS3.default,2,0,0,environment,1
+R.methodsS3,setGenericS3.default,3,0,0,any,1
+R.methodsS3,setGenericS3.default,4,0,0,null,1
+R.methodsS3,setGenericS3.default,4,0,1,list<class<`function`>>,1
+R.methodsS3,setGenericS3.default,5,0,0,logical,1
+R.methodsS3,setGenericS3.default,6,0,0,...,1
+R.methodsS3,setMethodS3,-1,0,0,null,1
+R.methodsS3,setMethodS3,0,0,0,...,1
+R.methodsS3,setMethodS3.default,-1,0,0,null,1
+R.methodsS3,setMethodS3.default,0,0,0,character,1
+R.methodsS3,setMethodS3.default,1,0,0,character,1
+R.methodsS3,setMethodS3.default,2,0,0,any,1
+R.methodsS3,setMethodS3.default,3,0,0,logical,1
+R.methodsS3,setMethodS3.default,4,0,0,logical,1
+R.methodsS3,setMethodS3.default,5,0,0,logical,1
+R.methodsS3,setMethodS3.default,6,0,0,logical,1
+R.methodsS3,setMethodS3.default,7,0,0,logical,1
+R.methodsS3,setMethodS3.default,8,0,0,logical,1
+R.methodsS3,setMethodS3.default,9,0,0,logical,1
+R.methodsS3,setMethodS3.default,10,0,0,environment,1
+R.methodsS3,setMethodS3.default,11,0,0,logical,1
+R.methodsS3,setMethodS3.default,12,0,0,character[],1
+R.methodsS3,setMethodS3.default,13,0,0,logical,1
+R.methodsS3,setMethodS3.default,14,0,0,logical,1
+R.methodsS3,setMethodS3.default,15,0,0,logical,1
+R.methodsS3,setMethodS3.default,16,0,0,null,1
+R.methodsS3,setMethodS3.default,16,0,1,list<class<`function`>>,1
+R.methodsS3,setMethodS3.default,17,0,0,...,1
+R.methodsS3,throw,-1,0,0,any,1
+R.methodsS3,throw,0,0,0,...,1
+R.methodsS3,throw.default,-1,0,0,any,1
+R.methodsS3,throw.default,0,0,0,...,1
+R6,is.R6,-1,0,0,logical,1
+R6,is.R6,0,0,0,class<`R6`>,1
+R6,is.R6,0,0,1,class<`R6ClassGenerator`>,1
+R6,is.R6Class,-1,0,0,logical,1
+R6,is.R6Class,0,0,0,class<`R6`>,1
+R6,is.R6Class,0,0,1,class<`R6ClassGenerator`>,1
+R6,R6Class,-1,0,0,class<`R6ClassGenerator`>,1
+R6,R6Class,0,0,0,character,1
+R6,R6Class,0,0,1,null,1
+R6,R6Class,1,0,0,list<any>,1
+R6,R6Class,2,0,0,list<double>,1
+R6,R6Class,2,0,1,list<class<`function`>>,1
+R6,R6Class,2,0,2,list<class<`function`> | list<any>>,1
+R6,R6Class,2,0,3,null,1
+R6,R6Class,2,0,4,list<double | class<`function`>>,1
+R6,R6Class,3,0,0,null,1
+R6,R6Class,3,0,1,list<class<`function`>>,1
+R6,R6Class,4,0,0,any,1
+R6,R6Class,5,0,0,logical,1
+R6,R6Class,6,0,0,logical,1
+R6,R6Class,7,0,0,logical,1
+RcppEigen,fastLm,-1,0,0,class<`fastLm`>,1
+RcppEigen,fastLm,0,0,0,class<`formula`>,1
+RcppEigen,fastLm,1,0,0,...,1
+RcppEigen,fastLm.default,-1,0,0,class<`fastLm`>,1
+RcppEigen,fastLm.default,0,0,0,class<`matrix`>,1
+RcppEigen,fastLm.default,1,0,0,double[],1
+RcppEigen,fastLm.default,2,0,0,integer,1
+RcppEigen,fastLm.default,3,0,0,...,1
+RcppEigen,fastLm.formula,-1,0,0,class<`fastLm`>,1
+RcppEigen,fastLm.formula,0,0,0,class<`formula`>,1
+RcppEigen,fastLm.formula,1,0,0,class<`data.frame`>,1
+RcppEigen,fastLm.formula,2,0,0,integer,1
+RcppEigen,fastLm.formula,3,0,0,...,1
+RcppEigen,fastLmPure,-1,0,0,list<^double[]>,1
+RcppEigen,fastLmPure,0,0,0,class<`matrix`>,1
+RcppEigen,fastLmPure,1,0,0,double[],1
+RcppEigen,fastLmPure,2,0,0,integer,1
+RcppEigen,summary.fastLm,-1,0,0,class<`summary.fastLm`>,1
+RcppEigen,summary.fastLm,0,0,0,class<`fastLm`>,1
+RcppEigen,summary.fastLm,1,0,0,...,1
+Rfit,cellx,-1,0,0,class<`matrix`>,1
+Rfit,cellx,0,0,0,class<`data.frame`>,1
+Rfit,disp,-1,0,0,class<`matrix`>,1
+Rfit,disp,0,0,0,double[],1
+Rfit,disp,1,0,0,class<`matrix`>,1
+Rfit,disp,2,0,0,double[],1
+Rfit,disp,3,0,0,class<`scores`>,1
+Rfit,drop.test,-1,0,0,class<`drop.test`>,1
+Rfit,drop.test,0,0,0,class<`rfit`>,1
+Rfit,drop.test,1,0,0,class<`rfit`>,1
+Rfit,drop.test,1,0,1,null,1
+Rfit,getScores,-1,0,0,double[],1
+Rfit,getScores,0,0,0,class<`scores`>,1
+Rfit,getScores,1,0,0,double[],1
+Rfit,getScores,-1,1,0,double[],1
+Rfit,getScores,0,1,0,class<`scores`>,1
+Rfit,getScores,1,1,0,double[],1
+Rfit,getScoresDeriv,-1,0,0,double[],1
+Rfit,getScoresDeriv,0,0,0,class<`scores`>,1
+Rfit,getScoresDeriv,1,0,0,double[],1
+Rfit,getScoresDeriv,-1,1,0,double[],1
+Rfit,getScoresDeriv,0,1,0,class<`scores`>,1
+Rfit,getScoresDeriv,1,1,0,double[],1
+Rfit,jaeckel,-1,0,0,list<double[] | null>,1
+Rfit,jaeckel,-1,0,1,list<double | integer[] | null>,1
+Rfit,jaeckel,0,0,0,class<`matrix`>,1
+Rfit,jaeckel,1,0,0,double[],1
+Rfit,jaeckel,2,0,0,double[],1
+Rfit,jaeckel,3,0,0,class<`scores`>,1
+Rfit,jaeckel,4,0,0,null,1
+Rfit,jaeckel,5,0,0,...,1
+Rfit,khmat,-1,0,0,class<`matrix`>,1
+Rfit,khmat,0,0,0,class<`data.frame`>,1
+Rfit,khmat,1,0,0,class<`data.frame`>,1
+Rfit,kwayr,-1,0,0,list<class<`matrix`> | class<`rfit`>>,1
+Rfit,kwayr,0,0,0,integer[],1
+Rfit,kwayr,1,0,0,class<`data.frame`>,1
+Rfit,oneway.rfit,-1,0,0,class<`oneway.rfit`>,1
+Rfit,oneway.rfit,0,0,0,integer[],1
+Rfit,oneway.rfit,1,0,0,class<`factor`>,1
+Rfit,oneway.rfit,2,0,0,any,1
+Rfit,oneway.rfit,3,0,0,character,1
+Rfit,pasteColsRfit,-1,0,0,character[],1
+Rfit,pasteColsRfit,0,0,0,class<`matrix`>,1
+Rfit,pasteColsRfit,1,0,0,character,1
+Rfit,raov,-1,0,0,class<`raov`>,1
+Rfit,raov,0,0,0,class<`formula`>,1
+Rfit,raov,1,0,0,class<`data.frame`>,1
+Rfit,raov,2,0,0,...,1
+Rfit,redmod,-1,0,0,class<`matrix`>,1
+Rfit,redmod,0,0,0,class<`matrix`>,1
+Rfit,redmod,1,0,0,class<`matrix`>,1
+Rfit,rfit,-1,0,0,class<`rfit`>,1
+Rfit,rfit,0,0,0,class<`formula`>,1
+Rfit,rfit,1,0,0,any,1
+Rfit,rfit,2,0,0,...,1
+Rfit,rfit.default,-1,0,0,class<`rfit`>,1
+Rfit,rfit.default,0,0,0,class<`formula`>,1
+Rfit,rfit.default,1,0,0,any,1
+Rfit,rfit.default,2,0,0,any,1
+Rfit,rfit.default,3,0,0,null,1
+Rfit,rfit.default,3,0,1,class<`matrix`>,1
+Rfit,rfit.default,4,0,0,class<`scores`>,1
+Rfit,rfit.default,5,0,0,logical,1
+Rfit,rfit.default,6,0,0,character,1
+Rfit,rfit.default,7,0,0,...,1
+Rfit,rstudent.rfit,-1,0,0,class<`matrix`>,1
+Rfit,rstudent.rfit,0,0,0,class<`rfit`>,1
+Rfit,rstudent.rfit,1,0,0,...,1
+Rfit,subsets,-1,0,0,class<`data.frame`>,1
+Rfit,subsets,0,0,0,integer,1
+Rfit,summary.rfit,-1,0,0,class<`summary.rfit`>,1
+Rfit,summary.rfit,0,0,0,class<`rfit`>,1
+Rfit,summary.rfit,1,0,0,character,1
+Rfit,summary.rfit,2,0,0,...,1
+Rfit,taustar,-1,0,0,double,1
+Rfit,taustar,0,0,0,class<`matrix`>,1
+Rfit,taustar,1,0,0,integer,1
+Rfit,taustar,2,0,0,double,1
+Rfit,vcov.rfit,-1,0,0,class<`matrix`>,1
+Rfit,vcov.rfit,0,0,0,class<`rfit`>,1
+Rfit,vcov.rfit,1,0,0,null,1
+Rfit,vcov.rfit,2,0,0,...,1
+Rfit,wald.test.overall,-1,0,0,list<class<`matrix`> | double>,1
+Rfit,wald.test.overall,0,0,0,class<`rfit`>,1
+Rfit,walsh,-1,0,0,double[],1
+Rfit,walsh,0,0,0,double[],1
+Rglpk,as.glp_bounds,-1,0,0,"class<`bound_table`, `data.frame`>",1
+Rglpk,as.glp_bounds,0,0,0,list<any>,1
+Rglpk,as.glp_bounds,1,0,0,...,1
+Rglpk,as.glp_bounds.list,-1,0,0,"class<`bound_table`, `data.frame`>",1
+Rglpk,as.glp_bounds.list,0,0,0,list<any>,1
+Rglpk,as.glp_bounds.list,1,0,0,integer,1
+Rglpk,.check_control_parameters,-1,0,0,list<integer>,1
+Rglpk,.check_control_parameters,0,0,0,list<any>,1
+Rglpk,glp_bounds,-1,0,0,"class<`bound_table`, `data.frame`>",1
+Rglpk,glp_bounds,0,0,0,list<any>,1
+Rglpk,glp_bounds,1,0,0,integer,1
+Rglpk,glp_bounds_check_sanity,-1,0,0,null,1
+Rglpk,glp_bounds_check_sanity,0,0,0,list<double[]>,1
+Rglpk,glp_bounds_check_sanity,1,0,0,integer,1
+Rglpk,glp_call_interface,-1,0,0,list<double[] | character>,1
+Rglpk,glp_call_interface,0,0,0,double[],1
+Rglpk,glp_call_interface,1,0,0,integer,1
+Rglpk,glp_call_interface,2,0,0,integer[],1
+Rglpk,glp_call_interface,3,0,0,integer[],1
+Rglpk,glp_call_interface,4,0,0,double[],1
+Rglpk,glp_call_interface,5,0,0,integer,1
+Rglpk,glp_call_interface,6,0,0,double[],1
+Rglpk,glp_call_interface,7,0,0,integer[],1
+Rglpk,glp_call_interface,8,0,0,integer,1
+Rglpk,glp_call_interface,9,0,0,logical,1
+Rglpk,glp_call_interface,10,0,0,logical[],1
+Rglpk,glp_call_interface,11,0,0,logical[],1
+Rglpk,glp_call_interface,12,0,0,integer,1
+Rglpk,glp_call_interface,13,0,0,integer[],1
+Rglpk,glp_call_interface,14,0,0,double[],1
+Rglpk,glp_call_interface,15,0,0,double[],1
+Rglpk,glp_call_interface,16,0,0,integer,1
+Rglpk,glp_call_interface,17,0,0,integer,1
+Rglpk,glp_call_interface,18,0,0,integer,1
+Rglpk,glp_call_interface,19,0,0,integer,1
+Rglpk,glp_fix_bound_type,-1,0,0,"class<`bound_table`, `data.frame`>",1
+Rglpk,glp_fix_bound_type,0,0,0,"class<`bound_table`, `data.frame`>",1
+Rglpk,glp_get_meta_data_from_file,-1,0,0,list<character | integer>,1
+Rglpk,glp_get_meta_data_from_file,0,0,0,list<character | integer>,1
+Rglpk,glp_get_meta_data_from_file,1,0,0,logical,1
+Rglpk,glp_merge_MP_data,-1,0,0,list<any>,1
+Rglpk,glp_merge_MP_data,0,0,0,list<character | integer>,1
+Rglpk,glp_merge_MP_data,1,0,0,list<double[] | character[]>,1
+Rglpk,glp_retrieve_MP_from_file,-1,0,0,list<double[] | character[]>,1
+Rglpk,glp_retrieve_MP_from_file,0,0,0,list<character | integer>,1
+Rglpk,glp_retrieve_MP_from_file,1,0,0,logical,1
+Rglpk,glp_retrieve_MP_from_file,2,0,0,logical,1
+Rglpk,MILP,-1,0,0,class<`MILP`>,1
+Rglpk,MILP,0,0,0,double[],1
+Rglpk,MILP,1,0,0,list<class<`simple_triplet_matrix`> | character[] | double[]>,1
+Rglpk,MILP,2,0,0,list<list<double[]>>,1
+Rglpk,MILP,3,0,0,character[],1
+Rglpk,MILP,4,0,0,logical,1
+Rglpk,Rglpk_call,-1,0,0,list<double[] | null | list<double[]>>,1
+Rglpk,Rglpk_call,-1,0,1,list<double[] | null | list<double[] | null>>,1
+Rglpk,Rglpk_call,0,0,0,class<`simple_triplet_matrix`>,1
+Rglpk,Rglpk_call,0,0,1,double[],1
+Rglpk,Rglpk_call,1,0,0,class<`simple_triplet_matrix`>,1
+Rglpk,Rglpk_call,1,0,1,class<`matrix`>,1
+Rglpk,Rglpk_call,2,0,0,character[],1
+Rglpk,Rglpk_call,3,0,0,double[],1
+Rglpk,Rglpk_call,4,0,0,list<list<double[]>>,1
+Rglpk,Rglpk_call,4,0,1,null,1
+Rglpk,Rglpk_call,5,0,0,character[],1
+Rglpk,Rglpk_call,5,0,1,null,1
+Rglpk,Rglpk_call,6,0,0,logical,1
+Rglpk,Rglpk_call,7,0,0,logical,1
+Rglpk,Rglpk_call,8,0,0,integer,1
+Rglpk,Rglpk_call,9,0,0,integer,1
+Rglpk,Rglpk_call,10,0,0,integer,1
+Rglpk,Rglpk_call,11,0,0,character,1
+Rglpk,Rglpk_call,12,0,0,integer,1
+Rglpk,Rglpk_call,13,0,0,logical,1
+Rglpk,Rglpk_read_file,-1,0,0,"class<`MILP`, `MP_data_from_file`>",1
+Rglpk,Rglpk_read_file,0,0,0,character,1
+Rglpk,Rglpk_read_file,1,0,0,character,1
+Rglpk,Rglpk_read_file,2,0,0,logical,1
+Rglpk,Rglpk_read_file,3,0,0,logical,1
+Rglpk,Rglpk_solve_LP,-1,0,0,list<double[] | null | list<double[]>>,1
+Rglpk,Rglpk_solve_LP,-1,0,1,list<double[] | null | list<double[] | null>>,1
+Rglpk,Rglpk_solve_LP,0,0,0,class<`simple_triplet_matrix`>,1
+Rglpk,Rglpk_solve_LP,0,0,1,double[],1
+Rglpk,Rglpk_solve_LP,1,0,0,class<`simple_triplet_matrix`>,1
+Rglpk,Rglpk_solve_LP,1,0,1,class<`matrix`>,1
+Rglpk,Rglpk_solve_LP,2,0,0,character[],1
+Rglpk,Rglpk_solve_LP,3,0,0,double[],1
+Rglpk,Rglpk_solve_LP,4,0,0,list<list<double[]>>,1
+Rglpk,Rglpk_solve_LP,4,0,1,null,1
+Rglpk,Rglpk_solve_LP,5,0,0,character[],1
+Rglpk,Rglpk_solve_LP,5,0,1,null,1
+Rglpk,Rglpk_solve_LP,6,0,0,logical,1
+Rglpk,Rglpk_solve_LP,7,0,0,list<any>,1
+Rglpk,Rglpk_solve_LP,8,0,0,...,1
+Rmpfr,Ai,-1,0,0,class<`mpfr`>,1
+Rmpfr,Ai,0,0,0,double[],1
+Rmpfr,all.equal,-1,0,0,logical,1
+Rmpfr,all.equal,0,0,0,double[],1
+Rmpfr,all.equal,1,0,0,class<`mpfr`>,1
+Rmpfr,all.equal,2,0,0,...,1
+Rmpfr,all.equal,-1,1,0,character,1
+Rmpfr,all.equal,-1,1,1,logical,1
+Rmpfr,all.equal,0,1,0,class<`mpfr`>,1
+Rmpfr,all.equal,1,1,0,class<`mpfr`>,1
+Rmpfr,all.equal,2,1,0,...,1
+Rmpfr,all.equal,-1,2,0,logical,1
+Rmpfr,all.equal,0,2,0,class<`mpfrMatrix`>,1
+Rmpfr,all.equal,1,2,0,class<`matrix`>,1
+Rmpfr,all.equal,2,2,0,...,1
+Rmpfr,all.equal,-1,3,0,character,1
+Rmpfr,all.equal,-1,3,1,logical,1
+Rmpfr,all.equal,0,3,0,class<`mpfr`>,1
+Rmpfr,all.equal,1,3,0,double[],1
+Rmpfr,all.equal,2,3,0,...,1
+Rmpfr,all.equal,-1,4,0,logical,1
+Rmpfr,all.equal,0,4,0,class<`mpfrMatrix`>,1
+Rmpfr,all.equal,1,4,0,class<`mpfrMatrix`>,1
+Rmpfr,all.equal,2,4,0,...,1
+Rmpfr,all.equal,-1,5,0,logical,1
+Rmpfr,all.equal,0,5,0,class<`mpfrArray`>,1
+Rmpfr,all.equal,1,5,0,class<`mpfrArray`>,1
+Rmpfr,all.equal,2,5,0,...,1
+Rmpfr,aperm,-1,0,0,class<`mpfrMatrix`>,1
+Rmpfr,aperm,0,0,0,class<`mpfrMatrix`>,1
+Rmpfr,aperm,1,0,0,integer[],1
+Rmpfr,aperm,2,0,0,...,1
+Rmpfr,aperm,-1,1,0,class<`mpfrArray`>,1
+Rmpfr,aperm,0,1,0,class<`mpfrArray`>,1
+Rmpfr,aperm,1,1,0,any,1
+Rmpfr,aperm,2,1,0,...,1
+Rmpfr,aperm.mpfrArray,-1,0,0,class<`mpfrMatrix`>,1
+Rmpfr,aperm.mpfrArray,0,0,0,class<`mpfrMatrix`>,1
+Rmpfr,aperm.mpfrArray,1,0,0,integer[],1
+Rmpfr,aperm.mpfrArray,2,0,0,logical,1
+Rmpfr,aperm.mpfrArray,3,0,0,...,1
+Rmpfr,apply,-1,0,0,class<`mpfr`>,1
+Rmpfr,apply,-1,0,1,class<`mpfrMatrix`>,1
+Rmpfr,apply,0,0,0,class<`mpfrMatrix`>,1
+Rmpfr,apply,1,0,0,double,1
+Rmpfr,apply,2,0,0,class<`function`>,1
+Rmpfr,apply,3,0,0,...,1
+Rmpfr,apply,-1,1,0,class<`mpfrArray`>,1
+Rmpfr,apply,-1,1,1,class<`mpfrMatrix`>,1
+Rmpfr,apply,0,1,0,class<`mpfrArray`>,1
+Rmpfr,apply,1,1,0,integer[],1
+Rmpfr,apply,1,1,1,double,1
+Rmpfr,apply,2,1,0,class<`function`>,1
+Rmpfr,apply,2,1,1,class<`standardGeneric`>,1
+Rmpfr,apply,3,1,0,...,1
+Rmpfr,applyMpfr,-1,0,0,class<`mpfr`>,1
+Rmpfr,applyMpfr,-1,0,1,class<`mpfrMatrix`>,1
+Rmpfr,applyMpfr,0,0,0,class<`mpfrArray`>,1
+Rmpfr,applyMpfr,0,0,1,class<`mpfrMatrix`>,1
+Rmpfr,applyMpfr,1,0,0,integer[],1
+Rmpfr,applyMpfr,2,0,0,class<`function`>,1
+Rmpfr,applyMpfr,2,0,1,class<`standardGeneric`>,1
+Rmpfr,applyMpfr,3,0,0,...,1
+Rmpfr,.Arith.mpfr.num,-1,0,0,list<class<`mpfr1`>>,1
+Rmpfr,.Arith.mpfr.num,0,0,0,class<`mpfrMatrix`>,1
+Rmpfr,.Arith.mpfr.num,1,0,0,double[],1
+Rmpfr,.Arith.mpfr.num,2,0,0,character,1
+Rmpfr,.Arith.num.mpfr,-1,0,0,list<class<`mpfr1`>>,1
+Rmpfr,.Arith.num.mpfr,0,0,0,class<`matrix`>,1
+Rmpfr,.Arith.num.mpfr,0,0,1,class<`array`>,1
+Rmpfr,.Arith.num.mpfr,0,0,2,double,1
+Rmpfr,.Arith.num.mpfr,1,0,0,class<`mpfrMatrix`>,1
+Rmpfr,.Arith.num.mpfr,1,0,1,class<`mpfr`>,1
+Rmpfr,.Arith.num.mpfr,2,0,0,character,1
+Rmpfr,as.data.frame.Ncharacter,-1,0,0,class<`data.frame`>,1
+Rmpfr,as.data.frame.Ncharacter,0,0,0,"class<`Ncharacter`, `character`>",1
+Rmpfr,as.data.frame.Ncharacter,1,0,0,...,1
+Rmpfr,as.matrix.mpfr,-1,0,0,class<`mpfrMatrix`>,1
+Rmpfr,as.matrix.mpfr,0,0,0,class<`mpfrMatrix`>,1
+Rmpfr,as.matrix.mpfr,1,0,0,...,1
+Rmpfr,atan2,-1,0,0,class<`mpfr`>,1
+Rmpfr,atan2,0,0,0,class<`mpfr`>,1
+Rmpfr,atan2,1,0,0,integer[],1
+Rmpfr,Bernoulli,-1,0,0,class<`mpfr`>,1
+Rmpfr,Bernoulli,0,0,0,double[],1
+Rmpfr,Bernoulli,1,0,0,double,1
+Rmpfr,.bigq2mpfr,-1,0,0,class<`mpfr`>,1
+Rmpfr,.bigq2mpfr,0,0,0,class<`bigq`>,1
+Rmpfr,.bigq2mpfr,1,0,0,null,1
+Rmpfr,.bigq2mpfr,2,0,0,character[],1
+Rmpfr,..bigq2mpfr,-1,0,0,class<`mpfr`>,1
+Rmpfr,..bigq2mpfr,0,0,0,class<`bigq`>,1
+Rmpfr,..bigq2mpfr,1,0,0,double,1
+Rmpfr,..bigq2mpfr,1,0,1,null,1
+Rmpfr,..bigq2mpfr,2,0,0,character[],1
+Rmpfr,.bigz2mpfr,-1,0,0,class<`mpfr`>,1
+Rmpfr,.bigz2mpfr,0,0,0,class<`bigz`>,1
+Rmpfr,.bigz2mpfr,1,0,0,double,1
+Rmpfr,.bigz2mpfr,1,0,1,null,1
+Rmpfr,.bigz2mpfr,2,0,0,character[],1
+Rmpfr,..bigz2mpfr,-1,0,0,any,1
+Rmpfr,..bigz2mpfr,0,0,0,class<`bigz`>,1
+Rmpfr,..bigz2mpfr,1,0,0,double,1
+Rmpfr,..bigz2mpfr,1,0,1,integer[],1
+Rmpfr,..bigz2mpfr,1,0,2,null,1
+Rmpfr,..bigz2mpfr,2,0,0,character[],1
+Rmpfr,cbind,-1,0,0,class<`mpfrMatrix`>,1
+Rmpfr,cbind,0,0,0,...,1
+Rmpfr,cbind,1,0,0,double,1
+Rmpfr,cbind,-1,1,0,class<`matrix`>,1
+Rmpfr,cbind,0,1,0,...,1
+Rmpfr,cbind,1,1,0,double,1
+Rmpfr,cbind,-1,2,0,class<`matrix`>,1
+Rmpfr,cbind,0,2,0,...,1
+Rmpfr,cbind,1,2,0,double,1
+Rmpfr,cbind,-1,3,0,any,1
+Rmpfr,cbind,0,3,0,...,1
+Rmpfr,cbind,1,3,0,double,1
+Rmpfr,cbind,-1,4,0,class<`matrix`>,1
+Rmpfr,cbind,0,4,0,...,1
+Rmpfr,cbind,1,4,0,double,1
+Rmpfr,cbind,-1,5,0,class<`mpfrMatrix`>,1
+Rmpfr,cbind,0,5,0,...,1
+Rmpfr,cbind,1,5,0,double,1
+Rmpfr,cbind,-1,6,0,class<`matrix`>,1
+Rmpfr,cbind,0,6,0,...,1
+Rmpfr,cbind,1,6,0,double,1
+Rmpfr,cbind,-1,7,0,any,1
+Rmpfr,cbind,0,7,0,...,1
+Rmpfr,cbind,1,7,0,double,1
+Rmpfr,cbind,-1,8,0,class<`matrix`>,1
+Rmpfr,cbind,0,8,0,...,1
+Rmpfr,cbind,1,8,0,double,1
+Rmpfr,cbind,-1,9,0,class<`matrix`>,1
+Rmpfr,cbind,0,9,0,...,1
+Rmpfr,cbind,1,9,0,double,1
+Rmpfr,cbind,-1,10,0,class<`mpfrMatrix`>,1
+Rmpfr,cbind,0,10,0,...,1
+Rmpfr,cbind,1,10,0,double,1
+Rmpfr,chooseMpfr,-1,0,0,class<`mpfr`>,1
+Rmpfr,chooseMpfr,0,0,0,class<`mpfr`>,1
+Rmpfr,chooseMpfr,0,0,1,double,1
+Rmpfr,chooseMpfr,0,0,2,integer[],1
+Rmpfr,chooseMpfr,1,0,0,integer[],1
+Rmpfr,chooseMpfr,1,0,1,double,1
+Rmpfr,chooseMpfr,2,0,0,character[],1
+Rmpfr,chooseMpfr.all,-1,0,0,class<`mpfr`>,1
+Rmpfr,chooseMpfr.all,0,0,0,double,1
+Rmpfr,chooseMpfr.all,1,0,0,null,1
+Rmpfr,chooseMpfr.all,2,0,0,double,1
+Rmpfr,chooseMpfr.all,3,0,0,logical,1
+Rmpfr,c.mpfr,-1,0,0,class<`mpfr`>,1
+Rmpfr,c.mpfr,0,0,0,...,1
+Rmpfr,colMeans,-1,0,0,class<`mpfr`>,1
+Rmpfr,colMeans,0,0,0,class<`mpfrMatrix`>,1
+Rmpfr,colMeans,1,0,0,logical,1
+Rmpfr,colMeans,2,0,0,double,1
+Rmpfr,colMeans,3,0,0,...,1
+Rmpfr,colSums,-1,0,0,class<`mpfr`>,1
+Rmpfr,colSums,0,0,0,class<`mpfrMatrix`>,1
+Rmpfr,colSums,1,0,0,logical,1
+Rmpfr,colSums,2,0,0,double,1
+Rmpfr,colSums,3,0,0,...,1
+Rmpfr,.Compare.mpfr.num,-1,0,0,logical[],1
+Rmpfr,.Compare.mpfr.num,0,0,0,class<`mpfrArray`>,1
+Rmpfr,.Compare.mpfr.num,0,0,1,class<`mpfrMatrix`>,1
+Rmpfr,.Compare.mpfr.num,1,0,0,double,1
+Rmpfr,.Compare.mpfr.num,1,0,1,class<`matrix`>,1
+Rmpfr,.Compare.mpfr.num,2,0,0,character,1
+Rmpfr,.Compare.num.mpfr,-1,0,0,logical[],1
+Rmpfr,.Compare.num.mpfr,0,0,0,class<`matrix`>,1
+Rmpfr,.Compare.num.mpfr,0,0,1,double,1
+Rmpfr,.Compare.num.mpfr,1,0,0,class<`mpfrMatrix`>,1
+Rmpfr,.Compare.num.mpfr,1,0,1,class<`mpfrArray`>,1
+Rmpfr,.Compare.num.mpfr,2,0,0,character,1
+Rmpfr,Const,-1,0,0,any,1
+Rmpfr,Const,0,0,0,character,1
+Rmpfr,Const,1,0,0,double[],1
+Rmpfr,Const,2,0,0,character[],1
+Rmpfr,crossprod,-1,0,0,class<`mpfrMatrix`>,1
+Rmpfr,crossprod,0,0,0,class<`mpfr`>,1
+Rmpfr,crossprod,1,0,0,null,1
+Rmpfr,crossprod,-1,1,0,class<`mpfrMatrix`>,1
+Rmpfr,crossprod,0,1,0,class<`mpfrMatrix`>,1
+Rmpfr,crossprod,1,1,0,null,1
+Rmpfr,crossprod,-1,2,0,class<`mpfrMatrix`>,1
+Rmpfr,crossprod,0,2,0,class<`mpfrMatrix`>,1
+Rmpfr,crossprod,1,2,0,class<`mpfrMatrix`>,1
+Rmpfr,crossprod,-1,3,0,class<`mpfrMatrix`>,1
+Rmpfr,crossprod,0,3,0,integer[],1
+Rmpfr,crossprod,1,3,0,class<`mpfrMatrix`>,1
+Rmpfr,.d2mpfr1,-1,0,0,class<`mpfr1`>,1
+Rmpfr,.d2mpfr1,0,0,0,double,1
+Rmpfr,.d2mpfr1,1,0,0,double,1
+Rmpfr,dbinom,-1,0,0,class<`mpfr`>,1
+Rmpfr,dbinom,-1,0,1,double[],1
+Rmpfr,dbinom,0,0,0,integer[],1
+Rmpfr,dbinom,1,0,0,double,1
+Rmpfr,dbinom,2,0,0,class<`mpfr`>,1
+Rmpfr,dbinom,2,0,1,double,1
+Rmpfr,dbinom,3,0,0,logical,1
+Rmpfr,determinant.mpfrMatrix,-1,0,0,class<`det`>,1
+Rmpfr,determinant.mpfrMatrix,0,0,0,class<`mpfrMatrix`>,1
+Rmpfr,determinant.mpfrMatrix,1,0,0,logical,1
+Rmpfr,determinant.mpfrMatrix,2,0,0,logical,1
+Rmpfr,determinant.mpfrMatrix,3,0,0,any,1
+Rmpfr,determinant.mpfrMatrix,4,0,0,...,1
+Rmpfr,diff.mpfr,-1,0,0,class<`mpfr`>,1
+Rmpfr,diff.mpfr,0,0,0,class<`mpfr`>,1
+Rmpfr,diff.mpfr,1,0,0,integer,1
+Rmpfr,diff.mpfr,2,0,0,integer,1
+Rmpfr,diff.mpfr,3,0,0,...,1
+Rmpfr,.dimCheck,-1,0,0,integer[],1
+Rmpfr,.dimCheck,0,0,0,class<`matrix`>,1
+Rmpfr,.dimCheck,0,0,1,class<`mpfrMatrix`>,1
+Rmpfr,.dimCheck,1,0,0,class<`mpfrMatrix`>,1
+Rmpfr,.dimCheck,1,0,1,class<`matrix`>,1
+Rmpfr,dnorm,-1,0,0,class<`mpfr`>,1
+Rmpfr,dnorm,-1,0,1,double[],1
+Rmpfr,dnorm,0,0,0,class<`mpfr`>,1
+Rmpfr,dnorm,0,0,1,integer[],1
+Rmpfr,dnorm,1,0,0,double,1
+Rmpfr,dnorm,2,0,0,double,1
+Rmpfr,dnorm,3,0,0,logical,1
+Rmpfr,dpois,-1,0,0,class<`mpfr`>,1
+Rmpfr,dpois,-1,0,1,double[],1
+Rmpfr,dpois,0,0,0,class<`mpfr`>,1
+Rmpfr,dpois,0,0,1,double[],1
+Rmpfr,dpois,1,0,0,double,1
+Rmpfr,dpois,1,0,1,class<`mpfr`>,1
+Rmpfr,dpois,2,0,0,logical,1
+Rmpfr,Ei,-1,0,0,class<`mpfr`>,1
+Rmpfr,Ei,0,0,0,double[],1
+Rmpfr,erf,-1,0,0,double[],1
+Rmpfr,erf,0,0,0,double[],1
+Rmpfr,erfc,-1,0,0,double[],1
+Rmpfr,erfc,0,0,0,double[],1
+Rmpfr,factorial,-1,0,0,class<`mpfr`>,1
+Rmpfr,factorial,0,0,0,class<`mpfr`>,1
+Rmpfr,factorialMpfr,-1,0,0,class<`mpfr`>,1
+Rmpfr,factorialMpfr,0,0,0,double,1
+Rmpfr,factorialMpfr,0,0,1,integer[],1
+Rmpfr,factorialMpfr,1,0,0,double,1
+Rmpfr,factorialMpfr,2,0,0,character[],1
+Rmpfr,format,-1,0,0,class<`matrix`>,1
+Rmpfr,format,0,0,0,class<`mpfrMatrix`>,1
+Rmpfr,format,1,0,0,...,1
+Rmpfr,format,-1,1,0,character[],1
+Rmpfr,format,0,1,0,class<`mpfr`>,1
+Rmpfr,format,1,1,0,...,1
+Rmpfr,formatAlign,-1,0,0,character[],1
+Rmpfr,formatAlign,0,0,0,character[],1
+Rmpfr,formatAlign,1,0,0,character,1
+Rmpfr,formatAlign,2,0,0,any,1
+Rmpfr,formatAlign,3,0,0,...,1
+Rmpfr,formatBin,-1,0,0,"class<`Ncharacter`, `character`>",1
+Rmpfr,formatBin,0,0,0,class<`mpfr`>,1
+Rmpfr,formatBin,0,0,1,double[],1
+Rmpfr,formatBin,0,0,2,class<`matrix`>,1
+Rmpfr,formatBin,0,0,3,class<`mpfrMatrix`>,1
+Rmpfr,formatBin,1,0,0,double,1
+Rmpfr,formatBin,2,0,0,logical,1
+Rmpfr,formatBin,3,0,0,character,1
+Rmpfr,formatBin,4,0,0,any,1
+Rmpfr,formatBin,5,0,0,character,1
+Rmpfr,formatBin,6,0,0,logical,1
+Rmpfr,formatDec,-1,0,0,"class<`Ncharacter`, `character`>",1
+Rmpfr,formatDec,0,0,0,class<`mpfr`>,1
+Rmpfr,formatDec,0,0,1,double[],1
+Rmpfr,formatDec,0,0,2,class<`matrix`>,1
+Rmpfr,formatDec,0,0,3,class<`mpfrMatrix`>,1
+Rmpfr,formatDec,1,0,0,double,1
+Rmpfr,formatDec,2,0,0,double,1
+Rmpfr,formatDec,3,0,0,null,1
+Rmpfr,formatDec,4,0,0,logical,1
+Rmpfr,formatDec,5,0,0,character,1
+Rmpfr,formatDec,6,0,0,logical,1
+Rmpfr,formatDec,7,0,0,...,1
+Rmpfr,formatHex,-1,0,0,"class<`Ncharacter`, `character`>",1
+Rmpfr,formatHex,0,0,0,class<`mpfr`>,1
+Rmpfr,formatHex,0,0,1,double[],1
+Rmpfr,formatHex,0,0,2,class<`matrix`>,1
+Rmpfr,formatHex,0,0,3,class<`mpfrMatrix`>,1
+Rmpfr,formatHex,1,0,0,any,1
+Rmpfr,formatHex,2,0,0,character,1
+Rmpfr,formatHex,3,0,0,any,1
+Rmpfr,formatMpfr,-1,0,0,character[],1
+Rmpfr,formatMpfr,-1,0,1,class<`array`>,1
+Rmpfr,formatMpfr,0,0,0,class<`mpfr`>,1
+Rmpfr,formatMpfr,0,0,1,class<`mpfrArray`>,1
+Rmpfr,formatMpfr,1,0,0,double,1
+Rmpfr,formatMpfr,1,0,1,null,1
+Rmpfr,formatMpfr,2,0,0,logical,1
+Rmpfr,formatMpfr,3,0,0,null,1
+Rmpfr,formatMpfr,3,0,1,logical,1
+Rmpfr,formatMpfr,4,0,0,logical,1
+Rmpfr,formatMpfr,5,0,0,double,1
+Rmpfr,formatMpfr,6,0,0,logical,1
+Rmpfr,formatMpfr,7,0,0,double,1
+Rmpfr,formatN.mpfr,-1,0,0,character[],1
+Rmpfr,formatN.mpfr,0,0,0,class<`mpfr`>,1
+Rmpfr,formatN.mpfr,1,0,0,logical,1
+Rmpfr,formatN.mpfr,2,0,0,...,1
+Rmpfr,getD,-1,0,0,list<any>,1
+Rmpfr,getD,-1,0,1,logical[],1
+Rmpfr,getD,0,0,0,class<`mpfr`>,1
+Rmpfr,getD,0,0,1,class<`mpfrMatrix`>,1
+Rmpfr,getD,0,0,2,class<`mpfrArray`>,1
+Rmpfr,getD,0,0,3,list<class<`mpfr1`>>,1
+Rmpfr,getD,0,0,4,class<`matrix`>,1
+Rmpfr,getPrec,-1,0,0,double[],1
+Rmpfr,getPrec,0,0,0,character[],1
+Rmpfr,getPrec,0,0,1,class<`mpfr`>,1
+Rmpfr,getPrec,0,0,2,class<`mpfrMatrix`>,1
+Rmpfr,getPrec,0,0,3,class<`matrix`>,1
+Rmpfr,getPrec,0,0,4,double[],1
+Rmpfr,getPrec,0,0,5,raw[],1
+Rmpfr,getPrec,1,0,0,any,1
+Rmpfr,getPrec,2,0,0,logical,1
+Rmpfr,getPrec,3,0,0,null,1
+Rmpfr,getPrec,4,0,0,integer,1
+Rmpfr,.getPrec,-1,0,0,integer[],1
+Rmpfr,.getPrec,0,0,0,class<`mpfr`>,1
+Rmpfr,.getPrec,0,0,1,class<`mpfrArray`>,1
+Rmpfr,.getPrec,0,0,2,class<`mpfrMatrix`>,1
+Rmpfr,.getPrec,0,0,3,list<class<`mpfr1`>>,1
+Rmpfr,.getSign,-1,0,0,integer[],1
+Rmpfr,.getSign,0,0,0,class<`mpfr`>,1
+Rmpfr,igamma,-1,0,0,class<`mpfr`>,1
+Rmpfr,igamma,0,0,0,class<`mpfr`>,1
+Rmpfr,igamma,1,0,0,double[],1
+Rmpfr,igamma,2,0,0,character[],1
+Rmpfr,integrateR,-1,0,0,"class<`integrate`, `integrateR`>",1
+Rmpfr,integrateR,0,0,0,class<`function`>,1
+Rmpfr,integrateR,1,0,0,class<`mpfr`>,1
+Rmpfr,integrateR,1,0,1,double,1
+Rmpfr,integrateR,2,0,0,double,1
+Rmpfr,integrateR,2,0,1,class<`mpfr`>,1
+Rmpfr,integrateR,3,0,0,...,1
+Rmpfr,integrateR,4,0,0,double,1
+Rmpfr,integrateR,4,0,1,null,1
+Rmpfr,integrateR,5,0,0,double,1
+Rmpfr,integrateR,6,0,0,any,1
+Rmpfr,integrateR,7,0,0,double,1
+Rmpfr,is.whole.mpfr,-1,0,0,logical[],1
+Rmpfr,is.whole.mpfr,0,0,0,class<`mpfr`>,1
+Rmpfr,j1,-1,0,0,class<`mpfr`>,1
+Rmpfr,j1,0,0,0,double[],1
+Rmpfr,jn,-1,0,0,class<`mpfr`>,1
+Rmpfr,jn,0,0,0,double,1
+Rmpfr,jn,1,0,0,double[],1
+Rmpfr,jn,2,0,0,character[],1
+Rmpfr,Li2,-1,0,0,class<`mpfr`>,1
+Rmpfr,Li2,0,0,0,double[],1
+Rmpfr,.mA.subAssign,-1,0,0,class<`mpfrArray`>,1
+Rmpfr,.mA.subAssign,-1,0,1,class<`mpfrMatrix`>,1
+Rmpfr,.mA.subAssign,0,0,0,class<`mpfrArray`>,1
+Rmpfr,.mA.subAssign,0,0,1,class<`mpfrMatrix`>,1
+Rmpfr,.mA.subAssign,1,0,0,any,1
+Rmpfr,.mA.subAssign,2,0,0,any,1
+Rmpfr,.mA.subAssign,3,0,0,...,1
+Rmpfr,.mA.subAssign,4,0,0,class<`mpfr`>,1
+Rmpfr,.mA.subAssign,4,0,1,class<`mpfrMatrix`>,1
+Rmpfr,.mA.subAssign,4,0,2,double,1
+Rmpfr,.mA.subAssign,5,0,0,integer,1
+Rmpfr,.mA.subAssign,6,0,0,logical,1
+Rmpfr,.mat2ind,-1,0,0,double[],1
+Rmpfr,.mat2ind,0,0,0,class<`matrix`>,1
+Rmpfr,.mat2ind,1,0,0,integer[],1
+Rmpfr,.mat2ind,2,0,0,any,1
+Rmpfr,.matmult.R,-1,0,0,class<`mpfrMatrix`>,1
+Rmpfr,.matmult.R,0,0,0,class<`mpfr`>,1
+Rmpfr,.matmult.R,0,0,1,class<`mpfrMatrix`>,1
+Rmpfr,.matmult.R,0,0,2,integer[],1
+Rmpfr,.matmult.R,1,0,0,class<`matrix`>,1
+Rmpfr,.matmult.R,1,0,1,class<`mpfr`>,1
+Rmpfr,.matmult.R,1,0,2,class<`mpfrMatrix`>,1
+Rmpfr,.matmult.R,1,0,3,double[],1
+Rmpfr,.matmult.R,2,0,0,double,1
+Rmpfr,matrix.mpfr,-1,0,0,class<`mpfrMatrix`>,1
+Rmpfr,matrix.mpfr,0,0,0,class<`mpfr`>,1
+Rmpfr,matrix.mpfr,1,0,0,double,1
+Rmpfr,matrix.mpfr,2,0,0,double,1
+Rmpfr,matrix.mpfr,3,0,0,logical,1
+Rmpfr,matrix.mpfr,4,0,0,...,1
+Rmpfr,mean,-1,0,0,class<`mpfr`>,1
+Rmpfr,mean,0,0,0,class<`mpfr`>,1
+Rmpfr,mean,1,0,0,...,1
+Rmpfr,mkDet,-1,0,0,class<`det`>,1
+Rmpfr,mkDet,0,0,0,class<`mpfr`>,1
+Rmpfr,mkDet,1,0,0,logical,1
+Rmpfr,mkDet,2,0,0,class<`mpfr`>,1
+Rmpfr,mkDet,3,0,0,integer,1
+Rmpfr,mpfr,-1,0,0,any,1
+Rmpfr,mpfr,0,0,0,character[],1
+Rmpfr,mpfr,0,0,1,class<`bigq`>,1
+Rmpfr,mpfr,0,0,2,class<`bigz`>,1
+Rmpfr,mpfr,0,0,3,class<`mpfr`>,1
+Rmpfr,mpfr,0,0,4,"class<`Ncharacter`, `character`>",1
+Rmpfr,mpfr,0,0,5,^double[],1
+Rmpfr,mpfr,0,0,6,null,1
+Rmpfr,mpfr,0,0,7,raw[],1
+Rmpfr,mpfr,0,0,8,class<`matrix`>,1
+Rmpfr,mpfr,1,0,0,any,1
+Rmpfr,mpfr,2,0,0,...,1
+Rmpfr,.mpfr,-1,0,0,class<`mpfr`>,1
+Rmpfr,.mpfr,0,0,0,double[],1
+Rmpfr,.mpfr,1,0,0,integer,1
+Rmpfr,mpfr2array,-1,0,0,class<`mpfrArray`>,1
+Rmpfr,mpfr2array,-1,0,1,class<`mpfrMatrix`>,1
+Rmpfr,mpfr2array,0,0,0,class<`mpfr`>,1
+Rmpfr,mpfr2array,0,0,1,class<`mpfrArray`>,1
+Rmpfr,mpfr2array,0,0,2,class<`mpfrMatrix`>,1
+Rmpfr,mpfr2array,1,0,0,double[],1
+Rmpfr,mpfr2array,2,0,0,null,1
+Rmpfr,mpfr2array,2,0,1,list<character[]>,1
+Rmpfr,mpfr2array,3,0,0,logical,1
+Rmpfr,.mpfr2bigz,-1,0,0,class<`bigz`>,1
+Rmpfr,.mpfr2bigz,0,0,0,class<`mpfr`>,1
+Rmpfr,.mpfr2bigz,1,0,0,null,1
+Rmpfr,.mpfr2exp,-1,0,0,double[],1
+Rmpfr,.mpfr2exp,0,0,0,class<`mpfr`>,1
+Rmpfr,.mpfr2list,-1,0,0,list<list<^integer[]>>,1
+Rmpfr,.mpfr2list,0,0,0,class<`mpfr`>,1
+Rmpfr,.mpfr2list,1,0,0,logical,1
+Rmpfr,.mpfr2str,-1,0,0,list<character[] | double[]>,1
+Rmpfr,.mpfr2str,-1,0,1,list<character[] | integer[]>,1
+Rmpfr,.mpfr2str,-1,0,2,list<character | integer>,1
+Rmpfr,.mpfr2str,0,0,0,class<`mpfr`>,1
+Rmpfr,.mpfr2str,0,0,1,class<`mpfrArray`>,1
+Rmpfr,.mpfr2str,0,0,2,class<`mpfrMatrix`>,1
+Rmpfr,.mpfr2str,1,0,0,null,1
+Rmpfr,.mpfr2str,1,0,1,double,1
+Rmpfr,.mpfr2str,2,0,0,logical,1
+Rmpfr,.mpfr2str,3,0,0,double,1
+Rmpfr,mpfrArray,-1,0,0,class<`mpfrArray`>,1
+Rmpfr,mpfrArray,-1,0,1,class<`mpfrMatrix`>,1
+Rmpfr,mpfrArray,0,0,0,integer[],1
+Rmpfr,mpfrArray,0,0,1,null,1
+Rmpfr,mpfrArray,1,0,0,double,1
+Rmpfr,mpfrArray,2,0,0,double[],1
+Rmpfr,mpfrArray,3,0,0,null,1
+Rmpfr,mpfrArray,3,0,1,list<null | character[]>,1
+Rmpfr,mpfrArray,4,0,0,character[],1
+Rmpfr,mpfr.Bcharacter,-1,0,0,class<`mpfr`>,1
+Rmpfr,mpfr.Bcharacter,-1,0,1,class<`mpfrMatrix`>,1
+Rmpfr,mpfr.Bcharacter,0,0,0,character[],1
+Rmpfr,mpfr.Bcharacter,0,0,1,class<`matrix`>,1
+Rmpfr,mpfr.Bcharacter,1,0,0,double,1
+Rmpfr,mpfr.Bcharacter,2,0,0,logical,1
+Rmpfr,mpfr.Bcharacter,2,0,1,null,1
+Rmpfr,mpfr.Bcharacter,3,0,0,...,1
+Rmpfr,mpfr.bigq,-1,0,0,class<`mpfr`>,1
+Rmpfr,mpfr.bigq,0,0,0,class<`bigq`>,1
+Rmpfr,mpfr.bigq,1,0,0,double,1
+Rmpfr,mpfr.bigq,2,0,0,...,1
+Rmpfr,mpfr.bigz,-1,0,0,any,1
+Rmpfr,mpfr.bigz,0,0,0,class<`bigz`>,1
+Rmpfr,mpfr.bigz,1,0,0,any,1
+Rmpfr,mpfr.bigz,2,0,0,...,1
+Rmpfr,mpfr.default,-1,0,0,any,1
+Rmpfr,mpfr.default,0,0,0,character[],1
+Rmpfr,mpfr.default,0,0,1,^double[],1
+Rmpfr,mpfr.default,0,0,2,null,1
+Rmpfr,mpfr.default,0,0,3,raw[],1
+Rmpfr,mpfr.default,0,0,4,class<`matrix`>,1
+Rmpfr,mpfr.default,1,0,0,any,1
+Rmpfr,mpfr.default,2,0,0,double,1
+Rmpfr,mpfr.default,3,0,0,character[],1
+Rmpfr,mpfr.default,4,0,0,null,1
+Rmpfr,mpfr.default,5,0,0,...,1
+Rmpfr,mpfr_default_prec,-1,0,0,integer,1
+Rmpfr,mpfr_default_prec,0,0,0,any,1
+Rmpfr,.mpfr_erange,-1,0,0,double[],1
+Rmpfr,.mpfr_erange,0,0,0,character[],1
+Rmpfr,.mpfr_erange,1,0,0,logical,1
+Rmpfr,.mpfr_erange_is_int,-1,0,0,logical,1
+Rmpfr,.mpfr_erange_set,-1,0,0,integer,1
+Rmpfr,.mpfr_erange_set,0,0,0,character,1
+Rmpfr,.mpfr_erange_set,1,0,0,double,1
+Rmpfr,.mpfr_formatinfo,-1,0,0,list<integer[]>,1
+Rmpfr,.mpfr_formatinfo,0,0,0,class<`mpfr`>,1
+Rmpfr,.mpfr_gmp_numbbits,-1,0,0,integer,1
+Rmpfr,mpfrImport,-1,0,0,class<`mpfr`>,1
+Rmpfr,mpfrImport,0,0,0,class<`mpfrXport`>,1
+Rmpfr,mpfr.is.0,-1,0,0,logical[],1
+Rmpfr,mpfr.is.0,0,0,0,class<`mpfr`>,1
+Rmpfr,mpfrIs0,-1,0,0,class<`array`>,1
+Rmpfr,mpfrIs0,-1,0,1,class<`matrix`>,1
+Rmpfr,mpfrIs0,-1,0,2,logical[],1
+Rmpfr,mpfrIs0,0,0,0,class<`mpfrArray`>,1
+Rmpfr,mpfrIs0,0,0,1,class<`mpfrMatrix`>,1
+Rmpfr,mpfrIs0,0,0,2,class<`mpfr`>,1
+Rmpfr,mpfr.is.integer,-1,0,0,logical[],1
+Rmpfr,mpfr.is.integer,0,0,0,class<`mpfr`>,1
+Rmpfr,.mpfr.is.whole,-1,0,0,logical[],1
+Rmpfr,.mpfr.is.whole,0,0,0,class<`mpfr`>,1
+Rmpfr,.mpfr_maxPrec,-1,0,0,double,1
+Rmpfr,.mpfr_minPrec,-1,0,0,double,1
+Rmpfr,mpfr.mpfr,-1,0,0,class<`mpfr`>,1
+Rmpfr,mpfr.mpfr,0,0,0,class<`mpfr`>,1
+Rmpfr,mpfr.mpfr,1,0,0,double,1
+Rmpfr,mpfr.mpfr,1,0,1,integer[],1
+Rmpfr,mpfr.mpfr,2,0,0,character[],1
+Rmpfr,mpfr.mpfr,3,0,0,...,1
+Rmpfr,.mpfr.mrepl,-1,0,0,class<`mpfrArray`>,1
+Rmpfr,.mpfr.mrepl,-1,0,1,class<`mpfrMatrix`>,1
+Rmpfr,.mpfr.mrepl,0,0,0,class<`mpfrArray`>,1
+Rmpfr,.mpfr.mrepl,0,0,1,class<`mpfrMatrix`>,1
+Rmpfr,.mpfr.mrepl,1,0,0,class<`matrix`>,1
+Rmpfr,.mpfr.mrepl,2,0,0,...,1
+Rmpfr,.mpfr.mrepl,3,0,0,class<`mpfr`>,1
+Rmpfr,.mpfr.mrepl,4,0,0,logical,1
+Rmpfr,mpfr.Ncharacter,-1,0,0,class<`mpfr`>,1
+Rmpfr,mpfr.Ncharacter,-1,0,1,class<`mpfrMatrix`>,1
+Rmpfr,mpfr.Ncharacter,0,0,0,"class<`Ncharacter`, `character`>",1
+Rmpfr,mpfr.Ncharacter,1,0,0,double,1
+Rmpfr,mpfr.Ncharacter,2,0,0,...,1
+Rmpfr,.mpfr_negative,-1,0,0,class<`mpfr`>,1
+Rmpfr,.mpfr_negative,-1,0,1,class<`mpfrMatrix`>,1
+Rmpfr,.mpfr_negative,0,0,0,class<`mpfr`>,1
+Rmpfr,.mpfr_negative,0,0,1,class<`mpfrMatrix`>,1
+Rmpfr,mpfr.NULL,-1,0,0,class<`mpfr`>,1
+Rmpfr,mpfr.NULL,0,0,0,null,1
+Rmpfr,mpfr.NULL,1,0,0,...,1
+Rmpfr,.mpfr.repl,-1,0,0,class<`mpfr`>,1
+Rmpfr,.mpfr.repl,0,0,0,class<`mpfr`>,1
+Rmpfr,.mpfr.repl,1,0,0,any,1
+Rmpfr,.mpfr.repl,2,0,0,...,1
+Rmpfr,.mpfr.repl,3,0,0,class<`mpfr`>,1
+Rmpfr,.mpfr.repl,4,0,0,logical,1
+Rmpfr,.mpfr_sign,-1,0,0,double[],1
+Rmpfr,.mpfr_sign,0,0,0,class<`mpfrArray`>,1
+Rmpfr,.mpfr_sign,0,0,1,class<`mpfrMatrix`>,1
+Rmpfr,mpfrVersion,-1,0,0,class<`numeric_version`>,1
+Rmpfr,.mpfrVersion,-1,0,0,character,1
+Rmpfr,mpfrXport,-1,0,0,class<`mpfrXport`>,1
+Rmpfr,mpfrXport,0,0,0,class<`mpfr`>,1
+Rmpfr,mpfrXport,1,0,0,logical,1
+Rmpfr,[.Ncharacter,-1,0,0,"class<`Ncharacter`, `character`>",1
+Rmpfr,[.Ncharacter,0,0,0,"class<`Ncharacter`, `character`>",1
+Rmpfr,[.Ncharacter,1,0,0,...,1
+Rmpfr,.ncharPrec,-1,0,0,integer[],1
+Rmpfr,.ncharPrec,0,0,0,character[],1
+Rmpfr,.ncharPrec,1,0,0,double,1
+Rmpfr,norm,-1,0,0,class<`mpfr`>,1
+Rmpfr,norm,0,0,0,class<`mpfrMatrix`>,1
+Rmpfr,norm,1,0,0,character,1
+Rmpfr,norm,2,0,0,...,1
+Rmpfr,norm,-1,1,0,class<`mpfr`>,1
+Rmpfr,norm,0,1,0,class<`mpfrMatrix`>,1
+Rmpfr,norm,1,1,0,any,1
+Rmpfr,norm,2,1,0,...,1
+Rmpfr,outer,-1,0,0,class<`matrix`>,1
+Rmpfr,outer,-1,0,1,class<`mpfrMatrix`>,1
+Rmpfr,outer,0,0,0,double[],1
+Rmpfr,outer,0,0,1,class<`mpfr`>,1
+Rmpfr,outer,1,0,0,double[],1
+Rmpfr,outer,2,0,0,character,1
+Rmpfr,outer,3,0,0,...,1
+Rmpfr,pbetaI,-1,0,0,class<`mpfr`>,1
+Rmpfr,pbetaI,0,0,0,double[],1
+Rmpfr,pbetaI,1,0,0,double,1
+Rmpfr,pbetaI,2,0,0,double,1
+Rmpfr,pbetaI,3,0,0,double,1
+Rmpfr,pbetaI,4,0,0,logical,1
+Rmpfr,pbetaI,5,0,0,logical,1
+Rmpfr,pbetaI,6,0,0,double,1
+Rmpfr,pbetaI,6,0,1,null,1
+Rmpfr,pbetaI,7,0,0,character[],1
+Rmpfr,pmax,-1,0,0,class<`matrix`>,1
+Rmpfr,pmax,-1,0,1,class<`mpfr`>,1
+Rmpfr,pmax,-1,0,2,double[],1
+Rmpfr,pmax,0,0,0,...,1
+Rmpfr,pmax,1,0,0,logical,1
+Rmpfr,pmax,-1,1,0,double[],1
+Rmpfr,pmax,0,1,0,...,1
+Rmpfr,pmax,1,1,0,logical,1
+Rmpfr,pmax,-1,2,0,class<`mpfr`>,1
+Rmpfr,pmax,0,2,0,...,1
+Rmpfr,pmax,1,2,0,logical,1
+Rmpfr,pmax,-1,3,0,integer[],1
+Rmpfr,pmax,0,3,0,...,1
+Rmpfr,pmax,1,3,0,logical,1
+Rmpfr,pmin,-1,0,0,double[],1
+Rmpfr,pmin,0,0,0,...,1
+Rmpfr,pmin,1,0,0,logical,1
+Rmpfr,pmin,-1,1,0,class<`matrix`>,1
+Rmpfr,pmin,-1,1,1,class<`mpfr`>,1
+Rmpfr,pmin,-1,1,2,double[],1
+Rmpfr,pmin,0,1,0,...,1
+Rmpfr,pmin,1,1,0,logical,1
+Rmpfr,pmin,-1,2,0,class<`mpfr`>,1
+Rmpfr,pmin,0,2,0,...,1
+Rmpfr,pmin,1,2,0,logical,1
+Rmpfr,pmin,-1,3,0,double,1
+Rmpfr,pmin,0,3,0,...,1
+Rmpfr,pmin,1,3,0,logical,1
+Rmpfr,pmin,-1,4,0,class<`mpfr`>,1
+Rmpfr,pmin,0,4,0,...,1
+Rmpfr,pmin,1,4,0,logical,1
+Rmpfr,pnorm,-1,0,0,double[],1
+Rmpfr,pnorm,0,0,0,double[],1
+Rmpfr,pnorm,1,0,0,double,1
+Rmpfr,pnorm,2,0,0,double,1
+Rmpfr,pnorm,3,0,0,logical,1
+Rmpfr,pnorm,4,0,0,logical,1
+Rmpfr,pochMpfr,-1,0,0,class<`mpfr`>,1
+Rmpfr,pochMpfr,0,0,0,class<`mpfr`>,1
+Rmpfr,pochMpfr,0,0,1,double,1
+Rmpfr,pochMpfr,0,0,2,integer[],1
+Rmpfr,pochMpfr,1,0,0,double,1
+Rmpfr,pochMpfr,2,0,0,character[],1
+Rmpfr,print.mpfr,-1,0,0,class<`mpfr`>,1
+Rmpfr,print.mpfr,0,0,0,class<`mpfr`>,1
+Rmpfr,print.mpfr,1,0,0,null,1
+Rmpfr,print.mpfr,2,0,0,logical,1
+Rmpfr,print.mpfr,3,0,0,logical,1
+Rmpfr,print.mpfr,4,0,0,any,1
+Rmpfr,print.mpfr,5,0,0,any,1
+Rmpfr,print.mpfr,6,0,0,...,1
+Rmpfr,print.mpfrArray,-1,0,0,class<`mpfrArray`>,1
+Rmpfr,print.mpfrArray,0,0,0,class<`mpfrArray`>,1
+Rmpfr,print.mpfrArray,1,0,0,null,1
+Rmpfr,print.mpfrArray,2,0,0,logical,1
+Rmpfr,print.mpfrArray,3,0,0,logical,1
+Rmpfr,print.mpfrArray,4,0,0,integer,1
+Rmpfr,print.mpfrArray,5,0,0,any,1
+Rmpfr,print.mpfrArray,6,0,0,...,1
+Rmpfr,print.Ncharacter,-1,0,0,"class<`Ncharacter`, `character`>",1
+Rmpfr,print.Ncharacter,0,0,0,"class<`Ncharacter`, `character`>",1
+Rmpfr,print.Ncharacter,1,0,0,...,1
+Rmpfr,rbind,-1,0,0,class<`mpfrMatrix`>,1
+Rmpfr,rbind,0,0,0,...,1
+Rmpfr,rbind,1,0,0,double,1
+Rmpfr,rbind,-1,1,0,class<`matrix`>,1
+Rmpfr,rbind,0,1,0,...,1
+Rmpfr,rbind,1,1,0,double,1
+Rmpfr,rbind,-1,2,0,class<`matrix`>,1
+Rmpfr,rbind,0,2,0,...,1
+Rmpfr,rbind,1,2,0,double,1
+Rmpfr,rbind,-1,3,0,class<`mpfrMatrix`>,1
+Rmpfr,rbind,0,3,0,...,1
+Rmpfr,rbind,1,3,0,double,1
+Rmpfr,rbind,-1,4,0,class<`matrix`>,1
+Rmpfr,rbind,-1,4,1,class<`mpfrMatrix`>,1
+Rmpfr,rbind,0,4,0,...,1
+Rmpfr,rbind,1,4,0,double,1
+Rmpfr,rep.mpfr,-1,0,0,class<`mpfr`>,1
+Rmpfr,rep.mpfr,0,0,0,class<`mpfr`>,1
+Rmpfr,rep.mpfr,1,0,0,double,1
+Rmpfr,rep.mpfr,2,0,0,null,1
+Rmpfr,rep.mpfr,3,0,0,double,1
+Rmpfr,rep.mpfr,4,0,0,...,1
+Rmpfr,roundMpfr,-1,0,0,class<`mpfr`>,1
+Rmpfr,roundMpfr,0,0,0,class<`mpfr`>,1
+Rmpfr,roundMpfr,1,0,0,double,1
+Rmpfr,roundMpfr,1,0,1,integer[],1
+Rmpfr,roundMpfr,2,0,0,character[],1
+Rmpfr,rowSums,-1,0,0,class<`mpfr`>,1
+Rmpfr,rowSums,0,0,0,class<`mpfrMatrix`>,1
+Rmpfr,rowSums,1,0,0,logical,1
+Rmpfr,rowSums,2,0,0,double,1
+Rmpfr,rowSums,3,0,0,...,1
+Rmpfr,sapplyMpfr,-1,0,0,class<`mpfr`>,1
+Rmpfr,sapplyMpfr,0,0,0,integer[],1
+Rmpfr,sapplyMpfr,1,0,0,class<`function`>,1
+Rmpfr,sapplyMpfr,2,0,0,...,1
+Rmpfr,scale.mpfrMatrix,-1,0,0,class<`mpfrMatrix`>,1
+Rmpfr,scale.mpfrMatrix,0,0,0,class<`mpfrMatrix`>,1
+Rmpfr,scale.mpfrMatrix,1,0,0,logical,1
+Rmpfr,scale.mpfrMatrix,2,0,0,logical,1
+Rmpfr,seqMpfr,-1,0,0,class<`mpfr`>,1
+Rmpfr,seqMpfr,0,0,0,class<`mpfr`>,1
+Rmpfr,seqMpfr,0,0,1,double,1
+Rmpfr,seqMpfr,1,0,0,class<`mpfr`>,1
+Rmpfr,seqMpfr,1,0,1,double,1
+Rmpfr,seqMpfr,2,0,0,any,1
+Rmpfr,seqMpfr,3,0,0,double,1
+Rmpfr,seqMpfr,3,0,1,null,1
+Rmpfr,seqMpfr,3,0,2,class<`mpfr`>,1
+Rmpfr,seqMpfr,4,0,0,null,1
+Rmpfr,seqMpfr,5,0,0,...,1
+Rmpfr,sprintfMpfr,-1,0,0,character[],1
+Rmpfr,sprintfMpfr,0,0,0,class<`mpfr`>,1
+Rmpfr,sprintfMpfr,0,0,1,class<`mpfrMatrix`>,1
+Rmpfr,sprintfMpfr,1,0,0,double,1
+Rmpfr,sprintfMpfr,2,0,0,character,1
+Rmpfr,sprintfMpfr,3,0,0,any,1
+Rmpfr,sprintfMpfr,4,0,0,logical,1
+Rmpfr,str.mpfr,-1,0,0,null,1
+Rmpfr,str.mpfr,0,0,0,class<`mpfr`>,1
+Rmpfr,str.mpfr,1,0,0,any,1
+Rmpfr,str.mpfr,2,0,0,logical,1
+Rmpfr,str.mpfr,3,0,0,logical,1
+Rmpfr,str.mpfr,4,0,0,double,1
+Rmpfr,str.mpfr,4,0,1,null,1
+Rmpfr,str.mpfr,5,0,0,integer,1
+Rmpfr,str.mpfr,5,0,1,null,1
+Rmpfr,str.mpfr,6,0,0,logical,1
+Rmpfr,str.mpfr,7,0,0,any,1
+Rmpfr,sumBinomMpfr,-1,0,0,class<`mpfr`>,1
+Rmpfr,sumBinomMpfr,0,0,0,double,1
+Rmpfr,sumBinomMpfr,1,0,0,class<`function`>,1
+Rmpfr,sumBinomMpfr,2,0,0,double,1
+Rmpfr,sumBinomMpfr,3,0,0,logical,1
+Rmpfr,sumBinomMpfr,4,0,0,double,1
+Rmpfr,sumBinomMpfr,5,0,0,class<`mpfr`>,1
+Rmpfr,summary,-1,0,0,class<`summaryMpfr`>,1
+Rmpfr,summary,0,0,0,class<`mpfr`>,1
+Rmpfr,summary,1,0,0,...,1
+Rmpfr,t,-1,0,0,class<`mpfrMatrix`>,1
+Rmpfr,t,0,0,0,class<`mpfrMatrix`>,1
+Rmpfr,t,-1,1,0,class<`mpfrMatrix`>,1
+Rmpfr,t,0,1,0,class<`mpfr`>,1
+Rmpfr,tcrossprod,-1,0,0,class<`mpfrMatrix`>,1
+Rmpfr,tcrossprod,0,0,0,integer[],1
+Rmpfr,tcrossprod,1,0,0,class<`mpfrMatrix`>,1
+Rmpfr,tcrossprod,-1,1,0,class<`mpfrMatrix`>,1
+Rmpfr,tcrossprod,0,1,0,integer[],1
+Rmpfr,tcrossprod,1,1,0,class<`mpfr`>,1
+Rmpfr,tcrossprod,-1,2,0,class<`mpfrMatrix`>,1
+Rmpfr,tcrossprod,0,2,0,class<`mpfr`>,1
+Rmpfr,tcrossprod,1,2,0,null,1
+Rmpfr,tcrossprod,-1,3,0,class<`mpfrMatrix`>,1
+Rmpfr,tcrossprod,0,3,0,class<`mpfrMatrix`>,1
+Rmpfr,tcrossprod,1,3,0,class<`mpfrMatrix`>,1
+Rmpfr,toNum,-1,0,0,class<`array`>,1
+Rmpfr,toNum,-1,0,1,class<`matrix`>,1
+Rmpfr,toNum,-1,0,2,double,1
+Rmpfr,toNum,0,0,0,class<`mpfrArray`>,1
+Rmpfr,toNum,0,0,1,class<`mpfrMatrix`>,1
+Rmpfr,toNum,0,0,2,class<`mpfr`>,1
+Rmpfr,toNum,1,0,0,character,1
+Rmpfr,.toNum,-1,0,0,class<`array`>,1
+Rmpfr,.toNum,-1,0,1,class<`matrix`>,1
+Rmpfr,.toNum,-1,0,2,double,1
+Rmpfr,.toNum,0,0,0,class<`mpfrArray`>,1
+Rmpfr,.toNum,0,0,1,class<`mpfrMatrix`>,1
+Rmpfr,.toNum,0,0,2,class<`mpfr`>,1
+Rmpfr,.toNum,1,0,0,character,1
+Rmpfr,unique,-1,0,0,class<`mpfr`>,1
+Rmpfr,unique,0,0,0,class<`mpfr`>,1
+Rmpfr,unique,1,0,0,logical,1
+Rmpfr,unique,2,0,0,...,1
+Rmpfr,unique.mpfr,-1,0,0,class<`mpfr`>,1
+Rmpfr,unique.mpfr,0,0,0,class<`mpfr`>,1
+Rmpfr,unique.mpfr,1,0,0,logical,1
+Rmpfr,unique.mpfr,2,0,0,...,1
+Rmpfr,unlistMpfr,-1,0,0,class<`mpfr`>,1
+Rmpfr,unlistMpfr,0,0,0,list<class<`mpfr`>>,1
+Rmpfr,unlistMpfr,1,0,0,logical,1
+Rmpfr,unlistMpfr,2,0,0,logical,1
+Rmpfr,y0,-1,0,0,class<`mpfr`>,1
+Rmpfr,y0,0,0,0,double[],1
+Rmpfr,yn,-1,0,0,class<`mpfr`>,1
+Rmpfr,yn,0,0,0,double,1
+Rmpfr,yn,1,0,0,double[],1
+Rmpfr,yn,2,0,0,character[],1
+Rmpfr,zeta,-1,0,0,class<`mpfr`>,1
+Rmpfr,zeta,0,0,0,class<`mpfr`>,1
+Rmpfr,zeta,0,0,1,double[],1
+Rtsne,.check_tsne_params,-1,0,0,list<double | class<`matrix`>>,1
+Rtsne,.check_tsne_params,0,0,0,integer,1
+Rtsne,.check_tsne_params,1,0,0,double,1
+Rtsne,.check_tsne_params,2,0,0,double,1
+Rtsne,.check_tsne_params,3,0,0,double,1
+Rtsne,.check_tsne_params,4,0,0,double,1
+Rtsne,.check_tsne_params,5,0,0,logical,1
+Rtsne,.check_tsne_params,6,0,0,class<`matrix`>,1
+Rtsne,.check_tsne_params,6,0,1,null,1
+Rtsne,.check_tsne_params,7,0,0,integer,1
+Rtsne,.check_tsne_params,8,0,0,integer,1
+Rtsne,.check_tsne_params,9,0,0,double,1
+Rtsne,.check_tsne_params,10,0,0,double,1
+Rtsne,.check_tsne_params,11,0,0,double,1
+Rtsne,.check_tsne_params,12,0,0,double,1
+Rtsne,.clear_unwanted_params,-1,0,0,list<double>,1
+Rtsne,.clear_unwanted_params,0,0,0,list<double | class<`matrix`>>,1
+Rtsne,is.wholenumber,-1,0,0,logical,1
+Rtsne,is.wholenumber,0,0,0,double,1
+Rtsne,is.wholenumber,1,0,0,double,1
+Rtsne,normalize_input,-1,0,0,class<`matrix`>,1
+Rtsne,normalize_input,0,0,0,class<`matrix`>,1
+Rtsne,normalize_input_cpp,-1,0,0,class<`matrix`>,1
+Rtsne,normalize_input_cpp,0,0,0,class<`matrix`>,1
+Rtsne,Rtsne,-1,0,0,list<class<`matrix`> | double[]>,1
+Rtsne,Rtsne,0,0,0,class<`data.frame`>,1
+Rtsne,Rtsne,0,0,1,class<`matrix`>,1
+Rtsne,Rtsne,0,0,2,class<`dist`>,1
+Rtsne,Rtsne,1,0,0,...,1
+Rtsne,Rtsne.data.frame,-1,0,0,list<class<`matrix`> | double[]>,1
+Rtsne,Rtsne.data.frame,0,0,0,class<`data.frame`>,1
+Rtsne,Rtsne.data.frame,1,0,0,...,1
+Rtsne,Rtsne.default,-1,0,0,list<class<`matrix`> | double[]>,1
+Rtsne,Rtsne.default,0,0,0,class<`matrix`>,1
+Rtsne,Rtsne.default,1,0,0,double,1
+Rtsne,Rtsne.default,2,0,0,double,1
+Rtsne,Rtsne.default,3,0,0,double,1
+Rtsne,Rtsne.default,4,0,0,double,1
+Rtsne,Rtsne.default,5,0,0,logical,1
+Rtsne,Rtsne.default,6,0,0,logical,1
+Rtsne,Rtsne.default,7,0,0,logical,1
+Rtsne,Rtsne.default,8,0,0,double,1
+Rtsne,Rtsne.default,9,0,0,logical,1
+Rtsne,Rtsne.default,10,0,0,logical,1
+Rtsne,Rtsne.default,11,0,0,null,1
+Rtsne,Rtsne.default,11,0,1,class<`matrix`>,1
+Rtsne,Rtsne.default,12,0,0,logical,1
+Rtsne,Rtsne.default,13,0,0,logical,1
+Rtsne,Rtsne.default,14,0,0,logical,1
+Rtsne,Rtsne.default,15,0,0,integer,1
+Rtsne,Rtsne.dist,-1,0,0,list<class<`matrix`> | double[]>,1
+Rtsne,Rtsne.dist,0,0,0,class<`dist`>,1
+Rtsne,Rtsne.dist,1,0,0,...,1
+Rtsne,Rtsne.dist,2,0,0,logical,1
+SKAT,Beta_Weights,-1,0,0,double[],1
+SKAT,Beta_Weights,0,0,0,double[],1
+SKAT,Beta_Weights,1,0,0,double[],1
+SKAT,Beta.Weights,-1,0,0,double[],1
+SKAT,Beta.Weights,0,0,0,double[],1
+SKAT,Beta.Weights,1,0,0,double[],1
+SKAT,Check_File_Exists,-1,0,0,any,1
+SKAT,Check_File_Exists,0,0,0,character,1
+SKAT,Check_Sex_Var,-1,0,0,double[],1
+SKAT,Check_Sex_Var,0,0,0,class<`formula`>,1
+SKAT,Check_Sex_Var,1,0,0,character,1
+SKAT,Check_Sex_Var,2,0,0,null,1
+SKAT,Dist_Case,-1,0,0,double[],1
+SKAT,Dist_Case,0,0,0,double[],1
+SKAT,Dist_Case,1,0,0,double,1
+SKAT,Dist_Case_Control,-1,0,0,double[],1
+SKAT,Dist_Case_Control,0,0,0,double[],1
+SKAT,Dist_Case_Control,1,0,0,double,1
+SKAT,Dist_Case_Control,2,0,0,double,1
+SKAT,Dist_Control,-1,0,0,double[],1
+SKAT,Dist_Control,0,0,0,double[],1
+SKAT,Dist_Control,1,0,0,double,1
+SKAT,emma.delta.REML.LL.wo.Z,-1,0,0,double,1
+SKAT,emma.delta.REML.LL.wo.Z,0,0,0,double,1
+SKAT,emma.delta.REML.LL.wo.Z,1,0,0,double[],1
+SKAT,emma.delta.REML.LL.wo.Z,2,0,0,class<`matrix`>,1
+SKAT,emma.eigen.R.wo.Z,-1,0,0,list<double[] | class<`matrix`>>,1
+SKAT,emma.eigen.R.wo.Z,0,0,0,class<`matrix`>,1
+SKAT,emma.eigen.R.wo.Z,1,0,0,class<`matrix`>,1
+SKAT,fast.invFisher,-1,0,0,class<`matrix`>,1
+SKAT,fast.invFisher,0,0,0,class<`matrix`>,1
+SKAT,fast.logDet,-1,0,0,double,1
+SKAT,fast.logDet,0,0,0,class<`matrix`>,1
+SKAT,fast.logistf.control,-1,0,0,list<double>,1
+SKAT,fast.logistf.control,0,0,0,double,1
+SKAT,fast.logistf.control,1,0,0,double,1
+SKAT,fast.logistf.control,2,0,0,double,1
+SKAT,fast.logistf.control,3,0,0,double,1
+SKAT,fast.logistf.control,4,0,0,double,1
+SKAT,fast.logistf.control,5,0,0,double,1
+SKAT,fast.logistf.fit,-1,0,0,list<double[] | class<`matrix`>>,1
+SKAT,fast.logistf.fit,0,0,0,class<`matrix`>,1
+SKAT,fast.logistf.fit,1,0,0,double[],1
+SKAT,fast.logistf.fit,2,0,0,null,1
+SKAT,fast.logistf.fit,3,0,0,null,1
+SKAT,fast.logistf.fit,4,0,0,logical,1
+SKAT,fast.logistf.fit,5,0,0,integer[],1
+SKAT,fast.logistf.fit,5,0,1,null,1
+SKAT,fast.logistf.fit,6,0,0,null,1
+SKAT,fast.logistf.fit,7,0,0,any,1
+SKAT,Generate_SSD_SetID,-1,0,0,any,1
+SKAT,Generate_SSD_SetID,0,0,0,character,1
+SKAT,Generate_SSD_SetID,1,0,0,character,1
+SKAT,Generate_SSD_SetID,2,0,0,character,1
+SKAT,Generate_SSD_SetID,3,0,0,character,1
+SKAT,Generate_SSD_SetID,4,0,0,character,1
+SKAT,Generate_SSD_SetID,5,0,0,character,1
+SKAT,Generate_SSD_SetID,6,0,0,logical,1
+SKAT,Generate_SSD_SetID_Work,-1,0,0,any,1
+SKAT,Generate_SSD_SetID_Work,0,0,0,character,1
+SKAT,Generate_SSD_SetID_Work,1,0,0,character,1
+SKAT,Generate_SSD_SetID_Work,2,0,0,character,1
+SKAT,Generate_SSD_SetID_Work,3,0,0,character,1
+SKAT,Generate_SSD_SetID_Work,4,0,0,character,1
+SKAT,Generate_SSD_SetID_Work,5,0,0,character,1
+SKAT,Generate_SSD_SetID_Work,6,0,0,any,1
+SKAT,Get_A,-1,0,0,class<`matrix`>,1
+SKAT,Get_A,0,0,0,class<`matrix`>,1
+SKAT,Get_A,1,0,0,double[],1
+SKAT,Get_A,2,0,0,double[],1
+SKAT,Get_A,3,0,0,double,1
+SKAT,Get_A_Q,-1,0,0,class<`matrix`>,1
+SKAT,Get_A_Q,0,0,0,class<`matrix`>,1
+SKAT,Get_B,-1,0,0,class<`matrix`>,1
+SKAT,Get_B,0,0,0,class<`matrix`>,1
+SKAT,Get_B,1,0,0,double[],1
+SKAT,Get_B,2,0,0,double[],1
+SKAT,Get_B,3,0,0,double,1
+SKAT,Get_Beta,-1,0,0,double[],1
+SKAT,Get_Beta,0,0,0,character,1
+SKAT,Get_Beta,1,0,0,double[],1
+SKAT,Get_Beta,2,0,0,double,1
+SKAT,Get_Beta,3,0,0,double,1
+SKAT,Get_B_Q,-1,0,0,class<`matrix`>,1
+SKAT,Get_B_Q,0,0,0,class<`matrix`>,1
+SKAT,Get_B_Q,1,0,0,double[],1
+SKAT,Get_CausalSNPs,-1,0,0,integer[],1
+SKAT,Get_CausalSNPs,0,0,0,double[],1
+SKAT,Get_CausalSNPs,1,0,0,double,1
+SKAT,Get_CausalSNPs,2,0,0,double,1
+SKAT,Get_Critical_Value,-1,0,0,list<double[] | list<double>>,1
+SKAT,Get_Critical_Value,0,0,0,double[],1
+SKAT,Get_Critical_Value,1,0,0,double,1
+SKAT,Get_Davies_PVal,-1,0,0,list<double[] | null | list<double[]>>,1
+SKAT,Get_Davies_PVal,-1,0,1,list<double | null | list<double>>,1
+SKAT,Get_Davies_PVal,0,0,0,class<`matrix`>,1
+SKAT,Get_Davies_PVal,1,0,0,class<`matrix`>,1
+SKAT,Get_Davies_PVal,2,0,0,double[],1
+SKAT,Get_Davies_PVal,2,0,1,null,1
+SKAT,Get_Lambda,-1,0,0,double[],1
+SKAT,Get_Lambda,0,0,0,class<`matrix`>,1
+SKAT,Get_Lambda_U_From_Z,-1,0,0,list<double[] | class<`matrix`>>,1
+SKAT,Get_Lambda_U_From_Z,0,0,0,class<`matrix`>,1
+SKAT,Get_Liu_Params,-1,0,0,list<double>,1
+SKAT,Get_Liu_Params,0,0,0,double[],1
+SKAT,Get_Liu_Params_Mod,-1,0,0,list<double>,1
+SKAT,Get_Liu_Params_Mod,0,0,0,double[],1
+SKAT,Get_Liu_Params_Mod_Lambda,-1,0,0,list<double>,1
+SKAT,Get_Liu_Params_Mod_Lambda,0,0,0,double[],1
+SKAT,Get_Liu_PVal.MOD.Lambda,-1,0,0,double[],1
+SKAT,Get_Liu_PVal.MOD.Lambda,0,0,0,double[],1
+SKAT,Get_Liu_PVal.MOD.Lambda,1,0,0,double[],1
+SKAT,Get_Liu_PVal.MOD.Lambda,2,0,0,logical,1
+SKAT,Get_Logistic_Weights,-1,0,0,double[],1
+SKAT,Get_Logistic_Weights,0,0,0,class<`matrix`>,1
+SKAT,Get_Logistic_Weights,1,0,0,double,1
+SKAT,Get_Logistic_Weights,2,0,0,double,1
+SKAT,Get_Logistic_Weights_MAF,-1,0,0,double[],1
+SKAT,Get_Logistic_Weights_MAF,0,0,0,double[],1
+SKAT,Get_Logistic_Weights_MAF,1,0,0,double,1
+SKAT,Get_Logistic_Weights_MAF,2,0,0,double,1
+SKAT,Get_MAF,-1,0,0,double[],1
+SKAT,Get_MAF,0,0,0,class<`matrix`>,1
+SKAT,Get_PI_New,-1,0,0,double[],1
+SKAT,Get_PI_New,0,0,0,double[],1
+SKAT,Get_PI_New,1,0,0,double,1
+SKAT,Get_Power_Continuous,-1,0,0,class<`matrix`>,1
+SKAT,Get_Power_Continuous,0,0,0,class<`matrix`>,1
+SKAT,Get_Power_Continuous,1,0,0,double[],1
+SKAT,Get_Power_Continuous,2,0,0,double[],1
+SKAT,Get_Power_Continuous,3,0,0,double[],1
+SKAT,Get_Power_Continuous,4,0,0,double[],1
+SKAT,Get_Power_Logistic,-1,0,0,class<`matrix`>,1
+SKAT,Get_Power_Logistic,0,0,0,class<`matrix`>,1
+SKAT,Get_Power_Logistic,1,0,0,double[],1
+SKAT,Get_Power_Logistic,2,0,0,double,1
+SKAT,Get_Power_Logistic,3,0,0,double,1
+SKAT,Get_Power_Logistic,4,0,0,double[],1
+SKAT,Get_Power_Logistic,5,0,0,double[],1
+SKAT,Get_Power_Logistic,6,0,0,double[],1
+SKAT,Get_PValue,-1,0,0,list<double[] | null>,1
+SKAT,Get_PValue,-1,0,1,list<double | null>,1
+SKAT,Get_PValue,0,0,0,class<`matrix`>,1
+SKAT,Get_PValue,1,0,0,double[],1
+SKAT,Get_PValue.Lambda,-1,0,0,list<double[] | null>,1
+SKAT,Get_PValue.Lambda,-1,0,1,list<double | null>,1
+SKAT,Get_PValue.Lambda,0,0,0,double[],1
+SKAT,Get_PValue.Lambda,1,0,0,double[],1
+SKAT,Get_RandomRegion,-1,0,0,integer[],1
+SKAT,Get_RandomRegion,0,0,0,integer[],1
+SKAT,Get_RandomRegion,1,0,0,double,1
+SKAT,Get_RequiredSampleSize,-1,0,0,list<character>,1
+SKAT,Get_RequiredSampleSize,-1,0,1,list<double | character>,1
+SKAT,Get_RequiredSampleSize,0,0,0,class<`SKAT_Power`>,1
+SKAT,Get_RequiredSampleSize,1,0,0,double,1
+SKAT,Get_RequiredSampleSize.numeric,-1,0,0,list<character>,1
+SKAT,Get_RequiredSampleSize.numeric,-1,0,1,list<double | character>,1
+SKAT,Get_RequiredSampleSize.numeric,0,0,0,class<`matrix`>,1
+SKAT,Get_RequiredSampleSize.numeric,1,0,0,double,1
+SKAT,Get_RequiredSampleSize.SKAT_Power,-1,0,0,list<character>,1
+SKAT,Get_RequiredSampleSize.SKAT_Power,-1,0,1,list<double | character>,1
+SKAT,Get_RequiredSampleSize.SKAT_Power,0,0,0,class<`SKAT_Power`>,1
+SKAT,Get_RequiredSampleSize.SKAT_Power,1,0,0,double,1
+SKAT,Get_Resampling_Pvalue,-1,0,0,list<double>,1
+SKAT,Get_Resampling_Pvalue,0,0,0,class<`SKAT_OUT`>,1
+SKAT,Get_Res_Arrays,-1,0,0,list<double[]>,1
+SKAT,Get_Res_Arrays,0,0,0,double[],1
+SKAT,Get_Res_Arrays,1,0,0,null,1
+SKAT,Get_Res_Arrays,2,0,0,integer[],1
+SKAT,Get_SKAT_Residuals.Get_X1,-1,0,0,class<`matrix`>,1
+SKAT,Get_SKAT_Residuals.Get_X1,0,0,0,class<`matrix`>,1
+SKAT,Get_SKAT_Residuals.linear,-1,0,0,list<any>,1
+SKAT,Get_SKAT_Residuals.linear,0,0,0,class<`formula`>,1
+SKAT,Get_SKAT_Residuals.linear,1,0,0,null,1
+SKAT,Get_SKAT_Residuals.linear,2,0,0,double,1
+SKAT,Get_SKAT_Residuals.linear,3,0,0,character,1
+SKAT,Get_SKAT_Residuals.linear,4,0,0,integer[],1
+SKAT,Get_SKAT_Residuals.logistic,-1,0,0,list<any>,1
+SKAT,Get_SKAT_Residuals.logistic,0,0,0,class<`formula`>,1
+SKAT,Get_SKAT_Residuals.logistic,1,0,0,null,1
+SKAT,Get_SKAT_Residuals.logistic,1,0,1,list<class<`matrix`> | double[] | list<class<`matrix`>>>,1
+SKAT,Get_SKAT_Residuals.logistic,2,0,0,double,1
+SKAT,Get_SKAT_Residuals.logistic,3,0,0,character,1
+SKAT,Get_SKAT_Residuals.logistic,4,0,0,integer[],1
+SKAT,Get_Total_K,-1,0,0,list<double[]>,1
+SKAT,Get_Total_K,0,0,0,integer,1
+SKAT,Get_W_New,-1,0,0,double[],1
+SKAT,Get_W_New,0,0,0,double[],1
+SKAT,Get_W_New,1,0,0,double[],1
+SKAT,Impute,-1,0,0,class<`matrix`>,1
+SKAT,Impute,0,0,0,class<`matrix`>,1
+SKAT,Impute,1,0,0,character,1
+SKAT,KMTest.linear.Linear,-1,0,0,list<any>,1
+SKAT,KMTest.linear.Linear,0,0,0,double[],1
+SKAT,KMTest.linear.Linear,1,0,0,class<`matrix`>,1
+SKAT,KMTest.linear.Linear,2,0,0,class<`matrix`>,1
+SKAT,KMTest.linear.Linear,3,0,0,character,1
+SKAT,KMTest.linear.Linear,4,0,0,any,1
+SKAT,KMTest.linear.Linear,5,0,0,double,1
+SKAT,KMTest.linear.Linear,6,0,0,character,1
+SKAT,KMTest.linear.Linear,7,0,0,any,1
+SKAT,KMTest.linear.Linear,8,0,0,double,1
+SKAT,KMTest.linear.Linear,9,0,0,double,1
+SKAT,KMTest.logistic.Linear,-1,0,0,list<any>,1
+SKAT,KMTest.logistic.Linear,0,0,0,double[],1
+SKAT,KMTest.logistic.Linear,1,0,0,class<`matrix`>,1
+SKAT,KMTest.logistic.Linear,2,0,0,class<`matrix`>,1
+SKAT,KMTest.logistic.Linear,3,0,0,character,1
+SKAT,KMTest.logistic.Linear,4,0,0,any,1
+SKAT,KMTest.logistic.Linear,5,0,0,double[],1
+SKAT,KMTest.logistic.Linear,6,0,0,character,1
+SKAT,KMTest.logistic.Linear,7,0,0,any,1
+SKAT,KMTest.logistic.Linear,8,0,0,double,1
+SKAT,KMTest.logistic.Linear,9,0,0,double,1
+SKAT,KMTest.logistic.Linear.VarMatching,-1,0,0,list<any>,1
+SKAT,KMTest.logistic.Linear.VarMatching,0,0,0,double[],1
+SKAT,KMTest.logistic.Linear.VarMatching,1,0,0,class<`matrix`>,1
+SKAT,KMTest.logistic.Linear.VarMatching,2,0,0,class<`matrix`>,1
+SKAT,KMTest.logistic.Linear.VarMatching,3,0,0,character,1
+SKAT,KMTest.logistic.Linear.VarMatching,4,0,0,null,1
+SKAT,KMTest.logistic.Linear.VarMatching,4,0,1,double[],1
+SKAT,KMTest.logistic.Linear.VarMatching,5,0,0,double[],1
+SKAT,KMTest.logistic.Linear.VarMatching,6,0,0,character,1
+SKAT,KMTest.logistic.Linear.VarMatching,7,0,0,any,1
+SKAT,KMTest.logistic.Linear.VarMatching,8,0,0,double,1
+SKAT,KMTest.logistic.Linear.VarMatching,9,0,0,double,1
+SKAT,KMTest.logistic.Linear.VarMatching,10,0,0,double[],1
+SKAT,KMTest.logistic.Linear.VarMatching,11,0,0,null,1
+SKAT,KMTest.logistic.Linear.VarMatching,11,0,1,class<`matrix`>,1
+SKAT,KMTest.logistic.Linear.VarMatching,12,0,0,double[],1
+SKAT,KMTest.logistic.Linear.VarMatching,12,0,1,null,1
+SKAT,Met_SKAT_Get_Pvalue,-1,0,0,list<double | null | list<double[]>>,1
+SKAT,Met_SKAT_Get_Pvalue,0,0,0,double[],1
+SKAT,Met_SKAT_Get_Pvalue,1,0,0,class<`matrix`>,1
+SKAT,Met_SKAT_Get_Pvalue,2,0,0,double[],1
+SKAT,Met_SKAT_Get_Pvalue,3,0,0,character,1
+SKAT,Met_SKAT_Get_Pvalue,4,0,0,null,1
+SKAT,MSG_SKAT_Example,-1,0,0,null,1
+SKAT,Power_Continuous,-1,0,0,class<`SKAT_Power`>,1
+SKAT,Power_Continuous,0,0,0,null,1
+SKAT,Power_Continuous,1,0,0,null,1
+SKAT,Power_Continuous,2,0,0,double,1
+SKAT,Power_Continuous,3,0,0,double,1
+SKAT,Power_Continuous,4,0,0,double,1
+SKAT,Power_Continuous,5,0,0,double[],1
+SKAT,Power_Continuous,6,0,0,double[],1
+SKAT,Power_Continuous,7,0,0,double[],1
+SKAT,Power_Continuous,8,0,0,double,1
+SKAT,Power_Continuous,9,0,0,character,1
+SKAT,Power_Continuous,10,0,0,double,1
+SKAT,Power_Continuous,11,0,0,double,1
+SKAT,Power_Logistic,-1,0,0,class<`SKAT_Power`>,1
+SKAT,Power_Logistic,0,0,0,null,1
+SKAT,Power_Logistic,1,0,0,null,1
+SKAT,Power_Logistic,2,0,0,double,1
+SKAT,Power_Logistic,3,0,0,double,1
+SKAT,Power_Logistic,4,0,0,double,1
+SKAT,Power_Logistic,5,0,0,double,1
+SKAT,Power_Logistic,6,0,0,double,1
+SKAT,Power_Logistic,7,0,0,double[],1
+SKAT,Power_Logistic,8,0,0,double[],1
+SKAT,Power_Logistic,9,0,0,double[],1
+SKAT,Power_Logistic,10,0,0,double,1
+SKAT,Power_Logistic,11,0,0,character,1
+SKAT,Power_Logistic,12,0,0,double,1
+SKAT,Power_Logistic,13,0,0,double,1
+SKAT,SKAT,-1,0,0,class<`SKAT_OUT`>,1
+SKAT,SKAT,0,0,0,class<`matrix`>,1
+SKAT,SKAT,1,0,0,class<`SKAT_NULL_Model`>,1
+SKAT,SKAT,1,0,1,class<`SKAT_NULL_Model_ADJ`>,1
+SKAT,SKAT,1,0,2,class<`SKAT_NULL_Model_EMMAX`>,1
+SKAT,SKAT,2,0,0,character,1
+SKAT,SKAT,3,0,0,character,1
+SKAT,SKAT,4,0,0,any,1
+SKAT,SKAT,5,0,0,double[],1
+SKAT,SKAT,5,0,1,null,1
+SKAT,SKAT,6,0,0,any,1
+SKAT,SKAT,7,0,0,double,1
+SKAT,SKAT,8,0,0,logical,1
+SKAT,SKAT,9,0,0,logical,1
+SKAT,SKAT,10,0,0,double,1
+SKAT,SKAT,11,0,0,double,1
+SKAT,SKAT,12,0,0,double,1
+SKAT,SKAT_1,-1,0,0,class<`SKAT_OUT`>,1
+SKAT,SKAT_1,0,0,0,class<`matrix`>,1
+SKAT,SKAT_1,1,0,0,class<`SKAT_NULL_Model`>,1
+SKAT,SKAT_1,2,0,0,...,1
+SKAT,SKAT_2Kernel_Optimal_Get_Q,-1,0,0,list<double[] | null>,1
+SKAT,SKAT_2Kernel_Optimal_Get_Q,0,0,0,class<`matrix`>,1
+SKAT,SKAT_2Kernel_Optimal_Get_Q,1,0,0,class<`matrix`>,1
+SKAT,SKAT_2Kernel_Optimal_Get_Q,2,0,0,double[],1
+SKAT,SKAT_2Kernel_Optimal_Get_Q,3,0,0,double[],1
+SKAT,SKAT_2Kernel_Optimal_Get_Q,4,0,0,double,1
+SKAT,SKAT_2Kernel_Optimal_Get_Q,5,0,0,any,1
+SKAT,SKAT_2Kernel_Optimal_Get_Q,6,0,0,null,1
+SKAT,SKAT_2Kernel_Ortho_Optimal_Each_Q,-1,0,0,list<double | class<`matrix`>>,1
+SKAT,SKAT_2Kernel_Ortho_Optimal_Each_Q,0,0,0,any,1
+SKAT,SKAT_2Kernel_Ortho_Optimal_Each_Q,1,0,0,class<`matrix`>,1
+SKAT,SKAT_2Kernel_Ortho_Optimal_Each_Q,2,0,0,double[],1
+SKAT,SKAT_2Kernel_Ortho_Optimal_Each_Q,3,0,0,class<`matrix`>,1
+SKAT,SKAT_2Kernel_Ortho_Optimal_Get_Params_each_r,-1,0,0,class<`matrix`>,1
+SKAT,SKAT_2Kernel_Ortho_Optimal_Get_Params_each_r,0,0,0,class<`matrix`>,1
+SKAT,SKAT_2Kernel_Ortho_Optimal_Get_Params_each_r,1,0,0,class<`matrix`>,1
+SKAT,SKAT_2Kernel_Ortho_Optimal_Get_Params_each_r,2,0,0,double[],1
+SKAT,SKAT_2Kernel_Ortho_Optimal_Get_Pvalue,-1,0,0,list<double | class<`matrix`>>,1
+SKAT,SKAT_2Kernel_Ortho_Optimal_Get_Pvalue,0,0,0,class<`matrix`>,1
+SKAT,SKAT_2Kernel_Ortho_Optimal_Get_Pvalue,1,0,0,class<`matrix`>,1
+SKAT,SKAT_2Kernel_Ortho_Optimal_Get_Pvalue,2,0,0,class<`matrix`>,1
+SKAT,SKAT_2Kernel_Ortho_Optimal_Get_Pvalue,3,0,0,double[],1
+SKAT,SKAT_2Kernel_Ortho_Optimal_Get_Pvalue,4,0,0,any,1
+SKAT,SKAT_2Kernel_Ortho_Optimal_Param,-1,0,0,list<list<double[]>>,1
+SKAT,SKAT_2Kernel_Ortho_Optimal_Param,0,0,0,class<`matrix`>,1
+SKAT,SKAT_2Kernel_Ortho_Optimal_Param,1,0,0,class<`matrix`>,1
+SKAT,SKAT_2Kernel_Ortho_Optimal_Param,2,0,0,double[],1
+SKAT,SKAT_2Kernel_Ortho_Optimal_PValue_Liu,-1,0,0,double,1
+SKAT,SKAT_2Kernel_Ortho_Optimal_PValue_Liu,0,0,0,double[],1
+SKAT,SKAT_2Kernel_Ortho_Optimal_PValue_Liu,1,0,0,list<list<double[]>>,1
+SKAT,SKAT_2Kernel_Ortho_Optimal_PValue_Liu,2,0,0,double[],1
+SKAT,SKAT_2Kernel_Ortho_Optimal_PValue_Liu,3,0,0,double,1
+SKAT,SKATBinary,-1,0,0,class<`SKAT_OUT`>,1
+SKAT,SKATBinary,-1,0,1,list<any>,1
+SKAT,SKATBinary,0,0,0,class<`matrix`>,1
+SKAT,SKATBinary,1,0,0,class<`SKAT_NULL_Model`>,1
+SKAT,SKATBinary,2,0,0,character,1
+SKAT,SKATBinary,3,0,0,character,1
+SKAT,SKATBinary,4,0,0,character,1
+SKAT,SKATBinary,5,0,0,double[],1
+SKAT,SKATBinary,6,0,0,null,1
+SKAT,SKATBinary,7,0,0,double,1
+SKAT,SKATBinary,8,0,0,character,1
+SKAT,SKATBinary,9,0,0,logical,1
+SKAT,SKATBinary,10,0,0,logical,1
+SKAT,SKATBinary,11,0,0,double,1
+SKAT,SKATBinary,12,0,0,double,1
+SKAT,SKATBinary,13,0,0,double,1
+SKAT,SKATBinary,14,0,0,any,1
+SKAT,SKATBinary,15,0,0,double,1
+SKAT,SKATBinary_RestoreSeed,-1,0,0,double,1
+SKAT,SKATBinary_RestoreSeed,0,0,0,any,1
+SKAT,SKATBinary_SeedNum,-1,0,0,double,1
+SKAT,SKATBinary_SeedNum,0,0,0,double,1
+SKAT,SKATBinary_Single,-1,0,0,list<any>,1
+SKAT,SKATBinary_Single,0,0,0,double[],1
+SKAT,SKATBinary_Single,1,0,0,class<`SKAT_NULL_Model`>,1
+SKAT,SKATBinary_Single,2,0,0,character,1
+SKAT,SKATBinary_Single,3,0,0,character,1
+SKAT,SKATBinary_Single,4,0,0,logical,1
+SKAT,SKATBinary_Single,5,0,0,logical,1
+SKAT,SKATBinary_Single,6,0,0,double,1
+SKAT,SKATBinary_Single,7,0,0,double,1
+SKAT,SKATBinary_Single,8,0,0,double,1
+SKAT,SKATBinary_Single,9,0,0,any,1
+SKAT,SKATBinary_Single,10,0,0,double,1
+SKAT,SKATBinary_Single,11,0,0,any,1
+SKAT,SKATBinary.Single.CheckZ,-1,0,0,list<double[]>,1
+SKAT,SKATBinary.Single.CheckZ,0,0,0,double[],1
+SKAT,SKATBinary.Single.CheckZ,1,0,0,integer[],1
+SKAT,SKATBinary.Single.CheckZ,2,0,0,any,1
+SKAT,SKATBinary.Single.CheckZ,3,0,0,logical,1
+SKAT,SKATBinary.Single.CheckZ,4,0,0,logical,1
+SKAT,SKATBinary.Single.CheckZ,5,0,0,double,1
+SKAT,SKAT_Check_Method,-1,0,0,list<character | double[]>,1
+SKAT,SKAT_Check_Method,-1,0,1,list<character | double>,1
+SKAT,SKAT_Check_Method,0,0,0,character,1
+SKAT,SKAT_Check_Method,1,0,0,any,1
+SKAT,SKAT_Check_Method,2,0,0,integer,1
+SKAT,SKAT_Check_Method,2,0,1,null,1
+SKAT,SKAT_Check_Method,3,0,0,integer,1
+SKAT,SKAT_Check_Method,3,0,1,null,1
+SKAT,SKAT_Check_RCorr,-1,0,0,double,1
+SKAT,SKAT_Check_RCorr,-1,0,1,null,1
+SKAT,SKAT_Check_RCorr,0,0,0,any,1
+SKAT,SKAT_Check_RCorr,1,0,0,double[],1
+SKAT,SKAT_ChrX,-1,0,0,class<`SKAT_OUT`>,1
+SKAT,SKAT_ChrX,0,0,0,class<`matrix`>,1
+SKAT,SKAT_ChrX,1,0,0,class<`SKAT_NULL_Model_ChrX`>,1
+SKAT,SKAT_ChrX,2,0,0,logical,1
+SKAT,SKAT_ChrX,3,0,0,character,1
+SKAT,SKAT_ChrX,4,0,0,character,1
+SKAT,SKAT_ChrX,5,0,0,double[],1
+SKAT,SKAT_ChrX,6,0,0,null,1
+SKAT,SKAT_ChrX,7,0,0,character,1
+SKAT,SKAT_ChrX,8,0,0,double,1
+SKAT,SKAT_ChrX,9,0,0,logical,1
+SKAT,SKAT_ChrX,10,0,0,logical,1
+SKAT,SKAT_ChrX,11,0,0,double,1
+SKAT,SKAT_ChrX,12,0,0,double,1
+SKAT,SKAT_ChrX,13,0,0,double,1
+SKAT,SKAT_ChrX,14,0,0,null,1
+SKAT,SKAT_Code_XChr,-1,0,0,class<`matrix`>,1
+SKAT,SKAT_Code_XChr,0,0,0,class<`matrix`>,1
+SKAT,SKAT_Code_XChr,1,0,0,logical,1
+SKAT,SKAT_Code_XChr,2,0,0,double[],1
+SKAT,SKAT_CommonRare,-1,0,0,class<`SKAT_OUT`>,1
+SKAT,SKAT_CommonRare,-1,0,1,list<any>,1
+SKAT,SKAT_CommonRare,0,0,0,class<`matrix`>,1
+SKAT,SKAT_CommonRare,1,0,0,class<`SKAT_NULL_Model`>,1
+SKAT,SKAT_CommonRare,2,0,0,any,1
+SKAT,SKAT_CommonRare,3,0,0,any,1
+SKAT,SKAT_CommonRare,4,0,0,character,1
+SKAT,SKAT_CommonRare,5,0,0,double,1
+SKAT,SKAT_CommonRare,6,0,0,double,1
+SKAT,SKAT_CommonRare,7,0,0,null,1
+SKAT,SKAT_CommonRare,7,0,1,double,1
+SKAT,SKAT_CommonRare,8,0,0,character,1
+SKAT,SKAT_CommonRare,9,0,0,logical,1
+SKAT,SKAT_CommonRare,10,0,0,double,1
+SKAT,SKAT_CommonRare,11,0,0,double,1
+SKAT,SKAT_CommonRare,12,0,0,null,1
+SKAT,SKAT_CR_Linear,-1,0,0,list<double | null | list<double[]>>,1
+SKAT,SKAT_CR_Linear,0,0,0,class<`SKAT_NULL_Model`>,1
+SKAT,SKAT_CR_Linear,1,0,0,class<`matrix`>,1
+SKAT,SKAT_CR_Linear,2,0,0,class<`matrix`>,1
+SKAT,SKAT_CR_Linear,3,0,0,double[],1
+SKAT,SKAT_CR_Linear,4,0,0,logical,1
+SKAT,SKAT_CR_Optimal,-1,0,0,list<double | null | list<double[]>>,1
+SKAT,SKAT_CR_Optimal,0,0,0,double[],1
+SKAT,SKAT_CR_Optimal,1,0,0,class<`matrix`>,1
+SKAT,SKAT_CR_Optimal,2,0,0,class<`matrix`>,1
+SKAT,SKAT_CR_Optimal,3,0,0,class<`matrix`>,1
+SKAT,SKAT_CR_Optimal,4,0,0,any,1
+SKAT,SKAT_CR_Optimal,5,0,0,any,1
+SKAT,SKAT_CR_Optimal,6,0,0,any,1
+SKAT,SKAT_CR_Optimal,7,0,0,double,1
+SKAT,SKAT_CR_Optimal,8,0,0,double[],1
+SKAT,SKAT_CR_Optimal,9,0,0,character,1
+SKAT,SKAT_davies,-1,0,0,list<double[]>,1
+SKAT,SKAT_davies,0,0,0,double,1
+SKAT,SKAT_davies,1,0,0,double[],1
+SKAT,SKAT_davies,2,0,0,double[],1
+SKAT,SKAT_davies,3,0,0,double[],1
+SKAT,SKAT_davies,4,0,0,double,1
+SKAT,SKAT_davies,5,0,0,double,1
+SKAT,SKAT_davies,6,0,0,double,1
+SKAT,SKAT_emmaX,-1,0,0,list<any>,1
+SKAT,SKAT_emmaX,0,0,0,class<`matrix`>,1
+SKAT,SKAT_emmaX,1,0,0,class<`SKAT_NULL_Model_EMMAX`>,1
+SKAT,SKAT_emmaX,2,0,0,character,1
+SKAT,SKAT_emmaX,3,0,0,character,1
+SKAT,SKAT_emmaX,4,0,0,double[],1
+SKAT,SKAT_emmaX,5,0,0,null,1
+SKAT,SKAT_emmaX,6,0,0,any,1
+SKAT,SKAT_emmaX,7,0,0,double,1
+SKAT,SKAT_emmaX,8,0,0,logical,1
+SKAT,SKAT_emmaX,9,0,0,logical,1
+SKAT,SKAT_emmaX,10,0,0,double,1
+SKAT,SKAT_emmaX,11,0,0,double,1
+SKAT,SKAT_emmaX,12,0,0,double,1
+SKAT,SKAT_emmaX,13,0,0,null,1
+SKAT,SKAT_emmaX_work,-1,0,0,list<any>,1
+SKAT,SKAT_emmaX_work,0,0,0,any,1
+SKAT,SKAT_emmaX_work,1,0,0,class<`matrix`>,1
+SKAT,SKAT_emmaX_work,2,0,0,class<`SKAT_NULL_Model_EMMAX`>,1
+SKAT,SKAT_emmaX_work,3,0,0,character,1
+SKAT,SKAT_emmaX_work,4,0,0,character,1
+SKAT,SKAT_emmaX_work,5,0,0,double[],1
+SKAT,SKAT_emmaX_work,6,0,0,double,1
+SKAT,SKATExactBin,-1,0,0,list<any>,1
+SKAT,SKATExactBin,0,0,0,class<`matrix`>,1
+SKAT,SKATExactBin,1,0,0,class<`SKAT_NULL_Model`>,1
+SKAT,SKATExactBin,2,0,0,character,1
+SKAT,SKATExactBin,3,0,0,character,1
+SKAT,SKATExactBin,4,0,0,double[],1
+SKAT,SKATExactBin,5,0,0,null,1
+SKAT,SKATExactBin,6,0,0,any,1
+SKAT,SKATExactBin,7,0,0,double[],1
+SKAT,SKATExactBin,8,0,0,any,1
+SKAT,SKATExactBin,9,0,0,logical,1
+SKAT,SKATExactBin,10,0,0,double,1
+SKAT,SKATExactBin,11,0,0,double,1
+SKAT,SKATExactBin,12,0,0,null,1
+SKAT,SKATExactBin,13,0,0,double,1
+SKAT,SKATExactBin,14,0,0,any,1
+SKAT,SKATExactBin,15,0,0,double,1
+SKAT,SKATExactBin.Adaptive,-1,0,0,list<double | null | list<integer>>,1
+SKAT,SKATExactBin.Adaptive,0,0,0,class<`matrix`>,1
+SKAT,SKATExactBin.Adaptive,1,0,0,class<`SKAT_NULL_Model`>,1
+SKAT,SKATExactBin.Adaptive,2,0,0,character,1
+SKAT,SKATExactBin.Adaptive,3,0,0,double[],1
+SKAT,SKATExactBin.Adaptive,4,0,0,null,1
+SKAT,SKATExactBin.Adaptive,5,0,0,any,1
+SKAT,SKATExactBin.Adaptive,6,0,0,double,1
+SKAT,SKATExactBin.Adaptive,7,0,0,any,1
+SKAT,SKATExactBin.Adaptive,8,0,0,logical,1
+SKAT,SKATExactBin.Adaptive,9,0,0,double,1
+SKAT,SKATExactBin.Adaptive,10,0,0,double,1
+SKAT,SKATExactBin.Adaptive,11,0,0,double,1
+SKAT,SKATExactBin.Adaptive,12,0,0,double,1
+SKAT,SKATExactBin.Adaptive,13,0,0,null,1
+SKAT,SKATExactBin.Adaptive,14,0,0,double,1
+SKAT,SKATExactBin.Adaptive,15,0,0,double,1
+SKAT,SKATExactBin_Check,-1,0,0,list<class<`matrix`> | class<`SKAT_NULL_Model`> | double[]>,1
+SKAT,SKATExactBin_Check,0,0,0,class<`matrix`>,1
+SKAT,SKATExactBin_Check,1,0,0,class<`SKAT_NULL_Model`>,1
+SKAT,SKATExactBin_Check,2,0,0,any,1
+SKAT,SKATExactBin_Check,3,0,0,double[],1
+SKAT,SKATExactBin_Check,4,0,0,null,1
+SKAT,SKATExactBin_Check,5,0,0,any,1
+SKAT,SKATExactBin_Check,6,0,0,double[],1
+SKAT,SKATExactBin_Check,7,0,0,logical,1
+SKAT,SKATExactBin_Check,8,0,0,double,1
+SKAT,SKATExactBin_Check,9,0,0,double,1
+SKAT,SKATExactBin_Check,10,0,0,any,1
+SKAT,SKATExactBin_Check,11,0,0,double,1
+SKAT,SKATExactBin_Check,12,0,0,logical,1
+SKAT,SKATExactBin_Check,13,0,0,logical,1
+SKAT,SKATExactBin_CheckAccuracy,-1,0,0,logical,1
+SKAT,SKATExactBin_CheckAccuracy,0,0,0,double,1
+SKAT,SKATExactBin_CheckAccuracy,1,0,0,double,1
+SKAT,SKATExactBin_CheckAccuracy,2,0,0,double,1
+SKAT,SKATExactBin_CheckObj,-1,0,0,class<`SKAT_NULL_Model`>,1
+SKAT,SKATExactBin_CheckObj,0,0,0,class<`SKAT_NULL_Model`>,1
+SKAT,SKATExactBin.ComputeProb_Group,-1,0,0,list<double[]>,1
+SKAT,SKATExactBin.ComputeProb_Group,0,0,0,integer[],1
+SKAT,SKATExactBin.ComputeProb_Group,1,0,0,double[],1
+SKAT,SKATExactBin.ComputeProb_Group,2,0,0,integer,1
+SKAT,SKATExactBin.ComputeProb_Group,3,0,0,double,1
+SKAT,SKATExactBin.ComputeProb_Group,4,0,0,double,1
+SKAT,SKATExactBin.ComputProb_New,-1,0,0,list<double[]>,1
+SKAT,SKATExactBin.ComputProb_New,0,0,0,integer[],1
+SKAT,SKATExactBin.ComputProb_New,1,0,0,double[],1
+SKAT,SKATExactBin.ComputProb_New,2,0,0,integer,1
+SKAT,SKATExactBin.ComputProb_New,3,0,0,double,1
+SKAT,SKATExactBin.ComputProb_New,4,0,0,double,1
+SKAT,SKATExactBin.ComputProb_New,5,0,0,any,1
+SKAT,SKATExactBin.ComputProb_New,6,0,0,any,1
+SKAT,SKATExactBin.ComputProb_New,7,0,0,double,1
+SKAT,SKATExactBin.ComputProb_Random,-1,0,0,list<double[] | class<`matrix`>>,1
+SKAT,SKATExactBin.ComputProb_Random,0,0,0,list<double[]>,1
+SKAT,SKATExactBin.ComputProb_Random,1,0,0,integer[],1
+SKAT,SKATExactBin.ComputProb_Random,2,0,0,double[],1
+SKAT,SKATExactBin.ComputProb_Random,3,0,0,integer,1
+SKAT,SKATExactBin.ComputProb_Random,4,0,0,any,1
+SKAT,SKATExactBin.ComputProb_Random,5,0,0,double,1
+SKAT,SKATExactBin.ComputProb_Random,6,0,0,double,1
+SKAT,SKATExactBin.ComputProb_Random,7,0,0,double,1
+SKAT,SKATExactBin.Firth,-1,0,0,list<double | null>,1
+SKAT,SKATExactBin.Firth,0,0,0,class<`matrix`>,1
+SKAT,SKATExactBin.Firth,1,0,0,class<`SKAT_NULL_Model`>,1
+SKAT,SKATExactBin.Firth,2,0,0,character,1
+SKAT,SKATExactBin.Firth,3,0,0,character,1
+SKAT,SKATExactBin.Firth,4,0,0,double[],1
+SKAT,SKATExactBin.Firth,5,0,0,null,1
+SKAT,SKATExactBin.Firth,6,0,0,any,1
+SKAT,SKATExactBin.Firth,7,0,0,double,1
+SKAT,SKATExactBin.Firth,8,0,0,any,1
+SKAT,SKATExactBin.Firth,9,0,0,logical,1
+SKAT,SKATExactBin.Firth,10,0,0,double,1
+SKAT,SKATExactBin.Firth,11,0,0,double,1
+SKAT,SKATExactBin.Firth,12,0,0,null,1
+SKAT,SKATExactBin.Firth,13,0,0,double,1
+SKAT,SKATExactBin.Firth,14,0,0,logical,1
+SKAT,SKATExactBin.Moment,-1,0,0,list<any>,1
+SKAT,SKATExactBin.Moment,0,0,0,class<`matrix`>,1
+SKAT,SKATExactBin.Moment,1,0,0,double[],1
+SKAT,SKATExactBin.Moment,2,0,0,double[],1
+SKAT,SKATExactBin.Moment,3,0,0,double,1
+SKAT,SKATExactBin.Moment,4,0,0,integer[],1
+SKAT,SKATExactBin.Moment,5,0,0,double,1
+SKAT,SKATExactBin.Moment,6,0,0,null,1
+SKAT,SKATExactBin.Moment,7,0,0,class<`matrix`>,1
+SKAT,SKATExactBin.Moment,8,0,0,double[],1
+SKAT,SKATExactBin.Moment,9,0,0,character,1
+SKAT,SKATExactBin.SKATO_GetQParam,-1,0,0,list<class<`matrix`> | integer>,1
+SKAT,SKATExactBin.SKATO_GetQParam,0,0,0,class<`matrix`>,1
+SKAT,SKATExactBin.SKATO_GetQParam,1,0,0,double[],1
+SKAT,SKATExactBin.SKATO_GetQParam,2,0,0,integer[],1
+SKAT,SKATExactBin.SKATO_GetQParam,3,0,0,double[],1
+SKAT,SKATExactBin.SKATO_GetQParam,4,0,0,double[],1
+SKAT,SKATExactBin.SKATO_GetQParam,5,0,0,double[],1
+SKAT,SKATExactBin.SKATO_GetQParam,6,0,0,any,1
+SKAT,SKATExactBin.SKATO_GetQParam,7,0,0,null,1
+SKAT,SKATExactBin.SKATO_GetQParam,8,0,0,double,1
+SKAT,SKATExactBin.SKATO_GetQParam,9,0,0,logical,1
+SKAT,SKATExactBin.Work,-1,0,0,list<double | null>,1
+SKAT,SKATExactBin.Work,0,0,0,class<`matrix`>,1
+SKAT,SKATExactBin.Work,1,0,0,double[],1
+SKAT,SKATExactBin.Work,2,0,0,double[],1
+SKAT,SKATExactBin.Work,3,0,0,double,1
+SKAT,SKATExactBin.Work,4,0,0,integer[],1
+SKAT,SKATExactBin.Work,5,0,0,double[],1
+SKAT,SKATExactBin.Work,6,0,0,null,1
+SKAT,SKATExactBin.Work,7,0,0,any,1
+SKAT,SKATExactBin.Work,8,0,0,any,1
+SKAT,SKATExactBin.Work,9,0,0,double,1
+SKAT,SKATExactBin.Work,10,0,0,any,1
+SKAT,SKATExactBin.Work,11,0,0,double,1
+SKAT,SKATExactBin.Work,12,0,0,any,1
+SKAT,SKATExactBin.Work_Adaptive,-1,0,0,list<double | null>,1
+SKAT,SKATExactBin.Work_Adaptive,0,0,0,class<`matrix`>,1
+SKAT,SKATExactBin.Work_Adaptive,1,0,0,double[],1
+SKAT,SKATExactBin.Work_Adaptive,2,0,0,double[],1
+SKAT,SKATExactBin.Work_Adaptive,3,0,0,double,1
+SKAT,SKATExactBin.Work_Adaptive,4,0,0,integer[],1
+SKAT,SKATExactBin.Work_Adaptive,5,0,0,double,1
+SKAT,SKATExactBin.Work_Adaptive,6,0,0,null,1
+SKAT,SKATExactBin.Work_Adaptive,7,0,0,logical,1
+SKAT,SKATExactBin.Work_Adaptive,8,0,0,null,1
+SKAT,SKATExactBin.Work_Adaptive,9,0,0,double,1
+SKAT,SKATExactBin.Work_Adaptive,10,0,0,double,1
+SKAT,SKATExactBin.Work_Adaptive,11,0,0,double,1
+SKAT,SKATExactBin.Work_Adaptive,12,0,0,double,1
+SKAT,SKAT_Get_Cov_Param,-1,0,0,list<double[]>,1
+SKAT,SKAT_Get_Cov_Param,0,0,0,double[],1
+SKAT,SKAT_Get_Cov_Param,1,0,0,double[],1
+SKAT,SKAT_Get_Cov_Param,2,0,0,class<`matrix`>,1
+SKAT,SKAT_Get_DF_Sim,-1,0,0,double,1
+SKAT,SKAT_Get_DF_Sim,0,0,0,double[],1
+SKAT,SKAT_GET_kurtosis,-1,0,0,double,1
+SKAT,SKAT_GET_kurtosis,0,0,0,double[],1
+SKAT,SKAT_Get_MAF,-1,0,0,double[],1
+SKAT,SKAT_Get_MAF,0,0,0,class<`matrix`>,1
+SKAT,SKAT_Get_MAF,1,0,0,integer[],1
+SKAT,SKAT_Get_MAF,1,0,1,null,1
+SKAT,SKAT_Get_MAF,2,0,0,logical,1
+SKAT,SKAT_Get_MAF,3,0,0,any,1
+SKAT,SKAT_Get_Var_Elements,-1,0,0,double,1
+SKAT,SKAT_Get_Var_Elements,0,0,0,double[],1
+SKAT,SKAT_Get_Var_Elements,1,0,0,any,1
+SKAT,SKAT_Get_Var_Elements,2,0,0,double[],1
+SKAT,SKAT_Get_Var_Elements,3,0,0,double[],1
+SKAT,SKAT.linear.Linear,-1,0,0,list<any>,1
+SKAT,SKAT.linear.Linear,0,0,0,double[],1
+SKAT,SKAT.linear.Linear,1,0,0,class<`matrix`>,1
+SKAT,SKAT.linear.Linear,2,0,0,class<`matrix`>,1
+SKAT,SKAT.linear.Linear,3,0,0,character,1
+SKAT,SKAT.linear.Linear,4,0,0,any,1
+SKAT,SKAT.linear.Linear,5,0,0,double,1
+SKAT,SKAT.linear.Linear,6,0,0,character,1
+SKAT,SKAT.linear.Linear,7,0,0,any,1
+SKAT,SKAT.linear.Linear,8,0,0,double,1
+SKAT,SKAT.linear.Linear,9,0,0,double[],1
+SKAT,SKAT.linear.Linear,10,0,0,logical,1
+SKAT,SKAT.logistic.Linear,-1,0,0,list<any>,1
+SKAT,SKAT.logistic.Linear,0,0,0,double[],1
+SKAT,SKAT.logistic.Linear,1,0,0,class<`matrix`>,1
+SKAT,SKAT.logistic.Linear,2,0,0,class<`matrix`>,1
+SKAT,SKAT.logistic.Linear,3,0,0,character,1
+SKAT,SKAT.logistic.Linear,4,0,0,any,1
+SKAT,SKAT.logistic.Linear,5,0,0,double[],1
+SKAT,SKAT.logistic.Linear,6,0,0,character,1
+SKAT,SKAT.logistic.Linear,7,0,0,any,1
+SKAT,SKAT.logistic.Linear,8,0,0,double,1
+SKAT,SKAT.logistic.Linear,9,0,0,double[],1
+SKAT,SKAT.logistic.Linear,10,0,0,logical,1
+SKAT,SKAT_Logistic_VarMatching_GetParam,-1,0,0,list<double[] | list<double>>,1
+SKAT,SKAT_Logistic_VarMatching_GetParam,0,0,0,double[],1
+SKAT,SKAT_Logistic_VarMatching_GetParam,1,0,0,class<`matrix`>,1
+SKAT,SKAT_Logistic_VarMatching_GetParam,2,0,0,double[],1
+SKAT,SKAT_Logistic_VarMatching_GetParam,3,0,0,double[],1
+SKAT,SKAT_Logistic_VarMatching_GetParam1,-1,0,0,list<double[] | list<double>>,1
+SKAT,SKAT_Logistic_VarMatching_GetParam1,0,0,0,class<`matrix`>,1
+SKAT,SKAT_Logistic_VarMatching_GetParam1,1,0,0,double[],1
+SKAT,SKAT_Logistic_VarMatching_GetParam1,2,0,0,double[],1
+SKAT,SKAT_Logistic_VarMatching_GetParam1,3,0,0,character,1
+SKAT,SKAT_MAIN_Check_OutType,-1,0,0,null,1
+SKAT,SKAT_MAIN_Check_OutType,0,0,0,character,1
+SKAT,SKAT_MAIN_Check_Z,-1,0,0,list<class<`matrix`> | double[]>,1
+SKAT,SKAT_MAIN_Check_Z,-1,0,1,list<class<`matrix`> | double | integer[]>,1
+SKAT,SKAT_MAIN_Check_Z,0,0,0,class<`matrix`>,1
+SKAT,SKAT_MAIN_Check_Z,1,0,0,integer,1
+SKAT,SKAT_MAIN_Check_Z,2,0,0,integer[],1
+SKAT,SKAT_MAIN_Check_Z,3,0,0,any,1
+SKAT,SKAT_MAIN_Check_Z,4,0,0,double[],1
+SKAT,SKAT_MAIN_Check_Z,4,0,1,null,1
+SKAT,SKAT_MAIN_Check_Z,5,0,0,any,1
+SKAT,SKAT_MAIN_Check_Z,6,0,0,any,1
+SKAT,SKAT_MAIN_Check_Z,7,0,0,logical,1
+SKAT,SKAT_MAIN_Check_Z,8,0,0,logical,1
+SKAT,SKAT_MAIN_Check_Z,9,0,0,double,1
+SKAT,SKAT_MAIN_Check_Z,10,0,0,double,1
+SKAT,SKAT_MAIN_Check_Z,11,0,0,double,1
+SKAT,SKAT_MAIN_Check_Z,12,0,0,logical,1
+SKAT,SKAT_MAIN_Check_Z,13,0,0,null,1
+SKAT,SKAT_MAIN_Check_Z,13,0,1,double[],1
+SKAT,SKAT_MAIN_Check_Z_Flip,-1,0,0,class<`matrix`>,1
+SKAT,SKAT_MAIN_Check_Z_Flip,0,0,0,class<`matrix`>,1
+SKAT,SKAT_MAIN_Check_Z_Flip,1,0,0,any,1
+SKAT,SKAT_MAIN_Check_Z_Flip,2,0,0,logical,1
+SKAT,SKAT_MAIN_Check_Z_Flip,3,0,0,any,1
+SKAT,SKAT_MAIN_Check_Z_Impute,-1,0,0,class<`matrix`>,1
+SKAT,SKAT_MAIN_Check_Z_Impute,0,0,0,class<`matrix`>,1
+SKAT,SKAT_MAIN_Check_Z_Impute,1,0,0,integer[],1
+SKAT,SKAT_MAIN_Check_Z_Impute,2,0,0,any,1
+SKAT,SKAT_MAIN_Check_Z_Impute,3,0,0,any,1
+SKAT,SKAT_MAIN_Check_Z_Impute,4,0,0,logical,1
+SKAT,SKAT_MAIN_Check_Z_Impute,5,0,0,any,1
+SKAT,SKAT_META_Optimal,-1,0,0,list<double | null | list<double[]>>,1
+SKAT,SKAT_META_Optimal,0,0,0,double[],1
+SKAT,SKAT_META_Optimal,1,0,0,class<`matrix`>,1
+SKAT,SKAT_META_Optimal,2,0,0,double[],1
+SKAT,SKAT_META_Optimal,3,0,0,character,1
+SKAT,SKAT_META_Optimal,4,0,0,null,1
+SKAT,SKAT_META_Optimal_Get_Pvalue,-1,0,0,list<double | class<`matrix`>>,1
+SKAT,SKAT_META_Optimal_Get_Pvalue,0,0,0,class<`matrix`>,1
+SKAT,SKAT_META_Optimal_Get_Pvalue,1,0,0,class<`matrix`>,1
+SKAT,SKAT_META_Optimal_Get_Pvalue,2,0,0,double[],1
+SKAT,SKAT_META_Optimal_Get_Pvalue,3,0,0,character,1
+SKAT,SKAT_META_Optimal_Get_Q,-1,0,0,list<double[]>,1
+SKAT,SKAT_META_Optimal_Get_Q,0,0,0,double[],1
+SKAT,SKAT_META_Optimal_Get_Q,1,0,0,double[],1
+SKAT,SKAT_META_Optimal_Param,-1,0,0,list<double[]>,1
+SKAT,SKAT_META_Optimal_Param,0,0,0,class<`matrix`>,1
+SKAT,SKAT_META_Optimal_Param,1,0,0,double[],1
+SKAT,SKAT_NULL_emmaX,-1,0,0,class<`SKAT_NULL_Model_EMMAX`>,1
+SKAT,SKAT_NULL_emmaX,0,0,0,class<`formula`>,1
+SKAT,SKAT_NULL_emmaX,1,0,0,null,1
+SKAT,SKAT_NULL_emmaX,2,0,0,class<`matrix`>,1
+SKAT,SKAT_NULL_emmaX,3,0,0,null,1
+SKAT,SKAT_NULL_emmaX,4,0,0,double,1
+SKAT,SKAT_NULL_emmaX,5,0,0,double,1
+SKAT,SKAT_NULL_emmaX,6,0,0,double,1
+SKAT,SKAT_NULL_emmaX,7,0,0,double,1
+SKAT,SKAT_NULL_emmaX,8,0,0,logical,1
+SKAT,SKAT_Null_Model,-1,0,0,class<`SKAT_NULL_Model`>,1
+SKAT,SKAT_Null_Model,-1,0,1,class<`SKAT_NULL_Model_ADJ`>,1
+SKAT,SKAT_Null_Model,0,0,0,class<`formula`>,1
+SKAT,SKAT_Null_Model,1,0,0,null,1
+SKAT,SKAT_Null_Model,2,0,0,character,1
+SKAT,SKAT_Null_Model,3,0,0,double,1
+SKAT,SKAT_Null_Model,4,0,0,character,1
+SKAT,SKAT_Null_Model,5,0,0,logical,1
+SKAT,SKAT_Null_Model_ChrX,-1,0,0,class<`SKAT_NULL_Model_ChrX`>,1
+SKAT,SKAT_Null_Model_ChrX,0,0,0,class<`formula`>,1
+SKAT,SKAT_Null_Model_ChrX,1,0,0,character,1
+SKAT,SKAT_Null_Model_ChrX,2,0,0,null,1
+SKAT,SKAT_Null_Model_ChrX,2,0,1,list<class<`matrix`> | double[] | list<class<`matrix`>>>,1
+SKAT,SKAT_Null_Model_ChrX,3,0,0,character,1
+SKAT,SKAT_Null_Model_ChrX,4,0,0,double,1
+SKAT,SKAT_Null_Model_ChrX,5,0,0,character,1
+SKAT,SKAT_Null_Model_ChrX,6,0,0,logical,1
+SKAT,SKAT_Null_Model_Get_Includes,-1,0,0,integer[],1
+SKAT,SKAT_Null_Model_Get_Includes,0,0,0,class<`data.frame`>,1
+SKAT,SKAT_Null_Model_Get_Includes,1,0,0,class<`data.frame`>,1
+SKAT,SKAT_Null_Model_MomentAdjust,-1,0,0,class<`SKAT_NULL_Model_ADJ`>,1
+SKAT,SKAT_Null_Model_MomentAdjust,0,0,0,class<`formula`>,1
+SKAT,SKAT_Null_Model_MomentAdjust,1,0,0,null,1
+SKAT,SKAT_Null_Model_MomentAdjust,2,0,0,double,1
+SKAT,SKAT_Null_Model_MomentAdjust,3,0,0,character,1
+SKAT,SKAT_Null_Model_MomentAdjust,4,0,0,logical,1
+SKAT,SKAT_Null_Model_MomentAdjust,5,0,0,double,1
+SKAT,SKAT_Optimal_Each_Q,-1,0,0,list<double | class<`matrix`>>,1
+SKAT,SKAT_Optimal_Each_Q,0,0,0,any,1
+SKAT,SKAT_Optimal_Each_Q,1,0,0,class<`matrix`>,1
+SKAT,SKAT_Optimal_Each_Q,2,0,0,double[],1
+SKAT,SKAT_Optimal_Each_Q,3,0,0,list<double[]>,1
+SKAT,SKAT_Optimal_Each_Q,4,0,0,character,1
+SKAT,SKAT_Optimal_Get_Pvalue,-1,0,0,list<double | class<`matrix`>>,1
+SKAT,SKAT_Optimal_Get_Pvalue,0,0,0,class<`matrix`>,1
+SKAT,SKAT_Optimal_Get_Pvalue,1,0,0,class<`matrix`>,1
+SKAT,SKAT_Optimal_Get_Pvalue,2,0,0,double[],1
+SKAT,SKAT_Optimal_Get_Pvalue,3,0,0,character,1
+SKAT,SKAT_Optimal_Get_Q,-1,0,0,list<double[] | null>,1
+SKAT,SKAT_Optimal_Get_Q,0,0,0,class<`matrix`>,1
+SKAT,SKAT_Optimal_Get_Q,1,0,0,double[],1
+SKAT,SKAT_Optimal_Get_Q,2,0,0,double[],1
+SKAT,SKAT_Optimal_Get_Q,3,0,0,double,1
+SKAT,SKAT_Optimal_Get_Q,4,0,0,any,1
+SKAT,SKAT_Optimal_Get_Q,5,0,0,null,1
+SKAT,SKAT_Optimal_Get_Q,6,0,0,null,1
+SKAT,SKAT_Optimal_Linear,-1,0,0,list<any>,1
+SKAT,SKAT_Optimal_Linear,0,0,0,double[],1
+SKAT,SKAT_Optimal_Linear,1,0,0,class<`matrix`>,1
+SKAT,SKAT_Optimal_Linear,2,0,0,class<`matrix`>,1
+SKAT,SKAT_Optimal_Linear,3,0,0,character,1
+SKAT,SKAT_Optimal_Linear,4,0,0,double[],1
+SKAT,SKAT_Optimal_Linear,5,0,0,double,1
+SKAT,SKAT_Optimal_Linear,6,0,0,character,1
+SKAT,SKAT_Optimal_Linear,7,0,0,any,1
+SKAT,SKAT_Optimal_Linear,8,0,0,double,1
+SKAT,SKAT_Optimal_Linear,9,0,0,double[],1
+SKAT,SKAT_Optimal_Logistic,-1,0,0,list<any>,1
+SKAT,SKAT_Optimal_Logistic,0,0,0,double[],1
+SKAT,SKAT_Optimal_Logistic,1,0,0,class<`matrix`>,1
+SKAT,SKAT_Optimal_Logistic,2,0,0,class<`matrix`>,1
+SKAT,SKAT_Optimal_Logistic,3,0,0,character,1
+SKAT,SKAT_Optimal_Logistic,4,0,0,double[],1
+SKAT,SKAT_Optimal_Logistic,5,0,0,double[],1
+SKAT,SKAT_Optimal_Logistic,6,0,0,character,1
+SKAT,SKAT_Optimal_Logistic,7,0,0,any,1
+SKAT,SKAT_Optimal_Logistic,8,0,0,double,1
+SKAT,SKAT_Optimal_Logistic,9,0,0,double[],1
+SKAT,SKAT_Optimal_Param,-1,0,0,list<double[]>,1
+SKAT,SKAT_Optimal_Param,0,0,0,class<`matrix`>,1
+SKAT,SKAT_Optimal_Param,1,0,0,double[],1
+SKAT,SKAT_Optimal_PValue_Davies,-1,0,0,double,1
+SKAT,SKAT_Optimal_PValue_Davies,0,0,0,double[],1
+SKAT,SKAT_Optimal_PValue_Davies,1,0,0,list<double[]>,1
+SKAT,SKAT_Optimal_PValue_Davies,2,0,0,double[],1
+SKAT,SKAT_Optimal_PValue_Davies,3,0,0,double,1
+SKAT,SKAT_PValue_Logistic_VarMatching,-1,0,0,list<double | null | list<double[] | list<double>>>,1
+SKAT,SKAT_PValue_Logistic_VarMatching,0,0,0,double,1
+SKAT,SKAT_PValue_Logistic_VarMatching,1,0,0,class<`matrix`>,1
+SKAT,SKAT_PValue_Logistic_VarMatching,2,0,0,double[],1
+SKAT,SKAT_PValue_Logistic_VarMatching,3,0,0,double[],1
+SKAT,SKAT_PValue_Logistic_VarMatching,4,0,0,character,1
+SKAT,SKAT_RunFrom_MetaSKAT,-1,0,0,list<double | null | list<double[]>>,1
+SKAT,SKAT_RunFrom_MetaSKAT,0,0,0,class<`matrix`>,1
+SKAT,SKAT_RunFrom_MetaSKAT,1,0,0,class<`matrix`>,1
+SKAT,SKAT_RunFrom_MetaSKAT,2,0,0,null,1
+SKAT,SKAT_RunFrom_MetaSKAT,3,0,0,character,1
+SKAT,SKAT_RunFrom_MetaSKAT,4,0,0,double[],1
+SKAT,SKAT_RunFrom_MetaSKAT,5,0,0,null,1
+SKAT,SKAT_RunFrom_MetaSKAT,6,0,0,null,1
+SKAT,SKAT_RunFrom_MetaSKAT,7,0,0,class<`matrix`>,1
+SKAT,SKAT_RunFrom_MetaSKAT,8,0,0,character,1
+SKAT,SKAT_RunFrom_MetaSKAT,9,0,0,character,1
+SKAT,SKAT_RunFrom_MetaSKAT,10,0,0,null,1
+SKAT,SKAT_RunFrom_MetaSKAT,11,0,0,double,1
+SKAT,SKAT_RunFrom_MetaSKAT,12,0,0,double[],1
+SKAT,SKAT_Scale_Genotypes,-1,0,0,list<class<`matrix`> | double>,1
+SKAT,SKAT_Scale_Genotypes,0,0,0,class<`SKAT_NULL_Model`>,1
+SKAT,SKAT_Scale_Genotypes,1,0,0,class<`matrix`>,1
+SKAT,SKAT_Scale_Genotypes,2,0,0,class<`matrix`>,1
+SKAT,SKAT_Scale_Genotypes,3,0,0,double[],1
+SKAT,SKAT_Scale_Genotypes,4,0,0,double[],1
+SKAT,SKAT_Scale_Genotypes,5,0,0,null,1
+SKAT,SKAT_Scale_Genotypes,6,0,0,double,1
+SKAT,SKAT_Scale_Genotypes,7,0,0,double,1
+SKAT,SKAT_With_NullModel,-1,0,0,list<any>,1
+SKAT,SKAT_With_NullModel,0,0,0,class<`matrix`>,1
+SKAT,SKAT_With_NullModel,1,0,0,class<`SKAT_NULL_Model`>,1
+SKAT,SKAT_With_NullModel,1,0,1,class<`SKAT_NULL_Model_ChrX`>,1
+SKAT,SKAT_With_NullModel,2,0,0,character,1
+SKAT,SKAT_With_NullModel,3,0,0,character,1
+SKAT,SKAT_With_NullModel,4,0,0,any,1
+SKAT,SKAT_With_NullModel,5,0,0,any,1
+SKAT,SKAT_With_NullModel,6,0,0,any,1
+SKAT,SKAT_With_NullModel,7,0,0,double,1
+SKAT,SKAT_With_NullModel,8,0,0,any,1
+SKAT,SKAT_With_NullModel,9,0,0,any,1
+SKAT,SKAT_With_NullModel,10,0,0,any,1
+SKAT,SKAT_With_NullModel,11,0,0,any,1
+SKAT,SKAT_With_NullModel,12,0,0,any,1
+SKAT,SKAT_With_NullModel,13,0,0,any,1
+SKAT,SKAT_With_NullModel,14,0,0,null,1
+SKAT,SKAT_With_NullModel,14,0,1,list<class<`matrix`> | double[]>,1
+SKAT,SKAT_With_NullModel_ADJ,-1,0,0,list<any>,1
+SKAT,SKAT_With_NullModel_ADJ,0,0,0,class<`matrix`>,1
+SKAT,SKAT_With_NullModel_ADJ,1,0,0,class<`SKAT_NULL_Model_ADJ`>,1
+SKAT,SKAT_With_NullModel_ADJ,2,0,0,character,1
+SKAT,SKAT_With_NullModel_ADJ,3,0,0,character,1
+SKAT,SKAT_With_NullModel_ADJ,4,0,0,double[],1
+SKAT,SKAT_With_NullModel_ADJ,5,0,0,null,1
+SKAT,SKAT_With_NullModel_ADJ,6,0,0,any,1
+SKAT,SKAT_With_NullModel_ADJ,7,0,0,double,1
+SKAT,SKAT_With_NullModel_ADJ,8,0,0,logical,1
+SKAT,SKAT_With_NullModel_ADJ,9,0,0,logical,1
+SKAT,SKAT_With_NullModel_ADJ,10,0,0,double,1
+SKAT,SKAT_With_NullModel_ADJ,11,0,0,double,1
+SKAT,SKAT_With_NullModel_ADJ,12,0,0,double,1
+SKAT,SKAT_With_NullModel_ADJ,13,0,0,null,1
+SKAT,SKAT_With_NullModel_ADJ,14,0,0,null,1
+SKAT,trace.SKAT,-1,0,0,double,1
+SKAT,trace.SKAT,0,0,0,class<`matrix`>,1
+SQUAREM,cyclem1,-1,0,0,list<double[]>,1
+SQUAREM,cyclem1,0,0,0,double[],1
+SQUAREM,cyclem1,1,0,0,class<`function`>,1
+SQUAREM,cyclem1,2,0,0,class<`function`>,1
+SQUAREM,cyclem1,3,0,0,list<double | character>,1
+SQUAREM,cyclem1,4,0,0,...,1
+SQUAREM,cyclem2,-1,0,0,list<double[] | null>,1
+SQUAREM,cyclem2,0,0,0,double[],1
+SQUAREM,cyclem2,1,0,0,class<`function`>,1
+SQUAREM,cyclem2,2,0,0,list<double | character>,1
+SQUAREM,cyclem2,3,0,0,...,1
+SQUAREM,fpiter,-1,0,0,list<double[]>,1
+SQUAREM,fpiter,-1,0,1,list<double[] | null>,1
+SQUAREM,fpiter,0,0,0,double[],1
+SQUAREM,fpiter,1,0,0,class<`function`>,1
+SQUAREM,fpiter,2,0,0,class<`function`>,1
+SQUAREM,fpiter,2,0,1,null,1
+SQUAREM,fpiter,3,0,0,list<any>,1
+SQUAREM,fpiter,4,0,0,...,1
+SQUAREM,squarem,-1,0,0,list<double[]>,1
+SQUAREM,squarem,-1,0,1,list<double[] | null>,1
+SQUAREM,squarem,0,0,0,double[],1
+SQUAREM,squarem,1,0,0,class<`function`>,1
+SQUAREM,squarem,2,0,0,any,1
+SQUAREM,squarem,3,0,0,...,1
+SQUAREM,squarem,4,0,0,list<any>,1
+SQUAREM,squarem1,-1,0,0,list<double[]>,1
+SQUAREM,squarem1,0,0,0,double[],1
+SQUAREM,squarem1,1,0,0,class<`function`>,1
+SQUAREM,squarem1,2,0,0,class<`function`>,1
+SQUAREM,squarem1,3,0,0,...,1
+SQUAREM,squarem1,4,0,0,list<double>,1
+SQUAREM,squarem2,-1,0,0,list<double[] | null>,1
+SQUAREM,squarem2,0,0,0,double[],1
+SQUAREM,squarem2,1,0,0,class<`function`>,1
+SQUAREM,squarem2,2,0,0,...,1
+SQUAREM,squarem2,3,0,0,list<double>,1
+SnowballC,getStemLanguages,-1,0,0,character[],1
+SnowballC,wordStem,-1,0,0,character[],1
+SnowballC,wordStem,-1,0,1,null,1
+SnowballC,wordStem,0,0,0,character[],1
+SnowballC,wordStem,0,0,1,null,1
+SnowballC,wordStem,1,0,0,character,1
+StatMatch,comp.prop,-1,0,0,"list<double[] | class<`table`, `xtabs`>>",1
+StatMatch,comp.prop,0,0,0,"class<`table`, `xtabs`>",1
+StatMatch,comp.prop,1,0,0,"class<`table`, `xtabs`>",1
+StatMatch,comp.prop,2,0,0,integer,1
+StatMatch,comp.prop,3,0,0,any,1
+StatMatch,comp.prop,4,0,0,logical,1
+StatMatch,create.fused,-1,0,0,class<`data.frame`>,1
+StatMatch,create.fused,0,0,0,class<`data.frame`>,1
+StatMatch,create.fused,1,0,0,class<`data.frame`>,1
+StatMatch,create.fused,2,0,0,class<`matrix`>,1
+StatMatch,create.fused,3,0,0,character,1
+StatMatch,create.fused,4,0,0,logical,1
+StatMatch,create.fused,5,0,0,character[],1
+StatMatch,create.fused,5,0,1,null,1
+StatMatch,fact2dummy,-1,0,0,class<`matrix`>,1
+StatMatch,fact2dummy,0,0,0,class<`data.frame`>,1
+StatMatch,fact2dummy,1,0,0,logical,1
+StatMatch,fact2dummy,2,0,0,character,1
+StatMatch,Fbwidths.by.x,-1,0,0,list<class<`data.frame`> | null>,1
+StatMatch,Fbwidths.by.x,0,0,0,"class<`table`, `xtabs`>",1
+StatMatch,Fbwidths.by.x,1,0,0,"class<`table`, `xtabs`>",1
+StatMatch,Fbwidths.by.x,2,0,0,"class<`table`, `xtabs`>",1
+StatMatch,Fbwidths.by.x,3,0,0,character,1
+StatMatch,Fbwidths.by.x,4,0,0,null,1
+StatMatch,Fbwidths.by.x,5,0,0,null,1
+StatMatch,Fbwidths.by.x,6,0,0,...,1
+StatMatch,Frechet.bounds.cat,-1,0,0,list<class<`data.frame`> | double[]>,1
+StatMatch,Frechet.bounds.cat,-1,0,1,list<class<`table`> | double[]>,1
+StatMatch,Frechet.bounds.cat,0,0,0,"class<`table`, `xtabs`>",1
+StatMatch,Frechet.bounds.cat,0,0,1,null,1
+StatMatch,Frechet.bounds.cat,1,0,0,"class<`table`, `xtabs`>",1
+StatMatch,Frechet.bounds.cat,2,0,0,"class<`table`, `xtabs`>",1
+StatMatch,Frechet.bounds.cat,3,0,0,character,1
+StatMatch,Frechet.bounds.cat,4,0,0,logical,1
+StatMatch,Frechet.bounds.cat,5,0,0,double,1
+StatMatch,Frechet.bounds.cat,6,0,0,logical,1
+StatMatch,gower.dist,-1,0,0,class<`matrix`>,1
+StatMatch,gower.dist,0,0,0,class<`data.frame`>,1
+StatMatch,gower.dist,1,0,0,class<`data.frame`>,1
+StatMatch,gower.dist,2,0,0,null,1
+StatMatch,gower.dist,3,0,0,logical,1
+StatMatch,gower.dist,4,0,0,null,1
+StatMatch,gower.dist,4,0,1,double[],1
+StatMatch,harmonize.x,-1,0,0,"list<class<`survey.design`, `survey.design2`> | double[] | class<`call`>>",1
+StatMatch,harmonize.x,0,0,0,"class<`survey.design`, `survey.design2`>",1
+StatMatch,harmonize.x,1,0,0,"class<`survey.design`, `survey.design2`>",1
+StatMatch,harmonize.x,2,0,0,class<`formula`>,1
+StatMatch,harmonize.x,3,0,0,"class<`table`, `xtabs`>",1
+StatMatch,harmonize.x,3,0,1,double[],1
+StatMatch,harmonize.x,3,0,2,null,1
+StatMatch,harmonize.x,4,0,0,character,1
+StatMatch,harmonize.x,5,0,0,...,1
+StatMatch,mahalanobis.dist,-1,0,0,class<`matrix`>,1
+StatMatch,mahalanobis.dist,0,0,0,class<`data.frame`>,1
+StatMatch,mahalanobis.dist,1,0,0,class<`data.frame`>,1
+StatMatch,mahalanobis.dist,1,0,1,null,1
+StatMatch,mahalanobis.dist,2,0,0,class<`matrix`>,1
+StatMatch,mahalanobis.dist,2,0,1,null,1
+StatMatch,NND.hotdeck,-1,0,0,list<class<`matrix`> | double[] | class<`call`>>,1
+StatMatch,NND.hotdeck,0,0,0,class<`data.frame`>,1
+StatMatch,NND.hotdeck,1,0,0,class<`data.frame`>,1
+StatMatch,NND.hotdeck,2,0,0,character[],1
+StatMatch,NND.hotdeck,3,0,0,character,1
+StatMatch,NND.hotdeck,3,0,1,null,1
+StatMatch,NND.hotdeck,4,0,0,character,1
+StatMatch,NND.hotdeck,5,0,0,logical,1
+StatMatch,NND.hotdeck,6,0,0,character,1
+StatMatch,NND.hotdeck,7,0,0,double,1
+StatMatch,pBayes,-1,0,0,"list<double[] | class<`array`> | class<`table`, `xtabs`>>",1
+StatMatch,pBayes,-1,0,1,"list<double[] | class<`table`, `xtabs`>>",1
+StatMatch,pBayes,0,0,0,"class<`table`, `xtabs`>",1
+StatMatch,pBayes,1,0,0,character,1
+StatMatch,pBayes,2,0,0,null,1
+StatMatch,RANDwNND.hotdeck,-1,0,0,list<class<`matrix`> | double[] | class<`call`>>,1
+StatMatch,RANDwNND.hotdeck,-1,0,1,list<class<`matrix`> | integer[] | class<`call`>>,1
+StatMatch,RANDwNND.hotdeck,0,0,0,class<`data.frame`>,1
+StatMatch,RANDwNND.hotdeck,1,0,0,class<`data.frame`>,1
+StatMatch,RANDwNND.hotdeck,2,0,0,character[],1
+StatMatch,RANDwNND.hotdeck,3,0,0,character[],1
+StatMatch,RANDwNND.hotdeck,4,0,0,character,1
+StatMatch,RANDwNND.hotdeck,5,0,0,character,1
+StatMatch,RANDwNND.hotdeck,6,0,0,null,1
+StatMatch,RANDwNND.hotdeck,6,0,1,double,1
+StatMatch,RANDwNND.hotdeck,7,0,0,null,1
+StatMatch,RANDwNND.hotdeck,7,0,1,character,1
+StatMatch,rankNND.hotdeck,-1,0,0,list<class<`matrix`> | double[] | class<`call`>>,1
+StatMatch,rankNND.hotdeck,0,0,0,class<`data.frame`>,1
+StatMatch,rankNND.hotdeck,1,0,0,class<`data.frame`>,1
+StatMatch,rankNND.hotdeck,2,0,0,character,1
+StatMatch,rankNND.hotdeck,3,0,0,character,1
+StatMatch,rankNND.hotdeck,4,0,0,character,1
+StatMatch,rankNND.hotdeck,5,0,0,character,1
+StatMatch,rankNND.hotdeck,5,0,1,null,1
+StatMatch,rankNND.hotdeck,6,0,0,character,1
+StatMatch,rankNND.hotdeck,6,0,1,null,1
+StatMatch,rankNND.hotdeck,7,0,0,logical,1
+StatMatch,selMtc.by.unc,-1,0,0,list<double[] | class<`data.frame`> | list<character[]>>,1
+StatMatch,selMtc.by.unc,0,0,0,"class<`table`, `xtabs`>",1
+StatMatch,selMtc.by.unc,1,0,0,"class<`table`, `xtabs`>",1
+StatMatch,selMtc.by.unc,2,0,0,"class<`table`, `xtabs`>",1
+StatMatch,selMtc.by.unc,3,0,0,double,1
+StatMatch,selMtc.by.unc,4,0,0,null,1
+StatMatch,selMtc.by.unc,5,0,0,null,1
+StatMatch,selMtc.by.unc,6,0,0,logical,1
+TSP,as.ATSP,-1,0,0,"class<`ATSP`, `ATSP`, `matrix`>",1
+TSP,as.ATSP,-1,0,1,"class<`ATSP`, `matrix`>",1
+TSP,as.ATSP,0,0,0,class<`dist`>,1
+TSP,as.ATSP,0,0,1,"class<`TSP`, `dist`>",1
+TSP,as.ATSP,0,0,2,class<`matrix`>,1
+TSP,as.ATSP.dist,-1,0,0,"class<`ATSP`, `ATSP`, `matrix`>",1
+TSP,as.ATSP.dist,0,0,0,class<`dist`>,1
+TSP,as.ATSP.dist,0,0,1,"class<`TSP`, `dist`>",1
+TSP,as.ATSP.matrix,-1,0,0,"class<`ATSP`, `matrix`>",1
+TSP,as.ATSP.matrix,0,0,0,class<`matrix`>,1
+TSP,as.ETSP,-1,0,0,"class<`ETSP`, `matrix`>",1
+TSP,as.ETSP,0,0,0,class<`data.frame`>,1
+TSP,as.ETSP,0,0,1,class<`matrix`>,1
+TSP,as.ETSP.data.frame,-1,0,0,"class<`ETSP`, `matrix`>",1
+TSP,as.ETSP.data.frame,0,0,0,class<`data.frame`>,1
+TSP,as.ETSP.matrix,-1,0,0,"class<`ETSP`, `matrix`>",1
+TSP,as.ETSP.matrix,0,0,0,class<`matrix`>,1
+TSP,as.matrix.ATSP,-1,0,0,class<`matrix`>,1
+TSP,as.matrix.ATSP,0,0,0,"class<`ATSP`, `matrix`>",1
+TSP,as.matrix.ATSP,0,0,1,"class<`ATSP`, `ATSP`, `matrix`>",1
+TSP,as.matrix.ATSP,1,0,0,...,1
+TSP,as.matrix.ETSP,-1,0,0,class<`matrix`>,1
+TSP,as.matrix.ETSP,0,0,0,"class<`ETSP`, `matrix`>",1
+TSP,as.matrix.ETSP,1,0,0,...,1
+TSP,as.TOUR,-1,0,0,"class<`TOUR`, `integer`>",1
+TSP,as.TOUR,0,0,0,integer[],1
+TSP,as.TOUR.integer,-1,0,0,"class<`TOUR`, `integer`>",1
+TSP,as.TOUR.integer,0,0,0,integer[],1
+TSP,as.TSP,-1,0,0,"class<`TSP`, `dist`>",1
+TSP,as.TSP,0,0,0,class<`dist`>,1
+TSP,as.TSP,0,0,1,class<`matrix`>,1
+TSP,as.TSP,0,0,2,"class<`ATSP`, `matrix`>",1
+TSP,as.TSP,0,0,3,"class<`ETSP`, `matrix`>",1
+TSP,as.TSP.dist,-1,0,0,"class<`TSP`, `dist`>",1
+TSP,as.TSP.dist,0,0,0,class<`dist`>,1
+TSP,as.TSP.ETSP,-1,0,0,"class<`TSP`, `dist`>",1
+TSP,as.TSP.ETSP,0,0,0,"class<`ETSP`, `matrix`>",1
+TSP,as.TSP.matrix,-1,0,0,"class<`TSP`, `dist`>",1
+TSP,as.TSP.matrix,0,0,0,class<`matrix`>,1
+TSP,as.TSP.matrix,0,0,1,"class<`ATSP`, `matrix`>",1
+TSP,ATSP,-1,0,0,"class<`ATSP`, `ATSP`, `matrix`>",1
+TSP,ATSP,-1,0,1,"class<`ATSP`, `matrix`>",1
+TSP,ATSP,0,0,0,class<`dist`>,1
+TSP,ATSP,0,0,1,"class<`TSP`, `dist`>",1
+TSP,ATSP,0,0,2,class<`matrix`>,1
+TSP,ATSP,1,0,0,null,1
+TSP,ATSP,2,0,0,null,1
+TSP,cut_tour,-1,0,0,integer[],1
+TSP,cut_tour,-1,0,1,list<integer[]>,1
+TSP,cut_tour,0,0,0,"class<`TOUR`, `integer`>",1
+TSP,cut_tour,1,0,0,integer,1
+TSP,cut_tour,1,0,1,character[],1
+TSP,cut_tour,2,0,0,logical,1
+TSP,cut_tour.TOUR,-1,0,0,integer[],1
+TSP,cut_tour.TOUR,-1,0,1,list<integer[]>,1
+TSP,cut_tour.TOUR,0,0,0,"class<`TOUR`, `integer`>",1
+TSP,cut_tour.TOUR,1,0,0,integer,1
+TSP,cut_tour.TOUR,1,0,1,character[],1
+TSP,cut_tour.TOUR,2,0,0,logical,1
+TSP,ETSP,-1,0,0,"class<`ETSP`, `matrix`>",1
+TSP,ETSP,0,0,0,class<`data.frame`>,1
+TSP,ETSP,0,0,1,class<`matrix`>,1
+TSP,ETSP,1,0,0,null,1
+TSP,.get_parameters,-1,0,0,list<integer>,1
+TSP,.get_parameters,-1,0,1,"list<class<`TOUR`, `integer`> | double>",1
+TSP,.get_parameters,-1,0,2,list<integer[] | double>,1
+TSP,.get_parameters,-1,0,3,list<null | double>,1
+TSP,.get_parameters,0,0,0,list<any>,1
+TSP,.get_parameters,1,0,0,list<any>,1
+TSP,image.ATSP,-1,0,0,null,1
+TSP,image.ATSP,0,0,0,"class<`ATSP`, `matrix`>",1
+TSP,image.ATSP,1,0,0,"class<`TOUR`, `integer`>",1
+TSP,image.ATSP,2,0,0,character[],1
+TSP,image.ATSP,3,0,0,...,1
+TSP,image.TSP,-1,0,0,null,1
+TSP,image.TSP,0,0,0,"class<`TSP`, `dist`>",1
+TSP,image.TSP,1,0,0,any,1
+TSP,image.TSP,2,0,0,character[],1
+TSP,image.TSP,3,0,0,...,1
+TSP,insert_dummy,-1,0,0,"class<`ATSP`, `matrix`>",1
+TSP,insert_dummy,-1,0,1,"class<`TSP`, `dist`>",1
+TSP,insert_dummy,0,0,0,"class<`ATSP`, `matrix`>",1
+TSP,insert_dummy,0,0,1,"class<`ATSP`, `ATSP`, `matrix`>",1
+TSP,insert_dummy,0,0,2,"class<`TSP`, `dist`>",1
+TSP,insert_dummy,1,0,0,double,1
+TSP,insert_dummy,2,0,0,double,1
+TSP,insert_dummy,3,0,0,any,1
+TSP,insert_dummy,4,0,0,character,1
+TSP,insert_dummy.ATSP,-1,0,0,"class<`ATSP`, `matrix`>",1
+TSP,insert_dummy.ATSP,0,0,0,"class<`ATSP`, `matrix`>",1
+TSP,insert_dummy.ATSP,0,0,1,"class<`ATSP`, `ATSP`, `matrix`>",1
+TSP,insert_dummy.ATSP,1,0,0,double,1
+TSP,insert_dummy.ATSP,2,0,0,double,1
+TSP,insert_dummy.ATSP,3,0,0,any,1
+TSP,insert_dummy.ATSP,4,0,0,character,1
+TSP,insert_dummy.TSP,-1,0,0,"class<`TSP`, `dist`>",1
+TSP,insert_dummy.TSP,0,0,0,"class<`TSP`, `dist`>",1
+TSP,insert_dummy.TSP,1,0,0,double,1
+TSP,insert_dummy.TSP,2,0,0,double,1
+TSP,insert_dummy.TSP,3,0,0,double,1
+TSP,insert_dummy.TSP,4,0,0,character,1
+TSP,labels.ATSP,-1,0,0,character[],1
+TSP,labels.ATSP,0,0,0,"class<`ATSP`, `ATSP`, `matrix`>",1
+TSP,labels.ATSP,0,0,1,"class<`ATSP`, `matrix`>",1
+TSP,labels.ATSP,1,0,0,...,1
+TSP,labels.ETSP,-1,0,0,character[],1
+TSP,labels.ETSP,0,0,0,"class<`ETSP`, `matrix`>",1
+TSP,labels.ETSP,1,0,0,...,1
+TSP,labels.TSP,-1,0,0,character[],1
+TSP,labels.TSP,-1,0,1,integer[],1
+TSP,labels.TSP,0,0,0,"class<`TSP`, `dist`>",1
+TSP,labels.TSP,1,0,0,...,1
+TSP,n_of_cities,-1,0,0,integer,1
+TSP,n_of_cities,0,0,0,"class<`ATSP`, `ATSP`, `matrix`>",1
+TSP,n_of_cities,0,0,1,"class<`ATSP`, `matrix`>",1
+TSP,n_of_cities,0,0,2,class<`dist`>,1
+TSP,n_of_cities,0,0,3,"class<`ETSP`, `matrix`>",1
+TSP,n_of_cities,0,0,4,"class<`TSP`, `dist`>",1
+TSP,n_of_cities.ATSP,-1,0,0,integer,1
+TSP,n_of_cities.ATSP,0,0,0,"class<`ATSP`, `ATSP`, `matrix`>",1
+TSP,n_of_cities.ATSP,0,0,1,"class<`ATSP`, `matrix`>",1
+TSP,n_of_cities.ATSP,0,0,2,"class<`ETSP`, `matrix`>",1
+TSP,n_of_cities.default,-1,0,0,integer,1
+TSP,n_of_cities.default,0,0,0,class<`dist`>,1
+TSP,n_of_cities.default,0,0,1,"class<`TSP`, `dist`>",1
+TSP,n_of_cities.ETSP,-1,0,0,integer,1
+TSP,n_of_cities.ETSP,0,0,0,"class<`ATSP`, `ATSP`, `matrix`>",1
+TSP,n_of_cities.ETSP,0,0,1,"class<`ATSP`, `matrix`>",1
+TSP,n_of_cities.ETSP,0,0,2,"class<`ETSP`, `matrix`>",1
+TSP,n_of_cities.TSP,-1,0,0,integer,1
+TSP,n_of_cities.TSP,0,0,0,class<`dist`>,1
+TSP,n_of_cities.TSP,0,0,1,"class<`TSP`, `dist`>",1
+TSP,plot.ETSP,-1,0,0,null,1
+TSP,plot.ETSP,0,0,0,"class<`ETSP`, `matrix`>",1
+TSP,plot.ETSP,1,0,0,"class<`TOUR`, `integer`>",1
+TSP,plot.ETSP,2,0,0,null,1
+TSP,plot.ETSP,3,0,0,double,1
+TSP,plot.ETSP,4,0,0,character,1
+TSP,plot.ETSP,4,0,1,double,1
+TSP,plot.ETSP,5,0,0,...,1
+TSP,read_TSPLIB,-1,0,0,"class<`ATSP`, `matrix`>",1
+TSP,read_TSPLIB,-1,0,1,"class<`ETSP`, `matrix`>",1
+TSP,read_TSPLIB,-1,0,2,"class<`TSP`, `dist`>",1
+TSP,read_TSPLIB,0,0,0,character,1
+TSP,read_TSPLIB,1,0,0,double,1
+TSP,reformulate_ATSP_as_TSP,-1,0,0,"class<`TSP`, `dist`>",1
+TSP,reformulate_ATSP_as_TSP,0,0,0,"class<`ATSP`, `ATSP`, `matrix`>",1
+TSP,reformulate_ATSP_as_TSP,1,0,0,double,1
+TSP,reformulate_ATSP_as_TSP,2,0,0,double,1
+TSP,.replaceInf,-1,0,0,"class<`ATSP`, `ATSP`, `matrix`>",1
+TSP,.replaceInf,-1,0,1,"class<`ATSP`, `matrix`>",1
+TSP,.replaceInf,-1,0,2,"class<`TSP`, `dist`>",1
+TSP,.replaceInf,0,0,0,"class<`ATSP`, `ATSP`, `matrix`>",1
+TSP,.replaceInf,0,0,1,"class<`ATSP`, `matrix`>",1
+TSP,.replaceInf,0,0,2,"class<`TSP`, `dist`>",1
+TSP,.replaceInf,1,0,0,any,1
+TSP,.replaceInf,2,0,0,any,1
+TSP,.solve_TSP,-1,0,0,any,1
+TSP,.solve_TSP,0,0,0,"class<`ATSP`, `ATSP`, `matrix`>",1
+TSP,.solve_TSP,0,0,1,"class<`ATSP`, `matrix`>",1
+TSP,.solve_TSP,0,0,2,"class<`TSP`, `dist`>",1
+TSP,.solve_TSP,1,0,0,character,1
+TSP,.solve_TSP,1,0,1,null,1
+TSP,.solve_TSP,2,0,0,null,1
+TSP,.solve_TSP,2,0,1,"list<class<`TOUR`, `integer`>>",1
+TSP,.solve_TSP,3,0,0,...,1
+TSP,solve_TSP,-1,0,0,any,1
+TSP,solve_TSP,0,0,0,"class<`ATSP`, `ATSP`, `matrix`>",1
+TSP,solve_TSP,0,0,1,"class<`ATSP`, `matrix`>",1
+TSP,solve_TSP,0,0,2,"class<`ETSP`, `matrix`>",1
+TSP,solve_TSP,0,0,3,"class<`TSP`, `dist`>",1
+TSP,solve_TSP,1,0,0,character,1
+TSP,solve_TSP,1,0,1,null,1
+TSP,solve_TSP,2,0,0,null,1
+TSP,solve_TSP,2,0,1,"list<class<`TOUR`, `integer`>>",1
+TSP,solve_TSP,3,0,0,...,1
+TSP,solve_TSP.ATSP,-1,0,0,"class<`TOUR`, `integer`>",1
+TSP,solve_TSP.ATSP,0,0,0,"class<`ATSP`, `ATSP`, `matrix`>",1
+TSP,solve_TSP.ATSP,0,0,1,"class<`ATSP`, `matrix`>",1
+TSP,solve_TSP.ATSP,1,0,0,character,1
+TSP,solve_TSP.ATSP,2,0,0,null,1
+TSP,solve_TSP.ATSP,2,0,1,"list<class<`TOUR`, `integer`>>",1
+TSP,solve_TSP.ATSP,3,0,0,logical,1
+TSP,solve_TSP.ATSP,4,0,0,...,1
+TSP,solve_TSP.ETSP,-1,0,0,"class<`TOUR`, `integer`>",1
+TSP,solve_TSP.ETSP,0,0,0,"class<`ETSP`, `matrix`>",1
+TSP,solve_TSP.ETSP,1,0,0,character,1
+TSP,solve_TSP.ETSP,1,0,1,null,1
+TSP,solve_TSP.ETSP,2,0,0,null,1
+TSP,solve_TSP.ETSP,3,0,0,...,1
+TSP,solve_TSP.TSP,-1,0,0,any,1
+TSP,solve_TSP.TSP,0,0,0,"class<`TSP`, `dist`>",1
+TSP,solve_TSP.TSP,1,0,0,character,1
+TSP,solve_TSP.TSP,1,0,1,null,1
+TSP,solve_TSP.TSP,2,0,0,null,1
+TSP,solve_TSP.TSP,3,0,0,...,1
+TSP,TOUR,-1,0,0,"class<`TOUR`, `integer`>",1
+TSP,TOUR,0,0,0,integer[],1
+TSP,TOUR,0,0,1,"class<`TOUR`, `integer`>",1
+TSP,TOUR,1,0,0,null,1
+TSP,TOUR,1,0,1,character,1
+TSP,TOUR,2,0,0,null,1
+TSP,TOUR,2,0,1,"class<`ATSP`, `ATSP`, `matrix`>",1
+TSP,TOUR,2,0,2,"class<`ATSP`, `matrix`>",1
+TSP,TOUR,2,0,3,"class<`TSP`, `dist`>",1
+TSP,tour_length,-1,0,0,double,1
+TSP,tour_length,-1,0,1,null,1
+TSP,tour_length,0,0,0,"class<`TOUR`, `integer`>",1
+TSP,tour_length,0,0,1,"class<`ATSP`, `ATSP`, `matrix`>",1
+TSP,tour_length,0,0,2,"class<`ATSP`, `matrix`>",1
+TSP,tour_length,0,0,3,"class<`ETSP`, `matrix`>",1
+TSP,tour_length,0,0,4,"class<`TSP`, `dist`>",1
+TSP,tour_length,1,0,0,...,1
+TSP,tour_length.ATSP,-1,0,0,double,1
+TSP,tour_length.ATSP,0,0,0,"class<`ATSP`, `ATSP`, `matrix`>",1
+TSP,tour_length.ATSP,0,0,1,"class<`ATSP`, `matrix`>",1
+TSP,tour_length.ATSP,1,0,0,any,1
+TSP,tour_length.ATSP,2,0,0,...,1
+TSP,tour_length.ETSP,-1,0,0,double,1
+TSP,tour_length.ETSP,0,0,0,"class<`ETSP`, `matrix`>",1
+TSP,tour_length.ETSP,1,0,0,any,1
+TSP,tour_length.ETSP,2,0,0,...,1
+TSP,tour_length.TOUR,-1,0,0,double,1
+TSP,tour_length.TOUR,-1,0,1,null,1
+TSP,tour_length.TOUR,0,0,0,"class<`TOUR`, `integer`>",1
+TSP,tour_length.TOUR,1,0,0,"class<`ATSP`, `ATSP`, `matrix`>",1
+TSP,tour_length.TOUR,1,0,1,"class<`ATSP`, `matrix`>",1
+TSP,tour_length.TOUR,1,0,2,"class<`TSP`, `dist`>",1
+TSP,tour_length.TOUR,1,0,3,"class<`ETSP`, `matrix`>",1
+TSP,tour_length.TOUR,1,0,4,null,1
+TSP,tour_length.TOUR,2,0,0,...,1
+TSP,tour_length.TSP,-1,0,0,double,1
+TSP,tour_length.TSP,0,0,0,"class<`TSP`, `dist`>",1
+TSP,tour_length.TSP,1,0,0,any,1
+TSP,tour_length.TSP,2,0,0,...,1
+TSP,TSP,-1,0,0,"class<`TSP`, `dist`>",1
+TSP,TSP,0,0,0,class<`dist`>,1
+TSP,TSP,0,0,1,class<`matrix`>,1
+TSP,TSP,0,0,2,"class<`ATSP`, `matrix`>",1
+TSP,TSP,1,0,0,null,1
+TSP,TSP,1,0,1,class<`factor`>,1
+TSP,TSP,2,0,0,null,1
+TSP,tsp_insertion,-1,0,0,integer[],1
+TSP,tsp_insertion,0,0,0,"class<`ATSP`, `matrix`>",1
+TSP,tsp_insertion,0,0,1,"class<`TSP`, `dist`>",1
+TSP,tsp_insertion,1,0,0,character,1
+TSP,tsp_insertion,2,0,0,list<any>,1
+TSP,tsp_insertion_arbitrary,-1,0,0,integer[],1
+TSP,tsp_insertion_arbitrary,0,0,0,"class<`ATSP`, `matrix`>",1
+TSP,tsp_insertion_arbitrary,0,0,1,"class<`TSP`, `dist`>",1
+TSP,tsp_insertion_arbitrary,1,0,0,list<any>,1
+TSP,tsp_nn,-1,0,0,integer[],1
+TSP,tsp_nn,0,0,0,"class<`ATSP`, `ATSP`, `matrix`>",1
+TSP,tsp_nn,0,0,1,"class<`ATSP`, `matrix`>",1
+TSP,tsp_nn,0,0,2,"class<`TSP`, `dist`>",1
+TSP,tsp_nn,1,0,0,list<any>,1
+TSP,tsp_repetitive_nn,-1,0,0,integer[],1
+TSP,tsp_repetitive_nn,0,0,0,"class<`ATSP`, `matrix`>",1
+TSP,tsp_repetitive_nn,0,0,1,"class<`TSP`, `dist`>",1
+TSP,tsp_repetitive_nn,1,0,0,any,1
+TSP,tsp_two_opt,-1,0,0,integer[],1
+TSP,tsp_two_opt,0,0,0,"class<`ATSP`, `ATSP`, `matrix`>",1
+TSP,tsp_two_opt,0,0,1,"class<`ATSP`, `matrix`>",1
+TSP,tsp_two_opt,0,0,2,"class<`TSP`, `dist`>",1
+TSP,tsp_two_opt,1,0,0,list<any>,1
+TSP,write_TSPLIB,-1,0,0,integer,1
+TSP,write_TSPLIB,0,0,0,"class<`ATSP`, `ATSP`, `matrix`>",1
+TSP,write_TSPLIB,0,0,1,"class<`ETSP`, `matrix`>",1
+TSP,write_TSPLIB,0,0,2,"class<`TSP`, `dist`>",1
+TSP,write_TSPLIB,1,0,0,character,1
+TSP,write_TSPLIB,2,0,0,double,1
+TSP,write_TSPLIB,3,0,0,null,1
+TSP,write_TSPLIB,4,0,0,null,1
+TSP,write_TSPLIB.ATSP,-1,0,0,integer,1
+TSP,write_TSPLIB.ATSP,0,0,0,"class<`ATSP`, `ATSP`, `matrix`>",1
+TSP,write_TSPLIB.ATSP,1,0,0,character,1
+TSP,write_TSPLIB.ATSP,2,0,0,double,1
+TSP,write_TSPLIB.ATSP,3,0,0,null,1
+TSP,write_TSPLIB.ATSP,4,0,0,null,1
+TSP,write_TSPLIB.ETSP,-1,0,0,integer,1
+TSP,write_TSPLIB.ETSP,0,0,0,"class<`ETSP`, `matrix`>",1
+TSP,write_TSPLIB.ETSP,1,0,0,character,1
+TSP,write_TSPLIB.ETSP,2,0,0,double,1
+TSP,write_TSPLIB.ETSP,3,0,0,null,1
+TSP,write_TSPLIB.ETSP,4,0,0,null,1
+TSP,write_TSPLIB.TSP,-1,0,0,integer,1
+TSP,write_TSPLIB.TSP,0,0,0,"class<`TSP`, `dist`>",1
+TSP,write_TSPLIB.TSP,1,0,0,character,1
+TSP,write_TSPLIB.TSP,2,0,0,double,1
+TSP,write_TSPLIB.TSP,3,0,0,null,1
+TSP,write_TSPLIB.TSP,4,0,0,null,1
+TTR,ADX,-1,0,0,class<`matrix`>,1
+TTR,ADX,0,0,0,class<`data.frame`>,1
+TTR,ADX,0,0,1,class<`matrix`>,1
+TTR,ADX,1,0,0,double,1
+TTR,ADX,2,0,0,any,1
+TTR,ADX,3,0,0,...,1
+TTR,ALMA,-1,0,0,double[],1
+TTR,ALMA,0,0,0,double[],1
+TTR,ALMA,1,0,0,double,1
+TTR,ALMA,2,0,0,double,1
+TTR,ALMA,3,0,0,double,1
+TTR,ALMA,4,0,0,...,1
+TTR,aroon,-1,0,0,class<`matrix`>,1
+TTR,aroon,0,0,0,class<`data.frame`>,1
+TTR,aroon,0,0,1,class<`matrix`>,1
+TTR,aroon,1,0,0,double,1
+TTR,ATR,-1,0,0,any,1
+TTR,ATR,0,0,0,class<`data.frame`>,1
+TTR,ATR,0,0,1,class<`matrix`>,1
+TTR,ATR,0,0,2,"class<`xts`, `zoo`>",1
+TTR,ATR,1,0,0,double,1
+TTR,ATR,2,0,0,any,1
+TTR,ATR,3,0,0,...,1
+TTR,BBands,-1,0,0,any,1
+TTR,BBands,0,0,0,class<`data.frame`>,1
+TTR,BBands,0,0,1,double[],1
+TTR,BBands,1,0,0,double,1
+TTR,BBands,2,0,0,any,1
+TTR,BBands,3,0,0,double,1
+TTR,BBands,4,0,0,...,1
+TTR,CCI,-1,0,0,class<`matrix`>,1
+TTR,CCI,-1,0,1,^double[],1
+TTR,CCI,0,0,0,class<`matrix`>,1
+TTR,CCI,0,0,1,class<`data.frame`>,1
+TTR,CCI,1,0,0,double,1
+TTR,CCI,2,0,0,any,1
+TTR,CCI,3,0,0,double,1
+TTR,CCI,4,0,0,...,1
+TTR,chaikinAD,-1,0,0,double[],1
+TTR,chaikinAD,0,0,0,class<`data.frame`>,1
+TTR,chaikinAD,1,0,0,double[],1
+TTR,chaikinVolatility,-1,0,0,^double[],1
+TTR,chaikinVolatility,0,0,0,class<`data.frame`>,1
+TTR,chaikinVolatility,0,0,1,class<`matrix`>,1
+TTR,chaikinVolatility,1,0,0,double,1
+TTR,chaikinVolatility,2,0,0,any,1
+TTR,chaikinVolatility,3,0,0,...,1
+TTR,CLV,-1,0,0,class<`data.frame`>,1
+TTR,CLV,-1,0,1,class<`matrix`>,1
+TTR,CLV,-1,0,2,^double[],1
+TTR,CLV,0,0,0,"class<`xts`, `zoo`>",1
+TTR,CLV,0,0,1,class<`matrix`>,1
+TTR,CLV,0,0,2,class<`data.frame`>,1
+TTR,CMF,-1,0,0,any,1
+TTR,CMF,0,0,0,class<`data.frame`>,1
+TTR,CMF,1,0,0,^double[],1
+TTR,CMF,2,0,0,double,1
+TTR,CMO,-1,0,0,any,1
+TTR,CMO,0,0,0,^double[],1
+TTR,CMO,1,0,0,double,1
+TTR,DEMA,-1,0,0,any,1
+TTR,DEMA,0,0,0,^double[],1
+TTR,DEMA,0,0,1,class<`data.frame`>,1
+TTR,DEMA,1,0,0,double,1
+TTR,DEMA,2,0,0,double,1
+TTR,DEMA,3,0,0,logical,1
+TTR,DEMA,4,0,0,null,1
+TTR,DonchianChannel,-1,0,0,class<`matrix`>,1
+TTR,DonchianChannel,0,0,0,class<`data.frame`>,1
+TTR,DonchianChannel,1,0,0,double,1
+TTR,DonchianChannel,2,0,0,logical,1
+TTR,DPO,-1,0,0,any,1
+TTR,DPO,0,0,0,^double[],1
+TTR,DPO,1,0,0,double,1
+TTR,DPO,2,0,0,any,1
+TTR,DPO,3,0,0,any,1
+TTR,DPO,4,0,0,logical,1
+TTR,DPO,5,0,0,...,1
+TTR,DVI,-1,0,0,class<`matrix`>,1
+TTR,DVI,0,0,0,double[],1
+TTR,DVI,1,0,0,double,1
+TTR,DVI,2,0,0,double[],1
+TTR,DVI,3,0,0,double,1
+TTR,DVI,4,0,0,double[],1
+TTR,DVI,5,0,0,double[],1
+TTR,DVI,6,0,0,double,1
+TTR,EMA,-1,0,0,any,1
+TTR,EMA,0,0,0,class<`matrix`>,1
+TTR,EMA,0,0,1,"class<`xts`, `zoo`>",1
+TTR,EMA,0,0,2,^double[],1
+TTR,EMA,0,0,3,class<`data.frame`>,1
+TTR,EMA,1,0,0,double,1
+TTR,EMA,2,0,0,logical,1
+TTR,EMA,3,0,0,null,1
+TTR,EMA,3,0,1,double,1
+TTR,EMA,4,0,0,...,1
+TTR,EMV,-1,0,0,class<`matrix`>,1
+TTR,EMV,0,0,0,class<`data.frame`>,1
+TTR,EMV,1,0,0,double[],1
+TTR,EMV,2,0,0,double,1
+TTR,EMV,3,0,0,any,1
+TTR,EMV,4,0,0,double,1
+TTR,EMV,5,0,0,...,1
+TTR,EVWMA,-1,0,0,any,1
+TTR,EVWMA,0,0,0,^double[],1
+TTR,EVWMA,0,0,1,class<`data.frame`>,1
+TTR,EVWMA,1,0,0,any,1
+TTR,EVWMA,2,0,0,any,1
+TTR,EVWMA,3,0,0,...,1
+TTR,GMMA,-1,0,0,class<`matrix`>,1
+TTR,GMMA,0,0,0,double[],1
+TTR,GMMA,1,0,0,double[],1
+TTR,GMMA,2,0,0,double[],1
+TTR,GMMA,3,0,0,any,1
+TTR,HMA,-1,0,0,^double[],1
+TTR,HMA,0,0,0,double[],1
+TTR,HMA,1,0,0,double,1
+TTR,HMA,2,0,0,...,1
+TTR,KST,-1,0,0,class<`matrix`>,1
+TTR,KST,0,0,0,double[],1
+TTR,KST,1,0,0,double[],1
+TTR,KST,2,0,0,double[],1
+TTR,KST,3,0,0,double,1
+TTR,KST,4,0,0,any,1
+TTR,KST,5,0,0,integer[],1
+TTR,KST,6,0,0,...,1
+TTR,MACD,-1,0,0,any,1
+TTR,MACD,0,0,0,^double[],1
+TTR,MACD,1,0,0,double,1
+TTR,MACD,2,0,0,double,1
+TTR,MACD,3,0,0,double,1
+TTR,MACD,4,0,0,any,1
+TTR,MACD,5,0,0,logical,1
+TTR,MACD,6,0,0,...,1
+TTR,MFI,-1,0,0,any,1
+TTR,MFI,0,0,0,class<`data.frame`>,1
+TTR,MFI,1,0,0,^double[],1
+TTR,MFI,2,0,0,double,1
+TTR,momentum,-1,0,0,class<`matrix`>,1
+TTR,momentum,-1,0,1,^double[],1
+TTR,momentum,0,0,0,"class<`xts`, `zoo`>",1
+TTR,momentum,0,0,1,class<`matrix`>,1
+TTR,momentum,0,0,2,double[],1
+TTR,momentum,1,0,0,double,1
+TTR,momentum,2,0,0,logical,1
+TTR,naCheck,-1,0,0,any,1
+TTR,naCheck,0,0,0,class<`matrix`>,1
+TTR,naCheck,0,0,1,"class<`xts`, `zoo`>",1
+TTR,naCheck,0,0,2,^double[],1
+TTR,naCheck,1,0,0,any,1
+TTR,OBV,-1,0,0,double[],1
+TTR,OBV,0,0,0,double[],1
+TTR,OBV,1,0,0,double[],1
+TTR,PBands,-1,0,0,class<`matrix`>,1
+TTR,PBands,0,0,0,double[],1
+TTR,PBands,1,0,0,double,1
+TTR,PBands,2,0,0,character,1
+TTR,PBands,3,0,0,double,1
+TTR,PBands,4,0,0,...,1
+TTR,PBands,5,0,0,double,1
+TTR,PBands,6,0,0,logical,1
+TTR,PBands,7,0,0,logical,1
+TTR,ROC,-1,0,0,class<`data.frame`>,1
+TTR,ROC,-1,0,1,^double[],1
+TTR,ROC,0,0,0,"class<`xts`, `zoo`>",1
+TTR,ROC,0,0,1,^double[],1
+TTR,ROC,1,0,0,double,1
+TTR,ROC,2,0,0,character[],1
+TTR,ROC,3,0,0,logical,1
+TTR,RSI,-1,0,0,any,1
+TTR,RSI,0,0,0,^double[],1
+TTR,RSI,1,0,0,double,1
+TTR,RSI,2,0,0,any,1
+TTR,RSI,3,0,0,...,1
+TTR,runCor,-1,0,0,any,1
+TTR,runCor,0,0,0,^double[],1
+TTR,runCor,0,0,1,class<`data.frame`>,1
+TTR,runCor,1,0,0,any,1
+TTR,runCor,2,0,0,any,1
+TTR,runCor,3,0,0,character,1
+TTR,runCor,4,0,0,logical,1
+TTR,runCor,5,0,0,logical,1
+TTR,runCov,-1,0,0,any,1
+TTR,runCov,0,0,0,class<`matrix`>,1
+TTR,runCov,0,0,1,^double[],1
+TTR,runCov,0,0,2,class<`data.frame`>,1
+TTR,runCov,1,0,0,any,1
+TTR,runCov,2,0,0,any,1
+TTR,runCov,3,0,0,any,1
+TTR,runCov,4,0,0,any,1
+TTR,runCov,5,0,0,any,1
+TTR,runMAD,-1,0,0,any,1
+TTR,runMAD,0,0,0,"class<`xts`, `zoo`>",1
+TTR,runMAD,0,0,1,^double[],1
+TTR,runMAD,0,0,2,class<`data.frame`>,1
+TTR,runMAD,1,0,0,double,1
+TTR,runMAD,2,0,0,class<`matrix`>,1
+TTR,runMAD,2,0,1,null,1
+TTR,runMAD,2,0,2,^double[],1
+TTR,runMAD,3,0,0,character,1
+TTR,runMAD,4,0,0,double,1
+TTR,runMAD,5,0,0,character,1
+TTR,runMAD,6,0,0,logical,1
+TTR,runMax,-1,0,0,any,1
+TTR,runMax,0,0,0,"class<`xts`, `zoo`>",1
+TTR,runMax,0,0,1,class<`matrix`>,1
+TTR,runMax,0,0,2,^double[],1
+TTR,runMax,0,0,3,class<`data.frame`>,1
+TTR,runMax,1,0,0,double,1
+TTR,runMax,2,0,0,logical,1
+TTR,runMean,-1,0,0,any,1
+TTR,runMean,0,0,0,class<`matrix`>,1
+TTR,runMean,0,0,1,"class<`xts`, `zoo`>",1
+TTR,runMean,0,0,2,^double[],1
+TTR,runMean,0,0,3,class<`data.frame`>,1
+TTR,runMean,1,0,0,double,1
+TTR,runMean,2,0,0,logical,1
+TTR,runMedian,-1,0,0,any,1
+TTR,runMedian,0,0,0,class<`matrix`>,1
+TTR,runMedian,0,0,1,^double[],1
+TTR,runMedian,0,0,2,class<`data.frame`>,1
+TTR,runMedian,1,0,0,double,1
+TTR,runMedian,2,0,0,character,1
+TTR,runMedian,3,0,0,logical,1
+TTR,runMin,-1,0,0,any,1
+TTR,runMin,0,0,0,"class<`xts`, `zoo`>",1
+TTR,runMin,0,0,1,class<`matrix`>,1
+TTR,runMin,0,0,2,^double[],1
+TTR,runMin,0,0,3,class<`data.frame`>,1
+TTR,runMin,1,0,0,double,1
+TTR,runMin,2,0,0,logical,1
+TTR,runPercentRank,-1,0,0,any,1
+TTR,runPercentRank,0,0,0,class<`matrix`>,1
+TTR,runPercentRank,0,0,1,"class<`xts`, `zoo`>",1
+TTR,runPercentRank,0,0,2,^double[],1
+TTR,runPercentRank,1,0,0,double,1
+TTR,runPercentRank,2,0,0,logical,1
+TTR,runPercentRank,3,0,0,double,1
+TTR,runSD,-1,0,0,any,1
+TTR,runSD,0,0,0,class<`matrix`>,1
+TTR,runSD,0,0,1,^double[],1
+TTR,runSD,0,0,2,class<`data.frame`>,1
+TTR,runSD,1,0,0,double,1
+TTR,runSD,2,0,0,logical,1
+TTR,runSD,3,0,0,logical,1
+TTR,runSum,-1,0,0,any,1
+TTR,runSum,0,0,0,"class<`xts`, `zoo`>",1
+TTR,runSum,0,0,1,class<`matrix`>,1
+TTR,runSum,0,0,2,^double[],1
+TTR,runSum,0,0,3,class<`data.frame`>,1
+TTR,runSum,1,0,0,double,1
+TTR,runSum,2,0,0,logical,1
+TTR,runVar,-1,0,0,any,1
+TTR,runVar,0,0,0,^double[],1
+TTR,runVar,0,0,1,class<`data.frame`>,1
+TTR,runVar,1,0,0,null,1
+TTR,runVar,1,0,1,double[],1
+TTR,runVar,2,0,0,double,1
+TTR,runVar,3,0,0,logical,1
+TTR,runVar,4,0,0,logical,1
+TTR,SAR,-1,0,0,any,1
+TTR,SAR,0,0,0,class<`data.frame`>,1
+TTR,SAR,1,0,0,any,1
+TTR,SMA,-1,0,0,any,1
+TTR,SMA,0,0,0,class<`matrix`>,1
+TTR,SMA,0,0,1,"class<`xts`, `zoo`>",1
+TTR,SMA,0,0,2,^double[],1
+TTR,SMA,0,0,3,class<`data.frame`>,1
+TTR,SMA,1,0,0,double,1
+TTR,SMA,2,0,0,...,1
+TTR,SMI,-1,0,0,any,1
+TTR,SMI,0,0,0,class<`data.frame`>,1
+TTR,SMI,1,0,0,double,1
+TTR,SMI,2,0,0,double,1
+TTR,SMI,3,0,0,double,1
+TTR,SMI,4,0,0,double,1
+TTR,SMI,5,0,0,any,1
+TTR,SMI,6,0,0,logical,1
+TTR,SMI,7,0,0,...,1
+TTR,stoch,-1,0,0,any,1
+TTR,stoch,0,0,0,class<`data.frame`>,1
+TTR,stoch,0,0,1,class<`matrix`>,1
+TTR,stoch,0,0,2,^double[],1
+TTR,stoch,1,0,0,double,1
+TTR,stoch,2,0,0,double,1
+TTR,stoch,3,0,0,double,1
+TTR,stoch,4,0,0,any,1
+TTR,stoch,5,0,0,logical,1
+TTR,stoch,6,0,0,double,1
+TTR,stoch,7,0,0,...,1
+TTR,TDI,-1,0,0,class<`matrix`>,1
+TTR,TDI,0,0,0,double[],1
+TTR,TDI,1,0,0,double,1
+TTR,TDI,2,0,0,double,1
+TTR,TRIX,-1,0,0,any,1
+TTR,TRIX,0,0,0,^double[],1
+TTR,TRIX,1,0,0,double,1
+TTR,TRIX,2,0,0,double,1
+TTR,TRIX,3,0,0,any,1
+TTR,TRIX,4,0,0,logical,1
+TTR,TRIX,5,0,0,...,1
+TTR,ultimateOscillator,-1,0,0,any,1
+TTR,ultimateOscillator,0,0,0,"class<`xts`, `zoo`>",1
+TTR,ultimateOscillator,0,0,1,class<`data.frame`>,1
+TTR,ultimateOscillator,0,0,2,^double[],1
+TTR,ultimateOscillator,1,0,0,double[],1
+TTR,ultimateOscillator,2,0,0,double[],1
+TTR,VHF,-1,0,0,^double[],1
+TTR,VHF,0,0,0,class<`data.frame`>,1
+TTR,VHF,0,0,1,double[],1
+TTR,VHF,1,0,0,double,1
+TTR,volatility,-1,0,0,any,1
+TTR,volatility,0,0,0,class<`data.frame`>,1
+TTR,volatility,1,0,0,double,1
+TTR,volatility,2,0,0,character,1
+TTR,volatility,3,0,0,double,1
+TTR,volatility,4,0,0,logical,1
+TTR,volatility,5,0,0,...,1
+TTR,wilderSum,-1,0,0,any,1
+TTR,wilderSum,0,0,0,class<`matrix`>,1
+TTR,wilderSum,0,0,1,^double[],1
+TTR,wilderSum,0,0,2,class<`data.frame`>,1
+TTR,wilderSum,1,0,0,double,1
+TTR,williamsAD,-1,0,0,^double[],1
+TTR,williamsAD,0,0,0,class<`data.frame`>,1
+TTR,WMA,-1,0,0,any,1
+TTR,WMA,0,0,0,^double[],1
+TTR,WMA,0,0,1,class<`data.frame`>,1
+TTR,WMA,1,0,0,double,1
+TTR,WMA,2,0,0,^double[],1
+TTR,WMA,2,0,1,class<`data.frame`>,1
+TTR,WMA,3,0,0,...,1
+TTR,WPR,-1,0,0,any,1
+TTR,WPR,0,0,0,class<`data.frame`>,1
+TTR,WPR,0,0,1,^double[],1
+TTR,WPR,1,0,0,double,1
+TTR,ZigZag,-1,0,0,any,1
+TTR,ZigZag,0,0,0,class<`data.frame`>,1
+TTR,ZigZag,1,0,0,double,1
+TTR,ZigZag,2,0,0,logical,1
+TTR,ZigZag,3,0,0,logical,1
+TTR,ZigZag,4,0,0,logical,1
+TTR,ZLEMA,-1,0,0,any,1
+TTR,ZLEMA,0,0,0,^double[],1
+TTR,ZLEMA,0,0,1,class<`data.frame`>,1
+TTR,ZLEMA,1,0,0,double,1
+TTR,ZLEMA,2,0,0,null,1
+TTR,ZLEMA,3,0,0,...,1
+WriteXLS,testPerl,-1,0,0,logical,1
+WriteXLS,testPerl,0,0,0,character,1
+WriteXLS,testPerl,1,0,0,logical,1
+WriteXLS,WriteXLS,-1,0,0,logical,1
+WriteXLS,WriteXLS,0,0,0,character[],1
+WriteXLS,WriteXLS,0,0,1,class<`data.frame`>,1
+WriteXLS,WriteXLS,0,0,2,list<class<`data.frame`>>,1
+WriteXLS,WriteXLS,1,0,0,character,1
+WriteXLS,WriteXLS,2,0,0,null,1
+WriteXLS,WriteXLS,3,0,0,character,1
+WriteXLS,WriteXLS,4,0,0,logical,1
+WriteXLS,WriteXLS,5,0,0,character[],1
+WriteXLS,WriteXLS,6,0,0,logical,1
+WriteXLS,WriteXLS,7,0,0,logical,1
+WriteXLS,WriteXLS,8,0,0,logical,1
+WriteXLS,WriteXLS,9,0,0,logical,1
+WriteXLS,WriteXLS,10,0,0,logical,1
+WriteXLS,WriteXLS,11,0,0,character,1
+WriteXLS,WriteXLS,12,0,0,double,1
+WriteXLS,WriteXLS,13,0,0,double,1
+WriteXLS,WriteXLS,14,0,0,any,1
+XLConnect,addImage,-1,0,0,null,1
+XLConnect,addImage,0,0,0,class<`workbook`>,1
+XLConnect,addImage,1,0,0,character,1
+XLConnect,addImage,2,0,0,character,1
+XLConnect,addImage,3,0,0,logical,1
+XLConnect,addImage,-1,1,0,null,1
+XLConnect,addImage,0,1,0,class<`workbook`>,1
+XLConnect,addImage,1,1,0,character,1
+XLConnect,addImage,2,1,0,character,1
+XLConnect,addImage,3,1,0,logical,1
+XLConnect,appendNamedRegion,-1,0,0,null,1
+XLConnect,appendNamedRegion,0,0,0,class<`workbook`>,1
+XLConnect,appendNamedRegion,1,0,0,class<`data.frame`>,1
+XLConnect,appendNamedRegion,2,0,0,character,1
+XLConnect,appendNamedRegion,3,0,0,logical,1
+XLConnect,appendNamedRegion,4,0,0,null,1
+XLConnect,appendNamedRegion,-1,1,0,null,1
+XLConnect,appendNamedRegion,0,1,0,class<`workbook`>,1
+XLConnect,appendNamedRegion,1,1,0,class<`data.frame`>,1
+XLConnect,appendNamedRegion,2,1,0,character,1
+XLConnect,appendNamedRegion,3,1,0,logical,1
+XLConnect,appendNamedRegion,4,1,0,null,1
+XLConnect,appendWorksheet,-1,0,0,null,1
+XLConnect,appendWorksheet,0,0,0,class<`workbook`>,1
+XLConnect,appendWorksheet,1,0,0,class<`data.frame`>,1
+XLConnect,appendWorksheet,2,0,0,character,1
+XLConnect,appendWorksheet,3,0,0,logical,1
+XLConnect,appendWorksheet,4,0,0,null,1
+XLConnect,appendWorksheet,-1,1,0,null,1
+XLConnect,appendWorksheet,0,1,0,class<`workbook`>,1
+XLConnect,appendWorksheet,1,1,0,class<`data.frame`>,1
+XLConnect,appendWorksheet,2,1,0,character,1
+XLConnect,appendWorksheet,3,1,0,logical,1
+XLConnect,appendWorksheet,4,1,0,null,1
+XLConnect,aref,-1,0,0,character,1
+XLConnect,aref,0,0,0,character,1
+XLConnect,aref,0,0,1,double[],1
+XLConnect,aref,1,0,0,double[],1
+XLConnect,aref2idx,-1,0,0,class<`matrix`>,1
+XLConnect,aref2idx,0,0,0,character[],1
+XLConnect,classToXlcType,-1,0,0,character[],1
+XLConnect,classToXlcType,0,0,0,character[],1
+XLConnect,clearNamedRegion,-1,0,0,null,1
+XLConnect,clearNamedRegion,0,0,0,class<`workbook`>,1
+XLConnect,clearNamedRegion,1,0,0,character[],1
+XLConnect,clearNamedRegion,-1,1,0,null,1
+XLConnect,clearNamedRegion,0,1,0,class<`workbook`>,1
+XLConnect,clearNamedRegion,1,1,0,character[],1
+XLConnect,clearRange,-1,0,0,null,1
+XLConnect,clearRange,0,0,0,class<`workbook`>,1
+XLConnect,clearRange,1,0,0,character,1
+XLConnect,clearRange,2,0,0,class<`matrix`>,1
+XLConnect,clearRange,2,0,1,double[],1
+XLConnect,clearRange,-1,1,0,null,1
+XLConnect,clearRange,0,1,0,class<`workbook`>,1
+XLConnect,clearRange,1,1,0,character,1
+XLConnect,clearRange,2,1,0,class<`matrix`>,1
+XLConnect,clearRange,2,1,1,double[],1
+XLConnect,clearRangeFromReference,-1,0,0,null,1
+XLConnect,clearRangeFromReference,0,0,0,class<`workbook`>,1
+XLConnect,clearRangeFromReference,1,0,0,character[],1
+XLConnect,clearRangeFromReference,-1,1,0,null,1
+XLConnect,clearRangeFromReference,0,1,0,class<`workbook`>,1
+XLConnect,clearRangeFromReference,1,1,0,character[],1
+XLConnect,clearSheet,-1,0,0,null,1
+XLConnect,clearSheet,0,0,0,class<`workbook`>,1
+XLConnect,clearSheet,1,0,0,double,1
+XLConnect,clearSheet,-1,1,0,null,1
+XLConnect,clearSheet,0,1,0,class<`workbook`>,1
+XLConnect,clearSheet,1,1,0,character[],1
+XLConnect,clearSheet,1,1,1,double,1
+XLConnect,clearSheet,-1,2,0,null,1
+XLConnect,clearSheet,0,2,0,class<`workbook`>,1
+XLConnect,clearSheet,1,2,0,character[],1
+XLConnect,cloneSheet,-1,0,0,null,1
+XLConnect,cloneSheet,0,0,0,class<`workbook`>,1
+XLConnect,cloneSheet,1,0,0,character,1
+XLConnect,cloneSheet,2,0,0,character,1
+XLConnect,cloneSheet,-1,1,0,null,1
+XLConnect,cloneSheet,0,1,0,class<`workbook`>,1
+XLConnect,cloneSheet,1,1,0,character,1
+XLConnect,cloneSheet,2,1,0,character,1
+XLConnect,col2idx,-1,0,0,double[],1
+XLConnect,col2idx,0,0,0,character[],1
+XLConnect,createCellStyle,-1,0,0,class<`cellstyle`>,1
+XLConnect,createCellStyle,0,0,0,class<`workbook`>,1
+XLConnect,createCellStyle,1,0,0,character,1
+XLConnect,createCellStyle,-1,1,0,class<`cellstyle`>,1
+XLConnect,createCellStyle,0,1,0,class<`workbook`>,1
+XLConnect,createCellStyle,1,1,0,any,1
+XLConnect,createCellStyle,-1,2,0,class<`cellstyle`>,1
+XLConnect,createCellStyle,0,2,0,class<`workbook`>,1
+XLConnect,createCellStyle,1,2,0,any,1
+XLConnect,createFreezePane,-1,0,0,null,1
+XLConnect,createFreezePane,0,0,0,class<`workbook`>,1
+XLConnect,createFreezePane,1,0,0,character,1
+XLConnect,createFreezePane,2,0,0,double,1
+XLConnect,createFreezePane,3,0,0,double,1
+XLConnect,createFreezePane,4,0,0,double,1
+XLConnect,createFreezePane,5,0,0,double,1
+XLConnect,createFreezePane,-1,1,0,null,1
+XLConnect,createFreezePane,0,1,0,class<`workbook`>,1
+XLConnect,createFreezePane,1,1,0,character,1
+XLConnect,createFreezePane,2,1,0,double,1
+XLConnect,createFreezePane,3,1,0,double,1
+XLConnect,createFreezePane,4,1,0,double,1
+XLConnect,createFreezePane,5,1,0,double,1
+XLConnect,createName,-1,0,0,any,1
+XLConnect,createName,0,0,0,class<`workbook`>,1
+XLConnect,createName,1,0,0,character,1
+XLConnect,createName,2,0,0,character,1
+XLConnect,createName,3,0,0,logical,1
+XLConnect,createName,-1,1,0,any,1
+XLConnect,createName,0,1,0,class<`workbook`>,1
+XLConnect,createName,1,1,0,character,1
+XLConnect,createName,2,1,0,character,1
+XLConnect,createName,3,1,0,logical,1
+XLConnect,createSheet,-1,0,0,any,1
+XLConnect,createSheet,0,0,0,class<`workbook`>,1
+XLConnect,createSheet,1,0,0,character[],1
+XLConnect,createSheet,-1,1,0,any,1
+XLConnect,createSheet,0,1,0,class<`workbook`>,1
+XLConnect,createSheet,1,1,0,character[],1
+XLConnect,createSplitPane,-1,0,0,null,1
+XLConnect,createSplitPane,0,0,0,class<`workbook`>,1
+XLConnect,createSplitPane,1,0,0,character,1
+XLConnect,createSplitPane,2,0,0,double,1
+XLConnect,createSplitPane,3,0,0,double,1
+XLConnect,createSplitPane,4,0,0,double,1
+XLConnect,createSplitPane,5,0,0,double,1
+XLConnect,createSplitPane,-1,1,0,null,1
+XLConnect,createSplitPane,0,1,0,class<`workbook`>,1
+XLConnect,createSplitPane,1,1,0,character,1
+XLConnect,createSplitPane,2,1,0,double,1
+XLConnect,createSplitPane,3,1,0,double,1
+XLConnect,createSplitPane,4,1,0,double,1
+XLConnect,createSplitPane,5,1,0,double,1
+XLConnect,cref2idx,-1,0,0,class<`matrix`>,1
+XLConnect,cref2idx,0,0,0,character[],1
+XLConnect,existsCellStyle,-1,0,0,logical,1
+XLConnect,existsCellStyle,0,0,0,class<`workbook`>,1
+XLConnect,existsCellStyle,1,0,0,character,1
+XLConnect,existsCellStyle,-1,1,0,logical,1
+XLConnect,existsCellStyle,0,1,0,class<`workbook`>,1
+XLConnect,existsCellStyle,1,1,0,character,1
+XLConnect,existsName,-1,0,0,logical,1
+XLConnect,existsName,0,0,0,class<`workbook`>,1
+XLConnect,existsName,1,0,0,character,1
+XLConnect,existsName,-1,1,0,logical,1
+XLConnect,existsName,0,1,0,class<`workbook`>,1
+XLConnect,existsName,1,1,0,character,1
+XLConnect,existsSheet,-1,0,0,logical,1
+XLConnect,existsSheet,0,0,0,class<`workbook`>,1
+XLConnect,existsSheet,1,0,0,character,1
+XLConnect,existsSheet,-1,1,0,logical,1
+XLConnect,existsSheet,0,1,0,class<`workbook`>,1
+XLConnect,existsSheet,1,1,0,character,1
+XLConnect,extractRownames,-1,0,0,list<class<`data.frame`>>,1
+XLConnect,extractRownames,-1,0,1,class<`data.frame`>,1
+XLConnect,extractRownames,0,0,0,list<class<`data.frame`>>,1
+XLConnect,extractRownames,0,0,1,class<`data.frame`>,1
+XLConnect,extractRownames,1,0,0,null,1
+XLConnect,extractRownames,1,0,1,character,1
+XLConnect,extractRownames,1,0,2,double,1
+XLConnect,extractSheetName,-1,0,0,any,1
+XLConnect,extractSheetName,0,0,0,any,1
+XLConnect,getActiveSheetIndex,-1,0,0,integer,1
+XLConnect,getActiveSheetIndex,0,0,0,class<`workbook`>,1
+XLConnect,getActiveSheetIndex,-1,1,0,integer,1
+XLConnect,getActiveSheetIndex,0,1,0,class<`workbook`>,1
+XLConnect,getActiveSheetName,-1,0,0,character,1
+XLConnect,getActiveSheetName,0,0,0,class<`workbook`>,1
+XLConnect,getActiveSheetName,-1,1,0,character,1
+XLConnect,getActiveSheetName,0,1,0,class<`workbook`>,1
+XLConnect,getBoundingBox,-1,0,0,any,1
+XLConnect,getBoundingBox,0,0,0,class<`workbook`>,1
+XLConnect,getBoundingBox,1,0,0,double[],1
+XLConnect,getBoundingBox,2,0,0,double[],1
+XLConnect,getBoundingBox,3,0,0,double[],1
+XLConnect,getBoundingBox,4,0,0,double[],1
+XLConnect,getBoundingBox,5,0,0,double[],1
+XLConnect,getBoundingBox,6,0,0,logical,1
+XLConnect,getBoundingBox,7,0,0,logical,1
+XLConnect,getBoundingBox,-1,1,0,any,1
+XLConnect,getBoundingBox,0,1,0,class<`workbook`>,1
+XLConnect,getBoundingBox,1,1,0,double[],1
+XLConnect,getBoundingBox,1,1,1,character[],1
+XLConnect,getBoundingBox,2,1,0,double[],1
+XLConnect,getBoundingBox,3,1,0,double[],1
+XLConnect,getBoundingBox,4,1,0,double[],1
+XLConnect,getBoundingBox,5,1,0,double[],1
+XLConnect,getBoundingBox,6,1,0,logical,1
+XLConnect,getBoundingBox,7,1,0,logical,1
+XLConnect,getBoundingBox,-1,2,0,class<`matrix`>,1
+XLConnect,getBoundingBox,0,2,0,class<`workbook`>,1
+XLConnect,getBoundingBox,1,2,0,character[],1
+XLConnect,getBoundingBox,2,2,0,double,1
+XLConnect,getBoundingBox,3,2,0,double,1
+XLConnect,getBoundingBox,4,2,0,double,1
+XLConnect,getBoundingBox,5,2,0,double,1
+XLConnect,getBoundingBox,6,2,0,logical,1
+XLConnect,getBoundingBox,7,2,0,logical,1
+XLConnect,getCellFormula,-1,0,0,character,1
+XLConnect,getCellFormula,0,0,0,class<`workbook`>,1
+XLConnect,getCellFormula,1,0,0,character,1
+XLConnect,getCellFormula,2,0,0,double,1
+XLConnect,getCellFormula,3,0,0,double,1
+XLConnect,getCellFormula,-1,1,0,character,1
+XLConnect,getCellFormula,0,1,0,class<`workbook`>,1
+XLConnect,getCellFormula,1,1,0,double,1
+XLConnect,getCellFormula,2,1,0,double,1
+XLConnect,getCellFormula,3,1,0,double,1
+XLConnect,getCellFormula,-1,2,0,character,1
+XLConnect,getCellFormula,0,2,0,class<`workbook`>,1
+XLConnect,getCellFormula,1,2,0,double,1
+XLConnect,getCellFormula,1,2,1,character,1
+XLConnect,getCellFormula,2,2,0,double,1
+XLConnect,getCellFormula,3,2,0,double,1
+XLConnect,getCellStyle,-1,0,0,class<`cellstyle`>,1
+XLConnect,getCellStyle,0,0,0,class<`workbook`>,1
+XLConnect,getCellStyle,1,0,0,character,1
+XLConnect,getCellStyle,-1,1,0,class<`cellstyle`>,1
+XLConnect,getCellStyle,0,1,0,class<`workbook`>,1
+XLConnect,getCellStyle,1,1,0,character,1
+XLConnect,getCellStyleForType,-1,0,0,class<`cellstyle`>,1
+XLConnect,getCellStyleForType,0,0,0,class<`workbook`>,1
+XLConnect,getCellStyleForType,1,0,0,character,1
+XLConnect,getCellStyleForType,-1,1,0,class<`cellstyle`>,1
+XLConnect,getCellStyleForType,0,1,0,class<`workbook`>,1
+XLConnect,getCellStyleForType,1,1,0,character,1
+XLConnect,getColSubset,-1,0,0,any,1
+XLConnect,getColSubset,0,0,0,any,1
+XLConnect,getColSubset,1,0,0,character[],1
+XLConnect,getColSubset,1,0,1,double[],1
+XLConnect,getColSubset,2,0,0,double[],1
+XLConnect,getColSubset,3,0,0,double[],1
+XLConnect,getColSubset,4,0,0,double[],1
+XLConnect,getColSubset,5,0,0,double[],1
+XLConnect,getColSubset,6,0,0,logical,1
+XLConnect,getColSubset,7,0,0,double[],1
+XLConnect,getDefinedNames,-1,0,0,character[],1
+XLConnect,getDefinedNames,0,0,0,class<`workbook`>,1
+XLConnect,getDefinedNames,1,0,0,logical,1
+XLConnect,getDefinedNames,-1,1,0,character[],1
+XLConnect,getDefinedNames,0,1,0,class<`workbook`>,1
+XLConnect,getDefinedNames,1,1,0,logical,1
+XLConnect,getForceFormulaRecalculation,-1,0,0,logical,1
+XLConnect,getForceFormulaRecalculation,0,0,0,class<`workbook`>,1
+XLConnect,getForceFormulaRecalculation,1,0,0,character,1
+XLConnect,getForceFormulaRecalculation,-1,1,0,logical,1
+XLConnect,getForceFormulaRecalculation,0,1,0,class<`workbook`>,1
+XLConnect,getForceFormulaRecalculation,1,1,0,character,1
+XLConnect,getLastColumn,-1,0,0,double,1
+XLConnect,getLastColumn,0,0,0,class<`workbook`>,1
+XLConnect,getLastColumn,1,0,0,character,1
+XLConnect,getLastColumn,-1,1,0,double,1
+XLConnect,getLastColumn,0,1,0,class<`workbook`>,1
+XLConnect,getLastColumn,1,1,0,character,1
+XLConnect,getLastRow,-1,0,0,double,1
+XLConnect,getLastRow,0,0,0,class<`workbook`>,1
+XLConnect,getLastRow,1,0,0,character,1
+XLConnect,getLastRow,-1,1,0,double,1
+XLConnect,getLastRow,0,1,0,class<`workbook`>,1
+XLConnect,getLastRow,1,1,0,character,1
+XLConnect,getOrCreateCellStyle,-1,0,0,class<`cellstyle`>,1
+XLConnect,getOrCreateCellStyle,0,0,0,class<`workbook`>,1
+XLConnect,getOrCreateCellStyle,1,0,0,character,1
+XLConnect,getOrCreateCellStyle,-1,1,0,class<`cellstyle`>,1
+XLConnect,getOrCreateCellStyle,0,1,0,class<`workbook`>,1
+XLConnect,getOrCreateCellStyle,1,1,0,character,1
+XLConnect,getReferenceCoordinatesForName,-1,0,0,class<`matrix`>,1
+XLConnect,getReferenceCoordinatesForName,0,0,0,class<`workbook`>,1
+XLConnect,getReferenceCoordinatesForName,1,0,0,character[],1
+XLConnect,getReferenceCoordinatesForName,-1,1,0,class<`matrix`>,1
+XLConnect,getReferenceCoordinatesForName,0,1,0,class<`workbook`>,1
+XLConnect,getReferenceCoordinatesForName,1,1,0,character[],1
+XLConnect,getReferenceCoordinatesForTable,-1,0,0,class<`matrix`>,1
+XLConnect,getReferenceCoordinatesForTable,0,0,0,class<`workbook`>,1
+XLConnect,getReferenceCoordinatesForTable,1,0,0,double,1
+XLConnect,getReferenceCoordinatesForTable,2,0,0,character,1
+XLConnect,getReferenceCoordinatesForTable,-1,1,0,class<`matrix`>,1
+XLConnect,getReferenceCoordinatesForTable,0,1,0,class<`workbook`>,1
+XLConnect,getReferenceCoordinatesForTable,1,1,0,character,1
+XLConnect,getReferenceCoordinatesForTable,2,1,0,character,1
+XLConnect,getReferenceCoordinatesForTable,-1,2,0,class<`matrix`>,1
+XLConnect,getReferenceCoordinatesForTable,0,2,0,class<`workbook`>,1
+XLConnect,getReferenceCoordinatesForTable,1,2,0,character,1
+XLConnect,getReferenceCoordinatesForTable,1,2,1,double,1
+XLConnect,getReferenceCoordinatesForTable,2,2,0,character,1
+XLConnect,getReferenceFormula,-1,0,0,any,1
+XLConnect,getReferenceFormula,0,0,0,class<`workbook`>,1
+XLConnect,getReferenceFormula,1,0,0,character[],1
+XLConnect,getReferenceFormula,-1,1,0,any,1
+XLConnect,getReferenceFormula,0,1,0,class<`workbook`>,1
+XLConnect,getReferenceFormula,1,1,0,character[],1
+XLConnect,getSheetPos,-1,0,0,double[],1
+XLConnect,getSheetPos,0,0,0,class<`workbook`>,1
+XLConnect,getSheetPos,1,0,0,character[],1
+XLConnect,getSheetPos,-1,1,0,double[],1
+XLConnect,getSheetPos,0,1,0,class<`workbook`>,1
+XLConnect,getSheetPos,1,1,0,character[],1
+XLConnect,getSheets,-1,0,0,character[],1
+XLConnect,getSheets,0,0,0,class<`workbook`>,1
+XLConnect,getSheets,-1,1,0,character[],1
+XLConnect,getSheets,0,1,0,class<`workbook`>,1
+XLConnect,getTables,-1,0,0,character,1
+XLConnect,getTables,0,0,0,class<`workbook`>,1
+XLConnect,getTables,1,0,0,character,1
+XLConnect,getTables,2,0,0,logical,1
+XLConnect,getTables,-1,1,0,character,1
+XLConnect,getTables,0,1,0,class<`workbook`>,1
+XLConnect,getTables,1,1,0,double,1
+XLConnect,getTables,2,1,0,logical,1
+XLConnect,getTables,-1,2,0,character,1
+XLConnect,getTables,0,2,0,class<`workbook`>,1
+XLConnect,getTables,1,2,0,character,1
+XLConnect,getTables,1,2,1,double,1
+XLConnect,getTables,2,2,0,logical,1
+XLConnect,hideSheet,-1,0,0,null,1
+XLConnect,hideSheet,0,0,0,class<`workbook`>,1
+XLConnect,hideSheet,1,0,0,character,1
+XLConnect,hideSheet,2,0,0,logical,1
+XLConnect,hideSheet,-1,1,0,null,1
+XLConnect,hideSheet,0,1,0,class<`workbook`>,1
+XLConnect,hideSheet,1,1,0,character,1
+XLConnect,hideSheet,2,1,0,logical,1
+XLConnect,idx2aref,-1,0,0,character[],1
+XLConnect,idx2aref,0,0,0,class<`matrix`>,1
+XLConnect,idx2aref,0,0,1,double[],1
+XLConnect,idx2col,-1,0,0,character[],1
+XLConnect,idx2col,0,0,0,double[],1
+XLConnect,idx2cref,-1,0,0,character[],1
+XLConnect,idx2cref,0,0,0,class<`matrix`>,1
+XLConnect,idx2cref,0,0,1,double[],1
+XLConnect,idx2cref,1,0,0,logical,1
+XLConnect,idx2cref,2,0,0,logical,1
+XLConnect,includeRownames,-1,0,0,any,1
+XLConnect,includeRownames,0,0,0,class<`data.frame`>,1
+XLConnect,includeRownames,0,0,1,"class<`data.frame`, `groupedData`, `nfGroupedData`, `nfnGroupedData`>",1
+XLConnect,includeRownames,0,0,2,class<`function`>,1
+XLConnect,includeRownames,0,0,3,list<any>,1
+XLConnect,includeRownames,0,0,4,character,1
+XLConnect,includeRownames,0,0,5,class<`Date`>,1
+XLConnect,includeRownames,0,0,6,"class<`factor`, `ordered`>",1
+XLConnect,includeRownames,0,0,7,"class<`POSIXct`, `POSIXt`>",1
+XLConnect,includeRownames,0,0,8,double,1
+XLConnect,includeRownames,1,0,0,any,1
+XLConnect,isSheetHidden,-1,0,0,logical,1
+XLConnect,isSheetHidden,0,0,0,class<`workbook`>,1
+XLConnect,isSheetHidden,1,0,0,character,1
+XLConnect,isSheetHidden,-1,1,0,logical,1
+XLConnect,isSheetHidden,0,1,0,class<`workbook`>,1
+XLConnect,isSheetHidden,1,1,0,character,1
+XLConnect,isSheetVeryHidden,-1,0,0,logical,1
+XLConnect,isSheetVeryHidden,0,0,0,class<`workbook`>,1
+XLConnect,isSheetVeryHidden,1,0,0,character,1
+XLConnect,isSheetVeryHidden,-1,1,0,logical,1
+XLConnect,isSheetVeryHidden,0,1,0,class<`workbook`>,1
+XLConnect,isSheetVeryHidden,1,1,0,character,1
+XLConnect,isSheetVisible,-1,0,0,logical,1
+XLConnect,isSheetVisible,0,0,0,class<`workbook`>,1
+XLConnect,isSheetVisible,1,0,0,character,1
+XLConnect,isSheetVisible,-1,1,0,logical,1
+XLConnect,isSheetVisible,0,1,0,class<`workbook`>,1
+XLConnect,isSheetVisible,1,1,0,character,1
+XLConnect,.jseq,-1,0,0,class<`jobjRef`>,1
+XLConnect,.jseq,0,0,0,character[],1
+XLConnect,.jseq,0,0,1,class<`cellstyle`>,1
+XLConnect,.jsle,-1,0,0,class<`jobjRef`>,1
+XLConnect,.jsle,0,0,0,double[],1
+XLConnect,jTryCatch,-1,0,0,any,1
+XLConnect,jTryCatch,0,0,0,...,1
+XLConnect,loadWorkbook,-1,0,0,any,1
+XLConnect,loadWorkbook,0,0,0,character,1
+XLConnect,loadWorkbook,1,0,0,logical,1
+XLConnect,loadWorkbook,2,0,0,character,1
+XLConnect,loadWorkbook,2,0,1,null,1
+XLConnect,mergeCells,-1,0,0,null,1
+XLConnect,mergeCells,0,0,0,class<`workbook`>,1
+XLConnect,mergeCells,1,0,0,character,1
+XLConnect,mergeCells,2,0,0,character,1
+XLConnect,mergeCells,-1,1,0,null,1
+XLConnect,mergeCells,0,1,0,class<`workbook`>,1
+XLConnect,mergeCells,1,1,0,character,1
+XLConnect,mergeCells,2,1,0,character,1
+XLConnect,normalizeDataframe,-1,0,0,class<`data.frame`>,1
+XLConnect,normalizeDataframe,0,0,0,class<`data.frame`>,1
+XLConnect,normalizeDataframe,1,0,0,logical,1
+XLConnect,onErrorCell,-1,0,0,null,1
+XLConnect,onErrorCell,0,0,0,class<`workbook`>,1
+XLConnect,onErrorCell,1,0,0,character,1
+XLConnect,onErrorCell,-1,1,0,null,1
+XLConnect,onErrorCell,0,1,0,class<`workbook`>,1
+XLConnect,onErrorCell,1,1,0,character,1
+XLConnect,print,-1,0,0,character,1
+XLConnect,print,0,0,0,class<`workbook`>,1
+XLConnect,print,1,0,0,...,1
+XLConnect,readNamedRegion,-1,0,0,any,1
+XLConnect,readNamedRegion,0,0,0,class<`workbook`>,1
+XLConnect,readNamedRegion,1,0,0,character[],1
+XLConnect,readNamedRegion,2,0,0,logical,1
+XLConnect,readNamedRegion,3,0,0,null,1
+XLConnect,readNamedRegion,3,0,1,character,1
+XLConnect,readNamedRegion,4,0,0,any,1
+XLConnect,readNamedRegion,5,0,0,logical,1
+XLConnect,readNamedRegion,6,0,0,any,1
+XLConnect,readNamedRegion,7,0,0,logical,1
+XLConnect,readNamedRegion,-1,1,0,any,1
+XLConnect,readNamedRegion,0,1,0,class<`workbook`>,1
+XLConnect,readNamedRegion,1,1,0,character[],1
+XLConnect,readNamedRegion,2,1,0,logical,1
+XLConnect,readNamedRegion,3,1,0,null,1
+XLConnect,readNamedRegion,3,1,1,character,1
+XLConnect,readNamedRegion,4,1,0,any,1
+XLConnect,readNamedRegion,5,1,0,logical,1
+XLConnect,readNamedRegion,6,1,0,any,1
+XLConnect,readNamedRegion,7,1,0,logical,1
+XLConnect,readNamedRegionFromFile,-1,0,0,class<`data.frame`>,1
+XLConnect,readNamedRegionFromFile,-1,0,1,list<class<`data.frame`>>,1
+XLConnect,readNamedRegionFromFile,0,0,0,character,1
+XLConnect,readNamedRegionFromFile,1,0,0,...,1
+XLConnect,readTable,-1,0,0,class<`data.frame`>,1
+XLConnect,readTable,0,0,0,class<`workbook`>,1
+XLConnect,readTable,1,0,0,double,1
+XLConnect,readTable,2,0,0,character,1
+XLConnect,readTable,3,0,0,logical,1
+XLConnect,readTable,4,0,0,null,1
+XLConnect,readTable,5,0,0,character[],1
+XLConnect,readTable,6,0,0,logical,1
+XLConnect,readTable,7,0,0,character,1
+XLConnect,readTable,-1,1,0,class<`data.frame`>,1
+XLConnect,readTable,0,1,0,class<`workbook`>,1
+XLConnect,readTable,1,1,0,character,1
+XLConnect,readTable,1,1,1,double,1
+XLConnect,readTable,2,1,0,character,1
+XLConnect,readTable,3,1,0,logical,1
+XLConnect,readTable,4,1,0,null,1
+XLConnect,readTable,5,1,0,any,1
+XLConnect,readTable,6,1,0,logical,1
+XLConnect,readTable,7,1,0,any,1
+XLConnect,readTable,-1,2,0,class<`data.frame`>,1
+XLConnect,readTable,0,2,0,class<`workbook`>,1
+XLConnect,readTable,1,2,0,character,1
+XLConnect,readTable,2,2,0,character,1
+XLConnect,readTable,3,2,0,logical,1
+XLConnect,readTable,4,2,0,null,1
+XLConnect,readTable,5,2,0,any,1
+XLConnect,readTable,6,2,0,logical,1
+XLConnect,readTable,7,2,0,any,1
+XLConnect,readWorksheet,-1,0,0,any,1
+XLConnect,readWorksheet,0,0,0,class<`workbook`>,1
+XLConnect,readWorksheet,1,0,0,double[],1
+XLConnect,readWorksheet,2,0,0,any,1
+XLConnect,readWorksheet,3,0,0,double[],1
+XLConnect,readWorksheet,4,0,0,double[],1
+XLConnect,readWorksheet,5,0,0,any,1
+XLConnect,readWorksheet,6,0,0,logical,1
+XLConnect,readWorksheet,7,0,0,logical,1
+XLConnect,readWorksheet,-1,1,0,any,1
+XLConnect,readWorksheet,0,1,0,class<`workbook`>,1
+XLConnect,readWorksheet,1,1,0,character[],1
+XLConnect,readWorksheet,2,1,0,double[],1
+XLConnect,readWorksheet,3,1,0,double[],1
+XLConnect,readWorksheet,4,1,0,double[],1
+XLConnect,readWorksheet,5,1,0,double[],1
+XLConnect,readWorksheet,6,1,0,logical,1
+XLConnect,readWorksheet,7,1,0,logical,1
+XLConnect,readWorksheet,-1,2,0,any,1
+XLConnect,readWorksheet,0,2,0,class<`workbook`>,1
+XLConnect,readWorksheet,1,2,0,double[],1
+XLConnect,readWorksheet,1,2,1,character[],1
+XLConnect,readWorksheet,2,2,0,any,1
+XLConnect,readWorksheet,3,2,0,double[],1
+XLConnect,readWorksheet,4,2,0,double[],1
+XLConnect,readWorksheet,5,2,0,any,1
+XLConnect,readWorksheet,6,2,0,logical,1
+XLConnect,readWorksheet,7,2,0,logical,1
+XLConnect,readWorksheetFromFile,-1,0,0,class<`data.frame`>,1
+XLConnect,readWorksheetFromFile,-1,0,1,list<class<`data.frame`>>,1
+XLConnect,readWorksheetFromFile,0,0,0,character,1
+XLConnect,readWorksheetFromFile,1,0,0,...,1
+XLConnect,removeName,-1,0,0,null,1
+XLConnect,removeName,0,0,0,class<`workbook`>,1
+XLConnect,removeName,1,0,0,character,1
+XLConnect,removeName,-1,1,0,null,1
+XLConnect,removeName,0,1,0,class<`workbook`>,1
+XLConnect,removeName,1,1,0,character,1
+XLConnect,removePane,-1,0,0,null,1
+XLConnect,removePane,0,0,0,class<`workbook`>,1
+XLConnect,removePane,1,0,0,character,1
+XLConnect,removePane,-1,1,0,null,1
+XLConnect,removePane,0,1,0,class<`workbook`>,1
+XLConnect,removePane,1,1,0,character,1
+XLConnect,removeSheet,-1,0,0,null,1
+XLConnect,removeSheet,0,0,0,class<`workbook`>,1
+XLConnect,removeSheet,1,0,0,character,1
+XLConnect,removeSheet,-1,1,0,null,1
+XLConnect,removeSheet,0,1,0,class<`workbook`>,1
+XLConnect,removeSheet,1,1,0,character,1
+XLConnect,renameSheet,-1,0,0,any,1
+XLConnect,renameSheet,0,0,0,class<`workbook`>,1
+XLConnect,renameSheet,1,0,0,character,1
+XLConnect,renameSheet,2,0,0,character,1
+XLConnect,renameSheet,-1,1,0,null,1
+XLConnect,renameSheet,0,1,0,class<`workbook`>,1
+XLConnect,renameSheet,1,1,0,double,1
+XLConnect,renameSheet,2,1,0,character,1
+XLConnect,renameSheet,-1,2,0,any,1
+XLConnect,renameSheet,0,2,0,class<`workbook`>,1
+XLConnect,renameSheet,1,2,0,character,1
+XLConnect,renameSheet,1,2,1,double,1
+XLConnect,renameSheet,2,2,0,character,1
+XLConnect,rg2idx,-1,0,0,class<`matrix`>,1
+XLConnect,rg2idx,0,0,0,character,1
+XLConnect,saveWorkbook,-1,0,0,null,1
+XLConnect,saveWorkbook,0,0,0,class<`workbook`>,1
+XLConnect,saveWorkbook,1,0,0,any,1
+XLConnect,saveWorkbook,-1,1,0,null,1
+XLConnect,saveWorkbook,0,1,0,class<`workbook`>,1
+XLConnect,saveWorkbook,1,1,0,any,1
+XLConnect,seqle,-1,0,0,list<double>,1
+XLConnect,seqle,-1,0,1,list<integer[]>,1
+XLConnect,seqle,0,0,0,integer[],1
+XLConnect,setActiveSheet,-1,0,0,null,1
+XLConnect,setActiveSheet,0,0,0,class<`workbook`>,1
+XLConnect,setActiveSheet,1,0,0,character,1
+XLConnect,setActiveSheet,-1,1,0,null,1
+XLConnect,setActiveSheet,0,1,0,class<`workbook`>,1
+XLConnect,setActiveSheet,1,1,0,character,1
+XLConnect,setAutoFilter,-1,0,0,null,1
+XLConnect,setAutoFilter,0,0,0,class<`workbook`>,1
+XLConnect,setAutoFilter,1,0,0,character,1
+XLConnect,setAutoFilter,2,0,0,character,1
+XLConnect,setAutoFilter,-1,1,0,null,1
+XLConnect,setAutoFilter,0,1,0,class<`workbook`>,1
+XLConnect,setAutoFilter,1,1,0,character,1
+XLConnect,setAutoFilter,2,1,0,character,1
+XLConnect,setBorder,-1,0,0,null,1
+XLConnect,setBorder,0,0,0,class<`cellstyle`>,1
+XLConnect,setBorder,1,0,0,character[],1
+XLConnect,setBorder,2,0,0,double,1
+XLConnect,setBorder,3,0,0,double[],1
+XLConnect,setBorder,-1,1,0,null,1
+XLConnect,setBorder,0,1,0,class<`cellstyle`>,1
+XLConnect,setBorder,1,1,0,character[],1
+XLConnect,setBorder,2,1,0,double,1
+XLConnect,setBorder,3,1,0,double[],1
+XLConnect,setCellFormula,-1,0,0,null,1
+XLConnect,setCellFormula,0,0,0,class<`workbook`>,1
+XLConnect,setCellFormula,1,0,0,character,1
+XLConnect,setCellFormula,2,0,0,double,1
+XLConnect,setCellFormula,3,0,0,double,1
+XLConnect,setCellFormula,4,0,0,character,1
+XLConnect,setCellFormula,-1,1,0,null,1
+XLConnect,setCellFormula,0,1,0,class<`workbook`>,1
+XLConnect,setCellFormula,1,1,0,character,1
+XLConnect,setCellFormula,2,1,0,double,1
+XLConnect,setCellFormula,3,1,0,double,1
+XLConnect,setCellFormula,4,1,0,character,1
+XLConnect,setCellStyle,-1,0,0,null,1
+XLConnect,setCellStyle,0,0,0,class<`workbook`>,1
+XLConnect,setCellStyle,1,0,0,any,1
+XLConnect,setCellStyle,2,0,0,character,1
+XLConnect,setCellStyle,3,0,0,double[],1
+XLConnect,setCellStyle,4,0,0,double,1
+XLConnect,setCellStyle,4,0,1,integer[],1
+XLConnect,setCellStyle,5,0,0,class<`cellstyle`>,1
+XLConnect,setCellStyle,-1,1,0,null,1
+XLConnect,setCellStyle,0,1,0,class<`workbook`>,1
+XLConnect,setCellStyle,1,1,0,any,1
+XLConnect,setCellStyle,2,1,0,character,1
+XLConnect,setCellStyle,3,1,0,double[],1
+XLConnect,setCellStyle,4,1,0,double,1
+XLConnect,setCellStyle,4,1,1,integer[],1
+XLConnect,setCellStyle,5,1,0,class<`cellstyle`>,1
+XLConnect,setCellStyleForType,-1,0,0,null,1
+XLConnect,setCellStyleForType,0,0,0,class<`workbook`>,1
+XLConnect,setCellStyleForType,1,0,0,character,1
+XLConnect,setCellStyleForType,2,0,0,class<`cellstyle`>,1
+XLConnect,setCellStyleForType,-1,1,0,null,1
+XLConnect,setCellStyleForType,0,1,0,class<`workbook`>,1
+XLConnect,setCellStyleForType,1,1,0,character,1
+XLConnect,setCellStyleForType,2,1,0,class<`cellstyle`>,1
+XLConnect,setColumnWidth,-1,0,0,null,1
+XLConnect,setColumnWidth,0,0,0,class<`workbook`>,1
+XLConnect,setColumnWidth,1,0,0,character,1
+XLConnect,setColumnWidth,2,0,0,double,1
+XLConnect,setColumnWidth,3,0,0,double,1
+XLConnect,setColumnWidth,-1,1,0,null,1
+XLConnect,setColumnWidth,0,1,0,class<`workbook`>,1
+XLConnect,setColumnWidth,1,1,0,character,1
+XLConnect,setColumnWidth,2,1,0,double,1
+XLConnect,setColumnWidth,3,1,0,double,1
+XLConnect,setDataFormat,-1,0,0,null,1
+XLConnect,setDataFormat,0,0,0,class<`cellstyle`>,1
+XLConnect,setDataFormat,1,0,0,character,1
+XLConnect,setDataFormat,-1,1,0,null,1
+XLConnect,setDataFormat,0,1,0,class<`cellstyle`>,1
+XLConnect,setDataFormat,1,1,0,character,1
+XLConnect,setDataFormatForType,-1,0,0,null,1
+XLConnect,setDataFormatForType,0,0,0,class<`workbook`>,1
+XLConnect,setDataFormatForType,1,0,0,character,1
+XLConnect,setDataFormatForType,2,0,0,character,1
+XLConnect,setDataFormatForType,-1,1,0,null,1
+XLConnect,setDataFormatForType,0,1,0,class<`workbook`>,1
+XLConnect,setDataFormatForType,1,1,0,character,1
+XLConnect,setDataFormatForType,2,1,0,character,1
+XLConnect,setFillBackgroundColor,-1,0,0,null,1
+XLConnect,setFillBackgroundColor,0,0,0,class<`cellstyle`>,1
+XLConnect,setFillBackgroundColor,1,0,0,double,1
+XLConnect,setFillBackgroundColor,-1,1,0,null,1
+XLConnect,setFillBackgroundColor,0,1,0,class<`cellstyle`>,1
+XLConnect,setFillBackgroundColor,1,1,0,double,1
+XLConnect,setFillForegroundColor,-1,0,0,null,1
+XLConnect,setFillForegroundColor,0,0,0,class<`cellstyle`>,1
+XLConnect,setFillForegroundColor,1,0,0,double,1
+XLConnect,setFillForegroundColor,-1,1,0,null,1
+XLConnect,setFillForegroundColor,0,1,0,class<`cellstyle`>,1
+XLConnect,setFillForegroundColor,1,1,0,double,1
+XLConnect,setFillPattern,-1,0,0,null,1
+XLConnect,setFillPattern,0,0,0,class<`cellstyle`>,1
+XLConnect,setFillPattern,1,0,0,double,1
+XLConnect,setFillPattern,-1,1,0,null,1
+XLConnect,setFillPattern,0,1,0,class<`cellstyle`>,1
+XLConnect,setFillPattern,1,1,0,double,1
+XLConnect,setForceFormulaRecalculation,-1,0,0,null,1
+XLConnect,setForceFormulaRecalculation,0,0,0,class<`workbook`>,1
+XLConnect,setForceFormulaRecalculation,1,0,0,character,1
+XLConnect,setForceFormulaRecalculation,2,0,0,logical,1
+XLConnect,setForceFormulaRecalculation,-1,1,0,null,1
+XLConnect,setForceFormulaRecalculation,0,1,0,class<`workbook`>,1
+XLConnect,setForceFormulaRecalculation,1,1,0,double,1
+XLConnect,setForceFormulaRecalculation,2,1,0,logical,1
+XLConnect,setForceFormulaRecalculation,-1,2,0,null,1
+XLConnect,setForceFormulaRecalculation,0,2,0,class<`workbook`>,1
+XLConnect,setForceFormulaRecalculation,1,2,0,character,1
+XLConnect,setForceFormulaRecalculation,1,2,1,double,1
+XLConnect,setForceFormulaRecalculation,2,2,0,logical,1
+XLConnect,setHyperlink,-1,0,0,null,1
+XLConnect,setHyperlink,0,0,0,class<`workbook`>,1
+XLConnect,setHyperlink,1,0,0,any,1
+XLConnect,setHyperlink,2,0,0,character,1
+XLConnect,setHyperlink,3,0,0,double[],1
+XLConnect,setHyperlink,4,0,0,double,1
+XLConnect,setHyperlink,5,0,0,character,1
+XLConnect,setHyperlink,6,0,0,character[],1
+XLConnect,setHyperlink,-1,1,0,null,1
+XLConnect,setHyperlink,0,1,0,class<`workbook`>,1
+XLConnect,setHyperlink,1,1,0,any,1
+XLConnect,setHyperlink,2,1,0,character,1
+XLConnect,setHyperlink,3,1,0,double[],1
+XLConnect,setHyperlink,4,1,0,double,1
+XLConnect,setHyperlink,5,1,0,character,1
+XLConnect,setHyperlink,6,1,0,character[],1
+XLConnect,setMissingValue,-1,0,0,null,1
+XLConnect,setMissingValue,0,0,0,class<`workbook`>,1
+XLConnect,setMissingValue,1,0,0,character[],1
+XLConnect,setMissingValue,1,0,1,list<character | double>,1
+XLConnect,setMissingValue,1,0,2,null,1
+XLConnect,setMissingValue,-1,1,0,null,1
+XLConnect,setMissingValue,0,1,0,class<`workbook`>,1
+XLConnect,setMissingValue,1,1,0,character[],1
+XLConnect,setMissingValue,1,1,1,list<character | double>,1
+XLConnect,setMissingValue,1,1,2,null,1
+XLConnect,setRowHeight,-1,0,0,null,1
+XLConnect,setRowHeight,0,0,0,class<`workbook`>,1
+XLConnect,setRowHeight,1,0,0,character,1
+XLConnect,setRowHeight,2,0,0,double,1
+XLConnect,setRowHeight,3,0,0,double,1
+XLConnect,setRowHeight,-1,1,0,null,1
+XLConnect,setRowHeight,0,1,0,class<`workbook`>,1
+XLConnect,setRowHeight,1,1,0,character,1
+XLConnect,setRowHeight,2,1,0,double,1
+XLConnect,setRowHeight,3,1,0,double,1
+XLConnect,setSheetColor,-1,0,0,null,1
+XLConnect,setSheetColor,0,0,0,class<`workbook`>,1
+XLConnect,setSheetColor,1,0,0,character,1
+XLConnect,setSheetColor,2,0,0,double,1
+XLConnect,setSheetColor,-1,1,0,null,1
+XLConnect,setSheetColor,0,1,0,class<`workbook`>,1
+XLConnect,setSheetColor,1,1,0,character,1
+XLConnect,setSheetColor,1,1,1,double,1
+XLConnect,setSheetColor,2,1,0,double,1
+XLConnect,setSheetColor,-1,2,0,null,1
+XLConnect,setSheetColor,0,2,0,class<`workbook`>,1
+XLConnect,setSheetColor,1,2,0,double,1
+XLConnect,setSheetColor,2,2,0,double,1
+XLConnect,setSheetPos,-1,0,0,any,1
+XLConnect,setSheetPos,0,0,0,class<`workbook`>,1
+XLConnect,setSheetPos,1,0,0,character[],1
+XLConnect,setSheetPos,2,0,0,double[],1
+XLConnect,setSheetPos,-1,1,0,any,1
+XLConnect,setSheetPos,0,1,0,class<`workbook`>,1
+XLConnect,setSheetPos,1,1,0,character[],1
+XLConnect,setSheetPos,2,1,0,double[],1
+XLConnect,setStyleAction,-1,0,0,null,1
+XLConnect,setStyleAction,0,0,0,class<`workbook`>,1
+XLConnect,setStyleAction,1,0,0,character,1
+XLConnect,setStyleAction,-1,1,0,null,1
+XLConnect,setStyleAction,0,1,0,class<`workbook`>,1
+XLConnect,setStyleAction,1,1,0,character,1
+XLConnect,setStyleNamePrefix,-1,0,0,null,1
+XLConnect,setStyleNamePrefix,0,0,0,class<`workbook`>,1
+XLConnect,setStyleNamePrefix,1,0,0,character,1
+XLConnect,setStyleNamePrefix,-1,1,0,null,1
+XLConnect,setStyleNamePrefix,0,1,0,class<`workbook`>,1
+XLConnect,setStyleNamePrefix,1,1,0,character,1
+XLConnect,setWrapText,-1,0,0,null,1
+XLConnect,setWrapText,0,0,0,class<`cellstyle`>,1
+XLConnect,setWrapText,1,0,0,logical,1
+XLConnect,setWrapText,-1,1,0,null,1
+XLConnect,setWrapText,0,1,0,class<`cellstyle`>,1
+XLConnect,setWrapText,1,1,0,logical,1
+XLConnect,summary,-1,0,0,null,1
+XLConnect,summary,0,0,0,class<`workbook`>,1
+XLConnect,summary,1,0,0,...,1
+XLConnect,unhideSheet,-1,0,0,null,1
+XLConnect,unhideSheet,0,0,0,class<`workbook`>,1
+XLConnect,unhideSheet,1,0,0,character,1
+XLConnect,unhideSheet,-1,1,0,null,1
+XLConnect,unhideSheet,0,1,0,class<`workbook`>,1
+XLConnect,unhideSheet,1,1,0,character,1
+XLConnect,unmergeCells,-1,0,0,null,1
+XLConnect,unmergeCells,0,0,0,class<`workbook`>,1
+XLConnect,unmergeCells,1,0,0,character,1
+XLConnect,unmergeCells,2,0,0,character,1
+XLConnect,unmergeCells,-1,1,0,null,1
+XLConnect,unmergeCells,0,1,0,class<`workbook`>,1
+XLConnect,unmergeCells,1,1,0,character,1
+XLConnect,unmergeCells,2,1,0,character,1
+XLConnect,with.workbook,-1,0,0,class<`table`>,1
+XLConnect,with.workbook,-1,0,1,logical,1
+XLConnect,with.workbook,0,0,0,class<`workbook`>,1
+XLConnect,with.workbook,1,0,0,any,1
+XLConnect,with.workbook,2,0,0,...,1
+XLConnect,wrapList,-1,0,0,"list<class<`data.frame`, `groupedData`, `nfGroupedData`, `nfnGroupedData`>>",1
+XLConnect,wrapList,-1,0,1,list<class<`data.frame`>>,1
+XLConnect,wrapList,-1,0,2,list<class<`jarrayRef`>>,1
+XLConnect,wrapList,-1,0,3,list<class<`jobjRef`>>,1
+XLConnect,wrapList,0,0,0,"class<`data.frame`, `groupedData`, `nfGroupedData`, `nfnGroupedData`>",1
+XLConnect,wrapList,0,0,1,class<`data.frame`>,1
+XLConnect,wrapList,0,0,2,list<class<`jarrayRef`>>,1
+XLConnect,wrapList,0,0,3,class<`jarrayRef`>,1
+XLConnect,wrapList,0,0,4,class<`cellstyle`>,1
+XLConnect,wrapList,0,0,5,list<class<`jobjRef`>>,1
+XLConnect,wrapList,0,0,6,list<class<`data.frame`>>,1
+XLConnect,writeNamedRegion,-1,0,0,any,1
+XLConnect,writeNamedRegion,0,0,0,class<`workbook`>,1
+XLConnect,writeNamedRegion,1,0,0,class<`data.frame`>,1
+XLConnect,writeNamedRegion,1,0,1,class<`function`>,1
+XLConnect,writeNamedRegion,2,0,0,character,1
+XLConnect,writeNamedRegion,3,0,0,logical,1
+XLConnect,writeNamedRegion,4,0,0,null,1
+XLConnect,writeNamedRegion,4,0,1,character,1
+XLConnect,writeNamedRegion,-1,1,0,any,1
+XLConnect,writeNamedRegion,0,1,0,class<`workbook`>,1
+XLConnect,writeNamedRegion,1,1,0,class<`data.frame`>,1
+XLConnect,writeNamedRegion,1,1,1,class<`function`>,1
+XLConnect,writeNamedRegion,2,1,0,character,1
+XLConnect,writeNamedRegion,3,1,0,logical,1
+XLConnect,writeNamedRegion,4,1,0,null,1
+XLConnect,writeNamedRegion,4,1,1,character,1
+XLConnect,writeNamedRegionToFile,-1,0,0,class<`workbook`>,1
+XLConnect,writeNamedRegionToFile,0,0,0,character,1
+XLConnect,writeNamedRegionToFile,1,0,0,class<`data.frame`>,1
+XLConnect,writeNamedRegionToFile,2,0,0,character,1
+XLConnect,writeNamedRegionToFile,3,0,0,character,1
+XLConnect,writeNamedRegionToFile,3,0,1,null,1
+XLConnect,writeNamedRegionToFile,4,0,0,...,1
+XLConnect,writeNamedRegionToFile,5,0,0,character,1
+XLConnect,writeNamedRegionToFile,6,0,0,logical,1
+XLConnect,writeWorksheet,-1,0,0,null,1
+XLConnect,writeWorksheet,0,0,0,class<`workbook`>,1
+XLConnect,writeWorksheet,1,0,0,"class<`data.frame`, `groupedData`, `nfGroupedData`, `nfnGroupedData`>",1
+XLConnect,writeWorksheet,2,0,0,character,1
+XLConnect,writeWorksheet,3,0,0,double,1
+XLConnect,writeWorksheet,4,0,0,double,1
+XLConnect,writeWorksheet,5,0,0,logical,1
+XLConnect,writeWorksheet,6,0,0,character,1
+XLConnect,writeWorksheet,6,0,1,null,1
+XLConnect,writeWorksheet,-1,1,0,any,1
+XLConnect,writeWorksheet,0,1,0,class<`workbook`>,1
+XLConnect,writeWorksheet,1,1,0,class<`data.frame`>,1
+XLConnect,writeWorksheet,1,1,1,class<`function`>,1
+XLConnect,writeWorksheet,1,1,2,"class<`data.frame`, `groupedData`, `nfGroupedData`, `nfnGroupedData`>",1
+XLConnect,writeWorksheet,1,1,3,list<any>,1
+XLConnect,writeWorksheet,2,1,0,character,1
+XLConnect,writeWorksheet,3,1,0,double,1
+XLConnect,writeWorksheet,4,1,0,double,1
+XLConnect,writeWorksheet,5,1,0,logical,1
+XLConnect,writeWorksheet,6,1,0,null,1
+XLConnect,writeWorksheet,6,1,1,character,1
+XLConnect,writeWorksheet,-1,2,0,any,1
+XLConnect,writeWorksheet,0,2,0,class<`workbook`>,1
+XLConnect,writeWorksheet,1,2,0,class<`function`>,1
+XLConnect,writeWorksheet,2,2,0,character,1
+XLConnect,writeWorksheet,3,2,0,double,1
+XLConnect,writeWorksheet,4,2,0,double,1
+XLConnect,writeWorksheet,5,2,0,logical,1
+XLConnect,writeWorksheet,6,2,0,null,1
+XLConnect,writeWorksheet,-1,3,0,any,1
+XLConnect,writeWorksheet,0,3,0,class<`workbook`>,1
+XLConnect,writeWorksheet,1,3,0,class<`data.frame`>,1
+XLConnect,writeWorksheet,2,3,0,character,1
+XLConnect,writeWorksheet,3,3,0,double,1
+XLConnect,writeWorksheet,4,3,0,double,1
+XLConnect,writeWorksheet,5,3,0,logical,1
+XLConnect,writeWorksheet,6,3,0,null,1
+XLConnect,writeWorksheet,6,3,1,character,1
+XLConnect,writeWorksheetToFile,-1,0,0,class<`workbook`>,1
+XLConnect,writeWorksheetToFile,0,0,0,character,1
+XLConnect,writeWorksheetToFile,1,0,0,class<`data.frame`>,1
+XLConnect,writeWorksheetToFile,1,0,1,"class<`data.frame`, `groupedData`, `nfGroupedData`, `nfnGroupedData`>",1
+XLConnect,writeWorksheetToFile,1,0,2,list<any>,1
+XLConnect,writeWorksheetToFile,2,0,0,character[],1
+XLConnect,writeWorksheetToFile,3,0,0,...,1
+XLConnect,writeWorksheetToFile,4,0,0,character,1
+XLConnect,writeWorksheetToFile,5,0,0,logical,1
+XLConnect,xlcCall,-1,0,0,any,1
+XLConnect,xlcCall,0,0,0,class<`workbook`>,1
+XLConnect,xlcCall,0,0,1,class<`cellstyle`>,1
+XLConnect,xlcCall,1,0,0,character,1
+XLConnect,xlcCall,2,0,0,...,1
+XLConnect,xlcCall,3,0,0,logical,1
+XLConnect,xlcCall,4,0,0,logical,1
+XLConnect,xlcDump,-1,0,0,logical[],1
+XLConnect,xlcDump,0,0,0,character[],1
+XLConnect,xlcDump,1,0,0,...,1
+XLConnect,xlcDump,2,0,0,character,1
+XLConnect,xlcDump,3,0,0,character,1
+XLConnect,xlcDump,4,0,0,logical,1
+XLConnect,xlcFreeMemory,-1,0,0,null,1
+XLConnect,xlcFreeMemory,0,0,0,...,1
+XLConnect,xlcMemoryReport,-1,0,0,null,1
+XLConnect,XLConnectSettings,-1,0,0,null,1
+XLConnect,XLConnectSettings,0,0,0,class<`packageDescription`>,1
+XLConnect,xlcRestore,-1,0,0,logical[],1
+XLConnect,xlcRestore,0,0,0,character,1
+XLConnect,xlcRestore,1,0,0,double,1
+XLConnect,xlcRestore,2,0,0,logical,1
+abind,abind,-1,0,0,class<`array`>,1
+abind,abind,-1,0,1,class<`matrix`>,1
+abind,abind,-1,0,2,null,1
+abind,abind,0,0,0,...,1
+abind,abind,1,0,0,any,1
+abind,abind,2,0,0,double,1
+abind,abind,2,0,1,null,1
+abind,abind,3,0,0,null,1
+abind,abind,4,0,0,logical,1
+abind,abind,5,0,0,any,1
+abind,abind,6,0,0,logical,1
+abind,abind,7,0,0,logical,1
+abind,abind,8,0,0,logical,1
+abind,abind,8,0,1,character,1
+abind,abind,9,0,0,logical,1
+abind,acorn,-1,0,0,class<`array`>,1
+abind,acorn,0,0,0,class<`array`>,1
+abind,acorn,1,0,0,double,1
+abind,acorn,2,0,0,double,1
+abind,acorn,3,0,0,double,1
+abind,acorn,4,0,0,...,1
+abind,acorn.default,-1,0,0,class<`array`>,1
+abind,acorn.default,0,0,0,class<`array`>,1
+abind,acorn.default,1,0,0,double,1
+abind,acorn.default,2,0,0,double,1
+abind,acorn.default,3,0,0,double,1
+abind,acorn.default,4,0,0,...,1
+abind,acorn.default,5,0,0,logical,1
+abind,adrop,-1,0,0,any,1
+abind,adrop,0,0,0,class<`array`>,1
+abind,adrop,1,0,0,integer[],1
+abind,adrop,1,0,1,double,1
+abind,adrop,2,0,0,logical,1
+abind,adrop,3,0,0,logical,1
+abind,adrop,4,0,0,...,1
+abind,adrop.default,-1,0,0,any,1
+abind,adrop.default,0,0,0,class<`array`>,1
+abind,adrop.default,1,0,0,integer[],1
+abind,adrop.default,1,0,1,double,1
+abind,adrop.default,2,0,0,logical,1
+abind,adrop.default,3,0,0,logical,1
+abind,adrop.default,4,0,0,...,1
+abind,afill<-,-1,0,0,any,1
+abind,afill<-,0,0,0,class<`array`>,1
+abind,afill<-,0,0,1,class<`matrix`>,1
+abind,afill<-,1,0,0,...,1
+abind,afill<-,2,0,0,logical,1
+abind,afill<-,3,0,0,logical,1
+abind,afill<-,4,0,0,class<`matrix`>,1
+abind,afill<-.default,-1,0,0,any,1
+abind,afill<-.default,0,0,0,class<`array`>,1
+abind,afill<-.default,0,0,1,class<`matrix`>,1
+abind,afill<-.default,1,0,0,...,1
+abind,afill<-.default,2,0,0,logical,1
+abind,afill<-.default,3,0,0,logical,1
+abind,afill<-.default,4,0,0,class<`matrix`>,1
+abind,asub,-1,0,0,class<`array`>,1
+abind,asub,-1,0,1,class<`matrix`>,1
+abind,asub,-1,0,2,integer[],1
+abind,asub,0,0,0,class<`array`>,1
+abind,asub,0,0,1,class<`matrix`>,1
+abind,asub,0,0,2,integer[],1
+abind,asub,1,0,0,double,1
+abind,asub,1,0,1,integer[],1
+abind,asub,1,0,2,list<double[]>,1
+abind,asub,1,0,3,list<integer[] | double>,1
+abind,asub,1,0,4,list<integer[] | null>,1
+abind,asub,1,0,5,list<null | double>,1
+abind,asub,1,0,6,list<double | character[]>,1
+abind,asub,1,0,7,list<character[]>,1
+abind,asub,2,0,0,any,1
+abind,asub,3,0,0,logical,1
+abind,asub,3,0,1,null,1
+abind,asub,4,0,0,...,1
+abind,asub.default,-1,0,0,class<`array`>,1
+abind,asub.default,-1,0,1,class<`matrix`>,1
+abind,asub.default,-1,0,2,integer[],1
+abind,asub.default,0,0,0,class<`array`>,1
+abind,asub.default,0,0,1,class<`matrix`>,1
+abind,asub.default,0,0,2,integer[],1
+abind,asub.default,1,0,0,double,1
+abind,asub.default,1,0,1,integer[],1
+abind,asub.default,1,0,2,list<double[]>,1
+abind,asub.default,1,0,3,list<integer[] | double>,1
+abind,asub.default,1,0,4,list<integer[] | null>,1
+abind,asub.default,1,0,5,list<null | double>,1
+abind,asub.default,1,0,6,list<double | character[]>,1
+abind,asub.default,1,0,7,list<character[]>,1
+abind,asub.default,2,0,0,double[],1
+abind,asub.default,3,0,0,logical,1
+abind,asub.default,3,0,1,null,1
+abind,asub.default,4,0,0,...,1
+actuar,adjCoef,-1,0,0,"class<`adjCoef`, `function`>",1
+actuar,adjCoef,-1,0,1,double,1
+actuar,adjCoef,0,0,0,any,1
+actuar,adjCoef,1,0,0,any,1
+actuar,adjCoef,2,0,0,any,1
+actuar,adjCoef,3,0,0,double,1
+actuar,adjCoef,4,0,0,any,1
+actuar,adjCoef,5,0,0,character[],1
+actuar,adjCoef,6,0,0,any,1
+actuar,adjCoef,7,0,0,any,1
+actuar,adjCoef,8,0,0,double,1
+actuar,aggregateDist,-1,0,0,"class<`aggregateDist`, `ecdf`, `function`, `stepfun`>",1
+actuar,aggregateDist,-1,0,1,"class<`aggregateDist`, `function`>",1
+actuar,aggregateDist,0,0,0,character,1
+actuar,aggregateDist,1,0,0,character,1
+actuar,aggregateDist,1,0,1,double[],1
+actuar,aggregateDist,1,0,2,expression,1
+actuar,aggregateDist,1,0,3,null,1
+actuar,aggregateDist,2,0,0,double[],1
+actuar,aggregateDist,2,0,1,expression,1
+actuar,aggregateDist,2,0,2,null,1
+actuar,aggregateDist,3,0,0,double,1
+actuar,aggregateDist,3,0,1,null,1
+actuar,aggregateDist,4,0,0,double,1
+actuar,aggregateDist,5,0,0,double,1
+actuar,aggregateDist,6,0,0,any,1
+actuar,aggregateDist,7,0,0,any,1
+actuar,aggregateDist,8,0,0,...,1
+actuar,aggregateDist,9,0,0,double,1
+actuar,aggregateDist,10,0,0,double,1
+actuar,aggregateDist,11,0,0,logical,1
+actuar,aggregate.portfolio,-1,0,0,class<`matrix`>,1
+actuar,aggregate.portfolio,-1,0,1,double[],1
+actuar,aggregate.portfolio,0,0,0,class<`portfolio`>,1
+actuar,aggregate.portfolio,1,0,0,character[],1
+actuar,aggregate.portfolio,2,0,0,class<`function`>,1
+actuar,aggregate.portfolio,3,0,0,logical,1
+actuar,aggregate.portfolio,4,0,0,null,1
+actuar,aggregate.portfolio,4,0,1,character,1
+actuar,aggregate.portfolio,5,0,0,...,1
+actuar,bayes,-1,0,0,class<`bayes`>,1
+actuar,bayes,0,0,0,double[],1
+actuar,bayes,1,0,0,character,1
+actuar,bayes,2,0,0,any,1
+actuar,bayes,3,0,0,double,1
+actuar,bayes,4,0,0,any,1
+actuar,bayes,5,0,0,any,1
+actuar,bayes,6,0,0,any,1
+actuar,bayes,7,0,0,double,1
+actuar,bayes,8,0,0,double,1
+actuar,bayes,9,0,0,any,1
+actuar,bayes,10,0,0,any,1
+actuar,bayes,11,0,0,any,1
+actuar,bayes,12,0,0,any,1
+actuar,bstraub,-1,0,0,class<`bstraub`>,1
+actuar,bstraub,0,0,0,class<`matrix`>,1
+actuar,bstraub,1,0,0,class<`matrix`>,1
+actuar,bstraub,2,0,0,character,1
+actuar,bstraub,3,0,0,any,1
+actuar,bstraub,4,0,0,any,1
+actuar,bstraub,5,0,0,any,1
+actuar,bvar.unbiased,-1,0,0,double,1
+actuar,bvar.unbiased,0,0,0,double[],1
+actuar,bvar.unbiased,1,0,0,double[],1
+actuar,bvar.unbiased,2,0,0,double,1
+actuar,bvar.unbiased,3,0,0,integer,1
+actuar,cm,-1,0,0,"class<`bayes`, `cm`>",1
+actuar,cm,-1,0,1,"class<`bstraub`, `cm`>",1
+actuar,cm,-1,0,2,"class<`cm`, `hache`>",1
+actuar,cm,-1,0,3,"class<`cm`, `hierarc`>",1
+actuar,cm,0,0,0,character,1
+actuar,cm,0,0,1,class<`formula`>,1
+actuar,cm,1,0,0,any,1
+actuar,cm,2,0,0,any,1
+actuar,cm,3,0,0,any,1
+actuar,cm,4,0,0,any,1
+actuar,cm,5,0,0,null,1
+actuar,cm,5,0,1,class<`formula`>,1
+actuar,cm,6,0,0,any,1
+actuar,cm,7,0,0,logical,1
+actuar,cm,8,0,0,any,1
+actuar,cm,9,0,0,any,1
+actuar,cm,10,0,0,...,1
+actuar,cm,11,0,0,any,1
+actuar,cm,12,0,0,double,1
+actuar,cm,13,0,0,logical,1
+actuar,coverage,-1,0,0,class<`function`>,1
+actuar,coverage,0,0,0,any,1
+actuar,coverage,1,0,0,any,1
+actuar,coverage,2,0,0,double,1
+actuar,coverage,3,0,0,logical,1
+actuar,coverage,4,0,0,double,1
+actuar,coverage,5,0,0,double,1
+actuar,coverage,6,0,0,double,1
+actuar,coverage,7,0,0,logical,1
+actuar,CTE,-1,0,0,double[],1
+actuar,CTE,0,0,0,"class<`aggregateDist`, `ecdf`, `function`, `stepfun`>",1
+actuar,CTE,1,0,0,...,1
+actuar,CTE.aggregateDist,-1,0,0,double[],1
+actuar,CTE.aggregateDist,0,0,0,"class<`aggregateDist`, `ecdf`, `function`, `stepfun`>",1
+actuar,CTE.aggregateDist,1,0,0,double[],1
+actuar,CTE.aggregateDist,2,0,0,logical,1
+actuar,CTE.aggregateDist,3,0,0,...,1
+actuar,dburr,-1,0,0,double,1
+actuar,dburr,0,0,0,double,1
+actuar,dburr,1,0,0,double,1
+actuar,dburr,2,0,0,double,1
+actuar,dburr,3,0,0,double,1
+actuar,dburr,4,0,0,double,1
+actuar,dburr,5,0,0,logical,1
+actuar,dgenbeta,-1,0,0,double,1
+actuar,dgenbeta,0,0,0,double,1
+actuar,dgenbeta,1,0,0,double,1
+actuar,dgenbeta,2,0,0,double,1
+actuar,dgenbeta,3,0,0,double,1
+actuar,dgenbeta,4,0,0,double,1
+actuar,dgenbeta,5,0,0,double,1
+actuar,dgenbeta,6,0,0,logical,1
+actuar,dgenpareto,-1,0,0,double,1
+actuar,dgenpareto,0,0,0,double,1
+actuar,dgenpareto,1,0,0,double,1
+actuar,dgenpareto,2,0,0,double,1
+actuar,dgenpareto,3,0,0,double,1
+actuar,dgenpareto,4,0,0,double,1
+actuar,dgenpareto,5,0,0,logical,1
+actuar,dgumbel,-1,0,0,double[],1
+actuar,dgumbel,0,0,0,double[],1
+actuar,dgumbel,1,0,0,double,1
+actuar,dgumbel,2,0,0,double,1
+actuar,dgumbel,3,0,0,logical,1
+actuar,diff.aggregateDist,-1,0,0,double[],1
+actuar,diff.aggregateDist,0,0,0,"class<`aggregateDist`, `ecdf`, `function`, `stepfun`>",1
+actuar,diff.aggregateDist,1,0,0,...,1
+actuar,dinvburr,-1,0,0,double,1
+actuar,dinvburr,0,0,0,double,1
+actuar,dinvburr,1,0,0,double,1
+actuar,dinvburr,2,0,0,double,1
+actuar,dinvburr,3,0,0,double,1
+actuar,dinvburr,4,0,0,double,1
+actuar,dinvburr,5,0,0,logical,1
+actuar,dinvexp,-1,0,0,double,1
+actuar,dinvexp,0,0,0,double,1
+actuar,dinvexp,1,0,0,double,1
+actuar,dinvexp,2,0,0,double,1
+actuar,dinvexp,3,0,0,logical,1
+actuar,dinvgamma,-1,0,0,double,1
+actuar,dinvgamma,0,0,0,double,1
+actuar,dinvgamma,1,0,0,double,1
+actuar,dinvgamma,2,0,0,double,1
+actuar,dinvgamma,3,0,0,double,1
+actuar,dinvgamma,4,0,0,logical,1
+actuar,dinvgauss,-1,0,0,double[],1
+actuar,dinvgauss,0,0,0,double[],1
+actuar,dinvgauss,1,0,0,double,1
+actuar,dinvgauss,2,0,0,double,1
+actuar,dinvgauss,3,0,0,double,1
+actuar,dinvgauss,4,0,0,logical,1
+actuar,dinvparalogis,-1,0,0,double,1
+actuar,dinvparalogis,0,0,0,double,1
+actuar,dinvparalogis,1,0,0,double,1
+actuar,dinvparalogis,2,0,0,double,1
+actuar,dinvparalogis,3,0,0,double,1
+actuar,dinvparalogis,4,0,0,logical,1
+actuar,dinvpareto,-1,0,0,double,1
+actuar,dinvpareto,0,0,0,double,1
+actuar,dinvpareto,1,0,0,double,1
+actuar,dinvpareto,2,0,0,double,1
+actuar,dinvpareto,3,0,0,logical,1
+actuar,dinvtrgamma,-1,0,0,double,1
+actuar,dinvtrgamma,0,0,0,double,1
+actuar,dinvtrgamma,1,0,0,double,1
+actuar,dinvtrgamma,2,0,0,double,1
+actuar,dinvtrgamma,3,0,0,double,1
+actuar,dinvtrgamma,4,0,0,double,1
+actuar,dinvtrgamma,5,0,0,logical,1
+actuar,dinvweibull,-1,0,0,double,1
+actuar,dinvweibull,0,0,0,double,1
+actuar,dinvweibull,1,0,0,double,1
+actuar,dinvweibull,2,0,0,double,1
+actuar,dinvweibull,3,0,0,double,1
+actuar,dinvweibull,4,0,0,logical,1
+actuar,discretize,-1,0,0,double[],1
+actuar,discretize,0,0,0,any,1
+actuar,discretize,1,0,0,double,1
+actuar,discretize,2,0,0,double,1
+actuar,discretize,3,0,0,double,1
+actuar,discretize,4,0,0,character,1
+actuar,discretize,5,0,0,any,1
+actuar,discretize,6,0,0,double,1
+actuar,discretize,7,0,0,null,1
+actuar,dlgamma,-1,0,0,double,1
+actuar,dlgamma,0,0,0,double,1
+actuar,dlgamma,1,0,0,double,1
+actuar,dlgamma,2,0,0,double,1
+actuar,dlgamma,3,0,0,logical,1
+actuar,dllogis,-1,0,0,double,1
+actuar,dllogis,0,0,0,double,1
+actuar,dllogis,1,0,0,double,1
+actuar,dllogis,2,0,0,double,1
+actuar,dllogis,3,0,0,double,1
+actuar,dllogis,4,0,0,logical,1
+actuar,dlogarithmic,-1,0,0,double[],1
+actuar,dlogarithmic,0,0,0,double,1
+actuar,dlogarithmic,0,0,1,integer[],1
+actuar,dlogarithmic,1,0,0,double[],1
+actuar,dlogarithmic,2,0,0,logical,1
+actuar,dparalogis,-1,0,0,double,1
+actuar,dparalogis,0,0,0,double,1
+actuar,dparalogis,1,0,0,double,1
+actuar,dparalogis,2,0,0,double,1
+actuar,dparalogis,3,0,0,double,1
+actuar,dparalogis,4,0,0,logical,1
+actuar,dpareto,-1,0,0,double,1
+actuar,dpareto,0,0,0,double,1
+actuar,dpareto,1,0,0,double,1
+actuar,dpareto,2,0,0,double,1
+actuar,dpareto,3,0,0,logical,1
+actuar,dpareto1,-1,0,0,double,1
+actuar,dpareto1,0,0,0,double,1
+actuar,dpareto1,1,0,0,double,1
+actuar,dpareto1,2,0,0,double,1
+actuar,dpareto1,3,0,0,logical,1
+actuar,dphtype,-1,0,0,double[],1
+actuar,dphtype,0,0,0,integer[],1
+actuar,dphtype,1,0,0,double[],1
+actuar,dphtype,2,0,0,class<`matrix`>,1
+actuar,dphtype,3,0,0,logical,1
+actuar,dpoisinvgauss,-1,0,0,double[],1
+actuar,dpoisinvgauss,0,0,0,integer[],1
+actuar,dpoisinvgauss,1,0,0,double,1
+actuar,dpoisinvgauss,2,0,0,double,1
+actuar,dpoisinvgauss,3,0,0,double,1
+actuar,dpoisinvgauss,4,0,0,logical,1
+actuar,dtrbeta,-1,0,0,double,1
+actuar,dtrbeta,0,0,0,double,1
+actuar,dtrbeta,1,0,0,double,1
+actuar,dtrbeta,2,0,0,double,1
+actuar,dtrbeta,3,0,0,double,1
+actuar,dtrbeta,4,0,0,double,1
+actuar,dtrbeta,5,0,0,double,1
+actuar,dtrbeta,6,0,0,logical,1
+actuar,dtrgamma,-1,0,0,double,1
+actuar,dtrgamma,0,0,0,double,1
+actuar,dtrgamma,1,0,0,double,1
+actuar,dtrgamma,2,0,0,double,1
+actuar,dtrgamma,3,0,0,double,1
+actuar,dtrgamma,4,0,0,double,1
+actuar,dtrgamma,5,0,0,logical,1
+actuar,dzmbinom,-1,0,0,double[],1
+actuar,dzmbinom,0,0,0,integer[],1
+actuar,dzmbinom,1,0,0,double,1
+actuar,dzmbinom,2,0,0,double,1
+actuar,dzmbinom,3,0,0,double,1
+actuar,dzmbinom,4,0,0,logical,1
+actuar,dzmgeom,-1,0,0,double[],1
+actuar,dzmgeom,0,0,0,integer[],1
+actuar,dzmgeom,1,0,0,double,1
+actuar,dzmgeom,2,0,0,double,1
+actuar,dzmgeom,3,0,0,logical,1
+actuar,dzmlogarithmic,-1,0,0,double[],1
+actuar,dzmlogarithmic,0,0,0,integer[],1
+actuar,dzmlogarithmic,1,0,0,double,1
+actuar,dzmlogarithmic,2,0,0,double,1
+actuar,dzmlogarithmic,3,0,0,logical,1
+actuar,dzmnbinom,-1,0,0,double[],1
+actuar,dzmnbinom,0,0,0,integer[],1
+actuar,dzmnbinom,1,0,0,double,1
+actuar,dzmnbinom,2,0,0,double,1
+actuar,dzmnbinom,3,0,0,double,1
+actuar,dzmnbinom,4,0,0,logical,1
+actuar,dzmpois,-1,0,0,double[],1
+actuar,dzmpois,0,0,0,integer[],1
+actuar,dzmpois,1,0,0,double,1
+actuar,dzmpois,2,0,0,double,1
+actuar,dzmpois,3,0,0,logical,1
+actuar,dztbinom,-1,0,0,double[],1
+actuar,dztbinom,0,0,0,integer[],1
+actuar,dztbinom,0,0,1,double,1
+actuar,dztbinom,1,0,0,double,1
+actuar,dztbinom,2,0,0,double,1
+actuar,dztbinom,3,0,0,logical,1
+actuar,dztgeom,-1,0,0,double[],1
+actuar,dztgeom,0,0,0,double[],1
+actuar,dztgeom,1,0,0,double,1
+actuar,dztgeom,2,0,0,logical,1
+actuar,dztnbinom,-1,0,0,double[],1
+actuar,dztnbinom,0,0,0,double[],1
+actuar,dztnbinom,1,0,0,double,1
+actuar,dztnbinom,2,0,0,double,1
+actuar,dztnbinom,3,0,0,logical,1
+actuar,dztpois,-1,0,0,double[],1
+actuar,dztpois,0,0,0,integer[],1
+actuar,dztpois,0,0,1,double,1
+actuar,dztpois,1,0,0,double,1
+actuar,dztpois,2,0,0,logical,1
+actuar,elev,-1,0,0,"class<`elev`, `function`>",1
+actuar,elev,0,0,0,"class<`data.frame`, `grouped.data`>",1
+actuar,elev,0,0,1,double[],1
+actuar,elev,1,0,0,...,1
+actuar,elev.default,-1,0,0,"class<`elev`, `function`>",1
+actuar,elev.default,0,0,0,double[],1
+actuar,elev.default,1,0,0,...,1
+actuar,elev.grouped.data,-1,0,0,"class<`elev`, `function`>",1
+actuar,elev.grouped.data,0,0,0,"class<`data.frame`, `grouped.data`>",1
+actuar,elev.grouped.data,1,0,0,...,1
+actuar,emm,-1,0,0,double[],1
+actuar,emm,0,0,0,"class<`data.frame`, `grouped.data`>",1
+actuar,emm,0,0,1,double[],1
+actuar,emm,1,0,0,integer[],1
+actuar,emm,1,0,1,double,1
+actuar,emm,2,0,0,...,1
+actuar,emm.default,-1,0,0,double[],1
+actuar,emm.default,0,0,0,double[],1
+actuar,emm.default,1,0,0,integer[],1
+actuar,emm.default,2,0,0,...,1
+actuar,emm.grouped.data,-1,0,0,double[],1
+actuar,emm.grouped.data,0,0,0,"class<`data.frame`, `grouped.data`>",1
+actuar,emm.grouped.data,1,0,0,integer[],1
+actuar,emm.grouped.data,1,0,1,double,1
+actuar,emm.grouped.data,2,0,0,...,1
+actuar,exact,-1,0,0,"class<`ecdf`, `function`, `stepfun`>",1
+actuar,exact,0,0,0,double[],1
+actuar,exact,1,0,0,double[],1
+actuar,exact,2,0,0,double,1
+actuar,frequency.portfolio,-1,0,0,class<`matrix`>,1
+actuar,frequency.portfolio,0,0,0,class<`portfolio`>,1
+actuar,frequency.portfolio,1,0,0,character[],1
+actuar,frequency.portfolio,2,0,0,logical,1
+actuar,frequency.portfolio,3,0,0,character,1
+actuar,frequency.portfolio,3,0,1,null,1
+actuar,frequency.portfolio,4,0,0,...,1
+actuar,[<-.grouped.data,-1,0,0,"class<`data.frame`, `grouped.data`>",1
+actuar,[<-.grouped.data,0,0,0,"class<`data.frame`, `grouped.data`>",1
+actuar,[<-.grouped.data,1,0,0,any,1
+actuar,[<-.grouped.data,2,0,0,double[],1
+actuar,[<-.grouped.data,3,0,0,double[],1
+actuar,[.grouped.data,-1,0,0,class<`data.frame`>,1
+actuar,[.grouped.data,-1,0,1,"class<`data.frame`, `grouped.data`>",1
+actuar,[.grouped.data,-1,0,2,double[],1
+actuar,[.grouped.data,0,0,0,"class<`data.frame`, `grouped.data`>",1
+actuar,[.grouped.data,1,0,0,any,1
+actuar,[.grouped.data,2,0,0,any,1
+actuar,grouped.data,-1,0,0,"class<`data.frame`, `grouped.data`>",1
+actuar,grouped.data,0,0,0,...,1
+actuar,grouped.data,1,0,0,character,1
+actuar,grouped.data,1,0,1,double[],1
+actuar,grouped.data,2,0,0,logical,1
+actuar,grouped.data,3,0,0,logical,1
+actuar,grouped.data,4,0,0,null,1
+actuar,grouped.data,5,0,0,logical,1
+actuar,grouped.data,6,0,0,null,1
+actuar,grouped.data,7,0,0,logical,1
+actuar,grouped.data,8,0,0,logical,1
+actuar,hache,-1,0,0,class<`hache`>,1
+actuar,hache,0,0,0,class<`matrix`>,1
+actuar,hache,1,0,0,class<`matrix`>,1
+actuar,hache,2,0,0,class<`formula`>,1
+actuar,hache,3,0,0,class<`data.frame`>,1
+actuar,hache,4,0,0,logical,1
+actuar,hache,5,0,0,any,1
+actuar,hache,6,0,0,any,1
+actuar,hache,7,0,0,any,1
+actuar,hache,8,0,0,any,1
+actuar,hache.barycenter,-1,0,0,list<any>,1
+actuar,hache.barycenter,0,0,0,class<`matrix`>,1
+actuar,hache.barycenter,1,0,0,class<`matrix`>,1
+actuar,hache.barycenter,2,0,0,class<`matrix`>,1
+actuar,hache.barycenter,3,0,0,character,1
+actuar,hache.barycenter,4,0,0,any,1
+actuar,hache.barycenter,5,0,0,any,1
+actuar,hache.barycenter,6,0,0,any,1
+actuar,hache.origin,-1,0,0,list<null | class<`array`> | list<any>>,1
+actuar,hache.origin,0,0,0,class<`matrix`>,1
+actuar,hache.origin,1,0,0,class<`matrix`>,1
+actuar,hache.origin,2,0,0,class<`matrix`>,1
+actuar,hache.origin,3,0,0,double,1
+actuar,hache.origin,4,0,0,double,1
+actuar,hache.origin,5,0,0,logical,1
+actuar,hierarc,-1,0,0,class<`hierarc`>,1
+actuar,hierarc,0,0,0,class<`matrix`>,1
+actuar,hierarc,1,0,0,class<`matrix`>,1
+actuar,hierarc,2,0,0,class<`matrix`>,1
+actuar,hierarc,3,0,0,character[],1
+actuar,hierarc,4,0,0,any,1
+actuar,hierarc,5,0,0,any,1
+actuar,hierarc,6,0,0,any,1
+actuar,hist.grouped.data,-1,0,0,class<`histogram`>,1
+actuar,hist.grouped.data,0,0,0,"class<`data.frame`, `grouped.data`>",1
+actuar,hist.grouped.data,1,0,0,null,1
+actuar,hist.grouped.data,2,0,0,any,1
+actuar,hist.grouped.data,3,0,0,null,1
+actuar,hist.grouped.data,4,0,0,double,1
+actuar,hist.grouped.data,5,0,0,null,1
+actuar,hist.grouped.data,6,0,0,null,1
+actuar,hist.grouped.data,7,0,0,character,1
+actuar,hist.grouped.data,8,0,0,double[],1
+actuar,hist.grouped.data,9,0,0,null,1
+actuar,hist.grouped.data,10,0,0,character,1
+actuar,hist.grouped.data,11,0,0,any,1
+actuar,hist.grouped.data,12,0,0,logical,1
+actuar,hist.grouped.data,13,0,0,logical,1
+actuar,hist.grouped.data,14,0,0,logical,1
+actuar,hist.grouped.data,15,0,0,...,1
+actuar,knots.elev,-1,0,0,double[],1
+actuar,knots.elev,0,0,0,"class<`elev`, `function`>",1
+actuar,knots.elev,1,0,0,...,1
+actuar,levbeta,-1,0,0,double,1
+actuar,levbeta,0,0,0,double,1
+actuar,levbeta,1,0,0,double,1
+actuar,levbeta,2,0,0,double,1
+actuar,levbeta,3,0,0,double,1
+actuar,levburr,-1,0,0,double,1
+actuar,levburr,0,0,0,double,1
+actuar,levburr,1,0,0,double,1
+actuar,levburr,2,0,0,double,1
+actuar,levburr,3,0,0,double,1
+actuar,levburr,4,0,0,double,1
+actuar,levburr,5,0,0,double,1
+actuar,levchisq,-1,0,0,double,1
+actuar,levchisq,0,0,0,double,1
+actuar,levchisq,1,0,0,double,1
+actuar,levchisq,2,0,0,double,1
+actuar,levchisq,3,0,0,double,1
+actuar,levexp,-1,0,0,double,1
+actuar,levexp,0,0,0,double,1
+actuar,levexp,1,0,0,double,1
+actuar,levexp,2,0,0,double,1
+actuar,levgamma,-1,0,0,double[],1
+actuar,levgamma,0,0,0,double[],1
+actuar,levgamma,1,0,0,double,1
+actuar,levgamma,2,0,0,double,1
+actuar,levgamma,3,0,0,double,1
+actuar,levgamma,4,0,0,double,1
+actuar,levgenbeta,-1,0,0,double,1
+actuar,levgenbeta,0,0,0,double,1
+actuar,levgenbeta,1,0,0,double,1
+actuar,levgenbeta,2,0,0,double,1
+actuar,levgenbeta,3,0,0,double,1
+actuar,levgenbeta,4,0,0,double,1
+actuar,levgenbeta,5,0,0,double,1
+actuar,levgenbeta,6,0,0,double,1
+actuar,levgenpareto,-1,0,0,double,1
+actuar,levgenpareto,0,0,0,double,1
+actuar,levgenpareto,1,0,0,double,1
+actuar,levgenpareto,2,0,0,double,1
+actuar,levgenpareto,3,0,0,double,1
+actuar,levgenpareto,4,0,0,double,1
+actuar,levgenpareto,5,0,0,double,1
+actuar,levinvburr,-1,0,0,double,1
+actuar,levinvburr,0,0,0,double,1
+actuar,levinvburr,1,0,0,double,1
+actuar,levinvburr,2,0,0,double,1
+actuar,levinvburr,3,0,0,double,1
+actuar,levinvburr,4,0,0,double,1
+actuar,levinvburr,5,0,0,double,1
+actuar,levinvgamma,-1,0,0,double,1
+actuar,levinvgamma,0,0,0,double,1
+actuar,levinvgamma,1,0,0,double,1
+actuar,levinvgamma,2,0,0,double,1
+actuar,levinvgamma,3,0,0,double,1
+actuar,levinvgamma,4,0,0,double,1
+actuar,levinvgauss,-1,0,0,double[],1
+actuar,levinvgauss,0,0,0,double[],1
+actuar,levinvgauss,1,0,0,double,1
+actuar,levinvgauss,2,0,0,double,1
+actuar,levinvgauss,3,0,0,double,1
+actuar,levinvgauss,4,0,0,double,1
+actuar,levinvparalogis,-1,0,0,double,1
+actuar,levinvparalogis,0,0,0,double,1
+actuar,levinvparalogis,1,0,0,double,1
+actuar,levinvparalogis,2,0,0,double,1
+actuar,levinvparalogis,3,0,0,double,1
+actuar,levinvparalogis,4,0,0,double,1
+actuar,levinvtrgamma,-1,0,0,double,1
+actuar,levinvtrgamma,0,0,0,double,1
+actuar,levinvtrgamma,1,0,0,double,1
+actuar,levinvtrgamma,2,0,0,double,1
+actuar,levinvtrgamma,3,0,0,double,1
+actuar,levinvtrgamma,4,0,0,double,1
+actuar,levinvtrgamma,5,0,0,double,1
+actuar,levinvweibull,-1,0,0,double,1
+actuar,levinvweibull,0,0,0,double,1
+actuar,levinvweibull,1,0,0,double,1
+actuar,levinvweibull,2,0,0,double,1
+actuar,levinvweibull,3,0,0,double,1
+actuar,levinvweibull,4,0,0,double,1
+actuar,levlgamma,-1,0,0,double,1
+actuar,levlgamma,0,0,0,double,1
+actuar,levlgamma,1,0,0,double,1
+actuar,levlgamma,2,0,0,double,1
+actuar,levlgamma,3,0,0,double,1
+actuar,levllogis,-1,0,0,double,1
+actuar,levllogis,0,0,0,double,1
+actuar,levllogis,1,0,0,double,1
+actuar,levllogis,2,0,0,double,1
+actuar,levllogis,3,0,0,double,1
+actuar,levllogis,4,0,0,double,1
+actuar,levlnorm,-1,0,0,double[],1
+actuar,levlnorm,0,0,0,double[],1
+actuar,levlnorm,1,0,0,double,1
+actuar,levlnorm,2,0,0,double,1
+actuar,levlnorm,3,0,0,double,1
+actuar,levparalogis,-1,0,0,double,1
+actuar,levparalogis,0,0,0,double,1
+actuar,levparalogis,1,0,0,double,1
+actuar,levparalogis,2,0,0,double,1
+actuar,levparalogis,3,0,0,double,1
+actuar,levparalogis,4,0,0,double,1
+actuar,levpareto,-1,0,0,double,1
+actuar,levpareto,0,0,0,double,1
+actuar,levpareto,1,0,0,double,1
+actuar,levpareto,2,0,0,double,1
+actuar,levpareto,3,0,0,double,1
+actuar,levtrbeta,-1,0,0,double,1
+actuar,levtrbeta,0,0,0,double,1
+actuar,levtrbeta,1,0,0,double,1
+actuar,levtrbeta,2,0,0,double,1
+actuar,levtrbeta,3,0,0,double,1
+actuar,levtrbeta,4,0,0,double,1
+actuar,levtrbeta,5,0,0,double,1
+actuar,levtrbeta,6,0,0,double,1
+actuar,levtrgamma,-1,0,0,double,1
+actuar,levtrgamma,0,0,0,double,1
+actuar,levtrgamma,1,0,0,double,1
+actuar,levtrgamma,2,0,0,double,1
+actuar,levtrgamma,3,0,0,double,1
+actuar,levtrgamma,4,0,0,double,1
+actuar,levtrgamma,5,0,0,double,1
+actuar,levunif,-1,0,0,double[],1
+actuar,levunif,0,0,0,double,1
+actuar,levunif,1,0,0,double,1
+actuar,levunif,2,0,0,double,1
+actuar,levunif,3,0,0,integer[],1
+actuar,levunif,3,0,1,double,1
+actuar,levweibull,-1,0,0,double,1
+actuar,levweibull,0,0,0,double,1
+actuar,levweibull,1,0,0,double,1
+actuar,levweibull,2,0,0,double,1
+actuar,levweibull,3,0,0,double,1
+actuar,mbeta,-1,0,0,double,1
+actuar,mbeta,0,0,0,double,1
+actuar,mbeta,1,0,0,double,1
+actuar,mbeta,2,0,0,double,1
+actuar,mburr,-1,0,0,double,1
+actuar,mburr,0,0,0,double,1
+actuar,mburr,1,0,0,double,1
+actuar,mburr,2,0,0,double,1
+actuar,mburr,3,0,0,double,1
+actuar,mburr,4,0,0,double,1
+actuar,mchisq,-1,0,0,double,1
+actuar,mchisq,0,0,0,double,1
+actuar,mchisq,1,0,0,double,1
+actuar,mchisq,2,0,0,double,1
+actuar,mde,-1,0,0,any,1
+actuar,mde,0,0,0,"class<`data.frame`, `grouped.data`>",1
+actuar,mde,0,0,1,double[],1
+actuar,mde,1,0,0,class<`function`>,1
+actuar,mde,2,0,0,list<double>,1
+actuar,mde,3,0,0,character,1
+actuar,mde,4,0,0,null,1
+actuar,mde,5,0,0,...,1
+actuar,mean.aggregateDist,-1,0,0,double,1
+actuar,mean.aggregateDist,0,0,0,"class<`aggregateDist`, `ecdf`, `function`, `stepfun`>",1
+actuar,mean.aggregateDist,1,0,0,...,1
+actuar,mean.grouped.data,-1,0,0,double[],1
+actuar,mean.grouped.data,0,0,0,"class<`data.frame`, `grouped.data`>",1
+actuar,mean.grouped.data,1,0,0,...,1
+actuar,mexp,-1,0,0,double,1
+actuar,mexp,0,0,0,double,1
+actuar,mexp,1,0,0,double,1
+actuar,mgamma,-1,0,0,double,1
+actuar,mgamma,0,0,0,double,1
+actuar,mgamma,1,0,0,double,1
+actuar,mgamma,2,0,0,double,1
+actuar,mgamma,3,0,0,double,1
+actuar,mgenbeta,-1,0,0,double,1
+actuar,mgenbeta,0,0,0,double,1
+actuar,mgenbeta,1,0,0,double,1
+actuar,mgenbeta,2,0,0,double,1
+actuar,mgenbeta,3,0,0,double,1
+actuar,mgenbeta,4,0,0,double,1
+actuar,mgenbeta,5,0,0,double,1
+actuar,mgenpareto,-1,0,0,double,1
+actuar,mgenpareto,0,0,0,double,1
+actuar,mgenpareto,1,0,0,double,1
+actuar,mgenpareto,2,0,0,double,1
+actuar,mgenpareto,3,0,0,double,1
+actuar,mgenpareto,4,0,0,double,1
+actuar,mgfchisq,-1,0,0,double,1
+actuar,mgfchisq,0,0,0,double,1
+actuar,mgfchisq,1,0,0,double,1
+actuar,mgfchisq,2,0,0,double,1
+actuar,mgfchisq,3,0,0,logical,1
+actuar,mgfexp,-1,0,0,double,1
+actuar,mgfexp,0,0,0,double,1
+actuar,mgfexp,1,0,0,double,1
+actuar,mgfexp,2,0,0,logical,1
+actuar,mgfgamma,-1,0,0,double,1
+actuar,mgfgamma,0,0,0,double,1
+actuar,mgfgamma,1,0,0,double,1
+actuar,mgfgamma,2,0,0,double,1
+actuar,mgfgamma,3,0,0,double,1
+actuar,mgfgamma,4,0,0,logical,1
+actuar,mgfinvgamma,-1,0,0,double,1
+actuar,mgfinvgamma,0,0,0,double,1
+actuar,mgfinvgamma,1,0,0,double,1
+actuar,mgfinvgamma,2,0,0,double,1
+actuar,mgfinvgamma,3,0,0,double,1
+actuar,mgfinvgamma,4,0,0,logical,1
+actuar,mgfnorm,-1,0,0,double[],1
+actuar,mgfnorm,0,0,0,integer[],1
+actuar,mgfnorm,1,0,0,double,1
+actuar,mgfnorm,2,0,0,double,1
+actuar,mgfnorm,3,0,0,logical,1
+actuar,mgfphtype,-1,0,0,double[],1
+actuar,mgfphtype,0,0,0,double[],1
+actuar,mgfphtype,1,0,0,double[],1
+actuar,mgfphtype,2,0,0,class<`matrix`>,1
+actuar,mgfphtype,3,0,0,logical,1
+actuar,mgfunif,-1,0,0,double,1
+actuar,mgfunif,0,0,0,double,1
+actuar,mgfunif,1,0,0,double,1
+actuar,mgfunif,2,0,0,double,1
+actuar,mgfunif,3,0,0,logical,1
+actuar,mgumbel,-1,0,0,double,1
+actuar,mgumbel,0,0,0,double,1
+actuar,mgumbel,1,0,0,double,1
+actuar,mgumbel,2,0,0,double,1
+actuar,minvburr,-1,0,0,double,1
+actuar,minvburr,0,0,0,double,1
+actuar,minvburr,1,0,0,double,1
+actuar,minvburr,2,0,0,double,1
+actuar,minvburr,3,0,0,double,1
+actuar,minvburr,4,0,0,double,1
+actuar,minvexp,-1,0,0,double,1
+actuar,minvexp,0,0,0,double,1
+actuar,minvexp,1,0,0,double,1
+actuar,minvexp,2,0,0,double,1
+actuar,minvgamma,-1,0,0,double,1
+actuar,minvgamma,0,0,0,double,1
+actuar,minvgamma,1,0,0,double,1
+actuar,minvgamma,2,0,0,double,1
+actuar,minvgamma,3,0,0,double,1
+actuar,minvgauss,-1,0,0,double[],1
+actuar,minvgauss,0,0,0,integer[],1
+actuar,minvgauss,1,0,0,double,1
+actuar,minvgauss,2,0,0,double,1
+actuar,minvgauss,3,0,0,double,1
+actuar,minvparalogis,-1,0,0,double,1
+actuar,minvparalogis,0,0,0,double,1
+actuar,minvparalogis,1,0,0,double,1
+actuar,minvparalogis,2,0,0,double,1
+actuar,minvparalogis,3,0,0,double,1
+actuar,minvpareto,-1,0,0,double,1
+actuar,minvpareto,0,0,0,double,1
+actuar,minvpareto,1,0,0,double,1
+actuar,minvpareto,2,0,0,double,1
+actuar,minvtrgamma,-1,0,0,double,1
+actuar,minvtrgamma,0,0,0,double,1
+actuar,minvtrgamma,1,0,0,double,1
+actuar,minvtrgamma,2,0,0,double,1
+actuar,minvtrgamma,3,0,0,double,1
+actuar,minvtrgamma,4,0,0,double,1
+actuar,mlgamma,-1,0,0,double,1
+actuar,mlgamma,0,0,0,double,1
+actuar,mlgamma,1,0,0,double,1
+actuar,mlgamma,2,0,0,double,1
+actuar,mlgompertz,-1,0,0,double,1
+actuar,mlgompertz,0,0,0,double,1
+actuar,mlgompertz,1,0,0,double,1
+actuar,mlgompertz,2,0,0,double,1
+actuar,mlgompertz,3,0,0,double,1
+actuar,mllogis,-1,0,0,double,1
+actuar,mllogis,0,0,0,double,1
+actuar,mllogis,1,0,0,double,1
+actuar,mllogis,2,0,0,double,1
+actuar,mllogis,3,0,0,double,1
+actuar,mlnorm,-1,0,0,double,1
+actuar,mlnorm,0,0,0,double,1
+actuar,mlnorm,1,0,0,double,1
+actuar,mlnorm,2,0,0,double,1
+actuar,mnorm,-1,0,0,double,1
+actuar,mnorm,0,0,0,double,1
+actuar,mnorm,1,0,0,double,1
+actuar,mnorm,2,0,0,double,1
+actuar,mparalogis,-1,0,0,double,1
+actuar,mparalogis,0,0,0,double,1
+actuar,mparalogis,1,0,0,double,1
+actuar,mparalogis,2,0,0,double,1
+actuar,mparalogis,3,0,0,double,1
+actuar,mpareto,-1,0,0,double,1
+actuar,mpareto,0,0,0,double,1
+actuar,mpareto,1,0,0,double,1
+actuar,mpareto,2,0,0,double,1
+actuar,mpareto1,-1,0,0,double,1
+actuar,mpareto1,0,0,0,double,1
+actuar,mpareto1,1,0,0,double,1
+actuar,mpareto1,2,0,0,double,1
+actuar,mphtype,-1,0,0,double,1
+actuar,mphtype,0,0,0,double,1
+actuar,mphtype,1,0,0,double[],1
+actuar,mphtype,2,0,0,class<`matrix`>,1
+actuar,mtrbeta,-1,0,0,double,1
+actuar,mtrbeta,0,0,0,double,1
+actuar,mtrbeta,1,0,0,double,1
+actuar,mtrbeta,2,0,0,double,1
+actuar,mtrbeta,3,0,0,double,1
+actuar,mtrbeta,4,0,0,double,1
+actuar,mtrbeta,5,0,0,double,1
+actuar,mtrgamma,-1,0,0,double,1
+actuar,mtrgamma,0,0,0,double,1
+actuar,mtrgamma,1,0,0,double,1
+actuar,mtrgamma,2,0,0,double,1
+actuar,mtrgamma,3,0,0,double,1
+actuar,mtrgamma,4,0,0,double,1
+actuar,munif,-1,0,0,double[],1
+actuar,munif,0,0,0,integer[],1
+actuar,munif,0,0,1,double,1
+actuar,munif,1,0,0,double,1
+actuar,munif,2,0,0,double,1
+actuar,mweibull,-1,0,0,double,1
+actuar,mweibull,0,0,0,double,1
+actuar,mweibull,1,0,0,double,1
+actuar,mweibull,2,0,0,double,1
+actuar,normal,-1,0,0,class<`function`>,1
+actuar,normal,0,0,0,double,1
+actuar,normal,1,0,0,double,1
+actuar,npower,-1,0,0,class<`function`>,1
+actuar,npower,0,0,0,double,1
+actuar,npower,1,0,0,double,1
+actuar,npower,2,0,0,double,1
+actuar,ogive,-1,0,0,"class<`function`, `ogive`>",1
+actuar,ogive,0,0,0,"class<`data.frame`, `grouped.data`>",1
+actuar,ogive,0,0,1,double[],1
+actuar,ogive,1,0,0,...,1
+actuar,ogive.default,-1,0,0,"class<`function`, `ogive`>",1
+actuar,ogive.default,0,0,0,double[],1
+actuar,ogive.default,1,0,0,double[],1
+actuar,ogive.default,1,0,1,null,1
+actuar,ogive.default,2,0,0,character,1
+actuar,ogive.default,2,0,1,double[],1
+actuar,ogive.default,3,0,0,null,1
+actuar,ogive.default,4,0,0,...,1
+actuar,.ogiveFUN,-1,0,0,"class<`function`, `ogive`>",1
+actuar,.ogiveFUN,0,0,0,double[],1
+actuar,.ogiveFUN,1,0,0,double[],1
+actuar,ogive.grouped.data,-1,0,0,"class<`function`, `ogive`>",1
+actuar,ogive.grouped.data,0,0,0,"class<`data.frame`, `grouped.data`>",1
+actuar,ogive.grouped.data,1,0,0,...,1
+actuar,panjer,-1,0,0,"class<`ecdf`, `function`, `stepfun`>",1
+actuar,panjer,0,0,0,double[],1
+actuar,panjer,1,0,0,character,1
+actuar,panjer,2,0,0,double,1
+actuar,panjer,2,0,1,null,1
+actuar,panjer,3,0,0,double,1
+actuar,panjer,4,0,0,...,1
+actuar,panjer,5,0,0,double,1
+actuar,panjer,6,0,0,double,1
+actuar,panjer,7,0,0,double,1
+actuar,panjer,8,0,0,logical,1
+actuar,pburr,-1,0,0,double[],1
+actuar,pburr,0,0,0,double[],1
+actuar,pburr,1,0,0,double,1
+actuar,pburr,2,0,0,double,1
+actuar,pburr,3,0,0,double,1
+actuar,pburr,4,0,0,double,1
+actuar,pburr,5,0,0,logical,1
+actuar,pburr,6,0,0,logical,1
+actuar,pgenbeta,-1,0,0,double[],1
+actuar,pgenbeta,0,0,0,double[],1
+actuar,pgenbeta,1,0,0,double,1
+actuar,pgenbeta,2,0,0,double,1
+actuar,pgenbeta,3,0,0,double,1
+actuar,pgenbeta,4,0,0,double,1
+actuar,pgenbeta,5,0,0,double,1
+actuar,pgenbeta,6,0,0,logical,1
+actuar,pgenbeta,7,0,0,logical,1
+actuar,pgenpareto,-1,0,0,double[],1
+actuar,pgenpareto,0,0,0,double[],1
+actuar,pgenpareto,1,0,0,double,1
+actuar,pgenpareto,2,0,0,double,1
+actuar,pgenpareto,3,0,0,double,1
+actuar,pgenpareto,4,0,0,double,1
+actuar,pgenpareto,5,0,0,logical,1
+actuar,pgenpareto,6,0,0,logical,1
+actuar,pgfztbinom,-1,0,0,double,1
+actuar,pgfztbinom,0,0,0,double,1
+actuar,pgfztbinom,1,0,0,double,1
+actuar,pgfztbinom,2,0,0,double,1
+actuar,pgfztpois,-1,0,0,double,1
+actuar,pgfztpois,0,0,0,double,1
+actuar,pgfztpois,1,0,0,double,1
+actuar,pgumbel,-1,0,0,double[],1
+actuar,pgumbel,0,0,0,double[],1
+actuar,pgumbel,1,0,0,double,1
+actuar,pgumbel,2,0,0,double,1
+actuar,pgumbel,3,0,0,logical,1
+actuar,pgumbel,4,0,0,logical,1
+actuar,pinvburr,-1,0,0,double[],1
+actuar,pinvburr,0,0,0,double[],1
+actuar,pinvburr,1,0,0,double,1
+actuar,pinvburr,2,0,0,double,1
+actuar,pinvburr,3,0,0,double,1
+actuar,pinvburr,4,0,0,double,1
+actuar,pinvburr,5,0,0,logical,1
+actuar,pinvburr,6,0,0,logical,1
+actuar,pinvexp,-1,0,0,double[],1
+actuar,pinvexp,0,0,0,double[],1
+actuar,pinvexp,1,0,0,double,1
+actuar,pinvexp,2,0,0,double,1
+actuar,pinvexp,3,0,0,logical,1
+actuar,pinvexp,4,0,0,logical,1
+actuar,pinvgamma,-1,0,0,double[],1
+actuar,pinvgamma,0,0,0,double[],1
+actuar,pinvgamma,1,0,0,double,1
+actuar,pinvgamma,2,0,0,double,1
+actuar,pinvgamma,3,0,0,double,1
+actuar,pinvgamma,4,0,0,logical,1
+actuar,pinvgamma,5,0,0,logical,1
+actuar,pinvgauss,-1,0,0,double[],1
+actuar,pinvgauss,0,0,0,double[],1
+actuar,pinvgauss,1,0,0,double,1
+actuar,pinvgauss,2,0,0,double,1
+actuar,pinvgauss,3,0,0,double,1
+actuar,pinvgauss,4,0,0,logical,1
+actuar,pinvgauss,5,0,0,logical,1
+actuar,pinvparalogis,-1,0,0,double[],1
+actuar,pinvparalogis,0,0,0,double[],1
+actuar,pinvparalogis,1,0,0,double,1
+actuar,pinvparalogis,2,0,0,double,1
+actuar,pinvparalogis,3,0,0,double,1
+actuar,pinvparalogis,4,0,0,logical,1
+actuar,pinvparalogis,5,0,0,logical,1
+actuar,pinvpareto,-1,0,0,double[],1
+actuar,pinvpareto,0,0,0,double[],1
+actuar,pinvpareto,1,0,0,double,1
+actuar,pinvpareto,2,0,0,double,1
+actuar,pinvpareto,3,0,0,logical,1
+actuar,pinvpareto,4,0,0,logical,1
+actuar,pinvtrgamma,-1,0,0,double[],1
+actuar,pinvtrgamma,0,0,0,double[],1
+actuar,pinvtrgamma,1,0,0,double,1
+actuar,pinvtrgamma,2,0,0,double,1
+actuar,pinvtrgamma,3,0,0,double,1
+actuar,pinvtrgamma,4,0,0,double,1
+actuar,pinvtrgamma,5,0,0,logical,1
+actuar,pinvtrgamma,6,0,0,logical,1
+actuar,pinvweibull,-1,0,0,double[],1
+actuar,pinvweibull,0,0,0,double[],1
+actuar,pinvweibull,1,0,0,double,1
+actuar,pinvweibull,2,0,0,double,1
+actuar,pinvweibull,3,0,0,double,1
+actuar,pinvweibull,4,0,0,logical,1
+actuar,pinvweibull,5,0,0,logical,1
+actuar,plgamma,-1,0,0,double[],1
+actuar,plgamma,0,0,0,double[],1
+actuar,plgamma,1,0,0,double,1
+actuar,plgamma,2,0,0,double,1
+actuar,plgamma,3,0,0,logical,1
+actuar,plgamma,4,0,0,logical,1
+actuar,pllogis,-1,0,0,double[],1
+actuar,pllogis,0,0,0,double[],1
+actuar,pllogis,1,0,0,double,1
+actuar,pllogis,2,0,0,double,1
+actuar,pllogis,3,0,0,double,1
+actuar,pllogis,4,0,0,logical,1
+actuar,pllogis,5,0,0,logical,1
+actuar,plogarithmic,-1,0,0,double[],1
+actuar,plogarithmic,0,0,0,double,1
+actuar,plogarithmic,0,0,1,integer[],1
+actuar,plogarithmic,1,0,0,double[],1
+actuar,plogarithmic,2,0,0,logical,1
+actuar,plogarithmic,3,0,0,logical,1
+actuar,plot.adjCoef,-1,0,0,null,1
+actuar,plot.adjCoef,0,0,0,"class<`adjCoef`, `function`>",1
+actuar,plot.adjCoef,1,0,0,character,1
+actuar,plot.adjCoef,2,0,0,character,1
+actuar,plot.adjCoef,3,0,0,character,1
+actuar,plot.adjCoef,4,0,0,character,1
+actuar,plot.adjCoef,5,0,0,character,1
+actuar,plot.adjCoef,6,0,0,logical,1
+actuar,plot.adjCoef,7,0,0,...,1
+actuar,plot.aggregateDist,-1,0,0,null,1
+actuar,plot.aggregateDist,0,0,0,"class<`aggregateDist`, `ecdf`, `function`, `stepfun`>",1
+actuar,plot.aggregateDist,0,0,1,"class<`aggregateDist`, `function`>",1
+actuar,plot.aggregateDist,1,0,0,any,1
+actuar,plot.aggregateDist,2,0,0,any,1
+actuar,plot.aggregateDist,3,0,0,character,1
+actuar,plot.aggregateDist,4,0,0,character,1
+actuar,plot.aggregateDist,5,0,0,...,1
+actuar,plot.elev,-1,0,0,null,1
+actuar,plot.elev,0,0,0,"class<`elev`, `function`>",1
+actuar,plot.elev,1,0,0,...,1
+actuar,plot.elev,2,0,0,null,1
+actuar,plot.elev,3,0,0,character,1
+actuar,plot.elev,4,0,0,character,1
+actuar,plot.ogive,-1,0,0,null,1
+actuar,plot.ogive,0,0,0,"class<`function`, `ogive`>",1
+actuar,plot.ogive,1,0,0,null,1
+actuar,plot.ogive,2,0,0,character,1
+actuar,plot.ogive,3,0,0,character,1
+actuar,plot.ogive,4,0,0,...,1
+actuar,plot.ruin,-1,0,0,list<double[]>,1
+actuar,plot.ruin,0,0,0,"class<`function`, `ruin`>",1
+actuar,plot.ruin,1,0,0,double,1
+actuar,plot.ruin,1,0,1,null,1
+actuar,plot.ruin,2,0,0,double,1
+actuar,plot.ruin,2,0,1,null,1
+actuar,plot.ruin,3,0,0,logical,1
+actuar,plot.ruin,4,0,0,character,1
+actuar,plot.ruin,5,0,0,expression,1
+actuar,plot.ruin,6,0,0,character,1
+actuar,plot.ruin,7,0,0,null,1
+actuar,plot.ruin,7,0,1,double[],1
+actuar,plot.ruin,8,0,0,...,1
+actuar,pparalogis,-1,0,0,double[],1
+actuar,pparalogis,0,0,0,double[],1
+actuar,pparalogis,1,0,0,double,1
+actuar,pparalogis,2,0,0,double,1
+actuar,pparalogis,3,0,0,double,1
+actuar,pparalogis,4,0,0,logical,1
+actuar,pparalogis,5,0,0,logical,1
+actuar,ppareto,-1,0,0,double[],1
+actuar,ppareto,0,0,0,double[],1
+actuar,ppareto,1,0,0,double,1
+actuar,ppareto,2,0,0,double,1
+actuar,ppareto,3,0,0,logical,1
+actuar,ppareto,4,0,0,logical,1
+actuar,ppareto1,-1,0,0,double[],1
+actuar,ppareto1,0,0,0,double[],1
+actuar,ppareto1,1,0,0,double,1
+actuar,ppareto1,2,0,0,double,1
+actuar,ppareto1,3,0,0,logical,1
+actuar,ppareto1,4,0,0,logical,1
+actuar,pphtype,-1,0,0,double[],1
+actuar,pphtype,0,0,0,double[],1
+actuar,pphtype,1,0,0,class<`matrix`>,1
+actuar,pphtype,1,0,1,double[],1
+actuar,pphtype,2,0,0,class<`matrix`>,1
+actuar,pphtype,3,0,0,logical,1
+actuar,pphtype,4,0,0,logical,1
+actuar,ppoisinvgauss,-1,0,0,double[],1
+actuar,ppoisinvgauss,0,0,0,integer[],1
+actuar,ppoisinvgauss,1,0,0,double,1
+actuar,ppoisinvgauss,2,0,0,double,1
+actuar,ppoisinvgauss,3,0,0,double,1
+actuar,ppoisinvgauss,4,0,0,logical,1
+actuar,ppoisinvgauss,5,0,0,logical,1
+actuar,predict.bayes,-1,0,0,double[],1
+actuar,predict.bayes,0,0,0,"class<`bayes`, `cm`>",1
+actuar,predict.bayes,0,0,1,"class<`bstraub`, `cm`>",1
+actuar,predict.bayes,1,0,0,null,1
+actuar,predict.bayes,2,0,0,any,1
+actuar,predict.bayes,3,0,0,...,1
+actuar,predict.bstraub,-1,0,0,double[],1
+actuar,predict.bstraub,0,0,0,"class<`bayes`, `cm`>",1
+actuar,predict.bstraub,0,0,1,"class<`bstraub`, `cm`>",1
+actuar,predict.bstraub,1,0,0,null,1
+actuar,predict.bstraub,2,0,0,any,1
+actuar,predict.bstraub,3,0,0,...,1
+actuar,predict.cm,-1,0,0,double[],1
+actuar,predict.cm,-1,0,1,list<double[]>,1
+actuar,predict.cm,0,0,0,"class<`bstraub`, `cm`>",1
+actuar,predict.cm,0,0,1,"class<`cm`, `hache`>",1
+actuar,predict.cm,0,0,2,"class<`bayes`, `cm`>",1
+actuar,predict.cm,0,0,3,"class<`cm`, `hierarc`>",1
+actuar,predict.cm,1,0,0,null,1
+actuar,predict.cm,1,0,1,character,1
+actuar,predict.cm,2,0,0,any,1
+actuar,predict.cm,3,0,0,...,1
+actuar,predict.hache,-1,0,0,double[],1
+actuar,predict.hache,0,0,0,"class<`cm`, `hache`>",1
+actuar,predict.hache,1,0,0,null,1
+actuar,predict.hache,2,0,0,class<`data.frame`>,1
+actuar,predict.hache,3,0,0,...,1
+actuar,predict.hierarc,-1,0,0,list<double[]>,1
+actuar,predict.hierarc,0,0,0,"class<`cm`, `hierarc`>",1
+actuar,predict.hierarc,1,0,0,integer[],1
+actuar,predict.hierarc,1,0,1,null,1
+actuar,predict.hierarc,2,0,0,any,1
+actuar,predict.hierarc,3,0,0,...,1
+actuar,ptrbeta,-1,0,0,double[],1
+actuar,ptrbeta,0,0,0,double[],1
+actuar,ptrbeta,1,0,0,double,1
+actuar,ptrbeta,2,0,0,double,1
+actuar,ptrbeta,3,0,0,double,1
+actuar,ptrbeta,4,0,0,double,1
+actuar,ptrbeta,5,0,0,double,1
+actuar,ptrbeta,6,0,0,logical,1
+actuar,ptrbeta,7,0,0,logical,1
+actuar,ptrgamma,-1,0,0,double[],1
+actuar,ptrgamma,0,0,0,double[],1
+actuar,ptrgamma,1,0,0,double,1
+actuar,ptrgamma,2,0,0,double,1
+actuar,ptrgamma,3,0,0,double,1
+actuar,ptrgamma,4,0,0,double,1
+actuar,ptrgamma,5,0,0,logical,1
+actuar,ptrgamma,6,0,0,logical,1
+actuar,pzmbinom,-1,0,0,double[],1
+actuar,pzmbinom,0,0,0,integer[],1
+actuar,pzmbinom,1,0,0,double,1
+actuar,pzmbinom,2,0,0,double,1
+actuar,pzmbinom,3,0,0,double,1
+actuar,pzmbinom,4,0,0,logical,1
+actuar,pzmbinom,5,0,0,logical,1
+actuar,pzmgeom,-1,0,0,double[],1
+actuar,pzmgeom,0,0,0,integer[],1
+actuar,pzmgeom,1,0,0,double,1
+actuar,pzmgeom,2,0,0,double,1
+actuar,pzmgeom,3,0,0,logical,1
+actuar,pzmgeom,4,0,0,logical,1
+actuar,pzmlogarithmic,-1,0,0,double[],1
+actuar,pzmlogarithmic,0,0,0,integer[],1
+actuar,pzmlogarithmic,1,0,0,double,1
+actuar,pzmlogarithmic,2,0,0,double,1
+actuar,pzmlogarithmic,3,0,0,logical,1
+actuar,pzmlogarithmic,4,0,0,logical,1
+actuar,pzmnbinom,-1,0,0,double[],1
+actuar,pzmnbinom,0,0,0,integer[],1
+actuar,pzmnbinom,1,0,0,double,1
+actuar,pzmnbinom,2,0,0,double,1
+actuar,pzmnbinom,3,0,0,double,1
+actuar,pzmnbinom,4,0,0,logical,1
+actuar,pzmnbinom,5,0,0,logical,1
+actuar,pzmpois,-1,0,0,double[],1
+actuar,pzmpois,0,0,0,integer[],1
+actuar,pzmpois,1,0,0,double,1
+actuar,pzmpois,2,0,0,double,1
+actuar,pzmpois,3,0,0,logical,1
+actuar,pzmpois,4,0,0,logical,1
+actuar,pztbinom,-1,0,0,double[],1
+actuar,pztbinom,0,0,0,integer[],1
+actuar,pztbinom,0,0,1,double,1
+actuar,pztbinom,1,0,0,double,1
+actuar,pztbinom,2,0,0,double,1
+actuar,pztbinom,3,0,0,logical,1
+actuar,pztbinom,4,0,0,logical,1
+actuar,pztgeom,-1,0,0,double[],1
+actuar,pztgeom,0,0,0,integer[],1
+actuar,pztgeom,0,0,1,double,1
+actuar,pztgeom,1,0,0,double,1
+actuar,pztgeom,2,0,0,logical,1
+actuar,pztgeom,3,0,0,logical,1
+actuar,pztnbinom,-1,0,0,double[],1
+actuar,pztnbinom,0,0,0,integer[],1
+actuar,pztnbinom,0,0,1,double,1
+actuar,pztnbinom,1,0,0,double,1
+actuar,pztnbinom,2,0,0,double,1
+actuar,pztnbinom,3,0,0,logical,1
+actuar,pztnbinom,4,0,0,logical,1
+actuar,pztpois,-1,0,0,double[],1
+actuar,pztpois,0,0,0,integer[],1
+actuar,pztpois,0,0,1,double,1
+actuar,pztpois,1,0,0,double,1
+actuar,pztpois,2,0,0,logical,1
+actuar,pztpois,3,0,0,logical,1
+actuar,qburr,-1,0,0,double[],1
+actuar,qburr,0,0,0,double[],1
+actuar,qburr,1,0,0,double,1
+actuar,qburr,2,0,0,double,1
+actuar,qburr,3,0,0,double,1
+actuar,qburr,4,0,0,double,1
+actuar,qburr,5,0,0,logical,1
+actuar,qburr,6,0,0,logical,1
+actuar,qgenbeta,-1,0,0,double[],1
+actuar,qgenbeta,0,0,0,double[],1
+actuar,qgenbeta,1,0,0,double,1
+actuar,qgenbeta,2,0,0,double,1
+actuar,qgenbeta,3,0,0,double,1
+actuar,qgenbeta,4,0,0,double,1
+actuar,qgenbeta,5,0,0,double,1
+actuar,qgenbeta,6,0,0,logical,1
+actuar,qgenbeta,7,0,0,logical,1
+actuar,qgenpareto,-1,0,0,double[],1
+actuar,qgenpareto,0,0,0,double[],1
+actuar,qgenpareto,1,0,0,double,1
+actuar,qgenpareto,2,0,0,double,1
+actuar,qgenpareto,3,0,0,double,1
+actuar,qgenpareto,4,0,0,double,1
+actuar,qgenpareto,5,0,0,logical,1
+actuar,qgenpareto,6,0,0,logical,1
+actuar,qgumbel,-1,0,0,double[],1
+actuar,qgumbel,0,0,0,double[],1
+actuar,qgumbel,1,0,0,double,1
+actuar,qgumbel,2,0,0,double,1
+actuar,qgumbel,3,0,0,logical,1
+actuar,qgumbel,4,0,0,logical,1
+actuar,qinvburr,-1,0,0,double[],1
+actuar,qinvburr,0,0,0,double[],1
+actuar,qinvburr,1,0,0,double,1
+actuar,qinvburr,2,0,0,double,1
+actuar,qinvburr,3,0,0,double,1
+actuar,qinvburr,4,0,0,double,1
+actuar,qinvburr,5,0,0,logical,1
+actuar,qinvburr,6,0,0,logical,1
+actuar,qinvexp,-1,0,0,double[],1
+actuar,qinvexp,0,0,0,double[],1
+actuar,qinvexp,1,0,0,double,1
+actuar,qinvexp,2,0,0,double,1
+actuar,qinvexp,3,0,0,logical,1
+actuar,qinvexp,4,0,0,logical,1
+actuar,qinvgamma,-1,0,0,double[],1
+actuar,qinvgamma,0,0,0,double[],1
+actuar,qinvgamma,1,0,0,double,1
+actuar,qinvgamma,2,0,0,double,1
+actuar,qinvgamma,3,0,0,double,1
+actuar,qinvgamma,4,0,0,logical,1
+actuar,qinvgamma,5,0,0,logical,1
+actuar,qinvgauss,-1,0,0,double[],1
+actuar,qinvgauss,0,0,0,double[],1
+actuar,qinvgauss,1,0,0,double,1
+actuar,qinvgauss,2,0,0,double,1
+actuar,qinvgauss,3,0,0,double,1
+actuar,qinvgauss,4,0,0,logical,1
+actuar,qinvgauss,5,0,0,logical,1
+actuar,qinvgauss,6,0,0,double,1
+actuar,qinvgauss,7,0,0,double,1
+actuar,qinvgauss,8,0,0,logical,1
+actuar,qinvgauss,9,0,0,logical,1
+actuar,qinvparalogis,-1,0,0,double[],1
+actuar,qinvparalogis,0,0,0,double[],1
+actuar,qinvparalogis,1,0,0,double,1
+actuar,qinvparalogis,2,0,0,double,1
+actuar,qinvparalogis,3,0,0,double,1
+actuar,qinvparalogis,4,0,0,logical,1
+actuar,qinvparalogis,5,0,0,logical,1
+actuar,qinvpareto,-1,0,0,double[],1
+actuar,qinvpareto,0,0,0,double[],1
+actuar,qinvpareto,1,0,0,double,1
+actuar,qinvpareto,2,0,0,double,1
+actuar,qinvpareto,3,0,0,logical,1
+actuar,qinvpareto,4,0,0,logical,1
+actuar,qinvtrgamma,-1,0,0,double[],1
+actuar,qinvtrgamma,0,0,0,double[],1
+actuar,qinvtrgamma,1,0,0,double,1
+actuar,qinvtrgamma,2,0,0,double,1
+actuar,qinvtrgamma,3,0,0,double,1
+actuar,qinvtrgamma,4,0,0,double,1
+actuar,qinvtrgamma,5,0,0,logical,1
+actuar,qinvtrgamma,6,0,0,logical,1
+actuar,qinvweibull,-1,0,0,double[],1
+actuar,qinvweibull,0,0,0,double[],1
+actuar,qinvweibull,1,0,0,double,1
+actuar,qinvweibull,2,0,0,double,1
+actuar,qinvweibull,3,0,0,double,1
+actuar,qinvweibull,4,0,0,logical,1
+actuar,qinvweibull,5,0,0,logical,1
+actuar,qlgamma,-1,0,0,double[],1
+actuar,qlgamma,0,0,0,double[],1
+actuar,qlgamma,1,0,0,double,1
+actuar,qlgamma,2,0,0,double,1
+actuar,qlgamma,3,0,0,logical,1
+actuar,qlgamma,4,0,0,logical,1
+actuar,qllogis,-1,0,0,double[],1
+actuar,qllogis,0,0,0,double[],1
+actuar,qllogis,1,0,0,double,1
+actuar,qllogis,2,0,0,double,1
+actuar,qllogis,3,0,0,double,1
+actuar,qllogis,4,0,0,logical,1
+actuar,qllogis,5,0,0,logical,1
+actuar,qlogarithmic,-1,0,0,double[],1
+actuar,qlogarithmic,0,0,0,double[],1
+actuar,qlogarithmic,1,0,0,double,1
+actuar,qlogarithmic,2,0,0,logical,1
+actuar,qlogarithmic,3,0,0,logical,1
+actuar,qparalogis,-1,0,0,double[],1
+actuar,qparalogis,0,0,0,double[],1
+actuar,qparalogis,1,0,0,double,1
+actuar,qparalogis,2,0,0,double,1
+actuar,qparalogis,3,0,0,double,1
+actuar,qparalogis,4,0,0,logical,1
+actuar,qparalogis,5,0,0,logical,1
+actuar,qpareto,-1,0,0,double[],1
+actuar,qpareto,0,0,0,double[],1
+actuar,qpareto,1,0,0,double,1
+actuar,qpareto,2,0,0,double,1
+actuar,qpareto,3,0,0,logical,1
+actuar,qpareto,4,0,0,logical,1
+actuar,qpareto1,-1,0,0,double[],1
+actuar,qpareto1,0,0,0,double[],1
+actuar,qpareto1,1,0,0,double,1
+actuar,qpareto1,2,0,0,double,1
+actuar,qpareto1,3,0,0,logical,1
+actuar,qpareto1,4,0,0,logical,1
+actuar,qpearson6,-1,0,0,double[],1
+actuar,qpearson6,0,0,0,double[],1
+actuar,qpearson6,1,0,0,double,1
+actuar,qpearson6,2,0,0,double,1
+actuar,qpearson6,3,0,0,double,1
+actuar,qpearson6,4,0,0,double,1
+actuar,qpearson6,5,0,0,double,1
+actuar,qpearson6,6,0,0,logical,1
+actuar,qpearson6,7,0,0,logical,1
+actuar,qpoisinvgauss,-1,0,0,double[],1
+actuar,qpoisinvgauss,0,0,0,double[],1
+actuar,qpoisinvgauss,1,0,0,double,1
+actuar,qpoisinvgauss,2,0,0,double,1
+actuar,qpoisinvgauss,3,0,0,double,1
+actuar,qpoisinvgauss,4,0,0,logical,1
+actuar,qpoisinvgauss,5,0,0,logical,1
+actuar,qtrbeta,-1,0,0,double[],1
+actuar,qtrbeta,0,0,0,double[],1
+actuar,qtrbeta,1,0,0,double,1
+actuar,qtrbeta,2,0,0,double,1
+actuar,qtrbeta,3,0,0,double,1
+actuar,qtrbeta,4,0,0,double,1
+actuar,qtrbeta,5,0,0,double,1
+actuar,qtrbeta,6,0,0,logical,1
+actuar,qtrbeta,7,0,0,logical,1
+actuar,qtrgamma,-1,0,0,double[],1
+actuar,qtrgamma,0,0,0,double[],1
+actuar,qtrgamma,1,0,0,double,1
+actuar,qtrgamma,2,0,0,double,1
+actuar,qtrgamma,3,0,0,double,1
+actuar,qtrgamma,4,0,0,double,1
+actuar,qtrgamma,5,0,0,logical,1
+actuar,qtrgamma,6,0,0,logical,1
+actuar,quantile.aggregateDist,-1,0,0,double[],1
+actuar,quantile.aggregateDist,0,0,0,"class<`aggregateDist`, `ecdf`, `function`, `stepfun`>",1
+actuar,quantile.aggregateDist,1,0,0,double[],1
+actuar,quantile.aggregateDist,2,0,0,logical,1
+actuar,quantile.aggregateDist,3,0,0,logical,1
+actuar,quantile.aggregateDist,4,0,0,...,1
+actuar,quantile.grouped.data,-1,0,0,double[],1
+actuar,quantile.grouped.data,0,0,0,"class<`data.frame`, `grouped.data`>",1
+actuar,quantile.grouped.data,1,0,0,double[],1
+actuar,quantile.grouped.data,2,0,0,logical,1
+actuar,quantile.grouped.data,3,0,0,...,1
+actuar,qzmbinom,-1,0,0,double[],1
+actuar,qzmbinom,0,0,0,double[],1
+actuar,qzmbinom,1,0,0,double,1
+actuar,qzmbinom,2,0,0,double,1
+actuar,qzmbinom,3,0,0,double,1
+actuar,qzmbinom,4,0,0,logical,1
+actuar,qzmbinom,5,0,0,logical,1
+actuar,qzmgeom,-1,0,0,double[],1
+actuar,qzmgeom,0,0,0,double[],1
+actuar,qzmgeom,1,0,0,double,1
+actuar,qzmgeom,2,0,0,double,1
+actuar,qzmgeom,3,0,0,logical,1
+actuar,qzmgeom,4,0,0,logical,1
+actuar,qzmlogarithmic,-1,0,0,double[],1
+actuar,qzmlogarithmic,0,0,0,double[],1
+actuar,qzmlogarithmic,1,0,0,double,1
+actuar,qzmlogarithmic,2,0,0,double,1
+actuar,qzmlogarithmic,3,0,0,logical,1
+actuar,qzmlogarithmic,4,0,0,logical,1
+actuar,qzmnbinom,-1,0,0,double[],1
+actuar,qzmnbinom,0,0,0,double[],1
+actuar,qzmnbinom,1,0,0,double,1
+actuar,qzmnbinom,2,0,0,double,1
+actuar,qzmnbinom,3,0,0,double,1
+actuar,qzmnbinom,4,0,0,logical,1
+actuar,qzmnbinom,5,0,0,logical,1
+actuar,qzmpois,-1,0,0,double[],1
+actuar,qzmpois,0,0,0,double[],1
+actuar,qzmpois,1,0,0,double,1
+actuar,qzmpois,2,0,0,double,1
+actuar,qzmpois,3,0,0,logical,1
+actuar,qzmpois,4,0,0,logical,1
+actuar,qztbinom,-1,0,0,double[],1
+actuar,qztbinom,0,0,0,double[],1
+actuar,qztbinom,1,0,0,double,1
+actuar,qztbinom,2,0,0,double,1
+actuar,qztbinom,3,0,0,logical,1
+actuar,qztbinom,4,0,0,logical,1
+actuar,qztgeom,-1,0,0,double[],1
+actuar,qztgeom,0,0,0,double[],1
+actuar,qztgeom,1,0,0,double,1
+actuar,qztgeom,2,0,0,logical,1
+actuar,qztgeom,3,0,0,logical,1
+actuar,qztnbinom,-1,0,0,double[],1
+actuar,qztnbinom,0,0,0,double[],1
+actuar,qztnbinom,1,0,0,double,1
+actuar,qztnbinom,2,0,0,double,1
+actuar,qztnbinom,3,0,0,logical,1
+actuar,qztnbinom,4,0,0,logical,1
+actuar,qztpois,-1,0,0,double[],1
+actuar,qztpois,0,0,0,double[],1
+actuar,qztpois,1,0,0,double,1
+actuar,qztpois,2,0,0,logical,1
+actuar,qztpois,3,0,0,logical,1
+actuar,rcomphierarc,-1,0,0,class<`portfolio`>,1
+actuar,rcomphierarc,0,0,0,list<double[]>,1
+actuar,rcomphierarc,0,0,1,double,1
+actuar,rcomphierarc,1,0,0,expression,1
+actuar,rcomphierarc,2,0,0,expression,1
+actuar,rcomphierarc,2,0,1,null,1
+actuar,rcomphierarc,3,0,0,double[],1
+actuar,rcomphierarc,3,0,1,null,1
+actuar,rcompound,-1,0,0,double[],1
+actuar,rcompound,0,0,0,double,1
+actuar,rcompound,1,0,0,any,1
+actuar,rcompound,2,0,0,any,1
+actuar,rcompound,3,0,0,logical,1
+actuar,rcomppois,-1,0,0,double[],1
+actuar,rcomppois,-1,0,1,list<double[]>,1
+actuar,rcomppois,0,0,0,double,1
+actuar,rcomppois,1,0,0,double,1
+actuar,rcomppois,2,0,0,any,1
+actuar,rcomppois,3,0,0,logical,1
+actuar,rlogarithmic,-1,0,0,integer[],1
+actuar,rlogarithmic,0,0,0,double,1
+actuar,rlogarithmic,1,0,0,double,1
+actuar,rmixture,-1,0,0,double[],1
+actuar,rmixture,0,0,0,double,1
+actuar,rmixture,1,0,0,double[],1
+actuar,rmixture,2,0,0,expression,1
+actuar,rphtype,-1,0,0,double[],1
+actuar,rphtype,0,0,0,double,1
+actuar,rphtype,1,0,0,double[],1
+actuar,rphtype,2,0,0,class<`matrix`>,1
+actuar,rpoisinvgauss,-1,0,0,integer[],1
+actuar,rpoisinvgauss,0,0,0,double,1
+actuar,rpoisinvgauss,1,0,0,double,1
+actuar,rpoisinvgauss,2,0,0,double,1
+actuar,rpoisinvgauss,3,0,0,double,1
+actuar,ruin,-1,0,0,"class<`function`, `ruin`>",1
+actuar,ruin,0,0,0,character,1
+actuar,ruin,1,0,0,list<double[] | class<`matrix`>>,1
+actuar,ruin,1,0,1,list<double[]>,1
+actuar,ruin,2,0,0,character,1
+actuar,ruin,3,0,0,list<double[]>,1
+actuar,ruin,4,0,0,double,1
+actuar,ruin,5,0,0,any,1
+actuar,ruin,6,0,0,integer,1
+actuar,ruin,7,0,0,logical,1
+actuar,rztnbinom,-1,0,0,integer[],1
+actuar,rztnbinom,0,0,0,double,1
+actuar,rztnbinom,1,0,0,double,1
+actuar,rztnbinom,2,0,0,double,1
+actuar,severity,-1,0,0,class<`matrix`>,1
+actuar,severity,-1,0,1,list<class<`matrix`>>,1
+actuar,severity,-1,0,2,list<class<`matrix`> | null>,1
+actuar,severity,0,0,0,class<`matrix`>,1
+actuar,severity,0,0,1,class<`portfolio`>,1
+actuar,severity,1,0,0,...,1
+actuar,severity.default,-1,0,0,class<`matrix`>,1
+actuar,severity.default,0,0,0,class<`matrix`>,1
+actuar,severity.default,1,0,0,logical,1
+actuar,severity.default,2,0,0,logical,1
+actuar,severity.default,3,0,0,...,1
+actuar,severity.portfolio,-1,0,0,list<class<`matrix`>>,1
+actuar,severity.portfolio,-1,0,1,list<class<`matrix`> | null>,1
+actuar,severity.portfolio,0,0,0,class<`portfolio`>,1
+actuar,severity.portfolio,1,0,0,character[],1
+actuar,severity.portfolio,2,0,0,character,1
+actuar,severity.portfolio,2,0,1,double,1
+actuar,severity.portfolio,2,0,2,logical[],1
+actuar,severity.portfolio,2,0,3,null,1
+actuar,severity.portfolio,3,0,0,logical,1
+actuar,severity.portfolio,4,0,0,null,1
+actuar,severity.portfolio,5,0,0,...,1
+actuar,simS,-1,0,0,"class<`ecdf`, `function`, `stepfun`>",1
+actuar,simS,0,0,0,double,1
+actuar,simS,1,0,0,expression,1
+actuar,simS,2,0,0,expression,1
+actuar,simul,-1,0,0,class<`portfolio`>,1
+actuar,simul,0,0,0,list<double[]>,1
+actuar,simul,0,0,1,double,1
+actuar,simul,1,0,0,expression,1
+actuar,simul,2,0,0,expression,1
+actuar,simul,2,0,1,null,1
+actuar,simul,3,0,0,double[],1
+actuar,simul,3,0,1,null,1
+actuar,summary.aggregateDist,-1,0,0,"class<`aggregateDist`, `ecdf`, `function`, `stepfun`, `summary.aggregateDist`>",1
+actuar,summary.aggregateDist,0,0,0,"class<`aggregateDist`, `ecdf`, `function`, `stepfun`>",1
+actuar,summary.aggregateDist,1,0,0,...,1
+actuar,summary.cm,-1,0,0,"class<`bayes`, `cm`, `summary.cm`>",1
+actuar,summary.cm,-1,0,1,"class<`bstraub`, `cm`, `summary.cm`>",1
+actuar,summary.cm,-1,0,2,"class<`cm`, `hache`, `summary.cm`>",1
+actuar,summary.cm,-1,0,3,"class<`cm`, `hierarc`, `summary.cm`>",1
+actuar,summary.cm,0,0,0,"class<`bayes`, `cm`>",1
+actuar,summary.cm,0,0,1,"class<`bstraub`, `cm`>",1
+actuar,summary.cm,0,0,2,"class<`cm`, `hache`>",1
+actuar,summary.cm,0,0,3,"class<`cm`, `hierarc`>",1
+actuar,summary.cm,1,0,0,null,1
+actuar,summary.cm,1,0,1,character,1
+actuar,summary.cm,2,0,0,any,1
+actuar,summary.cm,3,0,0,...,1
+actuar,summary.elev,-1,0,0,"class<`summaryDefault`, `table`>",1
+actuar,summary.elev,0,0,0,"class<`elev`, `function`>",1
+actuar,summary.elev,1,0,0,...,1
+actuar,summary.ogive,-1,0,0,class<`summary.ogive`>,1
+actuar,summary.ogive,0,0,0,"class<`function`, `ogive`>",1
+actuar,summary.ogive,1,0,0,...,1
+actuar,unroll,-1,0,0,class<`matrix`>,1
+actuar,unroll,-1,0,1,integer[],1
+actuar,unroll,0,0,0,class<`matrix`>,1
+actuar,unroll,0,0,1,list<integer[]>,1
+actuar,unroll,1,0,0,logical,1
+actuar,unroll,2,0,0,logical,1
+actuar,VaR,-1,0,0,double[],1
+actuar,VaR,0,0,0,"class<`aggregateDist`, `ecdf`, `function`, `stepfun`>",1
+actuar,VaR,1,0,0,...,1
+actuar,VaR.aggregateDist,-1,0,0,double[],1
+actuar,VaR.aggregateDist,0,0,0,"class<`aggregateDist`, `ecdf`, `function`, `stepfun`>",1
+actuar,VaR.aggregateDist,1,0,0,double[],1
+actuar,VaR.aggregateDist,2,0,0,logical,1
+actuar,VaR.aggregateDist,3,0,0,logical,1
+actuar,VaR.aggregateDist,4,0,0,...,1
+actuar,weights.portfolio,-1,0,0,class<`matrix`>,1
+actuar,weights.portfolio,-1,0,1,null,1
+actuar,weights.portfolio,0,0,0,class<`portfolio`>,1
+actuar,weights.portfolio,1,0,0,logical,1
+actuar,weights.portfolio,2,0,0,null,1
+actuar,weights.portfolio,3,0,0,...,1
+agricolae,AMMI,-1,0,0,class<`AMMI`>,1
+agricolae,AMMI,0,0,0,class<`factor`>,1
+agricolae,AMMI,1,0,0,class<`factor`>,1
+agricolae,AMMI,1,0,1,double[],1
+agricolae,AMMI,2,0,0,double[],1
+agricolae,AMMI,3,0,0,double[],1
+agricolae,AMMI,4,0,0,double,1
+agricolae,AMMI,5,0,0,logical,1
+agricolae,AMMI,6,0,0,logical,1
+agricolae,AMMI.contour,-1,0,0,list<character[] | class<`data.frame`>>,1
+agricolae,AMMI.contour,0,0,0,class<`AMMI`>,1
+agricolae,AMMI.contour,1,0,0,double,1
+agricolae,AMMI.contour,2,0,0,double,1
+agricolae,AMMI.contour,3,0,0,...,1
+agricolae,audpc,-1,0,0,double[],1
+agricolae,audpc,-1,0,1,null,1
+agricolae,audpc,0,0,0,class<`data.frame`>,1
+agricolae,audpc,0,0,1,double[],1
+agricolae,audpc,1,0,0,double[],1
+agricolae,audpc,2,0,0,character,1
+agricolae,audps,-1,0,0,double,1
+agricolae,audps,0,0,0,double[],1
+agricolae,audps,1,0,0,double[],1
+agricolae,audps,2,0,0,character,1
+agricolae,bar.err,-1,0,0,list<class<`matrix`> | class<`array`>>,1
+agricolae,bar.err,-1,0,1,list<class<`matrix`> | double[]>,1
+agricolae,bar.err,0,0,0,class<`data.frame`>,1
+agricolae,bar.err,1,0,0,character,1
+agricolae,bar.err,2,0,0,logical,1
+agricolae,bar.err,3,0,0,logical,1
+agricolae,bar.err,4,0,0,...,1
+agricolae,bar.group,-1,0,0,list<class<`matrix`> | double[]>,1
+agricolae,bar.group,-1,0,1,list<class<`matrix`> | integer[]>,1
+agricolae,bar.group,0,0,0,class<`data.frame`>,1
+agricolae,bar.group,1,0,0,logical,1
+agricolae,bar.group,2,0,0,...,1
+agricolae,BIB.test,-1,0,0,class<`group`>,1
+agricolae,BIB.test,0,0,0,class<`factor`>,1
+agricolae,BIB.test,0,0,1,double[],1
+agricolae,BIB.test,1,0,0,double[],1
+agricolae,BIB.test,1,0,1,class<`factor`>,1
+agricolae,BIB.test,2,0,0,double[],1
+agricolae,BIB.test,3,0,0,character[],1
+agricolae,BIB.test,4,0,0,double,1
+agricolae,BIB.test,5,0,0,logical,1
+agricolae,BIB.test,6,0,0,logical,1
+agricolae,carolina,-1,0,0,list<class<`lm`> | double>,1
+agricolae,carolina,0,0,0,double,1
+agricolae,carolina,1,0,0,class<`data.frame`>,1
+agricolae,consensus,-1,0,0,list<class<`data.frame`> | class<`hclust`>>,1
+agricolae,consensus,-1,0,1,list<class<`data.frame`> | class<`hclust`> | null>,1
+agricolae,consensus,0,0,0,class<`data.frame`>,1
+agricolae,consensus,1,0,0,character[],1
+agricolae,consensus,2,0,0,character[],1
+agricolae,consensus,3,0,0,double,1
+agricolae,consensus,4,0,0,logical,1
+agricolae,consensus,5,0,0,double,1
+agricolae,consensus,6,0,0,character,1
+agricolae,consensus,7,0,0,...,1
+agricolae,correl,-1,0,0,list<double>,1
+agricolae,correl,0,0,0,double[],1
+agricolae,correl,1,0,0,double[],1
+agricolae,correl,2,0,0,character,1
+agricolae,correl,3,0,0,character,1
+agricolae,correlation,-1,0,0,null,1
+agricolae,correlation,-1,0,1,list<class<`matrix`> | double>,1
+agricolae,correlation,0,0,0,double[],1
+agricolae,correlation,0,0,1,class<`data.frame`>,1
+agricolae,correlation,1,0,0,double[],1
+agricolae,correlation,1,0,1,null,1
+agricolae,correlation,1,0,2,class<`data.frame`>,1
+agricolae,correlation,2,0,0,character[],1
+agricolae,correlation,3,0,0,character,1
+agricolae,cv.model,-1,0,0,double,1
+agricolae,cv.model,0,0,0,"class<`aov`, `lm`>",1
+agricolae,cv.model,0,0,1,class<`lm`>,1
+agricolae,cv.similarity,-1,0,0,double,1
+agricolae,cv.similarity,0,0,0,class<`data.frame`>,1
+agricolae,DAU.test,-1,0,0,class<`group`>,1
+agricolae,DAU.test,0,0,0,character[],1
+agricolae,DAU.test,1,0,0,character[],1
+agricolae,DAU.test,2,0,0,double[],1
+agricolae,DAU.test,3,0,0,character,1
+agricolae,DAU.test,4,0,0,double,1
+agricolae,DAU.test,5,0,0,logical,1
+agricolae,DAU.test,6,0,0,logical,1
+agricolae,delete.na,-1,0,0,class<`data.frame`>,1
+agricolae,delete.na,-1,0,1,class<`matrix`>,1
+agricolae,delete.na,0,0,0,class<`data.frame`>,1
+agricolae,delete.na,0,0,1,class<`matrix`>,1
+agricolae,delete.na,1,0,0,character,1
+agricolae,design.ab,-1,0,0,list<class<`data.frame`> | list<character[] | double[]>>,1
+agricolae,design.ab,-1,0,1,list<class<`data.frame`> | list<character[] | double>>,1
+agricolae,design.ab,0,0,0,double[],1
+agricolae,design.ab,1,0,0,double,1
+agricolae,design.ab,1,0,1,null,1
+agricolae,design.ab,2,0,0,double,1
+agricolae,design.ab,3,0,0,character[],1
+agricolae,design.ab,4,0,0,double,1
+agricolae,design.ab,5,0,0,character,1
+agricolae,design.ab,6,0,0,logical,1
+agricolae,design.ab,7,0,0,logical,1
+agricolae,design.alpha,-1,0,0,list<class<`data.frame`> | list<character[] | double | class<`matrix`>>>,1
+agricolae,design.alpha,-1,0,1,list<class<`data.frame`> | list<character | integer[] | double | class<`matrix`>>>,1
+agricolae,design.alpha,0,0,0,character[],1
+agricolae,design.alpha,0,0,1,integer[],1
+agricolae,design.alpha,1,0,0,double,1
+agricolae,design.alpha,2,0,0,double,1
+agricolae,design.alpha,3,0,0,double,1
+agricolae,design.alpha,4,0,0,double,1
+agricolae,design.alpha,5,0,0,character,1
+agricolae,design.alpha,6,0,0,logical,1
+agricolae,design.bib,-1,0,0,list<class<`data.frame`> | class<`matrix`> | list<character[] | double>>,1
+agricolae,design.bib,0,0,0,character[],1
+agricolae,design.bib,1,0,0,double,1
+agricolae,design.bib,2,0,0,null,1
+agricolae,design.bib,3,0,0,double,1
+agricolae,design.bib,4,0,0,double,1
+agricolae,design.bib,5,0,0,character,1
+agricolae,design.bib,6,0,0,double,1
+agricolae,design.bib,7,0,0,logical,1
+agricolae,design.crd,-1,0,0,list<class<`data.frame`> | list<character[] | double[]>>,1
+agricolae,design.crd,0,0,0,character[],1
+agricolae,design.crd,1,0,0,double[],1
+agricolae,design.crd,2,0,0,double,1
+agricolae,design.crd,3,0,0,double,1
+agricolae,design.crd,4,0,0,character,1
+agricolae,design.crd,5,0,0,logical,1
+agricolae,design.cyclic,-1,0,0,list<class<`matrix`> | class<`data.frame`> | list<character[] | double>>,1
+agricolae,design.cyclic,0,0,0,character[],1
+agricolae,design.cyclic,1,0,0,double,1
+agricolae,design.cyclic,2,0,0,double,1
+agricolae,design.cyclic,3,0,0,double,1
+agricolae,design.cyclic,4,0,0,logical,1
+agricolae,design.cyclic,5,0,0,double,1
+agricolae,design.cyclic,6,0,0,character,1
+agricolae,design.cyclic,7,0,0,logical,1
+agricolae,design.dau,-1,0,0,list<class<`data.frame`> | list<character[] | double>>,1
+agricolae,design.dau,0,0,0,character[],1
+agricolae,design.dau,1,0,0,character[],1
+agricolae,design.dau,2,0,0,double,1
+agricolae,design.dau,3,0,0,double,1
+agricolae,design.dau,4,0,0,double,1
+agricolae,design.dau,5,0,0,character,1
+agricolae,design.dau,6,0,0,character,1
+agricolae,design.dau,7,0,0,logical,1
+agricolae,design.graeco,-1,0,0,list<class<`matrix`> | class<`data.frame`> | list<character[] | double>>,1
+agricolae,design.graeco,-1,0,1,list<class<`matrix`> | class<`data.frame`> | list<character[] | integer[] | double>>,1
+agricolae,design.graeco,0,0,0,character[],1
+agricolae,design.graeco,1,0,0,character[],1
+agricolae,design.graeco,1,0,1,integer[],1
+agricolae,design.graeco,2,0,0,double,1
+agricolae,design.graeco,3,0,0,double,1
+agricolae,design.graeco,4,0,0,character,1
+agricolae,design.graeco,5,0,0,logical,1
+agricolae,design.lattice,-1,0,0,list<class<`data.frame`> | list<character[] | double | class<`matrix`>>>,1
+agricolae,design.lattice,-1,0,1,list<class<`data.frame`> | list<character | integer[] | double | class<`matrix`>>>,1
+agricolae,design.lattice,0,0,0,character[],1
+agricolae,design.lattice,0,0,1,integer[],1
+agricolae,design.lattice,1,0,0,double,1
+agricolae,design.lattice,2,0,0,double,1
+agricolae,design.lattice,3,0,0,double,1
+agricolae,design.lattice,4,0,0,character,1
+agricolae,design.lattice,5,0,0,logical,1
+agricolae,design.lsd,-1,0,0,list<class<`matrix`> | class<`data.frame`> | list<character[] | double>>,1
+agricolae,design.lsd,-1,0,1,list<class<`matrix`> | class<`data.frame`> | list<character | integer[] | double>>,1
+agricolae,design.lsd,0,0,0,character[],1
+agricolae,design.lsd,0,0,1,integer[],1
+agricolae,design.lsd,1,0,0,double,1
+agricolae,design.lsd,2,0,0,double,1
+agricolae,design.lsd,3,0,0,character,1
+agricolae,design.lsd,4,0,0,logical,1
+agricolae,design.lsd,5,0,0,logical,1
+agricolae,design.rcbd,-1,0,0,list<class<`matrix`> | class<`data.frame`> | list<character[] | double>>,1
+agricolae,design.rcbd,0,0,0,character[],1
+agricolae,design.rcbd,1,0,0,double,1
+agricolae,design.rcbd,2,0,0,double,1
+agricolae,design.rcbd,3,0,0,double,1
+agricolae,design.rcbd,4,0,0,character,1
+agricolae,design.rcbd,5,0,0,logical,1
+agricolae,design.rcbd,6,0,0,logical,1
+agricolae,design.rcbd,7,0,0,logical,1
+agricolae,design.split,-1,0,0,list<class<`data.frame`> | list<character[] | double>>,1
+agricolae,design.split,0,0,0,character[],1
+agricolae,design.split,1,0,0,double[],1
+agricolae,design.split,2,0,0,double,1
+agricolae,design.split,3,0,0,character[],1
+agricolae,design.split,4,0,0,double,1
+agricolae,design.split,5,0,0,double,1
+agricolae,design.split,6,0,0,character,1
+agricolae,design.split,7,0,0,logical,1
+agricolae,design.split,8,0,0,logical,1
+agricolae,design.strip,-1,0,0,list<class<`data.frame`> | list<character[] | double[]>>,1
+agricolae,design.strip,0,0,0,character[],1
+agricolae,design.strip,1,0,0,double[],1
+agricolae,design.strip,2,0,0,double,1
+agricolae,design.strip,3,0,0,double,1
+agricolae,design.strip,4,0,0,double,1
+agricolae,design.strip,5,0,0,character,1
+agricolae,design.strip,6,0,0,logical,1
+agricolae,design.youden,-1,0,0,list<class<`matrix`> | class<`data.frame`> | list<character[] | double>>,1
+agricolae,design.youden,0,0,0,character[],1
+agricolae,design.youden,1,0,0,double,1
+agricolae,design.youden,2,0,0,double,1
+agricolae,design.youden,3,0,0,double,1
+agricolae,design.youden,4,0,0,character,1
+agricolae,design.youden,5,0,0,logical,1
+agricolae,design.youden,6,0,0,logical,1
+agricolae,diffograph,-1,0,0,list<list<double[]>>,1
+agricolae,diffograph,0,0,0,class<`group`>,1
+agricolae,diffograph,1,0,0,null,1
+agricolae,diffograph,2,0,0,character,1
+agricolae,diffograph,3,0,0,character,1
+agricolae,diffograph,4,0,0,character,1
+agricolae,diffograph,5,0,0,double,1
+agricolae,diffograph,6,0,0,double,1
+agricolae,diffograph,7,0,0,double,1
+agricolae,diffograph,8,0,0,character,1
+agricolae,diffograph,9,0,0,double,1
+agricolae,diffograph,10,0,0,double,1
+agricolae,diffograph,11,0,0,character,1
+agricolae,diffograph,12,0,0,character,1
+agricolae,diffograph,13,0,0,...,1
+agricolae,duncan.test,-1,0,0,class<`group`>,1
+agricolae,duncan.test,0,0,0,"class<`aov`, `lm`>",1
+agricolae,duncan.test,0,0,1,double[],1
+agricolae,duncan.test,1,0,0,character,1
+agricolae,duncan.test,1,0,1,class<`factor`>,1
+agricolae,duncan.test,2,0,0,any,1
+agricolae,duncan.test,3,0,0,any,1
+agricolae,duncan.test,4,0,0,double,1
+agricolae,duncan.test,5,0,0,logical,1
+agricolae,duncan.test,6,0,0,character,1
+agricolae,duncan.test,6,0,1,null,1
+agricolae,duncan.test,7,0,0,logical,1
+agricolae,durbin.test,-1,0,0,class<`group`>,1
+agricolae,durbin.test,0,0,0,class<`factor`>,1
+agricolae,durbin.test,1,0,0,character[],1
+agricolae,durbin.test,1,0,1,double[],1
+agricolae,durbin.test,2,0,0,double[],1
+agricolae,durbin.test,3,0,0,double,1
+agricolae,durbin.test,4,0,0,logical,1
+agricolae,durbin.test,5,0,0,character,1
+agricolae,durbin.test,6,0,0,logical,1
+agricolae,friedman,-1,0,0,class<`group`>,1
+agricolae,friedman,0,0,0,class<`factor`>,1
+agricolae,friedman,0,0,1,integer[],1
+agricolae,friedman,1,0,0,class<`factor`>,1
+agricolae,friedman,2,0,0,double[],1
+agricolae,friedman,3,0,0,double,1
+agricolae,friedman,4,0,0,logical,1
+agricolae,friedman,5,0,0,null,1
+agricolae,friedman,5,0,1,character,1
+agricolae,friedman,6,0,0,logical,1
+agricolae,graph.freq,-1,0,0,"class<`graph.freq`, `histogram`>",1
+agricolae,graph.freq,0,0,0,"class<`graph.freq`, `histogram`>",1
+agricolae,graph.freq,0,0,1,double[],1
+agricolae,graph.freq,1,0,0,null,1
+agricolae,graph.freq,1,0,1,double[],1
+agricolae,graph.freq,2,0,0,null,1
+agricolae,graph.freq,2,0,1,double[],1
+agricolae,graph.freq,3,0,0,double,1
+agricolae,graph.freq,4,0,0,logical,1
+agricolae,graph.freq,5,0,0,null,1
+agricolae,graph.freq,6,0,0,character,1
+agricolae,graph.freq,7,0,0,character,1
+agricolae,graph.freq,8,0,0,logical,1
+agricolae,graph.freq,8,0,1,character,1
+agricolae,graph.freq,9,0,0,double,1
+agricolae,graph.freq,10,0,0,...,1
+agricolae,hgroups,-1,0,0,class<`matrix`>,1
+agricolae,hgroups,0,0,0,class<`matrix`>,1
+agricolae,HSD.test,-1,0,0,class<`group`>,1
+agricolae,HSD.test,0,0,0,"class<`aov`, `lm`>",1
+agricolae,HSD.test,0,0,1,double[],1
+agricolae,HSD.test,1,0,0,character,1
+agricolae,HSD.test,1,0,1,class<`factor`>,1
+agricolae,HSD.test,1,0,2,double[],1
+agricolae,HSD.test,2,0,0,any,1
+agricolae,HSD.test,3,0,0,any,1
+agricolae,HSD.test,4,0,0,double,1
+agricolae,HSD.test,5,0,0,logical,1
+agricolae,HSD.test,6,0,0,character,1
+agricolae,HSD.test,6,0,1,null,1
+agricolae,HSD.test,7,0,0,logical,1
+agricolae,HSD.test,8,0,0,logical,1
+agricolae,index.AMMI,-1,0,0,class<`data.frame`>,1
+agricolae,index.AMMI,0,0,0,class<`AMMI`>,1
+agricolae,index.bio,-1,0,0,class<`data.frame`>,1
+agricolae,index.bio,0,0,0,integer[],1
+agricolae,index.bio,1,0,0,character,1
+agricolae,index.bio,2,0,0,double,1
+agricolae,index.bio,3,0,0,double,1
+agricolae,index.bio,4,0,0,logical,1
+agricolae,index.smith,-1,0,0,list<class<`lm`> | class<`matrix`>>,1
+agricolae,index.smith,0,0,0,class<`data.frame`>,1
+agricolae,index.smith,1,0,0,logical,1
+agricolae,index.smith,2,0,0,...,1
+agricolae,intervals.freq,-1,0,0,class<`matrix`>,1
+agricolae,intervals.freq,0,0,0,class<`histogram`>,1
+agricolae,intervals.freq,0,0,1,double[],1
+agricolae,join.freq,-1,0,0,"class<`graph.freq`, `histogram`>",1
+agricolae,join.freq,0,0,0,"class<`graph.freq`, `histogram`>",1
+agricolae,join.freq,1,0,0,integer[],1
+agricolae,kendall,-1,0,0,list<double>,1
+agricolae,kendall,0,0,0,double[],1
+agricolae,kendall,1,0,0,double[],1
+agricolae,kruskal,-1,0,0,class<`group`>,1
+agricolae,kruskal,0,0,0,integer[],1
+agricolae,kruskal,1,0,0,integer[],1
+agricolae,kruskal,2,0,0,double,1
+agricolae,kruskal,3,0,0,character[],1
+agricolae,kruskal,4,0,0,logical,1
+agricolae,kruskal,5,0,0,character,1
+agricolae,kruskal,6,0,0,logical,1
+agricolae,kurtosis,-1,0,0,double,1
+agricolae,kurtosis,0,0,0,^double[],1
+agricolae,lastC,-1,0,0,character[],1
+agricolae,lastC,0,0,0,character[],1
+agricolae,lateblight,-1,0,0,list<class<`data.frame`>>,1
+agricolae,lateblight,0,0,0,list<class<`data.frame`> | class<`Date`>>,1
+agricolae,lateblight,1,0,0,character,1
+agricolae,lateblight,2,0,0,character,1
+agricolae,lateblight,3,0,0,character,1
+agricolae,lateblight,4,0,0,double,1
+agricolae,lateblight,5,0,0,double,1
+agricolae,lateblight,6,0,0,double,1
+agricolae,lateblight,7,0,0,double,1
+agricolae,lateblight,8,0,0,double,1
+agricolae,lateblight,9,0,0,double,1
+agricolae,lateblight,10,0,0,character,1
+agricolae,lateblight,11,0,0,...,1
+agricolae,lineXtester,-1,0,0,"class<`aov`, `lm`>",1
+agricolae,lineXtester,0,0,0,double[],1
+agricolae,lineXtester,1,0,0,class<`factor`>,1
+agricolae,lineXtester,1,0,1,^integer[],1
+agricolae,lineXtester,2,0,0,class<`factor`>,1
+agricolae,lineXtester,2,0,1,^integer[],1
+agricolae,lineXtester,3,0,0,double[],1
+agricolae,LSD.test,-1,0,0,class<`group`>,1
+agricolae,LSD.test,0,0,0,"class<`aov`, `lm`>",1
+agricolae,LSD.test,0,0,1,double[],1
+agricolae,LSD.test,1,0,0,character,1
+agricolae,LSD.test,1,0,1,class<`factor`>,1
+agricolae,LSD.test,1,0,2,integer[],1
+agricolae,LSD.test,2,0,0,any,1
+agricolae,LSD.test,3,0,0,any,1
+agricolae,LSD.test,4,0,0,double,1
+agricolae,LSD.test,5,0,0,character[],1
+agricolae,LSD.test,6,0,0,logical,1
+agricolae,LSD.test,7,0,0,null,1
+agricolae,LSD.test,8,0,0,logical,1
+agricolae,Median.test,-1,0,0,class<`group`>,1
+agricolae,Median.test,0,0,0,integer[],1
+agricolae,Median.test,1,0,0,integer[],1
+agricolae,Median.test,2,0,0,double,1
+agricolae,Median.test,3,0,0,logical,1
+agricolae,Median.test,4,0,0,logical,1
+agricolae,Median.test,5,0,0,logical,1
+agricolae,Median.test,6,0,0,null,1
+agricolae,Median.test,7,0,0,logical,1
+agricolae,montecarlo,-1,0,0,double[],1
+agricolae,montecarlo,0,0,0,class<`histogram`>,1
+agricolae,montecarlo,0,0,1,double[],1
+agricolae,montecarlo,1,0,0,double,1
+agricolae,montecarlo,2,0,0,...,1
+agricolae,nonadditivity,-1,0,0,"list<double | class<`anova`, `data.frame`>>",1
+agricolae,nonadditivity,0,0,0,double[],1
+agricolae,nonadditivity,1,0,0,class<`factor`>,1
+agricolae,nonadditivity,2,0,0,class<`factor`>,1
+agricolae,nonadditivity,3,0,0,integer,1
+agricolae,nonadditivity,4,0,0,double,1
+agricolae,normal.freq,-1,0,0,null,1
+agricolae,normal.freq,0,0,0,"class<`graph.freq`, `histogram`>",1
+agricolae,normal.freq,0,0,1,class<`histogram`>,1
+agricolae,normal.freq,1,0,0,double,1
+agricolae,normal.freq,2,0,0,...,1
+agricolae,ogive.freq,-1,0,0,class<`data.frame`>,1
+agricolae,ogive.freq,0,0,0,"class<`graph.freq`, `histogram`>",1
+agricolae,ogive.freq,1,0,0,character,1
+agricolae,ogive.freq,2,0,0,character,1
+agricolae,ogive.freq,3,0,0,character,1
+agricolae,ogive.freq,4,0,0,character,1
+agricolae,ogive.freq,5,0,0,double,1
+agricolae,ogive.freq,6,0,0,...,1
+agricolae,order.group,-1,0,0,class<`data.frame`>,1
+agricolae,order.group,0,0,0,character[],1
+agricolae,order.group,1,0,0,double[],1
+agricolae,order.group,2,0,0,double[],1
+agricolae,order.group,3,0,0,double,1
+agricolae,order.group,4,0,0,double,1
+agricolae,order.group,5,0,0,double[],1
+agricolae,order.group,6,0,0,double,1
+agricolae,order.group,7,0,0,double,1
+agricolae,order.group,8,0,0,null,1
+agricolae,order.group,9,0,0,null,1
+agricolae,order.group,10,0,0,null,1
+agricolae,order.group,11,0,0,null,1
+agricolae,order.group,12,0,0,logical,1
+agricolae,orderPvalue,-1,0,0,class<`data.frame`>,1
+agricolae,orderPvalue,0,0,0,character[],1
+agricolae,orderPvalue,0,0,1,class<`factor`>,1
+agricolae,orderPvalue,0,0,2,double[],1
+agricolae,orderPvalue,1,0,0,double[],1
+agricolae,orderPvalue,1,0,1,class<`array`>,1
+agricolae,orderPvalue,2,0,0,double,1
+agricolae,orderPvalue,3,0,0,class<`matrix`>,1
+agricolae,orderPvalue,4,0,0,any,1
+agricolae,path.analysis,-1,0,0,list<class<`matrix`> | double>,1
+agricolae,path.analysis,0,0,0,class<`matrix`>,1
+agricolae,path.analysis,1,0,0,class<`matrix`>,1
+agricolae,PBIB.test,-1,0,0,class<`group`>,1
+agricolae,PBIB.test,0,0,0,class<`factor`>,1
+agricolae,PBIB.test,1,0,0,class<`factor`>,1
+agricolae,PBIB.test,2,0,0,class<`factor`>,1
+agricolae,PBIB.test,3,0,0,double[],1
+agricolae,PBIB.test,4,0,0,double,1
+agricolae,PBIB.test,5,0,0,character,1
+agricolae,PBIB.test,6,0,0,character[],1
+agricolae,PBIB.test,7,0,0,double,1
+agricolae,PBIB.test,8,0,0,logical,1
+agricolae,PBIB.test,9,0,0,logical,1
+agricolae,plot.AMMI,-1,0,0,null,1
+agricolae,plot.AMMI,0,0,0,class<`AMMI`>,1
+agricolae,plot.AMMI,1,0,0,double,1
+agricolae,plot.AMMI,2,0,0,double,1
+agricolae,plot.AMMI,3,0,0,double,1
+agricolae,plot.AMMI,4,0,0,double,1
+agricolae,plot.AMMI,5,0,0,logical,1
+agricolae,plot.AMMI,6,0,0,character,1
+agricolae,plot.AMMI,6,0,1,null,1
+agricolae,plot.AMMI,7,0,0,character,1
+agricolae,plot.AMMI,7,0,1,null,1
+agricolae,plot.AMMI,8,0,0,double,1
+agricolae,plot.AMMI,9,0,0,double,1
+agricolae,plot.AMMI,10,0,0,double,1
+agricolae,plot.AMMI,11,0,0,null,1
+agricolae,plot.AMMI,12,0,0,null,1
+agricolae,plot.AMMI,13,0,0,null,1
+agricolae,plot.AMMI,14,0,0,null,1
+agricolae,plot.AMMI,15,0,0,...,1
+agricolae,plot.graph.freq,-1,0,0,"class<`graph.freq`, `histogram`>",1
+agricolae,plot.graph.freq,0,0,0,"class<`graph.freq`, `histogram`>",1
+agricolae,plot.graph.freq,1,0,0,null,1
+agricolae,plot.graph.freq,2,0,0,null,1
+agricolae,plot.graph.freq,3,0,0,double,1
+agricolae,plot.graph.freq,4,0,0,logical,1
+agricolae,plot.graph.freq,5,0,0,null,1
+agricolae,plot.graph.freq,6,0,0,character,1
+agricolae,plot.graph.freq,7,0,0,character,1
+agricolae,plot.graph.freq,8,0,0,character,1
+agricolae,plot.graph.freq,8,0,1,logical,1
+agricolae,plot.graph.freq,9,0,0,double,1
+agricolae,plot.graph.freq,10,0,0,...,1
+agricolae,plot.group,-1,0,0,class<`matrix`>,1
+agricolae,plot.group,0,0,0,class<`group`>,1
+agricolae,plot.group,1,0,0,character[],1
+agricolae,plot.group,2,0,0,logical,1
+agricolae,plot.group,3,0,0,null,1
+agricolae,plot.group,4,0,0,double[],1
+agricolae,plot.group,4,0,1,null,1
+agricolae,plot.group,5,0,0,null,1
+agricolae,plot.group,6,0,0,null,1
+agricolae,plot.group,7,0,0,null,1
+agricolae,plot.group,8,0,0,double,1
+agricolae,plot.group,9,0,0,...,1
+agricolae,polygon.freq,-1,0,0,null,1
+agricolae,polygon.freq,0,0,0,"class<`graph.freq`, `histogram`>",1
+agricolae,polygon.freq,0,0,1,class<`histogram`>,1
+agricolae,polygon.freq,1,0,0,double,1
+agricolae,polygon.freq,2,0,0,...,1
+agricolae,reg.homog,-1,0,0,list<double | character>,1
+agricolae,reg.homog,0,0,0,character[],1
+agricolae,reg.homog,0,0,1,class<`factor`>,1
+agricolae,reg.homog,1,0,0,double[],1
+agricolae,reg.homog,2,0,0,double[],1
+agricolae,REGW.test,-1,0,0,class<`group`>,1
+agricolae,REGW.test,0,0,0,"class<`aov`, `lm`>",1
+agricolae,REGW.test,1,0,0,character,1
+agricolae,REGW.test,2,0,0,any,1
+agricolae,REGW.test,3,0,0,any,1
+agricolae,REGW.test,4,0,0,double,1
+agricolae,REGW.test,5,0,0,logical,1
+agricolae,REGW.test,6,0,0,character,1
+agricolae,REGW.test,6,0,1,null,1
+agricolae,REGW.test,7,0,0,logical,1
+agricolae,resampling.cv,-1,0,0,list<class<`lm`> | class<`data.frame`>>,1
+agricolae,resampling.cv,0,0,0,class<`data.frame`>,1
+agricolae,resampling.cv,1,0,0,double,1
+agricolae,resampling.cv,2,0,0,double,1
+agricolae,resampling.model,-1,0,0,list<class<`lm`> | class<`matrix`> | double[]>,1
+agricolae,resampling.model,-1,0,1,list<class<`lm`> | class<`matrix`> | double>,1
+agricolae,resampling.model,0,0,0,character,1
+agricolae,resampling.model,1,0,0,class<`data.frame`>,1
+agricolae,resampling.model,2,0,0,double,1
+agricolae,resampling.model,3,0,0,logical,1
+agricolae,scheffe.test,-1,0,0,class<`group`>,1
+agricolae,scheffe.test,0,0,0,"class<`aov`, `lm`>",1
+agricolae,scheffe.test,0,0,1,double[],1
+agricolae,scheffe.test,1,0,0,character,1
+agricolae,scheffe.test,1,0,1,class<`factor`>,1
+agricolae,scheffe.test,2,0,0,any,1
+agricolae,scheffe.test,3,0,0,any,1
+agricolae,scheffe.test,4,0,0,any,1
+agricolae,scheffe.test,5,0,0,double,1
+agricolae,scheffe.test,6,0,0,logical,1
+agricolae,scheffe.test,7,0,0,character,1
+agricolae,scheffe.test,7,0,1,null,1
+agricolae,scheffe.test,8,0,0,logical,1
+agricolae,similarity,-1,0,0,class<`dist`>,1
+agricolae,similarity,0,0,0,class<`data.frame`>,1
+agricolae,simulation.model,-1,0,0,list<class<`lm`> | class<`data.frame`>>,1
+agricolae,simulation.model,0,0,0,character,1
+agricolae,simulation.model,1,0,0,class<`data.frame`>,1
+agricolae,simulation.model,2,0,0,double[],1
+agricolae,simulation.model,2,0,1,null,1
+agricolae,simulation.model,3,0,0,double,1
+agricolae,simulation.model,4,0,0,logical,1
+agricolae,skewness,-1,0,0,double,1
+agricolae,skewness,0,0,0,^double[],1
+agricolae,SNK.test,-1,0,0,class<`group`>,1
+agricolae,SNK.test,0,0,0,"class<`aov`, `lm`>",1
+agricolae,SNK.test,0,0,1,double[],1
+agricolae,SNK.test,1,0,0,character,1
+agricolae,SNK.test,1,0,1,class<`factor`>,1
+agricolae,SNK.test,2,0,0,any,1
+agricolae,SNK.test,3,0,0,any,1
+agricolae,SNK.test,4,0,0,double,1
+agricolae,SNK.test,5,0,0,logical,1
+agricolae,SNK.test,6,0,0,character,1
+agricolae,SNK.test,6,0,1,null,1
+agricolae,SNK.test,7,0,0,logical,1
+agricolae,sp.plot,-1,0,0,"list<class<`anova`, `data.frame`> | double>",1
+agricolae,sp.plot,0,0,0,integer[],1
+agricolae,sp.plot,1,0,0,class<`factor`>,1
+agricolae,sp.plot,2,0,0,class<`factor`>,1
+agricolae,sp.plot,3,0,0,integer[],1
+agricolae,ssp.plot,-1,0,0,"list<class<`anova`, `data.frame`> | double>",1
+agricolae,ssp.plot,0,0,0,integer[],1
+agricolae,ssp.plot,1,0,0,integer[],1
+agricolae,ssp.plot,2,0,0,class<`factor`>,1
+agricolae,ssp.plot,3,0,0,integer[],1
+agricolae,ssp.plot,4,0,0,double[],1
+agricolae,stability.nonpar,-1,0,0,list<class<`data.frame`>>,1
+agricolae,stability.nonpar,0,0,0,class<`data.frame`>,1
+agricolae,stability.nonpar,1,0,0,character,1
+agricolae,stability.nonpar,1,0,1,null,1
+agricolae,stability.nonpar,2,0,0,logical,1
+agricolae,stability.nonpar,3,0,0,logical,1
+agricolae,stability.par,-1,0,0,list<class<`data.frame`>>,1
+agricolae,stability.par,0,0,0,class<`data.frame`>,1
+agricolae,stability.par,1,0,0,double,1
+agricolae,stability.par,2,0,0,double,1
+agricolae,stability.par,3,0,0,double,1
+agricolae,stability.par,4,0,0,character,1
+agricolae,stability.par,5,0,0,logical,1
+agricolae,stability.par,6,0,0,character,1
+agricolae,stability.par,6,0,1,null,1
+agricolae,stability.par,7,0,0,double[],1
+agricolae,stability.par,8,0,0,logical,1
+agricolae,stat.freq,-1,0,0,list<double | class<`matrix`>>,1
+agricolae,stat.freq,0,0,0,"class<`graph.freq`, `histogram`>",1
+agricolae,stat.freq,0,0,1,class<`histogram`>,1
+agricolae,strip.plot,-1,0,0,"list<class<`data.frame`> | class<`anova`, `data.frame`> | double>",1
+agricolae,strip.plot,0,0,0,class<`factor`>,1
+agricolae,strip.plot,1,0,0,class<`factor`>,1
+agricolae,strip.plot,2,0,0,class<`factor`>,1
+agricolae,strip.plot,3,0,0,double[],1
+agricolae,sturges.freq,-1,0,0,list<double[]>,1
+agricolae,sturges.freq,0,0,0,double[],1
+agricolae,sturges.freq,1,0,0,double,1
+agricolae,summary.graph.freq,-1,0,0,class<`data.frame`>,1
+agricolae,summary.graph.freq,0,0,0,"class<`graph.freq`, `histogram`>",1
+agricolae,summary.graph.freq,1,0,0,...,1
+agricolae,table.freq,-1,0,0,class<`data.frame`>,1
+agricolae,table.freq,0,0,0,"class<`graph.freq`, `histogram`>",1
+agricolae,tapply.stat,-1,0,0,class<`data.frame`>,1
+agricolae,tapply.stat,0,0,0,class<`data.frame`>,1
+agricolae,tapply.stat,0,0,1,double[],1
+agricolae,tapply.stat,1,0,0,class<`factor`>,1
+agricolae,tapply.stat,1,0,1,character[],1
+agricolae,tapply.stat,1,0,2,class<`data.frame`>,1
+agricolae,tapply.stat,1,0,3,double[],1
+agricolae,tapply.stat,2,0,0,class<`function`>,1
+agricolae,tapply.stat,2,0,1,character,1
+agricolae,vark,-1,0,0,double,1
+agricolae,vark,0,0,0,double[],1
+agricolae,vark,1,0,0,double[],1
+agricolae,waerden.test,-1,0,0,class<`group`>,1
+agricolae,waerden.test,0,0,0,double[],1
+agricolae,waerden.test,1,0,0,class<`factor`>,1
+agricolae,waerden.test,1,0,1,integer[],1
+agricolae,waerden.test,2,0,0,double,1
+agricolae,waerden.test,3,0,0,logical,1
+agricolae,waerden.test,4,0,0,null,1
+agricolae,waerden.test,5,0,0,logical,1
+agricolae,waller,-1,0,0,double,1
+agricolae,waller,0,0,0,double,1
+agricolae,waller,1,0,0,double,1
+agricolae,waller,2,0,0,double,1
+agricolae,waller,3,0,0,double,1
+agricolae,waller.test,-1,0,0,class<`group`>,1
+agricolae,waller.test,0,0,0,"class<`aov`, `lm`>",1
+agricolae,waller.test,0,0,1,double[],1
+agricolae,waller.test,1,0,0,character,1
+agricolae,waller.test,1,0,1,class<`factor`>,1
+agricolae,waller.test,2,0,0,any,1
+agricolae,waller.test,3,0,0,any,1
+agricolae,waller.test,4,0,0,any,1
+agricolae,waller.test,5,0,0,double,1
+agricolae,waller.test,6,0,0,logical,1
+agricolae,waller.test,7,0,0,character,1
+agricolae,waller.test,7,0,1,null,1
+agricolae,waller.test,8,0,0,logical,1
+agricolae,weatherSeverity,-1,0,0,list<class<`data.frame`> | class<`Date`>>,1
+agricolae,weatherSeverity,0,0,0,class<`data.frame`>,1
+agricolae,weatherSeverity,1,0,0,class<`data.frame`>,1
+agricolae,weatherSeverity,2,0,0,class<`Date`>,1
+agricolae,weatherSeverity,3,0,0,class<`Date`>,1
+agricolae,weatherSeverity,4,0,0,class<`Date`>,1
+agricolae,weatherSeverity,5,0,0,double,1
+agricolae,weatherSeverity,6,0,0,double,1
+agricolae,zigzag,-1,0,0,class<`data.frame`>,1
+agricolae,zigzag,0,0,0,list<class<`matrix`> | class<`data.frame`> | list<character[] | double>>,1
+anytime,addFormats,-1,0,0,null,1
+anytime,addFormats,0,0,0,character[],1
+anytime,anydate,-1,0,0,class<`Date`>,1
+anytime,anydate,0,0,0,"class<`POSIXct`, `POSIXt`>",1
+anytime,anydate,0,0,1,character[],1
+anytime,anydate,0,0,2,class<`Date`>,1
+anytime,anydate,0,0,3,class<`factor`>,1
+anytime,anydate,0,0,4,"class<`factor`, `ordered`>",1
+anytime,anydate,0,0,5,double[],1
+anytime,anydate,1,0,0,any,1
+anytime,anydate,2,0,0,logical,1
+anytime,anydate,3,0,0,any,1
+anytime,anydate,4,0,0,logical,1
+anytime,anydate.Date,-1,0,0,class<`Date`>,1
+anytime,anydate.Date,0,0,0,class<`Date`>,1
+anytime,anydate.Date,1,0,0,any,1
+anytime,anydate.Date,2,0,0,logical,1
+anytime,anydate.Date,3,0,0,any,1
+anytime,anydate.Date,4,0,0,logical,1
+anytime,anydate.default,-1,0,0,class<`Date`>,1
+anytime,anydate.default,0,0,0,character[],1
+anytime,anydate.default,0,0,1,double[],1
+anytime,anydate.default,1,0,0,character,1
+anytime,anydate.default,2,0,0,logical,1
+anytime,anydate.default,3,0,0,logical,1
+anytime,anydate.default,4,0,0,logical,1
+anytime,anydate.factor,-1,0,0,class<`Date`>,1
+anytime,anydate.factor,0,0,0,class<`factor`>,1
+anytime,anydate.factor,0,0,1,"class<`factor`, `ordered`>",1
+anytime,anydate.factor,1,0,0,any,1
+anytime,anydate.factor,2,0,0,logical,1
+anytime,anydate.factor,3,0,0,any,1
+anytime,anydate.factor,4,0,0,logical,1
+anytime,anydate.POSIXt,-1,0,0,class<`Date`>,1
+anytime,anydate.POSIXt,0,0,0,"class<`POSIXct`, `POSIXt`>",1
+anytime,anydate.POSIXt,1,0,0,character,1
+anytime,anydate.POSIXt,2,0,0,logical,1
+anytime,anydate.POSIXt,3,0,0,any,1
+anytime,anydate.POSIXt,4,0,0,logical,1
+anytime,anytime,-1,0,0,"class<`POSIXct`, `POSIXt`>",1
+anytime,anytime,0,0,0,character[],1
+anytime,anytime,1,0,0,any,1
+anytime,anytime,2,0,0,logical,1
+anytime,anytime,3,0,0,any,1
+anytime,anytime,4,0,0,any,1
+anytime,anytime,5,0,0,logical,1
+anytime,anytime_cpp,-1,0,0,class<`Date`>,1
+anytime,anytime_cpp,-1,0,1,"class<`POSIXct`, `POSIXt`>",1
+anytime,anytime_cpp,0,0,0,character[],1
+anytime,anytime_cpp,0,0,1,double[],1
+anytime,anytime_cpp,1,0,0,character,1
+anytime,anytime_cpp,2,0,0,logical,1
+anytime,anytime_cpp,3,0,0,logical,1
+anytime,anytime_cpp,4,0,0,logical,1
+anytime,anytime_cpp,5,0,0,logical,1
+anytime,anytime.default,-1,0,0,"class<`POSIXct`, `POSIXt`>",1
+anytime,anytime.default,0,0,0,character[],1
+anytime,anytime.default,1,0,0,character,1
+anytime,anytime.default,2,0,0,logical,1
+anytime,anytime.default,3,0,0,logical,1
+anytime,anytime.default,4,0,0,logical,1
+anytime,anytime.default,5,0,0,logical,1
+anytime,assertDate,-1,0,0,class<`Date`>,1
+anytime,assertDate,0,0,0,"class<`POSIXct`, `POSIXt`>",1
+anytime,assertDate,0,0,1,character[],1
+anytime,assertDate,0,0,2,class<`Date`>,1
+anytime,assertTime,-1,0,0,"class<`POSIXct`, `POSIXt`>",1
+anytime,assertTime,0,0,0,character[],1
+anytime,getFormats,-1,0,0,character[],1
+anytime,getTZ,-1,0,0,character,1
+anytime,iso8601,-1,0,0,character,1
+anytime,iso8601,0,0,0,class<`Date`>,1
+anytime,iso8601,0,0,1,"class<`POSIXct`, `POSIXt`>",1
+anytime,iso8601.Date,-1,0,0,character,1
+anytime,iso8601.Date,0,0,0,class<`Date`>,1
+anytime,iso8601.POSIXt,-1,0,0,character,1
+anytime,iso8601.POSIXt,0,0,0,"class<`POSIXct`, `POSIXt`>",1
+anytime,removeFormats,-1,0,0,null,1
+anytime,removeFormats,0,0,0,character,1
+anytime,rfc2822,-1,0,0,character,1
+anytime,rfc2822,0,0,0,class<`Date`>,1
+anytime,rfc2822,0,0,1,"class<`POSIXct`, `POSIXt`>",1
+anytime,rfc2822.Date,-1,0,0,character,1
+anytime,rfc2822.Date,0,0,0,class<`Date`>,1
+anytime,rfc2822.POSIXt,-1,0,0,character,1
+anytime,rfc2822.POSIXt,0,0,0,"class<`POSIXct`, `POSIXt`>",1
+anytime,rfc3339,-1,0,0,character,1
+anytime,rfc3339,0,0,0,class<`Date`>,1
+anytime,rfc3339,0,0,1,"class<`POSIXct`, `POSIXt`>",1
+anytime,rfc3339.Date,-1,0,0,character,1
+anytime,rfc3339.Date,0,0,0,class<`Date`>,1
+anytime,rfc3339.POSIXt,-1,0,0,character,1
+anytime,rfc3339.POSIXt,0,0,0,"class<`POSIXct`, `POSIXt`>",1
+anytime,setInitialTZ,-1,0,0,null,1
+anytime,setInitialTZ,0,0,0,character,1
+anytime,utcdate,-1,0,0,class<`Date`>,1
+anytime,utcdate,0,0,0,character[],1
+anytime,utcdate,1,0,0,any,1
+anytime,utcdate,2,0,0,any,1
+anytime,utcdate,3,0,0,logical,1
+anytime,utcdate.default,-1,0,0,class<`Date`>,1
+anytime,utcdate.default,0,0,0,character[],1
+anytime,utcdate.default,1,0,0,character,1
+anytime,utcdate.default,2,0,0,logical,1
+anytime,utcdate.default,3,0,0,logical,1
+anytime,utctime,-1,0,0,"class<`POSIXct`, `POSIXt`>",1
+anytime,utctime,0,0,0,character[],1
+anytime,utctime,1,0,0,character,1
+anytime,utctime,2,0,0,logical,1
+anytime,utctime,3,0,0,logical,1
+anytime,utctime,4,0,0,logical,1
+anytime,yyyymmdd,-1,0,0,character,1
+anytime,yyyymmdd,0,0,0,class<`Date`>,1
+anytime,yyyymmdd,0,0,1,"class<`POSIXct`, `POSIXt`>",1
+aod,AIC,-1,0,0,class<`aic`>,1
+aod,AIC,0,0,0,class<`glimML`>,1
+aod,AIC,1,0,0,...,1
+aod,AIC,2,0,0,double,1
+aod,anova,-1,0,0,class<`anova.glimML`>,1
+aod,anova,0,0,0,class<`glimML`>,1
+aod,anova,1,0,0,...,1
+aod,betabin,-1,0,0,class<`glimML`>,1
+aod,betabin,0,0,0,class<`formula`>,1
+aod,betabin,1,0,0,class<`formula`>,1
+aod,betabin,2,0,0,class<`data.frame`>,1
+aod,betabin,3,0,0,character[],1
+aod,betabin,4,0,0,null,1
+aod,betabin,5,0,0,logical,1
+aod,betabin,6,0,0,class<`function`>,1
+aod,betabin,7,0,0,list<any>,1
+aod,betabin,8,0,0,logical,1
+aod,betabin,9,0,0,list<double>,1
+aod,betabin,10,0,0,...,1
+aod,coef,-1,0,0,double[],1
+aod,coef,0,0,0,class<`glimML`>,1
+aod,coef,1,0,0,...,1
+aod,coef,-1,1,0,double[],1
+aod,coef,0,1,0,class<`glimQL`>,1
+aod,coef,1,1,0,...,1
+aod,deviance,-1,0,0,double,1
+aod,deviance,0,0,0,class<`glimML`>,1
+aod,deviance,1,0,0,...,1
+aod,df.residual,-1,0,0,integer,1
+aod,df.residual,0,0,0,class<`glimML`>,1
+aod,df.residual,1,0,0,...,1
+aod,donner,-1,0,0,class<`drs`>,1
+aod,donner,0,0,0,class<`formula`>,1
+aod,donner,0,0,1,null,1
+aod,donner,1,0,0,any,1
+aod,donner,2,0,0,any,1
+aod,donner,3,0,0,any,1
+aod,donner,4,0,0,class<`data.frame`>,1
+aod,donner,5,0,0,null,1
+aod,donner,5,0,1,double[],1
+aod,fitted,-1,0,0,double[],1
+aod,fitted,0,0,0,class<`glimML`>,1
+aod,fitted,1,0,0,...,1
+aod,iccbin,-1,0,0,class<`iccbin`>,1
+aod,iccbin,0,0,0,any,1
+aod,iccbin,1,0,0,any,1
+aod,iccbin,2,0,0,class<`data.frame`>,1
+aod,iccbin,3,0,0,character,1
+aod,iccbin,4,0,0,double,1
+aod,iccbin,5,0,0,double,1
+aod,invlink,-1,0,0,double[],1
+aod,invlink,0,0,0,double[],1
+aod,invlink,1,0,0,character,1
+aod,link,-1,0,0,double[],1
+aod,link,0,0,0,double[],1
+aod,link,1,0,0,character,1
+aod,negbin,-1,0,0,class<`glimML`>,1
+aod,negbin,0,0,0,class<`formula`>,1
+aod,negbin,1,0,0,class<`formula`>,1
+aod,negbin,2,0,0,class<`data.frame`>,1
+aod,negbin,3,0,0,null,1
+aod,negbin,4,0,0,logical,1
+aod,negbin,5,0,0,class<`function`>,1
+aod,negbin,6,0,0,list<any>,1
+aod,negbin,7,0,0,logical,1
+aod,negbin,8,0,0,list<double>,1
+aod,negbin,9,0,0,...,1
+aod,predict,-1,0,0,list<double[]>,1
+aod,predict,0,0,0,class<`glimML`>,1
+aod,predict,1,0,0,...,1
+aod,predict,-1,1,0,list<double[]>,1
+aod,predict,0,1,0,class<`glimQL`>,1
+aod,predict,1,1,0,...,1
+aod,quasibin,-1,0,0,class<`glimQL`>,1
+aod,quasibin,0,0,0,class<`formula`>,1
+aod,quasibin,1,0,0,class<`data.frame`>,1
+aod,quasibin,2,0,0,character[],1
+aod,quasibin,3,0,0,double,1
+aod,quasibin,3,0,1,null,1
+aod,quasibin,4,0,0,double,1
+aod,quasipois,-1,0,0,class<`glimQL`>,1
+aod,quasipois,0,0,0,class<`formula`>,1
+aod,quasipois,1,0,0,class<`data.frame`>,1
+aod,quasipois,2,0,0,double,1
+aod,quasipois,2,0,1,null,1
+aod,quasipois,3,0,0,double,1
+aod,raoscott,-1,0,0,class<`drs`>,1
+aod,raoscott,0,0,0,class<`formula`>,1
+aod,raoscott,0,0,1,null,1
+aod,raoscott,1,0,0,any,1
+aod,raoscott,2,0,0,any,1
+aod,raoscott,3,0,0,any,1
+aod,raoscott,4,0,0,class<`data.frame`>,1
+aod,raoscott,5,0,0,logical,1
+aod,raoscott,6,0,0,null,1
+aod,raoscott,6,0,1,double[],1
+aod,residuals,-1,0,0,double[],1
+aod,residuals,0,0,0,class<`glimML`>,1
+aod,residuals,1,0,0,...,1
+aod,residuals,-1,1,0,double[],1
+aod,residuals,0,1,0,class<`glimQL`>,1
+aod,residuals,1,1,0,...,1
+aod,splitbin,-1,0,0,list<class<`call`> | class<`data.frame`>>,1
+aod,splitbin,0,0,0,class<`formula`>,1
+aod,splitbin,1,0,0,class<`data.frame`>,1
+aod,splitbin,2,0,0,character,1
+aod,summary,-1,0,0,class<`summary.glimML`>,1
+aod,summary,0,0,0,class<`glimML`>,1
+aod,summary,1,0,0,...,1
+aod,summary,-1,1,0,class<`data.frame`>,1
+aod,summary,0,1,0,class<`aic`>,1
+aod,summary,1,1,0,...,1
+aod,varbin,-1,0,0,class<`varbin`>,1
+aod,varbin,0,0,0,any,1
+aod,varbin,1,0,0,any,1
+aod,varbin,2,0,0,class<`data.frame`>,1
+aod,varbin,3,0,0,double,1
+aod,varbin,4,0,0,double,1
+aod,vcov,-1,0,0,class<`matrix`>,1
+aod,vcov,0,0,0,class<`glimQL`>,1
+aod,vcov,1,0,0,...,1
+aod,vcov,-1,1,0,class<`matrix`>,1
+aod,vcov,0,1,0,class<`glimML`>,1
+aod,vcov,1,1,0,...,1
+aod,wald.test,-1,0,0,class<`wald.test`>,1
+aod,wald.test,0,0,0,class<`matrix`>,1
+aod,wald.test,1,0,0,double[],1
+aod,wald.test,2,0,0,integer[],1
+aod,wald.test,3,0,0,null,1
+aod,wald.test,4,0,0,null,1
+aod,wald.test,5,0,0,null,1
+aod,wald.test,6,0,0,logical,1
+arrangements,combinations,-1,0,0,class<`matrix`>,1
+arrangements,combinations,-1,0,1,list<integer[]>,1
+arrangements,combinations,0,0,0,character[],1
+arrangements,combinations,0,0,1,double,1
+arrangements,combinations,0,0,2,null,1
+arrangements,combinations,1,0,0,double,1
+arrangements,combinations,2,0,0,null,1
+arrangements,combinations,3,0,0,null,1
+arrangements,combinations,4,0,0,null,1
+arrangements,combinations,4,0,1,double[],1
+arrangements,combinations,5,0,0,logical,1
+arrangements,combinations,6,0,0,null,1
+arrangements,combinations,6,0,1,character,1
+arrangements,combinations,7,0,0,double,1
+arrangements,combinations,8,0,0,null,1
+arrangements,combinations,8,0,1,double,1
+arrangements,combinations,9,0,0,null,1
+arrangements,combinations,9,0,1,double[],1
+arrangements,combinations,10,0,0,null,1
+arrangements,combinations,10,0,1,double,1
+arrangements,combinations,11,0,0,null,1
+arrangements,compositions,-1,0,0,class<`matrix`>,1
+arrangements,compositions,-1,0,1,list<integer[]>,1
+arrangements,compositions,0,0,0,double,1
+arrangements,compositions,1,0,0,double,1
+arrangements,compositions,1,0,1,null,1
+arrangements,compositions,2,0,0,logical,1
+arrangements,compositions,3,0,0,character,1
+arrangements,compositions,3,0,1,null,1
+arrangements,compositions,4,0,0,integer,1
+arrangements,compositions,5,0,0,null,1
+arrangements,compositions,6,0,0,null,1
+arrangements,compositions,7,0,0,null,1
+arrangements,compositions,8,0,0,null,1
+arrangements,icombinations,-1,0,0,"class<`Arrangements`, `Combinations`, `R6`, `abstractiter`, `iter`>",1
+arrangements,icombinations,0,0,0,double,1
+arrangements,icombinations,1,0,0,double,1
+arrangements,icombinations,2,0,0,null,1
+arrangements,icombinations,3,0,0,null,1
+arrangements,icombinations,4,0,0,null,1
+arrangements,icombinations,5,0,0,logical,1
+arrangements,icombinations,6,0,0,null,1
+arrangements,icompositions,-1,0,0,"class<`Arrangements`, `Compositions`, `R6`, `abstractiter`, `iter`>",1
+arrangements,icompositions,0,0,0,double,1
+arrangements,icompositions,1,0,0,double,1
+arrangements,icompositions,1,0,1,null,1
+arrangements,icompositions,2,0,0,logical,1
+arrangements,icompositions,3,0,0,null,1
+arrangements,ipartitions,-1,0,0,"class<`Arrangements`, `Partitions`, `R6`, `abstractiter`, `iter`>",1
+arrangements,ipartitions,0,0,0,double,1
+arrangements,ipartitions,1,0,0,double,1
+arrangements,ipartitions,1,0,1,null,1
+arrangements,ipartitions,2,0,0,logical,1
+arrangements,ipartitions,3,0,0,logical,1
+arrangements,ipartitions,4,0,0,null,1
+arrangements,ipermutations,-1,0,0,"class<`Arrangements`, `Permutations`, `R6`, `abstractiter`, `iter`>",1
+arrangements,ipermutations,0,0,0,double,1
+arrangements,ipermutations,1,0,0,double,1
+arrangements,ipermutations,2,0,0,null,1
+arrangements,ipermutations,3,0,0,null,1
+arrangements,ipermutations,4,0,0,null,1
+arrangements,ipermutations,5,0,0,logical,1
+arrangements,ipermutations,6,0,0,null,1
+arrangements,ncombinations,-1,0,0,class<`bigz`>,1
+arrangements,ncombinations,-1,0,1,integer,1
+arrangements,ncombinations,0,0,0,double,1
+arrangements,ncombinations,0,0,1,character[],1
+arrangements,ncombinations,0,0,2,null,1
+arrangements,ncombinations,1,0,0,double,1
+arrangements,ncombinations,2,0,0,null,1
+arrangements,ncombinations,3,0,0,null,1
+arrangements,ncombinations,4,0,0,null,1
+arrangements,ncombinations,4,0,1,double[],1
+arrangements,ncombinations,5,0,0,logical,1
+arrangements,ncombinations,6,0,0,logical,1
+arrangements,ncompositions,-1,0,0,class<`bigz`>,1
+arrangements,ncompositions,-1,0,1,integer,1
+arrangements,ncompositions,0,0,0,double,1
+arrangements,ncompositions,1,0,0,null,1
+arrangements,ncompositions,1,0,1,double,1
+arrangements,ncompositions,2,0,0,logical,1
+arrangements,npartitions,-1,0,0,class<`bigz`>,1
+arrangements,npartitions,-1,0,1,integer,1
+arrangements,npartitions,0,0,0,double,1
+arrangements,npartitions,1,0,0,null,1
+arrangements,npartitions,1,0,1,double,1
+arrangements,npartitions,2,0,0,logical,1
+arrangements,npartitions,3,0,0,logical,1
+arrangements,npermutations,-1,0,0,class<`bigz`>,1
+arrangements,npermutations,-1,0,1,integer,1
+arrangements,npermutations,0,0,0,double,1
+arrangements,npermutations,0,0,1,character[],1
+arrangements,npermutations,0,0,2,null,1
+arrangements,npermutations,1,0,0,double,1
+arrangements,npermutations,1,0,1,null,1
+arrangements,npermutations,2,0,0,null,1
+arrangements,npermutations,3,0,0,null,1
+arrangements,npermutations,4,0,0,null,1
+arrangements,npermutations,4,0,1,double[],1
+arrangements,npermutations,5,0,0,logical,1
+arrangements,npermutations,6,0,0,logical,1
+arrangements,partitions,-1,0,0,class<`matrix`>,1
+arrangements,partitions,-1,0,1,list<integer[]>,1
+arrangements,partitions,0,0,0,double,1
+arrangements,partitions,1,0,0,double,1
+arrangements,partitions,1,0,1,null,1
+arrangements,partitions,2,0,0,logical,1
+arrangements,partitions,3,0,0,logical,1
+arrangements,partitions,4,0,0,character,1
+arrangements,partitions,4,0,1,null,1
+arrangements,partitions,5,0,0,integer,1
+arrangements,partitions,6,0,0,null,1
+arrangements,partitions,7,0,0,null,1
+arrangements,partitions,8,0,0,null,1
+arrangements,partitions,9,0,0,null,1
+arrangements,permutations,-1,0,0,class<`matrix`>,1
+arrangements,permutations,-1,0,1,list<integer[]>,1
+arrangements,permutations,0,0,0,character[],1
+arrangements,permutations,0,0,1,double,1
+arrangements,permutations,0,0,2,null,1
+arrangements,permutations,1,0,0,double,1
+arrangements,permutations,1,0,1,null,1
+arrangements,permutations,2,0,0,null,1
+arrangements,permutations,3,0,0,null,1
+arrangements,permutations,4,0,0,null,1
+arrangements,permutations,4,0,1,double[],1
+arrangements,permutations,5,0,0,logical,1
+arrangements,permutations,6,0,0,null,1
+arrangements,permutations,6,0,1,character,1
+arrangements,permutations,7,0,0,double,1
+arrangements,permutations,8,0,0,null,1
+arrangements,permutations,8,0,1,double,1
+arrangements,permutations,9,0,0,null,1
+arrangements,permutations,9,0,1,double[],1
+arrangements,permutations,10,0,0,null,1
+arrangements,permutations,10,0,1,double,1
+arrangements,permutations,11,0,0,null,1
+arrangements,validate_n_value,-1,0,0,integer,1
+arrangements,validate_n_value,0,0,0,double,1
+arrangements,validate_n_value,1,0,0,double,1
+arrangements,validate_n_value,2,0,0,null,1
+arrangements,validate_n_value,3,0,0,null,1
+arrangements,validate_n_value,4,0,0,null,1
+arrangements,validate_n_value,5,0,0,logical,1
+arules,abbreviate,-1,0,0,class<`itemMatrix`>,1
+arules,abbreviate,0,0,0,class<`itemMatrix`>,1
+arules,abbreviate,1,0,0,...,1
+arules,abbreviate,-1,1,0,character[],1
+arules,abbreviate,0,1,0,character[],1
+arules,abbreviate,1,1,0,...,1
+arules,abbreviate,-1,2,0,character[],1
+arules,abbreviate,-1,2,1,class<`itemMatrix`>,1
+arules,abbreviate,0,2,0,character[],1
+arules,abbreviate,0,2,1,class<`itemMatrix`>,1
+arules,abbreviate,0,2,2,class<`transactions`>,1
+arules,abbreviate,1,2,0,...,1
+arules,abbreviate,-1,3,0,class<`itemMatrix`>,1
+arules,abbreviate,0,3,0,class<`transactions`>,1
+arules,abbreviate,1,3,0,...,1
+arules,addAggregate,-1,0,0,class<`transactions`>,1
+arules,addAggregate,0,0,0,class<`transactions`>,1
+arules,addAggregate,1,0,0,character,1
+arules,addAggregate,2,0,0,character,1
+arules,addComplement,-1,0,0,class<`transactions`>,1
+arules,addComplement,0,0,0,class<`transactions`>,1
+arules,addComplement,1,0,0,character[],1
+arules,addComplement,2,0,0,null,1
+arules,addComplement,2,0,1,character,1
+arules,addComplement,-1,1,0,class<`transactions`>,1
+arules,addComplement,0,1,0,class<`transactions`>,1
+arules,addComplement,1,1,0,character[],1
+arules,addComplement,2,1,0,null,1
+arules,addComplement,2,1,1,character,1
+arules,affinity,-1,0,0,class<`ar_similarity`>,1
+arules,affinity,0,0,0,class<`matrix`>,1
+arules,affinity,0,0,1,class<`transactions`>,1
+arules,affinity,-1,1,0,class<`ar_similarity`>,1
+arules,affinity,0,1,0,class<`matrix`>,1
+arules,affinity,-1,2,0,class<`ar_similarity`>,1
+arules,affinity,0,2,0,class<`transactions`>,1
+arules,aggregate,-1,0,0,class<`rules`>,1
+arules,aggregate,0,0,0,class<`rules`>,1
+arules,aggregate,1,0,0,...,1
+arules,aggregate,-1,1,0,class<`transactions`>,1
+arules,aggregate,0,1,0,class<`transactions`>,1
+arules,aggregate,1,1,0,...,1
+arules,aggregate,-1,2,0,class<`itemMatrix`>,1
+arules,aggregate,0,2,0,class<`itemMatrix`>,1
+arules,aggregate,1,2,0,...,1
+arules,%ain%,-1,0,0,logical[],1
+arules,%ain%,0,0,0,class<`transactions`>,1
+arules,%ain%,1,0,0,character[],1
+arules,%ain%,-1,1,0,logical[],1
+arules,%ain%,0,1,0,class<`itemMatrix`>,1
+arules,%ain%,0,1,1,class<`transactions`>,1
+arules,%ain%,1,1,0,character[],1
+arules,%ain%,-1,2,0,logical[],1
+arules,%ain%,0,2,0,class<`itemMatrix`>,1
+arules,%ain%,1,2,0,character[],1
+arules,apriori,-1,0,0,class<`itemsets`>,1
+arules,apriori,-1,0,1,class<`rules`>,1
+arules,apriori,0,0,0,class<`transactions`>,1
+arules,apriori,1,0,0,list<double | character>,1
+arules,apriori,1,0,1,list<character | double>,1
+arules,apriori,1,0,2,null,1
+arules,apriori,1,0,3,list<double>,1
+arules,apriori,2,0,0,null,1
+arules,apriori,2,0,1,list<character[]>,1
+arules,apriori,3,0,0,list<logical>,1
+arules,apriori,3,0,1,null,1
+arules,.aremtypes,-1,0,0,character[],1
+arules,.barplot_horiz,-1,0,0,class<`matrix`>,1
+arules,.barplot_horiz,0,0,0,double[],1
+arules,.barplot_horiz,1,0,0,...,1
+arules,.barplot_horiz,2,0,0,double,1
+arules,.barplot_horiz,3,0,0,character,1
+arules,.barplot_horiz,4,0,0,null,1
+arules,.barplot_horiz,5,0,0,null,1
+arules,.barplot_vert,-1,0,0,class<`matrix`>,1
+arules,.barplot_vert,0,0,0,double[],1
+arules,.barplot_vert,1,0,0,...,1
+arules,.barplot_vert,2,0,0,double,1
+arules,.barplot_vert,3,0,0,null,1
+arules,.barplot_vert,4,0,0,character,1
+arules,.barplot_vert,5,0,0,null,1
+arules,.basicItemsetMeasures,-1,0,0,double[],1
+arules,.basicItemsetMeasures,0,0,0,class<`itemsets`>,1
+arules,.basicItemsetMeasures,1,0,0,any,1
+arules,.basicItemsetMeasures,2,0,0,class<`transactions`>,1
+arules,.basicItemsetMeasures,3,0,0,any,1
+arules,.basicItemsetMeasures,4,0,0,...,1
+arules,.basicRuleMeasure,-1,0,0,double[],1
+arules,.basicRuleMeasure,0,0,0,any,1
+arules,.basicRuleMeasure,1,0,0,character,1
+arules,.basicRuleMeasure,2,0,0,list<double[]>,1
+arules,.basicRuleMeasure,3,0,0,logical,1
+arules,.basicRuleMeasure,4,0,0,logical,1
+arules,.basicRuleMeasure,5,0,0,...,1
+arules,.combineMeta,-1,0,0,class<`data.frame`>,1
+arules,.combineMeta,0,0,0,class<`itemMatrix`>,1
+arules,.combineMeta,0,0,1,class<`itemsets`>,1
+arules,.combineMeta,0,0,2,class<`rules`>,1
+arules,.combineMeta,0,0,3,class<`transactions`>,1
+arules,.combineMeta,1,0,0,class<`itemMatrix`>,1
+arules,.combineMeta,1,0,1,class<`itemsets`>,1
+arules,.combineMeta,1,0,2,class<`rules`>,1
+arules,.combineMeta,1,0,3,class<`transactions`>,1
+arules,.combineMeta,2,0,0,character,1
+arules,.combineMeta,3,0,0,...,1
+arules,coverage,-1,0,0,double[],1
+arules,coverage,0,0,0,class<`rules`>,1
+arules,coverage,1,0,0,any,1
+arules,coverage,2,0,0,logical,1
+arules,coverage,-1,1,0,double[],1
+arules,coverage,0,1,0,class<`rules`>,1
+arules,coverage,1,1,0,any,1
+arules,coverage,2,1,0,logical,1
+arules,crossTable,-1,0,0,class<`matrix`>,1
+arules,crossTable,0,0,0,class<`itemMatrix`>,1
+arules,crossTable,1,0,0,...,1
+arules,crossTable,-1,1,0,class<`matrix`>,1
+arules,crossTable,0,1,0,class<`transactions`>,1
+arules,crossTable,1,1,0,...,1
+arules,crossTable,-1,2,0,class<`matrix`>,1
+arules,crossTable,0,2,0,class<`itemMatrix`>,1
+arules,crossTable,0,2,1,class<`transactions`>,1
+arules,crossTable,1,2,0,...,1
+arules,DATAFRAME,-1,0,0,class<`data.frame`>,1
+arules,DATAFRAME,0,0,0,class<`rules`>,1
+arules,DATAFRAME,0,0,1,class<`transactions`>,1
+arules,DATAFRAME,1,0,0,...,1
+arules,DATAFRAME,-1,1,0,class<`data.frame`>,1
+arules,DATAFRAME,0,1,0,class<`rules`>,1
+arules,DATAFRAME,1,1,0,...,1
+arules,DATAFRAME,-1,2,0,class<`data.frame`>,1
+arules,DATAFRAME,0,2,0,class<`transactions`>,1
+arules,DATAFRAME,1,2,0,...,1
+arules,decode,-1,0,0,list<character[]>,1
+arules,decode,0,0,0,list<integer[]>,1
+arules,decode,1,0,0,...,1
+arules,decode,-1,1,0,list<character[]>,1
+arules,decode,0,1,0,list<integer[]>,1
+arules,decode,1,1,0,...,1
+arules,.density_Matrix,-1,0,0,double,1
+arules,.density_Matrix,0,0,0,class<`ngCMatrix`>,1
+arules,discretize,-1,0,0,any,1
+arules,discretize,0,0,0,any,1
+arules,discretize,1,0,0,character,1
+arules,discretize,2,0,0,double[],1
+arules,discretize,3,0,0,character[],1
+arules,discretize,3,0,1,null,1
+arules,discretize,4,0,0,logical,1
+arules,discretize,5,0,0,logical,1
+arules,discretize,6,0,0,double,1
+arules,discretize,7,0,0,logical,1
+arules,discretize,8,0,0,logical,1
+arules,discretize,9,0,0,logical,1
+arules,discretize,10,0,0,null,1
+arules,discretize,11,0,0,...,1
+arules,discretizeDF,-1,0,0,class<`data.frame`>,1
+arules,discretizeDF,0,0,0,class<`data.frame`>,1
+arules,discretizeDF,1,0,0,null,1
+arules,discretizeDF,1,0,1,list<list<double | character[]>>,1
+arules,discretizeDF,1,0,2,class<`data.frame`>,1
+arules,discretizeDF,1,0,3,list<null | list<double[] | character[]>>,1
+arules,discretizeDF,2,0,0,null,1
+arules,discretizeDF,2,0,1,list<double | character[]>,1
+arules,discretizeDF,2,0,2,list<character>,1
+arules,dissimilarity,-1,0,0,class<`dist`>,1
+arules,dissimilarity,0,0,0,class<`itemMatrix`>,1
+arules,dissimilarity,1,0,0,null,1
+arules,dissimilarity,2,0,0,character,1
+arules,dissimilarity,3,0,0,list<class<`transactions`>>,1
+arules,dissimilarity,4,0,0,...,1
+arules,dissimilarity,-1,1,0,class<`dist`>,1
+arules,dissimilarity,0,1,0,class<`rules`>,1
+arules,dissimilarity,1,1,0,null,1
+arules,dissimilarity,2,1,0,character,1
+arules,dissimilarity,3,1,0,list<class<`transactions`>>,1
+arules,dissimilarity,4,1,0,...,1
+arules,dissimilarity,-1,2,0,class<`ar_cross_dissimilarity`>,1
+arules,dissimilarity,-1,2,1,class<`dist`>,1
+arules,dissimilarity,0,2,0,class<`matrix`>,1
+arules,dissimilarity,1,2,0,class<`matrix`>,1
+arules,dissimilarity,1,2,1,null,1
+arules,dissimilarity,2,2,0,null,1
+arules,dissimilarity,2,2,1,character,1
+arules,dissimilarity,3,2,0,any,1
+arules,dissimilarity,4,2,0,...,1
+arules,dissimilarity,-1,3,0,class<`ar_cross_dissimilarity`>,1
+arules,dissimilarity,-1,3,1,class<`dist`>,1
+arules,dissimilarity,0,3,0,class<`transactions`>,1
+arules,dissimilarity,1,3,0,class<`transactions`>,1
+arules,dissimilarity,1,3,1,null,1
+arules,dissimilarity,2,3,0,null,1
+arules,dissimilarity,2,3,1,character,1
+arules,dissimilarity,3,3,0,null,1
+arules,dissimilarity,4,3,0,...,1
+arules,dissimilarity,-1,4,0,class<`ar_cross_dissimilarity`>,1
+arules,dissimilarity,-1,4,1,class<`dist`>,1
+arules,dissimilarity,0,4,0,class<`matrix`>,1
+arules,dissimilarity,0,4,1,class<`transactions`>,1
+arules,dissimilarity,0,4,2,class<`itemMatrix`>,1
+arules,dissimilarity,0,4,3,class<`rules`>,1
+arules,dissimilarity,1,4,0,class<`matrix`>,1
+arules,dissimilarity,1,4,1,class<`transactions`>,1
+arules,dissimilarity,1,4,2,null,1
+arules,dissimilarity,2,4,0,null,1
+arules,dissimilarity,2,4,1,character,1
+arules,dissimilarity,3,4,0,any,1
+arules,dissimilarity,4,4,0,...,1
+arules,duplicated,-1,0,0,logical[],1
+arules,duplicated,0,0,0,class<`itemMatrix`>,1
+arules,duplicated,1,0,0,any,1
+arules,duplicated,2,0,0,...,1
+arules,duplicated,-1,1,0,logical[],1
+arules,duplicated,0,1,0,class<`itemsets`>,1
+arules,duplicated,1,1,0,any,1
+arules,duplicated,2,1,0,...,1
+arules,duplicated,-1,2,0,logical[],1
+arules,duplicated,0,2,0,class<`transactions`>,1
+arules,duplicated,1,2,0,any,1
+arules,duplicated,2,2,0,...,1
+arules,duplicated,-1,3,0,logical[],1
+arules,duplicated,0,3,0,class<`rules`>,1
+arules,duplicated,1,3,0,logical,1
+arules,duplicated,2,3,0,...,1
+arules,eclat,-1,0,0,class<`itemsets`>,1
+arules,eclat,0,0,0,class<`transactions`>,1
+arules,eclat,1,0,0,null,1
+arules,eclat,1,0,1,list<double>,1
+arules,eclat,1,0,2,list<character | double>,1
+arules,eclat,2,0,0,null,1
+arules,eclat,2,0,1,list<logical>,1
+arules,encode,-1,0,0,class<`itemMatrix`>,1
+arules,encode,-1,0,1,integer[],1
+arules,encode,0,0,0,list<character[]>,1
+arules,encode,0,0,1,list<integer[]>,1
+arules,encode,0,0,2,character[],1
+arules,encode,0,0,3,integer[],1
+arules,encode,1,0,0,...,1
+arules,encode,-1,1,0,class<`itemMatrix`>,1
+arules,encode,0,1,0,list<character[]>,1
+arules,encode,0,1,1,list<integer[]>,1
+arules,encode,1,1,0,...,1
+arules,filterAggregate,-1,0,0,class<`rules`>,1
+arules,filterAggregate,0,0,0,class<`rules`>,1
+arules,generatingItemsets,-1,0,0,class<`itemsets`>,1
+arules,generatingItemsets,0,0,0,class<`rules`>,1
+arules,generatingItemsets,-1,1,0,class<`itemsets`>,1
+arules,generatingItemsets,0,1,0,class<`rules`>,1
+arules,.getCounts,-1,0,0,list<double[]>,1
+arules,.getCounts,0,0,0,class<`rules`>,1
+arules,.getCounts,1,0,0,class<`transactions`>,1
+arules,.getCounts,2,0,0,logical,1
+arules,hits,-1,0,0,double[],1
+arules,hits,0,0,0,class<`transactions`>,1
+arules,hits,1,0,0,integer,1
+arules,hits,2,0,0,null,1
+arules,hits,3,0,0,character[],1
+arules,hits,4,0,0,logical,1
+arules,.hyperConfidence,-1,0,0,double[],1
+arules,.hyperConfidence,0,0,0,class<`rules`>,1
+arules,.hyperConfidence,1,0,0,class<`transactions`>,1
+arules,.hyperConfidence,2,0,0,logical,1
+arules,.hyperConfidence,3,0,0,logical,1
+arules,.hyperConfidence,4,0,0,logical,1
+arules,.hyperConfidence,5,0,0,...,1
+arules,.hyperLift,-1,0,0,double[],1
+arules,.hyperLift,0,0,0,class<`rules`>,1
+arules,.hyperLift,1,0,0,class<`transactions`>,1
+arules,.hyperLift,2,0,0,logical,1
+arules,.hyperLift,3,0,0,double,1
+arules,.hyperLift,4,0,0,...,1
+arules,.imbalance,-1,0,0,double[],1
+arules,.imbalance,0,0,0,class<`rules`>,1
+arules,.imbalance,1,0,0,class<`transactions`>,1
+arules,.imbalance,2,0,0,logical,1
+arules,.improvement,-1,0,0,double[],1
+arules,.improvement,0,0,0,class<`rules`>,1
+arules,.improvement,1,0,0,any,1
+arules,.improvement,2,0,0,logical,1
+arules,.improvement,3,0,0,character,1
+arules,%in%,-1,0,0,logical[],1
+arules,%in%,0,0,0,class<`transactions`>,1
+arules,%in%,1,0,0,character,1
+arules,%in%,-1,1,0,logical[],1
+arules,%in%,0,1,0,class<`itemMatrix`>,1
+arules,%in%,1,1,0,character,1
+arules,%in%,-1,2,0,integer[],1
+arules,%in%,0,2,0,class<`itemsets`>,1
+arules,%in%,1,2,0,class<`itemsets`>,1
+arules,%in%,-1,3,0,logical[],1
+arules,%in%,0,3,0,class<`transactions`>,1
+arules,%in%,1,3,0,class<`transactions`>,1
+arules,%in%,-1,4,0,integer[],1
+arules,%in%,0,4,0,class<`rules`>,1
+arules,%in%,1,4,0,class<`rules`>,1
+arules,inspect,-1,0,0,class<`data.frame`>,1
+arules,inspect,-1,0,1,null,1
+arules,inspect,0,0,0,class<`transactions`>,1
+arules,inspect,1,0,0,...,1
+arules,inspect,-1,1,0,class<`data.frame`>,1
+arules,inspect,-1,1,1,null,1
+arules,inspect,0,1,0,class<`itemMatrix`>,1
+arules,inspect,1,1,0,...,1
+arules,inspect,-1,2,0,class<`data.frame`>,1
+arules,inspect,-1,2,1,null,1
+arules,inspect,0,2,0,class<`rules`>,1
+arules,inspect,1,2,0,...,1
+arules,inspect,-1,3,0,class<`data.frame`>,1
+arules,inspect,-1,3,1,null,1
+arules,inspect,0,3,0,class<`itemsets`>,1
+arules,inspect,1,3,0,...,1
+arules,inspect,-1,4,0,class<`data.frame`>,1
+arules,inspect,-1,4,1,null,1
+arules,inspect,0,4,0,class<`itemMatrix`>,1
+arules,inspect,0,4,1,class<`itemsets`>,1
+arules,inspect,0,4,2,class<`rules`>,1
+arules,inspect,0,4,3,class<`tidLists`>,1
+arules,inspect,0,4,4,class<`transactions`>,1
+arules,inspect,1,4,0,...,1
+arules,inspect,-1,5,0,class<`data.frame`>,1
+arules,inspect,0,5,0,class<`tidLists`>,1
+arules,inspect,1,5,0,...,1
+arules,.installed,-1,0,0,logical,1
+arules,.installed,0,0,0,character,1
+arules,interestMeasure,-1,0,0,class<`data.frame`>,1
+arules,interestMeasure,-1,0,1,double[],1
+arules,interestMeasure,0,0,0,class<`itemsets`>,1
+arules,interestMeasure,1,0,0,any,1
+arules,interestMeasure,2,0,0,any,1
+arules,interestMeasure,3,0,0,logical,1
+arules,interestMeasure,4,0,0,...,1
+arules,interestMeasure,-1,1,0,class<`data.frame`>,1
+arules,interestMeasure,-1,1,1,^double[],1
+arules,interestMeasure,-1,1,2,null,1
+arules,interestMeasure,0,1,0,class<`rules`>,1
+arules,interestMeasure,1,1,0,any,1
+arules,interestMeasure,2,1,0,any,1
+arules,interestMeasure,3,1,0,any,1
+arules,interestMeasure,4,1,0,...,1
+arules,interestMeasure,-1,2,0,class<`data.frame`>,1
+arules,interestMeasure,-1,2,1,^double[],1
+arules,interestMeasure,-1,2,2,null,1
+arules,interestMeasure,0,2,0,class<`itemsets`>,1
+arules,interestMeasure,0,2,1,class<`rules`>,1
+arules,interestMeasure,1,2,0,any,1
+arules,interestMeasure,2,2,0,any,1
+arules,interestMeasure,3,2,0,any,1
+arules,interestMeasure,4,2,0,...,1
+arules,intersect,-1,0,0,class<`rules`>,1
+arules,intersect,0,0,0,class<`rules`>,1
+arules,intersect,1,0,0,class<`rules`>,1
+arules,is.closed,-1,0,0,logical[],1
+arules,is.closed,0,0,0,class<`itemsets`>,1
+arules,is.closed,-1,1,0,logical[],1
+arules,is.closed,0,1,0,class<`itemsets`>,1
+arules,is.element,-1,0,0,logical[],1
+arules,is.element,0,0,0,class<`itemMatrix`>,1
+arules,is.element,1,0,0,class<`itemMatrix`>,1
+arules,is.maximal,-1,0,0,logical[],1
+arules,is.maximal,0,0,0,class<`itemsets`>,1
+arules,is.maximal,1,0,0,...,1
+arules,is.maximal,-1,1,0,logical[],1
+arules,is.maximal,0,1,0,class<`itemMatrix`>,1
+arules,is.maximal,1,1,0,...,1
+arules,is.maximal,-1,2,0,logical[],1
+arules,is.maximal,0,2,0,class<`itemMatrix`>,1
+arules,is.maximal,0,2,1,class<`itemsets`>,1
+arules,is.maximal,1,2,0,...,1
+arules,is.redundant,-1,0,0,logical[],1
+arules,is.redundant,0,0,0,class<`rules`>,1
+arules,is.redundant,1,0,0,...,1
+arules,is.redundant,-1,1,0,logical[],1
+arules,is.redundant,0,1,0,class<`rules`>,1
+arules,is.redundant,1,1,0,...,1
+arules,is.significant,-1,0,0,logical[],1
+arules,is.significant,0,0,0,class<`rules`>,1
+arules,is.significant,1,0,0,class<`transactions`>,1
+arules,is.significant,2,0,0,character,1
+arules,is.significant,3,0,0,double,1
+arules,is.significant,4,0,0,character,1
+arules,is.significant,-1,1,0,logical[],1
+arules,is.significant,0,1,0,class<`rules`>,1
+arules,is.significant,1,1,0,class<`transactions`>,1
+arules,is.significant,2,1,0,character,1
+arules,is.significant,3,1,0,double,1
+arules,is.significant,4,1,0,character,1
+arules,is.subset,-1,0,0,class<`matrix`>,1
+arules,is.subset,-1,0,1,class<`ngCMatrix`>,1
+arules,is.subset,0,0,0,class<`itemMatrix`>,1
+arules,is.subset,0,0,1,class<`itemsets`>,1
+arules,is.subset,1,0,0,class<`itemsets`>,1
+arules,is.subset,1,0,1,null,1
+arules,is.subset,1,0,2,class<`transactions`>,1
+arules,is.subset,2,0,0,logical,1
+arules,is.subset,3,0,0,logical,1
+arules,is.subset,4,0,0,...,1
+arules,is.subset,-1,1,0,class<`matrix`>,1
+arules,is.subset,-1,1,1,class<`ngCMatrix`>,1
+arules,is.subset,0,1,0,class<`itemsets`>,1
+arules,is.subset,1,1,0,class<`itemsets`>,1
+arules,is.subset,1,1,1,null,1
+arules,is.subset,1,1,2,class<`transactions`>,1
+arules,is.subset,2,1,0,logical,1
+arules,is.subset,3,1,0,logical,1
+arules,is.subset,4,1,0,...,1
+arules,is.subset,-1,2,0,class<`matrix`>,1
+arules,is.subset,-1,2,1,class<`ngCMatrix`>,1
+arules,is.subset,0,2,0,class<`itemMatrix`>,1
+arules,is.subset,1,2,0,class<`itemsets`>,1
+arules,is.subset,1,2,1,null,1
+arules,is.subset,1,2,2,class<`transactions`>,1
+arules,is.subset,2,2,0,logical,1
+arules,is.subset,3,2,0,logical,1
+arules,is.subset,4,2,0,...,1
+arules,.is.subset_sparse,-1,0,0,class<`ngCMatrix`>,1
+arules,.is.subset_sparse,0,0,0,class<`itemMatrix`>,1
+arules,.is.subset_sparse,1,0,0,class<`itemMatrix`>,1
+arules,.is.subset_sparse,1,0,1,class<`transactions`>,1
+arules,.is.subset_sparse,1,0,2,null,1
+arules,.is.subset_sparse,2,0,0,logical,1
+arules,is.superset,-1,0,0,class<`matrix`>,1
+arules,is.superset,-1,0,1,class<`ngCMatrix`>,1
+arules,is.superset,0,0,0,class<`itemsets`>,1
+arules,is.superset,1,0,0,class<`itemsets`>,1
+arules,is.superset,1,0,1,null,1
+arules,is.superset,2,0,0,logical,1
+arules,is.superset,3,0,0,logical,1
+arules,is.superset,4,0,0,...,1
+arules,is.superset,-1,1,0,class<`matrix`>,1
+arules,is.superset,-1,1,1,class<`ngCMatrix`>,1
+arules,is.superset,0,1,0,class<`itemsets`>,1
+arules,is.superset,1,1,0,class<`itemsets`>,1
+arules,is.superset,1,1,1,null,1
+arules,is.superset,2,1,0,logical,1
+arules,is.superset,3,1,0,logical,1
+arules,is.superset,4,1,0,...,1
+arules,itemFrequency,-1,0,0,double[],1
+arules,itemFrequency,0,0,0,class<`transactions`>,1
+arules,itemFrequency,1,0,0,...,1
+arules,itemFrequency,-1,1,0,double[],1
+arules,itemFrequency,0,1,0,class<`transactions`>,1
+arules,itemFrequency,0,1,1,class<`itemMatrix`>,1
+arules,itemFrequency,1,1,0,...,1
+arules,itemFrequency,-1,2,0,double[],1
+arules,itemFrequency,0,2,0,class<`itemMatrix`>,1
+arules,itemFrequency,1,2,0,...,1
+arules,itemFrequencyPlot,-1,0,0,class<`matrix`>,1
+arules,itemFrequencyPlot,0,0,0,class<`transactions`>,1
+arules,itemFrequencyPlot,1,0,0,...,1
+arules,itemFrequencyPlot,-1,1,0,class<`matrix`>,1
+arules,itemFrequencyPlot,0,1,0,class<`transactions`>,1
+arules,itemFrequencyPlot,1,1,0,...,1
+arules,itemInfo,-1,0,0,class<`data.frame`>,1
+arules,itemInfo,0,0,0,class<`itemMatrix`>,1
+arules,itemInfo,-1,1,0,class<`data.frame`>,1
+arules,itemInfo,0,1,0,class<`itemMatrix`>,1
+arules,itemInfo,0,1,1,class<`transactions`>,1
+arules,itemInfo,0,1,2,class<`rules`>,1
+arules,itemInfo,-1,2,0,class<`data.frame`>,1
+arules,itemInfo,0,2,0,class<`transactions`>,1
+arules,itemInfo,-1,3,0,class<`data.frame`>,1
+arules,itemInfo,0,3,0,class<`rules`>,1
+arules,itemInfo<-,-1,0,0,class<`transactions`>,1
+arules,itemInfo<-,0,0,0,class<`transactions`>,1
+arules,itemInfo<-,1,0,0,class<`data.frame`>,1
+arules,itemInfo<-,-1,1,0,class<`itemMatrix`>,1
+arules,itemInfo<-,0,1,0,class<`itemMatrix`>,1
+arules,itemInfo<-,1,1,0,class<`data.frame`>,1
+arules,itemInfo<-,-1,2,0,class<`itemMatrix`>,1
+arules,itemInfo<-,-1,2,1,class<`transactions`>,1
+arules,itemInfo<-,0,2,0,class<`itemMatrix`>,1
+arules,itemInfo<-,0,2,1,class<`transactions`>,1
+arules,itemInfo<-,1,2,0,class<`data.frame`>,1
+arules,itemIntersect,-1,0,0,class<`itemMatrix`>,1
+arules,itemIntersect,0,0,0,class<`itemMatrix`>,1
+arules,itemIntersect,1,0,0,class<`itemMatrix`>,1
+arules,itemIntersect,-1,1,0,class<`itemMatrix`>,1
+arules,itemIntersect,0,1,0,class<`itemMatrix`>,1
+arules,itemIntersect,1,1,0,class<`itemMatrix`>,1
+arules,itemLabels,-1,0,0,character[],1
+arules,itemLabels,-1,0,1,class<`factor`>,1
+arules,itemLabels,0,0,0,class<`rules`>,1
+arules,itemLabels,0,0,1,class<`itemMatrix`>,1
+arules,itemLabels,0,0,2,class<`itemsets`>,1
+arules,itemLabels,0,0,3,class<`tidLists`>,1
+arules,itemLabels,0,0,4,class<`transactions`>,1
+arules,itemLabels,1,0,0,...,1
+arules,itemLabels,-1,1,0,character[],1
+arules,itemLabels,0,1,0,class<`itemMatrix`>,1
+arules,itemLabels,1,1,0,...,1
+arules,itemLabels,-1,2,0,character[],1
+arules,itemLabels,0,2,0,class<`transactions`>,1
+arules,itemLabels,1,2,0,...,1
+arules,itemLabels,-1,3,0,character[],1
+arules,itemLabels,0,3,0,class<`itemsets`>,1
+arules,itemLabels,1,3,0,...,1
+arules,itemLabels,-1,4,0,character[],1
+arules,itemLabels,-1,4,1,class<`factor`>,1
+arules,itemLabels,0,4,0,class<`tidLists`>,1
+arules,itemLabels,1,4,0,...,1
+arules,itemLabels<-,-1,0,0,class<`transactions`>,1
+arules,itemLabels<-,0,0,0,class<`transactions`>,1
+arules,itemLabels<-,1,0,0,character[],1
+arules,itemLabels<-,-1,1,0,class<`transactions`>,1
+arules,itemLabels<-,0,1,0,class<`transactions`>,1
+arules,itemLabels<-,1,1,0,character[],1
+arules,items,-1,0,0,class<`itemMatrix`>,1
+arules,items,0,0,0,class<`itemsets`>,1
+arules,items,0,0,1,class<`rules`>,1
+arules,items,-1,1,0,class<`itemMatrix`>,1
+arules,items,0,1,0,class<`rules`>,1
+arules,items,-1,2,0,class<`itemMatrix`>,1
+arules,items,0,2,0,class<`itemsets`>,1
+arules,itemSetdiff,-1,0,0,class<`itemMatrix`>,1
+arules,itemSetdiff,0,0,0,class<`itemMatrix`>,1
+arules,itemSetdiff,1,0,0,class<`itemMatrix`>,1
+arules,itemSetdiff,-1,1,0,class<`itemMatrix`>,1
+arules,itemSetdiff,0,1,0,class<`itemMatrix`>,1
+arules,itemSetdiff,1,1,0,class<`itemMatrix`>,1
+arules,itemsetInfo,-1,0,0,class<`data.frame`>,1
+arules,itemsetInfo,0,0,0,class<`itemMatrix`>,1
+arules,itemsetInfo,-1,1,0,class<`data.frame`>,1
+arules,itemsetInfo,0,1,0,class<`transactions`>,1
+arules,itemsetInfo,-1,2,0,class<`data.frame`>,1
+arules,itemsetInfo,0,2,0,class<`itemMatrix`>,1
+arules,itemsetInfo,0,2,1,class<`transactions`>,1
+arules,itemsetInfo<-,-1,0,0,class<`transactions`>,1
+arules,itemsetInfo<-,0,0,0,class<`transactions`>,1
+arules,itemsetInfo<-,1,0,0,class<`data.frame`>,1
+arules,itemsetInfo<-,-1,1,0,class<`itemMatrix`>,1
+arules,itemsetInfo<-,-1,1,1,class<`transactions`>,1
+arules,itemsetInfo<-,0,1,0,class<`itemMatrix`>,1
+arules,itemsetInfo<-,0,1,1,class<`transactions`>,1
+arules,itemsetInfo<-,1,1,0,class<`data.frame`>,1
+arules,itemsetInfo<-,-1,2,0,class<`itemMatrix`>,1
+arules,itemsetInfo<-,0,2,0,class<`itemMatrix`>,1
+arules,itemsetInfo<-,1,2,0,class<`data.frame`>,1
+arules,itemUnion,-1,0,0,class<`itemMatrix`>,1
+arules,itemUnion,0,0,0,class<`itemMatrix`>,1
+arules,itemUnion,1,0,0,class<`itemMatrix`>,1
+arules,itemUnion,-1,1,0,class<`itemMatrix`>,1
+arules,itemUnion,0,1,0,class<`itemMatrix`>,1
+arules,itemUnion,1,1,0,class<`itemMatrix`>,1
+arules,.joinedList,-1,0,0,list<double[]>,1
+arules,.joinedList,0,0,0,class<`rules`>,1
+arules,.kulc,-1,0,0,double[],1
+arules,.kulc,0,0,0,class<`rules`>,1
+arules,.kulc,1,0,0,class<`transactions`>,1
+arules,.kulc,2,0,0,logical,1
+arules,labels,-1,0,0,character[],1
+arules,labels,0,0,0,class<`itemMatrix`>,1
+arules,labels,1,0,0,...,1
+arules,labels,-1,1,0,character[],1
+arules,labels,0,1,0,class<`rules`>,1
+arules,labels,1,1,0,...,1
+arules,labels,-1,2,0,character[],1
+arules,labels,0,2,0,class<`transactions`>,1
+arules,labels,1,2,0,...,1
+arules,labels,-1,3,0,character[],1
+arules,labels,0,3,0,class<`tidLists`>,1
+arules,labels,1,3,0,...,1
+arules,labels,-1,4,0,character[],1
+arules,labels,0,4,0,class<`itemsets`>,1
+arules,labels,1,4,0,...,1
+arules,lhs,-1,0,0,class<`itemMatrix`>,1
+arules,lhs,0,0,0,class<`rules`>,1
+arules,lhs,-1,1,0,class<`itemMatrix`>,1
+arules,lhs,0,1,0,class<`rules`>,1
+arules,LIST,-1,0,0,list<any>,1
+arules,LIST,0,0,0,class<`itemMatrix`>,1
+arules,LIST,0,0,1,class<`transactions`>,1
+arules,LIST,0,0,2,class<`tidLists`>,1
+arules,LIST,1,0,0,...,1
+arules,LIST,-1,1,0,list<any>,1
+arules,LIST,0,1,0,class<`itemMatrix`>,1
+arules,LIST,1,1,0,...,1
+arules,LIST,-1,2,0,list<character[]>,1
+arules,LIST,-1,2,1,list<integer[]>,1
+arules,LIST,0,2,0,class<`tidLists`>,1
+arules,LIST,1,2,0,...,1
+arules,LIST,-1,3,0,list<character[]>,1
+arules,LIST,-1,3,1,list<integer[]>,1
+arules,LIST,0,3,0,class<`transactions`>,1
+arules,LIST,1,3,0,...,1
+arules,.list2object,-1,0,0,class<`APcontrol`>,1
+arules,.list2object,-1,0,1,class<`APparameter`>,1
+arules,.list2object,-1,0,2,class<`ECcontrol`>,1
+arules,.list2object,-1,0,3,class<`ECparameter`>,1
+arules,.list2object,0,0,0,list<double>,1
+arules,.list2object,0,0,1,list<double | character>,1
+arules,.list2object,0,0,2,list<character | double>,1
+arules,.list2object,1,0,0,character,1
+arules,match,-1,0,0,^integer[],1
+arules,match,0,0,0,class<`itemMatrix`>,1
+arules,match,1,0,0,class<`itemMatrix`>,1
+arules,match,2,0,0,null,1
+arules,match,2,0,1,double,1
+arules,match,3,0,0,null,1
+arules,match,-1,1,0,integer[],1
+arules,match,0,1,0,class<`itemsets`>,1
+arules,match,1,1,0,class<`itemsets`>,1
+arules,match,2,1,0,double,1
+arules,match,2,1,1,null,1
+arules,match,3,1,0,null,1
+arules,match,-1,2,0,integer[],1
+arules,match,0,2,0,class<`rules`>,1
+arules,match,1,2,0,class<`rules`>,1
+arules,match,2,2,0,integer,1
+arules,match,2,2,1,null,1
+arules,match,3,2,0,null,1
+arules,match,-1,3,0,^integer[],1
+arules,match,0,3,0,class<`transactions`>,1
+arules,match,1,3,0,class<`transactions`>,1
+arules,match,2,3,0,null,1
+arules,match,3,3,0,null,1
+arules,.maxConf,-1,0,0,double[],1
+arules,.maxConf,0,0,0,class<`rules`>,1
+arules,.maxConf,1,0,0,class<`transactions`>,1
+arules,.maxConf,2,0,0,logical,1
+arules,merge,-1,0,0,class<`transactions`>,1
+arules,merge,0,0,0,class<`transactions`>,1
+arules,merge,1,0,0,class<`matrix`>,1
+arules,merge,1,0,1,class<`transactions`>,1
+arules,merge,2,0,0,...,1
+arules,merge,-1,1,0,class<`itemMatrix`>,1
+arules,merge,0,1,0,class<`itemMatrix`>,1
+arules,merge,1,1,0,class<`itemMatrix`>,1
+arules,merge,2,1,0,...,1
+arules,nitems,-1,0,0,integer,1
+arules,nitems,0,0,0,class<`itemMatrix`>,1
+arules,nitems,0,0,1,class<`transactions`>,1
+arules,nitems,1,0,0,...,1
+arules,nitems,-1,1,0,integer,1
+arules,nitems,0,1,0,class<`transactions`>,1
+arules,nitems,1,1,0,...,1
+arules,nitems,-1,2,0,integer,1
+arules,nitems,0,2,0,class<`itemMatrix`>,1
+arules,nitems,1,2,0,...,1
+arules,%oin%,-1,0,0,logical[],1
+arules,%oin%,0,0,0,class<`transactions`>,1
+arules,%oin%,1,0,0,character,1
+arules,%oin%,-1,1,0,logical[],1
+arules,%oin%,0,1,0,class<`transactions`>,1
+arules,%oin%,1,1,0,character,1
+arules,%pin%,-1,0,0,any,1
+arules,%pin%,0,0,0,class<`itemMatrix`>,1
+arules,%pin%,1,0,0,character[],1
+arules,%pin%,-1,1,0,logical[],1
+arules,%pin%,0,1,0,class<`transactions`>,1
+arules,%pin%,1,1,0,character,1
+arules,%pin%,-1,2,0,any,1
+arules,%pin%,0,2,0,class<`itemMatrix`>,1
+arules,%pin%,0,2,1,class<`transactions`>,1
+arules,%pin%,1,2,0,character[],1
+arules,predict,-1,0,0,integer[],1
+arules,predict,0,0,0,class<`transactions`>,1
+arules,predict,1,0,0,...,1
+arules,quality,-1,0,0,class<`data.frame`>,1
+arules,quality,0,0,0,class<`itemsets`>,1
+arules,quality,-1,1,0,class<`data.frame`>,1
+arules,quality,0,1,0,class<`rules`>,1
+arules,quality,-1,2,0,class<`data.frame`>,1
+arules,quality,0,2,0,class<`itemsets`>,1
+arules,quality,0,2,1,class<`rules`>,1
+arules,quality<-,-1,0,0,class<`itemsets`>,1
+arules,quality<-,-1,0,1,class<`rules`>,1
+arules,quality<-,0,0,0,class<`itemsets`>,1
+arules,quality<-,0,0,1,class<`rules`>,1
+arules,quality<-,1,0,0,class<`data.frame`>,1
+arules,quality<-,-1,1,0,class<`itemsets`>,1
+arules,quality<-,0,1,0,class<`itemsets`>,1
+arules,quality<-,1,1,0,class<`data.frame`>,1
+arules,quality<-,-1,2,0,class<`rules`>,1
+arules,quality<-,0,2,0,class<`rules`>,1
+arules,quality<-,1,2,0,class<`data.frame`>,1
+arules,random.patterns,-1,0,0,class<`itemsets`>,1
+arules,random.patterns,0,0,0,double,1
+arules,random.patterns,1,0,0,double,1
+arules,random.patterns,2,0,0,null,1
+arules,random.patterns,3,0,0,double,1
+arules,random.patterns,4,0,0,double,1
+arules,random.patterns,5,0,0,double,1
+arules,random.patterns,6,0,0,double,1
+arules,random.patterns,7,0,0,null,1
+arules,random.patterns,8,0,0,logical,1
+arules,random.transactions,-1,0,0,class<`transactions`>,1
+arules,random.transactions,0,0,0,double,1
+arules,random.transactions,1,0,0,double,1
+arules,random.transactions,2,0,0,character,1
+arules,random.transactions,3,0,0,...,1
+arules,random.transactions,4,0,0,logical,1
+arules,.random.transactions_agrawal,-1,0,0,class<`transactions`>,1
+arules,.random.transactions_agrawal,0,0,0,double,1
+arules,.random.transactions_agrawal,1,0,0,double,1
+arules,.random.transactions_agrawal,2,0,0,double,1
+arules,.random.transactions_agrawal,3,0,0,class<`itemsets`>,1
+arules,.random.transactions_agrawal,4,0,0,...,1
+arules,.random.transactions_agrawal,5,0,0,logical,1
+arules,.random.transactions_independent,-1,0,0,class<`transactions`>,1
+arules,.random.transactions_independent,0,0,0,double,1
+arules,.random.transactions_independent,1,0,0,double,1
+arules,.random.transactions_independent,2,0,0,double,1
+arules,.random.transactions_independent,3,0,0,double[],1
+arules,.random.transactions_independent,4,0,0,any,1
+arules,read.PMML,-1,0,0,class<`rules`>,1
+arules,read.PMML,0,0,0,character,1
+arules,.read.PMML.arules,-1,0,0,class<`rules`>,1
+arules,.read.PMML.arules,0,0,0,"class<`RXMLAbstractNode`, `XMLAbstractNode`, `XMLNode`, `oldClass`>",1
+arules,read.transactions,-1,0,0,class<`transactions`>,1
+arules,read.transactions,0,0,0,character,1
+arules,read.transactions,0,0,1,"class<`connection`, `file`>",1
+arules,read.transactions,1,0,0,character[],1
+arules,read.transactions,2,0,0,logical,1
+arules,read.transactions,3,0,0,character,1
+arules,read.transactions,4,0,0,null,1
+arules,read.transactions,4,0,1,character[],1
+arules,read.transactions,4,0,2,double[],1
+arules,read.transactions,5,0,0,logical,1
+arules,read.transactions,6,0,0,character,1
+arules,read.transactions,7,0,0,double,1
+arules,read.transactions,8,0,0,character,1
+arules,recode,-1,0,0,class<`itemMatrix`>,1
+arules,recode,0,0,0,class<`itemMatrix`>,1
+arules,recode,1,0,0,...,1
+arules,recode,-1,1,0,class<`transactions`>,1
+arules,recode,0,1,0,class<`transactions`>,1
+arules,recode,1,1,0,...,1
+arules,recode,-1,2,0,class<`itemMatrix`>,1
+arules,recode,-1,2,1,class<`transactions`>,1
+arules,recode,0,2,0,class<`itemMatrix`>,1
+arules,recode,0,2,1,class<`transactions`>,1
+arules,recode,1,2,0,...,1
+arules,.rediscretizeDF,-1,0,0,class<`data.frame`>,1
+arules,.rediscretizeDF,0,0,0,class<`data.frame`>,1
+arules,.rediscretizeDF,1,0,0,class<`data.frame`>,1
+arules,rhs,-1,0,0,class<`itemMatrix`>,1
+arules,rhs,0,0,0,class<`rules`>,1
+arules,rhs,-1,1,0,class<`itemMatrix`>,1
+arules,rhs,0,1,0,class<`rules`>,1
+arules,.rhsSupport,-1,0,0,double[],1
+arules,.rhsSupport,0,0,0,class<`rules`>,1
+arules,.rhsSupport,1,0,0,class<`transactions`>,1
+arules,.rhsSupport,2,0,0,logical,1
+arules,.RLD,-1,0,0,^double[],1
+arules,.RLD,-1,0,1,null,1
+arules,.RLD,0,0,0,class<`rules`>,1
+arules,.RLD,1,0,0,class<`transactions`>,1
+arules,.RLD,2,0,0,logical,1
+arules,ruleInduction,-1,0,0,any,1
+arules,ruleInduction,0,0,0,class<`itemsets`>,1
+arules,ruleInduction,1,0,0,...,1
+arules,ruleInduction,-1,1,0,any,1
+arules,ruleInduction,0,1,0,class<`itemsets`>,1
+arules,ruleInduction,1,1,0,...,1
+arules,ruleInduction.apriori,-1,0,0,class<`rules`>,1
+arules,ruleInduction.apriori,0,0,0,any,1
+arules,ruleInduction.apriori,1,0,0,class<`transactions`>,1
+arules,ruleInduction.apriori,2,0,0,any,1
+arules,ruleInduction.apriori,3,0,0,any,1
+arules,ruleInduction.index,-1,0,0,any,1
+arules,ruleInduction.index,0,0,0,class<`itemsets`>,1
+arules,ruleInduction.index,1,0,0,any,1
+arules,ruleInduction.index,2,0,0,any,1
+arules,ruleInduction.ptree,-1,0,0,class<`rules`>,1
+arules,ruleInduction.ptree,0,0,0,class<`itemsets`>,1
+arules,ruleInduction.ptree,1,0,0,class<`transactions`>,1
+arules,ruleInduction.ptree,2,0,0,double,1
+arules,ruleInduction.ptree,3,0,0,logical,1
+arules,ruleInduction.ptree,4,0,0,logical,1
+arules,sample,-1,0,0,class<`transactions`>,1
+arules,sample,0,0,0,class<`transactions`>,1
+arules,sample,1,0,0,double,1
+arules,sample,2,0,0,logical,1
+arules,sample,3,0,0,null,1
+arules,sample,4,0,0,...,1
+arules,setequal,-1,0,0,logical,1
+arules,setequal,0,0,0,class<`rules`>,1
+arules,setequal,1,0,0,class<`rules`>,1
+arules,size,-1,0,0,integer[],1
+arules,size,0,0,0,class<`itemMatrix`>,1
+arules,size,1,0,0,...,1
+arules,size,-1,1,0,integer[],1
+arules,size,0,1,0,class<`itemMatrix`>,1
+arules,size,0,1,1,class<`itemsets`>,1
+arules,size,0,1,2,class<`rules`>,1
+arules,size,0,1,3,class<`tidLists`>,1
+arules,size,0,1,4,class<`transactions`>,1
+arules,size,1,1,0,...,1
+arules,size,-1,2,0,integer[],1
+arules,size,0,2,0,class<`transactions`>,1
+arules,size,1,2,0,...,1
+arules,size,-1,3,0,integer[],1
+arules,size,0,3,0,class<`tidLists`>,1
+arules,size,1,3,0,...,1
+arules,size,-1,4,0,integer[],1
+arules,size,0,4,0,class<`itemsets`>,1
+arules,size,1,4,0,...,1
+arules,size,-1,5,0,integer[],1
+arules,size,0,5,0,class<`rules`>,1
+arules,size,1,5,0,...,1
+arules,sort,-1,0,0,class<`rules`>,1
+arules,sort,-1,0,1,integer[],1
+arules,sort,0,0,0,class<`rules`>,1
+arules,sort,1,0,0,logical,1
+arules,sort,2,0,0,...,1
+arules,sort,-1,1,0,class<`itemsets`>,1
+arules,sort,0,1,0,class<`itemsets`>,1
+arules,sort,1,1,0,logical,1
+arules,sort,2,1,0,...,1
+arules,subset,-1,0,0,class<`rules`>,1
+arules,subset,0,0,0,class<`rules`>,1
+arules,subset,1,0,0,...,1
+arules,subset,-1,1,0,class<`itemsets`>,1
+arules,subset,0,1,0,class<`itemsets`>,1
+arules,subset,1,1,0,...,1
+arules,support,-1,0,0,any,1
+arules,support,0,0,0,class<`itemMatrix`>,1
+arules,support,1,0,0,class<`transactions`>,1
+arules,support,2,0,0,...,1
+arules,support,-1,1,0,double[],1
+arules,support,0,1,0,class<`rules`>,1
+arules,support,1,1,0,class<`transactions`>,1
+arules,support,2,1,0,...,1
+arules,support,-1,2,0,any,1
+arules,support,0,2,0,class<`itemsets`>,1
+arules,support,1,2,0,class<`transactions`>,1
+arules,support,2,2,0,...,1
+arules,support,-1,3,0,any,1
+arules,support,0,3,0,class<`itemMatrix`>,1
+arules,support,0,3,1,class<`itemsets`>,1
+arules,support,0,3,2,class<`rules`>,1
+arules,support,1,3,0,class<`transactions`>,1
+arules,support,2,3,0,...,1
+arules,supportingTransactions,-1,0,0,class<`tidLists`>,1
+arules,supportingTransactions,0,0,0,class<`itemsets`>,1
+arules,supportingTransactions,1,0,0,class<`transactions`>,1
+arules,supportingTransactions,2,0,0,...,1
+arules,supportingTransactions,-1,1,0,class<`tidLists`>,1
+arules,supportingTransactions,0,1,0,class<`itemsets`>,1
+arules,supportingTransactions,1,1,0,class<`transactions`>,1
+arules,supportingTransactions,2,1,0,...,1
+arules,support.ptree,-1,0,0,integer[],1
+arules,support.ptree,0,0,0,class<`itemMatrix`>,1
+arules,support.ptree,1,0,0,class<`transactions`>,1
+arules,support.ptree,2,0,0,list<character>,1
+arules,support.ptree,2,0,1,null,1
+arules,support.tidlists,-1,0,0,integer[],1
+arules,support.tidlists,0,0,0,class<`itemMatrix`>,1
+arules,support.tidlists,1,0,0,class<`transactions`>,1
+arules,support.tidlists,2,0,0,list<character>,1
+arules,support.weighted,-1,0,0,double[],1
+arules,support.weighted,0,0,0,class<`itemMatrix`>,1
+arules,support.weighted,1,0,0,class<`transactions`>,1
+arules,support.weighted,2,0,0,null,1
+arules,tidLists,-1,0,0,class<`tidLists`>,1
+arules,tidLists,-1,0,1,null,1
+arules,tidLists,0,0,0,class<`itemsets`>,1
+arules,tidLists,-1,1,0,class<`tidLists`>,1
+arules,tidLists,-1,1,1,null,1
+arules,tidLists,0,1,0,class<`itemsets`>,1
+arules,transactionInfo,-1,0,0,class<`data.frame`>,1
+arules,transactionInfo,0,0,0,class<`transactions`>,1
+arules,transactionInfo,-1,1,0,class<`data.frame`>,1
+arules,transactionInfo,0,1,0,class<`tidLists`>,1
+arules,transactionInfo,-1,2,0,class<`data.frame`>,1
+arules,transactionInfo,0,2,0,class<`tidLists`>,1
+arules,transactionInfo,0,2,1,class<`transactions`>,1
+arules,transactionInfo<-,-1,0,0,class<`transactions`>,1
+arules,transactionInfo<-,0,0,0,class<`transactions`>,1
+arules,transactionInfo<-,1,0,0,class<`data.frame`>,1
+arules,transactionInfo<-,-1,1,0,class<`tidLists`>,1
+arules,transactionInfo<-,0,1,0,class<`tidLists`>,1
+arules,transactionInfo<-,1,1,0,class<`data.frame`>,1
+arules,transactionInfo<-,-1,2,0,class<`tidLists`>,1
+arules,transactionInfo<-,-1,2,1,class<`transactions`>,1
+arules,transactionInfo<-,0,2,0,class<`tidLists`>,1
+arules,transactionInfo<-,0,2,1,class<`transactions`>,1
+arules,transactionInfo<-,1,2,0,class<`data.frame`>,1
+arules,.translate_index,-1,0,0,integer[],1
+arules,.translate_index,0,0,0,double[],1
+arules,.translate_index,0,0,1,character[],1
+arules,.translate_index,1,0,0,any,1
+arules,.translate_index,2,0,0,any,1
+arules,.types,-1,0,0,character[],1
+arules,.types,0,0,0,character,1
+arules,union,-1,0,0,class<`rules`>,1
+arules,union,0,0,0,class<`rules`>,1
+arules,union,1,0,0,class<`rules`>,1
+arules,unique,-1,0,0,class<`itemMatrix`>,1
+arules,unique,0,0,0,class<`itemMatrix`>,1
+arules,unique,1,0,0,logical,1
+arules,unique,2,0,0,...,1
+arules,unique,-1,1,0,class<`itemsets`>,1
+arules,unique,0,1,0,class<`itemsets`>,1
+arules,unique,1,1,0,logical,1
+arules,unique,2,1,0,...,1
+arules,unique,-1,2,0,class<`rules`>,1
+arules,unique,0,2,0,class<`rules`>,1
+arules,unique,1,2,0,logical,1
+arules,unique,2,2,0,...,1
+arules,unique,-1,3,0,class<`transactions`>,1
+arules,unique,0,3,0,class<`transactions`>,1
+arules,unique,1,3,0,logical,1
+arules,unique,2,3,0,...,1
+arules,weclat,-1,0,0,class<`itemsets`>,1
+arules,weclat,0,0,0,class<`transactions`>,1
+arules,weclat,1,0,0,null,1
+arules,weclat,1,0,1,list<double>,1
+arules,weclat,2,0,0,list<logical>,1
+arules,write,-1,0,0,character[],1
+arules,write,-1,0,1,class<`data.frame`>,1
+arules,write,0,0,0,class<`transactions`>,1
+arules,write,1,0,0,character,1
+arules,write,2,0,0,...,1
+arules,write,-1,1,0,character[],1
+arules,write,-1,1,1,class<`data.frame`>,1
+arules,write,-1,1,2,null,1
+arules,write,0,1,0,class<`transactions`>,1
+arules,write,0,1,1,character[],1
+arules,write,0,1,2,class<`rules`>,1
+arules,write,1,1,0,character,1
+arules,write,2,1,0,...,1
+arules,write,-1,2,0,null,1
+arules,write,0,2,0,class<`rules`>,1
+arules,write,1,2,0,character,1
+arules,write,2,2,0,...,1
+arules,write,-1,3,0,null,1
+arules,write,0,3,0,character[],1
+arules,write,1,3,0,character,1
+arules,write,2,3,0,...,1
+arules,write.PMML,-1,0,0,character,1
+arules,write.PMML,0,0,0,class<`rules`>,1
+arules,write.PMML,1,0,0,character,1
+assertive.properties,are_same_length,-1,0,0,logical,1
+assertive.properties,are_same_length,-1,0,1,"class<`logical`, `scalar_with_cause`>",1
+assertive.properties,are_same_length,0,0,0,double[],1
+assertive.properties,are_same_length,1,0,0,list<double | integer[]>,1
+assertive.properties,are_same_length,2,0,0,any,1
+assertive.properties,are_same_length,3,0,0,any,1
+assertive.properties,assert_are_same_length,-1,0,0,any,1
+assertive.properties,assert_are_same_length,0,0,0,double[],1
+assertive.properties,assert_are_same_length,1,0,0,list<double | integer[]>,1
+assertive.properties,assert_are_same_length,2,0,0,character,1
+assertive.properties,assert_has_all_attributes,-1,0,0,any,1
+assertive.properties,assert_has_all_attributes,0,0,0,double,1
+assertive.properties,assert_has_all_attributes,1,0,0,character[],1
+assertive.properties,assert_has_all_attributes,2,0,0,character,1
+assertive.properties,assert_has_any_attributes,-1,0,0,double,1
+assertive.properties,assert_has_any_attributes,0,0,0,double,1
+assertive.properties,assert_has_any_attributes,1,0,0,character[],1
+assertive.properties,assert_has_any_attributes,2,0,0,character,1
+assertive.properties,assert_has_colnames,-1,0,0,class<`data.frame`>,1
+assertive.properties,assert_has_colnames,0,0,0,class<`data.frame`>,1
+assertive.properties,assert_has_colnames,1,0,0,character,1
+assertive.properties,assert_has_cols,-1,0,0,class<`matrix`>,1
+assertive.properties,assert_has_cols,0,0,0,class<`matrix`>,1
+assertive.properties,assert_has_cols,1,0,0,character,1
+assertive.properties,assert_has_dimnames,-1,0,0,class<`data.frame`>,1
+assertive.properties,assert_has_dimnames,0,0,0,class<`data.frame`>,1
+assertive.properties,assert_has_dimnames,1,0,0,character,1
+assertive.properties,assert_has_duplicates,-1,0,0,integer[],1
+assertive.properties,assert_has_duplicates,0,0,0,integer[],1
+assertive.properties,assert_has_duplicates,1,0,0,character,1
+assertive.properties,assert_has_elements,-1,0,0,class<`data.frame`>,1
+assertive.properties,assert_has_elements,-1,0,1,class<`function`>,1
+assertive.properties,assert_has_elements,-1,0,2,integer[],1
+assertive.properties,assert_has_elements,-1,0,3,list<integer[] | list<integer[]>>,1
+assertive.properties,assert_has_elements,0,0,0,class<`data.frame`>,1
+assertive.properties,assert_has_elements,0,0,1,class<`function`>,1
+assertive.properties,assert_has_elements,0,0,2,integer[],1
+assertive.properties,assert_has_elements,0,0,3,list<integer[] | list<integer[]>>,1
+assertive.properties,assert_has_elements,1,0,0,double,1
+assertive.properties,assert_has_elements,2,0,0,character,1
+assertive.properties,assert_has_names,-1,0,0,double[],1
+assertive.properties,assert_has_names,0,0,0,double[],1
+assertive.properties,assert_has_names,1,0,0,character,1
+assertive.properties,assert_has_rownames,-1,0,0,class<`data.frame`>,1
+assertive.properties,assert_has_rownames,0,0,0,class<`data.frame`>,1
+assertive.properties,assert_has_rownames,1,0,0,character,1
+assertive.properties,assert_has_rows,-1,0,0,class<`data.frame`>,1
+assertive.properties,assert_has_rows,0,0,0,class<`data.frame`>,1
+assertive.properties,assert_has_rows,1,0,0,character,1
+assertive.properties,assert_is_atomic,-1,0,0,character[],1
+assertive.properties,assert_is_atomic,-1,0,1,class<`array`>,1
+assertive.properties,assert_is_atomic,-1,0,2,class<`factor`>,1
+assertive.properties,assert_is_atomic,-1,0,3,class<`matrix`>,1
+assertive.properties,assert_is_atomic,-1,0,4,complex[],1
+assertive.properties,assert_is_atomic,-1,0,5,null,1
+assertive.properties,assert_is_atomic,-1,0,6,raw[],1
+assertive.properties,assert_is_atomic,0,0,0,character[],1
+assertive.properties,assert_is_atomic,0,0,1,class<`array`>,1
+assertive.properties,assert_is_atomic,0,0,2,class<`factor`>,1
+assertive.properties,assert_is_atomic,0,0,3,class<`matrix`>,1
+assertive.properties,assert_is_atomic,0,0,4,complex[],1
+assertive.properties,assert_is_atomic,0,0,5,null,1
+assertive.properties,assert_is_atomic,0,0,6,raw[],1
+assertive.properties,assert_is_atomic,1,0,0,character,1
+assertive.properties,assert_is_empty,-1,0,0,double[],1
+assertive.properties,assert_is_empty,-1,0,1,null,1
+assertive.properties,assert_is_empty,0,0,0,double[],1
+assertive.properties,assert_is_empty,0,0,1,null,1
+assertive.properties,assert_is_empty,1,0,0,character[],1
+assertive.properties,assert_is_empty,2,0,0,character,1
+assertive.properties,assert_is_monotonic_decreasing,-1,0,0,any,1
+assertive.properties,assert_is_monotonic_decreasing,0,0,0,double[],1
+assertive.properties,assert_is_monotonic_decreasing,1,0,0,logical,1
+assertive.properties,assert_is_monotonic_decreasing,2,0,0,character,1
+assertive.properties,assert_is_monotonic_increasing,-1,0,0,any,1
+assertive.properties,assert_is_monotonic_increasing,0,0,0,double[],1
+assertive.properties,assert_is_monotonic_increasing,1,0,0,logical,1
+assertive.properties,assert_is_monotonic_increasing,2,0,0,character,1
+assertive.properties,assert_is_nested,-1,0,0,list<double | list<integer[]>>,1
+assertive.properties,assert_is_nested,0,0,0,list<double | list<integer[]>>,1
+assertive.properties,assert_is_nested,1,0,0,character,1
+assertive.properties,assert_is_non_empty,-1,0,0,integer[],1
+assertive.properties,assert_is_non_empty,-1,0,1,null,1
+assertive.properties,assert_is_non_empty,0,0,0,integer[],1
+assertive.properties,assert_is_non_empty,0,0,1,null,1
+assertive.properties,assert_is_non_empty,1,0,0,character[],1
+assertive.properties,assert_is_non_empty,2,0,0,character,1
+assertive.properties,assert_is_non_nested,-1,0,0,double,1
+assertive.properties,assert_is_non_nested,-1,0,1,list<integer[]>,1
+assertive.properties,assert_is_non_nested,0,0,0,double,1
+assertive.properties,assert_is_non_nested,0,0,1,list<integer[]>,1
+assertive.properties,assert_is_non_nested,1,0,0,character,1
+assertive.properties,assert_is_not_null,-1,0,0,null,1
+assertive.properties,assert_is_not_null,0,0,0,null,1
+assertive.properties,assert_is_not_null,1,0,0,any,1
+assertive.properties,assert_is_null,-1,0,0,any,1
+assertive.properties,assert_is_null,0,0,0,double,1
+assertive.properties,assert_is_null,0,0,1,null,1
+assertive.properties,assert_is_null,1,0,0,character,1
+assertive.properties,assert_is_of_dimension,-1,0,0,class<`data.frame`>,1
+assertive.properties,assert_is_of_dimension,-1,0,1,list<integer[] | list<integer[]>>,1
+assertive.properties,assert_is_of_dimension,0,0,0,class<`data.frame`>,1
+assertive.properties,assert_is_of_dimension,0,0,1,list<integer[] | list<integer[]>>,1
+assertive.properties,assert_is_of_dimension,1,0,0,double[],1
+assertive.properties,assert_is_of_dimension,1,0,1,null,1
+assertive.properties,assert_is_of_dimension,2,0,0,character,1
+assertive.properties,assert_is_of_length,-1,0,0,class<`data.frame`>,1
+assertive.properties,assert_is_of_length,-1,0,1,class<`function`>,1
+assertive.properties,assert_is_of_length,-1,0,2,integer[],1
+assertive.properties,assert_is_of_length,-1,0,3,list<integer[] | list<integer[]>>,1
+assertive.properties,assert_is_of_length,0,0,0,class<`data.frame`>,1
+assertive.properties,assert_is_of_length,0,0,1,class<`function`>,1
+assertive.properties,assert_is_of_length,0,0,2,integer[],1
+assertive.properties,assert_is_of_length,0,0,3,list<integer[] | list<integer[]>>,1
+assertive.properties,assert_is_of_length,1,0,0,double,1
+assertive.properties,assert_is_of_length,2,0,0,character,1
+assertive.properties,assert_is_recursive,-1,0,0,class<`call`>,1
+assertive.properties,assert_is_recursive,-1,0,1,class<`data.frame`>,1
+assertive.properties,assert_is_recursive,-1,0,2,class<`formula`>,1
+assertive.properties,assert_is_recursive,-1,0,3,class<`function`>,1
+assertive.properties,assert_is_recursive,-1,0,4,expression,1
+assertive.properties,assert_is_recursive,-1,0,5,list<any>,1
+assertive.properties,assert_is_recursive,0,0,0,class<`call`>,1
+assertive.properties,assert_is_recursive,0,0,1,class<`data.frame`>,1
+assertive.properties,assert_is_recursive,0,0,2,class<`formula`>,1
+assertive.properties,assert_is_recursive,0,0,3,class<`function`>,1
+assertive.properties,assert_is_recursive,0,0,4,expression,1
+assertive.properties,assert_is_recursive,0,0,5,list<any>,1
+assertive.properties,assert_is_recursive,1,0,0,character,1
+assertive.properties,assert_is_scalar,-1,0,0,character,1
+assertive.properties,assert_is_scalar,-1,0,1,double,1
+assertive.properties,assert_is_scalar,-1,0,2,null,1
+assertive.properties,assert_is_scalar,0,0,0,character,1
+assertive.properties,assert_is_scalar,0,0,1,double,1
+assertive.properties,assert_is_scalar,0,0,2,null,1
+assertive.properties,assert_is_scalar,1,0,0,character[],1
+assertive.properties,assert_is_scalar,2,0,0,character,1
+assertive.properties,assert_is_unsorted,-1,0,0,any,1
+assertive.properties,assert_is_unsorted,0,0,0,double[],1
+assertive.properties,assert_is_unsorted,1,0,0,logical,1
+assertive.properties,assert_is_unsorted,2,0,0,logical,1
+assertive.properties,assert_is_unsorted,3,0,0,character,1
+assertive.properties,assert_is_vector,-1,0,0,character[],1
+assertive.properties,assert_is_vector,-1,0,1,complex[],1
+assertive.properties,assert_is_vector,-1,0,2,expression,1
+assertive.properties,assert_is_vector,-1,0,3,list<any>,1
+assertive.properties,assert_is_vector,-1,0,4,raw[],1
+assertive.properties,assert_is_vector,0,0,0,character[],1
+assertive.properties,assert_is_vector,0,0,1,complex[],1
+assertive.properties,assert_is_vector,0,0,2,expression,1
+assertive.properties,assert_is_vector,0,0,3,list<any>,1
+assertive.properties,assert_is_vector,0,0,4,raw[],1
+assertive.properties,assert_is_vector,1,0,0,character,1
+assertive.properties,check_n,-1,0,0,null,1
+assertive.properties,check_n,0,0,0,double[],1
+assertive.properties,DIM,-1,0,0,integer[],1
+assertive.properties,DIM,0,0,0,any,1
+assertive.properties,get_dim_string,-1,0,0,character,1
+assertive.properties,get_dim_string,0,0,0,integer[],1
+assertive.properties,get_dim_string,0,0,1,null,1
+assertive.properties,get_metric,-1,0,0,class<`function`>,1
+assertive.properties,get_metric,0,0,0,character,1
+assertive.properties,has_any_attributes,-1,0,0,logical,1
+assertive.properties,has_any_attributes,0,0,0,class<`matrix`>,1
+assertive.properties,has_any_attributes,1,0,0,any,1
+assertive.properties,has_attributes,-1,0,0,"class<`logical`, `vector_with_cause`>",1
+assertive.properties,has_attributes,-1,0,1,logical[],1
+assertive.properties,has_attributes,0,0,0,class<`data.frame`>,1
+assertive.properties,has_attributes,0,0,1,double,1
+assertive.properties,has_attributes,1,0,0,character[],1
+assertive.properties,has_attributes,2,0,0,any,1
+assertive.properties,has_dims,-1,0,0,"class<`logical`, `scalar_with_cause`>",1
+assertive.properties,has_dims,0,0,0,list<integer[] | list<integer[]>>,1
+assertive.properties,has_dims,1,0,0,character,1
+assertive.properties,has_elements,-1,0,0,logical,1
+assertive.properties,has_elements,-1,0,1,"class<`logical`, `scalar_with_cause`>",1
+assertive.properties,has_elements,0,0,0,integer[],1
+assertive.properties,has_elements,0,0,1,class<`function`>,1
+assertive.properties,has_elements,0,0,2,list<integer[]>,1
+assertive.properties,has_elements,0,0,3,class<`data.frame`>,1
+assertive.properties,has_elements,0,0,4,list<integer[] | list<integer[]>>,1
+assertive.properties,has_elements,1,0,0,double,1
+assertive.properties,has_elements,2,0,0,any,1
+assertive.properties,has_no_attributes,-1,0,0,"class<`logical`, `scalar_with_cause`>",1
+assertive.properties,has_no_attributes,0,0,0,class<`data.frame`>,1
+assertive.properties,has_no_attributes,1,0,0,character,1
+assertive.properties,has_no_duplicates,-1,0,0,"class<`logical`, `scalar_with_cause`>",1
+assertive.properties,has_no_duplicates,0,0,0,integer[],1
+assertive.properties,has_no_duplicates,1,0,0,character,1
+assertive.properties,has_slot,-1,0,0,"class<`logical`, `scalar_with_cause`>",1
+assertive.properties,has_slot,-1,0,1,logical,1
+assertive.properties,has_slot,0,0,0,class<`numbers`>,1
+assertive.properties,has_slot,0,0,1,integer[],1
+assertive.properties,has_slot,1,0,0,character,1
+assertive.properties,has_slot,2,0,0,any,1
+assertive.properties,have_same_dims,-1,0,0,"class<`logical`, `scalar_with_cause`>",1
+assertive.properties,have_same_dims,-1,0,1,logical,1
+assertive.properties,have_same_dims,0,0,0,integer[],1
+assertive.properties,have_same_dims,0,0,1,class<`matrix`>,1
+assertive.properties,have_same_dims,1,0,0,class<`matrix`>,1
+assertive.properties,have_same_dims,1,0,1,class<`data.frame`>,1
+assertive.properties,have_same_dims,2,0,0,any,1
+assertive.properties,have_same_dims,3,0,0,any,1
+assertive.properties,is_atomic,-1,0,0,"class<`logical`, `scalar_with_cause`>",1
+assertive.properties,is_atomic,-1,0,1,logical,1
+assertive.properties,is_atomic,0,0,0,class<`name`>,1
+assertive.properties,is_atomic,0,0,1,character[],1
+assertive.properties,is_atomic,0,0,2,class<`array`>,1
+assertive.properties,is_atomic,0,0,3,class<`factor`>,1
+assertive.properties,is_atomic,0,0,4,class<`matrix`>,1
+assertive.properties,is_atomic,0,0,5,complex[],1
+assertive.properties,is_atomic,0,0,6,null,1
+assertive.properties,is_atomic,0,0,7,raw[],1
+assertive.properties,is_atomic,1,0,0,character,1
+assertive.properties,is_empty,-1,0,0,"class<`logical`, `scalar_with_cause`>",1
+assertive.properties,is_empty,0,0,0,character[],1
+assertive.properties,is_empty,0,0,1,list<integer[]>,1
+assertive.properties,is_empty,1,0,0,character[],1
+assertive.properties,is_empty,2,0,0,character,1
+assertive.properties,is_monotonic_decreasing,-1,0,0,"class<`logical`, `scalar_with_cause`>",1
+assertive.properties,is_monotonic_decreasing,0,0,0,double[],1
+assertive.properties,is_monotonic_decreasing,1,0,0,logical,1
+assertive.properties,is_monotonic_decreasing,2,0,0,character,1
+assertive.properties,is_monotonic_increasing,-1,0,0,"class<`logical`, `scalar_with_cause`>",1
+assertive.properties,is_monotonic_increasing,0,0,0,"class<`POSIXct`, `POSIXt`>",1
+assertive.properties,is_monotonic_increasing,0,0,1,double[],1
+assertive.properties,is_monotonic_increasing,1,0,0,logical,1
+assertive.properties,is_monotonic_increasing,2,0,0,character,1
+assertive.properties,is_non_empty,-1,0,0,logical,1
+assertive.properties,is_non_empty,0,0,0,integer[],1
+assertive.properties,is_non_empty,1,0,0,character[],1
+assertive.properties,is_non_empty,2,0,0,any,1
+assertive.properties,is_not_null,-1,0,0,"class<`logical`, `scalar_with_cause`>",1
+assertive.properties,is_not_null,-1,0,1,logical,1
+assertive.properties,is_not_null,0,0,0,null,1
+assertive.properties,is_not_null,0,0,1,character[],1
+assertive.properties,is_not_null,0,0,2,double[],1
+assertive.properties,is_not_null,1,0,0,any,1
+assertive.properties,is_null,-1,0,0,"class<`logical`, `scalar_with_cause`>",1
+assertive.properties,is_null,-1,0,1,logical,1
+assertive.properties,is_null,0,0,0,double[],1
+assertive.properties,is_null,0,0,1,null,1
+assertive.properties,is_null,1,0,0,any,1
+assertive.properties,is_of_length,-1,0,0,logical,1
+assertive.properties,is_of_length,-1,0,1,"class<`logical`, `scalar_with_cause`>",1
+assertive.properties,is_of_length,0,0,0,null,1
+assertive.properties,is_of_length,0,0,1,character,1
+assertive.properties,is_of_length,0,0,2,class<`function`>,1
+assertive.properties,is_of_length,0,0,3,double[],1
+assertive.properties,is_of_length,0,0,4,list<integer[]>,1
+assertive.properties,is_of_length,0,0,5,class<`data.frame`>,1
+assertive.properties,is_of_length,0,0,6,list<integer[] | list<integer[]>>,1
+assertive.properties,is_of_length,1,0,0,double,1
+assertive.properties,is_of_length,2,0,0,any,1
+assertive.properties,is_recursive,-1,0,0,"class<`logical`, `scalar_with_cause`>",1
+assertive.properties,is_recursive,-1,0,1,logical,1
+assertive.properties,is_recursive,0,0,0,class<`name`>,1
+assertive.properties,is_recursive,0,0,1,class<`call`>,1
+assertive.properties,is_recursive,0,0,2,class<`data.frame`>,1
+assertive.properties,is_recursive,0,0,3,class<`formula`>,1
+assertive.properties,is_recursive,0,0,4,class<`function`>,1
+assertive.properties,is_recursive,0,0,5,expression,1
+assertive.properties,is_recursive,0,0,6,list<any>,1
+assertive.properties,is_recursive,1,0,0,any,1
+assertive.properties,is_scalar,-1,0,0,"class<`logical`, `scalar_with_cause`>",1
+assertive.properties,is_scalar,-1,0,1,logical,1
+assertive.properties,is_scalar,0,0,0,class<`function`>,1
+assertive.properties,is_scalar,0,0,1,list<integer[]>,1
+assertive.properties,is_scalar,0,0,2,character,1
+assertive.properties,is_scalar,0,0,3,double,1
+assertive.properties,is_scalar,0,0,4,null,1
+assertive.properties,is_scalar,1,0,0,character[],1
+assertive.properties,is_scalar,2,0,0,any,1
+assertive.properties,n_elements,-1,0,0,integer,1
+assertive.properties,n_elements,0,0,0,any,1
+assertive.types,assert_all_are_classes,-1,0,0,character[],1
+assertive.types,assert_all_are_classes,0,0,0,character[],1
+assertive.types,assert_all_are_classes,1,0,0,character,1
+assertive.types,assert_is_a_bool,-1,0,0,any,1
+assertive.types,assert_is_a_bool,0,0,0,logical[],1
+assertive.types,assert_is_a_bool,0,0,1,null,1
+assertive.types,assert_is_a_bool,1,0,0,character,1
+assertive.types,assert_is_a_complex,-1,0,0,any,1
+assertive.types,assert_is_a_complex,0,0,0,complex[],1
+assertive.types,assert_is_a_complex,0,0,1,null,1
+assertive.types,assert_is_a_complex,1,0,0,character,1
+assertive.types,assert_is_a_double,-1,0,0,double,1
+assertive.types,assert_is_a_double,0,0,0,double,1
+assertive.types,assert_is_a_double,1,0,0,character,1
+assertive.types,assert_is_all_of,-1,0,0,integer[],1
+assertive.types,assert_is_all_of,0,0,0,integer[],1
+assertive.types,assert_is_all_of,1,0,0,character[],1
+assertive.types,assert_is_all_of,2,0,0,character,1
+assertive.types,assert_is_an_integer,-1,0,0,any,1
+assertive.types,assert_is_an_integer,0,0,0,integer[],1
+assertive.types,assert_is_an_integer,1,0,0,character,1
+assertive.types,assert_is_a_number,-1,0,0,any,1
+assertive.types,assert_is_a_number,0,0,0,double[],1
+assertive.types,assert_is_a_number,0,0,1,null,1
+assertive.types,assert_is_a_number,1,0,0,character,1
+assertive.types,assert_is_any_of,-1,0,0,any,1
+assertive.types,assert_is_any_of,0,0,0,integer[],1
+assertive.types,assert_is_any_of,1,0,0,character[],1
+assertive.types,assert_is_any_of,2,0,0,character,1
+assertive.types,assert_is_a_raw,-1,0,0,any,1
+assertive.types,assert_is_a_raw,0,0,0,raw[],1
+assertive.types,assert_is_a_raw,1,0,0,character,1
+assertive.types,assert_is_array,-1,0,0,class<`array`>,1
+assertive.types,assert_is_array,-1,0,1,class<`matrix`>,1
+assertive.types,assert_is_array,0,0,0,class<`array`>,1
+assertive.types,assert_is_array,0,0,1,class<`matrix`>,1
+assertive.types,assert_is_array,1,0,0,character,1
+assertive.types,assert_is_builtin_function,-1,0,0,any,1
+assertive.types,assert_is_builtin_function,0,0,0,character,1
+assertive.types,assert_is_builtin_function,0,0,1,class<`function`>,1
+assertive.types,assert_is_builtin_function,1,0,0,character,1
+assertive.types,assert_is_call,-1,0,0,class<`call`>,1
+assertive.types,assert_is_call,0,0,0,class<`call`>,1
+assertive.types,assert_is_call,1,0,0,character,1
+assertive.types,assert_is_character,-1,0,0,any,1
+assertive.types,assert_is_character,0,0,0,character[],1
+assertive.types,assert_is_character,0,0,1,class<`factor`>,1
+assertive.types,assert_is_character,1,0,0,character,1
+assertive.types,assert_is_complex,-1,0,0,any,1
+assertive.types,assert_is_complex,0,0,0,complex[],1
+assertive.types,assert_is_complex,1,0,0,character,1
+assertive.types,assert_is_data.frame,-1,0,0,class<`data.frame`>,1
+assertive.types,assert_is_data.frame,-1,0,1,"class<`data.frame`, `groupedData`, `nfGroupedData`, `nfnGroupedData`>",1
+assertive.types,assert_is_data.frame,0,0,0,class<`data.frame`>,1
+assertive.types,assert_is_data.frame,0,0,1,"class<`data.frame`, `groupedData`, `nfGroupedData`, `nfnGroupedData`>",1
+assertive.types,assert_is_data.frame,1,0,0,character,1
+assertive.types,assert_is_data.table,-1,0,0,any,1
+assertive.types,assert_is_data.table,0,0,0,"class<`data.frame`, `data.table`>",1
+assertive.types,assert_is_data.table,0,0,1,list<double>,1
+assertive.types,assert_is_data.table,1,0,0,character,1
+assertive.types,assert_is_date,-1,0,0,any,1
+assertive.types,assert_is_date,0,0,0,"class<`POSIXct`, `POSIXt`>",1
+assertive.types,assert_is_date,1,0,0,character,1
+assertive.types,assert_is_double,-1,0,0,any,1
+assertive.types,assert_is_double,0,0,0,integer[],1
+assertive.types,assert_is_double,1,0,0,character,1
+assertive.types,assert_is_environment,-1,0,0,environment,1
+assertive.types,assert_is_environment,0,0,0,environment,1
+assertive.types,assert_is_environment,1,0,0,character,1
+assertive.types,assert_is_expression,-1,0,0,expression,1
+assertive.types,assert_is_expression,0,0,0,expression,1
+assertive.types,assert_is_expression,1,0,0,character,1
+assertive.types,assert_is_externalptr,-1,0,0,any,1
+assertive.types,assert_is_externalptr,0,0,0,externalptr,1
+assertive.types,assert_is_externalptr,0,0,1,null,1
+assertive.types,assert_is_externalptr,1,0,0,character,1
+assertive.types,assert_is_factor,-1,0,0,class<`factor`>,1
+assertive.types,assert_is_factor,0,0,0,class<`factor`>,1
+assertive.types,assert_is_factor,1,0,0,character,1
+assertive.types,assert_is_function,-1,0,0,class<`function`>,1
+assertive.types,assert_is_function,0,0,0,class<`function`>,1
+assertive.types,assert_is_function,1,0,0,character,1
+assertive.types,assert_is_inherited_from,-1,0,0,any,1
+assertive.types,assert_is_inherited_from,0,0,0,"class<`bar`, `foo`>",1
+assertive.types,assert_is_inherited_from,1,0,0,character[],1
+assertive.types,assert_is_inherited_from,2,0,0,any,1
+assertive.types,assert_is_integer,-1,0,0,any,1
+assertive.types,assert_is_integer,0,0,0,double[],1
+assertive.types,assert_is_integer,1,0,0,character,1
+assertive.types,assert_is_internal_function,-1,0,0,any,1
+assertive.types,assert_is_internal_function,0,0,0,character,1
+assertive.types,assert_is_internal_function,0,0,1,class<`function`>,1
+assertive.types,assert_is_internal_function,1,0,0,character,1
+assertive.types,assert_is_language,-1,0,0,any,1
+assertive.types,assert_is_language,0,0,0,class<`call`>,1
+assertive.types,assert_is_language,0,0,1,class<`name`>,1
+assertive.types,assert_is_language,0,0,2,expression,1
+assertive.types,assert_is_language,0,0,3,class<`function`>,1
+assertive.types,assert_is_language,1,0,0,character,1
+assertive.types,assert_is_list,-1,0,0,any,1
+assertive.types,assert_is_list,0,0,0,integer[],1
+assertive.types,assert_is_list,0,0,1,list<double>,1
+assertive.types,assert_is_list,1,0,0,character,1
+assertive.types,assert_is_logical,-1,0,0,any,1
+assertive.types,assert_is_logical,0,0,0,double,1
+assertive.types,assert_is_logical,0,0,1,logical[],1
+assertive.types,assert_is_logical,1,0,0,character,1
+assertive.types,assert_is_matrix,-1,0,0,any,1
+assertive.types,assert_is_matrix,0,0,0,class<`matrix`>,1
+assertive.types,assert_is_matrix,0,0,1,class<`array`>,1
+assertive.types,assert_is_matrix,1,0,0,character,1
+assertive.types,assert_is_name,-1,0,0,class<`name`>,1
+assertive.types,assert_is_name,0,0,0,class<`name`>,1
+assertive.types,assert_is_name,1,0,0,character,1
+assertive.types,assert_is_numeric,-1,0,0,any,1
+assertive.types,assert_is_numeric,0,0,0,integer[],1
+assertive.types,assert_is_numeric,1,0,0,character,1
+assertive.types,assert_is_pairlist,-1,0,0,any,1
+assertive.types,assert_is_pairlist,0,0,0,list<any>,1
+assertive.types,assert_is_pairlist,0,0,1,pairlist,1
+assertive.types,assert_is_pairlist,1,0,0,character,1
+assertive.types,assert_is_qr,-1,0,0,class<`qr`>,1
+assertive.types,assert_is_qr,0,0,0,class<`qr`>,1
+assertive.types,assert_is_qr,1,0,0,character,1
+assertive.types,assert_is_raster,-1,0,0,class<`raster`>,1
+assertive.types,assert_is_raster,0,0,0,class<`raster`>,1
+assertive.types,assert_is_raster,1,0,0,character,1
+assertive.types,assert_is_raw,-1,0,0,any,1
+assertive.types,assert_is_raw,0,0,0,logical[],1
+assertive.types,assert_is_raw,0,0,1,raw[],1
+assertive.types,assert_is_raw,1,0,0,character,1
+assertive.types,assert_is_relistable,-1,0,0,any,1
+assertive.types,assert_is_relistable,0,0,0,"class<`list`, `relistable`>",1
+assertive.types,assert_is_relistable,0,0,1,list<double>,1
+assertive.types,assert_is_relistable,1,0,0,character,1
+assertive.types,assert_is_s3_primitive_generic,-1,0,0,any,1
+assertive.types,assert_is_s3_primitive_generic,0,0,0,class<`function`>,1
+assertive.types,assert_is_s3_primitive_generic,1,0,0,character,1
+assertive.types,assert_is_s4,-1,0,0,any,1
+assertive.types,assert_is_s4,0,0,0,class<`classRepresentation`>,1
+assertive.types,assert_is_s4,0,0,1,integer[],1
+assertive.types,assert_is_s4,1,0,0,character,1
+assertive.types,assert_is_s4_group_generic,-1,0,0,any,1
+assertive.types,assert_is_s4_group_generic,0,0,0,class<`function`>,1
+assertive.types,assert_is_s4_group_generic,1,0,0,character,1
+assertive.types,assert_is_simple_error,-1,0,0,any,1
+assertive.types,assert_is_simple_error,0,0,0,class<`try-error`>,1
+assertive.types,assert_is_simple_error,1,0,0,character,1
+assertive.types,assert_is_table,-1,0,0,class<`table`>,1
+assertive.types,assert_is_table,0,0,0,class<`table`>,1
+assertive.types,assert_is_table,1,0,0,character,1
+assertive.types,assert_is_tbl,-1,0,0,any,1
+assertive.types,assert_is_tbl,0,0,0,class<`data.frame`>,1
+assertive.types,assert_is_tbl,1,0,0,character,1
+assertive.types,assert_is_tbl_df,-1,0,0,"class<`data.frame`, `tbl`, `tbl_df`>",1
+assertive.types,assert_is_tbl_df,0,0,0,"class<`data.frame`, `tbl`, `tbl_df`>",1
+assertive.types,assert_is_tbl_df,1,0,0,character,1
+assertive.types,assert_is_try_error,-1,0,0,any,1
+assertive.types,assert_is_try_error,0,0,0,"class<`condition`, `error`, `simpleError`>",1
+assertive.types,assert_is_try_error,1,0,0,character,1
+assertive.types,assert_is_ts,-1,0,0,class<`ts`>,1
+assertive.types,assert_is_ts,0,0,0,class<`ts`>,1
+assertive.types,assert_is_ts,1,0,0,character,1
+assertive.types,%calls%,-1,0,0,logical,1
+assertive.types,%calls%,0,0,0,class<`function`>,1
+assertive.types,%calls%,1,0,0,character,1
+assertive.types,%fn_in%,-1,0,0,logical,1
+assertive.types,%fn_in%,0,0,0,class<`function`>,1
+assertive.types,%fn_in%,1,0,0,list<class<`function`>>,1
+assertive.types,is_builtin_function,-1,0,0,logical,1
+assertive.types,is_builtin_function,-1,0,1,"class<`logical`, `scalar_with_cause`>",1
+assertive.types,is_builtin_function,0,0,0,class<`function`>,1
+assertive.types,is_builtin_function,0,0,1,character,1
+assertive.types,is_builtin_function,1,0,0,any,1
+assertive.types,is_closure_function,-1,0,0,logical,1
+assertive.types,is_closure_function,0,0,0,class<`function`>,1
+assertive.types,is_closure_function,1,0,0,any,1
+assertive.types,is_complex,-1,0,0,logical,1
+assertive.types,is_complex,-1,0,1,"class<`logical`, `scalar_with_cause`>",1
+assertive.types,is_complex,0,0,0,complex[],1
+assertive.types,is_complex,0,0,1,null,1
+assertive.types,is_complex,1,0,0,any,1
+assertive.types,is_data.frame,-1,0,0,"class<`logical`, `scalar_with_cause`>",1
+assertive.types,is_data.frame,-1,0,1,logical,1
+assertive.types,is_data.frame,0,0,0,list<double>,1
+assertive.types,is_data.frame,0,0,1,class<`data.frame`>,1
+assertive.types,is_data.frame,0,0,2,"class<`data.frame`, `data.table`>",1
+assertive.types,is_data.frame,0,0,3,"class<`data.frame`, `tbl`, `tbl_df`>",1
+assertive.types,is_data.frame,1,0,0,any,1
+assertive.types,is_date,-1,0,0,logical,1
+assertive.types,is_date,-1,0,1,"class<`logical`, `scalar_with_cause`>",1
+assertive.types,is_date,0,0,0,class<`Date`>,1
+assertive.types,is_date,0,0,1,"class<`POSIXct`, `POSIXt`>",1
+assertive.types,is_date,1,0,0,any,1
+assertive.types,is_double,-1,0,0,logical,1
+assertive.types,is_double,-1,0,1,"class<`logical`, `scalar_with_cause`>",1
+assertive.types,is_double,0,0,0,double,1
+assertive.types,is_double,0,0,1,integer[],1
+assertive.types,is_double,1,0,0,any,1
+assertive.types,is_error,-1,0,0,"class<`logical`, `scalar_with_cause`>",1
+assertive.types,is_error,-1,0,1,logical,1
+assertive.types,is_error,0,0,0,class<`try-error`>,1
+assertive.types,is_error,0,0,1,"class<`condition`, `error`, `simpleError`>",1
+assertive.types,is_error,1,0,0,any,1
+assertive.types,is_formula,-1,0,0,logical,1
+assertive.types,is_formula,0,0,0,class<`formula`>,1
+assertive.types,is_formula,1,0,0,any,1
+assertive.types,is_function,-1,0,0,"class<`logical`, `scalar_with_cause`>",1
+assertive.types,is_function,-1,0,1,logical,1
+assertive.types,is_function,0,0,0,character,1
+assertive.types,is_function,0,0,1,class<`function`>,1
+assertive.types,is_function,1,0,0,any,1
+assertive.types,is_integer,-1,0,0,logical,1
+assertive.types,is_integer,-1,0,1,"class<`logical`, `scalar_with_cause`>",1
+assertive.types,is_integer,0,0,0,double[],1
+assertive.types,is_integer,1,0,0,any,1
+assertive.types,is_internal_function,-1,0,0,logical,1
+assertive.types,is_internal_function,-1,0,1,"class<`logical`, `scalar_with_cause`>",1
+assertive.types,is_internal_function,0,0,0,class<`function`>,1
+assertive.types,is_internal_function,0,0,1,character,1
+assertive.types,is_internal_function,1,0,0,any,1
+assertive.types,is_logical,-1,0,0,logical,1
+assertive.types,is_logical,-1,0,1,"class<`logical`, `scalar_with_cause`>",1
+assertive.types,is_logical,0,0,0,logical[],1
+assertive.types,is_logical,0,0,1,null,1
+assertive.types,is_logical,0,0,2,double,1
+assertive.types,is_logical,1,0,0,any,1
+assertive.types,is_message,-1,0,0,logical,1
+assertive.types,is_message,0,0,0,"class<`condition`, `message`, `simpleMessage`>",1
+assertive.types,is_message,1,0,0,any,1
+assertive.types,is_numeric,-1,0,0,logical,1
+assertive.types,is_numeric,-1,0,1,"class<`logical`, `scalar_with_cause`>",1
+assertive.types,is_numeric,0,0,0,double[],1
+assertive.types,is_numeric,0,0,1,null,1
+assertive.types,is_numeric,1,0,0,any,1
+assertive.types,is_one_sided_formula,-1,0,0,logical,1
+assertive.types,is_one_sided_formula,0,0,0,class<`formula`>,1
+assertive.types,is_one_sided_formula,1,0,0,any,1
+assertive.types,is_posixct,-1,0,0,logical,1
+assertive.types,is_posixct,0,0,0,"class<`POSIXct`, `POSIXt`>",1
+assertive.types,is_posixct,1,0,0,any,1
+assertive.types,is_raw,-1,0,0,logical,1
+assertive.types,is_raw,-1,0,1,"class<`logical`, `scalar_with_cause`>",1
+assertive.types,is_raw,0,0,0,raw[],1
+assertive.types,is_raw,0,0,1,logical[],1
+assertive.types,is_raw,1,0,0,any,1
+assertive.types,is_s3_generic,-1,0,0,logical,1
+assertive.types,is_s3_generic,0,0,0,class<`function`>,1
+assertive.types,is_s3_generic,1,0,0,any,1
+assertive.types,is_s3_group_generic,-1,0,0,logical,1
+assertive.types,is_s3_group_generic,0,0,0,class<`function`>,1
+assertive.types,is_s3_group_generic,1,0,0,any,1
+assertive.types,is_s3_internal_generic,-1,0,0,logical,1
+assertive.types,is_s3_internal_generic,0,0,0,class<`function`>,1
+assertive.types,is_s3_internal_generic,1,0,0,any,1
+assertive.types,is_s3_method,-1,0,0,logical,1
+assertive.types,is_s3_method,0,0,0,class<`function`>,1
+assertive.types,is_s3_method,1,0,0,any,1
+assertive.types,is_s3_primitive_generic,-1,0,0,logical,1
+assertive.types,is_s3_primitive_generic,-1,0,1,"class<`logical`, `scalar_with_cause`>",1
+assertive.types,is_s3_primitive_generic,0,0,0,class<`function`>,1
+assertive.types,is_s3_primitive_generic,1,0,0,any,1
+assertive.types,is_s4_group_generic,-1,0,0,logical,1
+assertive.types,is_s4_group_generic,-1,0,1,"class<`logical`, `scalar_with_cause`>",1
+assertive.types,is_s4_group_generic,0,0,0,class<`function`>,1
+assertive.types,is_s4_group_generic,1,0,0,character[],1
+assertive.types,is_s4_group_generic,2,0,0,any,1
+assertive.types,is_simple_error,-1,0,0,logical,1
+assertive.types,is_simple_error,-1,0,1,"class<`logical`, `scalar_with_cause`>",1
+assertive.types,is_simple_error,0,0,0,"class<`condition`, `error`, `simpleError`>",1
+assertive.types,is_simple_error,0,0,1,class<`try-error`>,1
+assertive.types,is_simple_error,1,0,0,any,1
+assertive.types,is_simple_message,-1,0,0,logical,1
+assertive.types,is_simple_message,0,0,0,"class<`condition`, `message`, `simpleMessage`>",1
+assertive.types,is_simple_message,1,0,0,any,1
+assertive.types,is_simple_warning,-1,0,0,logical,1
+assertive.types,is_simple_warning,0,0,0,"class<`condition`, `simpleWarning`, `warning`>",1
+assertive.types,is_simple_warning,1,0,0,any,1
+assertive.types,is_special_function,-1,0,0,logical,1
+assertive.types,is_special_function,0,0,0,class<`function`>,1
+assertive.types,is_special_function,1,0,0,any,1
+assertive.types,is_tbl,-1,0,0,logical,1
+assertive.types,is_tbl,-1,0,1,"class<`logical`, `scalar_with_cause`>",1
+assertive.types,is_tbl,0,0,0,"class<`data.frame`, `tbl`, `tbl_df`>",1
+assertive.types,is_tbl,0,0,1,class<`data.frame`>,1
+assertive.types,is_tbl,1,0,0,any,1
+assertive.types,is_try_error,-1,0,0,logical,1
+assertive.types,is_try_error,-1,0,1,"class<`logical`, `scalar_with_cause`>",1
+assertive.types,is_try_error,0,0,0,class<`try-error`>,1
+assertive.types,is_try_error,0,0,1,"class<`condition`, `error`, `simpleError`>",1
+assertive.types,is_try_error,1,0,0,any,1
+assertive.types,is_two_sided_formula,-1,0,0,logical,1
+assertive.types,is_two_sided_formula,0,0,0,class<`formula`>,1
+assertive.types,is_two_sided_formula,1,0,0,any,1
+assertive.types,is_typeof_function,-1,0,0,"class<`logical`, `scalar_with_cause`>",1
+assertive.types,is_typeof_function,-1,0,1,logical,1
+assertive.types,is_typeof_function,0,0,0,character,1
+assertive.types,is_typeof_function,0,0,1,class<`function`>,1
+assertive.types,is_typeof_function,1,0,0,character,1
+assertive.types,is_typeof_function,2,0,0,any,1
+assertive.types,is_warning,-1,0,0,logical,1
+assertive.types,is_warning,0,0,0,"class<`condition`, `simpleWarning`, `warning`>",1
+assertive.types,is_warning,1,0,0,any,1
+assertthat,%||%,-1,0,0,class<`function`>,1
+assertthat,%||%,-1,0,1,integer[],1
+assertthat,%||%,-1,0,2,null,1
+assertthat,%||%,0,0,0,class<`function`>,1
+assertthat,%||%,0,0,1,null,1
+assertthat,%||%,0,0,2,integer[],1
+assertthat,%||%,1,0,0,any,1
+assertthat,are_equal,-1,0,0,logical,1
+assertthat,are_equal,0,0,0,double,1
+assertthat,are_equal,1,0,0,double,1
+assertthat,are_equal,2,0,0,...,1
+assertthat,assertError,-1,0,0,"class<`assertError`, `condition`, `error`, `simpleError`>",1
+assertthat,assertError,0,0,0,character,1
+assertthat,assertError,1,0,0,null,1
+assertthat,assert_that,-1,0,0,any,1
+assertthat,assert_that,0,0,0,...,1
+assertthat,assert_that,1,0,0,environment,1
+assertthat,assert_that,2,0,0,null,1
+assertthat,check_result,-1,0,0,logical,1
+assertthat,check_result,0,0,0,logical,1
+assertthat,get_message,-1,0,0,character,1
+assertthat,get_message,0,0,0,logical,1
+assertthat,get_message,1,0,0,class<`call`>,1
+assertthat,get_message,2,0,0,any,1
+assertthat,%has_args%,-1,0,0,logical,1
+assertthat,%has_args%,0,0,0,class<`function`>,1
+assertthat,%has_args%,1,0,0,character,1
+assertthat,has_args,-1,0,0,logical,1
+assertthat,has_args,0,0,0,class<`function`>,1
+assertthat,has_args,1,0,0,character,1
+assertthat,has_args,2,0,0,logical,1
+assertthat,%has_attr%,-1,0,0,logical,1
+assertthat,%has_attr%,0,0,0,double,1
+assertthat,%has_attr%,0,0,1,class<`function`>,1
+assertthat,%has_attr%,1,0,0,character,1
+assertthat,has_attr,-1,0,0,logical,1
+assertthat,has_attr,0,0,0,double,1
+assertthat,has_attr,0,0,1,class<`function`>,1
+assertthat,has_attr,1,0,0,character,1
+assertthat,%has_name%,-1,0,0,logical,1
+assertthat,%has_name%,0,0,0,list<double>,1
+assertthat,%has_name%,1,0,0,character,1
+assertthat,is.count,-1,0,0,logical,1
+assertthat,is.count,0,0,0,character,1
+assertthat,is.count,0,0,1,double,1
+assertthat,is.count,0,0,2,integer[],1
+assertthat,is.date,-1,0,0,logical,1
+assertthat,is.date,0,0,0,class<`Date`>,1
+assertthat,is.dir,-1,0,0,any,1
+assertthat,is.dir,0,0,0,character,1
+assertthat,is.dir,0,0,1,double,1
+assertthat,is.error,-1,0,0,logical,1
+assertthat,is.error,0,0,0,class<`try-error`>,1
+assertthat,is.flag,-1,0,0,logical,1
+assertthat,is.flag,0,0,0,character,1
+assertthat,is.flag,0,0,1,integer[],1
+assertthat,is.integerish,-1,0,0,logical,1
+assertthat,is.integerish,0,0,0,character,1
+assertthat,is.integerish,0,0,1,double,1
+assertthat,is.number,-1,0,0,logical,1
+assertthat,is.number,0,0,0,double,1
+assertthat,is.number,0,0,1,integer[],1
+assertthat,is.readable,-1,0,0,any,1
+assertthat,is.readable,0,0,0,character,1
+assertthat,is.scalar,-1,0,0,logical,1
+assertthat,is.scalar,0,0,0,character,1
+assertthat,is.scalar,0,0,1,integer[],1
+assertthat,is.string,-1,0,0,logical,1
+assertthat,is.string,0,0,0,character[],1
+assertthat,is.string,0,0,1,double,1
+assertthat,is.string,0,0,2,integer[],1
+assertthat,is.time,-1,0,0,logical,1
+assertthat,is.time,0,0,0,"class<`POSIXct`, `POSIXt`>",1
+assertthat,is.writeable,-1,0,0,logical,1
+assertthat,is.writeable,0,0,0,character,1
+assertthat,noNA,-1,0,0,logical,1
+assertthat,noNA,0,0,0,character,1
+assertthat,noNA,0,0,1,^integer[],1
+assertthat,not_empty,-1,0,0,logical,1
+assertthat,not_empty,0,0,0,class<`data.frame`>,1
+assertthat,not_empty,0,0,1,double[],1
+assertthat,on_failure,-1,0,0,class<`function`>,1
+assertthat,on_failure,-1,0,1,null,1
+assertthat,on_failure,0,0,0,class<`function`>,1
+assertthat,on_failure<-,-1,0,0,class<`function`>,1
+assertthat,on_failure<-,0,0,0,class<`function`>,1
+assertthat,on_failure<-,1,0,0,class<`function`>,1
+assertthat,see_if,-1,0,0,logical,1
+assertthat,see_if,0,0,0,...,1
+assertthat,see_if,1,0,0,environment,1
+assertthat,see_if,2,0,0,any,1
+assertthat,validate_that,-1,0,0,character,1
+assertthat,validate_that,-1,0,1,logical,1
+assertthat,validate_that,0,0,0,...,1
+assertthat,validate_that,1,0,0,environment,1
+assertthat,validate_that,2,0,0,null,1
+attempt,attempt,-1,0,0,class<`try-error`>,1
+attempt,attempt,-1,0,1,double,1
+attempt,attempt,0,0,0,any,1
+attempt,attempt,1,0,0,character,1
+attempt,attempt,1,0,1,null,1
+attempt,attempt,2,0,0,logical,1
+attempt,attempt,3,0,0,logical,1
+attempt,if_all,-1,0,0,character[],1
+attempt,if_all,0,0,0,integer[],1
+attempt,if_all,1,0,0,class<`formula`>,1
+attempt,if_all,2,0,0,class<`formula`>,1
+attempt,if_any,-1,0,0,character[],1
+attempt,if_any,0,0,0,integer[],1
+attempt,if_any,1,0,0,class<`function`>,1
+attempt,if_any,2,0,0,class<`formula`>,1
+attempt,if_else,-1,0,0,character,1
+attempt,if_else,0,0,0,double,1
+attempt,if_else,1,0,0,class<`function`>,1
+attempt,if_else,2,0,0,class<`formula`>,1
+attempt,if_else,3,0,0,any,1
+attempt,if_none,-1,0,0,double[],1
+attempt,if_none,-1,0,1,null,1
+attempt,if_none,0,0,0,integer[],1
+attempt,if_none,1,0,0,class<`function`>,1
+attempt,if_none,2,0,0,any,1
+attempt,if_not,-1,0,0,character,1
+attempt,if_not,0,0,0,double,1
+attempt,if_not,1,0,0,class<`function`>,1
+attempt,if_not,2,0,0,class<`formula`>,1
+attempt,if_then,-1,0,0,character,1
+attempt,if_then,0,0,0,double,1
+attempt,if_then,1,0,0,class<`function`>,1
+attempt,if_then,2,0,0,class<`formula`>,1
+attempt,is_try_error,-1,0,0,logical,1
+attempt,is_try_error,0,0,0,class<`try-error`>,1
+attempt,silent_attempt,-1,0,0,class<`try-error`>,1
+attempt,silent_attempt,-1,0,1,null,1
+attempt,silent_attempt,0,0,0,...,1
+attempt,silently,-1,0,0,class<`function`>,1
+attempt,silently,0,0,0,class<`function`>,1
+attempt,stop_if,-1,0,0,any,1
+attempt,stop_if,0,0,0,double,1
+attempt,stop_if,1,0,0,class<`function`>,1
+attempt,stop_if,2,0,0,null,1
+attempt,surely,-1,0,0,class<`function`>,1
+attempt,surely,0,0,0,class<`function`>,1
+attempt,try_catch,-1,0,0,any,1
+attempt,try_catch,0,0,0,any,1
+attempt,try_catch,1,0,0,class<`formula`>,1
+attempt,try_catch,1,0,1,class<`function`>,1
+attempt,try_catch,2,0,0,class<`formula`>,1
+attempt,try_catch,2,0,1,class<`function`>,1
+attempt,try_catch,3,0,0,null,1
+attempt,with_message,-1,0,0,class<`function`>,1
+attempt,with_message,0,0,0,class<`function`>,1
+attempt,with_message,1,0,0,character,1
+attempt,without_warning,-1,0,0,class<`function`>,1
+attempt,without_warning,0,0,0,class<`function`>,1
+attempt,with_warning,-1,0,0,class<`function`>,1
+attempt,with_warning,0,0,0,class<`function`>,1
+attempt,with_warning,1,0,0,character,1
+automap,autofitVariogram,-1,0,0,"class<`autofitVariogram`, `list`>",1
+automap,autofitVariogram,0,0,0,class<`formula`>,1
+automap,autofitVariogram,1,0,0,class<`SpatialPointsDataFrame`>,1
+automap,autofitVariogram,2,0,0,character[],1
+automap,autofitVariogram,3,0,0,any,1
+automap,autofitVariogram,4,0,0,^double[],1
+automap,autofitVariogram,5,0,0,logical,1
+automap,autofitVariogram,6,0,0,null,1
+automap,autofitVariogram,7,0,0,^logical[],1
+automap,autofitVariogram,8,0,0,list<any>,1
+automap,autofitVariogram,9,0,0,...,1
+automap,autoKrige,-1,0,0,"class<`autoKrige`, `list`>",1
+automap,autoKrige,0,0,0,class<`formula`>,1
+automap,autoKrige,1,0,0,class<`SpatialPointsDataFrame`>,1
+automap,autoKrige,2,0,0,class<`SpatialPixelsDataFrame`>,1
+automap,autoKrige,3,0,0,class<`SpatialPointsDataFrame`>,1
+automap,autoKrige,4,0,0,double[],1
+automap,autoKrige,5,0,0,character[],1
+automap,autoKrige,6,0,0,any,1
+automap,autoKrige,7,0,0,^double[],1
+automap,autoKrige,8,0,0,logical,1
+automap,autoKrige,9,0,0,logical,1
+automap,autoKrige,10,0,0,null,1
+automap,autoKrige,11,0,0,^logical[],1
+automap,autoKrige,12,0,0,list<any>,1
+automap,autoKrige,13,0,0,...,1
+automap,autoKrige.cv,-1,0,0,class<`autoKrige.cv`>,1
+automap,autoKrige.cv,0,0,0,class<`formula`>,1
+automap,autoKrige.cv,1,0,0,class<`SpatialPointsDataFrame`>,1
+automap,autoKrige.cv,2,0,0,class<`SpatialPointsDataFrame`>,1
+automap,autoKrige.cv,3,0,0,character,1
+automap,autoKrige.cv,4,0,0,any,1
+automap,autoKrige.cv,5,0,0,^logical[],1
+automap,autoKrige.cv,6,0,0,logical[],1
+automap,autoKrige.cv,7,0,0,null,1
+automap,autoKrige.cv,8,0,0,^logical[],1
+automap,autoKrige.cv,9,0,0,list<any>,1
+automap,autoKrige.cv,10,0,0,...,1
+automap,automapPlot,-1,0,0,class<`trellis`>,1
+automap,automapPlot,0,0,0,class<`SpatialPixelsDataFrame`>,1
+automap,automapPlot,1,0,0,character,1
+automap,automapPlot,2,0,0,any,1
+automap,automapPlot,3,0,0,...,1
+automap,checkIfautokrige.cv,-1,0,0,list<class<`autoKrige.cv`>>,1
+automap,checkIfautokrige.cv,0,0,0,list<class<`autoKrige.cv`>>,1
+automap,compare.cv,-1,0,0,class<`data.frame`>,1
+automap,compare.cv,0,0,0,...,1
+automap,compare.cv,1,0,0,any,1
+automap,compare.cv,2,0,0,logical,1
+automap,compare.cv,3,0,0,character,1
+automap,compare.cv,4,0,0,any,1
+automap,compare.cv,5,0,0,any,1
+automap,compare.cv,6,0,0,double,1
+automap,compare.cv,7,0,0,logical,1
+automap,compare.cv,8,0,0,double,1
+automap,compare.cv,9,0,0,logical,1
+automap,compare.cv,10,0,0,null,1
+automap,cv.compare.bubble,-1,0,0,null,1
+automap,cv.compare.bubble,0,0,0,list<class<`autoKrige.cv`>>,1
+automap,cv.compare.bubble,1,0,0,character,1
+automap,cv.compare.bubble,2,0,0,double[],1
+automap,cv.compare.bubble,3,0,0,integer[],1
+automap,cv.compare.bubble,4,0,0,character[],1
+automap,cv.compare.bubble,5,0,0,logical,1
+automap,cv.compare.bubble,6,0,0,double,1
+automap,cv.compare.bubble,7,0,0,...,1
+automap,plot.autofitVariogram,-1,0,0,class<`trellis`>,1
+automap,plot.autofitVariogram,0,0,0,class<`autofitVariogram`>,1
+automap,plot.autofitVariogram,0,0,1,"class<`autofitVariogram`, `list`>",1
+automap,plot.autofitVariogram,1,0,0,logical,1
+automap,plot.autofitVariogram,2,0,0,...,1
+automap,plot.autoKrige,-1,0,0,class<`trellis`>,1
+automap,plot.autoKrige,0,0,0,"class<`autoKrige`, `list`>",1
+automap,plot.autoKrige,1,0,0,list<list<character | class<`SpatialPointsDataFrame`>>>,1
+automap,plot.autoKrige,2,0,0,...,1
+automap,plot.posPredictionInterval,-1,0,0,class<`trellis`>,1
+automap,plot.posPredictionInterval,0,0,0,"class<`list`, `posPredictionInterval`>",1
+automap,plot.posPredictionInterval,1,0,0,null,1
+automap,plot.posPredictionInterval,2,0,0,logical,1
+automap,plot.posPredictionInterval,3,0,0,character,1
+automap,plot.posPredictionInterval,4,0,0,...,1
+automap,posPredictionInterval,-1,0,0,"class<`list`, `posPredictionInterval`>",1
+automap,posPredictionInterval,0,0,0,"class<`autoKrige`, `list`>",1
+automap,posPredictionInterval,1,0,0,double,1
+automap,posPredictionInterval,2,0,0,double,1
+automap,summary.autoKrige,-1,0,0,double,1
+automap,summary.autoKrige,0,0,0,"class<`autoKrige`, `list`>",1
+automap,summary.autoKrige,1,0,0,...,1
+automap,summary.autoKrige.cv,-1,0,0,class<`matrix`>,1
+automap,summary.autoKrige.cv,0,0,0,class<`autoKrige.cv`>,1
+automap,summary.autoKrige.cv,1,0,0,...,1
+automap,summary.autoKrige.cv,2,0,0,double,1
+automap,summary.posPredictionInterval,-1,0,0,list<double>,1
+automap,summary.posPredictionInterval,0,0,0,"class<`list`, `posPredictionInterval`>",1
+automap,summary.posPredictionInterval,1,0,0,...,1
+backports,isTRUE,-1,0,0,logical,1
+backports,isTRUE,0,0,0,logical,1
+bayesplot,%||%,-1,0,0,^character[],1
+bayesplot,%||%,-1,0,1,class<`formula`>,1
+bayesplot,%||%,-1,0,2,class<`function`>,1
+bayesplot,%||%,-1,0,3,double,1
+bayesplot,%||%,-1,0,4,expression,1
+bayesplot,%||%,0,0,0,^character[],1
+bayesplot,%||%,0,0,1,null,1
+bayesplot,%||%,0,0,2,double,1
+bayesplot,%||%,1,0,0,any,1
+bayesplot,abline_01,-1,0,0,"class<`Layer`, `LayerInstance`, `gg`, `ggproto`>",1
+bayesplot,abline_01,0,0,0,...,1
+bayesplot,abline_01,1,0,0,logical,1
+bayesplot,acf_data,-1,0,0,class<`data.frame`>,1
+bayesplot,acf_data,0,0,0,"class<`array`, `mcmc_array`>",1
+bayesplot,acf_data,1,0,0,double,1
+bayesplot,all_counts,-1,0,0,logical,1
+bayesplot,all_counts,0,0,0,class<`matrix`>,1
+bayesplot,all_counts,0,0,1,integer[],1
+bayesplot,all_counts,1,0,0,...,1
+bayesplot,all_ggplot,-1,0,0,logical,1
+bayesplot,all_ggplot,0,0,0,"list<class<`gg`, `ggplot`>>",1
+bayesplot,all_whole_number,-1,0,0,logical,1
+bayesplot,all_whole_number,0,0,0,class<`matrix`>,1
+bayesplot,all_whole_number,0,0,1,integer[],1
+bayesplot,all_whole_number,1,0,0,...,1
+bayesplot,apply_transformations,-1,0,0,class<`array`>,1
+bayesplot,apply_transformations,0,0,0,class<`array`>,1
+bayesplot,apply_transformations,1,0,0,list<character>,1
+bayesplot,apply_transformations,1,0,1,list<character | class<`function`>>,1
+bayesplot,apply_transformations,1,0,2,list<class<`function`>>,1
+bayesplot,apply_transformations,2,0,0,...,1
+bayesplot,apply_transformations.array,-1,0,0,class<`array`>,1
+bayesplot,apply_transformations.array,0,0,0,class<`array`>,1
+bayesplot,apply_transformations.array,1,0,0,list<character>,1
+bayesplot,apply_transformations.array,1,0,1,list<character | class<`function`>>,1
+bayesplot,apply_transformations.array,1,0,2,list<class<`function`>>,1
+bayesplot,as_bayesplot_grid,-1,0,0,"class<`bayesplot_grid`, `gDesc`, `gTree`, `grob`, `gtable`>",1
+bayesplot,as_bayesplot_grid,0,0,0,"class<`gDesc`, `gTree`, `grob`, `gtable`>",1
+bayesplot,as_neff_ratio,-1,0,0,"class<`neff_ratio`, `numeric`>",1
+bayesplot,as_neff_ratio,0,0,0,double[],1
+bayesplot,as_rhat,-1,0,0,"class<`numeric`, `rhat`>",1
+bayesplot,as_rhat,0,0,0,double[],1
+bayesplot,as_rhat,0,0,1,"class<`numeric`, `rhat`>",1
+bayesplot,auto_name,-1,0,0,"class<`neff_ratio`, `numeric`>",1
+bayesplot,auto_name,-1,0,1,"class<`numeric`, `rhat`>",1
+bayesplot,auto_name,0,0,0,"class<`neff_ratio`, `numeric`>",1
+bayesplot,auto_name,0,0,1,"class<`numeric`, `rhat`>",1
+bayesplot,available_mcmc,-1,0,0,"class<`bayesplot_function_list`, `character`>",1
+bayesplot,available_mcmc,0,0,0,any,1
+bayesplot,available_mcmc,1,0,0,logical,1
+bayesplot,available_mcmc,2,0,0,logical,1
+bayesplot,available_ppc,-1,0,0,"class<`bayesplot_function_list`, `character`>",1
+bayesplot,available_ppc,0,0,0,any,1
+bayesplot,available_ppc,1,0,0,logical,1
+bayesplot,available_ppc,2,0,0,logical,1
+bayesplot,bayesplot_grid,-1,0,0,"class<`bayesplot_grid`, `gDesc`, `gTree`, `grob`, `gtable`>",1
+bayesplot,bayesplot_grid,0,0,0,...,1
+bayesplot,bayesplot_grid,1,0,0,"list<class<`gg`, `ggplot`>>",1
+bayesplot,bayesplot_grid,2,0,0,null,1
+bayesplot,bayesplot_grid,3,0,0,null,1
+bayesplot,bayesplot_grid,4,0,0,list<double>,1
+bayesplot,bayesplot_grid,5,0,0,character[],1
+bayesplot,bayesplot_grid,6,0,0,character[],1
+bayesplot,bayesplot_grid,7,0,0,logical,1
+bayesplot,bayesplot_theme_get,-1,0,0,"class<`gg`, `theme`>",1
+bayesplot,bayesplot_theme_set,-1,0,0,"class<`gg`, `theme`>",1
+bayesplot,bayesplot_theme_set,0,0,0,"class<`gg`, `theme`>",1
+bayesplot,bayesplot_theme_update,-1,0,0,"class<`gg`, `theme`>",1
+bayesplot,bayesplot_theme_update,0,0,0,...,1
+bayesplot,calc_intervals,-1,0,0,double[],1
+bayesplot,calc_intervals,0,0,0,double[],1
+bayesplot,calc_intervals,1,0,0,double,1
+bayesplot,calc_intervals,2,0,0,logical,1
+bayesplot,calc_intervals,3,0,0,...,1
+bayesplot,calc_v,-1,0,0,double[],1
+bayesplot,calc_v,0,0,0,double[],1
+bayesplot,calc_v,0,0,1,class<`matrix`>,1
+bayesplot,calc_v,1,0,0,any,1
+bayesplot,calc_v,2,0,0,any,1
+bayesplot,calc_v,3,0,0,...,1
+bayesplot,chain_colors,-1,0,0,character[],1
+bayesplot,chain_colors,0,0,0,integer,1
+bayesplot,check_ignored_arguments,-1,0,0,null,1
+bayesplot,check_ignored_arguments,0,0,0,...,1
+bayesplot,check_ignored_arguments,1,0,0,any,1
+bayesplot,check_interval_widths,-1,0,0,double[],1
+bayesplot,check_interval_widths,0,0,0,double,1
+bayesplot,check_interval_widths,1,0,0,double,1
+bayesplot,color_scheme_get,-1,0,0,"class<`bayesplot_scheme`, `list`>",1
+bayesplot,color_scheme_get,-1,0,1,list<character>,1
+bayesplot,color_scheme_get,0,0,0,character,1
+bayesplot,color_scheme_get,0,0,1,null,1
+bayesplot,color_scheme_get,1,0,0,null,1
+bayesplot,color_scheme_get,1,0,1,double[],1
+bayesplot,color_scheme_set,-1,0,0,list<character>,1
+bayesplot,color_scheme_set,0,0,0,character[],1
+bayesplot,color_scheme_view,-1,0,0,"class<`bayesplot_grid`, `gDesc`, `gTree`, `grob`, `gtable`>",1
+bayesplot,color_scheme_view,-1,0,1,"class<`gg`, `ggplot`>",1
+bayesplot,color_scheme_view,0,0,0,character[],1
+bayesplot,color_scheme_view,0,0,1,null,1
+bayesplot,compute_column_density,-1,0,0,class<`data.frame`>,1
+bayesplot,compute_column_density,-1,0,1,"class<`data.frame`, `tbl`, `tbl_df`>",1
+bayesplot,compute_column_density,0,0,0,class<`data.frame`>,1
+bayesplot,compute_column_density,0,0,1,"class<`data.frame`, `tbl`, `tbl_df`>",1
+bayesplot,compute_column_density,1,0,0,any,1
+bayesplot,compute_column_density,2,0,0,any,1
+bayesplot,compute_column_density,3,0,0,...,1
+bayesplot,compute_errors,-1,0,0,class<`matrix`>,1
+bayesplot,compute_errors,0,0,0,integer[],1
+bayesplot,compute_errors,1,0,0,class<`matrix`>,1
+bayesplot,create_yrep_ids,-1,0,0,character[],1
+bayesplot,create_yrep_ids,0,0,0,integer[],1
+bayesplot,diagnostic_colors,-1,0,0,list<character[] | expression>,1
+bayesplot,diagnostic_colors,0,0,0,character,1
+bayesplot,diagnostic_colors,1,0,0,character,1
+bayesplot,diagnostic_color_scale,-1,0,0,"class<`Scale`, `ScaleDiscrete`, `gg`, `ggproto`>",1
+bayesplot,diagnostic_color_scale,0,0,0,character,1
+bayesplot,diagnostic_color_scale,1,0,0,character,1
+bayesplot,diagnostic_data_frame,-1,0,0,"class<`data.frame`, `tbl`, `tbl_df`>",1
+bayesplot,diagnostic_data_frame,0,0,0,"class<`neff_ratio`, `numeric`>",1
+bayesplot,diagnostic_data_frame,0,0,1,"class<`numeric`, `rhat`>",1
+bayesplot,diagnostic_factor,-1,0,0,class<`factor`>,1
+bayesplot,diagnostic_factor,0,0,0,"class<`neff_ratio`, `numeric`>",1
+bayesplot,diagnostic_factor,0,0,1,"class<`numeric`, `rhat`>",1
+bayesplot,diagnostic_factor,1,0,0,any,1
+bayesplot,diagnostic_factor,2,0,0,...,1
+bayesplot,diagnostic_factor.neff_ratio,-1,0,0,class<`factor`>,1
+bayesplot,diagnostic_factor.neff_ratio,0,0,0,"class<`neff_ratio`, `numeric`>",1
+bayesplot,diagnostic_factor.neff_ratio,1,0,0,double[],1
+bayesplot,diagnostic_factor.rhat,-1,0,0,class<`factor`>,1
+bayesplot,diagnostic_factor.rhat,0,0,0,"class<`numeric`, `rhat`>",1
+bayesplot,diagnostic_factor.rhat,1,0,0,double[],1
+bayesplot,diagnostic_points,-1,0,0,"class<`Layer`, `LayerInstance`, `gg`, `ggproto`>",1
+bayesplot,diagnostic_points,0,0,0,double,1
+bayesplot,diagnostic_points,0,0,1,null,1
+bayesplot,dont_expand_axes,-1,0,0,"class<`Coord`, `CoordCartesian`, `gg`, `ggproto`>",1
+bayesplot,dont_expand_x_axis,-1,0,0,"class<`Scale`, `ScaleContinuous`, `ScaleContinuousPosition`, `gg`, `ggproto`>",1
+bayesplot,dont_expand_x_axis,0,0,0,double[],1
+bayesplot,dont_expand_y_axis,-1,0,0,"class<`Scale`, `ScaleContinuous`, `ScaleContinuousPosition`, `gg`, `ggproto`>",1
+bayesplot,dont_expand_y_axis,0,0,0,double[],1
+bayesplot,drop_NAs_and_warn,-1,0,0,"class<`neff_ratio`, `numeric`>",1
+bayesplot,drop_NAs_and_warn,-1,0,1,"class<`numeric`, `rhat`>",1
+bayesplot,drop_NAs_and_warn,0,0,0,"class<`neff_ratio`, `numeric`>",1
+bayesplot,drop_NAs_and_warn,0,0,1,"class<`numeric`, `rhat`>",1
+bayesplot,.example_group_data,-1,0,0,class<`factor`>,1
+bayesplot,example_group_data,-1,0,0,class<`factor`>,1
+bayesplot,.example_mcmc_draws,-1,0,0,class<`array`>,1
+bayesplot,.example_mcmc_draws,-1,0,1,class<`matrix`>,1
+bayesplot,.example_mcmc_draws,0,0,0,double,1
+bayesplot,.example_mcmc_draws,1,0,0,double,1
+bayesplot,example_mcmc_draws,-1,0,0,class<`array`>,1
+bayesplot,example_mcmc_draws,-1,0,1,class<`matrix`>,1
+bayesplot,example_mcmc_draws,0,0,0,double,1
+bayesplot,example_mcmc_draws,1,0,0,double,1
+bayesplot,.example_x_data,-1,0,0,double[],1
+bayesplot,example_x_data,-1,0,0,double[],1
+bayesplot,.example_y_data,-1,0,0,integer[],1
+bayesplot,example_y_data,-1,0,0,integer[],1
+bayesplot,.example_yrep_draws,-1,0,0,class<`matrix`>,1
+bayesplot,example_yrep_draws,-1,0,0,class<`matrix`>,1
+bayesplot,facet_bg,-1,0,0,"class<`gg`, `theme`>",1
+bayesplot,facet_bg,0,0,0,logical,1
+bayesplot,facet_bg,1,0,0,...,1
+bayesplot,facet_text,-1,0,0,"class<`gg`, `theme`>",1
+bayesplot,facet_text,0,0,0,logical,1
+bayesplot,facet_text,1,0,0,...,1
+bayesplot,facet_wrap_parsed,-1,0,0,"class<`Facet`, `FacetWrap`, `gg`, `ggproto`>",1
+bayesplot,facet_wrap_parsed,0,0,0,...,1
+bayesplot,force_axes_in_facets,-1,0,0,"class<`Layer`, `LayerInstance`, `gg`, `ggproto`>",1
+bayesplot,force_x_axis_in_facets,-1,0,0,"class<`Layer`, `LayerInstance`, `gg`, `ggproto`>",1
+bayesplot,full_level_name,-1,0,0,character[],1
+bayesplot,full_level_name,0,0,0,character[],1
+bayesplot,geom_ignore,-1,0,0,"class<`Layer`, `LayerInstance`, `gg`, `ggproto`>",1
+bayesplot,geom_ignore,0,0,0,...,1
+bayesplot,get_color,-1,0,0,character[],1
+bayesplot,get_color,0,0,0,character[],1
+bayesplot,grid_lines,-1,0,0,"class<`gg`, `theme`>",1
+bayesplot,grid_lines,0,0,0,character,1
+bayesplot,grid_lines,1,0,0,double,1
+bayesplot,grid_lines_y,-1,0,0,"class<`gg`, `theme`>",1
+bayesplot,grid_lines_y,0,0,0,character,1
+bayesplot,grid_lines_y,1,0,0,double,1
+bayesplot,grouped_error_data,-1,0,0,"class<`data.frame`, `tbl`, `tbl_df`>",1
+bayesplot,grouped_error_data,0,0,0,integer[],1
+bayesplot,grouped_error_data,1,0,0,class<`matrix`>,1
+bayesplot,grouped_error_data,2,0,0,class<`factor`>,1
+bayesplot,has_multiple_chains,-1,0,0,logical,1
+bayesplot,has_multiple_chains,0,0,0,"class<`array`, `mcmc_array`>",1
+bayesplot,hline_0,-1,0,0,"class<`Layer`, `LayerInstance`, `gg`, `ggproto`>",1
+bayesplot,hline_0,0,0,0,...,1
+bayesplot,hline_0,1,0,0,logical,1
+bayesplot,hline_at,-1,0,0,"class<`Layer`, `LayerInstance`, `gg`, `ggproto`>",1
+bayesplot,hline_at,0,0,0,double[],1
+bayesplot,hline_at,1,0,0,any,1
+bayesplot,hline_at,2,0,0,...,1
+bayesplot,hline_at,3,0,0,logical,1
+bayesplot,is_3d_array,-1,0,0,logical,1
+bayesplot,is_3d_array,0,0,0,class<`array`>,1
+bayesplot,is_3d_array,0,0,1,"class<`array`, `mcmc_array`>",1
+bayesplot,is_chain_list,-1,0,0,logical,1
+bayesplot,is_chain_list,0,0,0,class<`array`>,1
+bayesplot,is_chain_list,0,0,1,class<`matrix`>,1
+bayesplot,is_df_with_chain,-1,0,0,logical,1
+bayesplot,is_df_with_chain,0,0,0,class<`array`>,1
+bayesplot,is_df_with_chain,0,0,1,class<`matrix`>,1
+bayesplot,is_hex_color,-1,0,0,logical,1
+bayesplot,is_hex_color,0,0,0,character,1
+bayesplot,is_mcmc_array,-1,0,0,logical,1
+bayesplot,is_mcmc_array,0,0,0,"class<`array`, `mcmc_array`>",1
+bayesplot,is_vector_or_1Darray,-1,0,0,logical,1
+bayesplot,is_vector_or_1Darray,0,0,0,double[],1
+bayesplot,is_whole_number,-1,0,0,class<`matrix`>,1
+bayesplot,is_whole_number,-1,0,1,logical[],1
+bayesplot,is_whole_number,0,0,0,class<`matrix`>,1
+bayesplot,is_whole_number,0,0,1,integer[],1
+bayesplot,is_whole_number,1,0,0,double,1
+bayesplot,label_x,-1,0,0,null,1
+bayesplot,label_x,0,0,0,any,1
+bayesplot,lbub,-1,0,0,class<`function`>,1
+bayesplot,lbub,0,0,0,double,1
+bayesplot,lbub,1,0,0,logical,1
+bayesplot,legend_move,-1,0,0,"class<`gg`, `theme`>",1
+bayesplot,legend_move,0,0,0,character,1
+bayesplot,legend_move,0,0,1,double[],1
+bayesplot,legend_none,-1,0,0,"class<`gg`, `theme`>",1
+bayesplot,legend_text,-1,0,0,"class<`gg`, `theme`>",1
+bayesplot,legend_text,0,0,0,...,1
+bayesplot,.list_module_functions,-1,0,0,"class<`bayesplot_function_list`, `character`>",1
+bayesplot,.list_module_functions,0,0,0,character,1
+bayesplot,.list_module_functions,1,0,0,any,1
+bayesplot,.list_module_functions,2,0,0,any,1
+bayesplot,.list_module_functions,3,0,0,logical,1
+bayesplot,.mcmc_acf,-1,0,0,"class<`gg`, `ggplot`>",1
+bayesplot,.mcmc_acf,0,0,0,class<`array`>,1
+bayesplot,.mcmc_acf,1,0,0,character[],1
+bayesplot,.mcmc_acf,2,0,0,character[],1
+bayesplot,.mcmc_acf,3,0,0,list<any>,1
+bayesplot,.mcmc_acf,4,0,0,double,1
+bayesplot,.mcmc_acf,5,0,0,character,1
+bayesplot,.mcmc_acf,6,0,0,null,1
+bayesplot,mcmc_acf,-1,0,0,"class<`gg`, `ggplot`>",1
+bayesplot,mcmc_acf,0,0,0,class<`array`>,1
+bayesplot,mcmc_acf,1,0,0,character[],1
+bayesplot,mcmc_acf,2,0,0,character[],1
+bayesplot,mcmc_acf,3,0,0,...,1
+bayesplot,mcmc_acf,4,0,0,list<any>,1
+bayesplot,mcmc_acf,5,0,0,double,1
+bayesplot,mcmc_acf,6,0,0,null,1
+bayesplot,mcmc_acf_bar,-1,0,0,"class<`gg`, `ggplot`>",1
+bayesplot,mcmc_acf_bar,0,0,0,class<`array`>,1
+bayesplot,mcmc_acf_bar,1,0,0,character[],1
+bayesplot,mcmc_acf_bar,2,0,0,character[],1
+bayesplot,mcmc_acf_bar,3,0,0,...,1
+bayesplot,mcmc_acf_bar,4,0,0,list<any>,1
+bayesplot,mcmc_acf_bar,5,0,0,double,1
+bayesplot,mcmc_areas,-1,0,0,"class<`gg`, `ggplot`>",1
+bayesplot,mcmc_areas,0,0,0,class<`array`>,1
+bayesplot,mcmc_areas,1,0,0,character[],1
+bayesplot,mcmc_areas,2,0,0,character[],1
+bayesplot,mcmc_areas,3,0,0,list<any>,1
+bayesplot,mcmc_areas,4,0,0,...,1
+bayesplot,mcmc_areas,5,0,0,character[],1
+bayesplot,mcmc_areas,6,0,0,double,1
+bayesplot,mcmc_areas,7,0,0,double,1
+bayesplot,mcmc_areas_data,-1,0,0,"class<`data.frame`, `tbl`, `tbl_df`>",1
+bayesplot,mcmc_areas_data,0,0,0,class<`array`>,1
+bayesplot,mcmc_areas_data,1,0,0,character[],1
+bayesplot,mcmc_areas_data,2,0,0,character[],1
+bayesplot,mcmc_areas_data,3,0,0,list<any>,1
+bayesplot,mcmc_areas_data,4,0,0,...,1
+bayesplot,mcmc_areas_data,5,0,0,double,1
+bayesplot,mcmc_areas_data,6,0,0,double,1
+bayesplot,mcmc_areas_data,7,0,0,character[],1
+bayesplot,.mcmc_dens,-1,0,0,"class<`gg`, `ggplot`>",1
+bayesplot,.mcmc_dens,0,0,0,class<`array`>,1
+bayesplot,.mcmc_dens,1,0,0,character[],1
+bayesplot,.mcmc_dens,2,0,0,character[],1
+bayesplot,.mcmc_dens,3,0,0,list<any>,1
+bayesplot,.mcmc_dens,4,0,0,any,1
+bayesplot,.mcmc_dens,5,0,0,logical,1
+bayesplot,.mcmc_dens,6,0,0,logical,1
+bayesplot,.mcmc_dens,7,0,0,character[],1
+bayesplot,mcmc_dens,-1,0,0,"class<`gg`, `ggplot`>",1
+bayesplot,mcmc_dens,0,0,0,class<`array`>,1
+bayesplot,mcmc_dens,1,0,0,character[],1
+bayesplot,mcmc_dens,2,0,0,character[],1
+bayesplot,mcmc_dens,3,0,0,list<any>,1
+bayesplot,mcmc_dens,4,0,0,...,1
+bayesplot,mcmc_dens,5,0,0,any,1
+bayesplot,mcmc_dens,6,0,0,logical,1
+bayesplot,mcmc_dens_chains,-1,0,0,"class<`gg`, `ggplot`>",1
+bayesplot,mcmc_dens_chains,0,0,0,class<`array`>,1
+bayesplot,mcmc_dens_chains,1,0,0,character[],1
+bayesplot,mcmc_dens_chains,2,0,0,character[],1
+bayesplot,mcmc_dens_chains,3,0,0,list<any>,1
+bayesplot,mcmc_dens_chains,4,0,0,...,1
+bayesplot,mcmc_dens_chains,5,0,0,logical,1
+bayesplot,mcmc_dens_chains,6,0,0,null,1
+bayesplot,mcmc_dens_chains,7,0,0,null,1
+bayesplot,mcmc_dens_chains_data,-1,0,0,"class<`data.frame`, `tbl`, `tbl_df`>",1
+bayesplot,mcmc_dens_chains_data,0,0,0,class<`array`>,1
+bayesplot,mcmc_dens_chains_data,1,0,0,character[],1
+bayesplot,mcmc_dens_chains_data,2,0,0,character[],1
+bayesplot,mcmc_dens_chains_data,3,0,0,list<any>,1
+bayesplot,mcmc_dens_chains_data,4,0,0,...,1
+bayesplot,mcmc_dens_chains_data,5,0,0,null,1
+bayesplot,mcmc_dens_chains_data,6,0,0,null,1
+bayesplot,mcmc_dens_chains_data,7,0,0,null,1
+bayesplot,mcmc_dens_overlay,-1,0,0,"class<`gg`, `ggplot`>",1
+bayesplot,mcmc_dens_overlay,0,0,0,class<`array`>,1
+bayesplot,mcmc_dens_overlay,1,0,0,character[],1
+bayesplot,mcmc_dens_overlay,2,0,0,character[],1
+bayesplot,mcmc_dens_overlay,3,0,0,list<any>,1
+bayesplot,mcmc_dens_overlay,4,0,0,...,1
+bayesplot,mcmc_dens_overlay,5,0,0,list<any>,1
+bayesplot,mcmc_dens_overlay,6,0,0,logical,1
+bayesplot,mcmc_dens_overlay,7,0,0,logical,1
+bayesplot,.mcmc_hist,-1,0,0,"class<`gg`, `ggplot`>",1
+bayesplot,.mcmc_hist,0,0,0,class<`array`>,1
+bayesplot,.mcmc_hist,0,0,1,class<`matrix`>,1
+bayesplot,.mcmc_hist,1,0,0,character[],1
+bayesplot,.mcmc_hist,2,0,0,character[],1
+bayesplot,.mcmc_hist,3,0,0,list<any>,1
+bayesplot,.mcmc_hist,4,0,0,list<any>,1
+bayesplot,.mcmc_hist,5,0,0,null,1
+bayesplot,.mcmc_hist,5,0,1,double,1
+bayesplot,.mcmc_hist,6,0,0,null,1
+bayesplot,.mcmc_hist,7,0,0,logical,1
+bayesplot,mcmc_hist,-1,0,0,"class<`gg`, `ggplot`>",1
+bayesplot,mcmc_hist,0,0,0,class<`array`>,1
+bayesplot,mcmc_hist,0,0,1,class<`matrix`>,1
+bayesplot,mcmc_hist,1,0,0,character[],1
+bayesplot,mcmc_hist,2,0,0,character[],1
+bayesplot,mcmc_hist,3,0,0,list<any>,1
+bayesplot,mcmc_hist,4,0,0,...,1
+bayesplot,mcmc_hist,5,0,0,list<any>,1
+bayesplot,mcmc_hist,6,0,0,null,1
+bayesplot,mcmc_hist,6,0,1,double,1
+bayesplot,mcmc_hist,7,0,0,null,1
+bayesplot,mcmc_hist_by_chain,-1,0,0,"class<`gg`, `ggplot`>",1
+bayesplot,mcmc_hist_by_chain,0,0,0,class<`array`>,1
+bayesplot,mcmc_hist_by_chain,1,0,0,character[],1
+bayesplot,mcmc_hist_by_chain,2,0,0,character,1
+bayesplot,mcmc_hist_by_chain,3,0,0,list<any>,1
+bayesplot,mcmc_hist_by_chain,4,0,0,...,1
+bayesplot,mcmc_hist_by_chain,5,0,0,list<any>,1
+bayesplot,mcmc_hist_by_chain,6,0,0,null,1
+bayesplot,mcmc_hist_by_chain,7,0,0,logical,1
+bayesplot,mcmc_intervals,-1,0,0,"class<`gg`, `ggplot`>",1
+bayesplot,mcmc_intervals,0,0,0,class<`array`>,1
+bayesplot,mcmc_intervals,0,0,1,class<`matrix`>,1
+bayesplot,mcmc_intervals,1,0,0,character[],1
+bayesplot,mcmc_intervals,2,0,0,character[],1
+bayesplot,mcmc_intervals,3,0,0,list<any>,1
+bayesplot,mcmc_intervals,3,0,1,character,1
+bayesplot,mcmc_intervals,4,0,0,...,1
+bayesplot,mcmc_intervals,5,0,0,double,1
+bayesplot,mcmc_intervals,6,0,0,double,1
+bayesplot,mcmc_intervals,7,0,0,character[],1
+bayesplot,mcmc_intervals_data,-1,0,0,"class<`data.frame`, `tbl`, `tbl_df`>",1
+bayesplot,mcmc_intervals_data,0,0,0,class<`array`>,1
+bayesplot,mcmc_intervals_data,0,0,1,class<`matrix`>,1
+bayesplot,mcmc_intervals_data,1,0,0,character[],1
+bayesplot,mcmc_intervals_data,2,0,0,character[],1
+bayesplot,mcmc_intervals_data,3,0,0,list<any>,1
+bayesplot,mcmc_intervals_data,3,0,1,character,1
+bayesplot,mcmc_intervals_data,4,0,0,...,1
+bayesplot,mcmc_intervals_data,5,0,0,double,1
+bayesplot,mcmc_intervals_data,6,0,0,double,1
+bayesplot,mcmc_intervals_data,7,0,0,character[],1
+bayesplot,mcmc_neff,-1,0,0,"class<`gg`, `ggplot`>",1
+bayesplot,mcmc_neff,0,0,0,double[],1
+bayesplot,mcmc_neff,1,0,0,...,1
+bayesplot,mcmc_neff,2,0,0,null,1
+bayesplot,mcmc_neff_data,-1,0,0,"class<`data.frame`, `tbl`, `tbl_df`>",1
+bayesplot,mcmc_neff_data,0,0,0,double[],1
+bayesplot,mcmc_neff_data,1,0,0,...,1
+bayesplot,mcmc_neff_hist,-1,0,0,"class<`gg`, `ggplot`>",1
+bayesplot,mcmc_neff_hist,0,0,0,double[],1
+bayesplot,mcmc_neff_hist,1,0,0,...,1
+bayesplot,mcmc_neff_hist,2,0,0,null,1
+bayesplot,mcmc_neff_hist,3,0,0,null,1
+bayesplot,mcmc_parcoord,-1,0,0,"class<`gg`, `ggplot`>",1
+bayesplot,mcmc_parcoord,0,0,0,class<`array`>,1
+bayesplot,mcmc_parcoord,1,0,0,character[],1
+bayesplot,mcmc_parcoord,2,0,0,character[],1
+bayesplot,mcmc_parcoord,3,0,0,list<any>,1
+bayesplot,mcmc_parcoord,4,0,0,...,1
+bayesplot,mcmc_parcoord,5,0,0,double,1
+bayesplot,mcmc_parcoord,6,0,0,double,1
+bayesplot,mcmc_parcoord,7,0,0,null,1
+bayesplot,mcmc_parcoord_data,-1,0,0,"class<`data.frame`, `tbl`, `tbl_df`>",1
+bayesplot,mcmc_parcoord_data,0,0,0,class<`array`>,1
+bayesplot,mcmc_parcoord_data,1,0,0,character[],1
+bayesplot,mcmc_parcoord_data,2,0,0,character[],1
+bayesplot,mcmc_parcoord_data,3,0,0,list<any>,1
+bayesplot,mcmc_parcoord_data,4,0,0,null,1
+bayesplot,mcmc_rank_hist,-1,0,0,"class<`gg`, `ggplot`>",1
+bayesplot,mcmc_rank_hist,0,0,0,class<`array`>,1
+bayesplot,mcmc_rank_hist,1,0,0,character[],1
+bayesplot,mcmc_rank_hist,2,0,0,character[],1
+bayesplot,mcmc_rank_hist,3,0,0,list<any>,1
+bayesplot,mcmc_rank_hist,4,0,0,...,1
+bayesplot,mcmc_rank_hist,5,0,0,list<any>,1
+bayesplot,mcmc_rank_hist,6,0,0,double,1
+bayesplot,mcmc_rank_hist,7,0,0,logical,1
+bayesplot,mcmc_rank_overlay,-1,0,0,"class<`gg`, `ggplot`>",1
+bayesplot,mcmc_rank_overlay,0,0,0,class<`array`>,1
+bayesplot,mcmc_rank_overlay,1,0,0,character,1
+bayesplot,mcmc_rank_overlay,2,0,0,character[],1
+bayesplot,mcmc_rank_overlay,3,0,0,list<any>,1
+bayesplot,mcmc_rank_overlay,4,0,0,...,1
+bayesplot,mcmc_rank_overlay,5,0,0,double,1
+bayesplot,mcmc_rank_overlay,6,0,0,logical,1
+bayesplot,mcmc_rhat,-1,0,0,"class<`gg`, `ggplot`>",1
+bayesplot,mcmc_rhat,0,0,0,double[],1
+bayesplot,mcmc_rhat,1,0,0,...,1
+bayesplot,mcmc_rhat,2,0,0,double,1
+bayesplot,mcmc_rhat,2,0,1,null,1
+bayesplot,mcmc_rhat_data,-1,0,0,"class<`data.frame`, `tbl`, `tbl_df`>",1
+bayesplot,mcmc_rhat_data,0,0,0,"class<`numeric`, `rhat`>",1
+bayesplot,mcmc_rhat_data,0,0,1,double[],1
+bayesplot,mcmc_rhat_data,1,0,0,...,1
+bayesplot,mcmc_rhat_hist,-1,0,0,"class<`gg`, `ggplot`>",1
+bayesplot,mcmc_rhat_hist,0,0,0,double[],1
+bayesplot,mcmc_rhat_hist,1,0,0,...,1
+bayesplot,mcmc_rhat_hist,2,0,0,null,1
+bayesplot,mcmc_rhat_hist,3,0,0,null,1
+bayesplot,.mcmc_scatter,-1,0,0,"class<`gg`, `ggplot`>",1
+bayesplot,.mcmc_scatter,0,0,0,class<`array`>,1
+bayesplot,.mcmc_scatter,1,0,0,character[],1
+bayesplot,.mcmc_scatter,2,0,0,character[],1
+bayesplot,.mcmc_scatter,3,0,0,list<character>,1
+bayesplot,.mcmc_scatter,4,0,0,logical,1
+bayesplot,.mcmc_scatter,5,0,0,double,1
+bayesplot,.mcmc_scatter,6,0,0,double,1
+bayesplot,.mcmc_scatter,7,0,0,null,1
+bayesplot,mcmc_scatter,-1,0,0,"class<`gg`, `ggplot`>",1
+bayesplot,mcmc_scatter,0,0,0,class<`array`>,1
+bayesplot,mcmc_scatter,1,0,0,character[],1
+bayesplot,mcmc_scatter,2,0,0,character[],1
+bayesplot,mcmc_scatter,3,0,0,list<character>,1
+bayesplot,mcmc_scatter,4,0,0,...,1
+bayesplot,mcmc_scatter,5,0,0,double,1
+bayesplot,mcmc_scatter,6,0,0,double,1
+bayesplot,mcmc_scatter,7,0,0,null,1
+bayesplot,.mcmc_trace,-1,0,0,"class<`gg`, `ggplot`>",1
+bayesplot,.mcmc_trace,0,0,0,class<`array`>,1
+bayesplot,.mcmc_trace,1,0,0,character[],1
+bayesplot,.mcmc_trace,2,0,0,character[],1
+bayesplot,.mcmc_trace,3,0,0,list<any>,1
+bayesplot,.mcmc_trace,4,0,0,double,1
+bayesplot,.mcmc_trace,5,0,0,double[],1
+bayesplot,.mcmc_trace,5,0,1,null,1
+bayesplot,.mcmc_trace,6,0,0,double,1
+bayesplot,.mcmc_trace,6,0,1,null,1
+bayesplot,.mcmc_trace,7,0,0,any,1
+bayesplot,mcmc_trace,-1,0,0,"class<`gg`, `ggplot`>",1
+bayesplot,mcmc_trace,0,0,0,class<`array`>,1
+bayesplot,mcmc_trace,1,0,0,character[],1
+bayesplot,mcmc_trace,2,0,0,character[],1
+bayesplot,mcmc_trace,3,0,0,list<any>,1
+bayesplot,mcmc_trace,4,0,0,...,1
+bayesplot,mcmc_trace,5,0,0,any,1
+bayesplot,mcmc_trace,6,0,0,double,1
+bayesplot,mcmc_trace,7,0,0,double,1
+bayesplot,mcmc_trace_data,-1,0,0,"class<`data.frame`, `tbl`, `tbl_df`>",1
+bayesplot,mcmc_trace_data,0,0,0,class<`array`>,1
+bayesplot,mcmc_trace_data,1,0,0,character[],1
+bayesplot,mcmc_trace_data,2,0,0,character[],1
+bayesplot,mcmc_trace_data,3,0,0,list<any>,1
+bayesplot,mcmc_trace_data,4,0,0,...,1
+bayesplot,mcmc_trace_data,5,0,0,null,1
+bayesplot,mcmc_trace_data,6,0,0,double,1
+bayesplot,mcmc_trace_data,7,0,0,double,1
+bayesplot,mcmc_violin,-1,0,0,"class<`gg`, `ggplot`>",1
+bayesplot,mcmc_violin,0,0,0,class<`array`>,1
+bayesplot,mcmc_violin,1,0,0,character[],1
+bayesplot,mcmc_violin,2,0,0,character[],1
+bayesplot,mcmc_violin,3,0,0,list<any>,1
+bayesplot,mcmc_violin,4,0,0,...,1
+bayesplot,mcmc_violin,5,0,0,list<any>,1
+bayesplot,mcmc_violin,6,0,0,double[],1
+bayesplot,melt_and_stack,-1,0,0,"class<`data.frame`, `tbl`, `tbl_df`>",1
+bayesplot,melt_and_stack,0,0,0,double[],1
+bayesplot,melt_and_stack,1,0,0,class<`matrix`>,1
+bayesplot,melt_mcmc,-1,0,0,class<`data.frame`>,1
+bayesplot,melt_mcmc,0,0,0,"class<`array`, `mcmc_array`>",1
+bayesplot,melt_mcmc,0,0,1,class<`matrix`>,1
+bayesplot,melt_mcmc,1,0,0,...,1
+bayesplot,melt_mcmc.matrix,-1,0,0,class<`data.frame`>,1
+bayesplot,melt_mcmc.matrix,0,0,0,class<`matrix`>,1
+bayesplot,melt_mcmc.matrix,1,0,0,character[],1
+bayesplot,melt_mcmc.matrix,2,0,0,character,1
+bayesplot,melt_mcmc.matrix,3,0,0,...,1
+bayesplot,melt_mcmc.mcmc_array,-1,0,0,class<`data.frame`>,1
+bayesplot,melt_mcmc.mcmc_array,0,0,0,"class<`array`, `mcmc_array`>",1
+bayesplot,melt_mcmc.mcmc_array,1,0,0,character[],1
+bayesplot,melt_mcmc.mcmc_array,2,0,0,character,1
+bayesplot,melt_mcmc.mcmc_array,3,0,0,logical,1
+bayesplot,melt_mcmc.mcmc_array,4,0,0,...,1
+bayesplot,melt_yrep,-1,0,0,"class<`data.frame`, `tbl`, `tbl_df`>",1
+bayesplot,melt_yrep,0,0,0,class<`matrix`>,1
+bayesplot,merge_chains,-1,0,0,class<`matrix`>,1
+bayesplot,merge_chains,0,0,0,"class<`array`, `mcmc_array`>",1
+bayesplot,mixed_scheme,-1,0,0,list<character>,1
+bayesplot,mixed_scheme,0,0,0,character,1
+bayesplot,mixed_scheme,1,0,0,character,1
+bayesplot,modify_aes_,-1,0,0,class<`uneval`>,1
+bayesplot,modify_aes_,0,0,0,class<`uneval`>,1
+bayesplot,modify_aes_,1,0,0,...,1
+bayesplot,[.neff_ratio,-1,0,0,"class<`neff_ratio`, `numeric`>",1
+bayesplot,[.neff_ratio,0,0,0,"class<`neff_ratio`, `numeric`>",1
+bayesplot,[.neff_ratio,1,0,0,integer[],1
+bayesplot,[.neff_ratio,2,0,0,any,1
+bayesplot,[.neff_ratio,3,0,0,logical,1
+bayesplot,[.neff_ratio,4,0,0,...,1
+bayesplot,new_neff_ratio,-1,0,0,"class<`neff_ratio`, `numeric`>",1
+bayesplot,new_neff_ratio,0,0,0,double[],1
+bayesplot,new_rhat,-1,0,0,"class<`numeric`, `rhat`>",1
+bayesplot,new_rhat,0,0,0,double[],1
+bayesplot,new_rhat,0,0,1,"class<`numeric`, `rhat`>",1
+bayesplot,no_legend_spacing,-1,0,0,"class<`gg`, `theme`>",1
+bayesplot,num_chains,-1,0,0,integer,1
+bayesplot,num_chains,0,0,0,"class<`array`, `mcmc_array`>",1
+bayesplot,num_chains,0,0,1,class<`data.frame`>,1
+bayesplot,num_chains,1,0,0,...,1
+bayesplot,num_chains.data.frame,-1,0,0,integer,1
+bayesplot,num_chains.data.frame,0,0,0,class<`data.frame`>,1
+bayesplot,num_chains.data.frame,1,0,0,...,1
+bayesplot,num_chains.mcmc_array,-1,0,0,integer,1
+bayesplot,num_chains.mcmc_array,0,0,0,"class<`array`, `mcmc_array`>",1
+bayesplot,num_chains.mcmc_array,1,0,0,...,1
+bayesplot,num_iters,-1,0,0,integer,1
+bayesplot,num_iters,0,0,0,"class<`array`, `mcmc_array`>",1
+bayesplot,num_iters,0,0,1,class<`data.frame`>,1
+bayesplot,num_iters,1,0,0,...,1
+bayesplot,num_iters.data.frame,-1,0,0,integer,1
+bayesplot,num_iters.data.frame,0,0,0,class<`data.frame`>,1
+bayesplot,num_iters.data.frame,1,0,0,...,1
+bayesplot,num_iters.mcmc_array,-1,0,0,integer,1
+bayesplot,num_iters.mcmc_array,0,0,0,"class<`array`, `mcmc_array`>",1
+bayesplot,num_iters.mcmc_array,1,0,0,...,1
+bayesplot,num_params,-1,0,0,integer,1
+bayesplot,num_params,0,0,0,"class<`array`, `mcmc_array`>",1
+bayesplot,num_params,0,0,1,class<`data.frame`>,1
+bayesplot,num_params,1,0,0,...,1
+bayesplot,num_params.data.frame,-1,0,0,integer,1
+bayesplot,num_params.data.frame,0,0,0,class<`data.frame`>,1
+bayesplot,num_params.data.frame,1,0,0,...,1
+bayesplot,num_params.mcmc_array,-1,0,0,integer,1
+bayesplot,num_params.mcmc_array,0,0,0,"class<`array`, `mcmc_array`>",1
+bayesplot,num_params.mcmc_array,1,0,0,...,1
+bayesplot,overlay_function,-1,0,0,"class<`Layer`, `LayerInstance`, `gg`, `ggproto`>",1
+bayesplot,overlay_function,0,0,0,...,1
+bayesplot,panel_bg,-1,0,0,"class<`gg`, `theme`>",1
+bayesplot,panel_bg,0,0,0,logical,1
+bayesplot,panel_bg,1,0,0,...,1
+bayesplot,parameter_names,-1,0,0,character[],1
+bayesplot,parameter_names,0,0,0,class<`array`>,1
+bayesplot,parameter_names,0,0,1,"class<`array`, `mcmc_array`>",1
+bayesplot,parameter_names,0,0,2,class<`matrix`>,1
+bayesplot,parameter_names.array,-1,0,0,character[],1
+bayesplot,parameter_names.array,0,0,0,class<`array`>,1
+bayesplot,parameter_names.array,0,0,1,"class<`array`, `mcmc_array`>",1
+bayesplot,parameter_names.matrix,-1,0,0,character[],1
+bayesplot,parameter_names.matrix,0,0,0,class<`matrix`>,1
+bayesplot,parcoord_style_np,-1,0,0,"class<`list`, `nuts_style`>",1
+bayesplot,parcoord_style_np,0,0,0,character,1
+bayesplot,parcoord_style_np,1,0,0,double,1
+bayesplot,parcoord_style_np,2,0,0,double,1
+bayesplot,plot_bg,-1,0,0,"class<`gg`, `theme`>",1
+bayesplot,plot_bg,0,0,0,logical,1
+bayesplot,plot_bg,1,0,0,...,1
+bayesplot,plot_scheme,-1,0,0,"class<`gg`, `ggplot`>",1
+bayesplot,plot_scheme,0,0,0,character,1
+bayesplot,plot_scheme,0,0,1,null,1
+bayesplot,.ppc_bars,-1,0,0,"class<`gg`, `ggplot`>",1
+bayesplot,.ppc_bars,0,0,0,class<`data.frame`>,1
+bayesplot,.ppc_bars,1,0,0,"class<`data.frame`, `tbl`, `tbl_df`>",1
+bayesplot,.ppc_bars,2,0,0,any,1
+bayesplot,.ppc_bars,3,0,0,logical,1
+bayesplot,.ppc_bars,4,0,0,double,1
+bayesplot,.ppc_bars,5,0,0,double,1
+bayesplot,.ppc_bars,6,0,0,double,1
+bayesplot,.ppc_bars,7,0,0,logical,1
+bayesplot,ppc_bars,-1,0,0,"class<`gg`, `ggplot`>",1
+bayesplot,ppc_bars,0,0,0,integer[],1
+bayesplot,ppc_bars,1,0,0,class<`matrix`>,1
+bayesplot,ppc_bars,2,0,0,...,1
+bayesplot,ppc_bars,3,0,0,double,1
+bayesplot,ppc_bars,4,0,0,double,1
+bayesplot,ppc_bars,5,0,0,double,1
+bayesplot,ppc_bars,6,0,0,double,1
+bayesplot,ppc_bars,7,0,0,logical,1
+bayesplot,ppc_bars_grouped,-1,0,0,"class<`gg`, `ggplot`>",1
+bayesplot,ppc_bars_grouped,0,0,0,integer[],1
+bayesplot,ppc_bars_grouped,1,0,0,class<`matrix`>,1
+bayesplot,ppc_bars_grouped,2,0,0,class<`factor`>,1
+bayesplot,ppc_bars_grouped,3,0,0,...,1
+bayesplot,ppc_bars_grouped,4,0,0,list<any>,1
+bayesplot,ppc_bars_grouped,5,0,0,double,1
+bayesplot,ppc_bars_grouped,6,0,0,double,1
+bayesplot,ppc_bars_grouped,7,0,0,double,1
+bayesplot,ppc_bars_yrep_data,-1,0,0,"class<`data.frame`, `tbl`, `tbl_df`>",1
+bayesplot,ppc_bars_yrep_data,0,0,0,integer[],1
+bayesplot,ppc_bars_yrep_data,1,0,0,class<`matrix`>,1
+bayesplot,ppc_bars_yrep_data,2,0,0,double[],1
+bayesplot,ppc_bars_yrep_data,3,0,0,logical,1
+bayesplot,ppc_bars_yrep_data,4,0,0,class<`factor`>,1
+bayesplot,ppc_bars_yrep_data,4,0,1,null,1
+bayesplot,ppc_boxplot,-1,0,0,"class<`gg`, `ggplot`>",1
+bayesplot,ppc_boxplot,0,0,0,integer[],1
+bayesplot,ppc_boxplot,1,0,0,class<`matrix`>,1
+bayesplot,ppc_boxplot,2,0,0,...,1
+bayesplot,ppc_boxplot,3,0,0,logical,1
+bayesplot,ppc_boxplot,4,0,0,double,1
+bayesplot,ppc_boxplot,5,0,0,double,1
+bayesplot,ppc_data,-1,0,0,"class<`data.frame`, `tbl`, `tbl_df`>",1
+bayesplot,ppc_data,0,0,0,double[],1
+bayesplot,ppc_data,1,0,0,class<`matrix`>,1
+bayesplot,ppc_data,2,0,0,null,1
+bayesplot,ppc_data,2,0,1,class<`factor`>,1
+bayesplot,ppc_dens,-1,0,0,"class<`gg`, `ggplot`>",1
+bayesplot,ppc_dens,0,0,0,integer[],1
+bayesplot,ppc_dens,1,0,0,class<`matrix`>,1
+bayesplot,ppc_dens,2,0,0,...,1
+bayesplot,ppc_dens,3,0,0,logical,1
+bayesplot,ppc_dens,4,0,0,double,1
+bayesplot,ppc_dens,5,0,0,double,1
+bayesplot,ppc_dens_overlay,-1,0,0,"class<`gg`, `ggplot`>",1
+bayesplot,ppc_dens_overlay,0,0,0,double[],1
+bayesplot,ppc_dens_overlay,1,0,0,class<`matrix`>,1
+bayesplot,ppc_dens_overlay,2,0,0,...,1
+bayesplot,ppc_dens_overlay,3,0,0,double,1
+bayesplot,ppc_dens_overlay,4,0,0,double,1
+bayesplot,ppc_dens_overlay,5,0,0,logical,1
+bayesplot,ppc_dens_overlay,6,0,0,character,1
+bayesplot,ppc_dens_overlay,7,0,0,double,1
+bayesplot,ppc_ecdf_overlay,-1,0,0,"class<`gg`, `ggplot`>",1
+bayesplot,ppc_ecdf_overlay,0,0,0,integer[],1
+bayesplot,ppc_ecdf_overlay,1,0,0,class<`matrix`>,1
+bayesplot,ppc_ecdf_overlay,2,0,0,...,1
+bayesplot,ppc_ecdf_overlay,3,0,0,logical,1
+bayesplot,ppc_ecdf_overlay,4,0,0,logical,1
+bayesplot,ppc_ecdf_overlay,5,0,0,double,1
+bayesplot,ppc_ecdf_overlay,6,0,0,double,1
+bayesplot,ppc_error_hist,-1,0,0,"class<`gg`, `ggplot`>",1
+bayesplot,ppc_error_hist,0,0,0,integer[],1
+bayesplot,ppc_error_hist,1,0,0,class<`matrix`>,1
+bayesplot,ppc_error_hist,2,0,0,...,1
+bayesplot,ppc_error_hist,3,0,0,null,1
+bayesplot,ppc_error_hist,4,0,0,null,1
+bayesplot,ppc_error_hist,5,0,0,logical,1
+bayesplot,ppc_error_hist_grouped,-1,0,0,"class<`gg`, `ggplot`>",1
+bayesplot,ppc_error_hist_grouped,0,0,0,integer[],1
+bayesplot,ppc_error_hist_grouped,1,0,0,class<`matrix`>,1
+bayesplot,ppc_error_hist_grouped,2,0,0,class<`factor`>,1
+bayesplot,ppc_error_hist_grouped,3,0,0,...,1
+bayesplot,ppc_error_hist_grouped,4,0,0,null,1
+bayesplot,ppc_error_hist_grouped,5,0,0,null,1
+bayesplot,ppc_error_hist_grouped,6,0,0,logical,1
+bayesplot,ppc_error_scatter,-1,0,0,"class<`gg`, `ggplot`>",1
+bayesplot,ppc_error_scatter,0,0,0,integer[],1
+bayesplot,ppc_error_scatter,1,0,0,class<`matrix`>,1
+bayesplot,ppc_error_scatter,2,0,0,...,1
+bayesplot,ppc_error_scatter,3,0,0,double,1
+bayesplot,ppc_error_scatter,4,0,0,double,1
+bayesplot,ppc_error_scatter_avg,-1,0,0,"class<`gg`, `ggplot`>",1
+bayesplot,ppc_error_scatter_avg,0,0,0,integer[],1
+bayesplot,ppc_error_scatter_avg,1,0,0,class<`matrix`>,1
+bayesplot,ppc_error_scatter_avg,2,0,0,...,1
+bayesplot,ppc_error_scatter_avg,3,0,0,double,1
+bayesplot,ppc_error_scatter_avg,4,0,0,double,1
+bayesplot,ppc_error_scatter_avg_vs_x,-1,0,0,"class<`gg`, `ggplot`>",1
+bayesplot,ppc_error_scatter_avg_vs_x,0,0,0,integer[],1
+bayesplot,ppc_error_scatter_avg_vs_x,1,0,0,class<`matrix`>,1
+bayesplot,ppc_error_scatter_avg_vs_x,2,0,0,double[],1
+bayesplot,ppc_error_scatter_avg_vs_x,3,0,0,...,1
+bayesplot,ppc_error_scatter_avg_vs_x,4,0,0,double,1
+bayesplot,ppc_error_scatter_avg_vs_x,5,0,0,double,1
+bayesplot,ppc_freqpoly,-1,0,0,"class<`gg`, `ggplot`>",1
+bayesplot,ppc_freqpoly,0,0,0,integer[],1
+bayesplot,ppc_freqpoly,1,0,0,class<`matrix`>,1
+bayesplot,ppc_freqpoly,2,0,0,...,1
+bayesplot,ppc_freqpoly,3,0,0,double,1
+bayesplot,ppc_freqpoly,4,0,0,logical,1
+bayesplot,ppc_freqpoly,5,0,0,double,1
+bayesplot,ppc_freqpoly,6,0,0,double,1
+bayesplot,ppc_freqpoly_grouped,-1,0,0,"class<`gg`, `ggplot`>",1
+bayesplot,ppc_freqpoly_grouped,0,0,0,integer[],1
+bayesplot,ppc_freqpoly_grouped,1,0,0,class<`matrix`>,1
+bayesplot,ppc_freqpoly_grouped,2,0,0,class<`factor`>,1
+bayesplot,ppc_freqpoly_grouped,3,0,0,...,1
+bayesplot,ppc_freqpoly_grouped,4,0,0,null,1
+bayesplot,ppc_freqpoly_grouped,5,0,0,logical,1
+bayesplot,ppc_freqpoly_grouped,6,0,0,double,1
+bayesplot,ppc_freqpoly_grouped,7,0,0,double,1
+bayesplot,ppc_group_data,-1,0,0,"class<`data.frame`, `grouped_df`, `tbl`, `tbl_df`>",1
+bayesplot,ppc_group_data,0,0,0,integer[],1
+bayesplot,ppc_group_data,1,0,0,class<`matrix`>,1
+bayesplot,ppc_group_data,2,0,0,class<`factor`>,1
+bayesplot,ppc_group_data,2,0,1,double,1
+bayesplot,ppc_group_data,3,0,0,null,1
+bayesplot,ppc_group_data,3,0,1,class<`function`>,1
+bayesplot,pp_check,-1,0,0,"class<`gg`, `ggplot`>",1
+bayesplot,pp_check,0,0,0,class<`foo`>,1
+bayesplot,pp_check,0,0,1,integer[],1
+bayesplot,pp_check,1,0,0,...,1
+bayesplot,pp_check.default,-1,0,0,"class<`gg`, `ggplot`>",1
+bayesplot,pp_check.default,0,0,0,integer[],1
+bayesplot,pp_check.default,1,0,0,class<`matrix`>,1
+bayesplot,pp_check.default,2,0,0,character,1
+bayesplot,pp_check.default,2,0,1,class<`function`>,1
+bayesplot,pp_check.default,3,0,0,...,1
+bayesplot,ppc_hist,-1,0,0,"class<`gg`, `ggplot`>",1
+bayesplot,ppc_hist,0,0,0,double[],1
+bayesplot,ppc_hist,1,0,0,class<`matrix`>,1
+bayesplot,ppc_hist,2,0,0,...,1
+bayesplot,ppc_hist,3,0,0,double,1
+bayesplot,ppc_hist,3,0,1,null,1
+bayesplot,ppc_hist,4,0,0,null,1
+bayesplot,ppc_hist,5,0,0,logical,1
+bayesplot,.ppc_intervals,-1,0,0,"class<`gg`, `ggplot`>",1
+bayesplot,.ppc_intervals,0,0,0,"class<`data.frame`, `tbl`, `tbl_df`>",1
+bayesplot,.ppc_intervals,1,0,0,any,1
+bayesplot,.ppc_intervals,2,0,0,double,1
+bayesplot,.ppc_intervals,3,0,0,double,1
+bayesplot,.ppc_intervals,4,0,0,double,1
+bayesplot,.ppc_intervals,5,0,0,logical,1
+bayesplot,.ppc_intervals,6,0,0,character,1
+bayesplot,.ppc_intervals,7,0,0,null,1
+bayesplot,ppc_intervals,-1,0,0,"class<`gg`, `ggplot`>",1
+bayesplot,ppc_intervals,0,0,0,double[],1
+bayesplot,ppc_intervals,1,0,0,class<`matrix`>,1
+bayesplot,ppc_intervals,2,0,0,double[],1
+bayesplot,ppc_intervals,2,0,1,null,1
+bayesplot,ppc_intervals,3,0,0,...,1
+bayesplot,ppc_intervals,4,0,0,double,1
+bayesplot,ppc_intervals,5,0,0,double,1
+bayesplot,ppc_intervals,6,0,0,double,1
+bayesplot,ppc_intervals,7,0,0,double,1
+bayesplot,.ppc_intervals_data,-1,0,0,"class<`data.frame`, `tbl`, `tbl_df`>",1
+bayesplot,.ppc_intervals_data,0,0,0,double[],1
+bayesplot,.ppc_intervals_data,1,0,0,class<`matrix`>,1
+bayesplot,.ppc_intervals_data,2,0,0,double[],1
+bayesplot,.ppc_intervals_data,2,0,1,null,1
+bayesplot,.ppc_intervals_data,3,0,0,null,1
+bayesplot,.ppc_intervals_data,3,0,1,class<`factor`>,1
+bayesplot,.ppc_intervals_data,4,0,0,double,1
+bayesplot,.ppc_intervals_data,5,0,0,double,1
+bayesplot,ppc_intervals_data,-1,0,0,"class<`data.frame`, `tbl`, `tbl_df`>",1
+bayesplot,ppc_intervals_data,0,0,0,double[],1
+bayesplot,ppc_intervals_data,1,0,0,class<`matrix`>,1
+bayesplot,ppc_intervals_data,2,0,0,double[],1
+bayesplot,ppc_intervals_data,2,0,1,null,1
+bayesplot,ppc_intervals_data,3,0,0,null,1
+bayesplot,ppc_intervals_data,3,0,1,class<`factor`>,1
+bayesplot,ppc_intervals_data,4,0,0,...,1
+bayesplot,ppc_intervals_data,5,0,0,double,1
+bayesplot,ppc_intervals_data,6,0,0,double,1
+bayesplot,ppc_ribbon,-1,0,0,"class<`gg`, `ggplot`>",1
+bayesplot,ppc_ribbon,0,0,0,double[],1
+bayesplot,ppc_ribbon,1,0,0,class<`matrix`>,1
+bayesplot,ppc_ribbon,2,0,0,integer[],1
+bayesplot,ppc_ribbon,2,0,1,null,1
+bayesplot,ppc_ribbon,3,0,0,...,1
+bayesplot,ppc_ribbon,4,0,0,double,1
+bayesplot,ppc_ribbon,5,0,0,double,1
+bayesplot,ppc_ribbon,6,0,0,double,1
+bayesplot,ppc_ribbon,7,0,0,double,1
+bayesplot,ppc_ribbon_grouped,-1,0,0,"class<`gg`, `ggplot`>",1
+bayesplot,ppc_ribbon_grouped,0,0,0,double[],1
+bayesplot,ppc_ribbon_grouped,1,0,0,class<`matrix`>,1
+bayesplot,ppc_ribbon_grouped,2,0,0,integer[],1
+bayesplot,ppc_ribbon_grouped,3,0,0,class<`factor`>,1
+bayesplot,ppc_ribbon_grouped,4,0,0,...,1
+bayesplot,ppc_ribbon_grouped,5,0,0,list<any>,1
+bayesplot,ppc_ribbon_grouped,6,0,0,double,1
+bayesplot,ppc_ribbon_grouped,7,0,0,double,1
+bayesplot,ppc_rootogram,-1,0,0,"class<`gg`, `ggplot`>",1
+bayesplot,ppc_rootogram,0,0,0,integer[],1
+bayesplot,ppc_rootogram,1,0,0,class<`matrix`>,1
+bayesplot,ppc_rootogram,2,0,0,character[],1
+bayesplot,ppc_rootogram,3,0,0,...,1
+bayesplot,ppc_rootogram,4,0,0,double,1
+bayesplot,ppc_rootogram,5,0,0,double,1
+bayesplot,.ppc_scatter,-1,0,0,"class<`gg`, `ggplot`>",1
+bayesplot,.ppc_scatter,0,0,0,class<`data.frame`>,1
+bayesplot,.ppc_scatter,0,0,1,"class<`data.frame`, `tbl`, `tbl_df`>",1
+bayesplot,.ppc_scatter,1,0,0,class<`uneval`>,1
+bayesplot,.ppc_scatter,2,0,0,character,1
+bayesplot,.ppc_scatter,2,0,1,expression,1
+bayesplot,.ppc_scatter,3,0,0,expression,1
+bayesplot,.ppc_scatter,3,0,1,character,1
+bayesplot,.ppc_scatter,4,0,0,character[],1
+bayesplot,.ppc_scatter,5,0,0,double,1
+bayesplot,.ppc_scatter,6,0,0,double,1
+bayesplot,.ppc_scatter,7,0,0,logical,1
+bayesplot,ppc_scatter,-1,0,0,"class<`gg`, `ggplot`>",1
+bayesplot,ppc_scatter,0,0,0,integer[],1
+bayesplot,ppc_scatter,1,0,0,class<`matrix`>,1
+bayesplot,ppc_scatter,2,0,0,...,1
+bayesplot,ppc_scatter,3,0,0,double,1
+bayesplot,ppc_scatter,4,0,0,double,1
+bayesplot,ppc_scatter_avg,-1,0,0,"class<`gg`, `ggplot`>",1
+bayesplot,ppc_scatter_avg,0,0,0,integer[],1
+bayesplot,ppc_scatter_avg,1,0,0,class<`matrix`>,1
+bayesplot,ppc_scatter_avg,2,0,0,...,1
+bayesplot,ppc_scatter_avg,3,0,0,double,1
+bayesplot,ppc_scatter_avg,4,0,0,double,1
+bayesplot,ppc_scatter_avg_grouped,-1,0,0,"class<`gg`, `ggplot`>",1
+bayesplot,ppc_scatter_avg_grouped,0,0,0,integer[],1
+bayesplot,ppc_scatter_avg_grouped,1,0,0,class<`matrix`>,1
+bayesplot,ppc_scatter_avg_grouped,2,0,0,class<`factor`>,1
+bayesplot,ppc_scatter_avg_grouped,3,0,0,...,1
+bayesplot,ppc_scatter_avg_grouped,4,0,0,double,1
+bayesplot,ppc_scatter_avg_grouped,5,0,0,double,1
+bayesplot,ppc_stat,-1,0,0,"class<`gg`, `ggplot`>",1
+bayesplot,ppc_stat,0,0,0,integer[],1
+bayesplot,ppc_stat,1,0,0,class<`matrix`>,1
+bayesplot,ppc_stat,1,0,1,"class<`matrix`, `ppd`>",1
+bayesplot,ppc_stat,2,0,0,character,1
+bayesplot,ppc_stat,2,0,1,class<`function`>,1
+bayesplot,ppc_stat,3,0,0,...,1
+bayesplot,ppc_stat,4,0,0,double,1
+bayesplot,ppc_stat,4,0,1,null,1
+bayesplot,ppc_stat,5,0,0,null,1
+bayesplot,ppc_stat,6,0,0,logical,1
+bayesplot,ppc_stat_2d,-1,0,0,"class<`gg`, `ggplot`>",1
+bayesplot,ppc_stat_2d,0,0,0,integer[],1
+bayesplot,ppc_stat_2d,1,0,0,class<`matrix`>,1
+bayesplot,ppc_stat_2d,2,0,0,character[],1
+bayesplot,ppc_stat_2d,3,0,0,...,1
+bayesplot,ppc_stat_2d,4,0,0,double,1
+bayesplot,ppc_stat_2d,5,0,0,double,1
+bayesplot,ppc_stat_freqpoly_grouped,-1,0,0,"class<`gg`, `ggplot`>",1
+bayesplot,ppc_stat_freqpoly_grouped,0,0,0,integer[],1
+bayesplot,ppc_stat_freqpoly_grouped,1,0,0,class<`matrix`>,1
+bayesplot,ppc_stat_freqpoly_grouped,2,0,0,class<`factor`>,1
+bayesplot,ppc_stat_freqpoly_grouped,3,0,0,character,1
+bayesplot,ppc_stat_freqpoly_grouped,4,0,0,...,1
+bayesplot,ppc_stat_freqpoly_grouped,5,0,0,list<double>,1
+bayesplot,ppc_stat_freqpoly_grouped,6,0,0,null,1
+bayesplot,ppc_stat_freqpoly_grouped,7,0,0,logical,1
+bayesplot,ppc_stat_grouped,-1,0,0,"class<`gg`, `ggplot`>",1
+bayesplot,ppc_stat_grouped,0,0,0,integer[],1
+bayesplot,ppc_stat_grouped,1,0,0,class<`matrix`>,1
+bayesplot,ppc_stat_grouped,1,0,1,"class<`matrix`, `ppd`>",1
+bayesplot,ppc_stat_grouped,2,0,0,class<`factor`>,1
+bayesplot,ppc_stat_grouped,2,0,1,integer[],1
+bayesplot,ppc_stat_grouped,3,0,0,character,1
+bayesplot,ppc_stat_grouped,4,0,0,...,1
+bayesplot,ppc_stat_grouped,5,0,0,list<any>,1
+bayesplot,ppc_stat_grouped,6,0,0,null,1
+bayesplot,ppc_stat_grouped,7,0,0,null,1
+bayesplot,ppc_violin_grouped,-1,0,0,"class<`gg`, `ggplot`>",1
+bayesplot,ppc_violin_grouped,0,0,0,integer[],1
+bayesplot,ppc_violin_grouped,1,0,0,class<`matrix`>,1
+bayesplot,ppc_violin_grouped,2,0,0,class<`factor`>,1
+bayesplot,ppc_violin_grouped,3,0,0,...,1
+bayesplot,ppc_violin_grouped,4,0,0,double[],1
+bayesplot,ppc_violin_grouped,5,0,0,double,1
+bayesplot,ppc_violin_grouped,6,0,0,double,1
+bayesplot,ppc_violin_grouped,7,0,0,character[],1
+bayesplot,prepare_custom_colors,-1,0,0,list<character>,1
+bayesplot,prepare_custom_colors,0,0,0,character[],1
+bayesplot,prepare_mcmc_array,-1,0,0,"class<`array`, `mcmc_array`>",1
+bayesplot,prepare_mcmc_array,0,0,0,class<`array`>,1
+bayesplot,prepare_mcmc_array,0,0,1,class<`matrix`>,1
+bayesplot,prepare_mcmc_array,1,0,0,character[],1
+bayesplot,prepare_mcmc_array,2,0,0,character[],1
+bayesplot,prepare_mcmc_array,3,0,0,list<any>,1
+bayesplot,prepare_mcmc_array,3,0,1,character,1
+bayesplot,reduce_legend_spacing,-1,0,0,"class<`gg`, `theme`>",1
+bayesplot,reduce_legend_spacing,0,0,0,double,1
+bayesplot,rename_transformed_pars,-1,0,0,character[],1
+bayesplot,rename_transformed_pars,0,0,0,character[],1
+bayesplot,rename_transformed_pars,1,0,0,list<any>,1
+bayesplot,[.rhat,-1,0,0,"class<`numeric`, `rhat`>",1
+bayesplot,[.rhat,0,0,0,"class<`numeric`, `rhat`>",1
+bayesplot,[.rhat,1,0,0,integer[],1
+bayesplot,[.rhat,2,0,0,any,1
+bayesplot,[.rhat,3,0,0,logical,1
+bayesplot,[.rhat,4,0,0,...,1
+bayesplot,scale_color_diagnostic,-1,0,0,"class<`Scale`, `ScaleDiscrete`, `gg`, `ggproto`>",1
+bayesplot,scale_color_diagnostic,0,0,0,character,1
+bayesplot,scale_color_ppc_dist,-1,0,0,"class<`Scale`, `ScaleDiscrete`, `gg`, `ggproto`>",1
+bayesplot,scale_color_ppc_dist,0,0,0,null,1
+bayesplot,scale_color_ppc_dist,1,0,0,null,1
+bayesplot,scale_color_ppc_dist,2,0,0,null,1
+bayesplot,scale_fill_diagnostic,-1,0,0,"class<`Scale`, `ScaleDiscrete`, `gg`, `ggproto`>",1
+bayesplot,scale_fill_diagnostic,0,0,0,character,1
+bayesplot,scale_fill_ppc_dist,-1,0,0,"class<`Scale`, `ScaleDiscrete`, `gg`, `ggproto`>",1
+bayesplot,scale_fill_ppc_dist,0,0,0,null,1
+bayesplot,scale_fill_ppc_dist,1,0,0,^character[],1
+bayesplot,scale_fill_ppc_dist,1,0,1,null,1
+bayesplot,scale_fill_ppc_dist,2,0,0,null,1
+bayesplot,scheme_from_string,-1,0,0,list<character>,1
+bayesplot,scheme_from_string,0,0,0,character,1
+bayesplot,scheme_level_names,-1,0,0,character[],1
+bayesplot,select_parameters,-1,0,0,character[],1
+bayesplot,select_parameters,0,0,0,character[],1
+bayesplot,select_parameters,1,0,0,character[],1
+bayesplot,select_parameters,2,0,0,character[],1
+bayesplot,set_hist_aes,-1,0,0,class<`uneval`>,1
+bayesplot,set_hist_aes,0,0,0,logical,1
+bayesplot,set_hist_aes,1,0,0,...,1
+bayesplot,set_mcmc_dimnames,-1,0,0,"class<`array`, `mcmc_array`>",1
+bayesplot,set_mcmc_dimnames,0,0,0,class<`array`>,1
+bayesplot,set_mcmc_dimnames,1,0,0,character[],1
+bayesplot,set_rhat_breaks,-1,0,0,double[],1
+bayesplot,set_rhat_breaks,0,0,0,double[],1
+bayesplot,space_legend_keys,-1,0,0,"class<`gg`, `theme`>",1
+bayesplot,space_legend_keys,0,0,0,double,1
+bayesplot,space_legend_keys,1,0,0,character,1
+bayesplot,stat_legend_title,-1,0,0,class<`call`>,1
+bayesplot,stat_legend_title,-1,0,1,null,1
+bayesplot,stat_legend_title,0,0,0,character,1
+bayesplot,stat_legend_title,0,0,1,class<`function`>,1
+bayesplot,stat_legend_title,1,0,0,any,1
+bayesplot,suggested_package,-1,0,0,logical,1
+bayesplot,suggested_package,0,0,0,character,1
+bayesplot,suggested_package,1,0,0,null,1
+bayesplot,theme_default,-1,0,0,"class<`gg`, `theme`>",1
+bayesplot,theme_default,0,0,0,double,1
+bayesplot,theme_default,1,0,0,character,1
+bayesplot,Ty_label,-1,0,0,expression,1
+bayesplot,Tyrep_label,-1,0,0,expression,1
+bayesplot,validate_group,-1,0,0,class<`factor`>,1
+bayesplot,validate_group,0,0,0,class<`factor`>,1
+bayesplot,validate_group,0,0,1,integer[],1
+bayesplot,validate_group,1,0,0,double[],1
+bayesplot,validate_neff_ratio,-1,0,0,double[],1
+bayesplot,validate_neff_ratio,0,0,0,double[],1
+bayesplot,validate_rhat,-1,0,0,"class<`numeric`, `rhat`>",1
+bayesplot,validate_rhat,0,0,0,"class<`numeric`, `rhat`>",1
+bayesplot,validate_transformations,-1,0,0,list<class<`function`>>,1
+bayesplot,validate_transformations,0,0,0,list<character>,1
+bayesplot,validate_transformations,0,0,1,list<character | class<`function`>>,1
+bayesplot,validate_transformations,0,0,2,list<class<`function`>>,1
+bayesplot,validate_transformations,1,0,0,character[],1
+bayesplot,validate_x,-1,0,0,double[],1
+bayesplot,validate_x,0,0,0,double[],1
+bayesplot,validate_x,0,0,1,null,1
+bayesplot,validate_x,1,0,0,double[],1
+bayesplot,validate_x,2,0,0,logical,1
+bayesplot,validate_y,-1,0,0,double[],1
+bayesplot,validate_y,0,0,0,double[],1
+bayesplot,validate_yrep,-1,0,0,class<`matrix`>,1
+bayesplot,validate_yrep,0,0,0,class<`matrix`>,1
+bayesplot,validate_yrep,0,0,1,"class<`matrix`, `ppd`>",1
+bayesplot,validate_yrep,1,0,0,double[],1
+bayesplot,vline_0,-1,0,0,"class<`Layer`, `LayerInstance`, `gg`, `ggproto`>",1
+bayesplot,vline_0,0,0,0,...,1
+bayesplot,vline_0,1,0,0,logical,1
+bayesplot,vline_at,-1,0,0,"class<`Layer`, `LayerInstance`, `gg`, `ggproto`>",1
+bayesplot,vline_at,0,0,0,class<`matrix`>,1
+bayesplot,vline_at,0,0,1,double[],1
+bayesplot,vline_at,1,0,0,any,1
+bayesplot,vline_at,2,0,0,...,1
+bayesplot,vline_at,3,0,0,logical,1
+bayesplot,xaxis_text,-1,0,0,"class<`gg`, `theme`>",1
+bayesplot,xaxis_text,0,0,0,logical,1
+bayesplot,xaxis_text,1,0,0,...,1
+bayesplot,xaxis_ticks,-1,0,0,"class<`gg`, `theme`>",1
+bayesplot,xaxis_ticks,0,0,0,logical,1
+bayesplot,xaxis_ticks,1,0,0,...,1
+bayesplot,xaxis_title,-1,0,0,"class<`gg`, `theme`>",1
+bayesplot,xaxis_title,-1,0,1,class<`labels`>,1
+bayesplot,xaxis_title,0,0,0,logical,1
+bayesplot,xaxis_title,1,0,0,...,1
+bayesplot,yaxis_text,-1,0,0,"class<`gg`, `theme`>",1
+bayesplot,yaxis_text,0,0,0,logical,1
+bayesplot,yaxis_text,1,0,0,...,1
+bayesplot,yaxis_ticks,-1,0,0,"class<`gg`, `theme`>",1
+bayesplot,yaxis_ticks,0,0,0,logical,1
+bayesplot,yaxis_ticks,1,0,0,...,1
+bayesplot,yaxis_title,-1,0,0,"class<`gg`, `theme`>",1
+bayesplot,yaxis_title,-1,0,1,class<`labels`>,1
+bayesplot,yaxis_title,0,0,0,logical,1
+bayesplot,yaxis_title,1,0,0,...,1
+bayesplot,y_label,-1,0,0,expression,1
+bayesplot,yrep_avg_label,-1,0,0,expression,1
+bayesplot,yrep_label,-1,0,0,expression,1
+bayesplot,zero_pad_int,-1,0,0,character[],1
+bayesplot,zero_pad_int,0,0,0,integer[],1
+bbmle,AICc,-1,0,0,double,1
+bbmle,AICc,0,0,0,class<`logLik`>,1
+bbmle,AICc,0,0,1,"class<`glm`, `lm`>",1
+bbmle,AICc,0,0,2,class<`mle2`>,1
+bbmle,AICc,1,0,0,...,1
+bbmle,AICc,2,0,0,integer,1
+bbmle,AICc,3,0,0,double,1
+bbmle,AICc,-1,1,0,double,1
+bbmle,AICc,0,1,0,class<`logLik`>,1
+bbmle,AICc,1,1,0,...,1
+bbmle,AICc,2,1,0,integer,1
+bbmle,AICc,3,1,0,double,1
+bbmle,AICctab,-1,0,0,class<`ICtab`>,1
+bbmle,AICctab,0,0,0,...,1
+bbmle,AICctab,1,0,0,any,1
+bbmle,AICtab,-1,0,0,class<`ICtab`>,1
+bbmle,AICtab,0,0,0,...,1
+bbmle,AICtab,1,0,0,any,1
+bbmle,anova,-1,0,0,class<`anova`>,1
+bbmle,anova,0,0,0,class<`mle2`>,1
+bbmle,anova,1,0,0,...,1
+bbmle,as.data.frame.profile.mle2,-1,0,0,class<`data.frame`>,1
+bbmle,as.data.frame.profile.mle2,0,0,0,class<`profile.mle2`>,1
+bbmle,as.data.frame.profile.mle2,1,0,0,null,1
+bbmle,as.data.frame.profile.mle2,2,0,0,logical,1
+bbmle,as.data.frame.profile.mle2,3,0,0,...,1
+bbmle,calc_mle2_function,-1,0,0,list<any>,1
+bbmle,calc_mle2_function,0,0,0,class<`formula`>,1
+bbmle,calc_mle2_function,1,0,0,null,1
+bbmle,calc_mle2_function,1,0,1,list<class<`formula`>>,1
+bbmle,calc_mle2_function,2,0,0,any,1
+bbmle,calc_mle2_function,3,0,0,list<double[]>,1
+bbmle,calc_mle2_function,3,0,1,list<double | null>,1
+bbmle,calc_mle2_function,4,0,0,null,1
+bbmle,calc_mle2_function,5,0,0,logical,1
+bbmle,calc_mle2_function,6,0,0,class<`data.frame`>,1
+bbmle,calc_mle2_function,7,0,0,any,1
+bbmle,call.to.char,-1,0,0,character,1
+bbmle,call.to.char,0,0,0,class<`call`>,1
+bbmle,call.to.char,0,0,1,class<`formula`>,1
+bbmle,call.to.char,0,0,2,class<`name`>,1
+bbmle,call.to.char,0,0,3,double,1
+bbmle,dnorm_n,-1,0,0,double[],1
+bbmle,dnorm_n,0,0,0,double[],1
+bbmle,dnorm_n,1,0,0,double,1
+bbmle,dnorm_n,2,0,0,logical,1
+bbmle,formula,-1,0,0,class<`formula`>,1
+bbmle,formula,0,0,0,class<`mle2`>,1
+bbmle,formula,1,0,0,...,1
+bbmle,get_all_trange,-1,0,0,class<`matrix`>,1
+bbmle,get_all_trange,0,0,0,double[],1
+bbmle,get_all_trange,1,0,0,class<`function`>,1
+bbmle,get_all_trange,2,0,0,double[],1
+bbmle,get_all_trange,3,0,0,double[],1
+bbmle,get_all_trange,4,0,0,double,1
+bbmle,get_all_trange,5,0,0,...,1
+bbmle,get.mnames,-1,0,0,character[],1
+bbmle,get.mnames,0,0,0,class<`call`>,1
+bbmle,gfun,-1,0,0,class<`matrix`>,1
+bbmle,gfun,-1,0,1,double[],1
+bbmle,gfun,0,0,0,class<`mle2`>,1
+bbmle,gfun,1,0,0,class<`data.frame`>,1
+bbmle,gfun,1,0,1,null,1
+bbmle,gfun,1,0,2,list<class<`factor`> | double[]>,1
+bbmle,gfun,1,0,3,character,1
+bbmle,gfun,2,0,0,character[],1
+bbmle,gfun,3,0,0,any,1
+bbmle,gfun,4,0,0,character,1
+bbmle,ICtab,-1,0,0,class<`ICtab`>,1
+bbmle,ICtab,0,0,0,...,1
+bbmle,ICtab,1,0,0,character,1
+bbmle,ICtab,2,0,0,logical,1
+bbmle,ICtab,3,0,0,logical,1
+bbmle,ICtab,4,0,0,logical,1
+bbmle,ICtab,5,0,0,logical,1
+bbmle,ICtab,6,0,0,logical,1
+bbmle,ICtab,7,0,0,double,1
+bbmle,ICtab,7,0,1,null,1
+bbmle,mkpar,-1,0,0,double[],1
+bbmle,mkpar,0,0,0,double[],1
+bbmle,mkpar,1,0,0,double[],1
+bbmle,mkpar,2,0,0,integer[],1
+bbmle,mle2,-1,0,0,any,1
+bbmle,mle2,0,0,0,class<`formula`>,1
+bbmle,mle2,0,0,1,class<`function`>,1
+bbmle,mle2,1,0,0,any,1
+bbmle,mle2,2,0,0,any,1
+bbmle,mle2,3,0,0,any,1
+bbmle,mle2,4,0,0,null,1
+bbmle,mle2,4,0,1,list<double>,1
+bbmle,mle2,5,0,0,class<`data.frame`>,1
+bbmle,mle2,5,0,1,null,1
+bbmle,mle2,5,0,2,list<double[]>,1
+bbmle,mle2,5,0,3,list<integer[] | double>,1
+bbmle,mle2,6,0,0,null,1
+bbmle,mle2,7,0,0,logical,1
+bbmle,mle2.options,-1,0,0,character,1
+bbmle,mle2.options,0,0,0,...,1
+bbmle,namedrop,-1,0,0,double[],1
+bbmle,namedrop,-1,0,1,list<any>,1
+bbmle,namedrop,-1,0,2,null,1
+bbmle,namedrop,-1,0,3,pairlist,1
+bbmle,namedrop,0,0,0,double[],1
+bbmle,namedrop,0,0,1,list<any>,1
+bbmle,namedrop,0,0,2,null,1
+bbmle,namedrop,0,0,3,pairlist,1
+bbmle,parnames,-1,0,0,character[],1
+bbmle,parnames,-1,0,1,null,1
+bbmle,parnames,0,0,0,class<`function`>,1
+bbmle,parnames<-,-1,0,0,class<`function`>,1
+bbmle,parnames<-,0,0,0,class<`function`>,1
+bbmle,parnames<-,1,0,0,character[],1
+bbmle,plot.slice,-1,0,0,class<`trellis`>,1
+bbmle,plot.slice,0,0,0,class<`slice`>,1
+bbmle,plot.slice,1,0,0,...,1
+bbmle,pop_pred_samp,-1,0,0,class<`matrix`>,1
+bbmle,pop_pred_samp,0,0,0,class<`mle2`>,1
+bbmle,pop_pred_samp,1,0,0,double,1
+bbmle,pop_pred_samp,2,0,0,any,1
+bbmle,pop_pred_samp,3,0,0,logical,1
+bbmle,pop_pred_samp,4,0,0,logical,1
+bbmle,pop_pred_samp,5,0,0,logical,1
+bbmle,pop_pred_samp,6,0,0,null,1
+bbmle,pop_pred_samp,7,0,0,double,1
+bbmle,predict,-1,0,0,class<`matrix`>,1
+bbmle,predict,-1,0,1,double,1
+bbmle,predict,0,0,0,class<`mle2`>,1
+bbmle,predict,1,0,0,...,1
+bbmle,print.ICtab,-1,0,0,class<`matrix`>,1
+bbmle,print.ICtab,0,0,0,class<`ICtab`>,1
+bbmle,print.ICtab,1,0,0,...,1
+bbmle,print.ICtab,2,0,0,double,1
+bbmle,proffun,-1,0,0,class<`mle2`>,1
+bbmle,proffun,-1,0,1,list<class<`summary.mle2`> | list<class<`data.frame`> | list<character>>>,1
+bbmle,proffun,-1,0,2,list<class<`summary.mle2`> | list<class<`data.frame`> | null | list<character>>>,1
+bbmle,proffun,0,0,0,class<`mle2`>,1
+bbmle,proffun,1,0,0,integer[],1
+bbmle,proffun,1,0,1,character,1
+bbmle,proffun,2,0,0,double,1
+bbmle,proffun,3,0,0,double,1
+bbmle,proffun,4,0,0,double,1
+bbmle,proffun,5,0,0,double,1
+bbmle,proffun,6,0,0,logical,1
+bbmle,proffun,7,0,0,logical,1
+bbmle,qAIC,-1,0,0,double,1
+bbmle,qAIC,0,0,0,"class<`glm`, `lm`>",1
+bbmle,qAIC,1,0,0,...,1
+bbmle,qAIC,2,0,0,double,1
+bbmle,qAIC,3,0,0,double,1
+bbmle,qAIC,-1,1,0,double,1
+bbmle,qAIC,0,1,0,"class<`glm`, `lm`>",1
+bbmle,qAIC,0,1,1,class<`logLik`>,1
+bbmle,qAIC,1,1,0,...,1
+bbmle,qAIC,2,1,0,double,1
+bbmle,qAIC,3,1,0,double,1
+bbmle,qAIC,-1,2,0,double,1
+bbmle,qAIC,0,2,0,class<`logLik`>,1
+bbmle,qAIC,1,2,0,...,1
+bbmle,qAIC,2,2,0,double,1
+bbmle,qAIC,3,2,0,double,1
+bbmle,qAICc,-1,0,0,double,1
+bbmle,qAICc,-1,0,1,class<`data.frame`>,1
+bbmle,qAICc,0,0,0,"class<`glm`, `lm`>",1
+bbmle,qAICc,0,0,1,class<`mle2`>,1
+bbmle,qAICc,0,0,2,class<`logLik`>,1
+bbmle,qAICc,1,0,0,...,1
+bbmle,qAICc,2,0,0,double,1
+bbmle,qAICc,3,0,0,double,1
+bbmle,qAICc,4,0,0,double,1
+bbmle,qAICc,-1,1,0,double,1
+bbmle,qAICc,0,1,0,"class<`glm`, `lm`>",1
+bbmle,qAICc,1,1,0,...,1
+bbmle,qAICc,2,1,0,double,1
+bbmle,qAICc,3,1,0,double,1
+bbmle,qAICc,4,1,0,double,1
+bbmle,qAICc,-1,2,0,double,1
+bbmle,qAICc,-1,2,1,class<`data.frame`>,1
+bbmle,qAICc,0,2,0,class<`mle2`>,1
+bbmle,qAICc,1,2,0,...,1
+bbmle,qAICc,2,2,0,double,1
+bbmle,qAICc,3,2,0,double,1
+bbmle,qAICc,4,2,0,double,1
+bbmle,qAICc,-1,3,0,double,1
+bbmle,qAICc,0,3,0,class<`logLik`>,1
+bbmle,qAICc,1,3,0,...,1
+bbmle,qAICc,2,3,0,double,1
+bbmle,qAICc,3,3,0,double,1
+bbmle,qAICc,4,3,0,double,1
+bbmle,relist2,-1,0,0,list<any>,1
+bbmle,relist2,0,0,0,double[],1
+bbmle,relist2,1,0,0,list<any>,1
+bbmle,relist2,1,0,1,double[],1
+bbmle,residuals,-1,0,0,double[],1
+bbmle,residuals,0,0,0,class<`mle2`>,1
+bbmle,residuals,1,0,0,...,1
+bbmle,sbinom,-1,0,0,list<character | double | null>,1
+bbmle,sbinom,-1,0,1,list<character | null>,1
+bbmle,sbinom,0,0,0,double,1
+bbmle,sbinom,0,0,1,null,1
+bbmle,sbinom,1,0,0,double,1
+bbmle,sbinom,1,0,1,null,1
+bbmle,simulate,-1,0,0,double[],1
+bbmle,simulate,0,0,0,class<`mle2`>,1
+bbmle,simulate,1,0,0,double,1
+bbmle,simulate,2,0,0,null,1
+bbmle,simulate,3,0,0,...,1
+bbmle,slice0,-1,0,0,class<`slice`>,1
+bbmle,slice0,0,0,0,double[],1
+bbmle,slice0,1,0,0,class<`function`>,1
+bbmle,slice0,2,0,0,double,1
+bbmle,slice0,3,0,0,double[],1
+bbmle,slice0,3,0,1,null,1
+bbmle,slice0,4,0,0,...,1
+bbmle,slice1D,-1,0,0,class<`slice`>,1
+bbmle,slice1D,0,0,0,double[],1
+bbmle,slice1D,1,0,0,class<`function`>,1
+bbmle,slice1D,2,0,0,double,1
+bbmle,slice1D,3,0,0,double,1
+bbmle,slice1D,4,0,0,double,1
+bbmle,slice1D,5,0,0,logical,1
+bbmle,slice1D,6,0,0,null,1
+bbmle,slice1D,7,0,0,...,1
+bbmle,slice2D,-1,0,0,class<`slice`>,1
+bbmle,slice2D,0,0,0,double[],1
+bbmle,slice2D,1,0,0,class<`function`>,1
+bbmle,slice2D,2,0,0,double,1
+bbmle,slice2D,3,0,0,double,1
+bbmle,slice2D,4,0,0,double,1
+bbmle,slice2D,5,0,0,double,1
+bbmle,slice2D,6,0,0,logical,1
+bbmle,slice2D,7,0,0,null,1
+bbmle,slice.mle2,-1,0,0,class<`slice`>,1
+bbmle,slice.mle2,0,0,0,class<`mle2`>,1
+bbmle,slice.mle2,1,0,0,...,1
+bbmle,slices_apply,-1,0,0,list<list<null | class<`data.frame`>>>,1
+bbmle,slices_apply,0,0,0,list<list<null | class<`data.frame`>>>,1
+bbmle,slices_apply,1,0,0,class<`function`>,1
+bbmle,slices_apply,2,0,0,...,1
+bbmle,slicetrans,-1,0,0,class<`slice`>,1
+bbmle,slicetrans,0,0,0,double[],1
+bbmle,slicetrans,1,0,0,double[],1
+bbmle,slicetrans,2,0,0,class<`function`>,1
+bbmle,slicetrans,3,0,0,double,1
+bbmle,slicetrans,4,0,0,double,1
+bbmle,slicetrans,5,0,0,double,1
+bbmle,slicetrans,6,0,0,double,1
+bbmle,snbinom,-1,0,0,list<any>,1
+bbmle,snbinom,0,0,0,double,1
+bbmle,snbinom,1,0,0,any,1
+bbmle,snbinom,2,0,0,class<`matrix`>,1
+bbmle,snbinom,2,0,1,double,1
+bbmle,snorm,-1,0,0,list<character | class<`matrix`> | double>,1
+bbmle,snorm,0,0,0,class<`matrix`>,1
+bbmle,snorm,1,0,0,double,1
+bbmle,splom.slice,-1,0,0,class<`trellis`>,1
+bbmle,splom.slice,0,0,0,class<`slice`>,1
+bbmle,splom.slice,1,0,0,any,1
+bbmle,splom.slice,2,0,0,logical,1
+bbmle,splom.slice,3,0,0,null,1
+bbmle,splom.slice,4,0,0,null,1
+bbmle,splom.slice,5,0,0,null,1
+bbmle,splom.slice,6,0,0,double,1
+bbmle,splom.slice,7,0,0,logical,1
+bbmle,spois,-1,0,0,list<character | double | null>,1
+bbmle,spois,0,0,0,double,1
+bbmle,strwrapx,-1,0,0,character[],1
+bbmle,strwrapx,0,0,0,character[],1
+bbmle,strwrapx,1,0,0,integer,1
+bbmle,strwrapx,2,0,0,double,1
+bbmle,strwrapx,3,0,0,double,1
+bbmle,strwrapx,4,0,0,character,1
+bbmle,strwrapx,5,0,0,logical,1
+bbmle,strwrapx,6,0,0,character,1
+bbmle,strwrapx,7,0,0,character,1
+bbmle,xyplot.slice,-1,0,0,class<`trellis`>,1
+bbmle,xyplot.slice,0,0,0,class<`slice`>,1
+bbmle,xyplot.slice,1,0,0,any,1
+bbmle,xyplot.slice,2,0,0,character,1
+bbmle,xyplot.slice,3,0,0,logical,1
+bbmle,xyplot.slice,4,0,0,...,1
+bdsmatrix,as.matrix.bdsmatrix,-1,0,0,class<`matrix`>,1
+bdsmatrix,as.matrix.bdsmatrix,0,0,0,class<`bdsmatrix`>,1
+bdsmatrix,as.matrix.bdsmatrix,1,0,0,...,1
+bdsmatrix,as.matrix.gchol,-1,0,0,class<`matrix`>,1
+bdsmatrix,as.matrix.gchol,0,0,0,class<`gchol`>,1
+bdsmatrix,as.matrix.gchol,1,0,0,logical,1
+bdsmatrix,as.matrix.gchol,2,0,0,...,1
+bdsmatrix,as.matrix.gchol.bdsmatrix,-1,0,0,class<`matrix`>,1
+bdsmatrix,as.matrix.gchol.bdsmatrix,0,0,0,class<`gchol.bdsmatrix`>,1
+bdsmatrix,as.matrix.gchol.bdsmatrix,1,0,0,logical,1
+bdsmatrix,as.matrix.gchol.bdsmatrix,2,0,0,...,1
+bdsmatrix,backsolve,-1,0,0,class<`matrix`>,1
+bdsmatrix,backsolve,0,0,0,class<`gchol`>,1
+bdsmatrix,backsolve,0,0,1,class<`gchol.bdsmatrix`>,1
+bdsmatrix,backsolve,0,0,2,class<`matrix`>,1
+bdsmatrix,backsolve,1,0,0,...,1
+bdsmatrix,backsolve,-1,1,0,class<`matrix`>,1
+bdsmatrix,backsolve,0,1,0,class<`gchol`>,1
+bdsmatrix,backsolve,1,1,0,...,1
+bdsmatrix,backsolve,-1,2,0,class<`matrix`>,1
+bdsmatrix,backsolve,0,2,0,class<`gchol.bdsmatrix`>,1
+bdsmatrix,backsolve,1,2,0,...,1
+bdsmatrix,backsolve,-1,3,0,class<`matrix`>,1
+bdsmatrix,backsolve,0,3,0,class<`matrix`>,1
+bdsmatrix,backsolve,1,3,0,...,1
+bdsmatrix,bdsBlock,-1,0,0,class<`bdsmatrix`>,1
+bdsmatrix,bdsBlock,0,0,0,character[],1
+bdsmatrix,bdsBlock,1,0,0,double[],1
+bdsmatrix,bdsI,-1,0,0,class<`bdsmatrix`>,1
+bdsmatrix,bdsI,0,0,0,integer[],1
+bdsmatrix,bdsI,1,0,0,any,1
+bdsmatrix,bdsmatrix,-1,0,0,class<`bdsmatrix`>,1
+bdsmatrix,bdsmatrix,0,0,0,double[],1
+bdsmatrix,bdsmatrix,1,0,0,double[],1
+bdsmatrix,bdsmatrix,2,0,0,any,1
+bdsmatrix,bdsmatrix,3,0,0,list<null | character[]>,1
+bdsmatrix,bdsmatrix,3,0,1,null,1
+bdsmatrix,bdsmatrix,3,0,2,list<character[]>,1
+bdsmatrix,bdsmatrix,3,0,3,list<integer[]>,1
+bdsmatrix,bdsmatrix.reconcile,-1,0,0,class<`bdsmatrix`>,1
+bdsmatrix,bdsmatrix.reconcile,-1,0,1,list<class<`bdsmatrix`>>,1
+bdsmatrix,bdsmatrix.reconcile,0,0,0,class<`function`>,1
+bdsmatrix,bdsmatrix.reconcile,0,0,1,list<class<`matrix`> | class<`function`> | class<`bdsmatrix`>>,1
+bdsmatrix,bdsmatrix.reconcile,0,0,2,list<class<`bdsmatrix`>>,1
+bdsmatrix,bdsmatrix.reconcile,0,0,3,list<class<`bdsmatrix`> | class<`function`>>,1
+bdsmatrix,bdsmatrix.reconcile,0,0,4,list<class<`bdsmatrix`> | class<`matrix`>>,1
+bdsmatrix,bdsmatrix.reconcile,1,0,0,character[],1
+bdsmatrix,diag,-1,0,0,double[],1
+bdsmatrix,diag,0,0,0,class<`bdsmatrix`>,1
+bdsmatrix,diag,1,0,0,any,1
+bdsmatrix,diag,2,0,0,any,1
+bdsmatrix,diag,3,0,0,logical,1
+bdsmatrix,diag,-1,1,0,double[],1
+bdsmatrix,diag,0,1,0,class<`gchol.bdsmatrix`>,1
+bdsmatrix,diag,1,1,0,any,1
+bdsmatrix,diag,2,1,0,any,1
+bdsmatrix,diag,3,1,0,logical,1
+bdsmatrix,diag,-1,2,0,double[],1
+bdsmatrix,diag,0,2,0,class<`gchol`>,1
+bdsmatrix,diag,1,2,0,any,1
+bdsmatrix,diag,2,2,0,any,1
+bdsmatrix,diag,3,2,0,logical,1
+bdsmatrix,diag<-,-1,0,0,class<`bdsmatrix`>,1
+bdsmatrix,diag<-,0,0,0,class<`bdsmatrix`>,1
+bdsmatrix,diag<-,1,0,0,double[],1
+bdsmatrix,gchol,-1,0,0,class<`gchol.bdsmatrix`>,1
+bdsmatrix,gchol,0,0,0,class<`bdsmatrix`>,1
+bdsmatrix,gchol,1,0,0,double,1
+bdsmatrix,gchol,-1,1,0,class<`gchol`>,1
+bdsmatrix,gchol,0,1,0,class<`matrix`>,1
+bdsmatrix,gchol,1,1,0,double,1
+bdsmatrix,gchol,-1,2,0,class<`gchol`>,1
+bdsmatrix,gchol,-1,2,1,class<`gchol.bdsmatrix`>,1
+bdsmatrix,gchol,0,2,0,class<`matrix`>,1
+bdsmatrix,gchol,0,2,1,class<`bdsmatrix`>,1
+bdsmatrix,gchol,1,2,0,double,1
+bdsmatrix,solve.bdsmatrix,-1,0,0,class<`matrix`>,1
+bdsmatrix,solve.bdsmatrix,-1,0,1,double[],1
+bdsmatrix,solve.bdsmatrix,0,0,0,class<`bdsmatrix`>,1
+bdsmatrix,solve.bdsmatrix,1,0,0,any,1
+bdsmatrix,solve.bdsmatrix,2,0,0,logical,1
+bdsmatrix,solve.bdsmatrix,3,0,0,double,1
+bdsmatrix,solve.bdsmatrix,4,0,0,...,1
+bdsmatrix,solve.gchol,-1,0,0,class<`matrix`>,1
+bdsmatrix,solve.gchol,-1,0,1,double[],1
+bdsmatrix,solve.gchol,0,0,0,class<`gchol`>,1
+bdsmatrix,solve.gchol,1,0,0,any,1
+bdsmatrix,solve.gchol,2,0,0,logical,1
+bdsmatrix,solve.gchol,3,0,0,...,1
+bdsmatrix,solve.gchol.bdsmatrix,-1,0,0,class<`bdsmatrix`>,1
+bdsmatrix,solve.gchol.bdsmatrix,-1,0,1,class<`gchol.bdsmatrix`>,1
+bdsmatrix,solve.gchol.bdsmatrix,-1,0,2,class<`matrix`>,1
+bdsmatrix,solve.gchol.bdsmatrix,-1,0,3,double[],1
+bdsmatrix,solve.gchol.bdsmatrix,0,0,0,class<`gchol.bdsmatrix`>,1
+bdsmatrix,solve.gchol.bdsmatrix,1,0,0,any,1
+bdsmatrix,solve.gchol.bdsmatrix,2,0,0,logical,1
+bdsmatrix,solve.gchol.bdsmatrix,3,0,0,...,1
+bdsmatrix,unique.bdsmatrix,-1,0,0,double[],1
+bdsmatrix,unique.bdsmatrix,0,0,0,class<`bdsmatrix`>,1
+bdsmatrix,unique.bdsmatrix,1,0,0,logical,1
+bdsmatrix,unique.bdsmatrix,2,0,0,...,1
+behavr,all_identical,-1,0,0,logical,1
+behavr,all_identical,0,0,0,list<character[]>,1
+behavr,behavr,-1,0,0,"class<`behavr`, `data.frame`, `data.table`>",1
+behavr,behavr,0,0,0,"class<`data.frame`, `data.table`>",1
+behavr,behavr,1,0,0,"class<`data.frame`, `data.table`>",1
+behavr,[.behavr,-1,0,0,"class<`behavr`, `data.frame`, `data.table`>",1
+behavr,[.behavr,-1,0,1,"class<`data.frame`, `data.table`>",1
+behavr,[.behavr,-1,0,2,double,1
+behavr,[.behavr,0,0,0,"class<`behavr`, `data.frame`, `data.table`>",1
+behavr,[.behavr,1,0,0,...,1
+behavr,[.behavr,2,0,0,logical,1
+behavr,[.behavr,3,0,0,logical,1
+behavr,bin_apply,-1,0,0,"class<`data.frame`, `data.table`>",1
+behavr,bin_apply,0,0,0,"class<`behavr`, `data.frame`, `data.table`>",1
+behavr,bin_apply,1,0,0,any,1
+behavr,bin_apply,2,0,0,character,1
+behavr,bin_apply,2,0,1,class<`function`>,1
+behavr,bin_apply,3,0,0,double,1
+behavr,bin_apply,4,0,0,null,1
+behavr,bin_apply,4,0,1,double,1
+behavr,bin_apply,5,0,0,class<`function`>,1
+behavr,bin_apply,6,0,0,...,1
+behavr,bin_apply_all,-1,0,0,"class<`behavr`, `data.frame`, `data.table`>",1
+behavr,bin_apply_all,0,0,0,"class<`behavr`, `data.frame`, `data.table`>",1
+behavr,bin_apply_all,1,0,0,...,1
+behavr,bind_behavr_list,-1,0,0,"class<`behavr`, `data.frame`, `data.table`>",1
+behavr,bind_behavr_list,0,0,0,"list<class<`behavr`, `data.frame`, `data.table`>>",1
+behavr,bin_var,-1,0,0,double[],1
+behavr,bin_var,0,0,0,double[],1
+behavr,bin_var,1,0,0,double,1
+behavr,bin_var,2,0,0,double,1
+behavr,bin_var,2,0,1,null,1
+behavr,check_conform,-1,0,0,null,1
+behavr,check_conform,0,0,0,"class<`behavr`, `data.frame`, `data.table`>",1
+behavr,check_conform,0,0,1,"class<`data.frame`, `data.table`>",1
+behavr,check_conform,1,0,0,null,1
+behavr,check_conform,1,0,1,"class<`data.frame`, `data.table`>",1
+behavr,days,-1,0,0,double,1
+behavr,days,0,0,0,double,1
+behavr,is.behavr,-1,0,0,logical,1
+behavr,is.behavr,0,0,0,"class<`behavr`, `data.frame`, `data.table`>",1
+behavr,meta,-1,0,0,"class<`data.frame`, `data.table`>",1
+behavr,meta,0,0,0,"class<`behavr`, `data.frame`, `data.table`>",1
+behavr,mins,-1,0,0,double,1
+behavr,mins,0,0,0,double,1
+behavr,print.behavr,-1,0,0,"class<`behavr`, `data.frame`, `data.table`>",1
+behavr,print.behavr,0,0,0,"class<`behavr`, `data.frame`, `data.table`>",1
+behavr,print.behavr,1,0,0,...,1
+behavr,rejoin,-1,0,0,"class<`data.frame`, `data.table`>",1
+behavr,rejoin,0,0,0,"class<`behavr`, `data.frame`, `data.table`>",1
+behavr,setbehavr,-1,0,0,"class<`behavr`, `data.frame`, `data.table`>",1
+behavr,setbehavr,0,0,0,"class<`data.frame`, `data.table`>",1
+behavr,setbehavr,0,0,1,"class<`behavr`, `data.frame`, `data.table`>",1
+behavr,setbehavr,1,0,0,"class<`data.frame`, `data.table`>",1
+behavr,setmeta,-1,0,0,"class<`behavr`, `data.frame`, `data.table`>",1
+behavr,setmeta,0,0,0,"class<`behavr`, `data.frame`, `data.table`>",1
+behavr,setmeta,1,0,0,"class<`data.frame`, `data.table`>",1
+behavr,simulate_animal_activity,-1,0,0,"class<`data.frame`, `data.table`>",1
+behavr,simulate_animal_activity,0,0,0,double,1
+behavr,simulate_animal_activity,1,0,0,double,1
+behavr,simulate_animal_activity,2,0,0,class<`function`>,1
+behavr,simulate_animal_activity,3,0,0,...,1
+behavr,sleepContiguous,-1,0,0,logical[],1
+behavr,sleepContiguous,0,0,0,logical[],1
+behavr,sleepContiguous,1,0,0,double,1
+behavr,sleepContiguous,2,0,0,double,1
+behavr,stitch_on,-1,0,0,"class<`behavr`, `data.frame`, `data.table`>",1
+behavr,stitch_on,0,0,0,"class<`behavr`, `data.frame`, `data.table`>",1
+behavr,stitch_on,1,0,0,character,1
+behavr,stitch_on,2,0,0,character,1
+behavr,stitch_on,3,0,0,logical,1
+behavr,stitch_on,4,0,0,character,1
+behavr,summary.behavr,-1,0,0,null,1
+behavr,summary.behavr,0,0,0,"class<`behavr`, `data.frame`, `data.table`>",1
+behavr,summary.behavr,1,0,0,logical,1
+behavr,summary.behavr,2,0,0,...,1
+behavr,toy_activity_data,-1,0,0,"class<`behavr`, `data.frame`, `data.table`>",1
+behavr,toy_activity_data,0,0,0,class<`data.frame`>,1
+behavr,toy_activity_data,0,0,1,null,1
+behavr,toy_activity_data,1,0,0,double,1
+behavr,toy_activity_data,2,0,0,double[],1
+behavr,toy_activity_data,3,0,0,double,1
+behavr,toy_activity_data,4,0,0,double,1
+behavr,toy_activity_data,5,0,0,...,1
+behavr,toy_dam_data,-1,0,0,"class<`behavr`, `data.frame`, `data.table`>",1
+behavr,toy_dam_data,0,0,0,...,1
+behavr,toy_ethoscope_data,-1,0,0,"class<`behavr`, `data.frame`, `data.table`>",1
+behavr,toy_ethoscope_data,0,0,0,...,1
+behavr,velocityFromMovement,-1,0,0,"class<`data.frame`, `data.table`>",1
+behavr,velocityFromMovement,0,0,0,"class<`behavr`, `data.frame`, `data.table`>",1
+behavr,velocityFromMovement,1,0,0,double,1
+behavr,within_data_table,-1,0,0,logical,1
+behavr,xmv,-1,0,0,character[],1
+behavr,xmv,-1,0,1,double[],1
+behavr,xmv,0,0,0,any,1
+betareg,betamix,-1,0,0,class<`betamix`>,1
+betareg,betamix,0,0,0,class<`formula`>,1
+betareg,betamix,1,0,0,any,1
+betareg,betamix,2,0,0,any,1
+betareg,betamix,3,0,0,any,1
+betareg,betamix,4,0,0,any,1
+betareg,betamix,5,0,0,any,1
+betareg,betamix,6,0,0,any,1
+betareg,betamix,7,0,0,character[],1
+betareg,betareg,-1,0,0,class<`betareg`>,1
+betareg,betareg,0,0,0,class<`formula`>,1
+betareg,betareg,1,0,0,class<`data.frame`>,1
+betareg,betareg,1,0,1,list<any>,1
+betareg,betareg,2,0,0,any,1
+betareg,betareg,3,0,0,any,1
+betareg,betareg,4,0,0,any,1
+betareg,betareg,5,0,0,any,1
+betareg,betareg,6,0,0,character[],1
+betareg,betareg,7,0,0,null,1
+betareg,betareg,7,0,1,character,1
+betareg,betareg.control,-1,0,0,list<character | double | null>,1
+betareg,betareg.control,0,0,0,logical,1
+betareg,betareg.control,1,0,0,character,1
+betareg,betareg.control,2,0,0,double,1
+betareg,betareg.control,3,0,0,logical,1
+betareg,betareg.control,4,0,0,logical,1
+betareg,betareg.control,5,0,0,null,1
+betareg,betareg.control,6,0,0,double,1
+betareg,betareg.control,7,0,0,double,1
+betareg,betareg.fit,-1,0,0,list<any>,1
+betareg,betareg.fit,0,0,0,class<`matrix`>,1
+betareg,betareg.fit,1,0,0,double[],1
+betareg,betareg.fit,1,0,1,class<`AsIs`>,1
+betareg,betareg.fit,2,0,0,class<`matrix`>,1
+betareg,betareg.fit,3,0,0,double[],1
+betareg,betareg.fit,3,0,1,null,1
+betareg,betareg.fit,4,0,0,list<double[]>,1
+betareg,betareg.fit,4,0,1,null,1
+betareg,betareg.fit,5,0,0,character,1
+betareg,betareg.fit,6,0,0,character,1
+betareg,betareg.fit,7,0,0,character,1
+betareg,betatree,-1,0,0,"class<`betatree`, `modelparty`, `party`>",1
+betareg,betatree,0,0,0,class<`formula`>,1
+betareg,betatree,1,0,0,class<`formula`>,1
+betareg,betatree,2,0,0,class<`data.frame`>,1
+betareg,betatree,3,0,0,null,1
+betareg,betatree,4,0,0,any,1
+betareg,betatree,5,0,0,any,1
+betareg,betatree,6,0,0,any,1
+betareg,betatree,7,0,0,any,1
+betareg,coef.betamix,-1,0,0,class<`matrix`>,1
+betareg,coef.betamix,0,0,0,class<`betamix`>,1
+betareg,coef.betamix,1,0,0,character[],1
+betareg,coef.betamix,2,0,0,...,1
+betareg,coef.betareg,-1,0,0,double[],1
+betareg,coef.betareg,0,0,0,list<any>,1
+betareg,coef.betareg,0,0,1,class<`betareg`>,1
+betareg,coef.betareg,1,0,0,any,1
+betareg,coef.betareg,2,0,0,null,1
+betareg,coef.betareg,2,0,1,logical,1
+betareg,coef.betareg,3,0,0,...,1
+betareg,coeftest.betareg,-1,0,0,class<`coeftest`>,1
+betareg,coeftest.betareg,0,0,0,class<`betareg`>,1
+betareg,coeftest.betareg,1,0,0,null,1
+betareg,coeftest.betareg,2,0,0,double,1
+betareg,coeftest.betareg,3,0,0,...,1
+betareg,cooks.distance.betareg,-1,0,0,double[],1
+betareg,cooks.distance.betareg,0,0,0,class<`betareg`>,1
+betareg,cooks.distance.betareg,1,0,0,...,1
+betareg,estfun.betareg,-1,0,0,class<`matrix`>,1
+betareg,estfun.betareg,0,0,0,class<`betareg`>,1
+betareg,estfun.betareg,1,0,0,null,1
+betareg,estfun.betareg,2,0,0,...,1
+betareg,extraComponent,-1,0,0,class<`extraComponent`>,1
+betareg,extraComponent,0,0,0,character,1
+betareg,extraComponent,1,0,0,double,1
+betareg,extraComponent,1,0,1,list<double>,1
+betareg,extraComponent,2,0,0,any,1
+betareg,extraComponent,3,0,0,character,1
+betareg,extraComponent,4,0,0,character,1
+betareg,FLXMRbeta,-1,0,0,class<`FLXMRbeta`>,1
+betareg,FLXMRbeta,0,0,0,class<`formula`>,1
+betareg,FLXMRbeta,1,0,0,class<`formula`>,1
+betareg,FLXMRbeta,2,0,0,any,1
+betareg,FLXMRbeta,3,0,0,character[],1
+betareg,FLXMRbeta,4,0,0,character,1
+betareg,FLXMRbeta,5,0,0,list<character | double | null>,1
+betareg,FLXMRbeta_extra,-1,0,0,class<`FLXMRbeta_extra`>,1
+betareg,FLXMRbeta_extra,0,0,0,class<`formula`>,1
+betareg,FLXMRbeta_extra,1,0,0,class<`formula`>,1
+betareg,FLXMRbeta_extra,2,0,0,class<`extraComponent`>,1
+betareg,FLXMRbeta_extra,2,0,1,list<class<`extraComponent`>>,1
+betareg,FLXMRbeta_extra,3,0,0,any,1
+betareg,FLXMRbeta_extra,4,0,0,character[],1
+betareg,FLXMRbeta_extra,5,0,0,character,1
+betareg,FLXMRbeta_extra,6,0,0,list<character | double | null>,1
+betareg,gleverage,-1,0,0,double[],1
+betareg,gleverage,0,0,0,class<`betareg`>,1
+betareg,gleverage,1,0,0,...,1
+betareg,gleverage.betareg,-1,0,0,double[],1
+betareg,gleverage.betareg,0,0,0,class<`betareg`>,1
+betareg,gleverage.betareg,1,0,0,...,1
+betareg,halfnormal.betareg,-1,0,0,class<`matrix`>,1
+betareg,halfnormal.betareg,0,0,0,class<`betareg`>,1
+betareg,halfnormal.betareg,1,0,0,double,1
+betareg,halfnormal.betareg,2,0,0,double,1
+betareg,halfnormal.betareg,3,0,0,character,1
+betareg,hatvalues.betareg,-1,0,0,double[],1
+betareg,hatvalues.betareg,0,0,0,class<`betareg`>,1
+betareg,hatvalues.betareg,1,0,0,...,1
+betareg,logLik.betareg,-1,0,0,class<`logLik`>,1
+betareg,logLik.betareg,0,0,0,class<`betareg`>,1
+betareg,logLik.betareg,1,0,0,...,1
+betareg,make.dmu.deta,-1,0,0,class<`function`>,1
+betareg,make.dmu.deta,0,0,0,character,1
+betareg,model.frame.betareg,-1,0,0,class<`data.frame`>,1
+betareg,model.frame.betareg,0,0,0,class<`betareg`>,1
+betareg,model.frame.betareg,1,0,0,...,1
+betareg,model.matrix.betareg,-1,0,0,class<`matrix`>,1
+betareg,model.matrix.betareg,0,0,0,class<`betareg`>,1
+betareg,model.matrix.betareg,1,0,0,character,1
+betareg,model.matrix.betareg,2,0,0,...,1
+betareg,plot.betareg,-1,0,0,null,1
+betareg,plot.betareg,0,0,0,class<`betareg`>,1
+betareg,plot.betareg,1,0,0,double,1
+betareg,plot.betareg,1,0,1,integer[],1
+betareg,plot.betareg,2,0,0,character[],1
+betareg,plot.betareg,3,0,0,any,1
+betareg,plot.betareg,4,0,0,character,1
+betareg,plot.betareg,5,0,0,logical,1
+betareg,plot.betareg,6,0,0,...,1
+betareg,plot.betareg,7,0,0,character,1
+betareg,plot.betatree,-1,0,0,null,1
+betareg,plot.betatree,0,0,0,"class<`betatree`, `modelparty`, `party`>",1
+betareg,plot.betatree,1,0,0,class<`grapcon_generator`>,1
+betareg,plot.betatree,2,0,0,list<any>,1
+betareg,plot.betatree,3,0,0,null,1
+betareg,plot.betatree,4,0,0,null,1
+betareg,plot.betatree,5,0,0,...,1
+betareg,predict.betareg,-1,0,0,class<`matrix`>,1
+betareg,predict.betareg,-1,0,1,double[],1
+betareg,predict.betareg,0,0,0,class<`betareg`>,1
+betareg,predict.betareg,1,0,0,null,1
+betareg,predict.betareg,1,0,1,class<`data.frame`>,1
+betareg,predict.betareg,2,0,0,character[],1
+betareg,predict.betareg,3,0,0,any,1
+betareg,predict.betareg,4,0,0,double[],1
+betareg,predict.betareg,5,0,0,...,1
+betareg,print.betamix,-1,0,0,class<`betamix`>,1
+betareg,print.betamix,0,0,0,class<`betamix`>,1
+betareg,print.betamix,1,0,0,...,1
+betareg,print.betatree,-1,0,0,"class<`betatree`, `modelparty`, `party`>",1
+betareg,print.betatree,0,0,0,"class<`betatree`, `modelparty`, `party`>",1
+betareg,print.betatree,1,0,0,character,1
+betareg,print.betatree,2,0,0,character,1
+betareg,print.betatree,3,0,0,...,1
+betareg,register_s3_method,-1,0,0,null,1
+betareg,register_s3_method,0,0,0,character,1
+betareg,register_s3_method,1,0,0,character,1
+betareg,register_s3_method,2,0,0,character,1
+betareg,register_s3_method,3,0,0,null,1
+betareg,residuals.betareg,-1,0,0,class<`AsIs`>,1
+betareg,residuals.betareg,-1,0,1,double[],1
+betareg,residuals.betareg,0,0,0,class<`betareg`>,1
+betareg,residuals.betareg,1,0,0,character,1
+betareg,residuals.betareg,2,0,0,...,1
+betareg,sctest.betatree,-1,0,0,list<class<`matrix`> | null>,1
+betareg,sctest.betatree,0,0,0,"class<`betatree`, `modelparty`, `party`>",1
+betareg,sctest.betatree,1,0,0,...,1
+betareg,summary.betamix,-1,0,0,class<`FLXRoptim`>,1
+betareg,summary.betamix,0,0,0,class<`betamix`>,1
+betareg,summary.betamix,1,0,0,character[],1
+betareg,summary.betamix,2,0,0,...,1
+betareg,summary.betareg,-1,0,0,class<`summary.betareg`>,1
+betareg,summary.betareg,0,0,0,class<`betareg`>,1
+betareg,summary.betareg,1,0,0,logical,1
+betareg,summary.betareg,1,0,1,null,1
+betareg,summary.betareg,2,0,0,character,1
+betareg,summary.betareg,3,0,0,...,1
+betareg,terms.betareg,-1,0,0,"class<`formula`, `terms`>",1
+betareg,terms.betareg,0,0,0,class<`betareg`>,1
+betareg,terms.betareg,1,0,0,character[],1
+betareg,terms.betareg,2,0,0,...,1
+betareg,update.betareg,-1,0,0,class<`betareg`>,1
+betareg,update.betareg,0,0,0,class<`betareg`>,1
+betareg,update.betareg,1,0,0,any,1
+betareg,update.betareg,2,0,0,...,1
+betareg,update.betareg,3,0,0,logical,1
+betareg,vcov.betareg,-1,0,0,class<`matrix`>,1
+betareg,vcov.betareg,0,0,0,class<`betareg`>,1
+betareg,vcov.betareg,1,0,0,any,1
+betareg,vcov.betareg,2,0,0,null,1
+betareg,vcov.betareg,3,0,0,...,1
+bigassertr,assert_01,-1,0,0,null,1
+bigassertr,assert_01,0,0,0,double[],1
+bigassertr,assert_all,-1,0,0,null,1
+bigassertr,assert_all,0,0,0,double[],1
+bigassertr,assert_all,1,0,0,double,1
+bigassertr,assert_args,-1,0,0,null,1
+bigassertr,assert_args,0,0,0,class<`function`>,1
+bigassertr,assert_args,1,0,0,character,1
+bigassertr,assert_class,-1,0,0,null,1
+bigassertr,assert_class,0,0,0,class<`function`>,1
+bigassertr,assert_class,1,0,0,character,1
+bigassertr,assert_dir,-1,0,0,null,1
+bigassertr,assert_dir,0,0,0,character,1
+bigassertr,assert_exist,-1,0,0,null,1
+bigassertr,assert_exist,0,0,0,character,1
+bigassertr,assert_ext,-1,0,0,null,1
+bigassertr,assert_ext,0,0,0,character,1
+bigassertr,assert_ext,1,0,0,character,1
+bigassertr,assert_int,-1,0,0,null,1
+bigassertr,assert_int,0,0,0,double[],1
+bigassertr,assert_lengths,-1,0,0,null,1
+bigassertr,assert_lengths,0,0,0,...,1
+bigassertr,assert_multiple,-1,0,0,null,1
+bigassertr,assert_multiple,0,0,0,integer[],1
+bigassertr,assert_nodots,-1,0,0,null,1
+bigassertr,assert_noexist,-1,0,0,null,1
+bigassertr,assert_noexist,0,0,0,character,1
+bigassertr,assert_nona,-1,0,0,null,1
+bigassertr,assert_nona,0,0,0,integer[],1
+bigassertr,assert_sorted,-1,0,0,null,1
+bigassertr,assert_sorted,0,0,0,integer[],1
+bigassertr,assert_sorted,1,0,0,logical,1
+bigassertr,assert_type,-1,0,0,null,1
+bigassertr,assert_type,0,0,0,integer[],1
+bigassertr,assert_type,1,0,0,character,1
+bigassertr,printf,-1,0,0,null,1
+bigassertr,printf,0,0,0,...,1
+binom,binom.bayes,-1,0,0,class<`data.frame`>,1
+binom,binom.bayes,0,0,0,double[],1
+binom,binom.bayes,1,0,0,double[],1
+binom,binom.bayes,2,0,0,double,1
+binom,binom.bayes,3,0,0,character[],1
+binom,binom.bayes,4,0,0,double,1
+binom,binom.bayes,5,0,0,double,1
+binom,binom.bayes,6,0,0,double,1
+binom,binom.bayes,7,0,0,double,1
+binom,binom.bayes,8,0,0,...,1
+binom,binom.bayes.densityplot,-1,0,0,"class<`gg`, `ggplot`>",1
+binom,binom.bayes.densityplot,0,0,0,class<`data.frame`>,1
+binom,binom.bayes.densityplot,1,0,0,double,1
+binom,binom.bayes.densityplot,2,0,0,character,1
+binom,binom.bayes.densityplot,3,0,0,character,1
+binom,binom.bayes.densityplot,4,0,0,character,1
+binom,binom.bayes.densityplot,5,0,0,double,1
+binom,binom.bayes.densityplot,6,0,0,...,1
+binom,binom.cloglog,-1,0,0,class<`data.frame`>,1
+binom,binom.cloglog,0,0,0,integer[],1
+binom,binom.cloglog,1,0,0,double,1
+binom,binom.cloglog,2,0,0,double,1
+binom,binom.cloglog,3,0,0,...,1
+binom,binom.confint,-1,0,0,class<`data.frame`>,1
+binom,binom.confint,0,0,0,double[],1
+binom,binom.confint,1,0,0,double[],1
+binom,binom.confint,2,0,0,double[],1
+binom,binom.confint,3,0,0,character,1
+binom,binom.confint,4,0,0,...,1
+binom,binom.coverage,-1,0,0,class<`data.frame`>,1
+binom,binom.coverage,0,0,0,double,1
+binom,binom.coverage,1,0,0,double,1
+binom,binom.coverage,2,0,0,double,1
+binom,binom.coverage,3,0,0,character,1
+binom,binom.coverage,4,0,0,...,1
+binom,binom.lchoose,-1,0,0,double,1
+binom,binom.lchoose,0,0,0,double,1
+binom,binom.lchoose,1,0,0,double,1
+binom,binom.length,-1,0,0,class<`data.frame`>,1
+binom,binom.length,0,0,0,double,1
+binom,binom.length,1,0,0,double,1
+binom,binom.length,2,0,0,double,1
+binom,binom.length,3,0,0,character,1
+binom,binom.length,4,0,0,...,1
+binom,binom.logit,-1,0,0,class<`data.frame`>,1
+binom,binom.logit,0,0,0,integer[],1
+binom,binom.logit,1,0,0,double,1
+binom,binom.logit,2,0,0,double,1
+binom,binom.logit,3,0,0,...,1
+binom,binom.lrt,-1,0,0,class<`data.frame`>,1
+binom,binom.lrt,0,0,0,double[],1
+binom,binom.lrt,1,0,0,double[],1
+binom,binom.lrt,2,0,0,double,1
+binom,binom.lrt,3,0,0,logical,1
+binom,binom.lrt,4,0,0,logical,1
+binom,binom.lrt,5,0,0,logical,1
+binom,binom.lrt,6,0,0,...,1
+binom,binom.optim,-1,0,0,list<any>,1
+binom,binom.optim,0,0,0,double,1
+binom,binom.optim,1,0,0,double,1
+binom,binom.optim,2,0,0,class<`function`>,1
+binom,binom.optim,3,0,0,double,1
+binom,binom.optim,4,0,0,double,1
+binom,binom.optim,5,0,0,logical,1
+binom,binom.optim,6,0,0,logical,1
+binom,binom.optim,7,0,0,double,1
+binom,binom.optim,8,0,0,null,1
+binom,binom.optim,9,0,0,...,1
+binom,binom.plot,-1,0,0,class<`trellis`>,1
+binom,binom.plot,0,0,0,double[],1
+binom,binom.plot,1,0,0,class<`function`>,1
+binom,binom.plot,2,0,0,double,1
+binom,binom.plot,3,0,0,double,1
+binom,binom.plot,4,0,0,any,1
+binom,binom.plot,5,0,0,character,1
+binom,binom.plot,6,0,0,double,1
+binom,binom.plot,7,0,0,...,1
+binom,binom.power,-1,0,0,double,1
+binom,binom.power,0,0,0,double,1
+binom,binom.power,1,0,0,double,1
+binom,binom.power,2,0,0,double,1
+binom,binom.power,3,0,0,double,1
+binom,binom.power,4,0,0,double,1
+binom,binom.power,5,0,0,character,1
+binom,binom.power,6,0,0,character[],1
+binom,binom.probit,-1,0,0,class<`data.frame`>,1
+binom,binom.probit,0,0,0,integer[],1
+binom,binom.probit,1,0,0,double,1
+binom,binom.probit,2,0,0,double,1
+binom,binom.probit,3,0,0,...,1
+binom,binom.profile,-1,0,0,class<`data.frame`>,1
+binom,binom.profile,0,0,0,double[],1
+binom,binom.profile,1,0,0,double[],1
+binom,binom.profile,2,0,0,double,1
+binom,binom.profile,3,0,0,double,1
+binom,binom.profile,4,0,0,double,1
+binom,binom.profile,5,0,0,logical,1
+binom,binom.profile,6,0,0,logical,1
+binom,binom.profile,7,0,0,...,1
+binom,binom.sim,-1,0,0,class<`data.frame`>,1
+binom,binom.sim,0,0,0,double,1
+binom,binom.sim,1,0,0,double,1
+binom,binom.sim,2,0,0,double,1
+binom,binom.sim,3,0,0,double,1
+binom,binom.sim,4,0,0,character,1
+binom,binom.sim,5,0,0,...,1
+binom,cloglog.sample.size,-1,0,0,class<`data.frame`>,1
+binom,cloglog.sample.size,0,0,0,any,1
+binom,cloglog.sample.size,1,0,0,null,1
+binom,cloglog.sample.size,1,0,1,double,1
+binom,cloglog.sample.size,2,0,0,double,1
+binom,cloglog.sample.size,3,0,0,double,1
+binom,cloglog.sample.size,4,0,0,double,1
+binom,cloglog.sample.size,5,0,0,character[],1
+binom,cloglog.sample.size,6,0,0,logical,1
+binom,cloglog.sample.size,7,0,0,logical,1
+binom,cloglog.sample.size,8,0,0,double,1
+binom,integrate.poly,-1,0,0,double,1
+binom,integrate.poly,0,0,0,double[],1
+binom,integrate.poly,1,0,0,double,1
+binom,integrate.poly,2,0,0,double,1
+binom,integrate.poly,3,0,0,double,1
+binom,integrate.poly,4,0,0,double,1
+binom,integrate.poly,5,0,0,character,1
+binom,ldbinom,-1,0,0,double,1
+binom,ldbinom,0,0,0,double,1
+binom,ldbinom,1,0,0,double,1
+binom,ldbinom,2,0,0,double,1
+binom,ldbinom,3,0,0,logical,1
+binom,rbind.zero,-1,0,0,class<`data.frame`>,1
+binom,rbind.zero,0,0,0,class<`data.frame`>,1
+binom,rbind.zero,1,0,0,character,1
+binom,rbind.zero,2,0,0,logical,1
+binom,var.cloglog,-1,0,0,double[],1
+binom,var.cloglog,0,0,0,double[],1
+binom,var.cloglog,1,0,0,double[],1
+binom,var.logit,-1,0,0,double[],1
+binom,var.logit,0,0,0,double[],1
+binom,var.logit,1,0,0,double[],1
+binom,var.probit,-1,0,0,double[],1
+binom,var.probit,0,0,0,double[],1
+binom,var.probit,1,0,0,double[],1
+bit,all.bit,-1,0,0,logical,1
+bit,all.bit,0,0,0,class<`bit`>,1
+bit,all.bit,1,0,0,null,1
+bit,all.bit,2,0,0,...,1
+bit,all.bitwhich,-1,0,0,logical,1
+bit,all.bitwhich,0,0,0,class<`bitwhich`>,1
+bit,all.bitwhich,1,0,0,...,1
+bit,any.bit,-1,0,0,logical,1
+bit,any.bit,0,0,0,class<`bit`>,1
+bit,any.bit,1,0,0,null,1
+bit,any.bit,2,0,0,...,1
+bit,any.bitwhich,-1,0,0,logical,1
+bit,any.bitwhich,0,0,0,class<`bitwhich`>,1
+bit,any.bitwhich,1,0,0,...,1
+bit,anyDuplicated.rlepack,-1,0,0,integer,1
+bit,anyDuplicated.rlepack,0,0,0,class<`rlepack`>,1
+bit,anyDuplicated.rlepack,1,0,0,logical,1
+bit,anyDuplicated.rlepack,2,0,0,...,1
+bit,as.bit,-1,0,0,class<`bit`>,1
+bit,as.bit,0,0,0,class<`bit`>,1
+bit,as.bit,0,0,1,class<`ri`>,1
+bit,as.bit,0,0,2,^logical[],1
+bit,as.bit,0,0,3,class<`bitwhich`>,1
+bit,as.bit,1,0,0,...,1
+bit,as.bit.bit,-1,0,0,class<`bit`>,1
+bit,as.bit.bit,0,0,0,class<`bit`>,1
+bit,as.bit.bit,1,0,0,...,1
+bit,as.bit.bitwhich,-1,0,0,class<`bit`>,1
+bit,as.bit.bitwhich,0,0,0,class<`bitwhich`>,1
+bit,as.bit.bitwhich,1,0,0,...,1
+bit,as.bit.logical,-1,0,0,class<`bit`>,1
+bit,as.bit.logical,0,0,0,^logical[],1
+bit,as.bit.logical,1,0,0,...,1
+bit,as.bit.ri,-1,0,0,class<`bit`>,1
+bit,as.bit.ri,0,0,0,class<`ri`>,1
+bit,as.bit.ri,1,0,0,...,1
+bit,as.bitwhich,-1,0,0,class<`bitwhich`>,1
+bit,as.bitwhich,0,0,0,class<`bit`>,1
+bit,as.bitwhich,0,0,1,class<`bitwhich`>,1
+bit,as.bitwhich,0,0,2,class<`ri`>,1
+bit,as.bitwhich,0,0,3,^logical[],1
+bit,as.bitwhich,1,0,0,...,1
+bit,as.bit.which,-1,0,0,class<`bit`>,1
+bit,as.bit.which,0,0,0,class<`which`>,1
+bit,as.bit.which,0,0,1,double[],1
+bit,as.bit.which,1,0,0,double,1
+bit,as.bit.which,2,0,0,...,1
+bit,as.bitwhich.bit,-1,0,0,class<`bitwhich`>,1
+bit,as.bitwhich.bit,0,0,0,class<`bit`>,1
+bit,as.bitwhich.bit,1,0,0,null,1
+bit,as.bitwhich.bit,2,0,0,...,1
+bit,as.bitwhich.bitwhich,-1,0,0,class<`bitwhich`>,1
+bit,as.bitwhich.bitwhich,0,0,0,class<`bitwhich`>,1
+bit,as.bitwhich.bitwhich,1,0,0,...,1
+bit,as.bitwhich.logical,-1,0,0,class<`bitwhich`>,1
+bit,as.bitwhich.logical,0,0,0,^logical[],1
+bit,as.bitwhich.logical,1,0,0,...,1
+bit,as.bitwhich.ri,-1,0,0,class<`bitwhich`>,1
+bit,as.bitwhich.ri,0,0,0,class<`ri`>,1
+bit,as.bitwhich.ri,1,0,0,...,1
+bit,as.double.bit,-1,0,0,double[],1
+bit,as.double.bit,0,0,0,class<`bit`>,1
+bit,as.double.bit,1,0,0,...,1
+bit,as.double.bitwhich,-1,0,0,double[],1
+bit,as.double.bitwhich,0,0,0,class<`bitwhich`>,1
+bit,as.double.bitwhich,1,0,0,...,1
+bit,as.double.ri,-1,0,0,double[],1
+bit,as.double.ri,0,0,0,class<`ri`>,1
+bit,as.double.ri,1,0,0,...,1
+bit,as.integer.bit,-1,0,0,integer[],1
+bit,as.integer.bit,0,0,0,class<`bit`>,1
+bit,as.integer.bit,1,0,0,...,1
+bit,as.integer.bitwhich,-1,0,0,integer[],1
+bit,as.integer.bitwhich,0,0,0,class<`bitwhich`>,1
+bit,as.integer.bitwhich,1,0,0,...,1
+bit,as.integer.ri,-1,0,0,integer[],1
+bit,as.integer.ri,0,0,0,class<`ri`>,1
+bit,as.integer.ri,1,0,0,...,1
+bit,as.logical.bit,-1,0,0,logical[],1
+bit,as.logical.bit,0,0,0,class<`bit`>,1
+bit,as.logical.bit,1,0,0,...,1
+bit,as.logical.bitwhich,-1,0,0,logical[],1
+bit,as.logical.bitwhich,0,0,0,class<`bitwhich`>,1
+bit,as.logical.bitwhich,1,0,0,...,1
+bit,as.logical.ri,-1,0,0,logical[],1
+bit,as.logical.ri,0,0,0,class<`ri`>,1
+bit,as.logical.ri,1,0,0,...,1
+bit,as.which,-1,0,0,class<`which`>,1
+bit,as.which,0,0,0,class<`bit`>,1
+bit,as.which,0,0,1,class<`bitwhich`>,1
+bit,as.which,0,0,2,class<`ri`>,1
+bit,as.which,0,0,3,logical[],1
+bit,as.which,1,0,0,...,1
+bit,as.which.bit,-1,0,0,class<`which`>,1
+bit,as.which.bit,0,0,0,class<`bit`>,1
+bit,as.which.bit,1,0,0,null,1
+bit,as.which.bit,2,0,0,...,1
+bit,as.which.bitwhich,-1,0,0,class<`which`>,1
+bit,as.which.bitwhich,0,0,0,class<`bitwhich`>,1
+bit,as.which.bitwhich,1,0,0,...,1
+bit,as.which.default,-1,0,0,class<`which`>,1
+bit,as.which.default,0,0,0,logical[],1
+bit,as.which.default,1,0,0,...,1
+bit,as.which.ri,-1,0,0,class<`which`>,1
+bit,as.which.ri,0,0,0,class<`ri`>,1
+bit,as.which.ri,1,0,0,...,1
+bit,bbatch,-1,0,0,list<double>,1
+bit,bbatch,0,0,0,double,1
+bit,bbatch,1,0,0,double,1
+bit,bit,-1,0,0,class<`bit`>,1
+bit,bit,0,0,0,double,1
+bit,==.bit,-1,0,0,class<`bit`>,1
+bit,==.bit,0,0,0,class<`bit`>,1
+bit,==.bit,1,0,0,class<`bit`>,1
+bit,==.bit,1,0,1,^logical[],1
+bit,|.bit,-1,0,0,class<`bit`>,1
+bit,|.bit,0,0,0,class<`bit`>,1
+bit,|.bit,1,0,0,class<`bit`>,1
+bit,|.bit,1,0,1,^logical[],1
+bit,!=.bit,-1,0,0,class<`bit`>,1
+bit,!=.bit,0,0,0,class<`bit`>,1
+bit,!=.bit,1,0,0,class<`bit`>,1
+bit,!=.bit,1,0,1,^logical[],1
+bit,!.bit,-1,0,0,class<`bit`>,1
+bit,!.bit,0,0,0,class<`bit`>,1
+bit,[<-.bit,-1,0,0,class<`bit`>,1
+bit,[<-.bit,0,0,0,class<`bit`>,1
+bit,[<-.bit,1,0,0,any,1
+bit,[<-.bit,2,0,0,null,1
+bit,[<-.bit,2,0,1,^logical[],1
+bit,[.bit,-1,0,0,any,1
+bit,[.bit,0,0,0,class<`bit`>,1
+bit,[.bit,1,0,0,any,1
+bit,[[<-.bit,-1,0,0,class<`bit`>,1
+bit,[[<-.bit,0,0,0,class<`bit`>,1
+bit,[[<-.bit,1,0,0,double,1
+bit,[[<-.bit,2,0,0,logical,1
+bit,[[.bit,-1,0,0,logical,1
+bit,[[.bit,0,0,0,class<`bit`>,1
+bit,[[.bit,1,0,0,double,1
+bit,&.bit,-1,0,0,class<`bit`>,1
+bit,&.bit,0,0,0,class<`bit`>,1
+bit,&.bit,1,0,0,class<`bit`>,1
+bit,&.bit,1,0,1,^logical[],1
+bit,bit_done,-1,0,0,null,1
+bit,bit_init,-1,0,0,null,1
+bit,bitwhich,-1,0,0,class<`bitwhich`>,1
+bit,bitwhich,0,0,0,double,1
+bit,bitwhich,1,0,0,double,1
+bit,bitwhich,2,0,0,double[],1
+bit,bitwhich,2,0,1,class<`bitwhich`>,1
+bit,==.bitwhich,-1,0,0,class<`bitwhich`>,1
+bit,==.bitwhich,0,0,0,class<`bitwhich`>,1
+bit,==.bitwhich,1,0,0,class<`bitwhich`>,1
+bit,==.bitwhich,1,0,1,^logical[],1
+bit,|.bitwhich,-1,0,0,class<`bitwhich`>,1
+bit,|.bitwhich,0,0,0,class<`bitwhich`>,1
+bit,|.bitwhich,1,0,0,class<`bitwhich`>,1
+bit,|.bitwhich,1,0,1,^logical[],1
+bit,!=.bitwhich,-1,0,0,class<`bitwhich`>,1
+bit,!=.bitwhich,0,0,0,class<`bitwhich`>,1
+bit,!=.bitwhich,1,0,0,class<`bitwhich`>,1
+bit,!=.bitwhich,1,0,1,^logical[],1
+bit,!.bitwhich,-1,0,0,class<`bitwhich`>,1
+bit,!.bitwhich,0,0,0,class<`bitwhich`>,1
+bit,&.bitwhich,-1,0,0,class<`bitwhich`>,1
+bit,&.bitwhich,0,0,0,class<`bitwhich`>,1
+bit,&.bitwhich,1,0,0,class<`bitwhich`>,1
+bit,&.bitwhich,1,0,1,^logical[],1
+bit,c.bit,-1,0,0,class<`bit`>,1
+bit,c.bit,0,0,0,...,1
+bit,c.bitwhich,-1,0,0,class<`bitwhich`>,1
+bit,c.bitwhich,0,0,0,...,1
+bit,chunk,-1,0,0,list<class<`ri`>>,1
+bit,chunk,0,0,0,...,1
+bit,chunk.default,-1,0,0,list<class<`ri`>>,1
+bit,chunk.default,0,0,0,double,1
+bit,chunk.default,1,0,0,double,1
+bit,chunk.default,2,0,0,double,1
+bit,chunk.default,3,0,0,null,1
+bit,chunk.default,4,0,0,null,1
+bit,chunk.default,5,0,0,integer,1
+bit,chunk.default,6,0,0,character[],1
+bit,chunk.default,7,0,0,null,1
+bit,chunk.default,8,0,0,...,1
+bit,clone,-1,0,0,integer[],1
+bit,clone,0,0,0,integer[],1
+bit,clone,1,0,0,...,1
+bit,clone.default,-1,0,0,integer[],1
+bit,clone.default,0,0,0,integer[],1
+bit,clone.default,1,0,0,...,1
+bit,intisasc,-1,0,0,logical,1
+bit,intisasc,-1,0,1,null,1
+bit,intisasc,0,0,0,^integer[],1
+bit,intisdesc,-1,0,0,logical,1
+bit,intisdesc,0,0,0,integer[],1
+bit,intrle,-1,0,0,class<`rle`>,1
+bit,intrle,-1,0,1,null,1
+bit,intrle,0,0,0,integer[],1
+bit,is.bit,-1,0,0,logical,1
+bit,is.bit,0,0,0,class<`bit`>,1
+bit,is.bit,0,0,1,logical,1
+bit,is.bitwhich,-1,0,0,logical,1
+bit,is.bitwhich,0,0,0,class<`bitwhich`>,1
+bit,is.bitwhich,0,0,1,logical,1
+bit,is.ri,-1,0,0,logical,1
+bit,is.ri,0,0,0,class<`ri`>,1
+bit,is.ri,0,0,1,logical,1
+bit,length<-.bit,-1,0,0,class<`bit`>,1
+bit,length<-.bit,0,0,0,class<`bit`>,1
+bit,length<-.bit,1,0,0,double,1
+bit,length.bit,-1,0,0,integer,1
+bit,length.bit,0,0,0,class<`bit`>,1
+bit,length<-.bitwhich,-1,0,0,class<`bitwhich`>,1
+bit,length<-.bitwhich,0,0,0,class<`bitwhich`>,1
+bit,length<-.bitwhich,1,0,0,double,1
+bit,length.bitwhich,-1,0,0,integer,1
+bit,length.bitwhich,0,0,0,class<`bitwhich`>,1
+bit,length.ri,-1,0,0,integer,1
+bit,length.ri,0,0,0,class<`ri`>,1
+bit,max.bit,-1,0,0,integer,1
+bit,max.bit,-1,0,1,null,1
+bit,max.bit,0,0,0,class<`bit`>,1
+bit,max.bit,1,0,0,null,1
+bit,max.bit,2,0,0,...,1
+bit,max.bitwhich,-1,0,0,integer,1
+bit,max.bitwhich,0,0,0,class<`bitwhich`>,1
+bit,max.bitwhich,1,0,0,...,1
+bit,min.bit,-1,0,0,integer,1
+bit,min.bit,-1,0,1,null,1
+bit,min.bit,0,0,0,class<`bit`>,1
+bit,min.bit,1,0,0,null,1
+bit,min.bit,2,0,0,...,1
+bit,min.bitwhich,-1,0,0,integer,1
+bit,min.bitwhich,0,0,0,class<`bitwhich`>,1
+bit,min.bitwhich,1,0,0,...,1
+bit,physical,-1,0,0,list<character>,1
+bit,physical,0,0,0,class<`bit`>,1
+bit,physical.default,-1,0,0,list<character>,1
+bit,physical.default,0,0,0,class<`bit`>,1
+bit,range.bit,-1,0,0,^integer[],1
+bit,range.bit,0,0,0,class<`bit`>,1
+bit,range.bit,1,0,0,integer[],1
+bit,range.bit,1,0,1,null,1
+bit,range.bit,2,0,0,...,1
+bit,range.bitwhich,-1,0,0,integer,1
+bit,range.bitwhich,0,0,0,class<`bitwhich`>,1
+bit,range.bitwhich,1,0,0,...,1
+bit,regtest.bit,-1,0,0,logical,1
+bit,regtest.bit,0,0,0,double,1
+bit,repeat.time,-1,0,0,class<`proc_time`>,1
+bit,repeat.time,0,0,0,any,1
+bit,repeat.time,1,0,0,logical,1
+bit,repeat.time,2,0,0,double,1
+bit,repeat.time,3,0,0,environment,1
+bit,repfromto,-1,0,0,integer[],1
+bit,repfromto,0,0,0,integer[],1
+bit,repfromto,1,0,0,double,1
+bit,repfromto,2,0,0,double,1
+bit,ri,-1,0,0,class<`ri`>,1
+bit,ri,0,0,0,double,1
+bit,ri,1,0,0,double,1
+bit,ri,2,0,0,double,1
+bit,ri,2,0,1,null,1
+bit,rlepack,-1,0,0,class<`rlepack`>,1
+bit,rlepack,0,0,0,integer[],1
+bit,rlepack,1,0,0,...,1
+bit,rlepack.integer,-1,0,0,class<`rlepack`>,1
+bit,rlepack.integer,0,0,0,integer[],1
+bit,rlepack.integer,1,0,0,logical,1
+bit,rlepack.integer,2,0,0,...,1
+bit,rleunpack,-1,0,0,integer[],1
+bit,rleunpack,0,0,0,class<`rlepack`>,1
+bit,rleunpack.rlepack,-1,0,0,integer[],1
+bit,rleunpack.rlepack,0,0,0,class<`rlepack`>,1
+bit,setattr,-1,0,0,null,1
+bit,setattr,0,0,0,double[],1
+bit,setattr,1,0,0,character,1
+bit,setattr,2,0,0,null,1
+bit,still.identical,-1,0,0,logical,1
+bit,still.identical,0,0,0,integer[],1
+bit,still.identical,1,0,0,integer[],1
+bit,sum.bit,-1,0,0,integer,1
+bit,sum.bit,0,0,0,class<`bit`>,1
+bit,sum.bit,1,0,0,integer[],1
+bit,sum.bit,1,0,1,null,1
+bit,sum.bit,2,0,0,...,1
+bit,sum.bitwhich,-1,0,0,integer,1
+bit,sum.bitwhich,0,0,0,class<`bitwhich`>,1
+bit,sum.bitwhich,1,0,0,...,1
+bit,summary.bit,-1,0,0,^integer[],1
+bit,summary.bit,0,0,0,class<`bit`>,1
+bit,summary.bit,1,0,0,null,1
+bit,summary.bit,2,0,0,...,1
+bit,summary.bitwhich,-1,0,0,integer,1
+bit,summary.bitwhich,0,0,0,class<`bitwhich`>,1
+bit,summary.bitwhich,1,0,0,...,1
+bit,sum.ri,-1,0,0,integer,1
+bit,sum.ri,0,0,0,class<`ri`>,1
+bit,sum.ri,1,0,0,...,1
+bit,unattr,-1,0,0,^logical[],1
+bit,unattr,0,0,0,^logical[],1
+bit,unique.rlepack,-1,0,0,class<`rlepack`>,1
+bit,unique.rlepack,0,0,0,class<`rlepack`>,1
+bit,unique.rlepack,1,0,0,logical,1
+bit,unique.rlepack,2,0,0,...,1
+bit,vecseq,-1,0,0,class<`call`>,1
+bit,vecseq,-1,0,1,integer[],1
+bit,vecseq,-1,0,2,list<class<`call`>>,1
+bit,vecseq,-1,0,3,list<integer[]>,1
+bit,vecseq,0,0,0,double[],1
+bit,vecseq,1,0,0,double[],1
+bit,vecseq,1,0,1,null,1
+bit,vecseq,2,0,0,logical,1
+bit,vecseq,3,0,0,logical,1
+bit,virtual,-1,0,0,list<integer>,1
+bit,virtual,0,0,0,class<`bit`>,1
+bit,virtual.default,-1,0,0,list<integer>,1
+bit,virtual.default,0,0,0,class<`bit`>,1
+bit,xor,-1,0,0,class<`bit`>,1
+bit,xor,-1,0,1,class<`bitwhich`>,1
+bit,xor,-1,0,2,logical[],1
+bit,xor,0,0,0,class<`bit`>,1
+bit,xor,0,0,1,class<`bitwhich`>,1
+bit,xor,0,0,2,logical[],1
+bit,xor,1,0,0,class<`bit`>,1
+bit,xor,1,0,1,^logical[],1
+bit,xor,1,0,2,class<`bitwhich`>,1
+bit,xor.bit,-1,0,0,class<`bit`>,1
+bit,xor.bit,0,0,0,class<`bit`>,1
+bit,xor.bit,1,0,0,class<`bit`>,1
+bit,xor.bit,1,0,1,^logical[],1
+bit,xor.bitwhich,-1,0,0,class<`bitwhich`>,1
+bit,xor.bitwhich,0,0,0,class<`bitwhich`>,1
+bit,xor.bitwhich,1,0,0,class<`bitwhich`>,1
+bit,xor.bitwhich,1,0,1,^logical[],1
+bit,xor.default,-1,0,0,logical[],1
+bit,xor.default,0,0,0,logical[],1
+bit,xor.default,1,0,0,logical[],1
+bit64,:,-1,0,0,class<`integer64`>,1
+bit64,:,-1,0,1,integer[],1
+bit64,:,0,0,0,class<`integer64`>,1
+bit64,:,0,0,1,double,1
+bit64,:,1,0,0,double,1
+bit64,abs.integer64,-1,0,0,class<`integer64`>,1
+bit64,abs.integer64,0,0,0,class<`integer64`>,1
+bit64,all.integer64,-1,0,0,logical,1
+bit64,all.integer64,-1,0,1,null,1
+bit64,all.integer64,0,0,0,...,1
+bit64,all.integer64,1,0,0,logical,1
+bit64,any.integer64,-1,0,0,logical,1
+bit64,any.integer64,-1,0,1,null,1
+bit64,any.integer64,0,0,0,...,1
+bit64,any.integer64,1,0,0,logical,1
+bit64,as.bitstring,-1,0,0,character[],1
+bit64,as.bitstring,0,0,0,class<`integer64`>,1
+bit64,as.bitstring,1,0,0,...,1
+bit64,as.bitstring.integer64,-1,0,0,character[],1
+bit64,as.bitstring.integer64,0,0,0,class<`integer64`>,1
+bit64,as.bitstring.integer64,1,0,0,...,1
+bit64,as.character.integer64,-1,0,0,^character[],1
+bit64,as.character.integer64,0,0,0,"class<`AsIs`, `integer64`>",1
+bit64,as.character.integer64,0,0,1,class<`integer64`>,1
+bit64,as.character.integer64,1,0,0,...,1
+bit64,as.data.frame.integer64,-1,0,0,class<`data.frame`>,1
+bit64,as.data.frame.integer64,0,0,0,class<`integer64`>,1
+bit64,as.data.frame.integer64,1,0,0,...,1
+bit64,as.double.integer64,-1,0,0,^double[],1
+bit64,as.double.integer64,0,0,0,class<`integer64`>,1
+bit64,as.double.integer64,1,0,0,logical,1
+bit64,as.double.integer64,2,0,0,...,1
+bit64,as.integer64,-1,0,0,class<`integer64`>,1
+bit64,as.integer64,0,0,0,character[],1
+bit64,as.integer64,0,0,1,class<`factor`>,1
+bit64,as.integer64,0,0,2,class<`integer64`>,1
+bit64,as.integer64,0,0,3,^double[],1
+bit64,as.integer64,0,0,4,null,1
+bit64,as.integer64,1,0,0,...,1
+bit64,as.integer64.character,-1,0,0,class<`integer64`>,1
+bit64,as.integer64.character,0,0,0,character[],1
+bit64,as.integer64.character,1,0,0,...,1
+bit64,as.integer64.double,-1,0,0,class<`integer64`>,1
+bit64,as.integer64.double,0,0,0,^double[],1
+bit64,as.integer64.double,0,0,1,null,1
+bit64,as.integer64.double,1,0,0,logical,1
+bit64,as.integer64.double,2,0,0,...,1
+bit64,as.integer64.factor,-1,0,0,class<`integer64`>,1
+bit64,as.integer64.factor,0,0,0,class<`factor`>,1
+bit64,as.integer64.factor,1,0,0,...,1
+bit64,as.integer64.integer,-1,0,0,class<`integer64`>,1
+bit64,as.integer64.integer,0,0,0,^integer[],1
+bit64,as.integer64.integer,0,0,1,null,1
+bit64,as.integer64.integer,1,0,0,...,1
+bit64,as.integer64.integer64,-1,0,0,class<`integer64`>,1
+bit64,as.integer64.integer64,0,0,0,class<`integer64`>,1
+bit64,as.integer64.integer64,1,0,0,...,1
+bit64,as.integer64.logical,-1,0,0,class<`integer64`>,1
+bit64,as.integer64.logical,0,0,0,^integer[],1
+bit64,as.integer64.logical,0,0,1,null,1
+bit64,as.integer64.logical,1,0,0,...,1
+bit64,as.integer.integer64,-1,0,0,^integer[],1
+bit64,as.integer.integer64,0,0,0,class<`integer64`>,1
+bit64,as.integer.integer64,1,0,0,...,1
+bit64,as.logical.integer64,-1,0,0,^logical[],1
+bit64,as.logical.integer64,0,0,0,class<`integer64`>,1
+bit64,as.logical.integer64,1,0,0,...,1
+bit64,benchmark64,-1,0,0,class<`matrix`>,1
+bit64,benchmark64,0,0,0,double,1
+bit64,benchmark64,1,0,0,double,1
+bit64,benchmark64,2,0,0,class<`function`>,1
+bit64,binattr,-1,0,0,null,1
+bit64,binattr,-1,0,1,list<character>,1
+bit64,binattr,0,0,0,double[],1
+bit64,binattr,0,0,1,class<`integer64`>,1
+bit64,binattr,1,0,0,class<`integer64`>,1
+bit64,binattr,1,0,1,double[],1
+bit64,cache,-1,0,0,"class<`cache`, `cache_integer64`, `environment`>",1
+bit64,cache,-1,0,1,null,1
+bit64,cache,0,0,0,class<`integer64`>,1
+bit64,ceiling.integer64,-1,0,0,class<`integer64`>,1
+bit64,ceiling.integer64,0,0,0,class<`integer64`>,1
+bit64,c.integer64,-1,0,0,class<`integer64`>,1
+bit64,c.integer64,0,0,0,...,1
+bit64,c.integer64,1,0,0,logical,1
+bit64,cummax.integer64,-1,0,0,class<`integer64`>,1
+bit64,cummax.integer64,0,0,0,class<`integer64`>,1
+bit64,cummin.integer64,-1,0,0,class<`integer64`>,1
+bit64,cummin.integer64,0,0,0,class<`integer64`>,1
+bit64,cumprod.integer64,-1,0,0,class<`integer64`>,1
+bit64,cumprod.integer64,0,0,0,class<`integer64`>,1
+bit64,cumsum.integer64,-1,0,0,class<`integer64`>,1
+bit64,cumsum.integer64,0,0,0,class<`integer64`>,1
+bit64,:.default,-1,0,0,integer[],1
+bit64,:.default,0,0,0,double,1
+bit64,:.default,1,0,0,double,1
+bit64,diff.integer64,-1,0,0,class<`integer64`>,1
+bit64,diff.integer64,0,0,0,class<`integer64`>,1
+bit64,diff.integer64,1,0,0,double,1
+bit64,diff.integer64,2,0,0,double,1
+bit64,diff.integer64,3,0,0,...,1
+bit64,duplicated.integer64,-1,0,0,logical[],1
+bit64,duplicated.integer64,0,0,0,class<`integer64`>,1
+bit64,duplicated.integer64,1,0,0,logical,1
+bit64,duplicated.integer64,2,0,0,null,1
+bit64,duplicated.integer64,3,0,0,null,1
+bit64,duplicated.integer64,4,0,0,...,1
+bit64,floor.integer64,-1,0,0,class<`integer64`>,1
+bit64,floor.integer64,0,0,0,class<`integer64`>,1
+bit64,format.integer64,-1,0,0,character[],1
+bit64,format.integer64,0,0,0,class<`integer64`>,1
+bit64,format.integer64,1,0,0,character,1
+bit64,format.integer64,2,0,0,...,1
+bit64,getcache,-1,0,0,double,1
+bit64,getcache,-1,0,1,null,1
+bit64,getcache,0,0,0,class<`integer64`>,1
+bit64,getcache,1,0,0,character,1
+bit64,hashcache,-1,0,0,"class<`cache`, `cache_integer64`, `environment`>",1
+bit64,hashcache,0,0,0,class<`integer64`>,1
+bit64,hashcache,1,0,0,null,1
+bit64,hashcache,2,0,0,...,1
+bit64,hashdup,-1,0,0,logical[],1
+bit64,hashdup,0,0,0,"class<`cache`, `cache_integer64`, `environment`>",1
+bit64,hashdup,1,0,0,...,1
+bit64,hashdup.cache_integer64,-1,0,0,logical[],1
+bit64,hashdup.cache_integer64,0,0,0,"class<`cache`, `cache_integer64`, `environment`>",1
+bit64,hashdup.cache_integer64,1,0,0,...,1
+bit64,hashfin,-1,0,0,logical[],1
+bit64,hashfin,0,0,0,"class<`cache`, `cache_integer64`, `environment`>",1
+bit64,hashfin,1,0,0,...,1
+bit64,hashfin.cache_integer64,-1,0,0,logical[],1
+bit64,hashfin.cache_integer64,0,0,0,"class<`cache`, `cache_integer64`, `environment`>",1
+bit64,hashfin.cache_integer64,1,0,0,class<`integer64`>,1
+bit64,hashfin.cache_integer64,2,0,0,...,1
+bit64,hashfun,-1,0,0,integer[],1
+bit64,hashfun,0,0,0,class<`integer64`>,1
+bit64,hashfun,1,0,0,...,1
+bit64,hashfun.integer64,-1,0,0,integer[],1
+bit64,hashfun.integer64,0,0,0,class<`integer64`>,1
+bit64,hashfun.integer64,1,0,0,double,1
+bit64,hashfun.integer64,2,0,0,null,1
+bit64,hashfun.integer64,3,0,0,...,1
+bit64,hashmap,-1,0,0,"class<`cache`, `cache_integer64`, `environment`>",1
+bit64,hashmap,0,0,0,class<`integer64`>,1
+bit64,hashmap,1,0,0,...,1
+bit64,hashmap.integer64,-1,0,0,"class<`cache`, `cache_integer64`, `environment`>",1
+bit64,hashmap.integer64,0,0,0,class<`integer64`>,1
+bit64,hashmap.integer64,1,0,0,integer,1
+bit64,hashmap.integer64,1,0,1,null,1
+bit64,hashmap.integer64,2,0,0,double,1
+bit64,hashmap.integer64,3,0,0,null,1
+bit64,hashmap.integer64,3,0,1,integer,1
+bit64,hashmap.integer64,4,0,0,null,1
+bit64,hashmap.integer64,4,0,1,"class<`cache`, `cache_integer64`, `environment`>",1
+bit64,hashmap.integer64,5,0,0,...,1
+bit64,hashmaptab,-1,0,0,list<class<`integer64`> | integer[]>,1
+bit64,hashmaptab,0,0,0,class<`integer64`>,1
+bit64,hashmaptab,1,0,0,...,1
+bit64,hashmaptab.integer64,-1,0,0,list<class<`integer64`> | integer[]>,1
+bit64,hashmaptab.integer64,0,0,0,class<`integer64`>,1
+bit64,hashmaptab.integer64,1,0,0,null,1
+bit64,hashmaptab.integer64,2,0,0,double,1
+bit64,hashmaptab.integer64,3,0,0,null,1
+bit64,hashmaptab.integer64,4,0,0,...,1
+bit64,hashmapuni,-1,0,0,class<`integer64`>,1
+bit64,hashmapuni,0,0,0,class<`integer64`>,1
+bit64,hashmapuni,1,0,0,...,1
+bit64,hashmapuni.integer64,-1,0,0,class<`integer64`>,1
+bit64,hashmapuni.integer64,0,0,0,class<`integer64`>,1
+bit64,hashmapuni.integer64,1,0,0,null,1
+bit64,hashmapuni.integer64,1,0,1,integer,1
+bit64,hashmapuni.integer64,2,0,0,double,1
+bit64,hashmapuni.integer64,3,0,0,null,1
+bit64,hashmapuni.integer64,4,0,0,...,1
+bit64,hashmapupo,-1,0,0,integer[],1
+bit64,hashmapupo,0,0,0,class<`integer64`>,1
+bit64,hashmapupo,1,0,0,...,1
+bit64,hashmapupo.integer64,-1,0,0,integer[],1
+bit64,hashmapupo.integer64,0,0,0,class<`integer64`>,1
+bit64,hashmapupo.integer64,1,0,0,null,1
+bit64,hashmapupo.integer64,2,0,0,double,1
+bit64,hashmapupo.integer64,3,0,0,null,1
+bit64,hashmapupo.integer64,4,0,0,...,1
+bit64,hashpos,-1,0,0,^integer[],1
+bit64,hashpos,0,0,0,"class<`cache`, `cache_integer64`, `environment`>",1
+bit64,hashpos,1,0,0,...,1
+bit64,hashpos.cache_integer64,-1,0,0,^integer[],1
+bit64,hashpos.cache_integer64,0,0,0,"class<`cache`, `cache_integer64`, `environment`>",1
+bit64,hashpos.cache_integer64,1,0,0,class<`integer64`>,1
+bit64,hashpos.cache_integer64,2,0,0,null,1
+bit64,hashpos.cache_integer64,2,0,1,integer,1
+bit64,hashpos.cache_integer64,3,0,0,...,1
+bit64,hashrev,-1,0,0,^integer[],1
+bit64,hashrev,0,0,0,"class<`cache`, `cache_integer64`, `environment`>",1
+bit64,hashrev,1,0,0,...,1
+bit64,hashrev.cache_integer64,-1,0,0,^integer[],1
+bit64,hashrev.cache_integer64,0,0,0,"class<`cache`, `cache_integer64`, `environment`>",1
+bit64,hashrev.cache_integer64,1,0,0,class<`integer64`>,1
+bit64,hashrev.cache_integer64,2,0,0,null,1
+bit64,hashrev.cache_integer64,3,0,0,...,1
+bit64,hashrin,-1,0,0,logical[],1
+bit64,hashrin,0,0,0,"class<`cache`, `cache_integer64`, `environment`>",1
+bit64,hashrin,1,0,0,...,1
+bit64,hashrin.cache_integer64,-1,0,0,logical[],1
+bit64,hashrin.cache_integer64,0,0,0,"class<`cache`, `cache_integer64`, `environment`>",1
+bit64,hashrin.cache_integer64,1,0,0,class<`integer64`>,1
+bit64,hashrin.cache_integer64,2,0,0,...,1
+bit64,hashtab,-1,0,0,list<class<`integer64`> | integer[]>,1
+bit64,hashtab,0,0,0,"class<`cache`, `cache_integer64`, `environment`>",1
+bit64,hashtab,1,0,0,...,1
+bit64,hashtab.cache_integer64,-1,0,0,list<class<`integer64`> | integer[]>,1
+bit64,hashtab.cache_integer64,0,0,0,"class<`cache`, `cache_integer64`, `environment`>",1
+bit64,hashtab.cache_integer64,1,0,0,...,1
+bit64,hashuni,-1,0,0,class<`integer64`>,1
+bit64,hashuni,0,0,0,"class<`cache`, `cache_integer64`, `environment`>",1
+bit64,hashuni,1,0,0,...,1
+bit64,hashuni.cache_integer64,-1,0,0,class<`integer64`>,1
+bit64,hashuni.cache_integer64,0,0,0,"class<`cache`, `cache_integer64`, `environment`>",1
+bit64,hashuni.cache_integer64,1,0,0,logical,1
+bit64,hashuni.cache_integer64,2,0,0,...,1
+bit64,hashupo,-1,0,0,integer[],1
+bit64,hashupo,0,0,0,"class<`cache`, `cache_integer64`, `environment`>",1
+bit64,hashupo,1,0,0,...,1
+bit64,hashupo.cache_integer64,-1,0,0,integer[],1
+bit64,hashupo.cache_integer64,0,0,0,"class<`cache`, `cache_integer64`, `environment`>",1
+bit64,hashupo.cache_integer64,1,0,0,logical,1
+bit64,hashupo.cache_integer64,2,0,0,...,1
+bit64,identical.integer64,-1,0,0,logical,1
+bit64,identical.integer64,0,0,0,character[],1
+bit64,identical.integer64,0,0,1,class<`data.frame`>,1
+bit64,identical.integer64,0,0,2,class<`integer64`>,1
+bit64,identical.integer64,0,0,3,^logical[],1
+bit64,identical.integer64,0,0,4,null,1
+bit64,identical.integer64,1,0,0,character[],1
+bit64,identical.integer64,1,0,1,class<`data.frame`>,1
+bit64,identical.integer64,1,0,2,class<`integer64`>,1
+bit64,identical.integer64,1,0,3,^logical[],1
+bit64,identical.integer64,2,0,0,logical,1
+bit64,identical.integer64,3,0,0,logical,1
+bit64,identical.integer64,4,0,0,logical,1
+bit64,identical.integer64,5,0,0,logical,1
+bit64,%in%,-1,0,0,logical[],1
+bit64,%in%,0,0,0,^integer[],1
+bit64,%in%,0,0,1,character,1
+bit64,%in%,0,0,2,class<`integer64`>,1
+bit64,%in%,0,0,3,double,1
+bit64,%in%,1,0,0,^integer[],1
+bit64,%in%,1,0,1,character[],1
+bit64,%in%,1,0,2,class<`integer64`>,1
+bit64,%in%.default,-1,0,0,logical[],1
+bit64,%in%.default,0,0,0,^integer[],1
+bit64,%in%.default,0,0,1,character,1
+bit64,%in%.default,0,0,2,double,1
+bit64,%in%.default,1,0,0,^integer[],1
+bit64,%in%.default,1,0,1,character[],1
+bit64,%in%.integer64,-1,0,0,logical[],1
+bit64,%in%.integer64,0,0,0,class<`integer64`>,1
+bit64,%in%.integer64,1,0,0,class<`integer64`>,1
+bit64,%in%.integer64,2,0,0,...,1
+bit64,integer64,-1,0,0,class<`integer64`>,1
+bit64,integer64,0,0,0,double,1
+bit64,^.integer64,-1,0,0,class<`integer64`>,1
+bit64,^.integer64,0,0,0,class<`integer64`>,1
+bit64,^.integer64,1,0,0,double[],1
+bit64,<=.integer64,-1,0,0,^logical[],1
+bit64,<=.integer64,0,0,0,class<`integer64`>,1
+bit64,<=.integer64,1,0,0,class<`integer64`>,1
+bit64,<.integer64,-1,0,0,^logical[],1
+bit64,<.integer64,0,0,0,class<`integer64`>,1
+bit64,<.integer64,1,0,0,class<`integer64`>,1
+bit64,==.integer64,-1,0,0,^logical[],1
+bit64,==.integer64,0,0,0,class<`integer64`>,1
+bit64,==.integer64,1,0,0,class<`integer64`>,1
+bit64,==.integer64,1,0,1,integer,1
+bit64,>=.integer64,-1,0,0,^logical[],1
+bit64,>=.integer64,0,0,0,class<`integer64`>,1
+bit64,>=.integer64,1,0,0,class<`integer64`>,1
+bit64,>.integer64,-1,0,0,^logical[],1
+bit64,>.integer64,0,0,0,class<`integer64`>,1
+bit64,>.integer64,1,0,0,class<`integer64`>,1
+bit64,|.integer64,-1,0,0,^logical[],1
+bit64,|.integer64,0,0,0,class<`integer64`>,1
+bit64,|.integer64,1,0,0,class<`integer64`>,1
+bit64,-.integer64,-1,0,0,class<`integer64`>,1
+bit64,-.integer64,0,0,0,class<`integer64`>,1
+bit64,-.integer64,0,0,1,double,1
+bit64,-.integer64,1,0,0,any,1
+bit64,:.integer64,-1,0,0,class<`integer64`>,1
+bit64,:.integer64,0,0,0,class<`integer64`>,1
+bit64,:.integer64,1,0,0,double,1
+bit64,!=.integer64,-1,0,0,^logical[],1
+bit64,!=.integer64,0,0,0,class<`integer64`>,1
+bit64,!=.integer64,1,0,0,class<`integer64`>,1
+bit64,!.integer64,-1,0,0,^logical[],1
+bit64,!.integer64,0,0,0,class<`integer64`>,1
+bit64,/.integer64,-1,0,0,double[],1
+bit64,/.integer64,0,0,0,class<`integer64`>,1
+bit64,/.integer64,1,0,0,double,1
+bit64,[<-.integer64,-1,0,0,class<`integer64`>,1
+bit64,[<-.integer64,0,0,0,class<`integer64`>,1
+bit64,[<-.integer64,1,0,0,...,1
+bit64,[<-.integer64,2,0,0,class<`integer64`>,1
+bit64,[<-.integer64,2,0,1,double,1
+bit64,[<-.integer64,2,0,2,integer[],1
+bit64,[<-.integer64,2,0,3,null,1
+bit64,[.integer64,-1,0,0,"class<`AsIs`, `integer64`>",1
+bit64,[.integer64,-1,0,1,class<`integer64`>,1
+bit64,[.integer64,0,0,0,"class<`AsIs`, `integer64`>",1
+bit64,[.integer64,0,0,1,class<`integer64`>,1
+bit64,[.integer64,1,0,0,...,1
+bit64,[[<-.integer64,-1,0,0,class<`integer64`>,1
+bit64,[[<-.integer64,0,0,0,class<`integer64`>,1
+bit64,[[<-.integer64,1,0,0,...,1
+bit64,[[<-.integer64,2,0,0,class<`integer64`>,1
+bit64,[[<-.integer64,2,0,1,double,1
+bit64,[[<-.integer64,2,0,2,integer[],1
+bit64,[[<-.integer64,2,0,3,null,1
+bit64,[[.integer64,-1,0,0,class<`integer64`>,1
+bit64,[[.integer64,0,0,0,class<`integer64`>,1
+bit64,[[.integer64,1,0,0,...,1
+bit64,*.integer64,-1,0,0,class<`integer64`>,1
+bit64,*.integer64,0,0,0,class<`integer64`>,1
+bit64,*.integer64,0,0,1,double[],1
+bit64,*.integer64,1,0,0,class<`integer64`>,1
+bit64,*.integer64,1,0,1,double,1
+bit64,*.integer64,1,0,2,integer[],1
+bit64,&.integer64,-1,0,0,^logical[],1
+bit64,&.integer64,0,0,0,class<`integer64`>,1
+bit64,&.integer64,1,0,0,class<`integer64`>,1
+bit64,%/%.integer64,-1,0,0,class<`integer64`>,1
+bit64,%/%.integer64,0,0,0,class<`integer64`>,1
+bit64,%/%.integer64,1,0,0,class<`integer64`>,1
+bit64,%/%.integer64,1,0,1,double,1
+bit64,+.integer64,-1,0,0,class<`integer64`>,1
+bit64,+.integer64,0,0,0,class<`integer64`>,1
+bit64,+.integer64,0,0,1,integer[],1
+bit64,+.integer64,1,0,0,class<`integer64`>,1
+bit64,+.integer64,1,0,1,double,1
+bit64,+.integer64,1,0,2,integer[],1
+bit64,is.double,-1,0,0,logical,1
+bit64,is.double,0,0,0,class<`integer64`>,1
+bit64,is.double,0,0,1,double[],1
+bit64,is.double.default,-1,0,0,logical,1
+bit64,is.double.default,0,0,0,double[],1
+bit64,is.double.integer64,-1,0,0,logical,1
+bit64,is.double.integer64,0,0,0,class<`integer64`>,1
+bit64,is.integer64,-1,0,0,logical,1
+bit64,is.integer64,0,0,0,character[],1
+bit64,is.integer64,0,0,1,class<`integer64`>,1
+bit64,is.integer64,0,0,2,double[],1
+bit64,is.integer64,0,0,3,null,1
+bit64,is.na.integer64,-1,0,0,logical[],1
+bit64,is.na.integer64,0,0,0,class<`integer64`>,1
+bit64,is.sorted.integer64,-1,0,0,logical,1
+bit64,is.sorted.integer64,0,0,0,class<`integer64`>,1
+bit64,is.sorted.integer64,1,0,0,...,1
+bit64,jamcache,-1,0,0,"class<`cache`, `cache_integer64`, `environment`>",1
+bit64,jamcache,0,0,0,class<`integer64`>,1
+bit64,keypos,-1,0,0,integer[],1
+bit64,keypos,0,0,0,class<`integer64`>,1
+bit64,keypos,1,0,0,...,1
+bit64,keypos.integer64,-1,0,0,integer[],1
+bit64,keypos.integer64,0,0,0,class<`integer64`>,1
+bit64,keypos.integer64,1,0,0,null,1
+bit64,keypos.integer64,2,0,0,...,1
+bit64,length<-.integer64,-1,0,0,class<`integer64`>,1
+bit64,length<-.integer64,0,0,0,class<`integer64`>,1
+bit64,length<-.integer64,1,0,0,double,1
+bit64,lim.integer64,-1,0,0,class<`integer64`>,1
+bit64,log10.integer64,-1,0,0,double[],1
+bit64,log10.integer64,0,0,0,class<`integer64`>,1
+bit64,log2.integer64,-1,0,0,double[],1
+bit64,log2.integer64,0,0,0,class<`integer64`>,1
+bit64,log.integer64,-1,0,0,double[],1
+bit64,log.integer64,0,0,0,class<`integer64`>,1
+bit64,log.integer64,1,0,0,double,1
+bit64,match,-1,0,0,^integer[],1
+bit64,match,0,0,0,^integer[],1
+bit64,match,0,0,1,class<`integer64`>,1
+bit64,match,0,0,2,double,1
+bit64,match,1,0,0,^integer[],1
+bit64,match,1,0,1,class<`integer64`>,1
+bit64,match,2,0,0,...,1
+bit64,match.default,-1,0,0,^integer[],1
+bit64,match.default,0,0,0,^integer[],1
+bit64,match.default,0,0,1,double,1
+bit64,match.default,1,0,0,^integer[],1
+bit64,match.default,2,0,0,...,1
+bit64,match.integer64,-1,0,0,^integer[],1
+bit64,match.integer64,0,0,0,class<`integer64`>,1
+bit64,match.integer64,1,0,0,class<`integer64`>,1
+bit64,match.integer64,2,0,0,null,1
+bit64,match.integer64,2,0,1,integer,1
+bit64,match.integer64,3,0,0,null,1
+bit64,match.integer64,4,0,0,null,1
+bit64,match.integer64,5,0,0,...,1
+bit64,max.integer64,-1,0,0,class<`integer64`>,1
+bit64,max.integer64,0,0,0,...,1
+bit64,max.integer64,1,0,0,logical,1
+bit64,mean.integer64,-1,0,0,class<`integer64`>,1
+bit64,mean.integer64,0,0,0,class<`integer64`>,1
+bit64,mean.integer64,1,0,0,logical,1
+bit64,mean.integer64,2,0,0,...,1
+bit64,median.integer64,-1,0,0,class<`integer64`>,1
+bit64,median.integer64,0,0,0,class<`integer64`>,1
+bit64,median.integer64,1,0,0,logical,1
+bit64,median.integer64,2,0,0,...,1
+bit64,mergeorder.integer64,-1,0,0,integer,1
+bit64,mergeorder.integer64,0,0,0,class<`integer64`>,1
+bit64,mergeorder.integer64,1,0,0,integer[],1
+bit64,mergeorder.integer64,2,0,0,logical,1
+bit64,mergeorder.integer64,3,0,0,logical,1
+bit64,mergeorder.integer64,4,0,0,logical,1
+bit64,mergeorder.integer64,5,0,0,...,1
+bit64,mergesort.integer64,-1,0,0,integer,1
+bit64,mergesort.integer64,0,0,0,class<`integer64`>,1
+bit64,mergesort.integer64,1,0,0,logical,1
+bit64,mergesort.integer64,2,0,0,logical,1
+bit64,mergesort.integer64,3,0,0,logical,1
+bit64,mergesort.integer64,4,0,0,...,1
+bit64,mergesortorder.integer64,-1,0,0,integer,1
+bit64,mergesortorder.integer64,0,0,0,class<`integer64`>,1
+bit64,mergesortorder.integer64,1,0,0,integer[],1
+bit64,mergesortorder.integer64,2,0,0,logical,1
+bit64,mergesortorder.integer64,3,0,0,logical,1
+bit64,mergesortorder.integer64,4,0,0,logical,1
+bit64,mergesortorder.integer64,5,0,0,...,1
+bit64,min.integer64,-1,0,0,class<`integer64`>,1
+bit64,min.integer64,0,0,0,...,1
+bit64,min.integer64,1,0,0,logical,1
+bit64,minusclass,-1,0,0,character[],1
+bit64,minusclass,0,0,0,character[],1
+bit64,minusclass,1,0,0,character,1
+bit64,na.count.integer64,-1,0,0,integer,1
+bit64,na.count.integer64,0,0,0,class<`integer64`>,1
+bit64,na.count.integer64,1,0,0,...,1
+bit64,newcache,-1,0,0,"class<`cache`, `cache_integer64`, `environment`>",1
+bit64,newcache,0,0,0,class<`integer64`>,1
+bit64,nties.integer64,-1,0,0,integer,1
+bit64,nties.integer64,0,0,0,class<`integer64`>,1
+bit64,nties.integer64,1,0,0,...,1
+bit64,nunique.integer64,-1,0,0,integer,1
+bit64,nunique.integer64,0,0,0,class<`integer64`>,1
+bit64,nunique.integer64,1,0,0,...,1
+bit64,nvalid.integer64,-1,0,0,integer,1
+bit64,nvalid.integer64,0,0,0,class<`integer64`>,1
+bit64,nvalid.integer64,1,0,0,...,1
+bit64,optimizer64,-1,0,0,class<`matrix`>,1
+bit64,optimizer64,0,0,0,double,1
+bit64,optimizer64,1,0,0,double,1
+bit64,optimizer64,2,0,0,class<`function`>,1
+bit64,optimizer64,3,0,0,character[],1
+bit64,optimizer64,4,0,0,character[],1
+bit64,optimizer64,5,0,0,character[],1
+bit64,optimizer64,6,0,0,logical,1
+bit64,order,-1,0,0,integer[],1
+bit64,order,0,0,0,...,1
+bit64,ordercache,-1,0,0,class<`integer64`>,1
+bit64,ordercache,0,0,0,class<`integer64`>,1
+bit64,ordercache,1,0,0,null,1
+bit64,ordercache,2,0,0,null,1
+bit64,ordercache,3,0,0,character,1
+bit64,order.default,-1,0,0,integer[],1
+bit64,order.default,0,0,0,...,1
+bit64,orderdup,-1,0,0,logical[],1
+bit64,orderdup,0,0,0,class<`integer64`>,1
+bit64,orderdup,1,0,0,integer[],1
+bit64,orderdup,2,0,0,...,1
+bit64,orderdup.integer64,-1,0,0,logical[],1
+bit64,orderdup.integer64,0,0,0,class<`integer64`>,1
+bit64,orderdup.integer64,1,0,0,integer[],1
+bit64,orderdup.integer64,2,0,0,double,1
+bit64,orderdup.integer64,2,0,1,null,1
+bit64,orderdup.integer64,3,0,0,...,1
+bit64,orderfin,-1,0,0,logical[],1
+bit64,orderfin,0,0,0,class<`integer64`>,1
+bit64,orderfin,1,0,0,integer[],1
+bit64,orderfin,2,0,0,class<`integer64`>,1
+bit64,orderfin,3,0,0,...,1
+bit64,orderfin.integer64,-1,0,0,logical[],1
+bit64,orderfin.integer64,0,0,0,class<`integer64`>,1
+bit64,orderfin.integer64,1,0,0,integer[],1
+bit64,orderfin.integer64,2,0,0,class<`integer64`>,1
+bit64,orderfin.integer64,3,0,0,null,1
+bit64,orderfin.integer64,4,0,0,...,1
+bit64,order.integer64,-1,0,0,integer[],1
+bit64,order.integer64,0,0,0,...,1
+bit64,order.integer64,1,0,0,logical,1
+bit64,order.integer64,2,0,0,logical,1
+bit64,order.integer64,3,0,0,logical,1
+bit64,order.integer64,4,0,0,logical,1
+bit64,order.integer64,5,0,0,any,1
+bit64,order.integer64,6,0,0,logical,1
+bit64,ordernut,-1,0,0,integer[],1
+bit64,ordernut,0,0,0,class<`integer64`>,1
+bit64,ordernut,1,0,0,integer[],1
+bit64,ordernut,2,0,0,...,1
+bit64,ordernut.integer64,-1,0,0,integer[],1
+bit64,ordernut.integer64,0,0,0,class<`integer64`>,1
+bit64,ordernut.integer64,1,0,0,integer[],1
+bit64,ordernut.integer64,2,0,0,...,1
+bit64,orderpos,-1,0,0,^integer[],1
+bit64,orderpos,0,0,0,class<`integer64`>,1
+bit64,orderpos,1,0,0,integer[],1
+bit64,orderpos,2,0,0,class<`integer64`>,1
+bit64,orderpos,3,0,0,...,1
+bit64,orderpos.integer64,-1,0,0,^integer[],1
+bit64,orderpos.integer64,0,0,0,class<`integer64`>,1
+bit64,orderpos.integer64,1,0,0,integer[],1
+bit64,orderpos.integer64,2,0,0,class<`integer64`>,1
+bit64,orderpos.integer64,3,0,0,null,1
+bit64,orderpos.integer64,4,0,0,double,1
+bit64,orderpos.integer64,4,0,1,null,1
+bit64,orderpos.integer64,5,0,0,...,1
+bit64,orderqtl,-1,0,0,class<`integer64`>,1
+bit64,orderqtl,0,0,0,class<`integer64`>,1
+bit64,orderqtl,1,0,0,integer[],1
+bit64,orderqtl,2,0,0,integer,1
+bit64,orderqtl,3,0,0,double[],1
+bit64,orderqtl,4,0,0,...,1
+bit64,orderqtl.integer64,-1,0,0,class<`integer64`>,1
+bit64,orderqtl.integer64,0,0,0,class<`integer64`>,1
+bit64,orderqtl.integer64,1,0,0,integer[],1
+bit64,orderqtl.integer64,2,0,0,integer,1
+bit64,orderqtl.integer64,3,0,0,double[],1
+bit64,orderqtl.integer64,4,0,0,...,1
+bit64,orderrnk,-1,0,0,^double[],1
+bit64,orderrnk,0,0,0,class<`integer64`>,1
+bit64,orderrnk,1,0,0,integer[],1
+bit64,orderrnk,2,0,0,integer,1
+bit64,orderrnk,3,0,0,...,1
+bit64,orderrnk.integer64,-1,0,0,^double[],1
+bit64,orderrnk.integer64,0,0,0,class<`integer64`>,1
+bit64,orderrnk.integer64,1,0,0,integer[],1
+bit64,orderrnk.integer64,2,0,0,integer,1
+bit64,orderrnk.integer64,3,0,0,...,1
+bit64,ordertab,-1,0,0,integer[],1
+bit64,ordertab,0,0,0,class<`integer64`>,1
+bit64,ordertab,1,0,0,integer[],1
+bit64,ordertab,2,0,0,any,1
+bit64,ordertab,3,0,0,...,1
+bit64,ordertab.integer64,-1,0,0,integer[],1
+bit64,ordertab.integer64,0,0,0,class<`integer64`>,1
+bit64,ordertab.integer64,1,0,0,integer[],1
+bit64,ordertab.integer64,2,0,0,any,1
+bit64,ordertab.integer64,3,0,0,logical,1
+bit64,ordertab.integer64,4,0,0,logical,1
+bit64,ordertab.integer64,5,0,0,...,1
+bit64,orderuni,-1,0,0,class<`integer64`>,1
+bit64,orderuni,0,0,0,class<`integer64`>,1
+bit64,orderuni,1,0,0,integer[],1
+bit64,orderuni,2,0,0,integer,1
+bit64,orderuni,3,0,0,...,1
+bit64,orderuni.integer64,-1,0,0,class<`integer64`>,1
+bit64,orderuni.integer64,0,0,0,class<`integer64`>,1
+bit64,orderuni.integer64,1,0,0,integer[],1
+bit64,orderuni.integer64,2,0,0,integer,1
+bit64,orderuni.integer64,3,0,0,logical,1
+bit64,orderuni.integer64,4,0,0,...,1
+bit64,orderupo,-1,0,0,integer[],1
+bit64,orderupo,0,0,0,class<`integer64`>,1
+bit64,orderupo,1,0,0,integer[],1
+bit64,orderupo,2,0,0,integer,1
+bit64,orderupo,3,0,0,...,1
+bit64,orderupo.integer64,-1,0,0,integer[],1
+bit64,orderupo.integer64,0,0,0,class<`integer64`>,1
+bit64,orderupo.integer64,1,0,0,integer[],1
+bit64,orderupo.integer64,2,0,0,integer,1
+bit64,orderupo.integer64,3,0,0,logical,1
+bit64,orderupo.integer64,4,0,0,...,1
+bit64,plusclass,-1,0,0,character[],1
+bit64,plusclass,0,0,0,character,1
+bit64,plusclass,0,0,1,null,1
+bit64,plusclass,1,0,0,character,1
+bit64,prank,-1,0,0,^double[],1
+bit64,prank,0,0,0,class<`integer64`>,1
+bit64,prank,1,0,0,...,1
+bit64,prank.integer64,-1,0,0,^double[],1
+bit64,prank.integer64,0,0,0,class<`integer64`>,1
+bit64,prank.integer64,1,0,0,null,1
+bit64,prank.integer64,2,0,0,...,1
+bit64,prod.integer64,-1,0,0,class<`integer64`>,1
+bit64,prod.integer64,0,0,0,...,1
+bit64,prod.integer64,1,0,0,logical,1
+bit64,qtile,-1,0,0,class<`integer64`>,1
+bit64,qtile,0,0,0,class<`integer64`>,1
+bit64,qtile,1,0,0,double[],1
+bit64,qtile,2,0,0,...,1
+bit64,qtile.integer64,-1,0,0,class<`integer64`>,1
+bit64,qtile.integer64,0,0,0,class<`integer64`>,1
+bit64,qtile.integer64,1,0,0,double[],1
+bit64,qtile.integer64,2,0,0,logical,1
+bit64,qtile.integer64,3,0,0,null,1
+bit64,qtile.integer64,4,0,0,...,1
+bit64,quantile.integer64,-1,0,0,class<`integer64`>,1
+bit64,quantile.integer64,0,0,0,class<`integer64`>,1
+bit64,quantile.integer64,1,0,0,double[],1
+bit64,quantile.integer64,2,0,0,logical,1
+bit64,quantile.integer64,3,0,0,logical,1
+bit64,quantile.integer64,4,0,0,integer,1
+bit64,quantile.integer64,5,0,0,...,1
+bit64,radixsort.integer64,-1,0,0,integer,1
+bit64,radixsort.integer64,0,0,0,class<`integer64`>,1
+bit64,radixsort.integer64,1,0,0,logical,1
+bit64,radixsort.integer64,2,0,0,logical,1
+bit64,radixsort.integer64,3,0,0,logical,1
+bit64,radixsort.integer64,4,0,0,integer,1
+bit64,radixsort.integer64,5,0,0,...,1
+bit64,radixsortorder.integer64,-1,0,0,integer,1
+bit64,radixsortorder.integer64,0,0,0,class<`integer64`>,1
+bit64,radixsortorder.integer64,1,0,0,integer[],1
+bit64,radixsortorder.integer64,2,0,0,logical,1
+bit64,radixsortorder.integer64,3,0,0,logical,1
+bit64,radixsortorder.integer64,4,0,0,logical,1
+bit64,radixsortorder.integer64,5,0,0,integer,1
+bit64,radixsortorder.integer64,6,0,0,...,1
+bit64,ramorder.integer64,-1,0,0,integer,1
+bit64,ramorder.integer64,0,0,0,class<`integer64`>,1
+bit64,ramorder.integer64,1,0,0,integer[],1
+bit64,ramorder.integer64,2,0,0,logical,1
+bit64,ramorder.integer64,3,0,0,logical,1
+bit64,ramorder.integer64,4,0,0,logical,1
+bit64,ramorder.integer64,5,0,0,logical,1
+bit64,ramorder.integer64,6,0,0,character[],1
+bit64,ramorder.integer64,7,0,0,logical,1
+bit64,ramorder.integer64,8,0,0,...,1
+bit64,ramsort.integer64,-1,0,0,integer,1
+bit64,ramsort.integer64,0,0,0,class<`integer64`>,1
+bit64,ramsort.integer64,1,0,0,logical,1
+bit64,ramsort.integer64,2,0,0,logical,1
+bit64,ramsort.integer64,3,0,0,logical,1
+bit64,ramsort.integer64,4,0,0,any,1
+bit64,ramsort.integer64,5,0,0,character[],1
+bit64,ramsort.integer64,6,0,0,logical,1
+bit64,ramsort.integer64,7,0,0,...,1
+bit64,ramsortorder.integer64,-1,0,0,integer,1
+bit64,ramsortorder.integer64,0,0,0,class<`integer64`>,1
+bit64,ramsortorder.integer64,1,0,0,integer[],1
+bit64,ramsortorder.integer64,2,0,0,logical,1
+bit64,ramsortorder.integer64,3,0,0,logical,1
+bit64,ramsortorder.integer64,4,0,0,logical,1
+bit64,ramsortorder.integer64,5,0,0,logical,1
+bit64,ramsortorder.integer64,6,0,0,character[],1
+bit64,ramsortorder.integer64,7,0,0,logical,1
+bit64,ramsortorder.integer64,8,0,0,...,1
+bit64,range.integer64,-1,0,0,class<`integer64`>,1
+bit64,range.integer64,0,0,0,...,1
+bit64,range.integer64,1,0,0,logical,1
+bit64,rank,-1,0,0,^double[],1
+bit64,rank,0,0,0,^integer[],1
+bit64,rank,0,0,1,class<`integer64`>,1
+bit64,rank,0,0,2,double[],1
+bit64,rank,1,0,0,...,1
+bit64,rank.default,-1,0,0,^double[],1
+bit64,rank.default,0,0,0,^integer[],1
+bit64,rank.default,0,0,1,double[],1
+bit64,rank.default,1,0,0,...,1
+bit64,rank.integer64,-1,0,0,^double[],1
+bit64,rank.integer64,0,0,0,class<`integer64`>,1
+bit64,rank.integer64,1,0,0,null,1
+bit64,rank.integer64,2,0,0,...,1
+bit64,remcache,-1,0,0,null,1
+bit64,remcache,0,0,0,"class<`AsIs`, `integer64`>",1
+bit64,remcache,0,0,1,class<`integer64`>,1
+bit64,remcache,0,0,2,integer[],1
+bit64,rep.integer64,-1,0,0,class<`integer64`>,1
+bit64,rep.integer64,0,0,0,class<`integer64`>,1
+bit64,rep.integer64,1,0,0,...,1
+bit64,seq.integer64,-1,0,0,class<`integer64`>,1
+bit64,seq.integer64,0,0,0,class<`integer64`>,1
+bit64,seq.integer64,0,0,1,null,1
+bit64,seq.integer64,0,0,2,double,1
+bit64,seq.integer64,1,0,0,double,1
+bit64,seq.integer64,1,0,1,null,1
+bit64,seq.integer64,1,0,2,class<`integer64`>,1
+bit64,seq.integer64,2,0,0,null,1
+bit64,seq.integer64,2,0,1,double,1
+bit64,seq.integer64,3,0,0,null,1
+bit64,seq.integer64,3,0,1,double,1
+bit64,seq.integer64,4,0,0,null,1
+bit64,seq.integer64,4,0,1,class<`integer64`>,1
+bit64,seq.integer64,4,0,2,integer[],1
+bit64,seq.integer64,5,0,0,...,1
+bit64,setcache,-1,0,0,"class<`cache`, `cache_integer64`, `environment`>",1
+bit64,setcache,0,0,0,class<`integer64`>,1
+bit64,setcache,1,0,0,character,1
+bit64,setcache,2,0,0,class<`integer64`>,1
+bit64,setcache,2,0,1,double,1
+bit64,setcache,2,0,2,integer[],1
+bit64,signif.integer64,-1,0,0,class<`integer64`>,1
+bit64,signif.integer64,0,0,0,class<`integer64`>,1
+bit64,signif.integer64,1,0,0,double,1
+bit64,sign.integer64,-1,0,0,class<`integer64`>,1
+bit64,sign.integer64,0,0,0,class<`integer64`>,1
+bit64,sortcache,-1,0,0,class<`integer64`>,1
+bit64,sortcache,0,0,0,class<`integer64`>,1
+bit64,sortcache,1,0,0,null,1
+bit64,sortfin,-1,0,0,logical[],1
+bit64,sortfin,0,0,0,class<`integer64`>,1
+bit64,sortfin,1,0,0,class<`integer64`>,1
+bit64,sortfin,2,0,0,...,1
+bit64,sortfin.integer64,-1,0,0,logical[],1
+bit64,sortfin.integer64,0,0,0,class<`integer64`>,1
+bit64,sortfin.integer64,1,0,0,class<`integer64`>,1
+bit64,sortfin.integer64,2,0,0,null,1
+bit64,sortfin.integer64,3,0,0,...,1
+bit64,sort.integer64,-1,0,0,class<`integer64`>,1
+bit64,sort.integer64,0,0,0,class<`integer64`>,1
+bit64,sort.integer64,1,0,0,logical,1
+bit64,sort.integer64,2,0,0,logical,1
+bit64,sort.integer64,3,0,0,logical,1
+bit64,sort.integer64,3,0,1,null,1
+bit64,sort.integer64,4,0,0,logical,1
+bit64,sort.integer64,5,0,0,any,1
+bit64,sort.integer64,6,0,0,logical,1
+bit64,sort.integer64,7,0,0,...,1
+bit64,sortnut,-1,0,0,integer[],1
+bit64,sortnut,0,0,0,class<`integer64`>,1
+bit64,sortnut,1,0,0,...,1
+bit64,sortnut.integer64,-1,0,0,integer[],1
+bit64,sortnut.integer64,0,0,0,class<`integer64`>,1
+bit64,sortnut.integer64,1,0,0,...,1
+bit64,sortordercache,-1,0,0,class<`integer64`>,1
+bit64,sortordercache,0,0,0,class<`integer64`>,1
+bit64,sortordercache,1,0,0,null,1
+bit64,sortordercache,2,0,0,null,1
+bit64,sortorderdup,-1,0,0,logical[],1
+bit64,sortorderdup,0,0,0,class<`integer64`>,1
+bit64,sortorderdup,1,0,0,integer[],1
+bit64,sortorderdup,2,0,0,...,1
+bit64,sortorderdup.integer64,-1,0,0,logical[],1
+bit64,sortorderdup.integer64,0,0,0,class<`integer64`>,1
+bit64,sortorderdup.integer64,1,0,0,integer[],1
+bit64,sortorderdup.integer64,2,0,0,double,1
+bit64,sortorderdup.integer64,2,0,1,null,1
+bit64,sortorderdup.integer64,3,0,0,...,1
+bit64,sortorderkey,-1,0,0,integer[],1
+bit64,sortorderkey,0,0,0,class<`integer64`>,1
+bit64,sortorderkey,1,0,0,integer[],1
+bit64,sortorderkey,2,0,0,integer,1
+bit64,sortorderkey,3,0,0,...,1
+bit64,sortorderkey.integer64,-1,0,0,integer[],1
+bit64,sortorderkey.integer64,0,0,0,class<`integer64`>,1
+bit64,sortorderkey.integer64,1,0,0,integer[],1
+bit64,sortorderkey.integer64,2,0,0,integer,1
+bit64,sortorderkey.integer64,3,0,0,...,1
+bit64,sortorderpos,-1,0,0,^integer[],1
+bit64,sortorderpos,0,0,0,class<`integer64`>,1
+bit64,sortorderpos,1,0,0,integer[],1
+bit64,sortorderpos,2,0,0,class<`integer64`>,1
+bit64,sortorderpos,3,0,0,...,1
+bit64,sortorderpos.integer64,-1,0,0,^integer[],1
+bit64,sortorderpos.integer64,0,0,0,class<`integer64`>,1
+bit64,sortorderpos.integer64,1,0,0,integer[],1
+bit64,sortorderpos.integer64,2,0,0,class<`integer64`>,1
+bit64,sortorderpos.integer64,3,0,0,null,1
+bit64,sortorderpos.integer64,4,0,0,null,1
+bit64,sortorderpos.integer64,5,0,0,...,1
+bit64,sortorderrnk,-1,0,0,^double[],1
+bit64,sortorderrnk,0,0,0,class<`integer64`>,1
+bit64,sortorderrnk,1,0,0,integer[],1
+bit64,sortorderrnk,2,0,0,integer,1
+bit64,sortorderrnk,3,0,0,...,1
+bit64,sortorderrnk.integer64,-1,0,0,^double[],1
+bit64,sortorderrnk.integer64,0,0,0,class<`integer64`>,1
+bit64,sortorderrnk.integer64,1,0,0,integer[],1
+bit64,sortorderrnk.integer64,2,0,0,integer,1
+bit64,sortorderrnk.integer64,3,0,0,...,1
+bit64,sortordertab,-1,0,0,integer[],1
+bit64,sortordertab,0,0,0,class<`integer64`>,1
+bit64,sortordertab,1,0,0,integer[],1
+bit64,sortordertab,2,0,0,...,1
+bit64,sortordertab.integer64,-1,0,0,integer[],1
+bit64,sortordertab.integer64,0,0,0,class<`integer64`>,1
+bit64,sortordertab.integer64,1,0,0,integer[],1
+bit64,sortordertab.integer64,2,0,0,logical,1
+bit64,sortordertab.integer64,3,0,0,...,1
+bit64,sortordertie,-1,0,0,integer[],1
+bit64,sortordertie,0,0,0,class<`integer64`>,1
+bit64,sortordertie,1,0,0,integer[],1
+bit64,sortordertie,2,0,0,integer,1
+bit64,sortordertie,3,0,0,...,1
+bit64,sortordertie.integer64,-1,0,0,integer[],1
+bit64,sortordertie.integer64,0,0,0,class<`integer64`>,1
+bit64,sortordertie.integer64,1,0,0,integer[],1
+bit64,sortordertie.integer64,2,0,0,integer,1
+bit64,sortordertie.integer64,3,0,0,...,1
+bit64,sortorderuni,-1,0,0,class<`integer64`>,1
+bit64,sortorderuni,0,0,0,class<`integer64`>,1
+bit64,sortorderuni,1,0,0,class<`integer64`>,1
+bit64,sortorderuni,2,0,0,integer[],1
+bit64,sortorderuni,3,0,0,integer,1
+bit64,sortorderuni,4,0,0,...,1
+bit64,sortorderuni.integer64,-1,0,0,class<`integer64`>,1
+bit64,sortorderuni.integer64,0,0,0,class<`integer64`>,1
+bit64,sortorderuni.integer64,1,0,0,class<`integer64`>,1
+bit64,sortorderuni.integer64,2,0,0,integer[],1
+bit64,sortorderuni.integer64,3,0,0,integer,1
+bit64,sortorderuni.integer64,4,0,0,...,1
+bit64,sortorderupo,-1,0,0,integer[],1
+bit64,sortorderupo,0,0,0,class<`integer64`>,1
+bit64,sortorderupo,1,0,0,integer[],1
+bit64,sortorderupo,2,0,0,integer,1
+bit64,sortorderupo,3,0,0,logical,1
+bit64,sortorderupo,4,0,0,...,1
+bit64,sortorderupo.integer64,-1,0,0,integer[],1
+bit64,sortorderupo.integer64,0,0,0,class<`integer64`>,1
+bit64,sortorderupo.integer64,1,0,0,integer[],1
+bit64,sortorderupo.integer64,2,0,0,integer,1
+bit64,sortorderupo.integer64,3,0,0,logical,1
+bit64,sortorderupo.integer64,4,0,0,...,1
+bit64,sortqtl,-1,0,0,class<`integer64`>,1
+bit64,sortqtl,0,0,0,class<`integer64`>,1
+bit64,sortqtl,1,0,0,integer,1
+bit64,sortqtl,2,0,0,double[],1
+bit64,sortqtl,3,0,0,...,1
+bit64,sortqtl.integer64,-1,0,0,class<`integer64`>,1
+bit64,sortqtl.integer64,0,0,0,class<`integer64`>,1
+bit64,sortqtl.integer64,1,0,0,integer,1
+bit64,sortqtl.integer64,2,0,0,double[],1
+bit64,sortqtl.integer64,3,0,0,...,1
+bit64,sorttab,-1,0,0,integer[],1
+bit64,sorttab,0,0,0,class<`integer64`>,1
+bit64,sorttab,1,0,0,integer,1
+bit64,sorttab,2,0,0,...,1
+bit64,sorttab.integer64,-1,0,0,integer[],1
+bit64,sorttab.integer64,0,0,0,class<`integer64`>,1
+bit64,sorttab.integer64,1,0,0,integer,1
+bit64,sorttab.integer64,2,0,0,...,1
+bit64,sortuni,-1,0,0,class<`integer64`>,1
+bit64,sortuni,0,0,0,class<`integer64`>,1
+bit64,sortuni,1,0,0,integer,1
+bit64,sortuni,2,0,0,...,1
+bit64,sortuni.integer64,-1,0,0,class<`integer64`>,1
+bit64,sortuni.integer64,0,0,0,class<`integer64`>,1
+bit64,sortuni.integer64,1,0,0,integer,1
+bit64,sortuni.integer64,2,0,0,...,1
+bit64,sqrt.integer64,-1,0,0,double[],1
+bit64,sqrt.integer64,0,0,0,class<`integer64`>,1
+bit64,still.identical,-1,0,0,logical,1
+bit64,still.identical,0,0,0,class<`integer64`>,1
+bit64,still.identical,1,0,0,class<`integer64`>,1
+bit64,str.integer64,-1,0,0,null,1
+bit64,str.integer64,0,0,0,"class<`AsIs`, `integer64`>",1
+bit64,str.integer64,0,0,1,class<`integer64`>,1
+bit64,str.integer64,1,0,0,integer,1
+bit64,str.integer64,2,0,0,logical,1
+bit64,str.integer64,3,0,0,logical,1
+bit64,str.integer64,4,0,0,...,1
+bit64,sum.integer64,-1,0,0,class<`integer64`>,1
+bit64,sum.integer64,0,0,0,...,1
+bit64,sum.integer64,1,0,0,logical,1
+bit64,summary.integer64,-1,0,0,class<`integer64`>,1
+bit64,summary.integer64,0,0,0,class<`integer64`>,1
+bit64,summary.integer64,1,0,0,...,1
+bit64,table.integer64,-1,0,0,class<`data.frame`>,1
+bit64,table.integer64,-1,0,1,class<`table`>,1
+bit64,table.integer64,-1,0,2,list<class<`integer64`> | integer[]>,1
+bit64,table.integer64,0,0,0,...,1
+bit64,table.integer64,1,0,0,character[],1
+bit64,table.integer64,2,0,0,character[],1
+bit64,table.integer64,3,0,0,null,1
+bit64,table.integer64,4,0,0,null,1
+bit64,table.integer64,5,0,0,character[],1
+bit64,table.integer64,6,0,0,double,1
+bit64,tiepos,-1,0,0,integer[],1
+bit64,tiepos,0,0,0,class<`integer64`>,1
+bit64,tiepos,1,0,0,...,1
+bit64,tiepos.integer64,-1,0,0,integer[],1
+bit64,tiepos.integer64,0,0,0,class<`integer64`>,1
+bit64,tiepos.integer64,1,0,0,null,1
+bit64,tiepos.integer64,2,0,0,null,1
+bit64,tiepos.integer64,3,0,0,...,1
+bit64,trunc.integer64,-1,0,0,class<`integer64`>,1
+bit64,trunc.integer64,0,0,0,class<`integer64`>,1
+bit64,trunc.integer64,1,0,0,...,1
+bit64,unipos,-1,0,0,integer[],1
+bit64,unipos,0,0,0,class<`integer64`>,1
+bit64,unipos,1,0,0,logical,1
+bit64,unipos,2,0,0,any,1
+bit64,unipos,3,0,0,...,1
+bit64,unipos.integer64,-1,0,0,integer[],1
+bit64,unipos.integer64,0,0,0,class<`integer64`>,1
+bit64,unipos.integer64,1,0,0,logical,1
+bit64,unipos.integer64,2,0,0,character[],1
+bit64,unipos.integer64,3,0,0,null,1
+bit64,unipos.integer64,4,0,0,null,1
+bit64,unipos.integer64,5,0,0,...,1
+bit64,unique.integer64,-1,0,0,class<`integer64`>,1
+bit64,unique.integer64,0,0,0,class<`integer64`>,1
+bit64,unique.integer64,1,0,0,logical,1
+bit64,unique.integer64,2,0,0,character[],1
+bit64,unique.integer64,3,0,0,null,1
+bit64,unique.integer64,4,0,0,null,1
+bit64,unique.integer64,5,0,0,...,1
+bit64,xor.integer64,-1,0,0,^logical[],1
+bit64,xor.integer64,0,0,0,class<`integer64`>,1
+bit64,xor.integer64,1,0,0,class<`integer64`>,1
+bitops,bitAnd,-1,0,0,^double[],1
+bitops,bitAnd,0,0,0,^double[],1
+bitops,bitAnd,1,0,0,^double[],1
+bitops,bitFlip,-1,0,0,^double[],1
+bitops,bitFlip,0,0,0,^double[],1
+bitops,bitFlip,1,0,0,double,1
+bitops,bitOr,-1,0,0,^double[],1
+bitops,bitOr,0,0,0,^double[],1
+bitops,bitOr,1,0,0,^double[],1
+bitops,bitShiftL,-1,0,0,^double[],1
+bitops,bitShiftL,0,0,0,^double[],1
+bitops,bitShiftL,1,0,0,double[],1
+bitops,bitShiftR,-1,0,0,^double[],1
+bitops,bitShiftR,0,0,0,^double[],1
+bitops,bitShiftR,1,0,0,double[],1
+bitops,bitXor,-1,0,0,^double[],1
+bitops,bitXor,0,0,0,^double[],1
+bitops,bitXor,1,0,0,^double[],1
+bitops,cksum,-1,0,0,double[],1
+bitops,cksum,0,0,0,character[],1
+blob,as_blob,-1,0,0,"class<`blob`, `vctrs_list_of`, `vctrs_vctr`>",1
+blob,as_blob,0,0,0,character[],1
+blob,as.blob,-1,0,0,"class<`blob`, `vctrs_list_of`, `vctrs_vctr`>",1
+blob,as.blob,0,0,0,character[],1
+blob,as.blob,1,0,0,...,1
+blob,as.blob.default,-1,0,0,"class<`blob`, `vctrs_list_of`, `vctrs_vctr`>",1
+blob,as.blob.default,0,0,0,character[],1
+blob,as.blob.default,1,0,0,...,1
+blob,blob,-1,0,0,"class<`blob`, `vctrs_list_of`, `vctrs_vctr`>",1
+blob,blob,0,0,0,...,1
+blob,check_raw_list,-1,0,0,null,1
+blob,check_raw_list,0,0,0,list<raw[]>,1
+blob,check_raw_list,1,0,0,any,1
+blob,is_raw_list,-1,0,0,logical,1
+blob,is_raw_list,0,0,0,list<raw[]>,1
+blob,new_blob,-1,0,0,"class<`blob`, `vctrs_list_of`, `vctrs_vctr`>",1
+blob,new_blob,0,0,0,list<any>,1
+blob,signal_soft_deprecated,-1,0,0,null,1
+blob,signal_soft_deprecated,0,0,0,character,1
+blob,signal_soft_deprecated,1,0,0,character,1
+blob,signal_soft_deprecated,2,0,0,environment,1
+blob,validate_blob,-1,0,0,null,1
+blob,validate_blob,0,0,0,list<raw[]>,1
+blob,vec_cast.blob,-1,0,0,"class<`blob`, `vctrs_list_of`, `vctrs_vctr`>",1
+blob,vec_cast.blob,0,0,0,character[],1
+blob,vec_cast.blob,1,0,0,"class<`blob`, `vctrs_list_of`, `vctrs_vctr`>",1
+blob,vec_cast.blob,2,0,0,...,1
+blob,vec_cast.blob.character,-1,0,0,"class<`blob`, `vctrs_list_of`, `vctrs_vctr`>",1
+blob,vec_cast.blob.character,0,0,0,character[],1
+blob,vec_cast.blob.character,1,0,0,"class<`blob`, `vctrs_list_of`, `vctrs_vctr`>",1
+blob,vec_cast.blob.character,2,0,0,...,1
+blob,warn_deprecated,-1,0,0,character,1
+blob,warn_deprecated,0,0,0,character,1
+blob,warn_deprecated,1,0,0,character,1
+bootstrap,abcnon,-1,0,0,list<any>,1
+bootstrap,abcnon,0,0,0,class<`matrix`>,1
+bootstrap,abcnon,0,0,1,double[],1
+bootstrap,abcnon,1,0,0,class<`function`>,1
+bootstrap,abcnon,2,0,0,double,1
+bootstrap,abcnon,3,0,0,double[],1
+bootstrap,bcanon,-1,0,0,list<class<`matrix`> | double[] | class<`call`>>,1
+bootstrap,bcanon,0,0,0,double[],1
+bootstrap,bcanon,1,0,0,double,1
+bootstrap,bcanon,2,0,0,class<`function`>,1
+bootstrap,bcanon,3,0,0,...,1
+bootstrap,bcanon,4,0,0,double[],1
+bootstrap,bootpred,-1,0,0,list<double | class<`call`>>,1
+bootstrap,bootpred,0,0,0,double[],1
+bootstrap,bootpred,1,0,0,double[],1
+bootstrap,bootpred,2,0,0,double,1
+bootstrap,bootpred,3,0,0,class<`function`>,1
+bootstrap,bootpred,4,0,0,class<`function`>,1
+bootstrap,bootpred,5,0,0,class<`function`>,1
+bootstrap,bootpred,6,0,0,...,1
+bootstrap,bootstrap,-1,0,0,list<double[] | class<`call`>>,1
+bootstrap,bootstrap,-1,0,1,list<double[] | null | class<`call`>>,1
+bootstrap,bootstrap,0,0,0,double[],1
+bootstrap,bootstrap,1,0,0,double,1
+bootstrap,bootstrap,2,0,0,class<`function`>,1
+bootstrap,bootstrap,3,0,0,...,1
+bootstrap,bootstrap,4,0,0,class<`function`>,1
+bootstrap,bootstrap,4,0,1,null,1
+bootstrap,boott,-1,0,0,list<class<`matrix`> | double[] | class<`call`>>,1
+bootstrap,boott,-1,0,1,list<class<`matrix`> | null | class<`call`>>,1
+bootstrap,boott,0,0,0,double[],1
+bootstrap,boott,1,0,0,class<`function`>,1
+bootstrap,boott,2,0,0,...,1
+bootstrap,boott,3,0,0,class<`function`>,1
+bootstrap,boott,4,0,0,double,1
+bootstrap,boott,5,0,0,double,1
+bootstrap,boott,6,0,0,logical,1
+bootstrap,boott,7,0,0,double,1
+bootstrap,boott,8,0,0,double,1
+bootstrap,boott,9,0,0,double,1
+bootstrap,boott,10,0,0,double[],1
+bootstrap,crossval,-1,0,0,list<double[] | class<`call`> | list<integer[]>>,1
+bootstrap,crossval,0,0,0,double[],1
+bootstrap,crossval,1,0,0,double[],1
+bootstrap,crossval,2,0,0,class<`function`>,1
+bootstrap,crossval,3,0,0,class<`function`>,1
+bootstrap,crossval,4,0,0,...,1
+bootstrap,crossval,5,0,0,double,1
+bootstrap,ctsub,-1,0,0,double[],1
+bootstrap,ctsub,0,0,0,double[],1
+bootstrap,ctsub,1,0,0,double[],1
+bootstrap,ctsub,2,0,0,double[],1
+bootstrap,jackknife,-1,0,0,list<double[] | class<`call`>>,1
+bootstrap,jackknife,0,0,0,double[],1
+bootstrap,jackknife,1,0,0,class<`function`>,1
+bootstrap,jackknife,2,0,0,...,1
+bootstrap,xinter,-1,0,0,double,1
+bootstrap,xinter,0,0,0,double[],1
+bootstrap,xinter,1,0,0,double[],1
+bootstrap,xinter,2,0,0,double,1
+bootstrap,xinter,3,0,0,logical,1
+bootstrap,yinter,-1,0,0,double,1
+bootstrap,yinter,0,0,0,double[],1
+bootstrap,yinter,1,0,0,double[],1
+bootstrap,yinter,2,0,0,double,1
+bootstrap,yinter,3,0,0,logical,1
+brew,brew,-1,0,0,class<`try-error`>,1
+brew,brew,-1,0,1,null,1
+brew,brew,0,0,0,character,1
+brew,brew,1,0,0,character,1
+brew,brew,1,0,1,"class<`connection`, `terminal`>",1
+brew,brew,2,0,0,null,1
+brew,brew,3,0,0,environment,1
+brew,brew,4,0,0,logical,1
+brew,brew,5,0,0,logical,1
+brew,brew,6,0,0,null,1
+brew,brew,6,0,1,class<`function`>,1
+brew,brew,7,0,0,logical,1
+brew,brewCache,-1,0,0,environment,1
+brew,brewCache,-1,0,1,null,1
+brew,brewCache,0,0,0,null,1
+brew,brewCache,0,0,1,environment,1
+brew,brewCacheOff,-1,0,0,null,1
+brew,brewCacheOn,-1,0,0,null,1
+calibrate,calibrate,-1,0,0,list<null | class<`matrix`> | double[]>,1
+calibrate,calibrate,0,0,0,class<`matrix`>,1
+calibrate,calibrate,0,0,1,double[],1
+calibrate,calibrate,1,0,0,class<`matrix`>,1
+calibrate,calibrate,1,0,1,double[],1
+calibrate,calibrate,2,0,0,double[],1
+calibrate,calibrate,3,0,0,class<`matrix`>,1
+calibrate,calibrate,4,0,0,any,1
+calibrate,calibrate,5,0,0,double,1
+calibrate,calibrate,6,0,0,logical,1
+calibrate,calibrate,7,0,0,logical,1
+calibrate,calibrate,8,0,0,logical,1
+calibrate,calibrate,9,0,0,logical,1
+calibrate,calibrate,10,0,0,character,1
+calibrate,calibrate,11,0,0,logical,1
+calibrate,calibrate,12,0,0,null,1
+calibrate,calibrate,13,0,0,double,1
+calibrate,calibrate,14,0,0,class<`matrix`>,1
+calibrate,calibrate,15,0,0,character,1
+calibrate,canocor,-1,0,0,list<class<`matrix`>>,1
+calibrate,canocor,0,0,0,class<`matrix`>,1
+calibrate,canocor,1,0,0,class<`matrix`>,1
+calibrate,circle,-1,0,0,null,1
+calibrate,circle,0,0,0,double,1
+calibrate,circle,1,0,0,double[],1
+calibrate,dlines,-1,0,0,null,1
+calibrate,dlines,0,0,0,class<`matrix`>,1
+calibrate,dlines,1,0,0,class<`matrix`>,1
+calibrate,dlines,2,0,0,character,1
+calibrate,ones,-1,0,0,class<`matrix`>,1
+calibrate,ones,0,0,0,double,1
+calibrate,ones,1,0,0,double,1
+calibrate,origin,-1,0,0,null,1
+calibrate,origin,0,0,0,double[],1
+calibrate,origin,1,0,0,...,1
+calibrate,PrinCoor,-1,0,0,list<class<`matrix`> | double[] | class<`data.frame`>>,1
+calibrate,PrinCoor,0,0,0,class<`matrix`>,1
+calibrate,PrinCoor,1,0,0,double,1
+calibrate,rad2degree,-1,0,0,class<`matrix`>,1
+calibrate,rad2degree,-1,0,1,double,1
+calibrate,rad2degree,0,0,0,class<`matrix`>,1
+calibrate,rad2degree,0,0,1,double,1
+calibrate,rda,-1,0,0,list<class<`matrix`>>,1
+calibrate,rda,0,0,0,class<`data.frame`>,1
+calibrate,rda,0,0,1,class<`matrix`>,1
+calibrate,rda,1,0,0,class<`data.frame`>,1
+calibrate,rda,1,0,1,class<`matrix`>,1
+calibrate,rda,2,0,0,double,1
+calibrate,shiftvector,-1,0,0,list<double[]>,1
+calibrate,shiftvector,0,0,0,double[],1
+calibrate,shiftvector,1,0,0,class<`matrix`>,1
+calibrate,shiftvector,2,0,0,double[],1
+calibrate,shiftvector,3,0,0,logical,1
+calibrate,textxy,-1,0,0,null,1
+calibrate,textxy,0,0,0,double[],1
+calibrate,textxy,1,0,0,double[],1
+calibrate,textxy,2,0,0,integer[],1
+calibrate,textxy,2,0,1,expression,1
+calibrate,textxy,2,0,2,character[],1
+calibrate,textxy,3,0,0,double[],1
+calibrate,textxy,4,0,0,double,1
+calibrate,textxy,5,0,0,double,1
+calibrate,textxy,6,0,0,...,1
+capushe,AICcapushe,-1,0,0,list<character | double>,1
+capushe,AICcapushe,0,0,0,class<`data.frame`>,1
+capushe,AICcapushe,1,0,0,double,1
+capushe,BICcapushe,-1,0,0,list<character | double>,1
+capushe,BICcapushe,0,0,0,class<`data.frame`>,1
+capushe,BICcapushe,1,0,0,double,1
+capushe,capushe,-1,0,0,class<`Capushe`>,1
+capushe,capushe,0,0,0,class<`data.frame`>,1
+capushe,capushe,1,0,0,double,1
+capushe,capushe,2,0,0,double,1
+capushe,capushe,3,0,0,double,1
+capushe,capushe,4,0,0,class<`function`>,1
+capushe,capushe,5,0,0,double,1
+capushe,capushe,6,0,0,double,1
+capushe,capushe,7,0,0,double,1
+capushe,DDSE,-1,0,0,class<`DDSE`>,1
+capushe,DDSE,0,0,0,class<`data.frame`>,1
+capushe,DDSE,1,0,0,double,1
+capushe,DDSE,2,0,0,double,1
+capushe,DDSE,3,0,0,class<`function`>,1
+capushe,DDSE,3,0,1,character,1
+capushe,DDSE,4,0,0,double,1
+capushe,Djump,-1,0,0,class<`Djump`>,1
+capushe,Djump,0,0,0,class<`data.frame`>,1
+capushe,Djump,1,0,0,double,1
+capushe,Djump,2,0,0,double,1
+capushe,Djump,3,0,0,double,1
+capushe,plot,-1,0,0,list<double[] | character>,1
+capushe,plot,0,0,0,class<`DDSE`>,1
+capushe,plot,1,0,0,any,1
+capushe,plot,2,0,0,...,1
+capushe,plot,-1,1,0,list<double[] | character>,1
+capushe,plot,0,1,0,class<`Capushe`>,1
+capushe,plot,1,1,0,any,1
+capushe,plot,2,1,0,...,1
+capushe,plot,-1,2,0,list<double[] | character>,1
+capushe,plot,0,2,0,class<`Djump`>,1
+capushe,plot,1,2,0,any,1
+capushe,plot,2,2,0,...,1
+capushe,validation,-1,0,0,list<double[] | character>,1
+capushe,validation,0,0,0,class<`Capushe`>,1
+capushe,validation,1,0,0,class<`data.frame`>,1
+capushe,validation,2,0,0,...,1
+capushe,validation,-1,1,0,list<double[] | character>,1
+capushe,validation,0,1,0,class<`Capushe`>,1
+capushe,validation,0,1,1,class<`DDSE`>,1
+capushe,validation,1,1,0,class<`data.frame`>,1
+capushe,validation,2,1,0,...,1
+capushe,validation,-1,2,0,list<double[] | character>,1
+capushe,validation,0,2,0,class<`DDSE`>,1
+capushe,validation,1,2,0,class<`data.frame`>,1
+capushe,validation,2,2,0,...,1
+cellranger,%||%,-1,0,0,logical,1
+cellranger,%||%,0,0,0,logical,1
+cellranger,%||%,0,0,1,null,1
+cellranger,%||%,1,0,0,any,1
+cellranger,A1_to_R1C1,-1,0,0,^character[],1
+cellranger,A1_to_R1C1,-1,0,1,null,1
+cellranger,A1_to_R1C1,0,0,0,character[],1
+cellranger,A1_to_R1C1,1,0,0,logical,1
+cellranger,A1_to_ra_ref,-1,0,0,"list<class<`list`, `ra_ref`>>",1
+cellranger,A1_to_ra_ref,0,0,0,character[],1
+cellranger,A1_to_ra_ref,1,0,0,logical,1
+cellranger,addr_col,-1,0,0,integer[],1
+cellranger,addr_col,0,0,0,class<`cell_addr`>,1
+cellranger,addr_col,1,0,0,...,1
+cellranger,addr_col.cell_addr,-1,0,0,integer[],1
+cellranger,addr_col.cell_addr,0,0,0,class<`cell_addr`>,1
+cellranger,addr_col.cell_addr,1,0,0,...,1
+cellranger,addr_row,-1,0,0,integer[],1
+cellranger,addr_row,0,0,0,class<`cell_addr`>,1
+cellranger,addr_row,1,0,0,...,1
+cellranger,addr_row.cell_addr,-1,0,0,integer[],1
+cellranger,addr_row.cell_addr,-1,0,1,null,1
+cellranger,addr_row.cell_addr,0,0,0,class<`cell_addr`>,1
+cellranger,addr_row.cell_addr,1,0,0,...,1
+cellranger,add_single_quotes,-1,0,0,character,1
+cellranger,add_single_quotes,-1,0,1,null,1
+cellranger,add_single_quotes,0,0,0,character,1
+cellranger,add_single_quotes,0,0,1,null,1
+cellranger,anchored,-1,0,0,"class<`cell_limits`, `list`>",1
+cellranger,anchored,0,0,0,character,1
+cellranger,anchored,1,0,0,double[],1
+cellranger,anchored,2,0,0,null,1
+cellranger,anchored,2,0,1,character[],1
+cellranger,anchored,2,0,2,class<`data.frame`>,1
+cellranger,anchored,3,0,0,null,1
+cellranger,anchored,3,0,1,logical,1
+cellranger,anchored,4,0,0,logical,1
+cellranger,as.cell_addr,-1,0,0,class<`cell_addr`>,1
+cellranger,as.cell_addr,0,0,0,character[],1
+cellranger,as.cell_addr,0,0,1,"class<`list`, `ra_ref`>",1
+cellranger,as.cell_addr,1,0,0,...,1
+cellranger,as.cell_addr.character,-1,0,0,class<`cell_addr`>,1
+cellranger,as.cell_addr.character,0,0,0,character[],1
+cellranger,as.cell_addr.character,1,0,0,null,1
+cellranger,as.cell_addr.character,2,0,0,logical,1
+cellranger,as.cell_addr.character,3,0,0,...,1
+cellranger,as.cell_addr.ra_ref,-1,0,0,class<`cell_addr`>,1
+cellranger,as.cell_addr.ra_ref,0,0,0,"class<`list`, `ra_ref`>",1
+cellranger,as.cell_addr.ra_ref,1,0,0,...,1
+cellranger,as.cell_addr_v,-1,0,0,class<`cell_addr`>,1
+cellranger,as.cell_addr_v,0,0,0,"list<class<`list`, `ra_ref`>>",1
+cellranger,as.cell_addr_v,1,0,0,...,1
+cellranger,as.cell_addr_v.list,-1,0,0,class<`cell_addr`>,1
+cellranger,as.cell_addr_v.list,0,0,0,"list<class<`list`, `ra_ref`>>",1
+cellranger,as.cell_addr_v.list,1,0,0,...,1
+cellranger,as.cell_limits,-1,0,0,"class<`cell_limits`, `list`>",1
+cellranger,as.cell_limits,0,0,0,character,1
+cellranger,as.cell_limits,1,0,0,...,1
+cellranger,as.cell_limits.character,-1,0,0,"class<`cell_limits`, `list`>",1
+cellranger,as.cell_limits.character,0,0,0,character,1
+cellranger,as.cell_limits.character,1,0,0,null,1
+cellranger,as.cell_limits.character,2,0,0,...,1
+cellranger,as.range,-1,0,0,character,1
+cellranger,as.range,0,0,0,"class<`cell_limits`, `list`>",1
+cellranger,as.range,1,0,0,character[],1
+cellranger,as.range,2,0,0,logical,1
+cellranger,as.range,3,0,0,null,1
+cellranger,as.ra_ref,-1,0,0,"class<`list`, `ra_ref`>",1
+cellranger,as.ra_ref,0,0,0,character,1
+cellranger,as.ra_ref,0,0,1,class<`cell_addr`>,1
+cellranger,as.ra_ref,1,0,0,...,1
+cellranger,as.ra_ref.cell_addr,-1,0,0,"class<`list`, `ra_ref`>",1
+cellranger,as.ra_ref.cell_addr,0,0,0,class<`cell_addr`>,1
+cellranger,as.ra_ref.cell_addr,1,0,0,...,1
+cellranger,as.ra_ref.character,-1,0,0,"class<`list`, `ra_ref`>",1
+cellranger,as.ra_ref.character,0,0,0,character,1
+cellranger,as.ra_ref.character,1,0,0,character,1
+cellranger,as.ra_ref.character,1,0,1,null,1
+cellranger,as.ra_ref.character,2,0,0,logical,1
+cellranger,as.ra_ref.character,3,0,0,...,1
+cellranger,as.ra_ref_v,-1,0,0,"list<class<`list`, `ra_ref`>>",1
+cellranger,as.ra_ref_v,0,0,0,class<`cell_addr`>,1
+cellranger,as.ra_ref_v,0,0,1,character[],1
+cellranger,as.ra_ref_v,1,0,0,...,1
+cellranger,as.ra_ref_v.cell_addr,-1,0,0,"list<class<`list`, `ra_ref`>>",1
+cellranger,as.ra_ref_v.cell_addr,0,0,0,class<`cell_addr`>,1
+cellranger,as.ra_ref_v.cell_addr,1,0,0,...,1
+cellranger,as.ra_ref_v.character,-1,0,0,"list<class<`list`, `ra_ref`>>",1
+cellranger,as.ra_ref_v.character,0,0,0,character[],1
+cellranger,as.ra_ref_v.character,1,0,0,null,1
+cellranger,as.ra_ref_v.character,1,0,1,character,1
+cellranger,as.ra_ref_v.character,2,0,0,any,1
+cellranger,as.ra_ref_v.character,3,0,0,...,1
+cellranger,[.cell_addr,-1,0,0,class<`cell_addr`>,1
+cellranger,[.cell_addr,0,0,0,class<`cell_addr`>,1
+cellranger,[.cell_addr,1,0,0,integer[],1
+cellranger,[[.cell_addr,-1,0,0,class<`cell_addr`>,1
+cellranger,[[.cell_addr,0,0,0,class<`cell_addr`>,1
+cellranger,[[.cell_addr,1,0,0,double,1
+cellranger,cell_addr,-1,0,0,class<`cell_addr`>,1
+cellranger,cell_addr,0,0,0,double,1
+cellranger,cell_addr,0,0,1,^integer[],1
+cellranger,cell_addr,0,0,2,null,1
+cellranger,cell_addr,1,0,0,double,1
+cellranger,cell_addr,1,0,1,integer[],1
+cellranger,cell_cols,-1,0,0,"class<`cell_limits`, `list`>",1
+cellranger,cell_cols,0,0,0,^character[],1
+cellranger,cell_cols,0,0,1,^double[],1
+cellranger,cell_limits,-1,0,0,"class<`cell_limits`, `list`>",1
+cellranger,cell_limits,0,0,0,^double[],1
+cellranger,cell_limits,0,0,1,list<integer>,1
+cellranger,cell_limits,1,0,0,^double[],1
+cellranger,cell_limits,1,0,1,list<integer>,1
+cellranger,cell_limits,2,0,0,null,1
+cellranger,cell_limits,2,0,1,character,1
+cellranger,cell_rows,-1,0,0,"class<`cell_limits`, `list`>",1
+cellranger,cell_rows,0,0,0,^double[],1
+cellranger,dim.cell_limits,-1,0,0,^double[],1
+cellranger,dim.cell_limits,0,0,0,"class<`cell_limits`, `list`>",1
+cellranger,guess_fo,-1,0,0,character[],1
+cellranger,guess_fo,-1,0,1,null,1
+cellranger,guess_fo,0,0,0,character[],1
+cellranger,guess_fo,0,0,1,double,1
+cellranger,guess_fo,1,0,0,character[],1
+cellranger,is_A1,-1,0,0,logical[],1
+cellranger,is_A1,0,0,0,character[],1
+cellranger,is_A1,0,0,1,double,1
+cellranger,isFALSE,-1,0,0,logical,1
+cellranger,isFALSE,0,0,0,logical,1
+cellranger,is_R1C1,-1,0,0,logical[],1
+cellranger,is_R1C1,0,0,0,character[],1
+cellranger,is_R1C1,0,0,1,double,1
+cellranger,isTOGGLE,-1,0,0,logical,1
+cellranger,isTOGGLE,0,0,0,logical,1
+cellranger,isTOGGLE,0,0,1,null,1
+cellranger,isTRUE_v,-1,0,0,logical[],1
+cellranger,isTRUE_v,0,0,0,^logical[],1
+cellranger,isTRUE_v,0,0,1,null,1
+cellranger,length.cell_addr,-1,0,0,integer,1
+cellranger,length.cell_addr,0,0,0,class<`cell_addr`>,1
+cellranger,letter_to_num,-1,0,0,^integer[],1
+cellranger,letter_to_num,-1,0,1,null,1
+cellranger,letter_to_num,0,0,0,^character[],1
+cellranger,letter_to_num,0,0,1,null,1
+cellranger,num_to_letter,-1,0,0,^character[],1
+cellranger,num_to_letter,0,0,0,^double[],1
+cellranger,parse_ref_string,-1,0,0,list<character[]>,1
+cellranger,parse_ref_string,0,0,0,character,1
+cellranger,parse_ref_string,1,0,0,null,1
+cellranger,print.ra_ref,-1,0,0,null,1
+cellranger,print.ra_ref,0,0,0,"class<`list`, `ra_ref`>",1
+cellranger,print.ra_ref,1,0,0,character,1
+cellranger,print.ra_ref,2,0,0,...,1
+cellranger,R1C1_to_A1,-1,0,0,^character[],1
+cellranger,R1C1_to_A1,0,0,0,character[],1
+cellranger,R1C1_to_A1,1,0,0,logical,1
+cellranger,R1C1_to_ra_ref,-1,0,0,"list<class<`list`, `ra_ref`>>",1
+cellranger,R1C1_to_ra_ref,0,0,0,character[],1
+cellranger,ra_ref,-1,0,0,"class<`list`, `ra_ref`>",1
+cellranger,ra_ref,0,0,0,double,1
+cellranger,ra_ref,0,0,1,null,1
+cellranger,ra_ref,0,0,2,character,1
+cellranger,ra_ref,1,0,0,logical,1
+cellranger,ra_ref,1,0,1,null,1
+cellranger,ra_ref,2,0,0,double,1
+cellranger,ra_ref,2,0,1,null,1
+cellranger,ra_ref,2,0,2,character,1
+cellranger,ra_ref,3,0,0,logical,1
+cellranger,ra_ref,3,0,1,null,1
+cellranger,ra_ref,4,0,0,character,1
+cellranger,ra_ref,4,0,1,null,1
+cellranger,ra_ref,5,0,0,null,1
+cellranger,rel_abs_format,-1,0,0,character,1
+cellranger,rel_abs_format,-1,0,1,integer,1
+cellranger,rel_abs_format,0,0,0,logical,1
+cellranger,rel_abs_format,1,0,0,any,1
+cellranger,rel_abs_format,2,0,0,character[],1
+cellranger,relativize,-1,0,0,"class<`list`, `ra_ref`>",1
+cellranger,relativize,0,0,0,"class<`list`, `ra_ref`>",1
+cellranger,to_string,-1,0,0,character[],1
+cellranger,to_string,-1,0,1,null,1
+cellranger,to_string,0,0,0,"class<`list`, `ra_ref`>",1
+cellranger,to_string,0,0,1,class<`cell_addr`>,1
+cellranger,to_string,1,0,0,any,1
+cellranger,to_string,2,0,0,any,1
+cellranger,to_string,3,0,0,null,1
+cellranger,to_string,3,0,1,logical,1
+cellranger,to_string,4,0,0,...,1
+cellranger,to_string.cell_addr,-1,0,0,character[],1
+cellranger,to_string.cell_addr,0,0,0,class<`cell_addr`>,1
+cellranger,to_string.cell_addr,1,0,0,character[],1
+cellranger,to_string.cell_addr,2,0,0,any,1
+cellranger,to_string.cell_addr,3,0,0,logical,1
+cellranger,to_string.cell_addr,4,0,0,...,1
+cellranger,to_string.ra_ref,-1,0,0,character,1
+cellranger,to_string.ra_ref,-1,0,1,null,1
+cellranger,to_string.ra_ref,0,0,0,"class<`list`, `ra_ref`>",1
+cellranger,to_string.ra_ref,1,0,0,any,1
+cellranger,to_string.ra_ref,2,0,0,any,1
+cellranger,to_string.ra_ref,3,0,0,null,1
+cellranger,to_string.ra_ref,3,0,1,logical,1
+cellranger,to_string.ra_ref,4,0,0,...,1
+cellranger,to_string_v,-1,0,0,character[],1
+cellranger,to_string_v,0,0,0,class<`cell_addr`>,1
+cellranger,to_string_v,0,0,1,"list<class<`list`, `ra_ref`>>",1
+cellranger,to_string_v,1,0,0,any,1
+cellranger,to_string_v,2,0,0,logical,1
+cellranger,to_string_v,3,0,0,null,1
+cellranger,to_string_v,4,0,0,...,1
+cellranger,to_string_v.cell_addr,-1,0,0,character[],1
+cellranger,to_string_v.cell_addr,0,0,0,class<`cell_addr`>,1
+cellranger,to_string_v.cell_addr,1,0,0,character[],1
+cellranger,to_string_v.cell_addr,2,0,0,any,1
+cellranger,to_string_v.cell_addr,3,0,0,logical,1
+cellranger,to_string_v.cell_addr,4,0,0,...,1
+cellranger,to_string_v.list,-1,0,0,character[],1
+cellranger,to_string_v.list,0,0,0,"list<class<`list`, `ra_ref`>>",1
+cellranger,to_string_v.list,1,0,0,character[],1
+cellranger,to_string_v.list,2,0,0,logical,1
+cellranger,to_string_v.list,3,0,0,null,1
+cellranger,to_string_v.list,4,0,0,...,1
+checkmate,%??%,-1,0,0,character[],1
+checkmate,%??%,-1,0,1,class<`function`>,1
+checkmate,%??%,-1,0,2,double,1
+checkmate,%??%,0,0,0,character[],1
+checkmate,%??%,0,0,1,class<`function`>,1
+checkmate,%??%,0,0,2,double,1
+checkmate,%??%,0,0,3,null,1
+checkmate,%??%,1,0,0,any,1
+checkmate,allMissing,-1,0,0,logical,1
+checkmate,allMissing,0,0,0,class<`data.frame`>,1
+checkmate,allMissing,0,0,1,class<`factor`>,1
+checkmate,allMissing,0,0,2,^double[],1
+checkmate,%and%,-1,0,0,character,1
+checkmate,%and%,-1,0,1,logical,1
+checkmate,%and%,0,0,0,character,1
+checkmate,%and%,0,0,1,logical,1
+checkmate,%and%,1,0,0,any,1
+checkmate,anyInfinite,-1,0,0,logical,1
+checkmate,anyInfinite,0,0,0,class<`data.frame`>,1
+checkmate,anyInfinite,0,0,1,double[],1
+checkmate,anyMissing,-1,0,0,logical,1
+checkmate,anyMissing,0,0,0,class<`data.frame`>,1
+checkmate,anyMissing,0,0,1,^double[],1
+checkmate,anyMissing,0,0,2,list<double | null>,1
+checkmate,anyMissing,0,0,3,null,1
+checkmate,anyNaN,-1,0,0,logical,1
+checkmate,anyNaN,0,0,0,class<`data.frame`>,1
+checkmate,anyNaN,0,0,1,double[],1
+checkmate,asCount,-1,0,0,integer,1
+checkmate,asCount,0,0,0,double,1
+checkmate,asCount,1,0,0,logical,1
+checkmate,asCount,2,0,0,logical,1
+checkmate,asCount,3,0,0,double,1
+checkmate,asCount,4,0,0,any,1
+checkmate,asInt,-1,0,0,integer,1
+checkmate,asInt,0,0,0,double,1
+checkmate,asInt,1,0,0,logical,1
+checkmate,asInt,2,0,0,double,1
+checkmate,asInt,3,0,0,double,1
+checkmate,asInt,4,0,0,double,1
+checkmate,asInt,5,0,0,any,1
+checkmate,asInteger,-1,0,0,integer[],1
+checkmate,asInteger,0,0,0,double[],1
+checkmate,asInteger,1,0,0,double,1
+checkmate,asInteger,2,0,0,double,1
+checkmate,asInteger,3,0,0,double,1
+checkmate,asInteger,4,0,0,logical,1
+checkmate,asInteger,5,0,0,logical,1
+checkmate,asInteger,6,0,0,null,1
+checkmate,asInteger,7,0,0,null,1
+checkmate,assert,-1,0,0,logical,1
+checkmate,assert,0,0,0,...,1
+checkmate,assert,1,0,0,character,1
+checkmate,assert,2,0,0,null,1
+checkmate,assertCharacter,-1,0,0,character[],1
+checkmate,assertCharacter,0,0,0,character[],1
+checkmate,assertCharacter,1,0,0,double,1
+checkmate,assertCharacter,1,0,1,null,1
+checkmate,assertCharacter,2,0,0,null,1
+checkmate,assertCharacter,3,0,0,null,1
+checkmate,assertCharacter,4,0,0,logical,1
+checkmate,assertCharacter,5,0,0,logical,1
+checkmate,assertCharacter,6,0,0,logical,1
+checkmate,assertCharacter,7,0,0,null,1
+checkmate,assertCharacter,7,0,1,integer,1
+checkmate,assertChoice,-1,0,0,character,1
+checkmate,assertChoice,0,0,0,character,1
+checkmate,assertChoice,1,0,0,character[],1
+checkmate,assertChoice,2,0,0,logical,1
+checkmate,assertChoice,3,0,0,logical,1
+checkmate,assertChoice,4,0,0,any,1
+checkmate,assertChoice,5,0,0,any,1
+checkmate,assertClass,-1,0,0,class<`AssertCollection`>,1
+checkmate,assertClass,0,0,0,class<`AssertCollection`>,1
+checkmate,assertClass,1,0,0,character,1
+checkmate,assertClass,2,0,0,logical,1
+checkmate,assertClass,3,0,0,logical,1
+checkmate,assertClass,4,0,0,character,1
+checkmate,assertClass,5,0,0,null,1
+checkmate,assertCount,-1,0,0,double,1
+checkmate,assertCount,0,0,0,double,1
+checkmate,assertCount,1,0,0,logical,1
+checkmate,assertCount,2,0,0,logical,1
+checkmate,assertCount,3,0,0,double,1
+checkmate,assertCount,4,0,0,logical,1
+checkmate,assertCount,5,0,0,logical,1
+checkmate,assertCount,6,0,0,any,1
+checkmate,assertCount,7,0,0,null,1
+checkmate,assertFlag,-1,0,0,logical,1
+checkmate,assertFlag,0,0,0,logical,1
+checkmate,assertFlag,1,0,0,logical,1
+checkmate,assertFlag,2,0,0,logical,1
+checkmate,assertFlag,3,0,0,any,1
+checkmate,assertFlag,4,0,0,null,1
+checkmate,assertInt,-1,0,0,double,1
+checkmate,assertInt,0,0,0,double,1
+checkmate,assertInt,1,0,0,logical,1
+checkmate,assertInt,2,0,0,double,1
+checkmate,assertInt,3,0,0,double,1
+checkmate,assertInt,4,0,0,double,1
+checkmate,assertInt,5,0,0,logical,1
+checkmate,assertInt,6,0,0,logical,1
+checkmate,assertInt,7,0,0,any,1
+checkmate,assertInteger,-1,0,0,integer[],1
+checkmate,assertInteger,0,0,0,integer[],1
+checkmate,assertInteger,1,0,0,double,1
+checkmate,assertInteger,2,0,0,double,1
+checkmate,assertInteger,3,0,0,logical,1
+checkmate,assertInteger,4,0,0,logical,1
+checkmate,assertInteger,5,0,0,null,1
+checkmate,assertInteger,6,0,0,null,1
+checkmate,assertInteger,7,0,0,null,1
+checkmate,assertIntegerish,-1,0,0,double[],1
+checkmate,assertIntegerish,0,0,0,double[],1
+checkmate,assertIntegerish,1,0,0,double,1
+checkmate,assertIntegerish,2,0,0,double,1
+checkmate,assertIntegerish,3,0,0,double,1
+checkmate,assertIntegerish,4,0,0,logical,1
+checkmate,assertIntegerish,5,0,0,logical,1
+checkmate,assertIntegerish,6,0,0,null,1
+checkmate,assertIntegerish,7,0,0,null,1
+checkmate,assertNames,-1,0,0,character[],1
+checkmate,assertNames,0,0,0,character[],1
+checkmate,assertNames,1,0,0,character,1
+checkmate,assertNames,2,0,0,null,1
+checkmate,assertNames,3,0,0,null,1
+checkmate,assertNames,4,0,0,character[],1
+checkmate,assertNames,5,0,0,null,1
+checkmate,assertNames,6,0,0,null,1
+checkmate,assertNames,7,0,0,character,1
+checkmate,assertNumeric,-1,0,0,character,1
+checkmate,assertNumeric,-1,0,1,double[],1
+checkmate,assertNumeric,0,0,0,character,1
+checkmate,assertNumeric,0,0,1,double[],1
+checkmate,assertNumeric,1,0,0,double,1
+checkmate,assertNumeric,2,0,0,double,1
+checkmate,assertNumeric,3,0,0,logical,1
+checkmate,assertNumeric,4,0,0,logical,1
+checkmate,assertNumeric,5,0,0,logical,1
+checkmate,assertNumeric,6,0,0,null,1
+checkmate,assertNumeric,6,0,1,double,1
+checkmate,assertNumeric,7,0,0,null,1
+checkmate,checkAccess,-1,0,0,logical,1
+checkmate,checkAccess,0,0,0,character,1
+checkmate,checkAccess,1,0,0,character,1
+checkmate,checkArray,-1,0,0,logical,1
+checkmate,checkArray,0,0,0,class<`array`>,1
+checkmate,checkArray,1,0,0,null,1
+checkmate,checkArray,2,0,0,logical,1
+checkmate,checkArray,3,0,0,double,1
+checkmate,checkArray,4,0,0,null,1
+checkmate,checkArray,5,0,0,null,1
+checkmate,checkArray,6,0,0,logical,1
+checkmate,checkCharacter,-1,0,0,character,1
+checkmate,checkCharacter,-1,0,1,logical,1
+checkmate,checkCharacter,0,0,0,character[],1
+checkmate,checkCharacter,1,0,0,double,1
+checkmate,checkCharacter,1,0,1,null,1
+checkmate,checkCharacter,2,0,0,any,1
+checkmate,checkCharacter,3,0,0,any,1
+checkmate,checkCharacter,4,0,0,any,1
+checkmate,checkCharacter,5,0,0,logical,1
+checkmate,checkCharacter,6,0,0,logical,1
+checkmate,checkCharacter,7,0,0,null,1
+checkmate,checkCharacter,7,0,1,integer,1
+checkmate,checkCharacterPattern,-1,0,0,logical,1
+checkmate,checkCharacterPattern,0,0,0,character[],1
+checkmate,checkCharacterPattern,1,0,0,null,1
+checkmate,checkCharacterPattern,1,0,1,character,1
+checkmate,checkCharacterPattern,2,0,0,null,1
+checkmate,checkCharacterPattern,3,0,0,any,1
+checkmate,checkChoice,-1,0,0,character,1
+checkmate,checkChoice,-1,0,1,logical,1
+checkmate,checkChoice,0,0,0,class<`factor`>,1
+checkmate,checkChoice,0,0,1,double,1
+checkmate,checkChoice,0,0,2,character,1
+checkmate,checkChoice,1,0,0,character[],1
+checkmate,checkChoice,1,0,1,integer,1
+checkmate,checkChoice,2,0,0,logical,1
+checkmate,checkChoice,3,0,0,any,1
+checkmate,checkClass,-1,0,0,character,1
+checkmate,checkClass,-1,0,1,logical,1
+checkmate,checkClass,0,0,0,"class<`bar`, `foo`>",1
+checkmate,checkClass,0,0,1,class<`AssertCollection`>,1
+checkmate,checkClass,0,0,2,"class<`Bar`, `R6`>",1
+checkmate,checkClass,1,0,0,character[],1
+checkmate,checkClass,2,0,0,logical,1
+checkmate,checkClass,3,0,0,logical,1
+checkmate,checkDataFrame,-1,0,0,character,1
+checkmate,checkDataFrame,-1,0,1,logical,1
+checkmate,checkDataFrame,0,0,0,class<`data.frame`>,1
+checkmate,checkDataFrame,0,0,1,"class<`data.frame`, `data.table`>",1
+checkmate,checkDataFrame,0,0,2,"class<`data.frame`, `tbl`, `tbl_df`>",1
+checkmate,checkDataFrame,1,0,0,any,1
+checkmate,checkDataFrame,2,0,0,logical,1
+checkmate,checkDataFrame,3,0,0,logical,1
+checkmate,checkDataFrame,4,0,0,null,1
+checkmate,checkDataFrame,4,0,1,double,1
+checkmate,checkDataFrame,5,0,0,null,1
+checkmate,checkDataFrame,6,0,0,null,1
+checkmate,checkDataFrame,7,0,0,null,1
+checkmate,checkDataTable,-1,0,0,logical,1
+checkmate,checkDataTable,0,0,0,"class<`data.frame`, `data.table`>",1
+checkmate,checkDataTable,1,0,0,character,1
+checkmate,checkDataTable,1,0,1,null,1
+checkmate,checkDataTable,2,0,0,character,1
+checkmate,checkDataTable,2,0,1,null,1
+checkmate,checkDataTable,3,0,0,character[],1
+checkmate,checkDataTable,4,0,0,logical,1
+checkmate,checkDataTable,5,0,0,logical,1
+checkmate,checkDataTable,6,0,0,null,1
+checkmate,checkDataTable,7,0,0,null,1
+checkmate,checkDataTableProps,-1,0,0,logical,1
+checkmate,checkDataTableProps,0,0,0,any,1
+checkmate,checkDataTableProps,1,0,0,null,1
+checkmate,checkDataTableProps,1,0,1,character,1
+checkmate,checkDataTableProps,2,0,0,null,1
+checkmate,checkDataTableProps,2,0,1,character,1
+checkmate,checkDirectoryExists,-1,0,0,logical,1
+checkmate,checkDirectoryExists,0,0,0,character,1
+checkmate,checkDirectoryExists,1,0,0,character,1
+checkmate,checkDisjunct,-1,0,0,character,1
+checkmate,checkDisjunct,-1,0,1,logical,1
+checkmate,checkDisjunct,0,0,0,character[],1
+checkmate,checkDisjunct,0,0,1,class<`factor`>,1
+checkmate,checkDisjunct,0,0,2,double,1
+checkmate,checkDisjunct,1,0,0,character[],1
+checkmate,checkDisjunct,1,0,1,integer,1
+checkmate,checkDisjunct,2,0,0,logical,1
+checkmate,checkEnvironment,-1,0,0,logical,1
+checkmate,checkEnvironment,0,0,0,environment,1
+checkmate,checkEnvironment,1,0,0,character[],1
+checkmate,checkEnvironment,2,0,0,logical,1
+checkmate,checkFactor,-1,0,0,character,1
+checkmate,checkFactor,-1,0,1,logical,1
+checkmate,checkFactor,0,0,0,class<`factor`>,1
+checkmate,checkFactor,1,0,0,null,1
+checkmate,checkFactor,2,0,0,null,1
+checkmate,checkFactor,3,0,0,logical,1
+checkmate,checkFactor,4,0,0,logical,1
+checkmate,checkFactor,5,0,0,logical,1
+checkmate,checkFactor,6,0,0,null,1
+checkmate,checkFactor,7,0,0,null,1
+checkmate,checkFactorLevels,-1,0,0,character,1
+checkmate,checkFactorLevels,-1,0,1,logical,1
+checkmate,checkFactorLevels,0,0,0,class<`factor`>,1
+checkmate,checkFactorLevels,1,0,0,null,1
+checkmate,checkFactorLevels,2,0,0,null,1
+checkmate,checkFactorLevels,3,0,0,logical,1
+checkmate,checkFactorLevels,4,0,0,any,1
+checkmate,checkFactorLevels,5,0,0,any,1
+checkmate,checkFactorLevels,6,0,0,any,1
+checkmate,checkFALSE,-1,0,0,character,1
+checkmate,checkFALSE,-1,0,1,logical,1
+checkmate,checkFALSE,0,0,0,logical,1
+checkmate,checkFALSE,1,0,0,logical,1
+checkmate,checkFileExists,-1,0,0,logical,1
+checkmate,checkFileExists,0,0,0,character,1
+checkmate,checkFileExists,1,0,0,character,1
+checkmate,checkFileExists,2,0,0,null,1
+checkmate,checkFileExtension,-1,0,0,logical,1
+checkmate,checkFileExtension,0,0,0,any,1
+checkmate,checkFileExtension,1,0,0,null,1
+checkmate,checkFormula,-1,0,0,logical,1
+checkmate,checkFormula,0,0,0,class<`formula`>,1
+checkmate,checkFormula,1,0,0,logical,1
+checkmate,checkFunction,-1,0,0,logical,1
+checkmate,checkFunction,0,0,0,class<`function`>,1
+checkmate,checkFunction,1,0,0,character,1
+checkmate,checkFunction,1,0,1,null,1
+checkmate,checkFunction,2,0,0,any,1
+checkmate,checkFunction,3,0,0,null,1
+checkmate,checkFunction,4,0,0,logical,1
+checkmate,checkInteger,-1,0,0,logical,1
+checkmate,checkInteger,0,0,0,integer[],1
+checkmate,checkInteger,1,0,0,double,1
+checkmate,checkInteger,2,0,0,double,1
+checkmate,checkInteger,3,0,0,logical,1
+checkmate,checkInteger,4,0,0,logical,1
+checkmate,checkInteger,5,0,0,null,1
+checkmate,checkInteger,6,0,0,null,1
+checkmate,checkInteger,7,0,0,null,1
+checkmate,checkList,-1,0,0,character,1
+checkmate,checkList,-1,0,1,logical,1
+checkmate,checkList,0,0,0,list<any>,1
+checkmate,checkList,1,0,0,any,1
+checkmate,checkList,2,0,0,logical,1
+checkmate,checkList,3,0,0,logical,1
+checkmate,checkList,4,0,0,null,1
+checkmate,checkList,5,0,0,null,1
+checkmate,checkList,6,0,0,null,1
+checkmate,checkList,7,0,0,logical,1
+checkmate,checkListTypes,-1,0,0,logical,1
+checkmate,checkListTypes,0,0,0,class<`data.frame`>,1
+checkmate,checkListTypes,0,0,1,"class<`data.frame`, `data.table`>",1
+checkmate,checkListTypes,0,0,2,"class<`data.frame`, `tbl`, `tbl_df`>",1
+checkmate,checkListTypes,0,0,3,list<any>,1
+checkmate,checkListTypes,1,0,0,any,1
+checkmate,checkMatrix,-1,0,0,character,1
+checkmate,checkMatrix,-1,0,1,logical,1
+checkmate,checkMatrix,0,0,0,class<`matrix`>,1
+checkmate,checkMatrix,1,0,0,character,1
+checkmate,checkMatrix,1,0,1,null,1
+checkmate,checkMatrix,2,0,0,logical,1
+checkmate,checkMatrix,3,0,0,logical,1
+checkmate,checkMatrix,4,0,0,null,1
+checkmate,checkMatrix,5,0,0,null,1
+checkmate,checkMatrix,6,0,0,null,1
+checkmate,checkMatrix,7,0,0,null,1
+checkmate,checkMultiClass,-1,0,0,character,1
+checkmate,checkMultiClass,-1,0,1,logical,1
+checkmate,checkMultiClass,0,0,0,class<`bar`>,1
+checkmate,checkMultiClass,1,0,0,character[],1
+checkmate,checkMultiClass,2,0,0,logical,1
+checkmate,checkNames,-1,0,0,character,1
+checkmate,checkNames,-1,0,1,logical,1
+checkmate,checkNames,0,0,0,integer[],1
+checkmate,checkNames,0,0,1,character[],1
+checkmate,checkNames,1,0,0,character,1
+checkmate,checkNames,2,0,0,any,1
+checkmate,checkNames,3,0,0,any,1
+checkmate,checkNames,4,0,0,any,1
+checkmate,checkNames,5,0,0,any,1
+checkmate,checkNames,6,0,0,any,1
+checkmate,checkNames,7,0,0,character,1
+checkmate,checkNamesCmp,-1,0,0,logical,1
+checkmate,checkNamesCmp,0,0,0,character[],1
+checkmate,checkNamesCmp,1,0,0,null,1
+checkmate,checkNamesCmp,2,0,0,null,1
+checkmate,checkNamesCmp,3,0,0,character[],1
+checkmate,checkNamesCmp,4,0,0,null,1
+checkmate,checkNamesCmp,5,0,0,null,1
+checkmate,checkNull,-1,0,0,character,1
+checkmate,checkNull,-1,0,1,logical,1
+checkmate,checkNull,0,0,0,double,1
+checkmate,checkNull,0,0,1,integer[],1
+checkmate,checkNull,0,0,2,null,1
+checkmate,checkOS,-1,0,0,logical,1
+checkmate,checkOS,0,0,0,character,1
+checkmate,checkPathForOutput,-1,0,0,logical,1
+checkmate,checkPathForOutput,0,0,0,character,1
+checkmate,checkPathForOutput,1,0,0,logical,1
+checkmate,checkPathForOutput,2,0,0,null,1
+checkmate,checkR6,-1,0,0,logical,1
+checkmate,checkR6,0,0,0,"class<`Bar`, `R6`>",1
+checkmate,checkR6,1,0,0,character,1
+checkmate,checkR6,2,0,0,logical,1
+checkmate,checkR6,3,0,0,logical,1
+checkmate,checkR6,4,0,0,character,1
+checkmate,checkR6,5,0,0,null,1
+checkmate,checkR6,6,0,0,logical,1
+checkmate,checkR6Props,-1,0,0,logical,1
+checkmate,checkR6Props,0,0,0,"class<`Bar`, `R6`>",1
+checkmate,checkR6Props,1,0,0,logical,1
+checkmate,checkR6Props,2,0,0,character,1
+checkmate,checkR6Props,3,0,0,null,1
+checkmate,checkScalarNA,-1,0,0,character,1
+checkmate,checkScalarNA,-1,0,1,logical,1
+checkmate,checkScalarNA,0,0,0,double,1
+checkmate,checkScalarNA,0,0,1,^logical[],1
+checkmate,checkScalarNA,0,0,2,null,1
+checkmate,checkScalarNA,1,0,0,logical,1
+checkmate,checkSetEqual,-1,0,0,character,1
+checkmate,checkSetEqual,-1,0,1,logical,1
+checkmate,checkSetEqual,0,0,0,class<`factor`>,1
+checkmate,checkSetEqual,0,0,1,double,1
+checkmate,checkSetEqual,0,0,2,integer[],1
+checkmate,checkSetEqual,0,0,3,character[],1
+checkmate,checkSetEqual,1,0,0,integer[],1
+checkmate,checkSetEqual,1,0,1,character[],1
+checkmate,checkSetEqual,2,0,0,logical,1
+checkmate,checkSetEqual,3,0,0,logical,1
+checkmate,checkString,-1,0,0,character,1
+checkmate,checkString,-1,0,1,logical,1
+checkmate,checkString,0,0,0,character[],1
+checkmate,checkString,1,0,0,logical,1
+checkmate,checkString,2,0,0,null,1
+checkmate,checkString,3,0,0,any,1
+checkmate,checkString,4,0,0,any,1
+checkmate,checkString,5,0,0,any,1
+checkmate,checkString,6,0,0,logical,1
+checkmate,checkSubset,-1,0,0,character,1
+checkmate,checkSubset,-1,0,1,logical,1
+checkmate,checkSubset,0,0,0,class<`factor`>,1
+checkmate,checkSubset,0,0,1,double,1
+checkmate,checkSubset,0,0,2,character[],1
+checkmate,checkSubset,1,0,0,character[],1
+checkmate,checkSubset,1,0,1,integer,1
+checkmate,checkSubset,2,0,0,logical,1
+checkmate,checkSubset,3,0,0,logical,1
+checkmate,checkTibble,-1,0,0,logical,1
+checkmate,checkTibble,0,0,0,"class<`data.frame`, `tbl`, `tbl_df`>",1
+checkmate,checkTibble,1,0,0,character[],1
+checkmate,checkTibble,2,0,0,logical,1
+checkmate,checkTibble,3,0,0,logical,1
+checkmate,checkTibble,4,0,0,null,1
+checkmate,checkTibble,5,0,0,null,1
+checkmate,checkTibble,6,0,0,null,1
+checkmate,checkTibble,7,0,0,null,1
+checkmate,checkTRUE,-1,0,0,character,1
+checkmate,checkTRUE,-1,0,1,logical,1
+checkmate,checkTRUE,0,0,0,logical,1
+checkmate,checkTRUE,1,0,0,logical,1
+checkmate,isSameType,-1,0,0,logical,1
+checkmate,isSameType,0,0,0,character[],1
+checkmate,isSameType,0,0,1,class<`factor`>,1
+checkmate,isSameType,0,0,2,double,1
+checkmate,isSameType,0,0,3,integer[],1
+checkmate,isSameType,1,0,0,character[],1
+checkmate,isSameType,1,0,1,integer[],1
+checkmate,makeAssertCollection,-1,0,0,class<`AssertCollection`>,1
+checkmate,makeAssertion,-1,0,0,character[],1
+checkmate,makeAssertion,-1,0,1,class<`AssertCollection`>,1
+checkmate,makeAssertion,-1,0,2,double[],1
+checkmate,makeAssertion,0,0,0,character[],1
+checkmate,makeAssertion,0,0,1,class<`AssertCollection`>,1
+checkmate,makeAssertion,0,0,2,double[],1
+checkmate,makeAssertion,1,0,0,logical,1
+checkmate,makeAssertion,1,0,1,character,1
+checkmate,makeAssertion,2,0,0,any,1
+checkmate,makeAssertion,3,0,0,any,1
+checkmate,makeAssertionFunction,-1,0,0,class<`function`>,1
+checkmate,makeAssertionFunction,0,0,0,class<`function`>,1
+checkmate,makeAssertionFunction,1,0,0,null,1
+checkmate,makeAssertionFunction,2,0,0,logical,1
+checkmate,makeAssertionFunction,3,0,0,logical,1
+checkmate,makeAssertionFunction,4,0,0,environment,1
+checkmate,makeExpectationFunction,-1,0,0,class<`function`>,1
+checkmate,makeExpectationFunction,0,0,0,class<`function`>,1
+checkmate,makeExpectationFunction,1,0,0,null,1
+checkmate,makeExpectationFunction,2,0,0,logical,1
+checkmate,makeExpectationFunction,3,0,0,environment,1
+checkmate,makeTestFunction,-1,0,0,class<`function`>,1
+checkmate,makeTestFunction,0,0,0,class<`function`>,1
+checkmate,makeTestFunction,1,0,0,null,1
+checkmate,makeTestFunction,2,0,0,environment,1
+checkmate,matchArg,-1,0,0,character,1
+checkmate,matchArg,0,0,0,character,1
+checkmate,matchArg,1,0,0,character[],1
+checkmate,matchArg,2,0,0,logical,1
+checkmate,matchArg,3,0,0,any,1
+checkmate,matchArg,4,0,0,null,1
+checkmate,%nin%,-1,0,0,logical,1
+checkmate,%nin%,0,0,0,character,1
+checkmate,%nin%,1,0,0,character[],1
+checkmate,qassert,-1,0,0,character[],1
+checkmate,qassert,-1,0,1,class<`factor`>,1
+checkmate,qassert,-1,0,2,double[],1
+checkmate,qassert,-1,0,3,null,1
+checkmate,qassert,0,0,0,character[],1
+checkmate,qassert,0,0,1,class<`factor`>,1
+checkmate,qassert,0,0,2,double[],1
+checkmate,qassert,0,0,3,null,1
+checkmate,qassert,1,0,0,character,1
+checkmate,qassert,2,0,0,any,1
+checkmate,qtest,-1,0,0,logical,1
+checkmate,qtest,0,0,0,character,1
+checkmate,qtest,0,0,1,class<`data.frame`>,1
+checkmate,qtest,0,0,2,class<`factor`>,1
+checkmate,qtest,0,0,3,double[],1
+checkmate,qtest,0,0,4,null,1
+checkmate,qtest,1,0,0,character[],1
+checkmate,qtestr,-1,0,0,logical,1
+checkmate,qtestr,0,0,0,class<`data.frame`>,1
+checkmate,qtestr,0,0,1,list<integer>,1
+checkmate,qtestr,0,0,2,list<integer[] | double | character[]>,1
+checkmate,qtestr,1,0,0,character[],1
+checkmate,qtestr,2,0,0,integer,1
+checkmate,register_tinytest,-1,0,0,list<null>,1
+checkmate,set_collapse,-1,0,0,character,1
+checkmate,set_collapse,0,0,0,character[],1
+checkmate,set_collapse,0,0,1,class<`factor`>,1
+checkmate,set_collapse,0,0,2,double,1
+checkmate,set_collapse,0,0,3,integer[],1
+checkmate,testAccess,-1,0,0,logical,1
+checkmate,testAccess,0,0,0,character,1
+checkmate,testAccess,1,0,0,character,1
+checkmate,testAtomic,-1,0,0,logical,1
+checkmate,testAtomic,0,0,0,character[],1
+checkmate,testAtomic,1,0,0,logical,1
+checkmate,testAtomic,2,0,0,logical,1
+checkmate,testAtomic,3,0,0,null,1
+checkmate,testAtomic,4,0,0,integer,1
+checkmate,testAtomic,5,0,0,null,1
+checkmate,testAtomic,6,0,0,logical,1
+checkmate,testAtomic,7,0,0,null,1
+checkmate,testAtomicVector,-1,0,0,logical,1
+checkmate,testAtomicVector,0,0,0,character[],1
+checkmate,testAtomicVector,1,0,0,logical,1
+checkmate,testAtomicVector,2,0,0,logical,1
+checkmate,testAtomicVector,3,0,0,null,1
+checkmate,testAtomicVector,4,0,0,integer,1
+checkmate,testAtomicVector,5,0,0,null,1
+checkmate,testAtomicVector,6,0,0,logical,1
+checkmate,testAtomicVector,7,0,0,null,1
+checkmate,testCharacter,-1,0,0,logical,1
+checkmate,testCharacter,0,0,0,character[],1
+checkmate,testCharacter,1,0,0,double,1
+checkmate,testCharacter,1,0,1,null,1
+checkmate,testCharacter,2,0,0,null,1
+checkmate,testCharacter,2,0,1,character,1
+checkmate,testCharacter,3,0,0,null,1
+checkmate,testCharacter,4,0,0,logical,1
+checkmate,testCharacter,5,0,0,logical,1
+checkmate,testCharacter,6,0,0,logical,1
+checkmate,testCharacter,7,0,0,null,1
+checkmate,testChoice,-1,0,0,logical,1
+checkmate,testChoice,0,0,0,character,1
+checkmate,testChoice,0,0,1,class<`factor`>,1
+checkmate,testChoice,0,0,2,double,1
+checkmate,testChoice,1,0,0,character[],1
+checkmate,testChoice,1,0,1,integer,1
+checkmate,testChoice,2,0,0,logical,1
+checkmate,testChoice,3,0,0,logical,1
+checkmate,testClass,-1,0,0,logical,1
+checkmate,testClass,0,0,0,"class<`bar`, `foo`>",1
+checkmate,testClass,1,0,0,character[],1
+checkmate,testClass,2,0,0,logical,1
+checkmate,testClass,3,0,0,logical,1
+checkmate,testComplex,-1,0,0,logical,1
+checkmate,testComplex,0,0,0,complex,1
+checkmate,testComplex,1,0,0,logical,1
+checkmate,testComplex,2,0,0,logical,1
+checkmate,testComplex,3,0,0,null,1
+checkmate,testComplex,4,0,0,null,1
+checkmate,testComplex,5,0,0,null,1
+checkmate,testComplex,6,0,0,logical,1
+checkmate,testComplex,7,0,0,null,1
+checkmate,testCount,-1,0,0,logical,1
+checkmate,testCount,0,0,0,double,1
+checkmate,testCount,1,0,0,logical,1
+checkmate,testCount,2,0,0,logical,1
+checkmate,testCount,3,0,0,double,1
+checkmate,testCount,4,0,0,logical,1
+checkmate,testDataFrame,-1,0,0,logical,1
+checkmate,testDataFrame,0,0,0,class<`data.frame`>,1
+checkmate,testDataFrame,1,0,0,any,1
+checkmate,testDataFrame,2,0,0,logical,1
+checkmate,testDataFrame,3,0,0,logical,1
+checkmate,testDataFrame,4,0,0,double,1
+checkmate,testDataFrame,4,0,1,null,1
+checkmate,testDataFrame,5,0,0,null,1
+checkmate,testDataFrame,6,0,0,null,1
+checkmate,testDataFrame,7,0,0,null,1
+checkmate,testDataTable,-1,0,0,logical,1
+checkmate,testDataTable,0,0,0,"class<`data.frame`, `data.table`>",1
+checkmate,testDataTable,1,0,0,character,1
+checkmate,testDataTable,1,0,1,null,1
+checkmate,testDataTable,2,0,0,character,1
+checkmate,testDataTable,2,0,1,null,1
+checkmate,testDataTable,3,0,0,character[],1
+checkmate,testDataTable,4,0,0,logical,1
+checkmate,testDataTable,5,0,0,logical,1
+checkmate,testDataTable,6,0,0,null,1
+checkmate,testDataTable,7,0,0,null,1
+checkmate,testDirectory,-1,0,0,logical,1
+checkmate,testDirectory,0,0,0,character,1
+checkmate,testDirectory,1,0,0,character,1
+checkmate,testDisjunct,-1,0,0,logical,1
+checkmate,testDisjunct,0,0,0,character[],1
+checkmate,testDisjunct,0,0,1,class<`factor`>,1
+checkmate,testDisjunct,0,0,2,double,1
+checkmate,testDisjunct,1,0,0,character[],1
+checkmate,testDisjunct,1,0,1,integer,1
+checkmate,testDisjunct,2,0,0,logical,1
+checkmate,testDouble,-1,0,0,logical,1
+checkmate,testDouble,0,0,0,double,1
+checkmate,testDouble,1,0,0,double,1
+checkmate,testDouble,2,0,0,double,1
+checkmate,testDouble,3,0,0,logical,1
+checkmate,testDouble,4,0,0,logical,1
+checkmate,testDouble,5,0,0,logical,1
+checkmate,testDouble,6,0,0,null,1
+checkmate,testDouble,7,0,0,double,1
+checkmate,testDouble,7,0,1,null,1
+checkmate,testEnvironment,-1,0,0,logical,1
+checkmate,testEnvironment,0,0,0,environment,1
+checkmate,testEnvironment,1,0,0,character[],1
+checkmate,testEnvironment,2,0,0,logical,1
+checkmate,testFactor,-1,0,0,logical,1
+checkmate,testFactor,0,0,0,class<`factor`>,1
+checkmate,testFactor,1,0,0,null,1
+checkmate,testFactor,2,0,0,null,1
+checkmate,testFactor,3,0,0,logical,1
+checkmate,testFactor,4,0,0,logical,1
+checkmate,testFactor,5,0,0,logical,1
+checkmate,testFactor,6,0,0,null,1
+checkmate,testFactor,7,0,0,null,1
+checkmate,testFALSE,-1,0,0,logical,1
+checkmate,testFALSE,0,0,0,logical,1
+checkmate,testFALSE,1,0,0,logical,1
+checkmate,testFileExists,-1,0,0,logical,1
+checkmate,testFileExists,0,0,0,character,1
+checkmate,testFileExists,1,0,0,character,1
+checkmate,testFileExists,2,0,0,null,1
+checkmate,testFlag,-1,0,0,logical,1
+checkmate,testFlag,0,0,0,double,1
+checkmate,testFlag,1,0,0,logical,1
+checkmate,testFlag,2,0,0,logical,1
+checkmate,testFunction,-1,0,0,logical,1
+checkmate,testFunction,0,0,0,class<`function`>,1
+checkmate,testFunction,1,0,0,character,1
+checkmate,testFunction,1,0,1,null,1
+checkmate,testFunction,2,0,0,logical,1
+checkmate,testFunction,3,0,0,null,1
+checkmate,testFunction,4,0,0,logical,1
+checkmate,testInt,-1,0,0,logical,1
+checkmate,testInt,0,0,0,double,1
+checkmate,testInt,1,0,0,logical,1
+checkmate,testInt,2,0,0,double,1
+checkmate,testInt,3,0,0,double,1
+checkmate,testInt,4,0,0,double,1
+checkmate,testInt,5,0,0,logical,1
+checkmate,testInteger,-1,0,0,logical,1
+checkmate,testInteger,0,0,0,double,1
+checkmate,testInteger,0,0,1,integer[],1
+checkmate,testInteger,1,0,0,double,1
+checkmate,testInteger,2,0,0,double,1
+checkmate,testInteger,3,0,0,logical,1
+checkmate,testInteger,4,0,0,logical,1
+checkmate,testInteger,5,0,0,null,1
+checkmate,testInteger,6,0,0,null,1
+checkmate,testInteger,7,0,0,null,1
+checkmate,testIntegerish,-1,0,0,logical,1
+checkmate,testIntegerish,0,0,0,double,1
+checkmate,testIntegerish,0,0,1,integer[],1
+checkmate,testIntegerish,1,0,0,double,1
+checkmate,testIntegerish,2,0,0,double,1
+checkmate,testIntegerish,3,0,0,double,1
+checkmate,testIntegerish,4,0,0,logical,1
+checkmate,testIntegerish,5,0,0,logical,1
+checkmate,testIntegerish,6,0,0,null,1
+checkmate,testIntegerish,7,0,0,null,1
+checkmate,testList,-1,0,0,logical,1
+checkmate,testList,0,0,0,list<any>,1
+checkmate,testList,1,0,0,any,1
+checkmate,testList,2,0,0,logical,1
+checkmate,testList,3,0,0,logical,1
+checkmate,testList,4,0,0,null,1
+checkmate,testList,5,0,0,null,1
+checkmate,testList,6,0,0,null,1
+checkmate,testList,7,0,0,logical,1
+checkmate,testLogical,-1,0,0,logical,1
+checkmate,testLogical,0,0,0,logical,1
+checkmate,testLogical,1,0,0,logical,1
+checkmate,testLogical,2,0,0,logical,1
+checkmate,testLogical,3,0,0,null,1
+checkmate,testLogical,4,0,0,double,1
+checkmate,testLogical,4,0,1,null,1
+checkmate,testLogical,5,0,0,null,1
+checkmate,testLogical,6,0,0,logical,1
+checkmate,testLogical,7,0,0,null,1
+checkmate,testMatrix,-1,0,0,logical,1
+checkmate,testMatrix,0,0,0,class<`matrix`>,1
+checkmate,testMatrix,1,0,0,null,1
+checkmate,testMatrix,2,0,0,logical,1
+checkmate,testMatrix,3,0,0,logical,1
+checkmate,testMatrix,4,0,0,null,1
+checkmate,testMatrix,5,0,0,null,1
+checkmate,testMatrix,6,0,0,double,1
+checkmate,testMatrix,7,0,0,null,1
+checkmate,testNamed,-1,0,0,logical,1
+checkmate,testNamed,0,0,0,integer[],1
+checkmate,testNamed,1,0,0,character,1
+checkmate,testNames,-1,0,0,logical,1
+checkmate,testNames,0,0,0,integer[],1
+checkmate,testNames,1,0,0,character,1
+checkmate,testNames,2,0,0,null,1
+checkmate,testNames,3,0,0,null,1
+checkmate,testNames,4,0,0,null,1
+checkmate,testNames,5,0,0,null,1
+checkmate,testNames,6,0,0,null,1
+checkmate,testNames,7,0,0,character,1
+checkmate,testNull,-1,0,0,logical,1
+checkmate,testNull,0,0,0,double,1
+checkmate,testNull,0,0,1,null,1
+checkmate,testNumber,-1,0,0,logical,1
+checkmate,testNumber,0,0,0,double,1
+checkmate,testNumber,0,0,1,integer[],1
+checkmate,testNumber,1,0,0,logical,1
+checkmate,testNumber,2,0,0,double,1
+checkmate,testNumber,3,0,0,double,1
+checkmate,testNumber,4,0,0,logical,1
+checkmate,testNumber,5,0,0,logical,1
+checkmate,testNumeric,-1,0,0,logical,1
+checkmate,testNumeric,0,0,0,double,1
+checkmate,testNumeric,1,0,0,double,1
+checkmate,testNumeric,2,0,0,double,1
+checkmate,testNumeric,3,0,0,logical,1
+checkmate,testNumeric,4,0,0,logical,1
+checkmate,testNumeric,5,0,0,logical,1
+checkmate,testNumeric,6,0,0,null,1
+checkmate,testNumeric,7,0,0,double,1
+checkmate,testNumeric,7,0,1,null,1
+checkmate,testOS,-1,0,0,logical,1
+checkmate,testOS,0,0,0,character,1
+checkmate,testPathForOutput,-1,0,0,logical,1
+checkmate,testPathForOutput,0,0,0,character,1
+checkmate,testPathForOutput,1,0,0,logical,1
+checkmate,testPathForOutput,2,0,0,null,1
+checkmate,testRaw,-1,0,0,logical,1
+checkmate,testRaw,0,0,0,raw,1
+checkmate,testRaw,1,0,0,null,1
+checkmate,testRaw,2,0,0,integer,1
+checkmate,testRaw,3,0,0,null,1
+checkmate,testRaw,4,0,0,null,1
+checkmate,testRaw,5,0,0,logical,1
+checkmate,testScalar,-1,0,0,logical,1
+checkmate,testScalar,0,0,0,double,1
+checkmate,testScalar,0,0,1,integer[],1
+checkmate,testScalar,1,0,0,logical,1
+checkmate,testScalar,2,0,0,logical,1
+checkmate,testScalarNA,-1,0,0,logical,1
+checkmate,testScalarNA,0,0,0,double,1
+checkmate,testScalarNA,0,0,1,^logical[],1
+checkmate,testScalarNA,0,0,2,null,1
+checkmate,testScalarNA,1,0,0,logical,1
+checkmate,testSetEqual,-1,0,0,logical,1
+checkmate,testSetEqual,0,0,0,character[],1
+checkmate,testSetEqual,0,0,1,class<`factor`>,1
+checkmate,testSetEqual,0,0,2,double,1
+checkmate,testSetEqual,0,0,3,integer[],1
+checkmate,testSetEqual,1,0,0,character[],1
+checkmate,testSetEqual,1,0,1,integer[],1
+checkmate,testSetEqual,2,0,0,logical,1
+checkmate,testSetEqual,3,0,0,logical,1
+checkmate,testString,-1,0,0,logical,1
+checkmate,testString,0,0,0,character[],1
+checkmate,testString,1,0,0,logical,1
+checkmate,testString,2,0,0,null,1
+checkmate,testString,3,0,0,null,1
+checkmate,testString,4,0,0,null,1
+checkmate,testString,5,0,0,logical,1
+checkmate,testString,6,0,0,logical,1
+checkmate,testSubset,-1,0,0,logical,1
+checkmate,testSubset,0,0,0,character[],1
+checkmate,testSubset,0,0,1,class<`factor`>,1
+checkmate,testSubset,0,0,2,double,1
+checkmate,testSubset,1,0,0,character[],1
+checkmate,testSubset,1,0,1,integer,1
+checkmate,testSubset,2,0,0,logical,1
+checkmate,testSubset,3,0,0,logical,1
+checkmate,testTibble,-1,0,0,logical,1
+checkmate,testTibble,0,0,0,"class<`data.frame`, `tbl`, `tbl_df`>",1
+checkmate,testTibble,1,0,0,character[],1
+checkmate,testTibble,2,0,0,logical,1
+checkmate,testTibble,3,0,0,logical,1
+checkmate,testTibble,4,0,0,null,1
+checkmate,testTibble,5,0,0,null,1
+checkmate,testTibble,6,0,0,null,1
+checkmate,testTibble,7,0,0,null,1
+checkmate,testTRUE,-1,0,0,logical,1
+checkmate,testTRUE,0,0,0,logical,1
+checkmate,testTRUE,1,0,0,logical,1
+checkmate,testVector,-1,0,0,logical,1
+checkmate,testVector,0,0,0,character[],1
+checkmate,testVector,1,0,0,logical,1
+checkmate,testVector,2,0,0,logical,1
+checkmate,testVector,3,0,0,logical,1
+checkmate,testVector,4,0,0,null,1
+checkmate,testVector,5,0,0,integer,1
+checkmate,testVector,6,0,0,null,1
+checkmate,testVector,7,0,0,logical,1
+checkmate,vname,-1,0,0,character,1
+checkmate,vname,0,0,0,any,1
+checkmate,wf,-1,0,0,integer[],1
+checkmate,wf,0,0,0,logical[],1
+checkmate,wf,0,0,1,null,1
+checkmate,wf,1,0,0,logical,1
+checkmate,wl,-1,0,0,integer[],1
+checkmate,wl,0,0,0,logical[],1
+checkmate,wl,1,0,0,logical,1
+checkr,cc_and,-1,0,0,character,1
+checkr,cc_and,0,0,0,character[],1
+checkr,cc_and,0,0,1,double[],1
+checkr,cc_or,-1,0,0,character,1
+checkr,cc_or,0,0,0,character[],1
+checkr,check_attributes,-1,0,0,class<`Date`>,1
+checkr,check_attributes,-1,0,1,"class<`POSIXct`, `POSIXt`>",1
+checkr,check_attributes,-1,0,2,double,1
+checkr,check_attributes,-1,0,3,integer[],1
+checkr,check_attributes,0,0,0,class<`Date`>,1
+checkr,check_attributes,0,0,1,"class<`POSIXct`, `POSIXt`>",1
+checkr,check_attributes,0,0,2,double,1
+checkr,check_attributes,0,0,3,integer[],1
+checkr,check_attributes,1,0,0,null,1
+checkr,check_attributes,1,0,1,list<integer[]>,1
+checkr,check_attributes,2,0,0,logical,1
+checkr,check_attributes,3,0,0,logical,1
+checkr,check_attributes,4,0,0,logical,1
+checkr,check_attributes,5,0,0,logical,1
+checkr,check_attributes,6,0,0,character,1
+checkr,check_attributes,6,0,1,class<`name`>,1
+checkr,check_attributes,7,0,0,logical,1
+checkr,check_character,-1,0,0,character[],1
+checkr,check_character,-1,0,1,integer[],1
+checkr,check_character,0,0,0,character[],1
+checkr,check_character,0,0,1,integer[],1
+checkr,check_character,1,0,0,logical,1
+checkr,check_character,2,0,0,character,1
+checkr,check_character,2,0,1,class<`call`>,1
+checkr,check_character,3,0,0,logical,1
+checkr,check_chr,-1,0,0,character[],1
+checkr,check_chr,-1,0,1,double,1
+checkr,check_chr,0,0,0,character[],1
+checkr,check_chr,0,0,1,double,1
+checkr,check_chr,1,0,0,logical,1
+checkr,check_chr,2,0,0,class<`call`>,1
+checkr,check_chr,2,0,1,character,1
+checkr,check_chr,2,0,2,double,1
+checkr,check_chr,3,0,0,logical,1
+checkr,check_classes,-1,0,0,list<any>,1
+checkr,check_classes,0,0,0,list<any>,1
+checkr,check_classes,1,0,0,character[],1
+checkr,check_classes,2,0,0,logical,1
+checkr,check_classes,3,0,0,logical,1
+checkr,check_classes,4,0,0,class<`call`>,1
+checkr,check_classes,5,0,0,logical,1
+checkr,check_class_internal,-1,0,0,character[],1
+checkr,check_class_internal,-1,0,1,class<`Date`>,1
+checkr,check_class_internal,-1,0,2,"class<`POSIXct`, `POSIXt`>",1
+checkr,check_class_internal,-1,0,3,double[],1
+checkr,check_class_internal,-1,0,4,^integer[],1
+checkr,check_class_internal,0,0,0,character[],1
+checkr,check_class_internal,0,0,1,class<`Date`>,1
+checkr,check_class_internal,0,0,2,"class<`POSIXct`, `POSIXt`>",1
+checkr,check_class_internal,0,0,3,double[],1
+checkr,check_class_internal,0,0,4,^integer[],1
+checkr,check_class_internal,1,0,0,^character[],1
+checkr,check_class_internal,1,0,1,class<`Date`>,1
+checkr,check_class_internal,1,0,2,"class<`POSIXct`, `POSIXt`>",1
+checkr,check_class_internal,1,0,3,^double[],1
+checkr,check_class_internal,1,0,4,null,1
+checkr,check_class_internal,2,0,0,character,1
+checkr,check_class_internal,3,0,0,logical,1
+checkr,check_colnames,-1,0,0,class<`data.frame`>,1
+checkr,check_colnames,0,0,0,class<`data.frame`>,1
+checkr,check_colnames,1,0,0,character[],1
+checkr,check_colnames,2,0,0,logical,1
+checkr,check_colnames,3,0,0,logical,1
+checkr,check_colnames,4,0,0,character,1
+checkr,check_colnames,4,0,1,class<`name`>,1
+checkr,check_colnames,5,0,0,logical,1
+checkr,check_count,-1,0,0,double,1
+checkr,check_count,0,0,0,double,1
+checkr,check_count,1,0,0,logical,1
+checkr,check_count,2,0,0,double,1
+checkr,check_count,2,0,1,class<`call`>,1
+checkr,check_count,3,0,0,logical,1
+checkr,check_data,-1,0,0,class<`data.frame`>,1
+checkr,check_data,0,0,0,class<`data.frame`>,1
+checkr,check_data,1,0,0,null,1
+checkr,check_data,1,0,1,list<null | double[]>,1
+checkr,check_data,2,0,0,null,1
+checkr,check_data,2,0,1,integer,1
+checkr,check_data,3,0,0,logical,1
+checkr,check_data,4,0,0,logical,1
+checkr,check_data,5,0,0,character[],1
+checkr,check_data,6,0,0,character,1
+checkr,check_data,6,0,1,class<`name`>,1
+checkr,check_data,7,0,0,logical,1
+checkr,check_date,-1,0,0,class<`Date`>,1
+checkr,check_date,-1,0,1,"class<`POSIXct`, `POSIXt`>",1
+checkr,check_date,0,0,0,class<`Date`>,1
+checkr,check_date,0,0,1,"class<`POSIXct`, `POSIXt`>",1
+checkr,check_date,1,0,0,logical,1
+checkr,check_date,2,0,0,class<`call`>,1
+checkr,check_date,3,0,0,logical,1
+checkr,check_dbl,-1,0,0,double[],1
+checkr,check_dbl,0,0,0,double[],1
+checkr,check_dbl,1,0,0,logical,1
+checkr,check_dbl,2,0,0,class<`call`>,1
+checkr,check_dbl,2,0,1,double,1
+checkr,check_dbl,3,0,0,logical,1
+checkr,check_dttm,-1,0,0,class<`Date`>,1
+checkr,check_dttm,-1,0,1,"class<`POSIXct`, `POSIXt`>",1
+checkr,check_dttm,0,0,0,class<`Date`>,1
+checkr,check_dttm,0,0,1,"class<`POSIXct`, `POSIXt`>",1
+checkr,check_dttm,1,0,0,logical,1
+checkr,check_dttm,2,0,0,character,1
+checkr,check_dttm,3,0,0,class<`call`>,1
+checkr,check_dttm,4,0,0,logical,1
+checkr,check_environment,-1,0,0,double,1
+checkr,check_environment,-1,0,1,environment,1
+checkr,check_environment,0,0,0,double,1
+checkr,check_environment,0,0,1,environment,1
+checkr,check_environment,1,0,0,double,1
+checkr,check_environment,1,0,1,class<`name`>,1
+checkr,check_environment,2,0,0,logical,1
+checkr,check_flag,-1,0,0,logical,1
+checkr,check_flag,0,0,0,logical,1
+checkr,check_flag,1,0,0,logical,1
+checkr,check_flag,2,0,0,class<`name`>,1
+checkr,check_flag,3,0,0,logical,1
+checkr,check_flag_internal,-1,0,0,null,1
+checkr,check_flag_internal,0,0,0,logical,1
+checkr,check_function,-1,0,0,class<`function`>,1
+checkr,check_function,0,0,0,class<`function`>,1
+checkr,check_function,1,0,0,integer,1
+checkr,check_function,1,0,1,null,1
+checkr,check_function,2,0,0,class<`name`>,1
+checkr,check_function,3,0,0,logical,1
+checkr,check_grepl,-1,0,0,character[],1
+checkr,check_grepl,0,0,0,character[],1
+checkr,check_grepl,1,0,0,character,1
+checkr,check_grepl,2,0,0,any,1
+checkr,check_grepl,3,0,0,character,1
+checkr,check_grepl,4,0,0,logical,1
+checkr,check_homogenous,-1,0,0,integer[],1
+checkr,check_homogenous,-1,0,1,list<double>,1
+checkr,check_homogenous,0,0,0,integer[],1
+checkr,check_homogenous,0,0,1,list<double>,1
+checkr,check_homogenous,1,0,0,logical,1
+checkr,check_homogenous,2,0,0,logical,1
+checkr,check_homogenous,3,0,0,class<`call`>,1
+checkr,check_homogenous,4,0,0,logical,1
+checkr,check_inherits,-1,0,0,class<`data.frame`>,1
+checkr,check_inherits,-1,0,1,list<any>,1
+checkr,check_inherits,0,0,0,class<`data.frame`>,1
+checkr,check_inherits,0,0,1,list<any>,1
+checkr,check_inherits,1,0,0,character,1
+checkr,check_inherits,2,0,0,character,1
+checkr,check_inherits,2,0,1,class<`call`>,1
+checkr,check_inherits,3,0,0,logical,1
+checkr,check_int,-1,0,0,double,1
+checkr,check_int,-1,0,1,integer[],1
+checkr,check_int,0,0,0,double,1
+checkr,check_int,0,0,1,integer[],1
+checkr,check_int,1,0,0,logical,1
+checkr,check_int,2,0,0,double,1
+checkr,check_int,2,0,1,class<`call`>,1
+checkr,check_int,3,0,0,logical,1
+checkr,check_integer,-1,0,0,double,1
+checkr,check_integer,-1,0,1,integer[],1
+checkr,check_integer,0,0,0,double,1
+checkr,check_integer,0,0,1,integer[],1
+checkr,check_integer,1,0,0,logical,1
+checkr,check_integer,2,0,0,double,1
+checkr,check_integer,2,0,1,class<`call`>,1
+checkr,check_integer,3,0,0,logical,1
+checkr,check_intersection,-1,0,0,integer[],1
+checkr,check_intersection,0,0,0,integer[],1
+checkr,check_intersection,1,0,0,integer[],1
+checkr,check_intersection,2,0,0,logical,1
+checkr,check_intersection,3,0,0,class<`name`>,1
+checkr,check_intersection,4,0,0,class<`name`>,1
+checkr,check_intersection,5,0,0,logical,1
+checkr,check_join,-1,0,0,class<`data.frame`>,1
+checkr,check_join,0,0,0,class<`data.frame`>,1
+checkr,check_join,1,0,0,class<`data.frame`>,1
+checkr,check_join,2,0,0,character,1
+checkr,check_join,2,0,1,null,1
+checkr,check_join,3,0,0,logical,1
+checkr,check_join,4,0,0,class<`name`>,1
+checkr,check_join,5,0,0,class<`name`>,1
+checkr,check_join,6,0,0,logical,1
+checkr,check_key,-1,0,0,class<`data.frame`>,1
+checkr,check_key,0,0,0,class<`data.frame`>,1
+checkr,check_key,1,0,0,character[],1
+checkr,check_key,2,0,0,logical,1
+checkr,check_key,3,0,0,character,1
+checkr,check_key,3,0,1,class<`name`>,1
+checkr,check_key,4,0,0,any,1
+checkr,check_length,-1,0,0,any,1
+checkr,check_length,0,0,0,character[],1
+checkr,check_length,0,0,1,class<`Date`>,1
+checkr,check_length,0,0,2,"class<`POSIXct`, `POSIXt`>",1
+checkr,check_length,0,0,3,double[],1
+checkr,check_length,0,0,4,null,1
+checkr,check_length,0,0,5,list<any>,1
+checkr,check_length,1,0,0,double,1
+checkr,check_length,1,0,1,integer[],1
+checkr,check_length,1,0,2,null,1
+checkr,check_length,2,0,0,class<`call`>,1
+checkr,check_length,2,0,1,character,1
+checkr,check_length,2,0,2,double,1
+checkr,check_length,2,0,3,null,1
+checkr,check_length,3,0,0,logical,1
+checkr,check_length1,-1,0,0,double,1
+checkr,check_length1,-1,0,1,integer[],1
+checkr,check_length1,-1,0,2,list<any>,1
+checkr,check_length1,-1,0,3,null,1
+checkr,check_length1,0,0,0,double,1
+checkr,check_length1,0,0,1,integer[],1
+checkr,check_length1,0,0,2,list<any>,1
+checkr,check_length1,0,0,3,null,1
+checkr,check_length1,1,0,0,double,1
+checkr,check_length1,1,0,1,class<`call`>,1
+checkr,check_length1,1,0,2,null,1
+checkr,check_length1,2,0,0,logical,1
+checkr,check_length_internal,-1,0,0,null,1
+checkr,check_length_internal,0,0,0,double,1
+checkr,check_length_internal,0,0,1,integer[],1
+checkr,check_length_internal,0,0,2,null,1
+checkr,check_levels,-1,0,0,class<`factor`>,1
+checkr,check_levels,-1,0,1,double,1
+checkr,check_levels,0,0,0,class<`factor`>,1
+checkr,check_levels,0,0,1,double,1
+checkr,check_levels,1,0,0,character[],1
+checkr,check_levels,2,0,0,logical,1
+checkr,check_levels,3,0,0,logical,1
+checkr,check_levels,4,0,0,class<`call`>,1
+checkr,check_levels,4,0,1,double,1
+checkr,check_levels,5,0,0,logical,1
+checkr,check_lgl,-1,0,0,double,1
+checkr,check_lgl,-1,0,1,logical[],1
+checkr,check_lgl,0,0,0,double,1
+checkr,check_lgl,0,0,1,logical[],1
+checkr,check_lgl,1,0,0,logical,1
+checkr,check_lgl,2,0,0,double,1
+checkr,check_lgl,2,0,1,class<`call`>,1
+checkr,check_lgl,2,0,2,character,1
+checkr,check_lgl,3,0,0,logical,1
+checkr,check_list,-1,0,0,list<any>,1
+checkr,check_list,0,0,0,list<any>,1
+checkr,check_list,1,0,0,null,1
+checkr,check_list,1,0,1,list<double>,1
+checkr,check_list,1,0,2,list<integer[]>,1
+checkr,check_list,2,0,0,null,1
+checkr,check_list,3,0,0,logical,1
+checkr,check_list,4,0,0,null,1
+checkr,check_list,5,0,0,logical,1
+checkr,check_list,6,0,0,logical,1
+checkr,check_list,7,0,0,class<`call`>,1
+checkr,check_list,7,0,1,character,1
+checkr,check_logical,-1,0,0,double,1
+checkr,check_logical,-1,0,1,logical[],1
+checkr,check_logical,0,0,0,double,1
+checkr,check_logical,0,0,1,logical[],1
+checkr,check_logical,1,0,0,logical,1
+checkr,check_logical,2,0,0,double,1
+checkr,check_logical,2,0,1,class<`call`>,1
+checkr,check_logical,3,0,0,logical,1
+checkr,check_missing_colnames,-1,0,0,class<`data.frame`>,1
+checkr,check_missing_colnames,0,0,0,class<`data.frame`>,1
+checkr,check_missing_colnames,1,0,0,character[],1
+checkr,check_missing_colnames,2,0,0,class<`name`>,1
+checkr,check_missing_colnames,3,0,0,logical,1
+checkr,check_missing_names,-1,0,0,double[],1
+checkr,check_missing_names,0,0,0,double[],1
+checkr,check_missing_names,1,0,0,character[],1
+checkr,check_missing_names,2,0,0,class<`name`>,1
+checkr,check_missing_names,3,0,0,logical,1
+checkr,check_n,-1,0,0,any,1
+checkr,check_n,0,0,0,any,1
+checkr,check_n,1,0,0,any,1
+checkr,check_n,2,0,0,null,1
+checkr,check_n,2,0,1,double,1
+checkr,check_n,2,0,2,integer[],1
+checkr,check_n,3,0,0,any,1
+checkr,check_n,4,0,0,character,1
+checkr,check_n,5,0,0,any,1
+checkr,check_name,-1,0,0,character[],1
+checkr,check_name,0,0,0,character[],1
+checkr,check_name,1,0,0,class<`name`>,1
+checkr,check_name,2,0,0,logical,1
+checkr,check_name,3,0,0,logical,1
+checkr,check_named,-1,0,0,double[],1
+checkr,check_named,-1,0,1,list<double | integer[]>,1
+checkr,check_named,-1,0,2,list<double>,1
+checkr,check_named,-1,0,3,list<integer[]>,1
+checkr,check_named,0,0,0,double[],1
+checkr,check_named,0,0,1,list<double | integer[]>,1
+checkr,check_named,0,0,2,list<double>,1
+checkr,check_named,0,0,3,list<integer[]>,1
+checkr,check_named,1,0,0,any,1
+checkr,check_named,2,0,0,character,1
+checkr,check_named,3,0,0,any,1
+checkr,check_named,4,0,0,logical,1
+checkr,check_named,5,0,0,double,1
+checkr,check_named,5,0,1,character,1
+checkr,check_named,5,0,2,class<`name`>,1
+checkr,check_named,6,0,0,logical,1
+checkr,check_names,-1,0,0,double[],1
+checkr,check_names,-1,0,1,list<double | integer[]>,1
+checkr,check_names,-1,0,2,list<integer>,1
+checkr,check_names,0,0,0,double[],1
+checkr,check_names,0,0,1,list<double | integer[]>,1
+checkr,check_names,0,0,2,list<integer>,1
+checkr,check_names,1,0,0,character[],1
+checkr,check_names,2,0,0,logical,1
+checkr,check_names,3,0,0,logical,1
+checkr,check_names,4,0,0,logical,1
+checkr,check_names,5,0,0,logical,1
+checkr,check_names,6,0,0,class<`name`>,1
+checkr,check_names,7,0,0,logical,1
+checkr,check_nas,-1,0,0,character[],1
+checkr,check_nas,-1,0,1,class<`Date`>,1
+checkr,check_nas,-1,0,2,"class<`POSIXct`, `POSIXt`>",1
+checkr,check_nas,-1,0,3,double[],1
+checkr,check_nas,-1,0,4,^integer[],1
+checkr,check_nas,0,0,0,character[],1
+checkr,check_nas,0,0,1,class<`Date`>,1
+checkr,check_nas,0,0,2,"class<`POSIXct`, `POSIXt`>",1
+checkr,check_nas,0,0,3,double[],1
+checkr,check_nas,0,0,4,^integer[],1
+checkr,check_nas,1,0,0,^character[],1
+checkr,check_nas,1,0,1,class<`Date`>,1
+checkr,check_nas,1,0,2,"class<`POSIXct`, `POSIXt`>",1
+checkr,check_nas,1,0,3,^double[],1
+checkr,check_nas,1,0,4,null,1
+checkr,check_nas,2,0,0,character,1
+checkr,check_nas,3,0,0,logical,1
+checkr,check_nchar,-1,0,0,character[],1
+checkr,check_nchar,0,0,0,character[],1
+checkr,check_nchar,1,0,0,double,1
+checkr,check_nchar,1,0,1,integer[],1
+checkr,check_nchar,2,0,0,class<`call`>,1
+checkr,check_nchar,2,0,1,character,1
+checkr,check_nchar,3,0,0,logical,1
+checkr,check_ncol,-1,0,0,class<`data.frame`>,1
+checkr,check_ncol,0,0,0,class<`data.frame`>,1
+checkr,check_ncol,1,0,0,double,1
+checkr,check_ncol,2,0,0,class<`call`>,1
+checkr,check_ncol,3,0,0,logical,1
+checkr,check_neg_dbl,-1,0,0,double,1
+checkr,check_neg_dbl,0,0,0,double,1
+checkr,check_neg_dbl,1,0,0,logical,1
+checkr,check_neg_dbl,2,0,0,double,1
+checkr,check_neg_dbl,3,0,0,logical,1
+checkr,check_neg_int,-1,0,0,integer,1
+checkr,check_neg_int,0,0,0,integer,1
+checkr,check_neg_int,1,0,0,logical,1
+checkr,check_neg_int,2,0,0,class<`call`>,1
+checkr,check_neg_int,2,0,1,integer,1
+checkr,check_neg_int,3,0,0,logical,1
+checkr,check_nlevels,-1,0,0,class<`factor`>,1
+checkr,check_nlevels,0,0,0,class<`factor`>,1
+checkr,check_nlevels,1,0,0,double,1
+checkr,check_nlevels,2,0,0,class<`call`>,1
+checkr,check_nlevels,3,0,0,logical,1
+checkr,check_no_attributes,-1,0,0,character[],1
+checkr,check_no_attributes,-1,0,1,double[],1
+checkr,check_no_attributes,0,0,0,character[],1
+checkr,check_no_attributes,0,0,1,double[],1
+checkr,check_no_attributes,1,0,0,logical,1
+checkr,check_no_attributes,2,0,0,logical,1
+checkr,check_no_attributes,3,0,0,character,1
+checkr,check_no_attributes,3,0,1,class<`name`>,1
+checkr,check_no_attributes,4,0,0,logical,1
+checkr,check_noneg_dbl,-1,0,0,double,1
+checkr,check_noneg_dbl,0,0,0,double,1
+checkr,check_noneg_dbl,1,0,0,logical,1
+checkr,check_noneg_dbl,2,0,0,double,1
+checkr,check_noneg_dbl,3,0,0,logical,1
+checkr,check_noneg_int,-1,0,0,double,1
+checkr,check_noneg_int,0,0,0,double,1
+checkr,check_noneg_int,1,0,0,logical,1
+checkr,check_noneg_int,2,0,0,character,1
+checkr,check_noneg_int,2,0,1,double,1
+checkr,check_noneg_int,3,0,0,logical,1
+checkr,check_nrow,-1,0,0,class<`data.frame`>,1
+checkr,check_nrow,0,0,0,class<`data.frame`>,1
+checkr,check_nrow,1,0,0,double,1
+checkr,check_nrow,1,0,1,null,1
+checkr,check_nrow,2,0,0,class<`call`>,1
+checkr,check_nrow,2,0,1,character,1
+checkr,check_nrow,3,0,0,logical,1
+checkr,check_null,-1,0,0,any,1
+checkr,check_null,0,0,0,double,1
+checkr,check_null,0,0,1,character,1
+checkr,check_null,0,0,2,null,1
+checkr,check_null,1,0,0,double,1
+checkr,check_null,1,0,1,class<`name`>,1
+checkr,check_null,1,0,2,null,1
+checkr,check_null,2,0,0,logical,1
+checkr,check_numeric,-1,0,0,double,1
+checkr,check_numeric,-1,0,1,integer[],1
+checkr,check_numeric,0,0,0,double,1
+checkr,check_numeric,0,0,1,integer[],1
+checkr,check_numeric,1,0,0,logical,1
+checkr,check_numeric,2,0,0,double,1
+checkr,check_numeric,2,0,1,class<`call`>,1
+checkr,check_numeric,3,0,0,logical,1
+checkr,checkor,-1,0,0,logical,1
+checkr,checkor,0,0,0,...,1
+checkr,checkor,1,0,0,logical,1
+checkr,check_pos_dbl,-1,0,0,double,1
+checkr,check_pos_dbl,0,0,0,double,1
+checkr,check_pos_dbl,1,0,0,logical,1
+checkr,check_pos_dbl,2,0,0,double,1
+checkr,check_pos_dbl,3,0,0,logical,1
+checkr,check_pos_int,-1,0,0,double,1
+checkr,check_pos_int,-1,0,1,integer[],1
+checkr,check_pos_int,0,0,0,double,1
+checkr,check_pos_int,0,0,1,integer[],1
+checkr,check_pos_int,1,0,0,logical,1
+checkr,check_pos_int,2,0,0,double,1
+checkr,check_pos_int,2,0,1,class<`call`>,1
+checkr,check_pos_int,3,0,0,logical,1
+checkr,check_prob,-1,0,0,double[],1
+checkr,check_prob,0,0,0,double[],1
+checkr,check_prob,1,0,0,logical,1
+checkr,check_prob,2,0,0,class<`call`>,1
+checkr,check_prob,2,0,1,double,1
+checkr,check_prob,3,0,0,logical,1
+checkr,check_rbind,-1,0,0,class<`data.frame`>,1
+checkr,check_rbind,0,0,0,class<`data.frame`>,1
+checkr,check_rbind,1,0,0,class<`data.frame`>,1
+checkr,check_rbind,2,0,0,logical,1
+checkr,check_rbind,3,0,0,logical,1
+checkr,check_rbind,4,0,0,class<`call`>,1
+checkr,check_rbind,5,0,0,class<`call`>,1
+checkr,check_rbind,6,0,0,logical,1
+checkr,check_scalar,-1,0,0,character[],1
+checkr,check_scalar,-1,0,1,class<`Date`>,1
+checkr,check_scalar,-1,0,2,"class<`POSIXct`, `POSIXt`>",1
+checkr,check_scalar,-1,0,3,double[],1
+checkr,check_scalar,0,0,0,character[],1
+checkr,check_scalar,0,0,1,class<`Date`>,1
+checkr,check_scalar,0,0,2,"class<`POSIXct`, `POSIXt`>",1
+checkr,check_scalar,0,0,3,double[],1
+checkr,check_scalar,1,0,0,character,1
+checkr,check_scalar,1,0,1,class<`Date`>,1
+checkr,check_scalar,1,0,2,"class<`POSIXct`, `POSIXt`>",1
+checkr,check_scalar,1,0,3,double[],1
+checkr,check_scalar,1,0,4,null,1
+checkr,check_scalar,2,0,0,logical,1
+checkr,check_scalar,3,0,0,logical,1
+checkr,check_scalar,4,0,0,logical,1
+checkr,check_scalar,5,0,0,character,1
+checkr,check_scalar,5,0,1,class<`call`>,1
+checkr,check_scalar,5,0,2,double,1
+checkr,check_scalar,6,0,0,logical,1
+checkr,check_sorted,-1,0,0,integer[],1
+checkr,check_sorted,0,0,0,integer[],1
+checkr,check_sorted,1,0,0,character,1
+checkr,check_sorted,1,0,1,class<`call`>,1
+checkr,check_sorted,2,0,0,logical,1
+checkr,check_string,-1,0,0,character,1
+checkr,check_string,0,0,0,character,1
+checkr,check_string,1,0,0,logical,1
+checkr,check_string,2,0,0,class<`name`>,1
+checkr,check_string,3,0,0,logical,1
+checkr,check_string_internal,-1,0,0,null,1
+checkr,check_string_internal,0,0,0,character,1
+checkr,check_tzone,-1,0,0,class<`Date`>,1
+checkr,check_tzone,-1,0,1,"class<`POSIXct`, `POSIXt`>",1
+checkr,check_tzone,0,0,0,class<`Date`>,1
+checkr,check_tzone,0,0,1,"class<`POSIXct`, `POSIXt`>",1
+checkr,check_tzone,1,0,0,character,1
+checkr,check_tzone,2,0,0,class<`call`>,1
+checkr,check_tzone,2,0,1,class<`name`>,1
+checkr,check_tzone,3,0,0,logical,1
+checkr,check_unique,-1,0,0,character[],1
+checkr,check_unique,-1,0,1,double[],1
+checkr,check_unique,-1,0,2,list<any>,1
+checkr,check_unique,-1,0,3,null,1
+checkr,check_unique,0,0,0,character[],1
+checkr,check_unique,0,0,1,double[],1
+checkr,check_unique,0,0,2,list<any>,1
+checkr,check_unique,0,0,3,null,1
+checkr,check_unique,1,0,0,character,1
+checkr,check_unique,1,0,1,class<`call`>,1
+checkr,check_unique,1,0,2,double,1
+checkr,check_unique,1,0,3,null,1
+checkr,check_unique,2,0,0,logical,1
+checkr,check_unnamed,-1,0,0,character[],1
+checkr,check_unnamed,-1,0,1,class<`Date`>,1
+checkr,check_unnamed,-1,0,2,"class<`POSIXct`, `POSIXt`>",1
+checkr,check_unnamed,-1,0,3,double[],1
+checkr,check_unnamed,0,0,0,character[],1
+checkr,check_unnamed,0,0,1,class<`Date`>,1
+checkr,check_unnamed,0,0,2,"class<`POSIXct`, `POSIXt`>",1
+checkr,check_unnamed,0,0,3,double[],1
+checkr,check_unnamed,1,0,0,character,1
+checkr,check_unnamed,1,0,1,double,1
+checkr,check_unnamed,1,0,2,class<`name`>,1
+checkr,check_unnamed,2,0,0,logical,1
+checkr,check_unused,-1,0,0,double,1
+checkr,check_unused,-1,0,1,null,1
+checkr,check_unused,0,0,0,...,1
+checkr,check_unused,1,0,0,character,1
+checkr,check_unused,2,0,0,logical,1
+checkr,check_values,-1,0,0,character[],1
+checkr,check_values,-1,0,1,class<`Date`>,1
+checkr,check_values,-1,0,2,"class<`POSIXct`, `POSIXt`>",1
+checkr,check_values,-1,0,3,double[],1
+checkr,check_values,-1,0,4,^integer[],1
+checkr,check_values,0,0,0,character[],1
+checkr,check_values,0,0,1,class<`Date`>,1
+checkr,check_values,0,0,2,"class<`POSIXct`, `POSIXt`>",1
+checkr,check_values,0,0,3,double[],1
+checkr,check_values,0,0,4,^integer[],1
+checkr,check_values,1,0,0,^character[],1
+checkr,check_values,1,0,1,class<`Date`>,1
+checkr,check_values,1,0,2,"class<`POSIXct`, `POSIXt`>",1
+checkr,check_values,1,0,3,^double[],1
+checkr,check_values,1,0,4,null,1
+checkr,check_values,2,0,0,any,1
+checkr,check_values,3,0,0,character,1
+checkr,check_values,4,0,0,logical,1
+checkr,check_vector,-1,0,0,any,1
+checkr,check_vector,0,0,0,character[],1
+checkr,check_vector,0,0,1,class<`Date`>,1
+checkr,check_vector,0,0,2,"class<`POSIXct`, `POSIXt`>",1
+checkr,check_vector,0,0,3,double[],1
+checkr,check_vector,0,0,4,null,1
+checkr,check_vector,1,0,0,^character[],1
+checkr,check_vector,1,0,1,class<`Date`>,1
+checkr,check_vector,1,0,2,"class<`POSIXct`, `POSIXt`>",1
+checkr,check_vector,1,0,3,null,1
+checkr,check_vector,1,0,4,^double[],1
+checkr,check_vector,2,0,0,null,1
+checkr,check_vector,2,0,1,integer[],1
+checkr,check_vector,2,0,2,double,1
+checkr,check_vector,3,0,0,logical,1
+checkr,check_vector,4,0,0,logical,1
+checkr,check_vector,5,0,0,logical,1
+checkr,check_vector,5,0,1,null,1
+checkr,check_vector,6,0,0,logical,1
+checkr,check_vector,6,0,1,null,1
+checkr,check_vector,7,0,0,logical,1
+checkr,chk_deparse,-1,0,0,character,1
+checkr,chk_deparse,0,0,0,character,1
+checkr,chk_deparse,0,0,1,class<`call`>,1
+checkr,chk_deparse,0,0,2,class<`name`>,1
+checkr,chk_deparse,0,0,3,double,1
+checkr,chk_deparse,0,0,4,null,1
+checkr,chk_fail,-1,0,0,any,1
+checkr,chk_fail,0,0,0,...,1
+checkr,chk_fail,1,0,0,logical,1
+checkr,chk_max_dbl,-1,0,0,double,1
+checkr,chk_max_int,-1,0,0,integer,1
+checkr,chk_min_dbl,-1,0,0,double,1
+checkr,chk_min_int,-1,0,0,integer,1
+checkr,chk_tiny_dbl,-1,0,0,double,1
+checkr,co_and,-1,0,0,character,1
+checkr,co_and,0,0,0,character[],1
+checkr,co_and,1,0,0,character,1
+checkr,co_and,2,0,0,class<`call`>,1
+checkr,co_and,2,0,1,class<`name`>,1
+checkr,err_deparse,-1,0,0,character,1
+checkr,err_deparse,0,0,0,class<`call`>,1
+checkr,err_deparse,0,0,1,class<`name`>,1
+checkr,is_count,-1,0,0,logical,1
+checkr,is_count,0,0,0,double,1
+checkr,is_count,0,0,1,integer[],1
+checkr,is_count,0,0,2,null,1
+checkr,is_count_range,-1,0,0,logical,1
+checkr,is_count_range,0,0,0,double,1
+checkr,is_count_range,0,0,1,integer[],1
+checkr,is_count_range,0,0,2,null,1
+checkr,is_flag,-1,0,0,logical,1
+checkr,is_flag,0,0,0,double,1
+checkr,is_flag,0,0,1,integer[],1
+checkr,is_flag,0,0,2,null,1
+checkr,is_length,-1,0,0,logical,1
+checkr,is_length,0,0,0,double,1
+checkr,is_length,0,0,1,integer[],1
+checkr,is_length,0,0,2,null,1
+checkr,is_NA,-1,0,0,logical,1
+checkr,is_NA,0,0,0,double,1
+checkr,is_NA,0,0,1,integer[],1
+checkr,is_NA,0,0,2,null,1
+checkr,is.POSIXt,-1,0,0,logical,1
+checkr,is.POSIXt,0,0,0,"class<`POSIXct`, `POSIXt`>",1
+checkr,is_string,-1,0,0,logical,1
+checkr,is_string,0,0,0,character,1
+checkr,is_string,0,0,1,null,1
+checkr,new_duplicated,-1,0,0,logical[],1
+checkr,new_duplicated,0,0,0,class<`data.frame`>,1
+checkr,new_duplicated,1,0,0,logical,1
+checkr,new_duplicated,2,0,0,logical,1
+checkr,new_duplicated,3,0,0,...,1
+checkr,tz,-1,0,0,character,1
+checkr,tz,0,0,0,"class<`POSIXct`, `POSIXt`>",1
+chk,abort_chk,-1,0,0,any,1
+chk,abort_chk,0,0,0,...,1
+chk,abort_chk,1,0,0,double,1
+chk,abort_chk,1,0,1,null,1
+chk,abort_chk,2,0,0,logical,1
+chk,.anyDuplicated,-1,0,0,integer,1
+chk,.anyDuplicated,0,0,0,character[],1
+chk,.anyDuplicated,0,0,1,^double[],1
+chk,.anyDuplicated,0,0,2,null,1
+chk,.anyDuplicated,1,0,0,logical,1
+chk,.anyDuplicated,1,0,1,null,1
+chk,backtick_chk,-1,0,0,character,1
+chk,backtick_chk,0,0,0,character,1
+chk,cc,-1,0,0,character,1
+chk,cc,0,0,0,character[],1
+chk,cc,0,0,1,double[],1
+chk,cc,1,0,0,character,1
+chk,cc,2,0,0,character,1
+chk,cc,3,0,0,character,1
+chk,cc,4,0,0,integer,1
+chk,cc,5,0,0,logical,1
+chk,check_data,-1,0,0,any,1
+chk,check_data,0,0,0,class<`data.frame`>,1
+chk,check_data,1,0,0,null,1
+chk,check_data,1,0,1,list<double>,1
+chk,check_data,2,0,0,logical,1
+chk,check_data,3,0,0,logical,1
+chk,check_data,4,0,0,double[],1
+chk,check_data,5,0,0,any,1
+chk,check_data,6,0,0,null,1
+chk,check_dim,-1,0,0,any,1
+chk,check_dim,0,0,0,class<`data.frame`>,1
+chk,check_dim,0,0,1,double,1
+chk,check_dim,1,0,0,class<`function`>,1
+chk,check_dim,2,0,0,double[],1
+chk,check_dim,3,0,0,null,1
+chk,check_dim,3,0,1,character,1
+chk,check_dim,4,0,0,null,1
+chk,check_dim,4,0,1,character,1
+chk,check_key,-1,0,0,any,1
+chk,check_key,0,0,0,class<`data.frame`>,1
+chk,check_key,1,0,0,character[],1
+chk,check_key,2,0,0,logical,1
+chk,check_key,3,0,0,null,1
+chk,check_key,3,0,1,character,1
+chk,check_names,-1,0,0,any,1
+chk,check_names,0,0,0,class<`data.frame`>,1
+chk,check_names,0,0,1,double[],1
+chk,check_names,1,0,0,character[],1
+chk,check_names,2,0,0,logical,1
+chk,check_names,3,0,0,logical,1
+chk,check_names,4,0,0,character,1
+chk,check_names,4,0,1,null,1
+chk,check_values,-1,0,0,any,1
+chk,check_values,0,0,0,double,1
+chk,check_values,0,0,1,null,1
+chk,check_values,1,0,0,double[],1
+chk,check_values,2,0,0,null,1
+chk,check_values,2,0,1,character,1
+chk,chk_all,-1,0,0,null,1
+chk,chk_all,0,0,0,list<any>,1
+chk,chk_all,0,0,1,^logical[],1
+chk,chk_all,1,0,0,class<`function`>,1
+chk,chk_all,2,0,0,...,1
+chk,chk_all,3,0,0,null,1
+chk,chk_all_equal,-1,0,0,any,1
+chk,chk_all_equal,0,0,0,double[],1
+chk,chk_all_equal,0,0,1,list<double>,1
+chk,chk_all_equal,1,0,0,double,1
+chk,chk_all_equal,2,0,0,null,1
+chk,chk_all_equivalent,-1,0,0,any,1
+chk,chk_all_equivalent,0,0,0,double[],1
+chk,chk_all_equivalent,0,0,1,list<double>,1
+chk,chk_all_equivalent,1,0,0,double,1
+chk,chk_all_equivalent,2,0,0,null,1
+chk,chk_all_identical,-1,0,0,any,1
+chk,chk_all_identical,0,0,0,double[],1
+chk,chk_all_identical,1,0,0,null,1
+chk,chk_array,-1,0,0,null,1
+chk,chk_array,0,0,0,class<`array`>,1
+chk,chk_array,0,0,1,class<`matrix`>,1
+chk,chk_array,1,0,0,null,1
+chk,chk_atomic,-1,0,0,any,1
+chk,chk_atomic,0,0,0,list<double>,1
+chk,chk_atomic,0,0,1,double[],1
+chk,chk_atomic,0,0,2,null,1
+chk,chk_atomic,1,0,0,any,1
+chk,chk_character,-1,0,0,any,1
+chk,chk_character,0,0,0,double,1
+chk,chk_character,0,0,1,character,1
+chk,chk_character,1,0,0,null,1
+chk,chk_data,-1,0,0,any,1
+chk,chk_data,0,0,0,double,1
+chk,chk_data,0,0,1,class<`data.frame`>,1
+chk,chk_data,1,0,0,null,1
+chk,chk_data,1,0,1,character,1
+chk,chk_date,-1,0,0,any,1
+chk,chk_date,0,0,0,double,1
+chk,chk_date,0,0,1,class<`Date`>,1
+chk,chk_date,1,0,0,null,1
+chk,chk_datetime,-1,0,0,any,1
+chk,chk_datetime,0,0,0,double,1
+chk,chk_datetime,0,0,1,"class<`POSIXct`, `POSIXt`>",1
+chk,chk_datetime,1,0,0,null,1
+chk,chk_dir,-1,0,0,any,1
+chk,chk_dir,0,0,0,character,1
+chk,chk_dir,1,0,0,null,1
+chk,chk_double,-1,0,0,any,1
+chk,chk_double,0,0,0,double,1
+chk,chk_double,1,0,0,null,1
+chk,chk_environment,-1,0,0,any,1
+chk,chk_environment,0,0,0,double,1
+chk,chk_environment,0,0,1,environment,1
+chk,chk_environment,1,0,0,null,1
+chk,chk_equal,-1,0,0,any,1
+chk,chk_equal,0,0,0,double,1
+chk,chk_equal,1,0,0,double,1
+chk,chk_equal,2,0,0,double,1
+chk,chk_equal,3,0,0,null,1
+chk,chk_equal,3,0,1,character,1
+chk,chk_equivalent,-1,0,0,any,1
+chk,chk_equivalent,0,0,0,double,1
+chk,chk_equivalent,1,0,0,double,1
+chk,chk_equivalent,2,0,0,double,1
+chk,chk_equivalent,3,0,0,null,1
+chk,chk_ext,-1,0,0,any,1
+chk,chk_ext,0,0,0,character,1
+chk,chk_ext,1,0,0,character,1
+chk,chk_ext,2,0,0,null,1
+chk,chk_false,-1,0,0,any,1
+chk,chk_false,0,0,0,double,1
+chk,chk_false,1,0,0,null,1
+chk,chk_file,-1,0,0,any,1
+chk,chk_file,0,0,0,character,1
+chk,chk_file,1,0,0,null,1
+chk,chk_flag,-1,0,0,any,1
+chk,chk_flag,0,0,0,double[],1
+chk,chk_flag,1,0,0,null,1
+chk,chk_function,-1,0,0,any,1
+chk,chk_function,0,0,0,double,1
+chk,chk_function,0,0,1,class<`function`>,1
+chk,chk_function,1,0,0,null,1
+chk,chk_function,2,0,0,null,1
+chk,chk_gt,-1,0,0,any,1
+chk,chk_gt,0,0,0,double[],1
+chk,chk_gt,1,0,0,double,1
+chk,chk_gt,2,0,0,null,1
+chk,chk_gte,-1,0,0,any,1
+chk,chk_gte,0,0,0,double,1
+chk,chk_gte,1,0,0,double,1
+chk,chk_gte,2,0,0,null,1
+chk,chk_identical,-1,0,0,any,1
+chk,chk_identical,0,0,0,double[],1
+chk,chk_identical,1,0,0,double[],1
+chk,chk_identical,2,0,0,null,1
+chk,chk_integer,-1,0,0,any,1
+chk,chk_integer,0,0,0,double,1
+chk,chk_integer,1,0,0,null,1
+chk,chk_join,-1,0,0,any,1
+chk,chk_join,0,0,0,class<`data.frame`>,1
+chk,chk_join,1,0,0,class<`data.frame`>,1
+chk,chk_join,2,0,0,character,1
+chk,chk_join,3,0,0,null,1
+chk,chk_lgl,-1,0,0,any,1
+chk,chk_lgl,0,0,0,double,1
+chk,chk_lgl,0,0,1,null,1
+chk,chk_lgl,1,0,0,null,1
+chk,chk_list,-1,0,0,any,1
+chk,chk_list,0,0,0,double,1
+chk,chk_list,0,0,1,list<any>,1
+chk,chk_list,1,0,0,null,1
+chk,chk_logical,-1,0,0,any,1
+chk,chk_logical,0,0,0,double,1
+chk,chk_logical,1,0,0,null,1
+chk,chk_lt,-1,0,0,any,1
+chk,chk_lt,0,0,0,double[],1
+chk,chk_lt,1,0,0,double,1
+chk,chk_lt,2,0,0,null,1
+chk,chk_lte,-1,0,0,any,1
+chk,chk_lte,0,0,0,double,1
+chk,chk_lte,1,0,0,double,1
+chk,chk_lte,2,0,0,null,1
+chk,chk_match,-1,0,0,any,1
+chk,chk_match,0,0,0,character,1
+chk,chk_match,1,0,0,character,1
+chk,chk_match,2,0,0,null,1
+chk,chk_matrix,-1,0,0,any,1
+chk,chk_matrix,0,0,0,class<`array`>,1
+chk,chk_matrix,0,0,1,class<`matrix`>,1
+chk,chk_matrix,1,0,0,null,1
+chk,chk_named,-1,0,0,any,1
+chk,chk_named,0,0,0,class<`data.frame`>,1
+chk,chk_named,0,0,1,double[],1
+chk,chk_named,0,0,2,list<any>,1
+chk,chk_named,1,0,0,any,1
+chk,chk_not_any_na,-1,0,0,any,1
+chk,chk_not_any_na,0,0,0,null,1
+chk,chk_not_any_na,0,0,1,character[],1
+chk,chk_not_any_na,0,0,2,double,1
+chk,chk_not_any_na,1,0,0,any,1
+chk,chk_not_empty,-1,0,0,any,1
+chk,chk_not_empty,0,0,0,double[],1
+chk,chk_not_empty,1,0,0,null,1
+chk,chk_not_null,-1,0,0,any,1
+chk,chk_not_null,0,0,0,null,1
+chk,chk_not_null,0,0,1,double,1
+chk,chk_not_null,1,0,0,null,1
+chk,chk_null,-1,0,0,any,1
+chk,chk_null,0,0,0,double,1
+chk,chk_null,0,0,1,null,1
+chk,chk_null,1,0,0,null,1
+chk,chk_number,-1,0,0,any,1
+chk,chk_number,0,0,0,double,1
+chk,chk_number,1,0,0,null,1
+chk,chk_numeric,-1,0,0,any,1
+chk,chk_numeric,0,0,0,character,1
+chk,chk_numeric,0,0,1,double,1
+chk,chk_numeric,1,0,0,null,1
+chk,chkor,-1,0,0,any,1
+chk,chkor,0,0,0,...,1
+chk,chk_range,-1,0,0,any,1
+chk,chk_range,0,0,0,double,1
+chk,chk_range,1,0,0,double[],1
+chk,chk_range,2,0,0,null,1
+chk,chk_range,2,0,1,character,1
+chk,chk_s3_class,-1,0,0,any,1
+chk,chk_s3_class,0,0,0,class<`classRepresentation`>,1
+chk,chk_s3_class,0,0,1,double,1
+chk,chk_s3_class,0,0,2,character[],1
+chk,chk_s3_class,0,0,3,null,1
+chk,chk_s3_class,1,0,0,character,1
+chk,chk_s3_class,2,0,0,any,1
+chk,chk_s4_class,-1,0,0,any,1
+chk,chk_s4_class,0,0,0,double,1
+chk,chk_s4_class,0,0,1,class<`classRepresentation`>,1
+chk,chk_s4_class,1,0,0,character,1
+chk,chk_s4_class,2,0,0,null,1
+chk,chk_scalar,-1,0,0,any,1
+chk,chk_scalar,0,0,0,integer[],1
+chk,chk_scalar,0,0,1,double,1
+chk,chk_scalar,0,0,2,list<double>,1
+chk,chk_scalar,1,0,0,null,1
+chk,chk_setequal,-1,0,0,any,1
+chk,chk_setequal,0,0,0,double,1
+chk,chk_setequal,0,0,1,integer[],1
+chk,chk_setequal,1,0,0,integer[],1
+chk,chk_setequal,2,0,0,null,1
+chk,chk_sorted,-1,0,0,any,1
+chk,chk_sorted,0,0,0,integer[],1
+chk,chk_sorted,1,0,0,null,1
+chk,chk_string,-1,0,0,any,1
+chk,chk_string,0,0,0,double,1
+chk,chk_string,0,0,1,character,1
+chk,chk_string,1,0,0,any,1
+chk,chk_subset,-1,0,0,any,1
+chk,chk_subset,0,0,0,double,1
+chk,chk_subset,1,0,0,double[],1
+chk,chk_subset,2,0,0,null,1
+chk,chk_subset,2,0,1,character,1
+chk,chk_superset,-1,0,0,any,1
+chk,chk_superset,0,0,0,integer[],1
+chk,chk_superset,1,0,0,double,1
+chk,chk_superset,2,0,0,null,1
+chk,chk_true,-1,0,0,any,1
+chk,chk_true,0,0,0,double,1
+chk,chk_true,1,0,0,null,1
+chk,chk_tz,-1,0,0,any,1
+chk,chk_tz,0,0,0,character,1
+chk,chk_tz,1,0,0,null,1
+chk,chk_unique,-1,0,0,any,1
+chk,chk_unique,0,0,0,^double[],1
+chk,chk_unique,0,0,1,character[],1
+chk,chk_unique,1,0,0,logical,1
+chk,chk_unique,1,0,1,null,1
+chk,chk_unique,2,0,0,null,1
+chk,chk_unused,-1,0,0,any,1
+chk,chk_unused,0,0,0,...,1
+chk,chk_used,-1,0,0,any,1
+chk,chk_used,0,0,0,...,1
+chk,chk_vector,-1,0,0,any,1
+chk,chk_vector,0,0,0,class<`matrix`>,1
+chk,chk_vector,0,0,1,double[],1
+chk,chk_vector,0,0,2,list<any>,1
+chk,chk_vector,1,0,0,null,1
+chk,chk_whole_number,-1,0,0,any,1
+chk,chk_whole_number,0,0,0,double,1
+chk,chk_whole_number,1,0,0,null,1
+chk,chk_whole_numeric,-1,0,0,any,1
+chk,chk_whole_numeric,0,0,0,double[],1
+chk,chk_whole_numeric,1,0,0,null,1
+chk,deparse_backtick_chk,-1,0,0,character,1
+chk,deparse_backtick_chk,0,0,0,character,1
+chk,deparse_backtick_chk,0,0,1,class<`call`>,1
+chk,deparse_backtick_chk,0,0,2,class<`name`>,1
+chk,deparse_backtick_chk,0,0,3,double,1
+chk,deparse_backtick_chk,0,0,4,null,1
+chk,err,-1,0,0,any,1
+chk,err,0,0,0,...,1
+chk,err,1,0,0,double,1
+chk,err,1,0,1,null,1
+chk,err,2,0,0,logical,1
+chk,err,3,0,0,character,1
+chk,err,3,0,1,null,1
+chk,expect_chk_error,-1,0,0,any,1
+chk,expect_chk_error,0,0,0,any,1
+chk,expect_chk_error,1,0,0,null,1
+chk,expect_chk_error,2,0,0,...,1
+chk,expect_chk_error,3,0,0,null,1
+chk,expect_chk_error,4,0,0,null,1
+chk,expect_chk_error,5,0,0,null,1
+chk,message_chk,-1,0,0,character,1
+chk,message_chk,0,0,0,...,1
+chk,message_chk,1,0,0,double,1
+chk,message_chk,1,0,1,null,1
+chk,message_chk,2,0,0,logical,1
+chk,msg,-1,0,0,null,1
+chk,msg,0,0,0,...,1
+chk,msg,1,0,0,double,1
+chk,msg,2,0,0,logical,1
+chk,msg,3,0,0,null,1
+chk,new_duplicated,-1,0,0,logical[],1
+chk,new_duplicated,0,0,0,class<`data.frame`>,1
+chk,new_duplicated,1,0,0,logical,1
+chk,new_duplicated,2,0,0,logical,1
+chk,new_duplicated,3,0,0,...,1
+chk,p,-1,0,0,character,1
+chk,p,0,0,0,...,1
+chk,p,1,0,0,character,1
+chk,p,2,0,0,character,1
+chk,p,2,0,1,null,1
+chk,p0,-1,0,0,character[],1
+chk,p0,0,0,0,...,1
+chk,p0,1,0,0,null,1
+chk,p0,1,0,1,character,1
+chk,try_chk,-1,0,0,"class<`chk_error`, `condition`, `error`, `rlang_error`>",1
+chk,try_chk,-1,0,1,null,1
+chk,try_chk,0,0,0,"class<`formula`, `quosure`>",1
+chk,try_msg,-1,0,0,character,1
+chk,try_msg,0,0,0,"class<`chk_error`, `condition`, `error`, `rlang_error`>",1
+chk,unbacktick_chk,-1,0,0,character,1
+chk,unbacktick_chk,0,0,0,character,1
+chk,vld_all,-1,0,0,logical,1
+chk,vld_all,0,0,0,^logical[],1
+chk,vld_all,1,0,0,class<`function`>,1
+chk,vld_all,2,0,0,...,1
+chk,vld_all_equal,-1,0,0,logical,1
+chk,vld_all_equal,0,0,0,double[],1
+chk,vld_all_equal,0,0,1,list<double>,1
+chk,vld_all_equal,1,0,0,double,1
+chk,vld_all_equivalent,-1,0,0,logical,1
+chk,vld_all_equivalent,0,0,0,double[],1
+chk,vld_all_equivalent,0,0,1,list<double>,1
+chk,vld_all_equivalent,1,0,0,double,1
+chk,vld_all_identical,-1,0,0,logical,1
+chk,vld_all_identical,0,0,0,double[],1
+chk,vld_array,-1,0,0,logical,1
+chk,vld_array,0,0,0,class<`array`>,1
+chk,vld_array,0,0,1,class<`matrix`>,1
+chk,vld_array,0,0,2,double,1
+chk,vld_atomic,-1,0,0,logical,1
+chk,vld_atomic,0,0,0,character[],1
+chk,vld_atomic,0,0,1,class<`matrix`>,1
+chk,vld_atomic,0,0,2,double[],1
+chk,vld_atomic,0,0,3,list<double>,1
+chk,vld_atomic,0,0,4,null,1
+chk,vld_character,-1,0,0,logical,1
+chk,vld_character,0,0,0,character[],1
+chk,vld_character,0,0,1,class<`factor`>,1
+chk,vld_character,0,0,2,class<`matrix`>,1
+chk,vld_character,0,0,3,double,1
+chk,vld_character,0,0,4,null,1
+chk,vld_data,-1,0,0,logical,1
+chk,vld_data,0,0,0,class<`data.frame`>,1
+chk,vld_data,0,0,1,double,1
+chk,vld_date,-1,0,0,logical,1
+chk,vld_date,0,0,0,class<`Date`>,1
+chk,vld_date,0,0,1,"class<`POSIXct`, `POSIXt`>",1
+chk,vld_date,0,0,2,double,1
+chk,vld_datetime,-1,0,0,logical,1
+chk,vld_datetime,0,0,0,character,1
+chk,vld_datetime,0,0,1,"class<`POSIXct`, `POSIXt`>",1
+chk,vld_datetime,0,0,2,double,1
+chk,vld_datetime,1,0,0,null,1
+chk,vld_dir,-1,0,0,logical,1
+chk,vld_dir,0,0,0,character,1
+chk,vld_dir,0,0,1,double,1
+chk,vld_double,-1,0,0,logical,1
+chk,vld_double,0,0,0,class<`matrix`>,1
+chk,vld_double,0,0,1,double[],1
+chk,vld_double,0,0,2,null,1
+chk,vld_environment,-1,0,0,logical,1
+chk,vld_environment,0,0,0,double,1
+chk,vld_environment,0,0,1,environment,1
+chk,vld_environment,0,0,2,list<double>,1
+chk,vld_equal,-1,0,0,logical,1
+chk,vld_equal,0,0,0,double,1
+chk,vld_equal,1,0,0,double,1
+chk,vld_equal,2,0,0,double,1
+chk,vld_equivalent,-1,0,0,logical,1
+chk,vld_equivalent,0,0,0,double,1
+chk,vld_equivalent,1,0,0,double,1
+chk,vld_equivalent,2,0,0,double,1
+chk,vld_ext,-1,0,0,logical,1
+chk,vld_ext,0,0,0,character,1
+chk,vld_ext,1,0,0,character,1
+chk,vld_false,-1,0,0,logical,1
+chk,vld_false,0,0,0,double[],1
+chk,vld_false,0,0,1,null,1
+chk,vld_file,-1,0,0,logical,1
+chk,vld_file,0,0,0,character,1
+chk,vld_flag,-1,0,0,logical,1
+chk,vld_flag,0,0,0,double[],1
+chk,vld_function,-1,0,0,logical,1
+chk,vld_function,0,0,0,class<`function`>,1
+chk,vld_function,0,0,1,double,1
+chk,vld_function,0,0,2,list<double>,1
+chk,vld_function,1,0,0,any,1
+chk,vld_gt,-1,0,0,logical,1
+chk,vld_gt,0,0,0,character,1
+chk,vld_gt,0,0,1,^double[],1
+chk,vld_gt,1,0,0,character,1
+chk,vld_gt,1,0,1,double,1
+chk,vld_gte,-1,0,0,logical,1
+chk,vld_gte,0,0,0,^double[],1
+chk,vld_gte,1,0,0,double,1
+chk,vld_identical,-1,0,0,logical,1
+chk,vld_identical,0,0,0,double,1
+chk,vld_identical,1,0,0,double,1
+chk,vld_integer,-1,0,0,logical,1
+chk,vld_integer,0,0,0,class<`matrix`>,1
+chk,vld_integer,0,0,1,double,1
+chk,vld_integer,0,0,2,integer[],1
+chk,vld_integer,0,0,3,null,1
+chk,vld_join,-1,0,0,logical,1
+chk,vld_join,0,0,0,class<`data.frame`>,1
+chk,vld_join,1,0,0,class<`data.frame`>,1
+chk,vld_join,2,0,0,character,1
+chk,vld_lgl,-1,0,0,logical,1
+chk,vld_lgl,0,0,0,null,1
+chk,vld_lgl,0,0,1,double,1
+chk,vld_lgl,0,0,2,logical[],1
+chk,vld_list,-1,0,0,logical,1
+chk,vld_list,0,0,0,class<`data.frame`>,1
+chk,vld_list,0,0,1,double,1
+chk,vld_list,0,0,2,list<any>,1
+chk,vld_list,0,0,3,null,1
+chk,vld_logical,-1,0,0,logical,1
+chk,vld_logical,0,0,0,character,1
+chk,vld_logical,0,0,1,class<`matrix`>,1
+chk,vld_logical,0,0,2,double,1
+chk,vld_logical,0,0,3,logical[],1
+chk,vld_logical,0,0,4,null,1
+chk,vld_lt,-1,0,0,logical,1
+chk,vld_lt,0,0,0,character,1
+chk,vld_lt,0,0,1,^double[],1
+chk,vld_lt,1,0,0,character,1
+chk,vld_lt,1,0,1,double,1
+chk,vld_lte,-1,0,0,logical,1
+chk,vld_lte,0,0,0,^double[],1
+chk,vld_lte,1,0,0,double,1
+chk,vld_match,-1,0,0,logical,1
+chk,vld_match,0,0,0,character,1
+chk,vld_match,0,0,1,null,1
+chk,vld_match,1,0,0,character,1
+chk,vld_matrix,-1,0,0,logical,1
+chk,vld_matrix,0,0,0,class<`array`>,1
+chk,vld_matrix,0,0,1,class<`matrix`>,1
+chk,vld_matrix,0,0,2,double,1
+chk,vld_named,-1,0,0,logical,1
+chk,vld_named,0,0,0,class<`data.frame`>,1
+chk,vld_named,0,0,1,double[],1
+chk,vld_named,0,0,2,list<any>,1
+chk,vld_not_any_na,-1,0,0,logical,1
+chk,vld_not_any_na,0,0,0,character[],1
+chk,vld_not_any_na,0,0,1,^double[],1
+chk,vld_not_any_na,0,0,2,null,1
+chk,vld_not_empty,-1,0,0,logical,1
+chk,vld_not_empty,0,0,0,character[],1
+chk,vld_not_empty,0,0,1,class<`matrix`>,1
+chk,vld_not_empty,0,0,2,double[],1
+chk,vld_not_empty,0,0,3,list<any>,1
+chk,vld_not_empty,0,0,4,null,1
+chk,vld_not_null,-1,0,0,logical,1
+chk,vld_not_null,0,0,0,double,1
+chk,vld_not_null,0,0,1,null,1
+chk,vld_null,-1,0,0,logical,1
+chk,vld_null,0,0,0,double,1
+chk,vld_null,0,0,1,null,1
+chk,vld_number,-1,0,0,logical,1
+chk,vld_number,0,0,0,double,1
+chk,vld_numeric,-1,0,0,logical,1
+chk,vld_numeric,0,0,0,character,1
+chk,vld_numeric,0,0,1,double,1
+chk,vld_numeric,0,0,2,integer[],1
+chk,vld_numeric,0,0,3,null,1
+chk,vld_range,-1,0,0,logical,1
+chk,vld_range,0,0,0,^double[],1
+chk,vld_range,1,0,0,double[],1
+chk,vld_s3_class,-1,0,0,logical,1
+chk,vld_s3_class,0,0,0,character[],1
+chk,vld_s3_class,0,0,1,class<`classRepresentation`>,1
+chk,vld_s3_class,0,0,2,double[],1
+chk,vld_s3_class,0,0,3,null,1
+chk,vld_s3_class,1,0,0,any,1
+chk,vld_s4_class,-1,0,0,logical,1
+chk,vld_s4_class,0,0,0,class<`classRepresentation`>,1
+chk,vld_s4_class,0,0,1,double[],1
+chk,vld_s4_class,1,0,0,any,1
+chk,vld_scalar,-1,0,0,logical,1
+chk,vld_scalar,0,0,0,double,1
+chk,vld_scalar,0,0,1,integer[],1
+chk,vld_scalar,0,0,2,list<double>,1
+chk,vld_setequal,-1,0,0,logical,1
+chk,vld_setequal,0,0,0,double,1
+chk,vld_setequal,0,0,1,integer[],1
+chk,vld_setequal,1,0,0,double,1
+chk,vld_setequal,1,0,1,integer[],1
+chk,vld_sorted,-1,0,0,logical,1
+chk,vld_sorted,0,0,0,integer[],1
+chk,vld_string,-1,0,0,logical,1
+chk,vld_string,0,0,0,character[],1
+chk,vld_string,0,0,1,double,1
+chk,vld_string,0,0,2,null,1
+chk,vld_string,1,0,0,null,1
+chk,vld_subset,-1,0,0,logical,1
+chk,vld_subset,0,0,0,character,1
+chk,vld_subset,0,0,1,double[],1
+chk,vld_subset,1,0,0,character,1
+chk,vld_subset,1,0,1,double[],1
+chk,vld_superset,-1,0,0,logical,1
+chk,vld_superset,0,0,0,integer[],1
+chk,vld_superset,1,0,0,double,1
+chk,vld_superset,1,0,1,integer[],1
+chk,vld_true,-1,0,0,logical,1
+chk,vld_true,0,0,0,character,1
+chk,vld_true,0,0,1,double[],1
+chk,vld_true,0,0,2,null,1
+chk,vld_tz,-1,0,0,logical,1
+chk,vld_tz,0,0,0,character,1
+chk,vld_unique,-1,0,0,logical,1
+chk,vld_unique,0,0,0,character[],1
+chk,vld_unique,0,0,1,^double[],1
+chk,vld_unique,0,0,2,null,1
+chk,vld_unique,1,0,0,logical,1
+chk,vld_unique,1,0,1,null,1
+chk,vld_unused,-1,0,0,logical,1
+chk,vld_unused,0,0,0,...,1
+chk,vld_used,-1,0,0,logical,1
+chk,vld_used,0,0,0,...,1
+chk,vld_vector,-1,0,0,logical,1
+chk,vld_vector,0,0,0,class<`matrix`>,1
+chk,vld_vector,0,0,1,double[],1
+chk,vld_vector,0,0,2,list<any>,1
+chk,vld_whole_number,-1,0,0,logical,1
+chk,vld_whole_number,0,0,0,double,1
+chk,vld_whole_numeric,-1,0,0,logical,1
+chk,vld_whole_numeric,0,0,0,double[],1
+chk,vld_whole_numeric,0,0,1,null,1
+chk,wrn,-1,0,0,character,1
+chk,wrn,0,0,0,...,1
+chk,wrn,1,0,0,double,1
+chk,wrn,2,0,0,logical,1
+chk,wrn,3,0,0,null,1
+circular,A1,-1,0,0,double,1
+circular,A1,0,0,0,double,1
+circular,A1inv,-1,0,0,double,1
+circular,A1inv,0,0,0,"class<`circular`, `numeric`>",1
+circular,A1inv,0,0,1,double,1
+circular,allcrosses,-1,0,0,class<`matrix`>,1
+circular,allcrosses,0,0,0,double,1
+circular,allcrosses,1,0,0,class<`density.circular`>,1
+circular,allcrosses,2,0,0,"class<`circular`, `numeric`>",1
+circular,allcrosses,3,0,0,double,1
+circular,allcrosses,4,0,0,...,1
+circular,angular.deviation,-1,0,0,double,1
+circular,angular.deviation,0,0,0,"class<`circular`, `numeric`>",1
+circular,angular.deviation,1,0,0,logical,1
+circular,AngularDeviationRad,-1,0,0,double,1
+circular,AngularDeviationRad,0,0,0,double[],1
+circular,angular.variance,-1,0,0,double,1
+circular,angular.variance,0,0,0,"class<`circular`, `numeric`>",1
+circular,angular.variance,1,0,0,logical,1
+circular,AngularVarianceRad,-1,0,0,double,1
+circular,AngularVarianceRad,0,0,0,double[],1
+circular,aov.circular,-1,0,0,class<`aov.circular`>,1
+circular,aov.circular,0,0,0,"class<`circular`, `numeric`>",1
+circular,aov.circular,1,0,0,double[],1
+circular,aov.circular,2,0,0,null,1
+circular,aov.circular,3,0,0,character[],1
+circular,aov.circular,4,0,0,logical,1
+circular,aov.circular,5,0,0,list<any>,1
+circular,AovCircularRad,-1,0,0,list<any>,1
+circular,AovCircularRad,0,0,0,double[],1
+circular,AovCircularRad,1,0,0,double[],1
+circular,AovCircularRad,2,0,0,null,1
+circular,AovCircularRad,3,0,0,character,1
+circular,AovCircularRad,4,0,0,any,1
+circular,area,-1,0,0,list<double[]>,1
+circular,area,0,0,0,class<`matrix`>,1
+circular,area,1,0,0,class<`density.circular`>,1
+circular,area,2,0,0,...,1
+circular,area2,-1,0,0,list<double[]>,1
+circular,area2,0,0,0,class<`matrix`>,1
+circular,area2,1,0,0,class<`density.circular`>,1
+circular,area2,2,0,0,double[],1
+circular,area2,3,0,0,...,1
+circular,areas.region.circular,-1,0,0,class<`areas.region.circular`>,1
+circular,areas.region.circular,0,0,0,"class<`circular`, `numeric`>",1
+circular,areas.region.circular,1,0,0,class<`matrix`>,1
+circular,areas.region.circular,2,0,0,null,1
+circular,areas.region.circular,3,0,0,double,1
+circular,areas.region.circular,4,0,0,double,1
+circular,areas.region.circular,5,0,0,any,1
+circular,areas.region.circular,6,0,0,character[],1
+circular,areas.region.circular,7,0,0,any,1
+circular,areas.region.circular,8,0,0,double,1
+circular,areas.region.circular,9,0,0,...,1
+circular,arrows.circular,-1,0,0,null,1
+circular,arrows.circular,0,0,0,"class<`circular`, `numeric`>",1
+circular,arrows.circular,1,0,0,double[],1
+circular,arrows.circular,1,0,1,null,1
+circular,arrows.circular,2,0,0,double[],1
+circular,arrows.circular,3,0,0,double[],1
+circular,arrows.circular,4,0,0,logical,1
+circular,arrows.circular,5,0,0,double,1
+circular,arrows.circular,6,0,0,null,1
+circular,arrows.circular,7,0,0,null,1
+circular,arrows.circular,8,0,0,null,1
+circular,arrows.circular,9,0,0,...,1
+circular,as.circular,-1,0,0,"class<`array`, `circular`>",1
+circular,as.circular,-1,0,1,"class<`circular`, `integer`>",1
+circular,as.circular,-1,0,2,"class<`circular`, `matrix`>",1
+circular,as.circular,-1,0,3,"class<`circular`, `numeric`>",1
+circular,as.circular,0,0,0,"class<`array`, `circular`>",1
+circular,as.circular,0,0,1,"class<`circular`, `integer`>",1
+circular,as.circular,0,0,2,"class<`circular`, `matrix`>",1
+circular,as.circular,0,0,3,class<`matrix`>,1
+circular,as.circular,0,0,4,"class<`circular`, `numeric`>",1
+circular,as.circular,0,0,5,double[],1
+circular,as.circular,1,0,0,any,1
+circular,as.circular,2,0,0,...,1
+circular,as.data.frame.circular,-1,0,0,class<`data.frame`>,1
+circular,as.data.frame.circular,0,0,0,"class<`circular`, `integer`>",1
+circular,as.data.frame.circular,0,0,1,"class<`circular`, `matrix`>",1
+circular,as.data.frame.circular,0,0,2,"class<`circular`, `numeric`>",1
+circular,as.data.frame.circular,1,0,0,null,1
+circular,as.data.frame.circular,2,0,0,logical,1
+circular,as.data.frame.circular,3,0,0,...,1
+circular,axis.circular,-1,0,0,null,1
+circular,axis.circular,0,0,0,"class<`circular`, `numeric`>",1
+circular,axis.circular,0,0,1,null,1
+circular,axis.circular,1,0,0,expression,1
+circular,axis.circular,1,0,1,null,1
+circular,axis.circular,2,0,0,any,1
+circular,axis.circular,3,0,0,null,1
+circular,axis.circular,3,0,1,character,1
+circular,axis.circular,4,0,0,null,1
+circular,axis.circular,4,0,1,character,1
+circular,axis.circular,5,0,0,null,1
+circular,axis.circular,5,0,1,double,1
+circular,axis.circular,6,0,0,null,1
+circular,axis.circular,6,0,1,character,1
+circular,axis.circular,7,0,0,logical,1
+circular,axis.circular,8,0,0,any,1
+circular,axis.circular,9,0,0,any,1
+circular,axis.circular,10,0,0,any,1
+circular,axis.circular,11,0,0,any,1
+circular,axis.circular,12,0,0,any,1
+circular,axis.circular,13,0,0,double,1
+circular,axis.circular,14,0,0,double,1
+circular,axis.circular,15,0,0,double,1
+circular,AxisCircularRad,-1,0,0,null,1
+circular,AxisCircularRad,0,0,0,double[],1
+circular,AxisCircularRad,1,0,0,any,1
+circular,AxisCircularRad,2,0,0,character[],1
+circular,AxisCircularRad,2,0,1,expression,1
+circular,AxisCircularRad,3,0,0,any,1
+circular,AxisCircularRad,4,0,0,logical,1
+circular,AxisCircularRad,5,0,0,double,1
+circular,AxisCircularRad,6,0,0,double,1
+circular,AxisCircularRad,7,0,0,double,1
+circular,AxisCircularRad,8,0,0,character,1
+circular,AxisCircularRad,9,0,0,any,1
+circular,AxisCircularRad,10,0,0,any,1
+circular,bw.cv.ml.circular,-1,0,0,double,1
+circular,bw.cv.ml.circular,0,0,0,"class<`circular`, `numeric`>",1
+circular,bw.cv.ml.circular,1,0,0,double,1
+circular,bw.cv.ml.circular,1,0,1,null,1
+circular,bw.cv.ml.circular,2,0,0,double,1
+circular,bw.cv.ml.circular,2,0,1,null,1
+circular,bw.cv.ml.circular,3,0,0,double,1
+circular,bw.cv.ml.circular,4,0,0,character[],1
+circular,bw.cv.ml.circular,5,0,0,null,1
+circular,bw.cv.ml.circular,6,0,0,double,1
+circular,bw.cv.mse.circular,-1,0,0,double,1
+circular,bw.cv.mse.circular,0,0,0,"class<`circular`, `numeric`>",1
+circular,bw.cv.mse.circular,1,0,0,double,1
+circular,bw.cv.mse.circular,1,0,1,null,1
+circular,bw.cv.mse.circular,2,0,0,double,1
+circular,bw.cv.mse.circular,2,0,1,null,1
+circular,bw.cv.mse.circular,3,0,0,double,1
+circular,bw.cv.mse.circular,4,0,0,character[],1
+circular,bw.cv.mse.circular,5,0,0,null,1
+circular,bw.cv.mse.circular,6,0,0,double,1
+circular,bw.nrd.circular,-1,0,0,double,1
+circular,bw.nrd.circular,0,0,0,"class<`circular`, `numeric`>",1
+circular,bw.nrd.circular,1,0,0,null,1
+circular,bw.nrd.circular,2,0,0,null,1
+circular,bw.nrd.circular,3,0,0,character[],1
+circular,bw.nrd.circular,4,0,0,logical,1
+circular,bw.nrd.circular,5,0,0,double,1
+circular,c.circular,-1,0,0,"class<`circular`, `numeric`>",1
+circular,c.circular,0,0,0,...,1
+circular,c.circular,1,0,0,logical,1
+circular,circle.control,-1,0,0,list<double | character>,1
+circular,circle.control,0,0,0,double,1
+circular,circle.control,1,0,0,character,1
+circular,circle.control,2,0,0,double,1
+circular,circle.control,3,0,0,character,1
+circular,circle.control,4,0,0,double,1
+circular,circle.control,5,0,0,double,1
+circular,circle.control,6,0,0,double,1
+circular,circle.control,7,0,0,double,1
+circular,CirclePlotRad,-1,0,0,null,1
+circular,CirclePlotRad,0,0,0,double[],1
+circular,CirclePlotRad,1,0,0,double[],1
+circular,CirclePlotRad,2,0,0,null,1
+circular,CirclePlotRad,3,0,0,double,1
+circular,CirclePlotRad,4,0,0,double,1
+circular,CirclePlotRad,5,0,0,character,1
+circular,CirclePlotRad,5,0,1,expression,1
+circular,CirclePlotRad,5,0,2,null,1
+circular,CirclePlotRad,6,0,0,null,1
+circular,CirclePlotRad,7,0,0,character,1
+circular,CirclePlotRad,7,0,1,expression,1
+circular,CirclePlotRad,8,0,0,character,1
+circular,CirclePlotRad,9,0,0,list<double | character>,1
+circular,circular,-1,0,0,"class<`array`, `circular`>",1
+circular,circular,-1,0,1,"class<`circular`, `integer`>",1
+circular,circular,-1,0,2,"class<`circular`, `matrix`>",1
+circular,circular,-1,0,3,"class<`circular`, `numeric`>",1
+circular,circular,0,0,0,class<`array`>,1
+circular,circular,0,0,1,class<`matrix`>,1
+circular,circular,0,0,2,class<`data.frame`>,1
+circular,circular,0,0,3,"class<`circular`, `numeric`>",1
+circular,circular,0,0,4,double[],1
+circular,circular,0,0,5,null,1
+circular,circular,1,0,0,character[],1
+circular,circular,2,0,0,character[],1
+circular,circular,3,0,0,character[],1
+circular,circular,4,0,0,character[],1
+circular,circular,5,0,0,any,1
+circular,circular,6,0,0,character[],1
+circular,circular,7,0,0,null,1
+circular,[.circular,-1,0,0,"class<`circular`, `matrix`>",1
+circular,[.circular,-1,0,1,"class<`circular`, `numeric`>",1
+circular,[.circular,0,0,0,"class<`circular`, `matrix`>",1
+circular,[.circular,0,0,1,"class<`circular`, `numeric`>",1
+circular,[.circular,1,0,0,any,1
+circular,[.circular,2,0,0,...,1
+circular,circular.colors,-1,0,0,character[],1
+circular,circular.colors,0,0,0,double,1
+circular,circular.colors,1,0,0,double,1
+circular,circular.colors,2,0,0,double,1
+circular,circular.colors,3,0,0,double,1
+circular,circular.colors,4,0,0,...,1
+circular,circularp,-1,0,0,null,1
+circular,circularp,-1,0,1,list<character | double>,1
+circular,circularp,0,0,0,class<`matrix`>,1
+circular,circularp,0,0,1,double[],1
+circular,circularp,0,0,2,"class<`circular`, `matrix`>",1
+circular,circularp,0,0,3,"class<`circular`, `numeric`>",1
+circular,circularp<-,-1,0,0,"class<`array`, `circular`>",1
+circular,circularp<-,-1,0,1,"class<`circular`, `integer`>",1
+circular,circularp<-,-1,0,2,"class<`circular`, `matrix`>",1
+circular,circularp<-,-1,0,3,"class<`circular`, `numeric`>",1
+circular,circularp<-,-1,0,4,double[],1
+circular,circularp<-,0,0,0,"class<`array`, `circular`>",1
+circular,circularp<-,0,0,1,"class<`circular`, `integer`>",1
+circular,circularp<-,0,0,2,"class<`circular`, `matrix`>",1
+circular,circularp<-,0,0,3,"class<`circular`, `numeric`>",1
+circular,circularp<-,0,0,4,double[],1
+circular,circularp<-,1,0,0,list<character | double>,1
+circular,conversion.circular,-1,0,0,"class<`array`, `circular`>",1
+circular,conversion.circular,-1,0,1,"class<`circular`, `integer`>",1
+circular,conversion.circular,-1,0,2,"class<`circular`, `matrix`>",1
+circular,conversion.circular,-1,0,3,"class<`circular`, `numeric`>",1
+circular,conversion.circular,0,0,0,"class<`array`, `circular`>",1
+circular,conversion.circular,0,0,1,"class<`circular`, `integer`>",1
+circular,conversion.circular,0,0,2,"class<`circular`, `matrix`>",1
+circular,conversion.circular,0,0,3,class<`matrix`>,1
+circular,conversion.circular,0,0,4,"class<`circular`, `numeric`>",1
+circular,conversion.circular,0,0,5,double[],1
+circular,conversion.circular,1,0,0,character[],1
+circular,conversion.circular,2,0,0,character,1
+circular,conversion.circular,2,0,1,null,1
+circular,conversion.circular,3,0,0,character,1
+circular,conversion.circular,3,0,1,null,1
+circular,conversion.circular,4,0,0,character,1
+circular,conversion.circular,4,0,1,null,1
+circular,conversion.circular,5,0,0,double,1
+circular,conversion.circular,5,0,1,null,1
+circular,conversion.circular,6,0,0,character,1
+circular,conversion.circular,6,0,1,null,1
+circular,coord2rad,-1,0,0,"class<`circular`, `numeric`>",1
+circular,coord2rad,0,0,0,class<`matrix`>,1
+circular,coord2rad,1,0,0,null,1
+circular,coord2rad,2,0,0,list<any>,1
+circular,cor.circular,-1,0,0,list<double>,1
+circular,cor.circular,0,0,0,"class<`circular`, `numeric`>",1
+circular,cor.circular,1,0,0,"class<`circular`, `numeric`>",1
+circular,cor.circular,2,0,0,logical,1
+circular,CorCircularRad,-1,0,0,double[],1
+circular,CorCircularRad,0,0,0,double[],1
+circular,CorCircularRad,1,0,0,double[],1
+circular,CorCircularRad,2,0,0,logical,1
+circular,cross,-1,0,0,double,1
+circular,cross,0,0,0,double,1
+circular,cross,1,0,0,class<`density.circular`>,1
+circular,cross,2,0,0,double,1
+circular,cross,3,0,0,double,1
+circular,cross,4,0,0,...,1
+circular,curve.circular,-1,0,0,list<double[] | character>,1
+circular,curve.circular,0,0,0,any,1
+circular,curve.circular,1,0,0,double,1
+circular,curve.circular,1,0,1,null,1
+circular,curve.circular,2,0,0,double,1
+circular,curve.circular,2,0,1,null,1
+circular,curve.circular,3,0,0,double,1
+circular,curve.circular,4,0,0,logical,1
+circular,curve.circular,5,0,0,double,1
+circular,curve.circular,6,0,0,logical,1
+circular,curve.circular,7,0,0,logical,1
+circular,curve.circular,8,0,0,double,1
+circular,curve.circular,9,0,0,double,1
+circular,curve.circular,10,0,0,double,1
+circular,curve.circular,11,0,0,double,1
+circular,curve.circular,12,0,0,null,1
+circular,curve.circular,13,0,0,any,1
+circular,curve.circular,14,0,0,any,1
+circular,curve.circular,15,0,0,double,1
+circular,dasytriangular,-1,0,0,double[],1
+circular,dasytriangular,0,0,0,"class<`circular`, `numeric`>",1
+circular,dasytriangular,1,0,0,double,1
+circular,DasytriangularRad,-1,0,0,double[],1
+circular,DasytriangularRad,0,0,0,double[],1
+circular,DasytriangularRad,1,0,0,double,1
+circular,dcircularuniform,-1,0,0,double[],1
+circular,dcircularuniform,0,0,0,"class<`circular`, `numeric`>",1
+circular,density.circular,-1,0,0,class<`density.circular`>,1
+circular,density.circular,0,0,0,"class<`circular`, `numeric`>",1
+circular,density.circular,1,0,0,"class<`circular`, `numeric`>",1
+circular,density.circular,1,0,1,null,1
+circular,density.circular,2,0,0,double,1
+circular,density.circular,3,0,0,double,1
+circular,density.circular,4,0,0,any,1
+circular,density.circular,5,0,0,character[],1
+circular,density.circular,6,0,0,any,1
+circular,density.circular,7,0,0,"class<`circular`, `numeric`>",1
+circular,density.circular,8,0,0,"class<`circular`, `numeric`>",1
+circular,density.circular,9,0,0,double,1
+circular,density.circular,10,0,0,null,1
+circular,density.circular,11,0,0,double,1
+circular,density.circular,12,0,0,list<any>,1
+circular,density.circular,13,0,0,...,1
+circular,DensityCircularRad,-1,0,0,double[],1
+circular,DensityCircularRad,0,0,0,double[],1
+circular,DensityCircularRad,1,0,0,double[],1
+circular,DensityCircularRad,2,0,0,double,1
+circular,DensityCircularRad,3,0,0,character,1
+circular,DensityCircularRad,4,0,0,any,1
+circular,DensityCircularRad,5,0,0,any,1
+circular,dgenvonmises,-1,0,0,double[],1
+circular,dgenvonmises,0,0,0,"class<`circular`, `numeric`>",1
+circular,dgenvonmises,1,0,0,"class<`circular`, `numeric`>",1
+circular,dgenvonmises,2,0,0,"class<`circular`, `numeric`>",1
+circular,dgenvonmises,3,0,0,double,1
+circular,dgenvonmises,4,0,0,double,1
+circular,DgenvonmisesRad,-1,0,0,double[],1
+circular,DgenvonmisesRad,0,0,0,double[],1
+circular,DgenvonmisesRad,1,0,0,double,1
+circular,DgenvonmisesRad,2,0,0,double,1
+circular,DgenvonmisesRad,3,0,0,double,1
+circular,DgenvonmisesRad,4,0,0,double,1
+circular,djonespewsey,-1,0,0,double[],1
+circular,djonespewsey,0,0,0,"class<`circular`, `numeric`>",1
+circular,djonespewsey,1,0,0,"class<`circular`, `numeric`>",1
+circular,djonespewsey,2,0,0,double,1
+circular,djonespewsey,3,0,0,double,1
+circular,DjonespewseyRad,-1,0,0,double[],1
+circular,DjonespewseyRad,0,0,0,double[],1
+circular,DjonespewseyRad,1,0,0,double,1
+circular,DjonespewseyRad,2,0,0,double,1
+circular,DjonespewseyRad,3,0,0,double,1
+circular,dkatojones,-1,0,0,double[],1
+circular,dkatojones,0,0,0,"class<`circular`, `numeric`>",1
+circular,dkatojones,1,0,0,"class<`circular`, `numeric`>",1
+circular,dkatojones,2,0,0,"class<`circular`, `numeric`>",1
+circular,dkatojones,3,0,0,double,1
+circular,dkatojones,4,0,0,double,1
+circular,DkatojonesRad,-1,0,0,double[],1
+circular,DkatojonesRad,0,0,0,double[],1
+circular,DkatojonesRad,1,0,0,double,1
+circular,DkatojonesRad,2,0,0,double,1
+circular,DkatojonesRad,3,0,0,double,1
+circular,DkatojonesRad,4,0,0,double,1
+circular,dmixedvonmises,-1,0,0,double[],1
+circular,dmixedvonmises,0,0,0,"class<`circular`, `numeric`>",1
+circular,dmixedvonmises,1,0,0,"class<`circular`, `numeric`>",1
+circular,dmixedvonmises,2,0,0,"class<`circular`, `numeric`>",1
+circular,dmixedvonmises,3,0,0,double,1
+circular,dmixedvonmises,4,0,0,double,1
+circular,dmixedvonmises,5,0,0,double,1
+circular,DmixedvonmisesRad,-1,0,0,double[],1
+circular,DmixedvonmisesRad,0,0,0,double[],1
+circular,DmixedvonmisesRad,1,0,0,double,1
+circular,DmixedvonmisesRad,2,0,0,double,1
+circular,DmixedvonmisesRad,3,0,0,double,1
+circular,DmixedvonmisesRad,4,0,0,double,1
+circular,DmixedvonmisesRad,5,0,0,double,1
+circular,dpnorm,-1,0,0,double[],1
+circular,dpnorm,0,0,0,"class<`circular`, `numeric`>",1
+circular,dpnorm,1,0,0,double[],1
+circular,dpnorm,2,0,0,class<`matrix`>,1
+circular,dpnorm,3,0,0,logical,1
+circular,DpnormRad,-1,0,0,double[],1
+circular,DpnormRad,0,0,0,double[],1
+circular,DpnormRad,1,0,0,double[],1
+circular,DpnormRad,2,0,0,class<`matrix`>,1
+circular,DpnormRad,3,0,0,logical,1
+circular,dtriangular,-1,0,0,double[],1
+circular,dtriangular,0,0,0,"class<`circular`, `numeric`>",1
+circular,dtriangular,1,0,0,double,1
+circular,DtriangularRad,-1,0,0,double[],1
+circular,DtriangularRad,0,0,0,double[],1
+circular,DtriangularRad,1,0,0,double,1
+circular,dvonmises,-1,0,0,double[],1
+circular,dvonmises,0,0,0,"class<`circular`, `numeric`>",1
+circular,dvonmises,1,0,0,"class<`circular`, `numeric`>",1
+circular,dvonmises,2,0,0,double,1
+circular,dvonmises,3,0,0,logical,1
+circular,DvonmisesRad,-1,0,0,double[],1
+circular,DvonmisesRad,0,0,0,double[],1
+circular,DvonmisesRad,1,0,0,double[],1
+circular,DvonmisesRad,2,0,0,double,1
+circular,DvonmisesRad,3,0,0,logical,1
+circular,dwrappedcauchy,-1,0,0,double[],1
+circular,dwrappedcauchy,0,0,0,"class<`circular`, `numeric`>",1
+circular,dwrappedcauchy,1,0,0,"class<`circular`, `numeric`>",1
+circular,dwrappedcauchy,2,0,0,double,1
+circular,DwrappedcauchyRad,-1,0,0,double[],1
+circular,DwrappedcauchyRad,0,0,0,double[],1
+circular,DwrappedcauchyRad,1,0,0,double,1
+circular,DwrappedcauchyRad,2,0,0,double,1
+circular,dwrappednormal,-1,0,0,double[],1
+circular,dwrappednormal,0,0,0,"class<`circular`, `numeric`>",1
+circular,dwrappednormal,1,0,0,"class<`circular`, `numeric`>",1
+circular,dwrappednormal,2,0,0,double,1
+circular,dwrappednormal,3,0,0,double,1
+circular,dwrappednormal,4,0,0,null,1
+circular,dwrappednormal,5,0,0,double,1
+circular,DwrappednormalRad,-1,0,0,double[],1
+circular,DwrappednormalRad,0,0,0,double[],1
+circular,DwrappednormalRad,1,0,0,double,1
+circular,DwrappednormalRad,2,0,0,double,1
+circular,DwrappednormalRad,3,0,0,null,1
+circular,DwrappednormalRad,4,0,0,double,1
+circular,equal.kappa.test,-1,0,0,class<`equal.kappa.test`>,1
+circular,equal.kappa.test,0,0,0,"class<`circular`, `numeric`>",1
+circular,equal.kappa.test,1,0,0,double[],1
+circular,EqualKappaTestRad,-1,0,0,list<class<`array`> | double>,1
+circular,EqualKappaTestRad,0,0,0,double[],1
+circular,EqualKappaTestRad,1,0,0,class<`factor`>,1
+circular,EqualKappaTestRad,1,0,1,double[],1
+circular,EqualKappaTestRad,1,0,2,character[],1
+circular,IntersectIntervalRad,-1,0,0,class<`matrix`>,1
+circular,IntersectIntervalRad,-1,0,1,double[],1
+circular,IntersectIntervalRad,0,0,0,"class<`circular`, `matrix`>",1
+circular,IntersectIntervalRad,1,0,0,double[],1
+circular,intersect.modal.region,-1,0,0,list<double | list<class<`areas.region.circular`> | class<`matrix`>>>,1
+circular,intersect.modal.region,-1,0,1,list<double | list<null | class<`matrix`>>>,1
+circular,intersect.modal.region,0,0,0,"class<`circular`, `numeric`>",1
+circular,intersect.modal.region,1,0,0,...,1
+circular,intersect.modal.region.circular,-1,0,0,list<double | list<class<`areas.region.circular`> | class<`matrix`>>>,1
+circular,intersect.modal.region.circular,-1,0,1,list<double | list<null | class<`matrix`>>>,1
+circular,intersect.modal.region.circular,0,0,0,"class<`circular`, `numeric`>",1
+circular,intersect.modal.region.circular,1,0,0,"class<`circular`, `matrix`>",1
+circular,intersect.modal.region.circular,2,0,0,null,1
+circular,intersect.modal.region.circular,3,0,0,double,1
+circular,intersect.modal.region.circular,4,0,0,double,1
+circular,intersect.modal.region.circular,5,0,0,double,1
+circular,intersect.modal.region.circular,6,0,0,any,1
+circular,intersect.modal.region.circular,7,0,0,character[],1
+circular,intersect.modal.region.circular,8,0,0,logical,1
+circular,intersect.modal.region.circular,9,0,0,double,1
+circular,intersect.modal.region.circular,10,0,0,double,1
+circular,intersect.modal.region.circular,11,0,0,double,1
+circular,intersect.modal.region.circular,12,0,0,...,1
+circular,is.circular,-1,0,0,logical,1
+circular,is.circular,0,0,0,"class<`array`, `circular`>",1
+circular,is.circular,0,0,1,"class<`circular`, `integer`>",1
+circular,is.circular,0,0,2,"class<`circular`, `matrix`>",1
+circular,is.circular,0,0,3,"class<`circular`, `numeric`>",1
+circular,is.circular,0,0,4,class<`matrix`>,1
+circular,is.circular,0,0,5,double[],1
+circular,kuiper.test,-1,0,0,class<`kuiper.test`>,1
+circular,kuiper.test,0,0,0,"class<`circular`, `numeric`>",1
+circular,kuiper.test,1,0,0,double,1
+circular,KuiperTestRad,-1,0,0,double,1
+circular,KuiperTestRad,0,0,0,double[],1
+circular,KuiperTestRad,1,0,0,double,1
+circular,lines.circular,-1,0,0,list<double[] | character>,1
+circular,lines.circular,0,0,0,"class<`circular`, `numeric`>",1
+circular,lines.circular,1,0,0,double[],1
+circular,lines.circular,2,0,0,logical,1
+circular,lines.circular,3,0,0,logical,1
+circular,lines.circular,4,0,0,double,1
+circular,lines.circular,5,0,0,double,1
+circular,lines.circular,6,0,0,null,1
+circular,lines.circular,7,0,0,null,1
+circular,lines.circular,8,0,0,null,1
+circular,lines.circular,9,0,0,null,1
+circular,lines.circular,10,0,0,...,1
+circular,LinesCircularRad,-1,0,0,list<double[]>,1
+circular,LinesCircularRad,0,0,0,double[],1
+circular,LinesCircularRad,1,0,0,double[],1
+circular,LinesCircularRad,2,0,0,logical,1
+circular,LinesCircularRad,3,0,0,logical,1
+circular,LinesCircularRad,4,0,0,double,1
+circular,LinesCircularRad,5,0,0,double,1
+circular,LinesCircularRad,6,0,0,...,1
+circular,lines.density.circular,-1,0,0,list<double[] | character>,1
+circular,lines.density.circular,-1,0,1,list<null | double | character>,1
+circular,lines.density.circular,0,0,0,class<`density.circular`>,1
+circular,lines.density.circular,1,0,0,character,1
+circular,lines.density.circular,2,0,0,logical,1
+circular,lines.density.circular,3,0,0,logical,1
+circular,lines.density.circular,4,0,0,double,1
+circular,lines.density.circular,5,0,0,double,1
+circular,lines.density.circular,6,0,0,double,1
+circular,lines.density.circular,7,0,0,character[],1
+circular,lines.density.circular,8,0,0,null,1
+circular,lines.density.circular,9,0,0,double,1
+circular,lines.density.circular,10,0,0,double,1
+circular,lines.density.circular,11,0,0,double,1
+circular,lines.density.circular,12,0,0,double,1
+circular,lines.density.circular,13,0,0,logical,1
+circular,lines.density.circular,14,0,0,logical,1
+circular,lines.density.circular,15,0,0,null,1
+circular,lines.density.circular,15,0,1,list<double[] | character>,1
+circular,lines.edf,-1,0,0,null,1
+circular,lines.edf,0,0,0,"class<`circular`, `numeric`>",1
+circular,lines.edf,1,0,0,character,1
+circular,lines.edf,2,0,0,...,1
+circular,lm.circular,-1,0,0,class<`lm.circular.cc`>,1
+circular,lm.circular,-1,0,1,class<`lm.circular.cl`>,1
+circular,lm.circular,0,0,0,...,1
+circular,lm.circular,1,0,0,character[],1
+circular,lm.circular.cc,-1,0,0,class<`lm.circular.cc`>,1
+circular,lm.circular.cc,0,0,0,"class<`circular`, `numeric`>",1
+circular,lm.circular.cc,1,0,0,"class<`circular`, `numeric`>",1
+circular,lm.circular.cc,2,0,0,double,1
+circular,lm.circular.cc,3,0,0,double,1
+circular,lm.circular.cc,4,0,0,list<any>,1
+circular,LmCircularccRad,-1,0,0,list<class<`matrix`> | double[]>,1
+circular,LmCircularccRad,0,0,0,double[],1
+circular,LmCircularccRad,1,0,0,double[],1
+circular,LmCircularccRad,2,0,0,double,1
+circular,lm.circular.cl,-1,0,0,class<`lm.circular.cl`>,1
+circular,lm.circular.cl,0,0,0,"class<`circular`, `numeric`>",1
+circular,lm.circular.cl,1,0,0,class<`matrix`>,1
+circular,lm.circular.cl,2,0,0,double[],1
+circular,lm.circular.cl,3,0,0,logical,1
+circular,lm.circular.cl,4,0,0,double,1
+circular,lm.circular.cl,5,0,0,list<any>,1
+circular,LmCircularclRad,-1,0,0,list<class<`matrix`> | double[]>,1
+circular,LmCircularclRad,0,0,0,double[],1
+circular,LmCircularclRad,1,0,0,class<`matrix`>,1
+circular,LmCircularclRad,2,0,0,double[],1
+circular,LmCircularclRad,3,0,0,logical,1
+circular,LmCircularclRad,4,0,0,double,1
+circular,lsfit.circle,-1,0,0,class<`lsfit.circle`>,1
+circular,lsfit.circle,0,0,0,double[],1
+circular,lsfit.circle,1,0,0,double[],1
+circular,lsfit.circle,2,0,0,null,1
+circular,lsfit.circle,3,0,0,character[],1
+circular,lsfit.circle,4,0,0,character[],1
+circular,lsfit.circle,5,0,0,character[],1
+circular,lsfit.circle,6,0,0,double,1
+circular,lsfit.circle,7,0,0,character[],1
+circular,lsfit.circle,8,0,0,...,1
+circular,LsfitCircleRad,-1,0,0,list<double[] | list<double[] | null | class<`matrix`>>>,1
+circular,LsfitCircleRad,0,0,0,double[],1
+circular,LsfitCircleRad,1,0,0,double[],1
+circular,LsfitCircleRad,2,0,0,null,1
+circular,LsfitCircleRad,3,0,0,...,1
+circular,mean.circular,-1,0,0,"class<`circular`, `numeric`>",1
+circular,mean.circular,0,0,0,"class<`circular`, `numeric`>",1
+circular,mean.circular,1,0,0,logical,1
+circular,mean.circular,2,0,0,list<any>,1
+circular,mean.circular,3,0,0,...,1
+circular,MeanCircularRad,-1,0,0,double,1
+circular,MeanCircularRad,0,0,0,double[],1
+circular,meandeviation,-1,0,0,double,1
+circular,meandeviation,0,0,0,"class<`circular`, `numeric`>",1
+circular,meandeviation,1,0,0,logical,1
+circular,MeanDeviationRad,-1,0,0,double,1
+circular,MeanDeviationRad,0,0,0,double[],1
+circular,median.circular,-1,0,0,"class<`circular`, `numeric`>",1
+circular,median.circular,0,0,0,"class<`circular`, `numeric`>",1
+circular,median.circular,1,0,0,logical,1
+circular,median.circular,2,0,0,...,1
+circular,MedianCircularRad,-1,0,0,double,1
+circular,MedianCircularRad,-1,0,1,null,1
+circular,MedianCircularRad,0,0,0,double[],1
+circular,medianHL.circular,-1,0,0,"class<`circular`, `numeric`>",1
+circular,medianHL.circular,0,0,0,"class<`circular`, `numeric`>",1
+circular,medianHL.circular,1,0,0,logical,1
+circular,medianHL.circular,2,0,0,character,1
+circular,medianHL.circular,3,0,0,null,1
+circular,MedianHLCircularRad,-1,0,0,double,1
+circular,MedianHLCircularRad,0,0,0,double[],1
+circular,MedianHLCircularRad,1,0,0,character,1
+circular,MedianHLCircularRad,2,0,0,null,1
+circular,minusPiPlusPi,-1,0,0,"class<`circular`, `numeric`>",1
+circular,minusPiPlusPi,0,0,0,"class<`circular`, `numeric`>",1
+circular,MinusPiPlusPiRad,-1,0,0,double[],1
+circular,MinusPiPlusPiRad,0,0,0,double[],1
+circular,MinusPiPlusPiRad,0,0,1,null,1
+circular,mle.vonmises,-1,0,0,class<`mle.vonmises`>,1
+circular,mle.vonmises,0,0,0,"class<`circular`, `numeric`>",1
+circular,mle.vonmises,1,0,0,"class<`circular`, `numeric`>",1
+circular,mle.vonmises,1,0,1,null,1
+circular,mle.vonmises,2,0,0,null,1
+circular,mle.vonmises,3,0,0,logical,1
+circular,mle.vonmises,4,0,0,list<any>,1
+circular,mle.vonmises.bootstrap.ci,-1,0,0,class<`mle.vonmises.bootstrap.ci`>,1
+circular,mle.vonmises.bootstrap.ci,0,0,0,"class<`circular`, `numeric`>",1
+circular,mle.vonmises.bootstrap.ci,1,0,0,null,1
+circular,mle.vonmises.bootstrap.ci,2,0,0,logical,1
+circular,mle.vonmises.bootstrap.ci,3,0,0,double,1
+circular,mle.vonmises.bootstrap.ci,4,0,0,double,1
+circular,mle.vonmises.bootstrap.ci,5,0,0,list<any>,1
+circular,MleVonmisesBootstrapCiRad,-1,0,0,list<double[]>,1
+circular,MleVonmisesBootstrapCiRad,0,0,0,double[],1
+circular,MleVonmisesBootstrapCiRad,1,0,0,double,1
+circular,MleVonmisesBootstrapCiRad,2,0,0,logical,1
+circular,MleVonmisesBootstrapCiRad,3,0,0,double,1
+circular,MleVonmisesBootstrapCiRad,4,0,0,double,1
+circular,MlevonmisesRad,-1,0,0,double[],1
+circular,MlevonmisesRad,0,0,0,double[],1
+circular,MlevonmisesRad,1,0,0,double,1
+circular,MlevonmisesRad,1,0,1,null,1
+circular,MlevonmisesRad,2,0,0,null,1
+circular,MlevonmisesRad,3,0,0,logical,1
+circular,mle.wrappedcauchy,-1,0,0,class<`mle.wrappedcauchy`>,1
+circular,mle.wrappedcauchy,0,0,0,"class<`circular`, `numeric`>",1
+circular,mle.wrappedcauchy,1,0,0,"class<`circular`, `numeric`>",1
+circular,mle.wrappedcauchy,1,0,1,null,1
+circular,mle.wrappedcauchy,2,0,0,null,1
+circular,mle.wrappedcauchy,3,0,0,double,1
+circular,mle.wrappedcauchy,4,0,0,double,1
+circular,mle.wrappedcauchy,5,0,0,list<any>,1
+circular,MlewrappedcauchyRad,-1,0,0,double[],1
+circular,MlewrappedcauchyRad,0,0,0,double[],1
+circular,MlewrappedcauchyRad,1,0,0,double,1
+circular,MlewrappedcauchyRad,1,0,1,null,1
+circular,MlewrappedcauchyRad,2,0,0,null,1
+circular,MlewrappedcauchyRad,3,0,0,double,1
+circular,MlewrappedcauchyRad,4,0,0,double,1
+circular,mle.wrappednormal,-1,0,0,class<`mle.wrappednormal`>,1
+circular,mle.wrappednormal,0,0,0,"class<`circular`, `numeric`>",1
+circular,mle.wrappednormal,1,0,0,"class<`circular`, `numeric`>",1
+circular,mle.wrappednormal,1,0,1,null,1
+circular,mle.wrappednormal,2,0,0,null,1
+circular,mle.wrappednormal,3,0,0,null,1
+circular,mle.wrappednormal,4,0,0,null,1
+circular,mle.wrappednormal,5,0,0,double,1
+circular,mle.wrappednormal,6,0,0,double,1
+circular,mle.wrappednormal,7,0,0,double,1
+circular,mle.wrappednormal,8,0,0,double,1
+circular,mle.wrappednormal,9,0,0,logical,1
+circular,mle.wrappednormal,10,0,0,list<any>,1
+circular,MlewrappednormalRad,-1,0,0,double[],1
+circular,MlewrappednormalRad,0,0,0,double[],1
+circular,MlewrappednormalRad,1,0,0,double,1
+circular,MlewrappednormalRad,1,0,1,null,1
+circular,MlewrappednormalRad,2,0,0,null,1
+circular,MlewrappednormalRad,3,0,0,null,1
+circular,MlewrappednormalRad,4,0,0,double,1
+circular,MlewrappednormalRad,5,0,0,null,1
+circular,MlewrappednormalRad,6,0,0,double,1
+circular,MlewrappednormalRad,7,0,0,double,1
+circular,MlewrappednormalRad,8,0,0,double,1
+circular,MlewrappednormalRad,9,0,0,logical,1
+circular,modal.region,-1,0,0,class<`modal.region.circular`>,1
+circular,modal.region,0,0,0,"class<`circular`, `numeric`>",1
+circular,modal.region,1,0,0,...,1
+circular,modal.region.circular,-1,0,0,class<`modal.region.circular`>,1
+circular,modal.region.circular,0,0,0,"class<`circular`, `numeric`>",1
+circular,modal.region.circular,1,0,0,"class<`circular`, `numeric`>",1
+circular,modal.region.circular,1,0,1,null,1
+circular,modal.region.circular,2,0,0,double,1
+circular,modal.region.circular,3,0,0,double,1
+circular,modal.region.circular,4,0,0,double,1
+circular,modal.region.circular,5,0,0,any,1
+circular,modal.region.circular,6,0,0,character[],1
+circular,modal.region.circular,7,0,0,any,1
+circular,modal.region.circular,8,0,0,any,1
+circular,modal.region.circular,9,0,0,double,1
+circular,modal.region.circular,10,0,0,double,1
+circular,modal.region.circular,11,0,0,...,1
+circular,plot.circular,-1,0,0,list<double | character>,1
+circular,plot.circular,0,0,0,"class<`circular`, `integer`>",1
+circular,plot.circular,0,0,1,"class<`circular`, `matrix`>",1
+circular,plot.circular,0,0,2,"class<`circular`, `numeric`>",1
+circular,plot.circular,1,0,0,double,1
+circular,plot.circular,2,0,0,double,1
+circular,plot.circular,3,0,0,logical,1
+circular,plot.circular,4,0,0,logical,1
+circular,plot.circular,5,0,0,double,1
+circular,plot.circular,6,0,0,double,1
+circular,plot.circular,7,0,0,double,1
+circular,plot.circular,8,0,0,null,1
+circular,plot.circular,8,0,1,double,1
+circular,plot.circular,9,0,0,logical,1
+circular,plot.circular,10,0,0,double,1
+circular,plot.circular,11,0,0,double,1
+circular,plot.circular,12,0,0,null,1
+circular,plot.circular,12,0,1,double,1
+circular,plot.circular,13,0,0,double,1
+circular,plot.circular,14,0,0,null,1
+circular,plot.circular,15,0,0,double[],1
+circular,plot.density.circular,-1,0,0,null,1
+circular,plot.density.circular,-1,0,1,list<double[] | character>,1
+circular,plot.density.circular,0,0,0,class<`density.circular`>,1
+circular,plot.density.circular,1,0,0,character,1
+circular,plot.density.circular,1,0,1,null,1
+circular,plot.density.circular,2,0,0,null,1
+circular,plot.density.circular,3,0,0,character,1
+circular,plot.density.circular,3,0,1,null,1
+circular,plot.density.circular,4,0,0,character,1
+circular,plot.density.circular,5,0,0,character,1
+circular,plot.density.circular,6,0,0,logical,1
+circular,plot.density.circular,7,0,0,logical,1
+circular,plot.density.circular,8,0,0,double,1
+circular,plot.density.circular,9,0,0,double,1
+circular,plot.density.circular,10,0,0,double,1
+circular,plot.density.circular,11,0,0,character[],1
+circular,plot.density.circular,12,0,0,logical,1
+circular,plot.density.circular,13,0,0,logical,1
+circular,plot.density.circular,14,0,0,null,1
+circular,plot.density.circular,15,0,0,double,1
+circular,plot.edf,-1,0,0,null,1
+circular,plot.edf,0,0,0,"class<`circular`, `numeric`>",1
+circular,plot.edf,1,0,0,character,1
+circular,plot.edf,2,0,0,double[],1
+circular,plot.edf,3,0,0,double[],1
+circular,plot.edf,4,0,0,...,1
+circular,plot.function.circular,-1,0,0,list<double[] | character>,1
+circular,plot.function.circular,0,0,0,class<`function`>,1
+circular,plot.function.circular,1,0,0,double,1
+circular,plot.function.circular,2,0,0,double,1
+circular,plot.function.circular,3,0,0,...,1
+circular,plot.lsfit.circle,-1,0,0,class<`lsfit.circle`>,1
+circular,plot.lsfit.circle,0,0,0,class<`lsfit.circle`>,1
+circular,plot.lsfit.circle,1,0,0,logical,1
+circular,plot.lsfit.circle,2,0,0,null,1
+circular,plot.lsfit.circle,3,0,0,null,1
+circular,plot.lsfit.circle,4,0,0,null,1
+circular,plot.lsfit.circle,5,0,0,null,1
+circular,plot.lsfit.circle,6,0,0,null,1
+circular,plot.lsfit.circle,7,0,0,any,1
+circular,plot.lsfit.circle,8,0,0,double,1
+circular,plot.lsfit.circle,9,0,0,double,1
+circular,plot.lsfit.circle,10,0,0,...,1
+circular,plot.modal.region.circular,-1,0,0,null,1
+circular,plot.modal.region.circular,0,0,0,class<`modal.region.circular`>,1
+circular,plot.modal.region.circular,1,0,0,character[],1
+circular,plot.modal.region.circular,2,0,0,null,1
+circular,plot.modal.region.circular,3,0,0,null,1
+circular,plot.modal.region.circular,4,0,0,null,1
+circular,plot.modal.region.circular,5,0,0,null,1
+circular,plot.modal.region.circular,6,0,0,null,1
+circular,plot.modal.region.circular,7,0,0,list<any>,1
+circular,plot.modal.region.circular,8,0,0,...,1
+circular,plot.totalvariation.circular,-1,0,0,class<`totalvariation.circular`>,1
+circular,plot.totalvariation.circular,0,0,0,class<`totalvariation.circular`>,1
+circular,plot.totalvariation.circular,1,0,0,logical,1
+circular,plot.totalvariation.circular,2,0,0,logical,1
+circular,plot.totalvariation.circular,3,0,0,character[],1
+circular,plot.totalvariation.circular,4,0,0,null,1
+circular,plot.totalvariation.circular,5,0,0,null,1
+circular,plot.totalvariation.circular,6,0,0,null,1
+circular,plot.totalvariation.circular,7,0,0,double,1
+circular,plot.totalvariation.circular,8,0,0,double,1
+circular,plot.totalvariation.circular,9,0,0,logical,1
+circular,plot.totalvariation.circular,10,0,0,double,1
+circular,plot.totalvariation.circular,11,0,0,list<any>,1
+circular,plot.totalvariation.circular,12,0,0,list<any>,1
+circular,plot.totalvariation.circular,13,0,0,double,1
+circular,plot.totalvariation.circular,14,0,0,double,1
+circular,plot.totalvariation.circular,15,0,0,double,1
+circular,points.circular,-1,0,0,list<double | character>,1
+circular,points.circular,0,0,0,"class<`circular`, `integer`>",1
+circular,points.circular,0,0,1,"class<`circular`, `numeric`>",1
+circular,points.circular,1,0,0,double,1
+circular,points.circular,2,0,0,double,1
+circular,points.circular,3,0,0,logical,1
+circular,points.circular,4,0,0,double,1
+circular,points.circular,5,0,0,double,1
+circular,points.circular,6,0,0,double,1
+circular,points.circular,7,0,0,null,1
+circular,points.circular,8,0,0,double,1
+circular,points.circular,8,0,1,null,1
+circular,points.circular,9,0,0,null,1
+circular,points.circular,10,0,0,null,1
+circular,points.circular,10,0,1,list<double | character>,1
+circular,points.circular,10,0,2,list<double[] | character>,1
+circular,points.circular,11,0,0,null,1
+circular,points.circular,12,0,0,null,1
+circular,points.circular,13,0,0,...,1
+circular,PointsCircularRad,-1,0,0,null,1
+circular,PointsCircularRad,0,0,0,double[],1
+circular,PointsCircularRad,1,0,0,any,1
+circular,PointsCircularRad,2,0,0,logical,1
+circular,PointsCircularRad,3,0,0,double,1
+circular,PointsCircularRad,4,0,0,double,1
+circular,PointsCircularRad,5,0,0,double,1
+circular,PointsCircularRad,6,0,0,any,1
+circular,PointsCircularRad,7,0,0,double,1
+circular,PointsCircularRad,8,0,0,double,1
+circular,PointsCircularRad,9,0,0,any,1
+circular,PointsCircularRad,10,0,0,any,1
+circular,PointsCircularRad,11,0,0,double,1
+circular,PointsCircularRad,12,0,0,...,1
+circular,pp.plot,-1,0,0,"list<class<`circular`, `numeric`> | double>",1
+circular,pp.plot,0,0,0,"class<`circular`, `numeric`>",1
+circular,pp.plot,1,0,0,logical,1
+circular,pp.plot,2,0,0,double,1
+circular,pp.plot,3,0,0,character,1
+circular,pp.plot,4,0,0,character,1
+circular,pp.plot,5,0,0,list<any>,1
+circular,pp.plot,6,0,0,...,1
+circular,pp.unif.plot,-1,0,0,null,1
+circular,pp.unif.plot,0,0,0,"class<`circular`, `numeric`>",1
+circular,pp.unif.plot,1,0,0,logical,1
+circular,pp.unif.plot,2,0,0,double,1
+circular,pp.unif.plot,2,0,1,null,1
+circular,pp.unif.plot,3,0,0,character,1
+circular,pp.unif.plot,4,0,0,character,1
+circular,pp.unif.plot,5,0,0,null,1
+circular,pp.unif.plot,6,0,0,null,1
+circular,pp.unif.plot,7,0,0,null,1
+circular,pp.unif.plot,8,0,0,...,1
+circular,print.circular,-1,0,0,"class<`circular`, `numeric`>",1
+circular,print.circular,0,0,0,"class<`circular`, `numeric`>",1
+circular,print.circular,1,0,0,logical,1
+circular,print.circular,2,0,0,...,1
+circular,print.rao.spacing.test,-1,0,0,class<`rao.spacing.test`>,1
+circular,print.rao.spacing.test,0,0,0,class<`rao.spacing.test`>,1
+circular,print.rao.spacing.test,1,0,0,double,1
+circular,print.rao.spacing.test,2,0,0,...,1
+circular,prodseq,-1,0,0,double[],1
+circular,prodseq,0,0,0,double[],1
+circular,prodseq,1,0,0,integer,1
+circular,prodseq,2,0,0,integer,1
+circular,prodseq,3,0,0,...,1
+circular,pvonmises,-1,0,0,double[],1
+circular,pvonmises,0,0,0,"class<`circular`, `numeric`>",1
+circular,pvonmises,1,0,0,"class<`circular`, `numeric`>",1
+circular,pvonmises,2,0,0,double,1
+circular,pvonmises,3,0,0,null,1
+circular,pvonmises,4,0,0,double,1
+circular,PvonmisesRad,-1,0,0,double[],1
+circular,PvonmisesRad,0,0,0,double[],1
+circular,PvonmisesRad,1,0,0,double,1
+circular,PvonmisesRad,2,0,0,double,1
+circular,PvonmisesRad,3,0,0,double,1
+circular,pwrappednormal,-1,0,0,double[],1
+circular,pwrappednormal,0,0,0,"class<`circular`, `numeric`>",1
+circular,pwrappednormal,1,0,0,"class<`circular`, `numeric`>",1
+circular,pwrappednormal,2,0,0,double,1
+circular,pwrappednormal,3,0,0,double,1
+circular,pwrappednormal,4,0,0,"class<`circular`, `numeric`>",1
+circular,pwrappednormal,4,0,1,null,1
+circular,pwrappednormal,5,0,0,null,1
+circular,pwrappednormal,6,0,0,double,1
+circular,pwrappednormal,7,0,0,...,1
+circular,quantile.circular,-1,0,0,"class<`circular`, `numeric`>",1
+circular,quantile.circular,0,0,0,"class<`circular`, `numeric`>",1
+circular,quantile.circular,1,0,0,double[],1
+circular,quantile.circular,2,0,0,logical,1
+circular,quantile.circular,3,0,0,logical,1
+circular,quantile.circular,4,0,0,double,1
+circular,quantile.circular,5,0,0,...,1
+circular,QuantileCircularRad,-1,0,0,double[],1
+circular,QuantileCircularRad,0,0,0,double[],1
+circular,QuantileCircularRad,1,0,0,double[],1
+circular,QuantileCircularRad,2,0,0,logical,1
+circular,QuantileCircularRad,3,0,0,double,1
+circular,QuantileCircularRad,4,0,0,...,1
+circular,qvonmises,-1,0,0,"class<`circular`, `numeric`>",1
+circular,qvonmises,0,0,0,double[],1
+circular,qvonmises,1,0,0,"class<`circular`, `numeric`>",1
+circular,qvonmises,2,0,0,double,1
+circular,qvonmises,3,0,0,"class<`circular`, `numeric`>",1
+circular,qvonmises,3,0,1,null,1
+circular,qvonmises,4,0,0,double,1
+circular,qvonmises,5,0,0,list<any>,1
+circular,qvonmises,6,0,0,...,1
+circular,qwrappednormal,-1,0,0,"class<`circular`, `numeric`>",1
+circular,qwrappednormal,0,0,0,double[],1
+circular,qwrappednormal,1,0,0,"class<`circular`, `numeric`>",1
+circular,qwrappednormal,2,0,0,null,1
+circular,qwrappednormal,3,0,0,double,1
+circular,qwrappednormal,4,0,0,null,1
+circular,qwrappednormal,5,0,0,null,1
+circular,qwrappednormal,6,0,0,double,1
+circular,qwrappednormal,7,0,0,double,1
+circular,qwrappednormal,8,0,0,list<any>,1
+circular,qwrappednormal,9,0,0,...,1
+circular,range.circular,-1,0,0,"list<class<`circular`, `numeric`> | double>",1
+circular,range.circular,0,0,0,"class<`circular`, `numeric`>",1
+circular,range.circular,1,0,0,logical,1
+circular,range.circular,2,0,0,logical,1
+circular,range.circular,3,0,0,logical,1
+circular,range.circular,4,0,0,list<any>,1
+circular,range.circular,5,0,0,...,1
+circular,RangeCircularRad,-1,0,0,double,1
+circular,RangeCircularRad,-1,0,1,list<double>,1
+circular,RangeCircularRad,0,0,0,double[],1
+circular,RangeCircularRad,1,0,0,logical,1
+circular,rao.spacing.test,-1,0,0,class<`rao.spacing.test`>,1
+circular,rao.spacing.test,0,0,0,"class<`circular`, `numeric`>",1
+circular,rao.spacing.test,1,0,0,double,1
+circular,RaoSpacingTestDeg,-1,0,0,double,1
+circular,RaoSpacingTestDeg,0,0,0,double[],1
+circular,rao.test,-1,0,0,class<`rao.test`>,1
+circular,rao.test,0,0,0,...,1
+circular,rao.test,1,0,0,double,1
+circular,RaoTestRad,-1,0,0,list<double[]>,1
+circular,RaoTestRad,0,0,0,list<double[]>,1
+circular,rayleigh.test,-1,0,0,class<`rayleigh.test`>,1
+circular,rayleigh.test,0,0,0,"class<`circular`, `numeric`>",1
+circular,rayleigh.test,1,0,0,"class<`circular`, `numeric`>",1
+circular,rayleigh.test,1,0,1,null,1
+circular,RayleighTestRad,-1,0,0,list<double>,1
+circular,RayleighTestRad,-1,0,1,list<double | null>,1
+circular,RayleighTestRad,0,0,0,double[],1
+circular,RayleighTestRad,1,0,0,double,1
+circular,RayleighTestRad,1,0,1,null,1
+circular,rcardioid,-1,0,0,"class<`circular`, `numeric`>",1
+circular,rcardioid,0,0,0,double,1
+circular,rcardioid,1,0,0,"class<`circular`, `numeric`>",1
+circular,rcardioid,2,0,0,double,1
+circular,rcardioid,3,0,0,list<any>,1
+circular,RcardioidRad,-1,0,0,double[],1
+circular,RcardioidRad,0,0,0,double,1
+circular,RcardioidRad,1,0,0,double,1
+circular,RcardioidRad,2,0,0,double,1
+circular,rcircularuniform,-1,0,0,"class<`circular`, `numeric`>",1
+circular,rcircularuniform,0,0,0,double,1
+circular,rcircularuniform,1,0,0,list<character>,1
+circular,rho.circular,-1,0,0,double,1
+circular,rho.circular,0,0,0,"class<`circular`, `numeric`>",1
+circular,rho.circular,1,0,0,logical,1
+circular,RhoCircularRad,-1,0,0,double,1
+circular,RhoCircularRad,0,0,0,double[],1
+circular,RhoCircularRad,0,0,1,"class<`circular`, `numeric`>",1
+circular,rkatojones,-1,0,0,"class<`circular`, `numeric`>",1
+circular,rkatojones,0,0,0,double,1
+circular,rkatojones,1,0,0,"class<`circular`, `numeric`>",1
+circular,rkatojones,2,0,0,"class<`circular`, `numeric`>",1
+circular,rkatojones,3,0,0,double,1
+circular,rkatojones,4,0,0,double,1
+circular,rkatojones,5,0,0,list<any>,1
+circular,rkatojonesRad,-1,0,0,double[],1
+circular,rkatojonesRad,0,0,0,double,1
+circular,rkatojonesRad,1,0,0,double,1
+circular,rkatojonesRad,2,0,0,double,1
+circular,rkatojonesRad,3,0,0,double,1
+circular,rkatojonesRad,4,0,0,double,1
+circular,rmixedvonmises,-1,0,0,"class<`circular`, `numeric`>",1
+circular,rmixedvonmises,0,0,0,double,1
+circular,rmixedvonmises,1,0,0,"class<`circular`, `numeric`>",1
+circular,rmixedvonmises,2,0,0,"class<`circular`, `numeric`>",1
+circular,rmixedvonmises,3,0,0,double,1
+circular,rmixedvonmises,4,0,0,double,1
+circular,rmixedvonmises,5,0,0,double,1
+circular,rmixedvonmises,6,0,0,list<any>,1
+circular,RmixedvonmisesRad,-1,0,0,double[],1
+circular,RmixedvonmisesRad,0,0,0,double,1
+circular,RmixedvonmisesRad,1,0,0,double,1
+circular,RmixedvonmisesRad,2,0,0,double,1
+circular,RmixedvonmisesRad,3,0,0,double,1
+circular,RmixedvonmisesRad,4,0,0,double,1
+circular,RmixedvonmisesRad,5,0,0,double,1
+circular,rose.diag,-1,0,0,list<double | character>,1
+circular,rose.diag,0,0,0,"class<`circular`, `numeric`>",1
+circular,rose.diag,1,0,0,double,1
+circular,rose.diag,2,0,0,double,1
+circular,rose.diag,3,0,0,logical,1
+circular,rose.diag,4,0,0,double,1
+circular,rose.diag,5,0,0,double,1
+circular,rose.diag,6,0,0,logical,1
+circular,rose.diag,7,0,0,logical,1
+circular,rose.diag,8,0,0,double,1
+circular,rose.diag,9,0,0,double,1
+circular,rose.diag,10,0,0,character[],1
+circular,rose.diag,11,0,0,null,1
+circular,rose.diag,12,0,0,double,1
+circular,rose.diag,12,0,1,null,1
+circular,rose.diag,13,0,0,double,1
+circular,rose.diag,14,0,0,null,1
+circular,rose.diag,15,0,0,any,1
+circular,RosediagRad,-1,0,0,null,1
+circular,RosediagRad,0,0,0,double[],1
+circular,RosediagRad,1,0,0,double,1
+circular,RosediagRad,2,0,0,character,1
+circular,RosediagRad,3,0,0,double,1
+circular,RosediagRad,4,0,0,logical,1
+circular,RosediagRad,5,0,0,character,1
+circular,RosediagRad,6,0,0,double,1
+circular,RosediagRad,7,0,0,integer,1
+circular,RosediagRad,8,0,0,double,1
+circular,RosediagRad,8,0,1,null,1
+circular,RosediagRad,9,0,0,...,1
+circular,rpnorm,-1,0,0,"class<`circular`, `numeric`>",1
+circular,rpnorm,0,0,0,double,1
+circular,rpnorm,1,0,0,double[],1
+circular,rpnorm,2,0,0,class<`matrix`>,1
+circular,rpnorm,3,0,0,list<character>,1
+circular,RpnormRad,-1,0,0,double[],1
+circular,RpnormRad,0,0,0,double,1
+circular,RpnormRad,1,0,0,double[],1
+circular,RpnormRad,2,0,0,class<`matrix`>,1
+circular,rstable,-1,0,0,double[],1
+circular,rstable,0,0,0,double,1
+circular,rstable,1,0,0,double,1
+circular,rstable,2,0,0,double,1
+circular,rstable,3,0,0,double,1
+circular,rtriangular,-1,0,0,"class<`circular`, `numeric`>",1
+circular,rtriangular,0,0,0,double,1
+circular,rtriangular,1,0,0,double,1
+circular,rtriangular,2,0,0,list<character>,1
+circular,RtriangularRad,-1,0,0,double[],1
+circular,RtriangularRad,0,0,0,double,1
+circular,RtriangularRad,1,0,0,double,1
+circular,RuniformRad,-1,0,0,double[],1
+circular,RuniformRad,0,0,0,double,1
+circular,rvonmises,-1,0,0,"class<`circular`, `numeric`>",1
+circular,rvonmises,0,0,0,double,1
+circular,rvonmises,1,0,0,"class<`circular`, `numeric`>",1
+circular,rvonmises,2,0,0,double,1
+circular,rvonmises,3,0,0,list<any>,1
+circular,RvonmisesRad,-1,0,0,double[],1
+circular,RvonmisesRad,0,0,0,double,1
+circular,RvonmisesRad,1,0,0,double,1
+circular,RvonmisesRad,2,0,0,double,1
+circular,rwrappedcauchy,-1,0,0,"class<`circular`, `numeric`>",1
+circular,rwrappedcauchy,0,0,0,double,1
+circular,rwrappedcauchy,1,0,0,"class<`circular`, `numeric`>",1
+circular,rwrappedcauchy,2,0,0,double,1
+circular,rwrappedcauchy,3,0,0,list<any>,1
+circular,RwrappedcauchyRad,-1,0,0,double[],1
+circular,RwrappedcauchyRad,0,0,0,double,1
+circular,RwrappedcauchyRad,1,0,0,double,1
+circular,RwrappedcauchyRad,2,0,0,double,1
+circular,rwrappednormal,-1,0,0,"class<`circular`, `numeric`>",1
+circular,rwrappednormal,0,0,0,double,1
+circular,rwrappednormal,1,0,0,"class<`circular`, `numeric`>",1
+circular,rwrappednormal,2,0,0,double,1
+circular,rwrappednormal,2,0,1,null,1
+circular,rwrappednormal,3,0,0,double,1
+circular,rwrappednormal,4,0,0,list<any>,1
+circular,RwrappednormalRad,-1,0,0,double[],1
+circular,RwrappednormalRad,0,0,0,double,1
+circular,RwrappednormalRad,1,0,0,double,1
+circular,RwrappednormalRad,2,0,0,double,1
+circular,sd,-1,0,0,double,1
+circular,sd,0,0,0,"class<`circular`, `numeric`>",1
+circular,sd,1,0,0,...,1
+circular,sd.circular,-1,0,0,double,1
+circular,sd.circular,0,0,0,"class<`circular`, `numeric`>",1
+circular,sd.circular,1,0,0,logical,1
+circular,sd.circular,2,0,0,...,1
+circular,SdCircularRad,-1,0,0,double,1
+circular,SdCircularRad,0,0,0,double[],1
+circular,summary.circular,-1,0,0,double[],1
+circular,summary.circular,0,0,0,"class<`circular`, `numeric`>",1
+circular,summary.circular,1,0,0,double,1
+circular,summary.circular,2,0,0,...,1
+circular,ticks.circular,-1,0,0,null,1
+circular,ticks.circular,0,0,0,"class<`circular`, `numeric`>",1
+circular,ticks.circular,1,0,0,character[],1
+circular,ticks.circular,2,0,0,null,1
+circular,ticks.circular,3,0,0,null,1
+circular,ticks.circular,4,0,0,double,1
+circular,ticks.circular,5,0,0,null,1
+circular,ticks.circular,6,0,0,...,1
+circular,TicksCircularRad,-1,0,0,null,1
+circular,TicksCircularRad,0,0,0,double[],1
+circular,TicksCircularRad,1,0,0,double,1
+circular,TicksCircularRad,2,0,0,character,1
+circular,TicksCircularRad,3,0,0,...,1
+circular,totalvariation.circular,-1,0,0,class<`totalvariation.circular`>,1
+circular,totalvariation.circular,0,0,0,"class<`circular`, `numeric`>",1
+circular,totalvariation.circular,1,0,0,"class<`circular`, `numeric`>",1
+circular,totalvariation.circular,2,0,0,null,1
+circular,totalvariation.circular,3,0,0,double,1
+circular,totalvariation.circular,4,0,0,double,1
+circular,totalvariation.circular,5,0,0,double,1
+circular,totalvariation.circular,6,0,0,any,1
+circular,totalvariation.circular,7,0,0,character[],1
+circular,totalvariation.circular,8,0,0,logical,1
+circular,totalvariation.circular,9,0,0,double,1
+circular,totalvariation.circular,10,0,0,double,1
+circular,totalvariation.circular,11,0,0,double,1
+circular,totalvariation.circular,12,0,0,...,1
+circular,trigonometric.moment,-1,0,0,"list<class<`circular`, `numeric`> | double | class<`call`>>",1
+circular,trigonometric.moment,0,0,0,"class<`circular`, `numeric`>",1
+circular,trigonometric.moment,1,0,0,double,1
+circular,trigonometric.moment,2,0,0,logical,1
+circular,trigonometric.moment,3,0,0,list<character>,1
+circular,TrigonometricMomentRad,-1,0,0,double[],1
+circular,TrigonometricMomentRad,0,0,0,double[],1
+circular,TrigonometricMomentRad,1,0,0,double,1
+circular,TrigonometricMomentRad,2,0,0,logical,1
+circular,unique.circular,-1,0,0,"class<`circular`, `numeric`>",1
+circular,unique.circular,0,0,0,"class<`circular`, `numeric`>",1
+circular,unique.circular,1,0,0,...,1
+circular,var,-1,0,0,double,1
+circular,var,0,0,0,"class<`circular`, `numeric`>",1
+circular,var,1,0,0,...,1
+circular,var.circular,-1,0,0,double,1
+circular,var.circular,0,0,0,"class<`circular`, `numeric`>",1
+circular,var.circular,1,0,0,logical,1
+circular,var.circular,2,0,0,...,1
+circular,VarCircularRad,-1,0,0,double,1
+circular,VarCircularRad,0,0,0,double[],1
+circular,var.default,-1,0,0,double,1
+circular,var.default,0,0,0,double[],1
+circular,var.default,1,0,0,null,1
+circular,var.default,1,0,1,double[],1
+circular,var.default,2,0,0,logical,1
+circular,var.default,3,0,0,any,1
+circular,var.default,4,0,0,...,1
+circular,wallraff.test,-1,0,0,class<`htest`>,1
+circular,wallraff.test,0,0,0,"class<`circular`, `numeric`>",1
+circular,wallraff.test,0,0,1,class<`formula`>,1
+circular,wallraff.test,0,0,2,"list<class<`circular`, `numeric`>>",1
+circular,wallraff.test,1,0,0,...,1
+circular,wallraff.test.default,-1,0,0,class<`htest`>,1
+circular,wallraff.test.default,0,0,0,"class<`circular`, `numeric`>",1
+circular,wallraff.test.default,1,0,0,class<`factor`>,1
+circular,wallraff.test.default,2,0,0,null,1
+circular,wallraff.test.default,2,0,1,"class<`circular`, `numeric`>",1
+circular,wallraff.test.default,2,0,2,double,1
+circular,wallraff.test.default,3,0,0,...,1
+circular,wallraff.test.formula,-1,0,0,class<`htest`>,1
+circular,wallraff.test.formula,0,0,0,class<`formula`>,1
+circular,wallraff.test.formula,1,0,0,class<`data.frame`>,1
+circular,wallraff.test.formula,2,0,0,null,1
+circular,wallraff.test.formula,3,0,0,...,1
+circular,wallraff.test.list,-1,0,0,class<`htest`>,1
+circular,wallraff.test.list,0,0,0,"list<class<`circular`, `numeric`>>",1
+circular,wallraff.test.list,1,0,0,null,1
+circular,wallraff.test.list,1,0,1,"class<`circular`, `numeric`>",1
+circular,wallraff.test.list,1,0,2,double,1
+circular,wallraff.test.list,2,0,0,...,1
+circular,WallraffTestRad,-1,0,0,class<`htest`>,1
+circular,WallraffTestRad,0,0,0,double[],1
+circular,WallraffTestRad,1,0,0,class<`factor`>,1
+circular,WallraffTestRad,2,0,0,double[],1
+circular,watson.test,-1,0,0,class<`watson.test`>,1
+circular,watson.test,0,0,0,"class<`circular`, `numeric`>",1
+circular,watson.test,1,0,0,double,1
+circular,watson.test,2,0,0,character[],1
+circular,WatsonTestRad,-1,0,0,list<double>,1
+circular,WatsonTestRad,-1,0,1,list<double | null>,1
+circular,WatsonTestRad,0,0,0,double[],1
+circular,WatsonTestRad,1,0,0,character,1
+circular,watson.two.test,-1,0,0,class<`watson.two.test`>,1
+circular,watson.two.test,0,0,0,"class<`circular`, `numeric`>",1
+circular,watson.two.test,1,0,0,"class<`circular`, `numeric`>",1
+circular,watson.two.test,2,0,0,double,1
+circular,WatsonTwoTestRad,-1,0,0,list<double>,1
+circular,WatsonTwoTestRad,0,0,0,double[],1
+circular,WatsonTwoTestRad,1,0,0,double[],1
+circular,watson.wheeler.test,-1,0,0,class<`htest`>,1
+circular,watson.wheeler.test,0,0,0,"list<class<`circular`, `numeric`>>",1
+circular,watson.wheeler.test,1,0,0,...,1
+circular,watson.wheeler.test.default,-1,0,0,class<`htest`>,1
+circular,watson.wheeler.test.default,0,0,0,"class<`circular`, `numeric`>",1
+circular,watson.wheeler.test.default,1,0,0,character[],1
+circular,watson.wheeler.test.default,2,0,0,...,1
+circular,watson.wheeler.test.list,-1,0,0,class<`htest`>,1
+circular,watson.wheeler.test.list,0,0,0,"list<class<`circular`, `numeric`>>",1
+circular,watson.wheeler.test.list,1,0,0,...,1
+circular,WatsonWheelerTestRad,-1,0,0,class<`htest`>,1
+circular,WatsonWheelerTestRad,0,0,0,double[],1
+circular,WatsonWheelerTestRad,1,0,0,character[],1
+circular,watson.williams.test,-1,0,0,class<`htest`>,1
+circular,watson.williams.test,0,0,0,"class<`circular`, `numeric`>",1
+circular,watson.williams.test,0,0,1,class<`formula`>,1
+circular,watson.williams.test,0,0,2,"list<class<`circular`, `numeric`>>",1
+circular,watson.williams.test,1,0,0,...,1
+circular,watson.williams.test.default,-1,0,0,class<`htest`>,1
+circular,watson.williams.test.default,0,0,0,"class<`circular`, `numeric`>",1
+circular,watson.williams.test.default,1,0,0,class<`factor`>,1
+circular,watson.williams.test.default,1,0,1,character[],1
+circular,watson.williams.test.default,2,0,0,...,1
+circular,watson.williams.test.formula,-1,0,0,class<`htest`>,1
+circular,watson.williams.test.formula,0,0,0,class<`formula`>,1
+circular,watson.williams.test.formula,1,0,0,class<`data.frame`>,1
+circular,watson.williams.test.formula,2,0,0,...,1
+circular,watson.williams.test.list,-1,0,0,class<`htest`>,1
+circular,watson.williams.test.list,0,0,0,"list<class<`circular`, `numeric`>>",1
+circular,watson.williams.test.list,1,0,0,...,1
+circular,WatsonWilliamsTestRad,-1,0,0,class<`htest`>,1
+circular,WatsonWilliamsTestRad,0,0,0,double[],1
+circular,WatsonWilliamsTestRad,1,0,0,class<`factor`>,1
+circular,WatsonWilliamsTestRad,1,0,1,character[],1
+circular,WatsonWilliamsTestRad,2,0,0,list<class<`array`> | double>,1
+circular,weighted.mean.circular,-1,0,0,"class<`circular`, `numeric`>",1
+circular,weighted.mean.circular,0,0,0,"class<`circular`, `numeric`>",1
+circular,weighted.mean.circular,1,0,0,double[],1
+circular,weighted.mean.circular,2,0,0,logical,1
+circular,weighted.mean.circular,3,0,0,list<any>,1
+circular,weighted.mean.circular,4,0,0,...,1
+circular,WeightedMeanCircularRad,-1,0,0,double,1
+circular,WeightedMeanCircularRad,0,0,0,double[],1
+circular,WeightedMeanCircularRad,1,0,0,double[],1
+circular,windrose,-1,0,0,list<any>,1
+circular,windrose,0,0,0,"class<`circular`, `numeric`>",1
+circular,windrose,0,0,1,class<`data.frame`>,1
+circular,windrose,1,0,0,double[],1
+circular,windrose,1,0,1,null,1
+circular,windrose,2,0,0,null,1
+circular,windrose,2,0,1,"class<`circular`, `numeric`>",1
+circular,windrose,3,0,0,double,1
+circular,windrose,4,0,0,double,1
+circular,windrose,5,0,0,character,1
+circular,windrose,6,0,0,double,1
+circular,windrose,7,0,0,null,1
+circular,windrose,8,0,0,logical,1
+circular,windrose,9,0,0,double,1
+circular,windrose,10,0,0,double,1
+circular,windrose,11,0,0,logical,1
+circular,windrose,12,0,0,logical,1
+circular,windrose,13,0,0,double,1
+circular,windrose,14,0,0,double,1
+circular,windrose,15,0,0,double,1
+class,batchSOM,-1,0,0,class<`SOM`>,1
+class,batchSOM,0,0,0,class<`data.frame`>,1
+class,batchSOM,1,0,0,class<`somgrid`>,1
+class,batchSOM,2,0,0,double[],1
+class,batchSOM,3,0,0,any,1
+class,condense,-1,0,0,integer[],1
+class,condense,0,0,0,class<`matrix`>,1
+class,condense,1,0,0,class<`factor`>,1
+class,condense,2,0,0,integer,1
+class,condense,3,0,0,logical,1
+class,knn,-1,0,0,class<`factor`>,1
+class,knn,0,0,0,class<`matrix`>,1
+class,knn,1,0,0,class<`matrix`>,1
+class,knn,2,0,0,class<`factor`>,1
+class,knn,2,0,1,integer[],1
+class,knn,3,0,0,double,1
+class,knn,4,0,0,double,1
+class,knn,5,0,0,logical,1
+class,knn,6,0,0,logical,1
+class,knn1,-1,0,0,class<`factor`>,1
+class,knn1,0,0,0,class<`matrix`>,1
+class,knn1,1,0,0,class<`data.frame`>,1
+class,knn1,1,0,1,class<`matrix`>,1
+class,knn1,2,0,0,integer[],1
+class,knn1,2,0,1,class<`factor`>,1
+class,knn.cv,-1,0,0,class<`factor`>,1
+class,knn.cv,0,0,0,class<`matrix`>,1
+class,knn.cv,1,0,0,class<`factor`>,1
+class,knn.cv,2,0,0,double,1
+class,knn.cv,3,0,0,double,1
+class,knn.cv,4,0,0,logical,1
+class,knn.cv,5,0,0,logical,1
+class,lvq1,-1,0,0,list<class<`matrix`> | class<`factor`>>,1
+class,lvq1,0,0,0,class<`matrix`>,1
+class,lvq1,1,0,0,class<`factor`>,1
+class,lvq1,2,0,0,list<class<`matrix`> | class<`factor`>>,1
+class,lvq1,3,0,0,double,1
+class,lvq1,4,0,0,double,1
+class,lvq2,-1,0,0,list<class<`matrix`> | class<`factor`>>,1
+class,lvq2,0,0,0,class<`matrix`>,1
+class,lvq2,1,0,0,class<`factor`>,1
+class,lvq2,2,0,0,list<class<`matrix`> | class<`factor`>>,1
+class,lvq2,3,0,0,double,1
+class,lvq2,4,0,0,double,1
+class,lvq2,5,0,0,double,1
+class,lvq3,-1,0,0,list<class<`matrix`> | class<`factor`>>,1
+class,lvq3,0,0,0,class<`matrix`>,1
+class,lvq3,1,0,0,class<`factor`>,1
+class,lvq3,2,0,0,list<class<`matrix`> | class<`factor`>>,1
+class,lvq3,3,0,0,double,1
+class,lvq3,4,0,0,double,1
+class,lvq3,5,0,0,double,1
+class,lvq3,6,0,0,double,1
+class,lvqinit,-1,0,0,list<class<`matrix`> | class<`factor`>>,1
+class,lvqinit,0,0,0,class<`matrix`>,1
+class,lvqinit,1,0,0,class<`factor`>,1
+class,lvqinit,2,0,0,double,1
+class,lvqinit,3,0,0,any,1
+class,lvqinit,4,0,0,double,1
+class,lvqtest,-1,0,0,class<`factor`>,1
+class,lvqtest,0,0,0,list<class<`matrix`> | class<`factor`>>,1
+class,lvqtest,1,0,0,class<`matrix`>,1
+class,multiedit,-1,0,0,integer[],1
+class,multiedit,0,0,0,class<`matrix`>,1
+class,multiedit,1,0,0,class<`factor`>,1
+class,multiedit,2,0,0,double,1
+class,multiedit,3,0,0,double,1
+class,multiedit,4,0,0,double,1
+class,multiedit,5,0,0,logical,1
+class,olvq1,-1,0,0,list<class<`matrix`> | class<`factor`>>,1
+class,olvq1,0,0,0,class<`matrix`>,1
+class,olvq1,1,0,0,class<`factor`>,1
+class,olvq1,2,0,0,list<class<`matrix`> | class<`factor`>>,1
+class,olvq1,3,0,0,double,1
+class,olvq1,4,0,0,double,1
+class,plot.SOM,-1,0,0,null,1
+class,plot.SOM,0,0,0,class<`SOM`>,1
+class,plot.SOM,1,0,0,...,1
+class,plot.somgrid,-1,0,0,null,1
+class,plot.somgrid,0,0,0,class<`somgrid`>,1
+class,plot.somgrid,1,0,0,character,1
+class,plot.somgrid,2,0,0,...,1
+class,reduce.nn,-1,0,0,integer[],1
+class,reduce.nn,0,0,0,class<`matrix`>,1
+class,reduce.nn,1,0,0,integer[],1
+class,reduce.nn,2,0,0,class<`factor`>,1
+class,SOM,-1,0,0,class<`SOM`>,1
+class,SOM,0,0,0,class<`data.frame`>,1
+class,SOM,1,0,0,class<`somgrid`>,1
+class,SOM,2,0,0,double,1
+class,SOM,3,0,0,double[],1
+class,SOM,3,0,1,list<double[]>,1
+class,SOM,4,0,0,double[],1
+class,SOM,4,0,1,list<double[]>,1
+class,SOM,5,0,0,any,1
+class,somgrid,-1,0,0,class<`somgrid`>,1
+class,somgrid,0,0,0,double,1
+class,somgrid,1,0,0,double,1
+class,somgrid,2,0,0,character,1
+classInt,classIntervals,-1,0,0,class<`classIntervals`>,1
+classInt,classIntervals,0,0,0,"class<`POSIXct`, `POSIXt`>",1
+classInt,classIntervals,0,0,1,double[],1
+classInt,classIntervals,0,0,2,class<`units`>,1
+classInt,classIntervals,1,0,0,any,1
+classInt,classIntervals,2,0,0,character,1
+classInt,classIntervals,3,0,0,double,1
+classInt,classIntervals,4,0,0,...,1
+classInt,classIntervals,5,0,0,character[],1
+classInt,classIntervals,6,0,0,null,1
+classInt,classIntervals,6,0,1,double,1
+classInt,classIntervals,7,0,0,logical,1
+classInt,classIntervals,8,0,0,logical,1
+classInt,classIntervals,9,0,0,integer,1
+classInt,classIntervals,10,0,0,double,1
+classInt,classIntervals,11,0,0,any,1
+classInt,findColours,-1,0,0,character[],1
+classInt,findColours,0,0,0,class<`classIntervals`>,1
+classInt,findColours,1,0,0,character[],1
+classInt,findColours,2,0,0,character,1
+classInt,findColours,3,0,0,character,1
+classInt,findColours,4,0,0,character,1
+classInt,findColours,5,0,0,any,1
+classInt,findColours,6,0,0,logical,1
+classInt,findCols,-1,0,0,double[],1
+classInt,findCols,0,0,0,class<`classIntervals`>,1
+classInt,fish,-1,0,0,class<`matrix`>,1
+classInt,fish,0,0,0,class<`units`>,1
+classInt,fish,0,0,1,double[],1
+classInt,fish,1,0,0,integer,1
+classInt,getBclustClassIntervals,-1,0,0,class<`classIntervals`>,1
+classInt,getBclustClassIntervals,0,0,0,class<`classIntervals`>,1
+classInt,getBclustClassIntervals,1,0,0,double,1
+classInt,getHclustClassIntervals,-1,0,0,class<`classIntervals`>,1
+classInt,getHclustClassIntervals,0,0,0,class<`classIntervals`>,1
+classInt,getHclustClassIntervals,1,0,0,double,1
+classInt,gvf,-1,0,0,double,1
+classInt,gvf,0,0,0,double[],1
+classInt,gvf,1,0,0,integer[],1
+classInt,jenks.tests,-1,0,0,double[],1
+classInt,jenks.tests,0,0,0,class<`classIntervals`>,1
+classInt,jenks.tests,1,0,0,double[],1
+classInt,logLik.classIntervals,-1,0,0,class<`logLik`>,1
+classInt,logLik.classIntervals,0,0,0,class<`classIntervals`>,1
+classInt,logLik.classIntervals,1,0,0,...,1
+classInt,nPartitions,-1,0,0,double,1
+classInt,nPartitions,0,0,0,class<`classIntervals`>,1
+classInt,oai,-1,0,0,double,1
+classInt,oai,0,0,0,double[],1
+classInt,oai,1,0,0,integer[],1
+classInt,oai,2,0,0,double[],1
+classInt,plot.classIntervals,-1,0,0,null,1
+classInt,plot.classIntervals,0,0,0,class<`classIntervals`>,1
+classInt,plot.classIntervals,1,0,0,character[],1
+classInt,plot.classIntervals,2,0,0,...,1
+classInt,print.classIntervals,-1,0,0,class<`table`>,1
+classInt,print.classIntervals,0,0,0,class<`classIntervals`>,1
+classInt,print.classIntervals,1,0,0,integer,1
+classInt,print.classIntervals,2,0,0,...,1
+classInt,print.classIntervals,3,0,0,character,1
+classInt,print.classIntervals,4,0,0,character,1
+classInt,print.classIntervals,5,0,0,character,1
+classInt,print.classIntervals,6,0,0,logical,1
+classInt,print.classIntervals,7,0,0,logical,1
+classInt,.rbrks,-1,0,0,double[],1
+classInt,.rbrks,0,0,0,double[],1
+classInt,roundEndpoint,-1,0,0,character,1
+classInt,roundEndpoint,0,0,0,double,1
+classInt,roundEndpoint,1,0,0,character,1
+classInt,roundEndpoint,2,0,0,double,1
+classInt,roundEndpoint,2,0,1,null,1
+classInt,tableClassIntervals,-1,0,0,class<`table`>,1
+classInt,tableClassIntervals,0,0,0,double[],1
+classInt,tableClassIntervals,1,0,0,double[],1
+classInt,tableClassIntervals,2,0,0,any,1
+classInt,tableClassIntervals,3,0,0,any,1
+classInt,tableClassIntervals,4,0,0,any,1
+classInt,tableClassIntervals,5,0,0,any,1
+classInt,tableClassIntervals,6,0,0,logical,1
+classInt,tableClassIntervals,7,0,0,character,1
+classInt,tableClassIntervals,7,0,1,null,1
+classInt,tableClassIntervals,8,0,0,double,1
+classInt,tableClassIntervals,8,0,1,null,1
+classInt,tableClassIntervals,9,0,0,logical,1
+classInt,tableClassIntervals,10,0,0,any,1
+classInt,tai,-1,0,0,double,1
+classInt,tai,0,0,0,double[],1
+classInt,tai,1,0,0,integer[],1
+cli,%||%,-1,0,0,character[],1
+cli,%||%,-1,0,1,class<`cliapp`>,1
+cli,%||%,-1,0,2,class<`cli_glue_delay`>,1
+cli,%||%,-1,0,3,double,1
+cli,%||%,-1,0,4,list<any>,1
+cli,%||%,-1,0,5,null,1
+cli,%||%,0,0,0,character[],1
+cli,%||%,0,0,1,null,1
+cli,%||%,0,0,2,class<`cliapp`>,1
+cli,%||%,0,0,3,double,1
+cli,%||%,0,0,4,list<any>,1
+cli,%||%,1,0,0,any,1
+cli,add_child,-1,0,0,list<list<character[] | null>>,1
+cli,add_child,-1,0,1,list<list<character[] | null | character[]>>,1
+cli,add_child,-1,0,2,list<list<character[] | null | character>>,1
+cli,add_child,-1,0,3,list<list<character[] | null | character[] | character | null>>,1
+cli,add_child,-1,0,4,list<list<character[] | null | character | null>>,1
+cli,add_child,0,0,0,list<any>,1
+cli,add_child,1,0,0,character,1
+cli,add_child,2,0,0,...,1
+cli,add_handler,-1,0,0,list<class<`call`> | environment>,1
+cli,add_handler,0,0,0,environment,1
+cli,add_handler,1,0,0,list<class<`call`> | environment>,1
+cli,add_handler,2,0,0,logical,1
+cli,apply_style,-1,0,0,character[],1
+cli,apply_style,-1,0,1,class<`ansi_string`>,1
+cli,apply_style,0,0,0,character[],1
+cli,apply_style,0,0,1,class<`ansi_string`>,1
+cli,apply_style,1,0,0,any,1
+cli,apply_style,2,0,0,logical,1
+cli,as.character.cli_no,-1,0,0,character,1
+cli,as.character.cli_no,0,0,0,class<`cli_no`>,1
+cli,as.character.cli_no,1,0,0,...,1
+cli,as.character.cli_noprint,-1,0,0,character,1
+cli,as.character.cli_noprint,0,0,0,class<`cli_noprint`>,1
+cli,as.character.cli_noprint,1,0,0,...,1
+cli,bg_red,-1,0,0,class<`ansi_string`>,1
+cli,bg_red,0,0,0,...,1
+cli,box_chars,-1,0,0,list<character>,1
+cli,box_styles,-1,0,0,class<`matrix`>,1
+cli,boxx,-1,0,0,"class<`boxx`, `character`>",1
+cli,boxx,0,0,0,character[],1
+cli,boxx,0,0,1,class<`ansi_string`>,1
+cli,boxx,1,0,0,character,1
+cli,boxx,2,0,0,double[],1
+cli,boxx,3,0,0,double[],1
+cli,boxx,4,0,0,character[],1
+cli,boxx,5,0,0,null,1
+cli,boxx,6,0,0,null,1
+cli,boxx,6,0,1,character,1
+cli,boxx,6,0,2,class<`ansi_style`>,1
+cli,boxx,7,0,0,null,1
+cli,boxx,7,0,1,character,1
+cli,boxx,7,0,2,class<`ansi_style`>,1
+cli,boxx,8,0,0,character[],1
+cli,boxx,9,0,0,any,1
+cli,builtin_theme,-1,0,0,list<list<any>>,1
+cli,builtin_theme,0,0,0,character,1
+cli,capitalize,-1,0,0,character,1
+cli,capitalize,0,0,0,character,1
+cli,cat_bullet,-1,0,0,null,1
+cli,cat_bullet,0,0,0,...,1
+cli,cat_bullet,1,0,0,null,1
+cli,cat_bullet,2,0,0,null,1
+cli,cat_bullet,3,0,0,character,1
+cli,cat_bullet,4,0,0,character,1
+cli,cat_bullet,4,0,1,null,1
+cli,cat_bullet,5,0,0,"class<`connection`, `terminal`>",1
+cli,cat_line,-1,0,0,null,1
+cli,cat_line,0,0,0,...,1
+cli,cat_line,1,0,0,character,1
+cli,cat_line,1,0,1,null,1
+cli,cat_line,2,0,0,null,1
+cli,cat_line,3,0,0,"class<`connection`, `terminal`>",1
+cli,cat_rule,-1,0,0,null,1
+cli,cat_rule,0,0,0,...,1
+cli,cat_rule,1,0,0,"class<`connection`, `terminal`>",1
+cli,cli_alert,-1,0,0,character,1
+cli,cli_alert,0,0,0,character,1
+cli,cli_alert,1,0,0,null,1
+cli,cli_alert,2,0,0,character,1
+cli,cli_alert,2,0,1,null,1
+cli,cli_alert,3,0,0,logical,1
+cli,cli_alert,4,0,0,environment,1
+cli,cli_alert_danger,-1,0,0,character,1
+cli,cli_alert_danger,0,0,0,character,1
+cli,cli_alert_danger,1,0,0,null,1
+cli,cli_alert_danger,2,0,0,null,1
+cli,cli_alert_danger,3,0,0,logical,1
+cli,cli_alert_danger,4,0,0,environment,1
+cli,cli_alert_info,-1,0,0,character,1
+cli,cli_alert_info,0,0,0,character,1
+cli,cli_alert_info,1,0,0,null,1
+cli,cli_alert_info,2,0,0,null,1
+cli,cli_alert_info,3,0,0,logical,1
+cli,cli_alert_info,4,0,0,environment,1
+cli,cli_alert_success,-1,0,0,character,1
+cli,cli_alert_success,0,0,0,character,1
+cli,cli_alert_success,1,0,0,null,1
+cli,cli_alert_success,2,0,0,null,1
+cli,cli_alert_success,3,0,0,logical,1
+cli,cli_alert_success,4,0,0,environment,1
+cli,cli_alert_warning,-1,0,0,character,1
+cli,cli_alert_warning,0,0,0,character,1
+cli,cli_alert_warning,1,0,0,null,1
+cli,cli_alert_warning,2,0,0,null,1
+cli,cli_alert_warning,3,0,0,logical,1
+cli,cli_alert_warning,4,0,0,environment,1
+cli,cliapp,-1,0,0,class<`cliapp`>,1
+cli,cliapp,0,0,0,null,1
+cli,cliapp,0,0,1,list<list<any>>,1
+cli,cliapp,1,0,0,null,1
+cli,cliapp,2,0,0,character,1
+cli,cliapp,2,0,1,"class<`connection`, `textConnection`>",1
+cli,cli_blockquote,-1,0,0,character,1
+cli,cli_blockquote,0,0,0,character,1
+cli,cli_blockquote,1,0,0,character,1
+cli,cli_blockquote,2,0,0,null,1
+cli,cli_blockquote,3,0,0,null,1
+cli,cli_blockquote,4,0,0,environment,1
+cli,cli_code,-1,0,0,character,1
+cli,cli_code,0,0,0,character[],1
+cli,cli_code,1,0,0,...,1
+cli,cli_code,2,0,0,character,1
+cli,cli_code,3,0,0,logical,1
+cli,cli_code,4,0,0,environment,1
+cli,cli__default_handler,-1,0,0,character,1
+cli,cli__default_handler,-1,0,1,class<`cliapp`>,1
+cli,cli__default_handler,-1,0,2,null,1
+cli,cli__default_handler,0,0,0,"class<`callr_message`, `cli_message`, `condition`>",1
+cli,cli_div,-1,0,0,character,1
+cli,cli_div,0,0,0,null,1
+cli,cli_div,1,0,0,character,1
+cli,cli_div,1,0,1,null,1
+cli,cli_div,2,0,0,null,1
+cli,cli_div,2,0,1,list<list<any>>,1
+cli,cli_div,3,0,0,logical,1
+cli,cli_div,4,0,0,environment,1
+cli,cli_dl,-1,0,0,character,1
+cli,cli_dl,0,0,0,character[],1
+cli,cli_dl,0,0,1,null,1
+cli,cli_dl,1,0,0,null,1
+cli,cli_dl,2,0,0,null,1
+cli,cli_dl,3,0,0,logical,1
+cli,cli_dl,4,0,0,logical,1
+cli,cli_dl,5,0,0,environment,1
+cli,cli_end,-1,0,0,character,1
+cli,cli_end,-1,0,1,null,1
+cli,cli_end,0,0,0,character,1
+cli,cli_end,0,0,1,null,1
+cli,cli_format,-1,0,0,character[],1
+cli,cli_format,-1,0,1,double[],1
+cli,cli_format,0,0,0,character[],1
+cli,cli_format,0,0,1,double[],1
+cli,cli_format,1,0,0,any,1
+cli,cli_format,2,0,0,...,1
+cli,cli_format.character,-1,0,0,character[],1
+cli,cli_format.character,0,0,0,character[],1
+cli,cli_format.character,1,0,0,list<any>,1
+cli,cli_format.character,2,0,0,...,1
+cli,cli_format_method,-1,0,0,character[],1
+cli,cli_format_method,0,0,0,null,1
+cli,cli_format_method,1,0,0,list<list<any>>,1
+cli,cli_format.numeric,-1,0,0,double[],1
+cli,cli_format.numeric,0,0,0,double[],1
+cli,cli_format.numeric,1,0,0,list<any>,1
+cli,cli_format.numeric,2,0,0,...,1
+cli,cli_h1,-1,0,0,character,1
+cli,cli_h1,0,0,0,character,1
+cli,cli_h1,1,0,0,null,1
+cli,cli_h1,2,0,0,null,1
+cli,cli_h1,3,0,0,environment,1
+cli,cli_h2,-1,0,0,character,1
+cli,cli_h2,0,0,0,character,1
+cli,cli_h2,1,0,0,null,1
+cli,cli_h2,2,0,0,null,1
+cli,cli_h2,3,0,0,environment,1
+cli,cli_h3,-1,0,0,character,1
+cli,cli_h3,0,0,0,character,1
+cli,cli_h3,1,0,0,null,1
+cli,cli_h3,2,0,0,null,1
+cli,cli_h3,3,0,0,environment,1
+cli,clii_add_theme,-1,0,0,character,1
+cli,clii_add_theme,0,0,0,class<`cliapp`>,1
+cli,clii_add_theme,1,0,0,null,1
+cli,clii_add_theme,1,0,1,list<list<any>>,1
+cli,clii_alert,-1,0,0,null,1
+cli,clii_alert,0,0,0,class<`cliapp`>,1
+cli,clii_alert,1,0,0,character,1
+cli,clii_alert,2,0,0,class<`cli_glue_delay`>,1
+cli,clii_alert,3,0,0,character,1
+cli,clii_alert,4,0,0,character,1
+cli,clii_alert,4,0,1,null,1
+cli,clii_alert,5,0,0,logical,1
+cli,clii_blockquote,-1,0,0,class<`cliapp`>,1
+cli,clii_blockquote,0,0,0,class<`cliapp`>,1
+cli,clii_blockquote,1,0,0,class<`cli_glue_delay`>,1
+cli,clii_blockquote,2,0,0,class<`cli_glue_delay`>,1
+cli,clii_blockquote,3,0,0,character,1
+cli,clii_blockquote,4,0,0,null,1
+cli,clii__cat,-1,0,0,null,1
+cli,clii__cat,0,0,0,class<`cliapp`>,1
+cli,clii__cat,1,0,0,character,1
+cli,clii__cat_ln,-1,0,0,null,1
+cli,clii__cat_ln,0,0,0,class<`cliapp`>,1
+cli,clii__cat_ln,1,0,0,character[],1
+cli,clii__cat_ln,1,0,1,"class<`character`, `rule`>",1
+cli,clii__cat_ln,2,0,0,double,1
+cli,clii__cat_ln,3,0,0,double,1
+cli,clii__container_end,-1,0,0,class<`cliapp`>,1
+cli,clii__container_end,0,0,0,class<`cliapp`>,1
+cli,clii__container_end,1,0,0,character,1
+cli,clii__container_end,1,0,1,null,1
+cli,clii__container_start,-1,0,0,character,1
+cli,clii__container_start,0,0,0,class<`cliapp`>,1
+cli,clii__container_start,1,0,0,character,1
+cli,clii__container_start,2,0,0,character,1
+cli,clii__container_start,2,0,1,null,1
+cli,clii__container_start,3,0,0,character,1
+cli,clii__container_start,3,0,1,null,1
+cli,clii__container_start,4,0,0,character,1
+cli,clii__container_start,4,0,1,null,1
+cli,clii_div,-1,0,0,character,1
+cli,clii_div,0,0,0,class<`cliapp`>,1
+cli,clii_div,1,0,0,character,1
+cli,clii_div,2,0,0,character,1
+cli,clii_div,2,0,1,null,1
+cli,clii_div,3,0,0,null,1
+cli,clii_div,3,0,1,list<list<any>>,1
+cli,clii_dl,-1,0,0,character,1
+cli,clii_dl,0,0,0,class<`cliapp`>,1
+cli,clii_dl,1,0,0,list<any>,1
+cli,clii_dl,2,0,0,character,1
+cli,clii_dl,3,0,0,null,1
+cli,clii_dl,4,0,0,any,1
+cli,clii_end,-1,0,0,class<`cliapp`>,1
+cli,clii_end,0,0,0,class<`cliapp`>,1
+cli,clii_end,1,0,0,character,1
+cli,clii_end,1,0,1,null,1
+cli,clii__get_width,-1,0,0,double,1
+cli,clii__get_width,0,0,0,class<`cliapp`>,1
+cli,clii__get_width,1,0,0,double,1
+cli,clii_h1,-1,0,0,class<`cliapp`>,1
+cli,clii_h1,0,0,0,class<`cliapp`>,1
+cli,clii_h1,1,0,0,class<`cli_glue_delay`>,1
+cli,clii_h1,2,0,0,any,1
+cli,clii_h1,3,0,0,null,1
+cli,clii_h2,-1,0,0,class<`cliapp`>,1
+cli,clii_h2,0,0,0,class<`cliapp`>,1
+cli,clii_h2,1,0,0,class<`cli_glue_delay`>,1
+cli,clii_h2,2,0,0,any,1
+cli,clii_h2,3,0,0,null,1
+cli,clii_h3,-1,0,0,class<`cliapp`>,1
+cli,clii_h3,0,0,0,class<`cliapp`>,1
+cli,clii_h3,1,0,0,class<`cli_glue_delay`>,1
+cli,clii_h3,2,0,0,any,1
+cli,clii_h3,3,0,0,null,1
+cli,clii__heading,-1,0,0,class<`cliapp`>,1
+cli,clii__heading,0,0,0,class<`cliapp`>,1
+cli,clii__heading,1,0,0,character,1
+cli,clii__heading,2,0,0,class<`cli_glue_delay`>,1
+cli,clii__heading,3,0,0,any,1
+cli,clii__heading,4,0,0,null,1
+cli,clii_init,-1,0,0,class<`cliapp`>,1
+cli,clii_init,0,0,0,class<`cliapp`>,1
+cli,clii_init,1,0,0,null,1
+cli,clii_init,1,0,1,list<list<any>>,1
+cli,clii_init,2,0,0,null,1
+cli,clii_init,3,0,0,character,1
+cli,clii_init,3,0,1,"class<`connection`, `textConnection`>",1
+cli,clii__inline,-1,0,0,character,1
+cli,clii__inline,0,0,0,class<`cliapp`>,1
+cli,clii__inline,1,0,0,class<`cli_glue_delay`>,1
+cli,clii__inline,1,0,1,null,1
+cli,clii__inline,2,0,0,null,1
+cli,clii__inline,2,0,1,list<class<`cli_glue_delay`>>,1
+cli,clii__item_text,-1,0,0,class<`cliapp`>,1
+cli,clii__item_text,0,0,0,class<`cliapp`>,1
+cli,clii__item_text,1,0,0,character,1
+cli,clii__item_text,2,0,0,any,1
+cli,clii__item_text,3,0,0,character,1
+cli,clii__item_text,4,0,0,class<`cli_glue_delay`>,1
+cli,clii__item_text,5,0,0,null,1
+cli,clii_li,-1,0,0,character,1
+cli,clii_li,0,0,0,class<`cliapp`>,1
+cli,clii_li,1,0,0,list<any>,1
+cli,clii_li,2,0,0,character,1
+cli,clii_li,2,0,1,null,1
+cli,clii_li,3,0,0,null,1
+cli,clii__message,-1,0,0,null,1
+cli,clii__message,0,0,0,...,1
+cli,clii__message,1,0,0,null,1
+cli,clii__message,2,0,0,logical,1
+cli,clii__message,3,0,0,character,1
+cli,clii__message,3,0,1,"class<`connection`, `textConnection`>",1
+cli,clii_ol,-1,0,0,character,1
+cli,clii_ol,0,0,0,class<`cliapp`>,1
+cli,clii_ol,1,0,0,list<any>,1
+cli,clii_ol,2,0,0,character,1
+cli,clii_ol,3,0,0,null,1
+cli,clii_ol,4,0,0,any,1
+cli,clii_par,-1,0,0,character,1
+cli,clii_par,0,0,0,class<`cliapp`>,1
+cli,clii_par,1,0,0,character,1
+cli,clii_par,2,0,0,character,1
+cli,clii_par,2,0,1,null,1
+cli,clii_rule,-1,0,0,null,1
+cli,clii_rule,0,0,0,class<`cliapp`>,1
+cli,clii_rule,1,0,0,class<`cli_glue_delay`>,1
+cli,clii_rule,2,0,0,class<`cli_glue_delay`>,1
+cli,clii_rule,3,0,0,class<`cli_glue_delay`>,1
+cli,clii_rule,4,0,0,character,1
+cli,clii_status,-1,0,0,null,1
+cli,clii_status,0,0,0,class<`cliapp`>,1
+cli,clii_status,1,0,0,character,1
+cli,clii_status,2,0,0,class<`cli_glue_delay`>,1
+cli,clii_status,3,0,0,class<`cli_glue_delay`>,1
+cli,clii_status,4,0,0,class<`cli_glue_delay`>,1
+cli,clii_status,5,0,0,logical,1
+cli,clii_status,6,0,0,character,1
+cli,clii_status_clear,-1,0,0,null,1
+cli,clii_status_clear,0,0,0,class<`cliapp`>,1
+cli,clii_status_clear,1,0,0,character,1
+cli,clii_status_clear,1,0,1,null,1
+cli,clii_status_clear,2,0,0,any,1
+cli,clii_status_clear,3,0,0,any,1
+cli,clii_status_clear,4,0,0,any,1
+cli,clii_status_update,-1,0,0,null,1
+cli,clii_status_update,0,0,0,class<`cliapp`>,1
+cli,clii_status_update,1,0,0,character,1
+cli,clii_status_update,2,0,0,class<`cli_glue_delay`>,1
+cli,clii_status_update,3,0,0,null,1
+cli,clii_status_update,4,0,0,null,1
+cli,clii_text,-1,0,0,class<`cliapp`>,1
+cli,clii_text,0,0,0,class<`cliapp`>,1
+cli,clii_text,1,0,0,class<`cli_glue_delay`>,1
+cli,clii_ul,-1,0,0,character,1
+cli,clii_ul,0,0,0,class<`cliapp`>,1
+cli,clii_ul,1,0,0,list<any>,1
+cli,clii_ul,2,0,0,character,1
+cli,clii_ul,3,0,0,null,1
+cli,clii_ul,4,0,0,any,1
+cli,clii_verbatim,-1,0,0,class<`cliapp`>,1
+cli,clii_verbatim,0,0,0,class<`cliapp`>,1
+cli,clii_verbatim,1,0,0,...,1
+cli,clii_verbatim,2,0,0,environment,1
+cli,clii__vspace,-1,0,0,double,1
+cli,clii__vspace,-1,0,1,null,1
+cli,clii__vspace,0,0,0,class<`cliapp`>,1
+cli,clii__vspace,1,0,0,double,1
+cli,clii__xtext,-1,0,0,class<`cliapp`>,1
+cli,clii__xtext,0,0,0,class<`cliapp`>,1
+cli,clii__xtext,1,0,0,class<`cli_glue_delay`>,1
+cli,clii__xtext,1,0,1,null,1
+cli,clii__xtext,2,0,0,null,1
+cli,clii__xtext,2,0,1,list<class<`cli_glue_delay`>>,1
+cli,clii__xtext,3,0,0,double,1
+cli,clii__xtext,4,0,0,double,1
+cli,cli_li,-1,0,0,character,1
+cli,cli_li,0,0,0,character,1
+cli,cli_li,0,0,1,null,1
+cli,cli_li,1,0,0,null,1
+cli,cli_li,2,0,0,null,1
+cli,cli_li,3,0,0,logical,1
+cli,cli_li,4,0,0,environment,1
+cli,cli__message,-1,0,0,character,1
+cli,cli__message,-1,0,1,null,1
+cli,cli__message,0,0,0,character,1
+cli,cli__message,1,0,0,list<any>,1
+cli,cli__message,2,0,0,logical,1
+cli,cli__message,3,0,0,null,1
+cli,cli__message,3,0,1,environment,1
+cli,cli_ol,-1,0,0,character,1
+cli,cli_ol,0,0,0,character[],1
+cli,cli_ol,0,0,1,null,1
+cli,cli_ol,1,0,0,null,1
+cli,cli_ol,2,0,0,null,1
+cli,cli_ol,3,0,0,logical,1
+cli,cli_ol,4,0,0,logical,1
+cli,cli_ol,5,0,0,environment,1
+cli,cli_output_connection,-1,0,0,"class<`connection`, `terminal`>",1
+cli,cli_par,-1,0,0,character,1
+cli,cli_par,0,0,0,null,1
+cli,cli_par,1,0,0,character,1
+cli,cli_par,1,0,1,null,1
+cli,cli_par,2,0,0,logical,1
+cli,cli_par,3,0,0,environment,1
+cli,cli_process_done,-1,0,0,null,1
+cli,cli_process_done,0,0,0,null,1
+cli,cli_process_done,1,0,0,null,1
+cli,cli_process_done,2,0,0,any,1
+cli,cli_process_done,3,0,0,character,1
+cli,cli_process_failed,-1,0,0,null,1
+cli,cli_process_failed,0,0,0,null,1
+cli,cli_process_failed,1,0,0,null,1
+cli,cli_process_failed,2,0,0,null,1
+cli,cli_process_failed,3,0,0,any,1
+cli,cli_process_failed,4,0,0,character,1
+cli,cli_process_start,-1,0,0,character,1
+cli,cli_process_start,0,0,0,character,1
+cli,cli_process_start,1,0,0,character,1
+cli,cli_process_start,2,0,0,character,1
+cli,cli_process_start,3,0,0,character[],1
+cli,cli_process_start,4,0,0,character,1
+cli,cli_process_start,5,0,0,character,1
+cli,cli_process_start,6,0,0,character,1
+cli,cli_process_start,7,0,0,logical,1
+cli,cli_process_start,8,0,0,environment,1
+cli,cli_rule,-1,0,0,character,1
+cli,cli_rule,0,0,0,character,1
+cli,cli_rule,1,0,0,character,1
+cli,cli_rule,2,0,0,character,1
+cli,cli_rule,3,0,0,null,1
+cli,cli_rule,4,0,0,environment,1
+cli,cli_server_default,-1,0,0,character,1
+cli,cli_server_default,-1,0,1,class<`cliapp`>,1
+cli,cli_server_default,-1,0,2,null,1
+cli,cli_server_default,0,0,0,"class<`callr_message`, `cli_message`, `condition`>",1
+cli,cli_server_default_safe,-1,0,0,character,1
+cli,cli_server_default_safe,-1,0,1,class<`cliapp`>,1
+cli,cli_server_default_safe,-1,0,2,null,1
+cli,cli_server_default_safe,0,0,0,"class<`callr_message`, `cli_message`, `condition`>",1
+cli,cli_sitrep,-1,0,0,class<`cli_sitrep`>,1
+cli,cli_status,-1,0,0,character,1
+cli,cli_status,0,0,0,character,1
+cli,cli_status,1,0,0,character,1
+cli,cli_status,2,0,0,character,1
+cli,cli_status,3,0,0,logical,1
+cli,cli_status,4,0,0,logical,1
+cli,cli_status,5,0,0,environment,1
+cli,cli_status,6,0,0,character,1
+cli,cli_status_clear,-1,0,0,character,1
+cli,cli_status_clear,-1,0,1,null,1
+cli,cli_status_clear,0,0,0,character,1
+cli,cli_status_clear,0,0,1,null,1
+cli,cli_status_clear,1,0,0,character,1
+cli,cli_status_clear,2,0,0,null,1
+cli,cli_status_clear,3,0,0,null,1
+cli,cli_status_clear,4,0,0,any,1
+cli,cli_text,-1,0,0,null,1
+cli,cli_text,0,0,0,...,1
+cli,cli_text,1,0,0,environment,1
+cli,cli_ul,-1,0,0,character,1
+cli,cli_ul,0,0,0,character[],1
+cli,cli_ul,0,0,1,null,1
+cli,cli_ul,1,0,0,null,1
+cli,cli_ul,2,0,0,null,1
+cli,cli_ul,3,0,0,logical,1
+cli,cli_ul,4,0,0,logical,1
+cli,cli_ul,5,0,0,environment,1
+cli,cli_verbatim,-1,0,0,null,1
+cli,cli_verbatim,0,0,0,...,1
+cli,cli_verbatim,1,0,0,environment,1
+cli,col_blue,-1,0,0,class<`ansi_string`>,1
+cli,col_blue,0,0,0,...,1
+cli,col_cyan,-1,0,0,class<`ansi_string`>,1
+cli,col_cyan,0,0,0,...,1
+cli,col_green,-1,0,0,class<`ansi_string`>,1
+cli,col_green,0,0,0,...,1
+cli,col_red,-1,0,0,class<`ansi_string`>,1
+cli,col_red,0,0,0,...,1
+cli,col_white,-1,0,0,class<`ansi_string`>,1
+cli,col_white,0,0,0,...,1
+cli,combine_ansi_styles,-1,0,0,class<`ansi_style`>,1
+cli,combine_ansi_styles,0,0,0,...,1
+cli,console_width,-1,0,0,integer,1
+cli,cray_wrapper_fun,-1,0,0,class<`ansi_style`>,1
+cli,cray_wrapper_fun,0,0,0,class<`crayon`>,1
+cli,create_formatter,-1,0,0,list<any>,1
+cli,create_formatter,0,0,0,list<any>,1
+cli,dedent,-1,0,0,character,1
+cli,dedent,0,0,0,character,1
+cli,dedent,1,0,0,double,1
+cli,default_app,-1,0,0,class<`cliapp`>,1
+cli,default_app,-1,0,1,null,1
+cli,defer,-1,0,0,list<class<`call`> | environment>,1
+cli,defer,0,0,0,any,1
+cli,defer,1,0,0,environment,1
+cli,defer,2,0,0,character,1
+cli,detect_dark_theme,-1,0,0,logical,1
+cli,detect_dark_theme,0,0,0,character,1
+cli,format_code,-1,0,0,class<`function`>,1
+cli,format_code,0,0,0,any,1
+cli,format_r_code,-1,0,0,class<`function`>,1
+cli,format_r_code,0,0,0,any,1
+cli,get_active_symbol_set,-1,0,0,character,1
+cli,get_handlers,-1,0,0,list<any>,1
+cli,get_handlers,0,0,0,environment,1
+cli,get_line_char,-1,0,0,character,1
+cli,get_line_char,0,0,0,character,1
+cli,get_line_char,0,0,1,class<`ansi_string`>,1
+cli,get_line_char,0,0,2,double,1
+cli,get_real_output,-1,0,0,"class<`connection`, `terminal`>",1
+cli,get_real_output,-1,0,1,"class<`connection`, `textConnection`>",1
+cli,get_real_output,0,0,0,character,1
+cli,get_real_output,0,0,1,"class<`connection`, `textConnection`>",1
+cli,get_spinner,-1,0,0,list<character | integer | class<`AsIs`>>,1
+cli,get_spinner,0,0,0,character,1
+cli,get_spinner,0,0,1,null,1
+cli,glue_cmd,-1,0,0,class<`cli_glue_delay`>,1
+cli,glue_cmd,0,0,0,...,1
+cli,glue_cmd,1,0,0,environment,1
+cli,glue_delay,-1,0,0,class<`cli_glue_delay`>,1
+cli,glue_delay,0,0,0,character,1
+cli,glue_delay,0,0,1,"class<`character`, `glue`>",1
+cli,glue_delay,1,0,0,null,1
+cli,glue_delay,1,0,1,environment,1
+cli,inline_collapse,-1,0,0,"class<`character`, `glue`>",1
+cli,inline_collapse,0,0,0,character[],1
+cli,inline_collapse,0,0,1,class<`cli_no`>,1
+cli,inline_collapse,0,0,2,class<`cli_noprint`>,1
+cli,inline_collapse,0,0,3,double,1
+cli,inline_generic,-1,0,0,character[],1
+cli,inline_generic,0,0,0,any,1
+cli,inline_generic,1,0,0,any,1
+cli,inline_generic,2,0,0,"class<`character`, `glue`>",1
+cli,inline_generic,3,0,0,list<any>,1
+cli,inline_regex,-1,0,0,character,1
+cli,is_ansi_tty,-1,0,0,logical,1
+cli,is_ansi_tty,0,0,0,"class<`connection`, `terminal`>",1
+cli,is_border_style,-1,0,0,logical,1
+cli,is_border_style,0,0,0,character,1
+cli,is_col,-1,0,0,logical,1
+cli,is_col,0,0,0,character,1
+cli,is_col,0,0,1,null,1
+cli,is_count,-1,0,0,logical,1
+cli,is_count,0,0,0,integer,1
+cli,is_dynamic_tty,-1,0,0,logical,1
+cli,is_dynamic_tty,0,0,0,"class<`connection`, `terminal`>",1
+cli,is_interactive,-1,0,0,logical,1
+cli,is_iterm,-1,0,0,logical,1
+cli,is_latex_output,-1,0,0,logical,1
+cli,is_padding_or_margin,-1,0,0,logical,1
+cli,is_padding_or_margin,0,0,0,double[],1
+cli,is_rapp_stdx,-1,0,0,logical,1
+cli,is_rapp_stdx,0,0,0,any,1
+cli,is_rkward_stdx,-1,0,0,logical,1
+cli,is_rkward_stdx,0,0,0,any,1
+cli,is_rstudio_dynamic_tty,-1,0,0,logical,1
+cli,is_rstudio_dynamic_tty,0,0,0,any,1
+cli,is_string,-1,0,0,logical,1
+cli,is_string,0,0,0,character,1
+cli,is_string,0,0,1,class<`ansi_string`>,1
+cli,is_string,0,0,2,double,1
+cli,is_utf8_output,-1,0,0,logical,1
+cli,last,-1,0,0,null,1
+cli,last,-1,0,1,list<any>,1
+cli,last,0,0,0,null,1
+cli,last,0,0,1,list<list<any>>,1
+cli,list_border_styles,-1,0,0,character[],1
+cli,list_spinners,-1,0,0,character[],1
+cli,lorem_paragraph,-1,0,0,character,1
+cli,lorem_paragraph,0,0,0,integer[],1
+cli,lorem_paragraph,1,0,0,integer[],1
+cli,lorem_sentence,-1,0,0,character,1
+cli,lorem_sentence,0,0,0,integer[],1
+cli,make_ansi_style,-1,0,0,class<`ansi_string`>,1
+cli,make_ansi_style,0,0,0,...,1
+cli,make_ansi_style,-1,1,0,class<`ansi_style`>,1
+cli,make_ansi_style,0,1,0,...,1
+cli,make_ansi_style,1,1,0,logical,1
+cli,make_ansi_style,2,1,0,logical,1
+cli,make_ansi_style,3,1,0,double,1
+cli,make_cmd_transformer,-1,0,0,class<`function`>,1
+cli,make_cmd_transformer,0,0,0,environment,1
+cli,make_line,-1,0,0,character,1
+cli,make_line,-1,0,1,class<`ansi_string`>,1
+cli,make_line,0,0,0,double,1
+cli,make_line,1,0,0,character,1
+cli,make_line,2,0,0,null,1
+cli,make_line,2,0,1,character,1
+cli,make_quantity,-1,0,0,integer,1
+cli,make_quantity,-1,0,1,null,1
+cli,make_quantity,0,0,0,character[],1
+cli,make_quantity,0,0,1,class<`cli_no`>,1
+cli,make_quantity,0,0,2,class<`cli_noprint`>,1
+cli,make_quantity,0,0,3,double,1
+cli,make_quantity,0,0,4,null,1
+cli,make_space,-1,0,0,character[],1
+cli,make_space,0,0,0,double[],1
+cli,match_selector,-1,0,0,logical,1
+cli,match_selector,0,0,0,list<list<character[]>>,1
+cli,match_selector,1,0,0,list<list<character[] | null>>,1
+cli,match_selector,1,0,1,list<list<character[] | null | character[]>>,1
+cli,match_selector,1,0,2,list<list<character[] | null | character>>,1
+cli,match_selector,1,0,3,list<list<character[] | null | character[] | character | null>>,1
+cli,match_selector,1,0,4,list<list<character[] | null | character | null>>,1
+cli,match_selector_node,-1,0,0,logical,1
+cli,match_selector_node,0,0,0,list<character[]>,1
+cli,match_selector_node,1,0,0,list<character[]>,1
+cli,match_selector_node,1,0,1,list<character[] | null>,1
+cli,match_selector_node,1,0,2,list<character | null>,1
+cli,merge_embedded_styles,-1,0,0,list<any>,1
+cli,merge_embedded_styles,0,0,0,list<any>,1
+cli,merge_embedded_styles,1,0,0,list<any>,1
+cli,na.omit,-1,0,0,integer[],1
+cli,na.omit,0,0,0,null,1
+cli,nchar_fixed,-1,0,0,integer,1
+cli,nchar_fixed,0,0,0,character,1
+cli,nchar_fixed,1,0,0,character,1
+cli,nchar_fixed,2,0,0,...,1
+cli,new_class,-1,0,0,class<`cliapp`>,1
+cli,new_class,0,0,0,character,1
+cli,new_class,1,0,0,...,1
+cli,new_uuid,-1,0,0,character,1
+cli,no,-1,0,0,class<`cli_no`>,1
+cli,no,0,0,0,double,1
+cli,parse_plural,-1,0,0,character,1
+cli,parse_plural,0,0,0,character,1
+cli,parse_plural,1,0,0,environment,1
+cli,post_process_plurals,-1,0,0,"class<`character`, `glue`>",1
+cli,post_process_plurals,0,0,0,"class<`character`, `glue`>",1
+cli,post_process_plurals,1,0,0,environment,1
+cli,process_plural,-1,0,0,character,1
+cli,process_plural,0,0,0,integer,1
+cli,process_plural,1,0,0,character,1
+cli,push,-1,0,0,list<list<any>>,1
+cli,push,0,0,0,list<any>,1
+cli,push,0,0,1,null,1
+cli,push,1,0,0,list<any>,1
+cli,push,2,0,0,null,1
+cli,push,2,0,1,character,1
+cli,qty,-1,0,0,class<`cli_noprint`>,1
+cli,qty,0,0,0,double,1
+cli,random_id,-1,0,0,character,1
+cli,rule,-1,0,0,"class<`character`, `rule`>",1
+cli,rule,0,0,0,character,1
+cli,rule,1,0,0,character,1
+cli,rule,1,0,1,class<`ansi_string`>,1
+cli,rule,2,0,0,character,1
+cli,rule,3,0,0,character,1
+cli,rule,3,0,1,class<`ansi_string`>,1
+cli,rule,3,0,2,double,1
+cli,rule,4,0,0,null,1
+cli,rule,5,0,0,null,1
+cli,rule,5,0,1,character,1
+cli,rule,6,0,0,null,1
+cli,rule,7,0,0,integer,1
+cli,rule_center,-1,0,0,character,1
+cli,rule_center,0,0,0,list<character | null | integer>,1
+cli,rule_left,-1,0,0,character,1
+cli,rule_left,0,0,0,list<character | null | integer>,1
+cli,rule_left_right,-1,0,0,character,1
+cli,rule_left_right,0,0,0,list<character | null | integer>,1
+cli,rule_line,-1,0,0,character,1
+cli,rule_line,0,0,0,list<character | null | integer>,1
+cli,set_handlers,-1,0,0,null,1
+cli,set_handlers,0,0,0,environment,1
+cli,set_handlers,1,0,0,list<list<class<`call`> | environment>>,1
+cli,setup_unicode_width_fix,-1,0,0,character,1
+cli,simple_theme,-1,0,0,list<list<any>>,1
+cli,simple_theme,0,0,0,character,1
+cli,simple_theme_code,-1,0,0,list<character>,1
+cli,simple_theme_code,0,0,0,logical,1
+cli,simple_theme_emph,-1,0,0,list<character>,1
+cli,simple_theme_file,-1,0,0,list<character>,1
+cli,simple_theme_url,-1,0,0,list<character>,1
+cli,start_app,-1,0,0,class<`cliapp`>,1
+cli,start_app,0,0,0,null,1
+cli,start_app,0,0,1,list<list<any>>,1
+cli,start_app,1,0,0,character[],1
+cli,start_app,1,0,1,"class<`connection`, `textConnection`>",1
+cli,start_app,2,0,0,logical,1
+cli,start_app,3,0,0,any,1
+cli,stop_app,-1,0,0,null,1
+cli,stop_app,0,0,0,class<`cliapp`>,1
+cli,strrep,-1,0,0,character[],1
+cli,strrep,0,0,0,character,1
+cli,strrep,1,0,0,double[],1
+cli,str_tail,-1,0,0,character[],1
+cli,str_tail,0,0,0,character[],1
+cli,strwrap2_fixed,-1,0,0,character,1
+cli,strwrap2_fixed,0,0,0,character,1
+cli,strwrap2_fixed,1,0,0,...,1
+cli,strwrap_fixed,-1,0,0,character[],1
+cli,strwrap_fixed,0,0,0,character,1
+cli,strwrap_fixed,1,0,0,...,1
+cli,style_bold,-1,0,0,class<`ansi_string`>,1
+cli,style_bold,0,0,0,...,1
+cli,style_dim,-1,0,0,class<`ansi_string`>,1
+cli,style_dim,0,0,0,...,1
+cli,style_italic,-1,0,0,class<`ansi_string`>,1
+cli,style_italic,0,0,0,...,1
+cli,style_underline,-1,0,0,class<`ansi_string`>,1
+cli,style_underline,0,0,0,...,1
+cli,theme_code,-1,0,0,list<character>,1
+cli,theme_code,0,0,0,logical,1
+cli,theme_code_tick,-1,0,0,list<character>,1
+cli,theme_code_tick,0,0,0,logical,1
+cli,theme_create,-1,0,0,class<`data.frame`>,1
+cli,theme_create,0,0,0,null,1
+cli,theme_create,0,0,1,list<list<any>>,1
+cli,theme_function,-1,0,0,list<character>,1
+cli,theme_function,0,0,0,logical,1
+cli,tree,-1,0,0,"class<`character`, `tree`>",1
+cli,tree,0,0,0,class<`data.frame`>,1
+cli,tree,1,0,0,character,1
+cli,tree,2,0,0,null,1
+cli,tree,3,0,0,integer,1
+cli,tree,4,0,0,logical,1
+cli,try_silently,-1,0,0,character,1
+cli,try_silently,0,0,0,character,1
+cli,vcapply,-1,0,0,character[],1
+cli,vcapply,0,0,0,integer[],1
+cli,vcapply,0,0,1,character[],1
+cli,vcapply,1,0,0,class<`function`>,1
+cli,vcapply,2,0,0,...,1
+cli,vcapply,3,0,0,logical,1
+cli,viapply,-1,0,0,integer[],1
+cli,viapply,0,0,0,list<list<any>>,1
+cli,viapply,1,0,0,class<`function`>,1
+cli,viapply,2,0,0,...,1
+cli,viapply,3,0,0,logical,1
+cli,vlapply,-1,0,0,logical[],1
+cli,vlapply,0,0,0,list<list<character[] | null | character[]>>,1
+cli,vlapply,0,0,1,list<list<character[] | null | character>>,1
+cli,vlapply,0,0,2,list<list<character[] | null | character[] | character | null>>,1
+cli,vlapply,0,0,3,list<list<character[] | null>>,1
+cli,vlapply,0,0,4,list<list<character[] | null | character | null>>,1
+cli,vlapply,1,0,0,class<`function`>,1
+cli,vlapply,2,0,0,...,1
+cli,vlapply,3,0,0,logical,1
+cluster,agnes,-1,0,0,any,1
+cluster,agnes,0,0,0,class<`data.frame`>,1
+cluster,agnes,0,0,1,"class<`dissimilarity`, `dist`>",1
+cluster,agnes,0,0,2,class<`dist`>,1
+cluster,agnes,1,0,0,logical,1
+cluster,agnes,2,0,0,character,1
+cluster,agnes,3,0,0,logical,1
+cluster,agnes,4,0,0,character,1
+cluster,agnes,5,0,0,any,1
+cluster,agnes,6,0,0,logical,1
+cluster,agnes,7,0,0,any,1
+cluster,as.dendrogram.twins,-1,0,0,class<`dendrogram`>,1
+cluster,as.dendrogram.twins,0,0,0,"class<`agnes`, `twins`>",1
+cluster,as.dendrogram.twins,0,0,1,"class<`diana`, `twins`>",1
+cluster,as.dendrogram.twins,1,0,0,...,1
+cluster,bannerplot,-1,0,0,null,1
+cluster,bannerplot,0,0,0,"class<`agnes`, `twins`>",1
+cluster,bannerplot,0,0,1,"class<`diana`, `twins`>",1
+cluster,bannerplot,0,0,2,list<integer[] | character[]>,1
+cluster,bannerplot,1,0,0,double[],1
+cluster,bannerplot,2,0,0,logical,1
+cluster,bannerplot,3,0,0,character,1
+cluster,bannerplot,4,0,0,character,1
+cluster,bannerplot,4,0,1,null,1
+cluster,bannerplot,5,0,0,character,1
+cluster,bannerplot,6,0,0,double,1
+cluster,bannerplot,7,0,0,double[],1
+cluster,clara,-1,0,0,any,1
+cluster,clara,0,0,0,class<`data.frame`>,1
+cluster,clara,0,0,1,class<`matrix`>,1
+cluster,clara,1,0,0,double,1
+cluster,clara,2,0,0,character[],1
+cluster,clara,3,0,0,logical,1
+cluster,clara,4,0,0,double,1
+cluster,clara,5,0,0,double,1
+cluster,clara,6,0,0,double,1
+cluster,clara,7,0,0,logical,1
+cluster,clusGap,-1,0,0,class<`clusGap`>,1
+cluster,clusGap,0,0,0,class<`data.frame`>,1
+cluster,clusGap,0,0,1,class<`matrix`>,1
+cluster,clusGap,1,0,0,class<`function`>,1
+cluster,clusGap,2,0,0,double,1
+cluster,clusGap,3,0,0,double,1
+cluster,clusGap,4,0,0,double,1
+cluster,clusGap,5,0,0,character[],1
+cluster,clusGap,6,0,0,logical,1
+cluster,clusGap,7,0,0,...,1
+cluster,clusplot,-1,0,0,list<class<`matrix`> | double[]>,1
+cluster,clusplot,0,0,0,"class<`clara`, `partition`>",1
+cluster,clusplot,0,0,1,class<`data.frame`>,1
+cluster,clusplot,0,0,2,"class<`dissimilarity`, `dist`>",1
+cluster,clusplot,0,0,3,"class<`fanny`, `partition`>",1
+cluster,clusplot,0,0,4,"class<`pam`, `partition`>",1
+cluster,clusplot,1,0,0,...,1
+cluster,clusplot.default,-1,0,0,list<class<`matrix`> | double[]>,1
+cluster,clusplot.default,0,0,0,class<`data.frame`>,1
+cluster,clusplot.default,0,0,1,"class<`dissimilarity`, `dist`>",1
+cluster,clusplot.default,0,0,2,class<`dist`>,1
+cluster,clusplot.default,0,0,3,class<`matrix`>,1
+cluster,clusplot.default,1,0,0,integer[],1
+cluster,clusplot.default,2,0,0,logical,1
+cluster,clusplot.default,3,0,0,list<class<`matrix`> | double | integer[]>,1
+cluster,clusplot.default,3,0,1,list<class<`matrix`> | character[] | null>,1
+cluster,clusplot.default,3,0,2,list<class<`matrix`> | double | character[]>,1
+cluster,clusplot.default,4,0,0,logical,1
+cluster,clusplot.default,5,0,0,double,1
+cluster,clusplot.default,6,0,0,logical,1
+cluster,clusplot.default,7,0,0,logical,1
+cluster,clusplot.partition,-1,0,0,list<class<`matrix`> | double[]>,1
+cluster,clusplot.partition,0,0,0,"class<`clara`, `partition`>",1
+cluster,clusplot.partition,0,0,1,"class<`fanny`, `partition`>",1
+cluster,clusplot.partition,0,0,2,"class<`pam`, `partition`>",1
+cluster,clusplot.partition,1,0,0,null,1
+cluster,clusplot.partition,2,0,0,null,1
+cluster,clusplot.partition,3,0,0,...,1
+cluster,coef.hclust,-1,0,0,double,1
+cluster,coef.hclust,0,0,0,class<`hclust`>,1
+cluster,coef.hclust,1,0,0,...,1
+cluster,coefHier,-1,0,0,double,1
+cluster,coefHier,0,0,0,"class<`agnes`, `twins`>",1
+cluster,coef.twins,-1,0,0,double,1
+cluster,coef.twins,0,0,0,"class<`agnes`, `twins`>",1
+cluster,coef.twins,1,0,0,...,1
+cluster,daisy,-1,0,0,"class<`dissimilarity`, `dist`>",1
+cluster,daisy,0,0,0,class<`data.frame`>,1
+cluster,daisy,0,0,1,class<`matrix`>,1
+cluster,daisy,1,0,0,any,1
+cluster,daisy,2,0,0,logical,1
+cluster,daisy,3,0,0,list<any>,1
+cluster,daisy,4,0,0,double[],1
+cluster,daisy,5,0,0,logical,1
+cluster,daisy,6,0,0,any,1
+cluster,daisy,7,0,0,any,1
+cluster,diana,-1,0,0,"class<`diana`, `twins`>",1
+cluster,diana,0,0,0,class<`data.frame`>,1
+cluster,diana,0,0,1,"class<`dissimilarity`, `dist`>",1
+cluster,diana,0,0,2,class<`dist`>,1
+cluster,diana,0,0,3,class<`matrix`>,1
+cluster,diana,1,0,0,logical,1
+cluster,diana,2,0,0,character,1
+cluster,diana,3,0,0,logical,1
+cluster,diana,4,0,0,logical,1
+cluster,diana,5,0,0,logical,1
+cluster,diana,6,0,0,logical,1
+cluster,diana,7,0,0,double,1
+cluster,ellipsoidhull,-1,0,0,class<`ellipsoid`>,1
+cluster,ellipsoidhull,0,0,0,class<`matrix`>,1
+cluster,ellipsoidhull,1,0,0,double,1
+cluster,ellipsoidhull,2,0,0,double,1
+cluster,ellipsoidhull,3,0,0,logical,1
+cluster,ellipsoidhull,4,0,0,logical,1
+cluster,ellipsoidhull,5,0,0,logical,1
+cluster,ellipsoidPoints,-1,0,0,class<`matrix`>,1
+cluster,ellipsoidPoints,0,0,0,class<`matrix`>,1
+cluster,ellipsoidPoints,1,0,0,double,1
+cluster,ellipsoidPoints,2,0,0,double[],1
+cluster,ellipsoidPoints,3,0,0,double,1
+cluster,fanny,-1,0,0,"class<`fanny`, `partition`>",1
+cluster,fanny,0,0,0,class<`data.frame`>,1
+cluster,fanny,0,0,1,class<`matrix`>,1
+cluster,fanny,1,0,0,double,1
+cluster,fanny,2,0,0,logical,1
+cluster,fanny,3,0,0,double,1
+cluster,fanny,4,0,0,character[],1
+cluster,fanny,5,0,0,logical,1
+cluster,fanny,6,0,0,null,1
+cluster,fanny,6,0,1,class<`matrix`>,1
+cluster,fanny,7,0,0,logical,1
+cluster,lower.to.upper.tri.inds,-1,0,0,integer[],1
+cluster,lower.to.upper.tri.inds,0,0,0,double,1
+cluster,maxSE,-1,0,0,integer,1
+cluster,maxSE,0,0,0,double[],1
+cluster,maxSE,1,0,0,double[],1
+cluster,maxSE,2,0,0,character,1
+cluster,maxSE,3,0,0,double,1
+cluster,mkCheckX,-1,0,0,list<class<`matrix`> | double | character[]>,1
+cluster,mkCheckX,-1,0,1,list<class<`matrix`> | double | integer[]>,1
+cluster,mkCheckX,0,0,0,"class<`dissimilarity`, `dist`>",1
+cluster,mkCheckX,0,0,1,class<`dist`>,1
+cluster,mkCheckX,0,0,2,class<`matrix`>,1
+cluster,mkCheckX,1,0,0,logical,1
+cluster,mona,-1,0,0,any,1
+cluster,mona,0,0,0,class<`data.frame`>,1
+cluster,mona,0,0,1,class<`matrix`>,1
+cluster,mona,1,0,0,double,1
+cluster,pam,-1,0,0,"class<`pam`, `partition`>",1
+cluster,pam,-1,0,1,integer[],1
+cluster,pam,0,0,0,class<`data.frame`>,1
+cluster,pam,0,0,1,"class<`dissimilarity`, `dist`>",1
+cluster,pam,0,0,2,class<`dist`>,1
+cluster,pam,0,0,3,class<`matrix`>,1
+cluster,pam,0,0,4,double[],1
+cluster,pam,1,0,0,double,1
+cluster,pam,2,0,0,logical,1
+cluster,pam,3,0,0,any,1
+cluster,pam,4,0,0,null,1
+cluster,pam,4,0,1,double[],1
+cluster,pam,5,0,0,logical,1
+cluster,pam,6,0,0,logical,1
+cluster,pam,7,0,0,logical,1
+cluster,plot.agnes,-1,0,0,null,1
+cluster,plot.agnes,0,0,0,"class<`agnes`, `twins`>",1
+cluster,plot.agnes,1,0,0,logical,1
+cluster,plot.agnes,2,0,0,double,1
+cluster,plot.agnes,2,0,1,null,1
+cluster,plot.agnes,3,0,0,null,1
+cluster,plot.agnes,4,0,0,character,1
+cluster,plot.agnes,5,0,0,double,1
+cluster,plot.agnes,6,0,0,double,1
+cluster,plot.agnes,7,0,0,double,1
+cluster,plot.clusGap,-1,0,0,null,1
+cluster,plot.clusGap,0,0,0,class<`clusGap`>,1
+cluster,plot.clusGap,1,0,0,character,1
+cluster,plot.clusGap,2,0,0,character,1
+cluster,plot.clusGap,3,0,0,expression,1
+cluster,plot.clusGap,4,0,0,character,1
+cluster,plot.clusGap,4,0,1,null,1
+cluster,plot.clusGap,5,0,0,logical,1
+cluster,plot.clusGap,6,0,0,list<character | double>,1
+cluster,plot.clusGap,7,0,0,...,1
+cluster,plot.diana,-1,0,0,null,1
+cluster,plot.diana,0,0,0,"class<`diana`, `twins`>",1
+cluster,plot.diana,1,0,0,logical,1
+cluster,plot.diana,2,0,0,double,1
+cluster,plot.diana,2,0,1,null,1
+cluster,plot.diana,3,0,0,null,1
+cluster,plot.diana,4,0,0,character,1
+cluster,plot.diana,5,0,0,double,1
+cluster,plot.diana,6,0,0,double,1
+cluster,plot.diana,7,0,0,double,1
+cluster,plot.mona,-1,0,0,null,1
+cluster,plot.mona,0,0,0,class<`mona`>,1
+cluster,plot.mona,1,0,0,character,1
+cluster,plot.mona,2,0,0,null,1
+cluster,plot.mona,3,0,0,character,1
+cluster,plot.mona,4,0,0,double[],1
+cluster,plot.mona,5,0,0,logical,1
+cluster,plot.mona,6,0,0,double,1
+cluster,plot.mona,7,0,0,double,1
+cluster,plot.partition,-1,0,0,null,1
+cluster,plot.partition,0,0,0,"class<`clara`, `partition`>",1
+cluster,plot.partition,0,0,1,"class<`fanny`, `partition`>",1
+cluster,plot.partition,0,0,2,"class<`pam`, `partition`>",1
+cluster,plot.partition,1,0,0,logical,1
+cluster,plot.partition,2,0,0,null,1
+cluster,plot.partition,2,0,1,double,1
+cluster,plot.partition,3,0,0,double,1
+cluster,plot.partition,4,0,0,double,1
+cluster,plot.partition,5,0,0,any,1
+cluster,plot.partition,6,0,0,null,1
+cluster,plot.partition,6,0,1,class<`dist`>,1
+cluster,plot.partition,7,0,0,logical,1
+cluster,plot.silhouette,-1,0,0,null,1
+cluster,plot.silhouette,0,0,0,class<`silhouette`>,1
+cluster,plot.silhouette,1,0,0,double,1
+cluster,plot.silhouette,2,0,0,any,1
+cluster,plot.silhouette,3,0,0,null,1
+cluster,plot.silhouette,3,0,1,character,1
+cluster,plot.silhouette,4,0,0,null,1
+cluster,plot.silhouette,5,0,0,expression,1
+cluster,plot.silhouette,6,0,0,character[],1
+cluster,plot.silhouette,6,0,1,double[],1
+cluster,plot.silhouette,7,0,0,logical,1
+cluster,pltree,-1,0,0,null,1
+cluster,pltree,0,0,0,"class<`agnes`, `twins`>",1
+cluster,pltree,0,0,1,"class<`diana`, `twins`>",1
+cluster,pltree,1,0,0,...,1
+cluster,pltree.twins,-1,0,0,null,1
+cluster,pltree.twins,0,0,0,"class<`agnes`, `twins`>",1
+cluster,pltree.twins,0,0,1,"class<`diana`, `twins`>",1
+cluster,pltree.twins,1,0,0,character,1
+cluster,pltree.twins,2,0,0,character[],1
+cluster,pltree.twins,2,0,1,null,1
+cluster,pltree.twins,3,0,0,character,1
+cluster,pltree.twins,4,0,0,...,1
+cluster,predict.ellipsoid,-1,0,0,class<`matrix`>,1
+cluster,predict.ellipsoid,0,0,0,class<`ellipsoid`>,1
+cluster,predict.ellipsoid,1,0,0,double,1
+cluster,predict.ellipsoid,2,0,0,...,1
+cluster,print.agnes,-1,0,0,"class<`agnes`, `twins`>",1
+cluster,print.agnes,0,0,0,"class<`agnes`, `twins`>",1
+cluster,print.agnes,1,0,0,...,1
+cluster,print.diana,-1,0,0,"class<`diana`, `twins`>",1
+cluster,print.diana,0,0,0,"class<`diana`, `twins`>",1
+cluster,print.diana,1,0,0,...,1
+cluster,print.dissimilarity,-1,0,0,"class<`dissimilarity`, `dist`>",1
+cluster,print.dissimilarity,0,0,0,"class<`dissimilarity`, `dist`>",1
+cluster,print.dissimilarity,1,0,0,null,1
+cluster,print.dissimilarity,2,0,0,null,1
+cluster,print.dissimilarity,3,0,0,any,1
+cluster,print.dissimilarity,4,0,0,character,1
+cluster,print.dissimilarity,5,0,0,logical,1
+cluster,print.dissimilarity,6,0,0,...,1
+cluster,print.ellipsoid,-1,0,0,class<`ellipsoid`>,1
+cluster,print.ellipsoid,0,0,0,class<`ellipsoid`>,1
+cluster,print.ellipsoid,1,0,0,double,1
+cluster,print.ellipsoid,2,0,0,...,1
+cluster,print.mona,-1,0,0,class<`mona`>,1
+cluster,print.mona,0,0,0,class<`mona`>,1
+cluster,print.mona,1,0,0,...,1
+cluster,print.summary.silhouette,-1,0,0,class<`summary.silhouette`>,1
+cluster,print.summary.silhouette,0,0,0,class<`summary.silhouette`>,1
+cluster,print.summary.silhouette,1,0,0,...,1
+cluster,silhouette,-1,0,0,class<`silhouette`>,1
+cluster,silhouette,0,0,0,double[],1
+cluster,silhouette,0,0,1,"class<`clara`, `partition`>",1
+cluster,silhouette,0,0,2,"class<`fanny`, `partition`>",1
+cluster,silhouette,0,0,3,"class<`pam`, `partition`>",1
+cluster,silhouette,1,0,0,...,1
+cluster,silhouette.clara,-1,0,0,class<`silhouette`>,1
+cluster,silhouette.clara,0,0,0,"class<`clara`, `partition`>",1
+cluster,silhouette.clara,1,0,0,logical,1
+cluster,silhouette.clara,2,0,0,...,1
+cluster,silhouette.default,-1,0,0,class<`silhouette`>,1
+cluster,silhouette.default,0,0,0,double[],1
+cluster,silhouette.default,1,0,0,class<`dist`>,1
+cluster,silhouette.default,1,0,1,"class<`dissimilarity`, `dist`>",1
+cluster,silhouette.default,2,0,0,any,1
+cluster,silhouette.default,3,0,0,...,1
+cluster,silhouette.partition,-1,0,0,class<`silhouette`>,1
+cluster,silhouette.partition,0,0,0,"class<`clara`, `partition`>",1
+cluster,silhouette.partition,0,0,1,"class<`fanny`, `partition`>",1
+cluster,silhouette.partition,0,0,2,"class<`pam`, `partition`>",1
+cluster,silhouette.partition,1,0,0,...,1
+cluster,sizeDiss,-1,0,0,double,1
+cluster,sizeDiss,-1,0,1,null,1
+cluster,sizeDiss,0,0,0,class<`dist`>,1
+cluster,sizeDiss,0,0,1,integer[],1
+cluster,sortSilhouette,-1,0,0,class<`silhouette`>,1
+cluster,sortSilhouette,0,0,0,class<`silhouette`>,1
+cluster,sortSilhouette,1,0,0,...,1
+cluster,summary.agnes,-1,0,0,class<`summary.agnes`>,1
+cluster,summary.agnes,0,0,0,"class<`agnes`, `twins`>",1
+cluster,summary.agnes,1,0,0,...,1
+cluster,summary.clara,-1,0,0,class<`summary.clara`>,1
+cluster,summary.clara,0,0,0,"class<`clara`, `partition`>",1
+cluster,summary.clara,1,0,0,...,1
+cluster,summary.diana,-1,0,0,class<`summary.diana`>,1
+cluster,summary.diana,0,0,0,"class<`diana`, `twins`>",1
+cluster,summary.diana,1,0,0,...,1
+cluster,summary.dissimilarity,-1,0,0,class<`summary.dissimilarity`>,1
+cluster,summary.dissimilarity,0,0,0,"class<`dissimilarity`, `dist`>",1
+cluster,summary.dissimilarity,1,0,0,double,1
+cluster,summary.dissimilarity,2,0,0,...,1
+cluster,summary.fanny,-1,0,0,class<`summary.fanny`>,1
+cluster,summary.fanny,0,0,0,"class<`fanny`, `partition`>",1
+cluster,summary.fanny,1,0,0,...,1
+cluster,summary.pam,-1,0,0,class<`summary.pam`>,1
+cluster,summary.pam,0,0,0,"class<`pam`, `partition`>",1
+cluster,summary.pam,1,0,0,...,1
+cluster,summary.silhouette,-1,0,0,class<`summary.silhouette`>,1
+cluster,summary.silhouette,0,0,0,class<`silhouette`>,1
+cluster,summary.silhouette,1,0,0,class<`function`>,1
+cluster,summary.silhouette,2,0,0,...,1
+cluster,upper.to.lower.tri.inds,-1,0,0,integer[],1
+cluster,upper.to.lower.tri.inds,0,0,0,double,1
+cluster,volume,-1,0,0,double,1
+cluster,volume,0,0,0,class<`ellipsoid`>,1
+cluster,volume,1,0,0,...,1
+cluster,volume.ellipsoid,-1,0,0,double,1
+cluster,volume.ellipsoid,0,0,0,class<`ellipsoid`>,1
+cluster,volume.ellipsoid,1,0,0,logical,1
+cluster,volume.ellipsoid,2,0,0,...,1
+cmprsk,crr,-1,0,0,class<`crr`>,1
+cmprsk,crr,0,0,0,double[],1
+cmprsk,crr,1,0,0,integer[],1
+cmprsk,crr,2,0,0,any,1
+cmprsk,crr,3,0,0,any,1
+cmprsk,crr,4,0,0,any,1
+cmprsk,crr,5,0,0,any,1
+cmprsk,crr,6,0,0,double,1
+cmprsk,crr,7,0,0,double,1
+cmprsk,crr,8,0,0,any,1
+cmprsk,crr,9,0,0,class<`function`>,1
+cmprsk,crr,10,0,0,double,1
+cmprsk,crr,11,0,0,double,1
+cmprsk,crr,12,0,0,any,1
+cmprsk,crr,13,0,0,logical,1
+cmprsk,cuminc,-1,0,0,class<`cuminc`>,1
+cmprsk,cuminc,0,0,0,double[],1
+cmprsk,cuminc,1,0,0,integer[],1
+cmprsk,cuminc,2,0,0,any,1
+cmprsk,cuminc,3,0,0,any,1
+cmprsk,cuminc,4,0,0,double,1
+cmprsk,cuminc,5,0,0,double,1
+cmprsk,cuminc,6,0,0,any,1
+cmprsk,cuminc,7,0,0,class<`function`>,1
+cmprsk,[.cuminc,-1,0,0,class<`cuminc`>,1
+cmprsk,[.cuminc,0,0,0,class<`cuminc`>,1
+cmprsk,[.cuminc,1,0,0,logical[],1
+cmprsk,[.cuminc,2,0,0,...,1
+cmprsk,plot.cuminc,-1,0,0,null,1
+cmprsk,plot.cuminc,0,0,0,class<`cuminc`>,1
+cmprsk,plot.cuminc,1,0,0,character,1
+cmprsk,plot.cuminc,2,0,0,any,1
+cmprsk,plot.cuminc,3,0,0,double[],1
+cmprsk,plot.cuminc,4,0,0,any,1
+cmprsk,plot.cuminc,5,0,0,double,1
+cmprsk,plot.cuminc,6,0,0,character,1
+cmprsk,plot.cuminc,7,0,0,character,1
+cmprsk,plot.cuminc,8,0,0,double,1
+cmprsk,plot.cuminc,8,0,1,integer[],1
+cmprsk,plot.cuminc,9,0,0,integer[],1
+cmprsk,plot.cuminc,9,0,1,double,1
+cmprsk,plot.cuminc,10,0,0,double,1
+cmprsk,plot.cuminc,11,0,0,...,1
+cmprsk,plot.predict.crr,-1,0,0,null,1
+cmprsk,plot.predict.crr,0,0,0,class<`predict.crr`>,1
+cmprsk,plot.predict.crr,1,0,0,double,1
+cmprsk,plot.predict.crr,1,0,1,integer[],1
+cmprsk,plot.predict.crr,2,0,0,double[],1
+cmprsk,plot.predict.crr,3,0,0,double[],1
+cmprsk,plot.predict.crr,4,0,0,double,1
+cmprsk,plot.predict.crr,5,0,0,double,1
+cmprsk,plot.predict.crr,6,0,0,...,1
+cmprsk,predict.crr,-1,0,0,class<`predict.crr`>,1
+cmprsk,predict.crr,0,0,0,class<`crr`>,1
+cmprsk,predict.crr,1,0,0,class<`matrix`>,1
+cmprsk,predict.crr,2,0,0,any,1
+cmprsk,predict.crr,3,0,0,...,1
+cmprsk,print.crr,-1,0,0,null,1
+cmprsk,print.crr,0,0,0,class<`crr`>,1
+cmprsk,print.crr,1,0,0,...,1
+cmprsk,print.cuminc,-1,0,0,null,1
+cmprsk,print.cuminc,0,0,0,class<`cuminc`>,1
+cmprsk,print.cuminc,1,0,0,double,1
+cmprsk,print.cuminc,2,0,0,any,1
+cmprsk,print.cuminc,3,0,0,...,1
+cmprsk,print.summary.crr,-1,0,0,null,1
+cmprsk,print.summary.crr,0,0,0,class<`summary.crr`>,1
+cmprsk,print.summary.crr,1,0,0,double,1
+cmprsk,print.summary.crr,2,0,0,...,1
+cmprsk,summary.crr,-1,0,0,class<`summary.crr`>,1
+cmprsk,summary.crr,0,0,0,class<`crr`>,1
+cmprsk,summary.crr,1,0,0,double,1
+cmprsk,summary.crr,2,0,0,double,1
+cmprsk,summary.crr,3,0,0,...,1
+cmprsk,timepoints,-1,0,0,list<class<`matrix`>>,1
+cmprsk,timepoints,0,0,0,class<`cuminc`>,1
+cmprsk,timepoints,1,0,0,double[],1
+codetools,addLocalFunDef,-1,0,0,list<null>,1
+codetools,addLocalFunDef,-1,0,1,list<pairlist>,1
+codetools,addLocalFunDef,0,0,0,character,1
+codetools,addLocalFunDef,1,0,0,class<`<-`>,1
+codetools,addLocalFunDef,2,0,0,list<any>,1
+codetools,anyMissing,-1,0,0,logical,1
+codetools,anyMissing,0,0,0,class<`call`>,1
+codetools,anyMissing,0,0,1,null,1
+codetools,apdef,-1,0,0,list<class<`call`>>,1
+codetools,apdef,0,0,0,class<`call`>,1
+codetools,checkCall,-1,0,0,logical,1
+codetools,checkCall,0,0,0,class<`function`>,1
+codetools,checkCall,1,0,0,class<`call`>,1
+codetools,checkCall,2,0,0,any,1
+codetools,checkDotsAssignVar,-1,0,0,logical,1
+codetools,checkDotsAssignVar,0,0,0,character,1
+codetools,checkDotsAssignVar,1,0,0,any,1
+codetools,checkPrimopCall,-1,0,0,logical,1
+codetools,checkPrimopCall,0,0,0,character,1
+codetools,checkPrimopCall,1,0,0,class<`<-`>,1
+codetools,checkPrimopCall,1,0,1,class<`(`>,1
+codetools,checkPrimopCall,1,0,2,class<`{`>,1
+codetools,checkPrimopCall,1,0,3,class<`call`>,1
+codetools,checkPrimopCall,1,0,4,class<`for`>,1
+codetools,checkPrimopCall,1,0,5,class<`if`>,1
+codetools,checkPrimopCall,1,0,6,class<`while`>,1
+codetools,checkPrimopCall,2,0,0,any,1
+codetools,checkPrimopCall,3,0,0,any,1
+codetools,checkSymOrString,-1,0,0,class<`name`>,1
+codetools,checkSymOrString,0,0,0,class<`name`>,1
+codetools,checkSymOrString,1,0,0,any,1
+codetools,checkUsage,-1,0,0,null,1
+codetools,checkUsage,0,0,0,class<`function`>,1
+codetools,checkUsage,1,0,0,character,1
+codetools,checkUsage,2,0,0,class<`function`>,1
+codetools,checkUsage,3,0,0,logical,1
+codetools,checkUsage,4,0,0,logical,1
+codetools,checkUsage,5,0,0,logical,1
+codetools,checkUsage,6,0,0,logical,1
+codetools,checkUsage,7,0,0,logical,1
+codetools,checkUsageEnv,-1,0,0,null,1
+codetools,checkUsageEnv,0,0,0,environment,1
+codetools,checkUsageEnv,1,0,0,...,1
+codetools,checkUsagePackage,-1,0,0,null,1
+codetools,checkUsagePackage,0,0,0,character,1
+codetools,checkUsagePackage,1,0,0,...,1
+codetools,collectUsage,-1,0,0,null,1
+codetools,collectUsage,0,0,0,class<`function`>,1
+codetools,collectUsage,1,0,0,character,1
+codetools,collectUsage,2,0,0,...,1
+codetools,collectUsageArgs,-1,0,0,null,1
+codetools,collectUsageArgs,0,0,0,class<`(`>,1
+codetools,collectUsageArgs,0,0,1,class<`call`>,1
+codetools,collectUsageArgs,0,0,2,class<`if`>,1
+codetools,collectUsageArgs,0,0,3,class<`while`>,1
+codetools,collectUsageArgs,1,0,0,any,1
+codetools,collectUsageFun,-1,0,0,null,1
+codetools,collectUsageFun,0,0,0,character,1
+codetools,collectUsageFun,1,0,0,null,1
+codetools,collectUsageFun,1,0,1,pairlist,1
+codetools,collectUsageFun,2,0,0,class<`call`>,1
+codetools,collectUsageFun,2,0,1,class<`if`>,1
+codetools,collectUsageFun,2,0,2,class<`(`>,1
+codetools,collectUsageFun,2,0,3,class<`{`>,1
+codetools,collectUsageFun,2,0,4,class<`for`>,1
+codetools,collectUsageFun,2,0,5,class<`name`>,1
+codetools,collectUsageFun,2,0,6,logical,1
+codetools,collectUsageFun,2,0,7,null,1
+codetools,collectUsageFun,3,0,0,list<any>,1
+codetools,constantFold,-1,0,0,double,1
+codetools,constantFold,-1,0,1,null,1
+codetools,constantFold,0,0,0,class<`call`>,1
+codetools,constantFold,0,0,1,class<`name`>,1
+codetools,constantFold,0,0,2,double,1
+codetools,constantFold,1,0,0,null,1
+codetools,constantFold,1,0,1,character,1
+codetools,constantFold,2,0,0,null,1
+codetools,constantFold,2,0,1,logical,1
+codetools,constantFoldEnv,-1,0,0,logical,1
+codetools,constantFoldEnv,-1,0,1,null,1
+codetools,constantFoldEnv,0,0,0,class<`call`>,1
+codetools,constantFoldEnv,0,0,1,logical,1
+codetools,constantFoldEnv,0,0,2,class<`name`>,1
+codetools,constantFoldEnv,1,0,0,any,1
+codetools,constantFoldEnv,2,0,0,null,1
+codetools,dropMissings,-1,0,0,list<any>,1
+codetools,dropMissings,0,0,0,null,1
+codetools,dropMissings,0,0,1,pairlist,1
+codetools,dropMissings,0,0,2,class<`call`>,1
+codetools,evalseq,-1,0,0,list<class<`name`> | class<`call`>>,1
+codetools,evalseq,-1,0,1,list<class<`name`>>,1
+codetools,evalseq,0,0,0,class<`call`>,1
+codetools,evalseq,0,0,1,class<`name`>,1
+codetools,exitFolder,-1,0,0,any,1
+codetools,exitFolder,0,0,0,any,1
+codetools,exitFolder,1,0,0,list<class<`function`>>,1
+codetools,findFuncLocals,-1,0,0,character[],1
+codetools,findFuncLocals,0,0,0,null,1
+codetools,findFuncLocals,0,0,1,pairlist,1
+codetools,findFuncLocals,1,0,0,class<`{`>,1
+codetools,findFuncLocals,1,0,1,class<`call`>,1
+codetools,findFuncLocals,1,0,2,class<`if`>,1
+codetools,findFuncLocals,1,0,3,class<`<-`>,1
+codetools,findFuncLocals,1,0,4,class<`(`>,1
+codetools,findFuncLocals,1,0,5,class<`name`>,1
+codetools,findFuncLocals,1,0,6,logical,1
+codetools,findFuncLocals,1,0,7,null,1
+codetools,findFuncLocals,1,0,8,class<`for`>,1
+codetools,findGlobals,-1,0,0,character[],1
+codetools,findGlobals,-1,0,1,list<character[]>,1
+codetools,findGlobals,0,0,0,class<`function`>,1
+codetools,findGlobals,1,0,0,logical,1
+codetools,findLocals,-1,0,0,character[],1
+codetools,findLocals,0,0,0,class<`<-`>,1
+codetools,findLocals,0,0,1,class<`{`>,1
+codetools,findLocals,0,0,2,class<`call`>,1
+codetools,findLocals,1,0,0,environment,1
+codetools,findLocals,1,0,1,character,1
+codetools,findLocalsList,-1,0,0,character[],1
+codetools,findLocalsList,0,0,0,list<any>,1
+codetools,findLocalsList,1,0,0,environment,1
+codetools,findLocalsList,1,0,1,character,1
+codetools,findOwnerEnv,-1,0,0,environment,1
+codetools,findOwnerEnv,-1,0,1,null,1
+codetools,findOwnerEnv,0,0,0,character,1
+codetools,findOwnerEnv,1,0,0,environment,1
+codetools,findOwnerEnv,2,0,0,environment,1
+codetools,findOwnerEnv,2,0,1,null,1
+codetools,findOwnerEnv,3,0,0,any,1
+codetools,flattenAssignment,-1,0,0,list<list<class<`name`> | class<`call`> | class<`call`>>>,1
+codetools,flattenAssignment,-1,0,1,list<list<class<`name`> | class<`call`>>>,1
+codetools,flattenAssignment,-1,0,2,list<null>,1
+codetools,flattenAssignment,0,0,0,class<`call`>,1
+codetools,flattenAssignment,0,0,1,class<`name`>,1
+codetools,getAssignedVar,-1,0,0,character,1
+codetools,getAssignedVar,0,0,0,class<`<-`>,1
+codetools,getLocalUsageEntry,-1,0,0,environment,1
+codetools,getLocalUsageEntry,0,0,0,character,1
+codetools,getLocalUsageEntry,1,0,0,list<any>,1
+codetools,getLocalUsageValue,-1,0,0,class<`data.frame`>,1
+codetools,getLocalUsageValue,-1,0,1,double,1
+codetools,getLocalUsageValue,-1,0,2,list<null>,1
+codetools,getLocalUsageValue,-1,0,3,list<pairlist>,1
+codetools,getLocalUsageValue,-1,0,4,null,1
+codetools,getLocalUsageValue,0,0,0,character,1
+codetools,getLocalUsageValue,1,0,0,character,1
+codetools,getLocalUsageValue,2,0,0,list<any>,1
+codetools,incLocalSrcInfo,-1,0,0,class<`data.frame`>,1
+codetools,incLocalSrcInfo,0,0,0,character,1
+codetools,incLocalSrcInfo,1,0,0,list<any>,1
+codetools,incLocalUsageValue,-1,0,0,double,1
+codetools,incLocalUsageValue,0,0,0,character,1
+codetools,incLocalUsageValue,1,0,0,character,1
+codetools,incLocalUsageValue,2,0,0,list<any>,1
+codetools,is.baseenv,-1,0,0,logical,1
+codetools,is.baseenv,0,0,0,environment,1
+codetools,is.baseenv,0,0,1,null,1
+codetools,isBaseVar,-1,0,0,logical,1
+codetools,isBaseVar,0,0,0,character,1
+codetools,isBaseVar,1,0,0,environment,1
+codetools,isClosureFunDef,-1,0,0,logical,1
+codetools,isClosureFunDef,0,0,0,class<`<-`>,1
+codetools,isClosureFunDef,1,0,0,any,1
+codetools,isDDSym,-1,0,0,logical,1
+codetools,isDDSym,0,0,0,character,1
+codetools,isDDSym,0,0,1,class<`name`>,1
+codetools,is.emptyenv,-1,0,0,logical,1
+codetools,is.emptyenv,0,0,0,environment,1
+codetools,isSimpleFunDef,-1,0,0,logical,1
+codetools,isSimpleFunDef,0,0,0,class<`<-`>,1
+codetools,isSimpleFunDef,1,0,0,any,1
+codetools,isStatsVar,-1,0,0,logical,1
+codetools,isStatsVar,0,0,0,character,1
+codetools,isStatsVar,1,0,0,environment,1
+codetools,isUtilsVar,-1,0,0,logical,1
+codetools,isUtilsVar,0,0,0,character,1
+codetools,isUtilsVar,1,0,0,environment,1
+codetools,makeAssgnFcn,-1,0,0,class<`call`>,1
+codetools,makeAssgnFcn,-1,0,1,class<`name`>,1
+codetools,makeAssgnFcn,0,0,0,class<`call`>,1
+codetools,makeAssgnFcn,0,0,1,class<`name`>,1
+codetools,makeCodeWalker,-1,0,0,list<any>,1
+codetools,makeCodeWalker,0,0,0,...,1
+codetools,makeCodeWalker,1,0,0,class<`function`>,1
+codetools,makeCodeWalker,2,0,0,class<`function`>,1
+codetools,makeCodeWalker,3,0,0,class<`function`>,1
+codetools,makeConstantFolder,-1,0,0,list<class<`function`>>,1
+codetools,makeConstantFolder,0,0,0,...,1
+codetools,makeConstantFolder,1,0,0,class<`function`>,1
+codetools,makeConstantFolder,2,0,0,class<`function`>,1
+codetools,makeConstantFolder,3,0,0,class<`function`>,1
+codetools,makeConstantFolder,4,0,0,class<`function`>,1
+codetools,makeConstantFolder,5,0,0,class<`function`>,1
+codetools,makeConstantFolder,6,0,0,any,1
+codetools,makeConstantFolder,7,0,0,class<`function`>,1
+codetools,makeLocalsCollector,-1,0,0,list<class<`function`>>,1
+codetools,makeLocalsCollector,0,0,0,...,1
+codetools,makeLocalsCollector,1,0,0,class<`function`>,1
+codetools,makeLocalsCollector,2,0,0,class<`function`>,1
+codetools,makeLocalsCollector,3,0,0,class<`function`>,1
+codetools,makeLocalsCollector,4,0,0,any,1
+codetools,makeLocalsCollector,5,0,0,class<`function`>,1
+codetools,makeUsageCollector,-1,0,0,list<any>,1
+codetools,makeUsageCollector,0,0,0,class<`function`>,1
+codetools,makeUsageCollector,1,0,0,...,1
+codetools,makeUsageCollector,2,0,0,null,1
+codetools,makeUsageCollector,3,0,0,class<`function`>,1
+codetools,makeUsageCollector,4,0,0,class<`function`>,1
+codetools,makeUsageCollector,5,0,0,class<`function`>,1
+codetools,makeUsageCollector,6,0,0,class<`function`>,1
+codetools,makeUsageCollector,7,0,0,class<`function`>,1
+codetools,matchCall,-1,0,0,class<`call`>,1
+codetools,matchCall,0,0,0,class<`function`>,1
+codetools,matchCall,1,0,0,class<`call`>,1
+codetools,matchCall,2,0,0,...,1
+codetools,mkHash,-1,0,0,environment,1
+codetools,showTree,-1,0,0,character,1
+codetools,showTree,-1,0,1,null,1
+codetools,showTree,0,0,0,class<`call`>,1
+codetools,showTree,0,0,1,class<`<-`>,1
+codetools,showTree,1,0,0,class<`function`>,1
+codetools,suppressVar,-1,0,0,logical,1
+codetools,suppressVar,0,0,0,any,1
+codetools,suppressVar,1,0,0,logical,1
+codetools,walkCode,-1,0,0,any,1
+codetools,walkCode,0,0,0,character,1
+codetools,walkCode,0,0,1,class<`<-`>,1
+codetools,walkCode,0,0,2,class<`call`>,1
+codetools,walkCode,0,0,3,class<`name`>,1
+codetools,walkCode,0,0,4,double,1
+codetools,walkCode,0,0,5,null,1
+codetools,walkCode,0,0,6,class<`(`>,1
+codetools,walkCode,0,0,7,class<`if`>,1
+codetools,walkCode,0,0,8,class<`{`>,1
+codetools,walkCode,0,0,9,class<`for`>,1
+codetools,walkCode,0,0,10,class<`while`>,1
+codetools,walkCode,1,0,0,list<any>,1
+coin,ansari_test,-1,0,0,any,1
+coin,ansari_test,0,0,0,class<`formula`>,1
+coin,ansari_test,0,0,1,class<`IndependenceProblem`>,1
+coin,ansari_test,1,0,0,...,1
+coin,ansari_test.formula,-1,0,0,any,1
+coin,ansari_test.formula,0,0,0,class<`formula`>,1
+coin,ansari_test.formula,1,0,0,class<`data.frame`>,1
+coin,ansari_test.formula,1,0,1,list<any>,1
+coin,ansari_test.formula,2,0,0,null,1
+coin,ansari_test.formula,3,0,0,null,1
+coin,ansari_test.formula,4,0,0,...,1
+coin,ansari_test.IndependenceProblem,-1,0,0,any,1
+coin,ansari_test.IndependenceProblem,0,0,0,class<`IndependenceProblem`>,1
+coin,ansari_test.IndependenceProblem,1,0,0,any,1
+coin,ansari_test.IndependenceProblem,2,0,0,logical,1
+coin,ansari_test.IndependenceProblem,3,0,0,double,1
+coin,ansari_test.IndependenceProblem,4,0,0,...,1
+coin,ansari_trafo,-1,0,0,^double[],1
+coin,ansari_trafo,0,0,0,^integer[],1
+coin,ansari_trafo,0,0,1,double[],1
+coin,ansari_trafo,1,0,0,character[],1
+coin,approximate,-1,0,0,class<`function`>,1
+coin,approximate,0,0,0,double,1
+coin,approximate,1,0,0,character[],1
+coin,approximate,2,0,0,integer,1
+coin,approximate,3,0,0,null,1
+coin,approximate,4,0,0,any,1
+coin,ApproxNullDistribution,-1,0,0,class<`ApproxNullDistribution`>,1
+coin,ApproxNullDistribution,0,0,0,class<`QuadTypeIndependenceTestStatistic`>,1
+coin,ApproxNullDistribution,1,0,0,...,1
+coin,ApproxNullDistribution,-1,1,0,class<`ApproxNullDistribution`>,1
+coin,ApproxNullDistribution,0,1,0,class<`MaxTypeIndependenceTestStatistic`>,1
+coin,ApproxNullDistribution,0,1,1,class<`QuadTypeIndependenceTestStatistic`>,1
+coin,ApproxNullDistribution,0,1,2,class<`ScalarIndependenceTestStatistic`>,1
+coin,ApproxNullDistribution,1,1,0,...,1
+coin,ApproxNullDistribution,-1,2,0,class<`ApproxNullDistribution`>,1
+coin,ApproxNullDistribution,0,2,0,class<`MaxTypeIndependenceTestStatistic`>,1
+coin,ApproxNullDistribution,1,2,0,...,1
+coin,ApproxNullDistribution,-1,3,0,class<`ApproxNullDistribution`>,1
+coin,ApproxNullDistribution,0,3,0,class<`ScalarIndependenceTestStatistic`>,1
+coin,ApproxNullDistribution,1,3,0,...,1
+coin,AsymptNullDistribution,-1,0,0,class<`AsymptNullDistribution`>,1
+coin,AsymptNullDistribution,0,0,0,class<`MaxTypeIndependenceTestStatistic`>,1
+coin,AsymptNullDistribution,0,0,1,class<`QuadTypeIndependenceTestStatistic`>,1
+coin,AsymptNullDistribution,0,0,2,class<`ScalarIndependenceTestStatistic`>,1
+coin,AsymptNullDistribution,1,0,0,...,1
+coin,AsymptNullDistribution,-1,1,0,class<`AsymptNullDistribution`>,1
+coin,AsymptNullDistribution,0,1,0,class<`ScalarIndependenceTestStatistic`>,1
+coin,AsymptNullDistribution,1,1,0,...,1
+coin,AsymptNullDistribution,-1,2,0,class<`AsymptNullDistribution`>,1
+coin,AsymptNullDistribution,0,2,0,class<`QuadTypeIndependenceTestStatistic`>,1
+coin,AsymptNullDistribution,1,2,0,...,1
+coin,AsymptNullDistribution,-1,3,0,class<`AsymptNullDistribution`>,1
+coin,AsymptNullDistribution,0,3,0,class<`MaxTypeIndependenceTestStatistic`>,1
+coin,AsymptNullDistribution,1,3,0,...,1
+coin,asymptotic,-1,0,0,class<`function`>,1
+coin,asymptotic,0,0,0,double,1
+coin,asymptotic,1,0,0,double,1
+coin,asymptotic,2,0,0,double,1
+coin,average_scores,-1,0,0,^double[],1
+coin,average_scores,0,0,0,^double[],1
+coin,average_scores,1,0,0,^integer[],1
+coin,average_scores,1,0,1,double[],1
+coin,check_distribution_arg,-1,0,0,class<`function`>,1
+coin,check_distribution_arg,0,0,0,class<`function`>,1
+coin,check_distribution_arg,0,0,1,character[],1
+coin,check_distribution_arg,1,0,0,any,1
+coin,check_trafo,-1,0,0,any,1
+coin,check_trafo,0,0,0,any,1
+coin,check_trafo,1,0,0,any,1
+coin,chisq_test,-1,0,0,class<`QuadTypeIndependenceTest`>,1
+coin,chisq_test,-1,0,1,class<`ScalarIndependenceTest`>,1
+coin,chisq_test,0,0,0,class<`formula`>,1
+coin,chisq_test,0,0,1,class<`IndependenceProblem`>,1
+coin,chisq_test,0,0,2,class<`table`>,1
+coin,chisq_test,1,0,0,...,1
+coin,chisq_test.formula,-1,0,0,class<`QuadTypeIndependenceTest`>,1
+coin,chisq_test.formula,-1,0,1,class<`ScalarIndependenceTest`>,1
+coin,chisq_test.formula,0,0,0,class<`formula`>,1
+coin,chisq_test.formula,1,0,0,class<`data.frame`>,1
+coin,chisq_test.formula,2,0,0,null,1
+coin,chisq_test.formula,3,0,0,null,1
+coin,chisq_test.formula,4,0,0,...,1
+coin,chisq_test.IndependenceProblem,-1,0,0,class<`QuadTypeIndependenceTest`>,1
+coin,chisq_test.IndependenceProblem,-1,0,1,class<`ScalarIndependenceTest`>,1
+coin,chisq_test.IndependenceProblem,0,0,0,class<`IndependenceProblem`>,1
+coin,chisq_test.IndependenceProblem,1,0,0,...,1
+coin,chisq_test.table,-1,0,0,class<`QuadTypeIndependenceTest`>,1
+coin,chisq_test.table,-1,0,1,class<`ScalarIndependenceTest`>,1
+coin,chisq_test.table,0,0,0,class<`table`>,1
+coin,chisq_test.table,1,0,0,...,1
+coin,cmh_test,-1,0,0,class<`QuadTypeIndependenceTest`>,1
+coin,cmh_test,-1,0,1,class<`ScalarIndependenceTest`>,1
+coin,cmh_test,0,0,0,class<`formula`>,1
+coin,cmh_test,0,0,1,class<`IndependenceProblem`>,1
+coin,cmh_test,0,0,2,class<`table`>,1
+coin,cmh_test,1,0,0,...,1
+coin,cmh_test.formula,-1,0,0,class<`QuadTypeIndependenceTest`>,1
+coin,cmh_test.formula,0,0,0,class<`formula`>,1
+coin,cmh_test.formula,1,0,0,class<`data.frame`>,1
+coin,cmh_test.formula,2,0,0,null,1
+coin,cmh_test.formula,3,0,0,null,1
+coin,cmh_test.formula,4,0,0,...,1
+coin,cmh_test.IndependenceProblem,-1,0,0,class<`QuadTypeIndependenceTest`>,1
+coin,cmh_test.IndependenceProblem,-1,0,1,class<`ScalarIndependenceTest`>,1
+coin,cmh_test.IndependenceProblem,0,0,0,class<`IndependenceProblem`>,1
+coin,cmh_test.IndependenceProblem,1,0,0,...,1
+coin,cmh_test.table,-1,0,0,class<`QuadTypeIndependenceTest`>,1
+coin,cmh_test.table,-1,0,1,class<`ScalarIndependenceTest`>,1
+coin,cmh_test.table,0,0,0,class<`table`>,1
+coin,cmh_test.table,1,0,0,...,1
+coin,.confint,-1,0,0,list<double[]>,1
+coin,.confint,0,0,0,class<`ScalarIndependenceTestConfint`>,1
+coin,.confint,0,0,1,class<`ScalarIndependenceTestStatistic`>,1
+coin,.confint,1,0,0,any,1
+coin,.confint,2,0,0,...,1
+coin,.confint,-1,1,0,list<double[]>,1
+coin,.confint,0,1,0,class<`ScalarIndependenceTestStatistic`>,1
+coin,.confint,1,1,0,class<`AsymptNullDistribution`>,1
+coin,.confint,2,1,0,...,1
+coin,.confint,-1,2,0,list<double[]>,1
+coin,.confint,0,2,0,class<`ScalarIndependenceTestStatistic`>,1
+coin,.confint,1,2,0,class<`ApproxNullDistribution`>,1
+coin,.confint,2,2,0,...,1
+coin,.confint,-1,3,0,list<double[]>,1
+coin,.confint,0,3,0,class<`ScalarIndependenceTestConfint`>,1
+coin,.confint,1,3,0,any,1
+coin,.confint,2,3,0,...,1
+coin,.confint,-1,4,0,list<double[]>,1
+coin,.confint,0,4,0,class<`ScalarIndependenceTestStatistic`>,1
+coin,.confint,1,4,0,class<`ExactNullDistribution`>,1
+coin,.confint,2,4,0,...,1
+coin,confint_binom,-1,0,0,double[],1
+coin,confint_binom,0,0,0,double,1
+coin,confint_binom,1,0,0,double,1
+coin,confint_binom,2,0,0,double,1
+coin,confint_binom,3,0,0,character,1
+coin,confint_binom,4,0,0,any,1
+coin,conover_test,-1,0,0,any,1
+coin,conover_test,0,0,0,class<`formula`>,1
+coin,conover_test,0,0,1,class<`IndependenceProblem`>,1
+coin,conover_test,1,0,0,...,1
+coin,conover_test.formula,-1,0,0,any,1
+coin,conover_test.formula,0,0,0,class<`formula`>,1
+coin,conover_test.formula,1,0,0,class<`data.frame`>,1
+coin,conover_test.formula,1,0,1,list<any>,1
+coin,conover_test.formula,2,0,0,null,1
+coin,conover_test.formula,3,0,0,null,1
+coin,conover_test.formula,4,0,0,...,1
+coin,conover_test.IndependenceProblem,-1,0,0,any,1
+coin,conover_test.IndependenceProblem,0,0,0,class<`IndependenceProblem`>,1
+coin,conover_test.IndependenceProblem,1,0,0,logical,1
+coin,conover_test.IndependenceProblem,2,0,0,double,1
+coin,conover_test.IndependenceProblem,3,0,0,...,1
+coin,consal_trafo,-1,0,0,class<`matrix`>,1
+coin,consal_trafo,-1,0,1,^double[],1
+coin,consal_trafo,0,0,0,double[],1
+coin,consal_trafo,0,0,1,^integer[],1
+coin,consal_trafo,1,0,0,character[],1
+coin,consal_trafo,2,0,0,double[],1
+coin,copyslots,-1,0,0,class<`IndependenceLinearStatistic`>,1
+coin,copyslots,-1,0,1,class<`IndependenceTestProblem`>,1
+coin,copyslots,-1,0,2,class<`MaxTypeIndependenceTestStatistic`>,1
+coin,copyslots,-1,0,3,class<`QuadTypeIndependenceTestStatistic`>,1
+coin,copyslots,-1,0,4,class<`ScalarIndependenceTestStatistic`>,1
+coin,copyslots,0,0,0,class<`IndependenceLinearStatistic`>,1
+coin,copyslots,0,0,1,class<`IndependenceTestProblem`>,1
+coin,copyslots,0,0,2,class<`MaxTypeIndependenceTestStatistic`>,1
+coin,copyslots,0,0,3,class<`QuadTypeIndependenceTestStatistic`>,1
+coin,copyslots,0,0,4,class<`ScalarIndependenceTestStatistic`>,1
+coin,copyslots,0,0,5,class<`IndependenceProblem`>,1
+coin,copyslots,0,0,6,class<`SymmetryProblem`>,1
+coin,copyslots,1,0,0,class<`IndependenceLinearStatistic`>,1
+coin,copyslots,1,0,1,class<`IndependenceTestProblem`>,1
+coin,copyslots,1,0,2,class<`MaxTypeIndependenceTestStatistic`>,1
+coin,copyslots,1,0,3,class<`QuadTypeIndependenceTestStatistic`>,1
+coin,copyslots,1,0,4,class<`ScalarIndependenceTestStatistic`>,1
+coin,covariance,-1,0,0,class<`matrix`>,1
+coin,covariance,0,0,0,class<`ScalarIndependenceTest`>,1
+coin,covariance,1,0,0,...,1
+coin,covariance,-1,1,0,class<`matrix`>,1
+coin,covariance,0,1,0,class<`QuadTypeIndependenceTest`>,1
+coin,covariance,1,1,0,...,1
+coin,covariance,-1,2,0,class<`matrix`>,1
+coin,covariance,0,2,0,class<`QuadTypeIndependenceTestStatistic`>,1
+coin,covariance,1,2,0,...,1
+coin,covariance,-1,3,0,class<`matrix`>,1
+coin,covariance,0,3,0,class<`ScalarIndependenceTestConfint`>,1
+coin,covariance,1,3,0,...,1
+coin,covariance,-1,4,0,class<`matrix`>,1
+coin,covariance,0,4,0,class<`ScalarIndependenceTestStatistic`>,1
+coin,covariance,1,4,0,...,1
+coin,covariance,-1,5,0,class<`matrix`>,1
+coin,covariance,0,5,0,class<`CovarianceMatrix`>,1
+coin,covariance,0,5,1,class<`IndependenceLinearStatistic`>,1
+coin,covariance,0,5,2,class<`MaxTypeIndependenceTest`>,1
+coin,covariance,0,5,3,class<`MaxTypeIndependenceTestStatistic`>,1
+coin,covariance,0,5,4,class<`QuadTypeIndependenceTest`>,1
+coin,covariance,0,5,5,class<`QuadTypeIndependenceTestStatistic`>,1
+coin,covariance,0,5,6,class<`ScalarIndependenceTest`>,1
+coin,covariance,0,5,7,class<`ScalarIndependenceTestConfint`>,1
+coin,covariance,0,5,8,class<`ScalarIndependenceTestStatistic`>,1
+coin,covariance,1,5,0,...,1
+coin,covariance,-1,6,0,class<`matrix`>,1
+coin,covariance,0,6,0,class<`MaxTypeIndependenceTestStatistic`>,1
+coin,covariance,1,6,0,...,1
+coin,covariance,-1,7,0,class<`matrix`>,1
+coin,covariance,0,7,0,class<`CovarianceMatrix`>,1
+coin,covariance,1,7,0,...,1
+coin,covariance,-1,8,0,class<`matrix`>,1
+coin,covariance,0,8,0,class<`IndependenceLinearStatistic`>,1
+coin,covariance,1,8,0,...,1
+coin,covariance,-1,9,0,class<`matrix`>,1
+coin,covariance,0,9,0,class<`MaxTypeIndependenceTest`>,1
+coin,covariance,1,9,0,...,1
+coin,cSR_shift_2sample,-1,0,0,list<double[]>,1
+coin,cSR_shift_2sample,0,0,0,double[],1
+coin,cSR_shift_2sample,1,0,0,integer,1
+coin,cSR_shift_2sample,2,0,0,double,1
+coin,dperm,-1,0,0,class<`matrix`>,1
+coin,dperm,-1,0,1,double[],1
+coin,dperm,-1,0,2,null,1
+coin,dperm,0,0,0,class<`ApproxNullDistribution`>,1
+coin,dperm,0,0,1,class<`AsymptNullDistribution`>,1
+coin,dperm,0,0,2,class<`ExactNullDistribution`>,1
+coin,dperm,0,0,3,class<`MaxTypeIndependenceTest`>,1
+coin,dperm,0,0,4,class<`QuadTypeIndependenceTest`>,1
+coin,dperm,0,0,5,class<`ScalarIndependenceTest`>,1
+coin,dperm,1,0,0,any,1
+coin,dperm,2,0,0,...,1
+coin,dperm,-1,1,0,class<`matrix`>,1
+coin,dperm,-1,1,1,double[],1
+coin,dperm,0,1,0,class<`ApproxNullDistribution`>,1
+coin,dperm,1,1,0,class<`matrix`>,1
+coin,dperm,1,1,1,double[],1
+coin,dperm,2,1,0,...,1
+coin,dperm,-1,2,0,class<`matrix`>,1
+coin,dperm,-1,2,1,double[],1
+coin,dperm,0,2,0,class<`QuadTypeIndependenceTest`>,1
+coin,dperm,1,2,0,class<`matrix`>,1
+coin,dperm,1,2,1,integer[],1
+coin,dperm,1,2,2,double,1
+coin,dperm,2,2,0,...,1
+coin,dperm,-1,3,0,class<`matrix`>,1
+coin,dperm,-1,3,1,double[],1
+coin,dperm,0,3,0,class<`ExactNullDistribution`>,1
+coin,dperm,1,3,0,class<`matrix`>,1
+coin,dperm,1,3,1,double[],1
+coin,dperm,2,3,0,...,1
+coin,dperm,-1,4,0,class<`matrix`>,1
+coin,dperm,-1,4,1,double[],1
+coin,dperm,-1,4,2,null,1
+coin,dperm,0,4,0,class<`AsymptNullDistribution`>,1
+coin,dperm,1,4,0,any,1
+coin,dperm,2,4,0,...,1
+coin,dperm,-1,5,0,class<`matrix`>,1
+coin,dperm,-1,5,1,double[],1
+coin,dperm,0,5,0,class<`ScalarIndependenceTest`>,1
+coin,dperm,1,5,0,class<`matrix`>,1
+coin,dperm,1,5,1,double[],1
+coin,dperm,2,5,0,...,1
+coin,dperm,-1,6,0,class<`matrix`>,1
+coin,dperm,-1,6,1,double[],1
+coin,dperm,-1,6,2,null,1
+coin,dperm,0,6,0,class<`MaxTypeIndependenceTest`>,1
+coin,dperm,1,6,0,any,1
+coin,dperm,2,6,0,...,1
+coin,%EQ%,-1,0,0,class<`matrix`>,1
+coin,%EQ%,-1,0,1,^logical[],1
+coin,%EQ%,0,0,0,class<`matrix`>,1
+coin,%EQ%,0,0,1,^double[],1
+coin,%EQ%,1,0,0,double,1
+coin,exact,-1,0,0,class<`function`>,1
+coin,exact,0,0,0,character[],1
+coin,exact,1,0,0,null,1
+coin,exact,1,0,1,double,1
+coin,ExactNullDistribution,-1,0,0,any,1
+coin,ExactNullDistribution,0,0,0,class<`ScalarIndependenceTestStatistic`>,1
+coin,ExactNullDistribution,1,0,0,...,1
+coin,ExactNullDistribution,-1,1,0,any,1
+coin,ExactNullDistribution,0,1,0,class<`QuadTypeIndependenceTestStatistic`>,1
+coin,ExactNullDistribution,0,1,1,class<`ScalarIndependenceTestStatistic`>,1
+coin,ExactNullDistribution,1,1,0,...,1
+coin,ExactNullDistribution,-1,2,0,class<`ExactNullDistribution`>,1
+coin,ExactNullDistribution,0,2,0,class<`QuadTypeIndependenceTestStatistic`>,1
+coin,ExactNullDistribution,1,2,0,...,1
+coin,expectation,-1,0,0,double,1
+coin,expectation,0,0,0,class<`ScalarIndependenceTest`>,1
+coin,expectation,1,0,0,...,1
+coin,expectation,-1,1,0,double,1
+coin,expectation,0,1,0,class<`ScalarIndependenceTestConfint`>,1
+coin,expectation,1,1,0,...,1
+coin,expectation,-1,2,0,double[],1
+coin,expectation,0,2,0,class<`MaxTypeIndependenceTestStatistic`>,1
+coin,expectation,1,2,0,...,1
+coin,expectation,-1,3,0,double[],1
+coin,expectation,0,3,0,class<`QuadTypeIndependenceTest`>,1
+coin,expectation,1,3,0,...,1
+coin,expectation,-1,4,0,double[],1
+coin,expectation,0,4,0,class<`IndependenceLinearStatistic`>,1
+coin,expectation,1,4,0,...,1
+coin,expectation,-1,5,0,double[],1
+coin,expectation,0,5,0,class<`QuadTypeIndependenceTestStatistic`>,1
+coin,expectation,1,5,0,...,1
+coin,expectation,-1,6,0,double[],1
+coin,expectation,0,6,0,class<`IndependenceLinearStatistic`>,1
+coin,expectation,0,6,1,class<`ScalarIndependenceTestStatistic`>,1
+coin,expectation,0,6,2,class<`MaxTypeIndependenceTestStatistic`>,1
+coin,expectation,0,6,3,class<`QuadTypeIndependenceTest`>,1
+coin,expectation,0,6,4,class<`QuadTypeIndependenceTestStatistic`>,1
+coin,expectation,0,6,5,class<`ScalarIndependenceTestConfint`>,1
+coin,expectation,0,6,6,class<`MaxTypeIndependenceTest`>,1
+coin,expectation,0,6,7,class<`ScalarIndependenceTest`>,1
+coin,expectation,1,6,0,...,1
+coin,expectation,-1,7,0,double[],1
+coin,expectation,0,7,0,class<`MaxTypeIndependenceTest`>,1
+coin,expectation,1,7,0,...,1
+coin,expectation,-1,8,0,double,1
+coin,expectation,0,8,0,class<`ScalarIndependenceTestStatistic`>,1
+coin,expectation,1,8,0,...,1
+coin,fisyat_test,-1,0,0,any,1
+coin,fisyat_test,0,0,0,class<`formula`>,1
+coin,fisyat_test,0,0,1,class<`IndependenceProblem`>,1
+coin,fisyat_test,1,0,0,...,1
+coin,fisyat_test.formula,-1,0,0,any,1
+coin,fisyat_test.formula,0,0,0,class<`formula`>,1
+coin,fisyat_test.formula,1,0,0,class<`data.frame`>,1
+coin,fisyat_test.formula,2,0,0,null,1
+coin,fisyat_test.formula,3,0,0,null,1
+coin,fisyat_test.formula,4,0,0,...,1
+coin,fisyat_test.IndependenceProblem,-1,0,0,any,1
+coin,fisyat_test.IndependenceProblem,0,0,0,class<`IndependenceProblem`>,1
+coin,fisyat_test.IndependenceProblem,1,0,0,character[],1
+coin,fisyat_test.IndependenceProblem,2,0,0,character[],1
+coin,fisyat_test.IndependenceProblem,3,0,0,...,1
+coin,fligner_test,-1,0,0,any,1
+coin,fligner_test,0,0,0,class<`formula`>,1
+coin,fligner_test,0,0,1,class<`IndependenceProblem`>,1
+coin,fligner_test,1,0,0,...,1
+coin,fligner_test.formula,-1,0,0,any,1
+coin,fligner_test.formula,0,0,0,class<`formula`>,1
+coin,fligner_test.formula,1,0,0,class<`data.frame`>,1
+coin,fligner_test.formula,1,0,1,list<any>,1
+coin,fligner_test.formula,2,0,0,null,1
+coin,fligner_test.formula,3,0,0,null,1
+coin,fligner_test.formula,4,0,0,...,1
+coin,fligner_test.IndependenceProblem,-1,0,0,any,1
+coin,fligner_test.IndependenceProblem,0,0,0,class<`IndependenceProblem`>,1
+coin,fligner_test.IndependenceProblem,1,0,0,any,1
+coin,fligner_test.IndependenceProblem,2,0,0,logical,1
+coin,fligner_test.IndependenceProblem,3,0,0,double,1
+coin,fligner_test.IndependenceProblem,4,0,0,...,1
+coin,fligner_trafo,-1,0,0,^double[],1
+coin,fligner_trafo,0,0,0,^integer[],1
+coin,fligner_trafo,0,0,1,class<`array`>,1
+coin,fligner_trafo,0,0,2,double[],1
+coin,fligner_trafo,1,0,0,character[],1
+coin,fmaxstat_trafo,-1,0,0,class<`matrix`>,1
+coin,fmaxstat_trafo,0,0,0,class<`factor`>,1
+coin,fmaxstat_trafo,1,0,0,double,1
+coin,fmaxstat_trafo,2,0,0,double,1
+coin,formula2data,-1,0,0,list<class<`data.frame`> | class<`factor`> | double[]>,1
+coin,formula2data,-1,0,1,list<class<`data.frame`> | class<`factor`> | null>,1
+coin,formula2data,-1,0,2,list<class<`data.frame`> | double[] | null>,1
+coin,formula2data,-1,0,3,list<class<`data.frame`> | null | double[]>,1
+coin,formula2data,-1,0,4,list<class<`data.frame`> | null | integer[]>,1
+coin,formula2data,-1,0,5,list<class<`data.frame`> | null>,1
+coin,formula2data,0,0,0,class<`formula`>,1
+coin,formula2data,1,0,0,class<`data.frame`>,1
+coin,formula2data,1,0,1,list<any>,1
+coin,formula2data,2,0,0,null,1
+coin,formula2data,2,0,1,double[],1
+coin,formula2data,3,0,0,class<`formula`>,1
+coin,formula2data,3,0,1,null,1
+coin,formula2data,4,0,0,...,1
+coin,friedman_test,-1,0,0,any,1
+coin,friedman_test,0,0,0,class<`formula`>,1
+coin,friedman_test,0,0,1,class<`SymmetryProblem`>,1
+coin,friedman_test,1,0,0,...,1
+coin,friedman_test.formula,-1,0,0,any,1
+coin,friedman_test.formula,0,0,0,class<`formula`>,1
+coin,friedman_test.formula,1,0,0,class<`data.frame`>,1
+coin,friedman_test.formula,1,0,1,list<any>,1
+coin,friedman_test.formula,2,0,0,null,1
+coin,friedman_test.formula,3,0,0,...,1
+coin,friedman_test.SymmetryProblem,-1,0,0,any,1
+coin,friedman_test.SymmetryProblem,0,0,0,class<`SymmetryProblem`>,1
+coin,friedman_test.SymmetryProblem,1,0,0,...,1
+coin,fsplits,-1,0,0,class<`matrix`>,1
+coin,fsplits,0,0,0,integer,1
+coin,ft,-1,0,0,any,1
+coin,ft,0,0,0,character,1
+coin,ft,1,0,0,character,1
+coin,ft,2,0,0,class<`formula`>,1
+coin,ft,3,0,0,class<`data.frame`>,1
+coin,ft,3,0,1,list<any>,1
+coin,ft,4,0,0,null,1
+coin,ft,4,0,1,double[],1
+coin,ft,5,0,0,class<`formula`>,1
+coin,ft,5,0,1,null,1
+coin,ft,6,0,0,...,1
+coin,f_trafo,-1,0,0,class<`matrix`>,1
+coin,f_trafo,0,0,0,class<`factor`>,1
+coin,%GE%,-1,0,0,class<`matrix`>,1
+coin,%GE%,-1,0,1,logical[],1
+coin,%GE%,0,0,0,class<`matrix`>,1
+coin,%GE%,0,0,1,"class<`matrix`, `pvalue`>",1
+coin,%GE%,0,0,2,double[],1
+coin,%GE%,1,0,0,double[],1
+coin,%GE%,1,0,1,"class<`matrix`, `pvalue`>",1
+coin,%GT%,-1,0,0,class<`array`>,1
+coin,%GT%,-1,0,1,logical[],1
+coin,%GT%,0,0,0,class<`array`>,1
+coin,%GT%,0,0,1,double[],1
+coin,%GT%,1,0,0,double,1
+coin,has_distribution,-1,0,0,logical,1
+coin,has_distribution,0,0,0,list<character[] | class<`function`> | null>,1
+coin,has_distribution,0,0,1,list<character | class<`function`> | null>,1
+coin,has_distribution,0,0,2,list<class<`function`> | character[] | null>,1
+coin,id_trafo,-1,0,0,^integer[],1
+coin,id_trafo,0,0,0,^integer[],1
+coin,independence_test,-1,0,0,any,1
+coin,independence_test,0,0,0,class<`formula`>,1
+coin,independence_test,0,0,1,class<`IndependenceProblem`>,1
+coin,independence_test,0,0,2,class<`table`>,1
+coin,independence_test,1,0,0,...,1
+coin,independence_test.formula,-1,0,0,any,1
+coin,independence_test.formula,0,0,0,class<`formula`>,1
+coin,independence_test.formula,1,0,0,class<`data.frame`>,1
+coin,independence_test.formula,1,0,1,list<any>,1
+coin,independence_test.formula,2,0,0,null,1
+coin,independence_test.formula,2,0,1,double[],1
+coin,independence_test.formula,3,0,0,class<`formula`>,1
+coin,independence_test.formula,3,0,1,null,1
+coin,independence_test.formula,4,0,0,...,1
+coin,independence_test.IndependenceProblem,-1,0,0,any,1
+coin,independence_test.IndependenceProblem,0,0,0,class<`IndependenceProblem`>,1
+coin,independence_test.IndependenceProblem,1,0,0,character[],1
+coin,independence_test.IndependenceProblem,2,0,0,character[],1
+coin,independence_test.IndependenceProblem,2,0,1,class<`function`>,1
+coin,independence_test.IndependenceProblem,3,0,0,character[],1
+coin,independence_test.IndependenceProblem,4,0,0,class<`function`>,1
+coin,independence_test.IndependenceProblem,5,0,0,any,1
+coin,independence_test.IndependenceProblem,6,0,0,null,1
+coin,independence_test.IndependenceProblem,6,0,1,list<double[]>,1
+coin,independence_test.IndependenceProblem,7,0,0,null,1
+coin,independence_test.IndependenceProblem,7,0,1,class<`function`>,1
+coin,independence_test.table,-1,0,0,class<`MaxTypeIndependenceTest`>,1
+coin,independence_test.table,-1,0,1,class<`QuadTypeIndependenceTest`>,1
+coin,independence_test.table,-1,0,2,class<`ScalarIndependenceTest`>,1
+coin,independence_test.table,0,0,0,class<`table`>,1
+coin,independence_test.table,1,0,0,...,1
+coin,is_2sample,-1,0,0,logical,1
+coin,is_2sample,0,0,0,class<`IndependenceProblem`>,1
+coin,is_2sample,0,0,1,class<`IndependenceTestProblem`>,1
+coin,is_2sample,0,0,2,class<`MaxTypeIndependenceTestStatistic`>,1
+coin,is_2sample,0,0,3,class<`QuadTypeIndependenceTestStatistic`>,1
+coin,is_2sample,0,0,4,class<`ScalarIndependenceTestStatistic`>,1
+coin,is_2sample,0,0,5,class<`SymmetryProblem`>,1
+coin,is_censored_x,-1,0,0,logical,1
+coin,is_censored_x,0,0,0,class<`IndependenceTestProblem`>,1
+coin,is_censored_x,0,0,1,class<`MaxTypeIndependenceTestStatistic`>,1
+coin,is_censored_x,0,0,2,class<`QuadTypeIndependenceTestStatistic`>,1
+coin,is_censored_x,0,0,3,class<`ScalarIndependenceTestStatistic`>,1
+coin,is_censored_y,-1,0,0,logical,1
+coin,is_censored_y,0,0,0,class<`IndependenceTestProblem`>,1
+coin,is_censored_y,0,0,1,class<`MaxTypeIndependenceTestStatistic`>,1
+coin,is_censored_y,0,0,2,class<`QuadTypeIndependenceTestStatistic`>,1
+coin,is_censored_y,0,0,3,class<`ScalarIndependenceTestStatistic`>,1
+coin,is_completeblock,-1,0,0,logical,1
+coin,is_completeblock,0,0,0,class<`SymmetryProblem`>,1
+coin,is_contingency,-1,0,0,logical,1
+coin,is_contingency,0,0,0,class<`IndependenceTestProblem`>,1
+coin,is_contingency,0,0,1,class<`MaxTypeIndependenceTestStatistic`>,1
+coin,is_contingency,0,0,2,class<`ScalarIndependenceTestStatistic`>,1
+coin,is_contingency_2x2,-1,0,0,logical,1
+coin,is_contingency_2x2,0,0,0,class<`MaxTypeIndependenceTestStatistic`>,1
+coin,is_contingency_2x2,0,0,1,class<`ScalarIndependenceTestStatistic`>,1
+coin,is_corr,-1,0,0,logical,1
+coin,is_corr,0,0,0,class<`IndependenceTestProblem`>,1
+coin,is_corr,0,0,1,class<`MaxTypeIndependenceTestStatistic`>,1
+coin,is_corr,0,0,2,class<`ScalarIndependenceTestStatistic`>,1
+coin,is_doubly_ordered,-1,0,0,logical,1
+coin,is_doubly_ordered,0,0,0,class<`IndependenceTestProblem`>,1
+coin,is_doubly_ordered,0,0,1,class<`MaxTypeIndependenceTestStatistic`>,1
+coin,is_doubly_ordered,0,0,2,class<`QuadTypeIndependenceTestStatistic`>,1
+coin,is_doubly_ordered,0,0,3,class<`ScalarIndependenceTestStatistic`>,1
+coin,isequal,-1,0,0,logical,1
+coin,isequal,0,0,0,character,1
+coin,isequal,0,0,1,class<`matrix`>,1
+coin,isequal,0,0,2,"class<`numeric`, `pvalue`>",1
+coin,isequal,0,0,3,double[],1
+coin,isequal,0,0,4,null,1
+coin,isequal,1,0,0,character,1
+coin,isequal,1,0,1,class<`matrix`>,1
+coin,isequal,1,0,2,"class<`numeric`, `pvalue`>",1
+coin,isequal,1,0,3,double[],1
+coin,isequal,1,0,4,null,1
+coin,is_factor_x,-1,0,0,logical,1
+coin,is_factor_x,0,0,0,class<`IndependenceTestProblem`>,1
+coin,is_factor_x,0,0,1,class<`MaxTypeIndependenceTestStatistic`>,1
+coin,is_factor_x,0,0,2,class<`ScalarIndependenceTestStatistic`>,1
+coin,is_factor_y,-1,0,0,logical,1
+coin,is_factor_y,0,0,0,class<`IndependenceTestProblem`>,1
+coin,is_factor_y,0,0,1,class<`MaxTypeIndependenceTestStatistic`>,1
+coin,is_factor_y,0,0,2,class<`ScalarIndependenceTestStatistic`>,1
+coin,is_integer,-1,0,0,logical,1
+coin,is_integer,0,0,0,double[],1
+coin,is_integer,1,0,0,null,1
+coin,is_integer,1,0,1,double,1
+coin,is_Ksample,-1,0,0,logical,1
+coin,is_Ksample,0,0,0,class<`IndependenceTestProblem`>,1
+coin,is_Ksample,0,0,1,class<`MaxTypeIndependenceTestStatistic`>,1
+coin,is_Ksample,0,0,2,class<`ScalarIndependenceTestStatistic`>,1
+coin,is_numeric_x,-1,0,0,logical,1
+coin,is_numeric_x,0,0,0,class<`IndependenceTestProblem`>,1
+coin,is_numeric_x,0,0,1,class<`MaxTypeIndependenceTestStatistic`>,1
+coin,is_numeric_x,0,0,2,class<`QuadTypeIndependenceTestStatistic`>,1
+coin,is_numeric_x,0,0,3,class<`ScalarIndependenceTestStatistic`>,1
+coin,is_numeric_y,-1,0,0,logical,1
+coin,is_numeric_y,0,0,0,class<`IndependenceProblem`>,1
+coin,is_numeric_y,0,0,1,class<`IndependenceTestProblem`>,1
+coin,is_numeric_y,0,0,2,class<`MaxTypeIndependenceTestStatistic`>,1
+coin,is_numeric_y,0,0,3,class<`QuadTypeIndependenceTestStatistic`>,1
+coin,is_numeric_y,0,0,4,class<`ScalarIndependenceTestStatistic`>,1
+coin,is_numeric_y,0,0,5,class<`SymmetryProblem`>,1
+coin,is_ordered,-1,0,0,logical,1
+coin,is_ordered,0,0,0,class<`MaxTypeIndependenceTestStatistic`>,1
+coin,is_ordered,0,0,1,class<`QuadTypeIndependenceTestStatistic`>,1
+coin,is_ordered,0,0,2,class<`ScalarIndependenceTestStatistic`>,1
+coin,is_ordered_x,-1,0,0,logical,1
+coin,is_ordered_x,0,0,0,class<`IndependenceProblem`>,1
+coin,is_ordered_x,0,0,1,class<`IndependenceTestProblem`>,1
+coin,is_ordered_x,0,0,2,class<`MaxTypeIndependenceTestStatistic`>,1
+coin,is_ordered_x,0,0,3,class<`QuadTypeIndependenceTestStatistic`>,1
+coin,is_ordered_x,0,0,4,class<`ScalarIndependenceTestStatistic`>,1
+coin,is_ordered_x,0,0,5,class<`SymmetryProblem`>,1
+coin,is_ordered_y,-1,0,0,logical,1
+coin,is_ordered_y,0,0,0,class<`IndependenceTestProblem`>,1
+coin,is_ordered_y,0,0,1,class<`MaxTypeIndependenceTestStatistic`>,1
+coin,is_ordered_y,0,0,2,class<`QuadTypeIndependenceTestStatistic`>,1
+coin,is_ordered_y,0,0,3,class<`ScalarIndependenceTestStatistic`>,1
+coin,is_scalar,-1,0,0,logical,1
+coin,is_scalar,0,0,0,class<`IndependenceTestProblem`>,1
+coin,is_singly_ordered,-1,0,0,logical,1
+coin,is_singly_ordered,0,0,0,class<`MaxTypeIndependenceTestStatistic`>,1
+coin,is_singly_ordered,0,0,1,class<`QuadTypeIndependenceTestStatistic`>,1
+coin,is_singly_ordered,0,0,2,class<`ScalarIndependenceTestStatistic`>,1
+coin,is_unity,-1,0,0,logical,1
+coin,is_unity,0,0,0,double[],1
+coin,is_unordered_x,-1,0,0,logical,1
+coin,is_unordered_x,0,0,0,class<`MaxTypeIndependenceTestStatistic`>,1
+coin,is_unordered_x,0,0,1,class<`QuadTypeIndependenceTestStatistic`>,1
+coin,is_unordered_x,0,0,2,class<`ScalarIndependenceTestStatistic`>,1
+coin,is_unordered_y,-1,0,0,logical,1
+coin,is_unordered_y,0,0,0,class<`MaxTypeIndependenceTestStatistic`>,1
+coin,is_unordered_y,0,0,1,class<`QuadTypeIndependenceTestStatistic`>,1
+coin,is_unordered_y,0,0,2,class<`ScalarIndependenceTestStatistic`>,1
+coin,is_ytrafo,-1,0,0,logical,1
+coin,joint,-1,0,0,"class<`matrix`, `pvalue`>",1
+coin,joint,0,0,0,class<`MaxTypeIndependenceTestStatistic`>,1
+coin,joint,1,0,0,class<`AsymptNullDistribution`>,1
+coin,joint,2,0,0,...,1
+coin,joint,-1,1,0,"class<`matrix`, `pvalue`>",1
+coin,joint,0,1,0,class<`MaxTypeIndependenceTest`>,1
+coin,joint,0,1,1,class<`MaxTypeIndependenceTestStatistic`>,1
+coin,joint,1,1,0,any,1
+coin,joint,2,1,0,...,1
+coin,joint,-1,2,0,"class<`matrix`, `pvalue`>",1
+coin,joint,0,2,0,class<`MaxTypeIndependenceTestStatistic`>,1
+coin,joint,1,2,0,class<`ApproxNullDistribution`>,1
+coin,joint,2,2,0,...,1
+coin,joint,-1,3,0,"class<`matrix`, `pvalue`>",1
+coin,joint,0,3,0,class<`MaxTypeIndependenceTestStatistic`>,1
+coin,joint,1,3,0,class<`AsymptNullDistribution`>,1
+coin,joint,2,3,0,...,1
+coin,joint,-1,4,0,"class<`matrix`, `pvalue`>",1
+coin,joint,0,4,0,class<`MaxTypeIndependenceTestStatistic`>,1
+coin,joint,1,4,0,class<`ApproxNullDistribution`>,1
+coin,joint,2,4,0,...,1
+coin,joint,-1,5,0,"class<`matrix`, `pvalue`>",1
+coin,joint,0,5,0,class<`MaxTypeIndependenceTest`>,1
+coin,joint,1,5,0,any,1
+coin,joint,2,5,0,...,1
+coin,klotz_test,-1,0,0,any,1
+coin,klotz_test,0,0,0,class<`formula`>,1
+coin,klotz_test,0,0,1,class<`IndependenceProblem`>,1
+coin,klotz_test,1,0,0,...,1
+coin,klotz_test.formula,-1,0,0,any,1
+coin,klotz_test.formula,0,0,0,class<`formula`>,1
+coin,klotz_test.formula,1,0,0,class<`data.frame`>,1
+coin,klotz_test.formula,1,0,1,list<any>,1
+coin,klotz_test.formula,2,0,0,null,1
+coin,klotz_test.formula,3,0,0,null,1
+coin,klotz_test.formula,4,0,0,...,1
+coin,klotz_test.IndependenceProblem,-1,0,0,any,1
+coin,klotz_test.IndependenceProblem,0,0,0,class<`IndependenceProblem`>,1
+coin,klotz_test.IndependenceProblem,1,0,0,any,1
+coin,klotz_test.IndependenceProblem,2,0,0,logical,1
+coin,klotz_test.IndependenceProblem,3,0,0,double,1
+coin,klotz_test.IndependenceProblem,4,0,0,...,1
+coin,klotz_trafo,-1,0,0,^double[],1
+coin,klotz_trafo,0,0,0,^integer[],1
+coin,klotz_trafo,0,0,1,double[],1
+coin,klotz_trafo,1,0,0,character[],1
+coin,koziol_test,-1,0,0,any,1
+coin,koziol_test,0,0,0,class<`formula`>,1
+coin,koziol_test,0,0,1,class<`IndependenceProblem`>,1
+coin,koziol_test,1,0,0,...,1
+coin,koziol_test.formula,-1,0,0,any,1
+coin,koziol_test.formula,0,0,0,class<`formula`>,1
+coin,koziol_test.formula,1,0,0,class<`data.frame`>,1
+coin,koziol_test.formula,2,0,0,null,1
+coin,koziol_test.formula,3,0,0,null,1
+coin,koziol_test.formula,4,0,0,...,1
+coin,koziol_test.IndependenceProblem,-1,0,0,any,1
+coin,koziol_test.IndependenceProblem,0,0,0,class<`IndependenceProblem`>,1
+coin,koziol_test.IndependenceProblem,1,0,0,character[],1
+coin,koziol_test.IndependenceProblem,2,0,0,character[],1
+coin,koziol_test.IndependenceProblem,3,0,0,...,1
+coin,koziol_trafo,-1,0,0,^double[],1
+coin,koziol_trafo,0,0,0,^integer[],1
+coin,koziol_trafo,0,0,1,double[],1
+coin,koziol_trafo,1,0,0,character[],1
+coin,koziol_trafo,2,0,0,double,1
+coin,kruskal_test,-1,0,0,any,1
+coin,kruskal_test,0,0,0,class<`formula`>,1
+coin,kruskal_test,0,0,1,class<`IndependenceProblem`>,1
+coin,kruskal_test,1,0,0,...,1
+coin,kruskal_test.formula,-1,0,0,any,1
+coin,kruskal_test.formula,0,0,0,class<`formula`>,1
+coin,kruskal_test.formula,1,0,0,class<`data.frame`>,1
+coin,kruskal_test.formula,1,0,1,list<any>,1
+coin,kruskal_test.formula,2,0,0,null,1
+coin,kruskal_test.formula,3,0,0,null,1
+coin,kruskal_test.formula,4,0,0,...,1
+coin,kruskal_test.IndependenceProblem,-1,0,0,any,1
+coin,kruskal_test.IndependenceProblem,0,0,0,class<`IndependenceProblem`>,1
+coin,kruskal_test.IndependenceProblem,1,0,0,...,1
+coin,lbl_test,-1,0,0,class<`ScalarIndependenceTest`>,1
+coin,lbl_test,0,0,0,class<`formula`>,1
+coin,lbl_test,0,0,1,class<`IndependenceProblem`>,1
+coin,lbl_test,0,0,2,class<`table`>,1
+coin,lbl_test,1,0,0,...,1
+coin,lbl_test.formula,-1,0,0,class<`ScalarIndependenceTest`>,1
+coin,lbl_test.formula,0,0,0,class<`formula`>,1
+coin,lbl_test.formula,1,0,0,class<`data.frame`>,1
+coin,lbl_test.formula,2,0,0,null,1
+coin,lbl_test.formula,3,0,0,null,1
+coin,lbl_test.formula,4,0,0,...,1
+coin,lbl_test.IndependenceProblem,-1,0,0,class<`ScalarIndependenceTest`>,1
+coin,lbl_test.IndependenceProblem,0,0,0,class<`IndependenceProblem`>,1
+coin,lbl_test.IndependenceProblem,1,0,0,...,1
+coin,lbl_test.table,-1,0,0,class<`ScalarIndependenceTest`>,1
+coin,lbl_test.table,0,0,0,class<`table`>,1
+coin,lbl_test.table,1,0,0,...,1
+coin,%LE%,-1,0,0,class<`array`>,1
+coin,%LE%,-1,0,1,class<`matrix`>,1
+coin,%LE%,-1,0,2,logical[],1
+coin,%LE%,0,0,0,class<`array`>,1
+coin,%LE%,0,0,1,class<`matrix`>,1
+coin,%LE%,0,0,2,double[],1
+coin,%LE%,1,0,0,double[],1
+coin,logrank_test,-1,0,0,class<`QuadTypeIndependenceTest`>,1
+coin,logrank_test,-1,0,1,class<`ScalarIndependenceTest`>,1
+coin,logrank_test,0,0,0,class<`formula`>,1
+coin,logrank_test,0,0,1,class<`IndependenceProblem`>,1
+coin,logrank_test,1,0,0,...,1
+coin,logrank_test.formula,-1,0,0,class<`QuadTypeIndependenceTest`>,1
+coin,logrank_test.formula,-1,0,1,class<`ScalarIndependenceTest`>,1
+coin,logrank_test.formula,0,0,0,class<`formula`>,1
+coin,logrank_test.formula,1,0,0,class<`data.frame`>,1
+coin,logrank_test.formula,2,0,0,null,1
+coin,logrank_test.formula,3,0,0,null,1
+coin,logrank_test.formula,4,0,0,...,1
+coin,logrank_test.IndependenceProblem,-1,0,0,class<`QuadTypeIndependenceTest`>,1
+coin,logrank_test.IndependenceProblem,-1,0,1,class<`ScalarIndependenceTest`>,1
+coin,logrank_test.IndependenceProblem,0,0,0,class<`IndependenceProblem`>,1
+coin,logrank_test.IndependenceProblem,1,0,0,character[],1
+coin,logrank_test.IndependenceProblem,2,0,0,character[],1
+coin,logrank_test.IndependenceProblem,3,0,0,null,1
+coin,logrank_test.IndependenceProblem,3,0,1,double,1
+coin,logrank_test.IndependenceProblem,4,0,0,null,1
+coin,logrank_test.IndependenceProblem,5,0,0,...,1
+coin,logrank_trafo,-1,0,0,any,1
+coin,logrank_trafo,0,0,0,class<`Surv`>,1
+coin,logrank_trafo,1,0,0,character[],1
+coin,logrank_trafo,2,0,0,any,1
+coin,logrank_trafo,3,0,0,...,1
+coin,%LT%,-1,0,0,class<`array`>,1
+coin,%LT%,-1,0,1,logical[],1
+coin,%LT%,0,0,0,class<`array`>,1
+coin,%LT%,0,0,1,double[],1
+coin,%LT%,1,0,0,double,1
+coin,marginal,-1,0,0,"class<`matrix`, `pvalue`>",1
+coin,marginal,0,0,0,class<`MaxTypeIndependenceTestStatistic`>,1
+coin,marginal,1,0,0,class<`ApproxNullDistribution`>,1
+coin,marginal,2,0,0,...,1
+coin,marginal,-1,1,0,"class<`matrix`, `pvalue`>",1
+coin,marginal,0,1,0,class<`MaxTypeIndependenceTest`>,1
+coin,marginal,0,1,1,class<`MaxTypeIndependenceTestStatistic`>,1
+coin,marginal,1,1,0,any,1
+coin,marginal,2,1,0,...,1
+coin,marginal,-1,2,0,"class<`matrix`, `pvalue`>",1
+coin,marginal,0,2,0,class<`MaxTypeIndependenceTest`>,1
+coin,marginal,1,2,0,any,1
+coin,marginal,2,2,0,...,1
+coin,marginal,-1,3,0,"class<`matrix`, `pvalue`>",1
+coin,marginal,0,3,0,class<`MaxTypeIndependenceTestStatistic`>,1
+coin,marginal,1,3,0,class<`AsymptNullDistribution`>,1
+coin,marginal,2,3,0,...,1
+coin,maxstat_test,-1,0,0,class<`MaxTypeIndependenceTest`>,1
+coin,maxstat_test,-1,0,1,class<`ScalarIndependenceTest`>,1
+coin,maxstat_test,0,0,0,class<`formula`>,1
+coin,maxstat_test,0,0,1,class<`IndependenceProblem`>,1
+coin,maxstat_test,0,0,2,class<`table`>,1
+coin,maxstat_test,1,0,0,...,1
+coin,maxstat_test.formula,-1,0,0,class<`MaxTypeIndependenceTest`>,1
+coin,maxstat_test.formula,-1,0,1,class<`ScalarIndependenceTest`>,1
+coin,maxstat_test.formula,0,0,0,class<`formula`>,1
+coin,maxstat_test.formula,1,0,0,class<`data.frame`>,1
+coin,maxstat_test.formula,1,0,1,list<any>,1
+coin,maxstat_test.formula,2,0,0,null,1
+coin,maxstat_test.formula,3,0,0,null,1
+coin,maxstat_test.formula,4,0,0,...,1
+coin,maxstat_test.IndependenceProblem,-1,0,0,class<`MaxTypeIndependenceTest`>,1
+coin,maxstat_test.IndependenceProblem,-1,0,1,class<`ScalarIndependenceTest`>,1
+coin,maxstat_test.IndependenceProblem,0,0,0,class<`IndependenceProblem`>,1
+coin,maxstat_test.IndependenceProblem,1,0,0,character[],1
+coin,maxstat_test.IndependenceProblem,2,0,0,character[],1
+coin,maxstat_test.IndependenceProblem,2,0,1,class<`function`>,1
+coin,maxstat_test.IndependenceProblem,3,0,0,double,1
+coin,maxstat_test.IndependenceProblem,4,0,0,double,1
+coin,maxstat_test.IndependenceProblem,5,0,0,...,1
+coin,maxstat_test.table,-1,0,0,class<`MaxTypeIndependenceTest`>,1
+coin,maxstat_test.table,-1,0,1,class<`ScalarIndependenceTest`>,1
+coin,maxstat_test.table,0,0,0,class<`table`>,1
+coin,maxstat_test.table,1,0,0,...,1
+coin,maxstat_trafo,-1,0,0,class<`matrix`>,1
+coin,maxstat_trafo,0,0,0,double[],1
+coin,maxstat_trafo,0,0,1,^integer[],1
+coin,maxstat_trafo,0,0,2,"class<`factor`, `ordered`>",1
+coin,maxstat_trafo,1,0,0,double,1
+coin,maxstat_trafo,2,0,0,double,1
+coin,mcp_trafo,-1,0,0,class<`function`>,1
+coin,mcp_trafo,0,0,0,...,1
+coin,mcp_trafo,-1,1,0,class<`matrix`>,1
+coin,mcp_trafo,0,1,0,class<`data.frame`>,1
+coin,median_test,-1,0,0,any,1
+coin,median_test,0,0,0,class<`formula`>,1
+coin,median_test,0,0,1,class<`IndependenceProblem`>,1
+coin,median_test,1,0,0,...,1
+coin,median_test.formula,-1,0,0,any,1
+coin,median_test.formula,0,0,0,class<`formula`>,1
+coin,median_test.formula,1,0,0,class<`data.frame`>,1
+coin,median_test.formula,1,0,1,list<any>,1
+coin,median_test.formula,2,0,0,null,1
+coin,median_test.formula,3,0,0,null,1
+coin,median_test.formula,4,0,0,...,1
+coin,median_test.IndependenceProblem,-1,0,0,any,1
+coin,median_test.IndependenceProblem,0,0,0,class<`IndependenceProblem`>,1
+coin,median_test.IndependenceProblem,1,0,0,any,1
+coin,median_test.IndependenceProblem,2,0,0,logical,1
+coin,median_test.IndependenceProblem,3,0,0,double,1
+coin,median_test.IndependenceProblem,4,0,0,...,1
+coin,median_trafo,-1,0,0,^double[],1
+coin,median_trafo,0,0,0,^integer[],1
+coin,median_trafo,0,0,1,double[],1
+coin,median_trafo,1,0,0,character[],1
+coin,mh_test,-1,0,0,class<`QuadTypeIndependenceTest`>,1
+coin,mh_test,-1,0,1,class<`ScalarIndependenceTest`>,1
+coin,mh_test,0,0,0,class<`formula`>,1
+coin,mh_test,0,0,1,class<`SymmetryProblem`>,1
+coin,mh_test,0,0,2,class<`table`>,1
+coin,mh_test,1,0,0,...,1
+coin,mh_test.formula,-1,0,0,class<`QuadTypeIndependenceTest`>,1
+coin,mh_test.formula,0,0,0,class<`formula`>,1
+coin,mh_test.formula,1,0,0,class<`data.frame`>,1
+coin,mh_test.formula,2,0,0,null,1
+coin,mh_test.formula,3,0,0,...,1
+coin,mh_test.SymmetryProblem,-1,0,0,class<`QuadTypeIndependenceTest`>,1
+coin,mh_test.SymmetryProblem,-1,0,1,class<`ScalarIndependenceTest`>,1
+coin,mh_test.SymmetryProblem,0,0,0,class<`SymmetryProblem`>,1
+coin,mh_test.SymmetryProblem,1,0,0,...,1
+coin,mh_test.table,-1,0,0,class<`QuadTypeIndependenceTest`>,1
+coin,mh_test.table,-1,0,1,class<`ScalarIndependenceTest`>,1
+coin,mh_test.table,0,0,0,class<`table`>,1
+coin,mh_test.table,1,0,0,...,1
+coin,midpvalue,-1,0,0,"class<`numeric`, `pvalue`>",1
+coin,midpvalue,0,0,0,class<`ExactNullDistribution`>,1
+coin,midpvalue,0,0,1,class<`QuadTypeIndependenceTest`>,1
+coin,midpvalue,0,0,2,class<`ScalarIndependenceTest`>,1
+coin,midpvalue,0,0,3,class<`ApproxNullDistribution`>,1
+coin,midpvalue,0,0,4,class<`MaxTypeIndependenceTest`>,1
+coin,midpvalue,1,0,0,...,1
+coin,midpvalue,-1,1,0,"class<`numeric`, `pvalue`>",1
+coin,midpvalue,0,1,0,class<`MaxTypeIndependenceTest`>,1
+coin,midpvalue,1,1,0,...,1
+coin,midpvalue,-1,2,0,"class<`numeric`, `pvalue`>",1
+coin,midpvalue,0,2,0,class<`ScalarIndependenceTest`>,1
+coin,midpvalue,1,2,0,...,1
+coin,midpvalue,-1,3,0,"class<`numeric`, `pvalue`>",1
+coin,midpvalue,0,3,0,class<`QuadTypeIndependenceTest`>,1
+coin,midpvalue,1,3,0,...,1
+coin,midpvalue,-1,4,0,"class<`numeric`, `pvalue`>",1
+coin,midpvalue,0,4,0,class<`ApproxNullDistribution`>,1
+coin,midpvalue,1,4,0,...,1
+coin,midpvalue,-1,5,0,"class<`numeric`, `pvalue`>",1
+coin,midpvalue,0,5,0,class<`ApproxNullDistribution`>,1
+coin,midpvalue,1,5,0,...,1
+coin,midpvalue,-1,6,0,"class<`numeric`, `pvalue`>",1
+coin,midpvalue,0,6,0,class<`ExactNullDistribution`>,1
+coin,midpvalue,1,6,0,...,1
+coin,MonteCarlo,-1,0,0,class<`matrix`>,1
+coin,MonteCarlo,0,0,0,class<`matrix`>,1
+coin,MonteCarlo,1,0,0,class<`matrix`>,1
+coin,MonteCarlo,2,0,0,class<`factor`>,1
+coin,MonteCarlo,3,0,0,double[],1
+coin,MonteCarlo,4,0,0,double,1
+coin,MonteCarlo,5,0,0,character,1
+coin,MonteCarlo,6,0,0,any,1
+coin,MonteCarlo,7,0,0,any,1
+coin,mood_test,-1,0,0,any,1
+coin,mood_test,0,0,0,class<`formula`>,1
+coin,mood_test,0,0,1,class<`IndependenceProblem`>,1
+coin,mood_test,1,0,0,...,1
+coin,mood_test.formula,-1,0,0,any,1
+coin,mood_test.formula,0,0,0,class<`formula`>,1
+coin,mood_test.formula,1,0,0,class<`data.frame`>,1
+coin,mood_test.formula,1,0,1,list<any>,1
+coin,mood_test.formula,2,0,0,null,1
+coin,mood_test.formula,3,0,0,null,1
+coin,mood_test.formula,4,0,0,...,1
+coin,mood_test.IndependenceProblem,-1,0,0,any,1
+coin,mood_test.IndependenceProblem,0,0,0,class<`IndependenceProblem`>,1
+coin,mood_test.IndependenceProblem,1,0,0,any,1
+coin,mood_test.IndependenceProblem,2,0,0,logical,1
+coin,mood_test.IndependenceProblem,3,0,0,double,1
+coin,mood_test.IndependenceProblem,4,0,0,...,1
+coin,mood_trafo,-1,0,0,^double[],1
+coin,mood_trafo,0,0,0,^integer[],1
+coin,mood_trafo,0,0,1,double[],1
+coin,mood_trafo,1,0,0,character[],1
+coin,MPinv,-1,0,0,list<class<`matrix`> | integer>,1
+coin,MPinv,0,0,0,class<`matrix`>,1
+coin,MPinv,1,0,0,double,1
+coin,n_decimal_digits,-1,0,0,integer,1
+coin,n_decimal_digits,0,0,0,double[],1
+coin,%NE%,-1,0,0,logical[],1
+coin,%NE%,0,0,0,double[],1
+coin,%NE%,1,0,0,double[],1
+coin,normal_test,-1,0,0,any,1
+coin,normal_test,0,0,0,class<`formula`>,1
+coin,normal_test,0,0,1,class<`IndependenceProblem`>,1
+coin,normal_test,1,0,0,...,1
+coin,normal_test.formula,-1,0,0,any,1
+coin,normal_test.formula,0,0,0,class<`formula`>,1
+coin,normal_test.formula,1,0,0,class<`data.frame`>,1
+coin,normal_test.formula,1,0,1,list<any>,1
+coin,normal_test.formula,2,0,0,null,1
+coin,normal_test.formula,3,0,0,null,1
+coin,normal_test.formula,4,0,0,...,1
+coin,normal_test.IndependenceProblem,-1,0,0,any,1
+coin,normal_test.IndependenceProblem,0,0,0,class<`IndependenceProblem`>,1
+coin,normal_test.IndependenceProblem,1,0,0,any,1
+coin,normal_test.IndependenceProblem,2,0,0,logical,1
+coin,normal_test.IndependenceProblem,3,0,0,double,1
+coin,normal_test.IndependenceProblem,4,0,0,...,1
+coin,normal_trafo,-1,0,0,^double[],1
+coin,normal_trafo,0,0,0,double[],1
+coin,normal_trafo,0,0,1,^integer[],1
+coin,normal_trafo,1,0,0,character[],1
+coin,ofmaxstat_trafo,-1,0,0,class<`matrix`>,1
+coin,ofmaxstat_trafo,0,0,0,double[],1
+coin,ofmaxstat_trafo,0,0,1,^integer[],1
+coin,ofmaxstat_trafo,0,0,2,"class<`factor`, `ordered`>",1
+coin,ofmaxstat_trafo,1,0,0,double,1
+coin,ofmaxstat_trafo,2,0,0,double,1
+coin,of_trafo,-1,0,0,class<`matrix`>,1
+coin,of_trafo,0,0,0,class<`factor`>,1
+coin,of_trafo,0,0,1,"class<`factor`, `ordered`>",1
+coin,of_trafo,1,0,0,null,1
+coin,of_trafo,1,0,1,double[],1
+coin,of_trafo,1,0,2,list<double[]>,1
+coin,oneway_test,-1,0,0,any,1
+coin,oneway_test,0,0,0,class<`formula`>,1
+coin,oneway_test,0,0,1,class<`IndependenceProblem`>,1
+coin,oneway_test,1,0,0,...,1
+coin,oneway_test.formula,-1,0,0,any,1
+coin,oneway_test.formula,0,0,0,class<`formula`>,1
+coin,oneway_test.formula,1,0,0,class<`data.frame`>,1
+coin,oneway_test.formula,1,0,1,list<any>,1
+coin,oneway_test.formula,2,0,0,null,1
+coin,oneway_test.formula,3,0,0,null,1
+coin,oneway_test.formula,4,0,0,...,1
+coin,oneway_test.IndependenceProblem,-1,0,0,any,1
+coin,oneway_test.IndependenceProblem,0,0,0,class<`IndependenceProblem`>,1
+coin,oneway_test.IndependenceProblem,1,0,0,...,1
+coin,ordered_scores,-1,0,0,class<`matrix`>,1
+coin,ordered_scores,0,0,0,double,1
+coin,ordered_scores,1,0,0,double[],1
+coin,pmvn,-1,0,0,double,1
+coin,pmvn,0,0,0,double,1
+coin,pmvn,1,0,0,double,1
+coin,pmvn,2,0,0,double[],1
+coin,pmvn,3,0,0,class<`matrix`>,1
+coin,pmvn,4,0,0,logical,1
+coin,pmvn,5,0,0,...,1
+coin,pperm,-1,0,0,class<`matrix`>,1
+coin,pperm,-1,0,1,double[],1
+coin,pperm,0,0,0,class<`QuadTypeIndependenceTest`>,1
+coin,pperm,1,0,0,class<`matrix`>,1
+coin,pperm,1,0,1,integer[],1
+coin,pperm,1,0,2,double,1
+coin,pperm,2,0,0,...,1
+coin,pperm,-1,1,0,class<`matrix`>,1
+coin,pperm,-1,1,1,double[],1
+coin,pperm,0,1,0,class<`ApproxNullDistribution`>,1
+coin,pperm,1,1,0,class<`matrix`>,1
+coin,pperm,1,1,1,double[],1
+coin,pperm,2,1,0,...,1
+coin,pperm,-1,2,0,class<`matrix`>,1
+coin,pperm,-1,2,1,double[],1
+coin,pperm,0,2,0,class<`MaxTypeIndependenceTest`>,1
+coin,pperm,1,2,0,class<`matrix`>,1
+coin,pperm,1,2,1,integer[],1
+coin,pperm,1,2,2,double,1
+coin,pperm,2,2,0,...,1
+coin,pperm,-1,3,0,class<`matrix`>,1
+coin,pperm,-1,3,1,double[],1
+coin,pperm,0,3,0,class<`AsymptNullDistribution`>,1
+coin,pperm,1,3,0,class<`matrix`>,1
+coin,pperm,1,3,1,integer[],1
+coin,pperm,1,3,2,double,1
+coin,pperm,2,3,0,...,1
+coin,pperm,-1,4,0,class<`matrix`>,1
+coin,pperm,-1,4,1,double[],1
+coin,pperm,0,4,0,class<`ExactNullDistribution`>,1
+coin,pperm,1,4,0,class<`matrix`>,1
+coin,pperm,1,4,1,double[],1
+coin,pperm,2,4,0,...,1
+coin,pperm,-1,5,0,class<`matrix`>,1
+coin,pperm,-1,5,1,double[],1
+coin,pperm,0,5,0,class<`ScalarIndependenceTest`>,1
+coin,pperm,1,5,0,class<`matrix`>,1
+coin,pperm,1,5,1,double[],1
+coin,pperm,2,5,0,...,1
+coin,pperm,-1,6,0,class<`matrix`>,1
+coin,pperm,-1,6,1,double[],1
+coin,pperm,0,6,0,class<`ApproxNullDistribution`>,1
+coin,pperm,0,6,1,class<`AsymptNullDistribution`>,1
+coin,pperm,0,6,2,class<`ExactNullDistribution`>,1
+coin,pperm,0,6,3,class<`MaxTypeIndependenceTest`>,1
+coin,pperm,0,6,4,class<`QuadTypeIndependenceTest`>,1
+coin,pperm,0,6,5,class<`ScalarIndependenceTest`>,1
+coin,pperm,1,6,0,class<`matrix`>,1
+coin,pperm,1,6,1,double[],1
+coin,pperm,2,6,0,...,1
+coin,pvalue,-1,0,0,"class<`numeric`, `pvalue`>",1
+coin,pvalue,0,0,0,class<`ScalarIndependenceTestConfint`>,1
+coin,pvalue,1,0,0,...,1
+coin,pvalue,-1,1,0,"class<`numeric`, `pvalue`>",1
+coin,pvalue,0,1,0,class<`ExactNullDistribution`>,1
+coin,pvalue,1,1,0,...,1
+coin,pvalue,-1,2,0,"class<`matrix`, `pvalue`>",1
+coin,pvalue,-1,2,1,"class<`numeric`, `pvalue`>",1
+coin,pvalue,0,2,0,class<`MaxTypeIndependenceTest`>,1
+coin,pvalue,0,2,1,class<`AsymptNullDistribution`>,1
+coin,pvalue,0,2,2,class<`ExactNullDistribution`>,1
+coin,pvalue,0,2,3,class<`QuadTypeIndependenceTest`>,1
+coin,pvalue,0,2,4,class<`ScalarIndependenceTest`>,1
+coin,pvalue,0,2,5,class<`ScalarIndependenceTestConfint`>,1
+coin,pvalue,0,2,6,class<`ApproxNullDistribution`>,1
+coin,pvalue,1,2,0,...,1
+coin,pvalue,-1,3,0,"class<`numeric`, `pvalue`>",1
+coin,pvalue,0,3,0,class<`AsymptNullDistribution`>,1
+coin,pvalue,1,3,0,...,1
+coin,pvalue,-1,4,0,"class<`matrix`, `pvalue`>",1
+coin,pvalue,-1,4,1,"class<`numeric`, `pvalue`>",1
+coin,pvalue,0,4,0,class<`MaxTypeIndependenceTest`>,1
+coin,pvalue,1,4,0,...,1
+coin,pvalue,-1,5,0,"class<`numeric`, `pvalue`>",1
+coin,pvalue,0,5,0,class<`ApproxNullDistribution`>,1
+coin,pvalue,1,5,0,...,1
+coin,pvalue,-1,6,0,"class<`numeric`, `pvalue`>",1
+coin,pvalue,0,6,0,class<`ScalarIndependenceTest`>,1
+coin,pvalue,1,6,0,...,1
+coin,pvalue,-1,7,0,"class<`matrix`, `pvalue`>",1
+coin,pvalue,-1,7,1,"class<`numeric`, `pvalue`>",1
+coin,pvalue,0,7,0,class<`MaxTypeIndependenceTest`>,1
+coin,pvalue,1,7,0,...,1
+coin,pvalue,-1,8,0,"class<`numeric`, `pvalue`>",1
+coin,pvalue,0,8,0,class<`ApproxNullDistribution`>,1
+coin,pvalue,1,8,0,...,1
+coin,pvalue,-1,9,0,"class<`numeric`, `pvalue`>",1
+coin,pvalue,0,9,0,class<`QuadTypeIndependenceTest`>,1
+coin,pvalue,1,9,0,...,1
+coin,pvalue_interval,-1,0,0,double[],1
+coin,pvalue_interval,0,0,0,class<`QuadTypeIndependenceTest`>,1
+coin,pvalue_interval,1,0,0,...,1
+coin,pvalue_interval,-1,1,0,double[],1
+coin,pvalue_interval,0,1,0,class<`MaxTypeIndependenceTest`>,1
+coin,pvalue_interval,1,1,0,...,1
+coin,pvalue_interval,-1,2,0,double[],1
+coin,pvalue_interval,-1,2,1,null,1
+coin,pvalue_interval,0,2,0,class<`ScalarIndependenceTest`>,1
+coin,pvalue_interval,1,2,0,...,1
+coin,pvalue_interval,-1,3,0,class<`matrix`>,1
+coin,pvalue_interval,-1,3,1,double[],1
+coin,pvalue_interval,0,3,0,class<`ApproxNullDistribution`>,1
+coin,pvalue_interval,1,3,0,...,1
+coin,pvalue_interval,-1,4,0,class<`matrix`>,1
+coin,pvalue_interval,-1,4,1,double[],1
+coin,pvalue_interval,-1,4,2,null,1
+coin,pvalue_interval,0,4,0,class<`ExactNullDistribution`>,1
+coin,pvalue_interval,1,4,0,...,1
+coin,pvalue_interval,-1,5,0,class<`matrix`>,1
+coin,pvalue_interval,-1,5,1,double[],1
+coin,pvalue_interval,-1,5,2,null,1
+coin,pvalue_interval,0,5,0,class<`ApproxNullDistribution`>,1
+coin,pvalue_interval,0,5,1,class<`ExactNullDistribution`>,1
+coin,pvalue_interval,0,5,2,class<`MaxTypeIndependenceTest`>,1
+coin,pvalue_interval,0,5,3,class<`QuadTypeIndependenceTest`>,1
+coin,pvalue_interval,0,5,4,class<`ScalarIndependenceTest`>,1
+coin,pvalue_interval,1,5,0,...,1
+coin,qmvn,-1,0,0,double,1
+coin,qmvn,0,0,0,double,1
+coin,qmvn,1,0,0,double[],1
+coin,qmvn,2,0,0,class<`matrix`>,1
+coin,qmvn,3,0,0,...,1
+coin,qperm,-1,0,0,class<`matrix`>,1
+coin,qperm,-1,0,1,double[],1
+coin,qperm,0,0,0,class<`ApproxNullDistribution`>,1
+coin,qperm,0,0,1,class<`AsymptNullDistribution`>,1
+coin,qperm,0,0,2,class<`ExactNullDistribution`>,1
+coin,qperm,0,0,3,class<`MaxTypeIndependenceTest`>,1
+coin,qperm,0,0,4,class<`QuadTypeIndependenceTest`>,1
+coin,qperm,0,0,5,class<`ScalarIndependenceTest`>,1
+coin,qperm,1,0,0,class<`matrix`>,1
+coin,qperm,1,0,1,double[],1
+coin,qperm,2,0,0,...,1
+coin,qperm,-1,1,0,class<`matrix`>,1
+coin,qperm,-1,1,1,double[],1
+coin,qperm,0,1,0,class<`ExactNullDistribution`>,1
+coin,qperm,1,1,0,class<`matrix`>,1
+coin,qperm,1,1,1,double[],1
+coin,qperm,2,1,0,...,1
+coin,qperm,-1,2,0,class<`matrix`>,1
+coin,qperm,-1,2,1,double[],1
+coin,qperm,0,2,0,class<`AsymptNullDistribution`>,1
+coin,qperm,1,2,0,class<`matrix`>,1
+coin,qperm,1,2,1,double[],1
+coin,qperm,2,2,0,...,1
+coin,qperm,-1,3,0,class<`matrix`>,1
+coin,qperm,-1,3,1,double[],1
+coin,qperm,0,3,0,class<`MaxTypeIndependenceTest`>,1
+coin,qperm,1,3,0,class<`matrix`>,1
+coin,qperm,1,3,1,double[],1
+coin,qperm,2,3,0,...,1
+coin,qperm,-1,4,0,class<`matrix`>,1
+coin,qperm,-1,4,1,double[],1
+coin,qperm,0,4,0,class<`ScalarIndependenceTest`>,1
+coin,qperm,1,4,0,class<`matrix`>,1
+coin,qperm,1,4,1,double[],1
+coin,qperm,2,4,0,...,1
+coin,qperm,-1,5,0,class<`matrix`>,1
+coin,qperm,-1,5,1,double[],1
+coin,qperm,0,5,0,class<`QuadTypeIndependenceTest`>,1
+coin,qperm,1,5,0,class<`matrix`>,1
+coin,qperm,1,5,1,double[],1
+coin,qperm,2,5,0,...,1
+coin,qperm,-1,6,0,class<`matrix`>,1
+coin,qperm,-1,6,1,double[],1
+coin,qperm,0,6,0,class<`ApproxNullDistribution`>,1
+coin,qperm,1,6,0,class<`matrix`>,1
+coin,qperm,1,6,1,double[],1
+coin,qperm,2,6,0,...,1
+coin,quade_test,-1,0,0,any,1
+coin,quade_test,0,0,0,class<`formula`>,1
+coin,quade_test,0,0,1,class<`SymmetryProblem`>,1
+coin,quade_test,1,0,0,...,1
+coin,quade_test.formula,-1,0,0,any,1
+coin,quade_test.formula,0,0,0,class<`formula`>,1
+coin,quade_test.formula,1,0,0,class<`data.frame`>,1
+coin,quade_test.formula,1,0,1,list<any>,1
+coin,quade_test.formula,2,0,0,null,1
+coin,quade_test.formula,3,0,0,...,1
+coin,quade_test.SymmetryProblem,-1,0,0,any,1
+coin,quade_test.SymmetryProblem,0,0,0,class<`SymmetryProblem`>,1
+coin,quade_test.SymmetryProblem,1,0,0,...,1
+coin,quadrant_test,-1,0,0,any,1
+coin,quadrant_test,0,0,0,class<`formula`>,1
+coin,quadrant_test,0,0,1,class<`IndependenceProblem`>,1
+coin,quadrant_test,1,0,0,...,1
+coin,quadrant_test.formula,-1,0,0,any,1
+coin,quadrant_test.formula,0,0,0,class<`formula`>,1
+coin,quadrant_test.formula,1,0,0,class<`data.frame`>,1
+coin,quadrant_test.formula,2,0,0,null,1
+coin,quadrant_test.formula,3,0,0,null,1
+coin,quadrant_test.formula,4,0,0,...,1
+coin,quadrant_test.IndependenceProblem,-1,0,0,any,1
+coin,quadrant_test.IndependenceProblem,0,0,0,class<`IndependenceProblem`>,1
+coin,quadrant_test.IndependenceProblem,1,0,0,character[],1
+coin,quadrant_test.IndependenceProblem,2,0,0,character[],1
+coin,quadrant_test.IndependenceProblem,3,0,0,...,1
+coin,rank_trafo,-1,0,0,^double[],1
+coin,rank_trafo,0,0,0,double[],1
+coin,rank_trafo,0,0,1,^integer[],1
+coin,rank_trafo,0,0,2,class<`array`>,1
+coin,rank_trafo,0,0,3,class<`data.frame`>,1
+coin,rank_trafo,1,0,0,character[],1
+coin,rperm,-1,0,0,double[],1
+coin,rperm,0,0,0,class<`ScalarIndependenceTest`>,1
+coin,rperm,1,0,0,double,1
+coin,rperm,2,0,0,...,1
+coin,rperm,-1,1,0,double[],1
+coin,rperm,0,1,0,class<`ExactNullDistribution`>,1
+coin,rperm,1,1,0,double,1
+coin,rperm,2,1,0,...,1
+coin,rperm,-1,2,0,double[],1
+coin,rperm,0,2,0,class<`AsymptNullDistribution`>,1
+coin,rperm,1,2,0,double,1
+coin,rperm,2,2,0,...,1
+coin,rperm,-1,3,0,double[],1
+coin,rperm,0,3,0,class<`ApproxNullDistribution`>,1
+coin,rperm,1,3,0,double,1
+coin,rperm,2,3,0,...,1
+coin,rperm,-1,4,0,double[],1
+coin,rperm,0,4,0,class<`MaxTypeIndependenceTest`>,1
+coin,rperm,1,4,0,double,1
+coin,rperm,2,4,0,...,1
+coin,rperm,-1,5,0,double[],1
+coin,rperm,0,5,0,class<`QuadTypeIndependenceTest`>,1
+coin,rperm,1,5,0,double,1
+coin,rperm,2,5,0,...,1
+coin,rperm,-1,6,0,double[],1
+coin,rperm,0,6,0,class<`ApproxNullDistribution`>,1
+coin,rperm,0,6,1,class<`AsymptNullDistribution`>,1
+coin,rperm,0,6,2,class<`ExactNullDistribution`>,1
+coin,rperm,0,6,3,class<`MaxTypeIndependenceTest`>,1
+coin,rperm,0,6,4,class<`QuadTypeIndependenceTest`>,1
+coin,rperm,0,6,5,class<`ScalarIndependenceTest`>,1
+coin,rperm,1,6,0,double,1
+coin,rperm,2,6,0,...,1
+coin,savage_test,-1,0,0,any,1
+coin,savage_test,0,0,0,class<`formula`>,1
+coin,savage_test,0,0,1,class<`IndependenceProblem`>,1
+coin,savage_test,1,0,0,...,1
+coin,savage_test.formula,-1,0,0,any,1
+coin,savage_test.formula,0,0,0,class<`formula`>,1
+coin,savage_test.formula,1,0,0,class<`data.frame`>,1
+coin,savage_test.formula,1,0,1,list<any>,1
+coin,savage_test.formula,2,0,0,null,1
+coin,savage_test.formula,3,0,0,null,1
+coin,savage_test.formula,4,0,0,...,1
+coin,savage_test.IndependenceProblem,-1,0,0,any,1
+coin,savage_test.IndependenceProblem,0,0,0,class<`IndependenceProblem`>,1
+coin,savage_test.IndependenceProblem,1,0,0,any,1
+coin,savage_test.IndependenceProblem,2,0,0,logical,1
+coin,savage_test.IndependenceProblem,3,0,0,double,1
+coin,savage_test.IndependenceProblem,4,0,0,...,1
+coin,savage_trafo,-1,0,0,^double[],1
+coin,savage_trafo,0,0,0,^integer[],1
+coin,savage_trafo,0,0,1,double[],1
+coin,savage_trafo,1,0,0,character[],1
+coin,setAttributes,-1,0,0,class<`matrix`>,1
+coin,setAttributes,-1,0,1,double[],1
+coin,setAttributes,0,0,0,double[],1
+coin,setAttributes,1,0,0,list<integer[]>,1
+coin,setAttributes,1,0,1,list<integer[] | list<character | null>>,1
+coin,setAttributes,1,0,2,null,1
+coin,setAttributes,1,0,3,list<character>,1
+coin,setColnames,-1,0,0,class<`matrix`>,1
+coin,setColnames,0,0,0,class<`matrix`>,1
+coin,setColnames,1,0,0,character[],1
+coin,setDimnames,-1,0,0,class<`matrix`>,1
+coin,setDimnames,0,0,0,class<`matrix`>,1
+coin,setDimnames,1,0,0,list<integer[] | character[]>,1
+coin,setRownames,-1,0,0,class<`matrix`>,1
+coin,setRownames,0,0,0,class<`matrix`>,1
+coin,setRownames,1,0,0,integer[],1
+coin,setscores,-1,0,0,class<`IndependenceProblem`>,1
+coin,setscores,-1,0,1,class<`SymmetryProblem`>,1
+coin,setscores,0,0,0,class<`IndependenceProblem`>,1
+coin,setscores,0,0,1,class<`SymmetryProblem`>,1
+coin,setscores,1,0,0,list<double[]>,1
+coin,setup_args,-1,0,0,list<any>,1
+coin,setup_args,0,0,0,...,1
+coin,sign_test,-1,0,0,any,1
+coin,sign_test,0,0,0,class<`formula`>,1
+coin,sign_test,0,0,1,class<`SymmetryProblem`>,1
+coin,sign_test,1,0,0,...,1
+coin,sign_test.formula,-1,0,0,any,1
+coin,sign_test.formula,0,0,0,class<`formula`>,1
+coin,sign_test.formula,1,0,0,class<`data.frame`>,1
+coin,sign_test.formula,1,0,1,list<any>,1
+coin,sign_test.formula,2,0,0,null,1
+coin,sign_test.formula,3,0,0,...,1
+coin,sign_test.SymmetryProblem,-1,0,0,any,1
+coin,sign_test.SymmetryProblem,0,0,0,class<`SymmetryProblem`>,1
+coin,sign_test.SymmetryProblem,1,0,0,...,1
+coin,size,-1,0,0,double,1
+coin,size,0,0,0,class<`ApproxNullDistribution`>,1
+coin,size,1,0,0,...,1
+coin,size,-1,1,0,double,1
+coin,size,0,1,0,class<`ExactNullDistribution`>,1
+coin,size,1,1,0,...,1
+coin,size,-1,2,0,double,1
+coin,size,0,2,0,class<`ScalarIndependenceTest`>,1
+coin,size,1,2,0,...,1
+coin,size,-1,3,0,double,1
+coin,size,0,3,0,class<`ApproxNullDistribution`>,1
+coin,size,0,3,1,class<`ExactNullDistribution`>,1
+coin,size,0,3,2,class<`MaxTypeIndependenceTest`>,1
+coin,size,0,3,3,class<`QuadTypeIndependenceTest`>,1
+coin,size,0,3,4,class<`ScalarIndependenceTest`>,1
+coin,size,1,3,0,...,1
+coin,size,-1,4,0,double,1
+coin,size,0,4,0,class<`MaxTypeIndependenceTest`>,1
+coin,size,1,4,0,...,1
+coin,size,-1,5,0,double,1
+coin,size,0,5,0,class<`QuadTypeIndependenceTest`>,1
+coin,size,1,5,0,...,1
+coin,spearman_test,-1,0,0,any,1
+coin,spearman_test,0,0,0,class<`formula`>,1
+coin,spearman_test,0,0,1,class<`IndependenceProblem`>,1
+coin,spearman_test,1,0,0,...,1
+coin,spearman_test.formula,-1,0,0,any,1
+coin,spearman_test.formula,0,0,0,class<`formula`>,1
+coin,spearman_test.formula,1,0,0,class<`data.frame`>,1
+coin,spearman_test.formula,2,0,0,null,1
+coin,spearman_test.formula,3,0,0,null,1
+coin,spearman_test.formula,4,0,0,...,1
+coin,spearman_test.IndependenceProblem,-1,0,0,any,1
+coin,spearman_test.IndependenceProblem,0,0,0,class<`IndependenceProblem`>,1
+coin,spearman_test.IndependenceProblem,1,0,0,character[],1
+coin,spearman_test.IndependenceProblem,2,0,0,...,1
+coin,SR_shift_1sample,-1,0,0,any,1
+coin,SR_shift_1sample,0,0,0,class<`QuadTypeIndependenceTestStatistic`>,1
+coin,SR_shift_1sample,0,0,1,class<`ScalarIndependenceTestStatistic`>,1
+coin,SR_shift_1sample,1,0,0,any,1
+coin,SR_shift_2sample,-1,0,0,class<`ExactNullDistribution`>,1
+coin,SR_shift_2sample,0,0,0,class<`QuadTypeIndependenceTestStatistic`>,1
+coin,SR_shift_2sample,0,0,1,class<`ScalarIndependenceTestStatistic`>,1
+coin,SR_shift_2sample,1,0,0,double,1
+coin,statistic,-1,0,0,class<`matrix`>,1
+coin,statistic,-1,0,1,double,1
+coin,statistic,0,0,0,class<`IndependenceLinearStatistic`>,1
+coin,statistic,0,0,1,class<`MaxTypeIndependenceTest`>,1
+coin,statistic,0,0,2,class<`MaxTypeIndependenceTestStatistic`>,1
+coin,statistic,0,0,3,class<`QuadTypeIndependenceTest`>,1
+coin,statistic,0,0,4,class<`QuadTypeIndependenceTestStatistic`>,1
+coin,statistic,0,0,5,class<`ScalarIndependenceTest`>,1
+coin,statistic,0,0,6,class<`ScalarIndependenceTestConfint`>,1
+coin,statistic,0,0,7,class<`ScalarIndependenceTestStatistic`>,1
+coin,statistic,1,0,0,...,1
+coin,statistic,-1,1,0,class<`matrix`>,1
+coin,statistic,-1,1,1,double,1
+coin,statistic,0,1,0,class<`QuadTypeIndependenceTestStatistic`>,1
+coin,statistic,1,1,0,...,1
+coin,statistic,-1,2,0,class<`matrix`>,1
+coin,statistic,-1,2,1,double,1
+coin,statistic,0,2,0,class<`QuadTypeIndependenceTest`>,1
+coin,statistic,1,2,0,...,1
+coin,statistic,-1,3,0,class<`matrix`>,1
+coin,statistic,0,3,0,class<`ScalarIndependenceTestConfint`>,1
+coin,statistic,1,3,0,...,1
+coin,statistic,-1,4,0,class<`matrix`>,1
+coin,statistic,-1,4,1,double,1
+coin,statistic,0,4,0,class<`QuadTypeIndependenceTestStatistic`>,1
+coin,statistic,1,4,0,...,1
+coin,statistic,-1,5,0,class<`matrix`>,1
+coin,statistic,-1,5,1,double,1
+coin,statistic,0,5,0,class<`MaxTypeIndependenceTest`>,1
+coin,statistic,1,5,0,...,1
+coin,statistic,-1,6,0,class<`matrix`>,1
+coin,statistic,-1,6,1,double,1
+coin,statistic,0,6,0,class<`ScalarIndependenceTestStatistic`>,1
+coin,statistic,1,6,0,...,1
+coin,statistic,-1,7,0,class<`matrix`>,1
+coin,statistic,-1,7,1,double,1
+coin,statistic,0,7,0,class<`MaxTypeIndependenceTestStatistic`>,1
+coin,statistic,1,7,0,...,1
+coin,statistic,-1,8,0,class<`matrix`>,1
+coin,statistic,-1,8,1,double,1
+coin,statistic,0,8,0,class<`ScalarIndependenceTest`>,1
+coin,statistic,1,8,0,...,1
+coin,statistic,-1,9,0,class<`matrix`>,1
+coin,statistic,-1,9,1,double,1
+coin,statistic,0,9,0,class<`ScalarIndependenceTestStatistic`>,1
+coin,statistic,1,9,0,...,1
+coin,statistic,-1,10,0,class<`matrix`>,1
+coin,statistic,-1,10,1,double,1
+coin,statistic,0,10,0,class<`MaxTypeIndependenceTestStatistic`>,1
+coin,statistic,1,10,0,...,1
+coin,statistic,-1,11,0,class<`matrix`>,1
+coin,statistic,0,11,0,class<`IndependenceLinearStatistic`>,1
+coin,statistic,1,11,0,...,1
+coin,statnames,-1,0,0,list<character[] | list<character[]>>,1
+coin,statnames,-1,0,1,list<character | list<character>>,1
+coin,statnames,0,0,0,class<`IndependenceLinearStatistic`>,1
+coin,statnames,0,0,1,class<`IndependenceTestProblem`>,1
+coin,statnames,0,0,2,class<`MaxTypeIndependenceTestStatistic`>,1
+coin,statnames,0,0,3,class<`QuadTypeIndependenceTestStatistic`>,1
+coin,statnames,0,0,4,class<`ScalarIndependenceTestStatistic`>,1
+coin,str2lang,-1,0,0,class<`<-`>,1
+coin,str2lang,0,0,0,character,1
+coin,support,-1,0,0,double[],1
+coin,support,-1,1,0,class<`matrix`>,1
+coin,support,-1,1,1,double[],1
+coin,support,0,1,0,logical,1
+coin,support,-1,2,0,double[],1
+coin,support,0,2,0,logical,1
+coin,support,-1,3,0,double[],1
+coin,support,-1,3,1,null,1
+coin,support,0,3,0,class<`ScalarIndependenceTest`>,1
+coin,support,1,3,0,...,1
+coin,support,-1,4,0,class<`matrix`>,1
+coin,support,-1,4,1,double[],1
+coin,support,0,4,0,class<`ApproxNullDistribution`>,1
+coin,support,1,4,0,...,1
+coin,support,-1,5,0,class<`matrix`>,1
+coin,support,-1,5,1,double[],1
+coin,support,-1,5,2,null,1
+coin,support,0,5,0,class<`ApproxNullDistribution`>,1
+coin,support,0,5,1,class<`ExactNullDistribution`>,1
+coin,support,0,5,2,class<`MaxTypeIndependenceTest`>,1
+coin,support,0,5,3,class<`QuadTypeIndependenceTest`>,1
+coin,support,0,5,4,class<`ScalarIndependenceTest`>,1
+coin,support,0,5,5,class<`AsymptNullDistribution`>,1
+coin,support,1,5,0,...,1
+coin,support,-1,6,0,double[],1
+coin,support,-1,6,1,null,1
+coin,support,0,6,0,class<`QuadTypeIndependenceTest`>,1
+coin,support,1,6,0,...,1
+coin,support,-1,7,0,double[],1
+coin,support,0,7,0,class<`ExactNullDistribution`>,1
+coin,support,1,7,0,...,1
+coin,support,-1,8,0,null,1
+coin,support,0,8,0,class<`AsymptNullDistribution`>,1
+coin,support,1,8,0,...,1
+coin,support,-1,9,0,double[],1
+coin,support,0,9,0,class<`MaxTypeIndependenceTest`>,1
+coin,support,1,9,0,...,1
+coin,symmetry_test,-1,0,0,any,1
+coin,symmetry_test,0,0,0,class<`formula`>,1
+coin,symmetry_test,0,0,1,class<`SymmetryProblem`>,1
+coin,symmetry_test,0,0,2,class<`table`>,1
+coin,symmetry_test,1,0,0,...,1
+coin,symmetry_test.formula,-1,0,0,any,1
+coin,symmetry_test.formula,0,0,0,class<`formula`>,1
+coin,symmetry_test.formula,1,0,0,class<`data.frame`>,1
+coin,symmetry_test.formula,1,0,1,list<any>,1
+coin,symmetry_test.formula,2,0,0,null,1
+coin,symmetry_test.formula,3,0,0,null,1
+coin,symmetry_test.formula,4,0,0,...,1
+coin,symmetry_test.SymmetryProblem,-1,0,0,any,1
+coin,symmetry_test.SymmetryProblem,0,0,0,class<`SymmetryProblem`>,1
+coin,symmetry_test.SymmetryProblem,1,0,0,character[],1
+coin,symmetry_test.SymmetryProblem,2,0,0,character[],1
+coin,symmetry_test.SymmetryProblem,2,0,1,class<`function`>,1
+coin,symmetry_test.SymmetryProblem,3,0,0,character[],1
+coin,symmetry_test.SymmetryProblem,4,0,0,class<`function`>,1
+coin,symmetry_test.SymmetryProblem,5,0,0,class<`function`>,1
+coin,symmetry_test.SymmetryProblem,6,0,0,null,1
+coin,symmetry_test.SymmetryProblem,6,0,1,list<integer[]>,1
+coin,symmetry_test.SymmetryProblem,7,0,0,null,1
+coin,symmetry_test.SymmetryProblem,7,0,1,class<`function`>,1
+coin,symmetry_test.table,-1,0,0,class<`MaxTypeIndependenceTest`>,1
+coin,symmetry_test.table,-1,0,1,class<`QuadTypeIndependenceTest`>,1
+coin,symmetry_test.table,-1,0,2,class<`ScalarIndependenceTest`>,1
+coin,symmetry_test.table,0,0,0,class<`table`>,1
+coin,symmetry_test.table,1,0,0,...,1
+coin,table2IndependenceProblem,-1,0,0,class<`IndependenceProblem`>,1
+coin,table2IndependenceProblem,0,0,0,class<`table`>,1
+coin,table2SymmetryProblem,-1,0,0,class<`SymmetryProblem`>,1
+coin,table2SymmetryProblem,0,0,0,class<`table`>,1
+coin,taha_test,-1,0,0,any,1
+coin,taha_test,0,0,0,class<`formula`>,1
+coin,taha_test,0,0,1,class<`IndependenceProblem`>,1
+coin,taha_test,1,0,0,...,1
+coin,taha_test.formula,-1,0,0,any,1
+coin,taha_test.formula,0,0,0,class<`formula`>,1
+coin,taha_test.formula,1,0,0,class<`data.frame`>,1
+coin,taha_test.formula,1,0,1,list<any>,1
+coin,taha_test.formula,2,0,0,null,1
+coin,taha_test.formula,3,0,0,null,1
+coin,taha_test.formula,4,0,0,...,1
+coin,taha_test.IndependenceProblem,-1,0,0,any,1
+coin,taha_test.IndependenceProblem,0,0,0,class<`IndependenceProblem`>,1
+coin,taha_test.IndependenceProblem,1,0,0,logical,1
+coin,taha_test.IndependenceProblem,2,0,0,double,1
+coin,taha_test.IndependenceProblem,3,0,0,...,1
+coin,trafo,-1,0,0,any,1
+coin,trafo,0,0,0,class<`data.frame`>,1
+coin,trafo,1,0,0,any,1
+coin,trafo,2,0,0,any,1
+coin,trafo,3,0,0,any,1
+coin,trafo,4,0,0,any,1
+coin,trafo,5,0,0,null,1
+coin,trafo,5,0,1,list<class<`function`>>,1
+coin,trafo,6,0,0,class<`factor`>,1
+coin,trafo,6,0,1,null,1
+coin,unadjusted,-1,0,0,"class<`matrix`, `pvalue`>",1
+coin,unadjusted,0,0,0,class<`MaxTypeIndependenceTest`>,1
+coin,unadjusted,1,0,0,any,1
+coin,unadjusted,2,0,0,...,1
+coin,unadjusted,-1,1,0,"class<`matrix`, `pvalue`>",1
+coin,unadjusted,0,1,0,class<`MaxTypeIndependenceTestStatistic`>,1
+coin,unadjusted,1,1,0,class<`AsymptNullDistribution`>,1
+coin,unadjusted,2,1,0,...,1
+coin,unadjusted,-1,2,0,"class<`matrix`, `pvalue`>",1
+coin,unadjusted,0,2,0,class<`MaxTypeIndependenceTestStatistic`>,1
+coin,unadjusted,1,2,0,class<`ApproxNullDistribution`>,1
+coin,unadjusted,2,2,0,...,1
+coin,unadjusted,-1,3,0,"class<`matrix`, `pvalue`>",1
+coin,unadjusted,0,3,0,class<`MaxTypeIndependenceTest`>,1
+coin,unadjusted,0,3,1,class<`MaxTypeIndependenceTestStatistic`>,1
+coin,unadjusted,1,3,0,any,1
+coin,unadjusted,2,3,0,...,1
+coin,variance,-1,0,0,double[],1
+coin,variance,0,0,0,class<`CovarianceMatrix`>,1
+coin,variance,0,0,1,class<`IndependenceLinearStatistic`>,1
+coin,variance,0,0,2,class<`ScalarIndependenceTestStatistic`>,1
+coin,variance,0,0,3,class<`Variance`>,1
+coin,variance,0,0,4,class<`QuadTypeIndependenceTest`>,1
+coin,variance,0,0,5,class<`QuadTypeIndependenceTestStatistic`>,1
+coin,variance,0,0,6,class<`MaxTypeIndependenceTestStatistic`>,1
+coin,variance,0,0,7,class<`ScalarIndependenceTest`>,1
+coin,variance,0,0,8,class<`MaxTypeIndependenceTest`>,1
+coin,variance,1,0,0,...,1
+coin,variance,-1,1,0,double,1
+coin,variance,0,1,0,class<`ScalarIndependenceTest`>,1
+coin,variance,1,1,0,...,1
+coin,variance,-1,2,0,double[],1
+coin,variance,0,2,0,class<`IndependenceLinearStatistic`>,1
+coin,variance,1,2,0,...,1
+coin,variance,-1,3,0,double[],1
+coin,variance,0,3,0,class<`MaxTypeIndependenceTest`>,1
+coin,variance,1,3,0,...,1
+coin,variance,-1,4,0,double[],1
+coin,variance,0,4,0,class<`Variance`>,1
+coin,variance,1,4,0,...,1
+coin,variance,-1,5,0,double[],1
+coin,variance,0,5,0,class<`QuadTypeIndependenceTest`>,1
+coin,variance,1,5,0,...,1
+coin,variance,-1,6,0,double[],1
+coin,variance,0,6,0,class<`CovarianceMatrix`>,1
+coin,variance,1,6,0,...,1
+coin,variance,-1,7,0,double,1
+coin,variance,0,7,0,class<`ScalarIndependenceTestStatistic`>,1
+coin,variance,1,7,0,...,1
+coin,variance,-1,8,0,double[],1
+coin,variance,0,8,0,class<`MaxTypeIndependenceTestStatistic`>,1
+coin,variance,1,8,0,...,1
+coin,variance,-1,9,0,double[],1
+coin,variance,0,9,0,class<`QuadTypeIndependenceTestStatistic`>,1
+coin,variance,1,9,0,...,1
+coin,vdW_split_up_2sample,-1,0,0,any,1
+coin,vdW_split_up_2sample,0,0,0,class<`ScalarIndependenceTestStatistic`>,1
+coin,wilcoxsign_test,-1,0,0,any,1
+coin,wilcoxsign_test,0,0,0,class<`formula`>,1
+coin,wilcoxsign_test,0,0,1,class<`SymmetryProblem`>,1
+coin,wilcoxsign_test,1,0,0,...,1
+coin,wilcoxsign_test.formula,-1,0,0,any,1
+coin,wilcoxsign_test.formula,0,0,0,class<`formula`>,1
+coin,wilcoxsign_test.formula,1,0,0,class<`data.frame`>,1
+coin,wilcoxsign_test.formula,1,0,1,list<any>,1
+coin,wilcoxsign_test.formula,2,0,0,null,1
+coin,wilcoxsign_test.formula,3,0,0,...,1
+coin,wilcoxsign_test.SymmetryProblem,-1,0,0,any,1
+coin,wilcoxsign_test.SymmetryProblem,0,0,0,class<`SymmetryProblem`>,1
+coin,wilcoxsign_test.SymmetryProblem,1,0,0,character[],1
+coin,wilcoxsign_test.SymmetryProblem,2,0,0,...,1
+coin,wilcox_test,-1,0,0,any,1
+coin,wilcox_test,0,0,0,class<`formula`>,1
+coin,wilcox_test,0,0,1,class<`IndependenceProblem`>,1
+coin,wilcox_test,1,0,0,...,1
+coin,wilcox_test.formula,-1,0,0,any,1
+coin,wilcox_test.formula,0,0,0,class<`formula`>,1
+coin,wilcox_test.formula,1,0,0,class<`data.frame`>,1
+coin,wilcox_test.formula,1,0,1,list<any>,1
+coin,wilcox_test.formula,2,0,0,logical[],1
+coin,wilcox_test.formula,2,0,1,null,1
+coin,wilcox_test.formula,3,0,0,null,1
+coin,wilcox_test.formula,4,0,0,...,1
+coin,wilcox_test.IndependenceProblem,-1,0,0,any,1
+coin,wilcox_test.IndependenceProblem,0,0,0,class<`IndependenceProblem`>,1
+coin,wilcox_test.IndependenceProblem,1,0,0,logical,1
+coin,wilcox_test.IndependenceProblem,2,0,0,double,1
+coin,wilcox_test.IndependenceProblem,3,0,0,...,1
+coin,zheng_trafo,-1,0,0,class<`matrix`>,1
+coin,zheng_trafo,0,0,0,class<`factor`>,1
+coin,zheng_trafo,0,0,1,"class<`factor`, `ordered`>",1
+coin,zheng_trafo,1,0,0,double,1
+colorRamps,blue2green,-1,0,0,character[],1
+colorRamps,blue2green,0,0,0,double,1
+colorRamps,blue2red,-1,0,0,character[],1
+colorRamps,blue2red,0,0,0,double,1
+colorRamps,blue2yellow,-1,0,0,character[],1
+colorRamps,blue2yellow,0,0,0,double,1
+colorRamps,green2red,-1,0,0,character[],1
+colorRamps,green2red,0,0,0,double,1
+colorRamps,primary.colors,-1,0,0,character[],1
+colorRamps,primary.colors,0,0,0,double,1
+colorRamps,primary.colors,1,0,0,double,1
+colorRamps,primary.colors,2,0,0,logical,1
+colorRamps,rgb.tables,-1,0,0,character[],1
+colorRamps,rgb.tables,0,0,0,double,1
+colorRamps,rgb.tables,1,0,0,double[],1
+colorRamps,rgb.tables,2,0,0,double[],1
+colorRamps,rgb.tables,3,0,0,double[],1
+colorRamps,table.ramp,-1,0,0,double[],1
+colorRamps,table.ramp,0,0,0,double,1
+colorRamps,table.ramp,1,0,0,double,1
+colorRamps,table.ramp,2,0,0,double,1
+colorRamps,table.ramp,3,0,0,double,1
+colorRamps,table.ramp,4,0,0,double,1
+colorRamps,ygobb,-1,0,0,character[],1
+colorRamps,ygobb,0,0,0,double,1
+combinat,combn,-1,0,0,class<`matrix`>,1
+combinat,combn,-1,0,1,integer[],1
+combinat,combn,0,0,0,character[],1
+combinat,combn,0,0,1,double[],1
+combinat,combn,1,0,0,double,1
+combinat,combn,2,0,0,null,1
+combinat,combn,2,0,1,class<`function`>,1
+combinat,combn,3,0,0,logical,1
+combinat,combn,4,0,0,...,1
+combinat,dmnom,-1,0,0,double,1
+combinat,dmnom,0,0,0,double[],1
+combinat,dmnom,1,0,0,double,1
+combinat,dmnom,2,0,0,double[],1
+combinat,logfact,-1,0,0,double[],1
+combinat,logfact,0,0,0,double[],1
+combinat,nCm,-1,0,0,double,1
+combinat,nCm,0,0,0,double,1
+combinat,nCm,1,0,0,double,1
+combinat,nCm,2,0,0,double,1
+combinat,nsimplex,-1,0,0,double,1
+combinat,nsimplex,0,0,0,double,1
+combinat,nsimplex,1,0,0,double,1
+combinat,permn,-1,0,0,list<integer[]>,1
+combinat,permn,0,0,0,double,1
+combinat,permn,1,0,0,class<`function`>,1
+combinat,permn,1,0,1,null,1
+combinat,permn,2,0,0,...,1
+combinat,rmultinomial,-1,0,0,class<`matrix`>,1
+combinat,rmultinomial,0,0,0,double[],1
+combinat,rmultinomial,1,0,0,class<`matrix`>,1
+combinat,rmultinomial,2,0,0,integer,1
+combinat,xsimplex,-1,0,0,double[],1
+combinat,xsimplex,0,0,0,double,1
+combinat,xsimplex,1,0,0,double,1
+combinat,xsimplex,2,0,0,class<`function`>,1
+combinat,xsimplex,3,0,0,logical,1
+combinat,xsimplex,4,0,0,...,1
+compare,coercedMsg,-1,0,0,character,1
+compare,coercedMsg,0,0,0,character[],1
+compare,coercedMsg,0,0,1,class<`data.frame`>,1
+compare,coercedMsg,0,0,2,class<`dummy`>,1
+compare,coercedMsg,0,0,3,class<`factor`>,1
+compare,coercedMsg,0,0,4,class<`matrix`>,1
+compare,coercedMsg,0,0,5,integer[],1
+compare,coercedMsg,1,0,0,character,1
+compare,coerceListComponents,-1,0,0,"class<`comparison`, `multipleComparison`>",1
+compare,coerceListComponents,0,0,0,list<any>,1
+compare,coerceListComponents,1,0,0,list<any>,1
+compare,coerceListComponents,2,0,0,character[],1
+compare,coerceListComponents,3,0,0,logical,1
+compare,coerceListComponents,4,0,0,logical,1
+compare,coerceListComponents,5,0,0,...,1
+compare,commentQuestion,-1,0,0,character[],1
+compare,commentQuestion,0,0,0,class<`comparisonList`>,1
+compare,commentQuestion,0,0,1,class<`comparisonListList`>,1
+compare,commentQuestion,1,0,0,class<`questionComments`>,1
+compare,commentQuestion.comparisonList,-1,0,0,character,1
+compare,commentQuestion.comparisonList,0,0,0,class<`comparisonList`>,1
+compare,commentQuestion.comparisonList,1,0,0,class<`questionComments`>,1
+compare,commentQuestion.comparisonListList,-1,0,0,character[],1
+compare,commentQuestion.comparisonListList,0,0,0,class<`comparisonListList`>,1
+compare,commentQuestion.comparisonListList,1,0,0,class<`questionComments`>,1
+compare,commentQuestions,-1,0,0,class<`matrix`>,1
+compare,commentQuestions,0,0,0,class<`comparisonListList`>,1
+compare,commentQuestions,1,0,0,...,1
+compare,comments,-1,0,0,class<`markingComments`>,1
+compare,comments,0,0,0,character,1
+compare,comments,1,0,0,...,1
+compare,compare,-1,0,0,class<`comparison`>,1
+compare,compare,-1,0,1,"class<`comparison`, `multipleComparison`>",1
+compare,compare,0,0,0,character[],1
+compare,compare,0,0,1,class<`data.frame`>,1
+compare,compare,0,0,2,class<`factor`>,1
+compare,compare,0,0,3,double[],1
+compare,compare,0,0,4,class<`lm`>,1
+compare,compare,0,0,5,list<integer[] | character[]>,1
+compare,compare,0,0,6,class<`call`>,1
+compare,compare,0,0,7,"class<`formula`, `terms`>",1
+compare,compare,0,0,8,class<`matrix`>,1
+compare,compare,0,0,9,list<character[]>,1
+compare,compare,0,0,10,class<`qr`>,1
+compare,compare,0,0,11,list<class<`matrix`> | double[]>,1
+compare,compare,1,0,0,class<`factor`>,1
+compare,compare,1,0,1,class<`matrix`>,1
+compare,compare,1,0,2,class<`data.frame`>,1
+compare,compare,1,0,3,character[],1
+compare,compare,1,0,4,double[],1
+compare,compare,1,0,5,class<`lm`>,1
+compare,compare,1,0,6,class<`call`>,1
+compare,compare,1,0,7,"class<`formula`, `terms`>",1
+compare,compare,1,0,8,list<character[]>,1
+compare,compare,1,0,9,class<`qr`>,1
+compare,compare,1,0,10,list<class<`matrix`> | double[]>,1
+compare,compare,2,0,0,logical,1
+compare,compare,3,0,0,any,1
+compare,compare,4,0,0,any,1
+compare,compare,5,0,0,any,1
+compare,compare,6,0,0,any,1
+compare,compare,7,0,0,any,1
+compare,compare,8,0,0,any,1
+compare,compare,9,0,0,logical,1
+compare,compare,9,0,1,class<`function`>,1
+compare,compare,10,0,0,any,1
+compare,compare,11,0,0,any,1
+compare,compare,12,0,0,any,1
+compare,compare,13,0,0,any,1
+compare,compare,14,0,0,any,1
+compare,compare,15,0,0,any,1
+compare,compareCoerce,-1,0,0,class<`comparison`>,1
+compare,compareCoerce,-1,0,1,"class<`comparison`, `multipleComparison`>",1
+compare,compareCoerce,0,0,0,character[],1
+compare,compareCoerce,0,0,1,class<`factor`>,1
+compare,compareCoerce,0,0,2,double[],1
+compare,compareCoerce,0,0,3,class<`data.frame`>,1
+compare,compareCoerce,0,0,4,list<any>,1
+compare,compareCoerce,0,0,5,class<`lm`>,1
+compare,compareCoerce,0,0,6,expression,1
+compare,compareCoerce,0,0,7,class<`call`>,1
+compare,compareCoerce,0,0,8,"class<`formula`, `terms`>",1
+compare,compareCoerce,0,0,9,class<`matrix`>,1
+compare,compareCoerce,0,0,10,class<`qr`>,1
+compare,compareCoerce,1,0,0,class<`factor`>,1
+compare,compareCoerce,1,0,1,character[],1
+compare,compareCoerce,1,0,2,class<`matrix`>,1
+compare,compareCoerce,1,0,3,double[],1
+compare,compareCoerce,1,0,4,class<`data.frame`>,1
+compare,compareCoerce,1,0,5,list<any>,1
+compare,compareCoerce,1,0,6,class<`lm`>,1
+compare,compareCoerce,1,0,7,expression,1
+compare,compareCoerce,1,0,8,class<`dummy`>,1
+compare,compareCoerce,1,0,9,class<`call`>,1
+compare,compareCoerce,1,0,10,"class<`formula`, `terms`>",1
+compare,compareCoerce,1,0,11,class<`qr`>,1
+compare,compareCoerce,2,0,0,any,1
+compare,compareCoerce,3,0,0,any,1
+compare,compareCoerce,4,0,0,...,1
+compare,compareCoerce.character,-1,0,0,class<`comparison`>,1
+compare,compareCoerce.character,0,0,0,character[],1
+compare,compareCoerce.character,1,0,0,character[],1
+compare,compareCoerce.character,1,0,1,class<`factor`>,1
+compare,compareCoerce.character,2,0,0,character[],1
+compare,compareCoerce.character,3,0,0,any,1
+compare,compareCoerce.character,4,0,0,...,1
+compare,compareCoerce.data.frame,-1,0,0,"class<`comparison`, `multipleComparison`>",1
+compare,compareCoerce.data.frame,0,0,0,class<`data.frame`>,1
+compare,compareCoerce.data.frame,1,0,0,class<`data.frame`>,1
+compare,compareCoerce.data.frame,2,0,0,character[],1
+compare,compareCoerce.data.frame,3,0,0,any,1
+compare,compareCoerce.data.frame,4,0,0,logical,1
+compare,compareCoerce.data.frame,5,0,0,logical,1
+compare,compareCoerce.data.frame,6,0,0,...,1
+compare,compareCoerce.default,-1,0,0,class<`comparison`>,1
+compare,compareCoerce.default,-1,0,1,"class<`comparison`, `multipleComparison`>",1
+compare,compareCoerce.default,0,0,0,class<`call`>,1
+compare,compareCoerce.default,0,0,1,"class<`formula`, `terms`>",1
+compare,compareCoerce.default,0,0,2,class<`lm`>,1
+compare,compareCoerce.default,0,0,3,class<`qr`>,1
+compare,compareCoerce.default,0,0,4,expression,1
+compare,compareCoerce.default,1,0,0,class<`call`>,1
+compare,compareCoerce.default,1,0,1,"class<`formula`, `terms`>",1
+compare,compareCoerce.default,1,0,2,class<`lm`>,1
+compare,compareCoerce.default,1,0,3,class<`qr`>,1
+compare,compareCoerce.default,1,0,4,expression,1
+compare,compareCoerce.default,2,0,0,character[],1
+compare,compareCoerce.default,3,0,0,...,1
+compare,compareCoerceDF,-1,0,0,"class<`comparison`, `multipleComparison`>",1
+compare,compareCoerceDF,0,0,0,class<`data.frame`>,1
+compare,compareCoerceDF,1,0,0,class<`data.frame`>,1
+compare,compareCoerceDF,2,0,0,character[],1
+compare,compareCoerceDF,3,0,0,...,1
+compare,compareCoerce.factor,-1,0,0,class<`comparison`>,1
+compare,compareCoerce.factor,0,0,0,class<`factor`>,1
+compare,compareCoerce.factor,1,0,0,character[],1
+compare,compareCoerce.factor,1,0,1,class<`factor`>,1
+compare,compareCoerce.factor,1,0,2,integer[],1
+compare,compareCoerce.factor,2,0,0,character[],1
+compare,compareCoerce.factor,3,0,0,any,1
+compare,compareCoerce.factor,4,0,0,...,1
+compare,compareCoerce.integer,-1,0,0,class<`comparison`>,1
+compare,compareCoerce.integer,0,0,0,integer[],1
+compare,compareCoerce.integer,1,0,0,character[],1
+compare,compareCoerce.integer,1,0,1,class<`factor`>,1
+compare,compareCoerce.integer,1,0,2,integer[],1
+compare,compareCoerce.integer,2,0,0,character[],1
+compare,compareCoerce.integer,3,0,0,logical,1
+compare,compareCoerce.integer,4,0,0,...,1
+compare,compareCoerce.language,-1,0,0,class<`comparison`>,1
+compare,compareCoerce.language,-1,0,1,"class<`comparison`, `multipleComparison`>",1
+compare,compareCoerce.language,0,0,0,class<`call`>,1
+compare,compareCoerce.language,0,0,1,"class<`formula`, `terms`>",1
+compare,compareCoerce.language,0,0,2,expression,1
+compare,compareCoerce.language,1,0,0,class<`call`>,1
+compare,compareCoerce.language,1,0,1,"class<`formula`, `terms`>",1
+compare,compareCoerce.language,1,0,2,expression,1
+compare,compareCoerce.language,2,0,0,character[],1
+compare,compareCoerce.language,3,0,0,...,1
+compare,compareCoerce.list,-1,0,0,"class<`comparison`, `multipleComparison`>",1
+compare,compareCoerce.list,-1,0,1,class<`comparison`>,1
+compare,compareCoerce.list,0,0,0,list<any>,1
+compare,compareCoerce.list,1,0,0,list<any>,1
+compare,compareCoerce.list,1,0,1,class<`data.frame`>,1
+compare,compareCoerce.list,1,0,2,class<`dummy`>,1
+compare,compareCoerce.list,2,0,0,character[],1
+compare,compareCoerce.list,3,0,0,any,1
+compare,compareCoerce.list,4,0,0,logical,1
+compare,compareCoerce.list,5,0,0,logical,1
+compare,compareCoerce.list,6,0,0,...,1
+compare,compareCoerce.matrix,-1,0,0,class<`comparison`>,1
+compare,compareCoerce.matrix,0,0,0,class<`matrix`>,1
+compare,compareCoerce.matrix,1,0,0,class<`matrix`>,1
+compare,compareCoerce.matrix,2,0,0,character[],1
+compare,compareCoerce.matrix,3,0,0,logical,1
+compare,compareCoerce.matrix,4,0,0,...,1
+compare,compareCoerce.numeric,-1,0,0,class<`comparison`>,1
+compare,compareCoerce.numeric,0,0,0,double[],1
+compare,compareCoerce.numeric,1,0,0,character[],1
+compare,compareCoerce.numeric,1,0,1,class<`matrix`>,1
+compare,compareCoerce.numeric,1,0,2,double[],1
+compare,compareCoerce.numeric,2,0,0,character[],1
+compare,compareCoerce.numeric,3,0,0,any,1
+compare,compareCoerce.numeric,4,0,0,...,1
+compare,compareEqual,-1,0,0,class<`comparison`>,1
+compare,compareEqual,-1,0,1,"class<`comparison`, `multipleComparison`>",1
+compare,compareEqual,0,0,0,character[],1
+compare,compareEqual,0,0,1,class<`call`>,1
+compare,compareEqual,0,0,2,class<`factor`>,1
+compare,compareEqual,0,0,3,"class<`formula`, `terms`>",1
+compare,compareEqual,0,0,4,class<`matrix`>,1
+compare,compareEqual,0,0,5,double[],1
+compare,compareEqual,0,0,6,class<`data.frame`>,1
+compare,compareEqual,0,0,7,class<`lm`>,1
+compare,compareEqual,0,0,8,class<`qr`>,1
+compare,compareEqual,0,0,9,expression,1
+compare,compareEqual,0,0,10,list<any>,1
+compare,compareEqual,0,0,11,class<`array`>,1
+compare,compareEqual,0,0,12,class<`table`>,1
+compare,compareEqual,1,0,0,character[],1
+compare,compareEqual,1,0,1,class<`factor`>,1
+compare,compareEqual,1,0,2,class<`matrix`>,1
+compare,compareEqual,1,0,3,class<`call`>,1
+compare,compareEqual,1,0,4,double[],1
+compare,compareEqual,1,0,5,"class<`formula`, `terms`>",1
+compare,compareEqual,1,0,6,class<`data.frame`>,1
+compare,compareEqual,1,0,7,class<`lm`>,1
+compare,compareEqual,1,0,8,class<`qr`>,1
+compare,compareEqual,1,0,9,expression,1
+compare,compareEqual,1,0,10,list<any>,1
+compare,compareEqual,1,0,11,class<`array`>,1
+compare,compareEqual,1,0,12,class<`table`>,1
+compare,compareEqual,2,0,0,any,1
+compare,compareEqual,3,0,0,...,1
+compare,compareEqual.array,-1,0,0,class<`comparison`>,1
+compare,compareEqual.array,0,0,0,class<`array`>,1
+compare,compareEqual.array,0,0,1,class<`matrix`>,1
+compare,compareEqual.array,0,0,2,class<`table`>,1
+compare,compareEqual.array,1,0,0,class<`array`>,1
+compare,compareEqual.array,1,0,1,class<`matrix`>,1
+compare,compareEqual.array,1,0,2,class<`table`>,1
+compare,compareEqual.array,2,0,0,character[],1
+compare,compareEqual.array,3,0,0,logical,1
+compare,compareEqual.array,4,0,0,...,1
+compare,compareEqual.character,-1,0,0,class<`comparison`>,1
+compare,compareEqual.character,0,0,0,character[],1
+compare,compareEqual.character,1,0,0,character[],1
+compare,compareEqual.character,1,0,1,class<`factor`>,1
+compare,compareEqual.character,1,0,2,class<`matrix`>,1
+compare,compareEqual.character,2,0,0,character[],1
+compare,compareEqual.character,3,0,0,any,1
+compare,compareEqual.character,4,0,0,any,1
+compare,compareEqual.character,5,0,0,...,1
+compare,compareEqual.data.frame,-1,0,0,"class<`comparison`, `multipleComparison`>",1
+compare,compareEqual.data.frame,0,0,0,class<`data.frame`>,1
+compare,compareEqual.data.frame,1,0,0,class<`data.frame`>,1
+compare,compareEqual.data.frame,2,0,0,character[],1
+compare,compareEqual.data.frame,3,0,0,logical,1
+compare,compareEqual.data.frame,4,0,0,logical,1
+compare,compareEqual.data.frame,5,0,0,...,1
+compare,compareEqual.data.frame,6,0,0,class<`function`>,1
+compare,compareEqual.default,-1,0,0,class<`comparison`>,1
+compare,compareEqual.default,-1,0,1,"class<`comparison`, `multipleComparison`>",1
+compare,compareEqual.default,0,0,0,class<`call`>,1
+compare,compareEqual.default,0,0,1,"class<`formula`, `terms`>",1
+compare,compareEqual.default,0,0,2,class<`lm`>,1
+compare,compareEqual.default,0,0,3,class<`qr`>,1
+compare,compareEqual.default,0,0,4,expression,1
+compare,compareEqual.default,1,0,0,class<`call`>,1
+compare,compareEqual.default,1,0,1,"class<`formula`, `terms`>",1
+compare,compareEqual.default,1,0,2,class<`lm`>,1
+compare,compareEqual.default,1,0,3,class<`qr`>,1
+compare,compareEqual.default,1,0,4,expression,1
+compare,compareEqual.default,2,0,0,character[],1
+compare,compareEqual.default,3,0,0,...,1
+compare,compareEqualDF,-1,0,0,"class<`comparison`, `multipleComparison`>",1
+compare,compareEqualDF,0,0,0,class<`data.frame`>,1
+compare,compareEqualDF,1,0,0,class<`data.frame`>,1
+compare,compareEqualDF,2,0,0,class<`function`>,1
+compare,compareEqualDF,3,0,0,character[],1
+compare,compareEqualDF,4,0,0,any,1
+compare,compareEqualDF,5,0,0,any,1
+compare,compareEqualDF,6,0,0,logical,1
+compare,compareEqualDF,7,0,0,logical,1
+compare,compareEqualDF,8,0,0,...,1
+compare,compareEqual.factor,-1,0,0,class<`comparison`>,1
+compare,compareEqual.factor,0,0,0,class<`factor`>,1
+compare,compareEqual.factor,1,0,0,character[],1
+compare,compareEqual.factor,1,0,1,class<`factor`>,1
+compare,compareEqual.factor,1,0,2,double[],1
+compare,compareEqual.factor,2,0,0,character[],1
+compare,compareEqual.factor,3,0,0,any,1
+compare,compareEqual.factor,4,0,0,any,1
+compare,compareEqual.factor,5,0,0,...,1
+compare,compareEqual.language,-1,0,0,class<`comparison`>,1
+compare,compareEqual.language,-1,0,1,"class<`comparison`, `multipleComparison`>",1
+compare,compareEqual.language,0,0,0,class<`call`>,1
+compare,compareEqual.language,0,0,1,"class<`formula`, `terms`>",1
+compare,compareEqual.language,0,0,2,expression,1
+compare,compareEqual.language,1,0,0,class<`call`>,1
+compare,compareEqual.language,1,0,1,"class<`formula`, `terms`>",1
+compare,compareEqual.language,1,0,2,expression,1
+compare,compareEqual.language,2,0,0,character[],1
+compare,compareEqual.language,3,0,0,...,1
+compare,compareEqual.list,-1,0,0,"class<`comparison`, `multipleComparison`>",1
+compare,compareEqual.list,-1,0,1,class<`comparison`>,1
+compare,compareEqual.list,0,0,0,list<any>,1
+compare,compareEqual.list,1,0,0,list<any>,1
+compare,compareEqual.list,1,0,1,class<`data.frame`>,1
+compare,compareEqual.list,2,0,0,character[],1
+compare,compareEqual.list,3,0,0,logical,1
+compare,compareEqual.list,4,0,0,logical,1
+compare,compareEqual.list,5,0,0,...,1
+compare,compareEqual.list,6,0,0,any,1
+compare,compareEqual.matrix,-1,0,0,class<`comparison`>,1
+compare,compareEqual.matrix,0,0,0,class<`array`>,1
+compare,compareEqual.matrix,0,0,1,class<`matrix`>,1
+compare,compareEqual.matrix,0,0,2,class<`table`>,1
+compare,compareEqual.matrix,1,0,0,class<`array`>,1
+compare,compareEqual.matrix,1,0,1,class<`matrix`>,1
+compare,compareEqual.matrix,1,0,2,class<`table`>,1
+compare,compareEqual.matrix,2,0,0,character[],1
+compare,compareEqual.matrix,3,0,0,logical,1
+compare,compareEqual.matrix,4,0,0,...,1
+compare,compareEqual.numeric,-1,0,0,class<`comparison`>,1
+compare,compareEqual.numeric,0,0,0,double[],1
+compare,compareEqual.numeric,1,0,0,character[],1
+compare,compareEqual.numeric,1,0,1,class<`factor`>,1
+compare,compareEqual.numeric,1,0,2,class<`matrix`>,1
+compare,compareEqual.numeric,1,0,3,double[],1
+compare,compareEqual.numeric,2,0,0,character[],1
+compare,compareEqual.numeric,3,0,0,any,1
+compare,compareEqual.numeric,4,0,0,...,1
+compare,compareEqual.table,-1,0,0,class<`comparison`>,1
+compare,compareEqual.table,0,0,0,class<`array`>,1
+compare,compareEqual.table,0,0,1,class<`matrix`>,1
+compare,compareEqual.table,0,0,2,class<`table`>,1
+compare,compareEqual.table,1,0,0,class<`array`>,1
+compare,compareEqual.table,1,0,1,class<`matrix`>,1
+compare,compareEqual.table,1,0,2,class<`table`>,1
+compare,compareEqual.table,2,0,0,character[],1
+compare,compareEqual.table,3,0,0,logical,1
+compare,compareEqual.table,4,0,0,...,1
+compare,compareFile,-1,0,0,class<`comparisonList`>,1
+compare,compareFile,0,0,0,character,1
+compare,compareFile,0,0,1,"class<`connection`, `textConnection`>",1
+compare,compareFile,1,0,0,character[],1
+compare,compareFile,2,0,0,character,1
+compare,compareFile,2,0,1,null,1
+compare,compareFile,3,0,0,null,1
+compare,compareFile,4,0,0,null,1
+compare,compareFile,4,0,1,list<integer[]>,1
+compare,compareFile,5,0,0,logical,1
+compare,compareFile,5,0,1,class<`function`>,1
+compare,compareFile,5,0,2,list<class<`function`>>,1
+compare,compareFile,5,0,3,list<logical>,1
+compare,compareFile,6,0,0,...,1
+compare,compareFiles,-1,0,0,class<`comparisonListList`>,1
+compare,compareFiles,0,0,0,character[],1
+compare,compareFiles,1,0,0,character[],1
+compare,compareFiles,2,0,0,character,1
+compare,compareFiles,3,0,0,null,1
+compare,compareFiles,4,0,0,character[],1
+compare,compareFiles,5,0,0,...,1
+compare,compareIdentical,-1,0,0,class<`comparison`>,1
+compare,compareIdentical,0,0,0,character[],1
+compare,compareIdentical,0,0,1,class<`call`>,1
+compare,compareIdentical,0,0,2,class<`data.frame`>,1
+compare,compareIdentical,0,0,3,class<`factor`>,1
+compare,compareIdentical,0,0,4,"class<`formula`, `terms`>",1
+compare,compareIdentical,0,0,5,class<`lm`>,1
+compare,compareIdentical,0,0,6,class<`matrix`>,1
+compare,compareIdentical,0,0,7,class<`qr`>,1
+compare,compareIdentical,0,0,8,double[],1
+compare,compareIdentical,0,0,9,expression,1
+compare,compareIdentical,0,0,10,list<any>,1
+compare,compareIdentical,1,0,0,character[],1
+compare,compareIdentical,1,0,1,class<`factor`>,1
+compare,compareIdentical,1,0,2,class<`matrix`>,1
+compare,compareIdentical,1,0,3,class<`call`>,1
+compare,compareIdentical,1,0,4,class<`data.frame`>,1
+compare,compareIdentical,1,0,5,double[],1
+compare,compareIdentical,1,0,6,"class<`formula`, `terms`>",1
+compare,compareIdentical,1,0,7,class<`lm`>,1
+compare,compareIdentical,1,0,8,class<`qr`>,1
+compare,compareIdentical,1,0,9,expression,1
+compare,compareIdentical,1,0,10,list<any>,1
+compare,compareIdentical,2,0,0,any,1
+compare,compareIdentical,3,0,0,...,1
+compare,compareIdentical.default,-1,0,0,class<`comparison`>,1
+compare,compareIdentical.default,0,0,0,character[],1
+compare,compareIdentical.default,0,0,1,class<`call`>,1
+compare,compareIdentical.default,0,0,2,class<`data.frame`>,1
+compare,compareIdentical.default,0,0,3,class<`factor`>,1
+compare,compareIdentical.default,0,0,4,"class<`formula`, `terms`>",1
+compare,compareIdentical.default,0,0,5,class<`lm`>,1
+compare,compareIdentical.default,0,0,6,class<`matrix`>,1
+compare,compareIdentical.default,0,0,7,class<`qr`>,1
+compare,compareIdentical.default,0,0,8,double[],1
+compare,compareIdentical.default,0,0,9,expression,1
+compare,compareIdentical.default,0,0,10,list<any>,1
+compare,compareIdentical.default,1,0,0,character[],1
+compare,compareIdentical.default,1,0,1,class<`factor`>,1
+compare,compareIdentical.default,1,0,2,class<`matrix`>,1
+compare,compareIdentical.default,1,0,3,class<`call`>,1
+compare,compareIdentical.default,1,0,4,class<`data.frame`>,1
+compare,compareIdentical.default,1,0,5,double[],1
+compare,compareIdentical.default,1,0,6,"class<`formula`, `terms`>",1
+compare,compareIdentical.default,1,0,7,class<`lm`>,1
+compare,compareIdentical.default,1,0,8,class<`qr`>,1
+compare,compareIdentical.default,1,0,9,expression,1
+compare,compareIdentical.default,1,0,10,list<any>,1
+compare,compareIdentical.default,2,0,0,character[],1
+compare,compareIdentical.default,3,0,0,...,1
+compare,compareIgnoreAttrs,-1,0,0,class<`comparison`>,1
+compare,compareIgnoreAttrs,-1,0,1,"class<`comparison`, `multipleComparison`>",1
+compare,compareIgnoreAttrs,0,0,0,character[],1
+compare,compareIgnoreAttrs,0,0,1,class<`data.frame`>,1
+compare,compareIgnoreAttrs,0,0,2,class<`factor`>,1
+compare,compareIgnoreAttrs,0,0,3,double[],1
+compare,compareIgnoreAttrs,0,0,4,list<any>,1
+compare,compareIgnoreAttrs,0,0,5,class<`matrix`>,1
+compare,compareIgnoreAttrs,1,0,0,class<`matrix`>,1
+compare,compareIgnoreAttrs,1,0,1,character,1
+compare,compareIgnoreAttrs,1,0,2,class<`data.frame`>,1
+compare,compareIgnoreAttrs,1,0,3,class<`factor`>,1
+compare,compareIgnoreAttrs,1,0,4,double[],1
+compare,compareIgnoreAttrs,1,0,5,list<any>,1
+compare,compareIgnoreAttrs,2,0,0,any,1
+compare,compareIgnoreAttrs,3,0,0,any,1
+compare,compareIgnoreAttrs,4,0,0,...,1
+compare,compareIgnoreAttrs.default,-1,0,0,class<`comparison`>,1
+compare,compareIgnoreAttrs.default,-1,0,1,"class<`comparison`, `multipleComparison`>",1
+compare,compareIgnoreAttrs.default,0,0,0,character[],1
+compare,compareIgnoreAttrs.default,0,0,1,class<`data.frame`>,1
+compare,compareIgnoreAttrs.default,0,0,2,class<`factor`>,1
+compare,compareIgnoreAttrs.default,0,0,3,class<`matrix`>,1
+compare,compareIgnoreAttrs.default,0,0,4,double[],1
+compare,compareIgnoreAttrs.default,0,0,5,list<any>,1
+compare,compareIgnoreAttrs.default,1,0,0,class<`matrix`>,1
+compare,compareIgnoreAttrs.default,1,0,1,character,1
+compare,compareIgnoreAttrs.default,1,0,2,class<`data.frame`>,1
+compare,compareIgnoreAttrs.default,1,0,3,class<`factor`>,1
+compare,compareIgnoreAttrs.default,1,0,4,double[],1
+compare,compareIgnoreAttrs.default,1,0,5,list<any>,1
+compare,compareIgnoreAttrs.default,2,0,0,character[],1
+compare,compareIgnoreAttrs.default,3,0,0,any,1
+compare,compareIgnoreAttrs.default,4,0,0,...,1
+compare,compareIgnoreNameCase,-1,0,0,class<`comparison`>,1
+compare,compareIgnoreNameCase,-1,0,1,"class<`comparison`, `multipleComparison`>",1
+compare,compareIgnoreNameCase,0,0,0,character,1
+compare,compareIgnoreNameCase,0,0,1,class<`data.frame`>,1
+compare,compareIgnoreNameCase,0,0,2,class<`factor`>,1
+compare,compareIgnoreNameCase,0,0,3,double[],1
+compare,compareIgnoreNameCase,0,0,4,list<any>,1
+compare,compareIgnoreNameCase,1,0,0,character,1
+compare,compareIgnoreNameCase,1,0,1,class<`data.frame`>,1
+compare,compareIgnoreNameCase,1,0,2,class<`factor`>,1
+compare,compareIgnoreNameCase,1,0,3,double[],1
+compare,compareIgnoreNameCase,1,0,4,list<any>,1
+compare,compareIgnoreNameCase,2,0,0,any,1
+compare,compareIgnoreNameCase,3,0,0,any,1
+compare,compareIgnoreNameCase,4,0,0,...,1
+compare,compareIgnoreNameCase.data.frame,-1,0,0,class<`comparison`>,1
+compare,compareIgnoreNameCase.data.frame,-1,0,1,"class<`comparison`, `multipleComparison`>",1
+compare,compareIgnoreNameCase.data.frame,0,0,0,class<`data.frame`>,1
+compare,compareIgnoreNameCase.data.frame,1,0,0,class<`data.frame`>,1
+compare,compareIgnoreNameCase.data.frame,2,0,0,any,1
+compare,compareIgnoreNameCase.data.frame,3,0,0,any,1
+compare,compareIgnoreNameCase.data.frame,4,0,0,logical,1
+compare,compareIgnoreNameCase.data.frame,5,0,0,logical,1
+compare,compareIgnoreNameCase.data.frame,6,0,0,logical,1
+compare,compareIgnoreNameCase.data.frame,7,0,0,...,1
+compare,compareIgnoreNameCase.default,-1,0,0,class<`comparison`>,1
+compare,compareIgnoreNameCase.default,-1,0,1,"class<`comparison`, `multipleComparison`>",1
+compare,compareIgnoreNameCase.default,0,0,0,character,1
+compare,compareIgnoreNameCase.default,0,0,1,class<`data.frame`>,1
+compare,compareIgnoreNameCase.default,0,0,2,class<`factor`>,1
+compare,compareIgnoreNameCase.default,0,0,3,double[],1
+compare,compareIgnoreNameCase.default,1,0,0,character,1
+compare,compareIgnoreNameCase.default,1,0,1,class<`data.frame`>,1
+compare,compareIgnoreNameCase.default,1,0,2,class<`factor`>,1
+compare,compareIgnoreNameCase.default,1,0,3,double[],1
+compare,compareIgnoreNameCase.default,2,0,0,character[],1
+compare,compareIgnoreNameCase.default,3,0,0,any,1
+compare,compareIgnoreNameCase.default,4,0,0,...,1
+compare,compareIgnoreNameCase.list,-1,0,0,class<`comparison`>,1
+compare,compareIgnoreNameCase.list,-1,0,1,"class<`comparison`, `multipleComparison`>",1
+compare,compareIgnoreNameCase.list,0,0,0,list<any>,1
+compare,compareIgnoreNameCase.list,1,0,0,list<any>,1
+compare,compareIgnoreNameCase.list,2,0,0,character[],1
+compare,compareIgnoreNameCase.list,3,0,0,logical,1
+compare,compareIgnoreNameCase.list,4,0,0,logical,1
+compare,compareIgnoreNameCase.list,5,0,0,...,1
+compare,compareIgnoreNames,-1,0,0,class<`comparison`>,1
+compare,compareIgnoreNames,-1,0,1,"class<`comparison`, `multipleComparison`>",1
+compare,compareIgnoreNames,0,0,0,character,1
+compare,compareIgnoreNames,0,0,1,class<`data.frame`>,1
+compare,compareIgnoreNames,0,0,2,class<`factor`>,1
+compare,compareIgnoreNames,0,0,3,double[],1
+compare,compareIgnoreNames,0,0,4,list<any>,1
+compare,compareIgnoreNames,1,0,0,character,1
+compare,compareIgnoreNames,1,0,1,class<`data.frame`>,1
+compare,compareIgnoreNames,1,0,2,class<`factor`>,1
+compare,compareIgnoreNames,1,0,3,double[],1
+compare,compareIgnoreNames,1,0,4,list<any>,1
+compare,compareIgnoreNames,2,0,0,any,1
+compare,compareIgnoreNames,3,0,0,logical,1
+compare,compareIgnoreNames,4,0,0,...,1
+compare,compareIgnoreNames.data.frame,-1,0,0,class<`comparison`>,1
+compare,compareIgnoreNames.data.frame,-1,0,1,"class<`comparison`, `multipleComparison`>",1
+compare,compareIgnoreNames.data.frame,0,0,0,class<`data.frame`>,1
+compare,compareIgnoreNames.data.frame,1,0,0,class<`data.frame`>,1
+compare,compareIgnoreNames.data.frame,2,0,0,any,1
+compare,compareIgnoreNames.data.frame,3,0,0,logical,1
+compare,compareIgnoreNames.data.frame,4,0,0,logical,1
+compare,compareIgnoreNames.data.frame,5,0,0,logical,1
+compare,compareIgnoreNames.data.frame,6,0,0,logical,1
+compare,compareIgnoreNames.data.frame,7,0,0,...,1
+compare,compareIgnoreNames.default,-1,0,0,class<`comparison`>,1
+compare,compareIgnoreNames.default,-1,0,1,"class<`comparison`, `multipleComparison`>",1
+compare,compareIgnoreNames.default,0,0,0,character,1
+compare,compareIgnoreNames.default,0,0,1,class<`data.frame`>,1
+compare,compareIgnoreNames.default,0,0,2,class<`factor`>,1
+compare,compareIgnoreNames.default,0,0,3,double[],1
+compare,compareIgnoreNames.default,1,0,0,character,1
+compare,compareIgnoreNames.default,1,0,1,class<`data.frame`>,1
+compare,compareIgnoreNames.default,1,0,2,class<`factor`>,1
+compare,compareIgnoreNames.default,1,0,3,double[],1
+compare,compareIgnoreNames.default,2,0,0,character[],1
+compare,compareIgnoreNames.default,3,0,0,logical,1
+compare,compareIgnoreNames.default,4,0,0,...,1
+compare,compareIgnoreNames.list,-1,0,0,class<`comparison`>,1
+compare,compareIgnoreNames.list,-1,0,1,"class<`comparison`, `multipleComparison`>",1
+compare,compareIgnoreNames.list,0,0,0,list<any>,1
+compare,compareIgnoreNames.list,1,0,0,list<any>,1
+compare,compareIgnoreNames.list,2,0,0,character[],1
+compare,compareIgnoreNames.list,3,0,0,logical,1
+compare,compareIgnoreNames.list,4,0,0,logical,1
+compare,compareIgnoreNames.list,5,0,0,any,1
+compare,compareIgnoreNames.list,6,0,0,...,1
+compare,compareIgnoreOrder,-1,0,0,class<`comparison`>,1
+compare,compareIgnoreOrder,-1,0,1,"class<`comparison`, `multipleComparison`>",1
+compare,compareIgnoreOrder,0,0,0,character,1
+compare,compareIgnoreOrder,0,0,1,double[],1
+compare,compareIgnoreOrder,0,0,2,class<`data.frame`>,1
+compare,compareIgnoreOrder,0,0,3,list<any>,1
+compare,compareIgnoreOrder,0,0,4,class<`lm`>,1
+compare,compareIgnoreOrder,0,0,5,class<`table`>,1
+compare,compareIgnoreOrder,0,0,6,expression,1
+compare,compareIgnoreOrder,1,0,0,character[],1
+compare,compareIgnoreOrder,1,0,1,double[],1
+compare,compareIgnoreOrder,1,0,2,class<`data.frame`>,1
+compare,compareIgnoreOrder,1,0,3,list<any>,1
+compare,compareIgnoreOrder,1,0,4,class<`lm`>,1
+compare,compareIgnoreOrder,1,0,5,class<`table`>,1
+compare,compareIgnoreOrder,1,0,6,expression,1
+compare,compareIgnoreOrder,2,0,0,any,1
+compare,compareIgnoreOrder,3,0,0,any,1
+compare,compareIgnoreOrder,4,0,0,...,1
+compare,compareIgnoreOrder.data.frame,-1,0,0,class<`comparison`>,1
+compare,compareIgnoreOrder.data.frame,-1,0,1,"class<`comparison`, `multipleComparison`>",1
+compare,compareIgnoreOrder.data.frame,0,0,0,class<`data.frame`>,1
+compare,compareIgnoreOrder.data.frame,1,0,0,class<`data.frame`>,1
+compare,compareIgnoreOrder.data.frame,2,0,0,character[],1
+compare,compareIgnoreOrder.data.frame,3,0,0,logical,1
+compare,compareIgnoreOrder.data.frame,4,0,0,logical,1
+compare,compareIgnoreOrder.data.frame,5,0,0,logical,1
+compare,compareIgnoreOrder.data.frame,6,0,0,...,1
+compare,compareIgnoreOrder.default,-1,0,0,class<`comparison`>,1
+compare,compareIgnoreOrder.default,-1,0,1,"class<`comparison`, `multipleComparison`>",1
+compare,compareIgnoreOrder.default,0,0,0,character,1
+compare,compareIgnoreOrder.default,0,0,1,class<`lm`>,1
+compare,compareIgnoreOrder.default,0,0,2,class<`table`>,1
+compare,compareIgnoreOrder.default,0,0,3,double[],1
+compare,compareIgnoreOrder.default,0,0,4,expression,1
+compare,compareIgnoreOrder.default,1,0,0,class<`lm`>,1
+compare,compareIgnoreOrder.default,1,0,1,class<`table`>,1
+compare,compareIgnoreOrder.default,1,0,2,character[],1
+compare,compareIgnoreOrder.default,1,0,3,double[],1
+compare,compareIgnoreOrder.default,1,0,4,expression,1
+compare,compareIgnoreOrder.default,2,0,0,character[],1
+compare,compareIgnoreOrder.default,3,0,0,any,1
+compare,compareIgnoreOrder.default,4,0,0,...,1
+compare,compareIgnoreOrder.language,-1,0,0,class<`comparison`>,1
+compare,compareIgnoreOrder.language,-1,0,1,"class<`comparison`, `multipleComparison`>",1
+compare,compareIgnoreOrder.language,0,0,0,expression,1
+compare,compareIgnoreOrder.language,1,0,0,expression,1
+compare,compareIgnoreOrder.language,2,0,0,character[],1
+compare,compareIgnoreOrder.language,3,0,0,...,1
+compare,compareIgnoreOrder.list,-1,0,0,class<`comparison`>,1
+compare,compareIgnoreOrder.list,-1,0,1,"class<`comparison`, `multipleComparison`>",1
+compare,compareIgnoreOrder.list,0,0,0,list<any>,1
+compare,compareIgnoreOrder.list,1,0,0,list<any>,1
+compare,compareIgnoreOrder.list,2,0,0,character[],1
+compare,compareIgnoreOrder.list,3,0,0,logical,1
+compare,compareIgnoreOrder.list,4,0,0,logical,1
+compare,compareIgnoreOrder.list,5,0,0,...,1
+compare,compareListComponents,-1,0,0,"class<`comparison`, `multipleComparison`>",1
+compare,compareListComponents,0,0,0,list<any>,1
+compare,compareListComponents,1,0,0,class<`data.frame`>,1
+compare,compareListComponents,1,0,1,list<any>,1
+compare,compareListComponents,2,0,0,character[],1
+compare,compareListComponents,3,0,0,list<any>,1
+compare,compareListComponents,4,0,0,class<`data.frame`>,1
+compare,compareListComponents,4,0,1,list<any>,1
+compare,compareListComponents,5,0,0,character[],1
+compare,compareListComponents,6,0,0,logical,1
+compare,compareListComponents,7,0,0,logical,1
+compare,compareListComponents,8,0,0,...,1
+compare,compareListComponents,9,0,0,class<`function`>,1
+compare,compareShorten,-1,0,0,class<`comparison`>,1
+compare,compareShorten,-1,0,1,"class<`comparison`, `multipleComparison`>",1
+compare,compareShorten,0,0,0,character[],1
+compare,compareShorten,0,0,1,class<`matrix`>,1
+compare,compareShorten,0,0,2,double[],1
+compare,compareShorten,0,0,3,class<`data.frame`>,1
+compare,compareShorten,0,0,4,list<any>,1
+compare,compareShorten,0,0,5,class<`array`>,1
+compare,compareShorten,0,0,6,class<`lm`>,1
+compare,compareShorten,0,0,7,class<`table`>,1
+compare,compareShorten,0,0,8,expression,1
+compare,compareShorten,1,0,0,character[],1
+compare,compareShorten,1,0,1,class<`array`>,1
+compare,compareShorten,1,0,2,double[],1
+compare,compareShorten,1,0,3,class<`data.frame`>,1
+compare,compareShorten,1,0,4,list<any>,1
+compare,compareShorten,1,0,5,class<`matrix`>,1
+compare,compareShorten,1,0,6,class<`lm`>,1
+compare,compareShorten,1,0,7,expression,1
+compare,compareShorten,2,0,0,any,1
+compare,compareShorten,3,0,0,any,1
+compare,compareShorten,4,0,0,...,1
+compare,compareShorten.array,-1,0,0,class<`comparison`>,1
+compare,compareShorten.array,0,0,0,class<`array`>,1
+compare,compareShorten.array,0,0,1,class<`matrix`>,1
+compare,compareShorten.array,0,0,2,class<`table`>,1
+compare,compareShorten.array,1,0,0,class<`matrix`>,1
+compare,compareShorten.array,1,0,1,class<`array`>,1
+compare,compareShorten.array,2,0,0,character[],1
+compare,compareShorten.array,3,0,0,logical,1
+compare,compareShorten.array,4,0,0,...,1
+compare,compareShorten.data.frame,-1,0,0,"class<`comparison`, `multipleComparison`>",1
+compare,compareShorten.data.frame,0,0,0,class<`data.frame`>,1
+compare,compareShorten.data.frame,1,0,0,class<`data.frame`>,1
+compare,compareShorten.data.frame,2,0,0,character[],1
+compare,compareShorten.data.frame,3,0,0,logical,1
+compare,compareShorten.data.frame,4,0,0,logical,1
+compare,compareShorten.data.frame,5,0,0,logical,1
+compare,compareShorten.data.frame,6,0,0,logical,1
+compare,compareShorten.data.frame,7,0,0,...,1
+compare,compareShorten.default,-1,0,0,class<`comparison`>,1
+compare,compareShorten.default,-1,0,1,"class<`comparison`, `multipleComparison`>",1
+compare,compareShorten.default,0,0,0,character[],1
+compare,compareShorten.default,0,0,1,class<`lm`>,1
+compare,compareShorten.default,0,0,2,double[],1
+compare,compareShorten.default,0,0,3,expression,1
+compare,compareShorten.default,1,0,0,character[],1
+compare,compareShorten.default,1,0,1,class<`lm`>,1
+compare,compareShorten.default,1,0,2,double[],1
+compare,compareShorten.default,1,0,3,expression,1
+compare,compareShorten.default,2,0,0,character[],1
+compare,compareShorten.default,3,0,0,any,1
+compare,compareShorten.default,4,0,0,...,1
+compare,compareShorten.list,-1,0,0,class<`comparison`>,1
+compare,compareShorten.list,-1,0,1,"class<`comparison`, `multipleComparison`>",1
+compare,compareShorten.list,0,0,0,list<any>,1
+compare,compareShorten.list,1,0,0,list<any>,1
+compare,compareShorten.list,2,0,0,character[],1
+compare,compareShorten.list,3,0,0,logical,1
+compare,compareShorten.list,4,0,0,logical,1
+compare,compareShorten.list,5,0,0,any,1
+compare,compareShorten.list,6,0,0,...,1
+compare,compareShorten.matrix,-1,0,0,class<`comparison`>,1
+compare,compareShorten.matrix,0,0,0,class<`array`>,1
+compare,compareShorten.matrix,0,0,1,class<`matrix`>,1
+compare,compareShorten.matrix,0,0,2,class<`table`>,1
+compare,compareShorten.matrix,1,0,0,class<`matrix`>,1
+compare,compareShorten.matrix,1,0,1,class<`array`>,1
+compare,compareShorten.matrix,2,0,0,character[],1
+compare,compareShorten.matrix,3,0,0,logical,1
+compare,compareShorten.matrix,4,0,0,...,1
+compare,compareShorten.table,-1,0,0,class<`comparison`>,1
+compare,compareShorten.table,0,0,0,class<`array`>,1
+compare,compareShorten.table,0,0,1,class<`matrix`>,1
+compare,compareShorten.table,0,0,2,class<`table`>,1
+compare,compareShorten.table,1,0,0,class<`matrix`>,1
+compare,compareShorten.table,1,0,1,class<`array`>,1
+compare,compareShorten.table,2,0,0,character[],1
+compare,compareShorten.table,3,0,0,logical,1
+compare,compareShorten.table,4,0,0,...,1
+compare,comparison,-1,0,0,class<`comparison`>,1
+compare,comparison,0,0,0,character[],1
+compare,comparison,0,0,1,class<`call`>,1
+compare,comparison,0,0,2,class<`data.frame`>,1
+compare,comparison,0,0,3,class<`factor`>,1
+compare,comparison,0,0,4,"class<`formula`, `terms`>",1
+compare,comparison,0,0,5,class<`lm`>,1
+compare,comparison,0,0,6,class<`matrix`>,1
+compare,comparison,0,0,7,class<`qr`>,1
+compare,comparison,0,0,8,double[],1
+compare,comparison,0,0,9,expression,1
+compare,comparison,0,0,10,list<any>,1
+compare,comparison,1,0,0,character[],1
+compare,comparison,1,0,1,class<`factor`>,1
+compare,comparison,1,0,2,class<`matrix`>,1
+compare,comparison,1,0,3,class<`call`>,1
+compare,comparison,1,0,4,class<`data.frame`>,1
+compare,comparison,1,0,5,null,1
+compare,comparison,1,0,6,double[],1
+compare,comparison,1,0,7,"class<`formula`, `terms`>",1
+compare,comparison,1,0,8,class<`lm`>,1
+compare,comparison,1,0,9,class<`qr`>,1
+compare,comparison,1,0,10,expression,1
+compare,comparison,1,0,11,list<any>,1
+compare,comparison,2,0,0,logical,1
+compare,comparison,3,0,0,character[],1
+compare,comparison,4,0,0,character[],1
+compare,comparison,4,0,1,class<`call`>,1
+compare,comparison,4,0,2,class<`data.frame`>,1
+compare,comparison,4,0,3,class<`factor`>,1
+compare,comparison,4,0,4,"class<`formula`, `terms`>",1
+compare,comparison,4,0,5,class<`lm`>,1
+compare,comparison,4,0,6,class<`matrix`>,1
+compare,comparison,4,0,7,class<`qr`>,1
+compare,comparison,4,0,8,double[],1
+compare,comparison,4,0,9,expression,1
+compare,comparison,4,0,10,list<any>,1
+compare,comparison,5,0,0,character[],1
+compare,comparison,5,0,1,class<`factor`>,1
+compare,comparison,5,0,2,class<`matrix`>,1
+compare,comparison,5,0,3,class<`call`>,1
+compare,comparison,5,0,4,class<`data.frame`>,1
+compare,comparison,5,0,5,null,1
+compare,comparison,5,0,6,double[],1
+compare,comparison,5,0,7,"class<`formula`, `terms`>",1
+compare,comparison,5,0,8,class<`lm`>,1
+compare,comparison,5,0,9,class<`qr`>,1
+compare,comparison,5,0,10,expression,1
+compare,comparison,5,0,11,list<any>,1
+compare,comparison,6,0,0,character[],1
+compare,comparisonComments,-1,0,0,character,1
+compare,comparisonComments,0,0,0,class<`markingComments`>,1
+compare,comparisonComments,1,0,0,class<`comparison`>,1
+compare,dimnamesINdimnames,-1,0,0,list<integer[]>,1
+compare,dimnamesINdimnames,0,0,0,list<character[]>,1
+compare,dimnamesINdimnames,1,0,0,list<character[]>,1
+compare,dropDimensions,-1,0,0,list<class<`matrix`> | character>,1
+compare,dropDimensions,0,0,0,class<`array`>,1
+compare,dropDimensions,0,0,1,class<`matrix`>,1
+compare,dropDimensions,0,0,2,class<`table`>,1
+compare,dropDimensions,1,0,0,class<`matrix`>,1
+compare,dropDimensions,1,0,1,class<`array`>,1
+compare,dropDimensions,2,0,0,character[],1
+compare,dropDimensions.array,-1,0,0,list<class<`matrix`> | character>,1
+compare,dropDimensions.array,0,0,0,class<`array`>,1
+compare,dropDimensions.array,1,0,0,class<`matrix`>,1
+compare,dropDimensions.array,2,0,0,character[],1
+compare,dropDimensions.matrix,-1,0,0,list<class<`matrix`> | character>,1
+compare,dropDimensions.matrix,0,0,0,class<`matrix`>,1
+compare,dropDimensions.matrix,1,0,0,class<`array`>,1
+compare,dropDimensions.matrix,2,0,0,character[],1
+compare,dropDimensions.table,-1,0,0,list<class<`matrix`> | character>,1
+compare,dropDimensions.table,0,0,0,class<`table`>,1
+compare,dropDimensions.table,1,0,0,class<`matrix`>,1
+compare,dropDimensions.table,2,0,0,character[],1
+compare,growComments,-1,0,0,character,1
+compare,growComments,0,0,0,character[],1
+compare,growComments,1,0,0,character,1
+compare,isTRUE,-1,0,0,logical,1
+compare,isTRUE,0,0,0,class<`comparison`>,1
+compare,isTRUE,0,0,1,character[],1
+compare,isTRUE,0,0,2,logical,1
+compare,isTRUE.comparison,-1,0,0,logical,1
+compare,isTRUE.comparison,0,0,0,class<`comparison`>,1
+compare,markQuestion,-1,0,0,double[],1
+compare,markQuestion,0,0,0,class<`comparisonList`>,1
+compare,markQuestion,0,0,1,class<`comparisonListList`>,1
+compare,markQuestion,1,0,0,class<`questionMarks`>,1
+compare,markQuestion.comparisonList,-1,0,0,double,1
+compare,markQuestion.comparisonList,0,0,0,class<`comparisonList`>,1
+compare,markQuestion.comparisonList,1,0,0,class<`questionMarks`>,1
+compare,markQuestion.comparisonListList,-1,0,0,double[],1
+compare,markQuestion.comparisonListList,0,0,0,class<`comparisonListList`>,1
+compare,markQuestion.comparisonListList,1,0,0,class<`questionMarks`>,1
+compare,markQuestions,-1,0,0,class<`matrix`>,1
+compare,markQuestions,0,0,0,class<`comparisonListList`>,1
+compare,markQuestions,1,0,0,...,1
+compare,multipleComparison,-1,0,0,"class<`comparison`, `multipleComparison`>",1
+compare,multipleComparison,0,0,0,class<`data.frame`>,1
+compare,multipleComparison,0,0,1,list<any>,1
+compare,multipleComparison,1,0,0,class<`data.frame`>,1
+compare,multipleComparison,1,0,1,list<any>,1
+compare,multipleComparison,2,0,0,logical,1
+compare,multipleComparison,3,0,0,logical[],1
+compare,multipleComparison,3,0,1,list<any>,1
+compare,multipleComparison,4,0,0,character[],1
+compare,multipleComparison,5,0,0,class<`data.frame`>,1
+compare,multipleComparison,5,0,1,expression,1
+compare,multipleComparison,5,0,2,list<any>,1
+compare,multipleComparison,5,0,3,class<`lm`>,1
+compare,multipleComparison,6,0,0,class<`data.frame`>,1
+compare,multipleComparison,6,0,1,expression,1
+compare,multipleComparison,6,0,2,list<any>,1
+compare,multipleComparison,6,0,3,class<`lm`>,1
+compare,multipleComparison,7,0,0,character[],1
+compare,questionComments,-1,0,0,class<`questionComments`>,1
+compare,questionComments,0,0,0,character[],1
+compare,questionComments,1,0,0,...,1
+compare,questionMarks,-1,0,0,class<`questionMarks`>,1
+compare,questionMarks,0,0,0,character[],1
+compare,questionMarks,1,0,0,double,1
+compare,questionMarks,2,0,0,...,1
+compare,reorderComparison,-1,0,0,list<class<`data.frame`> | character[]>,1
+compare,reorderComparison,-1,0,1,list<class<`data.frame`> | character>,1
+compare,reorderComparison,-1,0,2,list<character[] | list<integer[] | character[] | list<class<`factor`>>>>,1
+compare,reorderComparison,-1,0,3,list<character | list<integer[] | character[] | list<class<`factor`>>>>,1
+compare,reorderComparison,0,0,0,class<`data.frame`>,1
+compare,reorderComparison,0,0,1,list<integer[] | character[] | list<class<`factor`>>>,1
+compare,reorderComparison,1,0,0,class<`data.frame`>,1
+compare,reorderComparison,1,0,1,list<integer[] | character[] | list<class<`factor`>>>,1
+compare,reorderComparison,2,0,0,character[],1
+compare,reorderComparison,3,0,0,logical,1
+compare,reorderComparison,4,0,0,class<`function`>,1
+compare,restoreAttrs,-1,0,0,character[],1
+compare,restoreAttrs,-1,0,1,class<`factor`>,1
+compare,restoreAttrs,-1,0,2,double[],1
+compare,restoreAttrs,-1,0,3,list<integer[] | character[]>,1
+compare,restoreAttrs,-1,0,4,list<integer[] | class<`factor`>>,1
+compare,restoreAttrs,0,0,0,character[],1
+compare,restoreAttrs,0,0,1,class<`factor`>,1
+compare,restoreAttrs,0,0,2,double[],1
+compare,restoreAttrs,0,0,3,list<integer[] | character[]>,1
+compare,restoreAttrs,0,0,4,list<integer[] | class<`factor`>>,1
+compare,restoreAttrs,1,0,0,null,1
+compare,restoreAttrs,1,0,1,list<character[]>,1
+compare,restoreAttrs,1,0,2,list<integer[] | character | list<character[]>>,1
+compare,restoreAttrs,1,0,3,list<integer[]>,1
+compare,restoreAttrs,1,0,4,list<character[] | integer[]>,1
+compare,rule,-1,0,0,class<`markingRule`>,1
+compare,rule,0,0,0,character,1
+compare,rule,1,0,0,double,1
+compare,rule,2,0,0,...,1
+compare,same,-1,0,0,class<`comparison`>,1
+compare,same,-1,0,1,"class<`comparison`, `multipleComparison`>",1
+compare,same,0,0,0,character[],1
+compare,same,0,0,1,class<`data.frame`>,1
+compare,same,0,0,2,class<`factor`>,1
+compare,same,0,0,3,class<`lm`>,1
+compare,same,0,0,4,class<`matrix`>,1
+compare,same,0,0,5,double[],1
+compare,same,0,0,6,expression,1
+compare,same,0,0,7,list<any>,1
+compare,same,1,0,0,character[],1
+compare,same,1,0,1,class<`data.frame`>,1
+compare,same,1,0,2,class<`factor`>,1
+compare,same,1,0,3,class<`lm`>,1
+compare,same,1,0,4,class<`matrix`>,1
+compare,same,1,0,5,double[],1
+compare,same,1,0,6,expression,1
+compare,same,1,0,7,list<any>,1
+compare,same,2,0,0,character[],1
+compare,same,3,0,0,any,1
+compare,same,4,0,0,...,1
+compare,similarNames,-1,0,0,logical,1
+compare,similarNames,0,0,0,class<`data.frame`>,1
+compare,similarNames,0,0,1,list<any>,1
+compare,similarNames,1,0,0,class<`data.frame`>,1
+compare,similarNames,1,0,1,list<any>,1
+compare,similarNames,2,0,0,logical,1
+compare,sourceFile,-1,0,0,list<class<`factor`> | double[]>,1
+compare,sourceFile,0,0,0,character,1
+compare,sourceFile,1,0,0,character[],1
+compare,transformComment,-1,0,0,class<`transformComment`>,1
+compare,transformComment,0,0,0,character,1
+compare,transformComment,1,0,0,character,1
+compare,transformRule,-1,0,0,class<`transformRule`>,1
+compare,transformRule,0,0,0,character,1
+compare,transformRule,1,0,0,double,1
+compare,transforms,-1,0,0,character[],1
+compare,transforms,0,0,0,class<`comparison`>,1
+coneproj,coef.coneproj,-1,0,0,class<`matrix`>,1
+coneproj,coef.coneproj,-1,0,1,double[],1
+coneproj,coef.coneproj,0,0,0,class<`coneproj`>,1
+coneproj,coef.coneproj,1,0,0,...,1
+coneproj,conc,-1,0,0,double[],1
+coneproj,conc,0,0,0,double[],1
+coneproj,coneA,-1,0,0,class<`coneproj`>,1
+coneproj,coneA,0,0,0,class<`matrix`>,1
+coneproj,coneA,0,0,1,double[],1
+coneproj,coneA,1,0,0,class<`matrix`>,1
+coneproj,coneA,2,0,0,null,1
+coneproj,coneA,2,0,1,double[],1
+coneproj,coneA,3,0,0,null,1
+coneproj,coneA,4,0,0,logical,1
+coneproj,coneB,-1,0,0,class<`coneproj`>,1
+coneproj,coneB,0,0,0,double[],1
+coneproj,coneB,1,0,0,class<`matrix`>,1
+coneproj,coneB,2,0,0,class<`matrix`>,1
+coneproj,coneB,3,0,0,double[],1
+coneproj,coneB,3,0,1,null,1
+coneproj,coneB,4,0,0,null,1
+coneproj,coneB,5,0,0,logical,1
+coneproj,constreg,-1,0,0,class<`coneproj`>,1
+coneproj,constreg,0,0,0,double[],1
+coneproj,constreg,1,0,0,class<`matrix`>,1
+coneproj,constreg,2,0,0,class<`matrix`>,1
+coneproj,constreg,3,0,0,null,1
+coneproj,constreg,4,0,0,logical,1
+coneproj,constreg,5,0,0,double,1
+coneproj,conv,-1,0,0,double[],1
+coneproj,conv,0,0,0,double[],1
+coneproj,decr,-1,0,0,double[],1
+coneproj,decr,0,0,0,double[],1
+coneproj,decr.conc,-1,0,0,double[],1
+coneproj,decr.conc,0,0,0,double[],1
+coneproj,decr.conv,-1,0,0,double[],1
+coneproj,decr.conv,0,0,0,double[],1
+coneproj,fitted.coneproj,-1,0,0,class<`matrix`>,1
+coneproj,fitted.coneproj,0,0,0,class<`coneproj`>,1
+coneproj,fitted.coneproj,1,0,0,...,1
+coneproj,incr,-1,0,0,double[],1
+coneproj,incr,0,0,0,double[],1
+coneproj,incr.conc,-1,0,0,double[],1
+coneproj,incr.conc,0,0,0,double[],1
+coneproj,incr.conv,-1,0,0,double[],1
+coneproj,incr.conv,0,0,0,double[],1
+coneproj,makedelta,-1,0,0,class<`matrix`>,1
+coneproj,makedelta,0,0,0,class<`matrix`>,1
+coneproj,makedelta,1,0,0,double,1
+coneproj,qprog,-1,0,0,class<`coneproj`>,1
+coneproj,qprog,0,0,0,class<`matrix`>,1
+coneproj,qprog,1,0,0,class<`matrix`>,1
+coneproj,qprog,2,0,0,class<`matrix`>,1
+coneproj,qprog,3,0,0,double[],1
+coneproj,qprog,4,0,0,null,1
+coneproj,qprog,5,0,0,logical,1
+coneproj,shapereg,-1,0,0,class<`coneproj`>,1
+coneproj,shapereg,0,0,0,any,1
+coneproj,shapereg,1,0,0,null,1
+coneproj,shapereg,2,0,0,null,1
+coneproj,shapereg,3,0,0,logical,1
+coneproj,shapereg,4,0,0,double,1
+coneproj,shapereg.fit,-1,0,0,list<double[] | class<`matrix`>>,1
+coneproj,shapereg.fit,-1,0,1,list<null | double[] | class<`matrix`>>,1
+coneproj,shapereg.fit,-1,0,2,list<null | double | class<`matrix`>>,1
+coneproj,shapereg.fit,0,0,0,double[],1
+coneproj,shapereg.fit,1,0,0,class<`matrix`>,1
+coneproj,shapereg.fit,2,0,0,double,1
+coneproj,shapereg.fit,3,0,0,class<`matrix`>,1
+coneproj,shapereg.fit,3,0,1,null,1
+coneproj,shapereg.fit,4,0,0,null,1
+coneproj,shapereg.fit,5,0,0,logical,1
+coneproj,shapereg.fit,6,0,0,any,1
+coneproj,summary.coneproj,-1,0,0,class<`summary.coneproj`>,1
+coneproj,summary.coneproj,0,0,0,class<`coneproj`>,1
+coneproj,summary.coneproj,1,0,0,...,1
+corpcor,cor2pcor,-1,0,0,class<`matrix`>,1
+corpcor,cor2pcor,0,0,0,class<`matrix`>,1
+corpcor,cor2pcor,0,0,1,class<`shrinkage`>,1
+corpcor,cor2pcor,1,0,0,any,1
+corpcor,cor.shrink,-1,0,0,class<`shrinkage`>,1
+corpcor,cor.shrink,0,0,0,class<`matrix`>,1
+corpcor,cor.shrink,1,0,0,any,1
+corpcor,cor.shrink,2,0,0,any,1
+corpcor,cor.shrink,3,0,0,logical,1
+corpcor,cov.shrink,-1,0,0,class<`shrinkage`>,1
+corpcor,cov.shrink,0,0,0,class<`matrix`>,1
+corpcor,cov.shrink,1,0,0,any,1
+corpcor,cov.shrink,2,0,0,any,1
+corpcor,cov.shrink,3,0,0,any,1
+corpcor,cov.shrink,4,0,0,logical,1
+corpcor,crossprod.powcor.shrink,-1,0,0,class<`shrinkage`>,1
+corpcor,crossprod.powcor.shrink,0,0,0,class<`matrix`>,1
+corpcor,crossprod.powcor.shrink,1,0,0,double[],1
+corpcor,crossprod.powcor.shrink,2,0,0,double,1
+corpcor,crossprod.powcor.shrink,3,0,0,double,1
+corpcor,crossprod.powcor.shrink,4,0,0,any,1
+corpcor,crossprod.powcor.shrink,5,0,0,logical,1
+corpcor,decompose.cov,-1,0,0,list<class<`matrix`> | double[]>,1
+corpcor,decompose.cov,0,0,0,class<`matrix`>,1
+corpcor,decompose.invcov,-1,0,0,list<class<`matrix`> | double[]>,1
+corpcor,decompose.invcov,0,0,0,class<`matrix`>,1
+corpcor,estimate.lambda,-1,0,0,double,1
+corpcor,estimate.lambda,0,0,0,class<`matrix`>,1
+corpcor,estimate.lambda,1,0,0,any,1
+corpcor,estimate.lambda,2,0,0,logical,1
+corpcor,estimate.lambda.var,-1,0,0,double,1
+corpcor,estimate.lambda.var,0,0,0,class<`matrix`>,1
+corpcor,estimate.lambda.var,1,0,0,any,1
+corpcor,estimate.lambda.var,2,0,0,logical,1
+corpcor,fast.svd,-1,0,0,list<double[] | class<`matrix`>>,1
+corpcor,fast.svd,-1,0,1,list<double | class<`matrix`>>,1
+corpcor,fast.svd,0,0,0,class<`matrix`>,1
+corpcor,fast.svd,0,0,1,class<`shrinkage`>,1
+corpcor,fast.svd,1,0,0,any,1
+corpcor,invcor.shrink,-1,0,0,class<`shrinkage`>,1
+corpcor,invcor.shrink,0,0,0,class<`matrix`>,1
+corpcor,invcor.shrink,1,0,0,any,1
+corpcor,invcor.shrink,2,0,0,any,1
+corpcor,invcor.shrink,3,0,0,logical,1
+corpcor,invcov.shrink,-1,0,0,class<`shrinkage`>,1
+corpcor,invcov.shrink,0,0,0,class<`matrix`>,1
+corpcor,invcov.shrink,1,0,0,any,1
+corpcor,invcov.shrink,2,0,0,any,1
+corpcor,invcov.shrink,3,0,0,any,1
+corpcor,invcov.shrink,4,0,0,logical,1
+corpcor,is.positive.definite,-1,0,0,logical,1
+corpcor,is.positive.definite,0,0,0,class<`matrix`>,1
+corpcor,is.positive.definite,0,0,1,class<`shrinkage`>,1
+corpcor,is.positive.definite,1,0,0,any,1
+corpcor,is.positive.definite,2,0,0,character[],1
+corpcor,make.positive.definite,-1,0,0,class<`matrix`>,1
+corpcor,make.positive.definite,0,0,0,class<`matrix`>,1
+corpcor,make.positive.definite,1,0,0,any,1
+corpcor,mpower,-1,0,0,class<`matrix`>,1
+corpcor,mpower,0,0,0,class<`matrix`>,1
+corpcor,mpower,0,0,1,class<`shrinkage`>,1
+corpcor,mpower,1,0,0,double,1
+corpcor,mpower,2,0,0,logical,1
+corpcor,mpower,3,0,0,any,1
+corpcor,nsmall.svd,-1,0,0,list<double[] | class<`matrix`>>,1
+corpcor,nsmall.svd,0,0,0,class<`matrix`>,1
+corpcor,nsmall.svd,1,0,0,any,1
+corpcor,pcor2cor,-1,0,0,class<`matrix`>,1
+corpcor,pcor2cor,0,0,0,class<`matrix`>,1
+corpcor,pcor2cor,1,0,0,any,1
+corpcor,pcor.shrink,-1,0,0,class<`shrinkage`>,1
+corpcor,pcor.shrink,0,0,0,class<`matrix`>,1
+corpcor,pcor.shrink,1,0,0,any,1
+corpcor,pcor.shrink,2,0,0,any,1
+corpcor,pcor.shrink,3,0,0,logical,1
+corpcor,positive.svd,-1,0,0,list<double[] | class<`matrix`>>,1
+corpcor,positive.svd,-1,0,1,list<double | class<`matrix`>>,1
+corpcor,positive.svd,0,0,0,class<`matrix`>,1
+corpcor,positive.svd,0,0,1,class<`shrinkage`>,1
+corpcor,positive.svd,1,0,0,any,1
+corpcor,powcor.shrink,-1,0,0,class<`shrinkage`>,1
+corpcor,powcor.shrink,0,0,0,class<`matrix`>,1
+corpcor,powcor.shrink,1,0,0,double,1
+corpcor,powcor.shrink,2,0,0,any,1
+corpcor,powcor.shrink,3,0,0,any,1
+corpcor,powcor.shrink,4,0,0,logical,1
+corpcor,pseudoinverse,-1,0,0,class<`matrix`>,1
+corpcor,pseudoinverse,0,0,0,class<`matrix`>,1
+corpcor,pseudoinverse,0,0,1,class<`shrinkage`>,1
+corpcor,pseudoinverse,1,0,0,any,1
+corpcor,pvar.shrink,-1,0,0,double[],1
+corpcor,pvar.shrink,0,0,0,class<`matrix`>,1
+corpcor,pvar.shrink,1,0,0,any,1
+corpcor,pvar.shrink,2,0,0,any,1
+corpcor,pvar.shrink,3,0,0,any,1
+corpcor,pvar.shrink,4,0,0,logical,1
+corpcor,pvt.check.w,-1,0,0,double[],1
+corpcor,pvt.check.w,0,0,0,any,1
+corpcor,pvt.check.w,1,0,0,integer,1
+corpcor,pvt.cppowscor,-1,0,0,class<`shrinkage`>,1
+corpcor,pvt.cppowscor,0,0,0,class<`matrix`>,1
+corpcor,pvt.cppowscor,1,0,0,class<`matrix`>,1
+corpcor,pvt.cppowscor,2,0,0,double,1
+corpcor,pvt.cppowscor,3,0,0,double,1
+corpcor,pvt.cppowscor,4,0,0,any,1
+corpcor,pvt.cppowscor,5,0,0,logical,1
+corpcor,pvt.powscor,-1,0,0,class<`shrinkage`>,1
+corpcor,pvt.powscor,0,0,0,class<`matrix`>,1
+corpcor,pvt.powscor,1,0,0,double,1
+corpcor,pvt.powscor,2,0,0,any,1
+corpcor,pvt.powscor,3,0,0,any,1
+corpcor,pvt.powscor,4,0,0,logical,1
+corpcor,pvt.svar,-1,0,0,class<`shrinkage`>,1
+corpcor,pvt.svar,0,0,0,class<`matrix`>,1
+corpcor,pvt.svar,1,0,0,any,1
+corpcor,pvt.svar,2,0,0,any,1
+corpcor,pvt.svar,3,0,0,logical,1
+corpcor,rank.condition,-1,0,0,list<double>,1
+corpcor,rank.condition,0,0,0,class<`matrix`>,1
+corpcor,rank.condition,0,0,1,class<`shrinkage`>,1
+corpcor,rank.condition,1,0,0,any,1
+corpcor,rebuild.cov,-1,0,0,class<`matrix`>,1
+corpcor,rebuild.cov,0,0,0,class<`matrix`>,1
+corpcor,rebuild.cov,1,0,0,double[],1
+corpcor,rebuild.invcov,-1,0,0,class<`matrix`>,1
+corpcor,rebuild.invcov,0,0,0,class<`matrix`>,1
+corpcor,rebuild.invcov,1,0,0,double[],1
+corpcor,sm2vec,-1,0,0,double[],1
+corpcor,sm2vec,0,0,0,class<`matrix`>,1
+corpcor,sm2vec,1,0,0,logical,1
+corpcor,sm.index,-1,0,0,class<`matrix`>,1
+corpcor,sm.index,0,0,0,class<`matrix`>,1
+corpcor,sm.index,1,0,0,logical,1
+corpcor,var.shrink,-1,0,0,class<`shrinkage`>,1
+corpcor,var.shrink,0,0,0,class<`matrix`>,1
+corpcor,var.shrink,1,0,0,any,1
+corpcor,var.shrink,2,0,0,any,1
+corpcor,var.shrink,3,0,0,logical,1
+corpcor,vec2sm,-1,0,0,class<`matrix`>,1
+corpcor,vec2sm,0,0,0,double[],1
+corpcor,vec2sm,1,0,0,logical,1
+corpcor,vec2sm,2,0,0,integer[],1
+corpcor,vec2sm,2,0,1,null,1
+corpcor,wt.moments,-1,0,0,list<double[]>,1
+corpcor,wt.moments,0,0,0,class<`matrix`>,1
+corpcor,wt.moments,1,0,0,any,1
+corpcor,wt.scale,-1,0,0,class<`matrix`>,1
+corpcor,wt.scale,0,0,0,class<`matrix`>,1
+corpcor,wt.scale,1,0,0,any,1
+corpcor,wt.scale,2,0,0,logical,1
+corpcor,wt.scale,3,0,0,logical,1
+corrplot,colorlegend,-1,0,0,null,1
+corrplot,colorlegend,0,0,0,character[],1
+corrplot,colorlegend,1,0,0,character[],1
+corrplot,colorlegend,1,0,1,double[],1
+corrplot,colorlegend,2,0,0,double[],1
+corrplot,colorlegend,2,0,1,null,1
+corrplot,colorlegend,3,0,0,double[],1
+corrplot,colorlegend,4,0,0,double[],1
+corrplot,colorlegend,5,0,0,logical,1
+corrplot,colorlegend,6,0,0,double,1
+corrplot,colorlegend,7,0,0,character,1
+corrplot,colorlegend,7,0,1,double[],1
+corrplot,colorlegend,8,0,0,character[],1
+corrplot,colorlegend,9,0,0,logical,1
+corrplot,colorlegend,10,0,0,...,1
+corrplot,cor.mtest,-1,0,0,list<class<`matrix`>>,1
+corrplot,cor.mtest,0,0,0,class<`data.frame`>,1
+corrplot,cor.mtest,1,0,0,...,1
+corrplot,corrMatOrder,-1,0,0,character[],1
+corrplot,corrMatOrder,-1,0,1,integer[],1
+corrplot,corrMatOrder,0,0,0,class<`matrix`>,1
+corrplot,corrMatOrder,1,0,0,character,1
+corrplot,corrMatOrder,2,0,0,character[],1
+corrplot,corrplot,-1,0,0,class<`matrix`>,1
+corrplot,corrplot,0,0,0,class<`matrix`>,1
+corrplot,corrplot,1,0,0,character[],1
+corrplot,corrplot,2,0,0,character[],1
+corrplot,corrplot,3,0,0,logical,1
+corrplot,corrplot,4,0,0,null,1
+corrplot,corrplot,4,0,1,character[],1
+corrplot,corrplot,5,0,0,character,1
+corrplot,corrplot,6,0,0,character,1
+corrplot,corrplot,6,0,1,class<`call`>,1
+corrplot,corrplot,7,0,0,logical,1
+corrplot,corrplot,8,0,0,logical,1
+corrplot,corrplot,9,0,0,logical,1
+corrplot,corrplot,10,0,0,double[],1
+corrplot,corrplot,11,0,0,null,1
+corrplot,corrplot,11,0,1,character,1
+corrplot,corrplot,12,0,0,null,1
+corrplot,corrplot,12,0,1,character,1
+corrplot,corrplot,13,0,0,logical,1
+corrplot,corrplot,14,0,0,character[],1
+corrplot,corrplot,15,0,0,character[],1
+corrplot,corrplot.mixed,-1,0,0,class<`matrix`>,1
+corrplot,corrplot.mixed,0,0,0,class<`matrix`>,1
+corrplot,corrplot.mixed,1,0,0,character,1
+corrplot,corrplot.mixed,2,0,0,character,1
+corrplot,corrplot.mixed,3,0,0,character[],1
+corrplot,corrplot.mixed,4,0,0,character[],1
+corrplot,corrplot.mixed,5,0,0,character,1
+corrplot,corrplot.mixed,6,0,0,character,1
+corrplot,corrplot.mixed,7,0,0,character,1
+corrplot,corrplot.mixed,7,0,1,null,1
+corrplot,corrplot.mixed,8,0,0,null,1
+corrplot,corrplot.mixed,9,0,0,character[],1
+corrplot,corrplot.mixed,10,0,0,double[],1
+corrplot,corrplot.mixed,11,0,0,...,1
+corrplot,corrRect,-1,0,0,null,1
+corrplot,corrRect,0,0,0,double[],1
+corrplot,corrRect,1,0,0,character,1
+corrplot,corrRect,2,0,0,double,1
+corrplot,corrRect.hclust,-1,0,0,null,1
+corrplot,corrRect.hclust,0,0,0,class<`matrix`>,1
+corrplot,corrRect.hclust,1,0,0,double,1
+corrplot,corrRect.hclust,2,0,0,character,1
+corrplot,corrRect.hclust,3,0,0,double,1
+corrplot,corrRect.hclust,4,0,0,character[],1
+corrplot,draw_grid,-1,0,0,null,1
+corrplot,draw_grid,0,0,0,class<`matrix`>,1
+corrplot,draw_grid,1,0,0,character,1
+corrplot,draw_grid,1,0,1,null,1
+corrplot,draw_method_color,-1,0,0,null,1
+corrplot,draw_method_color,0,0,0,class<`matrix`>,1
+corrplot,draw_method_color,1,0,0,character[],1
+corrplot,draw_method_color,2,0,0,character[],1
+corrplot,draw_method_square,-1,0,0,null,1
+corrplot,draw_method_square,0,0,0,class<`matrix`>,1
+corrplot,draw_method_square,1,0,0,double[],1
+corrplot,draw_method_square,2,0,0,double,1
+corrplot,draw_method_square,3,0,0,character[],1
+corrplot,draw_method_square,4,0,0,character[],1
+corrplot,reorder_using_aoe,-1,0,0,integer[],1
+corrplot,reorder_using_aoe,0,0,0,class<`matrix`>,1
+corrplot,reorder_using_fpc,-1,0,0,integer[],1
+corrplot,reorder_using_fpc,0,0,0,class<`matrix`>,1
+corrplot,reorder_using_hclust,-1,0,0,integer[],1
+corrplot,reorder_using_hclust,0,0,0,class<`matrix`>,1
+corrplot,reorder_using_hclust,1,0,0,character,1
+countrycode,countrycode,-1,0,0,character,1
+countrycode,countrycode,-1,0,1,integer[],1
+countrycode,countrycode,0,0,0,character[],1
+countrycode,countrycode,1,0,0,character,1
+countrycode,countrycode,2,0,0,character,1
+countrycode,countrycode,3,0,0,logical,1
+countrycode,countrycode,4,0,0,null,1
+countrycode,countrycode,5,0,0,null,1
+countrycode,countrycode,6,0,0,null,1
+countrycode,countrycode,7,0,0,logical,1
+coxme,coxme,-1,0,0,class<`coxme`>,1
+coxme,coxme,0,0,0,class<`formula`>,1
+coxme,coxme,1,0,0,any,1
+coxme,coxme,2,0,0,any,1
+coxme,coxme,3,0,0,any,1
+coxme,coxme,4,0,0,any,1
+coxme,coxme,5,0,0,any,1
+coxme,coxme,6,0,0,any,1
+coxme,coxme,7,0,0,character[],1
+coxme,coxme.control,-1,0,0,list<any>,1
+coxme,coxme.control,0,0,0,double,1
+coxme,coxme.control,1,0,0,double,1
+coxme,coxme.control,2,0,0,double,1
+coxme,coxme.control,3,0,0,class<`call`>,1
+coxme,coxme.control,4,0,0,double,1
+coxme,coxme.control,4,0,1,null,1
+coxme,coxme.control,5,0,0,list<character | list<double>>,1
+coxme,coxme.control,6,0,0,double,1
+coxme,coxme.control,7,0,0,logical,1
+coxme,coxme.fit,-1,0,0,list<any>,1
+coxme,coxme.fit,0,0,0,class<`matrix`>,1
+coxme,coxme.fit,1,0,0,class<`Surv`>,1
+coxme,coxme.fit,2,0,0,null,1
+coxme,coxme.fit,2,0,1,double[],1
+coxme,coxme.fit,3,0,0,double[],1
+coxme,coxme.fit,4,0,0,null,1
+coxme,coxme.fit,4,0,1,double[],1
+coxme,coxme.fit,5,0,0,list<any>,1
+coxme,coxme.fit,6,0,0,double[],1
+coxme,coxme.fit,7,0,0,character,1
+coxme,coxmeFull,-1,0,0,class<`coxmevar`>,1
+coxme,coxmeFull,0,0,0,logical,1
+coxme,coxmeMlist,-1,0,0,class<`coxmevar`>,1
+coxme,coxmeMlist,0,0,0,class<`dsCMatrix`>,1
+coxme,coxmeMlist,0,0,1,class<`matrix`>,1
+coxme,coxmeMlist,0,0,2,list<class<`bdsmatrix`> | class<`matrix`>>,1
+coxme,coxmeMlist,0,0,3,list<class<`bdsmatrix`>>,1
+coxme,coxmeMlist,0,0,4,list<class<`matrix`> | class<`bdsmatrix`>>,1
+coxme,coxmeMlist,0,0,5,list<class<`matrix`>>,1
+coxme,coxmeMlist,1,0,0,logical,1
+coxme,coxmeMlist,2,0,0,logical,1
+coxme,coxmeMlist,3,0,0,logical,1
+coxme,expand.nested,-1,0,0,class<`data.frame`>,1
+coxme,expand.nested,0,0,0,class<`data.frame`>,1
+coxme,findIntercept,-1,0,0,logical,1
+coxme,findIntercept,0,0,0,class<`call`>,1
+coxme,findIntercept,0,0,1,class<`name`>,1
+coxme,findIntercept,0,0,2,double,1
+coxme,fixef.coxme,-1,0,0,double[],1
+coxme,fixef.coxme,0,0,0,class<`coxme`>,1
+coxme,fixef.coxme,1,0,0,...,1
+coxme,fixef.lmekin,-1,0,0,double[],1
+coxme,fixef.lmekin,0,0,0,class<`lmekin`>,1
+coxme,fixef.lmekin,1,0,0,...,1
+coxme,formula1,-1,0,0,list<class<`call`>>,1
+coxme,formula1,-1,0,1,list<class<`call`> | list<class<`(`>>>,1
+coxme,formula1,-1,0,2,list<class<`call`> | null>,1
+coxme,formula1,-1,0,3,list<class<`formula`> | list<class<`(`>>>,1
+coxme,formula1,-1,0,4,list<class<`name`>>,1
+coxme,formula1,-1,0,5,list<class<`name`> | list<class<`(`>>>,1
+coxme,formula1,-1,0,6,list<list<class<`(`>>>,1
+coxme,formula1,0,0,0,class<`call`>,1
+coxme,formula1,0,0,1,class<`formula`>,1
+coxme,formula1,0,0,2,class<`name`>,1
+coxme,formula1,0,0,3,class<`(`>,1
+coxme,formula2,-1,0,0,list<class<`call`> | double>,1
+coxme,formula2,-1,0,1,list<logical | class<`name`> | class<`call`>>,1
+coxme,formula2,-1,0,2,list<logical | class<`name`>>,1
+coxme,formula2,-1,0,3,list<class<`name`> | double>,1
+coxme,formula2,-1,0,4,list<double | class<`call`>>,1
+coxme,formula2,-1,0,5,list<double | class<`name`>>,1
+coxme,formula2,0,0,0,class<`(`>,1
+coxme,getblock,-1,0,0,class<`dsCMatrix`>,1
+coxme,getblock,-1,0,1,double,1
+coxme,getblock,0,0,0,class<`dsCMatrix`>,1
+coxme,getblock,1,0,0,integer,1
+coxme,getblock,2,0,0,double,1
+coxme,hasAbar,-1,0,0,logical,1
+coxme,hasAbar,0,0,0,class<`formula`>,1
+coxme,lmekin,-1,0,0,class<`lmekin`>,1
+coxme,lmekin,0,0,0,class<`formula`>,1
+coxme,lmekin,1,0,0,any,1
+coxme,lmekin,2,0,0,any,1
+coxme,lmekin,3,0,0,any,1
+coxme,lmekin,4,0,0,any,1
+coxme,lmekin,5,0,0,any,1
+coxme,lmekin,6,0,0,any,1
+coxme,lmekin,7,0,0,any,1
+coxme,lmekin.control,-1,0,0,list<double[] | list<character | list<double>>>,1
+coxme,lmekin.control,0,0,0,list<character | list<double>>,1
+coxme,lmekin.control,1,0,0,double[],1
+coxme,lmekin.control,2,0,0,double[],1
+coxme,print.coxme,-1,0,0,class<`coxme`>,1
+coxme,print.coxme,0,0,0,class<`coxme`>,1
+coxme,print.coxme,1,0,0,logical,1
+coxme,print.coxme,2,0,0,double,1
+coxme,print.coxme,3,0,0,...,1
+coxme,print.lmekin,-1,0,0,class<`lmekin`>,1
+coxme,print.lmekin,0,0,0,class<`lmekin`>,1
+coxme,print.lmekin,1,0,0,...,1
+coxme,ranef.coxme,-1,0,0,list<double[]>,1
+coxme,ranef.coxme,-1,0,1,list<class<`matrix`>>,1
+coxme,ranef.coxme,-1,0,2,list<double[] | class<`matrix`>>,1
+coxme,ranef.coxme,0,0,0,class<`coxme`>,1
+coxme,ranef.coxme,1,0,0,...,1
+coxme,ranef.lmekin,-1,0,0,list<double[]>,1
+coxme,ranef.lmekin,0,0,0,class<`lmekin`>,1
+coxme,ranef.lmekin,1,0,0,...,1
+coxme,residuals.lmekin,-1,0,0,double[],1
+coxme,residuals.lmekin,0,0,0,class<`lmekin`>,1
+coxme,residuals.lmekin,1,0,0,...,1
+coxme,subbar,-1,0,0,class<`(`>,1
+coxme,subbar,-1,0,1,class<`call`>,1
+coxme,subbar,-1,0,2,class<`formula`>,1
+coxme,subbar,-1,0,3,class<`name`>,1
+coxme,subbar,0,0,0,class<`(`>,1
+coxme,subbar,0,0,1,class<`call`>,1
+coxme,subbar,0,0,2,class<`formula`>,1
+coxme,subbar,0,0,3,class<`name`>,1
+coxme,VarCorr.coxme,-1,0,0,list<class<`matrix`>>,1
+coxme,VarCorr.coxme,-1,0,1,list<double[]>,1
+coxme,VarCorr.coxme,0,0,0,class<`coxme`>,1
+coxme,VarCorr.coxme,0,0,1,class<`lmekin`>,1
+coxme,VarCorr.coxme,1,0,0,...,1
+coxme,VarCorr.lmekin,-1,0,0,list<class<`matrix`>>,1
+coxme,VarCorr.lmekin,-1,0,1,list<double[]>,1
+coxme,VarCorr.lmekin,0,0,0,class<`coxme`>,1
+coxme,VarCorr.lmekin,0,0,1,class<`lmekin`>,1
+coxme,VarCorr.lmekin,1,0,0,...,1
+coxme,vcov.coxme,-1,0,0,class<`matrix`>,1
+coxme,vcov.coxme,0,0,0,class<`coxme`>,1
+coxme,vcov.coxme,1,0,0,...,1
+crayon,%+%,-1,0,0,character[],1
+crayon,%+%,0,0,0,character[],1
+crayon,%+%,1,0,0,character[],1
+crayon,blue,-1,0,0,character,1
+crayon,blue,0,0,0,...,1
+crayon,bold,-1,0,0,character,1
+crayon,bold,0,0,0,...,1
+crayon,chr,-1,0,0,character[],1
+crayon,chr,0,0,0,integer[],1
+crayon,chr,1,0,0,...,1
+crayon,col_align,-1,0,0,character,1
+crayon,col_align,0,0,0,character,1
+crayon,col_align,1,0,0,double,1
+crayon,col_align,2,0,0,character,1
+crayon,col_align,3,0,0,character,1
+crayon,col_nchar,-1,0,0,integer,1
+crayon,col_nchar,0,0,0,character,1
+crayon,col_nchar,1,0,0,...,1
+crayon,col_strsplit,-1,0,0,list<character[]>,1
+crayon,col_strsplit,0,0,0,character,1
+crayon,col_strsplit,1,0,0,character,1
+crayon,col_strsplit,2,0,0,...,1
+crayon,col_substr,-1,0,0,character[],1
+crayon,col_substr,0,0,0,character[],1
+crayon,col_substr,1,0,0,double[],1
+crayon,col_substr,2,0,0,double[],1
+crayon,col_substring,-1,0,0,character[],1
+crayon,col_substring,0,0,0,character,1
+crayon,col_substring,1,0,0,double[],1
+crayon,col_substring,2,0,0,double[],1
+crayon,combine_styles,-1,0,0,class<`crayon`>,1
+crayon,combine_styles,0,0,0,...,1
+crayon,$.crayon,-1,0,0,class<`crayon`>,1
+crayon,$.crayon,0,0,0,class<`crayon`>,1
+crayon,$.crayon,1,0,0,character,1
+crayon,define_style,-1,0,0,list<character>,1
+crayon,define_style,0,0,0,character,1
+crayon,define_style,1,0,0,list<character>,1
+crayon,drop_style,-1,0,0,null,1
+crayon,drop_style,0,0,0,character,1
+crayon,finish,-1,0,0,character,1
+crayon,finish,0,0,0,class<`crayon`>,1
+crayon,finish,1,0,0,...,1
+crayon,finish.crayon,-1,0,0,character,1
+crayon,finish.crayon,0,0,0,class<`crayon`>,1
+crayon,finish.crayon,1,0,0,...,1
+crayon,green,-1,0,0,character,1
+crayon,green,0,0,0,...,1
+crayon,has_color,-1,0,0,logical,1
+crayon,has_style,-1,0,0,logical,1
+crayon,has_style,0,0,0,character,1
+crayon,i_num_colors,-1,0,0,double,1
+crayon,is_builtin_style,-1,0,0,logical,1
+crayon,is_builtin_style,0,0,0,character,1
+crayon,is_r_color,-1,0,0,logical,1
+crayon,is_r_color,0,0,0,character,1
+crayon,is_string,-1,0,0,logical,1
+crayon,is_string,0,0,0,character,1
+crayon,make_crayon,-1,0,0,class<`crayon`>,1
+crayon,make_crayon,0,0,0,list<list<character>>,1
+crayon,make_space,-1,0,0,character,1
+crayon,make_space,0,0,0,double,1
+crayon,make_space,1,0,0,character,1
+crayon,make_style,-1,0,0,class<`crayon`>,1
+crayon,make_style,0,0,0,...,1
+crayon,make_style,1,0,0,logical,1
+crayon,make_style,2,0,0,logical,1
+crayon,make_style,3,0,0,double,1
+crayon,map_to_ansi,-1,0,0,class<`function`>,1
+crayon,map_to_ansi,0,0,0,any,1
+crayon,map_to_ansi,1,0,0,list<class<`matrix`>>,1
+crayon,mypaste,-1,0,0,character,1
+crayon,mypaste,0,0,0,...,1
+crayon,mypaste,1,0,0,character,1
+crayon,non_matching,-1,0,0,list<class<`matrix`>>,1
+crayon,non_matching,0,0,0,list<class<`matrix`>>,1
+crayon,non_matching,1,0,0,character[],1
+crayon,non_matching,2,0,0,logical,1
+crayon,num_colors,-1,0,0,double,1
+crayon,num_colors,0,0,0,logical,1
+crayon,red,-1,0,0,character,1
+crayon,red,0,0,0,...,1
+crayon,re_table,-1,0,0,list<class<`matrix`>>,1
+crayon,re_table,0,0,0,...,1
+crayon,rstudio_initialized,-1,0,0,logical,1
+crayon,rstudio_with_ansi_support,-1,0,0,logical,1
+crayon,start.crayon,-1,0,0,character,1
+crayon,start.crayon,0,0,0,class<`crayon`>,1
+crayon,start.crayon,1,0,0,...,1
+crayon,strip_style,-1,0,0,character[],1
+crayon,strip_style,0,0,0,character[],1
+crayon,strrep,-1,0,0,character,1
+crayon,strrep,0,0,0,character,1
+crayon,strrep,1,0,0,double,1
+crayon,style,-1,0,0,character,1
+crayon,style,0,0,0,character,1
+crayon,style,1,0,0,character,1
+crayon,style,1,0,1,class<`crayon`>,1
+crayon,style,2,0,0,character,1
+crayon,style,2,0,1,null,1
+crayon,style_8_from_rgb,-1,0,0,list<character>,1
+crayon,style_8_from_rgb,0,0,0,class<`matrix`>,1
+crayon,style_8_from_rgb,1,0,0,logical,1
+crayon,style_from_r_color,-1,0,0,list<character>,1
+crayon,style_from_r_color,0,0,0,character,1
+crayon,style_from_r_color,1,0,0,logical,1
+crayon,style_from_r_color,2,0,0,double,1
+crayon,style_from_r_color,3,0,0,any,1
+crayon,style_from_rgb,-1,0,0,list<character>,1
+crayon,style_from_rgb,0,0,0,class<`matrix`>,1
+crayon,style_from_rgb,1,0,0,logical,1
+crayon,style_from_rgb,2,0,0,double,1
+crayon,style_from_rgb,3,0,0,any,1
+crayon,styles,-1,0,0,list<list<character>>,1
+crayon,underline,-1,0,0,character,1
+crayon,underline,0,0,0,...,1
+crayon,use_or_make_style,-1,0,0,class<`crayon`>,1
+crayon,use_or_make_style,0,0,0,null,1
+crayon,use_or_make_style,0,0,1,character,1
+crayon,use_or_make_style,0,0,2,class<`crayon`>,1
+crayon,use_or_make_style,1,0,0,logical,1
+curl,curl,-1,0,0,"class<`connection`, `curl`>",1
+curl,curl,0,0,0,character,1
+curl,curl,1,0,0,character,1
+curl,curl,2,0,0,class<`curl_handle`>,1
+curl,curl_connection,-1,0,0,"class<`connection`, `curl`>",1
+curl,curl_connection,0,0,0,character,1
+curl,curl_connection,1,0,0,character,1
+curl,curl_connection,2,0,0,class<`curl_handle`>,1
+curl,curl_connection,3,0,0,logical,1
+curl,curl_download,-1,0,0,character,1
+curl,curl_download,0,0,0,character,1
+curl,curl_download,1,0,0,character,1
+curl,curl_download,2,0,0,logical,1
+curl,curl_download,3,0,0,character,1
+curl,curl_download,4,0,0,class<`curl_handle`>,1
+curl,curl_echo,-1,0,0,list<raw[] | character[]>,1
+curl,curl_echo,0,0,0,class<`curl_handle`>,1
+curl,curl_echo,1,0,0,double,1
+curl,curl_echo,2,0,0,logical,1
+curl,curl_echo,3,0,0,null,1
+curl,curl_escape,-1,0,0,character,1
+curl,curl_escape,0,0,0,character,1
+curl,curl_fetch_disk,-1,0,0,list<any>,1
+curl,curl_fetch_disk,0,0,0,character,1
+curl,curl_fetch_disk,1,0,0,character,1
+curl,curl_fetch_disk,2,0,0,class<`curl_handle`>,1
+curl,curl_fetch_memory,-1,0,0,list<any>,1
+curl,curl_fetch_memory,0,0,0,character,1
+curl,curl_fetch_memory,1,0,0,class<`curl_handle`>,1
+curl,curl_fetch_multi,-1,0,0,class<`curl_handle`>,1
+curl,curl_fetch_multi,0,0,0,character,1
+curl,curl_fetch_multi,1,0,0,class<`function`>,1
+curl,curl_fetch_multi,2,0,0,class<`function`>,1
+curl,curl_fetch_multi,2,0,1,null,1
+curl,curl_fetch_multi,3,0,0,null,1
+curl,curl_fetch_multi,3,0,1,class<`curl_multi`>,1
+curl,curl_fetch_multi,4,0,0,null,1
+curl,curl_fetch_multi,5,0,0,class<`curl_handle`>,1
+curl,curl_fetch_stream,-1,0,0,list<any>,1
+curl,curl_fetch_stream,0,0,0,character,1
+curl,curl_fetch_stream,1,0,0,class<`function`>,1
+curl,curl_fetch_stream,2,0,0,class<`curl_handle`>,1
+curl,curl_options,-1,0,0,double[],1
+curl,curl_options,0,0,0,character,1
+curl,curl_symbols,-1,0,0,class<`data.frame`>,1
+curl,curl_symbols,0,0,0,character,1
+curl,curl_unescape,-1,0,0,character,1
+curl,curl_unescape,0,0,0,character,1
+curl,curl_upload,-1,0,0,any,1
+curl,curl_upload,0,0,0,character,1
+curl,curl_upload,1,0,0,character,1
+curl,curl_upload,2,0,0,logical,1
+curl,curl_upload,3,0,0,logical,1
+curl,curl_upload,4,0,0,...,1
+curl,curl_version,-1,0,0,list<null | character[] | logical>,1
+curl,file_writer,-1,0,0,class<`file_writer`>,1
+curl,file_writer,0,0,0,character,1
+curl,fix_options,-1,0,0,character[],1
+curl,fix_options,0,0,0,character[],1
+curl,form_file,-1,0,0,class<`form_file`>,1
+curl,form_file,0,0,0,character,1
+curl,form_file,1,0,0,character,1
+curl,handle_cookies,-1,0,0,class<`data.frame`>,1
+curl,handle_cookies,0,0,0,class<`curl_handle`>,1
+curl,handle_data,-1,0,0,list<any>,1
+curl,handle_data,0,0,0,class<`curl_handle`>,1
+curl,handle_getheaders,-1,0,0,character[],1
+curl,handle_getheaders,0,0,0,class<`curl_handle`>,1
+curl,handle_reset,-1,0,0,class<`curl_handle`>,1
+curl,handle_reset,0,0,0,class<`curl_handle`>,1
+curl,handle_setform,-1,0,0,class<`curl_handle`>,1
+curl,handle_setform,0,0,0,class<`curl_handle`>,1
+curl,handle_setform,1,0,0,...,1
+curl,handle_setform,2,0,0,list<any>,1
+curl,handle_setopt,-1,0,0,class<`curl_handle`>,1
+curl,handle_setopt,0,0,0,class<`curl_handle`>,1
+curl,handle_setopt,1,0,0,...,1
+curl,handle_setopt,2,0,0,list<any>,1
+curl,is_string,-1,0,0,logical,1
+curl,is_string,0,0,0,null,1
+curl,multi_add,-1,0,0,class<`curl_handle`>,1
+curl,multi_add,0,0,0,class<`curl_handle`>,1
+curl,multi_add,1,0,0,class<`function`>,1
+curl,multi_add,2,0,0,class<`function`>,1
+curl,multi_add,2,0,1,null,1
+curl,multi_add,3,0,0,"class<`connection`, `file`>",1
+curl,multi_add,3,0,1,null,1
+curl,multi_add,4,0,0,null,1
+curl,multi_add,4,0,1,class<`curl_multi`>,1
+curl,multi_default,-1,0,0,class<`curl_multi`>,1
+curl,multi_run,-1,0,0,list<integer>,1
+curl,multi_run,0,0,0,double,1
+curl,multi_run,1,0,0,logical,1
+curl,multi_run,2,0,0,class<`curl_multi`>,1
+curl,multi_run,2,0,1,null,1
+curl,multi_set,-1,0,0,class<`curl_multi`>,1
+curl,multi_set,0,0,0,double,1
+curl,multi_set,1,0,0,double,1
+curl,multi_set,2,0,0,logical,1
+curl,multi_set,3,0,0,class<`curl_multi`>,1
+curl,new_file_writer,-1,0,0,class<`file_writer`>,1
+curl,new_file_writer,0,0,0,character,1
+curl,new_handle,-1,0,0,class<`curl_handle`>,1
+curl,new_handle,0,0,0,...,1
+curl,new_pool,-1,0,0,class<`curl_multi`>,1
+curl,new_pool,0,0,0,double,1
+curl,new_pool,1,0,0,double,1
+curl,new_pool,2,0,0,logical,1
+curl,nslookup,-1,0,0,character,1
+curl,nslookup,0,0,0,character,1
+curl,nslookup,1,0,0,logical,1
+curl,nslookup,2,0,0,logical,1
+curl,nslookup,3,0,0,logical,1
+curl,parse_date,-1,0,0,"class<`POSIXct`, `POSIXt`>",1
+curl,parse_date,0,0,0,character,1
+curl,parse_headers,-1,0,0,character[],1
+curl,parse_headers,-1,0,1,list<character[]>,1
+curl,parse_headers,0,0,0,raw[],1
+curl,parse_headers,1,0,0,logical,1
+curl,parse_headers_list,-1,0,0,list<character>,1
+curl,parse_headers_list,0,0,0,raw[],1
+curl,replace_host,-1,0,0,character,1
+curl,replace_host,0,0,0,character,1
+curl,replace_host,1,0,0,character,1
+curl,write_file_writer,-1,0,0,integer,1
+curl,write_file_writer,0,0,0,class<`file_writer`>,1
+curl,write_file_writer,1,0,0,raw[],1
+curl,write_file_writer,2,0,0,logical,1
+data.tree,Aggregate,-1,0,0,double,1
+data.tree,Aggregate,0,0,0,"class<`Node`, `R6`>",1
+data.tree,Aggregate,1,0,0,character,1
+data.tree,Aggregate,1,0,1,class<`function`>,1
+data.tree,Aggregate,2,0,0,any,1
+data.tree,Aggregate,3,0,0,...,1
+data.tree,AreNamesUnique,-1,0,0,logical,1
+data.tree,AreNamesUnique,0,0,0,"class<`Node`, `R6`>",1
+data.tree,as.character.orderedSplit,-1,0,0,character,1
+data.tree,as.character.orderedSplit,0,0,0,class<`orderedSplit`>,1
+data.tree,as.character.orderedSplit,1,0,0,logical,1
+data.tree,as.character.orderedSplit,2,0,0,...,1
+data.tree,as.data.frame.Node,-1,0,0,class<`data.frame`>,1
+data.tree,as.data.frame.Node,0,0,0,"class<`Node`, `R6`>",1
+data.tree,as.data.frame.Node,1,0,0,null,1
+data.tree,as.data.frame.Node,2,0,0,logical,1
+data.tree,as.data.frame.Node,3,0,0,...,1
+data.tree,as.data.frame.Node,4,0,0,character[],1
+data.tree,as.data.frame.Node,5,0,0,class<`function`>,1
+data.tree,as.data.frame.Node,5,0,1,null,1
+data.tree,as.data.frame.Node,6,0,0,null,1
+data.tree,as.data.frame.Node,6,0,1,class<`function`>,1
+data.tree,as.data.frame.Node,7,0,0,logical,1
+data.tree,as.dendrogram.Node,-1,0,0,class<`dendrogram`>,1
+data.tree,as.dendrogram.Node,0,0,0,"class<`Node`, `R6`>",1
+data.tree,as.dendrogram.Node,1,0,0,character,1
+data.tree,as.dendrogram.Node,1,0,1,class<`function`>,1
+data.tree,as.dendrogram.Node,2,0,0,logical,1
+data.tree,as.dendrogram.Node,3,0,0,...,1
+data.tree,as.igraph.Node,-1,0,0,class<`igraph`>,1
+data.tree,as.igraph.Node,0,0,0,"class<`Node`, `R6`>",1
+data.tree,as.igraph.Node,1,0,0,character[],1
+data.tree,as.igraph.Node,2,0,0,character[],1
+data.tree,as.igraph.Node,3,0,0,logical,1
+data.tree,as.igraph.Node,4,0,0,character[],1
+data.tree,as.igraph.Node,5,0,0,...,1
+data.tree,as.list.Node,-1,0,0,list<list<list<double>>>,1
+data.tree,as.list.Node,-1,0,1,list<double>,1
+data.tree,as.list.Node,-1,0,2,list<character | double>,1
+data.tree,as.list.Node,-1,0,3,list<character | list<list<character | double>>>,1
+data.tree,as.list.Node,-1,0,4,list<character | list<list<character | list<list<character | double>>>>>,1
+data.tree,as.list.Node,-1,0,5,list<character | list<character | list<character | double>>>,1
+data.tree,as.list.Node,-1,0,6,list<character | list<list<character | list<list<character | list<list<character | integer>>>>>>>,1
+data.tree,as.list.Node,-1,0,7,list<character | list<list<character | list<list<character | integer>>>>>,1
+data.tree,as.list.Node,-1,0,8,list<character | list<list<character | integer>>>,1
+data.tree,as.list.Node,-1,0,9,list<character | list<list<list<list<double>>>>>,1
+data.tree,as.list.Node,-1,0,10,list<character | integer>,1
+data.tree,as.list.Node,-1,0,11,list<character | list<character | double>>,1
+data.tree,as.list.Node,-1,0,12,list<list<double>>,1
+data.tree,as.list.Node,0,0,0,"class<`Node`, `R6`>",1
+data.tree,as.list.Node,1,0,0,character[],1
+data.tree,as.list.Node,2,0,0,any,1
+data.tree,as.list.Node,3,0,0,character,1
+data.tree,as.list.Node,4,0,0,any,1
+data.tree,as.list.Node,5,0,0,character,1
+data.tree,as.list.Node,6,0,0,null,1
+data.tree,as.list.Node,6,0,1,character,1
+data.tree,as.list.Node,7,0,0,any,1
+data.tree,as.Node,-1,0,0,"class<`Node`, `R6`>",1
+data.tree,as.Node,0,0,0,class<`BinaryTree`>,1
+data.tree,as.Node,0,0,1,class<`data.frame`>,1
+data.tree,as.Node,0,0,2,class<`dendrogram`>,1
+data.tree,as.Node,0,0,3,class<`party`>,1
+data.tree,as.Node,0,0,4,class<`phylo`>,1
+data.tree,as.Node,0,0,5,class<`rpart`>,1
+data.tree,as.Node,0,0,6,list<character | list<list<integer>>>,1
+data.tree,as.Node,1,0,0,...,1
+data.tree,as.Node.BinaryTree,-1,0,0,"class<`Node`, `R6`>",1
+data.tree,as.Node.BinaryTree,0,0,0,class<`BinaryTree`>,1
+data.tree,as.Node.BinaryTree,1,0,0,...,1
+data.tree,as.Node.data.frame,-1,0,0,"class<`Node`, `R6`>",1
+data.tree,as.Node.data.frame,0,0,0,class<`data.frame`>,1
+data.tree,as.Node.data.frame,1,0,0,...,1
+data.tree,as.Node.data.frame,2,0,0,character[],1
+data.tree,as.Node.data.frame,3,0,0,character,1
+data.tree,as.Node.data.frame,4,0,0,character,1
+data.tree,as.Node.data.frame,5,0,0,null,1
+data.tree,as.Node.data.frame,6,0,0,logical,1
+data.tree,as.Node.dendrogram,-1,0,0,"class<`Node`, `R6`>",1
+data.tree,as.Node.dendrogram,0,0,0,class<`dendrogram`>,1
+data.tree,as.Node.dendrogram,1,0,0,null,1
+data.tree,as.Node.dendrogram,1,0,1,character,1
+data.tree,as.Node.dendrogram,2,0,0,character,1
+data.tree,as.Node.dendrogram,3,0,0,character[],1
+data.tree,as.Node.dendrogram,4,0,0,...,1
+data.tree,as.Node.list,-1,0,0,"class<`Node`, `R6`>",1
+data.tree,as.Node.list,0,0,0,list<character>,1
+data.tree,as.Node.list,0,0,1,list<list<integer>>,1
+data.tree,as.Node.list,0,0,2,list<character | list<character>>,1
+data.tree,as.Node.list,0,0,3,list<character | list<list<character>>>,1
+data.tree,as.Node.list,0,0,4,list<integer>,1
+data.tree,as.Node.list,0,0,5,list<character | list<list<integer>>>,1
+data.tree,as.Node.list,1,0,0,character[],1
+data.tree,as.Node.list,2,0,0,character,1
+data.tree,as.Node.list,3,0,0,character,1
+data.tree,as.Node.list,4,0,0,any,1
+data.tree,as.Node.list,5,0,0,character[],1
+data.tree,as.Node.list,6,0,0,...,1
+data.tree,as.Node.party,-1,0,0,"class<`Node`, `R6`>",1
+data.tree,as.Node.party,0,0,0,class<`party`>,1
+data.tree,as.Node.party,1,0,0,...,1
+data.tree,as.Node.phylo,-1,0,0,"class<`Node`, `R6`>",1
+data.tree,as.Node.phylo,0,0,0,class<`phylo`>,1
+data.tree,as.Node.phylo,1,0,0,character,1
+data.tree,as.Node.phylo,2,0,0,logical,1
+data.tree,as.Node.phylo,3,0,0,logical,1
+data.tree,as.Node.phylo,4,0,0,...,1
+data.tree,as.Node.rpart,-1,0,0,"class<`Node`, `R6`>",1
+data.tree,as.Node.rpart,0,0,0,class<`rpart`>,1
+data.tree,as.Node.rpart,1,0,0,double,1
+data.tree,as.Node.rpart,2,0,0,logical,1
+data.tree,as.Node.rpart,3,0,0,...,1
+data.tree,as.phylo.Node,-1,0,0,class<`phylo`>,1
+data.tree,as.phylo.Node,0,0,0,"class<`Node`, `R6`>",1
+data.tree,as.phylo.Node,1,0,0,class<`function`>,1
+data.tree,as.phylo.Node,2,0,0,...,1
+data.tree,averageBranchingFactor,-1,0,0,double,1
+data.tree,averageBranchingFactor,0,0,0,"class<`Node`, `R6`>",1
+data.tree,changeName,-1,0,0,character,1
+data.tree,changeName,0,0,0,"class<`Node`, `R6`>",1
+data.tree,changeName,1,0,0,any,1
+data.tree,changeName,2,0,0,character,1
+data.tree,CheckNameReservedWord,-1,0,0,character,1
+data.tree,CheckNameReservedWord,0,0,0,character,1
+data.tree,CheckNameReservedWord,1,0,0,character[],1
+data.tree,CheckNameReservedWord,1,0,1,logical,1
+data.tree,Climb,-1,0,0,"class<`Node`, `R6`>",1
+data.tree,Climb,-1,0,1,null,1
+data.tree,Climb,0,0,0,"class<`Node`, `R6`>",1
+data.tree,Climb,1,0,0,...,1
+data.tree,Clone,-1,0,0,"class<`Node`, `R6`>",1
+data.tree,Clone,0,0,0,"class<`Node`, `R6`>",1
+data.tree,Clone,1,0,0,class<`function`>,1
+data.tree,Clone,1,0,1,null,1
+data.tree,Clone,2,0,0,logical,1
+data.tree,.Clone,-1,0,0,"class<`Node`, `R6`>",1
+data.tree,.Clone,0,0,0,"class<`Node`, `R6`>",1
+data.tree,.Clone,1,0,0,class<`function`>,1
+data.tree,.Clone,1,0,1,null,1
+data.tree,.Clone,2,0,0,logical,1
+data.tree,.Clone,3,0,0,logical,1
+data.tree,CreateNodeFromSplittingNode,-1,0,0,"class<`Node`, `R6`>",1
+data.tree,CreateNodeFromSplittingNode,0,0,0,class<`SplittingNode`>,1
+data.tree,CreateNodeFromSplittingNode,0,0,1,class<`TerminalNode`>,1
+data.tree,CreateNodeFromSplittingNode,1,0,0,logical,1
+data.tree,CreateRandomTree,-1,0,0,"class<`Node`, `R6`>",1
+data.tree,CreateRandomTree,-1,0,1,null,1
+data.tree,CreateRandomTree,0,0,0,double,1
+data.tree,CreateRandomTree,1,0,0,any,1
+data.tree,CreateRandomTree,2,0,0,any,1
+data.tree,CreateRegularTree,-1,0,0,"class<`Node`, `R6`>",1
+data.tree,CreateRegularTree,-1,0,1,null,1
+data.tree,CreateRegularTree,0,0,0,double,1
+data.tree,CreateRegularTree,1,0,0,any,1
+data.tree,CreateRegularTree,2,0,0,any,1
+data.tree,Cumulate,-1,0,0,double,1
+data.tree,Cumulate,0,0,0,"class<`Node`, `R6`>",1
+data.tree,Cumulate,1,0,0,character,1
+data.tree,Cumulate,2,0,0,any,1
+data.tree,Cumulate,3,0,0,...,1
+data.tree,DefaultPlotHeight,-1,0,0,double,1
+data.tree,DefaultPlotHeight,0,0,0,"class<`Node`, `R6`>",1
+data.tree,DefaultPlotHeight,1,0,0,double,1
+data.tree,Distance,-1,0,0,double,1
+data.tree,Distance,0,0,0,"class<`Node`, `R6`>",1
+data.tree,Distance,1,0,0,"class<`Node`, `R6`>",1
+data.tree,Do,-1,0,0,"list<class<`Node`, `R6`>>",1
+data.tree,Do,0,0,0,"list<class<`Node`, `R6`>>",1
+data.tree,Do,1,0,0,class<`function`>,1
+data.tree,Do,2,0,0,...,1
+data.tree,FindNode,-1,0,0,"class<`Node`, `R6`>",1
+data.tree,FindNode,0,0,0,"class<`Node`, `R6`>",1
+data.tree,FindNode,1,0,0,character,1
+data.tree,FindNode,1,0,1,double,1
+data.tree,FormatFixedDecimal,-1,0,0,character,1
+data.tree,FormatFixedDecimal,0,0,0,double,1
+data.tree,FormatFixedDecimal,0,0,1,null,1
+data.tree,FormatFixedDecimal,1,0,0,double,1
+data.tree,FormatPercent,-1,0,0,character,1
+data.tree,FormatPercent,0,0,0,integer,1
+data.tree,FormatPercent,1,0,0,double,1
+data.tree,FormatPercent,2,0,0,character,1
+data.tree,FormatPercent,3,0,0,...,1
+data.tree,FromDataFrameNetwork,-1,0,0,"class<`Node`, `R6`>",1
+data.tree,FromDataFrameNetwork,0,0,0,class<`data.frame`>,1
+data.tree,FromDataFrameNetwork,1,0,0,character[],1
+data.tree,FromDataFrameTable,-1,0,0,"class<`Node`, `R6`>",1
+data.tree,FromDataFrameTable,0,0,0,class<`data.frame`>,1
+data.tree,FromDataFrameTable,1,0,0,character,1
+data.tree,FromDataFrameTable,2,0,0,character,1
+data.tree,FromDataFrameTable,3,0,0,list<null | character[]>,1
+data.tree,FromDataFrameTable,3,0,1,null,1
+data.tree,FromDataFrameTable,4,0,0,logical,1
+data.tree,FromDataFrameTable,5,0,0,character[],1
+data.tree,FromListExplicit,-1,0,0,"class<`Node`, `R6`>",1
+data.tree,FromListExplicit,0,0,0,list<character | list<list<character>>>,1
+data.tree,FromListExplicit,1,0,0,character,1
+data.tree,FromListExplicit,2,0,0,character,1
+data.tree,FromListExplicit,3,0,0,null,1
+data.tree,FromListExplicit,4,0,0,character[],1
+data.tree,FromListSimple,-1,0,0,"class<`Node`, `R6`>",1
+data.tree,FromListSimple,0,0,0,list<character | list<character>>,1
+data.tree,FromListSimple,1,0,0,character,1
+data.tree,FromListSimple,2,0,0,null,1
+data.tree,FromListSimple,2,0,1,character,1
+data.tree,FromListSimple,3,0,0,character[],1
+data.tree,FromParty,-1,0,0,"class<`Node`, `R6`>",1
+data.tree,FromParty,0,0,0,class<`party`>,1
+data.tree,FromParty,1,0,0,class<`partynode`>,1
+data.tree,Get,-1,0,0,^character[],1
+data.tree,Get,-1,0,1,class<`matrix`>,1
+data.tree,Get,-1,0,2,^double[],1
+data.tree,Get,-1,0,3,list<double>,1
+data.tree,Get,-1,0,4,list<null | character>,1
+data.tree,Get,-1,0,5,list<null | integer>,1
+data.tree,Get,-1,0,6,list<null | list<character | class<`function`>>>,1
+data.tree,Get,-1,0,7,list<null | list<class<`function`> | character | character | double>>,1
+data.tree,Get,-1,0,8,list<character[]>,1
+data.tree,Get,-1,0,9,list<character | null>,1
+data.tree,Get,-1,0,10,list<integer[] | double>,1
+data.tree,Get,-1,0,11,list<null | double>,1
+data.tree,Get,-1,0,12,list<null>,1
+data.tree,Get,-1,0,13,list<null | list<character | double>>,1
+data.tree,Get,-1,0,14,list<null | list<class<`function`> | character>>,1
+data.tree,Get,-1,0,15,list<null | list<character | class<`function`> | character>>,1
+data.tree,Get,0,0,0,"list<class<`Node`, `R6`>>",1
+data.tree,Get,1,0,0,character,1
+data.tree,Get,1,0,1,class<`function`>,1
+data.tree,Get,2,0,0,...,1
+data.tree,Get,3,0,0,logical,1
+data.tree,Get,3,0,1,class<`function`>,1
+data.tree,Get,4,0,0,any,1
+data.tree,Get,5,0,0,character[],1
+data.tree,Get,5,0,1,logical,1
+data.tree,GetAttribute,-1,0,0,character[],1
+data.tree,GetAttribute,-1,0,1,double[],1
+data.tree,GetAttribute,-1,0,2,null,1
+data.tree,GetAttribute,-1,0,3,list<character | double>,1
+data.tree,GetAttribute,-1,0,4,list<character | class<`function`>>,1
+data.tree,GetAttribute,-1,0,5,list<character>,1
+data.tree,GetAttribute,-1,0,6,list<class<`function`>>,1
+data.tree,GetAttribute,-1,0,7,list<class<`function`> | character>,1
+data.tree,GetAttribute,0,0,0,"class<`Node`, `R6`>",1
+data.tree,GetAttribute,1,0,0,character,1
+data.tree,GetAttribute,1,0,1,class<`function`>,1
+data.tree,GetAttribute,2,0,0,...,1
+data.tree,GetAttribute,3,0,0,logical,1
+data.tree,GetAttribute,3,0,1,class<`function`>,1
+data.tree,GetAttribute,4,0,0,any,1
+data.tree,GetAttribute,5,0,0,logical,1
+data.tree,GetEdgeStyleFactory,-1,0,0,class<`function`>,1
+data.tree,GetEdgeStyleFactory,0,0,0,character,1
+data.tree,GetObjectAttribute,-1,0,0,null,1
+data.tree,GetObjectAttribute,-1,0,1,list<class<`function`>>,1
+data.tree,GetObjectAttribute,0,0,0,"class<`Node`, `R6`>",1
+data.tree,GetObjectAttribute,1,0,0,character,1
+data.tree,GetSplittingNodeLabel,-1,0,0,character,1
+data.tree,GetSplittingNodeLabel,0,0,0,class<`SplittingNode`>,1
+data.tree,GetSplittingNodeLabel,0,0,1,class<`TerminalNode`>,1
+data.tree,GetSplittingNodeLabel,1,0,0,any,1
+data.tree,GetStyle,-1,0,0,character,1
+data.tree,GetStyle,-1,0,1,double,1
+data.tree,GetStyle,-1,0,2,null,1
+data.tree,GetStyle,0,0,0,"class<`Node`, `R6`>",1
+data.tree,GetStyle,1,0,0,character,1
+data.tree,GetStyle,2,0,0,character,1
+data.tree,GetStyle,3,0,0,any,1
+data.tree,isLeaf,-1,0,0,logical,1
+data.tree,isLeaf,0,0,0,"class<`Node`, `R6`>",1
+data.tree,isRoot,-1,0,0,logical,1
+data.tree,isRoot,0,0,0,"class<`Node`, `R6`>",1
+data.tree,Navigate,-1,0,0,"class<`Node`, `R6`>",1
+data.tree,Navigate,0,0,0,"class<`Node`, `R6`>",1
+data.tree,Navigate,1,0,0,character[],1
+data.tree,.parentSeparator,-1,0,0,character,1
+data.tree,.parentSeparator,0,0,0,"class<`Node`, `R6`>",1
+data.tree,plot.Node,-1,0,0,"class<`grViz`, `htmlwidget`>",1
+data.tree,plot.Node,0,0,0,"class<`Node`, `R6`>",1
+data.tree,plot.Node,1,0,0,...,1
+data.tree,plot.Node,2,0,0,character[],1
+data.tree,plot.Node,3,0,0,null,1
+data.tree,plot.Node,4,0,0,character,1
+data.tree,print.Node,-1,0,0,class<`data.frame`>,1
+data.tree,print.Node,0,0,0,"class<`Node`, `R6`>",1
+data.tree,print.Node,1,0,0,...,1
+data.tree,print.Node,2,0,0,any,1
+data.tree,print.Node,3,0,0,double,1
+data.tree,print.Node,4,0,0,class<`function`>,1
+data.tree,print.Node,4,0,1,null,1
+data.tree,PrintPruneDist,-1,0,0,"class<`Node`, `R6`>",1
+data.tree,PrintPruneDist,0,0,0,"class<`Node`, `R6`>",1
+data.tree,PrintPruneDist,1,0,0,double,1
+data.tree,PrintPruneSimple,-1,0,0,"class<`Node`, `R6`>",1
+data.tree,PrintPruneSimple,0,0,0,"class<`Node`, `R6`>",1
+data.tree,PrintPruneSimple,1,0,0,double,1
+data.tree,Prune,-1,0,0,double,1
+data.tree,Prune,0,0,0,"class<`Node`, `R6`>",1
+data.tree,Prune,1,0,0,class<`function`>,1
+data.tree,.Prune,-1,0,0,double,1
+data.tree,.Prune,-1,0,1,null,1
+data.tree,.Prune,0,0,0,"class<`Node`, `R6`>",1
+data.tree,.Prune,1,0,0,any,1
+data.tree,.Prune,2,0,0,logical,1
+data.tree,.separator,-1,0,0,character,1
+data.tree,.separator,0,0,0,"class<`Node`, `R6`>",1
+data.tree,Set,-1,0,0,"list<class<`Node`, `R6`>>",1
+data.tree,Set,0,0,0,"list<class<`Node`, `R6`>>",1
+data.tree,Set,1,0,0,...,1
+data.tree,SetEdgeStyle,-1,0,0,logical,1
+data.tree,SetEdgeStyle,0,0,0,"class<`Node`, `R6`>",1
+data.tree,SetEdgeStyle,1,0,0,logical,1
+data.tree,SetEdgeStyle,2,0,0,logical,1
+data.tree,SetEdgeStyle,3,0,0,...,1
+data.tree,SetFormat,-1,0,0,class<`function`>,1
+data.tree,SetFormat,0,0,0,"class<`Node`, `R6`>",1
+data.tree,SetFormat,1,0,0,character,1
+data.tree,SetFormat,2,0,0,class<`function`>,1
+data.tree,SetGraphStyle,-1,0,0,list<character>,1
+data.tree,SetGraphStyle,0,0,0,"class<`Node`, `R6`>",1
+data.tree,SetGraphStyle,1,0,0,logical,1
+data.tree,SetGraphStyle,2,0,0,...,1
+data.tree,SetNodeStyle,-1,0,0,logical,1
+data.tree,SetNodeStyle,0,0,0,"class<`Node`, `R6`>",1
+data.tree,SetNodeStyle,1,0,0,logical,1
+data.tree,SetNodeStyle,2,0,0,logical,1
+data.tree,SetNodeStyle,3,0,0,...,1
+data.tree,SetStyle,-1,0,0,logical,1
+data.tree,SetStyle,0,0,0,"class<`Node`, `R6`>",1
+data.tree,SetStyle,1,0,0,character,1
+data.tree,SetStyle,2,0,0,logical,1
+data.tree,SetStyle,3,0,0,logical,1
+data.tree,SetStyle,4,0,0,...,1
+data.tree,Sort,-1,0,0,"class<`Node`, `R6`>",1
+data.tree,Sort,-1,0,1,null,1
+data.tree,Sort,0,0,0,"class<`Node`, `R6`>",1
+data.tree,Sort,1,0,0,any,1
+data.tree,Sort,2,0,0,...,1
+data.tree,Sort,3,0,0,any,1
+data.tree,Sort,4,0,0,any,1
+data.tree,ToDataFrameNetwork,-1,0,0,class<`data.frame`>,1
+data.tree,ToDataFrameNetwork,0,0,0,"class<`Node`, `R6`>",1
+data.tree,ToDataFrameNetwork,1,0,0,...,1
+data.tree,ToDataFrameNetwork,2,0,0,character[],1
+data.tree,ToDataFrameNetwork,3,0,0,null,1
+data.tree,ToDataFrameNetwork,4,0,0,logical,1
+data.tree,ToDataFrameNetwork,5,0,0,logical,1
+data.tree,ToDataFrameTable,-1,0,0,class<`data.frame`>,1
+data.tree,ToDataFrameTable,0,0,0,"class<`Node`, `R6`>",1
+data.tree,ToDataFrameTable,1,0,0,...,1
+data.tree,ToDataFrameTable,2,0,0,null,1
+data.tree,ToDataFrameTree,-1,0,0,class<`data.frame`>,1
+data.tree,ToDataFrameTree,0,0,0,"class<`Node`, `R6`>",1
+data.tree,ToDataFrameTree,1,0,0,...,1
+data.tree,ToDataFrameTree,2,0,0,class<`function`>,1
+data.tree,ToDataFrameTree,2,0,1,null,1
+data.tree,ToDataFrameTypeCol,-1,0,0,class<`data.frame`>,1
+data.tree,ToDataFrameTypeCol,0,0,0,"class<`Node`, `R6`>",1
+data.tree,ToDataFrameTypeCol,1,0,0,...,1
+data.tree,ToDataFrameTypeCol,2,0,0,character,1
+data.tree,ToDataFrameTypeCol,3,0,0,character,1
+data.tree,ToDataFrameTypeCol,3,0,1,null,1
+data.tree,ToDataFrameTypeCol,4,0,0,null,1
+data.tree,ToDiagrammeRGraph,-1,0,0,class<`dgr_graph`>,1
+data.tree,ToDiagrammeRGraph,0,0,0,"class<`Node`, `R6`>",1
+data.tree,ToDiagrammeRGraph,1,0,0,character[],1
+data.tree,ToDiagrammeRGraph,2,0,0,null,1
+data.tree,ToListExplicit,-1,0,0,list<character | list<list<character | double>>>,1
+data.tree,ToListExplicit,-1,0,1,list<character | list<list<character | list<list<character | double>>>>>,1
+data.tree,ToListExplicit,-1,0,2,list<character | list<list<character | list<list<character | list<list<character | integer>>>>>>>,1
+data.tree,ToListExplicit,-1,0,3,list<character | list<list<list<list<double>>>>>,1
+data.tree,ToListExplicit,0,0,0,"class<`Node`, `R6`>",1
+data.tree,ToListExplicit,1,0,0,logical,1
+data.tree,ToListExplicit,2,0,0,character,1
+data.tree,ToListExplicit,3,0,0,character,1
+data.tree,ToListExplicit,4,0,0,null,1
+data.tree,ToListExplicit,5,0,0,...,1
+data.tree,ToListSimple,-1,0,0,list<character | list<character | list<character | double>>>,1
+data.tree,ToListSimple,0,0,0,"class<`Node`, `R6`>",1
+data.tree,ToListSimple,1,0,0,character,1
+data.tree,ToListSimple,2,0,0,null,1
+data.tree,ToListSimple,3,0,0,...,1
+data.tree,ToNewick,-1,0,0,character,1
+data.tree,ToNewick,0,0,0,"class<`Node`, `R6`>",1
+data.tree,ToNewick,1,0,0,class<`function`>,1
+data.tree,ToNewick,1,0,1,null,1
+data.tree,ToNewick,2,0,0,...,1
+data.tree,Traverse,-1,0,0,list<any>,1
+data.tree,Traverse,0,0,0,"class<`Node`, `R6`>",1
+data.tree,Traverse,1,0,0,character[],1
+data.tree,Traverse,2,0,0,any,1
+data.tree,Traverse,3,0,0,any,1
+dbplyr,add_op_order,-1,0,0,"class<`tbl`, `tbl_SQLiteConnection`, `tbl_dbi`, `tbl_lazy`, `tbl_sql`>",1
+dbplyr,add_op_order,-1,0,1,"class<`tbl`, `tbl_TestConnection`, `tbl_lazy`>",1
+dbplyr,add_op_order,0,0,0,"class<`tbl`, `tbl_SQLiteConnection`, `tbl_dbi`, `tbl_lazy`, `tbl_sql`>",1
+dbplyr,add_op_order,0,0,1,"class<`tbl`, `tbl_TestConnection`, `tbl_lazy`>",1
+dbplyr,add_op_order,1,0,0,null,1
+dbplyr,add_op_order,1,0,1,"list<class<`formula`, `quosure`>>",1
+dbplyr,add_op_semi_join,-1,0,0,"class<`tbl`, `tbl_SQLiteConnection`, `tbl_dbi`, `tbl_lazy`, `tbl_sql`>",1
+dbplyr,add_op_semi_join,0,0,0,"class<`tbl`, `tbl_SQLiteConnection`, `tbl_dbi`, `tbl_lazy`, `tbl_sql`>",1
+dbplyr,add_op_semi_join,1,0,0,"class<`data.frame`, `tbl`, `tbl_df`>",1
+dbplyr,add_op_semi_join,2,0,0,logical,1
+dbplyr,add_op_semi_join,3,0,0,null,1
+dbplyr,add_op_semi_join,4,0,0,null,1
+dbplyr,add_op_semi_join,5,0,0,logical,1
+dbplyr,add_op_semi_join,6,0,0,logical,1
+dbplyr,add_op_semi_join,7,0,0,...,1
+dbplyr,add_op_single,-1,0,0,"class<`tbl`, `tbl_SQLiteConnection`, `tbl_dbi`, `tbl_lazy`, `tbl_sql`>",1
+dbplyr,add_op_single,-1,0,1,"class<`tbl`, `tbl_SQLiteConnection`, `tbl_lazy`>",1
+dbplyr,add_op_single,-1,0,2,"class<`tbl`, `tbl_TestConnection`, `tbl_lazy`>",1
+dbplyr,add_op_single,0,0,0,character,1
+dbplyr,add_op_single,1,0,0,"class<`tbl`, `tbl_SQLiteConnection`, `tbl_dbi`, `tbl_lazy`, `tbl_sql`>",1
+dbplyr,add_op_single,1,0,1,"class<`tbl`, `tbl_SQLiteConnection`, `tbl_lazy`>",1
+dbplyr,add_op_single,1,0,2,"class<`tbl`, `tbl_TestConnection`, `tbl_lazy`>",1
+dbplyr,add_op_single,2,0,0,list<any>,1
+dbplyr,add_op_single,3,0,0,list<any>,1
+dbplyr,all_calls,-1,0,0,character[],1
+dbplyr,all_calls,-1,0,1,null,1
+dbplyr,all_calls,0,0,0,class<`call`>,1
+dbplyr,all_calls,0,0,1,"class<`formula`, `quosure`>",1
+dbplyr,all_calls,0,0,2,class<`if`>,1
+dbplyr,all_calls,0,0,3,class<`name`>,1
+dbplyr,all_calls,0,0,4,class<`(`>,1
+dbplyr,all_calls,0,0,5,character,1
+dbplyr,all_calls,0,0,6,double,1
+dbplyr,all_calls,0,0,7,null,1
+dbplyr,all_names,-1,0,0,character[],1
+dbplyr,all_names,-1,0,1,null,1
+dbplyr,all_names,0,0,0,class<`call`>,1
+dbplyr,all_names,0,0,1,"class<`formula`, `quosure`>",1
+dbplyr,all_names,0,0,2,class<`if`>,1
+dbplyr,all_names,0,0,3,class<`name`>,1
+dbplyr,all_names,0,0,4,class<`(`>,1
+dbplyr,all_names,0,0,5,character,1
+dbplyr,all_names,0,0,6,double,1
+dbplyr,all_names,0,0,7,null,1
+dbplyr,arrange.tbl_lazy,-1,0,0,"class<`tbl`, `tbl_SQLiteConnection`, `tbl_dbi`, `tbl_lazy`, `tbl_sql`>",1
+dbplyr,arrange.tbl_lazy,0,0,0,"class<`tbl`, `tbl_SQLiteConnection`, `tbl_dbi`, `tbl_lazy`, `tbl_sql`>",1
+dbplyr,arrange.tbl_lazy,1,0,0,...,1
+dbplyr,arrange.tbl_lazy,2,0,0,logical,1
+dbplyr,as.sql,-1,0,0,"class<`character`, `ident`>",1
+dbplyr,as.sql,-1,0,1,"class<`character`, `ident`, `ident_q`>",1
+dbplyr,as.sql,-1,0,2,"class<`character`, `sql`>",1
+dbplyr,as.sql,0,0,0,character[],1
+dbplyr,as.sql,0,0,1,"class<`character`, `ident`, `ident_q`>",1
+dbplyr,as.sql,0,0,2,"class<`character`, `sql`>",1
+dbplyr,as.sql.character,-1,0,0,"class<`character`, `ident`>",1
+dbplyr,as.sql.character,0,0,0,character[],1
+dbplyr,as.sql.ident,-1,0,0,"class<`character`, `ident`, `ident_q`>",1
+dbplyr,as.sql.ident,-1,0,1,"class<`character`, `sql`>",1
+dbplyr,as.sql.ident,0,0,0,"class<`character`, `ident`, `ident_q`>",1
+dbplyr,as.sql.ident,0,0,1,"class<`character`, `sql`>",1
+dbplyr,as.sql.sql,-1,0,0,"class<`character`, `ident`, `ident_q`>",1
+dbplyr,as.sql.sql,-1,0,1,"class<`character`, `sql`>",1
+dbplyr,as.sql.sql,0,0,0,"class<`character`, `ident`, `ident_q`>",1
+dbplyr,as.sql.sql,0,0,1,"class<`character`, `sql`>",1
+dbplyr,auto_copy.tbl_sql,-1,0,0,"class<`tbl`, `tbl_SQLiteConnection`, `tbl_dbi`, `tbl_lazy`, `tbl_sql`>",1
+dbplyr,auto_copy.tbl_sql,0,0,0,"class<`tbl`, `tbl_SQLiteConnection`, `tbl_dbi`, `tbl_lazy`, `tbl_sql`>",1
+dbplyr,auto_copy.tbl_sql,1,0,0,"class<`data.frame`, `tbl`, `tbl_df`>",1
+dbplyr,auto_copy.tbl_sql,2,0,0,logical,1
+dbplyr,auto_copy.tbl_sql,3,0,0,...,1
+dbplyr,build_sql,-1,0,0,"class<`character`, `sql`>",1
+dbplyr,build_sql,0,0,0,...,1
+dbplyr,build_sql,1,0,0,any,1
+dbplyr,build_sql,2,0,0,"class<`DBIConnection`, `TestConnection`>",1
+dbplyr,build_sql,2,0,1,"class<`DBIConnection`, `Microsoft SQL Server`, `TestConnection`>",1
+dbplyr,build_sql,2,0,2,"class<`DBIConnection`, `PostgreSQLConnection`, `TestConnection`>",1
+dbplyr,build_sql,2,0,3,"class<`DBIConnection`, `SQLiteConnection`, `TestConnection`>",1
+dbplyr,build_sql,2,0,4,"class<`DBIConnection`, `TestCon`, `TestConnection`>",1
+dbplyr,build_sql,2,0,5,class<`SQLiteConnection`>,1
+dbplyr,cache,-1,0,0,environment,1
+dbplyr,cache_computation,-1,0,0,"class<`src`, `src_SQLiteConnection`, `src_dbi`, `src_sql`>",1
+dbplyr,cache_computation,0,0,0,character,1
+dbplyr,cache_computation,1,0,0,any,1
+dbplyr,carry_over,-1,0,0,"list<class<`name`> | class<`formula`, `quosure`>>",1
+dbplyr,carry_over,-1,0,1,"list<class<`formula`, `quosure`>>",1
+dbplyr,carry_over,0,0,0,character[],1
+dbplyr,carry_over,1,0,0,"list<class<`formula`, `quosure`>>",1
+dbplyr,cat_line,-1,0,0,null,1
+dbplyr,cat_line,0,0,0,...,1
+dbplyr,c_character,-1,0,0,character[],1
+dbplyr,c_character,0,0,0,...,1
+dbplyr,ceply,-1,0,0,environment,1
+dbplyr,ceply,0,0,0,character[],1
+dbplyr,ceply,0,0,1,list<any>,1
+dbplyr,ceply,0,0,2,null,1
+dbplyr,ceply,1,0,0,any,1
+dbplyr,ceply,2,0,0,...,1
+dbplyr,ceply,3,0,0,environment,1
+dbplyr,check_na_rm,-1,0,0,logical,1
+dbplyr,check_na_rm,0,0,0,any,1
+dbplyr,check_na_rm,1,0,0,any,1
+dbplyr,check_na_rm,2,0,0,logical,1
+dbplyr,check_summarise_vars,-1,0,0,null,1
+dbplyr,check_summarise_vars,0,0,0,"list<class<`formula`, `quosure`>>",1
+dbplyr,collect.tbl_sql,-1,0,0,"class<`data.frame`, `tbl`, `tbl_df`>",1
+dbplyr,collect.tbl_sql,0,0,0,"class<`tbl`, `tbl_SQLiteConnection`, `tbl_dbi`, `tbl_lazy`, `tbl_sql`>",1
+dbplyr,collect.tbl_sql,1,0,0,...,1
+dbplyr,collect.tbl_sql,2,0,0,double,1
+dbplyr,collect.tbl_sql,3,0,0,logical,1
+dbplyr,compute.tbl_sql,-1,0,0,"class<`tbl`, `tbl_SQLiteConnection`, `tbl_dbi`, `tbl_lazy`, `tbl_sql`>",1
+dbplyr,compute.tbl_sql,0,0,0,"class<`tbl`, `tbl_SQLiteConnection`, `tbl_dbi`, `tbl_lazy`, `tbl_sql`>",1
+dbplyr,compute.tbl_sql,1,0,0,character,1
+dbplyr,compute.tbl_sql,2,0,0,logical,1
+dbplyr,compute.tbl_sql,3,0,0,null,1
+dbplyr,compute.tbl_sql,4,0,0,null,1
+dbplyr,compute.tbl_sql,5,0,0,logical,1
+dbplyr,compute.tbl_sql,6,0,0,...,1
+dbplyr,copy_env,-1,0,0,environment,1
+dbplyr,copy_env,0,0,0,environment,1
+dbplyr,copy_env,1,0,0,null,1
+dbplyr,copy_env,2,0,0,environment,1
+dbplyr,copy_lahman,-1,0,0,"class<`src`, `src_SQLiteConnection`, `src_dbi`, `src_sql`>",1
+dbplyr,copy_lahman,0,0,0,"class<`src`, `src_SQLiteConnection`, `src_dbi`, `src_sql`>",1
+dbplyr,copy_lahman,1,0,0,...,1
+dbplyr,copy_to.src_sql,-1,0,0,"class<`tbl`, `tbl_SQLiteConnection`, `tbl_dbi`, `tbl_lazy`, `tbl_sql`>",1
+dbplyr,copy_to.src_sql,0,0,0,"class<`src`, `src_SQLiteConnection`, `src_dbi`, `src_sql`>",1
+dbplyr,copy_to.src_sql,1,0,0,class<`data.frame`>,1
+dbplyr,copy_to.src_sql,1,0,1,"class<`data.frame`, `tbl`, `tbl_df`>",1
+dbplyr,copy_to.src_sql,1,0,2,"class<`tbl`, `tbl_SQLiteConnection`, `tbl_dbi`, `tbl_lazy`, `tbl_sql`>",1
+dbplyr,copy_to.src_sql,2,0,0,character,1
+dbplyr,copy_to.src_sql,2,0,1,"class<`character`, `ident`, `ident_q`>",1
+dbplyr,copy_to.src_sql,3,0,0,logical,1
+dbplyr,copy_to.src_sql,4,0,0,null,1
+dbplyr,copy_to.src_sql,5,0,0,logical,1
+dbplyr,copy_to.src_sql,6,0,0,null,1
+dbplyr,copy_to.src_sql,7,0,0,null,1
+dbplyr,copy_to.src_sql,7,0,1,list<any>,1
+dbplyr,c.sql,-1,0,0,"class<`character`, `sql`>",1
+dbplyr,c.sql,0,0,0,...,1
+dbplyr,c.sql,1,0,0,logical,1
+dbplyr,c.sql,2,0,0,"class<`DBIConnection`, `SQLiteConnection`, `TestConnection`>",1
+dbplyr,c.sql,2,0,1,class<`SQLiteConnection`>,1
+dbplyr,db_analyze.DBIConnection,-1,0,0,integer,1
+dbplyr,db_analyze.DBIConnection,0,0,0,class<`SQLiteConnection`>,1
+dbplyr,db_analyze.DBIConnection,1,0,0,character,1
+dbplyr,db_analyze.DBIConnection,1,0,1,"class<`character`, `ident`, `ident_q`>",1
+dbplyr,db_analyze.DBIConnection,2,0,0,...,1
+dbplyr,db_begin.DBIConnection,-1,0,0,logical,1
+dbplyr,db_begin.DBIConnection,0,0,0,class<`SQLiteConnection`>,1
+dbplyr,db_begin.DBIConnection,1,0,0,...,1
+dbplyr,db_collect,-1,0,0,class<`data.frame`>,1
+dbplyr,db_collect,0,0,0,class<`SQLiteConnection`>,1
+dbplyr,db_collect,1,0,0,"class<`character`, `sql`>",1
+dbplyr,db_collect,2,0,0,double,1
+dbplyr,db_collect,3,0,0,logical,1
+dbplyr,db_collect,4,0,0,...,1
+dbplyr,db_collect.DBIConnection,-1,0,0,class<`data.frame`>,1
+dbplyr,db_collect.DBIConnection,0,0,0,class<`SQLiteConnection`>,1
+dbplyr,db_collect.DBIConnection,1,0,0,"class<`character`, `sql`>",1
+dbplyr,db_collect.DBIConnection,2,0,0,double,1
+dbplyr,db_collect.DBIConnection,3,0,0,logical,1
+dbplyr,db_collect.DBIConnection,4,0,0,...,1
+dbplyr,db_commit.DBIConnection,-1,0,0,logical,1
+dbplyr,db_commit.DBIConnection,0,0,0,class<`SQLiteConnection`>,1
+dbplyr,db_commit.DBIConnection,1,0,0,...,1
+dbplyr,db_compute,-1,0,0,character,1
+dbplyr,db_compute,0,0,0,class<`SQLiteConnection`>,1
+dbplyr,db_compute,1,0,0,character,1
+dbplyr,db_compute,2,0,0,"class<`character`, `sql`>",1
+dbplyr,db_compute,3,0,0,logical,1
+dbplyr,db_compute,4,0,0,null,1
+dbplyr,db_compute,5,0,0,null,1
+dbplyr,db_compute,6,0,0,logical,1
+dbplyr,db_compute,7,0,0,...,1
+dbplyr,db_compute.DBIConnection,-1,0,0,character,1
+dbplyr,db_compute.DBIConnection,0,0,0,class<`SQLiteConnection`>,1
+dbplyr,db_compute.DBIConnection,1,0,0,character,1
+dbplyr,db_compute.DBIConnection,2,0,0,"class<`character`, `sql`>",1
+dbplyr,db_compute.DBIConnection,3,0,0,logical,1
+dbplyr,db_compute.DBIConnection,4,0,0,null,1
+dbplyr,db_compute.DBIConnection,5,0,0,null,1
+dbplyr,db_compute.DBIConnection,6,0,0,logical,1
+dbplyr,db_compute.DBIConnection,7,0,0,...,1
+dbplyr,db_copy_to,-1,0,0,character,1
+dbplyr,db_copy_to,-1,0,1,"class<`character`, `ident`, `ident_q`>",1
+dbplyr,db_copy_to,0,0,0,class<`SQLiteConnection`>,1
+dbplyr,db_copy_to,1,0,0,character,1
+dbplyr,db_copy_to,1,0,1,"class<`character`, `ident`, `ident_q`>",1
+dbplyr,db_copy_to,2,0,0,class<`data.frame`>,1
+dbplyr,db_copy_to,3,0,0,logical,1
+dbplyr,db_copy_to,4,0,0,null,1
+dbplyr,db_copy_to,5,0,0,logical,1
+dbplyr,db_copy_to,6,0,0,null,1
+dbplyr,db_copy_to,7,0,0,null,1
+dbplyr,db_copy_to,7,0,1,list<any>,1
+dbplyr,db_copy_to.DBIConnection,-1,0,0,character,1
+dbplyr,db_copy_to.DBIConnection,-1,0,1,"class<`character`, `ident`, `ident_q`>",1
+dbplyr,db_copy_to.DBIConnection,0,0,0,class<`SQLiteConnection`>,1
+dbplyr,db_copy_to.DBIConnection,1,0,0,character,1
+dbplyr,db_copy_to.DBIConnection,1,0,1,"class<`character`, `ident`, `ident_q`>",1
+dbplyr,db_copy_to.DBIConnection,2,0,0,class<`data.frame`>,1
+dbplyr,db_copy_to.DBIConnection,3,0,0,logical,1
+dbplyr,db_copy_to.DBIConnection,4,0,0,null,1
+dbplyr,db_copy_to.DBIConnection,5,0,0,logical,1
+dbplyr,db_copy_to.DBIConnection,6,0,0,null,1
+dbplyr,db_copy_to.DBIConnection,7,0,0,null,1
+dbplyr,db_copy_to.DBIConnection,7,0,1,list<any>,1
+dbplyr,db_create_index.DBIConnection,-1,0,0,integer,1
+dbplyr,db_create_index.DBIConnection,0,0,0,class<`SQLiteConnection`>,1
+dbplyr,db_create_index.DBIConnection,1,0,0,character,1
+dbplyr,db_create_index.DBIConnection,2,0,0,character[],1
+dbplyr,db_create_index.DBIConnection,3,0,0,null,1
+dbplyr,db_create_index.DBIConnection,4,0,0,logical,1
+dbplyr,db_create_index.DBIConnection,5,0,0,...,1
+dbplyr,db_create_indexes.DBIConnection,-1,0,0,null,1
+dbplyr,db_create_indexes.DBIConnection,0,0,0,class<`SQLiteConnection`>,1
+dbplyr,db_create_indexes.DBIConnection,1,0,0,any,1
+dbplyr,db_create_indexes.DBIConnection,2,0,0,list<any>,1
+dbplyr,db_create_indexes.DBIConnection,2,0,1,null,1
+dbplyr,db_create_indexes.DBIConnection,3,0,0,logical,1
+dbplyr,db_create_indexes.DBIConnection,4,0,0,...,1
+dbplyr,db_data_type.DBIConnection,-1,0,0,character[],1
+dbplyr,db_data_type.DBIConnection,0,0,0,class<`SQLiteConnection`>,1
+dbplyr,db_data_type.DBIConnection,1,0,0,class<`data.frame`>,1
+dbplyr,db_disconnector,-1,0,0,environment,1
+dbplyr,db_disconnector,0,0,0,any,1
+dbplyr,db_disconnector,1,0,0,any,1
+dbplyr,db_has_table.DBIConnection,-1,0,0,logical,1
+dbplyr,db_has_table.DBIConnection,0,0,0,class<`SQLiteConnection`>,1
+dbplyr,db_has_table.DBIConnection,1,0,0,character,1
+dbplyr,dbi_quote,-1,0,0,class<`SQL`>,1
+dbplyr,dbi_quote,0,0,0,"class<`character`, `ident`>",1
+dbplyr,dbi_quote,0,0,1,"class<`character`, `ident`, `ident_q`>",1
+dbplyr,dbi_quote,1,0,0,any,1
+dbplyr,dbi_quote.ident,-1,0,0,class<`SQL`>,1
+dbplyr,dbi_quote.ident,0,0,0,"class<`character`, `ident`>",1
+dbplyr,dbi_quote.ident,1,0,0,class<`SQLiteConnection`>,1
+dbplyr,dbi_quote.ident_q,-1,0,0,class<`SQL`>,1
+dbplyr,dbi_quote.ident_q,0,0,0,"class<`character`, `ident`, `ident_q`>",1
+dbplyr,dbi_quote.ident_q,1,0,0,any,1
+dbplyr,db_list_tables.DBIConnection,-1,0,0,character[],1
+dbplyr,db_list_tables.DBIConnection,0,0,0,class<`SQLiteConnection`>,1
+dbplyr,db_location,-1,0,0,character,1
+dbplyr,db_location,0,0,0,null,1
+dbplyr,db_location,1,0,0,character,1
+dbplyr,db_query_fields.DBIConnection,-1,0,0,character[],1
+dbplyr,db_query_fields.DBIConnection,0,0,0,class<`SQLiteConnection`>,1
+dbplyr,db_query_fields.DBIConnection,1,0,0,"class<`character`, `ident`>",1
+dbplyr,db_query_fields.DBIConnection,1,0,1,"class<`character`, `ident`, `ident_q`>",1
+dbplyr,db_query_fields.DBIConnection,1,0,2,"class<`character`, `sql`>",1
+dbplyr,db_query_fields.DBIConnection,2,0,0,...,1
+dbplyr,db_save_query.DBIConnection,-1,0,0,character,1
+dbplyr,db_save_query.DBIConnection,0,0,0,class<`SQLiteConnection`>,1
+dbplyr,db_save_query.DBIConnection,1,0,0,"class<`character`, `sql`>",1
+dbplyr,db_save_query.DBIConnection,2,0,0,character,1
+dbplyr,db_save_query.DBIConnection,3,0,0,logical,1
+dbplyr,db_save_query.DBIConnection,4,0,0,...,1
+dbplyr,db_sql_render,-1,0,0,"class<`character`, `sql`>",1
+dbplyr,db_sql_render,0,0,0,"class<`DBIConnection`, `Microsoft SQL Server`, `TestConnection`>",1
+dbplyr,db_sql_render,0,0,1,"class<`DBIConnection`, `PostgreSQLConnection`, `TestConnection`>",1
+dbplyr,db_sql_render,0,0,2,"class<`DBIConnection`, `SQLiteConnection`, `TestConnection`>",1
+dbplyr,db_sql_render,0,0,3,class<`SQLiteConnection`>,1
+dbplyr,db_sql_render,1,0,0,"class<`tbl`, `tbl_Microsoft SQL Server`, `tbl_lazy`>",1
+dbplyr,db_sql_render,1,0,1,"class<`tbl`, `tbl_PostgreSQLConnection`, `tbl_lazy`>",1
+dbplyr,db_sql_render,1,0,2,"class<`tbl`, `tbl_SQLiteConnection`, `tbl_lazy`>",1
+dbplyr,db_sql_render,1,0,3,"class<`op`, `op_select`, `op_single`>",1
+dbplyr,db_sql_render,1,0,4,"class<`tbl`, `tbl_SQLiteConnection`, `tbl_dbi`, `tbl_lazy`, `tbl_sql`>",1
+dbplyr,db_sql_render,2,0,0,...,1
+dbplyr,db_sql_render.DBIConnection,-1,0,0,"class<`character`, `sql`>",1
+dbplyr,db_sql_render.DBIConnection,0,0,0,"class<`DBIConnection`, `Microsoft SQL Server`, `TestConnection`>",1
+dbplyr,db_sql_render.DBIConnection,0,0,1,"class<`DBIConnection`, `PostgreSQLConnection`, `TestConnection`>",1
+dbplyr,db_sql_render.DBIConnection,0,0,2,"class<`DBIConnection`, `SQLiteConnection`, `TestConnection`>",1
+dbplyr,db_sql_render.DBIConnection,0,0,3,class<`SQLiteConnection`>,1
+dbplyr,db_sql_render.DBIConnection,1,0,0,"class<`tbl`, `tbl_Microsoft SQL Server`, `tbl_lazy`>",1
+dbplyr,db_sql_render.DBIConnection,1,0,1,"class<`tbl`, `tbl_PostgreSQLConnection`, `tbl_lazy`>",1
+dbplyr,db_sql_render.DBIConnection,1,0,2,"class<`tbl`, `tbl_SQLiteConnection`, `tbl_lazy`>",1
+dbplyr,db_sql_render.DBIConnection,1,0,3,"class<`op`, `op_select`, `op_single`>",1
+dbplyr,db_sql_render.DBIConnection,1,0,4,"class<`tbl`, `tbl_SQLiteConnection`, `tbl_dbi`, `tbl_lazy`, `tbl_sql`>",1
+dbplyr,db_sql_render.DBIConnection,2,0,0,...,1
+dbplyr,db_write_table.DBIConnection,-1,0,0,character,1
+dbplyr,db_write_table.DBIConnection,-1,0,1,"class<`character`, `ident`, `ident_q`>",1
+dbplyr,db_write_table.DBIConnection,0,0,0,class<`SQLiteConnection`>,1
+dbplyr,db_write_table.DBIConnection,1,0,0,character,1
+dbplyr,db_write_table.DBIConnection,1,0,1,"class<`character`, `ident`, `ident_q`>",1
+dbplyr,db_write_table.DBIConnection,2,0,0,character[],1
+dbplyr,db_write_table.DBIConnection,3,0,0,class<`data.frame`>,1
+dbplyr,db_write_table.DBIConnection,4,0,0,logical,1
+dbplyr,db_write_table.DBIConnection,5,0,0,...,1
+dbplyr,dim.tbl_lazy,-1,0,0,^integer[],1
+dbplyr,dim.tbl_lazy,0,0,0,"class<`tbl`, `tbl_SQLiteConnection`, `tbl_dbi`, `tbl_lazy`, `tbl_sql`>",1
+dbplyr,escape,-1,0,0,"class<`character`, `sql`>",1
+dbplyr,escape,0,0,0,character[],1
+dbplyr,escape,0,0,1,"class<`character`, `ident`>",1
+dbplyr,escape,0,0,2,"class<`character`, `ident`, `ident_q`>",1
+dbplyr,escape,0,0,3,"class<`character`, `sql`>",1
+dbplyr,escape,0,0,4,double[],1
+dbplyr,escape,0,0,5,"list<class<`character`, `sql`>>",1
+dbplyr,escape,0,0,6,"list<class<`character`, `sql`> | double>",1
+dbplyr,escape,0,0,7,"list<class<`character`, `sql`> | integer>",1
+dbplyr,escape,0,0,8,null,1
+dbplyr,escape,0,0,9,list<integer>,1
+dbplyr,escape,1,0,0,null,1
+dbplyr,escape,1,0,1,logical,1
+dbplyr,escape,2,0,0,character,1
+dbplyr,escape,2,0,1,null,1
+dbplyr,escape,3,0,0,"class<`DBIConnection`, `TestConnection`>",1
+dbplyr,escape,3,0,1,class<`SQLiteConnection`>,1
+dbplyr,escape,3,0,2,"class<`DBIConnection`, `Microsoft SQL Server`, `TestConnection`>",1
+dbplyr,escape,3,0,3,"class<`DBIConnection`, `PostgreSQLConnection`, `TestConnection`>",1
+dbplyr,escape,3,0,4,"class<`DBIConnection`, `SQLiteConnection`, `TestConnection`>",1
+dbplyr,escape,3,0,5,"class<`ACCESS`, `DBIConnection`, `TestConnection`>",1
+dbplyr,escape,3,0,6,"class<`DBIConnection`, `TestCon`, `TestConnection`>",1
+dbplyr,escape_ansi,-1,0,0,"class<`character`, `sql`>",1
+dbplyr,escape_ansi,0,0,0,character,1
+dbplyr,escape_ansi,0,0,1,"class<`character`, `ident`>",1
+dbplyr,escape_ansi,0,0,2,"class<`character`, `sql`>",1
+dbplyr,escape_ansi,0,0,3,double[],1
+dbplyr,escape_ansi,1,0,0,null,1
+dbplyr,escape_ansi,2,0,0,character,1
+dbplyr,escape.character,-1,0,0,"class<`character`, `sql`>",1
+dbplyr,escape.character,0,0,0,character[],1
+dbplyr,escape.character,1,0,0,null,1
+dbplyr,escape.character,2,0,0,character,1
+dbplyr,escape.character,3,0,0,"class<`DBIConnection`, `TestConnection`>",1
+dbplyr,escape.character,3,0,1,class<`SQLiteConnection`>,1
+dbplyr,escape.double,-1,0,0,"class<`character`, `sql`>",1
+dbplyr,escape.double,0,0,0,double[],1
+dbplyr,escape.double,1,0,0,null,1
+dbplyr,escape.double,2,0,0,character,1
+dbplyr,escape.double,3,0,0,"class<`DBIConnection`, `TestConnection`>",1
+dbplyr,escape.double,3,0,1,class<`SQLiteConnection`>,1
+dbplyr,escape.ident,-1,0,0,"class<`character`, `sql`>",1
+dbplyr,escape.ident,0,0,0,"class<`character`, `ident`>",1
+dbplyr,escape.ident,1,0,0,logical,1
+dbplyr,escape.ident,1,0,1,null,1
+dbplyr,escape.ident,2,0,0,character,1
+dbplyr,escape.ident,2,0,1,null,1
+dbplyr,escape.ident,3,0,0,"class<`ACCESS`, `DBIConnection`, `TestConnection`>",1
+dbplyr,escape.ident,3,0,1,"class<`DBIConnection`, `Microsoft SQL Server`, `TestConnection`>",1
+dbplyr,escape.ident,3,0,2,"class<`DBIConnection`, `PostgreSQLConnection`, `TestConnection`>",1
+dbplyr,escape.ident,3,0,3,"class<`DBIConnection`, `SQLiteConnection`, `TestConnection`>",1
+dbplyr,escape.ident,3,0,4,"class<`DBIConnection`, `TestConnection`>",1
+dbplyr,escape.ident,3,0,5,"class<`DBIConnection`, `TestCon`, `TestConnection`>",1
+dbplyr,escape.ident,3,0,6,class<`SQLiteConnection`>,1
+dbplyr,escape.ident_q,-1,0,0,"class<`character`, `sql`>",1
+dbplyr,escape.ident_q,0,0,0,"class<`character`, `ident`, `ident_q`>",1
+dbplyr,escape.ident_q,1,0,0,logical,1
+dbplyr,escape.ident_q,2,0,0,character,1
+dbplyr,escape.ident_q,3,0,0,class<`SQLiteConnection`>,1
+dbplyr,escape.integer,-1,0,0,"class<`character`, `sql`>",1
+dbplyr,escape.integer,0,0,0,integer[],1
+dbplyr,escape.integer,1,0,0,null,1
+dbplyr,escape.integer,2,0,0,character,1
+dbplyr,escape.integer,3,0,0,"class<`DBIConnection`, `TestConnection`>",1
+dbplyr,escape.integer,3,0,1,"class<`ACCESS`, `DBIConnection`, `TestConnection`>",1
+dbplyr,escape.integer,3,0,2,"class<`DBIConnection`, `Microsoft SQL Server`, `TestConnection`>",1
+dbplyr,escape.integer,3,0,3,"class<`DBIConnection`, `PostgreSQLConnection`, `TestConnection`>",1
+dbplyr,escape.integer,3,0,4,"class<`DBIConnection`, `SQLiteConnection`, `TestConnection`>",1
+dbplyr,escape.list,-1,0,0,"class<`character`, `sql`>",1
+dbplyr,escape.list,0,0,0,"list<class<`character`, `sql`>>",1
+dbplyr,escape.list,0,0,1,"list<class<`character`, `sql`> | double>",1
+dbplyr,escape.list,0,0,2,"list<class<`character`, `sql`> | integer>",1
+dbplyr,escape.list,0,0,3,list<integer>,1
+dbplyr,escape.list,1,0,0,logical,1
+dbplyr,escape.list,2,0,0,character,1
+dbplyr,escape.list,3,0,0,class<`SQLiteConnection`>,1
+dbplyr,escape.list,3,0,1,"class<`DBIConnection`, `PostgreSQLConnection`, `TestConnection`>",1
+dbplyr,escape.list,3,0,2,"class<`DBIConnection`, `Microsoft SQL Server`, `TestConnection`>",1
+dbplyr,escape.list,3,0,3,"class<`DBIConnection`, `SQLiteConnection`, `TestConnection`>",1
+dbplyr,escape.list,3,0,4,"class<`DBIConnection`, `TestConnection`>",1
+dbplyr,escape.list,3,0,5,"class<`DBIConnection`, `TestCon`, `TestConnection`>",1
+dbplyr,escape.logical,-1,0,0,"class<`character`, `sql`>",1
+dbplyr,escape.logical,0,0,0,null,1
+dbplyr,escape.logical,1,0,0,null,1
+dbplyr,escape.logical,2,0,0,character,1
+dbplyr,escape.logical,3,0,0,"class<`DBIConnection`, `TestConnection`>",1
+dbplyr,escape.sql,-1,0,0,"class<`character`, `sql`>",1
+dbplyr,escape.sql,0,0,0,"class<`character`, `sql`>",1
+dbplyr,escape.sql,1,0,0,logical,1
+dbplyr,escape.sql,1,0,1,null,1
+dbplyr,escape.sql,2,0,0,null,1
+dbplyr,escape.sql,2,0,1,character,1
+dbplyr,escape.sql,3,0,0,class<`SQLiteConnection`>,1
+dbplyr,escape.sql,3,0,1,"class<`DBIConnection`, `Microsoft SQL Server`, `TestConnection`>",1
+dbplyr,escape.sql,3,0,2,"class<`DBIConnection`, `PostgreSQLConnection`, `TestConnection`>",1
+dbplyr,escape.sql,3,0,3,"class<`DBIConnection`, `SQLiteConnection`, `TestConnection`>",1
+dbplyr,escape.sql,3,0,4,"class<`DBIConnection`, `TestConnection`>",1
+dbplyr,escape.sql,3,0,5,"class<`ACCESS`, `DBIConnection`, `TestConnection`>",1
+dbplyr,escape.sql,3,0,6,"class<`DBIConnection`, `TestCon`, `TestConnection`>",1
+dbplyr,filter.tbl_lazy,-1,0,0,"class<`tbl`, `tbl_SQLiteConnection`, `tbl_dbi`, `tbl_lazy`, `tbl_sql`>",1
+dbplyr,filter.tbl_lazy,0,0,0,"class<`tbl`, `tbl_SQLiteConnection`, `tbl_dbi`, `tbl_lazy`, `tbl_sql`>",1
+dbplyr,filter.tbl_lazy,1,0,0,...,1
+dbplyr,filter.tbl_lazy,2,0,0,logical,1
+dbplyr,find_fun,-1,0,0,character,1
+dbplyr,find_fun,0,0,0,class<`function`>,1
+dbplyr,fun_name,-1,0,0,character,1
+dbplyr,fun_name,0,0,0,class<`function`>,1
+dbplyr,group_by_drop_default.tbl_lazy,-1,0,0,logical,1
+dbplyr,group_by_drop_default.tbl_lazy,0,0,0,"class<`tbl`, `tbl_SQLiteConnection`, `tbl_dbi`, `tbl_lazy`, `tbl_sql`>",1
+dbplyr,group_by.tbl_lazy,-1,0,0,"class<`tbl`, `tbl_SQLiteConnection`, `tbl_dbi`, `tbl_lazy`, `tbl_sql`>",1
+dbplyr,group_by.tbl_lazy,-1,0,1,"class<`tbl`, `tbl_TestConnection`, `tbl_lazy`>",1
+dbplyr,group_by.tbl_lazy,0,0,0,"class<`tbl`, `tbl_SQLiteConnection`, `tbl_dbi`, `tbl_lazy`, `tbl_sql`>",1
+dbplyr,group_by.tbl_lazy,0,0,1,"class<`tbl`, `tbl_TestConnection`, `tbl_lazy`>",1
+dbplyr,group_by.tbl_lazy,1,0,0,...,1
+dbplyr,group_by.tbl_lazy,2,0,0,logical,1
+dbplyr,group_by.tbl_lazy,3,0,0,logical,1
+dbplyr,group_vars.tbl_lazy,-1,0,0,character[],1
+dbplyr,group_vars.tbl_lazy,0,0,0,"class<`tbl`, `tbl_SQLiteConnection`, `tbl_dbi`, `tbl_lazy`, `tbl_sql`>",1
+dbplyr,has_lahman,-1,0,0,logical,1
+dbplyr,has_lahman,0,0,0,character,1
+dbplyr,has_lahman,1,0,0,...,1
+dbplyr,head.tbl_lazy,-1,0,0,"class<`tbl`, `tbl_Microsoft SQL Server`, `tbl_lazy`>",1
+dbplyr,head.tbl_lazy,-1,0,1,"class<`tbl`, `tbl_PostgreSQLConnection`, `tbl_lazy`>",1
+dbplyr,head.tbl_lazy,0,0,0,"class<`tbl`, `tbl_Microsoft SQL Server`, `tbl_lazy`>",1
+dbplyr,head.tbl_lazy,0,0,1,"class<`tbl`, `tbl_PostgreSQLConnection`, `tbl_lazy`>",1
+dbplyr,head.tbl_lazy,1,0,0,double,1
+dbplyr,head.tbl_lazy,2,0,0,...,1
+dbplyr,ident,-1,0,0,"class<`character`, `ident`>",1
+dbplyr,ident,0,0,0,...,1
+dbplyr,ident_q,-1,0,0,"class<`character`, `ident`, `ident_q`>",1
+dbplyr,ident_q,0,0,0,...,1
+dbplyr,in_schema,-1,0,0,"class<`character`, `ident`, `ident_q`>",1
+dbplyr,in_schema,0,0,0,character,1
+dbplyr,in_schema,1,0,0,character,1
+dbplyr,is.ident,-1,0,0,logical,1
+dbplyr,is.ident,0,0,0,"class<`character`, `ident`>",1
+dbplyr,is.ident,0,0,1,"class<`character`, `ident`, `ident_q`>",1
+dbplyr,is.ident,0,0,2,"class<`character`, `sql`>",1
+dbplyr,is_infix_base,-1,0,0,logical,1
+dbplyr,is_infix_base,0,0,0,character,1
+dbplyr,is_infix_user,-1,0,0,logical,1
+dbplyr,is_infix_user,0,0,0,character,1
+dbplyr,is.sql,-1,0,0,logical,1
+dbplyr,is.sql,0,0,0,character[],1
+dbplyr,is.sql,0,0,1,"class<`character`, `ident`>",1
+dbplyr,is.sql,0,0,2,"class<`character`, `ident`, `ident_q`>",1
+dbplyr,is.sql,0,0,3,"class<`character`, `sql`>",1
+dbplyr,is.sql_variant,-1,0,0,logical,1
+dbplyr,is.sql_variant,0,0,0,class<`sql_variant`>,1
+dbplyr,is_tidy_pronoun,-1,0,0,logical,1
+dbplyr,is_tidy_pronoun,0,0,0,class<`(`>,1
+dbplyr,is_tidy_pronoun,0,0,1,class<`call`>,1
+dbplyr,is.wholenumber,-1,0,0,logical[],1
+dbplyr,is.wholenumber,0,0,0,double[],1
+dbplyr,is_writeable,-1,0,0,logical,1
+dbplyr,is_writeable,0,0,0,character,1
+dbplyr,lahman,-1,0,0,"class<`src`, `src_SQLiteConnection`, `src_dbi`, `src_sql`>",1
+dbplyr,lahman,0,0,0,character,1
+dbplyr,lahman,1,0,0,...,1
+dbplyr,lahman_sqlite,-1,0,0,"class<`src`, `src_SQLiteConnection`, `src_dbi`, `src_sql`>",1
+dbplyr,lahman_sqlite,0,0,0,null,1
+dbplyr,lahman_tables,-1,0,0,character[],1
+dbplyr,lazy_frame,-1,0,0,"class<`tbl`, `tbl_Microsoft SQL Server`, `tbl_lazy`>",1
+dbplyr,lazy_frame,-1,0,1,"class<`tbl`, `tbl_PostgreSQLConnection`, `tbl_lazy`>",1
+dbplyr,lazy_frame,-1,0,2,"class<`tbl`, `tbl_TestConnection`, `tbl_lazy`>",1
+dbplyr,lazy_frame,0,0,0,...,1
+dbplyr,lazy_frame,1,0,0,"class<`DBIConnection`, `Microsoft SQL Server`, `TestConnection`>",1
+dbplyr,lazy_frame,1,0,1,"class<`DBIConnection`, `PostgreSQLConnection`, `TestConnection`>",1
+dbplyr,lazy_frame,1,0,2,"class<`DBIConnection`, `TestConnection`>",1
+dbplyr,lazy_frame,2,0,0,null,1
+dbplyr,memdb_frame,-1,0,0,"class<`tbl`, `tbl_SQLiteConnection`, `tbl_dbi`, `tbl_lazy`, `tbl_sql`>",1
+dbplyr,memdb_frame,0,0,0,...,1
+dbplyr,memdb_frame,1,0,0,character,1
+dbplyr,mutate.tbl_lazy,-1,0,0,"class<`tbl`, `tbl_SQLiteConnection`, `tbl_dbi`, `tbl_lazy`, `tbl_sql`>",1
+dbplyr,mutate.tbl_lazy,-1,0,1,"class<`tbl`, `tbl_TestConnection`, `tbl_lazy`>",1
+dbplyr,mutate.tbl_lazy,0,0,0,"class<`tbl`, `tbl_SQLiteConnection`, `tbl_dbi`, `tbl_lazy`, `tbl_sql`>",1
+dbplyr,mutate.tbl_lazy,0,0,1,"class<`tbl`, `tbl_TestConnection`, `tbl_lazy`>",1
+dbplyr,mutate.tbl_lazy,1,0,0,...,1
+dbplyr,mutate.tbl_lazy,2,0,0,any,1
+dbplyr,names.sql_variant,-1,0,0,character[],1
+dbplyr,names.sql_variant,0,0,0,class<`sql_variant`>,1
+dbplyr,names_to_as,-1,0,0,character[],1
+dbplyr,names_to_as,0,0,0,character[],1
+dbplyr,names_to_as,0,0,1,"class<`character`, `ident`>",1
+dbplyr,names_to_as,0,0,2,"class<`character`, `sql`>",1
+dbplyr,names_to_as,0,0,3,"list<class<`character`, `sql`>>",1
+dbplyr,names_to_as,0,0,4,"class<`character`, `ident`, `ident_q`>",1
+dbplyr,names_to_as,0,0,5,class<`SQL`>,1
+dbplyr,names_to_as,1,0,0,any,1
+dbplyr,names_to_as,2,0,0,any,1
+dbplyr,nest_vars,-1,0,0,"class<`tbl`, `tbl_SQLiteConnection`, `tbl_dbi`, `tbl_lazy`, `tbl_sql`>",1
+dbplyr,nest_vars,-1,0,1,"class<`tbl`, `tbl_TestConnection`, `tbl_lazy`>",1
+dbplyr,nest_vars,0,0,0,"class<`tbl`, `tbl_SQLiteConnection`, `tbl_dbi`, `tbl_lazy`, `tbl_sql`>",1
+dbplyr,nest_vars,0,0,1,"class<`tbl`, `tbl_TestConnection`, `tbl_lazy`>",1
+dbplyr,nest_vars,1,0,0,"list<class<`formula`, `quosure`>>",1
+dbplyr,nest_vars,2,0,0,character[],1
+dbplyr,new_op_select,-1,0,0,"class<`op`, `op_select`, `op_single`>",1
+dbplyr,new_op_select,0,0,0,"class<`op`, `op_base`, `op_base_remote`>",1
+dbplyr,new_op_select,0,0,1,"class<`op`, `op_filter`, `op_single`>",1
+dbplyr,new_op_select,0,0,2,"class<`op`, `op_order`, `op_single`>",1
+dbplyr,new_op_select,0,0,3,"class<`op`, `op_select`, `op_single`>",1
+dbplyr,new_op_select,1,0,0,list<class<`name`>>,1
+dbplyr,new_op_select,1,0,1,"list<class<`name`> | class<`formula`, `quosure`>>",1
+dbplyr,new_op_select,1,0,2,"list<class<`formula`, `quosure`>>",1
+dbplyr,op_base,-1,0,0,"class<`op`, `op_base`, `op_base_local`>",1
+dbplyr,op_base,-1,0,1,"class<`op`, `op_base`, `op_base_remote`>",1
+dbplyr,op_base,0,0,0,class<`data.frame`>,1
+dbplyr,op_base,0,0,1,"class<`data.frame`, `tbl`, `tbl_df`>",1
+dbplyr,op_base,0,0,2,"class<`character`, `ident`>",1
+dbplyr,op_base,0,0,3,"class<`character`, `ident`, `ident_q`>",1
+dbplyr,op_base,0,0,4,"class<`character`, `sql`>",1
+dbplyr,op_base,1,0,0,character[],1
+dbplyr,op_base,2,0,0,character,1
+dbplyr,op_base_local,-1,0,0,"class<`op`, `op_base`, `op_base_local`>",1
+dbplyr,op_base_local,0,0,0,class<`data.frame`>,1
+dbplyr,op_base_local,0,0,1,"class<`data.frame`, `tbl`, `tbl_df`>",1
+dbplyr,op_base_remote,-1,0,0,"class<`op`, `op_base`, `op_base_remote`>",1
+dbplyr,op_base_remote,0,0,0,"class<`character`, `ident`>",1
+dbplyr,op_base_remote,0,0,1,"class<`character`, `ident`, `ident_q`>",1
+dbplyr,op_base_remote,0,0,2,"class<`character`, `sql`>",1
+dbplyr,op_base_remote,1,0,0,character[],1
+dbplyr,op_double,-1,0,0,"class<`op`, `op_double`, `op_semi_join`>",1
+dbplyr,op_double,0,0,0,character,1
+dbplyr,op_double,1,0,0,"class<`tbl`, `tbl_SQLiteConnection`, `tbl_dbi`, `tbl_lazy`, `tbl_sql`>",1
+dbplyr,op_double,2,0,0,"class<`tbl`, `tbl_SQLiteConnection`, `tbl_dbi`, `tbl_lazy`, `tbl_sql`>",1
+dbplyr,op_double,3,0,0,list<logical | list<character>>,1
+dbplyr,op_frame,-1,0,0,double[],1
+dbplyr,op_frame,-1,0,1,null,1
+dbplyr,op_frame,0,0,0,"class<`op`, `op_frame`, `op_single`>",1
+dbplyr,op_frame,0,0,1,"class<`op`, `op_order`, `op_single`>",1
+dbplyr,op_frame,0,0,2,"class<`op`, `op_select`, `op_single`>",1
+dbplyr,op_frame,0,0,3,"class<`op`, `op_base`, `op_base_local`>",1
+dbplyr,op_frame,0,0,4,"class<`op`, `op_base`, `op_base_remote`>",1
+dbplyr,op_frame,0,0,5,"class<`op`, `op_filter`, `op_single`>",1
+dbplyr,op_frame.op_base,-1,0,0,null,1
+dbplyr,op_frame.op_base,0,0,0,"class<`op`, `op_base`, `op_base_local`>",1
+dbplyr,op_frame.op_base,0,0,1,"class<`op`, `op_base`, `op_base_remote`>",1
+dbplyr,op_frame.op_frame,-1,0,0,double[],1
+dbplyr,op_frame.op_frame,0,0,0,"class<`op`, `op_frame`, `op_single`>",1
+dbplyr,op_frame.op_single,-1,0,0,double[],1
+dbplyr,op_frame.op_single,-1,0,1,null,1
+dbplyr,op_frame.op_single,0,0,0,"class<`op`, `op_order`, `op_single`>",1
+dbplyr,op_frame.op_single,0,0,1,"class<`op`, `op_select`, `op_single`>",1
+dbplyr,op_frame.op_single,0,0,2,"class<`op`, `op_filter`, `op_single`>",1
+dbplyr,op_grps,-1,0,0,character[],1
+dbplyr,op_grps,0,0,0,"class<`op`, `op_arrange`, `op_single`>",1
+dbplyr,op_grps,0,0,1,"class<`op`, `op_base`, `op_base_local`>",1
+dbplyr,op_grps,0,0,2,"class<`op`, `op_base`, `op_base_remote`>",1
+dbplyr,op_grps,0,0,3,"class<`op`, `op_filter`, `op_single`>",1
+dbplyr,op_grps,0,0,4,"class<`op`, `op_group_by`, `op_single`>",1
+dbplyr,op_grps,0,0,5,"class<`op`, `op_order`, `op_single`>",1
+dbplyr,op_grps,0,0,6,"class<`op`, `op_select`, `op_single`>",1
+dbplyr,op_grps,0,0,7,"class<`op`, `op_single`, `op_summarise`>",1
+dbplyr,op_grps,0,0,8,"class<`tbl`, `tbl_SQLiteConnection`, `tbl_dbi`, `tbl_lazy`, `tbl_sql`>",1
+dbplyr,op_grps,0,0,9,"class<`tbl`, `tbl_TestConnection`, `tbl_lazy`>",1
+dbplyr,op_grps,0,0,10,"class<`op`, `op_frame`, `op_single`>",1
+dbplyr,op_grps.op_base,-1,0,0,character[],1
+dbplyr,op_grps.op_base,0,0,0,"class<`op`, `op_base`, `op_base_local`>",1
+dbplyr,op_grps.op_base,0,0,1,"class<`op`, `op_base`, `op_base_remote`>",1
+dbplyr,op_grps.op_group_by,-1,0,0,character[],1
+dbplyr,op_grps.op_group_by,0,0,0,"class<`op`, `op_group_by`, `op_single`>",1
+dbplyr,op_grps.op_select,-1,0,0,character[],1
+dbplyr,op_grps.op_select,0,0,0,"class<`op`, `op_select`, `op_single`>",1
+dbplyr,op_grps.op_single,-1,0,0,character[],1
+dbplyr,op_grps.op_single,0,0,0,"class<`op`, `op_arrange`, `op_single`>",1
+dbplyr,op_grps.op_single,0,0,1,"class<`op`, `op_filter`, `op_single`>",1
+dbplyr,op_grps.op_single,0,0,2,"class<`op`, `op_order`, `op_single`>",1
+dbplyr,op_grps.op_single,0,0,3,"class<`op`, `op_frame`, `op_single`>",1
+dbplyr,op_grps.op_summarise,-1,0,0,character[],1
+dbplyr,op_grps.op_summarise,0,0,0,"class<`op`, `op_single`, `op_summarise`>",1
+dbplyr,op_grps.tbl_lazy,-1,0,0,character[],1
+dbplyr,op_grps.tbl_lazy,0,0,0,"class<`tbl`, `tbl_SQLiteConnection`, `tbl_dbi`, `tbl_lazy`, `tbl_sql`>",1
+dbplyr,op_grps.tbl_lazy,0,0,1,"class<`tbl`, `tbl_TestConnection`, `tbl_lazy`>",1
+dbplyr,op_select,-1,0,0,"class<`op`, `op_select`, `op_single`>",1
+dbplyr,op_select,0,0,0,"class<`op`, `op_base`, `op_base_remote`>",1
+dbplyr,op_select,0,0,1,"class<`op`, `op_filter`, `op_single`>",1
+dbplyr,op_select,0,0,2,"class<`op`, `op_order`, `op_single`>",1
+dbplyr,op_select,0,0,3,"class<`op`, `op_select`, `op_single`>",1
+dbplyr,op_select,1,0,0,list<class<`name`>>,1
+dbplyr,op_select,1,0,1,"list<class<`formula`, `quosure`>>",1
+dbplyr,op_select,1,0,2,"list<class<`name`> | class<`formula`, `quosure`>>",1
+dbplyr,op_single,-1,0,0,"class<`op`, `op_arrange`, `op_single`>",1
+dbplyr,op_single,-1,0,1,"class<`op`, `op_filter`, `op_single`>",1
+dbplyr,op_single,-1,0,2,"class<`op`, `op_frame`, `op_single`>",1
+dbplyr,op_single,-1,0,3,"class<`op`, `op_group_by`, `op_single`>",1
+dbplyr,op_single,-1,0,4,"class<`op`, `op_head`, `op_single`>",1
+dbplyr,op_single,-1,0,5,"class<`op`, `op_order`, `op_single`>",1
+dbplyr,op_single,-1,0,6,"class<`op`, `op_select`, `op_single`>",1
+dbplyr,op_single,-1,0,7,"class<`op`, `op_single`, `op_summarise`>",1
+dbplyr,op_single,0,0,0,character,1
+dbplyr,op_single,1,0,0,"class<`op`, `op_base`, `op_base_remote`>",1
+dbplyr,op_single,1,0,1,"class<`op`, `op_single`, `op_summarise`>",1
+dbplyr,op_single,1,0,2,"class<`op`, `op_arrange`, `op_single`>",1
+dbplyr,op_single,1,0,3,"class<`op`, `op_group_by`, `op_single`>",1
+dbplyr,op_single,1,0,4,"class<`op`, `op_base`, `op_base_local`>",1
+dbplyr,op_single,1,0,5,"class<`op`, `op_filter`, `op_single`>",1
+dbplyr,op_single,1,0,6,"class<`op`, `op_frame`, `op_single`>",1
+dbplyr,op_single,1,0,7,"class<`op`, `op_order`, `op_single`>",1
+dbplyr,op_single,1,0,8,"class<`op`, `op_select`, `op_single`>",1
+dbplyr,op_single,2,0,0,list<any>,1
+dbplyr,op_single,3,0,0,list<any>,1
+dbplyr,op_sort,-1,0,0,"list<class<`formula`, `quosure`>>",1
+dbplyr,op_sort,-1,0,1,null,1
+dbplyr,op_sort,0,0,0,"class<`op`, `op_order`, `op_single`>",1
+dbplyr,op_sort,0,0,1,"class<`op`, `op_select`, `op_single`>",1
+dbplyr,op_sort,0,0,2,"class<`op`, `op_base`, `op_base_local`>",1
+dbplyr,op_sort,0,0,3,"class<`op`, `op_base`, `op_base_remote`>",1
+dbplyr,op_sort,0,0,4,"class<`op`, `op_filter`, `op_single`>",1
+dbplyr,op_sort,0,0,5,"class<`op`, `op_frame`, `op_single`>",1
+dbplyr,op_sort,0,0,6,"class<`op`, `op_group_by`, `op_single`>",1
+dbplyr,op_sort,0,0,7,"class<`tbl`, `tbl_SQLiteConnection`, `tbl_dbi`, `tbl_lazy`, `tbl_sql`>",1
+dbplyr,op_sort.op_base,-1,0,0,null,1
+dbplyr,op_sort.op_base,0,0,0,"class<`op`, `op_base`, `op_base_local`>",1
+dbplyr,op_sort.op_base,0,0,1,"class<`op`, `op_base`, `op_base_remote`>",1
+dbplyr,op_sort.op_order,-1,0,0,"list<class<`formula`, `quosure`>>",1
+dbplyr,op_sort.op_order,0,0,0,"class<`op`, `op_order`, `op_single`>",1
+dbplyr,op_sort.op_single,-1,0,0,"list<class<`formula`, `quosure`>>",1
+dbplyr,op_sort.op_single,-1,0,1,null,1
+dbplyr,op_sort.op_single,0,0,0,"class<`op`, `op_select`, `op_single`>",1
+dbplyr,op_sort.op_single,0,0,1,"class<`op`, `op_filter`, `op_single`>",1
+dbplyr,op_sort.op_single,0,0,2,"class<`op`, `op_frame`, `op_single`>",1
+dbplyr,op_sort.op_single,0,0,3,"class<`op`, `op_group_by`, `op_single`>",1
+dbplyr,op_sort.tbl_lazy,-1,0,0,null,1
+dbplyr,op_sort.tbl_lazy,0,0,0,"class<`tbl`, `tbl_SQLiteConnection`, `tbl_dbi`, `tbl_lazy`, `tbl_sql`>",1
+dbplyr,op_vars,-1,0,0,character[],1
+dbplyr,op_vars,0,0,0,"class<`op`, `op_arrange`, `op_single`>",1
+dbplyr,op_vars,0,0,1,"class<`op`, `op_base`, `op_base_local`>",1
+dbplyr,op_vars,0,0,2,"class<`op`, `op_base`, `op_base_remote`>",1
+dbplyr,op_vars,0,0,3,"class<`op`, `op_filter`, `op_single`>",1
+dbplyr,op_vars,0,0,4,"class<`op`, `op_frame`, `op_single`>",1
+dbplyr,op_vars,0,0,5,"class<`op`, `op_group_by`, `op_single`>",1
+dbplyr,op_vars,0,0,6,"class<`op`, `op_order`, `op_single`>",1
+dbplyr,op_vars,0,0,7,"class<`op`, `op_select`, `op_single`>",1
+dbplyr,op_vars,0,0,8,"class<`op`, `op_single`, `op_summarise`>",1
+dbplyr,op_vars,0,0,9,"class<`tbl`, `tbl_SQLiteConnection`, `tbl_dbi`, `tbl_lazy`, `tbl_sql`>",1
+dbplyr,op_vars,0,0,10,"class<`tbl`, `tbl_SQLiteConnection`, `tbl_lazy`>",1
+dbplyr,op_vars,0,0,11,"class<`tbl`, `tbl_TestConnection`, `tbl_lazy`>",1
+dbplyr,op_vars.op_base,-1,0,0,character[],1
+dbplyr,op_vars.op_base,0,0,0,"class<`op`, `op_base`, `op_base_local`>",1
+dbplyr,op_vars.op_base,0,0,1,"class<`op`, `op_base`, `op_base_remote`>",1
+dbplyr,op_vars.op_select,-1,0,0,character[],1
+dbplyr,op_vars.op_select,0,0,0,"class<`op`, `op_select`, `op_single`>",1
+dbplyr,op_vars.op_single,-1,0,0,character[],1
+dbplyr,op_vars.op_single,0,0,0,"class<`op`, `op_arrange`, `op_single`>",1
+dbplyr,op_vars.op_single,0,0,1,"class<`op`, `op_filter`, `op_single`>",1
+dbplyr,op_vars.op_single,0,0,2,"class<`op`, `op_frame`, `op_single`>",1
+dbplyr,op_vars.op_single,0,0,3,"class<`op`, `op_group_by`, `op_single`>",1
+dbplyr,op_vars.op_single,0,0,4,"class<`op`, `op_order`, `op_single`>",1
+dbplyr,op_vars.op_summarise,-1,0,0,character[],1
+dbplyr,op_vars.op_summarise,0,0,0,"class<`op`, `op_single`, `op_summarise`>",1
+dbplyr,op_vars.tbl_lazy,-1,0,0,character[],1
+dbplyr,op_vars.tbl_lazy,0,0,0,"class<`tbl`, `tbl_SQLiteConnection`, `tbl_dbi`, `tbl_lazy`, `tbl_sql`>",1
+dbplyr,op_vars.tbl_lazy,0,0,1,"class<`tbl`, `tbl_SQLiteConnection`, `tbl_lazy`>",1
+dbplyr,op_vars.tbl_lazy,0,0,2,"class<`tbl`, `tbl_TestConnection`, `tbl_lazy`>",1
+dbplyr,partial_eval,-1,0,0,character[],1
+dbplyr,partial_eval,-1,0,1,class<`(`>,1
+dbplyr,partial_eval,-1,0,2,class<`call`>,1
+dbplyr,partial_eval,-1,0,3,class<`name`>,1
+dbplyr,partial_eval,-1,0,4,double,1
+dbplyr,partial_eval,0,0,0,class<`name`>,1
+dbplyr,partial_eval,0,0,1,character,1
+dbplyr,partial_eval,0,0,2,class<`(`>,1
+dbplyr,partial_eval,0,0,3,class<`call`>,1
+dbplyr,partial_eval,0,0,4,double,1
+dbplyr,partial_eval,1,0,0,any,1
+dbplyr,partial_eval,2,0,0,any,1
+dbplyr,partial_eval_call,-1,0,0,class<`(`>,1
+dbplyr,partial_eval_call,-1,0,1,class<`call`>,1
+dbplyr,partial_eval_call,-1,0,2,class<`name`>,1
+dbplyr,partial_eval_call,-1,0,3,double,1
+dbplyr,partial_eval_call,0,0,0,class<`(`>,1
+dbplyr,partial_eval_call,0,0,1,class<`call`>,1
+dbplyr,partial_eval_call,1,0,0,any,1
+dbplyr,partial_eval_call,2,0,0,any,1
+dbplyr,partial_eval_dots,-1,0,0,list<any>,1
+dbplyr,partial_eval_dots,0,0,0,"class<`list`, `quosures`>",1
+dbplyr,partial_eval_dots,1,0,0,any,1
+dbplyr,partial_eval_sym,-1,0,0,character[],1
+dbplyr,partial_eval_sym,-1,0,1,class<`name`>,1
+dbplyr,partial_eval_sym,-1,0,2,double,1
+dbplyr,partial_eval_sym,0,0,0,class<`name`>,1
+dbplyr,partial_eval_sym,1,0,0,character[],1
+dbplyr,partial_eval_sym,2,0,0,any,1
+dbplyr,register_s3_method,-1,0,0,null,1
+dbplyr,register_s3_method,0,0,0,character,1
+dbplyr,register_s3_method,1,0,0,character,1
+dbplyr,register_s3_method,2,0,0,character,1
+dbplyr,register_s3_method,3,0,0,null,1
+dbplyr,remote_con,-1,0,0,"class<`DBIConnection`, `Microsoft SQL Server`, `TestConnection`>",1
+dbplyr,remote_con,-1,0,1,"class<`DBIConnection`, `PostgreSQLConnection`, `TestConnection`>",1
+dbplyr,remote_con,-1,0,2,"class<`DBIConnection`, `SQLiteConnection`, `TestConnection`>",1
+dbplyr,remote_con,-1,0,3,class<`SQLiteConnection`>,1
+dbplyr,remote_con,0,0,0,"class<`tbl`, `tbl_Microsoft SQL Server`, `tbl_lazy`>",1
+dbplyr,remote_con,0,0,1,"class<`tbl`, `tbl_PostgreSQLConnection`, `tbl_lazy`>",1
+dbplyr,remote_con,0,0,2,"class<`tbl`, `tbl_SQLiteConnection`, `tbl_lazy`>",1
+dbplyr,remote_con,0,0,3,"class<`tbl`, `tbl_SQLiteConnection`, `tbl_dbi`, `tbl_lazy`, `tbl_sql`>",1
+dbplyr,remote_name,-1,0,0,"class<`character`, `ident`>",1
+dbplyr,remote_name,-1,0,1,null,1
+dbplyr,remote_name,0,0,0,"class<`tbl`, `tbl_SQLiteConnection`, `tbl_dbi`, `tbl_lazy`, `tbl_sql`>",1
+dbplyr,remote_query,-1,0,0,"class<`character`, `sql`>",1
+dbplyr,remote_query,0,0,0,"class<`tbl`, `tbl_Microsoft SQL Server`, `tbl_lazy`>",1
+dbplyr,remote_query,0,0,1,"class<`tbl`, `tbl_PostgreSQLConnection`, `tbl_lazy`>",1
+dbplyr,remote_query,0,0,2,"class<`tbl`, `tbl_SQLiteConnection`, `tbl_dbi`, `tbl_lazy`, `tbl_sql`>",1
+dbplyr,remote_query,0,0,3,"class<`tbl`, `tbl_SQLiteConnection`, `tbl_lazy`>",1
+dbplyr,remote_src,-1,0,0,"class<`src`, `src_SQLiteConnection`, `src_dbi`, `src_sql`>",1
+dbplyr,remote_src,0,0,0,"class<`tbl`, `tbl_SQLiteConnection`, `tbl_dbi`, `tbl_lazy`, `tbl_sql`>",1
+dbplyr,replace_expr,-1,0,0,character,1
+dbplyr,replace_expr,0,0,0,character[],1
+dbplyr,replace_expr,0,0,1,class<`(`>,1
+dbplyr,replace_expr,0,0,2,class<`call`>,1
+dbplyr,replace_expr,0,0,3,"class<`character`, `ident`>",1
+dbplyr,replace_expr,0,0,4,"class<`character`, `sql`>",1
+dbplyr,replace_expr,0,0,5,class<`name`>,1
+dbplyr,replace_expr,0,0,6,double,1
+dbplyr,replace_expr,1,0,0,any,1
+dbplyr,res_warn_incomplete,-1,0,0,null,1
+dbplyr,res_warn_incomplete,0,0,0,class<`SQLiteResult`>,1
+dbplyr,res_warn_incomplete,1,0,0,character,1
+dbplyr,rows,-1,0,0,"class<`character`, `sql`>",1
+dbplyr,rows,0,0,0,double,1
+dbplyr,rows,1,0,0,double,1
+dbplyr,same_src.src_sql,-1,0,0,logical,1
+dbplyr,same_src.src_sql,0,0,0,"class<`src`, `src_SQLiteConnection`, `src_dbi`, `src_sql`>",1
+dbplyr,same_src.src_sql,1,0,0,"class<`src`, `src_SQLiteConnection`, `src_dbi`, `src_sql`>",1
+dbplyr,same_src.tbl_sql,-1,0,0,logical,1
+dbplyr,same_src.tbl_sql,0,0,0,"class<`tbl`, `tbl_SQLiteConnection`, `tbl_dbi`, `tbl_lazy`, `tbl_sql`>",1
+dbplyr,same_src.tbl_sql,1,0,0,"class<`data.frame`, `tbl`, `tbl_df`>",1
+dbplyr,select_query,-1,0,0,"class<`query`, `select_query`>",1
+dbplyr,select_query,0,0,0,"class<`character`, `ident`>",1
+dbplyr,select_query,0,0,1,"class<`query`, `select_query`>",1
+dbplyr,select_query,1,0,0,"class<`character`, `sql`>",1
+dbplyr,select_query,2,0,0,character[],1
+dbplyr,select_query,2,0,1,"class<`character`, `sql`>",1
+dbplyr,select_query,3,0,0,character[],1
+dbplyr,select_query,3,0,1,"class<`character`, `sql`>",1
+dbplyr,select_query,4,0,0,character[],1
+dbplyr,select_query,5,0,0,character[],1
+dbplyr,select_query,5,0,1,"class<`character`, `sql`>",1
+dbplyr,select_query,6,0,0,double,1
+dbplyr,select_query,6,0,1,null,1
+dbplyr,select_query,7,0,0,logical,1
+dbplyr,select_query_clauses,-1,0,0,"class<`factor`, `ordered`>",1
+dbplyr,select_query_clauses,0,0,0,"class<`query`, `select_query`>",1
+dbplyr,select.tbl_lazy,-1,0,0,"class<`tbl`, `tbl_SQLiteConnection`, `tbl_dbi`, `tbl_lazy`, `tbl_sql`>",1
+dbplyr,select.tbl_lazy,0,0,0,"class<`tbl`, `tbl_SQLiteConnection`, `tbl_dbi`, `tbl_lazy`, `tbl_sql`>",1
+dbplyr,select.tbl_lazy,1,0,0,...,1
+dbplyr,semi_join.tbl_lazy,-1,0,0,"class<`tbl`, `tbl_SQLiteConnection`, `tbl_dbi`, `tbl_lazy`, `tbl_sql`>",1
+dbplyr,semi_join.tbl_lazy,0,0,0,"class<`tbl`, `tbl_SQLiteConnection`, `tbl_dbi`, `tbl_lazy`, `tbl_sql`>",1
+dbplyr,semi_join.tbl_lazy,1,0,0,"class<`data.frame`, `tbl`, `tbl_df`>",1
+dbplyr,semi_join.tbl_lazy,2,0,0,null,1
+dbplyr,semi_join.tbl_lazy,3,0,0,logical,1
+dbplyr,semi_join.tbl_lazy,4,0,0,logical,1
+dbplyr,semi_join.tbl_lazy,5,0,0,...,1
+dbplyr,semi_join.tbl_lazy,6,0,0,null,1
+dbplyr,set_current_con,-1,0,0,"class<`ACCESS`, `DBIConnection`, `TestConnection`>",1
+dbplyr,set_current_con,-1,0,1,"class<`DBIConnection`, `PostgreSQLConnection`, `TestConnection`>",1
+dbplyr,set_current_con,-1,0,2,"class<`DBIConnection`, `SQLiteConnection`, `TestConnection`>",1
+dbplyr,set_current_con,-1,0,3,"class<`DBIConnection`, `TestConnection`>",1
+dbplyr,set_current_con,-1,0,4,"class<`DBIConnection`, `TestCon`, `TestConnection`>",1
+dbplyr,set_current_con,-1,0,5,class<`SQLiteConnection`>,1
+dbplyr,set_current_con,-1,0,6,null,1
+dbplyr,set_current_con,0,0,0,null,1
+dbplyr,set_current_con,0,0,1,"class<`DBIConnection`, `TestConnection`>",1
+dbplyr,set_current_con,0,0,2,"class<`ACCESS`, `DBIConnection`, `TestConnection`>",1
+dbplyr,set_current_con,0,0,3,"class<`DBIConnection`, `PostgreSQLConnection`, `TestConnection`>",1
+dbplyr,set_current_con,0,0,4,"class<`DBIConnection`, `SQLiteConnection`, `TestConnection`>",1
+dbplyr,set_current_con,0,0,5,"class<`DBIConnection`, `TestCon`, `TestConnection`>",1
+dbplyr,set_current_con,0,0,6,class<`SQLiteConnection`>,1
+dbplyr,set_current_context,-1,0,0,character,1
+dbplyr,set_current_context,-1,0,1,list<character>,1
+dbplyr,set_current_context,0,0,0,list<character>,1
+dbplyr,set_current_context,0,0,1,character,1
+dbplyr,set_win_current_frame,-1,0,0,double[],1
+dbplyr,set_win_current_frame,-1,0,1,null,1
+dbplyr,set_win_current_frame,0,0,0,null,1
+dbplyr,set_win_current_frame,0,0,1,double[],1
+dbplyr,set_win_current_group,-1,0,0,character[],1
+dbplyr,set_win_current_group,-1,0,1,null,1
+dbplyr,set_win_current_group,0,0,0,null,1
+dbplyr,set_win_current_group,0,0,1,character[],1
+dbplyr,set_win_current_order,-1,0,0,character,1
+dbplyr,set_win_current_order,-1,0,1,"class<`character`, `sql`>",1
+dbplyr,set_win_current_order,-1,0,2,null,1
+dbplyr,set_win_current_order,0,0,0,null,1
+dbplyr,set_win_current_order,0,0,1,character,1
+dbplyr,set_win_current_order,0,0,2,"class<`character`, `sql`>",1
+dbplyr,show_query.tbl_lazy,-1,0,0,"class<`tbl`, `tbl_Microsoft SQL Server`, `tbl_lazy`>",1
+dbplyr,show_query.tbl_lazy,-1,0,1,"class<`tbl`, `tbl_PostgreSQLConnection`, `tbl_lazy`>",1
+dbplyr,show_query.tbl_lazy,-1,0,2,"class<`tbl`, `tbl_SQLiteConnection`, `tbl_dbi`, `tbl_lazy`, `tbl_sql`>",1
+dbplyr,show_query.tbl_lazy,-1,0,3,"class<`tbl`, `tbl_SQLiteConnection`, `tbl_lazy`>",1
+dbplyr,show_query.tbl_lazy,0,0,0,"class<`tbl`, `tbl_Microsoft SQL Server`, `tbl_lazy`>",1
+dbplyr,show_query.tbl_lazy,0,0,1,"class<`tbl`, `tbl_PostgreSQLConnection`, `tbl_lazy`>",1
+dbplyr,show_query.tbl_lazy,0,0,2,"class<`tbl`, `tbl_SQLiteConnection`, `tbl_dbi`, `tbl_lazy`, `tbl_sql`>",1
+dbplyr,show_query.tbl_lazy,0,0,3,"class<`tbl`, `tbl_SQLiteConnection`, `tbl_lazy`>",1
+dbplyr,show_query.tbl_lazy,1,0,0,...,1
+dbplyr,simulate_access,-1,0,0,"class<`ACCESS`, `DBIConnection`, `TestConnection`>",1
+dbplyr,simulate_dbi,-1,0,0,"class<`ACCESS`, `DBIConnection`, `TestConnection`>",1
+dbplyr,simulate_dbi,-1,0,1,"class<`DBIConnection`, `Microsoft SQL Server`, `TestConnection`>",1
+dbplyr,simulate_dbi,-1,0,2,"class<`DBIConnection`, `PostgreSQLConnection`, `TestConnection`>",1
+dbplyr,simulate_dbi,-1,0,3,"class<`DBIConnection`, `SQLiteConnection`, `TestConnection`>",1
+dbplyr,simulate_dbi,-1,0,4,"class<`DBIConnection`, `TestConnection`>",1
+dbplyr,simulate_dbi,-1,0,5,"class<`DBIConnection`, `TestCon`, `TestConnection`>",1
+dbplyr,simulate_dbi,0,0,0,character[],1
+dbplyr,simulate_mssql,-1,0,0,"class<`DBIConnection`, `Microsoft SQL Server`, `TestConnection`>",1
+dbplyr,simulate_postgres,-1,0,0,"class<`DBIConnection`, `PostgreSQLConnection`, `TestConnection`>",1
+dbplyr,simulate_sqlite,-1,0,0,"class<`DBIConnection`, `SQLiteConnection`, `TestConnection`>",1
+dbplyr,sql,-1,0,0,"class<`character`, `sql`>",1
+dbplyr,sql,0,0,0,...,1
+dbplyr,sql,-1,1,0,"class<`character`, `sql`>",1
+dbplyr,sql,0,1,0,...,1
+dbplyr,sql_aggregate,-1,0,0,class<`function`>,1
+dbplyr,sql_aggregate,0,0,0,character,1
+dbplyr,sql_aggregate,1,0,0,character,1
+dbplyr,sql_aggregate_2,-1,0,0,class<`function`>,1
+dbplyr,sql_aggregate_2,0,0,0,character,1
+dbplyr,sql_build,-1,0,0,"class<`character`, `ident`>",1
+dbplyr,sql_build,-1,0,1,"class<`query`, `select_query`>",1
+dbplyr,sql_build,0,0,0,"class<`op`, `op_base`, `op_base_local`>",1
+dbplyr,sql_build,0,0,1,"class<`op`, `op_base`, `op_base_remote`>",1
+dbplyr,sql_build,0,0,2,"class<`op`, `op_frame`, `op_single`>",1
+dbplyr,sql_build,0,0,3,"class<`op`, `op_group_by`, `op_single`>",1
+dbplyr,sql_build,0,0,4,"class<`op`, `op_order`, `op_single`>",1
+dbplyr,sql_build,0,0,5,"class<`op`, `op_arrange`, `op_single`>",1
+dbplyr,sql_build,0,0,6,"class<`op`, `op_filter`, `op_single`>",1
+dbplyr,sql_build,0,0,7,"class<`op`, `op_head`, `op_single`>",1
+dbplyr,sql_build,0,0,8,"class<`op`, `op_select`, `op_single`>",1
+dbplyr,sql_build,0,0,9,"class<`op`, `op_single`, `op_summarise`>",1
+dbplyr,sql_build,0,0,10,"class<`tbl`, `tbl_TestConnection`, `tbl_lazy`>",1
+dbplyr,sql_build,1,0,0,any,1
+dbplyr,sql_build,2,0,0,...,1
+dbplyr,sql_build.op_arrange,-1,0,0,"class<`query`, `select_query`>",1
+dbplyr,sql_build.op_arrange,0,0,0,"class<`op`, `op_arrange`, `op_single`>",1
+dbplyr,sql_build.op_arrange,1,0,0,class<`SQLiteConnection`>,1
+dbplyr,sql_build.op_arrange,2,0,0,...,1
+dbplyr,sql_build.op_base_local,-1,0,0,"class<`character`, `ident`>",1
+dbplyr,sql_build.op_base_local,0,0,0,"class<`op`, `op_base`, `op_base_local`>",1
+dbplyr,sql_build.op_base_local,1,0,0,any,1
+dbplyr,sql_build.op_base_local,2,0,0,...,1
+dbplyr,sql_build.op_base_remote,-1,0,0,"class<`character`, `ident`>",1
+dbplyr,sql_build.op_base_remote,0,0,0,"class<`op`, `op_base`, `op_base_remote`>",1
+dbplyr,sql_build.op_base_remote,1,0,0,any,1
+dbplyr,sql_build.op_base_remote,2,0,0,...,1
+dbplyr,sql_build.op_filter,-1,0,0,"class<`query`, `select_query`>",1
+dbplyr,sql_build.op_filter,0,0,0,"class<`op`, `op_filter`, `op_single`>",1
+dbplyr,sql_build.op_filter,1,0,0,class<`SQLiteConnection`>,1
+dbplyr,sql_build.op_filter,2,0,0,...,1
+dbplyr,sql_build.op_frame,-1,0,0,"class<`character`, `ident`>",1
+dbplyr,sql_build.op_frame,-1,0,1,"class<`query`, `select_query`>",1
+dbplyr,sql_build.op_frame,0,0,0,"class<`op`, `op_frame`, `op_single`>",1
+dbplyr,sql_build.op_frame,0,0,1,"class<`op`, `op_group_by`, `op_single`>",1
+dbplyr,sql_build.op_frame,0,0,2,"class<`op`, `op_order`, `op_single`>",1
+dbplyr,sql_build.op_frame,1,0,0,any,1
+dbplyr,sql_build.op_frame,2,0,0,...,1
+dbplyr,sql_build.op_group_by,-1,0,0,"class<`character`, `ident`>",1
+dbplyr,sql_build.op_group_by,-1,0,1,"class<`query`, `select_query`>",1
+dbplyr,sql_build.op_group_by,0,0,0,"class<`op`, `op_frame`, `op_single`>",1
+dbplyr,sql_build.op_group_by,0,0,1,"class<`op`, `op_group_by`, `op_single`>",1
+dbplyr,sql_build.op_group_by,0,0,2,"class<`op`, `op_order`, `op_single`>",1
+dbplyr,sql_build.op_group_by,1,0,0,any,1
+dbplyr,sql_build.op_group_by,2,0,0,...,1
+dbplyr,sql_build.op_head,-1,0,0,"class<`query`, `select_query`>",1
+dbplyr,sql_build.op_head,0,0,0,"class<`op`, `op_head`, `op_single`>",1
+dbplyr,sql_build.op_head,1,0,0,any,1
+dbplyr,sql_build.op_head,2,0,0,...,1
+dbplyr,sql_build.op_order,-1,0,0,"class<`character`, `ident`>",1
+dbplyr,sql_build.op_order,-1,0,1,"class<`query`, `select_query`>",1
+dbplyr,sql_build.op_order,0,0,0,"class<`op`, `op_frame`, `op_single`>",1
+dbplyr,sql_build.op_order,0,0,1,"class<`op`, `op_group_by`, `op_single`>",1
+dbplyr,sql_build.op_order,0,0,2,"class<`op`, `op_order`, `op_single`>",1
+dbplyr,sql_build.op_order,1,0,0,any,1
+dbplyr,sql_build.op_order,2,0,0,...,1
+dbplyr,sql_build.op_select,-1,0,0,"class<`query`, `select_query`>",1
+dbplyr,sql_build.op_select,0,0,0,"class<`op`, `op_select`, `op_single`>",1
+dbplyr,sql_build.op_select,1,0,0,"class<`DBIConnection`, `TestConnection`>",1
+dbplyr,sql_build.op_select,1,0,1,class<`SQLiteConnection`>,1
+dbplyr,sql_build.op_select,2,0,0,...,1
+dbplyr,sql_build.op_summarise,-1,0,0,"class<`query`, `select_query`>",1
+dbplyr,sql_build.op_summarise,0,0,0,"class<`op`, `op_single`, `op_summarise`>",1
+dbplyr,sql_build.op_summarise,1,0,0,"class<`DBIConnection`, `SQLiteConnection`, `TestConnection`>",1
+dbplyr,sql_build.op_summarise,1,0,1,class<`SQLiteConnection`>,1
+dbplyr,sql_build.op_summarise,2,0,0,...,1
+dbplyr,sql_build.tbl_lazy,-1,0,0,"class<`query`, `select_query`>",1
+dbplyr,sql_build.tbl_lazy,0,0,0,"class<`tbl`, `tbl_TestConnection`, `tbl_lazy`>",1
+dbplyr,sql_build.tbl_lazy,1,0,0,"class<`DBIConnection`, `TestConnection`>",1
+dbplyr,sql_build.tbl_lazy,2,0,0,...,1
+dbplyr,sql_call2,-1,0,0,"class<`character`, `sql`>",1
+dbplyr,sql_call2,0,0,0,character,1
+dbplyr,sql_call2,1,0,0,...,1
+dbplyr,sql_call2,2,0,0,"class<`DBIConnection`, `PostgreSQLConnection`, `TestConnection`>",1
+dbplyr,sql_call2,2,0,1,"class<`DBIConnection`, `SQLiteConnection`, `TestConnection`>",1
+dbplyr,sql_call2,2,0,2,"class<`DBIConnection`, `TestConnection`>",1
+dbplyr,sql_cast,-1,0,0,class<`function`>,1
+dbplyr,sql_cast,0,0,0,character,1
+dbplyr,sql_clause_from,-1,0,0,"class<`character`, `sql`>",1
+dbplyr,sql_clause_from,0,0,0,"class<`character`, `ident`>",1
+dbplyr,sql_clause_from,0,0,1,"class<`character`, `ident`, `ident_q`>",1
+dbplyr,sql_clause_from,0,0,2,"class<`character`, `sql`>",1
+dbplyr,sql_clause_from,1,0,0,"class<`DBIConnection`, `Microsoft SQL Server`, `TestConnection`>",1
+dbplyr,sql_clause_from,1,0,1,"class<`DBIConnection`, `PostgreSQLConnection`, `TestConnection`>",1
+dbplyr,sql_clause_from,1,0,2,"class<`DBIConnection`, `SQLiteConnection`, `TestConnection`>",1
+dbplyr,sql_clause_from,1,0,3,class<`SQLiteConnection`>,1
+dbplyr,sql_clause_generic,-1,0,0,"class<`character`, `sql`>",1
+dbplyr,sql_clause_generic,-1,0,1,null,1
+dbplyr,sql_clause_generic,0,0,0,character,1
+dbplyr,sql_clause_generic,1,0,0,"class<`character`, `ident`>",1
+dbplyr,sql_clause_generic,1,0,1,"class<`character`, `ident`, `ident_q`>",1
+dbplyr,sql_clause_generic,1,0,2,"class<`character`, `sql`>",1
+dbplyr,sql_clause_generic,1,0,3,character[],1
+dbplyr,sql_clause_generic,1,0,4,null,1
+dbplyr,sql_clause_generic,2,0,0,any,1
+dbplyr,sql_clause_group_by,-1,0,0,"class<`character`, `sql`>",1
+dbplyr,sql_clause_group_by,-1,0,1,null,1
+dbplyr,sql_clause_group_by,0,0,0,"class<`character`, `sql`>",1
+dbplyr,sql_clause_group_by,0,0,1,character[],1
+dbplyr,sql_clause_group_by,0,0,2,null,1
+dbplyr,sql_clause_group_by,1,0,0,any,1
+dbplyr,sql_clause_having,-1,0,0,null,1
+dbplyr,sql_clause_having,0,0,0,character[],1
+dbplyr,sql_clause_having,0,0,1,null,1
+dbplyr,sql_clause_having,1,0,0,any,1
+dbplyr,sql_clause_limit,-1,0,0,"class<`character`, `sql`>",1
+dbplyr,sql_clause_limit,-1,0,1,null,1
+dbplyr,sql_clause_limit,0,0,0,double,1
+dbplyr,sql_clause_limit,0,0,1,null,1
+dbplyr,sql_clause_limit,1,0,0,any,1
+dbplyr,sql_clause_order_by,-1,0,0,"class<`character`, `sql`>",1
+dbplyr,sql_clause_order_by,-1,0,1,null,1
+dbplyr,sql_clause_order_by,0,0,0,"class<`character`, `sql`>",1
+dbplyr,sql_clause_order_by,0,0,1,character[],1
+dbplyr,sql_clause_order_by,0,0,2,null,1
+dbplyr,sql_clause_order_by,1,0,0,any,1
+dbplyr,sql_clause_select,-1,0,0,"class<`character`, `sql`>",1
+dbplyr,sql_clause_select,0,0,0,"class<`character`, `sql`>",1
+dbplyr,sql_clause_select,1,0,0,"class<`DBIConnection`, `PostgreSQLConnection`, `TestConnection`>",1
+dbplyr,sql_clause_select,1,0,1,"class<`DBIConnection`, `SQLiteConnection`, `TestConnection`>",1
+dbplyr,sql_clause_select,1,0,2,class<`SQLiteConnection`>,1
+dbplyr,sql_clause_select,2,0,0,logical,1
+dbplyr,sql_clause_where,-1,0,0,"class<`character`, `sql`>",1
+dbplyr,sql_clause_where,-1,0,1,null,1
+dbplyr,sql_clause_where,0,0,0,"class<`character`, `sql`>",1
+dbplyr,sql_clause_where,0,0,1,character[],1
+dbplyr,sql_clause_where,0,0,2,null,1
+dbplyr,sql_clause_where,1,0,0,any,1
+dbplyr,sql_cot,-1,0,0,class<`function`>,1
+dbplyr,sql_current_con,-1,0,0,"class<`ACCESS`, `DBIConnection`, `TestConnection`>",1
+dbplyr,sql_current_con,-1,0,1,"class<`DBIConnection`, `PostgreSQLConnection`, `TestConnection`>",1
+dbplyr,sql_current_con,-1,0,2,"class<`DBIConnection`, `SQLiteConnection`, `TestConnection`>",1
+dbplyr,sql_current_con,-1,0,3,"class<`DBIConnection`, `TestConnection`>",1
+dbplyr,sql_current_con,-1,0,4,"class<`DBIConnection`, `TestCon`, `TestConnection`>",1
+dbplyr,sql_current_con,-1,0,5,class<`SQLiteConnection`>,1
+dbplyr,sql_data_mask,-1,0,0,environment,1
+dbplyr,sql_data_mask,0,0,0,class<`call`>,1
+dbplyr,sql_data_mask,0,0,1,"class<`formula`, `quosure`>",1
+dbplyr,sql_data_mask,0,0,2,class<`name`>,1
+dbplyr,sql_data_mask,1,0,0,class<`sql_variant`>,1
+dbplyr,sql_data_mask,2,0,0,any,1
+dbplyr,sql_data_mask,3,0,0,logical,1
+dbplyr,sql_data_mask,4,0,0,logical,1
+dbplyr,sql_escape_ident.SQLiteConnection,-1,0,0,character[],1
+dbplyr,sql_escape_ident.SQLiteConnection,-1,0,1,"class<`character`, `ident`>",1
+dbplyr,sql_escape_ident.SQLiteConnection,0,0,0,"class<`DBIConnection`, `SQLiteConnection`, `TestConnection`>",1
+dbplyr,sql_escape_ident.SQLiteConnection,0,0,1,class<`SQLiteConnection`>,1
+dbplyr,sql_escape_ident.SQLiteConnection,0,0,2,"class<`DBIConnection`, `Microsoft SQL Server`, `TestConnection`>",1
+dbplyr,sql_escape_ident.SQLiteConnection,0,0,3,"class<`DBIConnection`, `PostgreSQLConnection`, `TestConnection`>",1
+dbplyr,sql_escape_ident.SQLiteConnection,0,0,4,"class<`DBIConnection`, `TestConnection`>",1
+dbplyr,sql_escape_ident.SQLiteConnection,0,0,5,"class<`DBIConnection`, `TestCon`, `TestConnection`>",1
+dbplyr,sql_escape_ident.SQLiteConnection,0,0,6,"class<`ACCESS`, `DBIConnection`, `TestConnection`>",1
+dbplyr,sql_escape_ident.SQLiteConnection,1,0,0,character[],1
+dbplyr,sql_escape_ident.SQLiteConnection,1,0,1,"class<`character`, `ident`>",1
+dbplyr,sql_escape_ident.TestConnection,-1,0,0,character[],1
+dbplyr,sql_escape_ident.TestConnection,-1,0,1,"class<`character`, `ident`>",1
+dbplyr,sql_escape_ident.TestConnection,0,0,0,"class<`DBIConnection`, `SQLiteConnection`, `TestConnection`>",1
+dbplyr,sql_escape_ident.TestConnection,0,0,1,class<`SQLiteConnection`>,1
+dbplyr,sql_escape_ident.TestConnection,0,0,2,"class<`DBIConnection`, `Microsoft SQL Server`, `TestConnection`>",1
+dbplyr,sql_escape_ident.TestConnection,0,0,3,"class<`DBIConnection`, `PostgreSQLConnection`, `TestConnection`>",1
+dbplyr,sql_escape_ident.TestConnection,0,0,4,"class<`DBIConnection`, `TestConnection`>",1
+dbplyr,sql_escape_ident.TestConnection,0,0,5,"class<`DBIConnection`, `TestCon`, `TestConnection`>",1
+dbplyr,sql_escape_ident.TestConnection,0,0,6,"class<`ACCESS`, `DBIConnection`, `TestConnection`>",1
+dbplyr,sql_escape_ident.TestConnection,1,0,0,character[],1
+dbplyr,sql_escape_ident.TestConnection,1,0,1,"class<`character`, `ident`>",1
+dbplyr,sql_escape_logical,-1,0,0,character,1
+dbplyr,sql_escape_logical,0,0,0,"class<`DBIConnection`, `TestConnection`>",1
+dbplyr,sql_escape_logical,1,0,0,null,1
+dbplyr,sql_escape_logical.DBIConnection,-1,0,0,character,1
+dbplyr,sql_escape_logical.DBIConnection,0,0,0,"class<`DBIConnection`, `TestConnection`>",1
+dbplyr,sql_escape_logical.DBIConnection,1,0,0,null,1
+dbplyr,sql_escape_string.DBIConnection,-1,0,0,class<`SQL`>,1
+dbplyr,sql_escape_string.DBIConnection,0,0,0,class<`SQLiteConnection`>,1
+dbplyr,sql_escape_string.DBIConnection,1,0,0,character,1
+dbplyr,sql_escape_string.TestConnection,-1,0,0,character[],1
+dbplyr,sql_escape_string.TestConnection,0,0,0,"class<`DBIConnection`, `TestConnection`>",1
+dbplyr,sql_escape_string.TestConnection,1,0,0,character[],1
+dbplyr,sql_expr,-1,0,0,"class<`character`, `sql`>",1
+dbplyr,sql_expr,0,0,0,any,1
+dbplyr,sql_expr,1,0,0,any,1
+dbplyr,sql_infix,-1,0,0,class<`function`>,1
+dbplyr,sql_infix,0,0,0,character,1
+dbplyr,sql_infix,1,0,0,logical,1
+dbplyr,sqlite_version,-1,0,0,class<`numeric_version`>,1
+dbplyr,sql_log,-1,0,0,class<`function`>,1
+dbplyr,sql_not_supported,-1,0,0,class<`function`>,1
+dbplyr,sql_not_supported,0,0,0,character,1
+dbplyr,sql_optimise,-1,0,0,"class<`character`, `ident`>",1
+dbplyr,sql_optimise,-1,0,1,"class<`query`, `select_query`>",1
+dbplyr,sql_optimise,0,0,0,"class<`character`, `ident`>",1
+dbplyr,sql_optimise,0,0,1,"class<`query`, `select_query`>",1
+dbplyr,sql_optimise,1,0,0,any,1
+dbplyr,sql_optimise,2,0,0,...,1
+dbplyr,sql_optimise.ident,-1,0,0,"class<`character`, `ident`>",1
+dbplyr,sql_optimise.ident,0,0,0,"class<`character`, `ident`>",1
+dbplyr,sql_optimise.ident,1,0,0,any,1
+dbplyr,sql_optimise.ident,2,0,0,...,1
+dbplyr,sql_optimise.select_query,-1,0,0,"class<`query`, `select_query`>",1
+dbplyr,sql_optimise.select_query,0,0,0,"class<`query`, `select_query`>",1
+dbplyr,sql_optimise.select_query,1,0,0,any,1
+dbplyr,sql_optimise.select_query,2,0,0,...,1
+dbplyr,sql_paste,-1,0,0,class<`function`>,1
+dbplyr,sql_paste,0,0,0,character,1
+dbplyr,sql_paste,1,0,0,character,1
+dbplyr,sql_paste_infix,-1,0,0,class<`function`>,1
+dbplyr,sql_paste_infix,0,0,0,character,1
+dbplyr,sql_paste_infix,1,0,0,character,1
+dbplyr,sql_paste_infix,2,0,0,class<`function`>,1
+dbplyr,sql_prefix,-1,0,0,class<`function`>,1
+dbplyr,sql_prefix,0,0,0,character,1
+dbplyr,sql_prefix,1,0,0,null,1
+dbplyr,sql_quote,-1,0,0,character[],1
+dbplyr,sql_quote,-1,0,1,"class<`character`, `ident`>",1
+dbplyr,sql_quote,0,0,0,^character[],1
+dbplyr,sql_quote,0,0,1,"class<`character`, `ident`>",1
+dbplyr,sql_quote,1,0,0,character,1
+dbplyr,sql_render,-1,0,0,"class<`character`, `ident`>",1
+dbplyr,sql_render,-1,0,1,"class<`character`, `sql`>",1
+dbplyr,sql_render,0,0,0,"class<`character`, `ident`>",1
+dbplyr,sql_render,0,0,1,"class<`op`, `op_arrange`, `op_single`>",1
+dbplyr,sql_render,0,0,2,"class<`op`, `op_base`, `op_base_remote`>",1
+dbplyr,sql_render,0,0,3,"class<`op`, `op_filter`, `op_single`>",1
+dbplyr,sql_render,0,0,4,"class<`op`, `op_head`, `op_single`>",1
+dbplyr,sql_render,0,0,5,"class<`op`, `op_select`, `op_single`>",1
+dbplyr,sql_render,0,0,6,"class<`op`, `op_single`, `op_summarise`>",1
+dbplyr,sql_render,0,0,7,"class<`query`, `select_query`>",1
+dbplyr,sql_render,0,0,8,"class<`tbl`, `tbl_Microsoft SQL Server`, `tbl_lazy`>",1
+dbplyr,sql_render,0,0,9,"class<`tbl`, `tbl_PostgreSQLConnection`, `tbl_lazy`>",1
+dbplyr,sql_render,0,0,10,"class<`tbl`, `tbl_SQLiteConnection`, `tbl_dbi`, `tbl_lazy`, `tbl_sql`>",1
+dbplyr,sql_render,0,0,11,"class<`tbl`, `tbl_SQLiteConnection`, `tbl_lazy`>",1
+dbplyr,sql_render,1,0,0,any,1
+dbplyr,sql_render,2,0,0,...,1
+dbplyr,sql_render,3,0,0,any,1
+dbplyr,sql_render.ident,-1,0,0,"class<`character`, `ident`>",1
+dbplyr,sql_render.ident,-1,0,1,"class<`character`, `sql`>",1
+dbplyr,sql_render.ident,0,0,0,"class<`character`, `ident`>",1
+dbplyr,sql_render.ident,1,0,0,any,1
+dbplyr,sql_render.ident,2,0,0,...,1
+dbplyr,sql_render.ident,3,0,0,logical,1
+dbplyr,sql_render.op,-1,0,0,"class<`character`, `sql`>",1
+dbplyr,sql_render.op,0,0,0,"class<`op`, `op_arrange`, `op_single`>",1
+dbplyr,sql_render.op,0,0,1,"class<`op`, `op_base`, `op_base_remote`>",1
+dbplyr,sql_render.op,0,0,2,"class<`op`, `op_filter`, `op_single`>",1
+dbplyr,sql_render.op,0,0,3,"class<`op`, `op_head`, `op_single`>",1
+dbplyr,sql_render.op,0,0,4,"class<`op`, `op_select`, `op_single`>",1
+dbplyr,sql_render.op,0,0,5,"class<`op`, `op_single`, `op_summarise`>",1
+dbplyr,sql_render.op,1,0,0,class<`SQLiteConnection`>,1
+dbplyr,sql_render.op,1,0,1,"class<`DBIConnection`, `Microsoft SQL Server`, `TestConnection`>",1
+dbplyr,sql_render.op,1,0,2,"class<`DBIConnection`, `PostgreSQLConnection`, `TestConnection`>",1
+dbplyr,sql_render.op,1,0,3,"class<`DBIConnection`, `SQLiteConnection`, `TestConnection`>",1
+dbplyr,sql_render.op,2,0,0,...,1
+dbplyr,sql_render.op,3,0,0,any,1
+dbplyr,sql_render.select_query,-1,0,0,"class<`character`, `sql`>",1
+dbplyr,sql_render.select_query,0,0,0,"class<`query`, `select_query`>",1
+dbplyr,sql_render.select_query,1,0,0,"class<`DBIConnection`, `Microsoft SQL Server`, `TestConnection`>",1
+dbplyr,sql_render.select_query,1,0,1,"class<`DBIConnection`, `PostgreSQLConnection`, `TestConnection`>",1
+dbplyr,sql_render.select_query,1,0,2,"class<`DBIConnection`, `SQLiteConnection`, `TestConnection`>",1
+dbplyr,sql_render.select_query,1,0,3,class<`SQLiteConnection`>,1
+dbplyr,sql_render.select_query,2,0,0,...,1
+dbplyr,sql_render.select_query,3,0,0,any,1
+dbplyr,sql_render.tbl_lazy,-1,0,0,"class<`character`, `sql`>",1
+dbplyr,sql_render.tbl_lazy,0,0,0,"class<`tbl`, `tbl_Microsoft SQL Server`, `tbl_lazy`>",1
+dbplyr,sql_render.tbl_lazy,0,0,1,"class<`tbl`, `tbl_PostgreSQLConnection`, `tbl_lazy`>",1
+dbplyr,sql_render.tbl_lazy,0,0,2,"class<`tbl`, `tbl_SQLiteConnection`, `tbl_dbi`, `tbl_lazy`, `tbl_sql`>",1
+dbplyr,sql_render.tbl_lazy,0,0,3,"class<`tbl`, `tbl_SQLiteConnection`, `tbl_lazy`>",1
+dbplyr,sql_render.tbl_lazy,1,0,0,"class<`DBIConnection`, `Microsoft SQL Server`, `TestConnection`>",1
+dbplyr,sql_render.tbl_lazy,1,0,1,"class<`DBIConnection`, `PostgreSQLConnection`, `TestConnection`>",1
+dbplyr,sql_render.tbl_lazy,1,0,2,class<`SQLiteConnection`>,1
+dbplyr,sql_render.tbl_lazy,1,0,3,"class<`DBIConnection`, `SQLiteConnection`, `TestConnection`>",1
+dbplyr,sql_render.tbl_lazy,2,0,0,...,1
+dbplyr,sql_render.tbl_lazy,3,0,0,logical,1
+dbplyr,sql_select.DBIConnection,-1,0,0,"class<`character`, `sql`>",1
+dbplyr,sql_select.DBIConnection,0,0,0,"class<`DBIConnection`, `PostgreSQLConnection`, `TestConnection`>",1
+dbplyr,sql_select.DBIConnection,0,0,1,"class<`DBIConnection`, `SQLiteConnection`, `TestConnection`>",1
+dbplyr,sql_select.DBIConnection,0,0,2,class<`SQLiteConnection`>,1
+dbplyr,sql_select.DBIConnection,1,0,0,"class<`character`, `sql`>",1
+dbplyr,sql_select.DBIConnection,2,0,0,"class<`character`, `ident`>",1
+dbplyr,sql_select.DBIConnection,2,0,1,"class<`character`, `ident`, `ident_q`>",1
+dbplyr,sql_select.DBIConnection,2,0,2,"class<`character`, `sql`>",1
+dbplyr,sql_select.DBIConnection,3,0,0,character[],1
+dbplyr,sql_select.DBIConnection,3,0,1,"class<`character`, `sql`>",1
+dbplyr,sql_select.DBIConnection,3,0,2,null,1
+dbplyr,sql_select.DBIConnection,4,0,0,character[],1
+dbplyr,sql_select.DBIConnection,4,0,1,"class<`character`, `sql`>",1
+dbplyr,sql_select.DBIConnection,4,0,2,null,1
+dbplyr,sql_select.DBIConnection,5,0,0,character[],1
+dbplyr,sql_select.DBIConnection,5,0,1,null,1
+dbplyr,sql_select.DBIConnection,6,0,0,character[],1
+dbplyr,sql_select.DBIConnection,6,0,1,"class<`character`, `sql`>",1
+dbplyr,sql_select.DBIConnection,6,0,2,null,1
+dbplyr,sql_select.DBIConnection,7,0,0,double,1
+dbplyr,sql_select.DBIConnection,7,0,1,null,1
+dbplyr,sql_select.Microsoft SQL Server,-1,0,0,"class<`character`, `sql`>",1
+dbplyr,sql_select.Microsoft SQL Server,0,0,0,"class<`DBIConnection`, `Microsoft SQL Server`, `TestConnection`>",1
+dbplyr,sql_select.Microsoft SQL Server,1,0,0,"class<`character`, `sql`>",1
+dbplyr,sql_select.Microsoft SQL Server,2,0,0,"class<`character`, `ident`>",1
+dbplyr,sql_select.Microsoft SQL Server,3,0,0,character[],1
+dbplyr,sql_select.Microsoft SQL Server,4,0,0,character[],1
+dbplyr,sql_select.Microsoft SQL Server,5,0,0,character[],1
+dbplyr,sql_select.Microsoft SQL Server,6,0,0,character[],1
+dbplyr,sql_select.Microsoft SQL Server,7,0,0,double,1
+dbplyr,sql_subquery.DBIConnection,-1,0,0,"class<`character`, `ident`>",1
+dbplyr,sql_subquery.DBIConnection,0,0,0,"class<`DBIConnection`, `Microsoft SQL Server`, `TestConnection`>",1
+dbplyr,sql_subquery.DBIConnection,0,0,1,"class<`DBIConnection`, `PostgreSQLConnection`, `TestConnection`>",1
+dbplyr,sql_subquery.DBIConnection,1,0,0,"class<`character`, `ident`>",1
+dbplyr,sql_subquery.DBIConnection,2,0,0,null,1
+dbplyr,sql_subquery.DBIConnection,3,0,0,...,1
+dbplyr,sql_subquery.SQLiteConnection,-1,0,0,"class<`character`, `ident`>",1
+dbplyr,sql_subquery.SQLiteConnection,-1,0,1,"class<`character`, `ident`, `ident_q`>",1
+dbplyr,sql_subquery.SQLiteConnection,-1,0,2,"class<`character`, `sql`>",1
+dbplyr,sql_subquery.SQLiteConnection,0,0,0,"class<`DBIConnection`, `SQLiteConnection`, `TestConnection`>",1
+dbplyr,sql_subquery.SQLiteConnection,0,0,1,class<`SQLiteConnection`>,1
+dbplyr,sql_subquery.SQLiteConnection,1,0,0,"class<`character`, `ident`>",1
+dbplyr,sql_subquery.SQLiteConnection,1,0,1,"class<`character`, `ident`, `ident_q`>",1
+dbplyr,sql_subquery.SQLiteConnection,1,0,2,"class<`character`, `sql`>",1
+dbplyr,sql_subquery.SQLiteConnection,2,0,0,null,1
+dbplyr,sql_subquery.SQLiteConnection,2,0,1,character,1
+dbplyr,sql_subquery.SQLiteConnection,3,0,0,...,1
+dbplyr,sql_switch,-1,0,0,"class<`character`, `sql`>",1
+dbplyr,sql_switch,0,0,0,"class<`character`, `sql`>",1
+dbplyr,sql_switch,1,0,0,...,1
+dbplyr,sql_translate_env.ACCESS,-1,0,0,class<`sql_variant`>,1
+dbplyr,sql_translate_env.ACCESS,0,0,0,"class<`ACCESS`, `DBIConnection`, `TestConnection`>",1
+dbplyr,sql_translate_env.DBIConnection,-1,0,0,class<`sql_variant`>,1
+dbplyr,sql_translate_env.DBIConnection,0,0,0,"class<`DBIConnection`, `TestConnection`>",1
+dbplyr,sql_translate_env.PostgreSQLConnection,-1,0,0,class<`sql_variant`>,1
+dbplyr,sql_translate_env.PostgreSQLConnection,0,0,0,"class<`DBIConnection`, `PostgreSQLConnection`, `TestConnection`>",1
+dbplyr,sql_translate_env.SQLiteConnection,-1,0,0,class<`sql_variant`>,1
+dbplyr,sql_translate_env.SQLiteConnection,0,0,0,"class<`DBIConnection`, `SQLiteConnection`, `TestConnection`>",1
+dbplyr,sql_translate_env.SQLiteConnection,0,0,1,class<`SQLiteConnection`>,1
+dbplyr,sql_translator,-1,0,0,environment,1
+dbplyr,sql_translator,0,0,0,...,1
+dbplyr,sql_translator,1,0,0,list<any>,1
+dbplyr,sql_translator,2,0,0,environment,1
+dbplyr,sql_variant,-1,0,0,class<`sql_variant`>,1
+dbplyr,sql_variant,0,0,0,environment,1
+dbplyr,sql_variant,1,0,0,environment,1
+dbplyr,sql_variant,2,0,0,environment,1
+dbplyr,sql_vector,-1,0,0,"class<`character`, `sql`>",1
+dbplyr,sql_vector,0,0,0,character[],1
+dbplyr,sql_vector,0,0,1,"class<`character`, `sql`>",1
+dbplyr,sql_vector,0,0,2,class<`SQL`>,1
+dbplyr,sql_vector,0,0,3,list<any>,1
+dbplyr,sql_vector,1,0,0,any,1
+dbplyr,sql_vector,2,0,0,null,1
+dbplyr,sql_vector,2,0,1,character,1
+dbplyr,sql_vector,3,0,0,"class<`DBIConnection`, `SQLiteConnection`, `TestConnection`>",1
+dbplyr,sql_vector,3,0,1,"class<`DBIConnection`, `Microsoft SQL Server`, `TestConnection`>",1
+dbplyr,sql_vector,3,0,2,"class<`DBIConnection`, `PostgreSQLConnection`, `TestConnection`>",1
+dbplyr,sql_vector,3,0,3,"class<`DBIConnection`, `TestConnection`>",1
+dbplyr,sql_vector,3,0,4,"class<`DBIConnection`, `TestCon`, `TestConnection`>",1
+dbplyr,sql_vector,3,0,5,class<`SQLiteConnection`>,1
+dbplyr,sql_vector,3,0,6,"class<`ACCESS`, `DBIConnection`, `TestConnection`>",1
+dbplyr,src_dbi,-1,0,0,"class<`src`, `src_SQLiteConnection`, `src_dbi`, `src_sql`>",1
+dbplyr,src_dbi,-1,0,1,"class<`src`, `src_Microsoft SQL Server`, `src_dbi`, `src_sql`>",1
+dbplyr,src_dbi,-1,0,2,"class<`src`, `src_PostgreSQLConnection`, `src_dbi`, `src_sql`>",1
+dbplyr,src_dbi,-1,0,3,"class<`src`, `src_TestConnection`, `src_dbi`, `src_sql`>",1
+dbplyr,src_dbi,0,0,0,class<`SQLiteConnection`>,1
+dbplyr,src_dbi,0,0,1,"class<`DBIConnection`, `Microsoft SQL Server`, `TestConnection`>",1
+dbplyr,src_dbi,0,0,2,"class<`DBIConnection`, `PostgreSQLConnection`, `TestConnection`>",1
+dbplyr,src_dbi,0,0,3,"class<`DBIConnection`, `SQLiteConnection`, `TestConnection`>",1
+dbplyr,src_dbi,0,0,4,"class<`DBIConnection`, `TestConnection`>",1
+dbplyr,src_dbi,1,0,0,logical,1
+dbplyr,src_memdb,-1,0,0,"class<`src`, `src_SQLiteConnection`, `src_dbi`, `src_sql`>",1
+dbplyr,src_tbls.src_sql,-1,0,0,character[],1
+dbplyr,src_tbls.src_sql,0,0,0,"class<`src`, `src_SQLiteConnection`, `src_dbi`, `src_sql`>",1
+dbplyr,src_tbls.src_sql,1,0,0,...,1
+dbplyr,succeeds,-1,0,0,logical,1
+dbplyr,succeeds,0,0,0,"class<`src`, `src_SQLiteConnection`, `src_dbi`, `src_sql`>",1
+dbplyr,succeeds,1,0,0,logical,1
+dbplyr,summarise.tbl_lazy,-1,0,0,"class<`tbl`, `tbl_SQLiteConnection`, `tbl_dbi`, `tbl_lazy`, `tbl_sql`>",1
+dbplyr,summarise.tbl_lazy,-1,0,1,"class<`tbl`, `tbl_SQLiteConnection`, `tbl_lazy`>",1
+dbplyr,summarise.tbl_lazy,0,0,0,"class<`tbl`, `tbl_SQLiteConnection`, `tbl_dbi`, `tbl_lazy`, `tbl_sql`>",1
+dbplyr,summarise.tbl_lazy,0,0,1,"class<`tbl`, `tbl_SQLiteConnection`, `tbl_lazy`>",1
+dbplyr,summarise.tbl_lazy,1,0,0,...,1
+dbplyr,tail.tbl_sql,-1,0,0,any,1
+dbplyr,tail.tbl_sql,0,0,0,"class<`tbl`, `tbl_SQLiteConnection`, `tbl_dbi`, `tbl_lazy`, `tbl_sql`>",1
+dbplyr,tail.tbl_sql,1,0,0,integer,1
+dbplyr,tail.tbl_sql,2,0,0,...,1
+dbplyr,tbl_lazy,-1,0,0,"class<`tbl`, `tbl_Microsoft SQL Server`, `tbl_lazy`>",1
+dbplyr,tbl_lazy,-1,0,1,"class<`tbl`, `tbl_PostgreSQLConnection`, `tbl_lazy`>",1
+dbplyr,tbl_lazy,-1,0,2,"class<`tbl`, `tbl_SQLiteConnection`, `tbl_lazy`>",1
+dbplyr,tbl_lazy,-1,0,3,"class<`tbl`, `tbl_TestConnection`, `tbl_lazy`>",1
+dbplyr,tbl_lazy,0,0,0,"class<`data.frame`, `tbl`, `tbl_df`>",1
+dbplyr,tbl_lazy,0,0,1,class<`data.frame`>,1
+dbplyr,tbl_lazy,1,0,0,"class<`DBIConnection`, `Microsoft SQL Server`, `TestConnection`>",1
+dbplyr,tbl_lazy,1,0,1,"class<`DBIConnection`, `PostgreSQLConnection`, `TestConnection`>",1
+dbplyr,tbl_lazy,1,0,2,"class<`DBIConnection`, `SQLiteConnection`, `TestConnection`>",1
+dbplyr,tbl_lazy,1,0,3,"class<`DBIConnection`, `TestConnection`>",1
+dbplyr,tbl_lazy,2,0,0,null,1
+dbplyr,tbl_memdb,-1,0,0,"class<`tbl`, `tbl_SQLiteConnection`, `tbl_dbi`, `tbl_lazy`, `tbl_sql`>",1
+dbplyr,tbl_memdb,0,0,0,class<`data.frame`>,1
+dbplyr,tbl_memdb,1,0,0,character,1
+dbplyr,tbl_sql,-1,0,0,"class<`tbl`, `tbl_SQLiteConnection`, `tbl_dbi`, `tbl_lazy`, `tbl_sql`>",1
+dbplyr,tbl_sql,0,0,0,character[],1
+dbplyr,tbl_sql,1,0,0,"class<`src`, `src_SQLiteConnection`, `src_dbi`, `src_sql`>",1
+dbplyr,tbl_sql,2,0,0,character,1
+dbplyr,tbl_sql,2,0,1,"class<`character`, `ident`, `ident_q`>",1
+dbplyr,tbl_sql,2,0,2,"class<`character`, `sql`>",1
+dbplyr,tbl_sql,3,0,0,...,1
+dbplyr,tbl_sql,4,0,0,null,1
+dbplyr,tbl.src_dbi,-1,0,0,"class<`tbl`, `tbl_SQLiteConnection`, `tbl_dbi`, `tbl_lazy`, `tbl_sql`>",1
+dbplyr,tbl.src_dbi,0,0,0,"class<`src`, `src_SQLiteConnection`, `src_dbi`, `src_sql`>",1
+dbplyr,tbl.src_dbi,1,0,0,character,1
+dbplyr,tbl.src_dbi,1,0,1,"class<`character`, `ident`, `ident_q`>",1
+dbplyr,tbl.src_dbi,1,0,2,"class<`character`, `sql`>",1
+dbplyr,tbl.src_dbi,2,0,0,...,1
+dbplyr,tbl_vars.tbl_lazy,-1,0,0,character[],1
+dbplyr,tbl_vars.tbl_lazy,0,0,0,"class<`tbl`, `tbl_SQLiteConnection`, `tbl_dbi`, `tbl_lazy`, `tbl_sql`>",1
+dbplyr,translate_sql,-1,0,0,"class<`character`, `sql`>",1
+dbplyr,translate_sql,0,0,0,...,1
+dbplyr,translate_sql,1,0,0,"class<`ACCESS`, `DBIConnection`, `TestConnection`>",1
+dbplyr,translate_sql,1,0,1,"class<`DBIConnection`, `PostgreSQLConnection`, `TestConnection`>",1
+dbplyr,translate_sql,1,0,2,"class<`DBIConnection`, `SQLiteConnection`, `TestConnection`>",1
+dbplyr,translate_sql,1,0,3,"class<`DBIConnection`, `TestConnection`>",1
+dbplyr,translate_sql,1,0,4,"class<`DBIConnection`, `TestCon`, `TestConnection`>",1
+dbplyr,translate_sql,2,0,0,any,1
+dbplyr,translate_sql,3,0,0,null,1
+dbplyr,translate_sql,3,0,1,character,1
+dbplyr,translate_sql,4,0,0,null,1
+dbplyr,translate_sql,4,0,1,character,1
+dbplyr,translate_sql,5,0,0,null,1
+dbplyr,translate_sql,6,0,0,logical,1
+dbplyr,translate_sql_,-1,0,0,"class<`character`, `sql`>",1
+dbplyr,translate_sql_,0,0,0,"class<`list`, `quosures`>",1
+dbplyr,translate_sql_,0,0,1,list<class<`call`>>,1
+dbplyr,translate_sql_,0,0,2,"list<class<`formula`, `quosure`>>",1
+dbplyr,translate_sql_,0,0,3,null,1
+dbplyr,translate_sql_,0,0,4,list<class<`name`>>,1
+dbplyr,translate_sql_,0,0,5,"list<class<`name`> | class<`formula`, `quosure`>>",1
+dbplyr,translate_sql_,1,0,0,any,1
+dbplyr,translate_sql_,2,0,0,any,1
+dbplyr,translate_sql_,3,0,0,any,1
+dbplyr,translate_sql_,4,0,0,any,1
+dbplyr,translate_sql_,5,0,0,logical,1
+dbplyr,translate_sql_,6,0,0,any,1
+dbplyr,transmute.tbl_lazy,-1,0,0,"class<`tbl`, `tbl_SQLiteConnection`, `tbl_dbi`, `tbl_lazy`, `tbl_sql`>",1
+dbplyr,transmute.tbl_lazy,0,0,0,"class<`tbl`, `tbl_SQLiteConnection`, `tbl_dbi`, `tbl_lazy`, `tbl_sql`>",1
+dbplyr,transmute.tbl_lazy,1,0,0,...,1
+dbplyr,unique_name,-1,0,0,character,1
+dbplyr,unique_table_name,-1,0,0,character,1
+dbplyr,uses_window_fun,-1,0,0,logical,1
+dbplyr,uses_window_fun,0,0,0,"list<class<`formula`, `quosure`>>",1
+dbplyr,uses_window_fun,1,0,0,class<`SQLiteConnection`>,1
+dbplyr,win_aggregate,-1,0,0,class<`function`>,1
+dbplyr,win_aggregate,0,0,0,character,1
+dbplyr,win_aggregate_2,-1,0,0,class<`function`>,1
+dbplyr,win_aggregate_2,0,0,0,character,1
+dbplyr,win_current_frame,-1,0,0,double[],1
+dbplyr,win_current_frame,-1,0,1,null,1
+dbplyr,win_current_group,-1,0,0,character[],1
+dbplyr,win_current_group,-1,0,1,null,1
+dbplyr,win_current_order,-1,0,0,character,1
+dbplyr,win_current_order,-1,0,1,"class<`character`, `sql`>",1
+dbplyr,win_current_order,-1,0,2,null,1
+dbplyr,window_frame,-1,0,0,"class<`tbl`, `tbl_TestConnection`, `tbl_lazy`>",1
+dbplyr,window_frame,0,0,0,"class<`tbl`, `tbl_TestConnection`, `tbl_lazy`>",1
+dbplyr,window_frame,1,0,0,double,1
+dbplyr,window_frame,2,0,0,double,1
+dbplyr,window_order,-1,0,0,"class<`tbl`, `tbl_TestConnection`, `tbl_lazy`>",1
+dbplyr,window_order,0,0,0,"class<`tbl`, `tbl_TestConnection`, `tbl_lazy`>",1
+dbplyr,window_order,1,0,0,...,1
+dbplyr,win_over,-1,0,0,"class<`character`, `sql`>",1
+dbplyr,win_over,0,0,0,"class<`character`, `sql`>",1
+dbplyr,win_over,1,0,0,character[],1
+dbplyr,win_over,1,0,1,null,1
+dbplyr,win_over,2,0,0,"class<`character`, `sql`>",1
+dbplyr,win_over,2,0,1,null,1
+dbplyr,win_over,2,0,2,character[],1
+dbplyr,win_over,3,0,0,double[],1
+dbplyr,win_over,3,0,1,null,1
+dbplyr,win_over,4,0,0,"class<`DBIConnection`, `TestConnection`>",1
+dbplyr,with_transaction,-1,0,0,logical,1
+dbplyr,with_transaction,0,0,0,class<`SQLiteConnection`>,1
+dbplyr,with_transaction,1,0,0,integer,1
+dbscan,adjacencylist,-1,0,0,list<integer[]>,1
+dbscan,adjacencylist,0,0,0,"class<`NN`, `frNN`>",1
+dbscan,adjacencylist,0,0,1,"class<`NN`, `kNN`>",1
+dbscan,adjacencylist,0,0,2,"class<`NN`, `kNN`, `sNN`>",1
+dbscan,adjacencylist,1,0,0,...,1
+dbscan,adjacencylist.frNN,-1,0,0,list<integer[]>,1
+dbscan,adjacencylist.frNN,0,0,0,"class<`NN`, `frNN`>",1
+dbscan,adjacencylist.frNN,1,0,0,...,1
+dbscan,adjacencylist.kNN,-1,0,0,list<integer[]>,1
+dbscan,adjacencylist.kNN,0,0,0,"class<`NN`, `kNN`>",1
+dbscan,adjacencylist.kNN,0,0,1,"class<`NN`, `kNN`, `sNN`>",1
+dbscan,adjacencylist.kNN,1,0,0,...,1
+dbscan,all_children,-1,0,0,integer[],1
+dbscan,all_children,0,0,0,list<integer[]>,1
+dbscan,all_children,1,0,0,double,1
+dbscan,all_children,2,0,0,logical,1
+dbscan,as.dendrogram.optics,-1,0,0,any,1
+dbscan,as.dendrogram.optics,0,0,0,class<`optics`>,1
+dbscan,as.dendrogram.optics,1,0,0,...,1
+dbscan,as.dendrogram.reachability,-1,0,0,class<`dendrogram`>,1
+dbscan,as.dendrogram.reachability,0,0,0,class<`reachability`>,1
+dbscan,as.dendrogram.reachability,1,0,0,...,1
+dbscan,as.reachability,-1,0,0,class<`reachability`>,1
+dbscan,as.reachability,0,0,0,class<`dendrogram`>,1
+dbscan,as.reachability,0,0,1,class<`optics`>,1
+dbscan,as.reachability,1,0,0,...,1
+dbscan,as.reachability.dendrogram,-1,0,0,class<`reachability`>,1
+dbscan,as.reachability.dendrogram,0,0,0,class<`dendrogram`>,1
+dbscan,as.reachability.dendrogram,1,0,0,...,1
+dbscan,as.reachability.optics,-1,0,0,class<`reachability`>,1
+dbscan,as.reachability.optics,0,0,0,class<`optics`>,1
+dbscan,as.reachability.optics,1,0,0,...,1
+dbscan,buildDendrogram,-1,0,0,class<`dendrogram`>,1
+dbscan,buildDendrogram,0,0,0,class<`hclust`>,1
+dbscan,computeStability,-1,0,0,list<list<double[]>>,1
+dbscan,computeStability,0,0,0,class<`hclust`>,1
+dbscan,computeStability,1,0,0,double,1
+dbscan,computeStability,2,0,0,logical,1
+dbscan,dbscan,-1,0,0,any,1
+dbscan,dbscan,0,0,0,class<`dist`>,1
+dbscan,dbscan,0,0,1,class<`matrix`>,1
+dbscan,dbscan,0,0,2,class<`data.frame`>,1
+dbscan,dbscan,0,0,3,"class<`NN`, `frNN`>",1
+dbscan,dbscan,1,0,0,any,1
+dbscan,dbscan,2,0,0,double,1
+dbscan,dbscan,3,0,0,null,1
+dbscan,dbscan,4,0,0,logical,1
+dbscan,dbscan,5,0,0,...,1
+dbscan,dbscan_density_int,-1,0,0,integer[],1
+dbscan,dbscan_density_int,0,0,0,class<`matrix`>,1
+dbscan,dbscan_density_int,1,0,0,double,1
+dbscan,dbscan_density_int,2,0,0,integer,1
+dbscan,dbscan_density_int,3,0,0,integer,1
+dbscan,dbscan_density_int,4,0,0,integer,1
+dbscan,dbscan_density_int,5,0,0,double,1
+dbscan,dbscan_int,-1,0,0,integer[],1
+dbscan,dbscan_int,0,0,0,class<`matrix`>,1
+dbscan,dbscan_int,1,0,0,double,1
+dbscan,dbscan_int,2,0,0,integer,1
+dbscan,dbscan_int,3,0,0,double[],1
+dbscan,dbscan_int,4,0,0,integer,1
+dbscan,dbscan_int,5,0,0,integer,1
+dbscan,dbscan_int,6,0,0,integer,1
+dbscan,dbscan_int,7,0,0,integer,1
+dbscan,dendrogram_to_reach,-1,0,0,class<`reachability`>,1
+dbscan,dendrogram_to_reach,0,0,0,class<`dendrogram`>,1
+dbscan,distToAdjacency,-1,0,0,list<integer[]>,1
+dbscan,distToAdjacency,0,0,0,double[],1
+dbscan,distToAdjacency,1,0,0,integer,1
+dbscan,extractClusterLabels,-1,0,0,double[],1
+dbscan,extractClusterLabels,0,0,0,class<`data.frame`>,1
+dbscan,extractClusterLabels,1,0,0,integer[],1
+dbscan,extractClusterLabels,2,0,0,logical,1
+dbscan,extractDBSCAN,-1,0,0,class<`optics`>,1
+dbscan,extractDBSCAN,0,0,0,class<`optics`>,1
+dbscan,extractDBSCAN,1,0,0,double,1
+dbscan,extractFOSC,-1,0,0,any,1
+dbscan,extractFOSC,0,0,0,class<`data.frame`>,1
+dbscan,extractFOSC,0,0,1,class<`hclust`>,1
+dbscan,extractFOSC,1,0,0,null,1
+dbscan,extractFOSC,1,0,1,class<`matrix`>,1
+dbscan,extractFOSC,1,0,2,double[],1
+dbscan,extractFOSC,1,0,3,list<double[]>,1
+dbscan,extractFOSC,2,0,0,double,1
+dbscan,extractFOSC,3,0,0,double,1
+dbscan,extractFOSC,4,0,0,logical,1
+dbscan,extractFOSC,5,0,0,logical,1
+dbscan,extractSemiSupervised,-1,0,0,list<list<double[]>>,1
+dbscan,extractSemiSupervised,0,0,0,list<list<double[]>>,1
+dbscan,extractSemiSupervised,1,0,0,list<double[]>,1
+dbscan,extractSemiSupervised,2,0,0,double,1
+dbscan,extractSemiSupervised,3,0,0,logical,1
+dbscan,extractUnsupervised,-1,0,0,list<list<double[]>>,1
+dbscan,extractUnsupervised,0,0,0,list<list<double[]>>,1
+dbscan,extractUnsupervised,1,0,0,logical,1
+dbscan,extractXi,-1,0,0,class<`optics`>,1
+dbscan,extractXi,0,0,0,class<`optics`>,1
+dbscan,extractXi,1,0,0,double,1
+dbscan,extractXi,2,0,0,logical,1
+dbscan,extractXi,3,0,0,logical,1
+dbscan,frNN,-1,0,0,any,1
+dbscan,frNN,0,0,0,class<`data.frame`>,1
+dbscan,frNN,0,0,1,class<`dist`>,1
+dbscan,frNN,0,0,2,class<`matrix`>,1
+dbscan,frNN,0,0,3,"class<`NN`, `frNN`>",1
+dbscan,frNN,1,0,0,double,1
+dbscan,frNN,2,0,0,class<`data.frame`>,1
+dbscan,frNN,2,0,1,null,1
+dbscan,frNN,3,0,0,logical,1
+dbscan,frNN,4,0,0,character,1
+dbscan,frNN,5,0,0,double,1
+dbscan,frNN,6,0,0,character,1
+dbscan,frNN,7,0,0,double,1
+dbscan,frNN_int,-1,0,0,list<double | list<double[]>>,1
+dbscan,frNN_int,0,0,0,class<`matrix`>,1
+dbscan,frNN_int,1,0,0,double,1
+dbscan,frNN_int,2,0,0,integer,1
+dbscan,frNN_int,3,0,0,integer,1
+dbscan,frNN_int,4,0,0,integer,1
+dbscan,frNN_int,5,0,0,double,1
+dbscan,frNN_query_int,-1,0,0,list<double | list<double[]>>,1
+dbscan,frNN_query_int,0,0,0,class<`matrix`>,1
+dbscan,frNN_query_int,1,0,0,class<`matrix`>,1
+dbscan,frNN_query_int,2,0,0,double,1
+dbscan,frNN_query_int,3,0,0,integer,1
+dbscan,frNN_query_int,4,0,0,integer,1
+dbscan,frNN_query_int,5,0,0,integer,1
+dbscan,frNN_query_int,6,0,0,double,1
+dbscan,glosh,-1,0,0,double[],1
+dbscan,glosh,0,0,0,class<`hclust`>,1
+dbscan,glosh,0,0,1,class<`matrix`>,1
+dbscan,glosh,1,0,0,double,1
+dbscan,glosh,2,0,0,...,1
+dbscan,hclustMergeOrder,-1,0,0,class<`hclust`>,1
+dbscan,hclustMergeOrder,0,0,0,class<`matrix`>,1
+dbscan,hclustMergeOrder,1,0,0,integer[],1
+dbscan,hdbscan,-1,0,0,class<`hdbscan`>,1
+dbscan,hdbscan,0,0,0,class<`data.frame`>,1
+dbscan,hdbscan,0,0,1,"class<`data.frame`, `data.table`>",1
+dbscan,hdbscan,0,0,2,class<`matrix`>,1
+dbscan,hdbscan,1,0,0,double,1
+dbscan,hdbscan,2,0,0,null,1
+dbscan,hdbscan,3,0,0,logical,1
+dbscan,hdbscan,4,0,0,logical,1
+dbscan,hullplot,-1,0,0,null,1
+dbscan,hullplot,0,0,0,class<`matrix`>,1
+dbscan,hullplot,1,0,0,"class<`dbscan`, `dbscan_fast`>",1
+dbscan,hullplot,1,0,1,class<`kmeans`>,1
+dbscan,hullplot,1,0,2,class<`optics`>,1
+dbscan,hullplot,1,0,3,integer[],1
+dbscan,hullplot,2,0,0,null,1
+dbscan,hullplot,2,0,1,character,1
+dbscan,hullplot,3,0,0,double,1
+dbscan,hullplot,4,0,0,double,1
+dbscan,hullplot,5,0,0,double,1
+dbscan,hullplot,6,0,0,logical,1
+dbscan,hullplot,7,0,0,double,1
+dbscan,jpclust,-1,0,0,class<`general_clustering`>,1
+dbscan,jpclust,0,0,0,"class<`data.frame`, `data.table`>",1
+dbscan,jpclust,0,0,1,"class<`NN`, `kNN`>",1
+dbscan,jpclust,1,0,0,double,1
+dbscan,jpclust,2,0,0,double,1
+dbscan,jpclust,3,0,0,...,1
+dbscan,JP_int,-1,0,0,integer[],1
+dbscan,JP_int,0,0,0,class<`matrix`>,1
+dbscan,JP_int,1,0,0,integer,1
+dbscan,kNN,-1,0,0,any,1
+dbscan,kNN,0,0,0,class<`matrix`>,1
+dbscan,kNN,0,0,1,class<`data.frame`>,1
+dbscan,kNN,0,0,2,"class<`data.frame`, `data.table`>",1
+dbscan,kNN,0,0,3,class<`dist`>,1
+dbscan,kNN,0,0,4,"class<`NN`, `kNN`>",1
+dbscan,kNN,1,0,0,double,1
+dbscan,kNN,2,0,0,null,1
+dbscan,kNN,2,0,1,class<`data.frame`>,1
+dbscan,kNN,3,0,0,logical,1
+dbscan,kNN,4,0,0,character,1
+dbscan,kNN,5,0,0,any,1
+dbscan,kNN,6,0,0,any,1
+dbscan,kNN,7,0,0,any,1
+dbscan,kNNdist,-1,0,0,class<`matrix`>,1
+dbscan,kNNdist,-1,0,1,double[],1
+dbscan,kNNdist,0,0,0,class<`matrix`>,1
+dbscan,kNNdist,0,0,1,class<`data.frame`>,1
+dbscan,kNNdist,0,0,2,class<`dist`>,1
+dbscan,kNNdist,1,0,0,double,1
+dbscan,kNNdist,2,0,0,logical,1
+dbscan,kNNdist,3,0,0,...,1
+dbscan,kNNdistplot,-1,0,0,null,1
+dbscan,kNNdistplot,0,0,0,class<`matrix`>,1
+dbscan,kNNdistplot,1,0,0,double,1
+dbscan,kNNdistplot,2,0,0,...,1
+dbscan,kNN_int,-1,0,0,list<class<`matrix`> | integer>,1
+dbscan,kNN_int,0,0,0,class<`matrix`>,1
+dbscan,kNN_int,1,0,0,integer,1
+dbscan,kNN_int,2,0,0,integer,1
+dbscan,kNN_int,3,0,0,integer,1
+dbscan,kNN_int,4,0,0,integer,1
+dbscan,kNN_int,5,0,0,double,1
+dbscan,kNN_query_int,-1,0,0,list<class<`matrix`> | integer>,1
+dbscan,kNN_query_int,0,0,0,class<`matrix`>,1
+dbscan,kNN_query_int,1,0,0,class<`matrix`>,1
+dbscan,kNN_query_int,2,0,0,integer,1
+dbscan,kNN_query_int,3,0,0,integer,1
+dbscan,kNN_query_int,4,0,0,integer,1
+dbscan,kNN_query_int,5,0,0,integer,1
+dbscan,kNN_query_int,6,0,0,double,1
+dbscan,lof,-1,0,0,any,1
+dbscan,lof,0,0,0,class<`dist`>,1
+dbscan,lof,0,0,1,class<`matrix`>,1
+dbscan,lof,1,0,0,double,1
+dbscan,lof,2,0,0,...,1
+dbscan,.matrixlike,-1,0,0,logical,1
+dbscan,.matrixlike,0,0,0,class<`data.frame`>,1
+dbscan,.matrixlike,0,0,1,"class<`data.frame`, `data.table`>",1
+dbscan,.matrixlike,0,0,2,class<`dist`>,1
+dbscan,.matrixlike,0,0,3,class<`matrix`>,1
+dbscan,.memberDend,-1,0,0,integer,1
+dbscan,.memberDend,0,0,0,class<`dendrogram`>,1
+dbscan,.midcache.dendrogram,-1,0,0,class<`dendrogram`>,1
+dbscan,.midcache.dendrogram,0,0,0,class<`dendrogram`>,1
+dbscan,.midcache.dendrogram,1,0,0,character,1
+dbscan,.midcache.dendrogram,2,0,0,logical,1
+dbscan,mrd,-1,0,0,double[],1
+dbscan,mrd,0,0,0,class<`dist`>,1
+dbscan,mrd,1,0,0,double[],1
+dbscan,node_xy,-1,0,0,class<`matrix`>,1
+dbscan,node_xy,0,0,0,list<list<double[]>>,1
+dbscan,node_xy,1,0,0,list<integer[]>,1
+dbscan,node_xy,2,0,0,integer,1
+dbscan,optics,-1,0,0,any,1
+dbscan,optics,0,0,0,class<`data.frame`>,1
+dbscan,optics,0,0,1,class<`dist`>,1
+dbscan,optics,0,0,2,class<`matrix`>,1
+dbscan,optics,1,0,0,double,1
+dbscan,optics,1,0,1,null,1
+dbscan,optics,2,0,0,double,1
+dbscan,optics,3,0,0,...,1
+dbscan,optics_int,-1,0,0,list<double[] | ^integer[]>,1
+dbscan,optics_int,0,0,0,class<`matrix`>,1
+dbscan,optics_int,1,0,0,double,1
+dbscan,optics_int,2,0,0,integer,1
+dbscan,optics_int,3,0,0,integer,1
+dbscan,optics_int,4,0,0,integer,1
+dbscan,optics_int,5,0,0,integer,1
+dbscan,optics_int,6,0,0,double,1
+dbscan,optics_int,7,0,0,"class<`NN`, `frNN`>",1
+dbscan,optics_int,7,0,1,list<any>,1
+dbscan,plot.hdbscan,-1,0,0,class<`hdbscan`>,1
+dbscan,plot.hdbscan,0,0,0,class<`hdbscan`>,1
+dbscan,plot.hdbscan,1,0,0,character,1
+dbscan,plot.hdbscan,1,0,1,double,1
+dbscan,plot.hdbscan,2,0,0,character[],1
+dbscan,plot.hdbscan,3,0,0,logical,1
+dbscan,plot.hdbscan,4,0,0,...,1
+dbscan,plot.NN,-1,0,0,null,1
+dbscan,plot.NN,0,0,0,"class<`NN`, `frNN`>",1
+dbscan,plot.NN,0,0,1,"class<`NN`, `kNN`>",1
+dbscan,plot.NN,0,0,2,"class<`NN`, `kNN`, `sNN`>",1
+dbscan,plot.NN,1,0,0,class<`data.frame`>,1
+dbscan,plot.NN,2,0,0,null,1
+dbscan,plot.NN,3,0,0,...,1
+dbscan,plot.optics,-1,0,0,null,1
+dbscan,plot.optics,-1,0,1,list<character | double[] | null>,1
+dbscan,plot.optics,0,0,0,class<`optics`>,1
+dbscan,plot.optics,1,0,0,logical,1
+dbscan,plot.optics,2,0,0,logical,1
+dbscan,plot.optics,3,0,0,...,1
+dbscan,plot.reachability,-1,0,0,null,1
+dbscan,plot.reachability,0,0,0,class<`reachability`>,1
+dbscan,plot.reachability,1,0,0,logical,1
+dbscan,plot.reachability,2,0,0,character,1
+dbscan,plot.reachability,2,0,1,null,1
+dbscan,plot.reachability,3,0,0,character,1
+dbscan,plot.reachability,4,0,0,character,1
+dbscan,plot.reachability,5,0,0,...,1
+dbscan,pointdensity,-1,0,0,double[],1
+dbscan,pointdensity,0,0,0,class<`matrix`>,1
+dbscan,pointdensity,0,0,1,"class<`data.frame`, `data.table`>",1
+dbscan,pointdensity,1,0,0,double,1
+dbscan,pointdensity,2,0,0,character,1
+dbscan,pointdensity,3,0,0,character,1
+dbscan,pointdensity,4,0,0,double,1
+dbscan,pointdensity,5,0,0,character,1
+dbscan,pointdensity,6,0,0,double,1
+dbscan,predict.dbscan_fast,-1,0,0,integer[],1
+dbscan,predict.dbscan_fast,0,0,0,"class<`dbscan`, `dbscan_fast`>",1
+dbscan,predict.dbscan_fast,1,0,0,class<`matrix`>,1
+dbscan,predict.dbscan_fast,2,0,0,class<`matrix`>,1
+dbscan,predict.dbscan_fast,3,0,0,...,1
+dbscan,.predict_frNN,-1,0,0,integer[],1
+dbscan,.predict_frNN,0,0,0,class<`matrix`>,1
+dbscan,.predict_frNN,1,0,0,class<`matrix`>,1
+dbscan,.predict_frNN,2,0,0,integer[],1
+dbscan,.predict_frNN,3,0,0,double,1
+dbscan,.predict_frNN,4,0,0,...,1
+dbscan,prims,-1,0,0,class<`matrix`>,1
+dbscan,prims,0,0,0,double[],1
+dbscan,prims,1,0,0,integer,1
+dbscan,reach_to_dendrogram,-1,0,0,class<`dendrogram`>,1
+dbscan,reach_to_dendrogram,0,0,0,class<`reachability`>,1
+dbscan,reach_to_dendrogram,1,0,0,double[],1
+dbscan,simplifiedTree,-1,0,0,class<`dendrogram`>,1
+dbscan,simplifiedTree,0,0,0,list<list<double[]>>,1
+dbscan,sNN,-1,0,0,"class<`NN`, `kNN`, `sNN`>",1
+dbscan,sNN,0,0,0,class<`data.frame`>,1
+dbscan,sNN,0,0,1,"class<`data.frame`, `data.table`>",1
+dbscan,sNN,0,0,2,"class<`NN`, `kNN`, `sNN`>",1
+dbscan,sNN,1,0,0,any,1
+dbscan,sNN,2,0,0,null,1
+dbscan,sNN,2,0,1,double,1
+dbscan,sNN,3,0,0,logical,1
+dbscan,sNN,4,0,0,logical,1
+dbscan,sNN,5,0,0,character,1
+dbscan,sNN,6,0,0,double,1
+dbscan,sNN,7,0,0,character,1
+dbscan,sNNclust,-1,0,0,class<`general_clustering`>,1
+dbscan,sNNclust,0,0,0,"class<`data.frame`, `data.table`>",1
+dbscan,sNNclust,1,0,0,double,1
+dbscan,sNNclust,2,0,0,double,1
+dbscan,sNNclust,3,0,0,double,1
+dbscan,sNNclust,4,0,0,logical,1
+dbscan,sNNclust,5,0,0,...,1
+dbscan,SNN_sim_int,-1,0,0,class<`matrix`>,1
+dbscan,SNN_sim_int,0,0,0,class<`matrix`>,1
+dbscan,SNN_sim_int,1,0,0,logical,1
+dbscan,sort.frNN,-1,0,0,"class<`NN`, `frNN`>",1
+dbscan,sort.frNN,0,0,0,"class<`NN`, `frNN`>",1
+dbscan,sort.frNN,1,0,0,logical,1
+dbscan,sort.frNN,2,0,0,...,1
+dbscan,sort.kNN,-1,0,0,"class<`NN`, `kNN`, `sNN`>",1
+dbscan,sort.kNN,-1,0,1,"class<`NN`, `kNN`>",1
+dbscan,sort.kNN,0,0,0,"class<`NN`, `kNN`, `sNN`>",1
+dbscan,sort.kNN,0,0,1,"class<`NN`, `kNN`>",1
+dbscan,sort.kNN,1,0,0,logical,1
+dbscan,sort.kNN,2,0,0,...,1
+dbscan,sort.sNN,-1,0,0,"class<`NN`, `kNN`, `sNN`>",1
+dbscan,sort.sNN,0,0,0,"class<`NN`, `kNN`, `sNN`>",1
+dbscan,sort.sNN,1,0,0,logical,1
+dbscan,sort.sNN,2,0,0,...,1
+dbscan,steepDown,-1,0,0,logical,1
+dbscan,steepDown,0,0,0,double,1
+dbscan,steepDown,1,0,0,class<`optics`>,1
+dbscan,steepDown,2,0,0,double,1
+dbscan,steepUp,-1,0,0,logical,1
+dbscan,steepUp,0,0,0,double,1
+dbscan,steepUp,1,0,0,class<`optics`>,1
+dbscan,steepUp,2,0,0,any,1
+dbscan,updateFilterSDASet,-1,0,0,list<any>,1
+dbscan,updateFilterSDASet,0,0,0,any,1
+dbscan,updateFilterSDASet,1,0,0,list<any>,1
+dbscan,updateFilterSDASet,2,0,0,any,1
+dbscan,valid,-1,0,0,logical,1
+dbscan,valid,0,0,0,double,1
+dbscan,valid,1,0,0,class<`optics`>,1
+dbscan,validateConstraintList,-1,0,0,list<double>,1
+dbscan,validateConstraintList,0,0,0,list<double>,1
+dbscan,validateConstraintList,1,0,0,integer,1
+deldir,acw,-1,0,0,list<double[]>,1
+deldir,acw,0,0,0,list<double[]>,1
+deldir,binsrtR,-1,0,0,list<double[]>,1
+deldir,binsrtR,0,0,0,double[],1
+deldir,binsrtR,1,0,0,double[],1
+deldir,binsrtR,2,0,0,double[],1
+deldir,deldir,-1,0,0,class<`deldir`>,1
+deldir,deldir,0,0,0,class<`data.frame`>,1
+deldir,deldir,0,0,1,double[],1
+deldir,deldir,1,0,0,any,1
+deldir,deldir,2,0,0,null,1
+deldir,deldir,2,0,1,list<double>,1
+deldir,deldir,3,0,0,null,1
+deldir,deldir,3,0,1,double[],1
+deldir,deldir,4,0,0,double,1
+deldir,deldir,5,0,0,logical,1
+deldir,deldir,6,0,0,logical,1
+deldir,deldir,7,0,0,double,1
+deldir,deldir,8,0,0,null,1
+deldir,deldir,8,0,1,class<`factor`>,1
+deldir,deldir,8,0,2,double[],1
+deldir,deldir,9,0,0,null,1
+deldir,deldir,9,0,1,double[],1
+deldir,deldir,10,0,0,logical,1
+deldir,deldir,11,0,0,...,1
+deldir,divchain,-1,0,0,"class<`data.frame`, `divchain`>",1
+deldir,divchain,0,0,0,class<`deldir`>,1
+deldir,divchain,0,0,1,double[],1
+deldir,divchain,1,0,0,...,1
+deldir,divchain.default,-1,0,0,"class<`data.frame`, `divchain`>",1
+deldir,divchain.default,0,0,0,double[],1
+deldir,divchain.default,1,0,0,double[],1
+deldir,divchain.default,2,0,0,class<`factor`>,1
+deldir,divchain.default,3,0,0,...,1
+deldir,divchain.deldir,-1,0,0,"class<`data.frame`, `divchain`>",1
+deldir,divchain.deldir,0,0,0,class<`deldir`>,1
+deldir,divchain.deldir,1,0,0,...,1
+deldir,dumpts,-1,0,0,list<double[]>,1
+deldir,dumpts,0,0,0,double[],1
+deldir,dumpts,1,0,0,double[],1
+deldir,dumpts,2,0,0,list<double>,1
+deldir,dumpts,3,0,0,double[],1
+deldir,duplicatedxy,-1,0,0,logical[],1
+deldir,duplicatedxy,0,0,0,double[],1
+deldir,duplicatedxy,1,0,0,double[],1
+deldir,get.cnrind,-1,0,0,integer[],1
+deldir,get.cnrind,0,0,0,double[],1
+deldir,get.cnrind,1,0,0,double[],1
+deldir,get.cnrind,2,0,0,double[],1
+deldir,getCol,-1,0,0,null,1
+deldir,getCol,0,0,0,class<`tile.list`>,1
+deldir,getCol,1,0,0,any,1
+deldir,lawSummary,-1,0,0,list<double[] | list<class<`data.frame`> | double[]>>,1
+deldir,lawSummary,0,0,0,class<`deldir`>,1
+deldir,mid.in,-1,0,0,logical,1
+deldir,mid.in,0,0,0,double[],1
+deldir,mid.in,1,0,0,double[],1
+deldir,mid.in,2,0,0,double[],1
+deldir,mid.in,3,0,0,double[],1
+deldir,plot.deldir,-1,0,0,null,1
+deldir,plot.deldir,0,0,0,class<`deldir`>,1
+deldir,plot.deldir,1,0,0,logical,1
+deldir,plot.deldir,2,0,0,character,1
+deldir,plot.deldir,3,0,0,character[],1
+deldir,plot.deldir,4,0,0,logical,1
+deldir,plot.deldir,5,0,0,double,1
+deldir,plot.deldir,6,0,0,double,1
+deldir,plot.deldir,7,0,0,double[],1
+deldir,plot.deldir,8,0,0,null,1
+deldir,plot.deldir,9,0,0,null,1
+deldir,plot.deldir,10,0,0,null,1
+deldir,plot.deldir,11,0,0,null,1
+deldir,plot.deldir,12,0,0,logical,1
+deldir,plot.deldir,13,0,0,character,1
+deldir,plot.deldir,14,0,0,character,1
+deldir,plot.deldir,15,0,0,logical,1
+deldir,plot.divchain,-1,0,0,null,1
+deldir,plot.divchain,0,0,0,"class<`data.frame`, `divchain`>",1
+deldir,plot.divchain,1,0,0,logical,1
+deldir,plot.divchain,2,0,0,...,1
+deldir,plot.tile.list,-1,0,0,null,1
+deldir,plot.tile.list,0,0,0,class<`tile.list`>,1
+deldir,plot.tile.list,1,0,0,logical,1
+deldir,plot.tile.list,2,0,0,logical,1
+deldir,plot.tile.list,3,0,0,double,1
+deldir,plot.tile.list,4,0,0,character[],1
+deldir,plot.tile.list,4,0,1,null,1
+deldir,plot.tile.list,5,0,0,null,1
+deldir,plot.tile.list,5,0,1,character,1
+deldir,plot.tile.list,6,0,0,null,1
+deldir,plot.tile.list,6,0,1,character,1
+deldir,plot.tile.list,7,0,0,null,1
+deldir,plot.tile.list,8,0,0,logical,1
+deldir,plot.tile.list,9,0,0,logical,1
+deldir,plot.tile.list,10,0,0,double,1
+deldir,plot.tile.list,11,0,0,null,1
+deldir,plot.tile.list,11,0,1,list<double[]>,1
+deldir,plot.tile.list,12,0,0,character,1
+deldir,plot.tile.list,13,0,0,character,1
+deldir,plot.tile.list,14,0,0,character,1
+deldir,plot.tile.list,15,0,0,logical,1
+deldir,plot.triang.list,-1,0,0,null,1
+deldir,plot.triang.list,0,0,0,class<`triang.list`>,1
+deldir,plot.triang.list,1,0,0,logical,1
+deldir,plot.triang.list,2,0,0,logical,1
+deldir,plot.triang.list,3,0,0,character,1
+deldir,plot.triang.list,4,0,0,character,1
+deldir,plot.triang.list,5,0,0,character,1
+deldir,plot.triang.list,6,0,0,double,1
+deldir,plot.triang.list,7,0,0,...,1
+deldir,prelimtlist,-1,0,0,class<`matrix`>,1
+deldir,prelimtlist,0,0,0,class<`deldir`>,1
+deldir,print.tileInfo,-1,0,0,null,1
+deldir,print.tileInfo,0,0,0,class<`tileInfo`>,1
+deldir,print.tileInfo,1,0,0,double,1
+deldir,print.tileInfo,2,0,0,...,1
+deldir,tile.centroids,-1,0,0,class<`data.frame`>,1
+deldir,tile.centroids,0,0,0,class<`tile.list`>,1
+deldir,tileInfo,-1,0,0,class<`tileInfo`>,1
+deldir,tileInfo,0,0,0,class<`deldir`>,1
+deldir,tileInfo,1,0,0,logical,1
+deldir,[.tile.list,-1,0,0,class<`tile.list`>,1
+deldir,[.tile.list,0,0,0,class<`tile.list`>,1
+deldir,[.tile.list,1,0,0,double[],1
+deldir,[.tile.list,2,0,0,...,1
+deldir,tile.list,-1,0,0,class<`tile.list`>,1
+deldir,tile.list,0,0,0,class<`deldir`>,1
+deldir,tilePerim,-1,0,0,list<double[]>,1
+deldir,tilePerim,0,0,0,class<`tile.list`>,1
+deldir,tilePerim,1,0,0,logical,1
+deldir,triang.list,-1,0,0,class<`triang.list`>,1
+deldir,triang.list,0,0,0,class<`deldir`>,1
+deldir,triMat,-1,0,0,class<`matrix`>,1
+deldir,triMat,0,0,0,class<`deldir`>,1
+deldir,which.tile,-1,0,0,integer,1
+deldir,which.tile,0,0,0,double,1
+deldir,which.tile,1,0,0,double,1
+deldir,which.tile,2,0,0,class<`tile.list`>,1
+desc,all_true,-1,0,0,logical,1
+desc,all_true,0,0,0,list<logical>,1
+desc,check_encoding,-1,0,0,"class<`R6`, `description`>",1
+desc,check_encoding,0,0,0,"class<`R6`, `description`>",1
+desc,check_encoding,1,0,0,any,1
+desc,check_encoding,2,0,0,any,1
+desc,check_field.DescriptionPackage,-1,0,0,logical,1
+desc,check_field.DescriptionPackage,0,0,0,list<character>,1
+desc,check_field.DescriptionPackage,1,0,0,logical,1
+desc,check_field.DescriptionPackage,2,0,0,logical,1
+desc,check_field.DescriptionPackage,3,0,0,...,1
+desc,check_field.DescriptionPackageList,-1,0,0,logical,1
+desc,check_field.DescriptionPackageList,0,0,0,"class<`DescriptionField`, `DescriptionPackageList`>",1
+desc,check_field.DescriptionPackageList,1,0,0,logical,1
+desc,check_field.DescriptionPackageList,2,0,0,...,1
+desc,chk,-1,0,0,logical,1
+desc,chk,0,0,0,character,1
+desc,chk,1,0,0,logical,1
+desc,chks,-1,0,0,logical,1
+desc,chks,0,0,0,...,1
+desc,chks,1,0,0,any,1
+desc,chks,2,0,0,any,1
+desc,create_fields,-1,0,0,list<any>,1
+desc,create_fields,0,0,0,character[],1
+desc,create_fields,1,0,0,character[],1
+desc,desc,-1,0,0,"class<`R6`, `description`>",1
+desc,desc,0,0,0,character,1
+desc,desc,0,0,1,null,1
+desc,desc,1,0,0,null,1
+desc,desc,2,0,0,null,1
+desc,desc,3,0,0,null,1
+desc,desc,3,0,1,character,1
+desc,find_field_class,-1,0,0,character,1
+desc,find_field_class,0,0,0,character,1
+desc,has_no_na,-1,0,0,logical,1
+desc,has_no_na,0,0,0,character,1
+desc,idesc_create,-1,0,0,"class<`R6`, `description`>",1
+desc,idesc_create,0,0,0,"class<`R6`, `description`>",1
+desc,idesc_create,1,0,0,environment,1
+desc,idesc_create,2,0,0,character,1
+desc,idesc_create,2,0,1,null,1
+desc,idesc_create,3,0,0,any,1
+desc,idesc_create,4,0,0,null,1
+desc,idesc_create,5,0,0,null,1
+desc,idesc_create,5,0,1,character,1
+desc,idesc_create_cmd,-1,0,0,"class<`R6`, `description`>",1
+desc,idesc_create_cmd,0,0,0,"class<`R6`, `description`>",1
+desc,idesc_create_cmd,1,0,0,environment,1
+desc,idesc_create_cmd,2,0,0,character,1
+desc,idesc_create_file,-1,0,0,"class<`R6`, `description`>",1
+desc,idesc_create_file,0,0,0,"class<`R6`, `description`>",1
+desc,idesc_create_file,1,0,0,environment,1
+desc,idesc_create_file,2,0,0,character,1
+desc,idesc_create_package,-1,0,0,"class<`R6`, `description`>",1
+desc,idesc_create_package,0,0,0,"class<`R6`, `description`>",1
+desc,idesc_create_package,1,0,0,environment,1
+desc,idesc_create_package,2,0,0,character,1
+desc,idesc_create_text,-1,0,0,"class<`R6`, `description`>",1
+desc,idesc_create_text,0,0,0,"class<`R6`, `description`>",1
+desc,idesc_create_text,1,0,0,environment,1
+desc,idesc_create_text,2,0,0,character[],1
+desc,idesc_del,-1,0,0,"class<`R6`, `description`>",1
+desc,idesc_del,0,0,0,"class<`R6`, `description`>",1
+desc,idesc_del,1,0,0,environment,1
+desc,idesc_del,2,0,0,character,1
+desc,idesc_get,-1,0,0,character,1
+desc,idesc_get,0,0,0,any,1
+desc,idesc_get,1,0,0,environment,1
+desc,idesc_get,2,0,0,character,1
+desc,idesc_set,-1,0,0,"class<`R6`, `description`>",1
+desc,idesc_set,0,0,0,"class<`R6`, `description`>",1
+desc,idesc_set,1,0,0,environment,1
+desc,idesc_set,2,0,0,...,1
+desc,is_constructor_cmd,-1,0,0,logical,1
+desc,is_constructor_cmd,0,0,0,character,1
+desc,is_dir,-1,0,0,logical,1
+desc,is_dir,0,0,0,character,1
+desc,is_existing_file,-1,0,0,logical,1
+desc,is_existing_file,0,0,0,character,1
+desc,is_gz_file,-1,0,0,logical,1
+desc,is_gz_file,0,0,0,character,1
+desc,is_package_archive,-1,0,0,logical,1
+desc,is_package_archive,0,0,0,character,1
+desc,is_path,-1,0,0,logical,1
+desc,is_path,0,0,0,character,1
+desc,is_string,-1,0,0,logical,1
+desc,is_string,0,0,0,character,1
+desc,is_tar_gz_file,-1,0,0,logical,1
+desc,is_tar_gz_file,0,0,0,character,1
+desc,is_zip_file,-1,0,0,logical,1
+desc,is_zip_file,0,0,0,character,1
+desc,read_dcf,-1,0,0,list<character[] | list<any>>,1
+desc,read_dcf,0,0,0,"class<`connection`, `textConnection`>",1
+desc,str_trim,-1,0,0,character,1
+desc,str_trim,0,0,0,character,1
+diagram,bentarrow,-1,0,0,class<`matrix`>,1
+diagram,bentarrow,0,0,0,double[],1
+diagram,bentarrow,1,0,0,double[],1
+diagram,bentarrow,2,0,0,double,1
+diagram,bentarrow,3,0,0,double,1
+diagram,bentarrow,4,0,0,character,1
+diagram,bentarrow,4,0,1,double,1
+diagram,bentarrow,5,0,0,character,1
+diagram,bentarrow,5,0,1,double,1
+diagram,bentarrow,6,0,0,double,1
+diagram,bentarrow,6,0,1,integer[],1
+diagram,bentarrow,7,0,0,double,1
+diagram,bentarrow,8,0,0,character,1
+diagram,bentarrow,9,0,0,...,1
+diagram,coordinates,-1,0,0,class<`matrix`>,1
+diagram,coordinates,0,0,0,class<`matrix`>,1
+diagram,coordinates,0,0,1,double[],1
+diagram,coordinates,0,0,2,null,1
+diagram,coordinates,1,0,0,double,1
+diagram,coordinates,2,0,0,double,1
+diagram,coordinates,3,0,0,double,1
+diagram,coordinates,4,0,0,logical,1
+diagram,coordinates,5,0,0,double,1
+diagram,curvedarrow,-1,0,0,double[],1
+diagram,curvedarrow,0,0,0,double[],1
+diagram,curvedarrow,1,0,0,double[],1
+diagram,curvedarrow,2,0,0,double,1
+diagram,curvedarrow,3,0,0,double,1
+diagram,curvedarrow,4,0,0,character,1
+diagram,curvedarrow,4,0,1,double,1
+diagram,curvedarrow,5,0,0,character,1
+diagram,curvedarrow,5,0,1,double,1
+diagram,curvedarrow,6,0,0,double,1
+diagram,curvedarrow,7,0,0,double,1
+diagram,curvedarrow,8,0,0,double,1
+diagram,curvedarrow,9,0,0,logical,1
+diagram,curvedarrow,10,0,0,double[],1
+diagram,curvedarrow,11,0,0,...,1
+diagram,en.Amplifier,-1,0,0,null,1
+diagram,en.Amplifier,0,0,0,double[],1
+diagram,en.Amplifier,1,0,0,double,1
+diagram,en.Amplifier,2,0,0,null,1
+diagram,en.Amplifier,3,0,0,any,1
+diagram,en.Amplifier,4,0,0,any,1
+diagram,en.Amplifier,5,0,0,...,1
+diagram,en.Capacitator,-1,0,0,null,1
+diagram,en.Capacitator,0,0,0,double[],1
+diagram,en.Capacitator,1,0,0,double,1
+diagram,en.Capacitator,2,0,0,double,1
+diagram,en.Capacitator,3,0,0,character,1
+diagram,en.Capacitator,3,0,1,null,1
+diagram,en.Capacitator,4,0,0,double,1
+diagram,en.Capacitator,5,0,0,double,1
+diagram,en.Capacitator,6,0,0,logical,1
+diagram,en.Capacitator,7,0,0,...,1
+diagram,en.Ground,-1,0,0,null,1
+diagram,en.Ground,0,0,0,double[],1
+diagram,en.Ground,1,0,0,double,1
+diagram,en.Ground,2,0,0,double,1
+diagram,en.Ground,3,0,0,double,1
+diagram,en.Ground,4,0,0,double,1
+diagram,en.Ground,5,0,0,...,1
+diagram,en.Node,-1,0,0,null,1
+diagram,en.Node,0,0,0,double[],1
+diagram,en.Node,1,0,0,double,1
+diagram,en.Node,2,0,0,character,1
+diagram,en.Node,3,0,0,double,1
+diagram,en.Node,4,0,0,double,1
+diagram,en.Node,5,0,0,...,1
+diagram,en.Resistor,-1,0,0,null,1
+diagram,en.Resistor,0,0,0,double[],1
+diagram,en.Resistor,1,0,0,double,1
+diagram,en.Resistor,2,0,0,double,1
+diagram,en.Resistor,3,0,0,character,1
+diagram,en.Resistor,3,0,1,class<`call`>,1
+diagram,en.Resistor,3,0,2,double,1
+diagram,en.Resistor,3,0,3,null,1
+diagram,en.Resistor,4,0,0,double,1
+diagram,en.Resistor,5,0,0,double,1
+diagram,en.Resistor,6,0,0,logical,1
+diagram,en.Resistor,7,0,0,...,1
+diagram,en.Signal,-1,0,0,null,1
+diagram,en.Signal,0,0,0,double[],1
+diagram,en.Signal,1,0,0,double,1
+diagram,en.Signal,2,0,0,expression,1
+diagram,en.Signal,2,0,1,null,1
+diagram,en.Signal,3,0,0,double,1
+diagram,en.Signal,4,0,0,double,1
+diagram,en.Signal,5,0,0,...,1
+diagram,en.Transistor,-1,0,0,null,1
+diagram,en.Transistor,0,0,0,double[],1
+diagram,en.Transistor,1,0,0,double[],1
+diagram,en.Transistor,2,0,0,double[],1
+diagram,en.Transistor,3,0,0,double[],1
+diagram,en.Transistor,4,0,0,double,1
+diagram,en.Transistor,5,0,0,null,1
+diagram,en.Transistor,6,0,0,double,1
+diagram,en.Transistor,7,0,0,double,1
+diagram,en.Transistor,8,0,0,...,1
+diagram,openplotmat,-1,0,0,null,1
+diagram,openplotmat,0,0,0,null,1
+diagram,openplotmat,1,0,0,...,1
+diagram,plotmat,-1,0,0,list<class<`data.frame`> | class<`matrix`>>,1
+diagram,plotmat,0,0,0,class<`data.frame`>,1
+diagram,plotmat,0,0,1,class<`matrix`>,1
+diagram,plotmat,1,0,0,double[],1
+diagram,plotmat,1,0,1,null,1
+diagram,plotmat,1,0,2,class<`matrix`>,1
+diagram,plotmat,2,0,0,double,1
+diagram,plotmat,2,0,1,null,1
+diagram,plotmat,2,0,2,class<`matrix`>,1
+diagram,plotmat,3,0,0,expression,1
+diagram,plotmat,3,0,1,character[],1
+diagram,plotmat,3,0,2,integer[],1
+diagram,plotmat,3,0,3,null,1
+diagram,plotmat,4,0,0,double,1
+diagram,plotmat,5,0,0,double,1
+diagram,plotmat,6,0,0,double,1
+diagram,plotmat,7,0,0,character,1
+diagram,plotmat,8,0,0,double,1
+diagram,plotmat,9,0,0,character,1
+diagram,plotmat,10,0,0,double,1
+diagram,plotmat,11,0,0,character[],1
+diagram,plotmat,12,0,0,character,1
+diagram,plotmat,13,0,0,double,1
+diagram,plotmat,13,0,1,integer[],1
+diagram,plotmat,14,0,0,double,1
+diagram,plotmat,15,0,0,character,1
+diagram,plotmat,16,0,0,double,1
+diagram,plotmat,17,0,0,double,1
+diagram,plotmat,18,0,0,double,1
+diagram,plotmat,19,0,0,double,1
+diagram,plotweb,-1,0,0,list<double[]>,1
+diagram,plotweb,0,0,0,class<`matrix`>,1
+diagram,plotweb,1,0,0,null,1
+diagram,plotweb,2,0,0,double,1
+diagram,plotweb,3,0,0,logical,1
+diagram,plotweb,4,0,0,double,1
+diagram,plotweb,5,0,0,character,1
+diagram,plotweb,6,0,0,character,1
+diagram,plotweb,7,0,0,character,1
+diagram,plotweb,8,0,0,logical,1
+diagram,plotweb,9,0,0,double[],1
+diagram,plotweb,10,0,0,null,1
+diagram,plotweb,11,0,0,null,1
+diagram,plotweb,12,0,0,null,1
+diagram,plotweb,13,0,0,logical,1
+diagram,plotweb,14,0,0,double,1
+diagram,plotweb,15,0,0,null,1
+diagram,plotweb,16,0,0,character,1
+diagram,plotweb,17,0,0,character,1
+diagram,plotweb,17,0,1,class<`matrix`>,1
+diagram,plotweb,18,0,0,logical,1
+diagram,plotweb,19,0,0,double,1
+diagram,segmentarrow,-1,0,0,class<`matrix`>,1
+diagram,segmentarrow,0,0,0,double[],1
+diagram,segmentarrow,1,0,0,double[],1
+diagram,segmentarrow,2,0,0,double,1
+diagram,segmentarrow,3,0,0,double,1
+diagram,segmentarrow,4,0,0,character,1
+diagram,segmentarrow,4,0,1,double,1
+diagram,segmentarrow,5,0,0,any,1
+diagram,segmentarrow,6,0,0,double,1
+diagram,segmentarrow,6,0,1,integer[],1
+diagram,segmentarrow,7,0,0,double,1
+diagram,segmentarrow,8,0,0,character,1
+diagram,segmentarrow,9,0,0,double,1
+diagram,segmentarrow,10,0,0,...,1
+diagram,selfarrow,-1,0,0,double[],1
+diagram,selfarrow,0,0,0,double[],1
+diagram,selfarrow,1,0,0,double,1
+diagram,selfarrow,2,0,0,double,1
+diagram,selfarrow,3,0,0,character,1
+diagram,selfarrow,3,0,1,double,1
+diagram,selfarrow,4,0,0,double,1
+diagram,selfarrow,5,0,0,character,1
+diagram,selfarrow,6,0,0,double[],1
+diagram,selfarrow,7,0,0,double,1
+diagram,selfarrow,8,0,0,double,1
+diagram,selfarrow,9,0,0,...,1
+diagram,shadowbox,-1,0,0,null,1
+diagram,shadowbox,0,0,0,character,1
+diagram,shadowbox,1,0,0,any,1
+diagram,shadowbox,2,0,0,any,1
+diagram,shadowbox,3,0,0,any,1
+diagram,shadowbox,4,0,0,double,1
+diagram,shadowbox,5,0,0,any,1
+diagram,shadowbox,6,0,0,any,1
+diagram,shadowbox,7,0,0,any,1
+diagram,shadowbox,8,0,0,any,1
+diagram,shadowbox,9,0,0,any,1
+diagram,shadowbox,10,0,0,double,1
+diagram,shadowbox,11,0,0,double,1
+diagram,shadowbox,12,0,0,double,1
+diagram,shadowbox,13,0,0,any,1
+diagram,shadowbox,14,0,0,double,1
+diagram,shadowbox,15,0,0,...,1
+diagram,splitarrow,-1,0,0,class<`matrix`>,1
+diagram,splitarrow,0,0,0,double[],1
+diagram,splitarrow,1,0,0,class<`matrix`>,1
+diagram,splitarrow,2,0,0,double,1
+diagram,splitarrow,3,0,0,double,1
+diagram,splitarrow,4,0,0,character,1
+diagram,splitarrow,4,0,1,double,1
+diagram,splitarrow,5,0,0,character,1
+diagram,splitarrow,5,0,1,double,1
+diagram,splitarrow,6,0,0,double,1
+diagram,splitarrow,6,0,1,integer[],1
+diagram,splitarrow,7,0,0,double,1
+diagram,splitarrow,8,0,0,double[],1
+diagram,splitarrow,8,0,1,null,1
+diagram,splitarrow,9,0,0,double,1
+diagram,splitarrow,10,0,0,...,1
+diagram,straightarrow,-1,0,0,double[],1
+diagram,straightarrow,0,0,0,double[],1
+diagram,straightarrow,1,0,0,double[],1
+diagram,straightarrow,2,0,0,double,1
+diagram,straightarrow,3,0,0,double,1
+diagram,straightarrow,4,0,0,character,1
+diagram,straightarrow,4,0,1,double,1
+diagram,straightarrow,5,0,0,any,1
+diagram,straightarrow,6,0,0,double,1
+diagram,straightarrow,7,0,0,logical,1
+diagram,straightarrow,8,0,0,double[],1
+diagram,straightarrow,9,0,0,...,1
+diagram,textdiamond,-1,0,0,null,1
+diagram,textdiamond,0,0,0,double[],1
+diagram,textdiamond,1,0,0,double,1
+diagram,textdiamond,2,0,0,double,1
+diagram,textdiamond,3,0,0,double,1
+diagram,textdiamond,4,0,0,double,1
+diagram,textdiamond,5,0,0,double[],1
+diagram,textdiamond,6,0,0,character,1
+diagram,textdiamond,7,0,0,character,1
+diagram,textdiamond,8,0,0,character,1
+diagram,textdiamond,9,0,0,character,1
+diagram,textdiamond,10,0,0,double,1
+diagram,textdiamond,11,0,0,...,1
+diagram,textellipse,-1,0,0,null,1
+diagram,textellipse,0,0,0,double[],1
+diagram,textellipse,1,0,0,double,1
+diagram,textellipse,2,0,0,double,1
+diagram,textellipse,3,0,0,double,1
+diagram,textellipse,4,0,0,double,1
+diagram,textellipse,5,0,0,double[],1
+diagram,textellipse,6,0,0,character[],1
+diagram,textellipse,7,0,0,character,1
+diagram,textellipse,8,0,0,character,1
+diagram,textellipse,9,0,0,character,1
+diagram,textellipse,10,0,0,double,1
+diagram,textellipse,11,0,0,double,1
+diagram,textellipse,12,0,0,...,1
+diagram,textempty,-1,0,0,null,1
+diagram,textempty,0,0,0,double[],1
+diagram,textempty,1,0,0,character,1
+diagram,textempty,2,0,0,double[],1
+diagram,textempty,3,0,0,character,1
+diagram,textempty,3,0,1,integer,1
+diagram,textempty,4,0,0,double,1
+diagram,textempty,5,0,0,...,1
+diagram,texthexa,-1,0,0,null,1
+diagram,texthexa,0,0,0,double[],1
+diagram,texthexa,1,0,0,double,1
+diagram,texthexa,2,0,0,double,1
+diagram,texthexa,3,0,0,double,1
+diagram,texthexa,4,0,0,double,1
+diagram,texthexa,5,0,0,double[],1
+diagram,texthexa,6,0,0,character,1
+diagram,texthexa,7,0,0,character,1
+diagram,texthexa,8,0,0,character,1
+diagram,texthexa,9,0,0,character,1
+diagram,texthexa,10,0,0,double,1
+diagram,texthexa,11,0,0,...,1
+diagram,textmulti,-1,0,0,null,1
+diagram,textmulti,0,0,0,double[],1
+diagram,textmulti,1,0,0,double,1
+diagram,textmulti,2,0,0,double,1
+diagram,textmulti,3,0,0,double,1
+diagram,textmulti,4,0,0,double,1
+diagram,textmulti,5,0,0,double[],1
+diagram,textmulti,6,0,0,character,1
+diagram,textmulti,7,0,0,character,1
+diagram,textmulti,8,0,0,character,1
+diagram,textmulti,9,0,0,character,1
+diagram,textmulti,10,0,0,double,1
+diagram,textmulti,11,0,0,double,1
+diagram,textmulti,12,0,0,...,1
+diagram,textparallel,-1,0,0,null,1
+diagram,textparallel,0,0,0,double[],1
+diagram,textparallel,1,0,0,double,1
+diagram,textparallel,2,0,0,double,1
+diagram,textparallel,3,0,0,double,1
+diagram,textparallel,4,0,0,double,1
+diagram,textparallel,5,0,0,double[],1
+diagram,textparallel,6,0,0,character,1
+diagram,textparallel,7,0,0,character,1
+diagram,textparallel,8,0,0,character,1
+diagram,textparallel,9,0,0,character,1
+diagram,textparallel,10,0,0,double,1
+diagram,textparallel,11,0,0,double,1
+diagram,textparallel,12,0,0,...,1
+diagram,textplain,-1,0,0,null,1
+diagram,textplain,0,0,0,double[],1
+diagram,textplain,1,0,0,any,1
+diagram,textplain,2,0,0,expression,1
+diagram,textplain,2,0,1,integer,1
+diagram,textplain,2,0,2,character[],1
+diagram,textplain,3,0,0,double[],1
+diagram,textplain,4,0,0,...,1
+diagram,textrect,-1,0,0,null,1
+diagram,textrect,0,0,0,double[],1
+diagram,textrect,1,0,0,double,1
+diagram,textrect,2,0,0,double,1
+diagram,textrect,3,0,0,double,1
+diagram,textrect,4,0,0,double,1
+diagram,textrect,5,0,0,double[],1
+diagram,textrect,6,0,0,character,1
+diagram,textrect,6,0,1,integer,1
+diagram,textrect,7,0,0,character,1
+diagram,textrect,8,0,0,character,1
+diagram,textrect,9,0,0,character,1
+diagram,textrect,10,0,0,double,1
+diagram,textrect,11,0,0,...,1
+diagram,textround,-1,0,0,null,1
+diagram,textround,0,0,0,double[],1
+diagram,textround,1,0,0,double,1
+diagram,textround,2,0,0,double,1
+diagram,textround,3,0,0,double,1
+diagram,textround,4,0,0,double,1
+diagram,textround,5,0,0,double[],1
+diagram,textround,6,0,0,character,1
+diagram,textround,7,0,0,character,1
+diagram,textround,8,0,0,character,1
+diagram,textround,9,0,0,character,1
+diagram,textround,10,0,0,double,1
+diagram,textround,11,0,0,double,1
+diagram,textround,12,0,0,...,1
+diagram,tpos,-1,0,0,list<double[]>,1
+diagram,tpos,0,0,0,double[],1
+diagram,tpos,1,0,0,double,1
+diagram,tpos,2,0,0,double,1
+diagram,treearrow,-1,0,0,class<`matrix`>,1
+diagram,treearrow,-1,0,1,null,1
+diagram,treearrow,0,0,0,class<`matrix`>,1
+diagram,treearrow,1,0,0,class<`matrix`>,1
+diagram,treearrow,1,0,1,double[],1
+diagram,treearrow,2,0,0,double,1
+diagram,treearrow,3,0,0,double,1
+diagram,treearrow,4,0,0,character,1
+diagram,treearrow,4,0,1,double,1
+diagram,treearrow,5,0,0,any,1
+diagram,treearrow,6,0,0,double,1
+diagram,treearrow,6,0,1,integer[],1
+diagram,treearrow,7,0,0,double,1
+diagram,treearrow,8,0,0,double,1
+diagram,treearrow,9,0,0,character,1
+diagram,treearrow,10,0,0,...,1
+diptest,aLine,-1,0,0,null,1
+diptest,aLine,0,0,0,class<`dip`>,1
+diptest,aLine,1,0,0,character,1
+diptest,aLine,2,0,0,character,1
+diptest,aLine,3,0,0,character,1
+diptest,aLine,4,0,0,double,1
+diptest,aLine,5,0,0,...,1
+diptest,dip,-1,0,0,class<`dip`>,1
+diptest,dip,-1,0,1,double,1
+diptest,dip,0,0,0,double[],1
+diptest,dip,1,0,0,character,1
+diptest,dip,1,0,1,logical,1
+diptest,dip,2,0,0,logical,1
+diptest,dip,3,0,0,double,1
+diptest,dip.test,-1,0,0,class<`htest`>,1
+diptest,dip.test,0,0,0,double[],1
+diptest,dip.test,1,0,0,logical,1
+diptest,dip.test,2,0,0,double,1
+diptest,getCM,-1,0,0,list<integer[]>,1
+diptest,getCM,0,0,0,integer[],1
+diptest,getCM,1,0,0,integer[],1
+diptest,getCM,2,0,0,integer,1
+diptest,plot.dip,-1,0,0,null,1
+diptest,plot.dip,0,0,0,class<`dip`>,1
+diptest,plot.dip,1,0,0,logical,1
+diptest,plot.dip,2,0,0,character,1
+diptest,plot.dip,3,0,0,character,1
+diptest,plot.dip,4,0,0,character,1
+diptest,plot.dip,5,0,0,character,1
+diptest,plot.dip,6,0,0,character,1
+diptest,plot.dip,7,0,0,logical,1
+diptest,plot.dip,8,0,0,logical,1
+diptest,plot.dip,9,0,0,...,1
+diptest,rdRDS,-1,0,0,class<`matrix`>,1
+diptest,rdRDS,0,0,0,...,1
+diptest,rdRDS,1,0,0,character,1
+distr,AbscontDistribution,-1,0,0,class<`AbscontDistribution`>,1
+distr,AbscontDistribution,0,0,0,class<`function`>,1
+distr,AbscontDistribution,0,0,1,null,1
+distr,AbscontDistribution,1,0,0,class<`function`>,1
+distr,AbscontDistribution,1,0,1,null,1
+distr,AbscontDistribution,2,0,0,class<`function`>,1
+distr,AbscontDistribution,2,0,1,null,1
+distr,AbscontDistribution,3,0,0,class<`function`>,1
+distr,AbscontDistribution,3,0,1,null,1
+distr,AbscontDistribution,4,0,0,class<`matrix`>,1
+distr,AbscontDistribution,4,0,1,null,1
+distr,AbscontDistribution,5,0,0,null,1
+distr,AbscontDistribution,6,0,0,class<`Reals`>,1
+distr,AbscontDistribution,7,0,0,logical,1
+distr,acPart,-1,0,0,class<`AbscontDistribution`>,1
+distr,acPart,-1,0,1,class<`AffLinAbscontDistribution`>,1
+distr,acPart,-1,0,2,class<`Chisq`>,1
+distr,acPart,-1,0,3,class<`DExp`>,1
+distr,acPart,-1,0,4,class<`Norm`>,1
+distr,acPart,-1,0,5,class<`Unif`>,1
+distr,acPart,0,0,0,class<`UnivarLebDecDistribution`>,1
+distr,acPart,0,0,1,class<`AffLinUnivarLebDecDistribution`>,1
+distr,acPart,-1,1,0,class<`AbscontDistribution`>,1
+distr,acPart,-1,1,1,class<`AffLinAbscontDistribution`>,1
+distr,acPart,-1,1,2,class<`Chisq`>,1
+distr,acPart,-1,1,3,class<`DExp`>,1
+distr,acPart,-1,1,4,class<`Norm`>,1
+distr,acPart,-1,1,5,class<`Unif`>,1
+distr,acPart,0,1,0,class<`UnivarLebDecDistribution`>,1
+distr,acPart,-1,2,0,class<`AffLinAbscontDistribution`>,1
+distr,acPart,0,2,0,class<`AffLinUnivarLebDecDistribution`>,1
+distr,acWeight,-1,0,0,double,1
+distr,acWeight,0,0,0,class<`AffLinUnivarLebDecDistribution`>,1
+distr,acWeight,-1,1,0,double,1
+distr,acWeight,0,1,0,class<`AffLinUnivarLebDecDistribution`>,1
+distr,acWeight,0,1,1,class<`UnivarLebDecDistribution`>,1
+distr,acWeight,-1,2,0,double,1
+distr,acWeight,0,2,0,class<`UnivarLebDecDistribution`>,1
+distr,Arcsine,-1,0,0,class<`Arcsine`>,1
+distr,Beta,-1,0,0,class<`Beta`>,1
+distr,Beta,0,0,0,double,1
+distr,Beta,1,0,0,double,1
+distr,Beta,2,0,0,double,1
+distr,Binom,-1,0,0,class<`Binom`>,1
+distr,Binom,0,0,0,double,1
+distr,Binom,1,0,0,double,1
+distr,.BinomCI.in,-1,0,0,double,1
+distr,.BinomCI.in,0,0,0,double,1
+distr,.BinomCI.in,1,0,0,double,1
+distr,.BinomCI.in,2,0,0,double,1
+distr,.BinomCI.in,3,0,0,double,1
+distr,.BinomCI.in,4,0,0,class<`Chisq`>,1
+distr,.BinomCI.in,4,0,1,class<`Norm`>,1
+distr,.BinomCI.in,5,0,0,double,1
+distr,.BinomCI.in,6,0,0,double,1
+distr,Cauchy,-1,0,0,class<`Cauchy`>,1
+distr,Cauchy,0,0,0,double,1
+distr,Cauchy,1,0,0,double,1
+distr,Chisq,-1,0,0,class<`Chisq`>,1
+distr,Chisq,0,0,0,double,1
+distr,Chisq,1,0,0,double,1
+distr,CompoundDistribution,-1,0,0,class<`CompoundDistribution`>,1
+distr,CompoundDistribution,0,0,0,class<`DiscreteDistribution`>,1
+distr,CompoundDistribution,0,0,1,class<`Pois`>,1
+distr,CompoundDistribution,1,0,0,class<`Norm`>,1
+distr,CompoundDistribution,1,0,1,class<`UnivarDistrList`>,1
+distr,CompoundDistribution,2,0,0,logical,1
+distr,CompoundDistribution,3,0,0,logical,1
+distr,.confqq,-1,0,0,list<class<`matrix`> | logical[]>,1
+distr,.confqq,0,0,0,double[],1
+distr,.confqq,1,0,0,class<`Chisq`>,1
+distr,.confqq,2,0,0,logical,1
+distr,.confqq,3,0,0,logical,1
+distr,.confqq,4,0,0,logical,1
+distr,.confqq,5,0,0,double,1
+distr,.confqq,6,0,0,character,1
+distr,.confqq,7,0,0,double,1
+distr,.consolidategaps,-1,0,0,class<`matrix`>,1
+distr,.consolidategaps,0,0,0,class<`matrix`>,1
+distr,.convDiscrDiscr,-1,0,0,class<`DiscreteDistribution`>,1
+distr,.convDiscrDiscr,0,0,0,class<`Binom`>,1
+distr,.convDiscrDiscr,0,0,1,class<`LatticeDistribution`>,1
+distr,.convDiscrDiscr,1,0,0,class<`AffLinLatticeDistribution`>,1
+distr,.convDiscrDiscr,1,0,1,class<`LatticeDistribution`>,1
+distr,.convDiscrDiscr,1,0,2,class<`Binom`>,1
+distr,convpow,-1,0,0,class<`Norm`>,1
+distr,convpow,0,0,0,class<`Norm`>,1
+distr,convpow,1,0,0,...,1
+distr,convpow,-1,1,0,class<`AbscontDistribution`>,1
+distr,convpow,0,1,0,class<`AbscontDistribution`>,1
+distr,convpow,1,1,0,...,1
+distr,convpow,-1,2,0,class<`AbscontDistribution`>,1
+distr,convpow,-1,2,1,class<`Norm`>,1
+distr,convpow,0,2,0,class<`AbscontDistribution`>,1
+distr,convpow,0,2,1,class<`Norm`>,1
+distr,convpow,1,2,0,...,1
+distr,d,-1,0,0,double[],1
+distr,d,0,0,0,double[],1
+distr,d,1,0,0,logical,1
+distr,d,-1,1,0,double[],1
+distr,d,0,1,0,double[],1
+distr,d,1,1,0,logical,1
+distr,d,-1,2,0,double[],1
+distr,d,0,2,0,integer[],1
+distr,d,1,2,0,logical,1
+distr,d,-1,3,0,^double[],1
+distr,d,0,3,0,^double[],1
+distr,d,1,3,0,logical,1
+distr,d,-1,4,0,double[],1
+distr,d,0,4,0,double[],1
+distr,d,1,4,0,logical,1
+distr,d,2,4,0,...,1
+distr,d,-1,5,0,double[],1
+distr,d,0,5,0,integer[],1
+distr,d,1,5,0,logical,1
+distr,d,-1,6,0,double[],1
+distr,d,0,6,0,double[],1
+distr,d,1,6,0,logical,1
+distr,d,-1,7,0,double[],1
+distr,d,0,7,0,double[],1
+distr,d,1,7,0,logical,1
+distr,d,-1,8,0,double,1
+distr,d,0,8,0,double,1
+distr,d,1,8,0,logical,1
+distr,d,-1,9,0,double,1
+distr,d,0,9,0,double,1
+distr,d,1,9,0,logical,1
+distr,d,-1,10,0,double[],1
+distr,d,0,10,0,double[],1
+distr,d,1,10,0,logical,1
+distr,d,-1,11,0,double,1
+distr,d,0,11,0,double,1
+distr,d,1,11,0,logical,1
+distr,d,-1,12,0,class<`function`>,1
+distr,d,0,12,0,class<`Beta`>,1
+distr,d,-1,13,0,double[],1
+distr,d,0,13,0,double[],1
+distr,d,1,13,0,logical,1
+distr,d,2,13,0,...,1
+distr,d,-1,14,0,double[],1
+distr,d,0,14,0,double[],1
+distr,d,1,14,0,logical,1
+distr,d,2,14,0,...,1
+distr,d,-1,15,0,double[],1
+distr,d,0,15,0,double[],1
+distr,d,1,15,0,logical,1
+distr,d,2,15,0,...,1
+distr,d,-1,16,0,double[],1
+distr,d,0,16,0,double[],1
+distr,d,1,16,0,logical,1
+distr,d,-1,17,0,double[],1
+distr,d,0,17,0,double[],1
+distr,d,1,17,0,logical,1
+distr,d,-1,18,0,double,1
+distr,d,0,18,0,double,1
+distr,d,1,18,0,logical,1
+distr,d,-1,19,0,double,1
+distr,d,0,19,0,double,1
+distr,d,1,19,0,logical,1
+distr,d,-1,20,0,double[],1
+distr,d,0,20,0,double[],1
+distr,d,1,20,0,logical,1
+distr,d,-1,21,0,class<`function`>,1
+distr,d,0,21,0,class<`AffLinAbscontDistribution`>,1
+distr,d,-1,22,0,class<`function`>,1
+distr,d,0,22,0,class<`Logis`>,1
+distr,d,-1,23,0,double[],1
+distr,d,0,23,0,double[],1
+distr,d,1,23,0,logical,1
+distr,d,-1,24,0,class<`function`>,1
+distr,d,0,24,0,class<`Cauchy`>,1
+distr,d,-1,25,0,double,1
+distr,d,0,25,0,double,1
+distr,d,1,25,0,logical,1
+distr,d,-1,26,0,double[],1
+distr,d,0,26,0,double[],1
+distr,d,1,26,0,logical,1
+distr,d,-1,27,0,double,1
+distr,d,0,27,0,double,1
+distr,d,1,27,0,logical,1
+distr,d,-1,28,0,double[],1
+distr,d,0,28,0,double[],1
+distr,d,1,28,0,logical,1
+distr,d,-1,29,0,double[],1
+distr,d,0,29,0,double[],1
+distr,d,1,29,0,logical,1
+distr,d,-1,30,0,double[],1
+distr,d,0,30,0,double[],1
+distr,d,1,30,0,logical,1
+distr,d,-1,31,0,double[],1
+distr,d,0,31,0,double[],1
+distr,d,1,31,0,logical,1
+distr,d,-1,32,0,class<`function`>,1
+distr,d,0,32,0,class<`Pois`>,1
+distr,d,-1,33,0,double[],1
+distr,d,0,33,0,double[],1
+distr,d,1,33,0,logical,1
+distr,d,-1,34,0,double,1
+distr,d,0,34,0,double,1
+distr,d,1,34,0,logical,1
+distr,d,-1,35,0,double[],1
+distr,d,0,35,0,integer[],1
+distr,d,1,35,0,logical,1
+distr,d,-1,36,0,double[],1
+distr,d,0,36,0,double[],1
+distr,d,1,36,0,logical,1
+distr,d,2,36,0,...,1
+distr,d,-1,37,0,class<`function`>,1
+distr,d,0,37,0,class<`DiscreteDistribution`>,1
+distr,d,-1,38,0,double[],1
+distr,d,0,38,0,double[],1
+distr,d,1,38,0,logical,1
+distr,d,-1,39,0,double[],1
+distr,d,0,39,0,double[],1
+distr,d,1,39,0,logical,1
+distr,d,-1,40,0,class<`function`>,1
+distr,d,0,40,0,class<`Nbinom`>,1
+distr,d,-1,41,0,double[],1
+distr,d,0,41,0,double[],1
+distr,d,1,41,0,logical,1
+distr,d,-1,42,0,double[],1
+distr,d,0,42,0,integer[],1
+distr,d,0,42,1,double,1
+distr,d,1,42,0,logical,1
+distr,d,-1,43,0,double[],1
+distr,d,0,43,0,double[],1
+distr,d,1,43,0,logical,1
+distr,d,-1,44,0,double,1
+distr,d,0,44,0,double,1
+distr,d,1,44,0,logical,1
+distr,d,-1,45,0,double[],1
+distr,d,0,45,0,double[],1
+distr,d,1,45,0,logical,1
+distr,d,-1,46,0,double,1
+distr,d,0,46,0,double,1
+distr,d,1,46,0,logical,1
+distr,d,-1,47,0,class<`function`>,1
+distr,d,0,47,0,class<`Binom`>,1
+distr,d,-1,48,0,class<`function`>,1
+distr,d,0,48,0,class<`AbscontDistribution`>,1
+distr,d,-1,49,0,double,1
+distr,d,0,49,0,double,1
+distr,d,1,49,0,logical,1
+distr,d,-1,50,0,double[],1
+distr,d,0,50,0,double[],1
+distr,d,1,50,0,logical,1
+distr,d,2,50,0,...,1
+distr,d,-1,51,0,double[],1
+distr,d,0,51,0,double[],1
+distr,d,1,51,0,logical,1
+distr,d,-1,52,0,double[],1
+distr,d,0,52,0,double[],1
+distr,d,1,52,0,logical,1
+distr,d,2,52,0,...,1
+distr,d,-1,53,0,class<`function`>,1
+distr,d,0,53,0,class<`Lnorm`>,1
+distr,d,-1,54,0,double,1
+distr,d,0,54,0,double,1
+distr,d,1,54,0,logical,1
+distr,d,-1,55,0,class<`function`>,1
+distr,d,0,55,0,class<`AffLinDiscreteDistribution`>,1
+distr,d,-1,56,0,class<`function`>,1
+distr,d,0,56,0,class<`Norm`>,1
+distr,d,-1,57,0,double[],1
+distr,d,0,57,0,double[],1
+distr,d,1,57,0,logical,1
+distr,d,-1,58,0,double[],1
+distr,d,0,58,0,double[],1
+distr,d,1,58,0,logical,1
+distr,d,-1,59,0,class<`function`>,1
+distr,d,0,59,0,class<`LatticeDistribution`>,1
+distr,d,-1,60,0,double[],1
+distr,d,0,60,0,double[],1
+distr,d,1,60,0,logical,1
+distr,d,-1,61,0,double,1
+distr,d,0,61,0,double,1
+distr,d,1,61,0,logical,1
+distr,d,-1,62,0,class<`function`>,1
+distr,d,0,62,0,class<`Arcsine`>,1
+distr,d,-1,63,0,double[],1
+distr,d,0,63,0,integer[],1
+distr,d,1,63,0,logical,1
+distr,d,-1,64,0,class<`function`>,1
+distr,d,0,64,0,class<`Gammad`>,1
+distr,d,-1,65,0,class<`function`>,1
+distr,d,0,65,0,class<`Dirac`>,1
+distr,d,-1,66,0,class<`function`>,1
+distr,d,0,66,0,class<`Geom`>,1
+distr,d,-1,67,0,class<`function`>,1
+distr,d,0,67,0,class<`Fd`>,1
+distr,d,-1,68,0,double[],1
+distr,d,0,68,0,double[],1
+distr,d,1,68,0,logical,1
+distr,d,-1,69,0,double,1
+distr,d,0,69,0,double,1
+distr,d,1,69,0,logical,1
+distr,d,-1,70,0,double[],1
+distr,d,0,70,0,double[],1
+distr,d,1,70,0,logical,1
+distr,d,-1,71,0,double[],1
+distr,d,0,71,0,double[],1
+distr,d,1,71,0,logical,1
+distr,d,-1,72,0,class<`function`>,1
+distr,d,0,72,0,class<`Chisq`>,1
+distr,d,-1,73,0,double,1
+distr,d,0,73,0,double,1
+distr,d,1,73,0,logical,1
+distr,d,-1,74,0,class<`function`>,1
+distr,d,0,74,0,class<`Weibull`>,1
+distr,d,-1,75,0,double[],1
+distr,d,0,75,0,double[],1
+distr,d,1,75,0,logical,1
+distr,d,-1,76,0,double[],1
+distr,d,0,76,0,double[],1
+distr,d,1,76,0,logical,1
+distr,d,-1,77,0,double[],1
+distr,d,0,77,0,double[],1
+distr,d,1,77,0,logical,1
+distr,d,-1,78,0,class<`function`>,1
+distr,d,0,78,0,class<`DExp`>,1
+distr,d,-1,79,0,double[],1
+distr,d,0,79,0,double[],1
+distr,d,1,79,0,logical,1
+distr,d,2,79,0,...,1
+distr,d,-1,80,0,class<`function`>,1
+distr,d,0,80,0,class<`Td`>,1
+distr,d,-1,81,0,double[],1
+distr,d,0,81,0,double[],1
+distr,d,1,81,0,logical,1
+distr,d,-1,82,0,double[],1
+distr,d,0,82,0,double[],1
+distr,d,1,82,0,logical,1
+distr,d,2,82,0,...,1
+distr,d,-1,83,0,class<`function`>,1
+distr,d,0,83,0,class<`Exp`>,1
+distr,d,-1,84,0,class<`function`>,1
+distr,d,0,84,0,class<`AffLinLatticeDistribution`>,1
+distr,d,-1,85,0,double[],1
+distr,d,0,85,0,double[],1
+distr,d,1,85,0,logical,1
+distr,d,-1,86,0,double[],1
+distr,d,0,86,0,double[],1
+distr,d,1,86,0,logical,1
+distr,d,-1,87,0,class<`function`>,1
+distr,d,0,87,0,class<`Unif`>,1
+distr,d,-1,88,0,class<`function`>,1
+distr,d,0,88,0,class<`Hyper`>,1
+distr,d,-1,89,0,class<`function`>,1
+distr,d,0,89,0,class<`AbscontDistribution`>,1
+distr,d,0,89,1,class<`AffLinAbscontDistribution`>,1
+distr,d,0,89,2,class<`AffLinDiscreteDistribution`>,1
+distr,d,0,89,3,class<`AffLinLatticeDistribution`>,1
+distr,d,0,89,4,class<`Beta`>,1
+distr,d,0,89,5,class<`Binom`>,1
+distr,d,0,89,6,class<`Cauchy`>,1
+distr,d,0,89,7,class<`Chisq`>,1
+distr,d,0,89,8,class<`DExp`>,1
+distr,d,0,89,9,class<`Dirac`>,1
+distr,d,0,89,10,class<`DiscreteDistribution`>,1
+distr,d,0,89,11,class<`Exp`>,1
+distr,d,0,89,12,class<`Fd`>,1
+distr,d,0,89,13,class<`Gammad`>,1
+distr,d,0,89,14,class<`Geom`>,1
+distr,d,0,89,15,class<`Hyper`>,1
+distr,d,0,89,16,class<`LatticeDistribution`>,1
+distr,d,0,89,17,class<`Lnorm`>,1
+distr,d,0,89,18,class<`Logis`>,1
+distr,d,0,89,19,class<`Nbinom`>,1
+distr,d,0,89,20,class<`Norm`>,1
+distr,d,0,89,21,class<`Pois`>,1
+distr,d,0,89,22,class<`Td`>,1
+distr,d,0,89,23,class<`Unif`>,1
+distr,d,0,89,24,class<`Weibull`>,1
+distr,d,0,89,25,class<`Arcsine`>,1
+distr,d,-1,90,0,double[],1
+distr,d,0,90,0,double[],1
+distr,d,1,90,0,logical,1
+distr,d,-1,91,0,double[],1
+distr,d,0,91,0,double[],1
+distr,d,1,91,0,logical,1
+distr,d,-1,92,0,double,1
+distr,d,0,92,0,double,1
+distr,d,1,92,0,logical,1
+distr,d,-1,93,0,double,1
+distr,d,0,93,0,double,1
+distr,d,1,93,0,logical,1
+distr,d,-1,94,0,double,1
+distr,d,0,94,0,double,1
+distr,d,1,94,0,logical,1
+distr,d,-1,95,0,double,1
+distr,d,0,95,0,double,1
+distr,d,1,95,0,logical,1
+distr,.D2P,-1,0,0,class<`function`>,1
+distr,.D2P,0,0,0,class<`function`>,1
+distr,.D2P,1,0,0,any,1
+distr,.D2P,2,0,0,double,1
+distr,.D2P,3,0,0,double,1
+distr,.D2P,4,0,0,double,1
+distr,d.discrete,-1,0,0,^double[],1
+distr,d.discrete,0,0,0,^double[],1
+distr,d.discrete,1,0,0,logical,1
+distr,d.discrete,-1,1,0,double[],1
+distr,d.discrete,0,1,0,double[],1
+distr,d.discrete,1,1,0,logical,1
+distr,d.discrete,-1,2,0,double[],1
+distr,d.discrete,0,2,0,double[],1
+distr,d.discrete,1,2,0,logical,1
+distr,d.discrete,-1,3,0,double[],1
+distr,d.discrete,0,3,0,double[],1
+distr,d.discrete,1,3,0,logical,1
+distr,d.discrete,-1,4,0,class<`function`>,1
+distr,d.discrete,0,4,0,class<`UnivarLebDecDistribution`>,1
+distr,d.discrete,1,4,0,...,1
+distr,d.discrete,-1,5,0,class<`function`>,1
+distr,d.discrete,0,5,0,class<`UnivarLebDecDistribution`>,1
+distr,d.discrete,1,5,0,...,1
+distr,decomposePM,-1,0,0,list<list<class<`UnivarLebDecDistribution`> | double | class<`Dirac`> | double>>,1
+distr,decomposePM,0,0,0,class<`UnivarLebDecDistribution`>,1
+distr,decomposePM,-1,1,0,list<list<class<`AbscontDistribution`> | double>>,1
+distr,decomposePM,0,1,0,class<`AbscontDistribution`>,1
+distr,decomposePM,-1,2,0,list<list<class<`Dirac`> | double | class<`DiscreteDistribution`> | double>>,1
+distr,decomposePM,0,2,0,class<`DiscreteDistribution`>,1
+distr,decomposePM,-1,3,0,list<list<class<`AbscontDistribution`> | double>>,1
+distr,decomposePM,0,3,0,class<`Norm`>,1
+distr,decomposePM,-1,4,0,list<list<class<`DiscreteDistribution`> | double | class<`Dirac`> | double>>,1
+distr,decomposePM,0,4,0,class<`LatticeDistribution`>,1
+distr,decomposePM,-1,5,0,list<list<class<`AbscontDistribution`> | double>>,1
+distr,decomposePM,-1,5,1,list<list<class<`Dirac`> | double | class<`DiscreteDistribution`> | double>>,1
+distr,decomposePM,-1,5,2,list<list<class<`DiscreteDistribution`> | double | class<`Dirac`> | double>>,1
+distr,decomposePM,-1,5,3,list<list<class<`UnivarLebDecDistribution`> | double | class<`Dirac`> | double>>,1
+distr,decomposePM,0,5,0,class<`AbscontDistribution`>,1
+distr,decomposePM,0,5,1,class<`Norm`>,1
+distr,decomposePM,0,5,2,class<`DiscreteDistribution`>,1
+distr,decomposePM,0,5,3,class<`LatticeDistribution`>,1
+distr,decomposePM,0,5,4,class<`UnivarLebDecDistribution`>,1
+distr,.del0dmixfun,-1,0,0,class<`UnivarLebDecDistribution`>,1
+distr,.del0dmixfun,0,0,0,class<`UnivarLebDecDistribution`>,1
+distr,.deleteItemsMCL,-1,0,0,list<double[] | character>,1
+distr,.deleteItemsMCL,0,0,0,list<double[] | character>,1
+distr,devNew,-1,0,0,null,1
+distr,devNew,0,0,0,...,1
+distr,DExp,-1,0,0,class<`DExp`>,1
+distr,DExp,0,0,0,double,1
+distr,df,-1,0,0,double,1
+distr,df,0,0,0,class<`TParameter`>,1
+distr,df,1,0,0,...,1
+distr,df,-1,1,0,double,1
+distr,df,0,1,0,class<`Chisq`>,1
+distr,df,1,1,0,...,1
+distr,df,-1,2,0,double,1
+distr,df,0,2,0,class<`ChisqParameter`>,1
+distr,df,1,2,0,...,1
+distr,df,-1,3,0,double,1
+distr,df,0,3,0,class<`Chisq`>,1
+distr,df,0,3,1,class<`ChisqParameter`>,1
+distr,df,0,3,2,class<`Td`>,1
+distr,df,0,3,3,class<`TParameter`>,1
+distr,df,1,3,0,...,1
+distr,df,-1,4,0,double,1
+distr,df,0,4,0,class<`Td`>,1
+distr,df,1,4,0,...,1
+distr,df<-,-1,0,0,class<`TParameter`>,1
+distr,df<-,0,0,0,class<`TParameter`>,1
+distr,df<-,1,0,0,double,1
+distr,df<-,-1,1,0,class<`Chisq`>,1
+distr,df<-,0,1,0,class<`Chisq`>,1
+distr,df<-,1,1,0,double,1
+distr,df<-,-1,2,0,class<`Td`>,1
+distr,df<-,0,2,0,class<`Td`>,1
+distr,df<-,1,2,0,double,1
+distr,df<-,-1,3,0,class<`Chisq`>,1
+distr,df<-,-1,3,1,class<`Td`>,1
+distr,df<-,-1,3,2,class<`TParameter`>,1
+distr,df<-,0,3,0,class<`Chisq`>,1
+distr,df<-,0,3,1,class<`Td`>,1
+distr,df<-,0,3,2,class<`TParameter`>,1
+distr,df<-,1,3,0,double,1
+distr,df1,-1,0,0,double,1
+distr,df1,0,0,0,class<`FParameter`>,1
+distr,df1,-1,1,0,double,1
+distr,df1,0,1,0,class<`Fd`>,1
+distr,df1,-1,2,0,double,1
+distr,df1,0,2,0,class<`Fd`>,1
+distr,df1,0,2,1,class<`FParameter`>,1
+distr,df1<-,-1,0,0,class<`Fd`>,1
+distr,df1<-,0,0,0,class<`Fd`>,1
+distr,df1<-,1,0,0,double,1
+distr,df1<-,-1,1,0,class<`Fd`>,1
+distr,df1<-,0,1,0,class<`Fd`>,1
+distr,df1<-,1,1,0,double,1
+distr,df2,-1,0,0,double,1
+distr,df2,0,0,0,class<`Fd`>,1
+distr,df2,0,0,1,class<`FParameter`>,1
+distr,df2,-1,1,0,double,1
+distr,df2,0,1,0,class<`Fd`>,1
+distr,df2,-1,2,0,double,1
+distr,df2,0,2,0,class<`FParameter`>,1
+distr,df2<-,-1,0,0,class<`FParameter`>,1
+distr,df2<-,0,0,0,class<`FParameter`>,1
+distr,df2<-,1,0,0,double,1
+distr,df2<-,-1,1,0,class<`FParameter`>,1
+distr,df2<-,0,1,0,class<`FParameter`>,1
+distr,df2<-,1,1,0,double,1
+distr,dimension,-1,0,0,double,1
+distr,dimension,0,0,0,class<`Reals`>,1
+distr,dimension,-1,1,0,double,1
+distr,dimension,0,1,0,class<`EuclideanSpace`>,1
+distr,dimension,-1,2,0,double,1
+distr,dimension,0,2,0,class<`EuclideanSpace`>,1
+distr,dimension,0,2,1,class<`Reals`>,1
+distr,dimension<-,-1,0,0,class<`EuclideanSpace`>,1
+distr,dimension<-,0,0,0,class<`EuclideanSpace`>,1
+distr,dimension<-,1,0,0,double,1
+distr,dimension<-,-1,1,0,class<`EuclideanSpace`>,1
+distr,dimension<-,0,1,0,class<`EuclideanSpace`>,1
+distr,dimension<-,1,1,0,double,1
+distr,Dirac,-1,0,0,class<`Dirac`>,1
+distr,Dirac,0,0,0,double,1
+distr,DiscreteDistribution,-1,0,0,class<`DiscreteDistribution`>,1
+distr,DiscreteDistribution,0,0,0,double[],1
+distr,DiscreteDistribution,1,0,0,any,1
+distr,DiscreteDistribution,2,0,0,logical,1
+distr,DiscreteDistribution,3,0,0,logical,1
+distr,DiscreteDistribution,4,0,0,logical,1
+distr,DiscreteDistribution,5,0,0,logical,1
+distr,DiscreteDistribution,6,0,0,logical,1
+distr,DiscreteDistribution,7,0,0,any,1
+distr,discretePart,-1,0,0,class<`AffLinDiscreteDistribution`>,1
+distr,discretePart,-1,0,1,class<`Binom`>,1
+distr,discretePart,-1,0,2,class<`Dirac`>,1
+distr,discretePart,-1,0,3,class<`DiscreteDistribution`>,1
+distr,discretePart,-1,0,4,class<`LatticeDistribution`>,1
+distr,discretePart,-1,0,5,class<`Nbinom`>,1
+distr,discretePart,-1,0,6,class<`Pois`>,1
+distr,discretePart,0,0,0,class<`AffLinUnivarLebDecDistribution`>,1
+distr,discretePart,0,0,1,class<`UnivarLebDecDistribution`>,1
+distr,discretePart,-1,1,0,class<`Binom`>,1
+distr,discretePart,-1,1,1,class<`Dirac`>,1
+distr,discretePart,-1,1,2,class<`DiscreteDistribution`>,1
+distr,discretePart,-1,1,3,class<`LatticeDistribution`>,1
+distr,discretePart,-1,1,4,class<`Nbinom`>,1
+distr,discretePart,-1,1,5,class<`Pois`>,1
+distr,discretePart,0,1,0,class<`UnivarLebDecDistribution`>,1
+distr,discretePart,-1,2,0,class<`AffLinDiscreteDistribution`>,1
+distr,discretePart,0,2,0,class<`AffLinUnivarLebDecDistribution`>,1
+distr,discretePart<-,-1,0,0,class<`UnivarLebDecDistribution`>,1
+distr,discretePart<-,0,0,0,class<`UnivarLebDecDistribution`>,1
+distr,discretePart<-,1,0,0,class<`Dirac`>,1
+distr,discretePart<-,-1,1,0,class<`UnivarLebDecDistribution`>,1
+distr,discretePart<-,0,1,0,class<`UnivarLebDecDistribution`>,1
+distr,discretePart<-,1,1,0,class<`Dirac`>,1
+distr,discreteWeight,-1,0,0,double,1
+distr,discreteWeight,0,0,0,class<`UnivarLebDecDistribution`>,1
+distr,discreteWeight,-1,1,0,double,1
+distr,discreteWeight,0,1,0,class<`UnivarLebDecDistribution`>,1
+distr,.discretizeP,-1,0,0,double[],1
+distr,.discretizeP,0,0,0,class<`AbscontDistribution`>,1
+distr,.discretizeP,0,0,1,class<`AffLinAbscontDistribution`>,1
+distr,.discretizeP,0,0,2,class<`Chisq`>,1
+distr,.discretizeP,0,0,3,class<`Exp`>,1
+distr,.discretizeP,0,0,4,class<`Norm`>,1
+distr,.discretizeP,0,0,5,class<`Td`>,1
+distr,.discretizeP,1,0,0,double,1
+distr,.discretizeP,2,0,0,double,1
+distr,.discretizeP,3,0,0,double,1
+distr,distrARITH,-1,0,0,null,1
+distr,distrARITH,0,0,0,null,1
+distr,DistrList,-1,0,0,class<`DistrList`>,1
+distr,DistrList,0,0,0,...,1
+distr,DistrList,1,0,0,any,1
+distr,distrMASK,-1,0,0,null,1
+distr,distrMASK,0,0,0,null,1
+distr,distroptions,-1,0,0,list<double>,1
+distr,distroptions,0,0,0,...,1
+distr,DistrSymmList,-1,0,0,class<`DistrSymmList`>,1
+distr,DistrSymmList,0,0,0,...,1
+distr,.dmixfun,-1,0,0,class<`function`>,1
+distr,.dmixfun,0,0,0,any,1
+distr,.dmixfun,1,0,0,double[],1
+distr,.dmixfun,2,0,0,logical,1
+distr,.dmixfun,3,0,0,null,1
+distr,.dmixfun,3,0,1,double[],1
+distr,EllipticalSymmetry,-1,0,0,class<`EllipticalSymmetry`>,1
+distr,EllipticalSymmetry,0,0,0,double,1
+distr,EmpiricalDistribution,-1,0,0,class<`DiscreteDistribution`>,1
+distr,EmpiricalDistribution,0,0,0,double[],1
+distr,EmpiricalDistribution,1,0,0,logical,1
+distr,EmpiricalDistribution,2,0,0,logical,1
+distr,EmpiricalDistribution,3,0,0,logical,1
+distr,EmpiricalDistribution,4,0,0,logical,1
+distr,EmpiricalDistribution,5,0,0,logical,1
+distr,EmpiricalDistribution,6,0,0,any,1
+distr,EmpiricalDistribution,7,0,0,double,1
+distr,.EuclidAlgo,-1,0,0,double,1
+distr,.EuclidAlgo,0,0,0,double,1
+distr,.EuclidAlgo,1,0,0,double,1
+distr,EuclideanSpace,-1,0,0,class<`EuclideanSpace`>,1
+distr,EuclideanSpace,0,0,0,double,1
+distr,Exp,-1,0,0,class<`Exp`>,1
+distr,Exp,0,0,0,double,1
+distr,.expm.c,-1,0,0,class<`AbscontDistribution`>,1
+distr,.expm.c,0,0,0,class<`AbscontDistribution`>,1
+distr,.expm.c,0,0,1,class<`AffLinAbscontDistribution`>,1
+distr,Fd,-1,0,0,class<`Fd`>,1
+distr,Fd,0,0,0,double,1
+distr,Fd,1,0,0,double,1
+distr,Fd,2,0,0,double,1
+distr,.fillList,-1,0,0,list<class<`call`>>,1
+distr,.fillList,-1,0,1,list<expression | character>,1
+distr,.fillList,-1,0,2,list<expression>,1
+distr,.fillList,0,0,0,class<`call`>,1
+distr,.fillList,0,0,1,list<class<`call`>>,1
+distr,.fillList,0,0,2,list<expression | character>,1
+distr,.fillList,0,0,3,expression,1
+distr,.fillList,0,0,4,list<expression>,1
+distr,.fillList,1,0,0,integer,1
+distr,flat.LCD,-1,0,0,class<`UnivarLebDecDistribution`>,1
+distr,flat.LCD,0,0,0,...,1
+distr,flat.LCD,1,0,0,double[],1
+distr,flat.LCD,2,0,0,any,1
+distr,flat.mix,-1,0,0,class<`AbscontDistribution`>,1
+distr,flat.mix,-1,0,1,class<`UnivarLebDecDistribution`>,1
+distr,flat.mix,0,0,0,class<`CompoundDistribution`>,1
+distr,flat.mix,0,0,1,class<`UnivarMixingDistribution`>,1
+distr,.fM,-1,0,0,double,1
+distr,.fM,0,0,0,double,1
+distr,.fM,1,0,0,class<`function`>,1
+distr,Gammad,-1,0,0,class<`Gammad`>,1
+distr,Gammad,0,0,0,double,1
+distr,Gammad,1,0,0,double,1
+distr,gaps,-1,0,0,class<`matrix`>,1
+distr,gaps,-1,0,1,null,1
+distr,gaps,0,0,0,class<`Chisq`>,1
+distr,gaps,-1,1,0,class<`matrix`>,1
+distr,gaps,-1,1,1,null,1
+distr,gaps,0,1,0,class<`AbscontDistribution`>,1
+distr,gaps,-1,2,0,null,1
+distr,gaps,0,2,0,class<`UnivarMixingDistribution`>,1
+distr,gaps,-1,3,0,null,1
+distr,gaps,0,3,0,class<`DExp`>,1
+distr,gaps,-1,4,0,null,1
+distr,gaps,0,4,0,class<`Exp`>,1
+distr,gaps,-1,5,0,class<`matrix`>,1
+distr,gaps,-1,5,1,null,1
+distr,gaps,0,5,0,class<`AffLinAbscontDistribution`>,1
+distr,gaps,-1,6,0,null,1
+distr,gaps,0,6,0,class<`AffLinUnivarLebDecDistribution`>,1
+distr,gaps,-1,7,0,null,1
+distr,gaps,0,7,0,class<`Unif`>,1
+distr,gaps,-1,8,0,null,1
+distr,gaps,0,8,0,class<`Norm`>,1
+distr,gaps,-1,9,0,null,1
+distr,gaps,0,9,0,class<`Cauchy`>,1
+distr,gaps,-1,10,0,any,1
+distr,gaps,0,10,0,class<`AbscontDistribution`>,1
+distr,gaps,0,10,1,class<`AffLinAbscontDistribution`>,1
+distr,gaps,0,10,2,class<`Chisq`>,1
+distr,gaps,0,10,3,class<`UnivarLebDecDistribution`>,1
+distr,gaps,0,10,4,class<`Binom`>,1
+distr,gaps,0,10,5,class<`Dirac`>,1
+distr,gaps,0,10,6,class<`Pois`>,1
+distr,gaps,0,10,7,class<`AffLinUnivarLebDecDistribution`>,1
+distr,gaps,0,10,8,class<`Cauchy`>,1
+distr,gaps,0,10,9,class<`DExp`>,1
+distr,gaps,0,10,10,class<`Exp`>,1
+distr,gaps,0,10,11,class<`Norm`>,1
+distr,gaps,0,10,12,class<`Unif`>,1
+distr,gaps,0,10,13,class<`UnivarMixingDistribution`>,1
+distr,gaps,-1,11,0,class<`matrix`>,1
+distr,gaps,-1,11,1,null,1
+distr,gaps,0,11,0,class<`UnivarLebDecDistribution`>,1
+distr,Geom,-1,0,0,class<`Geom`>,1
+distr,Geom,0,0,0,double,1
+distr,.getCommonWidth,-1,0,0,double,1
+distr,.getCommonWidth,0,0,0,double,1
+distr,.getCommonWidth,1,0,0,double,1
+distr,.getCommonWidth,2,0,0,double,1
+distr,getdistrOption,-1,0,0,double,1
+distr,getdistrOption,0,0,0,character,1
+distr,getLabel,-1,0,0,character,1
+distr,getLabel,0,0,0,class<`Exp`>,1
+distr,getLabel,0,0,1,class<`Norm`>,1
+distr,getLabel,0,0,2,class<`Weibull`>,1
+distr,getLabel,1,0,0,logical,1
+distr,getLow,-1,0,0,double,1
+distr,getLow,0,0,0,class<`Cauchy`>,1
+distr,getLow,1,0,0,...,1
+distr,getLow,-1,1,0,double,1
+distr,getLow,0,1,0,class<`Chisq`>,1
+distr,getLow,1,1,0,...,1
+distr,getLow,-1,2,0,double,1
+distr,getLow,0,2,0,class<`Nbinom`>,1
+distr,getLow,1,2,0,...,1
+distr,getLow,-1,3,0,integer,1
+distr,getLow,0,3,0,class<`Binom`>,1
+distr,getLow,1,3,0,...,1
+distr,getLow,-1,4,0,double,1
+distr,getLow,0,4,0,class<`Norm`>,1
+distr,getLow,1,4,0,...,1
+distr,getLow,-1,5,0,double,1
+distr,getLow,0,5,0,class<`AffLinUnivarLebDecDistribution`>,1
+distr,getLow,1,5,0,...,1
+distr,getLow,-1,6,0,double,1
+distr,getLow,0,6,0,class<`Unif`>,1
+distr,getLow,1,6,0,...,1
+distr,getLow,-1,7,0,double,1
+distr,getLow,0,7,0,class<`Td`>,1
+distr,getLow,1,7,0,...,1
+distr,getLow,-1,8,0,double,1
+distr,getLow,0,8,0,class<`DiscreteDistribution`>,1
+distr,getLow,1,8,0,...,1
+distr,getLow,-1,9,0,double,1
+distr,getLow,0,9,0,class<`AffLinDiscreteDistribution`>,1
+distr,getLow,1,9,0,...,1
+distr,getLow,-1,10,0,class<`Integer`>,1
+distr,getLow,-1,10,1,double,1
+distr,getLow,0,10,0,class<`AbscontDistribution`>,1
+distr,getLow,1,10,0,...,1
+distr,getLow,-1,11,0,double,1
+distr,getLow,0,11,0,class<`LatticeDistribution`>,1
+distr,getLow,1,11,0,...,1
+distr,getLow,-1,12,0,double,1
+distr,getLow,0,12,0,class<`Exp`>,1
+distr,getLow,1,12,0,...,1
+distr,getLow,-1,13,0,class<`Integer`>,1
+distr,getLow,-1,13,1,double,1
+distr,getLow,0,13,0,class<`AbscontDistribution`>,1
+distr,getLow,0,13,1,class<`AffLinAbscontDistribution`>,1
+distr,getLow,0,13,2,class<`AffLinDiscreteDistribution`>,1
+distr,getLow,0,13,3,class<`AffLinLatticeDistribution`>,1
+distr,getLow,0,13,4,class<`AffLinUnivarLebDecDistribution`>,1
+distr,getLow,0,13,5,class<`Cauchy`>,1
+distr,getLow,0,13,6,class<`Chisq`>,1
+distr,getLow,0,13,7,class<`Dirac`>,1
+distr,getLow,0,13,8,class<`DiscreteDistribution`>,1
+distr,getLow,0,13,9,class<`Exp`>,1
+distr,getLow,0,13,10,class<`LatticeDistribution`>,1
+distr,getLow,0,13,11,class<`Nbinom`>,1
+distr,getLow,0,13,12,class<`Norm`>,1
+distr,getLow,0,13,13,class<`Pois`>,1
+distr,getLow,0,13,14,class<`Td`>,1
+distr,getLow,0,13,15,class<`Unif`>,1
+distr,getLow,0,13,16,class<`Binom`>,1
+distr,getLow,0,13,17,class<`Geom`>,1
+distr,getLow,1,13,0,...,1
+distr,getLow,-1,14,0,double,1
+distr,getLow,0,14,0,class<`Dirac`>,1
+distr,getLow,1,14,0,...,1
+distr,getLow,-1,15,0,double,1
+distr,getLow,0,15,0,class<`AffLinLatticeDistribution`>,1
+distr,getLow,1,15,0,...,1
+distr,getLow,-1,16,0,integer,1
+distr,getLow,0,16,0,class<`Geom`>,1
+distr,getLow,1,16,0,...,1
+distr,getLow,-1,17,0,double,1
+distr,getLow,0,17,0,class<`AffLinAbscontDistribution`>,1
+distr,getLow,1,17,0,...,1
+distr,getLow,-1,18,0,double,1
+distr,getLow,0,18,0,class<`Pois`>,1
+distr,getLow,1,18,0,...,1
+distr,.getObjName,-1,0,0,character,1
+distr,.getObjName,0,0,0,double,1
+distr,getUp,-1,0,0,double,1
+distr,getUp,0,0,0,class<`AffLinLatticeDistribution`>,1
+distr,getUp,1,0,0,...,1
+distr,getUp,-1,1,0,double,1
+distr,getUp,0,1,0,class<`Exp`>,1
+distr,getUp,1,1,0,...,1
+distr,getUp,-1,2,0,double,1
+distr,getUp,0,2,0,class<`DiscreteDistribution`>,1
+distr,getUp,1,2,0,...,1
+distr,getUp,-1,3,0,double,1
+distr,getUp,0,3,0,class<`Td`>,1
+distr,getUp,1,3,0,...,1
+distr,getUp,-1,4,0,double,1
+distr,getUp,0,4,0,class<`Pois`>,1
+distr,getUp,1,4,0,...,1
+distr,getUp,-1,5,0,double,1
+distr,getUp,0,5,0,class<`AffLinAbscontDistribution`>,1
+distr,getUp,1,5,0,...,1
+distr,getUp,-1,6,0,double,1
+distr,getUp,0,6,0,class<`Unif`>,1
+distr,getUp,1,6,0,...,1
+distr,getUp,-1,7,0,integer,1
+distr,getUp,0,7,0,class<`Binom`>,1
+distr,getUp,1,7,0,...,1
+distr,getUp,-1,8,0,double,1
+distr,getUp,0,8,0,class<`Nbinom`>,1
+distr,getUp,1,8,0,...,1
+distr,getUp,-1,9,0,double,1
+distr,getUp,0,9,0,class<`AffLinDiscreteDistribution`>,1
+distr,getUp,1,9,0,...,1
+distr,getUp,-1,10,0,double,1
+distr,getUp,0,10,0,class<`Dirac`>,1
+distr,getUp,1,10,0,...,1
+distr,getUp,-1,11,0,double,1
+distr,getUp,0,11,0,class<`Geom`>,1
+distr,getUp,1,11,0,...,1
+distr,getUp,-1,12,0,class<`Integer`>,1
+distr,getUp,-1,12,1,double,1
+distr,getUp,0,12,0,class<`AbscontDistribution`>,1
+distr,getUp,0,12,1,class<`AffLinAbscontDistribution`>,1
+distr,getUp,0,12,2,class<`AffLinDiscreteDistribution`>,1
+distr,getUp,0,12,3,class<`AffLinLatticeDistribution`>,1
+distr,getUp,0,12,4,class<`AffLinUnivarLebDecDistribution`>,1
+distr,getUp,0,12,5,class<`Cauchy`>,1
+distr,getUp,0,12,6,class<`Chisq`>,1
+distr,getUp,0,12,7,class<`Dirac`>,1
+distr,getUp,0,12,8,class<`DiscreteDistribution`>,1
+distr,getUp,0,12,9,class<`Exp`>,1
+distr,getUp,0,12,10,class<`Geom`>,1
+distr,getUp,0,12,11,class<`LatticeDistribution`>,1
+distr,getUp,0,12,12,class<`Nbinom`>,1
+distr,getUp,0,12,13,class<`Norm`>,1
+distr,getUp,0,12,14,class<`Pois`>,1
+distr,getUp,0,12,15,class<`Td`>,1
+distr,getUp,0,12,16,class<`Unif`>,1
+distr,getUp,0,12,17,class<`Binom`>,1
+distr,getUp,1,12,0,...,1
+distr,getUp,-1,13,0,double,1
+distr,getUp,0,13,0,class<`Chisq`>,1
+distr,getUp,1,13,0,...,1
+distr,getUp,-1,14,0,double,1
+distr,getUp,0,14,0,class<`Cauchy`>,1
+distr,getUp,1,14,0,...,1
+distr,getUp,-1,15,0,double,1
+distr,getUp,0,15,0,class<`AffLinUnivarLebDecDistribution`>,1
+distr,getUp,1,15,0,...,1
+distr,getUp,-1,16,0,double,1
+distr,getUp,0,16,0,class<`Norm`>,1
+distr,getUp,1,16,0,...,1
+distr,getUp,-1,17,0,class<`Integer`>,1
+distr,getUp,-1,17,1,double,1
+distr,getUp,0,17,0,class<`AbscontDistribution`>,1
+distr,getUp,1,17,0,...,1
+distr,getUp,-1,18,0,double,1
+distr,getUp,0,18,0,class<`LatticeDistribution`>,1
+distr,getUp,1,18,0,...,1
+distr,Huberize,-1,0,0,class<`AffLinUnivarLebDecDistribution`>,1
+distr,Huberize,0,0,0,class<`Norm`>,1
+distr,Huberize,1,0,0,...,1
+distr,Huberize,-1,1,0,class<`AffLinUnivarLebDecDistribution`>,1
+distr,Huberize,0,1,0,class<`Norm`>,1
+distr,Huberize,1,1,0,...,1
+distr,Hyper,-1,0,0,class<`Hyper`>,1
+distr,Hyper,0,0,0,double,1
+distr,Hyper,1,0,0,double,1
+distr,Hyper,2,0,0,double,1
+distr,img,-1,0,0,class<`Reals`>,1
+distr,img,0,0,0,class<`AffLinUnivarLebDecDistribution`>,1
+distr,img,-1,1,0,class<`Reals`>,1
+distr,img,0,1,0,class<`AffLinUnivarLebDecDistribution`>,1
+distr,.inArgs,-1,0,0,logical,1
+distr,.inArgs,0,0,0,character,1
+distr,.inArgs,1,0,0,class<`function`>,1
+distr,.inGaps,-1,0,0,logical[],1
+distr,.inGaps,0,0,0,double[],1
+distr,.inGaps,1,0,0,null,1
+distr,.inWithTol,-1,0,0,logical[],1
+distr,.inWithTol,0,0,0,double[],1
+distr,.inWithTol,1,0,0,double[],1
+distr,.inWithTol,2,0,0,double,1
+distr,.isEqual,-1,0,0,logical[],1
+distr,.isEqual,0,0,0,double[],1
+distr,.isEqual,0,0,1,class<`Integer`>,1
+distr,.isEqual,1,0,0,double,1
+distr,.isEqual,2,0,0,double,1
+distr,.isEqual01,-1,0,0,logical[],1
+distr,.isEqual01,0,0,0,double[],1
+distr,.isIn,-1,0,0,logical[],1
+distr,.isIn,0,0,0,double[],1
+distr,.isIn,1,0,0,class<`matrix`>,1
+distr,.isIn,2,0,0,double,1
+distr,.isInteger,-1,0,0,logical[],1
+distr,.isInteger,0,0,0,double[],1
+distr,.isInteger,0,0,1,class<`Integer`>,1
+distr,.isInteger,1,0,0,double,1
+distr,.isNatural,-1,0,0,logical,1
+distr,.isNatural,0,0,0,double,1
+distr,.isNatural,1,0,0,double,1
+distr,.isNatural0,-1,0,0,logical,1
+distr,.isNatural0,0,0,0,double,1
+distr,.isNatural0,1,0,0,double,1
+distr,isOldVersion,-1,0,0,logical,1
+distr,isOldVersion,0,0,0,class<`AffLinAbscontDistribution`>,1
+distr,isOldVersion,-1,1,0,logical,1
+distr,isOldVersion,0,1,0,class<`Exp`>,1
+distr,isOldVersion,-1,2,0,logical,1
+distr,isOldVersion,0,2,0,class<`AbscontDistribution`>,1
+distr,isOldVersion,0,2,1,class<`AffLinAbscontDistribution`>,1
+distr,isOldVersion,0,2,2,class<`Cauchy`>,1
+distr,isOldVersion,0,2,3,class<`Chisq`>,1
+distr,isOldVersion,0,2,4,class<`Exp`>,1
+distr,isOldVersion,0,2,5,class<`Norm`>,1
+distr,isOldVersion,-1,3,0,logical,1
+distr,isOldVersion,0,3,0,class<`AbscontDistribution`>,1
+distr,isOldVersion,-1,4,0,logical,1
+distr,isOldVersion,0,4,0,class<`Cauchy`>,1
+distr,isOldVersion,-1,5,0,logical,1
+distr,isOldVersion,0,5,0,class<`Norm`>,1
+distr,isOldVersion,-1,6,0,logical,1
+distr,isOldVersion,0,6,0,class<`Chisq`>,1
+distr,.is.vector.lattice,-1,0,0,logical,1
+distr,.is.vector.lattice,0,0,0,double[],1
+distr,k,-1,0,0,double,1
+distr,k,0,0,0,class<`Hyper`>,1
+distr,k,-1,1,0,double,1
+distr,k,0,1,0,class<`HyperParameter`>,1
+distr,k,-1,2,0,double,1
+distr,k,0,2,0,class<`Hyper`>,1
+distr,k,0,2,1,class<`HyperParameter`>,1
+distr,lambda,-1,0,0,double,1
+distr,lambda,0,0,0,class<`Pois`>,1
+distr,lambda,-1,1,0,double,1
+distr,lambda,0,1,0,class<`PoisParameter`>,1
+distr,lambda,-1,2,0,double,1
+distr,lambda,0,2,0,class<`Pois`>,1
+distr,lambda,0,2,1,class<`PoisParameter`>,1
+distr,lambda<-,-1,0,0,class<`Pois`>,1
+distr,lambda<-,-1,0,1,class<`PoisParameter`>,1
+distr,lambda<-,0,0,0,class<`Pois`>,1
+distr,lambda<-,0,0,1,class<`PoisParameter`>,1
+distr,lambda<-,1,0,0,double,1
+distr,lambda<-,-1,1,0,class<`Pois`>,1
+distr,lambda<-,0,1,0,class<`Pois`>,1
+distr,lambda<-,1,1,0,double,1
+distr,lambda<-,-1,2,0,class<`PoisParameter`>,1
+distr,lambda<-,0,2,0,class<`PoisParameter`>,1
+distr,lambda<-,1,2,0,double,1
+distr,lattice,-1,0,0,class<`Lattice`>,1
+distr,lattice,0,0,0,class<`Dirac`>,1
+distr,lattice,-1,1,0,class<`Lattice`>,1
+distr,lattice,0,1,0,class<`AffLinLatticeDistribution`>,1
+distr,lattice,-1,2,0,class<`Lattice`>,1
+distr,lattice,0,2,0,class<`Nbinom`>,1
+distr,lattice,-1,3,0,class<`Lattice`>,1
+distr,lattice,0,3,0,class<`Binom`>,1
+distr,lattice,-1,4,0,class<`Lattice`>,1
+distr,lattice,0,4,0,class<`Pois`>,1
+distr,lattice,-1,5,0,class<`Lattice`>,1
+distr,lattice,0,5,0,class<`Geom`>,1
+distr,lattice,-1,6,0,class<`Lattice`>,1
+distr,lattice,0,6,0,class<`AffLinLatticeDistribution`>,1
+distr,lattice,0,6,1,class<`Binom`>,1
+distr,lattice,0,6,2,class<`Dirac`>,1
+distr,lattice,0,6,3,class<`Geom`>,1
+distr,lattice,0,6,4,class<`LatticeDistribution`>,1
+distr,lattice,0,6,5,class<`Nbinom`>,1
+distr,lattice,0,6,6,class<`Pois`>,1
+distr,lattice,-1,7,0,class<`Lattice`>,1
+distr,lattice,0,7,0,class<`LatticeDistribution`>,1
+distr,Lattice,-1,0,0,class<`Lattice`>,1
+distr,Lattice,0,0,0,double,1
+distr,Lattice,1,0,0,double,1
+distr,Lattice,2,0,0,double,1
+distr,Lattice,3,0,0,character,1
+distr,LatticeDistribution,-1,0,0,class<`AffLinLatticeDistribution`>,1
+distr,LatticeDistribution,-1,0,1,class<`LatticeDistribution`>,1
+distr,LatticeDistribution,0,0,0,class<`Lattice`>,1
+distr,LatticeDistribution,0,0,1,null,1
+distr,LatticeDistribution,1,0,0,null,1
+distr,LatticeDistribution,1,0,1,double[],1
+distr,LatticeDistribution,2,0,0,null,1
+distr,LatticeDistribution,2,0,1,double[],1
+distr,LatticeDistribution,3,0,0,logical,1
+distr,LatticeDistribution,4,0,0,logical,1
+distr,LatticeDistribution,5,0,0,class<`AffLinDiscreteDistribution`>,1
+distr,LatticeDistribution,5,0,1,null,1
+distr,LatticeDistribution,5,0,2,class<`DiscreteDistribution`>,1
+distr,LatticeDistribution,6,0,0,logical,1
+distr,LatticeDistribution,7,0,0,class<`NoSymmetry`>,1
+distr,Length,-1,0,0,double,1
+distr,Length,0,0,0,class<`Lattice`>,1
+distr,Length,-1,1,0,double,1
+distr,Length,0,1,0,class<`Lattice`>,1
+distr,liesIn,-1,0,0,logical,1
+distr,liesIn,0,0,0,class<`EuclideanSpace`>,1
+distr,liesIn,0,0,1,class<`Naturals`>,1
+distr,liesIn,0,0,2,class<`Reals`>,1
+distr,liesIn,1,0,0,double[],1
+distr,liesIn,-1,1,0,logical,1
+distr,liesIn,0,1,0,class<`EuclideanSpace`>,1
+distr,liesIn,1,1,0,double[],1
+distr,liesIn,-1,2,0,logical,1
+distr,liesIn,0,2,0,class<`Reals`>,1
+distr,liesIn,1,2,0,double[],1
+distr,liesIn,-1,3,0,logical,1
+distr,liesIn,0,3,0,class<`Naturals`>,1
+distr,liesIn,1,3,0,double[],1
+distr,liesInSupport,-1,0,0,logical[],1
+distr,liesInSupport,0,0,0,class<`AbscontDistribution`>,1
+distr,liesInSupport,0,0,1,class<`AffLinLatticeDistribution`>,1
+distr,liesInSupport,0,0,2,class<`DiscreteDistribution`>,1
+distr,liesInSupport,0,0,3,class<`Exp`>,1
+distr,liesInSupport,0,0,4,class<`Pois`>,1
+distr,liesInSupport,0,0,5,class<`UnivarLebDecDistribution`>,1
+distr,liesInSupport,1,0,0,double[],1
+distr,liesInSupport,2,0,0,...,1
+distr,liesInSupport,-1,1,0,logical[],1
+distr,liesInSupport,0,1,0,class<`Exp`>,1
+distr,liesInSupport,1,1,0,double[],1
+distr,liesInSupport,2,1,0,...,1
+distr,liesInSupport,-1,2,0,logical[],1
+distr,liesInSupport,0,2,0,class<`AbscontDistribution`>,1
+distr,liesInSupport,1,2,0,double[],1
+distr,liesInSupport,2,2,0,...,1
+distr,liesInSupport,-1,3,0,logical[],1
+distr,liesInSupport,0,3,0,class<`UnivarLebDecDistribution`>,1
+distr,liesInSupport,1,3,0,double[],1
+distr,liesInSupport,2,3,0,...,1
+distr,liesInSupport,-1,4,0,logical[],1
+distr,liesInSupport,0,4,0,class<`AffLinLatticeDistribution`>,1
+distr,liesInSupport,1,4,0,double[],1
+distr,liesInSupport,2,4,0,...,1
+distr,liesInSupport,-1,5,0,logical[],1
+distr,liesInSupport,0,5,0,class<`Pois`>,1
+distr,liesInSupport,1,5,0,integer[],1
+distr,liesInSupport,2,5,0,...,1
+distr,liesInSupport,-1,6,0,logical[],1
+distr,liesInSupport,0,6,0,class<`Pois`>,1
+distr,liesInSupport,1,6,0,double[],1
+distr,liesInSupport,2,6,0,...,1
+distr,liesInSupport,-1,7,0,logical[],1
+distr,liesInSupport,0,7,0,class<`DiscreteDistribution`>,1
+distr,liesInSupport,1,7,0,double[],1
+distr,liesInSupport,2,7,0,...,1
+distr,.List,-1,0,0,list<class<`call`>>,1
+distr,.List,-1,0,1,list<expression | character>,1
+distr,.List,-1,0,2,list<expression>,1
+distr,.List,0,0,0,list<class<`call`>>,1
+distr,.List,0,0,1,class<`call`>,1
+distr,.List,0,0,2,list<expression | character>,1
+distr,.List,0,0,3,list<expression>,1
+distr,.List,0,0,4,expression,1
+distr,Lnorm,-1,0,0,class<`Lnorm`>,1
+distr,Lnorm,0,0,0,double,1
+distr,Lnorm,1,0,0,double,1
+distr,location,-1,0,0,class<`Integer`>,1
+distr,location,-1,0,1,double,1
+distr,location,0,0,0,class<`DiracParameter`>,1
+distr,location,0,0,1,class<`Cauchy`>,1
+distr,location,0,0,2,class<`CauchyParameter`>,1
+distr,location,0,0,3,class<`Dirac`>,1
+distr,location,0,0,4,class<`Logis`>,1
+distr,location,0,0,5,class<`LogisParameter`>,1
+distr,location,-1,1,0,double,1
+distr,location,0,1,0,class<`CauchyParameter`>,1
+distr,location,-1,2,0,double,1
+distr,location,0,2,0,class<`Dirac`>,1
+distr,location,-1,3,0,double,1
+distr,location,0,3,0,class<`Logis`>,1
+distr,location,-1,4,0,double,1
+distr,location,0,4,0,class<`LogisParameter`>,1
+distr,location,-1,5,0,class<`Integer`>,1
+distr,location,-1,5,1,double,1
+distr,location,0,5,0,class<`DiracParameter`>,1
+distr,location,-1,6,0,double,1
+distr,location,0,6,0,class<`Cauchy`>,1
+distr,location<-,-1,0,0,class<`DiracParameter`>,1
+distr,location<-,0,0,0,class<`DiracParameter`>,1
+distr,location<-,1,0,0,double,1
+distr,location<-,-1,1,0,class<`Cauchy`>,1
+distr,location<-,-1,1,1,class<`CauchyParameter`>,1
+distr,location<-,-1,1,2,class<`Dirac`>,1
+distr,location<-,-1,1,3,class<`DiracParameter`>,1
+distr,location<-,-1,1,4,class<`Logis`>,1
+distr,location<-,0,1,0,class<`Cauchy`>,1
+distr,location<-,0,1,1,class<`CauchyParameter`>,1
+distr,location<-,0,1,2,class<`Dirac`>,1
+distr,location<-,0,1,3,class<`DiracParameter`>,1
+distr,location<-,0,1,4,class<`Logis`>,1
+distr,location<-,1,1,0,double,1
+distr,location<-,-1,2,0,class<`CauchyParameter`>,1
+distr,location<-,0,2,0,class<`CauchyParameter`>,1
+distr,location<-,1,2,0,double,1
+distr,location<-,-1,3,0,class<`Dirac`>,1
+distr,location<-,0,3,0,class<`Dirac`>,1
+distr,location<-,1,3,0,double,1
+distr,location<-,-1,4,0,class<`Cauchy`>,1
+distr,location<-,0,4,0,class<`Cauchy`>,1
+distr,location<-,1,4,0,double,1
+distr,location<-,-1,5,0,class<`Logis`>,1
+distr,location<-,0,5,0,class<`Logis`>,1
+distr,location<-,1,5,0,double,1
+distr,.logExact,-1,0,0,logical,1
+distr,.logExact,0,0,0,class<`UnivarLebDecDistribution`>,1
+distr,.logExact,-1,1,0,logical,1
+distr,.logExact,0,1,0,class<`AffLinUnivarLebDecDistribution`>,1
+distr,.logExact,-1,2,0,logical,1
+distr,.logExact,0,2,0,class<`DiscreteDistribution`>,1
+distr,.logExact,-1,3,0,logical,1
+distr,.logExact,0,3,0,class<`AffLinDiscreteDistribution`>,1
+distr,.logExact,-1,4,0,logical,1
+distr,.logExact,0,4,0,class<`Norm`>,1
+distr,.logExact,-1,5,0,logical,1
+distr,.logExact,0,5,0,class<`AbscontDistribution`>,1
+distr,.logExact,-1,6,0,logical,1
+distr,.logExact,0,6,0,class<`LatticeDistribution`>,1
+distr,.logExact,-1,7,0,logical,1
+distr,.logExact,0,7,0,class<`AffLinAbscontDistribution`>,1
+distr,.logExact,-1,8,0,logical,1
+distr,.logExact,0,8,0,class<`AbscontDistribution`>,1
+distr,.logExact,0,8,1,class<`AffLinAbscontDistribution`>,1
+distr,.logExact,0,8,2,class<`AffLinDiscreteDistribution`>,1
+distr,.logExact,0,8,3,class<`AffLinUnivarLebDecDistribution`>,1
+distr,.logExact,0,8,4,class<`DiscreteDistribution`>,1
+distr,.logExact,0,8,5,class<`Geom`>,1
+distr,.logExact,0,8,6,class<`LatticeDistribution`>,1
+distr,.logExact,0,8,7,class<`Norm`>,1
+distr,.logExact,0,8,8,class<`UnivarLebDecDistribution`>,1
+distr,.logExact,-1,9,0,logical,1
+distr,.logExact,0,9,0,class<`Geom`>,1
+distr,Logis,-1,0,0,class<`Logis`>,1
+distr,Logis,0,0,0,double,1
+distr,Logis,1,0,0,double,1
+distr,.logm.c,-1,0,0,class<`AbscontDistribution`>,1
+distr,.logm.c,0,0,0,class<`AbscontDistribution`>,1
+distr,.logm.c,0,0,1,class<`AffLinAbscontDistribution`>,1
+distr,.logm.d,-1,0,0,class<`DiscreteDistribution`>,1
+distr,.logm.d,0,0,0,class<`DiscreteDistribution`>,1
+distr,.loupmixfun,-1,0,0,list<double>,1
+distr,.loupmixfun,0,0,0,class<`UnivarDistrList`>,1
+distr,.loupmixfun,0,0,1,list<class<`AbscontDistribution`>>,1
+distr,.loupmixfun,0,0,2,list<class<`AbscontDistribution`> | class<`AffLinAbscontDistribution`>>,1
+distr,.loupmixfun,0,0,3,list<class<`AbscontDistribution`> | class<`DExp`>>,1
+distr,.loupmixfun,0,0,4,list<class<`Chisq`> | class<`AbscontDistribution`>>,1
+distr,.loupmixfun,0,0,5,list<class<`Norm`> | class<`AbscontDistribution`>>,1
+distr,.loupmixfun,0,0,6,list<class<`Norm`>>,1
+distr,.loupmixfun,0,0,7,list<class<`Unif`>>,1
+distr,.lowerExact,-1,0,0,logical,1
+distr,.lowerExact,0,0,0,class<`Norm`>,1
+distr,.lowerExact,-1,1,0,logical,1
+distr,.lowerExact,0,1,0,class<`AbscontDistribution`>,1
+distr,.lowerExact,-1,2,0,logical,1
+distr,.lowerExact,0,2,0,class<`Nbinom`>,1
+distr,.lowerExact,-1,3,0,logical,1
+distr,.lowerExact,0,3,0,class<`AffLinAbscontDistribution`>,1
+distr,.lowerExact,-1,4,0,logical,1
+distr,.lowerExact,0,4,0,class<`UnivarLebDecDistribution`>,1
+distr,.lowerExact,-1,5,0,logical,1
+distr,.lowerExact,0,5,0,class<`Binom`>,1
+distr,.lowerExact,-1,6,0,logical,1
+distr,.lowerExact,0,6,0,class<`LatticeDistribution`>,1
+distr,.lowerExact,-1,7,0,logical,1
+distr,.lowerExact,0,7,0,class<`Chisq`>,1
+distr,.lowerExact,-1,8,0,logical,1
+distr,.lowerExact,0,8,0,class<`AffLinDiscreteDistribution`>,1
+distr,.lowerExact,-1,9,0,logical,1
+distr,.lowerExact,0,9,0,class<`Dirac`>,1
+distr,.lowerExact,-1,10,0,logical,1
+distr,.lowerExact,0,10,0,class<`Geom`>,1
+distr,.lowerExact,-1,11,0,logical,1
+distr,.lowerExact,0,11,0,class<`AffLinUnivarLebDecDistribution`>,1
+distr,.lowerExact,-1,12,0,logical,1
+distr,.lowerExact,0,12,0,class<`AbscontDistribution`>,1
+distr,.lowerExact,0,12,1,class<`AffLinAbscontDistribution`>,1
+distr,.lowerExact,0,12,2,class<`AffLinDiscreteDistribution`>,1
+distr,.lowerExact,0,12,3,class<`AffLinUnivarLebDecDistribution`>,1
+distr,.lowerExact,0,12,4,class<`Binom`>,1
+distr,.lowerExact,0,12,5,class<`Chisq`>,1
+distr,.lowerExact,0,12,6,class<`Dirac`>,1
+distr,.lowerExact,0,12,7,class<`DiscreteDistribution`>,1
+distr,.lowerExact,0,12,8,class<`Geom`>,1
+distr,.lowerExact,0,12,9,class<`LatticeDistribution`>,1
+distr,.lowerExact,0,12,10,class<`Nbinom`>,1
+distr,.lowerExact,0,12,11,class<`Norm`>,1
+distr,.lowerExact,0,12,12,class<`UnivarLebDecDistribution`>,1
+distr,.lowerExact,-1,13,0,logical,1
+distr,.lowerExact,0,13,0,class<`DiscreteDistribution`>,1
+distr,m,-1,0,0,double,1
+distr,m,0,0,0,class<`HyperParameter`>,1
+distr,m,-1,1,0,double,1
+distr,m,0,1,0,class<`Hyper`>,1
+distr,m,0,1,1,class<`HyperParameter`>,1
+distr,m,-1,2,0,double,1
+distr,m,0,2,0,class<`Hyper`>,1
+distr,m<-,-1,0,0,class<`HyperParameter`>,1
+distr,m<-,0,0,0,class<`HyperParameter`>,1
+distr,m<-,1,0,0,double,1
+distr,m<-,-1,1,0,class<`Hyper`>,1
+distr,m<-,0,1,0,class<`Hyper`>,1
+distr,m<-,1,1,0,double,1
+distr,m<-,-1,2,0,class<`Hyper`>,1
+distr,m<-,-1,2,1,class<`HyperParameter`>,1
+distr,m<-,0,2,0,class<`Hyper`>,1
+distr,m<-,0,2,1,class<`HyperParameter`>,1
+distr,m<-,1,2,0,double,1
+distr,makeAbscontDistribution,-1,0,0,class<`AbscontDistribution`>,1
+distr,makeAbscontDistribution,0,0,0,class<`AffLinUnivarLebDecDistribution`>,1
+distr,makeAbscontDistribution,1,0,0,null,1
+distr,makeAbscontDistribution,2,0,0,null,1
+distr,makeAbscontDistribution,3,0,0,null,1
+distr,makeAbscontDistribution,4,0,0,logical,1
+distr,makeAbscontDistribution,5,0,0,double,1
+distr,makeAbscontDistribution,6,0,0,any,1
+distr,.makeD,-1,0,0,class<`function`>,1
+distr,.makeD,0,0,0,class<`AbscontDistribution`>,1
+distr,.makeD,0,0,1,class<`AffLinAbscontDistribution`>,1
+distr,.makeD,0,0,2,class<`AffLinDiscreteDistribution`>,1
+distr,.makeD,0,0,3,class<`DiscreteDistribution`>,1
+distr,.makeD,0,0,4,class<`Exp`>,1
+distr,.makeD,0,0,5,class<`Gammad`>,1
+distr,.makeD,0,0,6,class<`Norm`>,1
+distr,.makeD,1,0,0,class<`call`>,1
+distr,.makeD,2,0,0,class<`call`>,1
+distr,.makeD,2,0,1,class<`Integer`>,1
+distr,.makeD,2,0,2,double,1
+distr,.makeD,2,0,3,null,1
+distr,.makeD,3,0,0,class<`(`>,1
+distr,.makeD,3,0,1,null,1
+distr,.makeD,3,0,2,class<`call`>,1
+distr,.makeDNew,-1,0,0,class<`function`>,1
+distr,.makeDNew,0,0,0,double[],1
+distr,.makeDNew,1,0,0,class<`matrix`>,1
+distr,.makeDNew,1,0,1,class<`table`>,1
+distr,.makeDNew,1,0,2,double[],1
+distr,.makeDNew,2,0,0,double,1
+distr,.makeDNew,2,0,1,null,1
+distr,.makeDNew,3,0,0,logical,1
+distr,.makeDNew,4,0,0,character,1
+distr,.makedotsL,-1,0,0,null,1
+distr,.makedotsL,0,0,0,null,1
+distr,.makedotsLowLevel,-1,0,0,null,1
+distr,.makedotsLowLevel,-1,0,1,pairlist,1
+distr,.makedotsLowLevel,0,0,0,null,1
+distr,.makedotsLowLevel,0,0,1,pairlist,1
+distr,.makedotsPt,-1,0,0,null,1
+distr,.makedotsPt,-1,0,1,list<double>,1
+distr,.makedotsPt,0,0,0,null,1
+distr,.makedotsPt,0,0,1,pairlist,1
+distr,.make.lattice.es.vector,-1,0,0,class<`Lattice`>,1
+distr,.make.lattice.es.vector,0,0,0,double[],1
+distr,.makeLenAndOrder,-1,0,0,character[],1
+distr,.makeLenAndOrder,-1,0,1,double[],1
+distr,.makeLenAndOrder,0,0,0,character[],1
+distr,.makeLenAndOrder,0,0,1,double,1
+distr,.makeLenAndOrder,1,0,0,integer[],1
+distr,.makeP,-1,0,0,class<`function`>,1
+distr,.makeP,0,0,0,class<`AbscontDistribution`>,1
+distr,.makeP,0,0,1,class<`AffLinAbscontDistribution`>,1
+distr,.makeP,0,0,2,class<`AffLinDiscreteDistribution`>,1
+distr,.makeP,0,0,3,class<`DiscreteDistribution`>,1
+distr,.makeP,0,0,4,class<`Exp`>,1
+distr,.makeP,0,0,5,class<`Gammad`>,1
+distr,.makeP,0,0,6,class<`Norm`>,1
+distr,.makeP,1,0,0,class<`call`>,1
+distr,.makeP,2,0,0,logical,1
+distr,.makeP,3,0,0,any,1
+distr,.makeP,4,0,0,class<`(`>,1
+distr,.makeP,4,0,1,null,1
+distr,.makeP,4,0,2,double,1
+distr,.makeP,5,0,0,class<`call`>,1
+distr,.makeP,5,0,1,null,1
+distr,.makePNew,-1,0,0,class<`function`>,1
+distr,.makePNew,0,0,0,double[],1
+distr,.makePNew,1,0,0,class<`table`>,1
+distr,.makePNew,1,0,1,double[],1
+distr,.makePNew,1,0,2,null,1
+distr,.makePNew,2,0,0,double,1
+distr,.makePNew,2,0,1,null,1
+distr,.makePNew,3,0,0,logical,1
+distr,.makePNew,4,0,0,logical,1
+distr,.makePNew,5,0,0,null,1
+distr,.makePNew,5,0,1,class<`function`>,1
+distr,.makePNew,6,0,0,null,1
+distr,.makePNew,6,0,1,class<`matrix`>,1
+distr,.makePNew,7,0,0,null,1
+distr,.makePNew,7,0,1,class<`matrix`>,1
+distr,.makeQ,-1,0,0,class<`function`>,1
+distr,.makeQ,0,0,0,class<`AbscontDistribution`>,1
+distr,.makeQ,0,0,1,class<`AffLinAbscontDistribution`>,1
+distr,.makeQ,0,0,2,class<`AffLinDiscreteDistribution`>,1
+distr,.makeQ,0,0,3,class<`DiscreteDistribution`>,1
+distr,.makeQ,0,0,4,class<`Exp`>,1
+distr,.makeQ,0,0,5,class<`Gammad`>,1
+distr,.makeQ,1,0,0,class<`call`>,1
+distr,.makeQ,2,0,0,logical,1
+distr,.makeQ,3,0,0,logical,1
+distr,.makeQNew,-1,0,0,class<`function`>,1
+distr,.makeQNew,0,0,0,double[],1
+distr,.makeQNew,1,0,0,double[],1
+distr,.makeQNew,2,0,0,any,1
+distr,.makeQNew,3,0,0,logical,1
+distr,.makeQNew,4,0,0,any,1
+distr,.makeQNew,5,0,0,double,1
+distr,.makeQNew,6,0,0,logical,1
+distr,Max,-1,0,0,double,1
+distr,Max,0,0,0,class<`Unif`>,1
+distr,Max,-1,1,0,double,1
+distr,Max,0,1,0,class<`UnifParameter`>,1
+distr,Max,-1,2,0,double,1
+distr,Max,0,2,0,class<`Unif`>,1
+distr,Max,0,2,1,class<`UnifParameter`>,1
+distr,Max<-,-1,0,0,class<`UnifParameter`>,1
+distr,Max<-,0,0,0,class<`UnifParameter`>,1
+distr,Max<-,1,0,0,double,1
+distr,Max<-,-1,1,0,class<`UnifParameter`>,1
+distr,Max<-,0,1,0,class<`UnifParameter`>,1
+distr,Max<-,1,1,0,double,1
+distr,Maximum,-1,0,0,class<`AffLinUnivarLebDecDistribution`>,1
+distr,Maximum,0,0,0,class<`Dirac`>,1
+distr,Maximum,1,0,0,class<`UnivarLebDecDistribution`>,1
+distr,Maximum,2,0,0,...,1
+distr,Maximum,-1,1,0,class<`AffLinAbscontDistribution`>,1
+distr,Maximum,0,1,0,class<`Unif`>,1
+distr,Maximum,1,1,0,class<`AbscontDistribution`>,1
+distr,Maximum,2,1,0,...,1
+distr,Maximum,-1,2,0,class<`AffLinAbscontDistribution`>,1
+distr,Maximum,-1,2,1,class<`AffLinUnivarLebDecDistribution`>,1
+distr,Maximum,0,2,0,class<`Unif`>,1
+distr,Maximum,0,2,1,class<`Dirac`>,1
+distr,Maximum,1,2,0,class<`AbscontDistribution`>,1
+distr,Maximum,1,2,1,class<`UnivarLebDecDistribution`>,1
+distr,Maximum,2,2,0,...,1
+distr,mean,-1,0,0,double,1
+distr,mean,0,0,0,class<`NormParameter`>,1
+distr,mean,1,0,0,...,1
+distr,mean,-1,1,0,double,1
+distr,mean,0,1,0,class<`Norm`>,1
+distr,mean,1,1,0,...,1
+distr,mean,-1,2,0,double,1
+distr,mean,0,2,0,class<`UniNormParameter`>,1
+distr,mean,1,2,0,...,1
+distr,meanlog,-1,0,0,double,1
+distr,meanlog,0,0,0,class<`LnormParameter`>,1
+distr,meanlog,-1,1,0,double,1
+distr,meanlog,0,1,0,class<`Lnorm`>,1
+distr,meanlog,-1,2,0,double,1
+distr,meanlog,0,2,0,class<`Lnorm`>,1
+distr,meanlog,0,2,1,class<`LnormParameter`>,1
+distr,meanlog<-,-1,0,0,class<`Lnorm`>,1
+distr,meanlog<-,0,0,0,class<`Lnorm`>,1
+distr,meanlog<-,1,0,0,double,1
+distr,meanlog<-,-1,1,0,class<`LnormParameter`>,1
+distr,meanlog<-,0,1,0,class<`LnormParameter`>,1
+distr,meanlog<-,1,1,0,double,1
+distr,meanlog<-,-1,2,0,class<`Lnorm`>,1
+distr,meanlog<-,-1,2,1,class<`LnormParameter`>,1
+distr,meanlog<-,0,2,0,class<`Lnorm`>,1
+distr,meanlog<-,0,2,1,class<`LnormParameter`>,1
+distr,meanlog<-,1,2,0,double,1
+distr,.mergegaps,-1,0,0,class<`matrix`>,1
+distr,.mergegaps,-1,0,1,null,1
+distr,.mergegaps,0,0,0,class<`matrix`>,1
+distr,.mergegaps,0,0,1,null,1
+distr,.mergegaps,1,0,0,any,1
+distr,.mergegaps2,-1,0,0,null,1
+distr,.mergegaps2,0,0,0,null,1
+distr,.mergegaps2,1,0,0,any,1
+distr,Min,-1,0,0,double,1
+distr,Min,0,0,0,class<`Unif`>,1
+distr,Min,-1,1,0,double,1
+distr,Min,0,1,0,class<`Unif`>,1
+distr,Min,0,1,1,class<`UnifParameter`>,1
+distr,Min,-1,2,0,double,1
+distr,Min,0,2,0,class<`UnifParameter`>,1
+distr,Min<-,-1,0,0,class<`Unif`>,1
+distr,Min<-,0,0,0,class<`Unif`>,1
+distr,Min<-,1,0,0,double,1
+distr,Min<-,-1,1,0,class<`Unif`>,1
+distr,Min<-,0,1,0,class<`Unif`>,1
+distr,Min<-,1,1,0,double,1
+distr,Minimum,-1,0,0,class<`AbscontDistribution`>,1
+distr,Minimum,0,0,0,class<`Exp`>,1
+distr,Minimum,1,0,0,double,1
+distr,Minimum,2,0,0,...,1
+distr,Minimum,-1,1,0,class<`UnivarLebDecDistribution`>,1
+distr,Minimum,0,1,0,class<`AffLinAbscontDistribution`>,1
+distr,Minimum,1,1,0,class<`Dirac`>,1
+distr,Minimum,2,1,0,...,1
+distr,Minimum,-1,2,0,class<`UnivarLebDecDistribution`>,1
+distr,Minimum,0,2,0,class<`Norm`>,1
+distr,Minimum,1,2,0,class<`Dirac`>,1
+distr,Minimum,2,2,0,...,1
+distr,Minimum,-1,3,0,class<`UnivarLebDecDistribution`>,1
+distr,Minimum,0,3,0,class<`Norm`>,1
+distr,Minimum,1,3,0,class<`Pois`>,1
+distr,Minimum,2,3,0,...,1
+distr,Minimum,-1,4,0,class<`AbscontDistribution`>,1
+distr,Minimum,0,4,0,class<`Unif`>,1
+distr,Minimum,1,4,0,class<`AffLinAbscontDistribution`>,1
+distr,Minimum,2,4,0,...,1
+distr,Minimum,-1,5,0,class<`AbscontDistribution`>,1
+distr,Minimum,-1,5,1,class<`DiscreteDistribution`>,1
+distr,Minimum,-1,5,2,class<`UnivarLebDecDistribution`>,1
+distr,Minimum,0,5,0,class<`Exp`>,1
+distr,Minimum,0,5,1,class<`Unif`>,1
+distr,Minimum,0,5,2,class<`Dirac`>,1
+distr,Minimum,0,5,3,class<`AffLinAbscontDistribution`>,1
+distr,Minimum,0,5,4,class<`Norm`>,1
+distr,Minimum,1,5,0,double,1
+distr,Minimum,1,5,1,class<`AffLinAbscontDistribution`>,1
+distr,Minimum,1,5,2,class<`Unif`>,1
+distr,Minimum,1,5,3,class<`Dirac`>,1
+distr,Minimum,1,5,4,class<`AffLinUnivarLebDecDistribution`>,1
+distr,Minimum,1,5,5,class<`Pois`>,1
+distr,Minimum,2,5,0,...,1
+distr,Minimum,-1,6,0,class<`AbscontDistribution`>,1
+distr,Minimum,0,6,0,class<`Unif`>,1
+distr,Minimum,1,6,0,class<`Unif`>,1
+distr,Minimum,2,6,0,...,1
+distr,Minimum,-1,7,0,class<`DiscreteDistribution`>,1
+distr,Minimum,0,7,0,class<`Dirac`>,1
+distr,Minimum,1,7,0,class<`Dirac`>,1
+distr,Minimum,2,7,0,...,1
+distr,Minimum,-1,8,0,class<`UnivarLebDecDistribution`>,1
+distr,Minimum,0,8,0,class<`Dirac`>,1
+distr,Minimum,1,8,0,class<`AffLinUnivarLebDecDistribution`>,1
+distr,Minimum,2,8,0,...,1
+distr,mixCoeff,-1,0,0,double[],1
+distr,mixCoeff,0,0,0,class<`CompoundDistribution`>,1
+distr,mixCoeff,0,0,1,class<`UnivarMixingDistribution`>,1
+distr,mixCoeff,-1,1,0,double[],1
+distr,mixCoeff,0,1,0,class<`CompoundDistribution`>,1
+distr,mixCoeff,-1,2,0,double[],1
+distr,mixCoeff,0,2,0,class<`UnivarMixingDistribution`>,1
+distr,mixDistr,-1,0,0,class<`UnivarDistrList`>,1
+distr,mixDistr,0,0,0,class<`CompoundDistribution`>,1
+distr,mixDistr,-1,1,0,class<`UnivarDistrList`>,1
+distr,mixDistr,0,1,0,class<`UnivarLebDecDistribution`>,1
+distr,mixDistr,-1,2,0,class<`UnivarDistrList`>,1
+distr,mixDistr,0,2,0,class<`UnivarMixingDistribution`>,1
+distr,mixDistr,-1,3,0,class<`UnivarDistrList`>,1
+distr,mixDistr,0,3,0,class<`CompoundDistribution`>,1
+distr,mixDistr,0,3,1,class<`UnivarLebDecDistribution`>,1
+distr,mixDistr,0,3,2,class<`UnivarMixingDistribution`>,1
+distr,.modifyqgaps,-1,0,0,class<`function`>,1
+distr,.modifyqgaps,0,0,0,class<`function`>,1
+distr,.modifyqgaps,1,0,0,class<`function`>,1
+distr,.modifyqgaps,2,0,0,class<`matrix`>,1
+distr,.modifyqgaps,3,0,0,character,1
+distr,.multm,-1,0,0,class<`AbscontDistribution`>,1
+distr,.multm,-1,0,1,class<`AffLinAbscontDistribution`>,1
+distr,.multm,-1,0,2,class<`AffLinDiscreteDistribution`>,1
+distr,.multm,-1,0,3,class<`DiscreteDistribution`>,1
+distr,.multm,0,0,0,class<`AbscontDistribution`>,1
+distr,.multm,0,0,1,class<`AffLinAbscontDistribution`>,1
+distr,.multm,0,0,2,class<`Gammad`>,1
+distr,.multm,0,0,3,class<`AffLinDiscreteDistribution`>,1
+distr,.multm,0,0,4,class<`DiscreteDistribution`>,1
+distr,.multm,1,0,0,class<`Integer`>,1
+distr,.multm,1,0,1,double,1
+distr,.multm,2,0,0,character,1
+distr,n,-1,0,0,double,1
+distr,n,0,0,0,class<`Hyper`>,1
+distr,n,-1,1,0,double,1
+distr,n,0,1,0,class<`Hyper`>,1
+distr,n,0,1,1,class<`HyperParameter`>,1
+distr,n,-1,2,0,double,1
+distr,n,0,2,0,class<`HyperParameter`>,1
+distr,name,-1,0,0,character,1
+distr,name,0,0,0,class<`Lattice`>,1
+distr,name,-1,1,0,character,1
+distr,name,0,1,0,class<`Lattice`>,1
+distr,Naturals,-1,0,0,class<`Naturals`>,1
+distr,Nbinom,-1,0,0,class<`Nbinom`>,1
+distr,Nbinom,0,0,0,double,1
+distr,Nbinom,1,0,0,double,1
+distr,ncp,-1,0,0,double,1
+distr,ncp,0,0,0,class<`FParameter`>,1
+distr,ncp,-1,1,0,double,1
+distr,ncp,0,1,0,class<`TParameter`>,1
+distr,ncp,-1,2,0,double,1
+distr,ncp,0,2,0,class<`Beta`>,1
+distr,ncp,0,2,1,class<`BetaParameter`>,1
+distr,ncp,0,2,2,class<`Chisq`>,1
+distr,ncp,0,2,3,class<`ChisqParameter`>,1
+distr,ncp,0,2,4,class<`Fd`>,1
+distr,ncp,0,2,5,class<`FParameter`>,1
+distr,ncp,0,2,6,class<`Td`>,1
+distr,ncp,0,2,7,class<`TParameter`>,1
+distr,ncp,-1,3,0,double,1
+distr,ncp,0,3,0,class<`BetaParameter`>,1
+distr,ncp,-1,4,0,double,1
+distr,ncp,0,4,0,class<`Fd`>,1
+distr,ncp,-1,5,0,double,1
+distr,ncp,0,5,0,class<`ChisqParameter`>,1
+distr,ncp,-1,6,0,double,1
+distr,ncp,0,6,0,class<`Chisq`>,1
+distr,ncp,-1,7,0,double,1
+distr,ncp,0,7,0,class<`Beta`>,1
+distr,ncp,-1,8,0,double,1
+distr,ncp,0,8,0,class<`Td`>,1
+distr,ncp<-,-1,0,0,class<`Beta`>,1
+distr,ncp<-,-1,0,1,class<`ChisqParameter`>,1
+distr,ncp<-,0,0,0,class<`Beta`>,1
+distr,ncp<-,0,0,1,class<`ChisqParameter`>,1
+distr,ncp<-,1,0,0,double,1
+distr,ncp<-,-1,1,0,class<`ChisqParameter`>,1
+distr,ncp<-,0,1,0,class<`ChisqParameter`>,1
+distr,ncp<-,1,1,0,double,1
+distr,ncp<-,-1,2,0,class<`Beta`>,1
+distr,ncp<-,0,2,0,class<`Beta`>,1
+distr,ncp<-,1,2,0,double,1
+distr,Norm,-1,0,0,class<`Norm`>,1
+distr,Norm,0,0,0,double,1
+distr,Norm,1,0,0,double,1
+distr,NoSymmetry,-1,0,0,class<`NoSymmetry`>,1
+distr,.NotInSupport,-1,0,0,logical[],1
+distr,.NotInSupport,0,0,0,double[],1
+distr,.NotInSupport,1,0,0,class<`Chisq`>,1
+distr,.NotInSupport,1,0,1,class<`Norm`>,1
+distr,.notwithLArg,-1,0,0,logical,1
+distr,.notwithLArg,0,0,0,class<`AbscontDistribution`>,1
+distr,.notwithLArg,0,0,1,class<`AffLinAbscontDistribution`>,1
+distr,.notwithLArg,0,0,2,class<`AffLinLatticeDistribution`>,1
+distr,.notwithLArg,0,0,3,class<`Binom`>,1
+distr,.notwithLArg,0,0,4,class<`Chisq`>,1
+distr,.notwithLArg,0,0,5,class<`DiscreteDistribution`>,1
+distr,.notwithLArg,0,0,6,class<`Exp`>,1
+distr,.notwithLArg,0,0,7,class<`Norm`>,1
+distr,.notwithLArg,0,0,8,class<`Pois`>,1
+distr,.notwithLArg,0,0,9,class<`Td`>,1
+distr,.notwithLArg,0,0,10,class<`Unif`>,1
+distr,p,-1,0,0,class<`matrix`>,1
+distr,p,-1,0,1,double[],1
+distr,p,0,0,0,class<`matrix`>,1
+distr,p,0,0,1,double[],1
+distr,p,1,0,0,logical,1
+distr,p,2,0,0,logical,1
+distr,p,-1,1,0,double[],1
+distr,p,0,1,0,double[],1
+distr,p,1,1,0,logical,1
+distr,p,2,1,0,logical,1
+distr,p,-1,2,0,^double[],1
+distr,p,0,2,0,^double[],1
+distr,p,0,2,1,class<`matrix`>,1
+distr,p,1,2,0,logical,1
+distr,p,2,2,0,logical,1
+distr,p,-1,3,0,double[],1
+distr,p,0,3,0,double[],1
+distr,p,1,3,0,logical,1
+distr,p,2,3,0,logical,1
+distr,p,-1,4,0,^double[],1
+distr,p,0,4,0,^double[],1
+distr,p,1,4,0,logical,1
+distr,p,2,4,0,logical,1
+distr,p,3,4,0,...,1
+distr,p,-1,5,0,^double[],1
+distr,p,0,5,0,^double[],1
+distr,p,1,5,0,logical,1
+distr,p,2,5,0,logical,1
+distr,p,-1,6,0,double[],1
+distr,p,0,6,0,double[],1
+distr,p,1,6,0,logical,1
+distr,p,2,6,0,logical,1
+distr,p,-1,7,0,double[],1
+distr,p,0,7,0,double[],1
+distr,p,1,7,0,logical,1
+distr,p,2,7,0,logical,1
+distr,p,-1,8,0,^double[],1
+distr,p,0,8,0,^double[],1
+distr,p,0,8,1,class<`matrix`>,1
+distr,p,1,8,0,logical,1
+distr,p,2,8,0,logical,1
+distr,p,-1,9,0,^double[],1
+distr,p,0,9,0,^double[],1
+distr,p,1,9,0,logical,1
+distr,p,2,9,0,logical,1
+distr,p,-1,10,0,double[],1
+distr,p,0,10,0,double[],1
+distr,p,1,10,0,logical,1
+distr,p,2,10,0,logical,1
+distr,p,-1,11,0,^double[],1
+distr,p,-1,11,1,class<`matrix`>,1
+distr,p,0,11,0,^double[],1
+distr,p,0,11,1,class<`matrix`>,1
+distr,p,1,11,0,logical,1
+distr,p,2,11,0,logical,1
+distr,p,3,11,0,...,1
+distr,p,-1,12,0,^double[],1
+distr,p,0,12,0,^double[],1
+distr,p,0,12,1,class<`matrix`>,1
+distr,p,1,12,0,logical,1
+distr,p,2,12,0,logical,1
+distr,p,-1,13,0,class<`matrix`>,1
+distr,p,-1,13,1,double[],1
+distr,p,0,13,0,class<`matrix`>,1
+distr,p,0,13,1,double[],1
+distr,p,1,13,0,logical,1
+distr,p,2,13,0,logical,1
+distr,p,-1,14,0,double,1
+distr,p,0,14,0,double,1
+distr,p,1,14,0,logical,1
+distr,p,2,14,0,logical,1
+distr,p,-1,15,0,class<`function`>,1
+distr,p,0,15,0,class<`AffLinDiscreteDistribution`>,1
+distr,p,-1,16,0,class<`function`>,1
+distr,p,0,16,0,class<`Beta`>,1
+distr,p,-1,17,0,double,1
+distr,p,0,17,0,double,1
+distr,p,1,17,0,logical,1
+distr,p,2,17,0,logical,1
+distr,p,-1,18,0,class<`function`>,1
+distr,p,0,18,0,class<`AbscontDistribution`>,1
+distr,p,-1,19,0,double,1
+distr,p,0,19,0,double,1
+distr,p,1,19,0,logical,1
+distr,p,2,19,0,logical,1
+distr,p,-1,20,0,class<`function`>,1
+distr,p,0,20,0,class<`Gammad`>,1
+distr,p,-1,21,0,double[],1
+distr,p,0,21,0,double[],1
+distr,p,1,21,0,logical,1
+distr,p,2,21,0,logical,1
+distr,p,-1,22,0,double[],1
+distr,p,0,22,0,double[],1
+distr,p,1,22,0,logical,1
+distr,p,2,22,0,logical,1
+distr,p,-1,23,0,^double[],1
+distr,p,0,23,0,^double[],1
+distr,p,1,23,0,logical,1
+distr,p,2,23,0,logical,1
+distr,p,-1,24,0,double[],1
+distr,p,0,24,0,double[],1
+distr,p,1,24,0,logical,1
+distr,p,2,24,0,logical,1
+distr,p,-1,25,0,double,1
+distr,p,0,25,0,double,1
+distr,p,1,25,0,logical,1
+distr,p,2,25,0,logical,1
+distr,p,-1,26,0,double,1
+distr,p,0,26,0,double,1
+distr,p,1,26,0,logical,1
+distr,p,2,26,0,logical,1
+distr,p,-1,27,0,class<`function`>,1
+distr,p,0,27,0,class<`Binom`>,1
+distr,p,-1,28,0,class<`function`>,1
+distr,p,0,28,0,class<`Logis`>,1
+distr,p,-1,29,0,class<`function`>,1
+distr,p,0,29,0,class<`Nbinom`>,1
+distr,p,-1,30,0,class<`function`>,1
+distr,p,0,30,0,class<`DExp`>,1
+distr,p,-1,31,0,double,1
+distr,p,0,31,0,double,1
+distr,p,1,31,0,logical,1
+distr,p,2,31,0,logical,1
+distr,p,-1,32,0,class<`function`>,1
+distr,p,0,32,0,class<`LatticeDistribution`>,1
+distr,p,-1,33,0,class<`function`>,1
+distr,p,0,33,0,class<`Pois`>,1
+distr,p,-1,34,0,double[],1
+distr,p,0,34,0,double[],1
+distr,p,1,34,0,logical,1
+distr,p,2,34,0,logical,1
+distr,p,-1,35,0,double[],1
+distr,p,0,35,0,double[],1
+distr,p,1,35,0,logical,1
+distr,p,2,35,0,logical,1
+distr,p,-1,36,0,class<`matrix`>,1
+distr,p,-1,36,1,double[],1
+distr,p,0,36,0,class<`matrix`>,1
+distr,p,0,36,1,double[],1
+distr,p,1,36,0,logical,1
+distr,p,2,36,0,logical,1
+distr,p,-1,37,0,double[],1
+distr,p,0,37,0,double[],1
+distr,p,1,37,0,logical,1
+distr,p,2,37,0,logical,1
+distr,p,-1,38,0,class<`function`>,1
+distr,p,0,38,0,class<`Dirac`>,1
+distr,p,-1,39,0,class<`function`>,1
+distr,p,0,39,0,class<`Td`>,1
+distr,p,-1,40,0,class<`function`>,1
+distr,p,0,40,0,class<`Chisq`>,1
+distr,p,-1,41,0,double[],1
+distr,p,-1,41,1,class<`matrix`>,1
+distr,p,0,41,0,double[],1
+distr,p,0,41,1,class<`matrix`>,1
+distr,p,1,41,0,logical,1
+distr,p,2,41,0,logical,1
+distr,p,-1,42,0,class<`function`>,1
+distr,p,0,42,0,class<`Cauchy`>,1
+distr,p,-1,43,0,double[],1
+distr,p,0,43,0,double[],1
+distr,p,1,43,0,logical,1
+distr,p,2,43,0,logical,1
+distr,p,-1,44,0,double,1
+distr,p,0,44,0,double,1
+distr,p,1,44,0,logical,1
+distr,p,2,44,0,logical,1
+distr,p,-1,45,0,double[],1
+distr,p,0,45,0,double[],1
+distr,p,1,45,0,logical,1
+distr,p,2,45,0,logical,1
+distr,p,-1,46,0,double,1
+distr,p,0,46,0,double,1
+distr,p,1,46,0,logical,1
+distr,p,2,46,0,logical,1
+distr,p,-1,47,0,double,1
+distr,p,0,47,0,double,1
+distr,p,1,47,0,logical,1
+distr,p,2,47,0,logical,1
+distr,p,-1,48,0,double[],1
+distr,p,0,48,0,double[],1
+distr,p,1,48,0,logical,1
+distr,p,2,48,0,logical,1
+distr,p,-1,49,0,class<`function`>,1
+distr,p,0,49,0,class<`Weibull`>,1
+distr,p,-1,50,0,double,1
+distr,p,0,50,0,double,1
+distr,p,1,50,0,logical,1
+distr,p,2,50,0,logical,1
+distr,p,-1,51,0,double[],1
+distr,p,0,51,0,double[],1
+distr,p,1,51,0,logical,1
+distr,p,2,51,0,logical,1
+distr,p,-1,52,0,double,1
+distr,p,0,52,0,double,1
+distr,p,1,52,0,logical,1
+distr,p,2,52,0,logical,1
+distr,p,-1,53,0,double,1
+distr,p,0,53,0,double,1
+distr,p,1,53,0,logical,1
+distr,p,2,53,0,logical,1
+distr,p,-1,54,0,class<`function`>,1
+distr,p,0,54,0,class<`Exp`>,1
+distr,p,-1,55,0,class<`function`>,1
+distr,p,0,55,0,class<`Unif`>,1
+distr,p,-1,56,0,double,1
+distr,p,0,56,0,double,1
+distr,p,1,56,0,logical,1
+distr,p,2,56,0,logical,1
+distr,p,-1,57,0,class<`function`>,1
+distr,p,0,57,0,class<`Geom`>,1
+distr,p,-1,58,0,class<`function`>,1
+distr,p,0,58,0,class<`DiscreteDistribution`>,1
+distr,p,-1,59,0,double[],1
+distr,p,0,59,0,double[],1
+distr,p,1,59,0,logical,1
+distr,p,2,59,0,logical,1
+distr,p,-1,60,0,double[],1
+distr,p,0,60,0,double[],1
+distr,p,1,60,0,logical,1
+distr,p,2,60,0,logical,1
+distr,p,-1,61,0,double[],1
+distr,p,0,61,0,double[],1
+distr,p,1,61,0,logical,1
+distr,p,2,61,0,logical,1
+distr,p,-1,62,0,double[],1
+distr,p,0,62,0,double[],1
+distr,p,1,62,0,logical,1
+distr,p,2,62,0,logical,1
+distr,p,-1,63,0,class<`function`>,1
+distr,p,0,63,0,class<`AffLinLatticeDistribution`>,1
+distr,p,-1,64,0,class<`function`>,1
+distr,p,0,64,0,class<`AbscontDistribution`>,1
+distr,p,0,64,1,class<`AffLinAbscontDistribution`>,1
+distr,p,0,64,2,class<`AffLinDiscreteDistribution`>,1
+distr,p,0,64,3,class<`AffLinLatticeDistribution`>,1
+distr,p,0,64,4,class<`AffLinUnivarLebDecDistribution`>,1
+distr,p,0,64,5,class<`Beta`>,1
+distr,p,0,64,6,class<`Binom`>,1
+distr,p,0,64,7,class<`Cauchy`>,1
+distr,p,0,64,8,class<`Chisq`>,1
+distr,p,0,64,9,class<`DExp`>,1
+distr,p,0,64,10,class<`Dirac`>,1
+distr,p,0,64,11,class<`DiscreteDistribution`>,1
+distr,p,0,64,12,class<`Exp`>,1
+distr,p,0,64,13,class<`Fd`>,1
+distr,p,0,64,14,class<`Gammad`>,1
+distr,p,0,64,15,class<`Geom`>,1
+distr,p,0,64,16,class<`Hyper`>,1
+distr,p,0,64,17,class<`LatticeDistribution`>,1
+distr,p,0,64,18,class<`Lnorm`>,1
+distr,p,0,64,19,class<`Logis`>,1
+distr,p,0,64,20,class<`Nbinom`>,1
+distr,p,0,64,21,class<`Norm`>,1
+distr,p,0,64,22,class<`Pois`>,1
+distr,p,0,64,23,class<`Td`>,1
+distr,p,0,64,24,class<`Unif`>,1
+distr,p,0,64,25,class<`UnivarLebDecDistribution`>,1
+distr,p,0,64,26,class<`Weibull`>,1
+distr,p,0,64,27,class<`Arcsine`>,1
+distr,p,0,64,28,class<`CompoundDistribution`>,1
+distr,p,-1,65,0,class<`function`>,1
+distr,p,0,65,0,class<`AffLinUnivarLebDecDistribution`>,1
+distr,p,-1,66,0,double[],1
+distr,p,0,66,0,class<`matrix`>,1
+distr,p,0,66,1,double[],1
+distr,p,1,66,0,logical,1
+distr,p,2,66,0,logical,1
+distr,p,-1,67,0,double,1
+distr,p,0,67,0,double,1
+distr,p,1,67,0,logical,1
+distr,p,2,67,0,logical,1
+distr,p,-1,68,0,double[],1
+distr,p,0,68,0,double[],1
+distr,p,1,68,0,logical,1
+distr,p,2,68,0,logical,1
+distr,p,-1,69,0,class<`function`>,1
+distr,p,0,69,0,class<`CompoundDistribution`>,1
+distr,p,-1,70,0,double,1
+distr,p,0,70,0,double,1
+distr,p,1,70,0,logical,1
+distr,p,2,70,0,logical,1
+distr,p,-1,71,0,class<`function`>,1
+distr,p,0,71,0,class<`Hyper`>,1
+distr,p,-1,72,0,double,1
+distr,p,0,72,0,double,1
+distr,p,1,72,0,logical,1
+distr,p,2,72,0,logical,1
+distr,p,-1,73,0,double[],1
+distr,p,0,73,0,double[],1
+distr,p,1,73,0,logical,1
+distr,p,2,73,0,logical,1
+distr,p,-1,74,0,double[],1
+distr,p,0,74,0,double[],1
+distr,p,1,74,0,logical,1
+distr,p,2,74,0,logical,1
+distr,p,-1,75,0,double,1
+distr,p,0,75,0,double,1
+distr,p,1,75,0,logical,1
+distr,p,2,75,0,logical,1
+distr,p,-1,76,0,double[],1
+distr,p,0,76,0,double[],1
+distr,p,1,76,0,logical,1
+distr,p,2,76,0,logical,1
+distr,p,-1,77,0,class<`function`>,1
+distr,p,0,77,0,class<`Fd`>,1
+distr,p,-1,78,0,class<`function`>,1
+distr,p,0,78,0,class<`AffLinAbscontDistribution`>,1
+distr,p,-1,79,0,double[],1
+distr,p,0,79,0,integer[],1
+distr,p,1,79,0,logical,1
+distr,p,2,79,0,logical,1
+distr,p,-1,80,0,double[],1
+distr,p,0,80,0,double[],1
+distr,p,1,80,0,logical,1
+distr,p,2,80,0,logical,1
+distr,p,-1,81,0,double[],1
+distr,p,0,81,0,double[],1
+distr,p,0,81,1,class<`matrix`>,1
+distr,p,1,81,0,logical,1
+distr,p,2,81,0,logical,1
+distr,p,3,81,0,...,1
+distr,p,-1,82,0,class<`function`>,1
+distr,p,0,82,0,class<`Lnorm`>,1
+distr,p,-1,83,0,double[],1
+distr,p,0,83,0,double[],1
+distr,p,1,83,0,logical,1
+distr,p,2,83,0,logical,1
+distr,p,-1,84,0,double,1
+distr,p,0,84,0,double,1
+distr,p,1,84,0,logical,1
+distr,p,2,84,0,logical,1
+distr,p,-1,85,0,double[],1
+distr,p,0,85,0,double[],1
+distr,p,1,85,0,logical,1
+distr,p,2,85,0,logical,1
+distr,p,-1,86,0,class<`function`>,1
+distr,p,0,86,0,class<`UnivarLebDecDistribution`>,1
+distr,p,-1,87,0,double,1
+distr,p,0,87,0,double,1
+distr,p,1,87,0,logical,1
+distr,p,2,87,0,logical,1
+distr,p,-1,88,0,class<`function`>,1
+distr,p,0,88,0,class<`Arcsine`>,1
+distr,p,-1,89,0,class<`function`>,1
+distr,p,0,89,0,class<`Norm`>,1
+distr,p,-1,90,0,double[],1
+distr,p,-1,90,1,class<`matrix`>,1
+distr,p,0,90,0,double[],1
+distr,p,0,90,1,class<`matrix`>,1
+distr,p,1,90,0,logical,1
+distr,p,2,90,0,logical,1
+distr,p,3,90,0,...,1
+distr,.P2D,-1,0,0,class<`function`>,1
+distr,.P2D,0,0,0,class<`function`>,1
+distr,.P2D,1,0,0,any,1
+distr,.P2D,2,0,0,double,1
+distr,.P2D,3,0,0,double,1
+distr,.P2D,4,0,0,double,1
+distr,.P2Q,-1,0,0,class<`function`>,1
+distr,.P2Q,0,0,0,class<`function`>,1
+distr,.P2Q,1,0,0,any,1
+distr,.P2Q,2,0,0,double,1
+distr,.P2Q,3,0,0,double,1
+distr,.P2Q,4,0,0,double,1
+distr,.P2Q,5,0,0,double,1
+distr,.P2Q,6,0,0,double,1
+distr,p.ac,-1,0,0,^double[],1
+distr,p.ac,0,0,0,^double[],1
+distr,p.ac,0,0,1,class<`matrix`>,1
+distr,p.ac,1,0,0,logical,1
+distr,p.ac,2,0,0,logical,1
+distr,p.ac,-1,1,0,class<`function`>,1
+distr,p.ac,0,1,0,class<`UnivarLebDecDistribution`>,1
+distr,p.ac,1,1,0,...,1
+distr,p.ac,-1,2,0,class<`function`>,1
+distr,p.ac,0,2,0,class<`UnivarLebDecDistribution`>,1
+distr,p.ac,1,2,0,...,1
+distr,.panel.mingle,-1,0,0,class<`call`>,1
+distr,.panel.mingle,-1,0,1,list<class<`call`>>,1
+distr,.panel.mingle,-1,0,2,list<expression>,1
+distr,.panel.mingle,0,0,0,pairlist,1
+distr,.panel.mingle,1,0,0,character,1
+distr,param,-1,0,0,class<`BinomParameter`>,1
+distr,param,0,0,0,class<`Binom`>,1
+distr,param,-1,1,0,class<`HyperParameter`>,1
+distr,param,0,1,0,class<`Hyper`>,1
+distr,param,-1,2,0,class<`NbinomParameter`>,1
+distr,param,0,2,0,class<`Geom`>,1
+distr,param,-1,3,0,class<`CauchyParameter`>,1
+distr,param,0,3,0,class<`Cauchy`>,1
+distr,param,-1,4,0,class<`UniNormParameter`>,1
+distr,param,0,4,0,class<`Norm`>,1
+distr,param,-1,5,0,class<`FParameter`>,1
+distr,param,0,5,0,class<`Fd`>,1
+distr,param,-1,6,0,class<`GammaParameter`>,1
+distr,param,0,6,0,class<`Gammad`>,1
+distr,param,-1,7,0,class<`LnormParameter`>,1
+distr,param,0,7,0,class<`Lnorm`>,1
+distr,param,-1,8,0,null,1
+distr,param,0,8,0,class<`AffLinUnivarLebDecDistribution`>,1
+distr,param,-1,9,0,class<`PoisParameter`>,1
+distr,param,0,9,0,class<`Pois`>,1
+distr,param,-1,10,0,class<`DiracParameter`>,1
+distr,param,0,10,0,class<`Dirac`>,1
+distr,param,-1,11,0,class<`UnifParameter`>,1
+distr,param,0,11,0,class<`Unif`>,1
+distr,param,-1,12,0,class<`WeibullParameter`>,1
+distr,param,0,12,0,class<`Weibull`>,1
+distr,param,-1,13,0,class<`TParameter`>,1
+distr,param,0,13,0,class<`Td`>,1
+distr,param,-1,14,0,class<`ExpParameter`>,1
+distr,param,0,14,0,class<`Exp`>,1
+distr,param,-1,15,0,null,1
+distr,param,0,15,0,class<`UnivarLebDecDistribution`>,1
+distr,param,-1,16,0,null,1
+distr,param,0,16,0,class<`AbscontDistribution`>,1
+distr,param,-1,17,0,null,1
+distr,param,0,17,0,class<`DiscreteDistribution`>,1
+distr,param,-1,18,0,class<`ExpParameter`>,1
+distr,param,0,18,0,class<`DExp`>,1
+distr,param,-1,19,0,class<`BetaParameter`>,1
+distr,param,0,19,0,class<`Beta`>,1
+distr,param,-1,20,0,class<`ChisqParameter`>,1
+distr,param,0,20,0,class<`Chisq`>,1
+distr,param,-1,21,0,null,1
+distr,param,0,21,0,class<`AffLinAbscontDistribution`>,1
+distr,param,-1,22,0,null,1
+distr,param,0,22,0,class<`LatticeDistribution`>,1
+distr,param,-1,23,0,null,1
+distr,param,0,23,0,class<`AffLinDiscreteDistribution`>,1
+distr,param,-1,24,0,class<`BetaParameter`>,1
+distr,param,-1,24,1,class<`BinomParameter`>,1
+distr,param,-1,24,2,class<`CauchyParameter`>,1
+distr,param,-1,24,3,class<`ChisqParameter`>,1
+distr,param,-1,24,4,class<`DiracParameter`>,1
+distr,param,-1,24,5,class<`ExpParameter`>,1
+distr,param,-1,24,6,class<`FParameter`>,1
+distr,param,-1,24,7,class<`GammaParameter`>,1
+distr,param,-1,24,8,class<`HyperParameter`>,1
+distr,param,-1,24,9,class<`LnormParameter`>,1
+distr,param,-1,24,10,class<`LogisParameter`>,1
+distr,param,-1,24,11,class<`NbinomParameter`>,1
+distr,param,-1,24,12,class<`PoisParameter`>,1
+distr,param,-1,24,13,class<`TParameter`>,1
+distr,param,-1,24,14,class<`UnifParameter`>,1
+distr,param,-1,24,15,class<`UniNormParameter`>,1
+distr,param,-1,24,16,class<`WeibullParameter`>,1
+distr,param,-1,24,17,null,1
+distr,param,0,24,0,class<`Beta`>,1
+distr,param,0,24,1,class<`Binom`>,1
+distr,param,0,24,2,class<`Cauchy`>,1
+distr,param,0,24,3,class<`Chisq`>,1
+distr,param,0,24,4,class<`Dirac`>,1
+distr,param,0,24,5,class<`DExp`>,1
+distr,param,0,24,6,class<`Exp`>,1
+distr,param,0,24,7,class<`Fd`>,1
+distr,param,0,24,8,class<`Gammad`>,1
+distr,param,0,24,9,class<`Hyper`>,1
+distr,param,0,24,10,class<`Lnorm`>,1
+distr,param,0,24,11,class<`Logis`>,1
+distr,param,0,24,12,class<`Geom`>,1
+distr,param,0,24,13,class<`Nbinom`>,1
+distr,param,0,24,14,class<`Pois`>,1
+distr,param,0,24,15,class<`Td`>,1
+distr,param,0,24,16,class<`Unif`>,1
+distr,param,0,24,17,class<`Norm`>,1
+distr,param,0,24,18,class<`Weibull`>,1
+distr,param,0,24,19,class<`AbscontDistribution`>,1
+distr,param,0,24,20,class<`AffLinAbscontDistribution`>,1
+distr,param,0,24,21,class<`AffLinDiscreteDistribution`>,1
+distr,param,0,24,22,class<`AffLinUnivarLebDecDistribution`>,1
+distr,param,0,24,23,class<`DiscreteDistribution`>,1
+distr,param,0,24,24,class<`LatticeDistribution`>,1
+distr,param,0,24,25,class<`UnivarLebDecDistribution`>,1
+distr,param,-1,25,0,class<`LogisParameter`>,1
+distr,param,0,25,0,class<`Logis`>,1
+distr,param,-1,26,0,class<`NbinomParameter`>,1
+distr,param,0,26,0,class<`Nbinom`>,1
+distr,pivot,-1,0,0,double,1
+distr,pivot,0,0,0,class<`Lattice`>,1
+distr,pivot,-1,1,0,double,1
+distr,pivot,0,1,0,class<`Lattice`>,1
+distr,pivot<-,-1,0,0,class<`Lattice`>,1
+distr,pivot<-,0,0,0,class<`Lattice`>,1
+distr,pivot<-,1,0,0,double,1
+distr,pivot<-,-1,1,0,class<`Lattice`>,1
+distr,pivot<-,0,1,0,class<`Lattice`>,1
+distr,pivot<-,1,1,0,double,1
+distr,.pk2,-1,0,0,double,1
+distr,.pk2,0,0,0,double,1
+distr,.pk2,1,0,0,double,1
+distr,.pks2,-1,0,0,double,1
+distr,.pks2,0,0,0,double,1
+distr,.pks2,1,0,0,double,1
+distr,p.l,-1,0,0,double[],1
+distr,p.l,0,0,0,double[],1
+distr,p.l,1,0,0,logical,1
+distr,p.l,2,0,0,logical,1
+distr,p.l,-1,1,0,double[],1
+distr,p.l,-1,1,1,class<`matrix`>,1
+distr,p.l,0,1,0,double[],1
+distr,p.l,0,1,1,class<`matrix`>,1
+distr,p.l,1,1,0,logical,1
+distr,p.l,2,1,0,logical,1
+distr,p.l,-1,2,0,double[],1
+distr,p.l,0,2,0,double[],1
+distr,p.l,1,2,0,logical,1
+distr,p.l,2,2,0,logical,1
+distr,p.l,-1,3,0,class<`function`>,1
+distr,p.l,0,3,0,class<`Binom`>,1
+distr,p.l,-1,4,0,class<`function`>,1
+distr,p.l,0,4,0,class<`AffLinAbscontDistribution`>,1
+distr,p.l,-1,5,0,double[],1
+distr,p.l,0,5,0,double[],1
+distr,p.l,1,5,0,logical,1
+distr,p.l,2,5,0,logical,1
+distr,p.l,-1,6,0,class<`function`>,1
+distr,p.l,0,6,0,class<`Chisq`>,1
+distr,p.l,-1,7,0,class<`function`>,1
+distr,p.l,0,7,0,class<`Dirac`>,1
+distr,p.l,-1,8,0,class<`function`>,1
+distr,p.l,0,8,0,class<`DExp`>,1
+distr,p.l,-1,9,0,class<`function`>,1
+distr,p.l,0,9,0,class<`Unif`>,1
+distr,p.l,-1,10,0,class<`function`>,1
+distr,p.l,0,10,0,class<`Geom`>,1
+distr,p.l,-1,11,0,class<`function`>,1
+distr,p.l,0,11,0,class<`AbscontDistribution`>,1
+distr,p.l,0,11,1,class<`AffLinAbscontDistribution`>,1
+distr,p.l,0,11,2,class<`Chisq`>,1
+distr,p.l,0,11,3,class<`DExp`>,1
+distr,p.l,0,11,4,class<`Norm`>,1
+distr,p.l,0,11,5,class<`Unif`>,1
+distr,p.l,0,11,6,class<`Binom`>,1
+distr,p.l,0,11,7,class<`Dirac`>,1
+distr,p.l,0,11,8,class<`DiscreteDistribution`>,1
+distr,p.l,0,11,9,class<`Geom`>,1
+distr,p.l,0,11,10,class<`Nbinom`>,1
+distr,p.l,0,11,11,class<`Pois`>,1
+distr,p.l,0,11,12,class<`UnivarLebDecDistribution`>,1
+distr,p.l,0,11,13,class<`UnivarMixingDistribution`>,1
+distr,p.l,-1,12,0,class<`function`>,1
+distr,p.l,0,12,0,class<`UnivarMixingDistribution`>,1
+distr,p.l,-1,13,0,class<`function`>,1
+distr,p.l,0,13,0,class<`UnivarLebDecDistribution`>,1
+distr,p.l,-1,14,0,class<`function`>,1
+distr,p.l,0,14,0,class<`Nbinom`>,1
+distr,p.l,-1,15,0,class<`function`>,1
+distr,p.l,0,15,0,class<`DiscreteDistribution`>,1
+distr,p.l,-1,16,0,class<`function`>,1
+distr,p.l,0,16,0,class<`Norm`>,1
+distr,p.l,-1,17,0,class<`function`>,1
+distr,p.l,0,17,0,class<`Pois`>,1
+distr,p.l,-1,18,0,class<`function`>,1
+distr,p.l,0,18,0,class<`AbscontDistribution`>,1
+distr,plot,-1,0,0,"class<`DiagnInfo`, `plotInfo`>",1
+distr,plot,0,0,0,class<`DiscreteDistribution`>,1
+distr,plot,1,0,0,any,1
+distr,plot,2,0,0,...,1
+distr,plot,-1,1,0,"class<`DiagnInfo`, `plotInfo`>",1
+distr,plot,0,1,0,class<`AffLinUnivarLebDecDistribution`>,1
+distr,plot,1,1,0,any,1
+distr,plot,2,1,0,...,1
+distr,plot,-1,2,0,"class<`DiagnInfo`, `plotInfo`>",1
+distr,plot,0,2,0,class<`Cauchy`>,1
+distr,plot,1,2,0,any,1
+distr,plot,2,2,0,...,1
+distr,plot,-1,3,0,"class<`DiagnInfo`, `plotInfo`>",1
+distr,plot,0,3,0,class<`UnivarLebDecDistribution`>,1
+distr,plot,1,3,0,any,1
+distr,plot,2,3,0,...,1
+distr,plot,-1,4,0,"class<`DiagnInfo`, `plotInfo`>",1
+distr,plot,0,4,0,class<`UnivarDistrList`>,1
+distr,plot,1,4,0,any,1
+distr,plot,2,4,0,...,1
+distr,plot,-1,5,0,"class<`DiagnInfo`, `plotInfo`>",1
+distr,plot,0,5,0,class<`Chisq`>,1
+distr,plot,1,5,0,any,1
+distr,plot,2,5,0,...,1
+distr,plot,-1,6,0,"class<`DiagnInfo`, `plotInfo`>",1
+distr,plot,0,6,0,class<`Binom`>,1
+distr,plot,1,6,0,any,1
+distr,plot,2,6,0,...,1
+distr,plot,-1,7,0,"class<`DiagnInfo`, `plotInfo`>",1
+distr,plot,0,7,0,class<`DistrList`>,1
+distr,plot,1,7,0,any,1
+distr,plot,2,7,0,...,1
+distr,plot,-1,8,0,"class<`DiagnInfo`, `plotInfo`>",1
+distr,plot,0,8,0,class<`Pois`>,1
+distr,plot,1,8,0,any,1
+distr,plot,2,8,0,...,1
+distr,plot,-1,9,0,"class<`DiagnInfo`, `plotInfo`>",1
+distr,plot,0,9,0,class<`Nbinom`>,1
+distr,plot,1,9,0,any,1
+distr,plot,2,9,0,...,1
+distr,plot,-1,10,0,"class<`DiagnInfo`, `plotInfo`>",1
+distr,plot,0,10,0,class<`CompoundDistribution`>,1
+distr,plot,1,10,0,any,1
+distr,plot,2,10,0,...,1
+distr,plot,-1,11,0,"class<`DiagnInfo`, `plotInfo`>",1
+distr,plot,0,11,0,class<`AffLinAbscontDistribution`>,1
+distr,plot,1,11,0,any,1
+distr,plot,2,11,0,...,1
+distr,plot,-1,12,0,"class<`DiagnInfo`, `plotInfo`>",1
+distr,plot,0,12,0,class<`Exp`>,1
+distr,plot,1,12,0,any,1
+distr,plot,2,12,0,...,1
+distr,plot,-1,13,0,"class<`DiagnInfo`, `plotInfo`>",1
+distr,plot,0,13,0,class<`AbscontDistribution`>,1
+distr,plot,0,13,1,class<`AffLinAbscontDistribution`>,1
+distr,plot,0,13,2,class<`Norm`>,1
+distr,plot,1,13,0,any,1
+distr,plot,2,13,0,...,1
+distr,plot,-1,14,0,"class<`DiagnInfo`, `plotInfo`>",1
+distr,plot,0,14,0,class<`Norm`>,1
+distr,plot,1,14,0,any,1
+distr,plot,2,14,0,...,1
+distr,plot,-1,15,0,"class<`DiagnInfo`, `plotInfo`>",1
+distr,plot,0,15,0,class<`LatticeDistribution`>,1
+distr,plot,1,15,0,any,1
+distr,plot,2,15,0,...,1
+distr,.plusm,-1,0,0,class<`AffLinAbscontDistribution`>,1
+distr,.plusm,-1,0,1,class<`AffLinDiscreteDistribution`>,1
+distr,.plusm,0,0,0,class<`AffLinAbscontDistribution`>,1
+distr,.plusm,0,0,1,class<`Exp`>,1
+distr,.plusm,0,0,2,class<`DiscreteDistribution`>,1
+distr,.plusm,1,0,0,double,1
+distr,.plusm,2,0,0,character,1
+distr,.pmixfun,-1,0,0,class<`function`>,1
+distr,.pmixfun,0,0,0,any,1
+distr,.pmixfun,1,0,0,double[],1
+distr,.pmixfun,2,0,0,character,1
+distr,Pois,-1,0,0,class<`Pois`>,1
+distr,Pois,0,0,0,double,1
+distr,PosDefSymmMatrix,-1,0,0,class<`PosDefSymmMatrix`>,1
+distr,PosDefSymmMatrix,0,0,0,class<`matrix`>,1
+distr,PosDefSymmMatrix,0,0,1,double,1
+distr,PosSemDefSymmMatrix,-1,0,0,class<`PosSemDefSymmMatrix`>,1
+distr,PosSemDefSymmMatrix,0,0,0,class<`matrix`>,1
+distr,PosSemDefSymmMatrix,0,0,1,double,1
+distr,p.r,-1,0,0,double[],1
+distr,p.r,-1,0,1,class<`matrix`>,1
+distr,p.r,0,0,0,double[],1
+distr,p.r,0,0,1,class<`matrix`>,1
+distr,p.r,1,0,0,logical,1
+distr,p.r,2,0,0,logical,1
+distr,p.r,-1,1,0,class<`function`>,1
+distr,p.r,0,1,0,class<`Norm`>,1
+distr,p.r,-1,2,0,class<`function`>,1
+distr,p.r,0,2,0,class<`Norm`>,1
+distr,.presubs,-1,0,0,expression,1
+distr,.presubs,0,0,0,character,1
+distr,.presubs,0,0,1,expression,1
+distr,.presubs,0,0,2,logical,1
+distr,.presubs,1,0,0,character[],1
+distr,.presubs,2,0,0,character[],1
+distr,prob,-1,0,0,double,1
+distr,prob,0,0,0,class<`Binom`>,1
+distr,prob,-1,1,0,double,1
+distr,prob,0,1,0,class<`NbinomParameter`>,1
+distr,prob,-1,2,0,double,1
+distr,prob,0,2,0,class<`Geom`>,1
+distr,prob,-1,3,0,double,1
+distr,prob,0,3,0,class<`BinomParameter`>,1
+distr,prob,-1,4,0,double[],1
+distr,prob,0,4,0,class<`DiscreteDistribution`>,1
+distr,prob,-1,5,0,double,1
+distr,prob,0,5,0,class<`Nbinom`>,1
+distr,prob,-1,6,0,double[],1
+distr,prob,0,6,0,class<`Binom`>,1
+distr,prob,0,6,1,class<`BinomParameter`>,1
+distr,prob,0,6,2,class<`Geom`>,1
+distr,prob,0,6,3,class<`Nbinom`>,1
+distr,prob,0,6,4,class<`NbinomParameter`>,1
+distr,prob,0,6,5,class<`DiscreteDistribution`>,1
+distr,prob<-,-1,0,0,class<`Geom`>,1
+distr,prob<-,0,0,0,class<`Geom`>,1
+distr,prob<-,1,0,0,double,1
+distr,prob<-,-1,1,0,class<`Geom`>,1
+distr,prob<-,0,1,0,class<`Geom`>,1
+distr,prob<-,1,1,0,double,1
+distr,q,-1,0,0,double[],1
+distr,q,0,0,0,double[],1
+distr,q,1,0,0,logical,1
+distr,q,2,0,0,logical,1
+distr,q,-1,1,0,double[],1
+distr,q,0,1,0,double[],1
+distr,q,1,1,0,logical,1
+distr,q,2,1,0,logical,1
+distr,q,-1,2,0,double,1
+distr,q,0,2,0,double,1
+distr,q,1,2,0,logical,1
+distr,q,2,2,0,logical,1
+distr,q,-1,3,0,double,1
+distr,q,0,3,0,double,1
+distr,q,1,3,0,logical,1
+distr,q,2,3,0,logical,1
+distr,q,-1,4,0,class<`function`>,1
+distr,q,0,4,0,class<`Hyper`>,1
+distr,q,1,4,0,double,1
+distr,q,2,4,0,logical,1
+distr,q,-1,5,0,class<`function`>,1
+distr,q,0,5,0,class<`Lnorm`>,1
+distr,q,1,5,0,double,1
+distr,q,2,5,0,logical,1
+distr,q,-1,6,0,double,1
+distr,q,0,6,0,double,1
+distr,q,1,6,0,logical,1
+distr,q,2,6,0,logical,1
+distr,q,-1,7,0,double,1
+distr,q,0,7,0,double,1
+distr,q,1,7,0,logical,1
+distr,q,2,7,0,logical,1
+distr,q,-1,8,0,double,1
+distr,q,0,8,0,double,1
+distr,q,1,8,0,logical,1
+distr,q,2,8,0,logical,1
+distr,q,-1,9,0,class<`function`>,1
+distr,q,0,9,0,class<`Gammad`>,1
+distr,q,1,9,0,double,1
+distr,q,2,9,0,logical,1
+distr,q,-1,10,0,class<`function`>,1
+distr,q,0,10,0,class<`AbscontDistribution`>,1
+distr,q,1,10,0,double,1
+distr,q,2,10,0,logical,1
+distr,q,-1,11,0,class<`function`>,1
+distr,q,0,11,0,class<`UnivarLebDecDistribution`>,1
+distr,q,1,11,0,double,1
+distr,q,2,11,0,logical,1
+distr,q,-1,12,0,double,1
+distr,q,0,12,0,double,1
+distr,q,1,12,0,logical,1
+distr,q,2,12,0,logical,1
+distr,q,-1,13,0,class<`function`>,1
+distr,q,0,13,0,class<`Fd`>,1
+distr,q,1,13,0,double,1
+distr,q,2,13,0,logical,1
+distr,q,-1,14,0,double,1
+distr,q,0,14,0,double,1
+distr,q,1,14,0,logical,1
+distr,q,2,14,0,logical,1
+distr,q,-1,15,0,double,1
+distr,q,0,15,0,double,1
+distr,q,1,15,0,logical,1
+distr,q,2,15,0,logical,1
+distr,q,-1,16,0,double,1
+distr,q,0,16,0,double,1
+distr,q,1,16,0,logical,1
+distr,q,2,16,0,logical,1
+distr,q,-1,17,0,double,1
+distr,q,0,17,0,double,1
+distr,q,1,17,0,logical,1
+distr,q,2,17,0,logical,1
+distr,q,-1,18,0,class<`function`>,1
+distr,q,0,18,0,class<`Binom`>,1
+distr,q,1,18,0,double,1
+distr,q,2,18,0,logical,1
+distr,q,-1,19,0,class<`function`>,1
+distr,q,0,19,0,class<`LatticeDistribution`>,1
+distr,q,1,19,0,double,1
+distr,q,2,19,0,logical,1
+distr,q,-1,20,0,double,1
+distr,q,0,20,0,double,1
+distr,q,1,20,0,logical,1
+distr,q,2,20,0,logical,1
+distr,q,-1,21,0,class<`function`>,1
+distr,q,0,21,0,class<`Cauchy`>,1
+distr,q,1,21,0,double,1
+distr,q,2,21,0,logical,1
+distr,q,-1,22,0,double,1
+distr,q,0,22,0,double,1
+distr,q,1,22,0,logical,1
+distr,q,2,22,0,logical,1
+distr,q,-1,23,0,class<`function`>,1
+distr,q,0,23,0,class<`Pois`>,1
+distr,q,1,23,0,double,1
+distr,q,2,23,0,logical,1
+distr,q,-1,24,0,class<`function`>,1
+distr,q,0,24,0,class<`Logis`>,1
+distr,q,1,24,0,double,1
+distr,q,2,24,0,logical,1
+distr,q,-1,25,0,class<`function`>,1
+distr,q,0,25,0,class<`DExp`>,1
+distr,q,1,25,0,double,1
+distr,q,2,25,0,logical,1
+distr,q,-1,26,0,double,1
+distr,q,0,26,0,double,1
+distr,q,1,26,0,logical,1
+distr,q,2,26,0,logical,1
+distr,q,-1,27,0,class<`function`>,1
+distr,q,0,27,0,class<`Weibull`>,1
+distr,q,1,27,0,double,1
+distr,q,2,27,0,logical,1
+distr,q,-1,28,0,class<`function`>,1
+distr,q,0,28,0,class<`Dirac`>,1
+distr,q,1,28,0,double,1
+distr,q,2,28,0,logical,1
+distr,q,-1,29,0,double,1
+distr,q,0,29,0,double,1
+distr,q,1,29,0,logical,1
+distr,q,2,29,0,logical,1
+distr,q,-1,30,0,class<`function`>,1
+distr,q,0,30,0,class<`Chisq`>,1
+distr,q,1,30,0,double,1
+distr,q,2,30,0,logical,1
+distr,q,-1,31,0,double,1
+distr,q,0,31,0,double,1
+distr,q,1,31,0,logical,1
+distr,q,2,31,0,logical,1
+distr,q,-1,32,0,class<`function`>,1
+distr,q,0,32,0,class<`Beta`>,1
+distr,q,1,32,0,double,1
+distr,q,2,32,0,logical,1
+distr,q,-1,33,0,class<`function`>,1
+distr,q,0,33,0,class<`Nbinom`>,1
+distr,q,1,33,0,double,1
+distr,q,2,33,0,logical,1
+distr,q,-1,34,0,double,1
+distr,q,0,34,0,double,1
+distr,q,1,34,0,logical,1
+distr,q,2,34,0,logical,1
+distr,q,-1,35,0,class<`function`>,1
+distr,q,0,35,0,class<`Td`>,1
+distr,q,1,35,0,double,1
+distr,q,2,35,0,logical,1
+distr,q,-1,36,0,double,1
+distr,q,0,36,0,double,1
+distr,q,1,36,0,logical,1
+distr,q,2,36,0,logical,1
+distr,q,-1,37,0,double,1
+distr,q,0,37,0,double,1
+distr,q,1,37,0,logical,1
+distr,q,2,37,0,logical,1
+distr,q,-1,38,0,double,1
+distr,q,0,38,0,double,1
+distr,q,1,38,0,logical,1
+distr,q,2,38,0,logical,1
+distr,q,-1,39,0,class<`function`>,1
+distr,q,0,39,0,class<`Arcsine`>,1
+distr,q,1,39,0,double,1
+distr,q,2,39,0,logical,1
+distr,q,-1,40,0,double,1
+distr,q,0,40,0,double,1
+distr,q,1,40,0,logical,1
+distr,q,2,40,0,logical,1
+distr,q,-1,41,0,class<`function`>,1
+distr,q,0,41,0,class<`Exp`>,1
+distr,q,1,41,0,double,1
+distr,q,2,41,0,logical,1
+distr,q,-1,42,0,class<`function`>,1
+distr,q,0,42,0,class<`Geom`>,1
+distr,q,1,42,0,double,1
+distr,q,2,42,0,logical,1
+distr,q,-1,43,0,class<`function`>,1
+distr,q,0,43,0,class<`Norm`>,1
+distr,q,1,43,0,double,1
+distr,q,2,43,0,logical,1
+distr,q,-1,44,0,double,1
+distr,q,0,44,0,double,1
+distr,q,1,44,0,logical,1
+distr,q,2,44,0,logical,1
+distr,q,-1,45,0,^double[],1
+distr,q,0,45,0,double[],1
+distr,q,1,45,0,logical,1
+distr,q,2,45,0,logical,1
+distr,q,-1,46,0,class<`function`>,1
+distr,q,0,46,0,class<`Unif`>,1
+distr,q,1,46,0,double,1
+distr,q,2,46,0,logical,1
+distr,q,-1,47,0,class<`function`>,1
+distr,q,0,47,0,class<`DiscreteDistribution`>,1
+distr,q,1,47,0,double,1
+distr,q,2,47,0,logical,1
+distr,.q2kolmogorov,-1,0,0,double,1
+distr,.q2kolmogorov,0,0,0,double,1
+distr,.q2kolmogorov,1,0,0,any,1
+distr,.q2kolmogorov,2,0,0,logical,1
+distr,.q2kolmogorov,3,0,0,any,1
+distr,.Q2P,-1,0,0,class<`function`>,1
+distr,.Q2P,0,0,0,class<`function`>,1
+distr,.Q2P,1,0,0,double,1
+distr,.q2pw,-1,0,0,class<`matrix`>,1
+distr,.q2pw,0,0,0,double[],1
+distr,.q2pw,1,0,0,double[],1
+distr,.q2pw,2,0,0,class<`Chisq`>,1
+distr,.q2pw,2,0,1,class<`Norm`>,1
+distr,.q2pw,3,0,0,any,1
+distr,.q2pw,4,0,0,double,1
+distr,.q2pw,5,0,0,logical,1
+distr,.q2pw,6,0,0,any,1
+distr,.q2pw,7,0,0,any,1
+distr,q.l,-1,0,0,double,1
+distr,q.l,0,0,0,double,1
+distr,q.l,1,0,0,logical,1
+distr,q.l,2,0,0,logical,1
+distr,q.l,-1,1,0,double,1
+distr,q.l,0,1,0,double,1
+distr,q.l,1,1,0,logical,1
+distr,q.l,2,1,0,logical,1
+distr,q.l,-1,2,0,double,1
+distr,q.l,0,2,0,double,1
+distr,q.l,1,2,0,logical,1
+distr,q.l,2,2,0,logical,1
+distr,q.l,-1,3,0,double,1
+distr,q.l,0,3,0,double,1
+distr,q.l,1,3,0,logical,1
+distr,q.l,2,3,0,logical,1
+distr,q.l,-1,4,0,double,1
+distr,q.l,0,4,0,double,1
+distr,q.l,1,4,0,logical,1
+distr,q.l,2,4,0,logical,1
+distr,q.l,-1,5,0,double,1
+distr,q.l,0,5,0,double,1
+distr,q.l,1,5,0,logical,1
+distr,q.l,2,5,0,logical,1
+distr,q.l,-1,6,0,double,1
+distr,q.l,0,6,0,double,1
+distr,q.l,1,6,0,logical,1
+distr,q.l,2,6,0,logical,1
+distr,q.l,-1,7,0,double,1
+distr,q.l,0,7,0,double,1
+distr,q.l,1,7,0,logical,1
+distr,q.l,2,7,0,logical,1
+distr,q.l,3,7,0,...,1
+distr,q.l,-1,8,0,double[],1
+distr,q.l,0,8,0,double[],1
+distr,q.l,1,8,0,logical,1
+distr,q.l,2,8,0,logical,1
+distr,q.l,-1,9,0,double,1
+distr,q.l,0,9,0,double,1
+distr,q.l,1,9,0,logical,1
+distr,q.l,2,9,0,logical,1
+distr,q.l,-1,10,0,double,1
+distr,q.l,0,10,0,double,1
+distr,q.l,1,10,0,logical,1
+distr,q.l,2,10,0,logical,1
+distr,q.l,-1,11,0,double,1
+distr,q.l,0,11,0,double,1
+distr,q.l,1,11,0,logical,1
+distr,q.l,2,11,0,logical,1
+distr,q.l,-1,12,0,double,1
+distr,q.l,0,12,0,double,1
+distr,q.l,1,12,0,logical,1
+distr,q.l,2,12,0,logical,1
+distr,q.l,-1,13,0,double,1
+distr,q.l,0,13,0,double,1
+distr,q.l,1,13,0,logical,1
+distr,q.l,2,13,0,logical,1
+distr,q.l,-1,14,0,double,1
+distr,q.l,0,14,0,double,1
+distr,q.l,1,14,0,logical,1
+distr,q.l,2,14,0,logical,1
+distr,q.l,-1,15,0,double,1
+distr,q.l,0,15,0,double,1
+distr,q.l,1,15,0,logical,1
+distr,q.l,2,15,0,logical,1
+distr,q.l,-1,16,0,double,1
+distr,q.l,0,16,0,double,1
+distr,q.l,1,16,0,logical,1
+distr,q.l,2,16,0,logical,1
+distr,q.l,-1,17,0,double,1
+distr,q.l,0,17,0,double,1
+distr,q.l,1,17,0,logical,1
+distr,q.l,2,17,0,logical,1
+distr,q.l,-1,18,0,double,1
+distr,q.l,0,18,0,double,1
+distr,q.l,1,18,0,logical,1
+distr,q.l,2,18,0,logical,1
+distr,q.l,-1,19,0,double[],1
+distr,q.l,0,19,0,double[],1
+distr,q.l,1,19,0,logical,1
+distr,q.l,2,19,0,logical,1
+distr,q.l,-1,20,0,double,1
+distr,q.l,0,20,0,double,1
+distr,q.l,1,20,0,logical,1
+distr,q.l,2,20,0,logical,1
+distr,q.l,-1,21,0,double,1
+distr,q.l,0,21,0,double,1
+distr,q.l,1,21,0,logical,1
+distr,q.l,2,21,0,logical,1
+distr,q.l,-1,22,0,double,1
+distr,q.l,0,22,0,double,1
+distr,q.l,1,22,0,logical,1
+distr,q.l,2,22,0,logical,1
+distr,q.l,-1,23,0,double,1
+distr,q.l,0,23,0,double,1
+distr,q.l,1,23,0,logical,1
+distr,q.l,2,23,0,logical,1
+distr,q.l,3,23,0,...,1
+distr,q.l,-1,24,0,double,1
+distr,q.l,0,24,0,double,1
+distr,q.l,1,24,0,logical,1
+distr,q.l,2,24,0,logical,1
+distr,q.l,-1,25,0,double,1
+distr,q.l,0,25,0,double,1
+distr,q.l,1,25,0,logical,1
+distr,q.l,2,25,0,logical,1
+distr,q.l,-1,26,0,double,1
+distr,q.l,0,26,0,double,1
+distr,q.l,1,26,0,logical,1
+distr,q.l,2,26,0,logical,1
+distr,q.l,-1,27,0,double,1
+distr,q.l,0,27,0,double,1
+distr,q.l,1,27,0,logical,1
+distr,q.l,2,27,0,logical,1
+distr,q.l,-1,28,0,class<`Integer`>,1
+distr,q.l,-1,28,1,double,1
+distr,q.l,0,28,0,double,1
+distr,q.l,1,28,0,logical,1
+distr,q.l,2,28,0,logical,1
+distr,q.l,3,28,0,...,1
+distr,q.l,-1,29,0,double,1
+distr,q.l,0,29,0,double,1
+distr,q.l,1,29,0,logical,1
+distr,q.l,2,29,0,logical,1
+distr,q.l,3,29,0,...,1
+distr,q.l,-1,30,0,double,1
+distr,q.l,0,30,0,double,1
+distr,q.l,1,30,0,logical,1
+distr,q.l,2,30,0,logical,1
+distr,q.l,-1,31,0,double[],1
+distr,q.l,0,31,0,double[],1
+distr,q.l,1,31,0,logical,1
+distr,q.l,2,31,0,logical,1
+distr,q.l,-1,32,0,double,1
+distr,q.l,0,32,0,double,1
+distr,q.l,1,32,0,logical,1
+distr,q.l,2,32,0,logical,1
+distr,q.l,-1,33,0,double,1
+distr,q.l,0,33,0,double,1
+distr,q.l,1,33,0,logical,1
+distr,q.l,2,33,0,logical,1
+distr,q.l,-1,34,0,double,1
+distr,q.l,0,34,0,double,1
+distr,q.l,1,34,0,logical,1
+distr,q.l,2,34,0,logical,1
+distr,q.l,-1,35,0,double,1
+distr,q.l,0,35,0,double,1
+distr,q.l,1,35,0,logical,1
+distr,q.l,2,35,0,logical,1
+distr,q.l,-1,36,0,double,1
+distr,q.l,0,36,0,double,1
+distr,q.l,1,36,0,logical,1
+distr,q.l,2,36,0,logical,1
+distr,q.l,-1,37,0,double,1
+distr,q.l,0,37,0,double,1
+distr,q.l,1,37,0,logical,1
+distr,q.l,2,37,0,logical,1
+distr,q.l,-1,38,0,double,1
+distr,q.l,0,38,0,double,1
+distr,q.l,1,38,0,logical,1
+distr,q.l,2,38,0,logical,1
+distr,q.l,-1,39,0,double,1
+distr,q.l,0,39,0,double,1
+distr,q.l,1,39,0,logical,1
+distr,q.l,2,39,0,logical,1
+distr,q.l,-1,40,0,double[],1
+distr,q.l,0,40,0,double[],1
+distr,q.l,1,40,0,logical,1
+distr,q.l,2,40,0,logical,1
+distr,q.l,-1,41,0,double,1
+distr,q.l,0,41,0,double,1
+distr,q.l,1,41,0,logical,1
+distr,q.l,2,41,0,logical,1
+distr,q.l,-1,42,0,class<`function`>,1
+distr,q.l,0,42,0,class<`Binom`>,1
+distr,q.l,-1,43,0,class<`function`>,1
+distr,q.l,0,43,0,class<`Geom`>,1
+distr,q.l,-1,44,0,double,1
+distr,q.l,0,44,0,double,1
+distr,q.l,1,44,0,logical,1
+distr,q.l,2,44,0,logical,1
+distr,q.l,-1,45,0,class<`function`>,1
+distr,q.l,0,45,0,class<`Chisq`>,1
+distr,q.l,-1,46,0,class<`function`>,1
+distr,q.l,0,46,0,class<`LatticeDistribution`>,1
+distr,q.l,-1,47,0,double,1
+distr,q.l,0,47,0,double,1
+distr,q.l,1,47,0,logical,1
+distr,q.l,2,47,0,logical,1
+distr,q.l,3,47,0,...,1
+distr,q.l,-1,48,0,class<`function`>,1
+distr,q.l,0,48,0,class<`AbscontDistribution`>,1
+distr,q.l,0,48,1,class<`AffLinAbscontDistribution`>,1
+distr,q.l,0,48,2,class<`AffLinLatticeDistribution`>,1
+distr,q.l,0,48,3,class<`AffLinUnivarLebDecDistribution`>,1
+distr,q.l,0,48,4,class<`Binom`>,1
+distr,q.l,0,48,5,class<`Cauchy`>,1
+distr,q.l,0,48,6,class<`Chisq`>,1
+distr,q.l,0,48,7,class<`Dirac`>,1
+distr,q.l,0,48,8,class<`DiscreteDistribution`>,1
+distr,q.l,0,48,9,class<`Exp`>,1
+distr,q.l,0,48,10,class<`Geom`>,1
+distr,q.l,0,48,11,class<`LatticeDistribution`>,1
+distr,q.l,0,48,12,class<`Nbinom`>,1
+distr,q.l,0,48,13,class<`Norm`>,1
+distr,q.l,0,48,14,class<`Pois`>,1
+distr,q.l,0,48,15,class<`Td`>,1
+distr,q.l,0,48,16,class<`Unif`>,1
+distr,q.l,0,48,17,class<`UnivarLebDecDistribution`>,1
+distr,q.l,-1,49,0,class<`function`>,1
+distr,q.l,0,49,0,class<`AffLinAbscontDistribution`>,1
+distr,q.l,-1,50,0,double,1
+distr,q.l,0,50,0,double,1
+distr,q.l,1,50,0,logical,1
+distr,q.l,2,50,0,logical,1
+distr,q.l,-1,51,0,class<`function`>,1
+distr,q.l,0,51,0,class<`Td`>,1
+distr,q.l,-1,52,0,class<`function`>,1
+distr,q.l,0,52,0,class<`DiscreteDistribution`>,1
+distr,q.l,-1,53,0,class<`function`>,1
+distr,q.l,0,53,0,class<`Exp`>,1
+distr,q.l,-1,54,0,double,1
+distr,q.l,0,54,0,double,1
+distr,q.l,1,54,0,logical,1
+distr,q.l,2,54,0,logical,1
+distr,q.l,-1,55,0,class<`function`>,1
+distr,q.l,0,55,0,class<`Nbinom`>,1
+distr,q.l,-1,56,0,class<`function`>,1
+distr,q.l,0,56,0,class<`AffLinLatticeDistribution`>,1
+distr,q.l,-1,57,0,class<`function`>,1
+distr,q.l,0,57,0,class<`AffLinUnivarLebDecDistribution`>,1
+distr,q.l,-1,58,0,class<`function`>,1
+distr,q.l,0,58,0,class<`Cauchy`>,1
+distr,q.l,-1,59,0,class<`function`>,1
+distr,q.l,0,59,0,class<`UnivarLebDecDistribution`>,1
+distr,q.l,-1,60,0,class<`function`>,1
+distr,q.l,0,60,0,class<`Pois`>,1
+distr,q.l,-1,61,0,class<`function`>,1
+distr,q.l,0,61,0,class<`Norm`>,1
+distr,q.l,-1,62,0,double,1
+distr,q.l,0,62,0,double,1
+distr,q.l,1,62,0,logical,1
+distr,q.l,2,62,0,logical,1
+distr,q.l,-1,63,0,double[],1
+distr,q.l,0,63,0,double[],1
+distr,q.l,1,63,0,logical,1
+distr,q.l,2,63,0,logical,1
+distr,q.l,-1,64,0,class<`function`>,1
+distr,q.l,0,64,0,class<`Unif`>,1
+distr,q.l,-1,65,0,class<`function`>,1
+distr,q.l,0,65,0,class<`AbscontDistribution`>,1
+distr,q.l,-1,66,0,double,1
+distr,q.l,0,66,0,double,1
+distr,q.l,1,66,0,logical,1
+distr,q.l,2,66,0,logical,1
+distr,q.l,-1,67,0,double,1
+distr,q.l,0,67,0,double,1
+distr,q.l,1,67,0,logical,1
+distr,q.l,2,67,0,logical,1
+distr,q.l,-1,68,0,class<`function`>,1
+distr,q.l,0,68,0,class<`Dirac`>,1
+distr,q.l,-1,69,0,double,1
+distr,q.l,0,69,0,double,1
+distr,q.l,1,69,0,logical,1
+distr,q.l,2,69,0,logical,1
+distr,q.l,-1,70,0,double[],1
+distr,q.l,0,70,0,double[],1
+distr,q.l,1,70,0,logical,1
+distr,q.l,2,70,0,logical,1
+distr,.qmixfun,-1,0,0,class<`function`>,1
+distr,.qmixfun,0,0,0,class<`UnivarDistrList`>,1
+distr,.qmixfun,0,0,1,list<class<`AbscontDistribution`>>,1
+distr,.qmixfun,0,0,2,list<class<`AbscontDistribution`> | class<`AffLinAbscontDistribution`>>,1
+distr,.qmixfun,0,0,3,list<class<`AbscontDistribution`> | class<`DExp`>>,1
+distr,.qmixfun,0,0,4,list<class<`Chisq`> | class<`AbscontDistribution`>>,1
+distr,.qmixfun,0,0,5,list<class<`Norm`> | class<`AbscontDistribution`>>,1
+distr,.qmixfun,0,0,6,list<class<`Norm`>>,1
+distr,.qmixfun,0,0,7,list<class<`Unif`>>,1
+distr,.qmixfun,1,0,0,double[],1
+distr,.qmixfun,2,0,0,logical,1
+distr,.qmixfun,3,0,0,class<`function`>,1
+distr,.qmixfun,4,0,0,null,1
+distr,.qmixfun,5,0,0,character,1
+distr,qqbounds,-1,0,0,list<class<`matrix`> | logical[]>,1
+distr,qqbounds,0,0,0,double[],1
+distr,qqbounds,1,0,0,class<`Chisq`>,1
+distr,qqbounds,1,0,1,class<`Norm`>,1
+distr,qqbounds,2,0,0,double,1
+distr,qqbounds,3,0,0,double,1
+distr,qqbounds,4,0,0,logical,1
+distr,qqbounds,5,0,0,logical,1
+distr,qqbounds,6,0,0,logical,1
+distr,qqbounds,7,0,0,logical,1
+distr,qqplot,-1,0,0,"class<`DiagnInfo`, `qqplotInfo`>",1
+distr,qqplot,0,0,0,class<`Norm`>,1
+distr,qqplot,1,0,0,class<`Chisq`>,1
+distr,qqplot,2,0,0,...,1
+distr,qqplot,-1,1,0,"class<`DiagnInfo`, `qqplotInfo`>",1
+distr,qqplot,0,1,0,class<`Norm`>,1
+distr,qqplot,1,1,0,class<`Chisq`>,1
+distr,qqplot,2,1,0,...,1
+distr,q.r,-1,0,0,double[],1
+distr,q.r,0,0,0,double[],1
+distr,q.r,1,0,0,logical,1
+distr,q.r,2,0,0,logical,1
+distr,q.r,-1,1,0,double[],1
+distr,q.r,0,1,0,double[],1
+distr,q.r,1,1,0,logical,1
+distr,q.r,2,1,0,logical,1
+distr,q.r,-1,2,0,double[],1
+distr,q.r,0,2,0,double[],1
+distr,q.r,1,2,0,logical,1
+distr,q.r,2,2,0,logical,1
+distr,q.r,-1,3,0,class<`function`>,1
+distr,q.r,0,3,0,class<`Chisq`>,1
+distr,q.r,0,3,1,class<`Norm`>,1
+distr,q.r,0,3,2,class<`DiscreteDistribution`>,1
+distr,q.r,0,3,3,class<`Geom`>,1
+distr,q.r,-1,4,0,class<`function`>,1
+distr,q.r,0,4,0,class<`Geom`>,1
+distr,q.r,-1,5,0,double[],1
+distr,q.r,0,5,0,double[],1
+distr,q.r,1,5,0,logical,1
+distr,q.r,2,5,0,logical,1
+distr,q.r,-1,6,0,class<`function`>,1
+distr,q.r,0,6,0,class<`Norm`>,1
+distr,q.r,-1,7,0,class<`function`>,1
+distr,q.r,0,7,0,class<`DiscreteDistribution`>,1
+distr,q.r,-1,8,0,class<`function`>,1
+distr,q.r,0,8,0,class<`Chisq`>,1
+distr,r,-1,0,0,double[],1
+distr,r,0,0,0,double,1
+distr,r,-1,1,0,class<`function`>,1
+distr,r,0,1,0,class<`Cauchy`>,1
+distr,r,-1,2,0,class<`function`>,1
+distr,r,0,2,0,class<`Chisq`>,1
+distr,r,-1,3,0,double,1
+distr,r,0,3,0,double,1
+distr,r,-1,4,0,double,1
+distr,r,0,4,0,double,1
+distr,r,-1,5,0,class<`function`>,1
+distr,r,0,5,0,class<`Pois`>,1
+distr,r,-1,6,0,double,1
+distr,r,0,6,0,double,1
+distr,r,-1,7,0,class<`function`>,1
+distr,r,0,7,0,class<`Fd`>,1
+distr,r,-1,8,0,class<`function`>,1
+distr,r,0,8,0,class<`Norm`>,1
+distr,r,-1,9,0,class<`function`>,1
+distr,r,0,9,0,class<`DiscreteDistribution`>,1
+distr,r,-1,10,0,class<`function`>,1
+distr,r,0,10,0,class<`Nbinom`>,1
+distr,r,-1,11,0,double[],1
+distr,r,0,11,0,double,1
+distr,r,-1,12,0,class<`function`>,1
+distr,r,0,12,0,class<`Td`>,1
+distr,r,-1,13,0,double,1
+distr,r,0,13,0,double,1
+distr,r,-1,14,0,double,1
+distr,r,0,14,0,double,1
+distr,r,-1,15,0,double[],1
+distr,r,0,15,0,double,1
+distr,r,-1,16,0,class<`function`>,1
+distr,r,0,16,0,class<`Logis`>,1
+distr,r,-1,17,0,class<`function`>,1
+distr,r,0,17,0,class<`AbscontDistribution`>,1
+distr,r,-1,18,0,integer,1
+distr,r,0,18,0,double,1
+distr,r,-1,19,0,double[],1
+distr,r,0,19,0,double,1
+distr,r,-1,20,0,double,1
+distr,r,0,20,0,double,1
+distr,r,-1,21,0,double[],1
+distr,r,0,21,0,double,1
+distr,r,-1,22,0,double,1
+distr,r,0,22,0,double,1
+distr,r,-1,23,0,class<`function`>,1
+distr,r,0,23,0,class<`Beta`>,1
+distr,r,-1,24,0,class<`function`>,1
+distr,r,0,24,0,class<`Exp`>,1
+distr,r,-1,25,0,class<`function`>,1
+distr,r,0,25,0,class<`Unif`>,1
+distr,r,-1,26,0,class<`function`>,1
+distr,r,0,26,0,class<`Gammad`>,1
+distr,r,-1,27,0,double[],1
+distr,r,0,27,0,double,1
+distr,r,-1,28,0,class<`function`>,1
+distr,r,0,28,0,class<`DExp`>,1
+distr,r,-1,29,0,class<`function`>,1
+distr,r,0,29,0,class<`Geom`>,1
+distr,r,-1,30,0,class<`function`>,1
+distr,r,0,30,0,class<`Lnorm`>,1
+distr,r,-1,31,0,class<`function`>,1
+distr,r,0,31,0,class<`UnivarLebDecDistribution`>,1
+distr,r,-1,32,0,double,1
+distr,r,0,32,0,double,1
+distr,r,-1,33,0,class<`function`>,1
+distr,r,0,33,0,class<`Binom`>,1
+distr,r,-1,34,0,class<`function`>,1
+distr,r,0,34,0,class<`Hyper`>,1
+distr,r,-1,35,0,class<`function`>,1
+distr,r,0,35,0,class<`LatticeDistribution`>,1
+distr,r,-1,36,0,integer,1
+distr,r,0,36,0,double,1
+distr,r,-1,37,0,class<`function`>,1
+distr,r,0,37,0,class<`AbscontDistribution`>,1
+distr,r,0,37,1,class<`AffLinAbscontDistribution`>,1
+distr,r,0,37,2,class<`Beta`>,1
+distr,r,0,37,3,class<`Binom`>,1
+distr,r,0,37,4,class<`Cauchy`>,1
+distr,r,0,37,5,class<`Chisq`>,1
+distr,r,0,37,6,class<`DExp`>,1
+distr,r,0,37,7,class<`Dirac`>,1
+distr,r,0,37,8,class<`Exp`>,1
+distr,r,0,37,9,class<`Fd`>,1
+distr,r,0,37,10,class<`Gammad`>,1
+distr,r,0,37,11,class<`Geom`>,1
+distr,r,0,37,12,class<`Hyper`>,1
+distr,r,0,37,13,class<`Lnorm`>,1
+distr,r,0,37,14,class<`Logis`>,1
+distr,r,0,37,15,class<`Nbinom`>,1
+distr,r,0,37,16,class<`Norm`>,1
+distr,r,0,37,17,class<`Pois`>,1
+distr,r,0,37,18,class<`Td`>,1
+distr,r,0,37,19,class<`Unif`>,1
+distr,r,0,37,20,class<`Weibull`>,1
+distr,r,0,37,21,class<`Arcsine`>,1
+distr,r,0,37,22,class<`DiscreteDistribution`>,1
+distr,r,0,37,23,class<`LatticeDistribution`>,1
+distr,r,0,37,24,class<`UnivarLebDecDistribution`>,1
+distr,r,-1,38,0,integer,1
+distr,r,0,38,0,double,1
+distr,r,-1,39,0,double,1
+distr,r,0,39,0,double,1
+distr,r,-1,40,0,double,1
+distr,r,0,40,0,double,1
+distr,r,-1,41,0,integer,1
+distr,r,0,41,0,double,1
+distr,r,-1,42,0,double[],1
+distr,r,0,42,0,double,1
+distr,r,-1,43,0,class<`function`>,1
+distr,r,0,43,0,class<`Weibull`>,1
+distr,r,-1,44,0,double,1
+distr,r,0,44,0,double,1
+distr,r,-1,45,0,double[],1
+distr,r,0,45,0,double,1
+distr,r,1,45,0,...,1
+distr,r,-1,46,0,double,1
+distr,r,0,46,0,double,1
+distr,r,-1,47,0,double[],1
+distr,r,0,47,0,double,1
+distr,r,-1,48,0,double,1
+distr,r,0,48,0,double,1
+distr,r,-1,49,0,class<`function`>,1
+distr,r,0,49,0,class<`AffLinAbscontDistribution`>,1
+distr,r,-1,50,0,integer,1
+distr,r,0,50,0,double,1
+distr,r,-1,51,0,double[],1
+distr,r,0,51,0,double,1
+distr,r,-1,52,0,class<`function`>,1
+distr,r,0,52,0,class<`Dirac`>,1
+distr,r,-1,53,0,double,1
+distr,r,0,53,0,double,1
+distr,r,-1,54,0,class<`function`>,1
+distr,r,0,54,0,class<`Arcsine`>,1
+distr,r,-1,55,0,double[],1
+distr,r,0,55,0,double,1
+distr,rate,-1,0,0,double,1
+distr,rate,0,0,0,class<`DExp`>,1
+distr,rate,-1,1,0,double,1
+distr,rate,0,1,0,class<`ExpParameter`>,1
+distr,rate,-1,2,0,double,1
+distr,rate,0,2,0,class<`Exp`>,1
+distr,rate,-1,3,0,double,1
+distr,rate,0,3,0,class<`DExp`>,1
+distr,rate,0,3,1,class<`Exp`>,1
+distr,rate,0,3,2,class<`ExpParameter`>,1
+distr,rate<-,-1,0,0,class<`Exp`>,1
+distr,rate<-,0,0,0,class<`Exp`>,1
+distr,rate<-,1,0,0,double,1
+distr,rate<-,-1,1,0,class<`DExp`>,1
+distr,rate<-,0,1,0,class<`DExp`>,1
+distr,rate<-,1,1,0,double,1
+distr,rate<-,-1,2,0,class<`ExpParameter`>,1
+distr,rate<-,0,2,0,class<`ExpParameter`>,1
+distr,rate<-,1,2,0,double,1
+distr,rate<-,-1,3,0,class<`DExp`>,1
+distr,rate<-,-1,3,1,class<`Exp`>,1
+distr,rate<-,-1,3,2,class<`ExpParameter`>,1
+distr,rate<-,0,3,0,class<`DExp`>,1
+distr,rate<-,0,3,1,class<`Exp`>,1
+distr,rate<-,0,3,2,class<`ExpParameter`>,1
+distr,rate<-,1,3,0,double,1
+distr,Reals,-1,0,0,class<`Reals`>,1
+distr,.rmixfun,-1,0,0,class<`function`>,1
+distr,.rmixfun,0,0,0,any,1
+distr,.rmixfun,1,0,0,double[],1
+distr,RtoDPQ,-1,0,0,list<class<`function`>>,1
+distr,RtoDPQ,0,0,0,any,1
+distr,RtoDPQ,1,0,0,any,1
+distr,RtoDPQ,2,0,0,double,1
+distr,RtoDPQ,3,0,0,double[],1
+distr,RtoDPQ,3,0,1,null,1
+distr,RtoDPQ.d,-1,0,0,list<class<`function`>>,1
+distr,RtoDPQ.d,0,0,0,class<`function`>,1
+distr,RtoDPQ.d,1,0,0,double,1
+distr,RtoDPQ.LC,-1,0,0,class<`UnivarLebDecDistribution`>,1
+distr,RtoDPQ.LC,0,0,0,class<`function`>,1
+distr,RtoDPQ.LC,1,0,0,double,1
+distr,RtoDPQ.LC,2,0,0,double,1
+distr,RtoDPQ.LC,3,0,0,null,1
+distr,scale,-1,0,0,double,1
+distr,scale,0,0,0,class<`GammaParameter`>,1
+distr,scale,1,0,0,logical,1
+distr,scale,2,0,0,logical,1
+distr,scale,-1,1,0,double,1
+distr,scale,0,1,0,class<`CauchyParameter`>,1
+distr,scale,1,1,0,logical,1
+distr,scale,2,1,0,logical,1
+distr,scale,-1,2,0,double,1
+distr,scale,0,2,0,class<`Chisq`>,1
+distr,scale,1,2,0,logical,1
+distr,scale,2,2,0,logical,1
+distr,scale,-1,3,0,double,1
+distr,scale,0,3,0,class<`Logis`>,1
+distr,scale,1,3,0,logical,1
+distr,scale,2,3,0,logical,1
+distr,scale,-1,4,0,double,1
+distr,scale,0,4,0,class<`Weibull`>,1
+distr,scale,1,4,0,logical,1
+distr,scale,2,4,0,logical,1
+distr,scale,-1,5,0,double,1
+distr,scale,0,5,0,class<`Cauchy`>,1
+distr,scale,1,5,0,logical,1
+distr,scale,2,5,0,logical,1
+distr,scale,-1,6,0,double,1
+distr,scale,0,6,0,class<`LogisParameter`>,1
+distr,scale,1,6,0,logical,1
+distr,scale,2,6,0,logical,1
+distr,scale,-1,7,0,double,1
+distr,scale,0,7,0,class<`Gammad`>,1
+distr,scale,1,7,0,logical,1
+distr,scale,2,7,0,logical,1
+distr,scale,-1,8,0,double,1
+distr,scale,0,8,0,class<`WeibullParameter`>,1
+distr,scale,1,8,0,logical,1
+distr,scale,2,8,0,logical,1
+distr,scale<-,-1,0,0,class<`Gammad`>,1
+distr,scale<-,-1,0,1,class<`LogisParameter`>,1
+distr,scale<-,0,0,0,class<`Gammad`>,1
+distr,scale<-,0,0,1,class<`LogisParameter`>,1
+distr,scale<-,1,0,0,double,1
+distr,scale<-,-1,1,0,class<`Gammad`>,1
+distr,scale<-,0,1,0,class<`Gammad`>,1
+distr,scale<-,1,1,0,double,1
+distr,scale<-,-1,2,0,class<`LogisParameter`>,1
+distr,scale<-,0,2,0,class<`LogisParameter`>,1
+distr,scale<-,1,2,0,double,1
+distr,sd,-1,0,0,double,1
+distr,sd,0,0,0,class<`Norm`>,1
+distr,sd,0,0,1,class<`NormParameter`>,1
+distr,sd,0,0,2,class<`UniNormParameter`>,1
+distr,sd,0,0,3,double[],1
+distr,sd,1,0,0,...,1
+distr,sd,-1,1,0,double,1
+distr,sd,0,1,0,double[],1
+distr,sd,1,1,0,...,1
+distr,sd,-1,2,0,double,1
+distr,sd,0,2,0,class<`Norm`>,1
+distr,sd,1,2,0,...,1
+distr,sd,-1,3,0,double,1
+distr,sd,0,3,0,class<`NormParameter`>,1
+distr,sd,1,3,0,...,1
+distr,sd,-1,4,0,double,1
+distr,sd,0,4,0,class<`UniNormParameter`>,1
+distr,sd,1,4,0,...,1
+distr,sd<-,-1,0,0,class<`UniNormParameter`>,1
+distr,sd<-,0,0,0,class<`UniNormParameter`>,1
+distr,sd<-,1,0,0,double,1
+distr,sd<-,-1,1,0,class<`Norm`>,1
+distr,sd<-,-1,1,1,class<`NormParameter`>,1
+distr,sd<-,-1,1,2,class<`UniNormParameter`>,1
+distr,sd<-,0,1,0,class<`Norm`>,1
+distr,sd<-,0,1,1,class<`NormParameter`>,1
+distr,sd<-,0,1,2,class<`UniNormParameter`>,1
+distr,sd<-,1,1,0,double,1
+distr,sd<-,-1,2,0,class<`NormParameter`>,1
+distr,sd<-,0,2,0,class<`NormParameter`>,1
+distr,sd<-,1,2,0,double,1
+distr,sd<-,-1,3,0,class<`Norm`>,1
+distr,sd<-,0,3,0,class<`Norm`>,1
+distr,sd<-,1,3,0,double,1
+distr,sdlog,-1,0,0,double,1
+distr,sdlog,0,0,0,class<`Lnorm`>,1
+distr,sdlog,-1,1,0,double,1
+distr,sdlog,0,1,0,class<`LnormParameter`>,1
+distr,sdlog,-1,2,0,double,1
+distr,sdlog,0,2,0,class<`Lnorm`>,1
+distr,sdlog,0,2,1,class<`LnormParameter`>,1
+distr,.setEqual,-1,0,0,double[],1
+distr,.setEqual,0,0,0,double[],1
+distr,.setEqual,1,0,0,double[],1
+distr,.setEqual,2,0,0,double,1
+distr,setgaps,-1,0,0,null,1
+distr,setgaps,0,0,0,class<`Chisq`>,1
+distr,setgaps,1,0,0,...,1
+distr,setgaps,-1,1,0,null,1
+distr,setgaps,0,1,0,class<`AbscontDistribution`>,1
+distr,setgaps,0,1,1,class<`Chisq`>,1
+distr,setgaps,1,1,0,...,1
+distr,setgaps,-1,2,0,null,1
+distr,setgaps,0,2,0,class<`AbscontDistribution`>,1
+distr,setgaps,1,2,0,...,1
+distr,shape,-1,0,0,double,1
+distr,shape,0,0,0,class<`Chisq`>,1
+distr,shape,0,0,1,class<`Gammad`>,1
+distr,shape,0,0,2,class<`GammaParameter`>,1
+distr,shape,0,0,3,class<`Weibull`>,1
+distr,shape,0,0,4,class<`WeibullParameter`>,1
+distr,shape,-1,1,0,double,1
+distr,shape,0,1,0,class<`Gammad`>,1
+distr,shape,-1,2,0,double,1
+distr,shape,0,2,0,class<`WeibullParameter`>,1
+distr,shape,-1,3,0,double,1
+distr,shape,0,3,0,class<`GammaParameter`>,1
+distr,shape,-1,4,0,double,1
+distr,shape,0,4,0,class<`Chisq`>,1
+distr,shape,-1,5,0,double,1
+distr,shape,0,5,0,class<`Weibull`>,1
+distr,shape<-,-1,0,0,class<`Weibull`>,1
+distr,shape<-,0,0,0,class<`Weibull`>,1
+distr,shape<-,1,0,0,double,1
+distr,shape<-,-1,1,0,class<`GammaParameter`>,1
+distr,shape<-,-1,1,1,class<`Weibull`>,1
+distr,shape<-,-1,1,2,class<`WeibullParameter`>,1
+distr,shape<-,0,1,0,class<`GammaParameter`>,1
+distr,shape<-,0,1,1,class<`Weibull`>,1
+distr,shape<-,0,1,2,class<`WeibullParameter`>,1
+distr,shape<-,1,1,0,double,1
+distr,shape<-,-1,2,0,class<`WeibullParameter`>,1
+distr,shape<-,0,2,0,class<`WeibullParameter`>,1
+distr,shape<-,1,2,0,double,1
+distr,shape<-,-1,3,0,class<`GammaParameter`>,1
+distr,shape<-,0,3,0,class<`GammaParameter`>,1
+distr,shape<-,1,3,0,double,1
+distr,shape1,-1,0,0,double,1
+distr,shape1,0,0,0,class<`BetaParameter`>,1
+distr,shape1,-1,1,0,double,1
+distr,shape1,0,1,0,class<`Beta`>,1
+distr,shape1,-1,2,0,double,1
+distr,shape1,0,2,0,class<`Beta`>,1
+distr,shape1,0,2,1,class<`BetaParameter`>,1
+distr,shape1<-,-1,0,0,class<`Beta`>,1
+distr,shape1<-,0,0,0,class<`Beta`>,1
+distr,shape1<-,1,0,0,double,1
+distr,shape1<-,-1,1,0,class<`Beta`>,1
+distr,shape1<-,0,1,0,class<`Beta`>,1
+distr,shape1<-,1,1,0,double,1
+distr,shape2,-1,0,0,double,1
+distr,shape2,0,0,0,class<`Beta`>,1
+distr,shape2,0,0,1,class<`BetaParameter`>,1
+distr,shape2,-1,1,0,double,1
+distr,shape2,0,1,0,class<`BetaParameter`>,1
+distr,shape2,-1,2,0,double,1
+distr,shape2,0,2,0,class<`Beta`>,1
+distr,shape2<-,-1,0,0,class<`BetaParameter`>,1
+distr,shape2<-,0,0,0,class<`BetaParameter`>,1
+distr,shape2<-,1,0,0,double,1
+distr,shape2<-,-1,1,0,class<`BetaParameter`>,1
+distr,shape2<-,0,1,0,class<`BetaParameter`>,1
+distr,shape2<-,1,1,0,double,1
+distr,simplifyD,-1,0,0,class<`AbscontDistribution`>,1
+distr,simplifyD,-1,0,1,class<`UnivarLebDecDistribution`>,1
+distr,simplifyD,0,0,0,class<`CompoundDistribution`>,1
+distr,simplifyD,-1,1,0,class<`AbscontDistribution`>,1
+distr,simplifyD,-1,1,1,class<`UnivarLebDecDistribution`>,1
+distr,simplifyD,0,1,0,class<`CompoundDistribution`>,1
+distr,simplifyD,0,1,1,class<`UnivarLebDecDistribution`>,1
+distr,simplifyD,0,1,2,class<`UnivarMixingDistribution`>,1
+distr,simplifyD,-1,2,0,class<`AbscontDistribution`>,1
+distr,simplifyD,-1,2,1,class<`UnivarLebDecDistribution`>,1
+distr,simplifyD,0,2,0,class<`UnivarLebDecDistribution`>,1
+distr,simplifyD,-1,3,0,class<`UnivarLebDecDistribution`>,1
+distr,simplifyD,0,3,0,class<`UnivarMixingDistribution`>,1
+distr,simplifyr,-1,0,0,class<`function`>,1
+distr,simplifyr,0,0,0,class<`AffLinAbscontDistribution`>,1
+distr,simplifyr,1,0,0,double,1
+distr,simplifyr,-1,1,0,class<`function`>,1
+distr,simplifyr,0,1,0,class<`AffLinAbscontDistribution`>,1
+distr,simplifyr,1,1,0,double,1
+distr,.SingleDiscrete,-1,0,0,double[],1
+distr,.SingleDiscrete,0,0,0,double[],1
+distr,.SingleDiscrete,1,0,0,class<`Chisq`>,1
+distr,.SingleDiscrete,1,0,1,class<`Norm`>,1
+distr,size,-1,0,0,double,1
+distr,size,0,0,0,class<`NbinomParameter`>,1
+distr,size,-1,1,0,double,1
+distr,size,0,1,0,class<`Geom`>,1
+distr,size,-1,2,0,double,1
+distr,size,0,2,0,class<`BinomParameter`>,1
+distr,size,-1,3,0,double,1
+distr,size,0,3,0,class<`Binom`>,1
+distr,size,-1,4,0,double,1
+distr,size,0,4,0,class<`Binom`>,1
+distr,size,0,4,1,class<`BinomParameter`>,1
+distr,size,0,4,2,class<`Geom`>,1
+distr,size,0,4,3,class<`Nbinom`>,1
+distr,size,0,4,4,class<`NbinomParameter`>,1
+distr,size,-1,5,0,double,1
+distr,size,0,5,0,class<`Nbinom`>,1
+distr,size<-,-1,0,0,class<`BinomParameter`>,1
+distr,size<-,0,0,0,class<`BinomParameter`>,1
+distr,size<-,1,0,0,double,1
+distr,size<-,-1,1,0,class<`Binom`>,1
+distr,size<-,-1,1,1,class<`BinomParameter`>,1
+distr,size<-,-1,1,2,class<`Nbinom`>,1
+distr,size<-,-1,1,3,class<`NbinomParameter`>,1
+distr,size<-,0,1,0,class<`Binom`>,1
+distr,size<-,0,1,1,class<`BinomParameter`>,1
+distr,size<-,0,1,2,class<`Nbinom`>,1
+distr,size<-,0,1,3,class<`NbinomParameter`>,1
+distr,size<-,1,1,0,double,1
+distr,size<-,-1,2,0,class<`Binom`>,1
+distr,size<-,0,2,0,class<`Binom`>,1
+distr,size<-,1,2,0,double,1
+distr,size<-,-1,3,0,class<`NbinomParameter`>,1
+distr,size<-,0,3,0,class<`NbinomParameter`>,1
+distr,size<-,1,3,0,double,1
+distr,size<-,-1,4,0,class<`Nbinom`>,1
+distr,size<-,0,4,0,class<`Nbinom`>,1
+distr,size<-,1,4,0,double,1
+distr,SphericalSymmetry,-1,0,0,class<`SphericalSymmetry`>,1
+distr,SphericalSymmetry,0,0,0,double,1
+distr,standardMethods,-1,0,0,null,1
+distr,standardMethods,0,0,0,character,1
+distr,standardMethods,1,0,0,logical,1
+distr,standardMethods,2,0,0,any,1
+distr,support,-1,0,0,double[],1
+distr,support,0,0,0,class<`Pois`>,1
+distr,support,-1,1,0,class<`Integer`>,1
+distr,support,-1,1,1,double[],1
+distr,support,0,1,0,class<`UnivarLebDecDistribution`>,1
+distr,support,-1,2,0,any,1
+distr,support,0,2,0,class<`Dirac`>,1
+distr,support,0,2,1,class<`UnivarLebDecDistribution`>,1
+distr,support,0,2,2,class<`AffLinDiscreteDistribution`>,1
+distr,support,0,2,3,class<`AffLinLatticeDistribution`>,1
+distr,support,0,2,4,class<`AffLinUnivarLebDecDistribution`>,1
+distr,support,0,2,5,class<`DiscreteDistribution`>,1
+distr,support,0,2,6,class<`LatticeDistribution`>,1
+distr,support,0,2,7,class<`Nbinom`>,1
+distr,support,0,2,8,class<`Pois`>,1
+distr,support,0,2,9,class<`UnivarMixingDistribution`>,1
+distr,support,0,2,10,class<`Binom`>,1
+distr,support,0,2,11,class<`Geom`>,1
+distr,support,0,2,12,class<`AbscontDistribution`>,1
+distr,support,0,2,13,class<`AffLinAbscontDistribution`>,1
+distr,support,0,2,14,class<`Chisq`>,1
+distr,support,0,2,15,class<`DExp`>,1
+distr,support,0,2,16,class<`Norm`>,1
+distr,support,0,2,17,class<`Unif`>,1
+distr,support,-1,3,0,double[],1
+distr,support,0,3,0,class<`UnivarMixingDistribution`>,1
+distr,support,-1,4,0,double[],1
+distr,support,0,4,0,class<`LatticeDistribution`>,1
+distr,support,-1,5,0,integer[],1
+distr,support,0,5,0,class<`Geom`>,1
+distr,support,-1,6,0,double[],1
+distr,support,0,6,0,class<`AffLinLatticeDistribution`>,1
+distr,support,-1,7,0,double[],1
+distr,support,0,7,0,class<`DiscreteDistribution`>,1
+distr,support,-1,8,0,class<`Integer`>,1
+distr,support,-1,8,1,double,1
+distr,support,0,8,0,class<`Dirac`>,1
+distr,support,-1,9,0,double[],1
+distr,support,0,9,0,class<`Nbinom`>,1
+distr,support,-1,10,0,double[],1
+distr,support,0,10,0,class<`AffLinDiscreteDistribution`>,1
+distr,support,-1,11,0,integer[],1
+distr,support,0,11,0,class<`Binom`>,1
+distr,support,-1,12,0,double[],1
+distr,support,0,12,0,class<`AffLinUnivarLebDecDistribution`>,1
+distr,SymmCenter,-1,0,0,double,1
+distr,SymmCenter,0,0,0,class<`SphericalSymmetry`>,1
+distr,SymmCenter,-1,1,0,double,1
+distr,SymmCenter,0,1,0,class<`SphericalSymmetry`>,1
+distr,Symmetry,-1,0,0,class<`NoSymmetry`>,1
+distr,Symmetry,0,0,0,class<`Binom`>,1
+distr,Symmetry,-1,1,0,class<`SphericalSymmetry`>,1
+distr,Symmetry,0,1,0,class<`Norm`>,1
+distr,Symmetry,-1,2,0,class<`NoSymmetry`>,1
+distr,Symmetry,-1,2,1,class<`SphericalSymmetry`>,1
+distr,Symmetry,0,2,0,class<`Binom`>,1
+distr,Symmetry,0,2,1,class<`Norm`>,1
+distr,Td,-1,0,0,class<`Td`>,1
+distr,Td,0,0,0,double,1
+distr,Td,1,0,0,double,1
+distr,Truncate,-1,0,0,class<`LatticeDistribution`>,1
+distr,Truncate,0,0,0,class<`LatticeDistribution`>,1
+distr,Truncate,1,0,0,...,1
+distr,Truncate,-1,1,0,class<`AbscontDistribution`>,1
+distr,Truncate,-1,1,1,class<`LatticeDistribution`>,1
+distr,Truncate,0,1,0,class<`AbscontDistribution`>,1
+distr,Truncate,0,1,1,class<`AffLinAbscontDistribution`>,1
+distr,Truncate,0,1,2,class<`Norm`>,1
+distr,Truncate,0,1,3,class<`Geom`>,1
+distr,Truncate,0,1,4,class<`LatticeDistribution`>,1
+distr,Truncate,1,1,0,...,1
+distr,Truncate,-1,2,0,class<`LatticeDistribution`>,1
+distr,Truncate,0,2,0,class<`Geom`>,1
+distr,Truncate,1,2,0,...,1
+distr,Truncate,-1,3,0,class<`AbscontDistribution`>,1
+distr,Truncate,0,3,0,class<`AbscontDistribution`>,1
+distr,Truncate,1,3,0,...,1
+distr,Truncate,-1,4,0,class<`AbscontDistribution`>,1
+distr,Truncate,0,4,0,class<`AffLinAbscontDistribution`>,1
+distr,Truncate,1,4,0,...,1
+distr,Truncate,-1,5,0,class<`AbscontDistribution`>,1
+distr,Truncate,0,5,0,class<`Norm`>,1
+distr,Truncate,1,5,0,...,1
+distr,.trunc.low,-1,0,0,list<class<`function`>>,1
+distr,.trunc.low,0,0,0,class<`Geom`>,1
+distr,.trunc.low,0,0,1,class<`Norm`>,1
+distr,.trunc.low,1,0,0,double,1
+distr,.trunc.up,-1,0,0,list<class<`function`>>,1
+distr,.trunc.up,0,0,0,class<`AbscontDistribution`>,1
+distr,.trunc.up,0,0,1,class<`Norm`>,1
+distr,.trunc.up,1,0,0,double,1
+distr,.ULC.cast,-1,0,0,class<`AbscontDistribution`>,1
+distr,.ULC.cast,-1,0,1,class<`UnivarLebDecDistribution`>,1
+distr,.ULC.cast,0,0,0,class<`CompoundDistribution`>,1
+distr,.ULC.cast,0,0,1,class<`AbscontDistribution`>,1
+distr,.ULC.cast,0,0,2,class<`Norm`>,1
+distr,.ULC.cast,0,0,3,class<`Pois`>,1
+distr,.ULC.cast,0,0,4,class<`UnivarLebDecDistribution`>,1
+distr,Unif,-1,0,0,class<`Unif`>,1
+distr,Unif,0,0,0,double,1
+distr,Unif,1,0,0,double,1
+distr,UnivarDistrList,-1,0,0,class<`UnivarDistrList`>,1
+distr,UnivarDistrList,0,0,0,...,1
+distr,UnivarDistrList,1,0,0,any,1
+distr,UnivarLebDecDistribution,-1,0,0,class<`UnivarLebDecDistribution`>,1
+distr,UnivarLebDecDistribution,0,0,0,any,1
+distr,UnivarLebDecDistribution,1,0,0,any,1
+distr,UnivarLebDecDistribution,2,0,0,any,1
+distr,UnivarLebDecDistribution,3,0,0,any,1
+distr,UnivarLebDecDistribution,4,0,0,null,1
+distr,UnivarLebDecDistribution,5,0,0,null,1
+distr,UnivarLebDecDistribution,6,0,0,null,1
+distr,UnivarLebDecDistribution,7,0,0,null,1
+distr,UnivarMixingDistribution,-1,0,0,class<`UnivarLebDecDistribution`>,1
+distr,UnivarMixingDistribution,-1,0,1,class<`UnivarMixingDistribution`>,1
+distr,UnivarMixingDistribution,0,0,0,...,1
+distr,UnivarMixingDistribution,1,0,0,any,1
+distr,UnivarMixingDistribution,2,0,0,any,1
+distr,UnivarMixingDistribution,3,0,0,logical,1
+distr,Weibull,-1,0,0,class<`Weibull`>,1
+distr,Weibull,0,0,0,double,1
+distr,Weibull,1,0,0,double,1
+distr,width,-1,0,0,double,1
+distr,width,0,0,0,class<`Lattice`>,1
+distr,width,-1,1,0,double,1
+distr,width,0,1,0,class<`Lattice`>,1
+distr,width<-,-1,0,0,class<`Lattice`>,1
+distr,width<-,0,0,0,class<`Lattice`>,1
+distr,width<-,1,0,0,double,1
+distr,width<-,-1,1,0,class<`Lattice`>,1
+distr,width<-,0,1,0,class<`Lattice`>,1
+distr,width<-,1,1,0,double,1
+doRNG,%||%,-1,0,0,class<`matrix`>,1
+doRNG,%||%,-1,0,1,double,1
+doRNG,%||%,-1,0,2,integer[],1
+doRNG,%||%,-1,0,3,list<double[]>,1
+doRNG,%||%,-1,0,4,list<double | character>,1
+doRNG,%||%,0,0,0,null,1
+doRNG,%||%,0,0,1,double,1
+doRNG,%||%,0,0,2,integer[],1
+doRNG,%||%,0,0,3,list<integer[]>,1
+doRNG,%||%,1,0,0,any,1
+doRNG,checkRNGversion,-1,0,0,double,1
+doRNG,checkRNGversion,0,0,0,character,1
+doRNG,%dorng%,-1,0,0,any,1
+doRNG,%dorng%,0,0,0,class<`foreach`>,1
+doRNG,%dorng%,0,0,1,"class<`filteredforeach`, `foreach`>",1
+doRNG,%dorng%,0,0,2,"class<`foreach`, `xforeach`>",1
+doRNG,%dorng%,1,0,0,any,1
+doRNG,doRNGseq,-1,0,0,list<integer[]>,1
+doRNG,doRNGseq,0,0,0,integer,1
+doRNG,doRNGseq,1,0,0,null,1
+doRNG,doRNGseq,1,0,1,double,1
+doRNG,doRNGseq,1,0,2,class<`matrix`>,1
+doRNG,doRNGseq,1,0,3,integer[],1
+doRNG,doRNGseq,1,0,4,list<double[]>,1
+doRNG,doRNGseq,2,0,0,...,1
+doRNG,doRNGversion,-1,0,0,character,1
+doRNG,doRNGversion,0,0,0,any,1
+doRNG,getDoBackend,-1,0,0,"list<class<`function`> | class<`SOCKcluster`, `cluster`>>",1
+doRNG,getDoBackend,-1,0,1,"list<class<`function`> | list<double | list<class<`function`> | class<`SOCKcluster`, `cluster`>>>>",1
+doRNG,getDoBackend,-1,0,2,"list<class<`function`> | list<null | double | list<class<`function`> | class<`SOCKcluster`, `cluster`>>>>",1
+doRNG,ns_get,-1,0,0,class<`function`>,1
+doRNG,ns_get,-1,0,1,environment,1
+doRNG,ns_get,0,0,0,character,1
+doRNG,ns_get,1,0,0,environment,1
+doRNG,ns_get,2,0,0,...,1
+doRNG,registerDoRNG,-1,0,0,class<`function`>,1
+doRNG,registerDoRNG,0,0,0,double,1
+doRNG,registerDoRNG,0,0,1,null,1
+doRNG,registerDoRNG,1,0,0,logical,1
+doRNG,setDoBackend,-1,0,0,"list<class<`function`> | class<`SOCKcluster`, `cluster`>>",1
+doRNG,setDoBackend,-1,0,1,"list<class<`function`> | list<double | list<class<`function`> | class<`SOCKcluster`, `cluster`>>>>",1
+doRNG,setDoBackend,-1,0,2,"list<class<`function`> | list<null | double | list<class<`function`> | class<`SOCKcluster`, `cluster`>>>>",1
+doRNG,setDoBackend,0,0,0,"list<class<`function`> | list<double | list<class<`function`> | class<`SOCKcluster`, `cluster`>>>>",1
+doRNG,setDoBackend,0,0,1,"list<class<`function`> | list<null | double | list<class<`function`> | class<`SOCKcluster`, `cluster`>>>>",1
+doRNG,setDoBackend,0,0,2,"list<class<`function`> | class<`SOCKcluster`, `cluster`>>",1
+docopt,Argument,-1,0,0,class<`Argument`>,1
+docopt,Argument,0,0,0,...,1
+docopt,docopt,-1,0,0,"class<`docopt`, `list`>",1
+docopt,docopt,0,0,0,character,1
+docopt,docopt,1,0,0,character,1
+docopt,docopt,2,0,0,null,1
+docopt,docopt,3,0,0,logical,1
+docopt,docopt,4,0,0,null,1
+docopt,docopt,5,0,0,logical,1
+docopt,docopt,6,0,0,logical,1
+docopt,docopt,7,0,0,any,1
+docopt,Either,-1,0,0,class<`Either`>,1
+docopt,Either,0,0,0,...,1
+docopt,extract,-1,0,0,list<character[]>,1
+docopt,extract,0,0,0,character,1
+docopt,extract,1,0,0,character,1
+docopt,extras,-1,0,0,null,1
+docopt,extras,0,0,0,logical,1
+docopt,extras,1,0,0,null,1
+docopt,extras,2,0,0,list<class<`Option`>>,1
+docopt,extras,3,0,0,any,1
+docopt,formal_usage,-1,0,0,character,1
+docopt,formal_usage,0,0,0,character,1
+docopt,matched,-1,0,0,list<logical | list<any>>,1
+docopt,matched,-1,0,1,list<logical | list<class<`Option`>>>,1
+docopt,matched,0,0,0,logical,1
+docopt,matched,1,0,0,list<any>,1
+docopt,matched,2,0,0,list<any>,1
+docopt,OneOrMore,-1,0,0,class<`OneOrMore`>,1
+docopt,OneOrMore,0,0,0,...,1
+docopt,Option,-1,0,0,class<`Option`>,1
+docopt,Option,0,0,0,...,1
+docopt,Optional,-1,0,0,class<`Optional`>,1
+docopt,Optional,0,0,0,...,1
+docopt,OptionList,-1,0,0,class<`OptionList`>,1
+docopt,OptionList,0,0,0,...,1
+docopt,parse_args,-1,0,0,list<class<`Option`>>,1
+docopt,parse_args,0,0,0,character,1
+docopt,parse_args,1,0,0,class<`OptionList`>,1
+docopt,parse_atom,-1,0,0,list<class<`Argument`>>,1
+docopt,parse_atom,-1,0,1,list<class<`Optional`>>,1
+docopt,parse_atom,-1,0,2,list<class<`Option`>>,1
+docopt,parse_atom,0,0,0,class<`Tokens`>,1
+docopt,parse_atom,1,0,0,any,1
+docopt,parse_doc_options,-1,0,0,class<`OptionList`>,1
+docopt,parse_doc_options,0,0,0,character,1
+docopt,parse_expr,-1,0,0,list<class<`Either`>>,1
+docopt,parse_expr,-1,0,1,list<class<`OneOrMore`>>,1
+docopt,parse_expr,-1,0,2,list<class<`Optional`>>,1
+docopt,parse_expr,-1,0,3,list<class<`Option`>>,1
+docopt,parse_expr,0,0,0,class<`Tokens`>,1
+docopt,parse_expr,1,0,0,any,1
+docopt,parse_long,-1,0,0,list<class<`Option`>>,1
+docopt,parse_long,0,0,0,class<`Tokens`>,1
+docopt,parse_long,1,0,0,class<`OptionList`>,1
+docopt,parse_option,-1,0,0,class<`Option`>,1
+docopt,parse_option,0,0,0,character,1
+docopt,parse_pattern,-1,0,0,class<`Required`>,1
+docopt,parse_pattern,0,0,0,character,1
+docopt,parse_pattern,1,0,0,class<`OptionList`>,1
+docopt,parse_seq,-1,0,0,list<class<`OneOrMore`>>,1
+docopt,parse_seq,-1,0,1,list<class<`Optional`>>,1
+docopt,parse_seq,-1,0,2,list<class<`Option`>>,1
+docopt,parse_seq,0,0,0,class<`Tokens`>,1
+docopt,parse_seq,1,0,0,any,1
+docopt,parse_shorts,-1,0,0,list<class<`Option`>>,1
+docopt,parse_shorts,0,0,0,class<`Tokens`>,1
+docopt,parse_shorts,1,0,0,class<`OptionList`>,1
+docopt,printable_usage,-1,0,0,character,1
+docopt,printable_usage,0,0,0,character,1
+docopt,printable_usage,1,0,0,any,1
+docopt,Required,-1,0,0,class<`Required`>,1
+docopt,Required,0,0,0,...,1
+docopt,str_c,-1,0,0,character,1
+docopt,str_c,0,0,0,character[],1
+docopt,str_c,1,0,0,...,1
+docopt,str_extract,-1,0,0,character[],1
+docopt,str_extract,0,0,0,character[],1
+docopt,str_extract,1,0,0,character,1
+docopt,str_extract_all,-1,0,0,list<list<character[]>>,1
+docopt,str_extract_all,0,0,0,character,1
+docopt,str_extract_all,1,0,0,character,1
+docopt,str_match,-1,0,0,class<`matrix`>,1
+docopt,str_match,0,0,0,character,1
+docopt,str_match,1,0,0,character,1
+docopt,str_replace,-1,0,0,character,1
+docopt,str_replace,0,0,0,character,1
+docopt,str_replace,1,0,0,character,1
+docopt,str_replace,2,0,0,character,1
+docopt,str_split,-1,0,0,list<character[]>,1
+docopt,str_split,0,0,0,character,1
+docopt,str_split,1,0,0,character,1
+docopt,str_sub,-1,0,0,character[],1
+docopt,str_sub,0,0,0,null,1
+docopt,str_sub,0,0,1,character,1
+docopt,str_sub,1,0,0,double,1
+docopt,str_sub,2,0,0,integer,1
+docopt,str_trim,-1,0,0,character,1
+docopt,str_trim,0,0,0,character,1
+docopt,Tokens,-1,0,0,class<`Tokens`>,1
+docopt,Tokens,0,0,0,...,1
+dplyr,add_computed_columns,-1,0,0,class<`data.frame`>,1
+dplyr,add_computed_columns,-1,0,1,"class<`data.frame`, `grouped_df`, `tbl`, `tbl_df`>",1
+dplyr,add_computed_columns,-1,0,2,"class<`data.frame`, `tbl`, `tbl_df`>",1
+dplyr,add_computed_columns,-1,0,3,class<`tbl_cube`>,1
+dplyr,add_computed_columns,-1,0,4,"class<`tbl`, `tbl_SQLiteConnection`, `tbl_dbi`, `tbl_lazy`, `tbl_sql`>",1
+dplyr,add_computed_columns,0,0,0,class<`data.frame`>,1
+dplyr,add_computed_columns,0,0,1,"class<`data.frame`, `grouped_df`, `tbl`, `tbl_df`>",1
+dplyr,add_computed_columns,0,0,2,"class<`data.frame`, `tbl`, `tbl_df`>",1
+dplyr,add_computed_columns,0,0,3,class<`tbl_cube`>,1
+dplyr,add_computed_columns,0,0,4,"class<`tbl`, `tbl_SQLiteConnection`, `tbl_dbi`, `tbl_lazy`, `tbl_sql`>",1
+dplyr,add_computed_columns,1,0,0,"class<`list`, `quosures`>",1
+dplyr,add_count,-1,0,0,"class<`data.frame`, `tbl`, `tbl_df`>",1
+dplyr,add_count,0,0,0,class<`data.frame`>,1
+dplyr,add_count,0,0,1,"class<`data.frame`, `tbl`, `tbl_df`>",1
+dplyr,add_count,1,0,0,...,1
+dplyr,add_count,2,0,0,null,1
+dplyr,add_count,3,0,0,logical,1
+dplyr,add_count,4,0,0,character,1
+dplyr,add_rownames,-1,0,0,"class<`data.frame`, `tbl`, `tbl_df`>",1
+dplyr,add_rownames,0,0,0,class<`data.frame`>,1
+dplyr,add_rownames,1,0,0,character,1
+dplyr,add_suffixes,-1,0,0,character[],1
+dplyr,add_suffixes,0,0,0,character[],1
+dplyr,add_suffixes,1,0,0,any,1
+dplyr,add_suffixes,2,0,0,character,1
+dplyr,add_tally,-1,0,0,"class<`data.frame`, `grouped_df`, `tbl`, `tbl_df`>",1
+dplyr,add_tally,-1,0,1,"class<`data.frame`, `tbl`, `tbl_df`>",1
+dplyr,add_tally,0,0,0,"class<`data.frame`, `grouped_df`, `tbl`, `tbl_df`>",1
+dplyr,add_tally,0,0,1,class<`data.frame`>,1
+dplyr,add_tally,1,0,0,any,1
+dplyr,add_tally,2,0,0,logical,1
+dplyr,add_tally,3,0,0,character,1
+dplyr,all_equal,-1,0,0,character,1
+dplyr,all_equal,-1,0,1,logical,1
+dplyr,all_equal,0,0,0,class<`data.frame`>,1
+dplyr,all_equal,1,0,0,class<`data.frame`>,1
+dplyr,all_equal,2,0,0,logical,1
+dplyr,all_equal,3,0,0,logical,1
+dplyr,all_equal,4,0,0,logical,1
+dplyr,all_equal,5,0,0,...,1
+dplyr,all_exprs,-1,0,0,"class<`formula`, `quosure`>",1
+dplyr,all_exprs,0,0,0,...,1
+dplyr,all_exprs,1,0,0,logical,1
+dplyr,all_vars,-1,0,0,"class<`all_vars`, `formula`, `quosure`>",1
+dplyr,all_vars,0,0,0,any,1
+dplyr,anti_join,-1,0,0,"class<`data.frame`, `tbl`, `tbl_df`>",1
+dplyr,anti_join,0,0,0,"class<`data.frame`, `tbl`, `tbl_df`>",1
+dplyr,anti_join,1,0,0,"class<`data.frame`, `tbl`, `tbl_df`>",1
+dplyr,anti_join,2,0,0,null,1
+dplyr,anti_join,2,0,1,character,1
+dplyr,anti_join,3,0,0,logical,1
+dplyr,anti_join,4,0,0,...,1
+dplyr,anti_join_impl,-1,0,0,"class<`data.frame`, `tbl`, `tbl_df`>",1
+dplyr,anti_join_impl,0,0,0,"class<`data.frame`, `tbl`, `tbl_df`>",1
+dplyr,anti_join_impl,1,0,0,"class<`data.frame`, `tbl`, `tbl_df`>",1
+dplyr,anti_join_impl,2,0,0,character,1
+dplyr,anti_join_impl,3,0,0,character,1
+dplyr,anti_join_impl,4,0,0,logical,1
+dplyr,anti_join_impl,5,0,0,environment,1
+dplyr,anti_join.tbl_df,-1,0,0,"class<`data.frame`, `tbl`, `tbl_df`>",1
+dplyr,anti_join.tbl_df,0,0,0,"class<`data.frame`, `tbl`, `tbl_df`>",1
+dplyr,anti_join.tbl_df,1,0,0,"class<`data.frame`, `tbl`, `tbl_df`>",1
+dplyr,anti_join.tbl_df,2,0,0,null,1
+dplyr,anti_join.tbl_df,2,0,1,character,1
+dplyr,anti_join.tbl_df,3,0,0,logical,1
+dplyr,anti_join.tbl_df,4,0,0,...,1
+dplyr,anti_join.tbl_df,5,0,0,null,1
+dplyr,any_apply,-1,0,0,logical,1
+dplyr,any_apply,0,0,0,list<character[]>,1
+dplyr,any_apply,0,0,1,"list<class<`factor`, `ordered`>>",1
+dplyr,any_apply,0,0,2,list<class<`array`>>,1
+dplyr,any_apply,1,0,0,class<`function`>,1
+dplyr,any_vars,-1,0,0,"class<`any_vars`, `formula`, `quosure`>",1
+dplyr,any_vars,0,0,0,any,1
+dplyr,append_pos,-1,0,0,character[],1
+dplyr,append_pos,0,0,0,character[],1
+dplyr,append_pos,1,0,0,logical[],1
+dplyr,apply_filter_syms,-1,0,0,"class<`formula`, `quosure`>",1
+dplyr,apply_filter_syms,0,0,0,"class<`all_vars`, `formula`, `quosure`>",1
+dplyr,apply_filter_syms,0,0,1,"class<`any_vars`, `formula`, `quosure`>",1
+dplyr,apply_filter_syms,0,0,2,class<`formula`>,1
+dplyr,apply_filter_syms,1,0,0,list<class<`name`>>,1
+dplyr,apply_filter_syms,2,0,0,any,1
+dplyr,arrange,-1,0,0,class<`data.frame`>,1
+dplyr,arrange,-1,0,1,"class<`data.frame`, `grouped_df`, `tbl`, `tbl_df`>",1
+dplyr,arrange,-1,0,2,"class<`data.frame`, `tbl`, `tbl_df`>",1
+dplyr,arrange,-1,0,3,"class<`tbl`, `tbl_SQLiteConnection`, `tbl_dbi`, `tbl_lazy`, `tbl_sql`>",1
+dplyr,arrange,0,0,0,class<`data.frame`>,1
+dplyr,arrange,0,0,1,"class<`data.frame`, `grouped_df`, `tbl`, `tbl_df`>",1
+dplyr,arrange,0,0,2,"class<`data.frame`, `tbl`, `tbl_df`>",1
+dplyr,arrange,0,0,3,"class<`tbl`, `tbl_SQLiteConnection`, `tbl_dbi`, `tbl_lazy`, `tbl_sql`>",1
+dplyr,arrange,1,0,0,...,1
+dplyr,arrange_all,-1,0,0,"class<`data.frame`, `tbl`, `tbl_df`>",1
+dplyr,arrange_all,0,0,0,"class<`data.frame`, `tbl`, `tbl_df`>",1
+dplyr,arrange_all,1,0,0,class<`function`>,1
+dplyr,arrange_all,1,0,1,list<any>,1
+dplyr,arrange_all,2,0,0,...,1
+dplyr,arrange_all,3,0,0,logical,1
+dplyr,arrange.data.frame,-1,0,0,class<`data.frame`>,1
+dplyr,arrange.data.frame,0,0,0,class<`data.frame`>,1
+dplyr,arrange.data.frame,1,0,0,...,1
+dplyr,arrange.data.frame,2,0,0,logical,1
+dplyr,arrange.grouped_df,-1,0,0,"class<`data.frame`, `grouped_df`, `tbl`, `tbl_df`>",1
+dplyr,arrange.grouped_df,0,0,0,"class<`data.frame`, `grouped_df`, `tbl`, `tbl_df`>",1
+dplyr,arrange.grouped_df,1,0,0,...,1
+dplyr,arrange.grouped_df,2,0,0,logical,1
+dplyr,arrange_impl,-1,0,0,"class<`data.frame`, `grouped_df`, `tbl`, `tbl_df`>",1
+dplyr,arrange_impl,-1,0,1,"class<`data.frame`, `tbl`, `tbl_df`>",1
+dplyr,arrange_impl,0,0,0,"class<`data.frame`, `grouped_df`, `tbl`, `tbl_df`>",1
+dplyr,arrange_impl,0,0,1,"class<`data.frame`, `tbl`, `tbl_df`>",1
+dplyr,arrange_impl,1,0,0,"class<`list`, `quosures`>",1
+dplyr,arrange_impl,2,0,0,environment,1
+dplyr,arrange.tbl_df,-1,0,0,"class<`data.frame`, `tbl`, `tbl_df`>",1
+dplyr,arrange.tbl_df,0,0,0,"class<`data.frame`, `tbl`, `tbl_df`>",1
+dplyr,arrange.tbl_df,1,0,0,...,1
+dplyr,arrange.tbl_df,2,0,0,any,1
+dplyr,as.data.frame.tbl_cube,-1,0,0,class<`data.frame`>,1
+dplyr,as.data.frame.tbl_cube,0,0,0,class<`tbl_cube`>,1
+dplyr,as.data.frame.tbl_cube,1,0,0,...,1
+dplyr,as_fun,-1,0,0,"class<`formula`, `quosure`>",1
+dplyr,as_fun,0,0,0,"class<`formula`, `quosure`>",1
+dplyr,as_fun,1,0,0,any,1
+dplyr,as_fun,2,0,0,list<any>,1
+dplyr,as_fun_list,-1,0,0,list<any>,1
+dplyr,as_fun_list,0,0,0,list<any>,1
+dplyr,as_fun_list,0,0,1,class<`function`>,1
+dplyr,as_fun_list,0,0,2,character,1
+dplyr,as_fun_list,0,0,3,class<`formula`>,1
+dplyr,as_fun_list,1,0,0,any,1
+dplyr,as_fun_list,2,0,0,...,1
+dplyr,as_group_map_function,-1,0,0,class<`function`>,1
+dplyr,as_group_map_function,-1,0,1,"class<`function`, `rlang_lambda_function`>",1
+dplyr,as_group_map_function,0,0,0,class<`function`>,1
+dplyr,as_group_map_function,0,0,1,class<`formula`>,1
+dplyr,as_inlined_function,-1,0,0,class<`inline_colwise_function`>,1
+dplyr,as_inlined_function,0,0,0,class<`formula`>,1
+dplyr,as_inlined_function,1,0,0,any,1
+dplyr,as_inlined_function,2,0,0,...,1
+dplyr,assert_all_allow_list,-1,0,0,null,1
+dplyr,assert_all_allow_list,0,0,0,class<`data.frame`>,1
+dplyr,assert_all_allow_list,0,0,1,"class<`data.frame`, `tbl`, `tbl_df`>",1
+dplyr,as.tbl,-1,0,0,"class<`data.frame`, `tbl`, `tbl_df`>",1
+dplyr,as.tbl,0,0,0,class<`data.frame`>,1
+dplyr,as.tbl,1,0,0,...,1
+dplyr,as.tbl_cube,-1,0,0,class<`tbl_cube`>,1
+dplyr,as.tbl_cube,0,0,0,class<`data.frame`>,1
+dplyr,as.tbl_cube,0,0,1,class<`table`>,1
+dplyr,as.tbl_cube,1,0,0,...,1
+dplyr,as.tbl_cube.array,-1,0,0,class<`tbl_cube`>,1
+dplyr,as.tbl_cube.array,0,0,0,class<`array`>,1
+dplyr,as.tbl_cube.array,1,0,0,any,1
+dplyr,as.tbl_cube.array,2,0,0,character,1
+dplyr,as.tbl_cube.array,3,0,0,...,1
+dplyr,as.tbl_cube.data.frame,-1,0,0,class<`tbl_cube`>,1
+dplyr,as.tbl_cube.data.frame,0,0,0,class<`data.frame`>,1
+dplyr,as.tbl_cube.data.frame,1,0,0,integer[],1
+dplyr,as.tbl_cube.data.frame,2,0,0,any,1
+dplyr,as.tbl_cube.data.frame,3,0,0,...,1
+dplyr,as.tbl_cube.table,-1,0,0,class<`tbl_cube`>,1
+dplyr,as.tbl_cube.table,0,0,0,class<`table`>,1
+dplyr,as.tbl_cube.table,1,0,0,any,1
+dplyr,as.tbl_cube.table,2,0,0,character,1
+dplyr,as.tbl_cube.table,3,0,0,...,1
+dplyr,as.tbl.data.frame,-1,0,0,"class<`data.frame`, `tbl`, `tbl_df`>",1
+dplyr,as.tbl.data.frame,0,0,0,class<`data.frame`>,1
+dplyr,as.tbl.data.frame,1,0,0,...,1
+dplyr,auto_by_msg,-1,0,0,character,1
+dplyr,auto_by_msg,0,0,0,character[],1
+dplyr,auto_copy,-1,0,0,class<`data.frame`>,1
+dplyr,auto_copy,-1,0,1,"class<`data.frame`, `tbl`, `tbl_df`>",1
+dplyr,auto_copy,-1,0,2,"class<`tbl`, `tbl_SQLiteConnection`, `tbl_dbi`, `tbl_lazy`, `tbl_sql`>",1
+dplyr,auto_copy,0,0,0,"class<`data.frame`, `tbl`, `tbl_df`>",1
+dplyr,auto_copy,0,0,1,"class<`tbl`, `tbl_SQLiteConnection`, `tbl_dbi`, `tbl_lazy`, `tbl_sql`>",1
+dplyr,auto_copy,1,0,0,class<`data.frame`>,1
+dplyr,auto_copy,1,0,1,"class<`data.frame`, `tbl`, `tbl_df`>",1
+dplyr,auto_copy,1,0,2,"class<`tbl`, `tbl_SQLiteConnection`, `tbl_dbi`, `tbl_lazy`, `tbl_sql`>",1
+dplyr,auto_copy,2,0,0,any,1
+dplyr,auto_copy,3,0,0,...,1
+dplyr,auto_name_formulas,-1,0,0,list<class<`function`>>,1
+dplyr,auto_name_formulas,-1,0,1,list<class<`formula`>>,1
+dplyr,auto_name_formulas,0,0,0,list<class<`function`>>,1
+dplyr,auto_name_formulas,0,0,1,list<class<`formula`>>,1
+dplyr,between,-1,0,0,logical[],1
+dplyr,between,0,0,0,double[],1
+dplyr,between,1,0,0,double,1
+dplyr,between,2,0,0,double,1
+dplyr,big_mark,-1,0,0,character[],1
+dplyr,big_mark,0,0,0,integer[],1
+dplyr,big_mark,1,0,0,...,1
+dplyr,bind_cols,-1,0,0,"class<`data.frame`, `tbl`, `tbl_df`>",1
+dplyr,bind_cols,-1,0,1,class<`data.frame`>,1
+dplyr,bind_cols,0,0,0,...,1
+dplyr,bind_rows,-1,0,0,class<`data.frame`>,1
+dplyr,bind_rows,-1,0,1,"class<`data.frame`, `tbl`, `tbl_df`>",1
+dplyr,bind_rows,0,0,0,...,1
+dplyr,bind_rows,1,0,0,character,1
+dplyr,bind_rows,1,0,1,null,1
+dplyr,bind_rows_,-1,0,0,class<`data.frame`>,1
+dplyr,bind_rows_,-1,0,1,"class<`data.frame`, `tbl`, `tbl_df`>",1
+dplyr,bind_rows_,0,0,0,list<class<`data.frame`>>,1
+dplyr,bind_rows_,0,0,1,"list<class<`data.frame`, `tbl`, `tbl_df`>>",1
+dplyr,bind_rows_,0,0,2,"list<double[] | class<`data.frame`, `tbl`, `tbl_df`>>",1
+dplyr,bind_rows_,0,0,3,list<double[]>,1
+dplyr,bind_rows_,0,0,4,list<list<double[]>>,1
+dplyr,bind_rows_,1,0,0,null,1
+dplyr,bind_rows_,1,0,1,character,1
+dplyr,case_when,-1,0,0,^character[],1
+dplyr,case_when,-1,0,1,^double[],1
+dplyr,case_when,0,0,0,...,1
+dplyr,cbind_all,-1,0,0,class<`data.frame`>,1
+dplyr,cbind_all,-1,0,1,"class<`data.frame`, `tbl`, `tbl_df`>",1
+dplyr,cbind_all,0,0,0,list<class<`data.frame`>>,1
+dplyr,cbind_all,0,0,1,list<list<double[]>>,1
+dplyr,cbind_all,0,0,2,"list<class<`data.frame`, `tbl`, `tbl_df`>>",1
+dplyr,cbind_all,0,0,3,"list<class<`data.frame`, `tbl`, `tbl_df`> | class<`data.frame`>>",1
+dplyr,changes,-1,0,0,class<`matrix`>,1
+dplyr,changes,-1,0,1,null,1
+dplyr,changes,0,0,0,class<`data.frame`>,1
+dplyr,changes,1,0,0,class<`data.frame`>,1
+dplyr,check_class,-1,0,0,null,1
+dplyr,check_class,0,0,0,^character[],1
+dplyr,check_class,0,0,1,class<`factor`>,1
+dplyr,check_class,0,0,2,^double[],1
+dplyr,check_class,0,0,3,null,1
+dplyr,check_class,1,0,0,any,1
+dplyr,check_class,2,0,0,any,1
+dplyr,check_dbplyr,-1,0,0,logical,1
+dplyr,check_dot_cols,-1,0,0,character[],1
+dplyr,check_dot_cols,-1,0,1,"class<`list`, `quosures`>",1
+dplyr,check_dot_cols,0,0,0,character[],1
+dplyr,check_dot_cols,0,0,1,"class<`list`, `quosures`>",1
+dplyr,check_dot_cols,1,0,0,null,1
+dplyr,check_frac,-1,0,0,double,1
+dplyr,check_frac,0,0,0,double,1
+dplyr,check_frac,1,0,0,any,1
+dplyr,check_grouped,-1,0,0,null,1
+dplyr,check_grouped,0,0,0,"class<`data.frame`, `tbl`, `tbl_df`>",1
+dplyr,check_grouped,1,0,0,character,1
+dplyr,check_grouped,2,0,0,character,1
+dplyr,check_grouped,3,0,0,logical,1
+dplyr,check_length,-1,0,0,null,1
+dplyr,check_length,0,0,0,^character[],1
+dplyr,check_length,0,0,1,class<`factor`>,1
+dplyr,check_length,0,0,2,^double[],1
+dplyr,check_length,0,0,3,null,1
+dplyr,check_length,1,0,0,^character[],1
+dplyr,check_length,1,0,1,null,1
+dplyr,check_length,1,0,2,class<`factor`>,1
+dplyr,check_length,1,0,3,^double[],1
+dplyr,check_length,2,0,0,any,1
+dplyr,check_length,3,0,0,any,1
+dplyr,check_length_val,-1,0,0,null,1
+dplyr,check_length_val,0,0,0,integer,1
+dplyr,check_length_val,1,0,0,integer,1
+dplyr,check_length_val,2,0,0,any,1
+dplyr,check_length_val,3,0,0,any,1
+dplyr,check_length_val,4,0,0,any,1
+dplyr,check_na_matches,-1,0,0,logical,1
+dplyr,check_na_matches,0,0,0,null,1
+dplyr,check_pkg,-1,0,0,logical,1
+dplyr,check_pkg,0,0,0,character,1
+dplyr,check_pkg,1,0,0,character,1
+dplyr,check_pkg,2,0,0,logical,1
+dplyr,check_size,-1,0,0,double,1
+dplyr,check_size,0,0,0,double,1
+dplyr,check_size,1,0,0,integer,1
+dplyr,check_size,2,0,0,any,1
+dplyr,check_suffix,-1,0,0,list<character>,1
+dplyr,check_suffix,0,0,0,character[],1
+dplyr,check_type,-1,0,0,null,1
+dplyr,check_type,0,0,0,^character[],1
+dplyr,check_type,0,0,1,class<`factor`>,1
+dplyr,check_type,0,0,2,^double[],1
+dplyr,check_type,0,0,3,null,1
+dplyr,check_type,1,0,0,^character[],1
+dplyr,check_type,1,0,1,null,1
+dplyr,check_type,1,0,2,class<`factor`>,1
+dplyr,check_type,1,0,3,^double[],1
+dplyr,check_type,2,0,0,any,1
+dplyr,check_valid_names,-1,0,0,null,1
+dplyr,check_valid_names,0,0,0,"class<`character`, `dplyr_sel_vars`>",1
+dplyr,check_valid_names,1,0,0,logical,1
+dplyr,coalesce,-1,0,0,double[],1
+dplyr,coalesce,0,0,0,...,1
+dplyr,collapse,-1,0,0,"class<`tbl`, `tbl_SQLiteConnection`, `tbl_dbi`, `tbl_lazy`, `tbl_sql`>",1
+dplyr,collapse,0,0,0,"class<`tbl`, `tbl_SQLiteConnection`, `tbl_dbi`, `tbl_lazy`, `tbl_sql`>",1
+dplyr,collapse,1,0,0,...,1
+dplyr,collect,-1,0,0,class<`data.frame`>,1
+dplyr,collect,-1,0,1,"class<`data.frame`, `tbl`, `tbl_df`>",1
+dplyr,collect,0,0,0,class<`data.frame`>,1
+dplyr,collect,0,0,1,"class<`tbl`, `tbl_SQLiteConnection`, `tbl_dbi`, `tbl_lazy`, `tbl_sql`>",1
+dplyr,collect,0,0,2,"class<`data.frame`, `tbl`, `tbl_df`>",1
+dplyr,collect,1,0,0,...,1
+dplyr,collect.data.frame,-1,0,0,class<`data.frame`>,1
+dplyr,collect.data.frame,-1,0,1,"class<`data.frame`, `tbl`, `tbl_df`>",1
+dplyr,collect.data.frame,0,0,0,class<`data.frame`>,1
+dplyr,collect.data.frame,0,0,1,"class<`data.frame`, `tbl`, `tbl_df`>",1
+dplyr,collect.data.frame,1,0,0,...,1
+dplyr,combine,-1,0,0,character[],1
+dplyr,combine,0,0,0,...,1
+dplyr,combine_all,-1,0,0,character[],1
+dplyr,combine_all,0,0,0,list<class<`factor`>>,1
+dplyr,commas,-1,0,0,character,1
+dplyr,commas,0,0,0,...,1
+dplyr,common_by,-1,0,0,list<character[]>,1
+dplyr,common_by,0,0,0,character[],1
+dplyr,common_by,0,0,1,null,1
+dplyr,common_by,1,0,0,"class<`data.frame`, `tbl`, `tbl_df`>",1
+dplyr,common_by,1,0,1,"class<`tbl`, `tbl_SQLiteConnection`, `tbl_dbi`, `tbl_lazy`, `tbl_sql`>",1
+dplyr,common_by,2,0,0,class<`data.frame`>,1
+dplyr,common_by,2,0,1,"class<`tbl`, `tbl_SQLiteConnection`, `tbl_dbi`, `tbl_lazy`, `tbl_sql`>",1
+dplyr,common_by,2,0,2,"class<`data.frame`, `tbl`, `tbl_df`>",1
+dplyr,common_by.character,-1,0,0,list<character[]>,1
+dplyr,common_by.character,0,0,0,character[],1
+dplyr,common_by.character,1,0,0,"class<`data.frame`, `tbl`, `tbl_df`>",1
+dplyr,common_by.character,1,0,1,"class<`tbl`, `tbl_SQLiteConnection`, `tbl_dbi`, `tbl_lazy`, `tbl_sql`>",1
+dplyr,common_by.character,2,0,0,class<`data.frame`>,1
+dplyr,common_by.character,2,0,1,"class<`tbl`, `tbl_SQLiteConnection`, `tbl_dbi`, `tbl_lazy`, `tbl_sql`>",1
+dplyr,common_by.character,2,0,2,"class<`data.frame`, `tbl`, `tbl_df`>",1
+dplyr,common_by_from_vector,-1,0,0,list<character[]>,1
+dplyr,common_by_from_vector,0,0,0,character[],1
+dplyr,common_by.list,-1,0,0,list<character[]>,1
+dplyr,common_by.list,0,0,0,list<character[]>,1
+dplyr,common_by.list,1,0,0,"class<`data.frame`, `tbl`, `tbl_df`>",1
+dplyr,common_by.list,1,0,1,"class<`tbl`, `tbl_SQLiteConnection`, `tbl_dbi`, `tbl_lazy`, `tbl_sql`>",1
+dplyr,common_by.list,2,0,0,class<`data.frame`>,1
+dplyr,common_by.list,2,0,1,"class<`tbl`, `tbl_SQLiteConnection`, `tbl_dbi`, `tbl_lazy`, `tbl_sql`>",1
+dplyr,common_by.list,2,0,2,"class<`data.frame`, `tbl`, `tbl_df`>",1
+dplyr,common_by.NULL,-1,0,0,list<character[]>,1
+dplyr,common_by.NULL,0,0,0,null,1
+dplyr,common_by.NULL,1,0,0,"class<`data.frame`, `tbl`, `tbl_df`>",1
+dplyr,common_by.NULL,2,0,0,"class<`data.frame`, `tbl`, `tbl_df`>",1
+dplyr,compact,-1,0,0,list<character>,1
+dplyr,compact,-1,0,1,list<class<`data.frame`>>,1
+dplyr,compact,-1,0,2,list<integer>,1
+dplyr,compact,-1,0,3,list<character | null>,1
+dplyr,compact,0,0,0,list<character>,1
+dplyr,compact,0,0,1,list<class<`data.frame`>>,1
+dplyr,compact,0,0,2,list<integer>,1
+dplyr,compact,0,0,3,list<character | null>,1
+dplyr,compact_null,-1,0,0,list<class<`formula`>>,1
+dplyr,compact_null,0,0,0,list<class<`formula`>>,1
+dplyr,compact_null,0,0,1,list<class<`formula`> | null>,1
+dplyr,compat_lazy,-1,0,0,"class<`formula`, `quosure`>",1
+dplyr,compat_lazy,0,0,0,character,1
+dplyr,compat_lazy,0,0,1,"class<`formula`, `quosure`>",1
+dplyr,compat_lazy,1,0,0,any,1
+dplyr,compat_lazy,2,0,0,logical,1
+dplyr,compat_lazy_dots,-1,0,0,list<any>,1
+dplyr,compat_lazy_dots,0,0,0,list<any>,1
+dplyr,compat_lazy_dots,0,0,1,character[],1
+dplyr,compat_lazy_dots,1,0,0,any,1
+dplyr,compat_lazy_dots,2,0,0,...,1
+dplyr,compat_lazy_dots,3,0,0,logical,1
+dplyr,compat_lengths,-1,0,0,null,1
+dplyr,compute,-1,0,0,"class<`tbl`, `tbl_SQLiteConnection`, `tbl_dbi`, `tbl_lazy`, `tbl_sql`>",1
+dplyr,compute,0,0,0,"class<`tbl`, `tbl_SQLiteConnection`, `tbl_dbi`, `tbl_lazy`, `tbl_sql`>",1
+dplyr,compute,1,0,0,any,1
+dplyr,compute,2,0,0,...,1
+dplyr,copy_to,-1,0,0,"class<`tbl`, `tbl_SQLiteConnection`, `tbl_dbi`, `tbl_lazy`, `tbl_sql`>",1
+dplyr,copy_to,0,0,0,class<`SQLiteConnection`>,1
+dplyr,copy_to,0,0,1,"class<`src`, `src_SQLiteConnection`, `src_dbi`, `src_sql`>",1
+dplyr,copy_to,1,0,0,class<`data.frame`>,1
+dplyr,copy_to,1,0,1,"class<`data.frame`, `tbl`, `tbl_df`>",1
+dplyr,copy_to,2,0,0,any,1
+dplyr,copy_to,3,0,0,logical,1
+dplyr,copy_to,4,0,0,...,1
+dplyr,copy_to.DBIConnection,-1,0,0,"class<`tbl`, `tbl_SQLiteConnection`, `tbl_dbi`, `tbl_lazy`, `tbl_sql`>",1
+dplyr,copy_to.DBIConnection,0,0,0,class<`SQLiteConnection`>,1
+dplyr,copy_to.DBIConnection,1,0,0,class<`data.frame`>,1
+dplyr,copy_to.DBIConnection,2,0,0,character,1
+dplyr,copy_to.DBIConnection,3,0,0,logical,1
+dplyr,copy_to.DBIConnection,4,0,0,...,1
+dplyr,count,-1,0,0,"class<`data.frame`, `grouped_df`, `tbl`, `tbl_df`>",1
+dplyr,count,-1,0,1,"class<`data.frame`, `tbl`, `tbl_df`>",1
+dplyr,count,0,0,0,"class<`data.frame`, `grouped_df`, `tbl`, `tbl_df`>",1
+dplyr,count,0,0,1,"class<`data.frame`, `tbl`, `tbl_df`>",1
+dplyr,count,0,0,2,class<`data.frame`>,1
+dplyr,count,1,0,0,...,1
+dplyr,count,2,0,0,null,1
+dplyr,count,3,0,0,logical,1
+dplyr,count,4,0,0,character,1
+dplyr,count,5,0,0,logical,1
+dplyr,cumall,-1,0,0,logical[],1
+dplyr,cumall,0,0,0,logical[],1
+dplyr,cumany,-1,0,0,logical[],1
+dplyr,cumany,0,0,0,logical[],1
+dplyr,cume_dist,-1,0,0,^double[],1
+dplyr,cume_dist,0,0,0,^double[],1
+dplyr,cummean,-1,0,0,double[],1
+dplyr,cummean,0,0,0,double[],1
+dplyr,db_analyze,-1,0,0,integer,1
+dplyr,db_analyze,0,0,0,class<`SQLiteConnection`>,1
+dplyr,db_analyze,1,0,0,character,1
+dplyr,db_analyze,2,0,0,...,1
+dplyr,db_begin,-1,0,0,logical,1
+dplyr,db_begin,0,0,0,class<`SQLiteConnection`>,1
+dplyr,db_begin,1,0,0,...,1
+dplyr,db_commit,-1,0,0,logical,1
+dplyr,db_commit,0,0,0,class<`SQLiteConnection`>,1
+dplyr,db_commit,1,0,0,...,1
+dplyr,db_create_index,-1,0,0,integer,1
+dplyr,db_create_index,0,0,0,class<`SQLiteConnection`>,1
+dplyr,db_create_index,1,0,0,character,1
+dplyr,db_create_index,2,0,0,character,1
+dplyr,db_create_index,3,0,0,null,1
+dplyr,db_create_index,4,0,0,logical,1
+dplyr,db_create_index,5,0,0,...,1
+dplyr,db_create_indexes,-1,0,0,null,1
+dplyr,db_create_indexes,0,0,0,class<`SQLiteConnection`>,1
+dplyr,db_create_indexes,1,0,0,any,1
+dplyr,db_create_indexes,2,0,0,list<any>,1
+dplyr,db_create_indexes,2,0,1,null,1
+dplyr,db_create_indexes,3,0,0,logical,1
+dplyr,db_create_indexes,4,0,0,...,1
+dplyr,db_data_type,-1,0,0,character[],1
+dplyr,db_data_type,0,0,0,class<`SQLiteConnection`>,1
+dplyr,db_data_type,1,0,0,class<`data.frame`>,1
+dplyr,db_explain,-1,0,0,character,1
+dplyr,db_explain,0,0,0,class<`SQLiteConnection`>,1
+dplyr,db_explain,1,0,0,"class<`character`, `sql`>",1
+dplyr,db_explain,2,0,0,...,1
+dplyr,db_has_table,-1,0,0,logical,1
+dplyr,db_has_table,0,0,0,class<`SQLiteConnection`>,1
+dplyr,db_has_table,1,0,0,character,1
+dplyr,db_list_tables,-1,0,0,character[],1
+dplyr,db_list_tables,0,0,0,class<`SQLiteConnection`>,1
+dplyr,db_query_fields,-1,0,0,character[],1
+dplyr,db_query_fields,0,0,0,class<`SQLiteConnection`>,1
+dplyr,db_query_fields,1,0,0,"class<`character`, `ident`>",1
+dplyr,db_query_fields,1,0,1,"class<`character`, `sql`>",1
+dplyr,db_query_fields,2,0,0,...,1
+dplyr,db_save_query,-1,0,0,character,1
+dplyr,db_save_query,0,0,0,class<`SQLiteConnection`>,1
+dplyr,db_save_query,1,0,0,"class<`character`, `sql`>",1
+dplyr,db_save_query,2,0,0,character,1
+dplyr,db_save_query,3,0,0,logical,1
+dplyr,db_save_query,4,0,0,...,1
+dplyr,db_write_table,-1,0,0,character,1
+dplyr,db_write_table,0,0,0,class<`SQLiteConnection`>,1
+dplyr,db_write_table,1,0,0,character,1
+dplyr,db_write_table,2,0,0,character[],1
+dplyr,db_write_table,3,0,0,class<`data.frame`>,1
+dplyr,db_write_table,4,0,0,logical,1
+dplyr,db_write_table,5,0,0,...,1
+dplyr,default_missing,-1,0,0,null,1
+dplyr,default_missing,0,0,0,integer[],1
+dplyr,default_missing.default,-1,0,0,null,1
+dplyr,default_missing.default,0,0,0,integer[],1
+dplyr,dense_rank,-1,0,0,^integer[],1
+dplyr,dense_rank,0,0,0,^double[],1
+dplyr,deparse_names,-1,0,0,character[],1
+dplyr,deparse_names,0,0,0,null,1
+dplyr,deparse_names,0,0,1,list<class<`name`>>,1
+dplyr,desc,-1,0,0,double[],1
+dplyr,desc,0,0,0,class<`Date`>,1
+dplyr,desc,0,0,1,double[],1
+dplyr,desc,0,0,2,class<`factor`>,1
+dplyr,dfloc,-1,0,0,character[],1
+dplyr,dfloc,0,0,0,class<`data.frame`>,1
+dplyr,dim_desc,-1,0,0,character,1
+dplyr,dim_desc,0,0,0,class<`data.frame`>,1
+dplyr,distinct,-1,0,0,"class<`data.frame`, `grouped_df`, `tbl`, `tbl_df`>",1
+dplyr,distinct,-1,0,1,"class<`data.frame`, `tbl`, `tbl_df`>",1
+dplyr,distinct,0,0,0,"class<`data.frame`, `grouped_df`, `tbl`, `tbl_df`>",1
+dplyr,distinct,0,0,1,"class<`data.frame`, `tbl`, `tbl_df`>",1
+dplyr,distinct,1,0,0,...,1
+dplyr,distinct,2,0,0,logical,1
+dplyr,distinct_all,-1,0,0,"class<`data.frame`, `tbl`, `tbl_df`>",1
+dplyr,distinct_all,0,0,0,"class<`data.frame`, `tbl`, `tbl_df`>",1
+dplyr,distinct_all,1,0,0,class<`function`>,1
+dplyr,distinct_all,1,0,1,list<any>,1
+dplyr,distinct_all,2,0,0,...,1
+dplyr,distinct_all,3,0,0,logical,1
+dplyr,distinct_at,-1,0,0,"class<`data.frame`, `tbl`, `tbl_df`>",1
+dplyr,distinct_at,0,0,0,"class<`data.frame`, `tbl`, `tbl_df`>",1
+dplyr,distinct_at,1,0,0,"class<`list`, `quosures`>",1
+dplyr,distinct_at,2,0,0,list<any>,1
+dplyr,distinct_at,3,0,0,...,1
+dplyr,distinct_at,4,0,0,logical,1
+dplyr,distinct.grouped_df,-1,0,0,"class<`data.frame`, `grouped_df`, `tbl`, `tbl_df`>",1
+dplyr,distinct.grouped_df,0,0,0,"class<`data.frame`, `grouped_df`, `tbl`, `tbl_df`>",1
+dplyr,distinct.grouped_df,1,0,0,...,1
+dplyr,distinct.grouped_df,2,0,0,logical,1
+dplyr,distinct_if,-1,0,0,"class<`data.frame`, `tbl`, `tbl_df`>",1
+dplyr,distinct_if,0,0,0,"class<`data.frame`, `tbl`, `tbl_df`>",1
+dplyr,distinct_if,1,0,0,class<`function`>,1
+dplyr,distinct_if,2,0,0,list<any>,1
+dplyr,distinct_if,3,0,0,...,1
+dplyr,distinct_if,4,0,0,logical,1
+dplyr,distinct_impl,-1,0,0,"class<`data.frame`, `grouped_df`, `tbl`, `tbl_df`>",1
+dplyr,distinct_impl,-1,0,1,"class<`data.frame`, `tbl`, `tbl_df`>",1
+dplyr,distinct_impl,0,0,0,"class<`data.frame`, `grouped_df`, `tbl`, `tbl_df`>",1
+dplyr,distinct_impl,0,0,1,"class<`data.frame`, `tbl`, `tbl_df`>",1
+dplyr,distinct_impl,1,0,0,integer[],1
+dplyr,distinct_impl,2,0,0,integer[],1
+dplyr,distinct_impl,3,0,0,environment,1
+dplyr,distinct_prepare,-1,0,0,"list<class<`data.frame`, `grouped_df`, `tbl`, `tbl_df`> | character[]>",1
+dplyr,distinct_prepare,-1,0,1,"list<class<`data.frame`, `grouped_df`, `tbl`, `tbl_df`> | integer[]>",1
+dplyr,distinct_prepare,-1,0,2,"list<class<`data.frame`, `tbl`, `tbl_df`> | character[]>",1
+dplyr,distinct_prepare,-1,0,3,"list<class<`data.frame`, `tbl`, `tbl_df`> | character>",1
+dplyr,distinct_prepare,-1,0,4,"list<class<`data.frame`, `tbl`, `tbl_df`> | character | integer[]>",1
+dplyr,distinct_prepare,-1,0,5,"list<class<`data.frame`, `tbl`, `tbl_df`> | integer[]>",1
+dplyr,distinct_prepare,-1,0,6,"list<class<`data.frame`, `tbl`, `tbl_df`> | integer>",1
+dplyr,distinct_prepare,0,0,0,"class<`data.frame`, `grouped_df`, `tbl`, `tbl_df`>",1
+dplyr,distinct_prepare,0,0,1,"class<`data.frame`, `tbl`, `tbl_df`>",1
+dplyr,distinct_prepare,1,0,0,"class<`list`, `quosures`>",1
+dplyr,distinct_prepare,2,0,0,character[],1
+dplyr,distinct_prepare,3,0,0,any,1
+dplyr,distinct.tbl_df,-1,0,0,"class<`data.frame`, `tbl`, `tbl_df`>",1
+dplyr,distinct.tbl_df,0,0,0,"class<`data.frame`, `tbl`, `tbl_df`>",1
+dplyr,distinct.tbl_df,1,0,0,...,1
+dplyr,distinct.tbl_df,2,0,0,logical,1
+dplyr,do,-1,0,0,"class<`data.frame`, `grouped_df`, `tbl`, `tbl_df`>",1
+dplyr,do,-1,0,1,"class<`data.frame`, `rowwise_df`, `tbl`, `tbl_df`>",1
+dplyr,do,0,0,0,"class<`data.frame`, `grouped_df`, `tbl`, `tbl_df`>",1
+dplyr,do,0,0,1,"class<`data.frame`, `rowwise_df`, `tbl`, `tbl_df`>",1
+dplyr,do,1,0,0,...,1
+dplyr,do.grouped_df,-1,0,0,"class<`data.frame`, `grouped_df`, `tbl`, `tbl_df`>",1
+dplyr,do.grouped_df,-1,0,1,"class<`data.frame`, `rowwise_df`, `tbl`, `tbl_df`>",1
+dplyr,do.grouped_df,0,0,0,"class<`data.frame`, `grouped_df`, `tbl`, `tbl_df`>",1
+dplyr,do.grouped_df,1,0,0,...,1
+dplyr,do.rowwise_df,-1,0,0,"class<`data.frame`, `rowwise_df`, `tbl`, `tbl_df`>",1
+dplyr,do.rowwise_df,0,0,0,"class<`data.frame`, `rowwise_df`, `tbl`, `tbl_df`>",1
+dplyr,do.rowwise_df,1,0,0,...,1
+dplyr,ensure_group_vars,-1,0,0,character[],1
+dplyr,ensure_group_vars,0,0,0,character[],1
+dplyr,ensure_group_vars,1,0,0,"class<`data.frame`, `grouped_df`, `tbl`, `tbl_df`>",1
+dplyr,ensure_group_vars,2,0,0,any,1
+dplyr,env_bind_do_pronouns,-1,0,0,list<class<`rlang_zap`>>,1
+dplyr,env_bind_do_pronouns,0,0,0,environment,1
+dplyr,env_bind_do_pronouns,1,0,0,class<`function`>,1
+dplyr,equal_data_frame,-1,0,0,class<`BoolResult`>,1
+dplyr,equal_data_frame,0,0,0,class<`data.frame`>,1
+dplyr,equal_data_frame,1,0,0,class<`data.frame`>,1
+dplyr,equal_data_frame,2,0,0,logical,1
+dplyr,equal_data_frame,3,0,0,logical,1
+dplyr,equal_data_frame,4,0,0,logical,1
+dplyr,explain,-1,0,0,"class<`tbl`, `tbl_SQLiteConnection`, `tbl_dbi`, `tbl_lazy`, `tbl_sql`>",1
+dplyr,explain,0,0,0,"class<`tbl`, `tbl_SQLiteConnection`, `tbl_dbi`, `tbl_lazy`, `tbl_sql`>",1
+dplyr,explain,1,0,0,...,1
+dplyr,expr_substitute,-1,0,0,"class<`all_vars`, `formula`, `quosure`>",1
+dplyr,expr_substitute,-1,0,1,"class<`any_vars`, `formula`, `quosure`>",1
+dplyr,expr_substitute,-1,0,2,"class<`formula`, `quosure`>",1
+dplyr,expr_substitute,0,0,0,"class<`all_vars`, `formula`, `quosure`>",1
+dplyr,expr_substitute,0,0,1,"class<`any_vars`, `formula`, `quosure`>",1
+dplyr,expr_substitute,0,0,2,"class<`formula`, `quosure`>",1
+dplyr,expr_substitute,1,0,0,class<`name`>,1
+dplyr,expr_substitute,2,0,0,class<`name`>,1
+dplyr,expr_type_of,-1,0,0,character,1
+dplyr,expr_type_of,0,0,0,class<`(`>,1
+dplyr,expr_type_of,0,0,1,class<`call`>,1
+dplyr,expr_type_of,0,0,2,class<`name`>,1
+dplyr,expr_type_of,0,0,3,double,1
+dplyr,filter,-1,0,0,logical[],1
+dplyr,filter,0,0,0,character[],1
+dplyr,filter,-1,1,0,class<`data.frame`>,1
+dplyr,filter,-1,1,1,"class<`data.frame`, `grouped_df`, `tbl`, `tbl_df`>",1
+dplyr,filter,-1,1,2,"class<`data.frame`, `tbl`, `tbl_df`>",1
+dplyr,filter,-1,1,3,class<`tbl_cube`>,1
+dplyr,filter,-1,1,4,"class<`tbl`, `tbl_SQLiteConnection`, `tbl_dbi`, `tbl_lazy`, `tbl_sql`>",1
+dplyr,filter,0,1,0,class<`data.frame`>,1
+dplyr,filter,0,1,1,"class<`data.frame`, `grouped_df`, `tbl`, `tbl_df`>",1
+dplyr,filter,0,1,2,"class<`data.frame`, `tbl`, `tbl_df`>",1
+dplyr,filter,0,1,3,class<`tbl_cube`>,1
+dplyr,filter,0,1,4,"class<`tbl`, `tbl_SQLiteConnection`, `tbl_dbi`, `tbl_lazy`, `tbl_sql`>",1
+dplyr,filter,1,1,0,...,1
+dplyr,filter,2,1,0,logical,1
+dplyr,filter_all,-1,0,0,class<`data.frame`>,1
+dplyr,filter_all,0,0,0,class<`data.frame`>,1
+dplyr,filter_all,1,0,0,"class<`all_vars`, `formula`, `quosure`>",1
+dplyr,filter_all,1,0,1,"class<`any_vars`, `formula`, `quosure`>",1
+dplyr,filter_all,2,0,0,logical,1
+dplyr,filter_at,-1,0,0,class<`data.frame`>,1
+dplyr,filter_at,0,0,0,class<`data.frame`>,1
+dplyr,filter_at,1,0,0,"class<`list`, `quosures`>",1
+dplyr,filter_at,2,0,0,"class<`any_vars`, `formula`, `quosure`>",1
+dplyr,filter_at,2,0,1,class<`formula`>,1
+dplyr,filter_at,3,0,0,logical,1
+dplyr,filter.data.frame,-1,0,0,class<`data.frame`>,1
+dplyr,filter.data.frame,0,0,0,class<`data.frame`>,1
+dplyr,filter.data.frame,1,0,0,...,1
+dplyr,filter.data.frame,2,0,0,logical,1
+dplyr,filter_if,-1,0,0,class<`data.frame`>,1
+dplyr,filter_if,0,0,0,class<`data.frame`>,1
+dplyr,filter_if,1,0,0,class<`formula`>,1
+dplyr,filter_if,2,0,0,"class<`all_vars`, `formula`, `quosure`>",1
+dplyr,filter_if,3,0,0,logical,1
+dplyr,filter_impl,-1,0,0,"class<`data.frame`, `grouped_df`, `tbl`, `tbl_df`>",1
+dplyr,filter_impl,-1,0,1,"class<`data.frame`, `tbl`, `tbl_df`>",1
+dplyr,filter_impl,0,0,0,"class<`data.frame`, `grouped_df`, `tbl`, `tbl_df`>",1
+dplyr,filter_impl,0,0,1,"class<`data.frame`, `tbl`, `tbl_df`>",1
+dplyr,filter_impl,1,0,0,"class<`formula`, `quosure`>",1
+dplyr,filter.tbl_cube,-1,0,0,class<`tbl_cube`>,1
+dplyr,filter.tbl_cube,0,0,0,class<`tbl_cube`>,1
+dplyr,filter.tbl_cube,1,0,0,...,1
+dplyr,filter.tbl_df,-1,0,0,"class<`data.frame`, `grouped_df`, `tbl`, `tbl_df`>",1
+dplyr,filter.tbl_df,-1,0,1,"class<`data.frame`, `tbl`, `tbl_df`>",1
+dplyr,filter.tbl_df,0,0,0,"class<`data.frame`, `grouped_df`, `tbl`, `tbl_df`>",1
+dplyr,filter.tbl_df,0,0,1,"class<`data.frame`, `tbl`, `tbl_df`>",1
+dplyr,filter.tbl_df,1,0,0,...,1
+dplyr,filter.tbl_df,2,0,0,logical,1
+dplyr,find_index,-1,0,0,integer[],1
+dplyr,find_index,0,0,0,class<`call`>,1
+dplyr,find_index,0,0,1,double,1
+dplyr,find_index,0,0,2,class<`name`>,1
+dplyr,find_index,1,0,0,character[],1
+dplyr,find_index_check,-1,0,0,integer,1
+dplyr,find_index_check,0,0,0,any,1
+dplyr,find_index_check,1,0,0,"class<`formula`, `quosure`>",1
+dplyr,find_index_check,2,0,0,character[],1
+dplyr,find_template,-1,0,0,character,1
+dplyr,find_template,-1,0,1,integer,1
+dplyr,find_template,0,0,0,list<character>,1
+dplyr,find_template,0,0,1,list<integer>,1
+dplyr,find_template,1,0,0,null,1
+dplyr,find_template,1,0,1,character[],1
+dplyr,find_template,2,0,0,null,1
+dplyr,find_template,2,0,1,character,1
+dplyr,first,-1,0,0,integer,1
+dplyr,first,-1,0,1,null,1
+dplyr,first,0,0,0,integer[],1
+dplyr,first,1,0,0,null,1
+dplyr,first,2,0,0,any,1
+dplyr,flatten_bindable,-1,0,0,list<class<`data.frame`>>,1
+dplyr,flatten_bindable,-1,0,1,"list<class<`data.frame`, `tbl`, `tbl_df`> | class<`data.frame`>>",1
+dplyr,flatten_bindable,-1,0,2,"list<class<`data.frame`, `tbl`, `tbl_df`>>",1
+dplyr,flatten_bindable,-1,0,3,"list<double[] | class<`data.frame`, `tbl`, `tbl_df`>>",1
+dplyr,flatten_bindable,-1,0,4,list<double[]>,1
+dplyr,flatten_bindable,-1,0,5,list<list<double[]>>,1
+dplyr,flatten_bindable,0,0,0,list<list<class<`data.frame`>>>,1
+dplyr,flatten_bindable,0,0,1,list<class<`data.frame`>>,1
+dplyr,flatten_bindable,0,0,2,"list<class<`data.frame`, `tbl`, `tbl_df`> | class<`data.frame`>>",1
+dplyr,flatten_bindable,0,0,3,"list<class<`rlang_box`, `rlang_box_splice`>>",1
+dplyr,flatten_bindable,0,0,4,"list<list<class<`data.frame`, `tbl`, `tbl_df`>>>",1
+dplyr,flatten_bindable,0,0,5,"list<class<`data.frame`, `tbl`, `tbl_df`>>",1
+dplyr,flatten_bindable,0,0,6,"list<double[] | class<`data.frame`, `tbl`, `tbl_df`>>",1
+dplyr,flatten_bindable,0,0,7,list<double[]>,1
+dplyr,flatten_bindable,0,0,8,list<list<double[]>>,1
+dplyr,fmt_cols,-1,0,0,"class<`character`, `glue`>",1
+dplyr,fmt_cols,0,0,0,character,1
+dplyr,fmt_comma,-1,0,0,character,1
+dplyr,fmt_comma,0,0,0,...,1
+dplyr,fmt_comma,1,0,0,double,1
+dplyr,fmt_dims,-1,0,0,character,1
+dplyr,fmt_dims,0,0,0,character[],1
+dplyr,fmt_items,-1,0,0,character,1
+dplyr,fmt_items,0,0,0,character,1
+dplyr,fmt_items,1,0,0,double,1
+dplyr,fmt_obj,-1,0,0,character,1
+dplyr,fmt_obj,0,0,0,character,1
+dplyr,fmt_obj1,-1,0,0,character,1
+dplyr,fmt_obj1,0,0,0,character,1
+dplyr,from_context,-1,0,0,integer,1
+dplyr,from_context,0,0,0,character,1
+dplyr,full_join,-1,0,0,"class<`data.frame`, `tbl`, `tbl_df`>",1
+dplyr,full_join,0,0,0,"class<`data.frame`, `tbl`, `tbl_df`>",1
+dplyr,full_join,1,0,0,"class<`data.frame`, `tbl`, `tbl_df`>",1
+dplyr,full_join,2,0,0,character,1
+dplyr,full_join,2,0,1,null,1
+dplyr,full_join,3,0,0,logical,1
+dplyr,full_join,4,0,0,any,1
+dplyr,full_join,5,0,0,...,1
+dplyr,full_join_impl,-1,0,0,"class<`data.frame`, `tbl`, `tbl_df`>",1
+dplyr,full_join_impl,0,0,0,"class<`data.frame`, `tbl`, `tbl_df`>",1
+dplyr,full_join_impl,1,0,0,"class<`data.frame`, `tbl`, `tbl_df`>",1
+dplyr,full_join_impl,2,0,0,integer[],1
+dplyr,full_join_impl,3,0,0,integer[],1
+dplyr,full_join_impl,4,0,0,integer[],1
+dplyr,full_join_impl,5,0,0,integer[],1
+dplyr,full_join_impl,6,0,0,logical,1
+dplyr,full_join_impl,7,0,0,environment,1
+dplyr,full_join.tbl_df,-1,0,0,"class<`data.frame`, `tbl`, `tbl_df`>",1
+dplyr,full_join.tbl_df,0,0,0,"class<`data.frame`, `tbl`, `tbl_df`>",1
+dplyr,full_join.tbl_df,1,0,0,"class<`data.frame`, `tbl`, `tbl_df`>",1
+dplyr,full_join.tbl_df,2,0,0,character,1
+dplyr,full_join.tbl_df,2,0,1,null,1
+dplyr,full_join.tbl_df,3,0,0,logical,1
+dplyr,full_join.tbl_df,4,0,0,character[],1
+dplyr,full_join.tbl_df,5,0,0,...,1
+dplyr,full_join.tbl_df,6,0,0,null,1
+dplyr,fun_env,-1,0,0,environment,1
+dplyr,fun_env,0,0,0,"class<`formula`, `quosure`>",1
+dplyr,fun_env,1,0,0,any,1
+dplyr,funs,-1,0,0,class<`fun_list`>,1
+dplyr,funs,0,0,0,...,1
+dplyr,funs,1,0,0,list<any>,1
+dplyr,funs_,-1,0,0,class<`fun_list`>,1
+dplyr,funs_,0,0,0,character[],1
+dplyr,funs_,1,0,0,list<any>,1
+dplyr,funs_,2,0,0,any,1
+dplyr,get_by_aux,-1,0,0,list<integer[]>,1
+dplyr,get_by_aux,0,0,0,"class<`character`, `dplyr_sel_vars`>",1
+dplyr,get_by_aux,1,0,0,character[],1
+dplyr,get_join_var_idx,-1,0,0,list<list<integer[]>>,1
+dplyr,get_join_var_idx,0,0,0,"class<`character`, `dplyr_sel_vars`>",1
+dplyr,get_join_var_idx,1,0,0,"class<`character`, `dplyr_sel_vars`>",1
+dplyr,get_join_var_idx,2,0,0,list<character[]>,1
+dplyr,glubort,-1,0,0,character,1
+dplyr,glubort,0,0,0,"class<`character`, `glue`>",1
+dplyr,glubort,1,0,0,...,1
+dplyr,glubort,2,0,0,environment,1
+dplyr,glubort,3,0,0,class<`function`>,1
+dplyr,group_by,-1,0,0,"class<`data.frame`, `grouped_df`, `tbl`, `tbl_df`>",1
+dplyr,group_by,-1,0,1,"class<`data.frame`, `tbl`, `tbl_df`>",1
+dplyr,group_by,-1,0,2,class<`tbl_cube`>,1
+dplyr,group_by,-1,0,3,"class<`tbl`, `tbl_SQLiteConnection`, `tbl_dbi`, `tbl_lazy`, `tbl_sql`>",1
+dplyr,group_by,0,0,0,class<`data.frame`>,1
+dplyr,group_by,0,0,1,"class<`data.frame`, `grouped_df`, `tbl`, `tbl_df`>",1
+dplyr,group_by,0,0,2,"class<`data.frame`, `tbl`, `tbl_df`>",1
+dplyr,group_by,0,0,3,class<`tbl_cube`>,1
+dplyr,group_by,0,0,4,"class<`tbl`, `tbl_SQLiteConnection`, `tbl_dbi`, `tbl_lazy`, `tbl_sql`>",1
+dplyr,group_by,1,0,0,...,1
+dplyr,group_by,2,0,0,logical,1
+dplyr,group_by,3,0,0,any,1
+dplyr,group_by_all,-1,0,0,"class<`data.frame`, `grouped_df`, `tbl`, `tbl_df`>",1
+dplyr,group_by_all,0,0,0,"class<`data.frame`, `tbl`, `tbl_df`>",1
+dplyr,group_by_all,0,0,1,class<`data.frame`>,1
+dplyr,group_by_all,1,0,0,class<`function`>,1
+dplyr,group_by_all,1,0,1,list<any>,1
+dplyr,group_by_all,2,0,0,...,1
+dplyr,group_by_all,3,0,0,logical,1
+dplyr,group_by_all,4,0,0,logical,1
+dplyr,group_by_at,-1,0,0,"class<`data.frame`, `grouped_df`, `tbl`, `tbl_df`>",1
+dplyr,group_by_at,0,0,0,"class<`data.frame`, `tbl`, `tbl_df`>",1
+dplyr,group_by_at,0,0,1,class<`data.frame`>,1
+dplyr,group_by_at,1,0,0,character,1
+dplyr,group_by_at,1,0,1,"class<`list`, `quosures`>",1
+dplyr,group_by_at,2,0,0,list<any>,1
+dplyr,group_by_at,3,0,0,...,1
+dplyr,group_by_at,4,0,0,logical,1
+dplyr,group_by_at,5,0,0,logical,1
+dplyr,group_by.data.frame,-1,0,0,"class<`data.frame`, `grouped_df`, `tbl`, `tbl_df`>",1
+dplyr,group_by.data.frame,-1,0,1,"class<`data.frame`, `tbl`, `tbl_df`>",1
+dplyr,group_by.data.frame,0,0,0,class<`data.frame`>,1
+dplyr,group_by.data.frame,0,0,1,"class<`data.frame`, `grouped_df`, `tbl`, `tbl_df`>",1
+dplyr,group_by.data.frame,0,0,2,"class<`data.frame`, `tbl`, `tbl_df`>",1
+dplyr,group_by.data.frame,1,0,0,...,1
+dplyr,group_by.data.frame,2,0,0,logical,1
+dplyr,group_by.data.frame,3,0,0,logical,1
+dplyr,group_by_drop_default,-1,0,0,logical,1
+dplyr,group_by_drop_default,0,0,0,class<`data.frame`>,1
+dplyr,group_by_drop_default,0,0,1,"class<`data.frame`, `grouped_df`, `tbl`, `tbl_df`>",1
+dplyr,group_by_drop_default,0,0,2,"class<`data.frame`, `tbl`, `tbl_df`>",1
+dplyr,group_by_drop_default.default,-1,0,0,logical,1
+dplyr,group_by_drop_default.default,0,0,0,class<`data.frame`>,1
+dplyr,group_by_drop_default.default,0,0,1,"class<`data.frame`, `tbl`, `tbl_df`>",1
+dplyr,group_by_drop_default.grouped_df,-1,0,0,logical,1
+dplyr,group_by_drop_default.grouped_df,0,0,0,"class<`data.frame`, `grouped_df`, `tbl`, `tbl_df`>",1
+dplyr,group_by_if,-1,0,0,"class<`data.frame`, `grouped_df`, `tbl`, `tbl_df`>",1
+dplyr,group_by_if,0,0,0,class<`data.frame`>,1
+dplyr,group_by_if,1,0,0,class<`function`>,1
+dplyr,group_by_if,2,0,0,class<`function`>,1
+dplyr,group_by_if,2,0,1,list<any>,1
+dplyr,group_by_if,3,0,0,...,1
+dplyr,group_by_if,4,0,0,logical,1
+dplyr,group_by_if,5,0,0,logical,1
+dplyr,group_by_prepare,-1,0,0,"list<class<`data.frame`, `grouped_df`, `tbl`, `tbl_df`> | character[] | list<any>>",1
+dplyr,group_by_prepare,-1,0,1,"list<class<`data.frame`, `grouped_df`, `tbl`, `tbl_df`> | character[] | list<class<`name`>>>",1
+dplyr,group_by_prepare,-1,0,2,"list<class<`data.frame`, `grouped_df`, `tbl`, `tbl_df`> | character | list<class<`name`>>>",1
+dplyr,group_by_prepare,-1,0,3,list<class<`data.frame`> | character[] | list<class<`name`>>>,1
+dplyr,group_by_prepare,-1,0,4,list<class<`data.frame`> | character | list<class<`name`>>>,1
+dplyr,group_by_prepare,-1,0,5,"list<class<`data.frame`, `tbl`, `tbl_df`> | character[] | list<any>>",1
+dplyr,group_by_prepare,-1,0,6,"list<class<`data.frame`, `tbl`, `tbl_df`> | character[] | list<class<`name`>>>",1
+dplyr,group_by_prepare,-1,0,7,"list<class<`data.frame`, `tbl`, `tbl_df`> | character | list<class<`name`>>>",1
+dplyr,group_by_prepare,-1,0,8,list<class<`tbl_cube`> | character[] | list<class<`name`>>>,1
+dplyr,group_by_prepare,-1,0,9,"list<class<`tbl`, `tbl_SQLiteConnection`, `tbl_dbi`, `tbl_lazy`, `tbl_sql`> | character | list<class<`name`>>>",1
+dplyr,group_by_prepare,0,0,0,"class<`data.frame`, `grouped_df`, `tbl`, `tbl_df`>",1
+dplyr,group_by_prepare,0,0,1,class<`data.frame`>,1
+dplyr,group_by_prepare,0,0,2,"class<`data.frame`, `tbl`, `tbl_df`>",1
+dplyr,group_by_prepare,0,0,3,class<`tbl_cube`>,1
+dplyr,group_by_prepare,0,0,4,"class<`tbl`, `tbl_SQLiteConnection`, `tbl_dbi`, `tbl_lazy`, `tbl_sql`>",1
+dplyr,group_by_prepare,1,0,0,...,1
+dplyr,group_by_prepare,2,0,0,list<any>,1
+dplyr,group_by_prepare,3,0,0,logical,1
+dplyr,.group_by_static_drop,-1,0,0,"class<`data.frame`, `grouped_df`, `tbl`, `tbl_df`>",1
+dplyr,.group_by_static_drop,-1,0,1,"class<`data.frame`, `tbl`, `tbl_df`>",1
+dplyr,.group_by_static_drop,0,0,0,...,1
+dplyr,.group_by_static_drop,1,0,0,logical,1
+dplyr,group_by.tbl_cube,-1,0,0,class<`tbl_cube`>,1
+dplyr,group_by.tbl_cube,0,0,0,class<`tbl_cube`>,1
+dplyr,group_by.tbl_cube,1,0,0,...,1
+dplyr,group_by.tbl_cube,2,0,0,logical,1
+dplyr,group_by.tbl_cube,3,0,0,logical,1
+dplyr,group_cols,-1,0,0,integer,1
+dplyr,group_cols,0,0,0,"class<`character`, `dplyr_sel_vars`>",1
+dplyr,group_data,-1,0,0,"class<`data.frame`, `tbl`, `tbl_df`>",1
+dplyr,group_data,0,0,0,"class<`data.frame`, `tbl`, `tbl_df`>",1
+dplyr,group_data,0,0,1,"class<`data.frame`, `grouped_df`, `tbl`, `tbl_df`>",1
+dplyr,group_data.data.frame,-1,0,0,"class<`data.frame`, `tbl`, `tbl_df`>",1
+dplyr,group_data.data.frame,0,0,0,"class<`data.frame`, `tbl`, `tbl_df`>",1
+dplyr,group_data_grouped_df,-1,0,0,"class<`data.frame`, `tbl`, `tbl_df`>",1
+dplyr,group_data_grouped_df,0,0,0,"class<`data.frame`, `grouped_df`, `tbl`, `tbl_df`>",1
+dplyr,group_data.grouped_df,-1,0,0,"class<`data.frame`, `tbl`, `tbl_df`>",1
+dplyr,group_data.grouped_df,0,0,0,"class<`data.frame`, `grouped_df`, `tbl`, `tbl_df`>",1
+dplyr,[.grouped_df,-1,0,0,"class<`data.frame`, `grouped_df`, `tbl`, `tbl_df`>",1
+dplyr,[.grouped_df,0,0,0,"class<`data.frame`, `grouped_df`, `tbl`, `tbl_df`>",1
+dplyr,[.grouped_df,1,0,0,character[],1
+dplyr,[.grouped_df,1,0,1,integer[],1
+dplyr,[.grouped_df,2,0,0,any,1
+dplyr,[.grouped_df,3,0,0,logical,1
+dplyr,grouped_df,-1,0,0,"class<`data.frame`, `grouped_df`, `tbl`, `tbl_df`>",1
+dplyr,grouped_df,-1,0,1,"class<`data.frame`, `tbl`, `tbl_df`>",1
+dplyr,grouped_df,0,0,0,"class<`data.frame`, `grouped_df`, `tbl`, `tbl_df`>",1
+dplyr,grouped_df,0,0,1,"class<`data.frame`, `tbl`, `tbl_df`>",1
+dplyr,grouped_df,0,0,2,class<`data.frame`>,1
+dplyr,grouped_df,1,0,0,list<class<`name`>>,1
+dplyr,grouped_df,1,0,1,character[],1
+dplyr,grouped_df,2,0,0,logical,1
+dplyr,grouped_df_impl,-1,0,0,"class<`data.frame`, `grouped_df`, `tbl`, `tbl_df`>",1
+dplyr,grouped_df_impl,-1,0,1,"class<`data.frame`, `tbl`, `tbl_df`>",1
+dplyr,grouped_df_impl,0,0,0,"class<`data.frame`, `grouped_df`, `tbl`, `tbl_df`>",1
+dplyr,grouped_df_impl,0,0,1,"class<`data.frame`, `tbl`, `tbl_df`>",1
+dplyr,grouped_df_impl,0,0,2,class<`data.frame`>,1
+dplyr,grouped_df_impl,1,0,0,character[],1
+dplyr,grouped_df_impl,2,0,0,logical,1
+dplyr,grouped_indices_grouped_df_impl,-1,0,0,integer[],1
+dplyr,grouped_indices_grouped_df_impl,0,0,0,"class<`data.frame`, `grouped_df`, `tbl`, `tbl_df`>",1
+dplyr,group_indices,-1,0,0,integer[],1
+dplyr,group_indices,0,0,0,class<`data.frame`>,1
+dplyr,group_indices,1,0,0,...,1
+dplyr,group_indices.data.frame,-1,0,0,integer[],1
+dplyr,group_indices.data.frame,0,0,0,class<`data.frame`>,1
+dplyr,group_indices.data.frame,1,0,0,...,1
+dplyr,group_indices.data.frame,2,0,0,logical,1
+dplyr,group_keys,-1,0,0,"class<`data.frame`, `tbl`, `tbl_df`>",1
+dplyr,group_keys,0,0,0,class<`data.frame`>,1
+dplyr,group_keys,0,0,1,"class<`data.frame`, `grouped_df`, `tbl`, `tbl_df`>",1
+dplyr,group_keys,1,0,0,...,1
+dplyr,group_keys.data.frame,-1,0,0,"class<`data.frame`, `tbl`, `tbl_df`>",1
+dplyr,group_keys.data.frame,0,0,0,class<`data.frame`>,1
+dplyr,group_keys.data.frame,1,0,0,...,1
+dplyr,group_keys.grouped_df,-1,0,0,"class<`data.frame`, `tbl`, `tbl_df`>",1
+dplyr,group_keys.grouped_df,0,0,0,"class<`data.frame`, `grouped_df`, `tbl`, `tbl_df`>",1
+dplyr,group_keys.grouped_df,1,0,0,...,1
+dplyr,group_keys_impl,-1,0,0,"class<`data.frame`, `tbl`, `tbl_df`>",1
+dplyr,group_keys_impl,0,0,0,"class<`data.frame`, `grouped_df`, `tbl`, `tbl_df`>",1
+dplyr,group_map,-1,0,0,"list<class<`data.frame`, `tbl`, `tbl_df`>>",1
+dplyr,group_map,-1,0,1,list<double[]>,1
+dplyr,group_map,-1,0,2,list<null>,1
+dplyr,group_map,0,0,0,"class<`data.frame`, `grouped_df`, `tbl`, `tbl_df`>",1
+dplyr,group_map,1,0,0,class<`formula`>,1
+dplyr,group_map,1,0,1,class<`function`>,1
+dplyr,group_map,2,0,0,...,1
+dplyr,group_map,3,0,0,logical,1
+dplyr,group_modify,-1,0,0,class<`data.frame`>,1
+dplyr,group_modify,-1,0,1,"class<`data.frame`, `grouped_df`, `tbl`, `tbl_df`>",1
+dplyr,group_modify,0,0,0,class<`data.frame`>,1
+dplyr,group_modify,0,0,1,"class<`data.frame`, `grouped_df`, `tbl`, `tbl_df`>",1
+dplyr,group_modify,1,0,0,class<`formula`>,1
+dplyr,group_modify,2,0,0,...,1
+dplyr,group_modify,3,0,0,logical,1
+dplyr,group_modify.data.frame,-1,0,0,class<`data.frame`>,1
+dplyr,group_modify.data.frame,0,0,0,class<`data.frame`>,1
+dplyr,group_modify.data.frame,1,0,0,class<`formula`>,1
+dplyr,group_modify.data.frame,2,0,0,...,1
+dplyr,group_modify.data.frame,3,0,0,logical,1
+dplyr,group_modify.grouped_df,-1,0,0,"class<`data.frame`, `grouped_df`, `tbl`, `tbl_df`>",1
+dplyr,group_modify.grouped_df,0,0,0,"class<`data.frame`, `grouped_df`, `tbl`, `tbl_df`>",1
+dplyr,group_modify.grouped_df,1,0,0,class<`formula`>,1
+dplyr,group_modify.grouped_df,2,0,0,...,1
+dplyr,group_modify.grouped_df,3,0,0,logical,1
+dplyr,group_nest,-1,0,0,"class<`data.frame`, `tbl`, `tbl_df`>",1
+dplyr,group_nest,0,0,0,"class<`data.frame`, `grouped_df`, `tbl`, `tbl_df`>",1
+dplyr,group_nest,0,0,1,"class<`data.frame`, `tbl`, `tbl_df`>",1
+dplyr,group_nest,1,0,0,...,1
+dplyr,group_nest,2,0,0,character,1
+dplyr,group_nest,3,0,0,logical,1
+dplyr,group_nest.data.frame,-1,0,0,"class<`data.frame`, `tbl`, `tbl_df`>",1
+dplyr,group_nest.data.frame,0,0,0,"class<`data.frame`, `tbl`, `tbl_df`>",1
+dplyr,group_nest.data.frame,1,0,0,...,1
+dplyr,group_nest.data.frame,2,0,0,character,1
+dplyr,group_nest.data.frame,3,0,0,logical,1
+dplyr,group_nest.grouped_df,-1,0,0,"class<`data.frame`, `tbl`, `tbl_df`>",1
+dplyr,group_nest.grouped_df,0,0,0,"class<`data.frame`, `grouped_df`, `tbl`, `tbl_df`>",1
+dplyr,group_nest.grouped_df,1,0,0,...,1
+dplyr,group_nest.grouped_df,2,0,0,character,1
+dplyr,group_nest.grouped_df,3,0,0,logical,1
+dplyr,group_nest_impl,-1,0,0,"class<`data.frame`, `tbl`, `tbl_df`>",1
+dplyr,group_nest_impl,0,0,0,"class<`data.frame`, `grouped_df`, `tbl`, `tbl_df`>",1
+dplyr,group_nest_impl,1,0,0,character,1
+dplyr,group_nest_impl,2,0,0,logical,1
+dplyr,group_rows,-1,0,0,list<integer[]>,1
+dplyr,group_rows,0,0,0,"class<`data.frame`, `grouped_df`, `tbl`, `tbl_df`>",1
+dplyr,group_rows,0,0,1,"class<`data.frame`, `tbl`, `tbl_df`>",1
+dplyr,groups,-1,0,0,list<class<`name`>>,1
+dplyr,groups,-1,0,1,null,1
+dplyr,groups,0,0,0,"class<`data.frame`, `grouped_df`, `tbl`, `tbl_df`>",1
+dplyr,groups,0,0,1,class<`data.frame`>,1
+dplyr,groups,0,0,2,"class<`data.frame`, `tbl`, `tbl_df`>",1
+dplyr,groups.default,-1,0,0,null,1
+dplyr,groups.default,0,0,0,class<`data.frame`>,1
+dplyr,groups.default,0,0,1,"class<`data.frame`, `tbl`, `tbl_df`>",1
+dplyr,groups.grouped_df,-1,0,0,list<class<`name`>>,1
+dplyr,groups.grouped_df,0,0,0,"class<`data.frame`, `grouped_df`, `tbl`, `tbl_df`>",1
+dplyr,group_size,-1,0,0,integer[],1
+dplyr,group_size,0,0,0,"class<`data.frame`, `grouped_df`, `tbl`, `tbl_df`>",1
+dplyr,group_size_grouped_cpp,-1,0,0,integer[],1
+dplyr,group_size_grouped_cpp,0,0,0,"class<`data.frame`, `grouped_df`, `tbl`, `tbl_df`>",1
+dplyr,group_size.grouped_df,-1,0,0,integer[],1
+dplyr,group_size.grouped_df,0,0,0,"class<`data.frame`, `grouped_df`, `tbl`, `tbl_df`>",1
+dplyr,group_split,-1,0,0,"list<class<`data.frame`, `tbl`, `tbl_df`>>",1
+dplyr,group_split,0,0,0,class<`data.frame`>,1
+dplyr,group_split,0,0,1,"class<`data.frame`, `grouped_df`, `tbl`, `tbl_df`>",1
+dplyr,group_split,1,0,0,...,1
+dplyr,group_split,2,0,0,logical,1
+dplyr,group_split.data.frame,-1,0,0,"list<class<`data.frame`, `tbl`, `tbl_df`>>",1
+dplyr,group_split.data.frame,0,0,0,class<`data.frame`>,1
+dplyr,group_split.data.frame,1,0,0,...,1
+dplyr,group_split.data.frame,2,0,0,logical,1
+dplyr,group_split.grouped_df,-1,0,0,"list<class<`data.frame`, `tbl`, `tbl_df`>>",1
+dplyr,group_split.grouped_df,0,0,0,"class<`data.frame`, `grouped_df`, `tbl`, `tbl_df`>",1
+dplyr,group_split.grouped_df,1,0,0,...,1
+dplyr,group_split.grouped_df,2,0,0,logical,1
+dplyr,group_split_impl,-1,0,0,"list<class<`data.frame`, `tbl`, `tbl_df`>>",1
+dplyr,group_split_impl,0,0,0,"class<`data.frame`, `grouped_df`, `tbl`, `tbl_df`>",1
+dplyr,group_split_impl,1,0,0,logical,1
+dplyr,group_split_impl,2,0,0,environment,1
+dplyr,group_trim,-1,0,0,"class<`data.frame`, `grouped_df`, `tbl`, `tbl_df`>",1
+dplyr,group_trim,0,0,0,"class<`data.frame`, `grouped_df`, `tbl`, `tbl_df`>",1
+dplyr,group_trim,1,0,0,any,1
+dplyr,group_trim.grouped_df,-1,0,0,"class<`data.frame`, `grouped_df`, `tbl`, `tbl_df`>",1
+dplyr,group_trim.grouped_df,0,0,0,"class<`data.frame`, `grouped_df`, `tbl`, `tbl_df`>",1
+dplyr,group_trim.grouped_df,1,0,0,logical,1
+dplyr,group_vars,-1,0,0,character[],1
+dplyr,group_vars,0,0,0,class<`data.frame`>,1
+dplyr,group_vars,0,0,1,"class<`data.frame`, `grouped_df`, `tbl`, `tbl_df`>",1
+dplyr,group_vars,0,0,2,"class<`data.frame`, `tbl`, `tbl_df`>",1
+dplyr,group_vars,0,0,3,"class<`tbl`, `tbl_SQLiteConnection`, `tbl_dbi`, `tbl_lazy`, `tbl_sql`>",1
+dplyr,group_vars.default,-1,0,0,character[],1
+dplyr,group_vars.default,0,0,0,class<`data.frame`>,1
+dplyr,group_vars.default,0,0,1,"class<`data.frame`, `tbl`, `tbl_df`>",1
+dplyr,group_vars.grouped_df,-1,0,0,character[],1
+dplyr,group_vars.grouped_df,0,0,0,"class<`data.frame`, `grouped_df`, `tbl`, `tbl_df`>",1
+dplyr,group_walk,-1,0,0,"class<`data.frame`, `grouped_df`, `tbl`, `tbl_df`>",1
+dplyr,group_walk,0,0,0,"class<`data.frame`, `grouped_df`, `tbl`, `tbl_df`>",1
+dplyr,group_walk,1,0,0,class<`formula`>,1
+dplyr,group_walk,2,0,0,...,1
+dplyr,hybrid_call,-1,0,0,class<`hybrid_call`>,1
+dplyr,hybrid_call,0,0,0,class<`data.frame`>,1
+dplyr,hybrid_call,1,0,0,any,1
+dplyr,hybrid_call.data.frame,-1,0,0,class<`hybrid_call`>,1
+dplyr,hybrid_call.data.frame,0,0,0,class<`data.frame`>,1
+dplyr,hybrid_call.data.frame,1,0,0,any,1
+dplyr,hybrid_impl,-1,0,0,class<`hybrid_call`>,1
+dplyr,hybrid_impl,0,0,0,class<`data.frame`>,1
+dplyr,hybrid_impl,1,0,0,"class<`formula`, `quosure`>",1
+dplyr,hybrid_impl,2,0,0,environment,1
+dplyr,ident,-1,0,0,"class<`character`, `ident`>",1
+dplyr,ident,0,0,0,...,1
+dplyr,if_else,-1,0,0,character[],1
+dplyr,if_else,-1,0,1,class<`factor`>,1
+dplyr,if_else,-1,0,2,^integer[],1
+dplyr,if_else,0,0,0,^logical[],1
+dplyr,if_else,1,0,0,character,1
+dplyr,if_else,1,0,1,class<`factor`>,1
+dplyr,if_else,1,0,2,null,1
+dplyr,if_else,2,0,0,character,1
+dplyr,if_else,2,0,1,class<`factor`>,1
+dplyr,if_else,2,0,2,^integer[],1
+dplyr,if_else,3,0,0,character,1
+dplyr,if_else,3,0,1,null,1
+dplyr,inner_join,-1,0,0,"class<`data.frame`, `tbl`, `tbl_df`>",1
+dplyr,inner_join,0,0,0,"class<`data.frame`, `tbl`, `tbl_df`>",1
+dplyr,inner_join,1,0,0,"class<`data.frame`, `tbl`, `tbl_df`>",1
+dplyr,inner_join,2,0,0,character,1
+dplyr,inner_join,2,0,1,null,1
+dplyr,inner_join,3,0,0,logical,1
+dplyr,inner_join,4,0,0,any,1
+dplyr,inner_join,5,0,0,...,1
+dplyr,inner_join_impl,-1,0,0,"class<`data.frame`, `tbl`, `tbl_df`>",1
+dplyr,inner_join_impl,0,0,0,"class<`data.frame`, `tbl`, `tbl_df`>",1
+dplyr,inner_join_impl,1,0,0,"class<`data.frame`, `tbl`, `tbl_df`>",1
+dplyr,inner_join_impl,2,0,0,integer,1
+dplyr,inner_join_impl,3,0,0,integer,1
+dplyr,inner_join_impl,4,0,0,integer[],1
+dplyr,inner_join_impl,5,0,0,integer[],1
+dplyr,inner_join_impl,6,0,0,logical,1
+dplyr,inner_join_impl,7,0,0,environment,1
+dplyr,inner_join.tbl_df,-1,0,0,"class<`data.frame`, `tbl`, `tbl_df`>",1
+dplyr,inner_join.tbl_df,0,0,0,"class<`data.frame`, `tbl`, `tbl_df`>",1
+dplyr,inner_join.tbl_df,1,0,0,"class<`data.frame`, `tbl`, `tbl_df`>",1
+dplyr,inner_join.tbl_df,2,0,0,character,1
+dplyr,inner_join.tbl_df,2,0,1,null,1
+dplyr,inner_join.tbl_df,3,0,0,logical,1
+dplyr,inner_join.tbl_df,4,0,0,character[],1
+dplyr,inner_join.tbl_df,5,0,0,...,1
+dplyr,inner_join.tbl_df,6,0,0,null,1
+dplyr,intersect,-1,0,0,character[],1
+dplyr,intersect,-1,0,1,class<`data.frame`>,1
+dplyr,intersect,-1,0,2,"class<`data.frame`, `tbl`, `tbl_df`>",1
+dplyr,intersect,0,0,0,character[],1
+dplyr,intersect,0,0,1,"class<`character`, `dplyr_sel_vars`>",1
+dplyr,intersect,0,0,2,list<character>,1
+dplyr,intersect,0,0,3,class<`data.frame`>,1
+dplyr,intersect,0,0,4,"class<`data.frame`, `tbl`, `tbl_df`>",1
+dplyr,intersect,1,0,0,"class<`character`, `dplyr_sel_vars`>",1
+dplyr,intersect,1,0,1,^character[],1
+dplyr,intersect,1,0,2,class<`data.frame`>,1
+dplyr,intersect,1,0,3,"class<`data.frame`, `tbl`, `tbl_df`>",1
+dplyr,intersect,2,0,0,...,1
+dplyr,intersect_data_frame,-1,0,0,class<`data.frame`>,1
+dplyr,intersect_data_frame,-1,0,1,"class<`data.frame`, `tbl`, `tbl_df`>",1
+dplyr,intersect_data_frame,0,0,0,class<`data.frame`>,1
+dplyr,intersect_data_frame,0,0,1,"class<`data.frame`, `tbl`, `tbl_df`>",1
+dplyr,intersect_data_frame,1,0,0,class<`data.frame`>,1
+dplyr,intersect_data_frame,1,0,1,"class<`data.frame`, `tbl`, `tbl_df`>",1
+dplyr,intersect.data.frame,-1,0,0,class<`data.frame`>,1
+dplyr,intersect.data.frame,-1,0,1,"class<`data.frame`, `tbl`, `tbl_df`>",1
+dplyr,intersect.data.frame,0,0,0,class<`data.frame`>,1
+dplyr,intersect.data.frame,0,0,1,"class<`data.frame`, `tbl`, `tbl_df`>",1
+dplyr,intersect.data.frame,1,0,0,class<`data.frame`>,1
+dplyr,intersect.data.frame,1,0,1,"class<`data.frame`, `tbl`, `tbl_df`>",1
+dplyr,intersect.data.frame,2,0,0,...,1
+dplyr,intersect.default,-1,0,0,character[],1
+dplyr,intersect.default,0,0,0,character[],1
+dplyr,intersect.default,0,0,1,"class<`character`, `dplyr_sel_vars`>",1
+dplyr,intersect.default,0,0,2,list<character>,1
+dplyr,intersect.default,1,0,0,"class<`character`, `dplyr_sel_vars`>",1
+dplyr,intersect.default,1,0,1,^character[],1
+dplyr,intersect.default,2,0,0,...,1
+dplyr,is_fun_list,-1,0,0,logical,1
+dplyr,is_fun_list,0,0,0,character,1
+dplyr,is_fun_list,0,0,1,class<`formula`>,1
+dplyr,is_fun_list,0,0,2,class<`function`>,1
+dplyr,is_fun_list,0,0,3,list<any>,1
+dplyr,is_grouped_df,-1,0,0,logical,1
+dplyr,is_grouped_df,0,0,0,class<`data.frame`>,1
+dplyr,is_grouped_df,0,0,1,"class<`data.frame`, `grouped_df`, `tbl`, `tbl_df`>",1
+dplyr,is_grouped_df,0,0,2,"class<`data.frame`, `tbl`, `tbl_df`>",1
+dplyr,is_sel_vars,-1,0,0,logical,1
+dplyr,is_sel_vars,0,0,0,"class<`character`, `dplyr_sel_vars`>",1
+dplyr,join_vars,-1,0,0,list<character[] | integer[] | list<list<integer[]>>>,1
+dplyr,join_vars,-1,0,1,list<character[] | ^integer[] | list<list<integer[]>>>,1
+dplyr,join_vars,-1,0,2,list<character[] | ^integer[] | list<list<integer>>>,1
+dplyr,join_vars,0,0,0,"class<`character`, `dplyr_sel_vars`>",1
+dplyr,join_vars,1,0,0,"class<`character`, `dplyr_sel_vars`>",1
+dplyr,join_vars,2,0,0,list<character[]>,1
+dplyr,join_vars,3,0,0,list<character>,1
+dplyr,label_output_dataframe,-1,0,0,"class<`data.frame`, `grouped_df`, `tbl`, `tbl_df`>",1
+dplyr,label_output_dataframe,-1,0,1,"class<`data.frame`, `rowwise_df`, `tbl`, `tbl_df`>",1
+dplyr,label_output_dataframe,0,0,0,"class<`data.frame`, `tbl`, `tbl_df`>",1
+dplyr,label_output_dataframe,0,0,1,null,1
+dplyr,label_output_dataframe,1,0,0,"list<list<class<`data.frame`, `tbl`, `tbl_df`>>>",1
+dplyr,label_output_dataframe,1,0,1,list<list<class<`data.frame`>>>,1
+dplyr,label_output_dataframe,2,0,0,any,1
+dplyr,label_output_dataframe,3,0,0,any,1
+dplyr,label_output_list,-1,0,0,"class<`data.frame`, `rowwise_df`, `tbl`, `tbl_df`>",1
+dplyr,label_output_list,0,0,0,null,1
+dplyr,label_output_list,0,0,1,"class<`data.frame`, `tbl`, `tbl_df`>",1
+dplyr,label_output_list,1,0,0,"list<list<class<`anova`, `data.frame`>>>",1
+dplyr,label_output_list,1,0,1,list<list<integer[]>>,1
+dplyr,label_output_list,1,0,2,list<list<class<`lm`>>>,1
+dplyr,label_output_list,2,0,0,any,1
+dplyr,lag,-1,0,0,^double[],1
+dplyr,lag,-1,0,1,class<`factor`>,1
+dplyr,lag,0,0,0,double[],1
+dplyr,lag,0,0,1,class<`factor`>,1
+dplyr,lag,1,0,0,double,1
+dplyr,lag,2,0,0,null,1
+dplyr,lag,3,0,0,null,1
+dplyr,lag,3,0,1,integer[],1
+dplyr,lag,4,0,0,...,1
+dplyr,last,-1,0,0,integer,1
+dplyr,last,0,0,0,integer[],1
+dplyr,last,1,0,0,integer[],1
+dplyr,last,1,0,1,null,1
+dplyr,last,2,0,0,any,1
+dplyr,lead,-1,0,0,^double[],1
+dplyr,lead,0,0,0,double[],1
+dplyr,lead,1,0,0,double,1
+dplyr,lead,2,0,0,null,1
+dplyr,lead,3,0,0,null,1
+dplyr,lead,4,0,0,...,1
+dplyr,left_join,-1,0,0,class<`data.frame`>,1
+dplyr,left_join,-1,0,1,"class<`data.frame`, `tbl`, `tbl_df`>",1
+dplyr,left_join,-1,0,2,"class<`tbl`, `tbl_SQLiteConnection`, `tbl_dbi`, `tbl_lazy`, `tbl_sql`>",1
+dplyr,left_join,0,0,0,class<`data.frame`>,1
+dplyr,left_join,0,0,1,"class<`data.frame`, `tbl`, `tbl_df`>",1
+dplyr,left_join,0,0,2,"class<`tbl`, `tbl_SQLiteConnection`, `tbl_dbi`, `tbl_lazy`, `tbl_sql`>",1
+dplyr,left_join,1,0,0,class<`data.frame`>,1
+dplyr,left_join,1,0,1,"class<`data.frame`, `tbl`, `tbl_df`>",1
+dplyr,left_join,1,0,2,"class<`tbl`, `tbl_SQLiteConnection`, `tbl_dbi`, `tbl_lazy`, `tbl_sql`>",1
+dplyr,left_join,2,0,0,character[],1
+dplyr,left_join,2,0,1,null,1
+dplyr,left_join,3,0,0,any,1
+dplyr,left_join,4,0,0,any,1
+dplyr,left_join,5,0,0,...,1
+dplyr,left_join.data.frame,-1,0,0,class<`data.frame`>,1
+dplyr,left_join.data.frame,0,0,0,class<`data.frame`>,1
+dplyr,left_join.data.frame,1,0,0,class<`data.frame`>,1
+dplyr,left_join.data.frame,2,0,0,character[],1
+dplyr,left_join.data.frame,3,0,0,logical,1
+dplyr,left_join.data.frame,4,0,0,...,1
+dplyr,left_join_impl,-1,0,0,"class<`data.frame`, `tbl`, `tbl_df`>",1
+dplyr,left_join_impl,0,0,0,"class<`data.frame`, `tbl`, `tbl_df`>",1
+dplyr,left_join_impl,1,0,0,"class<`data.frame`, `tbl`, `tbl_df`>",1
+dplyr,left_join_impl,1,0,1,class<`data.frame`>,1
+dplyr,left_join_impl,2,0,0,integer[],1
+dplyr,left_join_impl,3,0,0,integer[],1
+dplyr,left_join_impl,4,0,0,integer[],1
+dplyr,left_join_impl,5,0,0,integer[],1
+dplyr,left_join_impl,6,0,0,logical,1
+dplyr,left_join_impl,7,0,0,environment,1
+dplyr,left_join.tbl_df,-1,0,0,"class<`data.frame`, `tbl`, `tbl_df`>",1
+dplyr,left_join.tbl_df,0,0,0,"class<`data.frame`, `tbl`, `tbl_df`>",1
+dplyr,left_join.tbl_df,1,0,0,"class<`data.frame`, `tbl`, `tbl_df`>",1
+dplyr,left_join.tbl_df,1,0,1,class<`data.frame`>,1
+dplyr,left_join.tbl_df,2,0,0,null,1
+dplyr,left_join.tbl_df,2,0,1,character[],1
+dplyr,left_join.tbl_df,3,0,0,any,1
+dplyr,left_join.tbl_df,4,0,0,character[],1
+dplyr,left_join.tbl_df,5,0,0,...,1
+dplyr,left_join.tbl_df,6,0,0,null,1
+dplyr,list_cols_warning,-1,0,0,character[],1
+dplyr,list_cols_warning,-1,0,1,integer[],1
+dplyr,list_cols_warning,0,0,0,"class<`data.frame`, `grouped_df`, `tbl`, `tbl_df`>",1
+dplyr,list_cols_warning,0,0,1,"class<`data.frame`, `tbl`, `tbl_df`>",1
+dplyr,list_cols_warning,1,0,0,character[],1
+dplyr,list_cols_warning,1,0,1,integer[],1
+dplyr,loc,-1,0,0,character,1
+dplyr,loc,0,0,0,class<`data.frame`>,1
+dplyr,location,-1,0,0,class<`location`>,1
+dplyr,location,0,0,0,class<`data.frame`>,1
+dplyr,make_tbl,-1,0,0,"class<`tbl`, `tbl_SQLiteConnection`, `tbl_dbi`, `tbl_lazy`, `tbl_sql`>",1
+dplyr,make_tbl,0,0,0,character[],1
+dplyr,make_tbl,1,0,0,...,1
+dplyr,manip_all,-1,0,0,list<any>,1
+dplyr,manip_all,0,0,0,class<`data.frame`>,1
+dplyr,manip_all,0,0,1,"class<`data.frame`, `tbl`, `tbl_df`>",1
+dplyr,manip_all,0,0,2,"class<`data.frame`, `grouped_df`, `tbl`, `tbl_df`>",1
+dplyr,manip_all,1,0,0,list<any>,1
+dplyr,manip_all,1,0,1,class<`function`>,1
+dplyr,manip_all,2,0,0,any,1
+dplyr,manip_all,3,0,0,any,1
+dplyr,manip_all,4,0,0,...,1
+dplyr,manip_all,5,0,0,logical,1
+dplyr,manip_apply_syms,-1,0,0,list<any>,1
+dplyr,manip_apply_syms,0,0,0,list<any>,1
+dplyr,manip_apply_syms,1,0,0,list<class<`name`>>,1
+dplyr,manip_apply_syms,2,0,0,class<`data.frame`>,1
+dplyr,manip_apply_syms,2,0,1,"class<`data.frame`, `tbl`, `tbl_df`>",1
+dplyr,manip_apply_syms,2,0,2,"class<`data.frame`, `grouped_df`, `tbl`, `tbl_df`>",1
+dplyr,manip_at,-1,0,0,list<any>,1
+dplyr,manip_at,0,0,0,class<`data.frame`>,1
+dplyr,manip_at,0,0,1,"class<`data.frame`, `tbl`, `tbl_df`>",1
+dplyr,manip_at,0,0,2,"class<`data.frame`, `grouped_df`, `tbl`, `tbl_df`>",1
+dplyr,manip_at,1,0,0,"class<`list`, `quosures`>",1
+dplyr,manip_at,1,0,1,character[],1
+dplyr,manip_at,2,0,0,list<any>,1
+dplyr,manip_at,2,0,1,class<`formula`>,1
+dplyr,manip_at,2,0,2,class<`function`>,1
+dplyr,manip_at,3,0,0,any,1
+dplyr,manip_at,4,0,0,any,1
+dplyr,manip_at,5,0,0,...,1
+dplyr,manip_at,6,0,0,logical,1
+dplyr,manip_if,-1,0,0,list<any>,1
+dplyr,manip_if,0,0,0,class<`data.frame`>,1
+dplyr,manip_if,0,0,1,"class<`data.frame`, `tbl`, `tbl_df`>",1
+dplyr,manip_if,1,0,0,class<`function`>,1
+dplyr,manip_if,2,0,0,list<any>,1
+dplyr,manip_if,2,0,1,class<`function`>,1
+dplyr,manip_if,3,0,0,any,1
+dplyr,manip_if,4,0,0,any,1
+dplyr,manip_if,5,0,0,...,1
+dplyr,manip_if,6,0,0,logical,1
+dplyr,map,-1,0,0,list<any>,1
+dplyr,map,0,0,0,list<any>,1
+dplyr,map,0,0,1,null,1
+dplyr,map,0,0,2,integer[],1
+dplyr,map,0,0,3,pairlist,1
+dplyr,map,0,0,4,character,1
+dplyr,map,0,0,5,"class<`list`, `quosures`>",1
+dplyr,map,1,0,0,class<`function`>,1
+dplyr,map,2,0,0,...,1
+dplyr,map2,-1,0,0,"list<class<`data.frame`, `tbl`, `tbl_df`>>",1
+dplyr,map2,-1,0,1,list<double[]>,1
+dplyr,map2,-1,0,2,list<null>,1
+dplyr,map2,-1,0,3,"list<list<class<`formula`, `quosure`>>>",1
+dplyr,map2,0,0,0,"list<class<`data.frame`, `tbl`, `tbl_df`>>",1
+dplyr,map2,0,0,1,integer[],1
+dplyr,map2,0,0,2,list<class<`formula`>>,1
+dplyr,map2,1,0,0,"list<class<`data.frame`, `tbl`, `tbl_df`>>",1
+dplyr,map2,1,0,1,"class<`list`, `quosures`>",1
+dplyr,map2,1,0,2,integer[],1
+dplyr,map2,2,0,0,class<`function`>,1
+dplyr,map2,2,0,1,"class<`function`, `rlang_lambda_function`>",1
+dplyr,map2,3,0,0,...,1
+dplyr,map2_int,-1,0,0,integer[],1
+dplyr,map2_int,0,0,0,integer[],1
+dplyr,map2_int,1,0,0,"class<`list`, `quosures`>",1
+dplyr,map2_int,2,0,0,class<`function`>,1
+dplyr,map2_int,3,0,0,...,1
+dplyr,map_chr,-1,0,0,character[],1
+dplyr,map_chr,0,0,0,list<any>,1
+dplyr,map_chr,0,0,1,null,1
+dplyr,map_chr,1,0,0,class<`function`>,1
+dplyr,map_chr,2,0,0,...,1
+dplyr,map_if,-1,0,0,list<class<`name`>>,1
+dplyr,map_if,-1,0,1,null,1
+dplyr,map_if,0,0,0,list<class<`name`>>,1
+dplyr,map_if,0,0,1,null,1
+dplyr,map_if,1,0,0,class<`function`>,1
+dplyr,map_if,2,0,0,class<`function`>,1
+dplyr,map_if,3,0,0,...,1
+dplyr,map_lgl,-1,0,0,logical[],1
+dplyr,map_lgl,0,0,0,list<class<`data.frame`>>,1
+dplyr,map_lgl,0,0,1,list<class<`formula`>>,1
+dplyr,map_lgl,0,0,2,list<class<`function`>>,1
+dplyr,map_lgl,0,0,3,null,1
+dplyr,map_lgl,0,0,4,list<class<`name`>>,1
+dplyr,map_lgl,0,0,5,"class<`data.frame`, `tbl`, `tbl_df`>",1
+dplyr,map_lgl,0,0,6,"class<`list`, `quosures`>",1
+dplyr,map_lgl,0,0,7,"class<`data.frame`, `grouped_df`, `tbl`, `tbl_df`>",1
+dplyr,map_lgl,1,0,0,class<`function`>,1
+dplyr,map_lgl,2,0,0,...,1
+dplyr,map_mold,-1,0,0,character[],1
+dplyr,map_mold,-1,0,1,logical[],1
+dplyr,map_mold,0,0,0,list<any>,1
+dplyr,map_mold,0,0,1,null,1
+dplyr,map_mold,0,0,2,"class<`data.frame`, `tbl`, `tbl_df`>",1
+dplyr,map_mold,0,0,3,"class<`list`, `quosures`>",1
+dplyr,map_mold,0,0,4,"class<`data.frame`, `grouped_df`, `tbl`, `tbl_df`>",1
+dplyr,map_mold,1,0,0,class<`function`>,1
+dplyr,map_mold,2,0,0,character,1
+dplyr,map_mold,2,0,1,logical,1
+dplyr,map_mold,3,0,0,...,1
+dplyr,match_up,-1,0,0,class<`matrix`>,1
+dplyr,match_up,0,0,0,character[],1
+dplyr,match_up,1,0,0,character[],1
+dplyr,match_vars,-1,0,0,integer[],1
+dplyr,match_vars,0,0,0,character[],1
+dplyr,match_vars,0,0,1,integer[],1
+dplyr,match_vars,1,0,0,any,1
+dplyr,materialize_binding,-1,0,0,class<`factor`>,1
+dplyr,materialize_binding,-1,0,1,class<`lm`>,1
+dplyr,materialize_binding,-1,0,2,^double[],1
+dplyr,materialize_binding,0,0,0,integer,1
+dplyr,materialize_binding,1,0,0,externalptr,1
+dplyr,minimal_names,-1,0,0,character[],1
+dplyr,minimal_names,0,0,0,character[],1
+dplyr,minimal_names,1,0,0,any,1
+dplyr,min_rank,-1,0,0,^integer[],1
+dplyr,min_rank,0,0,0,^double[],1
+dplyr,mutate,-1,0,0,any,1
+dplyr,mutate,0,0,0,class<`data.frame`>,1
+dplyr,mutate,0,0,1,"class<`data.frame`, `grouped_df`, `tbl`, `tbl_df`>",1
+dplyr,mutate,0,0,2,"class<`data.frame`, `tbl`, `tbl_df`>",1
+dplyr,mutate,0,0,3,"class<`tbl`, `tbl_SQLiteConnection`, `tbl_dbi`, `tbl_lazy`, `tbl_sql`>",1
+dplyr,mutate,1,0,0,...,1
+dplyr,mutate_at,-1,0,0,"class<`data.frame`, `grouped_df`, `tbl`, `tbl_df`>",1
+dplyr,mutate_at,-1,0,1,"class<`data.frame`, `tbl`, `tbl_df`>",1
+dplyr,mutate_at,0,0,0,"class<`data.frame`, `grouped_df`, `tbl`, `tbl_df`>",1
+dplyr,mutate_at,0,0,1,"class<`data.frame`, `tbl`, `tbl_df`>",1
+dplyr,mutate_at,1,0,0,"class<`list`, `quosures`>",1
+dplyr,mutate_at,1,0,1,character[],1
+dplyr,mutate_at,2,0,0,class<`function`>,1
+dplyr,mutate_at,2,0,1,class<`formula`>,1
+dplyr,mutate_at,3,0,0,...,1
+dplyr,mutate_at,4,0,0,null,1
+dplyr,mutate.data.frame,-1,0,0,class<`data.frame`>,1
+dplyr,mutate.data.frame,0,0,0,class<`data.frame`>,1
+dplyr,mutate.data.frame,1,0,0,...,1
+dplyr,mutate_if,-1,0,0,"class<`data.frame`, `tbl`, `tbl_df`>",1
+dplyr,mutate_if,0,0,0,"class<`data.frame`, `tbl`, `tbl_df`>",1
+dplyr,mutate_if,1,0,0,class<`function`>,1
+dplyr,mutate_if,2,0,0,class<`function`>,1
+dplyr,mutate_if,2,0,1,list<class<`formula`>>,1
+dplyr,mutate_if,2,0,2,list<class<`function`>>,1
+dplyr,mutate_if,3,0,0,...,1
+dplyr,mutate_impl,-1,0,0,any,1
+dplyr,mutate_impl,0,0,0,"class<`data.frame`, `grouped_df`, `tbl`, `tbl_df`>",1
+dplyr,mutate_impl,0,0,1,"class<`data.frame`, `tbl`, `tbl_df`>",1
+dplyr,mutate_impl,1,0,0,"class<`list`, `quosures`>",1
+dplyr,mutate_impl,2,0,0,environment,1
+dplyr,mutate.tbl_df,-1,0,0,any,1
+dplyr,mutate.tbl_df,0,0,0,"class<`data.frame`, `grouped_df`, `tbl`, `tbl_df`>",1
+dplyr,mutate.tbl_df,0,0,1,"class<`data.frame`, `tbl`, `tbl_df`>",1
+dplyr,mutate.tbl_df,1,0,0,...,1
+dplyr,n,-1,0,0,integer,1
+dplyr,na_if,-1,0,0,^character[],1
+dplyr,na_if,-1,0,1,^double[],1
+dplyr,na_if,0,0,0,^character[],1
+dplyr,na_if,0,0,1,double[],1
+dplyr,na_if,1,0,0,character,1
+dplyr,na_if,1,0,1,double,1
+dplyr,na_if,1,0,2,integer[],1
+dplyr,named_args,-1,0,0,logical,1
+dplyr,named_args,0,0,0,"class<`list`, `quosures`>",1
+dplyr,n_distinct,-1,0,0,integer,1
+dplyr,n_distinct,0,0,0,...,1
+dplyr,n_distinct,1,0,0,logical,1
+dplyr,n_distinct_multi,-1,0,0,integer,1
+dplyr,n_distinct_multi,0,0,0,list<integer[]>,1
+dplyr,n_distinct_multi,1,0,0,logical,1
+dplyr,near,-1,0,0,logical,1
+dplyr,near,0,0,0,double,1
+dplyr,near,1,0,0,double,1
+dplyr,near,2,0,0,double,1
+dplyr,nest_join,-1,0,0,"class<`data.frame`, `tbl`, `tbl_df`>",1
+dplyr,nest_join,0,0,0,"class<`data.frame`, `tbl`, `tbl_df`>",1
+dplyr,nest_join,1,0,0,"class<`data.frame`, `tbl`, `tbl_df`>",1
+dplyr,nest_join,2,0,0,null,1
+dplyr,nest_join,3,0,0,logical,1
+dplyr,nest_join,4,0,0,logical,1
+dplyr,nest_join,5,0,0,null,1
+dplyr,nest_join,6,0,0,...,1
+dplyr,nest_join_impl,-1,0,0,"class<`data.frame`, `tbl`, `tbl_df`>",1
+dplyr,nest_join_impl,0,0,0,"class<`data.frame`, `tbl`, `tbl_df`>",1
+dplyr,nest_join_impl,1,0,0,"class<`data.frame`, `tbl`, `tbl_df`>",1
+dplyr,nest_join_impl,2,0,0,integer,1
+dplyr,nest_join_impl,3,0,0,integer,1
+dplyr,nest_join_impl,4,0,0,integer,1
+dplyr,nest_join_impl,5,0,0,character,1
+dplyr,nest_join_impl,6,0,0,environment,1
+dplyr,nest_join.tbl_df,-1,0,0,"class<`data.frame`, `tbl`, `tbl_df`>",1
+dplyr,nest_join.tbl_df,0,0,0,"class<`data.frame`, `tbl`, `tbl_df`>",1
+dplyr,nest_join.tbl_df,1,0,0,"class<`data.frame`, `tbl`, `tbl_df`>",1
+dplyr,nest_join.tbl_df,2,0,0,null,1
+dplyr,nest_join.tbl_df,3,0,0,logical,1
+dplyr,nest_join.tbl_df,4,0,0,logical,1
+dplyr,nest_join.tbl_df,5,0,0,null,1
+dplyr,nest_join.tbl_df,6,0,0,...,1
+dplyr,new_funs,-1,0,0,class<`fun_list`>,1
+dplyr,new_funs,0,0,0,"list<class<`formula`, `quosure`>>",1
+dplyr,new_grouped_df,-1,0,0,"class<`data.frame`, `grouped_df`, `tbl`, `tbl_df`>",1
+dplyr,new_grouped_df,0,0,0,"class<`data.frame`, `tbl`, `tbl_df`>",1
+dplyr,new_grouped_df,1,0,0,"class<`data.frame`, `tbl`, `tbl_df`>",1
+dplyr,new_grouped_df,2,0,0,...,1
+dplyr,new_grouped_df,3,0,0,character[],1
+dplyr,new_sel_vars,-1,0,0,"class<`character`, `dplyr_sel_vars`>",1
+dplyr,new_sel_vars,0,0,0,character[],1
+dplyr,new_sel_vars,1,0,0,character[],1
+dplyr,n_groups,-1,0,0,integer,1
+dplyr,n_groups,0,0,0,"class<`data.frame`, `grouped_df`, `tbl`, `tbl_df`>",1
+dplyr,n_groups.grouped_df,-1,0,0,integer,1
+dplyr,n_groups.grouped_df,0,0,0,"class<`data.frame`, `grouped_df`, `tbl`, `tbl_df`>",1
+dplyr,n_name,-1,0,0,character,1
+dplyr,n_name,0,0,0,character[],1
+dplyr,n_name,1,0,0,character,1
+dplyr,node_walk_replace,-1,0,0,null,1
+dplyr,node_walk_replace,0,0,0,pairlist,1
+dplyr,node_walk_replace,1,0,0,class<`name`>,1
+dplyr,node_walk_replace,2,0,0,class<`name`>,1
+dplyr,now,-1,0,0,double,1
+dplyr,ntext,-1,0,0,character,1
+dplyr,ntext,0,0,0,integer,1
+dplyr,ntext,1,0,0,character,1
+dplyr,ntext,2,0,0,character,1
+dplyr,nth,-1,0,0,integer,1
+dplyr,nth,-1,0,1,null,1
+dplyr,nth,0,0,0,integer[],1
+dplyr,nth,1,0,0,double,1
+dplyr,nth,2,0,0,any,1
+dplyr,nth,3,0,0,any,1
+dplyr,ntile,-1,0,0,^integer[],1
+dplyr,ntile,0,0,0,^double[],1
+dplyr,ntile,1,0,0,double,1
+dplyr,order_by,-1,0,0,double[],1
+dplyr,order_by,0,0,0,integer[],1
+dplyr,order_by,1,0,0,any,1
+dplyr,paste_line,-1,0,0,character,1
+dplyr,paste_line,0,0,0,...,1
+dplyr,percent_rank,-1,0,0,^double[],1
+dplyr,percent_rank,0,0,0,^double[],1
+dplyr,plfloc,-1,0,0,character[],1
+dplyr,plfloc,0,0,0,list<character[] | integer[]>,1
+dplyr,plfloc,0,0,1,list<character[]>,1
+dplyr,probe,-1,0,0,logical[],1
+dplyr,probe,0,0,0,null,1
+dplyr,probe,0,0,1,list<class<`name`>>,1
+dplyr,probe,1,0,0,class<`function`>,1
+dplyr,probe,2,0,0,...,1
+dplyr,progress_estimated,-1,0,0,"class<`Progress`, `R6`>",1
+dplyr,progress_estimated,0,0,0,double,1
+dplyr,progress_estimated,1,0,0,double,1
+dplyr,pull,-1,0,0,character[],1
+dplyr,pull,-1,0,1,^double[],1
+dplyr,pull,0,0,0,"class<`data.frame`, `tbl`, `tbl_df`>",1
+dplyr,pull,0,0,1,"class<`data.frame`, `grouped_df`, `tbl`, `tbl_df`>",1
+dplyr,pull,0,0,2,class<`data.frame`>,1
+dplyr,pull,0,0,3,"class<`tbl`, `tbl_SQLiteConnection`, `tbl_dbi`, `tbl_lazy`, `tbl_sql`>",1
+dplyr,pull,1,0,0,any,1
+dplyr,pull.data.frame,-1,0,0,character[],1
+dplyr,pull.data.frame,-1,0,1,^double[],1
+dplyr,pull.data.frame,0,0,0,"class<`data.frame`, `tbl`, `tbl_df`>",1
+dplyr,pull.data.frame,0,0,1,"class<`data.frame`, `grouped_df`, `tbl`, `tbl_df`>",1
+dplyr,pull.data.frame,0,0,2,class<`data.frame`>,1
+dplyr,pull.data.frame,1,0,0,any,1
+dplyr,quo_reduce,-1,0,0,"class<`formula`, `quosure`>",1
+dplyr,quo_reduce,0,0,0,...,1
+dplyr,quo_reduce,1,0,0,class<`name`>,1
+dplyr,recode,-1,0,0,^character[],1
+dplyr,recode,-1,0,1,class<`factor`>,1
+dplyr,recode,-1,0,2,^integer[],1
+dplyr,recode,0,0,0,character[],1
+dplyr,recode,0,0,1,^integer[],1
+dplyr,recode,0,0,2,double[],1
+dplyr,recode,0,0,3,class<`factor`>,1
+dplyr,recode,1,0,0,...,1
+dplyr,recode,2,0,0,null,1
+dplyr,recode,2,0,1,character[],1
+dplyr,recode,3,0,0,null,1
+dplyr,recode,3,0,1,character,1
+dplyr,recode.character,-1,0,0,^character[],1
+dplyr,recode.character,0,0,0,character[],1
+dplyr,recode.character,1,0,0,...,1
+dplyr,recode.character,2,0,0,null,1
+dplyr,recode.character,3,0,0,null,1
+dplyr,recode_default,-1,0,0,character[],1
+dplyr,recode_default,-1,0,1,^integer[],1
+dplyr,recode_default,-1,0,2,null,1
+dplyr,recode_default,0,0,0,character[],1
+dplyr,recode_default,0,0,1,class<`factor`>,1
+dplyr,recode_default,0,0,2,double[],1
+dplyr,recode_default,0,0,3,^integer[],1
+dplyr,recode_default,1,0,0,null,1
+dplyr,recode_default,1,0,1,character[],1
+dplyr,recode_default,2,0,0,any,1
+dplyr,recode_default.default,-1,0,0,character[],1
+dplyr,recode_default.default,-1,0,1,^integer[],1
+dplyr,recode_default.default,-1,0,2,null,1
+dplyr,recode_default.default,0,0,0,character[],1
+dplyr,recode_default.default,0,0,1,double[],1
+dplyr,recode_default.default,0,0,2,^integer[],1
+dplyr,recode_default.default,1,0,0,null,1
+dplyr,recode_default.default,1,0,1,character,1
+dplyr,recode_default.default,2,0,0,^character[],1
+dplyr,recode_default.default,2,0,1,^integer[],1
+dplyr,recode_default.factor,-1,0,0,character[],1
+dplyr,recode_default.factor,0,0,0,class<`factor`>,1
+dplyr,recode_default.factor,1,0,0,character[],1
+dplyr,recode_default.factor,1,0,1,null,1
+dplyr,recode_default.factor,2,0,0,any,1
+dplyr,recode_factor,-1,0,0,class<`factor`>,1
+dplyr,recode_factor,0,0,0,character[],1
+dplyr,recode_factor,0,0,1,class<`factor`>,1
+dplyr,recode_factor,0,0,2,^integer[],1
+dplyr,recode_factor,1,0,0,...,1
+dplyr,recode_factor,2,0,0,null,1
+dplyr,recode_factor,2,0,1,character,1
+dplyr,recode_factor,3,0,0,null,1
+dplyr,recode_factor,3,0,1,character,1
+dplyr,recode_factor,4,0,0,logical,1
+dplyr,recode.factor,-1,0,0,class<`factor`>,1
+dplyr,recode.factor,0,0,0,class<`factor`>,1
+dplyr,recode.factor,1,0,0,...,1
+dplyr,recode.factor,2,0,0,character[],1
+dplyr,recode.factor,2,0,1,null,1
+dplyr,recode.factor,3,0,0,null,1
+dplyr,recode.numeric,-1,0,0,^character[],1
+dplyr,recode.numeric,-1,0,1,^integer[],1
+dplyr,recode.numeric,0,0,0,^integer[],1
+dplyr,recode.numeric,0,0,1,double[],1
+dplyr,recode.numeric,1,0,0,...,1
+dplyr,recode.numeric,2,0,0,character,1
+dplyr,recode.numeric,2,0,1,null,1
+dplyr,recode.numeric,3,0,0,null,1
+dplyr,recode.numeric,3,0,1,character,1
+dplyr,reconstruct_join,-1,0,0,"class<`data.frame`, `tbl`, `tbl_df`>",1
+dplyr,reconstruct_join,0,0,0,"class<`data.frame`, `tbl`, `tbl_df`>",1
+dplyr,reconstruct_join,1,0,0,"class<`data.frame`, `tbl`, `tbl_df`>",1
+dplyr,reconstruct_join,2,0,0,any,1
+dplyr,reconstruct_set,-1,0,0,class<`data.frame`>,1
+dplyr,reconstruct_set,-1,0,1,"class<`data.frame`, `tbl`, `tbl_df`>",1
+dplyr,reconstruct_set,0,0,0,class<`data.frame`>,1
+dplyr,reconstruct_set,0,0,1,"class<`data.frame`, `tbl`, `tbl_df`>",1
+dplyr,reconstruct_set,1,0,0,class<`data.frame`>,1
+dplyr,reconstruct_set,1,0,1,"class<`data.frame`, `tbl`, `tbl_df`>",1
+dplyr,reduce,-1,0,0,class<`call`>,1
+dplyr,reduce,0,0,0,"class<`list`, `quosures`>",1
+dplyr,reduce,1,0,0,class<`function`>,1
+dplyr,reduce,2,0,0,...,1
+dplyr,reduce,3,0,0,any,1
+dplyr,regroup,-1,0,0,"class<`data.frame`, `tbl`, `tbl_df`>",1
+dplyr,regroup,0,0,0,"class<`data.frame`, `tbl`, `tbl_df`>",1
+dplyr,regroup,1,0,0,environment,1
+dplyr,rename,-1,0,0,class<`data.frame`>,1
+dplyr,rename,-1,0,1,"class<`data.frame`, `tbl`, `tbl_df`>",1
+dplyr,rename,0,0,0,class<`data.frame`>,1
+dplyr,rename,0,0,1,"class<`data.frame`, `tbl`, `tbl_df`>",1
+dplyr,rename,1,0,0,...,1
+dplyr,rename_all,-1,0,0,class<`data.frame`>,1
+dplyr,rename_all,0,0,0,class<`data.frame`>,1
+dplyr,rename_all,1,0,0,class<`function`>,1
+dplyr,rename_all,2,0,0,...,1
+dplyr,rename_at,-1,0,0,class<`data.frame`>,1
+dplyr,rename_at,0,0,0,class<`data.frame`>,1
+dplyr,rename_at,1,0,0,"class<`list`, `quosures`>",1
+dplyr,rename_at,2,0,0,class<`function`>,1
+dplyr,rename_at,3,0,0,...,1
+dplyr,rename.data.frame,-1,0,0,class<`data.frame`>,1
+dplyr,rename.data.frame,-1,0,1,"class<`data.frame`, `tbl`, `tbl_df`>",1
+dplyr,rename.data.frame,0,0,0,class<`data.frame`>,1
+dplyr,rename.data.frame,0,0,1,"class<`data.frame`, `tbl`, `tbl_df`>",1
+dplyr,rename.data.frame,1,0,0,...,1
+dplyr,rename_if,-1,0,0,class<`data.frame`>,1
+dplyr,rename_if,0,0,0,class<`data.frame`>,1
+dplyr,rename_if,1,0,0,class<`function`>,1
+dplyr,rename_if,2,0,0,class<`function`>,1
+dplyr,rename_if,3,0,0,...,1
+dplyr,replace_with,-1,0,0,^character[],1
+dplyr,replace_with,-1,0,1,class<`factor`>,1
+dplyr,replace_with,-1,0,2,^double[],1
+dplyr,replace_with,-1,0,3,null,1
+dplyr,replace_with,0,0,0,^character[],1
+dplyr,replace_with,0,0,1,null,1
+dplyr,replace_with,0,0,2,class<`factor`>,1
+dplyr,replace_with,0,0,3,^double[],1
+dplyr,replace_with,1,0,0,any,1
+dplyr,replace_with,2,0,0,null,1
+dplyr,replace_with,2,0,1,^character[],1
+dplyr,replace_with,2,0,2,class<`factor`>,1
+dplyr,replace_with,2,0,3,^double[],1
+dplyr,replace_with,3,0,0,any,1
+dplyr,replace_with,4,0,0,any,1
+dplyr,right_join,-1,0,0,"class<`data.frame`, `tbl`, `tbl_df`>",1
+dplyr,right_join,0,0,0,"class<`data.frame`, `tbl`, `tbl_df`>",1
+dplyr,right_join,1,0,0,"class<`data.frame`, `tbl`, `tbl_df`>",1
+dplyr,right_join,2,0,0,null,1
+dplyr,right_join,3,0,0,logical,1
+dplyr,right_join,4,0,0,any,1
+dplyr,right_join,5,0,0,...,1
+dplyr,right_join_impl,-1,0,0,"class<`data.frame`, `tbl`, `tbl_df`>",1
+dplyr,right_join_impl,0,0,0,"class<`data.frame`, `tbl`, `tbl_df`>",1
+dplyr,right_join_impl,1,0,0,"class<`data.frame`, `tbl`, `tbl_df`>",1
+dplyr,right_join_impl,2,0,0,integer,1
+dplyr,right_join_impl,3,0,0,integer,1
+dplyr,right_join_impl,4,0,0,integer,1
+dplyr,right_join_impl,5,0,0,integer[],1
+dplyr,right_join_impl,6,0,0,logical,1
+dplyr,right_join_impl,7,0,0,environment,1
+dplyr,right_join.tbl_df,-1,0,0,"class<`data.frame`, `tbl`, `tbl_df`>",1
+dplyr,right_join.tbl_df,0,0,0,"class<`data.frame`, `tbl`, `tbl_df`>",1
+dplyr,right_join.tbl_df,1,0,0,"class<`data.frame`, `tbl`, `tbl_df`>",1
+dplyr,right_join.tbl_df,2,0,0,null,1
+dplyr,right_join.tbl_df,3,0,0,logical,1
+dplyr,right_join.tbl_df,4,0,0,character[],1
+dplyr,right_join.tbl_df,5,0,0,...,1
+dplyr,right_join.tbl_df,6,0,0,null,1
+dplyr,row_number,-1,0,0,^integer[],1
+dplyr,row_number,0,0,0,any,1
+dplyr,rowwise,-1,0,0,"class<`data.frame`, `rowwise_df`, `tbl`, `tbl_df`>",1
+dplyr,rowwise,0,0,0,class<`data.frame`>,1
+dplyr,rowwise,0,0,1,"class<`data.frame`, `tbl`, `tbl_df`>",1
+dplyr,same_src,-1,0,0,logical,1
+dplyr,same_src,0,0,0,"class<`data.frame`, `tbl`, `tbl_df`>",1
+dplyr,same_src,0,0,1,"class<`src`, `src_SQLiteConnection`, `src_dbi`, `src_sql`>",1
+dplyr,same_src,0,0,2,"class<`tbl`, `tbl_SQLiteConnection`, `tbl_dbi`, `tbl_lazy`, `tbl_sql`>",1
+dplyr,same_src,1,0,0,"class<`data.frame`, `tbl`, `tbl_df`>",1
+dplyr,same_src,1,0,1,class<`data.frame`>,1
+dplyr,same_src,1,0,2,"class<`src`, `src_SQLiteConnection`, `src_dbi`, `src_sql`>",1
+dplyr,same_src,1,0,3,"class<`tbl`, `tbl_SQLiteConnection`, `tbl_dbi`, `tbl_lazy`, `tbl_sql`>",1
+dplyr,same_src.data.frame,-1,0,0,logical,1
+dplyr,same_src.data.frame,0,0,0,"class<`data.frame`, `tbl`, `tbl_df`>",1
+dplyr,same_src.data.frame,1,0,0,"class<`data.frame`, `tbl`, `tbl_df`>",1
+dplyr,same_src.data.frame,1,0,1,class<`data.frame`>,1
+dplyr,sample_frac,-1,0,0,class<`data.frame`>,1
+dplyr,sample_frac,-1,0,1,"class<`data.frame`, `grouped_df`, `tbl`, `tbl_df`>",1
+dplyr,sample_frac,-1,0,2,"class<`data.frame`, `tbl`, `tbl_df`>",1
+dplyr,sample_frac,0,0,0,class<`data.frame`>,1
+dplyr,sample_frac,0,0,1,"class<`data.frame`, `grouped_df`, `tbl`, `tbl_df`>",1
+dplyr,sample_frac,0,0,2,"class<`data.frame`, `tbl`, `tbl_df`>",1
+dplyr,sample_frac,1,0,0,double,1
+dplyr,sample_frac,2,0,0,logical,1
+dplyr,sample_frac,3,0,0,any,1
+dplyr,sample_frac,4,0,0,null,1
+dplyr,sample_frac,5,0,0,...,1
+dplyr,sample_frac.data.frame,-1,0,0,class<`data.frame`>,1
+dplyr,sample_frac.data.frame,-1,0,1,"class<`data.frame`, `grouped_df`, `tbl`, `tbl_df`>",1
+dplyr,sample_frac.data.frame,-1,0,2,"class<`data.frame`, `tbl`, `tbl_df`>",1
+dplyr,sample_frac.data.frame,0,0,0,class<`data.frame`>,1
+dplyr,sample_frac.data.frame,0,0,1,"class<`data.frame`, `grouped_df`, `tbl`, `tbl_df`>",1
+dplyr,sample_frac.data.frame,0,0,2,"class<`data.frame`, `tbl`, `tbl_df`>",1
+dplyr,sample_frac.data.frame,1,0,0,double,1
+dplyr,sample_frac.data.frame,2,0,0,logical,1
+dplyr,sample_frac.data.frame,3,0,0,any,1
+dplyr,sample_frac.data.frame,4,0,0,null,1
+dplyr,sample_frac.data.frame,5,0,0,...,1
+dplyr,sample_n,-1,0,0,class<`data.frame`>,1
+dplyr,sample_n,-1,0,1,"class<`data.frame`, `grouped_df`, `tbl`, `tbl_df`>",1
+dplyr,sample_n,-1,0,2,"class<`data.frame`, `tbl`, `tbl_df`>",1
+dplyr,sample_n,0,0,0,class<`data.frame`>,1
+dplyr,sample_n,0,0,1,"class<`data.frame`, `grouped_df`, `tbl`, `tbl_df`>",1
+dplyr,sample_n,0,0,2,"class<`data.frame`, `tbl`, `tbl_df`>",1
+dplyr,sample_n,1,0,0,double,1
+dplyr,sample_n,2,0,0,logical,1
+dplyr,sample_n,3,0,0,any,1
+dplyr,sample_n,4,0,0,null,1
+dplyr,sample_n,5,0,0,...,1
+dplyr,sample_n.data.frame,-1,0,0,class<`data.frame`>,1
+dplyr,sample_n.data.frame,-1,0,1,"class<`data.frame`, `grouped_df`, `tbl`, `tbl_df`>",1
+dplyr,sample_n.data.frame,-1,0,2,"class<`data.frame`, `tbl`, `tbl_df`>",1
+dplyr,sample_n.data.frame,0,0,0,class<`data.frame`>,1
+dplyr,sample_n.data.frame,0,0,1,"class<`data.frame`, `grouped_df`, `tbl`, `tbl_df`>",1
+dplyr,sample_n.data.frame,0,0,2,"class<`data.frame`, `tbl`, `tbl_df`>",1
+dplyr,sample_n.data.frame,1,0,0,double,1
+dplyr,sample_n.data.frame,2,0,0,logical,1
+dplyr,sample_n.data.frame,3,0,0,any,1
+dplyr,sample_n.data.frame,4,0,0,null,1
+dplyr,sample_n.data.frame,5,0,0,...,1
+dplyr,select,-1,0,0,class<`data.frame`>,1
+dplyr,select,-1,0,1,"class<`data.frame`, `grouped_df`, `tbl`, `tbl_df`>",1
+dplyr,select,-1,0,2,"class<`data.frame`, `tbl`, `tbl_df`>",1
+dplyr,select,-1,0,3,class<`tbl_cube`>,1
+dplyr,select,-1,0,4,"class<`tbl`, `tbl_SQLiteConnection`, `tbl_dbi`, `tbl_lazy`, `tbl_sql`>",1
+dplyr,select,0,0,0,class<`data.frame`>,1
+dplyr,select,0,0,1,"class<`data.frame`, `grouped_df`, `tbl`, `tbl_df`>",1
+dplyr,select,0,0,2,"class<`data.frame`, `tbl`, `tbl_df`>",1
+dplyr,select,0,0,3,class<`tbl_cube`>,1
+dplyr,select,0,0,4,"class<`tbl`, `tbl_SQLiteConnection`, `tbl_dbi`, `tbl_lazy`, `tbl_sql`>",1
+dplyr,select,1,0,0,...,1
+dplyr,select_all,-1,0,0,class<`data.frame`>,1
+dplyr,select_all,0,0,0,class<`data.frame`>,1
+dplyr,select_all,1,0,0,character,1
+dplyr,select_all,1,0,1,class<`function`>,1
+dplyr,select_all,1,0,2,list<any>,1
+dplyr,select_all,2,0,0,...,1
+dplyr,select_at,-1,0,0,class<`data.frame`>,1
+dplyr,select_at,-1,0,1,"class<`data.frame`, `tbl`, `tbl_df`>",1
+dplyr,select_at,0,0,0,class<`data.frame`>,1
+dplyr,select_at,0,0,1,"class<`data.frame`, `tbl`, `tbl_df`>",1
+dplyr,select_at,1,0,0,"class<`list`, `quosures`>",1
+dplyr,select_at,1,0,1,character,1
+dplyr,select_at,2,0,0,class<`function`>,1
+dplyr,select_at,2,0,1,list<any>,1
+dplyr,select_at,3,0,0,...,1
+dplyr,select.data.frame,-1,0,0,class<`data.frame`>,1
+dplyr,select.data.frame,-1,0,1,"class<`data.frame`, `tbl`, `tbl_df`>",1
+dplyr,select.data.frame,0,0,0,class<`data.frame`>,1
+dplyr,select.data.frame,0,0,1,"class<`data.frame`, `tbl`, `tbl_df`>",1
+dplyr,select.data.frame,1,0,0,...,1
+dplyr,.select_grouped_df,-1,0,0,"class<`data.frame`, `grouped_df`, `tbl`, `tbl_df`>",1
+dplyr,.select_grouped_df,0,0,0,"class<`data.frame`, `grouped_df`, `tbl`, `tbl_df`>",1
+dplyr,.select_grouped_df,1,0,0,...,1
+dplyr,.select_grouped_df,2,0,0,logical,1
+dplyr,select.grouped_df,-1,0,0,"class<`data.frame`, `grouped_df`, `tbl`, `tbl_df`>",1
+dplyr,select.grouped_df,0,0,0,"class<`data.frame`, `grouped_df`, `tbl`, `tbl_df`>",1
+dplyr,select.grouped_df,1,0,0,...,1
+dplyr,select_if,-1,0,0,class<`data.frame`>,1
+dplyr,select_if,-1,0,1,"class<`data.frame`, `tbl`, `tbl_df`>",1
+dplyr,select_if,0,0,0,class<`data.frame`>,1
+dplyr,select_if,0,0,1,"class<`data.frame`, `tbl`, `tbl_df`>",1
+dplyr,select_if,1,0,0,class<`function`>,1
+dplyr,select_if,2,0,0,class<`function`>,1
+dplyr,select_if,2,0,1,list<any>,1
+dplyr,select_if,3,0,0,...,1
+dplyr,select_impl,-1,0,0,class<`data.frame`>,1
+dplyr,select_impl,-1,0,1,"class<`data.frame`, `grouped_df`, `tbl`, `tbl_df`>",1
+dplyr,select_impl,-1,0,2,"class<`data.frame`, `tbl`, `tbl_df`>",1
+dplyr,select_impl,0,0,0,class<`data.frame`>,1
+dplyr,select_impl,0,0,1,"class<`data.frame`, `grouped_df`, `tbl`, `tbl_df`>",1
+dplyr,select_impl,0,0,2,"class<`data.frame`, `tbl`, `tbl_df`>",1
+dplyr,select_impl,1,0,0,character[],1
+dplyr,select.tbl_cube,-1,0,0,class<`tbl_cube`>,1
+dplyr,select.tbl_cube,0,0,0,class<`tbl_cube`>,1
+dplyr,select.tbl_cube,1,0,0,...,1
+dplyr,semi_join,-1,0,0,"class<`data.frame`, `tbl`, `tbl_df`>",1
+dplyr,semi_join,0,0,0,"class<`data.frame`, `tbl`, `tbl_df`>",1
+dplyr,semi_join,1,0,0,"class<`data.frame`, `tbl`, `tbl_df`>",1
+dplyr,semi_join,1,0,1,class<`data.frame`>,1
+dplyr,semi_join,2,0,0,null,1
+dplyr,semi_join,2,0,1,character,1
+dplyr,semi_join,3,0,0,logical,1
+dplyr,semi_join,4,0,0,...,1
+dplyr,semi_join_impl,-1,0,0,"class<`data.frame`, `tbl`, `tbl_df`>",1
+dplyr,semi_join_impl,0,0,0,"class<`data.frame`, `tbl`, `tbl_df`>",1
+dplyr,semi_join_impl,1,0,0,"class<`data.frame`, `tbl`, `tbl_df`>",1
+dplyr,semi_join_impl,1,0,1,class<`data.frame`>,1
+dplyr,semi_join_impl,2,0,0,character,1
+dplyr,semi_join_impl,3,0,0,character,1
+dplyr,semi_join_impl,4,0,0,logical,1
+dplyr,semi_join_impl,5,0,0,environment,1
+dplyr,semi_join.tbl_df,-1,0,0,"class<`data.frame`, `tbl`, `tbl_df`>",1
+dplyr,semi_join.tbl_df,0,0,0,"class<`data.frame`, `tbl`, `tbl_df`>",1
+dplyr,semi_join.tbl_df,1,0,0,"class<`data.frame`, `tbl`, `tbl_df`>",1
+dplyr,semi_join.tbl_df,1,0,1,class<`data.frame`>,1
+dplyr,semi_join.tbl_df,2,0,0,null,1
+dplyr,semi_join.tbl_df,2,0,1,character,1
+dplyr,semi_join.tbl_df,3,0,0,logical,1
+dplyr,semi_join.tbl_df,4,0,0,...,1
+dplyr,semi_join.tbl_df,5,0,0,null,1
+dplyr,setdiff,-1,0,0,character[],1
+dplyr,setdiff,-1,0,1,class<`data.frame`>,1
+dplyr,setdiff,-1,0,2,"class<`data.frame`, `tbl`, `tbl_df`>",1
+dplyr,setdiff,-1,0,3,null,1
+dplyr,setdiff,0,0,0,character[],1
+dplyr,setdiff,0,0,1,"class<`character`, `dplyr_sel_vars`>",1
+dplyr,setdiff,0,0,2,class<`data.frame`>,1
+dplyr,setdiff,0,0,3,"class<`data.frame`, `tbl`, `tbl_df`>",1
+dplyr,setdiff,0,0,4,null,1
+dplyr,setdiff,1,0,0,character[],1
+dplyr,setdiff,1,0,1,class<`data.frame`>,1
+dplyr,setdiff,1,0,2,"class<`data.frame`, `tbl`, `tbl_df`>",1
+dplyr,setdiff,2,0,0,...,1
+dplyr,setdiff_data_frame,-1,0,0,class<`data.frame`>,1
+dplyr,setdiff_data_frame,-1,0,1,"class<`data.frame`, `tbl`, `tbl_df`>",1
+dplyr,setdiff_data_frame,0,0,0,class<`data.frame`>,1
+dplyr,setdiff_data_frame,0,0,1,"class<`data.frame`, `tbl`, `tbl_df`>",1
+dplyr,setdiff_data_frame,1,0,0,class<`data.frame`>,1
+dplyr,setdiff_data_frame,1,0,1,"class<`data.frame`, `tbl`, `tbl_df`>",1
+dplyr,setdiff.data.frame,-1,0,0,class<`data.frame`>,1
+dplyr,setdiff.data.frame,-1,0,1,"class<`data.frame`, `tbl`, `tbl_df`>",1
+dplyr,setdiff.data.frame,0,0,0,class<`data.frame`>,1
+dplyr,setdiff.data.frame,0,0,1,"class<`data.frame`, `tbl`, `tbl_df`>",1
+dplyr,setdiff.data.frame,1,0,0,class<`data.frame`>,1
+dplyr,setdiff.data.frame,1,0,1,"class<`data.frame`, `tbl`, `tbl_df`>",1
+dplyr,setdiff.data.frame,2,0,0,...,1
+dplyr,setdiff.default,-1,0,0,character[],1
+dplyr,setdiff.default,-1,0,1,null,1
+dplyr,setdiff.default,0,0,0,character[],1
+dplyr,setdiff.default,0,0,1,"class<`character`, `dplyr_sel_vars`>",1
+dplyr,setdiff.default,0,0,2,null,1
+dplyr,setdiff.default,1,0,0,character[],1
+dplyr,setdiff.default,2,0,0,...,1
+dplyr,setequal,-1,0,0,logical,1
+dplyr,setequal,0,0,0,class<`data.frame`>,1
+dplyr,setequal,1,0,0,class<`data.frame`>,1
+dplyr,setequal,2,0,0,...,1
+dplyr,setequal.data.frame,-1,0,0,logical,1
+dplyr,setequal.data.frame,0,0,0,class<`data.frame`>,1
+dplyr,setequal.data.frame,1,0,0,class<`data.frame`>,1
+dplyr,setequal.data.frame,2,0,0,...,1
+dplyr,show_query,-1,0,0,"class<`tbl`, `tbl_SQLiteConnection`, `tbl_dbi`, `tbl_lazy`, `tbl_sql`>",1
+dplyr,show_query,0,0,0,"class<`tbl`, `tbl_SQLiteConnection`, `tbl_dbi`, `tbl_lazy`, `tbl_sql`>",1
+dplyr,show_query,1,0,0,...,1
+dplyr,signal_soft_deprecated,-1,0,0,null,1
+dplyr,signal_soft_deprecated,0,0,0,character,1
+dplyr,signal_soft_deprecated,1,0,0,any,1
+dplyr,signal_soft_deprecated,2,0,0,environment,1
+dplyr,slice,-1,0,0,class<`data.frame`>,1
+dplyr,slice,-1,0,1,"class<`data.frame`, `grouped_df`, `tbl`, `tbl_df`>",1
+dplyr,slice,-1,0,2,"class<`data.frame`, `tbl`, `tbl_df`>",1
+dplyr,slice,0,0,0,class<`data.frame`>,1
+dplyr,slice,0,0,1,"class<`data.frame`, `grouped_df`, `tbl`, `tbl_df`>",1
+dplyr,slice,0,0,2,"class<`data.frame`, `tbl`, `tbl_df`>",1
+dplyr,slice,1,0,0,...,1
+dplyr,slice,2,0,0,logical,1
+dplyr,slice.data.frame,-1,0,0,class<`data.frame`>,1
+dplyr,slice.data.frame,0,0,0,class<`data.frame`>,1
+dplyr,slice.data.frame,1,0,0,...,1
+dplyr,slice.data.frame,2,0,0,logical,1
+dplyr,slice_impl,-1,0,0,"class<`data.frame`, `grouped_df`, `tbl`, `tbl_df`>",1
+dplyr,slice_impl,-1,0,1,"class<`data.frame`, `tbl`, `tbl_df`>",1
+dplyr,slice_impl,0,0,0,"class<`data.frame`, `grouped_df`, `tbl`, `tbl_df`>",1
+dplyr,slice_impl,0,0,1,"class<`data.frame`, `tbl`, `tbl_df`>",1
+dplyr,slice_impl,1,0,0,"class<`formula`, `quosure`>",1
+dplyr,slice.tbl_df,-1,0,0,"class<`data.frame`, `grouped_df`, `tbl`, `tbl_df`>",1
+dplyr,slice.tbl_df,-1,0,1,"class<`data.frame`, `tbl`, `tbl_df`>",1
+dplyr,slice.tbl_df,0,0,0,"class<`data.frame`, `grouped_df`, `tbl`, `tbl_df`>",1
+dplyr,slice.tbl_df,0,0,1,"class<`data.frame`, `tbl`, `tbl_df`>",1
+dplyr,slice.tbl_df,1,0,0,...,1
+dplyr,slice.tbl_df,2,0,0,logical,1
+dplyr,sql_escape_ident,-1,0,0,character[],1
+dplyr,sql_escape_ident,0,0,0,class<`SQLiteConnection`>,1
+dplyr,sql_escape_ident,1,0,0,character[],1
+dplyr,sql_escape_ident,1,0,1,"class<`character`, `ident`>",1
+dplyr,sql_escape_string,-1,0,0,class<`SQL`>,1
+dplyr,sql_escape_string,0,0,0,class<`SQLiteConnection`>,1
+dplyr,sql_escape_string,1,0,0,character,1
+dplyr,sql_join,-1,0,0,"class<`character`, `sql`>",1
+dplyr,sql_join,0,0,0,class<`SQLiteConnection`>,1
+dplyr,sql_join,1,0,0,"class<`character`, `ident`>",1
+dplyr,sql_join,2,0,0,"class<`character`, `ident`>",1
+dplyr,sql_join,3,0,0,list<^character[]>,1
+dplyr,sql_join,4,0,0,character,1
+dplyr,sql_join,5,0,0,list<character[]>,1
+dplyr,sql_join,6,0,0,...,1
+dplyr,sql_select,-1,0,0,"class<`character`, `sql`>",1
+dplyr,sql_select,0,0,0,class<`SQLiteConnection`>,1
+dplyr,sql_select,1,0,0,"class<`character`, `sql`>",1
+dplyr,sql_select,2,0,0,"class<`character`, `ident`>",1
+dplyr,sql_select,2,0,1,"class<`character`, `sql`>",1
+dplyr,sql_select,3,0,0,"class<`character`, `sql`>",1
+dplyr,sql_select,3,0,1,null,1
+dplyr,sql_select,3,0,2,character[],1
+dplyr,sql_select,4,0,0,character[],1
+dplyr,sql_select,4,0,1,"class<`character`, `sql`>",1
+dplyr,sql_select,4,0,2,null,1
+dplyr,sql_select,5,0,0,character[],1
+dplyr,sql_select,5,0,1,null,1
+dplyr,sql_select,6,0,0,character[],1
+dplyr,sql_select,6,0,1,null,1
+dplyr,sql_select,7,0,0,null,1
+dplyr,sql_subquery,-1,0,0,"class<`character`, `ident`>",1
+dplyr,sql_subquery,-1,0,1,"class<`character`, `sql`>",1
+dplyr,sql_subquery,0,0,0,class<`SQLiteConnection`>,1
+dplyr,sql_subquery,1,0,0,"class<`character`, `ident`>",1
+dplyr,sql_subquery,1,0,1,"class<`character`, `sql`>",1
+dplyr,sql_subquery,2,0,0,any,1
+dplyr,sql_subquery,3,0,0,...,1
+dplyr,sql_translate_env,-1,0,0,class<`sql_variant`>,1
+dplyr,sql_translate_env,0,0,0,class<`SQLiteConnection`>,1
+dplyr,src_df,-1,0,0,"class<`src`, `src_local`>",1
+dplyr,src_df,0,0,0,character,1
+dplyr,src_df,1,0,0,null,1
+dplyr,src_local,-1,0,0,"class<`src`, `src_local`>",1
+dplyr,src_local,0,0,0,character,1
+dplyr,src_local,1,0,0,character,1
+dplyr,src_local,2,0,0,null,1
+dplyr,src_sqlite,-1,0,0,"class<`src`, `src_SQLiteConnection`, `src_dbi`, `src_sql`>",1
+dplyr,src_sqlite,0,0,0,character,1
+dplyr,src_sqlite,1,0,0,logical,1
+dplyr,src_tbls,-1,0,0,character[],1
+dplyr,src_tbls,0,0,0,"class<`src`, `src_SQLiteConnection`, `src_dbi`, `src_sql`>",1
+dplyr,strip_pos,-1,0,0,character[],1
+dplyr,strip_pos,0,0,0,character[],1
+dplyr,summarise,-1,0,0,class<`data.frame`>,1
+dplyr,summarise,-1,0,1,"class<`data.frame`, `grouped_df`, `tbl`, `tbl_df`>",1
+dplyr,summarise,-1,0,2,"class<`data.frame`, `tbl`, `tbl_df`>",1
+dplyr,summarise,-1,0,3,class<`tbl_cube`>,1
+dplyr,summarise,-1,0,4,"class<`tbl`, `tbl_SQLiteConnection`, `tbl_dbi`, `tbl_lazy`, `tbl_sql`>",1
+dplyr,summarise,0,0,0,class<`data.frame`>,1
+dplyr,summarise,0,0,1,"class<`data.frame`, `grouped_df`, `tbl`, `tbl_df`>",1
+dplyr,summarise,0,0,2,"class<`data.frame`, `rowwise_df`, `tbl`, `tbl_df`>",1
+dplyr,summarise,0,0,3,"class<`data.frame`, `tbl`, `tbl_df`>",1
+dplyr,summarise,0,0,4,class<`tbl_cube`>,1
+dplyr,summarise,0,0,5,"class<`tbl`, `tbl_SQLiteConnection`, `tbl_dbi`, `tbl_lazy`, `tbl_sql`>",1
+dplyr,summarise,1,0,0,...,1
+dplyr,summarise_all,-1,0,0,"class<`data.frame`, `tbl`, `tbl_df`>",1
+dplyr,summarise_all,0,0,0,"class<`data.frame`, `grouped_df`, `tbl`, `tbl_df`>",1
+dplyr,summarise_all,1,0,0,list<class<`formula`>>,1
+dplyr,summarise_all,1,0,1,list<class<`function`>>,1
+dplyr,summarise_all,2,0,0,...,1
+dplyr,summarise_at,-1,0,0,"class<`data.frame`, `tbl`, `tbl_df`>",1
+dplyr,summarise_at,0,0,0,"class<`data.frame`, `tbl`, `tbl_df`>",1
+dplyr,summarise_at,1,0,0,character[],1
+dplyr,summarise_at,1,0,1,"class<`list`, `quosures`>",1
+dplyr,summarise_at,2,0,0,class<`function`>,1
+dplyr,summarise_at,3,0,0,...,1
+dplyr,summarise_at,4,0,0,null,1
+dplyr,summarise.data.frame,-1,0,0,class<`data.frame`>,1
+dplyr,summarise.data.frame,0,0,0,class<`data.frame`>,1
+dplyr,summarise.data.frame,1,0,0,...,1
+dplyr,summarise_if,-1,0,0,"class<`data.frame`, `tbl`, `tbl_df`>",1
+dplyr,summarise_if,0,0,0,"class<`data.frame`, `tbl`, `tbl_df`>",1
+dplyr,summarise_if,1,0,0,class<`function`>,1
+dplyr,summarise_if,2,0,0,class<`function`>,1
+dplyr,summarise_if,3,0,0,...,1
+dplyr,summarise_impl,-1,0,0,"class<`data.frame`, `grouped_df`, `tbl`, `tbl_df`>",1
+dplyr,summarise_impl,-1,0,1,"class<`data.frame`, `tbl`, `tbl_df`>",1
+dplyr,summarise_impl,0,0,0,"class<`data.frame`, `grouped_df`, `tbl`, `tbl_df`>",1
+dplyr,summarise_impl,0,0,1,"class<`data.frame`, `rowwise_df`, `tbl`, `tbl_df`>",1
+dplyr,summarise_impl,0,0,2,"class<`data.frame`, `tbl`, `tbl_df`>",1
+dplyr,summarise_impl,1,0,0,"class<`list`, `quosures`>",1
+dplyr,summarise_impl,2,0,0,environment,1
+dplyr,summarise_impl,3,0,0,environment,1
+dplyr,summarise.tbl_cube,-1,0,0,class<`tbl_cube`>,1
+dplyr,summarise.tbl_cube,0,0,0,class<`tbl_cube`>,1
+dplyr,summarise.tbl_cube,1,0,0,...,1
+dplyr,summarise.tbl_df,-1,0,0,"class<`data.frame`, `grouped_df`, `tbl`, `tbl_df`>",1
+dplyr,summarise.tbl_df,-1,0,1,"class<`data.frame`, `tbl`, `tbl_df`>",1
+dplyr,summarise.tbl_df,0,0,0,"class<`data.frame`, `grouped_df`, `tbl`, `tbl_df`>",1
+dplyr,summarise.tbl_df,0,0,1,"class<`data.frame`, `rowwise_df`, `tbl`, `tbl_df`>",1
+dplyr,summarise.tbl_df,0,0,2,"class<`data.frame`, `tbl`, `tbl_df`>",1
+dplyr,summarise.tbl_df,1,0,0,...,1
+dplyr,switch_expr,-1,0,0,null,1
+dplyr,switch_expr,-1,0,1,pairlist,1
+dplyr,switch_expr,0,0,0,class<`(`>,1
+dplyr,switch_expr,0,0,1,class<`call`>,1
+dplyr,switch_expr,0,0,2,double,1
+dplyr,switch_expr,0,0,3,class<`name`>,1
+dplyr,switch_expr,1,0,0,...,1
+dplyr,tally,-1,0,0,class<`data.frame`>,1
+dplyr,tally,-1,0,1,"class<`data.frame`, `grouped_df`, `tbl`, `tbl_df`>",1
+dplyr,tally,-1,0,2,"class<`data.frame`, `tbl`, `tbl_df`>",1
+dplyr,tally,0,0,0,class<`data.frame`>,1
+dplyr,tally,0,0,1,"class<`data.frame`, `grouped_df`, `tbl`, `tbl_df`>",1
+dplyr,tally,1,0,0,any,1
+dplyr,tally,2,0,0,logical,1
+dplyr,tally,3,0,0,character,1
+dplyr,tbl,-1,0,0,"class<`data.frame`, `tbl`, `tbl_df`>",1
+dplyr,tbl,-1,0,1,"class<`tbl`, `tbl_SQLiteConnection`, `tbl_dbi`, `tbl_lazy`, `tbl_sql`>",1
+dplyr,tbl,0,0,0,"class<`src`, `src_local`>",1
+dplyr,tbl,0,0,1,class<`SQLiteConnection`>,1
+dplyr,tbl,0,0,2,"class<`src`, `src_SQLiteConnection`, `src_dbi`, `src_sql`>",1
+dplyr,tbl,1,0,0,...,1
+dplyr,tbl_at_syms,-1,0,0,list<class<`name`>>,1
+dplyr,tbl_at_syms,0,0,0,"class<`data.frame`, `grouped_df`, `tbl`, `tbl_df`>",1
+dplyr,tbl_at_syms,0,0,1,"class<`data.frame`, `tbl`, `tbl_df`>",1
+dplyr,tbl_at_syms,0,0,2,class<`data.frame`>,1
+dplyr,tbl_at_syms,1,0,0,"class<`list`, `quosures`>",1
+dplyr,tbl_at_syms,1,0,1,character[],1
+dplyr,tbl_at_syms,2,0,0,logical,1
+dplyr,tbl_at_vars,-1,0,0,character[],1
+dplyr,tbl_at_vars,0,0,0,class<`data.frame`>,1
+dplyr,tbl_at_vars,0,0,1,"class<`data.frame`, `grouped_df`, `tbl`, `tbl_df`>",1
+dplyr,tbl_at_vars,0,0,2,"class<`data.frame`, `tbl`, `tbl_df`>",1
+dplyr,tbl_at_vars,1,0,0,"class<`list`, `quosures`>",1
+dplyr,tbl_at_vars,1,0,1,character[],1
+dplyr,tbl_at_vars,2,0,0,logical,1
+dplyr,tbl_cube,-1,0,0,class<`tbl_cube`>,1
+dplyr,tbl_cube,0,0,0,list<character[]>,1
+dplyr,tbl_cube,0,0,1,"list<class<`factor`, `ordered`>>",1
+dplyr,tbl_cube,1,0,0,list<class<`array`>>,1
+dplyr,tbl.DBIConnection,-1,0,0,"class<`tbl`, `tbl_SQLiteConnection`, `tbl_dbi`, `tbl_lazy`, `tbl_sql`>",1
+dplyr,tbl.DBIConnection,0,0,0,class<`SQLiteConnection`>,1
+dplyr,tbl.DBIConnection,1,0,0,character,1
+dplyr,tbl.DBIConnection,1,0,1,"class<`character`, `sql`>",1
+dplyr,tbl.DBIConnection,2,0,0,...,1
+dplyr,tbl_df,-1,0,0,"class<`data.frame`, `tbl`, `tbl_df`>",1
+dplyr,tbl_df,0,0,0,class<`data.frame`>,1
+dplyr,tbl_if_syms,-1,0,0,list<class<`name`>>,1
+dplyr,tbl_if_syms,0,0,0,"class<`data.frame`, `tbl`, `tbl_df`>",1
+dplyr,tbl_if_syms,0,0,1,class<`data.frame`>,1
+dplyr,tbl_if_syms,1,0,0,class<`function`>,1
+dplyr,tbl_if_syms,1,0,1,class<`formula`>,1
+dplyr,tbl_if_syms,2,0,0,any,1
+dplyr,tbl_if_syms,3,0,0,...,1
+dplyr,tbl_if_syms,4,0,0,logical,1
+dplyr,tbl_if_vars,-1,0,0,character[],1
+dplyr,tbl_if_vars,0,0,0,class<`data.frame`>,1
+dplyr,tbl_if_vars,0,0,1,"class<`data.frame`, `tbl`, `tbl_df`>",1
+dplyr,tbl_if_vars,1,0,0,class<`formula`>,1
+dplyr,tbl_if_vars,1,0,1,list<class<`function`>>,1
+dplyr,tbl_if_vars,1,0,2,class<`function`>,1
+dplyr,tbl_if_vars,2,0,0,any,1
+dplyr,tbl_if_vars,3,0,0,...,1
+dplyr,tbl_if_vars,4,0,0,logical,1
+dplyr,tbl_nongroup_vars,-1,0,0,character[],1
+dplyr,tbl_nongroup_vars,0,0,0,class<`data.frame`>,1
+dplyr,tbl_nongroup_vars,0,0,1,"class<`data.frame`, `grouped_df`, `tbl`, `tbl_df`>",1
+dplyr,tbl_nongroup_vars,0,0,2,"class<`data.frame`, `tbl`, `tbl_df`>",1
+dplyr,tbl.src_local,-1,0,0,"class<`data.frame`, `tbl`, `tbl_df`>",1
+dplyr,tbl.src_local,0,0,0,"class<`src`, `src_local`>",1
+dplyr,tbl.src_local,1,0,0,character,1
+dplyr,tbl.src_local,2,0,0,...,1
+dplyr,tbl_vars,-1,0,0,"class<`character`, `dplyr_sel_vars`>",1
+dplyr,tbl_vars,0,0,0,class<`data.frame`>,1
+dplyr,tbl_vars,0,0,1,"class<`data.frame`, `grouped_df`, `tbl`, `tbl_df`>",1
+dplyr,tbl_vars,0,0,2,"class<`data.frame`, `tbl`, `tbl_df`>",1
+dplyr,tbl_vars,0,0,3,"class<`tbl`, `tbl_SQLiteConnection`, `tbl_dbi`, `tbl_lazy`, `tbl_sql`>",1
+dplyr,tbl_vars.data.frame,-1,0,0,character[],1
+dplyr,tbl_vars.data.frame,0,0,0,class<`data.frame`>,1
+dplyr,tbl_vars.data.frame,0,0,1,"class<`data.frame`, `grouped_df`, `tbl`, `tbl_df`>",1
+dplyr,tbl_vars.data.frame,0,0,2,"class<`data.frame`, `tbl`, `tbl_df`>",1
+dplyr,tbl_vars_dispatch,-1,0,0,character[],1
+dplyr,tbl_vars_dispatch,0,0,0,class<`data.frame`>,1
+dplyr,tbl_vars_dispatch,0,0,1,"class<`data.frame`, `grouped_df`, `tbl`, `tbl_df`>",1
+dplyr,tbl_vars_dispatch,0,0,2,"class<`data.frame`, `tbl`, `tbl_df`>",1
+dplyr,tbl_vars_dispatch,0,0,3,"class<`tbl`, `tbl_SQLiteConnection`, `tbl_dbi`, `tbl_lazy`, `tbl_sql`>",1
+dplyr,top_frac,-1,0,0,class<`data.frame`>,1
+dplyr,top_frac,0,0,0,class<`data.frame`>,1
+dplyr,top_frac,1,0,0,double,1
+dplyr,top_frac,2,0,0,any,1
+dplyr,top_n,-1,0,0,class<`data.frame`>,1
+dplyr,top_n,-1,0,1,"class<`data.frame`, `tbl`, `tbl_df`>",1
+dplyr,top_n,0,0,0,class<`data.frame`>,1
+dplyr,top_n,0,0,1,"class<`data.frame`, `tbl`, `tbl_df`>",1
+dplyr,top_n,1,0,0,any,1
+dplyr,top_n,2,0,0,any,1
+dplyr,top_n_rank,-1,0,0,logical[],1
+dplyr,top_n_rank,0,0,0,double,1
+dplyr,top_n_rank,1,0,0,double[],1
+dplyr,transmute,-1,0,0,class<`data.frame`>,1
+dplyr,transmute,-1,0,1,"class<`data.frame`, `tbl`, `tbl_df`>",1
+dplyr,transmute,0,0,0,class<`data.frame`>,1
+dplyr,transmute,0,0,1,"class<`data.frame`, `tbl`, `tbl_df`>",1
+dplyr,transmute,1,0,0,...,1
+dplyr,transmute.default,-1,0,0,class<`data.frame`>,1
+dplyr,transmute.default,-1,0,1,"class<`data.frame`, `tbl`, `tbl_df`>",1
+dplyr,transmute.default,0,0,0,class<`data.frame`>,1
+dplyr,transmute.default,0,0,1,"class<`data.frame`, `tbl`, `tbl_df`>",1
+dplyr,transmute.default,1,0,0,...,1
+dplyr,undimname,-1,0,0,class<`array`>,1
+dplyr,undimname,0,0,0,class<`array`>,1
+dplyr,ungroup,-1,0,0,"class<`data.frame`, `tbl`, `tbl_df`>",1
+dplyr,ungroup,-1,0,1,"class<`tbl`, `tbl_SQLiteConnection`, `tbl_dbi`, `tbl_lazy`, `tbl_sql`>",1
+dplyr,ungroup,0,0,0,"class<`data.frame`, `grouped_df`, `tbl`, `tbl_df`>",1
+dplyr,ungroup,0,0,1,"class<`data.frame`, `rowwise_df`, `tbl`, `tbl_df`>",1
+dplyr,ungroup,0,0,2,"class<`tbl`, `tbl_SQLiteConnection`, `tbl_dbi`, `tbl_lazy`, `tbl_sql`>",1
+dplyr,ungroup,1,0,0,...,1
+dplyr,ungroup_grouped_df,-1,0,0,"class<`data.frame`, `tbl`, `tbl_df`>",1
+dplyr,ungroup_grouped_df,0,0,0,"class<`data.frame`, `grouped_df`, `tbl`, `tbl_df`>",1
+dplyr,ungroup.grouped_df,-1,0,0,"class<`data.frame`, `tbl`, `tbl_df`>",1
+dplyr,ungroup.grouped_df,0,0,0,"class<`data.frame`, `grouped_df`, `tbl`, `tbl_df`>",1
+dplyr,ungroup.grouped_df,1,0,0,...,1
+dplyr,ungroup.rowwise_df,-1,0,0,"class<`data.frame`, `tbl`, `tbl_df`>",1
+dplyr,ungroup.rowwise_df,0,0,0,"class<`data.frame`, `rowwise_df`, `tbl`, `tbl_df`>",1
+dplyr,ungroup.rowwise_df,1,0,0,...,1
+dplyr,union,-1,0,0,character[],1
+dplyr,union,-1,0,1,class<`data.frame`>,1
+dplyr,union,-1,0,2,"class<`data.frame`, `tbl`, `tbl_df`>",1
+dplyr,union,0,0,0,character[],1
+dplyr,union,0,0,1,class<`data.frame`>,1
+dplyr,union,0,0,2,"class<`data.frame`, `tbl`, `tbl_df`>",1
+dplyr,union,1,0,0,character[],1
+dplyr,union,1,0,1,class<`data.frame`>,1
+dplyr,union,1,0,2,"class<`data.frame`, `tbl`, `tbl_df`>",1
+dplyr,union,2,0,0,...,1
+dplyr,union_all,-1,0,0,class<`data.frame`>,1
+dplyr,union_all,0,0,0,class<`data.frame`>,1
+dplyr,union_all,1,0,0,class<`data.frame`>,1
+dplyr,union_all,2,0,0,...,1
+dplyr,union_all.data.frame,-1,0,0,class<`data.frame`>,1
+dplyr,union_all.data.frame,0,0,0,class<`data.frame`>,1
+dplyr,union_all.data.frame,1,0,0,class<`data.frame`>,1
+dplyr,union_all.data.frame,2,0,0,...,1
+dplyr,union_data_frame,-1,0,0,class<`data.frame`>,1
+dplyr,union_data_frame,-1,0,1,"class<`data.frame`, `tbl`, `tbl_df`>",1
+dplyr,union_data_frame,0,0,0,class<`data.frame`>,1
+dplyr,union_data_frame,0,0,1,"class<`data.frame`, `tbl`, `tbl_df`>",1
+dplyr,union_data_frame,1,0,0,class<`data.frame`>,1
+dplyr,union_data_frame,1,0,1,"class<`data.frame`, `tbl`, `tbl_df`>",1
+dplyr,union.data.frame,-1,0,0,class<`data.frame`>,1
+dplyr,union.data.frame,-1,0,1,"class<`data.frame`, `tbl`, `tbl_df`>",1
+dplyr,union.data.frame,0,0,0,class<`data.frame`>,1
+dplyr,union.data.frame,0,0,1,"class<`data.frame`, `tbl`, `tbl_df`>",1
+dplyr,union.data.frame,1,0,0,class<`data.frame`>,1
+dplyr,union.data.frame,1,0,1,"class<`data.frame`, `tbl`, `tbl_df`>",1
+dplyr,union.data.frame,2,0,0,...,1
+dplyr,union.default,-1,0,0,character[],1
+dplyr,union.default,0,0,0,character[],1
+dplyr,union.default,1,0,0,character[],1
+dplyr,union.default,2,0,0,...,1
+dplyr,unique_names,-1,0,0,character[],1
+dplyr,unique_names,0,0,0,character[],1
+dplyr,unique_names,1,0,0,logical,1
+dplyr,unique_names,2,0,0,class<`function`>,1
+dplyr,validate_case_when_length,-1,0,0,integer,1
+dplyr,validate_case_when_length,0,0,0,list<^logical[]>,1
+dplyr,validate_case_when_length,1,0,0,list<^character[]>,1
+dplyr,validate_case_when_length,1,0,1,list<double | null>,1
+dplyr,validate_case_when_length,1,0,2,list<null | ^character[]>,1
+dplyr,validate_case_when_length,1,0,3,list<double[]>,1
+dplyr,validate_case_when_length,2,0,0,any,1
+dplyr,validate_recode_default,-1,0,0,character[],1
+dplyr,validate_recode_default,-1,0,1,^integer[],1
+dplyr,validate_recode_default,-1,0,2,null,1
+dplyr,validate_recode_default,0,0,0,character[],1
+dplyr,validate_recode_default,0,0,1,null,1
+dplyr,validate_recode_default,1,0,0,class<`factor`>,1
+dplyr,validate_recode_default,1,0,1,character[],1
+dplyr,validate_recode_default,1,0,2,double[],1
+dplyr,validate_recode_default,1,0,3,^integer[],1
+dplyr,validate_recode_default,2,0,0,any,1
+dplyr,validate_recode_default,3,0,0,any,1
+dplyr,vars,-1,0,0,"class<`list`, `quosures`>",1
+dplyr,vars,0,0,0,...,1
+dplyr,vars_select_syms,-1,0,0,list<any>,1
+dplyr,vars_select_syms,0,0,0,character[],1
+dplyr,vars_select_syms,0,0,1,"class<`character`, `dplyr_sel_vars`>",1
+dplyr,vars_select_syms,1,0,0,list<any>,1
+dplyr,vars_select_syms,2,0,0,class<`data.frame`>,1
+dplyr,vars_select_syms,2,0,1,"class<`data.frame`, `tbl`, `tbl_df`>",1
+dplyr,vars_select_syms,3,0,0,logical,1
+dplyr,warn_deprecated,-1,0,0,character,1
+dplyr,warn_deprecated,-1,0,1,null,1
+dplyr,warn_deprecated,0,0,0,any,1
+dplyr,warn_deprecated,1,0,0,character,1
+dplyr,warn_text_se,-1,0,0,null,1
+dplyr,warn_underscored,-1,0,0,null,1
+dplyr,with_order,-1,0,0,^double[],1
+dplyr,with_order,0,0,0,integer[],1
+dplyr,with_order,1,0,0,class<`function`>,1
+dplyr,with_order,2,0,0,double[],1
+dplyr,with_order,3,0,0,...,1
+dplyr,wrap_dbplyr_obj,-1,0,0,class<`<-`>,1
+dplyr,wrap_dbplyr_obj,0,0,0,character,1
+dtw,backtrack,-1,0,0,list<double[]>,1
+dtw,backtrack,0,0,0,list<any>,1
+dtw,.canonicalizeWindowFunction,-1,0,0,class<`function`>,1
+dtw,.canonicalizeWindowFunction,0,0,0,character,1
+dtw,.canonicalizeWindowFunction,0,0,1,class<`function`>,1
+dtw,countPaths,-1,0,0,double,1
+dtw,countPaths,0,0,0,class<`dtw`>,1
+dtw,countPaths,1,0,0,logical,1
+dtw,dtw,-1,0,0,class<`dtw`>,1
+dtw,dtw,0,0,0,class<`crossdist`>,1
+dtw,dtw,0,0,1,class<`matrix`>,1
+dtw,dtw,0,0,2,class<`ts`>,1
+dtw,dtw,0,0,3,double[],1
+dtw,dtw,1,0,0,null,1
+dtw,dtw,1,0,1,class<`matrix`>,1
+dtw,dtw,1,0,2,class<`ts`>,1
+dtw,dtw,1,0,3,double[],1
+dtw,dtw,2,0,0,character,1
+dtw,dtw,3,0,0,class<`stepPattern`>,1
+dtw,dtw,4,0,0,character,1
+dtw,dtw,4,0,1,class<`function`>,1
+dtw,dtw,5,0,0,logical,1
+dtw,dtw,6,0,0,logical,1
+dtw,dtw,7,0,0,logical,1
+dtw,dtw,8,0,0,logical,1
+dtw,dtw,9,0,0,...,1
+dtw,dtwPlot,-1,0,0,null,1
+dtw,dtwPlot,-1,0,1,list<character | double[] | null>,1
+dtw,dtwPlot,0,0,0,class<`dtw`>,1
+dtw,dtwPlot,1,0,0,character,1
+dtw,dtwPlot,2,0,0,...,1
+dtw,dtwPlotAlignment,-1,0,0,null,1
+dtw,dtwPlotAlignment,0,0,0,class<`dtw`>,1
+dtw,dtwPlotAlignment,1,0,0,character,1
+dtw,dtwPlotAlignment,2,0,0,character,1
+dtw,dtwPlotAlignment,3,0,0,character,1
+dtw,dtwPlotAlignment,4,0,0,...,1
+dtw,dtwPlotDensity,-1,0,0,null,1
+dtw,dtwPlotDensity,0,0,0,class<`dtw`>,1
+dtw,dtwPlotDensity,1,0,0,logical,1
+dtw,dtwPlotDensity,2,0,0,character,1
+dtw,dtwPlotDensity,3,0,0,character,1
+dtw,dtwPlotDensity,4,0,0,...,1
+dtw,dtwPlotThreeWay,-1,0,0,list<character | double[] | null>,1
+dtw,dtwPlotThreeWay,0,0,0,class<`dtw`>,1
+dtw,dtwPlotThreeWay,1,0,0,null,1
+dtw,dtwPlotThreeWay,2,0,0,null,1
+dtw,dtwPlotThreeWay,3,0,0,character,1
+dtw,dtwPlotThreeWay,4,0,0,character,1
+dtw,dtwPlotThreeWay,5,0,0,integer[],1
+dtw,dtwPlotThreeWay,5,0,1,null,1
+dtw,dtwPlotThreeWay,6,0,0,double,1
+dtw,dtwPlotThreeWay,7,0,0,double,1
+dtw,dtwPlotThreeWay,8,0,0,double,1
+dtw,dtwPlotThreeWay,9,0,0,character,1
+dtw,dtwPlotThreeWay,10,0,0,character,1
+dtw,dtwPlotThreeWay,11,0,0,character,1
+dtw,dtwPlotThreeWay,12,0,0,...,1
+dtw,dtwPlotTwoWay,-1,0,0,list<character | double[] | null>,1
+dtw,dtwPlotTwoWay,0,0,0,class<`dtw`>,1
+dtw,dtwPlotTwoWay,1,0,0,null,1
+dtw,dtwPlotTwoWay,2,0,0,null,1
+dtw,dtwPlotTwoWay,3,0,0,double,1
+dtw,dtwPlotTwoWay,4,0,0,character,1
+dtw,dtwPlotTwoWay,5,0,0,double,1
+dtw,dtwPlotTwoWay,6,0,0,double,1
+dtw,dtwPlotTwoWay,6,0,1,integer[],1
+dtw,dtwPlotTwoWay,6,0,2,null,1
+dtw,dtwPlotTwoWay,7,0,0,character,1
+dtw,dtwPlotTwoWay,8,0,0,double,1
+dtw,dtwPlotTwoWay,9,0,0,character,1
+dtw,dtwPlotTwoWay,10,0,0,character,1
+dtw,dtwPlotTwoWay,11,0,0,...,1
+dtw,dtwWindow.plot,-1,0,0,null,1
+dtw,dtwWindow.plot,0,0,0,class<`function`>,1
+dtw,dtwWindow.plot,1,0,0,double,1
+dtw,dtwWindow.plot,2,0,0,double,1
+dtw,dtwWindow.plot,3,0,0,...,1
+dtw,.extractpattern,-1,0,0,class<`matrix`>,1
+dtw,.extractpattern,0,0,0,class<`matrix`>,1
+dtw,.extractpattern,0,0,1,class<`stepPattern`>,1
+dtw,.extractpattern,1,0,0,integer,1
+dtw,globalCostMatrix,-1,0,0,list<class<`matrix`> | class<`stepPattern`>>,1
+dtw,globalCostMatrix,0,0,0,class<`matrix`>,1
+dtw,globalCostMatrix,0,0,1,class<`crossdist`>,1
+dtw,globalCostMatrix,1,0,0,class<`stepPattern`>,1
+dtw,globalCostMatrix,2,0,0,class<`function`>,1
+dtw,globalCostMatrix,3,0,0,logical,1
+dtw,globalCostMatrix,4,0,0,null,1
+dtw,globalCostMatrix,4,0,1,class<`matrix`>,1
+dtw,globalCostMatrix,5,0,0,...,1
+dtw,is.dtw,-1,0,0,logical,1
+dtw,is.dtw,0,0,0,class<`dtw`>,1
+dtw,is.stepPattern,-1,0,0,logical,1
+dtw,is.stepPattern,0,0,0,class<`stepPattern`>,1
+dtw,.mkDirDeltas,-1,0,0,class<`matrix`>,1
+dtw,.mkDirDeltas,0,0,0,class<`stepPattern`>,1
+dtw,mvmStepPattern,-1,0,0,class<`stepPattern`>,1
+dtw,mvmStepPattern,0,0,0,double,1
+dtw,.Pend,-1,0,0,list<double[] | character>,1
+dtw,.Pend,0,0,0,list<double[] | character>,1
+dtw,.Pend,1,0,0,any,1
+dtw,.Pend,2,0,0,any,1
+dtw,plot.dtw,-1,0,0,null,1
+dtw,plot.dtw,-1,0,1,list<character | double[] | null>,1
+dtw,plot.dtw,0,0,0,class<`dtw`>,1
+dtw,plot.dtw,1,0,0,character,1
+dtw,plot.dtw,2,0,0,...,1
+dtw,plot.stepPattern,-1,0,0,null,1
+dtw,plot.stepPattern,0,0,0,class<`stepPattern`>,1
+dtw,plot.stepPattern,1,0,0,...,1
+dtw,.Pnew,-1,0,0,list<double | character>,1
+dtw,.Pnew,0,0,0,double,1
+dtw,.Pnew,1,0,0,character,1
+dtw,.Pnew,2,0,0,logical,1
+dtw,print.stepPattern,-1,0,0,null,1
+dtw,print.stepPattern,0,0,0,class<`stepPattern`>,1
+dtw,print.stepPattern,1,0,0,...,1
+dtw,.Pstep,-1,0,0,list<double[] | character>,1
+dtw,.Pstep,0,0,0,list<double[] | character>,1
+dtw,.Pstep,0,0,1,list<double | character>,1
+dtw,.Pstep,1,0,0,double,1
+dtw,.Pstep,2,0,0,double,1
+dtw,.PtoMx,-1,0,0,class<`matrix`>,1
+dtw,.PtoMx,0,0,0,list<double[] | character>,1
+dtw,rabinerJuangStepPattern,-1,0,0,class<`stepPattern`>,1
+dtw,rabinerJuangStepPattern,0,0,0,double,1
+dtw,rabinerJuangStepPattern,1,0,0,character,1
+dtw,rabinerJuangStepPattern,2,0,0,logical,1
+dtw,.RJtypeIV,-1,0,0,class<`matrix`>,1
+dtw,.RJtypeIV,0,0,0,character,1
+dtw,.RJtypeIV,1,0,0,logical,1
+dtw,stepPattern,-1,0,0,class<`stepPattern`>,1
+dtw,stepPattern,0,0,0,double[],1
+dtw,stepPattern,0,0,1,class<`matrix`>,1
+dtw,stepPattern,1,0,0,null,1
+dtw,warp,-1,0,0,double[],1
+dtw,warp,0,0,0,class<`dtw`>,1
+dtw,warp,1,0,0,logical,1
+dtw,warpArea,-1,0,0,double,1
+dtw,warpArea,0,0,0,class<`dtw`>,1
+dummies,dummy,-1,0,0,class<`matrix`>,1
+dummies,dummy,0,0,0,character[],1
+dummies,dummy,0,0,1,class<`factor`>,1
+dummies,dummy,0,0,2,^integer[],1
+dummies,dummy,1,0,0,null,1
+dummies,dummy,1,0,1,class<`data.frame`>,1
+dummies,dummy,2,0,0,character,1
+dummies,dummy,3,0,0,logical,1
+dummies,dummy,4,0,0,any,1
+dummies,dummy,5,0,0,logical,1
+dummies,dummy.data.frame,-1,0,0,class<`data.frame`>,1
+dummies,dummy.data.frame,0,0,0,class<`data.frame`>,1
+dummies,dummy.data.frame,1,0,0,null,1
+dummies,dummy.data.frame,2,0,0,logical,1
+dummies,dummy.data.frame,3,0,0,character[],1
+dummies,dummy.data.frame,4,0,0,logical,1
+dummies,dummy.data.frame,5,0,0,...,1
+dummies,get.dummy,-1,0,0,class<`data.frame`>,1
+dummies,get.dummy,0,0,0,class<`data.frame`>,1
+dummies,get.dummy,1,0,0,character,1
+dummies,which.dummy,-1,0,0,integer[],1
+dummies,which.dummy,0,0,0,class<`data.frame`>,1
+dummies,which.dummy,1,0,0,character,1
+dummies,which.dummy,1,0,1,null,1
+dygraphs,%||%,-1,0,0,double,1
+dygraphs,%||%,0,0,0,null,1
+dygraphs,%||%,1,0,0,double,1
+dygraphs,asISO8601Time,-1,0,0,character[],1
+dygraphs,asISO8601Time,0,0,0,class<`Date`>,1
+dygraphs,asISO8601Time,0,0,1,"class<`POSIXct`, `POSIXt`>",1
+dygraphs,asISO8601Time,0,0,2,class<`yearmon`>,1
+dygraphs,asISO8601Time,0,0,3,class<`yearqtr`>,1
+dygraphs,asISO8601Time,0,0,4,character,1
+dygraphs,computeYaxisRange,-1,0,0,"class<`dygraphs`, `htmlwidget`>",1
+dygraphs,computeYaxisRange,0,0,0,"class<`dygraphs`, `htmlwidget`>",1
+dygraphs,computeYaxisRange,1,0,0,character[],1
+dygraphs,dyAnnotation,-1,0,0,"class<`dygraphs`, `htmlwidget`>",1
+dygraphs,dyAnnotation,0,0,0,"class<`dygraphs`, `htmlwidget`>",1
+dygraphs,dyAnnotation,1,0,0,character,1
+dygraphs,dyAnnotation,2,0,0,character,1
+dygraphs,dyAnnotation,3,0,0,character,1
+dygraphs,dyAnnotation,4,0,0,null,1
+dygraphs,dyAnnotation,5,0,0,null,1
+dygraphs,dyAnnotation,6,0,0,null,1
+dygraphs,dyAnnotation,7,0,0,null,1
+dygraphs,dyAxis,-1,0,0,"class<`dygraphs`, `htmlwidget`>",1
+dygraphs,dyAxis,0,0,0,"class<`dygraphs`, `htmlwidget`>",1
+dygraphs,dyAxis,1,0,0,character,1
+dygraphs,dyAxis,2,0,0,character,1
+dygraphs,dyAxis,2,0,1,null,1
+dygraphs,dyAxis,3,0,0,double[],1
+dygraphs,dyAxis,4,0,0,null,1
+dygraphs,dyAxis,5,0,0,null,1
+dygraphs,dyAxis,6,0,0,null,1
+dygraphs,dyAxis,7,0,0,null,1
+dygraphs,dyBarChart,-1,0,0,"class<`dygraphs`, `htmlwidget`>",1
+dygraphs,dyBarChart,0,0,0,"class<`dygraphs`, `htmlwidget`>",1
+dygraphs,dyBarSeries,-1,0,0,"class<`dygraphs`, `htmlwidget`>",1
+dygraphs,dyBarSeries,0,0,0,"class<`dygraphs`, `htmlwidget`>",1
+dygraphs,dyBarSeries,1,0,0,character,1
+dygraphs,dyBarSeries,2,0,0,...,1
+dygraphs,dyCandlestick,-1,0,0,"class<`dygraphs`, `htmlwidget`>",1
+dygraphs,dyCandlestick,0,0,0,"class<`dygraphs`, `htmlwidget`>",1
+dygraphs,dyCandlestick,1,0,0,logical,1
+dygraphs,dyCandlestickGroup,-1,0,0,"class<`dygraphs`, `htmlwidget`>",1
+dygraphs,dyCandlestickGroup,0,0,0,"class<`dygraphs`, `htmlwidget`>",1
+dygraphs,dyCandlestickGroup,1,0,0,character[],1
+dygraphs,dyCandlestickGroup,2,0,0,...,1
+dygraphs,dyCrosshair,-1,0,0,"class<`dygraphs`, `htmlwidget`>",1
+dygraphs,dyCrosshair,0,0,0,"class<`dygraphs`, `htmlwidget`>",1
+dygraphs,dyCrosshair,1,0,0,character,1
+dygraphs,dyDependency,-1,0,0,"class<`dygraphs`, `htmlwidget`>",1
+dygraphs,dyDependency,0,0,0,"class<`dygraphs`, `htmlwidget`>",1
+dygraphs,dyDependency,1,0,0,class<`html_dependency`>,1
+dygraphs,dyEvent,-1,0,0,"class<`dygraphs`, `htmlwidget`>",1
+dygraphs,dyEvent,0,0,0,"class<`dygraphs`, `htmlwidget`>",1
+dygraphs,dyEvent,1,0,0,character[],1
+dygraphs,dyEvent,2,0,0,character[],1
+dygraphs,dyEvent,3,0,0,character,1
+dygraphs,dyEvent,4,0,0,character,1
+dygraphs,dyEvent,5,0,0,character,1
+dygraphs,dyEvent,6,0,0,any,1
+dygraphs,dyFilledLine,-1,0,0,"class<`dygraphs`, `htmlwidget`>",1
+dygraphs,dyFilledLine,0,0,0,"class<`dygraphs`, `htmlwidget`>",1
+dygraphs,dyFilledLine,1,0,0,character,1
+dygraphs,dyFilledLine,2,0,0,...,1
+dygraphs,dygraph,-1,0,0,"class<`dygraphs`, `htmlwidget`>",1
+dygraphs,dygraph,0,0,0,class<`data.frame`>,1
+dygraphs,dygraph,0,0,1,"class<`data.frame`, `groupedData`, `nfGroupedData`, `nfnGroupedData`>",1
+dygraphs,dygraph,0,0,2,class<`matrix`>,1
+dygraphs,dygraph,0,0,3,"class<`matrix`, `mts`, `ts`>",1
+dygraphs,dygraph,0,0,4,class<`ts`>,1
+dygraphs,dygraph,1,0,0,null,1
+dygraphs,dygraph,1,0,1,character,1
+dygraphs,dygraph,2,0,0,null,1
+dygraphs,dygraph,3,0,0,null,1
+dygraphs,dygraph,4,0,0,null,1
+dygraphs,dygraph,5,0,0,null,1
+dygraphs,dygraph,6,0,0,null,1
+dygraphs,dygraph,7,0,0,null,1
+dygraphs,dygraphColors,-1,0,0,character[],1
+dygraphs,dygraphColors,0,0,0,"class<`dygraphs`, `htmlwidget`>",1
+dygraphs,dygraphColors,1,0,0,double,1
+dygraphs,dyGroup,-1,0,0,"class<`dygraphs`, `htmlwidget`>",1
+dygraphs,dyGroup,0,0,0,"class<`dygraphs`, `htmlwidget`>",1
+dygraphs,dyGroup,1,0,0,character[],1
+dygraphs,dyGroup,2,0,0,null,1
+dygraphs,dyGroup,3,0,0,null,1
+dygraphs,dyGroup,4,0,0,character,1
+dygraphs,dyGroup,5,0,0,null,1
+dygraphs,dyGroup,6,0,0,null,1
+dygraphs,dyGroup,7,0,0,null,1
+dygraphs,dyHighlight,-1,0,0,"class<`dygraphs`, `htmlwidget`>",1
+dygraphs,dyHighlight,0,0,0,"class<`dygraphs`, `htmlwidget`>",1
+dygraphs,dyHighlight,1,0,0,double,1
+dygraphs,dyHighlight,2,0,0,double,1
+dygraphs,dyHighlight,3,0,0,list<any>,1
+dygraphs,dyHighlight,4,0,0,logical,1
+dygraphs,dyLegend,-1,0,0,"class<`dygraphs`, `htmlwidget`>",1
+dygraphs,dyLegend,0,0,0,"class<`dygraphs`, `htmlwidget`>",1
+dygraphs,dyLegend,1,0,0,character,1
+dygraphs,dyLegend,2,0,0,double,1
+dygraphs,dyLegend,3,0,0,logical,1
+dygraphs,dyLegend,4,0,0,null,1
+dygraphs,dyLegend,5,0,0,logical,1
+dygraphs,dyLegend,6,0,0,logical,1
+dygraphs,dyLimit,-1,0,0,"class<`dygraphs`, `htmlwidget`>",1
+dygraphs,dyLimit,0,0,0,"class<`dygraphs`, `htmlwidget`>",1
+dygraphs,dyLimit,1,0,0,double,1
+dygraphs,dyLimit,2,0,0,character,1
+dygraphs,dyLimit,3,0,0,character[],1
+dygraphs,dyLimit,4,0,0,character,1
+dygraphs,dyLimit,5,0,0,character,1
+dygraphs,dyMultiColumn,-1,0,0,"class<`dygraphs`, `htmlwidget`>",1
+dygraphs,dyMultiColumn,0,0,0,"class<`dygraphs`, `htmlwidget`>",1
+dygraphs,dyOptions,-1,0,0,"class<`dygraphs`, `htmlwidget`>",1
+dygraphs,dyOptions,0,0,0,"class<`dygraphs`, `htmlwidget`>",1
+dygraphs,dyOptions,1,0,0,logical,1
+dygraphs,dyOptions,2,0,0,logical,1
+dygraphs,dyOptions,3,0,0,double,1
+dygraphs,dyOptions,4,0,0,logical,1
+dygraphs,dyOptions,5,0,0,logical,1
+dygraphs,dyOptions,6,0,0,logical,1
+dygraphs,dyOptions,7,0,0,double,1
+dygraphs,dyPlotter,-1,0,0,"class<`dygraphs`, `htmlwidget`>",1
+dygraphs,dyPlotter,0,0,0,"class<`dygraphs`, `htmlwidget`>",1
+dygraphs,dyPlotter,1,0,0,character,1
+dygraphs,dyPlotter,2,0,0,character,1
+dygraphs,dyPlotter,3,0,0,character,1
+dygraphs,dyPlugin,-1,0,0,"class<`dygraphs`, `htmlwidget`>",1
+dygraphs,dyPlugin,0,0,0,"class<`dygraphs`, `htmlwidget`>",1
+dygraphs,dyPlugin,1,0,0,character,1
+dygraphs,dyPlugin,2,0,0,character,1
+dygraphs,dyPlugin,3,0,0,list<any>,1
+dygraphs,dyPlugin,4,0,0,character,1
+dygraphs,dyRangeSelector,-1,0,0,"class<`dygraphs`, `htmlwidget`>",1
+dygraphs,dyRangeSelector,0,0,0,"class<`dygraphs`, `htmlwidget`>",1
+dygraphs,dyRangeSelector,1,0,0,character[],1
+dygraphs,dyRangeSelector,1,0,1,null,1
+dygraphs,dyRangeSelector,2,0,0,double,1
+dygraphs,dyRangeSelector,3,0,0,character,1
+dygraphs,dyRangeSelector,4,0,0,character,1
+dygraphs,dyRangeSelector,5,0,0,logical,1
+dygraphs,dyRangeSelector,6,0,0,logical,1
+dygraphs,dyRoller,-1,0,0,"class<`dygraphs`, `htmlwidget`>",1
+dygraphs,dyRoller,0,0,0,"class<`dygraphs`, `htmlwidget`>",1
+dygraphs,dyRoller,1,0,0,logical,1
+dygraphs,dyRoller,2,0,0,double,1
+dygraphs,dySeries,-1,0,0,"class<`dygraphs`, `htmlwidget`>",1
+dygraphs,dySeries,0,0,0,"class<`dygraphs`, `htmlwidget`>",1
+dygraphs,dySeries,1,0,0,character,1
+dygraphs,dySeries,2,0,0,character,1
+dygraphs,dySeries,2,0,1,null,1
+dygraphs,dySeries,3,0,0,null,1
+dygraphs,dySeries,3,0,1,character,1
+dygraphs,dySeries,4,0,0,character,1
+dygraphs,dySeries,5,0,0,null,1
+dygraphs,dySeries,5,0,1,logical,1
+dygraphs,dySeries,6,0,0,null,1
+dygraphs,dySeries,7,0,0,null,1
+dygraphs,dyShading,-1,0,0,"class<`dygraphs`, `htmlwidget`>",1
+dygraphs,dyShading,0,0,0,"class<`dygraphs`, `htmlwidget`>",1
+dygraphs,dyShading,1,0,0,character,1
+dygraphs,dyShading,2,0,0,character,1
+dygraphs,dyShading,3,0,0,character,1
+dygraphs,dyShading,4,0,0,character,1
+dygraphs,dyShadow,-1,0,0,"class<`dygraphs`, `htmlwidget`>",1
+dygraphs,dyShadow,0,0,0,"class<`dygraphs`, `htmlwidget`>",1
+dygraphs,dyShadow,1,0,0,character,1
+dygraphs,dyShadow,2,0,0,...,1
+dygraphs,dyStackedBarGroup,-1,0,0,"class<`dygraphs`, `htmlwidget`>",1
+dygraphs,dyStackedBarGroup,0,0,0,"class<`dygraphs`, `htmlwidget`>",1
+dygraphs,dyStackedBarGroup,1,0,0,character[],1
+dygraphs,dyStackedBarGroup,2,0,0,...,1
+dygraphs,dyStackedRibbonGroup,-1,0,0,"class<`dygraphs`, `htmlwidget`>",1
+dygraphs,dyStackedRibbonGroup,0,0,0,"class<`dygraphs`, `htmlwidget`>",1
+dygraphs,dyStackedRibbonGroup,1,0,0,character[],1
+dygraphs,dyStackedRibbonGroup,2,0,0,...,1
+dygraphs,dyStemSeries,-1,0,0,"class<`dygraphs`, `htmlwidget`>",1
+dygraphs,dyStemSeries,0,0,0,"class<`dygraphs`, `htmlwidget`>",1
+dygraphs,dyStemSeries,1,0,0,character,1
+dygraphs,dyStemSeries,2,0,0,...,1
+dygraphs,dyUnzoom,-1,0,0,"class<`dygraphs`, `htmlwidget`>",1
+dygraphs,dyUnzoom,0,0,0,"class<`dygraphs`, `htmlwidget`>",1
+dygraphs,hsvToRGB,-1,0,0,character,1
+dygraphs,hsvToRGB,0,0,0,double,1
+dygraphs,hsvToRGB,1,0,0,double,1
+dygraphs,hsvToRGB,2,0,0,double,1
+dygraphs,mergeLists,-1,0,0,list<any>,1
+dygraphs,mergeLists,0,0,0,list<character[] | logical | list<list<double[]>>>,1
+dygraphs,mergeLists,0,0,1,list<character[] | logical | list<list<double | character | double[] | character | logical | character | class<`JS_EVAL`>>>>,1
+dygraphs,mergeLists,0,0,2,list<character[] | logical | list<list<double[] | character | double[] | logical | character | class<`JS_EVAL`> | character | class<`JS_EVAL`>>>>,1
+dygraphs,mergeLists,0,0,3,list<character[] | logical | list<list<double[] | character | character | class<`JS_EVAL`>>>>,1
+dygraphs,mergeLists,0,0,4,list<character[] | logical | list<list<double | character>>>,1
+dygraphs,mergeLists,0,0,5,list<character[] | logical | list<list<double>>>,1
+dygraphs,mergeLists,0,0,6,list<character>,1
+dygraphs,mergeLists,0,0,7,null,1
+dygraphs,mergeLists,0,0,8,list<character | class<`JS_EVAL`>>,1
+dygraphs,mergeLists,0,0,9,list<character | logical>,1
+dygraphs,mergeLists,0,0,10,list<character | double[]>,1
+dygraphs,mergeLists,0,0,11,list<list<character | double[] | character | logical | character | class<`JS_EVAL`>>>,1
+dygraphs,mergeLists,0,0,12,list<list<character | double[] | logical | character | class<`JS_EVAL`> | character | class<`JS_EVAL`>>>,1
+dygraphs,mergeLists,0,0,13,list<list<character | character | class<`JS_EVAL`>>>,1
+dygraphs,mergeLists,0,0,14,list<list<character>>,1
+dygraphs,mergeLists,0,0,15,list<logical | character | class<`JS_EVAL`>>,1
+dygraphs,mergeLists,0,0,16,list<double[]>,1
+dygraphs,mergeLists,0,0,17,list<list<double[]>>,1
+dygraphs,mergeLists,1,0,0,list<double | character | list<list<logical>>>,1
+dygraphs,mergeLists,1,0,1,list<character[] | logical | list<list<double[] | character | double[] | character | logical | character | class<`JS_EVAL`>>>>,1
+dygraphs,mergeLists,1,0,2,list<character[] | logical | list<list<double[] | character | double[] | logical | character | class<`JS_EVAL`> | character | class<`JS_EVAL`>>>>,1
+dygraphs,mergeLists,1,0,3,list<character[] | logical | list<list<double[] | character | character | class<`JS_EVAL`>>>>,1
+dygraphs,mergeLists,1,0,4,list<character[] | logical | list<list<double[] | character>>>,1
+dygraphs,mergeLists,1,0,5,list<character[] | logical | list<list<double[]>>>,1
+dygraphs,mergeLists,1,0,6,list<character>,1
+dygraphs,mergeLists,1,0,7,list<character | class<`JS_EVAL`>>,1
+dygraphs,mergeLists,1,0,8,list<character | logical>,1
+dygraphs,mergeLists,1,0,9,list<character | double[]>,1
+dygraphs,mergeLists,1,0,10,list<double | character | class<`JS_EVAL`>>,1
+dygraphs,mergeLists,1,0,11,list<list<character | double[] | character | logical | character | class<`JS_EVAL`>>>,1
+dygraphs,mergeLists,1,0,12,list<list<character | double[] | logical | character | class<`JS_EVAL`> | character | class<`JS_EVAL`>>>,1
+dygraphs,mergeLists,1,0,13,list<list<character | character | class<`JS_EVAL`>>>,1
+dygraphs,mergeLists,1,0,14,list<list<character>>,1
+dygraphs,mergeLists,1,0,15,list<logical | character | class<`JS_EVAL`>>,1
+dygraphs,mergeLists,1,0,16,list<double | list<any>>,1
+dygraphs,mergeLists,1,0,17,list<character[] | double | class<`JS_EVAL`>>,1
+dygraphs,mergeLists,1,0,18,list<character | double>,1
+dygraphs,mergeLists,1,0,19,list<double[]>,1
+dygraphs,mergeLists,1,0,20,list<list<double[]>>,1
+dygraphs,mergeLists,2,0,0,logical,1
+dygraphs,resolveStemPlot,-1,0,0,character,1
+dygraphs,resolveStemPlot,-1,0,1,null,1
+dygraphs,resolveStemPlot,0,0,0,null,1
+dygraphs,resolveStemPlot,0,0,1,logical,1
+dygraphs,resolveStemPlot,1,0,0,character,1
+dygraphs,resolveStemPlot,1,0,1,null,1
+dygraphs,resolveStrokePattern,-1,0,0,double[],1
+dygraphs,resolveStrokePattern,-1,0,1,null,1
+dygraphs,resolveStrokePattern,0,0,0,character,1
+dygraphs,resolveStrokePattern,0,0,1,null,1
+e1071,allShortestPaths,-1,0,0,list<class<`matrix`>>,1
+e1071,allShortestPaths,0,0,0,class<`matrix`>,1
+e1071,bclust,-1,0,0,class<`bclust`>,1
+e1071,bclust,0,0,0,class<`data.frame`>,1
+e1071,bclust,1,0,0,double,1
+e1071,bclust,2,0,0,double,1
+e1071,bclust,3,0,0,double,1
+e1071,bclust,4,0,0,character,1
+e1071,bclust,5,0,0,character,1
+e1071,bclust,6,0,0,character,1
+e1071,bclust,7,0,0,double,1
+e1071,bincombinations,-1,0,0,class<`matrix`>,1
+e1071,bincombinations,0,0,0,double,1
+e1071,bootstrap.lca,-1,0,0,class<`bootstrap.lca`>,1
+e1071,bootstrap.lca,0,0,0,class<`lca`>,1
+e1071,bootstrap.lca,1,0,0,double,1
+e1071,bootstrap.lca,2,0,0,double,1
+e1071,bootstrap.lca,3,0,0,logical,1
+e1071,boxplot.bclust,-1,0,0,null,1
+e1071,boxplot.bclust,0,0,0,class<`bclust`>,1
+e1071,boxplot.bclust,1,0,0,integer,1
+e1071,boxplot.bclust,2,0,0,logical,1
+e1071,boxplot.bclust,3,0,0,any,1
+e1071,boxplot.bclust,4,0,0,logical,1
+e1071,boxplot.bclust,5,0,0,integer[],1
+e1071,boxplot.bclust,6,0,0,...,1
+e1071,centers.bclust,-1,0,0,class<`matrix`>,1
+e1071,centers.bclust,0,0,0,class<`bclust`>,1
+e1071,centers.bclust,1,0,0,double,1
+e1071,classAgreement,-1,0,0,list<double>,1
+e1071,classAgreement,0,0,0,class<`table`>,1
+e1071,classAgreement,1,0,0,logical,1
+e1071,classAgreement,-1,1,0,double,1
+e1071,classAgreement,0,1,0,class<`table`>,1
+e1071,clusters.bclust,-1,0,0,integer[],1
+e1071,clusters.bclust,0,0,0,class<`bclust`>,1
+e1071,clusters.bclust,1,0,0,double,1
+e1071,clusters.bclust,2,0,0,null,1
+e1071,cmeans,-1,0,0,class<`fclust`>,1
+e1071,cmeans,0,0,0,class<`matrix`>,1
+e1071,cmeans,0,0,1,class<`data.frame`>,1
+e1071,cmeans,1,0,0,double,1
+e1071,cmeans,2,0,0,double,1
+e1071,cmeans,3,0,0,logical,1
+e1071,cmeans,4,0,0,character,1
+e1071,cmeans,5,0,0,character,1
+e1071,cmeans,6,0,0,double,1
+e1071,cmeans,7,0,0,null,1
+e1071,coef.svm,-1,0,0,double[],1
+e1071,coef.svm,0,0,0,"class<`svm`, `svm.formula`>",1
+e1071,coef.svm,1,0,0,...,1
+e1071,compareMatchedClasses,-1,0,0,list<class<`matrix`>>,1
+e1071,compareMatchedClasses,0,0,0,double[],1
+e1071,compareMatchedClasses,1,0,0,double[],1
+e1071,compareMatchedClasses,2,0,0,character,1
+e1071,compareMatchedClasses,3,0,0,double,1
+e1071,compareMatchedClasses,4,0,0,double,1
+e1071,compareMatchedClasses,5,0,0,logical,1
+e1071,countpattern,-1,0,0,integer[],1
+e1071,countpattern,-1,0,1,list<double[]>,1
+e1071,countpattern,0,0,0,class<`matrix`>,1
+e1071,countpattern,1,0,0,logical,1
+e1071,cshell,-1,0,0,"class<`cshell`, `fclust`>",1
+e1071,cshell,0,0,0,class<`matrix`>,1
+e1071,cshell,1,0,0,double,1
+e1071,cshell,2,0,0,double,1
+e1071,cshell,3,0,0,logical,1
+e1071,cshell,4,0,0,character,1
+e1071,cshell,5,0,0,character,1
+e1071,cshell,6,0,0,double,1
+e1071,cshell,7,0,0,null,1
+e1071,dsigmoid,-1,0,0,double[],1
+e1071,dsigmoid,0,0,0,double[],1
+e1071,element,-1,0,0,double,1
+e1071,element,0,0,0,class<`matrix`>,1
+e1071,element,0,0,1,class<`array`>,1
+e1071,element,1,0,0,double[],1
+e1071,extractPath,-1,0,0,double[],1
+e1071,extractPath,0,0,0,list<class<`matrix`>>,1
+e1071,extractPath,1,0,0,double,1
+e1071,extractPath,2,0,0,double,1
+e1071,fclustIndex,-1,0,0,double[],1
+e1071,fclustIndex,0,0,0,class<`fclust`>,1
+e1071,fclustIndex,1,0,0,class<`matrix`>,1
+e1071,fclustIndex,2,0,0,character,1
+e1071,hamming.distance,-1,0,0,class<`matrix`>,1
+e1071,hamming.distance,-1,0,1,integer,1
+e1071,hamming.distance,0,0,0,class<`matrix`>,1
+e1071,hamming.distance,0,0,1,double[],1
+e1071,hamming.distance,1,0,0,any,1
+e1071,hamming.window,-1,0,0,double[],1
+e1071,hamming.window,0,0,0,double,1
+e1071,hanning.window,-1,0,0,double[],1
+e1071,hanning.window,0,0,0,double,1
+e1071,hclust.bclust,-1,0,0,class<`bclust`>,1
+e1071,hclust.bclust,0,0,0,class<`bclust`>,1
+e1071,hclust.bclust,1,0,0,any,1
+e1071,hclust.bclust,2,0,0,double,1
+e1071,hclust.bclust,3,0,0,character,1
+e1071,hclust.bclust,4,0,0,character,1
+e1071,hclust.bclust,5,0,0,logical,1
+e1071,hclust.bclust,6,0,0,logical,1
+e1071,hclust.bclust,7,0,0,double,1
+e1071,hsv_palette,-1,0,0,character[],1
+e1071,hsv_palette,0,0,0,double,1
+e1071,hsv_palette,-1,1,0,class<`function`>,1
+e1071,hsv_palette,0,1,0,any,1
+e1071,hsv_palette,1,1,0,double,1
+e1071,hsv_palette,2,1,0,double,1
+e1071,hsv_palette,3,1,0,double,1
+e1071,impute,-1,0,0,class<`matrix`>,1
+e1071,impute,0,0,0,class<`matrix`>,1
+e1071,impute,1,0,0,character[],1
+e1071,interpolate,-1,0,0,double,1
+e1071,interpolate,0,0,0,double[],1
+e1071,interpolate,1,0,0,class<`matrix`>,1
+e1071,interpolate,2,0,0,list<double[]>,1
+e1071,interpolate,3,0,0,character,1
+e1071,knn.wrapper,-1,0,0,list<class<`data.frame`> | class<`factor`> | double>,1
+e1071,knn.wrapper,0,0,0,class<`data.frame`>,1
+e1071,knn.wrapper,1,0,0,class<`factor`>,1
+e1071,knn.wrapper,2,0,0,integer,1
+e1071,knn.wrapper,3,0,0,double,1
+e1071,knn.wrapper,4,0,0,...,1
+e1071,kurtosis,-1,0,0,double,1
+e1071,kurtosis,0,0,0,double[],1
+e1071,kurtosis,1,0,0,logical,1
+e1071,kurtosis,2,0,0,double,1
+e1071,lca,-1,0,0,class<`lca`>,1
+e1071,lca,0,0,0,class<`matrix`>,1
+e1071,lca,0,0,1,integer[],1
+e1071,lca,1,0,0,double,1
+e1071,lca,2,0,0,double,1
+e1071,lca,3,0,0,logical,1
+e1071,lca,4,0,0,logical,1
+e1071,lines.probplot,-1,0,0,null,1
+e1071,lines.probplot,0,0,0,class<`probplot`>,1
+e1071,lines.probplot,1,0,0,double[],1
+e1071,lines.probplot,1,0,1,null,1
+e1071,lines.probplot,2,0,0,null,1
+e1071,lines.probplot,2,0,1,double,1
+e1071,lines.probplot,3,0,0,logical,1
+e1071,lines.probplot,4,0,0,...,1
+e1071,matchClasses,-1,0,0,integer[],1
+e1071,matchClasses,0,0,0,class<`table`>,1
+e1071,matchClasses,1,0,0,character,1
+e1071,matchClasses,2,0,0,any,1
+e1071,matchClasses,3,0,0,double,1
+e1071,matchClasses,4,0,0,logical,1
+e1071,matchControls,-1,0,0,list<character[] | class<`factor`>>,1
+e1071,matchControls,0,0,0,any,1
+e1071,matchControls,1,0,0,any,1
+e1071,matchControls,2,0,0,any,1
+e1071,matchControls,3,0,0,character,1
+e1071,matchControls,4,0,0,null,1
+e1071,matchControls,5,0,0,logical,1
+e1071,matchControls,6,0,0,logical,1
+e1071,moment,-1,0,0,double,1
+e1071,moment,0,0,0,double[],1
+e1071,moment,1,0,0,double,1
+e1071,moment,2,0,0,logical,1
+e1071,moment,3,0,0,logical,1
+e1071,moment,4,0,0,logical,1
+e1071,naiveBayes,-1,0,0,class<`naiveBayes`>,1
+e1071,naiveBayes,0,0,0,class<`data.frame`>,1
+e1071,naiveBayes,0,0,1,class<`formula`>,1
+e1071,naiveBayes,1,0,0,...,1
+e1071,naiveBayes.default,-1,0,0,class<`naiveBayes`>,1
+e1071,naiveBayes.default,0,0,0,class<`data.frame`>,1
+e1071,naiveBayes.default,1,0,0,class<`factor`>,1
+e1071,naiveBayes.default,2,0,0,any,1
+e1071,naiveBayes.default,3,0,0,...,1
+e1071,naiveBayes.formula,-1,0,0,class<`naiveBayes`>,1
+e1071,naiveBayes.formula,0,0,0,class<`formula`>,1
+e1071,naiveBayes.formula,1,0,0,class<`data.frame`>,1
+e1071,naiveBayes.formula,1,0,1,class<`table`>,1
+e1071,naiveBayes.formula,2,0,0,double,1
+e1071,naiveBayes.formula,3,0,0,...,1
+e1071,naiveBayes.formula,4,0,0,any,1
+e1071,naiveBayes.formula,5,0,0,any,1
+e1071,permutations,-1,0,0,class<`matrix`>,1
+e1071,permutations,0,0,0,double,1
+e1071,plot.bclust,-1,0,0,integer,1
+e1071,plot.bclust,0,0,0,class<`bclust`>,1
+e1071,plot.bclust,1,0,0,double,1
+e1071,plot.bclust,2,0,0,character,1
+e1071,plot.bclust,3,0,0,...,1
+e1071,plot.stft,-1,0,0,null,1
+e1071,plot.stft,0,0,0,class<`stft`>,1
+e1071,plot.stft,1,0,0,character[],1
+e1071,plot.stft,2,0,0,...,1
+e1071,plot.svm,-1,0,0,null,1
+e1071,plot.svm,0,0,0,"class<`svm`, `svm.formula`>",1
+e1071,plot.svm,1,0,0,class<`data.frame`>,1
+e1071,plot.svm,2,0,0,class<`formula`>,1
+e1071,plot.svm,2,0,1,null,1
+e1071,plot.svm,3,0,0,logical,1
+e1071,plot.svm,4,0,0,double,1
+e1071,plot.svm,5,0,0,list<any>,1
+e1071,plot.svm,6,0,0,character[],1
+e1071,plot.svm,7,0,0,character,1
+e1071,plot.svm,7,0,1,double,1
+e1071,plot.tune,-1,0,0,class<`matrix`>,1
+e1071,plot.tune,-1,0,1,null,1
+e1071,plot.tune,0,0,0,class<`tune`>,1
+e1071,plot.tune,1,0,0,character[],1
+e1071,plot.tune,2,0,0,double,1
+e1071,plot.tune,3,0,0,character,1
+e1071,plot.tune,4,0,0,null,1
+e1071,plot.tune,5,0,0,null,1
+e1071,plot.tune,6,0,0,null,1
+e1071,plot.tune,7,0,0,logical,1
+e1071,predict.lca,-1,0,0,integer[],1
+e1071,predict.lca,0,0,0,class<`lca`>,1
+e1071,predict.lca,1,0,0,class<`matrix`>,1
+e1071,predict.lca,2,0,0,...,1
+e1071,predict.naiveBayes,-1,0,0,class<`factor`>,1
+e1071,predict.naiveBayes,-1,0,1,class<`matrix`>,1
+e1071,predict.naiveBayes,0,0,0,class<`naiveBayes`>,1
+e1071,predict.naiveBayes,1,0,0,class<`data.frame`>,1
+e1071,predict.naiveBayes,2,0,0,character[],1
+e1071,predict.naiveBayes,3,0,0,double,1
+e1071,predict.naiveBayes,4,0,0,double,1
+e1071,predict.naiveBayes,5,0,0,...,1
+e1071,predict.svm,-1,0,0,class<`factor`>,1
+e1071,predict.svm,-1,0,1,double[],1
+e1071,predict.svm,0,0,0,class<`svm`>,1
+e1071,predict.svm,0,0,1,"class<`svm`, `svm.formula`>",1
+e1071,predict.svm,1,0,0,class<`data.frame`>,1
+e1071,predict.svm,1,0,1,class<`matrix`>,1
+e1071,predict.svm,1,0,2,double[],1
+e1071,predict.svm,2,0,0,logical,1
+e1071,predict.svm,3,0,0,logical,1
+e1071,predict.svm,4,0,0,...,1
+e1071,predict.svm,5,0,0,class<`function`>,1
+e1071,print.fclust,-1,0,0,"class<`cshell`, `fclust`>",1
+e1071,print.fclust,-1,0,1,class<`fclust`>,1
+e1071,print.fclust,0,0,0,"class<`cshell`, `fclust`>",1
+e1071,print.fclust,0,0,1,class<`fclust`>,1
+e1071,print.fclust,1,0,0,...,1
+e1071,print.lca,-1,0,0,class<`matrix`>,1
+e1071,print.lca,0,0,0,class<`lca`>,1
+e1071,print.lca,1,0,0,...,1
+e1071,print.svm,-1,0,0,null,1
+e1071,print.svm,0,0,0,class<`svm`>,1
+e1071,print.svm,1,0,0,...,1
+e1071,probplot,-1,0,0,class<`probplot`>,1
+e1071,probplot,0,0,0,double[],1
+e1071,probplot,1,0,0,character,1
+e1071,probplot,1,0,1,class<`function`>,1
+e1071,probplot,2,0,0,null,1
+e1071,probplot,3,0,0,logical,1
+e1071,probplot,4,0,0,null,1
+e1071,probplot,5,0,0,character,1
+e1071,probplot,6,0,0,...,1
+e1071,rbridge,-1,0,0,class<`ts`>,1
+e1071,rbridge,0,0,0,double,1
+e1071,rbridge,1,0,0,double,1
+e1071,rdiscrete,-1,0,0,character[],1
+e1071,rdiscrete,-1,0,1,integer[],1
+e1071,rdiscrete,0,0,0,double,1
+e1071,rdiscrete,1,0,0,double[],1
+e1071,rdiscrete,2,0,0,character[],1
+e1071,rdiscrete,2,0,1,integer[],1
+e1071,rdiscrete,3,0,0,...,1
+e1071,rpart.wrapper,-1,0,0,class<`rpart`>,1
+e1071,rpart.wrapper,0,0,0,class<`formula`>,1
+e1071,rpart.wrapper,1,0,0,double,1
+e1071,rpart.wrapper,2,0,0,double,1
+e1071,rpart.wrapper,3,0,0,double,1
+e1071,rpart.wrapper,4,0,0,double,1
+e1071,rpart.wrapper,5,0,0,double,1
+e1071,rpart.wrapper,6,0,0,double,1
+e1071,rpart.wrapper,7,0,0,double,1
+e1071,rwiener,-1,0,0,class<`ts`>,1
+e1071,rwiener,0,0,0,double,1
+e1071,rwiener,1,0,0,double,1
+e1071,sigmoid,-1,0,0,double[],1
+e1071,sigmoid,0,0,0,double[],1
+e1071,skewness,-1,0,0,double,1
+e1071,skewness,0,0,0,double[],1
+e1071,skewness,1,0,0,logical,1
+e1071,skewness,2,0,0,double,1
+e1071,stft,-1,0,0,class<`stft`>,1
+e1071,stft,0,0,0,double[],1
+e1071,stft,1,0,0,double,1
+e1071,stft,2,0,0,double,1
+e1071,stft,3,0,0,double,1
+e1071,stft,4,0,0,character,1
+e1071,summary.lca,-1,0,0,class<`summary.lca`>,1
+e1071,summary.lca,0,0,0,class<`lca`>,1
+e1071,summary.lca,1,0,0,...,1
+e1071,summary.svm,-1,0,0,class<`summary.svm`>,1
+e1071,summary.svm,0,0,0,class<`svm`>,1
+e1071,summary.svm,1,0,0,...,1
+e1071,summary.tune,-1,0,0,class<`summary.tune`>,1
+e1071,summary.tune,0,0,0,class<`tune`>,1
+e1071,summary.tune,1,0,0,...,1
+e1071,svm,-1,0,0,class<`svm`>,1
+e1071,svm,-1,0,1,"class<`svm`, `svm.formula`>",1
+e1071,svm,0,0,0,class<`data.frame`>,1
+e1071,svm,0,0,1,double[],1
+e1071,svm,0,0,2,class<`formula`>,1
+e1071,svm,1,0,0,...,1
+e1071,svm.default,-1,0,0,class<`svm`>,1
+e1071,svm.default,0,0,0,class<`matrix`>,1
+e1071,svm.default,0,0,1,class<`data.frame`>,1
+e1071,svm.default,0,0,2,double[],1
+e1071,svm.default,1,0,0,class<`factor`>,1
+e1071,svm.default,1,0,1,double[],1
+e1071,svm.default,1,0,2,null,1
+e1071,svm.default,2,0,0,logical[],1
+e1071,svm.default,3,0,0,null,1
+e1071,svm.default,4,0,0,character,1
+e1071,svm.default,5,0,0,double,1
+e1071,svm.default,6,0,0,double,1
+e1071,svm.default,7,0,0,double,1
+e1071,svm.formula,-1,0,0,"class<`svm`, `svm.formula`>",1
+e1071,svm.formula,0,0,0,class<`formula`>,1
+e1071,svm.formula,1,0,0,any,1
+e1071,svm.formula,2,0,0,...,1
+e1071,svm.formula,3,0,0,any,1
+e1071,svm.formula,4,0,0,class<`function`>,1
+e1071,svm.formula,5,0,0,logical,1
+e1071,tune,-1,0,0,class<`tune`>,1
+e1071,tune,0,0,0,character,1
+e1071,tune,0,0,1,class<`function`>,1
+e1071,tune,1,0,0,class<`data.frame`>,1
+e1071,tune,1,0,1,class<`formula`>,1
+e1071,tune,2,0,0,class<`factor`>,1
+e1071,tune,2,0,1,null,1
+e1071,tune,3,0,0,any,1
+e1071,tune,4,0,0,null,1
+e1071,tune,5,0,0,null,1
+e1071,tune,6,0,0,list<double[]>,1
+e1071,tune,6,0,1,null,1
+e1071,tune,7,0,0,class<`function`>,1
+e1071,tune.control,-1,0,0,class<`tune.control`>,1
+e1071,tune.control,0,0,0,logical,1
+e1071,tune.control,1,0,0,double,1
+e1071,tune.control,2,0,0,class<`function`>,1
+e1071,tune.control,3,0,0,character[],1
+e1071,tune.control,4,0,0,class<`function`>,1
+e1071,tune.control,5,0,0,class<`function`>,1
+e1071,tune.control,6,0,0,double,1
+e1071,tune.control,7,0,0,double,1
+e1071,tune.knn,-1,0,0,class<`tune`>,1
+e1071,tune.knn,0,0,0,class<`data.frame`>,1
+e1071,tune.knn,1,0,0,class<`factor`>,1
+e1071,tune.knn,2,0,0,integer[],1
+e1071,tune.knn,3,0,0,null,1
+e1071,tune.knn,4,0,0,...,1
+e1071,tune.rpart,-1,0,0,class<`tune`>,1
+e1071,tune.rpart,0,0,0,class<`formula`>,1
+e1071,tune.rpart,1,0,0,class<`data.frame`>,1
+e1071,tune.rpart,2,0,0,class<`function`>,1
+e1071,tune.rpart,3,0,0,double[],1
+e1071,tune.rpart,4,0,0,null,1
+e1071,tune.rpart,5,0,0,null,1
+e1071,tune.rpart,6,0,0,null,1
+e1071,tune.rpart,7,0,0,null,1
+e1071,tune.svm,-1,0,0,class<`tune`>,1
+e1071,tune.svm,0,0,0,class<`formula`>,1
+e1071,tune.svm,1,0,0,null,1
+e1071,tune.svm,2,0,0,class<`data.frame`>,1
+e1071,tune.svm,3,0,0,null,1
+e1071,tune.svm,4,0,0,double[],1
+e1071,tune.svm,5,0,0,null,1
+e1071,tune.svm,6,0,0,double[],1
+e1071,tune.svm,7,0,0,null,1
+e1071,write.svm,-1,0,0,null,1
+e1071,write.svm,0,0,0,"class<`svm`, `svm.formula`>",1
+e1071,write.svm,1,0,0,character,1
+e1071,write.svm,2,0,0,character,1
+e1071,write.svm,3,0,0,character,1
+elasticnet,cv.enet,-1,0,0,list<double[]>,1
+elasticnet,cv.enet,0,0,0,class<`AsIs`>,1
+elasticnet,cv.enet,1,0,0,double[],1
+elasticnet,cv.enet,2,0,0,double,1
+elasticnet,cv.enet,3,0,0,double,1
+elasticnet,cv.enet,4,0,0,double[],1
+elasticnet,cv.enet,5,0,0,character,1
+elasticnet,cv.enet,6,0,0,logical,1
+elasticnet,cv.enet,7,0,0,logical,1
+elasticnet,enet,-1,0,0,class<`enet`>,1
+elasticnet,enet,0,0,0,class<`AsIs`>,1
+elasticnet,enet,1,0,0,double[],1
+elasticnet,enet,2,0,0,double,1
+elasticnet,enet,3,0,0,any,1
+elasticnet,enet,4,0,0,logical,1
+elasticnet,enet,5,0,0,logical,1
+elasticnet,enet,6,0,0,logical,1
+elasticnet,enet,7,0,0,double,1
+elasticnet,plot.enet,-1,0,0,null,1
+elasticnet,plot.enet,0,0,0,class<`enet`>,1
+elasticnet,plot.enet,1,0,0,character[],1
+elasticnet,plot.enet,2,0,0,logical,1
+elasticnet,plot.enet,3,0,0,...,1
+elasticnet,predict.enet,-1,0,0,list<double[] | character | class<`matrix`>>,1
+elasticnet,predict.enet,-1,0,1,list<character | double[]>,1
+elasticnet,predict.enet,0,0,0,class<`enet`>,1
+elasticnet,predict.enet,1,0,0,any,1
+elasticnet,predict.enet,2,0,0,any,1
+elasticnet,predict.enet,3,0,0,character[],1
+elasticnet,predict.enet,4,0,0,character[],1
+elasticnet,predict.enet,5,0,0,logical,1
+elasticnet,predict.enet,6,0,0,...,1
+elasticnet,rootmatrix,-1,0,0,class<`matrix`>,1
+elasticnet,rootmatrix,0,0,0,class<`matrix`>,1
+elasticnet,solvebeta,-1,0,0,double[],1
+elasticnet,solvebeta,0,0,0,class<`matrix`>,1
+elasticnet,solvebeta,1,0,0,double[],1
+elasticnet,solvebeta,2,0,0,double[],1
+elasticnet,solvebeta,3,0,0,any,1
+elasticnet,solvebeta,4,0,0,character,1
+elasticnet,solvebeta,5,0,0,double,1
+elasticnet,spca,-1,0,0,class<`spca`>,1
+elasticnet,spca,0,0,0,class<`matrix`>,1
+elasticnet,spca,1,0,0,double,1
+elasticnet,spca,2,0,0,double[],1
+elasticnet,spca,3,0,0,character,1
+elasticnet,spca,4,0,0,character,1
+elasticnet,spca,5,0,0,logical,1
+elasticnet,spca,6,0,0,double,1
+elasticnet,spca,7,0,0,double,1
+elasticnet,updateRR,-1,0,0,class<`matrix`>,1
+elasticnet,updateRR,0,0,0,class<`AsIs`>,1
+elasticnet,updateRR,0,0,1,double[],1
+elasticnet,updateRR,1,0,0,class<`matrix`>,1
+elasticnet,updateRR,1,0,1,null,1
+elasticnet,updateRR,2,0,0,any,1
+elasticnet,updateRR,3,0,0,double,1
+elasticnet,updateRR,4,0,0,any,1
+ellipse,ellipse,-1,0,0,class<`matrix`>,1
+ellipse,ellipse,0,0,0,class<`arima0`>,1
+ellipse,ellipse,0,0,1,"class<`glm`, `lm`>",1
+ellipse,ellipse,0,0,2,class<`lm`>,1
+ellipse,ellipse,0,0,3,class<`matrix`>,1
+ellipse,ellipse,0,0,4,class<`nls`>,1
+ellipse,ellipse,0,0,5,"class<`profile`, `profile.glm`>",1
+ellipse,ellipse,0,0,6,"class<`profile`, `profile.nls`>",1
+ellipse,ellipse,0,0,7,double,1
+ellipse,ellipse,1,0,0,...,1
+ellipse,ellipse.arima0,-1,0,0,class<`matrix`>,1
+ellipse,ellipse.arima0,0,0,0,class<`arima0`>,1
+ellipse,ellipse.arima0,1,0,0,double[],1
+ellipse,ellipse.arima0,2,0,0,double,1
+ellipse,ellipse.arima0,3,0,0,double,1
+ellipse,ellipse.arima0,4,0,0,...,1
+ellipse,ellipse.default,-1,0,0,class<`matrix`>,1
+ellipse,ellipse.default,0,0,0,class<`matrix`>,1
+ellipse,ellipse.default,0,0,1,double,1
+ellipse,ellipse.default,1,0,0,any,1
+ellipse,ellipse.default,2,0,0,double[],1
+ellipse,ellipse.default,3,0,0,double,1
+ellipse,ellipse.default,4,0,0,double,1
+ellipse,ellipse.default,5,0,0,any,1
+ellipse,ellipse.default,6,0,0,double,1
+ellipse,ellipse.default,7,0,0,...,1
+ellipse,ellipse.glm,-1,0,0,class<`matrix`>,1
+ellipse,ellipse.glm,0,0,0,"class<`glm`, `lm`>",1
+ellipse,ellipse.glm,1,0,0,double[],1
+ellipse,ellipse.glm,2,0,0,double,1
+ellipse,ellipse.glm,3,0,0,any,1
+ellipse,ellipse.glm,4,0,0,double,1
+ellipse,ellipse.glm,5,0,0,any,1
+ellipse,ellipse.glm,6,0,0,...,1
+ellipse,ellipse.lm,-1,0,0,class<`matrix`>,1
+ellipse,ellipse.lm,0,0,0,class<`lm`>,1
+ellipse,ellipse.lm,1,0,0,character[],1
+ellipse,ellipse.lm,2,0,0,double,1
+ellipse,ellipse.lm,3,0,0,double,1
+ellipse,ellipse.lm,4,0,0,...,1
+ellipse,ellipse.nls,-1,0,0,class<`matrix`>,1
+ellipse,ellipse.nls,0,0,0,class<`nls`>,1
+ellipse,ellipse.nls,1,0,0,character[],1
+ellipse,ellipse.nls,1,0,1,integer[],1
+ellipse,ellipse.nls,2,0,0,double,1
+ellipse,ellipse.nls,3,0,0,double,1
+ellipse,ellipse.nls,4,0,0,...,1
+ellipse,ellipse.profile,-1,0,0,class<`matrix`>,1
+ellipse,ellipse.profile,0,0,0,"class<`profile`, `profile.glm`>",1
+ellipse,ellipse.profile,0,0,1,"class<`profile`, `profile.nls`>",1
+ellipse,ellipse.profile,1,0,0,integer[],1
+ellipse,ellipse.profile,1,0,1,character[],1
+ellipse,ellipse.profile,2,0,0,any,1
+ellipse,ellipse.profile,3,0,0,double,1
+ellipse,ellipse.profile,4,0,0,double,1
+ellipse,ellipse.profile,5,0,0,...,1
+ellipse,ellipse.profile.glm,-1,0,0,class<`matrix`>,1
+ellipse,ellipse.profile.glm,0,0,0,"class<`profile`, `profile.glm`>",1
+ellipse,ellipse.profile.glm,1,0,0,integer[],1
+ellipse,ellipse.profile.glm,2,0,0,double,1
+ellipse,ellipse.profile.glm,3,0,0,any,1
+ellipse,ellipse.profile.glm,4,0,0,double,1
+ellipse,ellipse.profile.glm,5,0,0,any,1
+ellipse,ellipse.profile.glm,6,0,0,...,1
+ellipse,ellipse.profile.nls,-1,0,0,class<`matrix`>,1
+ellipse,ellipse.profile.nls,0,0,0,"class<`profile`, `profile.nls`>",1
+ellipse,ellipse.profile.nls,1,0,0,character[],1
+ellipse,ellipse.profile.nls,1,0,1,integer[],1
+ellipse,ellipse.profile.nls,2,0,0,double,1
+ellipse,ellipse.profile.nls,3,0,0,double,1
+ellipse,ellipse.profile.nls,4,0,0,double,1
+ellipse,ellipse.profile.nls,5,0,0,...,1
+ellipse,pairs,-1,0,0,null,1
+ellipse,pairs,0,0,0,class<`data.frame`>,1
+ellipse,pairs,0,0,1,class<`formula`>,1
+ellipse,pairs,1,0,0,...,1
+ellipse,pairs.profile,-1,0,0,null,1
+ellipse,pairs.profile,0,0,0,"class<`profile`, `profile.nls`>",1
+ellipse,pairs.profile,1,0,0,character[],1
+ellipse,pairs.profile,2,0,0,class<`function`>,1
+ellipse,pairs.profile,3,0,0,logical,1
+ellipse,pairs.profile,4,0,0,logical,1
+ellipse,pairs.profile,5,0,0,logical,1
+ellipse,pairs.profile,6,0,0,logical,1
+ellipse,pairs.profile,7,0,0,logical,1
+ellipse,pairs.profile,8,0,0,double,1
+ellipse,pairs.profile,9,0,0,...,1
+ellipse,plotcorr,-1,0,0,null,1
+ellipse,plotcorr,0,0,0,class<`matrix`>,1
+ellipse,plotcorr,1,0,0,logical,1
+ellipse,plotcorr,2,0,0,character[],1
+ellipse,plotcorr,3,0,0,logical,1
+ellipse,plotcorr,4,0,0,character[],1
+ellipse,plotcorr,5,0,0,logical,1
+ellipse,plotcorr,6,0,0,character,1
+ellipse,plotcorr,7,0,0,logical,1
+ellipse,plotcorr,8,0,0,character,1
+ellipse,plotcorr,9,0,0,character,1
+ellipse,plotcorr,10,0,0,double,1
+ellipse,plotcorr,11,0,0,double,1
+ellipse,plotcorr,12,0,0,any,1
+ellipse,plotcorr,13,0,0,double[],1
+ellipse,plotcorr,14,0,0,...,1
+ellipsis,action_dots,-1,0,0,any,1
+ellipsis,action_dots,0,0,0,class<`function`>,1
+ellipsis,action_dots,1,0,0,character,1
+ellipsis,action_dots,2,0,0,character[],1
+ellipsis,action_dots,3,0,0,null,1
+ellipsis,action_dots,3,0,1,character,1
+ellipsis,action_dots,4,0,0,character,1
+ellipsis,action_dots,5,0,0,...,1
+ellipsis,check_dots_empty,-1,0,0,any,1
+ellipsis,check_dots_empty,0,0,0,environment,1
+ellipsis,check_dots_empty,1,0,0,any,1
+ellipsis,check_dots_unnamed,-1,0,0,any,1
+ellipsis,check_dots_unnamed,0,0,0,environment,1
+ellipsis,check_dots_unnamed,1,0,0,any,1
+ellipsis,check_dots_used,-1,0,0,null,1
+ellipsis,check_dots_used,0,0,0,environment,1
+ellipsis,check_dots_used,1,0,0,class<`function`>,1
+ellipsis,dots,-1,0,0,list<any>,1
+ellipsis,dots,0,0,0,environment,1
+ellipsis,dots,1,0,0,logical,1
+ellipsis,eval_bare,-1,0,0,null,1
+ellipsis,eval_bare,0,0,0,class<`call`>,1
+ellipsis,eval_bare,1,0,0,environment,1
+ellipsis,exit_handler,-1,0,0,class<`call`>,1
+ellipsis,exit_handler,0,0,0,class<`function`>,1
+ellipsis,paste_line,-1,0,0,character,1
+ellipsis,paste_line,0,0,0,...,1
+ellipsis,safe_median,-1,0,0,double,1
+ellipsis,safe_median,0,0,0,double,1
+ellipsis,safe_median,0,0,1,^integer[],1
+ellipsis,safe_median,1,0,0,...,1
+ellipsis,safe_median.numeric,-1,0,0,double,1
+ellipsis,safe_median.numeric,0,0,0,double,1
+ellipsis,safe_median.numeric,0,0,1,^integer[],1
+ellipsis,safe_median.numeric,1,0,0,...,1
+ellipsis,safe_median.numeric,2,0,0,logical,1
+emplik,bjtestII,-1,0,0,list<double[] | class<`matrix`>>,1
+emplik,bjtestII,0,0,0,double[],1
+emplik,bjtestII,1,0,0,double[],1
+emplik,bjtestII,2,0,0,class<`matrix`>,1
+emplik,bjtestII,3,0,0,double[],1
+emplik,cumsumsurv,-1,0,0,double[],1
+emplik,cumsumsurv,0,0,0,double[],1
+emplik,DnR,-1,0,0,list<double[]>,1
+emplik,DnR,0,0,0,double[],1
+emplik,DnR,1,0,0,double[],1
+emplik,DnR,2,0,0,double[],1
+emplik,DnR,3,0,0,double[],1
+emplik,el.cen.EM,-1,0,0,list<double[]>,1
+emplik,el.cen.EM,0,0,0,double[],1
+emplik,el.cen.EM,1,0,0,double[],1
+emplik,el.cen.EM,2,0,0,double[],1
+emplik,el.cen.EM,3,0,0,class<`function`>,1
+emplik,el.cen.EM,4,0,0,double,1
+emplik,el.cen.EM,5,0,0,double,1
+emplik,el.cen.EM,6,0,0,double,1
+emplik,el.cen.EM,7,0,0,...,1
+emplik,el.cen.EM2,-1,0,0,list<double[]>,1
+emplik,el.cen.EM2,0,0,0,double[],1
+emplik,el.cen.EM2,1,0,0,double[],1
+emplik,el.cen.EM2,2,0,0,integer[],1
+emplik,el.cen.EM2,3,0,0,class<`function`>,1
+emplik,el.cen.EM2,4,0,0,double[],1
+emplik,el.cen.EM2,5,0,0,double,1
+emplik,el.cen.EM2,6,0,0,double,1
+emplik,el.cen.EM2,7,0,0,...,1
+emplik,el.cen.test,-1,0,0,list<double[]>,1
+emplik,el.cen.test,0,0,0,double[],1
+emplik,el.cen.test,1,0,0,double[],1
+emplik,el.cen.test,2,0,0,class<`function`>,1
+emplik,el.cen.test,3,0,0,double,1
+emplik,el.cen.test,4,0,0,double,1
+emplik,el.cen.test,5,0,0,double,1
+emplik,el.ltrc.EM,-1,0,0,list<double[]>,1
+emplik,el.ltrc.EM,0,0,0,double[],1
+emplik,el.ltrc.EM,1,0,0,double[],1
+emplik,el.ltrc.EM,2,0,0,double[],1
+emplik,el.ltrc.EM,3,0,0,class<`function`>,1
+emplik,el.ltrc.EM,4,0,0,double,1
+emplik,el.ltrc.EM,5,0,0,double,1
+emplik,el.ltrc.EM,6,0,0,double,1
+emplik,el.test,-1,0,0,list<double[] | class<`matrix`>>,1
+emplik,el.test,-1,0,1,list<class<`matrix`> | double[]>,1
+emplik,el.test,0,0,0,class<`matrix`>,1
+emplik,el.test,0,0,1,double[],1
+emplik,el.test,1,0,0,double[],1
+emplik,el.test,2,0,0,any,1
+emplik,el.test,3,0,0,double,1
+emplik,el.test,4,0,0,double,1
+emplik,el.test,5,0,0,double,1
+emplik,el.test,6,0,0,logical,1
+emplik,el.test.wt,-1,0,0,list<double[]>,1
+emplik,el.test.wt,0,0,0,double[],1
+emplik,el.test.wt,1,0,0,double[],1
+emplik,el.test.wt,2,0,0,double,1
+emplik,el.test.wt,3,0,0,logical,1
+emplik,el.test.wt2,-1,0,0,list<double[] | null>,1
+emplik,el.test.wt2,0,0,0,class<`matrix`>,1
+emplik,el.test.wt2,0,0,1,double[],1
+emplik,el.test.wt2,1,0,0,double[],1
+emplik,el.test.wt2,2,0,0,double[],1
+emplik,el.test.wt2,3,0,0,double,1
+emplik,el.test.wt2,4,0,0,double,1
+emplik,el.test.wt2,5,0,0,logical,1
+emplik,el.test.wt2,6,0,0,double,1
+emplik,el.test.wt2,7,0,0,logical,1
+emplik,eltestwtinC,-1,0,0,list<double[]>,1
+emplik,eltestwtinC,0,0,0,double[],1
+emplik,eltestwtinC,1,0,0,double[],1
+emplik,eltestwtinC,2,0,0,double,1
+emplik,el.trun.test,-1,0,0,list<double[]>,1
+emplik,el.trun.test,0,0,0,double[],1
+emplik,el.trun.test,1,0,0,double[],1
+emplik,el.trun.test,2,0,0,class<`function`>,1
+emplik,el.trun.test,3,0,0,double,1
+emplik,el.trun.test,4,0,0,double,1
+emplik,el.trun.test,5,0,0,double,1
+emplik,emplikH1.test,-1,0,0,list<double[] | null>,1
+emplik,emplikH1.test,0,0,0,double[],1
+emplik,emplikH1.test,1,0,0,double[],1
+emplik,emplikH1.test,2,0,0,double,1
+emplik,emplikH1.test,3,0,0,double,1
+emplik,emplikH1.test,4,0,0,class<`function`>,1
+emplik,emplikH1.test,5,0,0,double,1
+emplik,emplikH2.test,-1,0,0,list<double[] | class<`matrix`> | null>,1
+emplik,emplikH2.test,-1,0,1,list<double[] | null>,1
+emplik,emplikH2.test,0,0,0,double[],1
+emplik,emplikH2.test,1,0,0,double[],1
+emplik,emplikH2.test,2,0,0,double,1
+emplik,emplikH2.test,3,0,0,double,1
+emplik,emplikH2.test,4,0,0,class<`function`>,1
+emplik,emplikH2.test,5,0,0,double,1
+emplik,emplikH2.test,6,0,0,...,1
+emplik,emplikH.disc,-1,0,0,list<double[]>,1
+emplik,emplikH.disc,0,0,0,double[],1
+emplik,emplikH.disc,1,0,0,double[],1
+emplik,emplikH.disc,2,0,0,double[],1
+emplik,emplikH.disc,3,0,0,double,1
+emplik,emplikH.disc,4,0,0,class<`function`>,1
+emplik,emplikH.disc,5,0,0,double,1
+emplik,emplikH.disc,6,0,0,double,1
+emplik,emplikH.disc2,-1,0,0,list<double[]>,1
+emplik,emplikH.disc2,0,0,0,double[],1
+emplik,emplikH.disc2,1,0,0,double[],1
+emplik,emplikH.disc2,2,0,0,double[],1
+emplik,emplikH.disc2,3,0,0,double[],1
+emplik,emplikH.disc2,4,0,0,double[],1
+emplik,emplikH.disc2,5,0,0,double[],1
+emplik,emplikH.disc2,6,0,0,double,1
+emplik,emplikH.disc2,7,0,0,class<`function`>,1
+emplik,emplikHs.disc2,-1,0,0,list<double[]>,1
+emplik,emplikHs.disc2,0,0,0,double[],1
+emplik,emplikHs.disc2,1,0,0,double[],1
+emplik,emplikHs.disc2,2,0,0,double[],1
+emplik,emplikHs.disc2,3,0,0,double[],1
+emplik,emplikHs.disc2,4,0,0,double[],1
+emplik,emplikHs.disc2,5,0,0,double[],1
+emplik,emplikHs.disc2,6,0,0,double[],1
+emplik,emplikHs.disc2,7,0,0,class<`function`>,1
+emplik,emplikHs.test2,-1,0,0,list<double[]>,1
+emplik,emplikHs.test2,0,0,0,double[],1
+emplik,emplikHs.test2,1,0,0,double[],1
+emplik,emplikHs.test2,2,0,0,double[],1
+emplik,emplikHs.test2,3,0,0,double[],1
+emplik,emplikHs.test2,4,0,0,double[],1
+emplik,emplikHs.test2,5,0,0,double[],1
+emplik,emplikHs.test2,6,0,0,double[],1
+emplik,emplikHs.test2,7,0,0,class<`function`>,1
+emplik,emplikHs.test22,-1,0,0,list<double>,1
+emplik,emplikHs.test22,0,0,0,double[],1
+emplik,emplikHs.test22,1,0,0,double[],1
+emplik,emplikHs.test22,2,0,0,double,1
+emplik,emplikHs.test22,3,0,0,integer[],1
+emplik,emplikHs.test22,4,0,0,double[],1
+emplik,emplikHs.test22,5,0,0,double,1
+emplik,emplikHs.test22,6,0,0,double,1
+emplik,emplikHs.test22,7,0,0,class<`function`>,1
+emplik,findUL,-1,0,0,list<double>,1
+emplik,findUL,0,0,0,double,1
+emplik,findUL,1,0,0,double,1
+emplik,findUL,2,0,0,class<`function`>,1
+emplik,findUL,3,0,0,double,1
+emplik,findUL,4,0,0,double,1
+emplik,findUL,5,0,0,...,1
+emplik,findUL2,-1,0,0,list<double>,1
+emplik,findUL2,0,0,0,double,1
+emplik,findUL2,1,0,0,double,1
+emplik,findUL2,2,0,0,class<`function`>,1
+emplik,findUL2,3,0,0,double,1
+emplik,findUL2,4,0,0,double,1
+emplik,findUL2,5,0,0,double,1
+emplik,findUL2,6,0,0,...,1
+emplik,findULold,-1,0,0,list<double>,1
+emplik,findULold,0,0,0,double,1
+emplik,findULold,1,0,0,double,1
+emplik,findULold,2,0,0,class<`function`>,1
+emplik,findULold,3,0,0,double,1
+emplik,findULold,4,0,0,double,1
+emplik,findULold,5,0,0,...,1
+emplik,gradf,-1,0,0,double[],1
+emplik,gradf,0,0,0,class<`matrix`>,1
+emplik,gradf,1,0,0,double[],1
+emplik,gradf,2,0,0,double[],1
+emplik,gradf2,-1,0,0,double[],1
+emplik,gradf2,0,0,0,double[],1
+emplik,gradf2,1,0,0,class<`matrix`>,1
+emplik,gradf2,2,0,0,double[],1
+emplik,gradf2,3,0,0,double[],1
+emplik,gradf2,4,0,0,class<`matrix`>,1
+emplik,gradf2,5,0,0,double[],1
+emplik,gradf2,6,0,0,double[],1
+emplik,gradf2,7,0,0,double[],1
+emplik,gradf3,-1,0,0,double[],1
+emplik,gradf3,0,0,0,double[],1
+emplik,gradf3,1,0,0,class<`matrix`>,1
+emplik,gradf3,2,0,0,double[],1
+emplik,gradf3,3,0,0,double[],1
+emplik,gradf3,4,0,0,class<`matrix`>,1
+emplik,gradf3,5,0,0,double[],1
+emplik,gradf3,6,0,0,double[],1
+emplik,gradf3,7,0,0,double[],1
+emplik,llog,-1,0,0,class<`matrix`>,1
+emplik,llog,-1,0,1,double[],1
+emplik,llog,0,0,0,class<`matrix`>,1
+emplik,llog,0,0,1,double[],1
+emplik,llog,1,0,0,double,1
+emplik,llogp,-1,0,0,class<`matrix`>,1
+emplik,llogp,-1,0,1,double[],1
+emplik,llogp,0,0,0,class<`matrix`>,1
+emplik,llogp,0,0,1,double[],1
+emplik,llogp,1,0,0,double,1
+emplik,llogpp,-1,0,0,class<`matrix`>,1
+emplik,llogpp,-1,0,1,double[],1
+emplik,llogpp,0,0,0,class<`matrix`>,1
+emplik,llogpp,0,0,1,double[],1
+emplik,llogpp,1,0,0,double,1
+emplik,logelr,-1,0,0,double,1
+emplik,logelr,0,0,0,class<`matrix`>,1
+emplik,logelr,1,0,0,double[],1
+emplik,logelr,2,0,0,double[],1
+emplik,LTRC,-1,0,0,list<double[]>,1
+emplik,LTRC,0,0,0,double[],1
+emplik,LTRC,1,0,0,double[],1
+emplik,LTRC,2,0,0,double[],1
+emplik,LTRC,3,0,0,double[],1
+emplik,RankRegTest,-1,0,0,list<double[]>,1
+emplik,RankRegTest,0,0,0,double[],1
+emplik,RankRegTest,1,0,0,double[],1
+emplik,RankRegTest,2,0,0,double[],1
+emplik,RankRegTest,3,0,0,double,1
+emplik,RankRegTest,4,0,0,character,1
+emplik,RankRegTestH,-1,0,0,list<double>,1
+emplik,RankRegTestH,0,0,0,double[],1
+emplik,RankRegTestH,1,0,0,double[],1
+emplik,RankRegTestH,2,0,0,double[],1
+emplik,RankRegTestH,3,0,0,double,1
+emplik,RankRegTestH,4,0,0,character,1
+emplik,redistF,-1,0,0,list<double[] | class<`matrix`>>,1
+emplik,redistF,0,0,0,double[],1
+emplik,redistF,1,0,0,double[],1
+emplik,redistF,2,0,0,double[],1
+emplik,ROCnp,-1,0,0,list<double>,1
+emplik,ROCnp,0,0,0,double[],1
+emplik,ROCnp,1,0,0,double[],1
+emplik,ROCnp,2,0,0,double[],1
+emplik,ROCnp,3,0,0,double[],1
+emplik,ROCnp,4,0,0,double,1
+emplik,ROCnp,5,0,0,double,1
+emplik,solve3.QP,-1,0,0,list<class<`matrix`>>,1
+emplik,solve3.QP,0,0,0,class<`matrix`>,1
+emplik,solve3.QP,0,0,1,double[],1
+emplik,solve3.QP,1,0,0,class<`matrix`>,1
+emplik,solve3.QP,1,0,1,double[],1
+emplik,solve3.QP,2,0,0,class<`matrix`>,1
+emplik,solve3.QP,3,0,0,double[],1
+emplik,solve3.QP,4,0,0,double,1
+emplik,solve3.QP,5,0,0,logical,1
+emplik,Wdataclean2,-1,0,0,list<double[]>,1
+emplik,Wdataclean2,0,0,0,double[],1
+emplik,Wdataclean2,1,0,0,double[],1
+emplik,Wdataclean2,2,0,0,double[],1
+emplik,Wdataclean3,-1,0,0,list<double[]>,1
+emplik,Wdataclean3,0,0,0,double[],1
+emplik,Wdataclean3,1,0,0,double[],1
+emplik,Wdataclean3,2,0,0,double[],1
+emplik,Wdataclean3,3,0,0,double[],1
+emplik,Wdataclean5,-1,0,0,list<double[] | class<`matrix`>>,1
+emplik,Wdataclean5,0,0,0,double[],1
+emplik,Wdataclean5,1,0,0,double[],1
+emplik,Wdataclean5,2,0,0,integer[],1
+emplik,Wdataclean5,3,0,0,double[],1
+emplik,Wdataclean5,4,0,0,class<`matrix`>,1
+emplik,WKM,-1,0,0,list<double[]>,1
+emplik,WKM,0,0,0,double[],1
+emplik,WKM,1,0,0,double[],1
+emplik,WKM,2,0,0,double[],1
+emplik,WKM,3,0,0,double[],1
+emplik,WRegEst,-1,0,0,double[],1
+emplik,WRegEst,0,0,0,class<`matrix`>,1
+emplik,WRegEst,1,0,0,double[],1
+emplik,WRegEst,2,0,0,integer[],1
+emplik,WRegEst,3,0,0,logical,1
+emplik,WRegEst,4,0,0,double,1
+emulator,betahat.fun,-1,0,0,double[],1
+emulator,betahat.fun,-1,0,1,list<double[] | class<`matrix`>>,1
+emulator,betahat.fun,0,0,0,class<`matrix`>,1
+emulator,betahat.fun,0,0,1,class<`data.frame`>,1
+emulator,betahat.fun,1,0,0,class<`matrix`>,1
+emulator,betahat.fun,2,0,0,double[],1
+emulator,betahat.fun,3,0,0,logical,1
+emulator,betahat.fun,4,0,0,class<`function`>,1
+emulator,betahat.fun.A,-1,0,0,double[],1
+emulator,betahat.fun.A,0,0,0,class<`matrix`>,1
+emulator,betahat.fun.A,1,0,0,class<`matrix`>,1
+emulator,betahat.fun.A,2,0,0,double[],1
+emulator,betahat.fun.A,3,0,0,logical,1
+emulator,betahat.fun.A,4,0,0,class<`function`>,1
+emulator,cond.sample,-1,0,0,class<`matrix`>,1
+emulator,cond.sample,0,0,0,double,1
+emulator,cond.sample,1,0,0,class<`matrix`>,1
+emulator,cond.sample,2,0,0,class<`matrix`>,1
+emulator,cond.sample,3,0,0,double[],1
+emulator,cond.sample,4,0,0,any,1
+emulator,cond.sample,5,0,0,class<`matrix`>,1
+emulator,cond.sample,6,0,0,double[],1
+emulator,cond.sample,7,0,0,null,1
+emulator,cond.sample,8,0,0,class<`function`>,1
+emulator,cond.sample,9,0,0,...,1
+emulator,corr,-1,0,0,double,1
+emulator,corr,0,0,0,double[],1
+emulator,corr,1,0,0,double[],1
+emulator,corr,2,0,0,double[],1
+emulator,corr,2,0,1,null,1
+emulator,corr,3,0,0,null,1
+emulator,corr,3,0,1,class<`matrix`>,1
+emulator,corr,4,0,0,character,1
+emulator,corr,5,0,0,null,1
+emulator,corr.matrix,-1,0,0,class<`matrix`>,1
+emulator,corr.matrix,0,0,0,class<`matrix`>,1
+emulator,corr.matrix,0,0,1,class<`data.frame`>,1
+emulator,corr.matrix,1,0,0,class<`matrix`>,1
+emulator,corr.matrix,1,0,1,null,1
+emulator,corr.matrix,1,0,2,class<`data.frame`>,1
+emulator,corr.matrix,2,0,0,double,1
+emulator,corr.matrix,3,0,0,class<`function`>,1
+emulator,corr.matrix,4,0,0,...,1
+emulator,cprod,-1,0,0,class<`matrix`>,1
+emulator,cprod,0,0,0,class<`matrix`>,1
+emulator,cprod,0,0,1,double[],1
+emulator,cprod,1,0,0,class<`matrix`>,1
+emulator,cprod,1,0,1,double[],1
+emulator,estimator,-1,0,0,double[],1
+emulator,estimator,0,0,0,class<`matrix`>,1
+emulator,estimator,1,0,0,class<`matrix`>,1
+emulator,estimator,2,0,0,double[],1
+emulator,estimator,3,0,0,double[],1
+emulator,estimator,4,0,0,null,1
+emulator,estimator,5,0,0,class<`function`>,1
+emulator,ht,-1,0,0,class<`matrix`>,1
+emulator,ht,0,0,0,class<`matrix`>,1
+emulator,ht,0,0,1,class<`data.frame`>,1
+emulator,interpolant,-1,0,0,double,1
+emulator,interpolant,-1,0,1,list<double[] | class<`matrix`>>,1
+emulator,interpolant,0,0,0,double[],1
+emulator,interpolant,1,0,0,double[],1
+emulator,interpolant,2,0,0,class<`matrix`>,1
+emulator,interpolant,3,0,0,class<`matrix`>,1
+emulator,interpolant,4,0,0,null,1
+emulator,interpolant,5,0,0,logical,1
+emulator,interpolant,6,0,0,double[],1
+emulator,interpolant,7,0,0,null,1
+emulator,interpolant,8,0,0,class<`function`>,1
+emulator,interpolant,9,0,0,logical,1
+emulator,interpolant,10,0,0,class<`function`>,1
+emulator,interpolant,11,0,0,...,1
+emulator,interpolant.quick,-1,0,0,double[],1
+emulator,interpolant.quick,-1,0,1,list<double[]>,1
+emulator,interpolant.quick,0,0,0,class<`matrix`>,1
+emulator,interpolant.quick,1,0,0,double[],1
+emulator,interpolant.quick,2,0,0,class<`matrix`>,1
+emulator,interpolant.quick,2,0,1,class<`data.frame`>,1
+emulator,interpolant.quick,3,0,0,class<`matrix`>,1
+emulator,interpolant.quick,4,0,0,double[],1
+emulator,interpolant.quick,5,0,0,null,1
+emulator,interpolant.quick,6,0,0,class<`function`>,1
+emulator,interpolant.quick,7,0,0,logical,1
+emulator,interpolant.quick,8,0,0,class<`function`>,1
+emulator,interpolant.quick,9,0,0,...,1
+emulator,int.qq,-1,0,0,double[],1
+emulator,int.qq,0,0,0,class<`matrix`>,1
+emulator,int.qq,1,0,0,double[],1
+emulator,int.qq,2,0,0,class<`matrix`>,1
+emulator,int.qq,3,0,0,class<`matrix`>,1
+emulator,int.qq,4,0,0,class<`matrix`>,1
+emulator,int.qq,5,0,0,class<`function`>,1
+emulator,latin.hypercube,-1,0,0,class<`matrix`>,1
+emulator,latin.hypercube,0,0,0,double,1
+emulator,latin.hypercube,1,0,0,double,1
+emulator,latin.hypercube,2,0,0,null,1
+emulator,latin.hypercube,3,0,0,logical,1
+emulator,latin.hypercube,4,0,0,logical,1
+emulator,model,-1,0,0,double,1
+emulator,model,0,0,0,double,1
+emulator,optimal.scale,-1,0,0,double,1
+emulator,optimal.scale,0,0,0,class<`matrix`>,1
+emulator,optimal.scale,1,0,0,double[],1
+emulator,optimal.scale,2,0,0,logical,1
+emulator,optimal.scale,3,0,0,logical,1
+emulator,optimal.scale,4,0,0,class<`function`>,1
+emulator,optimal.scale,5,0,0,...,1
+emulator,optimal.scales,-1,0,0,double[],1
+emulator,optimal.scales,0,0,0,class<`matrix`>,1
+emulator,optimal.scales,1,0,0,double[],1
+emulator,optimal.scales,2,0,0,double[],1
+emulator,optimal.scales,3,0,0,logical,1
+emulator,optimal.scales,4,0,0,logical,1
+emulator,optimal.scales,5,0,0,class<`function`>,1
+emulator,optimal.scales,6,0,0,...,1
+emulator,pad,-1,0,0,character,1
+emulator,pad,0,0,0,character,1
+emulator,pad,1,0,0,double,1
+emulator,pad,2,0,0,character,1
+emulator,pad,3,0,0,logical,1
+emulator,prior.b,-1,0,0,class<`matrix`>,1
+emulator,prior.b,0,0,0,class<`matrix`>,1
+emulator,prior.b,1,0,0,class<`matrix`>,1
+emulator,prior.b,2,0,0,double[],1
+emulator,prior.b,3,0,0,null,1
+emulator,prior.b,4,0,0,null,1
+emulator,prior.B,-1,0,0,class<`matrix`>,1
+emulator,prior.B,0,0,0,class<`matrix`>,1
+emulator,prior.B,1,0,0,class<`matrix`>,1
+emulator,prior.B,2,0,0,null,1
+emulator,quad.3diag,-1,0,0,complex[],1
+emulator,quad.3diag,0,0,0,class<`matrix`>,1
+emulator,quad.3diag,1,0,0,class<`matrix`>,1
+emulator,quad.3diag,2,0,0,class<`matrix`>,1
+emulator,quad.3form,-1,0,0,class<`matrix`>,1
+emulator,quad.3form,0,0,0,class<`matrix`>,1
+emulator,quad.3form,1,0,0,class<`matrix`>,1
+emulator,quad.3form,2,0,0,class<`matrix`>,1
+emulator,quad.3tdiag,-1,0,0,complex[],1
+emulator,quad.3tdiag,0,0,0,class<`matrix`>,1
+emulator,quad.3tdiag,1,0,0,class<`matrix`>,1
+emulator,quad.3tdiag,2,0,0,class<`matrix`>,1
+emulator,quad.3tform,-1,0,0,class<`matrix`>,1
+emulator,quad.3tform,0,0,0,class<`matrix`>,1
+emulator,quad.3tform,1,0,0,class<`matrix`>,1
+emulator,quad.3tform,2,0,0,class<`matrix`>,1
+emulator,quad.diag,-1,0,0,complex[],1
+emulator,quad.diag,0,0,0,class<`matrix`>,1
+emulator,quad.diag,1,0,0,class<`matrix`>,1
+emulator,quad.form,-1,0,0,class<`matrix`>,1
+emulator,quad.form,-1,0,1,double,1
+emulator,quad.form,0,0,0,class<`matrix`>,1
+emulator,quad.form,1,0,0,class<`matrix`>,1
+emulator,quad.form,1,0,1,double[],1
+emulator,quad.form,2,0,0,logical,1
+emulator,quad.form.inv,-1,0,0,class<`matrix`>,1
+emulator,quad.form.inv,-1,0,1,double,1
+emulator,quad.form.inv,0,0,0,class<`matrix`>,1
+emulator,quad.form.inv,1,0,0,class<`matrix`>,1
+emulator,quad.form.inv,1,0,1,double[],1
+emulator,quad.tdiag,-1,0,0,complex[],1
+emulator,quad.tdiag,0,0,0,class<`matrix`>,1
+emulator,quad.tdiag,1,0,0,class<`matrix`>,1
+emulator,quad.tform,-1,0,0,class<`matrix`>,1
+emulator,quad.tform,0,0,0,class<`matrix`>,1
+emulator,quad.tform,1,0,0,class<`matrix`>,1
+emulator,quad.tform.inv,-1,0,0,class<`matrix`>,1
+emulator,quad.tform.inv,0,0,0,class<`matrix`>,1
+emulator,quad.tform.inv,1,0,0,class<`matrix`>,1
+emulator,regressor.basis,-1,0,0,double[],1
+emulator,regressor.basis,0,0,0,double[],1
+emulator,regressor.multi,-1,0,0,class<`matrix`>,1
+emulator,regressor.multi,0,0,0,class<`data.frame`>,1
+emulator,regressor.multi,0,0,1,class<`matrix`>,1
+emulator,regressor.multi,1,0,0,class<`function`>,1
+emulator,sample.from.exp.est,-1,0,0,class<`matrix`>,1
+emulator,sample.from.exp.est,0,0,0,double,1
+emulator,sample.from.exp.est,1,0,0,class<`data.frame`>,1
+emulator,sample.from.exp.est,2,0,0,logical,1
+emulator,sample.from.exp.est,3,0,0,double,1
+emulator,sample.n.fit,-1,0,0,list<list<double[]>>,1
+emulator,sample.n.fit,0,0,0,double,1
+emulator,sample.n.fit,1,0,0,double,1
+emulator,sample.n.fit,2,0,0,double,1
+emulator,sample.n.fit,3,0,0,class<`function`>,1
+emulator,sample.n.fit,4,0,0,...,1
+emulator,scales.likelihood,-1,0,0,double,1
+emulator,scales.likelihood,0,0,0,null,1
+emulator,scales.likelihood,1,0,0,double[],1
+emulator,scales.likelihood,2,0,0,class<`matrix`>,1
+emulator,scales.likelihood,3,0,0,logical,1
+emulator,scales.likelihood,4,0,0,double[],1
+emulator,scales.likelihood,5,0,0,logical,1
+emulator,scales.likelihood,6,0,0,class<`function`>,1
+emulator,s.chi,-1,0,0,class<`matrix`>,1
+emulator,s.chi,-1,0,1,double,1
+emulator,s.chi,0,0,0,class<`matrix`>,1
+emulator,s.chi,1,0,0,class<`matrix`>,1
+emulator,s.chi,2,0,0,double[],1
+emulator,s.chi,3,0,0,double,1
+emulator,s.chi,4,0,0,logical,1
+emulator,sigmahatsquared,-1,0,0,double,1
+emulator,sigmahatsquared,0,0,0,class<`matrix`>,1
+emulator,sigmahatsquared,1,0,0,class<`matrix`>,1
+emulator,sigmahatsquared,2,0,0,double[],1
+emulator,sigmahatsquared.A,-1,0,0,double,1
+emulator,sigmahatsquared.A,0,0,0,class<`matrix`>,1
+emulator,sigmahatsquared.A,1,0,0,class<`matrix`>,1
+emulator,sigmahatsquared.A,2,0,0,double[],1
+emulator,tcprod,-1,0,0,class<`matrix`>,1
+emulator,tcprod,0,0,0,class<`matrix`>,1
+emulator,tcprod,1,0,0,class<`matrix`>,1
+emulator,tr,-1,0,0,integer,1
+emulator,tr,0,0,0,class<`matrix`>,1
+emulator,var.conditional,-1,0,0,class<`matrix`>,1
+emulator,var.conditional,0,0,0,class<`matrix`>,1
+emulator,var.conditional,1,0,0,class<`matrix`>,1
+emulator,var.conditional,2,0,0,double[],1
+emulator,var.conditional,3,0,0,any,1
+emulator,var.conditional,4,0,0,class<`matrix`>,1
+emulator,var.conditional,5,0,0,double[],1
+emulator,var.conditional,6,0,0,null,1
+emulator,var.conditional,7,0,0,class<`function`>,1
+emulator,var.conditional,8,0,0,class<`function`>,1
+emulator,var.conditional,9,0,0,...,1
+entropy,chi2.Dirichlet,-1,0,0,double,1
+entropy,chi2.Dirichlet,0,0,0,double[],1
+entropy,chi2.Dirichlet,1,0,0,double[],1
+entropy,chi2.Dirichlet,2,0,0,double,1
+entropy,chi2.Dirichlet,3,0,0,double,1
+entropy,chi2.Dirichlet,4,0,0,character[],1
+entropy,chi2.empirical,-1,0,0,double,1
+entropy,chi2.empirical,0,0,0,double[],1
+entropy,chi2.empirical,1,0,0,double[],1
+entropy,chi2.empirical,2,0,0,character[],1
+entropy,chi2indep.Dirichlet,-1,0,0,double,1
+entropy,chi2indep.Dirichlet,0,0,0,class<`matrix`>,1
+entropy,chi2indep.Dirichlet,1,0,0,double,1
+entropy,chi2indep.Dirichlet,2,0,0,character[],1
+entropy,chi2indep.empirical,-1,0,0,double,1
+entropy,chi2indep.empirical,0,0,0,class<`matrix`>,1
+entropy,chi2indep.empirical,1,0,0,character[],1
+entropy,chi2indep.plugin,-1,0,0,double,1
+entropy,chi2indep.plugin,0,0,0,class<`matrix`>,1
+entropy,chi2indep.plugin,1,0,0,character[],1
+entropy,chi2indep.shrink,-1,0,0,double,1
+entropy,chi2indep.shrink,0,0,0,class<`matrix`>,1
+entropy,chi2indep.shrink,1,0,0,any,1
+entropy,chi2indep.shrink,2,0,0,character[],1
+entropy,chi2indep.shrink,3,0,0,logical,1
+entropy,chi2.plugin,-1,0,0,double,1
+entropy,chi2.plugin,0,0,0,class<`matrix`>,1
+entropy,chi2.plugin,0,0,1,double[],1
+entropy,chi2.plugin,1,0,0,class<`matrix`>,1
+entropy,chi2.plugin,1,0,1,double[],1
+entropy,chi2.plugin,2,0,0,character[],1
+entropy,chi2.shrink,-1,0,0,double,1
+entropy,chi2.shrink,0,0,0,double[],1
+entropy,chi2.shrink,1,0,0,double[],1
+entropy,chi2.shrink,2,0,0,any,1
+entropy,chi2.shrink,3,0,0,any,1
+entropy,chi2.shrink,4,0,0,character[],1
+entropy,chi2.shrink,5,0,0,logical,1
+entropy,discretize,-1,0,0,class<`table`>,1
+entropy,discretize,0,0,0,double[],1
+entropy,discretize,1,0,0,double,1
+entropy,discretize,2,0,0,double[],1
+entropy,discretize2d,-1,0,0,class<`table`>,1
+entropy,discretize2d,0,0,0,double[],1
+entropy,discretize2d,1,0,0,double[],1
+entropy,discretize2d,2,0,0,double,1
+entropy,discretize2d,3,0,0,double,1
+entropy,discretize2d,4,0,0,double[],1
+entropy,discretize2d,5,0,0,double[],1
+entropy,entropy,-1,0,0,double,1
+entropy,entropy,0,0,0,class<`table`>,1
+entropy,entropy,0,0,1,double[],1
+entropy,entropy,1,0,0,any,1
+entropy,entropy,2,0,0,character[],1
+entropy,entropy,3,0,0,character[],1
+entropy,entropy,4,0,0,logical,1
+entropy,entropy,5,0,0,...,1
+entropy,entropy.ChaoShen,-1,0,0,double,1
+entropy,entropy.ChaoShen,0,0,0,double[],1
+entropy,entropy.ChaoShen,1,0,0,character[],1
+entropy,entropy.Dirichlet,-1,0,0,double,1
+entropy,entropy.Dirichlet,0,0,0,double[],1
+entropy,entropy.Dirichlet,1,0,0,double,1
+entropy,entropy.Dirichlet,2,0,0,character[],1
+entropy,entropy.empirical,-1,0,0,double,1
+entropy,entropy.empirical,0,0,0,class<`table`>,1
+entropy,entropy.empirical,0,0,1,double[],1
+entropy,entropy.empirical,1,0,0,character[],1
+entropy,entropy.MillerMadow,-1,0,0,double,1
+entropy,entropy.MillerMadow,0,0,0,double[],1
+entropy,entropy.MillerMadow,1,0,0,character[],1
+entropy,entropy.plugin,-1,0,0,double,1
+entropy,entropy.plugin,0,0,0,class<`matrix`>,1
+entropy,entropy.plugin,0,0,1,class<`table`>,1
+entropy,entropy.plugin,0,0,2,double[],1
+entropy,entropy.plugin,1,0,0,character[],1
+entropy,entropy.shrink,-1,0,0,double,1
+entropy,entropy.shrink,0,0,0,double[],1
+entropy,entropy.shrink,1,0,0,any,1
+entropy,entropy.shrink,2,0,0,character[],1
+entropy,entropy.shrink,3,0,0,logical,1
+entropy,freqs.Dirichlet,-1,0,0,class<`matrix`>,1
+entropy,freqs.Dirichlet,-1,0,1,double[],1
+entropy,freqs.Dirichlet,0,0,0,class<`matrix`>,1
+entropy,freqs.Dirichlet,0,0,1,double[],1
+entropy,freqs.Dirichlet,1,0,0,double,1
+entropy,freqs.empirical,-1,0,0,class<`matrix`>,1
+entropy,freqs.empirical,-1,0,1,class<`table`>,1
+entropy,freqs.empirical,-1,0,2,double[],1
+entropy,freqs.empirical,0,0,0,class<`matrix`>,1
+entropy,freqs.empirical,0,0,1,class<`table`>,1
+entropy,freqs.empirical,0,0,2,double[],1
+entropy,freqs.shrink,-1,0,0,class<`matrix`>,1
+entropy,freqs.shrink,-1,0,1,double[],1
+entropy,freqs.shrink,0,0,0,class<`matrix`>,1
+entropy,freqs.shrink,0,0,1,double[],1
+entropy,freqs.shrink,1,0,0,any,1
+entropy,freqs.shrink,2,0,0,logical,1
+entropy,get.lambda.shrink,-1,0,0,double,1
+entropy,get.lambda.shrink,0,0,0,double,1
+entropy,get.lambda.shrink,1,0,0,class<`matrix`>,1
+entropy,get.lambda.shrink,1,0,1,double[],1
+entropy,get.lambda.shrink,2,0,0,double,1
+entropy,get.lambda.shrink,3,0,0,logical,1
+entropy,KL.Dirichlet,-1,0,0,double,1
+entropy,KL.Dirichlet,0,0,0,double[],1
+entropy,KL.Dirichlet,1,0,0,double[],1
+entropy,KL.Dirichlet,2,0,0,double,1
+entropy,KL.Dirichlet,3,0,0,double,1
+entropy,KL.Dirichlet,4,0,0,character[],1
+entropy,KL.empirical,-1,0,0,double,1
+entropy,KL.empirical,0,0,0,double[],1
+entropy,KL.empirical,1,0,0,double[],1
+entropy,KL.empirical,2,0,0,character[],1
+entropy,KL.plugin,-1,0,0,double,1
+entropy,KL.plugin,0,0,0,class<`matrix`>,1
+entropy,KL.plugin,0,0,1,class<`table`>,1
+entropy,KL.plugin,0,0,2,double[],1
+entropy,KL.plugin,1,0,0,class<`matrix`>,1
+entropy,KL.plugin,1,0,1,double[],1
+entropy,KL.plugin,2,0,0,character[],1
+entropy,KL.shrink,-1,0,0,double,1
+entropy,KL.shrink,0,0,0,double[],1
+entropy,KL.shrink,1,0,0,double[],1
+entropy,KL.shrink,2,0,0,any,1
+entropy,KL.shrink,3,0,0,any,1
+entropy,KL.shrink,4,0,0,character[],1
+entropy,KL.shrink,5,0,0,logical,1
+entropy,mi.Dirichlet,-1,0,0,double,1
+entropy,mi.Dirichlet,0,0,0,class<`matrix`>,1
+entropy,mi.Dirichlet,1,0,0,double,1
+entropy,mi.Dirichlet,2,0,0,character[],1
+entropy,mi.empirical,-1,0,0,double,1
+entropy,mi.empirical,0,0,0,class<`matrix`>,1
+entropy,mi.empirical,0,0,1,class<`table`>,1
+entropy,mi.empirical,1,0,0,character[],1
+entropy,mi.plugin,-1,0,0,double,1
+entropy,mi.plugin,0,0,0,class<`matrix`>,1
+entropy,mi.plugin,0,0,1,class<`table`>,1
+entropy,mi.plugin,1,0,0,character[],1
+entropy,mi.shrink,-1,0,0,double,1
+entropy,mi.shrink,0,0,0,class<`matrix`>,1
+entropy,mi.shrink,1,0,0,any,1
+entropy,mi.shrink,2,0,0,character[],1
+entropy,mi.shrink,3,0,0,logical,1
+epitools,ageadjust.direct,-1,0,0,double[],1
+epitools,ageadjust.direct,0,0,0,double[],1
+epitools,ageadjust.direct,1,0,0,double[],1
+epitools,ageadjust.direct,2,0,0,null,1
+epitools,ageadjust.direct,3,0,0,double[],1
+epitools,ageadjust.direct,4,0,0,double,1
+epitools,ageadjust.indirect,-1,0,0,list<double[]>,1
+epitools,ageadjust.indirect,0,0,0,double[],1
+epitools,ageadjust.indirect,1,0,0,double[],1
+epitools,ageadjust.indirect,2,0,0,double[],1
+epitools,ageadjust.indirect,3,0,0,double[],1
+epitools,ageadjust.indirect,4,0,0,null,1
+epitools,ageadjust.indirect,5,0,0,double,1
+epitools,as.hour,-1,0,0,list<any>,1
+epitools,as.hour,0,0,0,"class<`POSIXlt`, `POSIXt`>",1
+epitools,as.hour,1,0,0,character,1
+epitools,as.hour,2,0,0,character,1
+epitools,as.hour,3,0,0,logical,1
+epitools,as.month,-1,0,0,list<any>,1
+epitools,as.month,0,0,0,^character[],1
+epitools,as.month,1,0,0,character,1
+epitools,as.month,2,0,0,any,1
+epitools,as.month,3,0,0,any,1
+epitools,as.month,4,0,0,double,1
+epitools,as.month,5,0,0,double,1
+epitools,as.month,6,0,0,class<`Date`>,1
+epitools,as.month,7,0,0,logical,1
+epitools,as.week,-1,0,0,list<any>,1
+epitools,as.week,0,0,0,class<`Date`>,1
+epitools,as.week,0,0,1,^character[],1
+epitools,as.week,1,0,0,character,1
+epitools,as.week,2,0,0,any,1
+epitools,as.week,3,0,0,any,1
+epitools,as.week,4,0,0,double,1
+epitools,as.week,5,0,0,double,1
+epitools,as.week,6,0,0,class<`Date`>,1
+epitools,as.week,7,0,0,logical,1
+epitools,binom.approx,-1,0,0,class<`data.frame`>,1
+epitools,binom.approx,0,0,0,integer[],1
+epitools,binom.approx,1,0,0,double[],1
+epitools,binom.approx,2,0,0,double,1
+epitools,binom.exact,-1,0,0,class<`data.frame`>,1
+epitools,binom.exact,0,0,0,integer[],1
+epitools,binom.exact,1,0,0,double[],1
+epitools,binom.exact,2,0,0,double,1
+epitools,binom.wilson,-1,0,0,class<`data.frame`>,1
+epitools,binom.wilson,0,0,0,integer[],1
+epitools,binom.wilson,1,0,0,double[],1
+epitools,binom.wilson,2,0,0,double,1
+epitools,colorbrewer.data,-1,0,0,class<`data.frame`>,1
+epitools,colorbrewer.display,-1,0,0,class<`data.frame`>,1
+epitools,colorbrewer.display,0,0,0,double,1
+epitools,colorbrewer.display,1,0,0,character,1
+epitools,colorbrewer.display,2,0,0,character,1
+epitools,colorbrewer.palette,-1,0,0,character[],1
+epitools,colorbrewer.palette,0,0,0,double,1
+epitools,colorbrewer.palette,1,0,0,character,1
+epitools,colorbrewer.palette,2,0,0,character[],1
+epitools,colors.matrix,-1,0,0,class<`matrix`>,1
+epitools,colors.plot,-1,0,0,class<`matrix`>,1
+epitools,colors.plot,0,0,0,logical,1
+epitools,colors.plot,1,0,0,double,1
+epitools,epicurve.dates,-1,0,0,list<any>,1
+epitools,epicurve.dates,0,0,0,class<`Date`>,1
+epitools,epicurve.dates,1,0,0,character,1
+epitools,epicurve.dates,2,0,0,character[],1
+epitools,epicurve.dates,2,0,1,null,1
+epitools,epicurve.dates,3,0,0,any,1
+epitools,epicurve.dates,4,0,0,any,1
+epitools,epicurve.dates,5,0,0,double,1
+epitools,epicurve.dates,6,0,0,double,1
+epitools,epicurve.dates,7,0,0,double,1
+epitools,epicurve.dates,8,0,0,double,1
+epitools,epicurve.dates,9,0,0,logical,1
+epitools,epicurve.dates,10,0,0,double,1
+epitools,epicurve.dates,11,0,0,logical,1
+epitools,epicurve.dates,12,0,0,...,1
+epitools,epicurve.hours,-1,0,0,list<any>,1
+epitools,epicurve.hours,0,0,0,"class<`POSIXlt`, `POSIXt`>",1
+epitools,epicurve.hours,1,0,0,character,1
+epitools,epicurve.hours,2,0,0,character,1
+epitools,epicurve.hours,3,0,0,character[],1
+epitools,epicurve.hours,4,0,0,logical,1
+epitools,epicurve.hours,5,0,0,double,1
+epitools,epicurve.hours,6,0,0,double,1
+epitools,epicurve.hours,7,0,0,logical,1
+epitools,epicurve.hours,8,0,0,double,1
+epitools,epicurve.hours,9,0,0,logical,1
+epitools,epicurve.hours,10,0,0,...,1
+epitools,epicurve.table,-1,0,0,class<`matrix`>,1
+epitools,epicurve.table,-1,0,1,double[],1
+epitools,epicurve.table,0,0,0,double[],1
+epitools,epicurve.table,0,0,1,class<`matrix`>,1
+epitools,epicurve.table,1,0,0,double,1
+epitools,epicurve.table,2,0,0,double,1
+epitools,epicurve.table,3,0,0,logical,1
+epitools,epicurve.table,4,0,0,double,1
+epitools,epicurve.table,5,0,0,logical,1
+epitools,epicurve.table,6,0,0,...,1
+epitools,epicurve.weeks,-1,0,0,list<any>,1
+epitools,epicurve.weeks,0,0,0,class<`Date`>,1
+epitools,epicurve.weeks,1,0,0,character,1
+epitools,epicurve.weeks,2,0,0,character[],1
+epitools,epicurve.weeks,2,0,1,null,1
+epitools,epicurve.weeks,3,0,0,any,1
+epitools,epicurve.weeks,4,0,0,any,1
+epitools,epicurve.weeks,5,0,0,double,1
+epitools,epicurve.weeks,6,0,0,double,1
+epitools,epicurve.weeks,7,0,0,double,1
+epitools,epicurve.weeks,8,0,0,double,1
+epitools,epicurve.weeks,9,0,0,logical,1
+epitools,epicurve.weeks,10,0,0,double,1
+epitools,epicurve.weeks,11,0,0,logical,1
+epitools,epicurve.weeks,12,0,0,class<`Date`>,1
+epitools,epicurve.weeks,13,0,0,logical,1
+epitools,epicurve.weeks,14,0,0,...,1
+epitools,epitab,-1,0,0,list<class<`matrix`> | character | double>,1
+epitools,epitab,0,0,0,class<`matrix`>,1
+epitools,epitab,1,0,0,null,1
+epitools,epitab,2,0,0,character[],1
+epitools,epitab,3,0,0,double,1
+epitools,epitab,4,0,0,character[],1
+epitools,epitab,5,0,0,any,1
+epitools,epitab,6,0,0,any,1
+epitools,epitab,7,0,0,any,1
+epitools,epitab,8,0,0,character[],1
+epitools,epitab,9,0,0,logical,1
+epitools,epitab,10,0,0,logical,1
+epitools,epitable,-1,0,0,class<`matrix`>,1
+epitools,epitable,-1,0,1,class<`table`>,1
+epitools,epitable,0,0,0,...,1
+epitools,epitable,1,0,0,double,1
+epitools,epitable,2,0,0,logical,1
+epitools,epitable,3,0,0,character[],1
+epitools,expand.table,-1,0,0,class<`data.frame`>,1
+epitools,expand.table,0,0,0,class<`array`>,1
+epitools,expand.table,0,0,1,class<`table`>,1
+epitools,expected,-1,0,0,class<`matrix`>,1
+epitools,expected,0,0,0,class<`matrix`>,1
+epitools,julian2date,-1,0,0,class<`Date`>,1
+epitools,julian2date,0,0,0,double[],1
+epitools,julian2date,-1,1,0,class<`Date`>,1
+epitools,julian2date,0,1,0,^double[],1
+epitools,kapmeier,-1,0,0,class<`matrix`>,1
+epitools,kapmeier,0,0,0,double[],1
+epitools,kapmeier,1,0,0,double[],1
+epitools,oddsratio,-1,0,0,list<class<`matrix`> | logical>,1
+epitools,oddsratio,-1,0,1,list<class<`matrix`> | double>,1
+epitools,oddsratio,0,0,0,class<`matrix`>,1
+epitools,oddsratio,1,0,0,null,1
+epitools,oddsratio,2,0,0,character[],1
+epitools,oddsratio,3,0,0,double,1
+epitools,oddsratio,4,0,0,character[],1
+epitools,oddsratio,5,0,0,logical,1
+epitools,oddsratio,6,0,0,logical,1
+epitools,oddsratio.fisher,-1,0,0,list<class<`matrix`> | logical>,1
+epitools,oddsratio.fisher,0,0,0,class<`matrix`>,1
+epitools,oddsratio.fisher,1,0,0,null,1
+epitools,oddsratio.fisher,2,0,0,double,1
+epitools,oddsratio.fisher,3,0,0,character,1
+epitools,oddsratio.fisher,4,0,0,logical,1
+epitools,oddsratio.fisher,5,0,0,logical,1
+epitools,oddsratio.midp,-1,0,0,list<class<`matrix`> | logical>,1
+epitools,oddsratio.midp,0,0,0,class<`matrix`>,1
+epitools,oddsratio.midp,1,0,0,null,1
+epitools,oddsratio.midp,2,0,0,double,1
+epitools,oddsratio.midp,3,0,0,character[],1
+epitools,oddsratio.midp,4,0,0,logical,1
+epitools,oddsratio.midp,5,0,0,logical,1
+epitools,oddsratio.midp,6,0,0,double[],1
+epitools,oddsratio.small,-1,0,0,list<class<`matrix`> | logical>,1
+epitools,oddsratio.small,0,0,0,class<`matrix`>,1
+epitools,oddsratio.small,1,0,0,null,1
+epitools,oddsratio.small,2,0,0,double,1
+epitools,oddsratio.small,3,0,0,character,1
+epitools,oddsratio.small,4,0,0,logical,1
+epitools,oddsratio.small,5,0,0,logical,1
+epitools,oddsratio.wald,-1,0,0,list<class<`matrix`> | logical>,1
+epitools,oddsratio.wald,-1,0,1,list<class<`matrix`> | double>,1
+epitools,oddsratio.wald,0,0,0,class<`matrix`>,1
+epitools,oddsratio.wald,1,0,0,null,1
+epitools,oddsratio.wald,2,0,0,double,1
+epitools,oddsratio.wald,3,0,0,character[],1
+epitools,oddsratio.wald,4,0,0,logical,1
+epitools,oddsratio.wald,5,0,0,logical,1
+epitools,or.midp,-1,0,0,list<class<`matrix`> | double[]>,1
+epitools,or.midp,0,0,0,class<`matrix`>,1
+epitools,or.midp,1,0,0,double,1
+epitools,or.midp,2,0,0,logical,1
+epitools,or.midp,3,0,0,double[],1
+epitools,ormidp.test,-1,0,0,class<`data.frame`>,1
+epitools,ormidp.test,0,0,0,double,1
+epitools,ormidp.test,1,0,0,double,1
+epitools,ormidp.test,2,0,0,double,1
+epitools,ormidp.test,3,0,0,double,1
+epitools,ormidp.test,4,0,0,double,1
+epitools,pois.approx,-1,0,0,class<`data.frame`>,1
+epitools,pois.approx,0,0,0,integer[],1
+epitools,pois.approx,1,0,0,double,1
+epitools,pois.approx,1,0,1,integer[],1
+epitools,pois.approx,2,0,0,double,1
+epitools,pois.byar,-1,0,0,class<`data.frame`>,1
+epitools,pois.byar,0,0,0,integer[],1
+epitools,pois.byar,1,0,0,double,1
+epitools,pois.byar,1,0,1,integer[],1
+epitools,pois.byar,2,0,0,double,1
+epitools,pois.daly,-1,0,0,class<`data.frame`>,1
+epitools,pois.daly,0,0,0,integer[],1
+epitools,pois.daly,1,0,0,double,1
+epitools,pois.daly,1,0,1,integer[],1
+epitools,pois.daly,2,0,0,double,1
+epitools,pois.exact,-1,0,0,class<`data.frame`>,1
+epitools,pois.exact,0,0,0,integer[],1
+epitools,pois.exact,1,0,0,double,1
+epitools,pois.exact,1,0,1,integer[],1
+epitools,pois.exact,2,0,0,double,1
+epitools,probratio,-1,0,0,class<`matrix`>,1
+epitools,probratio,0,0,0,"class<`glm`, `lm`>",1
+epitools,probratio,1,0,0,any,1
+epitools,probratio,2,0,0,any,1
+epitools,probratio,3,0,0,character,1
+epitools,probratio,4,0,0,character,1
+epitools,probratio,5,0,0,double,1
+epitools,probratio,6,0,0,any,1
+epitools,probratio,7,0,0,double,1
+epitools,probratio,8,0,0,...,1
+epitools,rate2by2.test,-1,0,0,list<class<`matrix`>>,1
+epitools,rate2by2.test,0,0,0,class<`matrix`>,1
+epitools,rate2by2.test,0,0,1,double[],1
+epitools,rate2by2.test,1,0,0,null,1
+epitools,rate2by2.test,1,0,1,double[],1
+epitools,rate2by2.test,2,0,0,double,1
+epitools,rate2by2.test,3,0,0,character[],1
+epitools,rateratio,-1,0,0,list<class<`matrix`>>,1
+epitools,rateratio,-1,0,1,list<class<`matrix`> | double>,1
+epitools,rateratio,0,0,0,class<`matrix`>,1
+epitools,rateratio,0,0,1,double[],1
+epitools,rateratio,1,0,0,null,1
+epitools,rateratio,1,0,1,double[],1
+epitools,rateratio,2,0,0,character[],1
+epitools,rateratio,3,0,0,double,1
+epitools,rateratio,4,0,0,character[],1
+epitools,rateratio,5,0,0,logical,1
+epitools,rateratio.midp,-1,0,0,list<class<`matrix`>>,1
+epitools,rateratio.midp,0,0,0,class<`matrix`>,1
+epitools,rateratio.midp,0,0,1,double[],1
+epitools,rateratio.midp,1,0,0,null,1
+epitools,rateratio.midp,1,0,1,double[],1
+epitools,rateratio.midp,2,0,0,double,1
+epitools,rateratio.midp,3,0,0,character[],1
+epitools,rateratio.midp,4,0,0,logical,1
+epitools,rateratio.wald,-1,0,0,list<class<`matrix`>>,1
+epitools,rateratio.wald,-1,0,1,list<class<`matrix`> | double>,1
+epitools,rateratio.wald,0,0,0,class<`matrix`>,1
+epitools,rateratio.wald,0,0,1,double[],1
+epitools,rateratio.wald,1,0,0,null,1
+epitools,rateratio.wald,1,0,1,double[],1
+epitools,rateratio.wald,2,0,0,double,1
+epitools,rateratio.wald,3,0,0,character[],1
+epitools,rateratio.wald,4,0,0,logical,1
+epitools,ratetable,-1,0,0,class<`matrix`>,1
+epitools,ratetable,0,0,0,...,1
+epitools,ratetable,1,0,0,logical,1
+epitools,ratetable,2,0,0,character[],1
+epitools,riskratio,-1,0,0,list<class<`matrix`> | logical>,1
+epitools,riskratio,-1,0,1,list<class<`matrix`> | double>,1
+epitools,riskratio,0,0,0,class<`matrix`>,1
+epitools,riskratio,1,0,0,null,1
+epitools,riskratio,2,0,0,character[],1
+epitools,riskratio,3,0,0,double,1
+epitools,riskratio,4,0,0,character[],1
+epitools,riskratio,5,0,0,logical,1
+epitools,riskratio,6,0,0,logical,1
+epitools,riskratio,7,0,0,double,1
+epitools,riskratio.boot,-1,0,0,list<class<`matrix`> | logical>,1
+epitools,riskratio.boot,-1,0,1,list<class<`matrix`> | double>,1
+epitools,riskratio.boot,0,0,0,class<`matrix`>,1
+epitools,riskratio.boot,1,0,0,null,1
+epitools,riskratio.boot,2,0,0,double,1
+epitools,riskratio.boot,3,0,0,character[],1
+epitools,riskratio.boot,4,0,0,logical,1
+epitools,riskratio.boot,5,0,0,logical,1
+epitools,riskratio.boot,6,0,0,double,1
+epitools,riskratio.small,-1,0,0,list<class<`matrix`> | logical>,1
+epitools,riskratio.small,0,0,0,class<`matrix`>,1
+epitools,riskratio.small,1,0,0,null,1
+epitools,riskratio.small,2,0,0,double,1
+epitools,riskratio.small,3,0,0,character,1
+epitools,riskratio.small,4,0,0,logical,1
+epitools,riskratio.small,5,0,0,logical,1
+epitools,riskratio.wald,-1,0,0,list<class<`matrix`> | logical>,1
+epitools,riskratio.wald,-1,0,1,list<class<`matrix`> | double>,1
+epitools,riskratio.wald,0,0,0,class<`matrix`>,1
+epitools,riskratio.wald,1,0,0,null,1
+epitools,riskratio.wald,2,0,0,double,1
+epitools,riskratio.wald,3,0,0,character[],1
+epitools,riskratio.wald,4,0,0,logical,1
+epitools,riskratio.wald,5,0,0,logical,1
+epitools,tab2by2.test,-1,0,0,list<class<`matrix`> | logical>,1
+epitools,tab2by2.test,0,0,0,class<`matrix`>,1
+epitools,tab2by2.test,1,0,0,null,1
+epitools,tab2by2.test,2,0,0,logical,1
+epitools,tab2by2.test,3,0,0,character[],1
+epitools,table.margins,-1,0,0,class<`matrix`>,1
+epitools,table.margins,0,0,0,class<`matrix`>,1
+evaluate,append_break,-1,0,0,character[],1
+evaluate,append_break,0,0,0,character[],1
+evaluate,evaluate,-1,0,0,list<any>,1
+evaluate,evaluate,0,0,0,"class<`connection`, `file`>",1
+evaluate,evaluate,0,0,1,character,1
+evaluate,evaluate,1,0,0,any,1
+evaluate,evaluate,2,0,0,null,1
+evaluate,evaluate,3,0,0,logical,1
+evaluate,evaluate,4,0,0,double,1
+evaluate,evaluate,5,0,0,logical,1
+evaluate,evaluate,6,0,0,logical,1
+evaluate,evaluate,7,0,0,logical,1
+evaluate,evaluate,8,0,0,class<`output_handler`>,1
+evaluate,evaluate,9,0,0,null,1
+evaluate,evaluate,10,0,0,logical,1
+evaluate,evaluate_call,-1,0,0,list<any>,1
+evaluate,evaluate_call,0,0,0,expression,1
+evaluate,evaluate_call,0,0,1,null,1
+evaluate,evaluate_call,1,0,0,character,1
+evaluate,evaluate_call,2,0,0,any,1
+evaluate,evaluate_call,3,0,0,any,1
+evaluate,evaluate_call,4,0,0,logical,1
+evaluate,evaluate_call,5,0,0,logical,1
+evaluate,evaluate_call,6,0,0,any,1
+evaluate,evaluate_call,7,0,0,any,1
+evaluate,evaluate_call,8,0,0,any,1
+evaluate,evaluate_call,9,0,0,class<`output_handler`>,1
+evaluate,evaluate_call,10,0,0,any,1
+evaluate,inject_funs,-1,0,0,list<any>,1
+evaluate,inject_funs,0,0,0,...,1
+evaluate,is.empty,-1,0,0,logical,1
+evaluate,is.empty,0,0,0,class<`recordedplot`>,1
+evaluate,is_par_change,-1,0,0,logical,1
+evaluate,is_par_change,0,0,0,null,1
+evaluate,is_par_change,1,0,0,class<`recordedplot`>,1
+evaluate,line_prompt,-1,0,0,character,1
+evaluate,line_prompt,0,0,0,character,1
+evaluate,line_prompt,1,0,0,character,1
+evaluate,line_prompt,2,0,0,any,1
+evaluate,new_source,-1,0,0,class<`source`>,1
+evaluate,new_source,0,0,0,character,1
+evaluate,parse_all,-1,0,0,class<`data.frame`>,1
+evaluate,parse_all,0,0,0,character[],1
+evaluate,parse_all,0,0,1,"class<`connection`, `file`>",1
+evaluate,parse_all,1,0,0,null,1
+evaluate,parse_all,1,0,1,character,1
+evaluate,parse_all,2,0,0,logical,1
+evaluate,parse_all.character,-1,0,0,class<`data.frame`>,1
+evaluate,parse_all.character,0,0,0,character[],1
+evaluate,parse_all.character,1,0,0,null,1
+evaluate,parse_all.character,1,0,1,character,1
+evaluate,parse_all.character,2,0,0,logical,1
+evaluate,parse_all.connection,-1,0,0,class<`data.frame`>,1
+evaluate,parse_all.connection,0,0,0,"class<`connection`, `file`>",1
+evaluate,parse_all.connection,1,0,0,null,1
+evaluate,parse_all.connection,2,0,0,...,1
+evaluate,plot_calls,-1,0,0,character[],1
+evaluate,plot_calls,-1,0,1,null,1
+evaluate,plot_calls,0,0,0,class<`recordedplot`>,1
+evaluate,plot_calls,0,0,1,null,1
+evaluate,plot_snapshot,-1,0,0,class<`recordedplot`>,1
+evaluate,plot_snapshot,-1,0,1,null,1
+evaluate,plot_snapshot,0,0,0,logical,1
+evaluate,remove_hooks,-1,0,0,null,1
+evaluate,remove_hooks,0,0,0,list<class<`function`>>,1
+evaluate,render,-1,0,0,null,1
+evaluate,render,0,0,0,null,1
+evaluate,render,0,0,1,class<`FOO_BAR`>,1
+evaluate,replay,-1,0,0,class<`recordedplot`>,1
+evaluate,replay,-1,0,1,null,1
+evaluate,replay,-1,0,2,list<null | class<`recordedplot`>>,1
+evaluate,replay,-1,0,3,list<null>,1
+evaluate,replay,0,0,0,class<`recordedplot`>,1
+evaluate,replay,0,0,1,character,1
+evaluate,replay,0,0,2,"class<`condition`, `error`, `simpleError`>",1
+evaluate,replay,0,0,3,"class<`condition`, `message`, `simpleMessage`>",1
+evaluate,replay,0,0,4,"class<`condition`, `simpleWarning`, `warning`>",1
+evaluate,replay,0,0,5,class<`source`>,1
+evaluate,replay,0,0,6,null,1
+evaluate,replay,0,0,7,list<any>,1
+evaluate,replay.character,-1,0,0,null,1
+evaluate,replay.character,0,0,0,character,1
+evaluate,replay.default,-1,0,0,null,1
+evaluate,replay.default,0,0,0,null,1
+evaluate,replay.error,-1,0,0,null,1
+evaluate,replay.error,0,0,0,"class<`condition`, `error`, `simpleError`>",1
+evaluate,replay.list,-1,0,0,list<null | class<`recordedplot`>>,1
+evaluate,replay.list,-1,0,1,list<null>,1
+evaluate,replay.list,0,0,0,list<any>,1
+evaluate,replay.message,-1,0,0,null,1
+evaluate,replay.message,0,0,0,"class<`condition`, `message`, `simpleMessage`>",1
+evaluate,replay.recordedplot,-1,0,0,class<`recordedplot`>,1
+evaluate,replay.recordedplot,0,0,0,class<`recordedplot`>,1
+evaluate,replay.source,-1,0,0,null,1
+evaluate,replay.source,0,0,0,class<`source`>,1
+evaluate,replay.warning,-1,0,0,null,1
+evaluate,replay.warning,0,0,0,"class<`condition`, `simpleWarning`, `warning`>",1
+evaluate,set_hooks,-1,0,0,list<list<any>>,1
+evaluate,set_hooks,0,0,0,list<class<`function`>>,1
+evaluate,set_hooks,0,0,1,list<list<any>>,1
+evaluate,set_hooks,1,0,0,character,1
+evaluate,watchout,-1,0,0,list<class<`function`>>,1
+evaluate,watchout,0,0,0,logical,1
+expm,%^%,-1,0,0,class<`matrix`>,1
+expm,%^%,0,0,0,class<`matrix`>,1
+expm,%^%,1,0,0,double,1
+expm,balance,-1,0,0,any,1
+expm,balance,0,0,0,class<`dgeMatrix`>,1
+expm,balance,0,0,1,class<`matrix`>,1
+expm,balance,1,0,0,character[],1
+expm,dgebal,-1,0,0,any,1
+expm,dgebal,0,0,0,class<`dgeMatrix`>,1
+expm,dgebal,0,0,1,class<`matrix`>,1
+expm,dgebal,1,0,0,character[],1
+expm,expAtv,-1,0,0,list<double[]>,1
+expm,expAtv,0,0,0,class<`dgCMatrix`>,1
+expm,expAtv,0,0,1,class<`dtCMatrix`>,1
+expm,expAtv,0,0,2,class<`matrix`>,1
+expm,expAtv,1,0,0,double[],1
+expm,expAtv,2,0,0,double,1
+expm,expAtv,3,0,0,character,1
+expm,expAtv,4,0,0,double,1
+expm,expAtv,5,0,0,double,1
+expm,expAtv,6,0,0,double,1
+expm,expAtv,7,0,0,double,1
+expm,expAtv,8,0,0,double,1
+expm,expAtv,9,0,0,any,1
+expm,expm,-1,0,0,any,1
+expm,expm,0,0,0,class<`dgCMatrix`>,1
+expm,expm,0,0,1,class<`matrix`>,1
+expm,expm,1,0,0,character[],1
+expm,expm,2,0,0,double,1
+expm,expm,3,0,0,logical,1
+expm,expm,4,0,0,any,1
+expm,expm,5,0,0,logical,1
+expm,expm,6,0,0,any,1
+expm,expm.AlMoHi09,-1,0,0,any,1
+expm,expm.AlMoHi09,0,0,0,class<`matrix`>,1
+expm,expm.AlMoHi09,0,0,1,class<`dgeMatrix`>,1
+expm,expm.AlMoHi09,1,0,0,double,1
+expm,expmCond,-1,0,0,double,1
+expm,expmCond,-1,0,1,list<double | class<`matrix`>>,1
+expm,expmCond,0,0,0,class<`matrix`>,1
+expm,expmCond,1,0,0,character,1
+expm,expmCond,2,0,0,logical,1
+expm,expmCond,3,0,0,double,1
+expm,expmCond,4,0,0,double,1
+expm,expmCond,5,0,0,character[],1
+expm,.expmCond.1,-1,0,0,double,1
+expm,.expmCond.1,-1,0,1,list<double | class<`matrix`>>,1
+expm,.expmCond.1,0,0,0,class<`matrix`>,1
+expm,.expmCond.1,1,0,0,logical,1
+expm,.expmCond.F,-1,0,0,list<double | class<`matrix`>>,1
+expm,.expmCond.F,0,0,0,class<`matrix`>,1
+expm,.expmCond.F,1,0,0,double,1
+expm,.expmCond.F,2,0,0,double,1
+expm,.expmCond.F,3,0,0,double,1
+expm,.expmCond.F,4,0,0,logical,1
+expm,.expmCond.X,-1,0,0,list<double | class<`matrix`>>,1
+expm,.expmCond.X,0,0,0,class<`matrix`>,1
+expm,.expmCond.X,1,0,0,character,1
+expm,.expmCond.X,2,0,0,logical,1
+expm,expmFrechet,-1,0,0,list<class<`matrix`>>,1
+expm,expmFrechet,0,0,0,class<`matrix`>,1
+expm,expmFrechet,1,0,0,class<`matrix`>,1
+expm,expmFrechet,2,0,0,any,1
+expm,expmFrechet,3,0,0,logical,1
+expm,.expmFrechet2008.26,-1,0,0,list<class<`matrix`>>,1
+expm,.expmFrechet2008.26,0,0,0,class<`matrix`>,1
+expm,.expmFrechet2008.26,1,0,0,class<`matrix`>,1
+expm,.expmFrechet2008.26,2,0,0,logical,1
+expm,expm.Higham08,-1,0,0,any,1
+expm,expm.Higham08,0,0,0,class<`matrix`>,1
+expm,expm.Higham08,0,0,1,class<`dgCMatrix`>,1
+expm,expm.Higham08,0,0,2,class<`dgeMatrix`>,1
+expm,expm.Higham08,1,0,0,logical,1
+expm,expm.s.Pade.s,-1,0,0,class<`dgeMatrix`>,1
+expm,expm.s.Pade.s,-1,0,1,class<`matrix`>,1
+expm,expm.s.Pade.s,0,0,0,class<`dgCMatrix`>,1
+expm,expm.s.Pade.s,0,0,1,class<`matrix`>,1
+expm,expm.s.Pade.s,1,0,0,double,1
+expm,expm.s.Pade.s,2,0,0,integer,1
+expm,logm,-1,0,0,any,1
+expm,logm,0,0,0,class<`matrix`>,1
+expm,logm,1,0,0,character[],1
+expm,logm,2,0,0,any,1
+expm,logm.Higham08,-1,0,0,class<`matrix`>,1
+expm,logm.Higham08,0,0,0,class<`matrix`>,1
+expm,rootS,-1,0,0,class<`matrix`>,1
+expm,rootS,0,0,0,class<`matrix`>,1
+expm,sqrtm,-1,0,0,class<`matrix`>,1
+expm,sqrtm,0,0,0,class<`matrix`>,1
+extraDistr,cpp_dbbinom,-1,0,0,double[],1
+extraDistr,cpp_dbbinom,0,0,0,integer[],1
+extraDistr,cpp_dbbinom,1,0,0,double,1
+extraDistr,cpp_dbbinom,2,0,0,double,1
+extraDistr,cpp_dbbinom,3,0,0,double,1
+extraDistr,cpp_dbbinom,4,0,0,logical,1
+extraDistr,cpp_dbetapr,-1,0,0,double[],1
+extraDistr,cpp_dbetapr,0,0,0,double[],1
+extraDistr,cpp_dbetapr,1,0,0,double,1
+extraDistr,cpp_dbetapr,2,0,0,double,1
+extraDistr,cpp_dbetapr,3,0,0,double,1
+extraDistr,cpp_dbetapr,4,0,0,logical,1
+extraDistr,cpp_dbhatt,-1,0,0,double[],1
+extraDistr,cpp_dbhatt,0,0,0,double[],1
+extraDistr,cpp_dbhatt,1,0,0,double,1
+extraDistr,cpp_dbhatt,2,0,0,double,1
+extraDistr,cpp_dbhatt,3,0,0,double,1
+extraDistr,cpp_dbhatt,4,0,0,logical,1
+extraDistr,cpp_dbnbinom,-1,0,0,double[],1
+extraDistr,cpp_dbnbinom,0,0,0,integer[],1
+extraDistr,cpp_dbnbinom,1,0,0,double,1
+extraDistr,cpp_dbnbinom,2,0,0,double,1
+extraDistr,cpp_dbnbinom,3,0,0,double,1
+extraDistr,cpp_dbnbinom,4,0,0,logical,1
+extraDistr,cpp_dbnorm,-1,0,0,double[],1
+extraDistr,cpp_dbnorm,0,0,0,double[],1
+extraDistr,cpp_dbnorm,1,0,0,double[],1
+extraDistr,cpp_dbnorm,2,0,0,double,1
+extraDistr,cpp_dbnorm,3,0,0,double,1
+extraDistr,cpp_dbnorm,4,0,0,double,1
+extraDistr,cpp_dbnorm,5,0,0,double,1
+extraDistr,cpp_dbnorm,6,0,0,double,1
+extraDistr,cpp_dbnorm,7,0,0,logical,1
+extraDistr,cpp_dcat,-1,0,0,double[],1
+extraDistr,cpp_dcat,0,0,0,double[],1
+extraDistr,cpp_dcat,1,0,0,class<`matrix`>,1
+extraDistr,cpp_dcat,2,0,0,logical,1
+extraDistr,cpp_ddgamma,-1,0,0,double[],1
+extraDistr,cpp_ddgamma,0,0,0,integer[],1
+extraDistr,cpp_ddgamma,1,0,0,double,1
+extraDistr,cpp_ddgamma,2,0,0,double,1
+extraDistr,cpp_ddgamma,3,0,0,logical,1
+extraDistr,cpp_ddlaplace,-1,0,0,double[],1
+extraDistr,cpp_ddlaplace,0,0,0,double[],1
+extraDistr,cpp_ddlaplace,1,0,0,double,1
+extraDistr,cpp_ddlaplace,2,0,0,double,1
+extraDistr,cpp_ddlaplace,3,0,0,logical,1
+extraDistr,cpp_ddnorm,-1,0,0,double[],1
+extraDistr,cpp_ddnorm,0,0,0,integer[],1
+extraDistr,cpp_ddnorm,1,0,0,double,1
+extraDistr,cpp_ddnorm,2,0,0,double,1
+extraDistr,cpp_ddnorm,3,0,0,logical,1
+extraDistr,cpp_ddunif,-1,0,0,double[],1
+extraDistr,cpp_ddunif,0,0,0,integer[],1
+extraDistr,cpp_ddunif,1,0,0,double,1
+extraDistr,cpp_ddunif,2,0,0,double,1
+extraDistr,cpp_ddunif,3,0,0,logical,1
+extraDistr,cpp_ddweibull,-1,0,0,double[],1
+extraDistr,cpp_ddweibull,0,0,0,double[],1
+extraDistr,cpp_ddweibull,1,0,0,double,1
+extraDistr,cpp_ddweibull,2,0,0,double,1
+extraDistr,cpp_ddweibull,3,0,0,logical,1
+extraDistr,cpp_dfatigue,-1,0,0,double[],1
+extraDistr,cpp_dfatigue,0,0,0,double[],1
+extraDistr,cpp_dfatigue,1,0,0,double,1
+extraDistr,cpp_dfatigue,2,0,0,double,1
+extraDistr,cpp_dfatigue,3,0,0,double,1
+extraDistr,cpp_dfatigue,4,0,0,logical,1
+extraDistr,cpp_dfrechet,-1,0,0,double[],1
+extraDistr,cpp_dfrechet,0,0,0,double[],1
+extraDistr,cpp_dfrechet,1,0,0,double,1
+extraDistr,cpp_dfrechet,2,0,0,double,1
+extraDistr,cpp_dfrechet,3,0,0,double,1
+extraDistr,cpp_dfrechet,4,0,0,logical,1
+extraDistr,cpp_dgev,-1,0,0,double[],1
+extraDistr,cpp_dgev,0,0,0,double[],1
+extraDistr,cpp_dgev,1,0,0,double,1
+extraDistr,cpp_dgev,2,0,0,double,1
+extraDistr,cpp_dgev,3,0,0,double,1
+extraDistr,cpp_dgev,4,0,0,logical,1
+extraDistr,cpp_dgompertz,-1,0,0,double[],1
+extraDistr,cpp_dgompertz,0,0,0,double[],1
+extraDistr,cpp_dgompertz,1,0,0,double,1
+extraDistr,cpp_dgompertz,2,0,0,double,1
+extraDistr,cpp_dgompertz,3,0,0,logical,1
+extraDistr,cpp_dgpd,-1,0,0,double[],1
+extraDistr,cpp_dgpd,0,0,0,double[],1
+extraDistr,cpp_dgpd,1,0,0,double,1
+extraDistr,cpp_dgpd,2,0,0,double,1
+extraDistr,cpp_dgpd,3,0,0,double,1
+extraDistr,cpp_dgpd,4,0,0,logical,1
+extraDistr,cpp_dgpois,-1,0,0,double[],1
+extraDistr,cpp_dgpois,0,0,0,double[],1
+extraDistr,cpp_dgpois,1,0,0,double,1
+extraDistr,cpp_dgpois,2,0,0,double,1
+extraDistr,cpp_dgpois,3,0,0,logical,1
+extraDistr,cpp_dgumbel,-1,0,0,double[],1
+extraDistr,cpp_dgumbel,0,0,0,double[],1
+extraDistr,cpp_dgumbel,1,0,0,double,1
+extraDistr,cpp_dgumbel,2,0,0,double,1
+extraDistr,cpp_dgumbel,3,0,0,logical,1
+extraDistr,cpp_dhcauchy,-1,0,0,double[],1
+extraDistr,cpp_dhcauchy,0,0,0,integer[],1
+extraDistr,cpp_dhcauchy,1,0,0,double,1
+extraDistr,cpp_dhcauchy,2,0,0,logical,1
+extraDistr,cpp_dhnorm,-1,0,0,double[],1
+extraDistr,cpp_dhnorm,0,0,0,double[],1
+extraDistr,cpp_dhnorm,1,0,0,double,1
+extraDistr,cpp_dhnorm,2,0,0,logical,1
+extraDistr,cpp_dht,-1,0,0,double[],1
+extraDistr,cpp_dht,0,0,0,integer[],1
+extraDistr,cpp_dht,1,0,0,double,1
+extraDistr,cpp_dht,2,0,0,double,1
+extraDistr,cpp_dht,3,0,0,logical,1
+extraDistr,cpp_dhuber,-1,0,0,double[],1
+extraDistr,cpp_dhuber,0,0,0,double[],1
+extraDistr,cpp_dhuber,1,0,0,double,1
+extraDistr,cpp_dhuber,2,0,0,double,1
+extraDistr,cpp_dhuber,3,0,0,double,1
+extraDistr,cpp_dhuber,4,0,0,logical,1
+extraDistr,cpp_dinvgamma,-1,0,0,double[],1
+extraDistr,cpp_dinvgamma,0,0,0,double[],1
+extraDistr,cpp_dinvgamma,1,0,0,double,1
+extraDistr,cpp_dinvgamma,2,0,0,double,1
+extraDistr,cpp_dinvgamma,3,0,0,logical,1
+extraDistr,cpp_dkumar,-1,0,0,double[],1
+extraDistr,cpp_dkumar,0,0,0,double[],1
+extraDistr,cpp_dkumar,1,0,0,double,1
+extraDistr,cpp_dkumar,2,0,0,double,1
+extraDistr,cpp_dkumar,3,0,0,logical,1
+extraDistr,cpp_dlaplace,-1,0,0,double[],1
+extraDistr,cpp_dlaplace,0,0,0,double[],1
+extraDistr,cpp_dlaplace,1,0,0,double,1
+extraDistr,cpp_dlaplace,2,0,0,double,1
+extraDistr,cpp_dlaplace,3,0,0,logical,1
+extraDistr,cpp_dlgser,-1,0,0,double[],1
+extraDistr,cpp_dlgser,0,0,0,double[],1
+extraDistr,cpp_dlgser,1,0,0,double,1
+extraDistr,cpp_dlgser,2,0,0,logical,1
+extraDistr,cpp_dlomax,-1,0,0,double[],1
+extraDistr,cpp_dlomax,0,0,0,double[],1
+extraDistr,cpp_dlomax,1,0,0,double,1
+extraDistr,cpp_dlomax,2,0,0,double,1
+extraDistr,cpp_dlomax,3,0,0,logical,1
+extraDistr,cpp_dlst,-1,0,0,double[],1
+extraDistr,cpp_dlst,0,0,0,double[],1
+extraDistr,cpp_dlst,1,0,0,double,1
+extraDistr,cpp_dlst,2,0,0,double,1
+extraDistr,cpp_dlst,3,0,0,double,1
+extraDistr,cpp_dlst,4,0,0,logical,1
+extraDistr,cpp_dmixnorm,-1,0,0,double[],1
+extraDistr,cpp_dmixnorm,0,0,0,double[],1
+extraDistr,cpp_dmixnorm,1,0,0,class<`matrix`>,1
+extraDistr,cpp_dmixnorm,2,0,0,class<`matrix`>,1
+extraDistr,cpp_dmixnorm,3,0,0,class<`matrix`>,1
+extraDistr,cpp_dmixnorm,4,0,0,logical,1
+extraDistr,cpp_dmixpois,-1,0,0,double[],1
+extraDistr,cpp_dmixpois,0,0,0,integer[],1
+extraDistr,cpp_dmixpois,1,0,0,class<`matrix`>,1
+extraDistr,cpp_dmixpois,2,0,0,class<`matrix`>,1
+extraDistr,cpp_dmixpois,3,0,0,logical,1
+extraDistr,cpp_dmnom,-1,0,0,double,1
+extraDistr,cpp_dmnom,0,0,0,class<`matrix`>,1
+extraDistr,cpp_dmnom,1,0,0,double,1
+extraDistr,cpp_dmnom,2,0,0,class<`matrix`>,1
+extraDistr,cpp_dmnom,3,0,0,logical,1
+extraDistr,cpp_dnhyper,-1,0,0,double[],1
+extraDistr,cpp_dnhyper,0,0,0,integer[],1
+extraDistr,cpp_dnhyper,1,0,0,double,1
+extraDistr,cpp_dnhyper,2,0,0,double,1
+extraDistr,cpp_dnhyper,3,0,0,double,1
+extraDistr,cpp_dnhyper,4,0,0,logical,1
+extraDistr,cpp_dnsbeta,-1,0,0,double[],1
+extraDistr,cpp_dnsbeta,0,0,0,double[],1
+extraDistr,cpp_dnsbeta,1,0,0,double,1
+extraDistr,cpp_dnsbeta,2,0,0,double,1
+extraDistr,cpp_dnsbeta,3,0,0,double,1
+extraDistr,cpp_dnsbeta,4,0,0,double,1
+extraDistr,cpp_dnsbeta,5,0,0,logical,1
+extraDistr,cpp_dpareto,-1,0,0,double[],1
+extraDistr,cpp_dpareto,0,0,0,integer[],1
+extraDistr,cpp_dpareto,1,0,0,double,1
+extraDistr,cpp_dpareto,2,0,0,double,1
+extraDistr,cpp_dpareto,3,0,0,logical,1
+extraDistr,cpp_dpower,-1,0,0,double[],1
+extraDistr,cpp_dpower,0,0,0,double[],1
+extraDistr,cpp_dpower,1,0,0,double,1
+extraDistr,cpp_dpower,2,0,0,double,1
+extraDistr,cpp_dpower,3,0,0,logical,1
+extraDistr,cpp_dprop,-1,0,0,double[],1
+extraDistr,cpp_dprop,0,0,0,double[],1
+extraDistr,cpp_dprop,1,0,0,double,1
+extraDistr,cpp_dprop,2,0,0,double,1
+extraDistr,cpp_dprop,3,0,0,double,1
+extraDistr,cpp_dprop,4,0,0,logical,1
+extraDistr,cpp_drayleigh,-1,0,0,double[],1
+extraDistr,cpp_drayleigh,0,0,0,double[],1
+extraDistr,cpp_drayleigh,1,0,0,double,1
+extraDistr,cpp_drayleigh,2,0,0,logical,1
+extraDistr,cpp_dsgomp,-1,0,0,double[],1
+extraDistr,cpp_dsgomp,0,0,0,double[],1
+extraDistr,cpp_dsgomp,1,0,0,double,1
+extraDistr,cpp_dsgomp,2,0,0,double,1
+extraDistr,cpp_dsgomp,3,0,0,logical,1
+extraDistr,cpp_dskellam,-1,0,0,double[],1
+extraDistr,cpp_dskellam,0,0,0,integer[],1
+extraDistr,cpp_dskellam,1,0,0,double,1
+extraDistr,cpp_dskellam,2,0,0,double,1
+extraDistr,cpp_dskellam,3,0,0,logical,1
+extraDistr,cpp_dslash,-1,0,0,double[],1
+extraDistr,cpp_dslash,0,0,0,double[],1
+extraDistr,cpp_dslash,1,0,0,double,1
+extraDistr,cpp_dslash,2,0,0,double,1
+extraDistr,cpp_dslash,3,0,0,logical,1
+extraDistr,cpp_dtbinom,-1,0,0,double[],1
+extraDistr,cpp_dtbinom,0,0,0,integer[],1
+extraDistr,cpp_dtbinom,1,0,0,double,1
+extraDistr,cpp_dtbinom,2,0,0,double,1
+extraDistr,cpp_dtbinom,3,0,0,double,1
+extraDistr,cpp_dtbinom,4,0,0,double,1
+extraDistr,cpp_dtbinom,5,0,0,logical,1
+extraDistr,cpp_dtnorm,-1,0,0,double[],1
+extraDistr,cpp_dtnorm,0,0,0,double[],1
+extraDistr,cpp_dtnorm,1,0,0,double,1
+extraDistr,cpp_dtnorm,2,0,0,double,1
+extraDistr,cpp_dtnorm,3,0,0,double,1
+extraDistr,cpp_dtnorm,4,0,0,double,1
+extraDistr,cpp_dtnorm,5,0,0,logical,1
+extraDistr,cpp_dtpois,-1,0,0,double[],1
+extraDistr,cpp_dtpois,0,0,0,integer[],1
+extraDistr,cpp_dtpois,1,0,0,double,1
+extraDistr,cpp_dtpois,2,0,0,double,1
+extraDistr,cpp_dtpois,3,0,0,double,1
+extraDistr,cpp_dtpois,4,0,0,logical,1
+extraDistr,cpp_dtriang,-1,0,0,double[],1
+extraDistr,cpp_dtriang,0,0,0,double[],1
+extraDistr,cpp_dtriang,1,0,0,double,1
+extraDistr,cpp_dtriang,2,0,0,double,1
+extraDistr,cpp_dtriang,3,0,0,double,1
+extraDistr,cpp_dtriang,4,0,0,logical,1
+extraDistr,cpp_dwald,-1,0,0,double[],1
+extraDistr,cpp_dwald,0,0,0,double[],1
+extraDistr,cpp_dwald,1,0,0,double,1
+extraDistr,cpp_dwald,2,0,0,double,1
+extraDistr,cpp_dwald,3,0,0,logical,1
+extraDistr,cpp_dzib,-1,0,0,double[],1
+extraDistr,cpp_dzib,0,0,0,integer[],1
+extraDistr,cpp_dzib,1,0,0,double,1
+extraDistr,cpp_dzib,2,0,0,double,1
+extraDistr,cpp_dzib,3,0,0,double,1
+extraDistr,cpp_dzib,4,0,0,logical,1
+extraDistr,cpp_dzinb,-1,0,0,double[],1
+extraDistr,cpp_dzinb,0,0,0,integer[],1
+extraDistr,cpp_dzinb,1,0,0,double,1
+extraDistr,cpp_dzinb,2,0,0,double,1
+extraDistr,cpp_dzinb,3,0,0,double,1
+extraDistr,cpp_dzinb,4,0,0,logical,1
+extraDistr,cpp_dzip,-1,0,0,double[],1
+extraDistr,cpp_dzip,0,0,0,integer[],1
+extraDistr,cpp_dzip,1,0,0,double,1
+extraDistr,cpp_dzip,2,0,0,double,1
+extraDistr,cpp_dzip,3,0,0,logical,1
+extraDistr,cpp_pbbinom,-1,0,0,double[],1
+extraDistr,cpp_pbbinom,0,0,0,double[],1
+extraDistr,cpp_pbbinom,1,0,0,double,1
+extraDistr,cpp_pbbinom,2,0,0,double,1
+extraDistr,cpp_pbbinom,3,0,0,double,1
+extraDistr,cpp_pbbinom,4,0,0,logical,1
+extraDistr,cpp_pbbinom,5,0,0,logical,1
+extraDistr,cpp_pbetapr,-1,0,0,double[],1
+extraDistr,cpp_pbetapr,0,0,0,double[],1
+extraDistr,cpp_pbetapr,1,0,0,double,1
+extraDistr,cpp_pbetapr,2,0,0,double,1
+extraDistr,cpp_pbetapr,3,0,0,double,1
+extraDistr,cpp_pbetapr,4,0,0,logical,1
+extraDistr,cpp_pbetapr,5,0,0,logical,1
+extraDistr,cpp_pbhatt,-1,0,0,double[],1
+extraDistr,cpp_pbhatt,0,0,0,double[],1
+extraDistr,cpp_pbhatt,1,0,0,double,1
+extraDistr,cpp_pbhatt,2,0,0,double,1
+extraDistr,cpp_pbhatt,3,0,0,double,1
+extraDistr,cpp_pbhatt,4,0,0,logical,1
+extraDistr,cpp_pbhatt,5,0,0,logical,1
+extraDistr,cpp_pbnbinom,-1,0,0,double[],1
+extraDistr,cpp_pbnbinom,0,0,0,double[],1
+extraDistr,cpp_pbnbinom,1,0,0,double,1
+extraDistr,cpp_pbnbinom,2,0,0,double,1
+extraDistr,cpp_pbnbinom,3,0,0,double,1
+extraDistr,cpp_pbnbinom,4,0,0,logical,1
+extraDistr,cpp_pbnbinom,5,0,0,logical,1
+extraDistr,cpp_pcat,-1,0,0,double[],1
+extraDistr,cpp_pcat,0,0,0,double[],1
+extraDistr,cpp_pcat,1,0,0,class<`matrix`>,1
+extraDistr,cpp_pcat,2,0,0,logical,1
+extraDistr,cpp_pcat,3,0,0,logical,1
+extraDistr,cpp_pdlaplace,-1,0,0,double[],1
+extraDistr,cpp_pdlaplace,0,0,0,double[],1
+extraDistr,cpp_pdlaplace,1,0,0,double,1
+extraDistr,cpp_pdlaplace,2,0,0,double,1
+extraDistr,cpp_pdlaplace,3,0,0,logical,1
+extraDistr,cpp_pdlaplace,4,0,0,logical,1
+extraDistr,cpp_pdunif,-1,0,0,double[],1
+extraDistr,cpp_pdunif,0,0,0,double[],1
+extraDistr,cpp_pdunif,1,0,0,double,1
+extraDistr,cpp_pdunif,2,0,0,double,1
+extraDistr,cpp_pdunif,3,0,0,logical,1
+extraDistr,cpp_pdunif,4,0,0,logical,1
+extraDistr,cpp_pdweibull,-1,0,0,double[],1
+extraDistr,cpp_pdweibull,0,0,0,double[],1
+extraDistr,cpp_pdweibull,1,0,0,double,1
+extraDistr,cpp_pdweibull,2,0,0,double,1
+extraDistr,cpp_pdweibull,3,0,0,logical,1
+extraDistr,cpp_pdweibull,4,0,0,logical,1
+extraDistr,cpp_pfatigue,-1,0,0,double[],1
+extraDistr,cpp_pfatigue,0,0,0,double[],1
+extraDistr,cpp_pfatigue,1,0,0,double,1
+extraDistr,cpp_pfatigue,2,0,0,double,1
+extraDistr,cpp_pfatigue,3,0,0,double,1
+extraDistr,cpp_pfatigue,4,0,0,logical,1
+extraDistr,cpp_pfatigue,5,0,0,logical,1
+extraDistr,cpp_pfrechet,-1,0,0,double[],1
+extraDistr,cpp_pfrechet,0,0,0,double[],1
+extraDistr,cpp_pfrechet,1,0,0,double,1
+extraDistr,cpp_pfrechet,2,0,0,double,1
+extraDistr,cpp_pfrechet,3,0,0,double,1
+extraDistr,cpp_pfrechet,4,0,0,logical,1
+extraDistr,cpp_pfrechet,5,0,0,logical,1
+extraDistr,cpp_pgev,-1,0,0,double[],1
+extraDistr,cpp_pgev,0,0,0,double[],1
+extraDistr,cpp_pgev,1,0,0,double,1
+extraDistr,cpp_pgev,2,0,0,double,1
+extraDistr,cpp_pgev,3,0,0,double,1
+extraDistr,cpp_pgev,4,0,0,logical,1
+extraDistr,cpp_pgev,5,0,0,logical,1
+extraDistr,cpp_pgompertz,-1,0,0,double[],1
+extraDistr,cpp_pgompertz,0,0,0,double[],1
+extraDistr,cpp_pgompertz,1,0,0,double,1
+extraDistr,cpp_pgompertz,2,0,0,double,1
+extraDistr,cpp_pgompertz,3,0,0,logical,1
+extraDistr,cpp_pgompertz,4,0,0,logical,1
+extraDistr,cpp_pgpd,-1,0,0,double[],1
+extraDistr,cpp_pgpd,0,0,0,double[],1
+extraDistr,cpp_pgpd,1,0,0,double,1
+extraDistr,cpp_pgpd,2,0,0,double,1
+extraDistr,cpp_pgpd,3,0,0,double,1
+extraDistr,cpp_pgpd,4,0,0,logical,1
+extraDistr,cpp_pgpd,5,0,0,logical,1
+extraDistr,cpp_pgpois,-1,0,0,double[],1
+extraDistr,cpp_pgpois,0,0,0,double[],1
+extraDistr,cpp_pgpois,1,0,0,double,1
+extraDistr,cpp_pgpois,2,0,0,double,1
+extraDistr,cpp_pgpois,3,0,0,logical,1
+extraDistr,cpp_pgpois,4,0,0,logical,1
+extraDistr,cpp_pgumbel,-1,0,0,double[],1
+extraDistr,cpp_pgumbel,0,0,0,double[],1
+extraDistr,cpp_pgumbel,1,0,0,double,1
+extraDistr,cpp_pgumbel,2,0,0,double,1
+extraDistr,cpp_pgumbel,3,0,0,logical,1
+extraDistr,cpp_pgumbel,4,0,0,logical,1
+extraDistr,cpp_phcauchy,-1,0,0,double[],1
+extraDistr,cpp_phcauchy,0,0,0,double[],1
+extraDistr,cpp_phcauchy,1,0,0,double,1
+extraDistr,cpp_phcauchy,2,0,0,logical,1
+extraDistr,cpp_phcauchy,3,0,0,logical,1
+extraDistr,cpp_phnorm,-1,0,0,double[],1
+extraDistr,cpp_phnorm,0,0,0,double[],1
+extraDistr,cpp_phnorm,1,0,0,double,1
+extraDistr,cpp_phnorm,2,0,0,logical,1
+extraDistr,cpp_phnorm,3,0,0,logical,1
+extraDistr,cpp_pht,-1,0,0,double[],1
+extraDistr,cpp_pht,0,0,0,double[],1
+extraDistr,cpp_pht,1,0,0,double,1
+extraDistr,cpp_pht,2,0,0,double,1
+extraDistr,cpp_pht,3,0,0,logical,1
+extraDistr,cpp_pht,4,0,0,logical,1
+extraDistr,cpp_phuber,-1,0,0,double[],1
+extraDistr,cpp_phuber,0,0,0,double[],1
+extraDistr,cpp_phuber,1,0,0,double,1
+extraDistr,cpp_phuber,2,0,0,double,1
+extraDistr,cpp_phuber,3,0,0,double,1
+extraDistr,cpp_phuber,4,0,0,logical,1
+extraDistr,cpp_phuber,5,0,0,logical,1
+extraDistr,cpp_pinvgamma,-1,0,0,double[],1
+extraDistr,cpp_pinvgamma,0,0,0,double[],1
+extraDistr,cpp_pinvgamma,1,0,0,double,1
+extraDistr,cpp_pinvgamma,2,0,0,double,1
+extraDistr,cpp_pinvgamma,3,0,0,logical,1
+extraDistr,cpp_pinvgamma,4,0,0,logical,1
+extraDistr,cpp_pkumar,-1,0,0,double[],1
+extraDistr,cpp_pkumar,0,0,0,double[],1
+extraDistr,cpp_pkumar,1,0,0,double,1
+extraDistr,cpp_pkumar,2,0,0,double,1
+extraDistr,cpp_pkumar,3,0,0,logical,1
+extraDistr,cpp_pkumar,4,0,0,logical,1
+extraDistr,cpp_plaplace,-1,0,0,double[],1
+extraDistr,cpp_plaplace,0,0,0,double[],1
+extraDistr,cpp_plaplace,1,0,0,double,1
+extraDistr,cpp_plaplace,2,0,0,double,1
+extraDistr,cpp_plaplace,3,0,0,logical,1
+extraDistr,cpp_plaplace,4,0,0,logical,1
+extraDistr,cpp_plgser,-1,0,0,double[],1
+extraDistr,cpp_plgser,0,0,0,double[],1
+extraDistr,cpp_plgser,1,0,0,double,1
+extraDistr,cpp_plgser,2,0,0,logical,1
+extraDistr,cpp_plgser,3,0,0,logical,1
+extraDistr,cpp_plomax,-1,0,0,double[],1
+extraDistr,cpp_plomax,0,0,0,double[],1
+extraDistr,cpp_plomax,1,0,0,double,1
+extraDistr,cpp_plomax,2,0,0,double,1
+extraDistr,cpp_plomax,3,0,0,logical,1
+extraDistr,cpp_plomax,4,0,0,logical,1
+extraDistr,cpp_plst,-1,0,0,double[],1
+extraDistr,cpp_plst,0,0,0,double[],1
+extraDistr,cpp_plst,1,0,0,double,1
+extraDistr,cpp_plst,2,0,0,double,1
+extraDistr,cpp_plst,3,0,0,double,1
+extraDistr,cpp_plst,4,0,0,logical,1
+extraDistr,cpp_plst,5,0,0,logical,1
+extraDistr,cpp_pmixnorm,-1,0,0,double[],1
+extraDistr,cpp_pmixnorm,0,0,0,double[],1
+extraDistr,cpp_pmixnorm,1,0,0,class<`matrix`>,1
+extraDistr,cpp_pmixnorm,2,0,0,class<`matrix`>,1
+extraDistr,cpp_pmixnorm,3,0,0,class<`matrix`>,1
+extraDistr,cpp_pmixnorm,4,0,0,logical,1
+extraDistr,cpp_pmixnorm,5,0,0,logical,1
+extraDistr,cpp_pmixpois,-1,0,0,double[],1
+extraDistr,cpp_pmixpois,0,0,0,double[],1
+extraDistr,cpp_pmixpois,1,0,0,class<`matrix`>,1
+extraDistr,cpp_pmixpois,2,0,0,class<`matrix`>,1
+extraDistr,cpp_pmixpois,3,0,0,logical,1
+extraDistr,cpp_pmixpois,4,0,0,logical,1
+extraDistr,cpp_pnhyper,-1,0,0,double[],1
+extraDistr,cpp_pnhyper,0,0,0,double[],1
+extraDistr,cpp_pnhyper,1,0,0,double,1
+extraDistr,cpp_pnhyper,2,0,0,double,1
+extraDistr,cpp_pnhyper,3,0,0,double,1
+extraDistr,cpp_pnhyper,4,0,0,logical,1
+extraDistr,cpp_pnhyper,5,0,0,logical,1
+extraDistr,cpp_pnsbeta,-1,0,0,double[],1
+extraDistr,cpp_pnsbeta,0,0,0,double[],1
+extraDistr,cpp_pnsbeta,1,0,0,double,1
+extraDistr,cpp_pnsbeta,2,0,0,double,1
+extraDistr,cpp_pnsbeta,3,0,0,double,1
+extraDistr,cpp_pnsbeta,4,0,0,double,1
+extraDistr,cpp_pnsbeta,5,0,0,logical,1
+extraDistr,cpp_pnsbeta,6,0,0,logical,1
+extraDistr,cpp_ppareto,-1,0,0,double[],1
+extraDistr,cpp_ppareto,0,0,0,double[],1
+extraDistr,cpp_ppareto,1,0,0,double,1
+extraDistr,cpp_ppareto,2,0,0,double,1
+extraDistr,cpp_ppareto,3,0,0,logical,1
+extraDistr,cpp_ppareto,4,0,0,logical,1
+extraDistr,cpp_ppower,-1,0,0,double[],1
+extraDistr,cpp_ppower,0,0,0,double[],1
+extraDistr,cpp_ppower,1,0,0,double,1
+extraDistr,cpp_ppower,2,0,0,double,1
+extraDistr,cpp_ppower,3,0,0,logical,1
+extraDistr,cpp_ppower,4,0,0,logical,1
+extraDistr,cpp_pprop,-1,0,0,double[],1
+extraDistr,cpp_pprop,0,0,0,double[],1
+extraDistr,cpp_pprop,1,0,0,double,1
+extraDistr,cpp_pprop,2,0,0,double,1
+extraDistr,cpp_pprop,3,0,0,double,1
+extraDistr,cpp_pprop,4,0,0,logical,1
+extraDistr,cpp_pprop,5,0,0,logical,1
+extraDistr,cpp_prayleigh,-1,0,0,double[],1
+extraDistr,cpp_prayleigh,0,0,0,double[],1
+extraDistr,cpp_prayleigh,1,0,0,double,1
+extraDistr,cpp_prayleigh,2,0,0,logical,1
+extraDistr,cpp_prayleigh,3,0,0,logical,1
+extraDistr,cpp_psgomp,-1,0,0,double[],1
+extraDistr,cpp_psgomp,0,0,0,double[],1
+extraDistr,cpp_psgomp,1,0,0,double,1
+extraDistr,cpp_psgomp,2,0,0,double,1
+extraDistr,cpp_psgomp,3,0,0,logical,1
+extraDistr,cpp_psgomp,4,0,0,logical,1
+extraDistr,cpp_pslash,-1,0,0,double[],1
+extraDistr,cpp_pslash,0,0,0,double[],1
+extraDistr,cpp_pslash,1,0,0,double,1
+extraDistr,cpp_pslash,2,0,0,double,1
+extraDistr,cpp_pslash,3,0,0,logical,1
+extraDistr,cpp_pslash,4,0,0,logical,1
+extraDistr,cpp_ptbinom,-1,0,0,double[],1
+extraDistr,cpp_ptbinom,0,0,0,double[],1
+extraDistr,cpp_ptbinom,1,0,0,double,1
+extraDistr,cpp_ptbinom,2,0,0,double,1
+extraDistr,cpp_ptbinom,3,0,0,double,1
+extraDistr,cpp_ptbinom,4,0,0,double,1
+extraDistr,cpp_ptbinom,5,0,0,logical,1
+extraDistr,cpp_ptbinom,6,0,0,logical,1
+extraDistr,cpp_ptnorm,-1,0,0,double[],1
+extraDistr,cpp_ptnorm,0,0,0,double[],1
+extraDistr,cpp_ptnorm,1,0,0,double,1
+extraDistr,cpp_ptnorm,2,0,0,double,1
+extraDistr,cpp_ptnorm,3,0,0,double,1
+extraDistr,cpp_ptnorm,4,0,0,double,1
+extraDistr,cpp_ptnorm,5,0,0,logical,1
+extraDistr,cpp_ptnorm,6,0,0,logical,1
+extraDistr,cpp_ptpois,-1,0,0,double[],1
+extraDistr,cpp_ptpois,0,0,0,double[],1
+extraDistr,cpp_ptpois,1,0,0,double,1
+extraDistr,cpp_ptpois,2,0,0,double,1
+extraDistr,cpp_ptpois,3,0,0,double,1
+extraDistr,cpp_ptpois,4,0,0,logical,1
+extraDistr,cpp_ptpois,5,0,0,logical,1
+extraDistr,cpp_ptriang,-1,0,0,double[],1
+extraDistr,cpp_ptriang,0,0,0,double[],1
+extraDistr,cpp_ptriang,1,0,0,double,1
+extraDistr,cpp_ptriang,2,0,0,double,1
+extraDistr,cpp_ptriang,3,0,0,double,1
+extraDistr,cpp_ptriang,4,0,0,logical,1
+extraDistr,cpp_ptriang,5,0,0,logical,1
+extraDistr,cpp_pwald,-1,0,0,double[],1
+extraDistr,cpp_pwald,0,0,0,double[],1
+extraDistr,cpp_pwald,1,0,0,double,1
+extraDistr,cpp_pwald,2,0,0,double,1
+extraDistr,cpp_pwald,3,0,0,logical,1
+extraDistr,cpp_pwald,4,0,0,logical,1
+extraDistr,cpp_pzib,-1,0,0,double[],1
+extraDistr,cpp_pzib,0,0,0,double[],1
+extraDistr,cpp_pzib,1,0,0,double,1
+extraDistr,cpp_pzib,2,0,0,double,1
+extraDistr,cpp_pzib,3,0,0,double,1
+extraDistr,cpp_pzib,4,0,0,logical,1
+extraDistr,cpp_pzib,5,0,0,logical,1
+extraDistr,cpp_pzinb,-1,0,0,double[],1
+extraDistr,cpp_pzinb,0,0,0,double[],1
+extraDistr,cpp_pzinb,1,0,0,double,1
+extraDistr,cpp_pzinb,2,0,0,double,1
+extraDistr,cpp_pzinb,3,0,0,double,1
+extraDistr,cpp_pzinb,4,0,0,logical,1
+extraDistr,cpp_pzinb,5,0,0,logical,1
+extraDistr,cpp_pzip,-1,0,0,double[],1
+extraDistr,cpp_pzip,0,0,0,double[],1
+extraDistr,cpp_pzip,1,0,0,double,1
+extraDistr,cpp_pzip,2,0,0,double,1
+extraDistr,cpp_pzip,3,0,0,logical,1
+extraDistr,cpp_pzip,4,0,0,logical,1
+extraDistr,cpp_qcat,-1,0,0,double[],1
+extraDistr,cpp_qcat,0,0,0,double[],1
+extraDistr,cpp_qcat,1,0,0,class<`matrix`>,1
+extraDistr,cpp_qcat,2,0,0,logical,1
+extraDistr,cpp_qcat,3,0,0,logical,1
+extraDistr,cpp_qtbinom,-1,0,0,double[],1
+extraDistr,cpp_qtbinom,0,0,0,double[],1
+extraDistr,cpp_qtbinom,1,0,0,double,1
+extraDistr,cpp_qtbinom,2,0,0,double,1
+extraDistr,cpp_qtbinom,3,0,0,double,1
+extraDistr,cpp_qtbinom,4,0,0,double,1
+extraDistr,cpp_qtbinom,5,0,0,logical,1
+extraDistr,cpp_qtbinom,6,0,0,logical,1
+extraDistr,cpp_qtlambda,-1,0,0,double[],1
+extraDistr,cpp_qtlambda,0,0,0,double[],1
+extraDistr,cpp_qtlambda,1,0,0,double,1
+extraDistr,cpp_qtlambda,2,0,0,logical,1
+extraDistr,cpp_qtlambda,3,0,0,logical,1
+extraDistr,cpp_qtpois,-1,0,0,double[],1
+extraDistr,cpp_qtpois,0,0,0,double[],1
+extraDistr,cpp_qtpois,1,0,0,double,1
+extraDistr,cpp_qtpois,2,0,0,double,1
+extraDistr,cpp_qtpois,3,0,0,double,1
+extraDistr,cpp_qtpois,4,0,0,logical,1
+extraDistr,cpp_qtpois,5,0,0,logical,1
+extraDistr,cpp_rbbinom,-1,0,0,double[],1
+extraDistr,cpp_rbbinom,0,0,0,double,1
+extraDistr,cpp_rbbinom,1,0,0,double,1
+extraDistr,cpp_rbbinom,2,0,0,double,1
+extraDistr,cpp_rbbinom,3,0,0,double,1
+extraDistr,cpp_rbern,-1,0,0,double[],1
+extraDistr,cpp_rbern,0,0,0,double,1
+extraDistr,cpp_rbern,1,0,0,double,1
+extraDistr,cpp_rbetapr,-1,0,0,double[],1
+extraDistr,cpp_rbetapr,0,0,0,double,1
+extraDistr,cpp_rbetapr,1,0,0,double,1
+extraDistr,cpp_rbetapr,2,0,0,double,1
+extraDistr,cpp_rbetapr,3,0,0,double,1
+extraDistr,cpp_rbhatt,-1,0,0,double[],1
+extraDistr,cpp_rbhatt,0,0,0,double,1
+extraDistr,cpp_rbhatt,1,0,0,double,1
+extraDistr,cpp_rbhatt,2,0,0,double,1
+extraDistr,cpp_rbhatt,3,0,0,double,1
+extraDistr,cpp_rbnbinom,-1,0,0,double[],1
+extraDistr,cpp_rbnbinom,0,0,0,double,1
+extraDistr,cpp_rbnbinom,1,0,0,double,1
+extraDistr,cpp_rbnbinom,2,0,0,double,1
+extraDistr,cpp_rbnbinom,3,0,0,double,1
+extraDistr,cpp_rbpois,-1,0,0,class<`matrix`>,1
+extraDistr,cpp_rbpois,0,0,0,double,1
+extraDistr,cpp_rbpois,1,0,0,double,1
+extraDistr,cpp_rbpois,2,0,0,double,1
+extraDistr,cpp_rbpois,3,0,0,double,1
+extraDistr,cpp_rcat,-1,0,0,double[],1
+extraDistr,cpp_rcat,0,0,0,double,1
+extraDistr,cpp_rcat,1,0,0,class<`matrix`>,1
+extraDistr,cpp_rdirichlet,-1,0,0,class<`matrix`>,1
+extraDistr,cpp_rdirichlet,0,0,0,double,1
+extraDistr,cpp_rdirichlet,1,0,0,class<`matrix`>,1
+extraDistr,cpp_rdlaplace,-1,0,0,double[],1
+extraDistr,cpp_rdlaplace,0,0,0,double,1
+extraDistr,cpp_rdlaplace,1,0,0,double,1
+extraDistr,cpp_rdlaplace,2,0,0,double,1
+extraDistr,cpp_rdunif,-1,0,0,double[],1
+extraDistr,cpp_rdunif,0,0,0,double,1
+extraDistr,cpp_rdunif,1,0,0,double,1
+extraDistr,cpp_rdunif,2,0,0,double,1
+extraDistr,cpp_rdweibull,-1,0,0,double[],1
+extraDistr,cpp_rdweibull,0,0,0,double,1
+extraDistr,cpp_rdweibull,1,0,0,double,1
+extraDistr,cpp_rdweibull,2,0,0,double,1
+extraDistr,cpp_rfatigue,-1,0,0,double[],1
+extraDistr,cpp_rfatigue,0,0,0,double,1
+extraDistr,cpp_rfatigue,1,0,0,double,1
+extraDistr,cpp_rfatigue,2,0,0,double,1
+extraDistr,cpp_rfatigue,3,0,0,double,1
+extraDistr,cpp_rfrechet,-1,0,0,double[],1
+extraDistr,cpp_rfrechet,0,0,0,double,1
+extraDistr,cpp_rfrechet,1,0,0,double,1
+extraDistr,cpp_rfrechet,2,0,0,double,1
+extraDistr,cpp_rfrechet,3,0,0,double,1
+extraDistr,cpp_rgev,-1,0,0,double[],1
+extraDistr,cpp_rgev,0,0,0,double,1
+extraDistr,cpp_rgev,1,0,0,double,1
+extraDistr,cpp_rgev,2,0,0,double,1
+extraDistr,cpp_rgev,3,0,0,double,1
+extraDistr,cpp_rgompertz,-1,0,0,double[],1
+extraDistr,cpp_rgompertz,0,0,0,double,1
+extraDistr,cpp_rgompertz,1,0,0,double,1
+extraDistr,cpp_rgompertz,2,0,0,double,1
+extraDistr,cpp_rgpd,-1,0,0,double[],1
+extraDistr,cpp_rgpd,0,0,0,double,1
+extraDistr,cpp_rgpd,1,0,0,double,1
+extraDistr,cpp_rgpd,2,0,0,double,1
+extraDistr,cpp_rgpd,3,0,0,double,1
+extraDistr,cpp_rgpois,-1,0,0,double[],1
+extraDistr,cpp_rgpois,0,0,0,double,1
+extraDistr,cpp_rgpois,1,0,0,double,1
+extraDistr,cpp_rgpois,2,0,0,double,1
+extraDistr,cpp_rgumbel,-1,0,0,double[],1
+extraDistr,cpp_rgumbel,0,0,0,double,1
+extraDistr,cpp_rgumbel,1,0,0,double,1
+extraDistr,cpp_rgumbel,2,0,0,double,1
+extraDistr,cpp_rhcauchy,-1,0,0,double[],1
+extraDistr,cpp_rhcauchy,0,0,0,double,1
+extraDistr,cpp_rhcauchy,1,0,0,double,1
+extraDistr,cpp_rhnorm,-1,0,0,double[],1
+extraDistr,cpp_rhnorm,0,0,0,double,1
+extraDistr,cpp_rhnorm,1,0,0,double,1
+extraDistr,cpp_rht,-1,0,0,double[],1
+extraDistr,cpp_rht,0,0,0,double,1
+extraDistr,cpp_rht,1,0,0,double,1
+extraDistr,cpp_rht,2,0,0,double,1
+extraDistr,cpp_rhuber,-1,0,0,double[],1
+extraDistr,cpp_rhuber,0,0,0,double,1
+extraDistr,cpp_rhuber,1,0,0,double,1
+extraDistr,cpp_rhuber,2,0,0,double,1
+extraDistr,cpp_rhuber,3,0,0,double,1
+extraDistr,cpp_rkumar,-1,0,0,double[],1
+extraDistr,cpp_rkumar,0,0,0,double,1
+extraDistr,cpp_rkumar,1,0,0,double,1
+extraDistr,cpp_rkumar,2,0,0,double,1
+extraDistr,cpp_rlaplace,-1,0,0,double[],1
+extraDistr,cpp_rlaplace,0,0,0,double,1
+extraDistr,cpp_rlaplace,1,0,0,double,1
+extraDistr,cpp_rlaplace,2,0,0,double,1
+extraDistr,cpp_rlgser,-1,0,0,double[],1
+extraDistr,cpp_rlgser,0,0,0,double,1
+extraDistr,cpp_rlgser,1,0,0,double,1
+extraDistr,cpp_rlomax,-1,0,0,double[],1
+extraDistr,cpp_rlomax,0,0,0,double,1
+extraDistr,cpp_rlomax,1,0,0,double,1
+extraDistr,cpp_rlomax,2,0,0,double,1
+extraDistr,cpp_rlst,-1,0,0,double[],1
+extraDistr,cpp_rlst,0,0,0,double,1
+extraDistr,cpp_rlst,1,0,0,double,1
+extraDistr,cpp_rlst,2,0,0,double,1
+extraDistr,cpp_rlst,3,0,0,double,1
+extraDistr,cpp_rmixnorm,-1,0,0,double[],1
+extraDistr,cpp_rmixnorm,0,0,0,double,1
+extraDistr,cpp_rmixnorm,1,0,0,class<`matrix`>,1
+extraDistr,cpp_rmixnorm,2,0,0,class<`matrix`>,1
+extraDistr,cpp_rmixnorm,3,0,0,class<`matrix`>,1
+extraDistr,cpp_rmixpois,-1,0,0,double[],1
+extraDistr,cpp_rmixpois,0,0,0,double,1
+extraDistr,cpp_rmixpois,1,0,0,class<`matrix`>,1
+extraDistr,cpp_rmixpois,2,0,0,class<`matrix`>,1
+extraDistr,cpp_rmnom,-1,0,0,class<`matrix`>,1
+extraDistr,cpp_rmnom,0,0,0,double,1
+extraDistr,cpp_rmnom,1,0,0,double,1
+extraDistr,cpp_rmnom,2,0,0,class<`matrix`>,1
+extraDistr,cpp_rmvhyper,-1,0,0,class<`matrix`>,1
+extraDistr,cpp_rmvhyper,0,0,0,double,1
+extraDistr,cpp_rmvhyper,1,0,0,class<`matrix`>,1
+extraDistr,cpp_rmvhyper,2,0,0,double,1
+extraDistr,cpp_rnhyper,-1,0,0,double[],1
+extraDistr,cpp_rnhyper,0,0,0,double,1
+extraDistr,cpp_rnhyper,1,0,0,double,1
+extraDistr,cpp_rnhyper,2,0,0,double,1
+extraDistr,cpp_rnhyper,3,0,0,double,1
+extraDistr,cpp_rnsbeta,-1,0,0,double[],1
+extraDistr,cpp_rnsbeta,0,0,0,double,1
+extraDistr,cpp_rnsbeta,1,0,0,double,1
+extraDistr,cpp_rnsbeta,2,0,0,double,1
+extraDistr,cpp_rnsbeta,3,0,0,double,1
+extraDistr,cpp_rnsbeta,4,0,0,double,1
+extraDistr,cpp_rpareto,-1,0,0,double[],1
+extraDistr,cpp_rpareto,0,0,0,double,1
+extraDistr,cpp_rpareto,1,0,0,double,1
+extraDistr,cpp_rpareto,2,0,0,double,1
+extraDistr,cpp_rpower,-1,0,0,double[],1
+extraDistr,cpp_rpower,0,0,0,double,1
+extraDistr,cpp_rpower,1,0,0,double,1
+extraDistr,cpp_rpower,2,0,0,double,1
+extraDistr,cpp_rprop,-1,0,0,double[],1
+extraDistr,cpp_rprop,0,0,0,double,1
+extraDistr,cpp_rprop,1,0,0,double,1
+extraDistr,cpp_rprop,2,0,0,double,1
+extraDistr,cpp_rprop,3,0,0,double,1
+extraDistr,cpp_rrayleigh,-1,0,0,double[],1
+extraDistr,cpp_rrayleigh,0,0,0,double,1
+extraDistr,cpp_rrayleigh,1,0,0,double,1
+extraDistr,cpp_rsgomp,-1,0,0,double[],1
+extraDistr,cpp_rsgomp,0,0,0,double,1
+extraDistr,cpp_rsgomp,1,0,0,double,1
+extraDistr,cpp_rsgomp,2,0,0,double,1
+extraDistr,cpp_rskellam,-1,0,0,double[],1
+extraDistr,cpp_rskellam,0,0,0,double,1
+extraDistr,cpp_rskellam,1,0,0,double,1
+extraDistr,cpp_rskellam,2,0,0,double,1
+extraDistr,cpp_rslash,-1,0,0,double[],1
+extraDistr,cpp_rslash,0,0,0,double,1
+extraDistr,cpp_rslash,1,0,0,double,1
+extraDistr,cpp_rslash,2,0,0,double,1
+extraDistr,cpp_rtbinom,-1,0,0,double[],1
+extraDistr,cpp_rtbinom,0,0,0,double,1
+extraDistr,cpp_rtbinom,1,0,0,double,1
+extraDistr,cpp_rtbinom,2,0,0,double,1
+extraDistr,cpp_rtbinom,3,0,0,double,1
+extraDistr,cpp_rtbinom,4,0,0,double,1
+extraDistr,cpp_rtlambda,-1,0,0,double[],1
+extraDistr,cpp_rtlambda,0,0,0,double,1
+extraDistr,cpp_rtlambda,1,0,0,double,1
+extraDistr,cpp_rtnorm,-1,0,0,double[],1
+extraDistr,cpp_rtnorm,0,0,0,double,1
+extraDistr,cpp_rtnorm,1,0,0,double,1
+extraDistr,cpp_rtnorm,2,0,0,double,1
+extraDistr,cpp_rtnorm,3,0,0,double,1
+extraDistr,cpp_rtnorm,4,0,0,double,1
+extraDistr,cpp_rtpois,-1,0,0,double[],1
+extraDistr,cpp_rtpois,0,0,0,double,1
+extraDistr,cpp_rtpois,1,0,0,double,1
+extraDistr,cpp_rtpois,2,0,0,double,1
+extraDistr,cpp_rtpois,3,0,0,double,1
+extraDistr,cpp_rtriang,-1,0,0,double[],1
+extraDistr,cpp_rtriang,0,0,0,double,1
+extraDistr,cpp_rtriang,1,0,0,double,1
+extraDistr,cpp_rtriang,2,0,0,double,1
+extraDistr,cpp_rtriang,3,0,0,double,1
+extraDistr,cpp_rwald,-1,0,0,double[],1
+extraDistr,cpp_rwald,0,0,0,double,1
+extraDistr,cpp_rwald,1,0,0,double,1
+extraDistr,cpp_rwald,2,0,0,double,1
+extraDistr,cpp_rzib,-1,0,0,double[],1
+extraDistr,cpp_rzib,0,0,0,double,1
+extraDistr,cpp_rzib,1,0,0,double,1
+extraDistr,cpp_rzib,2,0,0,double,1
+extraDistr,cpp_rzib,3,0,0,double,1
+extraDistr,cpp_rzinb,-1,0,0,double[],1
+extraDistr,cpp_rzinb,0,0,0,double,1
+extraDistr,cpp_rzinb,1,0,0,double,1
+extraDistr,cpp_rzinb,2,0,0,double,1
+extraDistr,cpp_rzinb,3,0,0,double,1
+extraDistr,cpp_rzip,-1,0,0,double[],1
+extraDistr,cpp_rzip,0,0,0,double,1
+extraDistr,cpp_rzip,1,0,0,double,1
+extraDistr,cpp_rzip,2,0,0,double,1
+extraDistr,dbbinom,-1,0,0,double[],1
+extraDistr,dbbinom,0,0,0,integer[],1
+extraDistr,dbbinom,1,0,0,double,1
+extraDistr,dbbinom,2,0,0,double,1
+extraDistr,dbbinom,3,0,0,double,1
+extraDistr,dbbinom,4,0,0,logical,1
+extraDistr,dbetapr,-1,0,0,double[],1
+extraDistr,dbetapr,0,0,0,double[],1
+extraDistr,dbetapr,1,0,0,double,1
+extraDistr,dbetapr,2,0,0,double,1
+extraDistr,dbetapr,3,0,0,double,1
+extraDistr,dbetapr,4,0,0,logical,1
+extraDistr,dbhatt,-1,0,0,double[],1
+extraDistr,dbhatt,0,0,0,double[],1
+extraDistr,dbhatt,1,0,0,double,1
+extraDistr,dbhatt,2,0,0,double,1
+extraDistr,dbhatt,3,0,0,double,1
+extraDistr,dbhatt,4,0,0,logical,1
+extraDistr,dbnbinom,-1,0,0,double[],1
+extraDistr,dbnbinom,0,0,0,integer[],1
+extraDistr,dbnbinom,1,0,0,double,1
+extraDistr,dbnbinom,2,0,0,double,1
+extraDistr,dbnbinom,3,0,0,double,1
+extraDistr,dbnbinom,4,0,0,logical,1
+extraDistr,dbvnorm,-1,0,0,double[],1
+extraDistr,dbvnorm,0,0,0,double[],1
+extraDistr,dbvnorm,1,0,0,double[],1
+extraDistr,dbvnorm,2,0,0,double,1
+extraDistr,dbvnorm,3,0,0,double,1
+extraDistr,dbvnorm,4,0,0,double,1
+extraDistr,dbvnorm,5,0,0,double,1
+extraDistr,dbvnorm,6,0,0,double,1
+extraDistr,dbvnorm,7,0,0,logical,1
+extraDistr,dcat,-1,0,0,double[],1
+extraDistr,dcat,0,0,0,integer[],1
+extraDistr,dcat,1,0,0,class<`matrix`>,1
+extraDistr,dcat,1,0,1,double[],1
+extraDistr,dcat,2,0,0,logical,1
+extraDistr,ddgamma,-1,0,0,double[],1
+extraDistr,ddgamma,0,0,0,integer[],1
+extraDistr,ddgamma,1,0,0,double,1
+extraDistr,ddgamma,2,0,0,double,1
+extraDistr,ddgamma,3,0,0,double,1
+extraDistr,ddgamma,4,0,0,logical,1
+extraDistr,ddlaplace,-1,0,0,double[],1
+extraDistr,ddlaplace,0,0,0,double[],1
+extraDistr,ddlaplace,1,0,0,double,1
+extraDistr,ddlaplace,2,0,0,double,1
+extraDistr,ddlaplace,3,0,0,logical,1
+extraDistr,ddnorm,-1,0,0,double[],1
+extraDistr,ddnorm,0,0,0,integer[],1
+extraDistr,ddnorm,1,0,0,double,1
+extraDistr,ddnorm,2,0,0,double,1
+extraDistr,ddnorm,3,0,0,logical,1
+extraDistr,ddunif,-1,0,0,double[],1
+extraDistr,ddunif,0,0,0,integer[],1
+extraDistr,ddunif,1,0,0,double,1
+extraDistr,ddunif,2,0,0,double,1
+extraDistr,ddunif,3,0,0,logical,1
+extraDistr,ddweibull,-1,0,0,double[],1
+extraDistr,ddweibull,0,0,0,double[],1
+extraDistr,ddweibull,1,0,0,double,1
+extraDistr,ddweibull,2,0,0,double,1
+extraDistr,ddweibull,3,0,0,logical,1
+extraDistr,dfatigue,-1,0,0,double[],1
+extraDistr,dfatigue,0,0,0,double[],1
+extraDistr,dfatigue,1,0,0,double,1
+extraDistr,dfatigue,2,0,0,double,1
+extraDistr,dfatigue,3,0,0,double,1
+extraDistr,dfatigue,4,0,0,logical,1
+extraDistr,dfrechet,-1,0,0,double[],1
+extraDistr,dfrechet,0,0,0,double[],1
+extraDistr,dfrechet,1,0,0,double,1
+extraDistr,dfrechet,2,0,0,double,1
+extraDistr,dfrechet,3,0,0,double,1
+extraDistr,dfrechet,4,0,0,logical,1
+extraDistr,dgev,-1,0,0,double[],1
+extraDistr,dgev,0,0,0,double[],1
+extraDistr,dgev,1,0,0,double,1
+extraDistr,dgev,2,0,0,double,1
+extraDistr,dgev,3,0,0,double,1
+extraDistr,dgev,4,0,0,logical,1
+extraDistr,dgompertz,-1,0,0,double[],1
+extraDistr,dgompertz,0,0,0,double[],1
+extraDistr,dgompertz,1,0,0,double,1
+extraDistr,dgompertz,2,0,0,double,1
+extraDistr,dgompertz,3,0,0,logical,1
+extraDistr,dgpd,-1,0,0,double[],1
+extraDistr,dgpd,0,0,0,double[],1
+extraDistr,dgpd,1,0,0,double,1
+extraDistr,dgpd,2,0,0,double,1
+extraDistr,dgpd,3,0,0,double,1
+extraDistr,dgpd,4,0,0,logical,1
+extraDistr,dgpois,-1,0,0,double[],1
+extraDistr,dgpois,0,0,0,double[],1
+extraDistr,dgpois,1,0,0,double,1
+extraDistr,dgpois,2,0,0,double,1
+extraDistr,dgpois,3,0,0,double,1
+extraDistr,dgpois,4,0,0,logical,1
+extraDistr,dgumbel,-1,0,0,double[],1
+extraDistr,dgumbel,0,0,0,double[],1
+extraDistr,dgumbel,1,0,0,double,1
+extraDistr,dgumbel,2,0,0,double,1
+extraDistr,dgumbel,3,0,0,logical,1
+extraDistr,dhcauchy,-1,0,0,double[],1
+extraDistr,dhcauchy,0,0,0,integer[],1
+extraDistr,dhcauchy,1,0,0,double,1
+extraDistr,dhcauchy,2,0,0,logical,1
+extraDistr,dhnorm,-1,0,0,double[],1
+extraDistr,dhnorm,0,0,0,double[],1
+extraDistr,dhnorm,1,0,0,double,1
+extraDistr,dhnorm,2,0,0,logical,1
+extraDistr,dht,-1,0,0,double[],1
+extraDistr,dht,0,0,0,integer[],1
+extraDistr,dht,1,0,0,double,1
+extraDistr,dht,2,0,0,double,1
+extraDistr,dht,3,0,0,logical,1
+extraDistr,dhuber,-1,0,0,double[],1
+extraDistr,dhuber,0,0,0,double[],1
+extraDistr,dhuber,1,0,0,double,1
+extraDistr,dhuber,2,0,0,double,1
+extraDistr,dhuber,3,0,0,double,1
+extraDistr,dhuber,4,0,0,logical,1
+extraDistr,dinvchisq,-1,0,0,double[],1
+extraDistr,dinvchisq,0,0,0,double[],1
+extraDistr,dinvchisq,1,0,0,double,1
+extraDistr,dinvchisq,2,0,0,any,1
+extraDistr,dinvchisq,3,0,0,logical,1
+extraDistr,dinvgamma,-1,0,0,double[],1
+extraDistr,dinvgamma,0,0,0,double[],1
+extraDistr,dinvgamma,1,0,0,double,1
+extraDistr,dinvgamma,2,0,0,double,1
+extraDistr,dinvgamma,3,0,0,logical,1
+extraDistr,dkumar,-1,0,0,double[],1
+extraDistr,dkumar,0,0,0,double[],1
+extraDistr,dkumar,1,0,0,double,1
+extraDistr,dkumar,2,0,0,double,1
+extraDistr,dkumar,3,0,0,logical,1
+extraDistr,dlaplace,-1,0,0,double[],1
+extraDistr,dlaplace,0,0,0,double[],1
+extraDistr,dlaplace,1,0,0,double,1
+extraDistr,dlaplace,2,0,0,double,1
+extraDistr,dlaplace,3,0,0,logical,1
+extraDistr,dlgser,-1,0,0,double[],1
+extraDistr,dlgser,0,0,0,double[],1
+extraDistr,dlgser,1,0,0,double,1
+extraDistr,dlgser,2,0,0,logical,1
+extraDistr,dlomax,-1,0,0,double[],1
+extraDistr,dlomax,0,0,0,double[],1
+extraDistr,dlomax,1,0,0,double,1
+extraDistr,dlomax,2,0,0,double,1
+extraDistr,dlomax,3,0,0,logical,1
+extraDistr,dlst,-1,0,0,double[],1
+extraDistr,dlst,0,0,0,double[],1
+extraDistr,dlst,1,0,0,double,1
+extraDistr,dlst,2,0,0,double,1
+extraDistr,dlst,3,0,0,double,1
+extraDistr,dlst,4,0,0,logical,1
+extraDistr,dmixnorm,-1,0,0,double[],1
+extraDistr,dmixnorm,0,0,0,double[],1
+extraDistr,dmixnorm,1,0,0,double[],1
+extraDistr,dmixnorm,2,0,0,double[],1
+extraDistr,dmixnorm,3,0,0,double[],1
+extraDistr,dmixnorm,4,0,0,logical,1
+extraDistr,dmixpois,-1,0,0,double[],1
+extraDistr,dmixpois,0,0,0,integer[],1
+extraDistr,dmixpois,1,0,0,double[],1
+extraDistr,dmixpois,2,0,0,double[],1
+extraDistr,dmixpois,3,0,0,logical,1
+extraDistr,dmnom,-1,0,0,double,1
+extraDistr,dmnom,0,0,0,class<`matrix`>,1
+extraDistr,dmnom,1,0,0,double,1
+extraDistr,dmnom,2,0,0,double[],1
+extraDistr,dmnom,3,0,0,logical,1
+extraDistr,dnhyper,-1,0,0,double[],1
+extraDistr,dnhyper,0,0,0,integer[],1
+extraDistr,dnhyper,1,0,0,double,1
+extraDistr,dnhyper,2,0,0,double,1
+extraDistr,dnhyper,3,0,0,double,1
+extraDistr,dnhyper,4,0,0,logical,1
+extraDistr,dnsbeta,-1,0,0,double[],1
+extraDistr,dnsbeta,0,0,0,double[],1
+extraDistr,dnsbeta,1,0,0,double,1
+extraDistr,dnsbeta,2,0,0,double,1
+extraDistr,dnsbeta,3,0,0,double,1
+extraDistr,dnsbeta,4,0,0,double,1
+extraDistr,dnsbeta,5,0,0,logical,1
+extraDistr,dpareto,-1,0,0,double[],1
+extraDistr,dpareto,0,0,0,integer[],1
+extraDistr,dpareto,1,0,0,double,1
+extraDistr,dpareto,2,0,0,double,1
+extraDistr,dpareto,3,0,0,logical,1
+extraDistr,dpower,-1,0,0,double[],1
+extraDistr,dpower,0,0,0,double[],1
+extraDistr,dpower,1,0,0,double,1
+extraDistr,dpower,2,0,0,double,1
+extraDistr,dpower,3,0,0,logical,1
+extraDistr,dprop,-1,0,0,double[],1
+extraDistr,dprop,0,0,0,double[],1
+extraDistr,dprop,1,0,0,double,1
+extraDistr,dprop,2,0,0,double,1
+extraDistr,dprop,3,0,0,double,1
+extraDistr,dprop,4,0,0,logical,1
+extraDistr,drayleigh,-1,0,0,double[],1
+extraDistr,drayleigh,0,0,0,double[],1
+extraDistr,drayleigh,1,0,0,double,1
+extraDistr,drayleigh,2,0,0,logical,1
+extraDistr,dsgomp,-1,0,0,double[],1
+extraDistr,dsgomp,0,0,0,double[],1
+extraDistr,dsgomp,1,0,0,double,1
+extraDistr,dsgomp,2,0,0,double,1
+extraDistr,dsgomp,3,0,0,logical,1
+extraDistr,dskellam,-1,0,0,double[],1
+extraDistr,dskellam,0,0,0,integer[],1
+extraDistr,dskellam,1,0,0,double,1
+extraDistr,dskellam,2,0,0,double,1
+extraDistr,dskellam,3,0,0,logical,1
+extraDistr,dslash,-1,0,0,double[],1
+extraDistr,dslash,0,0,0,double[],1
+extraDistr,dslash,1,0,0,double,1
+extraDistr,dslash,2,0,0,double,1
+extraDistr,dslash,3,0,0,logical,1
+extraDistr,dtbinom,-1,0,0,double[],1
+extraDistr,dtbinom,0,0,0,integer[],1
+extraDistr,dtbinom,1,0,0,double,1
+extraDistr,dtbinom,2,0,0,double,1
+extraDistr,dtbinom,3,0,0,double,1
+extraDistr,dtbinom,4,0,0,double,1
+extraDistr,dtbinom,5,0,0,logical,1
+extraDistr,dtnorm,-1,0,0,double[],1
+extraDistr,dtnorm,0,0,0,double[],1
+extraDistr,dtnorm,1,0,0,double,1
+extraDistr,dtnorm,2,0,0,double,1
+extraDistr,dtnorm,3,0,0,double,1
+extraDistr,dtnorm,4,0,0,double,1
+extraDistr,dtnorm,5,0,0,logical,1
+extraDistr,dtpois,-1,0,0,double[],1
+extraDistr,dtpois,0,0,0,integer[],1
+extraDistr,dtpois,1,0,0,double,1
+extraDistr,dtpois,2,0,0,double,1
+extraDistr,dtpois,3,0,0,double,1
+extraDistr,dtpois,4,0,0,logical,1
+extraDistr,dtriang,-1,0,0,double[],1
+extraDistr,dtriang,0,0,0,double[],1
+extraDistr,dtriang,1,0,0,double,1
+extraDistr,dtriang,2,0,0,double,1
+extraDistr,dtriang,3,0,0,double,1
+extraDistr,dtriang,4,0,0,logical,1
+extraDistr,dwald,-1,0,0,double[],1
+extraDistr,dwald,0,0,0,double[],1
+extraDistr,dwald,1,0,0,double,1
+extraDistr,dwald,2,0,0,double,1
+extraDistr,dwald,3,0,0,logical,1
+extraDistr,dzib,-1,0,0,double[],1
+extraDistr,dzib,0,0,0,integer[],1
+extraDistr,dzib,1,0,0,double,1
+extraDistr,dzib,2,0,0,double,1
+extraDistr,dzib,3,0,0,double,1
+extraDistr,dzib,4,0,0,logical,1
+extraDistr,dzinb,-1,0,0,double[],1
+extraDistr,dzinb,0,0,0,integer[],1
+extraDistr,dzinb,1,0,0,double,1
+extraDistr,dzinb,2,0,0,double,1
+extraDistr,dzinb,3,0,0,double,1
+extraDistr,dzinb,4,0,0,logical,1
+extraDistr,dzip,-1,0,0,double[],1
+extraDistr,dzip,0,0,0,integer[],1
+extraDistr,dzip,1,0,0,double,1
+extraDistr,dzip,2,0,0,double,1
+extraDistr,dzip,3,0,0,logical,1
+extraDistr,pbbinom,-1,0,0,double[],1
+extraDistr,pbbinom,0,0,0,double[],1
+extraDistr,pbbinom,1,0,0,double,1
+extraDistr,pbbinom,2,0,0,double,1
+extraDistr,pbbinom,3,0,0,double,1
+extraDistr,pbbinom,4,0,0,logical,1
+extraDistr,pbbinom,5,0,0,logical,1
+extraDistr,pbetapr,-1,0,0,double[],1
+extraDistr,pbetapr,0,0,0,double[],1
+extraDistr,pbetapr,1,0,0,double,1
+extraDistr,pbetapr,2,0,0,double,1
+extraDistr,pbetapr,3,0,0,double,1
+extraDistr,pbetapr,4,0,0,logical,1
+extraDistr,pbetapr,5,0,0,logical,1
+extraDistr,pbhatt,-1,0,0,double[],1
+extraDistr,pbhatt,0,0,0,double[],1
+extraDistr,pbhatt,1,0,0,double,1
+extraDistr,pbhatt,2,0,0,double,1
+extraDistr,pbhatt,3,0,0,double,1
+extraDistr,pbhatt,4,0,0,logical,1
+extraDistr,pbhatt,5,0,0,logical,1
+extraDistr,pbnbinom,-1,0,0,double[],1
+extraDistr,pbnbinom,0,0,0,double[],1
+extraDistr,pbnbinom,1,0,0,double,1
+extraDistr,pbnbinom,2,0,0,double,1
+extraDistr,pbnbinom,3,0,0,double,1
+extraDistr,pbnbinom,4,0,0,logical,1
+extraDistr,pbnbinom,5,0,0,logical,1
+extraDistr,pcat,-1,0,0,double[],1
+extraDistr,pcat,0,0,0,double[],1
+extraDistr,pcat,1,0,0,class<`matrix`>,1
+extraDistr,pcat,2,0,0,logical,1
+extraDistr,pcat,3,0,0,logical,1
+extraDistr,pdgamma,-1,0,0,double[],1
+extraDistr,pdgamma,0,0,0,double[],1
+extraDistr,pdgamma,1,0,0,double,1
+extraDistr,pdgamma,2,0,0,double,1
+extraDistr,pdgamma,3,0,0,double,1
+extraDistr,pdgamma,4,0,0,logical,1
+extraDistr,pdgamma,5,0,0,logical,1
+extraDistr,pdlaplace,-1,0,0,double[],1
+extraDistr,pdlaplace,0,0,0,double[],1
+extraDistr,pdlaplace,1,0,0,double,1
+extraDistr,pdlaplace,2,0,0,double,1
+extraDistr,pdlaplace,3,0,0,logical,1
+extraDistr,pdlaplace,4,0,0,logical,1
+extraDistr,pdnorm,-1,0,0,double[],1
+extraDistr,pdnorm,0,0,0,double[],1
+extraDistr,pdnorm,1,0,0,double,1
+extraDistr,pdnorm,2,0,0,double,1
+extraDistr,pdnorm,3,0,0,logical,1
+extraDistr,pdnorm,4,0,0,logical,1
+extraDistr,pdunif,-1,0,0,double[],1
+extraDistr,pdunif,0,0,0,double[],1
+extraDistr,pdunif,1,0,0,double,1
+extraDistr,pdunif,2,0,0,double,1
+extraDistr,pdunif,3,0,0,logical,1
+extraDistr,pdunif,4,0,0,logical,1
+extraDistr,pdweibull,-1,0,0,double[],1
+extraDistr,pdweibull,0,0,0,double[],1
+extraDistr,pdweibull,1,0,0,double,1
+extraDistr,pdweibull,2,0,0,double,1
+extraDistr,pdweibull,3,0,0,logical,1
+extraDistr,pdweibull,4,0,0,logical,1
+extraDistr,pfatigue,-1,0,0,double[],1
+extraDistr,pfatigue,0,0,0,double[],1
+extraDistr,pfatigue,1,0,0,double,1
+extraDistr,pfatigue,2,0,0,double,1
+extraDistr,pfatigue,3,0,0,double,1
+extraDistr,pfatigue,4,0,0,logical,1
+extraDistr,pfatigue,5,0,0,logical,1
+extraDistr,pfrechet,-1,0,0,double[],1
+extraDistr,pfrechet,0,0,0,double[],1
+extraDistr,pfrechet,1,0,0,double,1
+extraDistr,pfrechet,2,0,0,double,1
+extraDistr,pfrechet,3,0,0,double,1
+extraDistr,pfrechet,4,0,0,logical,1
+extraDistr,pfrechet,5,0,0,logical,1
+extraDistr,pgev,-1,0,0,double[],1
+extraDistr,pgev,0,0,0,double[],1
+extraDistr,pgev,1,0,0,double,1
+extraDistr,pgev,2,0,0,double,1
+extraDistr,pgev,3,0,0,double,1
+extraDistr,pgev,4,0,0,logical,1
+extraDistr,pgev,5,0,0,logical,1
+extraDistr,pgompertz,-1,0,0,double[],1
+extraDistr,pgompertz,0,0,0,double[],1
+extraDistr,pgompertz,1,0,0,double,1
+extraDistr,pgompertz,2,0,0,double,1
+extraDistr,pgompertz,3,0,0,logical,1
+extraDistr,pgompertz,4,0,0,logical,1
+extraDistr,pgpd,-1,0,0,double[],1
+extraDistr,pgpd,0,0,0,double[],1
+extraDistr,pgpd,1,0,0,double,1
+extraDistr,pgpd,2,0,0,double,1
+extraDistr,pgpd,3,0,0,double,1
+extraDistr,pgpd,4,0,0,logical,1
+extraDistr,pgpd,5,0,0,logical,1
+extraDistr,pgpois,-1,0,0,double[],1
+extraDistr,pgpois,0,0,0,double[],1
+extraDistr,pgpois,1,0,0,double,1
+extraDistr,pgpois,2,0,0,double,1
+extraDistr,pgpois,3,0,0,double,1
+extraDistr,pgpois,4,0,0,logical,1
+extraDistr,pgpois,5,0,0,logical,1
+extraDistr,pgumbel,-1,0,0,double[],1
+extraDistr,pgumbel,0,0,0,double[],1
+extraDistr,pgumbel,1,0,0,double,1
+extraDistr,pgumbel,2,0,0,double,1
+extraDistr,pgumbel,3,0,0,logical,1
+extraDistr,pgumbel,4,0,0,logical,1
+extraDistr,phcauchy,-1,0,0,double[],1
+extraDistr,phcauchy,0,0,0,double[],1
+extraDistr,phcauchy,1,0,0,double,1
+extraDistr,phcauchy,2,0,0,logical,1
+extraDistr,phcauchy,3,0,0,logical,1
+extraDistr,phnorm,-1,0,0,double[],1
+extraDistr,phnorm,0,0,0,double[],1
+extraDistr,phnorm,1,0,0,double,1
+extraDistr,phnorm,2,0,0,logical,1
+extraDistr,phnorm,3,0,0,logical,1
+extraDistr,pht,-1,0,0,double[],1
+extraDistr,pht,0,0,0,double[],1
+extraDistr,pht,1,0,0,double,1
+extraDistr,pht,2,0,0,double,1
+extraDistr,pht,3,0,0,logical,1
+extraDistr,pht,4,0,0,logical,1
+extraDistr,phuber,-1,0,0,double[],1
+extraDistr,phuber,0,0,0,double[],1
+extraDistr,phuber,1,0,0,double,1
+extraDistr,phuber,2,0,0,double,1
+extraDistr,phuber,3,0,0,double,1
+extraDistr,phuber,4,0,0,logical,1
+extraDistr,phuber,5,0,0,logical,1
+extraDistr,pinvchisq,-1,0,0,double[],1
+extraDistr,pinvchisq,0,0,0,double[],1
+extraDistr,pinvchisq,1,0,0,double,1
+extraDistr,pinvchisq,2,0,0,any,1
+extraDistr,pinvchisq,3,0,0,logical,1
+extraDistr,pinvchisq,4,0,0,logical,1
+extraDistr,pinvgamma,-1,0,0,double[],1
+extraDistr,pinvgamma,0,0,0,double[],1
+extraDistr,pinvgamma,1,0,0,double,1
+extraDistr,pinvgamma,2,0,0,double,1
+extraDistr,pinvgamma,3,0,0,logical,1
+extraDistr,pinvgamma,4,0,0,logical,1
+extraDistr,pkumar,-1,0,0,double[],1
+extraDistr,pkumar,0,0,0,double[],1
+extraDistr,pkumar,1,0,0,double,1
+extraDistr,pkumar,2,0,0,double,1
+extraDistr,pkumar,3,0,0,logical,1
+extraDistr,pkumar,4,0,0,logical,1
+extraDistr,plaplace,-1,0,0,double[],1
+extraDistr,plaplace,0,0,0,double[],1
+extraDistr,plaplace,1,0,0,double,1
+extraDistr,plaplace,2,0,0,double,1
+extraDistr,plaplace,3,0,0,logical,1
+extraDistr,plaplace,4,0,0,logical,1
+extraDistr,plgser,-1,0,0,double[],1
+extraDistr,plgser,0,0,0,double[],1
+extraDistr,plgser,1,0,0,double,1
+extraDistr,plgser,2,0,0,logical,1
+extraDistr,plgser,3,0,0,logical,1
+extraDistr,plomax,-1,0,0,double[],1
+extraDistr,plomax,0,0,0,double[],1
+extraDistr,plomax,1,0,0,double,1
+extraDistr,plomax,2,0,0,double,1
+extraDistr,plomax,3,0,0,logical,1
+extraDistr,plomax,4,0,0,logical,1
+extraDistr,plst,-1,0,0,double[],1
+extraDistr,plst,0,0,0,double[],1
+extraDistr,plst,1,0,0,double,1
+extraDistr,plst,2,0,0,double,1
+extraDistr,plst,3,0,0,double,1
+extraDistr,plst,4,0,0,logical,1
+extraDistr,plst,5,0,0,logical,1
+extraDistr,pmixnorm,-1,0,0,double[],1
+extraDistr,pmixnorm,0,0,0,double[],1
+extraDistr,pmixnorm,1,0,0,double[],1
+extraDistr,pmixnorm,2,0,0,double[],1
+extraDistr,pmixnorm,3,0,0,double[],1
+extraDistr,pmixnorm,4,0,0,logical,1
+extraDistr,pmixnorm,5,0,0,logical,1
+extraDistr,pmixpois,-1,0,0,double[],1
+extraDistr,pmixpois,0,0,0,double[],1
+extraDistr,pmixpois,1,0,0,double[],1
+extraDistr,pmixpois,2,0,0,double[],1
+extraDistr,pmixpois,3,0,0,logical,1
+extraDistr,pmixpois,4,0,0,logical,1
+extraDistr,pnhyper,-1,0,0,double[],1
+extraDistr,pnhyper,0,0,0,double[],1
+extraDistr,pnhyper,1,0,0,double,1
+extraDistr,pnhyper,2,0,0,double,1
+extraDistr,pnhyper,3,0,0,double,1
+extraDistr,pnhyper,4,0,0,logical,1
+extraDistr,pnhyper,5,0,0,logical,1
+extraDistr,pnsbeta,-1,0,0,double[],1
+extraDistr,pnsbeta,0,0,0,double[],1
+extraDistr,pnsbeta,1,0,0,double,1
+extraDistr,pnsbeta,2,0,0,double,1
+extraDistr,pnsbeta,3,0,0,double,1
+extraDistr,pnsbeta,4,0,0,double,1
+extraDistr,pnsbeta,5,0,0,logical,1
+extraDistr,pnsbeta,6,0,0,logical,1
+extraDistr,ppareto,-1,0,0,double[],1
+extraDistr,ppareto,0,0,0,double[],1
+extraDistr,ppareto,1,0,0,double,1
+extraDistr,ppareto,2,0,0,double,1
+extraDistr,ppareto,3,0,0,logical,1
+extraDistr,ppareto,4,0,0,logical,1
+extraDistr,ppower,-1,0,0,double[],1
+extraDistr,ppower,0,0,0,double[],1
+extraDistr,ppower,1,0,0,double,1
+extraDistr,ppower,2,0,0,double,1
+extraDistr,ppower,3,0,0,logical,1
+extraDistr,ppower,4,0,0,logical,1
+extraDistr,pprop,-1,0,0,double[],1
+extraDistr,pprop,0,0,0,double[],1
+extraDistr,pprop,1,0,0,double,1
+extraDistr,pprop,2,0,0,double,1
+extraDistr,pprop,3,0,0,double,1
+extraDistr,pprop,4,0,0,logical,1
+extraDistr,pprop,5,0,0,logical,1
+extraDistr,prayleigh,-1,0,0,double[],1
+extraDistr,prayleigh,0,0,0,double[],1
+extraDistr,prayleigh,1,0,0,double,1
+extraDistr,prayleigh,2,0,0,logical,1
+extraDistr,prayleigh,3,0,0,logical,1
+extraDistr,psgomp,-1,0,0,double[],1
+extraDistr,psgomp,0,0,0,double[],1
+extraDistr,psgomp,1,0,0,double,1
+extraDistr,psgomp,2,0,0,double,1
+extraDistr,psgomp,3,0,0,logical,1
+extraDistr,psgomp,4,0,0,logical,1
+extraDistr,pslash,-1,0,0,double[],1
+extraDistr,pslash,0,0,0,double[],1
+extraDistr,pslash,1,0,0,double,1
+extraDistr,pslash,2,0,0,double,1
+extraDistr,pslash,3,0,0,logical,1
+extraDistr,pslash,4,0,0,logical,1
+extraDistr,ptbinom,-1,0,0,double[],1
+extraDistr,ptbinom,0,0,0,double[],1
+extraDistr,ptbinom,1,0,0,double,1
+extraDistr,ptbinom,2,0,0,double,1
+extraDistr,ptbinom,3,0,0,double,1
+extraDistr,ptbinom,4,0,0,double,1
+extraDistr,ptbinom,5,0,0,logical,1
+extraDistr,ptbinom,6,0,0,logical,1
+extraDistr,ptnorm,-1,0,0,double[],1
+extraDistr,ptnorm,0,0,0,double[],1
+extraDistr,ptnorm,1,0,0,double,1
+extraDistr,ptnorm,2,0,0,double,1
+extraDistr,ptnorm,3,0,0,double,1
+extraDistr,ptnorm,4,0,0,double,1
+extraDistr,ptnorm,5,0,0,logical,1
+extraDistr,ptnorm,6,0,0,logical,1
+extraDistr,ptpois,-1,0,0,double[],1
+extraDistr,ptpois,0,0,0,double[],1
+extraDistr,ptpois,1,0,0,double,1
+extraDistr,ptpois,2,0,0,double,1
+extraDistr,ptpois,3,0,0,double,1
+extraDistr,ptpois,4,0,0,logical,1
+extraDistr,ptpois,5,0,0,logical,1
+extraDistr,ptriang,-1,0,0,double[],1
+extraDistr,ptriang,0,0,0,double[],1
+extraDistr,ptriang,1,0,0,double,1
+extraDistr,ptriang,2,0,0,double,1
+extraDistr,ptriang,3,0,0,double,1
+extraDistr,ptriang,4,0,0,logical,1
+extraDistr,ptriang,5,0,0,logical,1
+extraDistr,pwald,-1,0,0,double[],1
+extraDistr,pwald,0,0,0,double[],1
+extraDistr,pwald,1,0,0,double,1
+extraDistr,pwald,2,0,0,double,1
+extraDistr,pwald,3,0,0,logical,1
+extraDistr,pwald,4,0,0,logical,1
+extraDistr,pzib,-1,0,0,double[],1
+extraDistr,pzib,0,0,0,double[],1
+extraDistr,pzib,1,0,0,double,1
+extraDistr,pzib,2,0,0,double,1
+extraDistr,pzib,3,0,0,double,1
+extraDistr,pzib,4,0,0,logical,1
+extraDistr,pzib,5,0,0,logical,1
+extraDistr,pzinb,-1,0,0,double[],1
+extraDistr,pzinb,0,0,0,double[],1
+extraDistr,pzinb,1,0,0,double,1
+extraDistr,pzinb,2,0,0,double,1
+extraDistr,pzinb,3,0,0,double,1
+extraDistr,pzinb,4,0,0,logical,1
+extraDistr,pzinb,5,0,0,logical,1
+extraDistr,pzip,-1,0,0,double[],1
+extraDistr,pzip,0,0,0,double[],1
+extraDistr,pzip,1,0,0,double,1
+extraDistr,pzip,2,0,0,double,1
+extraDistr,pzip,3,0,0,logical,1
+extraDistr,pzip,4,0,0,logical,1
+extraDistr,qcat,-1,0,0,double[],1
+extraDistr,qcat,0,0,0,double[],1
+extraDistr,qcat,1,0,0,class<`matrix`>,1
+extraDistr,qcat,2,0,0,logical,1
+extraDistr,qcat,3,0,0,logical,1
+extraDistr,qcat,4,0,0,any,1
+extraDistr,qtbinom,-1,0,0,double[],1
+extraDistr,qtbinom,0,0,0,double[],1
+extraDistr,qtbinom,1,0,0,double,1
+extraDistr,qtbinom,2,0,0,double,1
+extraDistr,qtbinom,3,0,0,double,1
+extraDistr,qtbinom,4,0,0,double,1
+extraDistr,qtbinom,5,0,0,logical,1
+extraDistr,qtbinom,6,0,0,logical,1
+extraDistr,qtlambda,-1,0,0,double[],1
+extraDistr,qtlambda,0,0,0,double[],1
+extraDistr,qtlambda,1,0,0,double,1
+extraDistr,qtlambda,2,0,0,logical,1
+extraDistr,qtlambda,3,0,0,logical,1
+extraDistr,qtpois,-1,0,0,double[],1
+extraDistr,qtpois,0,0,0,double[],1
+extraDistr,qtpois,1,0,0,double,1
+extraDistr,qtpois,2,0,0,double,1
+extraDistr,qtpois,3,0,0,double,1
+extraDistr,qtpois,4,0,0,logical,1
+extraDistr,qtpois,5,0,0,logical,1
+extraDistr,rbbinom,-1,0,0,double[],1
+extraDistr,rbbinom,0,0,0,double,1
+extraDistr,rbbinom,1,0,0,double,1
+extraDistr,rbbinom,2,0,0,double,1
+extraDistr,rbbinom,3,0,0,double,1
+extraDistr,rbern,-1,0,0,double[],1
+extraDistr,rbern,0,0,0,double,1
+extraDistr,rbern,1,0,0,double,1
+extraDistr,rbetapr,-1,0,0,double[],1
+extraDistr,rbetapr,0,0,0,double,1
+extraDistr,rbetapr,1,0,0,double,1
+extraDistr,rbetapr,2,0,0,double,1
+extraDistr,rbetapr,3,0,0,double,1
+extraDistr,rbhatt,-1,0,0,double[],1
+extraDistr,rbhatt,0,0,0,double,1
+extraDistr,rbhatt,1,0,0,double,1
+extraDistr,rbhatt,2,0,0,double,1
+extraDistr,rbhatt,3,0,0,double,1
+extraDistr,rbnbinom,-1,0,0,double[],1
+extraDistr,rbnbinom,0,0,0,double,1
+extraDistr,rbnbinom,1,0,0,double,1
+extraDistr,rbnbinom,2,0,0,double,1
+extraDistr,rbnbinom,3,0,0,double,1
+extraDistr,rbvpois,-1,0,0,class<`matrix`>,1
+extraDistr,rbvpois,0,0,0,double,1
+extraDistr,rbvpois,1,0,0,double,1
+extraDistr,rbvpois,2,0,0,double,1
+extraDistr,rbvpois,3,0,0,double,1
+extraDistr,rcat,-1,0,0,double[],1
+extraDistr,rcat,0,0,0,double,1
+extraDistr,rcat,1,0,0,class<`matrix`>,1
+extraDistr,rcat,1,0,1,double[],1
+extraDistr,rcat,2,0,0,any,1
+extraDistr,rdgamma,-1,0,0,double[],1
+extraDistr,rdgamma,0,0,0,double,1
+extraDistr,rdgamma,1,0,0,double,1
+extraDistr,rdgamma,2,0,0,double,1
+extraDistr,rdgamma,3,0,0,double,1
+extraDistr,rdirichlet,-1,0,0,class<`matrix`>,1
+extraDistr,rdirichlet,0,0,0,double,1
+extraDistr,rdirichlet,1,0,0,class<`matrix`>,1
+extraDistr,rdirichlet,1,0,1,double[],1
+extraDistr,rdlaplace,-1,0,0,double[],1
+extraDistr,rdlaplace,0,0,0,double,1
+extraDistr,rdlaplace,1,0,0,double,1
+extraDistr,rdlaplace,2,0,0,double,1
+extraDistr,rdnorm,-1,0,0,double[],1
+extraDistr,rdnorm,0,0,0,double,1
+extraDistr,rdnorm,1,0,0,double,1
+extraDistr,rdnorm,2,0,0,double,1
+extraDistr,rdunif,-1,0,0,double[],1
+extraDistr,rdunif,0,0,0,double,1
+extraDistr,rdunif,1,0,0,double,1
+extraDistr,rdunif,2,0,0,double,1
+extraDistr,rdweibull,-1,0,0,double[],1
+extraDistr,rdweibull,0,0,0,double,1
+extraDistr,rdweibull,1,0,0,double,1
+extraDistr,rdweibull,2,0,0,double,1
+extraDistr,rfatigue,-1,0,0,double[],1
+extraDistr,rfatigue,0,0,0,double,1
+extraDistr,rfatigue,1,0,0,double,1
+extraDistr,rfatigue,2,0,0,double,1
+extraDistr,rfatigue,3,0,0,double,1
+extraDistr,rfrechet,-1,0,0,double[],1
+extraDistr,rfrechet,0,0,0,double,1
+extraDistr,rfrechet,1,0,0,double,1
+extraDistr,rfrechet,2,0,0,double,1
+extraDistr,rfrechet,3,0,0,double,1
+extraDistr,rgev,-1,0,0,double[],1
+extraDistr,rgev,0,0,0,double,1
+extraDistr,rgev,1,0,0,double,1
+extraDistr,rgev,2,0,0,double,1
+extraDistr,rgev,3,0,0,double,1
+extraDistr,rgompertz,-1,0,0,double[],1
+extraDistr,rgompertz,0,0,0,double,1
+extraDistr,rgompertz,1,0,0,double,1
+extraDistr,rgompertz,2,0,0,double,1
+extraDistr,rgpd,-1,0,0,double[],1
+extraDistr,rgpd,0,0,0,double,1
+extraDistr,rgpd,1,0,0,double,1
+extraDistr,rgpd,2,0,0,double,1
+extraDistr,rgpd,3,0,0,double,1
+extraDistr,rgpois,-1,0,0,double[],1
+extraDistr,rgpois,0,0,0,double,1
+extraDistr,rgpois,1,0,0,double,1
+extraDistr,rgpois,2,0,0,double,1
+extraDistr,rgpois,3,0,0,double,1
+extraDistr,rgumbel,-1,0,0,double[],1
+extraDistr,rgumbel,0,0,0,double,1
+extraDistr,rgumbel,1,0,0,double,1
+extraDistr,rgumbel,2,0,0,double,1
+extraDistr,rhcauchy,-1,0,0,double[],1
+extraDistr,rhcauchy,0,0,0,double,1
+extraDistr,rhcauchy,1,0,0,double,1
+extraDistr,rhnorm,-1,0,0,double[],1
+extraDistr,rhnorm,0,0,0,double,1
+extraDistr,rhnorm,1,0,0,double,1
+extraDistr,rht,-1,0,0,double[],1
+extraDistr,rht,0,0,0,double,1
+extraDistr,rht,1,0,0,double,1
+extraDistr,rht,2,0,0,double,1
+extraDistr,rhuber,-1,0,0,double[],1
+extraDistr,rhuber,0,0,0,double,1
+extraDistr,rhuber,1,0,0,double,1
+extraDistr,rhuber,2,0,0,double,1
+extraDistr,rhuber,3,0,0,double,1
+extraDistr,rinvchisq,-1,0,0,double[],1
+extraDistr,rinvchisq,0,0,0,double,1
+extraDistr,rinvchisq,1,0,0,double,1
+extraDistr,rinvchisq,2,0,0,any,1
+extraDistr,rinvgamma,-1,0,0,double[],1
+extraDistr,rinvgamma,0,0,0,double,1
+extraDistr,rinvgamma,1,0,0,double,1
+extraDistr,rinvgamma,2,0,0,double,1
+extraDistr,rkumar,-1,0,0,double[],1
+extraDistr,rkumar,0,0,0,double,1
+extraDistr,rkumar,1,0,0,double,1
+extraDistr,rkumar,2,0,0,double,1
+extraDistr,rlaplace,-1,0,0,double[],1
+extraDistr,rlaplace,0,0,0,double,1
+extraDistr,rlaplace,1,0,0,double,1
+extraDistr,rlaplace,2,0,0,double,1
+extraDistr,rlgser,-1,0,0,double[],1
+extraDistr,rlgser,0,0,0,double,1
+extraDistr,rlgser,1,0,0,double,1
+extraDistr,rlomax,-1,0,0,double[],1
+extraDistr,rlomax,0,0,0,double,1
+extraDistr,rlomax,1,0,0,double,1
+extraDistr,rlomax,2,0,0,double,1
+extraDistr,rlst,-1,0,0,double[],1
+extraDistr,rlst,0,0,0,double,1
+extraDistr,rlst,1,0,0,double,1
+extraDistr,rlst,2,0,0,double,1
+extraDistr,rlst,3,0,0,double,1
+extraDistr,rmixnorm,-1,0,0,double[],1
+extraDistr,rmixnorm,0,0,0,double,1
+extraDistr,rmixnorm,1,0,0,double[],1
+extraDistr,rmixnorm,2,0,0,double[],1
+extraDistr,rmixnorm,3,0,0,double[],1
+extraDistr,rmixpois,-1,0,0,double[],1
+extraDistr,rmixpois,0,0,0,double,1
+extraDistr,rmixpois,1,0,0,double[],1
+extraDistr,rmixpois,2,0,0,double[],1
+extraDistr,rmnom,-1,0,0,class<`matrix`>,1
+extraDistr,rmnom,0,0,0,double,1
+extraDistr,rmnom,1,0,0,double,1
+extraDistr,rmnom,2,0,0,double[],1
+extraDistr,rmvhyper,-1,0,0,class<`matrix`>,1
+extraDistr,rmvhyper,0,0,0,double,1
+extraDistr,rmvhyper,1,0,0,double[],1
+extraDistr,rmvhyper,2,0,0,double,1
+extraDistr,rnhyper,-1,0,0,double[],1
+extraDistr,rnhyper,0,0,0,double,1
+extraDistr,rnhyper,1,0,0,double,1
+extraDistr,rnhyper,2,0,0,double,1
+extraDistr,rnhyper,3,0,0,double,1
+extraDistr,rnsbeta,-1,0,0,double[],1
+extraDistr,rnsbeta,0,0,0,double,1
+extraDistr,rnsbeta,1,0,0,double,1
+extraDistr,rnsbeta,2,0,0,double,1
+extraDistr,rnsbeta,3,0,0,double,1
+extraDistr,rnsbeta,4,0,0,double,1
+extraDistr,rpareto,-1,0,0,double[],1
+extraDistr,rpareto,0,0,0,double,1
+extraDistr,rpareto,1,0,0,double,1
+extraDistr,rpareto,2,0,0,double,1
+extraDistr,rpower,-1,0,0,double[],1
+extraDistr,rpower,0,0,0,double,1
+extraDistr,rpower,1,0,0,double,1
+extraDistr,rpower,2,0,0,double,1
+extraDistr,rprop,-1,0,0,double[],1
+extraDistr,rprop,0,0,0,double,1
+extraDistr,rprop,1,0,0,double,1
+extraDistr,rprop,2,0,0,double,1
+extraDistr,rprop,3,0,0,double,1
+extraDistr,rrayleigh,-1,0,0,double[],1
+extraDistr,rrayleigh,0,0,0,double,1
+extraDistr,rrayleigh,1,0,0,double,1
+extraDistr,rsgomp,-1,0,0,double[],1
+extraDistr,rsgomp,0,0,0,double,1
+extraDistr,rsgomp,1,0,0,double,1
+extraDistr,rsgomp,2,0,0,double,1
+extraDistr,rskellam,-1,0,0,double[],1
+extraDistr,rskellam,0,0,0,double,1
+extraDistr,rskellam,1,0,0,double,1
+extraDistr,rskellam,2,0,0,double,1
+extraDistr,rslash,-1,0,0,double[],1
+extraDistr,rslash,0,0,0,double,1
+extraDistr,rslash,1,0,0,double,1
+extraDistr,rslash,2,0,0,double,1
+extraDistr,rtbinom,-1,0,0,double[],1
+extraDistr,rtbinom,0,0,0,double,1
+extraDistr,rtbinom,1,0,0,double,1
+extraDistr,rtbinom,2,0,0,double,1
+extraDistr,rtbinom,3,0,0,double,1
+extraDistr,rtbinom,4,0,0,double,1
+extraDistr,rtlambda,-1,0,0,double[],1
+extraDistr,rtlambda,0,0,0,double,1
+extraDistr,rtlambda,1,0,0,double,1
+extraDistr,rtnorm,-1,0,0,double[],1
+extraDistr,rtnorm,0,0,0,double,1
+extraDistr,rtnorm,1,0,0,double,1
+extraDistr,rtnorm,2,0,0,double,1
+extraDistr,rtnorm,3,0,0,double,1
+extraDistr,rtnorm,4,0,0,double,1
+extraDistr,rtpois,-1,0,0,double[],1
+extraDistr,rtpois,0,0,0,double,1
+extraDistr,rtpois,1,0,0,double,1
+extraDistr,rtpois,2,0,0,double,1
+extraDistr,rtpois,3,0,0,double,1
+extraDistr,rtriang,-1,0,0,double[],1
+extraDistr,rtriang,0,0,0,double,1
+extraDistr,rtriang,1,0,0,double,1
+extraDistr,rtriang,2,0,0,double,1
+extraDistr,rtriang,3,0,0,double,1
+extraDistr,rwald,-1,0,0,double[],1
+extraDistr,rwald,0,0,0,double,1
+extraDistr,rwald,1,0,0,double,1
+extraDistr,rwald,2,0,0,double,1
+extraDistr,rzib,-1,0,0,double[],1
+extraDistr,rzib,0,0,0,double,1
+extraDistr,rzib,1,0,0,double,1
+extraDistr,rzib,2,0,0,double,1
+extraDistr,rzib,3,0,0,double,1
+extraDistr,rzinb,-1,0,0,double[],1
+extraDistr,rzinb,0,0,0,double,1
+extraDistr,rzinb,1,0,0,double,1
+extraDistr,rzinb,2,0,0,double,1
+extraDistr,rzinb,3,0,0,double,1
+extraDistr,rzip,-1,0,0,double[],1
+extraDistr,rzip,0,0,0,double,1
+extraDistr,rzip,1,0,0,double,1
+extraDistr,rzip,2,0,0,double,1
+fOptions,BAWAmericanApproxOption,-1,0,0,class<`fOPTION`>,1
+fOptions,BAWAmericanApproxOption,0,0,0,character,1
+fOptions,BAWAmericanApproxOption,1,0,0,double,1
+fOptions,BAWAmericanApproxOption,2,0,0,double,1
+fOptions,BAWAmericanApproxOption,3,0,0,double,1
+fOptions,BAWAmericanApproxOption,4,0,0,double,1
+fOptions,BAWAmericanApproxOption,5,0,0,double,1
+fOptions,BAWAmericanApproxOption,6,0,0,double,1
+fOptions,BAWAmericanApproxOption,7,0,0,null,1
+fOptions,BAWAmericanApproxOption,8,0,0,null,1
+fOptions,.BAWAmPutApproxOption,-1,0,0,double,1
+fOptions,.BAWAmPutApproxOption,0,0,0,double,1
+fOptions,.BAWAmPutApproxOption,1,0,0,double,1
+fOptions,.BAWAmPutApproxOption,2,0,0,double,1
+fOptions,.BAWAmPutApproxOption,3,0,0,double,1
+fOptions,.BAWAmPutApproxOption,4,0,0,double,1
+fOptions,.BAWAmPutApproxOption,5,0,0,double,1
+fOptions,.bawKp,-1,0,0,double,1
+fOptions,.bawKp,0,0,0,double,1
+fOptions,.bawKp,1,0,0,double,1
+fOptions,.bawKp,2,0,0,double,1
+fOptions,.bawKp,3,0,0,double,1
+fOptions,.bawKp,4,0,0,double,1
+fOptions,BinomialTreeOption,-1,0,0,class<`matrix`>,1
+fOptions,BinomialTreeOption,0,0,0,character,1
+fOptions,BinomialTreeOption,1,0,0,double,1
+fOptions,BinomialTreeOption,2,0,0,double,1
+fOptions,BinomialTreeOption,3,0,0,double,1
+fOptions,BinomialTreeOption,4,0,0,double,1
+fOptions,BinomialTreeOption,5,0,0,double,1
+fOptions,BinomialTreeOption,6,0,0,double,1
+fOptions,BinomialTreeOption,7,0,0,double,1
+fOptions,BinomialTreeOption,8,0,0,null,1
+fOptions,BinomialTreeOption,9,0,0,null,1
+fOptions,BinomialTreePlot,-1,0,0,null,1
+fOptions,BinomialTreePlot,0,0,0,class<`matrix`>,1
+fOptions,BinomialTreePlot,1,0,0,double,1
+fOptions,BinomialTreePlot,2,0,0,double,1
+fOptions,BinomialTreePlot,3,0,0,double,1
+fOptions,BinomialTreePlot,4,0,0,double,1
+fOptions,BinomialTreePlot,5,0,0,...,1
+fOptions,Black76Option,-1,0,0,class<`fOPTION`>,1
+fOptions,Black76Option,0,0,0,character,1
+fOptions,Black76Option,1,0,0,double,1
+fOptions,Black76Option,2,0,0,double,1
+fOptions,Black76Option,3,0,0,double,1
+fOptions,Black76Option,4,0,0,double,1
+fOptions,Black76Option,5,0,0,double,1
+fOptions,Black76Option,6,0,0,null,1
+fOptions,Black76Option,7,0,0,null,1
+fOptions,BSAmericanApproxOption,-1,0,0,class<`fOPTION`>,1
+fOptions,BSAmericanApproxOption,0,0,0,character,1
+fOptions,BSAmericanApproxOption,1,0,0,double,1
+fOptions,BSAmericanApproxOption,2,0,0,double,1
+fOptions,BSAmericanApproxOption,3,0,0,double,1
+fOptions,BSAmericanApproxOption,4,0,0,double,1
+fOptions,BSAmericanApproxOption,5,0,0,double,1
+fOptions,BSAmericanApproxOption,6,0,0,double,1
+fOptions,BSAmericanApproxOption,7,0,0,null,1
+fOptions,BSAmericanApproxOption,8,0,0,null,1
+fOptions,.BSAmericanCallApprox,-1,0,0,list<double>,1
+fOptions,.BSAmericanCallApprox,0,0,0,double,1
+fOptions,.BSAmericanCallApprox,1,0,0,double,1
+fOptions,.BSAmericanCallApprox,2,0,0,double,1
+fOptions,.BSAmericanCallApprox,3,0,0,double,1
+fOptions,.BSAmericanCallApprox,4,0,0,double,1
+fOptions,.BSAmericanCallApprox,5,0,0,double,1
+fOptions,.bsPhi,-1,0,0,double,1
+fOptions,.bsPhi,0,0,0,double,1
+fOptions,.bsPhi,1,0,0,double,1
+fOptions,.bsPhi,2,0,0,double,1
+fOptions,.bsPhi,3,0,0,double,1
+fOptions,.bsPhi,4,0,0,double,1
+fOptions,.bsPhi,5,0,0,double,1
+fOptions,.bsPhi,6,0,0,double,1
+fOptions,.bsPhi,7,0,0,double,1
+fOptions,CBND,-1,0,0,double,1
+fOptions,CBND,0,0,0,double,1
+fOptions,CBND,1,0,0,double,1
+fOptions,CBND,2,0,0,double,1
+fOptions,CND,-1,0,0,double,1
+fOptions,CND,0,0,0,double,1
+fOptions,CRRBinomialTreeOption,-1,0,0,class<`fOPTION`>,1
+fOptions,CRRBinomialTreeOption,0,0,0,character,1
+fOptions,CRRBinomialTreeOption,1,0,0,double,1
+fOptions,CRRBinomialTreeOption,2,0,0,double,1
+fOptions,CRRBinomialTreeOption,3,0,0,double,1
+fOptions,CRRBinomialTreeOption,4,0,0,double,1
+fOptions,CRRBinomialTreeOption,5,0,0,double,1
+fOptions,CRRBinomialTreeOption,6,0,0,double,1
+fOptions,CRRBinomialTreeOption,7,0,0,double,1
+fOptions,CRRBinomialTreeOption,8,0,0,null,1
+fOptions,CRRBinomialTreeOption,9,0,0,null,1
+fOptions,.fHN,-1,0,0,complex[],1
+fOptions,.fHN,0,0,0,double[],1
+fOptions,.fHN,1,0,0,double,1
+fOptions,.fHN,2,0,0,list<double>,1
+fOptions,.fHN,3,0,0,double,1
+fOptions,.fHN,4,0,0,double,1
+fOptions,.fHN,5,0,0,double,1
+fOptions,.fHN,6,0,0,double,1
+fOptions,GBSCharacteristics,-1,0,0,list<double>,1
+fOptions,GBSCharacteristics,0,0,0,character,1
+fOptions,GBSCharacteristics,1,0,0,double,1
+fOptions,GBSCharacteristics,2,0,0,double,1
+fOptions,GBSCharacteristics,3,0,0,double,1
+fOptions,GBSCharacteristics,4,0,0,double,1
+fOptions,GBSCharacteristics,5,0,0,double,1
+fOptions,GBSCharacteristics,6,0,0,double,1
+fOptions,.GBSDelta,-1,0,0,double,1
+fOptions,.GBSDelta,0,0,0,character,1
+fOptions,.GBSDelta,1,0,0,double,1
+fOptions,.GBSDelta,2,0,0,double,1
+fOptions,.GBSDelta,3,0,0,double,1
+fOptions,.GBSDelta,4,0,0,double,1
+fOptions,.GBSDelta,5,0,0,double,1
+fOptions,.GBSDelta,6,0,0,double,1
+fOptions,.GBSGamma,-1,0,0,double,1
+fOptions,.GBSGamma,0,0,0,any,1
+fOptions,.GBSGamma,1,0,0,double,1
+fOptions,.GBSGamma,2,0,0,double,1
+fOptions,.GBSGamma,3,0,0,double,1
+fOptions,.GBSGamma,4,0,0,double,1
+fOptions,.GBSGamma,5,0,0,double,1
+fOptions,.GBSGamma,6,0,0,double,1
+fOptions,GBSGreeks,-1,0,0,double,1
+fOptions,GBSGreeks,0,0,0,character,1
+fOptions,GBSGreeks,1,0,0,character,1
+fOptions,GBSGreeks,2,0,0,double,1
+fOptions,GBSGreeks,3,0,0,double,1
+fOptions,GBSGreeks,4,0,0,double,1
+fOptions,GBSGreeks,5,0,0,double,1
+fOptions,GBSGreeks,6,0,0,double,1
+fOptions,GBSGreeks,7,0,0,double,1
+fOptions,.GBSLambda,-1,0,0,double,1
+fOptions,.GBSLambda,0,0,0,character,1
+fOptions,.GBSLambda,1,0,0,double,1
+fOptions,.GBSLambda,2,0,0,double,1
+fOptions,.GBSLambda,3,0,0,double,1
+fOptions,.GBSLambda,4,0,0,double,1
+fOptions,.GBSLambda,5,0,0,double,1
+fOptions,.GBSLambda,6,0,0,double,1
+fOptions,GBSOption,-1,0,0,class<`fOPTION`>,1
+fOptions,GBSOption,0,0,0,character,1
+fOptions,GBSOption,1,0,0,double,1
+fOptions,GBSOption,2,0,0,double,1
+fOptions,GBSOption,3,0,0,double,1
+fOptions,GBSOption,4,0,0,double,1
+fOptions,GBSOption,5,0,0,double,1
+fOptions,GBSOption,6,0,0,double,1
+fOptions,GBSOption,7,0,0,null,1
+fOptions,GBSOption,8,0,0,null,1
+fOptions,.GBSRho,-1,0,0,double,1
+fOptions,.GBSRho,0,0,0,character,1
+fOptions,.GBSRho,1,0,0,double,1
+fOptions,.GBSRho,2,0,0,double,1
+fOptions,.GBSRho,3,0,0,double,1
+fOptions,.GBSRho,4,0,0,double,1
+fOptions,.GBSRho,5,0,0,double,1
+fOptions,.GBSRho,6,0,0,double,1
+fOptions,.GBSTheta,-1,0,0,double,1
+fOptions,.GBSTheta,0,0,0,character,1
+fOptions,.GBSTheta,1,0,0,double,1
+fOptions,.GBSTheta,2,0,0,double,1
+fOptions,.GBSTheta,3,0,0,double,1
+fOptions,.GBSTheta,4,0,0,double,1
+fOptions,.GBSTheta,5,0,0,double,1
+fOptions,.GBSTheta,6,0,0,double,1
+fOptions,.GBSVega,-1,0,0,double,1
+fOptions,.GBSVega,0,0,0,any,1
+fOptions,.GBSVega,1,0,0,double,1
+fOptions,.GBSVega,2,0,0,double,1
+fOptions,.GBSVega,3,0,0,double,1
+fOptions,.GBSVega,4,0,0,double,1
+fOptions,.GBSVega,5,0,0,double,1
+fOptions,.GBSVega,6,0,0,double,1
+fOptions,.getfOptionsEnv,-1,0,0,list<double[]>,1
+fOptions,.getfOptionsEnv,0,0,0,character,1
+fOptions,.getfOptionsEnv,1,0,0,character,1
+fOptions,hngarchFit,-1,0,0,class<`hngarch`>,1
+fOptions,hngarchFit,0,0,0,double[],1
+fOptions,hngarchFit,1,0,0,list<double>,1
+fOptions,hngarchFit,2,0,0,logical,1
+fOptions,hngarchFit,3,0,0,logical,1
+fOptions,hngarchFit,4,0,0,null,1
+fOptions,hngarchFit,5,0,0,null,1
+fOptions,hngarchFit,6,0,0,...,1
+fOptions,hngarchSim,-1,0,0,double[],1
+fOptions,hngarchSim,0,0,0,list<double>,1
+fOptions,hngarchSim,1,0,0,double,1
+fOptions,hngarchSim,2,0,0,null,1
+fOptions,hngarchSim,3,0,0,double,1
+fOptions,hngarchSim,4,0,0,null,1
+fOptions,hngarchSim,5,0,0,class<`function`>,1
+fOptions,hngarchSim,6,0,0,...,1
+fOptions,hngarchStats,-1,0,0,list<double>,1
+fOptions,hngarchStats,0,0,0,list<double>,1
+fOptions,HNGGreeks,-1,0,0,double,1
+fOptions,HNGGreeks,0,0,0,character,1
+fOptions,HNGGreeks,1,0,0,character,1
+fOptions,HNGGreeks,2,0,0,list<double>,1
+fOptions,HNGGreeks,3,0,0,double,1
+fOptions,HNGGreeks,4,0,0,double,1
+fOptions,HNGGreeks,5,0,0,double,1
+fOptions,HNGGreeks,6,0,0,double,1
+fOptions,HNGOption,-1,0,0,class<`option`>,1
+fOptions,HNGOption,0,0,0,character,1
+fOptions,HNGOption,1,0,0,list<double>,1
+fOptions,HNGOption,2,0,0,double,1
+fOptions,HNGOption,3,0,0,double,1
+fOptions,HNGOption,4,0,0,double,1
+fOptions,HNGOption,5,0,0,double,1
+fOptions,JRBinomialTreeOption,-1,0,0,class<`fOPTION`>,1
+fOptions,JRBinomialTreeOption,0,0,0,character,1
+fOptions,JRBinomialTreeOption,1,0,0,double,1
+fOptions,JRBinomialTreeOption,2,0,0,double,1
+fOptions,JRBinomialTreeOption,3,0,0,double,1
+fOptions,JRBinomialTreeOption,4,0,0,double,1
+fOptions,JRBinomialTreeOption,5,0,0,double,1
+fOptions,JRBinomialTreeOption,6,0,0,double,1
+fOptions,JRBinomialTreeOption,7,0,0,integer,1
+fOptions,JRBinomialTreeOption,8,0,0,null,1
+fOptions,JRBinomialTreeOption,9,0,0,null,1
+fOptions,.llhHNGarch,-1,0,0,double,1
+fOptions,.llhHNGarch,0,0,0,double[],1
+fOptions,.llhHNGarch,1,0,0,logical,1
+fOptions,.llhHNGarch,2,0,0,logical,1
+fOptions,.llhHNGarch,3,0,0,double,1
+fOptions,.llhHNGarch,4,0,0,double[],1
+fOptions,MiltersenSchwartzOption,-1,0,0,class<`fOPTION`>,1
+fOptions,MiltersenSchwartzOption,0,0,0,character,1
+fOptions,MiltersenSchwartzOption,1,0,0,double,1
+fOptions,MiltersenSchwartzOption,2,0,0,double,1
+fOptions,MiltersenSchwartzOption,3,0,0,double,1
+fOptions,MiltersenSchwartzOption,4,0,0,double,1
+fOptions,MiltersenSchwartzOption,5,0,0,double,1
+fOptions,MiltersenSchwartzOption,6,0,0,double,1
+fOptions,MiltersenSchwartzOption,7,0,0,double,1
+fOptions,MiltersenSchwartzOption,8,0,0,double,1
+fOptions,MiltersenSchwartzOption,9,0,0,double,1
+fOptions,MiltersenSchwartzOption,10,0,0,double,1
+fOptions,MiltersenSchwartzOption,11,0,0,double,1
+fOptions,MiltersenSchwartzOption,12,0,0,double,1
+fOptions,MiltersenSchwartzOption,13,0,0,double,1
+fOptions,MiltersenSchwartzOption,14,0,0,null,1
+fOptions,MiltersenSchwartzOption,15,0,0,null,1
+fOptions,MonteCarloOption,-1,0,0,double[],1
+fOptions,MonteCarloOption,0,0,0,double,1
+fOptions,MonteCarloOption,1,0,0,double,1
+fOptions,MonteCarloOption,2,0,0,double,1
+fOptions,MonteCarloOption,3,0,0,double,1
+fOptions,MonteCarloOption,4,0,0,logical,1
+fOptions,MonteCarloOption,5,0,0,class<`function`>,1
+fOptions,MonteCarloOption,6,0,0,class<`function`>,1
+fOptions,MonteCarloOption,7,0,0,class<`function`>,1
+fOptions,MonteCarloOption,8,0,0,logical,1
+fOptions,MonteCarloOption,9,0,0,logical,1
+fOptions,MonteCarloOption,10,0,0,logical,1
+fOptions,MonteCarloOption,11,0,0,...,1
+fOptions,NDF,-1,0,0,double,1
+fOptions,NDF,0,0,0,double,1
+fOptions,rnorm.halton,-1,0,0,class<`matrix`>,1
+fOptions,rnorm.halton,0,0,0,double,1
+fOptions,rnorm.halton,1,0,0,double,1
+fOptions,rnorm.halton,2,0,0,logical,1
+fOptions,rnorm.pseudo,-1,0,0,class<`matrix`>,1
+fOptions,rnorm.pseudo,0,0,0,double,1
+fOptions,rnorm.pseudo,1,0,0,double,1
+fOptions,rnorm.pseudo,2,0,0,logical,1
+fOptions,rnorm.sobol,-1,0,0,class<`matrix`>,1
+fOptions,rnorm.sobol,0,0,0,double,1
+fOptions,rnorm.sobol,1,0,0,double,1
+fOptions,rnorm.sobol,2,0,0,logical,1
+fOptions,rnorm.sobol,3,0,0,double,1
+fOptions,rnorm.sobol,4,0,0,double,1
+fOptions,RollGeskeWhaleyOption,-1,0,0,class<`fOPTION`>,1
+fOptions,RollGeskeWhaleyOption,0,0,0,double,1
+fOptions,RollGeskeWhaleyOption,1,0,0,double,1
+fOptions,RollGeskeWhaleyOption,2,0,0,double,1
+fOptions,RollGeskeWhaleyOption,3,0,0,double,1
+fOptions,RollGeskeWhaleyOption,4,0,0,double,1
+fOptions,RollGeskeWhaleyOption,5,0,0,double,1
+fOptions,RollGeskeWhaleyOption,6,0,0,double,1
+fOptions,RollGeskeWhaleyOption,7,0,0,null,1
+fOptions,RollGeskeWhaleyOption,8,0,0,null,1
+fOptions,runif.halton,-1,0,0,class<`matrix`>,1
+fOptions,runif.halton,0,0,0,double,1
+fOptions,runif.halton,1,0,0,double,1
+fOptions,runif.halton,2,0,0,logical,1
+fOptions,runif.pseudo,-1,0,0,class<`matrix`>,1
+fOptions,runif.pseudo,0,0,0,double,1
+fOptions,runif.pseudo,1,0,0,double,1
+fOptions,runif.pseudo,2,0,0,null,1
+fOptions,runif.sobol,-1,0,0,class<`matrix`>,1
+fOptions,runif.sobol,0,0,0,double,1
+fOptions,runif.sobol,1,0,0,double,1
+fOptions,runif.sobol,2,0,0,logical,1
+fOptions,runif.sobol,3,0,0,double,1
+fOptions,runif.sobol,4,0,0,double,1
+fOptions,.setfOptionsEnv,-1,0,0,null,1
+fOptions,.setfOptionsEnv,0,0,0,...,1
+fOptions,summary.hngarch,-1,0,0,null,1
+fOptions,summary.hngarch,0,0,0,class<`hngarch`>,1
+fOptions,summary.hngarch,1,0,0,...,1
+fOptions,TIANBinomialTreeOption,-1,0,0,class<`fOPTION`>,1
+fOptions,TIANBinomialTreeOption,0,0,0,character,1
+fOptions,TIANBinomialTreeOption,1,0,0,double,1
+fOptions,TIANBinomialTreeOption,2,0,0,double,1
+fOptions,TIANBinomialTreeOption,3,0,0,double,1
+fOptions,TIANBinomialTreeOption,4,0,0,double,1
+fOptions,TIANBinomialTreeOption,5,0,0,double,1
+fOptions,TIANBinomialTreeOption,6,0,0,double,1
+fOptions,TIANBinomialTreeOption,7,0,0,integer,1
+fOptions,TIANBinomialTreeOption,8,0,0,null,1
+fOptions,TIANBinomialTreeOption,9,0,0,null,1
+fansi,check_assumptions,-1,0,0,logical,1
+fansi,fansi_lines,-1,0,0,character[],1
+fansi,fansi_lines,0,0,0,character[],1
+fansi,fansi_lines,1,0,0,double,1
+fansi,forder,-1,0,0,integer[],1
+fansi,forder,0,0,0,integer[],1
+fansi,has_ctl,-1,0,0,logical,1
+fansi,has_ctl,0,0,0,character,1
+fansi,has_ctl,1,0,0,character,1
+fansi,has_ctl,2,0,0,logical,1
+fansi,has_ctl,3,0,0,any,1
+fansi,has_sgr,-1,0,0,logical,1
+fansi,has_sgr,0,0,0,character,1
+fansi,has_sgr,1,0,0,logical,1
+fansi,html_code_block,-1,0,0,character,1
+fansi,html_code_block,0,0,0,character,1
+fansi,html_code_block,1,0,0,character,1
+fansi,html_esc,-1,0,0,character,1
+fansi,html_esc,0,0,0,character,1
+fansi,nchar_ctl,-1,0,0,integer,1
+fansi,nchar_ctl,0,0,0,character,1
+fansi,nchar_ctl,1,0,0,character,1
+fansi,nchar_ctl,2,0,0,logical,1
+fansi,nchar_ctl,3,0,0,null,1
+fansi,nchar_ctl,4,0,0,character[],1
+fansi,nchar_ctl,5,0,0,logical,1
+fansi,nchar_ctl,6,0,0,any,1
+fansi,nchar_sgr,-1,0,0,integer,1
+fansi,nchar_sgr,0,0,0,character,1
+fansi,nchar_sgr,1,0,0,character,1
+fansi,nchar_sgr,2,0,0,logical,1
+fansi,nchar_sgr,3,0,0,null,1
+fansi,nchar_sgr,4,0,0,logical,1
+fansi,nzchar_ctl,-1,0,0,logical,1
+fansi,nzchar_ctl,0,0,0,character,1
+fansi,nzchar_ctl,1,0,0,null,1
+fansi,nzchar_ctl,2,0,0,character,1
+fansi,nzchar_ctl,3,0,0,logical,1
+fansi,sgr_to_html,-1,0,0,character,1
+fansi,sgr_to_html,0,0,0,character,1
+fansi,sgr_to_html,1,0,0,logical,1
+fansi,sgr_to_html,2,0,0,character[],1
+fansi,strip_ctl,-1,0,0,character,1
+fansi,strip_ctl,0,0,0,character,1
+fansi,strip_ctl,1,0,0,character[],1
+fansi,strip_ctl,2,0,0,logical,1
+fansi,strip_ctl,3,0,0,any,1
+fansi,strip_sgr,-1,0,0,character,1
+fansi,strip_sgr,0,0,0,character,1
+fansi,strip_sgr,1,0,0,logical,1
+fansi,strsplit_ctl,-1,0,0,list<character[]>,1
+fansi,strsplit_ctl,0,0,0,character,1
+fansi,strsplit_ctl,1,0,0,character,1
+fansi,strsplit_ctl,2,0,0,logical,1
+fansi,strsplit_ctl,3,0,0,logical,1
+fansi,strsplit_ctl,4,0,0,logical,1
+fansi,strsplit_ctl,5,0,0,logical,1
+fansi,strsplit_ctl,6,0,0,character[],1
+fansi,strsplit_ctl,7,0,0,character[],1
+fansi,strsplit_sgr,-1,0,0,list<character[]>,1
+fansi,strsplit_sgr,0,0,0,character,1
+fansi,strsplit_sgr,1,0,0,character,1
+fansi,strsplit_sgr,2,0,0,logical,1
+fansi,strsplit_sgr,3,0,0,logical,1
+fansi,strsplit_sgr,4,0,0,logical,1
+fansi,strsplit_sgr,5,0,0,logical,1
+fansi,strsplit_sgr,6,0,0,character[],1
+fansi,strtrim_ctl,-1,0,0,character,1
+fansi,strtrim_ctl,0,0,0,character,1
+fansi,strtrim_ctl,1,0,0,double,1
+fansi,strtrim_ctl,2,0,0,logical,1
+fansi,strtrim_ctl,3,0,0,character,1
+fansi,strwrap2_ctl,-1,0,0,character[],1
+fansi,strwrap2_ctl,0,0,0,character[],1
+fansi,strwrap2_ctl,1,0,0,double,1
+fansi,strwrap2_ctl,2,0,0,double,1
+fansi,strwrap2_ctl,3,0,0,double,1
+fansi,strwrap2_ctl,4,0,0,character,1
+fansi,strwrap2_ctl,5,0,0,logical,1
+fansi,strwrap2_ctl,6,0,0,character,1
+fansi,strwrap2_ctl,7,0,0,logical,1
+fansi,strwrap2_ctl,8,0,0,character,1
+fansi,strwrap2_ctl,9,0,0,logical,1
+fansi,strwrap2_ctl,10,0,0,logical,1
+fansi,strwrap2_ctl,11,0,0,double[],1
+fansi,strwrap2_ctl,12,0,0,logical,1
+fansi,strwrap2_ctl,13,0,0,character[],1
+fansi,strwrap2_ctl,14,0,0,character,1
+fansi,strwrap_ctl,-1,0,0,character[],1
+fansi,strwrap_ctl,0,0,0,character,1
+fansi,strwrap_ctl,1,0,0,double,1
+fansi,strwrap_ctl,2,0,0,double,1
+fansi,strwrap_ctl,3,0,0,double,1
+fansi,strwrap_ctl,4,0,0,character,1
+fansi,strwrap_ctl,5,0,0,logical,1
+fansi,strwrap_ctl,6,0,0,character,1
+fansi,strwrap_ctl,7,0,0,logical,1
+fansi,strwrap_ctl,8,0,0,character[],1
+fansi,strwrap_ctl,9,0,0,character,1
+fansi,substr2_ctl,-1,0,0,character,1
+fansi,substr2_ctl,0,0,0,character,1
+fansi,substr2_ctl,1,0,0,double,1
+fansi,substr2_ctl,2,0,0,double,1
+fansi,substr2_ctl,3,0,0,character,1
+fansi,substr2_ctl,4,0,0,character,1
+fansi,substr2_ctl,5,0,0,logical,1
+fansi,substr2_ctl,6,0,0,integer,1
+fansi,substr2_ctl,7,0,0,logical,1
+fansi,substr2_ctl,8,0,0,character[],1
+fansi,substr2_ctl,9,0,0,character[],1
+fansi,substr_ctl,-1,0,0,character,1
+fansi,substr_ctl,0,0,0,character,1
+fansi,substr_ctl,1,0,0,double,1
+fansi,substr_ctl,2,0,0,double,1
+fansi,substr_ctl,3,0,0,logical,1
+fansi,substr_ctl,4,0,0,character[],1
+fansi,substr_ctl,5,0,0,character[],1
+fansi,substr_ctl_internal,-1,0,0,character[],1
+fansi,substr_ctl_internal,0,0,0,character,1
+fansi,substr_ctl_internal,1,0,0,integer[],1
+fansi,substr_ctl_internal,2,0,0,integer[],1
+fansi,substr_ctl_internal,3,0,0,integer,1
+fansi,substr_ctl_internal,4,0,0,any,1
+fansi,substr_ctl_internal,5,0,0,logical,1
+fansi,substr_ctl_internal,6,0,0,any,1
+fansi,substr_ctl_internal,7,0,0,logical,1
+fansi,substr_ctl_internal,8,0,0,integer[],1
+fansi,substr_ctl_internal,9,0,0,logical,1
+fansi,substr_ctl_internal,10,0,0,logical,1
+fansi,substr_ctl_internal,11,0,0,integer,1
+fansi,substr_ctl_internal,12,0,0,integer[],1
+fansi,substr_sgr,-1,0,0,character,1
+fansi,substr_sgr,0,0,0,character,1
+fansi,substr_sgr,1,0,0,double,1
+fansi,substr_sgr,2,0,0,double,1
+fansi,substr_sgr,3,0,0,logical,1
+fansi,substr_sgr,4,0,0,character[],1
+fansi,tabs_as_spaces,-1,0,0,character,1
+fansi,tabs_as_spaces,0,0,0,character,1
+fansi,tabs_as_spaces,1,0,0,double[],1
+fansi,tabs_as_spaces,2,0,0,logical,1
+fansi,tabs_as_spaces,3,0,0,character,1
+fansi,term_cap_test,-1,0,0,character[],1
+fansi,unhandled_ctl,-1,0,0,class<`data.frame`>,1
+fansi,unhandled_ctl,0,0,0,character[],1
+fansi,unhandled_ctl,1,0,0,character[],1
+fastcluster,hclust,-1,0,0,class<`hclust`>,1
+fastcluster,hclust,0,0,0,class<`dist`>,1
+fastcluster,hclust,1,0,0,character,1
+fastcluster,hclust,2,0,0,class<`table`>,1
+fastcluster,hclust,2,0,1,null,1
+fastcluster,hclust.vector,-1,0,0,class<`hclust`>,1
+fastcluster,hclust.vector,0,0,0,class<`data.frame`>,1
+fastcluster,hclust.vector,0,0,1,class<`matrix`>,1
+fastcluster,hclust.vector,1,0,0,character,1
+fastcluster,hclust.vector,2,0,0,null,1
+fastcluster,hclust.vector,2,0,1,class<`table`>,1
+fastcluster,hclust.vector,3,0,0,character,1
+fastcluster,hclust.vector,4,0,0,null,1
+fasterize,fasterize,-1,0,0,class<`RasterLayer`>,1
+fasterize,fasterize,0,0,0,"class<`data.frame`, `sf`>",1
+fasterize,fasterize,1,0,0,class<`RasterLayer`>,1
+fasterize,fasterize,2,0,0,character,1
+fasterize,fasterize,3,0,0,character,1
+fasterize,fasterize,4,0,0,null,1
+fasterize,fasterize,5,0,0,null,1
+fdrtool,approximate.fit,-1,0,0,list<double>,1
+fdrtool,approximate.fit,-1,0,1,list<double | null>,1
+fdrtool,approximate.fit,0,0,0,double[],1
+fdrtool,approximate.fit,1,0,0,character,1
+fdrtool,approximate.fit,2,0,0,double[],1
+fdrtool,censored.fit,-1,0,0,class<`matrix`>,1
+fdrtool,censored.fit,0,0,0,double[],1
+fdrtool,censored.fit,1,0,0,double[],1
+fdrtool,censored.fit,2,0,0,character,1
+fdrtool,dcor0,-1,0,0,double[],1
+fdrtool,dcor0,0,0,0,double[],1
+fdrtool,dcor0,1,0,0,double,1
+fdrtool,dcor0,2,0,0,logical,1
+fdrtool,dhalfnorm,-1,0,0,double[],1
+fdrtool,dhalfnorm,0,0,0,double[],1
+fdrtool,dhalfnorm,1,0,0,double,1
+fdrtool,dhalfnorm,2,0,0,logical,1
+fdrtool,ecdf.pval,-1,0,0,"class<`ecdf`, `function`, `stepfun`>",1
+fdrtool,ecdf.pval,0,0,0,double[],1
+fdrtool,ecdf.pval,1,0,0,double,1
+fdrtool,fdrtool,-1,0,0,list<double[] | character | class<`matrix`>>,1
+fdrtool,fdrtool,0,0,0,double[],1
+fdrtool,fdrtool,1,0,0,character[],1
+fdrtool,fdrtool,2,0,0,logical,1
+fdrtool,fdrtool,3,0,0,logical,1
+fdrtool,fdrtool,4,0,0,logical,1
+fdrtool,fdrtool,5,0,0,character[],1
+fdrtool,fdrtool,6,0,0,double,1
+fdrtool,fitted.monoreg,-1,0,0,double[],1
+fdrtool,fitted.monoreg,0,0,0,class<`monoreg`>,1
+fdrtool,fitted.monoreg,1,0,0,...,1
+fdrtool,fndr.cutoff,-1,0,0,double,1
+fdrtool,fndr.cutoff,0,0,0,double[],1
+fdrtool,fndr.cutoff,1,0,0,character,1
+fdrtool,gcmlcm,-1,0,0,list<double[]>,1
+fdrtool,gcmlcm,0,0,0,double[],1
+fdrtool,gcmlcm,1,0,0,double[],1
+fdrtool,gcmlcm,2,0,0,character[],1
+fdrtool,get.nullmodel,-1,0,0,list<class<`function`>>,1
+fdrtool,get.nullmodel,-1,0,1,list<class<`function`> | null>,1
+fdrtool,get.nullmodel,0,0,0,character,1
+fdrtool,grenander,-1,0,0,class<`grenander`>,1
+fdrtool,grenander,0,0,0,"class<`ecdf`, `function`, `stepfun`>",1
+fdrtool,grenander,1,0,0,character[],1
+fdrtool,hc.score,-1,0,0,double[],1
+fdrtool,hc.score,0,0,0,double[],1
+fdrtool,hc.thresh,-1,0,0,double,1
+fdrtool,hc.thresh,0,0,0,double[],1
+fdrtool,hc.thresh,1,0,0,double,1
+fdrtool,hc.thresh,2,0,0,logical,1
+fdrtool,iqr.fit,-1,0,0,double,1
+fdrtool,iqr.fit,-1,0,1,null,1
+fdrtool,iqr.fit,0,0,0,double[],1
+fdrtool,iqr.fit,1,0,0,character,1
+fdrtool,monoreg,-1,0,0,class<`monoreg`>,1
+fdrtool,monoreg,0,0,0,double[],1
+fdrtool,monoreg,1,0,0,double[],1
+fdrtool,monoreg,1,0,1,null,1
+fdrtool,monoreg,2,0,0,double[],1
+fdrtool,monoreg,3,0,0,character[],1
+fdrtool,num.curv,-1,0,0,double,1
+fdrtool,num.curv,0,0,0,double,1
+fdrtool,num.curv,1,0,0,class<`function`>,1
+fdrtool,pcor0,-1,0,0,double,1
+fdrtool,pcor0,0,0,0,double,1
+fdrtool,pcor0,1,0,0,double,1
+fdrtool,pcor0,2,0,0,logical,1
+fdrtool,pcor0,3,0,0,logical,1
+fdrtool,phalfnorm,-1,0,0,double[],1
+fdrtool,phalfnorm,0,0,0,double[],1
+fdrtool,phalfnorm,1,0,0,double,1
+fdrtool,phalfnorm,2,0,0,logical,1
+fdrtool,phalfnorm,3,0,0,logical,1
+fdrtool,plot.grenander,-1,0,0,list<integer[]>,1
+fdrtool,plot.grenander,0,0,0,class<`grenander`>,1
+fdrtool,plot.grenander,1,0,0,...,1
+fdrtool,plot.monoreg,-1,0,0,null,1
+fdrtool,plot.monoreg,-1,0,1,list<integer[]>,1
+fdrtool,plot.monoreg,0,0,0,class<`monoreg`>,1
+fdrtool,plot.monoreg,1,0,0,any,1
+fdrtool,plot.monoreg,2,0,0,any,1
+fdrtool,plot.monoreg,3,0,0,character[],1
+fdrtool,plot.monoreg,4,0,0,...,1
+fdrtool,pval.estimate.eta0,-1,0,0,double,1
+fdrtool,pval.estimate.eta0,0,0,0,double[],1
+fdrtool,pval.estimate.eta0,1,0,0,character,1
+fdrtool,pval.estimate.eta0,2,0,0,any,1
+fdrtool,pval.estimate.eta0,3,0,0,logical,1
+fdrtool,pval.estimate.eta0,4,0,0,double,1
+fdrtool,pvt.fit.nullmodel,-1,0,0,list<double>,1
+fdrtool,pvt.fit.nullmodel,-1,0,1,list<double | null>,1
+fdrtool,pvt.fit.nullmodel,0,0,0,double[],1
+fdrtool,pvt.fit.nullmodel,1,0,0,double,1
+fdrtool,pvt.fit.nullmodel,2,0,0,character,1
+fdrtool,pvt.isoMean,-1,0,0,double[],1
+fdrtool,pvt.isoMean,0,0,0,double[],1
+fdrtool,pvt.isoMean,1,0,0,double[],1
+fdrtool,pvt.plotlabels,-1,0,0,list<character>,1
+fdrtool,pvt.plotlabels,0,0,0,character,1
+fdrtool,pvt.plotlabels,1,0,0,any,1
+fdrtool,pvt.plotlabels,2,0,0,double,1
+fdrtool,qcor0,-1,0,0,double,1
+fdrtool,qcor0,0,0,0,double,1
+fdrtool,qcor0,1,0,0,double,1
+fdrtool,qcor0,2,0,0,logical,1
+fdrtool,qcor0,3,0,0,logical,1
+fdrtool,qhalfnorm,-1,0,0,double[],1
+fdrtool,qhalfnorm,0,0,0,double[],1
+fdrtool,qhalfnorm,1,0,0,double,1
+fdrtool,qhalfnorm,2,0,0,logical,1
+fdrtool,qhalfnorm,3,0,0,logical,1
+fdrtool,r2t,-1,0,0,double[],1
+fdrtool,r2t,0,0,0,double[],1
+fdrtool,r2t,1,0,0,double,1
+fdrtool,rcor0,-1,0,0,double[],1
+fdrtool,rcor0,0,0,0,double,1
+fdrtool,rcor0,1,0,0,double,1
+fdrtool,residuals.monoreg,-1,0,0,double[],1
+fdrtool,residuals.monoreg,0,0,0,class<`monoreg`>,1
+fdrtool,residuals.monoreg,1,0,0,...,1
+fdrtool,rhalfnorm,-1,0,0,double[],1
+fdrtool,rhalfnorm,0,0,0,double,1
+fdrtool,rhalfnorm,1,0,0,double,1
+fdrtool,sd2theta,-1,0,0,double,1
+fdrtool,sd2theta,0,0,0,double,1
+fdrtool,t2r,-1,0,0,double[],1
+fdrtool,t2r,0,0,0,double[],1
+fdrtool,t2r,1,0,0,double,1
+fdrtool,theta2sd,-1,0,0,double,1
+fdrtool,theta2sd,0,0,0,double,1
+ffbase,addfforder,-1,0,0,"class<`ff`, `ff_vector`>",1
+ffbase,addfforder,0,0,0,"class<`ff`, `ff_vector`>",1
+ffbase,addfforder,1,0,0,logical,1
+ffbase,addfforder,2,0,0,...,1
+ffbase,any.ff,-1,0,0,logical,1
+ffbase,any.ff,0,0,0,"class<`ff`, `ff_vector`>",1
+ffbase,any.ff,1,0,0,...,1
+ffbase,any.ff,2,0,0,logical,1
+ffbase,any.ff,3,0,0,null,1
+ffbase,as.character.ff,-1,0,0,"class<`ff`, `ff_vector`>",1
+ffbase,as.character.ff,0,0,0,"class<`ff`, `ff_vector`>",1
+ffbase,as.character.ff,1,0,0,...,1
+ffbase,as.ffdf.ffdf,-1,0,0,class<`ffdf`>,1
+ffbase,as.ffdf.ffdf,0,0,0,class<`ffdf`>,1
+ffbase,as.ffdf.ffdf,1,0,0,...,1
+ffbase,as.ffdf.list,-1,0,0,class<`ffdf`>,1
+ffbase,as.ffdf.list,0,0,0,"list<class<`ff`, `ff_vector`>>",1
+ffbase,binned_sum,-1,0,0,class<`matrix`>,1
+ffbase,binned_sum,0,0,0,double[],1
+ffbase,binned_sum,1,0,0,class<`factor`>,1
+ffbase,binned_sum,1,0,1,integer[],1
+ffbase,binned_sum,2,0,0,any,1
+ffbase,binned_sum,3,0,0,...,1
+ffbase,binned_sum.default,-1,0,0,class<`matrix`>,1
+ffbase,binned_sum.default,0,0,0,double[],1
+ffbase,binned_sum.default,1,0,0,class<`factor`>,1
+ffbase,binned_sum.default,1,0,1,integer[],1
+ffbase,binned_sum.default,2,0,0,any,1
+ffbase,binned_sum.default,3,0,0,...,1
+ffbase,binned_tabulate.ff,-1,0,0,class<`matrix`>,1
+ffbase,binned_tabulate.ff,0,0,0,"class<`ff`, `ff_vector`>",1
+ffbase,binned_tabulate.ff,1,0,0,"class<`ff`, `ff_vector`>",1
+ffbase,binned_tabulate.ff,2,0,0,any,1
+ffbase,binned_tabulate.ff,3,0,0,double,1
+ffbase,binned_tabulate.ff,4,0,0,...,1
+ffbase,bySum,-1,0,0,class<`array`>,1
+ffbase,bySum,-1,0,1,class<`matrix`>,1
+ffbase,bySum,0,0,0,double[],1
+ffbase,bySum,1,0,0,class<`factor`>,1
+ffbase,bySum,1,0,1,class<`data.frame`>,1
+ffbase,bySum,2,0,0,logical,1
+ffbase,bySum,3,0,0,null,1
+ffbase,bySum,4,0,0,...,1
+ffbase,c.ff,-1,0,0,"class<`ff`, `ff_vector`>",1
+ffbase,c.ff,0,0,0,...,1
+ffbase,checkRange,-1,0,0,class<`ri`>,1
+ffbase,checkRange,0,0,0,null,1
+ffbase,checkRange,1,0,0,"class<`ff`, `ff_vector`>",1
+ffbase,chunkexpr,-1,0,0,expression,1
+ffbase,chunkexpr,0,0,0,class<`call`>,1
+ffbase,chunkexpr,0,0,1,expression,1
+ffbase,chunkexpr,1,0,0,character[],1
+ffbase,chunkexpr,2,0,0,character,1
+ffbase,chunkexpr,3,0,0,character,1
+ffbase,coerce_to_allowNA,-1,0,0,list<character[]>,1
+ffbase,coerce_to_allowNA,0,0,0,character[],1
+ffbase,coerce_to_highest_vmode,-1,0,0,class<`ffdf`>,1
+ffbase,coerce_to_highest_vmode,-1,0,1,"class<`ff`, `ff_vector`>",1
+ffbase,coerce_to_highest_vmode,0,0,0,class<`ffdf`>,1
+ffbase,coerce_to_highest_vmode,0,0,1,"class<`ff`, `ff_vector`>",1
+ffbase,coerce_to_highest_vmode,1,0,0,class<`ffdf`>,1
+ffbase,coerce_to_highest_vmode,1,0,1,"class<`ff`, `ff_vector`>",1
+ffbase,coerce_to_highest_vmode,1,0,2,integer[],1
+ffbase,coerce_to_highest_vmode,2,0,0,logical,1
+ffbase,cummax.ff,-1,0,0,"class<`ff`, `ff_vector`>",1
+ffbase,cummax.ff,0,0,0,"class<`ff`, `ff_vector`>",1
+ffbase,cummax.ff,1,0,0,...,1
+ffbase,cummin.ff,-1,0,0,"class<`ff`, `ff_vector`>",1
+ffbase,cummin.ff,0,0,0,"class<`ff`, `ff_vector`>",1
+ffbase,cummin.ff,1,0,0,...,1
+ffbase,cumprod.ff,-1,0,0,"class<`ff`, `ff_vector`>",1
+ffbase,cumprod.ff,0,0,0,"class<`ff`, `ff_vector`>",1
+ffbase,cumprod.ff,1,0,0,...,1
+ffbase,cumsum.ff,-1,0,0,"class<`ff`, `ff_vector`>",1
+ffbase,cumsum.ff,0,0,0,"class<`ff`, `ff_vector`>",1
+ffbase,cumsum.ff,1,0,0,...,1
+ffbase,cut.ff,-1,0,0,"class<`ff`, `ff_vector`>",1
+ffbase,cut.ff,0,0,0,"class<`ff`, `ff_vector`>",1
+ffbase,cut.ff,1,0,0,double,1
+ffbase,cut.ff,2,0,0,...,1
+ffbase,duplicated.ff,-1,0,0,"class<`ff`, `ff_vector`>",1
+ffbase,duplicated.ff,0,0,0,"class<`ff`, `ff_vector`>",1
+ffbase,duplicated.ff,1,0,0,logical,1
+ffbase,duplicated.ff,2,0,0,logical,1
+ffbase,duplicated.ff,3,0,0,logical,1
+ffbase,duplicated.ff,4,0,0,...,1
+ffbase,duplicated.ffdf,-1,0,0,"class<`ff`, `ff_vector`>",1
+ffbase,duplicated.ffdf,0,0,0,class<`ffdf`>,1
+ffbase,duplicated.ffdf,1,0,0,logical,1
+ffbase,duplicated.ffdf,2,0,0,logical,1
+ffbase,duplicated.ffdf,3,0,0,logical,1
+ffbase,duplicated.ffdf,4,0,0,...,1
+ffbase,expand.ffgrid,-1,0,0,class<`ffdf`>,1
+ffbase,expand.ffgrid,0,0,0,...,1
+ffbase,expand.ffgrid,1,0,0,logical,1
+ffbase,expand.ffgrid,2,0,0,logical,1
+ffbase,[<-.ff,-1,0,0,"class<`ff`, `ff_vector`>",1
+ffbase,[<-.ff,0,0,0,"class<`ff`, `ff_vector`>",1
+ffbase,[<-.ff,1,0,0,"class<`ff`, `ff_vector`>",1
+ffbase,[<-.ff,1,0,1,class<`ri`>,1
+ffbase,[<-.ff,1,0,2,class<`which`>,1
+ffbase,[<-.ff,1,0,3,double,1
+ffbase,[<-.ff,1,0,4,integer[],1
+ffbase,[<-.ff,2,0,0,logical,1
+ffbase,[<-.ff,3,0,0,logical,1
+ffbase,[<-.ff,4,0,0,"class<`ff`, `ff_vector`>",1
+ffbase,[<-.ff,4,0,1,^character[],1
+ffbase,[<-.ff,4,0,2,class<`factor`>,1
+ffbase,[<-.ff,4,0,3,double[],1
+ffbase,[<-.ff,4,0,4,^integer[],1
+ffbase,[<-.ff,4,0,5,null,1
+ffbase,[.ff,-1,0,0,class<`Date`>,1
+ffbase,[.ff,-1,0,1,class<`factor`>,1
+ffbase,[.ff,-1,0,2,"class<`ff`, `ff_vector`>",1
+ffbase,[.ff,-1,0,3,"class<`POSIXct`, `POSIXt`>",1
+ffbase,[.ff,-1,0,4,^double[],1
+ffbase,[.ff,-1,0,5,null,1
+ffbase,[.ff,0,0,0,"class<`ff`, `ff_vector`>",1
+ffbase,[.ff,1,0,0,any,1
+ffbase,[.ff,2,0,0,logical,1
+ffbase,%ff:%,-1,0,0,"class<`ff`, `ff_vector`>",1
+ffbase,%ff:%,0,0,0,integer,1
+ffbase,%ff:%,1,0,0,integer,1
+ffbase,ffappend,-1,0,0,"class<`ff`, `ff_vector`>",1
+ffbase,ffappend,-1,0,1,null,1
+ffbase,ffappend,0,0,0,"class<`ff`, `ff_vector`>",1
+ffbase,ffappend,0,0,1,null,1
+ffbase,ffappend,1,0,0,"class<`ff`, `ff_vector`>",1
+ffbase,ffappend,1,0,1,class<`Date`>,1
+ffbase,ffappend,1,0,2,class<`factor`>,1
+ffbase,ffappend,1,0,3,"class<`POSIXct`, `POSIXt`>",1
+ffbase,ffappend,1,0,4,double[],1
+ffbase,ffappend,1,0,5,^integer[],1
+ffbase,ffappend,1,0,6,null,1
+ffbase,ffappend,2,0,0,logical,1
+ffbase,ffappend,3,0,0,...,1
+ffbase,ffbaseffdfindexget,-1,0,0,class<`ffdf`>,1
+ffbase,ffbaseffdfindexget,0,0,0,class<`ffdf`>,1
+ffbase,ffbaseffdfindexget,1,0,0,"class<`ff`, `ff_vector`>",1
+ffbase,ffbaseffdfindexget,2,0,0,null,1
+ffbase,ffbaseffdfindexget,3,0,0,...,1
+ffbase,[<-.ffdf,-1,0,0,class<`ffdf`>,1
+ffbase,[<-.ffdf,0,0,0,class<`ffdf`>,1
+ffbase,[<-.ffdf,1,0,0,"class<`ff`, `ff_vector`>",1
+ffbase,[<-.ffdf,1,0,1,class<`hi`>,1
+ffbase,[<-.ffdf,2,0,0,any,1
+ffbase,[<-.ffdf,3,0,0,class<`ffdf`>,1
+ffbase,[.ffdf,-1,0,0,class<`data.frame`>,1
+ffbase,[.ffdf,-1,0,1,class<`ffdf`>,1
+ffbase,[.ffdf,-1,0,2,"class<`ff`, `ff_vector`>",1
+ffbase,[.ffdf,-1,0,3,double[],1
+ffbase,[.ffdf,0,0,0,class<`ffdf`>,1
+ffbase,[.ffdf,1,0,0,any,1
+ffbase,[.ffdf,2,0,0,any,1
+ffbase,[.ffdf,3,0,0,logical,1
+ffbase,ffdfappend,-1,0,0,class<`ffdf`>,1
+ffbase,ffdfappend,0,0,0,class<`ffdf`>,1
+ffbase,ffdfappend,0,0,1,null,1
+ffbase,ffdfappend,1,0,0,class<`data.frame`>,1
+ffbase,ffdfappend,1,0,1,class<`ffdf`>,1
+ffbase,ffdfappend,2,0,0,logical,1
+ffbase,ffdfappend,3,0,0,logical,1
+ffbase,ffdfappend,4,0,0,...,1
+ffbase,ffdfdply,-1,0,0,class<`ffdf`>,1
+ffbase,ffdfdply,0,0,0,class<`ffdf`>,1
+ffbase,ffdfdply,1,0,0,"class<`ff`, `ff_vector`>",1
+ffbase,ffdfdply,2,0,0,class<`function`>,1
+ffbase,ffdfdply,3,0,0,double,1
+ffbase,ffdfdply,4,0,0,integer,1
+ffbase,ffdfdply,5,0,0,logical,1
+ffbase,ffdfdply,6,0,0,...,1
+ffbase,ffdfget_columnwise,-1,0,0,class<`data.frame`>,1
+ffbase,ffdfget_columnwise,0,0,0,class<`ffdf`>,1
+ffbase,ffdfget_columnwise,1,0,0,"class<`ff`, `ff_vector`>",1
+ffbase,ffdfmatch,-1,0,0,"class<`ff`, `ff_vector`>",1
+ffbase,ffdfmatch,0,0,0,class<`ffdf`>,1
+ffbase,ffdfmatch,1,0,0,class<`ffdf`>,1
+ffbase,ffdfmatch,2,0,0,integer,1
+ffbase,ffdfmatch,2,0,1,null,1
+ffbase,ffdfmatch,3,0,0,null,1
+ffbase,ffdfmatch,4,0,0,logical,1
+ffbase,ffdfmatch,5,0,0,...,1
+ffbase,ffdfrbind.fill,-1,0,0,class<`ffdf`>,1
+ffbase,ffdfrbind.fill,0,0,0,...,1
+ffbase,ffdfrbind.fill,1,0,0,logical,1
+ffbase,ffdfwith,-1,0,0,"class<`ff`, `ff_vector`>",1
+ffbase,ffdfwith,0,0,0,class<`ffdf`>,1
+ffbase,ffdfwith,1,0,0,any,1
+ffbase,ffdfwith,2,0,0,...,1
+ffbase,ffifelse,-1,0,0,"class<`ff`, `ff_vector`>",1
+ffbase,ffifelse,0,0,0,"class<`ff`, `ff_vector`>",1
+ffbase,ffifelse,1,0,0,class<`Date`>,1
+ffbase,ffifelse,1,0,1,class<`factor`>,1
+ffbase,ffifelse,1,0,2,logical,1
+ffbase,ffifelse,2,0,0,class<`factor`>,1
+ffbase,ffifelse,2,0,1,"class<`ff`, `ff_vector`>",1
+ffbase,ffifelse,2,0,2,null,1
+ffbase,ffmatch,-1,0,0,"class<`ff`, `ff_vector`>",1
+ffbase,ffmatch,0,0,0,"class<`ff`, `ff_vector`>",1
+ffbase,ffmatch,1,0,0,"class<`ff`, `ff_vector`>",1
+ffbase,ffmatch,2,0,0,integer,1
+ffbase,ffmatch,2,0,1,null,1
+ffbase,ffmatch,3,0,0,null,1
+ffbase,ffmatch,4,0,0,logical,1
+ffbase,ffmatch,5,0,0,...,1
+ffbase,ffordered,-1,0,0,"class<`ff`, `ff_vector`>",1
+ffbase,ffordered,0,0,0,"class<`ff`, `ff_vector`>",1
+ffbase,ffrandom,-1,0,0,"class<`ff`, `ff_vector`>",1
+ffbase,ffrandom,0,0,0,double,1
+ffbase,ffrandom,1,0,0,class<`function`>,1
+ffbase,ffrandom,2,0,0,...,1
+ffbase,ffrandom,3,0,0,null,1
+ffbase,ffrep.int,-1,0,0,"class<`ff`, `ff_vector`>",1
+ffbase,ffrep.int,0,0,0,"class<`ff`, `ff_vector`>",1
+ffbase,ffrep.int,0,0,1,integer,1
+ffbase,ffrep.int,1,0,0,"class<`ff`, `ff_vector`>",1
+ffbase,ffrep.int,1,0,1,double,1
+ffbase,ffseq,-1,0,0,"class<`ff`, `ff_vector`>",1
+ffbase,ffseq,0,0,0,double,1
+ffbase,ffseq,1,0,0,double,1
+ffbase,ffseq,2,0,0,any,1
+ffbase,ffseq,3,0,0,double,1
+ffbase,ffseq,3,0,1,null,1
+ffbase,ffseq,4,0,0,null,1
+ffbase,ffseq,4,0,1,double,1
+ffbase,ffseq,5,0,0,...,1
+ffbase,ffseq_len,-1,0,0,"class<`ff`, `ff_vector`>",1
+ffbase,ffseq_len,0,0,0,double,1
+ffbase,<.ff_vector,-1,0,0,"class<`ff`, `ff_vector`>",1
+ffbase,<.ff_vector,0,0,0,"class<`ff`, `ff_vector`>",1
+ffbase,<.ff_vector,0,0,1,double,1
+ffbase,<.ff_vector,1,0,0,double,1
+ffbase,<.ff_vector,1,0,1,"class<`ff`, `ff_vector`>",1
+ffbase,>.ff_vector,-1,0,0,"class<`ff`, `ff_vector`>",1
+ffbase,>.ff_vector,0,0,0,"class<`ff`, `ff_vector`>",1
+ffbase,>.ff_vector,0,0,1,double,1
+ffbase,>.ff_vector,1,0,0,double,1
+ffbase,>.ff_vector,1,0,1,"class<`ff`, `ff_vector`>",1
+ffbase,*.ff_vector,-1,0,0,"class<`ff`, `ff_vector`>",1
+ffbase,*.ff_vector,0,0,0,"class<`ff`, `ff_vector`>",1
+ffbase,*.ff_vector,1,0,0,double,1
+ffbase,+.ff_vector,-1,0,0,"class<`ff`, `ff_vector`>",1
+ffbase,+.ff_vector,0,0,0,"class<`ff`, `ff_vector`>",1
+ffbase,+.ff_vector,0,0,1,double,1
+ffbase,+.ff_vector,1,0,0,double,1
+ffbase,+.ff_vector,1,0,1,"class<`ff`, `ff_vector`>",1
+ffbase,ffwhich,-1,0,0,"class<`ff`, `ff_vector`>",1
+ffbase,ffwhich,-1,0,1,null,1
+ffbase,ffwhich,0,0,0,class<`ffdf`>,1
+ffbase,ffwhich,0,0,1,"class<`ff`, `ff_vector`>",1
+ffbase,ffwhich,1,0,0,any,1
+ffbase,ffwhich,2,0,0,...,1
+ffbase,ffwhich.ffdf,-1,0,0,"class<`ff`, `ff_vector`>",1
+ffbase,ffwhich.ffdf,0,0,0,class<`ffdf`>,1
+ffbase,ffwhich.ffdf,1,0,0,any,1
+ffbase,ffwhich.ffdf,2,0,0,...,1
+ffbase,ffwhich.ffdf,3,0,0,environment,1
+ffbase,ffwhich.ff_vector,-1,0,0,"class<`ff`, `ff_vector`>",1
+ffbase,ffwhich.ff_vector,-1,0,1,null,1
+ffbase,ffwhich.ff_vector,0,0,0,"class<`ff`, `ff_vector`>",1
+ffbase,ffwhich.ff_vector,1,0,0,any,1
+ffbase,ffwhich.ff_vector,2,0,0,...,1
+ffbase,ffwhich.ff_vector,3,0,0,environment,1
+ffbase,grouprunningcumsum,-1,0,0,integer[],1
+ffbase,grouprunningcumsum,0,0,0,integer[],1
+ffbase,grouprunningcumsum,1,0,0,double,1
+ffbase,grouprunningcumsumindex,-1,0,0,list<integer[]>,1
+ffbase,grouprunningcumsumindex,0,0,0,double[],1
+ffbase,grouprunningcumsumindex,1,0,0,double,1
+ffbase,grouprunningcumsumindex,2,0,0,double,1
+ffbase,ikey,-1,0,0,"class<`ff`, `ff_vector`>",1
+ffbase,ikey,0,0,0,class<`ffdf`>,1
+ffbase,ikey,1,0,0,...,1
+ffbase,%in%,-1,0,0,"class<`ff`, `ff_vector`>",1
+ffbase,%in%,-1,0,1,logical[],1
+ffbase,%in%,0,0,0,class<`ffdf`>,1
+ffbase,%in%,0,0,1,"class<`ff`, `ff_vector`>",1
+ffbase,%in%,0,0,2,character[],1
+ffbase,%in%,0,0,3,class<`factor`>,1
+ffbase,%in%,0,0,4,integer[],1
+ffbase,%in%,1,0,0,class<`ffdf`>,1
+ffbase,%in%,1,0,1,"class<`ff`, `ff_vector`>",1
+ffbase,%in%,1,0,2,character[],1
+ffbase,%in%,1,0,3,class<`factor`>,1
+ffbase,%in%,1,0,4,double[],1
+ffbase,is.na<-.ff,-1,0,0,"class<`ff`, `ff_vector`>",1
+ffbase,is.na<-.ff,0,0,0,"class<`ff`, `ff_vector`>",1
+ffbase,is.na<-.ff,1,0,0,...,1
+ffbase,is.na<-.ff,2,0,0,"class<`ff`, `ff_vector`>",1
+ffbase,is.na<-.ff,2,0,1,double,1
+ffbase,is.na<-.ff,2,0,2,integer[],1
+ffbase,is.na.ff,-1,0,0,"class<`ff`, `ff_vector`>",1
+ffbase,is.na.ff,0,0,0,"class<`ff`, `ff_vector`>",1
+ffbase,is.na.ff,1,0,0,...,1
+ffbase,load.ffdf,-1,0,0,environment,1
+ffbase,load.ffdf,0,0,0,character,1
+ffbase,load.ffdf,1,0,0,environment,1
+ffbase,max.ff,-1,0,0,double,1
+ffbase,max.ff,-1,0,1,null,1
+ffbase,max.ff,0,0,0,"class<`ff`, `ff_vector`>",1
+ffbase,max.ff,1,0,0,...,1
+ffbase,max.ff,2,0,0,logical,1
+ffbase,max.ff,3,0,0,null,1
+ffbase,mean.ff,-1,0,0,double,1
+ffbase,mean.ff,0,0,0,"class<`ff`, `ff_vector`>",1
+ffbase,mean.ff,1,0,0,double,1
+ffbase,mean.ff,2,0,0,...,1
+ffbase,mean.ff,3,0,0,null,1
+ffbase,merge.ffdf,-1,0,0,class<`ffdf`>,1
+ffbase,merge.ffdf,0,0,0,class<`ffdf`>,1
+ffbase,merge.ffdf,1,0,0,class<`ffdf`>,1
+ffbase,merge.ffdf,2,0,0,any,1
+ffbase,merge.ffdf,3,0,0,character,1
+ffbase,merge.ffdf,4,0,0,character,1
+ffbase,merge.ffdf,5,0,0,logical,1
+ffbase,merge.ffdf,6,0,0,logical,1
+ffbase,merge.ffdf,7,0,0,logical,1
+ffbase,min.ff,-1,0,0,integer,1
+ffbase,min.ff,-1,0,1,null,1
+ffbase,min.ff,0,0,0,"class<`ff`, `ff_vector`>",1
+ffbase,min.ff,1,0,0,...,1
+ffbase,min.ff,2,0,0,logical,1
+ffbase,min.ff,3,0,0,null,1
+ffbase,move.ffdf,-1,0,0,class<`ffdf`>,1
+ffbase,move.ffdf,0,0,0,class<`ffdf`>,1
+ffbase,move.ffdf,1,0,0,character,1
+ffbase,move.ffdf,2,0,0,character,1
+ffbase,move.ffdf,3,0,0,logical,1
+ffbase,opsff_arith,-1,0,0,"class<`ff`, `ff_vector`>",1
+ffbase,opsff_arith,0,0,0,"class<`ff`, `ff_vector`>",1
+ffbase,opsff_arith,0,0,1,double,1
+ffbase,opsff_arith,1,0,0,double,1
+ffbase,opsff_arith,1,0,1,"class<`ff`, `ff_vector`>",1
+ffbase,opsff_arith,2,0,0,character,1
+ffbase,opsff_compare_logic,-1,0,0,"class<`ff`, `ff_vector`>",1
+ffbase,opsff_compare_logic,0,0,0,"class<`ff`, `ff_vector`>",1
+ffbase,opsff_compare_logic,0,0,1,double,1
+ffbase,opsff_compare_logic,1,0,0,double,1
+ffbase,opsff_compare_logic,1,0,1,"class<`ff`, `ff_vector`>",1
+ffbase,opsff_compare_logic,2,0,0,character,1
+ffbase,pack.ffdf,-1,0,0,integer,1
+ffbase,pack.ffdf,0,0,0,character,1
+ffbase,pack.ffdf,1,0,0,...,1
+ffbase,range.ff,-1,0,0,^integer[],1
+ffbase,range.ff,0,0,0,"class<`ff`, `ff_vector`>",1
+ffbase,range.ff,1,0,0,...,1
+ffbase,range.ff,2,0,0,logical,1
+ffbase,range.ff,3,0,0,null,1
+ffbase,save.ffdf,-1,0,0,null,1
+ffbase,save.ffdf,0,0,0,...,1
+ffbase,save.ffdf,1,0,0,character,1
+ffbase,save.ffdf,2,0,0,logical,1
+ffbase,save.ffdf,3,0,0,logical,1
+ffbase,save.ffdf,4,0,0,logical,1
+ffbase,sum.ff,-1,0,0,integer,1
+ffbase,sum.ff,0,0,0,"class<`ff`, `ff_vector`>",1
+ffbase,sum.ff,1,0,0,...,1
+ffbase,sum.ff,2,0,0,logical,1
+ffbase,sum.ff,3,0,0,null,1
+ffbase,table,-1,0,0,class<`table`>,1
+ffbase,table,0,0,0,...,1
+ffbase,table,1,0,0,any,1
+ffbase,table,2,0,0,any,1
+ffbase,table,3,0,0,any,1
+ffbase,table,4,0,0,double,1
+ffbase,tabulate.ff,-1,0,0,integer[],1
+ffbase,tabulate.ff,0,0,0,"class<`ff`, `ff_vector`>",1
+ffbase,tabulate.ff,1,0,0,double,1
+ffbase,transform.ffdf,-1,0,0,class<`ffdf`>,1
+ffbase,transform.ffdf,0,0,0,class<`ffdf`>,1
+ffbase,transform.ffdf,1,0,0,...,1
+ffbase,unique.ff,-1,0,0,"class<`ff`, `ff_vector`>",1
+ffbase,unique.ff,0,0,0,"class<`ff`, `ff_vector`>",1
+ffbase,unique.ff,1,0,0,logical,1
+ffbase,unique.ff,2,0,0,logical,1
+ffbase,unique.ff,3,0,0,logical,1
+ffbase,unique.ff,4,0,0,...,1
+ffbase,unique.ffdf,-1,0,0,class<`ffdf`>,1
+ffbase,unique.ffdf,0,0,0,class<`ffdf`>,1
+ffbase,unique.ffdf,1,0,0,logical,1
+ffbase,unique.ffdf,2,0,0,logical,1
+ffbase,unique.ffdf,3,0,0,logical,1
+ffbase,unique.ffdf,4,0,0,...,1
+ffbase,unpack.ffdf,-1,0,0,environment,1
+ffbase,unpack.ffdf,0,0,0,character,1
+ffbase,unpack.ffdf,1,0,0,null,1
+ffbase,unpack.ffdf,2,0,0,environment,1
+ffbase,with.ffdf,-1,0,0,"class<`ff`, `ff_vector`>",1
+ffbase,with.ffdf,0,0,0,class<`ffdf`>,1
+ffbase,with.ffdf,1,0,0,any,1
+ffbase,with.ffdf,2,0,0,...,1
+ffbase,within.ffdf,-1,0,0,class<`ffdf`>,1
+ffbase,within.ffdf,0,0,0,class<`ffdf`>,1
+ffbase,within.ffdf,1,0,0,any,1
+ffbase,within.ffdf,2,0,0,...,1
+fftwtools,fftw,-1,0,0,complex[],1
+fftwtools,fftw,0,0,0,double[],1
+fftwtools,fftw,1,0,0,double,1
+fftwtools,fftw,2,0,0,double,1
+fftwtools,fftw,3,0,0,null,1
+fftwtools,fftw2d,-1,0,0,class<`matrix`>,1
+fftwtools,fftw2d,0,0,0,class<`matrix`>,1
+fftwtools,fftw2d,1,0,0,double,1
+fftwtools,fftw2d,2,0,0,double,1
+fftwtools,fftw_c2c_2d,-1,0,0,class<`matrix`>,1
+fftwtools,fftw_c2c_2d,0,0,0,class<`matrix`>,1
+fftwtools,fftw_c2c_2d,1,0,0,double,1
+fftwtools,fftw_c2r,-1,0,0,double[],1
+fftwtools,fftw_c2r,0,0,0,complex[],1
+fftwtools,fftw_c2r,1,0,0,double,1
+fftwtools,fftw_c2r,2,0,0,double,1
+fftwtools,fftw_c2r,2,0,1,null,1
+fftwtools,fftw_r2c,-1,0,0,complex[],1
+fftwtools,fftw_r2c,0,0,0,double[],1
+fftwtools,fftw_r2c,1,0,0,double,1
+fftwtools,fftw_r2c_2d,-1,0,0,class<`matrix`>,1
+fftwtools,fftw_r2c_2d,0,0,0,class<`matrix`>,1
+fftwtools,fftw_r2c_2d,1,0,0,double,1
+fftwtools,mvfftw,-1,0,0,class<`matrix`>,1
+fftwtools,mvfftw,0,0,0,class<`matrix`>,1
+fftwtools,mvfftw,1,0,0,double,1
+fftwtools,mvfftw,2,0,0,double,1
+fftwtools,mvfftw,3,0,0,double,1
+fftwtools,mvfftw,3,0,1,null,1
+fftwtools,mvfftw,4,0,0,double,1
+fftwtools,mvfftw_c2c,-1,0,0,class<`matrix`>,1
+fftwtools,mvfftw_c2c,0,0,0,class<`matrix`>,1
+fftwtools,mvfftw_c2c,1,0,0,double,1
+fftwtools,mvfftw_c2c,2,0,0,double,1
+fftwtools,mvfftw_c2r,-1,0,0,class<`matrix`>,1
+fftwtools,mvfftw_c2r,0,0,0,class<`matrix`>,1
+fftwtools,mvfftw_c2r,1,0,0,double,1
+fftwtools,mvfftw_c2r,2,0,0,double,1
+fftwtools,mvfftw_c2r,2,0,1,null,1
+fftwtools,mvfftw_c2r,3,0,0,double,1
+fftwtools,mvfftw_r2c,-1,0,0,class<`matrix`>,1
+fftwtools,mvfftw_r2c,0,0,0,class<`matrix`>,1
+fftwtools,mvfftw_r2c,1,0,0,double,1
+fftwtools,mvfftw_r2c,2,0,0,double,1
+fields,add.image,-1,0,0,null,1
+fields,add.image,0,0,0,double,1
+fields,add.image,1,0,0,double,1
+fields,add.image,2,0,0,class<`matrix`>,1
+fields,add.image,3,0,0,double,1
+fields,add.image,4,0,0,double,1
+fields,add.image,5,0,0,double,1
+fields,add.image,6,0,0,null,1
+fields,add.image,7,0,0,character[],1
+fields,arrow.plot,-1,0,0,list<logical>,1
+fields,arrow.plot,0,0,0,double[],1
+fields,arrow.plot,1,0,0,double[],1
+fields,arrow.plot,2,0,0,double[],1
+fields,arrow.plot,3,0,0,double[],1
+fields,arrow.plot,4,0,0,double,1
+fields,arrow.plot,5,0,0,logical,1
+fields,arrow.plot,6,0,0,logical,1
+fields,arrow.plot,7,0,0,class<`function`>,1
+fields,as.image,-1,0,0,list<any>,1
+fields,as.image,0,0,0,class<`matrix`>,1
+fields,as.image,0,0,1,^double[],1
+fields,as.image,1,0,0,null,1
+fields,as.image,2,0,0,null,1
+fields,as.image,2,0,1,list<double[]>,1
+fields,as.image,3,0,0,class<`matrix`>,1
+fields,as.image,3,0,1,class<`data.frame`>,1
+fields,as.image,4,0,0,double[],1
+fields,as.image,5,0,0,logical,1
+fields,as.image,6,0,0,double,1
+fields,as.image,7,0,0,double,1
+fields,as.surface,-1,0,0,list<double[] | character | class<`matrix`>>,1
+fields,as.surface,0,0,0,class<`matrix`>,1
+fields,as.surface,0,0,1,list<double[]>,1
+fields,as.surface,1,0,0,class<`matrix`>,1
+fields,as.surface,1,0,1,double[],1
+fields,as.surface,2,0,0,null,1
+fields,as.surface,3,0,0,character,1
+fields,average.image,-1,0,0,list<double[] | class<`matrix`>>,1
+fields,average.image,0,0,0,list<double[] | class<`matrix`>>,1
+fields,average.image,1,0,0,double,1
+fields,bisection.search,-1,0,0,list<double>,1
+fields,bisection.search,0,0,0,double,1
+fields,bisection.search,1,0,0,double,1
+fields,bisection.search,2,0,0,class<`function`>,1
+fields,bisection.search,3,0,0,double,1
+fields,bisection.search,4,0,0,double,1
+fields,bisection.search,5,0,0,class<`sreg`>,1
+fields,bisection.search,5,0,1,list<double[]>,1
+fields,bisection.search,5,0,2,list<double | list<double[]>>,1
+fields,bisection.search,5,0,3,list<double | list<double[] | class<`matrix`>>>,1
+fields,bisection.search,5,0,4,list<class<`matrix`> | double[]>,1
+fields,bisection.search,5,0,5,list<class<`matrix`> | null | double[]>,1
+fields,bisection.search,6,0,0,double,1
+fields,boxplotVGram,-1,0,0,null,1
+fields,boxplotVGram,0,0,0,"class<`list`, `vgram`>",1
+fields,boxplotVGram,1,0,0,double,1
+fields,boxplotVGram,2,0,0,double[],1
+fields,boxplotVGram,3,0,0,logical,1
+fields,boxplotVGram,4,0,0,list<character>,1
+fields,boxplotVGram,5,0,0,...,1
+fields,bplot,-1,0,0,list<class<`matrix`> | double[] | character[]>,1
+fields,bplot,0,0,0,class<`matrix`>,1
+fields,bplot,0,0,1,list<double[]>,1
+fields,bplot,1,0,0,any,1
+fields,bplot,2,0,0,double[],1
+fields,bplot,2,0,1,null,1
+fields,bplot,3,0,0,double[],1
+fields,bplot,3,0,1,null,1
+fields,bplot,4,0,0,logical,1
+fields,bplot,5,0,0,double,1
+fields,bplot,6,0,0,null,1
+fields,bplot,6,0,1,double[],1
+fields,bplot,7,0,0,...,1
+fields,bplot.xy,-1,0,0,double[],1
+fields,bplot.xy,0,0,0,double[],1
+fields,bplot.xy,1,0,0,double[],1
+fields,bplot.xy,2,0,0,double,1
+fields,bplot.xy,3,0,0,double[],1
+fields,bplot.xy,4,0,0,logical,1
+fields,bplot.xy,5,0,0,...,1
+fields,cat.matrix,-1,0,0,integer[],1
+fields,cat.matrix,0,0,0,class<`matrix`>,1
+fields,cat.matrix,0,0,1,class<`data.frame`>,1
+fields,cat.matrix,1,0,0,double,1
+fields,cat.to.list,-1,0,0,list<double[]>,1
+fields,cat.to.list,0,0,0,double[],1
+fields,cat.to.list,1,0,0,integer[],1
+fields,ceiling2,-1,0,0,double,1
+fields,ceiling2,0,0,0,double,1
+fields,colorbar.plot,-1,0,0,null,1
+fields,colorbar.plot,0,0,0,double,1
+fields,colorbar.plot,1,0,0,double,1
+fields,colorbar.plot,2,0,0,class<`matrix`>,1
+fields,colorbar.plot,3,0,0,double,1
+fields,colorbar.plot,4,0,0,double,1
+fields,colorbar.plot,5,0,0,class<`matrix`>,1
+fields,colorbar.plot,5,0,1,null,1
+fields,colorbar.plot,6,0,0,double,1
+fields,colorbar.plot,7,0,0,double,1
+fields,color.scale,-1,0,0,character[],1
+fields,color.scale,0,0,0,double[],1
+fields,color.scale,1,0,0,character[],1
+fields,color.scale,2,0,0,null,1
+fields,color.scale,3,0,0,any,1
+fields,color.scale,4,0,0,double,1
+fields,compactToMat,-1,0,0,class<`matrix`>,1
+fields,compactToMat,0,0,0,class<`dist`>,1
+fields,compactToMat,1,0,0,double,1
+fields,compactToMat,2,0,0,logical,1
+fields,compactToMat,3,0,0,logical,1
+fields,cover.design,-1,0,0,class<`spatialDesign`>,1
+fields,cover.design,0,0,0,class<`matrix`>,1
+fields,cover.design,1,0,0,double,1
+fields,cover.design,2,0,0,double,1
+fields,cover.design,3,0,0,logical,1
+fields,cover.design,4,0,0,double,1
+fields,cover.design,5,0,0,null,1
+fields,cover.design,5,0,1,integer[],1
+fields,cover.design,6,0,0,character,1
+fields,cover.design,7,0,0,any,1
+fields,crop.image,-1,0,0,list<double[] | class<`matrix`>>,1
+fields,crop.image,0,0,0,list<double[] | class<`matrix`>>,1
+fields,crop.image,1,0,0,class<`matrix`>,1
+fields,crop.image,2,0,0,...,1
+fields,crossCoVGram,-1,0,0,"class<`list`, `vgram`>",1
+fields,crossCoVGram,0,0,0,class<`matrix`>,1
+fields,crossCoVGram,1,0,0,class<`matrix`>,1
+fields,crossCoVGram,2,0,0,^double[],1
+fields,crossCoVGram,3,0,0,^double[],1
+fields,crossCoVGram,4,0,0,null,1
+fields,crossCoVGram,5,0,0,null,1
+fields,crossCoVGram,6,0,0,logical,1
+fields,crossCoVGram,7,0,0,null,1
+fields,describe,-1,0,0,character[],1
+fields,describe,-1,0,1,double[],1
+fields,describe,0,0,0,any,1
+fields,designer.colors,-1,0,0,character[],1
+fields,designer.colors,0,0,0,double,1
+fields,designer.colors,1,0,0,character[],1
+fields,designer.colors,2,0,0,double[],1
+fields,designer.colors,3,0,0,double,1
+fields,discretize.image,-1,0,0,list<any>,1
+fields,discretize.image,0,0,0,class<`data.frame`>,1
+fields,discretize.image,0,0,1,class<`matrix`>,1
+fields,discretize.image,1,0,0,any,1
+fields,discretize.image,2,0,0,any,1
+fields,discretize.image,3,0,0,list<double[]>,1
+fields,discretize.image,3,0,1,null,1
+fields,discretize.image,4,0,0,double[],1
+fields,discretize.image,5,0,0,logical,1
+fields,discretize.image,6,0,0,logical,1
+fields,drape.color,-1,0,0,list<class<`matrix`> | double[]>,1
+fields,drape.color,0,0,0,class<`matrix`>,1
+fields,drape.color,1,0,0,character[],1
+fields,drape.color,2,0,0,double[],1
+fields,drape.color,3,0,0,any,1
+fields,drape.color,4,0,0,any,1
+fields,drape.color,5,0,0,logical,1
+fields,drape.color,6,0,0,double,1
+fields,drape.plot,-1,0,0,class<`matrix`>,1
+fields,drape.plot,0,0,0,double[],1
+fields,drape.plot,1,0,0,double[],1
+fields,drape.plot,2,0,0,class<`matrix`>,1
+fields,drape.plot,3,0,0,null,1
+fields,drape.plot,4,0,0,character[],1
+fields,drape.plot,5,0,0,double[],1
+fields,drape.plot,6,0,0,double[],1
+fields,drape.plot,6,0,1,null,1
+fields,drape.plot,7,0,0,logical,1
+fields,envelopePlot,-1,0,0,null,1
+fields,envelopePlot,0,0,0,double[],1
+fields,envelopePlot,1,0,0,double[],1
+fields,envelopePlot,2,0,0,double[],1
+fields,envelopePlot,3,0,0,double[],1
+fields,envelopePlot,4,0,0,character,1
+fields,envelopePlot,5,0,0,character,1
+fields,envelopePlot,6,0,0,...,1
+fields,Exp.cov,-1,0,0,class<`matrix`>,1
+fields,Exp.cov,-1,0,1,double[],1
+fields,Exp.cov,0,0,0,class<`matrix`>,1
+fields,Exp.cov,1,0,0,class<`matrix`>,1
+fields,Exp.cov,1,0,1,null,1
+fields,Exp.cov,2,0,0,double,1
+fields,Exp.cov,3,0,0,double,1
+fields,Exp.cov,4,0,0,null,1
+fields,Exp.cov,4,0,1,class<`matrix`>,1
+fields,Exp.cov,4,0,2,class<`dist`>,1
+fields,Exp.cov,5,0,0,null,1
+fields,Exp.cov,5,0,1,double[],1
+fields,Exp.cov,5,0,2,class<`matrix`>,1
+fields,Exp.cov,6,0,0,logical,1
+fields,Exp.cov,7,0,0,logical,1
+fields,Exp.image.cov,-1,0,0,list<any>,1
+fields,Exp.image.cov,0,0,0,any,1
+fields,Exp.image.cov,1,0,0,any,1
+fields,Exp.image.cov,2,0,0,any,1
+fields,Exp.image.cov,3,0,0,null,1
+fields,Exp.image.cov,4,0,0,logical,1
+fields,Exp.image.cov,5,0,0,list<double[]>,1
+fields,Exp.image.cov,6,0,0,...,1
+fields,Exponential,-1,0,0,class<`dist`>,1
+fields,Exponential,-1,0,1,class<`matrix`>,1
+fields,Exponential,-1,0,2,double[],1
+fields,Exponential,0,0,0,class<`dist`>,1
+fields,Exponential,0,0,1,class<`matrix`>,1
+fields,Exponential,0,0,2,double[],1
+fields,Exponential,1,0,0,double,1
+fields,Exponential,2,0,0,double,1
+fields,Exponential,3,0,0,double,1
+fields,ExponentialUpper,-1,0,0,class<`matrix`>,1
+fields,ExponentialUpper,0,0,0,class<`matrix`>,1
+fields,ExponentialUpper,1,0,0,double,1
+fields,ExponentialUpper,2,0,0,double,1
+fields,fast.1way,-1,0,0,list<class<`matrix`> | double[]>,1
+fields,fast.1way,0,0,0,integer[],1
+fields,fast.1way,1,0,0,class<`matrix`>,1
+fields,fast.1way,1,0,1,double[],1
+fields,fast.1way,2,0,0,double[],1
+fields,fastTps,-1,0,0,"class<`fastTps`, `mKrig`>",1
+fields,fastTps,0,0,0,class<`data.frame`>,1
+fields,fastTps,0,0,1,class<`matrix`>,1
+fields,fastTps,1,0,0,double[],1
+fields,fastTps,2,0,0,double,1
+fields,fastTps,2,0,1,null,1
+fields,fastTps,3,0,0,null,1
+fields,fastTps,4,0,0,double,1
+fields,fastTps,5,0,0,logical,1
+fields,fastTps,6,0,0,logical,1
+fields,fastTps,7,0,0,double,1
+fields,fields.convert.grid,-1,0,0,double[],1
+fields,fields.convert.grid,0,0,0,double[],1
+fields,fields.D,-1,0,0,class<`call`>,1
+fields,fields.D,0,0,0,class<`call`>,1
+fields,fields.D,0,0,1,expression,1
+fields,fields.D,1,0,0,character,1
+fields,fields.D,2,0,0,double,1
+fields,fields.derivative.poly,-1,0,0,class<`matrix`>,1
+fields,fields.derivative.poly,0,0,0,class<`matrix`>,1
+fields,fields.derivative.poly,1,0,0,double,1
+fields,fields.derivative.poly,2,0,0,double[],1
+fields,fields.derivative.poly,2,0,1,class<`matrix`>,1
+fields,fields.diagonalize,-1,0,0,list<class<`matrix`> | double[]>,1
+fields,fields.diagonalize,0,0,0,class<`matrix`>,1
+fields,fields.diagonalize,1,0,0,class<`matrix`>,1
+fields,fields.diagonalize2,-1,0,0,list<class<`matrix`> | double[]>,1
+fields,fields.diagonalize2,0,0,0,class<`matrix`>,1
+fields,fields.diagonalize2,1,0,0,class<`matrix`>,1
+fields,fields.diagonalize2,2,0,0,logical,1
+fields,fields.duplicated.matrix,-1,0,0,integer[],1
+fields,fields.duplicated.matrix,0,0,0,class<`matrix`>,1
+fields,fields.duplicated.matrix,0,0,1,class<`data.frame`>,1
+fields,fields.duplicated.matrix,1,0,0,double,1
+fields,fields.evlpoly,-1,0,0,double[],1
+fields,fields.evlpoly,0,0,0,double[],1
+fields,fields.evlpoly,1,0,0,double[],1
+fields,fields.evlpoly2,-1,0,0,double[],1
+fields,fields.evlpoly2,0,0,0,class<`matrix`>,1
+fields,fields.evlpoly2,1,0,0,double[],1
+fields,fields.evlpoly2,2,0,0,class<`matrix`>,1
+fields,fields.mkpoly,-1,0,0,class<`matrix`>,1
+fields,fields.mkpoly,-1,0,1,null,1
+fields,fields.mkpoly,0,0,0,any,1
+fields,fields.mkpoly,1,0,0,double,1
+fields,fieldsPlotColors,-1,0,0,null,1
+fields,fieldsPlotColors,0,0,0,character[],1
+fields,fieldsPlotColors,1,0,0,...,1
+fields,fields.pochdown,-1,0,0,double,1
+fields,fields.pochdown,0,0,0,double,1
+fields,fields.pochdown,1,0,0,double,1
+fields,fields.pochup,-1,0,0,double,1
+fields,fields.pochup,0,0,0,double,1
+fields,fields.pochup,1,0,0,double,1
+fields,fields.rdist.near,-1,0,0,list<class<`matrix`> | double[]>,1
+fields,fields.rdist.near,0,0,0,class<`matrix`>,1
+fields,fields.rdist.near,1,0,0,class<`matrix`>,1
+fields,fields.rdist.near,2,0,0,double,1
+fields,fields.rdist.near,3,0,0,double,1
+fields,fields.rdist.near,3,0,1,null,1
+fields,fields.rdist.near,4,0,0,double,1
+fields,fields.x.to.grid,-1,0,0,list<double[]>,1
+fields,fields.x.to.grid,0,0,0,class<`matrix`>,1
+fields,fields.x.to.grid,0,0,1,class<`data.frame`>,1
+fields,fields.x.to.grid,1,0,0,double,1
+fields,fields.x.to.grid,2,0,0,double,1
+fields,fields.x.to.grid,3,0,0,double[],1
+fields,find.upcross,-1,0,0,double,1
+fields,find.upcross,0,0,0,class<`function`>,1
+fields,find.upcross,1,0,0,class<`sreg`>,1
+fields,find.upcross,1,0,1,list<double | list<double[] | class<`matrix`>>>,1
+fields,find.upcross,1,0,2,list<double | list<double[]>>,1
+fields,find.upcross,1,0,3,list<class<`matrix`> | null | double[]>,1
+fields,find.upcross,2,0,0,double,1
+fields,find.upcross,3,0,0,double,1
+fields,find.upcross,4,0,0,double,1
+fields,gcv.Krig,-1,0,0,list<class<`data.frame`> | class<`matrix`>>,1
+fields,gcv.Krig,0,0,0,"class<`Krig`, `Tps`>",1
+fields,gcv.Krig,0,0,1,list<any>,1
+fields,gcv.Krig,1,0,0,null,1
+fields,gcv.Krig,2,0,0,double,1
+fields,gcv.Krig,3,0,0,double,1
+fields,gcv.Krig,4,0,0,null,1
+fields,gcv.Krig,5,0,0,logical,1
+fields,gcv.Krig,6,0,0,double,1
+fields,gcv.Krig,7,0,0,double,1
+fields,gcv.sreg,-1,0,0,list<class<`data.frame`> | class<`matrix`>>,1
+fields,gcv.sreg,0,0,0,class<`sreg`>,1
+fields,gcv.sreg,0,0,1,list<class<`matrix`> | null | double[]>,1
+fields,gcv.sreg,1,0,0,null,1
+fields,gcv.sreg,2,0,0,double,1
+fields,gcv.sreg,3,0,0,double,1
+fields,gcv.sreg,4,0,0,null,1
+fields,gcv.sreg,5,0,0,double,1
+fields,gcv.sreg,6,0,0,null,1
+fields,gcv.sreg,6,0,1,double,1
+fields,gcv.sreg,7,0,0,null,1
+fields,gcv.sreg,7,0,1,double,1
+fields,getVGMean,-1,0,0,list<double[] | character>,1
+fields,getVGMean,0,0,0,"class<`list`, `vgram`>",1
+fields,getVGMean,1,0,0,double,1
+fields,getVGMean,2,0,0,double[],1
+fields,golden.section.search,-1,0,0,list<double | class<`matrix`>>,1
+fields,golden.section.search,0,0,0,double,1
+fields,golden.section.search,1,0,0,double,1
+fields,golden.section.search,2,0,0,double,1
+fields,golden.section.search,3,0,0,class<`function`>,1
+fields,golden.section.search,4,0,0,double,1
+fields,golden.section.search,5,0,0,class<`sreg`>,1
+fields,golden.section.search,5,0,1,list<double | list<double[] | class<`matrix`>>>,1
+fields,golden.section.search,5,0,2,list<double | null | list<double[] | class<`matrix`>>>,1
+fields,golden.section.search,5,0,3,list<double | list<double[]>>,1
+fields,golden.section.search,5,0,4,list<double | null | list<double[]>>,1
+fields,golden.section.search,5,0,5,list<class<`matrix`> | double[]>,1
+fields,golden.section.search,5,0,6,list<class<`matrix`> | null | double[]>,1
+fields,golden.section.search,6,0,0,double,1
+fields,golden.section.search,7,0,0,null,1
+fields,half.image,-1,0,0,list<double[] | class<`matrix`>>,1
+fields,half.image,0,0,0,list<double[] | class<`matrix`>>,1
+fields,image.plot,-1,0,0,null,1
+fields,image.plot,0,0,0,...,1
+fields,image.plot,1,0,0,logical,1
+fields,image.plot,2,0,0,double[],1
+fields,image.plot,2,0,1,null,1
+fields,image.plot,3,0,0,any,1
+fields,image.plot,4,0,0,character[],1
+fields,image.plot,4,0,1,null,1
+fields,image.plot,5,0,0,logical,1
+fields,image.plot,6,0,0,double,1
+fields,image.plot,7,0,0,double,1
+fields,imagePlotInfo,-1,0,0,list<double[]>,1
+fields,imagePlotInfo,-1,0,1,list<null | double[]>,1
+fields,imagePlotInfo,0,0,0,...,1
+fields,imagePlotInfo,1,0,0,null,1
+fields,imagePlotInfo,1,0,1,double[],1
+fields,imagePlotInfo,2,0,0,any,1
+fields,imageplot.setup,-1,0,0,list<double[]>,1
+fields,imageplot.setup,0,0,0,any,1
+fields,imageplot.setup,1,0,0,any,1
+fields,imageplot.setup,2,0,0,any,1
+fields,imageplot.setup,3,0,0,double,1
+fields,imageplot.setup,4,0,0,logical,1
+fields,imageplot.setup,5,0,0,double,1
+fields,imageplot.setup,6,0,0,null,1
+fields,imageplot.setup,7,0,0,double[],1
+fields,imageplot.setup,7,0,1,null,1
+fields,image.smooth,-1,0,0,list<double[] | class<`matrix`>>,1
+fields,image.smooth,0,0,0,class<`matrix`>,1
+fields,image.smooth,0,0,1,list<any>,1
+fields,image.smooth,1,0,0,null,1
+fields,image.smooth,1,0,1,list<any>,1
+fields,image.smooth,2,0,0,any,1
+fields,image.smooth,3,0,0,any,1
+fields,image.smooth,4,0,0,any,1
+fields,image.smooth,5,0,0,double,1
+fields,image.smooth,6,0,0,null,1
+fields,image.smooth,7,0,0,double,1
+fields,in.poly,-1,0,0,logical[],1
+fields,in.poly,0,0,0,class<`matrix`>,1
+fields,in.poly,1,0,0,class<`matrix`>,1
+fields,in.poly,2,0,0,logical,1
+fields,in.poly,3,0,0,double,1
+fields,in.poly.grid,-1,0,0,class<`matrix`>,1
+fields,in.poly.grid,0,0,0,list<double[]>,1
+fields,in.poly.grid,1,0,0,class<`matrix`>,1
+fields,in.poly.grid,2,0,0,logical,1
+fields,in.poly.grid,3,0,0,double,1
+fields,interp.surface,-1,0,0,^double[],1
+fields,interp.surface,0,0,0,list<integer[] | class<`matrix`>>,1
+fields,interp.surface,0,0,1,list<double[] | class<`matrix`>>,1
+fields,interp.surface,1,0,0,class<`matrix`>,1
+fields,interp.surface,1,0,1,class<`data.frame`>,1
+fields,interp.surface.grid,-1,0,0,list<double[] | class<`matrix`>>,1
+fields,interp.surface.grid,0,0,0,list<integer[] | class<`matrix`>>,1
+fields,interp.surface.grid,1,0,0,list<double[]>,1
+fields,Krig,-1,0,0,class<`Krig`>,1
+fields,Krig,0,0,0,class<`data.frame`>,1
+fields,Krig,0,0,1,class<`matrix`>,1
+fields,Krig,1,0,0,class<`matrix`>,1
+fields,Krig,1,0,1,^double[],1
+fields,Krig,2,0,0,character,1
+fields,Krig,2,0,1,class<`function`>,1
+fields,Krig,3,0,0,double,1
+fields,Krig,3,0,1,null,1
+fields,Krig,4,0,0,null,1
+fields,Krig,4,0,1,double,1
+fields,Krig,5,0,0,logical,1
+fields,Krig,6,0,0,double[],1
+fields,Krig,6,0,1,null,1
+fields,Krig,6,0,2,class<`matrix`>,1
+fields,Krig,7,0,0,double,1
+fields,Krig.Amatrix,-1,0,0,class<`matrix`>,1
+fields,Krig.Amatrix,0,0,0,class<`Krig`>,1
+fields,Krig.Amatrix,0,0,1,"class<`Krig`, `Tps`>",1
+fields,Krig.Amatrix,1,0,0,class<`matrix`>,1
+fields,Krig.Amatrix,2,0,0,double,1
+fields,Krig.Amatrix,2,0,1,null,1
+fields,Krig.Amatrix,3,0,0,logical,1
+fields,Krig.Amatrix,4,0,0,...,1
+fields,Krig.check.xY,-1,0,0,list<class<`matrix`> | double[]>,1
+fields,Krig.check.xY,-1,0,1,list<class<`matrix`> | double[] | null>,1
+fields,Krig.check.xY,-1,0,2,list<double[] | class<`matrix`>>,1
+fields,Krig.check.xY,-1,0,3,list<double[] | class<`matrix`> | null>,1
+fields,Krig.check.xY,0,0,0,class<`data.frame`>,1
+fields,Krig.check.xY,0,0,1,class<`matrix`>,1
+fields,Krig.check.xY,0,0,2,double[],1
+fields,Krig.check.xY,1,0,0,class<`matrix`>,1
+fields,Krig.check.xY,1,0,1,^double[],1
+fields,Krig.check.xY,2,0,0,double[],1
+fields,Krig.check.xY,2,0,1,class<`matrix`>,1
+fields,Krig.check.xY,2,0,2,null,1
+fields,Krig.check.xY,3,0,0,null,1
+fields,Krig.check.xY,3,0,1,double[],1
+fields,Krig.check.xY,4,0,0,logical,1
+fields,Krig.check.xY,5,0,0,logical,1
+fields,Krig.coef,-1,0,0,list<class<`matrix`> | double>,1
+fields,Krig.coef,-1,0,1,list<class<`matrix`> | null | double>,1
+fields,Krig.coef,-1,0,2,list<double[]>,1
+fields,Krig.coef,-1,0,3,list<double[] | null>,1
+fields,Krig.coef,0,0,0,class<`Krig`>,1
+fields,Krig.coef,0,0,1,"class<`Krig`, `Tps`>",1
+fields,Krig.coef,0,0,2,list<any>,1
+fields,Krig.coef,1,0,0,double,1
+fields,Krig.coef,2,0,0,double[],1
+fields,Krig.coef,2,0,1,class<`matrix`>,1
+fields,Krig.coef,2,0,2,null,1
+fields,Krig.coef,3,0,0,null,1
+fields,Krig.coef,3,0,1,class<`matrix`>,1
+fields,Krig.coef,3,0,2,double[],1
+fields,Krig.coef,4,0,0,logical,1
+fields,Krig.df.to.lambda,-1,0,0,double,1
+fields,Krig.df.to.lambda,0,0,0,double,1
+fields,Krig.df.to.lambda,1,0,0,double[],1
+fields,Krig.df.to.lambda,2,0,0,double,1
+fields,Krig.df.to.lambda,3,0,0,double,1
+fields,Krig.engine.default,-1,0,0,list<any>,1
+fields,Krig.engine.default,0,0,0,class<`Krig`>,1
+fields,Krig.engine.default,0,0,1,list<any>,1
+fields,Krig.engine.default,1,0,0,logical,1
+fields,Krig.engine.fixed,-1,0,0,list<any>,1
+fields,Krig.engine.fixed,0,0,0,list<any>,1
+fields,Krig.engine.fixed,1,0,0,any,1
+fields,Krig.engine.fixed,2,0,0,null,1
+fields,Krig.engine.knots,-1,0,0,list<any>,1
+fields,Krig.engine.knots,0,0,0,list<any>,1
+fields,Krig.engine.knots,1,0,0,logical,1
+fields,Krig.fgcv,-1,0,0,double,1
+fields,Krig.fgcv,0,0,0,double,1
+fields,Krig.fgcv,1,0,0,list<double | list<double[] | class<`matrix`>>>,1
+fields,Krig.fgcv,1,0,1,list<double | null | list<double[] | class<`matrix`>>>,1
+fields,Krig.fgcv,1,0,2,list<double | list<double[]>>,1
+fields,Krig.fgcv,1,0,3,list<double | null | list<double[]>>,1
+fields,Krig.fgcv,1,0,4,class<`Krig`>,1
+fields,Krig.fgcv.model,-1,0,0,double,1
+fields,Krig.fgcv.model,-1,0,1,null,1
+fields,Krig.fgcv.model,0,0,0,double,1
+fields,Krig.fgcv.model,1,0,0,list<double | list<double[] | class<`matrix`>>>,1
+fields,Krig.fgcv.model,1,0,1,list<double | list<double[]>>,1
+fields,Krig.fgcv.model,1,0,2,class<`Krig`>,1
+fields,Krig.fgcv.model,1,0,3,list<double | null | list<double[] | class<`matrix`>>>,1
+fields,Krig.fgcv.model,1,0,4,list<double | null | list<double[]>>,1
+fields,Krig.fgcv.one,-1,0,0,double,1
+fields,Krig.fgcv.one,0,0,0,double,1
+fields,Krig.fgcv.one,1,0,0,list<double | list<double[] | class<`matrix`>>>,1
+fields,Krig.fgcv.one,1,0,1,list<double | null | list<double[] | class<`matrix`>>>,1
+fields,Krig.fgcv.one,1,0,2,list<double | list<double[]>>,1
+fields,Krig.fgcv.one,1,0,3,list<double | null | list<double[]>>,1
+fields,Krig.fgcv.one,1,0,4,class<`Krig`>,1
+fields,Krig.flplike,-1,0,0,double,1
+fields,Krig.flplike,0,0,0,double,1
+fields,Krig.flplike,1,0,0,list<double | null | list<double[] | class<`matrix`>>>,1
+fields,Krig.flplike,1,0,1,list<double | list<double[]>>,1
+fields,Krig.flplike,1,0,2,list<double | null | list<double[]>>,1
+fields,Krig.flplike,1,0,3,class<`Krig`>,1
+fields,Krig.flplike,1,0,4,list<double | list<double[] | class<`matrix`>>>,1
+fields,Krig.fs2hat,-1,0,0,double,1
+fields,Krig.fs2hat,0,0,0,double,1
+fields,Krig.fs2hat,1,0,0,list<double | list<double[] | class<`matrix`>>>,1
+fields,Krig.fs2hat,1,0,1,list<double | list<double[]>>,1
+fields,Krig.fs2hat,1,0,2,list<double | null | list<double[] | class<`matrix`>>>,1
+fields,Krig.fs2hat,1,0,3,list<double | null | list<double[]>>,1
+fields,Krig.ftrace,-1,0,0,double,1
+fields,Krig.ftrace,0,0,0,double,1
+fields,Krig.ftrace,1,0,0,double[],1
+fields,Krig.make.u,-1,0,0,list<class<`matrix`> | null | double>,1
+fields,Krig.make.u,0,0,0,"class<`Krig`, `Tps`>",1
+fields,Krig.make.u,1,0,0,double[],1
+fields,Krig.make.u,2,0,0,null,1
+fields,Krig.make.u,3,0,0,logical,1
+fields,Krig.make.W,-1,0,0,list<class<`matrix`>>,1
+fields,Krig.make.W,-1,0,1,list<double[]>,1
+fields,Krig.make.W,-1,0,2,list<null>,1
+fields,Krig.make.W,0,0,0,list<any>,1
+fields,Krig.make.W,1,0,0,logical,1
+fields,Krig.make.Wi,-1,0,0,list<class<`matrix`>>,1
+fields,Krig.make.Wi,-1,0,1,list<double[]>,1
+fields,Krig.make.Wi,0,0,0,class<`Krig`>,1
+fields,Krig.make.Wi,0,0,1,"class<`Krig`, `Tps`>",1
+fields,Krig.make.Wi,1,0,0,any,1
+fields,Krig.null.function,-1,0,0,class<`matrix`>,1
+fields,Krig.null.function,0,0,0,class<`matrix`>,1
+fields,Krig.null.function,1,0,0,class<`matrix`>,1
+fields,Krig.null.function,1,0,1,double[],1
+fields,Krig.null.function,1,0,2,null,1
+fields,Krig.null.function,2,0,0,logical,1
+fields,Krig.null.function,3,0,0,double,1
+fields,Krig.parameters,-1,0,0,list<double>,1
+fields,Krig.parameters,-1,0,1,list<double | null>,1
+fields,Krig.parameters,-1,0,2,list<null | double>,1
+fields,Krig.parameters,-1,0,3,list<null>,1
+fields,Krig.parameters,0,0,0,list<any>,1
+fields,Krig.parameters,1,0,0,logical,1
+fields,Krig.replicates,-1,0,0,list<class<`matrix`> | double[] | null>,1
+fields,Krig.replicates,-1,0,1,list<class<`matrix`> | null | double[]>,1
+fields,Krig.replicates,0,0,0,list<any>,1
+fields,Krig.replicates,0,0,1,null,1
+fields,Krig.replicates,1,0,0,any,1
+fields,Krig.replicates,2,0,0,any,1
+fields,Krig.replicates,3,0,0,null,1
+fields,Krig.replicates,4,0,0,any,1
+fields,Krig.replicates,5,0,0,logical,1
+fields,Krig.transform.xY,-1,0,0,list<any>,1
+fields,Krig.transform.xY,0,0,0,list<any>,1
+fields,Krig.transform.xY,1,0,0,null,1
+fields,Krig.transform.xY,1,0,1,class<`matrix`>,1
+fields,Krig.transform.xY,2,0,0,logical,1
+fields,Krig.which.lambda,-1,0,0,list<character | null | double>,1
+fields,Krig.which.lambda,-1,0,1,list<character | null | logical>,1
+fields,Krig.which.lambda,0,0,0,list<any>,1
+fields,Krig.ynew,-1,0,0,list<class<`matrix`> | double>,1
+fields,Krig.ynew,-1,0,1,list<class<`matrix`> | null | double>,1
+fields,Krig.ynew,0,0,0,any,1
+fields,Krig.ynew,1,0,0,double[],1
+fields,Krig.ynew,1,0,1,null,1
+fields,Krig.ynew,1,0,2,class<`matrix`>,1
+fields,Krig.ynew,2,0,0,null,1
+fields,Krig.ynew,2,0,1,class<`matrix`>,1
+fields,Krig.ynew,2,0,2,double[],1
+fields,larry.colors,-1,0,0,character[],1
+fields,make.surface.grid,-1,0,0,class<`matrix`>,1
+fields,make.surface.grid,0,0,0,list<double[]>,1
+fields,make.surface.grid,0,0,1,list<integer[] | double>,1
+fields,Matern,-1,0,0,class<`dist`>,1
+fields,Matern,-1,0,1,class<`matrix`>,1
+fields,Matern,-1,0,2,double[],1
+fields,Matern,0,0,0,class<`dist`>,1
+fields,Matern,0,0,1,class<`matrix`>,1
+fields,Matern,0,0,2,double[],1
+fields,Matern,1,0,0,double,1
+fields,Matern,2,0,0,double,1
+fields,Matern,3,0,0,double,1
+fields,Matern,4,0,0,double,1
+fields,Matern,5,0,0,double,1
+fields,Matern.cor.to.range,-1,0,0,double,1
+fields,Matern.cor.to.range,0,0,0,double,1
+fields,Matern.cor.to.range,1,0,0,double,1
+fields,Matern.cor.to.range,2,0,0,double,1
+fields,Matern.cor.to.range,3,0,0,null,1
+fields,Matern.cor.to.range,4,0,0,...,1
+fields,matern.image.cov,-1,0,0,class<`matrix`>,1
+fields,matern.image.cov,-1,0,1,list<any>,1
+fields,matern.image.cov,0,0,0,any,1
+fields,matern.image.cov,1,0,0,any,1
+fields,matern.image.cov,2,0,0,any,1
+fields,matern.image.cov,3,0,0,list<any>,1
+fields,matern.image.cov,3,0,1,null,1
+fields,matern.image.cov,4,0,0,logical,1
+fields,matern.image.cov,5,0,0,any,1
+fields,matern.image.cov,6,0,0,null,1
+fields,matern.image.cov,7,0,0,null,1
+fields,MaternQRProfile.test,-1,0,0,list<class<`Krig`> | double[] | list<double | integer[] | character>>,1
+fields,MaternQRProfile.test,0,0,0,class<`matrix`>,1
+fields,MaternQRProfile.test,1,0,0,double[],1
+fields,MaternQRProfile.test,2,0,0,double,1
+fields,MaternQRProfile.test,3,0,0,double,1
+fields,MaternQR.test,-1,0,0,list<double[] | class<`matrix`> | list<double[] | character>>,1
+fields,MaternQR.test,0,0,0,class<`matrix`>,1
+fields,MaternQR.test,1,0,0,double[],1
+fields,MaternQR.test,2,0,0,double,1
+fields,MaternQR.test,3,0,0,double[],1
+fields,mKrig,-1,0,0,class<`mKrig`>,1
+fields,mKrig,0,0,0,class<`data.frame`>,1
+fields,mKrig,0,0,1,class<`matrix`>,1
+fields,mKrig,1,0,0,class<`matrix`>,1
+fields,mKrig,1,0,1,^double[],1
+fields,mKrig,2,0,0,double[],1
+fields,mKrig,3,0,0,double[],1
+fields,mKrig,3,0,1,null,1
+fields,mKrig,3,0,2,class<`matrix`>,1
+fields,mKrig,4,0,0,character,1
+fields,mKrig,4,0,1,class<`function`>,1
+fields,mKrig,5,0,0,null,1
+fields,mKrig,5,0,1,list<any>,1
+fields,mKrig,6,0,0,double,1
+fields,mKrig,7,0,0,double,1
+fields,mKrigCheckXY,-1,0,0,list<class<`matrix`> | double[]>,1
+fields,mKrigCheckXY,-1,0,1,list<class<`matrix`> | double[] | null>,1
+fields,mKrigCheckXY,-1,0,2,list<double[] | class<`matrix`> | null>,1
+fields,mKrigCheckXY,0,0,0,class<`matrix`>,1
+fields,mKrigCheckXY,0,0,1,class<`data.frame`>,1
+fields,mKrigCheckXY,1,0,0,class<`matrix`>,1
+fields,mKrigCheckXY,1,0,1,^double[],1
+fields,mKrigCheckXY,2,0,0,double[],1
+fields,mKrigCheckXY,3,0,0,class<`matrix`>,1
+fields,mKrigCheckXY,3,0,1,double[],1
+fields,mKrigCheckXY,3,0,2,null,1
+fields,mKrigCheckXY,4,0,0,logical,1
+fields,mKrig.coef,-1,0,0,list<class<`matrix`>>,1
+fields,mKrig.coef,0,0,0,"class<`fastTps`, `mKrig`>",1
+fields,mKrig.coef,0,0,1,class<`mKrig`>,1
+fields,mKrig.coef,0,0,2,list<any>,1
+fields,mKrig.coef,1,0,0,class<`matrix`>,1
+fields,mKrig.coef,1,0,1,double[],1
+fields,mKrig.coef,2,0,0,logical,1
+fields,mKrig.MLE,-1,0,0,list<any>,1
+fields,mKrig.MLE,0,0,0,class<`matrix`>,1
+fields,mKrig.MLE,1,0,0,double[],1
+fields,mKrig.MLE,1,0,1,class<`matrix`>,1
+fields,mKrig.MLE,2,0,0,double[],1
+fields,mKrig.MLE,3,0,0,character,1
+fields,mKrig.MLE,4,0,0,null,1
+fields,mKrig.MLE,4,0,1,list<character>,1
+fields,mKrig.MLE,5,0,0,null,1
+fields,mKrig.MLE,6,0,0,null,1
+fields,mKrig.MLE,6,0,1,list<double[]>,1
+fields,mKrig.MLE,7,0,0,null,1
+fields,mKrig.MLE,7,0,1,double,1
+fields,mKrigMLEGrid,-1,0,0,list<any>,1
+fields,mKrigMLEGrid,0,0,0,class<`matrix`>,1
+fields,mKrigMLEGrid,1,0,0,class<`matrix`>,1
+fields,mKrigMLEGrid,1,0,1,^double[],1
+fields,mKrigMLEGrid,2,0,0,double[],1
+fields,mKrigMLEGrid,3,0,0,null,1
+fields,mKrigMLEGrid,4,0,0,list<double>,1
+fields,mKrigMLEGrid,4,0,1,null,1
+fields,mKrigMLEGrid,5,0,0,character,1
+fields,mKrigMLEGrid,6,0,0,list<character | double>,1
+fields,mKrigMLEGrid,7,0,0,logical,1
+fields,mKrig.MLE.joint,-1,0,0,class<`mKrig`>,1
+fields,mKrig.MLE.joint,0,0,0,class<`matrix`>,1
+fields,mKrig.MLE.joint,1,0,0,double[],1
+fields,mKrig.MLE.joint,2,0,0,double[],1
+fields,mKrig.MLE.joint,3,0,0,double,1
+fields,mKrig.MLE.joint,4,0,0,list<double>,1
+fields,mKrig.MLE.joint,5,0,0,character,1
+fields,mKrig.MLE.joint,6,0,0,list<character | double>,1
+fields,mKrig.MLE.joint,7,0,0,null,1
+fields,mKrigMLEJoint,-1,0,0,list<any>,1
+fields,mKrigMLEJoint,0,0,0,class<`matrix`>,1
+fields,mKrigMLEJoint,1,0,0,class<`matrix`>,1
+fields,mKrigMLEJoint,1,0,1,^double[],1
+fields,mKrigMLEJoint,2,0,0,double[],1
+fields,mKrigMLEJoint,3,0,0,null,1
+fields,mKrigMLEJoint,4,0,0,null,1
+fields,mKrigMLEJoint,4,0,1,list<double>,1
+fields,mKrigMLEJoint,5,0,0,logical,1
+fields,mKrigMLEJoint,6,0,0,character,1
+fields,mKrigMLEJoint,7,0,0,list<any>,1
+fields,mKrig.trace,-1,0,0,list<double[]>,1
+fields,mKrig.trace,-1,0,1,list<null | double>,1
+fields,mKrig.trace,0,0,0,class<`mKrig`>,1
+fields,mKrig.trace,0,0,1,list<any>,1
+fields,mKrig.trace,1,0,0,double,1
+fields,mKrig.trace,2,0,0,double,1
+fields,MLE.Matern,-1,0,0,list<any>,1
+fields,MLE.Matern,0,0,0,class<`data.frame`>,1
+fields,MLE.Matern,0,0,1,class<`matrix`>,1
+fields,MLE.Matern,1,0,0,^double[],1
+fields,MLE.Matern,2,0,0,double,1
+fields,MLE.Matern,3,0,0,null,1
+fields,MLE.Matern,4,0,0,double,1
+fields,MLE.Matern,5,0,0,logical,1
+fields,MLE.Matern,6,0,0,double,1
+fields,MLE.Matern,7,0,0,double,1
+fields,MLESpatialProcess,-1,0,0,list<any>,1
+fields,MLESpatialProcess,0,0,0,class<`matrix`>,1
+fields,MLESpatialProcess,1,0,0,class<`matrix`>,1
+fields,MLESpatialProcess,1,0,1,^double[],1
+fields,MLESpatialProcess,2,0,0,double[],1
+fields,MLESpatialProcess,3,0,0,null,1
+fields,MLESpatialProcess,4,0,0,list<double>,1
+fields,MLESpatialProcess,5,0,0,character,1
+fields,MLESpatialProcess,6,0,0,list<character | double>,1
+fields,MLESpatialProcess,7,0,0,double,1
+fields,multWendlandGrid,-1,0,0,double[],1
+fields,multWendlandGrid,0,0,0,list<double[]>,1
+fields,multWendlandGrid,1,0,0,class<`matrix`>,1
+fields,multWendlandGrid,2,0,0,double,1
+fields,multWendlandGrid,3,0,0,class<`matrix`>,1
+fields,multWendlandGrid,3,0,1,double[],1
+fields,multWendlandGrid,4,0,0,double[],1
+fields,parse.grid.list,-1,0,0,list<double[] | character>,1
+fields,parse.grid.list,0,0,0,list<double[]>,1
+fields,parse.grid.list,1,0,0,character,1
+fields,plot.Krig,-1,0,0,class<`histogram`>,1
+fields,plot.Krig,0,0,0,class<`Krig`>,1
+fields,plot.Krig,0,0,1,"class<`Krig`, `Tps`>",1
+fields,plot.Krig,1,0,0,double,1
+fields,plot.Krig,2,0,0,integer[],1
+fields,plot.Krig,3,0,0,...,1
+fields,plot.qsreg,-1,0,0,null,1
+fields,plot.qsreg,0,0,0,class<`qsreg`>,1
+fields,plot.qsreg,1,0,0,character,1
+fields,plot.qsreg,2,0,0,null,1
+fields,plot.qsreg,3,0,0,...,1
+fields,plot.spatialDesign,-1,0,0,null,1
+fields,plot.spatialDesign,0,0,0,class<`spatialDesign`>,1
+fields,plot.spatialDesign,1,0,0,...,1
+fields,plot.spatialProcess,-1,0,0,null,1
+fields,plot.spatialProcess,0,0,0,"class<`mKrig`, `spatialProcess`>",1
+fields,plot.spatialProcess,1,0,0,double,1
+fields,plot.spatialProcess,2,0,0,integer[],1
+fields,plot.spatialProcess,3,0,0,...,1
+fields,plot.sreg,-1,0,0,class<`histogram`>,1
+fields,plot.sreg,0,0,0,class<`sreg`>,1
+fields,plot.sreg,1,0,0,double,1
+fields,plot.sreg,2,0,0,integer[],1
+fields,plot.sreg,3,0,0,...,1
+fields,plot.surface,-1,0,0,null,1
+fields,plot.surface,0,0,0,list<double[] | character | class<`matrix`>>,1
+fields,plot.surface,0,0,1,list<double[] | class<`matrix`>>,1
+fields,plot.surface,1,0,0,null,1
+fields,plot.surface,2,0,0,character,1
+fields,plot.surface,3,0,0,null,1
+fields,plot.surface,4,0,0,null,1
+fields,plot.surface,5,0,0,null,1
+fields,plot.surface,6,0,0,any,1
+fields,plot.surface,7,0,0,null,1
+fields,plot.vgram,-1,0,0,null,1
+fields,plot.vgram,0,0,0,"class<`list`, `vgram`>",1
+fields,plot.vgram,1,0,0,double,1
+fields,plot.vgram,2,0,0,double[],1
+fields,plot.vgram,3,0,0,logical,1
+fields,plot.vgram,4,0,0,...,1
+fields,plot.vgram.matrix,-1,0,0,null,1
+fields,plot.vgram.matrix,0,0,0,class<`vgram.matrix`>,1
+fields,plot.vgram.matrix,1,0,0,...,1
+fields,poly.image,-1,0,0,null,1
+fields,poly.image,0,0,0,class<`matrix`>,1
+fields,poly.image,1,0,0,class<`matrix`>,1
+fields,poly.image,2,0,0,class<`matrix`>,1
+fields,poly.image,3,0,0,character[],1
+fields,poly.image,4,0,0,any,1
+fields,poly.image,5,0,0,character,1
+fields,poly.image,6,0,0,logical,1
+fields,poly.image,7,0,0,double[],1
+fields,poly.image.regrid,-1,0,0,class<`matrix`>,1
+fields,poly.image.regrid,0,0,0,class<`matrix`>,1
+fields,predictDerivative.Krig,-1,0,0,class<`matrix`>,1
+fields,predictDerivative.Krig,0,0,0,class<`Krig`>,1
+fields,predictDerivative.Krig,0,0,1,"class<`Krig`, `Tps`>",1
+fields,predictDerivative.Krig,1,0,0,class<`matrix`>,1
+fields,predictDerivative.Krig,1,0,1,null,1
+fields,predictDerivative.Krig,2,0,0,logical,1
+fields,predictDerivative.Krig,3,0,0,...,1
+fields,predict.fastTps,-1,0,0,class<`matrix`>,1
+fields,predict.fastTps,0,0,0,"class<`fastTps`, `mKrig`>",1
+fields,predict.fastTps,1,0,0,class<`matrix`>,1
+fields,predict.fastTps,1,0,1,null,1
+fields,predict.fastTps,2,0,0,null,1
+fields,predict.fastTps,2,0,1,list<double[]>,1
+fields,predict.fastTps,3,0,0,null,1
+fields,predict.fastTps,3,0,1,double[],1
+fields,predict.fastTps,4,0,0,double,1
+fields,predict.fastTps,5,0,0,null,1
+fields,predict.fastTps,6,0,0,logical,1
+fields,predict.fastTps,7,0,0,logical,1
+fields,predict.Krig,-1,0,0,class<`matrix`>,1
+fields,predict.Krig,0,0,0,class<`Krig`>,1
+fields,predict.Krig,0,0,1,list<any>,1
+fields,predict.Krig,0,0,2,"class<`Krig`, `Tps`>",1
+fields,predict.Krig,1,0,0,null,1
+fields,predict.Krig,1,0,1,class<`matrix`>,1
+fields,predict.Krig,1,0,2,class<`data.frame`>,1
+fields,predict.Krig,2,0,0,null,1
+fields,predict.Krig,2,0,1,class<`matrix`>,1
+fields,predict.Krig,2,0,2,double[],1
+fields,predict.Krig,3,0,0,logical,1
+fields,predict.Krig,4,0,0,logical,1
+fields,predict.Krig,5,0,0,null,1
+fields,predict.Krig,5,0,1,double,1
+fields,predict.Krig,6,0,0,null,1
+fields,predict.Krig,6,0,1,double,1
+fields,predict.Krig,7,0,0,null,1
+fields,predict.mKrig,-1,0,0,class<`matrix`>,1
+fields,predict.mKrig,0,0,0,"class<`fastTps`, `mKrig`>",1
+fields,predict.mKrig,0,0,1,class<`mKrig`>,1
+fields,predict.mKrig,0,0,2,list<any>,1
+fields,predict.mKrig,0,0,3,"class<`mKrig`, `spatialProcess`>",1
+fields,predict.mKrig,1,0,0,class<`matrix`>,1
+fields,predict.mKrig,1,0,1,null,1
+fields,predict.mKrig,1,0,2,class<`data.frame`>,1
+fields,predict.mKrig,2,0,0,null,1
+fields,predict.mKrig,2,0,1,class<`matrix`>,1
+fields,predict.mKrig,3,0,0,null,1
+fields,predict.mKrig,4,0,0,double,1
+fields,predict.mKrig,5,0,0,null,1
+fields,predict.mKrig,5,0,1,double[],1
+fields,predict.mKrig,6,0,0,logical,1
+fields,predict.mKrig,7,0,0,logical,1
+fields,predict.qsreg,-1,0,0,double[],1
+fields,predict.qsreg,0,0,0,class<`qsreg`>,1
+fields,predict.qsreg,1,0,0,any,1
+fields,predict.qsreg,2,0,0,double,1
+fields,predict.qsreg,3,0,0,integer,1
+fields,predict.qsreg,4,0,0,...,1
+fields,predictSE,-1,0,0,class<`matrix`>,1
+fields,predictSE,-1,0,1,double[],1
+fields,predictSE,0,0,0,class<`Krig`>,1
+fields,predictSE,0,0,1,"class<`Krig`, `Tps`>",1
+fields,predictSE,0,0,2,class<`mKrig`>,1
+fields,predictSE,1,0,0,...,1
+fields,predictSE.Krig,-1,0,0,double[],1
+fields,predictSE.Krig,-1,0,1,class<`matrix`>,1
+fields,predictSE.Krig,0,0,0,class<`Krig`>,1
+fields,predictSE.Krig,0,0,1,"class<`Krig`, `Tps`>",1
+fields,predictSE.Krig,1,0,0,null,1
+fields,predictSE.Krig,1,0,1,class<`matrix`>,1
+fields,predictSE.Krig,2,0,0,logical,1
+fields,predictSE.Krig,3,0,0,logical,1
+fields,predictSE.Krig,4,0,0,...,1
+fields,predictSE.mKrig,-1,0,0,double[],1
+fields,predictSE.mKrig,0,0,0,class<`mKrig`>,1
+fields,predictSE.mKrig,1,0,0,class<`matrix`>,1
+fields,predictSE.mKrig,1,0,1,null,1
+fields,predictSE.mKrig,2,0,0,null,1
+fields,predictSE.mKrig,3,0,0,logical,1
+fields,predictSE.mKrig,4,0,0,logical,1
+fields,predictSE.mKrig,5,0,0,...,1
+fields,predict.sreg,-1,0,0,double[],1
+fields,predict.sreg,0,0,0,class<`sreg`>,1
+fields,predict.sreg,1,0,0,any,1
+fields,predict.sreg,2,0,0,double,1
+fields,predict.sreg,3,0,0,double,1
+fields,predict.sreg,4,0,0,...,1
+fields,predictSurface,-1,0,0,list<double[] | character | class<`matrix`>>,1
+fields,predictSurface,0,0,0,class<`Krig`>,1
+fields,predictSurface,0,0,1,"class<`Krig`, `Tps`>",1
+fields,predictSurface,0,0,2,class<`mKrig`>,1
+fields,predictSurface,0,0,3,"class<`mKrig`, `spatialProcess`>",1
+fields,predictSurface,0,0,4,"class<`fastTps`, `mKrig`>",1
+fields,predictSurface,1,0,0,...,1
+fields,predictSurface.fastTps,-1,0,0,list<double[] | character | class<`matrix`>>,1
+fields,predictSurface.fastTps,0,0,0,"class<`fastTps`, `mKrig`>",1
+fields,predictSurface.fastTps,1,0,0,list<double[]>,1
+fields,predictSurface.fastTps,2,0,0,logical,1
+fields,predictSurface.fastTps,3,0,0,null,1
+fields,predictSurface.fastTps,4,0,0,double,1
+fields,predictSurface.fastTps,5,0,0,double,1
+fields,predictSurface.fastTps,6,0,0,double[],1
+fields,predictSurface.fastTps,7,0,0,logical,1
+fields,predictSurface.Krig,-1,0,0,list<double[] | character | class<`matrix`>>,1
+fields,predictSurface.Krig,0,0,0,class<`mKrig`>,1
+fields,predictSurface.Krig,0,0,1,"class<`mKrig`, `spatialProcess`>",1
+fields,predictSurface.Krig,0,0,2,class<`Krig`>,1
+fields,predictSurface.Krig,0,0,3,"class<`Krig`, `Tps`>",1
+fields,predictSurface.Krig,1,0,0,null,1
+fields,predictSurface.Krig,1,0,1,list<double[]>,1
+fields,predictSurface.Krig,2,0,0,logical,1
+fields,predictSurface.Krig,3,0,0,null,1
+fields,predictSurface.Krig,4,0,0,any,1
+fields,predictSurface.Krig,5,0,0,any,1
+fields,predictSurface.Krig,6,0,0,any,1
+fields,predictSurface.Krig,7,0,0,logical,1
+fields,predictSurface.mKrig,-1,0,0,list<double[] | character | class<`matrix`>>,1
+fields,predictSurface.mKrig,0,0,0,class<`mKrig`>,1
+fields,predictSurface.mKrig,0,0,1,"class<`mKrig`, `spatialProcess`>",1
+fields,predictSurface.mKrig,1,0,0,...,1
+fields,predictSurfaceSE,-1,0,0,list<double[] | character | class<`matrix`>>,1
+fields,predictSurfaceSE,0,0,0,class<`Krig`>,1
+fields,predictSurfaceSE,0,0,1,"class<`Krig`, `Tps`>",1
+fields,predictSurfaceSE,1,0,0,...,1
+fields,predictSurfaceSE.default,-1,0,0,list<double[] | character | class<`matrix`>>,1
+fields,predictSurfaceSE.default,0,0,0,class<`Krig`>,1
+fields,predictSurfaceSE.default,0,0,1,"class<`Krig`, `Tps`>",1
+fields,predictSurfaceSE.default,1,0,0,null,1
+fields,predictSurfaceSE.default,1,0,1,list<double[]>,1
+fields,predictSurfaceSE.default,2,0,0,logical,1
+fields,predictSurfaceSE.default,3,0,0,null,1
+fields,predictSurfaceSE.default,4,0,0,double,1
+fields,predictSurfaceSE.default,5,0,0,double,1
+fields,predictSurfaceSE.default,6,0,0,any,1
+fields,predictSurfaceSE.default,7,0,0,logical,1
+fields,printGCVWarnings,-1,0,0,null,1
+fields,printGCVWarnings,0,0,0,class<`data.frame`>,1
+fields,printGCVWarnings,1,0,0,character,1
+fields,print.Krig,-1,0,0,class<`Krig`>,1
+fields,print.Krig,0,0,0,class<`Krig`>,1
+fields,print.Krig,1,0,0,double,1
+fields,print.Krig,2,0,0,...,1
+fields,print.mKrig,-1,0,0,class<`mKrigSummary`>,1
+fields,print.mKrig,0,0,0,"class<`fastTps`, `mKrig`>",1
+fields,print.mKrig,0,0,1,class<`mKrig`>,1
+fields,print.mKrig,1,0,0,double,1
+fields,print.mKrig,2,0,0,...,1
+fields,print.mKrigSummary,-1,0,0,class<`mKrigSummary`>,1
+fields,print.mKrigSummary,0,0,0,class<`mKrigSummary`>,1
+fields,print.mKrigSummary,1,0,0,any,1
+fields,print.mKrigSummary,2,0,0,...,1
+fields,pushpin,-1,0,0,null,1
+fields,pushpin,0,0,0,double,1
+fields,pushpin,1,0,0,double,1
+fields,pushpin,2,0,0,double,1
+fields,pushpin,3,0,0,class<`matrix`>,1
+fields,pushpin,4,0,0,double,1
+fields,pushpin,5,0,0,character,1
+fields,pushpin,6,0,0,character,1
+fields,pushpin,7,0,0,double,1
+fields,qr.q2ty,-1,0,0,class<`matrix`>,1
+fields,qr.q2ty,-1,0,1,double[],1
+fields,qr.q2ty,0,0,0,class<`qr`>,1
+fields,qr.q2ty,1,0,0,class<`matrix`>,1
+fields,qr.q2ty,1,0,1,double[],1
+fields,qr.yq2,-1,0,0,class<`matrix`>,1
+fields,qr.yq2,0,0,0,class<`qr`>,1
+fields,qr.yq2,1,0,0,class<`matrix`>,1
+fields,qsreg,-1,0,0,class<`qsreg`>,1
+fields,qsreg,0,0,0,double[],1
+fields,qsreg,1,0,0,double[],1
+fields,qsreg,2,0,0,double,1
+fields,qsreg,2,0,1,null,1
+fields,qsreg,3,0,0,double,1
+fields,qsreg,4,0,0,double,1
+fields,qsreg,5,0,0,double,1
+fields,qsreg,6,0,0,double,1
+fields,qsreg,7,0,0,double,1
+fields,qsreg.psi,-1,0,0,class<`matrix`>,1
+fields,qsreg.psi,-1,0,1,double[],1
+fields,qsreg.psi,0,0,0,class<`matrix`>,1
+fields,qsreg.psi,0,0,1,double[],1
+fields,qsreg.psi,1,0,0,double,1
+fields,qsreg.psi,2,0,0,double,1
+fields,qsreg.rho,-1,0,0,class<`matrix`>,1
+fields,qsreg.rho,-1,0,1,double[],1
+fields,qsreg.rho,0,0,0,class<`matrix`>,1
+fields,qsreg.rho,0,0,1,double[],1
+fields,qsreg.rho,1,0,0,double,1
+fields,qsreg.rho,2,0,0,double,1
+fields,qsreg.trace,-1,0,0,double,1
+fields,qsreg.trace,0,0,0,double[],1
+fields,qsreg.trace,1,0,0,double[],1
+fields,qsreg.trace,2,0,0,double,1
+fields,qsreg.trace,3,0,0,double,1
+fields,qsreg.trace,4,0,0,double,1
+fields,qsreg.trace,5,0,0,double,1
+fields,qsreg.trace,6,0,0,double,1
+fields,qsreg.trace,7,0,0,double,1
+fields,QTps,-1,0,0,class<`Krig`>,1
+fields,QTps,0,0,0,class<`matrix`>,1
+fields,QTps,1,0,0,^double[],1
+fields,QTps,2,0,0,...,1
+fields,QTps,3,0,0,class<`matrix`>,1
+fields,QTps,3,0,1,null,1
+fields,QTps,4,0,0,null,1
+fields,QTps,4,0,1,double,1
+fields,QTps,5,0,0,double,1
+fields,QTps,6,0,0,double,1
+fields,QTps,7,0,0,double,1
+fields,quilt.plot,-1,0,0,list<any>,1
+fields,quilt.plot,0,0,0,class<`data.frame`>,1
+fields,quilt.plot,0,0,1,class<`matrix`>,1
+fields,quilt.plot,1,0,0,class<`matrix`>,1
+fields,quilt.plot,1,0,1,^double[],1
+fields,quilt.plot,2,0,0,any,1
+fields,quilt.plot,3,0,0,double,1
+fields,quilt.plot,4,0,0,double,1
+fields,quilt.plot,5,0,0,null,1
+fields,quilt.plot,6,0,0,logical,1
+fields,quilt.plot,7,0,0,logical,1
+fields,radbas.constant,-1,0,0,double,1
+fields,radbas.constant,0,0,0,double,1
+fields,radbas.constant,1,0,0,double,1
+fields,Rad.cov,-1,0,0,class<`matrix`>,1
+fields,Rad.cov,-1,0,1,double[],1
+fields,Rad.cov,0,0,0,class<`matrix`>,1
+fields,Rad.cov,1,0,0,class<`matrix`>,1
+fields,Rad.cov,1,0,1,null,1
+fields,Rad.cov,2,0,0,double,1
+fields,Rad.cov,3,0,0,double,1
+fields,Rad.cov,3,0,1,null,1
+fields,Rad.cov,4,0,0,logical,1
+fields,Rad.cov,5,0,0,logical,1
+fields,Rad.cov,6,0,0,class<`matrix`>,1
+fields,Rad.cov,6,0,1,double[],1
+fields,Rad.cov,6,0,2,null,1
+fields,Rad.cov,7,0,0,logical,1
+fields,RadialBasis,-1,0,0,class<`matrix`>,1
+fields,RadialBasis,0,0,0,class<`matrix`>,1
+fields,RadialBasis,1,0,0,double,1
+fields,RadialBasis,2,0,0,double,1
+fields,RadialBasis,3,0,0,double,1
+fields,rdist,-1,0,0,class<`matrix`>,1
+fields,rdist,-1,0,1,class<`dist`>,1
+fields,rdist,0,0,0,class<`data.frame`>,1
+fields,rdist,0,0,1,class<`matrix`>,1
+fields,rdist,0,0,2,double[],1
+fields,rdist,1,0,0,class<`data.frame`>,1
+fields,rdist,1,0,1,class<`matrix`>,1
+fields,rdist,1,0,2,null,1
+fields,rdist,1,0,3,double[],1
+fields,rdist,2,0,0,logical,1
+fields,rdist.earth,-1,0,0,class<`matrix`>,1
+fields,rdist.earth,0,0,0,class<`matrix`>,1
+fields,rdist.earth,1,0,0,class<`matrix`>,1
+fields,rdist.earth,1,0,1,null,1
+fields,rdist.earth,2,0,0,logical,1
+fields,rdist.earth,3,0,0,null,1
+fields,RdistEarth,-1,0,0,class<`matrix`>,1
+fields,RdistEarth,0,0,0,class<`matrix`>,1
+fields,RdistEarth,1,0,0,null,1
+fields,RdistEarth,2,0,0,logical,1
+fields,RdistEarth,3,0,0,null,1
+fields,rdist.earth.vec,-1,0,0,double[],1
+fields,rdist.earth.vec,0,0,0,class<`matrix`>,1
+fields,rdist.earth.vec,1,0,0,class<`matrix`>,1
+fields,rdist.earth.vec,2,0,0,logical,1
+fields,rdist.earth.vec,3,0,0,null,1
+fields,rdist.vec,-1,0,0,double[],1
+fields,rdist.vec,0,0,0,integer[],1
+fields,rdist.vec,1,0,0,integer[],1
+fields,REML.test,-1,0,0,list<class<`matrix`> | double>,1
+fields,REML.test,0,0,0,class<`matrix`>,1
+fields,REML.test,1,0,0,double[],1
+fields,REML.test,2,0,0,double,1
+fields,REML.test,3,0,0,double,1
+fields,REML.test,4,0,0,double,1
+fields,REML.test,5,0,0,double,1
+fields,ribbon.plot,-1,0,0,null,1
+fields,ribbon.plot,0,0,0,double[],1
+fields,ribbon.plot,1,0,0,double[],1
+fields,ribbon.plot,2,0,0,double[],1
+fields,ribbon.plot,3,0,0,null,1
+fields,ribbon.plot,4,0,0,character[],1
+fields,ribbon.plot,5,0,0,character,1
+fields,ribbon.plot,6,0,0,...,1
+fields,set.panel,-1,0,0,null,1
+fields,set.panel,0,0,0,double,1
+fields,set.panel,1,0,0,double,1
+fields,set.panel,2,0,0,logical,1
+fields,setup.image.smooth,-1,0,0,list<any>,1
+fields,setup.image.smooth,0,0,0,double,1
+fields,setup.image.smooth,1,0,0,double,1
+fields,setup.image.smooth,2,0,0,double,1
+fields,setup.image.smooth,3,0,0,double,1
+fields,setup.image.smooth,4,0,0,class<`function`>,1
+fields,setup.image.smooth,5,0,0,double,1
+fields,setup.image.smooth,6,0,0,double,1
+fields,setup.image.smooth,7,0,0,double,1
+fields,sim.Krig,-1,0,0,class<`matrix`>,1
+fields,sim.Krig,0,0,0,class<`Krig`>,1
+fields,sim.Krig,1,0,0,class<`matrix`>,1
+fields,sim.Krig,2,0,0,double,1
+fields,sim.Krig,3,0,0,logical,1
+fields,sim.Krig,4,0,0,...,1
+fields,sim.Krig.approx,-1,0,0,list<double[] | class<`array`>>,1
+fields,sim.Krig.approx,0,0,0,class<`Krig`>,1
+fields,sim.Krig.approx,1,0,0,null,1
+fields,sim.Krig.approx,2,0,0,double,1
+fields,sim.Krig.approx,3,0,0,double,1
+fields,sim.Krig.approx,4,0,0,double,1
+fields,sim.Krig.approx,5,0,0,logical,1
+fields,sim.Krig.approx,6,0,0,logical,1
+fields,sim.Krig.approx,7,0,0,...,1
+fields,sim.rf,-1,0,0,class<`matrix`>,1
+fields,sim.rf,0,0,0,list<any>,1
+fields,smooth.2d,-1,0,0,list<double[] | class<`matrix`> | null>,1
+fields,smooth.2d,0,0,0,double[],1
+fields,smooth.2d,1,0,0,null,1
+fields,smooth.2d,2,0,0,null,1
+fields,smooth.2d,3,0,0,logical,1
+fields,smooth.2d,4,0,0,null,1
+fields,smooth.2d,5,0,0,class<`data.frame`>,1
+fields,smooth.2d,6,0,0,double,1
+fields,smooth.2d,7,0,0,double,1
+fields,snow.colors,-1,0,0,character[],1
+fields,snow.colors,0,0,0,double,1
+fields,snow.colors,1,0,0,double,1
+fields,spam2full,-1,0,0,class<`matrix`>,1
+fields,spam2full,0,0,0,class<`spam`>,1
+fields,spam2spind,-1,0,0,list<class<`matrix`> | double[]>,1
+fields,spam2spind,0,0,0,class<`spam`>,1
+fields,spatialProcess,-1,0,0,"class<`mKrig`, `spatialProcess`>",1
+fields,spatialProcess,0,0,0,class<`matrix`>,1
+fields,spatialProcess,1,0,0,^double[],1
+fields,spatialProcess,2,0,0,double[],1
+fields,spatialProcess,3,0,0,null,1
+fields,spatialProcess,4,0,0,list<double>,1
+fields,spatialProcess,5,0,0,character,1
+fields,spatialProcess,6,0,0,list<character | double>,1
+fields,spatialProcess,7,0,0,double,1
+fields,spatialProcess,7,0,1,null,1
+fields,spind2full,-1,0,0,class<`matrix`>,1
+fields,spind2full,0,0,0,list<class<`matrix`> | double[]>,1
+fields,spind2spam,-1,0,0,class<`spam`>,1
+fields,spind2spam,0,0,0,list<class<`matrix`> | double[]>,1
+fields,spind2spam,1,0,0,logical,1
+fields,splint,-1,0,0,double[],1
+fields,splint,-1,0,1,list<double[]>,1
+fields,splint,0,0,0,class<`matrix`>,1
+fields,splint,0,0,1,double[],1
+fields,splint,1,0,0,double[],1
+fields,splint,2,0,0,any,1
+fields,splint,3,0,0,null,1
+fields,splint,4,0,0,double,1
+fields,splint,5,0,0,double,1
+fields,splint,6,0,0,null,1
+fields,splint,6,0,1,double,1
+fields,splint,7,0,0,null,1
+fields,sreg,-1,0,0,class<`sreg`>,1
+fields,sreg,0,0,0,double[],1
+fields,sreg,1,0,0,double[],1
+fields,sreg,2,0,0,double,1
+fields,sreg,2,0,1,null,1
+fields,sreg,3,0,0,null,1
+fields,sreg,3,0,1,double,1
+fields,sreg,4,0,0,double,1
+fields,sreg,5,0,0,double[],1
+fields,sreg,6,0,0,double,1
+fields,sreg,7,0,0,double,1
+fields,sreg.df.to.lambda,-1,0,0,double,1
+fields,sreg.df.to.lambda,0,0,0,double,1
+fields,sreg.df.to.lambda,1,0,0,class<`matrix`>,1
+fields,sreg.df.to.lambda,1,0,1,double[],1
+fields,sreg.df.to.lambda,2,0,0,double[],1
+fields,sreg.df.to.lambda,3,0,0,double,1
+fields,sreg.df.to.lambda,4,0,0,double,1
+fields,sreg.fit,-1,0,0,list<double>,1
+fields,sreg.fit,-1,0,1,list<double | null>,1
+fields,sreg.fit,0,0,0,double,1
+fields,sreg.fit,1,0,0,class<`sreg`>,1
+fields,sreg.fit,1,0,1,list<class<`matrix`> | null | double[]>,1
+fields,sreg.fit,2,0,0,any,1
+fields,sreg.trace,-1,0,0,double,1
+fields,sreg.trace,0,0,0,double,1
+fields,sreg.trace,1,0,0,list<class<`matrix`> | double[]>,1
+fields,sreg.trace,1,0,1,list<double[]>,1
+fields,stationary.cov,-1,0,0,class<`matrix`>,1
+fields,stationary.cov,-1,0,1,double[],1
+fields,stationary.cov,0,0,0,class<`data.frame`>,1
+fields,stationary.cov,0,0,1,class<`matrix`>,1
+fields,stationary.cov,0,0,2,double[],1
+fields,stationary.cov,1,0,0,class<`matrix`>,1
+fields,stationary.cov,1,0,1,null,1
+fields,stationary.cov,1,0,2,double[],1
+fields,stationary.cov,2,0,0,character,1
+fields,stationary.cov,3,0,0,character,1
+fields,stationary.cov,4,0,0,null,1
+fields,stationary.cov,4,0,1,list<logical>,1
+fields,stationary.cov,5,0,0,double,1
+fields,stationary.cov,6,0,0,null,1
+fields,stationary.cov,6,0,1,class<`matrix`>,1
+fields,stationary.cov,7,0,0,class<`matrix`>,1
+fields,stationary.cov,7,0,1,null,1
+fields,stationary.cov,7,0,2,double[],1
+fields,stationary.image.cov,-1,0,0,class<`matrix`>,1
+fields,stationary.image.cov,-1,0,1,double[],1
+fields,stationary.image.cov,-1,0,2,list<any>,1
+fields,stationary.image.cov,0,0,0,any,1
+fields,stationary.image.cov,1,0,0,any,1
+fields,stationary.image.cov,2,0,0,any,1
+fields,stationary.image.cov,3,0,0,list<any>,1
+fields,stationary.image.cov,3,0,1,null,1
+fields,stationary.image.cov,4,0,0,logical,1
+fields,stationary.image.cov,5,0,0,any,1
+fields,stationary.image.cov,6,0,0,null,1
+fields,stationary.image.cov,7,0,0,null,1
+fields,stationary.taper.cov,-1,0,0,class<`matrix`>,1
+fields,stationary.taper.cov,-1,0,1,class<`spam`>,1
+fields,stationary.taper.cov,0,0,0,class<`matrix`>,1
+fields,stationary.taper.cov,1,0,0,class<`matrix`>,1
+fields,stationary.taper.cov,2,0,0,character,1
+fields,stationary.taper.cov,2,0,1,class<`function`>,1
+fields,stationary.taper.cov,3,0,0,character,1
+fields,stationary.taper.cov,4,0,0,null,1
+fields,stationary.taper.cov,4,0,1,list<character>,1
+fields,stationary.taper.cov,5,0,0,null,1
+fields,stationary.taper.cov,5,0,1,list<double>,1
+fields,stationary.taper.cov,6,0,0,double,1
+fields,stationary.taper.cov,7,0,0,null,1
+fields,stationary.taper.cov,7,0,1,class<`matrix`>,1
+fields,stats,-1,0,0,class<`matrix`>,1
+fields,stats,0,0,0,class<`matrix`>,1
+fields,stats,0,0,1,double[],1
+fields,stats,1,0,0,any,1
+fields,stats.bin,-1,0,0,list<double[] | class<`matrix`>>,1
+fields,stats.bin,0,0,0,double[],1
+fields,stats.bin,1,0,0,double[],1
+fields,stats.bin,2,0,0,double,1
+fields,stats.bin,3,0,0,double[],1
+fields,stats.bin,3,0,1,null,1
+fields,summaryGCV.Krig,-1,0,0,^double[],1
+fields,summaryGCV.Krig,0,0,0,class<`Krig`>,1
+fields,summaryGCV.Krig,0,0,1,"class<`Krig`, `Tps`>",1
+fields,summaryGCV.Krig,1,0,0,double,1
+fields,summaryGCV.Krig,2,0,0,double,1
+fields,summaryGCV.Krig,3,0,0,logical,1
+fields,summaryGCV.Krig,4,0,0,double,1
+fields,summaryGCV.Krig,5,0,0,null,1
+fields,summaryGCV.Krig,6,0,0,...,1
+fields,summaryGCV.sreg,-1,0,0,^double[],1
+fields,summaryGCV.sreg,0,0,0,class<`sreg`>,1
+fields,summaryGCV.sreg,1,0,0,double,1
+fields,summaryGCV.sreg,2,0,0,double,1
+fields,summaryGCV.sreg,3,0,0,double,1
+fields,summaryGCV.sreg,4,0,0,double,1
+fields,summaryGCV.sreg,5,0,0,logical,1
+fields,summaryGCV.sreg,6,0,0,...,1
+fields,summary.Krig,-1,0,0,class<`summary.Krig`>,1
+fields,summary.Krig,0,0,0,class<`Krig`>,1
+fields,summary.Krig,0,0,1,"class<`Krig`, `Tps`>",1
+fields,summary.Krig,1,0,0,double,1
+fields,summary.Krig,2,0,0,...,1
+fields,summary.mKrig,-1,0,0,class<`mKrigSummary`>,1
+fields,summary.mKrig,0,0,0,"class<`fastTps`, `mKrig`>",1
+fields,summary.mKrig,0,0,1,class<`mKrig`>,1
+fields,summary.mKrig,1,0,0,...,1
+fields,summary.spatialDesign,-1,0,0,class<`summarySpatialDesign`>,1
+fields,summary.spatialDesign,0,0,0,class<`spatialDesign`>,1
+fields,summary.spatialDesign,1,0,0,double,1
+fields,summary.spatialDesign,2,0,0,...,1
+fields,summary.spatialProcess,-1,0,0,class<`spatialProcessSummary`>,1
+fields,summary.spatialProcess,0,0,0,"class<`mKrig`, `spatialProcess`>",1
+fields,summary.spatialProcess,1,0,0,...,1
+fields,summary.sreg,-1,0,0,class<`summary.sreg`>,1
+fields,summary.sreg,0,0,0,class<`sreg`>,1
+fields,summary.sreg,1,0,0,double,1
+fields,summary.sreg,2,0,0,...,1
+fields,supportsArg,-1,0,0,logical,1
+fields,supportsArg,0,0,0,character,1
+fields,supportsArg,0,0,1,class<`function`>,1
+fields,supportsArg,1,0,0,character,1
+fields,surface,-1,0,0,null,1
+fields,surface,0,0,0,class<`Krig`>,1
+fields,surface,0,0,1,"class<`Krig`, `Tps`>",1
+fields,surface,0,0,2,class<`mKrig`>,1
+fields,surface,0,0,3,"class<`mKrig`, `spatialProcess`>",1
+fields,surface,0,0,4,list<double[] | character | class<`matrix`>>,1
+fields,surface,1,0,0,...,1
+fields,surface.default,-1,0,0,null,1
+fields,surface.default,0,0,0,list<double[] | character | class<`matrix`>>,1
+fields,surface.default,1,0,0,...,1
+fields,surface.Krig,-1,0,0,null,1
+fields,surface.Krig,0,0,0,class<`Krig`>,1
+fields,surface.Krig,0,0,1,"class<`Krig`, `Tps`>",1
+fields,surface.Krig,0,0,2,class<`mKrig`>,1
+fields,surface.Krig,0,0,3,"class<`mKrig`, `spatialProcess`>",1
+fields,surface.Krig,1,0,0,null,1
+fields,surface.Krig,1,0,1,list<double[]>,1
+fields,surface.Krig,2,0,0,logical,1
+fields,surface.Krig,3,0,0,null,1
+fields,surface.Krig,4,0,0,null,1
+fields,surface.Krig,5,0,0,null,1
+fields,surface.Krig,6,0,0,null,1
+fields,surface.Krig,7,0,0,null,1
+fields,surface.mKrig,-1,0,0,null,1
+fields,surface.mKrig,0,0,0,class<`Krig`>,1
+fields,surface.mKrig,0,0,1,"class<`Krig`, `Tps`>",1
+fields,surface.mKrig,0,0,2,class<`mKrig`>,1
+fields,surface.mKrig,0,0,3,"class<`mKrig`, `spatialProcess`>",1
+fields,surface.mKrig,1,0,0,null,1
+fields,surface.mKrig,1,0,1,list<double[]>,1
+fields,surface.mKrig,2,0,0,logical,1
+fields,surface.mKrig,3,0,0,null,1
+fields,surface.mKrig,4,0,0,null,1
+fields,surface.mKrig,5,0,0,null,1
+fields,surface.mKrig,6,0,0,null,1
+fields,surface.mKrig,7,0,0,null,1
+fields,test.for.zero,-1,0,0,null,1
+fields,test.for.zero,0,0,0,class<`matrix`>,1
+fields,test.for.zero,0,0,1,class<`spam`>,1
+fields,test.for.zero,0,0,2,double[],1
+fields,test.for.zero,0,0,3,null,1
+fields,test.for.zero,1,0,0,class<`matrix`>,1
+fields,test.for.zero,1,0,1,class<`spam`>,1
+fields,test.for.zero,1,0,2,double[],1
+fields,test.for.zero,2,0,0,double,1
+fields,test.for.zero,3,0,0,logical,1
+fields,test.for.zero,4,0,0,character,1
+fields,test.for.zero,4,0,1,null,1
+fields,tim.colors,-1,0,0,character[],1
+fields,tim.colors,0,0,0,double,1
+fields,tim.colors,1,0,0,double,1
+fields,Tps,-1,0,0,"class<`Krig`, `Tps`>",1
+fields,Tps,0,0,0,class<`data.frame`>,1
+fields,Tps,0,0,1,class<`matrix`>,1
+fields,Tps,0,0,2,double[],1
+fields,Tps,1,0,0,^double[],1
+fields,Tps,1,0,1,class<`matrix`>,1
+fields,Tps,2,0,0,null,1
+fields,Tps,2,0,1,double,1
+fields,Tps,3,0,0,null,1
+fields,Tps,4,0,0,character,1
+fields,Tps,5,0,0,logical,1
+fields,Tps,6,0,0,logical,1
+fields,Tps,7,0,0,character,1
+fields,transformx,-1,0,0,class<`matrix`>,1
+fields,transformx,0,0,0,class<`matrix`>,1
+fields,transformx,1,0,0,character,1
+fields,transformx,2,0,0,any,1
+fields,transformx,3,0,0,any,1
+fields,two.colors,-1,0,0,character[],1
+fields,two.colors,0,0,0,double,1
+fields,two.colors,1,0,0,character,1
+fields,two.colors,2,0,0,character,1
+fields,two.colors,3,0,0,character,1
+fields,two.colors,4,0,0,double,1
+fields,unrollZGrid,-1,0,0,null,1
+fields,unrollZGrid,0,0,0,any,1
+fields,unrollZGrid,1,0,0,null,1
+fields,unscale,-1,0,0,class<`matrix`>,1
+fields,unscale,0,0,0,class<`matrix`>,1
+fields,unscale,0,0,1,integer[],1
+fields,unscale,1,0,0,double[],1
+fields,unscale,2,0,0,double[],1
+fields,US,-1,0,0,null,1
+fields,US,0,0,0,...,1
+fields,vgram,-1,0,0,"class<`list`, `vgram`>",1
+fields,vgram,0,0,0,class<`matrix`>,1
+fields,vgram,1,0,0,class<`matrix`>,1
+fields,vgram,1,0,1,^double[],1
+fields,vgram,2,0,0,null,1
+fields,vgram,3,0,0,null,1
+fields,vgram,4,0,0,logical,1
+fields,vgram,5,0,0,null,1
+fields,vgram,6,0,0,null,1
+fields,vgram,6,0,1,double,1
+fields,vgram,7,0,0,null,1
+fields,vgram.matrix,-1,0,0,class<`vgram.matrix`>,1
+fields,vgram.matrix,0,0,0,class<`matrix`>,1
+fields,vgram.matrix,1,0,0,double,1
+fields,vgram.matrix,2,0,0,double,1
+fields,vgram.matrix,3,0,0,double,1
+fields,Wendland,-1,0,0,class<`matrix`>,1
+fields,Wendland,-1,0,1,double[],1
+fields,Wendland,0,0,0,class<`matrix`>,1
+fields,Wendland,0,0,1,double[],1
+fields,Wendland,1,0,0,double,1
+fields,Wendland,2,0,0,double,1
+fields,Wendland,3,0,0,double,1
+fields,Wendland,4,0,0,double,1
+fields,Wendland,5,0,0,null,1
+fields,Wendland2.2,-1,0,0,class<`matrix`>,1
+fields,Wendland2.2,-1,0,1,double[],1
+fields,Wendland2.2,0,0,0,class<`matrix`>,1
+fields,Wendland2.2,0,0,1,double[],1
+fields,Wendland2.2,1,0,0,double,1
+fields,Wendland.beta,-1,0,0,class<`matrix`>,1
+fields,Wendland.beta,0,0,0,double,1
+fields,Wendland.beta,1,0,0,double,1
+fields,wendland.cov,-1,0,0,class<`matrix`>,1
+fields,wendland.cov,-1,0,1,class<`spam`>,1
+fields,wendland.cov,0,0,0,class<`matrix`>,1
+fields,wendland.cov,0,0,1,double[],1
+fields,wendland.cov,1,0,0,class<`matrix`>,1
+fields,wendland.cov,1,0,1,double[],1
+fields,wendland.cov,2,0,0,double,1
+fields,wendland.cov,3,0,0,null,1
+fields,wendland.cov,3,0,1,class<`matrix`>,1
+fields,wendland.cov,4,0,0,double,1
+fields,wendland.cov,5,0,0,class<`matrix`>,1
+fields,wendland.cov,5,0,1,null,1
+fields,wendland.cov,5,0,2,double[],1
+fields,wendland.cov,6,0,0,logical,1
+fields,wendland.cov,7,0,0,list<character>,1
+fields,wendland.eval,-1,0,0,class<`matrix`>,1
+fields,wendland.eval,-1,0,1,double[],1
+fields,wendland.eval,0,0,0,class<`matrix`>,1
+fields,wendland.eval,0,0,1,double[],1
+fields,wendland.eval,1,0,0,double,1
+fields,wendland.eval,2,0,0,double,1
+fields,wendland.eval,3,0,0,double,1
+fields,which.max.image,-1,0,0,list<double | class<`matrix`>>,1
+fields,which.max.image,0,0,0,list<double[] | class<`matrix`>>,1
+fields,which.max.matrix,-1,0,0,class<`matrix`>,1
+fields,which.max.matrix,0,0,0,class<`matrix`>,1
+fields,world,-1,0,0,null,1
+fields,world,0,0,0,...,1
+fields,xline,-1,0,0,null,1
+fields,xline,0,0,0,double[],1
+fields,xline,1,0,0,...,1
+fields,yline,-1,0,0,null,1
+fields,yline,0,0,0,double[],1
+fields,yline,1,0,0,...,1
+filehash,checkMap,-1,0,0,class<`filehashDB1`>,1
+filehash,checkMap,0,0,0,class<`filehashDB1`>,1
+filehash,checkMap,1,0,0,...,1
+filehash,checkMap,-1,1,0,class<`filehashDB1`>,1
+filehash,checkMap,0,1,0,class<`filehashDB1`>,1
+filehash,checkMap,1,1,0,...,1
+filehash,createLockFile,-1,0,0,logical,1
+filehash,createLockFile,0,0,0,character,1
+filehash,createQ,-1,0,0,class<`queue`>,1
+filehash,createQ,0,0,0,character,1
+filehash,db2env,-1,0,0,environment,1
+filehash,db2env,0,0,0,class<`filehashDB1`>,1
+filehash,db2env,0,0,1,class<`filehashRDS`>,1
+filehash,dbCreate,-1,0,0,logical,1
+filehash,dbCreate,0,0,0,character,1
+filehash,dbCreate,1,0,0,...,1
+filehash,dbCreate,-1,1,0,logical,1
+filehash,dbCreate,0,1,0,character,1
+filehash,dbCreate,1,1,0,...,1
+filehash,dbDelete,-1,0,0,null,1
+filehash,dbDelete,0,0,0,class<`filehashDB1`>,1
+filehash,dbDelete,1,0,0,character,1
+filehash,dbDelete,2,0,0,...,1
+filehash,dbDelete,-1,1,0,logical,1
+filehash,dbDelete,0,1,0,class<`filehashRDS`>,1
+filehash,dbDelete,1,1,0,character,1
+filehash,dbDelete,2,1,0,...,1
+filehash,dbDelete,-1,2,0,logical,1
+filehash,dbDelete,-1,2,1,null,1
+filehash,dbDelete,0,2,0,class<`filehashRDS`>,1
+filehash,dbDelete,0,2,1,class<`filehashDB1`>,1
+filehash,dbDelete,1,2,0,character,1
+filehash,dbDelete,2,2,0,...,1
+filehash,dbExists,-1,0,0,logical,1
+filehash,dbExists,0,0,0,class<`filehashRDS`>,1
+filehash,dbExists,1,0,0,character,1
+filehash,dbExists,2,0,0,...,1
+filehash,dbExists,-1,1,0,logical,1
+filehash,dbExists,0,1,0,class<`filehashDB1`>,1
+filehash,dbExists,1,1,0,character,1
+filehash,dbExists,2,1,0,...,1
+filehash,dbExists,-1,2,0,logical,1
+filehash,dbExists,0,2,0,class<`filehashDB1`>,1
+filehash,dbExists,0,2,1,class<`filehashRDS`>,1
+filehash,dbExists,1,2,0,character,1
+filehash,dbExists,2,2,0,...,1
+filehash,dbFetch,-1,0,0,character[],1
+filehash,dbFetch,-1,0,1,double[],1
+filehash,dbFetch,-1,0,2,list<any>,1
+filehash,dbFetch,-1,0,3,null,1
+filehash,dbFetch,0,0,0,class<`filehashDB1`>,1
+filehash,dbFetch,1,0,0,character,1
+filehash,dbFetch,2,0,0,...,1
+filehash,dbFetch,-1,1,0,any,1
+filehash,dbFetch,0,1,0,class<`filehashDB1`>,1
+filehash,dbFetch,0,1,1,class<`filehashRDS`>,1
+filehash,dbFetch,1,1,0,character,1
+filehash,dbFetch,2,1,0,...,1
+filehash,dbFetch,-1,2,0,any,1
+filehash,dbFetch,0,2,0,class<`filehashRDS`>,1
+filehash,dbFetch,1,2,0,character,1
+filehash,dbFetch,2,2,0,...,1
+filehash,dbInit,-1,0,0,class<`filehashDB1`>,1
+filehash,dbInit,-1,0,1,class<`filehashRDS`>,1
+filehash,dbInit,0,0,0,character,1
+filehash,dbInit,1,0,0,...,1
+filehash,dbInit,-1,1,0,class<`filehashDB1`>,1
+filehash,dbInit,-1,1,1,class<`filehashRDS`>,1
+filehash,dbInit,0,1,0,character,1
+filehash,dbInit,1,1,0,...,1
+filehash,dbInsert,-1,0,0,logical,1
+filehash,dbInsert,-1,0,1,null,1
+filehash,dbInsert,0,0,0,class<`filehashRDS`>,1
+filehash,dbInsert,0,0,1,class<`filehashDB1`>,1
+filehash,dbInsert,1,0,0,character,1
+filehash,dbInsert,2,0,0,double[],1
+filehash,dbInsert,2,0,1,character[],1
+filehash,dbInsert,2,0,2,list<double | character>,1
+filehash,dbInsert,2,0,3,null,1
+filehash,dbInsert,2,0,4,list<double | null>,1
+filehash,dbInsert,3,0,0,...,1
+filehash,dbInsert,-1,1,0,logical,1
+filehash,dbInsert,0,1,0,class<`filehashRDS`>,1
+filehash,dbInsert,1,1,0,character,1
+filehash,dbInsert,2,1,0,character,1
+filehash,dbInsert,2,1,1,double[],1
+filehash,dbInsert,3,1,0,...,1
+filehash,dbInsert,-1,2,0,null,1
+filehash,dbInsert,0,2,0,class<`filehashDB1`>,1
+filehash,dbInsert,1,2,0,character,1
+filehash,dbInsert,2,2,0,character[],1
+filehash,dbInsert,2,2,1,double[],1
+filehash,dbInsert,2,2,2,list<double | character>,1
+filehash,dbInsert,2,2,3,null,1
+filehash,dbInsert,2,2,4,list<double | null>,1
+filehash,dbInsert,3,2,0,...,1
+filehash,dbLazyLoad,-1,0,0,character[],1
+filehash,dbLazyLoad,0,0,0,class<`filehashDB1`>,1
+filehash,dbLazyLoad,1,0,0,...,1
+filehash,dbLazyLoad,-1,1,0,character[],1
+filehash,dbLazyLoad,0,1,0,class<`filehashDB1`>,1
+filehash,dbLazyLoad,1,1,0,...,1
+filehash,dbList,-1,0,0,character[],1
+filehash,dbList,0,0,0,class<`filehashDB1`>,1
+filehash,dbList,1,0,0,...,1
+filehash,dbList,-1,1,0,character[],1
+filehash,dbList,0,1,0,class<`filehashRDS`>,1
+filehash,dbList,1,1,0,...,1
+filehash,dbList,-1,2,0,character[],1
+filehash,dbList,0,2,0,class<`filehashDB1`>,1
+filehash,dbList,0,2,1,class<`filehashRDS`>,1
+filehash,dbList,1,2,0,...,1
+filehash,dbLoad,-1,0,0,character[],1
+filehash,dbLoad,0,0,0,class<`filehashDB1`>,1
+filehash,dbLoad,1,0,0,...,1
+filehash,dbLoad,-1,1,0,character[],1
+filehash,dbLoad,0,1,0,class<`filehashRDS`>,1
+filehash,dbLoad,1,1,0,...,1
+filehash,dbLoad,-1,2,0,character[],1
+filehash,dbLoad,0,2,0,class<`filehashDB1`>,1
+filehash,dbLoad,0,2,1,class<`filehashRDS`>,1
+filehash,dbLoad,1,2,0,...,1
+filehash,dbMultiFetch,-1,0,0,list<double[]>,1
+filehash,dbMultiFetch,0,0,0,class<`filehashDB1`>,1
+filehash,dbMultiFetch,1,0,0,character[],1
+filehash,dbMultiFetch,2,0,0,...,1
+filehash,dbMultiFetch,-1,1,0,list<double[]>,1
+filehash,dbMultiFetch,0,1,0,class<`filehashDB1`>,1
+filehash,dbMultiFetch,1,1,0,character[],1
+filehash,dbMultiFetch,2,1,0,...,1
+filehash,dbReorganize,-1,0,0,logical,1
+filehash,dbReorganize,0,0,0,class<`filehashDB1`>,1
+filehash,dbReorganize,1,0,0,...,1
+filehash,dbReorganize,-1,1,0,logical,1
+filehash,dbReorganize,0,1,0,class<`filehashDB1`>,1
+filehash,dbReorganize,1,1,0,...,1
+filehash,dbStartup,-1,0,0,class<`filehashDB1`>,1
+filehash,dbStartup,-1,0,1,class<`filehashRDS`>,1
+filehash,dbStartup,-1,0,2,logical,1
+filehash,dbStartup,0,0,0,character,1
+filehash,dbStartup,1,0,0,character,1
+filehash,dbStartup,2,0,0,character,1
+filehash,dbUnlink,-1,0,0,logical,1
+filehash,dbUnlink,0,0,0,class<`filehashDB1`>,1
+filehash,dbUnlink,1,0,0,...,1
+filehash,dbUnlink,-1,1,0,logical,1
+filehash,dbUnlink,0,1,0,class<`filehashDB1`>,1
+filehash,dbUnlink,1,1,0,...,1
+filehash,deleteLockFile,-1,0,0,logical,1
+filehash,deleteLockFile,0,0,0,character,1
+filehash,dumpDF,-1,0,0,class<`filehashDB1`>,1
+filehash,dumpDF,0,0,0,class<`data.frame`>,1
+filehash,dumpDF,1,0,0,character,1
+filehash,dumpDF,2,0,0,null,1
+filehash,dumpList,-1,0,0,class<`filehashDB1`>,1
+filehash,dumpList,0,0,0,list<double[]>,1
+filehash,dumpList,1,0,0,character,1
+filehash,dumpList,2,0,0,null,1
+filehash,filehashFormats,-1,0,0,list<list<class<`function`>>>,1
+filehash,filehashFormats,0,0,0,...,1
+filehash,filehashOption,-1,0,0,list<character>,1
+filehash,filehashOption,0,0,0,...,1
+filehash,filesize,-1,0,0,double,1
+filehash,filesize,0,0,0,"class<`connection`, `file`>",1
+filehash,getMap,-1,0,0,environment,1
+filehash,getMap,-1,0,1,null,1
+filehash,getMap,0,0,0,class<`filehashDB1`>,1
+filehash,getMap,-1,1,0,environment,1
+filehash,getMap,-1,1,1,null,1
+filehash,getMap,0,1,0,class<`filehashDB1`>,1
+filehash,gotoEndPos,-1,0,0,double,1
+filehash,gotoEndPos,0,0,0,"class<`connection`, `file`>",1
+filehash,hasWorkingFtell,-1,0,0,logical,1
+filehash,isEmpty,-1,0,0,logical,1
+filehash,isEmpty,0,0,0,class<`queue`>,1
+filehash,isEmpty,1,0,0,...,1
+filehash,isEmpty,-1,1,0,logical,1
+filehash,isEmpty,0,1,0,class<`queue`>,1
+filehash,isEmpty,1,1,0,...,1
+filehash,lapply,-1,0,0,list<double>,1
+filehash,lapply,0,0,0,class<`filehashDB1`>,1
+filehash,lapply,1,0,0,class<`function`>,1
+filehash,lapply,2,0,0,...,1
+filehash,lockFile,-1,0,0,character,1
+filehash,lockFile,0,0,0,"class<`connection`, `file`>",1
+filehash,lockFile,1,0,0,...,1
+filehash,lockFile,-1,1,0,character,1
+filehash,lockFile,0,1,0,"class<`connection`, `file`>",1
+filehash,lockFile,0,1,1,class<`queue`>,1
+filehash,lockFile,1,1,0,...,1
+filehash,lockFile,-1,2,0,character,1
+filehash,lockFile,0,2,0,class<`queue`>,1
+filehash,lockFile,1,2,0,...,1
+filehash,makeMetaEnv,-1,0,0,list<class<`function`>>,1
+filehash,makeMetaEnv,0,0,0,character,1
+filehash,mangleName,-1,0,0,character,1
+filehash,mangleName,0,0,0,character,1
+filehash,objectFile,-1,0,0,character,1
+filehash,objectFile,0,0,0,class<`filehashRDS`>,1
+filehash,objectFile,1,0,0,character,1
+filehash,objectFile,-1,1,0,character,1
+filehash,objectFile,0,1,0,class<`filehashRDS`>,1
+filehash,objectFile,1,1,0,character,1
+filehash,openDBConn,-1,0,0,"class<`connection`, `file`>",1
+filehash,openDBConn,0,0,0,character,1
+filehash,openDBConn,1,0,0,character,1
+filehash,pop,-1,0,0,double,1
+filehash,pop,0,0,0,class<`queue`>,1
+filehash,pop,1,0,0,...,1
+filehash,pop,-1,1,0,double,1
+filehash,pop,0,1,0,class<`queue`>,1
+filehash,pop,1,1,0,...,1
+filehash,push,-1,0,0,null,1
+filehash,push,0,0,0,class<`queue`>,1
+filehash,push,1,0,0,double,1
+filehash,push,2,0,0,...,1
+filehash,push,-1,1,0,null,1
+filehash,push,0,1,0,class<`queue`>,1
+filehash,push,1,1,0,double,1
+filehash,push,2,1,0,...,1
+filehash,readKeyMap,-1,0,0,environment,1
+filehash,readKeyMap,0,0,0,"class<`connection`, `file`>",1
+filehash,readKeyMap,1,0,0,environment,1
+filehash,readKeyMap,1,0,1,null,1
+filehash,readKeyMap,2,0,0,double,1
+filehash,readKeys,-1,0,0,list<double[]>,1
+filehash,readKeys,0,0,0,"class<`connection`, `file`>",1
+filehash,readKeys,1,0,0,environment,1
+filehash,readKeys,2,0,0,character[],1
+filehash,readSingleKey,-1,0,0,any,1
+filehash,readSingleKey,0,0,0,any,1
+filehash,readSingleKey,1,0,0,environment,1
+filehash,readSingleKey,2,0,0,character,1
+filehash,sha1,-1,0,0,character,1
+filehash,sha1,0,0,0,list<double | null>,1
+filehash,sha1,1,0,0,integer,1
+filehash,top,-1,0,0,double,1
+filehash,top,0,0,0,class<`queue`>,1
+filehash,top,1,0,0,...,1
+filehash,top,-1,1,0,double,1
+filehash,top,0,1,0,class<`queue`>,1
+filehash,top,1,1,0,...,1
+filehash,unMangleName,-1,0,0,character[],1
+filehash,unMangleName,0,0,0,character[],1
+filehash,with,-1,0,0,class<`lm`>,1
+filehash,with,-1,0,1,double[],1
+filehash,with,0,0,0,class<`filehashDB1`>,1
+filehash,with,1,0,0,any,1
+filehash,with,2,0,0,...,1
+filehash,writeKeyValue,-1,0,0,null,1
+filehash,writeKeyValue,0,0,0,"class<`connection`, `file`>",1
+filehash,writeKeyValue,1,0,0,character,1
+filehash,writeKeyValue,2,0,0,character[],1
+filehash,writeKeyValue,2,0,1,double[],1
+filehash,writeKeyValue,2,0,2,list<double | character>,1
+filehash,writeKeyValue,2,0,3,null,1
+filehash,writeKeyValue,2,0,4,list<double | null>,1
+filehash,writeNullKeyValue,-1,0,0,null,1
+filehash,writeNullKeyValue,0,0,0,"class<`connection`, `file`>",1
+filehash,writeNullKeyValue,1,0,0,character,1
+filesstrings,all_equal,-1,0,0,logical,1
+filesstrings,all_equal,0,0,0,double[],1
+filesstrings,all_equal,0,0,1,list<integer[]>,1
+filesstrings,all_equal,1,0,0,null,1
+filesstrings,all_equal,1,0,1,double[],1
+filesstrings,all_equal,1,0,2,class<`matrix`>,1
+filesstrings,extend_char_vec,-1,0,0,character[],1
+filesstrings,extend_char_vec,0,0,0,character[],1
+filesstrings,extend_char_vec,0,0,1,integer[],1
+filesstrings,extend_char_vec,1,0,0,null,1
+filesstrings,extend_char_vec,1,0,1,double,1
+filesstrings,extend_char_vec,2,0,0,double,1
+filesstrings,extend_char_vec,2,0,1,null,1
+filesstrings,group_close,-1,0,0,list<double[]>,1
+filesstrings,group_close,0,0,0,double[],1
+filesstrings,group_close,1,0,0,double,1
+filesstrings,put_in_pos,-1,0,0,character[],1
+filesstrings,put_in_pos,0,0,0,character[],1
+filesstrings,put_in_pos,0,0,1,integer[],1
+filesstrings,put_in_pos,1,0,0,double[],1
+filesstrings,remove_filename_spaces,-1,0,0,logical[],1
+filesstrings,remove_filename_spaces,0,0,0,character,1
+filesstrings,remove_filename_spaces,1,0,0,character,1
+filesstrings,remove_filename_spaces,2,0,0,character,1
+flexclust,as.kcca,-1,0,0,class<`kcca`>,1
+flexclust,as.kcca,0,0,0,class<`hclust`>,1
+flexclust,as.kcca,0,0,1,class<`kmeans`>,1
+flexclust,as.kcca,0,0,2,"class<`pam`, `partition`>",1
+flexclust,as.kcca,1,0,0,...,1
+flexclust,as.kcca.hclust,-1,0,0,class<`kcca`>,1
+flexclust,as.kcca.hclust,0,0,0,class<`hclust`>,1
+flexclust,as.kcca.hclust,1,0,0,class<`data.frame`>,1
+flexclust,as.kcca.hclust,2,0,0,double,1
+flexclust,as.kcca.hclust,3,0,0,null,1
+flexclust,as.kcca.hclust,4,0,0,logical,1
+flexclust,as.kcca.hclust,5,0,0,...,1
+flexclust,as.kcca.kmeans,-1,0,0,class<`kcca`>,1
+flexclust,as.kcca.kmeans,0,0,0,class<`kmeans`>,1
+flexclust,as.kcca.kmeans,1,0,0,class<`matrix`>,1
+flexclust,as.kcca.kmeans,2,0,0,logical,1
+flexclust,as.kcca.kmeans,3,0,0,...,1
+flexclust,as.kcca.partition,-1,0,0,class<`kcca`>,1
+flexclust,as.kcca.partition,0,0,0,"class<`pam`, `partition`>",1
+flexclust,as.kcca.partition,1,0,0,class<`matrix`>,1
+flexclust,as.kcca.partition,1,0,1,null,1
+flexclust,as.kcca.partition,2,0,0,logical,1
+flexclust,as.kcca.partition,3,0,0,...,1
+flexclust,barchart,-1,0,0,class<`trellis`>,1
+flexclust,barchart,-1,0,1,null,1
+flexclust,barchart,0,0,0,class<`kcca`>,1
+flexclust,barchart,1,0,0,any,1
+flexclust,barchart,2,0,0,...,1
+flexclust,Barchart,-1,0,0,class<`trellis`>,1
+flexclust,Barchart,0,0,0,class<`matrix`>,1
+flexclust,Barchart,1,0,0,double[],1
+flexclust,Barchart,2,0,0,null,1
+flexclust,Barchart,3,0,0,null,1
+flexclust,Barchart,3,0,1,character,1
+flexclust,Barchart,4,0,0,any,1
+flexclust,Barchart,5,0,0,any,1
+flexclust,Barchart,6,0,0,character[],1
+flexclust,Barchart,7,0,0,character,1
+flexclust,Barchart,8,0,0,any,1
+flexclust,Barchart,9,0,0,null,1
+flexclust,Barchart,9,0,1,double,1
+flexclust,Barchart,10,0,0,logical,1
+flexclust,Barchart,11,0,0,...,1
+flexclust,barplot,-1,0,0,null,1
+flexclust,barplot,0,0,0,class<`kcca`>,1
+flexclust,barplot,1,0,0,...,1
+flexclust,bclust,-1,0,0,class<`bclust`>,1
+flexclust,bclust,0,0,0,class<`data.frame`>,1
+flexclust,bclust,1,0,0,double,1
+flexclust,bclust,2,0,0,double,1
+flexclust,bclust,3,0,0,double,1
+flexclust,bclust,4,0,0,double,1
+flexclust,bclust,5,0,0,character,1
+flexclust,bclust,6,0,0,character,1
+flexclust,bclust,7,0,0,character,1
+flexclust,bclust,8,0,0,logical,1
+flexclust,bclust,9,0,0,logical,1
+flexclust,bclust,10,0,0,logical,1
+flexclust,bclust,11,0,0,null,1
+flexclust,bclust,12,0,0,double,1
+flexclust,bclust,13,0,0,...,1
+flexclust,bootFlexclust,-1,0,0,class<`bootFlexclust`>,1
+flexclust,bootFlexclust,0,0,0,class<`matrix`>,1
+flexclust,bootFlexclust,1,0,0,double,1
+flexclust,bootFlexclust,2,0,0,double,1
+flexclust,bootFlexclust,3,0,0,logical,1
+flexclust,bootFlexclust,4,0,0,null,1
+flexclust,bootFlexclust,5,0,0,logical,1
+flexclust,bootFlexclust,6,0,0,logical,1
+flexclust,bootFlexclust,7,0,0,...,1
+flexclust,boxplot,-1,0,0,list<class<`matrix`> | double[] | character[]>,1
+flexclust,boxplot,0,0,0,class<`resampleFlexclust`>,1
+flexclust,boxplot,1,0,0,...,1
+flexclust,boxplot,-1,1,0,list<class<`matrix`> | double[] | character>,1
+flexclust,boxplot,0,1,0,class<`bootFlexclust`>,1
+flexclust,boxplot,1,1,0,...,1
+flexclust,bundestag,-1,0,0,class<`factor`>,1
+flexclust,bundestag,-1,0,1,class<`matrix`>,1
+flexclust,bundestag,0,0,0,double,1
+flexclust,bundestag,1,0,0,logical,1
+flexclust,bundestag,2,0,0,logical,1
+flexclust,bundestag,3,0,0,logical,1
+flexclust,bundestag,4,0,0,character,1
+flexclust,bundestag,4,0,1,logical,1
+flexclust,bwplot,-1,0,0,class<`trellis`>,1
+flexclust,bwplot,0,0,0,class<`kcca`>,1
+flexclust,bwplot,1,0,0,any,1
+flexclust,bwplot,2,0,0,...,1
+flexclust,cclust,-1,0,0,class<`kcca`>,1
+flexclust,cclust,0,0,0,class<`data.frame`>,1
+flexclust,cclust,0,0,1,class<`matrix`>,1
+flexclust,cclust,1,0,0,double,1
+flexclust,cclust,2,0,0,character,1
+flexclust,cclust,3,0,0,character,1
+flexclust,cclust,4,0,0,null,1
+flexclust,cclust,5,0,0,null,1
+flexclust,cclust,6,0,0,null,1
+flexclust,cclust,7,0,0,logical,1
+flexclust,cclust,8,0,0,logical,1
+flexclust,clusinfo,-1,0,0,class<`data.frame`>,1
+flexclust,clusinfo,0,0,0,integer[],1
+flexclust,clusinfo,1,0,0,class<`matrix`>,1
+flexclust,clusinfo,2,0,0,logical,1
+flexclust,clusterSim,-1,0,0,class<`matrix`>,1
+flexclust,clusterSim,0,0,0,class<`kcca`>,1
+flexclust,clusterSim,1,0,0,...,1
+flexclust,clusterSim,-1,1,0,class<`matrix`>,1
+flexclust,clusterSim,0,1,0,class<`kcca`>,1
+flexclust,clusterSim,1,1,0,...,1
+flexclust,clusterSim,-1,2,0,class<`matrix`>,1
+flexclust,clusterSim,0,2,0,class<`kcca`>,1
+flexclust,clusterSim,1,2,0,...,1
+flexclust,clusterwiseScheme,-1,0,0,class<`resampleScheme`>,1
+flexclust,clusterwiseScheme,0,0,0,class<`kcca`>,1
+flexclust,comPart,-1,0,0,double[],1
+flexclust,comPart,0,0,0,integer[],1
+flexclust,comPart,1,0,0,integer[],1
+flexclust,comPart,2,0,0,character[],1
+flexclust,comPart,-1,1,0,double[],1
+flexclust,comPart,0,1,0,double[],1
+flexclust,comPart,1,1,0,double[],1
+flexclust,comPart,2,1,0,character[],1
+flexclust,comPart,-1,2,0,double[],1
+flexclust,comPart,0,2,0,double[],1
+flexclust,comPart,1,2,0,double[],1
+flexclust,comPart,2,2,0,character[],1
+flexclust,computeClusterSim,-1,0,0,class<`matrix`>,1
+flexclust,computeClusterSim,0,0,0,class<`matrix`>,1
+flexclust,computeClusterSim,1,0,0,list<integer[]>,1
+flexclust,countPairs,-1,0,0,class<`matrix`>,1
+flexclust,countPairs,0,0,0,double[],1
+flexclust,countPairs,1,0,0,double[],1
+flexclust,createBarchartPanel,-1,0,0,class<`function`>,1
+flexclust,createBarchartPanel,0,0,0,any,1
+flexclust,createBarchartPanel,1,0,0,any,1
+flexclust,createBarchartPanel,2,0,0,any,1
+flexclust,createBarchartPanel,3,0,0,any,1
+flexclust,createBarchartPanel,4,0,0,any,1
+flexclust,createBarchartPanel,5,0,0,double,1
+flexclust,createBarchartPanel,5,0,1,null,1
+flexclust,createBarchartPanel,6,0,0,any,1
+flexclust,createBWplotPanel,-1,0,0,class<`function`>,1
+flexclust,createBWplotPanel,0,0,0,class<`data.frame`>,1
+flexclust,createBWplotPanel,1,0,0,any,1
+flexclust,createBWplotPanel,2,0,0,logical,1
+flexclust,createBWplotPanel,3,0,0,any,1
+flexclust,createBWplotPanel,4,0,0,logical,1
+flexclust,createBWplotPanel,5,0,0,...,1
+flexclust,Cutree,-1,0,0,double[],1
+flexclust,Cutree,0,0,0,class<`hclust`>,1
+flexclust,Cutree,1,0,0,double,1
+flexclust,Cutree,2,0,0,null,1
+flexclust,densityplot,-1,0,0,class<`trellis`>,1
+flexclust,densityplot,0,0,0,class<`bootFlexclust`>,1
+flexclust,densityplot,1,0,0,any,1
+flexclust,densityplot,2,0,0,...,1
+flexclust,densityplot,-1,1,0,class<`trellis`>,1
+flexclust,densityplot,0,1,0,class<`resampleFlexclust`>,1
+flexclust,densityplot,1,1,0,any,1
+flexclust,densityplot,2,1,0,...,1
+flexclust,dist2,-1,0,0,class<`matrix`>,1
+flexclust,dist2,0,0,0,class<`data.frame`>,1
+flexclust,dist2,0,0,1,class<`matrix`>,1
+flexclust,dist2,1,0,0,class<`data.frame`>,1
+flexclust,dist2,1,0,1,class<`matrix`>,1
+flexclust,dist2,2,0,0,character,1
+flexclust,dist2,3,0,0,double,1
+flexclust,distCanberra,-1,0,0,class<`matrix`>,1
+flexclust,distCanberra,0,0,0,class<`matrix`>,1
+flexclust,distCanberra,1,0,0,class<`matrix`>,1
+flexclust,distEuclidean,-1,0,0,class<`matrix`>,1
+flexclust,distEuclidean,0,0,0,class<`matrix`>,1
+flexclust,distEuclidean,1,0,0,class<`matrix`>,1
+flexclust,distJaccard,-1,0,0,class<`matrix`>,1
+flexclust,distJaccard,0,0,0,class<`matrix`>,1
+flexclust,distJaccard,1,0,0,class<`matrix`>,1
+flexclust,distManhattan,-1,0,0,class<`matrix`>,1
+flexclust,distManhattan,0,0,0,class<`matrix`>,1
+flexclust,distManhattan,1,0,0,class<`matrix`>,1
+flexclust,distMax,-1,0,0,class<`matrix`>,1
+flexclust,distMax,0,0,0,class<`matrix`>,1
+flexclust,distMax,1,0,0,class<`matrix`>,1
+flexclust,distMinkowski,-1,0,0,class<`matrix`>,1
+flexclust,distMinkowski,0,0,0,class<`matrix`>,1
+flexclust,distMinkowski,1,0,0,class<`matrix`>,1
+flexclust,distMinkowski,2,0,0,double,1
+flexclust,doRandIndex,-1,0,0,double,1
+flexclust,doRandIndex,0,0,0,class<`table`>,1
+flexclust,doRandIndex,1,0,0,any,1
+flexclust,doRandIndex,2,0,0,logical,1
+flexclust,doRandIndex,3,0,0,logical,1
+flexclust,dorelabel,-1,0,0,class<`kcca`>,1
+flexclust,dorelabel,0,0,0,class<`kcca`>,1
+flexclust,dorelabel,1,0,0,double[],1
+flexclust,expandColors,-1,0,0,character[],1
+flexclust,expandColors,0,0,0,null,1
+flexclust,expandColors,1,0,0,class<`kcca`>,1
+flexclust,flxColors,-1,0,0,character[],1
+flexclust,flxColors,0,0,0,any,1
+flexclust,flxColors,1,0,0,character,1
+flexclust,flxColors,2,0,0,logical,1
+flexclust,getColnames,-1,0,0,character[],1
+flexclust,getColnames,0,0,0,class<`prcomp`>,1
+flexclust,getColnames.prcomp,-1,0,0,character[],1
+flexclust,getColnames.prcomp,0,0,0,class<`prcomp`>,1
+flexclust,getData,-1,0,0,class<`matrix`>,1
+flexclust,getData,-1,0,1,null,1
+flexclust,getData,0,0,0,class<`kcca`>,1
+flexclust,getData,1,0,0,logical,1
+flexclust,getData,-1,1,0,class<`data.frame`>,1
+flexclust,getData,0,1,0,character,1
+flexclust,getDistColClust,-1,0,0,list<double[] | character[]>,1
+flexclust,getDistColClust,-1,0,1,list<double[]>,1
+flexclust,getDistColClust,0,0,0,class<`kcca`>,1
+flexclust,getDistColClust,1,0,0,integer,1
+flexclust,getDistColClust,2,0,0,character,1
+flexclust,getDistColClust,3,0,0,character[],1
+flexclust,getDistColClust,3,0,1,integer[],1
+flexclust,getDistColClust,4,0,0,any,1
+flexclust,groupBWplot,-1,0,0,class<`trellis`>,1
+flexclust,groupBWplot,0,0,0,class<`data.frame`>,1
+flexclust,groupBWplot,1,0,0,class<`factor`>,1
+flexclust,groupBWplot,2,0,0,double,1
+flexclust,groupBWplot,3,0,0,character,1
+flexclust,groupBWplot,4,0,0,character,1
+flexclust,groupBWplot,5,0,0,null,1
+flexclust,groupBWplot,6,0,0,logical,1
+flexclust,groupBWplot,7,0,0,character,1
+flexclust,groupBWplot,7,0,1,null,1
+flexclust,groupBWplot,8,0,0,character,1
+flexclust,groupBWplot,9,0,0,null,1
+flexclust,groupBWplot,10,0,0,null,1
+flexclust,groupBWplot,11,0,0,logical,1
+flexclust,groupBWplot,12,0,0,...,1
+flexclust,hclustBclust,-1,0,0,class<`bclust`>,1
+flexclust,hclustBclust,0,0,0,class<`bclust`>,1
+flexclust,hclustBclust,1,0,0,any,1
+flexclust,hclustBclust,2,0,0,double,1
+flexclust,hclustBclust,3,0,0,character,1
+flexclust,hclustBclust,4,0,0,character,1
+flexclust,hclustBclust,5,0,0,logical,1
+flexclust,hclustBclust,6,0,0,integer,1
+flexclust,image,-1,0,0,list<double[] | class<`matrix`>>,1
+flexclust,image,0,0,0,class<`kcca`>,1
+flexclust,image,1,0,0,...,1
+flexclust,initCenters,-1,0,0,list<class<`matrix`> | integer[]>,1
+flexclust,initCenters,0,0,0,class<`matrix`>,1
+flexclust,initCenters,1,0,0,double,1
+flexclust,initCenters,1,0,1,integer[],1
+flexclust,initCenters,2,0,0,class<`kccaFamily`>,1
+flexclust,initCenters,3,0,0,any,1
+flexclust,kcca,-1,0,0,class<`kcca`>,1
+flexclust,kcca,0,0,0,class<`matrix`>,1
+flexclust,kcca,1,0,0,double,1
+flexclust,kcca,1,0,1,integer[],1
+flexclust,kcca,2,0,0,class<`kccaFamily`>,1
+flexclust,kcca,3,0,0,double[],1
+flexclust,kcca,3,0,1,null,1
+flexclust,kcca,4,0,0,null,1
+flexclust,kcca,5,0,0,null,1
+flexclust,kcca,5,0,1,list<character>,1
+flexclust,kcca,5,0,2,list<double>,1
+flexclust,kcca,6,0,0,logical,1
+flexclust,kcca,7,0,0,logical,1
+flexclust,kcca2df,-1,0,0,class<`data.frame`>,1
+flexclust,kcca2df,0,0,0,class<`kcca`>,1
+flexclust,kcca2df,1,0,0,null,1
+flexclust,kccaFamily,-1,0,0,class<`kccaFamily`>,1
+flexclust,kccaFamily,0,0,0,character,1
+flexclust,kccaFamily,1,0,0,null,1
+flexclust,kccaFamily,2,0,0,null,1
+flexclust,kccaFamily,3,0,0,character,1
+flexclust,kccaFamily,4,0,0,null,1
+flexclust,kccaFamily,5,0,0,double,1
+flexclust,kccaFamily,6,0,0,character,1
+flexclust,kmeanspp,-1,0,0,class<`matrix`>,1
+flexclust,kmeanspp,0,0,0,class<`matrix`>,1
+flexclust,kmeanspp,1,0,0,integer,1
+flexclust,kmeanspp,2,0,0,class<`kccaFamily`>,1
+flexclust,list2object,-1,0,0,class<`cclustControl`>,1
+flexclust,list2object,-1,0,1,class<`flexclustControl`>,1
+flexclust,list2object,0,0,0,list<double | character>,1
+flexclust,list2object,0,0,1,list<character>,1
+flexclust,list2object,0,0,2,list<double>,1
+flexclust,list2object,1,0,0,character,1
+flexclust,matrix2df,-1,0,0,class<`data.frame`>,1
+flexclust,matrix2df,0,0,0,class<`matrix`>,1
+flexclust,matrix2df,1,0,0,class<`factor`>,1
+flexclust,matrix2df,1,0,1,integer[],1
+flexclust,maxDist,-1,0,0,double,1
+flexclust,maxDist,0,0,0,any,1
+flexclust,maxDist,1,0,0,character,1
+flexclust,maxDist,2,0,0,any,1
+flexclust,MClapply,-1,0,0,list<class<`kccasimple`>>,1
+flexclust,MClapply,-1,0,1,list<list<class<`matrix`> | double | list<class<`matrix`>>>>,1
+flexclust,MClapply,-1,0,2,list<list<class<`matrix`> | list<class<`matrix`>>>>,1
+flexclust,MClapply,0,0,0,list<double>,1
+flexclust,MClapply,1,0,0,any,1
+flexclust,MClapply,2,0,0,logical,1
+flexclust,MClapply,3,0,0,...,1
+flexclust,mincross,-1,0,0,double[],1
+flexclust,mincross,0,0,0,class<`table`>,1
+flexclust,mlogit,-1,0,0,class<`matrix`>,1
+flexclust,mlogit,0,0,0,class<`matrix`>,1
+flexclust,neighbourColors,-1,0,0,character[],1
+flexclust,neighbourColors,0,0,0,list<integer[]>,1
+flexclust,neighbourColors,1,0,0,null,1
+flexclust,neighbours,-1,0,0,list<integer[]>,1
+flexclust,neighbours,0,0,0,class<`kcca`>,1
+flexclust,neighbours,1,0,0,logical,1
+flexclust,neighbours,2,0,0,...,1
+flexclust,neighbours,-1,1,0,list<integer[]>,1
+flexclust,neighbours,0,1,0,list<integer[]>,1
+flexclust,neighbours,1,1,0,logical,1
+flexclust,neighbours,2,1,0,...,1
+flexclust,neighbours,-1,2,0,list<integer[]>,1
+flexclust,neighbours,0,2,0,class<`kcca`>,1
+flexclust,neighbours,0,2,1,list<integer[]>,1
+flexclust,neighbours,1,2,0,logical,1
+flexclust,neighbours,2,2,0,...,1
+flexclust,newKccaObject,-1,0,0,class<`kcca`>,1
+flexclust,newKccaObject,-1,0,1,class<`kccasimple`>,1
+flexclust,newKccaObject,0,0,0,class<`matrix`>,1
+flexclust,newKccaObject,1,0,0,class<`kccaFamily`>,1
+flexclust,newKccaObject,2,0,0,class<`matrix`>,1
+flexclust,newKccaObject,3,0,0,null,1
+flexclust,newKccaObject,4,0,0,logical,1
+flexclust,newKccaObject,5,0,0,...,1
+flexclust,newKccasimpleObject,-1,0,0,class<`kccasimple`>,1
+flexclust,newKccasimpleObject,0,0,0,class<`matrix`>,1
+flexclust,newKccasimpleObject,1,0,0,class<`kccaFamily`>,1
+flexclust,newKccasimpleObject,2,0,0,class<`matrix`>,1
+flexclust,newKccasimpleObject,3,0,0,null,1
+flexclust,newKccasimpleObject,4,0,0,class<`matrix`>,1
+flexclust,newKccasimpleObject,5,0,0,...,1
+flexclust,normWeights,-1,0,0,double[],1
+flexclust,normWeights,0,0,0,double[],1
+flexclust,plot,-1,0,0,list<class<`matrix`> | double[] | character>,1
+flexclust,plot,0,0,0,class<`bootFlexclust`>,1
+flexclust,plot,1,0,0,any,1
+flexclust,plot,2,0,0,...,1
+flexclust,plot,-1,1,0,null,1
+flexclust,plot,0,1,0,class<`projAxes`>,1
+flexclust,plot,1,1,0,any,1
+flexclust,plot,2,1,0,...,1
+flexclust,plot,-1,2,0,list<class<`matrix`> | double[] | character[]>,1
+flexclust,plot,0,2,0,class<`resampleFlexclust`>,1
+flexclust,plot,1,2,0,any,1
+flexclust,plot,2,2,0,...,1
+flexclust,plot,-1,3,0,null,1
+flexclust,plot,0,3,0,class<`shadow`>,1
+flexclust,plot,1,3,0,any,1
+flexclust,plot,2,3,0,...,1
+flexclust,plot,-1,4,0,integer,1
+flexclust,plot,0,4,0,class<`bclust`>,1
+flexclust,plot,1,4,0,any,1
+flexclust,plot,2,4,0,...,1
+flexclust,plot,-1,5,0,null,1
+flexclust,plot,0,5,0,class<`kcca`>,1
+flexclust,plot,1,5,0,any,1
+flexclust,plot,2,5,0,...,1
+flexclust,plot,-1,6,0,null,1
+flexclust,plot,0,6,0,class<`stepFlexclust`>,1
+flexclust,plot,1,6,0,any,1
+flexclust,plot,2,6,0,...,1
+flexclust,plotFramework,-1,0,0,null,1
+flexclust,plotFramework,0,0,0,any,1
+flexclust,plotFramework,1,0,0,double[],1
+flexclust,plotFramework,2,0,0,double[],1
+flexclust,plotFramework,3,0,0,logical,1
+flexclust,plotFramework,4,0,0,logical,1
+flexclust,plotFramework,5,0,0,null,1
+flexclust,plotFramework,6,0,0,null,1
+flexclust,plotFramework,7,0,0,character,1
+flexclust,plotFramework,8,0,0,character,1
+flexclust,plotFramework,9,0,0,character,1
+flexclust,plotFramework,10,0,0,logical,1
+flexclust,plotFramework,11,0,0,null,1
+flexclust,plotFramework,11,0,1,list<character[] | integer[] | double>,1
+flexclust,plot.priceFeature,-1,0,0,null,1
+flexclust,plot.priceFeature,0,0,0,class<`priceFeature`>,1
+flexclust,plot.priceFeature,1,0,0,logical,1
+flexclust,plot.priceFeature,2,0,0,...,1
+flexclust,predict,-1,0,0,integer[],1
+flexclust,predict,0,0,0,class<`kcca`>,1
+flexclust,predict,1,0,0,...,1
+flexclust,predict,-1,1,0,^integer[],1
+flexclust,predict,0,1,0,class<`kccasimple`>,1
+flexclust,predict,1,1,0,...,1
+flexclust,Predict,-1,0,0,class<`matrix`>,1
+flexclust,Predict,0,0,0,class<`prcomp`>,1
+flexclust,Predict,1,0,0,class<`matrix`>,1
+flexclust,priceFeature,-1,0,0,class<`priceFeature`>,1
+flexclust,priceFeature,0,0,0,double,1
+flexclust,priceFeature,1,0,0,character,1
+flexclust,projAxes,-1,0,0,class<`projAxes`>,1
+flexclust,projAxes,0,0,0,class<`prcomp`>,1
+flexclust,projAxes,1,0,0,double[],1
+flexclust,projAxes,2,0,0,null,1
+flexclust,projAxes,2,0,1,double,1
+flexclust,projAxes,3,0,0,character,1
+flexclust,projAxes,4,0,0,double,1
+flexclust,projAxes,4,0,1,null,1
+flexclust,projAxes,5,0,0,double,1
+flexclust,projAxes,6,0,0,list<character>,1
+flexclust,projAxes,7,0,0,character[],1
+flexclust,projAxes,8,0,0,character,1
+flexclust,projAxes,9,0,0,null,1
+flexclust,projAxes,10,0,0,any,1
+flexclust,projAxes,11,0,0,logical,1
+flexclust,projAxes,12,0,0,...,1
+flexclust,propBarchart,-1,0,0,class<`propBarchart`>,1
+flexclust,propBarchart,0,0,0,class<`matrix`>,1
+flexclust,propBarchart,1,0,0,class<`factor`>,1
+flexclust,propBarchart,2,0,0,double,1
+flexclust,propBarchart,3,0,0,character,1
+flexclust,propBarchart,4,0,0,character,1
+flexclust,propBarchart,5,0,0,logical,1
+flexclust,propBarchart,6,0,0,character,1
+flexclust,propBarchart,7,0,0,null,1
+flexclust,propBarchart,8,0,0,null,1
+flexclust,propBarchart,9,0,0,logical,1
+flexclust,propBarchart,10,0,0,...,1
+flexclust,qtclust,-1,0,0,class<`kccasimple`>,1
+flexclust,qtclust,0,0,0,class<`matrix`>,1
+flexclust,qtclust,1,0,0,double,1
+flexclust,qtclust,2,0,0,class<`kccaFamily`>,1
+flexclust,qtclust,3,0,0,null,1
+flexclust,qtclust,4,0,0,logical,1
+flexclust,qtclust,5,0,0,logical,1
+flexclust,randIndex,-1,0,0,double[],1
+flexclust,randIndex,0,0,0,class<`table`>,1
+flexclust,randIndex,1,0,0,any,1
+flexclust,randIndex,2,0,0,logical,1
+flexclust,randIndex,3,0,0,logical,1
+flexclust,randIndex,-1,1,0,double[],1
+flexclust,randIndex,0,1,0,class<`table`>,1
+flexclust,randIndex,1,1,0,any,1
+flexclust,randIndex,2,1,0,logical,1
+flexclust,randIndex,3,1,0,logical,1
+flexclust,randomcent,-1,0,0,class<`matrix`>,1
+flexclust,randomcent,0,0,0,class<`matrix`>,1
+flexclust,randomcent,1,0,0,integer,1
+flexclust,randomcent,2,0,0,class<`kccaFamily`>,1
+flexclust,resampleFlexclust,-1,0,0,class<`resampleFlexclust`>,1
+flexclust,resampleFlexclust,0,0,0,class<`matrix`>,1
+flexclust,resampleFlexclust,1,0,0,integer,1
+flexclust,resampleFlexclust,2,0,0,class<`resampleScheme`>,1
+flexclust,resampleFlexclust,3,0,0,double,1
+flexclust,resampleFlexclust,4,0,0,null,1
+flexclust,resampleFlexclust,5,0,0,logical,1
+flexclust,resampleFlexclust,6,0,0,logical,1
+flexclust,resampleFlexclust,7,0,0,...,1
+flexclust,shadow,-1,0,0,class<`shadow`>,1
+flexclust,shadow,0,0,0,class<`kcca`>,1
+flexclust,shadow,1,0,0,...,1
+flexclust,shadow,-1,1,0,class<`shadow`>,1
+flexclust,shadow,0,1,0,class<`kcca`>,1
+flexclust,shadow,1,1,0,...,1
+flexclust,shadowPlot,-1,0,0,null,1
+flexclust,shadowPlot,0,0,0,class<`shadow`>,1
+flexclust,shadowPlot,1,0,0,...,1
+flexclust,shadowPlot,-1,1,0,null,1
+flexclust,shadowPlot,0,1,0,class<`shadow`>,1
+flexclust,shadowPlot,1,1,0,...,1
+flexclust,shadowStars,-1,0,0,null,1
+flexclust,shadowStars,0,0,0,class<`kcca`>,1
+flexclust,shadowStars,1,0,0,integer[],1
+flexclust,shadowStars,2,0,0,null,1
+flexclust,shadowStars,3,0,0,double,1
+flexclust,shadowStars,4,0,0,logical,1
+flexclust,shadowStars,5,0,0,class<`function`>,1
+flexclust,shadowStars,6,0,0,null,1
+flexclust,shadowStars,7,0,0,null,1
+flexclust,shadowStars,8,0,0,logical,1
+flexclust,shadowStars,9,0,0,...,1
+flexclust,Silhouette,-1,0,0,class<`shadow`>,1
+flexclust,Silhouette,0,0,0,class<`kcca`>,1
+flexclust,Silhouette,1,0,0,...,1
+flexclust,Silhouette,-1,1,0,class<`shadow`>,1
+flexclust,Silhouette,0,1,0,class<`kcca`>,1
+flexclust,Silhouette,1,1,0,...,1
+flexclust,simple2kcca,-1,0,0,class<`kcca`>,1
+flexclust,simple2kcca,0,0,0,class<`matrix`>,1
+flexclust,simple2kcca,1,0,0,class<`kccasimple`>,1
+flexclust,simple2kcca,2,0,0,null,1
+flexclust,simple2kcca,3,0,0,class<`matrix`>,1
+flexclust,simple2kcca,3,0,1,null,1
+flexclust,slsaplot,-1,0,0,list<double[]>,1
+flexclust,slsaplot,0,0,0,class<`stepFlexclust`>,1
+flexclust,slsaplot,1,0,0,null,1
+flexclust,slsaplot,2,0,0,...,1
+flexclust,slswFlexclust,-1,0,0,class<`resampleFlexclust`>,1
+flexclust,slswFlexclust,0,0,0,class<`matrix`>,1
+flexclust,slswFlexclust,1,0,0,class<`kcca`>,1
+flexclust,slswFlexclust,2,0,0,...,1
+flexclust,stepFlexclust,-1,0,0,class<`stepFlexclust`>,1
+flexclust,stepFlexclust,0,0,0,class<`matrix`>,1
+flexclust,stepFlexclust,1,0,0,double,1
+flexclust,stepFlexclust,1,0,1,integer[],1
+flexclust,stepFlexclust,2,0,0,double,1
+flexclust,stepFlexclust,3,0,0,logical,1
+flexclust,stepFlexclust,4,0,0,class<`function`>,1
+flexclust,stepFlexclust,5,0,0,logical,1
+flexclust,stepFlexclust,6,0,0,null,1
+flexclust,stepFlexclust,7,0,0,logical,1
+flexclust,stepFlexclust,8,0,0,logical,1
+flexclust,stepFlexclust,9,0,0,null,1
+flexclust,stepFlexclust,10,0,0,logical,1
+flexclust,stepFlexclust,11,0,0,...,1
+flexclust,stripes,-1,0,0,null,1
+flexclust,stripes,0,0,0,class<`kcca`>,1
+flexclust,stripes,1,0,0,class<`factor`>,1
+flexclust,stripes,1,0,1,null,1
+flexclust,stripes,2,0,0,character[],1
+flexclust,stripes,3,0,0,logical,1
+flexclust,stripes,4,0,0,null,1
+flexclust,stripes,5,0,0,null,1
+flexclust,stripes,6,0,0,null,1
+flexclust,stripes,6,0,1,class<`gpar`>,1
+flexclust,stripes,7,0,0,null,1
+flexclust,stripes,7,0,1,class<`gpar`>,1
+flexclust,stripes,8,0,0,logical,1
+flexclust,stripes,9,0,0,any,1
+flexclust,stripes,10,0,0,null,1
+flexclust,stripes,11,0,0,character,1
+flexclust,stripes,12,0,0,double[],1
+flexclust,stripes,13,0,0,...,1
+flexclust,transitions,-1,0,0,list<double[]>,1
+flexclust,transitions,0,0,0,class<`stepFlexclust`>,1
+flexclust,transitions,1,0,0,double,1
+flexclust,transitions,2,0,0,double,1
+flexclust,transitions,3,0,0,double,1
+flexclust,transitions,4,0,0,logical,1
+flexclust,transitions,5,0,0,logical,1
+flexclust,transitions,6,0,0,logical,1
+flexclust,transitions,7,0,0,null,1
+flexclust,transitions,8,0,0,null,1
+flextable,add_cellstyle_column,-1,0,0,class<`data.frame`>,1
+flextable,add_cellstyle_column,0,0,0,class<`data.frame`>,1
+flextable,add_cellstyle_column,1,0,0,character,1
+flextable,add_cellstyle_column,2,0,0,any,1
+flextable,add_footer,-1,0,0,class<`flextable`>,1
+flextable,add_footer,0,0,0,class<`flextable`>,1
+flextable,add_footer,1,0,0,logical,1
+flextable,add_footer,2,0,0,...,1
+flextable,add_footer,3,0,0,null,1
+flextable,add_footer_lines,-1,0,0,class<`flextable`>,1
+flextable,add_footer_lines,0,0,0,class<`flextable`>,1
+flextable,add_footer_lines,1,0,0,character[],1
+flextable,add_footer_lines,2,0,0,logical,1
+flextable,add_footer_row,-1,0,0,class<`flextable`>,1
+flextable,add_footer_row,0,0,0,class<`flextable`>,1
+flextable,add_footer_row,1,0,0,logical,1
+flextable,add_footer_row,2,0,0,character[],1
+flextable,add_footer_row,3,0,0,double[],1
+flextable,add_header,-1,0,0,class<`flextable`>,1
+flextable,add_header,0,0,0,class<`flextable`>,1
+flextable,add_header,1,0,0,logical,1
+flextable,add_header,2,0,0,...,1
+flextable,add_header,3,0,0,null,1
+flextable,add_header_lines,-1,0,0,class<`flextable`>,1
+flextable,add_header_lines,0,0,0,class<`flextable`>,1
+flextable,add_header_lines,1,0,0,character[],1
+flextable,add_header_lines,2,0,0,logical,1
+flextable,add_header_row,-1,0,0,class<`flextable`>,1
+flextable,add_header_row,0,0,0,class<`flextable`>,1
+flextable,add_header_row,1,0,0,logical,1
+flextable,add_header_row,2,0,0,character[],1
+flextable,add_header_row,3,0,0,double[],1
+flextable,add_parstyle_column,-1,0,0,class<`data.frame`>,1
+flextable,add_parstyle_column,0,0,0,class<`data.frame`>,1
+flextable,add_parstyle_column,1,0,0,character,1
+flextable,add_parstyle_column,2,0,0,any,1
+flextable,add_parstyle_column,3,0,0,any,1
+flextable,add_raster_as_filecolumn,-1,0,0,class<`data.frame`>,1
+flextable,add_raster_as_filecolumn,0,0,0,class<`data.frame`>,1
+flextable,add_rows,-1,0,0,class<`cell_struct`>,1
+flextable,add_rows,-1,0,1,class<`chunkset_struct`>,1
+flextable,add_rows,-1,0,2,class<`complex_tabpart`>,1
+flextable,add_rows,-1,0,3,class<`fpstruct`>,1
+flextable,add_rows,-1,0,4,class<`par_struct`>,1
+flextable,add_rows,-1,0,5,class<`text_struct`>,1
+flextable,add_rows,0,0,0,class<`cell_struct`>,1
+flextable,add_rows,0,0,1,class<`chunkset_struct`>,1
+flextable,add_rows,0,0,2,class<`complex_tabpart`>,1
+flextable,add_rows,0,0,3,class<`fpstruct`>,1
+flextable,add_rows,0,0,4,class<`par_struct`>,1
+flextable,add_rows,0,0,5,class<`text_struct`>,1
+flextable,add_rows,1,0,0,...,1
+flextable,add_rows.cell_struct,-1,0,0,class<`cell_struct`>,1
+flextable,add_rows.cell_struct,0,0,0,class<`cell_struct`>,1
+flextable,add_rows.cell_struct,1,0,0,integer,1
+flextable,add_rows.cell_struct,2,0,0,logical,1
+flextable,add_rows.cell_struct,3,0,0,...,1
+flextable,add_rows.chunkset_struct,-1,0,0,class<`chunkset_struct`>,1
+flextable,add_rows.chunkset_struct,0,0,0,class<`chunkset_struct`>,1
+flextable,add_rows.chunkset_struct,1,0,0,integer,1
+flextable,add_rows.chunkset_struct,2,0,0,logical,1
+flextable,add_rows.chunkset_struct,3,0,0,class<`data.frame`>,1
+flextable,add_rows.chunkset_struct,4,0,0,...,1
+flextable,add_rows.complex_tabpart,-1,0,0,class<`complex_tabpart`>,1
+flextable,add_rows.complex_tabpart,0,0,0,class<`complex_tabpart`>,1
+flextable,add_rows.complex_tabpart,1,0,0,class<`data.frame`>,1
+flextable,add_rows.complex_tabpart,2,0,0,logical,1
+flextable,add_rows.fpstruct,-1,0,0,class<`fpstruct`>,1
+flextable,add_rows.fpstruct,0,0,0,class<`fpstruct`>,1
+flextable,add_rows.fpstruct,1,0,0,integer,1
+flextable,add_rows.fpstruct,2,0,0,logical,1
+flextable,add_rows.fpstruct,3,0,0,character,1
+flextable,add_rows.fpstruct,3,0,1,class<`paragraph`>,1
+flextable,add_rows.fpstruct,3,0,2,double,1
+flextable,add_rows.fpstruct,3,0,3,null,1
+flextable,add_rows.fpstruct,4,0,0,...,1
+flextable,add_rows.par_struct,-1,0,0,class<`par_struct`>,1
+flextable,add_rows.par_struct,-1,0,1,class<`text_struct`>,1
+flextable,add_rows.par_struct,0,0,0,class<`par_struct`>,1
+flextable,add_rows.par_struct,0,0,1,class<`text_struct`>,1
+flextable,add_rows.par_struct,1,0,0,integer,1
+flextable,add_rows.par_struct,2,0,0,logical,1
+flextable,add_rows.par_struct,3,0,0,...,1
+flextable,add_rows.text_struct,-1,0,0,class<`par_struct`>,1
+flextable,add_rows.text_struct,-1,0,1,class<`text_struct`>,1
+flextable,add_rows.text_struct,0,0,0,class<`par_struct`>,1
+flextable,add_rows.text_struct,0,0,1,class<`text_struct`>,1
+flextable,add_rows.text_struct,1,0,0,integer,1
+flextable,add_rows.text_struct,2,0,0,logical,1
+flextable,add_rows.text_struct,3,0,0,...,1
+flextable,add_runstyle_column,-1,0,0,class<`data.frame`>,1
+flextable,add_runstyle_column,0,0,0,class<`data.frame`>,1
+flextable,add_runstyle_column,1,0,0,character,1
+flextable,align,-1,0,0,class<`flextable`>,1
+flextable,align,0,0,0,class<`flextable`>,1
+flextable,align,1,0,0,any,1
+flextable,align,2,0,0,any,1
+flextable,align,3,0,0,any,1
+flextable,align,4,0,0,character,1
+flextable,align_nottext_col,-1,0,0,class<`flextable`>,1
+flextable,align_nottext_col,0,0,0,class<`flextable`>,1
+flextable,align_nottext_col,1,0,0,character,1
+flextable,align_nottext_col,2,0,0,logical,1
+flextable,align_nottext_col,3,0,0,logical,1
+flextable,align_text_col,-1,0,0,class<`flextable`>,1
+flextable,align_text_col,0,0,0,class<`flextable`>,1
+flextable,align_text_col,1,0,0,character,1
+flextable,align_text_col,2,0,0,logical,1
+flextable,align_text_col,3,0,0,logical,1
+flextable,as_b,-1,0,0,"class<`chunk`, `data.frame`>",1
+flextable,as_b,0,0,0,character,1
+flextable,as_b,0,0,1,double[],1
+flextable,as_bracket,-1,0,0,"class<`chunk`, `data.frame`>",1
+flextable,as_bracket,0,0,0,...,1
+flextable,as_bracket,1,0,0,character,1
+flextable,as_bracket,2,0,0,character,1
+flextable,as_bracket,3,0,0,character,1
+flextable,as_chunk,-1,0,0,"class<`chunk`, `data.frame`>",1
+flextable,as_chunk,0,0,0,character[],1
+flextable,as_chunk,0,0,1,class<`factor`>,1
+flextable,as_chunk,0,0,2,^double[],1
+flextable,as_chunk,0,0,3,null,1
+flextable,as_chunk,1,0,0,class<`fp_text`>,1
+flextable,as_chunk,1,0,1,null,1
+flextable,as_chunk,2,0,0,class<`function`>,1
+flextable,as_chunk,3,0,0,...,1
+flextable,as.data.frame.cell_struct,-1,0,0,class<`data.frame`>,1
+flextable,as.data.frame.cell_struct,0,0,0,class<`cell_struct`>,1
+flextable,as.data.frame.cell_struct,1,0,0,...,1
+flextable,as.data.frame.par_struct,-1,0,0,class<`data.frame`>,1
+flextable,as.data.frame.par_struct,0,0,0,class<`par_struct`>,1
+flextable,as.data.frame.par_struct,1,0,0,...,1
+flextable,as.data.frame.text_struct,-1,0,0,class<`data.frame`>,1
+flextable,as.data.frame.text_struct,0,0,0,class<`text_struct`>,1
+flextable,as.data.frame.text_struct,1,0,0,...,1
+flextable,as_flextable,-1,0,0,class<`flextable`>,1
+flextable,as_flextable,0,0,0,"class<`data.frame`, `grouped_data`>",1
+flextable,as_flextable,1,0,0,...,1
+flextable,as_flextable.grouped_data,-1,0,0,class<`flextable`>,1
+flextable,as_flextable.grouped_data,0,0,0,"class<`data.frame`, `grouped_data`>",1
+flextable,as_flextable.grouped_data,1,0,0,null,1
+flextable,as_flextable.grouped_data,2,0,0,logical,1
+flextable,as_flextable.grouped_data,3,0,0,...,1
+flextable,as_grouped_data,-1,0,0,"class<`data.frame`, `grouped_data`>",1
+flextable,as_grouped_data,0,0,0,"class<`data.frame`, `data.table`>",1
+flextable,as_grouped_data,1,0,0,character,1
+flextable,as_grouped_data,2,0,0,null,1
+flextable,as_i,-1,0,0,"class<`chunk`, `data.frame`>",1
+flextable,as_i,0,0,0,"class<`chunk`, `data.frame`>",1
+flextable,as_i,0,0,1,double[],1
+flextable,as_image,-1,0,0,"class<`chunk`, `data.frame`, `img_src`>",1
+flextable,as_image,0,0,0,character,1
+flextable,as_image,1,0,0,double,1
+flextable,as_image,2,0,0,double,1
+flextable,as_image,3,0,0,...,1
+flextable,as_new_data,-1,0,0,class<`data.frame`>,1
+flextable,as_new_data,0,0,0,class<`flextable`>,1
+flextable,as_new_data,1,0,0,...,1
+flextable,as_new_data,2,0,0,null,1
+flextable,as_paragraph,-1,0,0,class<`paragraph`>,1
+flextable,as_paragraph,0,0,0,...,1
+flextable,as_paragraph,1,0,0,null,1
+flextable,as_struct,-1,0,0,class<`cell_struct`>,1
+flextable,as_struct,-1,0,1,class<`par_struct`>,1
+flextable,as_struct,-1,0,2,class<`text_struct`>,1
+flextable,as_struct,0,0,0,integer,1
+flextable,as_struct,1,0,0,character[],1
+flextable,as_struct,2,0,0,class<`fp_cell`>,1
+flextable,as_struct,2,0,1,class<`fp_par`>,1
+flextable,as_struct,2,0,2,class<`fp_text`>,1
+flextable,as_struct,3,0,0,class<`function`>,1
+flextable,as_sub,-1,0,0,"class<`chunk`, `data.frame`>",1
+flextable,as_sub,0,0,0,character,1
+flextable,as_sup,-1,0,0,"class<`chunk`, `data.frame`>",1
+flextable,as_sup,0,0,0,character,1
+flextable,as_wide_matrix_,-1,0,0,class<`matrix`>,1
+flextable,as_wide_matrix_,0,0,0,class<`data.frame`>,1
+flextable,as_wide_matrix_,1,0,0,character,1
+flextable,as_wide_matrix_,2,0,0,character,1
+flextable,autofit,-1,0,0,class<`flextable`>,1
+flextable,autofit,0,0,0,class<`flextable`>,1
+flextable,autofit,1,0,0,double,1
+flextable,autofit,2,0,0,double,1
+flextable,bg,-1,0,0,class<`flextable`>,1
+flextable,bg,0,0,0,class<`flextable`>,1
+flextable,bg,1,0,0,any,1
+flextable,bg,2,0,0,any,1
+flextable,bg,3,0,0,any,1
+flextable,bg,4,0,0,character,1
+flextable,body_add_flextable,-1,0,0,class<`rdocx`>,1
+flextable,body_add_flextable,0,0,0,class<`rdocx`>,1
+flextable,body_add_flextable,1,0,0,class<`flextable`>,1
+flextable,body_add_flextable,2,0,0,character,1
+flextable,body_add_flextable,3,0,0,character,1
+flextable,body_add_flextable,4,0,0,logical,1
+flextable,bold,-1,0,0,class<`flextable`>,1
+flextable,bold,0,0,0,class<`flextable`>,1
+flextable,bold,1,0,0,any,1
+flextable,bold,2,0,0,any,1
+flextable,bold,3,0,0,any,1
+flextable,bold,4,0,0,character,1
+flextable,border,-1,0,0,class<`flextable`>,1
+flextable,border,0,0,0,class<`flextable`>,1
+flextable,border,1,0,0,any,1
+flextable,border,2,0,0,any,1
+flextable,border,3,0,0,null,1
+flextable,border,3,0,1,class<`fp_border`>,1
+flextable,border,4,0,0,any,1
+flextable,border,5,0,0,any,1
+flextable,border,6,0,0,any,1
+flextable,border,7,0,0,any,1
+flextable,border_css,-1,0,0,character[],1
+flextable,border_css,0,0,0,character[],1
+flextable,border_css,1,0,0,double[],1
+flextable,border_css,2,0,0,character[],1
+flextable,border_css,3,0,0,character,1
+flextable,border_inner,-1,0,0,class<`flextable`>,1
+flextable,border_inner,0,0,0,class<`flextable`>,1
+flextable,border_inner,1,0,0,any,1
+flextable,border_inner,2,0,0,character,1
+flextable,border_inner_h,-1,0,0,class<`flextable`>,1
+flextable,border_inner_h,0,0,0,class<`flextable`>,1
+flextable,border_inner_h,1,0,0,any,1
+flextable,border_inner_h,2,0,0,character,1
+flextable,border_inner_v,-1,0,0,class<`flextable`>,1
+flextable,border_inner_v,0,0,0,class<`flextable`>,1
+flextable,border_inner_v,1,0,0,any,1
+flextable,border_inner_v,2,0,0,character,1
+flextable,border_outer,-1,0,0,class<`flextable`>,1
+flextable,border_outer,0,0,0,class<`flextable`>,1
+flextable,border_outer,1,0,0,any,1
+flextable,border_outer,2,0,0,character,1
+flextable,border_pml,-1,0,0,character[],1
+flextable,border_pml,0,0,0,character[],1
+flextable,border_pml,1,0,0,double[],1
+flextable,border_pml,2,0,0,character[],1
+flextable,border_pml,3,0,0,character,1
+flextable,border_remove,-1,0,0,class<`flextable`>,1
+flextable,border_remove,0,0,0,class<`flextable`>,1
+flextable,border_wml,-1,0,0,character[],1
+flextable,border_wml,0,0,0,character[],1
+flextable,border_wml,1,0,0,double[],1
+flextable,border_wml,2,0,0,character[],1
+flextable,border_wml,3,0,0,character,1
+flextable,cast_borders,-1,0,0,list<character | double>,1
+flextable,cast_borders,0,0,0,class<`fp_cell`>,1
+flextable,cast_borders,0,0,1,class<`fp_par`>,1
+flextable,cell_data,-1,0,0,class<`data.frame`>,1
+flextable,cell_data,0,0,0,class<`cell_struct`>,1
+flextable,cell_data,1,0,0,"class<`data.frame`, `data.table`>",1
+flextable,cell_data,2,0,0,character,1
+flextable,cell_data,3,0,0,class<`matrix`>,1
+flextable,cell_data,4,0,0,class<`matrix`>,1
+flextable,cell_data,5,0,0,double[],1
+flextable,cell_data,6,0,0,double[],1
+flextable,cell_data,7,0,0,character[],1
+flextable,[<-.cell_struct,-1,0,0,class<`cell_struct`>,1
+flextable,[<-.cell_struct,0,0,0,class<`cell_struct`>,1
+flextable,[<-.cell_struct,1,0,0,any,1
+flextable,[<-.cell_struct,2,0,0,any,1
+flextable,[<-.cell_struct,3,0,0,any,1
+flextable,[<-.cell_struct,4,0,0,class<`fp_cell`>,1
+flextable,[<-.cell_struct,4,0,1,character[],1
+flextable,[<-.cell_struct,4,0,2,double[],1
+flextable,[.cell_struct,-1,0,0,class<`matrix`>,1
+flextable,[.cell_struct,-1,0,1,double[],1
+flextable,[.cell_struct,0,0,0,class<`cell_struct`>,1
+flextable,[.cell_struct,0,0,1,class<`par_struct`>,1
+flextable,[.cell_struct,1,0,0,any,1
+flextable,[.cell_struct,2,0,0,any,1
+flextable,[.cell_struct,3,0,0,character,1
+flextable,check_choice,-1,0,0,logical,1
+flextable,check_choice,0,0,0,character,1
+flextable,check_choice,1,0,0,character[],1
+flextable,check_formula_i_and_part,-1,0,0,logical,1
+flextable,check_formula_i_and_part,0,0,0,class<`formula`>,1
+flextable,check_formula_i_and_part,0,0,1,double[],1
+flextable,check_formula_i_and_part,0,0,2,null,1
+flextable,check_formula_i_and_part,1,0,0,any,1
+flextable,check_merge,-1,0,0,class<`complex_tabpart`>,1
+flextable,check_merge,0,0,0,class<`complex_tabpart`>,1
+flextable,chunk_dataframe,-1,0,0,class<`data.frame`>,1
+flextable,chunk_dataframe,0,0,0,...,1
+flextable,[<-.chunkset_struct,-1,0,0,class<`chunkset_struct`>,1
+flextable,[<-.chunkset_struct,0,0,0,class<`chunkset_struct`>,1
+flextable,[<-.chunkset_struct,1,0,0,any,1
+flextable,[<-.chunkset_struct,2,0,0,integer[],1
+flextable,[<-.chunkset_struct,2,0,1,double,1
+flextable,[<-.chunkset_struct,2,0,2,character[],1
+flextable,[<-.chunkset_struct,3,0,0,"list<class<`chunk`, `data.frame`>>",1
+flextable,[<-.chunkset_struct,3,0,1,class<`paragraph`>,1
+flextable,[.chunkset_struct,-1,0,0,"list<class<`chunk`, `data.frame`>>",1
+flextable,[.chunkset_struct,0,0,0,class<`chunkset_struct`>,1
+flextable,[.chunkset_struct,1,0,0,any,1
+flextable,[.chunkset_struct,2,0,0,any,1
+flextable,chunkset_struct,-1,0,0,class<`chunkset_struct`>,1
+flextable,chunkset_struct,0,0,0,integer,1
+flextable,chunkset_struct,1,0,0,character[],1
+flextable,colalpha,-1,0,0,integer[],1
+flextable,colalpha,0,0,0,character[],1
+flextable,colcode0,-1,0,0,character[],1
+flextable,colcode0,0,0,0,character[],1
+flextable,colcodecss,-1,0,0,character[],1
+flextable,colcodecss,0,0,0,character[],1
+flextable,colformat_char,-1,0,0,class<`flextable`>,1
+flextable,colformat_char,0,0,0,class<`flextable`>,1
+flextable,colformat_char,1,0,0,...,1
+flextable,colformat_char.flextable,-1,0,0,class<`flextable`>,1
+flextable,colformat_char.flextable,0,0,0,class<`flextable`>,1
+flextable,colformat_char.flextable,1,0,0,null,1
+flextable,colformat_char.flextable,2,0,0,character,1
+flextable,colformat_char.flextable,3,0,0,character,1
+flextable,colformat_char.flextable,4,0,0,character,1
+flextable,colformat_char.flextable,5,0,0,character,1
+flextable,colformat_char.flextable,6,0,0,...,1
+flextable,colformat_int,-1,0,0,class<`flextable`>,1
+flextable,colformat_int,0,0,0,class<`flextable`>,1
+flextable,colformat_int,1,0,0,...,1
+flextable,colformat_int.flextable,-1,0,0,class<`flextable`>,1
+flextable,colformat_int.flextable,0,0,0,class<`flextable`>,1
+flextable,colformat_int.flextable,1,0,0,null,1
+flextable,colformat_int.flextable,2,0,0,character[],1
+flextable,colformat_int.flextable,3,0,0,character,1
+flextable,colformat_int.flextable,4,0,0,character,1
+flextable,colformat_int.flextable,5,0,0,character,1
+flextable,colformat_int.flextable,6,0,0,character,1
+flextable,colformat_int.flextable,7,0,0,...,1
+flextable,colformat_lgl,-1,0,0,class<`flextable`>,1
+flextable,colformat_lgl,0,0,0,class<`flextable`>,1
+flextable,colformat_lgl,1,0,0,...,1
+flextable,colformat_lgl.flextable,-1,0,0,class<`flextable`>,1
+flextable,colformat_lgl.flextable,0,0,0,class<`flextable`>,1
+flextable,colformat_lgl.flextable,1,0,0,null,1
+flextable,colformat_lgl.flextable,2,0,0,character[],1
+flextable,colformat_lgl.flextable,3,0,0,character,1
+flextable,colformat_lgl.flextable,4,0,0,character,1
+flextable,colformat_lgl.flextable,5,0,0,character,1
+flextable,colformat_lgl.flextable,6,0,0,character,1
+flextable,colformat_lgl.flextable,7,0,0,character,1
+flextable,colformat_num,-1,0,0,class<`flextable`>,1
+flextable,colformat_num,0,0,0,class<`flextable`>,1
+flextable,colformat_num,1,0,0,...,1
+flextable,colformat_num.flextable,-1,0,0,class<`flextable`>,1
+flextable,colformat_num.flextable,0,0,0,class<`flextable`>,1
+flextable,colformat_num.flextable,1,0,0,null,1
+flextable,colformat_num.flextable,2,0,0,character[],1
+flextable,colformat_num.flextable,3,0,0,character,1
+flextable,colformat_num.flextable,4,0,0,double,1
+flextable,colformat_num.flextable,5,0,0,character,1
+flextable,colformat_num.flextable,6,0,0,character,1
+flextable,colformat_num.flextable,7,0,0,character,1
+flextable,color,-1,0,0,class<`flextable`>,1
+flextable,color,0,0,0,class<`flextable`>,1
+flextable,color,1,0,0,any,1
+flextable,color,2,0,0,any,1
+flextable,color,3,0,0,any,1
+flextable,color,4,0,0,character,1
+flextable,complex_tabpart,-1,0,0,class<`complex_tabpart`>,1
+flextable,complex_tabpart,0,0,0,class<`data.frame`>,1
+flextable,complex_tabpart,0,0,1,"class<`data.frame`, `grouped_data`>",1
+flextable,complex_tabpart,1,0,0,character[],1
+flextable,complex_tabpart,2,0,0,class<`fp_text`>,1
+flextable,complex_tabpart,3,0,0,class<`fp_par`>,1
+flextable,complex_tabpart,4,0,0,class<`fp_cell`>,1
+flextable,complex_tabpart,5,0,0,double[],1
+flextable,complex_tabpart,6,0,0,double,1
+flextable,compose,-1,0,0,class<`flextable`>,1
+flextable,compose,0,0,0,class<`flextable`>,1
+flextable,compose,1,0,0,class<`formula`>,1
+flextable,compose,1,0,1,double,1
+flextable,compose,1,0,2,integer[],1
+flextable,compose,1,0,3,null,1
+flextable,compose,2,0,0,character,1
+flextable,compose,2,0,1,double,1
+flextable,compose,3,0,0,any,1
+flextable,compose,4,0,0,character,1
+flextable,correct_h_border,-1,0,0,class<`complex_tabpart`>,1
+flextable,correct_h_border,0,0,0,class<`complex_tabpart`>,1
+flextable,correct_v_border,-1,0,0,class<`complex_tabpart`>,1
+flextable,correct_v_border,0,0,0,class<`complex_tabpart`>,1
+flextable,css_px,-1,0,0,character[],1
+flextable,css_px,0,0,0,^double[],1
+flextable,css_px,1,0,0,character,1
+flextable,delete_part,-1,0,0,class<`flextable`>,1
+flextable,delete_part,0,0,0,class<`flextable`>,1
+flextable,delete_part,1,0,0,character,1
+flextable,dim_cells,-1,0,0,list<class<`matrix`>>,1
+flextable,dim_cells,0,0,0,class<`complex_tabpart`>,1
+flextable,dim.flextable,-1,0,0,list<double[]>,1
+flextable,dim.flextable,0,0,0,class<`flextable`>,1
+flextable,dim_paragraphs,-1,0,0,list<class<`matrix`>>,1
+flextable,dim_paragraphs,0,0,0,class<`complex_tabpart`>,1
+flextable,dim_pretty,-1,0,0,list<double[]>,1
+flextable,dim_pretty,0,0,0,class<`flextable`>,1
+flextable,dim_pretty,1,0,0,character,1
+flextable,docall_display,-1,0,0,class<`flextable`>,1
+flextable,docall_display,0,0,0,character[],1
+flextable,docall_display,1,0,0,class<`function`>,1
+flextable,docall_display,2,0,0,class<`flextable`>,1
+flextable,docall_display,3,0,0,null,1
+flextable,docx_str,-1,0,0,character,1
+flextable,docx_str,0,0,0,class<`flextable`>,1
+flextable,docx_str,1,0,0,...,1
+flextable,docx_str.flextable,-1,0,0,character,1
+flextable,docx_str.flextable,0,0,0,class<`flextable`>,1
+flextable,docx_str.flextable,1,0,0,character,1
+flextable,docx_str.flextable,2,0,0,logical,1
+flextable,docx_str.flextable,3,0,0,any,1
+flextable,docx_str.flextable,4,0,0,...,1
+flextable,docx_value,-1,0,0,character,1
+flextable,docx_value,0,0,0,class<`flextable`>,1
+flextable,docx_value,1,0,0,logical,1
+flextable,docx_value,2,0,0,null,1
+flextable,docx_value,3,0,0,null,1
+flextable,docx_value,4,0,0,null,1
+flextable,empty_blanks,-1,0,0,class<`flextable`>,1
+flextable,empty_blanks,0,0,0,class<`flextable`>,1
+flextable,fit_to_width,-1,0,0,class<`flextable`>,1
+flextable,fit_to_width,0,0,0,class<`flextable`>,1
+flextable,fit_to_width,1,0,0,double,1
+flextable,fit_to_width,2,0,0,integer,1
+flextable,fit_to_width,3,0,0,double,1
+flextable,fix_border_issues,-1,0,0,class<`flextable`>,1
+flextable,fix_border_issues,0,0,0,class<`flextable`>,1
+flextable,fix_border_issues,1,0,0,character,1
+flextable,flextable,-1,0,0,class<`flextable`>,1
+flextable,flextable,0,0,0,class<`data.frame`>,1
+flextable,flextable,0,0,1,"class<`data.frame`, `grouped_data`>",1
+flextable,flextable,0,0,2,"class<`data.frame`, `tbl`, `tbl_df`>",1
+flextable,flextable,1,0,0,character[],1
+flextable,flextable,2,0,0,double,1
+flextable,flextable,3,0,0,double,1
+flextable,flextable,4,0,0,list<any>,1
+flextable,flextable,5,0,0,class<`function`>,1
+flextable,flextable_dim,-1,0,0,list<double>,1
+flextable,flextable_dim,0,0,0,class<`flextable`>,1
+flextable,flextable_html_dependency,-1,0,0,class<`html_dependency`>,1
+flextable,font,-1,0,0,class<`flextable`>,1
+flextable,font,0,0,0,class<`flextable`>,1
+flextable,font,1,0,0,any,1
+flextable,font,2,0,0,any,1
+flextable,font,3,0,0,any,1
+flextable,font,4,0,0,character,1
+flextable,fontsize,-1,0,0,class<`flextable`>,1
+flextable,fontsize,0,0,0,class<`flextable`>,1
+flextable,fontsize,1,0,0,any,1
+flextable,fontsize,2,0,0,any,1
+flextable,fontsize,3,0,0,any,1
+flextable,fontsize,4,0,0,character,1
+flextable,footnote,-1,0,0,class<`flextable`>,1
+flextable,footnote,0,0,0,class<`flextable`>,1
+flextable,footnote,1,0,0,double,1
+flextable,footnote,2,0,0,integer[],1
+flextable,footnote,3,0,0,class<`paragraph`>,1
+flextable,footnote,4,0,0,character[],1
+flextable,footnote,5,0,0,character,1
+flextable,format.complex_tabpart,-1,0,0,character,1
+flextable,format.complex_tabpart,0,0,0,class<`complex_tabpart`>,1
+flextable,format.complex_tabpart,1,0,0,character,1
+flextable,format.complex_tabpart,2,0,0,logical,1
+flextable,format.complex_tabpart,3,0,0,logical,1
+flextable,format.complex_tabpart,4,0,0,...,1
+flextable,format_fun,-1,0,0,character[],1
+flextable,format_fun,0,0,0,character[],1
+flextable,format_fun,0,0,1,class<`factor`>,1
+flextable,format_fun,0,0,2,double[],1
+flextable,format_fun,0,0,3,null,1
+flextable,format_fun,1,0,0,character,1
+flextable,format_fun,2,0,0,...,1
+flextable,format_fun,-1,1,0,character[],1
+flextable,format_fun,0,1,0,^double[],1
+flextable,format_fun,-1,2,0,character[],1
+flextable,format_fun,0,2,0,double[],1
+flextable,format_fun,-1,3,0,character[],1
+flextable,format_fun,0,3,0,logical[],1
+flextable,format_fun,-1,4,0,character[],1
+flextable,format_fun,0,4,0,class<`factor`>,1
+flextable,format_fun.character,-1,0,0,character[],1
+flextable,format_fun.character,0,0,0,character[],1
+flextable,format_fun.character,1,0,0,character,1
+flextable,format_fun.character,2,0,0,...,1
+flextable,format_fun.double,-1,0,0,character[],1
+flextable,format_fun.double,0,0,0,double[],1
+flextable,format_fun.double,0,0,1,null,1
+flextable,format_fun.double,1,0,0,character,1
+flextable,format_fun.double,2,0,0,character,1
+flextable,format_fun.double,3,0,0,...,1
+flextable,format_fun.factor,-1,0,0,character[],1
+flextable,format_fun.factor,0,0,0,class<`factor`>,1
+flextable,format_fun.factor,1,0,0,character,1
+flextable,format_fun.factor,2,0,0,...,1
+flextable,format_fun.integer,-1,0,0,character,1
+flextable,format_fun.integer,0,0,0,integer,1
+flextable,format_fun.integer,1,0,0,character,1
+flextable,format_fun.integer,2,0,0,character,1
+flextable,format_fun.integer,3,0,0,...,1
+flextable,format_fun.logical,-1,0,0,character,1
+flextable,format_fun.logical,0,0,0,null,1
+flextable,format_fun.logical,1,0,0,character,1
+flextable,format_fun.logical,2,0,0,character,1
+flextable,format_fun.logical,3,0,0,character,1
+flextable,format_fun.logical,4,0,0,...,1
+flextable,fortify_content,-1,0,0,class<`data.frame`>,1
+flextable,fortify_content,0,0,0,class<`chunkset_struct`>,1
+flextable,fortify_content,1,0,0,class<`text_struct`>,1
+flextable,fortify_content,2,0,0,...,1
+flextable,fpstruct,-1,0,0,class<`fpstruct`>,1
+flextable,fpstruct,0,0,0,integer,1
+flextable,fpstruct,1,0,0,character[],1
+flextable,fpstruct,2,0,0,character,1
+flextable,fpstruct,2,0,1,class<`paragraph`>,1
+flextable,fpstruct,2,0,2,double,1
+flextable,fpstruct,2,0,3,null,1
+flextable,[<-.fpstruct,-1,0,0,class<`fpstruct`>,1
+flextable,[<-.fpstruct,0,0,0,class<`fpstruct`>,1
+flextable,[<-.fpstruct,1,0,0,any,1
+flextable,[<-.fpstruct,2,0,0,any,1
+flextable,[<-.fpstruct,3,0,0,character[],1
+flextable,[<-.fpstruct,3,0,1,double[],1
+flextable,[<-.fpstruct,3,0,2,class<`paragraph`>,1
+flextable,[<-.fpstruct,3,0,3,"list<class<`chunk`, `data.frame`>>",1
+flextable,[.fpstruct,-1,0,0,character[],1
+flextable,[.fpstruct,-1,0,1,class<`matrix`>,1
+flextable,[.fpstruct,-1,0,2,double[],1
+flextable,[.fpstruct,-1,0,3,"list<class<`chunk`, `data.frame`>>",1
+flextable,[.fpstruct,0,0,0,class<`fpstruct`>,1
+flextable,[.fpstruct,1,0,0,any,1
+flextable,[.fpstruct,2,0,0,any,1
+flextable,get_columns_id,-1,0,0,double[],1
+flextable,get_columns_id,0,0,0,class<`complex_tabpart`>,1
+flextable,get_columns_id,0,0,1,null,1
+flextable,get_columns_id,1,0,0,double[],1
+flextable,get_columns_id,1,0,1,character[],1
+flextable,get_columns_id,1,0,2,class<`formula`>,1
+flextable,get_columns_id,1,0,3,null,1
+flextable,get_dataset_columns_id,-1,0,0,double,1
+flextable,get_dataset_columns_id,-1,0,1,integer[],1
+flextable,get_dataset_columns_id,0,0,0,class<`complex_tabpart`>,1
+flextable,get_dataset_columns_id,1,0,0,double,1
+flextable,get_dataset_columns_id,1,0,1,character[],1
+flextable,get_dataset_columns_id,1,0,2,class<`formula`>,1
+flextable,get_dataset_columns_id,1,0,3,null,1
+flextable,get_i_from_formula,-1,0,0,logical[],1
+flextable,get_i_from_formula,0,0,0,class<`formula`>,1
+flextable,get_i_from_formula,1,0,0,class<`data.frame`>,1
+flextable,get_i_from_formula,1,0,1,"class<`data.frame`, `grouped_data`>",1
+flextable,get_j_from_formula,-1,0,0,character[],1
+flextable,get_j_from_formula,0,0,0,class<`formula`>,1
+flextable,get_j_from_formula,1,0,0,class<`data.frame`>,1
+flextable,get_rows_id,-1,0,0,double[],1
+flextable,get_rows_id,0,0,0,class<`complex_tabpart`>,1
+flextable,get_rows_id,1,0,0,double[],1
+flextable,get_rows_id,1,0,1,class<`formula`>,1
+flextable,get_rows_id,1,0,2,null,1
+flextable,get_xtable_widths,-1,0,0,^double[],1
+flextable,get_xtable_widths,0,0,0,character[],1
+flextable,get_xtable_widths,1,0,0,double,1
+flextable,height,-1,0,0,class<`data.frame`>,1
+flextable,height,-1,0,1,class<`flextable`>,1
+flextable,height,0,0,0,class<`data.frame`>,1
+flextable,height,0,0,1,class<`flextable`>,1
+flextable,height,1,0,0,null,1
+flextable,height,1,0,1,double,1
+flextable,height,2,0,0,any,1
+flextable,height,3,0,0,character,1
+flextable,height_all,-1,0,0,class<`flextable`>,1
+flextable,height_all,0,0,0,class<`flextable`>,1
+flextable,height_all,1,0,0,double,1
+flextable,height_all,2,0,0,character,1
+flextable,hline,-1,0,0,class<`flextable`>,1
+flextable,hline,0,0,0,class<`flextable`>,1
+flextable,hline,1,0,0,any,1
+flextable,hline,2,0,0,any,1
+flextable,hline,3,0,0,any,1
+flextable,hline,4,0,0,character,1
+flextable,hline_bottom,-1,0,0,class<`flextable`>,1
+flextable,hline_bottom,0,0,0,class<`flextable`>,1
+flextable,hline_bottom,1,0,0,null,1
+flextable,hline_bottom,2,0,0,class<`fp_border`>,1
+flextable,hline_bottom,3,0,0,character,1
+flextable,hline_top,-1,0,0,class<`flextable`>,1
+flextable,hline_top,0,0,0,class<`flextable`>,1
+flextable,hline_top,1,0,0,any,1
+flextable,hline_top,2,0,0,any,1
+flextable,hline_top,3,0,0,character,1
+flextable,hrule,-1,0,0,class<`data.frame`>,1
+flextable,hrule,-1,0,1,class<`flextable`>,1
+flextable,hrule,0,0,0,class<`data.frame`>,1
+flextable,hrule,0,0,1,class<`flextable`>,1
+flextable,hrule,1,0,0,null,1
+flextable,hrule,1,0,1,double,1
+flextable,hrule,2,0,0,character,1
+flextable,hrule,3,0,0,character,1
+flextable,html_str,-1,0,0,character,1
+flextable,html_str,0,0,0,class<`flextable`>,1
+flextable,html_str.flextable,-1,0,0,character,1
+flextable,html_str.flextable,0,0,0,class<`flextable`>,1
+flextable,htmltools_value,-1,0,0,class<`shiny.tag`>,1
+flextable,htmltools_value,0,0,0,class<`flextable`>,1
+flextable,htmltools_value,1,0,0,null,1
+flextable,htmltools_value,2,0,0,character,1
+flextable,hyperlink_text,-1,0,0,"class<`chunk`, `data.frame`>",1
+flextable,hyperlink_text,0,0,0,character,1
+flextable,hyperlink_text,1,0,0,null,1
+flextable,hyperlink_text,2,0,0,class<`function`>,1
+flextable,hyperlink_text,3,0,0,character,1
+flextable,hyperlink_text,4,0,0,...,1
+flextable,italic,-1,0,0,class<`flextable`>,1
+flextable,italic,0,0,0,class<`flextable`>,1
+flextable,italic,1,0,0,any,1
+flextable,italic,2,0,0,any,1
+flextable,italic,3,0,0,any,1
+flextable,italic,4,0,0,character,1
+flextable,linerange,-1,0,0,"class<`chunk`, `data.frame`, `img_chunk`>",1
+flextable,linerange,0,0,0,double[],1
+flextable,linerange,1,0,0,null,1
+flextable,linerange,2,0,0,double,1
+flextable,linerange,2,0,1,null,1
+flextable,linerange,3,0,0,character,1
+flextable,linerange,4,0,0,character,1
+flextable,linerange,5,0,0,character,1
+flextable,linerange,6,0,0,double,1
+flextable,linerange,7,0,0,double,1
+flextable,lollipop,-1,0,0,"class<`chunk`, `data.frame`, `img_chunk`>",1
+flextable,lollipop,0,0,0,double[],1
+flextable,lollipop,1,0,0,double,1
+flextable,lollipop,2,0,0,double,1
+flextable,lollipop,3,0,0,character,1
+flextable,lollipop,4,0,0,character,1
+flextable,lollipop,5,0,0,double,1
+flextable,lollipop,6,0,0,double,1
+flextable,lollipop,7,0,0,double,1
+flextable,merge_at,-1,0,0,class<`flextable`>,1
+flextable,merge_at,0,0,0,class<`flextable`>,1
+flextable,merge_at,1,0,0,double,1
+flextable,merge_at,1,0,1,integer[],1
+flextable,merge_at,1,0,2,null,1
+flextable,merge_at,2,0,0,double[],1
+flextable,merge_at,3,0,0,character,1
+flextable,merge_h,-1,0,0,class<`flextable`>,1
+flextable,merge_h,0,0,0,class<`flextable`>,1
+flextable,merge_h,1,0,0,null,1
+flextable,merge_h,2,0,0,character,1
+flextable,merge_h_range,-1,0,0,class<`flextable`>,1
+flextable,merge_h_range,0,0,0,class<`flextable`>,1
+flextable,merge_h_range,1,0,0,class<`formula`>,1
+flextable,merge_h_range,1,0,1,logical[],1
+flextable,merge_h_range,2,0,0,character,1
+flextable,merge_h_range,2,0,1,double,1
+flextable,merge_h_range,3,0,0,character,1
+flextable,merge_h_range,3,0,1,integer,1
+flextable,merge_h_range,4,0,0,character,1
+flextable,merge_none,-1,0,0,class<`flextable`>,1
+flextable,merge_none,0,0,0,class<`flextable`>,1
+flextable,merge_none,1,0,0,character,1
+flextable,merge_rle,-1,0,0,integer[],1
+flextable,merge_rle,0,0,0,character[],1
+flextable,merge_v,-1,0,0,class<`flextable`>,1
+flextable,merge_v,0,0,0,class<`flextable`>,1
+flextable,merge_v,1,0,0,character[],1
+flextable,merge_v,1,0,1,class<`formula`>,1
+flextable,merge_v,1,0,2,double,1
+flextable,merge_v,1,0,3,null,1
+flextable,merge_v,2,0,0,null,1
+flextable,merge_v,2,0,1,character[],1
+flextable,merge_v,3,0,0,character,1
+flextable,minibar,-1,0,0,"class<`chunk`, `data.frame`, `img_chunk`>",1
+flextable,minibar,0,0,0,double[],1
+flextable,minibar,1,0,0,double,1
+flextable,minibar,1,0,1,null,1
+flextable,minibar,2,0,0,character,1
+flextable,minibar,3,0,0,character,1
+flextable,minibar,4,0,0,double,1
+flextable,minibar,5,0,0,double,1
+flextable,nrow_part,-1,0,0,double,1
+flextable,nrow_part,0,0,0,class<`data.frame`>,1
+flextable,nrow_part,0,0,1,class<`flextable`>,1
+flextable,nrow_part,1,0,0,character,1
+flextable,optimal_sizes,-1,0,0,list<double[]>,1
+flextable,optimal_sizes,0,0,0,class<`complex_tabpart`>,1
+flextable,padding,-1,0,0,class<`flextable`>,1
+flextable,padding,0,0,0,class<`flextable`>,1
+flextable,padding,1,0,0,any,1
+flextable,padding,2,0,0,any,1
+flextable,padding,3,0,0,null,1
+flextable,padding,3,0,1,double,1
+flextable,padding,4,0,0,any,1
+flextable,padding,5,0,0,any,1
+flextable,padding,6,0,0,any,1
+flextable,padding,7,0,0,any,1
+flextable,par_data,-1,0,0,"class<`data.frame`, `data.table`>",1
+flextable,par_data,0,0,0,class<`par_struct`>,1
+flextable,par_data,1,0,0,class<`data.frame`>,1
+flextable,par_data,2,0,0,character,1
+flextable,par_data,3,0,0,any,1
+flextable,par_data,4,0,0,any,1
+flextable,[<-.par_struct,-1,0,0,class<`par_struct`>,1
+flextable,[<-.par_struct,0,0,0,class<`par_struct`>,1
+flextable,[<-.par_struct,1,0,0,double,1
+flextable,[<-.par_struct,1,0,1,integer[],1
+flextable,[<-.par_struct,2,0,0,integer[],1
+flextable,[<-.par_struct,3,0,0,any,1
+flextable,[<-.par_struct,4,0,0,character,1
+flextable,[<-.par_struct,4,0,1,double,1
+flextable,[<-.par_struct,4,0,2,class<`fp_par`>,1
+flextable,[.par_struct,-1,0,0,class<`matrix`>,1
+flextable,[.par_struct,-1,0,1,double[],1
+flextable,[.par_struct,0,0,0,class<`cell_struct`>,1
+flextable,[.par_struct,0,0,1,class<`par_struct`>,1
+flextable,[.par_struct,1,0,0,any,1
+flextable,[.par_struct,2,0,0,any,1
+flextable,[.par_struct,3,0,0,character,1
+flextable,ph_with.flextable,-1,0,0,class<`rpptx`>,1
+flextable,ph_with.flextable,0,0,0,class<`rpptx`>,1
+flextable,ph_with.flextable,1,0,0,class<`flextable`>,1
+flextable,ph_with.flextable,2,0,0,"class<`location_left`, `location_str`>",1
+flextable,ph_with.flextable,2,0,1,"class<`location_str`, `location_type`>",1
+flextable,ph_with.flextable,3,0,0,...,1
+flextable,pml_flextable,-1,0,0,character,1
+flextable,pml_flextable,0,0,0,class<`flextable`>,1
+flextable,pml_flextable,1,0,0,integer,1
+flextable,pml_flextable,2,0,0,double,1
+flextable,pml_flextable,3,0,0,double,1
+flextable,pml_flextable,4,0,0,double,1
+flextable,pml_flextable,5,0,0,double,1
+flextable,print.flextable,-1,0,0,null,1
+flextable,print.flextable,0,0,0,class<`flextable`>,1
+flextable,print.flextable,1,0,0,character,1
+flextable,print.flextable,2,0,0,...,1
+flextable,proc_freq,-1,0,0,class<`flextable`>,1
+flextable,proc_freq,0,0,0,class<`data.frame`>,1
+flextable,proc_freq,1,0,0,character,1
+flextable,proc_freq,2,0,0,character,1
+flextable,proc_freq,3,0,0,character,1
+flextable,proc_freq,4,0,0,logical,1
+flextable,proc_freq,5,0,0,logical,1
+flextable,proc_freq,6,0,0,logical,1
+flextable,proc_freq,7,0,0,logical,1
+flextable,qflextable,-1,0,0,class<`flextable`>,1
+flextable,qflextable,0,0,0,class<`data.frame`>,1
+flextable,rbind.match.columns,-1,0,0,"class<`chunk`, `data.frame`>",1
+flextable,rbind.match.columns,-1,0,1,"class<`chunk`, `data.frame`, `img_chunk`>",1
+flextable,rbind.match.columns,-1,0,2,"class<`chunk`, `data.frame`, `img_src`>",1
+flextable,rbind.match.columns,-1,0,3,class<`data.frame`>,1
+flextable,rbind.match.columns,0,0,0,"list<class<`chunk`, `data.frame`>>",1
+flextable,rbind.match.columns,0,0,1,"list<class<`chunk`, `data.frame`, `img_chunk`> | class<`chunk`, `data.frame`>>",1
+flextable,rbind.match.columns,0,0,2,"list<class<`chunk`, `data.frame`, `img_chunk`>>",1
+flextable,rbind.match.columns,0,0,3,"list<class<`chunk`, `data.frame`, `img_src`> | class<`chunk`, `data.frame`>>",1
+flextable,rbind.match.columns,0,0,4,"list<class<`chunk`, `data.frame`, `img_src`>>",1
+flextable,rbind.match.columns,0,0,5,list<class<`data.frame`>>,1
+flextable,replace_missing_fptext_by_default,-1,0,0,class<`data.frame`>,1
+flextable,replace_missing_fptext_by_default,0,0,0,class<`data.frame`>,1
+flextable,replace_missing_fptext_by_default,1,0,0,class<`data.frame`>,1
+flextable,rotate,-1,0,0,class<`flextable`>,1
+flextable,rotate,0,0,0,class<`flextable`>,1
+flextable,rotate,1,0,0,null,1
+flextable,rotate,2,0,0,double,1
+flextable,rotate,2,0,1,integer[],1
+flextable,rotate,2,0,2,null,1
+flextable,rotate,3,0,0,character,1
+flextable,rotate,4,0,0,character,1
+flextable,rotate,5,0,0,character,1
+flextable,run_data,-1,0,0,class<`data.frame`>,1
+flextable,run_data,0,0,0,class<`data.frame`>,1
+flextable,run_data,1,0,0,character,1
+flextable,save_as_docx,-1,0,0,character,1
+flextable,save_as_docx,0,0,0,...,1
+flextable,save_as_docx,1,0,0,null,1
+flextable,save_as_docx,2,0,0,character,1
+flextable,save_as_html,-1,0,0,character,1
+flextable,save_as_html,0,0,0,class<`flextable`>,1
+flextable,save_as_html,1,0,0,character,1
+flextable,save_as_pptx,-1,0,0,character,1
+flextable,save_as_pptx,0,0,0,...,1
+flextable,save_as_pptx,1,0,0,null,1
+flextable,save_as_pptx,2,0,0,character,1
+flextable,set_caption,-1,0,0,class<`flextable`>,1
+flextable,set_caption,0,0,0,class<`flextable`>,1
+flextable,set_caption,1,0,0,character,1
+flextable,set_caption,2,0,0,logical,1
+flextable,set_footer_df,-1,0,0,class<`flextable`>,1
+flextable,set_footer_df,0,0,0,class<`flextable`>,1
+flextable,set_footer_df,1,0,0,class<`data.frame`>,1
+flextable,set_footer_df,2,0,0,character,1
+flextable,set_formatter,-1,0,0,class<`flextable`>,1
+flextable,set_formatter,0,0,0,class<`flextable`>,1
+flextable,set_formatter,1,0,0,...,1
+flextable,set_formatter,2,0,0,null,1
+flextable,set_formatter,3,0,0,character,1
+flextable,set_header_df,-1,0,0,class<`flextable`>,1
+flextable,set_header_df,0,0,0,class<`flextable`>,1
+flextable,set_header_df,1,0,0,class<`data.frame`>,1
+flextable,set_header_df,2,0,0,character,1
+flextable,set_header_labels,-1,0,0,class<`flextable`>,1
+flextable,set_header_labels,0,0,0,class<`flextable`>,1
+flextable,set_header_labels,1,0,0,...,1
+flextable,set_header_labels,2,0,0,null,1
+flextable,set_header_labels,2,0,1,list<character>,1
+flextable,set_part_df,-1,0,0,class<`flextable`>,1
+flextable,set_part_df,0,0,0,class<`flextable`>,1
+flextable,set_part_df,1,0,0,class<`data.frame`>,1
+flextable,set_part_df,2,0,0,character,1
+flextable,set_part_df,3,0,0,character,1
+flextable,span_cells_at,-1,0,0,class<`complex_tabpart`>,1
+flextable,span_cells_at,0,0,0,class<`complex_tabpart`>,1
+flextable,span_cells_at,1,0,0,character[],1
+flextable,span_cells_at,2,0,0,double,1
+flextable,span_cells_at,2,0,1,integer[],1
+flextable,span_columns,-1,0,0,class<`complex_tabpart`>,1
+flextable,span_columns,0,0,0,class<`complex_tabpart`>,1
+flextable,span_columns,1,0,0,character[],1
+flextable,span_columns,2,0,0,character[],1
+flextable,span_free,-1,0,0,class<`complex_tabpart`>,1
+flextable,span_free,-1,0,1,list<list<double[]>>,1
+flextable,span_free,0,0,0,class<`complex_tabpart`>,1
+flextable,span_free,0,0,1,null,1
+flextable,span_rows,-1,0,0,class<`complex_tabpart`>,1
+flextable,span_rows,0,0,0,class<`complex_tabpart`>,1
+flextable,span_rows,1,0,0,integer[],1
+flextable,style,-1,0,0,class<`flextable`>,1
+flextable,style,0,0,0,class<`flextable`>,1
+flextable,style,1,0,0,class<`formula`>,1
+flextable,style,1,0,1,null,1
+flextable,style,2,0,0,class<`formula`>,1
+flextable,style,2,0,1,null,1
+flextable,style,3,0,0,class<`fp_text`>,1
+flextable,style,3,0,1,null,1
+flextable,style,4,0,0,null,1
+flextable,style,4,0,1,class<`fp_par`>,1
+flextable,style,5,0,0,null,1
+flextable,style,5,0,1,class<`fp_cell`>,1
+flextable,style,6,0,0,character,1
+flextable,text_metric,-1,0,0,class<`data.frame`>,1
+flextable,text_metric,0,0,0,class<`complex_tabpart`>,1
+flextable,[<-.text_struct,-1,0,0,class<`text_struct`>,1
+flextable,[<-.text_struct,0,0,0,class<`text_struct`>,1
+flextable,[<-.text_struct,1,0,0,double,1
+flextable,[<-.text_struct,1,0,1,integer[],1
+flextable,[<-.text_struct,2,0,0,integer[],1
+flextable,[<-.text_struct,2,0,1,double,1
+flextable,[<-.text_struct,3,0,0,any,1
+flextable,[<-.text_struct,4,0,0,character,1
+flextable,[<-.text_struct,4,0,1,double,1
+flextable,[<-.text_struct,4,0,2,class<`fp_text`>,1
+flextable,theme_alafoli,-1,0,0,class<`flextable`>,1
+flextable,theme_alafoli,0,0,0,class<`flextable`>,1
+flextable,theme_booktabs,-1,0,0,class<`flextable`>,1
+flextable,theme_booktabs,0,0,0,class<`flextable`>,1
+flextable,theme_booktabs,1,0,0,double,1
+flextable,theme_box,-1,0,0,class<`flextable`>,1
+flextable,theme_box,0,0,0,class<`flextable`>,1
+flextable,theme_tron,-1,0,0,class<`flextable`>,1
+flextable,theme_tron,0,0,0,class<`flextable`>,1
+flextable,theme_tron_legacy,-1,0,0,class<`flextable`>,1
+flextable,theme_tron_legacy,0,0,0,class<`flextable`>,1
+flextable,theme_vader,-1,0,0,class<`flextable`>,1
+flextable,theme_vader,0,0,0,class<`flextable`>,1
+flextable,theme_vader,1,0,0,double,1
+flextable,theme_vanilla,-1,0,0,class<`flextable`>,1
+flextable,theme_vanilla,0,0,0,class<`flextable`>,1
+flextable,theme_zebra,-1,0,0,class<`flextable`>,1
+flextable,theme_zebra,0,0,0,class<`flextable`>,1
+flextable,theme_zebra,1,0,0,character,1
+flextable,theme_zebra,2,0,0,character,1
+flextable,theme_zebra,3,0,0,character,1
+flextable,theme_zebra,4,0,0,character,1
+flextable,valign,-1,0,0,class<`flextable`>,1
+flextable,valign,0,0,0,class<`flextable`>,1
+flextable,valign,1,0,0,any,1
+flextable,valign,2,0,0,any,1
+flextable,valign,3,0,0,any,1
+flextable,valign,4,0,0,character,1
+flextable,vline,-1,0,0,class<`flextable`>,1
+flextable,vline,0,0,0,class<`flextable`>,1
+flextable,vline,1,0,0,any,1
+flextable,vline,2,0,0,any,1
+flextable,vline,3,0,0,any,1
+flextable,vline,4,0,0,character,1
+flextable,vline_left,-1,0,0,class<`flextable`>,1
+flextable,vline_left,0,0,0,class<`flextable`>,1
+flextable,vline_left,1,0,0,any,1
+flextable,vline_left,2,0,0,any,1
+flextable,vline_left,3,0,0,character,1
+flextable,vline_right,-1,0,0,class<`flextable`>,1
+flextable,vline_right,0,0,0,class<`flextable`>,1
+flextable,vline_right,1,0,0,any,1
+flextable,vline_right,2,0,0,any,1
+flextable,vline_right,3,0,0,character,1
+flextable,void,-1,0,0,class<`flextable`>,1
+flextable,void,0,0,0,class<`flextable`>,1
+flextable,void,1,0,0,any,1
+flextable,void,2,0,0,character,1
+flextable,width,-1,0,0,class<`data.frame`>,1
+flextable,width,-1,0,1,class<`flextable`>,1
+flextable,width,0,0,0,class<`data.frame`>,1
+flextable,width,0,0,1,class<`flextable`>,1
+flextable,width,1,0,0,null,1
+flextable,width,1,0,1,class<`formula`>,1
+flextable,width,1,0,2,double[],1
+flextable,width,2,0,0,double[],1
+flextable,xtable_to_flextable,-1,0,0,class<`flextable`>,1
+flextable,xtable_to_flextable,0,0,0,"class<`data.frame`, `xtable`>",1
+flextable,xtable_to_flextable,1,0,0,class<`fp_text`>,1
+flextable,xtable_to_flextable,2,0,0,null,1
+flextable,xtable_to_flextable,3,0,0,character,1
+flextable,xtable_to_flextable,4,0,0,double[],1
+flextable,xtable_to_flextable,5,0,0,any,1
+flextable,xtable_to_flextable,6,0,0,logical,1
+flextable,xtable_to_flextable,7,0,0,logical,1
+forcats,as_factor,-1,0,0,class<`factor`>,1
+forcats,as_factor,0,0,0,character[],1
+forcats,as_factor,0,0,1,double[],1
+forcats,as_factor,1,0,0,...,1
+forcats,as_factor.character,-1,0,0,class<`factor`>,1
+forcats,as_factor.character,0,0,0,character[],1
+forcats,as_factor.character,1,0,0,...,1
+forcats,as_factor.numeric,-1,0,0,class<`factor`>,1
+forcats,as_factor.numeric,0,0,0,double[],1
+forcats,as_factor.numeric,1,0,0,...,1
+forcats,check_calc_levels,-1,0,0,any,1
+forcats,check_calc_levels,0,0,0,class<`factor`>,1
+forcats,check_calc_levels,0,0,1,character[],1
+forcats,check_calc_levels,1,0,0,double[],1
+forcats,check_calc_levels,1,0,1,null,1
+forcats,check_factor,-1,0,0,class<`factor`>,1
+forcats,check_factor,-1,0,1,"class<`factor`, `ordered`>",1
+forcats,check_factor,0,0,0,^character[],1
+forcats,check_factor,0,0,1,class<`factor`>,1
+forcats,check_factor,0,0,2,"class<`factor`, `ordered`>",1
+forcats,check_factor_list,-1,0,0,list<class<`factor`>>,1
+forcats,check_factor_list,0,0,0,list<class<`factor`>>,1
+forcats,check_factor_list,1,0,0,character,1
+forcats,check_recode_levels,-1,0,0,character[],1
+forcats,check_recode_levels,0,0,0,...,1
+forcats,check_weights,-1,0,0,any,1
+forcats,check_weights,0,0,0,double[],1
+forcats,check_weights,0,0,1,null,1
+forcats,check_weights,1,0,0,any,1
+forcats,digits,-1,0,0,integer,1
+forcats,digits,0,0,0,integer[],1
+forcats,fct_anon,-1,0,0,class<`factor`>,1
+forcats,fct_anon,0,0,0,class<`factor`>,1
+forcats,fct_anon,1,0,0,character,1
+forcats,fct_c,-1,0,0,class<`factor`>,1
+forcats,fct_c,0,0,0,...,1
+forcats,fct_collapse,-1,0,0,class<`factor`>,1
+forcats,fct_collapse,0,0,0,class<`factor`>,1
+forcats,fct_collapse,1,0,0,...,1
+forcats,fct_collapse,2,0,0,null,1
+forcats,fct_collapse,3,0,0,character,1
+forcats,fct_count,-1,0,0,"class<`data.frame`, `tbl`, `tbl_df`>",1
+forcats,fct_count,0,0,0,class<`factor`>,1
+forcats,fct_count,1,0,0,logical,1
+forcats,fct_count,2,0,0,logical,1
+forcats,fct_cross,-1,0,0,class<`factor`>,1
+forcats,fct_cross,0,0,0,...,1
+forcats,fct_cross,1,0,0,character,1
+forcats,fct_cross,2,0,0,logical,1
+forcats,fct_drop,-1,0,0,class<`factor`>,1
+forcats,fct_drop,0,0,0,class<`factor`>,1
+forcats,fct_drop,1,0,0,any,1
+forcats,fct_expand,-1,0,0,class<`factor`>,1
+forcats,fct_expand,0,0,0,class<`factor`>,1
+forcats,fct_expand,1,0,0,...,1
+forcats,fct_explicit_na,-1,0,0,class<`factor`>,1
+forcats,fct_explicit_na,0,0,0,class<`factor`>,1
+forcats,fct_explicit_na,1,0,0,character,1
+forcats,fct_infreq,-1,0,0,class<`factor`>,1
+forcats,fct_infreq,0,0,0,class<`factor`>,1
+forcats,fct_infreq,1,0,0,null,1
+forcats,fct_inorder,-1,0,0,class<`factor`>,1
+forcats,fct_inorder,0,0,0,^character[],1
+forcats,fct_inorder,0,0,1,class<`factor`>,1
+forcats,fct_inorder,1,0,0,null,1
+forcats,fct_inseq,-1,0,0,class<`factor`>,1
+forcats,fct_inseq,0,0,0,class<`factor`>,1
+forcats,fct_inseq,1,0,0,null,1
+forcats,fct_lump,-1,0,0,class<`factor`>,1
+forcats,fct_lump,0,0,0,character[],1
+forcats,fct_lump,0,0,1,class<`factor`>,1
+forcats,fct_lump,1,0,0,any,1
+forcats,fct_lump,2,0,0,any,1
+forcats,fct_lump,3,0,0,null,1
+forcats,fct_lump,4,0,0,character,1
+forcats,fct_lump,5,0,0,character[],1
+forcats,fct_lump_lowfreq,-1,0,0,class<`factor`>,1
+forcats,fct_lump_lowfreq,0,0,0,class<`factor`>,1
+forcats,fct_lump_lowfreq,1,0,0,character,1
+forcats,fct_lump_min,-1,0,0,class<`factor`>,1
+forcats,fct_lump_min,0,0,0,class<`factor`>,1
+forcats,fct_lump_min,1,0,0,double,1
+forcats,fct_lump_min,2,0,0,null,1
+forcats,fct_lump_min,3,0,0,character,1
+forcats,fct_lump_n,-1,0,0,any,1
+forcats,fct_lump_n,0,0,0,character[],1
+forcats,fct_lump_n,0,0,1,class<`factor`>,1
+forcats,fct_lump_n,1,0,0,double,1
+forcats,fct_lump_n,2,0,0,null,1
+forcats,fct_lump_n,2,0,1,double[],1
+forcats,fct_lump_n,3,0,0,character,1
+forcats,fct_lump_n,4,0,0,character[],1
+forcats,fct_lump_prop,-1,0,0,class<`factor`>,1
+forcats,fct_lump_prop,0,0,0,character[],1
+forcats,fct_lump_prop,0,0,1,class<`factor`>,1
+forcats,fct_lump_prop,1,0,0,double,1
+forcats,fct_lump_prop,2,0,0,null,1
+forcats,fct_lump_prop,3,0,0,character,1
+forcats,fct_match,-1,0,0,logical[],1
+forcats,fct_match,0,0,0,class<`factor`>,1
+forcats,fct_match,1,0,0,character[],1
+forcats,fct_other,-1,0,0,class<`factor`>,1
+forcats,fct_other,0,0,0,class<`factor`>,1
+forcats,fct_other,1,0,0,any,1
+forcats,fct_other,2,0,0,any,1
+forcats,fct_other,3,0,0,character,1
+forcats,fct_recode,-1,0,0,class<`factor`>,1
+forcats,fct_recode,0,0,0,class<`factor`>,1
+forcats,fct_recode,1,0,0,...,1
+forcats,fct_relabel,-1,0,0,class<`factor`>,1
+forcats,fct_relabel,0,0,0,class<`factor`>,1
+forcats,fct_relabel,1,0,0,class<`formula`>,1
+forcats,fct_relabel,1,0,1,class<`function`>,1
+forcats,fct_relabel,2,0,0,...,1
+forcats,fct_relevel,-1,0,0,class<`factor`>,1
+forcats,fct_relevel,0,0,0,class<`factor`>,1
+forcats,fct_relevel,1,0,0,...,1
+forcats,fct_relevel,2,0,0,double,1
+forcats,fct_reorder,-1,0,0,class<`factor`>,1
+forcats,fct_reorder,0,0,0,class<`factor`>,1
+forcats,fct_reorder,1,0,0,double[],1
+forcats,fct_reorder,2,0,0,class<`function`>,1
+forcats,fct_reorder,3,0,0,...,1
+forcats,fct_reorder,4,0,0,logical,1
+forcats,fct_reorder2,-1,0,0,class<`factor`>,1
+forcats,fct_reorder2,0,0,0,class<`factor`>,1
+forcats,fct_reorder2,1,0,0,double[],1
+forcats,fct_reorder2,2,0,0,double[],1
+forcats,fct_reorder2,3,0,0,class<`function`>,1
+forcats,fct_reorder2,4,0,0,...,1
+forcats,fct_reorder2,5,0,0,logical,1
+forcats,fct_rev,-1,0,0,class<`factor`>,1
+forcats,fct_rev,0,0,0,class<`factor`>,1
+forcats,fct_shift,-1,0,0,"class<`factor`, `ordered`>",1
+forcats,fct_shift,0,0,0,"class<`factor`, `ordered`>",1
+forcats,fct_shift,1,0,0,double,1
+forcats,fct_shuffle,-1,0,0,class<`factor`>,1
+forcats,fct_shuffle,-1,0,1,"class<`factor`, `ordered`>",1
+forcats,fct_shuffle,0,0,0,class<`factor`>,1
+forcats,fct_shuffle,0,0,1,"class<`factor`, `ordered`>",1
+forcats,fct_unify,-1,0,0,list<class<`factor`>>,1
+forcats,fct_unify,0,0,0,list<class<`factor`>>,1
+forcats,fct_unify,1,0,0,character[],1
+forcats,fct_unique,-1,0,0,class<`factor`>,1
+forcats,fct_unique,0,0,0,class<`factor`>,1
+forcats,in_smallest,-1,0,0,logical[],1
+forcats,in_smallest,0,0,0,integer[],1
+forcats,lump_cutoff,-1,0,0,double,1
+forcats,lump_cutoff,0,0,0,integer[],1
+forcats,lvls_expand,-1,0,0,class<`factor`>,1
+forcats,lvls_expand,0,0,0,class<`factor`>,1
+forcats,lvls_expand,1,0,0,character[],1
+forcats,lvls_reorder,-1,0,0,class<`factor`>,1
+forcats,lvls_reorder,-1,0,1,"class<`factor`, `ordered`>",1
+forcats,lvls_reorder,0,0,0,class<`factor`>,1
+forcats,lvls_reorder,0,0,1,"class<`factor`, `ordered`>",1
+forcats,lvls_reorder,1,0,0,double[],1
+forcats,lvls_reorder,2,0,0,null,1
+forcats,lvls_revalue,-1,0,0,class<`factor`>,1
+forcats,lvls_revalue,0,0,0,class<`factor`>,1
+forcats,lvls_revalue,1,0,0,character[],1
+forcats,lvls_seq,-1,0,0,integer[],1
+forcats,lvls_seq,0,0,0,class<`factor`>,1
+forcats,lvls_seq,0,0,1,"class<`factor`, `ordered`>",1
+forcats,lvls_union,-1,0,0,character[],1
+forcats,lvls_union,0,0,0,list<class<`factor`>>,1
+forcats,refactor,-1,0,0,class<`factor`>,1
+forcats,refactor,-1,0,1,"class<`factor`, `ordered`>",1
+forcats,refactor,0,0,0,class<`factor`>,1
+forcats,refactor,0,0,1,"class<`factor`, `ordered`>",1
+forcats,refactor,1,0,0,character[],1
+forcats,refactor,2,0,0,null,1
+forcats,shift,-1,0,0,double[],1
+forcats,shift,0,0,0,integer,1
+forcats,shift,1,0,0,double,1
+forcats,zero_pad,-1,0,0,character[],1
+forcats,zero_pad,0,0,0,integer[],1
+foreach,%:%,-1,0,0,"class<`filteredforeach`, `foreach`>",1
+foreach,%:%,-1,0,1,"class<`foreach`, `xforeach`>",1
+foreach,%:%,0,0,0,class<`foreach`>,1
+foreach,%:%,1,0,0,class<`foreachCondition`>,1
+foreach,%:%,1,0,1,class<`foreach`>,1
+foreach,accumulate,-1,0,0,logical,1
+foreach,accumulate,-1,0,1,null,1
+foreach,accumulate,0,0,0,"class<`ifilteredforeach`, `iter`>",1
+foreach,accumulate,0,0,1,"class<`iforeach`, `iter`>",1
+foreach,accumulate,0,0,2,"class<`iter`, `ixforeach`>",1
+foreach,accumulate,1,0,0,class<`data.frame`>,1
+foreach,accumulate,1,0,1,class<`matrix`>,1
+foreach,accumulate,1,0,2,class<`randomForest`>,1
+foreach,accumulate,1,0,3,double[],1
+foreach,accumulate,1,0,4,list<double>,1
+foreach,accumulate,2,0,0,double,1
+foreach,accumulate,3,0,0,...,1
+foreach,accumulate.ifilteredforeach,-1,0,0,logical,1
+foreach,accumulate.ifilteredforeach,0,0,0,"class<`ifilteredforeach`, `iter`>",1
+foreach,accumulate.ifilteredforeach,1,0,0,double,1
+foreach,accumulate.ifilteredforeach,2,0,0,double,1
+foreach,accumulate.ifilteredforeach,3,0,0,...,1
+foreach,accumulate.iforeach,-1,0,0,logical,1
+foreach,accumulate.iforeach,0,0,0,"class<`iforeach`, `iter`>",1
+foreach,accumulate.iforeach,1,0,0,class<`data.frame`>,1
+foreach,accumulate.iforeach,1,0,1,class<`matrix`>,1
+foreach,accumulate.iforeach,1,0,2,class<`randomForest`>,1
+foreach,accumulate.iforeach,1,0,3,double[],1
+foreach,accumulate.iforeach,1,0,4,list<double>,1
+foreach,accumulate.iforeach,2,0,0,double,1
+foreach,accumulate.iforeach,3,0,0,...,1
+foreach,accumulate.ixforeach,-1,0,0,null,1
+foreach,accumulate.ixforeach,0,0,0,"class<`iter`, `ixforeach`>",1
+foreach,accumulate.ixforeach,1,0,0,class<`data.frame`>,1
+foreach,accumulate.ixforeach,1,0,1,double,1
+foreach,accumulate.ixforeach,2,0,0,double,1
+foreach,accumulate.ixforeach,3,0,0,...,1
+foreach,callCombine,-1,0,0,null,1
+foreach,callCombine,0,0,0,"class<`iforeach`, `iter`>",1
+foreach,callCombine,1,0,0,any,1
+foreach,complete,-1,0,0,logical,1
+foreach,complete,0,0,0,"class<`iforeach`, `iter`>",1
+foreach,%do%,-1,0,0,class<`matrix`>,1
+foreach,%do%,-1,0,1,class<`randomForest`>,1
+foreach,%do%,-1,0,2,double[],1
+foreach,%do%,-1,0,3,list<double>,1
+foreach,%do%,-1,0,4,null,1
+foreach,%do%,0,0,0,class<`foreach`>,1
+foreach,%do%,0,0,1,"class<`foreach`, `xforeach`>",1
+foreach,%do%,0,0,2,"class<`filteredforeach`, `foreach`>",1
+foreach,%do%,1,0,0,any,1
+foreach,%dopar%,-1,0,0,class<`data.frame`>,1
+foreach,%dopar%,-1,0,1,class<`matrix`>,1
+foreach,%dopar%,-1,0,2,class<`randomForest`>,1
+foreach,%dopar%,-1,0,3,integer[],1
+foreach,%dopar%,-1,0,4,list<double>,1
+foreach,%dopar%,0,0,0,class<`foreach`>,1
+foreach,%dopar%,0,0,1,"class<`foreach`, `xforeach`>",1
+foreach,%dopar%,1,0,0,any,1
+foreach,foreach,-1,0,0,class<`foreach`>,1
+foreach,foreach,0,0,0,...,1
+foreach,foreach,1,0,0,any,1
+foreach,foreach,2,0,0,any,1
+foreach,foreach,3,0,0,null,1
+foreach,foreach,4,0,0,logical,1
+foreach,foreach,5,0,0,logical,1
+foreach,foreach,6,0,0,double,1
+foreach,foreach,7,0,0,character[],1
+foreach,foreach,8,0,0,character,1
+foreach,foreach,8,0,1,null,1
+foreach,getDoPar,-1,0,0,list<class<`function`> | null>,1
+foreach,getDoParName,-1,0,0,null,1
+foreach,getDoParRegistered,-1,0,0,logical,1
+foreach,getDoParVersion,-1,0,0,null,1
+foreach,getDoParWorkers,-1,0,0,integer,1
+foreach,getDoSeq,-1,0,0,list<class<`function`> | null>,1
+foreach,getDoSeqName,-1,0,0,null,1
+foreach,getDoSeqRegistered,-1,0,0,logical,1
+foreach,getDoSeqVersion,-1,0,0,null,1
+foreach,getDoSeqWorkers,-1,0,0,integer,1
+foreach,getErrorIndex,-1,0,0,integer,1
+foreach,getErrorIndex,0,0,0,"class<`ifilteredforeach`, `iter`>",1
+foreach,getErrorIndex,0,0,1,"class<`iforeach`, `iter`>",1
+foreach,getErrorIndex,0,0,2,"class<`iter`, `ixforeach`>",1
+foreach,getErrorIndex,1,0,0,...,1
+foreach,getErrorIndex.ifilteredforeach,-1,0,0,integer,1
+foreach,getErrorIndex.ifilteredforeach,0,0,0,"class<`ifilteredforeach`, `iter`>",1
+foreach,getErrorIndex.ifilteredforeach,1,0,0,...,1
+foreach,getErrorIndex.iforeach,-1,0,0,integer,1
+foreach,getErrorIndex.iforeach,0,0,0,"class<`iforeach`, `iter`>",1
+foreach,getErrorIndex.iforeach,0,0,1,"class<`iter`, `ixforeach`>",1
+foreach,getErrorIndex.iforeach,1,0,0,...,1
+foreach,getErrorIndex.ixforeach,-1,0,0,integer,1
+foreach,getErrorIndex.ixforeach,0,0,0,"class<`iforeach`, `iter`>",1
+foreach,getErrorIndex.ixforeach,0,0,1,"class<`iter`, `ixforeach`>",1
+foreach,getErrorIndex.ixforeach,1,0,0,...,1
+foreach,getErrorValue,-1,0,0,null,1
+foreach,getErrorValue,0,0,0,"class<`ifilteredforeach`, `iter`>",1
+foreach,getErrorValue,0,0,1,"class<`iforeach`, `iter`>",1
+foreach,getErrorValue,0,0,2,"class<`iter`, `ixforeach`>",1
+foreach,getErrorValue,1,0,0,...,1
+foreach,getErrorValue.ifilteredforeach,-1,0,0,null,1
+foreach,getErrorValue.ifilteredforeach,0,0,0,"class<`ifilteredforeach`, `iter`>",1
+foreach,getErrorValue.ifilteredforeach,1,0,0,...,1
+foreach,getErrorValue.iforeach,-1,0,0,null,1
+foreach,getErrorValue.iforeach,0,0,0,"class<`iforeach`, `iter`>",1
+foreach,getErrorValue.iforeach,0,0,1,"class<`iter`, `ixforeach`>",1
+foreach,getErrorValue.iforeach,1,0,0,...,1
+foreach,getErrorValue.ixforeach,-1,0,0,null,1
+foreach,getErrorValue.ixforeach,0,0,0,"class<`iforeach`, `iter`>",1
+foreach,getErrorValue.ixforeach,0,0,1,"class<`iter`, `ixforeach`>",1
+foreach,getErrorValue.ixforeach,1,0,0,...,1
+foreach,getResult,-1,0,0,class<`data.frame`>,1
+foreach,getResult,-1,0,1,class<`matrix`>,1
+foreach,getResult,-1,0,2,class<`randomForest`>,1
+foreach,getResult,-1,0,3,double[],1
+foreach,getResult,-1,0,4,list<double>,1
+foreach,getResult,-1,0,5,null,1
+foreach,getResult,0,0,0,"class<`iforeach`, `iter`>",1
+foreach,getResult,0,0,1,"class<`iter`, `ixforeach`>",1
+foreach,getResult,0,0,2,"class<`ifilteredforeach`, `iter`>",1
+foreach,getResult,1,0,0,...,1
+foreach,getResult.ifilteredforeach,-1,0,0,double[],1
+foreach,getResult.ifilteredforeach,-1,0,1,null,1
+foreach,getResult.ifilteredforeach,-1,0,2,class<`data.frame`>,1
+foreach,getResult.ifilteredforeach,-1,0,3,class<`matrix`>,1
+foreach,getResult.ifilteredforeach,0,0,0,"class<`ifilteredforeach`, `iter`>",1
+foreach,getResult.ifilteredforeach,0,0,1,"class<`iter`, `ixforeach`>",1
+foreach,getResult.ifilteredforeach,1,0,0,...,1
+foreach,getResult.iforeach,-1,0,0,class<`data.frame`>,1
+foreach,getResult.iforeach,-1,0,1,class<`matrix`>,1
+foreach,getResult.iforeach,-1,0,2,class<`randomForest`>,1
+foreach,getResult.iforeach,-1,0,3,double[],1
+foreach,getResult.iforeach,-1,0,4,list<double>,1
+foreach,getResult.iforeach,-1,0,5,null,1
+foreach,getResult.iforeach,0,0,0,"class<`iforeach`, `iter`>",1
+foreach,getResult.iforeach,1,0,0,...,1
+foreach,getResult.ixforeach,-1,0,0,double[],1
+foreach,getResult.ixforeach,-1,0,1,null,1
+foreach,getResult.ixforeach,-1,0,2,class<`data.frame`>,1
+foreach,getResult.ixforeach,-1,0,3,class<`matrix`>,1
+foreach,getResult.ixforeach,0,0,0,"class<`ifilteredforeach`, `iter`>",1
+foreach,getResult.ixforeach,0,0,1,"class<`iter`, `ixforeach`>",1
+foreach,getResult.ixforeach,1,0,0,...,1
+foreach,iter.filteredforeach,-1,0,0,"class<`ifilteredforeach`, `iter`>",1
+foreach,iter.filteredforeach,0,0,0,"class<`filteredforeach`, `foreach`>",1
+foreach,iter.filteredforeach,1,0,0,...,1
+foreach,iter.foreach,-1,0,0,"class<`iforeach`, `iter`>",1
+foreach,iter.foreach,0,0,0,class<`foreach`>,1
+foreach,iter.foreach,1,0,0,...,1
+foreach,iter.foreach,2,0,0,list<any>,1
+foreach,iter.xforeach,-1,0,0,"class<`iter`, `ixforeach`>",1
+foreach,iter.xforeach,0,0,0,"class<`foreach`, `xforeach`>",1
+foreach,iter.xforeach,1,0,0,...,1
+foreach,makeAccum,-1,0,0,class<`function`>,1
+foreach,makeAccum,0,0,0,any,1
+foreach,makeFiltered,-1,0,0,"class<`filteredforeach`, `foreach`>",1
+foreach,makeFiltered,0,0,0,class<`foreach`>,1
+foreach,makeFiltered,1,0,0,class<`foreachCondition`>,1
+foreach,makeMerged,-1,0,0,"class<`foreach`, `xforeach`>",1
+foreach,makeMerged,0,0,0,class<`foreach`>,1
+foreach,makeMerged,1,0,0,class<`foreach`>,1
+foreach,nextElem.ifilteredforeach,-1,0,0,any,1
+foreach,nextElem.ifilteredforeach,0,0,0,"class<`ifilteredforeach`, `iter`>",1
+foreach,nextElem.ifilteredforeach,1,0,0,...,1
+foreach,nextElem.ifilteredforeach,2,0,0,logical,1
+foreach,nextElem.iforeach,-1,0,0,any,1
+foreach,nextElem.iforeach,0,0,0,"class<`iforeach`, `iter`>",1
+foreach,nextElem.iforeach,1,0,0,...,1
+foreach,nextElem.iforeach,2,0,0,logical,1
+foreach,nextElem.ixforeach,-1,0,0,any,1
+foreach,nextElem.ixforeach,0,0,0,"class<`iter`, `ixforeach`>",1
+foreach,nextElem.ixforeach,1,0,0,...,1
+foreach,nextElem.ixforeach,2,0,0,logical,1
+foreach,registerDoSEQ,-1,0,0,class<`function`>,1
+foreach,setDoPar,-1,0,0,class<`function`>,1
+foreach,setDoPar,0,0,0,class<`function`>,1
+foreach,setDoPar,1,0,0,null,1
+foreach,setDoPar,2,0,0,class<`function`>,1
+foreach,setDoSeq,-1,0,0,class<`function`>,1
+foreach,setDoSeq,0,0,0,class<`function`>,1
+foreach,setDoSeq,1,0,0,null,1
+foreach,setDoSeq,2,0,0,class<`function`>,1
+foreach,times,-1,0,0,class<`foreach`>,1
+foreach,times,0,0,0,double,1
+foreach,when,-1,0,0,class<`foreachCondition`>,1
+foreach,when,0,0,0,any,1
+forecast,accuracy,-1,0,0,class<`matrix`>,1
+forecast,accuracy,0,0,0,"class<`ARIMA`, `Arima`, `forecast_ARIMA`>",1
+forecast,accuracy,0,0,1,class<`ets`>,1
+forecast,accuracy,0,0,2,class<`forecast`>,1
+forecast,accuracy,0,0,3,"class<`forecast`, `splineforecast`>",1
+forecast,accuracy,0,0,4,class<`ts`>,1
+forecast,accuracy,1,0,0,...,1
+forecast,accuracy.default,-1,0,0,class<`matrix`>,1
+forecast,accuracy.default,0,0,0,"class<`ARIMA`, `Arima`, `forecast_ARIMA`>",1
+forecast,accuracy.default,0,0,1,class<`ets`>,1
+forecast,accuracy.default,0,0,2,class<`forecast`>,1
+forecast,accuracy.default,0,0,3,"class<`forecast`, `splineforecast`>",1
+forecast,accuracy.default,0,0,4,class<`ts`>,1
+forecast,accuracy.default,1,0,0,any,1
+forecast,accuracy.default,2,0,0,null,1
+forecast,accuracy.default,2,0,1,integer[],1
+forecast,accuracy.default,3,0,0,null,1
+forecast,accuracy.default,4,0,0,null,1
+forecast,accuracy.default,5,0,0,...,1
+forecast,Acf,-1,0,0,class<`acf`>,1
+forecast,Acf,0,0,0,class<`ts`>,1
+forecast,Acf,1,0,0,double,1
+forecast,Acf,1,0,1,null,1
+forecast,Acf,2,0,0,character[],1
+forecast,Acf,3,0,0,logical,1
+forecast,Acf,4,0,0,class<`function`>,1
+forecast,Acf,5,0,0,any,1
+forecast,Acf,6,0,0,...,1
+forecast,admissible,-1,0,0,double,1
+forecast,admissible,0,0,0,double,1
+forecast,admissible,1,0,0,double,1
+forecast,admissible,1,0,1,null,1
+forecast,admissible,2,0,0,null,1
+forecast,admissible,2,0,1,double,1
+forecast,admissible,3,0,0,double,1
+forecast,admissible,3,0,1,null,1
+forecast,admissible,4,0,0,any,1
+forecast,arfima,-1,0,0,"class<`ARFIMA`, `fracdiff`>",1
+forecast,arfima,0,0,0,double[],1
+forecast,arfima,1,0,0,double[],1
+forecast,arfima,2,0,0,character[],1
+forecast,arfima,3,0,0,null,1
+forecast,arfima,4,0,0,null,1
+forecast,arfima,5,0,0,logical,1
+forecast,arfima,6,0,0,double[],1
+forecast,arfima,7,0,0,...,1
+forecast,Arima,-1,0,0,"class<`ARIMA`, `Arima`, `forecast_ARIMA`>",1
+forecast,Arima,0,0,0,class<`ts`>,1
+forecast,Arima,0,0,1,double[],1
+forecast,Arima,1,0,0,double[],1
+forecast,Arima,2,0,0,double[],1
+forecast,Arima,2,0,1,list<double[]>,1
+forecast,Arima,3,0,0,null,1
+forecast,Arima,4,0,0,logical,1
+forecast,Arima,5,0,0,logical,1
+forecast,Arima,6,0,0,any,1
+forecast,Arima,7,0,0,double,1
+forecast,Arima,7,0,1,null,1
+forecast,arima2,-1,0,0,"class<`ARIMA`, `Arima`, `forecast_ARIMA`>",1
+forecast,arima2,0,0,0,double[],1
+forecast,arima2,1,0,0,"class<`ARIMA`, `Arima`, `forecast_ARIMA`>",1
+forecast,arima2,2,0,0,any,1
+forecast,arima2,3,0,0,character[],1
+forecast,arimaorder,-1,0,0,integer[],1
+forecast,arimaorder,0,0,0,"class<`ARIMA`, `Arima`, `forecast_ARIMA`>",1
+forecast,arima.string,-1,0,0,character,1
+forecast,arima.string,0,0,0,"class<`ARIMA`, `Arima`, `forecast_ARIMA`>",1
+forecast,arima.string,1,0,0,logical,1
+forecast,arroots,-1,0,0,class<`armaroots`>,1
+forecast,arroots,0,0,0,class<`ar`>,1
+forecast,arroots,0,0,1,"class<`ARIMA`, `Arima`, `forecast_ARIMA`>",1
+forecast,as.character.Arima,-1,0,0,character,1
+forecast,as.character.Arima,0,0,0,"class<`ARIMA`, `Arima`, `forecast_ARIMA`>",1
+forecast,as.character.Arima,1,0,0,...,1
+forecast,as.data.frame.forecast,-1,0,0,class<`data.frame`>,1
+forecast,as.data.frame.forecast,0,0,0,class<`forecast`>,1
+forecast,as.data.frame.forecast,0,0,1,"class<`forecast`, `splineforecast`>",1
+forecast,as.data.frame.forecast,1,0,0,...,1
+forecast,auto.arima,-1,0,0,"class<`ARIMA`, `Arima`, `forecast_ARIMA`>",1
+forecast,auto.arima,0,0,0,class<`ts`>,1
+forecast,auto.arima,0,0,1,double[],1
+forecast,auto.arima,1,0,0,null,1
+forecast,auto.arima,2,0,0,null,1
+forecast,auto.arima,3,0,0,double,1
+forecast,auto.arima,4,0,0,double,1
+forecast,auto.arima,5,0,0,double,1
+forecast,auto.arima,6,0,0,double,1
+forecast,auto.arima,7,0,0,double,1
+forecast,autolayer.forecast,-1,0,0,"class<`Layer`, `LayerInstance`, `gg`, `ggproto`>",1
+forecast,autolayer.forecast,0,0,0,class<`forecast`>,1
+forecast,autolayer.forecast,0,0,1,"class<`forecast`, `splineforecast`>",1
+forecast,autolayer.forecast,1,0,0,null,1
+forecast,autolayer.forecast,2,0,0,logical,1
+forecast,autolayer.forecast,3,0,0,logical,1
+forecast,autolayer.forecast,4,0,0,...,1
+forecast,autolayer.mforecast,-1,0,0,"list<class<`Layer`, `LayerInstance`, `gg`, `ggproto`>>",1
+forecast,autolayer.mforecast,0,0,0,class<`mforecast`>,1
+forecast,autolayer.mforecast,1,0,0,null,1
+forecast,autolayer.mforecast,2,0,0,logical,1
+forecast,autolayer.mforecast,3,0,0,...,1
+forecast,autolayer.ts,-1,0,0,"class<`Layer`, `LayerInstance`, `gg`, `ggproto`>",1
+forecast,autolayer.ts,0,0,0,class<`ts`>,1
+forecast,autolayer.ts,1,0,0,logical,1
+forecast,autolayer.ts,2,0,0,character,1
+forecast,autolayer.ts,3,0,0,...,1
+forecast,autoplot.acf,-1,0,0,"class<`gg`, `ggplot`>",1
+forecast,autoplot.acf,0,0,0,class<`acf`>,1
+forecast,autoplot.acf,1,0,0,double,1
+forecast,autoplot.acf,2,0,0,...,1
+forecast,autoplot.ar,-1,0,0,"class<`gg`, `ggplot`>",1
+forecast,autoplot.ar,0,0,0,class<`ar`>,1
+forecast,autoplot.ar,1,0,0,...,1
+forecast,autoplot.Arima,-1,0,0,"class<`gg`, `ggplot`>",1
+forecast,autoplot.Arima,0,0,0,class<`ar`>,1
+forecast,autoplot.Arima,0,0,1,"class<`ARIMA`, `Arima`, `forecast_ARIMA`>",1
+forecast,autoplot.Arima,1,0,0,any,1
+forecast,autoplot.Arima,2,0,0,...,1
+forecast,autoplot.decomposed.ts,-1,0,0,"class<`gg`, `ggplot`>",1
+forecast,autoplot.decomposed.ts,0,0,0,class<`decomposed.ts`>,1
+forecast,autoplot.decomposed.ts,1,0,0,null,1
+forecast,autoplot.decomposed.ts,2,0,0,null,1
+forecast,autoplot.decomposed.ts,3,0,0,...,1
+forecast,autoplot.ets,-1,0,0,"class<`gg`, `ggplot`>",1
+forecast,autoplot.ets,0,0,0,class<`ets`>,1
+forecast,autoplot.ets,1,0,0,null,1
+forecast,autoplot.ets,2,0,0,...,1
+forecast,autoplot.forecast,-1,0,0,"class<`gg`, `ggplot`>",1
+forecast,autoplot.forecast,0,0,0,class<`forecast`>,1
+forecast,autoplot.forecast,1,0,0,any,1
+forecast,autoplot.forecast,2,0,0,logical,1
+forecast,autoplot.forecast,3,0,0,any,1
+forecast,autoplot.forecast,4,0,0,character,1
+forecast,autoplot.forecast,5,0,0,double,1
+forecast,autoplot.forecast,6,0,0,...,1
+forecast,autoplot.mforecast,-1,0,0,"class<`gg`, `ggplot`>",1
+forecast,autoplot.mforecast,-1,0,1,null,1
+forecast,autoplot.mforecast,0,0,0,class<`mforecast`>,1
+forecast,autoplot.mforecast,1,0,0,logical,1
+forecast,autoplot.mforecast,2,0,0,logical,1
+forecast,autoplot.mforecast,3,0,0,logical,1
+forecast,autoplot.mforecast,4,0,0,...,1
+forecast,autoplot.mstl,-1,0,0,"class<`gg`, `ggplot`>",1
+forecast,autoplot.mstl,0,0,0,"class<`mstl`, `msts`, `mts`, `ts`>",1
+forecast,autoplot.mstl,0,0,1,"class<`mstl`, `mts`, `ts`>",1
+forecast,autoplot.mstl,1,0,0,...,1
+forecast,autoplot.mts,-1,0,0,"class<`gg`, `ggplot`>",1
+forecast,autoplot.mts,0,0,0,"class<`mstl`, `msts`, `mts`, `ts`>",1
+forecast,autoplot.mts,0,0,1,"class<`mstl`, `mts`, `ts`>",1
+forecast,autoplot.mts,0,0,2,"class<`matrix`, `mts`, `ts`>",1
+forecast,autoplot.mts,1,0,0,logical,1
+forecast,autoplot.mts,2,0,0,logical,1
+forecast,autoplot.mts,3,0,0,character,1
+forecast,autoplot.mts,4,0,0,character[],1
+forecast,autoplot.mts,5,0,0,null,1
+forecast,autoplot.mts,6,0,0,...,1
+forecast,autoplot.splineforecast,-1,0,0,"class<`gg`, `ggplot`>",1
+forecast,autoplot.splineforecast,0,0,0,"class<`forecast`, `splineforecast`>",1
+forecast,autoplot.splineforecast,1,0,0,logical,1
+forecast,autoplot.splineforecast,2,0,0,...,1
+forecast,autoplot.stl,-1,0,0,"class<`gg`, `ggplot`>",1
+forecast,autoplot.stl,0,0,0,class<`stl`>,1
+forecast,autoplot.stl,1,0,0,null,1
+forecast,autoplot.stl,2,0,0,logical,1
+forecast,autoplot.stl,3,0,0,...,1
+forecast,autoplot.ts,-1,0,0,"class<`gg`, `ggplot`>",1
+forecast,autoplot.ts,0,0,0,class<`ts`>,1
+forecast,autoplot.ts,1,0,0,character,1
+forecast,autoplot.ts,1,0,1,null,1
+forecast,autoplot.ts,2,0,0,character,1
+forecast,autoplot.ts,3,0,0,character,1
+forecast,autoplot.ts,4,0,0,null,1
+forecast,autoplot.ts,4,0,1,character,1
+forecast,autoplot.ts,5,0,0,...,1
+forecast,avnnet,-1,0,0,class<`nnetarmodels`>,1
+forecast,avnnet,0,0,0,class<`matrix`>,1
+forecast,avnnet,1,0,0,double[],1
+forecast,avnnet,2,0,0,double,1
+forecast,avnnet,3,0,0,logical,1
+forecast,avnnet,4,0,0,logical,1
+forecast,avnnet,5,0,0,...,1
+forecast,baggedModel,-1,0,0,class<`baggedModel`>,1
+forecast,baggedModel,0,0,0,class<`ts`>,1
+forecast,baggedModel,1,0,0,list<class<`ts`>>,1
+forecast,baggedModel,2,0,0,class<`function`>,1
+forecast,baggedModel,3,0,0,...,1
+forecast,bizdays,-1,0,0,class<`ts`>,1
+forecast,bizdays,0,0,0,class<`ts`>,1
+forecast,bizdays,1,0,0,character,1
+forecast,bld.mbb.bootstrap,-1,0,0,list<class<`ts`>>,1
+forecast,bld.mbb.bootstrap,0,0,0,class<`ts`>,1
+forecast,bld.mbb.bootstrap,1,0,0,double,1
+forecast,bld.mbb.bootstrap,2,0,0,null,1
+forecast,BoxCox,-1,0,0,class<`ts`>,1
+forecast,BoxCox,0,0,0,class<`ts`>,1
+forecast,BoxCox,1,0,0,double,1
+forecast,BoxCox.lambda,-1,0,0,double,1
+forecast,BoxCox.lambda,0,0,0,class<`ts`>,1
+forecast,BoxCox.lambda,1,0,0,character[],1
+forecast,BoxCox.lambda,2,0,0,double,1
+forecast,BoxCox.lambda,3,0,0,double,1
+forecast,calcOCSBCritVal,-1,0,0,double,1
+forecast,calcOCSBCritVal,0,0,0,double,1
+forecast,Ccf,-1,0,0,class<`acf`>,1
+forecast,Ccf,0,0,0,class<`ts`>,1
+forecast,Ccf,1,0,0,class<`ts`>,1
+forecast,Ccf,2,0,0,null,1
+forecast,Ccf,3,0,0,character[],1
+forecast,Ccf,4,0,0,logical,1
+forecast,Ccf,5,0,0,class<`function`>,1
+forecast,Ccf,6,0,0,...,1
+forecast,check.param,-1,0,0,double,1
+forecast,check.param,0,0,0,double,1
+forecast,check.param,1,0,0,double,1
+forecast,check.param,1,0,1,null,1
+forecast,check.param,2,0,0,null,1
+forecast,check.param,2,0,1,double,1
+forecast,check.param,3,0,0,double,1
+forecast,check.param,3,0,1,null,1
+forecast,check.param,4,0,0,double[],1
+forecast,check.param,5,0,0,double[],1
+forecast,check.param,6,0,0,character,1
+forecast,check.param,7,0,0,any,1
+forecast,checkresiduals,-1,0,0,class<`htest`>,1
+forecast,checkresiduals,0,0,0,class<`ets`>,1
+forecast,checkresiduals,1,0,0,any,1
+forecast,checkresiduals,2,0,0,null,1
+forecast,checkresiduals,3,0,0,any,1
+forecast,checkresiduals,4,0,0,logical,1
+forecast,checkresiduals,5,0,0,...,1
+forecast,class1,-1,0,0,list<double[]>,1
+forecast,class1,0,0,0,double,1
+forecast,class1,1,0,0,double[],1
+forecast,class1,2,0,0,character,1
+forecast,class1,3,0,0,character,1
+forecast,class1,4,0,0,any,1
+forecast,class1,5,0,0,any,1
+forecast,class1,6,0,0,double,1
+forecast,class1,7,0,0,double[],1
+forecast,class2,-1,0,0,list<double[]>,1
+forecast,class2,0,0,0,double,1
+forecast,class2,1,0,0,double[],1
+forecast,class2,2,0,0,character,1
+forecast,class2,3,0,0,character,1
+forecast,class2,4,0,0,logical,1
+forecast,class2,5,0,0,any,1
+forecast,class2,6,0,0,double,1
+forecast,class2,7,0,0,double[],1
+forecast,class3,-1,0,0,list<double[]>,1
+forecast,class3,0,0,0,double,1
+forecast,class3,1,0,0,double[],1
+forecast,class3,2,0,0,character,1
+forecast,class3,3,0,0,any,1
+forecast,class3,4,0,0,logical,1
+forecast,class3,5,0,0,double,1
+forecast,class3,6,0,0,double,1
+forecast,class3,7,0,0,double[],1
+forecast,croston,-1,0,0,class<`forecast`>,1
+forecast,croston,0,0,0,integer[],1
+forecast,croston,1,0,0,double,1
+forecast,croston,2,0,0,double,1
+forecast,croston,3,0,0,integer[],1
+forecast,croston2,-1,0,0,class<`ts`>,1
+forecast,croston2,-1,0,1,list<class<`ts`> | list<class<`forecast`>>>,1
+forecast,croston2,0,0,0,integer[],1
+forecast,croston2,1,0,0,double,1
+forecast,croston2,2,0,0,any,1
+forecast,croston2,3,0,0,logical,1
+forecast,CV,-1,0,0,double[],1
+forecast,CV,0,0,0,"class<`lm`, `tslm`>",1
+forecast,CVar,-1,0,0,"class<`CVar`, `nnetar`>",1
+forecast,CVar,0,0,0,class<`ts`>,1
+forecast,CVar,1,0,0,double,1
+forecast,CVar,2,0,0,class<`function`>,1
+forecast,CVar,3,0,0,logical,1
+forecast,CVar,4,0,0,logical,1
+forecast,CVar,5,0,0,double,1
+forecast,CVar,6,0,0,...,1
+forecast,datamat,-1,0,0,class<`data.frame`>,1
+forecast,datamat,0,0,0,...,1
+forecast,datamat,1,0,0,logical,1
+forecast,datamat,2,0,0,logical,1
+forecast,dm.test,-1,0,0,class<`htest`>,1
+forecast,dm.test,0,0,0,class<`ts`>,1
+forecast,dm.test,1,0,0,class<`ts`>,1
+forecast,dm.test,2,0,0,character[],1
+forecast,dm.test,3,0,0,double,1
+forecast,dm.test,4,0,0,double,1
+forecast,easter,-1,0,0,class<`ts`>,1
+forecast,easter,0,0,0,class<`ts`>,1
+forecast,easter,1,0,0,logical,1
+forecast,ets,-1,0,0,class<`ets`>,1
+forecast,ets,0,0,0,class<`ts`>,1
+forecast,ets,0,0,1,double[],1
+forecast,ets,1,0,0,character,1
+forecast,ets,1,0,1,class<`ets`>,1
+forecast,ets,2,0,0,logical,1
+forecast,ets,2,0,1,null,1
+forecast,ets,3,0,0,null,1
+forecast,ets,4,0,0,null,1
+forecast,ets,5,0,0,null,1
+forecast,ets,6,0,0,null,1
+forecast,ets,7,0,0,logical,1
+forecast,etsmodel,-1,0,0,list<any>,1
+forecast,etsmodel,0,0,0,class<`ts`>,1
+forecast,etsmodel,1,0,0,character,1
+forecast,etsmodel,2,0,0,character,1
+forecast,etsmodel,3,0,0,character,1
+forecast,etsmodel,4,0,0,logical,1
+forecast,etsmodel,5,0,0,null,1
+forecast,etsmodel,5,0,1,double,1
+forecast,etsmodel,6,0,0,null,1
+forecast,etsmodel,6,0,1,double,1
+forecast,etsmodel,7,0,0,null,1
+forecast,etsTargetFunctionInit,-1,0,0,environment,1
+forecast,etsTargetFunctionInit,0,0,0,double[],1
+forecast,etsTargetFunctionInit,1,0,0,class<`ts`>,1
+forecast,etsTargetFunctionInit,2,0,0,integer,1
+forecast,etsTargetFunctionInit,3,0,0,character,1
+forecast,etsTargetFunctionInit,4,0,0,character,1
+forecast,etsTargetFunctionInit,5,0,0,character,1
+forecast,etsTargetFunctionInit,6,0,0,logical,1
+forecast,etsTargetFunctionInit,7,0,0,null,1
+forecast,etsTargetFunctionInit,7,0,1,double[],1
+forecast,findfrequency,-1,0,0,integer,1
+forecast,findfrequency,0,0,0,"class<`msts`, `ts`>",1
+forecast,findfrequency,0,0,1,class<`ts`>,1
+forecast,fitted.ar,-1,0,0,class<`ts`>,1
+forecast,fitted.ar,0,0,0,class<`ar`>,1
+forecast,fitted.ar,1,0,0,...,1
+forecast,fitted.Arima,-1,0,0,class<`ts`>,1
+forecast,fitted.Arima,0,0,0,"class<`ARIMA`, `Arima`, `forecast_ARIMA`>",1
+forecast,fitted.Arima,1,0,0,double,1
+forecast,fitted.Arima,2,0,0,...,1
+forecast,fitted.ets,-1,0,0,class<`ts`>,1
+forecast,fitted.ets,0,0,0,class<`ets`>,1
+forecast,fitted.ets,1,0,0,double,1
+forecast,fitted.ets,2,0,0,...,1
+forecast,fitted.forecast_ARIMA,-1,0,0,class<`ts`>,1
+forecast,fitted.forecast_ARIMA,0,0,0,"class<`ARIMA`, `Arima`, `forecast_ARIMA`>",1
+forecast,fitted.forecast_ARIMA,1,0,0,double,1
+forecast,fitted.forecast_ARIMA,2,0,0,...,1
+forecast,fitted.lagwalk,-1,0,0,class<`ts`>,1
+forecast,fitted.lagwalk,0,0,0,class<`lagwalk`>,1
+forecast,fitted.lagwalk,1,0,0,...,1
+forecast,fitted.nnetar,-1,0,0,class<`ts`>,1
+forecast,fitted.nnetar,0,0,0,class<`nnetar`>,1
+forecast,fitted.nnetar,1,0,0,double,1
+forecast,fitted.nnetar,2,0,0,...,1
+forecast,fitted.tslm,-1,0,0,class<`ts`>,1
+forecast,fitted.tslm,0,0,0,"class<`lm`, `tslm`>",1
+forecast,fitted.tslm,1,0,0,...,1
+forecast,forecast,-1,0,0,class<`forecast`>,1
+forecast,forecast,-1,0,1,class<`mforecast`>,1
+forecast,forecast,0,0,0,class<`ar`>,1
+forecast,forecast,0,0,1,"class<`ARFIMA`, `fracdiff`>",1
+forecast,forecast,0,0,2,"class<`ARIMA`, `Arima`, `forecast_ARIMA`>",1
+forecast,forecast,0,0,3,class<`baggedModel`>,1
+forecast,forecast,0,0,4,class<`ets`>,1
+forecast,forecast,0,0,5,class<`HoltWinters`>,1
+forecast,forecast,0,0,6,class<`lagwalk`>,1
+forecast,forecast,0,0,7,"class<`lm`, `tslm`>",1
+forecast,forecast,0,0,8,"class<`mstl`, `mts`, `ts`>",1
+forecast,forecast,0,0,9,class<`nnetar`>,1
+forecast,forecast,0,0,10,class<`stl`>,1
+forecast,forecast,0,0,11,class<`stlm`>,1
+forecast,forecast,0,0,12,class<`StructTS`>,1
+forecast,forecast,0,0,13,class<`ts`>,1
+forecast,forecast,0,0,14,"class<`lm`, `mlm`>",1
+forecast,forecast,0,0,15,"class<`lm`, `mlm`, `tslm`>",1
+forecast,forecast,1,0,0,...,1
+forecast,forecast2plotdf,-1,0,0,class<`data.frame`>,1
+forecast,forecast2plotdf,0,0,0,class<`forecast`>,1
+forecast,forecast2plotdf,0,0,1,"class<`forecast`, `splineforecast`>",1
+forecast,forecast2plotdf,1,0,0,class<`data.frame`>,1
+forecast,forecast2plotdf,2,0,0,logical,1
+forecast,forecast2plotdf,3,0,0,logical,1
+forecast,forecast2plotdf,4,0,0,...,1
+forecast,forecast.ar,-1,0,0,class<`forecast`>,1
+forecast,forecast.ar,0,0,0,class<`ar`>,1
+forecast,forecast.ar,1,0,0,double,1
+forecast,forecast.ar,2,0,0,double[],1
+forecast,forecast.ar,3,0,0,logical,1
+forecast,forecast.ar,4,0,0,double,1
+forecast,forecast.ar,4,0,1,null,1
+forecast,forecast.ar,5,0,0,logical,1
+forecast,forecast.ar,6,0,0,double,1
+forecast,forecast.ar,7,0,0,logical,1
+forecast,forecast.baggedModel,-1,0,0,class<`forecast`>,1
+forecast,forecast.baggedModel,0,0,0,class<`baggedModel`>,1
+forecast,forecast.baggedModel,1,0,0,double,1
+forecast,forecast.baggedModel,2,0,0,...,1
+forecast,forecast.ets,-1,0,0,class<`forecast`>,1
+forecast,forecast.ets,0,0,0,class<`ets`>,1
+forecast,forecast.ets,1,0,0,double,1
+forecast,forecast.ets,2,0,0,any,1
+forecast,forecast.ets,3,0,0,any,1
+forecast,forecast.ets,4,0,0,logical,1
+forecast,forecast.ets,5,0,0,logical,1
+forecast,forecast.ets,6,0,0,double,1
+forecast,forecast.ets,7,0,0,logical,1
+forecast,forecast.forecast_ARIMA,-1,0,0,class<`forecast`>,1
+forecast,forecast.forecast_ARIMA,0,0,0,"class<`ARIMA`, `Arima`, `forecast_ARIMA`>",1
+forecast,forecast.forecast_ARIMA,1,0,0,any,1
+forecast,forecast.forecast_ARIMA,2,0,0,double[],1
+forecast,forecast.forecast_ARIMA,3,0,0,logical,1
+forecast,forecast.forecast_ARIMA,4,0,0,class<`matrix`>,1
+forecast,forecast.forecast_ARIMA,4,0,1,null,1
+forecast,forecast.forecast_ARIMA,5,0,0,null,1
+forecast,forecast.forecast_ARIMA,5,0,1,double,1
+forecast,forecast.forecast_ARIMA,6,0,0,logical,1
+forecast,forecast.forecast_ARIMA,7,0,0,double,1
+forecast,forecast.fracdiff,-1,0,0,class<`forecast`>,1
+forecast,forecast.fracdiff,0,0,0,"class<`ARFIMA`, `fracdiff`>",1
+forecast,forecast.fracdiff,1,0,0,double,1
+forecast,forecast.fracdiff,2,0,0,double[],1
+forecast,forecast.fracdiff,3,0,0,logical,1
+forecast,forecast.fracdiff,4,0,0,null,1
+forecast,forecast.fracdiff,5,0,0,null,1
+forecast,forecast.fracdiff,6,0,0,...,1
+forecast,forecast.HoltWinters,-1,0,0,class<`forecast`>,1
+forecast,forecast.HoltWinters,0,0,0,class<`HoltWinters`>,1
+forecast,forecast.HoltWinters,1,0,0,double,1
+forecast,forecast.HoltWinters,2,0,0,double[],1
+forecast,forecast.HoltWinters,3,0,0,logical,1
+forecast,forecast.HoltWinters,4,0,0,null,1
+forecast,forecast.HoltWinters,5,0,0,null,1
+forecast,forecast.HoltWinters,6,0,0,...,1
+forecast,forecast.lagwalk,-1,0,0,class<`forecast`>,1
+forecast,forecast.lagwalk,0,0,0,class<`lagwalk`>,1
+forecast,forecast.lagwalk,1,0,0,double,1
+forecast,forecast.lagwalk,2,0,0,double[],1
+forecast,forecast.lagwalk,3,0,0,logical,1
+forecast,forecast.lagwalk,4,0,0,null,1
+forecast,forecast.lagwalk,5,0,0,logical,1
+forecast,forecast.lagwalk,6,0,0,double,1
+forecast,forecast.lagwalk,7,0,0,any,1
+forecast,forecast.lm,-1,0,0,class<`forecast`>,1
+forecast,forecast.lm,0,0,0,class<`lm`>,1
+forecast,forecast.lm,0,0,1,"class<`lm`, `tslm`>",1
+forecast,forecast.lm,1,0,0,any,1
+forecast,forecast.lm,2,0,0,double,1
+forecast,forecast.lm,3,0,0,double[],1
+forecast,forecast.lm,4,0,0,logical,1
+forecast,forecast.lm,5,0,0,null,1
+forecast,forecast.lm,6,0,0,null,1
+forecast,forecast.lm,7,0,0,logical,1
+forecast,forecast.mlm,-1,0,0,class<`mforecast`>,1
+forecast,forecast.mlm,0,0,0,"class<`lm`, `mlm`>",1
+forecast,forecast.mlm,0,0,1,"class<`lm`, `mlm`, `tslm`>",1
+forecast,forecast.mlm,1,0,0,any,1
+forecast,forecast.mlm,2,0,0,double,1
+forecast,forecast.mlm,3,0,0,any,1
+forecast,forecast.mlm,4,0,0,logical,1
+forecast,forecast.mlm,5,0,0,any,1
+forecast,forecast.mlm,6,0,0,null,1
+forecast,forecast.mlm,7,0,0,logical,1
+forecast,forecast.mstl,-1,0,0,class<`forecast`>,1
+forecast,forecast.mstl,0,0,0,"class<`mstl`, `mts`, `ts`>",1
+forecast,forecast.mstl,1,0,0,character[],1
+forecast,forecast.mstl,2,0,0,character,1
+forecast,forecast.mstl,3,0,0,null,1
+forecast,forecast.mstl,4,0,0,double,1
+forecast,forecast.mstl,5,0,0,double[],1
+forecast,forecast.mstl,6,0,0,logical,1
+forecast,forecast.mstl,7,0,0,double,1
+forecast,forecast.nnetar,-1,0,0,class<`forecast`>,1
+forecast,forecast.nnetar,0,0,0,class<`nnetar`>,1
+forecast,forecast.nnetar,1,0,0,double,1
+forecast,forecast.nnetar,2,0,0,logical,1
+forecast,forecast.nnetar,3,0,0,double[],1
+forecast,forecast.nnetar,4,0,0,logical,1
+forecast,forecast.nnetar,5,0,0,null,1
+forecast,forecast.nnetar,6,0,0,null,1
+forecast,forecast.nnetar,7,0,0,logical,1
+forecast,forecast.stl,-1,0,0,class<`forecast`>,1
+forecast,forecast.stl,0,0,0,"class<`mstl`, `mts`, `ts`>",1
+forecast,forecast.stl,0,0,1,class<`stl`>,1
+forecast,forecast.stl,1,0,0,character[],1
+forecast,forecast.stl,2,0,0,character,1
+forecast,forecast.stl,3,0,0,null,1
+forecast,forecast.stl,4,0,0,double,1
+forecast,forecast.stl,5,0,0,double[],1
+forecast,forecast.stl,6,0,0,logical,1
+forecast,forecast.stl,7,0,0,double,1
+forecast,forecast.stl,7,0,1,null,1
+forecast,forecast.stlm,-1,0,0,class<`forecast`>,1
+forecast,forecast.stlm,0,0,0,class<`stlm`>,1
+forecast,forecast.stlm,1,0,0,double,1
+forecast,forecast.stlm,2,0,0,double[],1
+forecast,forecast.stlm,3,0,0,logical,1
+forecast,forecast.stlm,4,0,0,null,1
+forecast,forecast.stlm,5,0,0,null,1
+forecast,forecast.stlm,6,0,0,null,1
+forecast,forecast.stlm,7,0,0,logical,1
+forecast,forecast.StructTS,-1,0,0,class<`forecast`>,1
+forecast,forecast.StructTS,0,0,0,class<`StructTS`>,1
+forecast,forecast.StructTS,1,0,0,double,1
+forecast,forecast.StructTS,2,0,0,double[],1
+forecast,forecast.StructTS,3,0,0,logical,1
+forecast,forecast.StructTS,4,0,0,null,1
+forecast,forecast.StructTS,5,0,0,null,1
+forecast,forecast.StructTS,6,0,0,...,1
+forecast,forecast.ts,-1,0,0,class<`forecast`>,1
+forecast,forecast.ts,0,0,0,class<`ts`>,1
+forecast,forecast.ts,1,0,0,double,1
+forecast,forecast.ts,2,0,0,double[],1
+forecast,forecast.ts,3,0,0,logical,1
+forecast,forecast.ts,4,0,0,logical,1
+forecast,forecast.ts,5,0,0,null,1
+forecast,forecast.ts,6,0,0,logical,1
+forecast,forecast.ts,7,0,0,logical,1
+forecast,fourier,-1,0,0,class<`matrix`>,1
+forecast,fourier,0,0,0,"class<`msts`, `ts`>",1
+forecast,fourier,0,0,1,class<`ts`>,1
+forecast,fourier,1,0,0,double[],1
+forecast,fourier,2,0,0,double,1
+forecast,fourier,2,0,1,null,1
+forecast,...fourier,-1,0,0,class<`matrix`>,1
+forecast,...fourier,0,0,0,"class<`msts`, `ts`>",1
+forecast,...fourier,0,0,1,class<`ts`>,1
+forecast,...fourier,1,0,0,double[],1
+forecast,...fourier,2,0,0,integer[],1
+forecast,geom_forecast,-1,0,0,"class<`Layer`, `LayerInstance`, `gg`, `ggproto`>",1
+forecast,geom_forecast,0,0,0,class<`uneval`>,1
+forecast,geom_forecast,1,0,0,class<`data.frame`>,1
+forecast,geom_forecast,2,0,0,character,1
+forecast,geom_forecast,3,0,0,character,1
+forecast,geom_forecast,4,0,0,logical,1
+forecast,geom_forecast,5,0,0,null,1
+forecast,geom_forecast,6,0,0,logical,1
+forecast,geom_forecast,7,0,0,logical,1
+forecast,getResponse,-1,0,0,"class<`matrix`, `mts`, `ts`>",1
+forecast,getResponse,-1,0,1,class<`ts`>,1
+forecast,getResponse,-1,0,2,double[],1
+forecast,getResponse,-1,0,3,null,1
+forecast,getResponse,0,0,0,class<`lm`>,1
+forecast,getResponse,0,0,1,class<`mforecast`>,1
+forecast,getResponse,0,0,2,"class<`lm`, `tslm`>",1
+forecast,getResponse,0,0,3,class<`ar`>,1
+forecast,getResponse,0,0,4,"class<`ARFIMA`, `fracdiff`>",1
+forecast,getResponse,0,0,5,"class<`ARIMA`, `Arima`, `forecast_ARIMA`>",1
+forecast,getResponse,0,0,6,class<`ets`>,1
+forecast,getResponse,0,0,7,class<`forecast`>,1
+forecast,getResponse,0,0,8,"class<`forecast`, `splineforecast`>",1
+forecast,getResponse,0,0,9,class<`nnetar`>,1
+forecast,getResponse,0,0,10,class<`ts`>,1
+forecast,getResponse,1,0,0,...,1
+forecast,getResponse.ar,-1,0,0,class<`ts`>,1
+forecast,getResponse.ar,0,0,0,class<`ar`>,1
+forecast,getResponse.ar,1,0,0,...,1
+forecast,getResponse.Arima,-1,0,0,class<`ts`>,1
+forecast,getResponse.Arima,0,0,0,class<`ar`>,1
+forecast,getResponse.Arima,0,0,1,"class<`ARIMA`, `Arima`, `forecast_ARIMA`>",1
+forecast,getResponse.Arima,1,0,0,...,1
+forecast,getResponse.default,-1,0,0,class<`ts`>,1
+forecast,getResponse.default,-1,0,1,double[],1
+forecast,getResponse.default,-1,0,2,null,1
+forecast,getResponse.default,0,0,0,class<`ets`>,1
+forecast,getResponse.default,0,0,1,class<`forecast`>,1
+forecast,getResponse.default,0,0,2,"class<`forecast`, `splineforecast`>",1
+forecast,getResponse.default,0,0,3,class<`nnetar`>,1
+forecast,getResponse.default,0,0,4,class<`ts`>,1
+forecast,getResponse.default,1,0,0,...,1
+forecast,getResponse.fracdiff,-1,0,0,class<`ts`>,1
+forecast,getResponse.fracdiff,0,0,0,"class<`ARFIMA`, `fracdiff`>",1
+forecast,getResponse.fracdiff,1,0,0,...,1
+forecast,getResponse.lm,-1,0,0,"class<`matrix`, `mts`, `ts`>",1
+forecast,getResponse.lm,-1,0,1,class<`ts`>,1
+forecast,getResponse.lm,-1,0,2,double[],1
+forecast,getResponse.lm,0,0,0,class<`lm`>,1
+forecast,getResponse.lm,0,0,1,"class<`lm`, `tslm`>",1
+forecast,getResponse.lm,1,0,0,...,1
+forecast,getResponse.mforecast,-1,0,0,"class<`matrix`, `mts`, `ts`>",1
+forecast,getResponse.mforecast,0,0,0,class<`mforecast`>,1
+forecast,getResponse.mforecast,1,0,0,...,1
+forecast,getxreg,-1,0,0,class<`matrix`>,1
+forecast,getxreg,0,0,0,"class<`ARIMA`, `Arima`, `forecast_ARIMA`>",1
+forecast,ggAcf,-1,0,0,"class<`gg`, `ggplot`>",1
+forecast,ggAcf,0,0,0,class<`ts`>,1
+forecast,ggAcf,1,0,0,null,1
+forecast,ggAcf,2,0,0,any,1
+forecast,ggAcf,3,0,0,logical,1
+forecast,ggAcf,4,0,0,any,1
+forecast,ggAcf,5,0,0,logical,1
+forecast,ggAcf,6,0,0,...,1
+forecast,ggAddExtras,-1,0,0,list<class<`labels`>>,1
+forecast,ggAddExtras,0,0,0,character,1
+forecast,ggAddExtras,0,0,1,null,1
+forecast,ggAddExtras,1,0,0,character[],1
+forecast,ggAddExtras,1,0,1,null,1
+forecast,ggAddExtras,2,0,0,null,1
+forecast,ggAddExtras,2,0,1,character,1
+forecast,ggCcf,-1,0,0,"class<`gg`, `ggplot`>",1
+forecast,ggCcf,0,0,0,any,1
+forecast,ggCcf,1,0,0,any,1
+forecast,ggCcf,2,0,0,null,1
+forecast,ggCcf,3,0,0,any,1
+forecast,ggCcf,4,0,0,logical,1
+forecast,ggCcf,5,0,0,any,1
+forecast,ggCcf,6,0,0,...,1
+forecast,gghistogram,-1,0,0,"class<`gg`, `ggplot`>",1
+forecast,gghistogram,0,0,0,class<`ts`>,1
+forecast,gghistogram,1,0,0,logical,1
+forecast,gghistogram,2,0,0,logical,1
+forecast,gghistogram,3,0,0,logical,1
+forecast,gghistogram,4,0,0,any,1
+forecast,gghistogram,5,0,0,double,1
+forecast,gglagchull,-1,0,0,"class<`gg`, `ggplot`>",1
+forecast,gglagchull,0,0,0,"class<`matrix`, `mts`, `ts`>",1
+forecast,gglagchull,0,0,1,class<`ts`>,1
+forecast,gglagchull,1,0,0,double,1
+forecast,gglagchull,2,0,0,integer[],1
+forecast,gglagchull,3,0,0,logical,1
+forecast,gglagchull,4,0,0,character,1
+forecast,gglagchull,5,0,0,...,1
+forecast,gglagplot,-1,0,0,"class<`gg`, `ggplot`>",1
+forecast,gglagplot,0,0,0,"class<`matrix`, `mts`, `ts`>",1
+forecast,gglagplot,0,0,1,class<`ts`>,1
+forecast,gglagplot,1,0,0,double,1
+forecast,gglagplot,2,0,0,integer[],1
+forecast,gglagplot,3,0,0,logical,1
+forecast,gglagplot,4,0,0,character,1
+forecast,gglagplot,5,0,0,logical,1
+forecast,gglagplot,6,0,0,logical,1
+forecast,gglagplot,7,0,0,any,1
+forecast,ggseasonplot,-1,0,0,"class<`gg`, `ggplot`>",1
+forecast,ggseasonplot,0,0,0,class<`ts`>,1
+forecast,ggseasonplot,1,0,0,null,1
+forecast,ggseasonplot,2,0,0,logical,1
+forecast,ggseasonplot,3,0,0,logical,1
+forecast,ggseasonplot,4,0,0,null,1
+forecast,ggseasonplot,5,0,0,character[],1
+forecast,ggseasonplot,5,0,1,null,1
+forecast,ggseasonplot,6,0,0,logical,1
+forecast,ggseasonplot,7,0,0,logical,1
+forecast,ggsubseriesplot,-1,0,0,"class<`gg`, `ggplot`>",1
+forecast,ggsubseriesplot,0,0,0,class<`ts`>,1
+forecast,ggsubseriesplot,1,0,0,null,1
+forecast,ggsubseriesplot,2,0,0,any,1
+forecast,ggsubseriesplot,3,0,0,class<`ts`>,1
+forecast,ggsubseriesplot,4,0,0,...,1
+forecast,ggtsdisplay,-1,0,0,"class<`gg`, `ggplot`>",1
+forecast,ggtsdisplay,0,0,0,class<`ts`>,1
+forecast,ggtsdisplay,1,0,0,character,1
+forecast,ggtsdisplay,2,0,0,logical,1
+forecast,ggtsdisplay,3,0,0,logical,1
+forecast,ggtsdisplay,4,0,0,any,1
+forecast,ggtsdisplay,5,0,0,class<`function`>,1
+forecast,ggtsdisplay,6,0,0,"class<`gg`, `theme`>",1
+forecast,ggtsdisplay,6,0,1,null,1
+forecast,ggtsdisplay,7,0,0,...,1
+forecast,guerrero,-1,0,0,double,1
+forecast,guerrero,0,0,0,class<`ts`>,1
+forecast,guerrero,1,0,0,double,1
+forecast,guerrero,2,0,0,double,1
+forecast,guerrero,3,0,0,double,1
+forecast,head.ts,-1,0,0,class<`ts`>,1
+forecast,head.ts,0,0,0,class<`ts`>,1
+forecast,head.ts,1,0,0,double,1
+forecast,head.ts,2,0,0,...,1
+forecast,hfitted,-1,0,0,class<`ts`>,1
+forecast,hfitted,0,0,0,class<`ets`>,1
+forecast,hfitted,1,0,0,double,1
+forecast,hfitted,2,0,0,character,1
+forecast,hfitted,3,0,0,...,1
+forecast,holt,-1,0,0,class<`forecast`>,1
+forecast,holt,0,0,0,class<`ts`>,1
+forecast,holt,1,0,0,double,1
+forecast,holt,2,0,0,logical,1
+forecast,holt,3,0,0,double[],1
+forecast,holt,4,0,0,logical,1
+forecast,holt,5,0,0,character[],1
+forecast,holt,6,0,0,logical,1
+forecast,holt,7,0,0,null,1
+forecast,HoltWintersZZ,-1,0,0,class<`ets`>,1
+forecast,HoltWintersZZ,0,0,0,double[],1
+forecast,HoltWintersZZ,1,0,0,double,1
+forecast,HoltWintersZZ,2,0,0,logical,1
+forecast,HoltWintersZZ,3,0,0,logical,1
+forecast,HoltWintersZZ,4,0,0,character[],1
+forecast,HoltWintersZZ,5,0,0,logical,1
+forecast,HoltWintersZZ,6,0,0,null,1
+forecast,HoltWintersZZ,7,0,0,null,1
+forecast,hw,-1,0,0,class<`forecast`>,1
+forecast,hw,0,0,0,class<`ts`>,1
+forecast,hw,1,0,0,double,1
+forecast,hw,2,0,0,character[],1
+forecast,hw,3,0,0,logical,1
+forecast,hw,4,0,0,double[],1
+forecast,hw,5,0,0,logical,1
+forecast,hw,6,0,0,character[],1
+forecast,hw,7,0,0,logical,1
+forecast,initparam,-1,0,0,double[],1
+forecast,initparam,0,0,0,double,1
+forecast,initparam,0,0,1,null,1
+forecast,initparam,1,0,0,any,1
+forecast,initparam,2,0,0,any,1
+forecast,initparam,3,0,0,any,1
+forecast,initparam,4,0,0,character,1
+forecast,initparam,5,0,0,character,1
+forecast,initparam,6,0,0,logical,1
+forecast,initparam,7,0,0,double[],1
+forecast,initstate,-1,0,0,double[],1
+forecast,initstate,0,0,0,class<`ts`>,1
+forecast,initstate,1,0,0,character,1
+forecast,initstate,2,0,0,character,1
+forecast,InvBoxCox,-1,0,0,class<`array`>,1
+forecast,InvBoxCox,-1,0,1,class<`matrix`>,1
+forecast,InvBoxCox,-1,0,2,"class<`matrix`, `mts`, `ts`>",1
+forecast,InvBoxCox,-1,0,3,class<`ts`>,1
+forecast,InvBoxCox,0,0,0,class<`array`>,1
+forecast,InvBoxCox,0,0,1,class<`matrix`>,1
+forecast,InvBoxCox,0,0,2,"class<`matrix`, `mts`, `ts`>",1
+forecast,InvBoxCox,0,0,3,class<`ts`>,1
+forecast,InvBoxCox,1,0,0,double,1
+forecast,InvBoxCox,2,0,0,logical,1
+forecast,InvBoxCox,2,0,1,null,1
+forecast,InvBoxCox,3,0,0,any,1
+forecast,is.Arima,-1,0,0,logical,1
+forecast,is.Arima,0,0,0,class<`ar`>,1
+forecast,is.Arima,0,0,1,"class<`ARIMA`, `Arima`, `forecast_ARIMA`>",1
+forecast,is.constant,-1,0,0,logical,1
+forecast,is.constant,0,0,0,double[],1
+forecast,is.constant,0,0,1,class<`ts`>,1
+forecast,is.ets,-1,0,0,logical,1
+forecast,is.ets,0,0,0,class<`ets`>,1
+forecast,is.forecast,-1,0,0,logical,1
+forecast,is.forecast,0,0,0,class<`forecast`>,1
+forecast,is.forecast,0,0,1,class<`uneval`>,1
+forecast,is.mforecast,-1,0,0,logical,1
+forecast,is.mforecast,0,0,0,class<`mforecast`>,1
+forecast,is.mforecast,0,0,1,class<`uneval`>,1
+forecast,is.nnetar,-1,0,0,logical,1
+forecast,is.nnetar,0,0,0,class<`nnetar`>,1
+forecast,lagwalk,-1,0,0,class<`lagwalk`>,1
+forecast,lagwalk,0,0,0,class<`ts`>,1
+forecast,lagwalk,0,0,1,double[],1
+forecast,lagwalk,1,0,0,double,1
+forecast,lagwalk,2,0,0,logical,1
+forecast,lagwalk,3,0,0,null,1
+forecast,lagwalk,4,0,0,any,1
+forecast,ma,-1,0,0,class<`ts`>,1
+forecast,ma,0,0,0,class<`ts`>,1
+forecast,ma,1,0,0,double,1
+forecast,ma,2,0,0,logical,1
+forecast,make.Sigma,-1,0,0,class<`matrix`>,1
+forecast,make.Sigma,0,0,0,integer,1
+forecast,make.Sigma,1,0,0,double,1
+forecast,maroots,-1,0,0,class<`armaroots`>,1
+forecast,maroots,0,0,0,"class<`ARIMA`, `Arima`, `forecast_ARIMA`>",1
+forecast,MBB,-1,0,0,class<`array`>,1
+forecast,MBB,0,0,0,double[],1
+forecast,MBB,1,0,0,double,1
+forecast,meanf,-1,0,0,class<`forecast`>,1
+forecast,meanf,0,0,0,class<`ts`>,1
+forecast,meanf,0,0,1,double[],1
+forecast,meanf,1,0,0,double,1
+forecast,meanf,2,0,0,double[],1
+forecast,meanf,3,0,0,logical,1
+forecast,meanf,4,0,0,null,1
+forecast,meanf,5,0,0,logical,1
+forecast,meanf,6,0,0,logical,1
+forecast,meanf,7,0,0,double,1
+forecast,mlmsplit,-1,0,0,class<`lm`>,1
+forecast,mlmsplit,0,0,0,"class<`lm`, `mlm`>",1
+forecast,mlmsplit,0,0,1,"class<`lm`, `mlm`, `tslm`>",1
+forecast,mlmsplit,1,0,0,integer,1
+forecast,modeldf,-1,0,0,integer,1
+forecast,modeldf,0,0,0,class<`ets`>,1
+forecast,modeldf,1,0,0,...,1
+forecast,modeldf.ets,-1,0,0,integer,1
+forecast,modeldf.ets,0,0,0,class<`ets`>,1
+forecast,modeldf.ets,1,0,0,...,1
+forecast,monthdays,-1,0,0,class<`ts`>,1
+forecast,monthdays,0,0,0,class<`ts`>,1
+forecast,mstl,-1,0,0,"class<`mstl`, `msts`, `mts`, `ts`>",1
+forecast,mstl,-1,0,1,"class<`mstl`, `mts`, `ts`>",1
+forecast,mstl,0,0,0,"class<`msts`, `ts`>",1
+forecast,mstl,0,0,1,class<`ts`>,1
+forecast,mstl,1,0,0,null,1
+forecast,mstl,1,0,1,character,1
+forecast,mstl,2,0,0,double,1
+forecast,mstl,3,0,0,double,1
+forecast,mstl,4,0,0,...,1
+forecast,msts,-1,0,0,"class<`msts`, `ts`>",1
+forecast,msts,-1,0,1,class<`ts`>,1
+forecast,msts,0,0,0,"class<`msts`, `ts`>",1
+forecast,msts,0,0,1,class<`ts`>,1
+forecast,msts,1,0,0,double[],1
+forecast,msts,2,0,0,double,1
+forecast,msts,3,0,0,...,1
+forecast,[.msts,-1,0,0,integer[],1
+forecast,[.msts,0,0,0,"class<`msts`, `ts`>",1
+forecast,[.msts,1,0,0,logical[],1
+forecast,[.msts,2,0,0,any,1
+forecast,[.msts,3,0,0,logical,1
+forecast,myarima,-1,0,0,"class<`ARIMA`, `Arima`, `forecast_ARIMA`>",1
+forecast,myarima,0,0,0,class<`ts`>,1
+forecast,myarima,1,0,0,double[],1
+forecast,myarima,2,0,0,double[],1
+forecast,myarima,3,0,0,logical,1
+forecast,myarima,4,0,0,character,1
+forecast,myarima,5,0,0,logical,1
+forecast,myarima,6,0,0,logical,1
+forecast,myarima,7,0,0,any,1
+forecast,na.ends,-1,0,0,class<`ts`>,1
+forecast,na.ends,-1,0,1,double[],1
+forecast,na.ends,0,0,0,class<`ts`>,1
+forecast,na.ends,0,0,1,double[],1
+forecast,na.interp,-1,0,0,class<`ts`>,1
+forecast,na.interp,0,0,0,class<`ts`>,1
+forecast,na.interp,1,0,0,any,1
+forecast,na.interp,2,0,0,any,1
+forecast,naive,-1,0,0,class<`forecast`>,1
+forecast,naive,0,0,0,class<`ts`>,1
+forecast,naive,1,0,0,double,1
+forecast,naive,2,0,0,double[],1
+forecast,naive,3,0,0,logical,1
+forecast,naive,4,0,0,null,1
+forecast,naive,5,0,0,logical,1
+forecast,naive,6,0,0,...,1
+forecast,naive,7,0,0,class<`ts`>,1
+forecast,ndiffs,-1,0,0,double,1
+forecast,ndiffs,0,0,0,class<`ts`>,1
+forecast,ndiffs,1,0,0,double,1
+forecast,ndiffs,2,0,0,character[],1
+forecast,ndiffs,3,0,0,character[],1
+forecast,ndiffs,4,0,0,double,1
+forecast,ndiffs,5,0,0,...,1
+forecast,newmodel,-1,0,0,logical,1
+forecast,newmodel,0,0,0,double,1
+forecast,newmodel,1,0,0,double,1
+forecast,newmodel,2,0,0,double,1
+forecast,newmodel,3,0,0,double,1
+forecast,newmodel,4,0,0,double,1
+forecast,newmodel,5,0,0,double,1
+forecast,newmodel,6,0,0,logical,1
+forecast,newmodel,7,0,0,class<`matrix`>,1
+forecast,nnetar,-1,0,0,class<`nnetar`>,1
+forecast,nnetar,0,0,0,class<`ts`>,1
+forecast,nnetar,1,0,0,any,1
+forecast,nnetar,2,0,0,double,1
+forecast,nnetar,3,0,0,any,1
+forecast,nnetar,4,0,0,double,1
+forecast,nnetar,5,0,0,null,1
+forecast,nnetar,6,0,0,null,1
+forecast,nnetar,7,0,0,null,1
+forecast,nnetar,7,0,1,class<`nnetar`>,1
+forecast,nsdiffs,-1,0,0,double,1
+forecast,nsdiffs,0,0,0,class<`ts`>,1
+forecast,nsdiffs,1,0,0,double,1
+forecast,nsdiffs,2,0,0,any,1
+forecast,nsdiffs,3,0,0,character[],1
+forecast,nsdiffs,4,0,0,double,1
+forecast,nsdiffs,5,0,0,...,1
+forecast,ocsb.test,-1,0,0,class<`OCSBtest`>,1
+forecast,ocsb.test,0,0,0,class<`ts`>,1
+forecast,ocsb.test,1,0,0,character[],1
+forecast,ocsb.test,2,0,0,double,1
+forecast,oldmodel_avnnet,-1,0,0,class<`nnetarmodels`>,1
+forecast,oldmodel_avnnet,0,0,0,class<`matrix`>,1
+forecast,oldmodel_avnnet,1,0,0,double[],1
+forecast,oldmodel_avnnet,2,0,0,double,1
+forecast,oldmodel_avnnet,3,0,0,class<`nnetar`>,1
+forecast,overwrite_s3_generic,-1,0,0,class<`function`>,1
+forecast,overwrite_s3_generic,-1,0,1,null,1
+forecast,overwrite_s3_generic,0,0,0,character,1
+forecast,overwrite_s3_generic,1,0,0,character,1
+forecast,Pacf,-1,0,0,class<`acf`>,1
+forecast,Pacf,0,0,0,class<`ts`>,1
+forecast,Pacf,1,0,0,null,1
+forecast,Pacf,2,0,0,logical,1
+forecast,Pacf,3,0,0,class<`function`>,1
+forecast,Pacf,4,0,0,logical,1
+forecast,Pacf,5,0,0,...,1
+forecast,pegelsresid.C,-1,0,0,list<double[] | class<`ts`> | class<`matrix`>>,1
+forecast,pegelsresid.C,0,0,0,class<`ts`>,1
+forecast,pegelsresid.C,1,0,0,double,1
+forecast,pegelsresid.C,2,0,0,double[],1
+forecast,pegelsresid.C,3,0,0,character,1
+forecast,pegelsresid.C,4,0,0,character,1
+forecast,pegelsresid.C,5,0,0,character,1
+forecast,pegelsresid.C,6,0,0,logical,1
+forecast,pegelsresid.C,7,0,0,double,1
+forecast,plot.ar,-1,0,0,null,1
+forecast,plot.ar,0,0,0,class<`ar`>,1
+forecast,plot.ar,1,0,0,any,1
+forecast,plot.ar,2,0,0,character,1
+forecast,plot.ar,3,0,0,character,1
+forecast,plot.ar,4,0,0,...,1
+forecast,plot.Arima,-1,0,0,null,1
+forecast,plot.Arima,0,0,0,"class<`ARIMA`, `Arima`, `forecast_ARIMA`>",1
+forecast,plot.Arima,1,0,0,character[],1
+forecast,plot.Arima,2,0,0,any,1
+forecast,plot.Arima,3,0,0,character,1
+forecast,plot.Arima,4,0,0,character,1
+forecast,plot.Arima,5,0,0,...,1
+forecast,plot.armaroots,-1,0,0,null,1
+forecast,plot.armaroots,0,0,0,class<`armaroots`>,1
+forecast,plot.armaroots,1,0,0,character,1
+forecast,plot.armaroots,2,0,0,character,1
+forecast,plot.armaroots,3,0,0,any,1
+forecast,plot.armaroots,4,0,0,...,1
+forecast,plot.ets,-1,0,0,null,1
+forecast,plot.ets,0,0,0,class<`ets`>,1
+forecast,plot.ets,1,0,0,...,1
+forecast,plot.forecast,-1,0,0,"list<class<`ts`> | class<`matrix`, `mts`, `ts`>>",1
+forecast,plot.forecast,-1,0,1,list<class<`ts`> | class<`matrix`>>,1
+forecast,plot.forecast,-1,0,2,list<class<`ts`>>,1
+forecast,plot.forecast,-1,0,3,list<double | class<`matrix`>>,1
+forecast,plot.forecast,0,0,0,"class<`forecast`, `splineforecast`>",1
+forecast,plot.forecast,0,0,1,class<`forecast`>,1
+forecast,plot.forecast,1,0,0,any,1
+forecast,plot.forecast,2,0,0,logical,1
+forecast,plot.forecast,3,0,0,logical,1
+forecast,plot.forecast,4,0,0,logical,1
+forecast,plot.forecast,5,0,0,any,1
+forecast,plot.forecast,6,0,0,null,1
+forecast,plot.forecast,7,0,0,double,1
+forecast,plotlmforecast,-1,0,0,null,1
+forecast,plotlmforecast,0,0,0,class<`forecast`>,1
+forecast,plotlmforecast,1,0,0,logical,1
+forecast,plotlmforecast,2,0,0,logical,1
+forecast,plotlmforecast,3,0,0,null,1
+forecast,plotlmforecast,4,0,0,double,1
+forecast,plotlmforecast,5,0,0,double,1
+forecast,plotlmforecast,6,0,0,any,1
+forecast,plotlmforecast,7,0,0,any,1
+forecast,plot.mforecast,-1,0,0,null,1
+forecast,plot.mforecast,0,0,0,class<`mforecast`>,1
+forecast,plot.mforecast,1,0,0,character,1
+forecast,plot.mforecast,2,0,0,character,1
+forecast,plot.mforecast,3,0,0,...,1
+forecast,plot.splineforecast,-1,0,0,null,1
+forecast,plot.splineforecast,0,0,0,"class<`forecast`, `splineforecast`>",1
+forecast,plot.splineforecast,1,0,0,double,1
+forecast,plot.splineforecast,2,0,0,character,1
+forecast,plot.splineforecast,3,0,0,double,1
+forecast,plot.splineforecast,4,0,0,...,1
+forecast,print.CVar,-1,0,0,"class<`CVar`, `nnetar`>",1
+forecast,print.CVar,0,0,0,"class<`CVar`, `nnetar`>",1
+forecast,print.CVar,1,0,0,...,1
+forecast,print.forecast,-1,0,0,class<`data.frame`>,1
+forecast,print.forecast,0,0,0,class<`forecast`>,1
+forecast,print.forecast,0,0,1,"class<`forecast`, `splineforecast`>",1
+forecast,print.forecast,1,0,0,...,1
+forecast,print.forecast_ARIMA,-1,0,0,"class<`ARIMA`, `Arima`, `forecast_ARIMA`>",1
+forecast,print.forecast_ARIMA,0,0,0,"class<`ARIMA`, `Arima`, `forecast_ARIMA`>",1
+forecast,print.forecast_ARIMA,1,0,0,double,1
+forecast,print.forecast_ARIMA,2,0,0,logical,1
+forecast,print.forecast_ARIMA,3,0,0,...,1
+forecast,print.nnetar,-1,0,0,class<`nnetar`>,1
+forecast,print.nnetar,0,0,0,class<`nnetar`>,1
+forecast,print.nnetar,1,0,0,double,1
+forecast,print.nnetar,2,0,0,...,1
+forecast,print.nnetarmodels,-1,0,0,class<`nnet`>,1
+forecast,print.nnetarmodels,0,0,0,class<`nnetarmodels`>,1
+forecast,print.nnetarmodels,1,0,0,...,1
+forecast,register_s3_method,-1,0,0,null,1
+forecast,register_s3_method,0,0,0,character,1
+forecast,register_s3_method,1,0,0,character,1
+forecast,register_s3_method,2,0,0,character,1
+forecast,register_s3_method,3,0,0,null,1
+forecast,remainder,-1,0,0,class<`ts`>,1
+forecast,remainder,0,0,0,"class<`mstl`, `mts`, `ts`>",1
+forecast,remainder,0,0,1,class<`stl`>,1
+forecast,residuals.ar,-1,0,0,class<`ts`>,1
+forecast,residuals.ar,0,0,0,class<`ar`>,1
+forecast,residuals.ar,1,0,0,character[],1
+forecast,residuals.ar,2,0,0,...,1
+forecast,residuals.Arima,-1,0,0,class<`ts`>,1
+forecast,residuals.Arima,0,0,0,"class<`ARIMA`, `Arima`, `forecast_ARIMA`>",1
+forecast,residuals.Arima,1,0,0,character[],1
+forecast,residuals.Arima,2,0,0,double,1
+forecast,residuals.Arima,3,0,0,...,1
+forecast,residuals.ets,-1,0,0,class<`ts`>,1
+forecast,residuals.ets,0,0,0,class<`ets`>,1
+forecast,residuals.ets,1,0,0,character[],1
+forecast,residuals.ets,2,0,0,double,1
+forecast,residuals.ets,3,0,0,...,1
+forecast,residuals.forecast,-1,0,0,class<`ts`>,1
+forecast,residuals.forecast,0,0,0,class<`forecast`>,1
+forecast,residuals.forecast,1,0,0,character[],1
+forecast,residuals.forecast,2,0,0,...,1
+forecast,residuals.forecast_ARIMA,-1,0,0,class<`ts`>,1
+forecast,residuals.forecast_ARIMA,0,0,0,"class<`ARIMA`, `Arima`, `forecast_ARIMA`>",1
+forecast,residuals.forecast_ARIMA,1,0,0,character[],1
+forecast,residuals.forecast_ARIMA,2,0,0,double,1
+forecast,residuals.forecast_ARIMA,3,0,0,...,1
+forecast,residuals.nnetar,-1,0,0,"class<`matrix`, `mts`, `ts`>",1
+forecast,residuals.nnetar,0,0,0,class<`nnetar`>,1
+forecast,residuals.nnetar,1,0,0,character[],1
+forecast,residuals.nnetar,2,0,0,double,1
+forecast,residuals.nnetar,3,0,0,...,1
+forecast,residuals.tslm,-1,0,0,class<`ts`>,1
+forecast,residuals.tslm,0,0,0,"class<`lm`, `tslm`>",1
+forecast,residuals.tslm,1,0,0,character[],1
+forecast,residuals.tslm,2,0,0,...,1
+forecast,rwf,-1,0,0,class<`forecast`>,1
+forecast,rwf,0,0,0,class<`ts`>,1
+forecast,rwf,0,0,1,double[],1
+forecast,rwf,1,0,0,double,1
+forecast,rwf,2,0,0,logical,1
+forecast,rwf,3,0,0,double[],1
+forecast,rwf,4,0,0,logical,1
+forecast,rwf,5,0,0,null,1
+forecast,rwf,6,0,0,any,1
+forecast,rwf,7,0,0,...,1
+forecast,scale.ts,-1,0,0,class<`ts`>,1
+forecast,scale.ts,0,0,0,class<`ts`>,1
+forecast,scale.ts,1,0,0,double,1
+forecast,scale.ts,2,0,0,double,1
+forecast,seasadj,-1,0,0,class<`ts`>,1
+forecast,seasadj,0,0,0,class<`decomposed.ts`>,1
+forecast,seasadj,0,0,1,"class<`mstl`, `mts`, `ts`>",1
+forecast,seasadj,0,0,2,class<`stl`>,1
+forecast,seasadj,1,0,0,...,1
+forecast,seasadj.decomposed.ts,-1,0,0,class<`ts`>,1
+forecast,seasadj.decomposed.ts,0,0,0,class<`decomposed.ts`>,1
+forecast,seasadj.decomposed.ts,1,0,0,...,1
+forecast,seasadj.mstl,-1,0,0,class<`ts`>,1
+forecast,seasadj.mstl,0,0,0,"class<`mstl`, `mts`, `ts`>",1
+forecast,seasadj.mstl,0,0,1,class<`stl`>,1
+forecast,seasadj.mstl,1,0,0,...,1
+forecast,seasadj.stl,-1,0,0,class<`ts`>,1
+forecast,seasadj.stl,0,0,0,"class<`mstl`, `mts`, `ts`>",1
+forecast,seasadj.stl,0,0,1,class<`stl`>,1
+forecast,seasadj.stl,1,0,0,...,1
+forecast,seas.heuristic,-1,0,0,double,1
+forecast,seas.heuristic,0,0,0,class<`ts`>,1
+forecast,seasonal,-1,0,0,class<`ts`>,1
+forecast,seasonal,0,0,0,class<`stl`>,1
+forecast,seasonalaxis,-1,0,0,double[],1
+forecast,seasonalaxis,0,0,0,double,1
+forecast,seasonalaxis,1,0,0,double,1
+forecast,seasonalaxis,2,0,0,character,1
+forecast,seasonalaxis,3,0,0,logical,1
+forecast,seasonaldummy,-1,0,0,class<`matrix`>,1
+forecast,seasonaldummy,0,0,0,class<`ts`>,1
+forecast,seasonaldummy,1,0,0,double,1
+forecast,seasonaldummy,1,0,1,null,1
+forecast,seasonplot,-1,0,0,double[],1
+forecast,seasonplot,0,0,0,class<`ts`>,1
+forecast,seasonplot,1,0,0,any,1
+forecast,seasonplot,2,0,0,null,1
+forecast,seasonplot,3,0,0,logical,1
+forecast,seasonplot,4,0,0,logical,1
+forecast,seasonplot,5,0,0,character,1
+forecast,seasonplot,6,0,0,any,1
+forecast,seasonplot,7,0,0,null,1
+forecast,ses,-1,0,0,class<`forecast`>,1
+forecast,ses,0,0,0,class<`ts`>,1
+forecast,ses,0,0,1,double[],1
+forecast,ses,1,0,0,double,1
+forecast,ses,2,0,0,any,1
+forecast,ses,3,0,0,logical,1
+forecast,ses,4,0,0,character[],1
+forecast,ses,5,0,0,null,1
+forecast,ses,5,0,1,double,1
+forecast,ses,6,0,0,null,1
+forecast,ses,7,0,0,logical,1
+forecast,simulate.ets,-1,0,0,class<`ts`>,1
+forecast,simulate.ets,0,0,0,class<`ets`>,1
+forecast,simulate.ets,1,0,0,double,1
+forecast,simulate.ets,2,0,0,null,1
+forecast,simulate.ets,3,0,0,logical,1
+forecast,simulate.ets,4,0,0,logical,1
+forecast,simulate.ets,5,0,0,null,1
+forecast,simulate.ets,6,0,0,...,1
+forecast,sindexf,-1,0,0,class<`ts`>,1
+forecast,sindexf,0,0,0,class<`stl`>,1
+forecast,sindexf,1,0,0,double,1
+forecast,snaive,-1,0,0,class<`forecast`>,1
+forecast,snaive,0,0,0,class<`ts`>,1
+forecast,snaive,1,0,0,double,1
+forecast,snaive,2,0,0,double[],1
+forecast,snaive,3,0,0,logical,1
+forecast,snaive,4,0,0,null,1
+forecast,snaive,5,0,0,logical,1
+forecast,snaive,6,0,0,...,1
+forecast,snaive,7,0,0,class<`ts`>,1
+forecast,splinef,-1,0,0,"class<`forecast`, `splineforecast`>",1
+forecast,splinef,0,0,0,class<`ts`>,1
+forecast,splinef,1,0,0,double,1
+forecast,splinef,2,0,0,double[],1
+forecast,splinef,3,0,0,logical,1
+forecast,splinef,4,0,0,null,1
+forecast,splinef,5,0,0,logical,1
+forecast,splinef,6,0,0,character[],1
+forecast,splinef,7,0,0,class<`ts`>,1
+forecast,spline.matrices,-1,0,0,list<class<`matrix`>>,1
+forecast,spline.matrices,0,0,0,integer,1
+forecast,spline.matrices,1,0,0,double,1
+forecast,spline.matrices,2,0,0,double,1
+forecast,spline.matrices,3,0,0,double,1
+forecast,stlf,-1,0,0,class<`forecast`>,1
+forecast,stlf,0,0,0,class<`ts`>,1
+forecast,stlf,1,0,0,double,1
+forecast,stlf,2,0,0,double,1
+forecast,stlf,3,0,0,null,1
+forecast,stlf,4,0,0,logical,1
+forecast,stlf,5,0,0,double,1
+forecast,stlf,6,0,0,logical,1
+forecast,stlf,7,0,0,class<`ts`>,1
+forecast,stlm,-1,0,0,class<`stlm`>,1
+forecast,stlm,0,0,0,class<`ts`>,1
+forecast,stlm,1,0,0,double,1
+forecast,stlm,2,0,0,logical,1
+forecast,stlm,3,0,0,character[],1
+forecast,stlm,4,0,0,class<`function`>,1
+forecast,stlm,5,0,0,null,1
+forecast,stlm,6,0,0,character,1
+forecast,stlm,7,0,0,null,1
+forecast,subset.ts,-1,0,0,class<`ts`>,1
+forecast,subset.ts,0,0,0,class<`ts`>,1
+forecast,subset.ts,1,0,0,null,1
+forecast,subset.ts,2,0,0,character,1
+forecast,subset.ts,2,0,1,null,1
+forecast,subset.ts,3,0,0,null,1
+forecast,subset.ts,3,0,1,double,1
+forecast,subset.ts,4,0,0,null,1
+forecast,subset.ts,5,0,0,null,1
+forecast,subset.ts,5,0,1,double,1
+forecast,subset.ts,6,0,0,null,1
+forecast,subset.ts,7,0,0,...,1
+forecast,summary.forecast,-1,0,0,class<`data.frame`>,1
+forecast,summary.forecast,0,0,0,class<`forecast`>,1
+forecast,summary.forecast,0,0,1,"class<`forecast`, `splineforecast`>",1
+forecast,summary.forecast,1,0,0,...,1
+forecast,tail.ts,-1,0,0,class<`ts`>,1
+forecast,tail.ts,0,0,0,class<`ts`>,1
+forecast,tail.ts,1,0,0,double,1
+forecast,tail.ts,2,0,0,...,1
+forecast,testaccuracy,-1,0,0,double[],1
+forecast,testaccuracy,0,0,0,class<`ts`>,1
+forecast,testaccuracy,0,0,1,class<`forecast`>,1
+forecast,testaccuracy,1,0,0,class<`ts`>,1
+forecast,testaccuracy,1,0,1,double[],1
+forecast,testaccuracy,2,0,0,integer[],1
+forecast,testaccuracy,2,0,1,null,1
+forecast,testaccuracy,3,0,0,any,1
+forecast,testaccuracy,4,0,0,any,1
+forecast,thetaf,-1,0,0,class<`forecast`>,1
+forecast,thetaf,0,0,0,class<`ts`>,1
+forecast,thetaf,1,0,0,double,1
+forecast,thetaf,2,0,0,double[],1
+forecast,thetaf,3,0,0,logical,1
+forecast,thetaf,4,0,0,class<`ts`>,1
+forecast,trainingaccuracy,-1,0,0,double[],1
+forecast,trainingaccuracy,0,0,0,"class<`ARIMA`, `Arima`, `forecast_ARIMA`>",1
+forecast,trainingaccuracy,0,0,1,class<`ets`>,1
+forecast,trainingaccuracy,0,0,2,class<`forecast`>,1
+forecast,trainingaccuracy,0,0,3,"class<`forecast`, `splineforecast`>",1
+forecast,trainingaccuracy,1,0,0,null,1
+forecast,trainingaccuracy,2,0,0,any,1
+forecast,trainingaccuracy,3,0,0,any,1
+forecast,trendcycle,-1,0,0,class<`ts`>,1
+forecast,trendcycle,0,0,0,"class<`mstl`, `mts`, `ts`>",1
+forecast,trendcycle,0,0,1,class<`stl`>,1
+forecast,tsclean,-1,0,0,class<`ts`>,1
+forecast,tsclean,0,0,0,class<`ts`>,1
+forecast,tsclean,1,0,0,logical,1
+forecast,tsclean,2,0,0,null,1
+forecast,tsdisplay,-1,0,0,null,1
+forecast,tsdisplay,0,0,0,class<`ts`>,1
+forecast,tsdisplay,1,0,0,character[],1
+forecast,tsdisplay,2,0,0,logical,1
+forecast,tsdisplay,3,0,0,character[],1
+forecast,tsdisplay,4,0,0,any,1
+forecast,tsdisplay,5,0,0,class<`function`>,1
+forecast,tsdisplay,6,0,0,null,1
+forecast,tsdisplay,7,0,0,character,1
+forecast,tslm,-1,0,0,"class<`lm`, `mlm`, `tslm`>",1
+forecast,tslm,-1,0,1,"class<`lm`, `tslm`>",1
+forecast,tslm,0,0,0,class<`formula`>,1
+forecast,tslm,1,0,0,any,1
+forecast,tslm,2,0,0,any,1
+forecast,tslm,3,0,0,null,1
+forecast,tslm,4,0,0,logical,1
+forecast,tslm,5,0,0,...,1
+forecast,tsoutliers,-1,0,0,list<double[]>,1
+forecast,tsoutliers,0,0,0,class<`ts`>,1
+forecast,tsoutliers,1,0,0,double,1
+forecast,tsoutliers,2,0,0,null,1
+forecast,undo.na.ends,-1,0,0,class<`ts`>,1
+forecast,undo.na.ends,0,0,0,class<`ts`>,1
+forecast,undo.na.ends,0,0,1,double[],1
+forecast,undo.na.ends,1,0,0,class<`ts`>,1
+forecast,unfracdiff,-1,0,0,class<`ts`>,1
+forecast,unfracdiff,0,0,0,class<`ts`>,1
+forecast,unfracdiff,1,0,0,class<`ts`>,1
+forecast,unfracdiff,2,0,0,integer,1
+forecast,unfracdiff,3,0,0,double,1
+forecast,unfracdiff,4,0,0,double,1
+forecast,window.msts,-1,0,0,"class<`msts`, `ts`>",1
+forecast,window.msts,0,0,0,"class<`msts`, `ts`>",1
+forecast,window.msts,1,0,0,...,1
+forecast,zzhw,-1,0,0,list<double[]>,1
+forecast,zzhw,0,0,0,class<`ts`>,1
+forecast,zzhw,1,0,0,integer,1
+forecast,zzhw,2,0,0,double,1
+forecast,zzhw,3,0,0,any,1
+forecast,zzhw,4,0,0,any,1
+forecast,zzhw,5,0,0,character,1
+forecast,zzhw,6,0,0,double,1
+forecast,zzhw,7,0,0,logical,1
+foreign,adQuote,-1,0,0,character[],1
+foreign,adQuote,0,0,0,character[],1
+foreign,lookup.xport,-1,0,0,any,1
+foreign,lookup.xport,0,0,0,character,1
+foreign,read.arff,-1,0,0,any,1
+foreign,read.arff,0,0,0,character,1
+foreign,read.dbf,-1,0,0,class<`data.frame`>,1
+foreign,read.dbf,0,0,0,character,1
+foreign,read.dbf,1,0,0,logical,1
+foreign,read.dta,-1,0,0,any,1
+foreign,read.dta,0,0,0,character,1
+foreign,read.dta,1,0,0,logical,1
+foreign,read.dta,2,0,0,logical,1
+foreign,read.dta,3,0,0,logical,1
+foreign,read.dta,4,0,0,logical,1
+foreign,read.dta,5,0,0,logical,1
+foreign,read.mtp,-1,0,0,any,1
+foreign,read.mtp,0,0,0,character,1
+foreign,read.octave,-1,0,0,any,1
+foreign,read.octave,0,0,0,character,1
+foreign,read.S,-1,0,0,any,1
+foreign,read.S,0,0,0,character,1
+foreign,read.spss,-1,0,0,any,1
+foreign,read.spss,0,0,0,character,1
+foreign,read.spss,1,0,0,logical,1
+foreign,read.spss,2,0,0,logical,1
+foreign,read.spss,3,0,0,double,1
+foreign,read.spss,4,0,0,logical,1
+foreign,read.spss,5,0,0,logical,1
+foreign,read.spss,6,0,0,null,1
+foreign,read.spss,7,0,0,any,1
+foreign,read.spss,8,0,0,character,1
+foreign,read.spss,9,0,0,character[],1
+foreign,read.spss,10,0,0,character[],1
+foreign,read.spss,11,0,0,character,1
+foreign,read.spss,12,0,0,...,1
+foreign,read.systat,-1,0,0,class<`data.frame`>,1
+foreign,read.systat,0,0,0,character,1
+foreign,read.systat,1,0,0,logical,1
+foreign,write.arff,-1,0,0,null,1
+foreign,write.arff,0,0,0,class<`data.frame`>,1
+foreign,write.arff,1,0,0,character,1
+foreign,write.arff,2,0,0,character,1
+foreign,write.arff,3,0,0,character,1
+foreign,write.dbf,-1,0,0,null,1
+foreign,write.dbf,0,0,0,class<`data.frame`>,1
+foreign,write.dbf,1,0,0,character,1
+foreign,write.dbf,2,0,0,logical,1
+foreign,write.dbf,3,0,0,double,1
+foreign,write.dta,-1,0,0,null,1
+foreign,write.dta,0,0,0,class<`data.frame`>,1
+foreign,write.dta,1,0,0,character,1
+foreign,write.dta,2,0,0,integer,1
+foreign,write.dta,3,0,0,logical,1
+foreign,write.dta,4,0,0,character,1
+foreign,write.dta,5,0,0,character[],1
+foreign,write.foreign,-1,0,0,null,1
+foreign,write.foreign,0,0,0,class<`data.frame`>,1
+foreign,write.foreign,1,0,0,character,1
+foreign,write.foreign,2,0,0,character,1
+foreign,write.foreign,3,0,0,character,1
+foreign,write.foreign,4,0,0,...,1
+foreign,writeForeignSPSS,-1,0,0,null,1
+foreign,writeForeignSPSS,0,0,0,class<`data.frame`>,1
+foreign,writeForeignSPSS,1,0,0,character,1
+foreign,writeForeignSPSS,2,0,0,character,1
+foreign,writeForeignSPSS,3,0,0,null,1
+foreign,writeForeignSPSS,4,0,0,integer,1
+forestplot,forestplot,-1,0,0,"class<`path`, `vpPath`>",1
+forestplot,forestplot,0,0,0,...,1
+forestplot,forestplot.default,-1,0,0,"class<`path`, `vpPath`>",1
+forestplot,forestplot.default,0,0,0,character[],1
+forestplot,forestplot.default,0,0,1,class<`matrix`>,1
+forestplot,forestplot.default,0,0,2,integer[],1
+forestplot,forestplot.default,0,0,3,list<^character[] | list<expression | character>>,1
+forestplot,forestplot.default,0,0,4,list<list<character | expression | character | class<`call`>>>,1
+forestplot,forestplot.default,0,0,5,list<list<character | expression>>,1
+forestplot,forestplot.default,1,0,0,class<`matrix`>,1
+forestplot,forestplot.default,1,0,1,class<`data.frame`>,1
+forestplot,forestplot.default,1,0,2,^double[],1
+forestplot,forestplot.default,2,0,0,any,1
+forestplot,forestplot.default,3,0,0,any,1
+forestplot,forestplot.default,4,0,0,any,1
+forestplot,forestplot.default,5,0,0,logical[],1
+forestplot,forestplot.default,6,0,0,character,1
+forestplot,forestplot.default,6,0,1,double,1
+forestplot,forestplot.default,7,0,0,any,1
+forestplot,forestplot.default,8,0,0,double[],1
+forestplot,forestplot.default,9,0,0,character,1
+forestplot,forestplot.default,10,0,0,double[],1
+forestplot,forestplot.default,11,0,0,character,1
+forestplot,forestplot.default,12,0,0,any,1
+forestplot,forestplot.default,13,0,0,character,1
+forestplot,forestplot.default,13,0,1,class<`unit`>,1
+forestplot,forestplot.default,14,0,0,any,1
+forestplot,forestplot.default,15,0,0,"class<`fpColors`, `list`>",1
+forestplot,fpColors,-1,0,0,"class<`fpColors`, `list`>",1
+forestplot,fpColors,0,0,0,any,1
+forestplot,fpColors,1,0,0,character[],1
+forestplot,fpColors,2,0,0,character[],1
+forestplot,fpColors,3,0,0,character[],1
+forestplot,fpColors,4,0,0,character,1
+forestplot,fpColors,5,0,0,character,1
+forestplot,fpColors,6,0,0,character,1
+forestplot,fpColors,7,0,0,character,1
+forestplot,fpDrawPointCI,-1,0,0,"class<`gDesc`, `grob`, `points`>",1
+forestplot,fpDrawPointCI,0,0,0,double,1
+forestplot,fpDrawPointCI,1,0,0,double,1
+forestplot,fpDrawPointCI,2,0,0,double,1
+forestplot,fpDrawPointCI,3,0,0,double,1
+forestplot,fpDrawPointCI,4,0,0,double,1
+forestplot,fpDrawPointCI,5,0,0,character,1
+forestplot,fpDrawPointCI,6,0,0,character,1
+forestplot,fpDrawPointCI,7,0,0,any,1
+forestplot,fpDrawPointCI,8,0,0,double,1
+forestplot,fpDrawPointCI,9,0,0,any,1
+forestplot,fpDrawPointCI,10,0,0,double,1
+forestplot,fpDrawPointCI,11,0,0,double,1
+forestplot,fpDrawPointCI,12,0,0,...,1
+forestplot,fpLegend,-1,0,0,list<any>,1
+forestplot,fpLegend,0,0,0,character,1
+forestplot,fpLegend,0,0,1,list<character>,1
+forestplot,fpLegend,0,0,2,list<character | double>,1
+forestplot,fpLegend,0,0,3,list<double>,1
+forestplot,fpLegend,1,0,0,null,1
+forestplot,fpLegend,1,0,1,class<`gpar`>,1
+forestplot,fpLegend,2,0,0,class<`unit`>,1
+forestplot,fpLegend,3,0,0,class<`unit`>,1
+forestplot,fpLegend,4,0,0,character,1
+forestplot,fpLegend,4,0,1,null,1
+forestplot,fpTxtGp,-1,0,0,"class<`fpTxtGp`, `list`>",1
+forestplot,fpTxtGp,0,0,0,any,1
+forestplot,fpTxtGp,1,0,0,any,1
+forestplot,fpTxtGp,2,0,0,any,1
+forestplot,fpTxtGp,3,0,0,any,1
+forestplot,fpTxtGp,4,0,0,any,1
+forestplot,fpTxtGp,5,0,0,any,1
+forestplot,fpTxtGp,6,0,0,any,1
+forestplot,fpTxtGp,7,0,0,double,1
+forestplot,getTicks,-1,0,0,double[],1
+forestplot,getTicks,0,0,0,double[],1
+forestplot,getTicks,1,0,0,double[],1
+forestplot,getTicks,2,0,0,double[],1
+forestplot,getTicks,3,0,0,logical,1
+forestplot,getTicks,4,0,0,any,1
+forestplot,heightDetails.xaxis,-1,0,0,"class<`unit`, `unit.arithmetic`>",1
+forestplot,heightDetails.xaxis,0,0,0,"class<`axis`, `gDesc`, `gTree`, `grob`, `xaxis`>",1
+forestplot,prFpConvertMultidimArray,-1,0,0,list<^double[]>,1
+forestplot,prFpConvertMultidimArray,0,0,0,class<`data.frame`>,1
+forestplot,prFpConvertMultidimArray,0,0,1,class<`matrix`>,1
+forestplot,prFpDrawLegend,-1,0,0,"class<`path`, `vpPath`>",1
+forestplot,prFpDrawLegend,-1,0,1,null,1
+forestplot,prFpDrawLegend,0,0,0,"class<`Legend`, `list`>",1
+forestplot,prFpDrawLegend,1,0,0,"class<`fpColors`, `list`>",1
+forestplot,prFpDrawLegend,2,0,0,class<`unit`>,1
+forestplot,prFpDrawLegend,3,0,0,list<double | character[]>,1
+forestplot,prFpDrawLegend,3,0,1,"list<class<`unit`> | class<`unit`, `unit.arithmetic`> | character[]>",1
+forestplot,prFpDrawLegend,3,0,2,character,1
+forestplot,prFpDrawLegend,4,0,0,class<`gpar`>,1
+forestplot,prFpDrawLegend,4,0,1,null,1
+forestplot,prFpDrawLegend,5,0,0,any,1
+forestplot,prFpDrawLegend,6,0,0,any,1
+forestplot,prFpDrawLegend,7,0,0,list<class<`function`>>,1
+forestplot,prFpDrawLegend,8,0,0,...,1
+forestplot,prFpDrawLine,-1,0,0,"class<`gDesc`, `grob`, `lines`>",1
+forestplot,prFpDrawLine,-1,0,1,null,1
+forestplot,prFpDrawLine,0,0,0,double,1
+forestplot,prFpDrawLine,1,0,0,double,1
+forestplot,prFpDrawLine,2,0,0,any,1
+forestplot,prFpDrawLine,3,0,0,any,1
+forestplot,prFpDrawLine,4,0,0,any,1
+forestplot,prFpDrawLine,5,0,0,any,1
+forestplot,prFpDrawLine,6,0,0,any,1
+forestplot,prFpDrawLine,7,0,0,any,1
+forestplot,prFpDrawLines,-1,0,0,null,1
+forestplot,prFpDrawLines,0,0,0,"list<null | class<`gpar`, `list`>>",1
+forestplot,prFpDrawLines,0,0,1,list<null>,1
+forestplot,prFpDrawLines,1,0,0,integer,1
+forestplot,prFpDrawLines,2,0,0,any,1
+forestplot,prFpDrawLines,3,0,0,any,1
+forestplot,prFpFetchRowLabel,-1,0,0,character,1
+forestplot,prFpFetchRowLabel,-1,0,1,class<`call`>,1
+forestplot,prFpFetchRowLabel,-1,0,2,expression,1
+forestplot,prFpFetchRowLabel,-1,0,3,integer,1
+forestplot,prFpFetchRowLabel,0,0,0,character,1
+forestplot,prFpFetchRowLabel,1,0,0,class<`matrix`>,1
+forestplot,prFpFetchRowLabel,1,0,1,list<^character[] | list<expression | character>>,1
+forestplot,prFpFetchRowLabel,1,0,2,list<list<character | expression | character | class<`call`>>>,1
+forestplot,prFpFetchRowLabel,1,0,3,list<list<character | expression>>,1
+forestplot,prFpFetchRowLabel,2,0,0,integer,1
+forestplot,prFpFetchRowLabel,3,0,0,integer,1
+forestplot,prFpFindWidestGrob,-1,0,0,class<`unit`>,1
+forestplot,prFpFindWidestGrob,0,0,0,"list<class<`gDesc`, `grob`, `text`> | null>",1
+forestplot,prFpFindWidestGrob,0,0,1,"list<class<`gDesc`, `grob`, `text`>>",1
+forestplot,prFpFindWidestGrob,1,0,0,character,1
+forestplot,prFpGetConfintFnList,-1,0,0,list<class<`function`>>,1
+forestplot,prFpGetConfintFnList,-1,0,1,list<list<class<`function`>>>,1
+forestplot,prFpGetConfintFnList,0,0,0,class<`function`>,1
+forestplot,prFpGetConfintFnList,0,0,1,list<character | class<`function`>>,1
+forestplot,prFpGetConfintFnList,0,0,2,character[],1
+forestplot,prFpGetConfintFnList,0,0,3,list<list<class<`function`>>>,1
+forestplot,prFpGetConfintFnList,0,0,4,list<class<`function`>>,1
+forestplot,prFpGetConfintFnList,1,0,0,integer,1
+forestplot,prFpGetConfintFnList,2,0,0,integer,1
+forestplot,prFpGetConfintFnList,3,0,0,any,1
+forestplot,prFpGetConfintFnList,4,0,0,any,1
+forestplot,prFpGetConfintFnList,5,0,0,any,1
+forestplot,prFpGetGraphTicksAndClips,-1,0,0,list<any>,1
+forestplot,prFpGetGraphTicksAndClips,0,0,0,any,1
+forestplot,prFpGetGraphTicksAndClips,1,0,0,any,1
+forestplot,prFpGetGraphTicksAndClips,2,0,0,double[],1
+forestplot,prFpGetGraphTicksAndClips,3,0,0,logical,1
+forestplot,prFpGetGraphTicksAndClips,4,0,0,character,1
+forestplot,prFpGetGraphTicksAndClips,5,0,0,any,1
+forestplot,prFpGetGraphTicksAndClips,6,0,0,"class<`fpColors`, `list`>",1
+forestplot,prFpGetGraphTicksAndClips,7,0,0,"class<`fpTxtGp`, `list`>",1
+forestplot,prFpGetGraphTicksAndClips,8,0,0,double[],1
+forestplot,prFpGetGraphTicksAndClips,9,0,0,double[],1
+forestplot,prFpGetGraphTicksAndClips,10,0,0,double[],1
+forestplot,prFpGetGraphTicksAndClips,11,0,0,class<`matrix`>,1
+forestplot,prFpGetGraphTicksAndClips,11,0,1,^double[],1
+forestplot,prFpGetGraphTicksAndClips,12,0,0,double,1
+forestplot,prFpGetLabels,-1,0,0,"list<list<class<`gDesc`, `grob`, `text`> | null>>",1
+forestplot,prFpGetLabels,-1,0,1,"list<list<class<`gDesc`, `grob`, `text`>>>",1
+forestplot,prFpGetLabels,0,0,0,character,1
+forestplot,prFpGetLabels,1,0,0,class<`matrix`>,1
+forestplot,prFpGetLabels,1,0,1,list<^character[] | list<expression | character>>,1
+forestplot,prFpGetLabels,1,0,2,list<list<character | expression | character | class<`call`>>>,1
+forestplot,prFpGetLabels,1,0,3,list<list<character | expression>>,1
+forestplot,prFpGetLabels,2,0,0,character[],1
+forestplot,prFpGetLabels,3,0,0,double,1
+forestplot,prFpGetLabels,4,0,0,integer,1
+forestplot,prFpGetLabels,5,0,0,logical[],1
+forestplot,prFpGetLabels,6,0,0,"class<`fpTxtGp`, `list`>",1
+forestplot,prFpGetLabels,7,0,0,"class<`fpColors`, `list`>",1
+forestplot,prFpGetLayoutVP,-1,0,0,class<`viewport`>,1
+forestplot,prFpGetLayoutVP,0,0,0,character,1
+forestplot,prFpGetLayoutVP,0,0,1,class<`unit`>,1
+forestplot,prFpGetLayoutVP,1,0,0,any,1
+forestplot,prFpGetLayoutVP,2,0,0,any,1
+forestplot,prFpGetLayoutVP,3,0,0,class<`layout`>,1
+forestplot,prFpGetLayoutVP,3,0,1,null,1
+forestplot,prFpGetLegendBoxPosition,-1,0,0,"list<class<`unit`> | class<`unit`, `unit.arithmetic`> | character[]>",1
+forestplot,prFpGetLegendBoxPosition,-1,0,1,list<double | character[]>,1
+forestplot,prFpGetLegendBoxPosition,0,0,0,list<character>,1
+forestplot,prFpGetLegendBoxPosition,0,0,1,list<character | double>,1
+forestplot,prFpGetLegendBoxPosition,0,0,2,list<double>,1
+forestplot,prFpGetLegendGrobs,-1,0,0,"class<`Legend`, `list`>",1
+forestplot,prFpGetLegendGrobs,0,0,0,character[],1
+forestplot,prFpGetLegendGrobs,1,0,0,"class<`fpTxtGp`, `list`>",1
+forestplot,prFpGetLegendGrobs,2,0,0,null,1
+forestplot,prFpGetLegendGrobs,2,0,1,character,1
+forestplot,prFpGetLines,-1,0,0,"list<null | class<`gpar`, `list`>>",1
+forestplot,prFpGetLines,-1,0,1,list<null>,1
+forestplot,prFpGetLines,0,0,0,any,1
+forestplot,prFpGetLines,1,0,0,logical[],1
+forestplot,prFpGetLines,2,0,0,any,1
+forestplot,prFpGetLines,3,0,0,any,1
+forestplot,prFpPrepareLegendMarker,-1,0,0,list<class<`function`>>,1
+forestplot,prFpPrepareLegendMarker,0,0,0,any,1
+forestplot,prFpPrepareLegendMarker,1,0,0,integer,1
+forestplot,prFpPrepareLegendMarker,2,0,0,any,1
+forestplot,prFpPrepareLegendMarker,3,0,0,character[],1
+forestplot,prFpPrepareLegendMarker,3,0,1,class<`function`>,1
+forestplot,prFpPrepareLegendMarker,3,0,2,list<list<class<`function`>>>,1
+forestplot,prFpPrepareLegendMarker,3,0,3,list<class<`function`>>,1
+forestplot,prFpPrintLabels,-1,0,0,null,1
+forestplot,prFpPrintLabels,0,0,0,"list<list<class<`gDesc`, `grob`, `text`> | null>>",1
+forestplot,prFpPrintLabels,0,0,1,"list<list<class<`gDesc`, `grob`, `text`>>>",1
+forestplot,prFpPrintLabels,1,0,0,double,1
+forestplot,prFpPrintLabels,2,0,0,integer,1
+forestplot,prFpPrintLabels,3,0,0,double,1
+forestplot,prFpPrintXaxis,-1,0,0,"class<`path`, `vpPath`>",1
+forestplot,prFpPrintXaxis,0,0,0,list<any>,1
+forestplot,prFpPrintXaxis,1,0,0,"class<`fpColors`, `list`>",1
+forestplot,prFpPrintXaxis,2,0,0,any,1
+forestplot,prFpValidateLabelList,-1,0,0,logical,1
+forestplot,prFpValidateLabelList,0,0,0,list<^character[] | list<expression | character>>,1
+forestplot,prFpValidateLabelList,0,0,1,list<list<character | expression | character | class<`call`>>>,1
+forestplot,prFpValidateLabelList,0,0,2,list<list<character | expression>>,1
+forestplot,prFpXrange,-1,0,0,double[],1
+forestplot,prFpXrange,0,0,0,^double[],1
+forestplot,prFpXrange,1,0,0,^double[],1
+forestplot,prFpXrange,2,0,0,double[],1
+forestplot,prFpXrange,3,0,0,double[],1
+forestplot,prFpXrange,4,0,0,any,1
+forestplot,prFpXrange,5,0,0,logical,1
+forestplot,prGetTextGrobCex,-1,0,0,double,1
+forestplot,prGetTextGrobCex,0,0,0,"class<`gDesc`, `grob`, `text`>",1
+forestplot,prGparMerge,-1,0,0,"class<`gpar`, `list`>",1
+forestplot,prGparMerge,-1,0,1,list<character | double>,1
+forestplot,prGparMerge,0,0,0,class<`gpar`>,1
+forestplot,prGparMerge,0,0,1,list<character | double>,1
+forestplot,prGparMerge,1,0,0,class<`gpar`>,1
+forestplot,prGparMerge,1,0,1,list<character | double>,1
+forestplot,prGparMerge,1,0,2,list<double>,1
+forestplot,prGridPlotTitle,-1,0,0,null,1
+forestplot,prGridPlotTitle,0,0,0,character,1
+forestplot,prGridPlotTitle,1,0,0,list<character | double>,1
+forestplot,prGridPlotTitle,2,0,0,any,1
+forestplot,prListRep,-1,0,0,list<list<list<character | double>>>,1
+forestplot,prListRep,-1,0,1,list<list<character | double>>,1
+forestplot,prListRep,0,0,0,list<list<list<character | double>>>,1
+forestplot,prListRep,0,0,1,list<list<character | double>>,1
+forestplot,prListRep,0,0,2,list<character | double>,1
+forestplot,prListRep,1,0,0,double,1
+forestplot,prPopulateList,-1,0,0,list<character | class<`function`>>,1
+forestplot,prPopulateList,-1,0,1,list<class<`function`>>,1
+forestplot,prPopulateList,-1,0,2,list<double>,1
+forestplot,prPopulateList,-1,0,3,list<list<character>>,1
+forestplot,prPopulateList,-1,0,4,list<list<character | class<`function`>>>,1
+forestplot,prPopulateList,-1,0,5,list<list<class<`function`>>>,1
+forestplot,prPopulateList,-1,0,6,list<list<double>>,1
+forestplot,prPopulateList,0,0,0,list<character | class<`function`>>,1
+forestplot,prPopulateList,0,0,1,class<`function`>,1
+forestplot,prPopulateList,0,0,2,character[],1
+forestplot,prPopulateList,0,0,3,list<list<class<`function`>>>,1
+forestplot,prPopulateList,0,0,4,list<class<`function`>>,1
+forestplot,prPopulateList,0,0,5,double[],1
+forestplot,prPopulateList,1,0,0,integer,1
+forestplot,prPopulateList,2,0,0,integer,1
+forestplot,prPopulateList,3,0,0,any,1
+forestplot,prPopulateList,4,0,0,any,1
+forestplot,prPopulateList,5,0,0,any,1
+forestplot,prPushMarginViewport,-1,0,0,null,1
+forestplot,prPushMarginViewport,0,0,0,class<`unit`>,1
+forestplot,prPushMarginViewport,1,0,0,class<`unit`>,1
+forestplot,prPushMarginViewport,2,0,0,class<`unit`>,1
+forestplot,prPushMarginViewport,3,0,0,class<`unit`>,1
+forestplot,prPushMarginViewport,4,0,0,character,1
+formatR,count_tokens,-1,0,0,integer[],1
+formatR,count_tokens,0,0,0,class<`call`>,1
+formatR,find_breaks,-1,0,0,list<integer | null>,1
+formatR,find_breaks,-1,0,1,list<integer[] | null>,1
+formatR,find_breaks,-1,0,2,list<integer[]>,1
+formatR,find_breaks,-1,0,3,list<null>,1
+formatR,find_breaks,0,0,0,integer[],1
+formatR,find_breaks,1,0,0,any,1
+formatR,find_breaks,2,0,0,any,1
+formatR,find_breaks,3,0,0,any,1
+formatR,find_breaks,4,0,0,any,1
+formatR,fix_parse_data,-1,0,0,class<`data.frame`>,1
+formatR,fix_parse_data,0,0,0,class<`data.frame`>,1
+formatR,fix_parse_data,1,0,0,any,1
+formatR,mask_comments,-1,0,0,character[],1
+formatR,mask_comments,0,0,0,character[],1
+formatR,mask_comments,1,0,0,any,1
+formatR,mask_comments,2,0,0,logical,1
+formatR,mask_comments,3,0,0,logical,1
+formatR,mask_line_break,-1,0,0,character[],1
+formatR,mask_line_break,0,0,0,character[],1
+formatR,overflow_message,-1,0,0,character,1
+formatR,overflow_message,0,0,0,integer[],1
+formatR,overflow_message,1,0,0,integer,1
+formatR,overflow_message,2,0,0,integer,1
+formatR,overflow_message,3,0,0,character,1
+formatR,parse_only,-1,0,0,expression,1
+formatR,parse_only,0,0,0,character[],1
+formatR,parse_source,-1,0,0,expression,1
+formatR,parse_source,0,0,0,character[],1
+formatR,reflow_comments,-1,0,0,character[],1
+formatR,reflow_comments,0,0,0,character[],1
+formatR,reflow_comments,1,0,0,any,1
+formatR,reindent_lines,-1,0,0,character[],1
+formatR,reindent_lines,0,0,0,character[],1
+formatR,reindent_lines,1,0,0,double,1
+formatR,restore_encoding,-1,0,0,character[],1
+formatR,restore_encoding,0,0,0,character[],1
+formatR,restore_encoding,1,0,0,character[],1
+formatR,special_encoding,-1,0,0,character[],1
+formatR,special_encoding,0,0,0,character[],1
+formatR,tidy_block,-1,0,0,character[],1
+formatR,tidy_block,0,0,0,character[],1
+formatR,tidy_block,1,0,0,integer,1
+formatR,tidy_block,2,0,0,logical,1
+formatR,tidy_dir,-1,0,0,null,1
+formatR,tidy_dir,0,0,0,character,1
+formatR,tidy_dir,1,0,0,logical,1
+formatR,tidy_dir,2,0,0,...,1
+formatR,tidy_eval,-1,0,0,null,1
+formatR,tidy_eval,0,0,0,character,1
+formatR,tidy_eval,1,0,0,...,1
+formatR,tidy_eval,2,0,0,character,1
+formatR,tidy_eval,3,0,0,character,1
+formatR,tidy_eval,4,0,0,environment,1
+formatR,tidy_file,-1,0,0,null,1
+formatR,tidy_file,0,0,0,character[],1
+formatR,tidy_file,1,0,0,...,1
+formatR,tidy_source,-1,0,0,list<character[]>,1
+formatR,tidy_source,0,0,0,any,1
+formatR,tidy_source,1,0,0,logical,1
+formatR,tidy_source,2,0,0,logical,1
+formatR,tidy_source,3,0,0,logical,1
+formatR,tidy_source,4,0,0,logical,1
+formatR,tidy_source,5,0,0,double,1
+formatR,tidy_source,6,0,0,any,1
+formatR,tidy_source,7,0,0,logical,1
+formatR,tidy_source,8,0,0,character[],1
+formatR,tidy_source,8,0,1,null,1
+formatR,tidy_source,9,0,0,integer,1
+formatR,tidy_source,10,0,0,...,1
+formatR,tidy_usage,-1,0,0,character,1
+formatR,tidy_usage,0,0,0,character,1
+formatR,tidy_usage,1,0,0,character[],1
+formatR,tidy_usage,2,0,0,double,1
+formatR,tidy_usage,3,0,0,double,1
+formatR,tidy_usage,4,0,0,character,1
+formatR,trimws,-1,0,0,character[],1
+formatR,trimws,0,0,0,character[],1
+formatR,trimws,1,0,0,character,1
+formatR,unmask_source,-1,0,0,character[],1
+formatR,unmask_source,0,0,0,character[],1
+formatR,usage,-1,0,0,character[],1
+formatR,usage,0,0,0,character,1
+formatR,usage,0,0,1,class<`function`>,1
+formatR,usage,1,0,0,double,1
+formatR,usage,2,0,0,logical,1
+formatR,usage,3,0,0,logical,1
+formatR,usage,4,0,0,logical,1
+formatR,usage,5,0,0,character[],1
+formattable,accounting,-1,0,0,"class<`formattable`, `numeric`>",1
+formattable,accounting,0,0,0,character[],1
+formattable,accounting,0,0,1,double[],1
+formattable,accounting,1,0,0,integer,1
+formattable,accounting,2,0,0,character,1
+formattable,accounting,3,0,0,character,1
+formattable,accounting,4,0,0,...,1
+formattable,accounting.character,-1,0,0,"class<`formattable`, `numeric`>",1
+formattable,accounting.character,0,0,0,character[],1
+formattable,accounting.character,1,0,0,integer,1
+formattable,accounting.character,2,0,0,character,1
+formattable,accounting.character,3,0,0,character,1
+formattable,accounting.character,4,0,0,...,1
+formattable,accounting.default,-1,0,0,"class<`formattable`, `numeric`>",1
+formattable,accounting.default,0,0,0,double[],1
+formattable,accounting.default,1,0,0,integer,1
+formattable,accounting.default,2,0,0,character,1
+formattable,accounting.default,3,0,0,character,1
+formattable,accounting.default,4,0,0,...,1
+formattable,all.formattable,-1,0,0,"class<`formattable`, `logical`>",1
+formattable,all.formattable,0,0,0,...,1
+formattable,any.formattable,-1,0,0,"class<`formattable`, `logical`>",1
+formattable,any.formattable,0,0,0,...,1
+formattable,area,-1,0,0,class<`area`>,1
+formattable,area,0,0,0,any,1
+formattable,area,1,0,0,any,1
+formattable,as.character.formattable,-1,0,0,character,1
+formattable,as.character.formattable,0,0,0,"class<`formattable`, `numeric`>",1
+formattable,as.character.formattable,1,0,0,...,1
+formattable,as.datatable,-1,0,0,"class<`datatables`, `htmlwidget`>",1
+formattable,as.datatable,0,0,0,"class<`data.frame`, `formattable`>",1
+formattable,as.datatable,1,0,0,...,1
+formattable,as.datatable.formattable,-1,0,0,"class<`datatables`, `htmlwidget`>",1
+formattable,as.datatable.formattable,0,0,0,"class<`data.frame`, `formattable`>",1
+formattable,as.datatable.formattable,1,0,0,logical,1
+formattable,as.datatable.formattable,2,0,0,...,1
+formattable,as_numeric,-1,0,0,class<`array`>,1
+formattable,as_numeric,-1,0,1,class<`matrix`>,1
+formattable,as_numeric,-1,0,2,double[],1
+formattable,as_numeric,0,0,0,class<`array`>,1
+formattable,as_numeric,0,0,1,class<`matrix`>,1
+formattable,as_numeric,0,0,2,double[],1
+formattable,call_or_default,-1,0,0,character[],1
+formattable,call_or_default,-1,0,1,double[],1
+formattable,call_or_default,0,0,0,character,1
+formattable,call_or_default,0,0,1,class<`function`>,1
+formattable,call_or_default,1,0,0,character[],1
+formattable,call_or_default,1,0,1,double[],1
+formattable,call_or_default,2,0,0,...,1
+formattable,check_rgb,-1,0,0,logical[],1
+formattable,check_rgb,0,0,0,character[],1
+formattable,check_rgb,1,0,0,logical,1
+formattable,check_rgba,-1,0,0,logical[],1
+formattable,check_rgba,0,0,0,character[],1
+formattable,color_bar,-1,0,0,"class<`formatter`, `function`>",1
+formattable,color_bar,0,0,0,any,1
+formattable,color_bar,1,0,0,class<`function`>,1
+formattable,color_bar,1,0,1,character,1
+formattable,color_bar,2,0,0,...,1
+formattable,color_text,-1,0,0,"class<`formatter`, `function`>",1
+formattable,color_text,0,0,0,...,1
+formattable,color_tile,-1,0,0,"class<`formatter`, `function`>",1
+formattable,color_tile,0,0,0,...,1
+formattable,comma,-1,0,0,"class<`formattable`, `numeric`>",1
+formattable,comma,0,0,0,character,1
+formattable,comma,0,0,1,double[],1
+formattable,comma,1,0,0,any,1
+formattable,comma,2,0,0,character,1
+formattable,comma,3,0,0,character,1
+formattable,comma,4,0,0,...,1
+formattable,comma.character,-1,0,0,"class<`formattable`, `numeric`>",1
+formattable,comma.character,0,0,0,character,1
+formattable,comma.character,1,0,0,integer,1
+formattable,comma.character,2,0,0,character,1
+formattable,comma.character,3,0,0,character,1
+formattable,comma.character,4,0,0,...,1
+formattable,comma.default,-1,0,0,"class<`formattable`, `numeric`>",1
+formattable,comma.default,0,0,0,double[],1
+formattable,comma.default,1,0,0,integer,1
+formattable,comma.default,2,0,0,character,1
+formattable,comma.default,3,0,0,character,1
+formattable,comma.default,4,0,0,...,1
+formattable,cop_create_obj,-1,0,0,"class<`Date`, `formattable`>",1
+formattable,cop_create_obj,-1,0,1,"class<`formattable`, `numeric`>",1
+formattable,cop_create_obj,-1,0,2,"class<`POSIXct`, `POSIXt`, `formattable`>",1
+formattable,cop_create_obj,0,0,0,class<`function`>,1
+formattable,cop_create_obj,1,0,0,character,1
+formattable,cop_create_obj,2,0,0,"class<`Date`, `formattable`>",1
+formattable,cop_create_obj,2,0,1,"class<`formattable`, `numeric`>",1
+formattable,cop_create_obj,2,0,2,"class<`POSIXct`, `POSIXt`, `formattable`>",1
+formattable,cop_create_obj,3,0,0,double,1
+formattable,cop_create_obj,3,0,1,"class<`formattable`, `numeric`>",1
+formattable,copy_dim,-1,0,0,character[],1
+formattable,copy_dim,-1,0,1,"class<`formattable`, `numeric`>",1
+formattable,copy_dim,-1,0,2,class<`matrix`>,1
+formattable,copy_dim,0,0,0,"class<`formattable`, `numeric`>",1
+formattable,copy_dim,0,0,1,double[],1
+formattable,copy_dim,0,0,2,character[],1
+formattable,copy_dim,0,0,3,class<`matrix`>,1
+formattable,copy_dim,1,0,0,character[],1
+formattable,copy_dim,1,0,1,"class<`formattable`, `numeric`>",1
+formattable,copy_dim,2,0,0,logical,1
+formattable,copy_obj,-1,0,0,"class<`formattable`, `logical`>",1
+formattable,copy_obj,-1,0,1,"class<`formattable`, `numeric`>",1
+formattable,copy_obj,0,0,0,"class<`formattable`, `logical`>",1
+formattable,copy_obj,0,0,1,"class<`formattable`, `numeric`>",1
+formattable,copy_obj,0,0,2,"class<`formattable`, `matrix`>",1
+formattable,copy_obj,1,0,0,double[],1
+formattable,copy_obj,2,0,0,character,1
+formattable,create_obj,-1,0,0,"class<`array`, `formattable`>",1
+formattable,create_obj,-1,0,1,"class<`data.frame`, `formattable`>",1
+formattable,create_obj,-1,0,2,"class<`Date`, `formattable`>",1
+formattable,create_obj,-1,0,3,"class<`factor`, `formattable`>",1
+formattable,create_obj,-1,0,4,"class<`formattable`, `integer`>",1
+formattable,create_obj,-1,0,5,"class<`formattable`, `logical`>",1
+formattable,create_obj,-1,0,6,"class<`formattable`, `matrix`>",1
+formattable,create_obj,-1,0,7,"class<`formattable`, `numeric`>",1
+formattable,create_obj,-1,0,8,"class<`POSIXct`, `POSIXt`, `formattable`>",1
+formattable,create_obj,0,0,0,class<`array`>,1
+formattable,create_obj,0,0,1,class<`data.frame`>,1
+formattable,create_obj,0,0,2,class<`Date`>,1
+formattable,create_obj,0,0,3,class<`factor`>,1
+formattable,create_obj,0,0,4,^integer[],1
+formattable,create_obj,0,0,5,class<`matrix`>,1
+formattable,create_obj,0,0,6,double[],1
+formattable,create_obj,0,0,7,"class<`POSIXct`, `POSIXt`>",1
+formattable,create_obj,1,0,0,character,1
+formattable,create_obj,2,0,0,list<any>,1
+formattable,csscolor,-1,0,0,character[],1
+formattable,csscolor,0,0,0,character[],1
+formattable,csscolor,0,0,1,class<`matrix`>,1
+formattable,csscolor,1,0,0,any,1
+formattable,csscolor,2,0,0,logical,1
+formattable,csscolor.character,-1,0,0,character[],1
+formattable,csscolor.character,0,0,0,character[],1
+formattable,csscolor.character,1,0,0,character[],1
+formattable,csscolor.character,2,0,0,logical,1
+formattable,csscolor.matrix,-1,0,0,character[],1
+formattable,csscolor.matrix,0,0,0,class<`matrix`>,1
+formattable,csscolor.matrix,1,0,0,character[],1
+formattable,csscolor.matrix,2,0,0,logical,1
+formattable,currency,-1,0,0,"class<`formattable`, `numeric`>",1
+formattable,currency,0,0,0,character,1
+formattable,currency,0,0,1,double,1
+formattable,currency,1,0,0,any,1
+formattable,currency,2,0,0,any,1
+formattable,currency,3,0,0,character,1
+formattable,currency,4,0,0,character,1
+formattable,currency,5,0,0,...,1
+formattable,currency.character,-1,0,0,"class<`formattable`, `numeric`>",1
+formattable,currency.character,0,0,0,character,1
+formattable,currency.character,1,0,0,any,1
+formattable,currency.character,2,0,0,integer,1
+formattable,currency.character,3,0,0,character,1
+formattable,currency.character,4,0,0,character,1
+formattable,currency.character,5,0,0,...,1
+formattable,currency.default,-1,0,0,"class<`formattable`, `numeric`>",1
+formattable,currency.default,0,0,0,double,1
+formattable,currency.default,1,0,0,any,1
+formattable,currency.default,2,0,0,integer,1
+formattable,currency.default,3,0,0,character,1
+formattable,currency.default,4,0,0,character,1
+formattable,currency.default,5,0,0,...,1
+formattable,currency.default,6,0,0,character,1
+formattable,digits,-1,0,0,"class<`formattable`, `numeric`>",1
+formattable,digits,0,0,0,double,1
+formattable,digits,1,0,0,double,1
+formattable,digits,2,0,0,character,1
+formattable,digits,3,0,0,...,1
+formattable,eval_formula,-1,0,0,^character[],1
+formattable,eval_formula,0,0,0,class<`formula`>,1
+formattable,eval_formula,1,0,0,any,1
+formattable,eval_formula,2,0,0,any,1
+formattable,eval_formula,3,0,0,environment,1
+formattable,fcreate_obj,-1,0,0,"class<`formattable`, `logical`>",1
+formattable,fcreate_obj,-1,0,1,"class<`formattable`, `numeric`>",1
+formattable,fcreate_obj,0,0,0,class<`function`>,1
+formattable,fcreate_obj,1,0,0,character,1
+formattable,fcreate_obj,2,0,0,"class<`formattable`, `logical`>",1
+formattable,fcreate_obj,2,0,1,"class<`formattable`, `numeric`>",1
+formattable,fcreate_obj,3,0,0,...,1
+formattable,format.formattable,-1,0,0,character[],1
+formattable,format.formattable,0,0,0,"class<`formattable`, `numeric`>",1
+formattable,format.formattable,1,0,0,...,1
+formattable,format.formattable,2,0,0,null,1
+formattable,format.formattable,3,0,0,character,1
+formattable,format.formattable,4,0,0,logical,1
+formattable,format.formattable,5,0,0,logical,1
+formattable,format.formattable,6,0,0,logical,1
+formattable,formattable,-1,0,0,"class<`array`, `formattable`>",1
+formattable,formattable,-1,0,1,"class<`data.frame`, `formattable`>",1
+formattable,formattable,-1,0,2,"class<`Date`, `formattable`>",1
+formattable,formattable,-1,0,3,"class<`factor`, `formattable`>",1
+formattable,formattable,-1,0,4,"class<`formattable`, `integer`>",1
+formattable,formattable,-1,0,5,"class<`formattable`, `logical`>",1
+formattable,formattable,-1,0,6,"class<`formattable`, `matrix`>",1
+formattable,formattable,-1,0,7,"class<`formattable`, `numeric`>",1
+formattable,formattable,-1,0,8,"class<`POSIXct`, `POSIXt`, `formattable`>",1
+formattable,formattable,0,0,0,class<`array`>,1
+formattable,formattable,0,0,1,class<`data.frame`>,1
+formattable,formattable,0,0,2,class<`Date`>,1
+formattable,formattable,0,0,3,class<`factor`>,1
+formattable,formattable,0,0,4,^integer[],1
+formattable,formattable,0,0,5,class<`matrix`>,1
+formattable,formattable,0,0,6,"class<`formattable`, `numeric`>",1
+formattable,formattable,0,0,7,double[],1
+formattable,formattable,0,0,8,"class<`POSIXct`, `POSIXt`>",1
+formattable,formattable,1,0,0,...,1
+formattable,[.formattable,-1,0,0,"class<`formattable`, `numeric`>",1
+formattable,[.formattable,0,0,0,"class<`formattable`, `numeric`>",1
+formattable,[.formattable,0,0,1,"class<`formattable`, `matrix`>",1
+formattable,[.formattable,1,0,0,...,1
+formattable,[[<-.formattable,-1,0,0,"class<`formattable`, `numeric`>",1
+formattable,[[<-.formattable,0,0,0,"class<`formattable`, `numeric`>",1
+formattable,[[<-.formattable,1,0,0,...,1
+formattable,[[<-.formattable,2,0,0,double,1
+formattable,[[.formattable,-1,0,0,"class<`formattable`, `logical`>",1
+formattable,[[.formattable,-1,0,1,"class<`formattable`, `numeric`>",1
+formattable,[[.formattable,0,0,0,"class<`formattable`, `logical`>",1
+formattable,[[.formattable,0,0,1,"class<`formattable`, `numeric`>",1
+formattable,[[.formattable,1,0,0,...,1
+formattable,*.formattable,-1,0,0,"class<`formattable`, `numeric`>",1
+formattable,*.formattable,0,0,0,"class<`formattable`, `numeric`>",1
+formattable,*.formattable,1,0,0,double,1
+formattable,+.formattable,-1,0,0,"class<`Date`, `formattable`>",1
+formattable,+.formattable,-1,0,1,"class<`formattable`, `numeric`>",1
+formattable,+.formattable,-1,0,2,"class<`POSIXct`, `POSIXt`, `formattable`>",1
+formattable,+.formattable,0,0,0,"class<`Date`, `formattable`>",1
+formattable,+.formattable,0,0,1,"class<`formattable`, `numeric`>",1
+formattable,+.formattable,0,0,2,"class<`POSIXct`, `POSIXt`, `formattable`>",1
+formattable,+.formattable,1,0,0,double,1
+formattable,+.formattable,1,0,1,"class<`formattable`, `numeric`>",1
+formattable,format_table,-1,0,0,class<`knitr_kable`>,1
+formattable,format_table,0,0,0,class<`data.frame`>,1
+formattable,format_table,1,0,0,list<class<`formula`>>,1
+formattable,format_table,1,0,1,"list<class<`formatter`, `function`>>",1
+formattable,format_table,1,0,2,list<logical>,1
+formattable,format_table,2,0,0,character[],1
+formattable,format_table,3,0,0,character,1
+formattable,format_table,4,0,0,...,1
+formattable,format_table,5,0,0,integer,1
+formattable,format_table,6,0,0,character,1
+formattable,formattable.data.frame,-1,0,0,"class<`data.frame`, `formattable`>",1
+formattable,formattable.data.frame,0,0,0,class<`data.frame`>,1
+formattable,formattable.data.frame,1,0,0,...,1
+formattable,formattable.data.frame,2,0,0,character,1
+formattable,formattable.data.frame,3,0,0,null,1
+formattable,formattable.data.frame,4,0,0,null,1
+formattable,formattable.Date,-1,0,0,"class<`Date`, `formattable`>",1
+formattable,formattable.Date,0,0,0,class<`Date`>,1
+formattable,formattable.Date,1,0,0,...,1
+formattable,formattable.Date,2,0,0,character,1
+formattable,formattable.Date,3,0,0,null,1
+formattable,formattable.Date,4,0,0,null,1
+formattable,formattable.factor,-1,0,0,"class<`factor`, `formattable`>",1
+formattable,formattable.factor,0,0,0,class<`factor`>,1
+formattable,formattable.factor,1,0,0,...,1
+formattable,formattable.factor,2,0,0,character,1
+formattable,formattable.factor,3,0,0,null,1
+formattable,formattable.factor,4,0,0,null,1
+formattable,formattable.formattable,-1,0,0,"class<`formattable`, `numeric`>",1
+formattable,formattable.formattable,0,0,0,"class<`formattable`, `numeric`>",1
+formattable,formattable.formattable,1,0,0,...,1
+formattable,formattable.formattable,2,0,0,any,1
+formattable,formattable.formattable,3,0,0,any,1
+formattable,formattable.formattable,4,0,0,list<class<`function`>>,1
+formattable,formattable.logical,-1,0,0,"class<`formattable`, `logical`>",1
+formattable,formattable.logical,0,0,0,logical[],1
+formattable,formattable.logical,1,0,0,...,1
+formattable,formattable.logical,2,0,0,character,1
+formattable,formattable.logical,3,0,0,null,1
+formattable,formattable.logical,4,0,0,null,1
+formattable,formattable.numeric,-1,0,0,"class<`array`, `formattable`>",1
+formattable,formattable.numeric,-1,0,1,"class<`formattable`, `integer`>",1
+formattable,formattable.numeric,-1,0,2,"class<`formattable`, `matrix`>",1
+formattable,formattable.numeric,-1,0,3,"class<`formattable`, `numeric`>",1
+formattable,formattable.numeric,0,0,0,class<`array`>,1
+formattable,formattable.numeric,0,0,1,^integer[],1
+formattable,formattable.numeric,0,0,2,class<`matrix`>,1
+formattable,formattable.numeric,0,0,3,double[],1
+formattable,formattable.numeric,1,0,0,...,1
+formattable,formattable.numeric,2,0,0,character,1
+formattable,formattable.numeric,3,0,0,character,1
+formattable,formattable.numeric,3,0,1,null,1
+formattable,formattable.numeric,4,0,0,character,1
+formattable,formattable.numeric,4,0,1,list<class<`function`>>,1
+formattable,formattable.numeric,4,0,2,class<`function`>,1
+formattable,formattable.numeric,4,0,3,null,1
+formattable,formattable.POSIXct,-1,0,0,"class<`POSIXct`, `POSIXt`, `formattable`>",1
+formattable,formattable.POSIXct,0,0,0,"class<`POSIXct`, `POSIXt`>",1
+formattable,formattable.POSIXct,1,0,0,...,1
+formattable,formattable.POSIXct,2,0,0,character,1
+formattable,formattable.POSIXct,3,0,0,null,1
+formattable,formattable.POSIXct,4,0,0,null,1
+formattable,formatter,-1,0,0,"class<`formatter`, `function`>",1
+formattable,formatter,0,0,0,character,1
+formattable,formatter,1,0,0,...,1
+formattable,get_digits,-1,0,0,integer[],1
+formattable,get_digits,0,0,0,character[],1
+formattable,get_false_entries,-1,0,0,character[],1
+formattable,get_false_entries,-1,0,1,null,1
+formattable,get_false_entries,0,0,0,list<any>,1
+formattable,gradient,-1,0,0,class<`matrix`>,1
+formattable,gradient,0,0,0,double[],1
+formattable,gradient,1,0,0,character,1
+formattable,gradient,2,0,0,character,1
+formattable,gradient,3,0,0,logical,1
+formattable,gradient,3,0,1,null,1
+formattable,gradient,4,0,0,logical,1
+formattable,gradient,5,0,0,logical,1
+formattable,icontext,-1,0,0,"class<`list`, `shiny.tag.list`>",1
+formattable,icontext,-1,0,1,"list<class<`list`, `shiny.tag.list`>>",1
+formattable,icontext,0,0,0,character[],1
+formattable,icontext,0,0,1,list<character[]>,1
+formattable,icontext,1,0,0,list<null>,1
+formattable,icontext,1,0,1,double[],1
+formattable,icontext,1,0,2,character[],1
+formattable,icontext,2,0,0,...,1
+formattable,icontext,3,0,0,logical,1
+formattable,icontext,4,0,0,character,1
+formattable,icontext,5,0,0,character,1
+formattable,ifelse,-1,0,0,character[],1
+formattable,ifelse,-1,0,1,double[],1
+formattable,ifelse,0,0,0,logical[],1
+formattable,ifelse,1,0,0,character[],1
+formattable,ifelse,1,0,1,double,1
+formattable,ifelse,1,0,2,integer[],1
+formattable,ifelse,2,0,0,character,1
+formattable,ifelse,2,0,1,double,1
+formattable,ifelse,3,0,0,...,1
+formattable,is_false,-1,0,0,logical,1
+formattable,is_false,0,0,0,"class<`formatter`, `function`>",1
+formattable,is_false,0,0,1,class<`formula`>,1
+formattable,is_false,0,0,2,logical,1
+formattable,is.formattable,-1,0,0,logical,1
+formattable,is.formattable,0,0,0,"class<`data.frame`, `formattable`>",1
+formattable,is.formattable,0,0,1,"class<`formattable`, `numeric`>",1
+formattable,is.formattable,0,0,2,double,1
+formattable,max.formattable,-1,0,0,"class<`formattable`, `numeric`>",1
+formattable,max.formattable,0,0,0,...,1
+formattable,mean.formattable,-1,0,0,"class<`formattable`, `numeric`>",1
+formattable,mean.formattable,0,0,0,"class<`formattable`, `numeric`>",1
+formattable,mean.formattable,1,0,0,...,1
+formattable,normalize,-1,0,0,double[],1
+formattable,normalize,0,0,0,double[],1
+formattable,normalize,1,0,0,double,1
+formattable,normalize,2,0,0,double,1
+formattable,normalize,3,0,0,logical,1
+formattable,normalize_bar,-1,0,0,"class<`formatter`, `function`>",1
+formattable,normalize_bar,0,0,0,character,1
+formattable,normalize_bar,1,0,0,...,1
+formattable,percent,-1,0,0,"class<`array`, `formattable`>",1
+formattable,percent,-1,0,1,"class<`formattable`, `matrix`>",1
+formattable,percent,-1,0,2,"class<`formattable`, `numeric`>",1
+formattable,percent,0,0,0,class<`array`>,1
+formattable,percent,0,0,1,class<`matrix`>,1
+formattable,percent,0,0,2,character[],1
+formattable,percent,0,0,3,double[],1
+formattable,percent,1,0,0,any,1
+formattable,percent,2,0,0,character,1
+formattable,percent,3,0,0,...,1
+formattable,percent.character,-1,0,0,"class<`formattable`, `numeric`>",1
+formattable,percent.character,0,0,0,character[],1
+formattable,percent.character,1,0,0,null,1
+formattable,percent.character,2,0,0,character,1
+formattable,percent.character,3,0,0,...,1
+formattable,percent.default,-1,0,0,"class<`formattable`, `numeric`>",1
+formattable,percent.default,-1,0,1,"class<`array`, `formattable`>",1
+formattable,percent.default,-1,0,2,"class<`formattable`, `matrix`>",1
+formattable,percent.default,0,0,0,double[],1
+formattable,percent.default,0,0,1,class<`array`>,1
+formattable,percent.default,0,0,2,class<`matrix`>,1
+formattable,percent.default,1,0,0,double,1
+formattable,percent.default,2,0,0,character,1
+formattable,percent.default,3,0,0,...,1
+formattable,prefix,-1,0,0,"class<`formattable`, `integer`>",1
+formattable,prefix,-1,0,1,"class<`formattable`, `numeric`>",1
+formattable,prefix,0,0,0,^integer[],1
+formattable,prefix,0,0,1,"class<`formattable`, `numeric`>",1
+formattable,prefix,0,0,2,double[],1
+formattable,prefix,1,0,0,character,1
+formattable,prefix,2,0,0,character,1
+formattable,prefix,3,0,0,...,1
+formattable,prefix,4,0,0,character,1
+formattable,prefix,4,0,1,null,1
+formattable,proportion,-1,0,0,double[],1
+formattable,proportion,0,0,0,double[],1
+formattable,proportion,1,0,0,logical,1
+formattable,proportion_bar,-1,0,0,"class<`formatter`, `function`>",1
+formattable,proportion_bar,0,0,0,character,1
+formattable,proportion_bar,1,0,0,...,1
+formattable,qrank,-1,0,0,double[],1
+formattable,qrank,0,0,0,double[],1
+formattable,qrank,1,0,0,...,1
+formattable,remove_attribute,-1,0,0,character[],1
+formattable,remove_attribute,0,0,0,character[],1
+formattable,remove_attribute,1,0,0,character,1
+formattable,remove_class,-1,0,0,class<`data.frame`>,1
+formattable,remove_class,-1,0,1,class<`Date`>,1
+formattable,remove_class,-1,0,2,"class<`POSIXct`, `POSIXt`>",1
+formattable,remove_class,-1,0,3,double[],1
+formattable,remove_class,0,0,0,"class<`data.frame`, `formattable`>",1
+formattable,remove_class,0,0,1,"class<`Date`, `formattable`>",1
+formattable,remove_class,0,0,2,"class<`POSIXct`, `POSIXt`, `formattable`>",1
+formattable,remove_class,0,0,3,"class<`formattable`, `numeric`>",1
+formattable,remove_class,0,0,4,"class<`formattable`, `logical`>",1
+formattable,remove_class,1,0,0,character,1
+formattable,render_html_matrix,-1,0,0,class<`matrix`>,1
+formattable,render_html_matrix,0,0,0,class<`data.frame`>,1
+formattable,render_html_matrix,1,0,0,...,1
+formattable,render_html_matrix.data.frame,-1,0,0,class<`matrix`>,1
+formattable,render_html_matrix.data.frame,0,0,0,class<`data.frame`>,1
+formattable,render_html_matrix.data.frame,1,0,0,list<class<`formula`>>,1
+formattable,render_html_matrix.data.frame,1,0,1,"list<class<`formatter`, `function`>>",1
+formattable,render_html_matrix.data.frame,1,0,2,list<logical>,1
+formattable,render_html_matrix.data.frame,2,0,0,integer,1
+formattable,render_html_matrix.data.frame,3,0,0,...,1
+formattable,render_html_matrix.formattable,-1,0,0,class<`matrix`>,1
+formattable,render_html_matrix.formattable,0,0,0,"class<`data.frame`, `formattable`>",1
+formattable,render_html_matrix.formattable,1,0,0,...,1
+formattable,reset_class,-1,0,0,"class<`formattable`, `numeric`>",1
+formattable,reset_class,0,0,0,"class<`formattable`, `numeric`>",1
+formattable,reset_class,1,0,0,"class<`formattable`, `numeric`>",1
+formattable,reset_class,2,0,0,character,1
+formattable,scientific,-1,0,0,"class<`formattable`, `numeric`>",1
+formattable,scientific,0,0,0,double,1
+formattable,scientific,1,0,0,character[],1
+formattable,scientific,2,0,0,...,1
+formattable,seq_list,-1,0,0,list<integer>,1
+formattable,seq_list,0,0,0,character[],1
+formattable,set_class,-1,0,0,"class<`array`, `formattable`>",1
+formattable,set_class,-1,0,1,"class<`data.frame`, `formattable`>",1
+formattable,set_class,-1,0,2,"class<`Date`, `formattable`>",1
+formattable,set_class,-1,0,3,"class<`factor`, `formattable`>",1
+formattable,set_class,-1,0,4,"class<`formattable`, `integer`>",1
+formattable,set_class,-1,0,5,"class<`formattable`, `logical`>",1
+formattable,set_class,-1,0,6,"class<`formattable`, `matrix`>",1
+formattable,set_class,-1,0,7,"class<`formattable`, `numeric`>",1
+formattable,set_class,-1,0,8,"class<`POSIXct`, `POSIXt`, `formattable`>",1
+formattable,set_class,0,0,0,class<`array`>,1
+formattable,set_class,0,0,1,class<`data.frame`>,1
+formattable,set_class,0,0,2,class<`Date`>,1
+formattable,set_class,0,0,3,class<`factor`>,1
+formattable,set_class,0,0,4,^integer[],1
+formattable,set_class,0,0,5,class<`matrix`>,1
+formattable,set_class,0,0,6,double[],1
+formattable,set_class,0,0,7,"class<`POSIXct`, `POSIXt`>",1
+formattable,set_class,1,0,0,character,1
+formattable,str2rgb,-1,0,0,class<`matrix`>,1
+formattable,str2rgb,0,0,0,character[],1
+formattable,str2rgb,1,0,0,logical,1
+formattable,str2rgb,1,0,1,null,1
+formattable,style,-1,0,0,character[],1
+formattable,style,0,0,0,...,1
+formattable,suffix,-1,0,0,"class<`formattable`, `integer`>",1
+formattable,suffix,-1,0,1,"class<`formattable`, `numeric`>",1
+formattable,suffix,0,0,0,^integer[],1
+formattable,suffix,0,0,1,"class<`formattable`, `numeric`>",1
+formattable,suffix,0,0,2,double[],1
+formattable,suffix,1,0,0,any,1
+formattable,suffix,2,0,0,character,1
+formattable,suffix,3,0,0,...,1
+formattable,suffix,4,0,0,character,1
+formattable,suffix,4,0,1,null,1
+formattable,vmap,-1,0,0,character[],1
+formattable,vmap,-1,0,1,double[],1
+formattable,vmap,0,0,0,double[],1
+formattable,vmap,0,0,1,character[],1
+formattable,vmap,1,0,0,...,1
+formattable,vmap,2,0,0,logical,1
+formula.tools,as.character.formula,-1,0,0,character,1
+formula.tools,as.character.formula,0,0,0,class<`formula`>,1
+formula.tools,as.character.formula,1,0,0,...,1
+formula.tools,env,-1,0,0,environment,1
+formula.tools,env,0,0,0,class<`formula`>,1
+formula.tools,env.formula,-1,0,0,environment,1
+formula.tools,env.formula,0,0,0,class<`formula`>,1
+formula.tools,get.vars,-1,0,0,character,1
+formula.tools,get.vars,0,0,0,class<`name`>,1
+formula.tools,get.vars,1,0,0,null,1
+formula.tools,get.vars,2,0,0,...,1
+formula.tools,get.vars,-1,1,0,character[],1
+formula.tools,get.vars,0,1,0,class<`call`>,1
+formula.tools,get.vars,1,1,0,null,1
+formula.tools,get.vars,2,1,0,...,1
+formula.tools,get.vars,-1,2,0,character,1
+formula.tools,get.vars,0,2,0,class<`name`>,1
+formula.tools,get.vars,1,2,0,class<`data.frame`>,1
+formula.tools,get.vars,2,2,0,...,1
+formula.tools,get.vars,-1,3,0,any,1
+formula.tools,get.vars,0,3,0,class<`call`>,1
+formula.tools,get.vars,0,3,1,class<`formula`>,1
+formula.tools,get.vars,0,3,2,double,1
+formula.tools,get.vars,0,3,3,null,1
+formula.tools,get.vars,0,3,4,class<`name`>,1
+formula.tools,get.vars,1,3,0,class<`data.frame`>,1
+formula.tools,get.vars,1,3,1,null,1
+formula.tools,get.vars,2,3,0,...,1
+formula.tools,get.vars,-1,4,0,null,1
+formula.tools,get.vars,0,4,0,null,1
+formula.tools,get.vars,1,4,0,null,1
+formula.tools,get.vars,2,4,0,...,1
+formula.tools,get.vars,-1,5,0,any,1
+formula.tools,get.vars,0,5,0,class<`formula`>,1
+formula.tools,get.vars,1,5,0,null,1
+formula.tools,get.vars,2,5,0,...,1
+formula.tools,get.vars,-1,6,0,character[],1
+formula.tools,get.vars,0,6,0,class<`call`>,1
+formula.tools,get.vars,1,6,0,class<`data.frame`>,1
+formula.tools,get.vars,2,6,0,...,1
+formula.tools,get.vars,-1,7,0,character[],1
+formula.tools,get.vars,0,7,0,class<`formula`>,1
+formula.tools,get.vars,1,7,0,class<`data.frame`>,1
+formula.tools,get.vars,2,7,0,...,1
+formula.tools,get.vars,-1,8,0,character[],1
+formula.tools,get.vars,0,8,0,null,1
+formula.tools,get.vars,1,8,0,null,1
+formula.tools,get.vars,2,8,0,...,1
+formula.tools,get.vars,-1,9,0,character[],1
+formula.tools,get.vars,0,9,0,double,1
+formula.tools,get.vars,1,9,0,null,1
+formula.tools,get.vars,2,9,0,...,1
+formula.tools,invert,-1,0,0,class<`call`>,1
+formula.tools,invert,0,0,0,class<`call`>,1
+formula.tools,invert,1,0,0,...,1
+formula.tools,invert,-1,1,0,class<`call`>,1
+formula.tools,invert,0,1,0,class<`call`>,1
+formula.tools,invert,1,1,0,...,1
+formula.tools,is.one.sided,-1,0,0,logical,1
+formula.tools,is.one.sided,0,0,0,class<`call`>,1
+formula.tools,is.one.sided,1,0,0,...,1
+formula.tools,is.one.sided,-1,1,0,logical,1
+formula.tools,is.one.sided,0,1,0,class<`call`>,1
+formula.tools,is.one.sided,0,1,1,class<`formula`>,1
+formula.tools,is.one.sided,1,1,0,...,1
+formula.tools,is.one.sided,-1,2,0,logical,1
+formula.tools,is.one.sided,0,2,0,class<`formula`>,1
+formula.tools,is.one.sided,1,2,0,...,1
+formula.tools,is.two.sided,-1,0,0,logical,1
+formula.tools,is.two.sided,0,0,0,class<`formula`>,1
+formula.tools,is.two.sided,1,0,0,...,1
+formula.tools,is.two.sided,-1,1,0,logical,1
+formula.tools,is.two.sided,0,1,0,class<`call`>,1
+formula.tools,is.two.sided,0,1,1,class<`formula`>,1
+formula.tools,is.two.sided,1,1,0,...,1
+formula.tools,is.two.sided,-1,2,0,logical,1
+formula.tools,is.two.sided,0,2,0,class<`call`>,1
+formula.tools,is.two.sided,1,2,0,...,1
+formula.tools,lhs,-1,0,0,class<`name`>,1
+formula.tools,lhs,0,0,0,class<`<-`>,1
+formula.tools,lhs,1,0,0,...,1
+formula.tools,lhs,-1,1,0,class<`call`>,1
+formula.tools,lhs,-1,1,1,class<`name`>,1
+formula.tools,lhs,-1,1,2,double,1
+formula.tools,lhs,-1,1,3,expression,1
+formula.tools,lhs,-1,1,4,null,1
+formula.tools,lhs,0,1,0,class<`call`>,1
+formula.tools,lhs,0,1,1,class<`formula`>,1
+formula.tools,lhs,0,1,2,class<`<-`>,1
+formula.tools,lhs,0,1,3,expression,1
+formula.tools,lhs,1,1,0,...,1
+formula.tools,lhs,-1,2,0,expression,1
+formula.tools,lhs,0,2,0,expression,1
+formula.tools,lhs,1,2,0,...,1
+formula.tools,lhs,-1,3,0,class<`call`>,1
+formula.tools,lhs,-1,3,1,class<`name`>,1
+formula.tools,lhs,-1,3,2,double,1
+formula.tools,lhs,-1,3,3,null,1
+formula.tools,lhs,0,3,0,class<`formula`>,1
+formula.tools,lhs,1,3,0,...,1
+formula.tools,lhs,-1,4,0,class<`call`>,1
+formula.tools,lhs,-1,4,1,class<`name`>,1
+formula.tools,lhs,-1,4,2,double,1
+formula.tools,lhs,-1,4,3,null,1
+formula.tools,lhs,0,4,0,class<`call`>,1
+formula.tools,lhs,1,4,0,...,1
+formula.tools,lhs<-,-1,0,0,class<`formula`>,1
+formula.tools,lhs<-,0,0,0,class<`formula`>,1
+formula.tools,lhs<-,1,0,0,class<`call`>,1
+formula.tools,lhs<-,1,0,1,class<`name`>,1
+formula.tools,lhs<-,-1,1,0,class<`call`>,1
+formula.tools,lhs<-,0,1,0,class<`call`>,1
+formula.tools,lhs<-,1,1,0,class<`name`>,1
+formula.tools,lhs<-,-1,2,0,class<`call`>,1
+formula.tools,lhs<-,-1,2,1,class<`formula`>,1
+formula.tools,lhs<-,0,2,0,class<`call`>,1
+formula.tools,lhs<-,0,2,1,class<`formula`>,1
+formula.tools,lhs<-,1,2,0,class<`name`>,1
+formula.tools,lhs<-,1,2,1,class<`call`>,1
+formula.tools,lhs.vars,-1,0,0,character[],1
+formula.tools,lhs.vars,-1,0,1,null,1
+formula.tools,lhs.vars,0,0,0,class<`formula`>,1
+formula.tools,lhs.vars,1,0,0,...,1
+formula.tools,lhs.vars,-1,1,0,character[],1
+formula.tools,lhs.vars,-1,1,1,null,1
+formula.tools,lhs.vars,0,1,0,class<`formula`>,1
+formula.tools,lhs.vars,1,1,0,...,1
+formula.tools,op,-1,0,0,class<`name`>,1
+formula.tools,op,0,0,0,class<`call`>,1
+formula.tools,op,-1,1,0,class<`name`>,1
+formula.tools,op,0,1,0,class<`formula`>,1
+formula.tools,op,-1,2,0,class<`name`>,1
+formula.tools,op,0,2,0,class<`<-`>,1
+formula.tools,op,-1,3,0,class<`name`>,1
+formula.tools,op,-1,3,1,expression,1
+formula.tools,op,-1,3,2,null,1
+formula.tools,op,0,3,0,class<`<-`>,1
+formula.tools,op,0,3,1,class<`call`>,1
+formula.tools,op,0,3,2,class<`formula`>,1
+formula.tools,op,0,3,3,expression,1
+formula.tools,op,0,3,4,class<`name`>,1
+formula.tools,op,-1,4,0,expression,1
+formula.tools,op,0,4,0,expression,1
+formula.tools,op,-1,5,0,null,1
+formula.tools,op,0,5,0,class<`name`>,1
+formula.tools,op<-,-1,0,0,class<`call`>,1
+formula.tools,op<-,0,0,0,class<`call`>,1
+formula.tools,op<-,1,0,0,class<`name`>,1
+formula.tools,op<-,-1,1,0,class<`call`>,1
+formula.tools,op<-,0,1,0,class<`call`>,1
+formula.tools,op<-,1,1,0,class<`name`>,1
+formula.tools,op.type,-1,0,0,list<character>,1
+formula.tools,op.type,0,0,0,expression,1
+formula.tools,op.type,-1,1,0,character,1
+formula.tools,op.type,0,1,0,class<`call`>,1
+formula.tools,op.type,-1,2,0,character,1
+formula.tools,op.type,-1,2,1,list<character>,1
+formula.tools,op.type,0,2,0,class<`<-`>,1
+formula.tools,op.type,0,2,1,class<`call`>,1
+formula.tools,op.type,0,2,2,class<`formula`>,1
+formula.tools,op.type,0,2,3,expression,1
+formula.tools,op.type,-1,3,0,character,1
+formula.tools,op.type,0,3,0,class<`formula`>,1
+formula.tools,op.type,-1,4,0,character,1
+formula.tools,op.type,0,4,0,class<`<-`>,1
+formula.tools,rhs,-1,0,0,class<`call`>,1
+formula.tools,rhs,-1,0,1,class<`name`>,1
+formula.tools,rhs,-1,0,2,double,1
+formula.tools,rhs,-1,0,3,null,1
+formula.tools,rhs,0,0,0,class<`formula`>,1
+formula.tools,rhs,1,0,0,...,1
+formula.tools,rhs,-1,1,0,class<`name`>,1
+formula.tools,rhs,0,1,0,class<`<-`>,1
+formula.tools,rhs,1,1,0,...,1
+formula.tools,rhs,-1,2,0,class<`call`>,1
+formula.tools,rhs,-1,2,1,class<`name`>,1
+formula.tools,rhs,-1,2,2,double,1
+formula.tools,rhs,-1,2,3,null,1
+formula.tools,rhs,0,2,0,class<`call`>,1
+formula.tools,rhs,1,2,0,...,1
+formula.tools,rhs,-1,3,0,class<`call`>,1
+formula.tools,rhs,-1,3,1,class<`name`>,1
+formula.tools,rhs,-1,3,2,double,1
+formula.tools,rhs,-1,3,3,expression,1
+formula.tools,rhs,-1,3,4,null,1
+formula.tools,rhs,0,3,0,class<`call`>,1
+formula.tools,rhs,0,3,1,class<`formula`>,1
+formula.tools,rhs,0,3,2,class<`<-`>,1
+formula.tools,rhs,0,3,3,expression,1
+formula.tools,rhs,1,3,0,...,1
+formula.tools,rhs,-1,4,0,expression,1
+formula.tools,rhs,0,4,0,expression,1
+formula.tools,rhs,1,4,0,...,1
+formula.tools,rhs<-,-1,0,0,class<`formula`>,1
+formula.tools,rhs<-,0,0,0,class<`formula`>,1
+formula.tools,rhs<-,1,0,0,class<`call`>,1
+formula.tools,rhs<-,-1,1,0,class<`formula`>,1
+formula.tools,rhs<-,0,1,0,class<`formula`>,1
+formula.tools,rhs<-,1,1,0,class<`call`>,1
+formula.tools,rhs.vars,-1,0,0,any,1
+formula.tools,rhs.vars,0,0,0,class<`formula`>,1
+formula.tools,rhs.vars,1,0,0,...,1
+formula.tools,rhs.vars,-1,1,0,any,1
+formula.tools,rhs.vars,0,1,0,class<`formula`>,1
+formula.tools,rhs.vars,1,1,0,...,1
+formula.tools,split_terms,-1,0,0,expression,1
+formula.tools,split_terms,0,0,0,class<`call`>,1
+formula.tools,split_terms,0,0,1,class<`name`>,1
+formula.tools,split_terms,0,0,2,double,1
+formula.tools,split_terms,1,0,0,logical,1
+formula.tools,split_terms.default,-1,0,0,expression,1
+formula.tools,split_terms.default,0,0,0,class<`call`>,1
+formula.tools,split_terms.default,0,0,1,double,1
+formula.tools,split_terms.default,0,0,2,class<`name`>,1
+formula.tools,split_terms.default,1,0,0,logical,1
+formula.tools,split_terms.name,-1,0,0,expression,1
+formula.tools,split_terms.name,0,0,0,class<`call`>,1
+formula.tools,split_terms.name,0,0,1,double,1
+formula.tools,split_terms.name,0,0,2,class<`name`>,1
+formula.tools,split_terms.name,1,0,0,logical,1
+formula.tools,terms.call,-1,0,0,character[],1
+formula.tools,terms.call,0,0,0,class<`call`>,1
+formula.tools,terms.call,1,0,0,...,1
+formula.tools,toggle.sign,-1,0,0,class<`call`>,1
+formula.tools,toggle.sign,-1,0,1,class<`name`>,1
+formula.tools,toggle.sign,-1,0,2,expression,1
+formula.tools,toggle.sign,-1,0,3,integer[],1
+formula.tools,toggle.sign,0,0,0,class<`name`>,1
+formula.tools,toggle.sign,0,0,1,class<`call`>,1
+formula.tools,toggle.sign,0,0,2,expression,1
+formula.tools,toggle.sign,0,0,3,integer[],1
+formula.tools,toggle.sign.call,-1,0,0,class<`name`>,1
+formula.tools,toggle.sign.call,-1,0,1,class<`call`>,1
+formula.tools,toggle.sign.call,0,0,0,class<`call`>,1
+formula.tools,toggle.sign.call,0,0,1,class<`name`>,1
+formula.tools,toggle.sign.default,-1,0,0,integer[],1
+formula.tools,toggle.sign.default,0,0,0,integer[],1
+formula.tools,toggle.sign.expression,-1,0,0,expression,1
+formula.tools,toggle.sign.expression,0,0,0,expression,1
+formula.tools,toggle.sign.name,-1,0,0,class<`name`>,1
+formula.tools,toggle.sign.name,-1,0,1,class<`call`>,1
+formula.tools,toggle.sign.name,0,0,0,class<`call`>,1
+formula.tools,toggle.sign.name,0,0,1,class<`name`>,1
+fpCompare,%<<%,-1,0,0,logical[],1
+fpCompare,%<<%,0,0,0,double[],1
+fpCompare,%<<%,1,0,0,integer[],1
+fpCompare,%<=%,-1,0,0,logical[],1
+fpCompare,%<=%,0,0,0,double[],1
+fpCompare,%<=%,1,0,0,integer[],1
+fpCompare,%==%,-1,0,0,logical[],1
+fpCompare,%==%,0,0,0,double[],1
+fpCompare,%==%,1,0,0,integer[],1
+fpCompare,%==%,1,0,1,double,1
+fpCompare,%>=%,-1,0,0,logical[],1
+fpCompare,%>=%,0,0,0,double[],1
+fpCompare,%>=%,1,0,0,integer[],1
+fpCompare,%>>%,-1,0,0,logical[],1
+fpCompare,%>>%,0,0,0,double[],1
+fpCompare,%>>%,1,0,0,integer[],1
+fpCompare,%!=%,-1,0,0,logical[],1
+fpCompare,%!=%,0,0,0,double[],1
+fpCompare,%!=%,1,0,0,integer[],1
+fpc,adcoord,-1,0,0,list<double[] | class<`matrix`>>,1
+fpc,adcoord,0,0,0,class<`matrix`>,1
+fpc,adcoord,1,0,0,logical[],1
+fpc,adcoord,2,0,0,double,1
+fpc,ancoord,-1,0,0,list<double[] | class<`matrix`>>,1
+fpc,ancoord,0,0,0,class<`matrix`>,1
+fpc,ancoord,1,0,0,integer[],1
+fpc,ancoord,2,0,0,double,1
+fpc,ancoord,3,0,0,double,1
+fpc,ancoord,4,0,0,character,1
+fpc,ancoord,5,0,0,double,1
+fpc,ancoord,6,0,0,...,1
+fpc,awcoord,-1,0,0,list<double[] | class<`matrix`>>,1
+fpc,awcoord,0,0,0,class<`matrix`>,1
+fpc,awcoord,1,0,0,integer[],1
+fpc,awcoord,2,0,0,double,1
+fpc,awcoord,3,0,0,character,1
+fpc,awcoord,4,0,0,character,1
+fpc,awcoord,5,0,0,logical,1
+fpc,awcoord,6,0,0,double,1
+fpc,awcoord,7,0,0,double,1
+fpc,batcoord,-1,0,0,list<double[] | class<`matrix`>>,1
+fpc,batcoord,0,0,0,class<`matrix`>,1
+fpc,batcoord,1,0,0,integer[],1
+fpc,batcoord,2,0,0,double,1
+fpc,batcoord,3,0,0,character,1
+fpc,batvarcoord,-1,0,0,list<double[] | class<`matrix`>>,1
+fpc,batvarcoord,0,0,0,class<`matrix`>,1
+fpc,batvarcoord,1,0,0,integer[],1
+fpc,batvarcoord,2,0,0,double,1
+fpc,bhattacharyya.dist,-1,0,0,double,1
+fpc,bhattacharyya.dist,0,0,0,double[],1
+fpc,bhattacharyya.dist,1,0,0,double[],1
+fpc,bhattacharyya.dist,2,0,0,class<`matrix`>,1
+fpc,bhattacharyya.dist,3,0,0,class<`matrix`>,1
+fpc,bhattacharyya.matrix,-1,0,0,class<`matrix`>,1
+fpc,bhattacharyya.matrix,0,0,0,class<`matrix`>,1
+fpc,bhattacharyya.matrix,1,0,0,class<`array`>,1
+fpc,bhattacharyya.matrix,2,0,0,list<double[]>,1
+fpc,bhattacharyya.matrix,2,0,1,character,1
+fpc,bhattacharyya.matrix,3,0,0,logical,1
+fpc,calinhara,-1,0,0,double,1
+fpc,calinhara,0,0,0,class<`data.frame`>,1
+fpc,calinhara,0,0,1,class<`matrix`>,1
+fpc,calinhara,1,0,0,integer[],1
+fpc,calinhara,2,0,0,integer,1
+fpc,can,-1,0,0,double,1
+fpc,can,0,0,0,double,1
+fpc,can,1,0,0,double,1
+fpc,cat2bin,-1,0,0,list<class<`matrix`> | list<list<character[] | integer[] | character | double>>>,1
+fpc,cat2bin,-1,0,1,list<class<`matrix`> | list<list<character | double | character[] | integer[]>>>,1
+fpc,cat2bin,0,0,0,class<`matrix`>,1
+fpc,cat2bin,1,0,0,double,1
+fpc,cat2bin,1,0,1,integer[],1
+fpc,cdbw,-1,0,0,list<double>,1
+fpc,cdbw,0,0,0,class<`matrix`>,1
+fpc,cdbw,1,0,0,double[],1
+fpc,cdbw,2,0,0,double,1
+fpc,cdbw,3,0,0,double[],1
+fpc,cdbw,4,0,0,logical,1
+fpc,cdbw,5,0,0,logical,1
+fpc,cgrestandard,-1,0,0,class<`valstat`>,1
+fpc,cgrestandard,0,0,0,class<`valstat`>,1
+fpc,cgrestandard,0,0,1,list<double | character[] | list<null | list<double>>>,1
+fpc,cgrestandard,1,0,0,list<double | list<null | class<`data.frame`>>>,1
+fpc,cgrestandard,2,0,0,integer[],1
+fpc,cgrestandard,2,0,1,double,1
+fpc,cgrestandard,3,0,0,logical,1
+fpc,cgrestandard,4,0,0,logical,1
+fpc,cgrestandard,5,0,0,logical,1
+fpc,cgrestandard,6,0,0,list<any>,1
+fpc,claraCBI,-1,0,0,list<any>,1
+fpc,claraCBI,0,0,0,class<`matrix`>,1
+fpc,claraCBI,1,0,0,double,1
+fpc,claraCBI,2,0,0,logical,1
+fpc,claraCBI,3,0,0,logical,1
+fpc,claraCBI,4,0,0,...,1
+fpc,classifdist,-1,0,0,double[],1
+fpc,classifdist,0,0,0,class<`dist`>,1
+fpc,classifdist,0,0,1,class<`matrix`>,1
+fpc,classifdist,1,0,0,double[],1
+fpc,classifdist,2,0,0,character,1
+fpc,classifdist,3,0,0,any,1
+fpc,classifdist,4,0,0,any,1
+fpc,classifnp,-1,0,0,double[],1
+fpc,classifnp,0,0,0,class<`matrix`>,1
+fpc,classifnp,1,0,0,double[],1
+fpc,classifnp,2,0,0,character,1
+fpc,classifnp,3,0,0,null,1
+fpc,classifnp,4,0,0,any,1
+fpc,classifnp,5,0,0,any,1
+fpc,clucols,-1,0,0,character[],1
+fpc,clucols,0,0,0,double,1
+fpc,clucols,1,0,0,null,1
+fpc,clujaccard,-1,0,0,double,1
+fpc,clujaccard,0,0,0,logical[],1
+fpc,clujaccard,1,0,0,logical[],1
+fpc,clujaccard,2,0,0,double,1
+fpc,clujaccard,2,0,1,null,1
+fpc,clusexpect,-1,0,0,double,1
+fpc,clusexpect,0,0,0,double,1
+fpc,clusexpect,1,0,0,double,1
+fpc,clusexpect,2,0,0,double,1
+fpc,clusexpect,3,0,0,double,1
+fpc,clustatsum,-1,0,0,list<double>,1
+fpc,clustatsum,0,0,0,class<`dist`>,1
+fpc,clustatsum,1,0,0,double[],1
+fpc,clustatsum,2,0,0,any,1
+fpc,clustatsum,3,0,0,any,1
+fpc,clustatsum,4,0,0,logical,1
+fpc,clustatsum,5,0,0,double,1
+fpc,clustatsum,6,0,0,logical,1
+fpc,clustatsum,7,0,0,...,1
+fpc,clusterbenchstats,-1,0,0,class<`clusterbenchstats`>,1
+fpc,clusterbenchstats,0,0,0,class<`matrix`>,1
+fpc,clusterbenchstats,0,0,1,double[],1
+fpc,clusterbenchstats,1,0,0,integer[],1
+fpc,clusterbenchstats,1,0,1,double,1
+fpc,clusterbenchstats,2,0,0,logical,1
+fpc,clusterbenchstats,3,0,0,logical,1
+fpc,clusterbenchstats,4,0,0,character[],1
+fpc,clusterbenchstats,5,0,0,character[],1
+fpc,clusterbenchstats,6,0,0,logical[],1
+fpc,clusterbenchstats,7,0,0,logical[],1
+fpc,clusterboot,-1,0,0,class<`clboot`>,1
+fpc,clusterboot,0,0,0,class<`data.frame`>,1
+fpc,clusterboot,0,0,1,class<`dist`>,1
+fpc,clusterboot,0,0,2,class<`matrix`>,1
+fpc,clusterboot,1,0,0,double,1
+fpc,clusterboot,2,0,0,logical,1
+fpc,clusterboot,3,0,0,character[],1
+fpc,clusterboot,4,0,0,logical,1
+fpc,clusterboot,5,0,0,logical,1
+fpc,clusterboot,6,0,0,double,1
+fpc,clusterboot,7,0,0,any,1
+fpc,cluster.magazine,-1,0,0,list<list<any>>,1
+fpc,cluster.magazine,0,0,0,double[],1
+fpc,cluster.magazine,0,0,1,class<`matrix`>,1
+fpc,cluster.magazine,1,0,0,double,1
+fpc,cluster.magazine,1,0,1,integer[],1
+fpc,cluster.magazine,2,0,0,logical,1
+fpc,cluster.magazine,3,0,0,logical,1
+fpc,cluster.magazine,4,0,0,character[],1
+fpc,cluster.magazine,5,0,0,logical[],1
+fpc,cluster.magazine,6,0,0,logical[],1
+fpc,cluster.magazine,7,0,0,list<list<any>>,1
+fpc,cluster.magazine,7,0,1,list<null | list<character>>,1
+fpc,cluster.stats,-1,0,0,list<any>,1
+fpc,cluster.stats,0,0,0,class<`dist`>,1
+fpc,cluster.stats,1,0,0,integer[],1
+fpc,cluster.stats,2,0,0,null,1
+fpc,cluster.stats,2,0,1,integer[],1
+fpc,cluster.stats,3,0,0,logical,1
+fpc,cluster.stats,4,0,0,logical,1
+fpc,cluster.stats,5,0,0,logical,1
+fpc,cluster.stats,6,0,0,logical,1
+fpc,cluster.stats,7,0,0,logical,1
+fpc,cluster.varstats,-1,0,0,class<`varwisetables`>,1
+fpc,cluster.varstats,0,0,0,integer[],1
+fpc,cluster.varstats,1,0,0,class<`data.frame`>,1
+fpc,cluster.varstats,2,0,0,class<`data.frame`>,1
+fpc,cluster.varstats,3,0,0,logical,1
+fpc,cluster.varstats,4,0,0,double[],1
+fpc,cluster.varstats,5,0,0,double[],1
+fpc,cluster.varstats,6,0,0,double[],1
+fpc,cluster.varstats,7,0,0,double,1
+fpc,cmahal,-1,0,0,double[],1
+fpc,cmahal,0,0,0,double,1
+fpc,cmahal,1,0,0,double,1
+fpc,cmahal,2,0,0,double,1
+fpc,cmahal,3,0,0,double,1
+fpc,cmahal,4,0,0,double,1
+fpc,cmahal,5,0,0,double,1
+fpc,cmahal,6,0,0,double,1
+fpc,con.comp,-1,0,0,double[],1
+fpc,con.comp,0,0,0,class<`matrix`>,1
+fpc,confusion,-1,0,0,double,1
+fpc,confusion,0,0,0,class<`matrix`>,1
+fpc,confusion,1,0,0,double[],1
+fpc,confusion,2,0,0,double,1
+fpc,confusion,3,0,0,double,1
+fpc,confusion,4,0,0,logical,1
+fpc,cov.wml,-1,0,0,list<class<`matrix`> | double[]>,1
+fpc,cov.wml,0,0,0,class<`matrix`>,1
+fpc,cov.wml,1,0,0,double[],1
+fpc,cov.wml,2,0,0,logical,1
+fpc,cov.wml,3,0,0,logical,1
+fpc,cqcluster.stats,-1,0,0,class<`cquality`>,1
+fpc,cqcluster.stats,0,0,0,class<`dist`>,1
+fpc,cqcluster.stats,1,0,0,double[],1
+fpc,cqcluster.stats,2,0,0,null,1
+fpc,cqcluster.stats,2,0,1,integer[],1
+fpc,cqcluster.stats,3,0,0,logical,1
+fpc,cqcluster.stats,4,0,0,logical,1
+fpc,cqcluster.stats,5,0,0,logical,1
+fpc,cqcluster.stats,6,0,0,logical,1
+fpc,cqcluster.stats,7,0,0,logical,1
+fpc,cvnn,-1,0,0,list<double[]>,1
+fpc,cvnn,0,0,0,class<`dist`>,1
+fpc,cvnn,1,0,0,list<double[]>,1
+fpc,cvnn,2,0,0,double,1
+fpc,dbscan,-1,0,0,class<`dbscan`>,1
+fpc,dbscan,0,0,0,class<`dist`>,1
+fpc,dbscan,0,0,1,class<`matrix`>,1
+fpc,dbscan,1,0,0,double,1
+fpc,dbscan,2,0,0,double,1
+fpc,dbscan,3,0,0,logical,1
+fpc,dbscan,4,0,0,character[],1
+fpc,dbscan,5,0,0,logical,1
+fpc,dbscan,6,0,0,logical,1
+fpc,dbscan,7,0,0,null,1
+fpc,dbscanCBI,-1,0,0,list<any>,1
+fpc,dbscanCBI,0,0,0,class<`matrix`>,1
+fpc,dbscanCBI,1,0,0,double,1
+fpc,dbscanCBI,2,0,0,double,1
+fpc,dbscanCBI,3,0,0,logical,1
+fpc,dbscanCBI,4,0,0,...,1
+fpc,dipp.tantrum,-1,0,0,list<double[]>,1
+fpc,dipp.tantrum,0,0,0,double[],1
+fpc,dipp.tantrum,1,0,0,double,1
+fpc,dipp.tantrum,2,0,0,double,1
+fpc,diptest.multi,-1,0,0,double,1
+fpc,diptest.multi,0,0,0,class<`matrix`>,1
+fpc,diptest.multi,1,0,0,double[],1
+fpc,diptest.multi,2,0,0,character,1
+fpc,diptest.multi,3,0,0,double,1
+fpc,discrcoord,-1,0,0,list<double[] | class<`matrix`>>,1
+fpc,discrcoord,0,0,0,class<`matrix`>,1
+fpc,discrcoord,1,0,0,double[],1
+fpc,discrcoord,2,0,0,character,1
+fpc,discrcoord,3,0,0,...,1
+fpc,discrete.recode,-1,0,0,list<class<`matrix`> | double[] | list<character[]>>,1
+fpc,discrete.recode,0,0,0,class<`matrix`>,1
+fpc,discrete.recode,0,0,1,class<`data.frame`>,1
+fpc,discrete.recode,1,0,0,logical,1
+fpc,discrete.recode,2,0,0,double[],1
+fpc,discrete.recode,3,0,0,double[],1
+fpc,discrproj,-1,0,0,list<double[] | class<`matrix`>>,1
+fpc,discrproj,0,0,0,class<`matrix`>,1
+fpc,discrproj,0,0,1,class<`data.frame`>,1
+fpc,discrproj,1,0,0,integer[],1
+fpc,discrproj,2,0,0,character,1
+fpc,discrproj,3,0,0,any,1
+fpc,discrproj,4,0,0,logical,1
+fpc,discrproj,5,0,0,any,1
+fpc,discrproj,6,0,0,...,1
+fpc,distancefactor,-1,0,0,double,1
+fpc,distancefactor,0,0,0,double,1
+fpc,distancefactor,1,0,0,double,1
+fpc,distancefactor,2,0,0,null,1
+fpc,distancefactor,3,0,0,character,1
+fpc,distancefactor,4,0,0,double,1
+fpc,distancefactor,5,0,0,double,1
+fpc,distcritmulti,-1,0,0,list<double[] | list<integer[]>>,1
+fpc,distcritmulti,0,0,0,class<`matrix`>,1
+fpc,distcritmulti,1,0,0,integer[],1
+fpc,distcritmulti,2,0,0,null,1
+fpc,distcritmulti,3,0,0,double,1
+fpc,distcritmulti,4,0,0,character,1
+fpc,distcritmulti,5,0,0,character,1
+fpc,distcritmulti,6,0,0,character,1
+fpc,distcritmulti,7,0,0,logical,1
+fpc,disthclustCBI,-1,0,0,list<any>,1
+fpc,disthclustCBI,0,0,0,class<`dist`>,1
+fpc,disthclustCBI,1,0,0,double,1
+fpc,disthclustCBI,2,0,0,character,1
+fpc,disthclustCBI,3,0,0,character,1
+fpc,disthclustCBI,4,0,0,double,1
+fpc,disthclustCBI,5,0,0,...,1
+fpc,disthclusttreeCBI,-1,0,0,list<any>,1
+fpc,disthclusttreeCBI,0,0,0,class<`dist`>,1
+fpc,disthclusttreeCBI,1,0,0,double,1
+fpc,disthclusttreeCBI,2,0,0,character,1
+fpc,disthclusttreeCBI,3,0,0,...,1
+fpc,distnoisemclustCBI,-1,0,0,list<any>,1
+fpc,distnoisemclustCBI,0,0,0,class<`dist`>,1
+fpc,distnoisemclustCBI,1,0,0,double,1
+fpc,distnoisemclustCBI,2,0,0,null,1
+fpc,distnoisemclustCBI,3,0,0,null,1
+fpc,distnoisemclustCBI,4,0,0,double,1
+fpc,distnoisemclustCBI,5,0,0,null,1
+fpc,distnoisemclustCBI,6,0,0,null,1
+fpc,distnoisemclustCBI,7,0,0,character,1
+fpc,distrsimilarity,-1,0,0,list<double[]>,1
+fpc,distrsimilarity,0,0,0,class<`matrix`>,1
+fpc,distrsimilarity,1,0,0,double[],1
+fpc,distrsimilarity,2,0,0,logical,1
+fpc,distrsimilarity,3,0,0,character[],1
+fpc,distrsimilarity,4,0,0,double,1
+fpc,distrsimilarity,5,0,0,logical,1
+fpc,distrsimilarity,6,0,0,logical,1
+fpc,dridgeline,-1,0,0,double[],1
+fpc,dridgeline,0,0,0,double[],1
+fpc,dridgeline,1,0,0,double,1
+fpc,dridgeline,2,0,0,double[],1
+fpc,dridgeline,3,0,0,double[],1
+fpc,dridgeline,4,0,0,class<`matrix`>,1
+fpc,dridgeline,5,0,0,class<`matrix`>,1
+fpc,dridgeline,6,0,0,logical,1
+fpc,dridgeline,7,0,0,...,1
+fpc,dudahart2,-1,0,0,list<double>,1
+fpc,dudahart2,0,0,0,class<`data.frame`>,1
+fpc,dudahart2,0,0,1,class<`matrix`>,1
+fpc,dudahart2,1,0,0,integer[],1
+fpc,dudahart2,2,0,0,double,1
+fpc,extract.mixturepars,-1,0,0,list<double[] | class<`matrix`> | list<any>>,1
+fpc,extract.mixturepars,-1,0,1,list<double[] | list<character | integer | class<`matrix`>>>,1
+fpc,extract.mixturepars,-1,0,2,list<double[] | list<character | class<`matrix`> | double[]>>,1
+fpc,extract.mixturepars,0,0,0,class<`summary.mclustBIC`>,1
+fpc,extract.mixturepars,1,0,0,integer[],1
+fpc,extract.mixturepars,1,0,1,double,1
+fpc,extract.mixturepars,2,0,0,logical,1
+fpc,findrep,-1,0,0,list<integer[] | double>,1
+fpc,findrep,0,0,0,class<`matrix`>,1
+fpc,findrep,1,0,0,double[],1
+fpc,findrep,2,0,0,double[],1
+fpc,findrep,3,0,0,double,1
+fpc,findrep,4,0,0,double,1
+fpc,findrep,5,0,0,integer,1
+fpc,findrep,6,0,0,integer,1
+fpc,findrep,7,0,0,double,1
+fpc,fixmahal,-1,0,0,class<`mfpc`>,1
+fpc,fixmahal,0,0,0,class<`matrix`>,1
+fpc,fixmahal,0,0,1,double[],1
+fpc,fixmahal,1,0,0,integer,1
+fpc,fixmahal,2,0,0,integer,1
+fpc,fixmahal,3,0,0,character,1
+fpc,fixmahal,4,0,0,character,1
+fpc,fixmahal,5,0,0,null,1
+fpc,fixmahal,6,0,0,null,1
+fpc,fixmahal,7,0,0,double,1
+fpc,fixreg,-1,0,0,class<`rfpc`>,1
+fpc,fixreg,0,0,0,double[],1
+fpc,fixreg,1,0,0,double[],1
+fpc,fixreg,2,0,0,integer,1
+fpc,fixreg,3,0,0,integer,1
+fpc,fixreg,4,0,0,null,1
+fpc,fixreg,5,0,0,null,1
+fpc,fixreg,6,0,0,double,1
+fpc,fixreg,7,0,0,double,1
+fpc,flexmixedruns,-1,0,0,list<any>,1
+fpc,flexmixedruns,0,0,0,class<`matrix`>,1
+fpc,flexmixedruns,1,0,0,logical,1
+fpc,flexmixedruns,2,0,0,logical,1
+fpc,flexmixedruns,3,0,0,double,1
+fpc,flexmixedruns,4,0,0,double,1
+fpc,flexmixedruns,5,0,0,null,1
+fpc,flexmixedruns,6,0,0,double[],1
+fpc,flexmixedruns,7,0,0,double,1
+fpc,fpclusters,-1,0,0,list<double[]>,1
+fpc,fpclusters,0,0,0,class<`mfpc`>,1
+fpc,fpclusters,1,0,0,...,1
+fpc,fpclusters.mfpc,-1,0,0,list<double[]>,1
+fpc,fpclusters.mfpc,0,0,0,class<`mfpc`>,1
+fpc,fpclusters.mfpc,1,0,0,any,1
+fpc,fpclusters.mfpc,2,0,0,any,1
+fpc,fpclusters.mfpc,3,0,0,any,1
+fpc,fpclusters.mfpc,4,0,0,...,1
+fpc,fpmi,-1,0,0,list<double[] | class<`matrix`> | character>,1
+fpc,fpmi,-1,0,1,list<class<`matrix`> | double[] | character>,1
+fpc,fpmi,0,0,0,class<`matrix`>,1
+fpc,fpmi,1,0,0,integer,1
+fpc,fpmi,2,0,0,any,1
+fpc,fpmi,3,0,0,double[],1
+fpc,fpmi,4,0,0,double,1
+fpc,fpmi,5,0,0,double,1
+fpc,fpmi,6,0,0,character,1
+fpc,fpmi,7,0,0,character,1
+fpc,hclusttreeCBI,-1,0,0,list<any>,1
+fpc,hclusttreeCBI,0,0,0,class<`matrix`>,1
+fpc,hclusttreeCBI,1,0,0,double,1
+fpc,hclusttreeCBI,2,0,0,character,1
+fpc,hclusttreeCBI,3,0,0,logical,1
+fpc,hclusttreeCBI,4,0,0,...,1
+fpc,itnumber,-1,0,0,double,1
+fpc,itnumber,0,0,0,double,1
+fpc,itnumber,1,0,0,double,1
+fpc,itnumber,2,0,0,double,1
+fpc,itnumber,3,0,0,double,1
+fpc,itnumber,4,0,0,double,1
+fpc,itnumber,5,0,0,double,1
+fpc,jittervar,-1,0,0,class<`matrix`>,1
+fpc,jittervar,0,0,0,class<`matrix`>,1
+fpc,jittervar,1,0,0,integer[],1
+fpc,jittervar,2,0,0,double,1
+fpc,kmeansCBI,-1,0,0,list<any>,1
+fpc,kmeansCBI,0,0,0,class<`matrix`>,1
+fpc,kmeansCBI,1,0,0,double,1
+fpc,kmeansCBI,2,0,0,null,1
+fpc,kmeansCBI,3,0,0,logical,1
+fpc,kmeansCBI,4,0,0,double,1
+fpc,kmeansCBI,5,0,0,character,1
+fpc,kmeansCBI,6,0,0,...,1
+fpc,kmeansruns,-1,0,0,class<`kmeans`>,1
+fpc,kmeansruns,0,0,0,class<`matrix`>,1
+fpc,kmeansruns,1,0,0,double,1
+fpc,kmeansruns,1,0,1,integer[],1
+fpc,kmeansruns,2,0,0,character,1
+fpc,kmeansruns,3,0,0,double,1
+fpc,kmeansruns,4,0,0,double,1
+fpc,kmeansruns,5,0,0,logical,1
+fpc,kmeansruns,6,0,0,double,1
+fpc,kmeansruns,7,0,0,logical,1
+fpc,lcmixed,-1,0,0,class<`FLXMC`>,1
+fpc,lcmixed,0,0,0,class<`formula`>,1
+fpc,lcmixed,1,0,0,any,1
+fpc,lcmixed,2,0,0,any,1
+fpc,lcmixed,3,0,0,any,1
+fpc,lcmixed,4,0,0,any,1
+fpc,lcmixed,5,0,0,logical,1
+fpc,lcmixed,6,0,0,logical,1
+fpc,localshape,-1,0,0,class<`matrix`>,1
+fpc,localshape,0,0,0,class<`data.frame`>,1
+fpc,localshape,1,0,0,double,1
+fpc,localshape,2,0,0,character,1
+fpc,localshape,3,0,0,double,1
+fpc,localshape,4,0,0,character,1
+fpc,mahalanodisc,-1,0,0,double[],1
+fpc,mahalanodisc,0,0,0,class<`matrix`>,1
+fpc,mahalanodisc,1,0,0,double[],1
+fpc,mahalanodisc,2,0,0,class<`matrix`>,1
+fpc,mahalanodisc,3,0,0,character,1
+fpc,mahalanofix,-1,0,0,list<double[] | class<`matrix`>>,1
+fpc,mahalanofix,0,0,0,class<`matrix`>,1
+fpc,mahalanofix,1,0,0,any,1
+fpc,mahalanofix,2,0,0,integer,1
+fpc,mahalanofix,3,0,0,double[],1
+fpc,mahalanofix,4,0,0,double,1
+fpc,mahalanofix,5,0,0,character,1
+fpc,mahalanofuz,-1,0,0,list<double[] | class<`matrix`>>,1
+fpc,mahalanofuz,0,0,0,class<`matrix`>,1
+fpc,mahalanofuz,1,0,0,any,1
+fpc,mahalanofuz,2,0,0,any,1
+fpc,mahalanofuz,3,0,0,double[],1
+fpc,mahalanofuz,4,0,0,double,1
+fpc,mahalCBI,-1,0,0,list<any>,1
+fpc,mahalCBI,0,0,0,class<`matrix`>,1
+fpc,mahalCBI,1,0,0,double,1
+fpc,mahalCBI,2,0,0,...,1
+fpc,mahalconf,-1,0,0,logical[],1
+fpc,mahalconf,0,0,0,class<`matrix`>,1
+fpc,mahalconf,1,0,0,integer,1
+fpc,mahalconf,2,0,0,double,1
+fpc,mahalconf,3,0,0,class<`matrix`>,1
+fpc,mahalconf,4,0,0,character,1
+fpc,mergenormals,-1,0,0,class<`mergenorm`>,1
+fpc,mergenormals,0,0,0,any,1
+fpc,mergenormals,1,0,0,class<`summary.mclustBIC`>,1
+fpc,mergenormals,2,0,0,any,1
+fpc,mergenormals,3,0,0,any,1
+fpc,mergenormals,4,0,0,any,1
+fpc,mergenormals,5,0,0,any,1
+fpc,mergenormals,6,0,0,any,1
+fpc,mergenormals,7,0,0,character,1
+fpc,mergenormCBI,-1,0,0,list<any>,1
+fpc,mergenormCBI,0,0,0,class<`matrix`>,1
+fpc,mergenormCBI,1,0,0,double,1
+fpc,mergenormCBI,2,0,0,null,1
+fpc,mergenormCBI,3,0,0,character,1
+fpc,mergenormCBI,4,0,0,double,1
+fpc,mergenormCBI,5,0,0,null,1
+fpc,mergenormCBI,6,0,0,null,1
+fpc,mergenormCBI,7,0,0,character,1
+fpc,mergeparameters,-1,0,0,list<double[] | class<`matrix`> | class<`array`>>,1
+fpc,mergeparameters,0,0,0,class<`data.frame`>,1
+fpc,mergeparameters,0,0,1,class<`matrix`>,1
+fpc,mergeparameters,1,0,0,double,1
+fpc,mergeparameters,2,0,0,double,1
+fpc,mergeparameters,3,0,0,double[],1
+fpc,mergeparameters,4,0,0,class<`matrix`>,1
+fpc,mergeparameters,5,0,0,class<`array`>,1
+fpc,mergeparameters,6,0,0,class<`matrix`>,1
+fpc,minsize,-1,0,0,double,1
+fpc,minsize,0,0,0,double,1
+fpc,minsize,1,0,0,double,1
+fpc,minsize,2,0,0,double,1
+fpc,minsize,3,0,0,double,1
+fpc,minsize,4,0,0,double,1
+fpc,mixdens,-1,0,0,double[],1
+fpc,mixdens,0,0,0,character,1
+fpc,mixdens,1,0,0,class<`matrix`>,1
+fpc,mixdens,1,0,1,class<`data.frame`>,1
+fpc,mixdens,2,0,0,list<any>,1
+fpc,mixpredictive,-1,0,0,list<double[]>,1
+fpc,mixpredictive,0,0,0,class<`data.frame`>,1
+fpc,mixpredictive,1,0,0,double,1
+fpc,mixpredictive,2,0,0,double,1
+fpc,mixpredictive,3,0,0,double,1
+fpc,mixpredictive,4,0,0,...,1
+fpc,mvdcoord,-1,0,0,list<double[] | class<`matrix`>>,1
+fpc,mvdcoord,0,0,0,class<`matrix`>,1
+fpc,mvdcoord,1,0,0,integer[],1
+fpc,mvdcoord,2,0,0,double,1
+fpc,mvdcoord,3,0,0,character,1
+fpc,mvdcoord,4,0,0,...,1
+fpc,ncoord,-1,0,0,list<double[] | class<`matrix`>>,1
+fpc,ncoord,0,0,0,class<`matrix`>,1
+fpc,ncoord,1,0,0,integer[],1
+fpc,ncoord,2,0,0,double,1
+fpc,ncoord,3,0,0,logical,1
+fpc,ncoord,4,0,0,character,1
+fpc,ncoord,5,0,0,logical,1
+fpc,ncoord,6,0,0,double,1
+fpc,ncoord,7,0,0,...,1
+fpc,neginc,-1,0,0,double,1
+fpc,neginc,0,0,0,class<`matrix`>,1
+fpc,neginc,1,0,0,double[],1
+fpc,noisemclustCBI,-1,0,0,list<any>,1
+fpc,noisemclustCBI,0,0,0,class<`matrix`>,1
+fpc,noisemclustCBI,1,0,0,integer[],1
+fpc,noisemclustCBI,2,0,0,null,1
+fpc,noisemclustCBI,3,0,0,null,1
+fpc,noisemclustCBI,4,0,0,double,1
+fpc,noisemclustCBI,5,0,0,null,1
+fpc,noisemclustCBI,6,0,0,null,1
+fpc,noisemclustCBI,7,0,0,logical,1
+fpc,nselectboot,-1,0,0,list<^double[] | class<`matrix`>>,1
+fpc,nselectboot,0,0,0,class<`dist`>,1
+fpc,nselectboot,0,0,1,class<`matrix`>,1
+fpc,nselectboot,1,0,0,double,1
+fpc,nselectboot,2,0,0,logical,1
+fpc,nselectboot,3,0,0,class<`function`>,1
+fpc,nselectboot,4,0,0,character,1
+fpc,nselectboot,5,0,0,integer[],1
+fpc,nselectboot,6,0,0,logical,1
+fpc,nselectboot,7,0,0,double,1
+fpc,pamk,-1,0,0,"list<class<`clara`, `partition`> | double[]>",1
+fpc,pamk,-1,0,1,"list<class<`pam`, `partition`> | double[]>",1
+fpc,pamk,0,0,0,class<`matrix`>,1
+fpc,pamk,0,0,1,class<`dist`>,1
+fpc,pamk,1,0,0,integer[],1
+fpc,pamk,2,0,0,character,1
+fpc,pamk,3,0,0,logical,1
+fpc,pamk,4,0,0,logical,1
+fpc,pamk,5,0,0,double,1
+fpc,pamk,6,0,0,logical,1
+fpc,pamk,7,0,0,logical,1
+fpc,piridge,-1,0,0,double[],1
+fpc,piridge,0,0,0,double[],1
+fpc,piridge,1,0,0,double[],1
+fpc,piridge,2,0,0,double[],1
+fpc,piridge,3,0,0,class<`matrix`>,1
+fpc,piridge,4,0,0,class<`matrix`>,1
+fpc,piridge,5,0,0,logical,1
+fpc,piridge.zeroes,-1,0,0,list<double[]>,1
+fpc,piridge.zeroes,0,0,0,double,1
+fpc,piridge.zeroes,1,0,0,double[],1
+fpc,piridge.zeroes,2,0,0,double[],1
+fpc,piridge.zeroes,3,0,0,class<`matrix`>,1
+fpc,piridge.zeroes,4,0,0,class<`matrix`>,1
+fpc,piridge.zeroes,5,0,0,double,1
+fpc,piridge.zeroes,6,0,0,double,1
+fpc,piridge.zeroes,7,0,0,double,1
+fpc,plot.clboot,-1,0,0,null,1
+fpc,plot.clboot,0,0,0,class<`clboot`>,1
+fpc,plot.clboot,1,0,0,double[],1
+fpc,plot.clboot,2,0,0,double[],1
+fpc,plot.clboot,3,0,0,...,1
+fpc,plotcluster,-1,0,0,null,1
+fpc,plotcluster,0,0,0,class<`matrix`>,1
+fpc,plotcluster,1,0,0,integer[],1
+fpc,plotcluster,2,0,0,double,1
+fpc,plotcluster,2,0,1,null,1
+fpc,plotcluster,3,0,0,character,1
+fpc,plotcluster,4,0,0,logical,1
+fpc,plotcluster,5,0,0,logical,1
+fpc,plotcluster,6,0,0,double,1
+fpc,plotcluster,7,0,0,logical,1
+fpc,plot.dbscan,-1,0,0,null,1
+fpc,plot.dbscan,0,0,0,class<`dbscan`>,1
+fpc,plot.dbscan,1,0,0,class<`matrix`>,1
+fpc,plot.dbscan,2,0,0,...,1
+fpc,plot.mfpc,-1,0,0,null,1
+fpc,plot.mfpc,0,0,0,class<`mfpc`>,1
+fpc,plot.mfpc,1,0,0,class<`matrix`>,1
+fpc,plot.mfpc,2,0,0,double,1
+fpc,plot.mfpc,3,0,0,logical,1
+fpc,plot.mfpc,4,0,0,character[],1
+fpc,plot.mfpc,5,0,0,null,1
+fpc,plot.mfpc,6,0,0,null,1
+fpc,plot.mfpc,7,0,0,null,1
+fpc,plot.valstat,-1,0,0,null,1
+fpc,plot.valstat,0,0,0,class<`valstat`>,1
+fpc,plot.valstat,1,0,0,list<double | list<null | class<`data.frame`>>>,1
+fpc,plot.valstat,2,0,0,character,1
+fpc,plot.valstat,3,0,0,null,1
+fpc,plot.valstat,4,0,0,double[],1
+fpc,plot.valstat,5,0,0,double,1
+fpc,plot.valstat,6,0,0,integer[],1
+fpc,plot.valstat,7,0,0,double,1
+fpc,predict.dbscan,-1,0,0,double[],1
+fpc,predict.dbscan,0,0,0,class<`dbscan`>,1
+fpc,predict.dbscan,1,0,0,class<`matrix`>,1
+fpc,predict.dbscan,2,0,0,class<`matrix`>,1
+fpc,predict.dbscan,3,0,0,double,1
+fpc,predict.dbscan,4,0,0,...,1
+fpc,prediction.strength,-1,0,0,class<`predstr`>,1
+fpc,prediction.strength,0,0,0,class<`data.frame`>,1
+fpc,prediction.strength,0,0,1,class<`dist`>,1
+fpc,prediction.strength,0,0,2,class<`matrix`>,1
+fpc,prediction.strength,1,0,0,double,1
+fpc,prediction.strength,2,0,0,double,1
+fpc,prediction.strength,3,0,0,double,1
+fpc,prediction.strength,4,0,0,class<`function`>,1
+fpc,prediction.strength,5,0,0,character,1
+fpc,prediction.strength,6,0,0,double,1
+fpc,prediction.strength,7,0,0,double,1
+fpc,print.clboot,-1,0,0,class<`clboot`>,1
+fpc,print.clboot,0,0,0,class<`clboot`>,1
+fpc,print.clboot,1,0,0,character[],1
+fpc,print.clboot,2,0,0,...,1
+fpc,print.clusterbenchstats,-1,0,0,null,1
+fpc,print.clusterbenchstats,0,0,0,class<`clusterbenchstats`>,1
+fpc,print.clusterbenchstats,1,0,0,...,1
+fpc,print.valstat,-1,0,0,class<`data.frame`>,1
+fpc,print.valstat,0,0,0,class<`valstat`>,1
+fpc,print.valstat,1,0,0,character[],1
+fpc,print.valstat,2,0,0,double,1
+fpc,print.valstat,3,0,0,logical,1
+fpc,print.valstat,4,0,0,double[],1
+fpc,print.valstat,5,0,0,double,1
+fpc,print.valstat,6,0,0,list<double[]>,1
+fpc,print.valstat,6,0,1,null,1
+fpc,print.valstat,7,0,0,...,1
+fpc,print.varwisetables,-1,0,0,class<`varwisetables`>,1
+fpc,print.varwisetables,0,0,0,class<`varwisetables`>,1
+fpc,print.varwisetables,1,0,0,double,1
+fpc,print.varwisetables,2,0,0,...,1
+fpc,randcmatrix,-1,0,0,class<`matrix`>,1
+fpc,randcmatrix,0,0,0,double,1
+fpc,randcmatrix,1,0,0,double,1
+fpc,randcmatrix,2,0,0,double,1
+fpc,randconf,-1,0,0,logical[],1
+fpc,randconf,0,0,0,double,1
+fpc,randconf,1,0,0,double,1
+fpc,randomclustersim,-1,0,0,list<double | list<null | class<`data.frame`>>>,1
+fpc,randomclustersim,0,0,0,class<`dist`>,1
+fpc,randomclustersim,1,0,0,any,1
+fpc,randomclustersim,2,0,0,logical,1
+fpc,randomclustersim,3,0,0,integer[],1
+fpc,randomclustersim,3,0,1,double,1
+fpc,randomclustersim,4,0,0,double,1
+fpc,randomclustersim,5,0,0,double,1
+fpc,randomclustersim,6,0,0,double,1
+fpc,randomclustersim,7,0,0,double,1
+fpc,rFace,-1,0,0,class<`matrix`>,1
+fpc,rFace,0,0,0,double,1
+fpc,rFace,1,0,0,double,1
+fpc,rFace,2,0,0,double,1
+fpc,rFace,3,0,0,double,1
+fpc,rFace,4,0,0,double,1
+fpc,rFace,5,0,0,double,1
+fpc,rfpi,-1,0,0,list<double[]>,1
+fpc,rfpi,0,0,0,double[],1
+fpc,rfpi,1,0,0,double[],1
+fpc,rfpi,2,0,0,integer,1
+fpc,rfpi,3,0,0,logical[],1
+fpc,rfpi,4,0,0,double,1
+fpc,rfpi,5,0,0,double,1
+fpc,rfpi,6,0,0,logical,1
+fpc,ridgeline,-1,0,0,class<`matrix`>,1
+fpc,ridgeline,0,0,0,double,1
+fpc,ridgeline,1,0,0,double[],1
+fpc,ridgeline,2,0,0,double[],1
+fpc,ridgeline,3,0,0,class<`matrix`>,1
+fpc,ridgeline,4,0,0,class<`matrix`>,1
+fpc,ridgeline.diagnosis,-1,0,0,list<double[] | class<`matrix`>>,1
+fpc,ridgeline.diagnosis,-1,0,1,list<double[] | class<`matrix`> | null>,1
+fpc,ridgeline.diagnosis,0,0,0,double[],1
+fpc,ridgeline.diagnosis,1,0,0,class<`matrix`>,1
+fpc,ridgeline.diagnosis,2,0,0,class<`array`>,1
+fpc,ridgeline.diagnosis,3,0,0,double,1
+fpc,ridgeline.diagnosis,4,0,0,character,1
+fpc,ridgeline.diagnosis,4,0,1,list<integer[]>,1
+fpc,ridgeline.diagnosis,5,0,0,logical,1
+fpc,ridgeline.diagnosis,6,0,0,double,1
+fpc,ridgeline.diagnosis,7,0,0,null,1
+fpc,ridgeline.diagnosis,7,0,1,double,1
+fpc,simmatrix,-1,0,0,double[],1
+fpc,simmatrix,0,0,0,class<`mfpc`>,1
+fpc,simmatrix,0,0,1,class<`rfpc`>,1
+fpc,solvecov,-1,0,0,list<class<`matrix`> | logical>,1
+fpc,solvecov,0,0,0,class<`matrix`>,1
+fpc,solvecov,1,0,0,any,1
+fpc,sseg,-1,0,0,double,1
+fpc,sseg,0,0,0,double,1
+fpc,sseg,1,0,0,double,1
+fpc,stupidkaven,-1,0,0,double[],1
+fpc,stupidkaven,0,0,0,class<`dist`>,1
+fpc,stupidkaven,1,0,0,double,1
+fpc,stupidkcentroids,-1,0,0,double[],1
+fpc,stupidkcentroids,0,0,0,class<`dist`>,1
+fpc,stupidkcentroids,1,0,0,double,1
+fpc,stupidkfn,-1,0,0,double[],1
+fpc,stupidkfn,0,0,0,class<`dist`>,1
+fpc,stupidkfn,1,0,0,double,1
+fpc,stupidknn,-1,0,0,any,1
+fpc,stupidknn,0,0,0,any,1
+fpc,stupidknn,1,0,0,double,1
+fpc,summary.cquality,-1,0,0,class<`summary.cquality`>,1
+fpc,summary.cquality,0,0,0,class<`cquality`>,1
+fpc,summary.cquality,1,0,0,logical,1
+fpc,summary.cquality,2,0,0,logical,1
+fpc,summary.cquality,3,0,0,...,1
+fpc,summary.mergenorm,-1,0,0,class<`summary.mergenorm`>,1
+fpc,summary.mergenorm,0,0,0,class<`mergenorm`>,1
+fpc,summary.mergenorm,1,0,0,...,1
+fpc,summary.mfpc,-1,0,0,class<`summary.mfpc`>,1
+fpc,summary.mfpc,0,0,0,class<`mfpc`>,1
+fpc,summary.mfpc,1,0,0,...,1
+fpc,summary.rfpc,-1,0,0,class<`summary.rfpc`>,1
+fpc,summary.rfpc,0,0,0,class<`rfpc`>,1
+fpc,summary.rfpc,1,0,0,...,1
+fpc,tclustCBI,-1,0,0,list<any>,1
+fpc,tclustCBI,0,0,0,class<`matrix`>,1
+fpc,tclustCBI,1,0,0,double,1
+fpc,tclustCBI,2,0,0,double,1
+fpc,tclustCBI,3,0,0,...,1
+fpc,tdecomp,-1,0,0,class<`matrix`>,1
+fpc,tdecomp,0,0,0,class<`matrix`>,1
+fpc,unimodal.ind,-1,0,0,logical,1
+fpc,unimodal.ind,0,0,0,double[],1
+fpc,weightplots,-1,0,0,class<`matrix`>,1
+fpc,weightplots,0,0,0,class<`matrix`>,1
+fpc,weightplots,1,0,0,integer[],1
+fpc,weightplots,2,0,0,double,1
+fpc,weightplots,3,0,0,character[],1
+fpc,weightplots,3,0,1,integer[],1
+fpc,weightplots,4,0,0,double[],1
+fpc,weightplots,5,0,0,double,1
+fpc,weightplots,6,0,0,character,1
+fpc,weightplots,6,0,1,double[],1
+fpc,weightplots,7,0,0,double,1
+fpc,wfu,-1,0,0,double[],1
+fpc,wfu,0,0,0,double[],1
+fpc,wfu,1,0,0,double,1
+fpc,wfu,2,0,0,double,1
+fpc,wfu,3,0,0,double,1
+fpc,wfu,4,0,0,double,1
+fpc,xtable,-1,0,0,class<`matrix`>,1
+fpc,xtable,0,0,0,double[],1
+fpc,xtable,1,0,0,double[],1
+fpc,xtable,2,0,0,double,1
+fpc,zmisclassification.matrix,-1,0,0,class<`matrix`>,1
+fpc,zmisclassification.matrix,0,0,0,class<`matrix`>,1
+fpc,zmisclassification.matrix,1,0,0,null,1
+fpc,zmisclassification.matrix,1,0,1,double[],1
+fpc,zmisclassification.matrix,2,0,0,null,1
+fpc,zmisclassification.matrix,2,0,1,double[],1
+fpc,zmisclassification.matrix,3,0,0,character,1
+fpc,zmisclassification.matrix,3,0,1,list<integer[]>,1
+fpc,zmisclassification.matrix,4,0,0,logical,1
+fpc,zmisclassification.matrix,5,0,0,character,1
+fracdiff,coef.fracdiff,-1,0,0,double[],1
+fracdiff,coef.fracdiff,0,0,0,class<`fracdiff`>,1
+fracdiff,coef.fracdiff,1,0,0,...,1
+fracdiff,confint.fracdiff,-1,0,0,class<`matrix`>,1
+fracdiff,confint.fracdiff,0,0,0,class<`fracdiff`>,1
+fracdiff,confint.fracdiff,1,0,0,any,1
+fracdiff,confint.fracdiff,2,0,0,double,1
+fracdiff,confint.fracdiff,3,0,0,...,1
+fracdiff,diffseries,-1,0,0,double[],1
+fracdiff,diffseries,0,0,0,double[],1
+fracdiff,diffseries,1,0,0,double,1
+fracdiff,.fdcov,-1,0,0,list<any>,1
+fracdiff,.fdcov,0,0,0,double[],1
+fracdiff,.fdcov,1,0,0,double,1
+fracdiff,.fdcov,2,0,0,any,1
+fracdiff,.fdcov,3,0,0,double,1
+fracdiff,.fdcov,4,0,0,double,1
+fracdiff,.fdcov,5,0,0,class<`matrix`>,1
+fracdiff,.fdcov,6,0,0,double[],1
+fracdiff,fdGPH,-1,0,0,list<double>,1
+fracdiff,fdGPH,0,0,0,double[],1
+fracdiff,fdGPH,1,0,0,double,1
+fracdiff,fdSperio,-1,0,0,list<double>,1
+fracdiff,fdSperio,0,0,0,double[],1
+fracdiff,fdSperio,1,0,0,double,1
+fracdiff,fdSperio,2,0,0,double,1
+fracdiff,fracdiff,-1,0,0,class<`fracdiff`>,1
+fracdiff,fracdiff,0,0,0,double[],1
+fracdiff,fracdiff,1,0,0,double,1
+fracdiff,fracdiff,2,0,0,double,1
+fracdiff,fracdiff,3,0,0,null,1
+fracdiff,fracdiff,3,0,1,^logical[],1
+fracdiff,fracdiff,4,0,0,null,1
+fracdiff,fracdiff,5,0,0,double,1
+fracdiff,fracdiff,5,0,1,null,1
+fracdiff,fracdiff,6,0,0,double[],1
+fracdiff,fracdiff,7,0,0,any,1
+fracdiff,fracdiff,8,0,0,double,1
+fracdiff,fracdiff,9,0,0,double,1
+fracdiff,fracdiff.sim,-1,0,0,list<double[]>,1
+fracdiff,fracdiff.sim,-1,0,1,list<double[] | null>,1
+fracdiff,fracdiff.sim,0,0,0,double,1
+fracdiff,fracdiff.sim,1,0,0,double[],1
+fracdiff,fracdiff.sim,1,0,1,null,1
+fracdiff,fracdiff.sim,2,0,0,double[],1
+fracdiff,fracdiff.sim,2,0,1,null,1
+fracdiff,fracdiff.sim,3,0,0,double,1
+fracdiff,fracdiff.sim,4,0,0,class<`function`>,1
+fracdiff,fracdiff.sim,5,0,0,double[],1
+fracdiff,fracdiff.sim,6,0,0,double,1
+fracdiff,fracdiff.sim,6,0,1,null,1
+fracdiff,fracdiff.sim,7,0,0,logical,1
+fracdiff,fracdiff.sim,8,0,0,logical,1
+fracdiff,fracdiff.sim,9,0,0,double[],1
+fracdiff,fracdiff.sim,10,0,0,...,1
+fracdiff,fracdiff.sim,11,0,0,double,1
+fracdiff,fracdiff.var,-1,0,0,class<`fracdiff`>,1
+fracdiff,fracdiff.var,0,0,0,double[],1
+fracdiff,fracdiff.var,1,0,0,class<`fracdiff`>,1
+fracdiff,fracdiff.var,2,0,0,double,1
+fracdiff,logLik.fracdiff,-1,0,0,class<`logLik`>,1
+fracdiff,logLik.fracdiff,0,0,0,class<`fracdiff`>,1
+fracdiff,logLik.fracdiff,1,0,0,...,1
+fracdiff,summary.fracdiff,-1,0,0,class<`summary.fracdiff`>,1
+fracdiff,summary.fracdiff,0,0,0,class<`fracdiff`>,1
+fracdiff,summary.fracdiff,1,0,0,logical,1
+fracdiff,summary.fracdiff,2,0,0,...,1
+fracdiff,vcov.fracdiff,-1,0,0,class<`matrix`>,1
+fracdiff,vcov.fracdiff,0,0,0,class<`fracdiff`>,1
+fracdiff,vcov.fracdiff,1,0,0,...,1
+fs,%||%,-1,0,0,character,1
+fs,%||%,-1,0,1,"class<`character`, `fs_path`>",1
+fs,%||%,0,0,0,null,1
+fs,%||%,0,0,1,"class<`character`, `fs_path`>",1
+fs,%||%,1,0,0,any,1
+fs,access_,-1,0,0,logical,1
+fs,access_,0,0,0,character,1
+fs,access_,1,0,0,integer,1
+fs,as_fs_bytes,-1,0,0,"class<`fs_bytes`, `numeric`>",1
+fs,as_fs_bytes,0,0,0,"class<`fs_bytes`, `numeric`>",1
+fs,as_fs_bytes,0,0,1,character[],1
+fs,as_fs_bytes.default,-1,0,0,"class<`fs_bytes`, `numeric`>",1
+fs,as_fs_bytes.default,0,0,0,character[],1
+fs,as_fs_bytes.fs_bytes,-1,0,0,"class<`fs_bytes`, `numeric`>",1
+fs,as_fs_bytes.fs_bytes,0,0,0,"class<`fs_bytes`, `numeric`>",1
+fs,as_fs_perms,-1,0,0,"class<`fs_perms`, `integer`>",1
+fs,as_fs_perms,0,0,0,character[],1
+fs,as_fs_perms,0,0,1,"class<`fs_perms`, `integer`>",1
+fs,as_fs_perms,0,0,2,double[],1
+fs,as_fs_perms,1,0,0,...,1
+fs,as_fs_perms.character,-1,0,0,"class<`fs_perms`, `integer`>",1
+fs,as_fs_perms.character,0,0,0,character[],1
+fs,as_fs_perms.character,1,0,0,...,1
+fs,as_fs_perms.character,2,0,0,class<`fs_perms`>,1
+fs,as_fs_perms.character,2,0,1,double,1
+fs,as_fs_perms.fs_perms,-1,0,0,"class<`fs_perms`, `integer`>",1
+fs,as_fs_perms.fs_perms,0,0,0,"class<`fs_perms`, `integer`>",1
+fs,as_fs_perms.fs_perms,1,0,0,...,1
+fs,as_fs_perms.integer,-1,0,0,"class<`fs_perms`, `integer`>",1
+fs,as_fs_perms.integer,0,0,0,integer,1
+fs,as_fs_perms.integer,1,0,0,...,1
+fs,as_fs_perms.numeric,-1,0,0,"class<`fs_perms`, `integer`>",1
+fs,as_fs_perms.numeric,0,0,0,double[],1
+fs,as_fs_perms.numeric,1,0,0,...,1
+fs,assert,-1,0,0,null,1
+fs,assert,0,0,0,character,1
+fs,assert,1,0,0,...,1
+fs,assert,2,0,0,character,1
+fs,assert_no_missing,-1,0,0,null,1
+fs,assert_no_missing,0,0,0,character[],1
+fs,assert_no_missing,0,0,1,"class<`character`, `fs_path`>",1
+fs,auto_name,-1,0,0,character[],1
+fs,auto_name,0,0,0,character[],1
+fs,captures,-1,0,0,class<`data.frame`>,1
+fs,captures,0,0,0,character[],1
+fs,captures,1,0,0,integer[],1
+fs,chmod_,-1,0,0,null,1
+fs,chmod_,0,0,0,"class<`character`, `fs_path`>",1
+fs,chmod_,1,0,0,"class<`fs_perms`, `integer`>",1
+fs,copyfile_,-1,0,0,any,1
+fs,copyfile_,0,0,0,"class<`character`, `fs_path`>",1
+fs,copyfile_,1,0,0,"class<`character`, `fs_path`>",1
+fs,copyfile_,2,0,0,logical,1
+fs,create_,-1,0,0,any,1
+fs,create_,0,0,0,"class<`character`, `fs_path`>",1
+fs,create_,1,0,0,"class<`fs_perms`, `integer`>",1
+fs,create_,1,0,1,double,1
+fs,dir_copy,-1,0,0,"class<`character`, `fs_path`>",1
+fs,dir_copy,0,0,0,character,1
+fs,dir_copy,1,0,0,character,1
+fs,dir_copy,2,0,0,logical,1
+fs,dir_create,-1,0,0,any,1
+fs,dir_create,0,0,0,character,1
+fs,dir_create,0,0,1,"class<`character`, `fs_path`>",1
+fs,dir_create,1,0,0,...,1
+fs,dir_create,2,0,0,character,1
+fs,dir_create,3,0,0,logical,1
+fs,dir_create,4,0,0,any,1
+fs,dir_delete,-1,0,0,"class<`character`, `fs_path`>",1
+fs,dir_delete,0,0,0,character[],1
+fs,dir_delete,0,0,1,"class<`character`, `fs_path`>",1
+fs,dir_exists,-1,0,0,logical,1
+fs,dir_exists,0,0,0,character,1
+fs,dir_exists,0,0,1,"class<`character`, `fs_path`>",1
+fs,dir_info,-1,0,0,"class<`data.frame`, `tbl`, `tbl_df`>",1
+fs,dir_info,0,0,0,character,1
+fs,dir_info,1,0,0,logical,1
+fs,dir_info,2,0,0,logical,1
+fs,dir_info,3,0,0,character,1
+fs,dir_info,4,0,0,null,1
+fs,dir_info,5,0,0,null,1
+fs,dir_info,6,0,0,logical,1
+fs,dir_info,7,0,0,...,1
+fs,dir_ls,-1,0,0,"class<`character`, `fs_path`>",1
+fs,dir_ls,0,0,0,character,1
+fs,dir_ls,0,0,1,"class<`character`, `fs_path`>",1
+fs,dir_ls,1,0,0,logical,1
+fs,dir_ls,2,0,0,logical,1
+fs,dir_ls,3,0,0,character[],1
+fs,dir_ls,4,0,0,null,1
+fs,dir_ls,4,0,1,character,1
+fs,dir_ls,5,0,0,null,1
+fs,dir_ls,6,0,0,logical,1
+fs,dir_ls,7,0,0,logical,1
+fs,dir_ls,8,0,0,...,1
+fs,dir_map,-1,0,0,list<any>,1
+fs,dir_map,0,0,0,"class<`character`, `fs_path`>",1
+fs,dir_map,0,0,1,character,1
+fs,dir_map,1,0,0,class<`function`>,1
+fs,dir_map,2,0,0,logical,1
+fs,dir_map,3,0,0,logical,1
+fs,dir_map,4,0,0,character[],1
+fs,dir_map,5,0,0,logical,1
+fs,dir_map_,-1,0,0,list<any>,1
+fs,dir_map_,0,0,0,"class<`character`, `fs_path`>",1
+fs,dir_map_,1,0,0,class<`function`>,1
+fs,dir_map_,2,0,0,logical,1
+fs,dir_map_,3,0,0,integer,1
+fs,dir_map_,4,0,0,double,1
+fs,dir_map_,5,0,0,logical,1
+fs,dir_walk,-1,0,0,"class<`character`, `fs_path`>",1
+fs,dir_walk,0,0,0,character,1
+fs,dir_walk,1,0,0,class<`function`>,1
+fs,dir_walk,2,0,0,logical,1
+fs,dir_walk,3,0,0,logical,1
+fs,dir_walk,4,0,0,character,1
+fs,dir_walk,5,0,0,logical,1
+fs,display_mode_to_symbolic_mode_posix,-1,0,0,character,1
+fs,display_mode_to_symbolic_mode_posix,0,0,0,character[],1
+fs,expand_,-1,0,0,character[],1
+fs,expand_,0,0,0,character[],1
+fs,expand_,0,0,1,"class<`character`, `fs_path`>",1
+fs,expand_,1,0,0,logical,1
+fs,file_access,-1,0,0,logical,1
+fs,file_access,0,0,0,character,1
+fs,file_access,1,0,0,character,1
+fs,file_chmod,-1,0,0,"class<`character`, `fs_path`>",1
+fs,file_chmod,0,0,0,character[],1
+fs,file_chmod,1,0,0,character[],1
+fs,file_copy,-1,0,0,any,1
+fs,file_copy,0,0,0,character,1
+fs,file_copy,0,0,1,"class<`character`, `fs_path`>",1
+fs,file_copy,1,0,0,character,1
+fs,file_copy,1,0,1,"class<`character`, `fs_path`>",1
+fs,file_copy,2,0,0,logical,1
+fs,file_create,-1,0,0,any,1
+fs,file_create,0,0,0,character[],1
+fs,file_create,0,0,1,"class<`character`, `fs_path`>",1
+fs,file_create,1,0,0,...,1
+fs,file_create,2,0,0,character,1
+fs,file_delete,-1,0,0,"class<`character`, `fs_path`>",1
+fs,file_delete,0,0,0,character[],1
+fs,file_delete,0,0,1,"class<`character`, `fs_path`>",1
+fs,file_exists,-1,0,0,logical[],1
+fs,file_exists,0,0,0,"class<`character`, `fs_path`>",1
+fs,file_exists,0,0,1,character[],1
+fs,file_info,-1,0,0,"class<`data.frame`, `tbl`, `tbl_df`>",1
+fs,file_info,0,0,0,character[],1
+fs,file_info,0,0,1,"class<`character`, `fs_path`>",1
+fs,file_info,1,0,0,logical,1
+fs,file_move,-1,0,0,"class<`character`, `fs_path`>",1
+fs,file_move,0,0,0,character,1
+fs,file_move,1,0,0,character,1
+fs,file_temp,-1,0,0,"class<`character`, `fs_path`>",1
+fs,file_temp,0,0,0,character,1
+fs,file_temp,1,0,0,character,1
+fs,file_temp,2,0,0,character,1
+fs,file_temp_pop,-1,0,0,"class<`character`, `fs_path`>",1
+fs,file_temp_pop,-1,0,1,null,1
+fs,file_temp_push,-1,0,0,"class<`character`, `fs_path`>",1
+fs,file_temp_push,0,0,0,character[],1
+fs,file_touch,-1,0,0,"class<`character`, `fs_path`>",1
+fs,file_touch,0,0,0,character,1
+fs,file_touch,1,0,0,character,1
+fs,file_touch,2,0,0,"class<`POSIXct`, `POSIXt`>",1
+fs,fs_bytes,-1,0,0,"class<`fs_bytes`, `numeric`>",1
+fs,fs_bytes,0,0,0,"class<`fs_bytes`, `numeric`>",1
+fs,fs_bytes,0,0,1,character[],1
+fs,[.fs_path,-1,0,0,"class<`character`, `fs_path`>",1
+fs,[.fs_path,0,0,0,"class<`character`, `fs_path`>",1
+fs,[.fs_path,1,0,0,double,1
+fs,[.fs_path,1,0,1,integer[],1
+fs,==.fs_perms,-1,0,0,logical,1
+fs,==.fs_perms,0,0,0,"class<`fs_perms`, `integer`>",1
+fs,==.fs_perms,1,0,0,character,1
+fs,&.fs_perms,-1,0,0,"class<`fs_perms`, `integer`>",1
+fs,&.fs_perms,0,0,0,"class<`fs_perms`, `integer`>",1
+fs,&.fs_perms,1,0,0,character,1
+fs,&.fs_perms,1,0,1,"class<`fs_perms`, `integer`>",1
+fs,fs_perms,-1,0,0,"class<`fs_perms`, `integer`>",1
+fs,fs_perms,0,0,0,character[],1
+fs,fs_perms,0,0,1,"class<`fs_perms`, `integer`>",1
+fs,fs_perms,0,0,2,double[],1
+fs,fs_perms,1,0,0,...,1
+fs,getmode_,-1,0,0,integer,1
+fs,getmode_,0,0,0,character,1
+fs,getmode_,1,0,0,double,1
+fs,group_ids,-1,0,0,class<`data.frame`>,1
+fs,groups_,-1,0,0,class<`data.frame`>,1
+fs,is_absolute_path,-1,0,0,logical[],1
+fs,is_absolute_path,0,0,0,character[],1
+fs,is_absolute_path,0,0,1,"class<`character`, `fs_path`>",1
+fs,is_dir,-1,0,0,logical[],1
+fs,is_dir,0,0,0,character,1
+fs,is_dir,0,0,1,"class<`character`, `fs_path`>",1
+fs,is_file,-1,0,0,logical[],1
+fs,is_file,0,0,0,"class<`character`, `fs_path`>",1
+fs,is_file,0,0,1,character,1
+fs,is_link,-1,0,0,logical[],1
+fs,is_link,0,0,0,"class<`character`, `fs_path`>",1
+fs,is_link,0,0,1,character,1
+fs,is_windows,-1,0,0,logical,1
+fs,link_copy,-1,0,0,"class<`character`, `fs_path`>",1
+fs,link_copy,0,0,0,character,1
+fs,link_copy,0,0,1,"class<`character`, `fs_path`>",1
+fs,link_copy,1,0,0,character,1
+fs,link_copy,1,0,1,"class<`character`, `fs_path`>",1
+fs,link_copy,2,0,0,logical,1
+fs,link_create,-1,0,0,"class<`character`, `fs_path`>",1
+fs,link_create,0,0,0,character,1
+fs,link_create,0,0,1,"class<`character`, `fs_path`>",1
+fs,link_create,1,0,0,character,1
+fs,link_create,1,0,1,"class<`character`, `fs_path`>",1
+fs,link_create,2,0,0,logical,1
+fs,link_create_symbolic_,-1,0,0,null,1
+fs,link_create_symbolic_,0,0,0,"class<`character`, `fs_path`>",1
+fs,link_create_symbolic_,1,0,0,"class<`character`, `fs_path`>",1
+fs,link_delete,-1,0,0,"class<`character`, `fs_path`>",1
+fs,link_delete,0,0,0,character[],1
+fs,link_delete,0,0,1,"class<`character`, `fs_path`>",1
+fs,link_exists,-1,0,0,logical[],1
+fs,link_exists,0,0,0,character,1
+fs,link_exists,0,0,1,"class<`character`, `fs_path`>",1
+fs,link_path,-1,0,0,"class<`character`, `fs_path`>",1
+fs,link_path,0,0,0,character[],1
+fs,link_path,0,0,1,"class<`character`, `fs_path`>",1
+fs,mkdir_,-1,0,0,any,1
+fs,mkdir_,0,0,0,character[],1
+fs,mkdir_,1,0,0,"class<`fs_perms`, `integer`>",1
+fs,move_,-1,0,0,null,1
+fs,move_,0,0,0,"class<`character`, `fs_path`>",1
+fs,move_,1,0,0,"class<`character`, `fs_path`>",1
+fs,new_fs_bytes,-1,0,0,"class<`fs_bytes`, `numeric`>",1
+fs,new_fs_bytes,0,0,0,double[],1
+fs,new_fs_path,-1,0,0,"class<`character`, `fs_path`>",1
+fs,new_fs_path,0,0,0,character[],1
+fs,new_fs_perms,-1,0,0,"class<`fs_perms`, `integer`>",1
+fs,new_fs_perms,0,0,0,integer[],1
+fs,Ops.fs_bytes,-1,0,0,logical,1
+fs,Ops.fs_bytes,0,0,0,"class<`fs_bytes`, `numeric`>",1
+fs,Ops.fs_bytes,1,0,0,character,1
+fs,path,-1,0,0,"class<`character`, `fs_path`>",1
+fs,path,0,0,0,...,1
+fs,path,1,0,0,character,1
+fs,path_,-1,0,0,character[],1
+fs,path_,0,0,0,list<character[]>,1
+fs,path_,0,0,1,character[],1
+fs,path_,1,0,0,character,1
+fs,path_abs,-1,0,0,"class<`character`, `fs_path`>",1
+fs,path_abs,0,0,0,character,1
+fs,path_abs,0,0,1,"class<`character`, `fs_path`>",1
+fs,path_abs,1,0,0,character,1
+fs,path_common,-1,0,0,"class<`character`, `fs_path`>",1
+fs,path_common,0,0,0,character[],1
+fs,path_dir,-1,0,0,character,1
+fs,path_dir,0,0,0,character,1
+fs,path_expand,-1,0,0,"class<`character`, `fs_path`>",1
+fs,path_expand,0,0,0,character[],1
+fs,path_expand,0,0,1,"class<`character`, `fs_path`>",1
+fs,path_expand_r,-1,0,0,"class<`character`, `fs_path`>",1
+fs,path_expand_r,0,0,0,character,1
+fs,path_ext,-1,0,0,character,1
+fs,path_ext,0,0,0,character,1
+fs,path_ext_remove,-1,0,0,character,1
+fs,path_ext_remove,0,0,0,character,1
+fs,path_ext_set,-1,0,0,"class<`character`, `fs_path`>",1
+fs,path_ext_set,0,0,0,character,1
+fs,path_ext_set,1,0,0,character,1
+fs,path_file,-1,0,0,character[],1
+fs,path_file,0,0,0,"class<`character`, `fs_path`>",1
+fs,path_file,0,0,1,character,1
+fs,path_filter,-1,0,0,"class<`character`, `fs_path`>",1
+fs,path_filter,0,0,0,character[],1
+fs,path_filter,1,0,0,character,1
+fs,path_filter,1,0,1,null,1
+fs,path_filter,2,0,0,null,1
+fs,path_filter,2,0,1,character,1
+fs,path_filter,3,0,0,any,1
+fs,path_filter,4,0,0,...,1
+fs,path_home,-1,0,0,"class<`character`, `fs_path`>",1
+fs,path_home,0,0,0,...,1
+fs,path_home_r,-1,0,0,"class<`character`, `fs_path`>",1
+fs,path_home_r,0,0,0,...,1
+fs,path_join,-1,0,0,"class<`character`, `fs_path`>",1
+fs,path_join,0,0,0,character[],1
+fs,path_join,0,0,1,list<character[]>,1
+fs,path_norm,-1,0,0,"class<`character`, `fs_path`>",1
+fs,path_norm,0,0,0,character[],1
+fs,path_norm,0,0,1,"class<`character`, `fs_path`>",1
+fs,path_package,-1,0,0,"class<`character`, `fs_path`>",1
+fs,path_package,0,0,0,character,1
+fs,path_package,1,0,0,...,1
+fs,path_real,-1,0,0,"class<`character`, `fs_path`>",1
+fs,path_real,0,0,0,character,1
+fs,path_rel,-1,0,0,"class<`character`, `fs_path`>",1
+fs,path_rel,0,0,0,character,1
+fs,path_rel,0,0,1,"class<`character`, `fs_path`>",1
+fs,path_rel,1,0,0,character,1
+fs,path_sanitize,-1,0,0,character,1
+fs,path_sanitize,0,0,0,character,1
+fs,path_sanitize,1,0,0,character,1
+fs,path_split,-1,0,0,list<any>,1
+fs,path_split,0,0,0,character[],1
+fs,path_split,0,0,1,"class<`character`, `fs_path`>",1
+fs,path_temp,-1,0,0,"class<`character`, `fs_path`>",1
+fs,path_temp,0,0,0,...,1
+fs,path_tidy,-1,0,0,"class<`character`, `fs_path`>",1
+fs,path_tidy,0,0,0,character[],1
+fs,path_tidy,0,0,1,"class<`character`, `fs_path`>",1
+fs,path_tidy,0,0,2,list<any>,1
+fs,readlink_,-1,0,0,character[],1
+fs,readlink_,0,0,0,"class<`character`, `fs_path`>",1
+fs,realize_,-1,0,0,character,1
+fs,realize_,0,0,0,"class<`character`, `fs_path`>",1
+fs,register_s3_method,-1,0,0,null,1
+fs,register_s3_method,0,0,0,character,1
+fs,register_s3_method,1,0,0,character,1
+fs,register_s3_method,2,0,0,character,1
+fs,register_s3_method,3,0,0,null,1
+fs,rmdir_,-1,0,0,null,1
+fs,rmdir_,0,0,0,character[],1
+fs,stat_,-1,0,0,"class<`data.frame`, `tbl`, `tbl_df`>",1
+fs,stat_,0,0,0,"class<`character`, `fs_path`>",1
+fs,stat_,1,0,0,logical,1
+fs,sum.fs_bytes,-1,0,0,"class<`fs_bytes`, `numeric`>",1
+fs,sum.fs_bytes,0,0,0,"class<`fs_bytes`, `numeric`>",1
+fs,sum.fs_bytes,1,0,0,...,1
+fs,tidy_,-1,0,0,character[],1
+fs,tidy_,0,0,0,character[],1
+fs,touch_,-1,0,0,null,1
+fs,touch_,0,0,0,"class<`character`, `fs_path`>",1
+fs,touch_,1,0,0,"class<`POSIXct`, `POSIXt`>",1
+fs,touch_,2,0,0,"class<`POSIXct`, `POSIXt`>",1
+fs,unlink_,-1,0,0,null,1
+fs,unlink_,0,0,0,"class<`character`, `fs_path`>",1
+fs,user_ids,-1,0,0,class<`data.frame`>,1
+fs,users_,-1,0,0,class<`data.frame`>,1
+functional,Compose,-1,0,0,class<`function`>,1
+functional,Compose,0,0,0,...,1
+functional,Curry,-1,0,0,class<`function`>,1
+functional,Curry,0,0,0,any,1
+functional,Curry,1,0,0,...,1
+functional,CurryL,-1,0,0,class<`function`>,1
+functional,CurryL,0,0,0,any,1
+functional,CurryL,1,0,0,...,1
+functional,CurryL,-1,1,0,class<`call`>,1
+functional,CurryL,0,1,0,...,1
+functional,multi.argument.Compose,-1,0,0,class<`function`>,1
+functional,multi.argument.Compose,0,0,0,...,1
+functional,multi.argument.Compose,-1,1,0,double,1
+functional,multi.argument.Compose,0,1,0,...,1
+futile.logger,appender.console,-1,0,0,class<`function`>,1
+futile.logger,flog.appender,-1,0,0,class<`function`>,1
+futile.logger,flog.appender,0,0,0,...,1
+futile.logger,flog.carp,-1,0,0,null,1
+futile.logger,flog.carp,0,0,0,...,1
+futile.logger,flog.debug,-1,0,0,character,1
+futile.logger,flog.debug,-1,0,1,null,1
+futile.logger,flog.debug,0,0,0,character,1
+futile.logger,flog.debug,1,0,0,...,1
+futile.logger,flog.debug,2,0,0,character,1
+futile.logger,flog.debug,3,0,0,logical,1
+futile.logger,flog.info,-1,0,0,character,1
+futile.logger,flog.info,-1,0,1,null,1
+futile.logger,flog.info,0,0,0,character,1
+futile.logger,flog.info,0,0,1,double,1
+futile.logger,flog.info,1,0,0,...,1
+futile.logger,flog.info,2,0,0,character,1
+futile.logger,flog.info,3,0,0,logical,1
+futile.logger,flog.layout,-1,0,0,class<`function`>,1
+futile.logger,flog.layout,-1,0,1,null,1
+futile.logger,flog.layout,0,0,0,...,1
+futile.logger,flog.logger,-1,0,0,null,1
+futile.logger,flog.logger,-1,0,1,list<character | integer | class<`function`>>,1
+futile.logger,flog.logger,0,0,0,...,1
+futile.logger,flog.namespace,-1,0,0,character,1
+futile.logger,flog.namespace,0,0,0,double,1
+futile.logger,flog.remove,-1,0,0,null,1
+futile.logger,flog.remove,0,0,0,...,1
+futile.logger,flog.threshold,-1,0,0,null,1
+futile.logger,flog.threshold,0,0,0,...,1
+futile.logger,flog.warn,-1,0,0,character,1
+futile.logger,flog.warn,0,0,0,character,1
+futile.logger,flog.warn,1,0,0,...,1
+futile.logger,flog.warn,2,0,0,character,1
+futile.logger,flog.warn,3,0,0,logical,1
+futile.logger,ftry,-1,0,0,character,1
+futile.logger,ftry,0,0,0,any,1
+futile.logger,ftry,1,0,0,any,1
+futile.logger,ftry,2,0,0,null,1
+futile.logger,layout.format,-1,0,0,class<`function`>,1
+futile.logger,layout.format,0,0,0,character,1
+futile.logger,layout.format,1,0,0,character,1
+futile.logger,.log_level,-1,0,0,character,1
+futile.logger,.log_level,-1,0,1,null,1
+futile.logger,.log_level,0,0,0,any,1
+futile.logger,.log_level,1,0,0,...,1
+futile.logger,.log_level,2,0,0,integer,1
+futile.logger,.log_level,3,0,0,character,1
+futile.logger,.log_level,4,0,0,any,1
+futile.logger,scat,-1,0,0,null,1
+futile.logger,scat,0,0,0,character,1
+futile.logger,scat,1,0,0,...,1
+futile.logger,scat,2,0,0,logical,1
+future.apply,future_by,-1,0,0,any,1
+future.apply,future_by,0,0,0,class<`data.frame`>,1
+future.apply,future_by,1,0,0,class<`factor`>,1
+future.apply,future_by,2,0,0,class<`function`>,1
+future.apply,future_by,3,0,0,...,1
+future.apply,future_by,4,0,0,logical,1
+future.apply,future_by.data.frame,-1,0,0,any,1
+future.apply,future_by.data.frame,0,0,0,class<`data.frame`>,1
+future.apply,future_by.data.frame,1,0,0,class<`factor`>,1
+future.apply,future_by.data.frame,2,0,0,class<`function`>,1
+future.apply,future_by.data.frame,3,0,0,...,1
+future.apply,future_by.data.frame,4,0,0,logical,1
+future.apply,future_by_internal,-1,0,0,any,1
+future.apply,future_by_internal,0,0,0,class<`data.frame`>,1
+future.apply,future_by_internal,1,0,0,class<`factor`>,1
+future.apply,future_by_internal,2,0,0,class<`function`>,1
+future.apply,future_by_internal,3,0,0,...,1
+future.apply,future_by_internal,4,0,0,any,1
+future.apply,future_by_internal,5,0,0,class<`function`>,1
+future.apply,future_by_internal,6,0,0,any,1
+future.apply,future_by_internal,7,0,0,character,1
+future.apply,future_by_internal,8,0,0,character,1
+future.apply,future_lapply,-1,0,0,any,1
+future.apply,future_lapply,0,0,0,list<class<`data.frame`>>,1
+future.apply,future_lapply,1,0,0,class<`function`>,1
+future.apply,future_lapply,2,0,0,...,1
+future.apply,future_lapply,3,0,0,logical,1
+future.apply,future_lapply,4,0,0,null,1
+future.apply,future_lapply,5,0,0,logical,1
+future.apply,future_lapply,6,0,0,null,1
+future.apply,future_lapply,7,0,0,logical,1
+future.apply,future_lapply,8,0,0,logical,1
+future.apply,future_lapply,9,0,0,double,1
+future.apply,future_lapply,10,0,0,null,1
+future.apply,future_lapply,11,0,0,character,1
+future.apply,future_version,-1,0,0,"class<`numeric_version`, `package_version`>",1
+future.apply,future_xapply,-1,0,0,any,1
+future.apply,future_xapply,0,0,0,class<`function`>,1
+future.apply,future_xapply,1,0,0,integer,1
+future.apply,future_xapply,2,0,0,list<class<`data.frame`>>,1
+future.apply,future_xapply,3,0,0,list<any>,1
+future.apply,future_xapply,4,0,0,null,1
+future.apply,future_xapply,5,0,0,class<`{`>,1
+future.apply,future_xapply,6,0,0,environment,1
+future.apply,future_xapply,7,0,0,logical,1
+future.apply,future_xapply,8,0,0,null,1
+future.apply,future_xapply,9,0,0,double,1
+future.apply,future_xapply,10,0,0,null,1
+future.apply,future_xapply,11,0,0,logical,1
+future.apply,future_xapply,12,0,0,null,1
+future.apply,future_xapply,13,0,0,logical,1
+future.apply,getGlobalsAndPackagesXApply,-1,0,0,"list<class<`FutureGlobals`, `Globals`, `list`> | character | logical>",1
+future.apply,getGlobalsAndPackagesXApply,0,0,0,any,1
+future.apply,getGlobalsAndPackagesXApply,1,0,0,list<any>,1
+future.apply,getGlobalsAndPackagesXApply,2,0,0,any,1
+future.apply,getGlobalsAndPackagesXApply,3,0,0,environment,1
+future.apply,getGlobalsAndPackagesXApply,4,0,0,logical,1
+future.apply,getGlobalsAndPackagesXApply,5,0,0,null,1
+future.apply,getGlobalsAndPackagesXApply,6,0,0,logical,1
+future.apply,getOption,-1,0,0,logical,1
+future.apply,getOption,-1,0,1,null,1
+future.apply,getOption,0,0,0,character,1
+future.apply,getOption,1,0,0,logical,1
+future.apply,getOption,1,0,1,null,1
+future.apply,import_from,-1,0,0,class<`function`>,1
+future.apply,import_from,0,0,0,character,1
+future.apply,import_from,1,0,0,any,1
+future.apply,import_from,2,0,0,character,1
+future.apply,import_future,-1,0,0,class<`function`>,1
+future.apply,import_future,0,0,0,character,1
+future.apply,import_future,1,0,0,null,1
+future.apply,isFALSE,-1,0,0,logical,1
+future.apply,isFALSE,0,0,0,logical,1
+future.apply,makeChunks,-1,0,0,list<integer>,1
+future.apply,makeChunks,0,0,0,integer,1
+future.apply,makeChunks,1,0,0,integer,1
+future.apply,makeChunks,2,0,0,double,1
+future.apply,makeChunks,3,0,0,null,1
+future.apply,make_rng_seeds,-1,0,0,null,1
+future.apply,make_rng_seeds,0,0,0,any,1
+future.apply,make_rng_seeds,1,0,0,logical,1
+future.apply,make_rng_seeds,2,0,0,any,1
+future.apply,stop_if_not,-1,0,0,null,1
+future.apply,stop_if_not,0,0,0,...,1
+gargle,cache_allowed,-1,0,0,logical,1
+gargle,cache_allowed,0,0,0,any,1
+gargle,cache_available,-1,0,0,logical,1
+gargle,cache_available,0,0,0,"class<`character`, `fs_path`>",1
+gargle,cache_establish,-1,0,0,null,1
+gargle,cache_establish,0,0,0,null,1
+gargle,cat_line,-1,0,0,null,1
+gargle,cat_line,0,0,0,...,1
+gargle,cat_line,1,0,0,logical,1
+gargle,check_params,-1,0,0,list<character>,1
+gargle,check_params,0,0,0,list<character>,1
+gargle,check_params,1,0,0,list<list<character | character | logical>>,1
+gargle,check_params,1,0,1,list<list<character | logical | character[]>>,1
+gargle,cred_funs_add,-1,0,0,null,1
+gargle,cred_funs_add,0,0,0,...,1
+gargle,cred_funs_clear,-1,0,0,null,1
+gargle,cred_funs_list,-1,0,0,list<class<`function`>>,1
+gargle,cred_funs_set_default,-1,0,0,null,1
+gargle,extract_path_names,-1,0,0,character,1
+gargle,extract_path_names,0,0,0,"class<`character`, `fs_path`>",1
+gargle,gargle_api_key,-1,0,0,character,1
+gargle,gargle_default_oauth_cache_path,-1,0,0,"class<`character`, `fs_path`>",1
+gargle,gargle_oauth_cache,-1,0,0,null,1
+gargle,gargle_oauth_email,-1,0,0,null,1
+gargle,gargle_oauth_sitrep,-1,0,0,null,1
+gargle,gargle_oauth_sitrep,0,0,0,null,1
+gargle,gargle_oob_default,-1,0,0,logical,1
+gargle,gargle_quiet,-1,0,0,logical,1
+gargle,init_AuthState,-1,0,0,"class<`AuthState`, `R6`>",1
+gargle,init_AuthState,0,0,0,character,1
+gargle,init_AuthState,1,0,0,class<`oauth_app`>,1
+gargle,init_AuthState,2,0,0,character,1
+gargle,init_AuthState,3,0,0,logical,1
+gargle,init_AuthState,4,0,0,null,1
+gargle,isFALSE,-1,0,0,logical,1
+gargle,isFALSE,0,0,0,logical,1
+gargle,is.oauth_app,-1,0,0,logical,1
+gargle,is.oauth_app,0,0,0,class<`oauth_app`>,1
+gargle,is_string,-1,0,0,logical,1
+gargle,is_string,0,0,0,character,1
+gargle,map_lgl,-1,0,0,logical[],1
+gargle,map_lgl,0,0,0,list<class<`function`>>,1
+gargle,map_lgl,1,0,0,class<`function`>,1
+gargle,map_lgl,2,0,0,...,1
+gargle,map_mold,-1,0,0,logical[],1
+gargle,map_mold,0,0,0,list<class<`function`>>,1
+gargle,map_mold,1,0,0,class<`function`>,1
+gargle,map_mold,2,0,0,logical,1
+gargle,map_mold,3,0,0,...,1
+gargle,partition_params,-1,0,0,list<list<any>>,1
+gargle,partition_params,0,0,0,list<character>,1
+gargle,partition_params,1,0,0,character[],1
+gdalUtils,gdaladdo,-1,0,0,null,1
+gdalUtils,gdaladdo,0,0,0,character,1
+gdalUtils,gdaladdo,1,0,0,double[],1
+gdalUtils,gdaladdo,2,0,0,character,1
+gdalUtils,gdaladdo,3,0,0,any,1
+gdalUtils,gdaladdo,4,0,0,any,1
+gdalUtils,gdaladdo,5,0,0,any,1
+gdalUtils,gdaladdo,6,0,0,any,1
+gdalUtils,gdaladdo,7,0,0,logical,1
+gdalUtils,gdalbuildvrt,-1,0,0,null,1
+gdalUtils,gdalbuildvrt,0,0,0,any,1
+gdalUtils,gdalbuildvrt,1,0,0,character,1
+gdalUtils,gdalbuildvrt,2,0,0,any,1
+gdalUtils,gdalbuildvrt,3,0,0,any,1
+gdalUtils,gdalbuildvrt,4,0,0,any,1
+gdalUtils,gdalbuildvrt,5,0,0,any,1
+gdalUtils,gdalbuildvrt,6,0,0,any,1
+gdalUtils,gdalbuildvrt,7,0,0,logical,1
+gdalUtils,gdal_chooseInstallation,-1,0,0,integer,1
+gdalUtils,gdal_chooseInstallation,0,0,0,any,1
+gdalUtils,gdal_cmd_builder,-1,0,0,character,1
+gdalUtils,gdal_cmd_builder,0,0,0,character,1
+gdalUtils,gdal_cmd_builder,1,0,0,list<list<character[]>>,1
+gdalUtils,gdal_cmd_builder,1,0,1,list<list<character[] | null>>,1
+gdalUtils,gdal_cmd_builder,2,0,0,list<any>,1
+gdalUtils,gdal_cmd_builder,3,0,0,character[],1
+gdalUtils,gdal_cmd_builder,4,0,0,character[],1
+gdalUtils,gdal_cmd_builder,5,0,0,any,1
+gdalUtils,gdal_cmd_builder,6,0,0,any,1
+gdalUtils,gdal_cmd_builder,7,0,0,double,1
+gdalUtils,gdal_contour,-1,0,0,class<`SpatialLinesDataFrame`>,1
+gdalUtils,gdal_contour,0,0,0,character,1
+gdalUtils,gdal_contour,1,0,0,character,1
+gdalUtils,gdal_contour,2,0,0,any,1
+gdalUtils,gdal_contour,3,0,0,character,1
+gdalUtils,gdal_contour,4,0,0,any,1
+gdalUtils,gdal_contour,5,0,0,any,1
+gdalUtils,gdal_contour,6,0,0,any,1
+gdalUtils,gdal_contour,7,0,0,double,1
+gdalUtils,gdaldem,-1,0,0,class<`RasterBrick`>,1
+gdalUtils,gdaldem,0,0,0,character,1
+gdalUtils,gdaldem,1,0,0,character,1
+gdalUtils,gdaldem,2,0,0,character,1
+gdalUtils,gdaldem,3,0,0,any,1
+gdalUtils,gdaldem,4,0,0,any,1
+gdalUtils,gdaldem,5,0,0,any,1
+gdalUtils,gdaldem,6,0,0,any,1
+gdalUtils,gdaldem,7,0,0,any,1
+gdalUtils,gdal_grid,-1,0,0,class<`RasterBrick`>,1
+gdalUtils,gdal_grid,0,0,0,character,1
+gdalUtils,gdal_grid,1,0,0,character,1
+gdalUtils,gdal_grid,2,0,0,character,1
+gdalUtils,gdal_grid,3,0,0,character,1
+gdalUtils,gdal_grid,4,0,0,double[],1
+gdalUtils,gdal_grid,5,0,0,double[],1
+gdalUtils,gdal_grid,6,0,0,double[],1
+gdalUtils,gdal_grid,7,0,0,any,1
+gdalUtils,gdalinfo,-1,0,0,character[],1
+gdalUtils,gdalinfo,-1,0,1,list<double | character | class<`matrix`>>,1
+gdalUtils,gdalinfo,0,0,0,character,1
+gdalUtils,gdalinfo,1,0,0,any,1
+gdalUtils,gdalinfo,2,0,0,any,1
+gdalUtils,gdalinfo,3,0,0,any,1
+gdalUtils,gdalinfo,4,0,0,any,1
+gdalUtils,gdalinfo,5,0,0,any,1
+gdalUtils,gdalinfo,6,0,0,any,1
+gdalUtils,gdalinfo,7,0,0,any,1
+gdalUtils,gdallocationinfo,-1,0,0,character[],1
+gdalUtils,gdallocationinfo,-1,0,1,class<`matrix`>,1
+gdalUtils,gdallocationinfo,0,0,0,character,1
+gdalUtils,gdallocationinfo,1,0,0,any,1
+gdalUtils,gdallocationinfo,2,0,0,any,1
+gdalUtils,gdallocationinfo,3,0,0,any,1
+gdalUtils,gdallocationinfo,4,0,0,any,1
+gdalUtils,gdallocationinfo,5,0,0,any,1
+gdalUtils,gdallocationinfo,6,0,0,any,1
+gdalUtils,gdallocationinfo,7,0,0,any,1
+gdalUtils,gdalmanage,-1,0,0,character,1
+gdalUtils,gdalmanage,0,0,0,character,1
+gdalUtils,gdalmanage,1,0,0,character,1
+gdalUtils,gdalmanage,2,0,0,any,1
+gdalUtils,gdalmanage,3,0,0,any,1
+gdalUtils,gdalmanage,4,0,0,any,1
+gdalUtils,gdalmanage,5,0,0,any,1
+gdalUtils,gdalmanage,6,0,0,logical,1
+gdalUtils,gdalmanage,7,0,0,logical,1
+gdalUtils,gdal_rasterize,-1,0,0,class<`RasterBrick`>,1
+gdalUtils,gdal_rasterize,0,0,0,character,1
+gdalUtils,gdal_rasterize,1,0,0,character,1
+gdalUtils,gdal_rasterize,2,0,0,double[],1
+gdalUtils,gdal_rasterize,3,0,0,any,1
+gdalUtils,gdal_rasterize,4,0,0,any,1
+gdalUtils,gdal_rasterize,5,0,0,double[],1
+gdalUtils,gdal_rasterize,6,0,0,any,1
+gdalUtils,gdal_rasterize,7,0,0,any,1
+gdalUtils,gdal_setInstallation,-1,0,0,null,1
+gdalUtils,gdal_setInstallation,0,0,0,null,1
+gdalUtils,gdal_setInstallation,1,0,0,logical,1
+gdalUtils,gdal_setInstallation,2,0,0,any,1
+gdalUtils,gdal_setInstallation,3,0,0,logical,1
+gdalUtils,gdalsrsinfo,-1,0,0,character,1
+gdalUtils,gdalsrsinfo,-1,0,1,class<`CRS`>,1
+gdalUtils,gdalsrsinfo,0,0,0,character,1
+gdalUtils,gdalsrsinfo,1,0,0,any,1
+gdalUtils,gdalsrsinfo,2,0,0,any,1
+gdalUtils,gdalsrsinfo,3,0,0,any,1
+gdalUtils,gdalsrsinfo,4,0,0,logical,1
+gdalUtils,gdalsrsinfo,5,0,0,logical,1
+gdalUtils,gdalsrsinfo,6,0,0,logical,1
+gdalUtils,gdaltindex,-1,0,0,class<`SpatialPolygonsDataFrame`>,1
+gdalUtils,gdaltindex,0,0,0,character,1
+gdalUtils,gdaltindex,1,0,0,character[],1
+gdalUtils,gdaltindex,2,0,0,any,1
+gdalUtils,gdaltindex,3,0,0,any,1
+gdalUtils,gdaltindex,4,0,0,any,1
+gdalUtils,gdaltindex,5,0,0,any,1
+gdalUtils,gdaltindex,6,0,0,any,1
+gdalUtils,gdaltindex,7,0,0,any,1
+gdalUtils,gdaltransform,-1,0,0,class<`matrix`>,1
+gdalUtils,gdaltransform,0,0,0,any,1
+gdalUtils,gdaltransform,1,0,0,any,1
+gdalUtils,gdaltransform,2,0,0,class<`matrix`>,1
+gdalUtils,gdaltransform,3,0,0,character,1
+gdalUtils,gdaltransform,4,0,0,character,1
+gdalUtils,gdaltransform,5,0,0,any,1
+gdalUtils,gdaltransform,6,0,0,any,1
+gdalUtils,gdaltransform,7,0,0,any,1
+gdalUtils,gdal_translate,-1,0,0,class<`RasterBrick`>,1
+gdalUtils,gdal_translate,-1,0,1,null,1
+gdalUtils,gdal_translate,0,0,0,character,1
+gdalUtils,gdal_translate,1,0,0,character,1
+gdalUtils,gdal_translate,2,0,0,any,1
+gdalUtils,gdal_translate,3,0,0,any,1
+gdalUtils,gdal_translate,4,0,0,character,1
+gdalUtils,gdal_translate,5,0,0,any,1
+gdalUtils,gdal_translate,6,0,0,any,1
+gdalUtils,gdal_translate,7,0,0,any,1
+gdalUtils,gdalwarp,-1,0,0,class<`RasterBrick`>,1
+gdalUtils,gdalwarp,0,0,0,character,1
+gdalUtils,gdalwarp,1,0,0,character,1
+gdalUtils,gdalwarp,2,0,0,any,1
+gdalUtils,gdalwarp,3,0,0,character,1
+gdalUtils,gdalwarp,4,0,0,any,1
+gdalUtils,gdalwarp,5,0,0,any,1
+gdalUtils,gdalwarp,6,0,0,any,1
+gdalUtils,gdalwarp,7,0,0,any,1
+gdalUtils,is.Raster,-1,0,0,logical,1
+gdalUtils,is.Raster,0,0,0,character,1
+gdalUtils,is.Raster,0,0,1,class<`RasterBrick`>,1
+gdalUtils,is.Raster,0,0,2,class<`RasterLayer`>,1
+gdalUtils,mosaic_rasters,-1,0,0,null,1
+gdalUtils,mosaic_rasters,0,0,0,character[],1
+gdalUtils,mosaic_rasters,1,0,0,character,1
+gdalUtils,mosaic_rasters,2,0,0,null,1
+gdalUtils,mosaic_rasters,3,0,0,logical,1
+gdalUtils,mosaic_rasters,4,0,0,logical,1
+gdalUtils,mosaic_rasters,5,0,0,null,1
+gdalUtils,mosaic_rasters,6,0,0,double,1
+gdalUtils,mosaic_rasters,7,0,0,list<character>,1
+gdalUtils,ogrinfo,-1,0,0,character[],1
+gdalUtils,ogrinfo,0,0,0,any,1
+gdalUtils,ogrinfo,1,0,0,any,1
+gdalUtils,ogrinfo,2,0,0,any,1
+gdalUtils,ogrinfo,3,0,0,any,1
+gdalUtils,ogrinfo,4,0,0,any,1
+gdalUtils,ogrinfo,5,0,0,any,1
+gdalUtils,ogrinfo,6,0,0,any,1
+gdalUtils,ogrinfo,7,0,0,any,1
+gdalUtils,ogrtindex,-1,0,0,class<`SpatialPolygonsDataFrame`>,1
+gdalUtils,ogrtindex,0,0,0,character,1
+gdalUtils,ogrtindex,1,0,0,character[],1
+gdalUtils,ogrtindex,2,0,0,any,1
+gdalUtils,ogrtindex,3,0,0,any,1
+gdalUtils,ogrtindex,4,0,0,any,1
+gdalUtils,ogrtindex,5,0,0,any,1
+gdalUtils,ogrtindex,6,0,0,any,1
+gdalUtils,ogrtindex,7,0,0,any,1
+gdalUtils,qm,-1,0,0,character[],1
+gdalUtils,qm,0,0,0,character[],1
+gdalUtils,qm,0,0,1,double[],1
+gdalUtils,remove_file_extension,-1,0,0,character,1
+gdalUtils,remove_file_extension,0,0,0,character,1
+gdalUtils,remove_file_extension,1,0,0,character,1
+gdata,ans,-1,0,0,null,1
+gdata,Args,-1,0,0,class<`data.frame`>,1
+gdata,Args,0,0,0,any,1
+gdata,Args,1,0,0,logical,1
+gdata,as.object_sizes,-1,0,0,any,1
+gdata,as.object_sizes,0,0,0,double[],1
+gdata,as.object_sizes,0,0,1,character,1
+gdata,as.object_sizes,0,0,2,complex,1
+gdata,as.object_sizes,0,0,3,list<any>,1
+gdata,as.object_sizes,0,0,4,null,1
+gdata,bindData,-1,0,0,class<`data.frame`>,1
+gdata,bindData,0,0,0,class<`data.frame`>,1
+gdata,bindData,1,0,0,class<`data.frame`>,1
+gdata,bindData,2,0,0,character[],1
+gdata,case,-1,0,0,class<`factor`>,1
+gdata,case,0,0,0,double[],1
+gdata,case,1,0,0,...,1
+gdata,case,2,0,0,character,1
+gdata,case,2,0,1,null,1
+gdata,cbindX,-1,0,0,class<`data.frame`>,1
+gdata,cbindX,-1,0,1,class<`matrix`>,1
+gdata,cbindX,0,0,0,...,1
+gdata,centerText,-1,0,0,character[],1
+gdata,centerText,0,0,0,character[],1
+gdata,centerText,1,0,0,integer,1
+gdata,.checkLevelsMap,-1,0,0,null,1
+gdata,.checkLevelsMap,0,0,0,class<`levelsMap`>,1
+gdata,.checkLevelsMap,1,0,0,character,1
+gdata,c.levelsMap,-1,0,0,class<`levelsMap`>,1
+gdata,c.levelsMap,0,0,0,...,1
+gdata,c.levelsMap,1,0,0,logical,1
+gdata,c.levelsMap,2,0,0,logical,1
+gdata,c.listLevelsMap,-1,0,0,class<`levelsMap`>,1
+gdata,c.listLevelsMap,0,0,0,...,1
+gdata,c.listLevelsMap,1,0,0,logical,1
+gdata,c.listLevelsMap,2,0,0,logical,1
+gdata,combine,-1,0,0,class<`data.frame`>,1
+gdata,combine,0,0,0,...,1
+gdata,combine,1,0,0,character[],1
+gdata,combine,1,0,1,null,1
+gdata,ConvertMedUnits,-1,0,0,double[],1
+gdata,ConvertMedUnits,0,0,0,double[],1
+gdata,ConvertMedUnits,1,0,0,character,1
+gdata,ConvertMedUnits,2,0,0,any,1
+gdata,ConvertMedUnits,3,0,0,character,1
+gdata,ConvertMedUnits,4,0,0,logical,1
+gdata,drop.levels,-1,0,0,class<`data.frame`>,1
+gdata,drop.levels,-1,0,1,class<`factor`>,1
+gdata,drop.levels,-1,0,2,list<class<`factor`> | integer[] | character[]>,1
+gdata,drop.levels,-1,0,3,character[],1
+gdata,drop.levels,-1,0,4,double[],1
+gdata,drop.levels,0,0,0,class<`data.frame`>,1
+gdata,drop.levels,0,0,1,class<`factor`>,1
+gdata,drop.levels,0,0,2,list<class<`factor`> | integer[] | character[]>,1
+gdata,drop.levels,0,0,3,character[],1
+gdata,drop.levels,0,0,4,double[],1
+gdata,drop.levels,1,0,0,any,1
+gdata,drop.levels,2,0,0,...,1
+gdata,drop.levels.data.frame,-1,0,0,class<`data.frame`>,1
+gdata,drop.levels.data.frame,0,0,0,class<`data.frame`>,1
+gdata,drop.levels.data.frame,1,0,0,logical,1
+gdata,drop.levels.data.frame,2,0,0,...,1
+gdata,drop.levels.default,-1,0,0,character[],1
+gdata,drop.levels.default,-1,0,1,double[],1
+gdata,drop.levels.default,0,0,0,character[],1
+gdata,drop.levels.default,0,0,1,double[],1
+gdata,drop.levels.default,1,0,0,any,1
+gdata,drop.levels.default,2,0,0,...,1
+gdata,drop.levels.factor,-1,0,0,class<`factor`>,1
+gdata,drop.levels.factor,0,0,0,class<`factor`>,1
+gdata,drop.levels.factor,1,0,0,logical,1
+gdata,drop.levels.factor,2,0,0,...,1
+gdata,drop.levels.list,-1,0,0,list<double[]>,1
+gdata,drop.levels.list,-1,0,1,list<class<`factor`> | integer[]>,1
+gdata,drop.levels.list,-1,0,2,list<class<`factor`>>,1
+gdata,drop.levels.list,-1,0,3,list<class<`factor`> | integer[] | character[]>,1
+gdata,drop.levels.list,0,0,0,class<`data.frame`>,1
+gdata,drop.levels.list,0,0,1,list<class<`factor`> | integer[] | character[]>,1
+gdata,drop.levels.list,1,0,0,any,1
+gdata,drop.levels.list,2,0,0,...,1
+gdata,duplicated2,-1,0,0,logical[],1
+gdata,duplicated2,0,0,0,class<`data.frame`>,1
+gdata,duplicated2,1,0,0,logical,1
+gdata,duplicated2,2,0,0,...,1
+gdata,findPerl,-1,0,0,character,1
+gdata,findPerl,0,0,0,any,1
+gdata,findPerl,1,0,0,character,1
+gdata,findPerl,1,0,1,logical,1
+gdata,first,-1,0,0,class<`data.frame`>,1
+gdata,first,-1,0,1,class<`matrix`>,1
+gdata,first,-1,0,2,integer,1
+gdata,first,-1,0,3,list<double>,1
+gdata,first,0,0,0,class<`data.frame`>,1
+gdata,first,0,0,1,class<`matrix`>,1
+gdata,first,0,0,2,integer[],1
+gdata,first,0,0,3,list<double>,1
+gdata,first,1,0,0,double,1
+gdata,first,2,0,0,...,1
+gdata,first<-,-1,0,0,class<`data.frame`>,1
+gdata,first<-,-1,0,1,class<`matrix`>,1
+gdata,first<-,-1,0,2,double[],1
+gdata,first<-,-1,0,3,list<character | double>,1
+gdata,first<-,0,0,0,class<`data.frame`>,1
+gdata,first<-,0,0,1,class<`matrix`>,1
+gdata,first<-,0,0,2,integer[],1
+gdata,first<-,0,0,3,list<double>,1
+gdata,first<-,1,0,0,double,1
+gdata,first<-,2,0,0,...,1
+gdata,first<-,3,0,0,class<`factor`>,1
+gdata,first<-,3,0,1,character,1
+gdata,first<-,3,0,2,double,1
+gdata,format.object_sizes,-1,0,0,character[],1
+gdata,format.object_sizes,0,0,0,"class<`numeric`, `object_sizes`>",1
+gdata,format.object_sizes,1,0,0,any,1
+gdata,format.object_sizes,2,0,0,character,1
+gdata,format.object_sizes,3,0,0,any,1
+gdata,format.object_sizes,4,0,0,double,1
+gdata,format.object_sizes,5,0,0,null,1
+gdata,format.object_sizes,6,0,0,character,1
+gdata,format.object_sizes,7,0,0,any,1
+gdata,format.object_sizes,8,0,0,...,1
+gdata,frameApply,-1,0,0,class<`data.frame`>,1
+gdata,frameApply,0,0,0,class<`data.frame`>,1
+gdata,frameApply,1,0,0,character[],1
+gdata,frameApply,2,0,0,character[],1
+gdata,frameApply,3,0,0,class<`function`>,1
+gdata,frameApply,4,0,0,any,1
+gdata,frameApply,5,0,0,logical,1
+gdata,frameApply,6,0,0,character,1
+gdata,frameApply,7,0,0,...,1
+gdata,getDay,-1,0,0,character,1
+gdata,getDay,0,0,0,class<`Date`>,1
+gdata,getDay,0,0,1,"class<`POSIXct`, `POSIXt`>",1
+gdata,getDay,0,0,2,"class<`POSIXlt`, `POSIXt`>",1
+gdata,getDay,1,0,0,any,1
+gdata,getDay,2,0,0,...,1
+gdata,getDay.Date,-1,0,0,character,1
+gdata,getDay.Date,0,0,0,class<`Date`>,1
+gdata,getDay.Date,0,0,1,"class<`POSIXct`, `POSIXt`>",1
+gdata,getDay.Date,0,0,2,"class<`POSIXlt`, `POSIXt`>",1
+gdata,getDay.Date,1,0,0,character,1
+gdata,getDay.Date,2,0,0,...,1
+gdata,getDay.POSIXct,-1,0,0,character,1
+gdata,getDay.POSIXct,0,0,0,class<`Date`>,1
+gdata,getDay.POSIXct,0,0,1,"class<`POSIXct`, `POSIXt`>",1
+gdata,getDay.POSIXct,0,0,2,"class<`POSIXlt`, `POSIXt`>",1
+gdata,getDay.POSIXct,1,0,0,character,1
+gdata,getDay.POSIXct,2,0,0,...,1
+gdata,getDay.POSIXlt,-1,0,0,character,1
+gdata,getDay.POSIXlt,0,0,0,class<`Date`>,1
+gdata,getDay.POSIXlt,0,0,1,"class<`POSIXct`, `POSIXt`>",1
+gdata,getDay.POSIXlt,0,0,2,"class<`POSIXlt`, `POSIXt`>",1
+gdata,getDay.POSIXlt,1,0,0,character,1
+gdata,getDay.POSIXlt,2,0,0,...,1
+gdata,getMonth,-1,0,0,character,1
+gdata,getMonth,0,0,0,class<`Date`>,1
+gdata,getMonth,0,0,1,"class<`POSIXct`, `POSIXt`>",1
+gdata,getMonth,0,0,2,"class<`POSIXlt`, `POSIXt`>",1
+gdata,getMonth,1,0,0,any,1
+gdata,getMonth,2,0,0,...,1
+gdata,getMonth.Date,-1,0,0,character,1
+gdata,getMonth.Date,0,0,0,class<`Date`>,1
+gdata,getMonth.Date,0,0,1,"class<`POSIXct`, `POSIXt`>",1
+gdata,getMonth.Date,0,0,2,"class<`POSIXlt`, `POSIXt`>",1
+gdata,getMonth.Date,1,0,0,character,1
+gdata,getMonth.Date,2,0,0,...,1
+gdata,getMonth.POSIXct,-1,0,0,character,1
+gdata,getMonth.POSIXct,0,0,0,class<`Date`>,1
+gdata,getMonth.POSIXct,0,0,1,"class<`POSIXct`, `POSIXt`>",1
+gdata,getMonth.POSIXct,0,0,2,"class<`POSIXlt`, `POSIXt`>",1
+gdata,getMonth.POSIXct,1,0,0,character,1
+gdata,getMonth.POSIXct,2,0,0,...,1
+gdata,getMonth.POSIXlt,-1,0,0,character,1
+gdata,getMonth.POSIXlt,0,0,0,class<`Date`>,1
+gdata,getMonth.POSIXlt,0,0,1,"class<`POSIXct`, `POSIXt`>",1
+gdata,getMonth.POSIXlt,0,0,2,"class<`POSIXlt`, `POSIXt`>",1
+gdata,getMonth.POSIXlt,1,0,0,character,1
+gdata,getMonth.POSIXlt,2,0,0,...,1
+gdata,getYear,-1,0,0,character,1
+gdata,getYear,0,0,0,class<`Date`>,1
+gdata,getYear,0,0,1,"class<`POSIXct`, `POSIXt`>",1
+gdata,getYear,0,0,2,"class<`POSIXlt`, `POSIXt`>",1
+gdata,getYear,1,0,0,any,1
+gdata,getYear,2,0,0,...,1
+gdata,getYear.Date,-1,0,0,character,1
+gdata,getYear.Date,0,0,0,class<`Date`>,1
+gdata,getYear.Date,0,0,1,"class<`POSIXct`, `POSIXt`>",1
+gdata,getYear.Date,0,0,2,"class<`POSIXlt`, `POSIXt`>",1
+gdata,getYear.Date,1,0,0,character,1
+gdata,getYear.Date,2,0,0,...,1
+gdata,getYear.POSIXct,-1,0,0,character,1
+gdata,getYear.POSIXct,0,0,0,class<`Date`>,1
+gdata,getYear.POSIXct,0,0,1,"class<`POSIXct`, `POSIXt`>",1
+gdata,getYear.POSIXct,0,0,2,"class<`POSIXlt`, `POSIXt`>",1
+gdata,getYear.POSIXct,1,0,0,character,1
+gdata,getYear.POSIXct,2,0,0,...,1
+gdata,getYear.POSIXlt,-1,0,0,character,1
+gdata,getYear.POSIXlt,0,0,0,class<`Date`>,1
+gdata,getYear.POSIXlt,0,0,1,"class<`POSIXct`, `POSIXt`>",1
+gdata,getYear.POSIXlt,0,0,2,"class<`POSIXlt`, `POSIXt`>",1
+gdata,getYear.POSIXlt,1,0,0,character,1
+gdata,getYear.POSIXlt,2,0,0,...,1
+gdata,humanReadable,-1,0,0,character[],1
+gdata,humanReadable,0,0,0,"class<`numeric`, `object_sizes`>",1
+gdata,humanReadable,0,0,1,double[],1
+gdata,humanReadable,1,0,0,any,1
+gdata,humanReadable,2,0,0,character[],1
+gdata,humanReadable,3,0,0,double,1
+gdata,humanReadable,4,0,0,null,1
+gdata,humanReadable,4,0,1,double,1
+gdata,humanReadable,5,0,0,character,1
+gdata,humanReadable,6,0,0,character[],1
+gdata,interleave,-1,0,0,class<`matrix`>,1
+gdata,interleave,-1,0,1,integer[],1
+gdata,interleave,0,0,0,...,1
+gdata,interleave,1,0,0,logical,1
+gdata,interleave,2,0,0,character,1
+gdata,interleave,3,0,0,logical,1
+gdata,is.levelsMap,-1,0,0,logical,1
+gdata,is.levelsMap,0,0,0,class<`levelsMap`>,1
+gdata,is.listLevelsMap,-1,0,0,logical,1
+gdata,is.listLevelsMap,0,0,0,class<`listLevelsMap`>,1
+gdata,is.object_sizes,-1,0,0,logical,1
+gdata,is.object_sizes,0,0,0,"class<`numeric`, `object_sizes`>",1
+gdata,isUnknown,-1,0,0,logical[],1
+gdata,isUnknown,-1,0,1,list<logical[]>,1
+gdata,isUnknown,0,0,0,class<`factor`>,1
+gdata,isUnknown,0,0,1,^double[],1
+gdata,isUnknown,0,0,2,list<^double[] | class<`factor`>>,1
+gdata,isUnknown,0,0,3,list<class<`factor`> | double[]>,1
+gdata,isUnknown,1,0,0,^character[],1
+gdata,isUnknown,1,0,1,^double[],1
+gdata,isUnknown,1,0,2,null,1
+gdata,isUnknown,1,0,3,list<character | double>,1
+gdata,isUnknown,1,0,4,list<double | character>,1
+gdata,isUnknown,2,0,0,...,1
+gdata,isUnknown.default,-1,0,0,logical[],1
+gdata,isUnknown.default,0,0,0,class<`factor`>,1
+gdata,isUnknown.default,0,0,1,^double[],1
+gdata,isUnknown.default,1,0,0,^character[],1
+gdata,isUnknown.default,1,0,1,^double[],1
+gdata,isUnknown.default,1,0,2,null,1
+gdata,isUnknown.default,2,0,0,...,1
+gdata,isUnknown.list,-1,0,0,list<logical[]>,1
+gdata,isUnknown.list,0,0,0,list<^double[] | class<`factor`>>,1
+gdata,isUnknown.list,0,0,1,list<class<`factor`> | double[]>,1
+gdata,isUnknown.list,1,0,0,^double[],1
+gdata,isUnknown.list,1,0,1,character[],1
+gdata,isUnknown.list,1,0,2,list<character | double>,1
+gdata,isUnknown.list,1,0,3,list<double | character>,1
+gdata,isUnknown.list,2,0,0,...,1
+gdata,is.what,-1,0,0,character[],1
+gdata,is.what,-1,0,1,class<`data.frame`>,1
+gdata,is.what,0,0,0,class<`function`>,1
+gdata,is.what,0,0,1,class<`lm`>,1
+gdata,is.what,0,0,2,double,1
+gdata,is.what,0,0,3,null,1
+gdata,is.what,1,0,0,logical,1
+gdata,keep,-1,0,0,character[],1
+gdata,keep,0,0,0,...,1
+gdata,keep,1,0,0,character[],1
+gdata,keep,2,0,0,logical,1
+gdata,keep,3,0,0,logical,1
+gdata,last,-1,0,0,class<`data.frame`>,1
+gdata,last,-1,0,1,class<`matrix`>,1
+gdata,last,-1,0,2,integer,1
+gdata,last,-1,0,3,list<double>,1
+gdata,last,0,0,0,class<`data.frame`>,1
+gdata,last,0,0,1,class<`matrix`>,1
+gdata,last,0,0,2,integer[],1
+gdata,last,0,0,3,list<double>,1
+gdata,last,1,0,0,double,1
+gdata,last,2,0,0,...,1
+gdata,last<-,-1,0,0,class<`data.frame`>,1
+gdata,last<-,-1,0,1,class<`matrix`>,1
+gdata,last<-,-1,0,2,double[],1
+gdata,last<-,-1,0,3,list<character | double>,1
+gdata,last<-,0,0,0,class<`data.frame`>,1
+gdata,last<-,0,0,1,class<`matrix`>,1
+gdata,last<-,0,0,2,double[],1
+gdata,last<-,0,0,3,list<character | double>,1
+gdata,last<-,1,0,0,double,1
+gdata,last<-,2,0,0,...,1
+gdata,last<-,3,0,0,list<double[]>,1
+gdata,last<-,3,0,1,character,1
+gdata,last<-,3,0,2,double,1
+gdata,left,-1,0,0,class<`data.frame`>,1
+gdata,left,-1,0,1,class<`matrix`>,1
+gdata,left,0,0,0,class<`data.frame`>,1
+gdata,left,0,0,1,class<`matrix`>,1
+gdata,left,1,0,0,integer,1
+gdata,left.data.frame,-1,0,0,class<`data.frame`>,1
+gdata,left.data.frame,-1,0,1,class<`matrix`>,1
+gdata,left.data.frame,0,0,0,class<`data.frame`>,1
+gdata,left.data.frame,0,0,1,class<`matrix`>,1
+gdata,left.data.frame,1,0,0,double,1
+gdata,left.matrix,-1,0,0,class<`data.frame`>,1
+gdata,left.matrix,-1,0,1,class<`matrix`>,1
+gdata,left.matrix,0,0,0,class<`data.frame`>,1
+gdata,left.matrix,0,0,1,class<`matrix`>,1
+gdata,left.matrix,1,0,0,double,1
+gdata,[.levelsMap,-1,0,0,class<`levelsMap`>,1
+gdata,[.levelsMap,0,0,0,class<`levelsMap`>,1
+gdata,[.levelsMap,1,0,0,integer[],1
+gdata,ll,-1,0,0,class<`data.frame`>,1
+gdata,ll,0,0,0,character,1
+gdata,ll,0,0,1,double,1
+gdata,ll,0,0,2,class<`data.frame`>,1
+gdata,ll,0,0,3,class<`family`>,1
+gdata,ll,0,0,4,"class<`glm`, `lm`>",1
+gdata,ll,1,0,0,character,1
+gdata,ll,2,0,0,double,1
+gdata,ll,3,0,0,logical,1
+gdata,ll,4,0,0,logical,1
+gdata,ll,5,0,0,null,1
+gdata,ll,5,0,1,character,1
+gdata,ll,6,0,0,logical,1
+gdata,ll,7,0,0,...,1
+gdata,lowerTriangle,-1,0,0,integer[],1
+gdata,lowerTriangle,0,0,0,class<`matrix`>,1
+gdata,lowerTriangle,1,0,0,logical,1
+gdata,lowerTriangle,2,0,0,logical,1
+gdata,lowerTriangle<-,-1,0,0,class<`matrix`>,1
+gdata,lowerTriangle<-,0,0,0,class<`matrix`>,1
+gdata,lowerTriangle<-,1,0,0,logical,1
+gdata,lowerTriangle<-,2,0,0,logical,1
+gdata,lowerTriangle<-,3,0,0,character[],1
+gdata,lowerTriangle<-,3,0,1,integer[],1
+gdata,lowerTriangle<-,3,0,2,null,1
+gdata,ls.funs,-1,0,0,character[],1
+gdata,ls.funs,0,0,0,...,1
+gdata,mapLevels,-1,0,0,class<`levelsMap`>,1
+gdata,mapLevels,0,0,0,class<`factor`>,1
+gdata,mapLevels,0,0,1,character,1
+gdata,mapLevels,0,0,2,list<class<`factor`>>,1
+gdata,mapLevels,1,0,0,logical,1
+gdata,mapLevels,2,0,0,any,1
+gdata,mapLevels,3,0,0,logical,1
+gdata,mapLevels,4,0,0,logical,1
+gdata,mapLevels,5,0,0,...,1
+gdata,mapLevels<-,-1,0,0,class<`factor`>,1
+gdata,mapLevels<-,0,0,0,character[],1
+gdata,mapLevels<-,0,0,1,class<`factor`>,1
+gdata,mapLevels<-,0,0,2,integer[],1
+gdata,mapLevels<-,1,0,0,class<`levelsMap`>,1
+gdata,mapLevels.character,-1,0,0,class<`levelsMap`>,1
+gdata,mapLevels.character,0,0,0,character,1
+gdata,mapLevels.character,1,0,0,logical,1
+gdata,mapLevels.character,2,0,0,logical,1
+gdata,mapLevels.character,3,0,0,logical,1
+gdata,mapLevels.character,4,0,0,logical,1
+gdata,mapLevels.character,5,0,0,...,1
+gdata,mapLevels<-.default,-1,0,0,class<`factor`>,1
+gdata,mapLevels<-.default,0,0,0,character[],1
+gdata,mapLevels<-.default,0,0,1,class<`factor`>,1
+gdata,mapLevels<-.default,0,0,2,integer[],1
+gdata,mapLevels<-.default,1,0,0,class<`levelsMap`>,1
+gdata,mapLevels.factor,-1,0,0,class<`levelsMap`>,1
+gdata,mapLevels.factor,0,0,0,character,1
+gdata,mapLevels.factor,0,0,1,class<`factor`>,1
+gdata,mapLevels.factor,1,0,0,logical,1
+gdata,mapLevels.factor,2,0,0,any,1
+gdata,mapLevels.factor,3,0,0,any,1
+gdata,mapLevels.factor,4,0,0,logical,1
+gdata,mapLevels.factor,5,0,0,...,1
+gdata,mapLevels.list,-1,0,0,class<`levelsMap`>,1
+gdata,mapLevels.list,0,0,0,list<class<`factor`>>,1
+gdata,mapLevels.list,1,0,0,logical,1
+gdata,mapLevels.list,2,0,0,logical,1
+gdata,mapLevels.list,3,0,0,logical,1
+gdata,mapLevels.list,4,0,0,logical,1
+gdata,mapLevels.list,5,0,0,...,1
+gdata,matchcols,-1,0,0,character[],1
+gdata,matchcols,0,0,0,class<`matrix`>,1
+gdata,matchcols,1,0,0,character[],1
+gdata,matchcols,2,0,0,any,1
+gdata,matchcols,3,0,0,character[],1
+gdata,matchcols,4,0,0,...,1
+gdata,mv,-1,0,0,null,1
+gdata,mv,0,0,0,character,1
+gdata,mv,1,0,0,character,1
+gdata,mv,2,0,0,environment,1
+gdata,NAToUnknown,-1,0,0,class<`factor`>,1
+gdata,NAToUnknown,-1,0,1,double[],1
+gdata,NAToUnknown,-1,0,2,list<double[] | class<`factor`>>,1
+gdata,NAToUnknown,-1,0,3,list<class<`factor`> | double[]>,1
+gdata,NAToUnknown,0,0,0,class<`factor`>,1
+gdata,NAToUnknown,0,0,1,^double[],1
+gdata,NAToUnknown,0,0,2,list<^double[] | class<`factor`>>,1
+gdata,NAToUnknown,0,0,3,list<class<`factor`> | ^double[]>,1
+gdata,NAToUnknown,1,0,0,character,1
+gdata,NAToUnknown,1,0,1,double,1
+gdata,NAToUnknown,1,0,2,list<character | double>,1
+gdata,NAToUnknown,2,0,0,logical,1
+gdata,NAToUnknown,3,0,0,logical,1
+gdata,NAToUnknown,4,0,0,...,1
+gdata,NAToUnknown.default,-1,0,0,double[],1
+gdata,NAToUnknown.default,0,0,0,^double[],1
+gdata,NAToUnknown.default,1,0,0,double,1
+gdata,NAToUnknown.default,2,0,0,logical,1
+gdata,NAToUnknown.default,3,0,0,logical,1
+gdata,NAToUnknown.default,4,0,0,...,1
+gdata,NAToUnknown.factor,-1,0,0,class<`factor`>,1
+gdata,NAToUnknown.factor,0,0,0,class<`factor`>,1
+gdata,NAToUnknown.factor,1,0,0,character,1
+gdata,NAToUnknown.factor,1,0,1,double,1
+gdata,NAToUnknown.factor,2,0,0,logical,1
+gdata,NAToUnknown.factor,3,0,0,logical,1
+gdata,NAToUnknown.factor,4,0,0,...,1
+gdata,NAToUnknown.list,-1,0,0,list<double[] | class<`factor`>>,1
+gdata,NAToUnknown.list,-1,0,1,list<class<`factor`> | double[]>,1
+gdata,NAToUnknown.list,0,0,0,list<^double[] | class<`factor`>>,1
+gdata,NAToUnknown.list,0,0,1,list<class<`factor`> | ^double[]>,1
+gdata,NAToUnknown.list,1,0,0,list<character | double>,1
+gdata,NAToUnknown.list,1,0,1,double,1
+gdata,NAToUnknown.list,2,0,0,logical,1
+gdata,NAToUnknown.list,3,0,0,logical,1
+gdata,NAToUnknown.list,4,0,0,...,1
+gdata,nobs,-1,0,0,integer[],1
+gdata,nobs,0,0,0,class<`lm`>,1
+gdata,nobs,0,0,1,^double[],1
+gdata,nobs,0,0,2,class<`data.frame`>,1
+gdata,nobs,1,0,0,...,1
+gdata,nobs.data.frame,-1,0,0,integer[],1
+gdata,nobs.data.frame,0,0,0,class<`data.frame`>,1
+gdata,nobs.data.frame,1,0,0,...,1
+gdata,nobs.default,-1,0,0,integer,1
+gdata,nobs.default,0,0,0,^double[],1
+gdata,nobs.default,1,0,0,...,1
+gdata,nPairs,-1,0,0,"class<`matrix`, `nPairs`>",1
+gdata,nPairs,0,0,0,class<`data.frame`>,1
+gdata,nPairs,1,0,0,logical,1
+gdata,nPairs,2,0,0,logical,1
+gdata,nPairs,3,0,0,logical,1
+gdata,nPairs,4,0,0,...,1
+gdata,object.size,-1,0,0,"class<`numeric`, `object_sizes`>",1
+gdata,object.size,0,0,0,...,1
+gdata,print.object_sizes,-1,0,0,"class<`numeric`, `object_sizes`>",1
+gdata,print.object_sizes,0,0,0,"class<`numeric`, `object_sizes`>",1
+gdata,print.object_sizes,1,0,0,logical,1
+gdata,print.object_sizes,2,0,0,logical,1
+gdata,print.object_sizes,3,0,0,character,1
+gdata,print.object_sizes,4,0,0,any,1
+gdata,print.object_sizes,5,0,0,double,1
+gdata,print.object_sizes,6,0,0,null,1
+gdata,print.object_sizes,7,0,0,character,1
+gdata,print.object_sizes,8,0,0,character[],1
+gdata,print.object_sizes,9,0,0,...,1
+gdata,read.xls,-1,0,0,class<`data.frame`>,1
+gdata,read.xls,0,0,0,character,1
+gdata,read.xls,1,0,0,character,1
+gdata,read.xls,1,0,1,double,1
+gdata,read.xls,2,0,0,logical,1
+gdata,read.xls,3,0,0,any,1
+gdata,read.xls,4,0,0,character[],1
+gdata,read.xls,5,0,0,...,1
+gdata,read.xls,6,0,0,character[],1
+gdata,read.xls,7,0,0,character,1
+gdata,remove.vars,-1,0,0,class<`data.frame`>,1
+gdata,remove.vars,0,0,0,class<`data.frame`>,1
+gdata,remove.vars,1,0,0,character,1
+gdata,remove.vars,2,0,0,logical,1
+gdata,rename.vars,-1,0,0,class<`data.frame`>,1
+gdata,rename.vars,0,0,0,class<`data.frame`>,1
+gdata,rename.vars,1,0,0,character[],1
+gdata,rename.vars,2,0,0,character[],1
+gdata,rename.vars,3,0,0,logical,1
+gdata,reorder.factor,-1,0,0,class<`factor`>,1
+gdata,reorder.factor,0,0,0,class<`factor`>,1
+gdata,reorder.factor,1,0,0,any,1
+gdata,reorder.factor,2,0,0,any,1
+gdata,reorder.factor,3,0,0,...,1
+gdata,reorder.factor,4,0,0,logical,1
+gdata,reorder.factor,5,0,0,any,1
+gdata,reorder.factor,6,0,0,any,1
+gdata,resample,-1,0,0,double[],1
+gdata,resample,0,0,0,double[],1
+gdata,resample,1,0,0,any,1
+gdata,resample,2,0,0,logical,1
+gdata,resample,3,0,0,null,1
+gdata,right,-1,0,0,class<`data.frame`>,1
+gdata,right,-1,0,1,class<`matrix`>,1
+gdata,right,0,0,0,class<`data.frame`>,1
+gdata,right,0,0,1,class<`matrix`>,1
+gdata,right,1,0,0,integer,1
+gdata,sheetCmd,-1,0,0,character[],1
+gdata,sheetCmd,-1,0,1,integer,1
+gdata,sheetCmd,0,0,0,character,1
+gdata,sheetCmd,1,0,0,character,1
+gdata,sheetCmd,2,0,0,logical,1
+gdata,sheetCmd,3,0,0,character,1
+gdata,sheetCount,-1,0,0,integer,1
+gdata,sheetCount,0,0,0,character,1
+gdata,sheetCount,1,0,0,logical,1
+gdata,sheetCount,2,0,0,character,1
+gdata,sheetNames,-1,0,0,character[],1
+gdata,sheetNames,0,0,0,character,1
+gdata,sheetNames,1,0,0,logical,1
+gdata,sheetNames,2,0,0,character,1
+gdata,sort.levelsMap,-1,0,0,class<`levelsMap`>,1
+gdata,sort.levelsMap,0,0,0,class<`levelsMap`>,1
+gdata,sort.levelsMap,1,0,0,logical,1
+gdata,sort.levelsMap,2,0,0,logical,1
+gdata,sort.levelsMap,3,0,0,...,1
+gdata,startsWith,-1,0,0,logical[],1
+gdata,startsWith,0,0,0,character[],1
+gdata,startsWith,1,0,0,character,1
+gdata,startsWith,2,0,0,logical,1
+gdata,startsWith,3,0,0,logical,1
+gdata,summary.nPairs,-1,0,0,class<`matrix`>,1
+gdata,summary.nPairs,0,0,0,"class<`matrix`, `nPairs`>",1
+gdata,summary.nPairs,1,0,0,...,1
+gdata,trim,-1,0,0,character[],1
+gdata,trim,-1,0,1,class<`factor`>,1
+gdata,trim,-1,0,2,integer[],1
+gdata,trim,-1,0,3,class<`data.frame`>,1
+gdata,trim,-1,0,4,list<character[] | class<`factor`> | integer[]>,1
+gdata,trim,0,0,0,character[],1
+gdata,trim,0,0,1,class<`factor`>,1
+gdata,trim,0,0,2,integer[],1
+gdata,trim,0,0,3,class<`data.frame`>,1
+gdata,trim,0,0,4,list<character[] | class<`factor`> | integer[]>,1
+gdata,trim,1,0,0,any,1
+gdata,trim,2,0,0,...,1
+gdata,trim.character,-1,0,0,character[],1
+gdata,trim.character,0,0,0,character[],1
+gdata,trim.character,1,0,0,any,1
+gdata,trim.character,2,0,0,...,1
+gdata,trim.data.frame,-1,0,0,class<`data.frame`>,1
+gdata,trim.data.frame,0,0,0,class<`data.frame`>,1
+gdata,trim.data.frame,1,0,0,logical,1
+gdata,trim.data.frame,2,0,0,...,1
+gdata,trim.default,-1,0,0,integer[],1
+gdata,trim.default,0,0,0,integer[],1
+gdata,trim.default,1,0,0,logical,1
+gdata,trim.default,2,0,0,...,1
+gdata,trim.factor,-1,0,0,class<`factor`>,1
+gdata,trim.factor,0,0,0,class<`factor`>,1
+gdata,trim.factor,1,0,0,logical,1
+gdata,trim.factor,2,0,0,...,1
+gdata,trim.list,-1,0,0,list<class<`factor`> | integer[]>,1
+gdata,trim.list,-1,0,1,list<character[] | class<`factor`> | integer[]>,1
+gdata,trim.list,0,0,0,class<`data.frame`>,1
+gdata,trim.list,0,0,1,list<character[] | class<`factor`> | integer[]>,1
+gdata,trim.list,1,0,0,logical,1
+gdata,trim.list,2,0,0,...,1
+gdata,trimSum,-1,0,0,^integer[],1
+gdata,trimSum,0,0,0,^integer[],1
+gdata,trimSum,1,0,0,double,1
+gdata,trimSum,2,0,0,logical,1
+gdata,trimSum,3,0,0,logical,1
+gdata,trimSum,4,0,0,...,1
+gdata,unique.levelsMap,-1,0,0,class<`levelsMap`>,1
+gdata,unique.levelsMap,0,0,0,class<`levelsMap`>,1
+gdata,unique.levelsMap,1,0,0,logical,1
+gdata,unique.levelsMap,2,0,0,...,1
+gdata,.unknownList,-1,0,0,character[],1
+gdata,.unknownList,-1,0,1,^double[],1
+gdata,.unknownList,-1,0,2,list<double | character[]>,1
+gdata,.unknownList,-1,0,3,list<double | character>,1
+gdata,.unknownList,-1,0,4,list<character | double>,1
+gdata,.unknownList,0,0,0,list<class<`factor`> | double[]>,1
+gdata,.unknownList,0,0,1,list<^double[] | class<`factor`>>,1
+gdata,.unknownList,0,0,2,list<class<`factor`> | ^double[]>,1
+gdata,.unknownList,0,0,3,class<`data.frame`>,1
+gdata,.unknownList,1,0,0,character[],1
+gdata,.unknownList,1,0,1,^double[],1
+gdata,.unknownList,1,0,2,list<character[] | double>,1
+gdata,.unknownList,1,0,3,list<character | double>,1
+gdata,.unknownList,1,0,4,list<double | character>,1
+gdata,unknownToNA,-1,0,0,class<`data.frame`>,1
+gdata,unknownToNA,-1,0,1,class<`factor`>,1
+gdata,unknownToNA,-1,0,2,^double[],1
+gdata,unknownToNA,-1,0,3,list<^double[] | class<`factor`>>,1
+gdata,unknownToNA,-1,0,4,list<class<`factor`> | ^double[]>,1
+gdata,unknownToNA,0,0,0,class<`data.frame`>,1
+gdata,unknownToNA,0,0,1,class<`factor`>,1
+gdata,unknownToNA,0,0,2,^double[],1
+gdata,unknownToNA,0,0,3,list<^double[] | class<`factor`>>,1
+gdata,unknownToNA,0,0,4,list<class<`factor`> | double[]>,1
+gdata,unknownToNA,1,0,0,list<double | character>,1
+gdata,unknownToNA,1,0,1,double,1
+gdata,unknownToNA,1,0,2,list<character[] | double>,1
+gdata,unknownToNA,1,0,3,character[],1
+gdata,unknownToNA,2,0,0,logical,1
+gdata,unknownToNA,3,0,0,...,1
+gdata,unknownToNA.data.frame,-1,0,0,class<`data.frame`>,1
+gdata,unknownToNA.data.frame,0,0,0,class<`data.frame`>,1
+gdata,unknownToNA.data.frame,1,0,0,list<double | character>,1
+gdata,unknownToNA.data.frame,2,0,0,logical,1
+gdata,unknownToNA.data.frame,3,0,0,...,1
+gdata,unknownToNA.default,-1,0,0,^double[],1
+gdata,unknownToNA.default,0,0,0,^double[],1
+gdata,unknownToNA.default,1,0,0,double,1
+gdata,unknownToNA.default,2,0,0,logical,1
+gdata,unknownToNA.default,3,0,0,...,1
+gdata,unknownToNA.factor,-1,0,0,class<`factor`>,1
+gdata,unknownToNA.factor,0,0,0,class<`factor`>,1
+gdata,unknownToNA.factor,1,0,0,character[],1
+gdata,unknownToNA.factor,1,0,1,double,1
+gdata,unknownToNA.factor,2,0,0,logical,1
+gdata,unknownToNA.factor,3,0,0,...,1
+gdata,unknownToNA.list,-1,0,0,list<^double[] | class<`factor`>>,1
+gdata,unknownToNA.list,-1,0,1,list<class<`factor`> | ^double[]>,1
+gdata,unknownToNA.list,0,0,0,class<`data.frame`>,1
+gdata,unknownToNA.list,0,0,1,list<^double[] | class<`factor`>>,1
+gdata,unknownToNA.list,0,0,2,list<class<`factor`> | double[]>,1
+gdata,unknownToNA.list,1,0,0,list<double | character>,1
+gdata,unknownToNA.list,1,0,1,list<character[] | double>,1
+gdata,unknownToNA.list,2,0,0,logical,1
+gdata,unknownToNA.list,3,0,0,...,1
+gdata,.unlistLevelsMap,-1,0,0,list<character[] | integer[]>,1
+gdata,.unlistLevelsMap,0,0,0,class<`levelsMap`>,1
+gdata,.unlistLevelsMap,1,0,0,logical,1
+gdata,unmatrix,-1,0,0,character[],1
+gdata,unmatrix,-1,0,1,double[],1
+gdata,unmatrix,0,0,0,class<`matrix`>,1
+gdata,unmatrix,1,0,0,logical,1
+gdata,update.list,-1,0,0,list<double | character>,1
+gdata,update.list,0,0,0,list<double | character>,1
+gdata,update.list,1,0,0,list<character | double>,1
+gdata,update.list,2,0,0,logical,1
+gdata,update.list,3,0,0,...,1
+gdata,upperTriangle,-1,0,0,character[],1
+gdata,upperTriangle,-1,0,1,integer[],1
+gdata,upperTriangle,0,0,0,class<`matrix`>,1
+gdata,upperTriangle,1,0,0,logical,1
+gdata,upperTriangle,2,0,0,logical,1
+gdata,upperTriangle<-,-1,0,0,class<`matrix`>,1
+gdata,upperTriangle<-,0,0,0,class<`matrix`>,1
+gdata,upperTriangle<-,1,0,0,logical,1
+gdata,upperTriangle<-,2,0,0,logical,1
+gdata,upperTriangle<-,3,0,0,integer[],1
+gdata,upperTriangle<-,3,0,1,null,1
+gdata,wideByFactor,-1,0,0,class<`data.frame`>,1
+gdata,wideByFactor,0,0,0,class<`data.frame`>,1
+gdata,wideByFactor,1,0,0,character,1
+gdata,wideByFactor,2,0,0,character[],1
+gdata,wideByFactor,3,0,0,logical,1
+gdata,wideByFactor,4,0,0,logical,1
+gdata,write.fwf,-1,0,0,class<`data.frame`>,1
+gdata,write.fwf,-1,0,1,null,1
+gdata,write.fwf,0,0,0,class<`data.frame`>,1
+gdata,write.fwf,1,0,0,character,1
+gdata,write.fwf,2,0,0,logical,1
+gdata,write.fwf,3,0,0,logical,1
+gdata,write.fwf,4,0,0,character,1
+gdata,write.fwf,5,0,0,character,1
+gdata,write.fwf,6,0,0,logical,1
+gdata,write.fwf,7,0,0,logical,1
+gdata,write.fwf,8,0,0,null,1
+gdata,write.fwf,8,0,1,character,1
+gdata,write.fwf,9,0,0,character,1
+gdata,write.fwf,10,0,0,logical,1
+gdata,write.fwf,11,0,0,logical,1
+gdata,write.fwf,12,0,0,null,1
+gdata,write.fwf,12,0,1,double,1
+gdata,write.fwf,13,0,0,character,1
+gdata,write.fwf,14,0,0,character[],1
+gdata,write.fwf,15,0,0,logical,1
+gdata,xls2sep,-1,0,0,"class<`connection`, `file`>",1
+gdata,xls2sep,0,0,0,character,1
+gdata,xls2sep,1,0,0,character,1
+gdata,xls2sep,1,0,1,double,1
+gdata,xls2sep,2,0,0,logical,1
+gdata,xls2sep,3,0,0,logical,1
+gdata,xls2sep,4,0,0,...,1
+gdata,xls2sep,5,0,0,character,1
+gdata,xls2sep,6,0,0,character,1
+gdata,xlsFormats,-1,0,0,character[],1
+gdata,xlsFormats,0,0,0,character,1
+gdata,xlsFormats,1,0,0,logical,1
+gdtools,base64_raster_encode,-1,0,0,character,1
+gdtools,base64_raster_encode,0,0,0,class<`raster`>,1
+gdtools,base64_raster_encode,1,0,0,integer,1
+gdtools,base64_raster_encode,2,0,0,integer,1
+gdtools,base64_raster_encode,3,0,0,double,1
+gdtools,base64_raster_encode,4,0,0,double,1
+gdtools,base64_raster_encode,5,0,0,logical,1
+gdtools,font_family_exists,-1,0,0,logical,1
+gdtools,font_family_exists,0,0,0,character,1
+gdtools,glyphs_match,-1,0,0,logical[],1
+gdtools,glyphs_match,0,0,0,character[],1
+gdtools,glyphs_match,1,0,0,character,1
+gdtools,glyphs_match,2,0,0,logical,1
+gdtools,glyphs_match,3,0,0,logical,1
+gdtools,glyphs_match,4,0,0,character,1
+gdtools,glyphs_match_,-1,0,0,logical[],1
+gdtools,glyphs_match_,0,0,0,character[],1
+gdtools,glyphs_match_,1,0,0,character,1
+gdtools,glyphs_match_,2,0,0,logical,1
+gdtools,glyphs_match_,3,0,0,logical,1
+gdtools,glyphs_match_,4,0,0,character,1
+gdtools,match_family,-1,0,0,character,1
+gdtools,match_family,0,0,0,character,1
+gdtools,match_family,1,0,0,logical,1
+gdtools,match_family,2,0,0,logical,1
+gdtools,match_family,3,0,0,null,1
+gdtools,m_str_extents,-1,0,0,class<`matrix`>,1
+gdtools,m_str_extents,0,0,0,character[],1
+gdtools,m_str_extents,1,0,0,character[],1
+gdtools,m_str_extents,2,0,0,double,1
+gdtools,m_str_extents,2,0,1,integer[],1
+gdtools,m_str_extents,3,0,0,logical[],1
+gdtools,m_str_extents,4,0,0,logical[],1
+gdtools,m_str_extents,5,0,0,null,1
+gdtools,m_str_extents_,-1,0,0,class<`matrix`>,1
+gdtools,m_str_extents_,0,0,0,character[],1
+gdtools,m_str_extents_,1,0,0,character[],1
+gdtools,m_str_extents_,2,0,0,double[],1
+gdtools,m_str_extents_,3,0,0,logical[],1
+gdtools,m_str_extents_,4,0,0,logical[],1
+gdtools,m_str_extents_,5,0,0,character[],1
+gdtools,raster_png_,-1,0,0,logical,1
+gdtools,raster_png_,0,0,0,class<`raster`>,1
+gdtools,raster_png_,1,0,0,integer,1
+gdtools,raster_png_,2,0,0,integer,1
+gdtools,raster_png_,3,0,0,double,1
+gdtools,raster_png_,4,0,0,double,1
+gdtools,raster_png_,5,0,0,logical,1
+gdtools,raster_png_,6,0,0,character,1
+gdtools,raster_str,-1,0,0,character,1
+gdtools,raster_str,0,0,0,class<`raster`>,1
+gdtools,raster_str,1,0,0,double,1
+gdtools,raster_str,2,0,0,double,1
+gdtools,raster_str,3,0,0,logical,1
+gdtools,raster_write,-1,0,0,character,1
+gdtools,raster_write,0,0,0,class<`raster`>,1
+gdtools,raster_write,1,0,0,character,1
+gdtools,raster_write,2,0,0,double,1
+gdtools,raster_write,3,0,0,double,1
+gdtools,raster_write,4,0,0,logical,1
+gdtools,str_extents,-1,0,0,class<`matrix`>,1
+gdtools,str_extents,0,0,0,character[],1
+gdtools,str_extents,1,0,0,character,1
+gdtools,str_extents,2,0,0,double,1
+gdtools,str_extents,3,0,0,logical,1
+gdtools,str_extents,4,0,0,logical,1
+gdtools,str_extents,5,0,0,character,1
+gdtools,str_extents_,-1,0,0,class<`matrix`>,1
+gdtools,str_extents_,0,0,0,character[],1
+gdtools,str_extents_,1,0,0,character,1
+gdtools,str_extents_,2,0,0,double,1
+gdtools,str_extents_,3,0,0,logical,1
+gdtools,str_extents_,4,0,0,logical,1
+gdtools,str_extents_,5,0,0,character,1
+gdtools,str_metrics,-1,0,0,double[],1
+gdtools,str_metrics,0,0,0,character,1
+gdtools,str_metrics,1,0,0,character,1
+gdtools,str_metrics,2,0,0,double,1
+gdtools,str_metrics,3,0,0,logical,1
+gdtools,str_metrics,4,0,0,logical,1
+gdtools,str_metrics,5,0,0,character,1
+gdtools,str_metrics_,-1,0,0,double[],1
+gdtools,str_metrics_,0,0,0,character,1
+gdtools,str_metrics_,1,0,0,character,1
+gdtools,str_metrics_,2,0,0,double,1
+gdtools,str_metrics_,3,0,0,logical,1
+gdtools,str_metrics_,4,0,0,logical,1
+gdtools,str_metrics_,5,0,0,character,1
+gdtools,sys_fonts,-1,0,0,"class<`data.frame`, `tbl`, `tbl_df`>",1
+gee,gee,-1,0,0,"class<`gee`, `glm`>",1
+gee,gee,0,0,0,any,1
+gee,gee,1,0,0,any,1
+gee,gee,2,0,0,any,1
+gee,gee,3,0,0,any,1
+gee,gee,4,0,0,any,1
+gee,gee,5,0,0,null,1
+gee,gee,6,0,0,null,1
+gee,gee,7,0,0,double,1
+gee,gee,8,0,0,double,1
+gee,gee,9,0,0,class<`function`>,1
+gee,gee,10,0,0,character,1
+gee,gee,11,0,0,double,1
+gee,gee,12,0,0,logical,1
+gee,gee,13,0,0,null,1
+gee,gee,14,0,0,logical,1
+gee,gee,15,0,0,double,1
+gee,gee,16,0,0,logical,1
+gee,summary.gee,-1,0,0,class<`summary.gee`>,1
+gee,summary.gee,0,0,0,"class<`gee`, `glm`>",1
+gee,summary.gee,1,0,0,logical,1
+gee,summary.gee,2,0,0,...,1
+geepack,anova.geeglm,-1,0,0,"class<`anova`, `data.frame`>",1
+geepack,anova.geeglm,0,0,0,"class<`gee`, `geeglm`, `glm`, `lm`>",1
+geepack,anova.geeglm,1,0,0,...,1
+geepack,anova.geeglm,2,0,0,null,1
+geepack,anova.geeglm,3,0,0,null,1
+geepack,compCoef,-1,0,0,list<double[] | class<`matrix`>>,1
+geepack,compCoef,0,0,0,class<`geese`>,1
+geepack,compCoef,1,0,0,class<`geese`>,1
+geepack,crossutri,-1,0,0,character[],1
+geepack,crossutri,0,0,0,integer[],1
+geepack,eprint,-1,0,0,null,1
+geepack,eprint,0,0,0,character,1
+geepack,fixed2Zcor,-1,0,0,double[],1
+geepack,fixed2Zcor,0,0,0,class<`matrix`>,1
+geepack,fixed2Zcor,1,0,0,integer[],1
+geepack,fixed2Zcor,2,0,0,integer[],1
+geepack,geeglm,-1,0,0,"class<`gee`, `geeglm`, `glm`, `lm`>",1
+geepack,geeglm,0,0,0,class<`formula`>,1
+geepack,geeglm,1,0,0,any,1
+geepack,geeglm,2,0,0,any,1
+geepack,geeglm,3,0,0,any,1
+geepack,geeglm,4,0,0,any,1
+geepack,geeglm,5,0,0,any,1
+geepack,geeglm,6,0,0,null,1
+geepack,geeglm,7,0,0,any,1
+geepack,geese,-1,0,0,class<`geese`>,1
+geepack,geese,0,0,0,class<`formula`>,1
+geepack,geese,1,0,0,class<`formula`>,1
+geepack,geese,2,0,0,any,1
+geepack,geese,3,0,0,any,1
+geepack,geese,4,0,0,any,1
+geepack,geese,5,0,0,any,1
+geepack,geese,6,0,0,any,1
+geepack,geese,7,0,0,null,1
+geepack,geese.control,-1,0,0,list<double>,1
+geepack,geese.control,0,0,0,double,1
+geepack,geese.control,1,0,0,double,1
+geepack,geese.control,2,0,0,logical,1
+geepack,geese.control,3,0,0,logical,1
+geepack,geese.control,4,0,0,logical,1
+geepack,geese.control,5,0,0,logical,1
+geepack,geese.control,6,0,0,logical,1
+geepack,geese.fit,-1,0,0,list<any>,1
+geepack,geese.fit,0,0,0,class<`matrix`>,1
+geepack,geese.fit,1,0,0,double[],1
+geepack,geese.fit,2,0,0,integer[],1
+geepack,geese.fit,2,0,1,class<`factor`>,1
+geepack,geese.fit,3,0,0,double[],1
+geepack,geese.fit,4,0,0,double[],1
+geepack,geese.fit,5,0,0,double[],1
+geepack,geese.fit,6,0,0,null,1
+geepack,geese.fit,6,0,1,class<`factor`>,1
+geepack,geese.fit,6,0,2,integer[],1
+geepack,geese.fit,7,0,0,class<`matrix`>,1
+geepack,genZcor,-1,0,0,class<`matrix`>,1
+geepack,genZcor,0,0,0,any,1
+geepack,genZcor,1,0,0,any,1
+geepack,genZcor,2,0,0,double,1
+geepack,genZcor,2,0,1,character,1
+geepack,genZodds,-1,0,0,class<`matrix`>,1
+geepack,genZodds,0,0,0,any,1
+geepack,genZodds,1,0,0,any,1
+geepack,genZodds,2,0,0,integer,1
+geepack,genZodds,3,0,0,any,1
+geepack,ordgee,-1,0,0,class<`geese`>,1
+geepack,ordgee,0,0,0,any,1
+geepack,ordgee,1,0,0,null,1
+geepack,ordgee,2,0,0,any,1
+geepack,ordgee,3,0,0,null,1
+geepack,ordgee,4,0,0,any,1
+geepack,ordgee,5,0,0,null,1
+geepack,ordgee,6,0,0,any,1
+geepack,ordgee,7,0,0,null,1
+geepack,QIC,-1,0,0,double[],1
+geepack,QIC,0,0,0,"class<`gee`, `geeglm`, `glm`, `lm`>",1
+geepack,QIC,1,0,0,any,1
+geepack,QIC,2,0,0,...,1
+geepack,QIC.geeglm,-1,0,0,double[],1
+geepack,QIC.geeglm,0,0,0,"class<`gee`, `geeglm`, `glm`, `lm`>",1
+geepack,QIC.geeglm,1,0,0,double,1
+geepack,QIC.geeglm,2,0,0,...,1
+geepack,relRisk,-1,0,0,class<`geese`>,1
+geepack,relRisk,0,0,0,class<`formula`>,1
+geepack,relRisk,1,0,0,any,1
+geepack,relRisk,2,0,0,null,1
+geepack,relRisk,3,0,0,any,1
+geepack,relRisk,4,0,0,null,1
+geepack,relRisk,5,0,0,null,1
+geepack,relRisk,6,0,0,any,1
+geepack,relRisk,7,0,0,character,1
+geepack,summary.geeglm,-1,0,0,class<`summary.geeglm`>,1
+geepack,summary.geeglm,0,0,0,"class<`gee`, `geeglm`, `glm`, `lm`>",1
+geepack,summary.geeglm,1,0,0,...,1
+geepack,summary.geese,-1,0,0,class<`summary.geese`>,1
+geepack,summary.geese,0,0,0,class<`geese`>,1
+geepack,summary.geese,1,0,0,...,1
+geepack,vcov.geeglm,-1,0,0,class<`matrix`>,1
+geepack,vcov.geeglm,0,0,0,"class<`gee`, `geeglm`, `glm`, `lm`>",1
+geepack,vcov.geeglm,1,0,0,...,1
+genalg,plot.rbga,-1,0,0,null,1
+genalg,plot.rbga,-1,0,1,list<integer[]>,1
+genalg,plot.rbga,0,0,0,class<`rbga`>,1
+genalg,plot.rbga,1,0,0,character,1
+genalg,plot.rbga,2,0,0,double,1
+genalg,plot.rbga,3,0,0,...,1
+genalg,rbga,-1,0,0,class<`rbga`>,1
+genalg,rbga,0,0,0,double[],1
+genalg,rbga,1,0,0,double[],1
+genalg,rbga,2,0,0,null,1
+genalg,rbga,3,0,0,double,1
+genalg,rbga,4,0,0,double,1
+genalg,rbga,5,0,0,double,1
+genalg,rbga,6,0,0,null,1
+genalg,rbga,7,0,0,class<`function`>,1
+genalg,rbga,8,0,0,class<`function`>,1
+genalg,rbga,9,0,0,logical,1
+genalg,rbga,10,0,0,logical,1
+genalg,rbga.bin,-1,0,0,class<`rbga`>,1
+genalg,rbga.bin,0,0,0,double,1
+genalg,rbga.bin,1,0,0,null,1
+genalg,rbga.bin,2,0,0,double,1
+genalg,rbga.bin,3,0,0,double,1
+genalg,rbga.bin,4,0,0,double,1
+genalg,rbga.bin,5,0,0,null,1
+genalg,rbga.bin,6,0,0,double,1
+genalg,rbga.bin,7,0,0,null,1
+genalg,rbga.bin,8,0,0,class<`function`>,1
+genalg,rbga.bin,9,0,0,logical,1
+genalg,rbga.bin,10,0,0,logical,1
+genalg,summary.rbga,-1,0,0,character,1
+genalg,summary.rbga,0,0,0,class<`rbga`>,1
+genalg,summary.rbga,1,0,0,logical,1
+genalg,summary.rbga,2,0,0,...,1
+generics,as.difftime,-1,0,0,class<`difftime`>,1
+generics,as.difftime,0,0,0,character[],1
+generics,as.difftime,0,0,1,integer[],1
+generics,as.difftime,1,0,0,...,1
+generics,as.difftime.default,-1,0,0,class<`difftime`>,1
+generics,as.difftime.default,0,0,0,character[],1
+generics,as.difftime.default,0,0,1,integer[],1
+generics,as.difftime.default,1,0,0,character,1
+generics,as.difftime.default,2,0,0,character,1
+generics,as.difftime.default,3,0,0,...,1
+generics,as.factor,-1,0,0,class<`factor`>,1
+generics,as.factor,0,0,0,character[],1
+generics,as.factor,1,0,0,...,1
+generics,as.factor.default,-1,0,0,class<`factor`>,1
+generics,as.factor.default,0,0,0,character[],1
+generics,as.factor.default,1,0,0,...,1
+generics,as.ordered,-1,0,0,"class<`factor`, `ordered`>",1
+generics,as.ordered,0,0,0,character[],1
+generics,as.ordered,1,0,0,...,1
+generics,as.ordered.default,-1,0,0,"class<`factor`, `ordered`>",1
+generics,as.ordered.default,0,0,0,character[],1
+generics,as.ordered.default,1,0,0,...,1
+generics,intersect,-1,0,0,integer[],1
+generics,intersect,0,0,0,integer[],1
+generics,intersect,1,0,0,integer[],1
+generics,intersect,2,0,0,...,1
+generics,intersect.default,-1,0,0,integer[],1
+generics,intersect.default,0,0,0,integer[],1
+generics,intersect.default,1,0,0,integer[],1
+generics,intersect.default,2,0,0,...,1
+generics,setdiff,-1,0,0,integer[],1
+generics,setdiff,0,0,0,integer[],1
+generics,setdiff,1,0,0,integer[],1
+generics,setdiff,2,0,0,...,1
+generics,setdiff.default,-1,0,0,integer[],1
+generics,setdiff.default,0,0,0,integer[],1
+generics,setdiff.default,1,0,0,integer[],1
+generics,setdiff.default,2,0,0,...,1
+generics,union,-1,0,0,integer[],1
+generics,union,0,0,0,integer[],1
+generics,union,1,0,0,integer[],1
+generics,union,2,0,0,...,1
+generics,union.default,-1,0,0,integer[],1
+generics,union.default,0,0,0,integer[],1
+generics,union.default,1,0,0,integer[],1
+generics,union.default,2,0,0,...,1
+ggfittext,geom_bar_text,-1,0,0,"class<`Layer`, `LayerInstance`, `gg`, `ggproto`>",1
+ggfittext,geom_bar_text,0,0,0,null,1
+ggfittext,geom_bar_text,1,0,0,null,1
+ggfittext,geom_bar_text,2,0,0,character,1
+ggfittext,geom_bar_text,3,0,0,character,1
+ggfittext,geom_bar_text,4,0,0,logical,1
+ggfittext,geom_bar_text,5,0,0,null,1
+ggfittext,geom_bar_text,6,0,0,logical,1
+ggfittext,geom_bar_text,7,0,0,class<`unit`>,1
+ggfittext,geom_fit_text,-1,0,0,"class<`Layer`, `LayerInstance`, `gg`, `ggproto`>",1
+ggfittext,geom_fit_text,0,0,0,null,1
+ggfittext,geom_fit_text,1,0,0,null,1
+ggfittext,geom_fit_text,2,0,0,character,1
+ggfittext,geom_fit_text,3,0,0,character,1
+ggfittext,geom_fit_text,4,0,0,logical,1
+ggfittext,geom_fit_text,5,0,0,null,1
+ggfittext,geom_fit_text,6,0,0,logical,1
+ggfittext,geom_fit_text,7,0,0,class<`unit`>,1
+ggforce,facet_col,-1,0,0,"class<`Facet`, `FacetCol`, `FacetWrap`, `gg`, `ggproto`>",1
+ggforce,facet_col,0,0,0,class<`formula`>,1
+ggforce,facet_col,1,0,0,character,1
+ggforce,facet_col,2,0,0,character,1
+ggforce,facet_col,3,0,0,logical,1
+ggforce,facet_col,4,0,0,character,1
+ggforce,facet_col,5,0,0,logical,1
+ggforce,facet_col,6,0,0,character,1
+ggforce,facet_grid_paginate,-1,0,0,"class<`Facet`, `FacetGrid`, `FacetGridPaginate`, `gg`, `ggproto`>",1
+ggforce,facet_grid_paginate,0,0,0,class<`formula`>,1
+ggforce,facet_grid_paginate,1,0,0,logical,1
+ggforce,facet_grid_paginate,2,0,0,character,1
+ggforce,facet_grid_paginate,3,0,0,character,1
+ggforce,facet_grid_paginate,4,0,0,logical,1
+ggforce,facet_grid_paginate,5,0,0,character,1
+ggforce,facet_grid_paginate,6,0,0,logical,1
+ggforce,facet_grid_paginate,7,0,0,null,1
+ggforce,facet_grid_paginate,8,0,0,logical,1
+ggforce,facet_grid_paginate,9,0,0,double,1
+ggforce,facet_grid_paginate,10,0,0,double,1
+ggforce,facet_grid_paginate,11,0,0,double,1
+ggforce,facet_grid_paginate,12,0,0,logical,1
+ggforce,facet_matrix,-1,0,0,"class<`Facet`, `FacetGrid`, `FacetMatrix`, `gg`, `ggproto`>",1
+ggforce,facet_matrix,0,0,0,"class<`list`, `quosures`>",1
+ggforce,facet_matrix,1,0,0,"class<`list`, `quosures`>",1
+ggforce,facet_matrix,2,0,0,logical,1
+ggforce,facet_matrix,3,0,0,character,1
+ggforce,facet_matrix,3,0,1,null,1
+ggforce,facet_matrix,4,0,0,logical,1
+ggforce,facet_matrix,5,0,0,logical,1
+ggforce,facet_matrix,6,0,0,null,1
+ggforce,facet_matrix,6,0,1,double,1
+ggforce,facet_matrix,7,0,0,null,1
+ggforce,facet_matrix,7,0,1,double,1
+ggforce,facet_matrix,8,0,0,null,1
+ggforce,facet_matrix,9,0,0,null,1
+ggforce,facet_matrix,9,0,1,double,1
+ggforce,facet_matrix,10,0,0,null,1
+ggforce,facet_matrix,10,0,1,double,1
+ggforce,facet_matrix,11,0,0,null,1
+ggforce,facet_matrix,11,0,1,double,1
+ggforce,facet_matrix,12,0,0,logical,1
+ggforce,facet_stereo,-1,0,0,"class<`Facet`, `FacetStereo`, `gg`, `ggproto`>",1
+ggforce,facet_stereo,0,0,0,double,1
+ggforce,facet_stereo,1,0,0,double,1
+ggforce,facet_stereo,2,0,0,logical,1
+ggforce,facet_wrap_paginate,-1,0,0,"class<`Facet`, `FacetWrap`, `FacetWrapPaginate`, `gg`, `ggproto`>",1
+ggforce,facet_wrap_paginate,0,0,0,class<`formula`>,1
+ggforce,facet_wrap_paginate,1,0,0,double,1
+ggforce,facet_wrap_paginate,2,0,0,double,1
+ggforce,facet_wrap_paginate,3,0,0,character,1
+ggforce,facet_wrap_paginate,4,0,0,logical,1
+ggforce,facet_wrap_paginate,5,0,0,character,1
+ggforce,facet_wrap_paginate,6,0,0,logical,1
+ggforce,facet_wrap_paginate,7,0,0,null,1
+ggforce,facet_wrap_paginate,8,0,0,logical,1
+ggforce,facet_wrap_paginate,9,0,0,character,1
+ggforce,facet_wrap_paginate,10,0,0,character,1
+ggforce,facet_wrap_paginate,11,0,0,double,1
+ggforce,facet_zoom,-1,0,0,"class<`Facet`, `FacetZoom`, `gg`, `ggproto`>",1
+ggforce,facet_zoom,0,0,0,any,1
+ggforce,facet_zoom,1,0,0,any,1
+ggforce,facet_zoom,2,0,0,any,1
+ggforce,facet_zoom,3,0,0,any,1
+ggforce,facet_zoom,4,0,0,null,1
+ggforce,facet_zoom,4,0,1,double[],1
+ggforce,facet_zoom,5,0,0,null,1
+ggforce,facet_zoom,6,0,0,logical,1
+ggforce,facet_zoom,7,0,0,logical,1
+ggforce,facet_zoom,8,0,0,double,1
+ggforce,facet_zoom,9,0,0,logical,1
+ggforce,facet_zoom,10,0,0,logical,1
+ggforce,gather_set_data,-1,0,0,class<`data.frame`>,1
+ggforce,gather_set_data,0,0,0,class<`data.frame`>,1
+ggforce,gather_set_data,1,0,0,integer[],1
+ggforce,gather_set_data,2,0,0,character,1
+ggforce,geom_arc,-1,0,0,"class<`Layer`, `LayerInstance`, `gg`, `ggproto`>",1
+ggforce,geom_arc,0,0,0,class<`uneval`>,1
+ggforce,geom_arc,1,0,0,null,1
+ggforce,geom_arc,2,0,0,character,1
+ggforce,geom_arc,3,0,0,character,1
+ggforce,geom_arc,4,0,0,double,1
+ggforce,geom_arc,5,0,0,null,1
+ggforce,geom_arc,6,0,0,character,1
+ggforce,geom_arc,7,0,0,logical,1
+ggforce,geom_arc,8,0,0,null,1
+ggforce,geom_arc,9,0,0,logical,1
+ggforce,geom_arc,10,0,0,...,1
+ggforce,geom_arc0,-1,0,0,"class<`Layer`, `LayerInstance`, `gg`, `ggproto`>",1
+ggforce,geom_arc0,0,0,0,class<`uneval`>,1
+ggforce,geom_arc0,1,0,0,null,1
+ggforce,geom_arc0,2,0,0,character,1
+ggforce,geom_arc0,3,0,0,character,1
+ggforce,geom_arc0,4,0,0,double,1
+ggforce,geom_arc0,5,0,0,null,1
+ggforce,geom_arc0,6,0,0,character,1
+ggforce,geom_arc0,7,0,0,logical,1
+ggforce,geom_arc0,8,0,0,null,1
+ggforce,geom_arc0,9,0,0,logical,1
+ggforce,geom_arc0,10,0,0,...,1
+ggforce,geom_arc2,-1,0,0,"class<`Layer`, `LayerInstance`, `gg`, `ggproto`>",1
+ggforce,geom_arc2,0,0,0,class<`uneval`>,1
+ggforce,geom_arc2,1,0,0,null,1
+ggforce,geom_arc2,2,0,0,character,1
+ggforce,geom_arc2,3,0,0,character,1
+ggforce,geom_arc2,4,0,0,double,1
+ggforce,geom_arc2,5,0,0,null,1
+ggforce,geom_arc2,6,0,0,character,1
+ggforce,geom_arc2,7,0,0,logical,1
+ggforce,geom_arc2,8,0,0,null,1
+ggforce,geom_arc2,9,0,0,logical,1
+ggforce,geom_arc2,10,0,0,...,1
+ggforce,geom_arc_bar,-1,0,0,"class<`Layer`, `LayerInstance`, `gg`, `ggproto`>",1
+ggforce,geom_arc_bar,0,0,0,class<`uneval`>,1
+ggforce,geom_arc_bar,1,0,0,class<`data.frame`>,1
+ggforce,geom_arc_bar,1,0,1,null,1
+ggforce,geom_arc_bar,2,0,0,character,1
+ggforce,geom_arc_bar,3,0,0,character,1
+ggforce,geom_arc_bar,4,0,0,double,1
+ggforce,geom_arc_bar,5,0,0,double,1
+ggforce,geom_arc_bar,6,0,0,double,1
+ggforce,geom_arc_bar,6,0,1,class<`unit`>,1
+ggforce,geom_arc_bar,7,0,0,logical,1
+ggforce,geom_arc_bar,8,0,0,null,1
+ggforce,geom_arc_bar,9,0,0,logical,1
+ggforce,geom_arc_bar,10,0,0,...,1
+ggforce,geom_autodensity,-1,0,0,"class<`Layer`, `LayerInstance`, `gg`, `ggproto`>",1
+ggforce,geom_autodensity,0,0,0,class<`uneval`>,1
+ggforce,geom_autodensity,0,0,1,null,1
+ggforce,geom_autodensity,1,0,0,null,1
+ggforce,geom_autodensity,2,0,0,character,1
+ggforce,geom_autodensity,3,0,0,character,1
+ggforce,geom_autodensity,4,0,0,...,1
+ggforce,geom_autodensity,5,0,0,character,1
+ggforce,geom_autodensity,6,0,0,double,1
+ggforce,geom_autodensity,7,0,0,character,1
+ggforce,geom_autodensity,8,0,0,double,1
+ggforce,geom_autodensity,9,0,0,logical,1
+ggforce,geom_autodensity,10,0,0,logical,1
+ggforce,geom_autodensity,11,0,0,null,1
+ggforce,geom_autodensity,12,0,0,logical,1
+ggforce,geom_autohistogram,-1,0,0,"class<`Layer`, `LayerInstance`, `gg`, `ggproto`>",1
+ggforce,geom_autohistogram,0,0,0,null,1
+ggforce,geom_autohistogram,1,0,0,null,1
+ggforce,geom_autohistogram,2,0,0,character,1
+ggforce,geom_autohistogram,3,0,0,character,1
+ggforce,geom_autohistogram,4,0,0,...,1
+ggforce,geom_autohistogram,5,0,0,null,1
+ggforce,geom_autohistogram,6,0,0,logical,1
+ggforce,geom_autohistogram,7,0,0,null,1
+ggforce,geom_autohistogram,8,0,0,logical,1
+ggforce,geom_autopoint,-1,0,0,"class<`Layer`, `LayerInstance`, `gg`, `ggproto`>",1
+ggforce,geom_autopoint,0,0,0,class<`uneval`>,1
+ggforce,geom_autopoint,0,0,1,null,1
+ggforce,geom_autopoint,1,0,0,null,1
+ggforce,geom_autopoint,2,0,0,character,1
+ggforce,geom_autopoint,3,0,0,character,1
+ggforce,geom_autopoint,4,0,0,...,1
+ggforce,geom_autopoint,5,0,0,logical,1
+ggforce,geom_autopoint,6,0,0,null,1
+ggforce,geom_autopoint,7,0,0,logical,1
+ggforce,geom_bezier,-1,0,0,"class<`Layer`, `LayerInstance`, `gg`, `ggproto`>",1
+ggforce,geom_bezier,0,0,0,class<`uneval`>,1
+ggforce,geom_bezier,1,0,0,class<`data.frame`>,1
+ggforce,geom_bezier,2,0,0,character,1
+ggforce,geom_bezier,3,0,0,character,1
+ggforce,geom_bezier,4,0,0,null,1
+ggforce,geom_bezier,5,0,0,character,1
+ggforce,geom_bezier,6,0,0,logical,1
+ggforce,geom_bezier,7,0,0,null,1
+ggforce,geom_bezier,8,0,0,logical,1
+ggforce,geom_bezier,9,0,0,double,1
+ggforce,geom_bezier,10,0,0,...,1
+ggforce,geom_bezier0,-1,0,0,"class<`Layer`, `LayerInstance`, `gg`, `ggproto`>",1
+ggforce,geom_bezier0,0,0,0,class<`uneval`>,1
+ggforce,geom_bezier0,1,0,0,class<`data.frame`>,1
+ggforce,geom_bezier0,2,0,0,character,1
+ggforce,geom_bezier0,3,0,0,character,1
+ggforce,geom_bezier0,4,0,0,null,1
+ggforce,geom_bezier0,5,0,0,character,1
+ggforce,geom_bezier0,6,0,0,logical,1
+ggforce,geom_bezier0,7,0,0,null,1
+ggforce,geom_bezier0,8,0,0,logical,1
+ggforce,geom_bezier0,9,0,0,...,1
+ggforce,geom_bezier2,-1,0,0,"class<`Layer`, `LayerInstance`, `gg`, `ggproto`>",1
+ggforce,geom_bezier2,0,0,0,class<`uneval`>,1
+ggforce,geom_bezier2,1,0,0,null,1
+ggforce,geom_bezier2,2,0,0,character,1
+ggforce,geom_bezier2,3,0,0,character,1
+ggforce,geom_bezier2,4,0,0,null,1
+ggforce,geom_bezier2,5,0,0,character,1
+ggforce,geom_bezier2,6,0,0,logical,1
+ggforce,geom_bezier2,7,0,0,null,1
+ggforce,geom_bezier2,8,0,0,logical,1
+ggforce,geom_bezier2,9,0,0,double,1
+ggforce,geom_bezier2,10,0,0,...,1
+ggforce,geom_bspline,-1,0,0,"class<`Layer`, `LayerInstance`, `gg`, `ggproto`>",1
+ggforce,geom_bspline,0,0,0,class<`uneval`>,1
+ggforce,geom_bspline,1,0,0,null,1
+ggforce,geom_bspline,2,0,0,character,1
+ggforce,geom_bspline,3,0,0,character,1
+ggforce,geom_bspline,4,0,0,null,1
+ggforce,geom_bspline,5,0,0,double,1
+ggforce,geom_bspline,6,0,0,character,1
+ggforce,geom_bspline,7,0,0,character,1
+ggforce,geom_bspline,8,0,0,logical,1
+ggforce,geom_bspline,9,0,0,null,1
+ggforce,geom_bspline,10,0,0,logical,1
+ggforce,geom_bspline,11,0,0,...,1
+ggforce,geom_bspline0,-1,0,0,"class<`Layer`, `LayerInstance`, `gg`, `ggproto`>",1
+ggforce,geom_bspline0,0,0,0,class<`uneval`>,1
+ggforce,geom_bspline0,1,0,0,null,1
+ggforce,geom_bspline0,2,0,0,character,1
+ggforce,geom_bspline0,3,0,0,character,1
+ggforce,geom_bspline0,4,0,0,null,1
+ggforce,geom_bspline0,5,0,0,character,1
+ggforce,geom_bspline0,6,0,0,logical,1
+ggforce,geom_bspline0,7,0,0,null,1
+ggforce,geom_bspline0,8,0,0,logical,1
+ggforce,geom_bspline0,9,0,0,character,1
+ggforce,geom_bspline0,10,0,0,...,1
+ggforce,geom_bspline2,-1,0,0,"class<`Layer`, `LayerInstance`, `gg`, `ggproto`>",1
+ggforce,geom_bspline2,0,0,0,class<`uneval`>,1
+ggforce,geom_bspline2,1,0,0,null,1
+ggforce,geom_bspline2,2,0,0,character,1
+ggforce,geom_bspline2,3,0,0,character,1
+ggforce,geom_bspline2,4,0,0,null,1
+ggforce,geom_bspline2,5,0,0,double,1
+ggforce,geom_bspline2,6,0,0,character,1
+ggforce,geom_bspline2,7,0,0,character,1
+ggforce,geom_bspline2,8,0,0,logical,1
+ggforce,geom_bspline2,9,0,0,null,1
+ggforce,geom_bspline2,10,0,0,logical,1
+ggforce,geom_bspline2,11,0,0,...,1
+ggforce,geom_bspline_closed,-1,0,0,"class<`Layer`, `LayerInstance`, `gg`, `ggproto`>",1
+ggforce,geom_bspline_closed,0,0,0,null,1
+ggforce,geom_bspline_closed,1,0,0,null,1
+ggforce,geom_bspline_closed,2,0,0,character,1
+ggforce,geom_bspline_closed,3,0,0,character,1
+ggforce,geom_bspline_closed,4,0,0,double,1
+ggforce,geom_bspline_closed,5,0,0,logical,1
+ggforce,geom_bspline_closed,6,0,0,null,1
+ggforce,geom_bspline_closed,7,0,0,logical,1
+ggforce,geom_bspline_closed,8,0,0,...,1
+ggforce,geom_bspline_closed0,-1,0,0,"class<`Layer`, `LayerInstance`, `gg`, `ggproto`>",1
+ggforce,geom_bspline_closed0,0,0,0,null,1
+ggforce,geom_bspline_closed0,1,0,0,null,1
+ggforce,geom_bspline_closed0,2,0,0,character,1
+ggforce,geom_bspline_closed0,3,0,0,character,1
+ggforce,geom_bspline_closed0,4,0,0,logical,1
+ggforce,geom_bspline_closed0,5,0,0,null,1
+ggforce,geom_bspline_closed0,6,0,0,logical,1
+ggforce,geom_bspline_closed0,7,0,0,...,1
+ggforce,geom_circle,-1,0,0,"class<`Layer`, `LayerInstance`, `gg`, `ggproto`>",1
+ggforce,geom_circle,0,0,0,class<`uneval`>,1
+ggforce,geom_circle,1,0,0,class<`data.frame`>,1
+ggforce,geom_circle,2,0,0,character,1
+ggforce,geom_circle,3,0,0,character,1
+ggforce,geom_circle,4,0,0,double,1
+ggforce,geom_circle,5,0,0,double,1
+ggforce,geom_circle,6,0,0,double,1
+ggforce,geom_circle,7,0,0,logical,1
+ggforce,geom_circle,8,0,0,null,1
+ggforce,geom_circle,9,0,0,logical,1
+ggforce,geom_circle,10,0,0,...,1
+ggforce,geom_delaunay_segment2,-1,0,0,"class<`Layer`, `LayerInstance`, `gg`, `ggproto`>",1
+ggforce,geom_delaunay_segment2,0,0,0,class<`uneval`>,1
+ggforce,geom_delaunay_segment2,1,0,0,null,1
+ggforce,geom_delaunay_segment2,2,0,0,character,1
+ggforce,geom_delaunay_segment2,3,0,0,character,1
+ggforce,geom_delaunay_segment2,4,0,0,logical,1
+ggforce,geom_delaunay_segment2,5,0,0,null,1
+ggforce,geom_delaunay_segment2,6,0,0,double,1
+ggforce,geom_delaunay_segment2,7,0,0,logical,1
+ggforce,geom_delaunay_segment2,8,0,0,double,1
+ggforce,geom_delaunay_segment2,9,0,0,double,1
+ggforce,geom_delaunay_segment2,10,0,0,null,1
+ggforce,geom_delaunay_segment2,11,0,0,logical,1
+ggforce,geom_delaunay_segment2,12,0,0,...,1
+ggforce,geom_delaunay_tile,-1,0,0,"class<`Layer`, `LayerInstance`, `gg`, `ggproto`>",1
+ggforce,geom_delaunay_tile,0,0,0,null,1
+ggforce,geom_delaunay_tile,1,0,0,null,1
+ggforce,geom_delaunay_tile,2,0,0,character,1
+ggforce,geom_delaunay_tile,3,0,0,character,1
+ggforce,geom_delaunay_tile,4,0,0,logical,1
+ggforce,geom_delaunay_tile,5,0,0,null,1
+ggforce,geom_delaunay_tile,6,0,0,double,1
+ggforce,geom_delaunay_tile,7,0,0,logical,1
+ggforce,geom_delaunay_tile,8,0,0,double,1
+ggforce,geom_delaunay_tile,9,0,0,double,1
+ggforce,geom_delaunay_tile,10,0,0,double,1
+ggforce,geom_delaunay_tile,11,0,0,null,1
+ggforce,geom_delaunay_tile,12,0,0,logical,1
+ggforce,geom_delaunay_tile,13,0,0,...,1
+ggforce,geom_diagonal,-1,0,0,"class<`Layer`, `LayerInstance`, `gg`, `ggproto`>",1
+ggforce,geom_diagonal,0,0,0,class<`uneval`>,1
+ggforce,geom_diagonal,0,0,1,null,1
+ggforce,geom_diagonal,1,0,0,null,1
+ggforce,geom_diagonal,2,0,0,character,1
+ggforce,geom_diagonal,3,0,0,character,1
+ggforce,geom_diagonal,4,0,0,double,1
+ggforce,geom_diagonal,5,0,0,logical,1
+ggforce,geom_diagonal,6,0,0,double,1
+ggforce,geom_diagonal,7,0,0,null,1
+ggforce,geom_diagonal,8,0,0,logical,1
+ggforce,geom_diagonal,9,0,0,...,1
+ggforce,geom_diagonal0,-1,0,0,"class<`Layer`, `LayerInstance`, `gg`, `ggproto`>",1
+ggforce,geom_diagonal0,0,0,0,class<`uneval`>,1
+ggforce,geom_diagonal0,1,0,0,null,1
+ggforce,geom_diagonal0,2,0,0,character,1
+ggforce,geom_diagonal0,3,0,0,character,1
+ggforce,geom_diagonal0,4,0,0,null,1
+ggforce,geom_diagonal0,5,0,0,character,1
+ggforce,geom_diagonal0,6,0,0,logical,1
+ggforce,geom_diagonal0,7,0,0,null,1
+ggforce,geom_diagonal0,8,0,0,logical,1
+ggforce,geom_diagonal0,9,0,0,double,1
+ggforce,geom_diagonal0,10,0,0,...,1
+ggforce,geom_diagonal2,-1,0,0,"class<`Layer`, `LayerInstance`, `gg`, `ggproto`>",1
+ggforce,geom_diagonal2,0,0,0,class<`uneval`>,1
+ggforce,geom_diagonal2,1,0,0,null,1
+ggforce,geom_diagonal2,2,0,0,character,1
+ggforce,geom_diagonal2,3,0,0,character,1
+ggforce,geom_diagonal2,4,0,0,null,1
+ggforce,geom_diagonal2,5,0,0,character,1
+ggforce,geom_diagonal2,6,0,0,logical,1
+ggforce,geom_diagonal2,7,0,0,null,1
+ggforce,geom_diagonal2,8,0,0,logical,1
+ggforce,geom_diagonal2,9,0,0,double,1
+ggforce,geom_diagonal2,10,0,0,double,1
+ggforce,geom_diagonal2,11,0,0,...,1
+ggforce,geom_diagonal_wide,-1,0,0,"class<`Layer`, `LayerInstance`, `gg`, `ggproto`>",1
+ggforce,geom_diagonal_wide,0,0,0,class<`uneval`>,1
+ggforce,geom_diagonal_wide,0,0,1,null,1
+ggforce,geom_diagonal_wide,1,0,0,null,1
+ggforce,geom_diagonal_wide,2,0,0,character,1
+ggforce,geom_diagonal_wide,3,0,0,character,1
+ggforce,geom_diagonal_wide,4,0,0,double,1
+ggforce,geom_diagonal_wide,5,0,0,logical,1
+ggforce,geom_diagonal_wide,6,0,0,double,1
+ggforce,geom_diagonal_wide,7,0,0,null,1
+ggforce,geom_diagonal_wide,8,0,0,logical,1
+ggforce,geom_diagonal_wide,9,0,0,...,1
+ggforce,geom_ellipse,-1,0,0,"class<`Layer`, `LayerInstance`, `gg`, `ggproto`>",1
+ggforce,geom_ellipse,0,0,0,class<`uneval`>,1
+ggforce,geom_ellipse,1,0,0,null,1
+ggforce,geom_ellipse,2,0,0,character,1
+ggforce,geom_ellipse,3,0,0,character,1
+ggforce,geom_ellipse,4,0,0,double,1
+ggforce,geom_ellipse,5,0,0,logical,1
+ggforce,geom_ellipse,6,0,0,null,1
+ggforce,geom_ellipse,7,0,0,logical,1
+ggforce,geom_ellipse,8,0,0,...,1
+ggforce,geom_link,-1,0,0,"class<`Layer`, `LayerInstance`, `gg`, `ggproto`>",1
+ggforce,geom_link,0,0,0,class<`uneval`>,1
+ggforce,geom_link,1,0,0,null,1
+ggforce,geom_link,2,0,0,character,1
+ggforce,geom_link,3,0,0,character,1
+ggforce,geom_link,4,0,0,null,1
+ggforce,geom_link,5,0,0,character,1
+ggforce,geom_link,6,0,0,logical,1
+ggforce,geom_link,7,0,0,null,1
+ggforce,geom_link,8,0,0,logical,1
+ggforce,geom_link,9,0,0,double,1
+ggforce,geom_link,10,0,0,...,1
+ggforce,geom_link2,-1,0,0,"class<`Layer`, `LayerInstance`, `gg`, `ggproto`>",1
+ggforce,geom_link2,0,0,0,class<`uneval`>,1
+ggforce,geom_link2,1,0,0,null,1
+ggforce,geom_link2,2,0,0,character,1
+ggforce,geom_link2,3,0,0,character,1
+ggforce,geom_link2,4,0,0,null,1
+ggforce,geom_link2,5,0,0,character,1
+ggforce,geom_link2,6,0,0,logical,1
+ggforce,geom_link2,7,0,0,null,1
+ggforce,geom_link2,8,0,0,logical,1
+ggforce,geom_link2,9,0,0,double,1
+ggforce,geom_link2,10,0,0,...,1
+ggforce,geom_mark_circle,-1,0,0,"class<`Layer`, `LayerInstance`, `gg`, `ggproto`>",1
+ggforce,geom_mark_circle,0,0,0,class<`uneval`>,1
+ggforce,geom_mark_circle,1,0,0,null,1
+ggforce,geom_mark_circle,2,0,0,character,1
+ggforce,geom_mark_circle,3,0,0,character,1
+ggforce,geom_mark_circle,4,0,0,class<`unit`>,1
+ggforce,geom_mark_circle,5,0,0,class<`unit`>,1
+ggforce,geom_mark_circle,6,0,0,double,1
+ggforce,geom_mark_circle,7,0,0,"class<`margin`, `unit`>",1
+ggforce,geom_mark_circle,8,0,0,null,1
+ggforce,geom_mark_circle,9,0,0,class<`unit`>,1
+ggforce,geom_mark_circle,10,0,0,double,1
+ggforce,geom_mark_circle,11,0,0,double,1
+ggforce,geom_mark_circle,12,0,0,character,1
+ggforce,geom_mark_circle,13,0,0,double,1
+ggforce,geom_mark_circle,14,0,0,character[],1
+ggforce,geom_mark_circle,15,0,0,character,1
+ggforce,geom_mark_ellipse,-1,0,0,"class<`Layer`, `LayerInstance`, `gg`, `ggproto`>",1
+ggforce,geom_mark_ellipse,0,0,0,class<`uneval`>,1
+ggforce,geom_mark_ellipse,1,0,0,null,1
+ggforce,geom_mark_ellipse,2,0,0,character,1
+ggforce,geom_mark_ellipse,3,0,0,character,1
+ggforce,geom_mark_ellipse,4,0,0,class<`unit`>,1
+ggforce,geom_mark_ellipse,5,0,0,class<`unit`>,1
+ggforce,geom_mark_ellipse,6,0,0,double,1
+ggforce,geom_mark_ellipse,7,0,0,double,1
+ggforce,geom_mark_ellipse,8,0,0,"class<`margin`, `unit`>",1
+ggforce,geom_mark_ellipse,9,0,0,null,1
+ggforce,geom_mark_ellipse,10,0,0,class<`unit`>,1
+ggforce,geom_mark_ellipse,11,0,0,double,1
+ggforce,geom_mark_ellipse,12,0,0,double,1
+ggforce,geom_mark_ellipse,13,0,0,character,1
+ggforce,geom_mark_ellipse,14,0,0,double,1
+ggforce,geom_mark_ellipse,15,0,0,character[],1
+ggforce,geom_mark_hull,-1,0,0,"class<`Layer`, `LayerInstance`, `gg`, `ggproto`>",1
+ggforce,geom_mark_hull,0,0,0,class<`uneval`>,1
+ggforce,geom_mark_hull,1,0,0,null,1
+ggforce,geom_mark_hull,2,0,0,character,1
+ggforce,geom_mark_hull,3,0,0,character,1
+ggforce,geom_mark_hull,4,0,0,class<`unit`>,1
+ggforce,geom_mark_hull,5,0,0,class<`unit`>,1
+ggforce,geom_mark_hull,6,0,0,double,1
+ggforce,geom_mark_hull,7,0,0,"class<`margin`, `unit`>",1
+ggforce,geom_mark_hull,8,0,0,null,1
+ggforce,geom_mark_hull,9,0,0,class<`unit`>,1
+ggforce,geom_mark_hull,10,0,0,double,1
+ggforce,geom_mark_hull,11,0,0,double,1
+ggforce,geom_mark_hull,12,0,0,character,1
+ggforce,geom_mark_hull,13,0,0,double,1
+ggforce,geom_mark_hull,14,0,0,character[],1
+ggforce,geom_mark_hull,15,0,0,character,1
+ggforce,geom_mark_rect,-1,0,0,"class<`Layer`, `LayerInstance`, `gg`, `ggproto`>",1
+ggforce,geom_mark_rect,0,0,0,class<`uneval`>,1
+ggforce,geom_mark_rect,1,0,0,null,1
+ggforce,geom_mark_rect,2,0,0,character,1
+ggforce,geom_mark_rect,3,0,0,character,1
+ggforce,geom_mark_rect,4,0,0,class<`unit`>,1
+ggforce,geom_mark_rect,5,0,0,class<`unit`>,1
+ggforce,geom_mark_rect,6,0,0,"class<`margin`, `unit`>",1
+ggforce,geom_mark_rect,7,0,0,null,1
+ggforce,geom_mark_rect,8,0,0,class<`unit`>,1
+ggforce,geom_mark_rect,9,0,0,double,1
+ggforce,geom_mark_rect,10,0,0,double,1
+ggforce,geom_mark_rect,11,0,0,character,1
+ggforce,geom_mark_rect,12,0,0,double,1
+ggforce,geom_mark_rect,13,0,0,character[],1
+ggforce,geom_mark_rect,14,0,0,character,1
+ggforce,geom_mark_rect,15,0,0,character,1
+ggforce,geom_parallel_sets,-1,0,0,"class<`Layer`, `LayerInstance`, `gg`, `ggproto`>",1
+ggforce,geom_parallel_sets,0,0,0,class<`uneval`>,1
+ggforce,geom_parallel_sets,1,0,0,null,1
+ggforce,geom_parallel_sets,2,0,0,character,1
+ggforce,geom_parallel_sets,3,0,0,character,1
+ggforce,geom_parallel_sets,4,0,0,double,1
+ggforce,geom_parallel_sets,5,0,0,logical,1
+ggforce,geom_parallel_sets,6,0,0,double,1
+ggforce,geom_parallel_sets,7,0,0,double,1
+ggforce,geom_parallel_sets,8,0,0,double,1
+ggforce,geom_parallel_sets,9,0,0,null,1
+ggforce,geom_parallel_sets,10,0,0,logical,1
+ggforce,geom_parallel_sets,11,0,0,...,1
+ggforce,geom_parallel_sets_axes,-1,0,0,"class<`Layer`, `LayerInstance`, `gg`, `ggproto`>",1
+ggforce,geom_parallel_sets_axes,0,0,0,null,1
+ggforce,geom_parallel_sets_axes,1,0,0,null,1
+ggforce,geom_parallel_sets_axes,2,0,0,character,1
+ggforce,geom_parallel_sets_axes,3,0,0,character,1
+ggforce,geom_parallel_sets_axes,4,0,0,logical,1
+ggforce,geom_parallel_sets_axes,5,0,0,null,1
+ggforce,geom_parallel_sets_axes,6,0,0,logical,1
+ggforce,geom_parallel_sets_axes,7,0,0,...,1
+ggforce,geom_parallel_sets_labels,-1,0,0,"class<`Layer`, `LayerInstance`, `gg`, `ggproto`>",1
+ggforce,geom_parallel_sets_labels,0,0,0,null,1
+ggforce,geom_parallel_sets_labels,1,0,0,null,1
+ggforce,geom_parallel_sets_labels,2,0,0,character,1
+ggforce,geom_parallel_sets_labels,3,0,0,double,1
+ggforce,geom_parallel_sets_labels,4,0,0,character,1
+ggforce,geom_parallel_sets_labels,5,0,0,logical,1
+ggforce,geom_parallel_sets_labels,6,0,0,null,1
+ggforce,geom_parallel_sets_labels,7,0,0,logical,1
+ggforce,geom_parallel_sets_labels,8,0,0,...,1
+ggforce,geom_regon,-1,0,0,"class<`Layer`, `LayerInstance`, `gg`, `ggproto`>",1
+ggforce,geom_regon,0,0,0,class<`uneval`>,1
+ggforce,geom_regon,1,0,0,null,1
+ggforce,geom_regon,2,0,0,character,1
+ggforce,geom_regon,3,0,0,character,1
+ggforce,geom_regon,4,0,0,logical,1
+ggforce,geom_regon,5,0,0,null,1
+ggforce,geom_regon,6,0,0,logical,1
+ggforce,geom_regon,7,0,0,...,1
+ggforce,geom_shape,-1,0,0,"class<`Layer`, `LayerInstance`, `gg`, `ggproto`>",1
+ggforce,geom_shape,0,0,0,null,1
+ggforce,geom_shape,1,0,0,null,1
+ggforce,geom_shape,2,0,0,character,1
+ggforce,geom_shape,3,0,0,character,1
+ggforce,geom_shape,4,0,0,class<`unit`>,1
+ggforce,geom_shape,4,0,1,double,1
+ggforce,geom_shape,5,0,0,class<`unit`>,1
+ggforce,geom_shape,5,0,1,double,1
+ggforce,geom_shape,6,0,0,...,1
+ggforce,geom_shape,7,0,0,logical,1
+ggforce,geom_shape,8,0,0,null,1
+ggforce,geom_shape,9,0,0,logical,1
+ggforce,geom_sina,-1,0,0,"class<`Layer`, `LayerInstance`, `gg`, `ggproto`>",1
+ggforce,geom_sina,0,0,0,class<`uneval`>,1
+ggforce,geom_sina,0,0,1,null,1
+ggforce,geom_sina,1,0,0,null,1
+ggforce,geom_sina,2,0,0,character,1
+ggforce,geom_sina,3,0,0,character,1
+ggforce,geom_sina,4,0,0,...,1
+ggforce,geom_sina,5,0,0,logical,1
+ggforce,geom_sina,6,0,0,null,1
+ggforce,geom_sina,7,0,0,logical,1
+ggforce,geom_spiro,-1,0,0,"class<`Layer`, `LayerInstance`, `gg`, `ggproto`>",1
+ggforce,geom_spiro,0,0,0,class<`uneval`>,1
+ggforce,geom_spiro,1,0,0,null,1
+ggforce,geom_spiro,2,0,0,character,1
+ggforce,geom_spiro,3,0,0,character,1
+ggforce,geom_spiro,4,0,0,null,1
+ggforce,geom_spiro,5,0,0,double,1
+ggforce,geom_spiro,6,0,0,character,1
+ggforce,geom_spiro,7,0,0,logical,1
+ggforce,geom_spiro,8,0,0,null,1
+ggforce,geom_spiro,9,0,0,logical,1
+ggforce,geom_spiro,10,0,0,...,1
+ggforce,geom_voronoi_segment,-1,0,0,"class<`Layer`, `LayerInstance`, `gg`, `ggproto`>",1
+ggforce,geom_voronoi_segment,0,0,0,null,1
+ggforce,geom_voronoi_segment,1,0,0,null,1
+ggforce,geom_voronoi_segment,2,0,0,character,1
+ggforce,geom_voronoi_segment,3,0,0,character,1
+ggforce,geom_voronoi_segment,4,0,0,logical,1
+ggforce,geom_voronoi_segment,5,0,0,null,1
+ggforce,geom_voronoi_segment,6,0,0,double,1
+ggforce,geom_voronoi_segment,7,0,0,logical,1
+ggforce,geom_voronoi_segment,8,0,0,double,1
+ggforce,geom_voronoi_segment,9,0,0,null,1
+ggforce,geom_voronoi_segment,10,0,0,logical,1
+ggforce,geom_voronoi_segment,11,0,0,...,1
+ggforce,geom_voronoi_tile,-1,0,0,"class<`Layer`, `LayerInstance`, `gg`, `ggproto`>",1
+ggforce,geom_voronoi_tile,0,0,0,class<`uneval`>,1
+ggforce,geom_voronoi_tile,1,0,0,null,1
+ggforce,geom_voronoi_tile,2,0,0,character,1
+ggforce,geom_voronoi_tile,3,0,0,character,1
+ggforce,geom_voronoi_tile,4,0,0,logical,1
+ggforce,geom_voronoi_tile,5,0,0,class<`matrix`>,1
+ggforce,geom_voronoi_tile,5,0,1,null,1
+ggforce,geom_voronoi_tile,6,0,0,double,1
+ggforce,geom_voronoi_tile,7,0,0,null,1
+ggforce,geom_voronoi_tile,7,0,1,double,1
+ggforce,geom_voronoi_tile,8,0,0,logical,1
+ggforce,geom_voronoi_tile,9,0,0,double,1
+ggforce,geom_voronoi_tile,10,0,0,double,1
+ggforce,geom_voronoi_tile,10,0,1,class<`unit`>,1
+ggforce,geom_voronoi_tile,11,0,0,double,1
+ggforce,geom_voronoi_tile,11,0,1,class<`unit`>,1
+ggforce,geom_voronoi_tile,12,0,0,null,1
+ggforce,geom_voronoi_tile,13,0,0,logical,1
+ggforce,geom_voronoi_tile,14,0,0,...,1
+ggforce,linear_trans,-1,0,0,class<`trans`>,1
+ggforce,linear_trans,0,0,0,...,1
+ggforce,n_pages,-1,0,0,double,1
+ggforce,n_pages,0,0,0,"class<`gg`, `ggplot`>",1
+ggforce,position_auto,-1,0,0,"class<`Position`, `PositionAuto`, `gg`, `ggproto`>",1
+ggforce,position_auto,0,0,0,double,1
+ggforce,position_auto,1,0,0,character,1
+ggforce,position_auto,2,0,0,logical,1
+ggforce,position_auto,3,0,0,null,1
+ggforce,position_jitternormal,-1,0,0,"class<`Position`, `PositionJitterNormal`, `gg`, `ggproto`>",1
+ggforce,position_jitternormal,0,0,0,double,1
+ggforce,position_jitternormal,0,0,1,null,1
+ggforce,position_jitternormal,1,0,0,double,1
+ggforce,position_jitternormal,1,0,1,null,1
+ggforce,power_trans,-1,0,0,class<`trans`>,1
+ggforce,power_trans,0,0,0,double,1
+ggforce,radial_trans,-1,0,0,class<`trans`>,1
+ggforce,radial_trans,0,0,0,double[],1
+ggforce,radial_trans,1,0,0,double[],1
+ggforce,radial_trans,2,0,0,any,1
+ggforce,radial_trans,3,0,0,double,1
+ggforce,radial_trans,4,0,0,logical,1
+ggforce,rotate,-1,0,0,class<`matrix`>,1
+ggforce,rotate,0,0,0,double,1
+ggforce,scale_depth,-1,0,0,"class<`Scale`, `ScaleContinuous`, `gg`, `ggproto`>",1
+ggforce,scale_depth,0,0,0,...,1
+ggforce,scale_depth,1,0,0,double[],1
+ggforce,scale_x_unit,-1,0,0,"class<`Scale`, `ScaleContinuous`, `ScaleContinuousPosition`, `ScaleContinuousPositionUnit`, `gg`, `ggproto`>",1
+ggforce,scale_x_unit,0,0,0,class<`waiver`>,1
+ggforce,scale_x_unit,1,0,0,class<`waiver`>,1
+ggforce,scale_x_unit,2,0,0,character,1
+ggforce,scale_x_unit,3,0,0,class<`waiver`>,1
+ggforce,scale_x_unit,4,0,0,class<`waiver`>,1
+ggforce,scale_x_unit,5,0,0,null,1
+ggforce,scale_x_unit,6,0,0,class<`waiver`>,1
+ggforce,scale_x_unit,7,0,0,class<`function`>,1
+ggforce,scale_x_unit,8,0,0,null,1
+ggforce,scale_x_unit,9,0,0,character,1
+ggforce,scale_x_unit,10,0,0,character,1
+ggforce,scale_x_unit,11,0,0,class<`waiver`>,1
+ggforce,scale_y_unit,-1,0,0,"class<`Scale`, `ScaleContinuous`, `ScaleContinuousPosition`, `ScaleContinuousPositionUnit`, `gg`, `ggproto`>",1
+ggforce,scale_y_unit,0,0,0,class<`waiver`>,1
+ggforce,scale_y_unit,1,0,0,class<`waiver`>,1
+ggforce,scale_y_unit,2,0,0,character,1
+ggforce,scale_y_unit,3,0,0,class<`waiver`>,1
+ggforce,scale_y_unit,4,0,0,class<`waiver`>,1
+ggforce,scale_y_unit,5,0,0,null,1
+ggforce,scale_y_unit,6,0,0,class<`waiver`>,1
+ggforce,scale_y_unit,7,0,0,class<`function`>,1
+ggforce,scale_y_unit,8,0,0,null,1
+ggforce,scale_y_unit,9,0,0,character,1
+ggforce,scale_y_unit,10,0,0,character,1
+ggforce,scale_y_unit,11,0,0,class<`waiver`>,1
+ggforce,shear,-1,0,0,class<`matrix`>,1
+ggforce,shear,0,0,0,double,1
+ggforce,shear,1,0,0,double,1
+ggforce,theme_no_axes,-1,0,0,"class<`gg`, `theme`>",1
+ggforce,theme_no_axes,0,0,0,"class<`gg`, `theme`>",1
+ggforce,translate,-1,0,0,class<`matrix`>,1
+ggforce,translate,0,0,0,double,1
+ggforce,translate,1,0,0,double,1
+ggforce,trans_reverser,-1,0,0,class<`trans`>,1
+ggforce,trans_reverser,0,0,0,character,1
+ggforce,try_require,-1,0,0,null,1
+ggforce,try_require,0,0,0,character,1
+ggforce,try_require,1,0,0,character,1
+ggpubr,.add_center_line,-1,0,0,"class<`gg`, `ggplot`>",1
+ggpubr,.add_center_line,0,0,0,"class<`gg`, `ggplot`>",1
+ggpubr,.add_center_line,1,0,0,character,1
+ggpubr,.add_center_line,2,0,0,character[],1
+ggpubr,.add_center_line,3,0,0,character,1
+ggpubr,.add_center_line,4,0,0,character,1
+ggpubr,.add_center_line,5,0,0,null,1
+ggpubr,add_ctr_rows,-1,0,0,"class<`data.frame`, `tbl`, `tbl_df`>",1
+ggpubr,add_ctr_rows,0,0,0,"class<`data.frame`, `tbl`, `tbl_df`>",1
+ggpubr,add_ctr_rows,1,0,0,character,1
+ggpubr,.add_item,-1,0,0,list<any>,1
+ggpubr,.add_item,0,0,0,list<any>,1
+ggpubr,.add_item,1,0,0,...,1
+ggpubr,add_summary,-1,0,0,"class<`gg`, `ggplot`>",1
+ggpubr,add_summary,0,0,0,"class<`gg`, `ggplot`>",1
+ggpubr,add_summary,1,0,0,character,1
+ggpubr,add_summary,2,0,0,character,1
+ggpubr,add_summary,3,0,0,character,1
+ggpubr,add_summary,4,0,0,character,1
+ggpubr,add_summary,5,0,0,character,1
+ggpubr,add_summary,5,0,1,double,1
+ggpubr,add_summary,5,0,2,null,1
+ggpubr,add_summary,6,0,0,any,1
+ggpubr,add_summary,7,0,0,any,1
+ggpubr,annotate_figure,-1,0,0,"class<`gg`, `ggplot`>",1
+ggpubr,annotate_figure,0,0,0,"class<`gg`, `ggarrange`, `ggplot`>",1
+ggpubr,annotate_figure,1,0,0,"class<`gDesc`, `grob`, `text`>",1
+ggpubr,annotate_figure,2,0,0,"class<`gDesc`, `grob`, `text`>",1
+ggpubr,annotate_figure,3,0,0,"class<`gDesc`, `grob`, `text`>",1
+ggpubr,annotate_figure,4,0,0,character,1
+ggpubr,annotate_figure,5,0,0,character,1
+ggpubr,annotate_figure,6,0,0,character[],1
+ggpubr,annotate_figure,7,0,0,any,1
+ggpubr,as_ggplot,-1,0,0,"class<`gg`, `ggplot`>",1
+ggpubr,as_ggplot,0,0,0,"class<`gDesc`, `grob`, `splitText`>",1
+ggpubr,as_ggplot,0,0,1,"class<`gDesc`, `grob`, `text`>",1
+ggpubr,as_ggplot,0,0,2,"class<`gDesc`, `gTree`, `grob`, `gtable`>",1
+ggpubr,asserttat_group_columns_exists,-1,0,0,"class<`data.frame`, `tbl`, `tbl_df`>",1
+ggpubr,asserttat_group_columns_exists,0,0,0,"class<`data.frame`, `tbl`, `tbl_df`>",1
+ggpubr,bgcolor,-1,0,0,"class<`gg`, `theme`>",1
+ggpubr,bgcolor,0,0,0,character,1
+ggpubr,border,-1,0,0,"class<`gg`, `theme`>",1
+ggpubr,border,0,0,0,character,1
+ggpubr,border,1,0,0,double,1
+ggpubr,border,2,0,0,null,1
+ggpubr,.brewerpal,-1,0,0,character[],1
+ggpubr,build_signif_data,-1,0,0,class<`data.frame`>,1
+ggpubr,build_signif_data,-1,0,1,"class<`data.frame`, `tbl`, `tbl_df`>",1
+ggpubr,build_signif_data,0,0,0,null,1
+ggpubr,build_signif_data,0,0,1,"class<`data.frame`, `tbl`, `tbl_df`>",1
+ggpubr,build_signif_data,1,0,0,character[],1
+ggpubr,build_signif_data,1,0,1,null,1
+ggpubr,build_signif_data,2,0,0,double[],1
+ggpubr,build_signif_data,2,0,1,null,1
+ggpubr,build_signif_data,3,0,0,character[],1
+ggpubr,build_signif_data,3,0,1,null,1
+ggpubr,build_signif_data,4,0,0,character[],1
+ggpubr,build_signif_data,4,0,1,null,1
+ggpubr,build_signif_data,5,0,0,double,1
+ggpubr,build_signif_data,6,0,0,null,1
+ggpubr,build_signif_data,7,0,0,double,1
+ggpubr,build_signif_mapping,-1,0,0,class<`uneval`>,1
+ggpubr,build_signif_mapping,0,0,0,class<`uneval`>,1
+ggpubr,build_signif_mapping,0,0,1,null,1
+ggpubr,build_signif_mapping,1,0,0,"class<`data.frame`, `tbl`, `tbl_df`>",1
+ggpubr,build_signif_mapping,1,0,1,class<`data.frame`>,1
+ggpubr,.check_add.params,-1,0,0,list<character>,1
+ggpubr,.check_add.params,-1,0,1,list<double | character>,1
+ggpubr,.check_add.params,0,0,0,character[],1
+ggpubr,.check_add.params,1,0,0,list<any>,1
+ggpubr,.check_add.params,2,0,0,character,1
+ggpubr,.check_add.params,3,0,0,class<`data.frame`>,1
+ggpubr,.check_add.params,4,0,0,character,1
+ggpubr,.check_add.params,5,0,0,character,1
+ggpubr,.check_add.params,5,0,1,null,1
+ggpubr,.check_add.params,6,0,0,...,1
+ggpubr,.check_data,-1,0,0,list<character | class<`data.frame`>>,1
+ggpubr,.check_data,0,0,0,class<`data.frame`>,1
+ggpubr,.check_data,1,0,0,character,1
+ggpubr,.check_data,2,0,0,character,1
+ggpubr,.check_data,2,0,1,null,1
+ggpubr,.check_data,3,0,0,logical,1
+ggpubr,.check_lab_font,-1,0,0,list<double | character>,1
+ggpubr,.check_lab_font,0,0,0,list<double | character>,1
+ggpubr,.check_legend,-1,0,0,character,1
+ggpubr,.check_legend,-1,0,1,null,1
+ggpubr,.check_legend,0,0,0,character,1
+ggpubr,.check_legend,0,0,1,null,1
+ggpubr,.check_margin_params,-1,0,0,list<character>,1
+ggpubr,.check_margin_params,-1,0,1,list<character | double>,1
+ggpubr,.check_margin_params,0,0,0,list<any>,1
+ggpubr,.check_margin_params,1,0,0,any,1
+ggpubr,.check_margin_params,2,0,0,any,1
+ggpubr,.check_margin_params,3,0,0,any,1
+ggpubr,.check_margin_params,4,0,0,character,1
+ggpubr,.check_pie_labfont,-1,0,0,list<double | character>,1
+ggpubr,.check_pie_labfont,0,0,0,list<double | character>,1
+ggpubr,.check_pie_labfont,0,0,1,list<null | character>,1
+ggpubr,clean_theme,-1,0,0,"class<`gg`, `theme`>",1
+ggpubr,.collapse,-1,0,0,character,1
+ggpubr,.collapse,0,0,0,character,1
+ggpubr,.collapse,1,0,0,character,1
+ggpubr,.collapse,2,0,0,character,1
+ggpubr,colnames_style,-1,0,0,list<list<character | double>>,1
+ggpubr,colnames_style,-1,0,1,list<list<character | double | null | double | character>>,1
+ggpubr,colnames_style,-1,0,2,list<list<character | double | null | double>>,1
+ggpubr,colnames_style,0,0,0,character,1
+ggpubr,colnames_style,1,0,0,character,1
+ggpubr,colnames_style,2,0,0,double,1
+ggpubr,colnames_style,3,0,0,character,1
+ggpubr,colnames_style,3,0,1,null,1
+ggpubr,colnames_style,4,0,0,double,1
+ggpubr,colnames_style,5,0,0,character,1
+ggpubr,colnames_style,5,0,1,null,1
+ggpubr,colnames_style,6,0,0,logical,1
+ggpubr,colnames_style,7,0,0,...,1
+ggpubr,color_palette,-1,0,0,"class<`Scale`, `ScaleDiscrete`, `gg`, `ggproto`>",1
+ggpubr,color_palette,-1,0,1,null,1
+ggpubr,color_palette,0,0,0,character[],1
+ggpubr,color_palette,0,0,1,null,1
+ggpubr,color_palette,1,0,0,...,1
+ggpubr,.compact,-1,0,0,list<any>,1
+ggpubr,.compact,0,0,0,list<null>,1
+ggpubr,.compact,0,0,1,list<character>,1
+ggpubr,.compact,0,0,2,list<double | character | null>,1
+ggpubr,.compact,0,0,3,"list<class<`gDesc`, `grob`, `text`> | character>",1
+ggpubr,.compact,0,0,4,list<character | class<`data.frame`> | null>,1
+ggpubr,.compact,0,0,5,list<character | class<`data.frame`>>,1
+ggpubr,compare_means,-1,0,0,"class<`data.frame`, `tbl`, `tbl_df`>",1
+ggpubr,compare_means,0,0,0,class<`formula`>,1
+ggpubr,compare_means,1,0,0,class<`data.frame`>,1
+ggpubr,compare_means,2,0,0,character,1
+ggpubr,compare_means,3,0,0,logical,1
+ggpubr,compare_means,4,0,0,character,1
+ggpubr,compare_means,4,0,1,null,1
+ggpubr,compare_means,5,0,0,null,1
+ggpubr,compare_means,5,0,1,character,1
+ggpubr,compare_means,6,0,0,list<any>,1
+ggpubr,compare_means,7,0,0,character,1
+ggpubr,.contains_curlybracket,-1,0,0,logical,1
+ggpubr,.contains_curlybracket,0,0,0,character,1
+ggpubr,desc_statby,-1,0,0,class<`data.frame`>,1
+ggpubr,desc_statby,0,0,0,class<`data.frame`>,1
+ggpubr,desc_statby,1,0,0,character,1
+ggpubr,desc_statby,2,0,0,character[],1
+ggpubr,desc_statby,3,0,0,double,1
+ggpubr,detect_comparison_type,-1,0,0,character,1
+ggpubr,detect_comparison_type,0,0,0,"class<`data.frame`, `tbl`, `tbl_df`>",1
+ggpubr,.df_strech,-1,0,0,class<`data.frame`>,1
+ggpubr,.df_strech,0,0,0,class<`data.frame`>,1
+ggpubr,facet,-1,0,0,"class<`gg`, `ggplot`>",1
+ggpubr,facet,0,0,0,"class<`gg`, `ggplot`>",1
+ggpubr,facet,1,0,0,character[],1
+ggpubr,facet,2,0,0,null,1
+ggpubr,facet,3,0,0,null,1
+ggpubr,facet,4,0,0,character,1
+ggpubr,facet,5,0,0,logical,1
+ggpubr,facet,6,0,0,null,1
+ggpubr,facet,7,0,0,list<null>,1
+ggpubr,facet,7,0,1,list<character>,1
+ggpubr,fill_palette,-1,0,0,"class<`Scale`, `ScaleDiscrete`, `gg`, `ggproto`>",1
+ggpubr,fill_palette,-1,0,1,null,1
+ggpubr,fill_palette,0,0,0,character[],1
+ggpubr,fill_palette,0,0,1,null,1
+ggpubr,fill_palette,1,0,0,...,1
+ggpubr,.find_cell,-1,0,0,integer,1
+ggpubr,.find_cell,0,0,0,"class<`gDesc`, `gTree`, `grob`, `gtable`>",1
+ggpubr,.find_cell,1,0,0,double,1
+ggpubr,.find_cell,2,0,0,double,1
+ggpubr,.find_cell,3,0,0,character,1
+ggpubr,font,-1,0,0,"class<`gg`, `theme`>",1
+ggpubr,font,0,0,0,character,1
+ggpubr,font,1,0,0,double,1
+ggpubr,font,1,0,1,null,1
+ggpubr,font,2,0,0,character,1
+ggpubr,font,3,0,0,character,1
+ggpubr,font,3,0,1,null,1
+ggpubr,font,4,0,0,null,1
+ggpubr,font,5,0,0,...,1
+ggpubr,.format_error,-1,0,0,class<`data.frame`>,1
+ggpubr,.format_error,0,0,0,class<`data.frame`>,1
+ggpubr,.format_error,1,0,0,character,1
+ggpubr,.formula_left_variables,-1,0,0,character,1
+ggpubr,.formula_left_variables,0,0,0,class<`formula`>,1
+ggpubr,.formula_right_variables,-1,0,0,character,1
+ggpubr,.formula_right_variables,0,0,0,class<`formula`>,1
+ggpubr,.geom,-1,0,0,character,1
+ggpubr,.geom,0,0,0,"class<`gg`, `ggplot`>",1
+ggpubr,.geom,1,0,0,double,1
+ggpubr,geom_bracket,-1,0,0,"class<`Layer`, `LayerInstance`, `gg`, `ggproto`>",1
+ggpubr,geom_bracket,0,0,0,class<`uneval`>,1
+ggpubr,geom_bracket,0,0,1,null,1
+ggpubr,geom_bracket,1,0,0,"class<`data.frame`, `tbl`, `tbl_df`>",1
+ggpubr,geom_bracket,1,0,1,null,1
+ggpubr,geom_bracket,2,0,0,character,1
+ggpubr,geom_bracket,3,0,0,character,1
+ggpubr,geom_bracket,4,0,0,logical,1
+ggpubr,geom_bracket,5,0,0,null,1
+ggpubr,geom_bracket,6,0,0,logical,1
+ggpubr,geom_bracket,7,0,0,null,1
+ggpubr,geom_bracket,7,0,1,character[],1
+ggpubr,.geom_exec,-1,0,0,"class<`Layer`, `LayerInstance`, `gg`, `ggproto`>",1
+ggpubr,.geom_exec,-1,0,1,list<list<any>>,1
+ggpubr,.geom_exec,0,0,0,class<`function`>,1
+ggpubr,.geom_exec,0,0,1,null,1
+ggpubr,.geom_exec,1,0,0,class<`data.frame`>,1
+ggpubr,.geom_exec,2,0,0,null,1
+ggpubr,.geom_exec,3,0,0,...,1
+ggpubr,geom_exec,-1,0,0,"class<`Layer`, `LayerInstance`, `gg`, `ggproto`>",1
+ggpubr,geom_exec,-1,0,1,list<list<any>>,1
+ggpubr,geom_exec,0,0,0,class<`function`>,1
+ggpubr,geom_exec,0,0,1,null,1
+ggpubr,geom_exec,0,0,2,character,1
+ggpubr,geom_exec,1,0,0,class<`data.frame`>,1
+ggpubr,geom_exec,1,0,1,"class<`data.frame`, `tbl`, `tbl_df`>",1
+ggpubr,geom_exec,2,0,0,"class<`Position`, `PositionDodge`, `gg`, `ggproto`>",1
+ggpubr,geom_exec,2,0,1,"class<`Position`, `PositionIdentity`, `gg`, `ggproto`>",1
+ggpubr,geom_exec,2,0,2,"class<`Position`, `PositionStack`, `gg`, `ggproto`>",1
+ggpubr,geom_exec,2,0,3,null,1
+ggpubr,geom_exec,2,0,4,character,1
+ggpubr,geom_exec,2,0,5,"class<`Position`, `PositionJitterdodge`, `gg`, `ggproto`>",1
+ggpubr,geom_exec,2,0,6,"class<`Position`, `PositionJitter`, `gg`, `ggproto`>",1
+ggpubr,geom_exec,3,0,0,...,1
+ggpubr,.get_brewer_pal,-1,0,0,character[],1
+ggpubr,.get_brewer_pal,0,0,0,character,1
+ggpubr,.get_brewer_pal,1,0,0,double,1
+ggpubr,.get_ggsci_pal,-1,0,0,character[],1
+ggpubr,.get_ggsci_pal,0,0,0,character,1
+ggpubr,.get_ggsci_pal,1,0,0,double,1
+ggpubr,.get_gg_xy_variables,-1,0,0,character[],1
+ggpubr,.get_gg_xy_variables,0,0,0,"class<`gg`, `ggplot`>",1
+ggpubr,.get_label_data,-1,0,0,class<`data.frame`>,1
+ggpubr,.get_label_data,0,0,0,class<`data.frame`>,1
+ggpubr,.get_label_data,1,0,0,any,1
+ggpubr,.get_label_data,2,0,0,any,1
+ggpubr,.get_label_data,3,0,0,character,1
+ggpubr,.get_label_data,4,0,0,character[],1
+ggpubr,.get_label_data,5,0,0,any,1
+ggpubr,.get_layout,-1,0,0,list<double>,1
+ggpubr,.get_layout,-1,0,1,list<null>,1
+ggpubr,.get_layout,0,0,0,double,1
+ggpubr,.get_layout,0,0,1,null,1
+ggpubr,.get_layout,1,0,0,double,1
+ggpubr,.get_layout,1,0,1,null,1
+ggpubr,.get_layout,2,0,0,any,1
+ggpubr,.get_legend,-1,0,0,"class<`gDesc`, `gTree`, `grob`, `gtable`>",1
+ggpubr,.get_legend,-1,0,1,null,1
+ggpubr,.get_legend,0,0,0,"class<`gg`, `ggplot`>",1
+ggpubr,get_legend,-1,0,0,"class<`gDesc`, `gTree`, `grob`, `gtable`>",1
+ggpubr,get_legend,-1,0,1,null,1
+ggpubr,get_legend,0,0,0,"class<`gg`, `ggplot`>",1
+ggpubr,get_legend,0,0,1,"list<class<`gg`, `ggplot`>>",1
+ggpubr,.get_not_numeric_vars,-1,0,0,character,1
+ggpubr,.get_not_numeric_vars,0,0,0,class<`data.frame`>,1
+ggpubr,.get_pal,-1,0,0,character[],1
+ggpubr,.get_pal,0,0,0,character,1
+ggpubr,.get_pal,1,0,0,double,1
+ggpubr,get_palette,-1,0,0,character[],1
+ggpubr,get_palette,0,0,0,character[],1
+ggpubr,get_palette,1,0,0,double,1
+ggpubr,.get_panel,-1,0,0,"class<`gDesc`, `gTree`, `grob`>",1
+ggpubr,.get_panel,0,0,0,"class<`gg`, `ggplot`>",1
+ggpubr,ggadd,-1,0,0,"class<`gg`, `ggplot`>",1
+ggpubr,ggadd,0,0,0,"class<`gg`, `ggplot`>",1
+ggpubr,ggadd,1,0,0,character[],1
+ggpubr,ggadd,2,0,0,character,1
+ggpubr,ggadd,3,0,0,character,1
+ggpubr,ggadd,4,0,0,double,1
+ggpubr,ggadd,5,0,0,double,1
+ggpubr,ggadd,6,0,0,double,1
+ggpubr,ggadd,7,0,0,null,1
+ggpubr,ggarrange,-1,0,0,"class<`gg`, `ggarrange`, `ggplot`>",1
+ggpubr,ggarrange,0,0,0,...,1
+ggpubr,ggarrange,1,0,0,null,1
+ggpubr,ggarrange,2,0,0,double,1
+ggpubr,ggarrange,2,0,1,null,1
+ggpubr,ggarrange,3,0,0,double,1
+ggpubr,ggarrange,3,0,1,null,1
+ggpubr,ggarrange,4,0,0,null,1
+ggpubr,ggarrange,5,0,0,double,1
+ggpubr,ggarrange,6,0,0,double,1
+ggpubr,ggarrange,7,0,0,double,1
+ggpubr,ggballoonplot,-1,0,0,"class<`gg`, `ggplot`>",1
+ggpubr,ggballoonplot,0,0,0,class<`data.frame`>,1
+ggpubr,ggballoonplot,1,0,0,character,1
+ggpubr,ggballoonplot,1,0,1,null,1
+ggpubr,ggballoonplot,2,0,0,character,1
+ggpubr,ggballoonplot,2,0,1,null,1
+ggpubr,ggballoonplot,3,0,0,character,1
+ggpubr,ggballoonplot,3,0,1,double,1
+ggpubr,ggballoonplot,4,0,0,character[],1
+ggpubr,ggballoonplot,4,0,1,null,1
+ggpubr,ggballoonplot,5,0,0,double[],1
+ggpubr,ggballoonplot,6,0,0,double,1
+ggpubr,ggballoonplot,7,0,0,character,1
+ggpubr,ggbarplot,-1,0,0,"class<`gg`, `ggplot`>",1
+ggpubr,ggbarplot,0,0,0,class<`data.frame`>,1
+ggpubr,ggbarplot,1,0,0,character,1
+ggpubr,ggbarplot,2,0,0,character,1
+ggpubr,ggbarplot,3,0,0,logical,1
+ggpubr,ggbarplot,4,0,0,logical,1
+ggpubr,ggbarplot,5,0,0,character,1
+ggpubr,ggbarplot,6,0,0,character,1
+ggpubr,ggbarplot,7,0,0,character[],1
+ggpubr,ggbarplot,7,0,1,null,1
+ggpubr,ggboxplot,-1,0,0,"class<`gg`, `ggplot`>",1
+ggpubr,ggboxplot,0,0,0,class<`data.frame`>,1
+ggpubr,ggboxplot,1,0,0,character,1
+ggpubr,ggboxplot,2,0,0,character,1
+ggpubr,ggboxplot,3,0,0,logical,1
+ggpubr,ggboxplot,4,0,0,logical,1
+ggpubr,ggboxplot,5,0,0,character,1
+ggpubr,ggboxplot,6,0,0,character,1
+ggpubr,ggboxplot,7,0,0,character[],1
+ggpubr,ggboxplot,7,0,1,null,1
+ggpubr,.ggcolor,-1,0,0,"class<`Scale`, `ScaleDiscrete`, `gg`, `ggproto`>",1
+ggpubr,.ggcolor,-1,0,1,null,1
+ggpubr,.ggcolor,0,0,0,character[],1
+ggpubr,.ggcolor,0,0,1,null,1
+ggpubr,.ggcolor,1,0,0,...,1
+ggpubr,ggdensity,-1,0,0,"class<`gg`, `ggplot`>",1
+ggpubr,ggdensity,0,0,0,class<`data.frame`>,1
+ggpubr,ggdensity,1,0,0,character,1
+ggpubr,ggdensity,2,0,0,character,1
+ggpubr,ggdensity,3,0,0,logical,1
+ggpubr,ggdensity,4,0,0,logical,1
+ggpubr,ggdensity,5,0,0,character,1
+ggpubr,ggdensity,6,0,0,character,1
+ggpubr,ggdensity,6,0,1,null,1
+ggpubr,ggdensity,7,0,0,character[],1
+ggpubr,ggdensity,7,0,1,null,1
+ggpubr,ggdonutchart,-1,0,0,"class<`gg`, `ggplot`>",1
+ggpubr,ggdonutchart,0,0,0,class<`data.frame`>,1
+ggpubr,ggdonutchart,1,0,0,character,1
+ggpubr,ggdonutchart,2,0,0,character[],1
+ggpubr,ggdonutchart,3,0,0,character[],1
+ggpubr,ggdonutchart,4,0,0,double,1
+ggpubr,ggdonutchart,5,0,0,character[],1
+ggpubr,ggdonutchart,6,0,0,character,1
+ggpubr,ggdonutchart,7,0,0,character,1
+ggpubr,ggdotchart,-1,0,0,"class<`gg`, `ggplot`>",1
+ggpubr,ggdotchart,0,0,0,class<`data.frame`>,1
+ggpubr,ggdotchart,1,0,0,character,1
+ggpubr,ggdotchart,2,0,0,character,1
+ggpubr,ggdotchart,3,0,0,null,1
+ggpubr,ggdotchart,3,0,1,character,1
+ggpubr,ggdotchart,4,0,0,logical,1
+ggpubr,ggdotchart,5,0,0,character,1
+ggpubr,ggdotchart,6,0,0,character[],1
+ggpubr,ggdotchart,6,0,1,null,1
+ggpubr,ggdotchart,7,0,0,double,1
+ggpubr,ggdotplot,-1,0,0,"class<`gg`, `ggplot`>",1
+ggpubr,ggdotplot,0,0,0,class<`data.frame`>,1
+ggpubr,ggdotplot,1,0,0,character,1
+ggpubr,ggdotplot,2,0,0,character,1
+ggpubr,ggdotplot,3,0,0,logical,1
+ggpubr,ggdotplot,4,0,0,logical,1
+ggpubr,ggdotplot,5,0,0,character,1
+ggpubr,ggdotplot,6,0,0,character,1
+ggpubr,ggdotplot,7,0,0,character[],1
+ggpubr,ggdotplot,7,0,1,null,1
+ggpubr,ggecdf,-1,0,0,"class<`gg`, `ggplot`>",1
+ggpubr,ggecdf,0,0,0,class<`data.frame`>,1
+ggpubr,ggecdf,1,0,0,character,1
+ggpubr,ggecdf,2,0,0,logical,1
+ggpubr,ggecdf,3,0,0,logical,1
+ggpubr,ggecdf,4,0,0,character,1
+ggpubr,ggecdf,5,0,0,character[],1
+ggpubr,ggecdf,5,0,1,null,1
+ggpubr,ggecdf,6,0,0,null,1
+ggpubr,ggecdf,7,0,0,character,1
+ggpubr,ggerrorplot,-1,0,0,"class<`gg`, `ggplot`>",1
+ggpubr,ggerrorplot,0,0,0,class<`data.frame`>,1
+ggpubr,ggerrorplot,1,0,0,character,1
+ggpubr,ggerrorplot,2,0,0,character,1
+ggpubr,ggerrorplot,3,0,0,character,1
+ggpubr,ggerrorplot,4,0,0,logical,1
+ggpubr,ggerrorplot,5,0,0,logical,1
+ggpubr,ggerrorplot,6,0,0,character,1
+ggpubr,ggerrorplot,7,0,0,character,1
+ggpubr,.ggfill,-1,0,0,"class<`Scale`, `ScaleDiscrete`, `gg`, `ggproto`>",1
+ggpubr,.ggfill,-1,0,1,null,1
+ggpubr,.ggfill,0,0,0,character[],1
+ggpubr,.ggfill,0,0,1,null,1
+ggpubr,.ggfill,1,0,0,...,1
+ggpubr,gghistogram,-1,0,0,"class<`gg`, `ggplot`>",1
+ggpubr,gghistogram,0,0,0,class<`data.frame`>,1
+ggpubr,gghistogram,1,0,0,character,1
+ggpubr,gghistogram,2,0,0,character,1
+ggpubr,gghistogram,3,0,0,logical,1
+ggpubr,gghistogram,4,0,0,logical,1
+ggpubr,gghistogram,5,0,0,character,1
+ggpubr,gghistogram,6,0,0,character,1
+ggpubr,gghistogram,6,0,1,null,1
+ggpubr,gghistogram,7,0,0,character[],1
+ggpubr,gghistogram,7,0,1,null,1
+ggpubr,ggline,-1,0,0,"class<`gg`, `ggplot`>",1
+ggpubr,ggline,0,0,0,class<`data.frame`>,1
+ggpubr,ggline,1,0,0,character,1
+ggpubr,ggline,2,0,0,character,1
+ggpubr,ggline,3,0,0,double,1
+ggpubr,ggline,4,0,0,logical,1
+ggpubr,ggline,5,0,0,logical,1
+ggpubr,ggline,6,0,0,logical,1
+ggpubr,ggline,7,0,0,character,1
+ggpubr,ggmaplot,-1,0,0,"class<`gg`, `ggplot`>",1
+ggpubr,ggmaplot,0,0,0,class<`data.frame`>,1
+ggpubr,ggmaplot,1,0,0,double,1
+ggpubr,ggmaplot,2,0,0,double,1
+ggpubr,ggmaplot,3,0,0,character[],1
+ggpubr,ggmaplot,4,0,0,null,1
+ggpubr,ggmaplot,5,0,0,double,1
+ggpubr,ggmaplot,6,0,0,character[],1
+ggpubr,ggmaplot,7,0,0,logical,1
+ggpubr,ggpaired,-1,0,0,"class<`gg`, `ggplot`>",1
+ggpubr,ggpaired,0,0,0,class<`data.frame`>,1
+ggpubr,ggpaired,1,0,0,any,1
+ggpubr,ggpaired,2,0,0,any,1
+ggpubr,ggpaired,3,0,0,null,1
+ggpubr,ggpaired,3,0,1,character,1
+ggpubr,ggpaired,4,0,0,null,1
+ggpubr,ggpaired,4,0,1,character,1
+ggpubr,ggpaired,5,0,0,null,1
+ggpubr,ggpaired,6,0,0,character,1
+ggpubr,ggpaired,7,0,0,character,1
+ggpubr,ggpar,-1,0,0,"class<`gg`, `ggplot`>",1
+ggpubr,ggpar,0,0,0,"class<`gg`, `ggplot`>",1
+ggpubr,ggpar,1,0,0,null,1
+ggpubr,ggpar,1,0,1,character[],1
+ggpubr,ggpar,2,0,0,null,1
+ggpubr,ggpar,2,0,1,character[],1
+ggpubr,ggpar,3,0,0,null,1
+ggpubr,ggpar,3,0,1,character,1
+ggpubr,ggpar,4,0,0,null,1
+ggpubr,ggpar,5,0,0,null,1
+ggpubr,ggpar,5,0,1,character,1
+ggpubr,ggpar,6,0,0,null,1
+ggpubr,ggpar,6,0,1,character,1
+ggpubr,ggpar,6,0,2,logical,1
+ggpubr,ggpar,7,0,0,null,1
+ggpubr,ggpar,7,0,1,character,1
+ggpubr,ggpar,7,0,2,logical,1
+ggpubr,ggparagraph,-1,0,0,"class<`gg`, `ggplot`>",1
+ggpubr,ggparagraph,0,0,0,character,1
+ggpubr,ggparagraph,1,0,0,null,1
+ggpubr,ggparagraph,2,0,0,double,1
+ggpubr,ggparagraph,3,0,0,character,1
+ggpubr,ggparagraph,4,0,0,null,1
+ggpubr,ggparagraph,5,0,0,null,1
+ggpubr,ggpie,-1,0,0,"class<`gg`, `ggplot`>",1
+ggpubr,ggpie,0,0,0,class<`data.frame`>,1
+ggpubr,ggpie,1,0,0,character,1
+ggpubr,ggpie,2,0,0,character[],1
+ggpubr,ggpie,3,0,0,character[],1
+ggpubr,ggpie,4,0,0,double,1
+ggpubr,ggpie,5,0,0,character[],1
+ggpubr,ggpie,6,0,0,character,1
+ggpubr,ggpie,7,0,0,character,1
+ggpubr,ggqqplot,-1,0,0,"class<`gg`, `ggplot`>",1
+ggpubr,ggqqplot,0,0,0,class<`data.frame`>,1
+ggpubr,ggqqplot,1,0,0,character,1
+ggpubr,ggqqplot,2,0,0,logical,1
+ggpubr,ggqqplot,3,0,0,logical,1
+ggpubr,ggqqplot,4,0,0,character,1
+ggpubr,ggqqplot,5,0,0,character[],1
+ggpubr,ggqqplot,5,0,1,null,1
+ggpubr,ggqqplot,6,0,0,null,1
+ggpubr,ggqqplot,7,0,0,null,1
+ggpubr,ggscatter,-1,0,0,"class<`gg`, `ggplot`>",1
+ggpubr,ggscatter,0,0,0,class<`data.frame`>,1
+ggpubr,ggscatter,1,0,0,character,1
+ggpubr,ggscatter,2,0,0,character,1
+ggpubr,ggscatter,3,0,0,logical,1
+ggpubr,ggscatter,4,0,0,logical,1
+ggpubr,ggscatter,5,0,0,character,1
+ggpubr,ggscatter,6,0,0,character,1
+ggpubr,ggscatter,6,0,1,null,1
+ggpubr,ggscatter,7,0,0,null,1
+ggpubr,ggscatter,7,0,1,character[],1
+ggpubr,ggscatterhist,-1,0,0,"class<`gg`, `ggplot`>",1
+ggpubr,ggscatterhist,0,0,0,class<`data.frame`>,1
+ggpubr,ggscatterhist,1,0,0,character,1
+ggpubr,ggscatterhist,2,0,0,character,1
+ggpubr,ggscatterhist,3,0,0,null,1
+ggpubr,ggscatterhist,4,0,0,character,1
+ggpubr,ggscatterhist,5,0,0,null,1
+ggpubr,ggscatterhist,6,0,0,character[],1
+ggpubr,ggscatterhist,6,0,1,null,1
+ggpubr,ggscatterhist,7,0,0,double,1
+ggpubr,.ggscipal,-1,0,0,character[],1
+ggpubr,ggstripchart,-1,0,0,"class<`gg`, `ggplot`>",1
+ggpubr,ggstripchart,0,0,0,class<`data.frame`>,1
+ggpubr,ggstripchart,1,0,0,character,1
+ggpubr,ggstripchart,2,0,0,character,1
+ggpubr,ggstripchart,3,0,0,logical,1
+ggpubr,ggstripchart,4,0,0,logical,1
+ggpubr,ggstripchart,5,0,0,character,1
+ggpubr,ggstripchart,6,0,0,character,1
+ggpubr,ggstripchart,7,0,0,character[],1
+ggpubr,ggstripchart,7,0,1,null,1
+ggpubr,ggtext,-1,0,0,"class<`gg`, `ggplot`>",1
+ggpubr,ggtext,0,0,0,class<`data.frame`>,1
+ggpubr,ggtext,1,0,0,character,1
+ggpubr,ggtext,2,0,0,character,1
+ggpubr,ggtext,3,0,0,character,1
+ggpubr,ggtext,4,0,0,character,1
+ggpubr,ggtext,5,0,0,any,1
+ggpubr,ggtext,6,0,0,double,1
+ggpubr,ggtext,7,0,0,character,1
+ggpubr,ggtexttable,-1,0,0,"class<`gg`, `ggplot`>",1
+ggpubr,ggtexttable,0,0,0,class<`data.frame`>,1
+ggpubr,ggtexttable,1,0,0,null,1
+ggpubr,ggtexttable,1,0,1,character[],1
+ggpubr,ggtexttable,2,0,0,character[],1
+ggpubr,ggtexttable,3,0,0,null,1
+ggpubr,ggtexttable,4,0,0,list<list<class<`function`> | class<`unit`> | list<character | double | character[] | double> | class<`function`> | class<`unit`> | list<character | double> | class<`function`> | class<`unit`> | list<character | double | null | double | character>>>,1
+ggpubr,ggtexttable,4,0,1,list<list<class<`function`> | class<`unit`> | list<character | double | null | double | character> | class<`function`> | class<`unit`> | list<character | double | null | double>>>,1
+ggpubr,ggtexttable,4,0,2,list<list<class<`function`> | class<`unit`> | list<character | double | null | double>>>,1
+ggpubr,ggtexttable,5,0,0,...,1
+ggpubr,ggviolin,-1,0,0,"class<`gg`, `ggplot`>",1
+ggpubr,ggviolin,0,0,0,class<`data.frame`>,1
+ggpubr,ggviolin,1,0,0,character,1
+ggpubr,ggviolin,2,0,0,character,1
+ggpubr,ggviolin,3,0,0,logical,1
+ggpubr,ggviolin,4,0,0,logical,1
+ggpubr,ggviolin,5,0,0,character,1
+ggpubr,ggviolin,6,0,0,character,1
+ggpubr,ggviolin,7,0,0,character[],1
+ggpubr,ggviolin,7,0,1,null,1
+ggpubr,.gradient_col,-1,0,0,"class<`Scale`, `ScaleContinuous`, `gg`, `ggproto`>",1
+ggpubr,.gradient_col,0,0,0,character[],1
+ggpubr,gradient_color,-1,0,0,"class<`Scale`, `ScaleContinuous`, `gg`, `ggproto`>",1
+ggpubr,gradient_color,0,0,0,character[],1
+ggpubr,gradient_fill,-1,0,0,"class<`Scale`, `ScaleContinuous`, `gg`, `ggproto`>",1
+ggpubr,gradient_fill,0,0,0,character[],1
+ggpubr,grids,-1,0,0,"class<`gg`, `theme`>",1
+ggpubr,grids,0,0,0,character[],1
+ggpubr,grids,1,0,0,character,1
+ggpubr,grids,2,0,0,null,1
+ggpubr,grids,3,0,0,character,1
+ggpubr,.group_by,-1,0,0,"class<`data.frame`, `grouped_df`, `tbl`, `tbl_df`>",1
+ggpubr,.group_by,0,0,0,class<`data.frame`>,1
+ggpubr,.group_by,1,0,0,character,1
+ggpubr,guess_labels_default_vjust,-1,0,0,double[],1
+ggpubr,guess_labels_default_vjust,0,0,0,character[],1
+ggpubr,guess_signif_label_column,-1,0,0,character,1
+ggpubr,guess_signif_label_column,0,0,0,class<`data.frame`>,1
+ggpubr,has_cowplot_v0.9,-1,0,0,logical,1
+ggpubr,.hist_label_data,-1,0,0,class<`data.frame`>,1
+ggpubr,.hist_label_data,0,0,0,"class<`gg`, `ggplot`>",1
+ggpubr,.hist_label_data,1,0,0,null,1
+ggpubr,.hist_label_data,2,0,0,character,1
+ggpubr,.hist_label_y,-1,0,0,class<`data.frame`>,1
+ggpubr,.hist_label_y,0,0,0,class<`data.frame`>,1
+ggpubr,.hist_label_y,1,0,0,class<`data.frame`>,1
+ggpubr,.hist_label_y,2,0,0,character,1
+ggpubr,.insert_xaxis_grob,-1,0,0,"class<`gDesc`, `gTree`, `grob`, `gtable`>",1
+ggpubr,.insert_xaxis_grob,0,0,0,"class<`gg`, `ggplot`>",1
+ggpubr,.insert_xaxis_grob,1,0,0,"class<`gg`, `ggplot`>",1
+ggpubr,.insert_xaxis_grob,2,0,0,class<`unit`>,1
+ggpubr,.insert_xaxis_grob,3,0,0,character,1
+ggpubr,.insert_yaxis_grob,-1,0,0,"class<`gDesc`, `gTree`, `grob`, `gtable`>",1
+ggpubr,.insert_yaxis_grob,0,0,0,"class<`gDesc`, `gTree`, `grob`, `gtable`>",1
+ggpubr,.insert_yaxis_grob,1,0,0,"class<`gg`, `ggplot`>",1
+ggpubr,.insert_yaxis_grob,2,0,0,class<`unit`>,1
+ggpubr,.insert_yaxis_grob,3,0,0,character,1
+ggpubr,.is_color,-1,0,0,logical,1
+ggpubr,.is_color,0,0,0,character,1
+ggpubr,.is_col_palette,-1,0,0,logical,1
+ggpubr,.is_col_palette,0,0,0,character[],1
+ggpubr,.is_empty,-1,0,0,logical,1
+ggpubr,.is_empty,0,0,0,character[],1
+ggpubr,.is_empty,0,0,1,class<`waiver`>,1
+ggpubr,.is_empty,0,0,2,integer[],1
+ggpubr,.is_empty,0,0,3,list<any>,1
+ggpubr,.is_empty,0,0,4,null,1
+ggpubr,.is_list,-1,0,0,logical,1
+ggpubr,.is_list,0,0,0,character[],1
+ggpubr,.is_list,0,0,1,"class<`gg`, `ggplot`>",1
+ggpubr,.is_list,0,0,2,"list<class<`gg`, `ggplot`>>",1
+ggpubr,.is_multi_formula,-1,0,0,logical,1
+ggpubr,.is_multi_formula,0,0,0,class<`formula`>,1
+ggpubr,is_null_model,-1,0,0,logical,1
+ggpubr,is_null_model,0,0,0,"class<`data.frame`, `tbl`, `tbl_df`>",1
+ggpubr,.is_numeric_data,-1,0,0,logical,1
+ggpubr,.is_numeric_data,0,0,0,class<`data.frame`>,1
+ggpubr,is_pkg_version_sup,-1,0,0,logical,1
+ggpubr,is_pkg_version_sup,0,0,0,character,1
+ggpubr,is_pkg_version_sup,1,0,0,character,1
+ggpubr,.is_p.signif_in_mapping,-1,0,0,logical,1
+ggpubr,.is_p.signif_in_mapping,0,0,0,null,1
+ggpubr,.is_streched,-1,0,0,logical,1
+ggpubr,.is_streched,0,0,0,class<`data.frame`>,1
+ggpubr,.is_streched,1,0,0,null,1
+ggpubr,.is_streched,2,0,0,null,1
+ggpubr,.labs,-1,0,0,"class<`gg`, `ggplot`>",1
+ggpubr,.labs,0,0,0,"class<`gg`, `ggplot`>",1
+ggpubr,.labs,1,0,0,character,1
+ggpubr,.labs,1,0,1,null,1
+ggpubr,.labs,2,0,0,character,1
+ggpubr,.labs,2,0,1,null,1
+ggpubr,.labs,2,0,2,logical,1
+ggpubr,.labs,3,0,0,character,1
+ggpubr,.labs,3,0,1,null,1
+ggpubr,.labs,3,0,2,logical,1
+ggpubr,.labs,4,0,0,null,1
+ggpubr,.labs,4,0,1,character[],1
+ggpubr,.labs,5,0,0,null,1
+ggpubr,.labs,5,0,1,character[],1
+ggpubr,.labs,6,0,0,null,1
+ggpubr,.labs,6,0,1,character[],1
+ggpubr,.labs,7,0,0,character,1
+ggpubr,.labs,7,0,1,null,1
+ggpubr,labs_pubr,-1,0,0,"class<`gg`, `theme`>",1
+ggpubr,labs_pubr,0,0,0,double,1
+ggpubr,labs_pubr,1,0,0,character,1
+ggpubr,.levels,-1,0,0,character[],1
+ggpubr,.levels,0,0,0,class<`factor`>,1
+ggpubr,.mapping,-1,0,0,list<character>,1
+ggpubr,.mapping,0,0,0,"class<`gg`, `ggplot`>",1
+ggpubr,.method_info,-1,0,0,list<character>,1
+ggpubr,.method_info,0,0,0,character,1
+ggpubr,.method_info,0,0,1,null,1
+ggpubr,minimalTableGrob,-1,0,0,"class<`gDesc`, `gTree`, `grob`, `gtable`>",1
+ggpubr,minimalTableGrob,0,0,0,class<`data.frame`>,1
+ggpubr,minimalTableGrob,1,0,0,null,1
+ggpubr,minimalTableGrob,2,0,0,character[],1
+ggpubr,minimalTableGrob,3,0,0,null,1
+ggpubr,minimalTableGrob,4,0,0,...,1
+ggpubr,.nbplots_per_page,-1,0,0,double,1
+ggpubr,.nbplots_per_page,0,0,0,double,1
+ggpubr,.nbplots_per_page,0,0,1,null,1
+ggpubr,.nbplots_per_page,1,0,0,double,1
+ggpubr,.nbplots_per_page,1,0,1,null,1
+ggpubr,.parse_font,-1,0,0,null,1
+ggpubr,.parse_font,-1,0,1,list<character>,1
+ggpubr,.parse_font,-1,0,2,list<double | character>,1
+ggpubr,.parse_font,-1,0,3,list<double | character | null>,1
+ggpubr,.parse_font,-1,0,4,list<null | character>,1
+ggpubr,.parse_font,0,0,0,null,1
+ggpubr,.parse_font,0,0,1,list<character>,1
+ggpubr,.parse_font,0,0,2,list<double | character>,1
+ggpubr,.parse_font,0,0,3,character[],1
+ggpubr,.paste_colnames,-1,0,0,class<`data.frame`>,1
+ggpubr,.paste_colnames,0,0,0,"class<`data.frame`, `grouped_df`, `tbl`, `tbl_df`>",1
+ggpubr,.paste_colnames,1,0,0,character,1
+ggpubr,.plot_to_gtable,-1,0,0,"class<`gDesc`, `gTree`, `grob`, `gtable`>",1
+ggpubr,.plot_to_gtable,0,0,0,"class<`gDesc`, `gTree`, `grob`, `gtable`>",1
+ggpubr,.plot_to_gtable,0,0,1,"class<`gg`, `ggplot`>",1
+ggpubr,.remove_axis,-1,0,0,"class<`gg`, `theme`>",1
+ggpubr,rotate,-1,0,0,"class<`Coord`, `CoordCartesian`, `CoordFlip`, `gg`, `ggproto`>",1
+ggpubr,rotate,0,0,0,...,1
+ggpubr,rotate_x_text,-1,0,0,"class<`gg`, `theme`>",1
+ggpubr,rotate_x_text,0,0,0,double,1
+ggpubr,rotate_x_text,1,0,0,double,1
+ggpubr,rotate_x_text,1,0,1,null,1
+ggpubr,rotate_x_text,2,0,0,double,1
+ggpubr,rotate_x_text,2,0,1,null,1
+ggpubr,rotate_x_text,3,0,0,...,1
+ggpubr,rotate_y_text,-1,0,0,"class<`gg`, `theme`>",1
+ggpubr,rotate_y_text,0,0,0,double,1
+ggpubr,rotate_y_text,1,0,0,null,1
+ggpubr,rotate_y_text,2,0,0,null,1
+ggpubr,rotate_y_text,3,0,0,...,1
+ggpubr,rownames_style,-1,0,0,list<list<character | double | null | double | character>>,1
+ggpubr,rownames_style,-1,0,1,list<list<character | double | null | double>>,1
+ggpubr,rownames_style,0,0,0,character,1
+ggpubr,rownames_style,1,0,0,character,1
+ggpubr,rownames_style,2,0,0,double,1
+ggpubr,rownames_style,3,0,0,null,1
+ggpubr,rownames_style,4,0,0,double,1
+ggpubr,rownames_style,5,0,0,character,1
+ggpubr,rownames_style,5,0,1,null,1
+ggpubr,rownames_style,6,0,0,logical,1
+ggpubr,rownames_style,7,0,0,...,1
+ggpubr,rremove,-1,0,0,"class<`gg`, `theme`>",1
+ggpubr,rremove,0,0,0,character,1
+ggpubr,.scale_color_ggsci,-1,0,0,"class<`Scale`, `ScaleDiscrete`, `gg`, `ggproto`>",1
+ggpubr,.scale_color_ggsci,0,0,0,character,1
+ggpubr,.scale_fill_ggsci,-1,0,0,"class<`Scale`, `ScaleDiscrete`, `gg`, `ggproto`>",1
+ggpubr,.scale_fill_ggsci,0,0,0,character,1
+ggpubr,.scale_point_shape,-1,0,0,"class<`gg`, `ggplot`>",1
+ggpubr,.scale_point_shape,0,0,0,"class<`gg`, `ggplot`>",1
+ggpubr,.scale_point_shape,1,0,0,class<`data.frame`>,1
+ggpubr,.scale_point_shape,2,0,0,character,1
+ggpubr,.scale_point_shape,2,0,1,double,1
+ggpubr,.select_vec,-1,0,0,class<`factor`>,1
+ggpubr,.select_vec,-1,0,1,double[],1
+ggpubr,.select_vec,0,0,0,class<`data.frame`>,1
+ggpubr,.select_vec,0,0,1,"class<`data.frame`, `tbl`, `tbl_df`>",1
+ggpubr,.select_vec,1,0,0,character,1
+ggpubr,.select_vec,1,0,1,double,1
+ggpubr,.set_axis_limits,-1,0,0,"class<`Coord`, `CoordCartesian`, `gg`, `ggproto`>",1
+ggpubr,.set_axis_limits,-1,0,1,null,1
+ggpubr,.set_axis_limits,0,0,0,null,1
+ggpubr,.set_axis_limits,1,0,0,double[],1
+ggpubr,.set_axis_limits,1,0,1,null,1
+ggpubr,.set_legend,-1,0,0,"class<`gg`, `ggplot`>",1
+ggpubr,.set_legend,0,0,0,"class<`gg`, `ggplot`>",1
+ggpubr,.set_legend,1,0,0,character,1
+ggpubr,.set_legend,1,0,1,null,1
+ggpubr,.set_legend,2,0,0,character,1
+ggpubr,.set_legend,2,0,1,null,1
+ggpubr,.set_legend,3,0,0,character[],1
+ggpubr,.set_legend,3,0,1,null,1
+ggpubr,.set_orientation,-1,0,0,"class<`gg`, `ggplot`>",1
+ggpubr,.set_orientation,0,0,0,"class<`gg`, `ggplot`>",1
+ggpubr,.set_orientation,1,0,0,character[],1
+ggpubr,set_palette,-1,0,0,"class<`gg`, `ggplot`>",1
+ggpubr,set_palette,0,0,0,"class<`gg`, `ggplot`>",1
+ggpubr,set_palette,1,0,0,character[],1
+ggpubr,set_palette,1,0,1,null,1
+ggpubr,.set_scale,-1,0,0,"class<`gg`, `ggplot`>",1
+ggpubr,.set_scale,0,0,0,"class<`gg`, `ggplot`>",1
+ggpubr,.set_scale,1,0,0,character[],1
+ggpubr,.set_scale,2,0,0,character[],1
+ggpubr,.set_scale,3,0,0,logical,1
+ggpubr,.set_ticks,-1,0,0,"class<`gg`, `theme`>",1
+ggpubr,.set_ticks,0,0,0,logical,1
+ggpubr,.set_ticks,1,0,0,logical,1
+ggpubr,.set_ticks,2,0,0,any,1
+ggpubr,.set_ticks,3,0,0,double,1
+ggpubr,.set_ticks,3,0,1,null,1
+ggpubr,.set_ticks,4,0,0,any,1
+ggpubr,.set_ticks,5,0,0,character[],1
+ggpubr,.set_ticks,5,0,1,null,1
+ggpubr,.set_ticks,6,0,0,character[],1
+ggpubr,.set_ticks,6,0,1,null,1
+ggpubr,.set_ticksby,-1,0,0,"class<`gg`, `ggplot`>",1
+ggpubr,.set_ticksby,0,0,0,"class<`gg`, `ggplot`>",1
+ggpubr,.set_ticksby,1,0,0,double,1
+ggpubr,.set_ticksby,1,0,1,null,1
+ggpubr,.set_ticksby,2,0,0,null,1
+ggpubr,.set_y_text_col,-1,0,0,"class<`gg`, `ggplot`>",1
+ggpubr,.set_y_text_col,0,0,0,"class<`gg`, `ggplot`>",1
+ggpubr,.set_y_text_col,1,0,0,class<`factor`>,1
+ggpubr,.set_y_text_col,2,0,0,any,1
+ggpubr,show_line_types,-1,0,0,"class<`gg`, `ggplot`>",1
+ggpubr,show_point_shapes,-1,0,0,"class<`gg`, `ggplot`>",1
+ggpubr,stat_central_tendency,-1,0,0,"class<`Layer`, `LayerInstance`, `gg`, `ggproto`>",1
+ggpubr,stat_central_tendency,0,0,0,class<`uneval`>,1
+ggpubr,stat_central_tendency,0,0,1,null,1
+ggpubr,stat_central_tendency,1,0,0,null,1
+ggpubr,stat_central_tendency,2,0,0,character[],1
+ggpubr,stat_central_tendency,3,0,0,character,1
+ggpubr,stat_central_tendency,4,0,0,logical,1
+ggpubr,stat_central_tendency,5,0,0,null,1
+ggpubr,stat_central_tendency,6,0,0,logical,1
+ggpubr,stat_central_tendency,7,0,0,character,1
+ggpubr,stat_chull,-1,0,0,"class<`Layer`, `LayerInstance`, `gg`, `ggproto`>",1
+ggpubr,stat_chull,0,0,0,class<`uneval`>,1
+ggpubr,stat_chull,1,0,0,null,1
+ggpubr,stat_chull,2,0,0,character,1
+ggpubr,stat_chull,3,0,0,character,1
+ggpubr,stat_chull,4,0,0,logical,1
+ggpubr,stat_chull,5,0,0,null,1
+ggpubr,stat_chull,6,0,0,logical,1
+ggpubr,stat_chull,7,0,0,...,1
+ggpubr,stat_compare_means,-1,0,0,"class<`Layer`, `LayerInstance`, `gg`, `ggproto`>",1
+ggpubr,stat_compare_means,0,0,0,class<`uneval`>,1
+ggpubr,stat_compare_means,0,0,1,null,1
+ggpubr,stat_compare_means,1,0,0,null,1
+ggpubr,stat_compare_means,2,0,0,character,1
+ggpubr,stat_compare_means,2,0,1,null,1
+ggpubr,stat_compare_means,3,0,0,logical,1
+ggpubr,stat_compare_means,4,0,0,list<any>,1
+ggpubr,stat_compare_means,5,0,0,character,1
+ggpubr,stat_compare_means,5,0,1,null,1
+ggpubr,stat_compare_means,6,0,0,null,1
+ggpubr,stat_compare_means,6,0,1,list<character[]>,1
+ggpubr,stat_compare_means,7,0,0,logical,1
+ggpubr,stat_conf_ellipse,-1,0,0,"class<`Layer`, `LayerInstance`, `gg`, `ggproto`>",1
+ggpubr,stat_conf_ellipse,0,0,0,class<`uneval`>,1
+ggpubr,stat_conf_ellipse,1,0,0,null,1
+ggpubr,stat_conf_ellipse,2,0,0,character,1
+ggpubr,stat_conf_ellipse,3,0,0,character,1
+ggpubr,stat_conf_ellipse,4,0,0,logical,1
+ggpubr,stat_conf_ellipse,5,0,0,null,1
+ggpubr,stat_conf_ellipse,6,0,0,logical,1
+ggpubr,stat_conf_ellipse,7,0,0,double,1
+ggpubr,stat_cor,-1,0,0,"class<`Layer`, `LayerInstance`, `gg`, `ggproto`>",1
+ggpubr,stat_cor,0,0,0,class<`uneval`>,1
+ggpubr,stat_cor,0,0,1,null,1
+ggpubr,stat_cor,1,0,0,null,1
+ggpubr,stat_cor,2,0,0,character,1
+ggpubr,stat_cor,3,0,0,character[],1
+ggpubr,stat_cor,4,0,0,character,1
+ggpubr,stat_cor,5,0,0,character,1
+ggpubr,stat_cor,6,0,0,character,1
+ggpubr,stat_cor,7,0,0,double,1
+ggpubr,stat_cor,7,0,1,null,1
+ggpubr,.stat_ellipse,-1,0,0,"class<`Layer`, `LayerInstance`, `gg`, `ggproto`>",1
+ggpubr,.stat_ellipse,0,0,0,class<`data.frame`>,1
+ggpubr,.stat_ellipse,1,0,0,character,1
+ggpubr,.stat_ellipse,2,0,0,character,1
+ggpubr,.stat_ellipse,3,0,0,character,1
+ggpubr,.stat_ellipse,4,0,0,any,1
+ggpubr,.stat_ellipse,5,0,0,any,1
+ggpubr,.stat_ellipse,6,0,0,double,1
+ggpubr,.stat_ellipse,7,0,0,character,1
+ggpubr,stat_mean,-1,0,0,"class<`Layer`, `LayerInstance`, `gg`, `ggproto`>",1
+ggpubr,stat_mean,0,0,0,class<`uneval`>,1
+ggpubr,stat_mean,1,0,0,null,1
+ggpubr,stat_mean,2,0,0,character,1
+ggpubr,stat_mean,3,0,0,character,1
+ggpubr,stat_mean,4,0,0,logical,1
+ggpubr,stat_mean,5,0,0,null,1
+ggpubr,stat_mean,6,0,0,logical,1
+ggpubr,stat_mean,7,0,0,...,1
+ggpubr,stat_overlay_normal_density,-1,0,0,"class<`Layer`, `LayerInstance`, `gg`, `ggproto`>",1
+ggpubr,stat_overlay_normal_density,0,0,0,class<`uneval`>,1
+ggpubr,stat_overlay_normal_density,0,0,1,null,1
+ggpubr,stat_overlay_normal_density,1,0,0,null,1
+ggpubr,stat_overlay_normal_density,2,0,0,character,1
+ggpubr,stat_overlay_normal_density,3,0,0,character,1
+ggpubr,stat_overlay_normal_density,4,0,0,logical,1
+ggpubr,stat_overlay_normal_density,5,0,0,null,1
+ggpubr,stat_overlay_normal_density,6,0,0,logical,1
+ggpubr,stat_overlay_normal_density,7,0,0,...,1
+ggpubr,stat_pvalue_manual,-1,0,0,"class<`Layer`, `LayerInstance`, `gg`, `ggproto`>",1
+ggpubr,stat_pvalue_manual,0,0,0,"class<`data.frame`, `tbl`, `tbl_df`>",1
+ggpubr,stat_pvalue_manual,1,0,0,character,1
+ggpubr,stat_pvalue_manual,2,0,0,character,1
+ggpubr,stat_pvalue_manual,2,0,1,double,1
+ggpubr,stat_pvalue_manual,3,0,0,character,1
+ggpubr,stat_pvalue_manual,4,0,0,character,1
+ggpubr,stat_pvalue_manual,5,0,0,null,1
+ggpubr,stat_pvalue_manual,5,0,1,character,1
+ggpubr,stat_pvalue_manual,6,0,0,double,1
+ggpubr,stat_pvalue_manual,7,0,0,double,1
+ggpubr,stat_regline_equation,-1,0,0,"class<`Layer`, `LayerInstance`, `gg`, `ggproto`>",1
+ggpubr,stat_regline_equation,0,0,0,class<`uneval`>,1
+ggpubr,stat_regline_equation,0,0,1,null,1
+ggpubr,stat_regline_equation,1,0,0,null,1
+ggpubr,stat_regline_equation,2,0,0,class<`formula`>,1
+ggpubr,stat_regline_equation,3,0,0,character,1
+ggpubr,stat_regline_equation,4,0,0,character,1
+ggpubr,stat_regline_equation,5,0,0,null,1
+ggpubr,stat_regline_equation,5,0,1,double,1
+ggpubr,stat_regline_equation,6,0,0,null,1
+ggpubr,stat_regline_equation,6,0,1,double,1
+ggpubr,stat_regline_equation,7,0,0,character,1
+ggpubr,stat_stars,-1,0,0,"class<`Layer`, `LayerInstance`, `gg`, `ggproto`>",1
+ggpubr,stat_stars,0,0,0,class<`uneval`>,1
+ggpubr,stat_stars,1,0,0,null,1
+ggpubr,stat_stars,2,0,0,character,1
+ggpubr,stat_stars,3,0,0,character,1
+ggpubr,stat_stars,4,0,0,logical,1
+ggpubr,stat_stars,5,0,0,null,1
+ggpubr,stat_stars,6,0,0,logical,1
+ggpubr,stat_stars,7,0,0,...,1
+ggpubr,.summary,-1,0,0,class<`data.frame`>,1
+ggpubr,.summary,0,0,0,"class<`data.frame`, `tbl`, `tbl_df`>",1
+ggpubr,.summary,1,0,0,double,1
+ggpubr,.summary_functions,-1,0,0,character[],1
+ggpubr,table_cell_bg,-1,0,0,"class<`gg`, `ggplot`>",1
+ggpubr,table_cell_bg,0,0,0,"class<`gg`, `ggplot`>",1
+ggpubr,table_cell_bg,1,0,0,double,1
+ggpubr,table_cell_bg,2,0,0,double,1
+ggpubr,table_cell_bg,3,0,0,character,1
+ggpubr,table_cell_bg,4,0,0,character,1
+ggpubr,table_cell_bg,5,0,0,double,1
+ggpubr,table_cell_font,-1,0,0,"class<`gg`, `ggplot`>",1
+ggpubr,table_cell_font,0,0,0,"class<`gg`, `ggplot`>",1
+ggpubr,table_cell_font,1,0,0,double,1
+ggpubr,table_cell_font,2,0,0,double,1
+ggpubr,table_cell_font,3,0,0,character,1
+ggpubr,table_cell_font,4,0,0,null,1
+ggpubr,tbody_style,-1,0,0,list<list<character | double | character[] | double>>,1
+ggpubr,tbody_style,-1,0,1,list<list<character | double | null | double | character>>,1
+ggpubr,tbody_style,-1,0,2,list<list<character | double | null | double>>,1
+ggpubr,tbody_style,0,0,0,character,1
+ggpubr,tbody_style,1,0,0,character,1
+ggpubr,tbody_style,2,0,0,double,1
+ggpubr,tbody_style,3,0,0,character[],1
+ggpubr,tbody_style,3,0,1,null,1
+ggpubr,tbody_style,4,0,0,double,1
+ggpubr,tbody_style,5,0,0,character,1
+ggpubr,tbody_style,5,0,1,null,1
+ggpubr,tbody_style,6,0,0,logical,1
+ggpubr,tbody_style,7,0,0,...,1
+ggpubr,.test,-1,0,0,class<`data.frame`>,1
+ggpubr,.test,0,0,0,class<`data.frame`>,1
+ggpubr,.test,1,0,0,class<`formula`>,1
+ggpubr,.test,2,0,0,character,1
+ggpubr,.test,3,0,0,...,1
+ggpubr,text_grob,-1,0,0,"class<`gDesc`, `grob`, `text`>",1
+ggpubr,text_grob,0,0,0,character,1
+ggpubr,text_grob,1,0,0,character,1
+ggpubr,text_grob,2,0,0,double,1
+ggpubr,text_grob,2,0,1,null,1
+ggpubr,text_grob,3,0,0,null,1
+ggpubr,text_grob,4,0,0,double,1
+ggpubr,text_grob,5,0,0,character,1
+ggpubr,text_grob,6,0,0,character,1
+ggpubr,text_grob,7,0,0,double,1
+ggpubr,text_grob,7,0,1,null,1
+ggpubr,theme_pubclean,-1,0,0,"class<`gg`, `theme`>",1
+ggpubr,theme_pubclean,0,0,0,double,1
+ggpubr,theme_pubclean,1,0,0,character,1
+ggpubr,theme_pubclean,2,0,0,logical,1
+ggpubr,theme_pubr,-1,0,0,"class<`gg`, `theme`>",1
+ggpubr,theme_pubr,0,0,0,double,1
+ggpubr,theme_pubr,1,0,0,character,1
+ggpubr,theme_pubr,2,0,0,logical,1
+ggpubr,theme_pubr,3,0,0,logical,1
+ggpubr,theme_pubr,4,0,0,character[],1
+ggpubr,theme_pubr,5,0,0,double,1
+ggpubr,theme_transparent,-1,0,0,"class<`gg`, `theme`>",1
+ggpubr,theme_transparent,0,0,0,double,1
+ggpubr,theme_transparent,1,0,0,character,1
+ggpubr,tstyle,-1,0,0,null,1
+ggpubr,tstyle,-1,0,1,list<list<list<character | double | character | double | null | double | character | character | double | character[] | double>>>,1
+ggpubr,tstyle,-1,0,2,list<list<list<character | double | null | double | character | character | double | null | double>>>,1
+ggpubr,tstyle,-1,0,3,list<list<list<character | double | null | double>>>,1
+ggpubr,tstyle,0,0,0,character,1
+ggpubr,tstyle,1,0,0,any,1
+ggpubr,ttheme,-1,0,0,list<list<class<`function`> | class<`unit`> | list<character | double | character[] | double> | class<`function`> | class<`unit`> | list<character | double> | class<`function`> | class<`unit`> | list<character | double | null | double | character>>>,1
+ggpubr,ttheme,-1,0,1,list<list<class<`function`> | class<`unit`> | list<character | double | null | double | character> | class<`function`> | class<`unit`> | list<character | double | null | double>>>,1
+ggpubr,ttheme,-1,0,2,list<list<class<`function`> | class<`unit`> | list<character | double | null | double>>>,1
+ggpubr,ttheme,0,0,0,character,1
+ggpubr,ttheme,1,0,0,double,1
+ggpubr,ttheme,2,0,0,character,1
+ggpubr,ttheme,3,0,0,class<`unit`>,1
+ggpubr,ttheme,4,0,0,any,1
+ggpubr,ttheme,5,0,0,any,1
+ggpubr,ttheme,6,0,0,any,1
+ggpubr,unnest,-1,0,0,"class<`data.frame`, `grouped_df`, `tbl`, `tbl_df`>",1
+ggpubr,unnest,0,0,0,"class<`data.frame`, `grouped_df`, `tbl`, `tbl_df`>",1
+ggpubr,unnest,1,0,0,character,1
+ggpubr,unnest,2,0,0,...,1
+ggpubr,.update_label_pms,-1,0,0,list<double | null | character>,1
+ggpubr,.update_label_pms,0,0,0,list<double | character | null>,1
+ggpubr,.update_label_pms,1,0,0,double,1
+ggpubr,.update_label_pms,2,0,0,double,1
+ggpubr,.update_label_pms,3,0,0,double,1
+ggpubr,.update_label_pms,4,0,0,double,1
+ggpubr,.update_mapping,-1,0,0,class<`uneval`>,1
+ggpubr,.update_mapping,-1,0,1,null,1
+ggpubr,.update_mapping,0,0,0,class<`uneval`>,1
+ggpubr,.update_mapping,0,0,1,null,1
+ggpubr,.update_mapping,1,0,0,null,1
+ggpubr,.update_plot,-1,0,0,"class<`gg`, `ggplot`>",1
+ggpubr,.update_plot,0,0,0,list<any>,1
+ggpubr,.update_plot,1,0,0,"class<`gg`, `ggplot`>",1
+ggpubr,.valide_y_position,-1,0,0,character,1
+ggpubr,.valide_y_position,-1,0,1,double[],1
+ggpubr,.valide_y_position,0,0,0,character,1
+ggpubr,.valide_y_position,0,0,1,double,1
+ggpubr,.valide_y_position,1,0,0,"class<`data.frame`, `tbl`, `tbl_df`>",1
+ggpubr,.violin_params,-1,0,0,list<character | logical>,1
+ggpubr,.violin_params,0,0,0,...,1
+ggpubr,yscale,-1,0,0,"class<`Scale`, `ScaleContinuous`, `ScaleContinuousPosition`, `gg`, `ggproto`>",1
+ggpubr,yscale,0,0,0,character,1
+ggpubr,yscale,1,0,0,logical,1
+ggrepel,%||%,-1,0,0,character,1
+ggrepel,%||%,-1,0,1,null,1
+ggrepel,%||%,0,0,0,character,1
+ggrepel,%||%,0,0,1,null,1
+ggrepel,%||%,1,0,0,any,1
+ggrepel,centroid,-1,0,0,double[],1
+ggrepel,centroid,0,0,0,double[],1
+ggrepel,centroid,1,0,0,double,1
+ggrepel,centroid,2,0,0,double,1
+ggrepel,euclid,-1,0,0,double,1
+ggrepel,euclid,0,0,0,double[],1
+ggrepel,euclid,1,0,0,double[],1
+ggrepel,geom_label_repel,-1,0,0,"class<`Layer`, `LayerInstance`, `gg`, `ggproto`>",1
+ggrepel,geom_label_repel,0,0,0,null,1
+ggrepel,geom_label_repel,1,0,0,null,1
+ggrepel,geom_label_repel,2,0,0,character,1
+ggrepel,geom_label_repel,3,0,0,character,1
+ggrepel,geom_label_repel,4,0,0,logical,1
+ggrepel,geom_label_repel,5,0,0,...,1
+ggrepel,geom_label_repel,6,0,0,double,1
+ggrepel,geom_label_repel,7,0,0,double,1
+ggrepel,geom_label_repel,8,0,0,double,1
+ggrepel,geom_label_repel,9,0,0,double,1
+ggrepel,geom_label_repel,10,0,0,double,1
+ggrepel,geom_label_repel,11,0,0,null,1
+ggrepel,geom_label_repel,12,0,0,null,1
+ggrepel,geom_label_repel,13,0,0,double,1
+ggrepel,geom_label_repel,14,0,0,null,1
+ggrepel,geom_label_repel,15,0,0,double,1
+ggrepel,geom_text_repel,-1,0,0,"class<`Layer`, `LayerInstance`, `gg`, `ggproto`>",1
+ggrepel,geom_text_repel,0,0,0,null,1
+ggrepel,geom_text_repel,1,0,0,class<`data.frame`>,1
+ggrepel,geom_text_repel,1,0,1,null,1
+ggrepel,geom_text_repel,2,0,0,character,1
+ggrepel,geom_text_repel,3,0,0,character,1
+ggrepel,geom_text_repel,4,0,0,logical,1
+ggrepel,geom_text_repel,5,0,0,...,1
+ggrepel,geom_text_repel,6,0,0,double,1
+ggrepel,geom_text_repel,7,0,0,double,1
+ggrepel,geom_text_repel,7,0,1,null,1
+ggrepel,geom_text_repel,8,0,0,null,1
+ggrepel,geom_text_repel,9,0,0,character,1
+ggrepel,geom_text_repel,9,0,1,null,1
+ggrepel,geom_text_repel,10,0,0,double,1
+ggrepel,geom_text_repel,11,0,0,null,1
+ggrepel,geom_text_repel,12,0,0,double,1
+ggrepel,geom_text_repel,13,0,0,null,1
+ggrepel,geom_text_repel,14,0,0,double,1
+ggrepel,geom_text_repel,15,0,0,double,1
+ggrepel,ggname,-1,0,0,"class<`gDesc`, `gTree`, `grob`, `textrepeltree`>",1
+ggrepel,ggname,0,0,0,character,1
+ggrepel,ggname,1,0,0,"class<`gDesc`, `gTree`, `grob`, `textrepeltree`>",1
+ggrepel,intersect_line_rectangle,-1,0,0,double[],1
+ggrepel,intersect_line_rectangle,0,0,0,double[],1
+ggrepel,intersect_line_rectangle,1,0,0,double[],1
+ggrepel,intersect_line_rectangle,2,0,0,double[],1
+ggrepel,makeContent.textrepelgrob,-1,0,0,"class<`gDesc`, `gTree`, `grob`, `textrepelgrob`>",1
+ggrepel,makeContent.textrepelgrob,0,0,0,"class<`gDesc`, `gTree`, `grob`, `textrepelgrob`>",1
+ggrepel,makeContent.textrepeltree,-1,0,0,"class<`gDesc`, `gTree`, `grob`, `textrepeltree`>",1
+ggrepel,makeContent.textrepeltree,0,0,0,"class<`gDesc`, `gTree`, `grob`, `textrepeltree`>",1
+ggrepel,not_empty,-1,0,0,logical[],1
+ggrepel,not_empty,0,0,0,character[],1
+ggrepel,repel_boxes,-1,0,0,class<`data.frame`>,1
+ggrepel,repel_boxes,0,0,0,class<`matrix`>,1
+ggrepel,repel_boxes,1,0,0,double,1
+ggrepel,repel_boxes,2,0,0,double,1
+ggrepel,repel_boxes,3,0,0,class<`matrix`>,1
+ggrepel,repel_boxes,4,0,0,double[],1
+ggrepel,repel_boxes,5,0,0,double[],1
+ggrepel,repel_boxes,6,0,0,double[],1
+ggrepel,repel_boxes,7,0,0,double[],1
+ggrepel,repel_boxes,8,0,0,double,1
+ggrepel,repel_boxes,9,0,0,double,1
+ggrepel,repel_boxes,10,0,0,character,1
+ggrepel,select_line_connection,-1,0,0,double[],1
+ggrepel,select_line_connection,0,0,0,double[],1
+ggrepel,select_line_connection,1,0,0,double[],1
+ggrepel,textRepelGrob,-1,0,0,"class<`gDesc`, `gTree`, `grob`, `textrepelgrob`>",1
+ggrepel,textRepelGrob,0,0,0,character,1
+ggrepel,textRepelGrob,1,0,0,class<`unit`>,1
+ggrepel,textRepelGrob,2,0,0,class<`unit`>,1
+ggrepel,textRepelGrob,3,0,0,class<`unit`>,1
+ggrepel,textRepelGrob,4,0,0,class<`unit`>,1
+ggrepel,textRepelGrob,5,0,0,double,1
+ggrepel,textRepelGrob,6,0,0,character,1
+ggrepel,textRepelGrob,7,0,0,character,1
+ggrepel,textRepelGrob,8,0,0,class<`unit`>,1
+ggrepel,textRepelGrob,9,0,0,class<`unit`>,1
+ggrepel,textRepelGrob,10,0,0,null,1
+ggrepel,textRepelGrob,11,0,0,class<`gpar`>,1
+ggrepel,textRepelGrob,12,0,0,class<`gpar`>,1
+ggrepel,textRepelGrob,13,0,0,null,1
+ggrepel,textRepelGrob,14,0,0,null,1
+ggrepel,textRepelGrob,15,0,0,class<`unit`>,1
+ggrepel,to_unit,-1,0,0,class<`unit`>,1
+ggrepel,to_unit,-1,0,1,null,1
+ggrepel,to_unit,0,0,0,class<`unit`>,1
+ggrepel,to_unit,0,0,1,double,1
+ggrepel,to_unit,0,0,2,null,1
+ggridges,check_breaks_labels,-1,0,0,logical,1
+ggridges,check_breaks_labels,0,0,0,character[],1
+ggridges,check_breaks_labels,0,0,1,class<`waiver`>,1
+ggridges,check_breaks_labels,1,0,0,character[],1
+ggridges,check_breaks_labels,1,0,1,class<`waiver`>,1
+ggridges,cyclical_scale,-1,0,0,"class<`Scale`, `ScaleCyclical`, `ScaleDiscrete`, `gg`, `ggproto`>",1
+ggridges,cyclical_scale,0,0,0,character,1
+ggridges,cyclical_scale,1,0,0,character[],1
+ggridges,cyclical_scale,1,0,1,double[],1
+ggridges,cyclical_scale,2,0,0,character,1
+ggridges,cyclical_scale,2,0,1,class<`waiver`>,1
+ggridges,cyclical_scale,3,0,0,character[],1
+ggridges,cyclical_scale,3,0,1,class<`waiver`>,1
+ggridges,cyclical_scale,4,0,0,character[],1
+ggridges,cyclical_scale,4,0,1,class<`waiver`>,1
+ggridges,cyclical_scale,5,0,0,null,1
+ggridges,cyclical_scale,6,0,0,class<`waiver`>,1
+ggridges,cyclical_scale,7,0,0,logical,1
+ggridges,discrete_range,-1,0,0,"class<`Range`, `RangeDiscrete`, `gg`, `ggproto`>",1
+ggridges,geom_density_line,-1,0,0,"class<`Layer`, `LayerInstance`, `gg`, `ggproto`>",1
+ggridges,geom_density_line,0,0,0,null,1
+ggridges,geom_density_line,1,0,0,null,1
+ggridges,geom_density_line,2,0,0,character,1
+ggridges,geom_density_line,3,0,0,character,1
+ggridges,geom_density_line,4,0,0,...,1
+ggridges,geom_density_line,5,0,0,logical,1
+ggridges,geom_density_line,6,0,0,null,1
+ggridges,geom_density_line,7,0,0,logical,1
+ggridges,geom_density_ridges,-1,0,0,"class<`Layer`, `LayerInstance`, `gg`, `ggproto`>",1
+ggridges,geom_density_ridges,0,0,0,class<`uneval`>,1
+ggridges,geom_density_ridges,0,0,1,null,1
+ggridges,geom_density_ridges,1,0,0,null,1
+ggridges,geom_density_ridges,2,0,0,character,1
+ggridges,geom_density_ridges,3,0,0,character,1
+ggridges,geom_density_ridges,3,0,1,"class<`Position`, `PositionPointsJitter`, `gg`, `ggproto`>",1
+ggridges,geom_density_ridges,3,0,2,"class<`Position`, `PositionPointsJitter`, `PositionRaincloud`, `gg`, `ggproto`>",1
+ggridges,geom_density_ridges,4,0,0,logical,1
+ggridges,geom_density_ridges,5,0,0,logical,1
+ggridges,geom_density_ridges,6,0,0,null,1
+ggridges,geom_density_ridges,7,0,0,logical,1
+ggridges,geom_density_ridges2,-1,0,0,"class<`Layer`, `LayerInstance`, `gg`, `ggproto`>",1
+ggridges,geom_density_ridges2,0,0,0,class<`uneval`>,1
+ggridges,geom_density_ridges2,0,0,1,null,1
+ggridges,geom_density_ridges2,1,0,0,null,1
+ggridges,geom_density_ridges2,2,0,0,character,1
+ggridges,geom_density_ridges2,3,0,0,character,1
+ggridges,geom_density_ridges2,4,0,0,logical,1
+ggridges,geom_density_ridges2,5,0,0,logical,1
+ggridges,geom_density_ridges2,6,0,0,null,1
+ggridges,geom_density_ridges2,7,0,0,logical,1
+ggridges,geom_density_ridges_gradient,-1,0,0,"class<`Layer`, `LayerInstance`, `gg`, `ggproto`>",1
+ggridges,geom_density_ridges_gradient,0,0,0,null,1
+ggridges,geom_density_ridges_gradient,1,0,0,null,1
+ggridges,geom_density_ridges_gradient,2,0,0,character,1
+ggridges,geom_density_ridges_gradient,3,0,0,character,1
+ggridges,geom_density_ridges_gradient,4,0,0,logical,1
+ggridges,geom_density_ridges_gradient,5,0,0,logical,1
+ggridges,geom_density_ridges_gradient,6,0,0,double,1
+ggridges,geom_density_ridges_gradient,7,0,0,null,1
+ggridges,geom_ridgeline,-1,0,0,"class<`Layer`, `LayerInstance`, `gg`, `ggproto`>",1
+ggridges,geom_ridgeline,0,0,0,null,1
+ggridges,geom_ridgeline,1,0,0,null,1
+ggridges,geom_ridgeline,2,0,0,character,1
+ggridges,geom_ridgeline,3,0,0,character,1
+ggridges,geom_ridgeline,4,0,0,logical,1
+ggridges,geom_ridgeline,5,0,0,null,1
+ggridges,geom_ridgeline,6,0,0,logical,1
+ggridges,geom_ridgeline,7,0,0,...,1
+ggridges,geom_ridgeline_gradient,-1,0,0,"class<`Layer`, `LayerInstance`, `gg`, `ggproto`>",1
+ggridges,geom_ridgeline_gradient,0,0,0,null,1
+ggridges,geom_ridgeline_gradient,1,0,0,null,1
+ggridges,geom_ridgeline_gradient,2,0,0,character,1
+ggridges,geom_ridgeline_gradient,3,0,0,character,1
+ggridges,geom_ridgeline_gradient,4,0,0,logical,1
+ggridges,geom_ridgeline_gradient,5,0,0,double,1
+ggridges,geom_ridgeline_gradient,6,0,0,null,1
+ggridges,geom_ridgeline_gradient,7,0,0,logical,1
+ggridges,geom_vridgeline,-1,0,0,"class<`Layer`, `LayerInstance`, `gg`, `ggproto`>",1
+ggridges,geom_vridgeline,0,0,0,null,1
+ggridges,geom_vridgeline,1,0,0,null,1
+ggridges,geom_vridgeline,2,0,0,character,1
+ggridges,geom_vridgeline,3,0,0,character,1
+ggridges,geom_vridgeline,4,0,0,logical,1
+ggridges,geom_vridgeline,5,0,0,null,1
+ggridges,geom_vridgeline,6,0,0,logical,1
+ggridges,geom_vridgeline,7,0,0,...,1
+ggridges,position_points_jitter,-1,0,0,"class<`Position`, `PositionPointsJitter`, `gg`, `ggproto`>",1
+ggridges,position_points_jitter,0,0,0,double,1
+ggridges,position_points_jitter,1,0,0,double,1
+ggridges,position_points_jitter,2,0,0,double,1
+ggridges,position_points_jitter,3,0,0,logical,1
+ggridges,position_points_jitter,4,0,0,null,1
+ggridges,position_raincloud,-1,0,0,"class<`Position`, `PositionPointsJitter`, `PositionRaincloud`, `gg`, `ggproto`>",1
+ggridges,position_raincloud,0,0,0,double,1
+ggridges,position_raincloud,1,0,0,double,1
+ggridges,position_raincloud,2,0,0,double,1
+ggridges,position_raincloud,3,0,0,logical,1
+ggridges,position_raincloud,4,0,0,null,1
+ggridges,scale_alpha_cyclical,-1,0,0,"class<`Scale`, `ScaleCyclical`, `ScaleDiscrete`, `gg`, `ggproto`>",1
+ggridges,scale_alpha_cyclical,0,0,0,...,1
+ggridges,scale_alpha_cyclical,1,0,0,double[],1
+ggridges,scale_color_cyclical,-1,0,0,"class<`Scale`, `ScaleCyclical`, `ScaleDiscrete`, `gg`, `ggproto`>",1
+ggridges,scale_color_cyclical,0,0,0,...,1
+ggridges,scale_color_cyclical,1,0,0,character[],1
+ggridges,scale_fill_cyclical,-1,0,0,"class<`Scale`, `ScaleCyclical`, `ScaleDiscrete`, `gg`, `ggproto`>",1
+ggridges,scale_fill_cyclical,0,0,0,...,1
+ggridges,scale_fill_cyclical,1,0,0,character[],1
+ggridges,scale_linetype_cyclical,-1,0,0,"class<`Scale`, `ScaleCyclical`, `ScaleDiscrete`, `gg`, `ggproto`>",1
+ggridges,scale_linetype_cyclical,0,0,0,...,1
+ggridges,scale_linetype_cyclical,1,0,0,double[],1
+ggridges,scale_point_color_hue,-1,0,0,"class<`Scale`, `ScaleDiscrete`, `gg`, `ggproto`>",1
+ggridges,scale_point_color_hue,0,0,0,...,1
+ggridges,scale_point_color_hue,1,0,0,double[],1
+ggridges,scale_point_color_hue,2,0,0,double,1
+ggridges,scale_point_color_hue,3,0,0,double,1
+ggridges,scale_point_color_hue,4,0,0,double,1
+ggridges,scale_point_color_hue,5,0,0,double,1
+ggridges,scale_point_color_hue,6,0,0,character,1
+ggridges,scale_point_color_hue,7,0,0,character,1
+ggridges,scale_point_fill_hue,-1,0,0,"class<`Scale`, `ScaleDiscrete`, `gg`, `ggproto`>",1
+ggridges,scale_point_fill_hue,0,0,0,...,1
+ggridges,scale_point_size_continuous,-1,0,0,"class<`Scale`, `ScaleContinuous`, `gg`, `ggproto`>",1
+ggridges,scale_point_size_continuous,0,0,0,class<`waiver`>,1
+ggridges,scale_point_size_continuous,1,0,0,class<`waiver`>,1
+ggridges,scale_point_size_continuous,2,0,0,class<`waiver`>,1
+ggridges,scale_point_size_continuous,3,0,0,null,1
+ggridges,scale_point_size_continuous,4,0,0,double[],1
+ggridges,scale_point_size_continuous,5,0,0,character,1
+ggridges,scale_point_size_continuous,6,0,0,character,1
+ggridges,scale_point_size_continuous,7,0,0,character,1
+ggridges,scale_size_cyclical,-1,0,0,"class<`Scale`, `ScaleCyclical`, `ScaleDiscrete`, `gg`, `ggproto`>",1
+ggridges,scale_size_cyclical,0,0,0,...,1
+ggridges,scale_size_cyclical,1,0,0,double[],1
+ggridges,scale_vline_color_hue,-1,0,0,"class<`Scale`, `ScaleDiscrete`, `gg`, `ggproto`>",1
+ggridges,scale_vline_color_hue,0,0,0,...,1
+ggridges,scale_vline_color_hue,1,0,0,double[],1
+ggridges,scale_vline_color_hue,2,0,0,double,1
+ggridges,scale_vline_color_hue,3,0,0,double,1
+ggridges,scale_vline_color_hue,4,0,0,double,1
+ggridges,scale_vline_color_hue,5,0,0,double,1
+ggridges,scale_vline_color_hue,6,0,0,character,1
+ggridges,scale_vline_color_hue,7,0,0,character,1
+ggridges,stat_binline,-1,0,0,"class<`Layer`, `LayerInstance`, `gg`, `ggproto`>",1
+ggridges,stat_binline,0,0,0,null,1
+ggridges,stat_binline,1,0,0,null,1
+ggridges,stat_binline,2,0,0,character,1
+ggridges,stat_binline,3,0,0,character,1
+ggridges,stat_binline,4,0,0,...,1
+ggridges,stat_binline,5,0,0,null,1
+ggridges,stat_binline,6,0,0,double,1
+ggridges,stat_binline,7,0,0,null,1
+ggridges,stat_density_ridges,-1,0,0,"class<`Layer`, `LayerInstance`, `gg`, `ggproto`>",1
+ggridges,stat_density_ridges,0,0,0,null,1
+ggridges,stat_density_ridges,1,0,0,null,1
+ggridges,stat_density_ridges,2,0,0,character,1
+ggridges,stat_density_ridges,3,0,0,character,1
+ggridges,stat_density_ridges,4,0,0,logical,1
+ggridges,stat_density_ridges,5,0,0,null,1
+ggridges,stat_density_ridges,6,0,0,logical,1
+ggridges,stat_density_ridges,7,0,0,null,1
+ggridges,theme_ridges,-1,0,0,"class<`gg`, `theme`>",1
+ggridges,theme_ridges,0,0,0,double,1
+ggridges,theme_ridges,1,0,0,character,1
+ggridges,theme_ridges,2,0,0,double,1
+ggridges,theme_ridges,3,0,0,logical,1
+ggridges,theme_ridges,4,0,0,logical,1
+ggthemes,bank_slopes,-1,0,0,double,1
+ggthemes,bank_slopes,0,0,0,integer[],1
+ggthemes,bank_slopes,1,0,0,double[],1
+ggthemes,bank_slopes,2,0,0,logical,1
+ggthemes,bank_slopes,3,0,0,null,1
+ggthemes,bank_slopes,4,0,0,character[],1
+ggthemes,bank_slopes,5,0,0,...,1
+ggthemes,calc_pal,-1,0,0,class<`function`>,1
+ggthemes,calc_shape_pal,-1,0,0,class<`function`>,1
+ggthemes,calc_slopes,-1,0,0,list<double[]>,1
+ggthemes,calc_slopes,0,0,0,integer[],1
+ggthemes,calc_slopes,1,0,0,double[],1
+ggthemes,calc_slopes,2,0,0,logical,1
+ggthemes,canva_pal,-1,0,0,class<`function`>,1
+ggthemes,canva_pal,0,0,0,character,1
+ggthemes,check_pal_n,-1,0,0,null,1
+ggthemes,check_pal_n,0,0,0,double,1
+ggthemes,check_pal_n,1,0,0,double,1
+ggthemes,circlefill_shape_pal,-1,0,0,class<`function`>,1
+ggthemes,cleveland_shape_pal,-1,0,0,class<`function`>,1
+ggthemes,cleveland_shape_pal,0,0,0,logical,1
+ggthemes,colorblind_pal,-1,0,0,class<`function`>,1
+ggthemes,.coverage,-1,0,0,double,1
+ggthemes,.coverage,0,0,0,double,1
+ggthemes,.coverage,1,0,0,double,1
+ggthemes,.coverage,2,0,0,double,1
+ggthemes,.coverage,3,0,0,double,1
+ggthemes,.coverage.max,-1,0,0,double,1
+ggthemes,.coverage.max,0,0,0,double,1
+ggthemes,.coverage.max,1,0,0,double,1
+ggthemes,.coverage.max,2,0,0,double,1
+ggthemes,.density,-1,0,0,double,1
+ggthemes,.density,0,0,0,double,1
+ggthemes,.density,1,0,0,integer,1
+ggthemes,.density,2,0,0,double,1
+ggthemes,.density,3,0,0,double,1
+ggthemes,.density,4,0,0,double,1
+ggthemes,.density,5,0,0,double,1
+ggthemes,.density.max,-1,0,0,double,1
+ggthemes,.density.max,0,0,0,double,1
+ggthemes,.density.max,1,0,0,integer,1
+ggthemes,economist_pal,-1,0,0,class<`function`>,1
+ggthemes,economist_pal,0,0,0,logical,1
+ggthemes,economist_pal,-1,1,0,character[],1
+ggthemes,economist_pal,0,1,0,double,1
+ggthemes,excel_new_pal,-1,0,0,class<`function`>,1
+ggthemes,excel_new_pal,0,0,0,character,1
+ggthemes,excel_pal,-1,0,0,class<`function`>,1
+ggthemes,excel_pal,0,0,0,logical,1
+ggthemes,extended_range_breaks,-1,0,0,class<`function`>,1
+ggthemes,extended_range_breaks,0,0,0,double,1
+ggthemes,extended_range_breaks,1,0,0,...,1
+ggthemes,extended_range_breaks,-1,1,0,double[],1
+ggthemes,extended_range_breaks,0,1,0,double[],1
+ggthemes,extended_range_breaks_,-1,0,0,double[],1
+ggthemes,extended_range_breaks_,0,0,0,double,1
+ggthemes,extended_range_breaks_,1,0,0,double,1
+ggthemes,extended_range_breaks_,2,0,0,any,1
+ggthemes,extended_range_breaks_,3,0,0,double[],1
+ggthemes,extended_range_breaks_,4,0,0,double[],1
+ggthemes,few_pal,-1,0,0,character[],1
+ggthemes,few_pal,0,0,0,double,1
+ggthemes,few_pal,-1,1,0,class<`function`>,1
+ggthemes,few_pal,0,1,0,character,1
+ggthemes,few_shape_pal,-1,0,0,class<`function`>,1
+ggthemes,fivethirtyeight_pal,-1,0,0,class<`function`>,1
+ggthemes,gdocs_pal,-1,0,0,class<`function`>,1
+ggthemes,geom_rangeframe,-1,0,0,"class<`Layer`, `LayerInstance`, `gg`, `ggproto`>",1
+ggthemes,geom_rangeframe,0,0,0,null,1
+ggthemes,geom_rangeframe,1,0,0,null,1
+ggthemes,geom_rangeframe,2,0,0,character,1
+ggthemes,geom_rangeframe,3,0,0,character,1
+ggthemes,geom_rangeframe,4,0,0,...,1
+ggthemes,geom_rangeframe,5,0,0,character,1
+ggthemes,geom_rangeframe,6,0,0,logical,1
+ggthemes,geom_rangeframe,7,0,0,null,1
+ggthemes,geom_rangeframe,8,0,0,logical,1
+ggthemes,geom_tufteboxplot,-1,0,0,"class<`Layer`, `LayerInstance`, `gg`, `ggproto`>",1
+ggthemes,geom_tufteboxplot,0,0,0,null,1
+ggthemes,geom_tufteboxplot,1,0,0,null,1
+ggthemes,geom_tufteboxplot,2,0,0,character,1
+ggthemes,geom_tufteboxplot,3,0,0,character,1
+ggthemes,geom_tufteboxplot,4,0,0,character,1
+ggthemes,geom_tufteboxplot,5,0,0,double,1
+ggthemes,geom_tufteboxplot,6,0,0,double,1
+ggthemes,geom_tufteboxplot,7,0,0,double,1
+ggthemes,geom_tufteboxplot,8,0,0,double,1
+ggthemes,geom_tufteboxplot,9,0,0,double,1
+ggthemes,geom_tufteboxplot,10,0,0,logical,1
+ggthemes,geom_tufteboxplot,11,0,0,null,1
+ggthemes,geom_tufteboxplot,12,0,0,logical,1
+ggthemes,geom_tufteboxplot,13,0,0,character,1
+ggthemes,geom_tufteboxplot,14,0,0,character,1
+ggthemes,geom_tufteboxplot,15,0,0,...,1
+ggthemes,get_colors,-1,0,0,character,1
+ggthemes,get_colors,0,0,0,character[],1
+ggthemes,get_colors,1,0,0,character,1
+ggthemes,hc_pal,-1,0,0,class<`function`>,1
+ggthemes,hc_pal,0,0,0,character,1
+ggthemes,.legibility,-1,0,0,double,1
+ggthemes,.legibility,0,0,0,any,1
+ggthemes,.legibility,1,0,0,any,1
+ggthemes,.legibility,2,0,0,any,1
+ggthemes,ptol_pal,-1,0,0,character[],1
+ggthemes,ptol_pal,0,0,0,double,1
+ggthemes,ptol_pal,-1,1,0,class<`function`>,1
+ggthemes,scale_color_calc,-1,0,0,"class<`Scale`, `ScaleDiscrete`, `gg`, `ggproto`>",1
+ggthemes,scale_color_calc,0,0,0,...,1
+ggthemes,scale_color_fivethirtyeight,-1,0,0,"class<`Scale`, `ScaleDiscrete`, `gg`, `ggproto`>",1
+ggthemes,scale_color_fivethirtyeight,0,0,0,...,1
+ggthemes,scale_color_gdocs,-1,0,0,"class<`Scale`, `ScaleDiscrete`, `gg`, `ggproto`>",1
+ggthemes,scale_color_gdocs,0,0,0,...,1
+ggthemes,scale_color_pander,-1,0,0,"class<`Scale`, `ScaleDiscrete`, `gg`, `ggproto`>",1
+ggthemes,scale_color_pander,0,0,0,...,1
+ggthemes,scale_color_ptol,-1,0,0,"class<`Scale`, `ScaleDiscrete`, `gg`, `ggproto`>",1
+ggthemes,scale_color_ptol,0,0,0,...,1
+ggthemes,scale_color_tableau,-1,0,0,"class<`Scale`, `ScaleDiscrete`, `gg`, `ggproto`>",1
+ggthemes,scale_color_tableau,0,0,0,character,1
+ggthemes,scale_color_tableau,1,0,0,character,1
+ggthemes,scale_color_tableau,2,0,0,any,1
+ggthemes,scale_color_tableau,3,0,0,...,1
+ggthemes,scale_colour_colorblind,-1,0,0,"class<`Scale`, `ScaleDiscrete`, `gg`, `ggproto`>",1
+ggthemes,scale_colour_colorblind,0,0,0,...,1
+ggthemes,scale_colour_economist,-1,0,0,"class<`Scale`, `ScaleDiscrete`, `gg`, `ggproto`>",1
+ggthemes,scale_colour_economist,0,0,0,...,1
+ggthemes,scale_colour_excel,-1,0,0,"class<`Scale`, `ScaleDiscrete`, `gg`, `ggproto`>",1
+ggthemes,scale_colour_excel,0,0,0,...,1
+ggthemes,scale_colour_excel_new,-1,0,0,"class<`Scale`, `ScaleDiscrete`, `gg`, `ggproto`>",1
+ggthemes,scale_colour_excel_new,0,0,0,character,1
+ggthemes,scale_colour_excel_new,1,0,0,...,1
+ggthemes,scale_colour_few,-1,0,0,"class<`Scale`, `ScaleDiscrete`, `gg`, `ggproto`>",1
+ggthemes,scale_colour_few,0,0,0,character,1
+ggthemes,scale_colour_few,1,0,0,...,1
+ggthemes,scale_colour_gradient2_tableau,-1,0,0,"class<`Scale`, `ScaleContinuous`, `gg`, `ggproto`>",1
+ggthemes,scale_colour_gradient2_tableau,0,0,0,character,1
+ggthemes,scale_colour_gradient2_tableau,1,0,0,...,1
+ggthemes,scale_colour_gradient2_tableau,2,0,0,character,1
+ggthemes,scale_colour_gradient2_tableau,3,0,0,character,1
+ggthemes,scale_colour_gradient_tableau,-1,0,0,"class<`Scale`, `ScaleContinuous`, `gg`, `ggproto`>",1
+ggthemes,scale_colour_gradient_tableau,0,0,0,character,1
+ggthemes,scale_colour_gradient_tableau,1,0,0,...,1
+ggthemes,scale_colour_gradient_tableau,2,0,0,character,1
+ggthemes,scale_colour_gradient_tableau,3,0,0,character,1
+ggthemes,scale_colour_hc,-1,0,0,"class<`Scale`, `ScaleDiscrete`, `gg`, `ggproto`>",1
+ggthemes,scale_colour_hc,0,0,0,character,1
+ggthemes,scale_colour_hc,1,0,0,...,1
+ggthemes,scale_colour_solarized,-1,0,0,"class<`Scale`, `ScaleDiscrete`, `gg`, `ggproto`>",1
+ggthemes,scale_colour_solarized,0,0,0,character,1
+ggthemes,scale_colour_solarized,1,0,0,...,1
+ggthemes,scale_colour_stata,-1,0,0,"class<`Scale`, `ScaleDiscrete`, `gg`, `ggproto`>",1
+ggthemes,scale_colour_stata,0,0,0,character,1
+ggthemes,scale_colour_stata,1,0,0,...,1
+ggthemes,scale_colour_tableau,-1,0,0,"class<`Scale`, `ScaleDiscrete`, `gg`, `ggproto`>",1
+ggthemes,scale_colour_tableau,0,0,0,character,1
+ggthemes,scale_colour_tableau,1,0,0,character,1
+ggthemes,scale_colour_tableau,2,0,0,any,1
+ggthemes,scale_colour_tableau,3,0,0,...,1
+ggthemes,scale_colour_wsj,-1,0,0,"class<`Scale`, `ScaleDiscrete`, `gg`, `ggproto`>",1
+ggthemes,scale_colour_wsj,0,0,0,character,1
+ggthemes,scale_colour_wsj,1,0,0,...,1
+ggthemes,scale_fill_excel,-1,0,0,"class<`Scale`, `ScaleDiscrete`, `gg`, `ggproto`>",1
+ggthemes,scale_fill_excel,0,0,0,...,1
+ggthemes,scale_fill_hc,-1,0,0,"class<`Scale`, `ScaleDiscrete`, `gg`, `ggproto`>",1
+ggthemes,scale_fill_hc,0,0,0,character,1
+ggthemes,scale_fill_hc,1,0,0,...,1
+ggthemes,scale_fill_pander,-1,0,0,"class<`Scale`, `ScaleDiscrete`, `gg`, `ggproto`>",1
+ggthemes,scale_fill_pander,0,0,0,...,1
+ggthemes,scale_fill_ptol,-1,0,0,"class<`Scale`, `ScaleDiscrete`, `gg`, `ggproto`>",1
+ggthemes,scale_fill_ptol,0,0,0,...,1
+ggthemes,scale_linetype_stata,-1,0,0,"class<`Scale`, `ScaleDiscrete`, `gg`, `ggproto`>",1
+ggthemes,scale_linetype_stata,0,0,0,...,1
+ggthemes,scale_shape_calc,-1,0,0,"class<`Scale`, `ScaleDiscrete`, `gg`, `ggproto`>",1
+ggthemes,scale_shape_calc,0,0,0,...,1
+ggthemes,scale_shape_circlefill,-1,0,0,"class<`Scale`, `ScaleDiscrete`, `gg`, `ggproto`>",1
+ggthemes,scale_shape_circlefill,0,0,0,...,1
+ggthemes,scale_shape_cleveland,-1,0,0,"class<`Scale`, `ScaleDiscrete`, `gg`, `ggproto`>",1
+ggthemes,scale_shape_cleveland,0,0,0,logical,1
+ggthemes,scale_shape_cleveland,1,0,0,...,1
+ggthemes,scale_shape_few,-1,0,0,"class<`Scale`, `ScaleDiscrete`, `gg`, `ggproto`>",1
+ggthemes,scale_shape_few,0,0,0,...,1
+ggthemes,scale_shape_stata,-1,0,0,"class<`Scale`, `ScaleDiscrete`, `gg`, `ggproto`>",1
+ggthemes,scale_shape_stata,0,0,0,...,1
+ggthemes,scale_shape_tableau,-1,0,0,"class<`Scale`, `ScaleDiscrete`, `gg`, `ggproto`>",1
+ggthemes,scale_shape_tableau,0,0,0,character,1
+ggthemes,scale_shape_tableau,1,0,0,...,1
+ggthemes,scale_shape_tremmel,-1,0,0,"class<`Scale`, `ScaleDiscrete`, `gg`, `ggproto`>",1
+ggthemes,scale_shape_tremmel,0,0,0,logical,1
+ggthemes,scale_shape_tremmel,1,0,0,logical,1
+ggthemes,scale_shape_tremmel,2,0,0,...,1
+ggthemes,show_linetypes,-1,0,0,character[],1
+ggthemes,show_linetypes,0,0,0,character[],1
+ggthemes,show_linetypes,1,0,0,logical,1
+ggthemes,show_shapes,-1,0,0,double[],1
+ggthemes,show_shapes,0,0,0,double[],1
+ggthemes,show_shapes,1,0,0,logical,1
+ggthemes,.simplicity,-1,0,0,double,1
+ggthemes,.simplicity,0,0,0,double,1
+ggthemes,.simplicity,1,0,0,double[],1
+ggthemes,.simplicity,2,0,0,double,1
+ggthemes,.simplicity,3,0,0,double,1
+ggthemes,.simplicity,4,0,0,any,1
+ggthemes,.simplicity,5,0,0,double,1
+ggthemes,.simplicity.max,-1,0,0,double,1
+ggthemes,.simplicity.max,0,0,0,double,1
+ggthemes,.simplicity.max,1,0,0,double[],1
+ggthemes,.simplicity.max,2,0,0,double,1
+ggthemes,solarized_pal,-1,0,0,character[],1
+ggthemes,solarized_pal,0,0,0,double,1
+ggthemes,solarized_pal,-1,1,0,class<`function`>,1
+ggthemes,solarized_pal,0,1,0,character,1
+ggthemes,solarized_rebase,-1,0,0,character[],1
+ggthemes,solarized_rebase,0,0,0,logical,1
+ggthemes,stata_linetype_pal,-1,0,0,class<`function`>,1
+ggthemes,stata_pal,-1,0,0,class<`function`>,1
+ggthemes,stata_pal,0,0,0,character,1
+ggthemes,stata_shape_pal,-1,0,0,class<`function`>,1
+ggthemes,tableau_color_pal,-1,0,0,class<`function`>,1
+ggthemes,tableau_color_pal,0,0,0,character,1
+ggthemes,tableau_color_pal,1,0,0,character[],1
+ggthemes,tableau_color_pal,2,0,0,any,1
+ggthemes,tableau_div_gradient_pal,-1,0,0,class<`function`>,1
+ggthemes,tableau_div_gradient_pal,0,0,0,character,1
+ggthemes,tableau_div_gradient_pal,1,0,0,...,1
+ggthemes,tableau_gradient_pal,-1,0,0,class<`function`>,1
+ggthemes,tableau_gradient_pal,0,0,0,character,1
+ggthemes,tableau_gradient_pal,1,0,0,character,1
+ggthemes,tableau_seq_gradient_pal,-1,0,0,class<`function`>,1
+ggthemes,tableau_seq_gradient_pal,0,0,0,character,1
+ggthemes,tableau_seq_gradient_pal,1,0,0,...,1
+ggthemes,tableau_shape_pal,-1,0,0,class<`function`>,1
+ggthemes,tableau_shape_pal,0,0,0,character,1
+ggthemes,theme_base,-1,0,0,"class<`gg`, `theme`>",1
+ggthemes,theme_base,0,0,0,double,1
+ggthemes,theme_base,1,0,0,character,1
+ggthemes,theme_calc,-1,0,0,"class<`gg`, `theme`>",1
+ggthemes,theme_calc,0,0,0,double,1
+ggthemes,theme_calc,1,0,0,character,1
+ggthemes,theme_clean,-1,0,0,"class<`gg`, `theme`>",1
+ggthemes,theme_clean,0,0,0,double,1
+ggthemes,theme_clean,1,0,0,character,1
+ggthemes,theme_economist,-1,0,0,"class<`gg`, `theme`>",1
+ggthemes,theme_economist,0,0,0,double,1
+ggthemes,theme_economist,1,0,0,character,1
+ggthemes,theme_economist,2,0,0,logical,1
+ggthemes,theme_economist,3,0,0,logical,1
+ggthemes,theme_economist_white,-1,0,0,"class<`gg`, `theme`>",1
+ggthemes,theme_economist_white,0,0,0,double,1
+ggthemes,theme_economist_white,1,0,0,character,1
+ggthemes,theme_economist_white,2,0,0,logical,1
+ggthemes,theme_economist_white,3,0,0,logical,1
+ggthemes,theme_excel,-1,0,0,"class<`gg`, `theme`>",1
+ggthemes,theme_excel,0,0,0,double,1
+ggthemes,theme_excel,1,0,0,character,1
+ggthemes,theme_excel,2,0,0,logical,1
+ggthemes,theme_excel_new,-1,0,0,"class<`gg`, `theme`>",1
+ggthemes,theme_excel_new,0,0,0,double,1
+ggthemes,theme_excel_new,1,0,0,character,1
+ggthemes,theme_few,-1,0,0,"class<`gg`, `theme`>",1
+ggthemes,theme_few,0,0,0,double,1
+ggthemes,theme_few,1,0,0,character,1
+ggthemes,theme_fivethirtyeight,-1,0,0,"class<`gg`, `theme`>",1
+ggthemes,theme_fivethirtyeight,0,0,0,double,1
+ggthemes,theme_fivethirtyeight,1,0,0,character,1
+ggthemes,theme_foundation,-1,0,0,"class<`gg`, `theme`>",1
+ggthemes,theme_foundation,0,0,0,double,1
+ggthemes,theme_foundation,1,0,0,character,1
+ggthemes,theme_gdocs,-1,0,0,"class<`gg`, `theme`>",1
+ggthemes,theme_gdocs,0,0,0,double,1
+ggthemes,theme_gdocs,1,0,0,character,1
+ggthemes,theme_hc,-1,0,0,"class<`gg`, `theme`>",1
+ggthemes,theme_hc,0,0,0,double,1
+ggthemes,theme_hc,1,0,0,character,1
+ggthemes,theme_hc,2,0,0,any,1
+ggthemes,theme_hc,3,0,0,character,1
+ggthemes,theme_hc,3,0,1,null,1
+ggthemes,theme_igray,-1,0,0,"class<`gg`, `theme`>",1
+ggthemes,theme_igray,0,0,0,double,1
+ggthemes,theme_igray,1,0,0,character,1
+ggthemes,theme_map,-1,0,0,"class<`gg`, `theme`>",1
+ggthemes,theme_map,0,0,0,double,1
+ggthemes,theme_map,1,0,0,character,1
+ggthemes,theme_pander,-1,0,0,"class<`gg`, `theme`>",1
+ggthemes,theme_pander,0,0,0,double,1
+ggthemes,theme_pander,1,0,0,character,1
+ggthemes,theme_pander,2,0,0,logical,1
+ggthemes,theme_pander,3,0,0,null,1
+ggthemes,theme_pander,4,0,0,character,1
+ggthemes,theme_pander,5,0,0,null,1
+ggthemes,theme_pander,6,0,0,logical,1
+ggthemes,theme_pander,7,0,0,logical,1
+ggthemes,theme_pander,8,0,0,character,1
+ggthemes,theme_pander,9,0,0,character,1
+ggthemes,theme_pander,10,0,0,logical,1
+ggthemes,theme_pander,11,0,0,character,1
+ggthemes,theme_pander,12,0,0,character,1
+ggthemes,theme_pander,13,0,0,character,1
+ggthemes,theme_pander,14,0,0,double,1
+ggthemes,theme_par,-1,0,0,"class<`gg`, `theme`>",1
+ggthemes,theme_par,0,0,0,integer,1
+ggthemes,theme_par,1,0,0,character,1
+ggthemes,theme_solarized,-1,0,0,"class<`gg`, `theme`>",1
+ggthemes,theme_solarized,0,0,0,double,1
+ggthemes,theme_solarized,1,0,0,character,1
+ggthemes,theme_solarized,2,0,0,logical,1
+ggthemes,theme_solarized_2,-1,0,0,"class<`gg`, `theme`>",1
+ggthemes,theme_solarized_2,0,0,0,double,1
+ggthemes,theme_solarized_2,1,0,0,character,1
+ggthemes,theme_solarized_2,2,0,0,logical,1
+ggthemes,theme_solid,-1,0,0,"class<`gg`, `theme`>",1
+ggthemes,theme_solid,0,0,0,double,1
+ggthemes,theme_solid,1,0,0,character,1
+ggthemes,theme_solid,2,0,0,character,1
+ggthemes,theme_stata,-1,0,0,"class<`gg`, `theme`>",1
+ggthemes,theme_stata,0,0,0,double,1
+ggthemes,theme_stata,1,0,0,character,1
+ggthemes,theme_stata,2,0,0,character,1
+ggthemes,theme_stata_base,-1,0,0,"class<`gg`, `theme`>",1
+ggthemes,theme_stata_base,0,0,0,double,1
+ggthemes,theme_stata_base,1,0,0,character,1
+ggthemes,theme_stata_colors,-1,0,0,"class<`gg`, `theme`>",1
+ggthemes,theme_stata_colors,0,0,0,character,1
+ggthemes,theme_tufte,-1,0,0,"class<`gg`, `theme`>",1
+ggthemes,theme_tufte,0,0,0,double,1
+ggthemes,theme_tufte,1,0,0,character,1
+ggthemes,theme_tufte,2,0,0,logical,1
+ggthemes,theme_wsj,-1,0,0,"class<`gg`, `theme`>",1
+ggthemes,theme_wsj,0,0,0,double,1
+ggthemes,theme_wsj,1,0,0,character,1
+ggthemes,theme_wsj,2,0,0,character,1
+ggthemes,theme_wsj,3,0,0,character,1
+ggthemes,tremmel_shape_pal,-1,0,0,class<`function`>,1
+ggthemes,tremmel_shape_pal,0,0,0,any,1
+ggthemes,tremmel_shape_pal,1,0,0,any,1
+ggthemes,tremmel_shape_pal,2,0,0,null,1
+ggthemes,wsj_pal,-1,0,0,class<`function`>,1
+ggthemes,wsj_pal,0,0,0,character,1
+git2r,add,-1,0,0,null,1
+git2r,add,0,0,0,class<`git_repository`>,1
+git2r,add,1,0,0,character[],1
+git2r,add,2,0,0,logical,1
+git2r,add_session_info,-1,0,0,character,1
+git2r,add_session_info,0,0,0,character,1
+git2r,ahead_behind,-1,0,0,integer[],1
+git2r,ahead_behind,0,0,0,class<`git_branch`>,1
+git2r,ahead_behind,0,0,1,class<`git_commit`>,1
+git2r,ahead_behind,0,0,2,class<`git_tag`>,1
+git2r,ahead_behind,1,0,0,class<`git_commit`>,1
+git2r,ahead_behind,1,0,1,class<`git_branch`>,1
+git2r,ahead_behind,1,0,2,class<`git_tag`>,1
+git2r,as.character.git_time,-1,0,0,character,1
+git2r,as.character.git_time,0,0,0,class<`git_time`>,1
+git2r,as.character.git_time,1,0,0,...,1
+git2r,as.data.frame.git_commit,-1,0,0,class<`data.frame`>,1
+git2r,as.data.frame.git_commit,0,0,0,class<`git_commit`>,1
+git2r,as.data.frame.git_commit,1,0,0,...,1
+git2r,as.data.frame.git_repository,-1,0,0,class<`data.frame`>,1
+git2r,as.data.frame.git_repository,0,0,0,class<`git_repository`>,1
+git2r,as.data.frame.git_repository,1,0,0,...,1
+git2r,as.data.frame.git_tree,-1,0,0,class<`data.frame`>,1
+git2r,as.data.frame.git_tree,0,0,0,class<`git_tree`>,1
+git2r,as.data.frame.git_tree,1,0,0,...,1
+git2r,as.list.git_tree,-1,0,0,list<class<`git_blob`>>,1
+git2r,as.list.git_tree,0,0,0,class<`git_tree`>,1
+git2r,as.list.git_tree,1,0,0,...,1
+git2r,as.POSIXct.git_time,-1,0,0,"class<`POSIXct`, `POSIXt`>",1
+git2r,as.POSIXct.git_time,0,0,0,class<`git_time`>,1
+git2r,as.POSIXct.git_time,1,0,0,...,1
+git2r,blame,-1,0,0,class<`git_blame`>,1
+git2r,blame,0,0,0,class<`git_repository`>,1
+git2r,blame,1,0,0,character,1
+git2r,blob_create,-1,0,0,list<class<`git_blob`>>,1
+git2r,blob_create,0,0,0,class<`git_repository`>,1
+git2r,blob_create,1,0,0,character[],1
+git2r,blob_create,2,0,0,logical,1
+git2r,branch_create,-1,0,0,any,1
+git2r,branch_create,0,0,0,class<`git_commit`>,1
+git2r,branch_create,1,0,0,character,1
+git2r,branch_create,2,0,0,logical,1
+git2r,branch_delete,-1,0,0,null,1
+git2r,branch_delete,0,0,0,class<`git_branch`>,1
+git2r,branches,-1,0,0,list<any>,1
+git2r,branches,0,0,0,class<`git_repository`>,1
+git2r,branches,0,0,1,character,1
+git2r,branches,1,0,0,character[],1
+git2r,branch_get_upstream,-1,0,0,class<`git_branch`>,1
+git2r,branch_get_upstream,-1,0,1,null,1
+git2r,branch_get_upstream,0,0,0,class<`git_branch`>,1
+git2r,branch_remote_name,-1,0,0,character,1
+git2r,branch_remote_name,0,0,0,class<`git_branch`>,1
+git2r,branch_remote_url,-1,0,0,character,1
+git2r,branch_remote_url,0,0,0,class<`git_branch`>,1
+git2r,branch_rename,-1,0,0,any,1
+git2r,branch_rename,0,0,0,class<`git_branch`>,1
+git2r,branch_rename,1,0,0,character,1
+git2r,branch_rename,2,0,0,logical,1
+git2r,branch_set_upstream,-1,0,0,any,1
+git2r,branch_set_upstream,0,0,0,class<`git_branch`>,1
+git2r,branch_set_upstream,0,0,1,null,1
+git2r,branch_set_upstream,1,0,0,any,1
+git2r,branch_target,-1,0,0,character,1
+git2r,branch_target,0,0,0,class<`git_branch`>,1
+git2r,bundle_r_package,-1,0,0,any,1
+git2r,bundle_r_package,0,0,0,class<`git_repository`>,1
+git2r,checkout,-1,0,0,any,1
+git2r,checkout,0,0,0,class<`git_repository`>,1
+git2r,checkout,0,0,1,class<`git_branch`>,1
+git2r,checkout,0,0,2,class<`git_commit`>,1
+git2r,checkout,0,0,3,class<`git_tag`>,1
+git2r,checkout,1,0,0,character[],1
+git2r,checkout,1,0,1,null,1
+git2r,checkout,1,0,2,logical,1
+git2r,checkout,2,0,0,logical,1
+git2r,checkout,3,0,0,logical,1
+git2r,checkout,4,0,0,null,1
+git2r,checkout,4,0,1,character,1
+git2r,checkout,5,0,0,...,1
+git2r,checkout_branch,-1,0,0,null,1
+git2r,checkout_branch,0,0,0,class<`git_branch`>,1
+git2r,checkout_branch,1,0,0,logical,1
+git2r,checkout_commit,-1,0,0,null,1
+git2r,checkout_commit,0,0,0,class<`git_commit`>,1
+git2r,checkout_commit,1,0,0,logical,1
+git2r,checkout_git_object,-1,0,0,any,1
+git2r,checkout_git_object,0,0,0,any,1
+git2r,checkout_git_object,1,0,0,any,1
+git2r,checkout_tag,-1,0,0,null,1
+git2r,checkout_tag,0,0,0,class<`git_tag`>,1
+git2r,checkout_tag,1,0,0,logical,1
+git2r,clone,-1,0,0,any,1
+git2r,clone,0,0,0,character,1
+git2r,clone,1,0,0,character,1
+git2r,clone,2,0,0,character,1
+git2r,clone,2,0,1,double,1
+git2r,clone,2,0,2,logical[],1
+git2r,clone,3,0,0,character,1
+git2r,clone,3,0,1,null,1
+git2r,clone,4,0,0,character,1
+git2r,clone,4,0,1,double,1
+git2r,clone,4,0,2,logical[],1
+git2r,clone,5,0,0,null,1
+git2r,clone,6,0,0,logical,1
+git2r,commit,-1,0,0,any,1
+git2r,commit,0,0,0,class<`git_repository`>,1
+git2r,commit,1,0,0,character,1
+git2r,commit,2,0,0,logical,1
+git2r,commit,3,0,0,logical,1
+git2r,commit,4,0,0,null,1
+git2r,commit,5,0,0,null,1
+git2r,commits,-1,0,0,any,1
+git2r,commits,0,0,0,any,1
+git2r,commits,1,0,0,logical,1
+git2r,commits,2,0,0,logical,1
+git2r,commits,3,0,0,logical,1
+git2r,commits,4,0,0,character,1
+git2r,commits,4,0,1,double,1
+git2r,commits,4,0,2,integer[],1
+git2r,commits,4,0,3,null,1
+git2r,commits,5,0,0,null,1
+git2r,commits,5,0,1,character,1
+git2r,commits,6,0,0,null,1
+git2r,commits,6,0,1,character,1
+git2r,config,-1,0,0,any,1
+git2r,config,0,0,0,class<`git_repository`>,1
+git2r,config,0,0,1,null,1
+git2r,config,1,0,0,logical,1
+git2r,config,2,0,0,any,1
+git2r,config,3,0,0,any,1
+git2r,config,4,0,0,...,1
+git2r,content,-1,0,0,character[],1
+git2r,content,-1,0,1,null,1
+git2r,content,0,0,0,class<`git_blob`>,1
+git2r,content,1,0,0,logical,1
+git2r,contributions,-1,0,0,class<`data.frame`>,1
+git2r,contributions,0,0,0,class<`git_repository`>,1
+git2r,contributions,1,0,0,character[],1
+git2r,contributions,2,0,0,character[],1
+git2r,cred_env,-1,0,0,class<`cred_env`>,1
+git2r,cred_env,0,0,0,character[],1
+git2r,cred_env,1,0,0,character[],1
+git2r,cred_token,-1,0,0,class<`cred_token`>,1
+git2r,cred_token,0,0,0,character[],1
+git2r,cred_user_pass,-1,0,0,class<`cred_user_pass`>,1
+git2r,cred_user_pass,0,0,0,character[],1
+git2r,cred_user_pass,1,0,0,character[],1
+git2r,default_signature,-1,0,0,class<`git_signature`>,1
+git2r,default_signature,0,0,0,class<`git_repository`>,1
+git2r,descendant_of,-1,0,0,logical,1
+git2r,descendant_of,0,0,0,class<`git_branch`>,1
+git2r,descendant_of,0,0,1,class<`git_commit`>,1
+git2r,descendant_of,0,0,2,class<`git_tag`>,1
+git2r,descendant_of,1,0,0,class<`git_commit`>,1
+git2r,descendant_of,1,0,1,class<`git_branch`>,1
+git2r,descendant_of,1,0,2,class<`git_tag`>,1
+git2r,diff.git_repository,-1,0,0,character,1
+git2r,diff.git_repository,-1,0,1,class<`git_diff`>,1
+git2r,diff.git_repository,-1,0,2,null,1
+git2r,diff.git_repository,0,0,0,class<`git_repository`>,1
+git2r,diff.git_repository,1,0,0,logical,1
+git2r,diff.git_repository,2,0,0,logical,1
+git2r,diff.git_repository,3,0,0,null,1
+git2r,diff.git_repository,3,0,1,character,1
+git2r,diff.git_repository,4,0,0,double,1
+git2r,diff.git_repository,5,0,0,double,1
+git2r,diff.git_repository,6,0,0,character,1
+git2r,diff.git_repository,7,0,0,character,1
+git2r,diff.git_repository,8,0,0,null,1
+git2r,diff.git_repository,9,0,0,null,1
+git2r,diff.git_repository,10,0,0,null,1
+git2r,diff.git_repository,11,0,0,...,1
+git2r,diff.git_tree,-1,0,0,class<`git_diff`>,1
+git2r,diff.git_tree,0,0,0,class<`git_tree`>,1
+git2r,diff.git_tree,1,0,0,class<`git_tree`>,1
+git2r,diff.git_tree,1,0,1,null,1
+git2r,diff.git_tree,2,0,0,logical,1
+git2r,diff.git_tree,3,0,0,logical,1
+git2r,diff.git_tree,4,0,0,null,1
+git2r,diff.git_tree,5,0,0,double,1
+git2r,diff.git_tree,6,0,0,double,1
+git2r,diff.git_tree,7,0,0,character,1
+git2r,diff.git_tree,8,0,0,character,1
+git2r,diff.git_tree,9,0,0,null,1
+git2r,diff.git_tree,10,0,0,null,1
+git2r,diff.git_tree,11,0,0,null,1
+git2r,diff.git_tree,12,0,0,...,1
+git2r,discover_repository,-1,0,0,any,1
+git2r,discover_repository,0,0,0,character,1
+git2r,discover_repository,1,0,0,double,1
+git2r,discover_repository,1,0,1,null,1
+git2r,fetch,-1,0,0,class<`git_transfer_progress`>,1
+git2r,fetch,0,0,0,class<`git_repository`>,1
+git2r,fetch,1,0,0,character,1
+git2r,fetch,2,0,0,null,1
+git2r,fetch,3,0,0,logical,1
+git2r,fetch,4,0,0,null,1
+git2r,fetch_heads,-1,0,0,list<class<`git_fetch_head`>>,1
+git2r,fetch_heads,0,0,0,class<`git_repository`>,1
+git2r,format.git_blob,-1,0,0,character,1
+git2r,format.git_blob,0,0,0,class<`git_blob`>,1
+git2r,format.git_blob,1,0,0,...,1
+git2r,format.git_commit,-1,0,0,character,1
+git2r,format.git_commit,0,0,0,class<`git_commit`>,1
+git2r,format.git_commit,1,0,0,...,1
+git2r,format.git_merge_result,-1,0,0,character,1
+git2r,format.git_merge_result,0,0,0,class<`git_merge_result`>,1
+git2r,format.git_merge_result,1,0,0,...,1
+git2r,format.git_note,-1,0,0,character,1
+git2r,format.git_note,0,0,0,class<`git_note`>,1
+git2r,format.git_note,1,0,0,...,1
+git2r,format.git_reference,-1,0,0,character,1
+git2r,format.git_reference,0,0,0,class<`git_reference`>,1
+git2r,format.git_reference,1,0,0,...,1
+git2r,format.git_signature,-1,0,0,character,1
+git2r,format.git_signature,0,0,0,class<`git_signature`>,1
+git2r,format.git_signature,1,0,0,...,1
+git2r,format.git_stash,-1,0,0,character,1
+git2r,format.git_stash,0,0,0,"class<`git_commit`, `git_stash`>",1
+git2r,format.git_stash,1,0,0,...,1
+git2r,format.git_tag,-1,0,0,character,1
+git2r,format.git_tag,0,0,0,class<`git_tag`>,1
+git2r,format.git_tag,1,0,0,...,1
+git2r,get_refspec,-1,0,0,any,1
+git2r,get_refspec,0,0,0,class<`git_repository`>,1
+git2r,get_refspec,1,0,0,character[],1
+git2r,get_refspec,1,0,1,null,1
+git2r,get_refspec,2,0,0,any,1
+git2r,get_refspec,3,0,0,list<logical>,1
+git2r,get_upstream_name,-1,0,0,any,1
+git2r,get_upstream_name,0,0,0,class<`git_branch`>,1
+git2r,git_config_files,-1,0,0,class<`data.frame`>,1
+git2r,git_config_files,0,0,0,character,1
+git2r,git_config_files,0,0,1,class<`git_repository`>,1
+git2r,git_config_files,0,0,2,double,1
+git2r,git_config_files,0,0,3,null,1
+git2r,[.git_tree,-1,0,0,any,1
+git2r,[.git_tree,0,0,0,class<`git_tree`>,1
+git2r,[.git_tree,1,0,0,character,1
+git2r,[.git_tree,1,0,1,integer,1
+git2r,[.git_tree,1,0,2,class<`data.frame`>,1
+git2r,hash,-1,0,0,^character[],1
+git2r,hash,0,0,0,^character[],1
+git2r,hashfile,-1,0,0,any,1
+git2r,hashfile,0,0,0,^character[],1
+git2r,home_dir,-1,0,0,character,1
+git2r,hunks_per_file,-1,0,0,double,1
+git2r,hunks_per_file,0,0,0,class<`git_diff`>,1
+git2r,index_remove_bypath,-1,0,0,null,1
+git2r,index_remove_bypath,0,0,0,class<`git_repository`>,1
+git2r,index_remove_bypath,1,0,0,character,1
+git2r,init,-1,0,0,any,1
+git2r,init,0,0,0,character,1
+git2r,init,1,0,0,logical,1
+git2r,in_repository,-1,0,0,logical,1
+git2r,in_repository,0,0,0,character,1
+git2r,is_bare,-1,0,0,any,1
+git2r,is_bare,0,0,0,any,1
+git2r,is_binary,-1,0,0,logical,1
+git2r,is_binary,0,0,0,class<`git_blob`>,1
+git2r,is_blob,-1,0,0,logical,1
+git2r,is_blob,0,0,0,class<`git_blob`>,1
+git2r,is_blob,0,0,1,class<`git_commit`>,1
+git2r,is_blob,0,0,2,class<`git_tree`>,1
+git2r,is_blob,0,0,3,double,1
+git2r,is_branch,-1,0,0,any,1
+git2r,is_branch,0,0,0,any,1
+git2r,is_commit,-1,0,0,logical,1
+git2r,is_commit,0,0,0,class<`git_blob`>,1
+git2r,is_commit,0,0,1,class<`git_commit`>,1
+git2r,is_commit,0,0,2,class<`git_repository`>,1
+git2r,is_commit,0,0,3,class<`git_tag`>,1
+git2r,is_commit,0,0,4,class<`git_tree`>,1
+git2r,is_commit,0,0,5,double,1
+git2r,is_detached,-1,0,0,logical,1
+git2r,is_detached,0,0,0,character,1
+git2r,is_detached,0,0,1,class<`git_repository`>,1
+git2r,is_empty,-1,0,0,any,1
+git2r,is_empty,0,0,0,any,1
+git2r,is_head,-1,0,0,logical,1
+git2r,is_head,0,0,0,class<`git_branch`>,1
+git2r,is_local,-1,0,0,any,1
+git2r,is_local,0,0,0,double,1
+git2r,is_local,0,0,1,class<`git_branch`>,1
+git2r,is_merge,-1,0,0,logical,1
+git2r,is_merge,0,0,0,class<`git_commit`>,1
+git2r,is_shallow,-1,0,0,logical,1
+git2r,is_shallow,0,0,0,character,1
+git2r,is_shallow,0,0,1,class<`git_repository`>,1
+git2r,is_tag,-1,0,0,logical,1
+git2r,is_tag,0,0,0,character,1
+git2r,is_tag,0,0,1,class<`git_repository`>,1
+git2r,is_tag,0,0,2,class<`git_tag`>,1
+git2r,is_tree,-1,0,0,logical,1
+git2r,is_tree,0,0,0,class<`git_blob`>,1
+git2r,is_tree,0,0,1,class<`git_commit`>,1
+git2r,is_tree,0,0,2,class<`git_tree`>,1
+git2r,is_tree,0,0,3,double,1
+git2r,last_commit,-1,0,0,class<`git_commit`>,1
+git2r,last_commit,0,0,0,character,1
+git2r,last_commit,0,0,1,class<`git_repository`>,1
+git2r,length.git_blob,-1,0,0,integer,1
+git2r,length.git_blob,0,0,0,class<`git_blob`>,1
+git2r,length.git_diff,-1,0,0,integer,1
+git2r,length.git_diff,0,0,0,class<`git_diff`>,1
+git2r,length.git_tree,-1,0,0,integer,1
+git2r,length.git_tree,0,0,0,class<`git_tree`>,1
+git2r,libgit2_features,-1,0,0,list<logical>,1
+git2r,libgit2_version,-1,0,0,list<integer>,1
+git2r,lines_per_file,-1,0,0,list<list<character | double>>,1
+git2r,lines_per_file,0,0,0,class<`git_diff`>,1
+git2r,lookup,-1,0,0,any,1
+git2r,lookup,0,0,0,class<`git_repository`>,1
+git2r,lookup,1,0,0,character,1
+git2r,lookup_commit,-1,0,0,class<`git_commit`>,1
+git2r,lookup_commit,0,0,0,class<`git_branch`>,1
+git2r,lookup_commit,0,0,1,class<`git_commit`>,1
+git2r,lookup_commit,0,0,2,class<`git_reference`>,1
+git2r,lookup_commit,0,0,3,class<`git_tag`>,1
+git2r,lookup_commit.git_branch,-1,0,0,class<`git_commit`>,1
+git2r,lookup_commit.git_branch,0,0,0,class<`git_branch`>,1
+git2r,lookup_commit.git_commit,-1,0,0,class<`git_commit`>,1
+git2r,lookup_commit.git_commit,0,0,0,class<`git_commit`>,1
+git2r,lookup_commit.git_reference,-1,0,0,class<`git_commit`>,1
+git2r,lookup_commit.git_reference,0,0,0,class<`git_reference`>,1
+git2r,lookup_commit.git_tag,-1,0,0,class<`git_commit`>,1
+git2r,lookup_commit.git_tag,0,0,0,class<`git_tag`>,1
+git2r,lookup_repository,-1,0,0,any,1
+git2r,lookup_repository,0,0,0,any,1
+git2r,ls_tree,-1,0,0,class<`data.frame`>,1
+git2r,ls_tree,0,0,0,character,1
+git2r,ls_tree,0,0,1,null,1
+git2r,ls_tree,1,0,0,class<`git_repository`>,1
+git2r,ls_tree,1,0,1,character,1
+git2r,ls_tree,2,0,0,logical,1
+git2r,merge_base,-1,0,0,class<`git_commit`>,1
+git2r,merge_base,0,0,0,class<`git_commit`>,1
+git2r,merge_base,1,0,0,class<`git_commit`>,1
+git2r,merge.character,-1,0,0,class<`git_merge_result`>,1
+git2r,merge.character,0,0,0,character,1
+git2r,merge.character,1,0,0,character,1
+git2r,merge.character,2,0,0,logical,1
+git2r,merge.character,3,0,0,null,1
+git2r,merge.character,4,0,0,logical,1
+git2r,merge.character,5,0,0,...,1
+git2r,merge.git_branch,-1,0,0,class<`git_merge_result`>,1
+git2r,merge.git_branch,0,0,0,class<`git_branch`>,1
+git2r,merge.git_branch,1,0,0,null,1
+git2r,merge.git_branch,2,0,0,logical,1
+git2r,merge.git_branch,3,0,0,class<`git_signature`>,1
+git2r,merge.git_branch,3,0,1,null,1
+git2r,merge.git_branch,4,0,0,logical,1
+git2r,merge.git_branch,5,0,0,...,1
+git2r,merge.git_repository,-1,0,0,any,1
+git2r,merge.git_repository,0,0,0,class<`git_repository`>,1
+git2r,merge.git_repository,1,0,0,character,1
+git2r,merge.git_repository,1,0,1,null,1
+git2r,merge.git_repository,2,0,0,logical,1
+git2r,merge.git_repository,3,0,0,null,1
+git2r,merge.git_repository,3,0,1,class<`git_signature`>,1
+git2r,merge.git_repository,4,0,0,logical,1
+git2r,merge.git_repository,5,0,0,...,1
+git2r,note_create,-1,0,0,any,1
+git2r,note_create,0,0,0,class<`git_blob`>,1
+git2r,note_create,0,0,1,class<`git_commit`>,1
+git2r,note_create,0,0,2,class<`git_tree`>,1
+git2r,note_create,0,0,3,double,1
+git2r,note_create,0,0,4,null,1
+git2r,note_create,1,0,0,character,1
+git2r,note_create,2,0,0,null,1
+git2r,note_create,2,0,1,character,1
+git2r,note_create,3,0,0,null,1
+git2r,note_create,4,0,0,null,1
+git2r,note_create,5,0,0,logical,1
+git2r,note_default_ref,-1,0,0,character,1
+git2r,note_default_ref,0,0,0,class<`git_repository`>,1
+git2r,note_remove,-1,0,0,any,1
+git2r,note_remove,0,0,0,double,1
+git2r,note_remove,0,0,1,class<`git_note`>,1
+git2r,note_remove,1,0,0,null,1
+git2r,note_remove,2,0,0,null,1
+git2r,notes,-1,0,0,list<any>,1
+git2r,notes,0,0,0,class<`git_repository`>,1
+git2r,notes,1,0,0,character,1
+git2r,notes,1,0,1,null,1
+git2r,odb_blobs,-1,0,0,class<`data.frame`>,1
+git2r,odb_blobs,0,0,0,class<`git_repository`>,1
+git2r,odb_objects,-1,0,0,class<`data.frame`>,1
+git2r,odb_objects,0,0,0,class<`git_repository`>,1
+git2r,parents,-1,0,0,list<any>,1
+git2r,parents,0,0,0,class<`git_commit`>,1
+git2r,plot.git_repository,-1,0,0,class<`matrix`>,1
+git2r,plot.git_repository,0,0,0,class<`git_repository`>,1
+git2r,plot.git_repository,1,0,0,character[],1
+git2r,plot.git_repository,2,0,0,null,1
+git2r,plot.git_repository,3,0,0,...,1
+git2r,previous_branch_name,-1,0,0,character,1
+git2r,previous_branch_name,0,0,0,class<`git_repository`>,1
+git2r,print.git_blob,-1,0,0,class<`git_blob`>,1
+git2r,print.git_blob,-1,0,1,class<`git_commit`>,1
+git2r,print.git_blob,-1,0,2,class<`git_merge_result`>,1
+git2r,print.git_blob,-1,0,3,class<`git_note`>,1
+git2r,print.git_blob,-1,0,4,class<`git_reference`>,1
+git2r,print.git_blob,-1,0,5,class<`git_signature`>,1
+git2r,print.git_blob,-1,0,6,"class<`git_commit`, `git_stash`>",1
+git2r,print.git_blob,-1,0,7,class<`git_tag`>,1
+git2r,print.git_blob,0,0,0,class<`git_blob`>,1
+git2r,print.git_blob,0,0,1,class<`git_commit`>,1
+git2r,print.git_blob,0,0,2,class<`git_merge_result`>,1
+git2r,print.git_blob,0,0,3,class<`git_note`>,1
+git2r,print.git_blob,0,0,4,class<`git_reference`>,1
+git2r,print.git_blob,0,0,5,class<`git_signature`>,1
+git2r,print.git_blob,0,0,6,"class<`git_commit`, `git_stash`>",1
+git2r,print.git_blob,0,0,7,class<`git_tag`>,1
+git2r,print.git_blob,1,0,0,...,1
+git2r,print.git_branch,-1,0,0,class<`git_branch`>,1
+git2r,print.git_branch,0,0,0,class<`git_branch`>,1
+git2r,print.git_branch,1,0,0,...,1
+git2r,print.git_commit,-1,0,0,class<`git_blob`>,1
+git2r,print.git_commit,-1,0,1,class<`git_commit`>,1
+git2r,print.git_commit,-1,0,2,class<`git_merge_result`>,1
+git2r,print.git_commit,-1,0,3,class<`git_note`>,1
+git2r,print.git_commit,-1,0,4,class<`git_reference`>,1
+git2r,print.git_commit,-1,0,5,class<`git_signature`>,1
+git2r,print.git_commit,-1,0,6,"class<`git_commit`, `git_stash`>",1
+git2r,print.git_commit,-1,0,7,class<`git_tag`>,1
+git2r,print.git_commit,0,0,0,class<`git_blob`>,1
+git2r,print.git_commit,0,0,1,class<`git_commit`>,1
+git2r,print.git_commit,0,0,2,class<`git_merge_result`>,1
+git2r,print.git_commit,0,0,3,class<`git_note`>,1
+git2r,print.git_commit,0,0,4,class<`git_reference`>,1
+git2r,print.git_commit,0,0,5,class<`git_signature`>,1
+git2r,print.git_commit,0,0,6,"class<`git_commit`, `git_stash`>",1
+git2r,print.git_commit,0,0,7,class<`git_tag`>,1
+git2r,print.git_commit,1,0,0,...,1
+git2r,print.git_config,-1,0,0,class<`git_config`>,1
+git2r,print.git_config,0,0,0,class<`git_config`>,1
+git2r,print.git_config,1,0,0,...,1
+git2r,print.git_diff,-1,0,0,class<`git_diff`>,1
+git2r,print.git_diff,0,0,0,class<`git_diff`>,1
+git2r,print.git_diff,1,0,0,...,1
+git2r,print.git_merge_result,-1,0,0,class<`git_blob`>,1
+git2r,print.git_merge_result,-1,0,1,class<`git_commit`>,1
+git2r,print.git_merge_result,-1,0,2,class<`git_merge_result`>,1
+git2r,print.git_merge_result,-1,0,3,class<`git_note`>,1
+git2r,print.git_merge_result,-1,0,4,class<`git_reference`>,1
+git2r,print.git_merge_result,-1,0,5,class<`git_signature`>,1
+git2r,print.git_merge_result,-1,0,6,"class<`git_commit`, `git_stash`>",1
+git2r,print.git_merge_result,-1,0,7,class<`git_tag`>,1
+git2r,print.git_merge_result,0,0,0,class<`git_blob`>,1
+git2r,print.git_merge_result,0,0,1,class<`git_commit`>,1
+git2r,print.git_merge_result,0,0,2,class<`git_merge_result`>,1
+git2r,print.git_merge_result,0,0,3,class<`git_note`>,1
+git2r,print.git_merge_result,0,0,4,class<`git_reference`>,1
+git2r,print.git_merge_result,0,0,5,class<`git_signature`>,1
+git2r,print.git_merge_result,0,0,6,"class<`git_commit`, `git_stash`>",1
+git2r,print.git_merge_result,0,0,7,class<`git_tag`>,1
+git2r,print.git_merge_result,1,0,0,...,1
+git2r,print.git_note,-1,0,0,class<`git_blob`>,1
+git2r,print.git_note,-1,0,1,class<`git_commit`>,1
+git2r,print.git_note,-1,0,2,class<`git_merge_result`>,1
+git2r,print.git_note,-1,0,3,class<`git_note`>,1
+git2r,print.git_note,-1,0,4,class<`git_reference`>,1
+git2r,print.git_note,-1,0,5,class<`git_signature`>,1
+git2r,print.git_note,-1,0,6,"class<`git_commit`, `git_stash`>",1
+git2r,print.git_note,-1,0,7,class<`git_tag`>,1
+git2r,print.git_note,0,0,0,class<`git_blob`>,1
+git2r,print.git_note,0,0,1,class<`git_commit`>,1
+git2r,print.git_note,0,0,2,class<`git_merge_result`>,1
+git2r,print.git_note,0,0,3,class<`git_note`>,1
+git2r,print.git_note,0,0,4,class<`git_reference`>,1
+git2r,print.git_note,0,0,5,class<`git_signature`>,1
+git2r,print.git_note,0,0,6,"class<`git_commit`, `git_stash`>",1
+git2r,print.git_note,0,0,7,class<`git_tag`>,1
+git2r,print.git_note,1,0,0,...,1
+git2r,print.git_reference,-1,0,0,class<`git_blob`>,1
+git2r,print.git_reference,-1,0,1,class<`git_commit`>,1
+git2r,print.git_reference,-1,0,2,class<`git_merge_result`>,1
+git2r,print.git_reference,-1,0,3,class<`git_note`>,1
+git2r,print.git_reference,-1,0,4,class<`git_reference`>,1
+git2r,print.git_reference,-1,0,5,class<`git_signature`>,1
+git2r,print.git_reference,-1,0,6,"class<`git_commit`, `git_stash`>",1
+git2r,print.git_reference,-1,0,7,class<`git_tag`>,1
+git2r,print.git_reference,0,0,0,class<`git_blob`>,1
+git2r,print.git_reference,0,0,1,class<`git_commit`>,1
+git2r,print.git_reference,0,0,2,class<`git_merge_result`>,1
+git2r,print.git_reference,0,0,3,class<`git_note`>,1
+git2r,print.git_reference,0,0,4,class<`git_reference`>,1
+git2r,print.git_reference,0,0,5,class<`git_signature`>,1
+git2r,print.git_reference,0,0,6,"class<`git_commit`, `git_stash`>",1
+git2r,print.git_reference,0,0,7,class<`git_tag`>,1
+git2r,print.git_reference,1,0,0,...,1
+git2r,print.git_reflog,-1,0,0,class<`git_reflog`>,1
+git2r,print.git_reflog,0,0,0,class<`git_reflog`>,1
+git2r,print.git_reflog,1,0,0,...,1
+git2r,print.git_reflog_entry,-1,0,0,class<`git_reflog_entry`>,1
+git2r,print.git_reflog_entry,0,0,0,class<`git_reflog_entry`>,1
+git2r,print.git_reflog_entry,1,0,0,...,1
+git2r,print.git_repository,-1,0,0,class<`git_repository`>,1
+git2r,print.git_repository,0,0,0,class<`git_repository`>,1
+git2r,print.git_repository,1,0,0,...,1
+git2r,print.git_signature,-1,0,0,class<`git_blob`>,1
+git2r,print.git_signature,-1,0,1,class<`git_commit`>,1
+git2r,print.git_signature,-1,0,2,class<`git_merge_result`>,1
+git2r,print.git_signature,-1,0,3,class<`git_note`>,1
+git2r,print.git_signature,-1,0,4,class<`git_reference`>,1
+git2r,print.git_signature,-1,0,5,class<`git_signature`>,1
+git2r,print.git_signature,-1,0,6,"class<`git_commit`, `git_stash`>",1
+git2r,print.git_signature,-1,0,7,class<`git_tag`>,1
+git2r,print.git_signature,0,0,0,class<`git_blob`>,1
+git2r,print.git_signature,0,0,1,class<`git_commit`>,1
+git2r,print.git_signature,0,0,2,class<`git_merge_result`>,1
+git2r,print.git_signature,0,0,3,class<`git_note`>,1
+git2r,print.git_signature,0,0,4,class<`git_reference`>,1
+git2r,print.git_signature,0,0,5,class<`git_signature`>,1
+git2r,print.git_signature,0,0,6,"class<`git_commit`, `git_stash`>",1
+git2r,print.git_signature,0,0,7,class<`git_tag`>,1
+git2r,print.git_signature,1,0,0,...,1
+git2r,print.git_stash,-1,0,0,class<`git_blob`>,1
+git2r,print.git_stash,-1,0,1,class<`git_commit`>,1
+git2r,print.git_stash,-1,0,2,class<`git_merge_result`>,1
+git2r,print.git_stash,-1,0,3,class<`git_note`>,1
+git2r,print.git_stash,-1,0,4,class<`git_reference`>,1
+git2r,print.git_stash,-1,0,5,class<`git_signature`>,1
+git2r,print.git_stash,-1,0,6,"class<`git_commit`, `git_stash`>",1
+git2r,print.git_stash,-1,0,7,class<`git_tag`>,1
+git2r,print.git_stash,0,0,0,class<`git_blob`>,1
+git2r,print.git_stash,0,0,1,class<`git_commit`>,1
+git2r,print.git_stash,0,0,2,class<`git_merge_result`>,1
+git2r,print.git_stash,0,0,3,class<`git_note`>,1
+git2r,print.git_stash,0,0,4,class<`git_reference`>,1
+git2r,print.git_stash,0,0,5,class<`git_signature`>,1
+git2r,print.git_stash,0,0,6,"class<`git_commit`, `git_stash`>",1
+git2r,print.git_stash,0,0,7,class<`git_tag`>,1
+git2r,print.git_stash,1,0,0,...,1
+git2r,print.git_status,-1,0,0,class<`git_status`>,1
+git2r,print.git_status,0,0,0,class<`git_status`>,1
+git2r,print.git_status,1,0,0,...,1
+git2r,print.git_tag,-1,0,0,class<`git_blob`>,1
+git2r,print.git_tag,-1,0,1,class<`git_commit`>,1
+git2r,print.git_tag,-1,0,2,class<`git_merge_result`>,1
+git2r,print.git_tag,-1,0,3,class<`git_note`>,1
+git2r,print.git_tag,-1,0,4,class<`git_reference`>,1
+git2r,print.git_tag,-1,0,5,class<`git_signature`>,1
+git2r,print.git_tag,-1,0,6,"class<`git_commit`, `git_stash`>",1
+git2r,print.git_tag,-1,0,7,class<`git_tag`>,1
+git2r,print.git_tag,0,0,0,class<`git_blob`>,1
+git2r,print.git_tag,0,0,1,class<`git_commit`>,1
+git2r,print.git_tag,0,0,2,class<`git_merge_result`>,1
+git2r,print.git_tag,0,0,3,class<`git_note`>,1
+git2r,print.git_tag,0,0,4,class<`git_reference`>,1
+git2r,print.git_tag,0,0,5,class<`git_signature`>,1
+git2r,print.git_tag,0,0,6,"class<`git_commit`, `git_stash`>",1
+git2r,print.git_tag,0,0,7,class<`git_tag`>,1
+git2r,print.git_tag,1,0,0,...,1
+git2r,print.git_time,-1,0,0,class<`git_time`>,1
+git2r,print.git_time,0,0,0,class<`git_time`>,1
+git2r,print.git_time,1,0,0,...,1
+git2r,print.git_tree,-1,0,0,class<`git_tree`>,1
+git2r,print.git_tree,0,0,0,class<`git_tree`>,1
+git2r,print.git_tree,1,0,0,...,1
+git2r,print_lines_per_file,-1,0,0,character,1
+git2r,print_lines_per_file,0,0,0,class<`git_diff`>,1
+git2r,pull,-1,0,0,any,1
+git2r,pull,0,0,0,class<`git_repository`>,1
+git2r,pull,1,0,0,null,1
+git2r,pull,2,0,0,null,1
+git2r,punch_card,-1,0,0,null,1
+git2r,punch_card,0,0,0,class<`git_repository`>,1
+git2r,punch_card,1,0,0,null,1
+git2r,punch_card,2,0,0,...,1
+git2r,push,-1,0,0,any,1
+git2r,push,0,0,0,class<`git_branch`>,1
+git2r,push,0,0,1,class<`git_repository`>,1
+git2r,push,1,0,0,null,1
+git2r,push,1,0,1,character[],1
+git2r,push,2,0,0,null,1
+git2r,push,2,0,1,^character[],1
+git2r,push,3,0,0,logical,1
+git2r,push,4,0,0,null,1
+git2r,push,5,0,0,logical,1
+git2r,references,-1,0,0,list<any>,1
+git2r,references,0,0,0,class<`git_repository`>,1
+git2r,references,0,0,1,character,1
+git2r,reflog,-1,0,0,class<`git_reflog`>,1
+git2r,reflog,0,0,0,class<`git_repository`>,1
+git2r,reflog,1,0,0,character,1
+git2r,remote_add,-1,0,0,null,1
+git2r,remote_add,0,0,0,class<`git_repository`>,1
+git2r,remote_add,1,0,0,character,1
+git2r,remote_add,2,0,0,character,1
+git2r,remote_ls,-1,0,0,any,1
+git2r,remote_ls,0,0,0,character,1
+git2r,remote_ls,1,0,0,null,1
+git2r,remote_ls,2,0,0,null,1
+git2r,remote_remove,-1,0,0,null,1
+git2r,remote_remove,0,0,0,class<`git_repository`>,1
+git2r,remote_remove,1,0,0,character,1
+git2r,remote_rename,-1,0,0,null,1
+git2r,remote_rename,0,0,0,class<`git_repository`>,1
+git2r,remote_rename,1,0,0,character,1
+git2r,remote_rename,2,0,0,character,1
+git2r,remotes,-1,0,0,character[],1
+git2r,remotes,0,0,0,class<`git_repository`>,1
+git2r,remote_set_url,-1,0,0,null,1
+git2r,remote_set_url,0,0,0,class<`git_repository`>,1
+git2r,remote_set_url,1,0,0,character,1
+git2r,remote_set_url,2,0,0,character,1
+git2r,remote_url,-1,0,0,character,1
+git2r,remote_url,0,0,0,class<`git_repository`>,1
+git2r,remote_url,1,0,0,character,1
+git2r,remote_url,1,0,1,null,1
+git2r,repository,-1,0,0,any,1
+git2r,repository,0,0,0,character,1
+git2r,repository,1,0,0,logical,1
+git2r,repository_head,-1,0,0,class<`git_branch`>,1
+git2r,repository_head,-1,0,1,class<`git_commit`>,1
+git2r,repository_head,-1,0,2,null,1
+git2r,repository_head,0,0,0,class<`git_repository`>,1
+git2r,reset,-1,0,0,null,1
+git2r,reset,0,0,0,class<`git_commit`>,1
+git2r,reset,0,0,1,class<`git_repository`>,1
+git2r,reset,1,0,0,any,1
+git2r,reset,2,0,0,null,1
+git2r,reset,2,0,1,character,1
+git2r,revparse_single,-1,0,0,any,1
+git2r,revparse_single,0,0,0,class<`git_repository`>,1
+git2r,revparse_single,1,0,0,character,1
+git2r,rm_file,-1,0,0,any,1
+git2r,rm_file,0,0,0,class<`git_repository`>,1
+git2r,rm_file,1,0,0,character[],1
+git2r,sanitize_path,-1,0,0,character,1
+git2r,sanitize_path,0,0,0,character,1
+git2r,sanitize_path,1,0,0,character,1
+git2r,sha,-1,0,0,character,1
+git2r,sha,-1,0,1,null,1
+git2r,sha,0,0,0,class<`git_blob`>,1
+git2r,sha,0,0,1,class<`git_branch`>,1
+git2r,sha,0,0,2,class<`git_commit`>,1
+git2r,sha,0,0,3,class<`git_fetch_head`>,1
+git2r,sha,0,0,4,class<`git_merge_result`>,1
+git2r,sha,0,0,5,class<`git_note`>,1
+git2r,sha,0,0,6,class<`git_reference`>,1
+git2r,sha,0,0,7,class<`git_reflog_entry`>,1
+git2r,sha,0,0,8,class<`git_tag`>,1
+git2r,sha,0,0,9,class<`git_tree`>,1
+git2r,sha.git_blob,-1,0,0,character,1
+git2r,sha.git_blob,-1,0,1,null,1
+git2r,sha.git_blob,0,0,0,class<`git_blob`>,1
+git2r,sha.git_blob,0,0,1,class<`git_commit`>,1
+git2r,sha.git_blob,0,0,2,class<`git_fetch_head`>,1
+git2r,sha.git_blob,0,0,3,class<`git_merge_result`>,1
+git2r,sha.git_blob,0,0,4,class<`git_note`>,1
+git2r,sha.git_blob,0,0,5,class<`git_reference`>,1
+git2r,sha.git_blob,0,0,6,class<`git_reflog_entry`>,1
+git2r,sha.git_blob,0,0,7,class<`git_tag`>,1
+git2r,sha.git_blob,0,0,8,class<`git_tree`>,1
+git2r,sha.git_branch,-1,0,0,character,1
+git2r,sha.git_branch,0,0,0,class<`git_branch`>,1
+git2r,sha.git_commit,-1,0,0,character,1
+git2r,sha.git_commit,-1,0,1,null,1
+git2r,sha.git_commit,0,0,0,class<`git_blob`>,1
+git2r,sha.git_commit,0,0,1,class<`git_commit`>,1
+git2r,sha.git_commit,0,0,2,class<`git_fetch_head`>,1
+git2r,sha.git_commit,0,0,3,class<`git_merge_result`>,1
+git2r,sha.git_commit,0,0,4,class<`git_note`>,1
+git2r,sha.git_commit,0,0,5,class<`git_reference`>,1
+git2r,sha.git_commit,0,0,6,class<`git_reflog_entry`>,1
+git2r,sha.git_commit,0,0,7,class<`git_tag`>,1
+git2r,sha.git_commit,0,0,8,class<`git_tree`>,1
+git2r,sha.git_fetch_head,-1,0,0,character,1
+git2r,sha.git_fetch_head,-1,0,1,null,1
+git2r,sha.git_fetch_head,0,0,0,class<`git_blob`>,1
+git2r,sha.git_fetch_head,0,0,1,class<`git_commit`>,1
+git2r,sha.git_fetch_head,0,0,2,class<`git_fetch_head`>,1
+git2r,sha.git_fetch_head,0,0,3,class<`git_merge_result`>,1
+git2r,sha.git_fetch_head,0,0,4,class<`git_note`>,1
+git2r,sha.git_fetch_head,0,0,5,class<`git_reference`>,1
+git2r,sha.git_fetch_head,0,0,6,class<`git_reflog_entry`>,1
+git2r,sha.git_fetch_head,0,0,7,class<`git_tag`>,1
+git2r,sha.git_fetch_head,0,0,8,class<`git_tree`>,1
+git2r,sha.git_merge_result,-1,0,0,character,1
+git2r,sha.git_merge_result,-1,0,1,null,1
+git2r,sha.git_merge_result,0,0,0,class<`git_blob`>,1
+git2r,sha.git_merge_result,0,0,1,class<`git_commit`>,1
+git2r,sha.git_merge_result,0,0,2,class<`git_fetch_head`>,1
+git2r,sha.git_merge_result,0,0,3,class<`git_merge_result`>,1
+git2r,sha.git_merge_result,0,0,4,class<`git_note`>,1
+git2r,sha.git_merge_result,0,0,5,class<`git_reference`>,1
+git2r,sha.git_merge_result,0,0,6,class<`git_reflog_entry`>,1
+git2r,sha.git_merge_result,0,0,7,class<`git_tag`>,1
+git2r,sha.git_merge_result,0,0,8,class<`git_tree`>,1
+git2r,sha.git_note,-1,0,0,character,1
+git2r,sha.git_note,-1,0,1,null,1
+git2r,sha.git_note,0,0,0,class<`git_blob`>,1
+git2r,sha.git_note,0,0,1,class<`git_commit`>,1
+git2r,sha.git_note,0,0,2,class<`git_fetch_head`>,1
+git2r,sha.git_note,0,0,3,class<`git_merge_result`>,1
+git2r,sha.git_note,0,0,4,class<`git_note`>,1
+git2r,sha.git_note,0,0,5,class<`git_reference`>,1
+git2r,sha.git_note,0,0,6,class<`git_reflog_entry`>,1
+git2r,sha.git_note,0,0,7,class<`git_tag`>,1
+git2r,sha.git_note,0,0,8,class<`git_tree`>,1
+git2r,sha.git_reference,-1,0,0,character,1
+git2r,sha.git_reference,-1,0,1,null,1
+git2r,sha.git_reference,0,0,0,class<`git_blob`>,1
+git2r,sha.git_reference,0,0,1,class<`git_commit`>,1
+git2r,sha.git_reference,0,0,2,class<`git_fetch_head`>,1
+git2r,sha.git_reference,0,0,3,class<`git_merge_result`>,1
+git2r,sha.git_reference,0,0,4,class<`git_note`>,1
+git2r,sha.git_reference,0,0,5,class<`git_reference`>,1
+git2r,sha.git_reference,0,0,6,class<`git_reflog_entry`>,1
+git2r,sha.git_reference,0,0,7,class<`git_tag`>,1
+git2r,sha.git_reference,0,0,8,class<`git_tree`>,1
+git2r,sha.git_reflog_entry,-1,0,0,character,1
+git2r,sha.git_reflog_entry,-1,0,1,null,1
+git2r,sha.git_reflog_entry,0,0,0,class<`git_blob`>,1
+git2r,sha.git_reflog_entry,0,0,1,class<`git_commit`>,1
+git2r,sha.git_reflog_entry,0,0,2,class<`git_fetch_head`>,1
+git2r,sha.git_reflog_entry,0,0,3,class<`git_merge_result`>,1
+git2r,sha.git_reflog_entry,0,0,4,class<`git_note`>,1
+git2r,sha.git_reflog_entry,0,0,5,class<`git_reference`>,1
+git2r,sha.git_reflog_entry,0,0,6,class<`git_reflog_entry`>,1
+git2r,sha.git_reflog_entry,0,0,7,class<`git_tag`>,1
+git2r,sha.git_reflog_entry,0,0,8,class<`git_tree`>,1
+git2r,sha.git_tag,-1,0,0,character,1
+git2r,sha.git_tag,-1,0,1,null,1
+git2r,sha.git_tag,0,0,0,class<`git_blob`>,1
+git2r,sha.git_tag,0,0,1,class<`git_commit`>,1
+git2r,sha.git_tag,0,0,2,class<`git_fetch_head`>,1
+git2r,sha.git_tag,0,0,3,class<`git_merge_result`>,1
+git2r,sha.git_tag,0,0,4,class<`git_note`>,1
+git2r,sha.git_tag,0,0,5,class<`git_reference`>,1
+git2r,sha.git_tag,0,0,6,class<`git_reflog_entry`>,1
+git2r,sha.git_tag,0,0,7,class<`git_tag`>,1
+git2r,sha.git_tag,0,0,8,class<`git_tree`>,1
+git2r,sha.git_tree,-1,0,0,character,1
+git2r,sha.git_tree,-1,0,1,null,1
+git2r,sha.git_tree,0,0,0,class<`git_blob`>,1
+git2r,sha.git_tree,0,0,1,class<`git_commit`>,1
+git2r,sha.git_tree,0,0,2,class<`git_fetch_head`>,1
+git2r,sha.git_tree,0,0,3,class<`git_merge_result`>,1
+git2r,sha.git_tree,0,0,4,class<`git_note`>,1
+git2r,sha.git_tree,0,0,5,class<`git_reference`>,1
+git2r,sha.git_tree,0,0,6,class<`git_reflog_entry`>,1
+git2r,sha.git_tree,0,0,7,class<`git_tag`>,1
+git2r,sha.git_tree,0,0,8,class<`git_tree`>,1
+git2r,ssh_path,-1,0,0,character,1
+git2r,ssh_path,0,0,0,character,1
+git2r,ssl_cert_locations,-1,0,0,any,1
+git2r,ssl_cert_locations,0,0,0,null,1
+git2r,ssl_cert_locations,1,0,0,null,1
+git2r,stash,-1,0,0,"class<`git_commit`, `git_stash`>",1
+git2r,stash,-1,0,1,null,1
+git2r,stash,0,0,0,class<`git_repository`>,1
+git2r,stash,1,0,0,character,1
+git2r,stash,2,0,0,logical,1
+git2r,stash,3,0,0,logical,1
+git2r,stash,4,0,0,logical,1
+git2r,stash,5,0,0,null,1
+git2r,stash_apply,-1,0,0,null,1
+git2r,stash_apply,0,0,0,class<`git_repository`>,1
+git2r,stash_apply,1,0,0,double,1
+git2r,stash_drop,-1,0,0,any,1
+git2r,stash_drop,0,0,0,class<`git_repository`>,1
+git2r,stash_drop,0,0,1,"class<`git_commit`, `git_stash`>",1
+git2r,stash_drop,1,0,0,double,1
+git2r,stash_index,-1,0,0,any,1
+git2r,stash_index,0,0,0,"class<`git_commit`, `git_stash`>",1
+git2r,stash_index,0,0,1,class<`git_repository`>,1
+git2r,stash_index,1,0,0,any,1
+git2r,stash_list,-1,0,0,list<any>,1
+git2r,stash_list,0,0,0,class<`git_repository`>,1
+git2r,stash_list,0,0,1,character,1
+git2r,stash_object,-1,0,0,class<`git_repository`>,1
+git2r,stash_object,0,0,0,"class<`git_commit`, `git_stash`>",1
+git2r,stash_object,0,0,1,class<`git_repository`>,1
+git2r,stash_pop,-1,0,0,null,1
+git2r,stash_pop,0,0,0,class<`git_repository`>,1
+git2r,stash_pop,1,0,0,double,1
+git2r,status,-1,0,0,class<`git_status`>,1
+git2r,status,0,0,0,class<`git_repository`>,1
+git2r,status,1,0,0,logical,1
+git2r,status,2,0,0,logical,1
+git2r,status,3,0,0,logical,1
+git2r,status,4,0,0,logical,1
+git2r,status,5,0,0,logical,1
+git2r,strip_trailing_slash,-1,0,0,character,1
+git2r,strip_trailing_slash,-1,0,1,null,1
+git2r,strip_trailing_slash,0,0,0,character,1
+git2r,strip_trailing_slash,0,0,1,null,1
+git2r,summary.git_commit,-1,0,0,null,1
+git2r,summary.git_commit,0,0,0,class<`git_commit`>,1
+git2r,summary.git_commit,1,0,0,...,1
+git2r,summary.git_diff,-1,0,0,null,1
+git2r,summary.git_diff,0,0,0,class<`git_diff`>,1
+git2r,summary.git_diff,1,0,0,...,1
+git2r,summary.git_repository,-1,0,0,null,1
+git2r,summary.git_repository,0,0,0,class<`git_repository`>,1
+git2r,summary.git_repository,1,0,0,...,1
+git2r,summary.git_stash,-1,0,0,null,1
+git2r,summary.git_stash,0,0,0,"class<`git_commit`, `git_stash`>",1
+git2r,summary.git_stash,1,0,0,...,1
+git2r,summary.git_tag,-1,0,0,null,1
+git2r,summary.git_tag,0,0,0,class<`git_tag`>,1
+git2r,summary.git_tag,1,0,0,...,1
+git2r,summary.git_tree,-1,0,0,class<`data.frame`>,1
+git2r,summary.git_tree,0,0,0,class<`git_tree`>,1
+git2r,summary.git_tree,1,0,0,...,1
+git2r,tag,-1,0,0,class<`git_tag`>,1
+git2r,tag,0,0,0,class<`git_repository`>,1
+git2r,tag,1,0,0,character,1
+git2r,tag,2,0,0,character,1
+git2r,tag,3,0,0,logical,1
+git2r,tag,4,0,0,null,1
+git2r,tag,5,0,0,logical,1
+git2r,tag_delete,-1,0,0,null,1
+git2r,tag_delete,0,0,0,character,1
+git2r,tag_delete,0,0,1,class<`git_tag`>,1
+git2r,tag_delete,1,0,0,character,1
+git2r,tag_delete,1,0,1,null,1
+git2r,tags,-1,0,0,list<any>,1
+git2r,tags,0,0,0,character,1
+git2r,tags,0,0,1,class<`git_repository`>,1
+git2r,tree,-1,0,0,class<`git_tree`>,1
+git2r,tree,0,0,0,class<`git_commit`>,1
+git2r,tree,0,0,1,"class<`git_commit`, `git_stash`>",1
+git2r,when,-1,0,0,character,1
+git2r,when,0,0,0,class<`git_commit`>,1
+git2r,when,0,0,1,class<`git_signature`>,1
+git2r,when,0,0,2,class<`git_tag`>,1
+git2r,when,0,0,3,class<`git_time`>,1
+git2r,workdir,-1,0,0,character,1
+git2r,workdir,-1,0,1,null,1
+git2r,workdir,0,0,0,character,1
+git2r,workdir,0,0,1,class<`git_repository`>,1
+glasso,glasso,-1,0,0,list<class<`matrix`> | null | double>,1
+glasso,glasso,0,0,0,class<`matrix`>,1
+glasso,glasso,1,0,0,double,1
+glasso,glasso,2,0,0,null,1
+glasso,glasso,3,0,0,class<`matrix`>,1
+glasso,glasso,3,0,1,null,1
+glasso,glasso,4,0,0,double,1
+glasso,glasso,5,0,0,double,1
+glasso,glasso,6,0,0,logical,1
+glasso,glasso,7,0,0,logical,1
+glasso,glasso,8,0,0,character[],1
+glasso,glasso,9,0,0,any,1
+glasso,glasso,10,0,0,any,1
+glasso,glasso,11,0,0,logical,1
+glasso,glassopath,-1,0,0,list<class<`array`> | double[]>,1
+glasso,glassopath,0,0,0,class<`matrix`>,1
+glasso,glassopath,1,0,0,null,1
+glasso,glassopath,2,0,0,double,1
+glasso,glassopath,3,0,0,double,1
+glasso,glassopath,4,0,0,logical,1
+glasso,glassopath,5,0,0,logical,1
+glasso,glassopath,6,0,0,null,1
+glasso,glassopath,7,0,0,null,1
+glasso,glassopath,8,0,0,double,1
+glm2,glm2,-1,0,0,"class<`glm`, `lm`>",1
+glm2,glm2,0,0,0,class<`formula`>,1
+glm2,glm2,1,0,0,class<`family`>,1
+glm2,glm2,2,0,0,any,1
+glm2,glm2,3,0,0,any,1
+glm2,glm2,4,0,0,any,1
+glm2,glm2,5,0,0,any,1
+glm2,glm2,6,0,0,double[],1
+glm2,glm2,6,0,1,null,1
+glm2,glm2,7,0,0,any,1
+glm2,glm2,8,0,0,any,1
+glm2,glm2,9,0,0,any,1
+glm2,glm2,10,0,0,list<any>,1
+glm2,glm2,11,0,0,logical,1
+glm2,glm2,12,0,0,character,1
+glm2,glm2,13,0,0,logical,1
+glm2,glm2,14,0,0,logical,1
+glm2,glm2,15,0,0,logical,1
+glm2,glm2,16,0,0,null,1
+glm2,glm2,17,0,0,...,1
+glm2,glm.fit2,-1,0,0,list<any>,1
+glm2,glm.fit2,0,0,0,double[],1
+glm2,glm.fit2,0,0,1,class<`matrix`>,1
+glm2,glm.fit2,1,0,0,double[],1
+glm2,glm.fit2,1,0,1,class<`matrix`>,1
+glm2,glm.fit2,2,0,0,double[],1
+glm2,glm.fit2,2,0,1,null,1
+glm2,glm.fit2,3,0,0,double[],1
+glm2,glm.fit2,3,0,1,null,1
+glm2,glm.fit2,4,0,0,null,1
+glm2,glm.fit2,5,0,0,null,1
+glm2,glm.fit2,6,0,0,double[],1
+glm2,glm.fit2,6,0,1,null,1
+glm2,glm.fit2,7,0,0,class<`family`>,1
+glm2,glm.fit2,8,0,0,list<any>,1
+glm2,glm.fit2,9,0,0,logical,1
+glm2,glm.fit2,10,0,0,logical,1
+globals,as_function,-1,0,0,class<`function`>,1
+globals,as_function,0,0,0,class<`{`>,1
+globals,as_function,1,0,0,environment,1
+globals,as_function,2,0,0,environment,1
+globals,as_function,3,0,0,...,1
+globals,findGlobals,-1,0,0,character[],1
+globals,findGlobals,0,0,0,class<`{`>,1
+globals,findGlobals,1,0,0,environment,1
+globals,findGlobals,2,0,0,...,1
+globals,findGlobals,3,0,0,null,1
+globals,findGlobals,4,0,0,character[],1
+globals,findGlobals,5,0,0,character,1
+globals,findGlobals,6,0,0,logical,1
+globals,findGlobals,7,0,0,any,1
+globals,findGlobals,8,0,0,logical,1
+globals,getOption,-1,0,0,logical,1
+globals,getOption,0,0,0,character,1
+globals,getOption,1,0,0,logical,1
+globals,[.Globals,-1,0,0,"class<`Globals`, `list`>",1
+globals,[.Globals,0,0,0,"class<`Globals`, `list`>",1
+globals,[.Globals,1,0,0,logical[],1
+globals,globalsByName,-1,0,0,"class<`Globals`, `list`>",1
+globals,globalsByName,0,0,0,character[],1
+globals,globalsByName,1,0,0,environment,1
+globals,globalsByName,2,0,0,any,1
+globals,globalsByName,3,0,0,...,1
+globals,globalsOf,-1,0,0,"class<`Globals`, `list`>",1
+globals,globalsOf,0,0,0,class<`{`>,1
+globals,globalsOf,1,0,0,environment,1
+globals,globalsOf,2,0,0,...,1
+globals,globalsOf,3,0,0,character,1
+globals,globalsOf,4,0,0,null,1
+globals,globalsOf,5,0,0,logical,1
+globals,globalsOf,6,0,0,logical,1
+globals,globalsOf,7,0,0,logical,1
+globals,globalsOf,8,0,0,logical,1
+globals,globalsOf,9,0,0,null,1
+globals,is_base_pkg,-1,0,0,logical[],1
+globals,is_base_pkg,0,0,0,character[],1
+globals,mdebug,-1,0,0,logical,1
+globals,mdebug,0,0,0,...,1
+globals,stop_if_not,-1,0,0,null,1
+globals,stop_if_not,0,0,0,...,1
+globals,where,-1,0,0,environment,1
+globals,where,0,0,0,character,1
+globals,where,1,0,0,any,1
+globals,where,2,0,0,environment,1
+globals,where,3,0,0,any,1
+globals,where,4,0,0,character,1
+globals,where,5,0,0,logical,1
+glue,as.character.glue,-1,0,0,character,1
+glue,as.character.glue,0,0,0,"class<`character`, `glue`>",1
+glue,as.character.glue,1,0,0,...,1
+glue,as_glue,-1,0,0,"class<`character`, `glue`>",1
+glue,as_glue,0,0,0,character[],1
+glue,as_glue,1,0,0,...,1
+glue,as_glue.character,-1,0,0,"class<`character`, `glue`>",1
+glue,as_glue.character,0,0,0,character[],1
+glue,as_glue.character,1,0,0,...,1
+glue,backtick,-1,0,0,character[],1
+glue,backtick,0,0,0,integer[],1
+glue,bind_args,-1,0,0,environment,1
+glue,bind_args,0,0,0,list<any>,1
+glue,bind_args,1,0,0,environment,1
+glue,delayed_assign,-1,0,0,null,1
+glue,delayed_assign,0,0,0,character,1
+glue,delayed_assign,1,0,0,character,1
+glue,delayed_assign,1,0,1,class<`call`>,1
+glue,delayed_assign,1,0,2,double,1
+glue,delayed_assign,2,0,0,environment,1
+glue,delayed_assign,3,0,0,environment,1
+glue,glue,-1,0,0,any,1
+glue,glue,0,0,0,...,1
+glue,glue,1,0,0,character,1
+glue,glue,2,0,0,environment,1
+glue,glue,3,0,0,character,1
+glue,glue,4,0,0,character,1
+glue,glue,5,0,0,character,1
+glue,glue,5,0,1,class<`SQL`>,1
+glue,glue,6,0,0,any,1
+glue,glue,7,0,0,logical,1
+glue,glue_col,-1,0,0,"class<`character`, `glue`>",1
+glue,glue_col,0,0,0,...,1
+glue,glue_col,1,0,0,environment,1
+glue,glue_col,2,0,0,character,1
+glue,glue_collapse,-1,0,0,"class<`character`, `glue`>",1
+glue,glue_collapse,0,0,0,character[],1
+glue,glue_collapse,0,0,1,"class<`character`, `glue`>",1
+glue,glue_collapse,0,0,2,integer[],1
+glue,glue_collapse,0,0,3,list<class<`SQL`>>,1
+glue,glue_collapse,1,0,0,character,1
+glue,glue_collapse,2,0,0,double,1
+glue,glue_collapse,3,0,0,character,1
+glue,glue_data,-1,0,0,any,1
+glue,glue_data,0,0,0,class<`data.frame`>,1
+glue,glue_data,0,0,1,null,1
+glue,glue_data,1,0,0,...,1
+glue,glue_data,2,0,0,character,1
+glue,glue_data,3,0,0,environment,1
+glue,glue_data,4,0,0,character,1
+glue,glue_data,5,0,0,character,1
+glue,glue_data,6,0,0,any,1
+glue,glue_data,7,0,0,any,1
+glue,glue_sql,-1,0,0,class<`SQL`>,1
+glue,glue_sql,0,0,0,...,1
+glue,glue_sql,1,0,0,class<`SQLiteConnection`>,1
+glue,glue_sql,2,0,0,environment,1
+glue,glue_sql,3,0,0,class<`SQL`>,1
+glue,has_names,-1,0,0,logical[],1
+glue,has_names,0,0,0,list<character>,1
+glue,has_names,0,0,1,list<character | double | class<`call`>>,1
+glue,has_names,0,0,2,list<character | class<`call`>>,1
+glue,has_names,0,0,3,list<character | double>,1
+glue,has_names,0,0,4,list<class<`name`>>,1
+glue,lengths,-1,0,0,integer[],1
+glue,lengths,0,0,0,list<character[]>,1
+glue,recycle_columns,-1,0,0,list<character[]>,1
+glue,recycle_columns,0,0,0,list<character[]>,1
+glue,register_s3_method,-1,0,0,null,1
+glue,register_s3_method,0,0,0,character,1
+glue,register_s3_method,1,0,0,character,1
+glue,register_s3_method,2,0,0,character,1
+glue,register_s3_method,3,0,0,null,1
+glue,sql_quote_transformer,-1,0,0,class<`function`>,1
+glue,sql_quote_transformer,0,0,0,any,1
+glue,trim,-1,0,0,character,1
+glue,trim,0,0,0,character,1
+gmp,%*%,-1,0,0,class<`bigq`>,1
+gmp,%*%,-1,0,1,class<`bigz`>,1
+gmp,%*%,-1,0,2,class<`matrix`>,1
+gmp,%*%,0,0,0,class<`bigq`>,1
+gmp,%*%,0,0,1,class<`bigz`>,1
+gmp,%*%,0,0,2,class<`matrix`>,1
+gmp,%*%,0,0,3,double[],1
+gmp,%*%,1,0,0,class<`bigq`>,1
+gmp,%*%,1,0,1,class<`matrix`>,1
+gmp,%*%,1,0,2,class<`bigz`>,1
+gmp,abs.bigq,-1,0,0,class<`bigq`>,1
+gmp,abs.bigq,0,0,0,class<`bigq`>,1
+gmp,abs.bigz,-1,0,0,class<`bigz`>,1
+gmp,abs.bigz,0,0,0,class<`bigz`>,1
+gmp,all.equal.bigq,-1,0,0,logical,1
+gmp,all.equal.bigq,0,0,0,class<`bigq`>,1
+gmp,all.equal.bigq,1,0,0,double[],1
+gmp,all.equal.bigq,1,0,1,class<`matrix`>,1
+gmp,all.equal.bigq,2,0,0,double,1
+gmp,all.equal.bigq,3,0,0,null,1
+gmp,all.equal.bigq,4,0,0,logical,1
+gmp,all.equal.bigq,5,0,0,logical,1
+gmp,all.equal.bigq,6,0,0,...,1
+gmp,all.equal.bigz,-1,0,0,logical,1
+gmp,all.equal.bigz,0,0,0,class<`bigz`>,1
+gmp,all.equal.bigz,1,0,0,double[],1
+gmp,all.equal.bigz,2,0,0,...,1
+gmp,apply,-1,0,0,class<`bigq`>,1
+gmp,apply,-1,0,1,class<`bigz`>,1
+gmp,apply,0,0,0,class<`bigq`>,1
+gmp,apply,0,0,1,class<`bigz`>,1
+gmp,apply,1,0,0,double,1
+gmp,apply,2,0,0,class<`function`>,1
+gmp,apply,3,0,0,...,1
+gmp,apply.bigq,-1,0,0,class<`bigq`>,1
+gmp,apply.bigq,0,0,0,class<`bigq`>,1
+gmp,apply.bigq,1,0,0,double,1
+gmp,apply.bigq,2,0,0,class<`function`>,1
+gmp,apply.bigq,3,0,0,...,1
+gmp,apply.bigz,-1,0,0,class<`bigz`>,1
+gmp,apply.bigz,0,0,0,class<`bigz`>,1
+gmp,apply.bigz,1,0,0,double,1
+gmp,apply.bigz,2,0,0,class<`function`>,1
+gmp,apply.bigz,3,0,0,...,1
+gmp,as.bigq,-1,0,0,any,1
+gmp,as.bigq,0,0,0,class<`bigz`>,1
+gmp,as.bigq,0,0,1,^double[],1
+gmp,as.bigq,0,0,2,null,1
+gmp,as.bigq,0,0,3,class<`matrix`>,1
+gmp,as.bigq,0,0,4,character,1
+gmp,as.bigq,0,0,5,class<`bigq`>,1
+gmp,as.bigq,1,0,0,class<`bigz`>,1
+gmp,as.bigq,1,0,1,character,1
+gmp,as.bigq,1,0,2,class<`bigq`>,1
+gmp,as.bigq,1,0,3,null,1
+gmp,as.bigq,1,0,4,double[],1
+gmp,as.bigz,-1,0,0,any,1
+gmp,as.bigz,0,0,0,character,1
+gmp,as.bigz,0,0,1,class<`bigq`>,1
+gmp,as.bigz,0,0,2,class<`bigz`>,1
+gmp,as.bigz,0,0,3,^double[],1
+gmp,as.bigz,0,0,4,null,1
+gmp,as.bigz,0,0,5,class<`matrix`>,1
+gmp,as.bigz,1,0,0,null,1
+gmp,as.bigz,1,0,1,^logical[],1
+gmp,as.bigz,1,0,2,character,1
+gmp,as.bigz,1,0,3,class<`bigq`>,1
+gmp,as.bigz,1,0,4,class<`bigz`>,1
+gmp,as.bigz,1,0,5,double[],1
+gmp,as.bigz.bigq,-1,0,0,any,1
+gmp,as.bigz.bigq,0,0,0,class<`bigq`>,1
+gmp,as.bigz.bigq,1,0,0,any,1
+gmp,as.character.bigq,-1,0,0,character[],1
+gmp,as.character.bigq,0,0,0,class<`bigq`>,1
+gmp,as.character.bigq,1,0,0,integer,1
+gmp,as.character.bigq,2,0,0,...,1
+gmp,as.character.bigz,-1,0,0,character[],1
+gmp,as.character.bigz,0,0,0,class<`bigz`>,1
+gmp,as.character.bigz,1,0,0,double,1
+gmp,as.character.bigz,2,0,0,...,1
+gmp,as.double.bigq,-1,0,0,^double[],1
+gmp,as.double.bigq,-1,0,1,null,1
+gmp,as.double.bigq,0,0,0,class<`bigq`>,1
+gmp,as.double.bigq,1,0,0,...,1
+gmp,as.double.bigz,-1,0,0,^double[],1
+gmp,as.double.bigz,-1,0,1,null,1
+gmp,as.double.bigz,0,0,0,class<`bigz`>,1
+gmp,as.double.bigz,1,0,0,...,1
+gmp,as.integer.bigq,-1,0,0,^integer[],1
+gmp,as.integer.bigq,0,0,0,class<`bigq`>,1
+gmp,as.integer.bigq,1,0,0,...,1
+gmp,as.integer.bigz,-1,0,0,^integer[],1
+gmp,as.integer.bigz,-1,0,1,null,1
+gmp,as.integer.bigz,0,0,0,class<`bigz`>,1
+gmp,as.integer.bigz,1,0,0,...,1
+gmp,as.matrix.bigq,-1,0,0,class<`bigq`>,1
+gmp,as.matrix.bigq,0,0,0,class<`bigq`>,1
+gmp,as.matrix.bigq,1,0,0,...,1
+gmp,as.matrix.bigz,-1,0,0,class<`bigz`>,1
+gmp,as.matrix.bigz,0,0,0,class<`bigz`>,1
+gmp,as.matrix.bigz,1,0,0,...,1
+gmp,asNumeric,-1,0,0,class<`matrix`>,1
+gmp,asNumeric,-1,0,1,^double[],1
+gmp,asNumeric,0,0,0,class<`bigq`>,1
+gmp,asNumeric,-1,1,0,class<`matrix`>,1
+gmp,asNumeric,-1,1,1,^double[],1
+gmp,asNumeric,0,1,0,class<`bigz`>,1
+gmp,asNumeric,-1,2,0,class<`matrix`>,1
+gmp,asNumeric,0,2,0,class<`matrix`>,1
+gmp,asNumeric,-1,3,0,class<`matrix`>,1
+gmp,asNumeric,-1,3,1,^double[],1
+gmp,asNumeric,0,3,0,class<`bigq`>,1
+gmp,asNumeric,0,3,1,class<`bigz`>,1
+gmp,asNumeric,0,3,2,class<`matrix`>,1
+gmp,as.vector.bigq,-1,0,0,class<`bigq`>,1
+gmp,as.vector.bigq,-1,0,1,list<class<`bigq`>>,1
+gmp,as.vector.bigq,0,0,0,class<`bigq`>,1
+gmp,as.vector.bigq,1,0,0,character,1
+gmp,as.vector.bigz,-1,0,0,class<`bigz`>,1
+gmp,as.vector.bigz,-1,0,1,list<class<`bigz`>>,1
+gmp,as.vector.bigz,0,0,0,class<`bigz`>,1
+gmp,as.vector.bigz,1,0,0,character,1
+gmp,^.bigq,-1,0,0,any,1
+gmp,^.bigq,0,0,0,any,1
+gmp,^.bigq,1,0,0,double,1
+gmp,^.bigq,1,0,1,class<`bigq`>,1
+gmp,<=.bigq,-1,0,0,class<`matrix`>,1
+gmp,<=.bigq,-1,0,1,^logical[],1
+gmp,<=.bigq,0,0,0,class<`bigq`>,1
+gmp,<=.bigq,0,0,1,double,1
+gmp,<=.bigq,0,0,2,null,1
+gmp,<=.bigq,1,0,0,class<`bigq`>,1
+gmp,<=.bigq,1,0,1,^double[],1
+gmp,<.bigq,-1,0,0,^logical[],1
+gmp,<.bigq,0,0,0,class<`bigq`>,1
+gmp,<.bigq,0,0,1,double,1
+gmp,<.bigq,0,0,2,null,1
+gmp,<.bigq,1,0,0,class<`bigq`>,1
+gmp,<.bigq,1,0,1,^double[],1
+gmp,==.bigq,-1,0,0,class<`matrix`>,1
+gmp,==.bigq,-1,0,1,^logical[],1
+gmp,==.bigq,0,0,0,class<`bigq`>,1
+gmp,==.bigq,0,0,1,class<`matrix`>,1
+gmp,==.bigq,0,0,2,^double[],1
+gmp,==.bigq,0,0,3,null,1
+gmp,==.bigq,1,0,0,class<`matrix`>,1
+gmp,==.bigq,1,0,1,class<`bigq`>,1
+gmp,==.bigq,1,0,2,^double[],1
+gmp,>=.bigq,-1,0,0,^logical[],1
+gmp,>=.bigq,0,0,0,class<`bigq`>,1
+gmp,>=.bigq,0,0,1,double,1
+gmp,>=.bigq,0,0,2,null,1
+gmp,>=.bigq,1,0,0,class<`bigq`>,1
+gmp,>=.bigq,1,0,1,^double[],1
+gmp,>.bigq,-1,0,0,^logical[],1
+gmp,>.bigq,0,0,0,class<`bigq`>,1
+gmp,>.bigq,0,0,1,double,1
+gmp,>.bigq,0,0,2,null,1
+gmp,>.bigq,1,0,0,class<`bigq`>,1
+gmp,>.bigq,1,0,1,^double[],1
+gmp,-.bigq,-1,0,0,class<`bigq`>,1
+gmp,-.bigq,0,0,0,class<`bigq`>,1
+gmp,-.bigq,0,0,1,^double[],1
+gmp,-.bigq,0,0,2,null,1
+gmp,-.bigq,1,0,0,class<`bigq`>,1
+gmp,-.bigq,1,0,1,^double[],1
+gmp,-.bigq,1,0,2,class<`matrix`>,1
+gmp,!=.bigq,-1,0,0,^logical[],1
+gmp,!=.bigq,0,0,0,class<`bigq`>,1
+gmp,!=.bigq,0,0,1,double,1
+gmp,!=.bigq,0,0,2,null,1
+gmp,!=.bigq,1,0,0,class<`bigq`>,1
+gmp,!=.bigq,1,0,1,^double[],1
+gmp,/.bigq,-1,0,0,class<`bigq`>,1
+gmp,/.bigq,0,0,0,class<`bigq`>,1
+gmp,/.bigq,0,0,1,double,1
+gmp,/.bigq,0,0,2,null,1
+gmp,/.bigq,1,0,0,class<`bigq`>,1
+gmp,/.bigq,1,0,1,^double[],1
+gmp,[<-.bigq,-1,0,0,any,1
+gmp,[<-.bigq,0,0,0,class<`bigq`>,1
+gmp,[<-.bigq,1,0,0,double,1
+gmp,[<-.bigq,1,0,1,integer[],1
+gmp,[<-.bigq,2,0,0,null,1
+gmp,[<-.bigq,2,0,1,double,1
+gmp,[<-.bigq,3,0,0,double[],1
+gmp,[<-.bigq,3,0,1,null,1
+gmp,[<-.bigq,3,0,2,list<double>,1
+gmp,[.bigq,-1,0,0,any,1
+gmp,[.bigq,0,0,0,class<`bigq`>,1
+gmp,[.bigq,1,0,0,double[],1
+gmp,[.bigq,2,0,0,null,1
+gmp,[.bigq,2,0,1,integer[],1
+gmp,[.bigq,2,0,2,double,1
+gmp,[.bigq,3,0,0,logical,1
+gmp,*.bigq,-1,0,0,class<`bigq`>,1
+gmp,*.bigq,0,0,0,class<`bigq`>,1
+gmp,*.bigq,0,0,1,double,1
+gmp,*.bigq,0,0,2,null,1
+gmp,*.bigq,1,0,0,class<`bigq`>,1
+gmp,*.bigq,1,0,1,^double[],1
+gmp,%*%.bigq,-1,0,0,class<`bigq`>,1
+gmp,%*%.bigq,0,0,0,class<`bigq`>,1
+gmp,%*%.bigq,1,0,0,class<`bigq`>,1
+gmp,%*%.bigq,1,0,1,class<`matrix`>,1
+gmp,+.bigq,-1,0,0,class<`bigq`>,1
+gmp,+.bigq,0,0,0,class<`bigq`>,1
+gmp,+.bigq,0,0,1,^double[],1
+gmp,+.bigq,0,0,2,null,1
+gmp,+.bigq,1,0,0,class<`bigq`>,1
+gmp,+.bigq,1,0,1,^double[],1
+gmp,^.bigz,-1,0,0,class<`bigq`>,1
+gmp,^.bigz,-1,0,1,class<`bigz`>,1
+gmp,^.bigz,0,0,0,class<`bigz`>,1
+gmp,^.bigz,0,0,1,double,1
+gmp,^.bigz,0,0,2,null,1
+gmp,^.bigz,0,0,3,integer[],1
+gmp,^.bigz,1,0,0,class<`bigz`>,1
+gmp,^.bigz,1,0,1,^double[],1
+gmp,^.bigz,2,0,0,...,1
+gmp,<=.bigz,-1,0,0,^logical[],1
+gmp,<=.bigz,0,0,0,class<`bigz`>,1
+gmp,<=.bigz,0,0,1,double,1
+gmp,<=.bigz,0,0,2,null,1
+gmp,<=.bigz,1,0,0,class<`bigz`>,1
+gmp,<=.bigz,1,0,1,^double[],1
+gmp,<.bigz,-1,0,0,class<`matrix`>,1
+gmp,<.bigz,-1,0,1,^logical[],1
+gmp,<.bigz,0,0,0,class<`bigz`>,1
+gmp,<.bigz,0,0,1,double,1
+gmp,<.bigz,0,0,2,null,1
+gmp,<.bigz,1,0,0,class<`bigz`>,1
+gmp,<.bigz,1,0,1,^double[],1
+gmp,==.bigz,-1,0,0,class<`matrix`>,1
+gmp,==.bigz,-1,0,1,^logical[],1
+gmp,==.bigz,0,0,0,class<`bigz`>,1
+gmp,==.bigz,0,0,1,^double[],1
+gmp,==.bigz,0,0,2,null,1
+gmp,==.bigz,1,0,0,class<`bigz`>,1
+gmp,==.bigz,1,0,1,class<`matrix`>,1
+gmp,==.bigz,1,0,2,^double[],1
+gmp,>=.bigz,-1,0,0,^logical[],1
+gmp,>=.bigz,0,0,0,class<`bigz`>,1
+gmp,>=.bigz,0,0,1,double,1
+gmp,>=.bigz,0,0,2,null,1
+gmp,>=.bigz,1,0,0,class<`bigz`>,1
+gmp,>=.bigz,1,0,1,^double[],1
+gmp,>.bigz,-1,0,0,class<`matrix`>,1
+gmp,>.bigz,-1,0,1,^logical[],1
+gmp,>.bigz,0,0,0,class<`bigz`>,1
+gmp,>.bigz,0,0,1,double,1
+gmp,>.bigz,0,0,2,null,1
+gmp,>.bigz,1,0,0,class<`bigz`>,1
+gmp,>.bigz,1,0,1,^double[],1
+gmp,-.bigz,-1,0,0,class<`bigz`>,1
+gmp,-.bigz,0,0,0,class<`bigz`>,1
+gmp,-.bigz,0,0,1,^double[],1
+gmp,-.bigz,0,0,2,null,1
+gmp,-.bigz,1,0,0,class<`bigz`>,1
+gmp,-.bigz,1,0,1,^double[],1
+gmp,!=.bigz,-1,0,0,^logical[],1
+gmp,!=.bigz,0,0,0,class<`bigz`>,1
+gmp,!=.bigz,0,0,1,double,1
+gmp,!=.bigz,0,0,2,null,1
+gmp,!=.bigz,1,0,0,class<`bigz`>,1
+gmp,!=.bigz,1,0,1,^double[],1
+gmp,/.bigz,-1,0,0,class<`bigq`>,1
+gmp,/.bigz,-1,0,1,class<`bigz`>,1
+gmp,/.bigz,0,0,0,class<`bigz`>,1
+gmp,/.bigz,0,0,1,double,1
+gmp,/.bigz,0,0,2,null,1
+gmp,/.bigz,1,0,0,class<`bigz`>,1
+gmp,/.bigz,1,0,1,^double[],1
+gmp,[<-.bigz,-1,0,0,any,1
+gmp,[<-.bigz,0,0,0,class<`bigz`>,1
+gmp,[<-.bigz,1,0,0,double,1
+gmp,[<-.bigz,1,0,1,integer[],1
+gmp,[<-.bigz,1,0,2,class<`matrix`>,1
+gmp,[<-.bigz,2,0,0,null,1
+gmp,[<-.bigz,2,0,1,double,1
+gmp,[<-.bigz,3,0,0,class<`bigz`>,1
+gmp,[<-.bigz,3,0,1,double[],1
+gmp,[<-.bigz,3,0,2,list<double>,1
+gmp,[<-.bigz,3,0,3,null,1
+gmp,[.bigz,-1,0,0,any,1
+gmp,[.bigz,0,0,0,class<`bigz`>,1
+gmp,[.bigz,1,0,0,double[],1
+gmp,[.bigz,1,0,1,^logical[],1
+gmp,[.bigz,1,0,2,null,1
+gmp,[.bigz,2,0,0,null,1
+gmp,[.bigz,2,0,1,integer[],1
+gmp,[.bigz,2,0,2,double,1
+gmp,[.bigz,3,0,0,logical,1
+gmp,[[<-.bigz,-1,0,0,class<`bigz`>,1
+gmp,[[<-.bigz,0,0,0,class<`bigz`>,1
+gmp,[[<-.bigz,1,0,0,double,1
+gmp,[[<-.bigz,2,0,0,class<`bigz`>,1
+gmp,*.bigz,-1,0,0,class<`bigz`>,1
+gmp,*.bigz,0,0,0,class<`bigz`>,1
+gmp,*.bigz,0,0,1,double,1
+gmp,*.bigz,0,0,2,null,1
+gmp,*.bigz,1,0,0,class<`bigz`>,1
+gmp,*.bigz,1,0,1,^double[],1
+gmp,%/%.bigz,-1,0,0,class<`bigz`>,1
+gmp,%/%.bigz,0,0,0,class<`bigz`>,1
+gmp,%/%.bigz,0,0,1,double,1
+gmp,%/%.bigz,0,0,2,integer[],1
+gmp,%/%.bigz,0,0,3,null,1
+gmp,%/%.bigz,0,0,4,character,1
+gmp,%/%.bigz,0,0,5,class<`bigq`>,1
+gmp,%/%.bigz,1,0,0,class<`bigz`>,1
+gmp,%/%.bigz,1,0,1,^double[],1
+gmp,%/%.bigz,1,0,2,character,1
+gmp,%/%.bigz,1,0,3,class<`bigq`>,1
+gmp,%/%.bigz,1,0,4,null,1
+gmp,%*%.bigz,-1,0,0,class<`bigq`>,1
+gmp,%*%.bigz,-1,0,1,class<`bigz`>,1
+gmp,%*%.bigz,0,0,0,class<`bigz`>,1
+gmp,%*%.bigz,1,0,0,class<`bigq`>,1
+gmp,%*%.bigz,1,0,1,class<`bigz`>,1
+gmp,%*%.bigz,1,0,2,class<`matrix`>,1
+gmp,%%.bigz,-1,0,0,class<`bigz`>,1
+gmp,%%.bigz,0,0,0,class<`bigz`>,1
+gmp,%%.bigz,0,0,1,double,1
+gmp,%%.bigz,0,0,2,integer[],1
+gmp,%%.bigz,0,0,3,null,1
+gmp,%%.bigz,1,0,0,class<`bigz`>,1
+gmp,%%.bigz,1,0,1,^double[],1
+gmp,%%.bigz,1,0,2,character,1
+gmp,+.bigz,-1,0,0,class<`bigz`>,1
+gmp,+.bigz,0,0,0,class<`bigz`>,1
+gmp,+.bigz,0,0,1,^double[],1
+gmp,+.bigz,0,0,2,null,1
+gmp,+.bigz,1,0,0,class<`bigz`>,1
+gmp,+.bigz,1,0,1,^double[],1
+gmp,c.bigq,-1,0,0,class<`bigq`>,1
+gmp,c.bigq,0,0,0,...,1
+gmp,c.bigq,1,0,0,logical,1
+gmp,c.bigz,-1,0,0,class<`bigz`>,1
+gmp,c.bigz,0,0,0,...,1
+gmp,c.bigz,1,0,0,logical,1
+gmp,chooseZ,-1,0,0,class<`bigz`>,1
+gmp,chooseZ,0,0,0,class<`bigz`>,1
+gmp,chooseZ,0,0,1,double[],1
+gmp,chooseZ,1,0,0,double[],1
+gmp,chooseZ,1,0,1,class<`bigz`>,1
+gmp,crossprod,-1,0,0,class<`bigq`>,1
+gmp,crossprod,-1,0,1,class<`bigz`>,1
+gmp,crossprod,0,0,0,class<`bigq`>,1
+gmp,crossprod,0,0,1,class<`bigz`>,1
+gmp,crossprod,1,0,0,class<`bigq`>,1
+gmp,crossprod,1,0,1,null,1
+gmp,crossprod,1,0,2,class<`bigz`>,1
+gmp,crossprod.bigq,-1,0,0,class<`bigq`>,1
+gmp,crossprod.bigq,0,0,0,class<`bigq`>,1
+gmp,crossprod.bigq,1,0,0,class<`bigq`>,1
+gmp,crossprod.bigq,1,0,1,null,1
+gmp,crossprod.bigz,-1,0,0,class<`bigq`>,1
+gmp,crossprod.bigz,-1,0,1,class<`bigz`>,1
+gmp,crossprod.bigz,0,0,0,class<`bigz`>,1
+gmp,crossprod.bigz,1,0,0,class<`bigq`>,1
+gmp,crossprod.bigz,1,0,1,class<`bigz`>,1
+gmp,crossprod.bigz,1,0,2,null,1
+gmp,cumsum.bigq,-1,0,0,class<`bigq`>,1
+gmp,cumsum.bigq,0,0,0,class<`bigq`>,1
+gmp,cumsum.bigz,-1,0,0,class<`bigz`>,1
+gmp,cumsum.bigz,0,0,0,class<`bigz`>,1
+gmp,%*%.default,-1,0,0,class<`bigq`>,1
+gmp,%*%.default,-1,0,1,class<`bigz`>,1
+gmp,%*%.default,-1,0,2,class<`matrix`>,1
+gmp,%*%.default,0,0,0,class<`matrix`>,1
+gmp,%*%.default,0,0,1,double[],1
+gmp,%*%.default,1,0,0,class<`bigq`>,1
+gmp,%*%.default,1,0,1,class<`bigz`>,1
+gmp,%*%.default,1,0,2,class<`matrix`>,1
+gmp,denominator,-1,0,0,class<`bigz`>,1
+gmp,denominator,0,0,0,class<`bigq`>,1
+gmp,dim<-.bigq,-1,0,0,class<`bigq`>,1
+gmp,dim<-.bigq,-1,0,1,class<`bigz`>,1
+gmp,dim<-.bigq,0,0,0,class<`bigq`>,1
+gmp,dim<-.bigq,0,0,1,class<`bigz`>,1
+gmp,dim<-.bigq,1,0,0,double[],1
+gmp,dim.bigq,-1,0,0,double[],1
+gmp,dim.bigq,-1,0,1,null,1
+gmp,dim.bigq,0,0,0,class<`bigq`>,1
+gmp,dim.bigq,0,0,1,class<`bigz`>,1
+gmp,dim<-.bigz,-1,0,0,class<`bigq`>,1
+gmp,dim<-.bigz,-1,0,1,class<`bigz`>,1
+gmp,dim<-.bigz,0,0,0,class<`bigq`>,1
+gmp,dim<-.bigz,0,0,1,class<`bigz`>,1
+gmp,dim<-.bigz,1,0,0,double[],1
+gmp,dim.bigz,-1,0,0,double[],1
+gmp,dim.bigz,-1,0,1,null,1
+gmp,dim.bigz,0,0,0,class<`bigq`>,1
+gmp,dim.bigz,0,0,1,class<`bigz`>,1
+gmp,divq.bigz,-1,0,0,class<`bigz`>,1
+gmp,divq.bigz,0,0,0,class<`bigz`>,1
+gmp,divq.bigz,0,0,1,double,1
+gmp,divq.bigz,0,0,2,integer[],1
+gmp,divq.bigz,0,0,3,null,1
+gmp,divq.bigz,0,0,4,character,1
+gmp,divq.bigz,0,0,5,class<`bigq`>,1
+gmp,divq.bigz,1,0,0,class<`bigz`>,1
+gmp,divq.bigz,1,0,1,^double[],1
+gmp,divq.bigz,1,0,2,character,1
+gmp,divq.bigz,1,0,3,class<`bigq`>,1
+gmp,divq.bigz,1,0,4,null,1
+gmp,duplicated.bigq,-1,0,0,logical[],1
+gmp,duplicated.bigq,0,0,0,class<`bigq`>,1
+gmp,duplicated.bigq,0,0,1,class<`bigz`>,1
+gmp,duplicated.bigq,1,0,0,logical,1
+gmp,duplicated.bigq,2,0,0,...,1
+gmp,duplicated.bigz,-1,0,0,logical[],1
+gmp,duplicated.bigz,0,0,0,class<`bigq`>,1
+gmp,duplicated.bigz,0,0,1,class<`bigz`>,1
+gmp,duplicated.bigz,1,0,0,logical,1
+gmp,duplicated.bigz,2,0,0,...,1
+gmp,Eulerian.all,-1,0,0,class<`bigz`>,1
+gmp,Eulerian.all,0,0,0,double,1
+gmp,factorialZ,-1,0,0,class<`bigz`>,1
+gmp,factorialZ,0,0,0,class<`bigz`>,1
+gmp,factorialZ,0,0,1,double[],1
+gmp,factorize,-1,0,0,any,1
+gmp,factorize,0,0,0,character,1
+gmp,factorize,0,0,1,class<`bigz`>,1
+gmp,factorize,0,0,2,double,1
+gmp,factorize,0,0,3,class<`bigq`>,1
+gmp,factorize,0,0,4,null,1
+gmp,fibnum,-1,0,0,class<`bigz`>,1
+gmp,fibnum,0,0,0,class<`bigz`>,1
+gmp,fibnum,0,0,1,double,1
+gmp,fibnum,0,0,2,integer[],1
+gmp,fibnum2,-1,0,0,class<`bigz`>,1
+gmp,fibnum2,0,0,0,class<`bigz`>,1
+gmp,fibnum2,0,0,1,double,1
+gmp,fibnum2,0,0,2,integer[],1
+gmp,formatN,-1,0,0,character[],1
+gmp,formatN,0,0,0,class<`bigq`>,1
+gmp,formatN,0,0,1,class<`bigz`>,1
+gmp,formatN,0,0,2,double[],1
+gmp,formatN,1,0,0,...,1
+gmp,formatN.bigq,-1,0,0,character[],1
+gmp,formatN.bigq,0,0,0,class<`bigq`>,1
+gmp,formatN.bigq,1,0,0,...,1
+gmp,formatN.bigz,-1,0,0,character[],1
+gmp,formatN.bigz,0,0,0,class<`bigz`>,1
+gmp,formatN.bigz,1,0,0,...,1
+gmp,formatN.default,-1,0,0,character,1
+gmp,formatN.default,0,0,0,character,1
+gmp,formatN.default,0,0,1,null,1
+gmp,formatN.default,1,0,0,...,1
+gmp,formatN.double,-1,0,0,character[],1
+gmp,formatN.double,0,0,0,double[],1
+gmp,formatN.double,1,0,0,...,1
+gmp,formatN.integer,-1,0,0,character[],1
+gmp,formatN.integer,0,0,0,integer[],1
+gmp,formatN.integer,1,0,0,...,1
+gmp,frexpZ,-1,0,0,list<double[]>,1
+gmp,frexpZ,0,0,0,class<`bigz`>,1
+gmp,frexpZ,0,0,1,double[],1
+gmp,gcd,-1,0,0,class<`bigz`>,1
+gmp,gcd,0,0,0,class<`bigz`>,1
+gmp,gcd,1,0,0,class<`bigz`>,1
+gmp,gcd.bigz,-1,0,0,class<`bigz`>,1
+gmp,gcd.bigz,0,0,0,character,1
+gmp,gcd.bigz,0,0,1,class<`bigq`>,1
+gmp,gcd.bigz,0,0,2,class<`bigz`>,1
+gmp,gcd.bigz,0,0,3,null,1
+gmp,gcd.bigz,0,0,4,double[],1
+gmp,gcd.bigz,1,0,0,character,1
+gmp,gcd.bigz,1,0,1,class<`bigq`>,1
+gmp,gcd.bigz,1,0,2,class<`bigz`>,1
+gmp,gcd.bigz,1,0,3,null,1
+gmp,gcd.bigz,1,0,4,double[],1
+gmp,gcd.default,-1,0,0,integer[],1
+gmp,gcd.default,-1,0,1,null,1
+gmp,gcd.default,0,0,0,double[],1
+gmp,gcd.default,0,0,1,null,1
+gmp,gcd.default,1,0,0,double[],1
+gmp,gcd.default,1,0,1,null,1
+gmp,gcdex,-1,0,0,class<`bigz`>,1
+gmp,gcdex,0,0,0,double,1
+gmp,gcdex,1,0,0,double,1
+gmp,gmpVersion,-1,0,0,class<`numeric_version`>,1
+gmp,.gmpVersion,-1,0,0,character,1
+gmp,inv.bigz,-1,0,0,class<`bigz`>,1
+gmp,inv.bigz,0,0,0,double,1
+gmp,inv.bigz,0,0,1,integer[],1
+gmp,inv.bigz,1,0,0,double,1
+gmp,inv.bigz,2,0,0,...,1
+gmp,is.bigq,-1,0,0,logical,1
+gmp,is.bigq,0,0,0,class<`bigq`>,1
+gmp,is.bigq,0,0,1,class<`bigz`>,1
+gmp,is.bigq,0,0,2,double,1
+gmp,is.bigz,-1,0,0,logical,1
+gmp,is.bigz,0,0,0,class<`bigq`>,1
+gmp,is.bigz,0,0,1,class<`bigz`>,1
+gmp,is.bigz,0,0,2,double,1
+gmp,is.finite.bigq,-1,0,0,logical[],1
+gmp,is.finite.bigq,0,0,0,class<`bigq`>,1
+gmp,is.finite.bigz,-1,0,0,logical[],1
+gmp,is.finite.bigz,0,0,0,class<`bigz`>,1
+gmp,is.infinite.bigq,-1,0,0,logical[],1
+gmp,is.infinite.bigq,0,0,0,class<`bigq`>,1
+gmp,is.infinite.bigq,0,0,1,class<`bigz`>,1
+gmp,is.infinite.bigz,-1,0,0,logical[],1
+gmp,is.infinite.bigz,0,0,0,class<`bigq`>,1
+gmp,is.infinite.bigz,0,0,1,class<`bigz`>,1
+gmp,is.matrixZQ,-1,0,0,logical,1
+gmp,is.matrixZQ,0,0,0,class<`bigz`>,1
+gmp,is.matrixZQ,0,0,1,double,1
+gmp,is.na.bigq,-1,0,0,logical[],1
+gmp,is.na.bigq,0,0,0,class<`bigq`>,1
+gmp,is.na.bigz,-1,0,0,logical[],1
+gmp,is.na.bigz,0,0,0,class<`bigz`>,1
+gmp,isprime,-1,0,0,integer[],1
+gmp,isprime,0,0,0,integer[],1
+gmp,isprime,0,0,1,class<`bigz`>,1
+gmp,isprime,0,0,2,double,1
+gmp,isprime,1,0,0,double,1
+gmp,is.whole,-1,0,0,logical[],1
+gmp,is.whole,0,0,0,class<`bigq`>,1
+gmp,is.whole,0,0,1,class<`bigz`>,1
+gmp,is.whole,0,0,2,complex[],1
+gmp,is.whole,0,0,3,null,1
+gmp,is.whole,0,0,4,character,1
+gmp,is.whole.bigq,-1,0,0,logical[],1
+gmp,is.whole.bigq,0,0,0,class<`bigq`>,1
+gmp,is.whole.bigz,-1,0,0,logical[],1
+gmp,is.whole.bigz,0,0,0,class<`bigz`>,1
+gmp,is.whole.default,-1,0,0,logical[],1
+gmp,is.whole.default,0,0,0,complex[],1
+gmp,is.whole.default,0,0,1,null,1
+gmp,is.whole.default,0,0,2,character,1
+gmp,lcm.bigz,-1,0,0,class<`bigz`>,1
+gmp,lcm.bigz,0,0,0,class<`bigz`>,1
+gmp,lcm.bigz,0,0,1,double,1
+gmp,lcm.bigz,1,0,0,class<`bigz`>,1
+gmp,lcm.bigz,1,0,1,double,1
+gmp,length.bigq,-1,0,0,integer,1
+gmp,length.bigq,0,0,0,class<`bigq`>,1
+gmp,length.bigz,-1,0,0,integer,1
+gmp,length.bigz,0,0,0,class<`bigz`>,1
+gmp,ln.bigz,-1,0,0,double[],1
+gmp,ln.bigz,0,0,0,class<`bigz`>,1
+gmp,ln.bigz,0,0,1,null,1
+gmp,ln.bigz,0,0,2,character,1
+gmp,ln.bigz,0,0,3,class<`bigq`>,1
+gmp,ln.bigz,0,0,4,double,1
+gmp,log2.bigz,-1,0,0,double[],1
+gmp,log2.bigz,0,0,0,class<`bigz`>,1
+gmp,log.bigz,-1,0,0,double[],1
+gmp,log.bigz,0,0,0,class<`bigz`>,1
+gmp,log.bigz,1,0,0,any,1
+gmp,lucnum,-1,0,0,class<`bigz`>,1
+gmp,lucnum,0,0,0,class<`bigz`>,1
+gmp,lucnum,0,0,1,double,1
+gmp,lucnum,0,0,2,integer[],1
+gmp,lucnum2,-1,0,0,class<`bigz`>,1
+gmp,lucnum2,0,0,0,class<`bigz`>,1
+gmp,lucnum2,0,0,1,double,1
+gmp,lucnum2,0,0,2,integer[],1
+gmp,matrix,-1,0,0,class<`bigq`>,1
+gmp,matrix,-1,0,1,class<`bigz`>,1
+gmp,matrix,-1,0,2,class<`matrix`>,1
+gmp,matrix,0,0,0,class<`bigq`>,1
+gmp,matrix,0,0,1,class<`bigz`>,1
+gmp,matrix,0,0,2,double[],1
+gmp,matrix,0,0,3,character,1
+gmp,matrix,1,0,0,double,1
+gmp,matrix,2,0,0,double,1
+gmp,matrix,3,0,0,logical,1
+gmp,matrix,4,0,0,...,1
+gmp,matrix.bigq,-1,0,0,class<`bigq`>,1
+gmp,matrix.bigq,0,0,0,class<`bigq`>,1
+gmp,matrix.bigq,1,0,0,double,1
+gmp,matrix.bigq,2,0,0,double,1
+gmp,matrix.bigq,3,0,0,logical,1
+gmp,matrix.bigq,4,0,0,null,1
+gmp,matrix.bigq,5,0,0,null,1
+gmp,matrix.bigq,6,0,0,...,1
+gmp,matrix.bigz,-1,0,0,class<`bigz`>,1
+gmp,matrix.bigz,0,0,0,integer[],1
+gmp,matrix.bigz,0,0,1,class<`bigz`>,1
+gmp,matrix.bigz,1,0,0,double,1
+gmp,matrix.bigz,2,0,0,double,1
+gmp,matrix.bigz,3,0,0,logical,1
+gmp,matrix.bigz,4,0,0,null,1
+gmp,matrix.bigz,5,0,0,null,1
+gmp,matrix.bigz,6,0,0,...,1
+gmp,matrix.default,-1,0,0,class<`matrix`>,1
+gmp,matrix.default,0,0,0,...,1
+gmp,max.bigq,-1,0,0,class<`bigq`>,1
+gmp,max.bigq,0,0,0,...,1
+gmp,max.bigq,1,0,0,logical,1
+gmp,max.bigz,-1,0,0,class<`bigz`>,1
+gmp,max.bigz,0,0,0,...,1
+gmp,max.bigz,1,0,0,logical,1
+gmp,mean.bigq,-1,0,0,class<`bigq`>,1
+gmp,mean.bigq,0,0,0,class<`bigq`>,1
+gmp,mean.bigq,1,0,0,double,1
+gmp,mean.bigq,2,0,0,logical,1
+gmp,mean.bigq,3,0,0,...,1
+gmp,min.bigq,-1,0,0,class<`bigq`>,1
+gmp,min.bigq,0,0,0,...,1
+gmp,min.bigq,1,0,0,logical,1
+gmp,min.bigz,-1,0,0,class<`bigz`>,1
+gmp,min.bigz,0,0,0,...,1
+gmp,min.bigz,1,0,0,logical,1
+gmp,mod.bigz,-1,0,0,class<`bigz`>,1
+gmp,mod.bigz,0,0,0,class<`bigz`>,1
+gmp,mod.bigz,0,0,1,double,1
+gmp,mod.bigz,0,0,2,integer[],1
+gmp,mod.bigz,0,0,3,null,1
+gmp,mod.bigz,1,0,0,class<`bigz`>,1
+gmp,mod.bigz,1,0,1,^double[],1
+gmp,mod.bigz,1,0,2,character,1
+gmp,modulus,-1,0,0,class<`bigz`>,1
+gmp,modulus,-1,0,1,null,1
+gmp,modulus,0,0,0,class<`bigz`>,1
+gmp,modulus<-,-1,0,0,class<`bigz`>,1
+gmp,modulus<-,0,0,0,class<`bigz`>,1
+gmp,modulus<-,1,0,0,null,1
+gmp,modulus<-,1,0,1,class<`bigz`>,1
+gmp,modulus<-,1,0,2,double,1
+gmp,modulus<-.bigz,-1,0,0,class<`bigz`>,1
+gmp,modulus<-.bigz,0,0,0,class<`bigz`>,1
+gmp,modulus<-.bigz,1,0,0,null,1
+gmp,modulus<-.bigz,1,0,1,class<`bigz`>,1
+gmp,modulus<-.bigz,1,0,2,double,1
+gmp,modulus.bigz,-1,0,0,class<`bigz`>,1
+gmp,modulus.bigz,-1,0,1,null,1
+gmp,modulus.bigz,0,0,0,class<`bigz`>,1
+gmp,nextprime,-1,0,0,class<`bigz`>,1
+gmp,nextprime,0,0,0,double,1
+gmp,numerator,-1,0,0,class<`bigz`>,1
+gmp,numerator,0,0,0,class<`bigq`>,1
+gmp,numerator<-,-1,0,0,class<`bigq`>,1
+gmp,numerator<-,0,0,0,class<`bigq`>,1
+gmp,numerator<-,1,0,0,class<`bigz`>,1
+gmp,outer,-1,0,0,class<`bigz`>,1
+gmp,outer,-1,0,1,class<`matrix`>,1
+gmp,outer,0,0,0,class<`bigz`>,1
+gmp,outer,0,0,1,double[],1
+gmp,outer,1,0,0,double[],1
+gmp,outer,2,0,0,class<`function`>,1
+gmp,outer,2,0,1,character,1
+gmp,outer,3,0,0,...,1
+gmp,pow.bigz,-1,0,0,class<`bigq`>,1
+gmp,pow.bigz,-1,0,1,class<`bigz`>,1
+gmp,pow.bigz,0,0,0,class<`bigz`>,1
+gmp,pow.bigz,0,0,1,double,1
+gmp,pow.bigz,0,0,2,null,1
+gmp,pow.bigz,0,0,3,integer[],1
+gmp,pow.bigz,1,0,0,class<`bigz`>,1
+gmp,pow.bigz,1,0,1,^double[],1
+gmp,pow.bigz,2,0,0,...,1
+gmp,powm,-1,0,0,class<`bigz`>,1
+gmp,powm,0,0,0,double,1
+gmp,powm,1,0,0,double,1
+gmp,powm,2,0,0,double,1
+gmp,prod.bigq,-1,0,0,class<`bigq`>,1
+gmp,prod.bigq,0,0,0,...,1
+gmp,prod.bigq,1,0,0,logical,1
+gmp,prod.bigz,-1,0,0,class<`bigz`>,1
+gmp,prod.bigz,0,0,0,...,1
+gmp,prod.bigz,1,0,0,logical,1
+gmp,rep.bigq,-1,0,0,class<`bigq`>,1
+gmp,rep.bigq,0,0,0,class<`bigq`>,1
+gmp,rep.bigq,1,0,0,double,1
+gmp,rep.bigq,2,0,0,double,1
+gmp,rep.bigq,2,0,1,null,1
+gmp,rep.bigq,3,0,0,double,1
+gmp,rep.bigq,4,0,0,...,1
+gmp,rep.bigz,-1,0,0,class<`bigz`>,1
+gmp,rep.bigz,0,0,0,class<`bigz`>,1
+gmp,rep.bigz,1,0,0,double,1
+gmp,rep.bigz,2,0,0,double,1
+gmp,rep.bigz,2,0,1,null,1
+gmp,rep.bigz,3,0,0,double,1
+gmp,rep.bigz,4,0,0,...,1
+gmp,sign.bigq,-1,0,0,integer[],1
+gmp,sign.bigq,0,0,0,class<`bigq`>,1
+gmp,sign.bigz,-1,0,0,integer[],1
+gmp,sign.bigz,0,0,0,class<`bigz`>,1
+gmp,sizeinbase,-1,0,0,integer[],1
+gmp,sizeinbase,0,0,0,class<`bigz`>,1
+gmp,sizeinbase,0,0,1,double,1
+gmp,sizeinbase,1,0,0,double,1
+gmp,solve.bigq,-1,0,0,class<`bigq`>,1
+gmp,solve.bigq,0,0,0,class<`bigq`>,1
+gmp,solve.bigq,1,0,0,any,1
+gmp,solve.bigq,2,0,0,...,1
+gmp,solve.bigz,-1,0,0,any,1
+gmp,solve.bigz,0,0,0,class<`bigz`>,1
+gmp,solve.bigz,1,0,0,any,1
+gmp,solve.bigz,2,0,0,...,1
+gmp,Stirling1,-1,0,0,class<`bigz`>,1
+gmp,Stirling1,0,0,0,double,1
+gmp,Stirling1,1,0,0,double,1
+gmp,Stirling1.all,-1,0,0,class<`bigz`>,1
+gmp,Stirling1.all,0,0,0,double,1
+gmp,Stirling2,-1,0,0,class<`bigz`>,1
+gmp,Stirling2,0,0,0,double,1
+gmp,Stirling2,1,0,0,double,1
+gmp,Stirling2,2,0,0,character[],1
+gmp,Stirling2.all,-1,0,0,class<`bigz`>,1
+gmp,Stirling2.all,0,0,0,double,1
+gmp,sum.bigq,-1,0,0,class<`bigq`>,1
+gmp,sum.bigq,0,0,0,...,1
+gmp,sum.bigq,1,0,0,logical,1
+gmp,sum.bigz,-1,0,0,class<`bigz`>,1
+gmp,sum.bigz,0,0,0,...,1
+gmp,sum.bigz,1,0,0,logical,1
+gmp,t.bigq,-1,0,0,class<`bigq`>,1
+gmp,t.bigq,0,0,0,class<`bigq`>,1
+gmp,t.bigz,-1,0,0,class<`bigz`>,1
+gmp,t.bigz,0,0,0,class<`bigz`>,1
+gmp,tcrossprod,-1,0,0,class<`bigq`>,1
+gmp,tcrossprod,-1,0,1,class<`bigz`>,1
+gmp,tcrossprod,0,0,0,class<`bigq`>,1
+gmp,tcrossprod,0,0,1,class<`bigz`>,1
+gmp,tcrossprod,0,0,2,class<`matrix`>,1
+gmp,tcrossprod,1,0,0,class<`bigq`>,1
+gmp,tcrossprod,1,0,1,null,1
+gmp,tcrossprod,1,0,2,class<`bigz`>,1
+gmp,tcrossprod.bigq,-1,0,0,class<`bigq`>,1
+gmp,tcrossprod.bigq,0,0,0,class<`bigq`>,1
+gmp,tcrossprod.bigq,1,0,0,class<`bigq`>,1
+gmp,tcrossprod.bigq,1,0,1,null,1
+gmp,tcrossprod.bigz,-1,0,0,class<`bigz`>,1
+gmp,tcrossprod.bigz,0,0,0,class<`bigz`>,1
+gmp,tcrossprod.bigz,1,0,0,class<`bigz`>,1
+gmp,tcrossprod.bigz,1,0,1,null,1
+gmp,tcrossprod.default,-1,0,0,class<`bigz`>,1
+gmp,tcrossprod.default,0,0,0,class<`matrix`>,1
+gmp,tcrossprod.default,1,0,0,class<`bigz`>,1
+gmp,unique.bigq,-1,0,0,class<`bigq`>,1
+gmp,unique.bigq,-1,0,1,class<`bigz`>,1
+gmp,unique.bigq,0,0,0,class<`bigq`>,1
+gmp,unique.bigq,0,0,1,class<`bigz`>,1
+gmp,unique.bigq,1,0,0,logical,1
+gmp,unique.bigq,2,0,0,...,1
+gmp,unique.bigz,-1,0,0,class<`bigq`>,1
+gmp,unique.bigz,-1,0,1,class<`bigz`>,1
+gmp,unique.bigz,0,0,0,class<`bigq`>,1
+gmp,unique.bigz,0,0,1,class<`bigz`>,1
+gmp,unique.bigz,1,0,0,logical,1
+gmp,unique.bigz,2,0,0,...,1
+gmp,urand.bigz,-1,0,0,class<`bigz`>,1
+gmp,urand.bigz,0,0,0,double,1
+gmp,urand.bigz,1,0,0,double,1
+gmp,urand.bigz,2,0,0,character,1
+gmp,urand.bigz,2,0,1,double,1
+gmp,which.max,-1,0,0,integer,1
+gmp,which.max,0,0,0,class<`bigq`>,1
+gmp,which.max,-1,1,0,integer,1
+gmp,which.max,0,1,0,class<`bigz`>,1
+gmp,which.min,-1,0,0,integer,1
+gmp,which.min,0,0,0,class<`bigz`>,1
+gmp,which.min,-1,1,0,integer,1
+gmp,which.min,0,1,0,class<`bigq`>,1
+gnm,anova.gnm,-1,0,0,"class<`anova`, `data.frame`>",1
+gnm,anova.gnm,0,0,0,"class<`glm`, `gnm`, `lm`>",1
+gnm,anova.gnm,1,0,0,...,1
+gnm,anova.gnm,2,0,0,null,1
+gnm,anova.gnm,3,0,0,character,1
+gnm,anova.gnm,3,0,1,null,1
+gnm,asGnm,-1,0,0,"class<`glm`, `gnm`, `lm`>",1
+gnm,asGnm,0,0,0,class<`lm`>,1
+gnm,asGnm,1,0,0,...,1
+gnm,asGnm.lm,-1,0,0,"class<`glm`, `gnm`, `lm`>",1
+gnm,asGnm.lm,0,0,0,class<`lm`>,1
+gnm,asGnm.lm,1,0,0,...,1
+gnm,checkEstimable,-1,0,0,^logical[],1
+gnm,checkEstimable,0,0,0,"class<`glm`, `gnm`, `lm`>",1
+gnm,checkEstimable,1,0,0,class<`matrix`>,1
+gnm,checkEstimable,1,0,1,double[],1
+gnm,checkEstimable,2,0,0,null,1
+gnm,coef.gnm,-1,0,0,"class<`coef.gnm`, `numeric`>",1
+gnm,coef.gnm,0,0,0,"class<`glm`, `gnm`, `lm`>",1
+gnm,coef.gnm,1,0,0,...,1
+gnm,confint.gnm,-1,0,0,class<`matrix`>,1
+gnm,confint.gnm,0,0,0,"class<`glm`, `gnm`, `lm`>",1
+gnm,confint.gnm,1,0,0,integer[],1
+gnm,confint.gnm,2,0,0,double,1
+gnm,confint.gnm,3,0,0,logical,1
+gnm,confint.gnm,4,0,0,...,1
+gnm,confint.profile.gnm,-1,0,0,class<`matrix`>,1
+gnm,confint.profile.gnm,0,0,0,"class<`profile`, `profile.glm`, `profile.gnm`>",1
+gnm,confint.profile.gnm,1,0,0,character[],1
+gnm,confint.profile.gnm,2,0,0,double,1
+gnm,confint.profile.gnm,3,0,0,...,1
+gnm,Const,-1,0,0,class<`call`>,1
+gnm,Const,0,0,0,double,1
+gnm,cooks.distance.gnm,-1,0,0,class<`table`>,1
+gnm,cooks.distance.gnm,0,0,0,"class<`glm`, `gnm`, `lm`>",1
+gnm,cooks.distance.gnm,1,0,0,class<`table`>,1
+gnm,cooks.distance.gnm,2,0,0,double,1
+gnm,cooks.distance.gnm,3,0,0,...,1
+gnm,Diag,-1,0,0,class<`factor`>,1
+gnm,Diag,-1,0,1,double[],1
+gnm,Diag,0,0,0,...,1
+gnm,Diag,1,0,0,logical,1
+gnm,Dref,-1,0,0,list<any>,1
+gnm,Dref,0,0,0,...,1
+gnm,Dref,1,0,0,class<`formula`>,1
+gnm,DrefWeights,-1,0,0,list<class<`data.frame`>>,1
+gnm,DrefWeights,-1,0,1,list<double[]>,1
+gnm,DrefWeights,0,0,0,"class<`glm`, `gnm`, `lm`>",1
+gnm,exitInfo,-1,0,0,class<`data.frame`>,1
+gnm,exitInfo,0,0,0,"class<`glm`, `gnm`, `lm`>",1
+gnm,Exp,-1,0,0,list<any>,1
+gnm,Exp,0,0,0,any,1
+gnm,Exp,1,0,0,null,1
+gnm,expandCategorical,-1,0,0,class<`data.frame`>,1
+gnm,expandCategorical,0,0,0,class<`data.frame`>,1
+gnm,expandCategorical,1,0,0,character,1
+gnm,expandCategorical,2,0,0,character,1
+gnm,expandCategorical,3,0,0,character,1
+gnm,expandCategorical,4,0,0,character,1
+gnm,expandCategorical,5,0,0,logical,1
+gnm,expandCategorical,6,0,0,logical,1
+gnm,getContrasts,-1,0,0,class<`qv`>,1
+gnm,getContrasts,0,0,0,"class<`glm`, `gnm`, `lm`>",1
+gnm,getContrasts,1,0,0,integer[],1
+gnm,getContrasts,2,0,0,character,1
+gnm,getContrasts,2,0,1,class<`array`>,1
+gnm,getContrasts,3,0,0,character,1
+gnm,getContrasts,3,0,1,class<`array`>,1
+gnm,getContrasts,4,0,0,null,1
+gnm,getContrasts,4,0,1,character,1
+gnm,getContrasts,4,0,2,class<`array`>,1
+gnm,getContrasts,5,0,0,null,1
+gnm,getContrasts,6,0,0,logical,1
+gnm,getContrasts,7,0,0,...,1
+gnm,glm.fit.e,-1,0,0,^double[],1
+gnm,glm.fit.e,-1,0,1,list<any>,1
+gnm,glm.fit.e,0,0,0,class<`matrix`>,1
+gnm,glm.fit.e,1,0,0,double[],1
+gnm,glm.fit.e,2,0,0,double[],1
+gnm,glm.fit.e,3,0,0,null,1
+gnm,glm.fit.e,4,0,0,null,1
+gnm,glm.fit.e,5,0,0,null,1
+gnm,glm.fit.e,6,0,0,double[],1
+gnm,glm.fit.e,7,0,0,class<`family`>,1
+gnm,gnm,-1,0,0,"class<`glm`, `gnm`, `lm`>",1
+gnm,gnm,-1,0,1,class<`matrix`>,1
+gnm,gnm,0,0,0,class<`formula`>,1
+gnm,gnm,1,0,0,any,1
+gnm,gnm,2,0,0,null,1
+gnm,gnm,2,0,1,character,1
+gnm,gnm,3,0,0,double[],1
+gnm,gnm,3,0,1,character,1
+gnm,gnm,4,0,0,double[],1
+gnm,gnm,5,0,0,character,1
+gnm,gnm,5,0,1,class<`function`>,1
+gnm,gnm,6,0,0,class<`data.frame`>,1
+gnm,gnm,6,0,1,class<`table`>,1
+gnm,gnm,6,0,2,"class<`data.frame`, `groupedData`, `nfGroupedData`, `nfnGroupedData`>",1
+gnm,gnm,6,0,3,"class<`table`, `xtabs`>",1
+gnm,gnm,6,0,4,null,1
+gnm,gnm,7,0,0,any,1
+gnm,gnmFit,-1,0,0,list<any>,1
+gnm,gnmFit,0,0,0,list<double[] | class<`function`>>,1
+gnm,gnmFit,0,0,1,list<^logical[] | class<`function`> | double[]>,1
+gnm,gnmFit,0,0,2,list<^logical[] | integer[] | class<`function`>>,1
+gnm,gnmFit,1,0,0,double[],1
+gnm,gnmFit,2,0,0,double[],1
+gnm,gnmFit,3,0,0,double[],1
+gnm,gnmFit,4,0,0,null,1
+gnm,gnmFit,4,0,1,class<`factor`>,1
+gnm,gnmFit,5,0,0,class<`family`>,1
+gnm,gnmFit,6,0,0,double[],1
+gnm,gnmFit,7,0,0,double[],1
+gnm,gnmStart,-1,0,0,double[],1
+gnm,gnmStart,0,0,0,integer,1
+gnm,gnmStart,1,0,0,double,1
+gnm,gnmTerms,-1,0,0,"class<`formula`, `gnmTerms`, `terms`>",1
+gnm,gnmTerms,0,0,0,class<`formula`>,1
+gnm,gnmTerms,1,0,0,null,1
+gnm,gnmTerms,1,0,1,class<`name`>,1
+gnm,gnmTerms,2,0,0,class<`data.frame`>,1
+gnm,gnmTerms,2,0,1,"class<`data.frame`, `groupedData`, `nfGroupedData`, `nfnGroupedData`>",1
+gnm,gnmTerms,2,0,2,class<`table`>,1
+gnm,gnmTerms,2,0,3,"class<`table`, `xtabs`>",1
+gnm,gnmTerms,2,0,4,null,1
+gnm,gnmTools,-1,0,0,list<double[] | class<`function`>>,1
+gnm,gnmTools,-1,0,1,list<^logical[] | class<`function`> | double[]>,1
+gnm,gnmTools,-1,0,2,list<^logical[] | integer[] | class<`function`>>,1
+gnm,gnmTools,0,0,0,"class<`formula`, `gnmTerms`, `terms`>",1
+gnm,gnmTools,1,0,0,class<`data.frame`>,1
+gnm,gnmTools,2,0,0,any,1
+gnm,grp.sum,-1,0,0,double[],1
+gnm,grp.sum,0,0,0,double[],1
+gnm,grp.sum,1,0,0,integer[],1
+gnm,hashSplit,-1,0,0,character[],1
+gnm,hashSplit,0,0,0,character[],1
+gnm,hatvalues.gnm,-1,0,0,class<`table`>,1
+gnm,hatvalues.gnm,0,0,0,"class<`glm`, `gnm`, `lm`>",1
+gnm,hatvalues.gnm,1,0,0,...,1
+gnm,instances,-1,0,0,character,1
+gnm,instances,0,0,0,any,1
+gnm,instances,1,0,0,double,1
+gnm,Inv,-1,0,0,list<any>,1
+gnm,Inv,0,0,0,any,1
+gnm,Inv,1,0,0,null,1
+gnm,labels.gnm,-1,0,0,character[],1
+gnm,labels.gnm,0,0,0,"class<`glm`, `gnm`, `lm`>",1
+gnm,labels.gnm,1,0,0,...,1
+gnm,meanResiduals,-1,0,0,"class<`meanResiduals`, `table`>",1
+gnm,meanResiduals,0,0,0,"class<`glm`, `gnm`, `lm`>",1
+gnm,meanResiduals,1,0,0,class<`formula`>,1
+gnm,meanResiduals,2,0,0,logical,1
+gnm,meanResiduals,3,0,0,logical,1
+gnm,meanResiduals,4,0,0,...,1
+gnm,messageVector,-1,0,0,null,1
+gnm,messageVector,0,0,0,character[],1
+gnm,model.frame.gnm,-1,0,0,class<`data.frame`>,1
+gnm,model.frame.gnm,0,0,0,"class<`glm`, `gnm`, `lm`>",1
+gnm,model.frame.gnm,1,0,0,...,1
+gnm,model.matrix.gnm,-1,0,0,class<`matrix`>,1
+gnm,model.matrix.gnm,0,0,0,"class<`glm`, `gnm`, `lm`>",1
+gnm,model.matrix.gnm,1,0,0,integer[],1
+gnm,model.matrix.gnm,1,0,1,null,1
+gnm,model.matrix.gnm,2,0,0,...,1
+gnm,MPinv,-1,0,0,class<`matrix`>,1
+gnm,MPinv,0,0,0,class<`matrix`>,1
+gnm,MPinv,1,0,0,any,1
+gnm,MPinv,2,0,0,integer,1
+gnm,MPinv,2,0,1,null,1
+gnm,MPinv,3,0,0,character,1
+gnm,Mult,-1,0,0,list<any>,1
+gnm,Mult,0,0,0,...,1
+gnm,Mult,1,0,0,double,1
+gnm,Mult,1,0,1,null,1
+gnm,MultHomog,-1,0,0,list<any>,1
+gnm,MultHomog,0,0,0,...,1
+gnm,MultHomog,1,0,0,double,1
+gnm,MultHomog,1,0,1,null,1
+gnm,naToZero,-1,0,0,"class<`coef.gnm`, `numeric`>",1
+gnm,naToZero,-1,0,1,class<`matrix`>,1
+gnm,naToZero,-1,0,2,double[],1
+gnm,naToZero,0,0,0,"class<`coef.gnm`, `numeric`>",1
+gnm,naToZero,0,0,1,class<`matrix`>,1
+gnm,naToZero,0,0,2,^double[],1
+gnm,nonlinTerms,-1,0,0,list<any>,1
+gnm,nonlinTerms,0,0,0,list<class<`call`>>,1
+gnm,nonlinTerms,0,0,1,pairlist,1
+gnm,nonlinTerms,0,0,2,list<class<`formula`> | class<`name`>>,1
+gnm,nonlinTerms,0,0,3,list<class<`name`> | double>,1
+gnm,nonlinTerms,0,0,4,list<class<`name`>>,1
+gnm,nonlinTerms,0,0,5,list<double>,1
+gnm,nonlinTerms,1,0,0,null,1
+gnm,nonlinTerms,1,0,1,list<class<`name`>>,1
+gnm,nonlinTerms,2,0,0,class<`function`>,1
+gnm,nonlinTerms,3,0,0,double[],1
+gnm,nonlinTerms,4,0,0,expression,1
+gnm,nonlinTerms,4,0,1,null,1
+gnm,nonlinTerms,5,0,0,double[],1
+gnm,nonlinTerms,6,0,0,null,1
+gnm,nonlinTerms,6,0,1,class<`function`>,1
+gnm,nonlinTerms,7,0,0,null,1
+gnm,nonlinTerms,7,0,1,character,1
+gnm,ofInterest,-1,0,0,integer[],1
+gnm,ofInterest,-1,0,1,null,1
+gnm,ofInterest,0,0,0,"class<`glm`, `gnm`, `lm`>",1
+gnm,ofInterest,0,0,1,class<`summary.gnm`>,1
+gnm,ofInterest<-,-1,0,0,"class<`glm`, `gnm`, `lm`>",1
+gnm,ofInterest<-,0,0,0,"class<`glm`, `gnm`, `lm`>",1
+gnm,ofInterest<-,1,0,0,integer[],1
+gnm,parameters,-1,0,0,"class<`coef.gnm`, `numeric`>",1
+gnm,parameters,0,0,0,"class<`glm`, `gnm`, `lm`>",1
+gnm,pickCoef,-1,0,0,double[],1
+gnm,pickCoef,0,0,0,"class<`glm`, `gnm`, `lm`>",1
+gnm,pickCoef,1,0,0,character,1
+gnm,pickCoef,2,0,0,logical,1
+gnm,pickCoef,3,0,0,...,1
+gnm,plot.gnm,-1,0,0,null,1
+gnm,plot.gnm,0,0,0,"class<`glm`, `gnm`, `lm`>",1
+gnm,plot.gnm,1,0,0,double[],1
+gnm,plot.gnm,2,0,0,character[],1
+gnm,plot.gnm,3,0,0,class<`function`>,1
+gnm,plot.gnm,4,0,0,character,1
+gnm,plot.gnm,4,0,1,null,1
+gnm,plot.gnm,5,0,0,character,1
+gnm,plot.gnm,6,0,0,logical,1
+gnm,plot.gnm,7,0,0,...,1
+gnm,plot.profile.gnm,-1,0,0,null,1
+gnm,plot.profile.gnm,0,0,0,"class<`profile`, `profile.glm`, `profile.gnm`>",1
+gnm,plot.profile.gnm,1,0,0,any,1
+gnm,plot.profile.gnm,2,0,0,...,1
+gnm,prattle,-1,0,0,null,1
+gnm,prattle,0,0,0,...,1
+gnm,predict.gnm,-1,0,0,class<`table`>,1
+gnm,predict.gnm,-1,0,1,list<class<`table`> | double>,1
+gnm,predict.gnm,0,0,0,"class<`glm`, `gnm`, `lm`>",1
+gnm,predict.gnm,1,0,0,null,1
+gnm,predict.gnm,2,0,0,character[],1
+gnm,predict.gnm,3,0,0,logical,1
+gnm,predict.gnm,4,0,0,null,1
+gnm,predict.gnm,5,0,0,null,1
+gnm,predict.gnm,6,0,0,any,1
+gnm,predict.gnm,7,0,0,...,1
+gnm,print.summary.gnm,-1,0,0,class<`summary.gnm`>,1
+gnm,print.summary.gnm,0,0,0,class<`summary.gnm`>,1
+gnm,print.summary.gnm,1,0,0,double,1
+gnm,print.summary.gnm,2,0,0,logical,1
+gnm,print.summary.gnm,3,0,0,any,1
+gnm,print.summary.gnm,4,0,0,...,1
+gnm,profile.gnm,-1,0,0,"class<`profile`, `profile.glm`, `profile.gnm`>",1
+gnm,profile.gnm,0,0,0,"class<`glm`, `gnm`, `lm`>",1
+gnm,profile.gnm,1,0,0,integer[],1
+gnm,profile.gnm,1,0,1,null,1
+gnm,profile.gnm,2,0,0,double,1
+gnm,profile.gnm,3,0,0,double,1
+gnm,profile.gnm,4,0,0,null,1
+gnm,profile.gnm,5,0,0,logical,1
+gnm,profile.gnm,6,0,0,...,1
+gnm,quickRank,-1,0,0,integer,1
+gnm,quickRank,0,0,0,class<`matrix`>,1
+gnm,quickRank,1,0,0,null,1
+gnm,residSVD,-1,0,0,class<`matrix`>,1
+gnm,residSVD,-1,0,1,double[],1
+gnm,residSVD,0,0,0,"class<`glm`, `gnm`, `lm`>",1
+gnm,residSVD,0,0,1,class<`lm`>,1
+gnm,residSVD,1,0,0,any,1
+gnm,residSVD,2,0,0,any,1
+gnm,residSVD,3,0,0,double,1
+gnm,residuals.gnm,-1,0,0,class<`table`>,1
+gnm,residuals.gnm,-1,0,1,double[],1
+gnm,residuals.gnm,0,0,0,"class<`glm`, `gnm`, `lm`>",1
+gnm,residuals.gnm,1,0,0,character,1
+gnm,residuals.gnm,2,0,0,...,1
+gnm,se,-1,0,0,class<`data.frame`>,1
+gnm,se,0,0,0,"class<`glm`, `gnm`, `lm`>",1
+gnm,se,1,0,0,...,1
+gnm,se.gnm,-1,0,0,class<`data.frame`>,1
+gnm,se.gnm,0,0,0,"class<`glm`, `gnm`, `lm`>",1
+gnm,se.gnm,1,0,0,double[],1
+gnm,se.gnm,1,0,1,null,1
+gnm,se.gnm,2,0,0,logical,1
+gnm,se.gnm,3,0,0,null,1
+gnm,se.gnm,4,0,0,null,1
+gnm,se.gnm,5,0,0,...,1
+gnm,sumExpression,-1,0,0,class<`call`>,1
+gnm,sumExpression,0,0,0,list<class<`name`> | class<`call`>>,1
+gnm,sumExpression,0,0,1,list<class<`call`>>,1
+gnm,summary.gnm,-1,0,0,class<`summary.gnm`>,1
+gnm,summary.gnm,0,0,0,"class<`glm`, `gnm`, `lm`>",1
+gnm,summary.gnm,1,0,0,null,1
+gnm,summary.gnm,2,0,0,logical,1
+gnm,summary.gnm,3,0,0,logical,1
+gnm,summary.gnm,4,0,0,logical,1
+gnm,summary.gnm,5,0,0,...,1
+gnm,summary.meanResiduals,-1,0,0,null,1
+gnm,summary.meanResiduals,0,0,0,"class<`meanResiduals`, `table`>",1
+gnm,summary.meanResiduals,1,0,0,double,1
+gnm,summary.meanResiduals,2,0,0,...,1
+gnm,Symm,-1,0,0,class<`factor`>,1
+gnm,Symm,0,0,0,...,1
+gnm,Symm,1,0,0,character,1
+gnm,termPredictors,-1,0,0,class<`matrix`>,1
+gnm,termPredictors,0,0,0,"class<`glm`, `gnm`, `lm`>",1
+gnm,termPredictors,0,0,1,"class<`glm`, `lm`>",1
+gnm,termPredictors,0,0,2,class<`lm`>,1
+gnm,termPredictors,1,0,0,...,1
+gnm,termPredictors.default,-1,0,0,class<`matrix`>,1
+gnm,termPredictors.default,0,0,0,"class<`glm`, `lm`>",1
+gnm,termPredictors.default,0,0,1,class<`lm`>,1
+gnm,termPredictors.default,1,0,0,...,1
+gnm,termPredictors.gnm,-1,0,0,class<`matrix`>,1
+gnm,termPredictors.gnm,0,0,0,"class<`glm`, `gnm`, `lm`>",1
+gnm,termPredictors.gnm,1,0,0,...,1
+gnm,Topo,-1,0,0,class<`factor`>,1
+gnm,Topo,0,0,0,...,1
+gnm,Topo,1,0,0,class<`matrix`>,1
+gnm,update.gnm,-1,0,0,"class<`glm`, `gnm`, `lm`>",1
+gnm,update.gnm,0,0,0,"class<`glm`, `gnm`, `lm`>",1
+gnm,update.gnm,1,0,0,any,1
+gnm,update.gnm,2,0,0,...,1
+gnm,update.gnm,3,0,0,logical,1
+gnm,updateLinear,-1,0,0,double[],1
+gnm,updateLinear,0,0,0,integer[],1
+gnm,updateLinear,1,0,0,double[],1
+gnm,updateLinear,2,0,0,double[],1
+gnm,updateLinear,3,0,0,double[],1
+gnm,updateLinear,4,0,0,double[],1
+gnm,updateLinear,5,0,0,double[],1
+gnm,updateLinear,6,0,0,double[],1
+gnm,updateLinear,7,0,0,class<`family`>,1
+gnm,vcov.gnm,-1,0,0,class<`vcov.gnm`>,1
+gnm,vcov.gnm,0,0,0,"class<`glm`, `gnm`, `lm`>",1
+gnm,vcov.gnm,1,0,0,null,1
+gnm,vcov.gnm,2,0,0,any,1
+gnm,vcov.gnm,3,0,0,...,1
+gnm,weights.gnm,-1,0,0,class<`table`>,1
+gnm,weights.gnm,0,0,0,"class<`glm`, `gnm`, `lm`>",1
+gnm,weights.gnm,1,0,0,any,1
+gnm,weights.gnm,2,0,0,...,1
+goftest,ad.test,-1,0,0,class<`htest`>,1
+goftest,ad.test,0,0,0,double[],1
+goftest,ad.test,1,0,0,character,1
+goftest,ad.test,2,0,0,...,1
+goftest,ad.test,3,0,0,logical,1
+goftest,ad.test,4,0,0,any,1
+goftest,braun,-1,0,0,list<double | character>,1
+goftest,braun,0,0,0,double[],1
+goftest,braun,1,0,0,class<`function`>,1
+goftest,braun,2,0,0,double,1
+goftest,cvm.test,-1,0,0,class<`htest`>,1
+goftest,cvm.test,0,0,0,double[],1
+goftest,cvm.test,1,0,0,character,1
+goftest,cvm.test,2,0,0,...,1
+goftest,cvm.test,3,0,0,logical,1
+goftest,cvm.test,4,0,0,any,1
+goftest,getCdf,-1,0,0,class<`function`>,1
+goftest,getCdf,0,0,0,character,1
+goftest,getCdf,1,0,0,logical,1
+goftest,getfunky,-1,0,0,class<`function`>,1
+goftest,getfunky,0,0,0,character,1
+goftest,pAD,-1,0,0,double,1
+goftest,pAD,0,0,0,double,1
+goftest,pAD,1,0,0,any,1
+goftest,pAD,2,0,0,logical,1
+goftest,pAD,3,0,0,any,1
+goftest,pCvM,-1,0,0,double[],1
+goftest,pCvM,0,0,0,double[],1
+goftest,pCvM,1,0,0,double,1
+goftest,pCvM,2,0,0,logical,1
+goftest,qAD,-1,0,0,double,1
+goftest,qAD,0,0,0,double,1
+goftest,qAD,1,0,0,double,1
+goftest,qAD,2,0,0,logical,1
+goftest,qAD,3,0,0,logical,1
+goftest,qCvM,-1,0,0,double,1
+goftest,qCvM,0,0,0,double,1
+goftest,qCvM,1,0,0,double,1
+goftest,qCvM,2,0,0,logical,1
+goftest,recogniseCdf,-1,0,0,character,1
+goftest,recogniseCdf,0,0,0,character,1
+goftest,simpleADtest,-1,0,0,list<double | character>,1
+goftest,simpleADtest,0,0,0,double[],1
+goftest,simpleCvMtest,-1,0,0,list<double | character>,1
+goftest,simpleCvMtest,0,0,0,double[],1
+gridBase,badFIG,-1,0,0,logical,1
+gridBase,badFIG,0,0,0,list<double>,1
+gridBase,badFIG,1,0,0,double[],1
+gridBase,badFIG,2,0,0,double[],1
+gridBase,badFIG,3,0,0,double[],1
+gridBase,badOMI,-1,0,0,logical,1
+gridBase,badOMI,0,0,0,list<double>,1
+gridBase,badOMI,1,0,0,double[],1
+gridBase,badOMI,2,0,0,double[],1
+gridBase,baseViewports,-1,0,0,list<class<`viewport`>>,1
+gridBase,currentViewportLoc,-1,0,0,list<double>,1
+gridBase,gridFIG,-1,0,0,double[],1
+gridBase,gridOMI,-1,0,0,double[],1
+gridBase,gridPAR,-1,0,0,list<character | double>,1
+gridBase,gridPLT,-1,0,0,double[],1
+gridExtra,align_2,-1,0,0,"list<class<`gDesc`, `gTree`, `grob`, `gtable`>>",1
+gridExtra,align_2,0,0,0,"class<`gDesc`, `gTree`, `grob`, `gtable`>",1
+gridExtra,align_2,1,0,0,"class<`gDesc`, `gTree`, `grob`, `gtable`>",1
+gridExtra,align_2,2,0,0,double,1
+gridExtra,align_2,3,0,0,character,1
+gridExtra,arrangeGrob,-1,0,0,"class<`gDesc`, `gTree`, `grob`, `gtable`>",1
+gridExtra,arrangeGrob,0,0,0,...,1
+gridExtra,arrangeGrob,1,0,0,"list<class<`gDesc`, `grob`, `rect`>>",1
+gridExtra,arrangeGrob,1,0,1,"list<class<`gDesc`, `gTree`, `grob`>>",1
+gridExtra,arrangeGrob,1,0,2,"list<class<`gDesc`, `gTree`, `grob`, `gtable`>>",1
+gridExtra,arrangeGrob,2,0,0,any,1
+gridExtra,arrangeGrob,3,0,0,null,1
+gridExtra,arrangeGrob,4,0,0,character,1
+gridExtra,arrangeGrob,5,0,0,logical,1
+gridExtra,arrangeGrob,6,0,0,logical,1
+gridExtra,arrangeGrob,7,0,0,character,1
+gridExtra,arrangeGrob,8,0,0,double,1
+gridExtra,arrangeGrob,8,0,1,null,1
+gridExtra,arrangeGrob,9,0,0,null,1
+gridExtra,arrangeGrob,9,0,1,double,1
+gridExtra,arrangeGrob,10,0,0,null,1
+gridExtra,arrangeGrob,11,0,0,null,1
+gridExtra,arrangeGrob,12,0,0,null,1
+gridExtra,arrangeGrob,12,0,1,character,1
+gridExtra,arrangeGrob,13,0,0,null,1
+gridExtra,arrangeGrob,13,0,1,character,1
+gridExtra,arrangeGrob,14,0,0,null,1
+gridExtra,arrangeGrob,14,0,1,character,1
+gridExtra,arrangeGrob,15,0,0,null,1
+gridExtra,arrangeGrob,15,0,1,character,1
+gridExtra,cbind_2,-1,0,0,"class<`gDesc`, `gTree`, `grob`, `gtable`>",1
+gridExtra,cbind_2,0,0,0,"class<`gDesc`, `gTree`, `grob`, `gtable`>",1
+gridExtra,cbind_2,1,0,0,"class<`gDesc`, `gTree`, `grob`, `gtable`>",1
+gridExtra,cbind_2,2,0,0,character,1
+gridExtra,col_widths,-1,0,0,"class<`unit`, `unit.list`>",1
+gridExtra,col_widths,0,0,0,class<`matrix`>,1
+gridExtra,combine_2,-1,0,0,"class<`gDesc`, `gTree`, `grob`, `gtable`>",1
+gridExtra,combine_2,0,0,0,"class<`gDesc`, `gTree`, `grob`, `gtable`>",1
+gridExtra,combine_2,1,0,0,"class<`gDesc`, `gTree`, `grob`, `gtable`>",1
+gridExtra,combine_2,2,0,0,double,1
+gridExtra,combine_2,3,0,0,character,1
+gridExtra,%contains%,-1,0,0,logical,1
+gridExtra,%contains%,0,0,0,character[],1
+gridExtra,%contains%,1,0,0,character[],1
+gridExtra,ellipseGrob,-1,0,0,"class<`gDesc`, `grob`, `polygon`>",1
+gridExtra,ellipseGrob,0,0,0,"class<`unit`, `unit.arithmetic`>",1
+gridExtra,ellipseGrob,1,0,0,"class<`unit`, `unit.arithmetic`>",1
+gridExtra,ellipseGrob,2,0,0,double,1
+gridExtra,ellipseGrob,3,0,0,double[],1
+gridExtra,ellipseGrob,4,0,0,double,1
+gridExtra,ellipseGrob,5,0,0,double,1
+gridExtra,ellipseGrob,6,0,0,class<`gpar`>,1
+gridExtra,ellipseGrob,7,0,0,...,1
+gridExtra,ellipseGrob,8,0,0,character,1
+gridExtra,ellipseGrob,9,0,0,character,1
+gridExtra,grid.arrange,-1,0,0,"class<`gDesc`, `gTree`, `grob`, `gtable`>",1
+gridExtra,grid.arrange,0,0,0,...,1
+gridExtra,grid.arrange,1,0,0,logical,1
+gridExtra,grid.table,-1,0,0,null,1
+gridExtra,grid.table,0,0,0,...,1
+gridExtra,gtable_combine,-1,0,0,"class<`gDesc`, `gTree`, `grob`, `gtable`>",1
+gridExtra,gtable_combine,0,0,0,...,1
+gridExtra,gtable_combine,1,0,0,double,1
+gridExtra,gtable_combine,2,0,0,character,1
+gridExtra,gtable_reindex,-1,0,0,"class<`gDesc`, `gTree`, `grob`, `gtable`>",1
+gridExtra,gtable_reindex,0,0,0,"class<`gDesc`, `gTree`, `grob`, `gtable`>",1
+gridExtra,gtable_reindex,1,0,0,character[],1
+gridExtra,gtable_reindex,2,0,0,double,1
+gridExtra,gtable_table,-1,0,0,"class<`gDesc`, `gTree`, `grob`, `gtable`>",1
+gridExtra,gtable_table,0,0,0,character[],1
+gridExtra,gtable_table,0,0,1,class<`data.frame`>,1
+gridExtra,gtable_table,0,0,2,class<`matrix`>,1
+gridExtra,gtable_table,1,0,0,any,1
+gridExtra,gtable_table,2,0,0,any,1
+gridExtra,gtable_table,3,0,0,class<`function`>,1
+gridExtra,gtable_table,4,0,0,list<character | double>,1
+gridExtra,gtable_table,4,0,1,list<double | character[]>,1
+gridExtra,gtable_table,5,0,0,class<`function`>,1
+gridExtra,gtable_table,6,0,0,list<null>,1
+gridExtra,gtable_table,6,0,1,list<null | double | character>,1
+gridExtra,gtable_table,6,0,2,list<character[] | double[]>,1
+gridExtra,gtable_table,6,0,3,list<character[] | null>,1
+gridExtra,gtable_table,6,0,4,list<character[] | double>,1
+gridExtra,gtable_table,6,0,5,list<character | double>,1
+gridExtra,gtable_table,7,0,0,class<`unit`>,1
+gridExtra,gtable_table,8,0,0,character,1
+gridExtra,gtable_table,9,0,0,null,1
+gridExtra,insert.unit,-1,0,0,"class<`unit`, `unit.list`>",1
+gridExtra,insert.unit,0,0,0,"class<`unit`, `unit.arithmetic`>",1
+gridExtra,insert.unit,0,0,1,"class<`unit`, `unit.list`>",1
+gridExtra,insert.unit,1,0,0,"class<`unit`, `unit.arithmetic`>",1
+gridExtra,insert.unit,1,0,1,"class<`unit`, `unit.list`>",1
+gridExtra,insert.unit,2,0,0,integer,1
+gridExtra,ngonGrob,-1,0,0,"class<`gDesc`, `grob`, `polygon`>",1
+gridExtra,ngonGrob,0,0,0,"class<`unit`, `unit.arithmetic`>",1
+gridExtra,ngonGrob,1,0,0,"class<`unit`, `unit.arithmetic`>",1
+gridExtra,ngonGrob,2,0,0,double[],1
+gridExtra,ngonGrob,3,0,0,double[],1
+gridExtra,ngonGrob,4,0,0,double,1
+gridExtra,ngonGrob,5,0,0,double[],1
+gridExtra,ngonGrob,6,0,0,integer[],1
+gridExtra,ngonGrob,6,0,1,double,1
+gridExtra,ngonGrob,7,0,0,class<`gpar`>,1
+gridExtra,ngonGrob,8,0,0,...,1
+gridExtra,ngonGrob,9,0,0,character,1
+gridExtra,ngonGrob,10,0,0,character,1
+gridExtra,polygon_regular,-1,0,0,class<`matrix`>,1
+gridExtra,polygon_regular,0,0,0,double,1
+gridExtra,polygon_regular,1,0,0,double,1
+gridExtra,rbind_2,-1,0,0,"class<`gDesc`, `gTree`, `grob`, `gtable`>",1
+gridExtra,rbind_2,0,0,0,"class<`gDesc`, `gTree`, `grob`, `gtable`>",1
+gridExtra,rbind_2,1,0,0,"class<`gDesc`, `gTree`, `grob`, `gtable`>",1
+gridExtra,rbind_2,2,0,0,character,1
+gridExtra,rep_along,-1,0,0,class<`unit`>,1
+gridExtra,rep_along,0,0,0,class<`unit`>,1
+gridExtra,rep_along,1,0,0,character,1
+gridExtra,row_heights,-1,0,0,"class<`unit`, `unit.list`>",1
+gridExtra,row_heights,0,0,0,class<`matrix`>,1
+gridExtra,tableGrob,-1,0,0,"class<`gDesc`, `gTree`, `grob`, `gtable`>",1
+gridExtra,tableGrob,0,0,0,class<`data.frame`>,1
+gridExtra,tableGrob,1,0,0,character[],1
+gridExtra,tableGrob,1,0,1,null,1
+gridExtra,tableGrob,2,0,0,character[],1
+gridExtra,tableGrob,2,0,1,null,1
+gridExtra,tableGrob,3,0,0,list<list<class<`function`> | class<`unit`> | list<double | character[] | character[] | double[]> | class<`function`> | class<`unit`> | list<character | double> | class<`function`> | class<`unit`> | list<character | double | null | double | character>>>,1
+gridExtra,tableGrob,3,0,1,list<list<class<`function`> | class<`unit`> | list<character | double | character[] | null> | class<`function`> | class<`unit`> | list<character | double | null>>>,1
+gridExtra,tableGrob,3,0,2,list<list<class<`function`> | class<`unit`> | list<character | double | character[] | double> | class<`function`> | class<`unit`> | list<character | double> | class<`function`> | class<`unit`> | list<character | double | null | double | character>>>,1
+gridExtra,tableGrob,3,0,3,list<list<class<`function`> | class<`unit`> | list<character | double | null>>>,1
+gridExtra,tableGrob,4,0,0,null,1
+gridExtra,tableGrob,5,0,0,...,1
+gridExtra,ttheme_default,-1,0,0,list<list<class<`function`> | class<`unit`> | list<double | character[] | character[] | double[]> | class<`function`> | class<`unit`> | list<character | double> | class<`function`> | class<`unit`> | list<character | double | null | double | character>>>,1
+gridExtra,ttheme_default,-1,0,1,list<list<class<`function`> | class<`unit`> | list<character | double | character[] | double> | class<`function`> | class<`unit`> | list<character | double> | class<`function`> | class<`unit`> | list<character | double | null | double | character>>>,1
+gridExtra,ttheme_default,0,0,0,double,1
+gridExtra,ttheme_default,1,0,0,character,1
+gridExtra,ttheme_default,2,0,0,character,1
+gridExtra,ttheme_default,3,0,0,logical,1
+gridExtra,ttheme_default,4,0,0,class<`unit`>,1
+gridExtra,ttheme_default,5,0,0,...,1
+gridExtra,ttheme_minimal,-1,0,0,list<list<class<`function`> | class<`unit`> | list<character | double | character[] | null> | class<`function`> | class<`unit`> | list<character | double | null>>>,1
+gridExtra,ttheme_minimal,-1,0,1,list<list<class<`function`> | class<`unit`> | list<character | double | null>>>,1
+gridExtra,ttheme_minimal,0,0,0,double,1
+gridExtra,ttheme_minimal,1,0,0,character,1
+gridExtra,ttheme_minimal,2,0,0,character,1
+gridExtra,ttheme_minimal,3,0,0,logical,1
+gridExtra,ttheme_minimal,4,0,0,class<`unit`>,1
+gridExtra,ttheme_minimal,5,0,0,...,1
+gsubfn,as.function.formula,-1,0,0,class<`function`>,1
+gsubfn,as.function.formula,0,0,0,class<`formula`>,1
+gsubfn,as.function.formula,1,0,0,...,1
+gsubfn,$.fn,-1,0,0,class<`function`>,1
+gsubfn,$.fn,0,0,0,class<`fn`>,1
+gsubfn,$.fn,1,0,0,character,1
+gsubfn,gsubfn,-1,0,0,character[],1
+gsubfn,gsubfn,0,0,0,any,1
+gsubfn,gsubfn,1,0,0,any,1
+gsubfn,gsubfn,2,0,0,character[],1
+gsubfn,gsubfn,3,0,0,any,1
+gsubfn,gsubfn,4,0,0,logical,1
+gsubfn,gsubfn,5,0,0,logical,1
+gsubfn,gsubfn,6,0,0,null,1
+gsubfn,gsubfn,6,0,1,character,1
+gsubfn,gsubfn,7,0,0,environment,1
+gsubfn,match.funfn,-1,0,0,class<`function`>,1
+gsubfn,match.funfn,-1,0,1,class<`protoMethod`>,1
+gsubfn,match.funfn,0,0,0,character,1
+gsubfn,match.funfn,0,0,1,class<`formula`>,1
+gsubfn,match.funfn,0,0,2,class<`function`>,1
+gsubfn,match.funfn,0,0,3,class<`result`>,1
+gsubfn,match.funfn,0,0,4,class<`protoMethod`>,1
+gsubfn,match.funfn,1,0,0,logical,1
+gsubfn,ostrapply,-1,0,0,class<`matrix`>,1
+gsubfn,ostrapply,-1,0,1,list<character[]>,1
+gsubfn,ostrapply,0,0,0,character[],1
+gsubfn,ostrapply,1,0,0,character,1
+gsubfn,ostrapply,2,0,0,"class<`environment`, `proto`>",1
+gsubfn,ostrapply,2,0,1,class<`function`>,1
+gsubfn,ostrapply,3,0,0,logical,1
+gsubfn,ostrapply,4,0,0,...,1
+gsubfn,ostrapply,5,0,0,any,1
+gsubfn,ostrapply,6,0,0,class<`formula`>,1
+gsubfn,ostrapply,6,0,1,logical,1
+gsubfn,ostrapply,7,0,0,logical,1
+gsubfn,read.pattern,-1,0,0,class<`data.frame`>,1
+gsubfn,read.pattern,0,0,0,any,1
+gsubfn,read.pattern,1,0,0,character,1
+gsubfn,read.pattern,2,0,0,logical,1
+gsubfn,read.pattern,3,0,0,character,1
+gsubfn,read.pattern,4,0,0,character,1
+gsubfn,read.pattern,5,0,0,character,1
+gsubfn,read.pattern,6,0,0,...,1
+gsubfn,[<-.result,-1,0,0,class<`result`>,1
+gsubfn,[<-.result,0,0,0,class<`result`>,1
+gsubfn,[<-.result,1,0,0,...,1
+gsubfn,[<-.result,2,0,0,class<`eigen`>,1
+gsubfn,[<-.result,2,0,1,class<`lm`>,1
+gsubfn,[<-.result,2,0,2,class<`matrix`>,1
+gsubfn,[<-.result,2,0,3,class<`qr`>,1
+gsubfn,[<-.result,2,0,4,list<double>,1
+gsubfn,strapply,-1,0,0,character[],1
+gsubfn,strapply,-1,0,1,class<`matrix`>,1
+gsubfn,strapply,-1,0,2,list<character[]>,1
+gsubfn,strapply,-1,0,3,list<list<character[]>>,1
+gsubfn,strapply,0,0,0,character[],1
+gsubfn,strapply,1,0,0,character,1
+gsubfn,strapply,2,0,0,class<`function`>,1
+gsubfn,strapply,2,0,1,class<`result`>,1
+gsubfn,strapply,2,0,2,"class<`environment`, `proto`>",1
+gsubfn,strapply,3,0,0,any,1
+gsubfn,strapply,4,0,0,...,1
+gsubfn,strapply,5,0,0,any,1
+gsubfn,strapply,6,0,0,logical,1
+gsubfn,strapply,7,0,0,logical,1
+gsubfn,strapply1,-1,0,0,class<`matrix`>,1
+gsubfn,strapply1,0,0,0,character,1
+gsubfn,strapply1,1,0,0,character,1
+gsubfn,strapply1,2,0,0,null,1
+gsubfn,strapply1,3,0,0,logical,1
+gsubfn,strapplyc,-1,0,0,list<character[]>,1
+gsubfn,strapplyc,0,0,0,character[],1
+gsubfn,strapplyc,1,0,0,character,1
+gsubfn,strapplyc,2,0,0,null,1
+gsubfn,strapplyc,3,0,0,logical,1
+gsubfn,strapplyc,4,0,0,logical,1
+gsubfn,strapplyc,5,0,0,any,1
+gsubfn,strapplyc,6,0,0,any,1
+gsubfn,tclList2R,-1,0,0,list<character[]>,1
+gsubfn,tclList2R,0,0,0,character,1
+gsubfn,tclList2R,1,0,0,class<`function`>,1
+gsubfn,transform2,-1,0,0,class<`data.frame`>,1
+gsubfn,transform2,0,0,0,any,1
+gsubfn,transform2,1,0,0,...,1
+gtable,%||%,-1,0,0,class<`unit`>,1
+gtable,%||%,0,0,0,null,1
+gtable,%||%,1,0,0,class<`unit`>,1
+gtable,cbind_gtable,-1,0,0,any,1
+gtable,cbind_gtable,0,0,0,"class<`gDesc`, `gTree`, `grob`, `gtable`>",1
+gtable,cbind_gtable,1,0,0,"class<`gDesc`, `gTree`, `grob`, `gtable`>",1
+gtable,cbind_gtable,2,0,0,any,1
+gtable,compare_unit,-1,0,0,class<`unit`>,1
+gtable,compare_unit,0,0,0,class<`unit`>,1
+gtable,compare_unit,1,0,0,class<`unit`>,1
+gtable,compare_unit,2,0,0,class<`function`>,1
+gtable,dim.gtable,-1,0,0,integer[],1
+gtable,dim.gtable,0,0,0,"class<`gDesc`, `gTree`, `grob`, `gtable`>",1
+gtable,dimnames<-.gtable,-1,0,0,"class<`gDesc`, `gTree`, `grob`, `gtable`>",1
+gtable,dimnames<-.gtable,0,0,0,"class<`gDesc`, `gTree`, `grob`, `gtable`>",1
+gtable,dimnames<-.gtable,1,0,0,list<double[] | character[]>,1
+gtable,dimnames<-.gtable,1,0,1,list<double[] | null>,1
+gtable,dimnames<-.gtable,1,0,2,list<integer[] | null>,1
+gtable,dimnames.gtable,-1,0,0,list<double[] | character[]>,1
+gtable,dimnames.gtable,-1,0,1,list<double[] | null>,1
+gtable,dimnames.gtable,-1,0,2,list<integer[] | null>,1
+gtable,dimnames.gtable,-1,0,3,list<null>,1
+gtable,dimnames.gtable,0,0,0,"class<`gDesc`, `gTree`, `grob`, `gtable`>",1
+gtable,dimnames.gtable,1,0,0,...,1
+gtable,gtable,-1,0,0,"class<`gDesc`, `gTree`, `grob`, `gtable`>",1
+gtable,gtable,0,0,0,class<`unit`>,1
+gtable,gtable,1,0,0,class<`unit`>,1
+gtable,gtable,2,0,0,logical,1
+gtable,gtable,3,0,0,character,1
+gtable,gtable,4,0,0,null,1
+gtable,gtable,5,0,0,null,1
+gtable,gtable,6,0,0,null,1
+gtable,[.gtable,-1,0,0,"class<`gDesc`, `gTree`, `grob`, `gtable`>",1
+gtable,[.gtable,0,0,0,"class<`gDesc`, `gTree`, `grob`, `gtable`>",1
+gtable,[.gtable,1,0,0,any,1
+gtable,[.gtable,2,0,0,any,1
+gtable,gtable_add_cols,-1,0,0,"class<`gDesc`, `gTree`, `grob`, `gtable`>",1
+gtable,gtable_add_cols,0,0,0,"class<`gDesc`, `gTree`, `grob`, `gtable`>",1
+gtable,gtable_add_cols,1,0,0,class<`unit`>,1
+gtable,gtable_add_cols,2,0,0,double,1
+gtable,gtable_add_col_space,-1,0,0,"class<`gDesc`, `gTree`, `grob`, `gtable`>",1
+gtable,gtable_add_col_space,0,0,0,"class<`gDesc`, `gTree`, `grob`, `gtable`>",1
+gtable,gtable_add_col_space,1,0,0,class<`unit`>,1
+gtable,gtable_add_grob,-1,0,0,"class<`gDesc`, `gTree`, `grob`, `gtable`>",1
+gtable,gtable_add_grob,0,0,0,"class<`gDesc`, `gTree`, `grob`, `gtable`>",1
+gtable,gtable_add_grob,1,0,0,"class<`circle`, `gDesc`, `grob`>",1
+gtable,gtable_add_grob,1,0,1,"class<`gDesc`, `grob`, `points`>",1
+gtable,gtable_add_grob,1,0,2,"class<`gDesc`, `grob`, `rect`>",1
+gtable,gtable_add_grob,1,0,3,class<`matrix`>,1
+gtable,gtable_add_grob,1,0,4,"list<class<`gDesc`, `grob`, `rect`> | class<`circle`, `gDesc`, `grob`> | class<`gDesc`, `grob`, `lines`>>",1
+gtable,gtable_add_grob,2,0,0,double,1
+gtable,gtable_add_grob,2,0,1,integer[],1
+gtable,gtable_add_grob,3,0,0,double,1
+gtable,gtable_add_grob,3,0,1,integer[],1
+gtable,gtable_add_grob,4,0,0,double,1
+gtable,gtable_add_grob,4,0,1,integer[],1
+gtable,gtable_add_grob,5,0,0,double,1
+gtable,gtable_add_grob,5,0,1,integer[],1
+gtable,gtable_add_grob,6,0,0,double[],1
+gtable,gtable_add_grob,7,0,0,character,1
+gtable,gtable_add_grob,8,0,0,character,1
+gtable,gtable_add_padding,-1,0,0,"class<`gDesc`, `gTree`, `grob`, `gtable`>",1
+gtable,gtable_add_padding,0,0,0,"class<`gDesc`, `gTree`, `grob`, `gtable`>",1
+gtable,gtable_add_padding,1,0,0,class<`unit`>,1
+gtable,gtable_add_rows,-1,0,0,"class<`gDesc`, `gTree`, `grob`, `gtable`>",1
+gtable,gtable_add_rows,0,0,0,"class<`gDesc`, `gTree`, `grob`, `gtable`>",1
+gtable,gtable_add_rows,1,0,0,class<`unit`>,1
+gtable,gtable_add_rows,2,0,0,double,1
+gtable,gtable_add_row_space,-1,0,0,"class<`gDesc`, `gTree`, `grob`, `gtable`>",1
+gtable,gtable_add_row_space,0,0,0,"class<`gDesc`, `gTree`, `grob`, `gtable`>",1
+gtable,gtable_add_row_space,1,0,0,class<`unit`>,1
+gtable,gtable_col,-1,0,0,"class<`gDesc`, `gTree`, `grob`, `gtable`>",1
+gtable,gtable_col,0,0,0,character,1
+gtable,gtable_col,1,0,0,"list<class<`gDesc`, `grob`, `rect`> | class<`circle`, `gDesc`, `grob`> | class<`gDesc`, `grob`, `lines`>>",1
+gtable,gtable_col,2,0,0,null,1
+gtable,gtable_col,3,0,0,null,1
+gtable,gtable_col,4,0,0,null,1
+gtable,gtable_col,5,0,0,null,1
+gtable,gtable_filter,-1,0,0,"class<`gDesc`, `gTree`, `grob`, `gtable`>",1
+gtable,gtable_filter,0,0,0,"class<`gDesc`, `gTree`, `grob`, `gtable`>",1
+gtable,gtable_filter,1,0,0,character,1
+gtable,gtable_filter,2,0,0,logical,1
+gtable,gtable_filter,3,0,0,logical,1
+gtable,gtable_filter,4,0,0,logical,1
+gtable,gtable_layout,-1,0,0,class<`layout`>,1
+gtable,gtable_layout,0,0,0,"class<`gDesc`, `gTree`, `grob`, `gtable`>",1
+gtable,gtable_matrix,-1,0,0,"class<`gDesc`, `gTree`, `grob`, `gtable`>",1
+gtable,gtable_matrix,0,0,0,character,1
+gtable,gtable_matrix,1,0,0,class<`matrix`>,1
+gtable,gtable_matrix,2,0,0,class<`unit`>,1
+gtable,gtable_matrix,3,0,0,class<`unit`>,1
+gtable,gtable_matrix,4,0,0,class<`matrix`>,1
+gtable,gtable_matrix,4,0,1,null,1
+gtable,gtable_matrix,5,0,0,logical,1
+gtable,gtable_matrix,6,0,0,character,1
+gtable,gtable_matrix,7,0,0,null,1
+gtable,gtable_row,-1,0,0,"class<`gDesc`, `gTree`, `grob`, `gtable`>",1
+gtable,gtable_row,0,0,0,character,1
+gtable,gtable_row,1,0,0,"list<class<`gDesc`, `grob`, `rect`> | class<`circle`, `gDesc`, `grob`> | class<`gDesc`, `grob`, `lines`>>",1
+gtable,gtable_row,2,0,0,null,1
+gtable,gtable_row,3,0,0,null,1
+gtable,gtable_row,4,0,0,null,1
+gtable,gtable_row,5,0,0,null,1
+gtable,gtable_show_layout,-1,0,0,class<`viewport`>,1
+gtable,gtable_show_layout,0,0,0,"class<`gDesc`, `gTree`, `grob`, `gtable`>",1
+gtable,gtable_show_layout,1,0,0,...,1
+gtable,gtable_trim,-1,0,0,"class<`gDesc`, `gTree`, `grob`, `gtable`>",1
+gtable,gtable_trim,0,0,0,"class<`gDesc`, `gTree`, `grob`, `gtable`>",1
+gtable,insert.unit,-1,0,0,class<`unit`>,1
+gtable,insert.unit,0,0,0,class<`unit`>,1
+gtable,insert.unit,1,0,0,class<`unit`>,1
+gtable,insert.unit,2,0,0,double,1
+gtable,is.gtable,-1,0,0,logical,1
+gtable,is.gtable,0,0,0,"class<`gDesc`, `gTree`, `grob`, `gtable`>",1
+gtable,length.gtable,-1,0,0,integer,1
+gtable,length.gtable,0,0,0,"class<`gDesc`, `gTree`, `grob`, `gtable`>",1
+gtable,makeContent.gtable,-1,0,0,"class<`gDesc`, `gTree`, `grob`, `gtable`>",1
+gtable,makeContent.gtable,0,0,0,"class<`gDesc`, `gTree`, `grob`, `gtable`>",1
+gtable,makeContext.gtable,-1,0,0,"class<`gDesc`, `gTree`, `grob`, `gtable`>",1
+gtable,makeContext.gtable,0,0,0,"class<`gDesc`, `gTree`, `grob`, `gtable`>",1
+gtable,makeContext.gTableChild,-1,0,0,"class<`circle`, `gDesc`, `gTableChild`, `grob`>",1
+gtable,makeContext.gTableChild,-1,0,1,"class<`gDesc`, `gTableChild`, `grob`, `lines`>",1
+gtable,makeContext.gTableChild,-1,0,2,"class<`gDesc`, `gTableChild`, `grob`, `null`>",1
+gtable,makeContext.gTableChild,-1,0,3,"class<`gDesc`, `gTableChild`, `grob`, `points`>",1
+gtable,makeContext.gTableChild,-1,0,4,"class<`gDesc`, `gTableChild`, `grob`, `rect`>",1
+gtable,makeContext.gTableChild,0,0,0,"class<`circle`, `gDesc`, `gTableChild`, `grob`>",1
+gtable,makeContext.gTableChild,0,0,1,"class<`gDesc`, `gTableChild`, `grob`, `lines`>",1
+gtable,makeContext.gTableChild,0,0,2,"class<`gDesc`, `gTableChild`, `grob`, `null`>",1
+gtable,makeContext.gTableChild,0,0,3,"class<`gDesc`, `gTableChild`, `grob`, `points`>",1
+gtable,makeContext.gTableChild,0,0,4,"class<`gDesc`, `gTableChild`, `grob`, `rect`>",1
+gtable,neg_to_pos,-1,0,0,double,1
+gtable,neg_to_pos,-1,0,1,integer[],1
+gtable,neg_to_pos,0,0,0,double,1
+gtable,neg_to_pos,0,0,1,integer[],1
+gtable,neg_to_pos,1,0,0,any,1
+gtable,new_data_frame,-1,0,0,class<`data.frame`>,1
+gtable,new_data_frame,0,0,0,list<double[] | character[]>,1
+gtable,new_data_frame,0,0,1,list<double | character>,1
+gtable,new_data_frame,1,0,0,double,1
+gtable,new_data_frame,1,0,1,null,1
+gtable,plot.gtable,-1,0,0,null,1
+gtable,plot.gtable,0,0,0,"class<`gDesc`, `gTree`, `grob`, `gtable`>",1
+gtable,plot.gtable,1,0,0,...,1
+gtable,rbind_gtable,-1,0,0,"class<`gDesc`, `gTree`, `grob`, `gtable`>",1
+gtable,rbind_gtable,0,0,0,"class<`gDesc`, `gTree`, `grob`, `gtable`>",1
+gtable,rbind_gtable,1,0,0,"class<`gDesc`, `gTree`, `grob`, `gtable`>",1
+gtable,rbind_gtable,2,0,0,character,1
+gtable,t.gtable,-1,0,0,"class<`gDesc`, `gTree`, `grob`, `gtable`>",1
+gtable,t.gtable,0,0,0,"class<`gDesc`, `gTree`, `grob`, `gtable`>",1
+gtable,vpname,-1,0,0,character[],1
+gtable,vpname,0,0,0,class<`data.frame`>,1
+gtools,asc,-1,0,0,class<`matrix`>,1
+gtools,asc,-1,0,1,integer[],1
+gtools,asc,-1,0,2,list<integer[]>,1
+gtools,asc,0,0,0,character[],1
+gtools,asc,1,0,0,logical,1
+gtools,ASCIIfy,-1,0,0,character[],1
+gtools,ASCIIfy,0,0,0,character[],1
+gtools,ASCIIfy,1,0,0,double,1
+gtools,ASCIIfy,2,0,0,any,1
+gtools,ask,-1,0,0,character[],1
+gtools,ask,0,0,0,character,1
+gtools,ask,1,0,0,"class<`connection`, `terminal`>",1
+gtools,baseOf,-1,0,0,class<`matrix`>,1
+gtools,baseOf,-1,0,1,double[],1
+gtools,baseOf,0,0,0,double[],1
+gtools,baseOf,1,0,0,double,1
+gtools,baseOf,2,0,0,double,1
+gtools,baseOf.inner,-1,0,0,double[],1
+gtools,baseOf.inner,0,0,0,double,1
+gtools,baseOf.inner,1,0,0,any,1
+gtools,baseOf.inner,2,0,0,double,1
+gtools,binsearch,-1,0,0,list<class<`call`> | character | double[]>,1
+gtools,binsearch,-1,0,1,list<class<`call`> | double | character>,1
+gtools,binsearch,0,0,0,class<`function`>,1
+gtools,binsearch,1,0,0,double[],1
+gtools,binsearch,2,0,0,...,1
+gtools,binsearch,3,0,0,double,1
+gtools,binsearch,4,0,0,double,1
+gtools,binsearch,5,0,0,double,1
+gtools,binsearch,6,0,0,double,1
+gtools,binsearch,7,0,0,logical,1
+gtools,capwords,-1,0,0,character,1
+gtools,capwords,0,0,0,character,1
+gtools,capwords,1,0,0,logical,1
+gtools,capwords,2,0,0,logical,1
+gtools,capwords,3,0,0,logical,1
+gtools,capwords,4,0,0,logical,1
+gtools,capwords,5,0,0,character,1
+gtools,checkRVersion,-1,0,0,class<`numeric_version`>,1
+gtools,checkRVersion,0,0,0,logical,1
+gtools,chr,-1,0,0,character[],1
+gtools,chr,0,0,0,class<`matrix`>,1
+gtools,chr,0,0,1,integer[],1
+gtools,chr,0,0,2,list<integer[]>,1
+gtools,.clean_up_dependencies2,-1,0,0,list<character[]>,1
+gtools,.clean_up_dependencies2,0,0,0,character[],1
+gtools,.clean_up_dependencies2,1,0,0,class<`matrix`>,1
+gtools,.clean_up_dependencies2,2,0,0,any,1
+gtools,combinations,-1,0,0,class<`matrix`>,1
+gtools,combinations,0,0,0,double,1
+gtools,combinations,1,0,0,double,1
+gtools,combinations,2,0,0,character[],1
+gtools,combinations,2,0,1,integer[],1
+gtools,combinations,3,0,0,logical,1
+gtools,combinations,4,0,0,logical,1
+gtools,ddirichlet,-1,0,0,double[],1
+gtools,ddirichlet,0,0,0,class<`matrix`>,1
+gtools,ddirichlet,0,0,1,double[],1
+gtools,ddirichlet,1,0,0,double[],1
+gtools,defmacro,-1,0,0,class<`function`>,1
+gtools,defmacro,0,0,0,...,1
+gtools,defmacro,1,0,0,any,1
+gtools,even,-1,0,0,logical[],1
+gtools,even,0,0,0,integer[],1
+gtools,even,0,0,1,double,1
+gtools,foldchange,-1,0,0,double[],1
+gtools,foldchange,0,0,0,integer[],1
+gtools,foldchange,1,0,0,integer[],1
+gtools,getDependencies,-1,0,0,character[],1
+gtools,getDependencies,0,0,0,character,1
+gtools,getDependencies,1,0,0,character[],1
+gtools,getDependencies,2,0,0,logical,1
+gtools,getDependencies,3,0,0,logical,1
+gtools,getDependencies,4,0,0,logical,1
+gtools,getDependencies,5,0,0,logical,1
+gtools,invalid,-1,0,0,logical,1
+gtools,invalid,0,0,0,any,1
+gtools,inv.logit,-1,0,0,double[],1
+gtools,inv.logit,0,0,0,double[],1
+gtools,inv.logit,1,0,0,double,1
+gtools,inv.logit,2,0,0,double,1
+gtools,keywords,-1,0,0,character[],1
+gtools,keywords,-1,0,1,null,1
+gtools,keywords,0,0,0,any,1
+gtools,lastAdd,-1,0,0,class<`function`>,1
+gtools,lastAdd,0,0,0,class<`function`>,1
+gtools,loadedPackages,-1,0,0,class<`data.frame`>,1
+gtools,loadedPackages,0,0,0,logical,1
+gtools,logit,-1,0,0,double[],1
+gtools,logit,0,0,0,double[],1
+gtools,logit,1,0,0,double,1
+gtools,logit,2,0,0,double,1
+gtools,mixedorder,-1,0,0,integer[],1
+gtools,mixedorder,0,0,0,^character[],1
+gtools,mixedorder,1,0,0,logical,1
+gtools,mixedorder,2,0,0,any,1
+gtools,mixedorder,3,0,0,any,1
+gtools,mixedorder,4,0,0,character[],1
+gtools,mixedorder,5,0,0,character[],1
+gtools,mixedsort,-1,0,0,^character[],1
+gtools,mixedsort,0,0,0,^character[],1
+gtools,mixedsort,1,0,0,logical,1
+gtools,mixedsort,2,0,0,logical,1
+gtools,mixedsort,3,0,0,logical,1
+gtools,mixedsort,4,0,0,character[],1
+gtools,mixedsort,5,0,0,character[],1
+gtools,na.replace,-1,0,0,character[],1
+gtools,na.replace,-1,0,1,double[],1
+gtools,na.replace,0,0,0,^double[],1
+gtools,na.replace,1,0,0,character,1
+gtools,na.replace,1,0,1,class<`function`>,1
+gtools,na.replace,2,0,0,...,1
+gtools,odd,-1,0,0,logical[],1
+gtools,odd,0,0,0,integer[],1
+gtools,odd,0,0,1,double,1
+gtools,permutations,-1,0,0,class<`matrix`>,1
+gtools,permutations,0,0,0,double,1
+gtools,permutations,1,0,0,double,1
+gtools,permutations,2,0,0,character[],1
+gtools,permutations,3,0,0,logical,1
+gtools,permutations,4,0,0,logical,1
+gtools,permute,-1,0,0,integer[],1
+gtools,permute,0,0,0,integer[],1
+gtools,quantcut,-1,0,0,class<`factor`>,1
+gtools,quantcut,0,0,0,double[],1
+gtools,quantcut,1,0,0,double[],1
+gtools,quantcut,2,0,0,logical,1
+gtools,quantcut,3,0,0,...,1
+gtools,rdirichlet,-1,0,0,class<`matrix`>,1
+gtools,rdirichlet,0,0,0,double,1
+gtools,rdirichlet,1,0,0,double[],1
+gtools,roman2int,-1,0,0,^integer[],1
+gtools,roman2int,0,0,0,character[],1
+gtools,roman2int.inner,-1,0,0,any,1
+gtools,roman2int.inner,0,0,0,character,1
+gtools,running,-1,0,0,class<`matrix`>,1
+gtools,running,-1,0,1,^double[],1
+gtools,running,-1,0,2,list<integer[]>,1
+gtools,running,0,0,0,double[],1
+gtools,running,1,0,0,null,1
+gtools,running,1,0,1,double[],1
+gtools,running,2,0,0,class<`function`>,1
+gtools,running,3,0,0,double,1
+gtools,running,4,0,0,logical,1
+gtools,running,5,0,0,logical,1
+gtools,running,6,0,0,character[],1
+gtools,running,7,0,0,logical,1
+gtools,running,8,0,0,any,1
+gtools,running,9,0,0,...,1
+gtools,scat,-1,0,0,null,1
+gtools,scat,0,0,0,...,1
+gtools,setTCPNoDelay,-1,0,0,character,1
+gtools,setTCPNoDelay,0,0,0,class<`socket`>,1
+gtools,setTCPNoDelay,1,0,0,logical,1
+gtools,smartbind,-1,0,0,class<`data.frame`>,1
+gtools,smartbind,0,0,0,...,1
+gtools,smartbind,1,0,0,any,1
+gtools,smartbind,2,0,0,null,1
+gtools,smartbind,2,0,1,double,1
+gtools,smartbind,3,0,0,character,1
+gtools,smartbind,4,0,0,logical,1
+gtools,stars.pval,-1,0,0,character[],1
+gtools,stars.pval,0,0,0,double[],1
+gtools,strmacro,-1,0,0,class<`function`>,1
+gtools,strmacro,0,0,0,...,1
+gtools,strmacro,1,0,0,any,1
+gtools,strmacro,2,0,0,any,1
+hash,as.list.hash,-1,0,0,list<double>,1
+hash,as.list.hash,0,0,0,class<`hash`>,1
+hash,as.list.hash,1,0,0,logical,1
+hash,as.list.hash,2,0,0,...,1
+hash,clear,-1,0,0,null,1
+hash,clear,0,0,0,class<`hash`>,1
+hash,clear,-1,1,0,null,1
+hash,clear,0,1,0,class<`hash`>,1
+hash,copy,-1,0,0,class<`hash`>,1
+hash,copy,0,0,0,class<`hash`>,1
+hash,copy,1,0,0,...,1
+hash,copy,-1,1,0,class<`hash`>,1
+hash,copy,0,1,0,class<`hash`>,1
+hash,copy,1,1,0,...,1
+hash,del,-1,0,0,null,1
+hash,del,0,0,0,character,1
+hash,del,1,0,0,class<`hash`>,1
+hash,del,-1,1,0,null,1
+hash,del,0,1,0,character,1
+hash,del,1,1,0,class<`hash`>,1
+hash,hash,-1,0,0,class<`hash`>,1
+hash,hash,0,0,0,...,1
+hash,has.key,-1,0,0,logical[],1
+hash,has.key,0,0,0,character[],1
+hash,has.key,1,0,0,class<`hash`>,1
+hash,has.key,2,0,0,...,1
+hash,has.key,-1,1,0,logical[],1
+hash,has.key,0,1,0,character[],1
+hash,has.key,1,1,0,class<`hash`>,1
+hash,has.key,2,1,0,...,1
+hash,invert,-1,0,0,class<`hash`>,1
+hash,invert,0,0,0,class<`hash`>,1
+hash,invert,-1,1,0,class<`hash`>,1
+hash,invert,0,1,0,class<`hash`>,1
+hash,inverted.hash,-1,0,0,class<`hash`>,1
+hash,inverted.hash,0,0,0,...,1
+hash,is.empty,-1,0,0,logical,1
+hash,is.empty,0,0,0,class<`hash`>,1
+hash,is.hash,-1,0,0,logical,1
+hash,is.hash,0,0,0,class<`hash`>,1
+hash,keys,-1,0,0,character[],1
+hash,keys,0,0,0,class<`hash`>,1
+hash,keys,-1,1,0,character[],1
+hash,keys,0,1,0,class<`hash`>,1
+hash,make.keys,-1,0,0,character[],1
+hash,make.keys,0,0,0,character[],1
+hash,make.keys,0,0,1,double[],1
+hash,names.hash,-1,0,0,character[],1
+hash,names.hash,0,0,0,class<`hash`>,1
+hash,.set,-1,0,0,null,1
+hash,.set,0,0,0,class<`hash`>,1
+hash,.set,1,0,0,...,1
+hash,values,-1,0,0,character[],1
+hash,values,-1,0,1,integer[],1
+hash,values,-1,0,2,list<integer>,1
+hash,values,0,0,0,class<`hash`>,1
+hash,values,1,0,0,...,1
+hash,values,-1,1,0,character[],1
+hash,values,-1,1,1,integer[],1
+hash,values,-1,1,2,list<integer>,1
+hash,values,0,1,0,class<`hash`>,1
+hash,values,1,1,0,...,1
+hash,values<-,-1,0,0,class<`hash`>,1
+hash,values<-,0,0,0,class<`hash`>,1
+hash,values<-,1,0,0,...,1
+hash,values<-,2,0,0,character[],1
+hash,values<-,2,0,1,integer[],1
+hash,values<-,-1,1,0,class<`hash`>,1
+hash,values<-,0,1,0,class<`hash`>,1
+hash,values<-,1,1,0,...,1
+hash,values<-,2,1,0,character[],1
+hash,values<-,2,1,1,integer[],1
+hms,as_hms,-1,0,0,"class<`difftime`, `hms`>",1
+hms,as_hms,0,0,0,character,1
+hms,as_hms,0,0,1,class<`difftime`>,1
+hms,as_hms,0,0,2,"class<`POSIXct`, `POSIXt`>",1
+hms,as_hms,0,0,3,double,1
+hms,as.POSIXct.hms,-1,0,0,"class<`POSIXct`, `POSIXt`>",1
+hms,as.POSIXct.hms,0,0,0,"class<`difftime`, `hms`>",1
+hms,as.POSIXct.hms,1,0,0,...,1
+hms,check_args,-1,0,0,null,1
+hms,check_args,0,0,0,list<double | null>,1
+hms,check_args,0,0,1,list<null | integer[]>,1
+hms,check_args,0,0,2,list<null>,1
+hms,hms,-1,0,0,"class<`difftime`, `hms`>",1
+hms,hms,0,0,0,double,1
+hms,hms,0,0,1,null,1
+hms,hms,1,0,0,double,1
+hms,hms,1,0,1,null,1
+hms,hms,2,0,0,double,1
+hms,hms,2,0,1,null,1
+hms,hms,2,0,2,integer[],1
+hms,hms,3,0,0,null,1
+hms,map2,-1,0,0,list<double[]>,1
+hms,map2,0,0,0,list<null | integer[]>,1
+hms,map2,0,0,1,list<null>,1
+hms,map2,0,0,2,list<double | null>,1
+hms,map2,1,0,0,double[],1
+hms,map2,2,0,0,class<`function`>,1
+hms,map2,3,0,0,...,1
+hms,map_int,-1,0,0,integer[],1
+hms,map_int,0,0,0,list<integer[]>,1
+hms,map_int,0,0,1,list<double>,1
+hms,map_int,1,0,0,class<`function`>,1
+hms,map_int,2,0,0,...,1
+hms,map_lgl,-1,0,0,logical[],1
+hms,map_lgl,0,0,0,list<integer[]>,1
+hms,map_lgl,0,0,1,list<double | null>,1
+hms,map_lgl,0,0,2,list<null | integer[]>,1
+hms,map_lgl,0,0,3,list<null>,1
+hms,map_lgl,0,0,4,list<double>,1
+hms,map_lgl,1,0,0,class<`function`>,1
+hms,map_lgl,2,0,0,...,1
+hms,map_mold,-1,0,0,integer[],1
+hms,map_mold,0,0,0,list<integer[]>,1
+hms,map_mold,0,0,1,list<double>,1
+hms,map_mold,0,0,2,list<double | null>,1
+hms,map_mold,0,0,3,list<null | integer[]>,1
+hms,map_mold,0,0,4,list<null>,1
+hms,map_mold,1,0,0,class<`function`>,1
+hms,map_mold,2,0,0,integer,1
+hms,map_mold,3,0,0,...,1
+hms,new_hms,-1,0,0,any,1
+hms,new_hms,0,0,0,double[],1
+hms,parse_hm,-1,0,0,"class<`difftime`, `hms`>",1
+hms,parse_hm,0,0,0,character,1
+hms,parse_hms,-1,0,0,"class<`difftime`, `hms`>",1
+hms,parse_hms,0,0,0,character,1
+hms,parse_time,-1,0,0,class<`difftime`>,1
+hms,parse_time,0,0,0,character,1
+hms,parse_time,1,0,0,character,1
+hms,reduce,-1,0,0,double[],1
+hms,reduce,-1,0,1,null,1
+hms,reduce,0,0,0,list<any>,1
+hms,reduce,1,0,0,any,1
+hms,reduce,2,0,0,...,1
+hms,reduce,3,0,0,any,1
+hms,round_hms,-1,0,0,"class<`difftime`, `hms`>",1
+hms,round_hms,0,0,0,"class<`difftime`, `hms`>",1
+hms,round_hms,1,0,0,double,1
+hms,trunc_hms,-1,0,0,"class<`difftime`, `hms`>",1
+hms,trunc_hms,0,0,0,"class<`difftime`, `hms`>",1
+hms,trunc_hms,1,0,0,double,1
+hms,vec_cast.hms,-1,0,0,"class<`difftime`, `hms`>",1
+hms,vec_cast.hms,0,0,0,character,1
+hms,vec_cast.hms,0,0,1,class<`difftime`>,1
+hms,vec_cast.hms,0,0,2,"class<`POSIXct`, `POSIXt`>",1
+hms,vec_cast.hms,0,0,3,"class<`POSIXlt`, `POSIXt`>",1
+hms,vec_cast.hms,0,0,4,double,1
+hms,vec_cast.hms,1,0,0,"class<`difftime`, `hms`>",1
+hms,vec_cast.hms,2,0,0,...,1
+hms,vec_cast.hms.character,-1,0,0,"class<`difftime`, `hms`>",1
+hms,vec_cast.hms.character,0,0,0,character,1
+hms,vec_cast.hms.character,1,0,0,"class<`difftime`, `hms`>",1
+hms,vec_cast.hms.character,2,0,0,...,1
+hms,vec_cast.hms.difftime,-1,0,0,"class<`difftime`, `hms`>",1
+hms,vec_cast.hms.difftime,0,0,0,class<`difftime`>,1
+hms,vec_cast.hms.difftime,1,0,0,"class<`difftime`, `hms`>",1
+hms,vec_cast.hms.difftime,2,0,0,...,1
+hms,vec_cast.hms.double,-1,0,0,"class<`difftime`, `hms`>",1
+hms,vec_cast.hms.double,0,0,0,double,1
+hms,vec_cast.hms.double,1,0,0,"class<`difftime`, `hms`>",1
+hms,vec_cast.hms.double,2,0,0,...,1
+hms,vec_cast.hms.POSIXct,-1,0,0,"class<`difftime`, `hms`>",1
+hms,vec_cast.hms.POSIXct,0,0,0,"class<`POSIXct`, `POSIXt`>",1
+hms,vec_cast.hms.POSIXct,1,0,0,"class<`difftime`, `hms`>",1
+hms,vec_cast.hms.POSIXct,2,0,0,...,1
+hms,vec_cast.hms.POSIXlt,-1,0,0,"class<`difftime`, `hms`>",1
+hms,vec_cast.hms.POSIXlt,0,0,0,"class<`POSIXlt`, `POSIXt`>",1
+hms,vec_cast.hms.POSIXlt,1,0,0,"class<`difftime`, `hms`>",1
+hms,vec_cast.hms.POSIXlt,2,0,0,...,1
+hms,vec_cast.POSIXct.hms,-1,0,0,"class<`POSIXct`, `POSIXt`>",1
+hms,vec_cast.POSIXct.hms,0,0,0,"class<`difftime`, `hms`>",1
+hms,vec_cast.POSIXct.hms,1,0,0,"class<`POSIXct`, `POSIXt`>",1
+hms,vec_cast.POSIXct.hms,2,0,0,...,1
+hms,warn_lossy_cast,-1,0,0,null,1
+hms,warn_lossy_cast,0,0,0,any,1
+hms,warn_lossy_cast,1,0,0,any,1
+hms,warn_lossy_cast,2,0,0,...,1
+hms,warn_lossy_cast,3,0,0,logical,1
+hoardr,getsize,-1,0,0,double,1
+hoardr,getsize,0,0,0,double,1
+hoardr,hoard,-1,0,0,"class<`HoardClient`, `R6`>",1
+htmltools,as.character.html,-1,0,0,character,1
+htmltools,as.character.html,0,0,0,"class<`character`, `html`>",1
+htmltools,as.character.html,1,0,0,...,1
+htmltools,as.character.shiny.tag,-1,0,0,character,1
+htmltools,as.character.shiny.tag,0,0,0,class<`shiny.tag`>,1
+htmltools,as.character.shiny.tag,1,0,0,...,1
+htmltools,as.tags,-1,0,0,"class<`list`, `shiny.tag.list`>",1
+htmltools,as.tags,0,0,0,null,1
+htmltools,as.tags,1,0,0,...,1
+htmltools,as.tags.default,-1,0,0,"class<`list`, `shiny.tag.list`>",1
+htmltools,as.tags.default,0,0,0,null,1
+htmltools,as.tags.default,1,0,0,...,1
+htmltools,attachDependencies,-1,0,0,class<`shiny.tag`>,1
+htmltools,attachDependencies,0,0,0,class<`shiny.tag`>,1
+htmltools,attachDependencies,1,0,0,class<`html_dependency`>,1
+htmltools,attachDependencies,2,0,0,logical,1
+htmltools,concat8,-1,0,0,character,1
+htmltools,concat8,0,0,0,...,1
+htmltools,css,-1,0,0,character,1
+htmltools,css,0,0,0,...,1
+htmltools,css,1,0,0,character,1
+htmltools,div,-1,0,0,class<`shiny.tag`>,1
+htmltools,div,0,0,0,...,1
+htmltools,div,1,0,0,character,1
+htmltools,div,1,0,1,null,1
+htmltools,doRenderTags,-1,0,0,"class<`character`, `html`>",1
+htmltools,doRenderTags,0,0,0,class<`shiny.tag`>,1
+htmltools,doRenderTags,0,0,1,list<any>,1
+htmltools,doRenderTags,1,0,0,any,1
+htmltools,dropNullsOrEmpty,-1,0,0,character[],1
+htmltools,dropNullsOrEmpty,-1,0,1,list<any>,1
+htmltools,dropNullsOrEmpty,0,0,0,character[],1
+htmltools,dropNullsOrEmpty,0,0,1,list<any>,1
+htmltools,extractPreserveChunks,-1,0,0,list<character>,1
+htmltools,extractPreserveChunks,0,0,0,character,1
+htmltools,findDependencies,-1,0,0,null,1
+htmltools,findDependencies,0,0,0,class<`shiny.tag`>,1
+htmltools,findDependencies,0,0,1,character,1
+htmltools,findDependencies,0,0,2,"class<`character`, `html`>",1
+htmltools,findDependencies,1,0,0,logical,1
+htmltools,flattenTags,-1,0,0,list<any>,1
+htmltools,flattenTags,0,0,0,list<any>,1
+htmltools,flattenTags,0,0,1,"class<`list`, `shiny.tag.list`>",1
+htmltools,flattenTags,0,0,2,character[],1
+htmltools,flattenTags,0,0,3,"class<`character`, `html`>",1
+htmltools,flattenTags,0,0,4,class<`shiny.tag`>,1
+htmltools,flattenTags,0,0,5,null,1
+htmltools,h1,-1,0,0,class<`shiny.tag`>,1
+htmltools,h1,0,0,0,...,1
+htmltools,h1,1,0,0,character,1
+htmltools,h1,1,0,1,null,1
+htmltools,h3,-1,0,0,class<`shiny.tag`>,1
+htmltools,h3,0,0,0,...,1
+htmltools,h3,1,0,0,character,1
+htmltools,h3,1,0,1,null,1
+htmltools,HTML,-1,0,0,"class<`character`, `html`>",1
+htmltools,HTML,0,0,0,character,1
+htmltools,HTML,1,0,0,...,1
+htmltools,htmlDependencies,-1,0,0,null,1
+htmltools,htmlDependencies,0,0,0,character,1
+htmltools,htmlDependencies,0,0,1,"class<`character`, `html`>",1
+htmltools,htmlDependencies,0,0,2,class<`shiny.tag`>,1
+htmltools,htmlDependencies<-,-1,0,0,class<`shiny.tag`>,1
+htmltools,htmlDependencies<-,0,0,0,class<`shiny.tag`>,1
+htmltools,htmlDependencies<-,1,0,0,class<`html_dependency`>,1
+htmltools,htmlDependency,-1,0,0,class<`html_dependency`>,1
+htmltools,htmlDependency,0,0,0,character,1
+htmltools,htmlDependency,1,0,0,character,1
+htmltools,htmlDependency,2,0,0,character,1
+htmltools,htmlDependency,3,0,0,null,1
+htmltools,htmlDependency,4,0,0,character,1
+htmltools,htmlDependency,4,0,1,null,1
+htmltools,htmlDependency,5,0,0,null,1
+htmltools,htmlDependency,5,0,1,character,1
+htmltools,htmlDependency,6,0,0,null,1
+htmltools,htmlDependency,7,0,0,null,1
+htmltools,htmlDependency,8,0,0,null,1
+htmltools,htmlDependency,9,0,0,logical,1
+htmltools,htmlEscape,-1,0,0,character,1
+htmltools,htmlEscape,0,0,0,character,1
+htmltools,htmlEscape,1,0,0,logical,1
+htmltools,htmlPreserve,-1,0,0,character,1
+htmltools,htmlPreserve,0,0,0,character,1
+htmltools,is.singleton,-1,0,0,logical,1
+htmltools,is.singleton,0,0,0,character,1
+htmltools,is.singleton,0,0,1,"class<`character`, `html`>",1
+htmltools,is.singleton,0,0,2,class<`shiny.tag`>,1
+htmltools,isTag,-1,0,0,logical,1
+htmltools,isTag,0,0,0,character[],1
+htmltools,isTag,0,0,1,"class<`character`, `html`>",1
+htmltools,isTag,0,0,2,"class<`list`, `shiny.tag.list`>",1
+htmltools,isTag,0,0,3,class<`shiny.tag`>,1
+htmltools,isTag,0,0,4,list<any>,1
+htmltools,isTag,0,0,5,null,1
+htmltools,isTagList,-1,0,0,logical,1
+htmltools,isTagList,0,0,0,character[],1
+htmltools,isTagList,0,0,1,"class<`character`, `html`>",1
+htmltools,isTagList,0,0,2,"class<`list`, `shiny.tag.list`>",1
+htmltools,isTagList,0,0,3,list<any>,1
+htmltools,isTagList,0,0,4,null,1
+htmltools,normalizeText,-1,0,0,character,1
+htmltools,normalizeText,-1,0,1,"class<`character`, `html`>",1
+htmltools,normalizeText,0,0,0,character,1
+htmltools,normalizeText,0,0,1,"class<`character`, `html`>",1
+htmltools,p,-1,0,0,class<`shiny.tag`>,1
+htmltools,p,0,0,0,...,1
+htmltools,p,1,0,0,character,1
+htmltools,p,1,0,1,null,1
+htmltools,paste8,-1,0,0,character,1
+htmltools,paste8,0,0,0,...,1
+htmltools,paste8,1,0,0,character,1
+htmltools,paste8,2,0,0,character,1
+htmltools,registerMethods,-1,0,0,list<null>,1
+htmltools,registerMethods,0,0,0,list<character[]>,1
+htmltools,renderTags,-1,0,0,"list<class<`character`, `html`> | character[] | list<any>>",1
+htmltools,renderTags,0,0,0,class<`shiny.tag`>,1
+htmltools,renderTags,1,0,0,character[],1
+htmltools,renderTags,2,0,0,double,1
+htmltools,resolveDependencies,-1,0,0,list<any>,1
+htmltools,resolveDependencies,0,0,0,null,1
+htmltools,resolveDependencies,1,0,0,logical,1
+htmltools,restorePreserveChunks,-1,0,0,character,1
+htmltools,restorePreserveChunks,0,0,0,character,1
+htmltools,restorePreserveChunks,1,0,0,character,1
+htmltools,rewriteTags,-1,0,0,character,1
+htmltools,rewriteTags,-1,0,1,"class<`character`, `html`>",1
+htmltools,rewriteTags,-1,0,2,class<`shiny.tag`>,1
+htmltools,rewriteTags,-1,0,3,null,1
+htmltools,rewriteTags,0,0,0,character,1
+htmltools,rewriteTags,0,0,1,"class<`character`, `html`>",1
+htmltools,rewriteTags,0,0,2,class<`shiny.tag`>,1
+htmltools,rewriteTags,1,0,0,class<`function`>,1
+htmltools,rewriteTags,2,0,0,logical,1
+htmltools,strong,-1,0,0,class<`shiny.tag`>,1
+htmltools,strong,0,0,0,...,1
+htmltools,strong,1,0,0,character,1
+htmltools,strong,1,0,1,null,1
+htmltools,tag,-1,0,0,class<`shiny.tag`>,1
+htmltools,tag,0,0,0,character,1
+htmltools,tag,1,0,0,character,1
+htmltools,tag,1,0,1,class<`shiny.tag`>,1
+htmltools,tag,1,0,2,list<character | class<`html_dependency`>>,1
+htmltools,tag,1,0,3,list<character | class<`shiny.tag`>>,1
+htmltools,tag,1,0,4,list<character>,1
+htmltools,tag,1,0,5,"list<class<`character`, `html`>>",1
+htmltools,tag,1,0,6,list<class<`shiny.tag`>>,1
+htmltools,tag,1,0,7,list<null | class<`shiny.tag`>>,1
+htmltools,tag,2,0,0,character,1
+htmltools,tag,2,0,1,null,1
+htmltools,tagify,-1,0,0,class<`shiny.tag`>,1
+htmltools,tagify,0,0,0,class<`shiny.tag`>,1
+htmltools,tagList,-1,0,0,"class<`list`, `shiny.tag.list`>",1
+htmltools,tagList,0,0,0,...,1
+htmltools,tagWrite,-1,0,0,character,1
+htmltools,tagWrite,-1,0,1,null,1
+htmltools,tagWrite,0,0,0,class<`shiny.tag`>,1
+htmltools,tagWrite,0,0,1,character,1
+htmltools,tagWrite,0,0,2,list<any>,1
+htmltools,tagWrite,1,0,0,any,1
+htmltools,tagWrite,2,0,0,any,1
+htmltools,tagWrite,3,0,0,character,1
+htmltools,takeHeads,-1,0,0,list<class<`shiny.tag`> | list<any>>,1
+htmltools,takeHeads,-1,0,1,list<class<`shiny.tag`> | list<class<`shiny.tag`>>>,1
+htmltools,takeHeads,0,0,0,class<`shiny.tag`>,1
+htmltools,takeSingletons,-1,0,0,list<class<`shiny.tag`> | character[]>,1
+htmltools,takeSingletons,0,0,0,class<`shiny.tag`>,1
+htmltools,takeSingletons,1,0,0,character[],1
+htmltools,takeSingletons,2,0,0,logical,1
+htmltools,validateCssUnit,-1,0,0,character,1
+htmltools,validateCssUnit,0,0,0,character,1
+htmltools,validateCssUnit,0,0,1,double,1
+htmltools,validateNoWS,-1,0,0,null,1
+htmltools,validateNoWS,0,0,0,character,1
+htmltools,validateNoWS,0,0,1,null,1
+htmltools,validateScalarName,-1,0,0,null,1
+htmltools,validateScalarName,0,0,0,character,1
+htmltools,validateScalarName,1,0,0,any,1
+htmltools,withPrivateSeed,-1,0,0,character,1
+htmltools,withPrivateSeed,0,0,0,character,1
+htmltools,withTags,-1,0,0,class<`shiny.tag`>,1
+htmltools,withTags,0,0,0,any,1
+htmltools,withTemporary,-1,0,0,character,1
+htmltools,withTemporary,0,0,0,environment,1
+htmltools,withTemporary,1,0,0,character,1
+htmltools,withTemporary,2,0,0,any,1
+htmltools,withTemporary,3,0,0,character,1
+htmltools,withTemporary,4,0,0,logical,1
+htmltools,WSTextWriter,-1,0,0,list<class<`function`>>,1
+htmltools,WSTextWriter,0,0,0,double,1
+hutils,%<->%,-1,0,0,null,1
+hutils,%<->%,0,0,0,any,1
+hutils,%<->%,1,0,0,any,1
+hutils,ahull,-1,0,0,"class<`data.frame`, `data.table`>",1
+hutils,ahull,0,0,0,any,1
+hutils,ahull,1,0,0,double[],1
+hutils,ahull,2,0,0,double[],1
+hutils,ahull,3,0,0,double,1
+hutils,ahull,4,0,0,double,1
+hutils,ahull,5,0,0,character,1
+hutils,ahull,6,0,0,logical,1
+hutils,all_same_sign,-1,0,0,logical,1
+hutils,all_same_sign,-1,0,1,null,1
+hutils,all_same_sign,0,0,0,character,1
+hutils,all_same_sign,0,0,1,null,1
+hutils,all_same_sign,0,0,2,^double[],1
+hutils,any_grepl,-1,0,0,logical,1
+hutils,any_grepl,0,0,0,character[],1
+hutils,any_grepl,1,0,0,character,1
+hutils,any_grepl,2,0,0,logical,1
+hutils,any_grepl,3,0,0,logical,1
+hutils,any_grepl,4,0,0,logical,1
+hutils,any_grepl,5,0,0,logical,1
+hutils,areTrueFalse,-1,0,0,logical[],1
+hutils,areTrueFalse,0,0,0,...,1
+hutils,average_bearing,-1,0,0,double,1
+hutils,average_bearing,0,0,0,double,1
+hutils,average_bearing,1,0,0,double,1
+hutils,average_bearing,2,0,0,character,1
+hutils,average_bearing,2,0,1,double,1
+hutils,average_bearing,2,0,2,null,1
+hutils,average_bearing_n,-1,0,0,double,1
+hutils,average_bearing_n,0,0,0,integer[],1
+hutils,check_TF,-1,0,0,null,1
+hutils,check_TF,0,0,0,logical,1
+hutils,coalesce,-1,0,0,double[],1
+hutils,coalesce,0,0,0,^double[],1
+hutils,coalesce,1,0,0,...,1
+hutils,definitely_sorted,-1,0,0,logical,1
+hutils,definitely_sorted,0,0,0,"class<`data.frame`, `data.table`>",1
+hutils,definitely_sorted,1,0,0,any,1
+hutils,definitely_sorted,2,0,0,logical,1
+hutils,definitely_sorted,3,0,0,any,1
+hutils,definitely_sorted,4,0,0,any,1
+hutils,drop_col,-1,0,0,"class<`data.frame`, `data.table`>",1
+hutils,drop_col,0,0,0,"class<`data.frame`, `data.table`>",1
+hutils,drop_col,1,0,0,character,1
+hutils,drop_col,2,0,0,logical,1
+hutils,drop_constant_cols,-1,0,0,"class<`data.frame`, `data.table`>",1
+hutils,drop_constant_cols,0,0,0,"class<`data.frame`, `data.table`>",1
+hutils,drop_constant_cols,1,0,0,logical,1
+hutils,drop_grep,-1,0,0,"class<`data.frame`, `data.table`>",1
+hutils,drop_grep,0,0,0,"class<`data.frame`, `data.table`>",1
+hutils,drop_grep,1,0,0,character,1
+hutils,drop_grep,2,0,0,...,1
+hutils,drop_grep,3,0,0,logical,1
+hutils,duplicated_rows,-1,0,0,"class<`data.frame`, `data.table`>",1
+hutils,duplicated_rows,0,0,0,"class<`data.frame`, `data.table`>",1
+hutils,duplicated_rows,1,0,0,character[],1
+hutils,duplicated_rows,2,0,0,logical,1
+hutils,duplicated_rows,3,0,0,logical,1
+hutils,duplicated_rows,4,0,0,logical,1
+hutils,duplicated_rows,5,0,0,logical,1
+hutils,haversine_distance,-1,0,0,double,1
+hutils,haversine_distance,0,0,0,double,1
+hutils,haversine_distance,1,0,0,double,1
+hutils,haversine_distance,2,0,0,double,1
+hutils,haversine_distance,3,0,0,double,1
+hutils,%implies%,-1,0,0,logical[],1
+hutils,%implies%,0,0,0,logical[],1
+hutils,%implies%,1,0,0,logical[],1
+hutils,longest_prefix,-1,0,0,character,1
+hutils,longest_prefix,0,0,0,character[],1
+hutils,longest_prefix,1,0,0,null,1
+hutils,longest_prefix,2,0,0,logical,1
+hutils,longest_prefix,3,0,0,logical,1
+hutils,longest_suffix,-1,0,0,character,1
+hutils,longest_suffix,0,0,0,character[],1
+hutils,longest_suffix,1,0,0,null,1
+hutils,longest_suffix,2,0,0,logical,1
+hutils,longest_suffix,3,0,0,logical,1
+hutils,mutate_ntile,-1,0,0,"class<`data.frame`, `data.table`>",1
+hutils,mutate_ntile,0,0,0,"class<`data.frame`, `data.table`>",1
+hutils,mutate_ntile,1,0,0,character,1
+hutils,mutate_ntile,2,0,0,double,1
+hutils,mutate_ntile,3,0,0,null,1
+hutils,mutate_ntile,4,0,0,character,1
+hutils,mutate_ntile,4,0,1,null,1
+hutils,mutate_ntile,5,0,0,null,1
+hutils,mutate_ntile,5,0,1,character,1
+hutils,mutate_ntile,6,0,0,null,1
+hutils,mutate_ntile,7,0,0,logical,1
+hutils,mutate_other,-1,0,0,"class<`data.frame`, `data.table`>",1
+hutils,mutate_other,0,0,0,"class<`data.frame`, `data.table`>",1
+hutils,mutate_other,1,0,0,character,1
+hutils,mutate_other,2,0,0,double,1
+hutils,mutate_other,3,0,0,any,1
+hutils,mutate_other,4,0,0,null,1
+hutils,mutate_other,5,0,0,character,1
+hutils,mutate_other,6,0,0,double,1
+hutils,mutate_other,7,0,0,logical,1
+hutils,ngrep,-1,0,0,character[],1
+hutils,ngrep,-1,0,1,integer[],1
+hutils,ngrep,0,0,0,character,1
+hutils,ngrep,1,0,0,character[],1
+hutils,ngrep,2,0,0,logical,1
+hutils,ngrep,3,0,0,...,1
+hutils,%notchin%,-1,0,0,logical,1
+hutils,%notchin%,0,0,0,character,1
+hutils,%notchin%,1,0,0,character[],1
+hutils,%pin%,-1,0,0,logical[],1
+hutils,%pin%,0,0,0,character[],1
+hutils,%pin%,1,0,0,character[],1
+hutils,RQ,-1,0,0,"class<`data.frame`, `data.table`>",1
+hutils,RQ,0,0,0,character,1
+hutils,RQ,1,0,0,null,1
+hutils,RQ,2,0,0,"class<`data.frame`, `data.table`>",1
+hutils,samp,-1,0,0,double[],1
+hutils,samp,0,0,0,double,1
+hutils,samp,0,0,1,integer[],1
+hutils,samp,1,0,0,double,1
+hutils,samp,2,0,0,logical,1
+hutils,samp,3,0,0,logical,1
+hutils,samp,4,0,0,null,1
+hutils,select_grep,-1,0,0,"class<`data.frame`, `data.table`>",1
+hutils,select_grep,0,0,0,"class<`data.frame`, `data.table`>",1
+hutils,select_grep,1,0,0,character,1
+hutils,select_grep,2,0,0,character,1
+hutils,select_grep,2,0,1,null,1
+hutils,select_grep,3,0,0,character,1
+hutils,select_grep,3,0,1,null,1
+hutils,select_grep,4,0,0,logical,1
+hutils,select_grep,5,0,0,logical,1
+hutils,select_grep,6,0,0,logical,1
+hutils,select_grep,7,0,0,logical,1
+hutils,selector,-1,0,0,"class<`data.frame`, `data.table`>",1
+hutils,selector,0,0,0,"class<`data.frame`, `data.table`>",1
+hutils,selector,1,0,0,...,1
+hutils,selector,2,0,0,null,1
+hutils,selector,3,0,0,logical,1
+hutils,selector,4,0,0,logical,1
+hutils,select_which,-1,0,0,"class<`data.frame`, `data.table`>",1
+hutils,select_which,0,0,0,"class<`data.frame`, `data.table`>",1
+hutils,select_which,1,0,0,class<`function`>,1
+hutils,select_which,2,0,0,character,1
+hutils,select_which,3,0,0,logical,1
+hutils,set_cols_first,-1,0,0,"class<`data.frame`, `data.table`>",1
+hutils,set_cols_first,0,0,0,"class<`data.frame`, `data.table`>",1
+hutils,set_cols_first,1,0,0,character,1
+hutils,set_cols_first,2,0,0,logical,1
+hutils,set_cols_last,-1,0,0,"class<`data.frame`, `data.table`>",1
+hutils,set_cols_last,0,0,0,"class<`data.frame`, `data.table`>",1
+hutils,set_cols_last,1,0,0,character,1
+hutils,set_cols_last,2,0,0,logical,1
+hutils,set_colsuborder,-1,0,0,"class<`data.frame`, `data.table`>",1
+hutils,set_colsuborder,0,0,0,"class<`data.frame`, `data.table`>",1
+hutils,set_colsuborder,1,0,0,character[],1
+hutils,set_colsuborder,2,0,0,logical,1
+hutils,set_local_extrema,-1,0,0,"class<`data.frame`, `data.table`>",1
+hutils,set_local_extrema,0,0,0,"class<`data.frame`, `data.table`>",1
+hutils,Switch,-1,0,0,double[],1
+hutils,Switch,0,0,0,character[],1
+hutils,Switch,1,0,0,...,1
+hutils,Switch,2,0,0,double,1
+hutils,Switch,3,0,0,null,1
+hutils,Switch,4,0,0,logical,1
+hutils,weight2rows,-1,0,0,"class<`data.frame`, `data.table`>",1
+hutils,weight2rows,0,0,0,"class<`data.frame`, `data.table`>",1
+hutils,weight2rows,1,0,0,character,1
+hutils,weight2rows,2,0,0,double,1
+hutils,weight2rows,2,0,1,null,1
+hutils,weight2rows,3,0,0,logical,1
+hutils,weighted_ntile,-1,0,0,integer[],1
+hutils,weighted_ntile,0,0,0,integer[],1
+hutils,weighted_ntile,1,0,0,any,1
+hutils,weighted_ntile,2,0,0,double,1
+hypergeo,buhring_eqn11,-1,0,0,complex[],1
+hypergeo,buhring_eqn11,0,0,0,integer[],1
+hypergeo,buhring_eqn11,0,0,1,double,1
+hypergeo,buhring_eqn11,1,0,0,double,1
+hypergeo,buhring_eqn11,2,0,0,double,1
+hypergeo,buhring_eqn11,3,0,0,double,1
+hypergeo,buhring_eqn11,4,0,0,double,1
+hypergeo,buhring_eqn11,5,0,0,double,1
+hypergeo,buhring_eqn12,-1,0,0,complex[],1
+hypergeo,buhring_eqn12,0,0,0,integer[],1
+hypergeo,buhring_eqn12,1,0,0,double,1
+hypergeo,buhring_eqn12,2,0,0,double,1
+hypergeo,buhring_eqn12,3,0,0,double,1
+hypergeo,buhring_eqn12,4,0,0,double,1
+hypergeo,buhring_eqn12,5,0,0,double,1
+hypergeo,buhring_eqn5_factors,-1,0,0,complex[],1
+hypergeo,buhring_eqn5_factors,0,0,0,double,1
+hypergeo,buhring_eqn5_factors,1,0,0,double,1
+hypergeo,buhring_eqn5_factors,2,0,0,double,1
+hypergeo,buhring_eqn5_factors,3,0,0,complex,1
+hypergeo,buhring_eqn5_factors,4,0,0,double,1
+hypergeo,buhring_eqn5_series,-1,0,0,complex,1
+hypergeo,buhring_eqn5_series,0,0,0,double,1
+hypergeo,buhring_eqn5_series,1,0,0,double,1
+hypergeo,buhring_eqn5_series,2,0,0,double,1
+hypergeo,buhring_eqn5_series,3,0,0,double,1
+hypergeo,buhring_eqn5_series,4,0,0,complex,1
+hypergeo,buhring_eqn5_series,5,0,0,double,1
+hypergeo,buhring_eqn5_series,6,0,0,logical,1
+hypergeo,buhring_eqn5_series,7,0,0,double,1
+hypergeo,buhring_eqn5_series,8,0,0,double,1
+hypergeo,complex_factorial,-1,0,0,complex,1
+hypergeo,complex_factorial,0,0,0,double,1
+hypergeo,complex_factorial,1,0,0,logical,1
+hypergeo,complex_gamma,-1,0,0,complex,1
+hypergeo,complex_gamma,0,0,0,complex,1
+hypergeo,complex_gamma,1,0,0,logical,1
+hypergeo,complex_ode,-1,0,0,"class<`deSolve`, `matrix`>",1
+hypergeo,complex_ode,0,0,0,complex[],1
+hypergeo,complex_ode,1,0,0,double[],1
+hypergeo,complex_ode,2,0,0,class<`function`>,1
+hypergeo,complex_ode,3,0,0,complex[],1
+hypergeo,complex_ode,4,0,0,null,1
+hypergeo,complex_ode,5,0,0,class<`function`>,1
+hypergeo,complex_ode,6,0,0,class<`function`>,1
+hypergeo,complex_ode,7,0,0,...,1
+hypergeo,crit,-1,0,0,complex[],1
+hypergeo,crit,0,0,0,...,1
+hypergeo,f15.1.1,-1,0,0,complex[],1
+hypergeo,f15.1.1,0,0,0,complex,1
+hypergeo,f15.1.1,1,0,0,complex,1
+hypergeo,f15.1.1,2,0,0,complex,1
+hypergeo,f15.1.1,3,0,0,complex[],1
+hypergeo,f15.1.1,4,0,0,double,1
+hypergeo,f15.1.1,5,0,0,double,1
+hypergeo,f15.3.1,-1,0,0,complex,1
+hypergeo,f15.3.1,0,0,0,double,1
+hypergeo,f15.3.1,1,0,0,double,1
+hypergeo,f15.3.1,2,0,0,double,1
+hypergeo,f15.3.1,3,0,0,double,1
+hypergeo,f15.3.1,4,0,0,complex[],1
+hypergeo,f15.3.10_11_12,-1,0,0,complex,1
+hypergeo,f15.3.10_11_12,-1,0,1,null,1
+hypergeo,f15.3.10_11_12,0,0,0,double,1
+hypergeo,f15.3.10_11_12,1,0,0,double,1
+hypergeo,f15.3.10_11_12,2,0,0,double,1
+hypergeo,f15.3.10_11_12,3,0,0,complex,1
+hypergeo,f15.3.10_11_12,4,0,0,double,1
+hypergeo,f15.3.10_11_12,5,0,0,double,1
+hypergeo,f15.3.10_11_12,6,0,0,character,1
+hypergeo,f15.3.11,-1,0,0,complex,1
+hypergeo,f15.3.11,-1,0,1,null,1
+hypergeo,f15.3.11,0,0,0,double,1
+hypergeo,f15.3.11,1,0,0,double,1
+hypergeo,f15.3.11,2,0,0,double,1
+hypergeo,f15.3.11,3,0,0,complex,1
+hypergeo,f15.3.11,4,0,0,double,1
+hypergeo,f15.3.11,5,0,0,double,1
+hypergeo,f15.3.11,6,0,0,character,1
+hypergeo,f15.3.11_bit1,-1,0,0,complex,1
+hypergeo,f15.3.11_bit1,0,0,0,double,1
+hypergeo,f15.3.11_bit1,1,0,0,double,1
+hypergeo,f15.3.11_bit1,2,0,0,double,1
+hypergeo,f15.3.11_bit1,3,0,0,complex,1
+hypergeo,f15.3.11_bit1,4,0,0,any,1
+hypergeo,f15.3.11_bit2_a,-1,0,0,complex,1
+hypergeo,f15.3.11_bit2_a,-1,0,1,null,1
+hypergeo,f15.3.11_bit2_a,0,0,0,double,1
+hypergeo,f15.3.11_bit2_a,1,0,0,double,1
+hypergeo,f15.3.11_bit2_a,2,0,0,double,1
+hypergeo,f15.3.11_bit2_a,3,0,0,complex,1
+hypergeo,f15.3.11_bit2_a,4,0,0,double,1
+hypergeo,f15.3.11_bit2_a,5,0,0,double,1
+hypergeo,f15.3.12,-1,0,0,complex,1
+hypergeo,f15.3.12,0,0,0,double,1
+hypergeo,f15.3.12,1,0,0,double,1
+hypergeo,f15.3.12,2,0,0,double,1
+hypergeo,f15.3.12,3,0,0,complex,1
+hypergeo,f15.3.12,4,0,0,double,1
+hypergeo,f15.3.12,5,0,0,double,1
+hypergeo,f15.3.12,6,0,0,character,1
+hypergeo,f15.3.12_bit1,-1,0,0,complex,1
+hypergeo,f15.3.12_bit1,0,0,0,double,1
+hypergeo,f15.3.12_bit1,1,0,0,double,1
+hypergeo,f15.3.12_bit1,2,0,0,double,1
+hypergeo,f15.3.12_bit1,3,0,0,complex,1
+hypergeo,f15.3.12_bit1,4,0,0,double,1
+hypergeo,f15.3.12_bit2_a,-1,0,0,complex,1
+hypergeo,f15.3.12_bit2_a,0,0,0,double,1
+hypergeo,f15.3.12_bit2_a,1,0,0,double,1
+hypergeo,f15.3.12_bit2_a,2,0,0,double,1
+hypergeo,f15.3.12_bit2_a,3,0,0,complex,1
+hypergeo,f15.3.12_bit2_a,4,0,0,double,1
+hypergeo,f15.3.12_bit2_a,5,0,0,double,1
+hypergeo,f15.3.13,-1,0,0,complex[],1
+hypergeo,f15.3.13,0,0,0,double,1
+hypergeo,f15.3.13,1,0,0,double,1
+hypergeo,f15.3.13,2,0,0,complex[],1
+hypergeo,f15.3.13,3,0,0,double,1
+hypergeo,f15.3.13,4,0,0,double,1
+hypergeo,f15.3.13,5,0,0,character,1
+hypergeo,f15.3.13_14,-1,0,0,complex[],1
+hypergeo,f15.3.13_14,0,0,0,double,1
+hypergeo,f15.3.13_14,1,0,0,double,1
+hypergeo,f15.3.13_14,2,0,0,double,1
+hypergeo,f15.3.13_14,3,0,0,complex[],1
+hypergeo,f15.3.13_14,4,0,0,double,1
+hypergeo,f15.3.13_14,5,0,0,double,1
+hypergeo,f15.3.13_14,6,0,0,character,1
+hypergeo,f15.3.13_a,-1,0,0,complex[],1
+hypergeo,f15.3.13_a,0,0,0,double,1
+hypergeo,f15.3.13_a,1,0,0,double,1
+hypergeo,f15.3.13_a,2,0,0,complex[],1
+hypergeo,f15.3.13_a,3,0,0,double,1
+hypergeo,f15.3.13_a,4,0,0,double,1
+hypergeo,f15.3.14,-1,0,0,complex,1
+hypergeo,f15.3.14,0,0,0,double,1
+hypergeo,f15.3.14,1,0,0,double,1
+hypergeo,f15.3.14,2,0,0,double,1
+hypergeo,f15.3.14,3,0,0,complex,1
+hypergeo,f15.3.14,4,0,0,double,1
+hypergeo,f15.3.14,5,0,0,double,1
+hypergeo,f15.3.14,6,0,0,character,1
+hypergeo,f15.3.14_bit1_a,-1,0,0,complex,1
+hypergeo,f15.3.14_bit1_a,0,0,0,double,1
+hypergeo,f15.3.14_bit1_a,1,0,0,double,1
+hypergeo,f15.3.14_bit1_a,2,0,0,double,1
+hypergeo,f15.3.14_bit1_a,3,0,0,complex,1
+hypergeo,f15.3.14_bit1_a,4,0,0,double,1
+hypergeo,f15.3.14_bit1_a,5,0,0,double,1
+hypergeo,f15.3.14_bit2,-1,0,0,complex,1
+hypergeo,f15.3.14_bit2,0,0,0,double,1
+hypergeo,f15.3.14_bit2,1,0,0,double,1
+hypergeo,f15.3.14_bit2,2,0,0,double,1
+hypergeo,f15.3.14_bit2,3,0,0,complex,1
+hypergeo,f15.3.14_bit2,4,0,0,double,1
+hypergeo,f15.3.4,-1,0,0,complex[],1
+hypergeo,f15.3.4,0,0,0,complex,1
+hypergeo,f15.3.4,1,0,0,complex,1
+hypergeo,f15.3.4,2,0,0,complex,1
+hypergeo,f15.3.4,3,0,0,complex[],1
+hypergeo,f15.3.4,4,0,0,double,1
+hypergeo,f15.3.4,5,0,0,double,1
+hypergeo,f15.3.6,-1,0,0,complex,1
+hypergeo,f15.3.6,0,0,0,complex,1
+hypergeo,f15.3.6,1,0,0,complex,1
+hypergeo,f15.3.6,2,0,0,complex,1
+hypergeo,f15.3.6,3,0,0,complex,1
+hypergeo,f15.3.6,4,0,0,double,1
+hypergeo,f15.3.6,5,0,0,double,1
+hypergeo,f15.3.7,-1,0,0,complex[],1
+hypergeo,f15.3.7,0,0,0,complex,1
+hypergeo,f15.3.7,1,0,0,complex,1
+hypergeo,f15.3.7,2,0,0,complex,1
+hypergeo,f15.3.7,3,0,0,complex[],1
+hypergeo,f15.3.7,4,0,0,double,1
+hypergeo,f15.3.7,5,0,0,double,1
+hypergeo,f15.3.8,-1,0,0,complex[],1
+hypergeo,f15.3.8,0,0,0,complex,1
+hypergeo,f15.3.8,1,0,0,complex,1
+hypergeo,f15.3.8,2,0,0,complex,1
+hypergeo,f15.3.8,3,0,0,complex[],1
+hypergeo,f15.3.8,4,0,0,double,1
+hypergeo,f15.3.8,5,0,0,double,1
+hypergeo,f15.3.9,-1,0,0,complex[],1
+hypergeo,f15.3.9,0,0,0,complex,1
+hypergeo,f15.3.9,1,0,0,complex,1
+hypergeo,f15.3.9,2,0,0,complex,1
+hypergeo,f15.3.9,3,0,0,complex[],1
+hypergeo,f15.3.9,4,0,0,double,1
+hypergeo,f15.3.9,5,0,0,double,1
+hypergeo,f15.5.1,-1,0,0,complex,1
+hypergeo,f15.5.1,0,0,0,double,1
+hypergeo,f15.5.1,1,0,0,double,1
+hypergeo,f15.5.1,2,0,0,double,1
+hypergeo,f15.5.1,3,0,0,any,1
+hypergeo,f15.5.1,4,0,0,double,1
+hypergeo,f15.5.1,5,0,0,class<`function`>,1
+hypergeo,f15.5.1,6,0,0,class<`function`>,1
+hypergeo,f15.5.1,7,0,0,logical,1
+hypergeo,f15.5.1,8,0,0,...,1
+hypergeo,.f3,-1,0,0,complex,1
+hypergeo,.f3,0,0,0,double,1
+hypergeo,.f3,1,0,0,double,1
+hypergeo,.f3,2,0,0,double,1
+hypergeo,.f4,-1,0,0,complex,1
+hypergeo,.f4,0,0,0,complex,1
+hypergeo,.f4,1,0,0,complex,1
+hypergeo,.f4,2,0,0,complex,1
+hypergeo,.f4,3,0,0,complex,1
+hypergeo,genhypergeo,-1,0,0,complex[],1
+hypergeo,genhypergeo,0,0,0,complex[],1
+hypergeo,genhypergeo,0,0,1,null,1
+hypergeo,genhypergeo,1,0,0,double[],1
+hypergeo,genhypergeo,1,0,1,complex,1
+hypergeo,genhypergeo,2,0,0,complex[],1
+hypergeo,genhypergeo,3,0,0,double,1
+hypergeo,genhypergeo,4,0,0,double,1
+hypergeo,genhypergeo,5,0,0,logical,1
+hypergeo,genhypergeo,6,0,0,logical,1
+hypergeo,genhypergeo,7,0,0,logical,1
+hypergeo,genhypergeo,8,0,0,logical,1
+hypergeo,genhypergeo_contfrac,-1,0,0,complex,1
+hypergeo,genhypergeo_contfrac,0,0,0,double[],1
+hypergeo,genhypergeo_contfrac,1,0,0,double[],1
+hypergeo,genhypergeo_contfrac,2,0,0,complex,1
+hypergeo,genhypergeo_contfrac,3,0,0,double,1
+hypergeo,genhypergeo_contfrac,4,0,0,double,1
+hypergeo,genhypergeo_contfrac_single,-1,0,0,complex,1
+hypergeo,genhypergeo_contfrac_single,0,0,0,double[],1
+hypergeo,genhypergeo_contfrac_single,1,0,0,double[],1
+hypergeo,genhypergeo_contfrac_single,2,0,0,complex,1
+hypergeo,genhypergeo_contfrac_single,3,0,0,double,1
+hypergeo,genhypergeo_contfrac_single,4,0,0,double,1
+hypergeo,genhypergeo_series,-1,0,0,complex[],1
+hypergeo,genhypergeo_series,0,0,0,complex[],1
+hypergeo,genhypergeo_series,0,0,1,null,1
+hypergeo,genhypergeo_series,1,0,0,double[],1
+hypergeo,genhypergeo_series,1,0,1,complex,1
+hypergeo,genhypergeo_series,2,0,0,complex[],1
+hypergeo,genhypergeo_series,3,0,0,double,1
+hypergeo,genhypergeo_series,4,0,0,double,1
+hypergeo,genhypergeo_series,5,0,0,logical,1
+hypergeo,genhypergeo_series,6,0,0,any,1
+hypergeo,genhypergeo_series,7,0,0,logical,1
+hypergeo,genhypergeo_shanks,-1,0,0,complex,1
+hypergeo,genhypergeo_shanks,0,0,0,double[],1
+hypergeo,genhypergeo_shanks,1,0,0,double,1
+hypergeo,genhypergeo_shanks,2,0,0,complex,1
+hypergeo,genhypergeo_shanks,3,0,0,double,1
+hypergeo,hypergeo,-1,0,0,class<`matrix`>,1
+hypergeo,hypergeo,-1,0,1,complex[],1
+hypergeo,hypergeo,0,0,0,class<`matrix`>,1
+hypergeo,hypergeo,0,0,1,complex,1
+hypergeo,hypergeo,1,0,0,complex,1
+hypergeo,hypergeo,2,0,0,complex,1
+hypergeo,hypergeo,3,0,0,complex[],1
+hypergeo,hypergeo,4,0,0,double,1
+hypergeo,hypergeo,5,0,0,any,1
+hypergeo,hypergeo_A_nonpos_int,-1,0,0,complex,1
+hypergeo,hypergeo_A_nonpos_int,0,0,0,double,1
+hypergeo,hypergeo_A_nonpos_int,1,0,0,double,1
+hypergeo,hypergeo_A_nonpos_int,2,0,0,double,1
+hypergeo,hypergeo_A_nonpos_int,3,0,0,complex,1
+hypergeo,hypergeo_A_nonpos_int,4,0,0,double,1
+hypergeo,hypergeo_AorB_nonpos_int,-1,0,0,complex,1
+hypergeo,hypergeo_AorB_nonpos_int,0,0,0,double,1
+hypergeo,hypergeo_AorB_nonpos_int,1,0,0,double,1
+hypergeo,hypergeo_AorB_nonpos_int,2,0,0,double,1
+hypergeo,hypergeo_AorB_nonpos_int,3,0,0,complex,1
+hypergeo,hypergeo_AorB_nonpos_int,4,0,0,double,1
+hypergeo,hypergeo_buhring,-1,0,0,complex,1
+hypergeo,hypergeo_buhring,0,0,0,double,1
+hypergeo,hypergeo_buhring,1,0,0,double,1
+hypergeo,hypergeo_buhring,2,0,0,double,1
+hypergeo,hypergeo_buhring,3,0,0,complex,1
+hypergeo,hypergeo_buhring,4,0,0,double,1
+hypergeo,hypergeo_buhring,5,0,0,double,1
+hypergeo,hypergeo_buhring,6,0,0,double,1
+hypergeo,hypergeo_buhring,7,0,0,logical,1
+hypergeo,hypergeo_contfrac,-1,0,0,complex,1
+hypergeo,hypergeo_contfrac,0,0,0,double,1
+hypergeo,hypergeo_contfrac,1,0,0,double,1
+hypergeo,hypergeo_contfrac,2,0,0,double,1
+hypergeo,hypergeo_contfrac,3,0,0,complex,1
+hypergeo,hypergeo_contfrac,4,0,0,double,1
+hypergeo,hypergeo_contfrac,5,0,0,double,1
+hypergeo,hypergeo_cover1,-1,0,0,complex[],1
+hypergeo,hypergeo_cover1,-1,0,1,null,1
+hypergeo,hypergeo_cover1,0,0,0,double,1
+hypergeo,hypergeo_cover1,1,0,0,double,1
+hypergeo,hypergeo_cover1,2,0,0,double,1
+hypergeo,hypergeo_cover1,3,0,0,complex[],1
+hypergeo,hypergeo_cover1,4,0,0,double,1
+hypergeo,hypergeo_cover1,5,0,0,double,1
+hypergeo,hypergeo_cover1,6,0,0,character,1
+hypergeo,hypergeo_cover1,7,0,0,logical,1
+hypergeo,hypergeo_cover2,-1,0,0,complex[],1
+hypergeo,hypergeo_cover2,0,0,0,double,1
+hypergeo,hypergeo_cover2,1,0,0,double,1
+hypergeo,hypergeo_cover2,2,0,0,double,1
+hypergeo,hypergeo_cover2,3,0,0,complex[],1
+hypergeo,hypergeo_cover2,4,0,0,double,1
+hypergeo,hypergeo_cover2,5,0,0,double,1
+hypergeo,hypergeo_cover2,6,0,0,character,1
+hypergeo,hypergeo_cover2,7,0,0,logical,1
+hypergeo,hypergeo_cover3,-1,0,0,complex[],1
+hypergeo,hypergeo_cover3,0,0,0,double,1
+hypergeo,hypergeo_cover3,1,0,0,double,1
+hypergeo,hypergeo_cover3,2,0,0,double,1
+hypergeo,hypergeo_cover3,3,0,0,complex[],1
+hypergeo,hypergeo_cover3,4,0,0,double,1
+hypergeo,hypergeo_cover3,5,0,0,double,1
+hypergeo,hypergeo_cover3,6,0,0,character,1
+hypergeo,hypergeo_cover3,7,0,0,logical,1
+hypergeo,hypergeo_general,-1,0,0,complex[],1
+hypergeo,hypergeo_general,0,0,0,complex,1
+hypergeo,hypergeo_general,1,0,0,complex,1
+hypergeo,hypergeo_general,2,0,0,complex,1
+hypergeo,hypergeo_general,3,0,0,complex[],1
+hypergeo,hypergeo_general,4,0,0,double,1
+hypergeo,hypergeo_general,5,0,0,double,1
+hypergeo,hypergeo_general,6,0,0,logical,1
+hypergeo,hypergeo_gosper,-1,0,0,complex[],1
+hypergeo,hypergeo_gosper,0,0,0,double,1
+hypergeo,hypergeo_gosper,1,0,0,double,1
+hypergeo,hypergeo_gosper,2,0,0,double,1
+hypergeo,hypergeo_gosper,3,0,0,complex[],1
+hypergeo,hypergeo_gosper,4,0,0,double,1
+hypergeo,hypergeo_gosper,5,0,0,double,1
+hypergeo,hypergeo_powerseries,-1,0,0,complex[],1
+hypergeo,hypergeo_powerseries,-1,0,1,null,1
+hypergeo,hypergeo_powerseries,0,0,0,complex,1
+hypergeo,hypergeo_powerseries,1,0,0,complex,1
+hypergeo,hypergeo_powerseries,2,0,0,complex,1
+hypergeo,hypergeo_powerseries,3,0,0,complex[],1
+hypergeo,hypergeo_powerseries,4,0,0,any,1
+hypergeo,hypergeo_powerseries,5,0,0,any,1
+hypergeo,hypergeo_press,-1,0,0,"class<`deSolve`, `matrix`>",1
+hypergeo,hypergeo_press,0,0,0,double,1
+hypergeo,hypergeo_press,1,0,0,double,1
+hypergeo,hypergeo_press,2,0,0,double,1
+hypergeo,hypergeo_press,3,0,0,complex,1
+hypergeo,hypergeo_press,4,0,0,...,1
+hypergeo,hypergeo_shanks,-1,0,0,complex,1
+hypergeo,hypergeo_shanks,0,0,0,double,1
+hypergeo,hypergeo_shanks,1,0,0,double,1
+hypergeo,hypergeo_shanks,2,0,0,double,1
+hypergeo,hypergeo_shanks,3,0,0,complex,1
+hypergeo,hypergeo_shanks,4,0,0,double,1
+hypergeo,hypergeo_taylor,-1,0,0,complex,1
+hypergeo,hypergeo_taylor,0,0,0,double,1
+hypergeo,hypergeo_taylor,1,0,0,double,1
+hypergeo,hypergeo_taylor,2,0,0,double,1
+hypergeo,hypergeo_taylor,3,0,0,complex,1
+hypergeo,hypergeo_taylor,4,0,0,double,1
+hypergeo,hypergeo_taylor,5,0,0,double,1
+hypergeo,i15.3.6,-1,0,0,complex[],1
+hypergeo,i15.3.6,0,0,0,complex,1
+hypergeo,i15.3.6,1,0,0,complex,1
+hypergeo,i15.3.6,2,0,0,complex,1
+hypergeo,i15.3.7,-1,0,0,complex[],1
+hypergeo,i15.3.7,0,0,0,complex,1
+hypergeo,i15.3.7,1,0,0,complex,1
+hypergeo,i15.3.7,2,0,0,complex,1
+hypergeo,i15.3.8,-1,0,0,complex[],1
+hypergeo,i15.3.8,0,0,0,complex,1
+hypergeo,i15.3.8,1,0,0,complex,1
+hypergeo,i15.3.8,2,0,0,complex,1
+hypergeo,i15.3.9,-1,0,0,complex[],1
+hypergeo,i15.3.9,0,0,0,complex,1
+hypergeo,i15.3.9,1,0,0,complex,1
+hypergeo,i15.3.9,2,0,0,complex,1
+hypergeo,isgood,-1,0,0,logical,1
+hypergeo,isgood,0,0,0,complex[],1
+hypergeo,isgood,1,0,0,double,1
+hypergeo,is.near_integer,-1,0,0,logical[],1
+hypergeo,is.near_integer,0,0,0,double[],1
+hypergeo,is.near_integer,0,0,1,complex,1
+hypergeo,is.near_integer,1,0,0,null,1
+hypergeo,is.nonpos,-1,0,0,logical[],1
+hypergeo,is.nonpos,0,0,0,double[],1
+hypergeo,is.nonpos,0,0,1,complex,1
+hypergeo,is.zero,-1,0,0,logical,1
+hypergeo,is.zero,0,0,0,complex,1
+hypergeo,j15.3.6,-1,0,0,logical[],1
+hypergeo,j15.3.6,0,0,0,double,1
+hypergeo,j15.3.6,1,0,0,double,1
+hypergeo,j15.3.6,2,0,0,double,1
+hypergeo,j15.3.7,-1,0,0,logical[],1
+hypergeo,j15.3.7,0,0,0,double,1
+hypergeo,j15.3.7,1,0,0,double,1
+hypergeo,j15.3.7,2,0,0,double,1
+hypergeo,j15.3.8,-1,0,0,logical[],1
+hypergeo,j15.3.8,0,0,0,double,1
+hypergeo,j15.3.8,1,0,0,double,1
+hypergeo,j15.3.8,2,0,0,double,1
+hypergeo,j15.3.9,-1,0,0,logical[],1
+hypergeo,j15.3.9,0,0,0,double,1
+hypergeo,j15.3.9,1,0,0,double,1
+hypergeo,j15.3.9,2,0,0,double,1
+hypergeo,lanczos,-1,0,0,complex[],1
+hypergeo,lanczos,0,0,0,complex[],1
+hypergeo,lanczos,1,0,0,logical,1
+hypergeo,lpham,-1,0,0,double,1
+hypergeo,lpham,0,0,0,double,1
+hypergeo,lpham,1,0,0,double,1
+hypergeo,.process_args,-1,0,0,list<class<`matrix`> | list<integer[]>>,1
+hypergeo,.process_args,0,0,0,...,1
+hypergeo,semicircle,-1,0,0,complex[],1
+hypergeo,semicircle,0,0,0,double[],1
+hypergeo,semicircle,1,0,0,double,1
+hypergeo,semicircle,2,0,0,complex,1
+hypergeo,semicircle,3,0,0,logical,1
+hypergeo,semidash,-1,0,0,complex,1
+hypergeo,semidash,0,0,0,double,1
+hypergeo,semidash,1,0,0,double,1
+hypergeo,semidash,2,0,0,complex,1
+hypergeo,semidash,3,0,0,logical,1
+hypergeo,shanks,-1,0,0,complex,1
+hypergeo,shanks,0,0,0,any,1
+hypergeo,shanks,1,0,0,complex,1
+hypergeo,shanks,2,0,0,complex,1
+hypergeo,straight,-1,0,0,double[],1
+hypergeo,straight,0,0,0,double[],1
+hypergeo,straight,1,0,0,double,1
+hypergeo,straight,2,0,0,double,1
+hypergeo,straightdash,-1,0,0,double,1
+hypergeo,straightdash,0,0,0,any,1
+hypergeo,straightdash,1,0,0,double,1
+hypergeo,straightdash,2,0,0,double,1
+hypergeo,thingfun,-1,0,0,class<`matrix`>,1
+hypergeo,thingfun,0,0,0,complex[],1
+hypergeo,thingfun,1,0,0,logical,1
+hypergeo,to_complex,-1,0,0,class<`matrix`>,1
+hypergeo,to_complex,-1,0,1,complex[],1
+hypergeo,to_complex,0,0,0,class<`matrix`>,1
+hypergeo,to_complex,0,0,1,double[],1
+hypergeo,to_real,-1,0,0,double[],1
+hypergeo,to_real,0,0,0,complex[],1
+hypergeo,w07.23.06.0026.01,-1,0,0,complex[],1
+hypergeo,w07.23.06.0026.01,0,0,0,double,1
+hypergeo,w07.23.06.0026.01,1,0,0,double,1
+hypergeo,w07.23.06.0026.01,2,0,0,double,1
+hypergeo,w07.23.06.0026.01,3,0,0,complex[],1
+hypergeo,w07.23.06.0026.01,4,0,0,double,1
+hypergeo,w07.23.06.0026.01,5,0,0,double,1
+hypergeo,w07.23.06.0026.01,6,0,0,character,1
+hypergeo,w07.23.06.0026.01_bit1,-1,0,0,complex,1
+hypergeo,w07.23.06.0026.01_bit1,0,0,0,any,1
+hypergeo,w07.23.06.0026.01_bit1,1,0,0,double,1
+hypergeo,w07.23.06.0026.01_bit1,2,0,0,any,1
+hypergeo,w07.23.06.0026.01_bit1,3,0,0,complex[],1
+hypergeo,w07.23.06.0026.01_bit1,4,0,0,any,1
+hypergeo,w07.23.06.0026.01_bit2,-1,0,0,complex[],1
+hypergeo,w07.23.06.0026.01_bit2,0,0,0,double,1
+hypergeo,w07.23.06.0026.01_bit2,1,0,0,double,1
+hypergeo,w07.23.06.0026.01_bit2,2,0,0,double,1
+hypergeo,w07.23.06.0026.01_bit2,3,0,0,complex[],1
+hypergeo,w07.23.06.0026.01_bit2,4,0,0,double,1
+hypergeo,w07.23.06.0026.01_bit2,5,0,0,double,1
+hypergeo,w07.23.06.0026.01_bit3_a,-1,0,0,complex[],1
+hypergeo,w07.23.06.0026.01_bit3_a,0,0,0,double,1
+hypergeo,w07.23.06.0026.01_bit3_a,1,0,0,double,1
+hypergeo,w07.23.06.0026.01_bit3_a,2,0,0,double,1
+hypergeo,w07.23.06.0026.01_bit3_a,3,0,0,complex[],1
+hypergeo,w07.23.06.0026.01_bit3_a,4,0,0,any,1
+hypergeo,w07.23.06.0029.01,-1,0,0,complex,1
+hypergeo,w07.23.06.0029.01,0,0,0,double,1
+hypergeo,w07.23.06.0029.01,1,0,0,double,1
+hypergeo,w07.23.06.0029.01,2,0,0,double,1
+hypergeo,w07.23.06.0029.01,3,0,0,complex,1
+hypergeo,w07.23.06.0029.01,4,0,0,double,1
+hypergeo,w07.23.06.0029.01,5,0,0,double,1
+hypergeo,w07.23.06.0031.01,-1,0,0,complex,1
+hypergeo,w07.23.06.0031.01,0,0,0,double,1
+hypergeo,w07.23.06.0031.01,1,0,0,double,1
+hypergeo,w07.23.06.0031.01,2,0,0,double,1
+hypergeo,w07.23.06.0031.01,3,0,0,complex,1
+hypergeo,w07.23.06.0031.01,4,0,0,double,1
+hypergeo,w07.23.06.0031.01,5,0,0,double,1
+hypergeo,w07.23.06.0031.01_bit1,-1,0,0,complex,1
+hypergeo,w07.23.06.0031.01_bit1,0,0,0,double,1
+hypergeo,w07.23.06.0031.01_bit1,1,0,0,double,1
+hypergeo,w07.23.06.0031.01_bit1,2,0,0,double,1
+hypergeo,w07.23.06.0031.01_bit1,3,0,0,complex,1
+hypergeo,w07.23.06.0031.01_bit1,4,0,0,any,1
+hypergeo,w07.23.06.0031.01_bit1,5,0,0,any,1
+hypergeo,w07.23.06.0031.01_bit2,-1,0,0,complex,1
+hypergeo,w07.23.06.0031.01_bit2,0,0,0,double,1
+hypergeo,w07.23.06.0031.01_bit2,1,0,0,double,1
+hypergeo,w07.23.06.0031.01_bit2,2,0,0,double,1
+hypergeo,w07.23.06.0031.01_bit2,3,0,0,complex,1
+hypergeo,w07.23.06.0031.01_bit2,4,0,0,double,1
+hypergeo,w07.23.06.0031.01_bit2,5,0,0,double,1
+imputeTS,locf,-1,0,0,double[],1
+imputeTS,locf,0,0,0,^double[],1
+imputeTS,locf,1,0,0,logical,1
+imputeTS,ma,-1,0,0,class<`ts`>,1
+imputeTS,ma,0,0,0,class<`ts`>,1
+imputeTS,ma,1,0,0,double,1
+imputeTS,ma,2,0,0,character,1
+imputeTS,na_locf,-1,0,0,class<`ts`>,1
+imputeTS,na_locf,0,0,0,class<`ts`>,1
+imputeTS,na_locf,1,0,0,character,1
+imputeTS,na_locf,2,0,0,any,1
+imputeTS,na_locf,3,0,0,double,1
+imputeTS,na.locf,-1,0,0,class<`ts`>,1
+imputeTS,na.locf,0,0,0,class<`ts`>,1
+imputeTS,na.locf,1,0,0,character,1
+imputeTS,na.locf,2,0,0,character,1
+imputeTS,na.locf,3,0,0,double,1
+imputeTS,na_ma,-1,0,0,class<`ts`>,1
+imputeTS,na_ma,0,0,0,class<`ts`>,1
+imputeTS,na_ma,1,0,0,double,1
+imputeTS,na_ma,2,0,0,character,1
+imputeTS,na_ma,3,0,0,double,1
+imputeTS,na_mean,-1,0,0,class<`ts`>,1
+imputeTS,na_mean,0,0,0,class<`ts`>,1
+imputeTS,na_mean,1,0,0,character,1
+imputeTS,na_mean,2,0,0,double,1
+imputeTS,na.mean,-1,0,0,class<`ts`>,1
+imputeTS,na.mean,0,0,0,class<`ts`>,1
+imputeTS,na.mean,1,0,0,character,1
+imputeTS,na.mean,2,0,0,double,1
+imputeTS,na_replace,-1,0,0,class<`ts`>,1
+imputeTS,na_replace,0,0,0,class<`ts`>,1
+imputeTS,na_replace,1,0,0,double,1
+imputeTS,na_replace,2,0,0,double,1
+imputeTS,plotNA.distribution,-1,0,0,null,1
+imputeTS,plotNA.distribution,0,0,0,class<`ts`>,1
+imputeTS,plotNA.distribution,1,0,0,character,1
+imputeTS,plotNA.distribution,2,0,0,character,1
+imputeTS,plotNA.distribution,3,0,0,character,1
+imputeTS,plotNA.distribution,4,0,0,character,1
+imputeTS,plotNA.distribution,5,0,0,character,1
+imputeTS,plotNA.distribution,6,0,0,double,1
+imputeTS,plotNA.distribution,7,0,0,double,1
+imputeTS,plotNA.distribution,8,0,0,character,1
+imputeTS,plotNA.distribution,9,0,0,...,1
+imputeTS,plotNA.distributionBar,-1,0,0,list<list<double[]>>,1
+imputeTS,plotNA.distributionBar,0,0,0,class<`ts`>,1
+imputeTS,plotNA.distributionBar,1,0,0,double,1
+imputeTS,plotNA.distributionBar,2,0,0,null,1
+imputeTS,plotNA.distributionBar,3,0,0,logical,1
+imputeTS,plotNA.distributionBar,4,0,0,logical,1
+imputeTS,plotNA.distributionBar,5,0,0,logical,1
+imputeTS,plotNA.distributionBar,6,0,0,double,1
+imputeTS,plotNA.distributionBar,7,0,0,character[],1
+imputeTS,plotNA.distributionBar,8,0,0,character,1
+imputeTS,plotNA.distributionBar,9,0,0,character,1
+imputeTS,plotNA.distributionBar,10,0,0,null,1
+imputeTS,plotNA.distributionBar,11,0,0,...,1
+imputeTS,plotNA.gapsize,-1,0,0,list<list<double[]>>,1
+imputeTS,plotNA.gapsize,0,0,0,class<`ts`>,1
+imputeTS,plotNA.gapsize,1,0,0,double,1
+imputeTS,plotNA.gapsize,2,0,0,logical,1
+imputeTS,plotNA.gapsize,3,0,0,logical,1
+imputeTS,plotNA.gapsize,4,0,0,character[],1
+imputeTS,plotNA.gapsize,5,0,0,character,1
+imputeTS,plotNA.gapsize,6,0,0,character,1
+imputeTS,plotNA.gapsize,7,0,0,character,1
+imputeTS,plotNA.gapsize,8,0,0,double,1
+imputeTS,plotNA.gapsize,9,0,0,logical,1
+imputeTS,plotNA.gapsize,10,0,0,logical,1
+imputeTS,plotNA.gapsize,11,0,0,logical,1
+imputeTS,plotNA.gapsize,12,0,0,double,1
+imputeTS,plotNA.gapsize,13,0,0,...,1
+imputeTS,plotNA.imputations,-1,0,0,list<list<double[]>>,1
+imputeTS,plotNA.imputations,0,0,0,class<`ts`>,1
+imputeTS,plotNA.imputations,1,0,0,class<`ts`>,1
+imputeTS,plotNA.imputations,2,0,0,class<`ts`>,1
+imputeTS,plotNA.imputations,2,0,1,null,1
+imputeTS,plotNA.imputations,3,0,0,logical,1
+imputeTS,plotNA.imputations,4,0,0,character,1
+imputeTS,plotNA.imputations,5,0,0,character,1
+imputeTS,plotNA.imputations,6,0,0,character,1
+imputeTS,plotNA.imputations,7,0,0,character,1
+imputeTS,plotNA.imputations,8,0,0,character,1
+imputeTS,plotNA.imputations,9,0,0,character,1
+imputeTS,plotNA.imputations,10,0,0,character,1
+imputeTS,plotNA.imputations,11,0,0,double[],1
+imputeTS,plotNA.imputations,12,0,0,double,1
+imputeTS,plotNA.imputations,13,0,0,double,1
+imputeTS,plotNA.imputations,14,0,0,...,1
+imputeTS,statsNA,-1,0,0,null,1
+imputeTS,statsNA,-1,0,1,list<integer | character>,1
+imputeTS,statsNA,0,0,0,class<`ts`>,1
+imputeTS,statsNA,1,0,0,double,1
+imputeTS,statsNA,2,0,0,logical,1
+infotheo,condentropy,-1,0,0,double,1
+infotheo,condentropy,0,0,0,integer[],1
+infotheo,condentropy,1,0,0,integer[],1
+infotheo,condentropy,2,0,0,character,1
+infotheo,condinformation,-1,0,0,double,1
+infotheo,condinformation,0,0,0,integer[],1
+infotheo,condinformation,1,0,0,integer[],1
+infotheo,condinformation,2,0,0,integer[],1
+infotheo,condinformation,3,0,0,character,1
+infotheo,discretize,-1,0,0,class<`data.frame`>,1
+infotheo,discretize,0,0,0,class<`data.frame`>,1
+infotheo,discretize,1,0,0,character,1
+infotheo,discretize,2,0,0,double,1
+infotheo,entropy,-1,0,0,double,1
+infotheo,entropy,0,0,0,class<`data.frame`>,1
+infotheo,entropy,0,0,1,integer[],1
+infotheo,entropy,1,0,0,character,1
+infotheo,interinformation,-1,0,0,double,1
+infotheo,interinformation,0,0,0,class<`data.frame`>,1
+infotheo,interinformation,1,0,0,character,1
+infotheo,multiinformation,-1,0,0,double,1
+infotheo,multiinformation,0,0,0,class<`data.frame`>,1
+infotheo,multiinformation,1,0,0,character,1
+infotheo,mutinformation,-1,0,0,class<`matrix`>,1
+infotheo,mutinformation,-1,0,1,double,1
+infotheo,mutinformation,0,0,0,class<`data.frame`>,1
+infotheo,mutinformation,0,0,1,integer[],1
+infotheo,mutinformation,1,0,0,null,1
+infotheo,mutinformation,1,0,1,integer[],1
+infotheo,mutinformation,2,0,0,character,1
+infotheo,natstobits,-1,0,0,double,1
+infotheo,natstobits,0,0,0,double,1
+ini,read.ini,-1,0,0,list<list<character>>,1
+ini,read.ini,0,0,0,character,1
+ini,read.ini,1,0,0,character,1
+ini,write.ini,-1,0,0,null,1
+ini,write.ini,0,0,0,list<list<character>>,1
+ini,write.ini,1,0,0,character,1
+ini,write.ini,2,0,0,character,1
+irlba,convtests,-1,0,0,list<double>,1
+irlba,convtests,0,0,0,any,1
+irlba,convtests,1,0,0,double,1
+irlba,convtests,2,0,0,double,1
+irlba,convtests,3,0,0,list<double[] | class<`matrix`>>,1
+irlba,convtests,4,0,0,class<`matrix`>,1
+irlba,convtests,5,0,0,double,1
+irlba,convtests,6,0,0,double,1
+irlba,convtests,7,0,0,double[],1
+irlba,convtests,7,0,1,null,1
+irlba,convtests,8,0,0,double,1
+irlba,convtests,9,0,0,any,1
+irlba,convtests,10,0,0,any,1
+irlba,convtests,11,0,0,any,1
+irlba,cross,-1,0,0,class<`matrix`>,1
+irlba,cross,0,0,0,class<`matrix`>,1
+irlba,cross,0,0,1,complex[],1
+irlba,cross,1,0,0,any,1
+irlba,irlba,-1,0,0,list<any>,1
+irlba,irlba,0,0,0,class<`matrix`>,1
+irlba,irlba,0,0,1,class<`dgCMatrix`>,1
+irlba,irlba,0,0,2,class<`dgTMatrix`>,1
+irlba,irlba,0,0,3,class<`scaled_matrix`>,1
+irlba,irlba,0,0,4,class<`dgeMatrix`>,1
+irlba,irlba,0,0,5,class<`lgCMatrix`>,1
+irlba,irlba,1,0,0,double,1
+irlba,irlba,2,0,0,double,1
+irlba,irlba,3,0,0,double,1
+irlba,irlba,4,0,0,double,1
+irlba,irlba,5,0,0,logical,1
+irlba,irlba,6,0,0,double,1
+irlba,irlba,7,0,0,double[],1
+irlba,irlba,7,0,1,null,1
+irlba,irlba,7,0,2,list<double[] | class<`matrix`>>,1
+irlba,irlba,8,0,0,logical,1
+irlba,irlba,9,0,0,logical,1
+irlba,irlba,10,0,0,null,1
+irlba,irlba,10,0,1,double[],1
+irlba,irlba,11,0,0,null,1
+irlba,irlba,11,0,1,double[],1
+irlba,irlba,12,0,0,null,1
+irlba,irlba,12,0,1,double,1
+irlba,irlba,13,0,0,null,1
+irlba,irlba,14,0,0,any,1
+irlba,irlba,15,0,0,any,1
+irlba,norm2,-1,0,0,double,1
+irlba,norm2,0,0,0,class<`matrix`>,1
+irlba,norm2,0,0,1,complex[],1
+irlba,orthog,-1,0,0,class<`matrix`>,1
+irlba,orthog,0,0,0,class<`matrix`>,1
+irlba,orthog,0,0,1,complex[],1
+irlba,orthog,1,0,0,class<`matrix`>,1
+irlba,orthog,1,0,1,complex[],1
+irlba,partial_eigen,-1,0,0,list<class<`matrix`> | double[]>,1
+irlba,partial_eigen,0,0,0,class<`matrix`>,1
+irlba,partial_eigen,1,0,0,double,1
+irlba,partial_eigen,2,0,0,logical,1
+irlba,partial_eigen,3,0,0,...,1
+irlba,prcomp_irlba,-1,0,0,"class<`irlba_prcomp`, `prcomp`>",1
+irlba,prcomp_irlba,0,0,0,class<`matrix`>,1
+irlba,prcomp_irlba,1,0,0,double,1
+irlba,prcomp_irlba,2,0,0,logical,1
+irlba,prcomp_irlba,3,0,0,logical,1
+irlba,prcomp_irlba,4,0,0,logical,1
+irlba,prcomp_irlba,5,0,0,...,1
+irlba,ssvd,-1,0,0,list<class<`matrix`> | double[]>,1
+irlba,ssvd,-1,0,1,list<class<`matrix`> | double>,1
+irlba,ssvd,0,0,0,class<`matrix`>,1
+irlba,ssvd,1,0,0,double,1
+irlba,ssvd,2,0,0,double[],1
+irlba,ssvd,3,0,0,double,1
+irlba,ssvd,4,0,0,double,1
+irlba,ssvd,5,0,0,logical,1
+irlba,ssvd,6,0,0,logical,1
+irlba,ssvd,7,0,0,double,1
+irlba,ssvd,8,0,0,null,1
+irlba,ssvd,9,0,0,...,1
+irlba,summary.irlba_prcomp,-1,0,0,class<`summary.prcomp`>,1
+irlba,summary.irlba_prcomp,0,0,0,"class<`irlba_prcomp`, `prcomp`>",1
+irlba,summary.irlba_prcomp,1,0,0,...,1
+irlba,svdr,-1,0,0,list<double[] | class<`matrix`>>,1
+irlba,svdr,-1,0,1,list<double[]>,1
+irlba,svdr,0,0,0,class<`dgeMatrix`>,1
+irlba,svdr,0,0,1,class<`matrix`>,1
+irlba,svdr,0,0,2,class<`lgCMatrix`>,1
+irlba,svdr,1,0,0,double,1
+irlba,svdr,2,0,0,double,1
+irlba,svdr,3,0,0,integer,1
+irlba,svdr,4,0,0,double,1
+irlba,svdr,5,0,0,double[],1
+irlba,svdr,5,0,1,null,1
+irlba,svdr,6,0,0,null,1
+irlba,svdr,7,0,0,logical,1
+irr,agree,-1,0,0,class<`irrlist`>,1
+irr,agree,0,0,0,class<`data.frame`>,1
+irr,agree,1,0,0,double,1
+irr,bhapkar,-1,0,0,class<`irrlist`>,1
+irr,bhapkar,0,0,0,class<`data.frame`>,1
+irr,finn,-1,0,0,class<`irrlist`>,1
+irr,finn,0,0,0,class<`data.frame`>,1
+irr,finn,1,0,0,double,1
+irr,finn,2,0,0,character[],1
+irr,icc,-1,0,0,class<`icclist`>,1
+irr,icc,0,0,0,class<`data.frame`>,1
+irr,icc,0,0,1,class<`matrix`>,1
+irr,icc,1,0,0,character,1
+irr,icc,2,0,0,character[],1
+irr,icc,3,0,0,character[],1
+irr,icc,4,0,0,double,1
+irr,icc,5,0,0,double,1
+irr,iota,-1,0,0,class<`irrlist`>,1
+irr,iota,0,0,0,list<class<`data.frame`>>,1
+irr,iota,0,0,1,list<class<`matrix`>>,1
+irr,iota,1,0,0,character[],1
+irr,iota,2,0,0,logical,1
+irr,kappa2,-1,0,0,class<`irrlist`>,1
+irr,kappa2,0,0,0,class<`data.frame`>,1
+irr,kappa2,0,0,1,class<`matrix`>,1
+irr,kappa2,1,0,0,character[],1
+irr,kappa2,1,0,1,double[],1
+irr,kappa2,2,0,0,logical,1
+irr,kappam.fleiss,-1,0,0,class<`irrlist`>,1
+irr,kappam.fleiss,0,0,0,class<`data.frame`>,1
+irr,kappam.fleiss,1,0,0,logical,1
+irr,kappam.fleiss,2,0,0,logical,1
+irr,kappam.light,-1,0,0,class<`irrlist`>,1
+irr,kappam.light,0,0,0,class<`data.frame`>,1
+irr,kendall,-1,0,0,class<`irrlist`>,1
+irr,kendall,0,0,0,class<`data.frame`>,1
+irr,kendall,1,0,0,logical,1
+irr,kripp.alpha,-1,0,0,class<`irrlist`>,1
+irr,kripp.alpha,0,0,0,class<`matrix`>,1
+irr,kripp.alpha,1,0,0,character[],1
+irr,maxwell,-1,0,0,class<`irrlist`>,1
+irr,maxwell,0,0,0,class<`matrix`>,1
+irr,meancor,-1,0,0,class<`irrlist`>,1
+irr,meancor,0,0,0,class<`data.frame`>,1
+irr,meancor,1,0,0,logical,1
+irr,meanrho,-1,0,0,class<`irrlist`>,1
+irr,meanrho,0,0,0,class<`data.frame`>,1
+irr,meanrho,1,0,0,logical,1
+irr,N2.cohen.kappa,-1,0,0,double,1
+irr,N2.cohen.kappa,0,0,0,double[],1
+irr,N2.cohen.kappa,1,0,0,double,1
+irr,N2.cohen.kappa,2,0,0,double,1
+irr,N2.cohen.kappa,3,0,0,double,1
+irr,N2.cohen.kappa,4,0,0,double,1
+irr,N2.cohen.kappa,5,0,0,logical,1
+irr,N.cohen.kappa,-1,0,0,double,1
+irr,N.cohen.kappa,0,0,0,double,1
+irr,N.cohen.kappa,1,0,0,double,1
+irr,N.cohen.kappa,2,0,0,double,1
+irr,N.cohen.kappa,3,0,0,double,1
+irr,N.cohen.kappa,4,0,0,double,1
+irr,N.cohen.kappa,5,0,0,double,1
+irr,N.cohen.kappa,6,0,0,logical,1
+irr,rater.bias,-1,0,0,class<`irrlist`>,1
+irr,rater.bias,0,0,0,class<`data.frame`>,1
+irr,rater.bias,0,0,1,class<`matrix`>,1
+irr,relInterIntra,-1,0,0,class<`irrlist`>,1
+irr,relInterIntra,0,0,0,class<`matrix`>,1
+irr,relInterIntra,1,0,0,double,1
+irr,relInterIntra,2,0,0,character[],1
+irr,relInterIntra,3,0,0,double,1
+irr,relInterIntra,4,0,0,double,1
+irr,relInterIntra,5,0,0,double,1
+irr,robinson,-1,0,0,class<`irrlist`>,1
+irr,robinson,0,0,0,class<`data.frame`>,1
+irr,stuart.maxwell.mh,-1,0,0,class<`irrlist`>,1
+irr,stuart.maxwell.mh,0,0,0,class<`data.frame`>,1
+irr,stuart.maxwell.mh,0,0,1,class<`matrix`>,1
+isotone,activeSet,-1,0,0,class<`activeset`>,1
+isotone,activeSet,0,0,0,class<`matrix`>,1
+isotone,activeSet,1,0,0,character,1
+isotone,activeSet,1,0,1,class<`function`>,1
+isotone,activeSet,2,0,0,integer[],1
+isotone,activeSet,2,0,1,null,1
+isotone,activeSet,3,0,0,double,1
+isotone,activeSet,4,0,0,logical,1
+isotone,activeSet,5,0,0,double,1
+isotone,activeSet,6,0,0,...,1
+isotone,aTx,-1,0,0,double[],1
+isotone,aTx,0,0,0,class<`matrix`>,1
+isotone,aTx,1,0,0,double[],1
+isotone,b2a,-1,0,0,class<`matrix`>,1
+isotone,b2a,0,0,0,class<`matrix`>,1
+isotone,b2a,1,0,0,integer,1
+isotone,checkSol,-1,0,0,^double[],1
+isotone,checkSol,0,0,0,any,1
+isotone,checkSol,1,0,0,double[],1
+isotone,checkSol,2,0,0,any,1
+isotone,checkSol,3,0,0,double[],1
+isotone,checkSol,4,0,0,^double[],1
+isotone,checkSol,5,0,0,^double[],1
+isotone,checkSol,6,0,0,any,1
+isotone,fSolver,-1,0,0,list<double[]>,1
+isotone,fSolver,0,0,0,double[],1
+isotone,fSolver,1,0,0,class<`matrix`>,1
+isotone,fSolver,1,0,1,integer[],1
+isotone,fSolver,1,0,2,null,1
+isotone,fSolver,2,0,0,list<class<`function`>>,1
+isotone,fSolver,2,0,1,list<class<`function`> | double[]>,1
+isotone,fSolver,2,0,2,list<double[] | class<`function`>>,1
+isotone,gpava,-1,0,0,class<`gpava`>,1
+isotone,gpava,0,0,0,double[],1
+isotone,gpava,0,0,1,null,1
+isotone,gpava,1,0,0,class<`data.frame`>,1
+isotone,gpava,1,0,1,class<`matrix`>,1
+isotone,gpava,1,0,2,double[],1
+isotone,gpava,2,0,0,null,1
+isotone,gpava,3,0,0,class<`function`>,1
+isotone,gpava,4,0,0,character,1
+isotone,gpava,5,0,0,null,1
+isotone,gpava,5,0,1,double,1
+isotone,is.active,-1,0,0,integer[],1
+isotone,is.active,0,0,0,double[],1
+isotone,is.active,1,0,0,double,1
+isotone,is.pos,-1,0,0,logical,1
+isotone,is.pos,0,0,0,double,1
+isotone,is.pos,1,0,0,double,1
+isotone,mkIndi,-1,0,0,class<`matrix`>,1
+isotone,mkIndi,0,0,0,class<`matrix`>,1
+isotone,mkIndi,1,0,0,integer,1
+isotone,mkLagrange,-1,0,0,^double[],1
+isotone,mkLagrange,0,0,0,class<`matrix`>,1
+isotone,mkLagrange,1,0,0,double[],1
+isotone,mregnn,-1,0,0,list<double[]>,1
+isotone,mregnn,0,0,0,class<`matrix`>,1
+isotone,mregnn,1,0,0,double[],1
+isotone,mregnn,2,0,0,class<`matrix`>,1
+isotone,mregnnM,-1,0,0,list<double[]>,1
+isotone,mregnnM,0,0,0,class<`matrix`>,1
+isotone,mregnnM,1,0,0,double[],1
+isotone,plot.gpava,-1,0,0,null,1
+isotone,plot.gpava,0,0,0,class<`gpava`>,1
+isotone,plot.gpava,1,0,0,character,1
+isotone,plot.gpava,2,0,0,character,1
+isotone,plot.gpava,3,0,0,character,1
+isotone,plot.gpava,4,0,0,character,1
+isotone,plot.gpava,5,0,0,...,1
+isotone,summary.activeset,-1,0,0,null,1
+isotone,summary.activeset,0,0,0,class<`activeset`>,1
+isotone,summary.activeset,1,0,0,...,1
+isotone,taTx,-1,0,0,^double[],1
+isotone,taTx,0,0,0,class<`matrix`>,1
+isotone,taTx,1,0,0,^double[],1
+isotone,taTx,2,0,0,integer,1
+isotone,warshall,-1,0,0,class<`matrix`>,1
+isotone,warshall,0,0,0,class<`matrix`>,1
+isotone,weighted.fractile,-1,0,0,integer,1
+isotone,weighted.fractile,0,0,0,integer[],1
+isotone,weighted.fractile,1,0,0,double[],1
+isotone,weighted.fractile,2,0,0,double,1
+isotone,weightedFractile,-1,0,0,double,1
+isotone,weightedFractile,0,0,0,double[],1
+isotone,weightedFractile,1,0,0,double[],1
+isotone,weightedFractile,2,0,0,double,1
+isotone,weightedFractile,3,0,0,double,1
+isotone,weighted.median,-1,0,0,integer,1
+isotone,weighted.median,0,0,0,integer[],1
+isotone,weighted.median,1,0,0,double[],1
+isotone,weightedMedian,-1,0,0,double,1
+isotone,weightedMedian,0,0,0,double[],1
+isotone,weightedMedian,1,0,0,double[],1
+isotone,weightedMidRange,-1,0,0,double,1
+isotone,weightedMidRange,0,0,0,double[],1
+isotone,weightedMidRange,1,0,0,double[],1
+iterators,as.list.iter,-1,0,0,list<class<`matrix`>>,1
+iterators,as.list.iter,-1,0,1,list<double>,1
+iterators,as.list.iter,-1,0,2,list<integer[]>,1
+iterators,as.list.iter,0,0,0,"class<`iter`, `matrixiter`>",1
+iterators,as.list.iter,0,0,1,"class<`abstractiter`, `iter`>",1
+iterators,as.list.iter,0,0,2,"class<`abstractiter`, `iforever`, `iter`>",1
+iterators,as.list.iter,0,0,3,"class<`abstractiter`, `irep`, `iter`>",1
+iterators,as.list.iter,0,0,4,"class<`abstractiter`, `ilimit`, `iter`>",1
+iterators,as.list.iter,0,0,5,"class<`abstractiter`, `irecycle`, `iter`>",1
+iterators,as.list.iter,0,0,6,"class<`abstractiter`, `iter`, `ivector`>",1
+iterators,as.list.iter,0,0,7,"class<`containeriter`, `iter`>",1
+iterators,as.list.iter,1,0,0,double,1
+iterators,as.list.iter,2,0,0,...,1
+iterators,getIterVal,-1,0,0,any,1
+iterators,getIterVal,0,0,0,"class<`containeriter`, `iter`>",1
+iterators,getIterVal,0,0,1,"class<`dataframeiter`, `iter`>",1
+iterators,getIterVal,0,0,2,"class<`iter`, `matrixiter`>",1
+iterators,getIterVal,1,0,0,any,1
+iterators,getIterVal,2,0,0,...,1
+iterators,getIterVal.containeriter,-1,0,0,any,1
+iterators,getIterVal.containeriter,0,0,0,"class<`containeriter`, `iter`>",1
+iterators,getIterVal.containeriter,1,0,0,integer,1
+iterators,getIterVal.containeriter,2,0,0,...,1
+iterators,getIterVal.dataframeiter,-1,0,0,any,1
+iterators,getIterVal.dataframeiter,0,0,0,"class<`dataframeiter`, `iter`>",1
+iterators,getIterVal.dataframeiter,1,0,0,integer,1
+iterators,getIterVal.dataframeiter,2,0,0,logical,1
+iterators,getIterVal.dataframeiter,3,0,0,...,1
+iterators,getIterVal.matrixiter,-1,0,0,any,1
+iterators,getIterVal.matrixiter,0,0,0,"class<`iter`, `matrixiter`>",1
+iterators,getIterVal.matrixiter,1,0,0,integer,1
+iterators,getIterVal.matrixiter,2,0,0,...,1
+iterators,iapply,-1,0,0,"class<`abstractiter`, `iter`>",1
+iterators,iapply,0,0,0,class<`array`>,1
+iterators,iapply,0,0,1,class<`matrix`>,1
+iterators,iapply,1,0,0,double[],1
+iterators,icount,-1,0,0,"class<`abstractiter`, `iter`>",1
+iterators,icount,0,0,0,double,1
+iterators,icountn,-1,0,0,"class<`abstractiter`, `iter`>",1
+iterators,icountn,0,0,0,double[],1
+iterators,idiv,-1,0,0,"class<`abstractiter`, `iter`>",1
+iterators,idiv,0,0,0,double,1
+iterators,idiv,1,0,0,...,1
+iterators,idiv,2,0,0,any,1
+iterators,idiv,3,0,0,any,1
+iterators,ireadLines,-1,0,0,"class<`abstractiter`, `iter`>",1
+iterators,ireadLines,0,0,0,character,1
+iterators,ireadLines,1,0,0,double,1
+iterators,ireadLines,2,0,0,...,1
+iterators,irnorm,-1,0,0,"class<`abstractiter`, `iter`>",1
+iterators,irnorm,0,0,0,...,1
+iterators,irnorm,1,0,0,any,1
+iterators,irunif,-1,0,0,"class<`abstractiter`, `iter`>",1
+iterators,irunif,0,0,0,...,1
+iterators,irunif,1,0,0,any,1
+iterators,isplit,-1,0,0,"class<`abstractiter`, `iter`>",1
+iterators,isplit,0,0,0,double[],1
+iterators,isplit,1,0,0,class<`factor`>,1
+iterators,isplit,1,0,1,list<class<`factor`>>,1
+iterators,isplit,2,0,0,logical,1
+iterators,isplit,3,0,0,...,1
+iterators,isplit.default,-1,0,0,"class<`abstractiter`, `iter`>",1
+iterators,isplit.default,0,0,0,double[],1
+iterators,isplit.default,1,0,0,class<`factor`>,1
+iterators,isplit.default,1,0,1,list<class<`factor`>>,1
+iterators,isplit.default,2,0,0,logical,1
+iterators,isplit.default,3,0,0,...,1
+iterators,iter,-1,0,0,"class<`abstractiter`, `iforever`, `iter`>",1
+iterators,iter,-1,0,1,"class<`abstractiter`, `irecycle`, `iter`>",1
+iterators,iter,-1,0,2,"class<`abstractiter`, `iter`>",1
+iterators,iter,-1,0,3,"class<`containeriter`, `iter`>",1
+iterators,iter,-1,0,4,"class<`dataframeiter`, `iter`>",1
+iterators,iter,-1,0,5,"class<`funiter`, `iter`>",1
+iterators,iter,-1,0,6,"class<`iforeach`, `iter`>",1
+iterators,iter,-1,0,7,"class<`iter`, `matrixiter`>",1
+iterators,iter,0,0,0,"class<`abstractiter`, `iforever`, `iter`>",1
+iterators,iter,0,0,1,"class<`abstractiter`, `irecycle`, `iter`>",1
+iterators,iter,0,0,2,"class<`abstractiter`, `iter`>",1
+iterators,iter,0,0,3,character[],1
+iterators,iter,0,0,4,"class<`containeriter`, `iter`>",1
+iterators,iter,0,0,5,double[],1
+iterators,iter,0,0,6,list<integer[]>,1
+iterators,iter,0,0,7,class<`data.frame`>,1
+iterators,iter,0,0,8,"class<`dataframeiter`, `iter`>",1
+iterators,iter,0,0,9,class<`function`>,1
+iterators,iter,0,0,10,class<`foreach`>,1
+iterators,iter,0,0,11,class<`matrix`>,1
+iterators,iter,1,0,0,...,1
+iterators,iter.data.frame,-1,0,0,"class<`dataframeiter`, `iter`>",1
+iterators,iter.data.frame,0,0,0,class<`data.frame`>,1
+iterators,iter.data.frame,1,0,0,character[],1
+iterators,iter.data.frame,2,0,0,class<`function`>,1
+iterators,iter.data.frame,3,0,0,logical,1
+iterators,iter.data.frame,4,0,0,...,1
+iterators,iter.default,-1,0,0,"class<`containeriter`, `iter`>",1
+iterators,iter.default,0,0,0,character[],1
+iterators,iter.default,0,0,1,double[],1
+iterators,iter.default,0,0,2,list<integer[]>,1
+iterators,iter.default,1,0,0,class<`function`>,1
+iterators,iter.default,2,0,0,logical,1
+iterators,iter.default,3,0,0,...,1
+iterators,iter.function,-1,0,0,"class<`funiter`, `iter`>",1
+iterators,iter.function,0,0,0,class<`function`>,1
+iterators,iter.function,1,0,0,class<`function`>,1
+iterators,iter.function,2,0,0,logical,1
+iterators,iter.function,3,0,0,...,1
+iterators,iter.iter,-1,0,0,"class<`abstractiter`, `iforever`, `iter`>",1
+iterators,iter.iter,-1,0,1,"class<`abstractiter`, `irecycle`, `iter`>",1
+iterators,iter.iter,-1,0,2,"class<`abstractiter`, `iter`>",1
+iterators,iter.iter,-1,0,3,"class<`containeriter`, `iter`>",1
+iterators,iter.iter,-1,0,4,"class<`dataframeiter`, `iter`>",1
+iterators,iter.iter,0,0,0,"class<`abstractiter`, `iforever`, `iter`>",1
+iterators,iter.iter,0,0,1,"class<`abstractiter`, `irecycle`, `iter`>",1
+iterators,iter.iter,0,0,2,"class<`abstractiter`, `iter`>",1
+iterators,iter.iter,0,0,3,"class<`containeriter`, `iter`>",1
+iterators,iter.iter,0,0,4,"class<`dataframeiter`, `iter`>",1
+iterators,iter.iter,1,0,0,...,1
+iterators,iter.matrix,-1,0,0,"class<`iter`, `matrixiter`>",1
+iterators,iter.matrix,0,0,0,class<`matrix`>,1
+iterators,iter.matrix,1,0,0,character,1
+iterators,iter.matrix,2,0,0,integer,1
+iterators,iter.matrix,3,0,0,class<`function`>,1
+iterators,iter.matrix,4,0,0,logical,1
+iterators,iter.matrix,5,0,0,...,1
+iterators,iwhich,-1,0,0,integer[],1
+iterators,iwhich,0,0,0,list<integer[]>,1
+iterators,iwhich,1,0,0,integer[],1
+iterators,makeIwrapper,-1,0,0,class<`function`>,1
+iterators,makeIwrapper,0,0,0,character,1
+iterators,nextElem,-1,0,0,any,1
+iterators,nextElem,0,0,0,"class<`dataframeiter`, `iter`>",1
+iterators,nextElem,0,0,1,"class<`containeriter`, `iter`>",1
+iterators,nextElem,0,0,2,"class<`abstractiter`, `iter`>",1
+iterators,nextElem,0,0,3,"class<`abstractiter`, `iforever`, `iter`>",1
+iterators,nextElem,0,0,4,"class<`abstractiter`, `ihasNext`, `iter`>",1
+iterators,nextElem,0,0,5,"class<`abstractiter`, `ilimit`, `iter`>",1
+iterators,nextElem,0,0,6,"class<`iter`, `matrixiter`>",1
+iterators,nextElem,0,0,7,"class<`abstractiter`, `irep`, `iter`>",1
+iterators,nextElem,0,0,8,"class<`funiter`, `iter`>",1
+iterators,nextElem,0,0,9,"class<`abstractiter`, `iter`, `ivector`>",1
+iterators,nextElem,0,0,10,"class<`abstractiter`, `irecycle`, `iter`>",1
+iterators,nextElem,0,0,11,"class<`iforeach`, `iter`>",1
+iterators,nextElem,1,0,0,...,1
+iterators,nextElem.abstractiter,-1,0,0,any,1
+iterators,nextElem.abstractiter,0,0,0,"class<`abstractiter`, `iforever`, `iter`>",1
+iterators,nextElem.abstractiter,0,0,1,"class<`abstractiter`, `ihasNext`, `iter`>",1
+iterators,nextElem.abstractiter,0,0,2,"class<`abstractiter`, `ilimit`, `iter`>",1
+iterators,nextElem.abstractiter,0,0,3,"class<`abstractiter`, `iter`>",1
+iterators,nextElem.abstractiter,0,0,4,"class<`abstractiter`, `irep`, `iter`>",1
+iterators,nextElem.abstractiter,0,0,5,"class<`abstractiter`, `iter`, `ivector`>",1
+iterators,nextElem.abstractiter,0,0,6,"class<`abstractiter`, `irecycle`, `iter`>",1
+iterators,nextElem.abstractiter,1,0,0,...,1
+iterators,nextElem.containeriter,-1,0,0,any,1
+iterators,nextElem.containeriter,0,0,0,"class<`containeriter`, `iter`>",1
+iterators,nextElem.containeriter,1,0,0,...,1
+iterators,nextElem.dataframeiter,-1,0,0,any,1
+iterators,nextElem.dataframeiter,0,0,0,"class<`dataframeiter`, `iter`>",1
+iterators,nextElem.dataframeiter,1,0,0,...,1
+iterators,nextElem.funiter,-1,0,0,any,1
+iterators,nextElem.funiter,0,0,0,"class<`funiter`, `iter`>",1
+iterators,nextElem.funiter,1,0,0,...,1
+iterators,nextElem.matrixiter,-1,0,0,any,1
+iterators,nextElem.matrixiter,0,0,0,"class<`iter`, `matrixiter`>",1
+iterators,nextElem.matrixiter,1,0,0,...,1
+janitor,adorn_ns,-1,0,0,"class<`data.frame`, `grouped_df`, `tbl`, `tbl_df`>",1
+janitor,adorn_ns,-1,0,1,"class<`data.frame`, `tabyl`>",1
+janitor,adorn_ns,-1,0,2,"list<class<`data.frame`, `tabyl`>>",1
+janitor,adorn_ns,0,0,0,"class<`data.frame`, `grouped_df`, `tbl`, `tbl_df`>",1
+janitor,adorn_ns,0,0,1,"class<`data.frame`, `tabyl`>",1
+janitor,adorn_ns,0,0,2,"list<class<`data.frame`, `tabyl`>>",1
+janitor,adorn_ns,1,0,0,character,1
+janitor,adorn_ns,2,0,0,any,1
+janitor,adorn_pct_formatting,-1,0,0,"class<`data.frame`, `tabyl`>",1
+janitor,adorn_pct_formatting,-1,0,1,"class<`data.frame`, `tbl`, `tbl_df`>",1
+janitor,adorn_pct_formatting,-1,0,2,"list<class<`data.frame`, `tabyl`>>",1
+janitor,adorn_pct_formatting,0,0,0,"class<`data.frame`, `tabyl`>",1
+janitor,adorn_pct_formatting,0,0,1,"class<`data.frame`, `tbl`, `tbl_df`>",1
+janitor,adorn_pct_formatting,0,0,2,"list<class<`data.frame`, `tabyl`>>",1
+janitor,adorn_pct_formatting,1,0,0,double,1
+janitor,adorn_pct_formatting,2,0,0,character,1
+janitor,adorn_pct_formatting,3,0,0,logical,1
+janitor,adorn_percentages,-1,0,0,"class<`data.frame`, `tabyl`>",1
+janitor,adorn_percentages,-1,0,1,"list<class<`data.frame`, `tabyl`>>",1
+janitor,adorn_percentages,0,0,0,"class<`data.frame`, `tabyl`>",1
+janitor,adorn_percentages,0,0,1,"list<class<`data.frame`, `tabyl`>>",1
+janitor,adorn_percentages,1,0,0,character,1
+janitor,adorn_percentages,2,0,0,any,1
+janitor,adorn_rounding,-1,0,0,class<`data.frame`>,1
+janitor,adorn_rounding,-1,0,1,"class<`data.frame`, `grouped_df`, `tbl`, `tbl_df`>",1
+janitor,adorn_rounding,-1,0,2,"class<`data.frame`, `tabyl`>",1
+janitor,adorn_rounding,-1,0,3,"class<`data.frame`, `tbl`, `tbl_df`>",1
+janitor,adorn_rounding,0,0,0,class<`data.frame`>,1
+janitor,adorn_rounding,0,0,1,"class<`data.frame`, `grouped_df`, `tbl`, `tbl_df`>",1
+janitor,adorn_rounding,0,0,2,"class<`data.frame`, `tabyl`>",1
+janitor,adorn_rounding,0,0,3,"class<`data.frame`, `tbl`, `tbl_df`>",1
+janitor,adorn_rounding,1,0,0,double,1
+janitor,adorn_rounding,2,0,0,character,1
+janitor,adorn_rounding,3,0,0,logical,1
+janitor,adorn_title,-1,0,0,class<`data.frame`>,1
+janitor,adorn_title,-1,0,1,"class<`data.frame`, `tabyl`>",1
+janitor,adorn_title,-1,0,2,"list<class<`data.frame`, `tabyl`>>",1
+janitor,adorn_title,0,0,0,"class<`data.frame`, `grouped_df`, `tbl`, `tbl_df`>",1
+janitor,adorn_title,0,0,1,"class<`data.frame`, `tbl`, `tbl_df`>",1
+janitor,adorn_title,0,0,2,"class<`data.frame`, `tabyl`>",1
+janitor,adorn_title,0,0,3,"list<class<`data.frame`, `tabyl`>>",1
+janitor,adorn_title,1,0,0,character,1
+janitor,adorn_title,2,0,0,any,1
+janitor,adorn_title,3,0,0,any,1
+janitor,adorn_totals,-1,0,0,"class<`data.frame`, `tabyl`>",1
+janitor,adorn_totals,-1,0,1,"list<class<`data.frame`, `tabyl`>>",1
+janitor,adorn_totals,0,0,0,class<`data.frame`>,1
+janitor,adorn_totals,0,0,1,"class<`data.frame`, `tabyl`>",1
+janitor,adorn_totals,0,0,2,"list<class<`data.frame`, `tabyl`>>",1
+janitor,adorn_totals,1,0,0,character[],1
+janitor,adorn_totals,2,0,0,character,1
+janitor,adorn_totals,3,0,0,logical,1
+janitor,adorn_totals,4,0,0,character,1
+janitor,as_tabyl,-1,0,0,any,1
+janitor,as_tabyl,0,0,0,class<`data.frame`>,1
+janitor,as_tabyl,0,0,1,"class<`data.frame`, `tabyl`>",1
+janitor,as_tabyl,0,0,2,integer[],1
+janitor,as_tabyl,1,0,0,double,1
+janitor,as_tabyl,2,0,0,null,1
+janitor,as_tabyl,2,0,1,character,1
+janitor,as_tabyl,3,0,0,null,1
+janitor,as_tabyl,3,0,1,character,1
+janitor,check_vars_in_df,-1,0,0,null,1
+janitor,check_vars_in_df,0,0,0,class<`data.frame`>,1
+janitor,check_vars_in_df,1,0,0,any,1
+janitor,check_vars_in_df,2,0,0,character[],1
+janitor,chisq.test,-1,0,0,class<`htest`>,1
+janitor,chisq.test,0,0,0,"class<`data.frame`, `tabyl`>",1
+janitor,chisq.test,1,0,0,...,1
+janitor,chisq.test.tabyl,-1,0,0,class<`htest`>,1
+janitor,chisq.test.tabyl,0,0,0,"class<`data.frame`, `tabyl`>",1
+janitor,chisq.test.tabyl,1,0,0,logical,1
+janitor,chisq.test.tabyl,2,0,0,...,1
+janitor,clean_names,-1,0,0,class<`data.frame`>,1
+janitor,clean_names,-1,0,1,"class<`data.frame`, `tabyl`>",1
+janitor,clean_names,0,0,0,class<`data.frame`>,1
+janitor,clean_names,0,0,1,"class<`data.frame`, `tabyl`>",1
+janitor,clean_names,1,0,0,any,1
+janitor,clean_names.default,-1,0,0,class<`data.frame`>,1
+janitor,clean_names.default,-1,0,1,"class<`data.frame`, `tabyl`>",1
+janitor,clean_names.default,0,0,0,class<`data.frame`>,1
+janitor,clean_names.default,0,0,1,"class<`data.frame`, `tabyl`>",1
+janitor,clean_names.default,1,0,0,character[],1
+janitor,compare_df_cols,-1,0,0,class<`data.frame`>,1
+janitor,compare_df_cols,0,0,0,...,1
+janitor,compare_df_cols,1,0,0,character[],1
+janitor,compare_df_cols,2,0,0,character[],1
+janitor,compare_df_cols,3,0,0,logical,1
+janitor,compare_df_cols_df_maker,-1,0,0,class<`data.frame`>,1
+janitor,compare_df_cols_df_maker,0,0,0,class<`data.frame`>,1
+janitor,compare_df_cols_df_maker,0,0,1,list<class<`data.frame`>>,1
+janitor,compare_df_cols_df_maker,0,0,2,list<class<`data.frame`> | list<class<`data.frame`>>>,1
+janitor,compare_df_cols_df_maker,1,0,0,character[],1
+janitor,compare_df_cols_df_maker,1,0,1,list<character[]>,1
+janitor,compare_df_cols_df_maker,2,0,0,any,1
+janitor,compare_df_cols_df_maker.data.frame,-1,0,0,class<`data.frame`>,1
+janitor,compare_df_cols_df_maker.data.frame,0,0,0,class<`data.frame`>,1
+janitor,compare_df_cols_df_maker.data.frame,1,0,0,character,1
+janitor,compare_df_cols_df_maker.data.frame,2,0,0,any,1
+janitor,compare_df_cols_df_maker.list,-1,0,0,class<`data.frame`>,1
+janitor,compare_df_cols_df_maker.list,0,0,0,list<class<`data.frame`>>,1
+janitor,compare_df_cols_df_maker.list,0,0,1,list<class<`data.frame`> | list<class<`data.frame`>>>,1
+janitor,compare_df_cols_df_maker.list,1,0,0,character[],1
+janitor,compare_df_cols_df_maker.list,1,0,1,list<character[]>,1
+janitor,compare_df_cols_df_maker.list,2,0,0,any,1
+janitor,compare_df_cols_same,-1,0,0,logical,1
+janitor,compare_df_cols_same,0,0,0,...,1
+janitor,compare_df_cols_same,1,0,0,character[],1
+janitor,compare_df_cols_same,2,0,0,logical,1
+janitor,describe_class,-1,0,0,character,1
+janitor,describe_class,0,0,0,class<`factor`>,1
+janitor,describe_class,0,0,1,"class<`factor`, `ordered`>",1
+janitor,describe_class,0,0,2,double,1
+janitor,describe_class,1,0,0,logical,1
+janitor,describe_class.default,-1,0,0,character,1
+janitor,describe_class.default,0,0,0,character[],1
+janitor,describe_class.default,0,0,1,double[],1
+janitor,describe_class.default,1,0,0,any,1
+janitor,describe_class.factor,-1,0,0,character,1
+janitor,describe_class.factor,0,0,0,class<`factor`>,1
+janitor,describe_class.factor,0,0,1,"class<`factor`, `ordered`>",1
+janitor,describe_class.factor,1,0,0,logical,1
+janitor,excel_numeric_to_date,-1,0,0,class<`Date`>,1
+janitor,excel_numeric_to_date,-1,0,1,"class<`POSIXct`, `POSIXt`>",1
+janitor,excel_numeric_to_date,0,0,0,double,1
+janitor,excel_numeric_to_date,1,0,0,character,1
+janitor,excel_numeric_to_date,2,0,0,logical,1
+janitor,excel_numeric_to_date,3,0,0,logical,1
+janitor,excel_numeric_to_date,4,0,0,character,1
+janitor,fisher.test,-1,0,0,class<`htest`>,1
+janitor,fisher.test,0,0,0,"class<`data.frame`, `tabyl`>",1
+janitor,fisher.test,1,0,0,...,1
+janitor,fisher.test.tabyl,-1,0,0,class<`htest`>,1
+janitor,fisher.test.tabyl,0,0,0,"class<`data.frame`, `tabyl`>",1
+janitor,fisher.test.tabyl,1,0,0,...,1
+janitor,get_dupes,-1,0,0,"class<`data.frame`, `tbl`, `tbl_df`>",1
+janitor,get_dupes,0,0,0,class<`data.frame`>,1
+janitor,get_dupes,1,0,0,...,1
+janitor,get_level_groups,-1,0,0,list<character>,1
+janitor,get_level_groups,0,0,0,class<`factor`>,1
+janitor,get_level_groups,1,0,0,double,1
+janitor,get_level_groups,2,0,0,integer,1
+janitor,handle_if_special_names_used,-1,0,0,class<`data.frame`>,1
+janitor,handle_if_special_names_used,-1,0,1,"class<`data.frame`, `tbl`, `tbl_df`>",1
+janitor,handle_if_special_names_used,0,0,0,class<`data.frame`>,1
+janitor,handle_if_special_names_used,0,0,1,"class<`data.frame`, `tbl`, `tbl_df`>",1
+janitor,make_clean_names,-1,0,0,character[],1
+janitor,make_clean_names,0,0,0,character[],1
+janitor,make_clean_names,1,0,0,character[],1
+janitor,paste_matrices,-1,0,0,"class<`data.frame`, `tbl`, `tbl_df`>",1
+janitor,paste_matrices,0,0,0,class<`data.frame`>,1
+janitor,paste_matrices,0,0,1,"class<`data.frame`, `grouped_df`, `tbl`, `tbl_df`>",1
+janitor,paste_matrices,0,0,2,"class<`data.frame`, `tabyl`>",1
+janitor,paste_matrices,1,0,0,class<`data.frame`>,1
+janitor,remove_constant,-1,0,0,class<`data.frame`>,1
+janitor,remove_constant,0,0,0,class<`data.frame`>,1
+janitor,remove_constant,1,0,0,logical,1
+janitor,remove_empty,-1,0,0,class<`data.frame`>,1
+janitor,remove_empty,0,0,0,class<`data.frame`>,1
+janitor,remove_empty,1,0,0,character[],1
+janitor,round_half_up,-1,0,0,double[],1
+janitor,round_half_up,0,0,0,double[],1
+janitor,round_half_up,1,0,0,double,1
+janitor,round_to_fraction,-1,0,0,double[],1
+janitor,round_to_fraction,0,0,0,double[],1
+janitor,round_to_fraction,1,0,0,double[],1
+janitor,round_to_fraction,2,0,0,character,1
+janitor,round_to_fraction,2,0,1,double,1
+janitor,row_to_names,-1,0,0,class<`data.frame`>,1
+janitor,row_to_names,0,0,0,class<`data.frame`>,1
+janitor,row_to_names,1,0,0,double,1
+janitor,row_to_names,2,0,0,logical,1
+janitor,row_to_names,3,0,0,logical,1
+janitor,tabyl,-1,0,0,"class<`data.frame`, `tabyl`>",1
+janitor,tabyl,-1,0,1,"list<class<`data.frame`, `tabyl`>>",1
+janitor,tabyl,0,0,0,^character[],1
+janitor,tabyl,0,0,1,class<`data.frame`>,1
+janitor,tabyl,0,0,2,"class<`data.frame`, `tbl`, `tbl_df`>",1
+janitor,tabyl,0,0,3,class<`factor`>,1
+janitor,tabyl,1,0,0,...,1
+janitor,tabyl_1way,-1,0,0,"class<`data.frame`, `tabyl`>",1
+janitor,tabyl_1way,0,0,0,class<`data.frame`>,1
+janitor,tabyl_1way,0,0,1,"class<`data.frame`, `tbl`, `tbl_df`>",1
+janitor,tabyl_1way,1,0,0,"class<`formula`, `quosure`>",1
+janitor,tabyl_1way,2,0,0,logical,1
+janitor,tabyl_1way,3,0,0,logical,1
+janitor,tabyl_2way,-1,0,0,"class<`data.frame`, `tabyl`>",1
+janitor,tabyl_2way,0,0,0,class<`data.frame`>,1
+janitor,tabyl_2way,0,0,1,"class<`data.frame`, `tbl`, `tbl_df`>",1
+janitor,tabyl_2way,1,0,0,"class<`formula`, `quosure`>",1
+janitor,tabyl_2way,2,0,0,"class<`formula`, `quosure`>",1
+janitor,tabyl_2way,3,0,0,logical,1
+janitor,tabyl_2way,4,0,0,logical,1
+janitor,tabyl_3way,-1,0,0,"list<class<`data.frame`, `tabyl`>>",1
+janitor,tabyl_3way,0,0,0,class<`data.frame`>,1
+janitor,tabyl_3way,0,0,1,"class<`data.frame`, `tbl`, `tbl_df`>",1
+janitor,tabyl_3way,1,0,0,"class<`formula`, `quosure`>",1
+janitor,tabyl_3way,2,0,0,"class<`formula`, `quosure`>",1
+janitor,tabyl_3way,3,0,0,"class<`formula`, `quosure`>",1
+janitor,tabyl_3way,4,0,0,logical,1
+janitor,tabyl_3way,5,0,0,logical,1
+janitor,tabyl.data.frame,-1,0,0,"class<`data.frame`, `tabyl`>",1
+janitor,tabyl.data.frame,-1,0,1,"list<class<`data.frame`, `tabyl`>>",1
+janitor,tabyl.data.frame,0,0,0,class<`data.frame`>,1
+janitor,tabyl.data.frame,0,0,1,"class<`data.frame`, `tbl`, `tbl_df`>",1
+janitor,tabyl.data.frame,1,0,0,any,1
+janitor,tabyl.data.frame,2,0,0,any,1
+janitor,tabyl.data.frame,3,0,0,any,1
+janitor,tabyl.data.frame,4,0,0,logical,1
+janitor,tabyl.data.frame,5,0,0,logical,1
+janitor,tabyl.data.frame,6,0,0,...,1
+janitor,tabyl.default,-1,0,0,"class<`data.frame`, `tabyl`>",1
+janitor,tabyl.default,0,0,0,^character[],1
+janitor,tabyl.default,0,0,1,class<`factor`>,1
+janitor,tabyl.default,0,0,2,class<`data.frame`>,1
+janitor,tabyl.default,0,0,3,"class<`data.frame`, `tbl`, `tbl_df`>",1
+janitor,tabyl.default,1,0,0,logical,1
+janitor,tabyl.default,2,0,0,logical,1
+janitor,tabyl.default,3,0,0,...,1
+janitor,top_levels,-1,0,0,"class<`data.frame`, `tabyl`>",1
+janitor,top_levels,0,0,0,class<`factor`>,1
+janitor,top_levels,1,0,0,double,1
+janitor,top_levels,2,0,0,logical,1
+janitor,untabyl,-1,0,0,class<`data.frame`>,1
+janitor,untabyl,-1,0,1,list<class<`data.frame`>>,1
+janitor,untabyl,0,0,0,"class<`data.frame`, `tabyl`>",1
+janitor,untabyl,0,0,1,class<`data.frame`>,1
+janitor,untabyl,0,0,2,"list<class<`data.frame`, `tabyl`>>",1
+jpeg,readJPEG,-1,0,0,class<`array`>,1
+jpeg,readJPEG,-1,0,1,class<`matrix`>,1
+jpeg,readJPEG,-1,0,2,class<`nativeRaster`>,1
+jpeg,readJPEG,0,0,0,character,1
+jpeg,readJPEG,0,0,1,raw[],1
+jpeg,readJPEG,1,0,0,logical,1
+jpeg,writeJPEG,-1,0,0,null,1
+jpeg,writeJPEG,-1,0,1,raw[],1
+jpeg,writeJPEG,0,0,0,class<`array`>,1
+jpeg,writeJPEG,0,0,1,class<`matrix`>,1
+jpeg,writeJPEG,0,0,2,class<`nativeRaster`>,1
+jpeg,writeJPEG,1,0,0,character,1
+jpeg,writeJPEG,1,0,1,raw[],1
+jpeg,writeJPEG,2,0,0,double,1
+jpeg,writeJPEG,3,0,0,character,1
+jpeg,writeJPEG,4,0,0,any,1
+jsonlite,all.identical,-1,0,0,logical,1
+jsonlite,all.identical,0,0,0,character[],1
+jsonlite,all.identical,0,0,1,integer[],1
+jsonlite,apply_by_pages,-1,0,0,list<any>,1
+jsonlite,apply_by_pages,0,0,0,class<`data.frame`>,1
+jsonlite,apply_by_pages,1,0,0,class<`function`>,1
+jsonlite,apply_by_pages,2,0,0,double,1
+jsonlite,apply_by_pages,3,0,0,logical,1
+jsonlite,apply_by_pages,4,0,0,...,1
+jsonlite,asJSON,-1,0,0,character[],1
+jsonlite,asJSON,0,0,0,class<`data.frame`>,1
+jsonlite,asJSON,1,0,0,...,1
+jsonlite,asJSON,-1,1,0,character[],1
+jsonlite,asJSON,0,1,0,^character[],1
+jsonlite,asJSON,1,1,0,...,1
+jsonlite,asJSON,-1,2,0,character,1
+jsonlite,asJSON,0,2,0,class<`matrix`>,1
+jsonlite,asJSON,1,2,0,...,1
+jsonlite,asJSON,-1,3,0,^character[],1
+jsonlite,asJSON,0,3,0,^integer[],1
+jsonlite,asJSON,1,3,0,...,1
+jsonlite,asJSON,-1,4,0,character,1
+jsonlite,asJSON,0,4,0,list<any>,1
+jsonlite,asJSON,1,4,0,...,1
+jsonlite,asJSON,-1,5,0,^character[],1
+jsonlite,asJSON,0,5,0,class<`data.frame`>,1
+jsonlite,asJSON,0,5,1,class<`matrix`>,1
+jsonlite,asJSON,0,5,2,list<any>,1
+jsonlite,asJSON,0,5,3,^character[],1
+jsonlite,asJSON,0,5,4,class<`factor`>,1
+jsonlite,asJSON,0,5,5,"class<`character`, `scalar`>",1
+jsonlite,asJSON,0,5,6,"class<`data.frame`, `scalar`>",1
+jsonlite,asJSON,0,5,7,"class<`numeric`, `scalar`>",1
+jsonlite,asJSON,0,5,8,complex[],1
+jsonlite,asJSON,0,5,9,^double[],1
+jsonlite,asJSON,0,5,10,null,1
+jsonlite,asJSON,1,5,0,...,1
+jsonlite,asJSON,-1,6,0,character[],1
+jsonlite,asJSON,0,6,0,double[],1
+jsonlite,asJSON,1,6,0,...,1
+jsonlite,as.scalar,-1,0,0,"class<`character`, `scalar`>",1
+jsonlite,as.scalar,-1,0,1,"class<`data.frame`, `scalar`>",1
+jsonlite,as.scalar,-1,0,2,"class<`numeric`, `scalar`>",1
+jsonlite,as.scalar,0,0,0,character,1
+jsonlite,as.scalar,0,0,1,class<`data.frame`>,1
+jsonlite,as.scalar,0,0,2,double,1
+jsonlite,base64_dec,-1,0,0,raw[],1
+jsonlite,base64_dec,0,0,0,character,1
+jsonlite,base64_enc,-1,0,0,character,1
+jsonlite,base64_enc,0,0,0,raw[],1
+jsonlite,cleannames,-1,0,0,character[],1
+jsonlite,cleannames,0,0,0,character[],1
+jsonlite,cleannames,1,0,0,logical,1
+jsonlite,collapse,-1,0,0,character,1
+jsonlite,collapse,0,0,0,character[],1
+jsonlite,collapse,1,0,0,logical,1
+jsonlite,collapse,2,0,0,integer,1
+jsonlite,collapse,2,0,1,null,1
+jsonlite,collapse_object,-1,0,0,character,1
+jsonlite,collapse_object,0,0,0,character[],1
+jsonlite,collapse_object,1,0,0,character[],1
+jsonlite,collapse_object,2,0,0,null,1
+jsonlite,deparse_vector,-1,0,0,character[],1
+jsonlite,deparse_vector,0,0,0,^character[],1
+jsonlite,flatten,-1,0,0,class<`data.frame`>,1
+jsonlite,flatten,0,0,0,class<`data.frame`>,1
+jsonlite,flatten,1,0,0,logical,1
+jsonlite,fromJSON,-1,0,0,^character[],1
+jsonlite,fromJSON,-1,0,1,class<`array`>,1
+jsonlite,fromJSON,-1,0,2,class<`data.frame`>,1
+jsonlite,fromJSON,-1,0,3,class<`matrix`>,1
+jsonlite,fromJSON,-1,0,4,list<any>,1
+jsonlite,fromJSON,0,0,0,character,1
+jsonlite,fromJSON,0,0,1,class<`json`>,1
+jsonlite,fromJSON,1,0,0,logical,1
+jsonlite,fromJSON,2,0,0,logical,1
+jsonlite,fromJSON,3,0,0,logical,1
+jsonlite,fromJSON,4,0,0,logical,1
+jsonlite,fromJSON,5,0,0,...,1
+jsonlite,givename,-1,0,0,list<any>,1
+jsonlite,givename,0,0,0,list<any>,1
+jsonlite,is.arraylist,-1,0,0,logical,1
+jsonlite,is.arraylist,0,0,0,list<any>,1
+jsonlite,is_datelist,-1,0,0,logical,1
+jsonlite,is_datelist,0,0,0,list<character>,1
+jsonlite,is_datelist,0,0,1,list<character | null>,1
+jsonlite,is_datelist,0,0,2,list<double>,1
+jsonlite,is_datelist,0,0,3,list<integer | character>,1
+jsonlite,is_datelist,0,0,4,list<integer | null>,1
+jsonlite,is_datelist,0,0,5,list<logical | null>,1
+jsonlite,is_datelist,0,0,6,list<null>,1
+jsonlite,is_datelist,0,0,7,list<null | character>,1
+jsonlite,is_datelist,0,0,8,list<null | logical>,1
+jsonlite,is.datelist,-1,0,0,logical,1
+jsonlite,is.datelist,0,0,0,class<`data.frame`>,1
+jsonlite,is.datelist,0,0,1,list<any>,1
+jsonlite,is.matrixlist,-1,0,0,logical,1
+jsonlite,is.matrixlist,0,0,0,list<any>,1
+jsonlite,is.namedlist,-1,0,0,logical,1
+jsonlite,is.namedlist,0,0,0,character,1
+jsonlite,is.namedlist,0,0,1,double,1
+jsonlite,is.recordlist,-1,0,0,logical,1
+jsonlite,is.recordlist,0,0,0,list<any>,1
+jsonlite,is.scalarlist,-1,0,0,logical,1
+jsonlite,is.scalarlist,0,0,0,list<any>,1
+jsonlite,list_to_vec,-1,0,0,^character[],1
+jsonlite,list_to_vec,-1,0,1,^double[],1
+jsonlite,list_to_vec,-1,0,2,null,1
+jsonlite,list_to_vec,0,0,0,list<character | null>,1
+jsonlite,list_to_vec,0,0,1,list<null | character>,1
+jsonlite,list_to_vec,0,0,2,list<character>,1
+jsonlite,list_to_vec,0,0,3,list<integer | character>,1
+jsonlite,list_to_vec,0,0,4,list<double>,1
+jsonlite,list_to_vec,0,0,5,list<integer | null>,1
+jsonlite,list_to_vec,0,0,6,list<logical | null>,1
+jsonlite,list_to_vec,0,0,7,list<null | logical>,1
+jsonlite,list_to_vec,0,0,8,list<null>,1
+jsonlite,loadpkg,-1,0,0,environment,1
+jsonlite,loadpkg,0,0,0,character,1
+jsonlite,minify,-1,0,0,class<`json`>,1
+jsonlite,minify,0,0,0,class<`json`>,1
+jsonlite,null_to_na,-1,0,0,list<character>,1
+jsonlite,null_to_na,-1,0,1,list<character | null>,1
+jsonlite,null_to_na,-1,0,2,list<double>,1
+jsonlite,null_to_na,-1,0,3,list<null | double>,1
+jsonlite,null_to_na,-1,0,4,list<integer | null>,1
+jsonlite,null_to_na,-1,0,5,list<logical | null>,1
+jsonlite,null_to_na,-1,0,6,list<null | character>,1
+jsonlite,null_to_na,-1,0,7,list<null>,1
+jsonlite,null_to_na,-1,0,8,list<null | logical>,1
+jsonlite,null_to_na,0,0,0,list<character>,1
+jsonlite,null_to_na,0,0,1,list<character | null>,1
+jsonlite,null_to_na,0,0,2,list<double>,1
+jsonlite,null_to_na,0,0,3,list<integer | character>,1
+jsonlite,null_to_na,0,0,4,list<integer | null>,1
+jsonlite,null_to_na,0,0,5,list<logical | null>,1
+jsonlite,null_to_na,0,0,6,list<null | character>,1
+jsonlite,null_to_na,0,0,7,list<null>,1
+jsonlite,null_to_na,0,0,8,list<null | logical>,1
+jsonlite,num_to_char,-1,0,0,^character[],1
+jsonlite,num_to_char,0,0,0,^double[],1
+jsonlite,num_to_char,1,0,0,double,1
+jsonlite,num_to_char,1,0,1,class<`AsIs`>,1
+jsonlite,num_to_char,2,0,0,null,1
+jsonlite,num_to_char,2,0,1,logical,1
+jsonlite,num_to_char,3,0,0,logical,1
+jsonlite,num_to_char,4,0,0,logical,1
+jsonlite,pack,-1,0,0,"list<class<`character`, `scalar`> | character[] | list<any>>",1
+jsonlite,pack,-1,0,1,"list<class<`character`, `scalar`> | character | list<any>>",1
+jsonlite,pack,-1,0,2,"list<class<`character`, `scalar`> | ^character[] | list<any>>",1
+jsonlite,pack,-1,0,3,"list<class<`character`, `scalar`> | list<any>>",1
+jsonlite,pack,-1,0,4,"list<class<`character`, `scalar`> | complex[] | list<any>>",1
+jsonlite,pack,-1,0,5,"list<class<`character`, `scalar`> | double[] | list<any>>",1
+jsonlite,pack,-1,0,6,"list<class<`character`, `scalar`> | double | list<any>>",1
+jsonlite,pack,-1,0,7,"list<class<`character`, `scalar`> | ^double[] | list<any>>",1
+jsonlite,pack,-1,0,8,"list<class<`character`, `scalar`> | integer[] | list<any>>",1
+jsonlite,pack,-1,0,9,"list<class<`character`, `scalar`> | ^logical[] | list<any>>",1
+jsonlite,pack,-1,0,10,"list<class<`character`, `scalar`> | null | list<any>>",1
+jsonlite,pack,-1,0,11,"list<class<`character`, `scalar`> | complex[] | list<list<class<`character`, `scalar`> | integer[] | list<any>>>>",1
+jsonlite,pack,-1,0,12,"list<class<`character`, `scalar`> | double[] | list<list<class<`character`, `scalar`> | integer[] | list<any>>>>",1
+jsonlite,pack,-1,0,13,"list<class<`character`, `scalar`> | list<list<class<`character`, `scalar`> | character[] | list<any> | class<`character`, `scalar`> | character | list<any> | class<`character`, `scalar`> | integer[] | list<any> | class<`character`, `scalar`> | double[] | list<any>>>>",1
+jsonlite,pack,-1,0,14,"list<class<`character`, `scalar`> | list<list<any>>>",1
+jsonlite,pack,-1,0,15,"list<class<`character`, `scalar`> | list<list<class<`character`, `scalar`> | character[] | list<any> | class<`character`, `scalar`> | complex[] | list<any> | class<`character`, `scalar`> | complex[] | list<list<class<`character`, `scalar`> | integer[] | list<any>>>>>>",1
+jsonlite,pack,-1,0,16,"list<class<`character`, `scalar`>>",1
+jsonlite,pack,-1,0,17,"list<class<`character`, `scalar`> | list<list<class<`character`, `scalar`> | character[] | list<any> | class<`character`, `scalar`> | character | list<any> | class<`character`, `scalar`> | double[] | list<any>>>>",1
+jsonlite,pack,0,0,0,^character[],1
+jsonlite,pack,0,0,1,raw[],1
+jsonlite,pack,0,0,2,complex[],1
+jsonlite,pack,0,0,3,^double[],1
+jsonlite,pack,0,0,4,null,1
+jsonlite,pack,0,0,5,class<`matrix`>,1
+jsonlite,pack,0,0,6,class<`data.frame`>,1
+jsonlite,pack,0,0,7,list<any>,1
+jsonlite,pack,1,0,0,...,1
+jsonlite,parse_and_simplify,-1,0,0,^character[],1
+jsonlite,parse_and_simplify,-1,0,1,class<`array`>,1
+jsonlite,parse_and_simplify,-1,0,2,class<`data.frame`>,1
+jsonlite,parse_and_simplify,-1,0,3,class<`matrix`>,1
+jsonlite,parse_and_simplify,-1,0,4,list<any>,1
+jsonlite,parse_and_simplify,0,0,0,character,1
+jsonlite,parse_and_simplify,0,0,1,"class<`connection`, `file`>",1
+jsonlite,parse_and_simplify,0,0,2,class<`json`>,1
+jsonlite,parse_and_simplify,0,0,3,"class<`connection`, `curl`>",1
+jsonlite,parse_and_simplify,1,0,0,logical,1
+jsonlite,parse_and_simplify,2,0,0,logical,1
+jsonlite,parse_and_simplify,3,0,0,logical,1
+jsonlite,parse_and_simplify,4,0,0,any,1
+jsonlite,parse_and_simplify,5,0,0,logical,1
+jsonlite,parse_and_simplify,6,0,0,logical,1
+jsonlite,parse_and_simplify,7,0,0,logical,1
+jsonlite,parse_and_simplify,8,0,0,...,1
+jsonlite,parse_con,-1,0,0,list<any>,1
+jsonlite,parse_con,0,0,0,"class<`connection`, `file`>",1
+jsonlite,parse_con,0,0,1,"class<`connection`, `curl`>",1
+jsonlite,parse_con,1,0,0,logical,1
+jsonlite,parse_json,-1,0,0,class<`data.frame`>,1
+jsonlite,parse_json,-1,0,1,list<list<double | character>>,1
+jsonlite,parse_json,0,0,0,"class<`connection`, `file`>",1
+jsonlite,parse_json,1,0,0,logical,1
+jsonlite,parse_json,2,0,0,...,1
+jsonlite,parseJSON,-1,0,0,list<any>,1
+jsonlite,parseJSON,0,0,0,character,1
+jsonlite,parseJSON,0,0,1,class<`json`>,1
+jsonlite,parseJSON,0,0,2,"class<`connection`, `file`>",1
+jsonlite,parseJSON,0,0,3,"class<`connection`, `curl`>",1
+jsonlite,parseJSON,1,0,0,logical,1
+jsonlite,parse_string,-1,0,0,list<character | null>,1
+jsonlite,parse_string,-1,0,1,list<list<any>>,1
+jsonlite,parse_string,-1,0,2,list<character>,1
+jsonlite,parse_string,-1,0,3,list<character | list<list<character | list<any>>>>,1
+jsonlite,parse_string,-1,0,4,list<character | list<list<any>>>,1
+jsonlite,parse_string,-1,0,5,list<character | integer | list<any>>,1
+jsonlite,parse_string,0,0,0,character,1
+jsonlite,parse_string,0,0,1,class<`json`>,1
+jsonlite,parse_string,1,0,0,logical,1
+jsonlite,post_process,-1,0,0,class<`data.frame`>,1
+jsonlite,post_process,0,0,0,list<list<character | integer | list<any>>>,1
+jsonlite,post_process,1,0,0,logical,1
+jsonlite,post_process,2,0,0,logical,1
+jsonlite,post_process,3,0,0,any,1
+jsonlite,post_process,4,0,0,logical,1
+jsonlite,prettify,-1,0,0,class<`json`>,1
+jsonlite,prettify,0,0,0,class<`json`>,1
+jsonlite,prettify,1,0,0,double,1
+jsonlite,rbind_pages,-1,0,0,class<`data.frame`>,1
+jsonlite,rbind_pages,0,0,0,list<class<`data.frame`>>,1
+jsonlite,read_json,-1,0,0,class<`data.frame`>,1
+jsonlite,read_json,-1,0,1,list<list<double | character>>,1
+jsonlite,read_json,0,0,0,character,1
+jsonlite,read_json,1,0,0,logical,1
+jsonlite,read_json,2,0,0,...,1
+jsonlite,reformat,-1,0,0,class<`json`>,1
+jsonlite,reformat,0,0,0,character,1
+jsonlite,reformat,1,0,0,logical,1
+jsonlite,reformat,2,0,0,character,1
+jsonlite,row_collapse,-1,0,0,character[],1
+jsonlite,row_collapse,0,0,0,class<`matrix`>,1
+jsonlite,row_collapse,1,0,0,integer,1
+jsonlite,row_collapse_object,-1,0,0,character[],1
+jsonlite,row_collapse_object,0,0,0,character[],1
+jsonlite,row_collapse_object,1,0,0,class<`matrix`>,1
+jsonlite,row_collapse_object,2,0,0,integer,1
+jsonlite,row_collapse_object,2,0,1,null,1
+jsonlite,serializeJSON,-1,0,0,class<`json`>,1
+jsonlite,serializeJSON,0,0,0,class<`data.frame`>,1
+jsonlite,serializeJSON,0,0,1,list<any>,1
+jsonlite,serializeJSON,1,0,0,double,1
+jsonlite,serializeJSON,2,0,0,logical,1
+jsonlite,simplify,-1,0,0,^character[],1
+jsonlite,simplify,-1,0,1,class<`data.frame`>,1
+jsonlite,simplify,-1,0,2,class<`matrix`>,1
+jsonlite,simplify,-1,0,3,double[],1
+jsonlite,simplify,-1,0,4,^integer[],1
+jsonlite,simplify,-1,0,5,null,1
+jsonlite,simplify,-1,0,6,class<`array`>,1
+jsonlite,simplify,-1,0,7,list<any>,1
+jsonlite,simplify,0,0,0,character,1
+jsonlite,simplify,0,0,1,integer,1
+jsonlite,simplify,0,0,2,null,1
+jsonlite,simplify,0,0,3,list<any>,1
+jsonlite,simplify,1,0,0,any,1
+jsonlite,simplify,2,0,0,any,1
+jsonlite,simplify,3,0,0,any,1
+jsonlite,simplify,4,0,0,any,1
+jsonlite,simplify,5,0,0,logical,1
+jsonlite,simplify,6,0,0,any,1
+jsonlite,simplify,7,0,0,any,1
+jsonlite,simplify,8,0,0,any,1
+jsonlite,simplifyDataFrame,-1,0,0,class<`data.frame`>,1
+jsonlite,simplifyDataFrame,0,0,0,list<list<any>>,1
+jsonlite,simplifyDataFrame,1,0,0,any,1
+jsonlite,simplifyDataFrame,2,0,0,any,1
+jsonlite,simplifyDataFrame,3,0,0,any,1
+jsonlite,stream_in,-1,0,0,class<`data.frame`>,1
+jsonlite,stream_in,0,0,0,"class<`connection`, `url`>",1
+jsonlite,stream_in,1,0,0,null,1
+jsonlite,stream_in,2,0,0,double,1
+jsonlite,stream_in,3,0,0,logical,1
+jsonlite,stream_in,4,0,0,...,1
+jsonlite,stream_out,-1,0,0,list<any>,1
+jsonlite,stream_out,0,0,0,class<`data.frame`>,1
+jsonlite,stream_out,1,0,0,"class<`connection`, `terminal`>",1
+jsonlite,stream_out,2,0,0,double,1
+jsonlite,stream_out,3,0,0,logical,1
+jsonlite,stream_out,4,0,0,character,1
+jsonlite,stream_out,5,0,0,...,1
+jsonlite,toJSON,-1,0,0,class<`json`>,1
+jsonlite,toJSON,0,0,0,class<`data.frame`>,1
+jsonlite,toJSON,0,0,1,class<`matrix`>,1
+jsonlite,toJSON,0,0,2,double,1
+jsonlite,toJSON,0,0,3,list<any>,1
+jsonlite,toJSON,1,0,0,character[],1
+jsonlite,toJSON,2,0,0,character[],1
+jsonlite,toJSON,3,0,0,character[],1
+jsonlite,toJSON,4,0,0,character[],1
+jsonlite,toJSON,5,0,0,character[],1
+jsonlite,toJSON,6,0,0,character[],1
+jsonlite,toJSON,7,0,0,character[],1
+jsonlite,toJSON,8,0,0,character[],1
+jsonlite,toJSON,9,0,0,any,1
+jsonlite,toJSON,10,0,0,logical,1
+jsonlite,toJSON,11,0,0,double,1
+jsonlite,toJSON,11,0,1,class<`AsIs`>,1
+jsonlite,toJSON,12,0,0,logical,1
+jsonlite,toJSON,13,0,0,logical,1
+jsonlite,toJSON,14,0,0,...,1
+jsonlite,transpose_list,-1,0,0,list<list<any>>,1
+jsonlite,transpose_list,0,0,0,list<list<any>>,1
+jsonlite,transpose_list,1,0,0,character[],1
+jsonlite,unbox,-1,0,0,"class<`data.frame`, `scalar`>",1
+jsonlite,unbox,-1,0,1,"class<`numeric`, `scalar`>",1
+jsonlite,unbox,0,0,0,class<`data.frame`>,1
+jsonlite,unbox,0,0,1,double,1
+jsonlite,unpack,-1,0,0,^character[],1
+jsonlite,unpack,-1,0,1,class<`data.frame`>,1
+jsonlite,unpack,-1,0,2,class<`matrix`>,1
+jsonlite,unpack,-1,0,3,complex[],1
+jsonlite,unpack,-1,0,4,^double[],1
+jsonlite,unpack,-1,0,5,null,1
+jsonlite,unpack,-1,0,6,raw[],1
+jsonlite,unpack,-1,0,7,list<any>,1
+jsonlite,unpack,0,0,0,list<character | list<any>>,1
+jsonlite,unpack,0,0,1,list<character | list<list<character | list<any>>>>,1
+jsonlite,unpack,0,0,2,list<character | list<character | list<character | list<any>>>>,1
+jsonlite,unpack,0,0,3,list<character | list<double | list<character | list<any>>>>,1
+jsonlite,unpack,0,0,4,list<character>,1
+jsonlite,unpack,0,0,5,list<character | list<list<character | list<any> | character | list<any> | character>>>,1
+jsonlite,unpack,0,0,6,list<character | list<list<character | list<any> | character | list<any> | character | list<character | list<character | list<any>>>>>>,1
+jsonlite,unpack,0,0,7,list<character | list<list<any>>>,1
+jsonlite,unserializeJSON,-1,0,0,class<`data.frame`>,1
+jsonlite,unserializeJSON,-1,0,1,list<any>,1
+jsonlite,unserializeJSON,0,0,0,class<`json`>,1
+jsonlite,validate,-1,0,0,logical,1
+jsonlite,validate,0,0,0,character,1
+jsonlite,validate,0,0,1,class<`json`>,1
+jsonlite,write_json,-1,0,0,null,1
+jsonlite,write_json,0,0,0,class<`data.frame`>,1
+jsonlite,write_json,1,0,0,character,1
+jsonlite,write_json,2,0,0,...,1
+kableExtra,add_footnote,-1,0,0,"class<`kableExtra`, `knitr_kable`>",1
+kableExtra,add_footnote,-1,0,1,class<`knitr_kable`>,1
+kableExtra,add_footnote,0,0,0,"class<`kableExtra`, `knitr_kable`>",1
+kableExtra,add_footnote,0,0,1,class<`knitr_kable`>,1
+kableExtra,add_footnote,1,0,0,character[],1
+kableExtra,add_footnote,2,0,0,character,1
+kableExtra,add_footnote,3,0,0,logical,1
+kableExtra,add_footnote,4,0,0,logical,1
+kableExtra,add_header_above,-1,0,0,"class<`kableExtra`, `knitr_kable`>",1
+kableExtra,add_header_above,-1,0,1,class<`knitr_kable`>,1
+kableExtra,add_header_above,0,0,0,"class<`kableExtra`, `knitr_kable`>",1
+kableExtra,add_header_above,0,0,1,class<`knitr_kable`>,1
+kableExtra,add_header_above,1,0,0,character[],1
+kableExtra,add_header_above,1,0,1,double[],1
+kableExtra,add_header_above,2,0,0,logical,1
+kableExtra,add_header_above,3,0,0,logical,1
+kableExtra,add_header_above,4,0,0,logical,1
+kableExtra,add_header_above,5,0,0,logical,1
+kableExtra,add_header_above,6,0,0,logical,1
+kableExtra,add_header_above,7,0,0,character,1
+kableExtra,add_indent,-1,0,0,"class<`kableExtra`, `knitr_kable`>",1
+kableExtra,add_indent,-1,0,1,class<`knitr_kable`>,1
+kableExtra,add_indent,0,0,0,"class<`kableExtra`, `knitr_kable`>",1
+kableExtra,add_indent,0,0,1,class<`knitr_kable`>,1
+kableExtra,add_indent,1,0,0,double[],1
+kableExtra,add_indent_html,-1,0,0,"class<`kableExtra`, `knitr_kable`>",1
+kableExtra,add_indent_html,0,0,0,"class<`kableExtra`, `knitr_kable`>",1
+kableExtra,add_indent_html,0,0,1,class<`knitr_kable`>,1
+kableExtra,add_indent_html,1,0,0,double[],1
+kableExtra,add_indent_latex,-1,0,0,class<`knitr_kable`>,1
+kableExtra,add_indent_latex,0,0,0,class<`knitr_kable`>,1
+kableExtra,add_indent_latex,1,0,0,double[],1
+kableExtra,as_kable_xml,-1,0,0,class<`knitr_kable`>,1
+kableExtra,as_kable_xml,0,0,0,class<`xml_node`>,1
+kableExtra,auto_set_format,-1,0,0,list<null>,1
+kableExtra,cell_spec,-1,0,0,character[],1
+kableExtra,cell_spec,0,0,0,character[],1
+kableExtra,cell_spec,0,0,1,class<`factor`>,1
+kableExtra,cell_spec,0,0,2,double[],1
+kableExtra,cell_spec,1,0,0,any,1
+kableExtra,cell_spec,2,0,0,logical,1
+kableExtra,cell_spec,3,0,0,logical,1
+kableExtra,cell_spec,4,0,0,logical,1
+kableExtra,cell_spec,5,0,0,logical,1
+kableExtra,cell_spec,6,0,0,logical,1
+kableExtra,cell_spec,7,0,0,character[],1
+kableExtra,cell_spec,7,0,1,null,1
+kableExtra,cell_spec_html,-1,0,0,character[],1
+kableExtra,cell_spec_html,0,0,0,character[],1
+kableExtra,cell_spec_html,0,0,1,class<`factor`>,1
+kableExtra,cell_spec_html,0,0,2,double[],1
+kableExtra,cell_spec_html,1,0,0,logical,1
+kableExtra,cell_spec_html,2,0,0,logical,1
+kableExtra,cell_spec_html,3,0,0,logical,1
+kableExtra,cell_spec_html,4,0,0,logical,1
+kableExtra,cell_spec_html,5,0,0,logical,1
+kableExtra,cell_spec_html,6,0,0,character[],1
+kableExtra,cell_spec_html,6,0,1,null,1
+kableExtra,cell_spec_html,7,0,0,null,1
+kableExtra,cell_spec_html,7,0,1,character[],1
+kableExtra,cell_spec_html,7,0,2,class<`factor`>,1
+kableExtra,cell_spec_latex,-1,0,0,character[],1
+kableExtra,cell_spec_latex,0,0,0,character[],1
+kableExtra,cell_spec_latex,0,0,1,class<`factor`>,1
+kableExtra,cell_spec_latex,0,0,2,double[],1
+kableExtra,cell_spec_latex,1,0,0,logical,1
+kableExtra,cell_spec_latex,2,0,0,logical,1
+kableExtra,cell_spec_latex,3,0,0,logical,1
+kableExtra,cell_spec_latex,4,0,0,logical,1
+kableExtra,cell_spec_latex,5,0,0,logical,1
+kableExtra,cell_spec_latex,6,0,0,character[],1
+kableExtra,cell_spec_latex,7,0,0,null,1
+kableExtra,cell_spec_latex,7,0,1,character[],1
+kableExtra,cell_spec_latex,7,0,2,class<`factor`>,1
+kableExtra,cline_gen,-1,0,0,character,1
+kableExtra,cline_gen,0,0,0,class<`data.frame`>,1
+kableExtra,cline_gen,1,0,0,logical,1
+kableExtra,cline_gen,2,0,0,double,1
+kableExtra,collapse_new_dt_item,-1,0,0,character,1
+kableExtra,collapse_new_dt_item,0,0,0,any,1
+kableExtra,collapse_new_dt_item,1,0,0,double,1
+kableExtra,collapse_new_dt_item,2,0,0,any,1
+kableExtra,collapse_new_dt_item,3,0,0,any,1
+kableExtra,collapse_new_dt_item,4,0,0,any,1
+kableExtra,collapse_row_matrix,-1,0,0,class<`data.frame`>,1
+kableExtra,collapse_row_matrix,0,0,0,class<`data.frame`>,1
+kableExtra,collapse_row_matrix,1,0,0,double,1
+kableExtra,collapse_row_matrix,1,0,1,integer[],1
+kableExtra,collapse_row_matrix,2,0,0,logical,1
+kableExtra,collapse_rows,-1,0,0,"class<`kableExtra`, `knitr_kable`>",1
+kableExtra,collapse_rows,-1,0,1,class<`knitr_kable`>,1
+kableExtra,collapse_rows,0,0,0,"class<`kableExtra`, `knitr_kable`>",1
+kableExtra,collapse_rows,0,0,1,class<`knitr_kable`>,1
+kableExtra,collapse_rows,1,0,0,integer[],1
+kableExtra,collapse_rows,1,0,1,null,1
+kableExtra,collapse_rows,1,0,2,double,1
+kableExtra,collapse_rows,2,0,0,character[],1
+kableExtra,collapse_rows,3,0,0,any,1
+kableExtra,collapse_rows,4,0,0,any,1
+kableExtra,collapse_rows,5,0,0,null,1
+kableExtra,collapse_rows,5,0,1,integer[],1
+kableExtra,collapse_rows,6,0,0,null,1
+kableExtra,collapse_rows,6,0,1,list<list<logical>>,1
+kableExtra,collapse_rows,7,0,0,null,1
+kableExtra,collapse_rows_html,-1,0,0,"class<`kableExtra`, `knitr_kable`>",1
+kableExtra,collapse_rows_html,0,0,0,"class<`kableExtra`, `knitr_kable`>",1
+kableExtra,collapse_rows_html,0,0,1,class<`knitr_kable`>,1
+kableExtra,collapse_rows_html,1,0,0,integer[],1
+kableExtra,collapse_rows_html,1,0,1,null,1
+kableExtra,collapse_rows_html,2,0,0,character,1
+kableExtra,collapse_rows_index,-1,0,0,list<integer[]>,1
+kableExtra,collapse_rows_index,0,0,0,class<`data.frame`>,1
+kableExtra,collapse_rows_index,1,0,0,integer[],1
+kableExtra,collapse_rows_latex,-1,0,0,class<`knitr_kable`>,1
+kableExtra,collapse_rows_latex,0,0,0,class<`knitr_kable`>,1
+kableExtra,collapse_rows_latex,1,0,0,integer[],1
+kableExtra,collapse_rows_latex,1,0,1,double,1
+kableExtra,collapse_rows_latex,2,0,0,character,1
+kableExtra,collapse_rows_latex,3,0,0,character,1
+kableExtra,collapse_rows_latex,4,0,0,character,1
+kableExtra,collapse_rows_latex,5,0,0,any,1
+kableExtra,collapse_rows_latex,6,0,0,null,1
+kableExtra,collapse_rows_latex,6,0,1,integer[],1
+kableExtra,collapse_rows_latex,7,0,0,any,1
+kableExtra,collapse_rows_latex_stack,-1,0,0,class<`knitr_kable`>,1
+kableExtra,collapse_rows_latex_stack,0,0,0,class<`knitr_kable`>,1
+kableExtra,collapse_rows_latex_stack,1,0,0,list<integer[]>,1
+kableExtra,collapse_rows_latex_stack,2,0,0,list<list<logical>>,1
+kableExtra,collapse_rows_latex_stack,2,0,1,null,1
+kableExtra,column_spec,-1,0,0,"class<`kableExtra`, `knitr_kable`>",1
+kableExtra,column_spec,-1,0,1,class<`knitr_kable`>,1
+kableExtra,column_spec,0,0,0,"class<`kableExtra`, `knitr_kable`>",1
+kableExtra,column_spec,0,0,1,class<`knitr_kable`>,1
+kableExtra,column_spec,1,0,0,double,1
+kableExtra,column_spec,1,0,1,integer[],1
+kableExtra,column_spec,2,0,0,character,1
+kableExtra,column_spec,2,0,1,null,1
+kableExtra,column_spec,3,0,0,logical,1
+kableExtra,column_spec,4,0,0,logical,1
+kableExtra,column_spec,5,0,0,logical,1
+kableExtra,column_spec,6,0,0,logical,1
+kableExtra,column_spec,7,0,0,logical,1
+kableExtra,column_spec_html,-1,0,0,"class<`kableExtra`, `knitr_kable`>",1
+kableExtra,column_spec_html,0,0,0,"class<`kableExtra`, `knitr_kable`>",1
+kableExtra,column_spec_html,0,0,1,class<`knitr_kable`>,1
+kableExtra,column_spec_html,1,0,0,double,1
+kableExtra,column_spec_html,1,0,1,integer[],1
+kableExtra,column_spec_html,2,0,0,character,1
+kableExtra,column_spec_html,2,0,1,null,1
+kableExtra,column_spec_html,3,0,0,logical,1
+kableExtra,column_spec_html,4,0,0,logical,1
+kableExtra,column_spec_html,5,0,0,logical,1
+kableExtra,column_spec_html,6,0,0,logical,1
+kableExtra,column_spec_html,7,0,0,logical,1
+kableExtra,column_spec_html_cell,-1,0,0,null,1
+kableExtra,column_spec_html_cell,0,0,0,class<`xml_node`>,1
+kableExtra,column_spec_html_cell,1,0,0,character,1
+kableExtra,column_spec_html_cell,1,0,1,null,1
+kableExtra,column_spec_html_cell,2,0,0,null,1
+kableExtra,column_spec_html_cell,3,0,0,null,1
+kableExtra,column_spec_html_cell,4,0,0,logical,1
+kableExtra,column_spec_html_cell,5,0,0,logical,1
+kableExtra,column_spec_html_cell,6,0,0,logical,1
+kableExtra,column_spec_html_cell,7,0,0,logical,1
+kableExtra,column_spec_latex,-1,0,0,class<`knitr_kable`>,1
+kableExtra,column_spec_latex,0,0,0,class<`knitr_kable`>,1
+kableExtra,column_spec_latex,1,0,0,double,1
+kableExtra,column_spec_latex,1,0,1,integer[],1
+kableExtra,column_spec_latex,2,0,0,character,1
+kableExtra,column_spec_latex,2,0,1,null,1
+kableExtra,column_spec_latex,3,0,0,logical,1
+kableExtra,column_spec_latex,4,0,0,logical,1
+kableExtra,column_spec_latex,5,0,0,logical,1
+kableExtra,column_spec_latex,6,0,0,logical,1
+kableExtra,column_spec_latex,7,0,0,logical,1
+kableExtra,escape_html,-1,0,0,character[],1
+kableExtra,escape_html,0,0,0,character[],1
+kableExtra,escape_html,0,0,1,class<`factor`>,1
+kableExtra,escape_html,0,0,2,double[],1
+kableExtra,escape_latex,-1,0,0,character[],1
+kableExtra,escape_latex,0,0,0,character[],1
+kableExtra,escape_latex,0,0,1,class<`factor`>,1
+kableExtra,escape_latex,0,0,2,double[],1
+kableExtra,escape_latex,1,0,0,logical,1
+kableExtra,escape_latex,2,0,0,logical,1
+kableExtra,escape_latex2,-1,0,0,character[],1
+kableExtra,escape_latex2,0,0,0,character[],1
+kableExtra,extract_latex_from_kable,-1,0,0,"class<`kableExtra`, `knitr_kable`>",1
+kableExtra,extract_latex_from_kable,-1,0,1,class<`knitr_kable`>,1
+kableExtra,extract_latex_from_kable,0,0,0,"class<`kableExtra`, `knitr_kable`>",1
+kableExtra,extract_latex_from_kable,0,0,1,class<`knitr_kable`>,1
+kableExtra,ez_rep,-1,0,0,character[],1
+kableExtra,ez_rep,-1,0,1,double[],1
+kableExtra,ez_rep,-1,0,2,null,1
+kableExtra,ez_rep,0,0,0,character,1
+kableExtra,ez_rep,0,0,1,double,1
+kableExtra,ez_rep,0,0,2,null,1
+kableExtra,ez_rep,1,0,0,any,1
+kableExtra,footnote,-1,0,0,"class<`kableExtra`, `knitr_kable`>",1
+kableExtra,footnote,-1,0,1,class<`knitr_kable`>,1
+kableExtra,footnote,0,0,0,"class<`kableExtra`, `knitr_kable`>",1
+kableExtra,footnote,0,0,1,class<`knitr_kable`>,1
+kableExtra,footnote,1,0,0,character,1
+kableExtra,footnote,1,0,1,null,1
+kableExtra,footnote,2,0,0,character[],1
+kableExtra,footnote,2,0,1,null,1
+kableExtra,footnote,3,0,0,character[],1
+kableExtra,footnote,3,0,1,null,1
+kableExtra,footnote,4,0,0,character[],1
+kableExtra,footnote,4,0,1,null,1
+kableExtra,footnote,5,0,0,character[],1
+kableExtra,footnote,6,0,0,logical,1
+kableExtra,footnote,7,0,0,logical,1
+kableExtra,footnote_html,-1,0,0,"class<`kableExtra`, `knitr_kable`>",1
+kableExtra,footnote_html,0,0,0,"class<`kableExtra`, `knitr_kable`>",1
+kableExtra,footnote_html,0,0,1,class<`knitr_kable`>,1
+kableExtra,footnote_html,1,0,0,list<list<class<`data.frame`> | character>>,1
+kableExtra,footnote_html,2,0,0,logical,1
+kableExtra,footnote_latex,-1,0,0,class<`knitr_kable`>,1
+kableExtra,footnote_latex,0,0,0,class<`knitr_kable`>,1
+kableExtra,footnote_latex,1,0,0,list<list<class<`data.frame`> | character>>,1
+kableExtra,footnote_latex,2,0,0,logical,1
+kableExtra,footnote_latex,3,0,0,logical,1
+kableExtra,footnote_latex,4,0,0,any,1
+kableExtra,footnote_marker_alphabet,-1,0,0,character,1
+kableExtra,footnote_marker_alphabet,0,0,0,double,1
+kableExtra,footnote_marker_alphabet,1,0,0,any,1
+kableExtra,footnote_marker_alphabet,2,0,0,logical,1
+kableExtra,footnote_marker_symbol,-1,0,0,character,1
+kableExtra,footnote_marker_symbol,0,0,0,double,1
+kableExtra,footnote_marker_symbol,1,0,0,any,1
+kableExtra,footnote_marker_symbol,2,0,0,logical,1
+kableExtra,footnote_table_maker,-1,0,0,list<list<class<`data.frame`> | character>>,1
+kableExtra,footnote_table_maker,0,0,0,character,1
+kableExtra,footnote_table_maker,1,0,0,list<character>,1
+kableExtra,footnote_table_maker,2,0,0,list<character[]>,1
+kableExtra,footnote_table_maker,3,0,0,null,1
+kableExtra,get_fixed_thead,-1,0,0,list<logical | character>,1
+kableExtra,get_fixed_thead,-1,0,1,list<logical>,1
+kableExtra,get_fixed_thead,0,0,0,logical,1
+kableExtra,group_row_index_translator,-1,0,0,class<`data.frame`>,1
+kableExtra,group_row_index_translator,0,0,0,integer[],1
+kableExtra,group_rows_html,-1,0,0,"class<`kableExtra`, `knitr_kable`>",1
+kableExtra,group_rows_html,0,0,0,"class<`kableExtra`, `knitr_kable`>",1
+kableExtra,group_rows_html,0,0,1,class<`knitr_kable`>,1
+kableExtra,group_rows_html,1,0,0,character,1
+kableExtra,group_rows_html,2,0,0,double,1
+kableExtra,group_rows_html,3,0,0,double,1
+kableExtra,group_rows_html,4,0,0,character,1
+kableExtra,group_rows_html,5,0,0,logical,1
+kableExtra,group_rows_html,6,0,0,null,1
+kableExtra,group_rows_html,7,0,0,logical,1
+kableExtra,group_rows_latex,-1,0,0,class<`knitr_kable`>,1
+kableExtra,group_rows_latex,0,0,0,class<`knitr_kable`>,1
+kableExtra,group_rows_latex,1,0,0,character,1
+kableExtra,group_rows_latex,2,0,0,double,1
+kableExtra,group_rows_latex,3,0,0,double,1
+kableExtra,group_rows_latex,4,0,0,character,1
+kableExtra,group_rows_latex,5,0,0,logical,1
+kableExtra,group_rows_latex,6,0,0,character,1
+kableExtra,group_rows_latex,7,0,0,null,1
+kableExtra,html_color,-1,0,0,character[],1
+kableExtra,html_color,0,0,0,character[],1
+kableExtra,html_color,0,0,1,class<`factor`>,1
+kableExtra,htmlTable_add_header_above,-1,0,0,"class<`kableExtra`, `knitr_kable`>",1
+kableExtra,htmlTable_add_header_above,0,0,0,"class<`kableExtra`, `knitr_kable`>",1
+kableExtra,htmlTable_add_header_above,0,0,1,class<`knitr_kable`>,1
+kableExtra,htmlTable_add_header_above,1,0,0,character[],1
+kableExtra,htmlTable_add_header_above,1,0,1,double[],1
+kableExtra,htmlTable_add_header_above,2,0,0,logical,1
+kableExtra,htmlTable_add_header_above,3,0,0,logical,1
+kableExtra,htmlTable_add_header_above,4,0,0,logical,1
+kableExtra,htmlTable_add_header_above,5,0,0,logical,1
+kableExtra,htmlTable_add_header_above,6,0,0,logical,1
+kableExtra,htmlTable_add_header_above,7,0,0,character,1
+kableExtra,htmlTable_new_header_generator,-1,0,0,"class<`xml_document`, `xml_node`>",1
+kableExtra,htmlTable_new_header_generator,0,0,0,class<`data.frame`>,1
+kableExtra,htmlTable_new_header_generator,1,0,0,logical,1
+kableExtra,htmlTable_new_header_generator,2,0,0,logical,1
+kableExtra,htmlTable_new_header_generator,3,0,0,logical,1
+kableExtra,htmlTable_new_header_generator,4,0,0,logical,1
+kableExtra,htmlTable_new_header_generator,5,0,0,logical,1
+kableExtra,htmlTable_new_header_generator,6,0,0,character,1
+kableExtra,htmlTable_new_header_generator,7,0,0,null,1
+kableExtra,htmlTable_styling,-1,0,0,"class<`kableExtra`, `knitr_kable`>",1
+kableExtra,htmlTable_styling,0,0,0,class<`knitr_kable`>,1
+kableExtra,htmlTable_styling,0,0,1,"class<`kableExtra`, `knitr_kable`>",1
+kableExtra,htmlTable_styling,1,0,0,character[],1
+kableExtra,htmlTable_styling,2,0,0,logical,1
+kableExtra,htmlTable_styling,3,0,0,character,1
+kableExtra,htmlTable_styling,4,0,0,null,1
+kableExtra,htmlTable_styling,4,0,1,double,1
+kableExtra,htmlTable_styling,5,0,0,logical,1
+kableExtra,htmlTable_styling,6,0,0,logical,1
+kableExtra,html_tfoot_maker,-1,0,0,class<`xml_node`>,1
+kableExtra,html_tfoot_maker,0,0,0,list<list<class<`data.frame`> | character>>,1
+kableExtra,html_tfoot_maker,1,0,0,logical,1
+kableExtra,html_tfoot_maker_,-1,0,0,character[],1
+kableExtra,html_tfoot_maker_,0,0,0,class<`data.frame`>,1
+kableExtra,html_tfoot_maker_,1,0,0,character,1
+kableExtra,html_tfoot_maker_,2,0,0,any,1
+kableExtra,html_tfoot_maker_,3,0,0,logical,1
+kableExtra,input_escape,-1,0,0,character[],1
+kableExtra,input_escape,0,0,0,character[],1
+kableExtra,input_escape,1,0,0,character,1
+kableExtra,kable_dt_latex,-1,0,0,class<`data.frame`>,1
+kableExtra,kable_dt_latex,0,0,0,character[],1
+kableExtra,kable_styling,-1,0,0,"class<`kableExtra`, `knitr_kable`>",1
+kableExtra,kable_styling,-1,0,1,class<`knitr_kable`>,1
+kableExtra,kable_styling,0,0,0,class<`knitr_kable`>,1
+kableExtra,kable_styling,0,0,1,"class<`kableExtra`, `knitr_kable`>",1
+kableExtra,kable_styling,1,0,0,character[],1
+kableExtra,kable_styling,2,0,0,character[],1
+kableExtra,kable_styling,3,0,0,logical,1
+kableExtra,kable_styling,3,0,1,null,1
+kableExtra,kable_styling,4,0,0,character,1
+kableExtra,kable_styling,5,0,0,null,1
+kableExtra,kable_styling,5,0,1,double,1
+kableExtra,kable_styling,6,0,0,character,1
+kableExtra,kable_styling,7,0,0,character,1
+kableExtra,landscape,-1,0,0,class<`knitr_kable`>,1
+kableExtra,landscape,0,0,0,class<`knitr_kable`>,1
+kableExtra,landscape,1,0,0,null,1
+kableExtra,landscape_latex,-1,0,0,class<`knitr_kable`>,1
+kableExtra,landscape_latex,0,0,0,class<`knitr_kable`>,1
+kableExtra,landscape_latex,1,0,0,null,1
+kableExtra,latex_color,-1,0,0,character[],1
+kableExtra,latex_color,0,0,0,character[],1
+kableExtra,latex_color,0,0,1,class<`factor`>,1
+kableExtra,latex_column_align_builder,-1,0,0,character,1
+kableExtra,latex_column_align_builder,0,0,0,character,1
+kableExtra,latex_column_align_builder,1,0,0,character,1
+kableExtra,latex_column_align_builder,1,0,1,null,1
+kableExtra,latex_column_align_builder,2,0,0,logical,1
+kableExtra,latex_column_align_builder,3,0,0,logical,1
+kableExtra,latex_column_align_builder,4,0,0,logical,1
+kableExtra,latex_column_align_builder,5,0,0,logical,1
+kableExtra,latex_column_align_builder,6,0,0,logical,1
+kableExtra,latex_column_align_builder,7,0,0,null,1
+kableExtra,latex_column_align_builder,7,0,1,character,1
+kableExtra,latex_indent_unit,-1,0,0,character,1
+kableExtra,latex_indent_unit,0,0,0,character,1
+kableExtra,latex_new_row_builder,-1,0,0,character[],1
+kableExtra,latex_new_row_builder,0,0,0,character,1
+kableExtra,latex_new_row_builder,1,0,0,any,1
+kableExtra,latex_new_row_builder,2,0,0,logical,1
+kableExtra,latex_new_row_builder,3,0,0,logical,1
+kableExtra,latex_new_row_builder,4,0,0,logical,1
+kableExtra,latex_new_row_builder,5,0,0,logical,1
+kableExtra,latex_new_row_builder,6,0,0,logical,1
+kableExtra,latex_new_row_builder,7,0,0,null,1
+kableExtra,latex_new_row_builder,7,0,1,character,1
+kableExtra,latex_row_cells,-1,0,0,list<character[]>,1
+kableExtra,latex_row_cells,0,0,0,character,1
+kableExtra,latex_tfoot_maker,-1,0,0,character,1
+kableExtra,latex_tfoot_maker,0,0,0,list<list<class<`data.frame`> | character>>,1
+kableExtra,latex_tfoot_maker,1,0,0,any,1
+kableExtra,latex_tfoot_maker,2,0,0,any,1
+kableExtra,latex_tfoot_maker,3,0,0,logical,1
+kableExtra,latex_tfoot_maker_,-1,0,0,character[],1
+kableExtra,latex_tfoot_maker_,0,0,0,class<`data.frame`>,1
+kableExtra,latex_tfoot_maker_,1,0,0,character,1
+kableExtra,latex_tfoot_maker_,2,0,0,logical,1
+kableExtra,latex_tfoot_maker_,3,0,0,integer,1
+kableExtra,latex_tfoot_maker_tpt_,-1,0,0,character,1
+kableExtra,latex_tfoot_maker_tpt_,0,0,0,class<`data.frame`>,1
+kableExtra,latex_tfoot_maker_tpt_,1,0,0,character,1
+kableExtra,latex_tfoot_maker_tpt_,2,0,0,any,1
+kableExtra,latex_tfoot_maker_tpt_,3,0,0,any,1
+kableExtra,linebreak,-1,0,0,character[],1
+kableExtra,linebreak,-1,0,1,double[],1
+kableExtra,linebreak,0,0,0,character[],1
+kableExtra,linebreak,0,0,1,class<`factor`>,1
+kableExtra,linebreak,0,0,2,double[],1
+kableExtra,linebreak,1,0,0,any,1
+kableExtra,linebreak,2,0,0,any,1
+kableExtra,linebreak,3,0,0,character,1
+kableExtra,magic_mirror,-1,0,0,list<any>,1
+kableExtra,magic_mirror,0,0,0,"class<`kableExtra`, `knitr_kable`>",1
+kableExtra,magic_mirror,0,0,1,class<`knitr_kable`>,1
+kableExtra,magic_mirror_html,-1,0,0,list<character[] | integer>,1
+kableExtra,magic_mirror_html,-1,0,1,list<null | character[] | integer>,1
+kableExtra,magic_mirror_html,0,0,0,"class<`kableExtra`, `knitr_kable`>",1
+kableExtra,magic_mirror_html,0,0,1,class<`knitr_kable`>,1
+kableExtra,magic_mirror_latex,-1,0,0,list<character[] | null | double>,1
+kableExtra,magic_mirror_latex,0,0,0,class<`knitr_kable`>,1
+kableExtra,midline_groups,-1,0,0,character,1
+kableExtra,midline_groups,0,0,0,integer[],1
+kableExtra,midline_groups,1,0,0,logical,1
+kableExtra,pack_rows,-1,0,0,"class<`kableExtra`, `knitr_kable`>",1
+kableExtra,pack_rows,-1,0,1,class<`knitr_kable`>,1
+kableExtra,pack_rows,0,0,0,"class<`kableExtra`, `knitr_kable`>",1
+kableExtra,pack_rows,0,0,1,class<`knitr_kable`>,1
+kableExtra,pack_rows,1,0,0,character,1
+kableExtra,pack_rows,1,0,1,null,1
+kableExtra,pack_rows,2,0,0,double,1
+kableExtra,pack_rows,2,0,1,null,1
+kableExtra,pack_rows,3,0,0,double,1
+kableExtra,pack_rows,3,0,1,null,1
+kableExtra,pack_rows,4,0,0,null,1
+kableExtra,pack_rows,4,0,1,integer[],1
+kableExtra,pack_rows,5,0,0,character,1
+kableExtra,pack_rows,6,0,0,character,1
+kableExtra,pack_rows,7,0,0,logical,1
+kableExtra,pdfTable_add_header_above,-1,0,0,class<`knitr_kable`>,1
+kableExtra,pdfTable_add_header_above,0,0,0,class<`knitr_kable`>,1
+kableExtra,pdfTable_add_header_above,1,0,0,character[],1
+kableExtra,pdfTable_add_header_above,1,0,1,double[],1
+kableExtra,pdfTable_add_header_above,2,0,0,logical,1
+kableExtra,pdfTable_add_header_above,3,0,0,logical,1
+kableExtra,pdfTable_add_header_above,4,0,0,logical,1
+kableExtra,pdfTable_add_header_above,5,0,0,logical,1
+kableExtra,pdfTable_add_header_above,6,0,0,logical,1
+kableExtra,pdfTable_add_header_above,7,0,0,character,1
+kableExtra,pdfTable_new_header_generator,-1,0,0,character[],1
+kableExtra,pdfTable_new_header_generator,0,0,0,class<`data.frame`>,1
+kableExtra,pdfTable_new_header_generator,1,0,0,logical,1
+kableExtra,pdfTable_new_header_generator,2,0,0,logical,1
+kableExtra,pdfTable_new_header_generator,3,0,0,logical,1
+kableExtra,pdfTable_new_header_generator,4,0,0,logical,1
+kableExtra,pdfTable_new_header_generator,5,0,0,logical,1
+kableExtra,pdfTable_new_header_generator,6,0,0,logical,1
+kableExtra,pdfTable_new_header_generator,7,0,0,character,1
+kableExtra,pdfTable_styling,-1,0,0,class<`knitr_kable`>,1
+kableExtra,pdfTable_styling,0,0,0,class<`knitr_kable`>,1
+kableExtra,pdfTable_styling,1,0,0,character[],1
+kableExtra,pdfTable_styling,2,0,0,logical,1
+kableExtra,pdfTable_styling,3,0,0,character,1
+kableExtra,pdfTable_styling,4,0,0,null,1
+kableExtra,pdfTable_styling,4,0,1,double,1
+kableExtra,pdfTable_styling,5,0,0,character,1
+kableExtra,pdfTable_styling,6,0,0,any,1
+kableExtra,pdfTable_styling,7,0,0,any,1
+kableExtra,positions_corrector,-1,0,0,integer[],1
+kableExtra,positions_corrector,0,0,0,integer[],1
+kableExtra,positions_corrector,1,0,0,integer[],1
+kableExtra,positions_corrector,2,0,0,integer,1
+kableExtra,read_kable_as_xml,-1,0,0,class<`xml_node`>,1
+kableExtra,read_kable_as_xml,0,0,0,"class<`kableExtra`, `knitr_kable`>",1
+kableExtra,read_kable_as_xml,0,0,1,class<`knitr_kable`>,1
+kableExtra,regex_escape,-1,0,0,character[],1
+kableExtra,regex_escape,0,0,0,character[],1
+kableExtra,regex_escape,1,0,0,logical,1
+kableExtra,replace_latex_in_kable,-1,0,0,class<`knitr_kable`>,1
+kableExtra,replace_latex_in_kable,0,0,0,class<`knitr_kable`>,1
+kableExtra,replace_latex_in_kable,1,0,0,character[],1
+kableExtra,replace_makecell_with_newline,-1,0,0,list<class<`knitr_kable`> | list<character[] | null | double>>,1
+kableExtra,replace_makecell_with_newline,0,0,0,class<`knitr_kable`>,1
+kableExtra,replace_makecell_with_newline,1,0,0,list<character[] | null | double>,1
+kableExtra,replace_makecell_with_newline,2,0,0,any,1
+kableExtra,row_spec,-1,0,0,"class<`kableExtra`, `knitr_kable`>",1
+kableExtra,row_spec,-1,0,1,class<`knitr_kable`>,1
+kableExtra,row_spec,0,0,0,"class<`kableExtra`, `knitr_kable`>",1
+kableExtra,row_spec,0,0,1,class<`knitr_kable`>,1
+kableExtra,row_spec,1,0,0,double[],1
+kableExtra,row_spec,2,0,0,logical,1
+kableExtra,row_spec,3,0,0,logical,1
+kableExtra,row_spec,4,0,0,logical,1
+kableExtra,row_spec,5,0,0,logical,1
+kableExtra,row_spec,6,0,0,logical,1
+kableExtra,row_spec,7,0,0,null,1
+kableExtra,row_spec,7,0,1,character,1
+kableExtra,row_spec_html,-1,0,0,"class<`kableExtra`, `knitr_kable`>",1
+kableExtra,row_spec_html,0,0,0,"class<`kableExtra`, `knitr_kable`>",1
+kableExtra,row_spec_html,0,0,1,class<`knitr_kable`>,1
+kableExtra,row_spec_html,1,0,0,double,1
+kableExtra,row_spec_html,1,0,1,integer[],1
+kableExtra,row_spec_html,2,0,0,logical,1
+kableExtra,row_spec_html,3,0,0,logical,1
+kableExtra,row_spec_html,4,0,0,logical,1
+kableExtra,row_spec_html,5,0,0,logical,1
+kableExtra,row_spec_html,6,0,0,logical,1
+kableExtra,row_spec_html,7,0,0,null,1
+kableExtra,row_spec_html,7,0,1,character,1
+kableExtra,row_spec_latex,-1,0,0,class<`knitr_kable`>,1
+kableExtra,row_spec_latex,0,0,0,class<`knitr_kable`>,1
+kableExtra,row_spec_latex,1,0,0,double[],1
+kableExtra,row_spec_latex,2,0,0,logical,1
+kableExtra,row_spec_latex,3,0,0,logical,1
+kableExtra,row_spec_latex,4,0,0,logical,1
+kableExtra,row_spec_latex,5,0,0,logical,1
+kableExtra,row_spec_latex,6,0,0,logical,1
+kableExtra,row_spec_latex,7,0,0,null,1
+kableExtra,row_spec_latex,7,0,1,character,1
+kableExtra,scroll_box,-1,0,0,"class<`kableExtra`, `knitr_kable`>",1
+kableExtra,scroll_box,0,0,0,"class<`kableExtra`, `knitr_kable`>",1
+kableExtra,scroll_box,1,0,0,character,1
+kableExtra,scroll_box,2,0,0,character,1
+kableExtra,scroll_box,3,0,0,character,1
+kableExtra,scroll_box,4,0,0,null,1
+kableExtra,scroll_box,5,0,0,logical,1
+kableExtra,solve_enc,-1,0,0,class<`knitr_kable`>,1
+kableExtra,solve_enc,0,0,0,class<`knitr_kable`>,1
+kableExtra,spec_color,-1,0,0,character[],1
+kableExtra,spec_color,0,0,0,double[],1
+kableExtra,spec_color,1,0,0,double,1
+kableExtra,spec_color,2,0,0,double,1
+kableExtra,spec_color,3,0,0,double,1
+kableExtra,spec_color,4,0,0,double,1
+kableExtra,spec_color,5,0,0,character,1
+kableExtra,spec_color,6,0,0,character,1
+kableExtra,spec_color,7,0,0,null,1
+kableExtra,spec_font_size,-1,0,0,double[],1
+kableExtra,spec_font_size,0,0,0,double[],1
+kableExtra,spec_font_size,1,0,0,double,1
+kableExtra,spec_font_size,2,0,0,double,1
+kableExtra,spec_font_size,3,0,0,double,1
+kableExtra,spec_font_size,4,0,0,null,1
+kableExtra,spec_popover,-1,0,0,class<`ke_popover`>,1
+kableExtra,spec_popover,0,0,0,character[],1
+kableExtra,spec_popover,1,0,0,null,1
+kableExtra,spec_popover,2,0,0,character,1
+kableExtra,spec_popover,3,0,0,character[],1
+kableExtra,spec_tooltip,-1,0,0,class<`ke_tooltip`>,1
+kableExtra,spec_tooltip,0,0,0,character[],1
+kableExtra,spec_tooltip,1,0,0,character,1
+kableExtra,standardize_header_input,-1,0,0,class<`data.frame`>,1
+kableExtra,standardize_header_input,0,0,0,character[],1
+kableExtra,standardize_header_input,0,0,1,double[],1
+kableExtra,styling_latex_font_size,-1,0,0,character,1
+kableExtra,styling_latex_font_size,0,0,0,class<`knitr_kable`>,1
+kableExtra,styling_latex_font_size,1,0,0,list<character[] | null | double>,1
+kableExtra,styling_latex_font_size,2,0,0,double,1
+kableExtra,styling_latex_full_width,-1,0,0,list<class<`knitr_kable`> | character[]>,1
+kableExtra,styling_latex_full_width,0,0,0,class<`knitr_kable`>,1
+kableExtra,styling_latex_full_width,1,0,0,list<character[] | null | double>,1
+kableExtra,styling_latex_hold_position,-1,0,0,character,1
+kableExtra,styling_latex_hold_position,0,0,0,class<`knitr_kable`>,1
+kableExtra,styling_latex_HOLD_position,-1,0,0,character,1
+kableExtra,styling_latex_HOLD_position,0,0,0,character,1
+kableExtra,styling_latex_position,-1,0,0,character,1
+kableExtra,styling_latex_position,-1,0,1,class<`knitr_kable`>,1
+kableExtra,styling_latex_position,0,0,0,character,1
+kableExtra,styling_latex_position,0,0,1,class<`knitr_kable`>,1
+kableExtra,styling_latex_position,1,0,0,list<any>,1
+kableExtra,styling_latex_position,2,0,0,character,1
+kableExtra,styling_latex_position,3,0,0,character[],1
+kableExtra,styling_latex_position,4,0,0,any,1
+kableExtra,styling_latex_position_center,-1,0,0,character,1
+kableExtra,styling_latex_position_center,-1,0,1,class<`knitr_kable`>,1
+kableExtra,styling_latex_position_center,0,0,0,character,1
+kableExtra,styling_latex_position_center,0,0,1,class<`knitr_kable`>,1
+kableExtra,styling_latex_position_center,1,0,0,list<any>,1
+kableExtra,styling_latex_position_center,2,0,0,any,1
+kableExtra,styling_latex_position_center,3,0,0,any,1
+kableExtra,styling_latex_position_float,-1,0,0,character,1
+kableExtra,styling_latex_position_float,0,0,0,class<`knitr_kable`>,1
+kableExtra,styling_latex_position_float,1,0,0,list<character[] | null | double>,1
+kableExtra,styling_latex_position_float,2,0,0,character,1
+kableExtra,styling_latex_position_float,3,0,0,any,1
+kableExtra,styling_latex_repeat_header,-1,0,0,character,1
+kableExtra,styling_latex_repeat_header,0,0,0,class<`knitr_kable`>,1
+kableExtra,styling_latex_repeat_header,1,0,0,list<any>,1
+kableExtra,styling_latex_repeat_header,2,0,0,character,1
+kableExtra,styling_latex_repeat_header,3,0,0,character,1
+kableExtra,styling_latex_repeat_header,4,0,0,logical,1
+kableExtra,styling_latex_scale_down,-1,0,0,class<`knitr_kable`>,1
+kableExtra,styling_latex_scale_down,0,0,0,class<`knitr_kable`>,1
+kableExtra,styling_latex_scale_down,1,0,0,list<character[] | null | double>,1
+kableExtra,styling_latex_striped,-1,0,0,class<`knitr_kable`>,1
+kableExtra,styling_latex_striped,0,0,0,class<`knitr_kable`>,1
+kableExtra,styling_latex_striped,1,0,0,any,1
+kableExtra,styling_latex_striped,2,0,0,character,1
+kableExtra,styling_latex_striped,3,0,0,double[],1
+kableExtra,styling_latex_striped,3,0,1,null,1
+kableExtra,styling_latex_table_env,-1,0,0,class<`knitr_kable`>,1
+kableExtra,styling_latex_table_env,0,0,0,class<`knitr_kable`>,1
+kableExtra,styling_latex_table_env,1,0,0,character,1
+kableExtra,styling_latex_table_env,2,0,0,character,1
+kableExtra,text_spec,-1,0,0,character[],1
+kableExtra,text_spec,0,0,0,character[],1
+kableExtra,text_spec,1,0,0,any,1
+kableExtra,text_spec,2,0,0,logical,1
+kableExtra,text_spec,3,0,0,logical,1
+kableExtra,text_spec,4,0,0,logical,1
+kableExtra,text_spec,5,0,0,logical,1
+kableExtra,text_spec,6,0,0,logical,1
+kableExtra,text_spec,7,0,0,character[],1
+kableExtra,usepackage_latex,-1,0,0,list<class<`latex_dependency`>>,1
+kableExtra,usepackage_latex,0,0,0,character,1
+kableExtra,usepackage_latex,1,0,0,null,1
+kableExtra,xml_cell_style,-1,0,0,class<`xml_node`>,1
+kableExtra,xml_cell_style,0,0,0,class<`xml_node`>,1
+kableExtra,xml_cell_style,1,0,0,logical,1
+kableExtra,xml_cell_style,2,0,0,logical,1
+kableExtra,xml_cell_style,3,0,0,logical,1
+kableExtra,xml_cell_style,4,0,0,logical,1
+kableExtra,xml_cell_style,5,0,0,logical,1
+kableExtra,xml_cell_style,6,0,0,character,1
+kableExtra,xml_cell_style,6,0,1,null,1
+kableExtra,xml_cell_style,7,0,0,character,1
+kableExtra,xml_cell_style,7,0,1,null,1
+kableExtra,xml_tpart,-1,0,0,class<`xml_node`>,1
+kableExtra,xml_tpart,-1,0,1,null,1
+kableExtra,xml_tpart,0,0,0,class<`xml_node`>,1
+kableExtra,xml_tpart,1,0,0,character,1
+kappalab,additive.capacity,-1,0,0,class<`Mobius.capacity`>,1
+kappalab,additive.capacity,0,0,0,double[],1
+kappalab,as.capacity,-1,0,0,class<`capacity`>,1
+kappalab,as.capacity,0,0,0,class<`set.func`>,1
+kappalab,as.capacity,1,0,0,...,1
+kappalab,as.capacity,-1,1,0,class<`capacity`>,1
+kappalab,as.capacity,0,1,0,class<`game`>,1
+kappalab,as.capacity,1,1,0,...,1
+kappalab,as.capacity,-1,2,0,class<`capacity`>,1
+kappalab,as.capacity,0,2,0,class<`card.capacity`>,1
+kappalab,as.capacity,1,2,0,...,1
+kappalab,as.capacity,-1,3,0,class<`capacity`>,1
+kappalab,as.capacity,0,3,0,class<`card.capacity`>,1
+kappalab,as.capacity,0,3,1,class<`game`>,1
+kappalab,as.capacity,0,3,2,class<`set.func`>,1
+kappalab,as.capacity,1,3,0,...,1
+kappalab,as.card.capacity,-1,0,0,class<`card.capacity`>,1
+kappalab,as.card.capacity,0,0,0,class<`capacity`>,1
+kappalab,as.card.capacity,1,0,0,...,1
+kappalab,as.card.capacity,-1,1,0,class<`card.capacity`>,1
+kappalab,as.card.capacity,0,1,0,class<`card.set.func`>,1
+kappalab,as.card.capacity,1,1,0,...,1
+kappalab,as.card.capacity,-1,2,0,class<`card.capacity`>,1
+kappalab,as.card.capacity,0,2,0,class<`capacity`>,1
+kappalab,as.card.capacity,0,2,1,class<`card.set.func`>,1
+kappalab,as.card.capacity,1,2,0,...,1
+kappalab,as.card.game,-1,0,0,class<`card.game`>,1
+kappalab,as.card.game,0,0,0,class<`card.set.func`>,1
+kappalab,as.card.game,1,0,0,...,1
+kappalab,as.card.game,-1,1,0,class<`card.game`>,1
+kappalab,as.card.game,0,1,0,class<`game`>,1
+kappalab,as.card.game,1,1,0,...,1
+kappalab,as.card.game,-1,2,0,class<`card.game`>,1
+kappalab,as.card.game,0,2,0,class<`card.set.func`>,1
+kappalab,as.card.game,0,2,1,class<`game`>,1
+kappalab,as.card.game,1,2,0,...,1
+kappalab,as.card.set.func,-1,0,0,class<`card.set.func`>,1
+kappalab,as.card.set.func,0,0,0,class<`set.func`>,1
+kappalab,as.card.set.func,1,0,0,...,1
+kappalab,as.card.set.func,-1,1,0,class<`card.set.func`>,1
+kappalab,as.card.set.func,0,1,0,class<`set.func`>,1
+kappalab,as.card.set.func,1,1,0,...,1
+kappalab,as.card.set.func.internal,-1,0,0,list<double[]>,1
+kappalab,as.card.set.func.internal,0,0,0,class<`capacity`>,1
+kappalab,as.card.set.func.internal,0,0,1,class<`game`>,1
+kappalab,as.card.set.func.internal,0,0,2,class<`set.func`>,1
+kappalab,as.game,-1,0,0,class<`game`>,1
+kappalab,as.game,0,0,0,class<`set.func`>,1
+kappalab,as.game,1,0,0,...,1
+kappalab,as.game,-1,1,0,class<`game`>,1
+kappalab,as.game,0,1,0,class<`capacity`>,1
+kappalab,as.game,1,1,0,...,1
+kappalab,as.game,-1,2,0,class<`game`>,1
+kappalab,as.game,0,2,0,class<`capacity`>,1
+kappalab,as.game,0,2,1,class<`card.game`>,1
+kappalab,as.game,0,2,2,class<`set.func`>,1
+kappalab,as.game,1,2,0,...,1
+kappalab,as.game,-1,3,0,class<`game`>,1
+kappalab,as.game,0,3,0,class<`card.game`>,1
+kappalab,as.game,1,3,0,...,1
+kappalab,as.Mobius.capacity,-1,0,0,class<`Mobius.capacity`>,1
+kappalab,as.Mobius.capacity,0,0,0,class<`Mobius.set.func`>,1
+kappalab,as.Mobius.capacity,1,0,0,...,1
+kappalab,as.Mobius.capacity,-1,1,0,class<`Mobius.capacity`>,1
+kappalab,as.Mobius.capacity,0,1,0,class<`Mobius.set.func`>,1
+kappalab,as.Mobius.capacity,1,1,0,...,1
+kappalab,as.Mobius.card.set.func,-1,0,0,class<`Mobius.card.set.func`>,1
+kappalab,as.Mobius.card.set.func,0,0,0,class<`Mobius.set.func`>,1
+kappalab,as.Mobius.card.set.func,1,0,0,...,1
+kappalab,as.Mobius.card.set.func,-1,1,0,class<`Mobius.card.set.func`>,1
+kappalab,as.Mobius.card.set.func,0,1,0,class<`Mobius.set.func`>,1
+kappalab,as.Mobius.card.set.func,1,1,0,...,1
+kappalab,as.Mobius.game,-1,0,0,class<`Mobius.game`>,1
+kappalab,as.Mobius.game,0,0,0,class<`Mobius.set.func`>,1
+kappalab,as.Mobius.game,1,0,0,...,1
+kappalab,as.Mobius.game,-1,1,0,class<`Mobius.game`>,1
+kappalab,as.Mobius.game,0,1,0,class<`Mobius.set.func`>,1
+kappalab,as.Mobius.game,1,1,0,...,1
+kappalab,as.Mobius.set.func,-1,0,0,class<`Mobius.set.func`>,1
+kappalab,as.Mobius.set.func,0,0,0,class<`Mobius.card.set.func`>,1
+kappalab,as.Mobius.set.func,1,0,0,...,1
+kappalab,as.Mobius.set.func,-1,1,0,class<`Mobius.set.func`>,1
+kappalab,as.Mobius.set.func,0,1,0,class<`Mobius.card.set.func`>,1
+kappalab,as.Mobius.set.func,1,1,0,...,1
+kappalab,as.set.func,-1,0,0,class<`set.func`>,1
+kappalab,as.set.func,0,0,0,class<`card.set.func`>,1
+kappalab,as.set.func,1,0,0,...,1
+kappalab,as.set.func,-1,1,0,class<`set.func`>,1
+kappalab,as.set.func,0,1,0,class<`card.capacity`>,1
+kappalab,as.set.func,1,1,0,...,1
+kappalab,as.set.func,-1,2,0,class<`set.func`>,1
+kappalab,as.set.func,0,2,0,class<`Mobius.card.set.func`>,1
+kappalab,as.set.func,1,2,0,...,1
+kappalab,as.set.func,-1,3,0,class<`set.func`>,1
+kappalab,as.set.func,0,3,0,class<`card.capacity`>,1
+kappalab,as.set.func,0,3,1,class<`card.set.func`>,1
+kappalab,as.set.func,0,3,2,class<`Mobius.card.set.func`>,1
+kappalab,as.set.func,1,3,0,...,1
+kappalab,as.set.func.internal,-1,0,0,list<double[]>,1
+kappalab,as.set.func.internal,0,0,0,class<`card.capacity`>,1
+kappalab,as.set.func.internal,0,0,1,class<`card.game`>,1
+kappalab,as.set.func.internal,0,0,2,class<`card.set.func`>,1
+kappalab,as.set.func.internal,0,0,3,class<`Mobius.card.set.func`>,1
+kappalab,binary2subset,-1,0,0,integer[],1
+kappalab,binary2subset,0,0,0,integer,1
+kappalab,binary2subset,1,0,0,double,1
+kappalab,binom.sum,-1,0,0,double,1
+kappalab,binom.sum,0,0,0,double,1
+kappalab,binom.sum,1,0,0,double,1
+kappalab,capacity,-1,0,0,class<`capacity`>,1
+kappalab,capacity,0,0,0,double[],1
+kappalab,card.capacity,-1,0,0,class<`card.capacity`>,1
+kappalab,card.capacity,0,0,0,double[],1
+kappalab,card.game,-1,0,0,class<`card.game`>,1
+kappalab,card.game,0,0,0,double[],1
+kappalab,card.set.func,-1,0,0,class<`card.set.func`>,1
+kappalab,card.set.func,0,0,0,double[],1
+kappalab,cdf.Choquet.unif,-1,0,0,double,1
+kappalab,cdf.Choquet.unif,0,0,0,class<`capacity`>,1
+kappalab,cdf.Choquet.unif,1,0,0,double,1
+kappalab,cdf.Choquet.unif,2,0,0,...,1
+kappalab,cdf.Choquet.unif,-1,1,0,double,1
+kappalab,cdf.Choquet.unif,0,1,0,class<`capacity`>,1
+kappalab,cdf.Choquet.unif,1,1,0,double,1
+kappalab,cdf.Choquet.unif,2,1,0,...,1
+kappalab,Choquet.integral,-1,0,0,double,1
+kappalab,Choquet.integral,0,0,0,class<`capacity`>,1
+kappalab,Choquet.integral,0,0,1,class<`card.capacity`>,1
+kappalab,Choquet.integral,0,0,2,class<`card.game`>,1
+kappalab,Choquet.integral,0,0,3,class<`game`>,1
+kappalab,Choquet.integral,0,0,4,class<`Mobius.capacity`>,1
+kappalab,Choquet.integral,0,0,5,class<`Mobius.game`>,1
+kappalab,Choquet.integral,1,0,0,double[],1
+kappalab,Choquet.integral,2,0,0,...,1
+kappalab,Choquet.integral,-1,1,0,double,1
+kappalab,Choquet.integral,0,1,0,class<`card.game`>,1
+kappalab,Choquet.integral,1,1,0,double[],1
+kappalab,Choquet.integral,2,1,0,...,1
+kappalab,Choquet.integral,-1,2,0,double,1
+kappalab,Choquet.integral,0,2,0,class<`capacity`>,1
+kappalab,Choquet.integral,1,2,0,double[],1
+kappalab,Choquet.integral,2,2,0,...,1
+kappalab,Choquet.integral,-1,3,0,double,1
+kappalab,Choquet.integral,0,3,0,class<`Mobius.capacity`>,1
+kappalab,Choquet.integral,1,3,0,double[],1
+kappalab,Choquet.integral,2,3,0,...,1
+kappalab,Choquet.integral,-1,4,0,double,1
+kappalab,Choquet.integral,0,4,0,class<`Mobius.game`>,1
+kappalab,Choquet.integral,1,4,0,double[],1
+kappalab,Choquet.integral,2,4,0,...,1
+kappalab,Choquet.integral,-1,5,0,double,1
+kappalab,Choquet.integral,0,5,0,class<`game`>,1
+kappalab,Choquet.integral,1,5,0,double[],1
+kappalab,Choquet.integral,2,5,0,...,1
+kappalab,Choquet.integral,-1,6,0,double,1
+kappalab,Choquet.integral,0,6,0,class<`card.capacity`>,1
+kappalab,Choquet.integral,1,6,0,double[],1
+kappalab,Choquet.integral,2,6,0,...,1
+kappalab,Choquet.preorder.constraint,-1,0,0,list<double[]>,1
+kappalab,Choquet.preorder.constraint,0,0,0,double,1
+kappalab,Choquet.preorder.constraint,1,0,0,double,1
+kappalab,Choquet.preorder.constraint,2,0,0,integer[],1
+kappalab,Choquet.preorder.constraint,3,0,0,double[],1
+kappalab,Choquet.preorder.constraint,4,0,0,double[],1
+kappalab,Choquet.preorder.constraint,5,0,0,double,1
+kappalab,conjugate,-1,0,0,class<`card.game`>,1
+kappalab,conjugate,0,0,0,class<`card.set.func`>,1
+kappalab,conjugate,1,0,0,...,1
+kappalab,conjugate,-1,1,0,class<`card.capacity`>,1
+kappalab,conjugate,0,1,0,class<`card.capacity`>,1
+kappalab,conjugate,1,1,0,...,1
+kappalab,conjugate,-1,2,0,class<`capacity`>,1
+kappalab,conjugate,0,2,0,class<`capacity`>,1
+kappalab,conjugate,1,2,0,...,1
+kappalab,conjugate,-1,3,0,class<`game`>,1
+kappalab,conjugate,0,3,0,class<`set.func`>,1
+kappalab,conjugate,1,3,0,...,1
+kappalab,conjugate,-1,4,0,class<`capacity`>,1
+kappalab,conjugate,-1,4,1,class<`card.capacity`>,1
+kappalab,conjugate,-1,4,2,class<`card.game`>,1
+kappalab,conjugate,-1,4,3,class<`game`>,1
+kappalab,conjugate,0,4,0,class<`capacity`>,1
+kappalab,conjugate,0,4,1,class<`card.capacity`>,1
+kappalab,conjugate,0,4,2,class<`card.game`>,1
+kappalab,conjugate,0,4,3,class<`card.set.func`>,1
+kappalab,conjugate,0,4,4,class<`game`>,1
+kappalab,conjugate,0,4,5,class<`set.func`>,1
+kappalab,conjugate,1,4,0,...,1
+kappalab,conjugate,-1,5,0,class<`card.game`>,1
+kappalab,conjugate,0,5,0,class<`card.game`>,1
+kappalab,conjugate,1,5,0,...,1
+kappalab,conjugate,-1,6,0,class<`game`>,1
+kappalab,conjugate,0,6,0,class<`game`>,1
+kappalab,conjugate,1,6,0,...,1
+kappalab,conjugate.internal,-1,0,0,list<double[]>,1
+kappalab,conjugate.internal,0,0,0,class<`capacity`>,1
+kappalab,conjugate.internal,0,0,1,class<`game`>,1
+kappalab,conjugate.internal,0,0,2,class<`set.func`>,1
+kappalab,entropy,-1,0,0,double,1
+kappalab,entropy,0,0,0,class<`card.capacity`>,1
+kappalab,entropy,1,0,0,...,1
+kappalab,entropy,-1,1,0,double,1
+kappalab,entropy,0,1,0,class<`capacity`>,1
+kappalab,entropy,1,1,0,...,1
+kappalab,entropy,-1,2,0,double,1
+kappalab,entropy,0,2,0,class<`Mobius.capacity`>,1
+kappalab,entropy,1,2,0,...,1
+kappalab,entropy,-1,3,0,double,1
+kappalab,entropy,0,3,0,class<`capacity`>,1
+kappalab,entropy,0,3,1,class<`card.capacity`>,1
+kappalab,entropy,0,3,2,class<`Mobius.capacity`>,1
+kappalab,entropy,1,3,0,...,1
+kappalab,entropy.capa.ident,-1,0,0,class<`capacity`>,1
+kappalab,entropy.capa.ident,0,0,0,class<`data.frame`>,1
+kappalab,entropy.capa.ident,1,0,0,character,1
+kappalab,entropy.capa.ident,2,0,0,double,1
+kappalab,expect.Choquet.norm,-1,0,0,double,1
+kappalab,expect.Choquet.norm,0,0,0,class<`capacity`>,1
+kappalab,expect.Choquet.norm,0,0,1,class<`Mobius.capacity`>,1
+kappalab,expect.Choquet.norm,1,0,0,...,1
+kappalab,expect.Choquet.norm,-1,1,0,double,1
+kappalab,expect.Choquet.norm,0,1,0,class<`capacity`>,1
+kappalab,expect.Choquet.norm,1,1,0,...,1
+kappalab,expect.Choquet.norm,-1,2,0,double,1
+kappalab,expect.Choquet.norm,0,2,0,class<`Mobius.capacity`>,1
+kappalab,expect.Choquet.norm,1,2,0,...,1
+kappalab,expect.Choquet.unif,-1,0,0,double,1
+kappalab,expect.Choquet.unif,0,0,0,class<`capacity`>,1
+kappalab,expect.Choquet.unif,1,0,0,...,1
+kappalab,expect.Choquet.unif,-1,1,0,double,1
+kappalab,expect.Choquet.unif,0,1,0,class<`capacity`>,1
+kappalab,expect.Choquet.unif,1,1,0,...,1
+kappalab,favor,-1,0,0,double[],1
+kappalab,favor,0,0,0,class<`Mobius.capacity`>,1
+kappalab,favor,1,0,0,...,1
+kappalab,favor,-1,1,0,double[],1
+kappalab,favor,0,1,0,class<`capacity`>,1
+kappalab,favor,1,1,0,...,1
+kappalab,favor,-1,2,0,double[],1
+kappalab,favor,0,2,0,class<`capacity`>,1
+kappalab,favor,0,2,1,class<`Mobius.capacity`>,1
+kappalab,favor,0,2,2,class<`card.capacity`>,1
+kappalab,favor,1,2,0,...,1
+kappalab,favor,-1,3,0,double,1
+kappalab,favor,0,3,0,class<`card.capacity`>,1
+kappalab,favor,1,3,0,...,1
+kappalab,game,-1,0,0,class<`game`>,1
+kappalab,game,0,0,0,double[],1
+kappalab,heuristic.ls.capa.ident,-1,0,0,list<class<`capacity`> | double[]>,1
+kappalab,heuristic.ls.capa.ident,0,0,0,double,1
+kappalab,heuristic.ls.capa.ident,1,0,0,class<`capacity`>,1
+kappalab,heuristic.ls.capa.ident,2,0,0,class<`matrix`>,1
+kappalab,heuristic.ls.capa.ident,3,0,0,double[],1
+kappalab,heuristic.ls.capa.ident,4,0,0,character,1
+kappalab,heuristic.ls.capa.ident,5,0,0,double,1
+kappalab,heuristic.ls.capa.ident,6,0,0,double,1
+kappalab,heuristic.ls.capa.ident,7,0,0,double,1
+kappalab,interaction.indices,-1,0,0,class<`matrix`>,1
+kappalab,interaction.indices,0,0,0,class<`Mobius.set.func`>,1
+kappalab,interaction.indices,1,0,0,...,1
+kappalab,interaction.indices,-1,1,0,class<`matrix`>,1
+kappalab,interaction.indices,0,1,0,class<`capacity`>,1
+kappalab,interaction.indices,1,1,0,...,1
+kappalab,interaction.indices,-1,2,0,class<`matrix`>,1
+kappalab,interaction.indices,0,2,0,class<`set.func`>,1
+kappalab,interaction.indices,1,2,0,...,1
+kappalab,interaction.indices,-1,3,0,class<`matrix`>,1
+kappalab,interaction.indices,0,3,0,class<`Mobius.capacity`>,1
+kappalab,interaction.indices,1,3,0,...,1
+kappalab,interaction.indices,-1,4,0,class<`matrix`>,1
+kappalab,interaction.indices,0,4,0,class<`card.set.func`>,1
+kappalab,interaction.indices,1,4,0,...,1
+kappalab,interaction.indices,-1,5,0,class<`matrix`>,1
+kappalab,interaction.indices,0,5,0,class<`capacity`>,1
+kappalab,interaction.indices,0,5,1,class<`card.capacity`>,1
+kappalab,interaction.indices,0,5,2,class<`card.set.func`>,1
+kappalab,interaction.indices,0,5,3,class<`Mobius.capacity`>,1
+kappalab,interaction.indices,0,5,4,class<`Mobius.set.func`>,1
+kappalab,interaction.indices,0,5,5,class<`set.func`>,1
+kappalab,interaction.indices,1,5,0,...,1
+kappalab,interaction.indices,-1,6,0,class<`matrix`>,1
+kappalab,interaction.indices,0,6,0,class<`card.capacity`>,1
+kappalab,interaction.indices,1,6,0,...,1
+kappalab,interaction.interval.constraint,-1,0,0,list<double[]>,1
+kappalab,interaction.interval.constraint,0,0,0,double,1
+kappalab,interaction.interval.constraint,1,0,0,double,1
+kappalab,interaction.interval.constraint,2,0,0,integer[],1
+kappalab,interaction.interval.constraint,3,0,0,double,1
+kappalab,interaction.interval.constraint,4,0,0,double,1
+kappalab,interaction.interval.constraint,5,0,0,double,1
+kappalab,interaction.interval.constraint,6,0,0,double,1
+kappalab,interaction.preorder.constraint,-1,0,0,list<double[]>,1
+kappalab,interaction.preorder.constraint,0,0,0,double,1
+kappalab,interaction.preorder.constraint,1,0,0,double,1
+kappalab,interaction.preorder.constraint,2,0,0,integer[],1
+kappalab,interaction.preorder.constraint,3,0,0,double,1
+kappalab,interaction.preorder.constraint,4,0,0,double,1
+kappalab,interaction.preorder.constraint,5,0,0,double,1
+kappalab,interaction.preorder.constraint,6,0,0,double,1
+kappalab,interaction.preorder.constraint,7,0,0,double,1
+kappalab,inter.additive.partition.constraint,-1,0,0,list<class<`matrix`> | double[]>,1
+kappalab,inter.additive.partition.constraint,0,0,0,double,1
+kappalab,inter.additive.partition.constraint,1,0,0,double,1
+kappalab,inter.additive.partition.constraint,2,0,0,integer[],1
+kappalab,inter.additive.partition.constraint,3,0,0,double[],1
+kappalab,is.cardinal,-1,0,0,logical,1
+kappalab,is.cardinal,0,0,0,class<`card.set.func`>,1
+kappalab,is.cardinal,1,0,0,...,1
+kappalab,is.cardinal,-1,1,0,logical,1
+kappalab,is.cardinal,0,1,0,class<`card.capacity`>,1
+kappalab,is.cardinal,1,1,0,...,1
+kappalab,is.cardinal,-1,2,0,logical,1
+kappalab,is.cardinal,0,2,0,class<`capacity`>,1
+kappalab,is.cardinal,1,2,0,...,1
+kappalab,is.cardinal,-1,3,0,logical,1
+kappalab,is.cardinal,0,3,0,class<`Mobius.game`>,1
+kappalab,is.cardinal,1,3,0,...,1
+kappalab,is.cardinal,-1,4,0,logical,1
+kappalab,is.cardinal,0,4,0,class<`set.func`>,1
+kappalab,is.cardinal,1,4,0,...,1
+kappalab,is.cardinal,-1,5,0,logical,1
+kappalab,is.cardinal,0,5,0,class<`capacity`>,1
+kappalab,is.cardinal,0,5,1,class<`card.capacity`>,1
+kappalab,is.cardinal,0,5,2,class<`card.set.func`>,1
+kappalab,is.cardinal,0,5,3,class<`game`>,1
+kappalab,is.cardinal,0,5,4,class<`Mobius.game`>,1
+kappalab,is.cardinal,0,5,5,class<`Mobius.set.func`>,1
+kappalab,is.cardinal,0,5,6,class<`set.func`>,1
+kappalab,is.cardinal,1,5,0,...,1
+kappalab,is.cardinal,-1,6,0,logical,1
+kappalab,is.cardinal,0,6,0,class<`Mobius.set.func`>,1
+kappalab,is.cardinal,1,6,0,...,1
+kappalab,is.cardinal,-1,7,0,logical,1
+kappalab,is.cardinal,0,7,0,class<`game`>,1
+kappalab,is.cardinal,1,7,0,...,1
+kappalab,is.kadditive,-1,0,0,logical,1
+kappalab,is.kadditive,0,0,0,class<`card.set.func`>,1
+kappalab,is.kadditive,0,0,1,class<`Mobius.set.func`>,1
+kappalab,is.kadditive,0,0,2,class<`set.func`>,1
+kappalab,is.kadditive,1,0,0,double,1
+kappalab,is.kadditive,2,0,0,...,1
+kappalab,is.kadditive,-1,1,0,logical,1
+kappalab,is.kadditive,0,1,0,class<`Mobius.set.func`>,1
+kappalab,is.kadditive,1,1,0,double,1
+kappalab,is.kadditive,2,1,0,...,1
+kappalab,is.kadditive,-1,2,0,logical,1
+kappalab,is.kadditive,0,2,0,class<`set.func`>,1
+kappalab,is.kadditive,1,2,0,double,1
+kappalab,is.kadditive,2,2,0,...,1
+kappalab,is.kadditive,-1,3,0,logical,1
+kappalab,is.kadditive,0,3,0,class<`card.set.func`>,1
+kappalab,is.kadditive,1,3,0,double,1
+kappalab,is.kadditive,2,3,0,...,1
+kappalab,is.monotone,-1,0,0,logical,1
+kappalab,is.monotone,0,0,0,class<`game`>,1
+kappalab,is.monotone,1,0,0,...,1
+kappalab,is.monotone,-1,1,0,logical,1
+kappalab,is.monotone,0,1,0,class<`Mobius.capacity`>,1
+kappalab,is.monotone,1,1,0,...,1
+kappalab,is.monotone,-1,2,0,logical,1
+kappalab,is.monotone,0,2,0,class<`card.set.func`>,1
+kappalab,is.monotone,1,2,0,...,1
+kappalab,is.monotone,-1,3,0,logical,1
+kappalab,is.monotone,0,3,0,class<`set.func`>,1
+kappalab,is.monotone,1,3,0,...,1
+kappalab,is.monotone,-1,4,0,logical,1
+kappalab,is.monotone,0,4,0,class<`card.capacity`>,1
+kappalab,is.monotone,1,4,0,...,1
+kappalab,is.monotone,-1,5,0,logical,1
+kappalab,is.monotone,0,5,0,class<`Mobius.set.func`>,1
+kappalab,is.monotone,1,5,0,...,1
+kappalab,is.monotone,-1,6,0,logical,1
+kappalab,is.monotone,0,6,0,class<`capacity`>,1
+kappalab,is.monotone,1,6,0,...,1
+kappalab,is.monotone,-1,7,0,logical,1
+kappalab,is.monotone,0,7,0,class<`capacity`>,1
+kappalab,is.monotone,0,7,1,class<`card.capacity`>,1
+kappalab,is.monotone,0,7,2,class<`card.set.func`>,1
+kappalab,is.monotone,0,7,3,class<`game`>,1
+kappalab,is.monotone,0,7,4,class<`Mobius.capacity`>,1
+kappalab,is.monotone,0,7,5,class<`Mobius.set.func`>,1
+kappalab,is.monotone,0,7,6,class<`set.func`>,1
+kappalab,is.monotone,1,7,0,...,1
+kappalab,is.normalized,-1,0,0,logical,1
+kappalab,is.normalized,0,0,0,class<`Mobius.capacity`>,1
+kappalab,is.normalized,1,0,0,...,1
+kappalab,is.normalized,-1,1,0,logical,1
+kappalab,is.normalized,0,1,0,class<`capacity`>,1
+kappalab,is.normalized,1,1,0,...,1
+kappalab,is.normalized,-1,2,0,logical,1
+kappalab,is.normalized,0,2,0,class<`card.capacity`>,1
+kappalab,is.normalized,1,2,0,...,1
+kappalab,is.normalized,-1,3,0,logical,1
+kappalab,is.normalized,0,3,0,class<`capacity`>,1
+kappalab,is.normalized,0,3,1,class<`card.capacity`>,1
+kappalab,is.normalized,0,3,2,class<`Mobius.capacity`>,1
+kappalab,is.normalized,1,3,0,...,1
+kappalab,is.positive,-1,0,0,logical,1
+kappalab,is.positive,0,0,0,double[],1
+kappalab,k.truncate.Mobius,-1,0,0,class<`Mobius.set.func`>,1
+kappalab,k.truncate.Mobius,0,0,0,class<`Mobius.set.func`>,1
+kappalab,k.truncate.Mobius,0,0,1,class<`set.func`>,1
+kappalab,k.truncate.Mobius,1,0,0,double,1
+kappalab,k.truncate.Mobius,2,0,0,...,1
+kappalab,k.truncate.Mobius,-1,1,0,class<`Mobius.set.func`>,1
+kappalab,k.truncate.Mobius,0,1,0,class<`Mobius.set.func`>,1
+kappalab,k.truncate.Mobius,1,1,0,double,1
+kappalab,k.truncate.Mobius,2,1,0,...,1
+kappalab,k.truncate.Mobius,-1,2,0,class<`Mobius.set.func`>,1
+kappalab,k.truncate.Mobius,0,2,0,class<`set.func`>,1
+kappalab,k.truncate.Mobius,1,2,0,double,1
+kappalab,k.truncate.Mobius,2,2,0,...,1
+kappalab,k.truncate.Mobius.internal,-1,0,0,list<double[]>,1
+kappalab,k.truncate.Mobius.internal,0,0,0,class<`capacity`>,1
+kappalab,k.truncate.Mobius.internal,0,0,1,class<`game`>,1
+kappalab,k.truncate.Mobius.internal,0,0,2,class<`set.func`>,1
+kappalab,k.truncate.Mobius.internal,1,0,0,double,1
+kappalab,least.squares.capa.ident,-1,0,0,list<class<`Mobius.capacity`> | double[] | character>,1
+kappalab,least.squares.capa.ident,0,0,0,double,1
+kappalab,least.squares.capa.ident,1,0,0,double,1
+kappalab,least.squares.capa.ident,2,0,0,class<`matrix`>,1
+kappalab,least.squares.capa.ident,3,0,0,double[],1
+kappalab,least.squares.capa.ident,4,0,0,character,1
+kappalab,least.squares.capa.ident,5,0,0,class<`matrix`>,1
+kappalab,least.squares.capa.ident,5,0,1,null,1
+kappalab,least.squares.capa.ident,6,0,0,class<`matrix`>,1
+kappalab,least.squares.capa.ident,6,0,1,null,1
+kappalab,least.squares.capa.ident,7,0,0,class<`matrix`>,1
+kappalab,least.squares.capa.ident,7,0,1,null,1
+kappalab,least.squares.capa.ident,8,0,0,class<`matrix`>,1
+kappalab,least.squares.capa.ident,8,0,1,null,1
+kappalab,least.squares.capa.ident,9,0,0,double[],1
+kappalab,least.squares.capa.ident,9,0,1,null,1
+kappalab,least.squares.capa.ident,10,0,0,double,1
+kappalab,least.squares.capa.ident,11,0,0,double,1
+kappalab,least.squares.capa.ident,12,0,0,double,1
+kappalab,lin.prog.capa.ident,-1,0,0,list<class<`Mobius.capacity`> | double | class<`lp`>>,1
+kappalab,lin.prog.capa.ident,0,0,0,double,1
+kappalab,lin.prog.capa.ident,1,0,0,double,1
+kappalab,lin.prog.capa.ident,2,0,0,class<`matrix`>,1
+kappalab,lin.prog.capa.ident,3,0,0,class<`matrix`>,1
+kappalab,lin.prog.capa.ident,3,0,1,null,1
+kappalab,lin.prog.capa.ident,4,0,0,class<`matrix`>,1
+kappalab,lin.prog.capa.ident,4,0,1,null,1
+kappalab,lin.prog.capa.ident,5,0,0,class<`matrix`>,1
+kappalab,lin.prog.capa.ident,5,0,1,null,1
+kappalab,lin.prog.capa.ident,6,0,0,class<`matrix`>,1
+kappalab,lin.prog.capa.ident,6,0,1,null,1
+kappalab,lin.prog.capa.ident,7,0,0,null,1
+kappalab,lin.prog.capa.ident,8,0,0,double,1
+kappalab,lower.capacity,-1,0,0,class<`card.capacity`>,1
+kappalab,lower.capacity,0,0,0,double,1
+kappalab,ls.ranking.capa.ident,-1,0,0,list<any>,1
+kappalab,ls.ranking.capa.ident,0,0,0,double,1
+kappalab,ls.ranking.capa.ident,1,0,0,double,1
+kappalab,ls.ranking.capa.ident,2,0,0,class<`matrix`>,1
+kappalab,ls.ranking.capa.ident,3,0,0,class<`matrix`>,1
+kappalab,ls.ranking.capa.ident,4,0,0,double,1
+kappalab,ls.ranking.capa.ident,5,0,0,null,1
+kappalab,ls.ranking.capa.ident,6,0,0,null,1
+kappalab,ls.ranking.capa.ident,7,0,0,null,1
+kappalab,ls.ranking.capa.ident,8,0,0,null,1
+kappalab,ls.ranking.capa.ident,9,0,0,null,1
+kappalab,ls.ranking.capa.ident,10,0,0,double,1
+kappalab,ls.ranking.capa.ident,11,0,0,double,1
+kappalab,ls.ranking.capa.ident,12,0,0,double,1
+kappalab,ls.sorting.capa.ident,-1,0,0,list<class<`Mobius.capacity`> | double[] | character>,1
+kappalab,ls.sorting.capa.ident,0,0,0,double,1
+kappalab,ls.sorting.capa.ident,1,0,0,double,1
+kappalab,ls.sorting.capa.ident,2,0,0,class<`matrix`>,1
+kappalab,ls.sorting.capa.ident,3,0,0,double[],1
+kappalab,ls.sorting.capa.ident,4,0,0,double,1
+kappalab,ls.sorting.capa.ident,5,0,0,class<`matrix`>,1
+kappalab,ls.sorting.capa.ident,5,0,1,null,1
+kappalab,ls.sorting.capa.ident,6,0,0,class<`matrix`>,1
+kappalab,ls.sorting.capa.ident,6,0,1,null,1
+kappalab,ls.sorting.capa.ident,7,0,0,class<`matrix`>,1
+kappalab,ls.sorting.capa.ident,7,0,1,null,1
+kappalab,ls.sorting.capa.ident,8,0,0,class<`matrix`>,1
+kappalab,ls.sorting.capa.ident,8,0,1,null,1
+kappalab,ls.sorting.capa.ident,9,0,0,double[],1
+kappalab,ls.sorting.capa.ident,9,0,1,null,1
+kappalab,ls.sorting.capa.ident,10,0,0,double,1
+kappalab,ls.sorting.capa.ident,11,0,0,double,1
+kappalab,ls.sorting.capa.ident,12,0,0,double,1
+kappalab,ls.sorting.treatment,-1,0,0,list<class<`matrix`> | double[]>,1
+kappalab,ls.sorting.treatment,0,0,0,class<`matrix`>,1
+kappalab,ls.sorting.treatment,1,0,0,double[],1
+kappalab,ls.sorting.treatment,2,0,0,class<`Mobius.capacity`>,1
+kappalab,ls.sorting.treatment,3,0,0,class<`matrix`>,1
+kappalab,ls.sorting.treatment,4,0,0,double[],1
+kappalab,mini.dist.capa.ident,-1,0,0,list<class<`Mobius.capacity`> | double | integer[]>,1
+kappalab,mini.dist.capa.ident,0,0,0,class<`Mobius.capacity`>,1
+kappalab,mini.dist.capa.ident,1,0,0,double,1
+kappalab,mini.dist.capa.ident,2,0,0,character,1
+kappalab,mini.dist.capa.ident,3,0,0,class<`matrix`>,1
+kappalab,mini.dist.capa.ident,3,0,1,null,1
+kappalab,mini.dist.capa.ident,4,0,0,class<`matrix`>,1
+kappalab,mini.dist.capa.ident,4,0,1,null,1
+kappalab,mini.dist.capa.ident,5,0,0,class<`matrix`>,1
+kappalab,mini.dist.capa.ident,5,0,1,null,1
+kappalab,mini.dist.capa.ident,6,0,0,class<`matrix`>,1
+kappalab,mini.dist.capa.ident,6,0,1,null,1
+kappalab,mini.dist.capa.ident,7,0,0,class<`matrix`>,1
+kappalab,mini.dist.capa.ident,7,0,1,null,1
+kappalab,mini.dist.capa.ident,8,0,0,null,1
+kappalab,mini.dist.capa.ident,9,0,0,double,1
+kappalab,mini.var.capa.ident,-1,0,0,list<class<`Mobius.capacity`> | double | integer[]>,1
+kappalab,mini.var.capa.ident,0,0,0,double,1
+kappalab,mini.var.capa.ident,1,0,0,double,1
+kappalab,mini.var.capa.ident,2,0,0,class<`matrix`>,1
+kappalab,mini.var.capa.ident,3,0,0,class<`matrix`>,1
+kappalab,mini.var.capa.ident,3,0,1,null,1
+kappalab,mini.var.capa.ident,4,0,0,class<`matrix`>,1
+kappalab,mini.var.capa.ident,4,0,1,null,1
+kappalab,mini.var.capa.ident,5,0,0,class<`matrix`>,1
+kappalab,mini.var.capa.ident,5,0,1,null,1
+kappalab,mini.var.capa.ident,6,0,0,class<`matrix`>,1
+kappalab,mini.var.capa.ident,6,0,1,null,1
+kappalab,mini.var.capa.ident,7,0,0,null,1
+kappalab,mini.var.capa.ident,8,0,0,double,1
+kappalab,Mobius,-1,0,0,class<`Mobius.capacity`>,1
+kappalab,Mobius,-1,0,1,class<`Mobius.card.set.func`>,1
+kappalab,Mobius,-1,0,2,class<`Mobius.game`>,1
+kappalab,Mobius,-1,0,3,class<`Mobius.set.func`>,1
+kappalab,Mobius,0,0,0,class<`capacity`>,1
+kappalab,Mobius,0,0,1,class<`card.capacity`>,1
+kappalab,Mobius,0,0,2,class<`card.set.func`>,1
+kappalab,Mobius,0,0,3,class<`game`>,1
+kappalab,Mobius,0,0,4,class<`set.func`>,1
+kappalab,Mobius,1,0,0,...,1
+kappalab,Mobius,-1,1,0,class<`Mobius.set.func`>,1
+kappalab,Mobius,0,1,0,class<`set.func`>,1
+kappalab,Mobius,1,1,0,...,1
+kappalab,Mobius,-1,2,0,class<`Mobius.game`>,1
+kappalab,Mobius,0,2,0,class<`game`>,1
+kappalab,Mobius,1,2,0,...,1
+kappalab,Mobius,-1,3,0,class<`Mobius.capacity`>,1
+kappalab,Mobius,0,3,0,class<`capacity`>,1
+kappalab,Mobius,1,3,0,...,1
+kappalab,Mobius,-1,4,0,class<`Mobius.card.set.func`>,1
+kappalab,Mobius,0,4,0,class<`card.capacity`>,1
+kappalab,Mobius,1,4,0,...,1
+kappalab,Mobius,-1,5,0,class<`Mobius.card.set.func`>,1
+kappalab,Mobius,0,5,0,class<`card.set.func`>,1
+kappalab,Mobius,1,5,0,...,1
+kappalab,Mobius.capacity,-1,0,0,class<`Mobius.capacity`>,1
+kappalab,Mobius.capacity,0,0,0,double[],1
+kappalab,Mobius.capacity,1,0,0,double,1
+kappalab,Mobius.capacity,2,0,0,double,1
+kappalab,Mobius.card.set.func,-1,0,0,class<`Mobius.card.set.func`>,1
+kappalab,Mobius.card.set.func,0,0,0,double[],1
+kappalab,Mobius.game,-1,0,0,class<`Mobius.game`>,1
+kappalab,Mobius.game,0,0,0,double[],1
+kappalab,Mobius.game,1,0,0,double,1
+kappalab,Mobius.game,2,0,0,double,1
+kappalab,Mobius.set.func,-1,0,0,class<`Mobius.set.func`>,1
+kappalab,Mobius.set.func,0,0,0,double[],1
+kappalab,Mobius.set.func,1,0,0,double,1
+kappalab,Mobius.set.func,2,0,0,double,1
+kappalab,Mobius.set.func.internal,-1,0,0,list<double[]>,1
+kappalab,Mobius.set.func.internal,-1,0,1,list<integer[] | double>,1
+kappalab,Mobius.set.func.internal,0,0,0,double[],1
+kappalab,Mobius.set.func.internal,1,0,0,double,1
+kappalab,Mobius.set.func.internal,2,0,0,double,1
+kappalab,normalize,-1,0,0,class<`card.capacity`>,1
+kappalab,normalize,0,0,0,class<`card.capacity`>,1
+kappalab,normalize,1,0,0,...,1
+kappalab,normalize,-1,1,0,class<`Mobius.capacity`>,1
+kappalab,normalize,0,1,0,class<`Mobius.capacity`>,1
+kappalab,normalize,1,1,0,...,1
+kappalab,normalize,-1,2,0,class<`capacity`>,1
+kappalab,normalize,-1,2,1,class<`card.capacity`>,1
+kappalab,normalize,-1,2,2,class<`Mobius.capacity`>,1
+kappalab,normalize,0,2,0,class<`capacity`>,1
+kappalab,normalize,0,2,1,class<`card.capacity`>,1
+kappalab,normalize,0,2,2,class<`Mobius.capacity`>,1
+kappalab,normalize,1,2,0,...,1
+kappalab,normalize,-1,3,0,class<`capacity`>,1
+kappalab,normalize,0,3,0,class<`capacity`>,1
+kappalab,normalize,1,3,0,...,1
+kappalab,orness,-1,0,0,double,1
+kappalab,orness,0,0,0,class<`capacity`>,1
+kappalab,orness,0,0,1,class<`card.capacity`>,1
+kappalab,orness,0,0,2,class<`Mobius.capacity`>,1
+kappalab,orness,1,0,0,...,1
+kappalab,orness,-1,1,0,double,1
+kappalab,orness,0,1,0,class<`card.capacity`>,1
+kappalab,orness,1,1,0,...,1
+kappalab,orness,-1,2,0,double,1
+kappalab,orness,0,2,0,class<`capacity`>,1
+kappalab,orness,1,2,0,...,1
+kappalab,orness,-1,3,0,double,1
+kappalab,orness,0,3,0,class<`Mobius.capacity`>,1
+kappalab,orness,1,3,0,...,1
+kappalab,rnd,-1,0,0,class<`card.capacity`>,1
+kappalab,rnd,0,0,0,class<`card.capacity`>,1
+kappalab,rnd,1,0,0,double,1
+kappalab,rnd,-1,1,0,class<`set.func`>,1
+kappalab,rnd,0,1,0,class<`set.func`>,1
+kappalab,rnd,1,1,0,double,1
+kappalab,rnd,-1,2,0,class<`Mobius.capacity`>,1
+kappalab,rnd,0,2,0,class<`Mobius.capacity`>,1
+kappalab,rnd,1,2,0,double,1
+kappalab,rnd,-1,3,0,class<`capacity`>,1
+kappalab,rnd,-1,3,1,class<`card.capacity`>,1
+kappalab,rnd,-1,3,2,class<`Mobius.capacity`>,1
+kappalab,rnd,-1,3,3,class<`set.func`>,1
+kappalab,rnd,0,3,0,class<`capacity`>,1
+kappalab,rnd,0,3,1,class<`card.capacity`>,1
+kappalab,rnd,0,3,2,class<`Mobius.capacity`>,1
+kappalab,rnd,0,3,3,class<`set.func`>,1
+kappalab,rnd,1,3,0,double,1
+kappalab,rnd,-1,4,0,class<`capacity`>,1
+kappalab,rnd,0,4,0,class<`capacity`>,1
+kappalab,rnd,1,4,0,double,1
+kappalab,sd.Choquet.norm,-1,0,0,double,1
+kappalab,sd.Choquet.norm,0,0,0,class<`capacity`>,1
+kappalab,sd.Choquet.norm,1,0,0,...,1
+kappalab,sd.Choquet.norm,-1,1,0,double,1
+kappalab,sd.Choquet.norm,0,1,0,class<`capacity`>,1
+kappalab,sd.Choquet.norm,1,1,0,...,1
+kappalab,sd.Choquet.unif,-1,0,0,double,1
+kappalab,sd.Choquet.unif,0,0,0,class<`capacity`>,1
+kappalab,sd.Choquet.unif,1,0,0,...,1
+kappalab,sd.Choquet.unif,-1,1,0,double,1
+kappalab,sd.Choquet.unif,0,1,0,class<`capacity`>,1
+kappalab,sd.Choquet.unif,1,1,0,...,1
+kappalab,set.func,-1,0,0,class<`set.func`>,1
+kappalab,set.func,0,0,0,double[],1
+kappalab,set.func.internal,-1,0,0,list<double[]>,1
+kappalab,set.func.internal,0,0,0,double[],1
+kappalab,Shapley.interval.constraint,-1,0,0,list<double[]>,1
+kappalab,Shapley.interval.constraint,0,0,0,double,1
+kappalab,Shapley.interval.constraint,1,0,0,double,1
+kappalab,Shapley.interval.constraint,2,0,0,integer[],1
+kappalab,Shapley.interval.constraint,3,0,0,double,1
+kappalab,Shapley.interval.constraint,4,0,0,double,1
+kappalab,Shapley.interval.constraint,5,0,0,double,1
+kappalab,Shapley.preorder.constraint,-1,0,0,list<double[]>,1
+kappalab,Shapley.preorder.constraint,0,0,0,double,1
+kappalab,Shapley.preorder.constraint,1,0,0,double,1
+kappalab,Shapley.preorder.constraint,2,0,0,integer[],1
+kappalab,Shapley.preorder.constraint,3,0,0,double,1
+kappalab,Shapley.preorder.constraint,4,0,0,double,1
+kappalab,Shapley.preorder.constraint,5,0,0,double,1
+kappalab,Shapley.value,-1,0,0,double[],1
+kappalab,Shapley.value,0,0,0,class<`Mobius.capacity`>,1
+kappalab,Shapley.value,1,0,0,...,1
+kappalab,Shapley.value,-1,1,0,double,1
+kappalab,Shapley.value,0,1,0,class<`card.set.func`>,1
+kappalab,Shapley.value,1,1,0,...,1
+kappalab,Shapley.value,-1,2,0,double[],1
+kappalab,Shapley.value,0,2,0,class<`capacity`>,1
+kappalab,Shapley.value,1,2,0,...,1
+kappalab,Shapley.value,-1,3,0,double[],1
+kappalab,Shapley.value,0,3,0,class<`set.func`>,1
+kappalab,Shapley.value,1,3,0,...,1
+kappalab,Shapley.value,-1,4,0,double[],1
+kappalab,Shapley.value,0,4,0,class<`set.func`>,1
+kappalab,Shapley.value,0,4,1,class<`Mobius.capacity`>,1
+kappalab,Shapley.value,0,4,2,class<`Mobius.set.func`>,1
+kappalab,Shapley.value,0,4,3,class<`capacity`>,1
+kappalab,Shapley.value,0,4,4,class<`card.capacity`>,1
+kappalab,Shapley.value,0,4,5,class<`card.set.func`>,1
+kappalab,Shapley.value,1,4,0,...,1
+kappalab,Shapley.value,-1,5,0,double[],1
+kappalab,Shapley.value,0,5,0,class<`Mobius.set.func`>,1
+kappalab,Shapley.value,1,5,0,...,1
+kappalab,Shapley.value,-1,6,0,double,1
+kappalab,Shapley.value,0,6,0,class<`card.capacity`>,1
+kappalab,Shapley.value,1,6,0,...,1
+kappalab,Sipos.integral,-1,0,0,double,1
+kappalab,Sipos.integral,0,0,0,class<`Mobius.capacity`>,1
+kappalab,Sipos.integral,1,0,0,double[],1
+kappalab,Sipos.integral,2,0,0,...,1
+kappalab,Sipos.integral,-1,1,0,double,1
+kappalab,Sipos.integral,0,1,0,class<`game`>,1
+kappalab,Sipos.integral,1,1,0,double[],1
+kappalab,Sipos.integral,2,1,0,...,1
+kappalab,Sipos.integral,-1,2,0,double,1
+kappalab,Sipos.integral,0,2,0,class<`capacity`>,1
+kappalab,Sipos.integral,0,2,1,class<`card.capacity`>,1
+kappalab,Sipos.integral,0,2,2,class<`card.game`>,1
+kappalab,Sipos.integral,0,2,3,class<`game`>,1
+kappalab,Sipos.integral,0,2,4,class<`Mobius.capacity`>,1
+kappalab,Sipos.integral,0,2,5,class<`Mobius.game`>,1
+kappalab,Sipos.integral,1,2,0,double[],1
+kappalab,Sipos.integral,2,2,0,...,1
+kappalab,Sipos.integral,-1,3,0,double,1
+kappalab,Sipos.integral,0,3,0,class<`Mobius.game`>,1
+kappalab,Sipos.integral,1,3,0,double[],1
+kappalab,Sipos.integral,2,3,0,...,1
+kappalab,Sipos.integral,-1,4,0,double,1
+kappalab,Sipos.integral,0,4,0,class<`card.game`>,1
+kappalab,Sipos.integral,1,4,0,double[],1
+kappalab,Sipos.integral,2,4,0,...,1
+kappalab,Sipos.integral,-1,5,0,double,1
+kappalab,Sipos.integral,0,5,0,class<`card.capacity`>,1
+kappalab,Sipos.integral,1,5,0,double[],1
+kappalab,Sipos.integral,2,5,0,...,1
+kappalab,Sipos.integral,-1,6,0,double,1
+kappalab,Sipos.integral,0,6,0,class<`capacity`>,1
+kappalab,Sipos.integral,1,6,0,double[],1
+kappalab,Sipos.integral,2,6,0,...,1
+kappalab,Sugeno.integral,-1,0,0,double,1
+kappalab,Sugeno.integral,0,0,0,class<`Mobius.capacity`>,1
+kappalab,Sugeno.integral,1,0,0,double[],1
+kappalab,Sugeno.integral,2,0,0,...,1
+kappalab,Sugeno.integral,-1,1,0,double,1
+kappalab,Sugeno.integral,0,1,0,class<`capacity`>,1
+kappalab,Sugeno.integral,1,1,0,double[],1
+kappalab,Sugeno.integral,2,1,0,...,1
+kappalab,Sugeno.integral,-1,2,0,double,1
+kappalab,Sugeno.integral,0,2,0,class<`Mobius.game`>,1
+kappalab,Sugeno.integral,1,2,0,double[],1
+kappalab,Sugeno.integral,2,2,0,...,1
+kappalab,Sugeno.integral,-1,3,0,double,1
+kappalab,Sugeno.integral,0,3,0,class<`game`>,1
+kappalab,Sugeno.integral,1,3,0,double[],1
+kappalab,Sugeno.integral,2,3,0,...,1
+kappalab,Sugeno.integral,-1,4,0,double,1
+kappalab,Sugeno.integral,0,4,0,class<`capacity`>,1
+kappalab,Sugeno.integral,0,4,1,class<`card.capacity`>,1
+kappalab,Sugeno.integral,0,4,2,class<`card.game`>,1
+kappalab,Sugeno.integral,0,4,3,class<`game`>,1
+kappalab,Sugeno.integral,0,4,4,class<`Mobius.capacity`>,1
+kappalab,Sugeno.integral,0,4,5,class<`Mobius.game`>,1
+kappalab,Sugeno.integral,1,4,0,double[],1
+kappalab,Sugeno.integral,2,4,0,...,1
+kappalab,Sugeno.integral,-1,5,0,double,1
+kappalab,Sugeno.integral,0,5,0,class<`card.game`>,1
+kappalab,Sugeno.integral,1,5,0,double[],1
+kappalab,Sugeno.integral,2,5,0,...,1
+kappalab,Sugeno.integral,-1,6,0,double,1
+kappalab,Sugeno.integral,0,6,0,class<`card.capacity`>,1
+kappalab,Sugeno.integral,1,6,0,double[],1
+kappalab,Sugeno.integral,2,6,0,...,1
+kappalab,summary,-1,0,0,class<`summary.superclass.set.func`>,1
+kappalab,summary,0,0,0,class<`Mobius.set.func`>,1
+kappalab,summary,1,0,0,...,1
+kappalab,summary,-1,1,0,class<`summary.superclass.capacity`>,1
+kappalab,summary,0,1,0,class<`card.capacity`>,1
+kappalab,summary,1,1,0,...,1
+kappalab,summary,-1,2,0,class<`summary.superclass.capacity`>,1
+kappalab,summary,0,2,0,class<`Mobius.capacity`>,1
+kappalab,summary,1,2,0,...,1
+kappalab,summary,-1,3,0,class<`summary.superclass.capacity`>,1
+kappalab,summary,0,3,0,class<`capacity`>,1
+kappalab,summary,1,3,0,...,1
+kappalab,summary,-1,4,0,class<`summary.superclass.set.func`>,1
+kappalab,summary,0,4,0,class<`card.set.func`>,1
+kappalab,summary,1,4,0,...,1
+kappalab,summary,-1,5,0,class<`summary.superclass.set.func`>,1
+kappalab,summary,0,5,0,class<`set.func`>,1
+kappalab,summary,1,5,0,...,1
+kappalab,to.data.frame,-1,0,0,class<`data.frame`>,1
+kappalab,to.data.frame,0,0,0,class<`card.capacity`>,1
+kappalab,to.data.frame,1,0,0,...,1
+kappalab,to.data.frame,-1,1,0,class<`data.frame`>,1
+kappalab,to.data.frame,0,1,0,class<`set.func`>,1
+kappalab,to.data.frame,1,1,0,...,1
+kappalab,to.data.frame,-1,2,0,class<`data.frame`>,1
+kappalab,to.data.frame,0,2,0,class<`Mobius.set.func`>,1
+kappalab,to.data.frame,1,2,0,...,1
+kappalab,to.data.frame,-1,3,0,class<`data.frame`>,1
+kappalab,to.data.frame,0,3,0,class<`Mobius.set.func`>,1
+kappalab,to.data.frame,0,3,1,class<`set.func`>,1
+kappalab,to.data.frame,0,3,2,class<`card.capacity`>,1
+kappalab,to.data.frame,0,3,3,class<`card.set.func`>,1
+kappalab,to.data.frame,1,3,0,...,1
+kappalab,to.data.frame,-1,4,0,class<`data.frame`>,1
+kappalab,to.data.frame,0,4,0,class<`card.set.func`>,1
+kappalab,to.data.frame,1,4,0,...,1
+kappalab,uniform.capacity,-1,0,0,class<`card.capacity`>,1
+kappalab,uniform.capacity,0,0,0,double,1
+kappalab,upper.capacity,-1,0,0,class<`card.capacity`>,1
+kappalab,upper.capacity,0,0,0,double,1
+kappalab,variance,-1,0,0,double,1
+kappalab,variance,0,0,0,class<`capacity`>,1
+kappalab,variance,1,0,0,...,1
+kappalab,variance,-1,1,0,double,1
+kappalab,variance,0,1,0,class<`Mobius.capacity`>,1
+kappalab,variance,1,1,0,...,1
+kappalab,variance,-1,2,0,double,1
+kappalab,variance,0,2,0,class<`card.capacity`>,1
+kappalab,variance,1,2,0,...,1
+kappalab,variance,-1,3,0,double,1
+kappalab,variance,0,3,0,class<`capacity`>,1
+kappalab,variance,0,3,1,class<`card.capacity`>,1
+kappalab,variance,0,3,2,class<`Mobius.capacity`>,1
+kappalab,variance,1,3,0,...,1
+kappalab,veto,-1,0,0,double[],1
+kappalab,veto,0,0,0,class<`Mobius.capacity`>,1
+kappalab,veto,1,0,0,...,1
+kappalab,veto,-1,1,0,double[],1
+kappalab,veto,0,1,0,class<`capacity`>,1
+kappalab,veto,0,1,1,class<`Mobius.capacity`>,1
+kappalab,veto,0,1,2,class<`card.capacity`>,1
+kappalab,veto,1,1,0,...,1
+kappalab,veto,-1,2,0,double[],1
+kappalab,veto,0,2,0,class<`capacity`>,1
+kappalab,veto,1,2,0,...,1
+kappalab,veto,-1,3,0,double,1
+kappalab,veto,0,3,0,class<`card.capacity`>,1
+kappalab,veto,1,3,0,...,1
+kappalab,zeta,-1,0,0,class<`game`>,1
+kappalab,zeta,0,0,0,class<`Mobius.game`>,1
+kappalab,zeta,1,0,0,...,1
+kappalab,zeta,-1,1,0,class<`card.set.func`>,1
+kappalab,zeta,0,1,0,class<`Mobius.card.set.func`>,1
+kappalab,zeta,1,1,0,...,1
+kappalab,zeta,-1,2,0,class<`capacity`>,1
+kappalab,zeta,0,2,0,class<`Mobius.capacity`>,1
+kappalab,zeta,1,2,0,...,1
+kappalab,zeta,-1,3,0,class<`capacity`>,1
+kappalab,zeta,-1,3,1,class<`card.set.func`>,1
+kappalab,zeta,-1,3,2,class<`game`>,1
+kappalab,zeta,-1,3,3,class<`set.func`>,1
+kappalab,zeta,0,3,0,class<`Mobius.capacity`>,1
+kappalab,zeta,0,3,1,class<`Mobius.card.set.func`>,1
+kappalab,zeta,0,3,2,class<`Mobius.game`>,1
+kappalab,zeta,0,3,3,class<`Mobius.set.func`>,1
+kappalab,zeta,1,3,0,...,1
+kappalab,zeta,-1,4,0,class<`set.func`>,1
+kappalab,zeta,0,4,0,class<`Mobius.set.func`>,1
+kappalab,zeta,1,4,0,...,1
+kappalab,zeta.internal,-1,0,0,list<double[]>,1
+kappalab,zeta.internal,0,0,0,class<`Mobius.capacity`>,1
+kappalab,zeta.internal,0,0,1,class<`Mobius.game`>,1
+kappalab,zeta.internal,0,0,2,class<`Mobius.set.func`>,1
+kinship2,alignped1,-1,0,0,list<double[] | class<`matrix`>>,1
+kinship2,alignped1,-1,0,1,list<class<`matrix`> | double[]>,1
+kinship2,alignped1,0,0,0,double,1
+kinship2,alignped1,1,0,0,any,1
+kinship2,alignped1,2,0,0,any,1
+kinship2,alignped1,3,0,0,double[],1
+kinship2,alignped1,4,0,0,any,1
+kinship2,alignped1,5,0,0,any,1
+kinship2,alignped1,6,0,0,class<`matrix`>,1
+kinship2,alignped2,-1,0,0,list<double[] | class<`matrix`>>,1
+kinship2,alignped2,-1,0,1,list<class<`matrix`> | double[]>,1
+kinship2,alignped2,0,0,0,integer[],1
+kinship2,alignped2,1,0,0,any,1
+kinship2,alignped2,2,0,0,any,1
+kinship2,alignped2,3,0,0,double[],1
+kinship2,alignped2,4,0,0,double[],1
+kinship2,alignped2,5,0,0,any,1
+kinship2,alignped2,6,0,0,class<`matrix`>,1
+kinship2,alignped3,-1,0,0,list<double[] | class<`matrix`>>,1
+kinship2,alignped3,0,0,0,list<double[] | class<`matrix`>>,1
+kinship2,alignped3,0,0,1,list<class<`matrix`> | double[]>,1
+kinship2,alignped3,1,0,0,list<double[] | class<`matrix`>>,1
+kinship2,alignped3,1,0,1,list<class<`matrix`> | double[]>,1
+kinship2,alignped3,2,0,0,logical,1
+kinship2,alignped3,3,0,0,double,1
+kinship2,alignped4,-1,0,0,class<`matrix`>,1
+kinship2,alignped4,0,0,0,list<double[] | class<`matrix`>>,1
+kinship2,alignped4,1,0,0,class<`matrix`>,1
+kinship2,alignped4,2,0,0,any,1
+kinship2,alignped4,3,0,0,double,1
+kinship2,alignped4,4,0,0,double[],1
+kinship2,align.pedigree,-1,0,0,list<double[] | class<`matrix`>>,1
+kinship2,align.pedigree,0,0,0,class<`pedigree`>,1
+kinship2,align.pedigree,1,0,0,logical,1
+kinship2,align.pedigree,2,0,0,double,1
+kinship2,align.pedigree,3,0,0,double[],1
+kinship2,align.pedigree,4,0,0,null,1
+kinship2,align.pedigree,4,0,1,list<double[] | class<`matrix`>>,1
+kinship2,align.pedigree,4,0,2,list<double[] | null>,1
+kinship2,align.pedigree,4,0,3,list<integer[] | null>,1
+kinship2,as.data.frame.pedigree,-1,0,0,class<`data.frame`>,1
+kinship2,as.data.frame.pedigree,0,0,0,class<`pedigree`>,1
+kinship2,as.data.frame.pedigree,1,0,0,...,1
+kinship2,autohint,-1,0,0,list<double[] | class<`matrix`>>,1
+kinship2,autohint,-1,0,1,list<integer[] | null>,1
+kinship2,autohint,0,0,0,class<`pedigree`>,1
+kinship2,autohint,1,0,0,any,1
+kinship2,autohint,2,0,0,logical,1
+kinship2,autohint,3,0,0,logical,1
+kinship2,bitSize,-1,0,0,list<double>,1
+kinship2,bitSize,0,0,0,class<`pedigree`>,1
+kinship2,check.hint,-1,0,0,list<double[] | class<`matrix`>>,1
+kinship2,check.hint,-1,0,1,list<double[] | null>,1
+kinship2,check.hint,-1,0,2,list<integer[] | null>,1
+kinship2,check.hint,0,0,0,list<double[] | class<`matrix`>>,1
+kinship2,check.hint,0,0,1,list<double[] | null>,1
+kinship2,check.hint,0,0,2,list<integer[] | null>,1
+kinship2,check.hint,1,0,0,class<`factor`>,1
+kinship2,excludeStrayMarryin,-1,0,0,class<`data.frame`>,1
+kinship2,excludeStrayMarryin,0,0,0,character[],1
+kinship2,excludeStrayMarryin,0,0,1,integer[],1
+kinship2,excludeStrayMarryin,1,0,0,double[],1
+kinship2,excludeStrayMarryin,2,0,0,double[],1
+kinship2,excludeUnavailFounders,-1,0,0,list<character[] | double[]>,1
+kinship2,excludeUnavailFounders,-1,0,1,list<character[] | double>,1
+kinship2,excludeUnavailFounders,-1,0,2,list<null | character[] | integer[]>,1
+kinship2,excludeUnavailFounders,-1,0,3,list<null | integer[]>,1
+kinship2,excludeUnavailFounders,0,0,0,character[],1
+kinship2,excludeUnavailFounders,0,0,1,integer[],1
+kinship2,excludeUnavailFounders,1,0,0,integer[],1
+kinship2,excludeUnavailFounders,2,0,0,integer[],1
+kinship2,excludeUnavailFounders,3,0,0,any,1
+kinship2,familycheck,-1,0,0,any,1
+kinship2,familycheck,0,0,0,double[],1
+kinship2,familycheck,1,0,0,integer[],1
+kinship2,familycheck,2,0,0,double[],1
+kinship2,familycheck,3,0,0,integer[],1
+kinship2,familycheck,4,0,0,any,1
+kinship2,findAvailAffected,-1,0,0,list<any>,1
+kinship2,findAvailAffected,0,0,0,class<`pedigree`>,1
+kinship2,findAvailAffected,1,0,0,integer[],1
+kinship2,findAvailAffected,2,0,0,null,1
+kinship2,findAvailAffected,2,0,1,double,1
+kinship2,findAvailNonInform,-1,0,0,character[],1
+kinship2,findAvailNonInform,-1,0,1,integer[],1
+kinship2,findAvailNonInform,0,0,0,class<`pedigree`>,1
+kinship2,findAvailNonInform,1,0,0,double[],1
+kinship2,findUnavailable,-1,0,0,character[],1
+kinship2,findUnavailable,-1,0,1,integer[],1
+kinship2,findUnavailable,0,0,0,class<`pedigree`>,1
+kinship2,findUnavailable,1,0,0,double[],1
+kinship2,fixParents,-1,0,0,class<`data.frame`>,1
+kinship2,fixParents,0,0,0,class<`factor`>,1
+kinship2,fixParents,0,0,1,integer[],1
+kinship2,fixParents,1,0,0,class<`factor`>,1
+kinship2,fixParents,1,0,1,double[],1
+kinship2,fixParents,2,0,0,class<`factor`>,1
+kinship2,fixParents,2,0,1,double[],1
+kinship2,fixParents,3,0,0,class<`factor`>,1
+kinship2,fixParents,3,0,1,double[],1
+kinship2,fixParents,4,0,0,character,1
+kinship2,fixParents,4,0,1,double,1
+kinship2,is.founder,-1,0,0,logical[],1
+kinship2,is.founder,0,0,0,double[],1
+kinship2,is.founder,1,0,0,double[],1
+kinship2,is.parent,-1,0,0,logical[],1
+kinship2,is.parent,0,0,0,character[],1
+kinship2,is.parent,0,0,1,integer[],1
+kinship2,is.parent,1,0,0,double[],1
+kinship2,is.parent,2,0,0,double[],1
+kinship2,kindepth,-1,0,0,any,1
+kinship2,kindepth,0,0,0,class<`pedigree`>,1
+kinship2,kindepth,0,0,1,integer[],1
+kinship2,kindepth,1,0,0,any,1
+kinship2,kindepth,2,0,0,any,1
+kinship2,kindepth,3,0,0,logical,1
+kinship2,kinship,-1,0,0,class<`dsCMatrix`>,1
+kinship2,kinship,-1,0,1,class<`matrix`>,1
+kinship2,kinship,0,0,0,class<`pedigreeList`>,1
+kinship2,kinship,0,0,1,class<`pedigree`>,1
+kinship2,kinship,1,0,0,...,1
+kinship2,kinship.pedigree,-1,0,0,class<`matrix`>,1
+kinship2,kinship.pedigree,0,0,0,class<`pedigree`>,1
+kinship2,kinship.pedigree,1,0,0,character,1
+kinship2,kinship.pedigree,2,0,0,...,1
+kinship2,kinship.pedigreeList,-1,0,0,class<`dsCMatrix`>,1
+kinship2,kinship.pedigreeList,0,0,0,class<`pedigreeList`>,1
+kinship2,kinship.pedigreeList,1,0,0,character,1
+kinship2,kinship.pedigreeList,2,0,0,...,1
+kinship2,legendPlot,-1,0,0,list<logical>,1
+kinship2,legendPlot,0,0,0,class<`pedigree`>,1
+kinship2,legendPlot,1,0,0,integer[],1
+kinship2,legendPlot,2,0,0,class<`matrix`>,1
+kinship2,legendPlot,3,0,0,character[],1
+kinship2,legendPlot,3,0,1,null,1
+kinship2,legendPlot,4,0,0,double[],1
+kinship2,legendPlot,5,0,0,character[],1
+kinship2,legendPlot,5,0,1,null,1
+kinship2,legendPlot,6,0,0,double,1
+kinship2,legendPlot,7,0,0,...,1
+kinship2,makefamid,-1,0,0,any,1
+kinship2,makefamid,0,0,0,integer[],1
+kinship2,makefamid,1,0,0,double[],1
+kinship2,makefamid,2,0,0,double[],1
+kinship2,pedigree,-1,0,0,class<`pedigree`>,1
+kinship2,pedigree,-1,0,1,class<`pedigreeList`>,1
+kinship2,pedigree,0,0,0,character[],1
+kinship2,pedigree,0,0,1,class<`factor`>,1
+kinship2,pedigree,0,0,2,double[],1
+kinship2,pedigree,1,0,0,character[],1
+kinship2,pedigree,1,0,1,class<`factor`>,1
+kinship2,pedigree,1,0,2,^double[],1
+kinship2,pedigree,2,0,0,character[],1
+kinship2,pedigree,2,0,1,class<`factor`>,1
+kinship2,pedigree,2,0,2,^double[],1
+kinship2,pedigree,3,0,0,class<`factor`>,1
+kinship2,pedigree,3,0,1,double[],1
+kinship2,pedigree,3,0,2,^character[],1
+kinship2,pedigree,4,0,0,any,1
+kinship2,pedigree,5,0,0,any,1
+kinship2,pedigree,6,0,0,any,1
+kinship2,pedigree,7,0,0,any,1
+kinship2,pedigree,8,0,0,any,1
+kinship2,[.pedigree,-1,0,0,class<`pedigree`>,1
+kinship2,[.pedigree,0,0,0,class<`pedigree`>,1
+kinship2,[.pedigree,1,0,0,...,1
+kinship2,[.pedigree,2,0,0,any,1
+kinship2,pedigree.legend,-1,0,0,null,1
+kinship2,pedigree.legend,0,0,0,class<`pedigree`>,1
+kinship2,pedigree.legend,1,0,0,character[],1
+kinship2,pedigree.legend,2,0,0,double,1
+kinship2,pedigree.legend,3,0,0,double,1
+kinship2,pedigree.legend,3,0,1,null,1
+kinship2,pedigree.legend,4,0,0,character,1
+kinship2,pedigree.legend,5,0,0,logical,1
+kinship2,pedigree.legend,6,0,0,double[],1
+kinship2,pedigree.legend,7,0,0,double[],1
+kinship2,pedigree.legend,8,0,0,...,1
+kinship2,[.pedigreeList,-1,0,0,class<`pedigree`>,1
+kinship2,[.pedigreeList,0,0,0,class<`pedigreeList`>,1
+kinship2,[.pedigreeList,1,0,0,...,1
+kinship2,[.pedigreeList,2,0,0,any,1
+kinship2,pedigree.shrink,-1,0,0,class<`pedigree.shrink`>,1
+kinship2,pedigree.shrink,0,0,0,class<`pedigree`>,1
+kinship2,pedigree.shrink,1,0,0,double[],1
+kinship2,pedigree.shrink,2,0,0,null,1
+kinship2,pedigree.shrink,3,0,0,null,1
+kinship2,pedigree.shrink,4,0,0,double,1
+kinship2,pedigree.trim,-1,0,0,class<`pedigree`>,1
+kinship2,pedigree.trim,0,0,0,character[],1
+kinship2,pedigree.trim,0,0,1,double[],1
+kinship2,pedigree.trim,1,0,0,class<`pedigree`>,1
+kinship2,pedigree.unrelated,-1,0,0,character[],1
+kinship2,pedigree.unrelated,0,0,0,class<`pedigree`>,1
+kinship2,pedigree.unrelated,1,0,0,integer[],1
+kinship2,plot.pedigree,-1,0,0,list<double[] | class<`call`> | list<double[] | class<`matrix`>>>,1
+kinship2,plot.pedigree,-1,0,1,list<^double[] | class<`call`> | list<double[] | class<`matrix`>>>,1
+kinship2,plot.pedigree,0,0,0,class<`pedigree`>,1
+kinship2,plot.pedigree,1,0,0,character[],1
+kinship2,plot.pedigree,1,0,1,integer[],1
+kinship2,plot.pedigree,2,0,0,double[],1
+kinship2,plot.pedigree,2,0,1,null,1
+kinship2,plot.pedigree,3,0,0,class<`matrix`>,1
+kinship2,plot.pedigree,3,0,1,^integer[],1
+kinship2,plot.pedigree,3,0,2,null,1
+kinship2,plot.pedigree,4,0,0,double,1
+kinship2,plot.pedigree,5,0,0,double[],1
+kinship2,plot.pedigree,5,0,1,character[],1
+kinship2,plot.pedigree,6,0,0,double,1
+kinship2,plot.pedigree,7,0,0,double,1
+kinship2,plot.pedigree,8,0,0,logical,1
+kinship2,plot.pedigree,9,0,0,double[],1
+kinship2,plot.pedigree,10,0,0,double,1
+kinship2,plot.pedigree,11,0,0,any,1
+kinship2,plot.pedigree,12,0,0,double[],1
+kinship2,plot.pedigree,13,0,0,any,1
+kinship2,plot.pedigree,14,0,0,logical,1
+kinship2,plot.pedigree,15,0,0,any,1
+kinship2,printBanner,-1,0,0,null,1
+kinship2,printBanner,0,0,0,character,1
+kinship2,printBanner,1,0,0,double,1
+kinship2,printBanner,2,0,0,double,1
+kinship2,printBanner,3,0,0,character,1
+kinship2,print.pedigree,-1,0,0,null,1
+kinship2,print.pedigree,0,0,0,class<`pedigree`>,1
+kinship2,print.pedigree,1,0,0,...,1
+kinship2,print.pedigreeList,-1,0,0,null,1
+kinship2,print.pedigreeList,0,0,0,class<`pedigreeList`>,1
+kinship2,print.pedigreeList,1,0,0,...,1
+kinship2,print.pedigree.shrink,-1,0,0,null,1
+kinship2,print.pedigree.shrink,0,0,0,class<`pedigree.shrink`>,1
+kinship2,print.pedigree.shrink,1,0,0,...,1
+kohonen,add.cluster.boundaries,-1,0,0,null,1
+kohonen,add.cluster.boundaries,0,0,0,class<`kohonen`>,1
+kohonen,add.cluster.boundaries,1,0,0,integer[],1
+kohonen,add.cluster.boundaries,2,0,0,double,1
+kohonen,add.cluster.boundaries,3,0,0,...,1
+kohonen,check.data,-1,0,0,list<class<`matrix`>>,1
+kohonen,check.data,0,0,0,list<class<`matrix`> | class<`factor`>>,1
+kohonen,check.data,0,0,1,list<class<`matrix`>>,1
+kohonen,check.data,0,0,2,class<`matrix`>,1
+kohonen,check.data.na,-1,0,0,integer[],1
+kohonen,check.data.na,-1,0,1,null,1
+kohonen,check.data.na,0,0,0,list<any>,1
+kohonen,check.data.na,1,0,0,any,1
+kohonen,checkListVariables,-1,0,0,logical,1
+kohonen,checkListVariables,0,0,0,list<any>,1
+kohonen,checkListVariables,1,0,0,integer[],1
+kohonen,checkListVariables,1,0,1,list<integer>,1
+kohonen,check.somgrid,-1,0,0,class<`somgrid`>,1
+kohonen,check.somgrid,0,0,0,class<`somgrid`>,1
+kohonen,check.whatmap,-1,0,0,double,1
+kohonen,check.whatmap,-1,0,1,integer[],1
+kohonen,check.whatmap,0,0,0,class<`kohonen`>,1
+kohonen,check.whatmap,0,0,1,list<class<`matrix`>>,1
+kohonen,check.whatmap,0,0,2,list<double | class<`somgrid`> | class<`matrix`>>,1
+kohonen,check.whatmap,1,0,0,double,1
+kohonen,check.whatmap,1,0,1,null,1
+kohonen,check.whatmap,1,0,2,character[],1
+kohonen,check.whatmap,1,0,3,integer[],1
+kohonen,classmat2classvec,-1,0,0,class<`factor`>,1
+kohonen,classmat2classvec,0,0,0,class<`matrix`>,1
+kohonen,classmat2classvec,1,0,0,double,1
+kohonen,classvec2classmat,-1,0,0,class<`matrix`>,1
+kohonen,classvec2classmat,0,0,0,class<`factor`>,1
+kohonen,classvec2classmat,0,0,1,double[],1
+kohonen,CreateStdDistancePointers,-1,0,0,expression,1
+kohonen,CreateStdDistancePointers,0,0,0,class<`factor`>,1
+kohonen,CreateStdDistancePointers,1,0,0,logical,1
+kohonen,expandMap,-1,0,0,class<`kohonen`>,1
+kohonen,expandMap,0,0,0,class<`kohonen`>,1
+kohonen,getCodes,-1,0,0,class<`matrix`>,1
+kohonen,getCodes,-1,0,1,list<class<`matrix`>>,1
+kohonen,getCodes,-1,0,2,list<null | class<`matrix`>>,1
+kohonen,getCodes,0,0,0,class<`kohonen`>,1
+kohonen,getCodes,1,0,0,double,1
+kohonen,getCodes,1,0,1,integer[],1
+kohonen,getDistancePointers,-1,0,0,list<externalptr>,1
+kohonen,getDistancePointers,0,0,0,character[],1
+kohonen,getDistancePointers,1,0,0,character[],1
+kohonen,getDistancePointers,2,0,0,double,1
+kohonen,getnNA,-1,0,0,class<`matrix`>,1
+kohonen,getnNA,0,0,0,list<class<`matrix`>>,1
+kohonen,getnNA,1,0,0,double,1
+kohonen,getnNA,2,0,0,any,1
+kohonen,Hexagon,-1,0,0,null,1
+kohonen,Hexagon,0,0,0,double,1
+kohonen,Hexagon,1,0,0,double,1
+kohonen,Hexagon,2,0,0,double,1
+kohonen,Hexagon,3,0,0,character,1
+kohonen,Hexagon,4,0,0,character,1
+kohonen,Hexagon,4,0,1,null,1
+kohonen,hexagons,-1,0,0,null,1
+kohonen,hexagons,0,0,0,double[],1
+kohonen,hexagons,1,0,0,double[],1
+kohonen,hexagons,2,0,0,double,1
+kohonen,hexagons,3,0,0,character[],1
+kohonen,hexagons,4,0,0,character,1
+kohonen,hexagons,4,0,1,null,1
+kohonen,is.factor.matrix,-1,0,0,logical,1
+kohonen,is.factor.matrix,0,0,0,class<`matrix`>,1
+kohonen,is.factor.matrix,1,0,0,double,1
+kohonen,is.factor.matrix,2,0,0,double,1
+kohonen,map,-1,0,0,list<double[]>,1
+kohonen,map,0,0,0,class<`kohonen`>,1
+kohonen,map,1,0,0,...,1
+kohonen,map.kohonen,-1,0,0,list<double[]>,1
+kohonen,map.kohonen,0,0,0,class<`kohonen`>,1
+kohonen,map.kohonen,1,0,0,any,1
+kohonen,map.kohonen,2,0,0,integer[],1
+kohonen,map.kohonen,2,0,1,double,1
+kohonen,map.kohonen,2,0,2,character[],1
+kohonen,map.kohonen,2,0,3,null,1
+kohonen,map.kohonen,3,0,0,double[],1
+kohonen,map.kohonen,3,0,1,null,1
+kohonen,map.kohonen,4,0,0,double,1
+kohonen,map.kohonen,5,0,0,...,1
+kohonen,object.distances,-1,0,0,class<`dist`>,1
+kohonen,object.distances,0,0,0,class<`kohonen`>,1
+kohonen,object.distances,0,0,1,list<double | character | list<class<`matrix`>>>,1
+kohonen,object.distances,1,0,0,character,1
+kohonen,object.distances,2,0,0,any,1
+kohonen,ObjectDistances,-1,0,0,double[],1
+kohonen,ObjectDistances,0,0,0,class<`matrix`>,1
+kohonen,ObjectDistances,1,0,0,integer[],1
+kohonen,ObjectDistances,2,0,0,class<`matrix`>,1
+kohonen,ObjectDistances,3,0,0,list<externalptr>,1
+kohonen,ObjectDistances,4,0,0,double[],1
+kohonen,plot.heatkey,-1,0,0,null,1
+kohonen,plot.heatkey,0,0,0,class<`kohonen`>,1
+kohonen,plot.heatkey,1,0,0,any,1
+kohonen,plot.heatkey,2,0,0,character[],1
+kohonen,plot.heatkey,3,0,0,character[],1
+kohonen,plot.heatkey,3,0,1,null,1
+kohonen,plot.heatkey,4,0,0,logical,1
+kohonen,plot.heatkey,5,0,0,double,1
+kohonen,plot.heatkey,6,0,0,...,1
+kohonen,plot.kohchanges,-1,0,0,null,1
+kohonen,plot.kohchanges,0,0,0,class<`kohonen`>,1
+kohonen,plot.kohchanges,1,0,0,null,1
+kohonen,plot.kohchanges,2,0,0,any,1
+kohonen,plot.kohchanges,3,0,0,...,1
+kohonen,plot.kohcodes,-1,0,0,null,1
+kohonen,plot.kohcodes,0,0,0,class<`kohonen`>,1
+kohonen,plot.kohcodes,0,0,1,list<double | class<`somgrid`> | class<`matrix`>>,1
+kohonen,plot.kohcodes,1,0,0,null,1
+kohonen,plot.kohcodes,2,0,0,character[],1
+kohonen,plot.kohcodes,3,0,0,null,1
+kohonen,plot.kohcodes,3,0,1,class<`function`>,1
+kohonen,plot.kohcodes,4,0,0,null,1
+kohonen,plot.kohcodes,5,0,0,null,1
+kohonen,plot.kohcodes,6,0,0,logical,1
+kohonen,plot.kohcodes,7,0,0,character[],1
+kohonen,plot.kohcodes,8,0,0,character,1
+kohonen,plot.kohcodes,9,0,0,...,1
+kohonen,plot.kohcounts,-1,0,0,^integer[],1
+kohonen,plot.kohcounts,0,0,0,class<`kohonen`>,1
+kohonen,plot.kohcounts,1,0,0,null,1
+kohonen,plot.kohcounts,2,0,0,character,1
+kohonen,plot.kohcounts,2,0,1,null,1
+kohonen,plot.kohcounts,3,0,0,null,1
+kohonen,plot.kohcounts,4,0,0,any,1
+kohonen,plot.kohcounts,5,0,0,null,1
+kohonen,plot.kohcounts,6,0,0,logical,1
+kohonen,plot.kohcounts,7,0,0,logical,1
+kohonen,plot.kohcounts,8,0,0,double,1
+kohonen,plot.kohcounts,9,0,0,character[],1
+kohonen,plot.kohcounts,10,0,0,character,1
+kohonen,plot.kohcounts,11,0,0,any,1
+kohonen,plot.kohcounts,12,0,0,...,1
+kohonen,plot.kohmapping,-1,0,0,null,1
+kohonen,plot.kohmapping,0,0,0,class<`kohonen`>,1
+kohonen,plot.kohmapping,1,0,0,null,1
+kohonen,plot.kohmapping,2,0,0,character,1
+kohonen,plot.kohmapping,2,0,1,null,1
+kohonen,plot.kohmapping,3,0,0,integer[],1
+kohonen,plot.kohmapping,3,0,1,null,1
+kohonen,plot.kohmapping,4,0,0,null,1
+kohonen,plot.kohmapping,4,0,1,integer[],1
+kohonen,plot.kohmapping,5,0,0,null,1
+kohonen,plot.kohmapping,5,0,1,character[],1
+kohonen,plot.kohmapping,6,0,0,logical,1
+kohonen,plot.kohmapping,7,0,0,character[],1
+kohonen,plot.kohmapping,8,0,0,character,1
+kohonen,plot.kohmapping,8,0,1,null,1
+kohonen,plot.kohmapping,9,0,0,...,1
+kohonen,plot.kohonen,-1,0,0,^double[],1
+kohonen,plot.kohonen,-1,0,1,null,1
+kohonen,plot.kohonen,0,0,0,class<`kohonen`>,1
+kohonen,plot.kohonen,1,0,0,character,1
+kohonen,plot.kohonen,2,0,0,null,1
+kohonen,plot.kohonen,3,0,0,null,1
+kohonen,plot.kohonen,4,0,0,null,1
+kohonen,plot.kohonen,4,0,1,integer[],1
+kohonen,plot.kohonen,5,0,0,null,1
+kohonen,plot.kohonen,5,0,1,integer[],1
+kohonen,plot.kohonen,6,0,0,null,1
+kohonen,plot.kohonen,6,0,1,character[],1
+kohonen,plot.kohonen,7,0,0,class<`function`>,1
+kohonen,plot.kohonen,7,0,1,null,1
+kohonen,plot.kohonen,8,0,0,any,1
+kohonen,plot.kohonen,9,0,0,null,1
+kohonen,plot.kohonen,9,0,1,character[],1
+kohonen,plot.kohonen,10,0,0,null,1
+kohonen,plot.kohonen,10,0,1,double[],1
+kohonen,plot.kohonen,11,0,0,logical,1
+kohonen,plot.kohonen,12,0,0,any,1
+kohonen,plot.kohonen,13,0,0,null,1
+kohonen,plot.kohonen,14,0,0,logical,1
+kohonen,plot.kohonen,15,0,0,double,1
+kohonen,plot.kohprop,-1,0,0,null,1
+kohonen,plot.kohprop,0,0,0,class<`kohonen`>,1
+kohonen,plot.kohprop,1,0,0,class<`factor`>,1
+kohonen,plot.kohprop,1,0,1,class<`matrix`>,1
+kohonen,plot.kohprop,1,0,2,^double[],1
+kohonen,plot.kohprop,2,0,0,character,1
+kohonen,plot.kohprop,3,0,0,class<`function`>,1
+kohonen,plot.kohprop,3,0,1,null,1
+kohonen,plot.kohprop,4,0,0,any,1
+kohonen,plot.kohprop,5,0,0,null,1
+kohonen,plot.kohprop,5,0,1,double[],1
+kohonen,plot.kohprop,6,0,0,logical,1
+kohonen,plot.kohprop,7,0,0,logical,1
+kohonen,plot.kohprop,8,0,0,double,1
+kohonen,plot.kohprop,9,0,0,character[],1
+kohonen,plot.kohprop,10,0,0,character,1
+kohonen,plot.kohprop,11,0,0,character,1
+kohonen,plot.kohprop,12,0,0,...,1
+kohonen,plot.kohquality,-1,0,0,^double[],1
+kohonen,plot.kohquality,0,0,0,class<`kohonen`>,1
+kohonen,plot.kohquality,1,0,0,null,1
+kohonen,plot.kohquality,2,0,0,null,1
+kohonen,plot.kohquality,3,0,0,class<`function`>,1
+kohonen,plot.kohquality,4,0,0,any,1
+kohonen,plot.kohquality,5,0,0,null,1
+kohonen,plot.kohquality,6,0,0,logical,1
+kohonen,plot.kohquality,7,0,0,logical,1
+kohonen,plot.kohquality,8,0,0,character[],1
+kohonen,plot.kohquality,9,0,0,character,1
+kohonen,plot.kohquality,10,0,0,...,1
+kohonen,plot.kohUmatrix,-1,0,0,double[],1
+kohonen,plot.kohUmatrix,0,0,0,class<`kohonen`>,1
+kohonen,plot.kohUmatrix,1,0,0,any,1
+kohonen,plot.kohUmatrix,2,0,0,character,1
+kohonen,plot.kohUmatrix,3,0,0,null,1
+kohonen,plot.kohUmatrix,4,0,0,any,1
+kohonen,plot.kohUmatrix,5,0,0,null,1
+kohonen,plot.kohUmatrix,6,0,0,logical,1
+kohonen,plot.kohUmatrix,7,0,0,logical,1
+kohonen,plot.kohUmatrix,8,0,0,double,1
+kohonen,plot.kohUmatrix,9,0,0,character[],1
+kohonen,plot.kohUmatrix,10,0,0,character,1
+kohonen,plot.kohUmatrix,11,0,0,...,1
+kohonen,plot.somgrid,-1,0,0,null,1
+kohonen,plot.somgrid,0,0,0,class<`somgrid`>,1
+kohonen,plot.somgrid,1,0,0,any,1
+kohonen,plot.somgrid,2,0,0,any,1
+kohonen,plot.somgrid,3,0,0,...,1
+kohonen,predict.kohonen,-1,0,0,list<double[] | list<class<`matrix`>>>,1
+kohonen,predict.kohonen,-1,0,1,list<double[] | list<class<`matrix`> | class<`factor`> | class<`matrix`>>>,1
+kohonen,predict.kohonen,0,0,0,class<`kohonen`>,1
+kohonen,predict.kohonen,1,0,0,class<`matrix`>,1
+kohonen,predict.kohonen,1,0,1,list<class<`matrix`> | class<`factor`>>,1
+kohonen,predict.kohonen,1,0,2,list<class<`matrix`>>,1
+kohonen,predict.kohonen,1,0,3,null,1
+kohonen,predict.kohonen,2,0,0,class<`matrix`>,1
+kohonen,predict.kohonen,2,0,1,null,1
+kohonen,predict.kohonen,3,0,0,null,1
+kohonen,predict.kohonen,3,0,1,list<class<`matrix`> | class<`factor`>>,1
+kohonen,predict.kohonen,4,0,0,double,1
+kohonen,predict.kohonen,4,0,1,character,1
+kohonen,predict.kohonen,4,0,2,null,1
+kohonen,predict.kohonen,5,0,0,double,1
+kohonen,predict.kohonen,6,0,0,double,1
+kohonen,predict.kohonen,7,0,0,...,1
+kohonen,RcppMap,-1,0,0,list<double[]>,1
+kohonen,RcppMap,0,0,0,class<`matrix`>,1
+kohonen,RcppMap,1,0,0,integer[],1
+kohonen,RcppMap,2,0,0,class<`matrix`>,1
+kohonen,RcppMap,3,0,0,class<`matrix`>,1
+kohonen,RcppMap,4,0,0,double[],1
+kohonen,RcppMap,5,0,0,list<externalptr>,1
+kohonen,RcppSupersom,-1,0,0,list<class<`matrix`>>,1
+kohonen,RcppSupersom,0,0,0,class<`matrix`>,1
+kohonen,RcppSupersom,1,0,0,class<`matrix`>,1
+kohonen,RcppSupersom,2,0,0,integer[],1
+kohonen,RcppSupersom,3,0,0,double[],1
+kohonen,RcppSupersom,4,0,0,list<externalptr>,1
+kohonen,RcppSupersom,5,0,0,class<`matrix`>,1
+kohonen,RcppSupersom,6,0,0,class<`matrix`>,1
+kohonen,RcppSupersom,7,0,0,integer,1
+kohonen,RcppSupersom,8,0,0,double[],1
+kohonen,RcppSupersom,9,0,0,double[],1
+kohonen,RcppSupersom,10,0,0,double,1
+kohonen,remove.data.na,-1,0,0,list<class<`matrix`>>,1
+kohonen,remove.data.na,0,0,0,list<class<`matrix`>>,1
+kohonen,remove.data.na,1,0,0,integer[],1
+kohonen,remove.data.na,1,0,1,null,1
+kohonen,som,-1,0,0,class<`kohonen`>,1
+kohonen,som,0,0,0,class<`matrix`>,1
+kohonen,som,1,0,0,...,1
+kohonen,somgrid,-1,0,0,class<`somgrid`>,1
+kohonen,somgrid,0,0,0,double,1
+kohonen,somgrid,1,0,0,double,1
+kohonen,somgrid,2,0,0,character,1
+kohonen,somgrid,3,0,0,character[],1
+kohonen,somgrid,4,0,0,logical,1
+kohonen,summary.kohonen,-1,0,0,null,1
+kohonen,summary.kohonen,0,0,0,class<`kohonen`>,1
+kohonen,summary.kohonen,1,0,0,...,1
+kohonen,supersom,-1,0,0,class<`kohonen`>,1
+kohonen,supersom,0,0,0,class<`matrix`>,1
+kohonen,supersom,0,0,1,list<class<`matrix`> | class<`factor`>>,1
+kohonen,supersom,0,0,2,list<class<`matrix`>>,1
+kohonen,supersom,1,0,0,class<`somgrid`>,1
+kohonen,supersom,2,0,0,double,1
+kohonen,supersom,3,0,0,double[],1
+kohonen,supersom,4,0,0,double,1
+kohonen,supersom,5,0,0,null,1
+kohonen,supersom,5,0,1,character[],1
+kohonen,supersom,5,0,2,integer[],1
+kohonen,supersom,6,0,0,double[],1
+kohonen,supersom,7,0,0,double,1
+kohonen,supersom,8,0,0,logical,1
+kohonen,supersom,9,0,0,null,1
+kohonen,supersom,10,0,0,character[],1
+kohonen,supersom,11,0,0,any,1
+kohonen,supersom,12,0,0,any,1
+kohonen,supersom,13,0,0,logical,1
+kohonen,tricolor,-1,0,0,class<`matrix`>,1
+kohonen,tricolor,0,0,0,class<`somgrid`>,1
+kohonen,tricolor,1,0,0,double[],1
+kohonen,tricolor,2,0,0,double,1
+kohonen,unit.distances,-1,0,0,class<`matrix`>,1
+kohonen,unit.distances,0,0,0,class<`somgrid`>,1
+kohonen,unit.distances,1,0,0,any,1
+kohonen,xyf,-1,0,0,class<`kohonen`>,1
+kohonen,xyf,0,0,0,class<`matrix`>,1
+kohonen,xyf,1,0,0,class<`matrix`>,1
+kohonen,xyf,1,0,1,class<`factor`>,1
+kohonen,xyf,2,0,0,...,1
+labelled,add_value_labels,-1,0,0,"class<`data.frame`, `tbl`, `tbl_df`>",1
+labelled,add_value_labels,0,0,0,"class<`data.frame`, `tbl`, `tbl_df`>",1
+labelled,add_value_labels,1,0,0,...,1
+labelled,copy_labels,-1,0,0,"class<`data.frame`, `tbl`, `tbl_df`>",1
+labelled,copy_labels,-1,0,1,class<`factor`>,1
+labelled,copy_labels,-1,0,2,class<`haven_labelled`>,1
+labelled,copy_labels,-1,0,3,integer[],1
+labelled,copy_labels,0,0,0,"class<`data.frame`, `tbl`, `tbl_df`>",1
+labelled,copy_labels,0,0,1,class<`factor`>,1
+labelled,copy_labels,0,0,2,class<`haven_labelled`>,1
+labelled,copy_labels,0,0,3,integer[],1
+labelled,copy_labels,1,0,0,"class<`data.frame`, `tbl`, `tbl_df`>",1
+labelled,copy_labels,1,0,1,class<`factor`>,1
+labelled,copy_labels,1,0,2,class<`haven_labelled`>,1
+labelled,copy_labels,1,0,3,integer[],1
+labelled,copy_labels.data.frame,-1,0,0,"class<`data.frame`, `tbl`, `tbl_df`>",1
+labelled,copy_labels.data.frame,0,0,0,"class<`data.frame`, `tbl`, `tbl_df`>",1
+labelled,copy_labels.data.frame,1,0,0,"class<`data.frame`, `tbl`, `tbl_df`>",1
+labelled,copy_labels.default,-1,0,0,class<`factor`>,1
+labelled,copy_labels.default,-1,0,1,class<`haven_labelled`>,1
+labelled,copy_labels.default,-1,0,2,integer[],1
+labelled,copy_labels.default,0,0,0,class<`factor`>,1
+labelled,copy_labels.default,0,0,1,class<`haven_labelled`>,1
+labelled,copy_labels.default,0,0,2,integer[],1
+labelled,copy_labels.default,1,0,0,class<`factor`>,1
+labelled,copy_labels.default,1,0,1,class<`haven_labelled`>,1
+labelled,copy_labels.default,1,0,2,integer[],1
+labelled,copy_labels_from,-1,0,0,"class<`data.frame`, `tbl`, `tbl_df`>",1
+labelled,copy_labels_from,0,0,0,"class<`data.frame`, `tbl`, `tbl_df`>",1
+labelled,copy_labels_from,1,0,0,"class<`data.frame`, `tbl`, `tbl_df`>",1
+labelled,foreign_to_labelled,-1,0,0,"class<`data.frame`, `tbl`, `tbl_df`>",1
+labelled,foreign_to_labelled,0,0,0,class<`data.frame`>,1
+labelled,look_for,-1,0,0,class<`data.frame`>,1
+labelled,look_for,0,0,0,class<`data.frame`>,1
+labelled,look_for,1,0,0,...,1
+labelled,look_for,2,0,0,logical,1
+labelled,look_for,3,0,0,logical,1
+labelled,look_for,4,0,0,logical,1
+labelled,na_range,-1,0,0,double[],1
+labelled,na_range,-1,0,1,null,1
+labelled,na_range,0,0,0,"class<`haven_labelled`, `haven_labelled_spss`>",1
+labelled,na_range,0,0,1,class<`haven_labelled`>,1
+labelled,na_range,0,0,2,integer[],1
+labelled,na_range<-,-1,0,0,class<`haven_labelled`>,1
+labelled,na_range<-,-1,0,1,"class<`haven_labelled`, `haven_labelled_spss`>",1
+labelled,na_range<-,-1,0,2,integer[],1
+labelled,na_range<-,0,0,0,class<`haven_labelled`>,1
+labelled,na_range<-,0,0,1,"class<`haven_labelled`, `haven_labelled_spss`>",1
+labelled,na_range<-,0,0,2,integer[],1
+labelled,na_range<-,1,0,0,null,1
+labelled,na_range<-,1,0,1,double[],1
+labelled,na_range<-.default,-1,0,0,integer[],1
+labelled,na_range<-.default,0,0,0,integer[],1
+labelled,na_range<-.default,1,0,0,null,1
+labelled,na_range.default,-1,0,0,null,1
+labelled,na_range.default,0,0,0,class<`haven_labelled`>,1
+labelled,na_range.default,0,0,1,integer[],1
+labelled,na_range.default,0,0,2,character[],1
+labelled,na_range<-.haven_labelled,-1,0,0,class<`haven_labelled`>,1
+labelled,na_range<-.haven_labelled,-1,0,1,"class<`haven_labelled`, `haven_labelled_spss`>",1
+labelled,na_range<-.haven_labelled,0,0,0,class<`haven_labelled`>,1
+labelled,na_range<-.haven_labelled,0,0,1,"class<`haven_labelled`, `haven_labelled_spss`>",1
+labelled,na_range<-.haven_labelled,1,0,0,null,1
+labelled,na_range<-.haven_labelled,1,0,1,double[],1
+labelled,na_range.haven_labelled_spss,-1,0,0,double[],1
+labelled,na_range.haven_labelled_spss,-1,0,1,null,1
+labelled,na_range.haven_labelled_spss,0,0,0,"class<`haven_labelled`, `haven_labelled_spss`>",1
+labelled,na_values,-1,0,0,null,1
+labelled,na_values,-1,0,1,double[],1
+labelled,na_values,-1,0,2,list<null | double>,1
+labelled,na_values,0,0,0,"class<`haven_labelled`, `haven_labelled_spss`>",1
+labelled,na_values,0,0,1,character[],1
+labelled,na_values,0,0,2,class<`haven_labelled`>,1
+labelled,na_values,0,0,3,integer[],1
+labelled,na_values,0,0,4,"class<`data.frame`, `tbl`, `tbl_df`>",1
+labelled,na_values<-,-1,0,0,class<`haven_labelled`>,1
+labelled,na_values<-,-1,0,1,"class<`haven_labelled`, `haven_labelled_spss`>",1
+labelled,na_values<-,-1,0,2,integer[],1
+labelled,na_values<-,0,0,0,class<`haven_labelled`>,1
+labelled,na_values<-,0,0,1,"class<`haven_labelled`, `haven_labelled_spss`>",1
+labelled,na_values<-,0,0,2,integer[],1
+labelled,na_values<-,1,0,0,null,1
+labelled,na_values<-,1,0,1,double,1
+labelled,na_values.data.frame,-1,0,0,list<null | double>,1
+labelled,na_values.data.frame,0,0,0,"class<`data.frame`, `tbl`, `tbl_df`>",1
+labelled,na_values<-.default,-1,0,0,integer[],1
+labelled,na_values<-.default,0,0,0,integer[],1
+labelled,na_values<-.default,1,0,0,null,1
+labelled,na_values.default,-1,0,0,null,1
+labelled,na_values.default,0,0,0,class<`haven_labelled`>,1
+labelled,na_values.default,0,0,1,integer[],1
+labelled,na_values.default,0,0,2,character[],1
+labelled,na_values<-.haven_labelled,-1,0,0,class<`haven_labelled`>,1
+labelled,na_values<-.haven_labelled,-1,0,1,"class<`haven_labelled`, `haven_labelled_spss`>",1
+labelled,na_values<-.haven_labelled,0,0,0,class<`haven_labelled`>,1
+labelled,na_values<-.haven_labelled,0,0,1,"class<`haven_labelled`, `haven_labelled_spss`>",1
+labelled,na_values<-.haven_labelled,1,0,0,null,1
+labelled,na_values<-.haven_labelled,1,0,1,double,1
+labelled,na_values.haven_labelled_spss,-1,0,0,double[],1
+labelled,na_values.haven_labelled_spss,0,0,0,"class<`haven_labelled`, `haven_labelled_spss`>",1
+labelled,nolabel_to_na,-1,0,0,class<`haven_labelled`>,1
+labelled,nolabel_to_na,0,0,0,class<`haven_labelled`>,1
+labelled,nolabel_to_na.haven_labelled,-1,0,0,class<`haven_labelled`>,1
+labelled,nolabel_to_na.haven_labelled,0,0,0,class<`haven_labelled`>,1
+labelled,recode.haven_labelled,-1,0,0,class<`haven_labelled`>,1
+labelled,recode.haven_labelled,0,0,0,class<`haven_labelled`>,1
+labelled,recode.haven_labelled,1,0,0,...,1
+labelled,recode.haven_labelled,2,0,0,null,1
+labelled,recode.haven_labelled,3,0,0,null,1
+labelled,remove_labels,-1,0,0,^integer[],1
+labelled,remove_labels,0,0,0,"class<`haven_labelled`, `haven_labelled_spss`>",1
+labelled,remove_labels,1,0,0,logical,1
+labelled,remove_labels.haven_labelled_spss,-1,0,0,^integer[],1
+labelled,remove_labels.haven_labelled_spss,0,0,0,"class<`haven_labelled`, `haven_labelled_spss`>",1
+labelled,remove_labels.haven_labelled_spss,1,0,0,logical,1
+labelled,remove_user_na,-1,0,0,class<`haven_labelled`>,1
+labelled,remove_user_na,0,0,0,"class<`haven_labelled`, `haven_labelled_spss`>",1
+labelled,remove_user_na,1,0,0,logical,1
+labelled,remove_user_na.haven_labelled_spss,-1,0,0,class<`haven_labelled`>,1
+labelled,remove_user_na.haven_labelled_spss,0,0,0,"class<`haven_labelled`, `haven_labelled_spss`>",1
+labelled,remove_user_na.haven_labelled_spss,1,0,0,logical,1
+labelled,remove_value_labels,-1,0,0,"class<`data.frame`, `tbl`, `tbl_df`>",1
+labelled,remove_value_labels,0,0,0,"class<`data.frame`, `tbl`, `tbl_df`>",1
+labelled,remove_value_labels,1,0,0,...,1
+labelled,set_na_values,-1,0,0,"class<`data.frame`, `tbl`, `tbl_df`>",1
+labelled,set_na_values,0,0,0,"class<`data.frame`, `tbl`, `tbl_df`>",1
+labelled,set_na_values,1,0,0,...,1
+labelled,set_value_labels,-1,0,0,"class<`data.frame`, `tbl`, `tbl_df`>",1
+labelled,set_value_labels,0,0,0,"class<`data.frame`, `tbl`, `tbl_df`>",1
+labelled,set_value_labels,1,0,0,...,1
+labelled,set_variable_labels,-1,0,0,class<`data.frame`>,1
+labelled,set_variable_labels,-1,0,1,"class<`data.frame`, `tbl`, `tbl_df`>",1
+labelled,set_variable_labels,0,0,0,class<`data.frame`>,1
+labelled,set_variable_labels,0,0,1,"class<`data.frame`, `tbl`, `tbl_df`>",1
+labelled,set_variable_labels,1,0,0,...,1
+labelled,set_variable_labels,2,0,0,character[],1
+labelled,set_variable_labels,2,0,1,null,1
+labelled,sort_val_labels,-1,0,0,class<`haven_labelled`>,1
+labelled,sort_val_labels,0,0,0,class<`haven_labelled`>,1
+labelled,sort_val_labels,1,0,0,any,1
+labelled,sort_val_labels,2,0,0,logical,1
+labelled,sort_val_labels.haven_labelled,-1,0,0,class<`haven_labelled`>,1
+labelled,sort_val_labels.haven_labelled,0,0,0,class<`haven_labelled`>,1
+labelled,sort_val_labels.haven_labelled,1,0,0,character[],1
+labelled,sort_val_labels.haven_labelled,2,0,0,logical,1
+labelled,to_character,-1,0,0,^character[],1
+labelled,to_character,0,0,0,class<`haven_labelled`>,1
+labelled,to_character,1,0,0,...,1
+labelled,to_character.haven_labelled,-1,0,0,^character[],1
+labelled,to_character.haven_labelled,0,0,0,class<`haven_labelled`>,1
+labelled,to_character.haven_labelled,1,0,0,character[],1
+labelled,to_character.haven_labelled,2,0,0,logical,1
+labelled,to_character.haven_labelled,3,0,0,...,1
+labelled,to_factor,-1,0,0,"class<`data.frame`, `tbl`, `tbl_df`>",1
+labelled,to_factor,-1,0,1,class<`factor`>,1
+labelled,to_factor,-1,0,2,"class<`factor`, `ordered`>",1
+labelled,to_factor,-1,0,3,class<`haven_labelled`>,1
+labelled,to_factor,-1,0,4,double[],1
+labelled,to_factor,0,0,0,"class<`data.frame`, `tbl`, `tbl_df`>",1
+labelled,to_factor,0,0,1,class<`haven_labelled`>,1
+labelled,to_factor,0,0,2,"class<`haven_labelled`, `haven_labelled_spss`>",1
+labelled,to_factor,1,0,0,...,1
+labelled,to_factor.data.frame,-1,0,0,"class<`data.frame`, `tbl`, `tbl_df`>",1
+labelled,to_factor.data.frame,0,0,0,"class<`data.frame`, `tbl`, `tbl_df`>",1
+labelled,to_factor.data.frame,1,0,0,character[],1
+labelled,to_factor.data.frame,2,0,0,logical,1
+labelled,to_factor.data.frame,3,0,0,logical,1
+labelled,to_factor.data.frame,4,0,0,character[],1
+labelled,to_factor.data.frame,5,0,0,logical,1
+labelled,to_factor.data.frame,6,0,0,logical,1
+labelled,to_factor.data.frame,7,0,0,logical,1
+labelled,to_factor.data.frame,8,0,0,logical,1
+labelled,to_factor.data.frame,9,0,0,logical,1
+labelled,to_factor.data.frame,10,0,0,...,1
+labelled,to_factor.haven_labelled,-1,0,0,class<`factor`>,1
+labelled,to_factor.haven_labelled,-1,0,1,"class<`factor`, `ordered`>",1
+labelled,to_factor.haven_labelled,-1,0,2,class<`haven_labelled`>,1
+labelled,to_factor.haven_labelled,-1,0,3,double[],1
+labelled,to_factor.haven_labelled,0,0,0,class<`haven_labelled`>,1
+labelled,to_factor.haven_labelled,0,0,1,"class<`haven_labelled`, `haven_labelled_spss`>",1
+labelled,to_factor.haven_labelled,1,0,0,character[],1
+labelled,to_factor.haven_labelled,2,0,0,logical,1
+labelled,to_factor.haven_labelled,3,0,0,logical,1
+labelled,to_factor.haven_labelled,4,0,0,character[],1
+labelled,to_factor.haven_labelled,5,0,0,any,1
+labelled,to_factor.haven_labelled,6,0,0,logical,1
+labelled,to_factor.haven_labelled,7,0,0,logical,1
+labelled,to_factor.haven_labelled,8,0,0,logical,1
+labelled,to_factor.haven_labelled,9,0,0,any,1
+labelled,to_factor.haven_labelled,10,0,0,...,1
+labelled,to_labelled,-1,0,0,"class<`data.frame`, `tbl`, `tbl_df`>",1
+labelled,to_labelled,-1,0,1,class<`haven_labelled`>,1
+labelled,to_labelled,0,0,0,class<`data.frame`>,1
+labelled,to_labelled,0,0,1,class<`factor`>,1
+labelled,to_labelled,1,0,0,...,1
+labelled,to_labelled.data.frame,-1,0,0,"class<`data.frame`, `tbl`, `tbl_df`>",1
+labelled,to_labelled.data.frame,0,0,0,class<`data.frame`>,1
+labelled,to_labelled.data.frame,1,0,0,...,1
+labelled,to_labelled.factor,-1,0,0,class<`haven_labelled`>,1
+labelled,to_labelled.factor,0,0,0,class<`factor`>,1
+labelled,to_labelled.factor,1,0,0,character[],1
+labelled,to_labelled.factor,1,0,1,double[],1
+labelled,to_labelled.factor,1,0,2,null,1
+labelled,to_labelled.factor,2,0,0,...,1
+labelled,user_na_to_na,-1,0,0,class<`haven_labelled`>,1
+labelled,user_na_to_na,0,0,0,"class<`haven_labelled`, `haven_labelled_spss`>",1
+labelled,user_na_to_na.haven_labelled_spss,-1,0,0,class<`haven_labelled`>,1
+labelled,user_na_to_na.haven_labelled_spss,0,0,0,"class<`haven_labelled`, `haven_labelled_spss`>",1
+labelled,val_label,-1,0,0,character,1
+labelled,val_label,-1,0,1,null,1
+labelled,val_label,0,0,0,class<`haven_labelled`>,1
+labelled,val_label,1,0,0,double,1
+labelled,val_label,2,0,0,logical,1
+labelled,val_label<-,-1,0,0,class<`data.frame`>,1
+labelled,val_label<-,-1,0,1,class<`haven_labelled`>,1
+labelled,val_label<-,0,0,0,class<`data.frame`>,1
+labelled,val_label<-,0,0,1,class<`haven_labelled`>,1
+labelled,val_label<-,0,0,2,^double[],1
+labelled,val_label<-,1,0,0,double,1
+labelled,val_label<-,2,0,0,character,1
+labelled,val_label<-,2,0,1,null,1
+labelled,val_label<-.data.frame,-1,0,0,class<`data.frame`>,1
+labelled,val_label<-.data.frame,0,0,0,class<`data.frame`>,1
+labelled,val_label<-.data.frame,1,0,0,double,1
+labelled,val_label<-.data.frame,2,0,0,character,1
+labelled,val_label<-.haven_labelled,-1,0,0,class<`haven_labelled`>,1
+labelled,val_label<-.haven_labelled,0,0,0,^double[],1
+labelled,val_label<-.haven_labelled,0,0,1,class<`haven_labelled`>,1
+labelled,val_label<-.haven_labelled,1,0,0,double,1
+labelled,val_label<-.haven_labelled,2,0,0,character,1
+labelled,val_label<-.haven_labelled,2,0,1,null,1
+labelled,val_label.haven_labelled,-1,0,0,character,1
+labelled,val_label.haven_labelled,-1,0,1,null,1
+labelled,val_label.haven_labelled,0,0,0,class<`haven_labelled`>,1
+labelled,val_label.haven_labelled,1,0,0,double,1
+labelled,val_label.haven_labelled,2,0,0,logical,1
+labelled,val_label<-.numeric,-1,0,0,class<`haven_labelled`>,1
+labelled,val_label<-.numeric,0,0,0,^double[],1
+labelled,val_label<-.numeric,1,0,0,double,1
+labelled,val_label<-.numeric,2,0,0,character,1
+labelled,val_labels,-1,0,0,character[],1
+labelled,val_labels,-1,0,1,double[],1
+labelled,val_labels,-1,0,2,null,1
+labelled,val_labels,-1,0,3,list<character[] | double[]>,1
+labelled,val_labels,-1,0,4,list<double[]>,1
+labelled,val_labels,-1,0,5,list<double[] | null>,1
+labelled,val_labels,-1,0,6,list<null>,1
+labelled,val_labels,0,0,0,class<`haven_labelled`>,1
+labelled,val_labels,0,0,1,"class<`haven_labelled`, `haven_labelled_spss`>",1
+labelled,val_labels,0,0,2,^double[],1
+labelled,val_labels,0,0,3,"class<`data.frame`, `tbl`, `tbl_df`>",1
+labelled,val_labels,0,0,4,class<`data.frame`>,1
+labelled,val_labels,1,0,0,any,1
+labelled,val_labels<-,-1,0,0,class<`data.frame`>,1
+labelled,val_labels<-,-1,0,1,class<`factor`>,1
+labelled,val_labels<-,-1,0,2,class<`haven_labelled`>,1
+labelled,val_labels<-,-1,0,3,^double[],1
+labelled,val_labels<-,0,0,0,class<`data.frame`>,1
+labelled,val_labels<-,0,0,1,class<`factor`>,1
+labelled,val_labels<-,0,0,2,character[],1
+labelled,val_labels<-,0,0,3,class<`haven_labelled`>,1
+labelled,val_labels<-,0,0,4,^double[],1
+labelled,val_labels<-,1,0,0,double[],1
+labelled,val_labels<-,1,0,1,null,1
+labelled,val_labels<-,1,0,2,list<double[]>,1
+labelled,val_labels<-,1,0,3,character[],1
+labelled,val_labels<-.character,-1,0,0,class<`haven_labelled`>,1
+labelled,val_labels<-.character,-1,0,1,integer[],1
+labelled,val_labels<-.character,0,0,0,character[],1
+labelled,val_labels<-.character,0,0,1,^double[],1
+labelled,val_labels<-.character,1,0,0,character[],1
+labelled,val_labels<-.character,1,0,1,double[],1
+labelled,val_labels<-.character,1,0,2,null,1
+labelled,val_labels<-.data.frame,-1,0,0,class<`data.frame`>,1
+labelled,val_labels<-.data.frame,0,0,0,class<`data.frame`>,1
+labelled,val_labels<-.data.frame,1,0,0,double[],1
+labelled,val_labels<-.data.frame,1,0,1,null,1
+labelled,val_labels<-.data.frame,1,0,2,list<double[]>,1
+labelled,val_labels.data.frame,-1,0,0,list<character[] | double[]>,1
+labelled,val_labels.data.frame,-1,0,1,list<double[]>,1
+labelled,val_labels.data.frame,-1,0,2,list<double[] | null>,1
+labelled,val_labels.data.frame,-1,0,3,list<null>,1
+labelled,val_labels.data.frame,0,0,0,"class<`data.frame`, `tbl`, `tbl_df`>",1
+labelled,val_labels.data.frame,0,0,1,class<`data.frame`>,1
+labelled,val_labels.data.frame,1,0,0,logical,1
+labelled,val_labels<-.default,-1,0,0,class<`factor`>,1
+labelled,val_labels<-.default,0,0,0,class<`factor`>,1
+labelled,val_labels<-.default,1,0,0,double[],1
+labelled,val_labels.default,-1,0,0,null,1
+labelled,val_labels.default,0,0,0,^double[],1
+labelled,val_labels.default,1,0,0,any,1
+labelled,val_labels<-.haven_labelled,-1,0,0,class<`haven_labelled`>,1
+labelled,val_labels<-.haven_labelled,-1,0,1,^double[],1
+labelled,val_labels<-.haven_labelled,0,0,0,class<`haven_labelled`>,1
+labelled,val_labels<-.haven_labelled,1,0,0,double[],1
+labelled,val_labels<-.haven_labelled,1,0,1,null,1
+labelled,val_labels.haven_labelled,-1,0,0,character[],1
+labelled,val_labels.haven_labelled,-1,0,1,double[],1
+labelled,val_labels.haven_labelled,0,0,0,class<`haven_labelled`>,1
+labelled,val_labels.haven_labelled,0,0,1,"class<`haven_labelled`, `haven_labelled_spss`>",1
+labelled,val_labels.haven_labelled,1,0,0,logical,1
+labelled,val_labels<-.numeric,-1,0,0,class<`haven_labelled`>,1
+labelled,val_labels<-.numeric,-1,0,1,integer[],1
+labelled,val_labels<-.numeric,0,0,0,character[],1
+labelled,val_labels<-.numeric,0,0,1,^double[],1
+labelled,val_labels<-.numeric,1,0,0,character[],1
+labelled,val_labels<-.numeric,1,0,1,double[],1
+labelled,val_labels<-.numeric,1,0,2,null,1
+labelled,val_labels_to_na,-1,0,0,^double[],1
+labelled,val_labels_to_na,0,0,0,class<`haven_labelled`>,1
+labelled,val_labels_to_na.haven_labelled,-1,0,0,^double[],1
+labelled,val_labels_to_na.haven_labelled,0,0,0,class<`haven_labelled`>,1
+labelled,var_label,-1,0,0,null,1
+labelled,var_label,-1,0,1,character[],1
+labelled,var_label,-1,0,2,list<character>,1
+labelled,var_label,-1,0,3,list<character | null>,1
+labelled,var_label,-1,0,4,list<null | character>,1
+labelled,var_label,-1,0,5,list<null>,1
+labelled,var_label,0,0,0,character[],1
+labelled,var_label,0,0,1,class<`factor`>,1
+labelled,var_label,0,0,2,class<`haven_labelled`>,1
+labelled,var_label,0,0,3,"class<`haven_labelled`, `haven_labelled_spss`>",1
+labelled,var_label,0,0,4,class<`data.frame`>,1
+labelled,var_label,0,0,5,^double[],1
+labelled,var_label,0,0,6,"class<`data.frame`, `tbl`, `tbl_df`>",1
+labelled,var_label,1,0,0,logical,1
+labelled,var_label<-,-1,0,0,^character[],1
+labelled,var_label<-,-1,0,1,class<`data.frame`>,1
+labelled,var_label<-,-1,0,2,class<`factor`>,1
+labelled,var_label<-,-1,0,3,"class<`factor`, `ordered`>",1
+labelled,var_label<-,-1,0,4,class<`haven_labelled`>,1
+labelled,var_label<-,-1,0,5,"class<`haven_labelled`, `haven_labelled_spss`>",1
+labelled,var_label<-,-1,0,6,double[],1
+labelled,var_label<-,0,0,0,^character[],1
+labelled,var_label<-,0,0,1,class<`data.frame`>,1
+labelled,var_label<-,0,0,2,class<`factor`>,1
+labelled,var_label<-,0,0,3,"class<`factor`, `ordered`>",1
+labelled,var_label<-,0,0,4,class<`haven_labelled`>,1
+labelled,var_label<-,0,0,5,"class<`haven_labelled`, `haven_labelled_spss`>",1
+labelled,var_label<-,0,0,6,double[],1
+labelled,var_label<-,1,0,0,null,1
+labelled,var_label<-,1,0,1,character[],1
+labelled,var_label<-,1,0,2,list<character>,1
+labelled,var_label<-.data.frame,-1,0,0,class<`data.frame`>,1
+labelled,var_label<-.data.frame,0,0,0,class<`data.frame`>,1
+labelled,var_label<-.data.frame,1,0,0,character[],1
+labelled,var_label<-.data.frame,1,0,1,list<character>,1
+labelled,var_label.data.frame,-1,0,0,character[],1
+labelled,var_label.data.frame,-1,0,1,list<character>,1
+labelled,var_label.data.frame,-1,0,2,list<character | null>,1
+labelled,var_label.data.frame,-1,0,3,list<null | character>,1
+labelled,var_label.data.frame,-1,0,4,list<null>,1
+labelled,var_label.data.frame,0,0,0,class<`data.frame`>,1
+labelled,var_label.data.frame,0,0,1,"class<`data.frame`, `tbl`, `tbl_df`>",1
+labelled,var_label.data.frame,1,0,0,logical,1
+labelled,var_label<-.default,-1,0,0,^character[],1
+labelled,var_label<-.default,-1,0,1,class<`factor`>,1
+labelled,var_label<-.default,-1,0,2,"class<`factor`, `ordered`>",1
+labelled,var_label<-.default,-1,0,3,class<`haven_labelled`>,1
+labelled,var_label<-.default,-1,0,4,"class<`haven_labelled`, `haven_labelled_spss`>",1
+labelled,var_label<-.default,-1,0,5,double[],1
+labelled,var_label<-.default,0,0,0,^character[],1
+labelled,var_label<-.default,0,0,1,class<`factor`>,1
+labelled,var_label<-.default,0,0,2,"class<`factor`, `ordered`>",1
+labelled,var_label<-.default,0,0,3,class<`haven_labelled`>,1
+labelled,var_label<-.default,0,0,4,"class<`haven_labelled`, `haven_labelled_spss`>",1
+labelled,var_label<-.default,0,0,5,double[],1
+labelled,var_label<-.default,1,0,0,null,1
+labelled,var_label<-.default,1,0,1,character,1
+labelled,var_label.default,-1,0,0,character,1
+labelled,var_label.default,-1,0,1,null,1
+labelled,var_label.default,0,0,0,character[],1
+labelled,var_label.default,0,0,1,class<`factor`>,1
+labelled,var_label.default,0,0,2,class<`haven_labelled`>,1
+labelled,var_label.default,0,0,3,"class<`haven_labelled`, `haven_labelled_spss`>",1
+labelled,var_label.default,0,0,4,^double[],1
+labelled,var_label.default,1,0,0,logical,1
+lamW,lambertW0,-1,0,0,double,1
+lamW,lambertW0,0,0,0,double,1
+lamW,lambertW0_C,-1,0,0,double,1
+lamW,lambertW0_C,0,0,0,double,1
+lamW,lambertWm1,-1,0,0,double,1
+lamW,lambertWm1,0,0,0,double,1
+lamW,lambertWm1_C,-1,0,0,double,1
+lamW,lambertWm1_C,0,0,0,double,1
+lambda.r,%:=%,-1,0,0,null,1
+lambda.r,%:=%,0,0,0,any,1
+lambda.r,%:=%,1,0,0,any,1
+lambda.r,%::%,-1,0,0,null,1
+lambda.r,%::%,0,0,0,any,1
+lambda.r,%::%,1,0,0,any,1
+lambda.r,add_type,-1,0,0,null,1
+lambda.r,add_type,0,0,0,character,1
+lambda.r,add_type,1,0,0,list<class<`data.frame`> | character>,1
+lambda.r,add_type,1,0,1,list<null | class<`data.frame`> | character>,1
+lambda.r,add_variant,-1,0,0,null,1
+lambda.r,add_variant,0,0,0,character,1
+lambda.r,add_variant,1,0,0,list<any>,1
+lambda.r,add_variant,2,0,0,environment,1
+lambda.r,%as%,-1,0,0,null,1
+lambda.r,%as%,0,0,0,any,1
+lambda.r,%as%,1,0,0,any,1
+lambda.r,body_fn,-1,0,0,character[],1
+lambda.r,body_fn,-1,0,1,class<`function`>,1
+lambda.r,body_fn,0,0,0,class<`data.frame`>,1
+lambda.r,body_fn,0,0,1,null,1
+lambda.r,body_fn,1,0,0,class<`data.frame`>,1
+lambda.r,body_fn,2,0,0,environment,1
+lambda.r,check_types,-1,0,0,logical,1
+lambda.r,check_types,0,0,0,null,1
+lambda.r,check_types,0,0,1,list<class<`data.frame`> | character | integer[]>,1
+lambda.r,check_types,1,0,0,any,1
+lambda.r,clean_defaults,-1,0,0,^character[],1
+lambda.r,clean_defaults,-1,0,1,^logical[],1
+lambda.r,clean_defaults,-1,0,2,null,1
+lambda.r,clean_defaults,0,0,0,list<any>,1
+lambda.r,clean_tokens,-1,0,0,character[],1
+lambda.r,clean_tokens,-1,0,1,null,1
+lambda.r,clean_tokens,0,0,0,list<any>,1
+lambda.r,dereference_type,-1,0,0,class<`function`>,1
+lambda.r,dereference_type,0,0,0,character[],1
+lambda.r,dereference_type,1,0,0,list<character[]>,1
+lambda.r,fast_forward,-1,0,0,class<`data.frame`>,1
+lambda.r,fast_forward,0,0,0,class<`function`>,1
+lambda.r,fast_forward,1,0,0,character[],1
+lambda.r,fill_args,-1,0,0,list<any>,1
+lambda.r,fill_args,-1,0,1,null,1
+lambda.r,fill_args,0,0,0,list<any>,1
+lambda.r,fill_args,1,0,0,null,1
+lambda.r,fill_args,1,0,1,character[],1
+lambda.r,fill_args,2,0,0,any,1
+lambda.r,fill_args,3,0,0,integer[],1
+lambda.r,from_root_env,-1,0,0,logical,1
+lambda.r,from_root_env,0,0,0,pairlist,1
+lambda.r,get_function_env,-1,0,0,environment,1
+lambda.r,get_lr,-1,0,0,"class<`function`, `lambdar.fun`>",1
+lambda.r,get_lr,-1,0,1,"class<`function`, `lambdar.type`>",1
+lambda.r,get_lr,0,0,0,character,1
+lambda.r,get_name,-1,0,0,character,1
+lambda.r,get_name,0,0,0,class<`function`>,1
+lambda.r,get_type,-1,0,0,null,1
+lambda.r,get_type,-1,0,1,list<class<`data.frame`> | character | integer[]>,1
+lambda.r,get_type,0,0,0,any,1
+lambda.r,get_type,1,0,0,null,1
+lambda.r,get_type,1,0,1,double,1
+lambda.r,get_type_index,-1,0,0,double,1
+lambda.r,get_type_index,-1,0,1,null,1
+lambda.r,get_type_index,0,0,0,"class<`function`, `lambdar.fun`>",1
+lambda.r,get_type_index,0,0,1,"class<`function`, `lambdar.type`>",1
+lambda.r,get_type_index,1,0,0,any,1
+lambda.r,get_type_index,2,0,0,any,1
+lambda.r,get_variant,-1,0,0,list<list<any>>,1
+lambda.r,get_variant,0,0,0,"class<`function`, `lambdar.fun`>",1
+lambda.r,get_variant,0,0,1,"class<`function`, `lambdar.type`>",1
+lambda.r,get_variant,1,0,0,integer,1
+lambda.r,guard_fn,-1,0,0,class<`function`>,1
+lambda.r,guard_fn,-1,0,1,null,1
+lambda.r,guard_fn,0,0,0,class<`data.frame`>,1
+lambda.r,guard_fn,1,0,0,class<`data.frame`>,1
+lambda.r,guard_fn,1,0,1,null,1
+lambda.r,guard_fn,2,0,0,any,1
+lambda.r,has_ellipsis,-1,0,0,integer[],1
+lambda.r,has_ellipsis,0,0,0,character[],1
+lambda.r,has_variant,-1,0,0,integer,1
+lambda.r,has_variant,-1,0,1,list<any>,1
+lambda.r,has_variant,-1,0,2,logical[],1
+lambda.r,has_variant,0,0,0,list<any>,1
+lambda.r,has_variant,1,0,0,any,1
+lambda.r,has_variant,2,0,0,any,1
+lambda.r,has_variant,3,0,0,any,1
+lambda.r,idx_ellipsis,-1,0,0,integer[],1
+lambda.r,idx_ellipsis,0,0,0,list<class<`data.frame`> | character[]>,1
+lambda.r,idx_ellipsis,0,0,1,list<class<`data.frame`> | class<`function`> | character>,1
+lambda.r,idx_ellipsis,0,0,2,list<null | character[]>,1
+lambda.r,idx_ellipsis,0,0,3,list<null | class<`function`> | character>,1
+lambda.r,init_function,-1,0,0,"class<`function`, `lambdar.fun`>",1
+lambda.r,init_function,-1,0,1,"class<`function`, `lambdar.type`>",1
+lambda.r,init_function,0,0,0,character,1
+lambda.r,init_function,1,0,0,environment,1
+lambda.r,%isa%,-1,0,0,logical,1
+lambda.r,%isa%,0,0,0,double,1
+lambda.r,%isa%,1,0,0,any,1
+lambda.r,is.bound,-1,0,0,logical,1
+lambda.r,is.bound,0,0,0,character,1
+lambda.r,is.infix,-1,0,0,logical,1
+lambda.r,is.infix,0,0,0,character,1
+lambda.r,.is.simple,-1,0,0,logical,1
+lambda.r,.is.simple,0,0,0,character,1
+lambda.r,.is.simple,0,0,1,class<`matrix`>,1
+lambda.r,.is.simple,0,0,2,"class<`Prices`, `numeric`>",1
+lambda.r,.is.simple,0,0,3,double,1
+lambda.r,is.type,-1,0,0,logical,1
+lambda.r,is.type,0,0,0,character,1
+lambda.r,iterator,-1,0,0,class<`function`>,1
+lambda.r,iterator,0,0,0,class<`data.frame`>,1
+lambda.r,NewObject,-1,0,0,any,1
+lambda.r,NewObject,0,0,0,any,1
+lambda.r,NewObject,1,0,0,character,1
+lambda.r,NewObject,2,0,0,...,1
+lambda.r,parse_body,-1,0,0,class<`data.frame`>,1
+lambda.r,parse_body,0,0,0,class<`function`>,1
+lambda.r,parse_eval,-1,0,0,class<`data.frame`>,1
+lambda.r,parse_eval,0,0,0,class<`function`>,1
+lambda.r,parse_eval,1,0,0,null,1
+lambda.r,parse_fun,-1,0,0,class<`data.frame`>,1
+lambda.r,parse_fun,0,0,0,class<`function`>,1
+lambda.r,parse_fun,1,0,0,null,1
+lambda.r,parse_guard,-1,0,0,class<`data.frame`>,1
+lambda.r,parse_guard,-1,0,1,null,1
+lambda.r,parse_guard,0,0,0,class<`function`>,1
+lambda.r,parse_infix,-1,0,0,class<`data.frame`>,1
+lambda.r,parse_infix,-1,0,1,null,1
+lambda.r,parse_infix,0,0,0,class<`data.frame`>,1
+lambda.r,parse_types,-1,0,0,class<`data.frame`>,1
+lambda.r,parse_types,0,0,0,class<`function`>,1
+lambda.r,parse_types,1,0,0,class<`data.frame`>,1
+lambda.r,parse_types,1,0,1,null,1
+lambda.r,parse_types,2,0,0,any,1
+lambda.r,print.lambdar.fun,-1,0,0,null,1
+lambda.r,print.lambdar.fun,0,0,0,"class<`function`, `lambdar.fun`>",1
+lambda.r,print.lambdar.fun,1,0,0,...,1
+lambda.r,return_type,-1,0,0,character,1
+lambda.r,return_type,0,0,0,list<class<`data.frame`> | character | integer[]>,1
+lambda.r,return_type,1,0,0,list<character>,1
+lambda.r,return_type,1,0,1,list<double>,1
+lambda.r,return_type,1,0,2,list<class<`function`> | double>,1
+lambda.r,return_type,1,0,3,"list<class<`Integer`, `numeric`>>",1
+lambda.r,return_type,1,0,4,"list<class<`WholeNumber`, `numeric`>>",1
+lambda.r,return_type,1,0,5,list<character | double>,1
+lambda.r,return_type,1,0,6,"list<class<`A`, `Base`, `numeric`>>",1
+lambda.r,return_type,1,0,7,"list<class<`A`, `Base`, `numeric`> | class<`A`, `B`, `Base`, `numeric`>>",1
+lambda.r,return_type,1,0,8,"list<class<`A`, `B`, `Base`, `numeric`>>",1
+lambda.r,return_type,1,0,9,"list<class<`Base`, `E`, `numeric`>>",1
+lambda.r,return_type,1,0,10,"list<class<`Base`, `E`, `numeric`> | class<`A`, `B`, `Base`, `numeric`>>",1
+lambda.r,return_type,1,0,11,list<class<`function`>>,1
+lambda.r,return_type,1,0,12,"list<class<`Temperature`, `numeric`>>",1
+lambda.r,return_type,1,0,13,"list<double | class<`GradientDescent`, `list`>>",1
+lambda.r,return_type,1,0,14,"list<double | class<`NewtonRaphson`, `list`>>",1
+lambda.r,return_type,1,0,15,list<double | class<`function`>>,1
+lambda.r,return_type,2,0,0,any,1
+lambda.r,seal,-1,0,0,null,1
+lambda.r,seal,0,0,0,"class<`function`, `lambdar.fun`>",1
+lambda.r,seal,0,0,1,"class<`function`, `lambdar.type`>",1
+lambda.r,setup_parent,-1,0,0,"class<`function`, `lambdar.fun`>",1
+lambda.r,setup_parent,-1,0,1,"class<`function`, `lambdar.type`>",1
+lambda.r,setup_parent,-1,0,2,null,1
+lambda.r,setup_parent,0,0,0,character,1
+lambda.r,setup_parent,1,0,0,environment,1
+lambda.r,strip_ellipsis,-1,0,0,character,1
+lambda.r,strip_ellipsis,0,0,0,character,1
+lambda.r,.sync_debug,-1,0,0,null,1
+lambda.r,.sync_debug,0,0,0,any,1
+lambda.r,target_env,-1,0,0,environment,1
+lambda.r,target_env,0,0,0,class<`call`>,1
+lambda.r,target_env,1,0,0,integer,1
+lambda.r,transform_attrs,-1,0,0,class<`data.frame`>,1
+lambda.r,transform_attrs,-1,0,1,null,1
+lambda.r,transform_attrs,0,0,0,class<`data.frame`>,1
+lambda.r,transform_attrs,0,0,1,null,1
+lambda.r,update_type_map,-1,0,0,list<character[]>,1
+lambda.r,update_type_map,0,0,0,list<any>,1
+lambda.r,update_type_map,1,0,0,character,1
+lambda.r,update_type_map,2,0,0,any,1
+lambda.r,use_error,-1,0,0,character,1
+lambda.r,use_error,0,0,0,character,1
+lambda.r,use_error,1,0,0,character,1
+lambda.r,use_error,2,0,0,list<character>,1
+lambda.r,use_error,2,0,1,list<class<`matrix`>>,1
+lambda.r,use_error,2,0,2,"list<class<`Prices`, `numeric`>>",1
+lambda.r,use_error,2,0,3,list<double>,1
+lambda.r,UseFunction,-1,0,0,any,1
+lambda.r,UseFunction,0,0,0,any,1
+lambda.r,UseFunction,1,0,0,character,1
+lambda.r,UseFunction,2,0,0,...,1
+lars,backsolvet,-1,0,0,double[],1
+lars,backsolvet,0,0,0,class<`matrix`>,1
+lars,backsolvet,1,0,0,double[],1
+lars,backsolvet,2,0,0,integer,1
+lars,betabreaker,-1,0,0,class<`matrix`>,1
+lars,betabreaker,0,0,0,class<`lars`>,1
+lars,coef.lars,-1,0,0,double[],1
+lars,coef.lars,0,0,0,class<`lars`>,1
+lars,coef.lars,1,0,0,...,1
+lars,cv.folds,-1,0,0,list<integer[]>,1
+lars,cv.folds,0,0,0,integer,1
+lars,cv.folds,1,0,0,double,1
+lars,cv.lars,-1,0,0,list<double[] | character>,1
+lars,cv.lars,0,0,0,class<`AsIs`>,1
+lars,cv.lars,1,0,0,double[],1
+lars,cv.lars,2,0,0,double,1
+lars,cv.lars,3,0,0,any,1
+lars,cv.lars,4,0,0,logical,1
+lars,cv.lars,5,0,0,logical,1
+lars,cv.lars,6,0,0,logical,1
+lars,cv.lars,7,0,0,character[],1
+lars,delcol,-1,0,0,list<class<`matrix`>>,1
+lars,delcol,0,0,0,class<`matrix`>,1
+lars,delcol,1,0,0,double[],1
+lars,delcol,2,0,0,integer,1
+lars,downdateR,-1,0,0,class<`matrix`>,1
+lars,downdateR,0,0,0,class<`matrix`>,1
+lars,downdateR,1,0,0,integer,1
+lars,error.bars,-1,0,0,double[],1
+lars,error.bars,0,0,0,double[],1
+lars,error.bars,1,0,0,double[],1
+lars,error.bars,2,0,0,double[],1
+lars,error.bars,3,0,0,double,1
+lars,error.bars,4,0,0,...,1
+lars,lars,-1,0,0,class<`lars`>,1
+lars,lars,0,0,0,class<`AsIs`>,1
+lars,lars,1,0,0,double[],1
+lars,lars,2,0,0,character[],1
+lars,lars,3,0,0,logical,1
+lars,lars,4,0,0,logical,1
+lars,lars,5,0,0,logical,1
+lars,lars,6,0,0,any,1
+lars,lars,7,0,0,double,1
+lars,nnls.lars,-1,0,0,list<class<`matrix`> | double[]>,1
+lars,nnls.lars,0,0,0,integer[],1
+lars,nnls.lars,1,0,0,double[],1
+lars,nnls.lars,2,0,0,class<`matrix`>,1
+lars,nnls.lars,3,0,0,double[],1
+lars,nnls.lars,4,0,0,class<`matrix`>,1
+lars,nnls.lars,5,0,0,any,1
+lars,nnls.lars,6,0,0,logical,1
+lars,nnls.lars,7,0,0,logical,1
+lars,plotCVLars,-1,0,0,null,1
+lars,plotCVLars,0,0,0,list<double[] | character>,1
+lars,plotCVLars,1,0,0,logical,1
+lars,plot.lars,-1,0,0,null,1
+lars,plot.lars,0,0,0,class<`lars`>,1
+lars,plot.lars,1,0,0,character[],1
+lars,plot.lars,2,0,0,logical,1
+lars,plot.lars,3,0,0,character[],1
+lars,plot.lars,4,0,0,logical,1
+lars,plot.lars,5,0,0,double,1
+lars,plot.lars,6,0,0,...,1
+lars,predict.lars,-1,0,0,list<double[] | character | class<`matrix`>>,1
+lars,predict.lars,-1,0,1,list<character | double[]>,1
+lars,predict.lars,0,0,0,class<`lars`>,1
+lars,predict.lars,1,0,0,any,1
+lars,predict.lars,2,0,0,any,1
+lars,predict.lars,3,0,0,character[],1
+lars,predict.lars,4,0,0,character[],1
+lars,predict.lars,5,0,0,...,1
+lars,summary.lars,-1,0,0,"class<`anova`, `data.frame`>",1
+lars,summary.lars,0,0,0,class<`lars`>,1
+lars,summary.lars,1,0,0,null,1
+lars,summary.lars,2,0,0,...,1
+lars,updateR,-1,0,0,class<`matrix`>,1
+lars,updateR,0,0,0,double,1
+lars,updateR,1,0,0,class<`matrix`>,1
+lars,updateR,1,0,1,null,1
+lars,updateR,2,0,0,any,1
+lars,updateR,3,0,0,any,1
+lars,updateR,4,0,0,logical,1
+later,createCallbackRegistry,-1,0,0,logical,1
+later,createCallbackRegistry,0,0,0,integer,1
+later,create_canceller,-1,0,0,class<`function`>,1
+later,create_canceller,0,0,0,any,1
+later,create_canceller,1,0,0,any,1
+later,create_loop,-1,0,0,class<`event_loop`>,1
+later,create_loop,0,0,0,logical,1
+later,current_loop,-1,0,0,class<`event_loop`>,1
+later,ensureInitialized,-1,0,0,null,1
+later,execLater,-1,0,0,character,1
+later,execLater,0,0,0,class<`function`>,1
+later,execLater,0,0,1,"class<`function`, `rlang_lambda_function`>",1
+later,execLater,1,0,0,double,1
+later,execLater,2,0,0,integer,1
+later,later,-1,0,0,class<`function`>,1
+later,later,0,0,0,class<`formula`>,1
+later,later,0,0,1,class<`function`>,1
+later,later,1,0,0,double,1
+later,later,2,0,0,class<`event_loop`>,1
+lattice,as.character.shingleLevel,-1,0,0,character[],1
+lattice,as.character.shingleLevel,0,0,0,class<`shingleLevel`>,1
+lattice,as.character.shingleLevel,1,0,0,...,1
+lattice,as.factorOrShingle,-1,0,0,class<`factor`>,1
+lattice,as.factorOrShingle,-1,0,1,class<`shingle`>,1
+lattice,as.factorOrShingle,0,0,0,character[],1
+lattice,as.factorOrShingle,0,0,1,class<`factor`>,1
+lattice,as.factorOrShingle,0,0,2,class<`shingle`>,1
+lattice,as.factorOrShingle,0,0,3,double[],1
+lattice,as.factorOrShingle,0,0,4,null,1
+lattice,as.factorOrShingle,1,0,0,integer[],1
+lattice,as.factorOrShingle,2,0,0,logical,1
+lattice,as.shingle,-1,0,0,class<`shingle`>,1
+lattice,as.shingle,0,0,0,class<`shingle`>,1
+lattice,as.shingle,0,0,1,double[],1
+lattice,as.shingle,0,0,2,null,1
+lattice,barchart,-1,0,0,class<`trellis`>,1
+lattice,barchart,0,0,0,class<`formula`>,1
+lattice,barchart,0,0,1,class<`array`>,1
+lattice,barchart,0,0,2,class<`matrix`>,1
+lattice,barchart,0,0,3,class<`table`>,1
+lattice,barchart,0,0,4,double[],1
+lattice,barchart,1,0,0,any,1
+lattice,barchart,2,0,0,...,1
+lattice,barchart.array,-1,0,0,class<`trellis`>,1
+lattice,barchart.array,0,0,0,class<`array`>,1
+lattice,barchart.array,0,0,1,class<`matrix`>,1
+lattice,barchart.array,1,0,0,null,1
+lattice,barchart.array,2,0,0,...,1
+lattice,barchart.formula,-1,0,0,class<`trellis`>,1
+lattice,barchart.formula,0,0,0,class<`formula`>,1
+lattice,barchart.formula,1,0,0,class<`data.frame`>,1
+lattice,barchart.formula,1,0,1,environment,1
+lattice,barchart.formula,1,0,2,list<integer[] | class<`factor`>>,1
+lattice,barchart.formula,2,0,0,character,1
+lattice,barchart.formula,3,0,0,character,1
+lattice,barchart.formula,4,0,0,double,1
+lattice,barchart.formula,5,0,0,...,1
+lattice,barchart.matrix,-1,0,0,class<`trellis`>,1
+lattice,barchart.matrix,0,0,0,class<`array`>,1
+lattice,barchart.matrix,0,0,1,class<`matrix`>,1
+lattice,barchart.matrix,1,0,0,null,1
+lattice,barchart.matrix,2,0,0,...,1
+lattice,barchart.numeric,-1,0,0,class<`trellis`>,1
+lattice,barchart.numeric,0,0,0,double[],1
+lattice,barchart.numeric,1,0,0,null,1
+lattice,barchart.numeric,2,0,0,character,1
+lattice,barchart.numeric,3,0,0,...,1
+lattice,barchart.table,-1,0,0,class<`trellis`>,1
+lattice,barchart.table,0,0,0,class<`table`>,1
+lattice,barchart.table,1,0,0,null,1
+lattice,barchart.table,2,0,0,logical,1
+lattice,barchart.table,3,0,0,double,1
+lattice,barchart.table,4,0,0,logical,1
+lattice,barchart.table,5,0,0,...,1
+lattice,barchart.table,6,0,0,logical,1
+lattice,bwplot,-1,0,0,class<`trellis`>,1
+lattice,bwplot,0,0,0,class<`formula`>,1
+lattice,bwplot,0,0,1,double[],1
+lattice,bwplot,1,0,0,any,1
+lattice,bwplot,2,0,0,...,1
+lattice,bwplot.formula,-1,0,0,class<`trellis`>,1
+lattice,bwplot.formula,0,0,0,class<`formula`>,1
+lattice,bwplot.formula,1,0,0,class<`data.frame`>,1
+lattice,bwplot.formula,1,0,1,environment,1
+lattice,bwplot.formula,1,0,2,null,1
+lattice,bwplot.formula,1,0,3,list<integer[] | class<`factor`>>,1
+lattice,bwplot.formula,1,0,4,list<integer[]>,1
+lattice,bwplot.formula,1,0,5,list<double[] | class<`shingle`> | class<`factor`>>,1
+lattice,bwplot.formula,2,0,0,logical,1
+lattice,bwplot.formula,3,0,0,logical,1
+lattice,bwplot.formula,4,0,0,logical,1
+lattice,bwplot.formula,4,0,1,list<character>,1
+lattice,bwplot.formula,4,0,2,list<double>,1
+lattice,bwplot.formula,5,0,0,character,1
+lattice,bwplot.formula,5,0,1,double,1
+lattice,bwplot.formula,6,0,0,character,1
+lattice,bwplot.formula,6,0,1,class<`function`>,1
+lattice,bwplot.formula,7,0,0,null,1
+lattice,bwplot.numeric,-1,0,0,class<`trellis`>,1
+lattice,bwplot.numeric,0,0,0,double[],1
+lattice,bwplot.numeric,1,0,0,null,1
+lattice,bwplot.numeric,2,0,0,character,1
+lattice,bwplot.numeric,3,0,0,...,1
+lattice,calculateAxisComponents,-1,0,0,list<double[] | character[]>,1
+lattice,calculateAxisComponents,-1,0,1,list<character[] | double[]>,1
+lattice,calculateAxisComponents,0,0,0,double[],1
+lattice,calculateAxisComponents,1,0,0,...,1
+lattice,calculateAxisComponents,2,0,0,any,1
+lattice,calculateAxisComponents,3,0,0,any,1
+lattice,calculateAxisComponents,4,0,0,logical,1
+lattice,calculateAxisComponents,4,0,1,null,1
+lattice,calculateAxisComponents,5,0,0,any,1
+lattice,calculateGridLayout,-1,0,0,list<class<`layout`> | list<double[]>>,1
+lattice,calculateGridLayout,0,0,0,class<`trellis`>,1
+lattice,calculateGridLayout,1,0,0,double,1
+lattice,calculateGridLayout,2,0,0,double,1
+lattice,calculateGridLayout,3,0,0,any,1
+lattice,calculateGridLayout,4,0,0,list<double | character | null>,1
+lattice,calculateGridLayout,5,0,0,list<double | character | null>,1
+lattice,calculateGridLayout,6,0,0,null,1
+lattice,calculateGridLayout,6,0,1,"class<`gDesc`, `grob`, `text`>",1
+lattice,calculateGridLayout,7,0,0,null,1
+lattice,canonical.theme,-1,0,0,list<list<any>>,1
+lattice,canonical.theme,0,0,0,any,1
+lattice,canonical.theme,1,0,0,logical,1
+lattice,checkArgsAndCall,-1,0,0,"class<`gDesc`, `grob`, `rect`>",1
+lattice,checkArgsAndCall,-1,0,1,"class<`path`, `vpPath`>",1
+lattice,checkArgsAndCall,-1,0,2,double[],1
+lattice,checkArgsAndCall,-1,0,3,null,1
+lattice,checkArgsAndCall,0,0,0,class<`function`>,1
+lattice,checkArgsAndCall,1,0,0,list<any>,1
+lattice,chooseFace,-1,0,0,double,1
+lattice,chooseFace,0,0,0,null,1
+lattice,chooseFace,1,0,0,double,1
+lattice,cloud,-1,0,0,class<`trellis`>,1
+lattice,cloud,0,0,0,class<`formula`>,1
+lattice,cloud,0,0,1,class<`matrix`>,1
+lattice,cloud,0,0,2,class<`table`>,1
+lattice,cloud,1,0,0,any,1
+lattice,cloud,2,0,0,...,1
+lattice,cloud.formula,-1,0,0,class<`trellis`>,1
+lattice,cloud.formula,0,0,0,class<`formula`>,1
+lattice,cloud.formula,1,0,0,class<`data.frame`>,1
+lattice,cloud.formula,1,0,1,null,1
+lattice,cloud.formula,2,0,0,logical,1
+lattice,cloud.formula,3,0,0,logical,1
+lattice,cloud.formula,4,0,0,logical,1
+lattice,cloud.formula,5,0,0,double[],1
+lattice,cloud.formula,6,0,0,double,1
+lattice,cloud.formula,7,0,0,character,1
+lattice,cloud.matrix,-1,0,0,class<`trellis`>,1
+lattice,cloud.matrix,0,0,0,class<`matrix`>,1
+lattice,cloud.matrix,1,0,0,null,1
+lattice,cloud.matrix,2,0,0,character,1
+lattice,cloud.matrix,3,0,0,character,1
+lattice,cloud.matrix,4,0,0,any,1
+lattice,cloud.matrix,5,0,0,...,1
+lattice,cloud.matrix,6,0,0,any,1
+lattice,cloud.matrix,7,0,0,any,1
+lattice,cloud.table,-1,0,0,class<`trellis`>,1
+lattice,cloud.table,0,0,0,class<`table`>,1
+lattice,cloud.table,1,0,0,null,1
+lattice,cloud.table,2,0,0,logical,1
+lattice,cloud.table,3,0,0,character,1
+lattice,cloud.table,4,0,0,character[],1
+lattice,cloud.table,5,0,0,...,1
+lattice,complete_names,-1,0,0,list<double>,1
+lattice,complete_names,-1,0,1,list<double | character>,1
+lattice,complete_names,-1,0,2,list<double | integer[] | character[]>,1
+lattice,complete_names,-1,0,3,list<class<`Date`>>,1
+lattice,complete_names,-1,0,4,list<double[] | character[]>,1
+lattice,complete_names,-1,0,5,list<logical | character>,1
+lattice,complete_names,-1,0,6,list<character | double>,1
+lattice,complete_names,-1,0,7,list<character | list<double[]>>,1
+lattice,complete_names,-1,0,8,list<character>,1
+lattice,complete_names,-1,0,9,list<character | double[]>,1
+lattice,complete_names,-1,0,10,list<character | list<double[] | character[] | double[] | character[] | double[]>>,1
+lattice,complete_names,-1,0,11,list<character | list<double[] | character[] | double[] | character[] | logical>>,1
+lattice,complete_names,-1,0,12,list<character | double[] | list<double[]>>,1
+lattice,complete_names,-1,0,13,list<character | list<double[] | character[] | double[]>>,1
+lattice,complete_names,-1,0,14,list<character | double | list<double[] | character[] | double[] | character[]>>,1
+lattice,complete_names,-1,0,15,list<double | character | list<logical | null>>,1
+lattice,complete_names,0,0,0,list<double>,1
+lattice,complete_names,0,0,1,list<double | character>,1
+lattice,complete_names,0,0,2,list<double | integer[] | character[]>,1
+lattice,complete_names,0,0,3,list<class<`Date`>>,1
+lattice,complete_names,0,0,4,list<double[] | character[]>,1
+lattice,complete_names,0,0,5,list<logical | character>,1
+lattice,complete_names,0,0,6,list<character | double>,1
+lattice,complete_names,0,0,7,list<character | list<double[]>>,1
+lattice,complete_names,0,0,8,list<character>,1
+lattice,complete_names,0,0,9,list<character | double[]>,1
+lattice,complete_names,0,0,10,list<character | list<double[] | character[] | double[] | character[] | double[]>>,1
+lattice,complete_names,0,0,11,list<character | list<double[] | character[] | double[] | character[] | logical>>,1
+lattice,complete_names,0,0,12,list<character | double[] | list<double[]>>,1
+lattice,complete_names,0,0,13,list<character | list<double[] | character[] | double[]>>,1
+lattice,complete_names,0,0,14,list<character | double | list<double[] | character[] | double[] | character[]>>,1
+lattice,complete_names,0,0,15,list<double | character | list<logical | null>>,1
+lattice,complete_names,1,0,0,list<character | double | null>,1
+lattice,complete_names,2,0,0,logical,1
+lattice,compute.layout,-1,0,0,double[],1
+lattice,compute.layout,0,0,0,double[],1
+lattice,compute.layout,0,0,1,null,1
+lattice,compute.layout,1,0,0,integer[],1
+lattice,compute.layout,2,0,0,logical,1
+lattice,compute.packet,-1,0,0,logical[],1
+lattice,compute.packet,0,0,0,list<class<`factor`>>,1
+lattice,compute.packet,0,0,1,list<class<`shingle`>>,1
+lattice,compute.packet,0,0,2,list<class<`shingle`> | class<`factor`>>,1
+lattice,compute.packet,0,0,3,list<class<`factor`> | class<`shingle`>>,1
+lattice,compute.packet,1,0,0,double[],1
+lattice,cond.orders,-1,0,0,list<integer[] | list<integer[]>>,1
+lattice,cond.orders,-1,0,1,list<integer | list<integer[]>>,1
+lattice,cond.orders,-1,0,2,list<integer | list<integer>>,1
+lattice,cond.orders,0,0,0,list<any>,1
+lattice,cond.orders,0,0,1,class<`trellis`>,1
+lattice,cond.orders,1,0,0,...,1
+lattice,construct.legend,-1,0,0,null,1
+lattice,construct.legend,-1,0,1,"list<list<character | double | list<logical | list<double | list<integer[]>>> | class<`gDesc`, `grob`, `text`>>>",1
+lattice,construct.legend,-1,0,2,list<list<character | list<logical | list<double[] | character[]>>>>,1
+lattice,construct.legend,-1,0,3,list<list<character | list<logical | list<double[] | character | class<`function`>>>>>,1
+lattice,construct.legend,-1,0,4,"list<list<character | list<logical | list<double[] | character>> | character | double | list<logical | list<double | list<integer[]>>> | class<`gDesc`, `grob`, `text`>>>",1
+lattice,construct.legend,-1,0,5,list<list<character | list<logical | list<double[] | character>>>>,1
+lattice,construct.legend,-1,0,6,list<list<character | list<logical | list<character | double[]>>>>,1
+lattice,construct.legend,-1,0,7,list<list<character | list<logical | list<any>>>>,1
+lattice,construct.legend,-1,0,8,list<list<character | list<logical | list<double | list<character[] | double[] | character[]>>>>>,1
+lattice,construct.legend,-1,0,9,list<list<character | list<logical | list<character | double | list<double[] | character[] | character[]>>>>>,1
+lattice,construct.legend,0,0,0,null,1
+lattice,construct.legend,0,0,1,"list<list<class<`gDesc`, `grob`, `text`>>>",1
+lattice,construct.legend,0,0,2,"list<list<character | double | list<logical | list<double | list<integer[]>>> | class<`gDesc`, `grob`, `text`>>>",1
+lattice,construct.legend,1,0,0,null,1
+lattice,construct.legend,1,0,1,list<any>,1
+lattice,construct.legend,2,0,0,character,1
+lattice,construct.scales,-1,0,0,any,1
+lattice,construct.scales,0,0,0,logical,1
+lattice,construct.scales,1,0,0,character,1
+lattice,construct.scales,2,0,0,double[],1
+lattice,construct.scales,3,0,0,double,1
+lattice,construct.scales,4,0,0,logical,1
+lattice,construct.scales,5,0,0,logical,1
+lattice,construct.scales,6,0,0,logical,1
+lattice,construct.scales,6,0,1,character,1
+lattice,construct.scales,7,0,0,double[],1
+lattice,contourplot,-1,0,0,class<`trellis`>,1
+lattice,contourplot,0,0,0,class<`formula`>,1
+lattice,contourplot,1,0,0,class<`data.frame`>,1
+lattice,contourplot,2,0,0,...,1
+lattice,contourplot.formula,-1,0,0,class<`trellis`>,1
+lattice,contourplot.formula,0,0,0,class<`formula`>,1
+lattice,contourplot.formula,1,0,0,class<`data.frame`>,1
+lattice,contourplot.formula,2,0,0,character,1
+lattice,contourplot.formula,2,0,1,class<`function`>,1
+lattice,contourplot.formula,3,0,0,any,1
+lattice,contourplot.formula,4,0,0,double,1
+lattice,contourplot.formula,5,0,0,logical,1
+lattice,contourplot.formula,6,0,0,logical,1
+lattice,contourplot.formula,7,0,0,logical,1
+lattice,cupdate,-1,0,0,double[],1
+lattice,cupdate,0,0,0,double[],1
+lattice,cupdate,1,0,0,integer[],1
+lattice,current.column,-1,0,0,integer,1
+lattice,current.column,0,0,0,character,1
+lattice,current.panel.limits,-1,0,0,list<double[]>,1
+lattice,current.panel.limits,0,0,0,character,1
+lattice,current.row,-1,0,0,integer,1
+lattice,current.row,0,0,0,character,1
+lattice,.defaultLatticeOptions,-1,0,0,list<any>,1
+lattice,.defaultLatticePrefixStatus,-1,0,0,list<double>,1
+lattice,.defaultLatticeStatus,-1,0,0,list<double>,1
+lattice,densityplot,-1,0,0,class<`trellis`>,1
+lattice,densityplot,0,0,0,class<`formula`>,1
+lattice,densityplot,0,0,1,double[],1
+lattice,densityplot,1,0,0,any,1
+lattice,densityplot,2,0,0,...,1
+lattice,densityplot.formula,-1,0,0,class<`trellis`>,1
+lattice,densityplot.formula,0,0,0,class<`formula`>,1
+lattice,densityplot.formula,1,0,0,class<`data.frame`>,1
+lattice,densityplot.formula,1,0,1,environment,1
+lattice,densityplot.formula,1,0,2,null,1
+lattice,densityplot.formula,1,0,3,list<integer[] | class<`factor`>>,1
+lattice,densityplot.formula,2,0,0,logical,1
+lattice,densityplot.formula,3,0,0,logical,1
+lattice,densityplot.formula,4,0,0,logical,1
+lattice,densityplot.formula,5,0,0,character,1
+lattice,densityplot.formula,6,0,0,character,1
+lattice,densityplot.formula,7,0,0,null,1
+lattice,densityplot.numeric,-1,0,0,class<`trellis`>,1
+lattice,densityplot.numeric,0,0,0,double[],1
+lattice,densityplot.numeric,1,0,0,null,1
+lattice,densityplot.numeric,2,0,0,character,1
+lattice,densityplot.numeric,3,0,0,...,1
+lattice,do.breaks,-1,0,0,double[],1
+lattice,do.breaks,0,0,0,double[],1
+lattice,do.breaks,1,0,0,double,1
+lattice,dotplot,-1,0,0,class<`trellis`>,1
+lattice,dotplot,0,0,0,class<`formula`>,1
+lattice,dotplot,0,0,1,class<`array`>,1
+lattice,dotplot,0,0,2,class<`matrix`>,1
+lattice,dotplot,0,0,3,class<`table`>,1
+lattice,dotplot,0,0,4,double[],1
+lattice,dotplot,1,0,0,any,1
+lattice,dotplot,2,0,0,...,1
+lattice,dotplot.array,-1,0,0,class<`trellis`>,1
+lattice,dotplot.array,0,0,0,class<`array`>,1
+lattice,dotplot.array,0,0,1,class<`matrix`>,1
+lattice,dotplot.array,1,0,0,null,1
+lattice,dotplot.array,2,0,0,...,1
+lattice,dotplot.formula,-1,0,0,class<`trellis`>,1
+lattice,dotplot.formula,0,0,0,class<`formula`>,1
+lattice,dotplot.formula,1,0,0,class<`data.frame`>,1
+lattice,dotplot.formula,1,0,1,environment,1
+lattice,dotplot.formula,1,0,2,list<integer[] | class<`factor`>>,1
+lattice,dotplot.formula,1,0,3,list<integer[]>,1
+lattice,dotplot.formula,1,0,4,list<double[] | class<`shingle`> | class<`factor`>>,1
+lattice,dotplot.formula,2,0,0,character,1
+lattice,dotplot.formula,3,0,0,character,1
+lattice,dotplot.formula,4,0,0,...,1
+lattice,dotplot.matrix,-1,0,0,class<`trellis`>,1
+lattice,dotplot.matrix,0,0,0,class<`array`>,1
+lattice,dotplot.matrix,0,0,1,class<`matrix`>,1
+lattice,dotplot.matrix,1,0,0,null,1
+lattice,dotplot.matrix,2,0,0,...,1
+lattice,dotplot.numeric,-1,0,0,class<`trellis`>,1
+lattice,dotplot.numeric,0,0,0,double[],1
+lattice,dotplot.numeric,1,0,0,null,1
+lattice,dotplot.numeric,2,0,0,character,1
+lattice,dotplot.numeric,3,0,0,...,1
+lattice,dotplot.table,-1,0,0,class<`trellis`>,1
+lattice,dotplot.table,0,0,0,class<`table`>,1
+lattice,dotplot.table,1,0,0,null,1
+lattice,dotplot.table,2,0,0,logical,1
+lattice,dotplot.table,3,0,0,...,1
+lattice,dotplot.table,4,0,0,logical,1
+lattice,drawInViewport,-1,0,0,"class<`path`, `vpPath`>",1
+lattice,drawInViewport,0,0,0,"class<`frame`, `gDesc`, `gTree`, `grob`>",1
+lattice,drawInViewport,0,0,1,"class<`gDesc`, `grob`, `text`>",1
+lattice,drawInViewport,1,0,0,class<`viewport`>,1
+lattice,equal.count,-1,0,0,class<`shingle`>,1
+lattice,equal.count,0,0,0,double[],1
+lattice,equal.count,0,0,1,class<`ts`>,1
+lattice,equal.count,1,0,0,...,1
+lattice,evaluate.legend,-1,0,0,null,1
+lattice,evaluate.legend,-1,0,1,"list<list<class<`frame`, `gDesc`, `gTree`, `grob`>>>",1
+lattice,evaluate.legend,0,0,0,null,1
+lattice,evaluate.legend,0,0,1,list<list<character | list<logical | list<double[] | character>>>>,1
+lattice,experimentalOptions,-1,0,0,list<list<list<double | character | null>>>,1
+lattice,extend.limits,-1,0,0,"class<`POSIXct`, `POSIXt`>",1
+lattice,extend.limits,-1,0,1,double[],1
+lattice,extend.limits,-1,0,2,null,1
+lattice,extend.limits,0,0,0,"class<`POSIXct`, `POSIXt`>",1
+lattice,extend.limits,0,0,1,character[],1
+lattice,extend.limits,0,0,2,^double[],1
+lattice,extend.limits,1,0,0,any,1
+lattice,extend.limits,2,0,0,any,1
+lattice,extend.limits,3,0,0,any,1
+lattice,formattedTicksAndLabels,-1,0,0,list<double[] | character[]>,1
+lattice,formattedTicksAndLabels,-1,0,1,list<character[] | double[]>,1
+lattice,formattedTicksAndLabels,0,0,0,double[],1
+lattice,formattedTicksAndLabels,1,0,0,...,1
+lattice,formattedTicksAndLabels.default,-1,0,0,list<double[] | character[]>,1
+lattice,formattedTicksAndLabels.default,-1,0,1,list<character[] | double[]>,1
+lattice,formattedTicksAndLabels.default,0,0,0,double[],1
+lattice,formattedTicksAndLabels.default,1,0,0,logical,1
+lattice,formattedTicksAndLabels.default,2,0,0,any,1
+lattice,formattedTicksAndLabels.default,3,0,0,logical,1
+lattice,formattedTicksAndLabels.default,4,0,0,logical,1
+lattice,formattedTicksAndLabels.default,5,0,0,...,1
+lattice,formattedTicksAndLabels.default,6,0,0,any,1
+lattice,formattedTicksAndLabels.default,7,0,0,null,1
+lattice,getFunctionOrName,-1,0,0,class<`function`>,1
+lattice,getFunctionOrName,-1,0,1,logical,1
+lattice,getFunctionOrName,-1,0,2,null,1
+lattice,getFunctionOrName,0,0,0,class<`function`>,1
+lattice,getFunctionOrName,0,0,1,character,1
+lattice,getFunctionOrName,0,0,2,logical,1
+lattice,getFunctionOrName,0,0,3,null,1
+lattice,getLabelList,-1,0,0,null,1
+lattice,getLabelList,-1,0,1,list<character | double>,1
+lattice,getLabelList,0,0,0,null,1
+lattice,getLabelList,0,0,1,character,1
+lattice,getLabelList,0,0,2,logical,1
+lattice,getLabelList,1,0,0,any,1
+lattice,getLabelList,2,0,0,any,1
+lattice,grobFromLabelList,-1,0,0,"class<`gDesc`, `grob`, `text`>",1
+lattice,grobFromLabelList,-1,0,1,null,1
+lattice,grobFromLabelList,0,0,0,list<character | double>,1
+lattice,grobFromLabelList,0,0,1,null,1
+lattice,grobFromLabelList,1,0,0,any,1
+lattice,grobFromLabelList,2,0,0,double,1
+lattice,hasGroupNumber,-1,0,0,logical,1
+lattice,hist.constructor,-1,0,0,class<`histogram`>,1
+lattice,hist.constructor,0,0,0,double[],1
+lattice,hist.constructor,1,0,0,double[],1
+lattice,hist.constructor,2,0,0,logical,1
+lattice,hist.constructor,3,0,0,logical,1
+lattice,hist.constructor,4,0,0,...,1
+lattice,histogram,-1,0,0,class<`trellis`>,1
+lattice,histogram,0,0,0,class<`formula`>,1
+lattice,histogram,1,0,0,any,1
+lattice,histogram,2,0,0,...,1
+lattice,histogram.formula,-1,0,0,class<`trellis`>,1
+lattice,histogram.formula,0,0,0,class<`formula`>,1
+lattice,histogram.formula,1,0,0,class<`data.frame`>,1
+lattice,histogram.formula,1,0,1,null,1
+lattice,histogram.formula,2,0,0,logical,1
+lattice,histogram.formula,3,0,0,logical,1
+lattice,histogram.formula,4,0,0,logical,1
+lattice,histogram.formula,5,0,0,character,1
+lattice,histogram.formula,5,0,1,double,1
+lattice,histogram.formula,6,0,0,character,1
+lattice,histogram.formula,6,0,1,class<`function`>,1
+lattice,histogram.formula,7,0,0,null,1
+lattice,is.characterOrExpression,-1,0,0,logical,1
+lattice,is.characterOrExpression,0,0,0,character,1
+lattice,is.characterOrExpression,0,0,1,logical,1
+lattice,is.shingle,-1,0,0,logical,1
+lattice,is.shingle,0,0,0,class<`AsIs`>,1
+lattice,is.shingle,0,0,1,^double[],1
+lattice,is.shingle,0,0,2,class<`by`>,1
+lattice,is.shingle,0,0,3,class<`Date`>,1
+lattice,is.shingle,0,0,4,class<`factor`>,1
+lattice,is.shingle,0,0,5,"class<`POSIXct`, `POSIXt`>",1
+lattice,is.shingle,0,0,6,class<`shingle`>,1
+lattice,is.shingle,0,0,7,class<`ts`>,1
+lattice,is.shingle,0,0,8,null,1
+lattice,larrows,-1,0,0,"class<`gDesc`, `grob`, `segments`>",1
+lattice,larrows,0,0,0,double,1
+lattice,larrows,1,0,0,double,1
+lattice,larrows,2,0,0,double,1
+lattice,larrows,3,0,0,double,1
+lattice,larrows,4,0,0,null,1
+lattice,larrows,5,0,0,null,1
+lattice,larrows,6,0,0,double,1
+lattice,larrows,7,0,0,double,1
+lattice,lattice.getOption,-1,0,0,character,1
+lattice,lattice.getOption,-1,0,1,class<`function`>,1
+lattice,lattice.getOption,-1,0,2,double,1
+lattice,lattice.getOption,-1,0,3,null,1
+lattice,lattice.getOption,-1,0,4,list<any>,1
+lattice,lattice.getOption,0,0,0,character,1
+lattice,lattice.getStatus,-1,0,0,character,1
+lattice,lattice.getStatus,-1,0,1,class<`matrix`>,1
+lattice,lattice.getStatus,-1,0,2,double[],1
+lattice,lattice.getStatus,-1,0,3,null,1
+lattice,lattice.getStatus,0,0,0,character,1
+lattice,lattice.getStatus,1,0,0,null,1
+lattice,lattice.getStatus,1,0,1,character,1
+lattice,lattice.options,-1,0,0,list<any>,1
+lattice,lattice.options,0,0,0,...,1
+lattice,latticeParseFormula,-1,0,0,list<any>,1
+lattice,latticeParseFormula,0,0,0,class<`formula`>,1
+lattice,latticeParseFormula,1,0,0,null,1
+lattice,latticeParseFormula,1,0,1,class<`data.frame`>,1
+lattice,latticeParseFormula,1,0,2,list<double[] | class<`shingle`> | class<`factor`>>,1
+lattice,latticeParseFormula,1,0,3,list<integer[] | class<`factor`>>,1
+lattice,latticeParseFormula,1,0,4,environment,1
+lattice,latticeParseFormula,1,0,5,list<double[] | character[]>,1
+lattice,latticeParseFormula,1,0,6,list<integer[]>,1
+lattice,latticeParseFormula,2,0,0,double,1
+lattice,latticeParseFormula,3,0,0,integer[],1
+lattice,latticeParseFormula,4,0,0,null,1
+lattice,latticeParseFormula,4,0,1,class<`factor`>,1
+lattice,latticeParseFormula,4,0,2,integer[],1
+lattice,latticeParseFormula,4,0,3,character[],1
+lattice,latticeParseFormula,5,0,0,logical,1
+lattice,latticeParseFormula,6,0,0,any,1
+lattice,latticeParseFormula,7,0,0,logical,1
+lattice,lattice.setStatus,-1,0,0,null,1
+lattice,lattice.setStatus,0,0,0,...,1
+lattice,lattice.setStatus,1,0,0,character,1
+lattice,lattice.setStatus,1,0,1,null,1
+lattice,lattice.setStatus,2,0,0,logical,1
+lattice,layoutNCol,-1,0,0,integer,1
+lattice,layoutNCol,0,0,0,class<`layout`>,1
+lattice,layoutNRow,-1,0,0,integer,1
+lattice,layoutNRow,0,0,0,class<`layout`>,1
+lattice,level.colors,-1,0,0,character[],1
+lattice,level.colors,0,0,0,double[],1
+lattice,level.colors,1,0,0,double[],1
+lattice,level.colors,2,0,0,character[],1
+lattice,level.colors,2,0,1,class<`function`>,1
+lattice,level.colors,3,0,0,logical,1
+lattice,level.colors,4,0,0,...,1
+lattice,levelplot,-1,0,0,class<`trellis`>,1
+lattice,levelplot,0,0,0,class<`formula`>,1
+lattice,levelplot,0,0,1,class<`matrix`>,1
+lattice,levelplot,1,0,0,any,1
+lattice,levelplot,2,0,0,...,1
+lattice,levelplot.formula,-1,0,0,class<`trellis`>,1
+lattice,levelplot.formula,0,0,0,class<`formula`>,1
+lattice,levelplot.formula,1,0,0,class<`data.frame`>,1
+lattice,levelplot.formula,1,0,1,null,1
+lattice,levelplot.formula,2,0,0,logical,1
+lattice,levelplot.formula,3,0,0,logical,1
+lattice,levelplot.formula,4,0,0,character,1
+lattice,levelplot.formula,4,0,1,double,1
+lattice,levelplot.formula,5,0,0,character,1
+lattice,levelplot.formula,5,0,1,class<`function`>,1
+lattice,levelplot.formula,6,0,0,null,1
+lattice,levelplot.formula,7,0,0,list<any>,1
+lattice,levelplot.matrix,-1,0,0,class<`trellis`>,1
+lattice,levelplot.matrix,0,0,0,class<`matrix`>,1
+lattice,levelplot.matrix,1,0,0,null,1
+lattice,levelplot.matrix,2,0,0,character,1
+lattice,levelplot.matrix,3,0,0,...,1
+lattice,levelplot.matrix,4,0,0,any,1
+lattice,levelplot.matrix,5,0,0,any,1
+lattice,levelplot.matrix,6,0,0,integer[],1
+lattice,levelplot.matrix,7,0,0,integer[],1
+lattice,limits.and.aspect,-1,0,0,any,1
+lattice,limits.and.aspect,0,0,0,character,1
+lattice,limits.and.aspect,1,0,0,null,1
+lattice,limits.and.aspect,1,0,1,class<`function`>,1
+lattice,limits.and.aspect,2,0,0,logical,1
+lattice,limits.and.aspect,3,0,0,any,1
+lattice,limits.and.aspect,4,0,0,any,1
+lattice,limits.and.aspect,5,0,0,any,1
+lattice,limits.and.aspect,6,0,0,character,1
+lattice,limits.and.aspect,7,0,0,any,1
+lattice,limitsFromLimitlist,-1,0,0,any,1
+lattice,limitsFromLimitlist,0,0,0,logical,1
+lattice,limitsFromLimitlist,1,0,0,any,1
+lattice,limitsFromLimitlist,2,0,0,character,1
+lattice,limitsFromLimitlist,3,0,0,list<character[]>,1
+lattice,limitsFromLimitlist,3,0,1,list<^double[] | character[]>,1
+lattice,limitsFromLimitlist,3,0,2,list<character | ^double[]>,1
+lattice,limitsFromLimitlist,3,0,3,list<class<`Date`>>,1
+lattice,limitsFromLimitlist,3,0,4,"list<class<`POSIXct`, `POSIXt`>>",1
+lattice,limitsFromLimitlist,3,0,5,list<^double[]>,1
+lattice,limitsFromLimitlist,4,0,0,any,1
+lattice,limitsFromLimitlist,5,0,0,any,1
+lattice,limitsFromLimitlist,6,0,0,any,1
+lattice,limitsFromLimitlist,7,0,0,any,1
+lattice,llines,-1,0,0,null,1
+lattice,llines,0,0,0,double[],1
+lattice,llines,1,0,0,...,1
+lattice,llines.default,-1,0,0,null,1
+lattice,llines.default,0,0,0,double[],1
+lattice,llines.default,1,0,0,double[],1
+lattice,llines.default,2,0,0,character,1
+lattice,llines.default,3,0,0,character,1
+lattice,llines.default,4,0,0,double,1
+lattice,llines.default,5,0,0,double,1
+lattice,llines.default,6,0,0,double,1
+lattice,llines.default,7,0,0,...,1
+lattice,lower.saturation,-1,0,0,character[],1
+lattice,lower.saturation,0,0,0,character[],1
+lattice,lower.saturation,1,0,0,double,1
+lattice,lplot.xy,-1,0,0,null,1
+lattice,lplot.xy,0,0,0,list<double[] | null>,1
+lattice,lplot.xy,0,0,1,list<double | null>,1
+lattice,lplot.xy,1,0,0,character,1
+lattice,lplot.xy,2,0,0,double[],1
+lattice,lplot.xy,3,0,0,double,1
+lattice,lplot.xy,4,0,0,character[],1
+lattice,lplot.xy,5,0,0,double[],1
+lattice,lplot.xy,6,0,0,double,1
+lattice,lplot.xy,7,0,0,double,1
+lattice,lpoints,-1,0,0,null,1
+lattice,lpoints,0,0,0,double[],1
+lattice,lpoints,1,0,0,...,1
+lattice,lpoints.default,-1,0,0,null,1
+lattice,lpoints.default,0,0,0,double[],1
+lattice,lpoints.default,1,0,0,double[],1
+lattice,lpoints.default,2,0,0,character,1
+lattice,lpoints.default,3,0,0,character[],1
+lattice,lpoints.default,4,0,0,double[],1
+lattice,lpoints.default,5,0,0,double,1
+lattice,lpoints.default,6,0,0,character,1
+lattice,lpoints.default,7,0,0,double,1
+lattice,lpretty,-1,0,0,double[],1
+lattice,lpretty,0,0,0,double[],1
+lattice,lpretty,1,0,0,...,1
+lattice,lrect,-1,0,0,"class<`gDesc`, `grob`, `rect`>",1
+lattice,lrect,0,0,0,any,1
+lattice,lrect,1,0,0,any,1
+lattice,lrect,2,0,0,any,1
+lattice,lrect,3,0,0,any,1
+lattice,lrect,4,0,0,double[],1
+lattice,lrect,5,0,0,double,1
+lattice,lrect,6,0,0,double[],1
+lattice,lrect,7,0,0,double[],1
+lattice,lsegments,-1,0,0,"class<`gDesc`, `grob`, `segments`>",1
+lattice,lsegments,0,0,0,double[],1
+lattice,lsegments,1,0,0,double[],1
+lattice,lsegments,2,0,0,double[],1
+lattice,lsegments,3,0,0,double[],1
+lattice,lsegments,4,0,0,null,1
+lattice,lsegments,5,0,0,null,1
+lattice,lsegments,6,0,0,character,1
+lattice,lsegments,7,0,0,double,1
+lattice,ltransform3dMatrix,-1,0,0,class<`matrix`>,1
+lattice,ltransform3dMatrix,0,0,0,list<double>,1
+lattice,ltransform3dMatrix,1,0,0,class<`matrix`>,1
+lattice,ltransform3dto3d,-1,0,0,class<`matrix`>,1
+lattice,ltransform3dto3d,0,0,0,class<`matrix`>,1
+lattice,ltransform3dto3d,1,0,0,class<`matrix`>,1
+lattice,ltransform3dto3d,2,0,0,double,1
+lattice,make.groups,-1,0,0,class<`data.frame`>,1
+lattice,make.groups,0,0,0,...,1
+lattice,make.list.from.intervals,-1,0,0,list<any>,1
+lattice,make.list.from.intervals,0,0,0,class<`matrix`>,1
+lattice,make.par.list,-1,0,0,list<character[]>,1
+lattice,make.par.list,-1,0,1,list<double>,1
+lattice,make.par.list,0,0,0,character[],1
+lattice,make.par.list,1,0,0,list<character[]>,1
+lattice,make.par.list,1,0,1,double,1
+lattice,make.par.list,1,0,2,list<double>,1
+lattice,make.par.list,1,0,3,character[],1
+lattice,make.par.list,1,0,4,integer[],1
+lattice,make.par.list,2,0,0,any,1
+lattice,make.par.list,3,0,0,any,1
+lattice,make.par.list,4,0,0,any,1
+lattice,make.par.list,5,0,0,logical,1
+lattice,needAutoKey,-1,0,0,logical,1
+lattice,needAutoKey,0,0,0,logical,1
+lattice,needAutoKey,0,0,1,list<double>,1
+lattice,needAutoKey,0,0,2,list<logical | character>,1
+lattice,needAutoKey,0,0,3,list<character>,1
+lattice,needAutoKey,1,0,0,class<`factor`>,1
+lattice,needAutoKey,1,0,1,null,1
+lattice,oneway,-1,0,0,list<double[]>,1
+lattice,oneway,0,0,0,class<`formula`>,1
+lattice,oneway,1,0,0,class<`data.frame`>,1
+lattice,oneway,2,0,0,class<`function`>,1
+lattice,oneway,3,0,0,double,1
+lattice,packet.number,-1,0,0,double,1
+lattice,packet.number,0,0,0,character,1
+lattice,packet.panel.default,-1,0,0,double[],1
+lattice,packet.panel.default,0,0,0,double[],1
+lattice,packet.panel.default,1,0,0,list<integer[]>,1
+lattice,packet.panel.default,2,0,0,double,1
+lattice,packet.panel.default,3,0,0,integer,1
+lattice,packet.panel.default,4,0,0,integer,1
+lattice,packet.panel.default,5,0,0,logical,1
+lattice,packet.panel.default,6,0,0,logical,1
+lattice,panel.axis,-1,0,0,null,1
+lattice,panel.axis,0,0,0,character,1
+lattice,panel.axis,1,0,0,double[],1
+lattice,panel.axis,2,0,0,character[],1
+lattice,panel.axis,2,0,1,logical,1
+lattice,panel.axis,3,0,0,logical,1
+lattice,panel.axis,4,0,0,logical,1
+lattice,panel.axis,5,0,0,logical,1
+lattice,panel.axis,6,0,0,logical,1
+lattice,panel.axis,7,0,0,logical,1
+lattice,panel.lines,-1,0,0,null,1
+lattice,panel.lines,0,0,0,...,1
+lattice,panel.number,-1,0,0,double,1
+lattice,panel.number,0,0,0,character,1
+lattice,panel.points,-1,0,0,null,1
+lattice,panel.points,0,0,0,...,1
+lattice,panel.rect,-1,0,0,"class<`gDesc`, `grob`, `rect`>",1
+lattice,panel.rect,0,0,0,...,1
+lattice,panel.xyplot,-1,0,0,null,1
+lattice,panel.xyplot,0,0,0,double[],1
+lattice,panel.xyplot,1,0,0,double[],1
+lattice,panel.xyplot,2,0,0,character,1
+lattice,panel.xyplot,3,0,0,null,1
+lattice,panel.xyplot,4,0,0,double,1
+lattice,panel.xyplot,5,0,0,any,1
+lattice,panel.xyplot,6,0,0,any,1
+lattice,panel.xyplot,7,0,0,character,1
+lattice,parallel,-1,0,0,class<`trellis`>,1
+lattice,parallel,0,0,0,class<`formula`>,1
+lattice,parallel,1,0,0,class<`data.frame`>,1
+lattice,parallel,2,0,0,...,1
+lattice,parallel.formula,-1,0,0,class<`trellis`>,1
+lattice,parallel.formula,0,0,0,class<`formula`>,1
+lattice,parallel.formula,1,0,0,class<`data.frame`>,1
+lattice,parallel.formula,2,0,0,logical,1
+lattice,parallel.formula,3,0,0,character,1
+lattice,parallel.formula,4,0,0,list<double>,1
+lattice,parallel.formula,5,0,0,character,1
+lattice,parallel.formula,6,0,0,null,1
+lattice,parallel.formula,7,0,0,list<any>,1
+lattice,parallelplot,-1,0,0,class<`trellis`>,1
+lattice,parallelplot,0,0,0,class<`formula`>,1
+lattice,parallelplot,1,0,0,class<`data.frame`>,1
+lattice,parallelplot,2,0,0,...,1
+lattice,parallelplot.formula,-1,0,0,class<`trellis`>,1
+lattice,parallelplot.formula,0,0,0,class<`formula`>,1
+lattice,parallelplot.formula,1,0,0,class<`data.frame`>,1
+lattice,parallelplot.formula,2,0,0,logical,1
+lattice,parallelplot.formula,3,0,0,character,1
+lattice,parallelplot.formula,4,0,0,list<double>,1
+lattice,parallelplot.formula,5,0,0,character,1
+lattice,parallelplot.formula,6,0,0,null,1
+lattice,parallelplot.formula,7,0,0,list<any>,1
+lattice,paste.and.draw,-1,0,0,"class<`gDesc`, `grob`, `text`>",1
+lattice,paste.and.draw,-1,0,1,null,1
+lattice,paste.and.draw,0,0,0,any,1
+lattice,paste.and.draw,1,0,0,any,1
+lattice,paste.and.draw,2,0,0,character,1
+lattice,paste.and.draw,3,0,0,logical,1
+lattice,paste.and.draw,4,0,0,logical,1
+lattice,paste.and.draw,5,0,0,logical,1
+lattice,paste.and.draw,6,0,0,logical,1
+lattice,paste.and.draw,7,0,0,class<`gpar`>,1
+lattice,plot.shingle,-1,0,0,class<`trellis`>,1
+lattice,plot.shingle,0,0,0,class<`shingle`>,1
+lattice,plot.shingle,1,0,0,class<`function`>,1
+lattice,plot.shingle,2,0,0,character,1
+lattice,plot.shingle,3,0,0,character,1
+lattice,plot.shingle,4,0,0,...,1
+lattice,plot.trellis,-1,0,0,null,1
+lattice,plot.trellis,0,0,0,class<`trellis`>,1
+lattice,plot.trellis,1,0,0,null,1
+lattice,plot.trellis,2,0,0,null,1
+lattice,plot.trellis,3,0,0,logical,1
+lattice,plot.trellis,4,0,0,logical,1
+lattice,plot.trellis,5,0,0,class<`function`>,1
+lattice,plot.trellis,6,0,0,null,1
+lattice,plot.trellis,7,0,0,list<double | character | null>,1
+lattice,prepanel.default.qqmath,-1,0,0,list<double[]>,1
+lattice,prepanel.default.qqmath,0,0,0,double[],1
+lattice,prepanel.default.qqmath,1,0,0,null,1
+lattice,prepanel.default.qqmath,2,0,0,class<`function`>,1
+lattice,prepanel.default.qqmath,3,0,0,any,1
+lattice,prepanel.default.qqmath,4,0,0,null,1
+lattice,prepanel.default.qqmath,4,0,1,class<`factor`>,1
+lattice,prepanel.default.qqmath,5,0,0,any,1
+lattice,prepanel.default.qqmath,6,0,0,...,1
+lattice,prepanel.default.qqmath,7,0,0,double,1
+lattice,prepanel.loess,-1,0,0,list<double[]>,1
+lattice,prepanel.loess,0,0,0,double[],1
+lattice,prepanel.loess,1,0,0,double[],1
+lattice,prepanel.loess,2,0,0,double,1
+lattice,prepanel.loess,3,0,0,double,1
+lattice,prepanel.loess,4,0,0,character[],1
+lattice,prepanel.loess,5,0,0,double,1
+lattice,prepanel.loess,6,0,0,logical,1
+lattice,prepanel.loess,7,0,0,...,1
+lattice,prepanel.null,-1,0,0,list<^double[] | null>,1
+lattice,primName,-1,0,0,character,1
+lattice,primName,0,0,0,character,1
+lattice,primName,1,0,0,character,1
+lattice,primName,2,0,0,character,1
+lattice,primName,3,0,0,double,1
+lattice,print.shingle,-1,0,0,class<`shingle`>,1
+lattice,print.shingle,0,0,0,class<`shingle`>,1
+lattice,print.shingle,1,0,0,logical,1
+lattice,print.shingle,2,0,0,...,1
+lattice,print.shingleLevel,-1,0,0,class<`shingleLevel`>,1
+lattice,print.shingleLevel,0,0,0,class<`shingleLevel`>,1
+lattice,print.shingleLevel,1,0,0,...,1
+lattice,print.trellis,-1,0,0,class<`trellis`>,1
+lattice,print.trellis,0,0,0,class<`trellis`>,1
+lattice,print.trellis,1,0,0,...,1
+lattice,qq,-1,0,0,class<`trellis`>,1
+lattice,qq,0,0,0,class<`formula`>,1
+lattice,qq,1,0,0,class<`data.frame`>,1
+lattice,qq,2,0,0,...,1
+lattice,qq.formula,-1,0,0,class<`trellis`>,1
+lattice,qq.formula,0,0,0,class<`formula`>,1
+lattice,qq.formula,1,0,0,class<`data.frame`>,1
+lattice,qq.formula,2,0,0,double,1
+lattice,qq.formula,3,0,0,character,1
+lattice,qq.formula,4,0,0,null,1
+lattice,qq.formula,5,0,0,list<any>,1
+lattice,qq.formula,6,0,0,logical,1
+lattice,qq.formula,7,0,0,null,1
+lattice,qqmath,-1,0,0,class<`trellis`>,1
+lattice,qqmath,0,0,0,class<`formula`>,1
+lattice,qqmath,1,0,0,any,1
+lattice,qqmath,2,0,0,...,1
+lattice,qqmath.formula,-1,0,0,class<`trellis`>,1
+lattice,qqmath.formula,0,0,0,class<`formula`>,1
+lattice,qqmath.formula,1,0,0,class<`data.frame`>,1
+lattice,qqmath.formula,1,0,1,null,1
+lattice,qqmath.formula,1,0,2,list<double[] | character[]>,1
+lattice,qqmath.formula,2,0,0,logical,1
+lattice,qqmath.formula,3,0,0,logical,1
+lattice,qqmath.formula,4,0,0,class<`function`>,1
+lattice,qqmath.formula,5,0,0,null,1
+lattice,qqmath.formula,6,0,0,logical,1
+lattice,qqmath.formula,6,0,1,list<character>,1
+lattice,qqmath.formula,7,0,0,character,1
+lattice,qqmath.formula,7,0,1,double,1
+lattice,rearrangeUnit,-1,0,0,"class<`unit`, `unit.list`>",1
+lattice,rearrangeUnit,0,0,0,class<`unit`>,1
+lattice,rearrangeUnit,0,0,1,"class<`unit`, `unit.list`>",1
+lattice,rearrangeUnit,1,0,0,double,1
+lattice,rearrangeUnit,2,0,0,"class<`unit`, `unit.arithmetic`>",1
+lattice,rfs,-1,0,0,class<`trellis`>,1
+lattice,rfs,0,0,0,list<double[]>,1
+lattice,rfs,1,0,0,double[],1
+lattice,rfs,2,0,0,character,1
+lattice,rfs,3,0,0,null,1
+lattice,rfs,4,0,0,class<`function`>,1
+lattice,rfs,5,0,0,class<`function`>,1
+lattice,rfs,6,0,0,null,1
+lattice,rfs,7,0,0,logical,1
+lattice,Rows,-1,0,0,list<double[] | character[]>,1
+lattice,Rows,0,0,0,list<double[] | character[]>,1
+lattice,Rows,1,0,0,integer[],1
+lattice,scale.limits,-1,0,0,character[],1
+lattice,scale.limits,-1,0,1,class<`Date`>,1
+lattice,scale.limits,-1,0,2,"class<`POSIXct`, `POSIXt`>",1
+lattice,scale.limits,-1,0,3,double[],1
+lattice,scale.limits,0,0,0,class<`factor`>,1
+lattice,scale.limits,0,0,1,class<`Date`>,1
+lattice,scale.limits,0,0,2,"class<`POSIXct`, `POSIXt`>",1
+lattice,scale.limits,0,0,3,class<`array`>,1
+lattice,scale.limits,0,0,4,double[],1
+lattice,shingle,-1,0,0,class<`shingle`>,1
+lattice,shingle,0,0,0,double[],1
+lattice,shingle,0,0,1,null,1
+lattice,shingle,1,0,0,double[],1
+lattice,[.shingle,-1,0,0,class<`shingle`>,1
+lattice,[.shingle,0,0,0,class<`shingle`>,1
+lattice,[.shingle,1,0,0,logical[],1
+lattice,[.shingle,2,0,0,logical,1
+lattice,show.settings,-1,0,0,class<`trellis`>,1
+lattice,show.settings,0,0,0,null,1
+lattice,simpleKey,-1,0,0,list<any>,1
+lattice,simpleKey,0,0,0,character[],1
+lattice,simpleKey,1,0,0,logical,1
+lattice,simpleKey,2,0,0,logical,1
+lattice,simpleKey,3,0,0,logical,1
+lattice,simpleKey,4,0,0,character,1
+lattice,simpleKey,5,0,0,double,1
+lattice,simpleKey,6,0,0,double,1
+lattice,simpleKey,7,0,0,double,1
+lattice,simpleTheme,-1,0,0,list<list<any>>,1
+lattice,simpleTheme,0,0,0,any,1
+lattice,simpleTheme,1,0,0,any,1
+lattice,simpleTheme,2,0,0,any,1
+lattice,simpleTheme,3,0,0,double,1
+lattice,simpleTheme,4,0,0,any,1
+lattice,simpleTheme,5,0,0,any,1
+lattice,simpleTheme,6,0,0,any,1
+lattice,simpleTheme,7,0,0,any,1
+lattice,splom,-1,0,0,class<`trellis`>,1
+lattice,splom,0,0,0,class<`formula`>,1
+lattice,splom,0,0,1,class<`data.frame`>,1
+lattice,splom,1,0,0,any,1
+lattice,splom,2,0,0,...,1
+lattice,splom.data.frame,-1,0,0,class<`trellis`>,1
+lattice,splom.data.frame,0,0,0,class<`data.frame`>,1
+lattice,splom.data.frame,1,0,0,null,1
+lattice,splom.data.frame,2,0,0,...,1
+lattice,splom.data.frame,3,0,0,any,1
+lattice,splom.data.frame,4,0,0,logical,1
+lattice,splom.formula,-1,0,0,class<`trellis`>,1
+lattice,splom.formula,0,0,0,class<`formula`>,1
+lattice,splom.formula,1,0,0,class<`data.frame`>,1
+lattice,splom.formula,1,0,1,environment,1
+lattice,splom.formula,1,0,2,null,1
+lattice,splom.formula,2,0,0,logical,1
+lattice,splom.formula,3,0,0,double,1
+lattice,splom.formula,3,0,1,character,1
+lattice,splom.formula,4,0,0,list<double>,1
+lattice,splom.formula,5,0,0,character,1
+lattice,splom.formula,5,0,1,class<`function`>,1
+lattice,splom.formula,6,0,0,null,1
+lattice,splom.formula,7,0,0,list<any>,1
+lattice,standard.theme,-1,0,0,list<list<any>>,1
+lattice,standard.theme,0,0,0,any,1
+lattice,standard.theme,1,0,0,logical,1
+lattice,strip.custom,-1,0,0,class<`function`>,1
+lattice,strip.custom,0,0,0,...,1
+lattice,stripplot,-1,0,0,class<`trellis`>,1
+lattice,stripplot,0,0,0,class<`formula`>,1
+lattice,stripplot,1,0,0,any,1
+lattice,stripplot,2,0,0,...,1
+lattice,stripplot.formula,-1,0,0,class<`trellis`>,1
+lattice,stripplot.formula,0,0,0,class<`formula`>,1
+lattice,stripplot.formula,1,0,0,class<`data.frame`>,1
+lattice,stripplot.formula,1,0,1,null,1
+lattice,stripplot.formula,1,0,2,list<double[] | class<`shingle`> | class<`factor`>>,1
+lattice,stripplot.formula,2,0,0,character,1
+lattice,stripplot.formula,2,0,1,class<`function`>,1
+lattice,stripplot.formula,3,0,0,null,1
+lattice,stripplot.formula,4,0,0,...,1
+lattice,summary.trellis,-1,0,0,class<`summary.trellis`>,1
+lattice,summary.trellis,0,0,0,class<`trellis`>,1
+lattice,summary.trellis,1,0,0,...,1
+lattice,tmd,-1,0,0,class<`trellis`>,1
+lattice,tmd,0,0,0,class<`trellis`>,1
+lattice,tmd,1,0,0,...,1
+lattice,tmd.trellis,-1,0,0,class<`trellis`>,1
+lattice,tmd.trellis,0,0,0,class<`trellis`>,1
+lattice,tmd.trellis,1,0,0,character,1
+lattice,tmd.trellis,2,0,0,character,1
+lattice,tmd.trellis,3,0,0,class<`function`>,1
+lattice,tmd.trellis,4,0,0,class<`function`>,1
+lattice,tmd.trellis,5,0,0,...,1
+lattice,[.trellis,-1,0,0,class<`trellis`>,1
+lattice,[.trellis,0,0,0,class<`trellis`>,1
+lattice,[.trellis,1,0,0,any,1
+lattice,[.trellis,2,0,0,any,1
+lattice,[.trellis,3,0,0,...,1
+lattice,[.trellis,4,0,0,logical,1
+lattice,trellis.currentLayout,-1,0,0,class<`matrix`>,1
+lattice,trellis.currentLayout,0,0,0,character,1
+lattice,trellis.currentLayout,1,0,0,character,1
+lattice,trellis.device,-1,0,0,null,1
+lattice,trellis.device,0,0,0,character,1
+lattice,trellis.device,0,0,1,class<`function`>,1
+lattice,trellis.device,1,0,0,logical,1
+lattice,trellis.device,2,0,0,null,1
+lattice,trellis.device,3,0,0,logical,1
+lattice,trellis.device,4,0,0,logical,1
+lattice,trellis.device,5,0,0,...,1
+lattice,trellis.focus,-1,0,0,any,1
+lattice,trellis.focus,0,0,0,character,1
+lattice,trellis.focus,1,0,0,double,1
+lattice,trellis.focus,2,0,0,double,1
+lattice,trellis.focus,3,0,0,null,1
+lattice,trellis.focus,4,0,0,logical,1
+lattice,trellis.focus,5,0,0,any,1
+lattice,trellis.focus,6,0,0,...,1
+lattice,trellis.focus,7,0,0,any,1
+lattice,trellis.grobname,-1,0,0,character,1
+lattice,trellis.grobname,0,0,0,character,1
+lattice,trellis.grobname,1,0,0,character,1
+lattice,trellis.grobname,2,0,0,double,1
+lattice,trellis.grobname,3,0,0,any,1
+lattice,trellis.grobname,4,0,0,any,1
+lattice,trellis.grobname,5,0,0,any,1
+lattice,trellis.grobname,6,0,0,any,1
+lattice,trellis.grobname,7,0,0,character,1
+lattice,trellis.last.object,-1,0,0,any,1
+lattice,trellis.last.object,0,0,0,...,1
+lattice,trellis.last.object,1,0,0,null,1
+lattice,trellis.par.get,-1,0,0,list<any>,1
+lattice,trellis.par.get,0,0,0,character,1
+lattice,trellis.par.get,0,0,1,null,1
+lattice,trellis.par.set,-1,0,0,null,1
+lattice,trellis.par.set,0,0,0,any,1
+lattice,trellis.par.set,1,0,0,any,1
+lattice,trellis.par.set,2,0,0,...,1
+lattice,trellis.par.set,3,0,0,any,1
+lattice,trellis.par.set,4,0,0,logical,1
+lattice,trellis.par.set,5,0,0,integer,1
+lattice,trellis.skeleton,-1,0,0,list<list<any>>,1
+lattice,trellis.skeleton,0,0,0,class<`formula`>,1
+lattice,trellis.skeleton,1,0,0,list<class<`factor`>>,1
+lattice,trellis.skeleton,1,0,1,list<class<`shingle`>>,1
+lattice,trellis.skeleton,1,0,2,list<class<`shingle`> | class<`factor`>>,1
+lattice,trellis.skeleton,1,0,3,list<class<`factor`> | class<`shingle`>>,1
+lattice,trellis.skeleton,2,0,0,double,1
+lattice,trellis.skeleton,2,0,1,character,1
+lattice,trellis.skeleton,3,0,0,logical,1
+lattice,trellis.skeleton,4,0,0,list<double[]>,1
+lattice,trellis.skeleton,5,0,0,null,1
+lattice,trellis.skeleton,5,0,1,list<double | list<integer[]>>,1
+lattice,trellis.skeleton,5,0,2,list<double | list<character[] | double[] | character[]>>,1
+lattice,trellis.skeleton,5,0,3,list<character | double | list<double[] | character[] | character[]>>,1
+lattice,trellis.skeleton,6,0,0,null,1
+lattice,trellis.skeleton,6,0,1,"list<list<class<`gDesc`, `grob`, `text`>>>",1
+lattice,trellis.skeleton,7,0,0,class<`function`>,1
+lattice,trellis.skeleton,7,0,1,null,1
+lattice,trellis.unfocus,-1,0,0,any,1
+lattice,trellis.vpname,-1,0,0,character,1
+lattice,trellis.vpname,0,0,0,character,1
+lattice,trellis.vpname,1,0,0,any,1
+lattice,trellis.vpname,2,0,0,any,1
+lattice,trellis.vpname,3,0,0,character[],1
+lattice,trellis.vpname,4,0,0,logical,1
+lattice,trellis.vpname,5,0,0,character,1
+lattice,trellis.vpname,5,0,1,null,1
+lattice,updateList,-1,0,0,list<any>,1
+lattice,updateList,0,0,0,list<any>,1
+lattice,updateList,1,0,0,list<any>,1
+lattice,update.trellis,-1,0,0,class<`trellis`>,1
+lattice,update.trellis,0,0,0,class<`trellis`>,1
+lattice,update.trellis,1,0,0,any,1
+lattice,update.trellis,2,0,0,any,1
+lattice,update.trellis,3,0,0,any,1
+lattice,update.trellis,4,0,0,any,1
+lattice,update.trellis,5,0,0,any,1
+lattice,update.trellis,6,0,0,any,1
+lattice,update.trellis,7,0,0,any,1
+lattice,which.packet,-1,0,0,double[],1
+lattice,which.packet,-1,0,1,null,1
+lattice,which.packet,0,0,0,character,1
+lattice,wireframe,-1,0,0,class<`trellis`>,1
+lattice,wireframe,0,0,0,class<`formula`>,1
+lattice,wireframe,0,0,1,class<`matrix`>,1
+lattice,wireframe,1,0,0,any,1
+lattice,wireframe,2,0,0,...,1
+lattice,wireframe.formula,-1,0,0,class<`trellis`>,1
+lattice,wireframe.formula,0,0,0,class<`formula`>,1
+lattice,wireframe.formula,1,0,0,class<`data.frame`>,1
+lattice,wireframe.formula,1,0,1,null,1
+lattice,wireframe.formula,2,0,0,character,1
+lattice,wireframe.formula,3,0,0,character,1
+lattice,wireframe.formula,4,0,0,...,1
+lattice,wireframe.matrix,-1,0,0,class<`trellis`>,1
+lattice,wireframe.matrix,0,0,0,class<`matrix`>,1
+lattice,wireframe.matrix,1,0,0,null,1
+lattice,wireframe.matrix,2,0,0,character,1
+lattice,wireframe.matrix,3,0,0,any,1
+lattice,wireframe.matrix,4,0,0,...,1
+lattice,wireframe.matrix,5,0,0,any,1
+lattice,wireframe.matrix,6,0,0,any,1
+lattice,wireframe.matrix,7,0,0,integer[],1
+lattice,xscale.components.default,-1,0,0,list<double[] | list<list<double[] | double[] | character[]>>>,1
+lattice,xscale.components.default,0,0,0,double[],1
+lattice,xscale.components.default,1,0,0,double,1
+lattice,xscale.components.default,2,0,0,null,1
+lattice,xscale.components.default,3,0,0,logical,1
+lattice,xscale.components.default,4,0,0,...,1
+lattice,xyplot,-1,0,0,any,1
+lattice,xyplot,0,0,0,class<`formula`>,1
+lattice,xyplot,0,0,1,"class<`matrix`, `mts`, `ts`>",1
+lattice,xyplot,0,0,2,class<`ts`>,1
+lattice,xyplot,1,0,0,any,1
+lattice,xyplot,2,0,0,...,1
+lattice,xyplot.formula,-1,0,0,any,1
+lattice,xyplot.formula,0,0,0,class<`formula`>,1
+lattice,xyplot.formula,1,0,0,class<`data.frame`>,1
+lattice,xyplot.formula,1,0,1,null,1
+lattice,xyplot.formula,1,0,2,list<integer[] | class<`factor`>>,1
+lattice,xyplot.formula,2,0,0,logical,1
+lattice,xyplot.formula,3,0,0,logical,1
+lattice,xyplot.formula,4,0,0,logical,1
+lattice,xyplot.formula,4,0,1,list<logical>,1
+lattice,xyplot.formula,4,0,2,list<logical | character>,1
+lattice,xyplot.formula,5,0,0,character,1
+lattice,xyplot.formula,5,0,1,double,1
+lattice,xyplot.formula,6,0,0,character,1
+lattice,xyplot.formula,6,0,1,class<`function`>,1
+lattice,xyplot.formula,7,0,0,null,1
+lattice,xyplot.formula,7,0,1,class<`function`>,1
+lattice,xyplot.ts,-1,0,0,class<`trellis`>,1
+lattice,xyplot.ts,0,0,0,"class<`matrix`, `mts`, `ts`>",1
+lattice,xyplot.ts,0,0,1,class<`ts`>,1
+lattice,xyplot.ts,1,0,0,null,1
+lattice,xyplot.ts,2,0,0,character[],1
+lattice,xyplot.ts,2,0,1,double,1
+lattice,xyplot.ts,2,0,2,list<character>,1
+lattice,xyplot.ts,3,0,0,...,1
+lattice,xyplot.ts,4,0,0,logical,1
+lattice,xyplot.ts,5,0,0,logical,1
+lattice,xyplot.ts,5,0,1,list<double>,1
+lattice,xyplot.ts,6,0,0,character[],1
+lattice,xyplot.ts,6,0,1,list<character[]>,1
+lattice,xyplot.ts,7,0,0,null,1
+lattice,xyplot.ts,7,0,1,list<character>,1
+lava,%++%,-1,0,0,character,1
+lava,%++%,-1,0,1,class<`function`>,1
+lava,%++%,-1,0,2,class<`matrix`>,1
+lava,%++%,0,0,0,any,1
+lava,%++%,1,0,0,character,1
+lava,%++%,1,0,1,class<`function`>,1
+lava,%++%,1,0,2,class<`matrix`>,1
+lava,aalenExponential.lvm,-1,0,0,class<`function`>,1
+lava,aalenExponential.lvm,0,0,0,double,1
+lava,aalenExponential.lvm,1,0,0,double[],1
+lava,aalenExponential.lvm,2,0,0,double[],1
+lava,acc,-1,0,0,character[],1
+lava,acc,0,0,0,class<`matrix`>,1
+lava,acc,1,0,0,character,1
+lava,addhook,-1,0,0,character[],1
+lava,addhook,0,0,0,character,1
+lava,addhook,1,0,0,character,1
+lava,addhook,2,0,0,...,1
+lava,addvar,-1,0,0,class<`lvm`>,1
+lava,addvar,0,0,0,class<`lvm`>,1
+lava,addvar,1,0,0,...,1
+lava,addvar<-,-1,0,0,class<`lvm`>,1
+lava,addvar<-,0,0,0,class<`lvm`>,1
+lava,addvar<-,1,0,0,...,1
+lava,addvar<-,2,0,0,character[],1
+lava,addvar<-,2,0,1,class<`formula`>,1
+lava,addvar<-.lvm,-1,0,0,class<`lvm`>,1
+lava,addvar<-.lvm,0,0,0,class<`lvm`>,1
+lava,addvar<-.lvm,1,0,0,...,1
+lava,addvar<-.lvm,2,0,0,character[],1
+lava,addvar<-.lvm,2,0,1,class<`formula`>,1
+lava,addvar.lvm,-1,0,0,class<`lvm`>,1
+lava,addvar.lvm,0,0,0,class<`lvm`>,1
+lava,addvar.lvm,1,0,0,character[],1
+lava,addvar.lvm,2,0,0,any,1
+lava,addvar.lvm,3,0,0,logical,1
+lava,addvar.lvm,4,0,0,...,1
+lava,adjMat,-1,0,0,class<`matrix`>,1
+lava,adjMat,0,0,0,class<`lvm`>,1
+lava,adjMat,1,0,0,...,1
+lava,adjMat.lvm,-1,0,0,class<`matrix`>,1
+lava,adjMat.lvm,0,0,0,class<`lvm`>,1
+lava,adjMat.lvm,1,0,0,...,1
+lava,ancestors,-1,0,0,character[],1
+lava,ancestors,-1,0,1,null,1
+lava,ancestors,0,0,0,class<`lvm`>,1
+lava,ancestors,1,0,0,...,1
+lava,ancestors.lvm,-1,0,0,character[],1
+lava,ancestors.lvm,-1,0,1,null,1
+lava,ancestors.lvm,0,0,0,class<`lvm`>,1
+lava,ancestors.lvm,1,0,0,character[],1
+lava,ancestors.lvm,2,0,0,...,1
+lava,backdoor,-1,0,0,logical,1
+lava,backdoor,-1,0,1,list<character[] | list<list<character[]>>>,1
+lava,backdoor,0,0,0,class<`lvm`>,1
+lava,backdoor,1,0,0,class<`formula`>,1
+lava,backdoor,2,0,0,any,1
+lava,backdoor,3,0,0,...,1
+lava,backdoor,4,0,0,logical,1
+lava,baptize,-1,0,0,class<`lvm`>,1
+lava,baptize,0,0,0,class<`lvm`>,1
+lava,baptize,1,0,0,...,1
+lava,baptize.lvm,-1,0,0,class<`lvm`>,1
+lava,baptize.lvm,0,0,0,class<`lvm`>,1
+lava,baptize.lvm,1,0,0,any,1
+lava,baptize.lvm,2,0,0,logical,1
+lava,baptize.lvm,3,0,0,logical,1
+lava,baptize.lvm,4,0,0,...,1
+lava,beta.lvm,-1,0,0,class<`function`>,1
+lava,beta.lvm,0,0,0,double,1
+lava,beta.lvm,1,0,0,double,1
+lava,beta.lvm,2,0,0,logical,1
+lava,binomial.lvm,-1,0,0,class<`function`>,1
+lava,binomial.lvm,0,0,0,character,1
+lava,binomial.lvm,1,0,0,any,1
+lava,binomial.lvm,2,0,0,double,1
+lava,blockdiag,-1,0,0,class<`matrix`>,1
+lava,blockdiag,0,0,0,class<`matrix`>,1
+lava,blockdiag,1,0,0,...,1
+lava,blockdiag,2,0,0,double,1
+lava,blockdiag,2,0,1,null,1
+lava,bootstrap,-1,0,0,class<`bootstrap.lvm`>,1
+lava,bootstrap,0,0,0,class<`lvmfit`>,1
+lava,bootstrap,1,0,0,...,1
+lava,bootstrap.lvm,-1,0,0,class<`bootstrap.lvm`>,1
+lava,bootstrap.lvm,0,0,0,class<`lvm`>,1
+lava,bootstrap.lvm,1,0,0,double,1
+lava,bootstrap.lvm,2,0,0,class<`data.frame`>,1
+lava,bootstrap.lvm,3,0,0,null,1
+lava,bootstrap.lvm,4,0,0,list<double[]>,1
+lava,bootstrap.lvm,5,0,0,any,1
+lava,bootstrap.lvm,6,0,0,logical,1
+lava,bootstrap.lvm,7,0,0,logical,1
+lava,bootstrap.lvmfit,-1,0,0,class<`bootstrap.lvm`>,1
+lava,bootstrap.lvmfit,0,0,0,class<`lvmfit`>,1
+lava,bootstrap.lvmfit,1,0,0,double,1
+lava,bootstrap.lvmfit,2,0,0,class<`data.frame`>,1
+lava,bootstrap.lvmfit,3,0,0,list<double[]>,1
+lava,bootstrap.lvmfit,4,0,0,any,1
+lava,bootstrap.lvmfit,5,0,0,logical,1
+lava,bootstrap.lvmfit,6,0,0,logical,1
+lava,bootstrap.lvmfit,7,0,0,character,1
+lava,By,-1,0,0,class<`by`>,1
+lava,By,-1,0,1,class<`matrix`>,1
+lava,By,0,0,0,"class<`data.frame`, `groupedData`, `nfGroupedData`, `nfnGroupedData`>",1
+lava,By,1,0,0,class<`formula`>,1
+lava,By,2,0,0,class<`function`>,1
+lava,By,3,0,0,class<`formula`>,1
+lava,By,4,0,0,logical,1
+lava,By,5,0,0,...,1
+lava,cancel,-1,0,0,class<`lvm`>,1
+lava,cancel,0,0,0,class<`lvm`>,1
+lava,cancel,1,0,0,...,1
+lava,cancel<-,-1,0,0,class<`lvm`>,1
+lava,cancel<-,0,0,0,class<`lvm`>,1
+lava,cancel<-,1,0,0,...,1
+lava,cancel<-,2,0,0,character[],1
+lava,cancel<-,2,0,1,class<`formula`>,1
+lava,cancel<-.lvm,-1,0,0,class<`lvm`>,1
+lava,cancel<-.lvm,0,0,0,class<`lvm`>,1
+lava,cancel<-.lvm,1,0,0,...,1
+lava,cancel<-.lvm,2,0,0,character[],1
+lava,cancel<-.lvm,2,0,1,class<`formula`>,1
+lava,cancel.lvm,-1,0,0,class<`lvm`>,1
+lava,cancel.lvm,0,0,0,class<`lvm`>,1
+lava,cancel.lvm,1,0,0,character[],1
+lava,cancel.lvm,1,0,1,class<`formula`>,1
+lava,cancel.lvm,2,0,0,...,1
+lava,categorical,-1,0,0,class<`lvm`>,1
+lava,categorical,0,0,0,class<`lvm`>,1
+lava,categorical,1,0,0,character,1
+lava,categorical,1,0,1,class<`formula`>,1
+lava,categorical,2,0,0,any,1
+lava,categorical,3,0,0,any,1
+lava,categorical,4,0,0,any,1
+lava,categorical,5,0,0,logical,1
+lava,categorical,6,0,0,logical,1
+lava,categorical,7,0,0,logical,1
+lava,categorical<-,-1,0,0,class<`lvm`>,1
+lava,categorical<-,0,0,0,class<`lvm`>,1
+lava,categorical<-,1,0,0,...,1
+lava,categorical<-,2,0,0,character,1
+lava,categorical2dummy,-1,0,0,list<class<`lvm`> | class<`data.frame`>>,1
+lava,categorical2dummy,-1,0,1,list<class<`lvm`> | list<class<`matrix`> | double[]>>,1
+lava,categorical2dummy,0,0,0,class<`lvm`>,1
+lava,categorical2dummy,1,0,0,class<`data.frame`>,1
+lava,categorical2dummy,1,0,1,list<class<`matrix`> | double[]>,1
+lava,categorical2dummy,2,0,0,double,1
+lava,categorical2dummy,3,0,0,...,1
+lava,char2num,-1,0,0,^double[],1
+lava,char2num,-1,0,1,null,1
+lava,char2num,0,0,0,character[],1
+lava,char2num,0,0,1,double[],1
+lava,char2num,0,0,2,list<character>,1
+lava,char2num,0,0,3,null,1
+lava,char2num,1,0,0,...,1
+lava,%++%.character,-1,0,0,character,1
+lava,%++%.character,0,0,0,character,1
+lava,%++%.character,1,0,0,character,1
+lava,checkmultigroup,-1,0,0,null,1
+lava,checkmultigroup,0,0,0,class<`multigroup`>,1
+lava,children,-1,0,0,character[],1
+lava,children,-1,0,1,null,1
+lava,children,0,0,0,class<`lvm`>,1
+lava,children,0,0,1,class<`lvmfit`>,1
+lava,children,1,0,0,...,1
+lava,children.lvm,-1,0,0,character[],1
+lava,children.lvm,-1,0,1,null,1
+lava,children.lvm,0,0,0,class<`lvm`>,1
+lava,children.lvm,1,0,0,character,1
+lava,children.lvm,1,0,1,class<`formula`>,1
+lava,children.lvm,2,0,0,...,1
+lava,children.lvmfit,-1,0,0,character[],1
+lava,children.lvmfit,0,0,0,class<`lvmfit`>,1
+lava,children.lvmfit,1,0,0,...,1
+lava,closed.testing,-1,0,0,double[],1
+lava,closed.testing,0,0,0,class<`estimate`>,1
+lava,closed.testing,1,0,0,integer[],1
+lava,closed.testing,2,0,0,double[],1
+lava,closed.testing,3,0,0,...,1
+lava,cluster.post.hook,-1,0,0,class<`lvmfit`>,1
+lava,cluster.post.hook,-1,0,1,null,1
+lava,cluster.post.hook,0,0,0,class<`lvmfit`>,1
+lava,cluster.post.hook,0,0,1,"class<`lvmfit`, `multigroupfit`>",1
+lava,cluster.post.hook,1,0,0,...,1
+lava,coef.estimate,-1,0,0,double[],1
+lava,coef.estimate,0,0,0,class<`estimate`>,1
+lava,coef.estimate,0,0,1,"class<`estimate`, `gkgamma`>",1
+lava,coef.estimate,1,0,0,logical,1
+lava,coef.estimate,2,0,0,logical,1
+lava,coef.estimate,3,0,0,double,1
+lava,coef.estimate,4,0,0,...,1
+lava,coef.lvm,-1,0,0,character[],1
+lava,coef.lvm,0,0,0,class<`lvm`>,1
+lava,coef.lvm,1,0,0,logical,1
+lava,coef.lvm,2,0,0,logical,1
+lava,coef.lvm,3,0,0,character[],1
+lava,coef.lvm,4,0,0,double,1
+lava,coef.lvm,5,0,0,any,1
+lava,coef.lvm,6,0,0,any,1
+lava,coef.lvm,7,0,0,any,1
+lava,coef.lvmfit,-1,0,0,class<`matrix`>,1
+lava,coef.lvmfit,-1,0,1,double[],1
+lava,coef.lvmfit,0,0,0,class<`lvm`>,1
+lava,coef.lvmfit,0,0,1,class<`lvmfit`>,1
+lava,coef.lvmfit,0,0,2,"class<`lvm.missing`, `lvmfit`>",1
+lava,coef.lvmfit,1,0,0,double,1
+lava,coef.lvmfit,2,0,0,any,1
+lava,coef.lvmfit,3,0,0,any,1
+lava,coef.lvmfit,4,0,0,null,1
+lava,coef.lvmfit,4,0,1,character,1
+lava,coef.lvmfit,5,0,0,any,1
+lava,coef.lvmfit,6,0,0,any,1
+lava,coef.lvmfit,7,0,0,any,1
+lava,coef.lvm.mixture,-1,0,0,double[],1
+lava,coef.lvm.mixture,0,0,0,"class<`lvm.mixture`, `mvn.mixture`>",1
+lava,coef.lvm.mixture,1,0,0,any,1
+lava,coef.lvm.mixture,2,0,0,logical,1
+lava,coef.lvm.mixture,3,0,0,logical,1
+lava,coef.lvm.mixture,4,0,0,logical,1
+lava,coef.lvm.mixture,5,0,0,logical,1
+lava,coef.lvm.mixture,6,0,0,logical,1
+lava,coef.lvm.mixture,7,0,0,...,1
+lava,CoefMat,-1,0,0,class<`matrix`>,1
+lava,CoefMat,0,0,0,class<`matrix`>,1
+lava,CoefMat,1,0,0,double,1
+lava,CoefMat,2,0,0,double,1
+lava,CoefMat,3,0,0,any,1
+lava,CoefMat,4,0,0,...,1
+lava,CoefMat.multigroupfit,-1,0,0,list<class<`matrix`>>,1
+lava,CoefMat.multigroupfit,0,0,0,"class<`lvmfit`, `multigroupfit`>",1
+lava,CoefMat.multigroupfit,1,0,0,double,1
+lava,CoefMat.multigroupfit,2,0,0,logical,1
+lava,CoefMat.multigroupfit,3,0,0,character,1
+lava,CoefMat.multigroupfit,4,0,0,null,1
+lava,CoefMat.multigroupfit,5,0,0,integer[],1
+lava,CoefMat.multigroupfit,6,0,0,...,1
+lava,coef.multigroupfit,-1,0,0,class<`matrix`>,1
+lava,coef.multigroupfit,-1,0,1,double[],1
+lava,coef.multigroupfit,-1,0,2,list<class<`matrix`>>,1
+lava,coef.multigroupfit,0,0,0,"class<`lvmfit`, `multigroupfit`>",1
+lava,coef.multigroupfit,1,0,0,double,1
+lava,coef.multigroupfit,2,0,0,any,1
+lava,coef.multigroupfit,3,0,0,logical,1
+lava,coef.multigroupfit,4,0,0,any,1
+lava,coef.multigroupfit,5,0,0,any,1
+lava,coef.multigroupfit,6,0,0,null,1
+lava,coef.multigroupfit,7,0,0,null,1
+lava,coef.multigroupfit,7,0,1,integer[],1
+lava,coef.multinomial,-1,0,0,double[],1
+lava,coef.multinomial,0,0,0,class<`multinomial`>,1
+lava,coef.multinomial,1,0,0,...,1
+lava,coef.zibreg,-1,0,0,double[],1
+lava,coef.zibreg,0,0,0,class<`zibreg`>,1
+lava,coef.zibreg,1,0,0,...,1
+lava,Col,-1,0,0,character[],1
+lava,Col,0,0,0,character[],1
+lava,Col,1,0,0,double[],1
+lava,Col,2,0,0,double,1
+lava,Combine,-1,0,0,"class<`Combine`, `matrix`>",1
+lava,Combine,0,0,0,list<class<`lm`>>,1
+lava,Combine,1,0,0,...,1
+lava,compare,-1,0,0,class<`htest`>,1
+lava,compare,0,0,0,"class<`glm`, `lm`>",1
+lava,compare,0,0,1,class<`lvmfit`>,1
+lava,compare,0,0,2,"class<`lvmfit`, `multigroupfit`>",1
+lava,compare,0,0,3,class<`zibreg`>,1
+lava,compare,0,0,4,class<`estimate`>,1
+lava,compare,1,0,0,...,1
+lava,compare.default,-1,0,0,class<`htest`>,1
+lava,compare.default,0,0,0,"class<`glm`, `lm`>",1
+lava,compare.default,0,0,1,class<`lvmfit`>,1
+lava,compare.default,0,0,2,"class<`lvmfit`, `multigroupfit`>",1
+lava,compare.default,0,0,3,class<`zibreg`>,1
+lava,compare.default,0,0,4,class<`estimate`>,1
+lava,compare.default,1,0,0,...,1
+lava,compare.default,2,0,0,any,1
+lava,compare.default,3,0,0,any,1
+lava,compare.default,4,0,0,any,1
+lava,compare.default,5,0,0,any,1
+lava,compare.default,6,0,0,any,1
+lava,compare.default,7,0,0,double,1
+lava,comparepair,-1,0,0,class<`htest`>,1
+lava,comparepair,0,0,0,"class<`glm`, `lm`>",1
+lava,comparepair,0,0,1,class<`lvmfit`>,1
+lava,comparepair,0,0,2,class<`zibreg`>,1
+lava,comparepair,1,0,0,"class<`glm`, `lm`>",1
+lava,comparepair,1,0,1,class<`lvmfit`>,1
+lava,comparepair,1,0,2,class<`zibreg`>,1
+lava,complik,-1,0,0,"class<`estimate.complik`, `lvm.missing`, `lvmfit`>",1
+lava,complik,0,0,0,class<`lvm`>,1
+lava,complik,1,0,0,class<`data.frame`>,1
+lava,complik,2,0,0,double,1
+lava,complik,3,0,0,character,1
+lava,complik,4,0,0,any,1
+lava,complik,5,0,0,double,1
+lava,complik,6,0,0,character,1
+lava,complik,7,0,0,...,1
+lava,condition,-1,0,0,double,1
+lava,condition,0,0,0,class<`matrix`>,1
+lava,confband,-1,0,0,^double[],1
+lava,confband,-1,0,1,null,1
+lava,confband,0,0,0,double[],1
+lava,confband,1,0,0,^double[],1
+lava,confband,2,0,0,^double[],1
+lava,confband,3,0,0,^double[],1
+lava,confband,3,0,1,null,1
+lava,confband,4,0,0,logical,1
+lava,confband,5,0,0,double,1
+lava,confband,6,0,0,double,1
+lava,confband,7,0,0,any,1
+lava,confint.lvmfit,-1,0,0,class<`matrix`>,1
+lava,confint.lvmfit,0,0,0,class<`lvmfit`>,1
+lava,confint.lvmfit,1,0,0,double,1
+lava,confint.lvmfit,2,0,0,double,1
+lava,confint.lvmfit,3,0,0,logical,1
+lava,confint.lvmfit,4,0,0,logical,1
+lava,confint.lvmfit,5,0,0,double,1
+lava,confint.lvmfit,6,0,0,null,1
+lava,confint.lvmfit,7,0,0,logical,1
+lava,confpred,-1,0,0,class<`data.frame`>,1
+lava,confpred,0,0,0,class<`lm`>,1
+lava,confpred,1,0,0,class<`data.frame`>,1
+lava,confpred,2,0,0,class<`data.frame`>,1
+lava,confpred,3,0,0,double,1
+lava,confpred,4,0,0,any,1
+lava,confpred,5,0,0,...,1
+lava,constrain,-1,0,0,list<any>,1
+lava,constrain,0,0,0,class<`lvm`>,1
+lava,constrain,0,0,1,class<`lvmfit`>,1
+lava,constrain,0,0,2,"class<`lvmfit`, `multigroupfit`>",1
+lava,constrain,1,0,0,...,1
+lava,constrain<-,-1,0,0,class<`lvm`>,1
+lava,constrain<-,0,0,0,class<`lvm`>,1
+lava,constrain<-,1,0,0,...,1
+lava,constrain<-,2,0,0,class<`function`>,1
+lava,constrain<-.default,-1,0,0,class<`lvm`>,1
+lava,constrain<-.default,0,0,0,class<`lvm`>,1
+lava,constrain<-.default,1,0,0,character,1
+lava,constrain<-.default,1,0,1,class<`formula`>,1
+lava,constrain<-.default,2,0,0,any,1
+lava,constrain<-.default,3,0,0,...,1
+lava,constrain<-.default,4,0,0,class<`function`>,1
+lava,constrain.default,-1,0,0,list<any>,1
+lava,constrain.default,0,0,0,class<`lvm`>,1
+lava,constrain.default,0,0,1,class<`lvmfit`>,1
+lava,constrain.default,0,0,2,"class<`lvmfit`, `multigroupfit`>",1
+lava,constrain.default,1,0,0,any,1
+lava,constrain.default,2,0,0,any,1
+lava,constrain.default,3,0,0,double,1
+lava,constrain.default,4,0,0,any,1
+lava,constrain.default,5,0,0,logical,1
+lava,constrain.default,6,0,0,...,1
+lava,constraints,-1,0,0,class<`matrix`>,1
+lava,constraints,-1,0,1,null,1
+lava,constraints,0,0,0,class<`lvm`>,1
+lava,constraints,0,0,1,class<`lvmfit`>,1
+lava,constraints,1,0,0,class<`matrix`>,1
+lava,constraints,1,0,1,class<`data.frame`>,1
+lava,constraints,2,0,0,any,1
+lava,constraints,3,0,0,double,1
+lava,constraints,4,0,0,any,1
+lava,constraints,5,0,0,any,1
+lava,constraints,6,0,0,any,1
+lava,constraints,7,0,0,...,1
+lava,contr,-1,0,0,class<`matrix`>,1
+lava,contr,0,0,0,double[],1
+lava,contr,0,0,1,list<double[]>,1
+lava,contr,1,0,0,any,1
+lava,contr,2,0,0,logical,1
+lava,contr,3,0,0,...,1
+lava,covariance,-1,0,0,class<`fix`>,1
+lava,covariance,-1,0,1,class<`lvm`>,1
+lava,covariance,0,0,0,class<`lvm`>,1
+lava,covariance,1,0,0,...,1
+lava,covariance<-,-1,0,0,class<`lvm`>,1
+lava,covariance<-,0,0,0,class<`lvm`>,1
+lava,covariance<-,1,0,0,...,1
+lava,covariance<-,2,0,0,character[],1
+lava,covariance<-,2,0,1,class<`formula`>,1
+lava,covariance<-,2,0,2,double,1
+lava,covariance<-,2,0,3,null,1
+lava,covariance<-.lvm,-1,0,0,class<`lvm`>,1
+lava,covariance<-.lvm,0,0,0,class<`lvm`>,1
+lava,covariance<-.lvm,1,0,0,character[],1
+lava,covariance<-.lvm,1,0,1,class<`formula`>,1
+lava,covariance<-.lvm,1,0,2,null,1
+lava,covariance<-.lvm,2,0,0,character[],1
+lava,covariance<-.lvm,2,0,1,null,1
+lava,covariance<-.lvm,3,0,0,logical,1
+lava,covariance<-.lvm,4,0,0,logical,1
+lava,covariance<-.lvm,5,0,0,...,1
+lava,covariance<-.lvm,6,0,0,null,1
+lava,covariance<-.lvm,6,0,1,double,1
+lava,covariance<-.lvm,6,0,2,character[],1
+lava,covariance<-.lvm,6,0,3,class<`formula`>,1
+lava,covariance.lvm,-1,0,0,class<`fix`>,1
+lava,covariance.lvm,-1,0,1,class<`lvm`>,1
+lava,covariance.lvm,0,0,0,class<`lvm`>,1
+lava,covariance.lvm,1,0,0,null,1
+lava,covariance.lvm,1,0,1,character[],1
+lava,covariance.lvm,2,0,0,null,1
+lava,covariance.lvm,2,0,1,character,1
+lava,covariance.lvm,3,0,0,logical,1
+lava,covariance.lvm,4,0,0,logical,1
+lava,covariance.lvm,5,0,0,logical,1
+lava,covariance.lvm,6,0,0,any,1
+lava,covariance.lvm,7,0,0,...,1
+lava,covfix,-1,0,0,class<`fix`>,1
+lava,covfix,0,0,0,class<`lvm`>,1
+lava,covfix,1,0,0,...,1
+lava,covfix<-,-1,0,0,class<`lvm`>,1
+lava,covfix<-,0,0,0,class<`lvm`>,1
+lava,covfix<-,1,0,0,...,1
+lava,covfix<-,2,0,0,character,1
+lava,covfix<-,2,0,1,double,1
+lava,covfix<-,2,0,2,null,1
+lava,covfix<-.lvm,-1,0,0,class<`lvm`>,1
+lava,covfix<-.lvm,0,0,0,class<`lvm`>,1
+lava,covfix<-.lvm,1,0,0,character[],1
+lava,covfix<-.lvm,1,0,1,class<`formula`>,1
+lava,covfix<-.lvm,2,0,0,character[],1
+lava,covfix<-.lvm,2,0,1,null,1
+lava,covfix<-.lvm,3,0,0,logical,1
+lava,covfix<-.lvm,4,0,0,logical,1
+lava,covfix<-.lvm,5,0,0,...,1
+lava,covfix<-.lvm,6,0,0,null,1
+lava,covfix<-.lvm,6,0,1,character,1
+lava,covfix<-.lvm,6,0,2,double,1
+lava,covfix.lvm,-1,0,0,class<`fix`>,1
+lava,covfix.lvm,0,0,0,class<`lvm`>,1
+lava,covfix.lvm,1,0,0,...,1
+lava,coxExponential.lvm,-1,0,0,class<`function`>,1
+lava,coxExponential.lvm,0,0,0,double,1
+lava,coxExponential.lvm,1,0,0,class<`matrix`>,1
+lava,coxExponential.lvm,1,0,1,double[],1
+lava,coxExponential.lvm,2,0,0,any,1
+lava,coxWeibull.lvm,-1,0,0,class<`function`>,1
+lava,coxWeibull.lvm,0,0,0,double,1
+lava,coxWeibull.lvm,1,0,0,class<`formula`>,1
+lava,coxWeibull.lvm,1,0,1,double,1
+lava,csplit,-1,0,0,list<class<`data.frame`>>,1
+lava,csplit,-1,0,1,list<integer[]>,1
+lava,csplit,0,0,0,class<`data.frame`>,1
+lava,csplit,0,0,1,double,1
+lava,csplit,1,0,0,double,1
+lava,csplit,1,0,1,null,1
+lava,csplit,2,0,0,logical,1
+lava,csplit,3,0,0,logical,1
+lava,csplit,4,0,0,double,1
+lava,csplit,5,0,0,...,1
+lava,cv,-1,0,0,class<`CrossValidated`>,1
+lava,cv,0,0,0,list<class<`lm`>>,1
+lava,cv,0,0,1,list<class<`function`>>,1
+lava,cv,1,0,0,class<`data.frame`>,1
+lava,cv,2,0,0,double,1
+lava,cv,3,0,0,double,1
+lava,cv,4,0,0,any,1
+lava,cv,5,0,0,null,1
+lava,cv,6,0,0,double,1
+lava,cv,7,0,0,null,1
+lava,Debug,-1,0,0,null,1
+lava,Debug,0,0,0,any,1
+lava,Debug,1,0,0,logical,1
+lava,decomp.specials,-1,0,0,character[],1
+lava,decomp.specials,0,0,0,character,1
+lava,decomp.specials,0,0,1,list<character>,1
+lava,decomp.specials,1,0,0,null,1
+lava,decomp.specials,1,0,1,character,1
+lava,decomp.specials,2,0,0,character,1
+lava,decomp.specials,2,0,1,null,1
+lava,decomp.specials,3,0,0,null,1
+lava,decomp.specials,3,0,1,character,1
+lava,decomp.specials,4,0,0,character,1
+lava,decomp.specials,5,0,0,logical,1
+lava,decomp.specials,6,0,0,logical,1
+lava,decomp.specials,7,0,0,...,1
+lava,density.sim,-1,0,0,"class<`matrix`, `summary.sim`>",1
+lava,density.sim,0,0,0,class<`matrix`>,1
+lava,density.sim,1,0,0,...,1
+lava,density.sim,2,0,0,character,1
+lava,deriv.lvm,-1,0,0,list<class<`matrix`>>,1
+lava,deriv.lvm,0,0,0,class<`lvm`>,1
+lava,deriv.lvm,1,0,0,any,1
+lava,deriv.lvm,2,0,0,any,1
+lava,deriv.lvm,3,0,0,logical,1
+lava,deriv.lvm,4,0,0,double[],1
+lava,deriv.lvm,4,0,1,null,1
+lava,deriv.lvm,5,0,0,double[],1
+lava,deriv.lvm,5,0,1,null,1
+lava,deriv.lvm,6,0,0,null,1
+lava,deriv.lvm,7,0,0,logical,1
+lava,descendants,-1,0,0,character[],1
+lava,descendants,0,0,0,class<`lvm`>,1
+lava,descendants,1,0,0,...,1
+lava,descendants.lvm,-1,0,0,character[],1
+lava,descendants.lvm,0,0,0,class<`lvm`>,1
+lava,descendants.lvm,1,0,0,character,1
+lava,descendants.lvm,2,0,0,...,1
+lava,describecoef,-1,0,0,list<character[]>,1
+lava,describecoef,0,0,0,class<`lvm`>,1
+lava,describecoef,1,0,0,any,1
+lava,describecoef,2,0,0,any,1
+lava,describecoef,3,0,0,any,1
+lava,describecoef,4,0,0,logical,1
+lava,DFS,-1,0,0,integer[],1
+lava,DFS,0,0,0,class<`matrix`>,1
+lava,DFS,1,0,0,integer,1
+lava,DFS,2,0,0,integer[],1
+lava,DFS,2,0,1,null,1
+lava,diagtest,-1,0,0,"class<`diagtest`, `estimate`>",1
+lava,diagtest,0,0,0,class<`table`>,1
+lava,diagtest,1,0,0,double,1
+lava,diagtest,2,0,0,logical,1
+lava,diagtest,3,0,0,null,1
+lava,diagtest,4,0,0,character[],1
+lava,diagtest,5,0,0,...,1
+lava,distribution,-1,0,0,list<any>,1
+lava,distribution,-1,0,1,null,1
+lava,distribution,0,0,0,class<`lvm`>,1
+lava,distribution,1,0,0,...,1
+lava,distribution,2,0,0,any,1
+lava,distribution<-,-1,0,0,class<`lvm`>,1
+lava,distribution<-,0,0,0,class<`lvm`>,1
+lava,distribution<-,1,0,0,...,1
+lava,distribution<-,2,0,0,class<`function`>,1
+lava,distribution<-,2,0,1,double,1
+lava,distribution<-,2,0,2,list<class<`function`>>,1
+lava,distribution<-.lvm,-1,0,0,class<`lvm`>,1
+lava,distribution<-.lvm,0,0,0,class<`lvm`>,1
+lava,distribution<-.lvm,1,0,0,character[],1
+lava,distribution<-.lvm,1,0,1,class<`formula`>,1
+lava,distribution<-.lvm,2,0,0,null,1
+lava,distribution<-.lvm,2,0,1,character,1
+lava,distribution<-.lvm,2,0,2,logical,1
+lava,distribution<-.lvm,3,0,0,any,1
+lava,distribution<-.lvm,4,0,0,logical,1
+lava,distribution<-.lvm,5,0,0,...,1
+lava,distribution<-.lvm,6,0,0,list<class<`function`>>,1
+lava,distribution<-.lvm,6,0,1,class<`function`>,1
+lava,distribution<-.lvm,6,0,2,double,1
+lava,distribution.lvm,-1,0,0,list<any>,1
+lava,distribution.lvm,-1,0,1,null,1
+lava,distribution.lvm,0,0,0,class<`lvm`>,1
+lava,distribution.lvm,1,0,0,any,1
+lava,distribution.lvm,2,0,0,any,1
+lava,distribution.lvm,3,0,0,logical,1
+lava,distribution.lvm,4,0,0,...,1
+lava,dsep,-1,0,0,logical,1
+lava,dsep,0,0,0,class<`lvm`>,1
+lava,dsep,1,0,0,...,1
+lava,dsep.lvm,-1,0,0,logical,1
+lava,dsep.lvm,0,0,0,class<`lvm`>,1
+lava,dsep.lvm,1,0,0,character[],1
+lava,dsep.lvm,1,0,1,class<`formula`>,1
+lava,dsep.lvm,2,0,0,character[],1
+lava,dsep.lvm,2,0,1,null,1
+lava,dsep.lvm,3,0,0,logical,1
+lava,dsep.lvm,4,0,0,...,1
+lava,edgelabels,-1,0,0,class<`lvm`>,1
+lava,edgelabels,0,0,0,class<`lvm`>,1
+lava,edgelabels,1,0,0,...,1
+lava,edgelabels<-,-1,0,0,class<`lvm`>,1
+lava,edgelabels<-,0,0,0,class<`lvm`>,1
+lava,edgelabels<-,1,0,0,...,1
+lava,edgelabels<-,2,0,0,double,1
+lava,edgelabels<-,2,0,1,expression,1
+lava,edgelabels<-.lvm,-1,0,0,class<`lvm`>,1
+lava,edgelabels<-.lvm,0,0,0,class<`lvm`>,1
+lava,edgelabels<-.lvm,1,0,0,class<`formula`>,1
+lava,edgelabels<-.lvm,2,0,0,...,1
+lava,edgelabels<-.lvm,3,0,0,double,1
+lava,edgelabels<-.lvm,3,0,1,expression,1
+lava,edgelabels.lvm,-1,0,0,class<`lvm`>,1
+lava,edgelabels.lvm,0,0,0,class<`lvm`>,1
+lava,edgelabels.lvm,1,0,0,double,1
+lava,edgelabels.lvm,1,0,1,expression,1
+lava,edgelabels.lvm,2,0,0,class<`formula`>,1
+lava,edgelabels.lvm,3,0,0,null,1
+lava,edgelabels.lvm,4,0,0,double[],1
+lava,edgelabels.lvm,5,0,0,double[],1
+lava,edgelabels.lvm,6,0,0,double,1
+lava,edgelabels.lvm,7,0,0,character[],1
+lava,effects.lvmfit,-1,0,0,class<`effects`>,1
+lava,effects.lvmfit,0,0,0,class<`lvmfit`>,1
+lava,effects.lvmfit,1,0,0,class<`formula`>,1
+lava,effects.lvmfit,2,0,0,any,1
+lava,effects.lvmfit,3,0,0,...,1
+lava,endogenous,-1,0,0,character[],1
+lava,endogenous,0,0,0,class<`lvm`>,1
+lava,endogenous,0,0,1,class<`lvmfit`>,1
+lava,endogenous,0,0,2,class<`lm`>,1
+lava,endogenous,0,0,3,"class<`lvmfit`, `multigroupfit`>",1
+lava,endogenous,0,0,4,class<`multigroup`>,1
+lava,endogenous,0,0,5,list<class<`lvm`>>,1
+lava,endogenous,1,0,0,...,1
+lava,endogenous.list,-1,0,0,character,1
+lava,endogenous.list,0,0,0,list<class<`lvm`>>,1
+lava,endogenous.list,1,0,0,...,1
+lava,endogenous.lm,-1,0,0,character,1
+lava,endogenous.lm,0,0,0,class<`lm`>,1
+lava,endogenous.lm,1,0,0,...,1
+lava,endogenous.lvm,-1,0,0,character[],1
+lava,endogenous.lvm,0,0,0,class<`lvm`>,1
+lava,endogenous.lvm,1,0,0,logical,1
+lava,endogenous.lvm,2,0,0,logical,1
+lava,endogenous.lvm,3,0,0,...,1
+lava,endogenous.lvmfit,-1,0,0,character[],1
+lava,endogenous.lvmfit,0,0,0,class<`lvmfit`>,1
+lava,endogenous.lvmfit,0,0,1,"class<`lvmfit`, `multigroupfit`>",1
+lava,endogenous.lvmfit,1,0,0,...,1
+lava,endogenous.multigroup,-1,0,0,character,1
+lava,endogenous.multigroup,0,0,0,class<`multigroup`>,1
+lava,endogenous.multigroup,1,0,0,...,1
+lava,estimate,-1,0,0,any,1
+lava,estimate,0,0,0,any,1
+lava,estimate,1,0,0,...,1
+lava,estimate.default,-1,0,0,any,1
+lava,estimate.default,0,0,0,"class<`glm`, `lm`>",1
+lava,estimate.default,0,0,1,null,1
+lava,estimate.default,0,0,2,class<`estimate`>,1
+lava,estimate.default,0,0,3,class<`lm`>,1
+lava,estimate.default,0,0,4,"class<`lvmfit`, `multigroupfit`>",1
+lava,estimate.default,0,0,5,class<`multinomial`>,1
+lava,estimate.default,0,0,6,double[],1
+lava,estimate.default,1,0,0,any,1
+lava,estimate.default,2,0,0,...,1
+lava,estimate.default,3,0,0,any,1
+lava,estimate.default,4,0,0,any,1
+lava,estimate.default,5,0,0,any,1
+lava,estimate.default,6,0,0,logical,1
+lava,estimate.default,7,0,0,logical,1
+lava,estimate.formula,-1,0,0,"class<`glm`, `lm`>",1
+lava,estimate.formula,0,0,0,class<`formula`>,1
+lava,estimate.formula,1,0,0,class<`data.frame`>,1
+lava,estimate.formula,2,0,0,any,1
+lava,estimate.formula,3,0,0,any,1
+lava,estimate.formula,4,0,0,...,1
+lava,estimate.formula,5,0,0,character,1
+lava,estimate.formula,6,0,0,logical,1
+lava,estimate.glm,-1,0,0,class<`estimate`>,1
+lava,estimate.glm,0,0,0,"class<`glm`, `lm`>",1
+lava,estimate.glm,1,0,0,...,1
+lava,estimate.list,-1,0,0,any,1
+lava,estimate.list,0,0,0,list<class<`lvm`>>,1
+lava,estimate.list,0,0,1,list<double[]>,1
+lava,estimate.list,1,0,0,...,1
+lava,estimate.lvm,-1,0,0,class<`lvmfit`>,1
+lava,estimate.lvm,-1,0,1,"class<`lvm.missing`, `lvmfit`>",1
+lava,estimate.lvm,-1,0,2,double[],1
+lava,estimate.lvm,0,0,0,class<`lvm`>,1
+lava,estimate.lvm,1,0,0,class<`data.frame`>,1
+lava,estimate.lvm,1,0,1,list<class<`matrix`> | double[]>,1
+lava,estimate.lvm,2,0,0,character,1
+lava,estimate.lvm,2,0,1,null,1
+lava,estimate.lvm,3,0,0,list<any>,1
+lava,estimate.lvm,4,0,0,logical,1
+lava,estimate.lvm,5,0,0,any,1
+lava,estimate.lvm,6,0,0,any,1
+lava,estimate.lvm,7,0,0,any,1
+lava,estimate.lvmlist,-1,0,0,"class<`lvmfit`, `multigroupfit`>",1
+lava,estimate.lvmlist,0,0,0,list<class<`lvm`>>,1
+lava,estimate.lvmlist,1,0,0,list<class<`data.frame`>>,1
+lava,estimate.lvmlist,2,0,0,any,1
+lava,estimate.lvmlist,3,0,0,any,1
+lava,estimate.lvmlist,4,0,0,logical,1
+lava,estimate.lvmlist,5,0,0,...,1
+lava,estimate.MAR,-1,0,0,"class<`lvm.missing`, `lvmfit`>",1
+lava,estimate.MAR,0,0,0,class<`lvm`>,1
+lava,estimate.MAR,1,0,0,class<`data.frame`>,1
+lava,estimate.MAR,2,0,0,character[],1
+lava,estimate.MAR,3,0,0,logical,1
+lava,estimate.MAR,4,0,0,double,1
+lava,estimate.MAR,5,0,0,logical,1
+lava,estimate.MAR,6,0,0,list<character | double[]>,1
+lava,estimate.MAR,7,0,0,double,1
+lava,estimate.multigroup,-1,0,0,"class<`lvmfit`, `multigroupfit`>",1
+lava,estimate.multigroup,0,0,0,class<`multigroup`>,1
+lava,estimate.multigroup,1,0,0,list<any>,1
+lava,estimate.multigroup,2,0,0,null,1
+lava,estimate.multigroup,2,0,1,character,1
+lava,estimate.multigroup,3,0,0,any,1
+lava,estimate.multigroup,4,0,0,any,1
+lava,estimate.multigroup,5,0,0,any,1
+lava,estimate.multigroup,6,0,0,null,1
+lava,estimate.multigroup,7,0,0,double,1
+lava,eventTime,-1,0,0,class<`lvm`>,1
+lava,eventTime,-1,0,1,null,1
+lava,eventTime,0,0,0,class<`lvm`>,1
+lava,eventTime,1,0,0,any,1
+lava,eventTime,2,0,0,character,1
+lava,eventTime,3,0,0,...,1
+lava,eventTime<-,-1,0,0,class<`lvm`>,1
+lava,eventTime<-,0,0,0,class<`lvm`>,1
+lava,eventTime<-,1,0,0,...,1
+lava,eventTime<-,2,0,0,class<`formula`>,1
+lava,exogenous,-1,0,0,character[],1
+lava,exogenous,-1,0,1,null,1
+lava,exogenous,0,0,0,class<`lvm`>,1
+lava,exogenous,0,0,1,list<class<`lvm`>>,1
+lava,exogenous,0,0,2,class<`lvmfit`>,1
+lava,exogenous,1,0,0,...,1
+lava,exogenous<-,-1,0,0,class<`lvm`>,1
+lava,exogenous<-,0,0,0,class<`lvm`>,1
+lava,exogenous<-,1,0,0,...,1
+lava,exogenous<-,2,0,0,character[],1
+lava,exogenous<-,2,0,1,null,1
+lava,exogenous.list,-1,0,0,character[],1
+lava,exogenous.list,0,0,0,list<class<`lvm`>>,1
+lava,exogenous.list,1,0,0,...,1
+lava,exogenous<-.lvm,-1,0,0,class<`lvm`>,1
+lava,exogenous<-.lvm,0,0,0,class<`lvm`>,1
+lava,exogenous<-.lvm,1,0,0,logical,1
+lava,exogenous<-.lvm,2,0,0,...,1
+lava,exogenous<-.lvm,3,0,0,character[],1
+lava,exogenous<-.lvm,3,0,1,null,1
+lava,exogenous.lvm,-1,0,0,character[],1
+lava,exogenous.lvm,-1,0,1,null,1
+lava,exogenous.lvm,0,0,0,class<`lvm`>,1
+lava,exogenous.lvm,1,0,0,any,1
+lava,exogenous.lvm,2,0,0,logical,1
+lava,exogenous.lvm,3,0,0,logical,1
+lava,exogenous.lvm,4,0,0,...,1
+lava,exogenous.lvmfit,-1,0,0,character,1
+lava,exogenous.lvmfit,0,0,0,class<`lvmfit`>,1
+lava,exogenous.lvmfit,1,0,0,...,1
+lava,Expand,-1,0,0,class<`data.frame`>,1
+lava,Expand,0,0,0,any,1
+lava,Expand,1,0,0,...,1
+lava,extractvar,-1,0,0,list<character[]>,1
+lava,extractvar,0,0,0,class<`formula`>,1
+lava,family.zibreg,-1,0,0,class<`family`>,1
+lava,family.zibreg,0,0,0,class<`zibreg`>,1
+lava,family.zibreg,1,0,0,...,1
+lava,fixsome,-1,0,0,class<`lvm`>,1
+lava,fixsome,0,0,0,class<`lvm`>,1
+lava,fixsome,1,0,0,logical,1
+lava,fixsome,2,0,0,logical,1
+lava,fixsome,3,0,0,any,1
+lava,fixsome,4,0,0,any,1
+lava,fixsome,5,0,0,any,1
+lava,fixsome,6,0,0,any,1
+lava,fixsome,7,0,0,logical,1
+lava,foldr,-1,0,0,list<list<integer[]>>,1
+lava,foldr,0,0,0,double,1
+lava,foldr,1,0,0,double,1
+lava,foldr,2,0,0,double,1
+lava,forestplot,-1,0,0,null,1
+lava,forestplot,0,0,0,class<`matrix`>,1
+lava,forestplot,1,0,0,any,1
+lava,forestplot,2,0,0,any,1
+lava,forestplot,3,0,0,double,1
+lava,forestplot,4,0,0,any,1
+lava,forestplot,5,0,0,logical,1
+lava,forestplot,6,0,0,logical,1
+lava,forestplot,7,0,0,null,1
+lava,forwardsearch,-1,0,0,class<`modelsearch`>,1
+lava,forwardsearch,0,0,0,class<`lvmfit`>,1
+lava,forwardsearch,1,0,0,double,1
+lava,forwardsearch,2,0,0,double,1
+lava,forwardsearch,3,0,0,character,1
+lava,forwardsearch,4,0,0,null,1
+lava,forwardsearch,5,0,0,...,1
+lava,%++%.function,-1,0,0,class<`function`>,1
+lava,%++%.function,0,0,0,any,1
+lava,%++%.function,1,0,0,class<`function`>,1
+lava,functional,-1,0,0,list<any>,1
+lava,functional,0,0,0,class<`lvm`>,1
+lava,functional,1,0,0,...,1
+lava,functional<-,-1,0,0,class<`lvm`>,1
+lava,functional<-,0,0,0,class<`lvm`>,1
+lava,functional<-,1,0,0,...,1
+lava,functional<-,2,0,0,class<`function`>,1
+lava,functional<-.lvm,-1,0,0,class<`lvm`>,1
+lava,functional<-.lvm,0,0,0,class<`lvm`>,1
+lava,functional<-.lvm,1,0,0,character,1
+lava,functional<-.lvm,1,0,1,class<`formula`>,1
+lava,functional<-.lvm,2,0,0,any,1
+lava,functional<-.lvm,3,0,0,...,1
+lava,functional<-.lvm,4,0,0,class<`function`>,1
+lava,functional.lvm,-1,0,0,list<any>,1
+lava,functional.lvm,0,0,0,class<`lvm`>,1
+lava,functional.lvm,1,0,0,any,1
+lava,functional.lvm,2,0,0,any,1
+lava,functional.lvm,3,0,0,any,1
+lava,functional.lvm,4,0,0,...,1
+lava,Gamma.lvm,-1,0,0,class<`function`>,1
+lava,Gamma.lvm,0,0,0,character,1
+lava,Gamma.lvm,1,0,0,double,1
+lava,Gamma.lvm,2,0,0,any,1
+lava,Gamma.lvm,3,0,0,logical,1
+lava,Gamma.lvm,4,0,0,logical,1
+lava,Gamma.lvm,5,0,0,logical,1
+lava,Gamma.lvm,6,0,0,...,1
+lava,gaussian_gradient.lvm,-1,0,0,double[],1
+lava,gaussian_gradient.lvm,0,0,0,class<`lvm`>,1
+lava,gaussian_gradient.lvm,1,0,0,double[],1
+lava,gaussian_gradient.lvm,2,0,0,class<`data.frame`>,1
+lava,gaussian_gradient.lvm,2,0,1,list<class<`matrix`> | double[]>,1
+lava,gaussian_gradient.lvm,3,0,0,class<`matrix`>,1
+lava,gaussian_gradient.lvm,4,0,0,double[],1
+lava,gaussian_gradient.lvm,5,0,0,integer,1
+lava,gaussian_gradient.lvm,6,0,0,...,1
+lava,gaussian_hessian.lvm,-1,0,0,class<`matrix`>,1
+lava,gaussian_hessian.lvm,0,0,0,class<`lvm`>,1
+lava,gaussian_hessian.lvm,1,0,0,double[],1
+lava,gaussian_hessian.lvm,2,0,0,integer,1
+lava,gaussian_hessian.lvm,3,0,0,...,1
+lava,gaussian_objective.lvm,-1,0,0,double,1
+lava,gaussian_objective.lvm,0,0,0,class<`lvm`>,1
+lava,gaussian_objective.lvm,1,0,0,double[],1
+lava,gaussian_objective.lvm,2,0,0,class<`data.frame`>,1
+lava,gaussian_objective.lvm,2,0,1,list<class<`matrix`> | double[]>,1
+lava,gaussian_objective.lvm,3,0,0,class<`matrix`>,1
+lava,gaussian_objective.lvm,4,0,0,double[],1
+lava,gaussian_objective.lvm,5,0,0,integer,1
+lava,gaussian_objective.lvm,6,0,0,...,1
+lava,gaussian_score.lvm,-1,0,0,class<`matrix`>,1
+lava,gaussian_score.lvm,0,0,0,class<`lvm`>,1
+lava,gaussian_score.lvm,1,0,0,null,1
+lava,gaussian_score.lvm,1,0,1,class<`data.frame`>,1
+lava,gaussian_score.lvm,2,0,0,double[],1
+lava,gaussian_score.lvm,3,0,0,any,1
+lava,gaussian_score.lvm,4,0,0,any,1
+lava,gaussian_score.lvm,5,0,0,double[],1
+lava,gaussian_score.lvm,5,0,1,null,1
+lava,gaussian_score.lvm,6,0,0,any,1
+lava,gaussian_score.lvm,7,0,0,logical,1
+lava,gethook,-1,0,0,character[],1
+lava,gethook,-1,0,1,null,1
+lava,gethook,0,0,0,character,1
+lava,gethook,1,0,0,...,1
+lava,getMeanVar,-1,0,0,list<list<double[] | class<`matrix`>>>,1
+lava,getMeanVar,-1,0,1,list<list<double | class<`matrix`>>>,1
+lava,getMeanVar,0,0,0,"class<`lvm.mixture`, `mvn.mixture`>",1
+lava,getMeanVar,1,0,0,any,1
+lava,getMeanVar,2,0,0,any,1
+lava,getMeanVar,3,0,0,...,1
+lava,getoutcome,-1,0,0,character,1
+lava,getoutcome,-1,0,1,list<any>,1
+lava,getoutcome,0,0,0,class<`formula`>,1
+lava,getoutcome,1,0,0,any,1
+lava,getoutcome,2,0,0,...,1
+lava,gfilter,-1,0,0,class<`matrix`>,1
+lava,gfilter,0,0,0,class<`matrix`>,1
+lava,gfilter,1,0,0,double,1
+lava,gkgamma,-1,0,0,"class<`estimate`, `gkgamma`>",1
+lava,gkgamma,0,0,0,class<`data.frame`>,1
+lava,gkgamma,0,0,1,class<`formula`>,1
+lava,gkgamma,1,0,0,environment,1
+lava,gkgamma,1,0,1,class<`data.frame`>,1
+lava,gkgamma,2,0,0,null,1
+lava,gkgamma,3,0,0,logical,1
+lava,gkgamma,4,0,0,logical,1
+lava,gkgamma,5,0,0,...,1
+lava,GLMest,-1,0,0,list<any>,1
+lava,GLMest,0,0,0,class<`lvm`>,1
+lava,GLMest,1,0,0,class<`data.frame`>,1
+lava,GLMest,2,0,0,list<any>,1
+lava,GLMest,3,0,0,...,1
+lava,glm.estimate.hook,-1,0,0,list<any>,1
+lava,glm.estimate.hook,0,0,0,class<`lvm`>,1
+lava,glm.estimate.hook,1,0,0,character,1
+lava,glm.estimate.hook,1,0,1,null,1
+lava,glm.estimate.hook,2,0,0,...,1
+lava,glm_objective.lvm,-1,0,0,list<any>,1
+lava,glm_objective.lvm,0,0,0,class<`lvm`>,1
+lava,glm_objective.lvm,1,0,0,any,1
+lava,glm_objective.lvm,2,0,0,class<`data.frame`>,1
+lava,glm_objective.lvm,3,0,0,...,1
+lava,glm_variance.lvm,-1,0,0,class<`matrix`>,1
+lava,glm_variance.lvm,0,0,0,class<`lvm`>,1
+lava,glm_variance.lvm,1,0,0,double[],1
+lava,glm_variance.lvm,2,0,0,class<`data.frame`>,1
+lava,glm_variance.lvm,3,0,0,list<any>,1
+lava,glm_variance.lvm,4,0,0,...,1
+lava,gof,-1,0,0,class<`gof.lvmfit`>,1
+lava,gof,0,0,0,class<`lvmfit`>,1
+lava,gof,0,0,1,"class<`lvmfit`, `multigroupfit`>",1
+lava,gof,1,0,0,...,1
+lava,gof.lvmfit,-1,0,0,class<`gof.lvmfit`>,1
+lava,gof.lvmfit,0,0,0,class<`lvmfit`>,1
+lava,gof.lvmfit,0,0,1,"class<`lvmfit`, `multigroupfit`>",1
+lava,gof.lvmfit,1,0,0,logical,1
+lava,gof.lvmfit,2,0,0,double,1
+lava,gof.lvmfit,3,0,0,double,1
+lava,gof.lvmfit,4,0,0,logical,1
+lava,gof.lvmfit,5,0,0,...,1
+lava,goodmankruskal_gamma,-1,0,0,list<double>,1
+lava,goodmankruskal_gamma,0,0,0,class<`table`>,1
+lava,goodmankruskal_gamma,1,0,0,...,1
+lava,Graph,-1,0,0,null,1
+lava,Graph,0,0,0,class<`lvm`>,1
+lava,Graph,1,0,0,...,1
+lava,Graph.lvm,-1,0,0,null,1
+lava,Graph.lvm,0,0,0,class<`lvm`>,1
+lava,Graph.lvm,1,0,0,logical,1
+lava,Graph.lvm,2,0,0,...,1
+lava,Grep,-1,0,0,class<`data.frame`>,1
+lava,Grep,0,0,0,class<`data.frame`>,1
+lava,Grep,1,0,0,character,1
+lava,Grep,2,0,0,logical,1
+lava,Grep,3,0,0,logical,1
+lava,Grep,4,0,0,...,1
+lava,heavytail,-1,0,0,null,1
+lava,heavytail,0,0,0,class<`lvm`>,1
+lava,heavytail,1,0,0,...,1
+lava,heavytail.init.hook,-1,0,0,class<`lvm`>,1
+lava,heavytail.init.hook,0,0,0,class<`lvm`>,1
+lava,heavytail.init.hook,1,0,0,...,1
+lava,heavytail.lvm,-1,0,0,null,1
+lava,heavytail.lvm,0,0,0,class<`lvm`>,1
+lava,heavytail.lvm,1,0,0,null,1
+lava,heavytail.lvm,2,0,0,double,1
+lava,heavytail.lvm,3,0,0,...,1
+lava,heavytail.sim.hook,-1,0,0,class<`matrix`>,1
+lava,heavytail.sim.hook,0,0,0,class<`lvm`>,1
+lava,heavytail.sim.hook,1,0,0,class<`matrix`>,1
+lava,heavytail.sim.hook,2,0,0,...,1
+lava,iid,-1,0,0,class<`matrix`>,1
+lava,iid,0,0,0,class<`multinomial`>,1
+lava,iid,0,0,1,"class<`lvmfit`, `multigroupfit`>",1
+lava,iid,0,0,2,class<`estimate`>,1
+lava,iid,0,0,3,"class<`estimate`, `gkgamma`>",1
+lava,iid,0,0,4,"class<`glm`, `lm`>",1
+lava,iid,0,0,5,class<`lm`>,1
+lava,iid,0,0,6,class<`lvmfit`>,1
+lava,iid,0,0,7,class<`data.frame`>,1
+lava,iid,0,0,8,class<`matrix`>,1
+lava,iid,1,0,0,...,1
+lava,iid.data.frame,-1,0,0,class<`matrix`>,1
+lava,iid.data.frame,0,0,0,class<`data.frame`>,1
+lava,iid.data.frame,1,0,0,...,1
+lava,iid.default,-1,0,0,class<`matrix`>,1
+lava,iid.default,0,0,0,"class<`lvmfit`, `multigroupfit`>",1
+lava,iid.default,0,0,1,"class<`glm`, `lm`>",1
+lava,iid.default,0,0,2,class<`lm`>,1
+lava,iid.default,0,0,3,class<`lvmfit`>,1
+lava,iid.default,1,0,0,any,1
+lava,iid.default,2,0,0,null,1
+lava,iid.default,3,0,0,double,1
+lava,iid.default,4,0,0,double,1
+lava,iid.default,5,0,0,...,1
+lava,iid.estimate,-1,0,0,class<`matrix`>,1
+lava,iid.estimate,0,0,0,class<`estimate`>,1
+lava,iid.estimate,0,0,1,"class<`estimate`, `gkgamma`>",1
+lava,iid.estimate,1,0,0,...,1
+lava,iid.glm,-1,0,0,class<`matrix`>,1
+lava,iid.glm,0,0,0,"class<`glm`, `lm`>",1
+lava,iid.glm,1,0,0,...,1
+lava,iid.matrix,-1,0,0,class<`matrix`>,1
+lava,iid.matrix,0,0,0,class<`matrix`>,1
+lava,iid.matrix,1,0,0,...,1
+lava,iid.multigroupfit,-1,0,0,class<`matrix`>,1
+lava,iid.multigroupfit,0,0,0,"class<`lvmfit`, `multigroupfit`>",1
+lava,iid.multigroupfit,1,0,0,...,1
+lava,iid.multinomial,-1,0,0,class<`matrix`>,1
+lava,iid.multinomial,0,0,0,class<`multinomial`>,1
+lava,iid.multinomial,1,0,0,...,1
+lava,images,-1,0,0,null,1
+lava,images,0,0,0,class<`matrix`>,1
+lava,images,0,0,1,list<class<`matrix`>>,1
+lava,images,1,0,0,any,1
+lava,images,2,0,0,double,1
+lava,images,3,0,0,logical,1
+lava,images,4,0,0,double,1
+lava,images,5,0,0,double,1
+lava,images,6,0,0,double,1
+lava,images,7,0,0,logical,1
+lava,img,-1,0,0,null,1
+lava,img,0,0,0,class<`matrix`>,1
+lava,img,1,0,0,list<integer[]>,1
+lava,img,2,0,0,list<character[]>,1
+lava,img,3,0,0,character,1
+lava,img,4,0,0,character,1
+lava,img,5,0,0,logical,1
+lava,img,6,0,0,double,1
+lava,img,7,0,0,logical,1
+lava,impute0,-1,0,0,class<`matrix`>,1
+lava,impute0,-1,0,1,double[],1
+lava,impute0,0,0,0,class<`matrix`>,1
+lava,impute0,0,0,1,^double[],1
+lava,impute0,1,0,0,null,1
+lava,impute0,1,0,1,class<`omit`>,1
+lava,impute0,2,0,0,any,1
+lava,impute0,3,0,0,any,1
+lava,impute0,4,0,0,any,1
+lava,impute0,5,0,0,...,1
+lava,index,-1,0,0,list<any>,1
+lava,index,-1,0,1,null,1
+lava,index,0,0,0,class<`lvm`>,1
+lava,index,0,0,1,class<`lvmfit`>,1
+lava,index,1,0,0,...,1
+lava,index<-,-1,0,0,class<`lvm`>,1
+lava,index<-,0,0,0,class<`lvm`>,1
+lava,index<-,1,0,0,...,1
+lava,index<-,2,0,0,list<any>,1
+lava,index<-.lvm,-1,0,0,class<`lvm`>,1
+lava,index<-.lvm,0,0,0,class<`lvm`>,1
+lava,index<-.lvm,1,0,0,...,1
+lava,index<-.lvm,2,0,0,list<any>,1
+lava,index.lvm,-1,0,0,null,1
+lava,index.lvm,-1,0,1,list<any>,1
+lava,index.lvm,0,0,0,class<`lvm`>,1
+lava,index.lvm,1,0,0,...,1
+lava,index.lvmfit,-1,0,0,list<any>,1
+lava,index.lvmfit,0,0,0,class<`lvmfit`>,1
+lava,index.lvmfit,1,0,0,...,1
+lava,information,-1,0,0,class<`matrix`>,1
+lava,information,0,0,0,class<`lvm`>,1
+lava,information,0,0,1,"class<`lvmfit`, `multigroupfit`>",1
+lava,information,0,0,2,"class<`lvm.missing`, `lvmfit`>",1
+lava,information,0,0,3,class<`multigroup`>,1
+lava,information,0,0,4,"class<`lvm.mixture`, `mvn.mixture`>",1
+lava,information,1,0,0,...,1
+lava,information.lvm,-1,0,0,class<`matrix`>,1
+lava,information.lvm,0,0,0,class<`lvm`>,1
+lava,information.lvm,1,0,0,double[],1
+lava,information.lvm,2,0,0,any,1
+lava,information.lvm,3,0,0,character,1
+lava,information.lvm,4,0,0,class<`data.frame`>,1
+lava,information.lvm,4,0,1,list<class<`matrix`> | double[]>,1
+lava,information.lvm,5,0,0,null,1
+lava,information.lvm,6,0,0,null,1
+lava,information.lvm,7,0,0,character,1
+lava,information.lvm.missing,-1,0,0,class<`matrix`>,1
+lava,information.lvm.missing,0,0,0,"class<`lvm.missing`, `lvmfit`>",1
+lava,information.lvm.missing,1,0,0,double[],1
+lava,information.lvm.missing,2,0,0,character,1
+lava,information.lvm.missing,3,0,0,null,1
+lava,information.lvm.missing,4,0,0,...,1
+lava,information.lvm.mixture,-1,0,0,class<`matrix`>,1
+lava,information.lvm.mixture,0,0,0,"class<`lvm.mixture`, `mvn.mixture`>",1
+lava,information.lvm.mixture,1,0,0,double[],1
+lava,information.lvm.mixture,2,0,0,...,1
+lava,information.lvm.mixture,3,0,0,character,1
+lava,information.multigroup,-1,0,0,class<`matrix`>,1
+lava,information.multigroup,0,0,0,class<`multigroup`>,1
+lava,information.multigroup,1,0,0,list<class<`data.frame`>>,1
+lava,information.multigroup,2,0,0,null,1
+lava,information.multigroup,3,0,0,double[],1
+lava,information.multigroup,4,0,0,logical,1
+lava,information.multigroup,5,0,0,...,1
+lava,information.multigroupfit,-1,0,0,class<`matrix`>,1
+lava,information.multigroupfit,0,0,0,"class<`lvmfit`, `multigroupfit`>",1
+lava,information.multigroupfit,1,0,0,double[],1
+lava,information.multigroupfit,2,0,0,null,1
+lava,information.multigroupfit,3,0,0,character,1
+lava,information.multigroupfit,4,0,0,...,1
+lava,intercept,-1,0,0,class<`fix`>,1
+lava,intercept,0,0,0,class<`lvm`>,1
+lava,intercept,1,0,0,...,1
+lava,intercept<-,-1,0,0,class<`lvm`>,1
+lava,intercept<-,0,0,0,class<`lvm`>,1
+lava,intercept<-,1,0,0,...,1
+lava,intercept<-,2,0,0,character,1
+lava,intercept<-,2,0,1,class<`formula`>,1
+lava,intercept<-,2,0,2,double[],1
+lava,intercept<-,2,0,3,list<double | character>,1
+lava,intercept<-,2,0,4,null,1
+lava,intercept<-,2,0,5,list<null>,1
+lava,intercept<-,2,0,6,list<double>,1
+lava,intercept<-,2,0,7,list<double | null>,1
+lava,intercept<-.lvm,-1,0,0,class<`lvm`>,1
+lava,intercept<-.lvm,0,0,0,class<`lvm`>,1
+lava,intercept<-.lvm,1,0,0,any,1
+lava,intercept<-.lvm,2,0,0,...,1
+lava,intercept<-.lvm,3,0,0,list<null>,1
+lava,intercept<-.lvm,3,0,1,list<double>,1
+lava,intercept<-.lvm,3,0,2,list<double | null>,1
+lava,intercept<-.lvm,3,0,3,null,1
+lava,intercept<-.lvm,3,0,4,character,1
+lava,intercept<-.lvm,3,0,5,double[],1
+lava,intercept<-.lvm,3,0,6,list<double | character>,1
+lava,intercept<-.lvm,3,0,7,class<`formula`>,1
+lava,intercept.lvm,-1,0,0,class<`fix`>,1
+lava,intercept.lvm,0,0,0,class<`lvm`>,1
+lava,intercept.lvm,1,0,0,any,1
+lava,intercept.lvm,2,0,0,...,1
+lava,intfix,-1,0,0,class<`fix`>,1
+lava,intfix,0,0,0,class<`lvm`>,1
+lava,intfix,1,0,0,...,1
+lava,intfix<-,-1,0,0,class<`lvm`>,1
+lava,intfix<-,0,0,0,class<`lvm`>,1
+lava,intfix<-,1,0,0,...,1
+lava,intfix<-,2,0,0,character,1
+lava,intfix<-,2,0,1,double,1
+lava,intfix<-,2,0,2,list<null>,1
+lava,intfix<-.lvm,-1,0,0,class<`lvm`>,1
+lava,intfix<-.lvm,0,0,0,class<`lvm`>,1
+lava,intfix<-.lvm,1,0,0,any,1
+lava,intfix<-.lvm,2,0,0,...,1
+lava,intfix<-.lvm,3,0,0,list<null>,1
+lava,intfix<-.lvm,3,0,1,list<double>,1
+lava,intfix<-.lvm,3,0,2,list<double | null>,1
+lava,intfix<-.lvm,3,0,3,null,1
+lava,intfix<-.lvm,3,0,4,character,1
+lava,intfix<-.lvm,3,0,5,double[],1
+lava,intfix<-.lvm,3,0,6,list<double | character>,1
+lava,intfix<-.lvm,3,0,7,class<`formula`>,1
+lava,intfix.lvm,-1,0,0,class<`fix`>,1
+lava,intfix.lvm,0,0,0,class<`lvm`>,1
+lava,intfix.lvm,1,0,0,any,1
+lava,intfix.lvm,2,0,0,...,1
+lava,Inverse,-1,0,0,class<`matrix`>,1
+lava,Inverse,0,0,0,class<`matrix`>,1
+lava,Inverse,1,0,0,any,1
+lava,Inverse,2,0,0,logical,1
+lava,Inverse,3,0,0,any,1
+lava,Inverse,4,0,0,logical,1
+lava,Inverse,5,0,0,logical,1
+lava,izero,-1,0,0,double[],1
+lava,izero,0,0,0,integer[],1
+lava,izero,1,0,0,integer,1
+lava,kappa.data.frame,-1,0,0,class<`estimate`>,1
+lava,kappa.data.frame,0,0,0,class<`data.frame`>,1
+lava,kappa.data.frame,1,0,0,...,1
+lava,kappa.multinomial,-1,0,0,class<`estimate`>,1
+lava,kappa.multinomial,0,0,0,class<`multinomial`>,1
+lava,kappa.multinomial,1,0,0,logical,1
+lava,kappa.multinomial,2,0,0,...,1
+lava,kill,-1,0,0,class<`lvm`>,1
+lava,kill,0,0,0,class<`lvm`>,1
+lava,kill,1,0,0,...,1
+lava,kill.lvm,-1,0,0,class<`lvm`>,1
+lava,kill.lvm,0,0,0,class<`lvm`>,1
+lava,kill.lvm,1,0,0,character[],1
+lava,kill.lvm,1,0,1,class<`formula`>,1
+lava,kill.lvm,2,0,0,...,1
+lava,kmpp,-1,0,0,double[],1
+lava,kmpp,0,0,0,class<`matrix`>,1
+lava,kmpp,1,0,0,double,1
+lava,kronprod,-1,0,0,class<`matrix`>,1
+lava,kronprod,0,0,0,class<`matrix`>,1
+lava,kronprod,1,0,0,class<`matrix`>,1
+lava,kronprod,2,0,0,any,1
+lava,ksmooth2,-1,0,0,list<double[]>,1
+lava,ksmooth2,-1,0,1,list<double[] | class<`matrix`>>,1
+lava,ksmooth2,0,0,0,class<`function`>,1
+lava,ksmooth2,0,0,1,class<`matrix`>,1
+lava,ksmooth2,1,0,0,any,1
+lava,ksmooth2,2,0,0,null,1
+lava,ksmooth2,2,0,1,double,1
+lava,ksmooth2,3,0,0,null,1
+lava,ksmooth2,4,0,0,null,1
+lava,ksmooth2,5,0,0,character,1
+lava,ksmooth2,6,0,0,any,1
+lava,ksmooth2,7,0,0,...,1
+lava,labels<-,-1,0,0,class<`lvm`>,1
+lava,labels<-,0,0,0,class<`lvm`>,1
+lava,labels<-,1,0,0,...,1
+lava,labels<-,2,0,0,expression,1
+lava,labels<-,2,0,1,list<character>,1
+lava,labels<-.default,-1,0,0,class<`lvm`>,1
+lava,labels<-.default,0,0,0,class<`lvm`>,1
+lava,labels<-.default,1,0,0,...,1
+lava,labels<-.default,2,0,0,expression,1
+lava,labels<-.default,2,0,1,list<character>,1
+lava,labels.lvm,-1,0,0,class<`lvm`>,1
+lava,labels.lvm,0,0,0,class<`lvm`>,1
+lava,labels.lvm,1,0,0,expression,1
+lava,labels.lvm,1,0,1,list<character>,1
+lava,labels.lvm,2,0,0,...,1
+lava,latent,-1,0,0,character[],1
+lava,latent,-1,0,1,class<`lvm`>,1
+lava,latent,-1,0,2,null,1
+lava,latent,0,0,0,class<`lvm`>,1
+lava,latent,0,0,1,class<`lvmfit`>,1
+lava,latent,1,0,0,...,1
+lava,latent<-,-1,0,0,class<`lvm`>,1
+lava,latent<-,0,0,0,class<`lvm`>,1
+lava,latent<-,1,0,0,...,1
+lava,latent<-,2,0,0,character[],1
+lava,latent<-,2,0,1,class<`formula`>,1
+lava,latent<-.lvm,-1,0,0,class<`lvm`>,1
+lava,latent<-.lvm,0,0,0,class<`lvm`>,1
+lava,latent<-.lvm,1,0,0,logical,1
+lava,latent<-.lvm,2,0,0,...,1
+lava,latent<-.lvm,3,0,0,character[],1
+lava,latent<-.lvm,3,0,1,class<`formula`>,1
+lava,latent.lvm,-1,0,0,character[],1
+lava,latent.lvm,-1,0,1,class<`lvm`>,1
+lava,latent.lvm,-1,0,2,null,1
+lava,latent.lvm,0,0,0,class<`lvm`>,1
+lava,latent.lvm,1,0,0,any,1
+lava,latent.lvm,2,0,0,logical,1
+lava,latent.lvm,3,0,0,any,1
+lava,latent.lvm,4,0,0,...,1
+lava,latent.lvmfit,-1,0,0,character,1
+lava,latent.lvmfit,0,0,0,class<`lvmfit`>,1
+lava,latent.lvmfit,1,0,0,logical,1
+lava,latent.lvmfit,2,0,0,...,1
+lava,lava,-1,0,0,class<`matrix`>,1
+lava,lava,0,0,0,any,1
+lava,lava,1,0,0,double,1
+lava,lava,2,0,0,double,1
+lava,lava,3,0,0,double,1
+lava,lava,4,0,0,double,1
+lava,lava,5,0,0,double,1
+lava,lava,6,0,0,double,1
+lava,lava,7,0,0,character[],1
+lava,lava.options,-1,0,0,list<double | character[]>,1
+lava,lava.options,0,0,0,...,1
+lava,loggamma.lvm,-1,0,0,class<`function`>,1
+lava,loggamma.lvm,0,0,0,...,1
+lava,logLik.lvm,-1,0,0,class<`logLik`>,1
+lava,logLik.lvm,0,0,0,class<`lvm`>,1
+lava,logLik.lvm,1,0,0,any,1
+lava,logLik.lvm,2,0,0,class<`data.frame`>,1
+lava,logLik.lvm,3,0,0,character,1
+lava,logLik.lvm,4,0,0,logical,1
+lava,logLik.lvm,5,0,0,any,1
+lava,logLik.lvm,6,0,0,any,1
+lava,logLik.lvm,7,0,0,any,1
+lava,logLik.lvmfit,-1,0,0,class<`logLik`>,1
+lava,logLik.lvmfit,0,0,0,class<`lvmfit`>,1
+lava,logLik.lvmfit,1,0,0,double[],1
+lava,logLik.lvmfit,2,0,0,class<`data.frame`>,1
+lava,logLik.lvmfit,3,0,0,character,1
+lava,logLik.lvmfit,4,0,0,any,1
+lava,logLik.lvmfit,5,0,0,any,1
+lava,logLik.lvmfit,6,0,0,...,1
+lava,logLik.multigroup,-1,0,0,class<`logLik`>,1
+lava,logLik.multigroup,0,0,0,class<`multigroup`>,1
+lava,logLik.multigroup,1,0,0,double[],1
+lava,logLik.multigroup,2,0,0,any,1
+lava,logLik.multigroup,3,0,0,any,1
+lava,logLik.multigroup,4,0,0,character[],1
+lava,logLik.multigroup,5,0,0,...,1
+lava,logLik.multigroupfit,-1,0,0,class<`logLik`>,1
+lava,logLik.multigroupfit,0,0,0,"class<`lvmfit`, `multigroupfit`>",1
+lava,logLik.multigroupfit,1,0,0,double[],1
+lava,logLik.multigroupfit,2,0,0,any,1
+lava,logLik.multigroupfit,3,0,0,any,1
+lava,logLik.multigroupfit,4,0,0,...,1
+lava,logLik.zibreg,-1,0,0,class<`logLik`>,1
+lava,logLik.zibreg,0,0,0,class<`zibreg`>,1
+lava,logLik.zibreg,1,0,0,double[],1
+lava,logLik.zibreg,2,0,0,double[],1
+lava,logLik.zibreg,3,0,0,any,1
+lava,logLik.zibreg,4,0,0,null,1
+lava,logLik.zibreg,5,0,0,logical,1
+lava,logLik.zibreg,6,0,0,...,1
+lava,lvm,-1,0,0,class<`lvm`>,1
+lava,lvm,0,0,0,character[],1
+lava,lvm,0,0,1,class<`formula`>,1
+lava,lvm,0,0,2,list<class<`formula`>>,1
+lava,lvm,0,0,3,null,1
+lava,lvm,1,0,0,...,1
+lava,lvm,2,0,0,null,1
+lava,lvm,2,0,1,class<`formula`>,1
+lava,lvm,3,0,0,any,1
+lava,makemissing,-1,0,0,class<`data.frame`>,1
+lava,makemissing,0,0,0,class<`data.frame`>,1
+lava,makemissing,1,0,0,double,1
+lava,makemissing,2,0,0,integer[],1
+lava,makemissing,3,0,0,logical,1
+lava,makemissing,4,0,0,class<`function`>,1
+lava,makemissing,5,0,0,null,1
+lava,manifest,-1,0,0,character[],1
+lava,manifest,0,0,0,class<`lvm`>,1
+lava,manifest,0,0,1,class<`lvmfit`>,1
+lava,manifest,0,0,2,"class<`lvmfit`, `multigroupfit`>",1
+lava,manifest,0,0,3,class<`multigroup`>,1
+lava,manifest,0,0,4,list<class<`lvm`>>,1
+lava,manifest,1,0,0,...,1
+lava,manifest.list,-1,0,0,character[],1
+lava,manifest.list,0,0,0,list<class<`lvm`>>,1
+lava,manifest.list,1,0,0,...,1
+lava,manifest.lvm,-1,0,0,character[],1
+lava,manifest.lvm,0,0,0,class<`lvm`>,1
+lava,manifest.lvm,1,0,0,...,1
+lava,manifest.lvmfit,-1,0,0,character[],1
+lava,manifest.lvmfit,0,0,0,class<`lvmfit`>,1
+lava,manifest.lvmfit,0,0,1,"class<`lvmfit`, `multigroupfit`>",1
+lava,manifest.lvmfit,0,0,2,class<`multigroup`>,1
+lava,manifest.lvmfit,1,0,0,...,1
+lava,manifest.multigroup,-1,0,0,character[],1
+lava,manifest.multigroup,0,0,0,class<`lvmfit`>,1
+lava,manifest.multigroup,0,0,1,"class<`lvmfit`, `multigroupfit`>",1
+lava,manifest.multigroup,0,0,2,class<`multigroup`>,1
+lava,manifest.multigroup,1,0,0,...,1
+lava,mat.lvm,-1,0,0,list<class<`matrix`> | null | list<any>>,1
+lava,mat.lvm,-1,0,1,list<class<`matrix`> | null | list<double[]>>,1
+lava,mat.lvm,-1,0,2,list<class<`matrix`> | list<double[] | list<integer | null>>>,1
+lava,mat.lvm,-1,0,3,list<class<`matrix`> | list<double[] | list<null | integer[]>>>,1
+lava,mat.lvm,0,0,0,class<`lvm`>,1
+lava,mat.lvm,1,0,0,list<any>,1
+lava,mat.lvm,2,0,0,...,1
+lava,matrices,-1,0,0,list<any>,1
+lava,matrices,0,0,0,class<`lvm`>,1
+lava,matrices,1,0,0,...,1
+lava,matrices2,-1,0,0,list<any>,1
+lava,matrices2,0,0,0,class<`lvm`>,1
+lava,matrices2,1,0,0,integer[],1
+lava,matrices2,2,0,0,...,1
+lava,matrices.lvm,-1,0,0,list<any>,1
+lava,matrices.lvm,0,0,0,class<`lvm`>,1
+lava,matrices.lvm,1,0,0,character[],1
+lava,matrices.lvm,1,0,1,double[],1
+lava,matrices.lvm,2,0,0,character[],1
+lava,matrices.lvm,2,0,1,null,1
+lava,matrices.lvm,2,0,2,double[],1
+lava,matrices.lvm,3,0,0,null,1
+lava,matrices.lvm,3,0,1,double[],1
+lava,matrices.lvm,4,0,0,any,1
+lava,matrices.lvm,5,0,0,...,1
+lava,%++%.matrix,-1,0,0,class<`matrix`>,1
+lava,%++%.matrix,0,0,0,class<`matrix`>,1
+lava,%++%.matrix,1,0,0,class<`matrix`>,1
+lava,measurement.error,-1,0,0,"class<`estimate`, `measurement.error`>",1
+lava,measurement.error,0,0,0,class<`lvmfit`>,1
+lava,measurement.error,1,0,0,class<`formula`>,1
+lava,measurement.error,2,0,0,class<`data.frame`>,1
+lava,measurement.error,3,0,0,class<`function`>,1
+lava,measurement.error,4,0,0,any,1
+lava,measurement.error,5,0,0,any,1
+lava,measurement.error,6,0,0,...,1
+lava,merge.estimate,-1,0,0,class<`estimate`>,1
+lava,merge.estimate,0,0,0,class<`estimate`>,1
+lava,merge.estimate,0,0,1,"class<`estimate`, `gkgamma`>",1
+lava,merge.estimate,1,0,0,class<`estimate`>,1
+lava,merge.estimate,1,0,1,"class<`estimate`, `gkgamma`>",1
+lava,merge.estimate,2,0,0,...,1
+lava,merge.estimate,3,0,0,any,1
+lava,merge.estimate,4,0,0,logical,1
+lava,merge.estimate,5,0,0,null,1
+lava,merge.estimate,6,0,0,null,1
+lava,merge.estimate,7,0,0,null,1
+lava,merge.estimate,7,0,1,double,1
+lava,merge.glm,-1,0,0,class<`estimate`>,1
+lava,merge.glm,0,0,0,"class<`glm`, `lm`>",1
+lava,merge.glm,0,0,1,class<`lm`>,1
+lava,merge.glm,1,0,0,"class<`glm`, `lm`>",1
+lava,merge.glm,1,0,1,class<`lm`>,1
+lava,merge.glm,2,0,0,...,1
+lava,merge.lm,-1,0,0,class<`estimate`>,1
+lava,merge.lm,0,0,0,"class<`glm`, `lm`>",1
+lava,merge.lm,0,0,1,class<`lm`>,1
+lava,merge.lm,1,0,0,"class<`glm`, `lm`>",1
+lava,merge.lm,1,0,1,class<`lm`>,1
+lava,merge.lm,2,0,0,...,1
+lava,Missing,-1,0,0,class<`lvm`>,1
+lava,Missing,0,0,0,class<`lvm`>,1
+lava,Missing,1,0,0,character,1
+lava,Missing,1,0,1,class<`formula`>,1
+lava,Missing,2,0,0,character,1
+lava,Missing,2,0,1,class<`formula`>,1
+lava,Missing,3,0,0,any,1
+lava,Missing,4,0,0,character,1
+lava,Missing,5,0,0,...,1
+lava,Missing<-,-1,0,0,class<`lvm`>,1
+lava,Missing<-,0,0,0,class<`lvm`>,1
+lava,Missing<-,1,0,0,character,1
+lava,Missing<-,1,0,1,class<`formula`>,1
+lava,Missing<-,2,0,0,...,1
+lava,Missing<-,3,0,0,class<`formula`>,1
+lava,missingModel,-1,0,0,list<any>,1
+lava,missingModel,0,0,0,class<`lvm`>,1
+lava,missingModel,1,0,0,class<`data.frame`>,1
+lava,missingModel,2,0,0,character[],1
+lava,missingModel,3,0,0,logical,1
+lava,missingModel,4,0,0,double,1
+lava,missingModel,5,0,0,character[],1
+lava,missingModel,6,0,0,any,1
+lava,missingModel,7,0,0,any,1
+lava,Model,-1,0,0,class<`lvm`>,1
+lava,Model,-1,0,1,class<`multigroup`>,1
+lava,Model,-1,0,2,list<class<`lvm`>>,1
+lava,Model,0,0,0,class<`lvm`>,1
+lava,Model,0,0,1,class<`lvmfit`>,1
+lava,Model,0,0,2,"class<`lvmfit`, `multigroupfit`>",1
+lava,Model,0,0,3,class<`multigroup`>,1
+lava,Model,1,0,0,...,1
+lava,Model<-,-1,0,0,class<`lvm`>,1
+lava,Model<-,0,0,0,class<`lvm`>,1
+lava,Model<-,1,0,0,...,1
+lava,Model<-,2,0,0,class<`lvm`>,1
+lava,model.frame.estimate,-1,0,0,null,1
+lava,model.frame.estimate,0,0,0,class<`estimate`>,1
+lava,model.frame.estimate,1,0,0,...,1
+lava,model.frame.lvmfit,-1,0,0,class<`data.frame`>,1
+lava,model.frame.lvmfit,0,0,0,class<`lvmfit`>,1
+lava,model.frame.lvmfit,1,0,0,logical,1
+lava,model.frame.lvmfit,2,0,0,...,1
+lava,model.frame.multigroupfit,-1,0,0,list<class<`data.frame`>>,1
+lava,model.frame.multigroupfit,0,0,0,"class<`lvmfit`, `multigroupfit`>",1
+lava,model.frame.multigroupfit,1,0,0,...,1
+lava,model.frame.multinomial,-1,0,0,class<`data.frame`>,1
+lava,model.frame.multinomial,0,0,0,class<`multinomial`>,1
+lava,model.frame.multinomial,1,0,0,...,1
+lava,Model<-.lvm,-1,0,0,class<`lvm`>,1
+lava,Model<-.lvm,0,0,0,class<`lvm`>,1
+lava,Model<-.lvm,1,0,0,...,1
+lava,Model<-.lvm,2,0,0,class<`lvm`>,1
+lava,Model.lvm,-1,0,0,double[],1
+lava,Model.lvm,-1,0,1,class<`lvm`>,1
+lava,Model.lvm,0,0,0,double[],1
+lava,Model.lvm,0,0,1,class<`lvm`>,1
+lava,Model.lvm,1,0,0,...,1
+lava,Model.lvmfit,-1,0,0,class<`lvm`>,1
+lava,Model.lvmfit,-1,0,1,class<`multigroup`>,1
+lava,Model.lvmfit,0,0,0,class<`lvmfit`>,1
+lava,Model.lvmfit,0,0,1,"class<`lvmfit`, `multigroupfit`>",1
+lava,Model.lvmfit,1,0,0,...,1
+lava,Model.multigroup,-1,0,0,list<class<`lvm`>>,1
+lava,Model.multigroup,0,0,0,class<`multigroup`>,1
+lava,Model.multigroup,1,0,0,...,1
+lava,Model.multigroupfit,-1,0,0,class<`lvm`>,1
+lava,Model.multigroupfit,-1,0,1,class<`multigroup`>,1
+lava,Model.multigroupfit,0,0,0,class<`lvmfit`>,1
+lava,Model.multigroupfit,0,0,1,"class<`lvmfit`, `multigroupfit`>",1
+lava,Model.multigroupfit,1,0,0,...,1
+lava,modelPar,-1,0,0,list<double[]>,1
+lava,modelPar,-1,0,1,list<double[] | null>,1
+lava,modelPar,-1,0,2,list<null | double[]>,1
+lava,modelPar,-1,0,3,list<list<double[]>>,1
+lava,modelPar,0,0,0,class<`lvm`>,1
+lava,modelPar,0,0,1,class<`multigroup`>,1
+lava,modelPar,1,0,0,double[],1
+lava,modelPar,2,0,0,...,1
+lava,modelPar.lvm,-1,0,0,list<double[]>,1
+lava,modelPar.lvm,-1,0,1,list<double[] | null>,1
+lava,modelPar.lvm,-1,0,2,list<null | double[]>,1
+lava,modelPar.lvm,0,0,0,class<`lvm`>,1
+lava,modelPar.lvm,1,0,0,double[],1
+lava,modelPar.lvm,2,0,0,...,1
+lava,modelPar.multigroup,-1,0,0,list<list<double[]>>,1
+lava,modelPar.multigroup,0,0,0,class<`multigroup`>,1
+lava,modelPar.multigroup,1,0,0,double[],1
+lava,modelPar.multigroup,2,0,0,...,1
+lava,modelsearch,-1,0,0,class<`modelsearch`>,1
+lava,modelsearch,0,0,0,class<`lvmfit`>,1
+lava,modelsearch,1,0,0,double,1
+lava,modelsearch,2,0,0,character,1
+lava,modelsearch,3,0,0,character,1
+lava,modelsearch,4,0,0,...,1
+lava,modelVar,-1,0,0,list<any>,1
+lava,modelVar,0,0,0,class<`lvm`>,1
+lava,modelVar,0,0,1,class<`lvmfit`>,1
+lava,modelVar,1,0,0,any,1
+lava,modelVar,2,0,0,...,1
+lava,modelVar.lvm,-1,0,0,list<any>,1
+lava,modelVar.lvm,0,0,0,class<`lvm`>,1
+lava,modelVar.lvm,1,0,0,double[],1
+lava,modelVar.lvm,2,0,0,any,1
+lava,modelVar.lvm,3,0,0,...,1
+lava,modelVar.lvmfit,-1,0,0,list<any>,1
+lava,modelVar.lvmfit,0,0,0,class<`lvmfit`>,1
+lava,modelVar.lvmfit,1,0,0,double[],1
+lava,modelVar.lvmfit,2,0,0,...,1
+lava,moments,-1,0,0,list<any>,1
+lava,moments,0,0,0,class<`lvm`>,1
+lava,moments,0,0,1,class<`lvmfit`>,1
+lava,moments,1,0,0,...,1
+lava,moments.lvm,-1,0,0,list<any>,1
+lava,moments.lvm,0,0,0,class<`lvm`>,1
+lava,moments.lvm,1,0,0,double[],1
+lava,moments.lvm,2,0,0,logical,1
+lava,moments.lvm,3,0,0,logical,1
+lava,moments.lvm,4,0,0,any,1
+lava,moments.lvm,5,0,0,logical,1
+lava,moments.lvm,6,0,0,...,1
+lava,moments.lvmfit,-1,0,0,list<any>,1
+lava,moments.lvmfit,0,0,0,class<`lvmfit`>,1
+lava,moments.lvmfit,1,0,0,double[],1
+lava,moments.lvmfit,2,0,0,...,1
+lava,multigroup,-1,0,0,class<`multigroup`>,1
+lava,multigroup,0,0,0,list<class<`lvm`>>,1
+lava,multigroup,1,0,0,list<class<`data.frame`>>,1
+lava,multigroup,2,0,0,any,1
+lava,multigroup,3,0,0,logical,1
+lava,multigroup,4,0,0,null,1
+lava,multigroup,5,0,0,logical,1
+lava,multigroup,6,0,0,...,1
+lava,multinomial,-1,0,0,class<`multinomial`>,1
+lava,multinomial,0,0,0,class<`data.frame`>,1
+lava,multinomial,0,0,1,class<`factor`>,1
+lava,multinomial,1,0,0,any,1
+lava,multinomial,2,0,0,logical,1
+lava,multinomial,3,0,0,any,1
+lava,multinomial,4,0,0,logical,1
+lava,multinomial,5,0,0,logical,1
+lava,multinomial,6,0,0,...,1
+lava,mvnmix,-1,0,0,"class<`lvm.mixture`, `mvn.mixture`>",1
+lava,mvnmix,0,0,0,class<`data.frame`>,1
+lava,mvnmix,1,0,0,double,1
+lava,mvnmix,2,0,0,any,1
+lava,mvnmix,3,0,0,double,1
+lava,mvnmix,4,0,0,double,1
+lava,mvnmix,5,0,0,double,1
+lava,mvnmix,6,0,0,null,1
+lava,mvnmix,7,0,0,logical,1
+lava,NA2x,-1,0,0,double[],1
+lava,NA2x,0,0,0,^integer[],1
+lava,NA2x,1,0,0,double,1
+lava,na.pass0,-1,0,0,class<`matrix`>,1
+lava,na.pass0,-1,0,1,class<`data.frame`>,1
+lava,na.pass0,0,0,0,class<`matrix`>,1
+lava,na.pass0,0,0,1,class<`data.frame`>,1
+lava,na.pass0,1,0,0,logical,1
+lava,na.pass0,2,0,0,class<`function`>,1
+lava,na.pass0,3,0,0,...,1
+lava,%ni%,-1,0,0,logical[],1
+lava,%ni%,0,0,0,integer[],1
+lava,%ni%,0,0,1,null,1
+lava,%ni%,0,0,2,character,1
+lava,%ni%,1,0,0,double[],1
+lava,%ni%,1,0,1,character[],1
+lava,nlminb0,-1,0,0,list<double[] | character>,1
+lava,nlminb0,0,0,0,double[],1
+lava,nlminb0,1,0,0,class<`function`>,1
+lava,nlminb0,2,0,0,class<`function`>,1
+lava,nlminb0,3,0,0,class<`function`>,1
+lava,nlminb0,4,0,0,...,1
+lava,nlminb1,-1,0,0,list<double[] | character>,1
+lava,nlminb1,0,0,0,double[],1
+lava,nlminb1,1,0,0,class<`function`>,1
+lava,nlminb1,2,0,0,class<`function`>,1
+lava,nlminb1,3,0,0,class<`function`>,1
+lava,nlminb1,4,0,0,...,1
+lava,nlminb2,-1,0,0,list<double[] | character>,1
+lava,nlminb2,0,0,0,double[],1
+lava,nlminb2,1,0,0,class<`function`>,1
+lava,nlminb2,2,0,0,class<`function`>,1
+lava,nlminb2,2,0,1,null,1
+lava,nlminb2,3,0,0,class<`function`>,1
+lava,nlminb2,3,0,1,null,1
+lava,nlminb2,4,0,0,...,1
+lava,nodecolor<-,-1,0,0,class<`lvm`>,1
+lava,nodecolor<-,0,0,0,class<`lvm`>,1
+lava,nodecolor<-,1,0,0,class<`formula`>,1
+lava,nodecolor<-,2,0,0,...,1
+lava,nodecolor<-,3,0,0,character[],1
+lava,nodecolor<-.lvm,-1,0,0,class<`lvm`>,1
+lava,nodecolor<-.lvm,0,0,0,class<`lvm`>,1
+lava,nodecolor<-.lvm,1,0,0,class<`formula`>,1
+lava,nodecolor<-.lvm,2,0,0,character[],1
+lava,nodecolor<-.lvm,3,0,0,character,1
+lava,nodecolor<-.lvm,4,0,0,any,1
+lava,nodecolor<-.lvm,5,0,0,double[],1
+lava,nodecolor<-.lvm,6,0,0,...,1
+lava,nodecolor<-.lvm,7,0,0,character[],1
+lava,normal_gradient.lvm,-1,0,0,class<`matrix`>,1
+lava,normal_gradient.lvm,-1,0,1,double[],1
+lava,normal_gradient.lvm,0,0,0,class<`lvm`>,1
+lava,normal_gradient.lvm,1,0,0,double[],1
+lava,normal_gradient.lvm,2,0,0,class<`data.frame`>,1
+lava,normal_gradient.lvm,3,0,0,null,1
+lava,normal_gradient.lvm,4,0,0,null,1
+lava,normal_gradient.lvm,5,0,0,logical,1
+lava,normal_gradient.lvm,6,0,0,...,1
+lava,normal_hessian.lvm,-1,0,0,class<`matrix`>,1
+lava,normal_hessian.lvm,0,0,0,class<`lvm`>,1
+lava,normal_hessian.lvm,1,0,0,double[],1
+lava,normal_hessian.lvm,2,0,0,logical,1
+lava,normal_hessian.lvm,3,0,0,null,1
+lava,normal_hessian.lvm,4,0,0,...,1
+lava,normal.lvm,-1,0,0,class<`function`>,1
+lava,normal.lvm,0,0,0,character,1
+lava,normal.lvm,1,0,0,double,1
+lava,normal.lvm,2,0,0,double,1
+lava,normal.lvm,3,0,0,logical,1
+lava,normal.lvm,4,0,0,...,1
+lava,normal_objective.lvm,-1,0,0,class<`matrix`>,1
+lava,normal_objective.lvm,-1,0,1,double,1
+lava,normal_objective.lvm,0,0,0,class<`lvm`>,1
+lava,normal_objective.lvm,1,0,0,double[],1
+lava,normal_objective.lvm,2,0,0,class<`data.frame`>,1
+lava,normal_objective.lvm,3,0,0,null,1
+lava,normal_objective.lvm,4,0,0,null,1
+lava,normal_objective.lvm,5,0,0,logical,1
+lava,normal_objective.lvm,6,0,0,...,1
+lava,NR,-1,0,0,list<double[] | character | class<`matrix`>>,1
+lava,NR,-1,0,1,list<double | character | class<`matrix`>>,1
+lava,NR,0,0,0,double[],1
+lava,NR,1,0,0,class<`function`>,1
+lava,NR,1,0,1,null,1
+lava,NR,2,0,0,null,1
+lava,NR,2,0,1,class<`function`>,1
+lava,NR,3,0,0,null,1
+lava,NR,3,0,1,class<`function`>,1
+lava,NR,4,0,0,any,1
+lava,NR,5,0,0,null,1
+lava,NR,5,0,1,list<double>,1
+lava,NR,6,0,0,...,1
+lava,numberdup,-1,0,0,double[],1
+lava,numberdup,0,0,0,integer[],1
+lava,offdiag,-1,0,0,"class<`numeric`, `offdiag`>",1
+lava,offdiag,0,0,0,class<`matrix`>,1
+lava,offdiag,1,0,0,double,1
+lava,offdiag,2,0,0,...,1
+lava,offdiags,-1,0,0,double[],1
+lava,offdiags,0,0,0,class<`lvm`>,1
+lava,offdiags,1,0,0,logical,1
+lava,ones.lvm,-1,0,0,class<`function`>,1
+lava,ones.lvm,0,0,0,double,1
+lava,ones.lvm,1,0,0,any,1
+lava,ordinal,-1,0,0,class<`ordinal.lvm`>,1
+lava,ordinal,-1,0,1,null,1
+lava,ordinal,-1,0,2,class<`lvm`>,1
+lava,ordinal,0,0,0,class<`lvm`>,1
+lava,ordinal,1,0,0,...,1
+lava,ordinal<-,-1,0,0,class<`lvm`>,1
+lava,ordinal<-,0,0,0,class<`lvm`>,1
+lava,ordinal<-,1,0,0,...,1
+lava,ordinal<-,2,0,0,character[],1
+lava,ordinal<-,2,0,1,class<`formula`>,1
+lava,ordinal.estimate.hook,-1,0,0,null,1
+lava,ordinal.estimate.hook,-1,0,1,list<any>,1
+lava,ordinal.estimate.hook,0,0,0,class<`lvm`>,1
+lava,ordinal.estimate.hook,1,0,0,list<class<`matrix`> | double[]>,1
+lava,ordinal.estimate.hook,1,0,1,class<`data.frame`>,1
+lava,ordinal.estimate.hook,2,0,0,null,1
+lava,ordinal.estimate.hook,3,0,0,null,1
+lava,ordinal.estimate.hook,4,0,0,null,1
+lava,ordinal.estimate.hook,4,0,1,character,1
+lava,ordinal.estimate.hook,5,0,0,...,1
+lava,ordinal<-.lvm,-1,0,0,class<`lvm`>,1
+lava,ordinal<-.lvm,0,0,0,class<`lvm`>,1
+lava,ordinal<-.lvm,1,0,0,...,1
+lava,ordinal<-.lvm,2,0,0,character[],1
+lava,ordinal<-.lvm,2,0,1,class<`formula`>,1
+lava,ordinal.lvm,-1,0,0,class<`lvm`>,1
+lava,ordinal.lvm,-1,0,1,class<`ordinal.lvm`>,1
+lava,ordinal.lvm,-1,0,2,null,1
+lava,ordinal.lvm,0,0,0,class<`lvm`>,1
+lava,ordinal.lvm,1,0,0,character[],1
+lava,ordinal.lvm,1,0,1,class<`formula`>,1
+lava,ordinal.lvm,1,0,2,null,1
+lava,ordinal.lvm,2,0,0,double,1
+lava,ordinal.lvm,2,0,1,null,1
+lava,ordinal.lvm,3,0,0,any,1
+lava,ordinal.lvm,4,0,0,null,1
+lava,ordinal.lvm,5,0,0,any,1
+lava,ordinal.lvm,6,0,0,logical,1
+lava,ordinal.lvm,7,0,0,any,1
+lava,ordinal.remove.hook,-1,0,0,class<`lvm`>,1
+lava,ordinal.remove.hook,0,0,0,class<`lvm`>,1
+lava,ordinal.remove.hook,1,0,0,character[],1
+lava,ordinal.remove.hook,2,0,0,...,1
+lava,ordinal.sim.hook,-1,0,0,class<`data.frame`>,1
+lava,ordinal.sim.hook,0,0,0,class<`lvm`>,1
+lava,ordinal.sim.hook,1,0,0,class<`data.frame`>,1
+lava,ordinal.sim.hook,2,0,0,double[],1
+lava,ordinal.sim.hook,2,0,1,null,1
+lava,ordinal.sim.hook,3,0,0,list<any>,1
+lava,ordinal.sim.hook,4,0,0,...,1
+lava,ordreg,-1,0,0,class<`ordreg`>,1
+lava,ordreg,0,0,0,class<`formula`>,1
+lava,ordreg,1,0,0,class<`data.frame`>,1
+lava,ordreg,2,0,0,any,1
+lava,ordreg,3,0,0,class<`family`>,1
+lava,ordreg,4,0,0,any,1
+lava,ordreg,5,0,0,logical,1
+lava,ordreg,6,0,0,...,1
+lava,ordreg_dthreshold,-1,0,0,class<`matrix`>,1
+lava,ordreg_dthreshold,0,0,0,double[],1
+lava,ordreg_hessian,-1,0,0,class<`matrix`>,1
+lava,ordreg_hessian,0,0,0,double[],1
+lava,ordreg_hessian,1,0,0,environment,1
+lava,ordreg_hessian,2,0,0,...,1
+lava,ordreg_ithreshold,-1,0,0,double[],1
+lava,ordreg_ithreshold,0,0,0,double[],1
+lava,ordreg_logL,-1,0,0,double,1
+lava,ordreg_logL,0,0,0,double[],1
+lava,ordreg_logL,1,0,0,environment,1
+lava,ordreg_logL,2,0,0,logical,1
+lava,ordreg_logL,3,0,0,...,1
+lava,ordreg_score,-1,0,0,double[],1
+lava,ordreg_score,0,0,0,double[],1
+lava,ordreg_score,1,0,0,environment,1
+lava,ordreg_score,2,0,0,...,1
+lava,ordreg_threshold,-1,0,0,double[],1
+lava,ordreg_threshold,0,0,0,double[],1
+lava,parameter,-1,0,0,character[],1
+lava,parameter,-1,0,1,null,1
+lava,parameter,0,0,0,class<`lvm`>,1
+lava,parameter,1,0,0,any,1
+lava,parameter,2,0,0,...,1
+lava,parameter<-,-1,0,0,class<`lvm`>,1
+lava,parameter<-,0,0,0,class<`lvm`>,1
+lava,parameter<-,1,0,0,...,1
+lava,parameter<-,2,0,0,character[],1
+lava,parameter<-,2,0,1,class<`formula`>,1
+lava,parameter<-.lvm,-1,0,0,class<`lvm`>,1
+lava,parameter<-.lvm,0,0,0,class<`lvm`>,1
+lava,parameter<-.lvm,1,0,0,any,1
+lava,parameter<-.lvm,2,0,0,any,1
+lava,parameter<-.lvm,3,0,0,logical,1
+lava,parameter<-.lvm,4,0,0,...,1
+lava,parameter<-.lvm,5,0,0,character[],1
+lava,parameter<-.lvm,5,0,1,class<`formula`>,1
+lava,parents,-1,0,0,character[],1
+lava,parents,-1,0,1,null,1
+lava,parents,0,0,0,class<`lvm`>,1
+lava,parents,1,0,0,...,1
+lava,parents.lvm,-1,0,0,character[],1
+lava,parents.lvm,-1,0,1,null,1
+lava,parents.lvm,0,0,0,class<`lvm`>,1
+lava,parents.lvm,1,0,0,character[],1
+lava,parents.lvm,1,0,1,class<`formula`>,1
+lava,parents.lvm,2,0,0,...,1
+lava,parfix,-1,0,0,class<`lvm`>,1
+lava,parfix,0,0,0,class<`lvm`>,1
+lava,parfix,1,0,0,...,1
+lava,parfix.lvm,-1,0,0,class<`lvm`>,1
+lava,parfix.lvm,0,0,0,class<`lvm`>,1
+lava,parfix.lvm,1,0,0,double,1
+lava,parfix.lvm,2,0,0,double,1
+lava,parfix.lvm,3,0,0,logical,1
+lava,parfix.lvm,4,0,0,...,1
+lava,parlabels,-1,0,0,character[],1
+lava,parlabels,-1,0,1,logical[],1
+lava,parlabels,-1,0,2,null,1
+lava,parlabels,0,0,0,class<`lvm`>,1
+lava,parlabels,1,0,0,logical,1
+lava,parpos,-1,0,0,integer[],1
+lava,parpos,-1,0,1,list<any>,1
+lava,parpos,0,0,0,class<`multigroup`>,1
+lava,parpos,0,0,1,class<`lvm`>,1
+lava,parpos,1,0,0,...,1
+lava,parpos.lvm,-1,0,0,integer[],1
+lava,parpos.lvm,-1,0,1,list<any>,1
+lava,parpos.lvm,0,0,0,class<`lvm`>,1
+lava,parpos.lvm,1,0,0,any,1
+lava,parpos.lvm,2,0,0,logical,1
+lava,parpos.lvm,3,0,0,...,1
+lava,parpos.multigroup,-1,0,0,integer[],1
+lava,parpos.multigroup,0,0,0,class<`multigroup`>,1
+lava,parpos.multigroup,1,0,0,character[],1
+lava,parpos.multigroup,2,0,0,logical,1
+lava,parpos.multigroup,3,0,0,...,1
+lava,pars,-1,0,0,character[],1
+lava,pars,-1,0,1,double[],1
+lava,pars,-1,0,2,list<character>,1
+lava,pars,0,0,0,class<`lvm`>,1
+lava,pars,0,0,1,"class<`lvmfit`, `multigroupfit`>",1
+lava,pars,0,0,2,class<`lm`>,1
+lava,pars,0,0,3,"class<`glm`, `lm`>",1
+lava,pars,0,0,4,class<`lvmfit`>,1
+lava,pars,0,0,5,"class<`lvm.missing`, `lvmfit`>",1
+lava,pars,1,0,0,...,1
+lava,pars.default,-1,0,0,double[],1
+lava,pars.default,0,0,0,class<`lvmfit`>,1
+lava,pars.default,0,0,1,"class<`lvm.missing`, `lvmfit`>",1
+lava,pars.default,0,0,2,class<`lvm`>,1
+lava,pars.default,0,0,3,"class<`lvmfit`, `multigroupfit`>",1
+lava,pars.default,0,0,4,class<`lm`>,1
+lava,pars.default,1,0,0,...,1
+lava,parsedesign,-1,0,0,class<`matrix`>,1
+lava,parsedesign,0,0,0,character[],1
+lava,parsedesign,1,0,0,character,1
+lava,parsedesign,2,0,0,...,1
+lava,parsedesign,3,0,0,logical,1
+lava,parsedesign,4,0,0,logical[],1
+lava,pars.glm,-1,0,0,double[],1
+lava,pars.glm,0,0,0,"class<`glm`, `lm`>",1
+lava,pars.glm,1,0,0,...,1
+lava,pars.lvm,-1,0,0,character[],1
+lava,pars.lvm,-1,0,1,double[],1
+lava,pars.lvm,-1,0,2,list<character>,1
+lava,pars.lvm,0,0,0,class<`lvm`>,1
+lava,pars.lvm,1,0,0,class<`matrix`>,1
+lava,pars.lvm,2,0,0,class<`matrix`>,1
+lava,pars.lvm,3,0,0,any,1
+lava,pars.lvm,4,0,0,any,1
+lava,pars.lvm,5,0,0,...,1
+lava,pars.lvm.missing,-1,0,0,double[],1
+lava,pars.lvm.missing,0,0,0,"class<`lvm.missing`, `lvmfit`>",1
+lava,pars.lvm.missing,1,0,0,logical,1
+lava,pars.lvm.missing,2,0,0,...,1
+lava,partialcor,-1,0,0,class<`matrix`>,1
+lava,partialcor,0,0,0,class<`formula`>,1
+lava,partialcor,1,0,0,class<`data.frame`>,1
+lava,partialcor,2,0,0,double,1
+lava,partialcor,3,0,0,...,1
+lava,partialcorpair,-1,0,0,double[],1
+lava,partialcorpair,0,0,0,class<`formula`>,1
+lava,partialcorpair,1,0,0,class<`data.frame`>,1
+lava,partialcorpair,2,0,0,double,1
+lava,partialcorpair,3,0,0,...,1
+lava,path,-1,0,0,list<character[]>,1
+lava,path,-1,0,1,list<list<double | class<`matrix`> | double[] | character[]>>,1
+lava,path,0,0,0,class<`lvm`>,1
+lava,path,0,0,1,class<`lvmfit`>,1
+lava,path,1,0,0,...,1
+lava,path.lvm,-1,0,0,list<character[]>,1
+lava,path.lvm,0,0,0,class<`lvm`>,1
+lava,path.lvm,1,0,0,character,1
+lava,path.lvm,1,0,1,class<`formula`>,1
+lava,path.lvm,2,0,0,any,1
+lava,path.lvm,3,0,0,logical,1
+lava,path.lvm,4,0,0,...,1
+lava,path.lvmfit,-1,0,0,list<list<double | class<`matrix`> | double[] | character[]>>,1
+lava,path.lvmfit,0,0,0,class<`lvmfit`>,1
+lava,path.lvmfit,1,0,0,class<`formula`>,1
+lava,path.lvmfit,2,0,0,any,1
+lava,path.lvmfit,3,0,0,...,1
+lava,pathM,-1,0,0,list<character[]>,1
+lava,pathM,0,0,0,class<`matrix`>,1
+lava,pathM,1,0,0,character,1
+lava,pathM,1,0,1,class<`formula`>,1
+lava,pathM,2,0,0,any,1
+lava,pathM,3,0,0,logical,1
+lava,pathM,4,0,0,...,1
+lava,p.correct,-1,0,0,double,1
+lava,p.correct,0,0,0,class<`estimate`>,1
+lava,p.correct,1,0,0,any,1
+lava,p.correct,2,0,0,double,1
+lava,PD,-1,0,0,class<`matrix`>,1
+lava,PD,0,0,0,class<`zibreg`>,1
+lava,PD,1,0,0,double[],1
+lava,PD,2,0,0,double[],1
+lava,PD,3,0,0,null,1
+lava,PD,4,0,0,any,1
+lava,PD,5,0,0,double,1
+lava,PD,6,0,0,double,1
+lava,PD,7,0,0,any,1
+lava,plotConf,-1,0,0,list<any>,1
+lava,plotConf,0,0,0,class<`lm`>,1
+lava,plotConf,1,0,0,null,1
+lava,plotConf,1,0,1,character,1
+lava,plotConf,2,0,0,character,1
+lava,plotConf,3,0,0,null,1
+lava,plotConf,4,0,0,double,1
+lava,plotConf,5,0,0,logical,1
+lava,plotConf,6,0,0,double,1
+lava,plotConf,7,0,0,double,1
+lava,plot.sim,-1,0,0,null,1
+lava,plot.sim,-1,0,1,list<list<double[]>>,1
+lava,plot.sim,0,0,0,class<`matrix`>,1
+lava,plot.sim,1,0,0,double[],1
+lava,plot.sim,2,0,0,double[],1
+lava,plot.sim,2,0,1,null,1
+lava,plot.sim,3,0,0,double[],1
+lava,plot.sim,3,0,1,null,1
+lava,plot.sim,4,0,0,null,1
+lava,plot.sim,5,0,0,logical,1
+lava,plot.sim,6,0,0,logical,1
+lava,plot.sim,7,0,0,character,1
+lava,poisson.lvm,-1,0,0,class<`function`>,1
+lava,poisson.lvm,0,0,0,character,1
+lava,poisson.lvm,1,0,0,any,1
+lava,poisson.lvm,2,0,0,...,1
+lava,predictlvm,-1,0,0,list<class<`matrix`>>,1
+lava,predictlvm,0,0,0,class<`lvmfit`>,1
+lava,predictlvm,1,0,0,class<`formula`>,1
+lava,predictlvm,2,0,0,double[],1
+lava,predictlvm,3,0,0,class<`data.frame`>,1
+lava,predictlvm,4,0,0,...,1
+lava,predict.lvm,-1,0,0,class<`matrix`>,1
+lava,predict.lvm,0,0,0,class<`lvm`>,1
+lava,predict.lvm,1,0,0,character[],1
+lava,predict.lvm,1,0,1,class<`formula`>,1
+lava,predict.lvm,1,0,2,null,1
+lava,predict.lvm,2,0,0,any,1
+lava,predict.lvm,3,0,0,logical,1
+lava,predict.lvm,4,0,0,double[],1
+lava,predict.lvm,5,0,0,class<`data.frame`>,1
+lava,predict.lvm,6,0,0,logical,1
+lava,predict.lvm,7,0,0,logical,1
+lava,predict.lvmfit,-1,0,0,class<`matrix`>,1
+lava,predict.lvmfit,0,0,0,class<`lvmfit`>,1
+lava,predict.lvmfit,1,0,0,character[],1
+lava,predict.lvmfit,1,0,1,class<`formula`>,1
+lava,predict.lvmfit,1,0,2,null,1
+lava,predict.lvmfit,2,0,0,null,1
+lava,predict.lvmfit,3,0,0,class<`data.frame`>,1
+lava,predict.lvmfit,4,0,0,double[],1
+lava,predict.lvmfit,5,0,0,...,1
+lava,predict.zibreg,-1,0,0,double[],1
+lava,predict.zibreg,0,0,0,class<`zibreg`>,1
+lava,predict.zibreg,1,0,0,double[],1
+lava,predict.zibreg,2,0,0,any,1
+lava,predict.zibreg,3,0,0,any,1
+lava,predict.zibreg,4,0,0,logical,1
+lava,predict.zibreg,5,0,0,logical,1
+lava,predict.zibreg,6,0,0,...,1
+lava,procdata.lvm,-1,0,0,list<class<`matrix`> | double[]>,1
+lava,procdata.lvm,-1,0,1,list<class<`matrix`> | double>,1
+lava,procdata.lvm,0,0,0,class<`lvm`>,1
+lava,procdata.lvm,1,0,0,class<`data.frame`>,1
+lava,procdata.lvm,1,0,1,list<class<`matrix`> | double[]>,1
+lava,procdata.lvm,2,0,0,logical,1
+lava,procdata.lvm,3,0,0,any,1
+lava,procdata.lvm,4,0,0,any,1
+lava,procformula,-1,0,0,list<any>,1
+lava,procformula,0,0,0,class<`lvm`>,1
+lava,procformula,1,0,0,class<`formula`>,1
+lava,procformula,2,0,0,logical,1
+lava,procformula,3,0,0,...,1
+lava,procrandomslope,-1,0,0,list<class<`multigroup`> | list<any>>,1
+lava,procrandomslope,0,0,0,class<`multigroup`>,1
+lava,procrandomslope,1,0,0,list<class<`data.frame`>>,1
+lava,procrandomslope,2,0,0,...,1
+lava,prodsumdelta,-1,0,0,list<class<`matrix`> | double[]>,1
+lava,prodsumdelta,-1,0,1,list<double | class<`matrix`>>,1
+lava,prodsumdelta,0,0,0,double[],1
+lava,prodsumdelta,1,0,0,list<double[]>,1
+lava,prodsumdelta,2,0,0,class<`matrix`>,1
+lava,prodsumdelta,3,0,0,double,1
+lava,prodtrans,-1,0,0,double,1
+lava,prodtrans,0,0,0,double[],1
+lava,profci.lvmfit,-1,0,0,double[],1
+lava,profci.lvmfit,0,0,0,class<`lvmfit`>,1
+lava,profci.lvmfit,1,0,0,double,1
+lava,profci.lvmfit,2,0,0,double,1
+lava,profci.lvmfit,3,0,0,null,1
+lava,profci.lvmfit,4,0,0,logical,1
+lava,profci.lvmfit,5,0,0,any,1
+lava,profci.lvmfit,6,0,0,logical,1
+lava,profci.lvmfit,7,0,0,logical,1
+lava,profile.lvmfit,-1,0,0,double,1
+lava,profile.lvmfit,0,0,0,class<`lvmfit`>,1
+lava,profile.lvmfit,1,0,0,double,1
+lava,profile.lvmfit,2,0,0,double,1
+lava,profile.lvmfit,3,0,0,...,1
+lava,pzmax,-1,0,0,double,1
+lava,pzmax,0,0,0,double,1
+lava,pzmax,1,0,0,class<`matrix`>,1
+lava,randomslope,-1,0,0,null,1
+lava,randomslope,0,0,0,class<`lvm`>,1
+lava,randomslope,1,0,0,...,1
+lava,randomslope.lvm,-1,0,0,null,1
+lava,randomslope.lvm,0,0,0,class<`lvm`>,1
+lava,randomslope.lvm,1,0,0,any,1
+lava,randomslope.lvm,2,0,0,null,1
+lava,randomslope.lvm,3,0,0,null,1
+lava,randomslope.lvm,4,0,0,any,1
+lava,randomslope.lvm,5,0,0,any,1
+lava,randomslope.lvm,6,0,0,logical,1
+lava,randomslope.lvm,7,0,0,logical,1
+lava,regfix,-1,0,0,class<`fix`>,1
+lava,regfix,0,0,0,class<`lvm`>,1
+lava,regfix,1,0,0,...,1
+lava,regfix<-,-1,0,0,class<`lvm`>,1
+lava,regfix<-,0,0,0,class<`lvm`>,1
+lava,regfix<-,1,0,0,...,1
+lava,regfix<-,2,0,0,character,1
+lava,regfix<-,2,0,1,double[],1
+lava,regfix<-,2,0,2,list<null | character>,1
+lava,regfix<-,2,0,3,null,1
+lava,regfix<-.lvm,-1,0,0,class<`lvm`>,1
+lava,regfix<-.lvm,0,0,0,class<`lvm`>,1
+lava,regfix<-.lvm,1,0,0,character[],1
+lava,regfix<-.lvm,1,0,1,class<`formula`>,1
+lava,regfix<-.lvm,2,0,0,any,1
+lava,regfix<-.lvm,3,0,0,logical,1
+lava,regfix<-.lvm,4,0,0,any,1
+lava,regfix<-.lvm,5,0,0,any,1
+lava,regfix<-.lvm,6,0,0,any,1
+lava,regfix<-.lvm,7,0,0,...,1
+lava,regfix.lvm,-1,0,0,class<`fix`>,1
+lava,regfix.lvm,0,0,0,class<`lvm`>,1
+lava,regfix.lvm,1,0,0,...,1
+lava,regression,-1,0,0,class<`fix`>,1
+lava,regression,-1,0,1,class<`lvm`>,1
+lava,regression,0,0,0,class<`lvm`>,1
+lava,regression,1,0,0,any,1
+lava,regression,2,0,0,any,1
+lava,regression,3,0,0,...,1
+lava,regression<-,-1,0,0,class<`lvm`>,1
+lava,regression<-,0,0,0,class<`lvm`>,1
+lava,regression<-,1,0,0,...,1
+lava,regression<-,2,0,0,character,1
+lava,regression<-,2,0,1,class<`formula`>,1
+lava,regression<-,2,0,2,double[],1
+lava,regression<-,2,0,3,list<null | character>,1
+lava,regression<-,2,0,4,null,1
+lava,regression<-.lvm,-1,0,0,class<`lvm`>,1
+lava,regression<-.lvm,0,0,0,class<`lvm`>,1
+lava,regression<-.lvm,1,0,0,character[],1
+lava,regression<-.lvm,1,0,1,class<`formula`>,1
+lava,regression<-.lvm,1,0,2,null,1
+lava,regression<-.lvm,2,0,0,logical,1
+lava,regression<-.lvm,3,0,0,...,1
+lava,regression<-.lvm,4,0,0,character,1
+lava,regression<-.lvm,4,0,1,double[],1
+lava,regression<-.lvm,4,0,2,list<null | character>,1
+lava,regression<-.lvm,4,0,3,null,1
+lava,regression<-.lvm,4,0,4,class<`formula`>,1
+lava,regression.lvm,-1,0,0,class<`fix`>,1
+lava,regression.lvm,-1,0,1,class<`lvm`>,1
+lava,regression.lvm,0,0,0,class<`lvm`>,1
+lava,regression.lvm,1,0,0,any,1
+lava,regression.lvm,2,0,0,any,1
+lava,regression.lvm,3,0,0,null,1
+lava,regression.lvm,4,0,0,any,1
+lava,regression.lvm,5,0,0,logical,1
+lava,regression.lvm,6,0,0,any,1
+lava,regression.lvm,7,0,0,any,1
+lava,reindex,-1,0,0,list<any>,1
+lava,reindex,0,0,0,class<`lvm`>,1
+lava,reindex,1,0,0,logical,1
+lava,reindex,2,0,0,logical,1
+lava,reindex,3,0,0,logical,1
+lava,reindex,4,0,0,logical,1
+lava,reindex,5,0,0,logical,1
+lava,reorderdata.lvm,-1,0,0,class<`matrix`>,1
+lava,reorderdata.lvm,-1,0,1,double[],1
+lava,reorderdata.lvm,0,0,0,class<`lvm`>,1
+lava,reorderdata.lvm,1,0,0,class<`matrix`>,1
+lava,reorderdata.lvm,1,0,1,double[],1
+lava,rmvar,-1,0,0,class<`lvm`>,1
+lava,rmvar,0,0,0,class<`lvm`>,1
+lava,rmvar,1,0,0,...,1
+lava,rmvar<-,-1,0,0,class<`lvm`>,1
+lava,rmvar<-,0,0,0,class<`lvm`>,1
+lava,rmvar<-,1,0,0,...,1
+lava,rmvar<-,2,0,0,character[],1
+lava,rmvar<-,2,0,1,class<`formula`>,1
+lava,rmvar<-.lvm,-1,0,0,class<`lvm`>,1
+lava,rmvar<-.lvm,0,0,0,class<`lvm`>,1
+lava,rmvar<-.lvm,1,0,0,...,1
+lava,rmvar<-.lvm,2,0,0,character[],1
+lava,rmvar<-.lvm,2,0,1,class<`formula`>,1
+lava,rmvar.lvm,-1,0,0,class<`lvm`>,1
+lava,rmvar.lvm,0,0,0,class<`lvm`>,1
+lava,rmvar.lvm,1,0,0,character[],1
+lava,rmvar.lvm,1,0,1,class<`formula`>,1
+lava,rmvar.lvm,2,0,0,...,1
+lava,rmvn0,-1,0,0,class<`matrix`>,1
+lava,rmvn0,0,0,0,double,1
+lava,rmvn0,1,0,0,any,1
+lava,rmvn0,2,0,0,class<`matrix`>,1
+lava,rmvn0,3,0,0,any,1
+lava,rmvn0,4,0,0,...,1
+lava,rotate2,-1,0,0,class<`matrix`>,1
+lava,rotate2,0,0,0,class<`matrix`>,1
+lava,rotate2,1,0,0,double,1
+lava,rsq,-1,0,0,class<`estimate`>,1
+lava,rsq,-1,0,1,list<double[]>,1
+lava,rsq,0,0,0,class<`lvmfit`>,1
+lava,rsq,1,0,0,logical,1
+lava,satmodel,-1,0,0,class<`logLik`>,1
+lava,satmodel,0,0,0,class<`lvmfit`>,1
+lava,satmodel,0,0,1,"class<`lvmfit`, `multigroupfit`>",1
+lava,satmodel,1,0,0,logical,1
+lava,satmodel,2,0,0,any,1
+lava,satmodel,3,0,0,any,1
+lava,satmodel,4,0,0,any,1
+lava,satmodel,5,0,0,any,1
+lava,satmodel,6,0,0,logical,1
+lava,satmodel,7,0,0,logical,1
+lava,scheffe,-1,0,0,class<`matrix`>,1
+lava,scheffe,0,0,0,class<`lm`>,1
+lava,scheffe,1,0,0,class<`data.frame`>,1
+lava,scheffe,2,0,0,double,1
+lava,score,-1,0,0,class<`matrix`>,1
+lava,score,-1,0,1,double[],1
+lava,score,-1,0,2,list<class<`matrix`>>,1
+lava,score,0,0,0,class<`lvm`>,1
+lava,score,0,0,1,"class<`lvmfit`, `multigroupfit`>",1
+lava,score,0,0,2,class<`multigroup`>,1
+lava,score,0,0,3,class<`lvmfit`>,1
+lava,score,0,0,4,"class<`lvm.missing`, `lvmfit`>",1
+lava,score,0,0,5,"class<`glm`, `lm`>",1
+lava,score,0,0,6,class<`lm`>,1
+lava,score,1,0,0,...,1
+lava,score.glm,-1,0,0,class<`matrix`>,1
+lava,score.glm,0,0,0,"class<`glm`, `lm`>",1
+lava,score.glm,1,0,0,double[],1
+lava,score.glm,2,0,0,any,1
+lava,score.glm,3,0,0,logical,1
+lava,score.glm,4,0,0,logical,1
+lava,score.glm,5,0,0,any,1
+lava,score.glm,6,0,0,any,1
+lava,score.glm,7,0,0,any,1
+lava,score.lm,-1,0,0,class<`matrix`>,1
+lava,score.lm,0,0,0,class<`lm`>,1
+lava,score.lm,1,0,0,double[],1
+lava,score.lm,2,0,0,any,1
+lava,score.lm,3,0,0,logical,1
+lava,score.lm,4,0,0,any,1
+lava,score.lm,5,0,0,any,1
+lava,score.lm,6,0,0,null,1
+lava,score.lm,7,0,0,null,1
+lava,score.lvm,-1,0,0,class<`matrix`>,1
+lava,score.lvm,0,0,0,class<`lvm`>,1
+lava,score.lvm,1,0,0,class<`data.frame`>,1
+lava,score.lvm,1,0,1,null,1
+lava,score.lvm,2,0,0,any,1
+lava,score.lvm,3,0,0,character,1
+lava,score.lvm,4,0,0,any,1
+lava,score.lvm,5,0,0,any,1
+lava,score.lvm,6,0,0,any,1
+lava,score.lvm,7,0,0,any,1
+lava,score.lvmfit,-1,0,0,class<`matrix`>,1
+lava,score.lvmfit,0,0,0,class<`lvmfit`>,1
+lava,score.lvmfit,1,0,0,class<`data.frame`>,1
+lava,score.lvmfit,2,0,0,double[],1
+lava,score.lvmfit,3,0,0,character,1
+lava,score.lvmfit,4,0,0,null,1
+lava,score.lvmfit,5,0,0,any,1
+lava,score.lvmfit,6,0,0,...,1
+lava,score.lvm.missing,-1,0,0,class<`matrix`>,1
+lava,score.lvm.missing,0,0,0,"class<`lvm.missing`, `lvmfit`>",1
+lava,score.lvm.missing,1,0,0,double[],1
+lava,score.lvm.missing,2,0,0,character,1
+lava,score.lvm.missing,3,0,0,null,1
+lava,score.lvm.missing,4,0,0,logical,1
+lava,score.lvm.missing,5,0,0,logical,1
+lava,score.lvm.missing,6,0,0,...,1
+lava,score.lvm.mixture,-1,0,0,class<`matrix`>,1
+lava,score.lvm.mixture,0,0,0,"class<`lvm.mixture`, `mvn.mixture`>",1
+lava,score.lvm.mixture,1,0,0,double[],1
+lava,score.lvm.mixture,2,0,0,any,1
+lava,score.lvm.mixture,3,0,0,logical,1
+lava,score.lvm.mixture,4,0,0,character,1
+lava,score.lvm.mixture,5,0,0,...,1
+lava,score.multigroup,-1,0,0,class<`matrix`>,1
+lava,score.multigroup,-1,0,1,double[],1
+lava,score.multigroup,-1,0,2,list<class<`matrix`>>,1
+lava,score.multigroup,0,0,0,class<`multigroup`>,1
+lava,score.multigroup,1,0,0,list<class<`data.frame`>>,1
+lava,score.multigroup,2,0,0,null,1
+lava,score.multigroup,3,0,0,null,1
+lava,score.multigroup,4,0,0,double[],1
+lava,score.multigroup,5,0,0,logical,1
+lava,score.multigroup,6,0,0,logical,1
+lava,score.multigroup,7,0,0,...,1
+lava,score.multigroupfit,-1,0,0,class<`matrix`>,1
+lava,score.multigroupfit,-1,0,1,double[],1
+lava,score.multigroupfit,0,0,0,"class<`lvmfit`, `multigroupfit`>",1
+lava,score.multigroupfit,1,0,0,double[],1
+lava,score.multigroupfit,2,0,0,null,1
+lava,score.multigroupfit,3,0,0,character,1
+lava,score.multigroupfit,4,0,0,...,1
+lava,sequence.lvm,-1,0,0,class<`function`>,1
+lava,sequence.lvm,0,0,0,double,1
+lava,sequence.lvm,1,0,0,double,1
+lava,sequence.lvm,2,0,0,logical,1
+lava,sim,-1,0,0,class<`data.frame`>,1
+lava,sim,-1,0,1,class<`lvm`>,1
+lava,sim,-1,0,2,"class<`matrix`, `sim`>",1
+lava,sim,0,0,0,class<`lvm`>,1
+lava,sim,0,0,1,class<`lvmfit`>,1
+lava,sim,0,0,2,class<`function`>,1
+lava,sim,0,0,3,"class<`matrix`, `sim`>",1
+lava,sim,1,0,0,...,1
+lava,[.sim,-1,0,0,"class<`matrix`, `sim`>",1
+lava,[.sim,0,0,0,"class<`matrix`, `sim`>",1
+lava,[.sim,1,0,0,any,1
+lava,[.sim,2,0,0,double[],1
+lava,[.sim,3,0,0,logical,1
+lava,sim.default,-1,0,0,null,1
+lava,sim.default,0,0,0,class<`function`>,1
+lava,sim.default,0,0,1,"class<`matrix`, `sim`>",1
+lava,sim.default,1,0,0,class<`data.frame`>,1
+lava,sim.default,1,0,1,double,1
+lava,sim.default,2,0,0,null,1
+lava,sim.default,3,0,0,null,1
+lava,sim.default,4,0,0,any,1
+lava,sim.default,5,0,0,any,1
+lava,sim.default,6,0,0,any,1
+lava,sim.default,7,0,0,any,1
+lava,sim.lvm,-1,0,0,class<`data.frame`>,1
+lava,sim.lvm,-1,0,1,class<`lvm`>,1
+lava,sim.lvm,0,0,0,class<`lvm`>,1
+lava,sim.lvm,1,0,0,double,1
+lava,sim.lvm,1,0,1,null,1
+lava,sim.lvm,2,0,0,double[],1
+lava,sim.lvm,2,0,1,null,1
+lava,sim.lvm,3,0,0,logical,1
+lava,sim.lvm,4,0,0,logical,1
+lava,sim.lvm,5,0,0,double,1
+lava,sim.lvm,6,0,0,double,1
+lava,sim.lvm,7,0,0,null,1
+lava,sim.lvmfit,-1,0,0,class<`data.frame`>,1
+lava,sim.lvmfit,0,0,0,class<`lvmfit`>,1
+lava,sim.lvmfit,1,0,0,double,1
+lava,sim.lvmfit,2,0,0,double[],1
+lava,sim.lvmfit,3,0,0,logical,1
+lava,sim.lvmfit,4,0,0,...,1
+lava,simnull,-1,0,0,class<`matrix`>,1
+lava,simnull,0,0,0,double,1
+lava,simnull,1,0,0,class<`function`>,1
+lava,simnull,2,0,0,double[],1
+lava,simnull,3,0,0,class<`matrix`>,1
+lava,simnull,4,0,0,character,1
+lava,simplePaths,-1,0,0,list<character[]>,1
+lava,simplePaths,0,0,0,character,1
+lava,simplePaths,1,0,0,character[],1
+lava,simplePaths,2,0,0,any,1
+lava,simplePaths,3,0,0,class<`matrix`>,1
+lava,simplePaths,4,0,0,list<any>,1
+lava,simulate.lvm,-1,0,0,class<`data.frame`>,1
+lava,simulate.lvm,0,0,0,class<`lvm`>,1
+lava,simulate.lvm,1,0,0,double,1
+lava,simulate.lvm,2,0,0,double,1
+lava,simulate.lvm,3,0,0,...,1
+lava,simulate.multiple.inputs,-1,0,0,class<`data.frame`>,1
+lava,simulate.multiple.inputs,0,0,0,class<`lvm`>,1
+lava,simulate.multiple.inputs,1,0,0,class<`data.frame`>,1
+lava,simulate.multiple.inputs,2,0,0,...,1
+lava,stack.estimate,-1,0,0,class<`estimate`>,1
+lava,stack.estimate,0,0,0,"class<`glm`, `lm`>",1
+lava,stack.estimate,0,0,1,class<`estimate`>,1
+lava,stack.estimate,1,0,0,"class<`glm`, `lm`>",1
+lava,stack.estimate,1,0,1,class<`estimate`>,1
+lava,stack.estimate,2,0,0,any,1
+lava,stack.estimate,3,0,0,any,1
+lava,stack.estimate,4,0,0,any,1
+lava,stack.estimate,5,0,0,any,1
+lava,stack.estimate,6,0,0,any,1
+lava,stack.estimate,7,0,0,logical,1
+lava,stack.glm,-1,0,0,class<`estimate`>,1
+lava,stack.glm,0,0,0,"class<`glm`, `lm`>",1
+lava,stack.glm,1,0,0,"class<`glm`, `lm`>",1
+lava,stack.glm,2,0,0,...,1
+lava,starter.multigroup,-1,0,0,double[],1
+lava,starter.multigroup,0,0,0,class<`multigroup`>,1
+lava,starter.multigroup,1,0,0,class<`function`>,1
+lava,starter.multigroup,2,0,0,logical,1
+lava,starter.multigroup,3,0,0,double,1
+lava,starter.multigroup,4,0,0,...,1
+lava,startmean,-1,0,0,double[],1
+lava,startmean,0,0,0,class<`lvm`>,1
+lava,startmean,1,0,0,double[],1
+lava,startmean,2,0,0,double[],1
+lava,startvalues,-1,0,0,double[],1
+lava,startvalues,0,0,0,class<`lvm`>,1
+lava,startvalues,1,0,0,class<`matrix`>,1
+lava,startvalues,2,0,0,double[],1
+lava,startvalues,3,0,0,logical,1
+lava,startvalues,4,0,0,double,1
+lava,startvalues,5,0,0,double,1
+lava,startvalues,6,0,0,double,1
+lava,startvalues,7,0,0,...,1
+lava,startvalues0,-1,0,0,double[],1
+lava,startvalues0,0,0,0,class<`lvm`>,1
+lava,startvalues0,1,0,0,class<`matrix`>,1
+lava,startvalues0,2,0,0,double[],1
+lava,startvalues0,3,0,0,double,1
+lava,startvalues0,4,0,0,double,1
+lava,startvalues0,5,0,0,...,1
+lava,stdcoef,-1,0,0,list<class<`matrix`>>,1
+lava,stdcoef,0,0,0,class<`lvmfit`>,1
+lava,stdcoef,1,0,0,double[],1
+lava,stdcoef,2,0,0,...,1
+lava,subset.lvm,-1,0,0,class<`lvm`>,1
+lava,subset.lvm,0,0,0,class<`lvm`>,1
+lava,subset.lvm,1,0,0,character,1
+lava,subset.lvm,1,0,1,class<`formula`>,1
+lava,subset.lvm,2,0,0,...,1
+lava,summary.multigroupfit,-1,0,0,class<`summary.multigroupfit`>,1
+lava,summary.multigroupfit,0,0,0,"class<`lvmfit`, `multigroupfit`>",1
+lava,summary.multigroupfit,1,0,0,null,1
+lava,summary.multigroupfit,2,0,0,...,1
+lava,summary.sim,-1,0,0,"class<`matrix`, `summary.sim`>",1
+lava,summary.sim,0,0,0,class<`matrix`>,1
+lava,summary.sim,0,0,1,"class<`matrix`, `sim`>",1
+lava,summary.sim,1,0,0,double[],1
+lava,summary.sim,2,0,0,double[],1
+lava,summary.sim,2,0,1,null,1
+lava,summary.sim,3,0,0,double[],1
+lava,summary.sim,4,0,0,double[],1
+lava,summary.sim,4,0,1,null,1
+lava,summary.sim,5,0,0,any,1
+lava,summary.sim,6,0,0,null,1
+lava,summary.sim,6,0,1,character[],1
+lava,summary.sim,7,0,0,logical,1
+lava,summary.zibreg,-1,0,0,class<`summary.zibreg`>,1
+lava,summary.zibreg,0,0,0,class<`zibreg`>,1
+lava,summary.zibreg,1,0,0,double,1
+lava,summary.zibreg,2,0,0,class<`matrix`>,1
+lava,summary.zibreg,3,0,0,...,1
+lava,sumsplit,-1,0,0,character[],1
+lava,sumsplit,0,0,0,character,1
+lava,sumsplit,1,0,0,...,1
+lava,surface,-1,0,0,list<double[]>,1
+lava,surface,0,0,0,class<`matrix`>,1
+lava,surface,0,0,1,class<`function`>,1
+lava,surface,1,0,0,any,1
+lava,surface,2,0,0,any,1
+lava,surface,3,0,0,any,1
+lava,surface,4,0,0,any,1
+lava,surface,5,0,0,character,1
+lava,surface,6,0,0,any,1
+lava,surface,7,0,0,any,1
+lava,timedep,-1,0,0,class<`lvm`>,1
+lava,timedep,0,0,0,class<`lvm`>,1
+lava,timedep,1,0,0,class<`formula`>,1
+lava,timedep,2,0,0,any,1
+lava,timedep,3,0,0,double[],1
+lava,timedep,4,0,0,character,1
+lava,timedep,5,0,0,...,1
+lava,toformula,-1,0,0,class<`formula`>,1
+lava,toformula,0,0,0,character[],1
+lava,toformula,1,0,0,character,1
+lava,toformula,1,0,1,double,1
+lava,toPar,-1,0,0,list<class<`matrix`> | double[]>,1
+lava,toPar,0,0,0,double[],1
+lava,toPar,1,0,0,integer,1
+lava,toPar,2,0,0,double,1
+lava,toTheta,-1,0,0,double[],1
+lava,toTheta,0,0,0,class<`matrix`>,1
+lava,toTheta,1,0,0,class<`matrix`>,1
+lava,toTheta,2,0,0,double[],1
+lava,tr,-1,0,0,class<`matrix`>,1
+lava,tr,-1,0,1,double,1
+lava,tr,0,0,0,class<`matrix`>,1
+lava,tr,1,0,0,...,1
+lava,transform<-,-1,0,0,class<`lvm`>,1
+lava,transform<-,0,0,0,class<`lvm`>,1
+lava,transform<-,1,0,0,...,1
+lava,transform<-,2,0,0,class<`function`>,1
+lava,transform<-.lvm,-1,0,0,class<`lvm`>,1
+lava,transform<-.lvm,0,0,0,class<`lvm`>,1
+lava,transform<-.lvm,1,0,0,character,1
+lava,transform<-.lvm,1,0,1,class<`formula`>,1
+lava,transform<-.lvm,1,0,2,null,1
+lava,transform<-.lvm,2,0,0,...,1
+lava,transform<-.lvm,3,0,0,class<`function`>,1
+lava,transform.lvm,-1,0,0,class<`lvm`>,1
+lava,transform.lvm,0,0,0,class<`lvm`>,1
+lava,transform.lvm,1,0,0,any,1
+lava,transform.lvm,2,0,0,class<`function`>,1
+lava,transform.lvm,3,0,0,logical,1
+lava,transform.lvm,4,0,0,any,1
+lava,transform.lvm,5,0,0,any,1
+lava,transform.lvm,6,0,0,...,1
+lava,tr.matrix,-1,0,0,class<`matrix`>,1
+lava,tr.matrix,-1,0,1,double,1
+lava,tr.matrix,0,0,0,class<`matrix`>,1
+lava,tr.matrix,1,0,0,logical,1
+lava,tr.matrix,2,0,0,...,1
+lava,uhat,-1,0,0,class<`matrix`>,1
+lava,uhat,0,0,0,double[],1
+lava,uniform.lvm,-1,0,0,class<`function`>,1
+lava,uniform.lvm,0,0,0,any,1
+lava,uniform.lvm,1,0,0,double,1
+lava,updatelvm,-1,0,0,class<`lvm`>,1
+lava,updatelvm,0,0,0,class<`lvm`>,1
+lava,updatelvm,1,0,0,logical,1
+lava,updatelvm,2,0,0,...,1
+lava,variance<-,-1,0,0,class<`lvm`>,1
+lava,variance<-,0,0,0,class<`lvm`>,1
+lava,variance<-,1,0,0,...,1
+lava,variance<-,2,0,0,character[],1
+lava,variance<-,2,0,1,class<`formula`>,1
+lava,variance<-,2,0,2,double,1
+lava,variance<-,2,0,3,null,1
+lava,variances,-1,0,0,double[],1
+lava,variances,0,0,0,class<`lvm`>,1
+lava,variances,0,0,1,class<`lvmfit`>,1
+lava,variances,1,0,0,logical,1
+lava,vars,-1,0,0,character[],1
+lava,vars,-1,0,1,null,1
+lava,vars,0,0,0,class<`lvm`>,1
+lava,vars,0,0,1,class<`lvmfit`>,1
+lava,vars,1,0,0,...,1
+lava,vars.lvm,-1,0,0,character[],1
+lava,vars.lvm,-1,0,1,null,1
+lava,vars.lvm,0,0,0,class<`lvm`>,1
+lava,vars.lvm,1,0,0,...,1
+lava,vars.lvmfit,-1,0,0,character[],1
+lava,vars.lvmfit,0,0,0,class<`lvmfit`>,1
+lava,vars.lvmfit,1,0,0,...,1
+lava,vcov.estimate,-1,0,0,class<`matrix`>,1
+lava,vcov.estimate,0,0,0,class<`estimate`>,1
+lava,vcov.estimate,1,0,0,logical,1
+lava,vcov.estimate,2,0,0,...,1
+lava,vcov.lvmfit,-1,0,0,class<`matrix`>,1
+lava,vcov.lvmfit,0,0,0,class<`lvmfit`>,1
+lava,vcov.lvmfit,1,0,0,...,1
+lava,vcov.multigroupfit,-1,0,0,class<`matrix`>,1
+lava,vcov.multigroupfit,0,0,0,"class<`lvmfit`, `multigroupfit`>",1
+lava,vcov.multigroupfit,1,0,0,...,1
+lava,vcov.zibreg,-1,0,0,class<`matrix`>,1
+lava,vcov.zibreg,0,0,0,class<`zibreg`>,1
+lava,vcov.zibreg,1,0,0,...,1
+lava,vec,-1,0,0,double[],1
+lava,vec,0,0,0,double[],1
+lava,vec,1,0,0,logical,1
+lava,vec,2,0,0,character,1
+lava,vec,3,0,0,...,1
+lava,versioncheck,-1,0,0,logical,1
+lava,versioncheck,0,0,0,character,1
+lava,versioncheck,1,0,0,double[],1
+lava,versioncheck,2,0,0,character,1
+lava,versioncheck,3,0,0,...,1
+lava,weibull.lvm,-1,0,0,class<`function`>,1
+lava,weibull.lvm,0,0,0,double,1
+lava,weibull.lvm,1,0,0,double,1
+lava,Weights,-1,0,0,null,1
+lava,Weights,0,0,0,class<`lvmfit`>,1
+lava,Weights,0,0,1,"class<`lvmfit`, `multigroupfit`>",1
+lava,Weights,1,0,0,...,1
+lava,Weights.default,-1,0,0,null,1
+lava,Weights.default,0,0,0,class<`lvmfit`>,1
+lava,Weights.default,0,0,1,"class<`lvmfit`, `multigroupfit`>",1
+lava,Weights.default,1,0,0,...,1
+lava,wrapvec,-1,0,0,integer[],1
+lava,wrapvec,0,0,0,double,1
+lava,wrapvec,1,0,0,double,1
+lava,wrapvec,2,0,0,...,1
+lava,x2NA,-1,0,0,^integer[],1
+lava,x2NA,0,0,0,integer[],1
+lava,x2NA,1,0,0,double,1
+lava,x2NA,1,0,1,integer[],1
+lava,zibreg,-1,0,0,class<`zibreg`>,1
+lava,zibreg,0,0,0,class<`formula`>,1
+lava,zibreg,1,0,0,class<`formula`>,1
+lava,zibreg,2,0,0,class<`data.frame`>,1
+lava,zibreg,3,0,0,class<`family`>,1
+lava,zibreg,4,0,0,null,1
+lava,zibreg,5,0,0,any,1
+lava,zibreg,6,0,0,character,1
+lava,zibreg,7,0,0,...,1
+lava,zibreg_information,-1,0,0,class<`matrix`>,1
+lava,zibreg_information,0,0,0,double[],1
+lava,zibreg_information,1,0,0,double[],1
+lava,zibreg_information,2,0,0,double[],1
+lava,zibreg_information,3,0,0,class<`matrix`>,1
+lava,zibreg_information,4,0,0,class<`matrix`>,1
+lava,zibreg_information,5,0,0,null,1
+lava,zibreg_information,6,0,0,class<`family`>,1
+lava,zibreg_information,7,0,0,character,1
+lava,zibreg_logL,-1,0,0,class<`logLik`>,1
+lava,zibreg_logL,0,0,0,double[],1
+lava,zibreg_logL,1,0,0,double[],1
+lava,zibreg_logL,2,0,0,double[],1
+lava,zibreg_logL,3,0,0,class<`matrix`>,1
+lava,zibreg_logL,4,0,0,class<`matrix`>,1
+lava,zibreg_logL,5,0,0,null,1
+lava,zibreg_logL,6,0,0,class<`family`>,1
+lava,zibreg_logL,7,0,0,logical,1
+lava,zibreg_score,-1,0,0,double[],1
+lava,zibreg_score,0,0,0,double[],1
+lava,zibreg_score,1,0,0,double[],1
+lava,zibreg_score,2,0,0,double[],1
+lava,zibreg_score,3,0,0,class<`matrix`>,1
+lava,zibreg_score,4,0,0,class<`matrix`>,1
+lava,zibreg_score,5,0,0,null,1
+lava,zibreg_score,6,0,0,class<`family`>,1
+lava,zibreg_score,7,0,0,logical,1
+lazyeval,%||%,-1,0,0,character[],1
+lazyeval,%||%,0,0,0,character[],1
+lazyeval,%||%,0,0,1,null,1
+lazyeval,%||%,1,0,0,any,1
+lazyeval,all_values,-1,0,0,list<class<`name`>>,1
+lazyeval,all_values,-1,0,1,list<double | character[]>,1
+lazyeval,all_values,-1,0,2,list<class<`name`> | double>,1
+lazyeval,all_values,-1,0,3,list<double>,1
+lazyeval,all_values,0,0,0,any,1
+lazyeval,all_values,1,0,0,...,1
+lazyeval,as_call,-1,0,0,class<`call`>,1
+lazyeval,as_call,0,0,0,character,1
+lazyeval,as_call,0,0,1,class<`formula`>,1
+lazyeval,as_call,0,0,2,class<`name`>,1
+lazyeval,as_call.character,-1,0,0,class<`call`>,1
+lazyeval,as_call.character,0,0,0,character,1
+lazyeval,as_call.formula,-1,0,0,class<`call`>,1
+lazyeval,as_call.formula,0,0,0,class<`formula`>,1
+lazyeval,as_call.name,-1,0,0,class<`call`>,1
+lazyeval,as_call.name,0,0,0,class<`name`>,1
+lazyeval,as.lazy,-1,0,0,class<`lazy`>,1
+lazyeval,as.lazy,0,0,0,character,1
+lazyeval,as.lazy,0,0,1,class<`call`>,1
+lazyeval,as.lazy,0,0,2,class<`formula`>,1
+lazyeval,as.lazy,0,0,3,class<`lazy`>,1
+lazyeval,as.lazy,0,0,4,class<`name`>,1
+lazyeval,as.lazy,0,0,5,double,1
+lazyeval,as.lazy,1,0,0,any,1
+lazyeval,as.lazy.call,-1,0,0,class<`lazy`>,1
+lazyeval,as.lazy.call,0,0,0,class<`call`>,1
+lazyeval,as.lazy.call,0,0,1,class<`name`>,1
+lazyeval,as.lazy.call,1,0,0,environment,1
+lazyeval,as.lazy.character,-1,0,0,class<`lazy`>,1
+lazyeval,as.lazy.character,0,0,0,character,1
+lazyeval,as.lazy.character,1,0,0,environment,1
+lazyeval,as.lazy_dots,-1,0,0,class<`lazy_dots`>,1
+lazyeval,as.lazy_dots,0,0,0,character[],1
+lazyeval,as.lazy_dots,0,0,1,class<`call`>,1
+lazyeval,as.lazy_dots,0,0,2,class<`formula`>,1
+lazyeval,as.lazy_dots,0,0,3,class<`lazy`>,1
+lazyeval,as.lazy_dots,0,0,4,class<`lazy_dots`>,1
+lazyeval,as.lazy_dots,0,0,5,class<`name`>,1
+lazyeval,as.lazy_dots,0,0,6,list<class<`formula`>>,1
+lazyeval,as.lazy_dots,0,0,7,list<class<`formula`> | class<`name`>>,1
+lazyeval,as.lazy_dots,0,0,8,list<double | class<`formula`>>,1
+lazyeval,as.lazy_dots,1,0,0,any,1
+lazyeval,as.lazy_dots.call,-1,0,0,class<`lazy_dots`>,1
+lazyeval,as.lazy_dots.call,0,0,0,class<`call`>,1
+lazyeval,as.lazy_dots.call,0,0,1,class<`formula`>,1
+lazyeval,as.lazy_dots.call,0,0,2,class<`name`>,1
+lazyeval,as.lazy_dots.call,1,0,0,any,1
+lazyeval,as.lazy_dots.character,-1,0,0,class<`lazy_dots`>,1
+lazyeval,as.lazy_dots.character,0,0,0,character[],1
+lazyeval,as.lazy_dots.character,0,0,1,list<class<`formula`>>,1
+lazyeval,as.lazy_dots.character,0,0,2,list<class<`formula`> | class<`name`>>,1
+lazyeval,as.lazy_dots.character,0,0,3,list<double | class<`formula`>>,1
+lazyeval,as.lazy_dots.character,1,0,0,any,1
+lazyeval,as.lazy_dots.formula,-1,0,0,class<`lazy_dots`>,1
+lazyeval,as.lazy_dots.formula,0,0,0,class<`call`>,1
+lazyeval,as.lazy_dots.formula,0,0,1,class<`formula`>,1
+lazyeval,as.lazy_dots.formula,0,0,2,class<`name`>,1
+lazyeval,as.lazy_dots.formula,1,0,0,any,1
+lazyeval,as.lazy_dots.lazy,-1,0,0,class<`lazy_dots`>,1
+lazyeval,as.lazy_dots.lazy,0,0,0,class<`lazy`>,1
+lazyeval,as.lazy_dots.lazy,1,0,0,any,1
+lazyeval,as.lazy_dots.lazy_dots,-1,0,0,class<`lazy_dots`>,1
+lazyeval,as.lazy_dots.lazy_dots,0,0,0,class<`lazy_dots`>,1
+lazyeval,as.lazy_dots.lazy_dots,1,0,0,any,1
+lazyeval,as.lazy_dots.list,-1,0,0,class<`lazy_dots`>,1
+lazyeval,as.lazy_dots.list,0,0,0,character[],1
+lazyeval,as.lazy_dots.list,0,0,1,list<class<`formula`>>,1
+lazyeval,as.lazy_dots.list,0,0,2,list<class<`formula`> | class<`name`>>,1
+lazyeval,as.lazy_dots.list,0,0,3,list<double | class<`formula`>>,1
+lazyeval,as.lazy_dots.list,1,0,0,any,1
+lazyeval,as.lazy_dots.name,-1,0,0,class<`lazy_dots`>,1
+lazyeval,as.lazy_dots.name,0,0,0,class<`call`>,1
+lazyeval,as.lazy_dots.name,0,0,1,class<`formula`>,1
+lazyeval,as.lazy_dots.name,0,0,2,class<`name`>,1
+lazyeval,as.lazy_dots.name,1,0,0,any,1
+lazyeval,as.lazy.formula,-1,0,0,class<`lazy`>,1
+lazyeval,as.lazy.formula,0,0,0,class<`formula`>,1
+lazyeval,as.lazy.formula,1,0,0,any,1
+lazyeval,as.lazy.lazy,-1,0,0,class<`lazy`>,1
+lazyeval,as.lazy.lazy,0,0,0,class<`lazy`>,1
+lazyeval,as.lazy.lazy,1,0,0,any,1
+lazyeval,as.lazy.name,-1,0,0,class<`lazy`>,1
+lazyeval,as.lazy.name,0,0,0,class<`call`>,1
+lazyeval,as.lazy.name,0,0,1,class<`name`>,1
+lazyeval,as.lazy.name,1,0,0,environment,1
+lazyeval,as.lazy.numeric,-1,0,0,class<`lazy`>,1
+lazyeval,as.lazy.numeric,0,0,0,double,1
+lazyeval,as.lazy.numeric,1,0,0,environment,1
+lazyeval,as_name,-1,0,0,class<`name`>,1
+lazyeval,as_name,0,0,0,character,1
+lazyeval,as_name,0,0,1,class<`call`>,1
+lazyeval,as_name,0,0,2,class<`formula`>,1
+lazyeval,as_name.call,-1,0,0,class<`name`>,1
+lazyeval,as_name.call,0,0,0,class<`call`>,1
+lazyeval,as_name.character,-1,0,0,class<`name`>,1
+lazyeval,as_name.character,0,0,0,character,1
+lazyeval,as_name.formula,-1,0,0,class<`name`>,1
+lazyeval,as_name.formula,0,0,0,class<`formula`>,1
+lazyeval,ast,-1,0,0,null,1
+lazyeval,ast,0,0,0,any,1
+lazyeval,ast_,-1,0,0,null,1
+lazyeval,ast_,0,0,0,class<`call`>,1
+lazyeval,ast_,0,0,1,class<`if`>,1
+lazyeval,ast_,0,0,2,expression,1
+lazyeval,ast_,1,0,0,integer,1
+lazyeval,auto_name,-1,0,0,class<`lazy_dots`>,1
+lazyeval,auto_name,-1,0,1,list<class<`formula`> | class<`name`>>,1
+lazyeval,auto_name,0,0,0,class<`lazy_dots`>,1
+lazyeval,auto_name,0,0,1,list<class<`formula`> | class<`name`>>,1
+lazyeval,auto_name,1,0,0,double,1
+lazyeval,auto_names,-1,0,0,character[],1
+lazyeval,auto_names,0,0,0,class<`lazy_dots`>,1
+lazyeval,auto_names,0,0,1,list<class<`formula`> | class<`name`>>,1
+lazyeval,auto_names,1,0,0,any,1
+lazyeval,call_modify,-1,0,0,class<`call`>,1
+lazyeval,call_modify,0,0,0,class<`call`>,1
+lazyeval,call_modify,1,0,0,list<class<`name`>>,1
+lazyeval,call_modify,1,0,1,list<null>,1
+lazyeval,call_modify,1,0,2,list<double>,1
+lazyeval,call_modify,2,0,0,environment,1
+lazyeval,call_new,-1,0,0,class<`call`>,1
+lazyeval,call_new,0,0,0,character,1
+lazyeval,call_new,0,0,1,class<`call`>,1
+lazyeval,call_new,0,0,2,class<`name`>,1
+lazyeval,call_new,1,0,0,...,1
+lazyeval,call_new,2,0,0,list<any>,1
+lazyeval,call_standardise,-1,0,0,class<`call`>,1
+lazyeval,call_standardise,0,0,0,class<`call`>,1
+lazyeval,call_standardise,1,0,0,environment,1
+lazyeval,c.lazy_dots,-1,0,0,class<`lazy_dots`>,1
+lazyeval,c.lazy_dots,0,0,0,...,1
+lazyeval,c.lazy_dots,1,0,0,logical,1
+lazyeval,clone_env,-1,0,0,environment,1
+lazyeval,clone_env,0,0,0,environment,1
+lazyeval,common_env,-1,0,0,environment,1
+lazyeval,common_env,0,0,0,class<`lazy_dots`>,1
+lazyeval,common_env,0,0,1,list<class<`formula`>>,1
+lazyeval,complain,-1,0,0,"class<`complain`, `data.frame`>",1
+lazyeval,complain,-1,0,1,"class<`complain`, `environment`>",1
+lazyeval,complain,-1,0,2,"class<`complain`, `list`>",1
+lazyeval,complain,0,0,0,class<`data.frame`>,1
+lazyeval,complain,0,0,1,environment,1
+lazyeval,complain,0,0,2,list<any>,1
+lazyeval,complain,1,0,0,character,1
+lazyeval,[[.complain,-1,0,0,double[],1
+lazyeval,[[.complain,0,0,0,"class<`complain`, `data.frame`>",1
+lazyeval,[[.complain,0,0,1,"class<`complain`, `environment`>",1
+lazyeval,[[.complain,1,0,0,character,1
+lazyeval,[[.complain,2,0,0,...,1
+lazyeval,$.complain,-1,0,0,any,1
+lazyeval,$.complain,0,0,0,"class<`complain`, `data.frame`>",1
+lazyeval,$.complain,0,0,1,"class<`complain`, `environment`>",1
+lazyeval,$.complain,1,0,0,character,1
+lazyeval,dots_capture,-1,0,0,list<class<`formula`>>,1
+lazyeval,dots_capture,0,0,0,...,1
+lazyeval,dots_capture,1,0,0,logical,1
+lazyeval,eval_expr,-1,0,0,any,1
+lazyeval,eval_expr,0,0,0,class<`call`>,1
+lazyeval,eval_expr,0,0,1,class<`name`>,1
+lazyeval,eval_expr,1,0,0,environment,1
+lazyeval,eval_expr,2,0,0,class<`data.frame`>,1
+lazyeval,eval_expr,2,0,1,null,1
+lazyeval,eval_expr,2,0,2,list<class<`function`>>,1
+lazyeval,eval_expr,2,0,3,list<double>,1
+lazyeval,expr_find,-1,0,0,character,1
+lazyeval,expr_find,-1,0,1,class<`{`>,1
+lazyeval,expr_find,-1,0,2,class<`call`>,1
+lazyeval,expr_find,-1,0,3,class<`if`>,1
+lazyeval,expr_find,-1,0,4,class<`name`>,1
+lazyeval,expr_find,-1,0,5,double,1
+lazyeval,expr_find,0,0,0,any,1
+lazyeval,expr_label,-1,0,0,character,1
+lazyeval,expr_label,0,0,0,any,1
+lazyeval,expr_label_,-1,0,0,character,1
+lazyeval,expr_label_,0,0,0,character,1
+lazyeval,expr_label_,0,0,1,class<`call`>,1
+lazyeval,expr_label_,0,0,2,class<`name`>,1
+lazyeval,expr_label_,0,0,3,double,1
+lazyeval,expr_text,-1,0,0,character,1
+lazyeval,expr_text,0,0,0,any,1
+lazyeval,expr_text,1,0,0,integer,1
+lazyeval,expr_text,2,0,0,double,1
+lazyeval,expr_text_,-1,0,0,character,1
+lazyeval,expr_text_,0,0,0,class<`{`>,1
+lazyeval,expr_text_,0,0,1,class<`call`>,1
+lazyeval,expr_text_,1,0,0,integer,1
+lazyeval,expr_text_,2,0,0,double,1
+lazyeval,f_capture,-1,0,0,class<`formula`>,1
+lazyeval,f_capture,0,0,0,any,1
+lazyeval,f_env,-1,0,0,environment,1
+lazyeval,f_env,0,0,0,class<`formula`>,1
+lazyeval,f_eval,-1,0,0,any,1
+lazyeval,f_eval,0,0,0,class<`formula`>,1
+lazyeval,f_eval,1,0,0,class<`data.frame`>,1
+lazyeval,f_eval,1,0,1,null,1
+lazyeval,f_eval,1,0,2,list<class<`function`>>,1
+lazyeval,f_eval,1,0,3,list<double>,1
+lazyeval,find_data,-1,0,0,class<`data.frame`>,1
+lazyeval,find_data,-1,0,1,list<any>,1
+lazyeval,find_data,0,0,0,class<`data.frame`>,1
+lazyeval,find_data,0,0,1,null,1
+lazyeval,find_data,0,0,2,list<class<`function`>>,1
+lazyeval,find_data,0,0,3,list<double>,1
+lazyeval,find_data.data.frame,-1,0,0,class<`data.frame`>,1
+lazyeval,find_data.data.frame,-1,0,1,list<class<`function`>>,1
+lazyeval,find_data.data.frame,-1,0,2,list<double>,1
+lazyeval,find_data.data.frame,0,0,0,class<`data.frame`>,1
+lazyeval,find_data.data.frame,0,0,1,list<class<`function`>>,1
+lazyeval,find_data.data.frame,0,0,2,list<double>,1
+lazyeval,find_data.list,-1,0,0,class<`data.frame`>,1
+lazyeval,find_data.list,-1,0,1,list<class<`function`>>,1
+lazyeval,find_data.list,-1,0,2,list<double>,1
+lazyeval,find_data.list,0,0,0,class<`data.frame`>,1
+lazyeval,find_data.list,0,0,1,list<class<`function`>>,1
+lazyeval,find_data.list,0,0,2,list<double>,1
+lazyeval,find_data.NULL,-1,0,0,list<any>,1
+lazyeval,find_data.NULL,0,0,0,null,1
+lazyeval,f_interp,-1,0,0,class<`formula`>,1
+lazyeval,f_interp,0,0,0,class<`formula`>,1
+lazyeval,f_interp,1,0,0,class<`data.frame`>,1
+lazyeval,f_interp,1,0,1,null,1
+lazyeval,f_interp,1,0,2,list<class<`function`>>,1
+lazyeval,f_interp,1,0,3,list<double>,1
+lazyeval,f_label,-1,0,0,character,1
+lazyeval,f_label,0,0,0,class<`formula`>,1
+lazyeval,f_lhs,-1,0,0,class<`name`>,1
+lazyeval,f_lhs,-1,0,1,null,1
+lazyeval,f_lhs,0,0,0,class<`formula`>,1
+lazyeval,f_list,-1,0,0,list<class<`formula`>>,1
+lazyeval,f_list,0,0,0,...,1
+lazyeval,f_new,-1,0,0,class<`formula`>,1
+lazyeval,f_new,0,0,0,class<`call`>,1
+lazyeval,f_new,0,0,1,class<`name`>,1
+lazyeval,f_new,1,0,0,class<`name`>,1
+lazyeval,f_new,1,0,1,null,1
+lazyeval,f_new,2,0,0,environment,1
+lazyeval,f_rhs,-1,0,0,character,1
+lazyeval,f_rhs,-1,0,1,class<`call`>,1
+lazyeval,f_rhs,-1,0,2,class<`name`>,1
+lazyeval,f_rhs,-1,0,3,double,1
+lazyeval,f_rhs,0,0,0,class<`formula`>,1
+lazyeval,f_rhs<-,-1,0,0,class<`formula`>,1
+lazyeval,f_rhs<-,0,0,0,class<`formula`>,1
+lazyeval,f_rhs<-,1,0,0,class<`call`>,1
+lazyeval,f_rhs<-,1,0,1,class<`name`>,1
+lazyeval,f_text,-1,0,0,character,1
+lazyeval,f_text,0,0,0,class<`formula`>,1
+lazyeval,f_text,1,0,0,integer,1
+lazyeval,f_text,2,0,0,double,1
+lazyeval,function_new,-1,0,0,class<`function`>,1
+lazyeval,function_new,0,0,0,list<class<`name`>>,1
+lazyeval,function_new,1,0,0,class<`call`>,1
+lazyeval,function_new,2,0,0,environment,1
+lazyeval,f_unwrap,-1,0,0,class<`formula`>,1
+lazyeval,f_unwrap,0,0,0,class<`formula`>,1
+lazyeval,has_name,-1,0,0,logical,1
+lazyeval,has_name,0,0,0,"class<`complain`, `data.frame`>",1
+lazyeval,has_name,0,0,1,"class<`complain`, `environment`>",1
+lazyeval,has_name,1,0,0,character,1
+lazyeval,has_name.default,-1,0,0,logical,1
+lazyeval,has_name.default,0,0,0,"class<`complain`, `data.frame`>",1
+lazyeval,has_name.default,1,0,0,character,1
+lazyeval,has_name.environment,-1,0,0,logical,1
+lazyeval,has_name.environment,0,0,0,"class<`complain`, `environment`>",1
+lazyeval,has_name.environment,1,0,0,character,1
+lazyeval,has_names,-1,0,0,logical,1
+lazyeval,has_names,0,0,0,list<class<`name`>>,1
+lazyeval,has_names,0,0,1,list<null>,1
+lazyeval,has_names,0,0,2,list<double>,1
+lazyeval,interp,-1,0,0,character,1
+lazyeval,interp,-1,0,1,class<`call`>,1
+lazyeval,interp,-1,0,2,class<`formula`>,1
+lazyeval,interp,-1,0,3,class<`lazy`>,1
+lazyeval,interp,0,0,0,character,1
+lazyeval,interp,0,0,1,class<`call`>,1
+lazyeval,interp,0,0,2,class<`formula`>,1
+lazyeval,interp,0,0,3,class<`lazy`>,1
+lazyeval,interp,1,0,0,...,1
+lazyeval,interp,2,0,0,any,1
+lazyeval,interp.call,-1,0,0,class<`call`>,1
+lazyeval,interp.call,0,0,0,class<`call`>,1
+lazyeval,interp.call,1,0,0,...,1
+lazyeval,interp.call,2,0,0,any,1
+lazyeval,interp.character,-1,0,0,character,1
+lazyeval,interp.character,0,0,0,character,1
+lazyeval,interp.character,1,0,0,...,1
+lazyeval,interp.character,2,0,0,any,1
+lazyeval,interp.formula,-1,0,0,class<`formula`>,1
+lazyeval,interp.formula,0,0,0,class<`formula`>,1
+lazyeval,interp.formula,1,0,0,...,1
+lazyeval,interp.formula,2,0,0,any,1
+lazyeval,interp.lazy,-1,0,0,class<`lazy`>,1
+lazyeval,interp.lazy,0,0,0,class<`lazy`>,1
+lazyeval,interp.lazy,1,0,0,...,1
+lazyeval,interp.lazy,2,0,0,any,1
+lazyeval,is_atomic,-1,0,0,logical,1
+lazyeval,is_atomic,0,0,0,class<`{`>,1
+lazyeval,is_atomic,0,0,1,class<`call`>,1
+lazyeval,is_atomic,0,0,2,class<`if`>,1
+lazyeval,is_atomic,0,0,3,class<`name`>,1
+lazyeval,is_atomic,0,0,4,double,1
+lazyeval,is_atomic,0,0,5,null,1
+lazyeval,is_atomic,0,0,6,pairlist,1
+lazyeval,is_atomic,0,0,7,list<integer[]>,1
+lazyeval,is_atomic,0,0,8,list<double>,1
+lazyeval,is_call,-1,0,0,logical,1
+lazyeval,is_call,0,0,0,class<`{`>,1
+lazyeval,is_call,0,0,1,class<`call`>,1
+lazyeval,is_call,0,0,2,class<`if`>,1
+lazyeval,is_call,0,0,3,class<`name`>,1
+lazyeval,is_call,0,0,4,double,1
+lazyeval,is_call,0,0,5,null,1
+lazyeval,is_call,0,0,6,pairlist,1
+lazyeval,is_formula,-1,0,0,logical,1
+lazyeval,is_formula,0,0,0,any,1
+lazyeval,is_lang,-1,0,0,logical,1
+lazyeval,is_lang,0,0,0,class<`call`>,1
+lazyeval,is_lang,0,0,1,class<`name`>,1
+lazyeval,is_lang,0,0,2,double,1
+lazyeval,is.lazy_dots,-1,0,0,logical,1
+lazyeval,is.lazy_dots,0,0,0,character,1
+lazyeval,is.lazy_dots,0,0,1,class<`call`>,1
+lazyeval,is.lazy_dots,0,0,2,class<`formula`>,1
+lazyeval,is.lazy_dots,0,0,3,class<`lazy`>,1
+lazyeval,is.lazy_dots,0,0,4,class<`lazy_dots`>,1
+lazyeval,is_name,-1,0,0,logical,1
+lazyeval,is_name,0,0,0,class<`{`>,1
+lazyeval,is_name,0,0,1,class<`call`>,1
+lazyeval,is_name,0,0,2,class<`if`>,1
+lazyeval,is_name,0,0,3,class<`name`>,1
+lazyeval,is_name,0,0,4,null,1
+lazyeval,is_name,0,0,5,pairlist,1
+lazyeval,is_pairlist,-1,0,0,logical,1
+lazyeval,is_pairlist,0,0,0,class<`name`>,1
+lazyeval,is_pairlist,0,0,1,double,1
+lazyeval,is_pairlist,0,0,2,null,1
+lazyeval,is_pairlist,0,0,3,pairlist,1
+lazyeval,is_vector,-1,0,0,logical,1
+lazyeval,is_vector,0,0,0,list<integer[]>,1
+lazyeval,is_vector,0,0,1,list<double>,1
+lazyeval,lazy,-1,0,0,class<`lazy`>,1
+lazyeval,lazy,0,0,0,any,1
+lazyeval,lazy,1,0,0,any,1
+lazyeval,lazy,2,0,0,logical,1
+lazyeval,lazy_,-1,0,0,class<`lazy`>,1
+lazyeval,lazy_,0,0,0,class<`call`>,1
+lazyeval,lazy_,0,0,1,class<`name`>,1
+lazyeval,lazy_,0,0,2,double,1
+lazyeval,lazy_,1,0,0,environment,1
+lazyeval,[<-.lazy_dots,-1,0,0,class<`lazy_dots`>,1
+lazyeval,[<-.lazy_dots,0,0,0,class<`lazy_dots`>,1
+lazyeval,[<-.lazy_dots,1,0,0,character,1
+lazyeval,[<-.lazy_dots,2,0,0,list<class<`formula`>>,1
+lazyeval,[.lazy_dots,-1,0,0,class<`lazy_dots`>,1
+lazyeval,[.lazy_dots,0,0,0,class<`lazy_dots`>,1
+lazyeval,[.lazy_dots,1,0,0,logical[],1
+lazyeval,[.lazy_dots,1,0,1,character[],1
+lazyeval,$<-.lazy_dots,-1,0,0,class<`lazy_dots`>,1
+lazyeval,$<-.lazy_dots,0,0,0,class<`lazy_dots`>,1
+lazyeval,$<-.lazy_dots,1,0,0,character,1
+lazyeval,$<-.lazy_dots,2,0,0,class<`name`>,1
+lazyeval,lazy_dots,-1,0,0,class<`lazy_dots`>,1
+lazyeval,lazy_dots,0,0,0,...,1
+lazyeval,lazy_dots,1,0,0,logical,1
+lazyeval,lazy_dots,2,0,0,logical,1
+lazyeval,lazy_eval,-1,0,0,double,1
+lazyeval,lazy_eval,-1,0,1,logical[],1
+lazyeval,lazy_eval,-1,0,2,list<double>,1
+lazyeval,lazy_eval,0,0,0,class<`lazy`>,1
+lazyeval,lazy_eval,0,0,1,class<`formula`>,1
+lazyeval,lazy_eval,0,0,2,character,1
+lazyeval,lazy_eval,0,0,3,class<`call`>,1
+lazyeval,lazy_eval,0,0,4,class<`lazy_dots`>,1
+lazyeval,lazy_eval,1,0,0,list<double>,1
+lazyeval,lazy_eval,1,0,1,null,1
+lazyeval,lazy_eval,1,0,2,class<`data.frame`>,1
+lazyeval,make_call,-1,0,0,class<`lazy`>,1
+lazyeval,make_call,0,0,0,class<`name`>,1
+lazyeval,make_call,1,0,0,class<`formula`>,1
+lazyeval,make_call,1,0,1,class<`lazy_dots`>,1
+lazyeval,make_call,1,0,2,class<`name`>,1
+lazyeval,make_call,1,0,3,list<double | class<`formula`>>,1
+lazyeval,missing_arg,-1,0,0,any,1
+lazyeval,str_dup,-1,0,0,character,1
+lazyeval,str_dup,0,0,0,character,1
+lazyeval,str_dup,1,0,0,double,1
+lazyeval,str_trunc,-1,0,0,character,1
+lazyeval,str_trunc,0,0,0,character,1
+lazyeval,str_trunc,1,0,0,double,1
+lazyeval,substitute_,-1,0,0,class<`call`>,1
+lazyeval,substitute_,0,0,0,class<`call`>,1
+lazyeval,substitute_,1,0,0,environment,1
+lazyeval,substitute_,1,0,1,list<class<`name`>>,1
+lazyeval,substitute_,1,0,2,list<double | character[]>,1
+lazyeval,substitute_,1,0,3,list<class<`name`> | double>,1
+lazyeval,substitute_,1,0,4,list<double>,1
+lazyeval,tree,-1,0,0,character,1
+lazyeval,tree,0,0,0,class<`{`>,1
+lazyeval,tree,0,0,1,class<`call`>,1
+lazyeval,tree,0,0,2,class<`name`>,1
+lazyeval,tree,0,0,3,double,1
+lazyeval,tree,0,0,4,null,1
+lazyeval,tree,0,0,5,pairlist,1
+lazyeval,tree,0,0,6,class<`if`>,1
+lazyeval,tree,1,0,0,double,1
+lazyeval,tree,2,0,0,double,1
+lazyeval,tree,3,0,0,character,1
+lazyeval,uq,-1,0,0,any,1
+lazyeval,uq,0,0,0,any,1
+lazyeval,uq,1,0,0,null,1
+lazyeval,uq,1,0,1,class<`data.frame`>,1
+lazyeval,uqs,-1,0,0,pairlist,1
+lazyeval,uqs,0,0,0,list<integer[]>,1
+lazyeval,uqs,0,0,1,list<double>,1
+lhs,augmentLHS,-1,0,0,class<`matrix`>,1
+lhs,augmentLHS,0,0,0,class<`matrix`>,1
+lhs,augmentLHS,1,0,0,double,1
+lhs,createAddelKemp,-1,0,0,class<`matrix`>,1
+lhs,createAddelKemp,0,0,0,double,1
+lhs,createAddelKemp,1,0,0,double,1
+lhs,createAddelKemp,2,0,0,logical,1
+lhs,createAddelKemp3,-1,0,0,class<`matrix`>,1
+lhs,createAddelKemp3,0,0,0,double,1
+lhs,createAddelKemp3,1,0,0,double,1
+lhs,createAddelKemp3,2,0,0,logical,1
+lhs,createAddelKempN,-1,0,0,class<`matrix`>,1
+lhs,createAddelKempN,0,0,0,double,1
+lhs,createAddelKempN,1,0,0,double,1
+lhs,createAddelKempN,2,0,0,double,1
+lhs,createAddelKempN,3,0,0,logical,1
+lhs,createBose,-1,0,0,class<`matrix`>,1
+lhs,createBose,0,0,0,double,1
+lhs,createBose,1,0,0,double,1
+lhs,createBose,2,0,0,logical,1
+lhs,createBoseBush,-1,0,0,class<`matrix`>,1
+lhs,createBoseBush,0,0,0,double,1
+lhs,createBoseBush,1,0,0,double,1
+lhs,createBoseBush,2,0,0,logical,1
+lhs,createBoseBushl,-1,0,0,class<`matrix`>,1
+lhs,createBoseBushl,0,0,0,double,1
+lhs,createBoseBushl,1,0,0,double,1
+lhs,createBoseBushl,2,0,0,double,1
+lhs,createBoseBushl,3,0,0,logical,1
+lhs,createBush,-1,0,0,class<`matrix`>,1
+lhs,createBush,0,0,0,double,1
+lhs,createBush,1,0,0,double,1
+lhs,createBush,2,0,0,logical,1
+lhs,createBusht,-1,0,0,class<`matrix`>,1
+lhs,createBusht,0,0,0,double,1
+lhs,createBusht,1,0,0,double,1
+lhs,createBusht,2,0,0,double,1
+lhs,createBusht,3,0,0,logical,1
+lhs,create_oalhs,-1,0,0,class<`matrix`>,1
+lhs,create_oalhs,0,0,0,double,1
+lhs,create_oalhs,1,0,0,double,1
+lhs,create_oalhs,2,0,0,logical,1
+lhs,create_oalhs,3,0,0,logical,1
+lhs,geneticLHS,-1,0,0,class<`matrix`>,1
+lhs,geneticLHS,0,0,0,double,1
+lhs,geneticLHS,1,0,0,double,1
+lhs,geneticLHS,2,0,0,double,1
+lhs,geneticLHS,3,0,0,double,1
+lhs,geneticLHS,4,0,0,double,1
+lhs,geneticLHS,5,0,0,character,1
+lhs,geneticLHS,6,0,0,logical,1
+lhs,improvedLHS,-1,0,0,class<`matrix`>,1
+lhs,improvedLHS,0,0,0,double,1
+lhs,improvedLHS,1,0,0,double,1
+lhs,improvedLHS,2,0,0,double,1
+lhs,maximinLHS,-1,0,0,class<`matrix`>,1
+lhs,maximinLHS,0,0,0,double,1
+lhs,maximinLHS,1,0,0,double,1
+lhs,maximinLHS,2,0,0,character,1
+lhs,maximinLHS,3,0,0,double,1
+lhs,maximinLHS,4,0,0,double,1
+lhs,maximinLHS,5,0,0,double,1
+lhs,maximinLHS,6,0,0,character,1
+lhs,maximinLHS,7,0,0,logical,1
+lhs,oa_to_oalhs,-1,0,0,class<`matrix`>,1
+lhs,oa_to_oalhs,0,0,0,double,1
+lhs,oa_to_oalhs,1,0,0,double,1
+lhs,oa_to_oalhs,2,0,0,class<`matrix`>,1
+lhs,optAugmentLHS,-1,0,0,class<`matrix`>,1
+lhs,optAugmentLHS,0,0,0,class<`matrix`>,1
+lhs,optAugmentLHS,1,0,0,double,1
+lhs,optAugmentLHS,2,0,0,double,1
+lhs,optimumLHS,-1,0,0,class<`matrix`>,1
+lhs,optimumLHS,0,0,0,double,1
+lhs,optimumLHS,1,0,0,double,1
+lhs,optimumLHS,2,0,0,double,1
+lhs,optimumLHS,3,0,0,double,1
+lhs,optimumLHS,4,0,0,logical,1
+lhs,optSeededLHS,-1,0,0,class<`matrix`>,1
+lhs,optSeededLHS,0,0,0,class<`matrix`>,1
+lhs,optSeededLHS,1,0,0,double,1
+lhs,optSeededLHS,2,0,0,double,1
+lhs,optSeededLHS,3,0,0,double,1
+lhs,optSeededLHS,4,0,0,logical,1
+lhs,randomLHS,-1,0,0,class<`matrix`>,1
+lhs,randomLHS,0,0,0,double,1
+lhs,randomLHS,1,0,0,double,1
+lhs,randomLHS,2,0,0,logical,1
+lhs,runifint,-1,0,0,double[],1
+lhs,runifint,0,0,0,double,1
+lhs,runifint,1,0,0,double,1
+lhs,runifint,2,0,0,integer,1
+lifecycle,deprecated,-1,0,0,any,1
+lifecycle,deprecate_soft,-1,0,0,any,1
+lifecycle,deprecate_soft,0,0,0,character,1
+lifecycle,deprecate_soft,1,0,0,character,1
+lifecycle,deprecate_soft,2,0,0,null,1
+lifecycle,deprecate_soft,3,0,0,null,1
+lifecycle,deprecate_soft,4,0,0,null,1
+lifecycle,deprecate_soft,5,0,0,any,1
+lifecycle,deprecate_stop,-1,0,0,any,1
+lifecycle,deprecate_stop,0,0,0,character,1
+lifecycle,deprecate_stop,1,0,0,character,1
+lifecycle,deprecate_stop,2,0,0,null,1
+lifecycle,deprecate_stop,3,0,0,null,1
+lifecycle,deprecate_warn,-1,0,0,any,1
+lifecycle,deprecate_warn,0,0,0,character,1
+lifecycle,deprecate_warn,1,0,0,character,1
+lifecycle,deprecate_warn,2,0,0,character,1
+lifecycle,deprecate_warn,2,0,1,null,1
+lifecycle,deprecate_warn,3,0,0,null,1
+lifecycle,deprecate_warn,4,0,0,null,1
+lifecycle,deprecate_warn,5,0,0,any,1
+lifecycle,has_crayon,-1,0,0,logical,1
+lifecycle,lifecycle_build_message,-1,0,0,character,1
+lifecycle,lifecycle_build_message,0,0,0,character,1
+lifecycle,lifecycle_build_message,1,0,0,character,1
+lifecycle,lifecycle_build_message,2,0,0,character,1
+lifecycle,lifecycle_build_message,2,0,1,null,1
+lifecycle,lifecycle_build_message,3,0,0,null,1
+lifecycle,lifecycle_build_message,4,0,0,character,1
+lifecycle,lifecycle_verbosity,-1,0,0,character,1
+lifecycle,new_deprecated_warning,-1,0,0,"class<`condition`, `lifecycle_warning_deprecated`, `warning`>",1
+lifecycle,new_deprecated_warning,0,0,0,character,1
+lifecycle,new_deprecated_warning,1,0,0,class<`rlang_trace`>,1
+lifecycle,paste_line,-1,0,0,character,1
+lifecycle,paste_line,0,0,0,...,1
+lifecycle,push_warning,-1,0,0,"list<class<`condition`, `lifecycle_warning_deprecated`, `warning`>>",1
+lifecycle,push_warning,0,0,0,"class<`condition`, `lifecycle_warning_deprecated`, `warning`>",1
+lifecycle,signal_validate_arg,-1,0,0,character,1
+lifecycle,signal_validate_arg,-1,0,1,null,1
+lifecycle,signal_validate_arg,0,0,0,class<`call`>,1
+lifecycle,signal_validate_arg,1,0,0,any,1
+lifecycle,signal_validate_fn,-1,0,0,character,1
+lifecycle,signal_validate_fn,0,0,0,class<`call`>,1
+lifecycle,signal_validate_pkg,-1,0,0,character,1
+lifecycle,signal_validate_pkg,0,0,0,environment,1
+lifecycle,signal_validate_what,-1,0,0,list<character | class<`call`>>,1
+lifecycle,signal_validate_what,-1,0,1,list<null | class<`call`>>,1
+lifecycle,signal_validate_what,0,0,0,character,1
+lifecycle,signal_validate_what,1,0,0,character,1
+lifecycle,signal_validate_what,2,0,0,any,1
+lifecycle,silver,-1,0,0,character,1
+lifecycle,silver,0,0,0,character,1
+lmerTest,anova.lmerModLmerTest,-1,0,0,any,1
+lmerTest,anova.lmerModLmerTest,0,0,0,class<`lmerModLmerTest`>,1
+lmerTest,anova.lmerModLmerTest,1,0,0,...,1
+lmerTest,anova.lmerModLmerTest,2,0,0,any,1
+lmerTest,anova.lmerModLmerTest,3,0,0,any,1
+lmerTest,anova.merModLmerTest,-1,0,0,"class<`anova`, `data.frame`>",1
+lmerTest,anova.merModLmerTest,0,0,0,class<`merModLmerTest`>,1
+lmerTest,anova.merModLmerTest,1,0,0,...,1
+lmerTest,anova.merModLmerTest,2,0,0,character[],1
+lmerTest,anova.merModLmerTest,3,0,0,character[],1
+lmerTest,as.data.frame.ls_means,-1,0,0,class<`data.frame`>,1
+lmerTest,as.data.frame.ls_means,0,0,0,"class<`data.frame`, `ls_means`>",1
+lmerTest,as.data.frame.ls_means,1,0,0,...,1
+lmerTest,as.data.frame.ls_means,2,0,0,logical,1
+lmerTest,as_lmerModLmerTest,-1,0,0,any,1
+lmerTest,as_lmerModLmerTest,0,0,0,class<`lmerMod`>,1
+lmerTest,as_lmerModLmerTest,0,0,1,class<`merModLmerTest`>,1
+lmerTest,as_lmerModLmerTest,1,0,0,double,1
+lmerTest,as_lmerModLT,-1,0,0,class<`lmerModLmerTest`>,1
+lmerTest,as_lmerModLT,0,0,0,class<`lmerMod`>,1
+lmerTest,as_lmerModLT,0,0,1,class<`merModLmerTest`>,1
+lmerTest,as_lmerModLT,1,0,0,class<`function`>,1
+lmerTest,as_lmerModLT,2,0,0,double,1
+lmerTest,containment,-1,0,0,list<character[]>,1
+lmerTest,containment,0,0,0,class<`lmerModLmerTest`>,1
+lmerTest,contest,-1,0,0,class<`data.frame`>,1
+lmerTest,contest,-1,0,1,list<class<`data.frame`>>,1
+lmerTest,contest,0,0,0,class<`lmerModLmerTest`>,1
+lmerTest,contest,0,0,1,class<`merModLmerTest`>,1
+lmerTest,contest,1,0,0,class<`matrix`>,1
+lmerTest,contest,1,0,1,double[],1
+lmerTest,contest,1,0,2,list<double[] | class<`matrix`>>,1
+lmerTest,contest,2,0,0,...,1
+lmerTest,contest1D,-1,0,0,any,1
+lmerTest,contest1D,0,0,0,class<`lmerMod`>,1
+lmerTest,contest1D,0,0,1,class<`lmerModLmerTest`>,1
+lmerTest,contest1D,1,0,0,class<`matrix`>,1
+lmerTest,contest1D,1,0,1,^double[],1
+lmerTest,contest1D,1,0,2,list<double[]>,1
+lmerTest,contest1D,2,0,0,...,1
+lmerTest,contest1D.lmerMod,-1,0,0,class<`data.frame`>,1
+lmerTest,contest1D.lmerMod,0,0,0,class<`lmerMod`>,1
+lmerTest,contest1D.lmerMod,1,0,0,double[],1
+lmerTest,contest1D.lmerMod,2,0,0,double,1
+lmerTest,contest1D.lmerMod,3,0,0,character[],1
+lmerTest,contest1D.lmerMod,4,0,0,logical,1
+lmerTest,contest1D.lmerMod,5,0,0,double,1
+lmerTest,contest1D.lmerMod,6,0,0,...,1
+lmerTest,contest1D.lmerModLmerTest,-1,0,0,any,1
+lmerTest,contest1D.lmerModLmerTest,0,0,0,class<`lmerModLmerTest`>,1
+lmerTest,contest1D.lmerModLmerTest,1,0,0,class<`matrix`>,1
+lmerTest,contest1D.lmerModLmerTest,1,0,1,^double[],1
+lmerTest,contest1D.lmerModLmerTest,1,0,2,list<double[]>,1
+lmerTest,contest1D.lmerModLmerTest,2,0,0,double,1
+lmerTest,contest1D.lmerModLmerTest,3,0,0,character[],1
+lmerTest,contest1D.lmerModLmerTest,4,0,0,logical,1
+lmerTest,contest1D.lmerModLmerTest,5,0,0,any,1
+lmerTest,contest1D.lmerModLmerTest,6,0,0,...,1
+lmerTest,contest.lmerMod,-1,0,0,class<`data.frame`>,1
+lmerTest,contest.lmerMod,0,0,0,class<`merModLmerTest`>,1
+lmerTest,contest.lmerMod,1,0,0,class<`matrix`>,1
+lmerTest,contest.lmerMod,1,0,1,double[],1
+lmerTest,contest.lmerMod,2,0,0,double,1
+lmerTest,contest.lmerMod,3,0,0,logical,1
+lmerTest,contest.lmerMod,4,0,0,logical,1
+lmerTest,contest.lmerMod,5,0,0,logical,1
+lmerTest,contest.lmerMod,6,0,0,double,1
+lmerTest,contest.lmerMod,7,0,0,logical,1
+lmerTest,contest.lmerModLmerTest,-1,0,0,class<`data.frame`>,1
+lmerTest,contest.lmerModLmerTest,-1,0,1,list<class<`data.frame`>>,1
+lmerTest,contest.lmerModLmerTest,0,0,0,class<`lmerModLmerTest`>,1
+lmerTest,contest.lmerModLmerTest,1,0,0,class<`matrix`>,1
+lmerTest,contest.lmerModLmerTest,1,0,1,double[],1
+lmerTest,contest.lmerModLmerTest,1,0,2,list<double[] | class<`matrix`>>,1
+lmerTest,contest.lmerModLmerTest,2,0,0,double,1
+lmerTest,contest.lmerModLmerTest,3,0,0,logical,1
+lmerTest,contest.lmerModLmerTest,4,0,0,logical,1
+lmerTest,contest.lmerModLmerTest,5,0,0,any,1
+lmerTest,contest.lmerModLmerTest,6,0,0,any,1
+lmerTest,contest.lmerModLmerTest,7,0,0,any,1
+lmerTest,contestMD,-1,0,0,any,1
+lmerTest,contestMD,0,0,0,class<`lmerMod`>,1
+lmerTest,contestMD,0,0,1,class<`lmerModLmerTest`>,1
+lmerTest,contestMD,1,0,0,class<`matrix`>,1
+lmerTest,contestMD,1,0,1,^double[],1
+lmerTest,contestMD,1,0,2,list<class<`matrix`>>,1
+lmerTest,contestMD,2,0,0,...,1
+lmerTest,contestMD.lmerMod,-1,0,0,class<`data.frame`>,1
+lmerTest,contestMD.lmerMod,0,0,0,class<`lmerMod`>,1
+lmerTest,contestMD.lmerMod,1,0,0,class<`matrix`>,1
+lmerTest,contestMD.lmerMod,2,0,0,double,1
+lmerTest,contestMD.lmerMod,3,0,0,character[],1
+lmerTest,contestMD.lmerMod,4,0,0,any,1
+lmerTest,contestMD.lmerMod,5,0,0,...,1
+lmerTest,contestMD.lmerModLmerTest,-1,0,0,any,1
+lmerTest,contestMD.lmerModLmerTest,0,0,0,class<`lmerModLmerTest`>,1
+lmerTest,contestMD.lmerModLmerTest,1,0,0,class<`matrix`>,1
+lmerTest,contestMD.lmerModLmerTest,1,0,1,^double[],1
+lmerTest,contestMD.lmerModLmerTest,1,0,2,list<class<`matrix`>>,1
+lmerTest,contestMD.lmerModLmerTest,2,0,0,double[],1
+lmerTest,contestMD.lmerModLmerTest,3,0,0,any,1
+lmerTest,contestMD.lmerModLmerTest,4,0,0,any,1
+lmerTest,contestMD.lmerModLmerTest,5,0,0,...,1
+lmerTest,difflsmeans,-1,0,0,"class<`data.frame`, `ls_means`>",1
+lmerTest,difflsmeans,0,0,0,class<`lmerModLmerTest`>,1
+lmerTest,difflsmeans,0,0,1,class<`merModLmerTest`>,1
+lmerTest,difflsmeans,1,0,0,...,1
+lmerTest,difflsmeans.lmerModLmerTest,-1,0,0,"class<`data.frame`, `ls_means`>",1
+lmerTest,difflsmeans.lmerModLmerTest,0,0,0,class<`lmerModLmerTest`>,1
+lmerTest,difflsmeans.lmerModLmerTest,1,0,0,null,1
+lmerTest,difflsmeans.lmerModLmerTest,2,0,0,double,1
+lmerTest,difflsmeans.lmerModLmerTest,3,0,0,character[],1
+lmerTest,difflsmeans.lmerModLmerTest,4,0,0,...,1
+lmerTest,difflsmeans.merModLmerTest,-1,0,0,"class<`data.frame`, `ls_means`>",1
+lmerTest,difflsmeans.merModLmerTest,0,0,0,class<`merModLmerTest`>,1
+lmerTest,difflsmeans.merModLmerTest,1,0,0,null,1
+lmerTest,difflsmeans.merModLmerTest,2,0,0,double,1
+lmerTest,difflsmeans.merModLmerTest,3,0,0,character[],1
+lmerTest,difflsmeans.merModLmerTest,4,0,0,...,1
+lmerTest,doolittle,-1,0,0,list<class<`matrix`>>,1
+lmerTest,doolittle,0,0,0,class<`matrix`>,1
+lmerTest,doolittle,1,0,0,double,1
+lmerTest,drop1.lmerModLmerTest,-1,0,0,any,1
+lmerTest,drop1.lmerModLmerTest,0,0,0,class<`lmerModLmerTest`>,1
+lmerTest,drop1.lmerModLmerTest,1,0,0,any,1
+lmerTest,drop1.lmerModLmerTest,2,0,0,character[],1
+lmerTest,drop1.lmerModLmerTest,3,0,0,logical,1
+lmerTest,drop1.lmerModLmerTest,4,0,0,...,1
+lmerTest,drop1.merModLmerTest,-1,0,0,"class<`anova`, `data.frame`>",1
+lmerTest,drop1.merModLmerTest,0,0,0,class<`merModLmerTest`>,1
+lmerTest,drop1.merModLmerTest,1,0,0,any,1
+lmerTest,drop1.merModLmerTest,2,0,0,character[],1
+lmerTest,drop1.merModLmerTest,3,0,0,logical,1
+lmerTest,drop1.merModLmerTest,4,0,0,...,1
+lmerTest,ensure_full_rank,-1,0,0,class<`matrix`>,1
+lmerTest,ensure_full_rank,0,0,0,class<`matrix`>,1
+lmerTest,ensure_full_rank,1,0,0,double,1
+lmerTest,ensure_full_rank,2,0,0,logical,1
+lmerTest,ensure_full_rank,3,0,0,logical,1
+lmerTest,extract_contrasts_type3,-1,0,0,list<class<`matrix`>>,1
+lmerTest,extract_contrasts_type3,0,0,0,class<`lmerModLmerTest`>,1
+lmerTest,extract_contrasts_type3,1,0,0,class<`matrix`>,1
+lmerTest,fix_redTable,-1,0,0,"class<`anova`, `data.frame`>",1
+lmerTest,fix_redTable,0,0,0,"class<`anova`, `data.frame`>",1
+lmerTest,get_coefmat,-1,0,0,class<`matrix`>,1
+lmerTest,get_coefmat,0,0,0,class<`lmerModLmerTest`>,1
+lmerTest,get_coefmat,1,0,0,character,1
+lmerTest,get_contrast_coding,-1,0,0,list<any>,1
+lmerTest,get_contrast_coding,-1,0,1,null,1
+lmerTest,get_contrast_coding,0,0,0,class<`lmerModLmerTest`>,1
+lmerTest,get_contrast_coding,1,0,0,character,1
+lmerTest,get_contrasts_marginal,-1,0,0,list<class<`matrix`>>,1
+lmerTest,get_contrasts_marginal,0,0,0,class<`lmerModLmerTest`>,1
+lmerTest,get_contrasts_marginal,1,0,0,null,1
+lmerTest,get_contrasts_marginal,1,0,1,character[],1
+lmerTest,get_contrasts_type1,-1,0,0,list<class<`matrix`>>,1
+lmerTest,get_contrasts_type1,0,0,0,class<`lmerModLmerTest`>,1
+lmerTest,get_contrasts_type2,-1,0,0,list<class<`matrix`>>,1
+lmerTest,get_contrasts_type2,0,0,0,class<`lmerModLmerTest`>,1
+lmerTest,get_contrasts_type2,1,0,0,character[],1
+lmerTest,get_contrasts_type2_unfolded,-1,0,0,list<class<`matrix`>>,1
+lmerTest,get_contrasts_type2_unfolded,0,0,0,class<`lmerModLmerTest`>,1
+lmerTest,get_contrasts_type2_unfolded,1,0,0,null,1
+lmerTest,get_contrasts_type3,-1,0,0,list<class<`matrix`>>,1
+lmerTest,get_contrasts_type3,0,0,0,class<`lmerModLmerTest`>,1
+lmerTest,get_contrasts_type3,1,0,0,null,1
+lmerTest,get_fac_list,-1,0,0,list<any>,1
+lmerTest,get_fac_list,0,0,0,class<`lmerModLmerTest`>,1
+lmerTest,get_Fstat_ddf,-1,0,0,double,1
+lmerTest,get_Fstat_ddf,0,0,0,double[],1
+lmerTest,get_Fstat_ddf,1,0,0,double,1
+lmerTest,get_Ldiffmat2,-1,0,0,class<`matrix`>,1
+lmerTest,get_Ldiffmat2,0,0,0,class<`matrix`>,1
+lmerTest,get_Ldiffmat2,1,0,0,class<`matrix`>,1
+lmerTest,get_lhs,-1,0,0,class<`formula`>,1
+lmerTest,get_lhs,0,0,0,character,1
+lmerTest,get_lm_call,-1,0,0,list<class<`name`> | class<`formula`>>,1
+lmerTest,get_lm_call,0,0,0,class<`lmerModLmerTest`>,1
+lmerTest,get_lm_call,0,0,1,class<`merModLmerTest`>,1
+lmerTest,get_lm_call,1,0,0,class<`formula`>,1
+lmerTest,get_logLik,-1,0,0,class<`data.frame`>,1
+lmerTest,get_logLik,0,0,0,class<`lm`>,1
+lmerTest,get_logLik,0,0,1,class<`lmerMod`>,1
+lmerTest,get_logLik,0,0,2,class<`lmerModLmerTest`>,1
+lmerTest,get_logLik,0,0,3,class<`merModLmerTest`>,1
+lmerTest,get_logLik,1,0,0,...,1
+lmerTest,get_min_data,-1,0,0,class<`data.frame`>,1
+lmerTest,get_min_data,0,0,0,class<`lmerModLmerTest`>,1
+lmerTest,get_min_data,1,0,0,any,1
+lmerTest,get_model,-1,0,0,class<`lmerModLmerTest`>,1
+lmerTest,get_model,0,0,0,class<`step_list`>,1
+lmerTest,get_model,1,0,0,...,1
+lmerTest,get_model_matrix,-1,0,0,class<`matrix`>,1
+lmerTest,get_model_matrix,0,0,0,class<`lmerModLmerTest`>,1
+lmerTest,get_model_matrix,1,0,0,character,1
+lmerTest,get_model_matrix,2,0,0,character,1
+lmerTest,get_model.step_list,-1,0,0,class<`lmerModLmerTest`>,1
+lmerTest,get_model.step_list,0,0,0,class<`step_list`>,1
+lmerTest,get_model.step_list,1,0,0,...,1
+lmerTest,get_num_list,-1,0,0,list<any>,1
+lmerTest,get_num_list,0,0,0,class<`lmerModLmerTest`>,1
+lmerTest,get_num_list,1,0,0,any,1
+lmerTest,get_pairs,-1,0,0,class<`data.frame`>,1
+lmerTest,get_pairs,0,0,0,character[],1
+lmerTest,get_rdX,-1,0,0,class<`matrix`>,1
+lmerTest,get_rdX,0,0,0,class<`lmerModLmerTest`>,1
+lmerTest,get_rdX,1,0,0,logical,1
+lmerTest,get_rhs,-1,0,0,character,1
+lmerTest,get_rhs,0,0,0,character,1
+lmerTest,get_var_list,-1,0,0,list<any>,1
+lmerTest,get_var_list,0,0,0,class<`lmerModLmerTest`>,1
+lmerTest,get_var_list,1,0,0,any,1
+lmerTest,has_ranef,-1,0,0,logical,1
+lmerTest,has_ranef,0,0,0,class<`call`>,1
+lmerTest,has_ranef,0,0,1,class<`formula`>,1
+lmerTest,has_terms,-1,0,0,logical,1
+lmerTest,has_terms,0,0,0,class<`formula`>,1
+lmerTest,is_estimable,-1,0,0,logical[],1
+lmerTest,is_estimable,0,0,0,class<`matrix`>,1
+lmerTest,is_estimable,1,0,0,class<`matrix`>,1
+lmerTest,is_estimable,2,0,0,null,1
+lmerTest,is_estimable,3,0,0,any,1
+lmerTest,lmer,-1,0,0,any,1
+lmerTest,lmer,0,0,0,any,1
+lmerTest,lmer,1,0,0,any,1
+lmerTest,lmer,2,0,0,logical,1
+lmerTest,lmer,3,0,0,any,1
+lmerTest,lmer,4,0,0,null,1
+lmerTest,lmer,5,0,0,integer,1
+lmerTest,lmer,6,0,0,any,1
+lmerTest,lmer,7,0,0,any,1
+lmerTest,ls_means,-1,0,0,"class<`data.frame`, `ls_means`>",1
+lmerTest,ls_means,0,0,0,class<`lmerModLmerTest`>,1
+lmerTest,ls_means,0,0,1,class<`merModLmerTest`>,1
+lmerTest,ls_means,1,0,0,...,1
+lmerTest,lsmeans_contrasts,-1,0,0,list<any>,1
+lmerTest,lsmeans_contrasts,0,0,0,class<`lmerModLmerTest`>,1
+lmerTest,lsmeans_contrasts,1,0,0,null,1
+lmerTest,lsmeans_contrasts,1,0,1,character,1
+lmerTest,ls_means.lmerModLmerTest,-1,0,0,"class<`data.frame`, `ls_means`>",1
+lmerTest,ls_means.lmerModLmerTest,0,0,0,class<`lmerModLmerTest`>,1
+lmerTest,ls_means.lmerModLmerTest,1,0,0,character,1
+lmerTest,ls_means.lmerModLmerTest,1,0,1,null,1
+lmerTest,ls_means.lmerModLmerTest,2,0,0,double,1
+lmerTest,ls_means.lmerModLmerTest,3,0,0,character[],1
+lmerTest,ls_means.lmerModLmerTest,4,0,0,logical,1
+lmerTest,ls_means.lmerModLmerTest,5,0,0,...,1
+lmerTest,lsmeansLT,-1,0,0,"class<`data.frame`, `ls_means`>",1
+lmerTest,lsmeansLT,0,0,0,class<`lmerModLmerTest`>,1
+lmerTest,lsmeansLT,1,0,0,...,1
+lmerTest,lsmeansLT.lmerModLmerTest,-1,0,0,"class<`data.frame`, `ls_means`>",1
+lmerTest,lsmeansLT.lmerModLmerTest,0,0,0,class<`lmerModLmerTest`>,1
+lmerTest,lsmeansLT.lmerModLmerTest,1,0,0,character,1
+lmerTest,lsmeansLT.lmerModLmerTest,1,0,1,null,1
+lmerTest,lsmeansLT.lmerModLmerTest,2,0,0,double,1
+lmerTest,lsmeansLT.lmerModLmerTest,3,0,0,character[],1
+lmerTest,lsmeansLT.lmerModLmerTest,4,0,0,logical,1
+lmerTest,lsmeansLT.lmerModLmerTest,5,0,0,...,1
+lmerTest,ls_means.merModLmerTest,-1,0,0,"class<`data.frame`, `ls_means`>",1
+lmerTest,ls_means.merModLmerTest,0,0,0,class<`merModLmerTest`>,1
+lmerTest,ls_means.merModLmerTest,1,0,0,null,1
+lmerTest,ls_means.merModLmerTest,2,0,0,double,1
+lmerTest,ls_means.merModLmerTest,3,0,0,character[],1
+lmerTest,ls_means.merModLmerTest,4,0,0,logical,1
+lmerTest,ls_means.merModLmerTest,5,0,0,...,1
+lmerTest,mk_LRtab,-1,0,0,class<`data.frame`>,1
+lmerTest,mk_LRtab,0,0,0,class<`data.frame`>,1
+lmerTest,nullspace,-1,0,0,class<`matrix`>,1
+lmerTest,nullspace,0,0,0,class<`matrix`>,1
+lmerTest,nullspace,1,0,0,character[],1
+lmerTest,nullspace,2,0,0,any,1
+lmerTest,numeric_terms,-1,0,0,list<any>,1
+lmerTest,numeric_terms,-1,0,1,logical[],1
+lmerTest,numeric_terms,0,0,0,class<`lmerModLmerTest`>,1
+lmerTest,qform,-1,0,0,double,1
+lmerTest,qform,0,0,0,double[],1
+lmerTest,qform,1,0,0,class<`matrix`>,1
+lmerTest,ranova,-1,0,0,"class<`anova`, `data.frame`>",1
+lmerTest,ranova,0,0,0,class<`lmerModLmerTest`>,1
+lmerTest,ranova,0,0,1,class<`merModLmerTest`>,1
+lmerTest,ranova,1,0,0,logical,1
+lmerTest,ranova,2,0,0,...,1
+lmerTest,ran_redTable,-1,0,0,"class<`anova`, `data.frame`>",1
+lmerTest,ran_redTable,0,0,0,"class<`anova`, `data.frame`>",1
+lmerTest,rbindall,-1,0,0,class<`data.frame`>,1
+lmerTest,rbindall,0,0,0,...,1
+lmerTest,reduce_fixed,-1,0,0,"class<`anova`, `data.frame`>",1
+lmerTest,reduce_fixed,0,0,0,class<`lmerModLmerTest`>,1
+lmerTest,reduce_fixed,1,0,0,character[],1
+lmerTest,reduce_fixed,2,0,0,double,1
+lmerTest,reduce_fixed,3,0,0,character[],1
+lmerTest,reduce_random,-1,0,0,"class<`anova`, `data.frame`>",1
+lmerTest,reduce_random,0,0,0,class<`lmerModLmerTest`>,1
+lmerTest,reduce_random,1,0,0,double,1
+lmerTest,rm_complete_terms,-1,0,0,list<class<`formula`>>,1
+lmerTest,rm_complete_terms,0,0,0,list<character>,1
+lmerTest,rm_complete_terms,0,0,1,character[],1
+lmerTest,rm_complete_terms,1,0,0,class<`formula`>,1
+lmerTest,rm_complete_terms,2,0,0,logical,1
+lmerTest,safeDeparse,-1,0,0,character,1
+lmerTest,safeDeparse,0,0,0,class<`call`>,1
+lmerTest,safeDeparse,0,0,1,class<`name`>,1
+lmerTest,safeDeparse,1,0,0,integer,1
+lmerTest,safeDeparse,2,0,0,logical,1
+lmerTest,safeDeparse,3,0,0,character[],1
+lmerTest,safeDeparse,4,0,0,integer,1
+lmerTest,show_tests,-1,0,0,"list<class<`fractions`, `matrix`>>",1
+lmerTest,show_tests,-1,0,1,list<class<`matrix`>>,1
+lmerTest,show_tests,0,0,0,"class<`anova`, `data.frame`>",1
+lmerTest,show_tests,0,0,1,"class<`data.frame`, `ls_means`>",1
+lmerTest,show_tests,1,0,0,...,1
+lmerTest,show_tests.anova,-1,0,0,"list<class<`fractions`, `matrix`>>",1
+lmerTest,show_tests.anova,-1,0,1,list<class<`matrix`>>,1
+lmerTest,show_tests.anova,0,0,0,"class<`anova`, `data.frame`>",1
+lmerTest,show_tests.anova,0,0,1,"class<`data.frame`, `ls_means`>",1
+lmerTest,show_tests.anova,1,0,0,logical,1
+lmerTest,show_tests.anova,2,0,0,logical,1
+lmerTest,show_tests.anova,3,0,0,...,1
+lmerTest,show_tests.default,-1,0,0,"list<class<`fractions`, `matrix`>>",1
+lmerTest,show_tests.default,-1,0,1,list<class<`matrix`>>,1
+lmerTest,show_tests.default,0,0,0,"class<`anova`, `data.frame`>",1
+lmerTest,show_tests.default,0,0,1,"class<`data.frame`, `ls_means`>",1
+lmerTest,show_tests.default,1,0,0,logical,1
+lmerTest,show_tests.default,2,0,0,logical,1
+lmerTest,show_tests.default,3,0,0,...,1
+lmerTest,show_tests.ls_means,-1,0,0,"list<class<`fractions`, `matrix`>>",1
+lmerTest,show_tests.ls_means,-1,0,1,list<class<`matrix`>>,1
+lmerTest,show_tests.ls_means,0,0,0,"class<`anova`, `data.frame`>",1
+lmerTest,show_tests.ls_means,0,0,1,"class<`data.frame`, `ls_means`>",1
+lmerTest,show_tests.ls_means,1,0,0,logical,1
+lmerTest,show_tests.ls_means,2,0,0,logical,1
+lmerTest,show_tests.ls_means,3,0,0,...,1
+lmerTest,single_anova,-1,0,0,any,1
+lmerTest,single_anova,0,0,0,class<`lmerModLmerTest`>,1
+lmerTest,single_anova,1,0,0,character[],1
+lmerTest,single_anova,1,0,1,double,1
+lmerTest,single_anova,2,0,0,any,1
+lmerTest,step,-1,0,0,class<`step_list`>,1
+lmerTest,step,0,0,0,class<`lmerModLmerTest`>,1
+lmerTest,step,0,0,1,class<`merModLmerTest`>,1
+lmerTest,step,1,0,0,...,1
+lmerTest,step.lmerModLmerTest,-1,0,0,class<`step_list`>,1
+lmerTest,step.lmerModLmerTest,0,0,0,class<`lmerModLmerTest`>,1
+lmerTest,step.lmerModLmerTest,1,0,0,character[],1
+lmerTest,step.lmerModLmerTest,2,0,0,double,1
+lmerTest,step.lmerModLmerTest,3,0,0,double,1
+lmerTest,step.lmerModLmerTest,4,0,0,logical,1
+lmerTest,step.lmerModLmerTest,5,0,0,logical,1
+lmerTest,step.lmerModLmerTest,6,0,0,any,1
+lmerTest,step.lmerModLmerTest,7,0,0,...,1
+lmerTest,step.merModLmerTest,-1,0,0,class<`step_list`>,1
+lmerTest,step.merModLmerTest,0,0,0,class<`merModLmerTest`>,1
+lmerTest,step.merModLmerTest,1,0,0,character[],1
+lmerTest,step.merModLmerTest,2,0,0,double,1
+lmerTest,step.merModLmerTest,3,0,0,double,1
+lmerTest,step.merModLmerTest,4,0,0,logical,1
+lmerTest,step.merModLmerTest,5,0,0,logical,1
+lmerTest,step.merModLmerTest,6,0,0,any,1
+lmerTest,step.merModLmerTest,7,0,0,...,1
+lmerTest,summary.lmerModLmerTest,-1,0,0,"class<`summary.lmerModLmerTest`, `summary.merMod`>",1
+lmerTest,summary.lmerModLmerTest,-1,0,1,class<`summary.merMod`>,1
+lmerTest,summary.lmerModLmerTest,0,0,0,class<`lmerModLmerTest`>,1
+lmerTest,summary.lmerModLmerTest,1,0,0,...,1
+lmerTest,summary.lmerModLmerTest,2,0,0,character[],1
+lmerTest,summary.merModLmerTest,-1,0,0,"class<`summary.lmerModLmerTest`, `summary.merMod`>",1
+lmerTest,summary.merModLmerTest,0,0,0,class<`merModLmerTest`>,1
+lmerTest,summary.merModLmerTest,1,0,0,...,1
+lmerTest,summary.merModLmerTest,2,0,0,character[],1
+lmerTest,term2colX,-1,0,0,list<integer[]>,1
+lmerTest,term2colX,0,0,0,"class<`formula`, `terms`>",1
+lmerTest,term2colX,1,0,0,class<`matrix`>,1
+lmerTest,term_contain,-1,0,0,logical[],1
+lmerTest,term_contain,0,0,0,character,1
+lmerTest,term_contain,1,0,0,class<`matrix`>,1
+lmerTest,term_contain,2,0,0,character[],1
+lmerTest,term_contain,3,0,0,character[],1
+lmerTest,update.lmerModLmerTest,-1,0,0,class<`call`>,1
+lmerTest,update.lmerModLmerTest,-1,0,1,class<`function`>,1
+lmerTest,update.lmerModLmerTest,-1,0,2,class<`lmerModLmerTest`>,1
+lmerTest,update.lmerModLmerTest,0,0,0,class<`lmerModLmerTest`>,1
+lmerTest,update.lmerModLmerTest,1,0,0,any,1
+lmerTest,update.lmerModLmerTest,2,0,0,...,1
+lmerTest,update.lmerModLmerTest,3,0,0,logical,1
+lmerTest,waldCI,-1,0,0,class<`matrix`>,1
+lmerTest,waldCI,0,0,0,double[],1
+lmerTest,waldCI,0,0,1,null,1
+lmerTest,waldCI,1,0,0,double[],1
+lmerTest,waldCI,1,0,1,null,1
+lmerTest,waldCI,2,0,0,double[],1
+lmerTest,waldCI,2,0,1,null,1
+lmerTest,waldCI,3,0,0,double,1
+lmtest,bgtest,-1,0,0,"class<`bgtest`, `htest`>",1
+lmtest,bgtest,0,0,0,class<`formula`>,1
+lmtest,bgtest,1,0,0,double,1
+lmtest,bgtest,2,0,0,null,1
+lmtest,bgtest,3,0,0,character[],1
+lmtest,bgtest,4,0,0,"class<`mts`, `ts`>",1
+lmtest,bgtest,4,0,1,list<any>,1
+lmtest,bgtest,5,0,0,double,1
+lmtest,bptest,-1,0,0,class<`htest`>,1
+lmtest,bptest,0,0,0,class<`formula`>,1
+lmtest,bptest,1,0,0,class<`formula`>,1
+lmtest,bptest,1,0,1,null,1
+lmtest,bptest,2,0,0,logical,1
+lmtest,bptest,3,0,0,"class<`mts`, `ts`>",1
+lmtest,bptest,3,0,1,"class<`matrix`, `mts`, `ts`>",1
+lmtest,bptest,3,0,2,list<any>,1
+lmtest,coefci,-1,0,0,class<`matrix`>,1
+lmtest,coefci,0,0,0,class<`lm`>,1
+lmtest,coefci,1,0,0,null,1
+lmtest,coefci,2,0,0,double,1
+lmtest,coefci,3,0,0,class<`function`>,1
+lmtest,coefci,3,0,1,null,1
+lmtest,coefci,4,0,0,double,1
+lmtest,coefci,4,0,1,null,1
+lmtest,coefci,5,0,0,...,1
+lmtest,coefci.default,-1,0,0,class<`matrix`>,1
+lmtest,coefci.default,0,0,0,class<`lm`>,1
+lmtest,coefci.default,1,0,0,null,1
+lmtest,coefci.default,2,0,0,double,1
+lmtest,coefci.default,3,0,0,class<`function`>,1
+lmtest,coefci.default,3,0,1,null,1
+lmtest,coefci.default,4,0,0,double,1
+lmtest,coefci.default,4,0,1,null,1
+lmtest,coefci.default,5,0,0,...,1
+lmtest,coeftest,-1,0,0,class<`coeftest`>,1
+lmtest,coeftest,0,0,0,"class<`bgtest`, `htest`>",1
+lmtest,coeftest,0,0,1,class<`lm`>,1
+lmtest,coeftest,1,0,0,null,1
+lmtest,coeftest,1,0,1,class<`function`>,1
+lmtest,coeftest,1,0,2,class<`matrix`>,1
+lmtest,coeftest,2,0,0,null,1
+lmtest,coeftest,2,0,1,double,1
+lmtest,coeftest,3,0,0,...,1
+lmtest,coeftest.default,-1,0,0,class<`coeftest`>,1
+lmtest,coeftest.default,0,0,0,"class<`bgtest`, `htest`>",1
+lmtest,coeftest.default,0,0,1,class<`lm`>,1
+lmtest,coeftest.default,1,0,0,null,1
+lmtest,coeftest.default,1,0,1,class<`function`>,1
+lmtest,coeftest.default,1,0,2,class<`matrix`>,1
+lmtest,coeftest.default,2,0,0,null,1
+lmtest,coeftest.default,2,0,1,double,1
+lmtest,coeftest.default,3,0,0,...,1
+lmtest,confint.coeftest,-1,0,0,class<`matrix`>,1
+lmtest,confint.coeftest,0,0,0,class<`coeftest`>,1
+lmtest,confint.coeftest,1,0,0,null,1
+lmtest,confint.coeftest,2,0,0,double,1
+lmtest,confint.coeftest,3,0,0,...,1
+lmtest,coxtest,-1,0,0,"class<`anova`, `data.frame`>",1
+lmtest,coxtest,0,0,0,class<`lm`>,1
+lmtest,coxtest,1,0,0,class<`lm`>,1
+lmtest,coxtest,2,0,0,any,1
+lmtest,df.residual.bgtest,-1,0,0,null,1
+lmtest,df.residual.bgtest,0,0,0,"class<`bgtest`, `htest`>",1
+lmtest,df.residual.bgtest,1,0,0,...,1
+lmtest,df.residual.coeftest,-1,0,0,double,1
+lmtest,df.residual.coeftest,0,0,0,class<`coeftest`>,1
+lmtest,df.residual.coeftest,1,0,0,...,1
+lmtest,dwtest,-1,0,0,class<`htest`>,1
+lmtest,dwtest,0,0,0,class<`formula`>,1
+lmtest,dwtest,1,0,0,null,1
+lmtest,dwtest,2,0,0,character[],1
+lmtest,dwtest,3,0,0,double,1
+lmtest,dwtest,4,0,0,null,1
+lmtest,dwtest,5,0,0,double,1
+lmtest,dwtest,6,0,0,class<`data.frame`>,1
+lmtest,dwtest,6,0,1,"class<`matrix`, `mts`, `ts`>",1
+lmtest,dwtest,6,0,2,"class<`mts`, `ts`>",1
+lmtest,dwtest,6,0,3,list<any>,1
+lmtest,encomptest,-1,0,0,"class<`anova`, `data.frame`>",1
+lmtest,encomptest,0,0,0,class<`lm`>,1
+lmtest,encomptest,1,0,0,class<`lm`>,1
+lmtest,encomptest,2,0,0,any,1
+lmtest,encomptest,3,0,0,null,1
+lmtest,encomptest,4,0,0,...,1
+lmtest,gqtest,-1,0,0,class<`htest`>,1
+lmtest,gqtest,0,0,0,class<`formula`>,1
+lmtest,gqtest,1,0,0,double,1
+lmtest,gqtest,2,0,0,double,1
+lmtest,gqtest,3,0,0,character[],1
+lmtest,gqtest,4,0,0,null,1
+lmtest,gqtest,5,0,0,list<any>,1
+lmtest,grangertest,-1,0,0,"class<`anova`, `data.frame`>",1
+lmtest,grangertest,0,0,0,class<`formula`>,1
+lmtest,grangertest,0,0,1,class<`matrix`>,1
+lmtest,grangertest,0,0,2,"class<`mts`, `ts`>",1
+lmtest,grangertest,0,0,3,class<`ts`>,1
+lmtest,grangertest,1,0,0,...,1
+lmtest,grangertest.default,-1,0,0,"class<`anova`, `data.frame`>",1
+lmtest,grangertest.default,0,0,0,class<`matrix`>,1
+lmtest,grangertest.default,0,0,1,"class<`mts`, `ts`>",1
+lmtest,grangertest.default,0,0,2,class<`ts`>,1
+lmtest,grangertest.default,1,0,0,any,1
+lmtest,grangertest.default,2,0,0,double,1
+lmtest,grangertest.default,3,0,0,class<`function`>,1
+lmtest,grangertest.default,4,0,0,...,1
+lmtest,grangertest.formula,-1,0,0,"class<`anova`, `data.frame`>",1
+lmtest,grangertest.formula,0,0,0,class<`formula`>,1
+lmtest,grangertest.formula,1,0,0,"class<`mts`, `ts`>",1
+lmtest,grangertest.formula,2,0,0,...,1
+lmtest,harvtest,-1,0,0,class<`htest`>,1
+lmtest,harvtest,0,0,0,class<`formula`>,1
+lmtest,harvtest,1,0,0,class<`formula`>,1
+lmtest,harvtest,1,0,1,null,1
+lmtest,harvtest,2,0,0,"class<`matrix`, `mts`, `ts`>",1
+lmtest,harvtest,2,0,1,"class<`mts`, `ts`>",1
+lmtest,harvtest,2,0,2,list<any>,1
+lmtest,hmctest,-1,0,0,class<`htest`>,1
+lmtest,hmctest,0,0,0,class<`formula`>,1
+lmtest,hmctest,1,0,0,double,1
+lmtest,hmctest,2,0,0,null,1
+lmtest,hmctest,3,0,0,logical,1
+lmtest,hmctest,4,0,0,double,1
+lmtest,hmctest,5,0,0,logical,1
+lmtest,hmctest,6,0,0,list<any>,1
+lmtest,jtest,-1,0,0,"class<`anova`, `data.frame`>",1
+lmtest,jtest,0,0,0,class<`lm`>,1
+lmtest,jtest,1,0,0,class<`lm`>,1
+lmtest,jtest,2,0,0,any,1
+lmtest,jtest,3,0,0,null,1
+lmtest,jtest,4,0,0,...,1
+lmtest,lrtest,-1,0,0,"class<`anova`, `data.frame`>",1
+lmtest,lrtest,0,0,0,class<`lm`>,1
+lmtest,lrtest,1,0,0,...,1
+lmtest,lrtest.default,-1,0,0,"class<`anova`, `data.frame`>",1
+lmtest,lrtest.default,0,0,0,class<`lm`>,1
+lmtest,lrtest.default,1,0,0,...,1
+lmtest,lrtest.default,2,0,0,null,1
+lmtest,raintest,-1,0,0,class<`htest`>,1
+lmtest,raintest,0,0,0,class<`formula`>,1
+lmtest,raintest,1,0,0,double,1
+lmtest,raintest,2,0,0,character,1
+lmtest,raintest,2,0,1,class<`formula`>,1
+lmtest,raintest,2,0,2,null,1
+lmtest,raintest,3,0,0,null,1
+lmtest,raintest,4,0,0,"class<`matrix`, `mts`, `ts`>",1
+lmtest,raintest,4,0,1,"class<`mts`, `ts`>",1
+lmtest,raintest,4,0,2,class<`data.frame`>,1
+lmtest,raintest,4,0,3,list<any>,1
+lmtest,reset,-1,0,0,class<`htest`>,1
+lmtest,reset,0,0,0,class<`formula`>,1
+lmtest,reset,1,0,0,double,1
+lmtest,reset,1,0,1,integer[],1
+lmtest,reset,2,0,0,character[],1
+lmtest,reset,3,0,0,"class<`matrix`, `mts`, `ts`>",1
+lmtest,reset,3,0,1,"class<`mts`, `ts`>",1
+lmtest,reset,3,0,2,class<`data.frame`>,1
+lmtest,reset,3,0,3,list<any>,1
+lmtest,reset,4,0,0,null,1
+lmtest,reset,5,0,0,...,1
+lmtest,resettest,-1,0,0,class<`htest`>,1
+lmtest,resettest,0,0,0,class<`formula`>,1
+lmtest,resettest,1,0,0,double,1
+lmtest,resettest,1,0,1,integer[],1
+lmtest,resettest,2,0,0,character[],1
+lmtest,resettest,3,0,0,"class<`matrix`, `mts`, `ts`>",1
+lmtest,resettest,3,0,1,"class<`mts`, `ts`>",1
+lmtest,resettest,3,0,2,class<`data.frame`>,1
+lmtest,resettest,3,0,3,list<any>,1
+lmtest,resettest,4,0,0,null,1
+lmtest,resettest,5,0,0,...,1
+lmtest,vcov.bgtest,-1,0,0,class<`matrix`>,1
+lmtest,vcov.bgtest,0,0,0,"class<`bgtest`, `htest`>",1
+lmtest,vcov.bgtest,1,0,0,...,1
+lmtest,waldtest,-1,0,0,"class<`anova`, `data.frame`>",1
+lmtest,waldtest,0,0,0,class<`lm`>,1
+lmtest,waldtest,1,0,0,...,1
+lmtest,waldtest.default,-1,0,0,"class<`anova`, `data.frame`>",1
+lmtest,waldtest.default,0,0,0,class<`lm`>,1
+lmtest,waldtest.default,1,0,0,...,1
+lmtest,waldtest.default,2,0,0,class<`function`>,1
+lmtest,waldtest.default,2,0,1,null,1
+lmtest,waldtest.default,3,0,0,character,1
+lmtest,waldtest.default,4,0,0,null,1
+lmtest,waldtest.lm,-1,0,0,"class<`anova`, `data.frame`>",1
+lmtest,waldtest.lm,0,0,0,class<`lm`>,1
+lmtest,waldtest.lm,1,0,0,...,1
+lmtest,waldtest.lm,2,0,0,character[],1
+logging,addHandler,-1,0,0,any,1
+logging,addHandler,0,0,0,class<`function`>,1
+logging,addHandler,0,0,1,character,1
+logging,addHandler,1,0,0,...,1
+logging,addHandler,2,0,0,character,1
+logging,.basic_config,-1,0,0,environment,1
+logging,.basic_config,0,0,0,class<`Logger`>,1
+logging,basicConfig,-1,0,0,null,1
+logging,basicConfig,0,0,0,character,1
+logging,basicConfig,0,0,1,double,1
+logging,.build_msg_coloring,-1,0,0,class<`function`>,1
+logging,getHandler,-1,0,0,environment,1
+logging,getHandler,-1,0,1,null,1
+logging,getHandler,0,0,0,character,1
+logging,getHandler,0,0,1,class<`function`>,1
+logging,getHandler,1,0,0,character,1
+logging,getLogger,-1,0,0,class<`Logger`>,1
+logging,getLogger,0,0,0,character,1
+logging,getLogger,1,0,0,...,1
+logging,levellog,-1,0,0,logical,1
+logging,levellog,0,0,0,character,1
+logging,levellog,1,0,0,double,1
+logging,levellog,2,0,0,...,1
+logging,levellog,3,0,0,character,1
+logging,.levellog,-1,0,0,any,1
+logging,.levellog,0,0,0,double,1
+logging,.levellog,0,0,1,character,1
+logging,.levellog,1,0,0,any,1
+logging,.levellog,2,0,0,...,1
+logging,.levellog,3,0,0,character,1
+logging,.levellog,3,0,1,class<`Logger`>,1
+logging,logdebug,-1,0,0,logical,1
+logging,logdebug,0,0,0,character,1
+logging,logdebug,1,0,0,...,1
+logging,logdebug,2,0,0,character,1
+logging,logerror,-1,0,0,logical,1
+logging,logerror,0,0,0,character,1
+logging,logerror,1,0,0,...,1
+logging,logerror,2,0,0,character,1
+logging,logfine,-1,0,0,logical,1
+logging,logfine,0,0,0,character,1
+logging,logfine,1,0,0,...,1
+logging,logfine,2,0,0,character,1
+logging,logfiner,-1,0,0,logical,1
+logging,logfiner,0,0,0,character,1
+logging,logfiner,1,0,0,...,1
+logging,logfiner,2,0,0,character,1
+logging,logfinest,-1,0,0,logical,1
+logging,logfinest,0,0,0,character,1
+logging,logfinest,1,0,0,...,1
+logging,logfinest,2,0,0,character,1
+logging,loginfo,-1,0,0,any,1
+logging,loginfo,0,0,0,character,1
+logging,loginfo,0,0,1,double,1
+logging,loginfo,1,0,0,...,1
+logging,loginfo,2,0,0,character,1
+logging,loginfo,2,0,1,class<`Logger`>,1
+logging,logReset,-1,0,0,null,1
+logging,logwarn,-1,0,0,logical,1
+logging,logwarn,0,0,0,character,1
+logging,logwarn,1,0,0,...,1
+logging,logwarn,2,0,0,character,1
+logging,namedLevel,-1,0,0,double,1
+logging,namedLevel,0,0,0,character,1
+logging,namedLevel,0,0,1,double,1
+logging,namedLevel.character,-1,0,0,double,1
+logging,namedLevel.character,0,0,0,character,1
+logging,namedLevel.default,-1,0,0,double,1
+logging,namedLevel.default,0,0,0,logical,1
+logging,namedLevel.numeric,-1,0,0,double,1
+logging,namedLevel.numeric,0,0,0,double,1
+logging,removeHandler,-1,0,0,list<any>,1
+logging,removeHandler,0,0,0,character,1
+logging,removeHandler,0,0,1,class<`function`>,1
+logging,removeHandler,-1,1,0,list<any>,1
+logging,removeHandler,0,1,0,character,1
+logging,removeHandler,0,1,1,class<`function`>,1
+logging,removeHandler,1,1,0,character,1
+logging,resetMsgComposer,-1,0,0,class<`function`>,1
+logging,resetMsgComposer,0,0,0,character,1
+logging,setLevel,-1,0,0,any,1
+logging,setLevel,0,0,0,character,1
+logging,setLevel,0,0,1,double,1
+logging,setLevel,1,0,0,character,1
+logging,setLevel,1,0,1,environment,1
+logging,setLevel,1,0,2,null,1
+logging,setMsgComposer,-1,0,0,any,1
+logging,setMsgComposer,0,0,0,class<`function`>,1
+logging,setMsgComposer,1,0,0,character,1
+logging,updateOptions,-1,0,0,null,1
+logging,updateOptions,0,0,0,character,1
+logging,updateOptions,0,0,1,class<`Logger`>,1
+logging,updateOptions,1,0,0,...,1
+logging,updateOptions.character,-1,0,0,null,1
+logging,updateOptions.character,0,0,0,character,1
+logging,updateOptions.character,1,0,0,...,1
+logging,updateOptions.environment,-1,0,0,null,1
+logging,updateOptions.environment,0,0,0,class<`Logger`>,1
+logging,updateOptions.environment,0,0,1,environment,1
+logging,updateOptions.environment,1,0,0,...,1
+logging,updateOptions.Logger,-1,0,0,null,1
+logging,updateOptions.Logger,0,0,0,class<`Logger`>,1
+logging,updateOptions.Logger,1,0,0,...,1
+logspline,dlogspline,-1,0,0,double[],1
+logspline,dlogspline,0,0,0,double[],1
+logspline,dlogspline,1,0,0,class<`logspline`>,1
+logspline,doldlogspline,-1,0,0,double[],1
+logspline,doldlogspline,0,0,0,double[],1
+logspline,doldlogspline,1,0,0,class<`oldlogspline`>,1
+logspline,logspline,-1,0,0,class<`logspline`>,1
+logspline,logspline,0,0,0,double[],1
+logspline,logspline,1,0,0,any,1
+logspline,logspline,2,0,0,any,1
+logspline,logspline,3,0,0,double,1
+logspline,logspline,4,0,0,any,1
+logspline,logspline,5,0,0,double,1
+logspline,logspline,6,0,0,double,1
+logspline,logspline,7,0,0,logical,1
+logspline,logspline,8,0,0,double,1
+logspline,logspline,9,0,0,double,1
+logspline,oldlogspline,-1,0,0,class<`oldlogspline`>,1
+logspline,oldlogspline,0,0,0,double[],1
+logspline,oldlogspline,1,0,0,any,1
+logspline,oldlogspline,2,0,0,any,1
+logspline,oldlogspline,3,0,0,any,1
+logspline,oldlogspline,4,0,0,any,1
+logspline,oldlogspline,5,0,0,any,1
+logspline,oldlogspline,6,0,0,any,1
+logspline,oldlogspline,7,0,0,any,1
+logspline,oldlogspline,8,0,0,any,1
+logspline,oldlogspline,9,0,0,logical,1
+logspline,oldlogspline.to.logspline,-1,0,0,class<`logspline`>,1
+logspline,oldlogspline.to.logspline,0,0,0,class<`oldlogspline`>,1
+logspline,oldlogspline.to.logspline,1,0,0,any,1
+logspline,plogspline,-1,0,0,double[],1
+logspline,plogspline,0,0,0,double[],1
+logspline,plogspline,1,0,0,class<`logspline`>,1
+logspline,plot.logspline,-1,0,0,null,1
+logspline,plot.logspline,0,0,0,class<`logspline`>,1
+logspline,plot.logspline,1,0,0,double,1
+logspline,plot.logspline,2,0,0,character,1
+logspline,plot.logspline,3,0,0,logical,1
+logspline,plot.logspline,4,0,0,any,1
+logspline,plot.logspline,5,0,0,character,1
+logspline,plot.logspline,6,0,0,character,1
+logspline,plot.logspline,7,0,0,character,1
+logspline,plot.logspline,8,0,0,...,1
+logspline,plot.oldlogspline,-1,0,0,null,1
+logspline,plot.oldlogspline,0,0,0,class<`oldlogspline`>,1
+logspline,plot.oldlogspline,1,0,0,double,1
+logspline,plot.oldlogspline,2,0,0,character,1
+logspline,plot.oldlogspline,3,0,0,any,1
+logspline,plot.oldlogspline,4,0,0,character,1
+logspline,plot.oldlogspline,5,0,0,character,1
+logspline,plot.oldlogspline,6,0,0,character,1
+logspline,plot.oldlogspline,7,0,0,logical,1
+logspline,plot.oldlogspline,8,0,0,...,1
+logspline,poldlogspline,-1,0,0,double[],1
+logspline,poldlogspline,0,0,0,double[],1
+logspline,poldlogspline,1,0,0,class<`oldlogspline`>,1
+logspline,qlogspline,-1,0,0,double[],1
+logspline,qlogspline,0,0,0,double[],1
+logspline,qlogspline,1,0,0,class<`logspline`>,1
+logspline,qoldlogspline,-1,0,0,double[],1
+logspline,qoldlogspline,0,0,0,double[],1
+logspline,qoldlogspline,1,0,0,class<`oldlogspline`>,1
+logspline,rlogspline,-1,0,0,double[],1
+logspline,rlogspline,0,0,0,double,1
+logspline,rlogspline,1,0,0,class<`logspline`>,1
+logspline,roldlogspline,-1,0,0,double[],1
+logspline,roldlogspline,0,0,0,double,1
+logspline,roldlogspline,1,0,0,class<`oldlogspline`>,1
+logspline,summary.logspline,-1,0,0,null,1
+logspline,summary.logspline,0,0,0,class<`logspline`>,1
+logspline,summary.logspline,1,0,0,...,1
+logspline,summary.oldlogspline,-1,0,0,null,1
+logspline,summary.oldlogspline,0,0,0,class<`oldlogspline`>,1
+logspline,summary.oldlogspline,1,0,0,...,1
+logspline,unstrip,-1,0,0,class<`matrix`>,1
+logspline,unstrip,-1,0,1,double[],1
+logspline,unstrip,0,0,0,class<`data.frame`>,1
+logspline,unstrip,0,0,1,class<`ts`>,1
+logspline,unstrip,0,0,2,double[],1
+longitudinalData,adjustGraph3d,-1,0,0,null,1
+longitudinalData,adjustGraph3d,0,0,0,character,1
+longitudinalData,adjustGraph3d,1,0,0,character,1
+longitudinalData,bisector,-1,0,0,double[],1
+longitudinalData,bisector,0,0,0,integer,1
+longitudinalData,bisector,1,0,0,double,1
+longitudinalData,bisector,2,0,0,integer,1
+longitudinalData,bisector,3,0,0,double,1
+longitudinalData,bisector,4,0,0,double,1
+longitudinalData,bisector,5,0,0,double,1
+longitudinalData,calculTrajMean,-1,0,0,class<`matrix`>,1
+longitudinalData,calculTrajMean,0,0,0,class<`matrix`>,1
+longitudinalData,calculTrajMean,1,0,0,class<`factor`>,1
+longitudinalData,calculTrajMean,2,0,0,class<`function`>,1
+longitudinalData,calculTrajMean3d,-1,0,0,class<`array`>,1
+longitudinalData,calculTrajMean3d,0,0,0,class<`array`>,1
+longitudinalData,calculTrajMean3d,1,0,0,class<`factor`>,1
+longitudinalData,calculTrajMean3d,2,0,0,class<`function`>,1
+longitudinalData,calculTrajMeanPoint,-1,0,0,class<`matrix`>,1
+longitudinalData,calculTrajMeanPoint,0,0,0,class<`matrix`>,1
+longitudinalData,calculTrajMeanPoint,1,0,0,double,1
+longitudinalData,canonicalizeAndMergeScene,-1,0,0,class<`Triangles3D`>,1
+longitudinalData,canonicalizeAndMergeScene,0,0,0,class<`Triangles3D`>,1
+longitudinalData,canonicalizeAndMergeScene,1,0,0,...,1
+longitudinalData,colorScene,-1,0,0,class<`Triangles3D`>,1
+longitudinalData,colorScene,0,0,0,class<`Triangles3D`>,1
+longitudinalData,colorTriangles,-1,0,0,class<`Triangles3D`>,1
+longitudinalData,colorTriangles,0,0,0,class<`Triangles3D`>,1
+longitudinalData,distFrechet,-1,0,0,double,1
+longitudinalData,distFrechet,0,0,0,integer[],1
+longitudinalData,distFrechet,1,0,0,double[],1
+longitudinalData,distFrechet,2,0,0,integer[],1
+longitudinalData,distFrechet,3,0,0,double[],1
+longitudinalData,distFrechet,4,0,0,double,1
+longitudinalData,distFrechet,5,0,0,character,1
+longitudinalData,expandParLongData,-1,0,0,class<`ParLongData`>,1
+longitudinalData,expandParLongData,0,0,0,class<`ParLongData`>,1
+longitudinalData,expandParLongData,1,0,0,integer,1
+longitudinalData,expandParLongData,-1,1,0,class<`ParLongData`>,1
+longitudinalData,expandParLongData,0,1,0,class<`ParLongData`>,1
+longitudinalData,expandParLongData,1,1,0,class<`Partition`>,1
+longitudinalData,expandParLongData,-1,2,0,class<`ParLongData`>,1
+longitudinalData,expandParLongData,0,2,0,class<`ParLongData`>,1
+longitudinalData,expandParLongData,1,2,0,double,1
+longitudinalData,expandParLongData,-1,3,0,class<`ParLongData`>,1
+longitudinalData,expandParLongData,0,3,0,class<`ParLongData`>,1
+longitudinalData,expandParLongData,1,3,0,class<`Partition`>,1
+longitudinalData,expandParLongData,1,3,1,double,1
+longitudinalData,imputation,-1,0,0,class<`matrix`>,1
+longitudinalData,imputation,0,0,0,class<`matrix`>,1
+longitudinalData,imputation,1,0,0,character,1
+longitudinalData,imputation,2,0,0,character,1
+longitudinalData,imputation,2,0,1,null,1
+longitudinalData,imputation,3,0,0,character,1
+longitudinalData,imputation,3,0,1,null,1
+longitudinalData,imputation,-1,1,0,class<`matrix`>,1
+longitudinalData,imputation,0,1,0,class<`matrix`>,1
+longitudinalData,imputation,1,1,0,character,1
+longitudinalData,imputation,2,1,0,character,1
+longitudinalData,imputation,2,1,1,null,1
+longitudinalData,imputation,3,1,0,character,1
+longitudinalData,imputation,3,1,1,null,1
+longitudinalData,imput_copyMean_bisector,-1,0,0,class<`matrix`>,1
+longitudinalData,imput_copyMean_bisector,0,0,0,class<`matrix`>,1
+longitudinalData,imput_copyMean_global,-1,0,0,class<`matrix`>,1
+longitudinalData,imput_copyMean_global,0,0,0,class<`matrix`>,1
+longitudinalData,imput_copyMean_local,-1,0,0,class<`matrix`>,1
+longitudinalData,imput_copyMean_local,0,0,0,class<`matrix`>,1
+longitudinalData,imput_copyMean_locf,-1,0,0,class<`matrix`>,1
+longitudinalData,imput_copyMean_locf,0,0,0,class<`matrix`>,1
+longitudinalData,imput_copyMean_middleTraj,-1,0,0,^double[],1
+longitudinalData,imput_copyMean_middleTraj,0,0,0,^double[],1
+longitudinalData,imput_copyMean_middleTraj,1,0,0,any,1
+longitudinalData,imput_copyMean_middleTrajAux,-1,0,0,double[],1
+longitudinalData,imput_copyMean_middleTrajAux,0,0,0,^double[],1
+longitudinalData,imput_copyMean_middleTrajAux,1,0,0,any,1
+longitudinalData,imput_crossHotDeck,-1,0,0,class<`matrix`>,1
+longitudinalData,imput_crossHotDeck,0,0,0,class<`matrix`>,1
+longitudinalData,imput_crossHotDeck,1,0,0,logical,1
+longitudinalData,imput_crossMean,-1,0,0,class<`matrix`>,1
+longitudinalData,imput_crossMean,0,0,0,class<`matrix`>,1
+longitudinalData,imput_crossMean,1,0,0,logical,1
+longitudinalData,imput_crossMedian,-1,0,0,class<`matrix`>,1
+longitudinalData,imput_crossMedian,0,0,0,class<`matrix`>,1
+longitudinalData,imput_crossMedian,1,0,0,logical,1
+longitudinalData,imput_linearInterpol_bisector,-1,0,0,class<`matrix`>,1
+longitudinalData,imput_linearInterpol_bisector,0,0,0,class<`matrix`>,1
+longitudinalData,imput_linearInterpol_global,-1,0,0,class<`matrix`>,1
+longitudinalData,imput_linearInterpol_global,0,0,0,class<`matrix`>,1
+longitudinalData,imput_linearInterpol_local,-1,0,0,class<`matrix`>,1
+longitudinalData,imput_linearInterpol_local,0,0,0,class<`matrix`>,1
+longitudinalData,imput_linearInterpol_locf,-1,0,0,class<`matrix`>,1
+longitudinalData,imput_linearInterpol_locf,0,0,0,class<`matrix`>,1
+longitudinalData,imput_linearInterpol_middleTraj,-1,0,0,^double[],1
+longitudinalData,imput_linearInterpol_middleTraj,0,0,0,^double[],1
+longitudinalData,imput_linearInterpol_middleTrajAux,-1,0,0,double[],1
+longitudinalData,imput_linearInterpol_middleTrajAux,0,0,0,^double[],1
+longitudinalData,imput_locf,-1,0,0,class<`matrix`>,1
+longitudinalData,imput_locf,0,0,0,class<`matrix`>,1
+longitudinalData,imput_locf_traj,-1,0,0,double[],1
+longitudinalData,imput_locf_traj,0,0,0,^double[],1
+longitudinalData,imput_nocb,-1,0,0,class<`matrix`>,1
+longitudinalData,imput_nocb,0,0,0,class<`matrix`>,1
+longitudinalData,imput_spline,-1,0,0,class<`matrix`>,1
+longitudinalData,imput_spline,0,0,0,class<`matrix`>,1
+longitudinalData,imput_trajHotDeck,-1,0,0,class<`matrix`>,1
+longitudinalData,imput_trajHotDeck,0,0,0,class<`matrix`>,1
+longitudinalData,imput_trajMean,-1,0,0,class<`matrix`>,1
+longitudinalData,imput_trajMean,0,0,0,class<`matrix`>,1
+longitudinalData,imput_trajMedian,-1,0,0,class<`matrix`>,1
+longitudinalData,imput_trajMedian,0,0,0,class<`matrix`>,1
+longitudinalData,initializePartition,-1,0,0,^double[],1
+longitudinalData,initializePartition,0,0,0,double,1
+longitudinalData,initializePartition,1,0,0,double,1
+longitudinalData,initializePartition,2,0,0,character,1
+longitudinalData,initializePartition,3,0,0,any,1
+longitudinalData,is.Triangles3D,-1,0,0,logical,1
+longitudinalData,is.Triangles3D,0,0,0,class<`Triangles3D`>,1
+longitudinalData,listPartition,-1,0,0,class<`ListPartition`>,1
+longitudinalData,longData,-1,0,0,class<`LongData`>,1
+longitudinalData,longData,0,0,0,class<`data.frame`>,1
+longitudinalData,longData,0,0,1,class<`matrix`>,1
+longitudinalData,longData,1,0,0,any,1
+longitudinalData,longData,2,0,0,any,1
+longitudinalData,longData,3,0,0,any,1
+longitudinalData,longData,4,0,0,any,1
+longitudinalData,longData,5,0,0,any,1
+longitudinalData,longData3d,-1,0,0,class<`LongData3d`>,1
+longitudinalData,longData3d,0,0,0,class<`array`>,1
+longitudinalData,longData3d,0,0,1,class<`data.frame`>,1
+longitudinalData,longData3d,1,0,0,any,1
+longitudinalData,longData3d,2,0,0,any,1
+longitudinalData,longData3d,3,0,0,any,1
+longitudinalData,longData3d,4,0,0,any,1
+longitudinalData,longData3d,5,0,0,any,1
+longitudinalData,longDataFrom3d,-1,0,0,class<`LongData`>,1
+longitudinalData,longDataFrom3d,0,0,0,class<`LongData3d`>,1
+longitudinalData,longDataFrom3d,1,0,0,character,1
+longitudinalData,longDataFrom3d,1,0,1,double,1
+longitudinalData,longDataTo3d,-1,0,0,class<`LongData3d`>,1
+longitudinalData,longDataTo3d,0,0,0,class<`LongData`>,1
+longitudinalData,longToWide,-1,0,0,class<`data.frame`>,1
+longitudinalData,longToWide,-1,0,1,"class<`data.frame`, `groupedData`, `nfGroupedData`, `nfnGroupedData`>",1
+longitudinalData,longToWide,0,0,0,class<`data.frame`>,1
+longitudinalData,longToWide,0,0,1,"class<`data.frame`, `groupedData`, `nfGroupedData`, `nfnGroupedData`>",1
+longitudinalData,makeLatexFile,-1,0,0,null,1
+longitudinalData,makeLatexFile,0,0,0,character,1
+longitudinalData,makeLatexFile,1,0,0,character,1
+longitudinalData,misc3dLine,-1,0,0,class<`data.frame`>,1
+longitudinalData,misc3dLine,0,0,0,double[],1
+longitudinalData,misc3dLine,1,0,0,double[],1
+longitudinalData,misc3dLine,2,0,0,character,1
+longitudinalData,misc3dLine,3,0,0,double,1
+longitudinalData,misc3dLine,4,0,0,double,1
+longitudinalData,misc3dLines,-1,0,0,class<`data.frame`>,1
+longitudinalData,misc3dLines,0,0,0,double[],1
+longitudinalData,misc3dLines,1,0,0,double[],1
+longitudinalData,misc3dLines,2,0,0,double[],1
+longitudinalData,misc3dLines,3,0,0,character,1
+longitudinalData,misc3dLines,4,0,0,double,1
+longitudinalData,misc3dLines,5,0,0,double,1
+longitudinalData,misc3dPave,-1,0,0,class<`data.frame`>,1
+longitudinalData,misc3dPave,0,0,0,double[],1
+longitudinalData,misc3dPave,1,0,0,double[],1
+longitudinalData,misc3dPave,2,0,0,double[],1
+longitudinalData,misc3dPave,3,0,0,double[],1
+longitudinalData,misc3dPave,4,0,0,character,1
+longitudinalData,misc3dPave,5,0,0,double,1
+longitudinalData,misc3dPlan,-1,0,0,class<`data.frame`>,1
+longitudinalData,misc3dPlan,0,0,0,double[],1
+longitudinalData,misc3dPlan,1,0,0,double[],1
+longitudinalData,misc3dPlan,2,0,0,double[],1
+longitudinalData,ordered,-1,0,0,class<`matrix`>,1
+longitudinalData,ordered,0,0,0,class<`ListPartition`>,1
+longitudinalData,ordered,1,0,0,...,1
+longitudinalData,parLongData,-1,0,0,class<`ParLongData`>,1
+longitudinalData,parLongData,0,0,0,character,1
+longitudinalData,parLongData,1,0,0,character,1
+longitudinalData,parLongData,1,0,1,double,1
+longitudinalData,parLongData,2,0,0,character,1
+longitudinalData,parLongData,3,0,0,double,1
+longitudinalData,parLongData,4,0,0,double,1
+longitudinalData,parLongData,5,0,0,character,1
+longitudinalData,parLongData,6,0,0,character,1
+longitudinalData,parMEAN,-1,0,0,class<`ParLongData`>,1
+longitudinalData,parMEAN,0,0,0,character,1
+longitudinalData,parMEAN,1,0,0,character,1
+longitudinalData,parMEAN,2,0,0,character,1
+longitudinalData,parMEAN,3,0,0,double,1
+longitudinalData,parMEAN,4,0,0,double,1
+longitudinalData,parMEAN,5,0,0,character,1
+longitudinalData,parMEAN,6,0,0,character,1
+longitudinalData,partition,-1,0,0,class<`Partition`>,1
+longitudinalData,partition,0,0,0,character[],1
+longitudinalData,partition,1,0,0,any,1
+longitudinalData,partition,2,0,0,character[],1
+longitudinalData,partition,-1,1,0,class<`Partition`>,1
+longitudinalData,partition,0,1,0,^integer[],1
+longitudinalData,partition,1,1,0,any,1
+longitudinalData,partition,2,1,0,character[],1
+longitudinalData,partition,-1,2,0,class<`Partition`>,1
+longitudinalData,partition,0,2,0,^double[],1
+longitudinalData,partition,1,2,0,any,1
+longitudinalData,partition,2,2,0,character[],1
+longitudinalData,partition,-1,3,0,class<`Partition`>,1
+longitudinalData,partition,0,3,0,integer[],1
+longitudinalData,partition,1,3,0,class<`matrix`>,1
+longitudinalData,partition,2,3,0,character[],1
+longitudinalData,partition,-1,4,0,any,1
+longitudinalData,partition,0,4,0,any,1
+longitudinalData,partition,1,4,0,any,1
+longitudinalData,partition,2,4,0,any,1
+longitudinalData,partition,-1,5,0,class<`Partition`>,1
+longitudinalData,partition,0,5,0,any,1
+longitudinalData,partition,1,5,0,any,1
+longitudinalData,partition,2,5,0,any,1
+longitudinalData,partition,-1,6,0,any,1
+longitudinalData,partition,0,6,0,character[],1
+longitudinalData,partition,1,6,0,any,1
+longitudinalData,partition,2,6,0,any,1
+longitudinalData,partition,-1,7,0,class<`Partition`>,1
+longitudinalData,partition,0,7,0,character[],1
+longitudinalData,partition,1,7,0,class<`matrix`>,1
+longitudinalData,partition,2,7,0,character[],1
+longitudinalData,parTRAJ,-1,0,0,class<`ParLongData`>,1
+longitudinalData,parTRAJ,0,0,0,character,1
+longitudinalData,parTRAJ,1,0,0,character,1
+longitudinalData,parTRAJ,2,0,0,character,1
+longitudinalData,parTRAJ,3,0,0,double,1
+longitudinalData,parTRAJ,4,0,0,double,1
+longitudinalData,parTRAJ,5,0,0,character,1
+longitudinalData,parTRAJ,6,0,0,character,1
+longitudinalData,parWindows,-1,0,0,class<`ParWindows`>,1
+longitudinalData,parWindows,0,0,0,double,1
+longitudinalData,parWindows,1,0,0,double,1
+longitudinalData,parWindows,2,0,0,logical,1
+longitudinalData,parWindows,3,0,0,logical,1
+longitudinalData,plot3dPdf,-1,0,0,class<`Triangles3D`>,1
+longitudinalData,plot3dPdf,0,0,0,class<`LongData3d`>,1
+longitudinalData,plot3dPdf,1,0,0,class<`Partition`>,1
+longitudinalData,plot3dPdf,2,0,0,double,1
+longitudinalData,plot3dPdf,3,0,0,double,1
+longitudinalData,plot3dPdf,-1,1,0,class<`Triangles3D`>,1
+longitudinalData,plot3dPdf,0,1,0,class<`LongData3d`>,1
+longitudinalData,plot3dPdf,1,1,0,class<`Partition`>,1
+longitudinalData,plot3dPdf,2,1,0,double,1
+longitudinalData,plot3dPdf,3,1,0,double,1
+longitudinalData,plotAllCriterion,-1,0,0,null,1
+longitudinalData,plotAllCriterion,0,0,0,class<`ListPartition`>,1
+longitudinalData,plotAllCriterion,1,0,0,character[],1
+longitudinalData,plotAllCriterion,2,0,0,logical,1
+longitudinalData,plotAllCriterion,-1,1,0,null,1
+longitudinalData,plotAllCriterion,0,1,0,class<`ListPartition`>,1
+longitudinalData,plotAllCriterion,1,1,0,character[],1
+longitudinalData,plotAllCriterion,2,1,0,logical,1
+longitudinalData,plotCriterion,-1,0,0,null,1
+longitudinalData,plotCriterion,0,0,0,class<`ListPartition`>,1
+longitudinalData,plotCriterion,1,0,0,character,1
+longitudinalData,plotCriterion,2,0,0,double,1
+longitudinalData,plotCriterion,-1,1,0,null,1
+longitudinalData,plotCriterion,0,1,0,class<`ListPartition`>,1
+longitudinalData,plotCriterion,1,1,0,character,1
+longitudinalData,plotCriterion,2,1,0,double,1
+longitudinalData,plotTrajMeans,-1,0,0,null,1
+longitudinalData,plotTrajMeans,0,0,0,class<`LongData`>,1
+longitudinalData,plotTrajMeans,1,0,0,class<`Partition`>,1
+longitudinalData,plotTrajMeans,1,0,1,null,1
+longitudinalData,plotTrajMeans,2,0,0,class<`ParLongData`>,1
+longitudinalData,plotTrajMeans,3,0,0,any,1
+longitudinalData,plotTrajMeans,4,0,0,...,1
+longitudinalData,plotTrajMeans3d,-1,0,0,null,1
+longitudinalData,plotTrajMeans3d,0,0,0,class<`LongData3d`>,1
+longitudinalData,plotTrajMeans3d,1,0,0,class<`Partition`>,1
+longitudinalData,plotTrajMeans3d,1,0,1,null,1
+longitudinalData,plotTrajMeans3d,2,0,0,double,1
+longitudinalData,plotTrajMeans3d,3,0,0,double,1
+longitudinalData,plotTrajMeans3d,4,0,0,class<`ParLongData`>,1
+longitudinalData,plotTrajMeans3d,5,0,0,any,1
+longitudinalData,plotTrajMeans3d,6,0,0,...,1
+longitudinalData,qualityCriterion,-1,0,0,list<double[] | class<`matrix`>>,1
+longitudinalData,qualityCriterion,0,0,0,class<`LongData`>,1
+longitudinalData,qualityCriterion,1,0,0,class<`Partition`>,1
+longitudinalData,qualityCriterion,2,0,0,character,1
+longitudinalData,qualityCriterion,-1,1,0,list<double[] | class<`matrix`>>,1
+longitudinalData,qualityCriterion,0,1,0,class<`matrix`>,1
+longitudinalData,qualityCriterion,1,1,0,double[],1
+longitudinalData,qualityCriterion,2,1,0,character,1
+longitudinalData,qualityCriterion,-1,2,0,list<double[] | class<`matrix`>>,1
+longitudinalData,qualityCriterion,0,2,0,class<`matrix`>,1
+longitudinalData,qualityCriterion,1,2,0,integer[],1
+longitudinalData,qualityCriterion,2,2,0,any,1
+longitudinalData,qualityCriterion,-1,3,0,list<double[] | class<`matrix`>>,1
+longitudinalData,qualityCriterion,0,3,0,class<`array`>,1
+longitudinalData,qualityCriterion,1,3,0,integer[],1
+longitudinalData,qualityCriterion,2,3,0,any,1
+longitudinalData,qualityCriterion,-1,4,0,list<double[] | class<`matrix`>>,1
+longitudinalData,qualityCriterion,0,4,0,class<`array`>,1
+longitudinalData,qualityCriterion,0,4,1,class<`LongData`>,1
+longitudinalData,qualityCriterion,0,4,2,class<`LongData3d`>,1
+longitudinalData,qualityCriterion,0,4,3,class<`matrix`>,1
+longitudinalData,qualityCriterion,1,4,0,class<`Partition`>,1
+longitudinalData,qualityCriterion,1,4,1,double[],1
+longitudinalData,qualityCriterion,2,4,0,any,1
+longitudinalData,qualityCriterion,-1,5,0,list<double[] | class<`matrix`>>,1
+longitudinalData,qualityCriterion,0,5,0,class<`LongData3d`>,1
+longitudinalData,qualityCriterion,1,5,0,class<`Partition`>,1
+longitudinalData,qualityCriterion,2,5,0,character,1
+longitudinalData,regroup,-1,0,0,class<`ListPartition`>,1
+longitudinalData,regroup,0,0,0,class<`ListPartition`>,1
+longitudinalData,restoreRealData,-1,0,0,null,1
+longitudinalData,restoreRealData,0,0,0,class<`LongData3d`>,1
+longitudinalData,restoreRealData,-1,1,0,null,1
+longitudinalData,restoreRealData,0,1,0,class<`LongData3d`>,1
+longitudinalData,saveTrianglesAsASY,-1,0,0,null,1
+longitudinalData,saveTrianglesAsASY,0,0,0,class<`Triangles3D`>,1
+longitudinalData,saveTrianglesAsASY,1,0,0,character,1
+longitudinalData,scale,-1,0,0,class<`matrix`>,1
+longitudinalData,scale,0,0,0,class<`matrix`>,1
+longitudinalData,scale,-1,1,0,null,1
+longitudinalData,scale,0,1,0,class<`LongData3d`>,1
+longitudinalData,scale,1,1,0,double[],1
+longitudinalData,scale,2,1,0,double[],1
+longitudinalData,sdcNA,-1,0,0,double,1
+longitudinalData,sdcNA,0,0,0,double[],1
+longitudinalData,sdNA,-1,0,0,double,1
+longitudinalData,sdNA,0,0,0,^double[],1
+longitudinalData,t2ve,-1,0,0,list<class<`matrix`>>,1
+longitudinalData,t2ve,0,0,0,class<`Triangles3D`>,1
+longitudinalData,varNumAndName,-1,0,0,list<double | character>,1
+longitudinalData,varNumAndName,-1,0,1,list<integer | character>,1
+longitudinalData,varNumAndName,0,0,0,double,1
+longitudinalData,varNumAndName,0,0,1,character,1
+longitudinalData,varNumAndName,1,0,0,character[],1
+longitudinalData,wideToLong,-1,0,0,class<`data.frame`>,1
+longitudinalData,wideToLong,0,0,0,class<`data.frame`>,1
+longitudinalData,wideToLong,1,0,0,double[],1
+longitudinalData,windowsCut,-1,0,0,class<`ParWindows`>,1
+longitudinalData,windowsCut,0,0,0,double,1
+longitudinalData,windowsCut,1,0,0,logical,1
+longitudinalData,windowsCut,2,0,0,logical,1
+loo,adjust_k_wip,-1,0,0,double,1
+loo,adjust_k_wip,0,0,0,double,1
+loo,adjust_k_wip,1,0,0,integer,1
+loo,assert_importance_sampling_method_is_implemented,-1,0,0,null,1
+loo,assert_importance_sampling_method_is_implemented,0,0,0,character,1
+loo,autocovariance,-1,0,0,double[],1
+loo,autocovariance,0,0,0,double[],1
+loo,called_from_loo,-1,0,0,logical,1
+loo,dim.importance_sampling,-1,0,0,integer[],1
+loo,dim.importance_sampling,0,0,0,"class<`importance_sampling`, `list`, `psis`>",1
+loo,dim.importance_sampling,0,0,1,"class<`importance_sampling_loo`, `loo`, `psis_loo`>",1
+loo,dim.importance_sampling,0,0,2,"class<`loo`, `waic`>",1
+loo,dim.psis_loo,-1,0,0,integer[],1
+loo,dim.psis_loo,0,0,0,"class<`importance_sampling`, `list`, `psis`>",1
+loo,dim.psis_loo,0,0,1,"class<`importance_sampling_loo`, `loo`, `psis_loo`>",1
+loo,dim.psis_loo,0,0,2,"class<`loo`, `waic`>",1
+loo,dim.waic,-1,0,0,integer[],1
+loo,dim.waic,0,0,0,"class<`importance_sampling`, `list`, `psis`>",1
+loo,dim.waic,0,0,1,"class<`importance_sampling_loo`, `loo`, `psis_loo`>",1
+loo,dim.waic,0,0,2,"class<`loo`, `waic`>",1
+loo,dirichlet_rng,-1,0,0,class<`matrix`>,1
+loo,dirichlet_rng,0,0,0,double,1
+loo,dirichlet_rng,1,0,0,double[],1
+loo,do_importance_sampling,-1,0,0,"class<`importance_sampling`, `list`, `psis`>",1
+loo,do_importance_sampling,-1,0,1,"class<`importance_sampling`, `list`, `sis`>",1
+loo,do_importance_sampling,-1,0,2,"class<`importance_sampling`, `list`, `tis`>",1
+loo,do_importance_sampling,0,0,0,class<`matrix`>,1
+loo,do_importance_sampling,1,0,0,double[],1
+loo,do_importance_sampling,2,0,0,double,1
+loo,do_importance_sampling,3,0,0,character,1
+loo,.E_fun,-1,0,0,class<`function`>,1
+loo,.E_fun,0,0,0,character,1
+loo,E_loo,-1,0,0,list<class<`matrix`> | null>,1
+loo,E_loo,-1,0,1,list<double[]>,1
+loo,E_loo,-1,0,2,list<double[] | null>,1
+loo,E_loo,0,0,0,"class<`matrix`, `ppd`>",1
+loo,E_loo,1,0,0,"class<`importance_sampling`, `list`, `psis`>",1
+loo,E_loo,2,0,0,...,1
+loo,.E_loo_khat_i,-1,0,0,double,1
+loo,.E_loo_khat_i,0,0,0,double[],1
+loo,.E_loo_khat_i,1,0,0,double[],1
+loo,.E_loo_khat_i,2,0,0,double,1
+loo,E_loo_khat.matrix,-1,0,0,double[],1
+loo,E_loo_khat.matrix,0,0,0,"class<`matrix`, `ppd`>",1
+loo,E_loo_khat.matrix,1,0,0,"class<`importance_sampling`, `list`, `psis`>",1
+loo,E_loo_khat.matrix,2,0,0,class<`matrix`>,1
+loo,E_loo_khat.matrix,3,0,0,...,1
+loo,E_loo.matrix,-1,0,0,list<class<`matrix`> | null>,1
+loo,E_loo.matrix,-1,0,1,list<double[]>,1
+loo,E_loo.matrix,-1,0,2,list<double[] | null>,1
+loo,E_loo.matrix,0,0,0,"class<`matrix`, `ppd`>",1
+loo,E_loo.matrix,1,0,0,"class<`importance_sampling`, `list`, `psis`>",1
+loo,E_loo.matrix,2,0,0,...,1
+loo,E_loo.matrix,3,0,0,character,1
+loo,E_loo.matrix,4,0,0,double[],1
+loo,E_loo.matrix,4,0,1,null,1
+loo,E_loo.matrix,5,0,0,null,1
+loo,E_loo.matrix,5,0,1,class<`matrix`>,1
+loo,enough_tail_samples,-1,0,0,logical,1
+loo,enough_tail_samples,0,0,0,double,1
+loo,enough_tail_samples,1,0,0,double,1
+loo,example_loglik_array,-1,0,0,class<`array`>,1
+loo,example_loglik_matrix,-1,0,0,class<`matrix`>,1
+loo,fft_next_good_size,-1,0,0,integer,1
+loo,fft_next_good_size,0,0,0,integer,1
+loo,find_model_names,-1,0,0,character[],1
+loo,find_model_names,0,0,0,"list<class<`importance_sampling_loo`, `loo`, `psis_loo`>>",1
+loo,.fr,-1,0,0,character[],1
+loo,.fr,-1,0,1,class<`data.frame`>,1
+loo,.fr,-1,0,2,class<`matrix`>,1
+loo,.fr,0,0,0,null,1
+loo,.fr,0,0,1,double[],1
+loo,.fr,0,0,2,class<`data.frame`>,1
+loo,.fr,0,0,3,"class<`compare.loo`, `matrix`>",1
+loo,.fr,0,0,4,class<`matrix`>,1
+loo,.fr,1,0,0,double,1
+loo,gpdfit,-1,0,0,list<double>,1
+loo,gpdfit,0,0,0,double[],1
+loo,gpdfit,1,0,0,logical,1
+loo,gpdfit,2,0,0,double,1
+loo,gpdfit,3,0,0,logical,1
+loo,implemented_is_methods,-1,0,0,character[],1
+loo,importance_sampling.array,-1,0,0,"class<`importance_sampling`, `list`, `psis`>",1
+loo,importance_sampling.array,-1,0,1,"class<`importance_sampling`, `list`, `sis`>",1
+loo,importance_sampling.array,-1,0,2,"class<`importance_sampling`, `list`, `tis`>",1
+loo,importance_sampling.array,0,0,0,class<`array`>,1
+loo,importance_sampling.array,1,0,0,character,1
+loo,importance_sampling.array,2,0,0,...,1
+loo,importance_sampling.array,3,0,0,double[],1
+loo,importance_sampling.array,3,0,1,null,1
+loo,importance_sampling.array,4,0,0,double,1
+loo,importance_sampling_loo_object,-1,0,0,"class<`importance_sampling_loo`, `loo`, `psis_loo`>",1
+loo,importance_sampling_loo_object,0,0,0,class<`matrix`>,1
+loo,importance_sampling_loo_object,1,0,0,list<double[]>,1
+loo,importance_sampling_loo_object,2,0,0,integer[],1
+loo,importance_sampling_loo_object,3,0,0,character,1
+loo,importance_sampling_loo_object,4,0,0,null,1
+loo,importance_sampling.matrix,-1,0,0,"class<`importance_sampling`, `list`, `psis`>",1
+loo,importance_sampling.matrix,0,0,0,class<`matrix`>,1
+loo,importance_sampling.matrix,1,0,0,character,1
+loo,importance_sampling.matrix,2,0,0,...,1
+loo,importance_sampling.matrix,3,0,0,double[],1
+loo,importance_sampling.matrix,3,0,1,null,1
+loo,importance_sampling.matrix,4,0,0,double,1
+loo,importance_sampling_object,-1,0,0,"class<`importance_sampling`, `list`, `psis`>",1
+loo,importance_sampling_object,-1,0,1,"class<`importance_sampling`, `list`, `sis`>",1
+loo,importance_sampling_object,-1,0,2,"class<`importance_sampling`, `list`, `tis`>",1
+loo,importance_sampling_object,0,0,0,class<`matrix`>,1
+loo,importance_sampling_object,1,0,0,double[],1
+loo,importance_sampling_object,2,0,0,double[],1
+loo,importance_sampling_object,3,0,0,double[],1
+loo,importance_sampling_object,4,0,0,character[],1
+loo,is.loo,-1,0,0,logical,1
+loo,is.loo,0,0,0,"class<`importance_sampling_loo`, `loo`, `psis_loo`>",1
+loo,is.loo,0,0,1,"list<class<`importance_sampling_loo`, `loo`, `psis_loo`>>",1
+loo,is.psis,-1,0,0,logical,1
+loo,is.psis,0,0,0,"class<`importance_sampling`, `list`, `psis`>",1
+loo,is.psis_loo,-1,0,0,logical,1
+loo,is.psis_loo,0,0,0,"class<`importance_sampling_loo`, `loo`, `psis_loo`>",1
+loo,k_cut,-1,0,0,class<`factor`>,1
+loo,k_cut,0,0,0,^double[],1
+loo,kfold_split_grouped,-1,0,0,double[],1
+loo,kfold_split_grouped,0,0,0,double,1
+loo,kfold_split_grouped,1,0,0,class<`factor`>,1
+loo,kfold_split_random,-1,0,0,integer[],1
+loo,kfold_split_random,0,0,0,double,1
+loo,kfold_split_random,1,0,0,double,1
+loo,kfold_split_stratified,-1,0,0,integer[],1
+loo,kfold_split_stratified,0,0,0,double,1
+loo,kfold_split_stratified,1,0,0,double[],1
+loo,.k_help,-1,0,0,character,1
+loo,llarray_to_matrix,-1,0,0,class<`matrix`>,1
+loo,llarray_to_matrix,0,0,0,class<`array`>,1
+loo,llmatrix_to_array,-1,0,0,class<`array`>,1
+loo,llmatrix_to_array,0,0,0,class<`matrix`>,1
+loo,llmatrix_to_array,1,0,0,integer[],1
+loo,logMeanExp,-1,0,0,double,1
+loo,logMeanExp,0,0,0,double[],1
+loo,loo,-1,0,0,"class<`importance_sampling_loo`, `loo`, `psis_loo`>",1
+loo,loo,0,0,0,class<`array`>,1
+loo,loo,0,0,1,class<`function`>,1
+loo,loo,0,0,2,class<`matrix`>,1
+loo,loo,0,0,3,"class<`glm`, `lm`, `stanreg`>",1
+loo,loo,1,0,0,...,1
+loo,[[.loo,-1,0,0,null,1
+loo,[[.loo,0,0,0,"class<`importance_sampling_loo`, `loo`, `psis_loo`>",1
+loo,[[.loo,1,0,0,character,1
+loo,[[.loo,2,0,0,logical,1
+loo,$.loo,-1,0,0,class<`matrix`>,1
+loo,$.loo,-1,0,1,list<^double[]>,1
+loo,$.loo,0,0,0,"class<`importance_sampling_loo`, `loo`, `psis_loo`>",1
+loo,$.loo,0,0,1,"class<`loo`, `waic`>",1
+loo,$.loo,1,0,0,character,1
+loo,loo.array,-1,0,0,"class<`importance_sampling_loo`, `loo`, `psis_loo`>",1
+loo,loo.array,0,0,0,class<`array`>,1
+loo,loo.array,1,0,0,...,1
+loo,loo.array,2,0,0,double[],1
+loo,loo.array,2,0,1,null,1
+loo,loo.array,3,0,0,logical,1
+loo,loo.array,4,0,0,double,1
+loo,loo.array,5,0,0,character[],1
+loo,loo_compare,-1,0,0,"class<`compare.loo`, `matrix`>",1
+loo,loo_compare,0,0,0,"class<`importance_sampling_loo`, `loo`, `psis_loo`>",1
+loo,loo_compare,0,0,1,"list<class<`importance_sampling_loo`, `loo`, `psis_loo`>>",1
+loo,loo_compare,1,0,0,...,1
+loo,loo_compare_checks,-1,0,0,null,1
+loo,loo_compare_checks,0,0,0,"list<class<`importance_sampling_loo`, `loo`, `psis_loo`>>",1
+loo,loo_compare.default,-1,0,0,"class<`compare.loo`, `matrix`>",1
+loo,loo_compare.default,0,0,0,"class<`importance_sampling_loo`, `loo`, `psis_loo`>",1
+loo,loo_compare.default,0,0,1,"list<class<`importance_sampling_loo`, `loo`, `psis_loo`>>",1
+loo,loo_compare.default,1,0,0,...,1
+loo,loo_compare_matrix,-1,0,0,class<`matrix`>,1
+loo,loo_compare_matrix,0,0,0,"list<class<`importance_sampling_loo`, `loo`, `psis_loo`>>",1
+loo,loo_compare_order,-1,0,0,integer[],1
+loo,loo_compare_order,0,0,0,"list<class<`importance_sampling_loo`, `loo`, `psis_loo`>>",1
+loo,loo_cores,-1,0,0,double,1
+loo,loo_cores,0,0,0,double,1
+loo,loo.function,-1,0,0,"class<`importance_sampling_loo`, `loo`, `psis_loo`>",1
+loo,loo.function,0,0,0,class<`function`>,1
+loo,loo.function,1,0,0,...,1
+loo,loo.function,2,0,0,class<`data.frame`>,1
+loo,loo.function,3,0,0,list<class<`family`> | class<`matrix`>>,1
+loo,loo.function,3,0,1,list<class<`family`> | class<`matrix`> | double[]>,1
+loo,loo.function,3,0,2,class<`matrix`>,1
+loo,loo.function,4,0,0,double[],1
+loo,loo.function,4,0,1,null,1
+loo,loo.function,5,0,0,logical,1
+loo,loo.function,6,0,0,double,1
+loo,loo.function,7,0,0,character[],1
+loo,.loo_i,-1,0,0,list<class<`matrix`> | null | list<double>>,1
+loo,.loo_i,0,0,0,integer,1
+loo,.loo_i,1,0,0,class<`function`>,1
+loo,.loo_i,2,0,0,...,1
+loo,.loo_i,3,0,0,class<`data.frame`>,1
+loo,.loo_i,4,0,0,class<`matrix`>,1
+loo,.loo_i,5,0,0,double[],1
+loo,.loo_i,5,0,1,null,1
+loo,.loo_i,6,0,0,logical,1
+loo,.loo_i,7,0,0,character,1
+loo,loo_i,-1,0,0,list<class<`matrix`> | null | list<double>>,1
+loo,loo_i,0,0,0,double,1
+loo,loo_i,1,0,0,class<`function`>,1
+loo,loo_i,2,0,0,...,1
+loo,loo_i,3,0,0,class<`data.frame`>,1
+loo,loo_i,4,0,0,class<`matrix`>,1
+loo,loo_i,5,0,0,null,1
+loo,loo_i,6,0,0,character,1
+loo,loo.matrix,-1,0,0,"class<`importance_sampling_loo`, `loo`, `psis_loo`>",1
+loo,loo.matrix,0,0,0,class<`matrix`>,1
+loo,loo.matrix,1,0,0,...,1
+loo,loo.matrix,2,0,0,double[],1
+loo,loo.matrix,2,0,1,null,1
+loo,loo.matrix,3,0,0,logical,1
+loo,loo.matrix,4,0,0,double,1
+loo,loo.matrix,5,0,0,character[],1
+loo,loo_model_weights,-1,0,0,class<`pseudobma_bb_weights`>,1
+loo,loo_model_weights,-1,0,1,class<`pseudobma_weights`>,1
+loo,loo_model_weights,-1,0,2,class<`stacking_weights`>,1
+loo,loo_model_weights,0,0,0,"list<class<`importance_sampling_loo`, `loo`, `psis_loo`>>",1
+loo,loo_model_weights,1,0,0,...,1
+loo,loo_model_weights.default,-1,0,0,class<`pseudobma_bb_weights`>,1
+loo,loo_model_weights.default,-1,0,1,class<`pseudobma_weights`>,1
+loo,loo_model_weights.default,-1,0,2,class<`stacking_weights`>,1
+loo,loo_model_weights.default,0,0,0,"list<class<`importance_sampling_loo`, `loo`, `psis_loo`>>",1
+loo,loo_model_weights.default,1,0,0,...,1
+loo,loo_model_weights.default,2,0,0,character[],1
+loo,loo_model_weights.default,3,0,0,character,1
+loo,loo_model_weights.default,4,0,0,any,1
+loo,loo_model_weights.default,5,0,0,logical,1
+loo,loo_model_weights.default,6,0,0,double,1
+loo,loo_model_weights.default,7,0,0,double,1
+loo,lx,-1,0,0,double[],1
+loo,lx,0,0,0,double[],1
+loo,lx,1,0,0,double[],1
+loo,mcse_elpd,-1,0,0,double[],1
+loo,mcse_elpd,0,0,0,class<`matrix`>,1
+loo,mcse_elpd,1,0,0,class<`matrix`>,1
+loo,mcse_elpd,2,0,0,double[],1
+loo,mcse_elpd,3,0,0,double[],1
+loo,mcse_elpd,4,0,0,double,1
+loo,mcse_loo,-1,0,0,double,1
+loo,mcse_loo,-1,0,1,null,1
+loo,mcse_loo,0,0,0,"class<`importance_sampling_loo`, `loo`, `psis_loo`>",1
+loo,mcse_loo,1,0,0,double,1
+loo,min_n_eff_by_k,-1,0,0,^double[],1
+loo,min_n_eff_by_k,0,0,0,double[],1
+loo,min_n_eff_by_k,1,0,0,class<`factor`>,1
+loo,nlist,-1,0,0,list<double[] | class<`matrix`>>,1
+loo,nlist,-1,0,1,list<double[] | class<`matrix`> | character[]>,1
+loo,nlist,-1,0,2,list<class<`matrix`> | list<double[]>>,1
+loo,nlist,-1,0,3,list<class<`matrix`>>,1
+loo,nlist,-1,0,4,list<double>,1
+loo,nlist,0,0,0,...,1
+loo,n_pareto,-1,0,0,double[],1
+loo,n_pareto,0,0,0,double[],1
+loo,n_pareto,1,0,0,integer,1
+loo,os_is_windows,-1,0,0,logical,1
+loo,parallel_importance_sampling_list,-1,0,0,list<list<class<`matrix`> | null | list<double>>>,1
+loo,parallel_importance_sampling_list,0,0,0,integer,1
+loo,parallel_importance_sampling_list,1,0,0,class<`function`>,1
+loo,parallel_importance_sampling_list,2,0,0,class<`function`>,1
+loo,parallel_importance_sampling_list,3,0,0,class<`data.frame`>,1
+loo,parallel_importance_sampling_list,4,0,0,list<class<`family`> | class<`matrix`>>,1
+loo,parallel_importance_sampling_list,4,0,1,list<class<`family`> | class<`matrix`> | double[]>,1
+loo,parallel_importance_sampling_list,4,0,2,class<`matrix`>,1
+loo,parallel_importance_sampling_list,5,0,0,double[],1
+loo,parallel_importance_sampling_list,6,0,0,logical,1
+loo,parallel_importance_sampling_list,7,0,0,double,1
+loo,pareto_k_ids,-1,0,0,integer[],1
+loo,pareto_k_ids,0,0,0,"class<`importance_sampling_loo`, `loo`, `psis_loo`>",1
+loo,pareto_k_ids,1,0,0,double,1
+loo,pareto_k_table,-1,0,0,"class<`matrix`, `pareto_k_table`>",1
+loo,pareto_k_table,0,0,0,"class<`importance_sampling_loo`, `loo`, `psis_loo`>",1
+loo,pareto_k_values,-1,0,0,^double[],1
+loo,pareto_k_values,0,0,0,"class<`importance_sampling_loo`, `loo`, `psis_loo`>",1
+loo,pareto_k_values,0,0,1,"class<`importance_sampling`, `list`, `psis`>",1
+loo,plot_diagnostic,-1,0,0,null,1
+loo,plot_diagnostic,0,0,0,double[],1
+loo,plot_diagnostic,1,0,0,null,1
+loo,plot_diagnostic,2,0,0,...,1
+loo,plot_diagnostic,3,0,0,any,1
+loo,plot_diagnostic,4,0,0,character,1
+loo,plot.psis,-1,0,0,null,1
+loo,plot.psis,0,0,0,"class<`importance_sampling`, `list`, `psis`>",1
+loo,plot.psis,1,0,0,character[],1
+loo,plot.psis,2,0,0,...,1
+loo,plot.psis,3,0,0,logical,1
+loo,plot.psis,4,0,0,character,1
+loo,plot.psis_loo,-1,0,0,null,1
+loo,plot.psis_loo,0,0,0,"class<`importance_sampling`, `list`, `psis`>",1
+loo,plot.psis_loo,1,0,0,character[],1
+loo,plot.psis_loo,2,0,0,...,1
+loo,plot.psis_loo,3,0,0,any,1
+loo,plot.psis_loo,4,0,0,character,1
+loo,pointwise_loo_calcs,-1,0,0,class<`matrix`>,1
+loo,pointwise_loo_calcs,0,0,0,class<`matrix`>,1
+loo,pointwise_loo_calcs,1,0,0,"class<`importance_sampling`, `list`, `psis`>",1
+loo,prepare_psis_r_eff,-1,0,0,double[],1
+loo,prepare_psis_r_eff,0,0,0,double[],1
+loo,prepare_psis_r_eff,0,0,1,null,1
+loo,prepare_psis_r_eff,1,0,0,integer,1
+loo,print.compare.loo,-1,0,0,"class<`compare.loo`, `matrix`>",1
+loo,print.compare.loo,0,0,0,"class<`compare.loo`, `matrix`>",1
+loo,print.compare.loo,1,0,0,...,1
+loo,print.compare.loo,2,0,0,double,1
+loo,print.compare.loo,3,0,0,logical,1
+loo,print_dims,-1,0,0,null,1
+loo,print_dims,0,0,0,"class<`importance_sampling_loo`, `loo`, `psis_loo`>",1
+loo,print_dims,0,0,1,"class<`loo`, `waic`>",1
+loo,print_dims,1,0,0,...,1
+loo,print_dims.psis_loo,-1,0,0,null,1
+loo,print_dims.psis_loo,0,0,0,"class<`importance_sampling_loo`, `loo`, `psis_loo`>",1
+loo,print_dims.psis_loo,0,0,1,"class<`loo`, `waic`>",1
+loo,print_dims.psis_loo,1,0,0,...,1
+loo,print_dims.waic,-1,0,0,null,1
+loo,print_dims.waic,0,0,0,"class<`importance_sampling_loo`, `loo`, `psis_loo`>",1
+loo,print_dims.waic,0,0,1,"class<`loo`, `waic`>",1
+loo,print_dims.waic,1,0,0,...,1
+loo,print.loo,-1,0,0,"class<`importance_sampling_loo`, `loo`, `psis_loo`>",1
+loo,print.loo,-1,0,1,"class<`loo`, `waic`>",1
+loo,print.loo,0,0,0,"class<`importance_sampling_loo`, `loo`, `psis_loo`>",1
+loo,print.loo,0,0,1,"class<`loo`, `waic`>",1
+loo,print.loo,1,0,0,double,1
+loo,print.loo,2,0,0,...,1
+loo,print_mcse_summary,-1,0,0,null,1
+loo,print_mcse_summary,0,0,0,"class<`importance_sampling_loo`, `loo`, `psis_loo`>",1
+loo,print_mcse_summary,1,0,0,double,1
+loo,print.pareto_k_table,-1,0,0,"class<`matrix`, `pareto_k_table`>",1
+loo,print.pareto_k_table,-1,0,1,null,1
+loo,print.pareto_k_table,0,0,0,"class<`matrix`, `pareto_k_table`>",1
+loo,print.pareto_k_table,1,0,0,any,1
+loo,print.pareto_k_table,2,0,0,...,1
+loo,print.psis_loo,-1,0,0,"class<`importance_sampling_loo`, `loo`, `psis_loo`>",1
+loo,print.psis_loo,0,0,0,"class<`importance_sampling_loo`, `loo`, `psis_loo`>",1
+loo,print.psis_loo,1,0,0,double,1
+loo,print.psis_loo,2,0,0,logical,1
+loo,print.psis_loo,3,0,0,...,1
+loo,print.waic,-1,0,0,"class<`loo`, `waic`>",1
+loo,print.waic,0,0,0,"class<`loo`, `waic`>",1
+loo,print.waic,1,0,0,double,1
+loo,print.waic,2,0,0,...,1
+loo,pseudobma_weights,-1,0,0,class<`pseudobma_bb_weights`>,1
+loo,pseudobma_weights,-1,0,1,class<`pseudobma_weights`>,1
+loo,pseudobma_weights,0,0,0,class<`matrix`>,1
+loo,pseudobma_weights,1,0,0,logical,1
+loo,pseudobma_weights,2,0,0,any,1
+loo,pseudobma_weights,3,0,0,any,1
+loo,psis,-1,0,0,"class<`importance_sampling`, `list`, `psis`>",1
+loo,psis,0,0,0,class<`array`>,1
+loo,psis,0,0,1,class<`matrix`>,1
+loo,psis,1,0,0,...,1
+loo,psis_apply,-1,0,0,class<`matrix`>,1
+loo,psis_apply,-1,0,1,double[],1
+loo,psis_apply,0,0,0,list<list<double[]>>,1
+loo,psis_apply,1,0,0,character,1
+loo,psis_apply,2,0,0,character[],1
+loo,psis_apply,3,0,0,double[],1
+loo,psis.array,-1,0,0,"class<`importance_sampling`, `list`, `psis`>",1
+loo,psis.array,0,0,0,class<`array`>,1
+loo,psis.array,1,0,0,...,1
+loo,psis.array,2,0,0,double[],1
+loo,psis.array,3,0,0,double,1
+loo,psis.matrix,-1,0,0,"class<`importance_sampling`, `list`, `psis`>",1
+loo,psis.matrix,0,0,0,class<`matrix`>,1
+loo,psis.matrix,1,0,0,...,1
+loo,psis.matrix,2,0,0,double[],1
+loo,psis.matrix,3,0,0,double,1
+loo,psis_n_eff,-1,0,0,double[],1
+loo,psis_n_eff,0,0,0,class<`matrix`>,1
+loo,psis_n_eff,1,0,0,...,1
+loo,psis_n_eff.matrix,-1,0,0,double[],1
+loo,psis_n_eff.matrix,0,0,0,class<`matrix`>,1
+loo,psis_n_eff.matrix,1,0,0,double[],1
+loo,psis_n_eff.matrix,2,0,0,...,1
+loo,psis_n_eff_values,-1,0,0,double[],1
+loo,psis_n_eff_values,0,0,0,"class<`importance_sampling_loo`, `loo`, `psis_loo`>",1
+loo,psis_smooth_tail,-1,0,0,list<double[]>,1
+loo,psis_smooth_tail,0,0,0,double[],1
+loo,psis_smooth_tail,1,0,0,double,1
+loo,qgpd,-1,0,0,double[],1
+loo,qgpd,0,0,0,double[],1
+loo,qgpd,1,0,0,double,1
+loo,qgpd,2,0,0,double,1
+loo,relative_eff,-1,0,0,double[],1
+loo,relative_eff,0,0,0,class<`function`>,1
+loo,relative_eff,0,0,1,class<`array`>,1
+loo,relative_eff,0,0,2,"class<`importance_sampling`, `list`, `psis`>",1
+loo,relative_eff,0,0,3,class<`matrix`>,1
+loo,relative_eff,1,0,0,...,1
+loo,relative_eff.array,-1,0,0,double[],1
+loo,relative_eff.array,0,0,0,class<`array`>,1
+loo,relative_eff.array,1,0,0,...,1
+loo,relative_eff.array,2,0,0,double,1
+loo,relative_eff.default,-1,0,0,double,1
+loo,relative_eff.default,0,0,0,double[],1
+loo,relative_eff.default,1,0,0,integer[],1
+loo,relative_eff.default,2,0,0,...,1
+loo,relative_eff.function,-1,0,0,double[],1
+loo,relative_eff.function,0,0,0,class<`function`>,1
+loo,relative_eff.function,1,0,0,integer[],1
+loo,relative_eff.function,2,0,0,...,1
+loo,relative_eff.function,3,0,0,double,1
+loo,relative_eff.function,4,0,0,class<`data.frame`>,1
+loo,relative_eff.function,5,0,0,list<class<`family`> | class<`matrix`>>,1
+loo,relative_eff.function,5,0,1,list<class<`family`> | class<`matrix`> | double[]>,1
+loo,relative_eff.importance_sampling,-1,0,0,double[],1
+loo,relative_eff.importance_sampling,0,0,0,"class<`importance_sampling`, `list`, `psis`>",1
+loo,relative_eff.importance_sampling,1,0,0,...,1
+loo,relative_eff.matrix,-1,0,0,double[],1
+loo,relative_eff.matrix,0,0,0,class<`matrix`>,1
+loo,relative_eff.matrix,1,0,0,integer[],1
+loo,relative_eff.matrix,2,0,0,...,1
+loo,relative_eff.matrix,3,0,0,double,1
+loo,sis,-1,0,0,"class<`importance_sampling`, `list`, `sis`>",1
+loo,sis,0,0,0,class<`array`>,1
+loo,sis,1,0,0,...,1
+loo,sis.array,-1,0,0,"class<`importance_sampling`, `list`, `sis`>",1
+loo,sis.array,0,0,0,class<`array`>,1
+loo,sis.array,1,0,0,...,1
+loo,sis.array,2,0,0,double[],1
+loo,sis.array,3,0,0,double,1
+loo,stacking_weights,-1,0,0,class<`stacking_weights`>,1
+loo,stacking_weights,0,0,0,class<`matrix`>,1
+loo,stacking_weights,1,0,0,character,1
+loo,stacking_weights,2,0,0,list<any>,1
+loo,table_of_estimates,-1,0,0,class<`matrix`>,1
+loo,table_of_estimates,0,0,0,class<`matrix`>,1
+loo,throw_pareto_warnings,-1,0,0,character,1
+loo,throw_pareto_warnings,-1,0,1,null,1
+loo,throw_pareto_warnings,0,0,0,double[],1
+loo,throw_pareto_warnings,1,0,0,double,1
+loo,throw_pareto_warnings,2,0,0,double,1
+loo,throw_pwaic_warnings,-1,0,0,null,1
+loo,throw_pwaic_warnings,0,0,0,double[],1
+loo,throw_pwaic_warnings,1,0,0,double,1
+loo,throw_pwaic_warnings,2,0,0,logical,1
+loo,throw_tail_length_warnings,-1,0,0,double[],1
+loo,throw_tail_length_warnings,0,0,0,double[],1
+loo,tis,-1,0,0,"class<`importance_sampling`, `list`, `tis`>",1
+loo,tis,0,0,0,class<`array`>,1
+loo,tis,1,0,0,...,1
+loo,tis.array,-1,0,0,"class<`importance_sampling`, `list`, `tis`>",1
+loo,tis.array,0,0,0,class<`array`>,1
+loo,tis.array,1,0,0,...,1
+loo,tis.array,2,0,0,double[],1
+loo,tis.array,3,0,0,double,1
+loo,validate_ll,-1,0,0,class<`array`>,1
+loo,validate_ll,-1,0,1,class<`matrix`>,1
+loo,validate_ll,0,0,0,class<`array`>,1
+loo,validate_ll,0,0,1,class<`matrix`>,1
+loo,validate_llfun,-1,0,0,class<`function`>,1
+loo,validate_llfun,0,0,0,class<`function`>,1
+loo,validate_psis_loo_list,-1,0,0,logical,1
+loo,validate_psis_loo_list,0,0,0,"list<class<`importance_sampling_loo`, `loo`, `psis_loo`>>",1
+loo,waic,-1,0,0,"class<`loo`, `waic`>",1
+loo,waic,0,0,0,class<`array`>,1
+loo,waic,0,0,1,class<`matrix`>,1
+loo,waic,0,0,2,"class<`glm`, `lm`, `stanreg`>",1
+loo,waic,1,0,0,...,1
+loo,waic.array,-1,0,0,"class<`loo`, `waic`>",1
+loo,waic.array,0,0,0,class<`array`>,1
+loo,waic.array,1,0,0,...,1
+loo,waic.function,-1,0,0,"class<`loo`, `waic`>",1
+loo,waic.function,0,0,0,class<`function`>,1
+loo,waic.function,1,0,0,...,1
+loo,waic.function,2,0,0,class<`data.frame`>,1
+loo,waic.function,3,0,0,list<class<`family`> | class<`matrix`>>,1
+loo,waic.function,3,0,1,list<class<`family`> | class<`matrix`> | double[]>,1
+loo,waic.matrix,-1,0,0,"class<`loo`, `waic`>",1
+loo,waic.matrix,0,0,0,class<`matrix`>,1
+loo,waic.matrix,1,0,0,...,1
+loo,waic_object,-1,0,0,"class<`loo`, `waic`>",1
+loo,waic_object,0,0,0,class<`matrix`>,1
+loo,waic_object,1,0,0,integer[],1
+loo,.warn,-1,0,0,character,1
+loo,.warn,0,0,0,...,1
+loo,.warn,1,0,0,logical,1
+loo,weights.importance_sampling,-1,0,0,class<`matrix`>,1
+loo,weights.importance_sampling,0,0,0,"class<`importance_sampling`, `list`, `psis`>",1
+loo,weights.importance_sampling,0,0,1,"class<`importance_sampling`, `list`, `sis`>",1
+loo,weights.importance_sampling,0,0,2,"class<`importance_sampling`, `list`, `tis`>",1
+loo,weights.importance_sampling,1,0,0,...,1
+loo,weights.importance_sampling,2,0,0,logical,1
+loo,weights.importance_sampling,3,0,0,logical,1
+loo,.wmean,-1,0,0,double,1
+loo,.wmean,0,0,0,double[],1
+loo,.wmean,1,0,0,double[],1
+loo,.wmean,2,0,0,...,1
+lsa,associate,-1,0,0,double[],1
+lsa,associate,0,0,0,class<`textmatrix`>,1
+lsa,associate,1,0,0,character,1
+lsa,associate,2,0,0,character,1
+lsa,associate,3,0,0,double,1
+lsa,as.textmatrix,-1,0,0,class<`textmatrix`>,1
+lsa,as.textmatrix,0,0,0,class<`LSAspace`>,1
+lsa,cosine,-1,0,0,class<`matrix`>,1
+lsa,cosine,-1,0,1,double[],1
+lsa,cosine,0,0,0,double[],1
+lsa,cosine,0,0,1,class<`matrix`>,1
+lsa,cosine,1,0,0,double[],1
+lsa,cosine,1,0,1,null,1
+lsa,cosine,1,0,2,class<`textmatrix`>,1
+lsa,delTriple,-1,0,0,class<`matrix`>,1
+lsa,delTriple,0,0,0,class<`textmatrix`>,1
+lsa,delTriple,1,0,0,character,1
+lsa,delTriple,2,0,0,character,1
+lsa,delTriple,3,0,0,character,1
+lsa,dimcalc_ndocs,-1,0,0,class<`function`>,1
+lsa,dimcalc_ndocs,0,0,0,any,1
+lsa,dimcalc_ndocs,-1,1,0,double,1
+lsa,dimcalc_ndocs,0,1,0,double[],1
+lsa,dimcalc_raw,-1,0,0,class<`function`>,1
+lsa,dimcalc_share,-1,0,0,double,1
+lsa,dimcalc_share,0,0,0,double[],1
+lsa,dimcalc_share,-1,1,0,class<`function`>,1
+lsa,dimcalc_share,0,1,0,double,1
+lsa,fold_in,-1,0,0,class<`textmatrix`>,1
+lsa,fold_in,0,0,0,class<`textmatrix`>,1
+lsa,fold_in,1,0,0,class<`LSAspace`>,1
+lsa,getSubjectId,-1,0,0,integer,1
+lsa,getSubjectId,0,0,0,class<`textmatrix`>,1
+lsa,getSubjectId,1,0,0,character,1
+lsa,getTriple,-1,0,0,character[],1
+lsa,getTriple,-1,0,1,list<character[]>,1
+lsa,getTriple,-1,0,2,null,1
+lsa,getTriple,0,0,0,class<`textmatrix`>,1
+lsa,getTriple,1,0,0,character,1
+lsa,getTriple,2,0,0,any,1
+lsa,gw_idf,-1,0,0,double[],1
+lsa,gw_idf,0,0,0,class<`matrix`>,1
+lsa,gw_idf,0,0,1,class<`textmatrix`>,1
+lsa,lsa,-1,0,0,class<`LSAspace`>,1
+lsa,lsa,0,0,0,class<`textmatrix`>,1
+lsa,lsa,1,0,0,class<`function`>,1
+lsa,lw_bintf,-1,0,0,class<`matrix`>,1
+lsa,lw_bintf,0,0,0,class<`matrix`>,1
+lsa,lw_bintf,0,0,1,class<`textmatrix`>,1
+lsa,lw_logtf,-1,0,0,class<`matrix`>,1
+lsa,lw_logtf,-1,0,1,class<`textmatrix`>,1
+lsa,lw_logtf,0,0,0,class<`matrix`>,1
+lsa,lw_logtf,0,0,1,class<`textmatrix`>,1
+lsa,print.textmatrix,-1,0,0,class<`textmatrix`>,1
+lsa,print.textmatrix,0,0,0,class<`textmatrix`>,1
+lsa,print.textmatrix,1,0,0,double,1
+lsa,print.textmatrix,2,0,0,double,1
+lsa,print.textmatrix,3,0,0,...,1
+lsa,query,-1,0,0,class<`textmatrix`>,1
+lsa,query,0,0,0,character,1
+lsa,query,1,0,0,character[],1
+lsa,query,2,0,0,logical,1
+lsa,query,3,0,0,character,1
+lsa,setTriple,-1,0,0,class<`factor`>,1
+lsa,setTriple,0,0,0,class<`textmatrix`>,1
+lsa,setTriple,1,0,0,character,1
+lsa,setTriple,2,0,0,character,1
+lsa,setTriple,3,0,0,character,1
+lsa,summary.textmatrix,-1,0,0,class<`summary.textmatrix`>,1
+lsa,summary.textmatrix,0,0,0,class<`textmatrix`>,1
+lsa,summary.textmatrix,1,0,0,...,1
+lsa,textmatrix,-1,0,0,class<`textmatrix`>,1
+lsa,textmatrix,0,0,0,character,1
+lsa,textmatrix,1,0,0,logical,1
+lsa,textmatrix,2,0,0,character,1
+lsa,textmatrix,3,0,0,double,1
+lsa,textmatrix,4,0,0,logical,1
+lsa,textmatrix,5,0,0,double,1
+lsa,textmatrix,6,0,0,logical,1
+lsa,textmatrix,7,0,0,logical,1
+lsa,textmatrix,8,0,0,logical,1
+lsa,textmatrix,9,0,0,character[],1
+lsa,textmatrix,9,0,1,null,1
+lsa,textmatrix,10,0,0,null,1
+lsa,textmatrix,10,0,1,character[],1
+lsa,textmatrix,11,0,0,null,1
+lsa,textmatrix,12,0,0,logical,1
+lsa,textmatrix,13,0,0,logical,1
+ltsa,DHSimulate,-1,0,0,double[],1
+ltsa,DHSimulate,0,0,0,double,1
+ltsa,DHSimulate,1,0,0,double[],1
+ltsa,DHSimulate,2,0,0,logical,1
+ltsa,DHSimulate,3,0,0,any,1
+ltsa,DHSimulate,4,0,0,...,1
+ltsa,DLAcfToAR,-1,0,0,class<`matrix`>,1
+ltsa,DLAcfToAR,-1,0,1,logical,1
+ltsa,DLAcfToAR,0,0,0,double[],1
+ltsa,DLAcfToAR,1,0,0,logical,1
+ltsa,DLAcfToAR,2,0,0,logical,1
+ltsa,DLLoglikelihood,-1,0,0,double,1
+ltsa,DLLoglikelihood,0,0,0,double[],1
+ltsa,DLLoglikelihood,1,0,0,class<`ts`>,1
+ltsa,DLLoglikelihood,1,0,1,double[],1
+ltsa,DLLoglikelihood,2,0,0,logical,1
+ltsa,DLResiduals,-1,0,0,double[],1
+ltsa,DLResiduals,0,0,0,double[],1
+ltsa,DLResiduals,1,0,0,class<`ts`>,1
+ltsa,DLResiduals,1,0,1,double[],1
+ltsa,DLResiduals,2,0,0,logical,1
+ltsa,DLResiduals,3,0,0,logical,1
+ltsa,DLSimulate,-1,0,0,double[],1
+ltsa,DLSimulate,0,0,0,double,1
+ltsa,DLSimulate,1,0,0,double[],1
+ltsa,DLSimulate,2,0,0,logical,1
+ltsa,DLSimulate,3,0,0,class<`function`>,1
+ltsa,DLSimulate,4,0,0,...,1
+ltsa,exactLoglikelihood,-1,0,0,list<double>,1
+ltsa,exactLoglikelihood,0,0,0,double[],1
+ltsa,exactLoglikelihood,1,0,0,class<`ts`>,1
+ltsa,exactLoglikelihood,2,0,0,logical,1
+ltsa,innovationVariance,-1,0,0,double,1
+ltsa,innovationVariance,0,0,0,class<`ts`>,1
+ltsa,innovationVariance,1,0,0,character[],1
+ltsa,innovationVariance,2,0,0,...,1
+ltsa,is.toeplitz,-1,0,0,logical,1
+ltsa,is.toeplitz,0,0,0,class<`matrix`>,1
+ltsa,is.toeplitz,0,0,1,double,1
+ltsa,PredictionVariance,-1,0,0,double[],1
+ltsa,PredictionVariance,0,0,0,double[],1
+ltsa,PredictionVariance,1,0,0,double,1
+ltsa,PredictionVariance,2,0,0,logical,1
+ltsa,SimGLP,-1,0,0,double[],1
+ltsa,SimGLP,0,0,0,double[],1
+ltsa,SimGLP,1,0,0,double[],1
+ltsa,tacvfARMA,-1,0,0,any,1
+ltsa,tacvfARMA,0,0,0,double[],1
+ltsa,tacvfARMA,1,0,0,any,1
+ltsa,tacvfARMA,2,0,0,double,1
+ltsa,tacvfARMA,3,0,0,double,1
+ltsa,ToeplitzInverseUpdate,-1,0,0,class<`matrix`>,1
+ltsa,ToeplitzInverseUpdate,0,0,0,class<`matrix`>,1
+ltsa,ToeplitzInverseUpdate,1,0,0,double[],1
+ltsa,ToeplitzInverseUpdate,2,0,0,double,1
+ltsa,TrenchForecast,-1,0,0,list<class<`matrix`>>,1
+ltsa,TrenchForecast,0,0,0,class<`ts`>,1
+ltsa,TrenchForecast,1,0,0,double[],1
+ltsa,TrenchForecast,2,0,0,double,1
+ltsa,TrenchForecast,3,0,0,double,1
+ltsa,TrenchForecast,4,0,0,double,1
+ltsa,TrenchForecast,5,0,0,logical,1
+ltsa,TrenchInverse,-1,0,0,class<`matrix`>,1
+ltsa,TrenchInverse,0,0,0,class<`matrix`>,1
+ltsa,TrenchLoglikelihood,-1,0,0,double,1
+ltsa,TrenchLoglikelihood,0,0,0,double[],1
+ltsa,TrenchLoglikelihood,1,0,0,class<`ts`>,1
+ltsa,TrenchLoglikelihood,1,0,1,double[],1
+ltsa,TrenchMean,-1,0,0,double,1
+ltsa,TrenchMean,0,0,0,double[],1
+ltsa,TrenchMean,1,0,0,double[],1
+lubridate,%--%,-1,0,0,class<`Interval`>,1
+lubridate,%--%,0,0,0,"class<`POSIXct`, `POSIXt`>",1
+lubridate,%--%,1,0,0,"class<`POSIXct`, `POSIXt`>",1
+lubridate,add_duration_to_date,-1,0,0,class<`Date`>,1
+lubridate,add_duration_to_date,-1,0,1,"class<`POSIXct`, `POSIXt`>",1
+lubridate,add_duration_to_date,0,0,0,class<`Duration`>,1
+lubridate,add_duration_to_date,1,0,0,class<`Date`>,1
+lubridate,add_duration_to_date,1,0,1,"class<`POSIXct`, `POSIXt`>",1
+lubridate,add_duration_to_duration,-1,0,0,class<`Duration`>,1
+lubridate,add_duration_to_duration,0,0,0,class<`Duration`>,1
+lubridate,add_duration_to_duration,1,0,0,class<`Duration`>,1
+lubridate,add_months,-1,0,0,"class<`POSIXlt`, `POSIXt`>",1
+lubridate,add_months,0,0,0,"class<`POSIXlt`, `POSIXt`>",1
+lubridate,add_months,1,0,0,double[],1
+lubridate,add_period_to_date,-1,0,0,class<`Date`>,1
+lubridate,add_period_to_date,-1,0,1,"class<`POSIXct`, `POSIXt`>",1
+lubridate,add_period_to_date,-1,0,2,"class<`POSIXlt`, `POSIXt`>",1
+lubridate,add_period_to_date,0,0,0,class<`Period`>,1
+lubridate,add_period_to_date,1,0,0,class<`Date`>,1
+lubridate,add_period_to_date,1,0,1,"class<`POSIXct`, `POSIXt`>",1
+lubridate,add_period_to_date,1,0,2,"class<`POSIXlt`, `POSIXt`>",1
+lubridate,add_period_to_period,-1,0,0,class<`Period`>,1
+lubridate,add_period_to_period,0,0,0,class<`Period`>,1
+lubridate,add_period_to_period,1,0,0,class<`Period`>,1
+lubridate,.add_truncated,-1,0,0,character[],1
+lubridate,.add_truncated,0,0,0,character,1
+lubridate,.add_truncated,1,0,0,double,1
+lubridate,add_with_rollback,-1,0,0,class<`Date`>,1
+lubridate,add_with_rollback,-1,0,1,"class<`POSIXct`, `POSIXt`>",1
+lubridate,add_with_rollback,0,0,0,class<`Date`>,1
+lubridate,add_with_rollback,0,0,1,"class<`POSIXct`, `POSIXt`>",1
+lubridate,add_with_rollback,1,0,0,class<`Period`>,1
+lubridate,add_with_rollback,2,0,0,logical,1
+lubridate,add_with_rollback,3,0,0,logical,1
+lubridate,adjust_estimate,-1,0,0,double,1
+lubridate,adjust_estimate,0,0,0,double,1
+lubridate,adjust_estimate,1,0,0,class<`Interval`>,1
+lubridate,adjust_estimate,2,0,0,class<`Period`>,1
+lubridate,am,-1,0,0,logical,1
+lubridate,am,0,0,0,class<`Date`>,1
+lubridate,as_date,-1,0,0,class<`Date`>,1
+lubridate,as_date,0,0,0,"class<`POSIXct`, `POSIXt`>",1
+lubridate,as_date,1,0,0,...,1
+lubridate,as_date,-1,1,0,class<`Date`>,1
+lubridate,as_date,0,1,0,"class<`POSIXct`, `POSIXt`>",1
+lubridate,as_date,0,1,1,double,1
+lubridate,as_date,1,1,0,...,1
+lubridate,as_date,-1,2,0,class<`Date`>,1
+lubridate,as_date,0,2,0,double,1
+lubridate,as_date,1,2,0,...,1
+lubridate,as_datetime,-1,0,0,"class<`POSIXct`, `POSIXt`>",1
+lubridate,as_datetime,0,0,0,class<`Date`>,1
+lubridate,as_datetime,1,0,0,...,1
+lubridate,as_datetime,-1,1,0,"class<`POSIXct`, `POSIXt`>",1
+lubridate,as_datetime,0,1,0,class<`Date`>,1
+lubridate,as_datetime,0,1,1,"class<`POSIXct`, `POSIXt`>",1
+lubridate,as_datetime,1,1,0,...,1
+lubridate,as_datetime,-1,2,0,"class<`POSIXct`, `POSIXt`>",1
+lubridate,as_datetime,0,2,0,"class<`POSIXct`, `POSIXt`>",1
+lubridate,as_datetime,1,2,0,...,1
+lubridate,as.duration,-1,0,0,class<`Duration`>,1
+lubridate,as.duration,0,0,0,double,1
+lubridate,as.duration,1,0,0,...,1
+lubridate,as.duration,-1,1,0,class<`Duration`>,1
+lubridate,as.duration,0,1,0,character,1
+lubridate,as.duration,0,1,1,class<`difftime`>,1
+lubridate,as.duration,0,1,2,class<`Duration`>,1
+lubridate,as.duration,0,1,3,class<`Interval`>,1
+lubridate,as.duration,0,1,4,class<`Period`>,1
+lubridate,as.duration,0,1,5,double,1
+lubridate,as.duration,1,1,0,...,1
+lubridate,as.duration,-1,2,0,class<`Duration`>,1
+lubridate,as.duration,0,2,0,class<`Interval`>,1
+lubridate,as.duration,1,2,0,...,1
+lubridate,as.duration,-1,3,0,class<`Duration`>,1
+lubridate,as.duration,0,3,0,class<`Period`>,1
+lubridate,as.duration,1,3,0,...,1
+lubridate,as.duration,-1,4,0,class<`Duration`>,1
+lubridate,as.duration,0,4,0,class<`Duration`>,1
+lubridate,as.duration,1,4,0,...,1
+lubridate,as.duration,-1,5,0,class<`Duration`>,1
+lubridate,as.duration,0,5,0,class<`difftime`>,1
+lubridate,as.duration,1,5,0,...,1
+lubridate,as.duration,-1,6,0,class<`Duration`>,1
+lubridate,as.duration,0,6,0,character,1
+lubridate,as.duration,1,6,0,...,1
+lubridate,as.interval,-1,0,0,class<`Interval`>,1
+lubridate,as.interval,0,0,0,class<`Duration`>,1
+lubridate,as.interval,1,0,0,class<`Date`>,1
+lubridate,as.interval,2,0,0,...,1
+lubridate,as.interval,-1,1,0,class<`Interval`>,1
+lubridate,as.interval,0,1,0,class<`difftime`>,1
+lubridate,as.interval,0,1,1,class<`Duration`>,1
+lubridate,as.interval,0,1,2,class<`Period`>,1
+lubridate,as.interval,0,1,3,double,1
+lubridate,as.interval,1,1,0,class<`Date`>,1
+lubridate,as.interval,2,1,0,...,1
+lubridate,as.interval,-1,2,0,class<`Interval`>,1
+lubridate,as.interval,0,2,0,class<`difftime`>,1
+lubridate,as.interval,1,2,0,class<`Date`>,1
+lubridate,as.interval,2,2,0,...,1
+lubridate,as.interval,-1,3,0,class<`Interval`>,1
+lubridate,as.interval,0,3,0,class<`Period`>,1
+lubridate,as.interval,1,3,0,class<`Date`>,1
+lubridate,as.interval,2,3,0,...,1
+lubridate,as.interval,-1,4,0,class<`Interval`>,1
+lubridate,as.interval,0,4,0,double,1
+lubridate,as.interval,1,4,0,class<`Date`>,1
+lubridate,as.interval,2,4,0,...,1
+lubridate,as.period,-1,0,0,class<`Period`>,1
+lubridate,as.period,0,0,0,character,1
+lubridate,as.period,1,0,0,any,1
+lubridate,as.period,2,0,0,...,1
+lubridate,as.period,-1,1,0,class<`Period`>,1
+lubridate,as.period,0,1,0,character,1
+lubridate,as.period,0,1,1,class<`Interval`>,1
+lubridate,as.period,0,1,2,class<`Period`>,1
+lubridate,as.period,1,1,0,any,1
+lubridate,as.period,2,1,0,...,1
+lubridate,as.period,-1,2,0,class<`Period`>,1
+lubridate,as.period,0,2,0,class<`Interval`>,1
+lubridate,as.period,1,2,0,any,1
+lubridate,as.period,2,2,0,...,1
+lubridate,as_POSIXct,-1,0,0,"class<`POSIXct`, `POSIXt`>",1
+lubridate,as_POSIXct,0,0,0,"class<`POSIXct`, `POSIXt`>",1
+lubridate,as_POSIXct,1,0,0,any,1
+lubridate,.best_formats,-1,0,0,character[],1
+lubridate,.best_formats,-1,0,1,null,1
+lubridate,.best_formats,0,0,0,character[],1
+lubridate,.best_formats,1,0,0,character[],1
+lubridate,.best_formats,2,0,0,character,1
+lubridate,.best_formats,3,0,0,any,1
+lubridate,.best_formats,4,0,0,any,1
+lubridate,ceiling_date,-1,0,0,class<`Date`>,1
+lubridate,ceiling_date,-1,0,1,"class<`POSIXct`, `POSIXt`>",1
+lubridate,ceiling_date,0,0,0,class<`Date`>,1
+lubridate,ceiling_date,0,0,1,"class<`POSIXct`, `POSIXt`>",1
+lubridate,ceiling_date,1,0,0,character,1
+lubridate,ceiling_date,2,0,0,logical,1
+lubridate,ceiling_date,2,0,1,null,1
+lubridate,ceiling_date,3,0,0,any,1
+lubridate,ceil_multi_unit,-1,0,0,double,1
+lubridate,ceil_multi_unit,0,0,0,double,1
+lubridate,ceil_multi_unit,1,0,0,double,1
+lubridate,ceil_multi_unit1,-1,0,0,double,1
+lubridate,ceil_multi_unit1,0,0,0,double,1
+lubridate,ceil_multi_unit1,1,0,0,double,1
+lubridate,C_force_tz,-1,0,0,"class<`POSIXct`, `POSIXt`>",1
+lubridate,C_force_tz,0,0,0,"class<`POSIXct`, `POSIXt`>",1
+lubridate,C_force_tz,1,0,0,character,1
+lubridate,C_force_tz,2,0,0,logical,1
+lubridate,C_force_tzs,-1,0,0,"class<`POSIXct`, `POSIXt`>",1
+lubridate,C_force_tzs,0,0,0,"class<`POSIXct`, `POSIXt`>",1
+lubridate,C_force_tzs,1,0,0,character[],1
+lubridate,C_force_tzs,2,0,0,character,1
+lubridate,C_force_tzs,3,0,0,logical,1
+lubridate,C_local_time,-1,0,0,double[],1
+lubridate,C_local_time,0,0,0,"class<`POSIXct`, `POSIXt`>",1
+lubridate,C_local_time,1,0,0,character[],1
+lubridate,c.POSIXct,-1,0,0,"class<`POSIXct`, `POSIXt`>",1
+lubridate,c.POSIXct,0,0,0,...,1
+lubridate,c.POSIXct,1,0,0,logical,1
+lubridate,C_update_dt,-1,0,0,"class<`POSIXct`, `POSIXt`>",1
+lubridate,C_update_dt,0,0,0,"class<`POSIXct`, `POSIXt`>",1
+lubridate,C_update_dt,1,0,0,double,1
+lubridate,C_update_dt,1,0,1,integer[],1
+lubridate,C_update_dt,2,0,0,double,1
+lubridate,C_update_dt,2,0,1,integer[],1
+lubridate,C_update_dt,3,0,0,integer[],1
+lubridate,C_update_dt,4,0,0,double,1
+lubridate,C_update_dt,5,0,0,integer[],1
+lubridate,C_update_dt,6,0,0,double,1
+lubridate,C_update_dt,7,0,0,double,1
+lubridate,C_update_dt,8,0,0,double[],1
+lubridate,C_update_dt,9,0,0,character,1
+lubridate,C_update_dt,10,0,0,logical,1
+lubridate,C_update_dt,11,0,0,double,1
+lubridate,C_valid_tz,-1,0,0,logical,1
+lubridate,C_valid_tz,0,0,0,character,1
+lubridate,date,-1,0,0,class<`Date`>,1
+lubridate,date,0,0,0,class<`Date`>,1
+lubridate,date,0,0,1,"class<`POSIXct`, `POSIXt`>",1
+lubridate,date<-,-1,0,0,"class<`POSIXct`, `POSIXt`>",1
+lubridate,date<-,0,0,0,"class<`POSIXct`, `POSIXt`>",1
+lubridate,date<-,1,0,0,class<`Date`>,1
+lubridate,date<-,-1,1,0,"class<`POSIXct`, `POSIXt`>",1
+lubridate,date<-,0,1,0,"class<`POSIXct`, `POSIXt`>",1
+lubridate,date<-,1,1,0,class<`Date`>,1
+lubridate,date_decimal,-1,0,0,"class<`POSIXct`, `POSIXt`>",1
+lubridate,date_decimal,0,0,0,double,1
+lubridate,date_decimal,1,0,0,character,1
+lubridate,date.default,-1,0,0,class<`Date`>,1
+lubridate,date.default,0,0,0,class<`Date`>,1
+lubridate,date.default,0,0,1,"class<`POSIXct`, `POSIXt`>",1
+lubridate,date_to_posix,-1,0,0,"class<`POSIXct`, `POSIXt`>",1
+lubridate,date_to_posix,0,0,0,class<`Date`>,1
+lubridate,date_to_posix,1,0,0,character,1
+lubridate,day,-1,0,0,integer[],1
+lubridate,day,0,0,0,class<`Date`>,1
+lubridate,day,0,0,1,"class<`POSIXct`, `POSIXt`>",1
+lubridate,day,0,0,2,"class<`POSIXlt`, `POSIXt`>",1
+lubridate,day<-,-1,0,0,class<`Date`>,1
+lubridate,day<-,-1,0,1,"class<`POSIXct`, `POSIXt`>",1
+lubridate,day<-,0,0,0,class<`Date`>,1
+lubridate,day<-,0,0,1,"class<`POSIXct`, `POSIXt`>",1
+lubridate,day<-,1,0,0,double,1
+lubridate,day<-,-1,1,0,class<`Date`>,1
+lubridate,day<-,0,1,0,class<`Date`>,1
+lubridate,day<-,1,1,0,double,1
+lubridate,day<-,-1,2,0,"class<`POSIXct`, `POSIXt`>",1
+lubridate,day<-,0,2,0,"class<`POSIXct`, `POSIXt`>",1
+lubridate,day<-,1,2,0,double,1
+lubridate,days,-1,0,0,class<`Period`>,1
+lubridate,days,0,0,0,class<`difftime`>,1
+lubridate,days,0,0,1,double[],1
+lubridate,ddays,-1,0,0,class<`Duration`>,1
+lubridate,ddays,0,0,0,double,1
+lubridate,decimal_date,-1,0,0,double,1
+lubridate,decimal_date,0,0,0,class<`Date`>,1
+lubridate,decimal_date.default,-1,0,0,double,1
+lubridate,decimal_date.default,0,0,0,class<`Date`>,1
+lubridate,dhours,-1,0,0,class<`Duration`>,1
+lubridate,dhours,0,0,0,double,1
+lubridate,.difftime_from_num,-1,0,0,class<`difftime`>,1
+lubridate,.difftime_from_num,0,0,0,double[],1
+lubridate,.difftime_from_num,1,0,0,character,1
+lubridate,.difftime_from_pieces,-1,0,0,double,1
+lubridate,.difftime_from_pieces,0,0,0,list<double>,1
+lubridate,divide_duration_by_duration,-1,0,0,double,1
+lubridate,divide_duration_by_duration,0,0,0,class<`Duration`>,1
+lubridate,divide_duration_by_duration,1,0,0,class<`Duration`>,1
+lubridate,divide_interval_by_duration,-1,0,0,double,1
+lubridate,divide_interval_by_duration,0,0,0,class<`Interval`>,1
+lubridate,divide_interval_by_duration,1,0,0,class<`Duration`>,1
+lubridate,divide_interval_by_period,-1,0,0,double,1
+lubridate,divide_interval_by_period,0,0,0,class<`Interval`>,1
+lubridate,divide_interval_by_period,1,0,0,class<`Period`>,1
+lubridate,dminutes,-1,0,0,class<`Duration`>,1
+lubridate,dminutes,0,0,0,double,1
+lubridate,dmy,-1,0,0,class<`Date`>,1
+lubridate,dmy,0,0,0,...,1
+lubridate,dmy,1,0,0,logical,1
+lubridate,dmy,2,0,0,null,1
+lubridate,dmy,3,0,0,character,1
+lubridate,dmy,4,0,0,double,1
+lubridate,dmy_hms,-1,0,0,"class<`POSIXct`, `POSIXt`>",1
+lubridate,dmy_hms,0,0,0,...,1
+lubridate,dmy_hms,1,0,0,logical,1
+lubridate,dmy_hms,2,0,0,character,1
+lubridate,dmy_hms,3,0,0,character,1
+lubridate,dmy_hms,4,0,0,double,1
+lubridate,dseconds,-1,0,0,class<`Duration`>,1
+lubridate,dseconds,0,0,0,double,1
+lubridate,dst,-1,0,0,logical,1
+lubridate,dst,0,0,0,class<`Date`>,1
+lubridate,dst.default,-1,0,0,logical,1
+lubridate,dst.default,0,0,0,class<`Date`>,1
+lubridate,duration,-1,0,0,class<`Duration`>,1
+lubridate,duration,0,0,0,character,1
+lubridate,duration,0,0,1,double,1
+lubridate,duration,0,0,2,null,1
+lubridate,duration,1,0,0,character,1
+lubridate,duration,2,0,0,...,1
+lubridate,.duration_from_num,-1,0,0,class<`Duration`>,1
+lubridate,.duration_from_num,0,0,0,double,1
+lubridate,.duration_from_num,1,0,0,character,1
+lubridate,.duration_from_units,-1,0,0,class<`Duration`>,1
+lubridate,.duration_from_units,0,0,0,list<double>,1
+lubridate,dweeks,-1,0,0,class<`Duration`>,1
+lubridate,dweeks,0,0,0,double,1
+lubridate,dyears,-1,0,0,class<`Duration`>,1
+lubridate,dyears,0,0,0,double,1
+lubridate,.enclose,-1,0,0,character[],1
+lubridate,.enclose,0,0,0,character[],1
+lubridate,.enclosed.na,-1,0,0,logical[],1
+lubridate,.enclosed.na,0,0,0,character[],1
+lubridate,fast_strptime,-1,0,0,"class<`POSIXct`, `POSIXt`>",1
+lubridate,fast_strptime,0,0,0,character[],1
+lubridate,fast_strptime,1,0,0,character,1
+lubridate,fast_strptime,2,0,0,character,1
+lubridate,fast_strptime,3,0,0,logical,1
+lubridate,fast_strptime,4,0,0,integer,1
+lubridate,floor_date,-1,0,0,class<`Date`>,1
+lubridate,floor_date,-1,0,1,"class<`POSIXct`, `POSIXt`>",1
+lubridate,floor_date,0,0,0,class<`Date`>,1
+lubridate,floor_date,0,0,1,"class<`POSIXct`, `POSIXt`>",1
+lubridate,floor_date,1,0,0,character,1
+lubridate,floor_date,2,0,0,any,1
+lubridate,floor_multi_unit,-1,0,0,double,1
+lubridate,floor_multi_unit,0,0,0,double,1
+lubridate,floor_multi_unit,1,0,0,double,1
+lubridate,floor_multi_unit1,-1,0,0,double,1
+lubridate,floor_multi_unit1,0,0,0,double,1
+lubridate,floor_multi_unit1,1,0,0,double,1
+lubridate,force_tz,-1,0,0,class<`Date`>,1
+lubridate,force_tz,-1,0,1,"class<`POSIXct`, `POSIXt`>",1
+lubridate,force_tz,0,0,0,class<`Date`>,1
+lubridate,force_tz,0,0,1,"class<`POSIXct`, `POSIXt`>",1
+lubridate,force_tz,1,0,0,character,1
+lubridate,force_tz,2,0,0,logical,1
+lubridate,force_tzs,-1,0,0,"class<`POSIXct`, `POSIXt`>",1
+lubridate,force_tzs,0,0,0,"class<`POSIXct`, `POSIXt`>",1
+lubridate,force_tzs,1,0,0,character[],1
+lubridate,force_tzs,2,0,0,character,1
+lubridate,force_tzs,3,0,0,logical,1
+lubridate,.get_locale_regs,-1,0,0,list<character[] | list<character[]>>,1
+lubridate,.get_locale_regs,0,0,0,character,1
+lubridate,.get_train_set,-1,0,0,character[],1
+lubridate,.get_train_set,0,0,0,character[],1
+lubridate,guess_formats,-1,0,0,character[],1
+lubridate,guess_formats,-1,0,1,null,1
+lubridate,guess_formats,0,0,0,character[],1
+lubridate,guess_formats,1,0,0,character[],1
+lubridate,guess_formats,2,0,0,character,1
+lubridate,guess_formats,3,0,0,logical,1
+lubridate,guess_formats,4,0,0,logical,1
+lubridate,hm,-1,0,0,class<`Period`>,1
+lubridate,hm,0,0,0,...,1
+lubridate,hm,1,0,0,logical,1
+lubridate,hm,2,0,0,logical,1
+lubridate,hms,-1,0,0,class<`Period`>,1
+lubridate,hms,0,0,0,...,1
+lubridate,hms,1,0,0,logical,1
+lubridate,hms,2,0,0,logical,1
+lubridate,hour,-1,0,0,integer[],1
+lubridate,hour,0,0,0,"class<`POSIXlt`, `POSIXt`>",1
+lubridate,hour,0,0,1,class<`Date`>,1
+lubridate,hour,0,0,2,"class<`POSIXct`, `POSIXt`>",1
+lubridate,hour<-,-1,0,0,"class<`POSIXlt`, `POSIXt`>",1
+lubridate,hour<-,0,0,0,"class<`POSIXlt`, `POSIXt`>",1
+lubridate,hour<-,1,0,0,double,1
+lubridate,hour<-,-1,1,0,"class<`POSIXlt`, `POSIXt`>",1
+lubridate,hour<-,0,1,0,class<`Date`>,1
+lubridate,hour<-,1,1,0,double,1
+lubridate,hour<-,-1,2,0,"class<`POSIXct`, `POSIXt`>",1
+lubridate,hour<-,0,2,0,"class<`POSIXct`, `POSIXt`>",1
+lubridate,hour<-,1,2,0,double,1
+lubridate,hour<-,-1,3,0,"class<`POSIXct`, `POSIXt`>",1
+lubridate,hour<-,-1,3,1,"class<`POSIXlt`, `POSIXt`>",1
+lubridate,hour<-,0,3,0,"class<`POSIXct`, `POSIXt`>",1
+lubridate,hour<-,0,3,1,class<`Date`>,1
+lubridate,hour<-,0,3,2,"class<`POSIXlt`, `POSIXt`>",1
+lubridate,hour<-,1,3,0,double,1
+lubridate,hour.default,-1,0,0,integer[],1
+lubridate,hour.default,0,0,0,"class<`POSIXlt`, `POSIXt`>",1
+lubridate,hour.default,0,0,1,class<`Date`>,1
+lubridate,hour.default,0,0,2,"class<`POSIXct`, `POSIXt`>",1
+lubridate,hours,-1,0,0,class<`Period`>,1
+lubridate,hours,0,0,0,double,1
+lubridate,hours,0,0,1,integer[],1
+lubridate,int_aligns,-1,0,0,logical,1
+lubridate,int_aligns,0,0,0,class<`Interval`>,1
+lubridate,int_aligns,1,0,0,class<`Interval`>,1
+lubridate,int_diff,-1,0,0,class<`Interval`>,1
+lubridate,int_diff,0,0,0,"class<`POSIXct`, `POSIXt`>",1
+lubridate,integer_divide_spans,-1,0,0,double,1
+lubridate,integer_divide_spans,0,0,0,class<`Interval`>,1
+lubridate,integer_divide_spans,1,0,0,class<`Period`>,1
+lubridate,int_end,-1,0,0,"class<`POSIXct`, `POSIXt`>",1
+lubridate,int_end,0,0,0,class<`Interval`>,1
+lubridate,int_end<-,-1,0,0,class<`Interval`>,1
+lubridate,int_end<-,0,0,0,class<`Interval`>,1
+lubridate,int_end<-,1,0,0,class<`Date`>,1
+lubridate,interval,-1,0,0,class<`Interval`>,1
+lubridate,interval,0,0,0,character,1
+lubridate,interval,0,0,1,class<`Date`>,1
+lubridate,interval,0,0,2,"class<`POSIXct`, `POSIXt`>",1
+lubridate,interval,1,0,0,null,1
+lubridate,interval,1,0,1,class<`Date`>,1
+lubridate,interval,1,0,2,"class<`POSIXct`, `POSIXt`>",1
+lubridate,interval,2,0,0,character,1
+lubridate,int_flip,-1,0,0,class<`Interval`>,1
+lubridate,int_flip,0,0,0,class<`Interval`>,1
+lubridate,int_length,-1,0,0,double,1
+lubridate,int_length,0,0,0,class<`Interval`>,1
+lubridate,int_overlaps,-1,0,0,logical,1
+lubridate,int_overlaps,0,0,0,class<`Interval`>,1
+lubridate,int_overlaps,1,0,0,class<`Interval`>,1
+lubridate,int_shift,-1,0,0,class<`Interval`>,1
+lubridate,int_shift,0,0,0,class<`Interval`>,1
+lubridate,int_shift,1,0,0,class<`Duration`>,1
+lubridate,int_standardize,-1,0,0,class<`Interval`>,1
+lubridate,int_standardize,0,0,0,class<`Interval`>,1
+lubridate,int_start,-1,0,0,"class<`POSIXct`, `POSIXt`>",1
+lubridate,int_start,0,0,0,class<`Interval`>,1
+lubridate,int_start<-,-1,0,0,class<`Interval`>,1
+lubridate,int_start<-,0,0,0,class<`Interval`>,1
+lubridate,int_start<-,1,0,0,class<`Date`>,1
+lubridate,.int_to_period,-1,0,0,class<`Period`>,1
+lubridate,.int_to_period,0,0,0,class<`Interval`>,1
+lubridate,is.Date,-1,0,0,logical,1
+lubridate,is.Date,0,0,0,class<`Date`>,1
+lubridate,is.Date,0,0,1,class<`difftime`>,1
+lubridate,is.Date,0,0,2,"class<`POSIXct`, `POSIXt`>",1
+lubridate,is.Date,0,0,3,"class<`POSIXlt`, `POSIXt`>",1
+lubridate,is.difftime,-1,0,0,logical,1
+lubridate,is.difftime,0,0,0,class<`Date`>,1
+lubridate,is.difftime,0,0,1,class<`difftime`>,1
+lubridate,is.duration,-1,0,0,logical,1
+lubridate,is.duration,0,0,0,class<`Date`>,1
+lubridate,is.duration,0,0,1,class<`Duration`>,1
+lubridate,is.instant,-1,0,0,logical,1
+lubridate,is.instant,0,0,0,class<`Date`>,1
+lubridate,is.instant,0,0,1,class<`difftime`>,1
+lubridate,is.instant,0,0,2,class<`Duration`>,1
+lubridate,is.instant,0,0,3,class<`Period`>,1
+lubridate,is.instant,0,0,4,"class<`POSIXct`, `POSIXt`>",1
+lubridate,is.instant,0,0,5,double,1
+lubridate,is.interval,-1,0,0,logical,1
+lubridate,is.interval,0,0,0,class<`Interval`>,1
+lubridate,is.interval,0,0,1,class<`Duration`>,1
+lubridate,is.interval,0,0,2,class<`Period`>,1
+lubridate,is.interval,0,0,3,double[],1
+lubridate,is.period,-1,0,0,logical,1
+lubridate,is.period,0,0,0,class<`Date`>,1
+lubridate,is.period,0,0,1,class<`Period`>,1
+lubridate,is.POSIXct,-1,0,0,logical,1
+lubridate,is.POSIXct,0,0,0,class<`Date`>,1
+lubridate,is.POSIXct,0,0,1,"class<`POSIXct`, `POSIXt`>",1
+lubridate,is.POSIXlt,-1,0,0,logical,1
+lubridate,is.POSIXlt,0,0,0,"class<`POSIXct`, `POSIXt`>",1
+lubridate,is.POSIXt,-1,0,0,logical,1
+lubridate,is.POSIXt,0,0,0,character,1
+lubridate,is.POSIXt,0,0,1,class<`Date`>,1
+lubridate,is.POSIXt,0,0,2,"class<`POSIXct`, `POSIXt`>",1
+lubridate,is.timepoint,-1,0,0,logical,1
+lubridate,is.timepoint,0,0,0,class<`Date`>,1
+lubridate,is.timepoint,0,0,1,class<`difftime`>,1
+lubridate,is.timepoint,0,0,2,class<`Duration`>,1
+lubridate,is.timepoint,0,0,3,class<`Period`>,1
+lubridate,is.timepoint,0,0,4,"class<`POSIXct`, `POSIXt`>",1
+lubridate,is.timepoint,0,0,5,double,1
+lubridate,is.timespan,-1,0,0,logical,1
+lubridate,is.timespan,0,0,0,class<`Date`>,1
+lubridate,is.timespan,0,0,1,class<`Duration`>,1
+lubridate,leap_year,-1,0,0,logical,1
+lubridate,leap_year,0,0,0,class<`Date`>,1
+lubridate,leap_year,0,0,1,double,1
+lubridate,local_time,-1,0,0,class<`difftime`>,1
+lubridate,local_time,0,0,0,"class<`POSIXct`, `POSIXt`>",1
+lubridate,local_time,1,0,0,character[],1
+lubridate,local_time,1,0,1,null,1
+lubridate,local_time,2,0,0,character,1
+lubridate,%m-%,-1,0,0,class<`Date`>,1
+lubridate,%m-%,0,0,0,class<`Date`>,1
+lubridate,%m-%,1,0,0,class<`Period`>,1
+lubridate,%m-%,-1,1,0,class<`Date`>,1
+lubridate,%m-%,0,1,0,class<`Date`>,1
+lubridate,%m-%,1,1,0,class<`Period`>,1
+lubridate,%m+%,-1,0,0,class<`Date`>,1
+lubridate,%m+%,0,0,0,class<`Date`>,1
+lubridate,%m+%,1,0,0,class<`Period`>,1
+lubridate,%m+%,-1,1,0,"class<`POSIXct`, `POSIXt`>",1
+lubridate,%m+%,0,1,0,"class<`POSIXct`, `POSIXt`>",1
+lubridate,%m+%,1,1,0,class<`Period`>,1
+lubridate,%m+%,-1,2,0,class<`Date`>,1
+lubridate,%m+%,-1,2,1,"class<`POSIXct`, `POSIXt`>",1
+lubridate,%m+%,0,2,0,class<`Date`>,1
+lubridate,%m+%,0,2,1,"class<`POSIXct`, `POSIXt`>",1
+lubridate,%m+%,1,2,0,class<`Period`>,1
+lubridate,make_date,-1,0,0,class<`Date`>,1
+lubridate,make_date,0,0,0,double,1
+lubridate,make_date,1,0,0,double,1
+lubridate,make_date,2,0,0,integer,1
+lubridate,make_datetime,-1,0,0,"class<`POSIXct`, `POSIXt`>",1
+lubridate,make_datetime,0,0,0,double,1
+lubridate,make_datetime,1,0,0,double,1
+lubridate,make_datetime,2,0,0,double,1
+lubridate,make_datetime,3,0,0,integer,1
+lubridate,make_datetime,4,0,0,integer,1
+lubridate,make_datetime,5,0,0,double[],1
+lubridate,make_datetime,6,0,0,character,1
+lubridate,make_difftime,-1,0,0,class<`difftime`>,1
+lubridate,make_difftime,0,0,0,double,1
+lubridate,make_difftime,0,0,1,null,1
+lubridate,make_difftime,1,0,0,character,1
+lubridate,make_difftime,2,0,0,...,1
+lubridate,match_lengths,-1,0,0,list<class<`Interval`> | class<`Period`>>,1
+lubridate,match_lengths,0,0,0,class<`Interval`>,1
+lubridate,match_lengths,1,0,0,class<`Period`>,1
+lubridate,mday,-1,0,0,integer[],1
+lubridate,mday,0,0,0,class<`Date`>,1
+lubridate,mday,0,0,1,"class<`POSIXct`, `POSIXt`>",1
+lubridate,mday,0,0,2,"class<`POSIXlt`, `POSIXt`>",1
+lubridate,mday.default,-1,0,0,integer[],1
+lubridate,mday.default,0,0,0,class<`Date`>,1
+lubridate,mday.default,0,0,1,"class<`POSIXct`, `POSIXt`>",1
+lubridate,mday.default,0,0,2,"class<`POSIXlt`, `POSIXt`>",1
+lubridate,mdy,-1,0,0,class<`Date`>,1
+lubridate,mdy,0,0,0,...,1
+lubridate,mdy,1,0,0,logical,1
+lubridate,mdy,2,0,0,null,1
+lubridate,mdy,3,0,0,character,1
+lubridate,mdy,4,0,0,double,1
+lubridate,minute,-1,0,0,integer[],1
+lubridate,minute,0,0,0,"class<`POSIXlt`, `POSIXt`>",1
+lubridate,minute,0,0,1,class<`Date`>,1
+lubridate,minute,0,0,2,"class<`POSIXct`, `POSIXt`>",1
+lubridate,minute<-,-1,0,0,"class<`POSIXct`, `POSIXt`>",1
+lubridate,minute<-,0,0,0,"class<`POSIXct`, `POSIXt`>",1
+lubridate,minute<-,1,0,0,double,1
+lubridate,minute<-,-1,1,0,"class<`POSIXlt`, `POSIXt`>",1
+lubridate,minute<-,0,1,0,"class<`POSIXlt`, `POSIXt`>",1
+lubridate,minute<-,1,1,0,double,1
+lubridate,minute<-,-1,2,0,"class<`POSIXct`, `POSIXt`>",1
+lubridate,minute<-,-1,2,1,"class<`POSIXlt`, `POSIXt`>",1
+lubridate,minute<-,0,2,0,"class<`POSIXct`, `POSIXt`>",1
+lubridate,minute<-,0,2,1,class<`Date`>,1
+lubridate,minute<-,0,2,2,"class<`POSIXlt`, `POSIXt`>",1
+lubridate,minute<-,1,2,0,double,1
+lubridate,minute<-,-1,3,0,"class<`POSIXlt`, `POSIXt`>",1
+lubridate,minute<-,0,3,0,class<`Date`>,1
+lubridate,minute<-,1,3,0,double,1
+lubridate,minute.default,-1,0,0,integer[],1
+lubridate,minute.default,0,0,0,"class<`POSIXlt`, `POSIXt`>",1
+lubridate,minute.default,0,0,1,class<`Date`>,1
+lubridate,minute.default,0,0,2,"class<`POSIXct`, `POSIXt`>",1
+lubridate,minutes,-1,0,0,class<`Period`>,1
+lubridate,minutes,0,0,0,double,1
+lubridate,.mklt,-1,0,0,"class<`POSIXlt`, `POSIXt`>",1
+lubridate,.mklt,0,0,0,list<double>,1
+lubridate,.mklt,1,0,0,character,1
+lubridate,modulo_interval_by_period,-1,0,0,class<`Interval`>,1
+lubridate,modulo_interval_by_period,0,0,0,class<`Interval`>,1
+lubridate,modulo_interval_by_period,1,0,0,class<`Period`>,1
+lubridate,month,-1,0,0,"class<`factor`, `ordered`>",1
+lubridate,month,-1,0,1,double[],1
+lubridate,month,0,0,0,class<`Date`>,1
+lubridate,month,0,0,1,double[],1
+lubridate,month,0,0,2,class<`Period`>,1
+lubridate,month,0,0,3,"class<`POSIXct`, `POSIXt`>",1
+lubridate,month,1,0,0,logical,1
+lubridate,month,2,0,0,any,1
+lubridate,month,3,0,0,any,1
+lubridate,month<-,-1,0,0,class<`Date`>,1
+lubridate,month<-,0,0,0,class<`Date`>,1
+lubridate,month<-,1,0,0,double,1
+lubridate,month<-,-1,1,0,class<`Date`>,1
+lubridate,month<-,0,1,0,class<`Date`>,1
+lubridate,month<-,1,1,0,double,1
+lubridate,month.default,-1,0,0,"class<`factor`, `ordered`>",1
+lubridate,month.default,-1,0,1,double[],1
+lubridate,month.default,0,0,0,class<`Date`>,1
+lubridate,month.default,0,0,1,"class<`POSIXct`, `POSIXt`>",1
+lubridate,month.default,1,0,0,logical,1
+lubridate,month.default,2,0,0,logical,1
+lubridate,month.default,3,0,0,any,1
+lubridate,month.numeric,-1,0,0,"class<`factor`, `ordered`>",1
+lubridate,month.numeric,-1,0,1,double[],1
+lubridate,month.numeric,0,0,0,double[],1
+lubridate,month.numeric,1,0,0,logical,1
+lubridate,month.numeric,2,0,0,any,1
+lubridate,month.numeric,3,0,0,any,1
+lubridate,month.Period,-1,0,0,double[],1
+lubridate,month.Period,0,0,0,class<`Period`>,1
+lubridate,month.Period,1,0,0,logical,1
+lubridate,month.Period,2,0,0,logical,1
+lubridate,month.Period,3,0,0,any,1
+lubridate,months.numeric,-1,0,0,class<`Period`>,1
+lubridate,months.numeric,0,0,0,double,1
+lubridate,months.numeric,0,0,1,integer[],1
+lubridate,months.numeric,1,0,0,any,1
+lubridate,ms,-1,0,0,class<`Period`>,1
+lubridate,ms,0,0,0,...,1
+lubridate,ms,1,0,0,logical,1
+lubridate,ms,2,0,0,logical,1
+lubridate,multiply_duration_by_number,-1,0,0,class<`Duration`>,1
+lubridate,multiply_duration_by_number,0,0,0,class<`Duration`>,1
+lubridate,multiply_duration_by_number,1,0,0,double,1
+lubridate,multiply_duration_by_number,1,0,1,integer[],1
+lubridate,multiply_period_by_number,-1,0,0,class<`Period`>,1
+lubridate,multiply_period_by_number,0,0,0,class<`Period`>,1
+lubridate,multiply_period_by_number,1,0,0,double,1
+lubridate,multiply_period_by_number,1,0,1,integer[],1
+lubridate,now,-1,0,0,"class<`POSIXct`, `POSIXt`>",1
+lubridate,now,0,0,0,character,1
+lubridate,.number_to_interval,-1,0,0,class<`Interval`>,1
+lubridate,.number_to_interval,0,0,0,class<`difftime`>,1
+lubridate,.number_to_interval,0,0,1,class<`Duration`>,1
+lubridate,.number_to_interval,0,0,2,class<`Period`>,1
+lubridate,.number_to_interval,0,0,3,double,1
+lubridate,.number_to_interval,1,0,0,class<`Date`>,1
+lubridate,.number_to_interval,2,0,0,...,1
+lubridate,.num_to_date,-1,0,0,character[],1
+lubridate,.num_to_date,0,0,0,character[],1
+lubridate,.num_to_date,0,0,1,double,1
+lubridate,.parse_date_time,-1,0,0,"class<`POSIXct`, `POSIXt`>",1
+lubridate,.parse_date_time,-1,0,1,"class<`POSIXlt`, `POSIXt`>",1
+lubridate,.parse_date_time,0,0,0,character[],1
+lubridate,.parse_date_time,1,0,0,character[],1
+lubridate,.parse_date_time,2,0,0,character,1
+lubridate,.parse_date_time,3,0,0,any,1
+lubridate,.parse_date_time,4,0,0,any,1
+lubridate,parse_date_time,-1,0,0,"class<`POSIXct`, `POSIXt`>",1
+lubridate,parse_date_time,0,0,0,character[],1
+lubridate,parse_date_time,1,0,0,any,1
+lubridate,parse_date_time,2,0,0,character,1
+lubridate,parse_date_time,3,0,0,double,1
+lubridate,parse_date_time,4,0,0,any,1
+lubridate,parse_date_time,5,0,0,character,1
+lubridate,parse_date_time,6,0,0,any,1
+lubridate,parse_date_time,7,0,0,logical,1
+lubridate,parse_date_time,8,0,0,logical,1
+lubridate,parse_date_time,9,0,0,logical,1
+lubridate,parse_date_time2,-1,0,0,"class<`POSIXct`, `POSIXt`>",1
+lubridate,parse_date_time2,-1,0,1,"class<`POSIXlt`, `POSIXt`>",1
+lubridate,parse_date_time2,0,0,0,character,1
+lubridate,parse_date_time2,1,0,0,character,1
+lubridate,parse_date_time2,2,0,0,character,1
+lubridate,parse_date_time2,3,0,0,logical,1
+lubridate,parse_date_time2,4,0,0,logical,1
+lubridate,parse_date_time2,5,0,0,integer,1
+lubridate,parse_dt,-1,0,0,^double[],1
+lubridate,parse_dt,-1,0,1,null,1
+lubridate,parse_dt,-1,0,2,list<double>,1
+lubridate,parse_dt,0,0,0,character[],1
+lubridate,parse_dt,1,0,0,character,1
+lubridate,parse_dt,2,0,0,logical,1
+lubridate,parse_dt,3,0,0,logical,1
+lubridate,parse_dt,4,0,0,integer,1
+lubridate,.parse_hms,-1,0,0,class<`matrix`>,1
+lubridate,.parse_hms,0,0,0,...,1
+lubridate,.parse_hms,1,0,0,character,1
+lubridate,.parse_hms,2,0,0,logical,1
+lubridate,parse_interval,-1,0,0,class<`Interval`>,1
+lubridate,parse_interval,0,0,0,character,1
+lubridate,parse_interval,1,0,0,character,1
+lubridate,.parse_iso_dt,-1,0,0,"class<`POSIXct`, `POSIXt`>",1
+lubridate,.parse_iso_dt,0,0,0,character[],1
+lubridate,.parse_iso_dt,1,0,0,character,1
+lubridate,parse_period,-1,0,0,class<`Period`>,1
+lubridate,parse_period,0,0,0,character[],1
+lubridate,parse_period_unit,-1,0,0,list<double | character>,1
+lubridate,parse_period_unit,0,0,0,character,1
+lubridate,.parse_xxx,-1,0,0,class<`Date`>,1
+lubridate,.parse_xxx,-1,0,1,"class<`POSIXct`, `POSIXt`>",1
+lubridate,.parse_xxx,0,0,0,...,1
+lubridate,.parse_xxx,1,0,0,character,1
+lubridate,.parse_xxx,2,0,0,any,1
+lubridate,.parse_xxx,3,0,0,null,1
+lubridate,.parse_xxx,3,0,1,character,1
+lubridate,.parse_xxx,4,0,0,character,1
+lubridate,.parse_xxx,5,0,0,double,1
+lubridate,.parse_xxx_hms,-1,0,0,"class<`POSIXct`, `POSIXt`>",1
+lubridate,.parse_xxx_hms,0,0,0,...,1
+lubridate,.parse_xxx_hms,1,0,0,character[],1
+lubridate,.parse_xxx_hms,2,0,0,double,1
+lubridate,.parse_xxx_hms,3,0,0,any,1
+lubridate,.parse_xxx_hms,4,0,0,character,1
+lubridate,.parse_xxx_hms,5,0,0,character,1
+lubridate,period,-1,0,0,class<`Period`>,1
+lubridate,period,0,0,0,character,1
+lubridate,period,0,0,1,double[],1
+lubridate,period,0,0,2,null,1
+lubridate,period,1,0,0,character[],1
+lubridate,period,2,0,0,...,1
+lubridate,.period_from_num,-1,0,0,class<`Period`>,1
+lubridate,.period_from_num,0,0,0,double[],1
+lubridate,.period_from_num,1,0,0,character[],1
+lubridate,.period_from_units,-1,0,0,class<`Period`>,1
+lubridate,.period_from_units,0,0,0,list<class<`difftime`>>,1
+lubridate,.period_from_units,0,0,1,list<double[]>,1
+lubridate,period_to_seconds,-1,0,0,double,1
+lubridate,period_to_seconds,0,0,0,class<`Period`>,1
+lubridate,pm,-1,0,0,logical,1
+lubridate,pm,0,0,0,class<`Date`>,1
+lubridate,pretty_dates,-1,0,0,"class<`POSIXct`, `POSIXt`>",1
+lubridate,pretty_dates,0,0,0,class<`Date`>,1
+lubridate,pretty_dates,1,0,0,double,1
+lubridate,pretty_dates,2,0,0,...,1
+lubridate,pretty_point,-1,0,0,"class<`POSIXct`, `POSIXt`>",1
+lubridate,pretty_point,0,0,0,class<`Date`>,1
+lubridate,pretty_point,1,0,0,character,1
+lubridate,pretty_point,2,0,0,double,1
+lubridate,pretty_point,3,0,0,logical,1
+lubridate,pretty_point,4,0,0,...,1
+lubridate,pretty_unit,-1,0,0,character,1
+lubridate,pretty_unit,0,0,0,class<`difftime`>,1
+lubridate,pretty_unit,1,0,0,...,1
+lubridate,quarter,-1,0,0,double[],1
+lubridate,quarter,0,0,0,class<`Date`>,1
+lubridate,quarter,1,0,0,logical,1
+lubridate,quarter,2,0,0,double,1
+lubridate,.quick_month_add,-1,0,0,class<`Date`>,1
+lubridate,.quick_month_add,-1,0,1,"class<`POSIXct`, `POSIXt`>",1
+lubridate,.quick_month_add,0,0,0,class<`Date`>,1
+lubridate,.quick_month_add,0,0,1,"class<`POSIXct`, `POSIXt`>",1
+lubridate,.quick_month_add,1,0,0,double[],1
+lubridate,reclass_date,-1,0,0,class<`Date`>,1
+lubridate,reclass_date,-1,0,1,"class<`POSIXct`, `POSIXt`>",1
+lubridate,reclass_date,-1,0,2,"class<`POSIXlt`, `POSIXt`>",1
+lubridate,reclass_date,0,0,0,class<`Date`>,1
+lubridate,reclass_date,0,0,1,"class<`POSIXct`, `POSIXt`>",1
+lubridate,reclass_date,0,0,2,"class<`POSIXlt`, `POSIXt`>",1
+lubridate,reclass_date,1,0,0,class<`Date`>,1
+lubridate,reclass_date,1,0,1,"class<`POSIXct`, `POSIXt`>",1
+lubridate,reclass_date,1,0,2,"class<`POSIXlt`, `POSIXt`>",1
+lubridate,reclass_date.Date,-1,0,0,class<`Date`>,1
+lubridate,reclass_date.Date,0,0,0,class<`Date`>,1
+lubridate,reclass_date.Date,0,0,1,"class<`POSIXct`, `POSIXt`>",1
+lubridate,reclass_date.Date,0,0,2,"class<`POSIXlt`, `POSIXt`>",1
+lubridate,reclass_date.Date,1,0,0,class<`Date`>,1
+lubridate,reclass_date_maybe,-1,0,0,class<`Date`>,1
+lubridate,reclass_date_maybe,-1,0,1,"class<`POSIXct`, `POSIXt`>",1
+lubridate,reclass_date_maybe,0,0,0,class<`Date`>,1
+lubridate,reclass_date_maybe,0,0,1,"class<`POSIXct`, `POSIXt`>",1
+lubridate,reclass_date_maybe,0,0,2,"class<`POSIXlt`, `POSIXt`>",1
+lubridate,reclass_date_maybe,1,0,0,class<`Date`>,1
+lubridate,reclass_date_maybe,1,0,1,"class<`POSIXct`, `POSIXt`>",1
+lubridate,reclass_date_maybe,2,0,0,any,1
+lubridate,reclass_date.POSIXct,-1,0,0,"class<`POSIXct`, `POSIXt`>",1
+lubridate,reclass_date.POSIXct,0,0,0,"class<`POSIXct`, `POSIXt`>",1
+lubridate,reclass_date.POSIXct,0,0,1,"class<`POSIXlt`, `POSIXt`>",1
+lubridate,reclass_date.POSIXct,1,0,0,"class<`POSIXct`, `POSIXt`>",1
+lubridate,reclass_date.POSIXlt,-1,0,0,"class<`POSIXlt`, `POSIXt`>",1
+lubridate,reclass_date.POSIXlt,0,0,0,"class<`POSIXct`, `POSIXt`>",1
+lubridate,reclass_date.POSIXlt,0,0,1,"class<`POSIXlt`, `POSIXt`>",1
+lubridate,reclass_date.POSIXlt,1,0,0,"class<`POSIXlt`, `POSIXt`>",1
+lubridate,recognize,-1,0,0,logical,1
+lubridate,recognize,0,0,0,class<`Date`>,1
+lubridate,recognize,0,0,1,double,1
+lubridate,.rep_maybe,-1,0,0,"class<`POSIXct`, `POSIXt`>",1
+lubridate,.rep_maybe,-1,0,1,double[],1
+lubridate,.rep_maybe,0,0,0,"class<`POSIXct`, `POSIXt`>",1
+lubridate,.rep_maybe,0,0,1,double[],1
+lubridate,.rep_maybe,1,0,0,double,1
+lubridate,rollback,-1,0,0,class<`Date`>,1
+lubridate,rollback,-1,0,1,"class<`POSIXct`, `POSIXt`>",1
+lubridate,rollback,0,0,0,class<`Date`>,1
+lubridate,rollback,0,0,1,"class<`POSIXct`, `POSIXt`>",1
+lubridate,rollback,1,0,0,any,1
+lubridate,rollback,2,0,0,any,1
+lubridate,round_date,-1,0,0,"class<`POSIXct`, `POSIXt`>",1
+lubridate,round_date,0,0,0,"class<`POSIXct`, `POSIXt`>",1
+lubridate,round_date,1,0,0,character,1
+lubridate,round_date,2,0,0,any,1
+lubridate,second,-1,0,0,double[],1
+lubridate,second,0,0,0,"class<`POSIXlt`, `POSIXt`>",1
+lubridate,second,0,0,1,class<`Date`>,1
+lubridate,second,0,0,2,"class<`POSIXct`, `POSIXt`>",1
+lubridate,second<-,-1,0,0,"class<`POSIXlt`, `POSIXt`>",1
+lubridate,second<-,0,0,0,"class<`POSIXlt`, `POSIXt`>",1
+lubridate,second<-,1,0,0,double,1
+lubridate,second<-,-1,1,0,"class<`POSIXct`, `POSIXt`>",1
+lubridate,second<-,0,1,0,"class<`POSIXct`, `POSIXt`>",1
+lubridate,second<-,1,1,0,double,1
+lubridate,second<-,-1,2,0,"class<`POSIXlt`, `POSIXt`>",1
+lubridate,second<-,0,2,0,class<`Date`>,1
+lubridate,second<-,1,2,0,double,1
+lubridate,second<-,-1,3,0,"class<`POSIXct`, `POSIXt`>",1
+lubridate,second<-,-1,3,1,"class<`POSIXlt`, `POSIXt`>",1
+lubridate,second<-,0,3,0,"class<`POSIXct`, `POSIXt`>",1
+lubridate,second<-,0,3,1,class<`Date`>,1
+lubridate,second<-,0,3,2,"class<`POSIXlt`, `POSIXt`>",1
+lubridate,second<-,1,3,0,double,1
+lubridate,second.default,-1,0,0,double[],1
+lubridate,second.default,0,0,0,"class<`POSIXlt`, `POSIXt`>",1
+lubridate,second.default,0,0,1,class<`Date`>,1
+lubridate,second.default,0,0,2,"class<`POSIXct`, `POSIXt`>",1
+lubridate,seconds,-1,0,0,class<`Period`>,1
+lubridate,seconds,0,0,0,double,1
+lubridate,seconds_to_unit,-1,0,0,double[],1
+lubridate,seconds_to_unit,0,0,0,double[],1
+lubridate,seconds_to_unit,1,0,0,character,1
+lubridate,.select_formats,-1,0,0,character[],1
+lubridate,.select_formats,0,0,0,integer[],1
+lubridate,.select_formats,1,0,0,logical,1
+lubridate,semester,-1,0,0,double[],1
+lubridate,semester,0,0,0,class<`Date`>,1
+lubridate,semester,1,0,0,logical,1
+lubridate,setdiff,-1,0,0,class<`Interval`>,1
+lubridate,setdiff,0,0,0,class<`Interval`>,1
+lubridate,setdiff,1,0,0,class<`Interval`>,1
+lubridate,.shift_wday_names,-1,0,0,character[],1
+lubridate,.shift_wday_names,0,0,0,character[],1
+lubridate,.shift_wday_names,1,0,0,integer,1
+lubridate,standardise_date_names,-1,0,0,character[],1
+lubridate,standardise_date_names,0,0,0,character[],1
+lubridate,standardise_difftime_names,-1,0,0,character[],1
+lubridate,standardise_difftime_names,0,0,0,character[],1
+lubridate,standardise_period_names,-1,0,0,character,1
+lubridate,standardise_period_names,0,0,0,character,1
+lubridate,.strptime,-1,0,0,"class<`POSIXct`, `POSIXt`>",1
+lubridate,.strptime,-1,0,1,"class<`POSIXlt`, `POSIXt`>",1
+lubridate,.strptime,0,0,0,character[],1
+lubridate,.strptime,1,0,0,character,1
+lubridate,.strptime,2,0,0,character,1
+lubridate,.strptime,3,0,0,any,1
+lubridate,.strptime,4,0,0,any,1
+lubridate,.substitute_formats,-1,0,0,character[],1
+lubridate,.substitute_formats,-1,0,1,null,1
+lubridate,.substitute_formats,0,0,0,character,1
+lubridate,.substitute_formats,1,0,0,character[],1
+lubridate,.substitute_formats,2,0,0,logical,1
+lubridate,time_length,-1,0,0,double,1
+lubridate,time_length,0,0,0,class<`Duration`>,1
+lubridate,time_length,0,0,1,class<`Interval`>,1
+lubridate,time_length,1,0,0,character,1
+lubridate,time_length,-1,1,0,double,1
+lubridate,time_length,0,1,0,class<`Interval`>,1
+lubridate,time_length,1,1,0,character,1
+lubridate,time_length,-1,2,0,double,1
+lubridate,time_length,0,2,0,class<`Duration`>,1
+lubridate,time_length,1,2,0,character,1
+lubridate,today,-1,0,0,class<`Date`>,1
+lubridate,today,0,0,0,character,1
+lubridate,.train_formats,-1,0,0,integer[],1
+lubridate,.train_formats,0,0,0,character[],1
+lubridate,.train_formats,1,0,0,character[],1
+lubridate,.train_formats,2,0,0,any,1
+lubridate,trunc_multi_unit,-1,0,0,"class<`POSIXlt`, `POSIXt`>",1
+lubridate,trunc_multi_unit,0,0,0,"class<`POSIXct`, `POSIXt`>",1
+lubridate,trunc_multi_unit,1,0,0,character,1
+lubridate,trunc_multi_unit,2,0,0,double,1
+lubridate,tz,-1,0,0,character,1
+lubridate,tz,0,0,0,character,1
+lubridate,tz,0,0,1,class<`Date`>,1
+lubridate,tz,0,0,2,"class<`POSIXct`, `POSIXt`>",1
+lubridate,tz,0,0,3,"class<`POSIXlt`, `POSIXt`>",1
+lubridate,tz<-,-1,0,0,class<`Date`>,1
+lubridate,tz<-,0,0,0,class<`Date`>,1
+lubridate,tz<-,1,0,0,character,1
+lubridate,tz.default,-1,0,0,character,1
+lubridate,tz.default,0,0,0,character,1
+lubridate,tz.default,0,0,1,class<`Date`>,1
+lubridate,tz.default,0,0,2,"class<`POSIXct`, `POSIXt`>",1
+lubridate,tz.default,0,0,3,"class<`POSIXlt`, `POSIXt`>",1
+lubridate,.units_within_seconds,-1,0,0,list<double>,1
+lubridate,.units_within_seconds,0,0,0,double,1
+lubridate,.units_within_seconds,1,0,0,character,1
+lubridate,update.Date,-1,0,0,class<`Date`>,1
+lubridate,update.Date,-1,0,1,"class<`POSIXct`, `POSIXt`>",1
+lubridate,update.Date,0,0,0,class<`Date`>,1
+lubridate,update.Date,1,0,0,...,1
+lubridate,update.POSIXt,-1,0,0,"class<`POSIXct`, `POSIXt`>",1
+lubridate,update.POSIXt,-1,0,1,"class<`POSIXlt`, `POSIXt`>",1
+lubridate,update.POSIXt,0,0,0,"class<`POSIXct`, `POSIXt`>",1
+lubridate,update.POSIXt,0,0,1,"class<`POSIXlt`, `POSIXt`>",1
+lubridate,update.POSIXt,1,0,0,...,1
+lubridate,update.POSIXt,2,0,0,logical,1
+lubridate,update.POSIXt,3,0,0,double,1
+lubridate,update.POSIXt,4,0,0,logical,1
+lubridate,update.POSIXt,4,0,1,null,1
+lubridate,wday,-1,0,0,"class<`factor`, `ordered`>",1
+lubridate,wday,-1,0,1,double[],1
+lubridate,wday,0,0,0,class<`Date`>,1
+lubridate,wday,0,0,1,"class<`POSIXct`, `POSIXt`>",1
+lubridate,wday,0,0,2,double[],1
+lubridate,wday,1,0,0,logical,1
+lubridate,wday,2,0,0,any,1
+lubridate,wday,3,0,0,any,1
+lubridate,wday,4,0,0,any,1
+lubridate,wday.default,-1,0,0,"class<`factor`, `ordered`>",1
+lubridate,wday.default,-1,0,1,double[],1
+lubridate,wday.default,0,0,0,class<`Date`>,1
+lubridate,wday.default,0,0,1,"class<`POSIXct`, `POSIXt`>",1
+lubridate,wday.default,1,0,0,logical,1
+lubridate,wday.default,2,0,0,logical,1
+lubridate,wday.default,3,0,0,double,1
+lubridate,wday.default,4,0,0,any,1
+lubridate,wday.numeric,-1,0,0,"class<`factor`, `ordered`>",1
+lubridate,wday.numeric,-1,0,1,double[],1
+lubridate,wday.numeric,0,0,0,double[],1
+lubridate,wday.numeric,1,0,0,logical,1
+lubridate,wday.numeric,2,0,0,any,1
+lubridate,wday.numeric,3,0,0,double,1
+lubridate,wday.numeric,4,0,0,any,1
+lubridate,week,-1,0,0,double,1
+lubridate,week,0,0,0,class<`Date`>,1
+lubridate,week<-,-1,0,0,class<`Date`>,1
+lubridate,week<-,0,0,0,class<`Date`>,1
+lubridate,week<-,1,0,0,double,1
+lubridate,weeks,-1,0,0,class<`Period`>,1
+lubridate,weeks,0,0,0,integer[],1
+lubridate,.within,-1,0,0,logical[],1
+lubridate,.within,0,0,0,"class<`POSIXct`, `POSIXt`>",1
+lubridate,.within,1,0,0,class<`Interval`>,1
+lubridate,%within%,-1,0,0,logical[],1
+lubridate,%within%,0,0,0,class<`Date`>,1
+lubridate,%within%,1,0,0,class<`Interval`>,1
+lubridate,%within%,-1,1,0,logical[],1
+lubridate,%within%,0,1,0,class<`Date`>,1
+lubridate,%within%,0,1,1,"class<`POSIXct`, `POSIXt`>",1
+lubridate,%within%,0,1,2,class<`Interval`>,1
+lubridate,%within%,1,1,0,class<`Interval`>,1
+lubridate,%within%,1,1,1,list<class<`Interval`>>,1
+lubridate,%within%,-1,2,0,logical[],1
+lubridate,%within%,0,2,0,class<`Date`>,1
+lubridate,%within%,1,2,0,list<class<`Interval`>>,1
+lubridate,%within%,-1,3,0,logical,1
+lubridate,%within%,0,3,0,class<`Interval`>,1
+lubridate,%within%,1,3,0,class<`Interval`>,1
+lubridate,%within%,-1,4,0,logical[],1
+lubridate,%within%,0,4,0,"class<`POSIXct`, `POSIXt`>",1
+lubridate,%within%,1,4,0,class<`Interval`>,1
+lubridate,.with_tz,-1,0,0,"class<`POSIXct`, `POSIXt`>",1
+lubridate,.with_tz,0,0,0,"class<`POSIXct`, `POSIXt`>",1
+lubridate,.with_tz,1,0,0,character,1
+lubridate,with_tz,-1,0,0,"class<`POSIXct`, `POSIXt`>",1
+lubridate,with_tz,0,0,0,"class<`POSIXct`, `POSIXt`>",1
+lubridate,with_tz,1,0,0,character,1
+lubridate,yday,-1,0,0,double,1
+lubridate,yday,0,0,0,class<`Date`>,1
+lubridate,yday<-,-1,0,0,class<`Date`>,1
+lubridate,yday<-,0,0,0,class<`Date`>,1
+lubridate,yday<-,1,0,0,double,1
+lubridate,yday.default,-1,0,0,double,1
+lubridate,yday.default,0,0,0,class<`Date`>,1
+lubridate,year,-1,0,0,double[],1
+lubridate,year,0,0,0,class<`Date`>,1
+lubridate,year,0,0,1,class<`Period`>,1
+lubridate,year,0,0,2,"class<`POSIXct`, `POSIXt`>",1
+lubridate,year<-,-1,0,0,class<`Date`>,1
+lubridate,year<-,0,0,0,class<`Date`>,1
+lubridate,year<-,1,0,0,double,1
+lubridate,year<-,-1,1,0,class<`Date`>,1
+lubridate,year<-,0,1,0,class<`Date`>,1
+lubridate,year<-,1,1,0,double,1
+lubridate,year.default,-1,0,0,double[],1
+lubridate,year.default,0,0,0,class<`Date`>,1
+lubridate,year.default,0,0,1,"class<`POSIXct`, `POSIXt`>",1
+lubridate,year.Period,-1,0,0,double[],1
+lubridate,year.Period,0,0,0,class<`Period`>,1
+lubridate,years,-1,0,0,class<`Period`>,1
+lubridate,years,0,0,0,double,1
+lubridate,ymd,-1,0,0,class<`Date`>,1
+lubridate,ymd,-1,0,1,"class<`POSIXct`, `POSIXt`>",1
+lubridate,ymd,0,0,0,...,1
+lubridate,ymd,1,0,0,logical,1
+lubridate,ymd,2,0,0,null,1
+lubridate,ymd,2,0,1,character,1
+lubridate,ymd,3,0,0,character,1
+lubridate,ymd,4,0,0,double,1
+lubridate,ymd_hm,-1,0,0,"class<`POSIXct`, `POSIXt`>",1
+lubridate,ymd_hm,0,0,0,...,1
+lubridate,ymd_hm,1,0,0,logical,1
+lubridate,ymd_hm,2,0,0,character,1
+lubridate,ymd_hm,3,0,0,character,1
+lubridate,ymd_hm,4,0,0,double,1
+lubridate,ymd_hms,-1,0,0,"class<`POSIXct`, `POSIXt`>",1
+lubridate,ymd_hms,0,0,0,...,1
+lubridate,ymd_hms,1,0,0,logical,1
+lubridate,ymd_hms,2,0,0,character,1
+lubridate,ymd_hms,3,0,0,character,1
+lubridate,ymd_hms,4,0,0,double,1
+magic,adiag,-1,0,0,class<`array`>,1
+magic,adiag,-1,0,1,class<`matrix`>,1
+magic,adiag,0,0,0,...,1
+magic,adiag,1,0,0,double,1
+magic,adiag,1,0,1,integer[],1
+magic,adiag,2,0,0,logical,1
+magic,allsubhypercubes,-1,0,0,list<class<`array`>>,1
+magic,allsubhypercubes,-1,0,1,list<class<`matrix`> | class<`array`>>,1
+magic,allsubhypercubes,-1,0,2,list<class<`array`> | class<`matrix`>>,1
+magic,allsubhypercubes,0,0,0,class<`matrix`>,1
+magic,allsubhypercubes,0,0,1,class<`array`>,1
+magic,allsums,-1,0,0,list<class<`matrix`>>,1
+magic,allsums,-1,0,1,list<double[]>,1
+magic,allsums,0,0,0,class<`matrix`>,1
+magic,allsums,1,0,0,class<`function`>,1
+magic,allsums,1,0,1,null,1
+magic,allsums,2,0,0,...,1
+magic,another_incidence,-1,0,0,class<`array`>,1
+magic,another_incidence,0,0,0,class<`array`>,1
+magic,another_latin,-1,0,0,class<`matrix`>,1
+magic,another_latin,0,0,0,class<`matrix`>,1
+magic,apad,-1,0,0,class<`array`>,1
+magic,apad,-1,0,1,class<`matrix`>,1
+magic,apad,-1,0,2,integer[],1
+magic,apad,0,0,0,class<`array`>,1
+magic,apad,0,0,1,class<`matrix`>,1
+magic,apad,0,0,2,integer[],1
+magic,apad,1,0,0,double[],1
+magic,apad,2,0,0,any,1
+magic,apad,3,0,0,character,1
+magic,apad,4,0,0,logical,1
+magic,apldrop,-1,0,0,class<`array`>,1
+magic,apldrop,-1,0,1,class<`matrix`>,1
+magic,apldrop,-1,0,2,list<integer[]>,1
+magic,apldrop,0,0,0,class<`array`>,1
+magic,apldrop,0,0,1,class<`matrix`>,1
+magic,apldrop,1,0,0,double[],1
+magic,apldrop,2,0,0,logical,1
+magic,apldrop<-,-1,0,0,class<`matrix`>,1
+magic,apldrop<-,0,0,0,class<`matrix`>,1
+magic,apldrop<-,1,0,0,double[],1
+magic,apldrop<-,2,0,0,double,1
+magic,apltake,-1,0,0,class<`array`>,1
+magic,apltake,-1,0,1,class<`matrix`>,1
+magic,apltake,-1,0,2,list<integer[]>,1
+magic,apltake,0,0,0,class<`array`>,1
+magic,apltake,0,0,1,class<`matrix`>,1
+magic,apltake,1,0,0,double[],1
+magic,apltake,2,0,0,logical,1
+magic,apltake<-,-1,0,0,class<`matrix`>,1
+magic,apltake<-,0,0,0,class<`matrix`>,1
+magic,apltake<-,1,0,0,double,1
+magic,apltake<-,2,0,0,double,1
+magic,aplus,-1,0,0,class<`matrix`>,1
+magic,aplus,0,0,0,...,1
+magic,arev,-1,0,0,class<`array`>,1
+magic,arev,-1,0,1,class<`matrix`>,1
+magic,arev,0,0,0,class<`array`>,1
+magic,arev,0,0,1,class<`matrix`>,1
+magic,arev,1,0,0,double,1
+magic,arev,1,0,1,integer[],1
+magic,arot,-1,0,0,class<`array`>,1
+magic,arot,0,0,0,class<`array`>,1
+magic,arot,1,0,0,double,1
+magic,arot,2,0,0,double[],1
+magic,arow,-1,0,0,class<`array`>,1
+magic,arow,-1,0,1,class<`matrix`>,1
+magic,arow,0,0,0,class<`array`>,1
+magic,arow,0,0,1,class<`matrix`>,1
+magic,arow,1,0,0,double,1
+magic,ashift,-1,0,0,class<`array`>,1
+magic,ashift,-1,0,1,class<`matrix`>,1
+magic,ashift,0,0,0,class<`array`>,1
+magic,ashift,0,0,1,class<`matrix`>,1
+magic,ashift,1,0,0,double[],1
+magic,ashift,1,0,1,class<`matrix`>,1
+magic,as.standard,-1,0,0,class<`array`>,1
+magic,as.standard,-1,0,1,class<`matrix`>,1
+magic,as.standard,0,0,0,class<`array`>,1
+magic,as.standard,0,0,1,class<`matrix`>,1
+magic,as.standard,1,0,0,logical,1
+magic,as.standard,2,0,0,logical,1
+magic,bernhardsson,-1,0,0,class<`matrix`>,1
+magic,bernhardsson,0,0,0,double,1
+magic,bernhardssonA,-1,0,0,class<`matrix`>,1
+magic,bernhardssonA,0,0,0,double,1
+magic,cilleruelo,-1,0,0,class<`matrix`>,1
+magic,cilleruelo,0,0,0,double,1
+magic,cilleruelo,1,0,0,double,1
+magic,circulant,-1,0,0,class<`matrix`>,1
+magic,circulant,0,0,0,double[],1
+magic,circulant,1,0,0,logical,1
+magic,diag.off,-1,0,0,double[],1
+magic,diag.off,0,0,0,class<`matrix`>,1
+magic,diag.off,1,0,0,double,1
+magic,diag.off,2,0,0,logical,1
+magic,do.index,-1,0,0,class<`array`>,1
+magic,do.index,0,0,0,class<`array`>,1
+magic,do.index,1,0,0,class<`function`>,1
+magic,do.index,2,0,0,...,1
+magic,eq,-1,0,0,logical,1
+magic,eq,0,0,0,class<`matrix`>,1
+magic,eq,1,0,0,class<`matrix`>,1
+magic,%eq%,-1,0,0,logical,1
+magic,%eq%,0,0,0,class<`matrix`>,1
+magic,%eq%,1,0,0,class<`matrix`>,1
+magic,fnsd,-1,0,0,integer[],1
+magic,fnsd,0,0,0,class<`array`>,1
+magic,fnsd,1,0,0,double,1
+magic,force.integer,-1,0,0,class<`array`>,1
+magic,force.integer,-1,0,1,class<`matrix`>,1
+magic,force.integer,0,0,0,class<`array`>,1
+magic,force.integer,0,0,1,class<`matrix`>,1
+magic,hudson,-1,0,0,class<`matrix`>,1
+magic,hudson,0,0,0,double,1
+magic,hudson,0,0,1,null,1
+magic,hudson,1,0,0,null,1
+magic,hudson,1,0,1,double[],1
+magic,hudson,2,0,0,null,1
+magic,hudson,2,0,1,double[],1
+magic,incidence,-1,0,0,class<`array`>,1
+magic,incidence,0,0,0,class<`matrix`>,1
+magic,inc_to_inc,-1,0,0,class<`array`>,1
+magic,inc_to_inc,0,0,0,class<`array`>,1
+magic,is.2x2.correct,-1,0,0,logical,1
+magic,is.2x2.correct,0,0,0,class<`matrix`>,1
+magic,is.2x2.correct,1,0,0,logical,1
+magic,is.alicehypercube,-1,0,0,list<logical | class<`matrix`>>,1
+magic,is.alicehypercube,0,0,0,class<`array`>,1
+magic,is.alicehypercube,1,0,0,double,1
+magic,is.alicehypercube,2,0,0,logical,1
+magic,is.alicehypercube,3,0,0,class<`function`>,1
+magic,is.alicehypercube,4,0,0,logical,1
+magic,is.antimagic,-1,0,0,logical,1
+magic,is.antimagic,0,0,0,class<`matrix`>,1
+magic,is.antimagic,1,0,0,logical,1
+magic,is.antimagic,2,0,0,class<`function`>,1
+magic,is.associative,-1,0,0,logical,1
+magic,is.associative,0,0,0,class<`matrix`>,1
+magic,is.bree.correct,-1,0,0,logical,1
+magic,is.bree.correct,0,0,0,class<`matrix`>,1
+magic,is.bree.correct,1,0,0,logical,1
+magic,is.circulant,-1,0,0,logical,1
+magic,is.circulant,0,0,0,class<`array`>,1
+magic,is.circulant,0,0,1,class<`matrix`>,1
+magic,is.circulant,1,0,0,double[],1
+magic,is.diagonally.correct,-1,0,0,logical,1
+magic,is.diagonally.correct,-1,0,1,list<logical | class<`array`>>,1
+magic,is.diagonally.correct,-1,0,2,list<logical | class<`matrix`>>,1
+magic,is.diagonally.correct,0,0,0,class<`array`>,1
+magic,is.diagonally.correct,0,0,1,class<`matrix`>,1
+magic,is.diagonally.correct,1,0,0,logical,1
+magic,is.diagonally.correct,2,0,0,class<`function`>,1
+magic,is.diagonally.correct,3,0,0,logical,1
+magic,is.diagonally.correct,4,0,0,...,1
+magic,is.hadamard,-1,0,0,logical,1
+magic,is.hadamard,0,0,0,class<`matrix`>,1
+magic,is.incidence,-1,0,0,logical,1
+magic,is.incidence,0,0,0,class<`array`>,1
+magic,is.incidence,1,0,0,logical,1
+magic,is.incidence.improper,-1,0,0,logical,1
+magic,is.incidence.improper,0,0,0,class<`array`>,1
+magic,is.latin,-1,0,0,logical,1
+magic,is.latin,0,0,0,class<`matrix`>,1
+magic,is.latin,1,0,0,logical,1
+magic,is.latinhypercube,-1,0,0,logical,1
+magic,is.latinhypercube,0,0,0,class<`matrix`>,1
+magic,is.latinhypercube,1,0,0,logical,1
+magic,is.magic,-1,0,0,logical[],1
+magic,is.magic,-1,0,1,list<integer[]>,1
+magic,is.magic,0,0,0,class<`matrix`>,1
+magic,is.magic,0,0,1,list<class<`matrix`>>,1
+magic,is.magic,1,0,0,logical,1
+magic,is.magic,2,0,0,class<`function`>,1
+magic,is.magic,3,0,0,logical,1
+magic,is.magichypercube,-1,0,0,logical,1
+magic,is.magichypercube,0,0,0,class<`array`>,1
+magic,is.magichypercube,0,0,1,class<`matrix`>,1
+magic,is.magichypercube,1,0,0,logical,1
+magic,is.magichypercube,2,0,0,class<`function`>,1
+magic,is.magichypercube,3,0,0,logical,1
+magic,is.magichypercube,4,0,0,...,1
+magic,is.mostperfect,-1,0,0,logical,1
+magic,is.mostperfect,0,0,0,class<`matrix`>,1
+magic,is.mostperfect,1,0,0,logical,1
+magic,is.normal,-1,0,0,logical[],1
+magic,is.normal,0,0,0,class<`matrix`>,1
+magic,is.normal,0,0,1,list<class<`matrix`>>,1
+magic,is.ok,-1,0,0,logical,1
+magic,is.ok,0,0,0,integer[],1
+magic,is.ok,1,0,0,integer,1
+magic,is.ok,2,0,0,double,1
+magic,is.pandiagonal,-1,0,0,logical,1
+magic,is.pandiagonal,0,0,0,class<`matrix`>,1
+magic,is.pandiagonal,1,0,0,logical,1
+magic,is.pandiagonal,2,0,0,class<`function`>,1
+magic,is.pandiagonal,3,0,0,logical,1
+magic,is.panmagic,-1,0,0,logical,1
+magic,is.panmagic,0,0,0,class<`matrix`>,1
+magic,is.panmagic,1,0,0,logical,1
+magic,is.panmagic,2,0,0,class<`function`>,1
+magic,is.panmagic,3,0,0,logical,1
+magic,is.perfect,-1,0,0,logical,1
+magic,is.perfect,0,0,0,class<`array`>,1
+magic,is.perfect,0,0,1,class<`matrix`>,1
+magic,is.perfect,1,0,0,logical,1
+magic,is.perfect,2,0,0,class<`function`>,1
+magic,is.perfect,3,0,0,logical,1
+magic,is.persymmetric,-1,0,0,logical,1
+magic,is.persymmetric,0,0,0,class<`matrix`>,1
+magic,is.sam,-1,0,0,logical,1
+magic,is.sam,0,0,0,class<`matrix`>,1
+magic,is.semimagic,-1,0,0,logical,1
+magic,is.semimagic,0,0,0,class<`matrix`>,1
+magic,is.semimagic,1,0,0,logical,1
+magic,is.semimagic,2,0,0,class<`function`>,1
+magic,is.semimagic,3,0,0,logical,1
+magic,is.semimagichypercube,-1,0,0,logical,1
+magic,is.semimagichypercube,-1,0,1,list<logical | class<`array`>>,1
+magic,is.semimagichypercube,-1,0,2,list<logical | class<`matrix`>>,1
+magic,is.semimagichypercube,-1,0,3,list<logical | list<class<`matrix`>>>,1
+magic,is.semimagichypercube,0,0,0,class<`array`>,1
+magic,is.semimagichypercube,0,0,1,class<`matrix`>,1
+magic,is.semimagichypercube,1,0,0,logical,1
+magic,is.semimagichypercube,2,0,0,class<`function`>,1
+magic,is.semimagichypercube,3,0,0,logical,1
+magic,is.semimagichypercube,4,0,0,...,1
+magic,is.sparse,-1,0,0,logical,1
+magic,is.sparse,0,0,0,class<`matrix`>,1
+magic,is.square.palindromic,-1,0,0,logical,1
+magic,is.square.palindromic,0,0,0,class<`matrix`>,1
+magic,is.square.palindromic,1,0,0,double,1
+magic,is.square.palindromic,2,0,0,logical,1
+magic,is.standard,-1,0,0,logical[],1
+magic,is.standard,0,0,0,class<`matrix`>,1
+magic,is.standard,0,0,1,list<class<`matrix`>>,1
+magic,is.standard,0,0,2,class<`array`>,1
+magic,is.standard,1,0,0,logical,1
+magic,is.standard,2,0,0,logical,1
+magic,latin,-1,0,0,class<`matrix`>,1
+magic,latin,0,0,0,double[],1
+magic,latin,1,0,0,logical,1
+magic,lozenge,-1,0,0,class<`matrix`>,1
+magic,lozenge,-1,0,1,list<class<`matrix`>>,1
+magic,lozenge,0,0,0,double,1
+magic,lozenge,0,0,1,integer[],1
+magic,magic,-1,0,0,class<`matrix`>,1
+magic,magic,-1,0,1,list<class<`matrix`>>,1
+magic,magic,0,0,0,double,1
+magic,magic,0,0,1,integer[],1
+magic,magic.2np1,-1,0,0,class<`matrix`>,1
+magic,magic.2np1,-1,0,1,list<class<`matrix`>>,1
+magic,magic.2np1,0,0,0,double,1
+magic,magic.2np1,0,0,1,integer[],1
+magic,magic.2np1,1,0,0,double[],1
+magic,magic.2np1,2,0,0,double[],1
+magic,magic.2np1,3,0,0,null,1
+magic,magic.4n,-1,0,0,class<`matrix`>,1
+magic,magic.4n,-1,0,1,list<class<`matrix`>>,1
+magic,magic.4n,0,0,0,double,1
+magic,magic.4n,0,0,1,integer[],1
+magic,magic.4np2,-1,0,0,class<`matrix`>,1
+magic,magic.4np2,0,0,0,double,1
+magic,magic.constant,-1,0,0,double,1
+magic,magic.constant,0,0,0,double,1
+magic,magic.constant,1,0,0,double,1
+magic,magic.constant,2,0,0,double,1
+magic,magiccube.2np1,-1,0,0,class<`array`>,1
+magic,magiccube.2np1,0,0,0,double,1
+magic,magichypercube.4n,-1,0,0,class<`array`>,1
+magic,magichypercube.4n,-1,0,1,class<`matrix`>,1
+magic,magichypercube.4n,0,0,0,double,1
+magic,magichypercube.4n,1,0,0,double,1
+magic,magicplot,-1,0,0,null,1
+magic,magicplot,0,0,0,class<`matrix`>,1
+magic,magicplot,1,0,0,logical,1
+magic,magicplot,2,0,0,logical,1
+magic,magicplot,3,0,0,...,1
+magic,magic.prime,-1,0,0,class<`matrix`>,1
+magic,magic.prime,0,0,0,double,1
+magic,magic.prime,1,0,0,double,1
+magic,magic.prime,2,0,0,double,1
+magic,magic.product,-1,0,0,class<`matrix`>,1
+magic,magic.product,0,0,0,class<`matrix`>,1
+magic,magic.product,0,0,1,double,1
+magic,magic.product,1,0,0,class<`matrix`>,1
+magic,magic.product,1,0,1,double,1
+magic,magic.product,2,0,0,null,1
+magic,magic.product,2,0,1,class<`matrix`>,1
+magic,minmax,-1,0,0,logical,1
+magic,minmax,0,0,0,class<`array`>,1
+magic,minmax,0,0,1,class<`matrix`>,1
+magic,minmax,0,0,2,double[],1
+magic,minmax,1,0,0,double,1
+magic,notmagic.2n,-1,0,0,class<`matrix`>,1
+magic,notmagic.2n,0,0,0,double,1
+magic,panmagic.4,-1,0,0,class<`matrix`>,1
+magic,panmagic.4,0,0,0,double[],1
+magic,panmagic.6np1,-1,0,0,class<`matrix`>,1
+magic,panmagic.6np1,-1,0,1,list<class<`matrix`>>,1
+magic,panmagic.6np1,0,0,0,double,1
+magic,panmagic.6np1,0,0,1,integer[],1
+magic,panmagic.6npm1,-1,0,0,class<`matrix`>,1
+magic,panmagic.6npm1,-1,0,1,list<class<`matrix`>>,1
+magic,panmagic.6npm1,0,0,0,double[],1
+magic,panmagic.8,-1,0,0,class<`matrix`>,1
+magic,panmagic.8,0,0,0,double[],1
+magic,panmagic.8,1,0,0,double[],1
+magic,process,-1,0,0,class<`array`>,1
+magic,process,-1,0,1,class<`matrix`>,1
+magic,process,-1,0,2,integer[],1
+magic,process,0,0,0,class<`array`>,1
+magic,process,0,0,1,class<`matrix`>,1
+magic,process,0,0,2,integer[],1
+magic,process,1,0,0,double,1
+magic,recurse,-1,0,0,character[],1
+magic,recurse,-1,0,1,double[],1
+magic,recurse,0,0,0,double[],1
+magic,recurse,0,0,1,class<`matrix`>,1
+magic,recurse,1,0,0,double,1
+magic,recurse,2,0,0,character[],1
+magic,recurse,2,0,1,double[],1
+magic,rlatin,-1,0,0,class<`array`>,1
+magic,rlatin,-1,0,1,class<`matrix`>,1
+magic,rlatin,0,0,0,double,1
+magic,rlatin,1,0,0,double,1
+magic,rlatin,1,0,1,null,1
+magic,rlatin,2,0,0,null,1
+magic,rlatin,3,0,0,double,1
+magic,rlatin,3,0,1,null,1
+magic,sam,-1,0,0,class<`matrix`>,1
+magic,sam,0,0,0,double,1
+magic,sam,1,0,0,double,1
+magic,sam,2,0,0,null,1
+magic,sam,3,0,0,class<`matrix`>,1
+magic,shift,-1,0,0,integer[],1
+magic,shift,0,0,0,integer[],1
+magic,shift,1,0,0,double,1
+magic,strachey,-1,0,0,class<`matrix`>,1
+magic,strachey,-1,0,1,list<class<`matrix`>>,1
+magic,strachey,0,0,0,double,1
+magic,strachey,0,0,1,integer[],1
+magic,strachey,1,0,0,class<`matrix`>,1
+magic,strachey,1,0,1,list<class<`matrix`>>,1
+magic,subsums,-1,0,0,class<`array`>,1
+magic,subsums,-1,0,1,class<`matrix`>,1
+magic,subsums,0,0,0,class<`array`>,1
+magic,subsums,0,0,1,class<`matrix`>,1
+magic,subsums,1,0,0,double[],1
+magic,subsums,1,0,1,class<`matrix`>,1
+magic,subsums,2,0,0,character,1
+magic,subsums,3,0,0,logical,1
+magic,subsums,4,0,0,any,1
+magic,sylvester,-1,0,0,class<`matrix`>,1
+magic,sylvester,0,0,0,double,1
+magic,transf,-1,0,0,class<`matrix`>,1
+magic,transf,0,0,0,class<`matrix`>,1
+magic,transf,1,0,0,double,1
+magic,unincidence,-1,0,0,class<`matrix`>,1
+magic,unincidence,0,0,0,class<`array`>,1
+magick,as.integer.bitmap,-1,0,0,class<`array`>,1
+magick,as.integer.bitmap,0,0,0,"class<`bitmap`, `rgba`>",1
+magick,as.integer.bitmap,1,0,0,logical,1
+magick,as.integer.bitmap,2,0,0,...,1
+magick,as.integer.magick-image,-1,0,0,class<`nativeRaster`>,1
+magick,as.integer.magick-image,0,0,0,class<`magick-image`>,1
+magick,as.integer.magick-image,1,0,0,...,1
+magick,as.list.magick-image,-1,0,0,list<class<`magick-image`>>,1
+magick,as.list.magick-image,0,0,0,class<`magick-image`>,1
+magick,as.list.magick-image,1,0,0,...,1
+magick,as.raster.magick-image,-1,0,0,class<`raster`>,1
+magick,as.raster.magick-image,0,0,0,class<`magick-image`>,1
+magick,as.raster.magick-image,1,0,0,...,1
+magick,assert_image,-1,0,0,null,1
+magick,assert_image,0,0,0,"class<`magick-device`, `magick-image`>",1
+magick,assert_image,0,0,1,class<`magick-image`>,1
+magick,autobrewed,-1,0,0,logical,1
+magick,autoviewer_disable,-1,0,0,null,1
+magick,autoviewer_enable,-1,0,0,null,1
+magick,c.magick-image,-1,0,0,class<`magick-image`>,1
+magick,c.magick-image,0,0,0,...,1
+magick,coder_info,-1,0,0,list<character>,1
+magick,coder_info,0,0,0,character,1
+magick,demo_image,-1,0,0,class<`magick-image`>,1
+magick,demo_image,0,0,0,character,1
+magick,df_to_tibble,-1,0,0,"class<`data.frame`, `tbl`, `tbl_df`>",1
+magick,df_to_tibble,0,0,0,class<`data.frame`>,1
+magick,download_url,-1,0,0,character,1
+magick,download_url,0,0,0,character,1
+magick,geometry_area,-1,0,0,character,1
+magick,geometry_area,0,0,0,double,1
+magick,geometry_area,1,0,0,double,1
+magick,geometry_area,2,0,0,double,1
+magick,geometry_area,3,0,0,double,1
+magick,geometry_point,-1,0,0,character,1
+magick,geometry_point,0,0,0,double,1
+magick,geometry_point,1,0,0,double,1
+magick,geometry_size_percent,-1,0,0,character,1
+magick,geometry_size_percent,0,0,0,double,1
+magick,geometry_size_percent,1,0,0,double,1
+magick,geometry_size_percent,1,0,1,null,1
+magick,geometry_size_pixels,-1,0,0,character,1
+magick,geometry_size_pixels,0,0,0,double,1
+magick,geometry_size_pixels,0,0,1,null,1
+magick,geometry_size_pixels,1,0,0,double,1
+magick,geometry_size_pixels,1,0,1,null,1
+magick,geometry_size_pixels,2,0,0,logical,1
+magick,image_animate,-1,0,0,class<`magick-image`>,1
+magick,image_animate,0,0,0,"class<`magick-device`, `magick-image`>",1
+magick,image_animate,0,0,1,class<`magick-image`>,1
+magick,image_animate,1,0,0,double,1
+magick,image_animate,2,0,0,null,1
+magick,image_animate,3,0,0,double,1
+magick,image_animate,4,0,0,character[],1
+magick,image_animate,5,0,0,logical,1
+magick,image_annotate,-1,0,0,class<`magick-image`>,1
+magick,image_annotate,0,0,0,class<`magick-image`>,1
+magick,image_annotate,1,0,0,character,1
+magick,image_annotate,2,0,0,character,1
+magick,image_annotate,3,0,0,character,1
+magick,image_annotate,4,0,0,double,1
+magick,image_annotate,5,0,0,double,1
+magick,image_annotate,6,0,0,character,1
+magick,image_annotate,7,0,0,character,1
+magick,image_append,-1,0,0,class<`magick-image`>,1
+magick,image_append,0,0,0,class<`magick-image`>,1
+magick,image_append,1,0,0,logical,1
+magick,image_apply,-1,0,0,class<`magick-image`>,1
+magick,image_apply,0,0,0,class<`magick-image`>,1
+magick,image_apply,1,0,0,class<`function`>,1
+magick,image_apply,2,0,0,...,1
+magick,image_average,-1,0,0,class<`magick-image`>,1
+magick,image_average,0,0,0,class<`magick-image`>,1
+magick,image_background,-1,0,0,class<`magick-image`>,1
+magick,image_background,0,0,0,class<`magick-image`>,1
+magick,image_background,1,0,0,character,1
+magick,image_background,2,0,0,logical,1
+magick,image_blank,-1,0,0,class<`magick-image`>,1
+magick,image_blank,0,0,0,double,1
+magick,image_blank,1,0,0,double,1
+magick,image_blank,2,0,0,character,1
+magick,image_blank,3,0,0,character,1
+magick,image_blur,-1,0,0,class<`magick-image`>,1
+magick,image_blur,0,0,0,class<`magick-image`>,1
+magick,image_blur,1,0,0,double,1
+magick,image_blur,2,0,0,double,1
+magick,image_border,-1,0,0,class<`magick-image`>,1
+magick,image_border,0,0,0,class<`magick-image`>,1
+magick,image_border,1,0,0,character,1
+magick,image_border,2,0,0,character,1
+magick,image_border,3,0,0,character,1
+magick,image_canny,-1,0,0,class<`magick-image`>,1
+magick,image_canny,0,0,0,class<`magick-image`>,1
+magick,image_canny,1,0,0,character,1
+magick,image_charcoal,-1,0,0,class<`magick-image`>,1
+magick,image_charcoal,0,0,0,class<`magick-image`>,1
+magick,image_charcoal,1,0,0,double,1
+magick,image_charcoal,2,0,0,double,1
+magick,image_chop,-1,0,0,class<`magick-image`>,1
+magick,image_chop,0,0,0,class<`magick-image`>,1
+magick,image_chop,1,0,0,character,1
+magick,image_colorize,-1,0,0,class<`magick-image`>,1
+magick,image_colorize,0,0,0,class<`magick-image`>,1
+magick,image_colorize,1,0,0,double,1
+magick,image_colorize,2,0,0,character,1
+magick,image_compare,-1,0,0,class<`magick-image`>,1
+magick,image_compare,0,0,0,class<`magick-image`>,1
+magick,image_compare,1,0,0,class<`magick-image`>,1
+magick,image_compare,2,0,0,character,1
+magick,image_compare,3,0,0,double,1
+magick,image_composite,-1,0,0,class<`magick-image`>,1
+magick,image_composite,0,0,0,"class<`magick-device`, `magick-image`>",1
+magick,image_composite,0,0,1,class<`magick-image`>,1
+magick,image_composite,1,0,0,class<`magick-image`>,1
+magick,image_composite,2,0,0,character,1
+magick,image_composite,3,0,0,character,1
+magick,image_composite,4,0,0,character,1
+magick,image_composite,5,0,0,character,1
+magick,image_connect,-1,0,0,class<`magick-image`>,1
+magick,image_connect,0,0,0,class<`magick-image`>,1
+magick,image_connect,1,0,0,double,1
+magick,image_contrast,-1,0,0,class<`magick-image`>,1
+magick,image_contrast,0,0,0,class<`magick-image`>,1
+magick,image_contrast,1,0,0,double,1
+magick,image_convert,-1,0,0,class<`magick-image`>,1
+magick,image_convert,0,0,0,class<`magick-image`>,1
+magick,image_convert,1,0,0,character,1
+magick,image_convert,1,0,1,null,1
+magick,image_convert,2,0,0,null,1
+magick,image_convert,2,0,1,character,1
+magick,image_convert,3,0,0,null,1
+magick,image_convert,3,0,1,character,1
+magick,image_convert,4,0,0,null,1
+magick,image_convert,5,0,0,null,1
+magick,image_convert,6,0,0,null,1
+magick,image_convolve,-1,0,0,class<`magick-image`>,1
+magick,image_convolve,0,0,0,class<`magick-image`>,1
+magick,image_convolve,1,0,0,character,1
+magick,image_convolve,1,0,1,class<`matrix`>,1
+magick,image_convolve,2,0,0,double,1
+magick,image_convolve,3,0,0,null,1
+magick,image_convolve,4,0,0,character,1
+magick,image_convolve,4,0,1,null,1
+magick,image_crop,-1,0,0,class<`magick-image`>,1
+magick,image_crop,0,0,0,class<`magick-image`>,1
+magick,image_crop,1,0,0,character,1
+magick,image_crop,1,0,1,null,1
+magick,image_crop,2,0,0,null,1
+magick,image_crop,3,0,0,logical,1
+magick,image_data,-1,0,0,"class<`bitmap`, `rgba`>",1
+magick,image_data,0,0,0,class<`magick-image`>,1
+magick,image_data,1,0,0,null,1
+magick,image_data,2,0,0,double,1
+magick,image_despeckle,-1,0,0,class<`magick-image`>,1
+magick,image_despeckle,0,0,0,class<`magick-image`>,1
+magick,image_despeckle,1,0,0,integer,1
+magick,image_draw,-1,0,0,class<`magick-image`>,1
+magick,image_draw,0,0,0,class<`magick-image`>,1
+magick,image_draw,1,0,0,double,1
+magick,image_draw,2,0,0,double,1
+magick,image_draw,3,0,0,logical,1
+magick,image_draw,4,0,0,...,1
+magick,image_emboss,-1,0,0,class<`magick-image`>,1
+magick,image_emboss,0,0,0,class<`magick-image`>,1
+magick,image_emboss,1,0,0,double,1
+magick,image_emboss,2,0,0,double,1
+magick,image_enhance,-1,0,0,class<`magick-image`>,1
+magick,image_enhance,0,0,0,class<`magick-image`>,1
+magick,image_equalize,-1,0,0,class<`magick-image`>,1
+magick,image_equalize,0,0,0,class<`magick-image`>,1
+magick,image_extent,-1,0,0,class<`magick-image`>,1
+magick,image_extent,0,0,0,class<`magick-image`>,1
+magick,image_extent,1,0,0,character,1
+magick,image_extent,2,0,0,character,1
+magick,image_extent,3,0,0,character,1
+magick,image_fill,-1,0,0,class<`magick-image`>,1
+magick,image_fill,0,0,0,class<`magick-image`>,1
+magick,image_fill,1,0,0,character,1
+magick,image_fill,2,0,0,character,1
+magick,image_fill,3,0,0,double,1
+magick,image_fill,4,0,0,null,1
+magick,image_flatten,-1,0,0,class<`magick-image`>,1
+magick,image_flatten,0,0,0,class<`magick-image`>,1
+magick,image_flatten,1,0,0,null,1
+magick,image_flatten,1,0,1,character,1
+magick,image_flip,-1,0,0,class<`magick-image`>,1
+magick,image_flip,0,0,0,class<`magick-image`>,1
+magick,image_flop,-1,0,0,class<`magick-image`>,1
+magick,image_flop,0,0,0,class<`magick-image`>,1
+magick,image_frame,-1,0,0,class<`magick-image`>,1
+magick,image_frame,0,0,0,class<`magick-image`>,1
+magick,image_frame,1,0,0,character,1
+magick,image_frame,2,0,0,character,1
+magick,image_fuzzycmeans,-1,0,0,class<`magick-image`>,1
+magick,image_fuzzycmeans,0,0,0,class<`magick-image`>,1
+magick,image_fuzzycmeans,1,0,0,double,1
+magick,image_fuzzycmeans,2,0,0,double,1
+magick,image_fx,-1,0,0,class<`magick-image`>,1
+magick,image_fx,0,0,0,class<`magick-image`>,1
+magick,image_fx,1,0,0,character,1
+magick,image_fx,2,0,0,null,1
+magick,image_ggplot,-1,0,0,"class<`gg`, `ggplot`>",1
+magick,image_ggplot,0,0,0,class<`magick-image`>,1
+magick,image_ggplot,1,0,0,logical,1
+magick,image_graph,-1,0,0,"class<`magick-device`, `magick-image`>",1
+magick,image_graph,0,0,0,double,1
+magick,image_graph,1,0,0,double,1
+magick,image_graph,2,0,0,character,1
+magick,image_graph,3,0,0,double,1
+magick,image_graph,4,0,0,double,1
+magick,image_graph,5,0,0,logical,1
+magick,image_graph,6,0,0,logical,1
+magick,image_hough_draw,-1,0,0,class<`magick-image`>,1
+magick,image_hough_draw,0,0,0,class<`magick-image`>,1
+magick,image_hough_draw,1,0,0,character,1
+magick,image_hough_draw,1,0,1,null,1
+magick,image_hough_draw,2,0,0,character,1
+magick,image_hough_draw,3,0,0,character,1
+magick,image_hough_draw,4,0,0,double,1
+magick,image_hough_draw,5,0,0,logical,1
+magick,image_hough_txt,-1,0,0,character,1
+magick,image_hough_txt,0,0,0,class<`magick-image`>,1
+magick,image_hough_txt,1,0,0,null,1
+magick,image_hough_txt,2,0,0,character,1
+magick,image_implode,-1,0,0,class<`magick-image`>,1
+magick,image_implode,0,0,0,class<`magick-image`>,1
+magick,image_implode,1,0,0,double,1
+magick,image_info,-1,0,0,"class<`data.frame`, `tbl`, `tbl_df`>",1
+magick,image_info,0,0,0,class<`magick-image`>,1
+magick,image_join,-1,0,0,class<`magick-image`>,1
+magick,image_join,0,0,0,...,1
+magick,image_lat,-1,0,0,class<`magick-image`>,1
+magick,image_lat,0,0,0,class<`magick-image`>,1
+magick,image_lat,1,0,0,character,1
+magick,image_median,-1,0,0,class<`magick-image`>,1
+magick,image_median,0,0,0,class<`magick-image`>,1
+magick,image_median,1,0,0,double,1
+magick,image_modulate,-1,0,0,class<`magick-image`>,1
+magick,image_modulate,0,0,0,class<`magick-image`>,1
+magick,image_modulate,1,0,0,double,1
+magick,image_modulate,2,0,0,double,1
+magick,image_modulate,3,0,0,double,1
+magick,image_morph,-1,0,0,class<`magick-image`>,1
+magick,image_morph,0,0,0,class<`magick-image`>,1
+magick,image_morph,1,0,0,double,1
+magick,image_morphology,-1,0,0,class<`magick-image`>,1
+magick,image_morphology,0,0,0,class<`magick-image`>,1
+magick,image_morphology,1,0,0,character,1
+magick,image_morphology,2,0,0,character,1
+magick,image_morphology,3,0,0,double,1
+magick,image_morphology,4,0,0,list<any>,1
+magick,image_mosaic,-1,0,0,class<`magick-image`>,1
+magick,image_mosaic,0,0,0,class<`magick-image`>,1
+magick,image_mosaic,1,0,0,null,1
+magick,image_negate,-1,0,0,class<`magick-image`>,1
+magick,image_negate,0,0,0,class<`magick-image`>,1
+magick,image_noise,-1,0,0,class<`magick-image`>,1
+magick,image_noise,0,0,0,class<`magick-image`>,1
+magick,image_noise,1,0,0,character,1
+magick,image_normalize,-1,0,0,class<`magick-image`>,1
+magick,image_normalize,0,0,0,class<`magick-image`>,1
+magick,image_ocr,-1,0,0,character,1
+magick,image_ocr,0,0,0,class<`magick-image`>,1
+magick,image_ocr,1,0,0,character,1
+magick,image_ocr,2,0,0,logical,1
+magick,image_ocr,3,0,0,...,1
+magick,image_ocr_data,-1,0,0,"class<`data.frame`, `tbl`, `tbl_df`>",1
+magick,image_ocr_data,0,0,0,class<`magick-image`>,1
+magick,image_ocr_data,1,0,0,character,1
+magick,image_ocr_data,2,0,0,...,1
+magick,image_oilpaint,-1,0,0,class<`magick-image`>,1
+magick,image_oilpaint,0,0,0,class<`magick-image`>,1
+magick,image_oilpaint,1,0,0,double,1
+magick,image_orient,-1,0,0,class<`magick-image`>,1
+magick,image_orient,0,0,0,class<`magick-image`>,1
+magick,image_orient,1,0,0,null,1
+magick,image_quantize,-1,0,0,class<`magick-image`>,1
+magick,image_quantize,0,0,0,class<`magick-image`>,1
+magick,image_quantize,1,0,0,double,1
+magick,image_quantize,2,0,0,character,1
+magick,image_quantize,3,0,0,null,1
+magick,image_quantize,4,0,0,null,1
+magick,image_read,-1,0,0,class<`magick-image`>,1
+magick,image_read,0,0,0,character,1
+magick,image_read,0,0,1,class<`array`>,1
+magick,image_read,0,0,2,"class<`bitmap`, `rgba`>",1
+magick,image_read,0,0,3,class<`matrix`>,1
+magick,image_read,1,0,0,null,1
+magick,image_read,2,0,0,null,1
+magick,image_read,3,0,0,logical,1
+magick,image_readbitmap,-1,0,0,class<`magick-image`>,1
+magick,image_readbitmap,0,0,0,class<`array`>,1
+magick,image_readbitmap,0,0,1,"class<`bitmap`, `rgba`>",1
+magick,image_read_nativeraster,-1,0,0,class<`magick-image`>,1
+magick,image_read_nativeraster,0,0,0,class<`matrix`>,1
+magick,image_read_pdf,-1,0,0,class<`magick-image`>,1
+magick,image_read_pdf,0,0,0,character,1
+magick,image_read_pdf,1,0,0,double,1
+magick,image_read_pdf,1,0,1,null,1
+magick,image_read_pdf,2,0,0,double,1
+magick,image_read_pdf,3,0,0,character,1
+magick,image_read_svg,-1,0,0,class<`magick-image`>,1
+magick,image_read_svg,0,0,0,character,1
+magick,image_read_svg,1,0,0,double,1
+magick,image_read_svg,1,0,1,null,1
+magick,image_read_svg,2,0,0,null,1
+magick,image_reducenoise,-1,0,0,class<`magick-image`>,1
+magick,image_reducenoise,0,0,0,class<`magick-image`>,1
+magick,image_reducenoise,1,0,0,integer,1
+magick,image_resize,-1,0,0,class<`magick-image`>,1
+magick,image_resize,0,0,0,class<`magick-image`>,1
+magick,image_resize,1,0,0,character,1
+magick,image_resize,2,0,0,character,1
+magick,image_resize,2,0,1,null,1
+magick,image_rotate,-1,0,0,class<`magick-image`>,1
+magick,image_rotate,0,0,0,class<`magick-image`>,1
+magick,image_rotate,1,0,0,double,1
+magick,image_sample,-1,0,0,class<`magick-image`>,1
+magick,image_sample,0,0,0,class<`magick-image`>,1
+magick,image_sample,1,0,0,character,1
+magick,image_scale,-1,0,0,class<`magick-image`>,1
+magick,image_scale,0,0,0,class<`magick-image`>,1
+magick,image_scale,1,0,0,character,1
+magick,image_scale,1,0,1,null,1
+magick,image_shadow,-1,0,0,class<`magick-image`>,1
+magick,image_shadow,0,0,0,class<`magick-image`>,1
+magick,image_shadow,1,0,0,character,1
+magick,image_shadow,2,0,0,character,1
+magick,image_shadow,3,0,0,character,1
+magick,image_shadow,4,0,0,character,1
+magick,image_shadow,5,0,0,character,1
+magick,image_shear,-1,0,0,class<`magick-image`>,1
+magick,image_shear,0,0,0,class<`magick-image`>,1
+magick,image_shear,1,0,0,character,1
+magick,image_shear,2,0,0,character,1
+magick,image_split,-1,0,0,class<`magick-image`>,1
+magick,image_split,0,0,0,class<`magick-image`>,1
+magick,image_split,1,0,0,logical,1
+magick,image_threshold,-1,0,0,class<`magick-image`>,1
+magick,image_threshold,0,0,0,class<`magick-image`>,1
+magick,image_threshold,1,0,0,character,1
+magick,image_threshold,2,0,0,character,1
+magick,image_threshold,3,0,0,null,1
+magick,image_transparent,-1,0,0,class<`magick-image`>,1
+magick,image_transparent,0,0,0,class<`magick-image`>,1
+magick,image_transparent,1,0,0,character,1
+magick,image_transparent,2,0,0,double,1
+magick,image_trim,-1,0,0,class<`magick-image`>,1
+magick,image_trim,0,0,0,class<`magick-image`>,1
+magick,image_trim,1,0,0,double,1
+magick,image_write,-1,0,0,character,1
+magick,image_write,-1,0,1,raw[],1
+magick,image_write,0,0,0,class<`magick-image`>,1
+magick,image_write,1,0,0,character,1
+magick,image_write,1,0,1,null,1
+magick,image_write,2,0,0,character,1
+magick,image_write,2,0,1,null,1
+magick,image_write,3,0,0,null,1
+magick,image_write,4,0,0,null,1
+magick,image_write,5,0,0,character,1
+magick,image_write,5,0,1,null,1
+magick,image_write,6,0,0,null,1
+magick,image_write,7,0,0,logical,1
+magick,image_write_frame,-1,0,0,"class<`bitmap`, `rgba`>",1
+magick,image_write_frame,0,0,0,class<`magick-image`>,1
+magick,image_write_frame,1,0,0,character,1
+magick,image_write_frame,2,0,0,double,1
+magick,is_check,-1,0,0,logical,1
+magick,is_url,-1,0,0,logical,1
+magick,is_url,0,0,0,character,1
+magick,length.magick-image,-1,0,0,integer,1
+magick,length.magick-image,0,0,0,class<`magick-image`>,1
+magick,magick_attr_stroke_antialias,-1,0,0,logical[],1
+magick,magick_attr_stroke_antialias,0,0,0,class<`magick-image`>,1
+magick,magick_attr_stroke_antialias,1,0,0,logical,1
+magick,magick_attr_text_antialias,-1,0,0,logical[],1
+magick,magick_attr_text_antialias,0,0,0,class<`magick-image`>,1
+magick,magick_attr_text_antialias,1,0,0,logical,1
+magick,magick_coder_info,-1,0,0,list<character>,1
+magick,magick_coder_info,0,0,0,character,1
+magick,magick_config,-1,0,0,list<class<`numeric_version`> | logical>,1
+magick,magick_config_internal,-1,0,0,list<character | logical>,1
+magick,magick_device_internal,-1,0,0,class<`magick-image`>,1
+magick,magick_device_internal,0,0,0,character,1
+magick,magick_device_internal,1,0,0,double,1
+magick,magick_device_internal,2,0,0,double,1
+magick,magick_device_internal,3,0,0,double,1
+magick,magick_device_internal,4,0,0,double,1
+magick,magick_device_internal,5,0,0,logical,1
+magick,magick_device_internal,6,0,0,logical,1
+magick,magick_device_internal,7,0,0,logical,1
+magick,magick_device_pop,-1,0,0,"class<`magick-device`, `magick-image`>",1
+magick,magick_device_pop,-1,0,1,null,1
+magick,[.magick-image,-1,0,0,class<`magick-image`>,1
+magick,[.magick-image,0,0,0,class<`magick-image`>,1
+magick,[.magick-image,1,0,0,double[],1
+magick,[[.magick-image,-1,0,0,"class<`bitmap`, `rgba`>",1
+magick,[[.magick-image,0,0,0,class<`magick-image`>,1
+magick,[[.magick-image,1,0,0,double,1
+magick,magick_image_animate,-1,0,0,class<`magick-image`>,1
+magick,magick_image_animate,0,0,0,"class<`magick-device`, `magick-image`>",1
+magick,magick_image_animate,0,0,1,class<`magick-image`>,1
+magick,magick_image_animate,1,0,0,integer,1
+magick,magick_image_animate,2,0,0,integer,1
+magick,magick_image_animate,3,0,0,character,1
+magick,magick_image_animate,4,0,0,logical,1
+magick,magick_image_annotate,-1,0,0,class<`magick-image`>,1
+magick,magick_image_annotate,0,0,0,class<`magick-image`>,1
+magick,magick_image_annotate,1,0,0,character,1
+magick,magick_image_annotate,2,0,0,character,1
+magick,magick_image_annotate,3,0,0,character,1
+magick,magick_image_annotate,4,0,0,double,1
+magick,magick_image_annotate,5,0,0,integer,1
+magick,magick_image_annotate,6,0,0,character,1
+magick,magick_image_annotate,7,0,0,character,1
+magick,magick_image_append,-1,0,0,class<`magick-image`>,1
+magick,magick_image_append,0,0,0,class<`magick-image`>,1
+magick,magick_image_append,1,0,0,logical,1
+magick,magick_image_as_raster,-1,0,0,class<`raster`>,1
+magick,magick_image_as_raster,0,0,0,"class<`bitmap`, `rgba`>",1
+magick,magick_image_average,-1,0,0,class<`magick-image`>,1
+magick,magick_image_average,0,0,0,class<`magick-image`>,1
+magick,magick_image_background,-1,0,0,class<`magick-image`>,1
+magick,magick_image_background,0,0,0,class<`magick-image`>,1
+magick,magick_image_background,1,0,0,character,1
+magick,magick_image_blank,-1,0,0,class<`magick-image`>,1
+magick,magick_image_blank,0,0,0,double,1
+magick,magick_image_blank,1,0,0,double,1
+magick,magick_image_blank,2,0,0,character,1
+magick,magick_image_blank,3,0,0,character,1
+magick,magick_image_blur,-1,0,0,class<`magick-image`>,1
+magick,magick_image_blur,0,0,0,class<`magick-image`>,1
+magick,magick_image_blur,1,0,0,double,1
+magick,magick_image_blur,2,0,0,double,1
+magick,magick_image_border,-1,0,0,class<`magick-image`>,1
+magick,magick_image_border,0,0,0,class<`magick-image`>,1
+magick,magick_image_border,1,0,0,character,1
+magick,magick_image_border,2,0,0,character,1
+magick,magick_image_border,3,0,0,character,1
+magick,magick_image_canny,-1,0,0,class<`magick-image`>,1
+magick,magick_image_canny,0,0,0,class<`magick-image`>,1
+magick,magick_image_canny,1,0,0,character,1
+magick,magick_image_charcoal,-1,0,0,class<`magick-image`>,1
+magick,magick_image_charcoal,0,0,0,class<`magick-image`>,1
+magick,magick_image_charcoal,1,0,0,double,1
+magick,magick_image_charcoal,2,0,0,double,1
+magick,magick_image_chop,-1,0,0,class<`magick-image`>,1
+magick,magick_image_chop,0,0,0,class<`magick-image`>,1
+magick,magick_image_chop,1,0,0,character,1
+magick,magick_image_colorize,-1,0,0,class<`magick-image`>,1
+magick,magick_image_colorize,0,0,0,class<`magick-image`>,1
+magick,magick_image_colorize,1,0,0,double,1
+magick,magick_image_colorize,2,0,0,character,1
+magick,magick_image_compare,-1,0,0,class<`magick-image`>,1
+magick,magick_image_compare,0,0,0,class<`magick-image`>,1
+magick,magick_image_compare,1,0,0,class<`magick-image`>,1
+magick,magick_image_compare,2,0,0,character,1
+magick,magick_image_compare,3,0,0,double,1
+magick,magick_image_composite,-1,0,0,class<`magick-image`>,1
+magick,magick_image_composite,0,0,0,"class<`magick-device`, `magick-image`>",1
+magick,magick_image_composite,0,0,1,class<`magick-image`>,1
+magick,magick_image_composite,1,0,0,class<`magick-image`>,1
+magick,magick_image_composite,2,0,0,character,1
+magick,magick_image_composite,3,0,0,character,1
+magick,magick_image_composite,4,0,0,character,1
+magick,magick_image_composite,5,0,0,character,1
+magick,magick_image_connect,-1,0,0,class<`magick-image`>,1
+magick,magick_image_connect,0,0,0,class<`magick-image`>,1
+magick,magick_image_connect,1,0,0,integer,1
+magick,magick_image_contrast,-1,0,0,class<`magick-image`>,1
+magick,magick_image_contrast,0,0,0,class<`magick-image`>,1
+magick,magick_image_contrast,1,0,0,double,1
+magick,magick_image_convolve_kernel,-1,0,0,class<`magick-image`>,1
+magick,magick_image_convolve_kernel,0,0,0,class<`magick-image`>,1
+magick,magick_image_convolve_kernel,1,0,0,character,1
+magick,magick_image_convolve_kernel,2,0,0,integer,1
+magick,magick_image_convolve_kernel,3,0,0,character[],1
+magick,magick_image_convolve_kernel,4,0,0,character[],1
+magick,magick_image_convolve_matrix,-1,0,0,class<`magick-image`>,1
+magick,magick_image_convolve_matrix,0,0,0,class<`magick-image`>,1
+magick,magick_image_convolve_matrix,1,0,0,class<`matrix`>,1
+magick,magick_image_convolve_matrix,2,0,0,integer,1
+magick,magick_image_convolve_matrix,3,0,0,character[],1
+magick,magick_image_convolve_matrix,4,0,0,character[],1
+magick,magick_image_copy,-1,0,0,class<`magick-image`>,1
+magick,magick_image_copy,0,0,0,class<`magick-image`>,1
+magick,magick_image_copy,1,0,0,class<`magick-image`>,1
+magick,magick_image_crop,-1,0,0,class<`magick-image`>,1
+magick,magick_image_crop,0,0,0,class<`magick-image`>,1
+magick,magick_image_crop,1,0,0,character[],1
+magick,magick_image_crop,2,0,0,character[],1
+magick,magick_image_crop,3,0,0,logical,1
+magick,magick_image_dead,-1,0,0,integer,1
+magick,magick_image_dead,0,0,0,"class<`magick-device`, `magick-image`>",1
+magick,magick_image_dead,0,0,1,class<`magick-image`>,1
+magick,magick_image_despeckle,-1,0,0,class<`magick-image`>,1
+magick,magick_image_despeckle,0,0,0,class<`magick-image`>,1
+magick,magick_image_despeckle,1,0,0,integer,1
+magick,magick_image_emboss,-1,0,0,class<`magick-image`>,1
+magick,magick_image_emboss,0,0,0,class<`magick-image`>,1
+magick,magick_image_emboss,1,0,0,double,1
+magick,magick_image_emboss,2,0,0,double,1
+magick,magick_image_enhance,-1,0,0,class<`magick-image`>,1
+magick,magick_image_enhance,0,0,0,class<`magick-image`>,1
+magick,magick_image_equalize,-1,0,0,class<`magick-image`>,1
+magick,magick_image_equalize,0,0,0,class<`magick-image`>,1
+magick,magick_image_extent,-1,0,0,class<`magick-image`>,1
+magick,magick_image_extent,0,0,0,class<`magick-image`>,1
+magick,magick_image_extent,1,0,0,character,1
+magick,magick_image_extent,2,0,0,character,1
+magick,magick_image_extent,3,0,0,character,1
+magick,magick_image_fill,-1,0,0,class<`magick-image`>,1
+magick,magick_image_fill,0,0,0,class<`magick-image`>,1
+magick,magick_image_fill,1,0,0,character,1
+magick,magick_image_fill,2,0,0,character,1
+magick,magick_image_fill,3,0,0,double,1
+magick,magick_image_fill,4,0,0,character[],1
+magick,magick_image_flatten,-1,0,0,class<`magick-image`>,1
+magick,magick_image_flatten,0,0,0,class<`magick-image`>,1
+magick,magick_image_flatten,1,0,0,character[],1
+magick,magick_image_flip,-1,0,0,class<`magick-image`>,1
+magick,magick_image_flip,0,0,0,class<`magick-image`>,1
+magick,magick_image_flop,-1,0,0,class<`magick-image`>,1
+magick,magick_image_flop,0,0,0,class<`magick-image`>,1
+magick,magick_image_format,-1,0,0,class<`magick-image`>,1
+magick,magick_image_format,0,0,0,class<`magick-image`>,1
+magick,magick_image_format,1,0,0,character[],1
+magick,magick_image_format,2,0,0,character[],1
+magick,magick_image_format,3,0,0,character[],1
+magick,magick_image_format,4,0,0,integer[],1
+magick,magick_image_format,5,0,0,logical[],1
+magick,magick_image_format,6,0,0,logical[],1
+magick,magick_image_frame,-1,0,0,class<`magick-image`>,1
+magick,magick_image_frame,0,0,0,class<`magick-image`>,1
+magick,magick_image_frame,1,0,0,character,1
+magick,magick_image_frame,2,0,0,character,1
+magick,magick_image_fuzzycmeans,-1,0,0,class<`magick-image`>,1
+magick,magick_image_fuzzycmeans,0,0,0,class<`magick-image`>,1
+magick,magick_image_fuzzycmeans,1,0,0,double,1
+magick,magick_image_fuzzycmeans,2,0,0,double,1
+magick,magick_image_fx,-1,0,0,class<`magick-image`>,1
+magick,magick_image_fx,0,0,0,class<`magick-image`>,1
+magick,magick_image_fx,1,0,0,character,1
+magick,magick_image_fx,2,0,0,character[],1
+magick,magick_image_houghline,-1,0,0,class<`magick-image`>,1
+magick,magick_image_houghline,0,0,0,class<`magick-image`>,1
+magick,magick_image_houghline,1,0,0,character,1
+magick,magick_image_houghline,2,0,0,character,1
+magick,magick_image_houghline,3,0,0,character,1
+magick,magick_image_houghline,4,0,0,double,1
+magick,magick_image_implode,-1,0,0,class<`magick-image`>,1
+magick,magick_image_implode,0,0,0,class<`magick-image`>,1
+magick,magick_image_implode,1,0,0,double,1
+magick,magick_image_info,-1,0,0,class<`data.frame`>,1
+magick,magick_image_info,0,0,0,class<`magick-image`>,1
+magick,magick_image_join,-1,0,0,class<`magick-image`>,1
+magick,magick_image_join,0,0,0,list<class<`magick-image`>>,1
+magick,magick_image_lat,-1,0,0,class<`magick-image`>,1
+magick,magick_image_lat,0,0,0,class<`magick-image`>,1
+magick,magick_image_lat,1,0,0,character,1
+magick,magick_image_length,-1,0,0,integer,1
+magick,magick_image_length,0,0,0,class<`magick-image`>,1
+magick,magick_image_median,-1,0,0,class<`magick-image`>,1
+magick,magick_image_median,0,0,0,class<`magick-image`>,1
+magick,magick_image_median,1,0,0,double,1
+magick,magick_image_modulate,-1,0,0,class<`magick-image`>,1
+magick,magick_image_modulate,0,0,0,class<`magick-image`>,1
+magick,magick_image_modulate,1,0,0,double,1
+magick,magick_image_modulate,2,0,0,double,1
+magick,magick_image_modulate,3,0,0,double,1
+magick,magick_image_morph,-1,0,0,class<`magick-image`>,1
+magick,magick_image_morph,0,0,0,class<`magick-image`>,1
+magick,magick_image_morph,1,0,0,double,1
+magick,magick_image_morphology,-1,0,0,class<`magick-image`>,1
+magick,magick_image_morphology,0,0,0,class<`magick-image`>,1
+magick,magick_image_morphology,1,0,0,character,1
+magick,magick_image_morphology,2,0,0,character,1
+magick,magick_image_morphology,3,0,0,integer,1
+magick,magick_image_morphology,4,0,0,character[],1
+magick,magick_image_morphology,5,0,0,character[],1
+magick,magick_image_mosaic,-1,0,0,class<`magick-image`>,1
+magick,magick_image_mosaic,0,0,0,class<`magick-image`>,1
+magick,magick_image_mosaic,1,0,0,character[],1
+magick,magick_image_negate,-1,0,0,class<`magick-image`>,1
+magick,magick_image_negate,0,0,0,class<`magick-image`>,1
+magick,magick_image_noise,-1,0,0,class<`magick-image`>,1
+magick,magick_image_noise,0,0,0,class<`magick-image`>,1
+magick,magick_image_noise,1,0,0,character,1
+magick,magick_image_normalize,-1,0,0,class<`magick-image`>,1
+magick,magick_image_normalize,0,0,0,class<`magick-image`>,1
+magick,magick_image_oilpaint,-1,0,0,class<`magick-image`>,1
+magick,magick_image_oilpaint,0,0,0,class<`magick-image`>,1
+magick,magick_image_oilpaint,1,0,0,double,1
+magick,magick_image_orient,-1,0,0,class<`magick-image`>,1
+magick,magick_image_orient,0,0,0,class<`magick-image`>,1
+magick,magick_image_orient,1,0,0,character[],1
+magick,magick_image_quantize,-1,0,0,class<`magick-image`>,1
+magick,magick_image_quantize,0,0,0,class<`magick-image`>,1
+magick,magick_image_quantize,1,0,0,integer,1
+magick,magick_image_quantize,2,0,0,character,1
+magick,magick_image_quantize,3,0,0,logical[],1
+magick,magick_image_quantize,4,0,0,integer[],1
+magick,magick_image_readbitmap_double,-1,0,0,class<`magick-image`>,1
+magick,magick_image_readbitmap_double,0,0,0,class<`array`>,1
+magick,magick_image_readbitmap_native,-1,0,0,class<`magick-image`>,1
+magick,magick_image_readbitmap_native,0,0,0,class<`matrix`>,1
+magick,magick_image_readbitmap_raw,-1,0,0,class<`magick-image`>,1
+magick,magick_image_readbitmap_raw,0,0,0,class<`array`>,1
+magick,magick_image_readbitmap_raw,0,0,1,"class<`bitmap`, `rgba`>",1
+magick,magick_image_readpath,-1,0,0,class<`magick-image`>,1
+magick,magick_image_readpath,0,0,0,character,1
+magick,magick_image_readpath,1,0,0,character[],1
+magick,magick_image_readpath,2,0,0,integer[],1
+magick,magick_image_readpath,3,0,0,logical,1
+magick,magick_image_reducenoise,-1,0,0,class<`magick-image`>,1
+magick,magick_image_reducenoise,0,0,0,class<`magick-image`>,1
+magick,magick_image_reducenoise,1,0,0,integer,1
+magick,magick_image_resize,-1,0,0,class<`magick-image`>,1
+magick,magick_image_resize,0,0,0,class<`magick-image`>,1
+magick,magick_image_resize,1,0,0,character,1
+magick,magick_image_resize,2,0,0,character[],1
+magick,magick_image_rev,-1,0,0,class<`magick-image`>,1
+magick,magick_image_rev,0,0,0,class<`magick-image`>,1
+magick,magick_image_rotate,-1,0,0,class<`magick-image`>,1
+magick,magick_image_rotate,0,0,0,class<`magick-image`>,1
+magick,magick_image_rotate,1,0,0,double,1
+magick,magick_image_sample,-1,0,0,class<`magick-image`>,1
+magick,magick_image_sample,0,0,0,class<`magick-image`>,1
+magick,magick_image_sample,1,0,0,character,1
+magick,magick_image_scale,-1,0,0,class<`magick-image`>,1
+magick,magick_image_scale,0,0,0,class<`magick-image`>,1
+magick,magick_image_scale,1,0,0,character[],1
+magick,magick_image_shadow_mask,-1,0,0,class<`magick-image`>,1
+magick,magick_image_shadow_mask,0,0,0,class<`magick-image`>,1
+magick,magick_image_shadow_mask,1,0,0,character,1
+magick,magick_image_shear,-1,0,0,class<`magick-image`>,1
+magick,magick_image_shear,0,0,0,class<`magick-image`>,1
+magick,magick_image_shear,1,0,0,character,1
+magick,magick_image_shear,2,0,0,character,1
+magick,magick_image_subset,-1,0,0,class<`magick-image`>,1
+magick,magick_image_subset,0,0,0,class<`magick-image`>,1
+magick,magick_image_subset,1,0,0,integer[],1
+magick,magick_image_threshold_black,-1,0,0,class<`magick-image`>,1
+magick,magick_image_threshold_black,0,0,0,class<`magick-image`>,1
+magick,magick_image_threshold_black,1,0,0,character,1
+magick,magick_image_threshold_black,2,0,0,character[],1
+magick,magick_image_threshold_white,-1,0,0,class<`magick-image`>,1
+magick,magick_image_threshold_white,0,0,0,class<`magick-image`>,1
+magick,magick_image_threshold_white,1,0,0,character,1
+magick,magick_image_threshold_white,2,0,0,character[],1
+magick,magick_image_transparent,-1,0,0,class<`magick-image`>,1
+magick,magick_image_transparent,0,0,0,class<`magick-image`>,1
+magick,magick_image_transparent,1,0,0,character,1
+magick,magick_image_transparent,2,0,0,double,1
+magick,magick_image_trim,-1,0,0,class<`magick-image`>,1
+magick,magick_image_trim,0,0,0,class<`magick-image`>,1
+magick,magick_image_trim,1,0,0,double,1
+magick,magick_image_write,-1,0,0,raw[],1
+magick,magick_image_write,0,0,0,class<`magick-image`>,1
+magick,magick_image_write,1,0,0,character[],1
+magick,magick_image_write,2,0,0,integer[],1
+magick,magick_image_write,3,0,0,integer[],1
+magick,magick_image_write,4,0,0,character[],1
+magick,magick_image_write,5,0,0,character[],1
+magick,magick_image_write_frame,-1,0,0,"class<`bitmap`, `rgba`>",1
+magick,magick_image_write_frame,0,0,0,class<`magick-image`>,1
+magick,magick_image_write_frame,1,0,0,character,1
+magick,magick_image_write_frame,2,0,0,double,1
+magick,magick_image_write_integer,-1,0,0,class<`nativeRaster`>,1
+magick,magick_image_write_integer,0,0,0,class<`magick-image`>,1
+magick,plot.magick-image,-1,0,0,null,1
+magick,plot.magick-image,0,0,0,class<`magick-image`>,1
+magick,plot.magick-image,1,0,0,...,1
+magick,print.magick-image,-1,0,0,null,1
+magick,print.magick-image,0,0,0,class<`magick-image`>,1
+magick,print.magick-image,1,0,0,logical,1
+magick,print.magick-image,2,0,0,...,1
+magick,register_s3_method,-1,0,0,null,1
+magick,register_s3_method,0,0,0,character,1
+magick,register_s3_method,1,0,0,character,1
+magick,register_s3_method,2,0,0,character,1
+magick,register_s3_method,3,0,0,null,1
+magick,replace_url,-1,0,0,character,1
+magick,replace_url,0,0,0,character,1
+magick,rev.magick-image,-1,0,0,class<`magick-image`>,1
+magick,rev.magick-image,0,0,0,class<`magick-image`>,1
+magick,set_magick_tempdir,-1,0,0,character,1
+magick,set_magick_tempdir,0,0,0,character,1
+magick,setup_device,-1,0,0,null,1
+magick,setup_device,0,0,0,any,1
+magick,setup_device,1,0,0,double[],1
+magick,setup_device,1,0,1,null,1
+magick,setup_device,2,0,0,double[],1
+magick,setup_device,2,0,1,null,1
+magick,setup_device,3,0,0,character,1
+magick,setup_device,4,0,0,character,1
+magick,setup_device,5,0,0,double[],1
+magick,setup_device,6,0,0,...,1
+mapproj,.Last.projection,-1,0,0,list<character | double[]>,1
+mapproj,.Last.projection,-1,0,1,list<character | null | double[]>,1
+mapproj,.Last.projection,0,0,0,any,1
+mapproj,map.grid,-1,0,0,null,1
+mapproj,map.grid,0,0,0,class<`map`>,1
+mapproj,map.grid,1,0,0,double,1
+mapproj,map.grid,2,0,0,double,1
+mapproj,map.grid,3,0,0,logical,1
+mapproj,map.grid,4,0,0,logical,1
+mapproj,map.grid,5,0,0,double,1
+mapproj,map.grid,6,0,0,double,1
+mapproj,map.grid,7,0,0,double,1
+mapproj,map.grid,8,0,0,double,1
+mapproj,map.grid,9,0,0,...,1
+mapproj,mapproject,-1,0,0,list<^double[]>,1
+mapproj,mapproject,0,0,0,list<^double[] | character[]>,1
+mapproj,mapproject,0,0,1,class<`data.frame`>,1
+mapproj,mapproject,0,0,2,double[],1
+mapproj,mapproject,0,0,3,list<double[]>,1
+mapproj,mapproject,1,0,0,any,1
+mapproj,mapproject,2,0,0,character,1
+mapproj,mapproject,3,0,0,double[],1
+mapproj,mapproject,3,0,1,null,1
+mapproj,mapproject,4,0,0,null,1
+mapproj,mapproject,4,0,1,double[],1
+matlab,as.size_t,-1,0,0,class<`size_t`>,1
+matlab,as.size_t,0,0,0,integer[],1
+matlab,ceil,-1,0,0,double[],1
+matlab,ceil,0,0,0,double[],1
+matlab,cell,-1,0,0,class<`matrix`>,1
+matlab,cell,0,0,0,...,1
+matlab,circularPad,-1,0,0,character[],1
+matlab,circularPad,0,0,0,class<`matrix`>,1
+matlab,circularPad,1,0,0,double[],1
+matlab,circularPad,2,0,0,character,1
+matlab,colorbar,-1,0,0,null,1
+matlab,colorbar,0,0,0,class<`matrix`>,1
+matlab,colorbar,1,0,0,character,1
+matlab,colorbar,2,0,0,...,1
+matlab,constantPad,-1,0,0,class<`array`>,1
+matlab,constantPad,-1,0,1,class<`matrix`>,1
+matlab,constantPad,0,0,0,class<`array`>,1
+matlab,constantPad,0,0,1,class<`matrix`>,1
+matlab,constantPad,1,0,0,double[],1
+matlab,constantPad,2,0,0,double,1
+matlab,constantPad,3,0,0,character,1
+matlab,eye,-1,0,0,class<`matrix`>,1
+matlab,eye,0,0,0,double,1
+matlab,eye,1,0,0,any,1
+matlab,factors,-1,0,0,double[],1
+matlab,factors,0,0,0,double,1
+matlab,fileparts,-1,0,0,list<character>,1
+matlab,fileparts,0,0,0,character,1
+matlab,find,-1,0,0,integer[],1
+matlab,find,0,0,0,double[],1
+matlab,fix,-1,0,0,double[],1
+matlab,fix,0,0,0,double[],1
+matlab,fliplr,-1,0,0,class<`matrix`>,1
+matlab,fliplr,-1,0,1,integer[],1
+matlab,fliplr,0,0,0,class<`matrix`>,1
+matlab,fliplr,0,0,1,integer[],1
+matlab,fliplr,-1,1,0,integer[],1
+matlab,fliplr,0,1,0,integer[],1
+matlab,fliplr,-1,2,0,class<`matrix`>,1
+matlab,fliplr,0,2,0,class<`matrix`>,1
+matlab,flipud,-1,0,0,integer[],1
+matlab,flipud,0,0,0,integer[],1
+matlab,flipud,-1,1,0,class<`matrix`>,1
+matlab,flipud,-1,1,1,integer[],1
+matlab,flipud,0,1,0,class<`matrix`>,1
+matlab,flipud,0,1,1,integer[],1
+matlab,flipud,-1,2,0,class<`matrix`>,1
+matlab,flipud,0,2,0,class<`matrix`>,1
+matlab,fullfile,-1,0,0,character,1
+matlab,fullfile,0,0,0,...,1
+matlab,getLengthOfDimension,-1,0,0,integer,1
+matlab,getLengthOfDimension,0,0,0,class<`array`>,1
+matlab,getLengthOfDimension,0,0,1,class<`matrix`>,1
+matlab,getLengthOfDimension,1,0,0,integer,1
+matlab,hilb,-1,0,0,class<`matrix`>,1
+matlab,hilb,0,0,0,double,1
+matlab,imagesc,-1,0,0,null,1
+matlab,imagesc,0,0,0,class<`matrix`>,1
+matlab,imagesc,1,0,0,integer[],1
+matlab,imagesc,2,0,0,any,1
+matlab,imagesc,3,0,0,character[],1
+matlab,imagesc,4,0,0,...,1
+matlab,isempty,-1,0,0,logical,1
+matlab,isempty,0,0,0,class<`array`>,1
+matlab,isempty,0,0,1,integer[],1
+matlab,isprime,-1,0,0,integer[],1
+matlab,isprime,0,0,0,double[],1
+matlab,is.size_t,-1,0,0,logical,1
+matlab,is.size_t,0,0,0,class<`matrix`>,1
+matlab,is.size_t,0,0,1,class<`size_t`>,1
+matlab,is.size_t,0,0,2,double[],1
+matlab,jet,-1,0,0,class<`matrix`>,1
+matlab,jet,0,0,0,integer,1
+matlab,jet.colors,-1,0,0,character[],1
+matlab,jet.colors,0,0,0,double,1
+matlab,linspace,-1,0,0,double[],1
+matlab,linspace,0,0,0,double,1
+matlab,linspace,1,0,0,double,1
+matlab,linspace,2,0,0,double,1
+matlab,logspace,-1,0,0,double[],1
+matlab,logspace,0,0,0,double,1
+matlab,logspace,1,0,0,double,1
+matlab,logspace,2,0,0,double,1
+matlab,magic,-1,0,0,class<`matrix`>,1
+matlab,magic,0,0,0,double,1
+matlab,meshgrid,-1,0,0,list<class<`array`>>,1
+matlab,meshgrid,-1,0,1,list<class<`matrix`>>,1
+matlab,meshgrid,0,0,0,integer[],1
+matlab,meshgrid,1,0,0,any,1
+matlab,meshgrid,2,0,0,any,1
+matlab,meshgrid,3,0,0,double,1
+matlab,mkconstarray,-1,0,0,class<`array`>,1
+matlab,mkconstarray,-1,0,1,class<`matrix`>,1
+matlab,mkconstarray,0,0,0,character,1
+matlab,mkconstarray,1,0,0,double,1
+matlab,mkconstarray,2,0,0,class<`matrix`>,1
+matlab,mod,-1,0,0,double,1
+matlab,mod,0,0,0,double,1
+matlab,mod,1,0,0,double,1
+matlab,multiline.plot.colors,-1,0,0,character[],1
+matlab,ndims,-1,0,0,integer,1
+matlab,ndims,0,0,0,class<`array`>,1
+matlab,ndims,0,0,1,class<`matrix`>,1
+matlab,ndims,0,0,2,integer[],1
+matlab,nextpow2,-1,0,0,double[],1
+matlab,nextpow2,0,0,0,double[],1
+matlab,numel,-1,0,0,double,1
+matlab,numel,0,0,0,class<`matrix`>,1
+matlab,numel,0,0,1,integer[],1
+matlab,numel,1,0,0,any,1
+matlab,ones,-1,0,0,class<`matrix`>,1
+matlab,ones,0,0,0,...,1
+matlab,padarray,-1,0,0,character[],1
+matlab,padarray,-1,0,1,class<`matrix`>,1
+matlab,padarray,-1,0,2,integer[],1
+matlab,padarray,-1,0,3,class<`array`>,1
+matlab,padarray,0,0,0,character[],1
+matlab,padarray,0,0,1,class<`matrix`>,1
+matlab,padarray,0,0,2,integer[],1
+matlab,padarray,0,0,3,class<`array`>,1
+matlab,padarray,1,0,0,double[],1
+matlab,padarray,2,0,0,character,1
+matlab,padarray,2,0,1,double,1
+matlab,padarray,3,0,0,character[],1
+matlab,padarray,-1,1,0,class<`matrix`>,1
+matlab,padarray,0,1,0,integer[],1
+matlab,padarray,1,1,0,double[],1
+matlab,padarray,2,1,0,double,1
+matlab,padarray,3,1,0,character[],1
+matlab,padarray,-1,2,0,class<`matrix`>,1
+matlab,padarray,0,2,0,class<`matrix`>,1
+matlab,padarray,1,2,0,double[],1
+matlab,padarray,2,2,0,double,1
+matlab,padarray,3,2,0,character[],1
+matlab,padarray,-1,3,0,class<`matrix`>,1
+matlab,padarray,0,3,0,integer[],1
+matlab,padarray,1,3,0,double[],1
+matlab,padarray,2,3,0,double,1
+matlab,padarray,3,3,0,character[],1
+matlab,padarray,-1,4,0,character[],1
+matlab,padarray,-1,4,1,class<`matrix`>,1
+matlab,padarray,-1,4,2,integer[],1
+matlab,padarray,0,4,0,class<`matrix`>,1
+matlab,padarray,1,4,0,double[],1
+matlab,padarray,2,4,0,character,1
+matlab,padarray,3,4,0,character[],1
+matlab,padarray,-1,5,0,class<`matrix`>,1
+matlab,padarray,0,5,0,integer[],1
+matlab,padarray,1,5,0,double[],1
+matlab,padarray,2,5,0,double,1
+matlab,padarray,3,5,0,character,1
+matlab,padarray,-1,6,0,character[],1
+matlab,padarray,0,6,0,character[],1
+matlab,padarray,1,6,0,double[],1
+matlab,padarray,2,6,0,character,1
+matlab,padarray,3,6,0,character[],1
+matlab,padarray,-1,7,0,character[],1
+matlab,padarray,0,7,0,character[],1
+matlab,padarray,1,7,0,double[],1
+matlab,padarray,2,7,0,character,1
+matlab,padarray,3,7,0,character,1
+matlab,padarray,-1,8,0,integer[],1
+matlab,padarray,0,8,0,integer[],1
+matlab,padarray,1,8,0,double[],1
+matlab,padarray,2,8,0,character,1
+matlab,padarray,3,8,0,character,1
+matlab,padarray0,-1,0,0,character[],1
+matlab,padarray0,-1,0,1,class<`array`>,1
+matlab,padarray0,-1,0,2,class<`matrix`>,1
+matlab,padarray0,-1,0,3,integer[],1
+matlab,padarray0,0,0,0,class<`matrix`>,1
+matlab,padarray0,0,0,1,class<`array`>,1
+matlab,padarray0,1,0,0,character,1
+matlab,padarray0,2,0,0,double[],1
+matlab,padarray0,3,0,0,null,1
+matlab,padarray0,3,0,1,double,1
+matlab,padarray0,4,0,0,character,1
+matlab,pascal,-1,0,0,class<`matrix`>,1
+matlab,pascal,0,0,0,double,1
+matlab,pascal,1,0,0,double,1
+matlab,pow2,-1,0,0,complex,1
+matlab,pow2,-1,0,1,double[],1
+matlab,pow2,0,0,0,complex,1
+matlab,pow2,0,0,1,double[],1
+matlab,pow2,1,0,0,any,1
+matlab,primes,-1,0,0,double[],1
+matlab,primes,0,0,0,double,1
+matlab,rem,-1,0,0,double,1
+matlab,rem,0,0,0,double,1
+matlab,rem,1,0,0,double,1
+matlab,replicatePad,-1,0,0,character[],1
+matlab,replicatePad,-1,0,1,class<`matrix`>,1
+matlab,replicatePad,0,0,0,class<`matrix`>,1
+matlab,replicatePad,1,0,0,double[],1
+matlab,replicatePad,2,0,0,character,1
+matlab,repmat,-1,0,0,class<`matrix`>,1
+matlab,repmat,0,0,0,class<`matrix`>,1
+matlab,repmat,0,0,1,double,1
+matlab,repmat,1,0,0,...,1
+matlab,reshape,-1,0,0,class<`array`>,1
+matlab,reshape,-1,0,1,class<`matrix`>,1
+matlab,reshape,0,0,0,class<`matrix`>,1
+matlab,reshape,1,0,0,...,1
+matlab,rosser,-1,0,0,class<`matrix`>,1
+matlab,rot90,-1,0,0,class<`matrix`>,1
+matlab,rot90,0,0,0,class<`matrix`>,1
+matlab,rot90,-1,1,0,class<`matrix`>,1
+matlab,rot90,0,1,0,class<`matrix`>,1
+matlab,rot90,1,1,0,double,1
+matlab,size,-1,0,0,class<`size_t`>,1
+matlab,size,-1,0,1,integer,1
+matlab,size,0,0,0,class<`array`>,1
+matlab,size,0,0,1,class<`matrix`>,1
+matlab,size,0,0,2,double[],1
+matlab,size,1,0,0,any,1
+matlab,size,-1,1,0,class<`size_t`>,1
+matlab,size,0,1,0,class<`matrix`>,1
+matlab,size,1,1,0,any,1
+matlab,size,-1,2,0,integer,1
+matlab,size,0,2,0,class<`array`>,1
+matlab,size,1,2,0,integer,1
+matlab,size,-1,3,0,integer,1
+matlab,size,0,3,0,class<`matrix`>,1
+matlab,size,1,3,0,double,1
+matlab,size,-1,4,0,class<`size_t`>,1
+matlab,size,0,4,0,class<`array`>,1
+matlab,size,1,4,0,any,1
+matlab,size,-1,5,0,class<`size_t`>,1
+matlab,size,0,5,0,integer[],1
+matlab,size,1,5,0,any,1
+matlab,size,-1,6,0,integer,1
+matlab,size,0,6,0,class<`matrix`>,1
+matlab,size,1,6,0,integer,1
+matlab,size_t,-1,0,0,class<`size_t`>,1
+matlab,size_t,0,0,0,integer[],1
+matlab,std,-1,0,0,double,1
+matlab,std,0,0,0,integer[],1
+matlab,std,1,0,0,double,1
+matlab,strcmp,-1,0,0,logical,1
+matlab,strcmp,0,0,0,character[],1
+matlab,strcmp,1,0,0,character[],1
+matlab,sum,-1,0,0,integer[],1
+matlab,sum,0,0,0,class<`matrix`>,1
+matlab,sum,1,0,0,logical,1
+matlab,sum,-1,1,0,integer[],1
+matlab,sum,0,1,0,class<`matrix`>,1
+matlab,sum,0,1,1,integer[],1
+matlab,sum,1,1,0,logical,1
+matlab,sum,-1,2,0,integer[],1
+matlab,sum,0,2,0,class<`matrix`>,1
+matlab,sum,1,2,0,logical,1
+matlab,sum,-1,3,0,integer,1
+matlab,sum,0,3,0,integer[],1
+matlab,sum,1,3,0,logical,1
+matlab,sum,-1,4,0,integer,1
+matlab,sum,0,4,0,integer[],1
+matlab,sum,1,4,0,logical,1
+matlab,symmetricPad,-1,0,0,character[],1
+matlab,symmetricPad,-1,0,1,class<`matrix`>,1
+matlab,symmetricPad,-1,0,2,integer[],1
+matlab,symmetricPad,0,0,0,class<`matrix`>,1
+matlab,symmetricPad,1,0,0,double[],1
+matlab,symmetricPad,2,0,0,character,1
+matlab,tic,-1,0,0,null,1
+matlab,tic,0,0,0,logical,1
+matlab,toc,-1,0,0,null,1
+matlab,toc,0,0,0,logical,1
+matlab,vander,-1,0,0,class<`matrix`>,1
+matlab,vander,0,0,0,integer[],1
+matlab,zeros,-1,0,0,class<`matrix`>,1
+matlab,zeros,0,0,0,...,1
+matrixStats,allocArray,-1,0,0,class<`array`>,1
+matrixStats,allocArray,0,0,0,integer[],1
+matrixStats,allocArray,1,0,0,double,1
+matrixStats,allocArray,1,0,1,null,1
+matrixStats,allocArray,2,0,0,...,1
+matrixStats,allocMatrix,-1,0,0,class<`matrix`>,1
+matrixStats,allocMatrix,0,0,0,integer,1
+matrixStats,allocMatrix,1,0,0,integer,1
+matrixStats,allocMatrix,2,0,0,double,1
+matrixStats,allocMatrix,2,0,1,null,1
+matrixStats,allocMatrix,3,0,0,...,1
+matrixStats,allocVector,-1,0,0,^double[],1
+matrixStats,allocVector,0,0,0,double,1
+matrixStats,allocVector,1,0,0,null,1
+matrixStats,allocVector,1,0,1,double,1
+matrixStats,allocVector,2,0,0,...,1
+matrixStats,allValue,-1,0,0,logical,1
+matrixStats,allValue,-1,0,1,null,1
+matrixStats,allValue,0,0,0,^character[],1
+matrixStats,allValue,0,0,1,^double[],1
+matrixStats,allValue,1,0,0,null,1
+matrixStats,allValue,2,0,0,character,1
+matrixStats,allValue,2,0,1,null,1
+matrixStats,allValue,2,0,2,double,1
+matrixStats,allValue,3,0,0,logical,1
+matrixStats,allValue,4,0,0,...,1
+matrixStats,anyMissing,-1,0,0,logical,1
+matrixStats,anyMissing,0,0,0,class<`AsIs`>,1
+matrixStats,anyMissing,0,0,1,class<`data.frame`>,1
+matrixStats,anyMissing,0,0,2,class<`matrix`>,1
+matrixStats,anyMissing,0,0,3,class<`table`>,1
+matrixStats,anyMissing,0,0,4,^complex[],1
+matrixStats,anyMissing,0,0,5,list<null>,1
+matrixStats,anyMissing,0,0,6,null,1
+matrixStats,anyMissing,0,0,7,raw[],1
+matrixStats,anyMissing,0,0,8,list<^logical[] | complex[] | class<`AsIs`>>,1
+matrixStats,anyMissing,0,0,9,list<^integer[] | complex[] | class<`AsIs`>>,1
+matrixStats,anyMissing,0,0,10,list<^double[] | complex[] | class<`AsIs`>>,1
+matrixStats,anyMissing,0,0,11,list<^complex[] | class<`AsIs`>>,1
+matrixStats,anyMissing,0,0,12,list<complex[] | class<`AsIs`>>,1
+matrixStats,anyMissing,1,0,0,null,1
+matrixStats,anyMissing,2,0,0,...,1
+matrixStats,anyValue,-1,0,0,logical,1
+matrixStats,anyValue,-1,0,1,null,1
+matrixStats,anyValue,0,0,0,^character[],1
+matrixStats,anyValue,0,0,1,^double[],1
+matrixStats,anyValue,1,0,0,null,1
+matrixStats,anyValue,2,0,0,character,1
+matrixStats,anyValue,2,0,1,null,1
+matrixStats,anyValue,2,0,2,double,1
+matrixStats,anyValue,3,0,0,logical,1
+matrixStats,anyValue,4,0,0,...,1
+matrixStats,binCounts,-1,0,0,any,1
+matrixStats,binCounts,0,0,0,double[],1
+matrixStats,binCounts,0,0,1,^integer[],1
+matrixStats,binCounts,1,0,0,null,1
+matrixStats,binCounts,2,0,0,double[],1
+matrixStats,binCounts,3,0,0,logical,1
+matrixStats,binCounts,4,0,0,...,1
+matrixStats,binMeans,-1,0,0,any,1
+matrixStats,binMeans,0,0,0,^double[],1
+matrixStats,binMeans,1,0,0,^integer[],1
+matrixStats,binMeans,1,0,1,double[],1
+matrixStats,binMeans,2,0,0,null,1
+matrixStats,binMeans,3,0,0,double[],1
+matrixStats,binMeans,4,0,0,logical,1
+matrixStats,binMeans,5,0,0,logical,1
+matrixStats,binMeans,6,0,0,logical,1
+matrixStats,binMeans,7,0,0,...,1
+matrixStats,colAlls,-1,0,0,^logical[],1
+matrixStats,colAlls,0,0,0,class<`matrix`>,1
+matrixStats,colAlls,1,0,0,null,1
+matrixStats,colAlls,2,0,0,null,1
+matrixStats,colAlls,3,0,0,character,1
+matrixStats,colAlls,3,0,1,double,1
+matrixStats,colAlls,3,0,2,null,1
+matrixStats,colAlls,4,0,0,logical,1
+matrixStats,colAlls,5,0,0,any,1
+matrixStats,colAlls,6,0,0,...,1
+matrixStats,colAnyMissings,-1,0,0,logical[],1
+matrixStats,colAnyMissings,0,0,0,class<`matrix`>,1
+matrixStats,colAnyMissings,1,0,0,null,1
+matrixStats,colAnyMissings,2,0,0,null,1
+matrixStats,colAnyMissings,3,0,0,...,1
+matrixStats,colAnys,-1,0,0,^logical[],1
+matrixStats,colAnys,0,0,0,class<`matrix`>,1
+matrixStats,colAnys,1,0,0,null,1
+matrixStats,colAnys,2,0,0,null,1
+matrixStats,colAnys,3,0,0,character,1
+matrixStats,colAnys,3,0,1,double,1
+matrixStats,colAnys,3,0,2,null,1
+matrixStats,colAnys,4,0,0,logical,1
+matrixStats,colAnys,5,0,0,any,1
+matrixStats,colAnys,6,0,0,...,1
+matrixStats,colAvgsPerRowSet,-1,0,0,class<`matrix`>,1
+matrixStats,colAvgsPerRowSet,0,0,0,class<`matrix`>,1
+matrixStats,colAvgsPerRowSet,1,0,0,class<`matrix`>,1
+matrixStats,colAvgsPerRowSet,1,0,1,null,1
+matrixStats,colAvgsPerRowSet,2,0,0,null,1
+matrixStats,colAvgsPerRowSet,3,0,0,class<`matrix`>,1
+matrixStats,colAvgsPerRowSet,4,0,0,class<`function`>,1
+matrixStats,colAvgsPerRowSet,5,0,0,...,1
+matrixStats,colAvgsPerRowSet,6,0,0,logical,1
+matrixStats,colCollapse,-1,0,0,integer[],1
+matrixStats,colCollapse,0,0,0,class<`matrix`>,1
+matrixStats,colCollapse,1,0,0,double[],1
+matrixStats,colCollapse,2,0,0,null,1
+matrixStats,colCollapse,3,0,0,any,1
+matrixStats,colCollapse,4,0,0,...,1
+matrixStats,colCounts,-1,0,0,^integer[],1
+matrixStats,colCounts,0,0,0,class<`matrix`>,1
+matrixStats,colCounts,1,0,0,null,1
+matrixStats,colCounts,2,0,0,null,1
+matrixStats,colCounts,3,0,0,character,1
+matrixStats,colCounts,3,0,1,double,1
+matrixStats,colCounts,3,0,2,null,1
+matrixStats,colCounts,3,0,3,raw,1
+matrixStats,colCounts,4,0,0,any,1
+matrixStats,colCounts,5,0,0,integer[],1
+matrixStats,colCounts,6,0,0,...,1
+matrixStats,colCummaxs,-1,0,0,class<`matrix`>,1
+matrixStats,colCummaxs,0,0,0,class<`matrix`>,1
+matrixStats,colCummaxs,1,0,0,null,1
+matrixStats,colCummaxs,2,0,0,null,1
+matrixStats,colCummaxs,3,0,0,integer[],1
+matrixStats,colCummaxs,4,0,0,...,1
+matrixStats,colCummins,-1,0,0,class<`matrix`>,1
+matrixStats,colCummins,0,0,0,class<`matrix`>,1
+matrixStats,colCummins,1,0,0,null,1
+matrixStats,colCummins,2,0,0,null,1
+matrixStats,colCummins,3,0,0,integer[],1
+matrixStats,colCummins,4,0,0,...,1
+matrixStats,colCumprods,-1,0,0,class<`matrix`>,1
+matrixStats,colCumprods,0,0,0,class<`matrix`>,1
+matrixStats,colCumprods,1,0,0,null,1
+matrixStats,colCumprods,2,0,0,null,1
+matrixStats,colCumprods,3,0,0,integer[],1
+matrixStats,colCumprods,4,0,0,...,1
+matrixStats,colCumsums,-1,0,0,class<`matrix`>,1
+matrixStats,colCumsums,0,0,0,class<`matrix`>,1
+matrixStats,colCumsums,1,0,0,null,1
+matrixStats,colCumsums,2,0,0,null,1
+matrixStats,colCumsums,3,0,0,integer[],1
+matrixStats,colCumsums,4,0,0,...,1
+matrixStats,colDiffs,-1,0,0,class<`matrix`>,1
+matrixStats,colDiffs,0,0,0,class<`matrix`>,1
+matrixStats,colDiffs,1,0,0,null,1
+matrixStats,colDiffs,2,0,0,null,1
+matrixStats,colDiffs,3,0,0,integer,1
+matrixStats,colDiffs,4,0,0,integer,1
+matrixStats,colDiffs,5,0,0,integer[],1
+matrixStats,colDiffs,6,0,0,...,1
+matrixStats,colIQRs,-1,0,0,^double[],1
+matrixStats,colIQRs,0,0,0,class<`matrix`>,1
+matrixStats,colIQRs,1,0,0,null,1
+matrixStats,colIQRs,2,0,0,null,1
+matrixStats,colIQRs,3,0,0,any,1
+matrixStats,colIQRs,4,0,0,...,1
+matrixStats,colLogSumExps,-1,0,0,^double[],1
+matrixStats,colLogSumExps,0,0,0,class<`matrix`>,1
+matrixStats,colLogSumExps,1,0,0,null,1
+matrixStats,colLogSumExps,2,0,0,null,1
+matrixStats,colLogSumExps,2,0,1,integer[],1
+matrixStats,colLogSumExps,3,0,0,logical,1
+matrixStats,colLogSumExps,4,0,0,integer[],1
+matrixStats,colLogSumExps,5,0,0,...,1
+matrixStats,colMads,-1,0,0,^double[],1
+matrixStats,colMads,0,0,0,class<`matrix`>,1
+matrixStats,colMads,1,0,0,null,1
+matrixStats,colMads,2,0,0,null,1
+matrixStats,colMads,3,0,0,null,1
+matrixStats,colMads,3,0,1,double[],1
+matrixStats,colMads,4,0,0,double,1
+matrixStats,colMads,5,0,0,logical,1
+matrixStats,colMads,6,0,0,any,1
+matrixStats,colMads,7,0,0,...,1
+matrixStats,colMaxs,-1,0,0,^double[],1
+matrixStats,colMaxs,0,0,0,class<`matrix`>,1
+matrixStats,colMaxs,1,0,0,null,1
+matrixStats,colMaxs,2,0,0,null,1
+matrixStats,colMaxs,3,0,0,logical,1
+matrixStats,colMaxs,4,0,0,integer[],1
+matrixStats,colMaxs,5,0,0,...,1
+matrixStats,colMeans2,-1,0,0,^double[],1
+matrixStats,colMeans2,0,0,0,class<`matrix`>,1
+matrixStats,colMeans2,1,0,0,null,1
+matrixStats,colMeans2,2,0,0,null,1
+matrixStats,colMeans2,3,0,0,logical,1
+matrixStats,colMeans2,4,0,0,integer[],1
+matrixStats,colMeans2,5,0,0,...,1
+matrixStats,colMedians,-1,0,0,^double[],1
+matrixStats,colMedians,0,0,0,class<`matrix`>,1
+matrixStats,colMedians,1,0,0,null,1
+matrixStats,colMedians,2,0,0,null,1
+matrixStats,colMedians,3,0,0,logical,1
+matrixStats,colMedians,4,0,0,integer[],1
+matrixStats,colMedians,5,0,0,...,1
+matrixStats,colMins,-1,0,0,^double[],1
+matrixStats,colMins,0,0,0,class<`matrix`>,1
+matrixStats,colMins,1,0,0,null,1
+matrixStats,colMins,2,0,0,null,1
+matrixStats,colMins,3,0,0,logical,1
+matrixStats,colMins,4,0,0,integer[],1
+matrixStats,colMins,5,0,0,...,1
+matrixStats,colOrderStats,-1,0,0,double[],1
+matrixStats,colOrderStats,0,0,0,class<`matrix`>,1
+matrixStats,colOrderStats,1,0,0,null,1
+matrixStats,colOrderStats,2,0,0,null,1
+matrixStats,colOrderStats,3,0,0,double,1
+matrixStats,colOrderStats,4,0,0,integer[],1
+matrixStats,colOrderStats,5,0,0,...,1
+matrixStats,colProds,-1,0,0,^double[],1
+matrixStats,colProds,0,0,0,class<`matrix`>,1
+matrixStats,colProds,1,0,0,null,1
+matrixStats,colProds,2,0,0,null,1
+matrixStats,colProds,3,0,0,logical,1
+matrixStats,colProds,4,0,0,any,1
+matrixStats,colProds,5,0,0,...,1
+matrixStats,colQuantiles,-1,0,0,class<`matrix`>,1
+matrixStats,colQuantiles,-1,0,1,double[],1
+matrixStats,colQuantiles,0,0,0,class<`matrix`>,1
+matrixStats,colQuantiles,1,0,0,null,1
+matrixStats,colQuantiles,2,0,0,null,1
+matrixStats,colQuantiles,3,0,0,double[],1
+matrixStats,colQuantiles,4,0,0,any,1
+matrixStats,colQuantiles,5,0,0,integer,1
+matrixStats,colQuantiles,6,0,0,...,1
+matrixStats,colQuantiles,7,0,0,logical,1
+matrixStats,colRanges,-1,0,0,class<`matrix`>,1
+matrixStats,colRanges,0,0,0,class<`matrix`>,1
+matrixStats,colRanges,1,0,0,null,1
+matrixStats,colRanges,2,0,0,null,1
+matrixStats,colRanges,3,0,0,logical,1
+matrixStats,colRanges,4,0,0,integer[],1
+matrixStats,colRanges,5,0,0,...,1
+matrixStats,colRanks,-1,0,0,any,1
+matrixStats,colRanks,0,0,0,any,1
+matrixStats,colRanks,1,0,0,null,1
+matrixStats,colRanks,2,0,0,null,1
+matrixStats,colRanks,3,0,0,character,1
+matrixStats,colRanks,4,0,0,any,1
+matrixStats,colRanks,5,0,0,logical,1
+matrixStats,colRanks,6,0,0,...,1
+matrixStats,colSds,-1,0,0,^double[],1
+matrixStats,colSds,-1,0,1,null,1
+matrixStats,colSds,0,0,0,class<`matrix`>,1
+matrixStats,colSds,1,0,0,null,1
+matrixStats,colSds,2,0,0,null,1
+matrixStats,colSds,3,0,0,any,1
+matrixStats,colSds,4,0,0,^double[],1
+matrixStats,colSds,4,0,1,null,1
+matrixStats,colSds,5,0,0,integer[],1
+matrixStats,colSds,6,0,0,...,1
+matrixStats,colSums2,-1,0,0,^double[],1
+matrixStats,colSums2,0,0,0,class<`matrix`>,1
+matrixStats,colSums2,1,0,0,null,1
+matrixStats,colSums2,2,0,0,null,1
+matrixStats,colSums2,3,0,0,logical,1
+matrixStats,colSums2,4,0,0,integer[],1
+matrixStats,colSums2,5,0,0,...,1
+matrixStats,colTabulates,-1,0,0,class<`matrix`>,1
+matrixStats,colTabulates,0,0,0,class<`matrix`>,1
+matrixStats,colTabulates,1,0,0,null,1
+matrixStats,colTabulates,2,0,0,null,1
+matrixStats,colTabulates,3,0,0,^integer[],1
+matrixStats,colTabulates,3,0,1,null,1
+matrixStats,colTabulates,3,0,2,raw[],1
+matrixStats,colTabulates,4,0,0,...,1
+matrixStats,colVars,-1,0,0,^double[],1
+matrixStats,colVars,-1,0,1,null,1
+matrixStats,colVars,0,0,0,class<`matrix`>,1
+matrixStats,colVars,1,0,0,null,1
+matrixStats,colVars,2,0,0,null,1
+matrixStats,colVars,3,0,0,any,1
+matrixStats,colVars,4,0,0,^double[],1
+matrixStats,colVars,4,0,1,null,1
+matrixStats,colVars,5,0,0,integer[],1
+matrixStats,colVars,6,0,0,...,1
+matrixStats,colWeightedMads,-1,0,0,^double[],1
+matrixStats,colWeightedMads,0,0,0,class<`matrix`>,1
+matrixStats,colWeightedMads,1,0,0,double[],1
+matrixStats,colWeightedMads,2,0,0,null,1
+matrixStats,colWeightedMads,3,0,0,null,1
+matrixStats,colWeightedMads,4,0,0,logical,1
+matrixStats,colWeightedMads,5,0,0,double,1
+matrixStats,colWeightedMads,6,0,0,null,1
+matrixStats,colWeightedMads,7,0,0,...,1
+matrixStats,colWeightedMeans,-1,0,0,^double[],1
+matrixStats,colWeightedMeans,0,0,0,class<`matrix`>,1
+matrixStats,colWeightedMeans,1,0,0,^integer[],1
+matrixStats,colWeightedMeans,1,0,1,null,1
+matrixStats,colWeightedMeans,1,0,2,double[],1
+matrixStats,colWeightedMeans,2,0,0,null,1
+matrixStats,colWeightedMeans,3,0,0,null,1
+matrixStats,colWeightedMeans,4,0,0,logical,1
+matrixStats,colWeightedMeans,5,0,0,...,1
+matrixStats,colWeightedMedians,-1,0,0,^double[],1
+matrixStats,colWeightedMedians,0,0,0,class<`matrix`>,1
+matrixStats,colWeightedMedians,1,0,0,double[],1
+matrixStats,colWeightedMedians,1,0,1,null,1
+matrixStats,colWeightedMedians,2,0,0,null,1
+matrixStats,colWeightedMedians,3,0,0,null,1
+matrixStats,colWeightedMedians,4,0,0,logical,1
+matrixStats,colWeightedMedians,5,0,0,...,1
+matrixStats,colWeightedSds,-1,0,0,^double[],1
+matrixStats,colWeightedSds,0,0,0,class<`matrix`>,1
+matrixStats,colWeightedSds,1,0,0,double[],1
+matrixStats,colWeightedSds,2,0,0,null,1
+matrixStats,colWeightedSds,3,0,0,null,1
+matrixStats,colWeightedSds,4,0,0,logical,1
+matrixStats,colWeightedSds,5,0,0,...,1
+matrixStats,colWeightedVars,-1,0,0,^double[],1
+matrixStats,colWeightedVars,0,0,0,class<`matrix`>,1
+matrixStats,colWeightedVars,1,0,0,double[],1
+matrixStats,colWeightedVars,2,0,0,null,1
+matrixStats,colWeightedVars,3,0,0,null,1
+matrixStats,colWeightedVars,4,0,0,logical,1
+matrixStats,colWeightedVars,5,0,0,...,1
+matrixStats,count,-1,0,0,integer,1
+matrixStats,count,-1,0,1,null,1
+matrixStats,count,0,0,0,^character[],1
+matrixStats,count,0,0,1,^double[],1
+matrixStats,count,1,0,0,null,1
+matrixStats,count,2,0,0,character,1
+matrixStats,count,2,0,1,null,1
+matrixStats,count,2,0,2,double,1
+matrixStats,count,3,0,0,any,1
+matrixStats,count,4,0,0,...,1
+matrixStats,diff2,-1,0,0,^double[],1
+matrixStats,diff2,-1,0,1,null,1
+matrixStats,diff2,0,0,0,^double[],1
+matrixStats,diff2,1,0,0,null,1
+matrixStats,diff2,2,0,0,integer,1
+matrixStats,diff2,3,0,0,integer,1
+matrixStats,diff2,4,0,0,...,1
+matrixStats,indexByRow,-1,0,0,any,1
+matrixStats,indexByRow,0,0,0,class<`matrix`>,1
+matrixStats,indexByRow,0,0,1,double[],1
+matrixStats,indexByRow,1,0,0,double[],1
+matrixStats,indexByRow,1,0,1,null,1
+matrixStats,indexByRow,2,0,0,...,1
+matrixStats,iqr,-1,0,0,double,1
+matrixStats,iqr,-1,0,1,null,1
+matrixStats,iqr,0,0,0,^double[],1
+matrixStats,iqr,1,0,0,null,1
+matrixStats,iqr,2,0,0,logical,1
+matrixStats,iqr,3,0,0,...,1
+matrixStats,iqrDiff,-1,0,0,double,1
+matrixStats,iqrDiff,-1,0,1,null,1
+matrixStats,iqrDiff,0,0,0,double[],1
+matrixStats,iqrDiff,1,0,0,null,1
+matrixStats,iqrDiff,2,0,0,logical,1
+matrixStats,iqrDiff,3,0,0,integer,1
+matrixStats,iqrDiff,4,0,0,double,1
+matrixStats,iqrDiff,5,0,0,...,1
+matrixStats,logSumExp,-1,0,0,double,1
+matrixStats,logSumExp,-1,0,1,null,1
+matrixStats,logSumExp,0,0,0,^double[],1
+matrixStats,logSumExp,0,0,1,null,1
+matrixStats,logSumExp,1,0,0,null,1
+matrixStats,logSumExp,2,0,0,logical,1
+matrixStats,logSumExp,3,0,0,...,1
+matrixStats,madDiff,-1,0,0,double,1
+matrixStats,madDiff,-1,0,1,null,1
+matrixStats,madDiff,0,0,0,double[],1
+matrixStats,madDiff,1,0,0,null,1
+matrixStats,madDiff,2,0,0,logical,1
+matrixStats,madDiff,3,0,0,integer,1
+matrixStats,madDiff,4,0,0,double,1
+matrixStats,madDiff,5,0,0,double,1
+matrixStats,madDiff,6,0,0,...,1
+matrixStats,mean2,-1,0,0,double,1
+matrixStats,mean2,-1,0,1,null,1
+matrixStats,mean2,0,0,0,^double[],1
+matrixStats,mean2,1,0,0,null,1
+matrixStats,mean2,1,0,1,double[],1
+matrixStats,mean2,2,0,0,logical,1
+matrixStats,mean2,3,0,0,logical,1
+matrixStats,mean2,4,0,0,...,1
+matrixStats,product,-1,0,0,double,1
+matrixStats,product,-1,0,1,null,1
+matrixStats,product,0,0,0,^double[],1
+matrixStats,product,1,0,0,null,1
+matrixStats,product,2,0,0,logical,1
+matrixStats,product,3,0,0,...,1
+matrixStats,rowAlls,-1,0,0,^logical[],1
+matrixStats,rowAlls,0,0,0,class<`matrix`>,1
+matrixStats,rowAlls,1,0,0,null,1
+matrixStats,rowAlls,2,0,0,null,1
+matrixStats,rowAlls,3,0,0,character,1
+matrixStats,rowAlls,3,0,1,integer,1
+matrixStats,rowAlls,3,0,2,null,1
+matrixStats,rowAlls,4,0,0,logical,1
+matrixStats,rowAlls,5,0,0,any,1
+matrixStats,rowAlls,6,0,0,...,1
+matrixStats,rowAnyMissings,-1,0,0,logical[],1
+matrixStats,rowAnyMissings,0,0,0,class<`matrix`>,1
+matrixStats,rowAnyMissings,1,0,0,null,1
+matrixStats,rowAnyMissings,2,0,0,null,1
+matrixStats,rowAnyMissings,3,0,0,...,1
+matrixStats,rowAnys,-1,0,0,^logical[],1
+matrixStats,rowAnys,0,0,0,class<`matrix`>,1
+matrixStats,rowAnys,1,0,0,null,1
+matrixStats,rowAnys,2,0,0,null,1
+matrixStats,rowAnys,3,0,0,character,1
+matrixStats,rowAnys,3,0,1,double,1
+matrixStats,rowAnys,3,0,2,null,1
+matrixStats,rowAnys,4,0,0,logical,1
+matrixStats,rowAnys,5,0,0,any,1
+matrixStats,rowAnys,6,0,0,...,1
+matrixStats,rowAvgsPerColSet,-1,0,0,class<`matrix`>,1
+matrixStats,rowAvgsPerColSet,0,0,0,class<`matrix`>,1
+matrixStats,rowAvgsPerColSet,1,0,0,null,1
+matrixStats,rowAvgsPerColSet,1,0,1,class<`matrix`>,1
+matrixStats,rowAvgsPerColSet,2,0,0,double,1
+matrixStats,rowAvgsPerColSet,2,0,1,null,1
+matrixStats,rowAvgsPerColSet,3,0,0,class<`matrix`>,1
+matrixStats,rowAvgsPerColSet,4,0,0,class<`function`>,1
+matrixStats,rowAvgsPerColSet,5,0,0,...,1
+matrixStats,rowAvgsPerColSet,6,0,0,logical,1
+matrixStats,rowCollapse,-1,0,0,integer[],1
+matrixStats,rowCollapse,0,0,0,class<`matrix`>,1
+matrixStats,rowCollapse,1,0,0,double[],1
+matrixStats,rowCollapse,2,0,0,null,1
+matrixStats,rowCollapse,3,0,0,any,1
+matrixStats,rowCollapse,4,0,0,...,1
+matrixStats,rowCounts,-1,0,0,^integer[],1
+matrixStats,rowCounts,0,0,0,class<`matrix`>,1
+matrixStats,rowCounts,1,0,0,null,1
+matrixStats,rowCounts,2,0,0,null,1
+matrixStats,rowCounts,3,0,0,character,1
+matrixStats,rowCounts,3,0,1,double,1
+matrixStats,rowCounts,3,0,2,null,1
+matrixStats,rowCounts,3,0,3,raw,1
+matrixStats,rowCounts,4,0,0,any,1
+matrixStats,rowCounts,5,0,0,integer[],1
+matrixStats,rowCounts,6,0,0,...,1
+matrixStats,rowCummaxs,-1,0,0,class<`matrix`>,1
+matrixStats,rowCummaxs,0,0,0,class<`matrix`>,1
+matrixStats,rowCummaxs,1,0,0,null,1
+matrixStats,rowCummaxs,2,0,0,null,1
+matrixStats,rowCummaxs,3,0,0,integer[],1
+matrixStats,rowCummaxs,4,0,0,...,1
+matrixStats,rowCummins,-1,0,0,class<`matrix`>,1
+matrixStats,rowCummins,0,0,0,class<`matrix`>,1
+matrixStats,rowCummins,1,0,0,null,1
+matrixStats,rowCummins,2,0,0,null,1
+matrixStats,rowCummins,3,0,0,integer[],1
+matrixStats,rowCummins,4,0,0,...,1
+matrixStats,rowCumprods,-1,0,0,class<`matrix`>,1
+matrixStats,rowCumprods,0,0,0,class<`matrix`>,1
+matrixStats,rowCumprods,1,0,0,null,1
+matrixStats,rowCumprods,2,0,0,null,1
+matrixStats,rowCumprods,3,0,0,integer[],1
+matrixStats,rowCumprods,4,0,0,...,1
+matrixStats,rowCumsums,-1,0,0,class<`matrix`>,1
+matrixStats,rowCumsums,0,0,0,class<`matrix`>,1
+matrixStats,rowCumsums,1,0,0,null,1
+matrixStats,rowCumsums,2,0,0,null,1
+matrixStats,rowCumsums,3,0,0,integer[],1
+matrixStats,rowCumsums,4,0,0,...,1
+matrixStats,rowDiffs,-1,0,0,class<`matrix`>,1
+matrixStats,rowDiffs,0,0,0,class<`matrix`>,1
+matrixStats,rowDiffs,1,0,0,null,1
+matrixStats,rowDiffs,2,0,0,null,1
+matrixStats,rowDiffs,3,0,0,integer,1
+matrixStats,rowDiffs,4,0,0,integer,1
+matrixStats,rowDiffs,5,0,0,integer[],1
+matrixStats,rowDiffs,6,0,0,...,1
+matrixStats,rowIQRs,-1,0,0,^double[],1
+matrixStats,rowIQRs,0,0,0,class<`matrix`>,1
+matrixStats,rowIQRs,1,0,0,null,1
+matrixStats,rowIQRs,2,0,0,null,1
+matrixStats,rowIQRs,3,0,0,any,1
+matrixStats,rowIQRs,4,0,0,...,1
+matrixStats,rowLogSumExps,-1,0,0,^double[],1
+matrixStats,rowLogSumExps,0,0,0,class<`matrix`>,1
+matrixStats,rowLogSumExps,1,0,0,null,1
+matrixStats,rowLogSumExps,1,0,1,double,1
+matrixStats,rowLogSumExps,2,0,0,null,1
+matrixStats,rowLogSumExps,3,0,0,logical,1
+matrixStats,rowLogSumExps,4,0,0,integer[],1
+matrixStats,rowLogSumExps,5,0,0,...,1
+matrixStats,rowMads,-1,0,0,^double[],1
+matrixStats,rowMads,0,0,0,class<`matrix`>,1
+matrixStats,rowMads,1,0,0,null,1
+matrixStats,rowMads,2,0,0,null,1
+matrixStats,rowMads,3,0,0,null,1
+matrixStats,rowMads,3,0,1,double[],1
+matrixStats,rowMads,4,0,0,double,1
+matrixStats,rowMads,5,0,0,logical,1
+matrixStats,rowMads,6,0,0,any,1
+matrixStats,rowMads,7,0,0,...,1
+matrixStats,rowMaxs,-1,0,0,^double[],1
+matrixStats,rowMaxs,0,0,0,class<`matrix`>,1
+matrixStats,rowMaxs,1,0,0,null,1
+matrixStats,rowMaxs,2,0,0,null,1
+matrixStats,rowMaxs,3,0,0,logical,1
+matrixStats,rowMaxs,4,0,0,integer[],1
+matrixStats,rowMaxs,5,0,0,...,1
+matrixStats,rowMeans2,-1,0,0,^double[],1
+matrixStats,rowMeans2,0,0,0,class<`matrix`>,1
+matrixStats,rowMeans2,1,0,0,null,1
+matrixStats,rowMeans2,2,0,0,null,1
+matrixStats,rowMeans2,3,0,0,logical,1
+matrixStats,rowMeans2,4,0,0,integer[],1
+matrixStats,rowMeans2,5,0,0,...,1
+matrixStats,rowMedians,-1,0,0,^double[],1
+matrixStats,rowMedians,0,0,0,class<`matrix`>,1
+matrixStats,rowMedians,1,0,0,null,1
+matrixStats,rowMedians,2,0,0,null,1
+matrixStats,rowMedians,3,0,0,logical,1
+matrixStats,rowMedians,4,0,0,integer[],1
+matrixStats,rowMedians,5,0,0,...,1
+matrixStats,rowMins,-1,0,0,^double[],1
+matrixStats,rowMins,0,0,0,class<`matrix`>,1
+matrixStats,rowMins,1,0,0,null,1
+matrixStats,rowMins,2,0,0,null,1
+matrixStats,rowMins,3,0,0,logical,1
+matrixStats,rowMins,4,0,0,integer[],1
+matrixStats,rowMins,5,0,0,...,1
+matrixStats,rowOrderStats,-1,0,0,double[],1
+matrixStats,rowOrderStats,0,0,0,class<`matrix`>,1
+matrixStats,rowOrderStats,1,0,0,null,1
+matrixStats,rowOrderStats,2,0,0,null,1
+matrixStats,rowOrderStats,3,0,0,double,1
+matrixStats,rowOrderStats,4,0,0,integer[],1
+matrixStats,rowOrderStats,5,0,0,...,1
+matrixStats,rowProds,-1,0,0,^double[],1
+matrixStats,rowProds,0,0,0,class<`matrix`>,1
+matrixStats,rowProds,1,0,0,null,1
+matrixStats,rowProds,2,0,0,null,1
+matrixStats,rowProds,3,0,0,logical,1
+matrixStats,rowProds,4,0,0,any,1
+matrixStats,rowProds,5,0,0,...,1
+matrixStats,rowQuantiles,-1,0,0,class<`matrix`>,1
+matrixStats,rowQuantiles,-1,0,1,double[],1
+matrixStats,rowQuantiles,0,0,0,class<`matrix`>,1
+matrixStats,rowQuantiles,1,0,0,null,1
+matrixStats,rowQuantiles,2,0,0,null,1
+matrixStats,rowQuantiles,3,0,0,double[],1
+matrixStats,rowQuantiles,4,0,0,any,1
+matrixStats,rowQuantiles,5,0,0,integer,1
+matrixStats,rowQuantiles,6,0,0,...,1
+matrixStats,rowQuantiles,7,0,0,logical,1
+matrixStats,rowRanges,-1,0,0,class<`matrix`>,1
+matrixStats,rowRanges,0,0,0,class<`matrix`>,1
+matrixStats,rowRanges,1,0,0,null,1
+matrixStats,rowRanges,2,0,0,null,1
+matrixStats,rowRanges,3,0,0,logical,1
+matrixStats,rowRanges,4,0,0,integer[],1
+matrixStats,rowRanges,5,0,0,...,1
+matrixStats,rowRanks,-1,0,0,any,1
+matrixStats,rowRanks,0,0,0,any,1
+matrixStats,rowRanks,1,0,0,null,1
+matrixStats,rowRanks,2,0,0,null,1
+matrixStats,rowRanks,3,0,0,character,1
+matrixStats,rowRanks,4,0,0,any,1
+matrixStats,rowRanks,5,0,0,...,1
+matrixStats,rowSds,-1,0,0,^double[],1
+matrixStats,rowSds,-1,0,1,null,1
+matrixStats,rowSds,0,0,0,class<`matrix`>,1
+matrixStats,rowSds,1,0,0,null,1
+matrixStats,rowSds,2,0,0,null,1
+matrixStats,rowSds,3,0,0,any,1
+matrixStats,rowSds,4,0,0,^double[],1
+matrixStats,rowSds,4,0,1,null,1
+matrixStats,rowSds,5,0,0,integer[],1
+matrixStats,rowSds,6,0,0,...,1
+matrixStats,rowSums2,-1,0,0,^double[],1
+matrixStats,rowSums2,0,0,0,class<`matrix`>,1
+matrixStats,rowSums2,1,0,0,null,1
+matrixStats,rowSums2,2,0,0,null,1
+matrixStats,rowSums2,3,0,0,logical,1
+matrixStats,rowSums2,4,0,0,integer[],1
+matrixStats,rowSums2,5,0,0,...,1
+matrixStats,rowTabulates,-1,0,0,class<`matrix`>,1
+matrixStats,rowTabulates,0,0,0,class<`matrix`>,1
+matrixStats,rowTabulates,1,0,0,null,1
+matrixStats,rowTabulates,2,0,0,null,1
+matrixStats,rowTabulates,3,0,0,^integer[],1
+matrixStats,rowTabulates,3,0,1,null,1
+matrixStats,rowTabulates,3,0,2,raw[],1
+matrixStats,rowTabulates,4,0,0,...,1
+matrixStats,rowVars,-1,0,0,^double[],1
+matrixStats,rowVars,-1,0,1,null,1
+matrixStats,rowVars,0,0,0,class<`matrix`>,1
+matrixStats,rowVars,1,0,0,null,1
+matrixStats,rowVars,2,0,0,null,1
+matrixStats,rowVars,3,0,0,any,1
+matrixStats,rowVars,4,0,0,^double[],1
+matrixStats,rowVars,4,0,1,null,1
+matrixStats,rowVars,5,0,0,integer[],1
+matrixStats,rowVars,6,0,0,...,1
+matrixStats,rowWeightedMads,-1,0,0,^double[],1
+matrixStats,rowWeightedMads,0,0,0,class<`matrix`>,1
+matrixStats,rowWeightedMads,1,0,0,double[],1
+matrixStats,rowWeightedMads,2,0,0,null,1
+matrixStats,rowWeightedMads,3,0,0,null,1
+matrixStats,rowWeightedMads,4,0,0,logical,1
+matrixStats,rowWeightedMads,5,0,0,double,1
+matrixStats,rowWeightedMads,6,0,0,null,1
+matrixStats,rowWeightedMads,7,0,0,...,1
+matrixStats,rowWeightedMeans,-1,0,0,^double[],1
+matrixStats,rowWeightedMeans,0,0,0,class<`matrix`>,1
+matrixStats,rowWeightedMeans,1,0,0,^integer[],1
+matrixStats,rowWeightedMeans,1,0,1,null,1
+matrixStats,rowWeightedMeans,1,0,2,double[],1
+matrixStats,rowWeightedMeans,2,0,0,null,1
+matrixStats,rowWeightedMeans,3,0,0,null,1
+matrixStats,rowWeightedMeans,4,0,0,logical,1
+matrixStats,rowWeightedMeans,5,0,0,...,1
+matrixStats,rowWeightedMedians,-1,0,0,^double[],1
+matrixStats,rowWeightedMedians,0,0,0,class<`matrix`>,1
+matrixStats,rowWeightedMedians,1,0,0,double[],1
+matrixStats,rowWeightedMedians,1,0,1,null,1
+matrixStats,rowWeightedMedians,2,0,0,null,1
+matrixStats,rowWeightedMedians,3,0,0,null,1
+matrixStats,rowWeightedMedians,4,0,0,logical,1
+matrixStats,rowWeightedMedians,5,0,0,...,1
+matrixStats,rowWeightedSds,-1,0,0,^double[],1
+matrixStats,rowWeightedSds,0,0,0,class<`matrix`>,1
+matrixStats,rowWeightedSds,1,0,0,double[],1
+matrixStats,rowWeightedSds,2,0,0,null,1
+matrixStats,rowWeightedSds,3,0,0,null,1
+matrixStats,rowWeightedSds,4,0,0,logical,1
+matrixStats,rowWeightedSds,5,0,0,...,1
+matrixStats,rowWeightedVars,-1,0,0,^double[],1
+matrixStats,rowWeightedVars,0,0,0,class<`matrix`>,1
+matrixStats,rowWeightedVars,1,0,0,double[],1
+matrixStats,rowWeightedVars,2,0,0,null,1
+matrixStats,rowWeightedVars,3,0,0,null,1
+matrixStats,rowWeightedVars,4,0,0,logical,1
+matrixStats,rowWeightedVars,5,0,0,...,1
+matrixStats,sdDiff,-1,0,0,double,1
+matrixStats,sdDiff,-1,0,1,null,1
+matrixStats,sdDiff,0,0,0,double[],1
+matrixStats,sdDiff,1,0,0,null,1
+matrixStats,sdDiff,2,0,0,logical,1
+matrixStats,sdDiff,3,0,0,integer,1
+matrixStats,sdDiff,4,0,0,double,1
+matrixStats,sdDiff,5,0,0,...,1
+matrixStats,signTabulate,-1,0,0,double[],1
+matrixStats,signTabulate,0,0,0,^double[],1
+matrixStats,signTabulate,1,0,0,null,1
+matrixStats,signTabulate,2,0,0,...,1
+matrixStats,sum2,-1,0,0,any,1
+matrixStats,sum2,0,0,0,^double[],1
+matrixStats,sum2,0,0,1,null,1
+matrixStats,sum2,1,0,0,null,1
+matrixStats,sum2,1,0,1,double[],1
+matrixStats,sum2,2,0,0,logical,1
+matrixStats,sum2,3,0,0,character,1
+matrixStats,sum2,4,0,0,...,1
+matrixStats,t_tx_OP_y,-1,0,0,class<`matrix`>,1
+matrixStats,t_tx_OP_y,0,0,0,class<`matrix`>,1
+matrixStats,t_tx_OP_y,1,0,0,^double[],1
+matrixStats,t_tx_OP_y,2,0,0,character,1
+matrixStats,t_tx_OP_y,3,0,0,null,1
+matrixStats,t_tx_OP_y,4,0,0,null,1
+matrixStats,t_tx_OP_y,5,0,0,null,1
+matrixStats,t_tx_OP_y,6,0,0,logical,1
+matrixStats,t_tx_OP_y,7,0,0,logical,1
+matrixStats,validateIndices,-1,0,0,double[],1
+matrixStats,validateIndices,0,0,0,double[],1
+matrixStats,validateIndices,1,0,0,double,1
+matrixStats,validateIndices,2,0,0,logical,1
+matrixStats,varDiff,-1,0,0,double,1
+matrixStats,varDiff,-1,0,1,null,1
+matrixStats,varDiff,0,0,0,double[],1
+matrixStats,varDiff,1,0,0,null,1
+matrixStats,varDiff,2,0,0,logical,1
+matrixStats,varDiff,3,0,0,integer,1
+matrixStats,varDiff,4,0,0,double,1
+matrixStats,varDiff,5,0,0,...,1
+matrixStats,weightedMad,-1,0,0,double,1
+matrixStats,weightedMad,-1,0,1,null,1
+matrixStats,weightedMad,0,0,0,integer[],1
+matrixStats,weightedMad,1,0,0,double[],1
+matrixStats,weightedMad,1,0,1,null,1
+matrixStats,weightedMad,2,0,0,null,1
+matrixStats,weightedMad,3,0,0,logical,1
+matrixStats,weightedMad,4,0,0,double,1
+matrixStats,weightedMad,5,0,0,null,1
+matrixStats,weightedMad,6,0,0,...,1
+matrixStats,weightedMean,-1,0,0,double,1
+matrixStats,weightedMean,-1,0,1,null,1
+matrixStats,weightedMean,0,0,0,^double[],1
+matrixStats,weightedMean,1,0,0,^double[],1
+matrixStats,weightedMean,2,0,0,null,1
+matrixStats,weightedMean,3,0,0,logical,1
+matrixStats,weightedMean,4,0,0,logical,1
+matrixStats,weightedMean,5,0,0,...,1
+matrixStats,weightedMedian,-1,0,0,double,1
+matrixStats,weightedMedian,-1,0,1,null,1
+matrixStats,weightedMedian,0,0,0,double[],1
+matrixStats,weightedMedian,0,0,1,null,1
+matrixStats,weightedMedian,1,0,0,null,1
+matrixStats,weightedMedian,1,0,1,^double[],1
+matrixStats,weightedMedian,2,0,0,null,1
+matrixStats,weightedMedian,3,0,0,logical,1
+matrixStats,weightedMedian,3,0,1,null,1
+matrixStats,weightedMedian,4,0,0,logical,1
+matrixStats,weightedMedian,5,0,0,null,1
+matrixStats,weightedMedian,5,0,1,character,1
+matrixStats,weightedMedian,6,0,0,...,1
+matrixStats,weightedVar,-1,0,0,double,1
+matrixStats,weightedVar,-1,0,1,null,1
+matrixStats,weightedVar,0,0,0,^double[],1
+matrixStats,weightedVar,1,0,0,null,1
+matrixStats,weightedVar,1,0,1,^double[],1
+matrixStats,weightedVar,1,0,2,class<`table`>,1
+matrixStats,weightedVar,2,0,0,null,1
+matrixStats,weightedVar,3,0,0,logical,1
+matrixStats,weightedVar,4,0,0,null,1
+matrixStats,weightedVar,5,0,0,...,1
+matrixStats,x_OP_y,-1,0,0,class<`matrix`>,1
+matrixStats,x_OP_y,0,0,0,class<`matrix`>,1
+matrixStats,x_OP_y,1,0,0,^double[],1
+matrixStats,x_OP_y,1,0,1,null,1
+matrixStats,x_OP_y,2,0,0,character,1
+matrixStats,x_OP_y,3,0,0,null,1
+matrixStats,x_OP_y,4,0,0,null,1
+matrixStats,x_OP_y,5,0,0,null,1
+matrixStats,x_OP_y,6,0,0,logical,1
+matrixStats,x_OP_y,7,0,0,logical,1
+matrixcalc,commutation.matrix,-1,0,0,class<`matrix`>,1
+matrixcalc,commutation.matrix,0,0,0,double,1
+matrixcalc,commutation.matrix,1,0,0,double,1
+matrixcalc,creation.matrix,-1,0,0,class<`matrix`>,1
+matrixcalc,creation.matrix,0,0,0,double,1
+matrixcalc,direct.prod,-1,0,0,class<`matrix`>,1
+matrixcalc,direct.prod,0,0,0,class<`matrix`>,1
+matrixcalc,direct.prod,1,0,0,class<`matrix`>,1
+matrixcalc,direct.sum,-1,0,0,class<`matrix`>,1
+matrixcalc,direct.sum,0,0,0,class<`matrix`>,1
+matrixcalc,direct.sum,1,0,0,class<`matrix`>,1
+matrixcalc,D.matrix,-1,0,0,class<`matrix`>,1
+matrixcalc,D.matrix,0,0,0,double,1
+matrixcalc,duplication.matrix,-1,0,0,class<`matrix`>,1
+matrixcalc,duplication.matrix,0,0,0,double,1
+matrixcalc,elimination.matrix,-1,0,0,class<`matrix`>,1
+matrixcalc,elimination.matrix,0,0,0,double,1
+matrixcalc,E.matrices,-1,0,0,list<list<class<`matrix`>>>,1
+matrixcalc,E.matrices,0,0,0,double,1
+matrixcalc,entrywise.norm,-1,0,0,double,1
+matrixcalc,entrywise.norm,0,0,0,class<`matrix`>,1
+matrixcalc,entrywise.norm,1,0,0,double,1
+matrixcalc,fibonacci.matrix,-1,0,0,class<`matrix`>,1
+matrixcalc,fibonacci.matrix,0,0,0,double,1
+matrixcalc,frobenius.matrix,-1,0,0,class<`matrix`>,1
+matrixcalc,frobenius.matrix,0,0,0,double,1
+matrixcalc,frobenius.norm,-1,0,0,double,1
+matrixcalc,frobenius.norm,0,0,0,class<`matrix`>,1
+matrixcalc,frobenius.prod,-1,0,0,double,1
+matrixcalc,frobenius.prod,0,0,0,class<`matrix`>,1
+matrixcalc,frobenius.prod,1,0,0,class<`matrix`>,1
+matrixcalc,hadamard.prod,-1,0,0,class<`matrix`>,1
+matrixcalc,hadamard.prod,0,0,0,class<`matrix`>,1
+matrixcalc,hadamard.prod,1,0,0,class<`matrix`>,1
+matrixcalc,hankel.matrix,-1,0,0,class<`matrix`>,1
+matrixcalc,hankel.matrix,0,0,0,double,1
+matrixcalc,hankel.matrix,1,0,0,integer[],1
+matrixcalc,hilbert.matrix,-1,0,0,class<`matrix`>,1
+matrixcalc,hilbert.matrix,0,0,0,double,1
+matrixcalc,hilbert.schmidt.norm,-1,0,0,double,1
+matrixcalc,hilbert.schmidt.norm,0,0,0,class<`matrix`>,1
+matrixcalc,H.matrices,-1,0,0,list<list<class<`matrix`>>>,1
+matrixcalc,H.matrices,0,0,0,double,1
+matrixcalc,H.matrices,1,0,0,double,1
+matrixcalc,inf.norm,-1,0,0,double,1
+matrixcalc,inf.norm,0,0,0,class<`matrix`>,1
+matrixcalc,is.diagonal.matrix,-1,0,0,logical,1
+matrixcalc,is.diagonal.matrix,0,0,0,class<`matrix`>,1
+matrixcalc,is.diagonal.matrix,1,0,0,double,1
+matrixcalc,is.idempotent.matrix,-1,0,0,logical,1
+matrixcalc,is.idempotent.matrix,0,0,0,class<`matrix`>,1
+matrixcalc,is.idempotent.matrix,1,0,0,double,1
+matrixcalc,is.indefinite,-1,0,0,logical,1
+matrixcalc,is.indefinite,0,0,0,class<`matrix`>,1
+matrixcalc,is.indefinite,1,0,0,double,1
+matrixcalc,is.negative.definite,-1,0,0,logical,1
+matrixcalc,is.negative.definite,0,0,0,class<`matrix`>,1
+matrixcalc,is.negative.definite,1,0,0,double,1
+matrixcalc,is.negative.semi.definite,-1,0,0,logical,1
+matrixcalc,is.negative.semi.definite,0,0,0,class<`matrix`>,1
+matrixcalc,is.negative.semi.definite,1,0,0,double,1
+matrixcalc,is.non.singular.matrix,-1,0,0,logical,1
+matrixcalc,is.non.singular.matrix,0,0,0,class<`matrix`>,1
+matrixcalc,is.non.singular.matrix,1,0,0,double,1
+matrixcalc,is.positive.definite,-1,0,0,logical,1
+matrixcalc,is.positive.definite,0,0,0,class<`matrix`>,1
+matrixcalc,is.positive.definite,1,0,0,double,1
+matrixcalc,is.positive.semi.definite,-1,0,0,logical,1
+matrixcalc,is.positive.semi.definite,0,0,0,class<`matrix`>,1
+matrixcalc,is.positive.semi.definite,1,0,0,double,1
+matrixcalc,is.singular.matrix,-1,0,0,logical,1
+matrixcalc,is.singular.matrix,0,0,0,class<`matrix`>,1
+matrixcalc,is.singular.matrix,1,0,0,double,1
+matrixcalc,is.skew.symmetric.matrix,-1,0,0,logical,1
+matrixcalc,is.skew.symmetric.matrix,0,0,0,class<`matrix`>,1
+matrixcalc,is.skew.symmetric.matrix,1,0,0,double,1
+matrixcalc,is.square.matrix,-1,0,0,logical,1
+matrixcalc,is.square.matrix,0,0,0,class<`matrix`>,1
+matrixcalc,is.symmetric.matrix,-1,0,0,logical,1
+matrixcalc,is.symmetric.matrix,0,0,0,class<`matrix`>,1
+matrixcalc,K.matrix,-1,0,0,class<`matrix`>,1
+matrixcalc,K.matrix,0,0,0,double,1
+matrixcalc,K.matrix,1,0,0,double,1
+matrixcalc,L.matrix,-1,0,0,class<`matrix`>,1
+matrixcalc,L.matrix,0,0,0,double,1
+matrixcalc,lower.triangle,-1,0,0,class<`matrix`>,1
+matrixcalc,lower.triangle,0,0,0,class<`matrix`>,1
+matrixcalc,lu.decomposition,-1,0,0,list<class<`matrix`>>,1
+matrixcalc,lu.decomposition,0,0,0,class<`matrix`>,1
+matrixcalc,matrix.inverse,-1,0,0,class<`matrix`>,1
+matrixcalc,matrix.inverse,0,0,0,class<`matrix`>,1
+matrixcalc,matrix.power,-1,0,0,class<`matrix`>,1
+matrixcalc,matrix.power,0,0,0,class<`matrix`>,1
+matrixcalc,matrix.power,1,0,0,double,1
+matrixcalc,matrix.rank,-1,0,0,integer,1
+matrixcalc,matrix.rank,0,0,0,class<`matrix`>,1
+matrixcalc,matrix.rank,1,0,0,character[],1
+matrixcalc,matrix.trace,-1,0,0,double,1
+matrixcalc,matrix.trace,0,0,0,class<`matrix`>,1
+matrixcalc,maximum.norm,-1,0,0,double,1
+matrixcalc,maximum.norm,0,0,0,class<`matrix`>,1
+matrixcalc,N.matrix,-1,0,0,class<`matrix`>,1
+matrixcalc,N.matrix,0,0,0,double,1
+matrixcalc,one.norm,-1,0,0,double,1
+matrixcalc,one.norm,0,0,0,class<`matrix`>,1
+matrixcalc,pascal.matrix,-1,0,0,class<`matrix`>,1
+matrixcalc,pascal.matrix,0,0,0,double,1
+matrixcalc,%s%,-1,0,0,class<`matrix`>,1
+matrixcalc,%s%,0,0,0,class<`matrix`>,1
+matrixcalc,%s%,1,0,0,class<`matrix`>,1
+matrixcalc,set.submatrix,-1,0,0,class<`matrix`>,1
+matrixcalc,set.submatrix,0,0,0,class<`matrix`>,1
+matrixcalc,set.submatrix,1,0,0,class<`matrix`>,1
+matrixcalc,set.submatrix,2,0,0,double,1
+matrixcalc,set.submatrix,3,0,0,double,1
+matrixcalc,shift.down,-1,0,0,class<`matrix`>,1
+matrixcalc,shift.down,0,0,0,class<`matrix`>,1
+matrixcalc,shift.down,1,0,0,double,1
+matrixcalc,shift.down,2,0,0,double,1
+matrixcalc,shift.left,-1,0,0,class<`matrix`>,1
+matrixcalc,shift.left,0,0,0,class<`matrix`>,1
+matrixcalc,shift.left,1,0,0,double,1
+matrixcalc,shift.left,2,0,0,double,1
+matrixcalc,shift.right,-1,0,0,class<`matrix`>,1
+matrixcalc,shift.right,0,0,0,class<`matrix`>,1
+matrixcalc,shift.right,1,0,0,double,1
+matrixcalc,shift.right,2,0,0,double,1
+matrixcalc,shift.up,-1,0,0,class<`matrix`>,1
+matrixcalc,shift.up,0,0,0,class<`matrix`>,1
+matrixcalc,shift.up,1,0,0,double,1
+matrixcalc,shift.up,2,0,0,double,1
+matrixcalc,spectral.norm,-1,0,0,double,1
+matrixcalc,spectral.norm,0,0,0,class<`matrix`>,1
+matrixcalc,stirling.matrix,-1,0,0,class<`matrix`>,1
+matrixcalc,stirling.matrix,0,0,0,double,1
+matrixcalc,svd.inverse,-1,0,0,class<`matrix`>,1
+matrixcalc,svd.inverse,0,0,0,class<`matrix`>,1
+matrixcalc,symmetric.pascal.matrix,-1,0,0,class<`matrix`>,1
+matrixcalc,symmetric.pascal.matrix,0,0,0,double,1
+matrixcalc,T.matrices,-1,0,0,list<list<class<`matrix`>>>,1
+matrixcalc,T.matrices,0,0,0,double,1
+matrixcalc,toeplitz.matrix,-1,0,0,class<`matrix`>,1
+matrixcalc,toeplitz.matrix,0,0,0,double,1
+matrixcalc,toeplitz.matrix,1,0,0,integer[],1
+matrixcalc,upper.triangle,-1,0,0,class<`matrix`>,1
+matrixcalc,upper.triangle,0,0,0,class<`matrix`>,1
+matrixcalc,u.vectors,-1,0,0,list<class<`matrix`>>,1
+matrixcalc,u.vectors,0,0,0,double,1
+matrixcalc,vandermonde.matrix,-1,0,0,class<`matrix`>,1
+matrixcalc,vandermonde.matrix,0,0,0,double[],1
+matrixcalc,vandermonde.matrix,1,0,0,double,1
+matrixcalc,vec,-1,0,0,class<`matrix`>,1
+matrixcalc,vec,0,0,0,class<`matrix`>,1
+matrixcalc,vech,-1,0,0,class<`matrix`>,1
+matrixcalc,vech,0,0,0,class<`matrix`>,1
+maxLik,activePar,-1,0,0,logical[],1
+maxLik,activePar,0,0,0,"class<`list`, `maxim`>",1
+maxLik,activePar,0,0,1,"class<`list`, `maxLik`, `maxim`>",1
+maxLik,activePar,0,0,2,"class<`maxLik`, `maxim`>",1
+maxLik,activePar,0,0,3,class<`summary.maxLik`>,1
+maxLik,activePar,1,0,0,...,1
+maxLik,activePar.default,-1,0,0,logical[],1
+maxLik,activePar.default,0,0,0,"class<`list`, `maxim`>",1
+maxLik,activePar.default,0,0,1,"class<`list`, `maxLik`, `maxim`>",1
+maxLik,activePar.default,0,0,2,"class<`maxLik`, `maxim`>",1
+maxLik,activePar.default,0,0,3,class<`summary.maxLik`>,1
+maxLik,activePar.default,1,0,0,...,1
+maxLik,addControlDddot,-1,0,0,class<`MaxControl`>,1
+maxLik,addControlDddot,0,0,0,class<`MaxControl`>,1
+maxLik,addControlDddot,1,0,0,...,1
+maxLik,addControlList,-1,0,0,class<`MaxControl`>,1
+maxLik,addControlList,0,0,0,class<`MaxControl`>,1
+maxLik,addControlList,1,0,0,list<any>,1
+maxLik,addControlList,1,0,1,null,1
+maxLik,addControlList,2,0,0,logical,1
+maxLik,addFixedPar,-1,0,0,double[],1
+maxLik,addFixedPar,0,0,0,double[],1
+maxLik,addFixedPar,1,0,0,any,1
+maxLik,addFixedPar,2,0,0,null,1
+maxLik,addFixedPar,2,0,1,logical[],1
+maxLik,addFixedPar,3,0,0,...,1
+maxLik,AIC.maxLik,-1,0,0,double,1
+maxLik,AIC.maxLik,0,0,0,"class<`list`, `maxLik`, `maxim`>",1
+maxLik,AIC.maxLik,1,0,0,...,1
+maxLik,AIC.maxLik,2,0,0,double,1
+maxLik,bread.maxLik,-1,0,0,class<`matrix`>,1
+maxLik,bread.maxLik,0,0,0,"class<`list`, `maxLik`, `maxim`>",1
+maxLik,bread.maxLik,1,0,0,...,1
+maxLik,callWithoutArgs,-1,0,0,class<`matrix`>,1
+maxLik,callWithoutArgs,-1,0,1,double[],1
+maxLik,callWithoutArgs,0,0,0,any,1
+maxLik,callWithoutArgs,1,0,0,character,1
+maxLik,callWithoutArgs,2,0,0,character[],1
+maxLik,callWithoutArgs,3,0,0,...,1
+maxLik,checkBhhhGrad,-1,0,0,any,1
+maxLik,checkBhhhGrad,0,0,0,class<`matrix`>,1
+maxLik,checkBhhhGrad,1,0,0,any,1
+maxLik,checkBhhhGrad,2,0,0,logical,1
+maxLik,checkBhhhGrad,3,0,0,logical[],1
+maxLik,checkFuncArgs,-1,0,0,null,1
+maxLik,checkFuncArgs,0,0,0,class<`function`>,1
+maxLik,checkFuncArgs,1,0,0,any,1
+maxLik,checkFuncArgs,2,0,0,character,1
+maxLik,checkFuncArgs,3,0,0,any,1
+maxLik,coef.maxim,-1,0,0,double[],1
+maxLik,coef.maxim,0,0,0,"class<`list`, `maxim`>",1
+maxLik,coef.maxim,0,0,1,"class<`list`, `maxLik`, `maxim`>",1
+maxLik,coef.maxim,0,0,2,"class<`maxLik`, `maxim`>",1
+maxLik,coef.maxim,1,0,0,...,1
+maxLik,coef.maxLik,-1,0,0,double[],1
+maxLik,coef.maxLik,0,0,0,"class<`list`, `maxim`>",1
+maxLik,coef.maxLik,0,0,1,"class<`list`, `maxLik`, `maxim`>",1
+maxLik,coef.maxLik,0,0,2,"class<`maxLik`, `maxim`>",1
+maxLik,coef.maxLik,1,0,0,...,1
+maxLik,compareDerivatives,-1,0,0,list<double[] | list<double[] | class<`matrix`>>>,1
+maxLik,compareDerivatives,-1,0,1,list<double | list<double | class<`matrix`>>>,1
+maxLik,compareDerivatives,-1,0,2,list<integer[] | double | list<double[] | class<`matrix`>>>,1
+maxLik,compareDerivatives,0,0,0,class<`function`>,1
+maxLik,compareDerivatives,1,0,0,class<`function`>,1
+maxLik,compareDerivatives,2,0,0,null,1
+maxLik,compareDerivatives,3,0,0,double[],1
+maxLik,compareDerivatives,4,0,0,double,1
+maxLik,compareDerivatives,5,0,0,logical,1
+maxLik,compareDerivatives,6,0,0,...,1
+maxLik,condiNumber,-1,0,0,double[],1
+maxLik,condiNumber,0,0,0,class<`matrix`>,1
+maxLik,condiNumber,1,0,0,...,1
+maxLik,condiNumber.default,-1,0,0,double[],1
+maxLik,condiNumber.default,0,0,0,class<`matrix`>,1
+maxLik,condiNumber.default,1,0,0,logical,1
+maxLik,condiNumber.default,2,0,0,logical,1
+maxLik,condiNumber.default,3,0,0,double,1
+maxLik,condiNumber.default,4,0,0,double,1
+maxLik,condiNumber.default,5,0,0,integer,1
+maxLik,condiNumber.default,6,0,0,...,1
+maxLik,constrOptim2,-1,0,0,list<double[] | ^integer[] | null>,1
+maxLik,constrOptim2,0,0,0,double[],1
+maxLik,constrOptim2,1,0,0,class<`function`>,1
+maxLik,constrOptim2,2,0,0,null,1
+maxLik,constrOptim2,3,0,0,class<`matrix`>,1
+maxLik,constrOptim2,4,0,0,double,1
+maxLik,constrOptim2,5,0,0,double,1
+maxLik,constrOptim2,6,0,0,list<double[]>,1
+maxLik,constrOptim2,7,0,0,character,1
+maxLik,constrOptim2,8,0,0,double,1
+maxLik,constrOptim2,9,0,0,double,1
+maxLik,constrOptim2,10,0,0,...,1
+maxLik,estfun.maxLik,-1,0,0,class<`matrix`>,1
+maxLik,estfun.maxLik,0,0,0,"class<`list`, `maxLik`, `maxim`>",1
+maxLik,estfun.maxLik,0,0,1,"class<`maxLik`, `maxim`>",1
+maxLik,estfun.maxLik,1,0,0,...,1
+maxLik,fnSubset,-1,0,0,double,1
+maxLik,fnSubset,0,0,0,double,1
+maxLik,fnSubset,1,0,0,class<`function`>,1
+maxLik,fnSubset,2,0,0,double,1
+maxLik,fnSubset,3,0,0,double[],1
+maxLik,fnSubset,4,0,0,...,1
+maxLik,gradient,-1,0,0,double[],1
+maxLik,gradient,0,0,0,"class<`list`, `maxim`>",1
+maxLik,gradient,0,0,1,"class<`list`, `maxLik`, `maxim`>",1
+maxLik,gradient,0,0,2,"class<`maxLik`, `maxim`>",1
+maxLik,gradient,1,0,0,...,1
+maxLik,gradient.maxim,-1,0,0,double[],1
+maxLik,gradient.maxim,0,0,0,"class<`list`, `maxim`>",1
+maxLik,gradient.maxim,0,0,1,"class<`list`, `maxLik`, `maxim`>",1
+maxLik,gradient.maxim,0,0,2,"class<`maxLik`, `maxim`>",1
+maxLik,gradient.maxim,1,0,0,...,1
+maxLik,hessian,-1,0,0,class<`matrix`>,1
+maxLik,hessian,-1,0,1,null,1
+maxLik,hessian,0,0,0,"class<`list`, `maxLik`, `maxim`>",1
+maxLik,hessian,0,0,1,"class<`maxLik`, `maxim`>",1
+maxLik,hessian,1,0,0,...,1
+maxLik,hessian.default,-1,0,0,class<`matrix`>,1
+maxLik,hessian.default,-1,0,1,null,1
+maxLik,hessian.default,0,0,0,"class<`list`, `maxLik`, `maxim`>",1
+maxLik,hessian.default,0,0,1,"class<`maxLik`, `maxim`>",1
+maxLik,hessian.default,1,0,0,...,1
+maxLik,logLikFunc,-1,0,0,class<`matrix`>,1
+maxLik,logLikFunc,-1,0,1,double[],1
+maxLik,logLikFunc,0,0,0,double[],1
+maxLik,logLikFunc,1,0,0,class<`function`>,1
+maxLik,logLikFunc,2,0,0,any,1
+maxLik,logLikFunc,3,0,0,any,1
+maxLik,logLikFunc,4,0,0,null,1
+maxLik,logLikFunc,4,0,1,double[],1
+maxLik,logLikFunc,5,0,0,null,1
+maxLik,logLikFunc,5,0,1,logical[],1
+maxLik,logLikFunc,6,0,0,logical,1
+maxLik,logLikFunc,7,0,0,...,1
+maxLik,logLikGrad,-1,0,0,double[],1
+maxLik,logLikGrad,-1,0,1,class<`matrix`>,1
+maxLik,logLikGrad,0,0,0,double[],1
+maxLik,logLikGrad,1,0,0,class<`function`>,1
+maxLik,logLikGrad,2,0,0,class<`function`>,1
+maxLik,logLikGrad,2,0,1,null,1
+maxLik,logLikGrad,3,0,0,any,1
+maxLik,logLikGrad,4,0,0,null,1
+maxLik,logLikGrad,4,0,1,double[],1
+maxLik,logLikGrad,5,0,0,null,1
+maxLik,logLikGrad,5,0,1,logical[],1
+maxLik,logLikGrad,6,0,0,logical,1
+maxLik,logLikGrad,7,0,0,null,1
+maxLik,logLikGrad,8,0,0,...,1
+maxLik,logLikHess,-1,0,0,class<`matrix`>,1
+maxLik,logLikHess,0,0,0,double[],1
+maxLik,logLikHess,1,0,0,class<`function`>,1
+maxLik,logLikHess,2,0,0,null,1
+maxLik,logLikHess,3,0,0,null,1
+maxLik,logLikHess,4,0,0,null,1
+maxLik,logLikHess,5,0,0,null,1
+maxLik,logLikHess,6,0,0,null,1
+maxLik,logLikHess,7,0,0,null,1
+maxLik,logLikHess,8,0,0,...,1
+maxLik,logLik.maxLik,-1,0,0,double,1
+maxLik,logLik.maxLik,0,0,0,"class<`list`, `maxLik`, `maxim`>",1
+maxLik,logLik.maxLik,1,0,0,...,1
+maxLik,logLik.summary.maxLik,-1,0,0,double,1
+maxLik,logLik.summary.maxLik,0,0,0,class<`summary.maxLik`>,1
+maxLik,logLik.summary.maxLik,1,0,0,...,1
+maxLik,maxBFGS,-1,0,0,class<`maxim`>,1
+maxLik,maxBFGS,0,0,0,class<`function`>,1
+maxLik,maxBFGS,1,0,0,null,1
+maxLik,maxBFGS,2,0,0,null,1
+maxLik,maxBFGS,3,0,0,double[],1
+maxLik,maxBFGS,4,0,0,null,1
+maxLik,maxBFGS,5,0,0,null,1
+maxLik,maxBFGS,6,0,0,null,1
+maxLik,maxBFGS,7,0,0,logical,1
+maxLik,maxBFGS,8,0,0,double[],1
+maxLik,maxBFGS,9,0,0,...,1
+maxLik,maxBFGSR,-1,0,0,"class<`list`, `maxim`>",1
+maxLik,maxBFGSR,0,0,0,class<`function`>,1
+maxLik,maxBFGSR,1,0,0,null,1
+maxLik,maxBFGSR,2,0,0,null,1
+maxLik,maxBFGSR,3,0,0,double[],1
+maxLik,maxBFGSR,4,0,0,null,1
+maxLik,maxBFGSR,4,0,1,list<class<`matrix`> | double>,1
+maxLik,maxBFGSR,5,0,0,logical,1
+maxLik,maxBFGSR,6,0,0,null,1
+maxLik,maxBFGSR,6,0,1,double,1
+maxLik,maxBFGSR,6,0,2,logical[],1
+maxLik,maxBFGSR,7,0,0,null,1
+maxLik,maxBFGSR,8,0,0,null,1
+maxLik,maxBFGSR,8,0,1,class<`MaxControl`>,1
+maxLik,maxBFGSR,9,0,0,...,1
+maxLik,maxBFGSRCompute,-1,0,0,"class<`list`, `maxim`>",1
+maxLik,maxBFGSRCompute,0,0,0,class<`function`>,1
+maxLik,maxBFGSRCompute,1,0,0,double[],1
+maxLik,maxBFGSRCompute,2,0,0,character,1
+maxLik,maxBFGSRCompute,2,0,1,logical,1
+maxLik,maxBFGSRCompute,3,0,0,logical[],1
+maxLik,maxBFGSRCompute,4,0,0,class<`MaxControl`>,1
+maxLik,maxBFGSRCompute,5,0,0,...,1
+maxLik,maxBHHH,-1,0,0,"class<`list`, `maxim`>",1
+maxLik,maxBHHH,0,0,0,class<`function`>,1
+maxLik,maxBHHH,1,0,0,class<`function`>,1
+maxLik,maxBHHH,2,0,0,null,1
+maxLik,maxBHHH,3,0,0,double,1
+maxLik,maxBHHH,4,0,0,character,1
+maxLik,maxBHHH,5,0,0,...,1
+maxLik,maxControl,-1,0,0,class<`MaxControl`>,1
+maxLik,maxControl,0,0,0,any,1
+maxLik,maxControl,1,0,0,...,1
+maxLik,maxControl,-1,1,0,class<`MaxControl`>,1
+maxLik,maxControl,0,1,0,"class<`list`, `maxLik`, `maxim`>",1
+maxLik,maxControl,0,1,1,"class<`maxLik`, `maxim`>",1
+maxLik,maxControl,1,1,0,...,1
+maxLik,maxControl,-1,2,0,class<`MaxControl`>,1
+maxLik,maxControl,0,2,0,class<`MaxControl`>,1
+maxLik,maxControl,1,2,0,...,1
+maxLik,maxControl,-1,3,0,class<`MaxControl`>,1
+maxLik,maxControl,0,3,0,"class<`list`, `maxim`>",1
+maxLik,maxControl,1,3,0,...,1
+maxLik,maxControl,-1,4,0,class<`MaxControl`>,1
+maxLik,maxControl,0,4,0,any,1
+maxLik,maxControl,1,4,0,...,1
+maxLik,maximMessage,-1,0,0,character,1
+maxLik,maximMessage,0,0,0,double,1
+maxLik,maximType,-1,0,0,character,1
+maxLik,maximType,0,0,0,"class<`list`, `maxim`>",1
+maxLik,maximType,0,0,1,class<`maxim`>,1
+maxLik,maximType,0,0,2,class<`summary.maxLik`>,1
+maxLik,maximType.default,-1,0,0,character,1
+maxLik,maximType.default,0,0,0,class<`summary.maxLik`>,1
+maxLik,maximType.maxim,-1,0,0,character,1
+maxLik,maximType.maxim,0,0,0,"class<`list`, `maxim`>",1
+maxLik,maximType.maxim,0,0,1,class<`maxim`>,1
+maxLik,maxLik,-1,0,0,any,1
+maxLik,maxLik,0,0,0,class<`function`>,1
+maxLik,maxLik,1,0,0,class<`function`>,1
+maxLik,maxLik,1,0,1,null,1
+maxLik,maxLik,2,0,0,class<`function`>,1
+maxLik,maxLik,2,0,1,null,1
+maxLik,maxLik,3,0,0,double[],1
+maxLik,maxLik,4,0,0,any,1
+maxLik,maxLik,5,0,0,null,1
+maxLik,maxLik,6,0,0,...,1
+maxLik,maxNM,-1,0,0,class<`maxim`>,1
+maxLik,maxNM,0,0,0,class<`function`>,1
+maxLik,maxNM,1,0,0,null,1
+maxLik,maxNM,2,0,0,null,1
+maxLik,maxNM,3,0,0,double[],1
+maxLik,maxNM,4,0,0,null,1
+maxLik,maxNM,5,0,0,list<double>,1
+maxLik,maxNM,6,0,0,list<class<`matrix`> | double>,1
+maxLik,maxNM,7,0,0,logical,1
+maxLik,maxNM,8,0,0,double[],1
+maxLik,maxNM,9,0,0,...,1
+maxLik,maxNR,-1,0,0,any,1
+maxLik,maxNR,0,0,0,class<`function`>,1
+maxLik,maxNR,1,0,0,class<`function`>,1
+maxLik,maxNR,1,0,1,null,1
+maxLik,maxNR,2,0,0,class<`function`>,1
+maxLik,maxNR,2,0,1,null,1
+maxLik,maxNR,3,0,0,double[],1
+maxLik,maxNR,4,0,0,null,1
+maxLik,maxNR,4,0,1,list<class<`matrix`> | double>,1
+maxLik,maxNR,5,0,0,logical,1
+maxLik,maxNR,5,0,1,character,1
+maxLik,maxNR,6,0,0,logical,1
+maxLik,maxNR,7,0,0,null,1
+maxLik,maxNR,7,0,1,character,1
+maxLik,maxNR,7,0,2,logical[],1
+maxLik,maxNR,8,0,0,null,1
+maxLik,maxNR,9,0,0,null,1
+maxLik,maxNR,9,0,1,class<`MaxControl`>,1
+maxLik,maxNR,9,0,2,list<double>,1
+maxLik,maxNR,10,0,0,...,1
+maxLik,maxNRCompute,-1,0,0,any,1
+maxLik,maxNRCompute,0,0,0,class<`function`>,1
+maxLik,maxNRCompute,1,0,0,double[],1
+maxLik,maxNRCompute,2,0,0,character,1
+maxLik,maxNRCompute,2,0,1,logical,1
+maxLik,maxNRCompute,3,0,0,logical,1
+maxLik,maxNRCompute,4,0,0,logical[],1
+maxLik,maxNRCompute,5,0,0,class<`MaxControl`>,1
+maxLik,maxNRCompute,6,0,0,...,1
+maxLik,maxOptim,-1,0,0,class<`maxim`>,1
+maxLik,maxOptim,0,0,0,class<`function`>,1
+maxLik,maxOptim,1,0,0,class<`function`>,1
+maxLik,maxOptim,1,0,1,null,1
+maxLik,maxOptim,2,0,0,class<`function`>,1
+maxLik,maxOptim,2,0,1,null,1
+maxLik,maxOptim,3,0,0,double[],1
+maxLik,maxOptim,4,0,0,character,1
+maxLik,maxOptim,5,0,0,null,1
+maxLik,maxOptim,6,0,0,null,1
+maxLik,maxOptim,6,0,1,list<class<`matrix`> | double>,1
+maxLik,maxOptim,7,0,0,logical,1
+maxLik,maxOptim,7,0,1,character,1
+maxLik,maxOptim,8,0,0,double[],1
+maxLik,maxOptim,9,0,0,class<`MaxControl`>,1
+maxLik,maxOptim,10,0,0,...,1
+maxLik,maxValue,-1,0,0,double,1
+maxLik,maxValue,0,0,0,"class<`list`, `maxim`>",1
+maxLik,maxValue,0,0,1,"class<`list`, `maxLik`, `maxim`>",1
+maxLik,maxValue,0,0,2,"class<`maxLik`, `maxim`>",1
+maxLik,maxValue,1,0,0,...,1
+maxLik,maxValue.maxim,-1,0,0,double,1
+maxLik,maxValue.maxim,0,0,0,"class<`list`, `maxim`>",1
+maxLik,maxValue.maxim,0,0,1,"class<`list`, `maxLik`, `maxim`>",1
+maxLik,maxValue.maxim,0,0,2,"class<`maxLik`, `maxim`>",1
+maxLik,maxValue.maxim,1,0,0,...,1
+maxLik,nIter,-1,0,0,double,1
+maxLik,nIter,0,0,0,"class<`list`, `maxim`>",1
+maxLik,nIter,0,0,1,class<`summary.maxLik`>,1
+maxLik,nIter,1,0,0,...,1
+maxLik,nIter.default,-1,0,0,double,1
+maxLik,nIter.default,0,0,0,"class<`list`, `maxim`>",1
+maxLik,nIter.default,0,0,1,class<`summary.maxLik`>,1
+maxLik,nIter.default,1,0,0,...,1
+maxLik,nObs.maxLik,-1,0,0,integer,1
+maxLik,nObs.maxLik,0,0,0,"class<`list`, `maxLik`, `maxim`>",1
+maxLik,nObs.maxLik,1,0,0,...,1
+maxLik,nParam.maxim,-1,0,0,integer,1
+maxLik,nParam.maxim,0,0,0,"class<`list`, `maxLik`, `maxim`>",1
+maxLik,nParam.maxim,0,0,1,"class<`maxLik`, `maxim`>",1
+maxLik,nParam.maxim,1,0,0,logical,1
+maxLik,nParam.maxim,2,0,0,...,1
+maxLik,numericGradient,-1,0,0,class<`matrix`>,1
+maxLik,numericGradient,0,0,0,class<`function`>,1
+maxLik,numericGradient,1,0,0,double[],1
+maxLik,numericGradient,2,0,0,double,1
+maxLik,numericGradient,3,0,0,any,1
+maxLik,numericGradient,4,0,0,...,1
+maxLik,numericHessian,-1,0,0,class<`matrix`>,1
+maxLik,numericHessian,0,0,0,class<`function`>,1
+maxLik,numericHessian,1,0,0,class<`function`>,1
+maxLik,numericHessian,1,0,1,null,1
+maxLik,numericHessian,2,0,0,double[],1
+maxLik,numericHessian,3,0,0,double,1
+maxLik,numericHessian,4,0,0,any,1
+maxLik,numericHessian,5,0,0,...,1
+maxLik,numericNHessian,-1,0,0,class<`matrix`>,1
+maxLik,numericNHessian,0,0,0,class<`function`>,1
+maxLik,numericNHessian,1,0,0,double[],1
+maxLik,numericNHessian,2,0,0,double,1
+maxLik,numericNHessian,3,0,0,any,1
+maxLik,numericNHessian,4,0,0,...,1
+maxLik,objectiveFn,-1,0,0,class<`function`>,1
+maxLik,objectiveFn,0,0,0,"class<`list`, `maxim`>",1
+maxLik,objectiveFn,0,0,1,class<`maxim`>,1
+maxLik,objectiveFn,1,0,0,...,1
+maxLik,objectiveFn.maxim,-1,0,0,class<`function`>,1
+maxLik,objectiveFn.maxim,0,0,0,"class<`list`, `maxim`>",1
+maxLik,objectiveFn.maxim,0,0,1,class<`maxim`>,1
+maxLik,objectiveFn.maxim,1,0,0,...,1
+maxLik,observationGradient,-1,0,0,logical,1
+maxLik,observationGradient,0,0,0,class<`matrix`>,1
+maxLik,observationGradient,0,0,1,double[],1
+maxLik,observationGradient,1,0,0,any,1
+maxLik,openParam,-1,0,0,character[],1
+maxLik,openParam,0,0,0,class<`MaxControl`>,1
+maxLik,prepareFixed,-1,0,0,logical[],1
+maxLik,prepareFixed,0,0,0,double[],1
+maxLik,prepareFixed,1,0,0,logical[],1
+maxLik,prepareFixed,1,0,1,null,1
+maxLik,prepareFixed,2,0,0,null,1
+maxLik,prepareFixed,2,0,1,double,1
+maxLik,prepareFixed,2,0,2,logical[],1
+maxLik,prepareFixed,2,0,3,character,1
+maxLik,print.summary.maxim,-1,0,0,null,1
+maxLik,print.summary.maxim,0,0,0,"class<`list`, `summary.maxim`>",1
+maxLik,print.summary.maxim,1,0,0,...,1
+maxLik,print.summary.maxLik,-1,0,0,null,1
+maxLik,print.summary.maxLik,0,0,0,class<`summary.maxLik`>,1
+maxLik,print.summary.maxLik,1,0,0,integer,1
+maxLik,print.summary.maxLik,2,0,0,...,1
+maxLik,returnCode,-1,0,0,double,1
+maxLik,returnCode,0,0,0,"class<`list`, `maxim`>",1
+maxLik,returnCode,0,0,1,class<`summary.maxLik`>,1
+maxLik,returnCode,1,0,0,...,1
+maxLik,returnCode.default,-1,0,0,double,1
+maxLik,returnCode.default,0,0,0,class<`summary.maxLik`>,1
+maxLik,returnCode.default,1,0,0,...,1
+maxLik,returnCode.maxim,-1,0,0,double,1
+maxLik,returnCode.maxim,0,0,0,"class<`list`, `maxim`>",1
+maxLik,returnCode.maxim,1,0,0,...,1
+maxLik,returnMessage,-1,0,0,character,1
+maxLik,returnMessage,0,0,0,"class<`list`, `maxim`>",1
+maxLik,returnMessage,0,0,1,class<`summary.maxLik`>,1
+maxLik,returnMessage,1,0,0,...,1
+maxLik,returnMessage.default,-1,0,0,character,1
+maxLik,returnMessage.default,0,0,0,class<`summary.maxLik`>,1
+maxLik,returnMessage.default,1,0,0,...,1
+maxLik,returnMessage.maxim,-1,0,0,character,1
+maxLik,returnMessage.maxim,0,0,0,"class<`list`, `maxim`>",1
+maxLik,returnMessage.maxim,1,0,0,...,1
+maxLik,stdEr.maxLik,-1,0,0,double[],1
+maxLik,stdEr.maxLik,-1,0,1,null,1
+maxLik,stdEr.maxLik,0,0,0,"class<`list`, `maxLik`, `maxim`>",1
+maxLik,stdEr.maxLik,0,0,1,"class<`maxLik`, `maxim`>",1
+maxLik,stdEr.maxLik,1,0,0,any,1
+maxLik,stdEr.maxLik,2,0,0,...,1
+maxLik,sumGradients,-1,0,0,^double[],1
+maxLik,sumGradients,0,0,0,class<`matrix`>,1
+maxLik,sumGradients,0,0,1,double[],1
+maxLik,sumGradients,1,0,0,any,1
+maxLik,summary.maxim,-1,0,0,"class<`list`, `summary.maxim`>",1
+maxLik,summary.maxim,0,0,0,"class<`list`, `maxim`>",1
+maxLik,summary.maxim,0,0,1,class<`maxim`>,1
+maxLik,summary.maxim,1,0,0,logical,1
+maxLik,summary.maxim,2,0,0,logical,1
+maxLik,summary.maxim,3,0,0,...,1
+maxLik,summary.maxLik,-1,0,0,class<`summary.maxLik`>,1
+maxLik,summary.maxLik,0,0,0,"class<`list`, `maxLik`, `maxim`>",1
+maxLik,summary.maxLik,0,0,1,"class<`maxLik`, `maxim`>",1
+maxLik,summary.maxLik,1,0,0,double,1
+maxLik,summary.maxLik,2,0,0,...,1
+maxLik,sumt,-1,0,0,"class<`list`, `maxim`>",1
+maxLik,sumt,0,0,0,class<`function`>,1
+maxLik,sumt,1,0,0,null,1
+maxLik,sumt,2,0,0,null,1
+maxLik,sumt,3,0,0,double[],1
+maxLik,sumt,4,0,0,class<`function`>,1
+maxLik,sumt,5,0,0,list<class<`matrix`> | double>,1
+maxLik,sumt,6,0,0,double,1
+maxLik,sumt,7,0,0,double,1
+maxLik,sumt,8,0,0,double,1
+maxLik,sumt,9,0,0,null,1
+maxLik,sumt,10,0,0,double,1
+maxLik,sumt,11,0,0,double,1
+maxLik,sumt,12,0,0,double,1
+maxLik,sumt,13,0,0,...,1
+maxLik,vcov.maxLik,-1,0,0,class<`matrix`>,1
+maxLik,vcov.maxLik,-1,0,1,null,1
+maxLik,vcov.maxLik,0,0,0,"class<`list`, `maxLik`, `maxim`>",1
+maxLik,vcov.maxLik,0,0,1,"class<`maxLik`, `maxim`>",1
+maxLik,vcov.maxLik,1,0,0,any,1
+maxLik,vcov.maxLik,2,0,0,...,1
+mc2d,addvar,-1,0,0,class<`mcnode`>,1
+mc2d,addvar,0,0,0,...,1
+mc2d,converg,-1,0,0,null,1
+mc2d,converg,0,0,0,class<`mcnode`>,1
+mc2d,converg,1,0,0,any,1
+mc2d,converg,2,0,0,character,1
+mc2d,converg,3,0,0,double,1
+mc2d,converg,4,0,0,double,1
+mc2d,converg,5,0,0,double[],1
+mc2d,converg,6,0,0,any,1
+mc2d,converg,7,0,0,null,1
+mc2d,converg,8,0,0,logical,1
+mc2d,cornode,-1,0,0,class<`matrix`>,1
+mc2d,cornode,-1,0,1,list<class<`mcnode`>>,1
+mc2d,cornode,0,0,0,...,1
+mc2d,cornode,1,0,0,class<`matrix`>,1
+mc2d,cornode,2,0,0,logical,1
+mc2d,cornode,3,0,0,logical,1
+mc2d,cornode,4,0,0,null,1
+mc2d,dbetagen,-1,0,0,double[],1
+mc2d,dbetagen,0,0,0,double[],1
+mc2d,dbetagen,1,0,0,double,1
+mc2d,dbetagen,2,0,0,double,1
+mc2d,dbetagen,3,0,0,double,1
+mc2d,dbetagen,4,0,0,double,1
+mc2d,dbetagen,5,0,0,double,1
+mc2d,dbetagen,6,0,0,logical,1
+mc2d,ddirichlet,-1,0,0,double[],1
+mc2d,ddirichlet,0,0,0,class<`matrix`>,1
+mc2d,ddirichlet,1,0,0,class<`matrix`>,1
+mc2d,dempiricalC,-1,0,0,double[],1
+mc2d,dempiricalC,0,0,0,double[],1
+mc2d,dempiricalC,1,0,0,double,1
+mc2d,dempiricalC,2,0,0,double,1
+mc2d,dempiricalC,3,0,0,class<`matrix`>,1
+mc2d,dempiricalC,3,0,1,integer[],1
+mc2d,dempiricalC,4,0,0,null,1
+mc2d,dempiricalC,4,0,1,double[],1
+mc2d,dempiricalC,5,0,0,logical,1
+mc2d,dempiricalD,-1,0,0,double[],1
+mc2d,dempiricalD,0,0,0,double[],1
+mc2d,dempiricalD,1,0,0,class<`matrix`>,1
+mc2d,dempiricalD,1,0,1,integer[],1
+mc2d,dempiricalD,2,0,0,null,1
+mc2d,dempiricalD,2,0,1,double[],1
+mc2d,dempiricalD,3,0,0,logical,1
+mc2d,dimmc,-1,0,0,integer[],1
+mc2d,dimmc,0,0,0,class<`mc`>,1
+mc2d,dimmcnode,-1,0,0,integer[],1
+mc2d,dimmcnode,0,0,0,class<`mcnode`>,1
+mc2d,dmultinomial,-1,0,0,double[],1
+mc2d,dmultinomial,0,0,0,class<`matrix`>,1
+mc2d,dmultinomial,0,0,1,double[],1
+mc2d,dmultinomial,1,0,0,null,1
+mc2d,dmultinomial,2,0,0,class<`matrix`>,1
+mc2d,dmultinomial,2,0,1,double[],1
+mc2d,dmultinomial,3,0,0,logical,1
+mc2d,dmultinormal,-1,0,0,class<`matrix`>,1
+mc2d,dmultinormal,-1,0,1,double[],1
+mc2d,dmultinormal,0,0,0,class<`matrix`>,1
+mc2d,dmultinormal,1,0,0,class<`matrix`>,1
+mc2d,dmultinormal,1,0,1,double[],1
+mc2d,dmultinormal,2,0,0,class<`matrix`>,1
+mc2d,dmultinormal,2,0,1,double[],1
+mc2d,dmultinormal,3,0,0,logical,1
+mc2d,dpert,-1,0,0,double[],1
+mc2d,dpert,0,0,0,double[],1
+mc2d,dpert,1,0,0,double,1
+mc2d,dpert,2,0,0,double,1
+mc2d,dpert,3,0,0,double,1
+mc2d,dpert,4,0,0,double,1
+mc2d,dpert,5,0,0,logical,1
+mc2d,dtriang,-1,0,0,double[],1
+mc2d,dtriang,0,0,0,double[],1
+mc2d,dtriang,1,0,0,double,1
+mc2d,dtriang,2,0,0,double,1
+mc2d,dtriang,3,0,0,double,1
+mc2d,dtriang,4,0,0,logical,1
+mc2d,evalmccut,-1,0,0,class<`mccut`>,1
+mc2d,evalmccut,0,0,0,class<`mcmodelcut`>,1
+mc2d,evalmccut,1,0,0,double,1
+mc2d,evalmccut,2,0,0,double,1
+mc2d,evalmccut,3,0,0,double,1
+mc2d,evalmccut,4,0,0,character,1
+mc2d,evalmcmod,-1,0,0,class<`mc`>,1
+mc2d,evalmcmod,0,0,0,class<`mcmodel`>,1
+mc2d,evalmcmod,0,0,1,expression,1
+mc2d,evalmcmod,1,0,0,double,1
+mc2d,evalmcmod,2,0,0,double,1
+mc2d,evalmcmod,3,0,0,null,1
+mc2d,evalmcmod,3,0,1,double,1
+mc2d,extractvar,-1,0,0,class<`mcnode`>,1
+mc2d,extractvar,0,0,0,class<`mcnode`>,1
+mc2d,extractvar,1,0,0,double[],1
+mc2d,hist.mc,-1,0,0,null,1
+mc2d,hist.mc,0,0,0,list<class<`mcnode`>>,1
+mc2d,hist.mc,0,0,1,class<`mc`>,1
+mc2d,hist.mc,1,0,0,null,1
+mc2d,hist.mc,2,0,0,character[],1
+mc2d,hist.mc,3,0,0,character,1
+mc2d,hist.mc,4,0,0,character,1
+mc2d,hist.mc,5,0,0,...,1
+mc2d,hist.mcnode,-1,0,0,null,1
+mc2d,hist.mcnode,0,0,0,class<`mcnode`>,1
+mc2d,hist.mcnode,1,0,0,...,1
+mc2d,is.mc,-1,0,0,logical,1
+mc2d,is.mc,0,0,0,class<`mc`>,1
+mc2d,is.mc,0,0,1,class<`mcnode`>,1
+mc2d,is.mcnode,-1,0,0,logical,1
+mc2d,is.mcnode,0,0,0,class<`mcnode`>,1
+mc2d,is.mcnode,0,0,1,class<`mc`>,1
+mc2d,is.na.mcnode,-1,0,0,class<`mcnode`>,1
+mc2d,is.na.mcnode,0,0,0,class<`mcnode`>,1
+mc2d,lhs,-1,0,0,double[],1
+mc2d,lhs,0,0,0,character,1
+mc2d,lhs,0,0,1,class<`function`>,1
+mc2d,lhs,1,0,0,double,1
+mc2d,lhs,2,0,0,double,1
+mc2d,lhs,3,0,0,double,1
+mc2d,lhs,4,0,0,...,1
+mc2d,mc,-1,0,0,class<`mc`>,1
+mc2d,mc,0,0,0,...,1
+mc2d,mc,1,0,0,character[],1
+mc2d,mc,1,0,1,null,1
+mc2d,mc,2,0,0,logical,1
+mc2d,mcdata,-1,0,0,class<`mcnode`>,1
+mc2d,mcdata,0,0,0,class<`array`>,1
+mc2d,mcdata,0,0,1,class<`matrix`>,1
+mc2d,mcdata,0,0,2,class<`mcnode`>,1
+mc2d,mcdata,0,0,3,double[],1
+mc2d,mcdata,0,0,4,null,1
+mc2d,mcdata,1,0,0,character[],1
+mc2d,mcdata,2,0,0,any,1
+mc2d,mcdata,3,0,0,any,1
+mc2d,mcdata,4,0,0,double,1
+mc2d,mcdata,5,0,0,character,1
+mc2d,mcmodel,-1,0,0,class<`mcmodel`>,1
+mc2d,mcmodel,0,0,0,any,1
+mc2d,mcmodel,1,0,0,logical,1
+mc2d,mcmodelcut,-1,0,0,class<`mcmodelcut`>,1
+mc2d,mcmodelcut,0,0,0,any,1
+mc2d,mcmodelcut,1,0,0,logical,1
+mc2d,mcprobtree,-1,0,0,class<`mcnode`>,1
+mc2d,mcprobtree,0,0,0,class<`mcnode`>,1
+mc2d,mcprobtree,0,0,1,double[],1
+mc2d,mcprobtree,1,0,0,any,1
+mc2d,mcprobtree,2,0,0,character,1
+mc2d,mcprobtree,3,0,0,double,1
+mc2d,mcprobtree,4,0,0,double,1
+mc2d,mcprobtree,5,0,0,double,1
+mc2d,mcprobtree,6,0,0,character,1
+mc2d,mcprobtree,7,0,0,null,1
+mc2d,mcratio,-1,0,0,class<`matrix`>,1
+mc2d,mcratio,0,0,0,class<`mc`>,1
+mc2d,mcratio,1,0,0,double,1
+mc2d,mcratio,2,0,0,double,1
+mc2d,mcratio,3,0,0,double,1
+mc2d,mcratio,4,0,0,logical,1
+mc2d,mcstoc,-1,0,0,class<`mcnode`>,1
+mc2d,mcstoc,0,0,0,class<`function`>,1
+mc2d,mcstoc,1,0,0,character[],1
+mc2d,mcstoc,2,0,0,...,1
+mc2d,mcstoc,3,0,0,any,1
+mc2d,mcstoc,4,0,0,any,1
+mc2d,mcstoc,5,0,0,double,1
+mc2d,mcstoc,6,0,0,character[],1
+mc2d,mcstoc,7,0,0,character,1
+mc2d,mcstoc,8,0,0,null,1
+mc2d,mcstoc,9,0,0,logical,1
+mc2d,mcstoc,10,0,0,any,1
+mc2d,mcstoc,11,0,0,double,1
+mc2d,mcstoc,12,0,0,logical,1
+mc2d,ndunc,-1,0,0,double,1
+mc2d,ndunc,0,0,0,any,1
+mc2d,ndvar,-1,0,0,double,1
+mc2d,ndvar,0,0,0,any,1
+mc2d,Ops.mcnode,-1,0,0,class<`mcnode`>,1
+mc2d,Ops.mcnode,0,0,0,class<`mcnode`>,1
+mc2d,Ops.mcnode,0,0,1,double,1
+mc2d,Ops.mcnode,0,0,2,integer[],1
+mc2d,Ops.mcnode,1,0,0,any,1
+mc2d,outm,-1,0,0,class<`mcnode`>,1
+mc2d,outm,0,0,0,class<`mcnode`>,1
+mc2d,outm,1,0,0,character,1
+mc2d,outm,2,0,0,double,1
+mc2d,pempiricalC,-1,0,0,double[],1
+mc2d,pempiricalC,0,0,0,double[],1
+mc2d,pempiricalC,1,0,0,double,1
+mc2d,pempiricalC,2,0,0,double,1
+mc2d,pempiricalC,3,0,0,integer[],1
+mc2d,pempiricalC,4,0,0,double[],1
+mc2d,pempiricalC,5,0,0,logical,1
+mc2d,pempiricalC,6,0,0,logical,1
+mc2d,pempiricalD,-1,0,0,double[],1
+mc2d,pempiricalD,0,0,0,integer[],1
+mc2d,pempiricalD,1,0,0,integer[],1
+mc2d,pempiricalD,2,0,0,double[],1
+mc2d,pempiricalD,3,0,0,logical,1
+mc2d,pempiricalD,4,0,0,logical,1
+mc2d,plot.mc,-1,0,0,class<`plotmc`>,1
+mc2d,plot.mc,0,0,0,class<`mc`>,1
+mc2d,plot.mc,1,0,0,double,1
+mc2d,plot.mc,2,0,0,any,1
+mc2d,plot.mc,3,0,0,double[],1
+mc2d,plot.mc,4,0,0,logical,1
+mc2d,plot.mc,5,0,0,null,1
+mc2d,plot.mc,6,0,0,null,1
+mc2d,plot.mc,7,0,0,character,1
+mc2d,plot.mc,8,0,0,character,1
+mc2d,plot.mc,9,0,0,logical,1
+mc2d,plot.mc,10,0,0,logical,1
+mc2d,plot.mc,11,0,0,null,1
+mc2d,plot.mc,12,0,0,null,1
+mc2d,plot.mc,13,0,0,...,1
+mc2d,plot.tornado,-1,0,0,null,1
+mc2d,plot.tornado,0,0,0,class<`tornado`>,1
+mc2d,plot.tornado,1,0,0,double,1
+mc2d,plot.tornado,2,0,0,null,1
+mc2d,plot.tornado,3,0,0,character[],1
+mc2d,plot.tornado,4,0,0,character,1
+mc2d,plot.tornado,5,0,0,character,1
+mc2d,plot.tornado,6,0,0,...,1
+mc2d,pmax,-1,0,0,integer[],1
+mc2d,pmax,0,0,0,...,1
+mc2d,pmax,1,0,0,logical,1
+mc2d,pmax.default,-1,0,0,integer[],1
+mc2d,pmax.default,0,0,0,...,1
+mc2d,pmax.default,1,0,0,logical,1
+mc2d,pmin,-1,0,0,class<`mcnode`>,1
+mc2d,pmin,0,0,0,...,1
+mc2d,pmin,1,0,0,logical,1
+mc2d,pmin.mcnode,-1,0,0,class<`mcnode`>,1
+mc2d,pmin.mcnode,0,0,0,...,1
+mc2d,pmin.mcnode,1,0,0,logical,1
+mc2d,qempiricalC,-1,0,0,double[],1
+mc2d,qempiricalC,0,0,0,double[],1
+mc2d,qempiricalC,1,0,0,double,1
+mc2d,qempiricalC,2,0,0,double,1
+mc2d,qempiricalC,3,0,0,class<`matrix`>,1
+mc2d,qempiricalC,4,0,0,null,1
+mc2d,qempiricalC,5,0,0,logical,1
+mc2d,qempiricalC,6,0,0,logical,1
+mc2d,qempiricalD,-1,0,0,double[],1
+mc2d,qempiricalD,0,0,0,double[],1
+mc2d,qempiricalD,1,0,0,integer[],1
+mc2d,qempiricalD,2,0,0,double[],1
+mc2d,qempiricalD,3,0,0,logical,1
+mc2d,qempiricalD,4,0,0,logical,1
+mc2d,quantile.mc,-1,0,0,list<class<`matrix`>>,1
+mc2d,quantile.mc,-1,0,1,list<list<class<`matrix`>>>,1
+mc2d,quantile.mc,-1,0,2,list<class<`matrix`> | list<class<`matrix`>>>,1
+mc2d,quantile.mc,0,0,0,class<`mc`>,1
+mc2d,quantile.mc,0,0,1,list<class<`mcnode`>>,1
+mc2d,quantile.mc,1,0,0,double[],1
+mc2d,quantile.mc,2,0,0,double[],1
+mc2d,quantile.mc,3,0,0,logical,1
+mc2d,quantile.mc,4,0,0,...,1
+mc2d,quantile.mcnode,-1,0,0,list<list<class<`matrix`>>>,1
+mc2d,quantile.mcnode,0,0,0,class<`mcnode`>,1
+mc2d,quantile.mcnode,1,0,0,...,1
+mc2d,rbern,-1,0,0,integer[],1
+mc2d,rbern,0,0,0,double,1
+mc2d,rbern,1,0,0,double[],1
+mc2d,rdirichlet,-1,0,0,class<`matrix`>,1
+mc2d,rdirichlet,0,0,0,double,1
+mc2d,rdirichlet,1,0,0,class<`matrix`>,1
+mc2d,rempiricalD,-1,0,0,double[],1
+mc2d,rempiricalD,0,0,0,double,1
+mc2d,rempiricalD,1,0,0,class<`matrix`>,1
+mc2d,rempiricalD,1,0,1,double[],1
+mc2d,rempiricalD,2,0,0,double[],1
+mc2d,rempiricalD,2,0,1,null,1
+mc2d,rmultinomial,-1,0,0,class<`matrix`>,1
+mc2d,rmultinomial,0,0,0,double,1
+mc2d,rmultinomial,1,0,0,double[],1
+mc2d,rmultinomial,1,0,1,class<`matrix`>,1
+mc2d,rmultinomial,2,0,0,double[],1
+mc2d,rmultinomial,2,0,1,class<`matrix`>,1
+mc2d,rmultinormal,-1,0,0,class<`matrix`>,1
+mc2d,rmultinormal,0,0,0,double,1
+mc2d,rmultinormal,1,0,0,class<`matrix`>,1
+mc2d,rmultinormal,1,0,1,double[],1
+mc2d,rmultinormal,2,0,0,class<`matrix`>,1
+mc2d,rmultinormal,2,0,1,double[],1
+mc2d,rmultinormal,3,0,0,character[],1
+mc2d,rtrunc,-1,0,0,double[],1
+mc2d,rtrunc,0,0,0,character,1
+mc2d,rtrunc,0,0,1,class<`function`>,1
+mc2d,rtrunc,1,0,0,double,1
+mc2d,rtrunc,2,0,0,double,1
+mc2d,rtrunc,3,0,0,double,1
+mc2d,rtrunc,4,0,0,...,1
+mc2d,summary.mc,-1,0,0,"class<`listof`, `summary.mc`>",1
+mc2d,summary.mc,-1,0,1,null,1
+mc2d,summary.mc,0,0,0,list<class<`mcnode`>>,1
+mc2d,summary.mc,0,0,1,class<`mc`>,1
+mc2d,summary.mc,1,0,0,double[],1
+mc2d,summary.mc,2,0,0,double[],1
+mc2d,summary.mc,3,0,0,...,1
+mc2d,summary.mccut,-1,0,0,"class<`listof`, `summary.mc`>",1
+mc2d,summary.mccut,0,0,0,class<`mccut`>,1
+mc2d,summary.mccut,1,0,0,double[],1
+mc2d,summary.mccut,2,0,0,...,1
+mc2d,summary.mcnode,-1,0,0,"class<`listof`, `summary.mc`>",1
+mc2d,summary.mcnode,-1,0,1,null,1
+mc2d,summary.mcnode,0,0,0,class<`mcnode`>,1
+mc2d,summary.mcnode,1,0,0,double[],1
+mc2d,summary.mcnode,2,0,0,double[],1
+mc2d,summary.mcnode,3,0,0,double,1
+mc2d,summary.mcnode,4,0,0,...,1
+mc2d,tornado,-1,0,0,class<`tornado`>,1
+mc2d,tornado,0,0,0,class<`mc`>,1
+mc2d,tornado,1,0,0,double,1
+mc2d,tornado,2,0,0,character,1
+mc2d,tornado,3,0,0,character[],1
+mc2d,tornado,4,0,0,any,1
+mc2d,typemcnode,-1,0,0,character,1
+mc2d,typemcnode,0,0,0,class<`mcnode`>,1
+mc2d,typemcnode,1,0,0,logical,1
+mc2d,unmc,-1,0,0,class<`array`>,1
+mc2d,unmc,-1,0,1,double[],1
+mc2d,unmc,0,0,0,class<`mcnode`>,1
+mc2d,unmc,1,0,0,logical,1
+mcclust,arandi,-1,0,0,double,1
+mcclust,arandi,0,0,0,integer[],1
+mcclust,arandi,1,0,0,integer[],1
+mcclust,arandi,2,0,0,logical,1
+mcclust,binder,-1,0,0,double[],1
+mcclust,binder,0,0,0,class<`matrix`>,1
+mcclust,binder,1,0,0,class<`matrix`>,1
+mcclust,cltoSim,-1,0,0,class<`matrix`>,1
+mcclust,cltoSim,0,0,0,double[],1
+mcclust,comp.psm,-1,0,0,class<`matrix`>,1
+mcclust,comp.psm,0,0,0,class<`matrix`>,1
+mcclust,laugreen,-1,0,0,list<double[] | character>,1
+mcclust,laugreen,0,0,0,class<`matrix`>,1
+mcclust,laugreen,1,0,0,null,1
+mcclust,laugreen,2,0,0,double,1
+mcclust,maxpear,-1,0,0,list<integer[] | double | character>,1
+mcclust,maxpear,0,0,0,class<`matrix`>,1
+mcclust,maxpear,1,0,0,null,1
+mcclust,maxpear,2,0,0,character[],1
+mcclust,maxpear,3,0,0,null,1
+mcclust,medv,-1,0,0,integer[],1
+mcclust,medv,0,0,0,class<`matrix`>,1
+mcclust,medv,1,0,0,double,1
+mcclust,minbinder,-1,0,0,list<class<`matrix`> | double[]>,1
+mcclust,minbinder,-1,0,1,list<integer[] | double | character>,1
+mcclust,minbinder,0,0,0,class<`matrix`>,1
+mcclust,minbinder,1,0,0,class<`matrix`>,1
+mcclust,minbinder,1,0,1,null,1
+mcclust,minbinder,2,0,0,character[],1
+mcclust,minbinder,3,0,0,null,1
+mcclust,minbinder,4,0,0,logical,1
+mcclust,minbinder,5,0,0,null,1
+mcclust,minbinder,6,0,0,double,1
+mcclust,norm.label,-1,0,0,integer[],1
+mcclust,norm.label,0,0,0,character[],1
+mcclust,norm.label,0,0,1,double[],1
+mcclust,pear,-1,0,0,double[],1
+mcclust,pear,0,0,0,class<`matrix`>,1
+mcclust,pear,1,0,0,class<`matrix`>,1
+mcclust,relabel,-1,0,0,list<class<`matrix`> | double | integer[]>,1
+mcclust,relabel,0,0,0,class<`matrix`>,1
+mcclust,relabel,1,0,0,logical,1
+mcclust,Simtocl,-1,0,0,double[],1
+mcclust,Simtocl,0,0,0,class<`matrix`>,1
+mcclust,vi.dist,-1,0,0,double[],1
+mcclust,vi.dist,0,0,0,integer[],1
+mcclust,vi.dist,1,0,0,integer[],1
+mcclust,vi.dist,2,0,0,logical,1
+mcclust,vi.dist,3,0,0,double,1
+mcmcse,batchSize,-1,0,0,double,1
+mcmcse,batchSize,0,0,0,class<`matrix`>,1
+mcmcse,batchSize,0,0,1,double[],1
+mcmcse,batchSize,1,0,0,character,1
+mcmcse,batchSize,2,0,0,class<`function`>,1
+mcmcse,batchSize,2,0,1,null,1
+mcmcse,confRegion,-1,0,0,class<`matrix`>,1
+mcmcse,confRegion,0,0,0,list<class<`matrix`> | double[] | character>,1
+mcmcse,confRegion,1,0,0,double[],1
+mcmcse,confRegion,2,0,0,double,1
+mcmcse,inseq,-1,0,0,list<class<`matrix`> | double[]>,1
+mcmcse,inseq,0,0,0,class<`matrix`>,1
+mcmcse,inseq,1,0,0,logical,1
+mcmcse,mbmC,-1,0,0,class<`matrix`>,1
+mcmcse,mbmC,0,0,0,class<`matrix`>,1
+mcmcse,mbmC,1,0,0,double,1
+mcmcse,mcse,-1,0,0,list<double>,1
+mcmcse,mcse,0,0,0,double[],1
+mcmcse,mcse,1,0,0,null,1
+mcmcse,mcse,2,0,0,class<`function`>,1
+mcmcse,mcse,2,0,1,null,1
+mcmcse,mcse,3,0,0,double,1
+mcmcse,mcse,4,0,0,character,1
+mcmcse,mcse,5,0,0,logical,1
+mcmcse,mcse.initseq,-1,0,0,list<class<`matrix`> | double[]>,1
+mcmcse,mcse.initseq,-1,0,1,list<class<`matrix`> | null | double[]>,1
+mcmcse,mcse.initseq,0,0,0,class<`matrix`>,1
+mcmcse,mcse.initseq,1,0,0,null,1
+mcmcse,mcse.initseq,1,0,1,class<`function`>,1
+mcmcse,mcse.initseq,2,0,0,logical,1
+mcmcse,mcse.initseq,3,0,0,logical,1
+mcmcse,mcse.multi,-1,0,0,list<class<`matrix`> | double[]>,1
+mcmcse,mcse.multi,-1,0,1,list<class<`matrix`> | double[] | character>,1
+mcmcse,mcse.multi,0,0,0,class<`matrix`>,1
+mcmcse,mcse.multi,1,0,0,character,1
+mcmcse,mcse.multi,2,0,0,double,1
+mcmcse,mcse.multi,3,0,0,null,1
+mcmcse,mcse.multi,4,0,0,class<`function`>,1
+mcmcse,mcse.multi,4,0,1,null,1
+mcmcse,mcse.multi,5,0,0,logical,1
+mcmcse,mcse.multi,6,0,0,logical,1
+mcmcse,mcse.q,-1,0,0,list<double>,1
+mcmcse,mcse.q,0,0,0,double[],1
+mcmcse,mcse.q,1,0,0,double,1
+mcmcse,mcse.q,2,0,0,character,1
+mcmcse,mcse.q,3,0,0,null,1
+mcmcse,mcse.q,4,0,0,character[],1
+mcmcse,mcse.q,5,0,0,logical,1
+mcmcse,minESS,-1,0,0,double,1
+mcmcse,minESS,0,0,0,double,1
+mcmcse,minESS,1,0,0,double,1
+mcmcse,minESS,2,0,0,double,1
+mcmcse,minESS,3,0,0,null,1
+mcmcse,msveC,-1,0,0,class<`matrix`>,1
+mcmcse,msveC,0,0,0,class<`matrix`>,1
+mcmcse,msveC,1,0,0,double,1
+mcmcse,msveC,2,0,0,character,1
+mcmcse,multiESS,-1,0,0,double,1
+mcmcse,multiESS,0,0,0,class<`matrix`>,1
+mcmcse,multiESS,1,0,0,null,1
+mcmcse,multiESS,2,0,0,null,1
+mcmcse,multiESS,3,0,0,...,1
+memoise,cache_memory,-1,0,0,list<class<`function`>>,1
+memoise,cache_memory,0,0,0,character,1
+memoise,forget,-1,0,0,logical,1
+memoise,forget,0,0,0,"class<`function`, `memoised`>",1
+memoise,is.memoised,-1,0,0,logical,1
+memoise,is.memoised,0,0,0,class<`function`>,1
+memoise,is.memoised,0,0,1,"class<`function`, `memoised`>",1
+memoise,make_call,-1,0,0,class<`call`>,1
+memoise,make_call,0,0,0,class<`name`>,1
+memoise,make_call,1,0,0,list<any>,1
+memoise,memoise,-1,0,0,"class<`function`, `memoised`>",1
+memoise,memoise,0,0,0,class<`function`>,1
+memoise,memoise,1,0,0,...,1
+memoise,memoise,2,0,0,environment,1
+memoise,memoise,3,0,0,list<class<`function`>>,1
+memoise,validate_formulas,-1,0,0,list<any>,1
+memoise,validate_formulas,0,0,0,...,1
+metRology,algA,-1,0,0,list<double>,1
+metRology,algA,0,0,0,class<`array`>,1
+metRology,algA,0,0,1,double[],1
+metRology,algA,1,0,0,double,1
+metRology,algA,2,0,0,logical,1
+metRology,algA,3,0,0,double,1
+metRology,algA,4,0,0,double,1
+metRology,algA,5,0,0,logical,1
+metRology,algS,-1,0,0,double,1
+metRology,algS,0,0,0,class<`array`>,1
+metRology,algS,0,0,1,double[],1
+metRology,algS,1,0,0,any,1
+metRology,algS,2,0,0,logical,1
+metRology,algS,3,0,0,double,1
+metRology,algS,4,0,0,logical,1
+metRology,algS,5,0,0,double,1
+metRology,algS,6,0,0,double,1
+metRology,algS,7,0,0,logical,1
+metRology,barplot.mandel.kh,-1,0,0,class<`matrix`>,1
+metRology,barplot.mandel.kh,0,0,0,"class<`data.frame`, `mandel.kh`>",1
+metRology,barplot.mandel.kh,1,0,0,double[],1
+metRology,barplot.mandel.kh,2,0,0,any,1
+metRology,barplot.mandel.kh,3,0,0,character,1
+metRology,barplot.mandel.kh,4,0,0,character,1
+metRology,barplot.mandel.kh,5,0,0,logical,1
+metRology,barplot.mandel.kh,6,0,0,logical,1
+metRology,barplot.mandel.kh,7,0,0,any,1
+metRology,barplot.mandel.kh,8,0,0,character,1
+metRology,barplot.mandel.kh,9,0,0,logical,1
+metRology,barplot.mandel.kh,10,0,0,...,1
+metRology,barplot.mandel.kh,11,0,0,double,1
+metRology,barplot.mandel.kh,12,0,0,double[],1
+metRology,barplot.mandel.kh,13,0,0,double,1
+metRology,barplot.mandel.kh,14,0,0,character,1
+metRology,barplot.mandel.kh,15,0,0,double,1
+metRology,barplot.MSD,-1,0,0,class<`matrix`>,1
+metRology,barplot.MSD,0,0,0,"class<`MSD`, `numeric`>",1
+metRology,barplot.MSD,1,0,0,character,1
+metRology,barplot.MSD,2,0,0,character[],1
+metRology,barplot.MSD,3,0,0,logical,1
+metRology,barplot.MSD,4,0,0,double[],1
+metRology,barplot.MSD,5,0,0,double,1
+metRology,barplot.MSD,6,0,0,double[],1
+metRology,barplot.MSD,7,0,0,double[],1
+metRology,barplot.MSD,8,0,0,integer,1
+metRology,barplot.MSD,9,0,0,...,1
+metRology,bkp,-1,0,0,list<^double[] | class<`factor`> | character[]>,1
+metRology,bkp,-1,0,1,list<double[] | class<`factor`> | character[]>,1
+metRology,bkp,-1,0,2,list<double[] | null | character[]>,1
+metRology,bkp,0,0,0,list<^double[] | class<`factor`> | character[]>,1
+metRology,bkp,0,0,1,"class<`blockplot`, `list`>",1
+metRology,bkp,0,0,2,list<double[] | class<`factor`> | character[]>,1
+metRology,bkp,0,0,3,list<double[] | null | character[]>,1
+metRology,bkp,1,0,0,character[],1
+metRology,bkp,2,0,0,null,1
+metRology,bkp,3,0,0,null,1
+metRology,bkp,4,0,0,character,1
+metRology,bkp,4,0,1,null,1
+metRology,bkp,5,0,0,character,1
+metRology,bkp,5,0,1,null,1
+metRology,bkp,6,0,0,character,1
+metRology,bkp,7,0,0,logical,1
+metRology,bkp,8,0,0,logical,1
+metRology,bkp,9,0,0,double,1
+metRology,bkp,10,0,0,double,1
+metRology,bkp,11,0,0,null,1
+metRology,bkp,12,0,0,null,1
+metRology,bkp,12,0,1,character[],1
+metRology,bkp,13,0,0,null,1
+metRology,bkp,14,0,0,null,1
+metRology,bkp,15,0,0,double,1
+metRology,blockplot,-1,0,0,"class<`blockplot`, `list`>",1
+metRology,blockplot,0,0,0,class<`formula`>,1
+metRology,blockplot,0,0,1,^double[],1
+metRology,blockplot,1,0,0,...,1
+metRology,blockplot.default,-1,0,0,"class<`blockplot`, `list`>",1
+metRology,blockplot.default,0,0,0,^double[],1
+metRology,blockplot.default,1,0,0,character,1
+metRology,blockplot.default,2,0,0,character[],1
+metRology,blockplot.default,3,0,0,class<`factor`>,1
+metRology,blockplot.default,3,0,1,null,1
+metRology,blockplot.default,4,0,0,null,1
+metRology,blockplot.default,5,0,0,null,1
+metRology,blockplot.default,6,0,0,character,1
+metRology,blockplot.default,6,0,1,null,1
+metRology,blockplot.default,7,0,0,character,1
+metRology,blockplot.default,7,0,1,null,1
+metRology,blockplot.default,8,0,0,character,1
+metRology,blockplot.default,9,0,0,character[],1
+metRology,blockplot.default,9,0,1,logical,1
+metRology,blockplot.default,10,0,0,logical,1
+metRology,blockplot.default,11,0,0,logical,1
+metRology,blockplot.default,12,0,0,null,1
+metRology,blockplot.default,13,0,0,logical,1
+metRology,blockplot.default,14,0,0,logical,1
+metRology,blockplot.default,15,0,0,...,1
+metRology,blockplot.formula,-1,0,0,"class<`blockplot`, `list`>",1
+metRology,blockplot.formula,0,0,0,class<`formula`>,1
+metRology,blockplot.formula,1,0,0,null,1
+metRology,blockplot.formula,2,0,0,...,1
+metRology,blockplot.formula,3,0,0,any,1
+metRology,blockplot.formula,4,0,0,null,1
+metRology,blockplot.formula,5,0,0,null,1
+metRology,boxplot.mandel.kh,-1,0,0,list<class<`matrix`> | double[] | character[]>,1
+metRology,boxplot.mandel.kh,0,0,0,"class<`data.frame`, `mandel.kh`>",1
+metRology,boxplot.mandel.kh,1,0,0,double[],1
+metRology,boxplot.mandel.kh,2,0,0,any,1
+metRology,boxplot.mandel.kh,3,0,0,character,1
+metRology,boxplot.mandel.kh,4,0,0,character,1
+metRology,boxplot.mandel.kh,5,0,0,logical,1
+metRology,boxplot.mandel.kh,6,0,0,logical,1
+metRology,boxplot.mandel.kh,7,0,0,any,1
+metRology,boxplot.mandel.kh,8,0,0,character,1
+metRology,boxplot.mandel.kh,9,0,0,logical,1
+metRology,boxplot.mandel.kh,10,0,0,logical,1
+metRology,boxplot.mandel.kh,11,0,0,any,1
+metRology,boxplot.mandel.kh,12,0,0,...,1
+metRology,boxplot.mandel.kh,13,0,0,double,1
+metRology,boxplot.mandel.kh,14,0,0,double[],1
+metRology,boxplot.mandel.kh,15,0,0,double,1
+metRology,buildCor,-1,0,0,class<`matrix`>,1
+metRology,buildCor,0,0,0,double,1
+metRology,buildCor,1,0,0,class<`matrix`>,1
+metRology,buildCor,1,0,1,double[],1
+metRology,buildCov,-1,0,0,class<`matrix`>,1
+metRology,buildCov,0,0,0,integer[],1
+metRology,buildCov,1,0,0,any,1
+metRology,buildCov,2,0,0,double[],1
+metRology,buildCov,3,0,0,class<`matrix`>,1
+metRology,buildCov,4,0,0,any,1
+metRology,cbind,-1,0,0,class<`data.frame`>,1
+metRology,cbind,-1,0,1,class<`matrix`>,1
+metRology,cbind,0,0,0,...,1
+metRology,cbind,1,0,0,double,1
+metRology,cbind.default,-1,0,0,class<`matrix`>,1
+metRology,cbind.default,0,0,0,...,1
+metRology,cbind.default,1,0,0,double,1
+metRology,construct.ilab,-1,0,0,class<`ilab`>,1
+metRology,construct.ilab,0,0,0,character[],1
+metRology,construct.ilab,0,0,1,class<`factor`>,1
+metRology,construct.ilab,1,0,0,character,1
+metRology,construct.ilab,1,0,1,class<`factor`>,1
+metRology,construct.ilab,2,0,0,character,1
+metRology,construct.ilab,2,0,1,class<`factor`>,1
+metRology,construct.ilab,3,0,0,^double[],1
+metRology,construct.ilab,4,0,0,any,1
+metRology,construct.ilab,5,0,0,any,1
+metRology,construct.ilab,6,0,0,any,1
+metRology,construct.ilab,7,0,0,any,1
+metRology,construct.ilab,8,0,0,any,1
+metRology,construct.ilab,9,0,0,any,1
+metRology,construct.ilab,10,0,0,null,1
+metRology,construct.ilab,10,0,1,character,1
+metRology,construct.ilab,11,0,0,null,1
+metRology,construct.ilab,12,0,0,null,1
+metRology,construct.ilab,13,0,0,character[],1
+metRology,construct.ilab,13,0,1,null,1
+metRology,construct.ilab,14,0,0,double,1
+metRology,construct.ilab,15,0,0,...,1
+metRology,.construct.loc.est,-1,0,0,class<`loc.est`>,1
+metRology,.construct.loc.est,0,0,0,double,1
+metRology,.construct.loc.est,1,0,0,double,1
+metRology,.construct.loc.est,2,0,0,double,1
+metRology,.construct.loc.est,2,0,1,null,1
+metRology,.construct.loc.est,3,0,0,double[],1
+metRology,.construct.loc.est,4,0,0,double[],1
+metRology,.construct.loc.est,5,0,0,^logical[],1
+metRology,.construct.loc.est,6,0,0,double[],1
+metRology,.construct.loc.est,7,0,0,double[],1
+metRology,.construct.loc.est,8,0,0,character,1
+metRology,.construct.loc.est,9,0,0,list<double>,1
+metRology,.construct.loc.est,9,0,1,"class<`lm`, `rlm`>",1
+metRology,.construct.uncert,-1,0,0,"class<`list`, `uncert`>",1
+metRology,.construct.uncert,0,0,0,class<`call`>,1
+metRology,.construct.uncert,1,0,0,class<`formula`>,1
+metRology,.construct.uncert,1,0,1,class<`function`>,1
+metRology,.construct.uncert,1,0,2,expression,1
+metRology,.construct.uncert,1,0,3,null,1
+metRology,.construct.uncert,2,0,0,double,1
+metRology,.construct.uncert,2,0,1,null,1
+metRology,.construct.uncert,3,0,0,double,1
+metRology,.construct.uncert,4,0,0,character,1
+metRology,.construct.uncert,5,0,0,list<double>,1
+metRology,.construct.uncert,5,0,1,null,1
+metRology,.construct.uncert,6,0,0,list<null>,1
+metRology,.construct.uncert,6,0,1,null,1
+metRology,.construct.uncert,7,0,0,list<double>,1
+metRology,.construct.uncert,7,0,1,double[],1
+metRology,.construct.uncert,8,0,0,double[],1
+metRology,.construct.uncert,8,0,1,list<double>,1
+metRology,.construct.uncert,9,0,0,null,1
+metRology,.construct.uncert,10,0,0,character[],1
+metRology,.construct.uncert,10,0,1,null,1
+metRology,.construct.uncert,11,0,0,class<`matrix`>,1
+metRology,.construct.uncert,11,0,1,null,1
+metRology,.construct.uncert,12,0,0,class<`matrix`>,1
+metRology,.construct.uncert,13,0,0,null,1
+metRology,.construct.uncert,14,0,0,list<character>,1
+metRology,.construct.uncert,14,0,1,null,1
+metRology,.construct.uncert,15,0,0,list<list<double>>,1
+metRology,.construct.uncert,15,0,1,null,1
+metRology,contribs,-1,0,0,class<`matrix`>,1
+metRology,contribs,-1,0,1,double[],1
+metRology,contribs,0,0,0,"class<`list`, `uncert`>",1
+metRology,contribs,1,0,0,any,1
+metRology,contribs,2,0,0,logical,1
+metRology,contribs,3,0,0,logical,1
+metRology,contribs,4,0,0,logical,1
+metRology,contribs,5,0,0,logical,1
+metRology,cov.dellipse,-1,0,0,class<`cov.dellipse`>,1
+metRology,cov.dellipse,0,0,0,class<`data.frame`>,1
+metRology,cov.dellipse,0,0,1,class<`matrix`>,1
+metRology,cov.dellipse,1,0,0,null,1
+metRology,cov.dellipse,2,0,0,character[],1
+metRology,cov.dellipse,2,0,1,null,1
+metRology,cov.dellipse,3,0,0,null,1
+metRology,cov.dellipse,3,0,1,class<`function`>,1
+metRology,cov.dellipse,4,0,0,null,1
+metRology,cov.dellipse,5,0,0,list<any>,1
+metRology,cplot,-1,0,0,class<`matrix`>,1
+metRology,cplot,0,0,0,double[],1
+metRology,cplot,1,0,0,double[],1
+metRology,cplot,2,0,0,null,1
+metRology,cplot,3,0,0,character,1
+metRology,cplot,4,0,0,logical,1
+metRology,cplot,5,0,0,double[],1
+metRology,cplot,6,0,0,character[],1
+metRology,cplot,7,0,0,logical,1
+metRology,cplot,8,0,0,character,1
+metRology,cplot,9,0,0,null,1
+metRology,cplot,10,0,0,logical,1
+metRology,cplot,11,0,0,double,1
+metRology,cplot,12,0,0,double,1
+metRology,cplot,13,0,0,...,1
+metRology,data.ellipse,-1,0,0,class<`d.ellipse`>,1
+metRology,data.ellipse,0,0,0,class<`cov.dellipse`>,1
+metRology,data.ellipse,1,0,0,double[],1
+metRology,data.ellipse,2,0,0,logical,1
+metRology,data.ellipse,3,0,0,double,1
+metRology,data.ellipse,4,0,0,...,1
+metRology,drop1.uncert,-1,0,0,"class<`data.frame`, `drop1.uncert`>",1
+metRology,drop1.uncert,-1,0,1,double[],1
+metRology,drop1.uncert,0,0,0,"class<`list`, `uncert`>",1
+metRology,drop1.uncert,1,0,0,any,1
+metRology,drop1.uncert,2,0,0,logical,1
+metRology,drop1.uncert,3,0,0,character[],1
+metRology,drop1.uncert,4,0,0,...,1
+metRology,dsl,-1,0,0,class<`loc.est`>,1
+metRology,dsl,0,0,0,double[],1
+metRology,dsl,1,0,0,...,1
+metRology,dsl,2,0,0,logical,1
+metRology,dsl.default,-1,0,0,class<`loc.est`>,1
+metRology,dsl.default,0,0,0,double[],1
+metRology,dsl.default,1,0,0,double[],1
+metRology,dsl.default,2,0,0,null,1
+metRology,dsl.default,3,0,0,null,1
+metRology,dsl.default,4,0,0,...,1
+metRology,dsl.default,5,0,0,logical,1
+metRology,dtri,-1,0,0,double[],1
+metRology,dtri,0,0,0,double[],1
+metRology,dtri,1,0,0,double,1
+metRology,dtri,2,0,0,double,1
+metRology,dtri,3,0,0,double,1
+metRology,dtri,4,0,0,logical,1
+metRology,duewer.plot,-1,0,0,list<double>,1
+metRology,duewer.plot,0,0,0,double[],1
+metRology,duewer.plot,1,0,0,...,1
+metRology,duewer.plot.default,-1,0,0,list<double>,1
+metRology,duewer.plot.default,0,0,0,double[],1
+metRology,duewer.plot.default,1,0,0,double[],1
+metRology,duewer.plot.default,2,0,0,double,1
+metRology,duewer.plot.default,3,0,0,double,1
+metRology,duewer.plot.default,4,0,0,double,1
+metRology,duewer.plot.default,5,0,0,null,1
+metRology,duewer.plot.default,6,0,0,integer[],1
+metRology,duewer.plot.default,7,0,0,character[],1
+metRology,duewer.plot.default,8,0,0,any,1
+metRology,duewer.plot.default,9,0,0,any,1
+metRology,duewer.plot.default,10,0,0,any,1
+metRology,duewer.plot.default,11,0,0,any,1
+metRology,duewer.plot.default,12,0,0,any,1
+metRology,duewer.plot.default,13,0,0,null,1
+metRology,duewer.plot.default,14,0,0,null,1
+metRology,duewer.plot.default,15,0,0,any,1
+metRology,.get.df,-1,0,0,double,1
+metRology,.get.df,0,0,0,double,1
+metRology,.get.df,1,0,0,double,1
+metRology,.get.mandel.rowname,-1,0,0,character,1
+metRology,.get.mandel.rowname,0,0,0,character,1
+metRology,.get.mandel.rowname,1,0,0,any,1
+metRology,.get.pars,-1,0,0,list<double>,1
+metRology,.get.pars,0,0,0,character,1
+metRology,.get.pars,1,0,0,double,1
+metRology,.get.pars,2,0,0,double,1
+metRology,.get.pars,3,0,0,any,1
+metRology,gplot,-1,0,0,integer[],1
+metRology,gplot,0,0,0,"class<`data.frame`, `mandel.kh`>",1
+metRology,gplot,1,0,0,character,1
+metRology,gplot,1,0,1,null,1
+metRology,gplot,2,0,0,character,1
+metRology,gplot,2,0,1,null,1
+metRology,gplot,3,0,0,character,1
+metRology,gplot,4,0,0,null,1
+metRology,gplot,5,0,0,double,1
+metRology,gplot,6,0,0,logical,1
+metRology,gplot,7,0,0,double,1
+metRology,gplot,8,0,0,logical,1
+metRology,gplot,9,0,0,double,1
+metRology,gplot,10,0,0,double,1
+metRology,gplot,11,0,0,character,1
+metRology,gplot,11,0,1,integer[],1
+metRology,gplot,12,0,0,logical,1
+metRology,gplot,13,0,0,character,1
+metRology,gplot,14,0,0,double,1
+metRology,gplot,15,0,0,double,1
+metRology,GUM,-1,0,0,list<double[] | class<`matrix`> | character[]>,1
+metRology,GUM,-1,0,1,list<double | class<`matrix`> | character[]>,1
+metRology,GUM,0,0,0,character[],1
+metRology,GUM,1,0,0,class<`matrix`>,1
+metRology,GUM,1,0,1,double[],1
+metRology,GUM,2,0,0,class<`matrix`>,1
+metRology,GUM,2,0,1,double[],1
+metRology,GUM,3,0,0,class<`matrix`>,1
+metRology,GUM,3,0,1,double[],1
+metRology,GUM,4,0,0,character,1
+metRology,GUM,5,0,0,class<`matrix`>,1
+metRology,GUM,6,0,0,character[],1
+metRology,GUM,7,0,0,double,1
+metRology,GUM,8,0,0,character,1
+metRology,GUM,9,0,0,double,1
+metRology,GUM,10,0,0,...,1
+metRology,GUM.validate,-1,0,0,double,1
+metRology,GUM.validate,0,0,0,character[],1
+metRology,GUM.validate,1,0,0,double[],1
+metRology,GUM.validate,2,0,0,double[],1
+metRology,GUM.validate,3,0,0,double[],1
+metRology,GUM.validate,4,0,0,character[],1
+metRology,GUM.validate,5,0,0,character[],1
+metRology,GUM.validate,6,0,0,character,1
+metRology,GUM.validate,7,0,0,class<`matrix`>,1
+metRology,GUM.validate,8,0,0,character[],1
+metRology,GUM.validate,9,0,0,double,1
+metRology,GUM.validate,10,0,0,character,1
+metRology,GUM.validate,11,0,0,double,1
+metRology,huber.estimate,-1,0,0,class<`loc.est`>,1
+metRology,huber.estimate,0,0,0,double[],1
+metRology,huber.estimate,1,0,0,...,1
+metRology,huber.estimate.default,-1,0,0,class<`loc.est`>,1
+metRology,huber.estimate.default,0,0,0,double[],1
+metRology,huber.estimate.default,1,0,0,double[],1
+metRology,huber.estimate.default,2,0,0,double,1
+metRology,huber.estimate.default,3,0,0,...,1
+metRology,[.ilab,-1,0,0,class<`ilab`>,1
+metRology,[.ilab,0,0,0,class<`ilab`>,1
+metRology,[.ilab,1,0,0,integer[],1
+metRology,[.ilab,2,0,0,any,1
+metRology,kplot,-1,0,0,list<integer[]>,1
+metRology,kplot,0,0,0,class<`ilab`>,1
+metRology,kplot,0,0,1,double[],1
+metRology,kplot,1,0,0,...,1
+metRology,kplot.default,-1,0,0,list<integer[]>,1
+metRology,kplot.default,0,0,0,double[],1
+metRology,kplot.default,1,0,0,double[],1
+metRology,kplot.default,2,0,0,null,1
+metRology,kplot.default,3,0,0,double,1
+metRology,kplot.default,4,0,0,double,1
+metRology,kplot.default,5,0,0,double[],1
+metRology,kplot.default,6,0,0,double[],1
+metRology,kplot.default,7,0,0,double,1
+metRology,kplot.default,8,0,0,null,1
+metRology,kplot.default,9,0,0,logical,1
+metRology,kplot.default,10,0,0,logical,1
+metRology,kplot.default,11,0,0,any,1
+metRology,kplot.default,12,0,0,any,1
+metRology,kplot.default,13,0,0,any,1
+metRology,kplot.default,14,0,0,null,1
+metRology,kplot.default,15,0,0,null,1
+metRology,kplot.ilab,-1,0,0,list<integer[]>,1
+metRology,kplot.ilab,0,0,0,class<`ilab`>,1
+metRology,kplot.ilab,1,0,0,...,1
+metRology,LCS,-1,0,0,integer[],1
+metRology,LCS,0,0,0,double[],1
+metRology,LCS,1,0,0,double[],1
+metRology,LCS,2,0,0,double,1
+metRology,LCS,3,0,0,character,1
+metRology,LCS,4,0,0,logical,1
+metRology,LCS,5,0,0,logical,1
+metRology,mandel.h,-1,0,0,"class<`data.frame`, `mandel.kh`>",1
+metRology,mandel.h,0,0,0,class<`data.frame`>,1
+metRology,mandel.h,0,0,1,class<`ilab`>,1
+metRology,mandel.h,0,0,2,^double[],1
+metRology,mandel.h,1,0,0,class<`factor`>,1
+metRology,mandel.h,1,0,1,null,1
+metRology,mandel.h,2,0,0,null,1
+metRology,mandel.h,2,0,1,class<`factor`>,1
+metRology,mandel.h,3,0,0,any,1
+metRology,mandel.h,4,0,0,null,1
+metRology,mandel.h,4,0,1,character,1
+metRology,mandel.h,5,0,0,any,1
+metRology,mandel.h,6,0,0,null,1
+metRology,mandel.h,7,0,0,...,1
+metRology,mandel.h.default,-1,0,0,"class<`data.frame`, `mandel.kh`>",1
+metRology,mandel.h.default,0,0,0,class<`data.frame`>,1
+metRology,mandel.h.default,0,0,1,^double[],1
+metRology,mandel.h.default,1,0,0,class<`factor`>,1
+metRology,mandel.h.default,2,0,0,null,1
+metRology,mandel.h.default,2,0,1,class<`factor`>,1
+metRology,mandel.h.default,3,0,0,logical,1
+metRology,mandel.h.default,4,0,0,null,1
+metRology,mandel.h.default,4,0,1,character,1
+metRology,mandel.h.default,5,0,0,character[],1
+metRology,mandel.h.default,6,0,0,null,1
+metRology,mandel.h.default,7,0,0,...,1
+metRology,mandel.h.ilab,-1,0,0,"class<`data.frame`, `mandel.kh`>",1
+metRology,mandel.h.ilab,0,0,0,class<`ilab`>,1
+metRology,mandel.h.ilab,1,0,0,null,1
+metRology,mandel.h.ilab,2,0,0,null,1
+metRology,mandel.h.ilab,3,0,0,logical,1
+metRology,mandel.h.ilab,4,0,0,null,1
+metRology,mandel.h.ilab,5,0,0,character[],1
+metRology,mandel.h.ilab,6,0,0,null,1
+metRology,mandel.h.ilab,7,0,0,...,1
+metRology,mandel.k,-1,0,0,"class<`data.frame`, `mandel.kh`>",1
+metRology,mandel.k,0,0,0,class<`data.frame`>,1
+metRology,mandel.k,0,0,1,class<`ilab`>,1
+metRology,mandel.k,0,0,2,^double[],1
+metRology,mandel.k,1,0,0,class<`factor`>,1
+metRology,mandel.k,1,0,1,null,1
+metRology,mandel.k,2,0,0,null,1
+metRology,mandel.k,2,0,1,class<`factor`>,1
+metRology,mandel.k,3,0,0,any,1
+metRology,mandel.k,4,0,0,null,1
+metRology,mandel.k,4,0,1,character,1
+metRology,mandel.k,5,0,0,any,1
+metRology,mandel.k,6,0,0,null,1
+metRology,mandel.k,7,0,0,...,1
+metRology,mandel.k.default,-1,0,0,"class<`data.frame`, `mandel.kh`>",1
+metRology,mandel.k.default,0,0,0,class<`data.frame`>,1
+metRology,mandel.k.default,0,0,1,^double[],1
+metRology,mandel.k.default,1,0,0,class<`factor`>,1
+metRology,mandel.k.default,2,0,0,null,1
+metRology,mandel.k.default,2,0,1,class<`factor`>,1
+metRology,mandel.k.default,3,0,0,logical,1
+metRology,mandel.k.default,4,0,0,null,1
+metRology,mandel.k.default,4,0,1,character,1
+metRology,mandel.k.default,5,0,0,character[],1
+metRology,mandel.k.default,6,0,0,null,1
+metRology,mandel.k.default,7,0,0,...,1
+metRology,mandel.kh,-1,0,0,"class<`data.frame`, `mandel.kh`>",1
+metRology,mandel.kh,0,0,0,class<`data.frame`>,1
+metRology,mandel.kh,0,0,1,class<`ilab`>,1
+metRology,mandel.kh,0,0,2,^double[],1
+metRology,mandel.kh,1,0,0,class<`factor`>,1
+metRology,mandel.kh,1,0,1,null,1
+metRology,mandel.kh,2,0,0,any,1
+metRology,mandel.kh,3,0,0,any,1
+metRology,mandel.kh,4,0,0,any,1
+metRology,mandel.kh,5,0,0,any,1
+metRology,mandel.kh,6,0,0,any,1
+metRology,mandel.kh,7,0,0,null,1
+metRology,mandel.kh,8,0,0,...,1
+metRology,mandel.kh.data.frame,-1,0,0,"class<`data.frame`, `mandel.kh`>",1
+metRology,mandel.kh.data.frame,0,0,0,class<`data.frame`>,1
+metRology,mandel.kh.data.frame,1,0,0,class<`factor`>,1
+metRology,mandel.kh.data.frame,2,0,0,any,1
+metRology,mandel.kh.data.frame,3,0,0,logical,1
+metRology,mandel.kh.data.frame,4,0,0,any,1
+metRology,mandel.kh.data.frame,5,0,0,character[],1
+metRology,mandel.kh.data.frame,6,0,0,character[],1
+metRology,mandel.kh.data.frame,7,0,0,null,1
+metRology,mandel.kh.data.frame,8,0,0,...,1
+metRology,mandel.kh.default,-1,0,0,"class<`data.frame`, `mandel.kh`>",1
+metRology,mandel.kh.default,0,0,0,^double[],1
+metRology,mandel.kh.default,1,0,0,class<`factor`>,1
+metRology,mandel.kh.default,2,0,0,class<`factor`>,1
+metRology,mandel.kh.default,3,0,0,logical,1
+metRology,mandel.kh.default,4,0,0,any,1
+metRology,mandel.kh.default,5,0,0,character[],1
+metRology,mandel.kh.default,6,0,0,character[],1
+metRology,mandel.kh.default,7,0,0,null,1
+metRology,mandel.kh.default,8,0,0,...,1
+metRology,mandel.kh.ilab,-1,0,0,"class<`data.frame`, `mandel.kh`>",1
+metRology,mandel.kh.ilab,0,0,0,class<`ilab`>,1
+metRology,mandel.kh.ilab,1,0,0,null,1
+metRology,mandel.kh.ilab,2,0,0,null,1
+metRology,mandel.kh.ilab,3,0,0,logical,1
+metRology,mandel.kh.ilab,4,0,0,null,1
+metRology,mandel.kh.ilab,5,0,0,character,1
+metRology,mandel.kh.ilab,6,0,0,character[],1
+metRology,mandel.kh.ilab,7,0,0,null,1
+metRology,mandel.kh.ilab,8,0,0,...,1
+metRology,mandel.k.ilab,-1,0,0,"class<`data.frame`, `mandel.kh`>",1
+metRology,mandel.k.ilab,0,0,0,class<`ilab`>,1
+metRology,mandel.k.ilab,1,0,0,null,1
+metRology,mandel.k.ilab,2,0,0,null,1
+metRology,mandel.k.ilab,3,0,0,logical,1
+metRology,mandel.k.ilab,4,0,0,null,1
+metRology,mandel.k.ilab,5,0,0,character[],1
+metRology,mandel.k.ilab,6,0,0,null,1
+metRology,mandel.k.ilab,7,0,0,...,1
+metRology,mle.1wre,-1,0,0,class<`summary.mle.1wre`>,1
+metRology,mle.1wre,0,0,0,double[],1
+metRology,mle.1wre,1,0,0,double[],1
+metRology,mle.1wre,2,0,0,double[],1
+metRology,mle.1wre,3,0,0,double,1
+metRology,mle.1wre,4,0,0,double,1
+metRology,mle.1wre,5,0,0,integer[],1
+metRology,mle.1wre,6,0,0,double,1
+metRology,mle.1wre,7,0,0,double,1
+metRology,mle.1wre,8,0,0,logical,1
+metRology,MM.estimate,-1,0,0,class<`loc.est`>,1
+metRology,MM.estimate,0,0,0,double[],1
+metRology,MM.estimate,1,0,0,...,1
+metRology,MM.estimate.default,-1,0,0,class<`loc.est`>,1
+metRology,MM.estimate.default,0,0,0,double[],1
+metRology,MM.estimate.default,1,0,0,double[],1
+metRology,MM.estimate.default,2,0,0,double,1
+metRology,MM.estimate.default,3,0,0,...,1
+metRology,mpaule,-1,0,0,class<`loc.est`>,1
+metRology,mpaule,0,0,0,double[],1
+metRology,mpaule,1,0,0,...,1
+metRology,mpaule,2,0,0,any,1
+metRology,mpaule,3,0,0,double,1
+metRology,mpaule.default,-1,0,0,class<`loc.est`>,1
+metRology,mpaule.default,0,0,0,double[],1
+metRology,mpaule.default,1,0,0,double[],1
+metRology,mpaule.default,2,0,0,null,1
+metRology,mpaule.default,3,0,0,null,1
+metRology,mpaule.default,4,0,0,double,1
+metRology,mpaule.default,5,0,0,double,1
+metRology,mpaule.default,6,0,0,...,1
+metRology,msd,-1,0,0,"class<`MSD`, `numeric`>",1
+metRology,msd,0,0,0,double[],1
+metRology,msd,1,0,0,class<`function`>,1
+metRology,msd,1,0,1,double[],1
+metRology,msd,2,0,0,...,1
+metRology,nclass.23,-1,0,0,double,1
+metRology,nclass.23,0,0,0,double[],1
+metRology,.neg.ll.reml,-1,0,0,double,1
+metRology,.neg.ll.reml,0,0,0,double,1
+metRology,.neg.ll.reml,1,0,0,double,1
+metRology,.neg.ll.reml,2,0,0,double[],1
+metRology,.neg.ll.reml,3,0,0,double[],1
+metRology,.neg.ll.reml,4,0,0,logical,1
+metRology,.neg.ll.reml,5,0,0,logical,1
+metRology,.neg.ll.reml,6,0,0,logical,1
+metRology,.newton.raphson,-1,0,0,double,1
+metRology,.newton.raphson,0,0,0,class<`function`>,1
+metRology,.newton.raphson,1,0,0,class<`function`>,1
+metRology,.newton.raphson,2,0,0,double,1
+metRology,.newton.raphson,3,0,0,double,1
+metRology,.newton.raphson,4,0,0,logical,1
+metRology,.newton.raphson,5,0,0,double,1
+metRology,plot.d.ellipse,-1,0,0,null,1
+metRology,plot.d.ellipse,0,0,0,class<`d.ellipse`>,1
+metRology,plot.d.ellipse,1,0,0,double,1
+metRology,plot.d.ellipse,2,0,0,double,1
+metRology,plot.d.ellipse,3,0,0,double,1
+metRology,plot.d.ellipse,4,0,0,null,1
+metRology,plot.d.ellipse,5,0,0,null,1
+metRology,plot.d.ellipse,6,0,0,double,1
+metRology,plot.d.ellipse,7,0,0,logical,1
+metRology,plot.d.ellipse,8,0,0,double,1
+metRology,plot.d.ellipse,9,0,0,any,1
+metRology,plot.d.ellipse,10,0,0,any,1
+metRology,plot.d.ellipse,11,0,0,logical,1
+metRology,plot.d.ellipse,12,0,0,double,1
+metRology,plot.d.ellipse,13,0,0,double,1
+metRology,plot.d.ellipse,14,0,0,double,1
+metRology,plot.d.ellipse,15,0,0,null,1
+metRology,plot.drop1.uncert,-1,0,0,null,1
+metRology,plot.drop1.uncert,0,0,0,"class<`data.frame`, `drop1.uncert`>",1
+metRology,plot.drop1.uncert,1,0,0,...,1
+metRology,plot.drop1.uncert,2,0,0,character[],1
+metRology,plot.ilab,-1,0,0,list<integer[]>,1
+metRology,plot.ilab,0,0,0,class<`ilab`>,1
+metRology,plot.ilab,1,0,0,...,1
+metRology,plot.mandel.kh,-1,0,0,integer[],1
+metRology,plot.mandel.kh,0,0,0,"class<`data.frame`, `mandel.kh`>",1
+metRology,plot.mandel.kh,1,0,0,double[],1
+metRology,plot.mandel.kh,2,0,0,any,1
+metRology,plot.mandel.kh,3,0,0,character,1
+metRology,plot.mandel.kh,4,0,0,character,1
+metRology,plot.mandel.kh,5,0,0,null,1
+metRology,plot.mandel.kh,6,0,0,double,1
+metRology,plot.mandel.kh,7,0,0,logical,1
+metRology,plot.mandel.kh,8,0,0,double,1
+metRology,plot.mandel.kh,9,0,0,logical,1
+metRology,plot.mandel.kh,10,0,0,double,1
+metRology,plot.mandel.kh,11,0,0,double,1
+metRology,plot.mandel.kh,12,0,0,character,1
+metRology,plot.mandel.kh,12,0,1,integer[],1
+metRology,plot.mandel.kh,13,0,0,double,1
+metRology,plot.mandel.kh,14,0,0,double[],1
+metRology,plot.mandel.kh,15,0,0,double,1
+metRology,plot.MSD,-1,0,0,null,1
+metRology,plot.MSD,0,0,0,"class<`MSD`, `numeric`>",1
+metRology,plot.MSD,1,0,0,character,1
+metRology,plot.MSD,2,0,0,character,1
+metRology,plot.MSD,3,0,0,...,1
+metRology,plot.uncert,-1,0,0,class<`matrix`>,1
+metRology,plot.uncert,0,0,0,"class<`list`, `uncert`>",1
+metRology,plot.uncert,1,0,0,integer[],1
+metRology,plot.uncert,2,0,0,character,1
+metRology,plot.uncert,3,0,0,logical,1
+metRology,plot.uncert,4,0,0,list<character | expression>,1
+metRology,plot.uncert,5,0,0,double,1
+metRology,plot.uncert,6,0,0,...,1
+metRology,plot.uncertMC,-1,0,0,null,1
+metRology,plot.uncertMC,0,0,0,"class<`list`, `uncert`, `uncertMC`>",1
+metRology,plot.uncertMC,1,0,0,integer[],1
+metRology,plot.uncertMC,2,0,0,character,1
+metRology,plot.uncertMC,3,0,0,logical,1
+metRology,plot.uncertMC,4,0,0,list<character>,1
+metRology,plot.uncertMC,5,0,0,character,1
+metRology,plot.uncertMC,6,0,0,...,1
+metRology,plot.uncertMC,7,0,0,double,1
+metRology,plot.uncertMC,8,0,0,double,1
+metRology,plot.uncertMC,9,0,0,double,1
+metRology,plot.uncertMC,10,0,0,double,1
+metRology,plot.uncertMC,11,0,0,double,1
+metRology,plot.uncertMC,12,0,0,null,1
+metRology,plot.uncertMC,13,0,0,null,1
+metRology,plot.uncertMC,14,0,0,null,1
+metRology,.pmsd.interp.spline,-1,0,0,class<`function`>,1
+metRology,.pmsd.interp.spline,0,0,0,integer,1
+metRology,.pmsd.interp.spline,1,0,0,logical,1
+metRology,print.ilab,-1,0,0,class<`data.frame`>,1
+metRology,print.ilab,0,0,0,class<`ilab`>,1
+metRology,print.ilab,1,0,0,...,1
+metRology,print.ilab,2,0,0,null,1
+metRology,print.ilab,3,0,0,logical,1
+metRology,print.loc.est,-1,0,0,null,1
+metRology,print.loc.est,0,0,0,class<`loc.est`>,1
+metRology,print.loc.est,1,0,0,...,1
+metRology,print.uncert,-1,0,0,"class<`list`, `uncert`>",1
+metRology,print.uncert,0,0,0,"class<`list`, `uncert`>",1
+metRology,print.uncert,1,0,0,null,1
+metRology,print.uncert,2,0,0,logical,1
+metRology,print.uncert,3,0,0,...,1
+metRology,print.uncert,4,0,0,logical,1
+metRology,print.uncertMC,-1,0,0,"class<`list`, `uncert`, `uncertMC`>",1
+metRology,print.uncertMC,0,0,0,"class<`list`, `uncert`, `uncertMC`>",1
+metRology,print.uncertMC,1,0,0,null,1
+metRology,print.uncertMC,2,0,0,logical,1
+metRology,print.uncertMC,3,0,0,...,1
+metRology,print.uncertMC,4,0,0,logical,1
+metRology,print.uncertMC,5,0,0,logical,1
+metRology,ptri,-1,0,0,double[],1
+metRology,ptri,0,0,0,double[],1
+metRology,ptri,1,0,0,double,1
+metRology,ptri,2,0,0,double,1
+metRology,ptri,3,0,0,double,1
+metRology,ptri,4,0,0,logical,1
+metRology,ptri,5,0,0,logical,1
+metRology,qmandelh,-1,0,0,double[],1
+metRology,qmandelh,0,0,0,double[],1
+metRology,qmandelh,1,0,0,integer[],1
+metRology,qmandelh,2,0,0,logical,1
+metRology,qmandelh,3,0,0,logical,1
+metRology,qmandelk,-1,0,0,double[],1
+metRology,qmandelk,0,0,0,double[],1
+metRology,qmandelk,1,0,0,integer[],1
+metRology,qmandelk,2,0,0,double,1
+metRology,qmandelk,3,0,0,logical,1
+metRology,qmandelk,4,0,0,logical,1
+metRology,qmsd,-1,0,0,double[],1
+metRology,qmsd,0,0,0,double[],1
+metRology,qmsd,1,0,0,integer,1
+metRology,qmsd,2,0,0,logical,1
+metRology,qmsd,3,0,0,character[],1
+metRology,qmsd,4,0,0,double,1
+metRology,.qmsd.interp,-1,0,0,double[],1
+metRology,.qmsd.interp,0,0,0,double[],1
+metRology,.qmsd.interp,1,0,0,integer,1
+metRology,.qmsd.interp,2,0,0,logical,1
+metRology,qtri,-1,0,0,double[],1
+metRology,qtri,0,0,0,double[],1
+metRology,qtri,1,0,0,double,1
+metRology,qtri,2,0,0,double,1
+metRology,qtri,3,0,0,double,1
+metRology,qtri,4,0,0,logical,1
+metRology,qtri,5,0,0,logical,1
+metRology,qt.scaled,-1,0,0,double[],1
+metRology,qt.scaled,0,0,0,double[],1
+metRology,qt.scaled,1,0,0,double,1
+metRology,qt.scaled,2,0,0,double,1
+metRology,qt.scaled,3,0,0,double,1
+metRology,qt.scaled,4,0,0,any,1
+metRology,qt.scaled,5,0,0,logical,1
+metRology,qt.scaled,6,0,0,logical,1
+metRology,rbind,-1,0,0,class<`data.frame`>,1
+metRology,rbind,-1,0,1,class<`ilab`>,1
+metRology,rbind,-1,0,2,class<`matrix`>,1
+metRology,rbind,0,0,0,...,1
+metRology,rbind,1,0,0,any,1
+metRology,rbind.default,-1,0,0,class<`matrix`>,1
+metRology,rbind.default,0,0,0,...,1
+metRology,rbind.default,1,0,0,double,1
+metRology,rbind.ilab,-1,0,0,class<`ilab`>,1
+metRology,rbind.ilab,0,0,0,...,1
+metRology,rbind.ilab,1,0,0,double,1
+metRology,reml.loc,-1,0,0,class<`loc.est`>,1
+metRology,reml.loc,0,0,0,double[],1
+metRology,reml.loc,1,0,0,...,1
+metRology,reml.loc,2,0,0,logical,1
+metRology,reml.loc.default,-1,0,0,class<`loc.est`>,1
+metRology,reml.loc.default,0,0,0,double[],1
+metRology,reml.loc.default,1,0,0,double[],1
+metRology,reml.loc.default,2,0,0,null,1
+metRology,reml.loc.default,3,0,0,null,1
+metRology,reml.loc.default,4,0,0,logical,1
+metRology,reml.loc.default,5,0,0,double,1
+metRology,reml.loc.default,6,0,0,logical,1
+metRology,reml.loc.default,7,0,0,...,1
+metRology,rtri,-1,0,0,double[],1
+metRology,rtri,0,0,0,double,1
+metRology,rtri,1,0,0,double,1
+metRology,rtri,2,0,0,double,1
+metRology,rtri,3,0,0,double,1
+metRology,rt.scaled,-1,0,0,double[],1
+metRology,rt.scaled,0,0,0,double,1
+metRology,rt.scaled,1,0,0,double,1
+metRology,rt.scaled,2,0,0,double,1
+metRology,rt.scaled,3,0,0,double,1
+metRology,rt.scaled,4,0,0,any,1
+metRology,subset.ilab,-1,0,0,class<`ilab`>,1
+metRology,subset.ilab,0,0,0,class<`ilab`>,1
+metRology,subset.ilab,1,0,0,any,1
+metRology,subset.ilab,2,0,0,logical,1
+metRology,subset.ilab,3,0,0,...,1
+metRology,summary.d.ellipse,-1,0,0,"list<class<`summaryDefault`, `table`>>",1
+metRology,summary.d.ellipse,0,0,0,class<`d.ellipse`>,1
+metRology,summary.d.ellipse,1,0,0,...,1
+metRology,.to.wide,-1,0,0,class<`data.frame`>,1
+metRology,.to.wide,0,0,0,^double[],1
+metRology,.to.wide,1,0,0,class<`factor`>,1
+metRology,.to.wide,2,0,0,class<`factor`>,1
+metRology,uncert,-1,0,0,"class<`list`, `uncert`>",1
+metRology,uncert,-1,0,1,"class<`list`, `uncert`, `uncertMC`>",1
+metRology,uncert,0,0,0,any,1
+metRology,uncert,1,0,0,...,1
+metRology,uncert.default,-1,0,0,"class<`list`, `uncert`>",1
+metRology,uncert.default,0,0,0,any,1
+metRology,uncert.default,1,0,0,double[],1
+metRology,uncert.default,2,0,0,character[],1
+metRology,uncert.default,3,0,0,any,1
+metRology,uncert.default,4,0,0,any,1
+metRology,uncert.default,5,0,0,null,1
+metRology,uncert.default,6,0,0,null,1
+metRology,uncert.default,7,0,0,double,1
+metRology,uncert.default,8,0,0,null,1
+metRology,uncert.default,9,0,0,logical,1
+metRology,uncert.default,10,0,0,double[],1
+metRology,uncert.default,11,0,0,...,1
+metRology,uncert.expression,-1,0,0,"class<`list`, `uncert`>",1
+metRology,uncert.expression,-1,0,1,"class<`list`, `uncert`, `uncertMC`>",1
+metRology,uncert.expression,0,0,0,expression,1
+metRology,uncert.expression,1,0,0,list<double>,1
+metRology,uncert.expression,2,0,0,list<double>,1
+metRology,uncert.expression,3,0,0,character,1
+metRology,uncert.expression,4,0,0,any,1
+metRology,uncert.expression,5,0,0,any,1
+metRology,uncert.expression,6,0,0,null,1
+metRology,uncert.expression,7,0,0,null,1
+metRology,uncert.expression,8,0,0,double,1
+metRology,uncert.expression,9,0,0,double,1
+metRology,uncert.expression,10,0,0,logical,1
+metRology,uncert.expression,11,0,0,...,1
+metRology,uncert.formula,-1,0,0,"class<`list`, `uncert`>",1
+metRology,uncert.formula,-1,0,1,"class<`list`, `uncert`, `uncertMC`>",1
+metRology,uncert.formula,0,0,0,class<`formula`>,1
+metRology,uncert.formula,1,0,0,list<double>,1
+metRology,uncert.formula,2,0,0,list<double>,1
+metRology,uncert.formula,3,0,0,character,1
+metRology,uncert.formula,4,0,0,any,1
+metRology,uncert.formula,5,0,0,any,1
+metRology,uncert.formula,6,0,0,null,1
+metRology,uncert.formula,7,0,0,null,1
+metRology,uncert.formula,8,0,0,double,1
+metRology,uncert.formula,9,0,0,double,1
+metRology,uncert.formula,10,0,0,logical,1
+metRology,uncert.formula,11,0,0,...,1
+metRology,uncert.function,-1,0,0,"class<`list`, `uncert`>",1
+metRology,uncert.function,0,0,0,class<`function`>,1
+metRology,uncert.function,1,0,0,list<double>,1
+metRology,uncert.function,2,0,0,any,1
+metRology,uncert.function,3,0,0,character,1
+metRology,uncert.function,4,0,0,any,1
+metRology,uncert.function,5,0,0,any,1
+metRology,uncert.function,6,0,0,null,1
+metRology,uncert.function,7,0,0,null,1
+metRology,uncert.function,8,0,0,any,1
+metRology,uncert.function,9,0,0,double,1
+metRology,uncert.function,10,0,0,logical,1
+metRology,uncert.function,11,0,0,...,1
+metRology,uncertMC,-1,0,0,"class<`list`, `uncert`, `uncertMC`>",1
+metRology,uncertMC,0,0,0,class<`formula`>,1
+metRology,uncertMC,0,0,1,expression,1
+metRology,uncertMC,1,0,0,list<double>,1
+metRology,uncertMC,2,0,0,any,1
+metRology,uncertMC,3,0,0,character,1
+metRology,uncertMC,4,0,0,any,1
+metRology,uncertMC,5,0,0,any,1
+metRology,uncertMC,6,0,0,any,1
+metRology,uncertMC,7,0,0,null,1
+metRology,uncertMC,7,0,1,character[],1
+metRology,uncertMC,8,0,0,any,1
+metRology,uncertMC,9,0,0,double,1
+metRology,uncertMC,10,0,0,logical,1
+metRology,uncertMC,11,0,0,logical,1
+metRology,uncertMC,12,0,0,...,1
+metRology,updateCor,-1,0,0,class<`matrix`>,1
+metRology,updateCor,0,0,0,class<`matrix`>,1
+metRology,updateCor,1,0,0,double[],1
+metRology,updateCor,2,0,0,any,1
+metRology,update.uncert,-1,0,0,"class<`list`, `uncert`>",1
+metRology,update.uncert,-1,0,1,"class<`list`, `uncert`, `uncertMC`>",1
+metRology,update.uncert,0,0,0,"class<`list`, `uncert`>",1
+metRology,update.uncert,1,0,0,null,1
+metRology,update.uncert,2,0,0,null,1
+metRology,update.uncert,2,0,1,character,1
+metRology,update.uncert,3,0,0,null,1
+metRology,update.uncert,4,0,0,list<double>,1
+metRology,update.uncert,4,0,1,null,1
+metRology,update.uncert,5,0,0,null,1
+metRology,update.uncert,6,0,0,null,1
+metRology,update.uncert,7,0,0,null,1
+metRology,update.uncert,8,0,0,null,1
+metRology,update.uncert,9,0,0,null,1
+metRology,update.uncert,10,0,0,null,1
+metRology,update.uncert,11,0,0,null,1
+metRology,update.uncert,12,0,0,null,1
+metRology,update.uncert,13,0,0,null,1
+metRology,update.uncert,14,0,0,...,1
+metRology,vr.mle,-1,0,0,class<`summary.vr.mle`>,1
+metRology,vr.mle,0,0,0,double[],1
+metRology,vr.mle,1,0,0,double[],1
+metRology,vr.mle,2,0,0,double[],1
+metRology,vr.mle,3,0,0,double,1
+metRology,vr.mle,4,0,0,double,1
+metRology,vr.mle,5,0,0,integer[],1
+metRology,vr.mle,6,0,0,double,1
+metRology,vr.mle,7,0,0,double,1
+metRology,vr.mle,8,0,0,logical,1
+metRology,w.s,-1,0,0,double,1
+metRology,w.s,0,0,0,double[],1
+metRology,w.s,1,0,0,double[],1
+metRology,w.s,2,0,0,double[],1
+metRology,w.s,3,0,0,double,1
+metRology,xs.plot,-1,0,0,list<class<`array`> | double | list<class<`data.frame`>>>,1
+metRology,xs.plot,0,0,0,class<`array`>,1
+metRology,xs.plot,0,0,1,double[],1
+metRology,xs.plot,1,0,0,...,1
+metRology,xs.plot.default,-1,0,0,list<class<`array`> | double | list<class<`data.frame`>>>,1
+metRology,xs.plot.default,0,0,0,class<`array`>,1
+metRology,xs.plot.default,0,0,1,double[],1
+metRology,xs.plot.default,1,0,0,any,1
+metRology,xs.plot.default,2,0,0,any,1
+metRology,xs.plot.default,3,0,0,any,1
+metRology,xs.plot.default,4,0,0,null,1
+metRology,xs.plot.default,4,0,1,logical,1
+metRology,xs.plot.default,5,0,0,any,1
+metRology,xs.plot.default,6,0,0,any,1
+metRology,xs.plot.default,7,0,0,double[],1
+metRology,xs.plot.default,8,0,0,character[],1
+metRology,xs.plot.default,9,0,0,character[],1
+metRology,xs.plot.default,10,0,0,character,1
+metRology,xs.plot.default,11,0,0,character,1
+metRology,xs.plot.default,12,0,0,any,1
+metRology,xs.plot.default,13,0,0,logical,1
+metRology,xs.plot.default,14,0,0,character,1
+metRology,xs.plot.default,15,0,0,character,1
+metRology,youden.plot,-1,0,0,class<`d.ellipse`>,1
+metRology,youden.plot,0,0,0,class<`data.frame`>,1
+metRology,youden.plot,0,0,1,double[],1
+metRology,youden.plot,1,0,0,...,1
+metRology,youden.plot.default,-1,0,0,class<`d.ellipse`>,1
+metRology,youden.plot.default,0,0,0,class<`data.frame`>,1
+metRology,youden.plot.default,0,0,1,double[],1
+metRology,youden.plot.default,1,0,0,null,1
+metRology,youden.plot.default,1,0,1,double[],1
+metRology,youden.plot.default,2,0,0,character[],1
+metRology,youden.plot.default,3,0,0,any,1
+metRology,youden.plot.default,4,0,0,double[],1
+metRology,youden.plot.default,5,0,0,any,1
+metRology,youden.plot.default,6,0,0,any,1
+metRology,youden.plot.default,7,0,0,integer,1
+metRology,youden.plot.default,8,0,0,double,1
+metRology,youden.plot.default,9,0,0,character,1
+metRology,youden.plot.default,10,0,0,character,1
+metRology,youden.plot.default,11,0,0,any,1
+metRology,youden.plot.default,12,0,0,any,1
+metRology,youden.plot.default,13,0,0,any,1
+metRology,youden.plot.default,14,0,0,character[],1
+metRology,youden.plot.default,15,0,0,character[],1
+metRology,yplot,-1,0,0,class<`d.ellipse`>,1
+metRology,yplot,0,0,0,class<`data.frame`>,1
+metRology,yplot,0,0,1,double[],1
+metRology,yplot,1,0,0,...,1
+mice,ampute,-1,0,0,class<`mads`>,1
+mice,ampute,0,0,0,class<`matrix`>,1
+mice,ampute,1,0,0,double,1
+mice,ampute,2,0,0,class<`data.frame`>,1
+mice,ampute,2,0,1,null,1
+mice,ampute,3,0,0,double[],1
+mice,ampute,3,0,1,null,1
+mice,ampute,4,0,0,character,1
+mice,ampute,5,0,0,null,1
+mice,ampute,6,0,0,logical,1
+mice,ampute,7,0,0,logical,1
+mice,ampute.continuous,-1,0,0,list<double[]>,1
+mice,ampute.continuous,0,0,0,double[],1
+mice,ampute.continuous,1,0,0,list<class<`matrix`>>,1
+mice,ampute.continuous,2,0,0,double,1
+mice,ampute.continuous,3,0,0,character[],1
+mice,ampute.default.freq,-1,0,0,double[],1
+mice,ampute.default.freq,0,0,0,class<`data.frame`>,1
+mice,ampute.default.odds,-1,0,0,class<`matrix`>,1
+mice,ampute.default.odds,0,0,0,class<`data.frame`>,1
+mice,ampute.default.patterns,-1,0,0,class<`matrix`>,1
+mice,ampute.default.patterns,0,0,0,integer,1
+mice,ampute.default.type,-1,0,0,character[],1
+mice,ampute.default.type,0,0,0,class<`data.frame`>,1
+mice,ampute.default.weights,-1,0,0,class<`matrix`>,1
+mice,ampute.default.weights,0,0,0,class<`data.frame`>,1
+mice,ampute.default.weights,1,0,0,character,1
+mice,ampute.discrete,-1,0,0,list<double[]>,1
+mice,ampute.discrete,0,0,0,double[],1
+mice,ampute.discrete,1,0,0,list<class<`matrix`>>,1
+mice,ampute.discrete,2,0,0,double,1
+mice,ampute.discrete,3,0,0,class<`matrix`>,1
+mice,as.mids,-1,0,0,class<`mids`>,1
+mice,as.mids,0,0,0,class<`data.frame`>,1
+mice,as.mids,1,0,0,class<`matrix`>,1
+mice,as.mids,1,0,1,null,1
+mice,as.mids,2,0,0,character,1
+mice,as.mids,3,0,0,character,1
+mice,as.mids,3,0,1,double,1
+mice,as.mira,-1,0,0,"class<`matrix`, `mira`>",1
+mice,as.mira,0,0,0,"class<`list`, `mitml.result`>",1
+mice,as.mira,0,0,1,"class<`matrix`, `mira`>",1
+mice,as.mitml.result,-1,0,0,"class<`list`, `mitml.result`>",1
+mice,as.mitml.result,0,0,0,"class<`matrix`, `mira`>",1
+mice,augment,-1,0,0,list<class<`factor`> | class<`data.frame`> | double[]>,1
+mice,augment,0,0,0,class<`factor`>,1
+mice,augment,0,0,1,"class<`factor`, `ordered`>",1
+mice,augment,1,0,0,logical[],1
+mice,augment,2,0,0,class<`matrix`>,1
+mice,augment,3,0,0,logical[],1
+mice,augment,4,0,0,double,1
+mice,barnard.rubin,-1,0,0,double,1
+mice,barnard.rubin,0,0,0,integer,1
+mice,barnard.rubin,1,0,0,double,1
+mice,barnard.rubin,2,0,0,double,1
+mice,barnard.rubin,3,0,0,double,1
+mice,bootfunc.plain,-1,0,0,double[],1
+mice,bootfunc.plain,0,0,0,integer,1
+mice,bwplot.mids,-1,0,0,class<`trellis`>,1
+mice,bwplot.mids,0,0,0,class<`mids`>,1
+mice,bwplot.mids,1,0,0,any,1
+mice,bwplot.mids,2,0,0,null,1
+mice,bwplot.mids,3,0,0,null,1
+mice,bwplot.mids,4,0,0,logical,1
+mice,bwplot.mids,5,0,0,list<any>,1
+mice,bwplot.mids,6,0,0,logical,1
+mice,bwplot.mids,7,0,0,logical,1
+mice,cbind,-1,0,0,class<`data.frame`>,1
+mice,cbind,-1,0,1,class<`matrix`>,1
+mice,cbind,-1,0,2,class<`mids`>,1
+mice,cbind,0,0,0,...,1
+mice,cbind.mids,-1,0,0,class<`mids`>,1
+mice,cbind.mids,0,0,0,class<`mids`>,1
+mice,cbind.mids,1,0,0,class<`data.frame`>,1
+mice,cbind.mids,1,0,1,class<`mids`>,1
+mice,cbind.mids,1,0,2,null,1
+mice,cbind.mids,2,0,0,...,1
+mice,cbind.mids.mids,-1,0,0,class<`mids`>,1
+mice,cbind.mids.mids,0,0,0,class<`mids`>,1
+mice,cbind.mids.mids,1,0,0,class<`mids`>,1
+mice,cbind.mids.mids,2,0,0,class<`call`>,1
+mice,cci,-1,0,0,logical[],1
+mice,cci,0,0,0,class<`data.frame`>,1
+mice,cci,0,0,1,class<`mids`>,1
+mice,cci.default,-1,0,0,logical[],1
+mice,cci.default,0,0,0,class<`data.frame`>,1
+mice,cci.mids,-1,0,0,logical[],1
+mice,cci.mids,0,0,0,class<`mids`>,1
+mice,check.blocks,-1,0,0,list<character[]>,1
+mice,check.blocks,0,0,0,list<character[]>,1
+mice,check.blocks,1,0,0,class<`data.frame`>,1
+mice,check.blocks,2,0,0,character,1
+mice,check.blots,-1,0,0,list<list<any>>,1
+mice,check.blots,0,0,0,null,1
+mice,check.blots,0,0,1,list<list<character>>,1
+mice,check.blots,0,0,2,list<list<character | character | class<`matrix`>>>,1
+mice,check.blots,1,0,0,class<`data.frame`>,1
+mice,check.blots,2,0,0,list<character[]>,1
+mice,check.cluster,-1,0,0,logical,1
+mice,check.cluster,0,0,0,any,1
+mice,check.cluster,1,0,0,class<`matrix`>,1
+mice,check.dataform,-1,0,0,class<`data.frame`>,1
+mice,check.dataform,0,0,0,class<`data.frame`>,1
+mice,check.dataform,0,0,1,class<`matrix`>,1
+mice,check.deprecated,-1,0,0,null,1
+mice,check.deprecated,0,0,0,...,1
+mice,check.df,-1,0,0,null,1
+mice,check.df,0,0,0,class<`matrix`>,1
+mice,check.df,1,0,0,any,1
+mice,check.df,2,0,0,logical[],1
+mice,check.formulas,-1,0,0,list<class<`formula`>>,1
+mice,check.formulas,0,0,0,list<class<`formula`>>,1
+mice,check.formulas,1,0,0,class<`data.frame`>,1
+mice,check.m,-1,0,0,double,1
+mice,check.m,0,0,0,double,1
+mice,check.method,-1,0,0,character[],1
+mice,check.method,0,0,0,character[],1
+mice,check.method,0,0,1,null,1
+mice,check.method,1,0,0,class<`data.frame`>,1
+mice,check.method,2,0,0,class<`matrix`>,1
+mice,check.method,3,0,0,list<character[]>,1
+mice,check.method,4,0,0,any,1
+mice,check.post,-1,0,0,character[],1
+mice,check.post,0,0,0,null,1
+mice,check.post,1,0,0,class<`data.frame`>,1
+mice,check.predictorMatrix,-1,0,0,class<`matrix`>,1
+mice,check.predictorMatrix,-1,0,1,list<class<`matrix`> | list<character[]>>,1
+mice,check.predictorMatrix,0,0,0,class<`matrix`>,1
+mice,check.predictorMatrix,1,0,0,class<`data.frame`>,1
+mice,check.predictorMatrix,2,0,0,null,1
+mice,check.predictorMatrix,2,0,1,list<character[]>,1
+mice,check.visitSequence,-1,0,0,character[],1
+mice,check.visitSequence,0,0,0,null,1
+mice,check.visitSequence,1,0,0,any,1
+mice,check.visitSequence,2,0,0,any,1
+mice,check.visitSequence,3,0,0,list<character[]>,1
+mice,check.where,-1,0,0,class<`matrix`>,1
+mice,check.where,0,0,0,class<`matrix`>,1
+mice,check.where,0,0,1,null,1
+mice,check.where,1,0,0,class<`data.frame`>,1
+mice,check.where,2,0,0,list<character[]>,1
+mice,complete.mids,-1,0,0,class<`data.frame`>,1
+mice,complete.mids,-1,0,1,"class<`list`, `mild`>",1
+mice,complete.mids,0,0,0,class<`mids`>,1
+mice,complete.mids,1,0,0,character,1
+mice,complete.mids,1,0,1,double[],1
+mice,complete.mids,2,0,0,logical,1
+mice,complete.mids,3,0,0,logical,1
+mice,complete.mids,4,0,0,...,1
+mice,construct.blocks,-1,0,0,list<character[]>,1
+mice,construct.blocks,0,0,0,list<class<`formula`>>,1
+mice,construct.blocks,1,0,0,null,1
+mice,construct.blocks,1,0,1,class<`matrix`>,1
+mice,D2,-1,0,0,"class<`list`, `mice.anova`, `mitml.result`>",1
+mice,D2,0,0,0,"class<`matrix`, `mira`>",1
+mice,D2,1,0,0,"class<`matrix`, `mira`>",1
+mice,D2,2,0,0,character,1
+mice,D2,3,0,0,...,1
+mice,densityplot.mids,-1,0,0,class<`trellis`>,1
+mice,densityplot.mids,0,0,0,class<`mids`>,1
+mice,densityplot.mids,1,0,0,class<`formula`>,1
+mice,densityplot.mids,2,0,0,null,1
+mice,densityplot.mids,3,0,0,null,1
+mice,densityplot.mids,4,0,0,logical,1
+mice,densityplot.mids,5,0,0,logical,1
+mice,densityplot.mids,6,0,0,list<list<character[] | double | character[] | logical>>,1
+mice,densityplot.mids,7,0,0,logical,1
+mice,edit.setup,-1,0,0,list<character[] | class<`matrix`>>,1
+mice,edit.setup,-1,0,1,list<class<`matrix`> | character[]>,1
+mice,edit.setup,0,0,0,any,1
+mice,edit.setup,1,0,0,list<character[] | class<`matrix`>>,1
+mice,edit.setup,1,0,1,list<class<`matrix`> | character[]>,1
+mice,edit.setup,2,0,0,logical,1
+mice,edit.setup,3,0,0,logical,1
+mice,edit.setup,4,0,0,logical,1
+mice,edit.setup,5,0,0,logical,1
+mice,edit.setup,6,0,0,...,1
+mice,estimice,-1,0,0,list<class<`matrix`> | double | character>,1
+mice,estimice,0,0,0,class<`matrix`>,1
+mice,estimice,1,0,0,double[],1
+mice,estimice,2,0,0,character,1
+mice,estimice,3,0,0,any,1
+mice,estimice,4,0,0,...,1
+mice,fico,-1,0,0,double[],1
+mice,fico,0,0,0,class<`data.frame`>,1
+mice,find.collinear,-1,0,0,character[],1
+mice,find.collinear,0,0,0,class<`data.frame`>,1
+mice,find.collinear,1,0,0,double,1
+mice,find.collinear,2,0,0,...,1
+mice,fix.coef,-1,0,0,class<`lm`>,1
+mice,fix.coef,0,0,0,class<`lm`>,1
+mice,fix.coef,1,0,0,double[],1
+mice,fix.coef,1,0,1,null,1
+mice,flux,-1,0,0,class<`data.frame`>,1
+mice,flux,0,0,0,class<`data.frame`>,1
+mice,flux,1,0,0,character[],1
+mice,fluxplot,-1,0,0,class<`data.frame`>,1
+mice,fluxplot,0,0,0,class<`data.frame`>,1
+mice,fluxplot,1,0,0,character[],1
+mice,fluxplot,2,0,0,logical,1
+mice,fluxplot,3,0,0,logical,1
+mice,fluxplot,4,0,0,double[],1
+mice,fluxplot,5,0,0,double[],1
+mice,fluxplot,6,0,0,double,1
+mice,fluxplot,7,0,0,character,1
+mice,getfit,-1,0,0,"class<`glm`, `lm`>",1
+mice,getfit,-1,0,1,"class<`list`, `mira`>",1
+mice,getfit,-1,0,2,class<`lm`>,1
+mice,getfit,0,0,0,"class<`matrix`, `mira`>",1
+mice,getfit,0,0,1,"class<`list`, `mira`>",1
+mice,getfit,1,0,0,double,1
+mice,getfit,2,0,0,logical,1
+mice,getqbar,-1,0,0,double[],1
+mice,getqbar,0,0,0,"class<`data.frame`, `mipo`>",1
+mice,glm.mids,-1,0,0,"class<`glm`, `lm`, `mira`>",1
+mice,glm.mids,0,0,0,class<`formula`>,1
+mice,glm.mids,1,0,0,class<`function`>,1
+mice,glm.mids,2,0,0,class<`mids`>,1
+mice,glm.mids,3,0,0,...,1
+mice,handle.oldstyle.formulas,-1,0,0,list<class<`formula`>>,1
+mice,handle.oldstyle.formulas,0,0,0,list<class<`formula`>>,1
+mice,handle.oldstyle.formulas,1,0,0,class<`data.frame`>,1
+mice,handles.arg,-1,0,0,logical,1
+mice,handles.arg,0,0,0,class<`function`>,1
+mice,handles.arg,1,0,0,character,1
+mice,handles.format,-1,0,0,logical,1
+mice,handles.format,0,0,0,character,1
+mice,hasdot,-1,0,0,logical,1
+mice,hasdot,0,0,0,class<`call`>,1
+mice,hasdot,0,0,1,class<`name`>,1
+mice,hasdot,0,0,2,class<`formula`>,1
+mice,ibind,-1,0,0,class<`mids`>,1
+mice,ibind,0,0,0,class<`mids`>,1
+mice,ibind,1,0,0,class<`mids`>,1
+mice,ic,-1,0,0,class<`data.frame`>,1
+mice,ic,0,0,0,class<`data.frame`>,1
+mice,ic.data.frame,-1,0,0,class<`data.frame`>,1
+mice,ic.data.frame,0,0,0,class<`data.frame`>,1
+mice,ici,-1,0,0,logical[],1
+mice,ici,0,0,0,class<`data.frame`>,1
+mice,ici.default,-1,0,0,logical[],1
+mice,ici.default,0,0,0,class<`data.frame`>,1
+mice,.imputation.level2,-1,0,0,double[],1
+mice,.imputation.level2,0,0,0,double[],1
+mice,.imputation.level2,0,0,1,class<`factor`>,1
+mice,.imputation.level2,1,0,0,logical[],1
+mice,.imputation.level2,2,0,0,class<`matrix`>,1
+mice,.imputation.level2,3,0,0,double[],1
+mice,.imputation.level2,4,0,0,logical[],1
+mice,.imputation.level2,5,0,0,character,1
+mice,.imputation.level2,6,0,0,...,1
+mice,initialize.chain,-1,0,0,class<`array`>,1
+mice,initialize.chain,0,0,0,list<character[]>,1
+mice,initialize.chain,1,0,0,double,1
+mice,initialize.chain,2,0,0,double,1
+mice,initialize.imp,-1,0,0,list<class<`data.frame`>>,1
+mice,initialize.imp,-1,0,1,list<null | class<`data.frame`>>,1
+mice,initialize.imp,0,0,0,class<`data.frame`>,1
+mice,initialize.imp,1,0,0,double,1
+mice,initialize.imp,2,0,0,class<`matrix`>,1
+mice,initialize.imp,3,0,0,list<character[]>,1
+mice,initialize.imp,4,0,0,character[],1
+mice,initialize.imp,5,0,0,character[],1
+mice,initialize.imp,6,0,0,integer[],1
+mice,initialize.imp,7,0,0,null,1
+mice,install.on.demand,-1,0,0,null,1
+mice,install.on.demand,0,0,0,character,1
+mice,install.on.demand,1,0,0,logical,1
+mice,install.on.demand,2,0,0,...,1
+mice,is.formula,-1,0,0,logical,1
+mice,is.formula,0,0,0,class<`formula`>,1
+mice,is.mids,-1,0,0,logical,1
+mice,is.mids,0,0,0,class<`data.frame`>,1
+mice,is.mids,0,0,1,class<`mids`>,1
+mice,is.mids,0,0,2,null,1
+mice,is.mids,0,0,3,list<null>,1
+mice,is.mipo,-1,0,0,logical,1
+mice,is.mipo,0,0,0,"class<`data.frame`, `mipo`>",1
+mice,is.mira,-1,0,0,logical,1
+mice,is.mira,0,0,0,"class<`list`, `mitml.result`>",1
+mice,is.mira,0,0,1,"class<`lm`, `mira`>",1
+mice,is.mira,0,0,2,"class<`matrix`, `mira`>",1
+mice,is.passive,-1,0,0,logical[],1
+mice,is.passive,0,0,0,character[],1
+mice,lhs,-1,0,0,character[],1
+mice,lhs,0,0,0,class<`formula`>,1
+mice,lm.mids,-1,0,0,"class<`lm`, `mira`>",1
+mice,lm.mids,0,0,0,class<`formula`>,1
+mice,lm.mids,1,0,0,class<`mids`>,1
+mice,lm.mids,2,0,0,...,1
+mice,ma_exists,-1,0,0,list<logical | class<`data.frame`> | environment>,1
+mice,ma_exists,-1,0,1,list<logical | environment | list<double | character>>,1
+mice,ma_exists,-1,0,2,list<logical | environment | list<integer | character>>,1
+mice,ma_exists,0,0,0,character,1
+mice,ma_exists,1,0,0,double,1
+mice,ma_exists,2,0,0,integer[],1
+mice,make.blocks,-1,0,0,list<character[]>,1
+mice,make.blocks,0,0,0,character[],1
+mice,make.blocks,0,0,1,class<`data.frame`>,1
+mice,make.blocks,0,0,2,class<`matrix`>,1
+mice,make.blocks,1,0,0,any,1
+mice,make.blocks,2,0,0,character,1
+mice,make.blots,-1,0,0,list<list<any>>,1
+mice,make.blots,0,0,0,class<`data.frame`>,1
+mice,make.blots,1,0,0,list<character[]>,1
+mice,make.formulas,-1,0,0,list<class<`formula`>>,1
+mice,make.formulas,0,0,0,class<`data.frame`>,1
+mice,make.formulas,1,0,0,list<character[]>,1
+mice,make.formulas,2,0,0,class<`matrix`>,1
+mice,make.formulas,2,0,1,null,1
+mice,make.method,-1,0,0,character[],1
+mice,make.method,0,0,0,class<`data.frame`>,1
+mice,make.method,1,0,0,class<`matrix`>,1
+mice,make.method,2,0,0,list<character[]>,1
+mice,make.method,3,0,0,character[],1
+mice,make.post,-1,0,0,character[],1
+mice,make.post,0,0,0,class<`data.frame`>,1
+mice,make.predictorMatrix,-1,0,0,class<`matrix`>,1
+mice,make.predictorMatrix,0,0,0,class<`data.frame`>,1
+mice,make.predictorMatrix,1,0,0,list<character[]>,1
+mice,make.visitSequence,-1,0,0,character[],1
+mice,make.visitSequence,0,0,0,any,1
+mice,make.visitSequence,1,0,0,list<character[]>,1
+mice,make.visitSequence,1,0,1,null,1
+mice,make.where,-1,0,0,class<`matrix`>,1
+mice,make.where,0,0,0,class<`data.frame`>,1
+mice,make.where,1,0,0,character[],1
+mice,matcher,-1,0,0,integer[],1
+mice,matcher,0,0,0,class<`matrix`>,1
+mice,matcher,1,0,0,class<`matrix`>,1
+mice,matcher,2,0,0,integer,1
+mice,mdc,-1,0,0,character[],1
+mice,mdc,0,0,0,character[],1
+mice,mdc,0,0,1,integer[],1
+mice,mdc,0,0,2,double,1
+mice,mdc,1,0,0,character,1
+mice,mdc,2,0,0,logical,1
+mice,mdc,3,0,0,character,1
+mice,mdc,4,0,0,character,1
+mice,mdc,5,0,0,character,1
+mice,mdc,6,0,0,character,1
+mice,mdc,7,0,0,character,1
+mice,md.pairs,-1,0,0,list<class<`matrix`>>,1
+mice,md.pairs,0,0,0,class<`data.frame`>,1
+mice,md.pattern,-1,0,0,class<`matrix`>,1
+mice,md.pattern,0,0,0,class<`data.frame`>,1
+mice,md.pattern,1,0,0,logical,1
+mice,md.pattern,2,0,0,logical,1
+mice,mice,-1,0,0,class<`mids`>,1
+mice,mice,0,0,0,class<`data.frame`>,1
+mice,mice,0,0,1,class<`matrix`>,1
+mice,mice,1,0,0,double,1
+mice,mice,2,0,0,character[],1
+mice,mice,2,0,1,null,1
+mice,mice,3,0,0,any,1
+mice,mice,4,0,0,null,1
+mice,mice,4,0,1,class<`matrix`>,1
+mice,mice,5,0,0,any,1
+mice,mice,6,0,0,null,1
+mice,mice,7,0,0,any,1
+mice,mice.impute.2lonly.norm,-1,0,0,double[],1
+mice,mice.impute.2lonly.norm,0,0,0,double[],1
+mice,mice.impute.2lonly.norm,1,0,0,logical[],1
+mice,mice.impute.2lonly.norm,2,0,0,class<`matrix`>,1
+mice,mice.impute.2lonly.norm,3,0,0,double[],1
+mice,mice.impute.2lonly.norm,4,0,0,logical[],1
+mice,mice.impute.2lonly.norm,5,0,0,...,1
+mice,mice.impute.2lonly.pmm,-1,0,0,double[],1
+mice,mice.impute.2lonly.pmm,0,0,0,double[],1
+mice,mice.impute.2lonly.pmm,0,0,1,class<`factor`>,1
+mice,mice.impute.2lonly.pmm,1,0,0,logical[],1
+mice,mice.impute.2lonly.pmm,2,0,0,class<`matrix`>,1
+mice,mice.impute.2lonly.pmm,3,0,0,double[],1
+mice,mice.impute.2lonly.pmm,4,0,0,logical[],1
+mice,mice.impute.2lonly.pmm,5,0,0,...,1
+mice,mice.impute.2l.pan,-1,0,0,double[],1
+mice,mice.impute.2l.pan,0,0,0,double[],1
+mice,mice.impute.2l.pan,1,0,0,logical[],1
+mice,mice.impute.2l.pan,2,0,0,class<`matrix`>,1
+mice,mice.impute.2l.pan,3,0,0,double[],1
+mice,mice.impute.2l.pan,4,0,0,logical,1
+mice,mice.impute.2l.pan,5,0,0,double,1
+mice,mice.impute.2l.pan,6,0,0,logical,1
+mice,mice.impute.2l.pan,7,0,0,...,1
+mice,mice.impute.jomoImpute,-1,0,0,list<^double[]>,1
+mice,mice.impute.jomoImpute,0,0,0,class<`data.frame`>,1
+mice,mice.impute.jomoImpute,1,0,0,any,1
+mice,mice.impute.jomoImpute,2,0,0,double[],1
+mice,mice.impute.jomoImpute,3,0,0,double,1
+mice,mice.impute.jomoImpute,4,0,0,logical,1
+mice,mice.impute.jomoImpute,5,0,0,character,1
+mice,mice.impute.jomoImpute,6,0,0,...,1
+mice,mice.impute.logreg,-1,0,0,class<`factor`>,1
+mice,mice.impute.logreg,0,0,0,class<`factor`>,1
+mice,mice.impute.logreg,1,0,0,logical[],1
+mice,mice.impute.logreg,2,0,0,class<`matrix`>,1
+mice,mice.impute.logreg,3,0,0,logical[],1
+mice,mice.impute.logreg,4,0,0,...,1
+mice,mice.impute.midastouch,-1,0,0,double[],1
+mice,mice.impute.midastouch,0,0,0,double[],1
+mice,mice.impute.midastouch,1,0,0,logical[],1
+mice,mice.impute.midastouch,2,0,0,class<`matrix`>,1
+mice,mice.impute.midastouch,3,0,0,logical[],1
+mice,mice.impute.midastouch,4,0,0,double,1
+mice,mice.impute.midastouch,5,0,0,null,1
+mice,mice.impute.midastouch,6,0,0,logical,1
+mice,mice.impute.midastouch,7,0,0,null,1
+mice,mice.impute.mnar.logreg,-1,0,0,class<`factor`>,1
+mice,mice.impute.mnar.logreg,0,0,0,class<`factor`>,1
+mice,mice.impute.mnar.logreg,1,0,0,logical[],1
+mice,mice.impute.mnar.logreg,2,0,0,class<`matrix`>,1
+mice,mice.impute.mnar.logreg,3,0,0,logical[],1
+mice,mice.impute.mnar.logreg,4,0,0,character,1
+mice,mice.impute.mnar.logreg,5,0,0,null,1
+mice,mice.impute.mnar.logreg,6,0,0,...,1
+mice,mice.impute.mnar.norm,-1,0,0,class<`matrix`>,1
+mice,mice.impute.mnar.norm,0,0,0,double[],1
+mice,mice.impute.mnar.norm,1,0,0,logical[],1
+mice,mice.impute.mnar.norm,2,0,0,class<`matrix`>,1
+mice,mice.impute.mnar.norm,3,0,0,logical[],1
+mice,mice.impute.mnar.norm,4,0,0,character,1
+mice,mice.impute.mnar.norm,5,0,0,class<`matrix`>,1
+mice,mice.impute.mnar.norm,5,0,1,null,1
+mice,mice.impute.mnar.norm,6,0,0,...,1
+mice,mice.impute.norm,-1,0,0,class<`matrix`>,1
+mice,mice.impute.norm,0,0,0,double[],1
+mice,mice.impute.norm,1,0,0,logical[],1
+mice,mice.impute.norm,2,0,0,class<`matrix`>,1
+mice,mice.impute.norm,3,0,0,logical[],1
+mice,mice.impute.norm,4,0,0,...,1
+mice,mice.impute.pmm,-1,0,0,double[],1
+mice,mice.impute.pmm,0,0,0,class<`matrix`>,1
+mice,mice.impute.pmm,0,0,1,double[],1
+mice,mice.impute.pmm,0,0,2,^integer[],1
+mice,mice.impute.pmm,1,0,0,logical[],1
+mice,mice.impute.pmm,2,0,0,double[],1
+mice,mice.impute.pmm,2,0,1,class<`matrix`>,1
+mice,mice.impute.pmm,2,0,2,class<`data.frame`>,1
+mice,mice.impute.pmm,3,0,0,null,1
+mice,mice.impute.pmm,3,0,1,logical[],1
+mice,mice.impute.pmm,4,0,0,integer,1
+mice,mice.impute.pmm,5,0,0,integer,1
+mice,mice.impute.pmm,6,0,0,double,1
+mice,mice.impute.pmm,7,0,0,...,1
+mice,mice.impute.polr,-1,0,0,character[],1
+mice,mice.impute.polr,0,0,0,"class<`factor`, `ordered`>",1
+mice,mice.impute.polr,1,0,0,logical[],1
+mice,mice.impute.polr,2,0,0,class<`matrix`>,1
+mice,mice.impute.polr,3,0,0,logical[],1
+mice,mice.impute.polr,4,0,0,double,1
+mice,mice.impute.polr,5,0,0,logical,1
+mice,mice.impute.polr,6,0,0,double,1
+mice,mice.impute.polr,7,0,0,logical,1
+mice,mice.impute.polyreg,-1,0,0,character[],1
+mice,mice.impute.polyreg,0,0,0,class<`factor`>,1
+mice,mice.impute.polyreg,1,0,0,logical[],1
+mice,mice.impute.polyreg,2,0,0,class<`matrix`>,1
+mice,mice.impute.polyreg,3,0,0,logical[],1
+mice,mice.impute.polyreg,4,0,0,double,1
+mice,mice.impute.polyreg,5,0,0,logical,1
+mice,mice.impute.polyreg,6,0,0,double,1
+mice,mice.impute.polyreg,7,0,0,...,1
+mice,mice.impute.quadratic,-1,0,0,double[],1
+mice,mice.impute.quadratic,0,0,0,double[],1
+mice,mice.impute.quadratic,1,0,0,logical[],1
+mice,mice.impute.quadratic,2,0,0,class<`matrix`>,1
+mice,mice.impute.quadratic,3,0,0,logical[],1
+mice,mice.impute.quadratic,4,0,0,...,1
+mice,mice.impute.rf,-1,0,0,class<`factor`>,1
+mice,mice.impute.rf,-1,0,1,double[],1
+mice,mice.impute.rf,0,0,0,class<`factor`>,1
+mice,mice.impute.rf,0,0,1,double[],1
+mice,mice.impute.rf,1,0,0,logical[],1
+mice,mice.impute.rf,2,0,0,class<`matrix`>,1
+mice,mice.impute.rf,3,0,0,logical[],1
+mice,mice.impute.rf,4,0,0,double,1
+mice,mice.impute.rf,5,0,0,...,1
+mice,mice.impute.sample,-1,0,0,class<`factor`>,1
+mice,mice.impute.sample,-1,0,1,"class<`factor`, `ordered`>",1
+mice,mice.impute.sample,-1,0,2,double[],1
+mice,mice.impute.sample,0,0,0,class<`factor`>,1
+mice,mice.impute.sample,0,0,1,"class<`factor`, `ordered`>",1
+mice,mice.impute.sample,0,0,2,^double[],1
+mice,mice.impute.sample,1,0,0,logical[],1
+mice,mice.impute.sample,2,0,0,null,1
+mice,mice.impute.sample,3,0,0,logical[],1
+mice,mice.impute.sample,4,0,0,...,1
+mice,mice.mids,-1,0,0,class<`mids`>,1
+mice,mice.mids,0,0,0,class<`mids`>,1
+mice,mice.mids,1,0,0,double,1
+mice,mice.mids,2,0,0,logical,1
+mice,mice.mids,3,0,0,...,1
+mice,mice.theme,-1,0,0,list<list<character[] | double | character[] | logical>>,1
+mice,mice.theme,0,0,0,logical,1
+mice,mice.theme,1,0,0,double,1
+mice,minmax,-1,0,0,class<`matrix`>,1
+mice,minmax,-1,0,1,double[],1
+mice,minmax,0,0,0,class<`matrix`>,1
+mice,minmax,0,0,1,double[],1
+mice,minmax,1,0,0,logical,1
+mice,minmax,2,0,0,logical,1
+mice,name.blocks,-1,0,0,list<character[]>,1
+mice,name.blocks,-1,0,1,list<class<`formula`>>,1
+mice,name.blocks,0,0,0,character[],1
+mice,name.blocks,0,0,1,list<character[]>,1
+mice,name.blocks,0,0,2,list<class<`formula`>>,1
+mice,name.blocks,1,0,0,character,1
+mice,name.formulas,-1,0,0,list<class<`formula`>>,1
+mice,name.formulas,0,0,0,list<class<`formula`>>,1
+mice,name.formulas,1,0,0,character,1
+mice,ncc,-1,0,0,integer,1
+mice,ncc,0,0,0,class<`data.frame`>,1
+mice,nelsonaalen,-1,0,0,double[],1
+mice,nelsonaalen,0,0,0,class<`data.frame`>,1
+mice,nelsonaalen,1,0,0,any,1
+mice,nelsonaalen,2,0,0,any,1
+mice,nic,-1,0,0,integer,1
+mice,nic,0,0,0,class<`data.frame`>,1
+mice,nimp,-1,0,0,integer[],1
+mice,nimp,0,0,0,class<`matrix`>,1
+mice,nimp,1,0,0,list<character[]>,1
+mice,.norm.draw,-1,0,0,list<class<`matrix`> | double | character>,1
+mice,.norm.draw,0,0,0,class<`matrix`>,1
+mice,.norm.draw,0,0,1,double[],1
+mice,.norm.draw,0,0,2,^integer[],1
+mice,.norm.draw,1,0,0,logical[],1
+mice,.norm.draw,2,0,0,class<`matrix`>,1
+mice,.norm.draw,3,0,0,logical,1
+mice,.norm.draw,4,0,0,...,1
+mice,obtain.design,-1,0,0,class<`matrix`>,1
+mice,obtain.design,0,0,0,class<`data.frame`>,1
+mice,obtain.design,1,0,0,class<`formula`>,1
+mice,parse.ums,-1,0,0,list<double[] | class<`matrix`>>,1
+mice,parse.ums,-1,0,1,list<double | class<`matrix`>>,1
+mice,parse.ums,0,0,0,class<`matrix`>,1
+mice,parse.ums,1,0,0,character,1
+mice,parse.ums,2,0,0,class<`matrix`>,1
+mice,parse.ums,2,0,1,null,1
+mice,parse.ums,3,0,0,...,1
+mice,plot.mids,-1,0,0,class<`trellis`>,1
+mice,plot.mids,0,0,0,class<`mids`>,1
+mice,plot.mids,1,0,0,null,1
+mice,plot.mids,2,0,0,list<list<character[] | double | character[] | logical>>,1
+mice,plot.mids,3,0,0,double[],1
+mice,plot.mids,4,0,0,character,1
+mice,plot.mids,5,0,0,integer[],1
+mice,plot.mids,6,0,0,double,1
+mice,plot.mids,7,0,0,...,1
+mice,pool,-1,0,0,"class<`data.frame`, `mipo`>",1
+mice,pool,0,0,0,"class<`list`, `mitml.result`>",1
+mice,pool,0,0,1,"class<`matrix`, `mira`>",1
+mice,pool,1,0,0,null,1
+mice,pool.fitlist,-1,0,0,class<`data.frame`>,1
+mice,pool.fitlist,0,0,0,"class<`list`, `mira`>",1
+mice,pool.fitlist,1,0,0,null,1
+mice,pool.r.squared,-1,0,0,class<`matrix`>,1
+mice,pool.r.squared,0,0,0,"class<`lm`, `mira`>",1
+mice,pool.r.squared,1,0,0,logical,1
+mice,pool.scalar,-1,0,0,list<double[]>,1
+mice,pool.scalar,0,0,0,double[],1
+mice,pool.scalar,1,0,0,double[],1
+mice,pool.scalar,2,0,0,double,1
+mice,pool.scalar,3,0,0,double,1
+mice,process_mipo,-1,0,0,class<`data.frame`>,1
+mice,process_mipo,0,0,0,class<`data.frame`>,1
+mice,process_mipo,1,0,0,any,1
+mice,process_mipo,2,0,0,logical,1
+mice,process_mipo,3,0,0,any,1
+mice,process_mipo,4,0,0,logical,1
+mice,quickpred,-1,0,0,class<`matrix`>,1
+mice,quickpred,0,0,0,class<`data.frame`>,1
+mice,quickpred,1,0,0,double[],1
+mice,quickpred,2,0,0,double,1
+mice,quickpred,3,0,0,character[],1
+mice,quickpred,4,0,0,character,1
+mice,quickpred,5,0,0,character,1
+mice,rbind,-1,0,0,class<`data.frame`>,1
+mice,rbind,-1,0,1,class<`matrix`>,1
+mice,rbind,-1,0,2,class<`mids`>,1
+mice,rbind,0,0,0,...,1
+mice,rbind.mids,-1,0,0,class<`mids`>,1
+mice,rbind.mids,0,0,0,class<`mids`>,1
+mice,rbind.mids,1,0,0,class<`data.frame`>,1
+mice,rbind.mids,1,0,1,class<`mids`>,1
+mice,rbind.mids,1,0,2,list<null>,1
+mice,rbind.mids,2,0,0,...,1
+mice,rbind.mids.mids,-1,0,0,class<`mids`>,1
+mice,rbind.mids.mids,0,0,0,class<`mids`>,1
+mice,rbind.mids.mids,1,0,0,class<`mids`>,1
+mice,rbind.mids.mids,2,0,0,any,1
+mice,remove.lindep,-1,0,0,logical[],1
+mice,remove.lindep,0,0,0,class<`matrix`>,1
+mice,remove.lindep,1,0,0,class<`factor`>,1
+mice,remove.lindep,1,0,1,double[],1
+mice,remove.lindep,1,0,2,"class<`factor`, `ordered`>",1
+mice,remove.lindep,2,0,0,logical[],1
+mice,remove.lindep,3,0,0,double,1
+mice,remove.lindep,4,0,0,double,1
+mice,remove.lindep,5,0,0,logical,1
+mice,remove.lindep,6,0,0,double,1
+mice,remove.lindep,7,0,0,...,1
+mice,sampler,-1,0,0,list<double | class<`array`> | list<class<`data.frame`>>>,1
+mice,sampler,-1,0,1,list<double | class<`array`> | list<null | class<`data.frame`>>>,1
+mice,sampler,0,0,0,class<`data.frame`>,1
+mice,sampler,1,0,0,double,1
+mice,sampler,2,0,0,any,1
+mice,sampler,3,0,0,list<class<`data.frame`>>,1
+mice,sampler,3,0,1,list<null | class<`data.frame`>>,1
+mice,sampler,4,0,0,list<character[]>,1
+mice,sampler,5,0,0,any,1
+mice,sampler,6,0,0,any,1
+mice,sampler,7,0,0,any,1
+mice,sampler.univ,-1,0,0,class<`factor`>,1
+mice,sampler.univ,-1,0,1,"class<`factor`, `ordered`>",1
+mice,sampler.univ,-1,0,2,double[],1
+mice,sampler.univ,0,0,0,class<`data.frame`>,1
+mice,sampler.univ,1,0,0,class<`matrix`>,1
+mice,sampler.univ,2,0,0,class<`matrix`>,1
+mice,sampler.univ,3,0,0,any,1
+mice,sampler.univ,4,0,0,any,1
+mice,sampler.univ,5,0,0,character,1
+mice,sampler.univ,6,0,0,character,1
+mice,sampler.univ,7,0,0,integer,1
+mice,single2imputes,-1,0,0,list<^double[]>,1
+mice,single2imputes,0,0,0,class<`data.frame`>,1
+mice,single2imputes,1,0,0,class<`matrix`>,1
+mice,single.complete,-1,0,0,class<`data.frame`>,1
+mice,single.complete,0,0,0,class<`data.frame`>,1
+mice,single.complete,1,0,0,any,1
+mice,single.complete,2,0,0,any,1
+mice,single.complete,3,0,0,integer,1
+mice,stripplot.mids,-1,0,0,class<`trellis`>,1
+mice,stripplot.mids,0,0,0,class<`mids`>,1
+mice,stripplot.mids,1,0,0,any,1
+mice,stripplot.mids,2,0,0,any,1
+mice,stripplot.mids,3,0,0,null,1
+mice,stripplot.mids,4,0,0,logical,1
+mice,stripplot.mids,5,0,0,list<list<character[] | double | character[] | logical>>,1
+mice,stripplot.mids,6,0,0,logical,1
+mice,stripplot.mids,7,0,0,logical,1
+mice,summary.mipo,-1,0,0,"class<`data.frame`, `mipo.summary`>",1
+mice,summary.mipo,0,0,0,"class<`data.frame`, `mipo`>",1
+mice,summary.mipo,1,0,0,character[],1
+mice,summary.mipo,2,0,0,logical,1
+mice,summary.mipo,3,0,0,double,1
+mice,summary.mipo,4,0,0,logical,1
+mice,summary.mipo,5,0,0,...,1
+mice,summary.mira,-1,0,0,"class<`data.frame`, `tbl`, `tbl_df`>",1
+mice,summary.mira,0,0,0,"class<`list`, `mira`>",1
+mice,summary.mira,1,0,0,character,1
+mice,summary.mira,2,0,0,...,1
+mice,supports.transparent,-1,0,0,logical,1
+mice,sym,-1,0,0,class<`matrix`>,1
+mice,sym,0,0,0,class<`matrix`>,1
+mice,tidy.coef,-1,0,0,double[],1
+mice,tidy.coef,0,0,0,class<`lm`>,1
+mice,updateLog,-1,0,0,null,1
+mice,updateLog,0,0,0,character,1
+mice,updateLog,1,0,0,character,1
+mice,updateLog,1,0,1,null,1
+mice,updateLog,2,0,0,double,1
+mice,version,-1,0,0,character,1
+mice,version,0,0,0,character,1
+mice,with.mids,-1,0,0,"class<`matrix`, `mira`>",1
+mice,with.mids,0,0,0,class<`mids`>,1
+mice,with.mids,1,0,0,any,1
+mice,with.mids,2,0,0,...,1
+mice,xyplot.mids,-1,0,0,class<`trellis`>,1
+mice,xyplot.mids,0,0,0,class<`mids`>,1
+mice,xyplot.mids,1,0,0,class<`formula`>,1
+mice,xyplot.mids,2,0,0,any,1
+mice,xyplot.mids,3,0,0,null,1
+mice,xyplot.mids,4,0,0,logical,1
+mice,xyplot.mids,5,0,0,list<list<character[] | double | character[] | logical>>,1
+mice,xyplot.mids,6,0,0,logical,1
+mice,xyplot.mids,7,0,0,logical,1
+miniUI,buildTabset,-1,0,0,list<class<`shiny.tag`>>,1
+miniUI,buildTabset,0,0,0,list<class<`shiny.tag`>>,1
+miniUI,buildTabset,1,0,0,character,1
+miniUI,buildTabset,2,0,0,null,1
+miniUI,buildTabset,3,0,0,null,1
+miniUI,buildTabset,4,0,0,null,1
+miniUI,gadgetDependencies,-1,0,0,list<class<`html_dependency`>>,1
+miniUI,miniButtonBlock,-1,0,0,class<`shiny.tag`>,1
+miniUI,miniButtonBlock,0,0,0,...,1
+miniUI,miniButtonBlock,1,0,0,character,1
+miniUI,miniContentPanel,-1,0,0,class<`shiny.tag`>,1
+miniUI,miniContentPanel,0,0,0,...,1
+miniUI,miniContentPanel,1,0,0,double,1
+miniUI,miniContentPanel,2,0,0,logical,1
+miniUI,miniTabPanel,-1,0,0,class<`shiny.tag`>,1
+miniUI,miniTabPanel,0,0,0,character,1
+miniUI,miniTabPanel,1,0,0,...,1
+miniUI,miniTabPanel,2,0,0,any,1
+miniUI,miniTabPanel,3,0,0,class<`shiny.tag`>,1
+miniUI,miniTabstripPanel,-1,0,0,"class<`list`, `shiny.tag.list`>",1
+miniUI,miniTabstripPanel,0,0,0,...,1
+miniUI,miniTabstripPanel,1,0,0,null,1
+miniUI,miniTabstripPanel,2,0,0,null,1
+miniUI,miniTabstripPanel,3,0,0,null,1
+miniUI,miniTitleBar,-1,0,0,class<`shiny.tag`>,1
+miniUI,miniTitleBar,0,0,0,character,1
+miniUI,miniTitleBar,1,0,0,class<`shiny.tag`>,1
+miniUI,miniTitleBar,2,0,0,class<`shiny.tag`>,1
+miniUI,miniTitleBarButton,-1,0,0,class<`shiny.tag`>,1
+miniUI,miniTitleBarButton,0,0,0,character,1
+miniUI,miniTitleBarButton,1,0,0,character,1
+miniUI,miniTitleBarButton,2,0,0,logical,1
+miniUI,paddingToPos,-1,0,0,character,1
+miniUI,paddingToPos,0,0,0,double,1
+minpack.lm,coef.nls.lm,-1,0,0,double[],1
+minpack.lm,coef.nls.lm,0,0,0,class<`nls.lm`>,1
+minpack.lm,coef.nls.lm,1,0,0,...,1
+minpack.lm,deviance.nls.lm,-1,0,0,double,1
+minpack.lm,deviance.nls.lm,0,0,0,class<`nls.lm`>,1
+minpack.lm,deviance.nls.lm,1,0,0,...,1
+minpack.lm,nls.lm,-1,0,0,class<`nls.lm`>,1
+minpack.lm,nls.lm,0,0,0,double[],1
+minpack.lm,nls.lm,0,0,1,list<double>,1
+minpack.lm,nls.lm,1,0,0,null,1
+minpack.lm,nls.lm,2,0,0,null,1
+minpack.lm,nls.lm,3,0,0,class<`function`>,1
+minpack.lm,nls.lm,4,0,0,null,1
+minpack.lm,nls.lm,4,0,1,class<`function`>,1
+minpack.lm,nls.lm,5,0,0,list<double | integer[] | list<any>>,1
+minpack.lm,nls.lm,5,0,1,list<double>,1
+minpack.lm,nls.lm,6,0,0,...,1
+minpack.lm,nlsLM,-1,0,0,any,1
+minpack.lm,nlsLM,0,0,0,class<`formula`>,1
+minpack.lm,nlsLM,1,0,0,class<`data.frame`>,1
+minpack.lm,nlsLM,1,0,1,"class<`data.frame`, `groupedData`, `nfGroupedData`, `nfnGroupedData`>",1
+minpack.lm,nlsLM,1,0,2,environment,1
+minpack.lm,nlsLM,2,0,0,any,1
+minpack.lm,nlsLM,3,0,0,null,1
+minpack.lm,nlsLM,4,0,0,character,1
+minpack.lm,nlsLM,5,0,0,any,1
+minpack.lm,nlsLM,6,0,0,null,1
+minpack.lm,nlsLM,7,0,0,null,1
+minpack.lm,nlsLM,8,0,0,logical,1
+minpack.lm,nlsLM,9,0,0,any,1
+minpack.lm,nlsLM,10,0,0,any,1
+minpack.lm,nlsLM,11,0,0,any,1
+minpack.lm,nlsLM,12,0,0,logical,1
+minpack.lm,nlsLM,13,0,0,...,1
+minpack.lm,nls.lm.control,-1,0,0,list<double | integer[] | list<any>>,1
+minpack.lm,nls.lm.control,0,0,0,double,1
+minpack.lm,nls.lm.control,1,0,0,double,1
+minpack.lm,nls.lm.control,2,0,0,double,1
+minpack.lm,nls.lm.control,3,0,0,list<any>,1
+minpack.lm,nls.lm.control,4,0,0,double,1
+minpack.lm,nls.lm.control,5,0,0,double,1
+minpack.lm,nls.lm.control,6,0,0,integer[],1
+minpack.lm,nls.lm.control,7,0,0,double,1
+minpack.lm,nls.lm.control,8,0,0,double,1
+minpack.lm,nlsModel,-1,0,0,class<`nlsModel`>,1
+minpack.lm,nlsModel,0,0,0,class<`formula`>,1
+minpack.lm,nlsModel,1,0,0,list<double[]>,1
+minpack.lm,nlsModel,2,0,0,double[],1
+minpack.lm,nlsModel,2,0,1,list<double>,1
+minpack.lm,nlsModel,3,0,0,double[],1
+minpack.lm,nlsModel,4,0,0,null,1
+minpack.lm,summary.nls.lm,-1,0,0,class<`summary.nls.lm`>,1
+minpack.lm,summary.nls.lm,0,0,0,class<`nls.lm`>,1
+minpack.lm,summary.nls.lm,1,0,0,...,1
+minpack.lm,wfct,-1,0,0,any,1
+minpack.lm,wfct,0,0,0,any,1
+minqa,bobyqa,-1,0,0,"class<`bobyqa`, `minqa`>",1
+minqa,bobyqa,0,0,0,double[],1
+minqa,bobyqa,1,0,0,class<`function`>,1
+minqa,bobyqa,2,0,0,double[],1
+minqa,bobyqa,3,0,0,double[],1
+minqa,bobyqa,4,0,0,list<any>,1
+minqa,bobyqa,5,0,0,...,1
+minqa,commonArgs,-1,0,0,environment,1
+minqa,commonArgs,0,0,0,double[],1
+minqa,commonArgs,1,0,0,class<`function`>,1
+minqa,commonArgs,2,0,0,list<any>,1
+minqa,commonArgs,3,0,0,environment,1
+minqa,newuoa,-1,0,0,"class<`minqa`, `newuoa`>",1
+minqa,newuoa,0,0,0,double[],1
+minqa,newuoa,1,0,0,class<`function`>,1
+minqa,newuoa,2,0,0,list<any>,1
+minqa,newuoa,3,0,0,...,1
+minqa,uobyqa,-1,0,0,"class<`minqa`, `uobyqa`>",1
+minqa,uobyqa,0,0,0,double[],1
+minqa,uobyqa,1,0,0,class<`function`>,1
+minqa,uobyqa,2,0,0,list<any>,1
+minqa,uobyqa,3,0,0,...,1
+miscTools,coefTable,-1,0,0,class<`matrix`>,1
+miscTools,coefTable,0,0,0,double[],1
+miscTools,coefTable,1,0,0,double[],1
+miscTools,coefTable,2,0,0,double,1
+miscTools,colMedians,-1,0,0,class<`array`>,1
+miscTools,colMedians,-1,0,1,class<`matrix`>,1
+miscTools,colMedians,0,0,0,class<`matrix`>,1
+miscTools,colMedians,0,0,1,class<`array`>,1
+miscTools,colMedians,0,0,2,class<`data.frame`>,1
+miscTools,colMedians,1,0,0,logical,1
+miscTools,compPlot,-1,0,0,double[],1
+miscTools,compPlot,0,0,0,double[],1
+miscTools,compPlot,1,0,0,double[],1
+miscTools,compPlot,2,0,0,double[],1
+miscTools,compPlot,2,0,1,null,1
+miscTools,compPlot,3,0,0,...,1
+miscTools,ddnorm,-1,0,0,double[],1
+miscTools,ddnorm,0,0,0,double[],1
+miscTools,ddnorm,1,0,0,double,1
+miscTools,ddnorm,2,0,0,double,1
+miscTools,insertCol,-1,0,0,class<`matrix`>,1
+miscTools,insertCol,0,0,0,class<`matrix`>,1
+miscTools,insertCol,1,0,0,double,1
+miscTools,insertCol,2,0,0,double,1
+miscTools,insertCol,2,0,1,integer[],1
+miscTools,insertCol,3,0,0,character,1
+miscTools,insertRow,-1,0,0,class<`matrix`>,1
+miscTools,insertRow,0,0,0,class<`matrix`>,1
+miscTools,insertRow,1,0,0,double,1
+miscTools,insertRow,2,0,0,double,1
+miscTools,insertRow,2,0,1,integer[],1
+miscTools,insertRow,3,0,0,character,1
+miscTools,isSemidefinite,-1,0,0,any,1
+miscTools,isSemidefinite,0,0,0,class<`matrix`>,1
+miscTools,isSemidefinite,0,0,1,list<class<`matrix`>>,1
+miscTools,isSemidefinite,0,0,2,list<class<`matrix`> | double[]>,1
+miscTools,isSemidefinite,1,0,0,...,1
+miscTools,isSemidefinite.list,-1,0,0,any,1
+miscTools,isSemidefinite.list,0,0,0,list<class<`matrix`>>,1
+miscTools,isSemidefinite.list,0,0,1,list<class<`matrix`> | double[]>,1
+miscTools,isSemidefinite.list,1,0,0,...,1
+miscTools,isSemidefinite.matrix,-1,0,0,any,1
+miscTools,isSemidefinite.matrix,0,0,0,class<`matrix`>,1
+miscTools,isSemidefinite.matrix,1,0,0,logical,1
+miscTools,isSemidefinite.matrix,2,0,0,double,1
+miscTools,isSemidefinite.matrix,3,0,0,any,1
+miscTools,isSemidefinite.matrix,4,0,0,...,1
+miscTools,margEff,-1,0,0,any,1
+miscTools,margEff,0,0,0,double,1
+miscTools,margEff,1,0,0,...,1
+miscTools,margEff.default,-1,0,0,any,1
+miscTools,margEff.default,0,0,0,double,1
+miscTools,margEff.default,1,0,0,...,1
+miscTools,nObs,-1,0,0,integer,1
+miscTools,nObs,0,0,0,class<`lm`>,1
+miscTools,nObs,1,0,0,...,1
+miscTools,nObs.lm,-1,0,0,integer,1
+miscTools,nObs.lm,0,0,0,class<`lm`>,1
+miscTools,nObs.lm,1,0,0,...,1
+miscTools,nParam,-1,0,0,integer,1
+miscTools,nParam,0,0,0,class<`lm`>,1
+miscTools,nParam,1,0,0,logical,1
+miscTools,nParam,2,0,0,...,1
+miscTools,nParam.lm,-1,0,0,integer,1
+miscTools,nParam.lm,0,0,0,class<`lm`>,1
+miscTools,nParam.lm,1,0,0,...,1
+miscTools,quasiconcavity,-1,0,0,logical[],1
+miscTools,quasiconcavity,0,0,0,list<class<`matrix`>>,1
+miscTools,quasiconcavity,0,0,1,class<`matrix`>,1
+miscTools,quasiconcavity,1,0,0,any,1
+miscTools,quasiconvexity,-1,0,0,logical[],1
+miscTools,quasiconvexity,0,0,0,list<class<`matrix`>>,1
+miscTools,quasiconvexity,0,0,1,class<`matrix`>,1
+miscTools,quasiconvexity,1,0,0,any,1
+miscTools,rowMedians,-1,0,0,class<`array`>,1
+miscTools,rowMedians,0,0,0,class<`matrix`>,1
+miscTools,rowMedians,0,0,1,class<`data.frame`>,1
+miscTools,rowMedians,1,0,0,logical,1
+miscTools,rSquared,-1,0,0,class<`matrix`>,1
+miscTools,rSquared,0,0,0,double[],1
+miscTools,rSquared,1,0,0,double[],1
+miscTools,semidefiniteness,-1,0,0,any,1
+miscTools,semidefiniteness,0,0,0,class<`matrix`>,1
+miscTools,semidefiniteness,0,0,1,list<class<`matrix`>>,1
+miscTools,semidefiniteness,0,0,2,list<class<`matrix`> | double[]>,1
+miscTools,semidefiniteness,1,0,0,...,1
+miscTools,stdEr,-1,0,0,double[],1
+miscTools,stdEr,0,0,0,class<`nls`>,1
+miscTools,stdEr,0,0,1,class<`lm`>,1
+miscTools,stdEr,1,0,0,...,1
+miscTools,stdEr.default,-1,0,0,double[],1
+miscTools,stdEr.default,0,0,0,class<`nls`>,1
+miscTools,stdEr.default,1,0,0,...,1
+miscTools,stdEr.lm,-1,0,0,double[],1
+miscTools,stdEr.lm,0,0,0,class<`lm`>,1
+miscTools,stdEr.lm,1,0,0,...,1
+miscTools,sumKeepAttr,-1,0,0,integer,1
+miscTools,sumKeepAttr,0,0,0,integer[],1
+miscTools,sumKeepAttr,1,0,0,logical,1
+miscTools,sumKeepAttr,2,0,0,logical,1
+miscTools,summarizeDF,-1,0,0,null,1
+miscTools,summarizeDF,0,0,0,class<`data.frame`>,1
+miscTools,summarizeDF,1,0,0,logical,1
+miscTools,summarizeDF,2,0,0,double,1
+miscTools,summarizeDF,3,0,0,"class<`connection`, `file`>",1
+miscTools,summarizeDF,3,0,1,null,1
+miscTools,summarizeDF,4,0,0,...,1
+miscTools,symMatrix,-1,0,0,class<`matrix`>,1
+miscTools,symMatrix,0,0,0,double[],1
+miscTools,symMatrix,1,0,0,null,1
+miscTools,symMatrix,1,0,1,double,1
+miscTools,symMatrix,2,0,0,logical,1
+miscTools,symMatrix,3,0,0,logical,1
+miscTools,triang,-1,0,0,class<`matrix`>,1
+miscTools,triang,0,0,0,integer[],1
+miscTools,triang,1,0,0,double,1
+miscTools,vecli,-1,0,0,class<`array`>,1
+miscTools,vecli,0,0,0,class<`matrix`>,1
+miscTools,vecli2m,-1,0,0,class<`matrix`>,1
+miscTools,vecli2m,0,0,0,double[],1
+miscTools,veclipos,-1,0,0,double,1
+miscTools,veclipos,0,0,0,double,1
+miscTools,veclipos,1,0,0,double,1
+miscTools,veclipos,2,0,0,double,1
+mlbench,as.data.frame.mlbench,-1,0,0,class<`data.frame`>,1
+mlbench,as.data.frame.mlbench,0,0,0,"class<`mlbench`, `mlbench.hypercube`>",1
+mlbench,as.data.frame.mlbench,0,0,1,"class<`mlbench`, `mlbench.simplex`>",1
+mlbench,as.data.frame.mlbench,0,0,2,"class<`mlbench`, `mlbench.xor`>",1
+mlbench,as.data.frame.mlbench,1,0,0,null,1
+mlbench,as.data.frame.mlbench,2,0,0,logical,1
+mlbench,as.data.frame.mlbench,3,0,0,...,1
+mlbench,bayesclass,-1,0,0,class<`factor`>,1
+mlbench,bayesclass,0,0,0,"class<`mlbench`, `mlbench.2dnormals`>",1
+mlbench,bayesclass.mlbench.2dnormals,-1,0,0,class<`factor`>,1
+mlbench,bayesclass.mlbench.2dnormals,0,0,0,"class<`mlbench`, `mlbench.2dnormals`>",1
+mlbench,hypercube,-1,0,0,class<`matrix`>,1
+mlbench,hypercube,0,0,0,double,1
+mlbench,mlbench.1spiral,-1,0,0,class<`matrix`>,1
+mlbench,mlbench.1spiral,0,0,0,double,1
+mlbench,mlbench.1spiral,1,0,0,double,1
+mlbench,mlbench.1spiral,2,0,0,double,1
+mlbench,mlbench.2dnormals,-1,0,0,"class<`mlbench`, `mlbench.2dnormals`>",1
+mlbench,mlbench.2dnormals,0,0,0,double,1
+mlbench,mlbench.2dnormals,1,0,0,double,1
+mlbench,mlbench.2dnormals,2,0,0,double,1
+mlbench,mlbench.2dnormals,3,0,0,double,1
+mlbench,mlbench.cassini,-1,0,0,"class<`mlbench`, `mlbench.cassini`>",1
+mlbench,mlbench.cassini,0,0,0,double,1
+mlbench,mlbench.cassini,1,0,0,double[],1
+mlbench,mlbench.circle,-1,0,0,"class<`mlbench`, `mlbench.circle`>",1
+mlbench,mlbench.circle,0,0,0,double,1
+mlbench,mlbench.circle,1,0,0,double,1
+mlbench,mlbench.cuboids,-1,0,0,"class<`mlbench`, `mlbench.cuboids`>",1
+mlbench,mlbench.cuboids,0,0,0,double,1
+mlbench,mlbench.cuboids,1,0,0,double[],1
+mlbench,mlbench.hypercube,-1,0,0,"class<`mlbench`, `mlbench.hypercube`>",1
+mlbench,mlbench.hypercube,0,0,0,double,1
+mlbench,mlbench.hypercube,1,0,0,double,1
+mlbench,mlbench.hypercube,2,0,0,double[],1
+mlbench,mlbench.hypercube,3,0,0,double,1
+mlbench,mlbench.ringnorm,-1,0,0,"class<`mlbench`, `mlbench.ringnorm`>",1
+mlbench,mlbench.ringnorm,0,0,0,double,1
+mlbench,mlbench.ringnorm,1,0,0,double,1
+mlbench,mlbench.shapes,-1,0,0,"class<`mlbench`, `mlbench.shapes`>",1
+mlbench,mlbench.shapes,0,0,0,double,1
+mlbench,mlbench.simplex,-1,0,0,"class<`mlbench`, `mlbench.simplex`>",1
+mlbench,mlbench.simplex,0,0,0,double,1
+mlbench,mlbench.simplex,1,0,0,double,1
+mlbench,mlbench.simplex,2,0,0,double,1
+mlbench,mlbench.simplex,3,0,0,double,1
+mlbench,mlbench.simplex,4,0,0,logical,1
+mlbench,mlbench.smiley,-1,0,0,"class<`mlbench`, `mlbench.smiley`>",1
+mlbench,mlbench.smiley,0,0,0,double,1
+mlbench,mlbench.smiley,1,0,0,double,1
+mlbench,mlbench.smiley,2,0,0,double,1
+mlbench,mlbench.spirals,-1,0,0,"class<`mlbench`, `mlbench.spirals`>",1
+mlbench,mlbench.spirals,0,0,0,double,1
+mlbench,mlbench.spirals,1,0,0,double,1
+mlbench,mlbench.spirals,2,0,0,double,1
+mlbench,mlbench.threenorm,-1,0,0,"class<`mlbench`, `mlbench.threenorm`>",1
+mlbench,mlbench.threenorm,0,0,0,double,1
+mlbench,mlbench.threenorm,1,0,0,double,1
+mlbench,mlbench.twonorm,-1,0,0,"class<`mlbench`, `mlbench.twonorm`>",1
+mlbench,mlbench.twonorm,0,0,0,double,1
+mlbench,mlbench.twonorm,1,0,0,double,1
+mlbench,mlbench.waveform,-1,0,0,"class<`mlbench`, `mlbench.waveform`>",1
+mlbench,mlbench.waveform,0,0,0,double,1
+mlbench,mlbench.xor,-1,0,0,"class<`mlbench`, `mlbench.xor`>",1
+mlbench,mlbench.xor,0,0,0,double,1
+mlbench,mlbench.xor,1,0,0,double,1
+mlbench,plot.mlbench,-1,0,0,null,1
+mlbench,plot.mlbench,0,0,0,"class<`mlbench`, `mlbench.2dnormals`>",1
+mlbench,plot.mlbench,0,0,1,"class<`mlbench`, `mlbench.cassini`>",1
+mlbench,plot.mlbench,0,0,2,"class<`mlbench`, `mlbench.circle`>",1
+mlbench,plot.mlbench,0,0,3,"class<`mlbench`, `mlbench.cuboids`>",1
+mlbench,plot.mlbench,0,0,4,"class<`mlbench`, `mlbench.hypercube`>",1
+mlbench,plot.mlbench,0,0,5,"class<`mlbench`, `mlbench.ringnorm`>",1
+mlbench,plot.mlbench,0,0,6,"class<`mlbench`, `mlbench.shapes`>",1
+mlbench,plot.mlbench,0,0,7,"class<`mlbench`, `mlbench.simplex`>",1
+mlbench,plot.mlbench,0,0,8,"class<`mlbench`, `mlbench.smiley`>",1
+mlbench,plot.mlbench,0,0,9,"class<`mlbench`, `mlbench.spirals`>",1
+mlbench,plot.mlbench,0,0,10,"class<`mlbench`, `mlbench.threenorm`>",1
+mlbench,plot.mlbench,0,0,11,"class<`mlbench`, `mlbench.twonorm`>",1
+mlbench,plot.mlbench,0,0,12,"class<`mlbench`, `mlbench.waveform`>",1
+mlbench,plot.mlbench,0,0,13,"class<`mlbench`, `mlbench.xor`>",1
+mlbench,plot.mlbench,1,0,0,character,1
+mlbench,plot.mlbench,2,0,0,character,1
+mlbench,plot.mlbench,3,0,0,...,1
+mlbench,simplex,-1,0,0,class<`matrix`>,1
+mlbench,simplex,0,0,0,double,1
+mlbench,simplex,1,0,0,double,1
+mlbench,simplex,2,0,0,logical,1
+mlr3,append_log,-1,0,0,"class<`data.frame`, `data.table`>",1
+mlr3,append_log,0,0,0,"class<`data.frame`, `data.table`>",1
+mlr3,append_log,0,0,1,null,1
+mlr3,append_log,1,0,0,character,1
+mlr3,append_log,2,0,0,any,1
+mlr3,append_log,3,0,0,character[],1
+mlr3,as_benchmark_result,-1,0,0,"class<`BenchmarkResult`, `R6`>",1
+mlr3,as_benchmark_result,0,0,0,"class<`R6`, `ResampleResult`>",1
+mlr3,as_benchmark_result,1,0,0,...,1
+mlr3,as_benchmark_result.ResampleResult,-1,0,0,"class<`BenchmarkResult`, `R6`>",1
+mlr3,as_benchmark_result.ResampleResult,0,0,0,"class<`R6`, `ResampleResult`>",1
+mlr3,as_benchmark_result.ResampleResult,1,0,0,...,1
+mlr3,as_data_backend,-1,0,0,"class<`DataBackend`, `DataBackendDataTable`, `R6`>",1
+mlr3,as_data_backend,-1,0,1,"class<`DataBackend`, `DataBackendMatrix`, `R6`>",1
+mlr3,as_data_backend,0,0,0,class<`data.frame`>,1
+mlr3,as_data_backend,0,0,1,"class<`data.frame`, `data.table`>",1
+mlr3,as_data_backend,0,0,2,class<`dgCMatrix`>,1
+mlr3,as_data_backend,1,0,0,...,1
+mlr3,as_data_backend.data.frame,-1,0,0,"class<`DataBackend`, `DataBackendDataTable`, `R6`>",1
+mlr3,as_data_backend.data.frame,0,0,0,class<`data.frame`>,1
+mlr3,as_data_backend.data.frame,0,0,1,"class<`data.frame`, `data.table`>",1
+mlr3,as_data_backend.data.frame,1,0,0,null,1
+mlr3,as_data_backend.data.frame,2,0,0,logical,1
+mlr3,as_data_backend.data.frame,2,0,1,character,1
+mlr3,as_data_backend.data.frame,3,0,0,...,1
+mlr3,as_data_backend.Matrix,-1,0,0,"class<`DataBackend`, `DataBackendMatrix`, `R6`>",1
+mlr3,as_data_backend.Matrix,0,0,0,class<`dgCMatrix`>,1
+mlr3,as_data_backend.Matrix,1,0,0,class<`data.frame`>,1
+mlr3,as_data_backend.Matrix,2,0,0,character,1
+mlr3,as_data_backend.Matrix,3,0,0,...,1
+mlr3,as.data.table.BenchmarkResult,-1,0,0,"class<`data.frame`, `data.table`>",1
+mlr3,as.data.table.BenchmarkResult,0,0,0,"class<`BenchmarkResult`, `R6`>",1
+mlr3,as.data.table.BenchmarkResult,1,0,0,...,1
+mlr3,as.data.table.DictionaryLearner,-1,0,0,"class<`data.frame`, `data.table`>",1
+mlr3,as.data.table.DictionaryLearner,0,0,0,"class<`Dictionary`, `DictionaryLearner`, `R6`>",1
+mlr3,as.data.table.DictionaryLearner,1,0,0,...,1
+mlr3,as.data.table.DictionaryMeasure,-1,0,0,"class<`data.frame`, `data.table`>",1
+mlr3,as.data.table.DictionaryMeasure,0,0,0,"class<`Dictionary`, `DictionaryMeasure`, `R6`>",1
+mlr3,as.data.table.DictionaryMeasure,1,0,0,...,1
+mlr3,as.data.table.DictionaryResampling,-1,0,0,"class<`data.frame`, `data.table`>",1
+mlr3,as.data.table.DictionaryResampling,0,0,0,"class<`Dictionary`, `DictionaryResampling`, `R6`>",1
+mlr3,as.data.table.DictionaryResampling,1,0,0,...,1
+mlr3,as.data.table.DictionaryTask,-1,0,0,"class<`data.frame`, `data.table`>",1
+mlr3,as.data.table.DictionaryTask,0,0,0,"class<`Dictionary`, `DictionaryTask`, `R6`>",1
+mlr3,as.data.table.DictionaryTask,1,0,0,...,1
+mlr3,as.data.table.PredictionClassif,-1,0,0,"class<`data.frame`, `data.table`>",1
+mlr3,as.data.table.PredictionClassif,0,0,0,"class<`Prediction`, `PredictionClassif`, `R6`>",1
+mlr3,as.data.table.PredictionClassif,1,0,0,...,1
+mlr3,as.data.table.PredictionRegr,-1,0,0,"class<`data.frame`, `data.table`>",1
+mlr3,as.data.table.PredictionRegr,0,0,0,"class<`Prediction`, `PredictionRegr`, `R6`>",1
+mlr3,as.data.table.PredictionRegr,1,0,0,...,1
+mlr3,as_learner,-1,0,0,"class<`Learner`, `LearnerClassif`, `LearnerClassifFeatureless`, `R6`>",1
+mlr3,as_learner,-1,0,1,"class<`Learner`, `LearnerClassif`, `LearnerClassifRpart`, `R6`>",1
+mlr3,as_learner,0,0,0,"class<`Learner`, `LearnerClassif`, `LearnerClassifFeatureless`, `R6`>",1
+mlr3,as_learner,0,0,1,"class<`Learner`, `LearnerClassif`, `LearnerClassifRpart`, `R6`>",1
+mlr3,as_learner,1,0,0,logical,1
+mlr3,as_learner.Learner,-1,0,0,"class<`Learner`, `LearnerClassif`, `LearnerClassifFeatureless`, `R6`>",1
+mlr3,as_learner.Learner,-1,0,1,"class<`Learner`, `LearnerClassif`, `LearnerClassifRpart`, `R6`>",1
+mlr3,as_learner.Learner,0,0,0,"class<`Learner`, `LearnerClassif`, `LearnerClassifFeatureless`, `R6`>",1
+mlr3,as_learner.Learner,0,0,1,"class<`Learner`, `LearnerClassif`, `LearnerClassifRpart`, `R6`>",1
+mlr3,as_learner.Learner,1,0,0,logical,1
+mlr3,as_learners,-1,0,0,"list<class<`Learner`, `LearnerClassif`, `LearnerClassifFeatureless`, `R6`> | class<`Learner`, `LearnerClassif`, `LearnerClassifRpart`, `R6`>>",1
+mlr3,as_learners,0,0,0,"list<class<`Learner`, `LearnerClassif`, `LearnerClassifFeatureless`, `R6`> | class<`Learner`, `LearnerClassif`, `LearnerClassifRpart`, `R6`>>",1
+mlr3,as_learners,1,0,0,logical,1
+mlr3,as_learners.list,-1,0,0,"list<class<`Learner`, `LearnerClassif`, `LearnerClassifFeatureless`, `R6`> | class<`Learner`, `LearnerClassif`, `LearnerClassifRpart`, `R6`>>",1
+mlr3,as_learners.list,0,0,0,"list<class<`Learner`, `LearnerClassif`, `LearnerClassifFeatureless`, `R6`> | class<`Learner`, `LearnerClassif`, `LearnerClassifRpart`, `R6`>>",1
+mlr3,as_learners.list,1,0,0,logical,1
+mlr3,as_measures,-1,0,0,list<any>,1
+mlr3,as_measures,0,0,0,list<any>,1
+mlr3,as_measures,0,0,1,"class<`Measure`, `MeasureClassif`, `MeasureClassifCosts`, `R6`>",1
+mlr3,as_measures,0,0,2,"class<`Measure`, `MeasureClassif`, `MeasureClassifSimple`, `R6`>",1
+mlr3,as_measures,0,0,3,"class<`Measure`, `MeasureDebug`, `R6`>",1
+mlr3,as_measures,0,0,4,null,1
+mlr3,as_measures,1,0,0,any,1
+mlr3,as_measures,2,0,0,logical,1
+mlr3,as_measures.list,-1,0,0,list<any>,1
+mlr3,as_measures.list,0,0,0,list<any>,1
+mlr3,as_measures.list,1,0,0,any,1
+mlr3,as_measures.list,2,0,0,logical,1
+mlr3,as_measures.Measure,-1,0,0,"list<class<`Measure`, `MeasureClassif`, `MeasureClassifCosts`, `R6`>>",1
+mlr3,as_measures.Measure,-1,0,1,"list<class<`Measure`, `MeasureClassif`, `MeasureClassifSimple`, `R6`>>",1
+mlr3,as_measures.Measure,-1,0,2,"list<class<`Measure`, `MeasureDebug`, `R6`>>",1
+mlr3,as_measures.Measure,0,0,0,"class<`Measure`, `MeasureClassif`, `MeasureClassifCosts`, `R6`>",1
+mlr3,as_measures.Measure,0,0,1,"class<`Measure`, `MeasureClassif`, `MeasureClassifSimple`, `R6`>",1
+mlr3,as_measures.Measure,0,0,2,"class<`Measure`, `MeasureDebug`, `R6`>",1
+mlr3,as_measures.Measure,1,0,0,any,1
+mlr3,as_measures.Measure,2,0,0,logical,1
+mlr3,as_measures.NULL,-1,0,0,"list<class<`Measure`, `MeasureClassif`, `MeasureClassifSimple`, `R6`>>",1
+mlr3,as_measures.NULL,0,0,0,null,1
+mlr3,as_measures.NULL,1,0,0,character,1
+mlr3,as_measures.NULL,2,0,0,logical,1
+mlr3,as_resampling,-1,0,0,"class<`R6`, `Resampling`, `ResamplingCV`>",1
+mlr3,as_resampling,0,0,0,"class<`R6`, `Resampling`, `ResamplingCV`>",1
+mlr3,as_resampling,1,0,0,logical,1
+mlr3,as_resampling.Resampling,-1,0,0,"class<`R6`, `Resampling`, `ResamplingCV`>",1
+mlr3,as_resampling.Resampling,-1,0,1,"class<`R6`, `Resampling`, `ResamplingHoldout`>",1
+mlr3,as_resampling.Resampling,-1,0,2,"class<`R6`, `Resampling`, `ResamplingSubsampling`>",1
+mlr3,as_resampling.Resampling,-1,0,3,"class<`R6`, `Task`, `TaskClassif`, `TaskSupervised`>",1
+mlr3,as_resampling.Resampling,-1,0,4,"class<`R6`, `Task`, `TaskRegr`, `TaskSupervised`>",1
+mlr3,as_resampling.Resampling,0,0,0,"class<`R6`, `Resampling`, `ResamplingCV`>",1
+mlr3,as_resampling.Resampling,0,0,1,"class<`R6`, `Resampling`, `ResamplingHoldout`>",1
+mlr3,as_resampling.Resampling,0,0,2,"class<`R6`, `Resampling`, `ResamplingSubsampling`>",1
+mlr3,as_resampling.Resampling,0,0,3,"class<`R6`, `Task`, `TaskClassif`, `TaskSupervised`>",1
+mlr3,as_resampling.Resampling,0,0,4,"class<`R6`, `Task`, `TaskRegr`, `TaskSupervised`>",1
+mlr3,as_resampling.Resampling,1,0,0,logical,1
+mlr3,as_resamplings,-1,0,0,"list<class<`R6`, `Resampling`, `ResamplingCV`>>",1
+mlr3,as_resamplings,-1,0,1,"list<class<`R6`, `Resampling`, `ResamplingCV`> | class<`R6`, `Resampling`, `ResamplingHoldout`>>",1
+mlr3,as_resamplings,-1,0,2,"list<class<`R6`, `Resampling`, `ResamplingCV`> | class<`R6`, `Resampling`, `ResamplingSubsampling`>>",1
+mlr3,as_resamplings,0,0,0,"list<class<`R6`, `Resampling`, `ResamplingCV`>>",1
+mlr3,as_resamplings,0,0,1,"list<class<`R6`, `Resampling`, `ResamplingCV`> | class<`R6`, `Resampling`, `ResamplingHoldout`>>",1
+mlr3,as_resamplings,0,0,2,"list<class<`R6`, `Resampling`, `ResamplingCV`> | class<`R6`, `Resampling`, `ResamplingSubsampling`>>",1
+mlr3,as_resamplings,0,0,3,"class<`R6`, `Resampling`, `ResamplingCV`>",1
+mlr3,as_resamplings,1,0,0,logical,1
+mlr3,as_resamplings.list,-1,0,0,"list<class<`R6`, `Resampling`, `ResamplingCV`>>",1
+mlr3,as_resamplings.list,-1,0,1,"list<class<`R6`, `Resampling`, `ResamplingCV`> | class<`R6`, `Resampling`, `ResamplingHoldout`>>",1
+mlr3,as_resamplings.list,-1,0,2,"list<class<`R6`, `Resampling`, `ResamplingCV`> | class<`R6`, `Resampling`, `ResamplingSubsampling`>>",1
+mlr3,as_resamplings.list,0,0,0,"list<class<`R6`, `Resampling`, `ResamplingCV`>>",1
+mlr3,as_resamplings.list,0,0,1,"list<class<`R6`, `Resampling`, `ResamplingCV`> | class<`R6`, `Resampling`, `ResamplingHoldout`>>",1
+mlr3,as_resamplings.list,0,0,2,"list<class<`R6`, `Resampling`, `ResamplingCV`> | class<`R6`, `Resampling`, `ResamplingSubsampling`>>",1
+mlr3,as_resamplings.list,1,0,0,logical,1
+mlr3,as_resamplings.Resampling,-1,0,0,"list<class<`R6`, `Resampling`, `ResamplingCV`>>",1
+mlr3,as_resamplings.Resampling,0,0,0,"class<`R6`, `Resampling`, `ResamplingCV`>",1
+mlr3,as_resamplings.Resampling,1,0,0,logical,1
+mlr3,assert_backend,-1,0,0,"class<`DataBackend`, `DataBackendDataTable`, `R6`>",1
+mlr3,assert_backend,0,0,0,"class<`DataBackend`, `DataBackendDataTable`, `R6`>",1
+mlr3,assert_backend,1,0,0,any,1
+mlr3,assert_benchmark_result,-1,0,0,"class<`BenchmarkResult`, `R6`>",1
+mlr3,assert_benchmark_result,0,0,0,"class<`BenchmarkResult`, `R6`>",1
+mlr3,assert_benchmark_result,1,0,0,any,1
+mlr3,assert_cost_matrix,-1,0,0,class<`matrix`>,1
+mlr3,assert_cost_matrix,0,0,0,class<`matrix`>,1
+mlr3,assert_cost_matrix,1,0,0,"class<`R6`, `Task`, `TaskClassif`, `TaskSupervised`>",1
+mlr3,assert_cost_matrix,1,0,1,null,1
+mlr3,assert_learnable,-1,0,0,null,1
+mlr3,assert_learnable,0,0,0,"class<`R6`, `Task`, `TaskClassif`, `TaskSupervised`>",1
+mlr3,assert_learnable,0,0,1,"class<`R6`, `Task`, `TaskRegr`, `TaskSupervised`>",1
+mlr3,assert_learnable,1,0,0,"class<`Learner`, `LearnerClassif`, `LearnerClassifDebug`, `R6`>",1
+mlr3,assert_learnable,1,0,1,"class<`Learner`, `LearnerClassif`, `LearnerClassifFeatureless`, `R6`>",1
+mlr3,assert_learnable,1,0,2,"class<`Learner`, `LearnerClassif`, `LearnerClassifRpart`, `R6`>",1
+mlr3,assert_learnable,1,0,3,"class<`Learner`, `LearnerRegr`, `LearnerRegrFeatureless`, `R6`>",1
+mlr3,assert_learner,-1,0,0,"class<`Learner`, `LearnerClassif`, `LearnerClassifFeatureless`, `R6`>",1
+mlr3,assert_learner,-1,0,1,"class<`Learner`, `LearnerClassif`, `LearnerClassifRpart`, `R6`>",1
+mlr3,assert_learner,0,0,0,"class<`Learner`, `LearnerClassif`, `LearnerClassifFeatureless`, `R6`>",1
+mlr3,assert_learner,0,0,1,"class<`Learner`, `LearnerClassif`, `LearnerClassifRpart`, `R6`>",1
+mlr3,assert_learner,1,0,0,null,1
+mlr3,assert_learner,2,0,0,character[],1
+mlr3,assert_learner,3,0,0,any,1
+mlr3,assert_learners,-1,0,0,"list<class<`Learner`, `LearnerClassif`, `LearnerClassifFeatureless`, `R6`> | class<`Learner`, `LearnerClassif`, `LearnerClassifRpart`, `R6`>>",1
+mlr3,assert_learners,0,0,0,"list<class<`Learner`, `LearnerClassif`, `LearnerClassifFeatureless`, `R6`> | class<`Learner`, `LearnerClassif`, `LearnerClassifRpart`, `R6`>>",1
+mlr3,assert_learners,1,0,0,null,1
+mlr3,assert_learners,2,0,0,character[],1
+mlr3,assert_learners,3,0,0,any,1
+mlr3,assert_measures,-1,0,0,list<any>,1
+mlr3,assert_measures,0,0,0,list<any>,1
+mlr3,assert_measures,1,0,0,any,1
+mlr3,assert_measures,2,0,0,any,1
+mlr3,assert_measures,3,0,0,any,1
+mlr3,assert_prediction,-1,0,0,"class<`Prediction`, `PredictionClassif`, `R6`>",1
+mlr3,assert_prediction,0,0,0,"class<`Prediction`, `PredictionClassif`, `R6`>",1
+mlr3,assert_prediction,1,0,0,any,1
+mlr3,assert_range,-1,0,0,double[],1
+mlr3,assert_range,0,0,0,double[],1
+mlr3,assert_range,1,0,0,any,1
+mlr3,assert_resampling,-1,0,0,"class<`R6`, `Resampling`, `ResamplingCV`>",1
+mlr3,assert_resampling,0,0,0,"class<`R6`, `Resampling`, `ResamplingCV`>",1
+mlr3,assert_resampling,1,0,0,null,1
+mlr3,assert_resampling,2,0,0,any,1
+mlr3,assert_resamplings,-1,0,0,"list<class<`R6`, `Resampling`, `ResamplingCV`>>",1
+mlr3,assert_resamplings,-1,0,1,"list<class<`R6`, `Resampling`, `ResamplingCV`> | class<`R6`, `Resampling`, `ResamplingHoldout`>>",1
+mlr3,assert_resamplings,-1,0,2,"list<class<`R6`, `Resampling`, `ResamplingCV`> | class<`R6`, `Resampling`, `ResamplingSubsampling`>>",1
+mlr3,assert_resamplings,0,0,0,"list<class<`R6`, `Resampling`, `ResamplingCV`>>",1
+mlr3,assert_resamplings,0,0,1,"list<class<`R6`, `Resampling`, `ResamplingCV`> | class<`R6`, `Resampling`, `ResamplingHoldout`>>",1
+mlr3,assert_resamplings,0,0,2,"list<class<`R6`, `Resampling`, `ResamplingCV`> | class<`R6`, `Resampling`, `ResamplingSubsampling`>>",1
+mlr3,assert_resamplings,1,0,0,logical,1
+mlr3,assert_resamplings,1,0,1,null,1
+mlr3,assert_resamplings,2,0,0,any,1
+mlr3,assert_ro_binding,-1,0,0,null,1
+mlr3,assert_ro_binding,0,0,0,any,1
+mlr3,assert_row_ids,-1,0,0,integer[],1
+mlr3,assert_row_ids,-1,0,1,null,1
+mlr3,assert_row_ids,0,0,0,integer[],1
+mlr3,assert_row_ids,0,0,1,null,1
+mlr3,assert_row_ids,1,0,0,logical,1
+mlr3,assert_row_ids,2,0,0,any,1
+mlr3,assert_set,-1,0,0,character[],1
+mlr3,assert_set,0,0,0,character[],1
+mlr3,assert_set,1,0,0,logical,1
+mlr3,assert_set,2,0,0,any,1
+mlr3,assert_task,-1,0,0,"class<`R6`, `Task`, `TaskClassif`, `TaskSupervised`>",1
+mlr3,assert_task,-1,0,1,"class<`R6`, `Task`, `TaskRegr`, `TaskSupervised`>",1
+mlr3,assert_task,0,0,0,"class<`R6`, `Task`, `TaskClassif`, `TaskSupervised`>",1
+mlr3,assert_task,0,0,1,"class<`R6`, `Task`, `TaskRegr`, `TaskSupervised`>",1
+mlr3,assert_task,1,0,0,null,1
+mlr3,assert_task,2,0,0,null,1
+mlr3,assert_task,3,0,0,null,1
+mlr3,assert_task,4,0,0,any,1
+mlr3,assert_tasks,-1,0,0,"list<class<`R6`, `Task`, `TaskClassif`, `TaskSupervised`>>",1
+mlr3,assert_tasks,0,0,0,"list<class<`R6`, `Task`, `TaskClassif`, `TaskSupervised`>>",1
+mlr3,assert_tasks,1,0,0,null,1
+mlr3,assert_tasks,2,0,0,null,1
+mlr3,assert_tasks,3,0,0,null,1
+mlr3,assert_tasks,4,0,0,any,1
+mlr3,as_task,-1,0,0,"class<`R6`, `Task`, `TaskClassif`, `TaskSupervised`>",1
+mlr3,as_task,-1,0,1,"class<`R6`, `Task`, `TaskRegr`, `TaskSupervised`>",1
+mlr3,as_task,0,0,0,"class<`R6`, `Task`, `TaskClassif`, `TaskSupervised`>",1
+mlr3,as_task,0,0,1,"class<`R6`, `Task`, `TaskRegr`, `TaskSupervised`>",1
+mlr3,as_task,1,0,0,logical,1
+mlr3,as_tasks,-1,0,0,"list<class<`R6`, `Task`, `TaskClassif`, `TaskSupervised`>>",1
+mlr3,as_tasks,0,0,0,"list<class<`R6`, `Task`, `TaskClassif`, `TaskSupervised`>>",1
+mlr3,as_tasks,1,0,0,logical,1
+mlr3,as_tasks.list,-1,0,0,"list<class<`R6`, `Task`, `TaskClassif`, `TaskSupervised`>>",1
+mlr3,as_tasks.list,0,0,0,"list<class<`R6`, `Task`, `TaskClassif`, `TaskSupervised`>>",1
+mlr3,as_tasks.list,1,0,0,logical,1
+mlr3,as_task.Task,-1,0,0,"class<`R6`, `Resampling`, `ResamplingCV`>",1
+mlr3,as_task.Task,-1,0,1,"class<`R6`, `Resampling`, `ResamplingHoldout`>",1
+mlr3,as_task.Task,-1,0,2,"class<`R6`, `Resampling`, `ResamplingSubsampling`>",1
+mlr3,as_task.Task,-1,0,3,"class<`R6`, `Task`, `TaskClassif`, `TaskSupervised`>",1
+mlr3,as_task.Task,-1,0,4,"class<`R6`, `Task`, `TaskRegr`, `TaskSupervised`>",1
+mlr3,as_task.Task,0,0,0,"class<`R6`, `Resampling`, `ResamplingCV`>",1
+mlr3,as_task.Task,0,0,1,"class<`R6`, `Resampling`, `ResamplingHoldout`>",1
+mlr3,as_task.Task,0,0,2,"class<`R6`, `Resampling`, `ResamplingSubsampling`>",1
+mlr3,as_task.Task,0,0,3,"class<`R6`, `Task`, `TaskClassif`, `TaskSupervised`>",1
+mlr3,as_task.Task,0,0,4,"class<`R6`, `Task`, `TaskRegr`, `TaskSupervised`>",1
+mlr3,as_task.Task,1,0,0,logical,1
+mlr3,benchmark,-1,0,0,"class<`BenchmarkResult`, `R6`>",1
+mlr3,benchmark,0,0,0,"class<`data.frame`, `data.table`>",1
+mlr3,benchmark,1,0,0,logical,1
+mlr3,benchmark_grid,-1,0,0,"class<`data.frame`, `data.table`>",1
+mlr3,benchmark_grid,0,0,0,"list<class<`R6`, `Task`, `TaskClassif`, `TaskSupervised`>>",1
+mlr3,benchmark_grid,1,0,0,"list<class<`Learner`, `LearnerClassif`, `LearnerClassifFeatureless`, `R6`> | class<`Learner`, `LearnerClassif`, `LearnerClassifRpart`, `R6`>>",1
+mlr3,benchmark_grid,2,0,0,"class<`R6`, `Resampling`, `ResamplingCV`>",1
+mlr3,benchmark_grid,2,0,1,"list<class<`R6`, `Resampling`, `ResamplingCV`> | class<`R6`, `Resampling`, `ResamplingSubsampling`>>",1
+mlr3,col_info,-1,0,0,"class<`data.frame`, `data.table`>",1
+mlr3,col_info,0,0,0,"class<`DataBackend`, `DataBackendDataTable`, `R6`>",1
+mlr3,col_info,0,0,1,"class<`data.frame`, `data.table`>",1
+mlr3,col_info,1,0,0,...,1
+mlr3,col_info.DataBackend,-1,0,0,"class<`data.frame`, `data.table`>",1
+mlr3,col_info.DataBackend,0,0,0,"class<`DataBackend`, `DataBackendDataTable`, `R6`>",1
+mlr3,col_info.DataBackend,1,0,0,...,1
+mlr3,col_info.data.table,-1,0,0,"class<`data.frame`, `data.table`>",1
+mlr3,col_info.data.table,0,0,0,"class<`data.frame`, `data.table`>",1
+mlr3,col_info.data.table,1,0,0,character[],1
+mlr3,col_info.data.table,2,0,0,...,1
+mlr3,convert_matching_types,-1,0,0,list<null>,1
+mlr3,convert_matching_types,0,0,0,"class<`data.frame`, `data.table`>",1
+mlr3,convert_matching_types,1,0,0,"class<`data.frame`, `data.table`>",1
+mlr3,c.PredictionClassif,-1,0,0,"class<`Prediction`, `PredictionClassif`, `R6`>",1
+mlr3,c.PredictionClassif,0,0,0,...,1
+mlr3,c.PredictionClassif,1,0,0,logical,1
+mlr3,default_measures,-1,0,0,"list<class<`Measure`, `MeasureClassif`, `MeasureClassifSimple`, `R6`>>",1
+mlr3,default_measures,-1,0,1,"list<class<`Measure`, `MeasureRegr`, `MeasureRegrSimple`, `R6`>>",1
+mlr3,default_measures,0,0,0,character,1
+mlr3,get_progressor,-1,0,0,null,1
+mlr3,get_progressor,0,0,0,any,1
+mlr3,get_progressor,1,0,0,null,1
+mlr3,hash,-1,0,0,character,1
+mlr3,hash,0,0,0,...,1
+mlr3,hashes,-1,0,0,character[],1
+mlr3,hashes,0,0,0,"list<class<`Learner`, `LearnerClassif`, `LearnerClassifFeatureless`, `R6`> | class<`Learner`, `LearnerClassif`, `LearnerClassifRpart`, `R6`>>",1
+mlr3,hashes,0,0,1,"list<class<`R6`, `Resampling`, `ResamplingCV`>>",1
+mlr3,hashes,0,0,2,"list<class<`R6`, `Resampling`, `ResamplingCV`> | class<`R6`, `Resampling`, `ResamplingHoldout`>>",1
+mlr3,hashes,0,0,3,"list<class<`R6`, `Task`, `TaskClassif`, `TaskSupervised`>>",1
+mlr3,learner_predict,-1,0,0,"class<`Prediction`, `PredictionClassif`, `R6`>",1
+mlr3,learner_predict,-1,0,1,"class<`Prediction`, `PredictionRegr`, `R6`>",1
+mlr3,learner_predict,0,0,0,"class<`Learner`, `LearnerClassif`, `LearnerClassifDebug`, `R6`>",1
+mlr3,learner_predict,0,0,1,"class<`Learner`, `LearnerClassif`, `LearnerClassifFeatureless`, `R6`>",1
+mlr3,learner_predict,0,0,2,"class<`Learner`, `LearnerClassif`, `LearnerClassifRpart`, `R6`>",1
+mlr3,learner_predict,0,0,3,"class<`Learner`, `LearnerRegr`, `LearnerRegrFeatureless`, `R6`>",1
+mlr3,learner_predict,1,0,0,"class<`R6`, `Task`, `TaskClassif`, `TaskSupervised`>",1
+mlr3,learner_predict,1,0,1,"class<`R6`, `Task`, `TaskRegr`, `TaskSupervised`>",1
+mlr3,learner_predict,2,0,0,null,1
+mlr3,learner_predict,2,0,1,integer[],1
+mlr3,learner_train,-1,0,0,"class<`Learner`, `LearnerClassif`, `LearnerClassifDebug`, `R6`>",1
+mlr3,learner_train,-1,0,1,"class<`Learner`, `LearnerClassif`, `LearnerClassifFeatureless`, `R6`>",1
+mlr3,learner_train,-1,0,2,"class<`Learner`, `LearnerClassif`, `LearnerClassifRpart`, `R6`>",1
+mlr3,learner_train,-1,0,3,"class<`Learner`, `LearnerRegr`, `LearnerRegrFeatureless`, `R6`>",1
+mlr3,learner_train,0,0,0,"class<`Learner`, `LearnerClassif`, `LearnerClassifDebug`, `R6`>",1
+mlr3,learner_train,0,0,1,"class<`Learner`, `LearnerClassif`, `LearnerClassifFeatureless`, `R6`>",1
+mlr3,learner_train,0,0,2,"class<`Learner`, `LearnerClassif`, `LearnerClassifRpart`, `R6`>",1
+mlr3,learner_train,0,0,3,"class<`Learner`, `LearnerRegr`, `LearnerRegrFeatureless`, `R6`>",1
+mlr3,learner_train,1,0,0,"class<`R6`, `Task`, `TaskClassif`, `TaskSupervised`>",1
+mlr3,learner_train,1,0,1,"class<`R6`, `Task`, `TaskRegr`, `TaskSupervised`>",1
+mlr3,learner_train,2,0,0,null,1
+mlr3,learner_train,2,0,1,integer[],1
+mlr3,lrn,-1,0,0,"class<`Learner`, `LearnerClassif`, `LearnerClassifFeatureless`, `R6`>",1
+mlr3,lrn,-1,0,1,"class<`Learner`, `LearnerClassif`, `LearnerClassifRpart`, `R6`>",1
+mlr3,lrn,-1,0,2,"class<`Learner`, `LearnerClassif`, `LearnerClassifDebug`, `R6`>",1
+mlr3,lrn,-1,0,3,"class<`Learner`, `LearnerRegr`, `LearnerRegrFeatureless`, `R6`>",1
+mlr3,lrn,0,0,0,character,1
+mlr3,lrn,1,0,0,...,1
+mlr3,measure_score,-1,0,0,double,1
+mlr3,measure_score,0,0,0,"class<`Measure`, `MeasureClassif`, `MeasureClassifCosts`, `R6`>",1
+mlr3,measure_score,0,0,1,"class<`Measure`, `MeasureClassif`, `MeasureClassifSimple`, `R6`>",1
+mlr3,measure_score,0,0,2,"class<`Measure`, `MeasureDebug`, `R6`>",1
+mlr3,measure_score,1,0,0,"list<class<`Prediction`, `PredictionClassif`, `R6`>>",1
+mlr3,measure_score,1,0,1,"class<`Prediction`, `PredictionClassif`, `R6`>",1
+mlr3,measure_score,2,0,0,any,1
+mlr3,measure_score,3,0,0,any,1
+mlr3,measure_score,4,0,0,any,1
+mlr3,measure_score_data,-1,0,0,double[],1
+mlr3,measure_score_data,0,0,0,"class<`Measure`, `MeasureClassif`, `MeasureClassifCosts`, `R6`>",1
+mlr3,measure_score_data,0,0,1,"class<`Measure`, `MeasureClassif`, `MeasureClassifSimple`, `R6`>",1
+mlr3,measure_score_data,0,0,2,"class<`Measure`, `MeasureDebug`, `R6`>",1
+mlr3,measure_score_data,1,0,0,"class<`data.frame`, `data.table`>",1
+mlr3,msr,-1,0,0,"class<`Measure`, `MeasureClassif`, `MeasureClassifCosts`, `R6`>",1
+mlr3,msr,-1,0,1,"class<`Measure`, `MeasureClassif`, `MeasureClassifSimple`, `R6`>",1
+mlr3,msr,-1,0,2,"class<`Measure`, `MeasureDebug`, `R6`>",1
+mlr3,msr,-1,0,3,"class<`Measure`, `MeasureRegr`, `MeasureRegrSimple`, `R6`>",1
+mlr3,msr,0,0,0,character,1
+mlr3,msr,1,0,0,...,1
+mlr3,predict.Learner,-1,0,0,class<`factor`>,1
+mlr3,predict.Learner,-1,0,1,class<`matrix`>,1
+mlr3,predict.Learner,-1,0,2,"class<`Prediction`, `PredictionClassif`, `R6`>",1
+mlr3,predict.Learner,0,0,0,"class<`Learner`, `LearnerClassif`, `LearnerClassifRpart`, `R6`>",1
+mlr3,predict.Learner,1,0,0,"class<`data.frame`, `data.table`>",1
+mlr3,predict.Learner,2,0,0,character,1
+mlr3,predict.Learner,3,0,0,...,1
+mlr3,replace_with,-1,0,0,character[],1
+mlr3,replace_with,0,0,0,character[],1
+mlr3,replace_with,1,0,0,character,1
+mlr3,replace_with,2,0,0,character,1
+mlr3,resample,-1,0,0,"class<`R6`, `ResampleResult`>",1
+mlr3,resample,0,0,0,"class<`R6`, `Task`, `TaskClassif`, `TaskSupervised`>",1
+mlr3,resample,1,0,0,"class<`Learner`, `LearnerClassif`, `LearnerClassifFeatureless`, `R6`>",1
+mlr3,resample,1,0,1,"class<`Learner`, `LearnerClassif`, `LearnerClassifRpart`, `R6`>",1
+mlr3,resample,2,0,0,"class<`R6`, `Resampling`, `ResamplingCV`>",1
+mlr3,resample,3,0,0,logical,1
+mlr3,rsmp,-1,0,0,"class<`R6`, `Resampling`, `ResamplingBootstrap`>",1
+mlr3,rsmp,-1,0,1,"class<`R6`, `Resampling`, `ResamplingCustom`>",1
+mlr3,rsmp,-1,0,2,"class<`R6`, `Resampling`, `ResamplingCV`>",1
+mlr3,rsmp,-1,0,3,"class<`R6`, `Resampling`, `ResamplingHoldout`>",1
+mlr3,rsmp,-1,0,4,"class<`R6`, `Resampling`, `ResamplingRepeatedCV`>",1
+mlr3,rsmp,-1,0,5,"class<`R6`, `Resampling`, `ResamplingSubsampling`>",1
+mlr3,rsmp,0,0,0,character,1
+mlr3,rsmp,1,0,0,...,1
+mlr3,task_cbind,-1,0,0,"class<`R6`, `Task`, `TaskClassif`, `TaskSupervised`>",1
+mlr3,task_cbind,0,0,0,"class<`R6`, `Task`, `TaskClassif`, `TaskSupervised`>",1
+mlr3,task_cbind,1,0,0,class<`data.frame`>,1
+mlr3,task_data,-1,0,0,"class<`data.frame`, `data.table`>",1
+mlr3,task_data,0,0,0,"class<`R6`, `Task`, `TaskClassif`, `TaskSupervised`>",1
+mlr3,task_data,0,0,1,"class<`R6`, `Task`, `TaskRegr`, `TaskSupervised`>",1
+mlr3,task_data,1,0,0,environment,1
+mlr3,task_data,2,0,0,integer[],1
+mlr3,task_data,2,0,1,null,1
+mlr3,task_data,3,0,0,character[],1
+mlr3,task_data,3,0,1,null,1
+mlr3,task_data,4,0,0,character,1
+mlr3,task_data,5,0,0,any,1
+mlr3,task_rbind,-1,0,0,"class<`R6`, `Task`, `TaskClassif`, `TaskSupervised`>",1
+mlr3,task_rbind,0,0,0,"class<`R6`, `Task`, `TaskClassif`, `TaskSupervised`>",1
+mlr3,task_rbind,1,0,0,"class<`data.frame`, `data.table`>",1
+mlr3,task_rm_data,-1,0,0,"class<`R6`, `Task`, `TaskClassif`, `TaskSupervised`>",1
+mlr3,task_rm_data,-1,0,1,"class<`R6`, `Task`, `TaskRegr`, `TaskSupervised`>",1
+mlr3,task_rm_data,0,0,0,"class<`R6`, `Task`, `TaskClassif`, `TaskSupervised`>",1
+mlr3,task_rm_data,0,0,1,"class<`R6`, `Task`, `TaskRegr`, `TaskSupervised`>",1
+mlr3,task_set_col_roles,-1,0,0,list<character[]>,1
+mlr3,task_set_col_roles,0,0,0,"class<`R6`, `Task`, `TaskClassif`, `TaskSupervised`>",1
+mlr3,task_set_col_roles,0,0,1,"class<`R6`, `Task`, `TaskRegr`, `TaskSupervised`>",1
+mlr3,task_set_col_roles,0,0,2,"class<`R6`, `Task`, `TaskSupervised`>",1
+mlr3,task_set_col_roles,1,0,0,environment,1
+mlr3,task_set_col_roles,2,0,0,list<character[]>,1
+mlr3,tgen,-1,0,0,"class<`R6`, `TaskGenerator`, `TaskGenerator2DNormals`>",1
+mlr3,tgen,-1,0,1,"class<`R6`, `TaskGenerator`, `TaskGeneratorFriedman1`>",1
+mlr3,tgen,-1,0,2,"class<`R6`, `TaskGenerator`, `TaskGeneratorSmiley`>",1
+mlr3,tgen,-1,0,3,"class<`R6`, `TaskGenerator`, `TaskGeneratorXor`>",1
+mlr3,tgen,0,0,0,character,1
+mlr3,tgen,1,0,0,...,1
+mlr3,translate_types,-1,0,0,class<`factor`>,1
+mlr3,translate_types,0,0,0,character[],1
+mlr3,tsk,-1,0,0,"class<`R6`, `Task`, `TaskClassif`, `TaskSupervised`>",1
+mlr3,tsk,-1,0,1,"class<`R6`, `Task`, `TaskRegr`, `TaskSupervised`>",1
+mlr3,tsk,0,0,0,character,1
+mlr3,tsk,1,0,0,...,1
+mlr3,ujoin,-1,0,0,"class<`data.frame`, `data.table`>",1
+mlr3,ujoin,0,0,0,"class<`data.frame`, `data.table`>",1
+mlr3,ujoin,1,0,0,"class<`data.frame`, `data.table`>",1
+mlr3,ujoin,2,0,0,character,1
+mlr3,use_future,-1,0,0,logical,1
+mlr3misc,as_factor,-1,0,0,class<`factor`>,1
+mlr3misc,as_factor,0,0,0,class<`factor`>,1
+mlr3misc,as_factor,1,0,0,character[],1
+mlr3misc,as_factor,2,0,0,logical,1
+mlr3misc,as_short_string,-1,0,0,character,1
+mlr3misc,as_short_string,0,0,0,list<any>,1
+mlr3misc,as_short_string,1,0,0,integer,1
+mlr3misc,as_short_string,2,0,0,character,1
+mlr3misc,check_packages_installed,-1,0,0,any,1
+mlr3misc,check_packages_installed,0,0,0,character[],1
+mlr3misc,check_packages_installed,1,0,0,logical,1
+mlr3misc,check_packages_installed,2,0,0,character,1
+mlr3misc,chunk,-1,0,0,integer[],1
+mlr3misc,chunk,0,0,0,integer,1
+mlr3misc,chunk,1,0,0,double,1
+mlr3misc,chunk,2,0,0,null,1
+mlr3misc,chunk,3,0,0,logical,1
+mlr3misc,chunk_vector,-1,0,0,list<integer[]>,1
+mlr3misc,chunk_vector,0,0,0,integer[],1
+mlr3misc,chunk_vector,1,0,0,double,1
+mlr3misc,chunk_vector,2,0,0,null,1
+mlr3misc,chunk_vector,3,0,0,logical,1
+mlr3misc,cite_bib,-1,0,0,character,1
+mlr3misc,cite_bib,0,0,0,character,1
+mlr3misc,cite_bib,1,0,0,character,1
+mlr3misc,compute_mode,-1,0,0,double,1
+mlr3misc,compute_mode,0,0,0,double[],1
+mlr3misc,compute_mode,1,0,0,character,1
+mlr3misc,compute_mode,2,0,0,logical,1
+mlr3misc,cross_join,-1,0,0,"class<`data.frame`, `data.table`>",1
+mlr3misc,cross_join,0,0,0,list<integer[] | character[]>,1
+mlr3misc,cross_join,1,0,0,logical,1
+mlr3misc,cross_join,2,0,0,logical,1
+mlr3misc,dictionary_get,-1,0,0,"class<`Item`, `R6`>",1
+mlr3misc,dictionary_get,0,0,0,"class<`Dictionary`, `R6`>",1
+mlr3misc,dictionary_get,1,0,0,character,1
+mlr3misc,dictionary_get,2,0,0,...,1
+mlr3misc,dictionary_initialize_item,-1,0,0,"class<`Item`, `R6`>",1
+mlr3misc,dictionary_initialize_item,0,0,0,any,1
+mlr3misc,dictionary_initialize_item,1,0,0,list<class<`R6ClassGenerator`> | character[] | list<any>>,1
+mlr3misc,dictionary_initialize_item,2,0,0,list<any>,1
+mlr3misc,dictionary_retrieve_item,-1,0,0,list<class<`R6ClassGenerator`> | character[] | list<any>>,1
+mlr3misc,dictionary_retrieve_item,0,0,0,"class<`Dictionary`, `R6`>",1
+mlr3misc,dictionary_retrieve_item,1,0,0,character,1
+mlr3misc,dictionary_sugar_get,-1,0,0,"class<`Item`, `R6`>",1
+mlr3misc,dictionary_sugar_get,0,0,0,"class<`Dictionary`, `R6`>",1
+mlr3misc,dictionary_sugar_get,1,0,0,character,1
+mlr3misc,dictionary_sugar_get,2,0,0,...,1
+mlr3misc,did_you_mean,-1,0,0,character,1
+mlr3misc,did_you_mean,0,0,0,character,1
+mlr3misc,did_you_mean,1,0,0,character[],1
+mlr3misc,distinct_values,-1,0,0,^character[],1
+mlr3misc,distinct_values,-1,0,1,integer[],1
+mlr3misc,distinct_values,0,0,0,class<`factor`>,1
+mlr3misc,distinct_values,0,0,1,integer[],1
+mlr3misc,distinct_values,1,0,0,logical,1
+mlr3misc,distinct_values,2,0,0,logical,1
+mlr3misc,distinct_values.default,-1,0,0,integer[],1
+mlr3misc,distinct_values.default,0,0,0,integer[],1
+mlr3misc,distinct_values.default,1,0,0,logical,1
+mlr3misc,distinct_values.default,2,0,0,logical,1
+mlr3misc,distinct_values.factor,-1,0,0,^character[],1
+mlr3misc,distinct_values.factor,0,0,0,class<`factor`>,1
+mlr3misc,distinct_values.factor,1,0,0,logical,1
+mlr3misc,distinct_values.factor,2,0,0,logical,1
+mlr3misc,distinct_values.logical,-1,0,0,logical[],1
+mlr3misc,distinct_values.logical,0,0,0,logical,1
+mlr3misc,distinct_values.logical,1,0,0,logical,1
+mlr3misc,distinct_values.logical,2,0,0,logical,1
+mlr3misc,encapsulate,-1,0,0,"list<double | class<`data.frame`, `data.table`>>",1
+mlr3misc,encapsulate,0,0,0,character,1
+mlr3misc,encapsulate,1,0,0,class<`function`>,1
+mlr3misc,encapsulate,2,0,0,list<double>,1
+mlr3misc,encapsulate,3,0,0,list<any>,1
+mlr3misc,encapsulate,4,0,0,character[],1
+mlr3misc,encapsulate,5,0,0,double,1
+mlr3misc,enframe,-1,0,0,"class<`data.frame`, `data.table`>",1
+mlr3misc,enframe,0,0,0,integer[],1
+mlr3misc,enframe,1,0,0,character,1
+mlr3misc,enframe,2,0,0,character,1
+mlr3misc,extract_vars,-1,0,0,list<character[]>,1
+mlr3misc,extract_vars,0,0,0,class<`formula`>,1
+mlr3misc,formulate,-1,0,0,class<`formula`>,1
+mlr3misc,formulate,0,0,0,character,1
+mlr3misc,formulate,0,0,1,null,1
+mlr3misc,formulate,1,0,0,character[],1
+mlr3misc,formulate,2,0,0,null,1
+mlr3misc,get_constructor_formals,-1,0,0,character[],1
+mlr3misc,get_constructor_formals,0,0,0,class<`R6ClassGenerator`>,1
+mlr3misc,get_seed,-1,0,0,integer[],1
+mlr3misc,has_element,-1,0,0,logical,1
+mlr3misc,has_element,0,0,0,list<double>,1
+mlr3misc,has_element,1,0,0,double,1
+mlr3misc,ids,-1,0,0,character[],1
+mlr3misc,ids,0,0,0,list<list<character | double>>,1
+mlr3misc,insert_named,-1,0,0,list<any>,1
+mlr3misc,insert_named,0,0,0,list<any>,1
+mlr3misc,insert_named,1,0,0,list<any>,1
+mlr3misc,insert_named.default,-1,0,0,list<double>,1
+mlr3misc,insert_named.default,0,0,0,list<double>,1
+mlr3misc,insert_named.default,1,0,0,list<double>,1
+mlr3misc,invoke,-1,0,0,"class<`data.frame`, `data.table`>",1
+mlr3misc,invoke,-1,0,1,double,1
+mlr3misc,invoke,0,0,0,any,1
+mlr3misc,invoke,1,0,0,...,1
+mlr3misc,invoke,2,0,0,list<integer[] | character[]>,1
+mlr3misc,invoke,2,0,1,list<integer[]>,1
+mlr3misc,invoke,2,0,2,list<double>,1
+mlr3misc,invoke,3,0,0,list<any>,1
+mlr3misc,invoke,4,0,0,null,1
+mlr3misc,invoke,4,0,1,double,1
+mlr3misc,keep_in_bounds,-1,0,0,integer[],1
+mlr3misc,keep_in_bounds,0,0,0,integer[],1
+mlr3misc,keep_in_bounds,1,0,0,double,1
+mlr3misc,keep_in_bounds,2,0,0,double,1
+mlr3misc,load_dataset,-1,0,0,class<`data.frame`>,1
+mlr3misc,load_dataset,0,0,0,character,1
+mlr3misc,load_dataset,1,0,0,character,1
+mlr3misc,load_dataset,2,0,0,logical,1
+mlr3misc,map,-1,0,0,list<character[]>,1
+mlr3misc,map,-1,0,1,list<list<character>>,1
+mlr3misc,map,-1,0,2,list<double[]>,1
+mlr3misc,map,0,0,0,list<character[]>,1
+mlr3misc,map,0,0,1,"list<class<`condition`, `message`, `simpleMessage`>>",1
+mlr3misc,map,0,0,2,class<`data.frame`>,1
+mlr3misc,map,1,0,0,class<`function`>,1
+mlr3misc,map,2,0,0,...,1
+mlr3misc,map_chr,-1,0,0,character[],1
+mlr3misc,map_chr,0,0,0,character[],1
+mlr3misc,map_chr,0,0,1,list<class<`formula`>>,1
+mlr3misc,map_chr,1,0,0,class<`function`>,1
+mlr3misc,map_chr,2,0,0,...,1
+mlr3misc,map_dtr,-1,0,0,"class<`data.frame`, `data.table`>",1
+mlr3misc,map_dtr,0,0,0,"list<class<`condition`, `message`, `simpleMessage`>>",1
+mlr3misc,map_dtr,1,0,0,class<`function`>,1
+mlr3misc,map_dtr,2,0,0,...,1
+mlr3misc,map_dtr,3,0,0,logical,1
+mlr3misc,map_dtr,4,0,0,null,1
+mlr3misc,map_int,-1,0,0,integer[],1
+mlr3misc,map_int,0,0,0,list<character[]>,1
+mlr3misc,map_int,1,0,0,class<`function`>,1
+mlr3misc,map_int,2,0,0,...,1
+mlr3misc,map_lgl,-1,0,0,logical[],1
+mlr3misc,map_lgl,0,0,0,character[],1
+mlr3misc,map_lgl,0,0,1,list<double>,1
+mlr3misc,map_lgl,0,0,2,class<`data.frame`>,1
+mlr3misc,map_lgl,1,0,0,class<`function`>,1
+mlr3misc,map_lgl,2,0,0,...,1
+mlr3misc,map_mold,-1,0,0,character[],1
+mlr3misc,map_mold,-1,0,1,integer[],1
+mlr3misc,map_mold,0,0,0,character[],1
+mlr3misc,map_mold,0,0,1,list<class<`formula`>>,1
+mlr3misc,map_mold,0,0,2,list<character[]>,1
+mlr3misc,map_mold,0,0,3,list<double>,1
+mlr3misc,map_mold,0,0,4,class<`data.frame`>,1
+mlr3misc,map_mold,1,0,0,class<`function`>,1
+mlr3misc,map_mold,2,0,0,null,1
+mlr3misc,map_mold,3,0,0,...,1
+mlr3misc,map_values,-1,0,0,character[],1
+mlr3misc,map_values,0,0,0,character[],1
+mlr3misc,map_values,1,0,0,character[],1
+mlr3misc,map_values,2,0,0,character[],1
+mlr3misc,messagef,-1,0,0,null,1
+mlr3misc,messagef,0,0,0,character,1
+mlr3misc,messagef,1,0,0,...,1
+mlr3misc,messagef,2,0,0,double,1
+mlr3misc,modify_at,-1,0,0,class<`data.frame`>,1
+mlr3misc,modify_at,0,0,0,class<`data.frame`>,1
+mlr3misc,modify_at,1,0,0,character,1
+mlr3misc,modify_at,1,0,1,double,1
+mlr3misc,modify_at,2,0,0,class<`function`>,1
+mlr3misc,modify_at,3,0,0,...,1
+mlr3misc,modify_at.default,-1,0,0,class<`data.frame`>,1
+mlr3misc,modify_at.default,0,0,0,class<`data.frame`>,1
+mlr3misc,modify_at.default,1,0,0,character,1
+mlr3misc,modify_at.default,1,0,1,double,1
+mlr3misc,modify_at.default,2,0,0,class<`function`>,1
+mlr3misc,modify_at.default,3,0,0,...,1
+mlr3misc,modify_if,-1,0,0,class<`data.frame`>,1
+mlr3misc,modify_if,0,0,0,class<`data.frame`>,1
+mlr3misc,modify_if,1,0,0,class<`function`>,1
+mlr3misc,modify_if,2,0,0,class<`function`>,1
+mlr3misc,modify_if,3,0,0,...,1
+mlr3misc,modify_if.default,-1,0,0,class<`data.frame`>,1
+mlr3misc,modify_if.default,0,0,0,class<`data.frame`>,1
+mlr3misc,modify_if.default,1,0,0,class<`function`>,1
+mlr3misc,modify_if.default,2,0,0,class<`function`>,1
+mlr3misc,modify_if.default,3,0,0,...,1
+mlr3misc,named_list,-1,0,0,list<double>,1
+mlr3misc,named_list,-1,0,1,list<null>,1
+mlr3misc,named_list,0,0,0,character[],1
+mlr3misc,named_list,1,0,0,double,1
+mlr3misc,named_list,1,0,1,null,1
+mlr3misc,named_vector,-1,0,0,^logical[],1
+mlr3misc,named_vector,0,0,0,character[],1
+mlr3misc,named_vector,1,0,0,null,1
+mlr3misc,names2,-1,0,0,^character[],1
+mlr3misc,names2,0,0,0,integer[],1
+mlr3misc,names2,0,0,1,character[],1
+mlr3misc,names2,0,0,2,list<any>,1
+mlr3misc,names2,1,0,0,null,1
+mlr3misc,names2,1,0,1,character,1
+mlr3misc,%nin%,-1,0,0,logical[],1
+mlr3misc,%nin%,0,0,0,character[],1
+mlr3misc,%nin%,1,0,0,null,1
+mlr3misc,%nin%,1,0,1,character,1
+mlr3misc,parse_callr,-1,0,0,"class<`data.frame`, `data.table`>",1
+mlr3misc,parse_callr,0,0,0,character,1
+mlr3misc,parse_evaluate,-1,0,0,"class<`data.frame`, `data.table`>",1
+mlr3misc,parse_evaluate,0,0,0,"list<class<`source`> | class<`condition`, `message`, `simpleMessage`>>",1
+mlr3misc,probe,-1,0,0,logical[],1
+mlr3misc,probe,0,0,0,class<`data.frame`>,1
+mlr3misc,probe,1,0,0,class<`function`>,1
+mlr3misc,probe,2,0,0,...,1
+mlr3misc,rbindlist2,-1,0,0,"class<`data.frame`, `data.table`>",1
+mlr3misc,rbindlist2,0,0,0,list<list<double>>,1
+mlr3misc,rcbind,-1,0,0,"class<`data.frame`, `data.table`>",1
+mlr3misc,rcbind,0,0,0,"class<`data.frame`, `data.table`>",1
+mlr3misc,rcbind,1,0,0,"class<`data.frame`, `data.table`>",1
+mlr3misc,remove_named,-1,0,0,"class<`data.frame`, `data.table`>",1
+mlr3misc,remove_named,-1,0,1,list<double>,1
+mlr3misc,remove_named,0,0,0,"class<`data.frame`, `data.table`>",1
+mlr3misc,remove_named,0,0,1,list<double>,1
+mlr3misc,remove_named,1,0,0,character,1
+mlr3misc,remove_named.data.table,-1,0,0,"class<`data.frame`, `data.table`>",1
+mlr3misc,remove_named.data.table,0,0,0,"class<`data.frame`, `data.table`>",1
+mlr3misc,remove_named.data.table,1,0,0,character,1
+mlr3misc,remove_named.default,-1,0,0,list<double>,1
+mlr3misc,remove_named.default,0,0,0,list<double>,1
+mlr3misc,remove_named.default,1,0,0,character,1
+mlr3misc,require_namespaces,-1,0,0,any,1
+mlr3misc,require_namespaces,0,0,0,character[],1
+mlr3misc,require_namespaces,1,0,0,character,1
+mlr3misc,rowwise_table,-1,0,0,"class<`data.frame`, `data.table`>",1
+mlr3misc,rowwise_table,0,0,0,...,1
+mlr3misc,rowwise_table,1,0,0,null,1
+mlr3misc,seq_len0,-1,0,0,integer[],1
+mlr3misc,seq_len0,0,0,0,double,1
+mlr3misc,set_class,-1,0,0,"class<`foo1`, `foo2`>",1
+mlr3misc,set_class,0,0,0,list<any>,1
+mlr3misc,set_class,1,0,0,character[],1
+mlr3misc,set_names,-1,0,0,character[],1
+mlr3misc,set_names,-1,0,1,double[],1
+mlr3misc,set_names,-1,0,2,^logical[],1
+mlr3misc,set_names,-1,0,3,"list<class<`Item`, `R6`>>",1
+mlr3misc,set_names,0,0,0,character[],1
+mlr3misc,set_names,0,0,1,double[],1
+mlr3misc,set_names,0,0,2,^logical[],1
+mlr3misc,set_names,0,0,3,"list<class<`Item`, `R6`>>",1
+mlr3misc,set_names,1,0,0,character[],1
+mlr3misc,set_names,1,0,1,class<`function`>,1
+mlr3misc,set_names,2,0,0,...,1
+mlr3misc,shuffle,-1,0,0,double,1
+mlr3misc,shuffle,-1,0,1,integer[],1
+mlr3misc,shuffle,0,0,0,double,1
+mlr3misc,shuffle,0,0,1,integer[],1
+mlr3misc,shuffle,1,0,0,integer,1
+mlr3misc,shuffle,2,0,0,...,1
+mlr3misc,str_collapse,-1,0,0,character,1
+mlr3misc,str_collapse,0,0,0,character[],1
+mlr3misc,str_collapse,1,0,0,character,1
+mlr3misc,str_collapse,2,0,0,character,1
+mlr3misc,str_collapse,3,0,0,double,1
+mlr3misc,str_collapse,4,0,0,character,1
+mlr3misc,str_indent,-1,0,0,character[],1
+mlr3misc,str_indent,0,0,0,character,1
+mlr3misc,str_indent,1,0,0,character,1
+mlr3misc,str_indent,2,0,0,double,1
+mlr3misc,str_indent,3,0,0,integer,1
+mlr3misc,str_indent,4,0,0,...,1
+mlr3misc,str_trunc,-1,0,0,character,1
+mlr3misc,str_trunc,0,0,0,character,1
+mlr3misc,str_trunc,1,0,0,double,1
+mlr3misc,str_trunc,2,0,0,character,1
+mlr3misc,str_wrap,-1,0,0,character,1
+mlr3misc,str_wrap,0,0,0,character,1
+mlr3misc,str_wrap,1,0,0,double,1
+mlr3misc,topo_sort,-1,0,0,"class<`data.frame`, `data.table`>",1
+mlr3misc,topo_sort,0,0,0,"class<`data.frame`, `data.table`>",1
+mlr3misc,transpose_list,-1,0,0,list<list<double | class<`factor`>>>,1
+mlr3misc,transpose_list,-1,0,1,list<list<double>>,1
+mlr3misc,transpose_list,0,0,0,class<`data.frame`>,1
+mlr3misc,transpose_list,0,0,1,list<list<double>>,1
+mlr3misc,unnest,-1,0,0,"class<`data.frame`, `data.table`>",1
+mlr3misc,unnest,0,0,0,"class<`data.frame`, `data.table`>",1
+mlr3misc,unnest,1,0,0,character,1
+mlr3misc,unnest,2,0,0,null,1
+mlr3misc,which_max,-1,0,0,integer[],1
+mlr3misc,which_max,-1,0,1,null,1
+mlr3misc,which_max,0,0,0,^double[],1
+mlr3misc,which_max,0,0,1,null,1
+mlr3misc,which_max,1,0,0,character,1
+mlr3misc,which_max,2,0,0,logical,1
+mlr3misc,which_min,-1,0,0,integer,1
+mlr3misc,which_min,0,0,0,double[],1
+mlr3misc,which_min,1,0,0,character,1
+mlr3misc,which_min,2,0,0,logical,1
+mlt,as.Surv,-1,0,0,class<`Surv`>,1
+mlt,as.Surv,0,0,0,"class<`data.frame`, `response`>",1
+mlt,as.Surv.response,-1,0,0,class<`Surv`>,1
+mlt,as.Surv.response,0,0,0,"class<`data.frame`, `response`>",1
+mlt,as.vars.ctm,-1,0,0,class<`vars`>,1
+mlt,as.vars.ctm,0,0,0,class<`ctm`>,1
+mlt,bounds.ctm,-1,0,0,"list<class<`factor`, `ordered`> | double[]>",1
+mlt,bounds.ctm,-1,0,1,list<double[] | null>,1
+mlt,bounds.ctm,-1,0,2,list<double[]>,1
+mlt,bounds.ctm,0,0,0,class<`ctm`>,1
+mlt,.checkR,-1,0,0,logical,1
+mlt,.checkR,0,0,0,"class<`data.frame`, `response`>",1
+mlt,.checkR,1,0,0,double[],1
+mlt,.checkR,1,0,1,null,1
+mlt,.cinterval,-1,0,0,logical[],1
+mlt,.cinterval,0,0,0,"class<`data.frame`, `response`>",1
+mlt,.cleft,-1,0,0,logical[],1
+mlt,.cleft,0,0,0,"class<`data.frame`, `response`>",1
+mlt,coef<-,-1,0,0,class<`ctm`>,1
+mlt,coef<-,-1,0,1,"class<`mlt`, `mlt_setup`>",1
+mlt,coef<-,0,0,0,class<`ctm`>,1
+mlt,coef<-,0,0,1,"class<`mlt`, `mlt_setup`>",1
+mlt,coef<-,1,0,0,double[],1
+mlt,coef<-.ctm,-1,0,0,class<`ctm`>,1
+mlt,coef<-.ctm,0,0,0,class<`ctm`>,1
+mlt,coef<-.ctm,1,0,0,double[],1
+mlt,coef.ctm,-1,0,0,^double[],1
+mlt,coef.ctm,0,0,0,class<`ctm`>,1
+mlt,coef.ctm,1,0,0,...,1
+mlt,coef<-.mlt,-1,0,0,"class<`mlt`, `mlt_setup`>",1
+mlt,coef<-.mlt,0,0,0,"class<`mlt`, `mlt_setup`>",1
+mlt,coef<-.mlt,1,0,0,double[],1
+mlt,coef.mlt,-1,0,0,double[],1
+mlt,coef.mlt,-1,0,1,^logical[],1
+mlt,coef.mlt,0,0,0,"class<`mlt`, `mlt_fit`, `mlt_setup`>",1
+mlt,coef.mlt,0,0,1,"class<`mlt`, `mlt_setup`>",1
+mlt,coef.mlt,1,0,0,logical,1
+mlt,coef.mlt,2,0,0,...,1
+mlt,.cright,-1,0,0,logical[],1
+mlt,.cright,0,0,0,"class<`data.frame`, `response`>",1
+mlt,ctm,-1,0,0,class<`ctm`>,1
+mlt,ctm,0,0,0,"class<`basis`, `formula_basis`, `function`>",1
+mlt,ctm,0,0,1,"class<`basis`, `function`, `polynomial_basis`>",1
+mlt,ctm,0,0,2,"class<`Bernstein_basis`, `basis`, `function`>",1
+mlt,ctm,0,0,3,class<`formula`>,1
+mlt,ctm,1,0,0,"class<`basis`, `formula_basis`, `function`>",1
+mlt,ctm,1,0,1,null,1
+mlt,ctm,1,0,2,"class<`Bernstein_basis`, `basis`, `function`>",1
+mlt,ctm,1,0,3,"class<`bases`, `box_bases`>",1
+mlt,ctm,1,0,4,"class<`bases`, `cbind_bases`>",1
+mlt,ctm,2,0,0,null,1
+mlt,ctm,2,0,1,"class<`basis`, `formula_basis`, `function`>",1
+mlt,ctm,2,0,2,"class<`basis`, `function`, `intercept_basis`>",1
+mlt,ctm,2,0,3,class<`formula`>,1
+mlt,ctm,2,0,4,"class<`Bernstein_basis`, `basis`, `function`>",1
+mlt,ctm,3,0,0,null,1
+mlt,ctm,3,0,1,class<`data.frame`>,1
+mlt,ctm,4,0,0,character[],1
+mlt,ctm,5,0,0,any,1
+mlt,ctm,6,0,0,...,1
+mlt,.dealinf,-1,0,0,class<`matrix`>,1
+mlt,.dealinf,-1,0,1,double[],1
+mlt,.dealinf,0,0,0,class<`matrix`>,1
+mlt,.dealinf,1,0,0,any,1
+mlt,.dealinf,2,0,0,any,1
+mlt,.dealinf,3,0,0,any,1
+mlt,.dealinf,4,0,0,double,1
+mlt,.dealinf,5,0,0,any,1
+mlt,description,-1,0,0,character,1
+mlt,description,0,0,0,"class<`mlt`, `mlt_fit`, `mlt_setup`>",1
+mlt,.distr,-1,0,0,list<class<`function`> | character>,1
+mlt,.distr,0,0,0,character[],1
+mlt,dmlt,-1,0,0,class<`array`>,1
+mlt,dmlt,-1,0,1,class<`matrix`>,1
+mlt,dmlt,0,0,0,class<`ctm`>,1
+mlt,dmlt,1,0,0,"list<class<`factor`, `ordered`> | integer[]>",1
+mlt,dmlt,1,0,1,list<double[] | class<`factor`>>,1
+mlt,dmlt,1,0,2,class<`data.frame`>,1
+mlt,dmlt,2,0,0,null,1
+mlt,dmlt,2,0,1,"class<`factor`, `ordered`>",1
+mlt,dmlt,3,0,0,logical,1
+mlt,dmlt,4,0,0,...,1
+mlt,estfun.mlt,-1,0,0,class<`matrix`>,1
+mlt,estfun.mlt,0,0,0,"class<`mlt`, `mlt_fit`, `mlt_setup`>",1
+mlt,estfun.mlt,1,0,0,class<`matrix`>,1
+mlt,estfun.mlt,1,0,1,double[],1
+mlt,estfun.mlt,2,0,0,null,1
+mlt,estfun.mlt,3,0,0,any,1
+mlt,estfun.mlt,4,0,0,...,1
+mlt,.exact,-1,0,0,logical[],1
+mlt,.exact,0,0,0,"class<`data.frame`, `response`>",1
+mlt,.exact_subset,-1,0,0,list<integer[]>,1
+mlt,.exact_subset,-1,0,1,list<integer[] | null>,1
+mlt,.exact_subset,-1,0,2,list<null | integer[]>,1
+mlt,.exact_subset,0,0,0,logical[],1
+mlt,.exact_subset,1,0,0,null,1
+mlt,.exact_subset,1,0,1,integer[],1
+mlt,.frmt,-1,0,0,character[],1
+mlt,.frmt,0,0,0,"class<`factor`, `ordered`>",1
+mlt,.frmt,0,0,1,double[],1
+mlt,.frmt,0,0,2,class<`factor`>,1
+mlt,Hessian,-1,0,0,class<`matrix`>,1
+mlt,Hessian,0,0,0,"class<`mlt`, `mlt_fit`, `mlt_setup`>",1
+mlt,Hessian,1,0,0,...,1
+mlt,Hessian.mlt,-1,0,0,class<`matrix`>,1
+mlt,Hessian.mlt,0,0,0,"class<`mlt`, `mlt_fit`, `mlt_setup`>",1
+mlt,Hessian.mlt,1,0,0,double[],1
+mlt,Hessian.mlt,2,0,0,...,1
+mlt,.is.formula,-1,0,0,logical,1
+mlt,.is.formula,0,0,0,"class<`bases`, `box_bases`>",1
+mlt,.is.formula,0,0,1,"class<`bases`, `cbind_bases`>",1
+mlt,.is.formula,0,0,2,"class<`basis`, `formula_basis`, `function`>",1
+mlt,.is.formula,0,0,3,"class<`basis`, `function`, `intercept_basis`>",1
+mlt,.is.formula,0,0,4,"class<`basis`, `function`, `polynomial_basis`>",1
+mlt,.is.formula,0,0,5,"class<`Bernstein_basis`, `basis`, `function`>",1
+mlt,.is.formula,0,0,6,class<`formula`>,1
+mlt,.is.formula,0,0,7,null,1
+mlt,.is.R,-1,0,0,logical,1
+mlt,.is.R,0,0,0,"class<`data.frame`, `response`>",1
+mlt,.is.R,0,0,1,"class<`factor`, `ordered`>",1
+mlt,.is.R,0,0,2,double[],1
+mlt,.is.Surv,-1,0,0,logical,1
+mlt,.is.Surv,0,0,0,"class<`factor`, `ordered`>",1
+mlt,.is.Surv,0,0,1,double[],1
+mlt,.log,-1,0,0,double[],1
+mlt,.log,0,0,0,class<`matrix`>,1
+mlt,.log,0,0,1,double[],1
+mlt,.Logistic,-1,0,0,list<class<`function`> | character>,1
+mlt,logLik.mlt,-1,0,0,class<`logLik`>,1
+mlt,logLik.mlt,0,0,0,"class<`mlt`, `mlt_fit`, `mlt_setup`>",1
+mlt,logLik.mlt,1,0,0,class<`matrix`>,1
+mlt,logLik.mlt,1,0,1,double[],1
+mlt,logLik.mlt,2,0,0,null,1
+mlt,logLik.mlt,3,0,0,any,1
+mlt,logLik.mlt,4,0,0,...,1
+mlt,.MaxExtrVal,-1,0,0,list<class<`function`> | character>,1
+mlt,.MinExtrVal,-1,0,0,list<class<`function`> | character>,1
+mlt,mkgrid.ctm,-1,0,0,list<double[]>,1
+mlt,mkgrid.ctm,-1,0,1,"list<class<`factor`, `ordered`> | class<`factor`>>",1
+mlt,mkgrid.ctm,-1,0,2,"list<class<`factor`, `ordered`> | double[]>",1
+mlt,mkgrid.ctm,-1,0,3,"list<class<`factor`, `ordered`> | double>",1
+mlt,mkgrid.ctm,-1,0,4,"list<class<`factor`, `ordered`> | integer[] | double>",1
+mlt,mkgrid.ctm,-1,0,5,list<class<`factor`> | double>,1
+mlt,mkgrid.ctm,-1,0,6,list<double[] | class<`factor`>>,1
+mlt,mkgrid.ctm,-1,0,7,list<double | class<`factor`>>,1
+mlt,mkgrid.ctm,-1,0,8,list<double | integer[]>,1
+mlt,mkgrid.ctm,0,0,0,class<`ctm`>,1
+mlt,mkgrid.ctm,1,0,0,double,1
+mlt,mkgrid.ctm,2,0,0,...,1
+mlt,mkgrid.mlt,-1,0,0,list<double[] | class<`factor`>>,1
+mlt,mkgrid.mlt,-1,0,1,list<double[]>,1
+mlt,mkgrid.mlt,0,0,0,"class<`mlt`, `mlt_setup`>",1
+mlt,mkgrid.mlt,0,0,1,"class<`mlt`, `mlt_fit`, `mlt_setup`>",1
+mlt,mkgrid.mlt,1,0,0,double,1
+mlt,mkgrid.mlt,2,0,0,...,1
+mlt,.mkR,-1,0,0,"class<`data.frame`, `response`>",1
+mlt,.mkR,0,0,0,...,1
+mlt,mlt,-1,0,0,"class<`mlt`, `mlt_fit`, `mlt_setup`>",1
+mlt,mlt,-1,0,1,"class<`mlt`, `mlt_setup`>",1
+mlt,mlt,0,0,0,class<`ctm`>,1
+mlt,mlt,1,0,0,class<`data.frame`>,1
+mlt,mlt,2,0,0,null,1
+mlt,mlt,2,0,1,double[],1
+mlt,mlt,3,0,0,null,1
+mlt,mlt,3,0,1,double[],1
+mlt,mlt,4,0,0,null,1
+mlt,mlt,4,0,1,double[],1
+mlt,mlt,5,0,0,null,1
+mlt,mlt,5,0,1,double[],1
+mlt,mlt,6,0,0,null,1
+mlt,mlt,7,0,0,logical,1
+mlt,.mlt_fit,-1,0,0,"class<`mlt`, `mlt_fit`, `mlt_setup`>",1
+mlt,.mlt_fit,0,0,0,"class<`mlt`, `mlt_setup`>",1
+mlt,.mlt_fit,1,0,0,double[],1
+mlt,.mlt_fit,2,0,0,integer[],1
+mlt,.mlt_fit,2,0,1,null,1
+mlt,.mlt_fit,3,0,0,double[],1
+mlt,.mlt_fit,4,0,0,double[],1
+mlt,.mlt_fit,5,0,0,logical,1
+mlt,.mlt_fit,6,0,0,list<class<`function`>>,1
+mlt,.mlt_fit,7,0,0,...,1
+mlt,.mlt_hessian_exact,-1,0,0,class<`matrix`>,1
+mlt,.mlt_hessian_exact,0,0,0,double[],1
+mlt,.mlt_hessian_exact,-1,1,0,class<`function`>,1
+mlt,.mlt_hessian_exact,0,1,0,any,1
+mlt,.mlt_hessian_exact,1,1,0,any,1
+mlt,.mlt_hessian_exact,2,1,0,any,1
+mlt,.mlt_hessian_exact,3,1,0,any,1
+mlt,.mlt_hessian_exact,4,1,0,any,1
+mlt,.mlt_hessian_exact,5,1,0,any,1
+mlt,..mlt_hessian_interval,-1,0,0,class<`matrix`>,1
+mlt,..mlt_hessian_interval,0,0,0,list<class<`function`> | character>,1
+mlt,..mlt_hessian_interval,1,0,0,class<`matrix`>,1
+mlt,..mlt_hessian_interval,2,0,0,class<`matrix`>,1
+mlt,..mlt_hessian_interval,3,0,0,double[],1
+mlt,..mlt_hessian_interval,4,0,0,double[],1
+mlt,..mlt_hessian_interval,5,0,0,double[],1
+mlt,.mlt_hessian_interval,-1,0,0,class<`matrix`>,1
+mlt,.mlt_hessian_interval,0,0,0,double[],1
+mlt,.mlt_hessian_interval,-1,1,0,class<`function`>,1
+mlt,.mlt_hessian_interval,0,1,0,any,1
+mlt,.mlt_hessian_interval,1,1,0,any,1
+mlt,.mlt_hessian_interval,2,1,0,any,1
+mlt,.mlt_hessian_interval,3,1,0,any,1
+mlt,.mlt_hessian_interval,4,1,0,null,1
+mlt,.mlt_hessian_interval,4,1,1,list<class<`matrix`>>,1
+mlt,.mlt_hessian_interval,5,1,0,any,1
+mlt,.mlt_hessian_interval,-1,2,0,class<`matrix`>,1
+mlt,.mlt_hessian_interval,0,2,0,double[],1
+mlt,.mlt_loglik_exact,-1,0,0,class<`function`>,1
+mlt,.mlt_loglik_exact,0,0,0,any,1
+mlt,.mlt_loglik_exact,1,0,0,any,1
+mlt,.mlt_loglik_exact,2,0,0,any,1
+mlt,.mlt_loglik_exact,3,0,0,any,1
+mlt,.mlt_loglik_exact,4,0,0,null,1
+mlt,.mlt_loglik_exact,4,0,1,list<class<`matrix`>>,1
+mlt,.mlt_loglik_exact,-1,1,0,class<`matrix`>,1
+mlt,.mlt_loglik_exact,0,1,0,double[],1
+mlt,.mlt_loglik_exact,-1,2,0,class<`matrix`>,1
+mlt,.mlt_loglik_exact,-1,2,1,double[],1
+mlt,.mlt_loglik_exact,0,2,0,double[],1
+mlt,.mlt_loglik_exact,0,2,1,class<`matrix`>,1
+mlt,..mlt_loglik_interval,-1,0,0,double[],1
+mlt,..mlt_loglik_interval,0,0,0,list<class<`function`> | character>,1
+mlt,..mlt_loglik_interval,1,0,0,class<`matrix`>,1
+mlt,..mlt_loglik_interval,2,0,0,class<`matrix`>,1
+mlt,..mlt_loglik_interval,3,0,0,double[],1
+mlt,..mlt_loglik_interval,4,0,0,double[],1
+mlt,.mlt_loglik_interval,-1,0,0,double[],1
+mlt,.mlt_loglik_interval,0,0,0,double[],1
+mlt,.mlt_loglik_interval,-1,1,0,class<`function`>,1
+mlt,.mlt_loglik_interval,0,1,0,any,1
+mlt,.mlt_loglik_interval,1,1,0,any,1
+mlt,.mlt_loglik_interval,2,1,0,any,1
+mlt,.mlt_loglik_interval,3,1,0,any,1
+mlt,.mlt_loglik_interval,4,1,0,null,1
+mlt,.mlt_loglik_interval,4,1,1,list<class<`matrix`>>,1
+mlt,.mlt_loglik_interval,-1,2,0,double[],1
+mlt,.mlt_loglik_interval,0,2,0,double[],1
+mlt,mltoptim,-1,0,0,list<class<`function`>>,1
+mlt,mltoptim,0,0,0,list<double>,1
+mlt,mltoptim,1,0,0,list<double>,1
+mlt,mltoptim,2,0,0,null,1
+mlt,mltoptim,3,0,0,logical,1
+mlt,.mlt_score_exact,-1,0,0,class<`matrix`>,1
+mlt,.mlt_score_exact,0,0,0,double[],1
+mlt,.mlt_score_exact,0,0,1,class<`matrix`>,1
+mlt,.mlt_score_exact,1,0,0,logical,1
+mlt,.mlt_score_exact,-1,1,0,class<`function`>,1
+mlt,.mlt_score_exact,0,1,0,any,1
+mlt,.mlt_score_exact,1,1,0,any,1
+mlt,.mlt_score_exact,2,1,0,any,1
+mlt,.mlt_score_exact,3,1,0,any,1
+mlt,.mlt_score_exact,4,1,0,any,1
+mlt,..mlt_score_interval,-1,0,0,class<`matrix`>,1
+mlt,..mlt_score_interval,0,0,0,list<class<`function`> | character>,1
+mlt,..mlt_score_interval,1,0,0,class<`matrix`>,1
+mlt,..mlt_score_interval,2,0,0,class<`matrix`>,1
+mlt,..mlt_score_interval,3,0,0,double[],1
+mlt,..mlt_score_interval,4,0,0,double[],1
+mlt,..mlt_score_interval,5,0,0,logical,1
+mlt,.mlt_score_interval,-1,0,0,class<`function`>,1
+mlt,.mlt_score_interval,0,0,0,any,1
+mlt,.mlt_score_interval,1,0,0,any,1
+mlt,.mlt_score_interval,2,0,0,any,1
+mlt,.mlt_score_interval,3,0,0,any,1
+mlt,.mlt_score_interval,4,0,0,null,1
+mlt,.mlt_score_interval,4,0,1,list<class<`matrix`>>,1
+mlt,.mlt_score_interval,-1,1,0,class<`matrix`>,1
+mlt,.mlt_score_interval,0,1,0,double[],1
+mlt,.mlt_score_interval,1,1,0,logical,1
+mlt,.mlt_score_interval,-1,2,0,class<`matrix`>,1
+mlt,.mlt_score_interval,0,2,0,double[],1
+mlt,.mlt_score_interval,1,2,0,logical,1
+mlt,.mlt_setup,-1,0,0,"class<`mlt`, `mlt_setup`>",1
+mlt,.mlt_setup,0,0,0,class<`ctm`>,1
+mlt,.mlt_setup,1,0,0,class<`data.frame`>,1
+mlt,.mlt_setup,2,0,0,"class<`data.frame`, `response`>",1
+mlt,.mlt_setup,3,0,0,double[],1
+mlt,.mlt_setup,4,0,0,double[],1
+mlt,.mlt_setup,4,0,1,null,1
+mlt,.mlt_start,-1,0,0,double[],1
+mlt,.mlt_start,0,0,0,class<`ctm`>,1
+mlt,.mlt_start,1,0,0,class<`data.frame`>,1
+mlt,.mlt_start,2,0,0,"class<`data.frame`, `response`>",1
+mlt,.mlt_start,3,0,0,double[],1
+mlt,.mlt_start,4,0,0,any,1
+mlt,.mlt_start,5,0,0,null,1
+mlt,.mlt_start,5,0,1,double[],1
+mlt,.mlt_start,6,0,0,double[],1
+mlt,.mm_exact,-1,0,0,null,1
+mlt,.mm_exact,-1,0,1,list<class<`matrix`> | null | integer[]>,1
+mlt,.mm_exact,-1,0,2,list<class<`matrix`> | integer[] | list<class<`matrix`>>>,1
+mlt,.mm_exact,0,0,0,any,1
+mlt,.mm_exact,1,0,0,any,1
+mlt,.mm_exact,2,0,0,any,1
+mlt,.mm_exact,3,0,0,"class<`data.frame`, `response`>",1
+mlt,.mm_interval,-1,0,0,null,1
+mlt,.mm_interval,-1,0,1,list<class<`matrix`> | null | integer[]>,1
+mlt,.mm_interval,-1,0,2,list<class<`matrix`> | integer[] | list<class<`matrix`>>>,1
+mlt,.mm_interval,0,0,0,any,1
+mlt,.mm_interval,1,0,0,any,1
+mlt,.mm_interval,2,0,0,any,1
+mlt,.mm_interval,3,0,0,"class<`data.frame`, `response`>",1
+mlt,model,-1,0,0,list<any>,1
+mlt,model,0,0,0,class<`ctm`>,1
+mlt,model,0,0,1,"class<`mlt`, `mlt_fit`, `mlt_setup`>",1
+mlt,model.ctm,-1,0,0,list<any>,1
+mlt,model.ctm,0,0,0,class<`ctm`>,1
+mlt,model.matrix.ctm,-1,0,0,class<`matrix`>,1
+mlt,model.matrix.ctm,0,0,0,class<`ctm`>,1
+mlt,model.matrix.ctm,1,0,0,class<`data.frame`>,1
+mlt,model.matrix.ctm,2,0,0,...,1
+mlt,model.mlt,-1,0,0,list<any>,1
+mlt,model.mlt,0,0,0,"class<`mlt`, `mlt_fit`, `mlt_setup`>",1
+mlt,.Normal,-1,0,0,list<class<`function`> | character>,1
+mlt,.one_factor_only,-1,0,0,logical,1
+mlt,.one_factor_only,0,0,0,"class<`Bernstein_basis`, `basis`, `function`>",1
+mlt,.p2q,-1,0,0,"class<`data.frame`, `response`>",1
+mlt,.p2q,-1,0,1,"class<`factor`, `ordered`>",1
+mlt,.p2q,-1,0,2,double[],1
+mlt,.p2q,0,0,0,class<`matrix`>,1
+mlt,.p2q,1,0,0,double[],1
+mlt,.p2q,1,0,1,"class<`factor`, `ordered`>",1
+mlt,.p2q,2,0,0,double[],1
+mlt,.p2q,3,0,0,any,1
+mlt,.p2q,4,0,0,logical,1
+mlt,.p2q,5,0,0,any,1
+mlt,plot.ctm,-1,0,0,class<`matrix`>,1
+mlt,plot.ctm,0,0,0,class<`ctm`>,1
+mlt,plot.ctm,1,0,0,class<`data.frame`>,1
+mlt,plot.ctm,2,0,0,character[],1
+mlt,plot.ctm,3,0,0,null,1
+mlt,plot.ctm,4,0,0,any,1
+mlt,plot.ctm,5,0,0,double,1
+mlt,plot.ctm,6,0,0,character,1
+mlt,plot.ctm,7,0,0,double,1
+mlt,plot.mlt,-1,0,0,class<`matrix`>,1
+mlt,plot.mlt,0,0,0,"class<`mlt`, `mlt_fit`, `mlt_setup`>",1
+mlt,plot.mlt,1,0,0,...,1
+mlt,pmlt,-1,0,0,class<`array`>,1
+mlt,pmlt,-1,0,1,class<`matrix`>,1
+mlt,pmlt,0,0,0,class<`ctm`>,1
+mlt,pmlt,1,0,0,"list<class<`factor`, `ordered`> | integer[]>",1
+mlt,pmlt,1,0,1,list<double[] | class<`factor`>>,1
+mlt,pmlt,1,0,2,list<double[]>,1
+mlt,pmlt,1,0,3,class<`data.frame`>,1
+mlt,pmlt,2,0,0,null,1
+mlt,pmlt,2,0,1,double[],1
+mlt,pmlt,2,0,2,"class<`factor`, `ordered`>",1
+mlt,pmlt,3,0,0,...,1
+mlt,predict.ctm,-1,0,0,class<`array`>,1
+mlt,predict.ctm,-1,0,1,"class<`factor`, `ordered`>",1
+mlt,predict.ctm,-1,0,2,class<`matrix`>,1
+mlt,predict.ctm,-1,0,3,double[],1
+mlt,predict.ctm,0,0,0,class<`ctm`>,1
+mlt,predict.ctm,1,0,0,list<double[]>,1
+mlt,predict.ctm,1,0,1,"list<class<`factor`, `ordered`> | integer[]>",1
+mlt,predict.ctm,1,0,2,list<double[] | class<`factor`>>,1
+mlt,predict.ctm,1,0,3,class<`data.frame`>,1
+mlt,predict.ctm,2,0,0,character[],1
+mlt,predict.ctm,3,0,0,character[],1
+mlt,predict.ctm,4,0,0,null,1
+mlt,predict.ctm,4,0,1,double[],1
+mlt,predict.ctm,4,0,2,"class<`factor`, `ordered`>",1
+mlt,predict.ctm,5,0,0,any,1
+mlt,predict.ctm,6,0,0,double,1
+mlt,predict.ctm,7,0,0,logical,1
+mlt,predict.mlt,-1,0,0,class<`array`>,1
+mlt,predict.mlt,-1,0,1,"class<`factor`, `ordered`>",1
+mlt,predict.mlt,-1,0,2,class<`matrix`>,1
+mlt,predict.mlt,-1,0,3,double[],1
+mlt,predict.mlt,0,0,0,"class<`mlt`, `mlt_fit`, `mlt_setup`>",1
+mlt,predict.mlt,0,0,1,"class<`mlt`, `mlt_setup`>",1
+mlt,predict.mlt,1,0,0,list<double[]>,1
+mlt,predict.mlt,1,0,1,"list<class<`factor`, `ordered`> | integer[]>",1
+mlt,predict.mlt,1,0,2,list<double[] | class<`factor`>>,1
+mlt,predict.mlt,1,0,3,class<`data.frame`>,1
+mlt,predict.mlt,2,0,0,...,1
+mlt,qmlt,-1,0,0,class<`array`>,1
+mlt,qmlt,-1,0,1,"class<`factor`, `ordered`>",1
+mlt,qmlt,-1,0,2,class<`matrix`>,1
+mlt,qmlt,0,0,0,class<`ctm`>,1
+mlt,qmlt,1,0,0,list<integer[]>,1
+mlt,qmlt,1,0,1,list<double[] | class<`factor`>>,1
+mlt,qmlt,1,0,2,class<`data.frame`>,1
+mlt,qmlt,2,0,0,double[],1
+mlt,qmlt,2,0,1,null,1
+mlt,qmlt,3,0,0,double[],1
+mlt,qmlt,4,0,0,any,1
+mlt,qmlt,5,0,0,any,1
+mlt,qmlt,6,0,0,...,1
+mlt,R,-1,0,0,"class<`data.frame`, `response`>",1
+mlt,R,0,0,0,any,1
+mlt,R,1,0,0,...,1
+mlt,R.factor,-1,0,0,"class<`data.frame`, `response`>",1
+mlt,R.factor,0,0,0,class<`factor`>,1
+mlt,R.factor,1,0,0,...,1
+mlt,R.list,-1,0,0,"class<`data.frame`, `response`>",1
+mlt,R.list,0,0,0,list<double[]>,1
+mlt,R.list,1,0,0,...,1
+mlt,R.logical,-1,0,0,"class<`data.frame`, `response`>",1
+mlt,R.logical,0,0,0,^double[],1
+mlt,R.logical,0,0,1,null,1
+mlt,R.logical,1,0,0,^double[],1
+mlt,R.logical,1,0,1,null,1
+mlt,R.logical,2,0,0,^double[],1
+mlt,R.logical,2,0,1,null,1
+mlt,R.logical,3,0,0,null,1
+mlt,R.logical,3,0,1,double[],1
+mlt,R.logical,4,0,0,null,1
+mlt,R.logical,4,0,1,double[],1
+mlt,R.logical,5,0,0,any,1
+mlt,R.logical,6,0,0,...,1
+mlt,R.numeric,-1,0,0,"class<`data.frame`, `response`>",1
+mlt,R.numeric,0,0,0,^double[],1
+mlt,R.numeric,0,0,1,null,1
+mlt,R.numeric,1,0,0,^double[],1
+mlt,R.numeric,1,0,1,null,1
+mlt,R.numeric,2,0,0,^double[],1
+mlt,R.numeric,2,0,1,null,1
+mlt,R.numeric,3,0,0,null,1
+mlt,R.numeric,3,0,1,double[],1
+mlt,R.numeric,4,0,0,null,1
+mlt,R.numeric,4,0,1,double[],1
+mlt,R.numeric,5,0,0,any,1
+mlt,R.numeric,6,0,0,...,1
+mlt,R.ordered,-1,0,0,"class<`data.frame`, `response`>",1
+mlt,R.ordered,0,0,0,"class<`factor`, `ordered`>",1
+mlt,R.ordered,1,0,0,null,1
+mlt,R.ordered,2,0,0,null,1
+mlt,R.ordered,3,0,0,...,1
+mlt,R.response,-1,0,0,"class<`data.frame`, `response`>",1
+mlt,R.response,0,0,0,"class<`data.frame`, `response`>",1
+mlt,R.response,1,0,0,...,1
+mlt,R.Surv,-1,0,0,"class<`data.frame`, `response`>",1
+mlt,R.Surv,0,0,0,class<`Surv`>,1
+mlt,R.Surv,1,0,0,...,1
+mlt,simulate.ctm,-1,0,0,"class<`data.frame`, `response`>",1
+mlt,simulate.ctm,-1,0,1,"list<class<`factor`, `ordered`>>",1
+mlt,simulate.ctm,-1,0,2,list<double[]>,1
+mlt,simulate.ctm,0,0,0,class<`ctm`>,1
+mlt,simulate.ctm,1,0,0,double,1
+mlt,simulate.ctm,2,0,0,double,1
+mlt,simulate.ctm,2,0,1,null,1
+mlt,simulate.ctm,3,0,0,class<`data.frame`>,1
+mlt,simulate.ctm,4,0,0,double,1
+mlt,simulate.ctm,5,0,0,null,1
+mlt,simulate.ctm,6,0,0,logical,1
+mlt,simulate.ctm,7,0,0,any,1
+mlt,simulate.mlt,-1,0,0,"class<`data.frame`, `response`>",1
+mlt,simulate.mlt,-1,0,1,"list<class<`factor`, `ordered`>>",1
+mlt,simulate.mlt,-1,0,2,list<double[]>,1
+mlt,simulate.mlt,0,0,0,"class<`mlt`, `mlt_fit`, `mlt_setup`>",1
+mlt,simulate.mlt,1,0,0,double,1
+mlt,simulate.mlt,2,0,0,double,1
+mlt,simulate.mlt,2,0,1,null,1
+mlt,simulate.mlt,3,0,0,class<`data.frame`>,1
+mlt,simulate.mlt,4,0,0,logical,1
+mlt,simulate.mlt,5,0,0,...,1
+mlt,smlt,-1,0,0,class<`matrix`>,1
+mlt,smlt,0,0,0,class<`ctm`>,1
+mlt,smlt,1,0,0,class<`data.frame`>,1
+mlt,smlt,2,0,0,double[],1
+mlt,smlt,3,0,0,...,1
+mlt,summary.mlt,-1,0,0,class<`summary.mlt`>,1
+mlt,summary.mlt,0,0,0,"class<`mlt`, `mlt_fit`, `mlt_setup`>",1
+mlt,summary.mlt,1,0,0,...,1
+mlt,.tinterval,-1,0,0,logical[],1
+mlt,.tinterval,0,0,0,"class<`data.frame`, `response`>",1
+mlt,.tleft,-1,0,0,logical[],1
+mlt,.tleft,0,0,0,"class<`data.frame`, `response`>",1
+mlt,tmlt,-1,0,0,class<`array`>,1
+mlt,tmlt,-1,0,1,class<`matrix`>,1
+mlt,tmlt,-1,0,2,double[],1
+mlt,tmlt,0,0,0,class<`ctm`>,1
+mlt,tmlt,1,0,0,list<double[]>,1
+mlt,tmlt,1,0,1,"list<class<`factor`, `ordered`> | integer[]>",1
+mlt,tmlt,1,0,2,list<double[] | class<`factor`>>,1
+mlt,tmlt,1,0,3,class<`data.frame`>,1
+mlt,tmlt,2,0,0,null,1
+mlt,tmlt,2,0,1,double[],1
+mlt,tmlt,2,0,2,"class<`factor`, `ordered`>",1
+mlt,tmlt,3,0,0,...,1
+mlt,.tright,-1,0,0,logical[],1
+mlt,.tright,0,0,0,"class<`data.frame`, `response`>",1
+mlt,.type_of_response,-1,0,0,character,1
+mlt,.type_of_response,0,0,0,"class<`factor`, `ordered`>",1
+mlt,.type_of_response,0,0,1,double[],1
+mlt,update.mlt_fit,-1,0,0,"class<`mlt`, `mlt_fit`, `mlt_setup`>",1
+mlt,update.mlt_fit,0,0,0,"class<`mlt`, `mlt_fit`, `mlt_setup`>",1
+mlt,update.mlt_fit,1,0,0,double[],1
+mlt,update.mlt_fit,2,0,0,integer[],1
+mlt,update.mlt_fit,2,0,1,null,1
+mlt,update.mlt_fit,3,0,0,double[],1
+mlt,update.mlt_fit,4,0,0,double[],1
+mlt,update.mlt_fit,5,0,0,...,1
+mlt,variable.names.ctm,-1,0,0,character[],1
+mlt,variable.names.ctm,0,0,0,class<`ctm`>,1
+mlt,variable.names.ctm,1,0,0,character[],1
+mlt,variable.names.ctm,2,0,0,...,1
+mlt,vcov.mlt,-1,0,0,class<`matrix`>,1
+mlt,vcov.mlt,0,0,0,"class<`mlt`, `mlt_fit`, `mlt_setup`>",1
+mlt,vcov.mlt,1,0,0,double[],1
+mlt,vcov.mlt,2,0,0,logical,1
+mlt,vcov.mlt,3,0,0,...,1
+mlt,.wecdf,-1,0,0,class<`function`>,1
+mlt,.wecdf,0,0,0,double[],1
+mlt,.wecdf,1,0,0,double[],1
+mlt,weights.mlt,-1,0,0,double[],1
+mlt,weights.mlt,0,0,0,"class<`mlt`, `mlt_fit`, `mlt_setup`>",1
+mlt,weights.mlt,1,0,0,...,1
+mlt,.xmb,-1,0,0,class<`matrix`>,1
+mlt,.xmb,-1,0,1,double[],1
+mlt,.xmb,0,0,0,class<`matrix`>,1
+mlt,.xmb,1,0,0,double[],1
+mlt,.xmb,1,0,1,class<`matrix`>,1
+mnormt,biv.nt.prob,-1,0,0,double,1
+mnormt,biv.nt.prob,0,0,0,double,1
+mnormt,biv.nt.prob,1,0,0,double[],1
+mnormt,biv.nt.prob,2,0,0,double[],1
+mnormt,biv.nt.prob,3,0,0,double[],1
+mnormt,biv.nt.prob,4,0,0,class<`matrix`>,1
+mnormt,dmnorm,-1,0,0,double[],1
+mnormt,dmnorm,0,0,0,class<`matrix`>,1
+mnormt,dmnorm,0,0,1,double[],1
+mnormt,dmnorm,1,0,0,double[],1
+mnormt,dmnorm,2,0,0,class<`matrix`>,1
+mnormt,dmnorm,3,0,0,logical,1
+mnormt,dmt,-1,0,0,double[],1
+mnormt,dmt,0,0,0,class<`matrix`>,1
+mnormt,dmt,1,0,0,double[],1
+mnormt,dmt,2,0,0,class<`matrix`>,1
+mnormt,dmt,3,0,0,double,1
+mnormt,dmt,4,0,0,logical,1
+mnormt,pd.solve,-1,0,0,class<`matrix`>,1
+mnormt,pd.solve,0,0,0,class<`matrix`>,1
+mnormt,pd.solve,1,0,0,logical,1
+mnormt,pd.solve,2,0,0,logical,1
+mnormt,pmnorm,-1,0,0,double[],1
+mnormt,pmnorm,0,0,0,class<`matrix`>,1
+mnormt,pmnorm,0,0,1,double[],1
+mnormt,pmnorm,1,0,0,double[],1
+mnormt,pmnorm,2,0,0,class<`matrix`>,1
+mnormt,pmnorm,2,0,1,double,1
+mnormt,pmnorm,3,0,0,...,1
+mnormt,pmt,-1,0,0,double,1
+mnormt,pmt,0,0,0,double[],1
+mnormt,pmt,1,0,0,double[],1
+mnormt,pmt,2,0,0,class<`matrix`>,1
+mnormt,pmt,3,0,0,double,1
+mnormt,pmt,4,0,0,...,1
+mnormt,rmnorm,-1,0,0,class<`matrix`>,1
+mnormt,rmnorm,0,0,0,double,1
+mnormt,rmnorm,1,0,0,double[],1
+mnormt,rmnorm,2,0,0,any,1
+mnormt,rmnorm,3,0,0,null,1
+mnormt,rmnorm,3,0,1,class<`matrix`>,1
+mnormt,rmt,-1,0,0,class<`matrix`>,1
+mnormt,rmt,0,0,0,double,1
+mnormt,rmt,1,0,0,double[],1
+mnormt,rmt,2,0,0,class<`matrix`>,1
+mnormt,rmt,3,0,0,double,1
+mnormt,rmt,4,0,0,null,1
+mnormt,sadmvn,-1,0,0,double,1
+mnormt,sadmvn,0,0,0,double[],1
+mnormt,sadmvn,1,0,0,double[],1
+mnormt,sadmvn,2,0,0,double[],1
+mnormt,sadmvn,3,0,0,class<`matrix`>,1
+mnormt,sadmvn,4,0,0,double,1
+mnormt,sadmvn,5,0,0,double,1
+mnormt,sadmvn,6,0,0,double,1
+mnormt,sadmvt,-1,0,0,double,1
+mnormt,sadmvt,0,0,0,double,1
+mnormt,sadmvt,1,0,0,double[],1
+mnormt,sadmvt,2,0,0,double[],1
+mnormt,sadmvt,3,0,0,double[],1
+mnormt,sadmvt,4,0,0,class<`matrix`>,1
+mnormt,sadmvt,5,0,0,double,1
+mnormt,sadmvt,6,0,0,double,1
+mnormt,sadmvt,7,0,0,double,1
+modelr,add_predictions,-1,0,0,class<`data.frame`>,1
+modelr,add_predictions,0,0,0,class<`data.frame`>,1
+modelr,add_predictions,1,0,0,class<`lm`>,1
+modelr,add_predictions,2,0,0,character,1
+modelr,add_predictions,3,0,0,null,1
+modelr,add_predictors,-1,0,0,class<`formula`>,1
+modelr,add_predictors,0,0,0,class<`formula`>,1
+modelr,add_predictors,1,0,0,...,1
+modelr,add_predictors,2,0,0,character,1
+modelr,add_residuals,-1,0,0,"class<`data.frame`, `tbl`, `tbl_df`>",1
+modelr,add_residuals,0,0,0,"class<`data.frame`, `tbl`, `tbl_df`>",1
+modelr,add_residuals,1,0,0,class<`lm`>,1
+modelr,add_residuals,2,0,0,character,1
+modelr,as.data.frame.resample,-1,0,0,class<`data.frame`>,1
+modelr,as.data.frame.resample,0,0,0,class<`resample`>,1
+modelr,as.data.frame.resample,1,0,0,...,1
+modelr,as.integer.resample,-1,0,0,integer[],1
+modelr,as.integer.resample,0,0,0,class<`resample`>,1
+modelr,as.integer.resample,1,0,0,...,1
+modelr,bootstrap,-1,0,0,"class<`data.frame`, `tbl`, `tbl_df`>",1
+modelr,bootstrap,0,0,0,class<`data.frame`>,1
+modelr,bootstrap,1,0,0,double,1
+modelr,bootstrap,2,0,0,character,1
+modelr,crossv_kfold,-1,0,0,"class<`data.frame`, `tbl`, `tbl_df`>",1
+modelr,crossv_kfold,0,0,0,class<`data.frame`>,1
+modelr,crossv_kfold,1,0,0,double,1
+modelr,crossv_kfold,2,0,0,character,1
+modelr,crossv_mc,-1,0,0,"class<`data.frame`, `tbl`, `tbl_df`>",1
+modelr,crossv_mc,0,0,0,class<`data.frame`>,1
+modelr,crossv_mc,1,0,0,double,1
+modelr,crossv_mc,2,0,0,double,1
+modelr,crossv_mc,3,0,0,character,1
+modelr,data_grid,-1,0,0,"class<`data.frame`, `tbl`, `tbl_df`>",1
+modelr,data_grid,0,0,0,class<`data.frame`>,1
+modelr,data_grid,1,0,0,...,1
+modelr,data_grid,2,0,0,class<`lm`>,1
+modelr,data_grid,2,0,1,null,1
+modelr,find_binding_env,-1,0,0,null,1
+modelr,find_binding_env,0,0,0,character,1
+modelr,find_binding_env,1,0,0,environment,1
+modelr,find_symbols,-1,0,0,character[],1
+modelr,find_symbols,0,0,0,class<`call`>,1
+modelr,find_symbols,0,0,1,double,1
+modelr,find_symbols,0,0,2,class<`(`>,1
+modelr,find_symbols,0,0,3,class<`name`>,1
+modelr,find_symbols,0,0,4,class<`formula`>,1
+modelr,find_symbols_call,-1,0,0,character[],1
+modelr,find_symbols_call,0,0,0,class<`call`>,1
+modelr,find_symbols_call,0,0,1,class<`formula`>,1
+modelr,find_symbols_call,0,0,2,class<`(`>,1
+modelr,fit_with,-1,0,0,"list<class<`glm`, `lm`>>",1
+modelr,fit_with,-1,0,1,list<class<`lm`>>,1
+modelr,fit_with,0,0,0,class<`data.frame`>,1
+modelr,fit_with,1,0,0,class<`function`>,1
+modelr,fit_with,2,0,0,list<class<`formula`>>,1
+modelr,fit_with,3,0,0,...,1
+modelr,formulas,-1,0,0,list<class<`formula`>>,1
+modelr,formulas,0,0,0,class<`formula`>,1
+modelr,formulas,1,0,0,...,1
+modelr,gather_predictions,-1,0,0,class<`data.frame`>,1
+modelr,gather_predictions,0,0,0,class<`data.frame`>,1
+modelr,gather_predictions,1,0,0,...,1
+modelr,gather_predictions,2,0,0,character,1
+modelr,gather_predictions,3,0,0,character,1
+modelr,gather_predictions,4,0,0,null,1
+modelr,gather_residuals,-1,0,0,"class<`data.frame`, `tbl`, `tbl_df`>",1
+modelr,gather_residuals,0,0,0,"class<`data.frame`, `tbl`, `tbl_df`>",1
+modelr,gather_residuals,1,0,0,...,1
+modelr,gather_residuals,2,0,0,character,1
+modelr,gather_residuals,3,0,0,character,1
+modelr,has_name,-1,0,0,logical[],1
+modelr,has_name,0,0,0,double[],1
+modelr,id,-1,0,0,character[],1
+modelr,id,0,0,0,double,1
+modelr,is_formula,-1,0,0,logical,1
+modelr,is_formula,0,0,0,class<`formula`>,1
+modelr,mae,-1,0,0,double,1
+modelr,mae,0,0,0,class<`lm`>,1
+modelr,mae,1,0,0,class<`data.frame`>,1
+modelr,mape,-1,0,0,double,1
+modelr,mape,0,0,0,class<`lm`>,1
+modelr,mape,1,0,0,class<`data.frame`>,1
+modelr,merge_envs,-1,0,0,environment,1
+modelr,merge_envs,0,0,0,class<`formula`>,1
+modelr,merge_envs,1,0,0,class<`formula`>,1
+modelr,model_matrix,-1,0,0,"class<`data.frame`, `tbl`, `tbl_df`>",1
+modelr,model_matrix,0,0,0,class<`data.frame`>,1
+modelr,model_matrix,1,0,0,class<`formula`>,1
+modelr,model_matrix,2,0,0,...,1
+modelr,mse,-1,0,0,double,1
+modelr,mse,0,0,0,class<`lm`>,1
+modelr,mse,1,0,0,class<`data.frame`>,1
+modelr,predict2,-1,0,0,double[],1
+modelr,predict2,0,0,0,class<`lm`>,1
+modelr,predict2,1,0,0,class<`data.frame`>,1
+modelr,predict2,2,0,0,null,1
+modelr,predictor_vars,-1,0,0,character[],1
+modelr,predictor_vars,0,0,0,class<`lm`>,1
+modelr,predictor_vars.default,-1,0,0,character[],1
+modelr,predictor_vars.default,0,0,0,class<`lm`>,1
+modelr,predictor_vars.default,1,0,0,any,1
+modelr,qae,-1,0,0,double[],1
+modelr,qae,0,0,0,class<`lm`>,1
+modelr,qae,1,0,0,class<`data.frame`>,1
+modelr,qae,2,0,0,double[],1
+modelr,resample,-1,0,0,class<`resample`>,1
+modelr,resample,0,0,0,class<`data.frame`>,1
+modelr,resample,1,0,0,integer[],1
+modelr,resample_bootstrap,-1,0,0,class<`resample`>,1
+modelr,resample_bootstrap,0,0,0,class<`data.frame`>,1
+modelr,resample_partition,-1,0,0,list<class<`resample`>>,1
+modelr,resample_partition,0,0,0,class<`data.frame`>,1
+modelr,resample_partition,1,0,0,double[],1
+modelr,residuals,-1,0,0,double[],1
+modelr,residuals,0,0,0,class<`lm`>,1
+modelr,residuals,1,0,0,"class<`data.frame`, `tbl`, `tbl_df`>",1
+modelr,residuals,1,0,1,class<`resample`>,1
+modelr,residuals,1,0,2,class<`data.frame`>,1
+modelr,response,-1,0,0,double[],1
+modelr,response,0,0,0,class<`lm`>,1
+modelr,response,1,0,0,class<`data.frame`>,1
+modelr,response,1,0,1,"class<`data.frame`, `tbl`, `tbl_df`>",1
+modelr,response,1,0,2,class<`resample`>,1
+modelr,response_var,-1,0,0,class<`name`>,1
+modelr,response_var,0,0,0,class<`lm`>,1
+modelr,response_var.default,-1,0,0,class<`name`>,1
+modelr,response_var.default,0,0,0,class<`lm`>,1
+modelr,response_var.default,1,0,0,any,1
+modelr,rmse,-1,0,0,double,1
+modelr,rmse,0,0,0,class<`lm`>,1
+modelr,rmse,1,0,0,class<`data.frame`>,1
+modelr,rmse,1,0,1,class<`resample`>,1
+modelr,rsae,-1,0,0,double,1
+modelr,rsae,0,0,0,class<`lm`>,1
+modelr,rsae,1,0,0,class<`data.frame`>,1
+modelr,rsquare,-1,0,0,double,1
+modelr,rsquare,0,0,0,class<`lm`>,1
+modelr,rsquare,1,0,0,class<`data.frame`>,1
+modelr,seq_range,-1,0,0,double[],1
+modelr,seq_range,0,0,0,double[],1
+modelr,seq_range,1,0,0,any,1
+modelr,seq_range,2,0,0,any,1
+modelr,seq_range,3,0,0,double,1
+modelr,seq_range,3,0,1,null,1
+modelr,seq_range,4,0,0,null,1
+modelr,seq_range,4,0,1,double,1
+modelr,seq_range,5,0,0,logical,1
+modelr,spread_predictions,-1,0,0,class<`data.frame`>,1
+modelr,spread_predictions,0,0,0,class<`data.frame`>,1
+modelr,spread_predictions,1,0,0,...,1
+modelr,spread_predictions,2,0,0,null,1
+modelr,spread_residuals,-1,0,0,"class<`data.frame`, `tbl`, `tbl_df`>",1
+modelr,spread_residuals,0,0,0,"class<`data.frame`, `tbl`, `tbl_df`>",1
+modelr,spread_residuals,1,0,0,...,1
+modelr,typical,-1,0,0,character[],1
+modelr,typical,-1,0,1,integer,1
+modelr,typical,0,0,0,character[],1
+modelr,typical,0,0,1,class<`factor`>,1
+modelr,typical,0,0,2,"class<`factor`, `ordered`>",1
+modelr,typical,0,0,3,integer[],1
+modelr,typical,1,0,0,...,1
+modelr,typical.character,-1,0,0,character[],1
+modelr,typical.character,0,0,0,character[],1
+modelr,typical.character,1,0,0,...,1
+modelr,typical.factor,-1,0,0,character,1
+modelr,typical.factor,0,0,0,class<`factor`>,1
+modelr,typical.factor,1,0,0,...,1
+modelr,typical.integer,-1,0,0,integer,1
+modelr,typical.integer,0,0,0,integer[],1
+modelr,typical.integer,1,0,0,...,1
+modelr,typical.numeric,-1,0,0,double,1
+modelr,typical.numeric,0,0,0,double[],1
+modelr,typical.numeric,1,0,0,...,1
+modelr,typical.ordered,-1,0,0,character,1
+modelr,typical.ordered,0,0,0,"class<`factor`, `ordered`>",1
+modelr,typical.ordered,1,0,0,...,1
+modelr,validate_formulas,-1,0,0,list<class<`formula`>>,1
+modelr,validate_formulas,0,0,0,class<`formula`>,1
+modelr,validate_formulas,1,0,0,list<class<`formula`>>,1
+modeltools,checkData,-1,0,0,null,1
+modeltools,checkData,0,0,0,class<`data.frame`>,1
+modeltools,checkData,1,0,0,class<`data.frame`>,1
+modeltools,clone,-1,0,0,class<`ModelEnvFormula`>,1
+modeltools,clone,0,0,0,class<`ModelEnvFormula`>,1
+modeltools,clone,1,0,0,...,1
+modeltools,clone,-1,1,0,class<`ModelEnv`>,1
+modeltools,clone,0,1,0,class<`ModelEnv`>,1
+modeltools,clone,1,1,0,...,1
+modeltools,clone,-1,2,0,class<`ModelEnv`>,1
+modeltools,clone,-1,2,1,class<`ModelEnvFormula`>,1
+modeltools,clone,0,2,0,class<`ModelEnv`>,1
+modeltools,clone,0,2,1,class<`ModelEnvFormula`>,1
+modeltools,clone,1,2,0,...,1
+modeltools,complete.cases.ModelEnv,-1,0,0,logical[],1
+modeltools,complete.cases.ModelEnv,0,0,0,class<`ModelEnv`>,1
+modeltools,complete.cases.ModelEnv,0,0,1,class<`ModelEnvFormula`>,1
+modeltools,dimension,-1,0,0,integer[],1
+modeltools,dimension,0,0,0,class<`ModelEnv`>,1
+modeltools,dimension,1,0,0,character,1
+modeltools,dimension,-1,1,0,integer[],1
+modeltools,dimension,0,1,0,class<`ModelEnv`>,1
+modeltools,dimension,1,1,0,character,1
+modeltools,dpp,-1,0,0,class<`ModelEnvFormula`>,1
+modeltools,dpp,0,0,0,class<`StatModel`>,1
+modeltools,dpp,1,0,0,...,1
+modeltools,dpp,-1,1,0,class<`ModelEnvFormula`>,1
+modeltools,dpp,0,1,0,class<`StatModel`>,1
+modeltools,dpp,1,1,0,...,1
+modeltools,empty,-1,0,0,logical,1
+modeltools,empty,0,0,0,class<`ModelEnv`>,1
+modeltools,empty,0,0,1,class<`ModelEnvFormula`>,1
+modeltools,empty,-1,1,0,logical,1
+modeltools,empty,0,1,0,class<`ModelEnv`>,1
+modeltools,empty,-1,2,0,logical,1
+modeltools,empty,0,2,0,class<`ModelEnvFormula`>,1
+modeltools,fit,-1,0,0,"class<`linearModel`, `lm`>",1
+modeltools,fit,0,0,0,class<`StatModel`>,1
+modeltools,fit,1,0,0,class<`ModelEnvFormula`>,1
+modeltools,fit,2,0,0,...,1
+modeltools,fit,-1,1,0,"class<`linearModel`, `lm`>",1
+modeltools,fit,0,1,0,class<`StatModel`>,1
+modeltools,fit,1,1,0,class<`ModelEnvFormula`>,1
+modeltools,fit,2,1,0,...,1
+modeltools,has,-1,0,0,logical,1
+modeltools,has,0,0,0,class<`ModelEnv`>,1
+modeltools,has,1,0,0,character,1
+modeltools,has,-1,1,0,logical,1
+modeltools,has,0,1,0,class<`ModelEnv`>,1
+modeltools,has,1,1,0,character,1
+modeltools,MEapply,-1,0,0,class<`ModelEnv`>,1
+modeltools,MEapply,0,0,0,class<`ModelEnv`>,1
+modeltools,MEapply,1,0,0,class<`function`>,1
+modeltools,MEapply,2,0,0,logical,1
+modeltools,MEapply,3,0,0,...,1
+modeltools,MEapply,-1,1,0,class<`ModelEnv`>,1
+modeltools,MEapply,-1,1,1,class<`ModelEnvFormula`>,1
+modeltools,MEapply,0,1,0,class<`ModelEnv`>,1
+modeltools,MEapply,0,1,1,class<`ModelEnvFormula`>,1
+modeltools,MEapply,1,1,0,class<`function`>,1
+modeltools,MEapply,1,1,1,null,1
+modeltools,MEapply,1,1,2,list<class<`function`>>,1
+modeltools,MEapply,2,1,0,logical,1
+modeltools,MEapply,3,1,0,...,1
+modeltools,MEapply,-1,2,0,class<`ModelEnvFormula`>,1
+modeltools,MEapply,0,2,0,class<`ModelEnvFormula`>,1
+modeltools,MEapply,1,2,0,class<`function`>,1
+modeltools,MEapply,1,2,1,null,1
+modeltools,MEapply,1,2,2,list<class<`function`>>,1
+modeltools,MEapply,2,2,0,logical,1
+modeltools,MEapply,3,2,0,...,1
+modeltools,ModelEnvFormula,-1,0,0,class<`ModelEnvFormula`>,1
+modeltools,ModelEnvFormula,0,0,0,class<`formula`>,1
+modeltools,ModelEnvFormula,1,0,0,class<`data.frame`>,1
+modeltools,ModelEnvFormula,1,0,1,list<any>,1
+modeltools,ModelEnvFormula,2,0,0,null,1
+modeltools,ModelEnvFormula,2,0,1,integer[],1
+modeltools,ModelEnvFormula,3,0,0,class<`standardGeneric`>,1
+modeltools,ModelEnvFormula,3,0,1,null,1
+modeltools,ModelEnvFormula,4,0,0,null,1
+modeltools,ModelEnvFormula,4,0,1,environment,1
+modeltools,ModelEnvFormula,5,0,0,environment,1
+modeltools,ModelEnvFormula,6,0,0,list<any>,1
+modeltools,ModelEnvFormula,7,0,0,logical,1
+modeltools,ModelEnvFormula,8,0,0,logical,1
+modeltools,ModelEnvFormula,9,0,0,null,1
+modeltools,ModelEnvFormula,9,0,1,list<class<`function`>>,1
+modeltools,ModelEnvFormula,10,0,0,...,1
+modeltools,ModelEnvMatrix,-1,0,0,class<`ModelEnv`>,1
+modeltools,ModelEnvMatrix,0,0,0,class<`data.frame`>,1
+modeltools,ModelEnvMatrix,1,0,0,class<`data.frame`>,1
+modeltools,ModelEnvMatrix,2,0,0,integer[],1
+modeltools,ModelEnvMatrix,2,0,1,null,1
+modeltools,ModelEnvMatrix,3,0,0,class<`standardGeneric`>,1
+modeltools,ModelEnvMatrix,3,0,1,null,1
+modeltools,ModelEnvMatrix,4,0,0,list<any>,1
+modeltools,ModelEnvMatrix,5,0,0,...,1
+modeltools,na.omit,-1,0,0,class<`ModelEnvFormula`>,1
+modeltools,na.omit,0,0,0,class<`ModelEnvFormula`>,1
+modeltools,na.omit,1,0,0,...,1
+modeltools,ParseFormula,-1,0,0,class<`FormulaParts`>,1
+modeltools,ParseFormula,0,0,0,class<`formula`>,1
+modeltools,ParseFormula,1,0,0,class<`data.frame`>,1
+modeltools,ParseFormula,1,0,1,list<any>,1
+modeltools,Predict,-1,0,0,double[],1
+modeltools,Predict,0,0,0,"class<`linearModel`, `lm`>",1
+modeltools,Predict,0,0,1,class<`lm`>,1
+modeltools,Predict,1,0,0,...,1
+modeltools,predict.linearModel,-1,0,0,double[],1
+modeltools,predict.linearModel,0,0,0,"class<`linearModel`, `lm`>",1
+modeltools,predict.linearModel,1,0,0,class<`data.frame`>,1
+modeltools,predict.linearModel,2,0,0,...,1
+modeltools,print.linearModel,-1,0,0,"class<`linearModel`, `lm`>",1
+modeltools,print.linearModel,0,0,0,"class<`linearModel`, `lm`>",1
+modeltools,print.linearModel,1,0,0,double,1
+modeltools,print.linearModel,2,0,0,...,1
+modeltools,subset,-1,0,0,class<`ModelEnv`>,1
+modeltools,subset,0,0,0,class<`ModelEnv`>,1
+modeltools,subset,1,0,0,...,1
+modeltools,subset,-1,1,0,class<`ModelEnvFormula`>,1
+modeltools,subset,0,1,0,class<`ModelEnvFormula`>,1
+modeltools,subset,1,1,0,...,1
+moments,agostino.test,-1,0,0,class<`htest`>,1
+moments,agostino.test,0,0,0,double[],1
+moments,agostino.test,1,0,0,character[],1
+moments,all.cumulants,-1,0,0,class<`matrix`>,1
+moments,all.cumulants,-1,0,1,double[],1
+moments,all.cumulants,0,0,0,class<`matrix`>,1
+moments,all.cumulants,0,0,1,double[],1
+moments,all.moments,-1,0,0,class<`matrix`>,1
+moments,all.moments,-1,0,1,double[],1
+moments,all.moments,0,0,0,class<`data.frame`>,1
+moments,all.moments,0,0,1,class<`matrix`>,1
+moments,all.moments,0,0,2,double[],1
+moments,all.moments,1,0,0,double,1
+moments,all.moments,2,0,0,logical,1
+moments,all.moments,3,0,0,logical,1
+moments,all.moments,4,0,0,logical,1
+moments,anscombe.test,-1,0,0,class<`htest`>,1
+moments,anscombe.test,0,0,0,double[],1
+moments,anscombe.test,1,0,0,character[],1
+moments,bonett.test,-1,0,0,class<`htest`>,1
+moments,bonett.test,0,0,0,double[],1
+moments,bonett.test,1,0,0,character[],1
+moments,central2raw,-1,0,0,class<`matrix`>,1
+moments,central2raw,-1,0,1,double[],1
+moments,central2raw,0,0,0,class<`matrix`>,1
+moments,central2raw,0,0,1,double[],1
+moments,central2raw,1,0,0,double[],1
+moments,geary,-1,0,0,double,1
+moments,geary,0,0,0,double[],1
+moments,geary,1,0,0,logical,1
+moments,jarque.test,-1,0,0,class<`htest`>,1
+moments,jarque.test,0,0,0,double[],1
+moments,kurtosis,-1,0,0,double,1
+moments,kurtosis,0,0,0,double[],1
+moments,kurtosis,1,0,0,logical,1
+moments,moment,-1,0,0,double[],1
+moments,moment,0,0,0,double[],1
+moments,moment,0,0,1,class<`matrix`>,1
+moments,moment,0,0,2,class<`data.frame`>,1
+moments,moment,1,0,0,double,1
+moments,moment,2,0,0,logical,1
+moments,moment,3,0,0,logical,1
+moments,moment,4,0,0,logical,1
+moments,raw2central,-1,0,0,double[],1
+moments,raw2central,-1,0,1,class<`matrix`>,1
+moments,raw2central,0,0,0,double[],1
+moments,raw2central,0,0,1,class<`matrix`>,1
+moments,skewness,-1,0,0,double,1
+moments,skewness,0,0,0,double[],1
+moments,skewness,1,0,0,logical,1
+msm,absorbing.msm,-1,0,0,integer[],1
+msm,absorbing.msm,0,0,0,null,1
+msm,absorbing.msm,0,0,1,class<`msm`>,1
+msm,absorbing.msm,1,0,0,class<`matrix`>,1
+msm,absorbing.msm,1,0,1,null,1
+msm,agg.tables,-1,0,0,list<class<`array`>>,1
+msm,agg.tables,0,0,0,class<`table`>,1
+msm,agg.tables,1,0,0,class<`array`>,1
+msm,agg.tables,2,0,0,integer[],1
+msm,agg.tables,3,0,0,list<character[]>,1
+msm,agg.tables,4,0,0,list<any>,1
+msm,Ccall.msm,-1,0,0,class<`array`>,1
+msm,Ccall.msm,-1,0,1,class<`matrix`>,1
+msm,Ccall.msm,-1,0,2,double[],1
+msm,Ccall.msm,0,0,0,double[],1
+msm,Ccall.msm,1,0,0,character,1
+msm,Ccall.msm,2,0,0,list<any>,1
+msm,Ccall.msm,3,0,0,class<`msmqmodel`>,1
+msm,Ccall.msm,4,0,0,list<double[] | character[]>,1
+msm,Ccall.msm,4,0,1,list<double>,1
+msm,Ccall.msm,5,0,0,list<double | null>,1
+msm,Ccall.msm,6,0,0,list<double[]>,1
+msm,Ccall.msm,6,0,1,class<`hmodel`>,1
+msm,Ccall.msm,7,0,0,list<any>,1
+msm,crudeinits.msm,-1,0,0,class<`matrix`>,1
+msm,crudeinits.msm,0,0,0,class<`formula`>,1
+msm,crudeinits.msm,1,0,0,any,1
+msm,crudeinits.msm,2,0,0,class<`matrix`>,1
+msm,crudeinits.msm,3,0,0,class<`data.frame`>,1
+msm,crudeinits.msm,4,0,0,null,1
+msm,crudeinits.msm,5,0,0,null,1
+msm,deltamethod,-1,0,0,double,1
+msm,deltamethod,0,0,0,class<`formula`>,1
+msm,deltamethod,1,0,0,double[],1
+msm,deltamethod,2,0,0,class<`matrix`>,1
+msm,deltamethod,2,0,1,double,1
+msm,deltamethod,3,0,0,logical,1
+msm,deriv.msm,-1,0,0,double[],1
+msm,deriv.msm,0,0,0,double[],1
+msm,deriv.msm,1,0,0,...,1
+msm,deriv.supported,-1,0,0,logical,1
+msm,deriv.supported,0,0,0,list<any>,1
+msm,deriv.supported,1,0,0,list<double[]>,1
+msm,deriv.supported,1,0,1,class<`hmodel`>,1
+msm,deriv.supported,2,0,0,any,1
+msm,dgexpit,-1,0,0,double[],1
+msm,dgexpit,0,0,0,double[],1
+msm,dgexpit,1,0,0,double,1
+msm,dgexpit,2,0,0,double,1
+msm,dmenorm,-1,0,0,double[],1
+msm,dmenorm,0,0,0,double[],1
+msm,dmenorm,1,0,0,double,1
+msm,dmenorm,2,0,0,double,1
+msm,dmenorm,3,0,0,double,1
+msm,dmenorm,4,0,0,double,1
+msm,dmenorm,5,0,0,double,1
+msm,dmenorm,6,0,0,double,1
+msm,dmenorm,7,0,0,logical,1
+msm,dpexp,-1,0,0,double[],1
+msm,dpexp,0,0,0,double[],1
+msm,dpexp,1,0,0,double[],1
+msm,dpexp,2,0,0,double[],1
+msm,dpexp,3,0,0,logical,1
+msm,dtnorm,-1,0,0,double[],1
+msm,dtnorm,0,0,0,double[],1
+msm,dtnorm,1,0,0,double,1
+msm,dtnorm,2,0,0,double,1
+msm,dtnorm,3,0,0,double,1
+msm,dtnorm,4,0,0,double,1
+msm,dtnorm,5,0,0,logical,1
+msm,efpt.msm,-1,0,0,double[],1
+msm,efpt.msm,0,0,0,null,1
+msm,efpt.msm,1,0,0,class<`matrix`>,1
+msm,efpt.msm,2,0,0,double,1
+msm,efpt.msm,3,0,0,character,1
+msm,efpt.msm,4,0,0,character,1
+msm,efpt.msm,5,0,0,character[],1
+msm,efpt.msm,6,0,0,double,1
+msm,efpt.msm,7,0,0,double,1
+msm,efpt.msm,8,0,0,null,1
+msm,efpt.msm,9,0,0,...,1
+msm,expand.data,-1,0,0,list<class<`data.frame`> | class<`matrix`>>,1
+msm,expand.data,0,0,0,class<`msm`>,1
+msm,expand.interactions.msm,-1,0,0,list<double>,1
+msm,expand.interactions.msm,0,0,0,list<integer>,1
+msm,expand.interactions.msm,1,0,0,character[],1
+msm,expsum,-1,0,0,character,1
+msm,expsum,0,0,0,double,1
+msm,expsum,1,0,0,double,1
+msm,expsum.formstr,-1,0,0,list<character[] | double[]>,1
+msm,expsum.formstr,-1,0,1,list<character | double>,1
+msm,expsum.formstr,0,0,0,integer,1
+msm,expsum.formstr,1,0,0,integer[],1
+msm,expsum.formstr,2,0,0,double,1
+msm,expsum.formstr,3,0,0,double,1
+msm,expsum.formstr,4,0,0,integer,1
+msm,expsum.formstr,5,0,0,double,1
+msm,factorcov2numeric.msm,-1,0,0,list<double>,1
+msm,factorcov2numeric.msm,0,0,0,list<integer>,1
+msm,factorcov2numeric.msm,1,0,0,class<`msm`>,1
+msm,factorcov2numeric.msm,2,0,0,list<double[] | character[]>,1
+msm,getobs.msm,-1,0,0,list<double[]>,1
+msm,getobs.msm,0,0,0,list<double[] | class<`matrix`>>,1
+msm,getobs.msm,1,0,0,double[],1
+msm,getobs.msm,2,0,0,double,1
+msm,getobs.msm,3,0,0,logical,1
+msm,gexpit,-1,0,0,^double[],1
+msm,gexpit,0,0,0,^double[],1
+msm,gexpit,1,0,0,class<`matrix`>,1
+msm,gexpit,1,0,1,double[],1
+msm,gexpit,2,0,0,class<`matrix`>,1
+msm,gexpit,2,0,1,double[],1
+msm,glogit,-1,0,0,double[],1
+msm,glogit,0,0,0,double[],1
+msm,glogit,1,0,0,double[],1
+msm,glogit,2,0,0,double[],1
+msm,hazard.msm,-1,0,0,list<class<`matrix`>>,1
+msm,hazard.msm,0,0,0,class<`msm`>,1
+msm,hazard.msm,1,0,0,double,1
+msm,hazard.msm,2,0,0,double,1
+msm,hmmBinom,-1,0,0,class<`hmmdist`>,1
+msm,hmmBinom,0,0,0,double,1
+msm,hmmBinom,1,0,0,double,1
+msm,hmmCheckInits,-1,0,0,null,1
+msm,hmmCheckInits,0,0,0,double[],1
+msm,hmmDIST,-1,0,0,class<`hmmdist`>,1
+msm,hmmDIST,0,0,0,character,1
+msm,hmmDIST,1,0,0,character,1
+msm,hmmDIST,2,0,0,class<`function`>,1
+msm,hmmDIST,3,0,0,class<`call`>,1
+msm,hmmDIST,4,0,0,...,1
+msm,hmmMV,-1,0,0,"class<`hmmMVdist`, `hmmdist`>",1
+msm,hmmMV,0,0,0,...,1
+msm,information.msm,-1,0,0,class<`matrix`>,1
+msm,information.msm,0,0,0,double[],1
+msm,information.msm,1,0,0,...,1
+msm,info.supported,-1,0,0,logical,1
+msm,info.supported,0,0,0,list<any>,1
+msm,info.supported,1,0,0,list<double[]>,1
+msm,info.supported,1,0,1,class<`hmodel`>,1
+msm,info.supported,2,0,0,any,1
+msm,in.range,-1,0,0,logical,1
+msm,in.range,0,0,0,double,1
+msm,in.range,1,0,0,double[],1
+msm,in.range,2,0,0,logical,1
+msm,intervaltrans.msm,-1,0,0,class<`matrix`>,1
+msm,intervaltrans.msm,0,0,0,class<`msm`>,1
+msm,intervaltrans.msm,1,0,0,null,1
+msm,intervaltrans.msm,2,0,0,null,1
+msm,intervaltrans.msm,3,0,0,logical,1
+msm,intervaltrans.msm,4,0,0,logical,1
+msm,is.qmatrix,-1,0,0,logical,1
+msm,is.qmatrix,0,0,0,class<`matrix`>,1
+msm,lsum,-1,0,0,character,1
+msm,lsum,0,0,0,integer,1
+msm,lsum,1,0,0,double,1
+msm,MatrixExp,-1,0,0,class<`array`>,1
+msm,MatrixExp,-1,0,1,class<`matrix`>,1
+msm,MatrixExp,0,0,0,class<`matrix`>,1
+msm,MatrixExp,1,0,0,double[],1
+msm,MatrixExp,2,0,0,character,1
+msm,MatrixExp,2,0,1,null,1
+msm,MatrixExp,3,0,0,...,1
+msm,model.matrix.wrap,-1,0,0,class<`matrix`>,1
+msm,model.matrix.wrap,0,0,0,class<`formula`>,1
+msm,model.matrix.wrap,1,0,0,class<`data.frame`>,1
+msm,msm,-1,0,0,class<`msm`>,1
+msm,msm,0,0,0,class<`formula`>,1
+msm,msm,1,0,0,any,1
+msm,msm,2,0,0,class<`data.frame`>,1
+msm,msm,3,0,0,class<`matrix`>,1
+msm,msm,4,0,0,logical,1
+msm,msm,5,0,0,null,1
+msm,msm,6,0,0,null,1
+msm,msm,6,0,1,"list<class<`hmmMVdist`, `hmmdist`>>",1
+msm,msm,7,0,0,null,1
+msm,msm,8,0,0,null,1
+msm,msm,9,0,0,class<`formula`>,1
+msm,msm,9,0,1,null,1
+msm,msm,10,0,0,null,1
+msm,msm,11,0,0,list<double[]>,1
+msm,msm,11,0,1,null,1
+msm,msm,12,0,0,null,1
+msm,msm,13,0,0,null,1
+msm,msm,14,0,0,null,1
+msm,msm,15,0,0,null,1
+msm,msm2Surv,-1,0,0,"class<`data.frame`, `msdata`>",1
+msm,msm2Surv,0,0,0,class<`data.frame`>,1
+msm,msm2Surv,1,0,0,character,1
+msm,msm2Surv,2,0,0,character,1
+msm,msm2Surv,3,0,0,character,1
+msm,msm2Surv,4,0,0,null,1
+msm,msm2Surv,5,0,0,class<`matrix`>,1
+msm,msm.add.hmmcovs,-1,0,0,class<`matrix`>,1
+msm,msm.add.hmmcovs,0,0,0,class<`hmodel`>,1
+msm,msm.add.hmmcovs,1,0,0,double[],1
+msm,msm.add.hmmcovs,2,0,0,list<class<`matrix`>>,1
+msm,msm.add.qcovs,-1,0,0,class<`array`>,1
+msm,msm.add.qcovs,0,0,0,class<`msmqmodel`>,1
+msm,msm.add.qcovs,1,0,0,double[],1
+msm,msm.add.qcovs,2,0,0,class<`matrix`>,1
+msm,msm.aggregate.data,-1,0,0,class<`data.frame`>,1
+msm,msm.aggregate.data,0,0,0,class<`data.frame`>,1
+msm,msm.center.covs,-1,0,0,class<`matrix`>,1
+msm,msm.center.covs,-1,0,1,null,1
+msm,msm.center.covs,0,0,0,class<`matrix`>,1
+msm,msm.center.covs,0,0,1,null,1
+msm,msm.center.covs,1,0,0,any,1
+msm,msm.center.covs,2,0,0,any,1
+msm,msm.check.constraint,-1,0,0,null,1
+msm,msm.check.constraint,0,0,0,list<double[]>,1
+msm,msm.check.constraint,1,0,0,class<`matrix`>,1
+msm,msm.check.hmodel,-1,0,0,null,1
+msm,msm.check.hmodel,0,0,0,list<class<`hmmdist`>>,1
+msm,msm.check.hmodel,0,0,1,"list<class<`hmmMVdist`, `hmmdist`>>",1
+msm,msm.check.hmodel,1,0,0,integer,1
+msm,msm.check.model,-1,0,0,null,1
+msm,msm.check.model,0,0,0,integer[],1
+msm,msm.check.model,1,0,0,integer[],1
+msm,msm.check.model,2,0,0,any,1
+msm,msm.check.model,3,0,0,any,1
+msm,msm.check.model,4,0,0,double[],1
+msm,msm.check.model,5,0,0,class<`matrix`>,1
+msm,msm.check.model,6,0,0,list<double | null>,1
+msm,msm.check.qmatrix,-1,0,0,null,1
+msm,msm.check.qmatrix,0,0,0,class<`matrix`>,1
+msm,msm.check.state,-1,0,0,null,1
+msm,msm.check.state,0,0,0,any,1
+msm,msm.check.state,1,0,0,class<`matrix`>,1
+msm,msm.check.state,1,0,1,integer[],1
+msm,msm.check.state,2,0,0,any,1
+msm,msm.check.state,3,0,0,class<`hmodel`>,1
+msm,msm.check.state,3,0,1,list<double[]>,1
+msm,msm.check.times,-1,0,0,null,1
+msm,msm.check.times,0,0,0,double[],1
+msm,msm.check.times,1,0,0,double[],1
+msm,msm.check.times,2,0,0,class<`matrix`>,1
+msm,msm.check.times,2,0,1,integer[],1
+msm,msm.check.times,2,0,2,null,1
+msm,msm.dmninvlogit,-1,0,0,class<`array`>,1
+msm,msm.dmninvlogit,0,0,0,class<`hmodel`>,1
+msm,msm.dmninvlogit,1,0,0,any,1
+msm,msm.dmninvlogit,2,0,0,list<class<`matrix`>>,1
+msm,msm.dmninvlogit,3,0,0,any,1
+msm,msm.dmninvlogit,4,0,0,class<`array`>,1
+msm,[.msm.est,-1,0,0,double[],1
+msm,[.msm.est,0,0,0,class<`msm.est`>,1
+msm,[.msm.est,1,0,0,class<`factor`>,1
+msm,[.msm.est,2,0,0,any,1
+msm,[.msm.est,3,0,0,logical,1
+msm,msm.fixdiag.qmatrix,-1,0,0,class<`matrix`>,1
+msm,msm.fixdiag.qmatrix,0,0,0,class<`matrix`>,1
+msm,msm.form.cmodel,-1,0,0,list<double | null>,1
+msm,msm.form.cmodel,0,0,0,null,1
+msm,msm.form.cmodel,1,0,0,null,1
+msm,msm.form.cmodel,2,0,0,any,1
+msm,msm.form.covmodel,-1,0,0,list<double[] | character[]>,1
+msm,msm.form.covmodel,0,0,0,any,1
+msm,msm.form.covmodel,1,0,0,class<`matrix`>,1
+msm,msm.form.covmodel,2,0,0,list<double[]>,1
+msm,msm.form.covmodel,3,0,0,null,1
+msm,msm.form.covmodel,4,0,0,any,1
+msm,msm.form.covmodel,5,0,0,double,1
+msm,msm.form.covmodel,6,0,0,null,1
+msm,msm.form.dh,-1,0,0,class<`array`>,1
+msm,msm.form.dh,0,0,0,class<`hmodel`>,1
+msm,msm.form.dh,1,0,0,double[],1
+msm,msm.form.dh,2,0,0,class<`matrix`>,1
+msm,msm.form.dh,3,0,0,list<any>,1
+msm,msm.form.dh,4,0,0,list<class<`matrix`>>,1
+msm,msm.form.dmodel,-1,0,0,list<double[]>,1
+msm,msm.form.dmodel,0,0,0,null,1
+msm,msm.form.dmodel,0,0,1,double,1
+msm,msm.form.dmodel,1,0,0,class<`msmqmodel`>,1
+msm,msm.form.dmodel,2,0,0,list<double[]>,1
+msm,msm.form.dmodel,2,0,1,class<`hmodel`>,1
+msm,msm.form.dq,-1,0,0,class<`array`>,1
+msm,msm.form.dq,0,0,0,class<`msmqmodel`>,1
+msm,msm.form.dq,1,0,0,list<double>,1
+msm,msm.form.dq,1,0,1,list<double[] | character[]>,1
+msm,msm.form.dq,2,0,0,double[],1
+msm,msm.form.dq,3,0,0,list<any>,1
+msm,msm.form.dq,4,0,0,class<`matrix`>,1
+msm,msm.form.hconstraint,-1,0,0,integer[],1
+msm,msm.form.hconstraint,0,0,0,null,1
+msm,msm.form.hconstraint,1,0,0,class<`hmodel`>,1
+msm,msm.form.hcovconstraint,-1,0,0,integer[],1
+msm,msm.form.hcovconstraint,0,0,0,null,1
+msm,msm.form.hcovconstraint,1,0,0,class<`hmodel`>,1
+msm,msm.form.hmm.agg,-1,0,0,^integer[],1
+msm,msm.form.hmm.agg,0,0,0,class<`data.frame`>,1
+msm,msm.form.hmodel,-1,0,0,class<`hmodel`>,1
+msm,msm.form.hmodel,0,0,0,list<class<`hmmdist`>>,1
+msm,msm.form.hmodel,0,0,1,"list<class<`hmmMVdist`, `hmmdist`>>",1
+msm,msm.form.hmodel,1,0,0,any,1
+msm,msm.form.hmodel,2,0,0,null,1
+msm,msm.form.hmodel,3,0,0,logical,1
+msm,msm.form.houtput,-1,0,0,class<`hmodel`>,1
+msm,msm.form.houtput,0,0,0,class<`hmodel`>,1
+msm,msm.form.houtput,1,0,0,list<any>,1
+msm,msm.form.houtput,2,0,0,list<any>,1
+msm,msm.form.hranges,-1,0,0,class<`matrix`>,1
+msm,msm.form.hranges,0,0,0,null,1
+msm,msm.form.hranges,1,0,0,class<`hmodel`>,1
+msm,msm.form.initprobs,-1,0,0,class<`hmodel`>,1
+msm,msm.form.initprobs,0,0,0,class<`hmodel`>,1
+msm,msm.form.initprobs,1,0,0,any,1
+msm,msm.form.initprobs,2,0,0,class<`data.frame`>,1
+msm,msm.form.mf.agg,-1,0,0,class<`data.frame`>,1
+msm,msm.form.mf.agg,-1,0,1,null,1
+msm,msm.form.mf.agg,0,0,0,class<`msm`>,1
+msm,msm.form.mf.agg,0,0,1,list<class<`msmqmodel`> | list<class<`data.frame`> | double[] | double | null>>,1
+msm,msm.form.mf.agg,0,0,2,list<class<`msmqmodel`> | class<`hmodel`> | list<class<`data.frame`> | double | null>>,1
+msm,msm.form.mm.cov,-1,0,0,class<`matrix`>,1
+msm,msm.form.mm.cov,0,0,0,class<`msm`>,1
+msm,msm.form.mm.cov,0,0,1,list<class<`formula`> | logical | list<class<`data.frame`>>>,1
+msm,msm.form.mm.cov.agg,-1,0,0,class<`matrix`>,1
+msm,msm.form.mm.cov.agg,-1,0,1,null,1
+msm,msm.form.mm.cov.agg,0,0,0,class<`msm`>,1
+msm,msm.form.mm.cov.agg,0,0,1,list<any>,1
+msm,msm.form.mm.hcov,-1,0,0,list<class<`matrix`>>,1
+msm,msm.form.mm.hcov,-1,0,1,null,1
+msm,msm.form.mm.hcov,0,0,0,list<any>,1
+msm,msm.form.mm.hcov,0,0,1,class<`msm`>,1
+msm,msm.form.mm.icov,-1,0,0,class<`matrix`>,1
+msm,msm.form.mm.icov,-1,0,1,null,1
+msm,msm.form.mm.icov,0,0,0,list<any>,1
+msm,msm.form.mm.icov,0,0,1,class<`msm`>,1
+msm,msm.form.mm.mcov,-1,0,0,null,1
+msm,msm.form.mm.mcov,0,0,0,class<`msm`>,1
+msm,msm.form.mm.mcov,0,0,1,list<null | logical | list<class<`data.frame`> | double>>,1
+msm,msm.form.mvhmodel,-1,0,0,list<class<`matrix`> | double[] | character[]>,1
+msm,msm.form.mvhmodel,0,0,0,"list<class<`hmmMVdist`, `hmmdist`>>",1
+msm,msm.form.obstrue,-1,0,0,double[],1
+msm,msm.form.obstrue,0,0,0,class<`data.frame`>,1
+msm,msm.form.obstrue,1,0,0,class<`hmodel`>,1
+msm,msm.form.obstrue,1,0,1,list<double[]>,1
+msm,msm.form.obstrue,2,0,0,list<double | null>,1
+msm,msm.form.obstype,-1,0,0,double[],1
+msm,msm.form.obstype,0,0,0,class<`data.frame`>,1
+msm,msm.form.obstype,1,0,0,null,1
+msm,msm.form.obstype,2,0,0,list<double[]>,1
+msm,msm.form.obstype,3,0,0,logical,1
+msm,msm.form.output,-1,0,0,class<`msm`>,1
+msm,msm.form.output,0,0,0,class<`msm`>,1
+msm,msm.form.output,1,0,0,character,1
+msm,msm.form.params,-1,0,0,list<double[] | character[] | class<`matrix`>>,1
+msm,msm.form.params,0,0,0,class<`msmqmodel`>,1
+msm,msm.form.params,1,0,0,list<double>,1
+msm,msm.form.params,1,0,1,list<double[] | character[]>,1
+msm,msm.form.params,2,0,0,any,1
+msm,msm.form.params,3,0,0,class<`hmodel`>,1
+msm,msm.form.params,3,0,1,list<double[]>,1
+msm,msm.form.params,4,0,0,null,1
+msm,msm.form.params,4,0,1,logical,1
+msm,msm.form.qmodel,-1,0,0,class<`msmqmodel`>,1
+msm,msm.form.qmodel,0,0,0,class<`matrix`>,1
+msm,msm.form.qmodel,1,0,0,null,1
+msm,msm.form.qmodel,2,0,0,logical,1
+msm,msm.form.qmodel,3,0,0,logical,1
+msm,msm.form.qmodel,4,0,0,any,1
+msm,msm.form.univhmodel,-1,0,0,list<character[] | double[]>,1
+msm,msm.form.univhmodel,0,0,0,list<class<`hmmdist`>>,1
+msm,msm.impute.censored,-1,0,0,list<integer[]>,1
+msm,msm.impute.censored,0,0,0,integer[],1
+msm,msm.impute.censored,1,0,0,integer[],1
+msm,msm.impute.censored,2,0,0,any,1
+msm,msm.impute.censored,3,0,0,list<double | null>,1
+msm,msm.initprobs2mat,-1,0,0,class<`matrix`>,1
+msm,msm.initprobs2mat,-1,0,1,double,1
+msm,msm.initprobs2mat,0,0,0,class<`hmodel`>,1
+msm,msm.initprobs2mat,0,0,1,list<double[]>,1
+msm,msm.initprobs2mat,1,0,0,any,1
+msm,msm.initprobs2mat,2,0,0,any,1
+msm,msm.initprobs2mat,3,0,0,class<`data.frame`>,1
+msm,msm.inv.transform,-1,0,0,double[],1
+msm,msm.inv.transform,0,0,0,double[],1
+msm,msm.inv.transform,1,0,0,list<double[]>,1
+msm,msm.inv.transform,1,0,1,class<`hmodel`>,1
+msm,msm.inv.transform,2,0,0,class<`matrix`>,1
+msm,msm.mninvlogit.transform,-1,0,0,class<`matrix`>,1
+msm,msm.mninvlogit.transform,-1,0,1,double[],1
+msm,msm.mninvlogit.transform,0,0,0,class<`matrix`>,1
+msm,msm.mninvlogit.transform,0,0,1,double[],1
+msm,msm.mninvlogit.transform,1,0,0,class<`hmodel`>,1
+msm,msm.mninvlogit.transform,1,0,1,list<double[]>,1
+msm,msm.mnlogit.transform,-1,0,0,double[],1
+msm,msm.mnlogit.transform,0,0,0,double[],1
+msm,msm.mnlogit.transform,1,0,0,list<double[]>,1
+msm,msm.mnlogit.transform,1,0,1,class<`hmodel`>,1
+msm,msm.obs.to.fromto,-1,0,0,class<`data.frame`>,1
+msm,msm.obs.to.fromto,0,0,0,class<`data.frame`>,1
+msm,msm.optim,-1,0,0,list<any>,1
+msm,msm.optim,0,0,0,character,1
+msm,msm.optim,1,0,0,list<double[] | character[] | class<`matrix`>>,1
+msm,msm.optim,2,0,0,logical,1
+msm,msm.optim,3,0,0,logical,1
+msm,msm.optim,4,0,0,list<any>,1
+msm,msm.optim,5,0,0,class<`msmqmodel`>,1
+msm,msm.optim,6,0,0,list<double>,1
+msm,msm.optim,6,0,1,list<double[] | character[]>,1
+msm,msm.optim,7,0,0,list<double | null>,1
+msm,msm.optim,8,0,0,class<`hmodel`>,1
+msm,msm.optim,8,0,1,list<double[]>,1
+msm,msm.optim,9,0,0,...,1
+msm,msm.optim.optim,-1,0,0,list<any>,1
+msm,msm.optim.optim,0,0,0,list<double[] | character[] | class<`matrix`>>,1
+msm,msm.optim.optim,1,0,0,class<`function`>,1
+msm,msm.optim.optim,2,0,0,logical,1
+msm,msm.optim.optim,3,0,0,list<any>,1
+msm,msm.optim.optim,4,0,0,class<`msmqmodel`>,1
+msm,msm.optim.optim,5,0,0,list<double>,1
+msm,msm.optim.optim,5,0,1,list<double[] | character[]>,1
+msm,msm.optim.optim,6,0,0,list<double | null>,1
+msm,msm.optim.optim,7,0,0,class<`hmodel`>,1
+msm,msm.optim.optim,7,0,1,list<double[]>,1
+msm,msm.optim.optim,8,0,0,...,1
+msm,msm.parse.covariates,-1,0,0,list<any>,1
+msm,msm.parse.covariates,0,0,0,any,1
+msm,msm.parse.covariates,1,0,0,character,1
+msm,msm.parse.covariates,1,0,1,list<integer>,1
+msm,msm.parse.covariates,2,0,0,list<double>,1
+msm,msm.parse.covariates,2,0,1,list<double[] | character[]>,1
+msm,msm.parse.covariates,3,0,0,logical,1
+msm,msm.rep.constraints,-1,0,0,double[],1
+msm,msm.rep.constraints,0,0,0,double[],1
+msm,msm.rep.constraints,1,0,0,list<any>,1
+msm,msm.rep.constraints,2,0,0,list<double[]>,1
+msm,msm.rep.constraints,2,0,1,class<`hmodel`>,1
+msm,msm.transform,-1,0,0,double[],1
+msm,msm.transform,0,0,0,double[],1
+msm,msm.transform,1,0,0,list<double[]>,1
+msm,msm.transform,1,0,1,class<`hmodel`>,1
+msm,msm.transform,2,0,0,class<`matrix`>,1
+msm,na.find.msmdata,-1,0,0,class<`array`>,1
+msm,na.find.msmdata,0,0,0,class<`data.frame`>,1
+msm,na.find.msmdata,1,0,0,...,1
+msm,na.omit.msmdata,-1,0,0,class<`data.frame`>,1
+msm,na.omit.msmdata,0,0,0,class<`data.frame`>,1
+msm,na.omit.msmdata,1,0,0,...,1
+msm,pearson.msm,-1,0,0,class<`pearson.msm`>,1
+msm,pearson.msm,0,0,0,class<`msm`>,1
+msm,pearson.msm,1,0,0,null,1
+msm,pearson.msm,2,0,0,double,1
+msm,pearson.msm,3,0,0,double,1
+msm,pearson.msm,4,0,0,double,1
+msm,pearson.msm,5,0,0,null,1
+msm,pearson.msm,6,0,0,logical,1
+msm,pearson.msm,7,0,0,double,1
+msm,pearson.msm,8,0,0,null,1
+msm,pearson.msm,9,0,0,double,1
+msm,pearson.msm,10,0,0,logical,1
+msm,pearson.msm,11,0,0,null,1
+msm,pearson.msm,12,0,0,logical,1
+msm,pmatrix.msm,-1,0,0,class<`msm.est`>,1
+msm,pmatrix.msm,0,0,0,class<`msm`>,1
+msm,pmatrix.msm,1,0,0,double,1
+msm,pmatrix.msm,2,0,0,any,1
+msm,pmatrix.msm,3,0,0,list<integer>,1
+msm,pmatrix.msm,3,0,1,character,1
+msm,pmatrix.msm,4,0,0,character[],1
+msm,pmatrix.msm,5,0,0,double,1
+msm,pmatrix.msm,6,0,0,double,1
+msm,pmatrix.msm,7,0,0,null,1
+msm,pmatrix.msm,8,0,0,null,1
+msm,pmatrix.msm,9,0,0,...,1
+msm,ppass.msm,-1,0,0,class<`matrix`>,1
+msm,ppass.msm,0,0,0,null,1
+msm,ppass.msm,1,0,0,class<`matrix`>,1
+msm,ppass.msm,2,0,0,double,1
+msm,ppass.msm,3,0,0,character,1
+msm,ppass.msm,4,0,0,character,1
+msm,ppass.msm,5,0,0,null,1
+msm,ppass.msm,6,0,0,null,1
+msm,ppass.msm,7,0,0,character[],1
+msm,ppass.msm,8,0,0,double,1
+msm,ppass.msm,9,0,0,double,1
+msm,ppass.msm,10,0,0,null,1
+msm,ppass.msm,11,0,0,...,1
+msm,ppexp,-1,0,0,double[],1
+msm,ppexp,0,0,0,double[],1
+msm,ppexp,1,0,0,double[],1
+msm,ppexp,2,0,0,double[],1
+msm,ppexp,3,0,0,logical,1
+msm,ppexp,4,0,0,logical,1
+msm,qcut,-1,0,0,class<`factor`>,1
+msm,qcut,0,0,0,double[],1
+msm,qcut,1,0,0,any,1
+msm,qcut,2,0,0,null,1
+msm,qcut,2,0,1,double[],1
+msm,qcut,3,0,0,double,1
+msm,qcut,4,0,0,double,1
+msm,qcut,5,0,0,logical,1
+msm,qgeneric,-1,0,0,double[],1
+msm,qgeneric,0,0,0,class<`function`>,1
+msm,qgeneric,1,0,0,double[],1
+msm,qgeneric,2,0,0,null,1
+msm,qgeneric,3,0,0,...,1
+msm,qmatrix.diagse.msm,-1,0,0,list<double[]>,1
+msm,qmatrix.diagse.msm,0,0,0,class<`msm`>,1
+msm,qmatrix.diagse.msm,1,0,0,list<any>,1
+msm,qmatrix.diagse.msm,2,0,0,logical,1
+msm,qmatrix.diagse.msm,3,0,0,double,1
+msm,qmatrix.diagse.msm,4,0,0,double[],1
+msm,qmatrix.diagse.msm,5,0,0,integer,1
+msm,qmatrix.msm,-1,0,0,class<`matrix`>,1
+msm,qmatrix.msm,-1,0,1,class<`msm.est`>,1
+msm,qmatrix.msm,0,0,0,class<`msm`>,1
+msm,qmatrix.msm,1,0,0,character,1
+msm,qmatrix.msm,1,0,1,list<integer>,1
+msm,qmatrix.msm,2,0,0,logical,1
+msm,qmatrix.msm,3,0,0,character[],1
+msm,qmatrix.msm,4,0,0,double,1
+msm,qmatrix.msm,5,0,0,any,1
+msm,qmatrix.msm,6,0,0,null,1
+msm,reformat.pearson.msm,-1,0,0,list<class<`data.frame`> | class<`array`> | double[]>,1
+msm,reformat.pearson.msm,0,0,0,list<class<`array`> | class<`data.frame`> | double[]>,1
+msm,resample,-1,0,0,integer,1
+msm,resample,0,0,0,integer[],1
+msm,resample,1,0,0,double,1
+msm,resample,2,0,0,...,1
+msm,rpexp,-1,0,0,double,1
+msm,rpexp,0,0,0,double,1
+msm,rpexp,1,0,0,double,1
+msm,rpexp,2,0,0,double,1
+msm,sim.msm,-1,0,0,list<double[] | class<`matrix`>>,1
+msm,sim.msm,0,0,0,class<`matrix`>,1
+msm,sim.msm,1,0,0,double,1
+msm,sim.msm,2,0,0,null,1
+msm,sim.msm,3,0,0,any,1
+msm,sim.msm,4,0,0,any,1
+msm,sim.msm,5,0,0,double,1
+msm,sim.msm,6,0,0,double,1
+msm,simmulti.msm,-1,0,0,class<`data.frame`>,1
+msm,simmulti.msm,0,0,0,class<`data.frame`>,1
+msm,simmulti.msm,1,0,0,class<`matrix`>,1
+msm,simmulti.msm,2,0,0,null,1
+msm,simmulti.msm,3,0,0,logical,1
+msm,simmulti.msm,4,0,0,any,1
+msm,simmulti.msm,5,0,0,null,1
+msm,simmulti.msm,6,0,0,null,1
+msm,simmulti.msm,7,0,0,null,1
+msm,simmulti.msm,8,0,0,null,1
+msm,simmulti.msm,9,0,0,null,1
+msm,simmulti.msm,10,0,0,logical,1
+msm,sojourn.msm,-1,0,0,class<`data.frame`>,1
+msm,sojourn.msm,-1,0,1,list<double>,1
+msm,sojourn.msm,0,0,0,class<`msm`>,1
+msm,sojourn.msm,1,0,0,character,1
+msm,sojourn.msm,2,0,0,character[],1
+msm,sojourn.msm,3,0,0,double,1
+msm,sojourn.msm,4,0,0,double,1
+msm,statetable.msm,-1,0,0,class<`table`>,1
+msm,statetable.msm,0,0,0,any,1
+msm,statetable.msm,1,0,0,any,1
+msm,statetable.msm,2,0,0,class<`data.frame`>,1
+msm,statetable.msm,2,0,1,null,1
+msm,transient.msm,-1,0,0,integer[],1
+msm,transient.msm,0,0,0,class<`msm`>,1
+msm,transient.msm,0,0,1,null,1
+msm,transient.msm,1,0,0,null,1
+msm,transient.msm,1,0,1,class<`matrix`>,1
+mstate,create.wData.omega,-1,0,0,class<`data.frame`>,1
+mstate,create.wData.omega,0,0,0,double[],1
+mstate,create.wData.omega,1,0,0,double[],1
+mstate,create.wData.omega,2,0,0,class<`factor`>,1
+mstate,create.wData.omega,3,0,0,integer[],1
+mstate,create.wData.omega,4,0,0,double,1
+mstate,create.wData.omega,5,0,0,character,1
+mstate,create.wData.omega,6,0,0,character,1
+mstate,crprep,-1,0,0,"class<`crprep`, `data.frame`>",1
+mstate,crprep,0,0,0,character,1
+mstate,crprep,1,0,0,...,1
+mstate,crprep.default,-1,0,0,"class<`crprep`, `data.frame`>",1
+mstate,crprep.default,0,0,0,character,1
+mstate,crprep.default,1,0,0,character,1
+mstate,crprep.default,2,0,0,class<`data.frame`>,1
+mstate,crprep.default,3,0,0,character[],1
+mstate,crprep.default,4,0,0,character,1
+mstate,crprep.default,5,0,0,double,1
+mstate,crprep.default,6,0,0,character,1
+mstate,crprep.default,7,0,0,any,1
+mstate,crsample,-1,0,0,list<double>,1
+mstate,crsample,0,0,0,class<`data.frame`>,1
+mstate,crsample,1,0,0,double,1
+mstate,crsample,2,0,0,null,1
+mstate,Cuminc,-1,0,0,"class<`Cuminc`, `data.frame`>",1
+mstate,Cuminc,0,0,0,character,1
+mstate,Cuminc,0,0,1,double[],1
+mstate,Cuminc,1,0,0,character,1
+mstate,Cuminc,1,0,1,integer[],1
+mstate,Cuminc,2,0,0,any,1
+mstate,Cuminc,3,0,0,any,1
+mstate,Cuminc,4,0,0,any,1
+mstate,Cuminc,5,0,0,any,1
+mstate,Cuminc,6,0,0,logical,1
+mstate,cutLMms,-1,0,0,"class<`data.frame`, `msdata`>",1
+mstate,cutLMms,0,0,0,"class<`data.frame`, `msdata`>",1
+mstate,cutLMms,1,0,0,double,1
+mstate,cutLMms,2,0,0,any,1
+mstate,ELOS,-1,0,0,class<`matrix`>,1
+mstate,ELOS,0,0,0,class<`probtrans`>,1
+mstate,ELOS,1,0,0,any,1
+mstate,events,-1,0,0,list<class<`table`>>,1
+mstate,events,0,0,0,"class<`data.frame`, `msdata`>",1
+mstate,expand.covs,-1,0,0,class<`data.frame`>,1
+mstate,expand.covs,-1,0,1,"class<`data.frame`, `msdata`>",1
+mstate,expand.covs,0,0,0,class<`data.frame`>,1
+mstate,expand.covs,0,0,1,"class<`data.frame`, `msdata`>",1
+mstate,expand.covs,1,0,0,...,1
+mstate,expand.covs.default,-1,0,0,class<`data.frame`>,1
+mstate,expand.covs.default,0,0,0,class<`data.frame`>,1
+mstate,expand.covs.default,1,0,0,character[],1
+mstate,expand.covs.default,2,0,0,logical,1
+mstate,expand.covs.default,3,0,0,logical,1
+mstate,expand.covs.default,4,0,0,character,1
+mstate,expand.covs.default,5,0,0,...,1
+mstate,expand.covs.msdata,-1,0,0,class<`data.frame`>,1
+mstate,expand.covs.msdata,-1,0,1,"class<`data.frame`, `msdata`>",1
+mstate,expand.covs.msdata,0,0,0,"class<`data.frame`, `msdata`>",1
+mstate,expand.covs.msdata,1,0,0,character[],1
+mstate,expand.covs.msdata,2,0,0,logical,1
+mstate,expand.covs.msdata,3,0,0,logical,1
+mstate,expand.covs.msdata,4,0,0,...,1
+mstate,fillplot,-1,0,0,null,1
+mstate,fillplot,0,0,0,double[],1
+mstate,fillplot,1,0,0,double[],1
+mstate,fillplot,2,0,0,double[],1
+mstate,fillplot,3,0,0,character,1
+mstate,fillplot,4,0,0,double,1
+mstate,Hazsample,-1,0,0,double,1
+mstate,Hazsample,0,0,0,class<`data.frame`>,1
+mstate,Hazsample,1,0,0,double,1
+mstate,Hazsample,2,0,0,logical,1
+mstate,LMAJ,-1,0,0,class<`data.frame`>,1
+mstate,LMAJ,0,0,0,"class<`data.frame`, `msdata`>",1
+mstate,LMAJ,1,0,0,double,1
+mstate,LMAJ,2,0,0,double,1
+mstate,LMAJ,3,0,0,character[],1
+mstate,msboot,-1,0,0,class<`matrix`>,1
+mstate,msboot,0,0,0,class<`function`>,1
+mstate,msboot,1,0,0,"class<`data.frame`, `msdata`>",1
+mstate,msboot,2,0,0,double,1
+mstate,msboot,3,0,0,character,1
+mstate,msboot,4,0,0,double,1
+mstate,msboot,5,0,0,...,1
+mstate,msfit,-1,0,0,class<`msfit`>,1
+mstate,msfit,0,0,0,class<`coxph`>,1
+mstate,msfit,0,0,1,"class<`coxph`, `coxph.null`>",1
+mstate,msfit,1,0,0,any,1
+mstate,msfit,2,0,0,logical,1
+mstate,msfit,3,0,0,character[],1
+mstate,msfit,4,0,0,class<`matrix`>,1
+mstate,msprep,-1,0,0,"class<`data.frame`, `msdata`>",1
+mstate,msprep,0,0,0,^character[],1
+mstate,msprep,0,0,1,class<`matrix`>,1
+mstate,msprep,1,0,0,^character[],1
+mstate,msprep,1,0,1,class<`matrix`>,1
+mstate,msprep,2,0,0,any,1
+mstate,msprep,3,0,0,class<`matrix`>,1
+mstate,msprep,4,0,0,any,1
+mstate,msprep,5,0,0,any,1
+mstate,msprep,6,0,0,any,1
+mstate,msprepEngine,-1,0,0,class<`matrix`>,1
+mstate,msprepEngine,0,0,0,class<`matrix`>,1
+mstate,msprepEngine,0,0,1,double[],1
+mstate,msprepEngine,1,0,0,any,1
+mstate,msprepEngine,2,0,0,any,1
+mstate,msprepEngine,3,0,0,any,1
+mstate,msprepEngine,4,0,0,any,1
+mstate,msprepEngine,5,0,0,any,1
+mstate,msprepEngine,6,0,0,any,1
+mstate,msprepEngine,7,0,0,class<`matrix`>,1
+mstate,msprepEngine,7,0,1,null,1
+mstate,mssample,-1,0,0,class<`data.frame`>,1
+mstate,mssample,-1,0,1,class<`msdata`>,1
+mstate,mssample,0,0,0,class<`data.frame`>,1
+mstate,mssample,1,0,0,class<`matrix`>,1
+mstate,mssample,2,0,0,list<double | null>,1
+mstate,mssample,3,0,0,null,1
+mstate,mssample,4,0,0,character[],1
+mstate,mssample,5,0,0,character[],1
+mstate,mssample,6,0,0,any,1
+mstate,mssample,7,0,0,null,1
+mstate,mssample1,-1,0,0,class<`matrix`>,1
+mstate,mssample1,0,0,0,class<`data.frame`>,1
+mstate,mssample1,1,0,0,class<`matrix`>,1
+mstate,mssample1,2,0,0,list<double[]>,1
+mstate,mssample1,3,0,0,null,1
+mstate,mssample1,4,0,0,character,1
+mstate,mssample1,5,0,0,character,1
+mstate,mssample1,6,0,0,any,1
+mstate,mssample1,7,0,0,null,1
+mstate,my.cbind2,-1,0,0,class<`matrix`>,1
+mstate,my.cbind2,0,0,0,double,1
+mstate,my.cbind2,1,0,0,class<`matrix`>,1
+mstate,my.rbind,-1,0,0,class<`matrix`>,1
+mstate,my.rbind,0,0,0,class<`matrix`>,1
+mstate,my.rbind,1,0,0,class<`matrix`>,1
+mstate,NAfix,-1,0,0,double[],1
+mstate,NAfix,0,0,0,^double[],1
+mstate,NAfix,1,0,0,double,1
+mstate,paths,-1,0,0,class<`matrix`>,1
+mstate,paths,0,0,0,class<`matrix`>,1
+mstate,paths,1,0,0,double,1
+mstate,plot.msfit,-1,0,0,null,1
+mstate,plot.msfit,0,0,0,class<`msfit`>,1
+mstate,plot.msfit,1,0,0,character[],1
+mstate,plot.msfit,2,0,0,any,1
+mstate,plot.msfit,3,0,0,character,1
+mstate,plot.msfit,4,0,0,character,1
+mstate,plot.msfit,5,0,0,any,1
+mstate,plot.msfit,6,0,0,any,1
+mstate,plot.msfit,7,0,0,any,1
+mstate,plot.probtrans,-1,0,0,null,1
+mstate,plot.probtrans,0,0,0,class<`probtrans`>,1
+mstate,plot.probtrans,1,0,0,double,1
+mstate,plot.probtrans,2,0,0,character[],1
+mstate,plot.probtrans,3,0,0,any,1
+mstate,plot.probtrans,4,0,0,any,1
+mstate,plot.probtrans,5,0,0,character,1
+mstate,plot.probtrans,6,0,0,character,1
+mstate,plot.probtrans,7,0,0,any,1
+mstate,print.msdata,-1,0,0,null,1
+mstate,print.msdata,0,0,0,"class<`data.frame`, `msdata`>",1
+mstate,print.msdata,1,0,0,logical,1
+mstate,print.msdata,2,0,0,...,1
+mstate,probtrans,-1,0,0,class<`probtrans`>,1
+mstate,probtrans,0,0,0,class<`msfit`>,1
+mstate,probtrans,1,0,0,double,1
+mstate,probtrans,2,0,0,character[],1
+mstate,probtrans,3,0,0,character[],1
+mstate,probtrans,4,0,0,logical,1
+mstate,probtrans,5,0,0,logical,1
+mstate,summary.msfit,-1,0,0,null,1
+mstate,summary.msfit,0,0,0,class<`msfit`>,1
+mstate,summary.msfit,1,0,0,logical,1
+mstate,summary.msfit,2,0,0,logical,1
+mstate,summary.msfit,3,0,0,...,1
+mstate,summary.probtrans,-1,0,0,null,1
+mstate,summary.probtrans,0,0,0,class<`probtrans`>,1
+mstate,summary.probtrans,1,0,0,any,1
+mstate,summary.probtrans,2,0,0,logical,1
+mstate,summary.probtrans,3,0,0,logical,1
+mstate,summary.probtrans,4,0,0,...,1
+mstate,to.trans2,-1,0,0,class<`data.frame`>,1
+mstate,to.trans2,0,0,0,class<`matrix`>,1
+mstate,trans.comprisk,-1,0,0,class<`matrix`>,1
+mstate,trans.comprisk,0,0,0,double,1
+mstate,trans.comprisk,1,0,0,any,1
+mstate,trans.illdeath,-1,0,0,class<`matrix`>,1
+mstate,trans.illdeath,0,0,0,any,1
+mstate,transMat,-1,0,0,class<`matrix`>,1
+mstate,transMat,0,0,0,list<double[] | null>,1
+mstate,transMat,1,0,0,any,1
+mstate,xsect,-1,0,0,class<`data.frame`>,1
+mstate,xsect,0,0,0,"class<`data.frame`, `msdata`>",1
+mstate,xsect,1,0,0,double,1
+multcomp,adjusted,-1,0,0,class<`function`>,1
+multcomp,adjusted,0,0,0,character[],1
+multcomp,adjusted,1,0,0,...,1
+multcomp,adjusted_calpha,-1,0,0,class<`function`>,1
+multcomp,adjusted_calpha,0,0,0,...,1
+multcomp,allsubsets,-1,0,0,list<integer[]>,1
+multcomp,allsubsets,-1,0,1,list<null>,1
+multcomp,allsubsets,0,0,0,integer[],1
+multcomp,as.char,-1,0,0,character,1
+multcomp,as.char,0,0,0,class<`name`>,1
+multcomp,.bdiag,-1,0,0,class<`matrix`>,1
+multcomp,.bdiag,0,0,0,...,1
+multcomp,bread.mmm,-1,0,0,class<`matrix`>,1
+multcomp,bread.mmm,0,0,0,class<`mmm`>,1
+multcomp,bread.mmm,1,0,0,...,1
+multcomp,cftest,-1,0,0,"class<`glht`, `summary.glht`>",1
+multcomp,cftest,0,0,0,class<`lm`>,1
+multcomp,cftest,1,0,0,any,1
+multcomp,cftest,2,0,0,class<`function`>,1
+multcomp,cftest,3,0,0,...,1
+multcomp,Chisqtest,-1,0,0,class<`function`>,1
+multcomp,chkdots,-1,0,0,character,1
+multcomp,chkdots,-1,0,1,null,1
+multcomp,chkdots,0,0,0,...,1
+multcomp,chrlinfct2matrix,-1,0,0,any,1
+multcomp,chrlinfct2matrix,0,0,0,character[],1
+multcomp,chrlinfct2matrix,1,0,0,character[],1
+multcomp,cld,-1,0,0,class<`cld`>,1
+multcomp,cld,0,0,0,"class<`confint.glht`, `glht`>",1
+multcomp,cld,0,0,1,class<`glht`>,1
+multcomp,cld,0,0,2,"class<`glht`, `summary.glht`>",1
+multcomp,cld,1,0,0,...,1
+multcomp,cld.confint.glht,-1,0,0,class<`cld`>,1
+multcomp,cld.confint.glht,0,0,0,"class<`confint.glht`, `glht`>",1
+multcomp,cld.confint.glht,1,0,0,logical,1
+multcomp,cld.confint.glht,2,0,0,...,1
+multcomp,cld.glht,-1,0,0,class<`cld`>,1
+multcomp,cld.glht,0,0,0,class<`glht`>,1
+multcomp,cld.glht,1,0,0,double,1
+multcomp,cld.glht,2,0,0,logical,1
+multcomp,cld.glht,3,0,0,...,1
+multcomp,cld.summary.glht,-1,0,0,class<`cld`>,1
+multcomp,cld.summary.glht,0,0,0,"class<`glht`, `summary.glht`>",1
+multcomp,cld.summary.glht,1,0,0,double,1
+multcomp,cld.summary.glht,2,0,0,logical,1
+multcomp,cld.summary.glht,3,0,0,...,1
+multcomp,coef.glht,-1,0,0,double[],1
+multcomp,coef.glht,0,0,0,class<`glht`>,1
+multcomp,coef.glht,0,0,1,"class<`glht`, `summary.gtest`>",1
+multcomp,coef.glht,1,0,0,logical,1
+multcomp,coef.glht,2,0,0,...,1
+multcomp,coef.mmm,-1,0,0,double[],1
+multcomp,coef.mmm,0,0,0,class<`mmm`>,1
+multcomp,coef.mmm,1,0,0,...,1
+multcomp,coef.parm,-1,0,0,double[],1
+multcomp,coef.parm,0,0,0,class<`parm`>,1
+multcomp,coef.parm,1,0,0,...,1
+multcomp,confint.glht,-1,0,0,"class<`confint.glht`, `glht`>",1
+multcomp,confint.glht,0,0,0,class<`glht`>,1
+multcomp,confint.glht,1,0,0,any,1
+multcomp,confint.glht,2,0,0,double,1
+multcomp,confint.glht,3,0,0,class<`function`>,1
+multcomp,confint.glht,3,0,1,double,1
+multcomp,confint.glht,4,0,0,...,1
+multcomp,contrMat,-1,0,0,"class<`contrMat`, `matrix`>",1
+multcomp,contrMat,0,0,0,class<`table`>,1
+multcomp,contrMat,0,0,1,double[],1
+multcomp,contrMat,1,0,0,character[],1
+multcomp,contrMat,2,0,0,double,1
+multcomp,estfun.mmm,-1,0,0,class<`matrix`>,1
+multcomp,estfun.mmm,0,0,0,class<`mmm`>,1
+multcomp,estfun.mmm,1,0,0,...,1
+multcomp,expression2coef,-1,0,0,any,1
+multcomp,expression2coef,0,0,0,expression,1
+multcomp,expression2coef,1,0,0,any,1
+multcomp,expression2coef,2,0,0,logical,1
+multcomp,extr,-1,0,0,list<any>,1
+multcomp,extr,0,0,0,"class<`glht`, `summary.glht`>",1
+multcomp,extr,0,0,1,"class<`confint.glht`, `glht`>",1
+multcomp,factor_contrasts,-1,0,0,any,1
+multcomp,factor_contrasts,0,0,0,"class<`aovlist`, `listof`>",1
+multcomp,factor_contrasts,0,0,1,"class<`aov`, `lm`>",1
+multcomp,factor_contrasts,0,0,2,class<`coxph`>,1
+multcomp,factor_contrasts,0,0,3,"class<`glm`, `lm`>",1
+multcomp,factor_contrasts,0,0,4,class<`lm`>,1
+multcomp,factor_contrasts,0,0,5,class<`polr`>,1
+multcomp,factor_contrasts,0,0,6,class<`survreg`>,1
+multcomp,factor_contrasts,0,0,7,class<`lme`>,1
+multcomp,factor_contrasts,0,0,8,class<`coxme`>,1
+multcomp,factor_contrasts,0,0,9,class<`lmerMod`>,1
+multcomp,factor_contrasts,0,0,10,"class<`colr`, `mlt`, `mlt_fit`, `mlt_setup`, `tram`>",1
+multcomp,Ftest,-1,0,0,class<`function`>,1
+multcomp,get_letters,-1,0,0,character[],1
+multcomp,get_letters,0,0,0,integer,1
+multcomp,get_letters,1,0,0,character[],1
+multcomp,get_letters,2,0,0,any,1
+multcomp,glht,-1,0,0,any,1
+multcomp,glht,0,0,0,"class<`aov`, `lm`>",1
+multcomp,glht,0,0,1,"class<`colr`, `mlt`, `mlt_fit`, `mlt_setup`, `tram`>",1
+multcomp,glht,0,0,2,class<`coxme`>,1
+multcomp,glht,0,0,3,class<`coxph`>,1
+multcomp,glht,0,0,4,class<`glmerMod`>,1
+multcomp,glht,0,0,5,"class<`glm`, `lm`>",1
+multcomp,glht,0,0,6,class<`lm`>,1
+multcomp,glht,0,0,7,class<`lme`>,1
+multcomp,glht,0,0,8,class<`lmerMod`>,1
+multcomp,glht,0,0,9,class<`lmrob`>,1
+multcomp,glht,0,0,10,class<`mmm`>,1
+multcomp,glht,0,0,11,class<`nls`>,1
+multcomp,glht,0,0,12,class<`parm`>,1
+multcomp,glht,0,0,13,class<`polr`>,1
+multcomp,glht,0,0,14,class<`survreg`>,1
+multcomp,glht,0,0,15,list<double[] | class<`matrix`>>,1
+multcomp,glht,0,0,16,"class<`aovlist`, `listof`>",1
+multcomp,glht,1,0,0,any,1
+multcomp,glht,2,0,0,...,1
+multcomp,glht.character,-1,0,0,class<`glht`>,1
+multcomp,glht.character,0,0,0,"class<`aov`, `lm`>",1
+multcomp,glht.character,0,0,1,"class<`glm`, `lm`>",1
+multcomp,glht.character,0,0,2,class<`lm`>,1
+multcomp,glht.character,0,0,3,class<`parm`>,1
+multcomp,glht.character,0,0,4,list<double[] | class<`matrix`>>,1
+multcomp,glht.character,1,0,0,character[],1
+multcomp,glht.character,2,0,0,...,1
+multcomp,glht.matrix,-1,0,0,class<`glht`>,1
+multcomp,glht.matrix,0,0,0,class<`mmm`>,1
+multcomp,glht.matrix,0,0,1,"class<`aov`, `lm`>",1
+multcomp,glht.matrix,0,0,2,"class<`colr`, `mlt`, `mlt_fit`, `mlt_setup`, `tram`>",1
+multcomp,glht.matrix,0,0,3,class<`coxme`>,1
+multcomp,glht.matrix,0,0,4,class<`coxph`>,1
+multcomp,glht.matrix,0,0,5,class<`glmerMod`>,1
+multcomp,glht.matrix,0,0,6,"class<`glm`, `lm`>",1
+multcomp,glht.matrix,0,0,7,class<`lm`>,1
+multcomp,glht.matrix,0,0,8,class<`lme`>,1
+multcomp,glht.matrix,0,0,9,class<`lmerMod`>,1
+multcomp,glht.matrix,0,0,10,class<`lmrob`>,1
+multcomp,glht.matrix,0,0,11,class<`nls`>,1
+multcomp,glht.matrix,0,0,12,class<`parm`>,1
+multcomp,glht.matrix,0,0,13,class<`polr`>,1
+multcomp,glht.matrix,0,0,14,class<`survreg`>,1
+multcomp,glht.matrix,0,0,15,list<double[] | class<`matrix`>>,1
+multcomp,glht.matrix,1,0,0,class<`matrix`>,1
+multcomp,glht.matrix,2,0,0,character[],1
+multcomp,glht.matrix,3,0,0,double[],1
+multcomp,glht.matrix,4,0,0,...,1
+multcomp,glht.mcp,-1,0,0,any,1
+multcomp,glht.mcp,0,0,0,"class<`aov`, `lm`>",1
+multcomp,glht.mcp,0,0,1,"class<`colr`, `mlt`, `mlt_fit`, `mlt_setup`, `tram`>",1
+multcomp,glht.mcp,0,0,2,class<`coxme`>,1
+multcomp,glht.mcp,0,0,3,class<`coxph`>,1
+multcomp,glht.mcp,0,0,4,"class<`glm`, `lm`>",1
+multcomp,glht.mcp,0,0,5,class<`lm`>,1
+multcomp,glht.mcp,0,0,6,class<`lme`>,1
+multcomp,glht.mcp,0,0,7,class<`lmerMod`>,1
+multcomp,glht.mcp,0,0,8,class<`polr`>,1
+multcomp,glht.mcp,0,0,9,class<`survreg`>,1
+multcomp,glht.mcp,0,0,10,"class<`aovlist`, `listof`>",1
+multcomp,glht.mcp,1,0,0,class<`mcp`>,1
+multcomp,glht.mcp,2,0,0,...,1
+multcomp,glht.means,-1,0,0,class<`glht`>,1
+multcomp,glht.means,0,0,0,"class<`aov`, `lm`>",1
+multcomp,glht.means,1,0,0,class<`means`>,1
+multcomp,glht.means,2,0,0,...,1
+multcomp,glht.mlf,-1,0,0,class<`glht`>,1
+multcomp,glht.mlf,0,0,0,class<`mmm`>,1
+multcomp,glht.mlf,1,0,0,class<`mlf`>,1
+multcomp,glht.mlf,2,0,0,...,1
+multcomp,global,-1,0,0,class<`function`>,1
+multcomp,global,0,0,0,character,1
+multcomp,insert_absorb,-1,0,0,class<`multcompLetters`>,1
+multcomp,insert_absorb,0,0,0,logical[],1
+multcomp,insert_absorb,1,0,0,character[],1
+multcomp,insert_absorb,2,0,0,character,1
+multcomp,insert_absorb,3,0,0,logical,1
+multcomp,insert_absorb,4,0,0,class<`matrix`>,1
+multcomp,insert_absorb,5,0,0,character[],1
+multcomp,is_num,-1,0,0,logical,1
+multcomp,is_num,0,0,0,double,1
+multcomp,lhs,-1,0,0,class<`call`>,1
+multcomp,lhs,-1,0,1,class<`name`>,1
+multcomp,lhs,0,0,0,expression,1
+multcomp,maxsets,-1,0,0,list<list<integer[]>>,1
+multcomp,maxsets,0,0,0,class<`matrix`>,1
+multcomp,mcp,-1,0,0,class<`mcp`>,1
+multcomp,mcp,-1,0,1,class<`means`>,1
+multcomp,mcp,0,0,0,...,1
+multcomp,mcp,1,0,0,logical,1
+multcomp,mcp,2,0,0,logical,1
+multcomp,mcp2matrix,-1,0,0,any,1
+multcomp,mcp2matrix,0,0,0,"class<`aovlist`, `listof`>",1
+multcomp,mcp2matrix,0,0,1,"class<`aov`, `lm`>",1
+multcomp,mcp2matrix,0,0,2,class<`lm`>,1
+multcomp,mcp2matrix,0,0,3,class<`polr`>,1
+multcomp,mcp2matrix,0,0,4,"class<`colr`, `mlt`, `mlt_fit`, `mlt_setup`, `tram`>",1
+multcomp,mcp2matrix,0,0,5,class<`coxme`>,1
+multcomp,mcp2matrix,0,0,6,class<`coxph`>,1
+multcomp,mcp2matrix,0,0,7,"class<`glm`, `lm`>",1
+multcomp,mcp2matrix,0,0,8,class<`lme`>,1
+multcomp,mcp2matrix,0,0,9,class<`lmerMod`>,1
+multcomp,mcp2matrix,0,0,10,class<`survreg`>,1
+multcomp,mcp2matrix,1,0,0,any,1
+multcomp,meanslinfct,-1,0,0,class<`matrix`>,1
+multcomp,meanslinfct,0,0,0,"class<`aov`, `lm`>",1
+multcomp,meanslinfct,1,0,0,character,1
+multcomp,meanslinfct,2,0,0,class<`data.frame`>,1
+multcomp,meanslinfct,3,0,0,"class<`formula`, `terms`>",1
+multcomp,meanslinfct,4,0,0,null,1
+multcomp,mlf,-1,0,0,class<`mlf`>,1
+multcomp,mlf,0,0,0,...,1
+multcomp,mmm,-1,0,0,class<`mmm`>,1
+multcomp,mmm,0,0,0,...,1
+multcomp,model.frame.coxme,-1,0,0,class<`data.frame`>,1
+multcomp,model.frame.coxme,0,0,0,class<`coxme`>,1
+multcomp,model.frame.coxme,1,0,0,...,1
+multcomp,model.frame.lme,-1,0,0,"class<`data.frame`, `groupedData`, `nfGroupedData`, `nffGroupedData`>",1
+multcomp,model.frame.lme,-1,0,1,"class<`data.frame`, `groupedData`, `nfGroupedData`, `nfnGroupedData`>",1
+multcomp,model.frame.lme,0,0,0,class<`lme`>,1
+multcomp,model.frame.lme,1,0,0,...,1
+multcomp,model.matrix.aovlist,-1,0,0,any,1
+multcomp,model.matrix.aovlist,0,0,0,"class<`aovlist`, `listof`>",1
+multcomp,model.matrix.aovlist,1,0,0,...,1
+multcomp,model.matrix.coxme,-1,0,0,class<`matrix`>,1
+multcomp,model.matrix.coxme,0,0,0,class<`coxme`>,1
+multcomp,model.matrix.coxme,1,0,0,...,1
+multcomp,model.matrix.lme,-1,0,0,class<`matrix`>,1
+multcomp,model.matrix.lme,0,0,0,class<`lme`>,1
+multcomp,model.matrix.lme,1,0,0,...,1
+multcomp,model.matrix.polr,-1,0,0,class<`matrix`>,1
+multcomp,model.matrix.polr,0,0,0,class<`polr`>,1
+multcomp,model.matrix.polr,1,0,0,...,1
+multcomp,modelparm,-1,0,0,class<`modelparm`>,1
+multcomp,modelparm,0,0,0,"class<`aov`, `lm`>",1
+multcomp,modelparm,0,0,1,"class<`colr`, `mlt`, `mlt_fit`, `mlt_setup`, `tram`>",1
+multcomp,modelparm,0,0,2,class<`coxme`>,1
+multcomp,modelparm,0,0,3,class<`coxph`>,1
+multcomp,modelparm,0,0,4,class<`glmerMod`>,1
+multcomp,modelparm,0,0,5,"class<`glm`, `lm`>",1
+multcomp,modelparm,0,0,6,class<`lm`>,1
+multcomp,modelparm,0,0,7,class<`lme`>,1
+multcomp,modelparm,0,0,8,class<`lmerMod`>,1
+multcomp,modelparm,0,0,9,class<`lmrob`>,1
+multcomp,modelparm,0,0,10,class<`mmm`>,1
+multcomp,modelparm,0,0,11,class<`nls`>,1
+multcomp,modelparm,0,0,12,class<`parm`>,1
+multcomp,modelparm,0,0,13,class<`polr`>,1
+multcomp,modelparm,0,0,14,class<`survreg`>,1
+multcomp,modelparm,0,0,15,list<double[] | class<`matrix`>>,1
+multcomp,modelparm,1,0,0,any,1
+multcomp,modelparm,2,0,0,any,1
+multcomp,modelparm,3,0,0,any,1
+multcomp,modelparm,4,0,0,...,1
+multcomp,modelparm.coxme,-1,0,0,class<`modelparm`>,1
+multcomp,modelparm.coxme,0,0,0,class<`coxme`>,1
+multcomp,modelparm.coxme,1,0,0,class<`function`>,1
+multcomp,modelparm.coxme,2,0,0,class<`function`>,1
+multcomp,modelparm.coxme,3,0,0,null,1
+multcomp,modelparm.coxme,4,0,0,...,1
+multcomp,modelparm.default,-1,0,0,class<`modelparm`>,1
+multcomp,modelparm.default,0,0,0,class<`coxme`>,1
+multcomp,modelparm.default,0,0,1,class<`glmerMod`>,1
+multcomp,modelparm.default,0,0,2,class<`lme`>,1
+multcomp,modelparm.default,0,0,3,class<`lmerMod`>,1
+multcomp,modelparm.default,0,0,4,class<`polr`>,1
+multcomp,modelparm.default,0,0,5,class<`survreg`>,1
+multcomp,modelparm.default,0,0,6,"class<`aov`, `lm`>",1
+multcomp,modelparm.default,0,0,7,"class<`colr`, `mlt`, `mlt_fit`, `mlt_setup`, `tram`>",1
+multcomp,modelparm.default,0,0,8,class<`coxph`>,1
+multcomp,modelparm.default,0,0,9,"class<`glm`, `lm`>",1
+multcomp,modelparm.default,0,0,10,class<`lm`>,1
+multcomp,modelparm.default,0,0,11,class<`lmrob`>,1
+multcomp,modelparm.default,0,0,12,class<`mmm`>,1
+multcomp,modelparm.default,0,0,13,class<`nls`>,1
+multcomp,modelparm.default,0,0,14,class<`parm`>,1
+multcomp,modelparm.default,0,0,15,list<double[] | class<`matrix`>>,1
+multcomp,modelparm.default,1,0,0,class<`function`>,1
+multcomp,modelparm.default,2,0,0,class<`function`>,1
+multcomp,modelparm.default,3,0,0,null,1
+multcomp,modelparm.default,3,0,1,double,1
+multcomp,modelparm.default,4,0,0,...,1
+multcomp,modelparm.lme,-1,0,0,class<`modelparm`>,1
+multcomp,modelparm.lme,0,0,0,class<`lme`>,1
+multcomp,modelparm.lme,1,0,0,class<`function`>,1
+multcomp,modelparm.lme,2,0,0,class<`function`>,1
+multcomp,modelparm.lme,3,0,0,null,1
+multcomp,modelparm.lme,4,0,0,...,1
+multcomp,modelparm.merMod,-1,0,0,class<`modelparm`>,1
+multcomp,modelparm.merMod,0,0,0,class<`glmerMod`>,1
+multcomp,modelparm.merMod,0,0,1,class<`lmerMod`>,1
+multcomp,modelparm.merMod,1,0,0,class<`function`>,1
+multcomp,modelparm.merMod,2,0,0,class<`function`>,1
+multcomp,modelparm.merMod,3,0,0,null,1
+multcomp,modelparm.merMod,4,0,0,...,1
+multcomp,modelparm.polr,-1,0,0,class<`modelparm`>,1
+multcomp,modelparm.polr,0,0,0,class<`polr`>,1
+multcomp,modelparm.polr,1,0,0,class<`function`>,1
+multcomp,modelparm.polr,2,0,0,class<`function`>,1
+multcomp,modelparm.polr,3,0,0,null,1
+multcomp,modelparm.polr,4,0,0,...,1
+multcomp,modelparm.survreg,-1,0,0,class<`modelparm`>,1
+multcomp,modelparm.survreg,0,0,0,class<`survreg`>,1
+multcomp,modelparm.survreg,1,0,0,class<`function`>,1
+multcomp,modelparm.survreg,2,0,0,class<`function`>,1
+multcomp,modelparm.survreg,3,0,0,null,1
+multcomp,modelparm.survreg,4,0,0,...,1
+multcomp,MPinv,-1,0,0,list<class<`matrix`> | integer>,1
+multcomp,MPinv,0,0,0,class<`matrix`>,1
+multcomp,MPinv,1,0,0,double,1
+multcomp,parm,-1,0,0,class<`parm`>,1
+multcomp,parm,0,0,0,double[],1
+multcomp,parm,1,0,0,class<`matrix`>,1
+multcomp,parm,2,0,0,double,1
+multcomp,plot.cld,-1,0,0,"class<`table`, `xtabs`>",1
+multcomp,plot.cld,-1,0,1,double[],1
+multcomp,plot.cld,-1,0,2,list<list<double[]>>,1
+multcomp,plot.cld,0,0,0,class<`cld`>,1
+multcomp,plot.cld,1,0,0,character[],1
+multcomp,plot.cld,2,0,0,...,1
+multcomp,plot.confint.glht,-1,0,0,null,1
+multcomp,plot.confint.glht,0,0,0,"class<`confint.glht`, `glht`>",1
+multcomp,plot.confint.glht,1,0,0,any,1
+multcomp,plot.confint.glht,2,0,0,any,1
+multcomp,plot.confint.glht,3,0,0,any,1
+multcomp,plot.confint.glht,4,0,0,...,1
+multcomp,plot.glht,-1,0,0,null,1
+multcomp,plot.glht,0,0,0,class<`glht`>,1
+multcomp,plot.glht,1,0,0,...,1
+multcomp,pqglht,-1,0,0,class<`pqglht`>,1
+multcomp,pqglht,0,0,0,class<`glht`>,1
+multcomp,print.confint.glht,-1,0,0,"class<`confint.glht`, `glht`>",1
+multcomp,print.confint.glht,0,0,0,"class<`confint.glht`, `glht`>",1
+multcomp,print.confint.glht,1,0,0,double,1
+multcomp,print.confint.glht,2,0,0,...,1
+multcomp,print.glht,-1,0,0,"class<`glht`, `summary.gtest`>",1
+multcomp,print.glht,-1,0,1,class<`glht`>,1
+multcomp,print.glht,0,0,0,"class<`glht`, `summary.gtest`>",1
+multcomp,print.glht,0,0,1,class<`glht`>,1
+multcomp,print.glht,1,0,0,double,1
+multcomp,print.glht,2,0,0,...,1
+multcomp,print.summary.glht,-1,0,0,"class<`glht`, `summary.glht`>",1
+multcomp,print.summary.glht,0,0,0,"class<`glht`, `summary.glht`>",1
+multcomp,print.summary.glht,1,0,0,double,1
+multcomp,print.summary.glht,2,0,0,...,1
+multcomp,print.summary.gtest,-1,0,0,"class<`glht`, `summary.gtest`>",1
+multcomp,print.summary.gtest,0,0,0,"class<`glht`, `summary.gtest`>",1
+multcomp,print.summary.gtest,1,0,0,double,1
+multcomp,print.summary.gtest,2,0,0,...,1
+multcomp,rhs,-1,0,0,double,1
+multcomp,rhs,0,0,0,expression,1
+multcomp,side,-1,0,0,character,1
+multcomp,side,0,0,0,expression,1
+multcomp,summary.glht,-1,0,0,"class<`glht`, `summary.glht`>",1
+multcomp,summary.glht,-1,0,1,"class<`glht`, `summary.gtest`>",1
+multcomp,summary.glht,0,0,0,class<`glht`>,1
+multcomp,summary.glht,1,0,0,class<`function`>,1
+multcomp,summary.glht,2,0,0,...,1
+multcomp,sweepLetters,-1,0,0,class<`matrix`>,1
+multcomp,sweepLetters,0,0,0,class<`matrix`>,1
+multcomp,sweepLetters,1,0,0,double,1
+multcomp,sweepLetters,2,0,0,any,1
+multcomp,sweepLetters,3,0,0,character,1
+multcomp,univariate,-1,0,0,class<`function`>,1
+multcomp,vcov.glht,-1,0,0,class<`matrix`>,1
+multcomp,vcov.glht,0,0,0,class<`glht`>,1
+multcomp,vcov.glht,1,0,0,...,1
+multcomp,vcov.mmm,-1,0,0,class<`matrix`>,1
+multcomp,vcov.mmm,0,0,0,class<`mmm`>,1
+multcomp,vcov.mmm,1,0,0,...,1
+multcomp,vcov.parm,-1,0,0,class<`matrix`>,1
+multcomp,vcov.parm,0,0,0,class<`parm`>,1
+multcomp,vcov.parm,1,0,0,...,1
+multicool,allPerm,-1,0,0,class<`matrix`>,1
+multicool,allPerm,0,0,0,class<`mc`>,1
+multicool,B,-1,0,0,double[],1
+multicool,B,0,0,0,integer[],1
+multicool,Bell,-1,0,0,double[],1
+multicool,Bell,0,0,0,integer[],1
+multicool,Bell,0,0,1,double,1
+multicool,genComp,-1,0,0,list<double[]>,1
+multicool,genComp,0,0,0,double,1
+multicool,genComp,1,0,0,double,1
+multicool,genComp,2,0,0,logical,1
+multicool,generateCompositions,-1,0,0,list<integer[]>,1
+multicool,generateCompositions,0,0,0,double,1
+multicool,initMC,-1,0,0,class<`mc`>,1
+multicool,initMC,0,0,0,character[],1
+multicool,initMC,0,0,1,double[],1
+multicool,multinom,-1,0,0,double,1
+multicool,multinom,0,0,0,character[],1
+multicool,multinom,0,0,1,integer[],1
+multicool,multinom,1,0,0,logical,1
+multicool,multinom,2,0,0,logical,1
+multicool,nextPerm,-1,0,0,character[],1
+multicool,nextPerm,-1,0,1,double[],1
+multicool,nextPerm,0,0,0,class<`mc`>,1
+multicool,S2,-1,0,0,double[],1
+multicool,S2,0,0,0,double,1
+multicool,S2,0,0,1,integer[],1
+multicool,S2,1,0,0,integer[],1
+multicool,Stirling2,-1,0,0,double[],1
+multicool,Stirling2,0,0,0,double,1
+multicool,Stirling2,0,0,1,integer[],1
+multicool,Stirling2,1,0,0,integer[],1
+multicool,Stirling2,1,0,1,double,1
+multicool,Stirling2C,-1,0,0,double,1
+multicool,Stirling2C,0,0,0,double,1
+multicool,Stirling2C,1,0,0,double,1
+mvmeta,blup.mvmeta,-1,0,0,class<`matrix`>,1
+mvmeta,blup.mvmeta,-1,0,1,list<class<`matrix`>>,1
+mvmeta,blup.mvmeta,-1,0,2,list<list<double[] | class<`matrix`>>>,1
+mvmeta,blup.mvmeta,0,0,0,class<`mvmeta`>,1
+mvmeta,blup.mvmeta,1,0,0,logical,1
+mvmeta,blup.mvmeta,2,0,0,logical,1
+mvmeta,blup.mvmeta,3,0,0,logical,1
+mvmeta,blup.mvmeta,4,0,0,double,1
+mvmeta,blup.mvmeta,5,0,0,character[],1
+mvmeta,blup.mvmeta,6,0,0,character[],1
+mvmeta,blup.mvmeta,7,0,0,...,1
+mvmeta,checkPD,-1,0,0,class<`matrix`>,1
+mvmeta,checkPD,0,0,0,class<`matrix`>,1
+mvmeta,checkPD,1,0,0,integer,1
+mvmeta,checkPD,2,0,0,character,1
+mvmeta,coef.mvmeta,-1,0,0,class<`matrix`>,1
+mvmeta,coef.mvmeta,-1,0,1,double[],1
+mvmeta,coef.mvmeta,0,0,0,class<`mvmeta`>,1
+mvmeta,coef.mvmeta,1,0,0,character[],1
+mvmeta,coef.mvmeta,2,0,0,...,1
+mvmeta,fbtr,-1,0,0,class<`matrix`>,1
+mvmeta,fbtr,-1,0,1,double,1
+mvmeta,fbtr,0,0,0,class<`matrix`>,1
+mvmeta,fbtr,1,0,0,integer,1
+mvmeta,glsfit,-1,0,0,list<double[] | class<`matrix`> | list<class<`matrix`>>>,1
+mvmeta,glsfit,-1,0,1,list<double | class<`matrix`> | list<class<`matrix`>>>,1
+mvmeta,glsfit,0,0,0,list<class<`matrix`>>,1
+mvmeta,glsfit,1,0,0,list<double[]>,1
+mvmeta,glsfit,2,0,0,list<class<`matrix`>>,1
+mvmeta,glsfit,3,0,0,list<logical[]>,1
+mvmeta,glsfit,4,0,0,class<`matrix`>,1
+mvmeta,glsfit,5,0,0,logical,1
+mvmeta,gradchol.ml,-1,0,0,double[],1
+mvmeta,gradchol.ml,0,0,0,double[],1
+mvmeta,gradchol.ml,1,0,0,class<`matrix`>,1
+mvmeta,gradchol.ml,2,0,0,integer[],1
+mvmeta,gradchol.ml,3,0,0,integer[],1
+mvmeta,gradchol.ml,4,0,0,list<class<`matrix`>>,1
+mvmeta,gradchol.ml,5,0,0,list<double[]>,1
+mvmeta,gradchol.ml,6,0,0,list<logical[]>,1
+mvmeta,gradchol.ml,7,0,0,integer,1
+mvmeta,gradchol.ml,8,0,0,any,1
+mvmeta,gradchol.reml,-1,0,0,double[],1
+mvmeta,gradchol.reml,0,0,0,double[],1
+mvmeta,gradchol.reml,1,0,0,class<`matrix`>,1
+mvmeta,gradchol.reml,2,0,0,class<`matrix`>,1
+mvmeta,gradchol.reml,3,0,0,integer[],1
+mvmeta,gradchol.reml,4,0,0,integer[],1
+mvmeta,gradchol.reml,5,0,0,list<class<`matrix`>>,1
+mvmeta,gradchol.reml,6,0,0,list<class<`matrix`>>,1
+mvmeta,gradchol.reml,7,0,0,list<class<`matrix`>>,1
+mvmeta,gradchol.reml,8,0,0,list<logical[]>,1
+mvmeta,gradchol.reml,9,0,0,integer,1
+mvmeta,gradchol.reml,10,0,0,any,1
+mvmeta,initpar,-1,0,0,double[],1
+mvmeta,initpar,0,0,0,list<class<`matrix`>>,1
+mvmeta,initpar,1,0,0,list<double[]>,1
+mvmeta,initpar,2,0,0,list<class<`matrix`>>,1
+mvmeta,initpar,3,0,0,list<logical[]>,1
+mvmeta,initpar,4,0,0,integer,1
+mvmeta,initpar,5,0,0,any,1
+mvmeta,initpar,6,0,0,any,1
+mvmeta,initpar,7,0,0,character,1
+mvmeta,initpar,8,0,0,list<any>,1
+mvmeta,iter.igls,-1,0,0,class<`matrix`>,1
+mvmeta,iter.igls,0,0,0,class<`matrix`>,1
+mvmeta,iter.igls,1,0,0,list<class<`matrix`>>,1
+mvmeta,iter.igls,2,0,0,list<double[]>,1
+mvmeta,iter.igls,3,0,0,list<class<`matrix`>>,1
+mvmeta,iter.igls,4,0,0,list<logical[]>,1
+mvmeta,iter.igls,5,0,0,integer,1
+mvmeta,iter.igls,6,0,0,any,1
+mvmeta,logLik.mvmeta,-1,0,0,class<`logLik`>,1
+mvmeta,logLik.mvmeta,0,0,0,class<`mvmeta`>,1
+mvmeta,logLik.mvmeta,1,0,0,...,1
+mvmeta,mkS,-1,0,0,class<`matrix`>,1
+mvmeta,mkS,0,0,0,class<`data.frame`>,1
+mvmeta,mkS,0,0,1,class<`matrix`>,1
+mvmeta,mkS,0,0,2,^double[],1
+mvmeta,mkS,1,0,0,class<`matrix`>,1
+mvmeta,mkS,2,0,0,class<`exclude`>,1
+mvmeta,mkS,2,0,1,class<`omit`>,1
+mvmeta,mkS,2,0,2,null,1
+mvmeta,mkS,3,0,0,null,1
+mvmeta,model.frame.mvmeta,-1,0,0,"class<`data.frame`, `data.frame.mvmeta`>",1
+mvmeta,model.frame.mvmeta,0,0,0,class<`mvmeta`>,1
+mvmeta,model.frame.mvmeta,1,0,0,...,1
+mvmeta,model.matrix.mvmeta,-1,0,0,class<`matrix`>,1
+mvmeta,model.matrix.mvmeta,0,0,0,class<`mvmeta`>,1
+mvmeta,model.matrix.mvmeta,1,0,0,...,1
+mvmeta,mvmeta,-1,0,0,"class<`data.frame`, `data.frame.mvmeta`>",1
+mvmeta,mvmeta,-1,0,1,class<`mvmeta`>,1
+mvmeta,mvmeta,0,0,0,any,1
+mvmeta,mvmeta,1,0,0,any,1
+mvmeta,mvmeta,2,0,0,any,1
+mvmeta,mvmeta,3,0,0,any,1
+mvmeta,mvmeta,4,0,0,character,1
+mvmeta,mvmeta,5,0,0,character,1
+mvmeta,mvmeta,6,0,0,logical,1
+mvmeta,mvmeta,7,0,0,null,1
+mvmeta,mvmeta,8,0,0,any,1
+mvmeta,mvmeta,9,0,0,any,1
+mvmeta,mvmeta,10,0,0,any,1
+mvmeta,mvmeta.control,-1,0,0,list<any>,1
+mvmeta,mvmeta.control,0,0,0,list<any>,1
+mvmeta,mvmeta.control,1,0,0,logical,1
+mvmeta,mvmeta.control,2,0,0,double,1
+mvmeta,mvmeta.control,3,0,0,null,1
+mvmeta,mvmeta.control,4,0,0,class<`matrix`>,1
+mvmeta,mvmeta.control,4,0,1,null,1
+mvmeta,mvmeta.control,5,0,0,double,1
+mvmeta,mvmeta.control,6,0,0,double[],1
+mvmeta,mvmeta.control,7,0,0,logical,1
+mvmeta,mvmeta.control,8,0,0,double,1
+mvmeta,mvmeta.control,9,0,0,double,1
+mvmeta,mvmeta.control,10,0,0,logical,1
+mvmeta,mvmeta.control,11,0,0,logical,1
+mvmeta,mvmeta.control,12,0,0,double,1
+mvmeta,mvmeta.control,13,0,0,double,1
+mvmeta,mvmeta.fit,-1,0,0,list<any>,1
+mvmeta,mvmeta.fit,0,0,0,class<`matrix`>,1
+mvmeta,mvmeta.fit,1,0,0,class<`matrix`>,1
+mvmeta,mvmeta.fit,2,0,0,class<`matrix`>,1
+mvmeta,mvmeta.fit,3,0,0,null,1
+mvmeta,mvmeta.fit,4,0,0,character,1
+mvmeta,mvmeta.fit,5,0,0,character,1
+mvmeta,mvmeta.fit,6,0,0,list<any>,1
+mvmeta,mvmeta.fixed,-1,0,0,list<any>,1
+mvmeta,mvmeta.fixed,0,0,0,list<class<`matrix`>>,1
+mvmeta,mvmeta.fixed,1,0,0,list<double[]>,1
+mvmeta,mvmeta.fixed,2,0,0,list<class<`matrix`>>,1
+mvmeta,mvmeta.fixed,3,0,0,list<logical[]>,1
+mvmeta,mvmeta.fixed,4,0,0,integer,1
+mvmeta,mvmeta.fixed,5,0,0,integer,1
+mvmeta,mvmeta.fixed,6,0,0,integer,1
+mvmeta,mvmeta.fixed,7,0,0,integer,1
+mvmeta,mvmeta.fixed,8,0,0,list<double | null | list<double>>,1
+mvmeta,mvmeta.fixed,9,0,0,...,1
+mvmeta,mvmeta.ml,-1,0,0,list<any>,1
+mvmeta,mvmeta.ml,0,0,0,list<class<`matrix`>>,1
+mvmeta,mvmeta.ml,1,0,0,list<double[]>,1
+mvmeta,mvmeta.ml,2,0,0,list<class<`matrix`>>,1
+mvmeta,mvmeta.ml,3,0,0,list<logical[]>,1
+mvmeta,mvmeta.ml,4,0,0,integer,1
+mvmeta,mvmeta.ml,5,0,0,integer,1
+mvmeta,mvmeta.ml,6,0,0,integer,1
+mvmeta,mvmeta.ml,7,0,0,integer,1
+mvmeta,mvmeta.ml,8,0,0,character,1
+mvmeta,mvmeta.ml,9,0,0,list<double | null | list<double>>,1
+mvmeta,mvmeta.ml,10,0,0,...,1
+mvmeta,mvmeta.mm,-1,0,0,list<any>,1
+mvmeta,mvmeta.mm,0,0,0,list<class<`matrix`>>,1
+mvmeta,mvmeta.mm,1,0,0,list<double[]>,1
+mvmeta,mvmeta.mm,2,0,0,list<class<`matrix`>>,1
+mvmeta,mvmeta.mm,3,0,0,list<logical[]>,1
+mvmeta,mvmeta.mm,4,0,0,integer,1
+mvmeta,mvmeta.mm,5,0,0,integer,1
+mvmeta,mvmeta.mm,6,0,0,integer,1
+mvmeta,mvmeta.mm,7,0,0,integer,1
+mvmeta,mvmeta.mm,8,0,0,list<double | null | list<double>>,1
+mvmeta,mvmeta.mm,9,0,0,...,1
+mvmeta,mvmeta.reml,-1,0,0,list<any>,1
+mvmeta,mvmeta.reml,0,0,0,list<class<`matrix`>>,1
+mvmeta,mvmeta.reml,1,0,0,list<double[]>,1
+mvmeta,mvmeta.reml,2,0,0,list<class<`matrix`>>,1
+mvmeta,mvmeta.reml,3,0,0,list<logical[]>,1
+mvmeta,mvmeta.reml,4,0,0,integer,1
+mvmeta,mvmeta.reml,5,0,0,integer,1
+mvmeta,mvmeta.reml,6,0,0,integer,1
+mvmeta,mvmeta.reml,7,0,0,integer,1
+mvmeta,mvmeta.reml,8,0,0,character,1
+mvmeta,mvmeta.reml,9,0,0,list<any>,1
+mvmeta,mvmeta.reml,10,0,0,...,1
+mvmeta,mvmetaSim,-1,0,0,class<`matrix`>,1
+mvmeta,mvmetaSim,-1,0,1,list<class<`matrix`>>,1
+mvmeta,mvmetaSim,0,0,0,class<`matrix`>,1
+mvmeta,mvmetaSim,1,0,0,class<`matrix`>,1
+mvmeta,mvmetaSim,2,0,0,any,1
+mvmeta,mvmetaSim,3,0,0,any,1
+mvmeta,mvmetaSim,4,0,0,any,1
+mvmeta,mvmetaSim,5,0,0,double,1
+mvmeta,mvmetaSim,6,0,0,null,1
+mvmeta,mvmetaSim,7,0,0,any,1
+mvmeta,mvmeta.vc,-1,0,0,list<any>,1
+mvmeta,mvmeta.vc,0,0,0,list<class<`matrix`>>,1
+mvmeta,mvmeta.vc,1,0,0,list<double[]>,1
+mvmeta,mvmeta.vc,2,0,0,list<class<`matrix`>>,1
+mvmeta,mvmeta.vc,3,0,0,list<logical[]>,1
+mvmeta,mvmeta.vc,4,0,0,integer,1
+mvmeta,mvmeta.vc,5,0,0,integer,1
+mvmeta,mvmeta.vc,6,0,0,integer,1
+mvmeta,mvmeta.vc,7,0,0,integer,1
+mvmeta,mvmeta.vc,8,0,0,list<double | null | list<double>>,1
+mvmeta,mvmeta.vc,9,0,0,...,1
+mvmeta,mvSim,-1,0,0,class<`matrix`>,1
+mvmeta,mvSim,0,0,0,double,1
+mvmeta,mvSim,1,0,0,double[],1
+mvmeta,mvSim,2,0,0,class<`matrix`>,1
+mvmeta,mvSim,3,0,0,double,1
+mvmeta,mvSim,4,0,0,logical,1
+mvmeta,na.exclude.data.frame.mvmeta,-1,0,0,"class<`data.frame`, `data.frame.mvmeta`>",1
+mvmeta,na.exclude.data.frame.mvmeta,0,0,0,"class<`data.frame`, `data.frame.mvmeta`>",1
+mvmeta,na.exclude.data.frame.mvmeta,1,0,0,...,1
+mvmeta,na.omit.data.frame.mvmeta,-1,0,0,"class<`data.frame`, `data.frame.mvmeta`>",1
+mvmeta,na.omit.data.frame.mvmeta,0,0,0,"class<`data.frame`, `data.frame.mvmeta`>",1
+mvmeta,na.omit.data.frame.mvmeta,1,0,0,...,1
+mvmeta,par2Psi,-1,0,0,class<`matrix`>,1
+mvmeta,par2Psi,0,0,0,double[],1
+mvmeta,par2Psi,1,0,0,any,1
+mvmeta,par2Psi,2,0,0,character,1
+mvmeta,par2Psi,3,0,0,any,1
+mvmeta,predict.mvmeta,-1,0,0,list<list<double[] | class<`matrix`>>>,1
+mvmeta,predict.mvmeta,-1,0,1,list<class<`matrix`>>,1
+mvmeta,predict.mvmeta,0,0,0,class<`mvmeta`>,1
+mvmeta,predict.mvmeta,1,0,0,class<`data.frame`>,1
+mvmeta,predict.mvmeta,2,0,0,logical,1
+mvmeta,predict.mvmeta,3,0,0,logical,1
+mvmeta,predict.mvmeta,4,0,0,logical,1
+mvmeta,predict.mvmeta,5,0,0,character[],1
+mvmeta,predict.mvmeta,6,0,0,double,1
+mvmeta,predict.mvmeta,7,0,0,character[],1
+mvmeta,predict.mvmeta,8,0,0,character[],1
+mvmeta,predict.mvmeta,9,0,0,class<`function`>,1
+mvmeta,predict.mvmeta,10,0,0,...,1
+mvmeta,print.mvmeta,-1,0,0,null,1
+mvmeta,print.mvmeta,0,0,0,class<`mvmeta`>,1
+mvmeta,print.mvmeta,1,0,0,double,1
+mvmeta,print.mvmeta,2,0,0,...,1
+mvmeta,print.qtest.mvmeta,-1,0,0,null,1
+mvmeta,print.qtest.mvmeta,0,0,0,class<`qtest.mvmeta`>,1
+mvmeta,print.qtest.mvmeta,1,0,0,double,1
+mvmeta,print.qtest.mvmeta,2,0,0,...,1
+mvmeta,print.summary.mvmeta,-1,0,0,null,1
+mvmeta,print.summary.mvmeta,0,0,0,class<`summary.mvmeta`>,1
+mvmeta,print.summary.mvmeta,1,0,0,double,1
+mvmeta,print.summary.mvmeta,2,0,0,...,1
+mvmeta,qtest.mvmeta,-1,0,0,class<`qtest.mvmeta`>,1
+mvmeta,qtest.mvmeta,0,0,0,class<`mvmeta`>,1
+mvmeta,qtest.mvmeta,1,0,0,...,1
+mvmeta,simulate.mvmeta,-1,0,0,class<`matrix`>,1
+mvmeta,simulate.mvmeta,0,0,0,class<`mvmeta`>,1
+mvmeta,simulate.mvmeta,1,0,0,double,1
+mvmeta,simulate.mvmeta,2,0,0,null,1
+mvmeta,simulate.mvmeta,3,0,0,...,1
+mvmeta,sumlist,-1,0,0,class<`matrix`>,1
+mvmeta,sumlist,-1,0,1,double[],1
+mvmeta,sumlist,0,0,0,list<class<`matrix`>>,1
+mvmeta,sumlist,0,0,1,list<logical[]>,1
+mvmeta,summary.mvmeta,-1,0,0,class<`summary.mvmeta`>,1
+mvmeta,summary.mvmeta,0,0,0,class<`mvmeta`>,1
+mvmeta,summary.mvmeta,1,0,0,double,1
+mvmeta,summary.mvmeta,2,0,0,...,1
+mvmeta,vcov.mvmeta,-1,0,0,class<`matrix`>,1
+mvmeta,vcov.mvmeta,0,0,0,class<`mvmeta`>,1
+mvmeta,vcov.mvmeta,1,0,0,...,1
+mvtnorm,checkmvArgs,-1,0,0,list<double[] | class<`matrix`> | null>,1
+mvtnorm,checkmvArgs,-1,0,1,list<double[] | null | class<`matrix`>>,1
+mvtnorm,checkmvArgs,-1,0,2,list<double | null>,1
+mvtnorm,checkmvArgs,0,0,0,double[],1
+mvtnorm,checkmvArgs,1,0,0,double[],1
+mvtnorm,checkmvArgs,2,0,0,double[],1
+mvtnorm,checkmvArgs,3,0,0,class<`matrix`>,1
+mvtnorm,checkmvArgs,3,0,1,null,1
+mvtnorm,checkmvArgs,3,0,2,double,1
+mvtnorm,checkmvArgs,4,0,0,null,1
+mvtnorm,checkmvArgs,4,0,1,class<`matrix`>,1
+mvtnorm,checkmvArgs,4,0,2,double,1
+mvtnorm,chkcorr,-1,0,0,logical,1
+mvtnorm,chkcorr,0,0,0,class<`matrix`>,1
+mvtnorm,dmvnorm,-1,0,0,double,1
+mvtnorm,dmvnorm,0,0,0,class<`matrix`>,1
+mvtnorm,dmvnorm,0,0,1,double[],1
+mvtnorm,dmvnorm,1,0,0,double[],1
+mvtnorm,dmvnorm,2,0,0,class<`matrix`>,1
+mvtnorm,dmvnorm,3,0,0,logical,1
+mvtnorm,dmvt,-1,0,0,double,1
+mvtnorm,dmvt,0,0,0,double[],1
+mvtnorm,dmvt,1,0,0,double[],1
+mvtnorm,dmvt,2,0,0,class<`matrix`>,1
+mvtnorm,dmvt,3,0,0,double,1
+mvtnorm,dmvt,4,0,0,logical,1
+mvtnorm,dmvt,5,0,0,character,1
+mvtnorm,dots2GenzBretz,-1,0,0,list<class<`GenzBretz`> | null>,1
+mvtnorm,dots2GenzBretz,-1,0,1,list<null>,1
+mvtnorm,dots2GenzBretz,0,0,0,...,1
+mvtnorm,fitlr,-1,0,0,"class<`glm`, `lm`>",1
+mvtnorm,fitlr,0,0,0,double[],1
+mvtnorm,fitlr,1,0,0,double[],1
+mvtnorm,fitlr,2,0,0,double[],1
+mvtnorm,fitlr,3,0,0,character,1
+mvtnorm,GenzBretz,-1,0,0,class<`GenzBretz`>,1
+mvtnorm,GenzBretz,0,0,0,double,1
+mvtnorm,GenzBretz,1,0,0,double,1
+mvtnorm,GenzBretz,2,0,0,double,1
+mvtnorm,get_est,-1,0,0,double,1
+mvtnorm,get_est,0,0,0,"class<`glm`, `lm`>",1
+mvtnorm,get_est,1,0,0,double,1
+mvtnorm,getInt,-1,0,0,double[],1
+mvtnorm,getInt,0,0,0,double,1
+mvtnorm,getInt,1,0,0,double[],1
+mvtnorm,getInt,2,0,0,class<`matrix`>,1
+mvtnorm,getInt,3,0,0,character,1
+mvtnorm,getInt,4,0,0,character[],1
+mvtnorm,getInt,5,0,0,double,1
+mvtnorm,get_new_points,-1,0,0,double[],1
+mvtnorm,get_new_points,0,0,0,"class<`glm`, `lm`>",1
+mvtnorm,get_new_points,1,0,0,double,1
+mvtnorm,get_new_points,2,0,0,any,1
+mvtnorm,get_new_points,3,0,0,double,1
+mvtnorm,get_quant_loclin,-1,0,0,list<double>,1
+mvtnorm,get_quant_loclin,0,0,0,class<`function`>,1
+mvtnorm,get_quant_loclin,1,0,0,double,1
+mvtnorm,get_quant_loclin,2,0,0,double[],1
+mvtnorm,get_quant_loclin,3,0,0,double,1
+mvtnorm,get_quant_loclin,4,0,0,double,1
+mvtnorm,get_quant_loclin,5,0,0,character,1
+mvtnorm,get_quant_loclin,6,0,0,double,1
+mvtnorm,get_quant_loclin,7,0,0,logical,1
+mvtnorm,isInf,-1,0,0,logical[],1
+mvtnorm,isInf,0,0,0,double[],1
+mvtnorm,isNInf,-1,0,0,logical[],1
+mvtnorm,isNInf,0,0,0,double[],1
+mvtnorm,Miwa,-1,0,0,class<`Miwa`>,1
+mvtnorm,Miwa,0,0,0,double,1
+mvtnorm,mvt,-1,0,0,any,1
+mvtnorm,mvt,0,0,0,double[],1
+mvtnorm,mvt,1,0,0,double[],1
+mvtnorm,mvt,2,0,0,double,1
+mvtnorm,mvt,3,0,0,class<`matrix`>,1
+mvtnorm,mvt,4,0,0,any,1
+mvtnorm,mvt,5,0,0,any,1
+mvtnorm,mvt,6,0,0,...,1
+mvtnorm,pmvnorm,-1,0,0,double,1
+mvtnorm,pmvnorm,0,0,0,double[],1
+mvtnorm,pmvnorm,1,0,0,double[],1
+mvtnorm,pmvnorm,2,0,0,double[],1
+mvtnorm,pmvnorm,3,0,0,class<`matrix`>,1
+mvtnorm,pmvnorm,3,0,1,null,1
+mvtnorm,pmvnorm,4,0,0,null,1
+mvtnorm,pmvnorm,4,0,1,class<`matrix`>,1
+mvtnorm,pmvnorm,4,0,2,double,1
+mvtnorm,pmvnorm,5,0,0,any,1
+mvtnorm,pmvnorm,6,0,0,...,1
+mvtnorm,pmvt,-1,0,0,any,1
+mvtnorm,pmvt,0,0,0,double[],1
+mvtnorm,pmvt,1,0,0,double[],1
+mvtnorm,pmvt,2,0,0,double[],1
+mvtnorm,pmvt,3,0,0,double,1
+mvtnorm,pmvt,4,0,0,class<`matrix`>,1
+mvtnorm,pmvt,4,0,1,null,1
+mvtnorm,pmvt,5,0,0,null,1
+mvtnorm,pmvt,5,0,1,class<`matrix`>,1
+mvtnorm,pmvt,5,0,2,double,1
+mvtnorm,pmvt,6,0,0,any,1
+mvtnorm,pmvt,7,0,0,character[],1
+mvtnorm,predict_with_se,-1,0,0,list<double>,1
+mvtnorm,predict_with_se,0,0,0,"class<`glm`, `lm`>",1
+mvtnorm,predict_with_se,1,0,0,class<`data.frame`>,1
+mvtnorm,probval,-1,0,0,any,1
+mvtnorm,probval,0,0,0,class<`TVPACK`>,1
+mvtnorm,probval,0,0,1,class<`GenzBretz`>,1
+mvtnorm,probval,0,0,2,class<`Miwa`>,1
+mvtnorm,probval,1,0,0,...,1
+mvtnorm,probval.GenzBretz,-1,0,0,list<double[]>,1
+mvtnorm,probval.GenzBretz,0,0,0,class<`GenzBretz`>,1
+mvtnorm,probval.GenzBretz,1,0,0,integer,1
+mvtnorm,probval.GenzBretz,2,0,0,double,1
+mvtnorm,probval.GenzBretz,3,0,0,double[],1
+mvtnorm,probval.GenzBretz,4,0,0,double[],1
+mvtnorm,probval.GenzBretz,5,0,0,double[],1
+mvtnorm,probval.GenzBretz,6,0,0,any,1
+mvtnorm,probval.GenzBretz,7,0,0,double[],1
+mvtnorm,probval.Miwa,-1,0,0,list<double | null>,1
+mvtnorm,probval.Miwa,0,0,0,class<`Miwa`>,1
+mvtnorm,probval.Miwa,1,0,0,integer,1
+mvtnorm,probval.Miwa,2,0,0,double,1
+mvtnorm,probval.Miwa,3,0,0,double[],1
+mvtnorm,probval.Miwa,4,0,0,double[],1
+mvtnorm,probval.Miwa,5,0,0,double[],1
+mvtnorm,probval.Miwa,6,0,0,class<`matrix`>,1
+mvtnorm,probval.Miwa,7,0,0,any,1
+mvtnorm,probval.TVPACK,-1,0,0,any,1
+mvtnorm,probval.TVPACK,0,0,0,class<`TVPACK`>,1
+mvtnorm,probval.TVPACK,1,0,0,integer,1
+mvtnorm,probval.TVPACK,2,0,0,double,1
+mvtnorm,probval.TVPACK,3,0,0,any,1
+mvtnorm,probval.TVPACK,4,0,0,any,1
+mvtnorm,probval.TVPACK,5,0,0,any,1
+mvtnorm,probval.TVPACK,6,0,0,any,1
+mvtnorm,probval.TVPACK,7,0,0,any,1
+mvtnorm,qmvnorm,-1,0,0,list<double>,1
+mvtnorm,qmvnorm,0,0,0,double,1
+mvtnorm,qmvnorm,1,0,0,double[],1
+mvtnorm,qmvnorm,1,0,1,null,1
+mvtnorm,qmvnorm,2,0,0,character[],1
+mvtnorm,qmvnorm,3,0,0,double[],1
+mvtnorm,qmvnorm,4,0,0,class<`matrix`>,1
+mvtnorm,qmvnorm,4,0,1,null,1
+mvtnorm,qmvnorm,5,0,0,null,1
+mvtnorm,qmvnorm,5,0,1,class<`matrix`>,1
+mvtnorm,qmvnorm,6,0,0,class<`GenzBretz`>,1
+mvtnorm,qmvnorm,7,0,0,double,1
+mvtnorm,qmvt,-1,0,0,list<double>,1
+mvtnorm,qmvt,0,0,0,double,1
+mvtnorm,qmvt,1,0,0,null,1
+mvtnorm,qmvt,1,0,1,double[],1
+mvtnorm,qmvt,2,0,0,character[],1
+mvtnorm,qmvt,3,0,0,double,1
+mvtnorm,qmvt,4,0,0,double[],1
+mvtnorm,qmvt,5,0,0,double,1
+mvtnorm,qmvt,5,0,1,null,1
+mvtnorm,qmvt,5,0,2,class<`matrix`>,1
+mvtnorm,qmvt,6,0,0,null,1
+mvtnorm,qmvt,6,0,1,double,1
+mvtnorm,qmvt,6,0,2,class<`matrix`>,1
+mvtnorm,qmvt,7,0,0,any,1
+mvtnorm,rmvnorm,-1,0,0,class<`matrix`>,1
+mvtnorm,rmvnorm,0,0,0,double,1
+mvtnorm,rmvnorm,1,0,0,double[],1
+mvtnorm,rmvnorm,2,0,0,class<`matrix`>,1
+mvtnorm,rmvnorm,3,0,0,character[],1
+mvtnorm,rmvnorm,4,0,0,logical,1
+mvtnorm,rmvt,-1,0,0,any,1
+mvtnorm,rmvt,0,0,0,any,1
+mvtnorm,rmvt,1,0,0,class<`matrix`>,1
+mvtnorm,rmvt,2,0,0,double,1
+mvtnorm,rmvt,3,0,0,double[],1
+mvtnorm,rmvt,4,0,0,any,1
+mvtnorm,rmvt,5,0,0,...,1
+mvtnorm,sanitize_x,-1,0,0,double[],1
+mvtnorm,sanitize_x,0,0,0,double[],1
+mvtnorm,sanitize_x,1,0,0,double,1
+mvtnorm,sanitize_y,-1,0,0,double[],1
+mvtnorm,sanitize_y,0,0,0,double[],1
+mvtnorm,stop_crit,-1,0,0,list<logical>,1
+mvtnorm,stop_crit,0,0,0,double,1
+mvtnorm,stop_crit,1,0,0,"class<`glm`, `lm`>",1
+mvtnorm,stop_crit,2,0,0,double,1
+mvtnorm,stop_crit,3,0,0,double,1
+mvtnorm,stop_crit,4,0,0,double,1
+mvtnorm,TVPACK,-1,0,0,class<`TVPACK`>,1
+mvtnorm,TVPACK,0,0,0,double,1
+mvtnorm,wgts,-1,0,0,double[],1
+mvtnorm,wgts,0,0,0,double[],1
+mvtnorm,wgts,1,0,0,double,1
+nabor,knn,-1,0,0,list<class<`matrix`>>,1
+nabor,knn,0,0,0,class<`matrix`>,1
+nabor,knn,1,0,0,class<`matrix`>,1
+nabor,knn,2,0,0,double,1
+nabor,knn,3,0,0,double,1
+nabor,knn,4,0,0,character,1
+nabor,knn,4,0,1,integer,1
+nabor,knn,5,0,0,double,1
+nabor,WKNND,-1,0,0,any,1
+nabor,WKNND,0,0,0,...,1
+nabor,WKNNF,-1,0,0,class<`WKNNF`>,1
+nabor,WKNNF,0,0,0,...,1
+neuralnet,calculate.data.result,-1,0,0,class<`matrix`>,1
+neuralnet,calculate.data.result,0,0,0,class<`matrix`>,1
+neuralnet,calculate.data.result,1,0,0,class<`matrix`>,1
+neuralnet,calculate.data.result,2,0,0,any,1
+neuralnet,calculate.delta,-1,0,0,double[],1
+neuralnet,calculate.delta,0,0,0,double[],1
+neuralnet,calculate.delta,1,0,0,double[],1
+neuralnet,calculate.delta,2,0,0,double,1
+neuralnet,calculate.generalized.weights,-1,0,0,class<`matrix`>,1
+neuralnet,calculate.generalized.weights,0,0,0,list<class<`matrix`>>,1
+neuralnet,calculate.generalized.weights,1,0,0,list<class<`matrix`>>,1
+neuralnet,calculate.generalized.weights,2,0,0,class<`matrix`>,1
+neuralnet,calculate.gradients,-1,0,0,double[],1
+neuralnet,calculate.gradients,0,0,0,any,1
+neuralnet,calculate.gradients,1,0,0,integer,1
+neuralnet,calculate.gradients,2,0,0,list<class<`matrix`>>,1
+neuralnet,calculate.gradients,3,0,0,any,1
+neuralnet,calculate.gradients,4,0,0,class<`matrix`>,1
+neuralnet,calculate.gradients,5,0,0,double,1
+neuralnet,calculate.gradients,6,0,0,logical,1
+neuralnet,calculate.information.matrices,-1,0,0,list<double | class<`matrix`>>,1
+neuralnet,calculate.information.matrices,0,0,0,class<`matrix`>,1
+neuralnet,calculate.information.matrices,1,0,0,class<`matrix`>,1
+neuralnet,calculate.information.matrices,2,0,0,list<class<`matrix`>>,1
+neuralnet,calculate.information.matrices,3,0,0,class<`function`>,1
+neuralnet,calculate.information.matrices,4,0,0,class<`function`>,1
+neuralnet,calculate.information.matrices,5,0,0,null,1
+neuralnet,calculate.information.matrices,6,0,0,logical,1
+neuralnet,calculate.neuralnet,-1,0,0,list<class<`matrix`> | double[] | list<class<`matrix`>>>,1
+neuralnet,calculate.neuralnet,0,0,0,any,1
+neuralnet,calculate.neuralnet,1,0,0,list<character[]>,1
+neuralnet,calculate.neuralnet,2,0,0,double[],1
+neuralnet,calculate.neuralnet,3,0,0,double,1
+neuralnet,calculate.neuralnet,4,0,0,integer,1
+neuralnet,calculate.neuralnet,5,0,0,double,1
+neuralnet,calculate.neuralnet,6,0,0,list<double>,1
+neuralnet,calculate.neuralnet,7,0,0,list<double>,1
+neuralnet,calculate.neuralnet,8,0,0,character,1
+neuralnet,calculate.neuralnet,9,0,0,class<`matrix`>,1
+neuralnet,calculate.neuralnet,10,0,0,class<`matrix`>,1
+neuralnet,calculate.neuralnet,11,0,0,any,1
+neuralnet,calculate.neuralnet,12,0,0,null,1
+neuralnet,calculate.neuralnet,13,0,0,character,1
+neuralnet,calculate.neuralnet,14,0,0,class<`function`>,1
+neuralnet,calculate.neuralnet,15,0,0,class<`function`>,1
+neuralnet,calculate.predictions,-1,0,0,list<class<`matrix`>>,1
+neuralnet,calculate.predictions,0,0,0,class<`matrix`>,1
+neuralnet,calculate.predictions,1,0,0,class<`matrix`>,1
+neuralnet,calculate.predictions,2,0,0,"list<class<`glm`, `lm`>>",1
+neuralnet,calculate.predictions,2,0,1,null,1
+neuralnet,calculate.predictions,3,0,0,class<`matrix`>,1
+neuralnet,calculate.predictions,4,0,0,list<class<`matrix`>>,1
+neuralnet,calculate.predictions,5,0,0,list<character[]>,1
+neuralnet,compute.net,-1,0,0,list<class<`matrix`> | list<class<`matrix`>>>,1
+neuralnet,compute.net,0,0,0,list<class<`matrix`>>,1
+neuralnet,compute.net,1,0,0,integer,1
+neuralnet,compute.net,2,0,0,class<`matrix`>,1
+neuralnet,compute.net,3,0,0,any,1
+neuralnet,compute.net,4,0,0,any,1
+neuralnet,compute.net,5,0,0,class<`function`>,1
+neuralnet,compute.net,6,0,0,class<`function`>,1
+neuralnet,compute.net,7,0,0,logical,1
+neuralnet,confidence.interval,-1,0,0,list<double | list<list<class<`matrix`>>>>,1
+neuralnet,confidence.interval,0,0,0,class<`nn`>,1
+neuralnet,confidence.interval,1,0,0,double,1
+neuralnet,convert.activation.function,-1,0,0,list<class<`function`>>,1
+neuralnet,convert.activation.function,0,0,0,character,1
+neuralnet,convert.error.function,-1,0,0,list<class<`function`>>,1
+neuralnet,convert.error.function,0,0,0,character,1
+neuralnet,draw.text,-1,0,0,"class<`gDesc`, `grob`, `text`>",1
+neuralnet,draw.text,0,0,0,character,1
+neuralnet,draw.text,0,0,1,double,1
+neuralnet,draw.text,1,0,0,double[],1
+neuralnet,draw.text,2,0,0,double[],1
+neuralnet,draw.text,3,0,0,double[],1
+neuralnet,draw.text,3,0,1,class<`matrix`>,1
+neuralnet,draw.text,4,0,0,character,1
+neuralnet,draw.text,5,0,0,character[],1
+neuralnet,draw.text,6,0,0,...,1
+neuralnet,generate.output,-1,0,0,class<`nn`>,1
+neuralnet,generate.output,0,0,0,class<`matrix`>,1
+neuralnet,generate.output,1,0,0,class<`call`>,1
+neuralnet,generate.output,2,0,0,any,1
+neuralnet,generate.output,3,0,0,any,1
+neuralnet,generate.output,4,0,0,class<`matrix`>,1
+neuralnet,generate.output,5,0,0,any,1
+neuralnet,generate.output,6,0,0,list<character[]>,1
+neuralnet,generate.output,7,0,0,class<`matrix`>,1
+neuralnet,generate.output,8,0,0,class<`function`>,1
+neuralnet,generate.output,9,0,0,class<`function`>,1
+neuralnet,generate.output,10,0,0,class<`data.frame`>,1
+neuralnet,generate.output,11,0,0,list<list<class<`matrix`> | double[] | list<class<`matrix`>>>>,1
+neuralnet,generate.output,12,0,0,logical,1
+neuralnet,generate.output,13,0,0,null,1
+neuralnet,generate.startweights,-1,0,0,list<null | list<class<`matrix`>>>,1
+neuralnet,generate.startweights,0,0,0,list<character[]>,1
+neuralnet,generate.startweights,1,0,0,double[],1
+neuralnet,generate.startweights,2,0,0,null,1
+neuralnet,generate.startweights,3,0,0,integer,1
+neuralnet,generate.startweights,4,0,0,null,1
+neuralnet,generate.startweights,5,0,0,any,1
+neuralnet,get_weight_names,-1,0,0,character[],1
+neuralnet,get_weight_names,0,0,0,list<class<`matrix`>>,1
+neuralnet,get_weight_names,1,0,0,list<character[]>,1
+neuralnet,gwplot,-1,0,0,null,1
+neuralnet,gwplot,0,0,0,class<`nn`>,1
+neuralnet,gwplot,1,0,0,null,1
+neuralnet,gwplot,2,0,0,null,1
+neuralnet,gwplot,3,0,0,null,1
+neuralnet,gwplot,4,0,0,null,1
+neuralnet,gwplot,5,0,0,character,1
+neuralnet,gwplot,6,0,0,double,1
+neuralnet,gwplot,7,0,0,logical,1
+neuralnet,gwplot,8,0,0,character,1
+neuralnet,gwplot,9,0,0,character,1
+neuralnet,gwplot,10,0,0,...,1
+neuralnet,neuralnet,-1,0,0,class<`nn`>,1
+neuralnet,neuralnet,0,0,0,class<`formula`>,1
+neuralnet,neuralnet,1,0,0,class<`data.frame`>,1
+neuralnet,neuralnet,2,0,0,double[],1
+neuralnet,neuralnet,3,0,0,double,1
+neuralnet,neuralnet,4,0,0,double,1
+neuralnet,neuralnet,5,0,0,double,1
+neuralnet,neuralnet,6,0,0,null,1
+neuralnet,neuralnet,7,0,0,null,1
+neuralnet,neuralnet,8,0,0,list<double>,1
+neuralnet,neuralnet,9,0,0,null,1
+neuralnet,neuralnet,10,0,0,character,1
+neuralnet,neuralnet,11,0,0,double,1
+neuralnet,neuralnet,12,0,0,character,1
+neuralnet,neuralnet,13,0,0,character,1
+neuralnet,neuralnet,14,0,0,class<`function`>,1
+neuralnet,neuralnet,14,0,1,character,1
+neuralnet,neuralnet,15,0,0,logical,1
+neuralnet,plot.nn,-1,0,0,null,1
+neuralnet,plot.nn,0,0,0,class<`nn`>,1
+neuralnet,plot.nn,1,0,0,character,1
+neuralnet,plot.nn,2,0,0,null,1
+neuralnet,plot.nn,3,0,0,null,1
+neuralnet,plot.nn,4,0,0,double,1
+neuralnet,plot.nn,5,0,0,double,1
+neuralnet,plot.nn,6,0,0,logical,1
+neuralnet,plot.nn,7,0,0,double,1
+neuralnet,plot.nn,8,0,0,logical,1
+neuralnet,plot.nn,9,0,0,double,1
+neuralnet,plot.nn,10,0,0,character,1
+neuralnet,plot.nn,11,0,0,character,1
+neuralnet,plot.nn,12,0,0,character,1
+neuralnet,plot.nn,13,0,0,character,1
+neuralnet,plot.nn,14,0,0,character,1
+neuralnet,plot.nn,15,0,0,character,1
+neuralnet,plus,-1,0,0,list<double[] | list<class<`matrix`>>>,1
+neuralnet,plus,0,0,0,double[],1
+neuralnet,plus,1,0,0,double[],1
+neuralnet,plus,2,0,0,list<class<`matrix`>>,1
+neuralnet,plus,3,0,0,integer[],1
+neuralnet,plus,4,0,0,integer[],1
+neuralnet,plus,5,0,0,double[],1
+neuralnet,plus,6,0,0,any,1
+neuralnet,plus,7,0,0,any,1
+neuralnet,plus,8,0,0,double,1
+neuralnet,prediction,-1,0,0,list<class<`matrix`>>,1
+neuralnet,prediction,0,0,0,class<`nn`>,1
+neuralnet,prediction,1,0,0,"list<class<`glm`, `lm`>>",1
+neuralnet,prediction,1,0,1,null,1
+neuralnet,predict.nn,-1,0,0,class<`matrix`>,1
+neuralnet,predict.nn,0,0,0,class<`nn`>,1
+neuralnet,predict.nn,1,0,0,class<`data.frame`>,1
+neuralnet,predict.nn,2,0,0,double,1
+neuralnet,predict.nn,3,0,0,logical,1
+neuralnet,predict.nn,4,0,0,...,1
+neuralnet,relist,-1,0,0,list<class<`matrix`>>,1
+neuralnet,relist,0,0,0,double[],1
+neuralnet,relist,1,0,0,class<`array`>,1
+neuralnet,relist,1,0,1,integer[],1
+neuralnet,relist,2,0,0,class<`array`>,1
+neuralnet,relist,2,0,1,integer[],1
+neuralnet,rprop,-1,0,0,list<double | class<`matrix`> | list<class<`matrix`>>>,1
+neuralnet,rprop,0,0,0,list<class<`matrix`>>,1
+neuralnet,rprop,1,0,0,class<`matrix`>,1
+neuralnet,rprop,2,0,0,class<`matrix`>,1
+neuralnet,rprop,3,0,0,double,1
+neuralnet,rprop,4,0,0,list<double>,1
+neuralnet,rprop,5,0,0,list<double>,1
+neuralnet,rprop,6,0,0,double,1
+neuralnet,rprop,7,0,0,character,1
+neuralnet,rprop,8,0,0,any,1
+neuralnet,rprop,9,0,0,class<`function`>,1
+neuralnet,rprop,10,0,0,class<`function`>,1
+neuralnet,rprop,11,0,0,any,1
+neuralnet,rprop,12,0,0,any,1
+neuralnet,rprop,13,0,0,character,1
+neuralnet,rprop,14,0,0,logical,1
+neuralnet,rprop,15,0,0,null,1
+nleqslv,nleqslv,-1,0,0,any,1
+nleqslv,nleqslv,0,0,0,class<`function`>,1
+nleqslv,nleqslv,0,0,1,double[],1
+nleqslv,nleqslv,1,0,0,any,1
+nleqslv,nleqslv,2,0,0,null,1
+nleqslv,nleqslv,2,0,1,class<`function`>,1
+nleqslv,nleqslv,3,0,0,...,1
+nleqslv,nleqslv,4,0,0,character[],1
+nleqslv,nleqslv,5,0,0,character[],1
+nleqslv,nleqslv,6,0,0,character[],1
+nleqslv,nleqslv,7,0,0,logical,1
+nleqslv,nleqslv,8,0,0,list<any>,1
+nleqslv,print.test.nleqslv,-1,0,0,class<`test.nleqslv`>,1
+nleqslv,print.test.nleqslv,0,0,0,class<`test.nleqslv`>,1
+nleqslv,print.test.nleqslv,1,0,0,double,1
+nleqslv,print.test.nleqslv,2,0,0,integer,1
+nleqslv,print.test.nleqslv,3,0,0,...,1
+nleqslv,searchZeros,-1,0,0,list<class<`matrix`> | double[]>,1
+nleqslv,searchZeros,0,0,0,class<`matrix`>,1
+nleqslv,searchZeros,1,0,0,class<`function`>,1
+nleqslv,searchZeros,2,0,0,integer,1
+nleqslv,searchZeros,3,0,0,...,1
+nleqslv,testnslv,-1,0,0,class<`test.nleqslv`>,1
+nleqslv,testnslv,0,0,0,double[],1
+nleqslv,testnslv,1,0,0,class<`function`>,1
+nleqslv,testnslv,2,0,0,null,1
+nleqslv,testnslv,3,0,0,...,1
+nleqslv,testnslv,4,0,0,character[],1
+nleqslv,testnslv,5,0,0,character[],1
+nleqslv,testnslv,6,0,0,integer,1
+nleqslv,testnslv,7,0,0,null,1
+nlme,%||%,-1,0,0,character,1
+nlme,%||%,-1,0,1,class<`function`>,1
+nlme,%||%,0,0,0,character,1
+nlme,%||%,0,0,1,null,1
+nlme,%||%,1,0,0,any,1
+nlme,ACF,-1,0,0,"class<`ACF`, `data.frame`>",1
+nlme,ACF,0,0,0,class<`gls`>,1
+nlme,ACF,0,0,1,"class<`gls`, `gnls`>",1
+nlme,ACF,0,0,2,class<`lme`>,1
+nlme,ACF,1,0,0,any,1
+nlme,ACF,2,0,0,...,1
+nlme,ACF.gls,-1,0,0,"class<`ACF`, `data.frame`>",1
+nlme,ACF.gls,0,0,0,class<`gls`>,1
+nlme,ACF.gls,0,0,1,"class<`gls`, `gnls`>",1
+nlme,ACF.gls,1,0,0,any,1
+nlme,ACF.gls,2,0,0,character[],1
+nlme,ACF.gls,3,0,0,class<`formula`>,1
+nlme,ACF.gls,4,0,0,class<`function`>,1
+nlme,ACF.gls,5,0,0,...,1
+nlme,ACF.lme,-1,0,0,"class<`ACF`, `data.frame`>",1
+nlme,ACF.lme,0,0,0,class<`lme`>,1
+nlme,ACF.lme,1,0,0,double,1
+nlme,ACF.lme,2,0,0,character[],1
+nlme,ACF.lme,3,0,0,...,1
+nlme,allCoef,-1,0,0,double[],1
+nlme,allCoef,0,0,0,...,1
+nlme,allCoef,1,0,0,class<`function`>,1
+nlme,allVarsRec,-1,0,0,character[],1
+nlme,allVarsRec,-1,0,1,null,1
+nlme,allVarsRec,0,0,0,list<any>,1
+nlme,allVarsRec,0,0,1,class<`call`>,1
+nlme,allVarsRec,0,0,2,class<`formula`>,1
+nlme,allVarsRec,0,0,3,"class<`formula`, `terms`>",1
+nlme,allVarsRec,0,0,4,class<`listForm`>,1
+nlme,allVarsRec,0,0,5,double,1
+nlme,allVarsRec,0,0,6,null,1
+nlme,anova.gls,-1,0,0,"class<`anova.lme`, `data.frame`>",1
+nlme,anova.gls,0,0,0,class<`gls`>,1
+nlme,anova.gls,0,0,1,"class<`gls`, `gnls`>",1
+nlme,anova.gls,1,0,0,...,1
+nlme,anova.gls,2,0,0,logical,1
+nlme,anova.gls,3,0,0,any,1
+nlme,anova.gls,4,0,0,null,1
+nlme,anova.gls,5,0,0,any,1
+nlme,anova.gls,6,0,0,any,1
+nlme,anova.gls,7,0,0,logical,1
+nlme,anova.lme,-1,0,0,"class<`anova.lme`, `data.frame`>",1
+nlme,anova.lme,0,0,0,class<`gls`>,1
+nlme,anova.lme,0,0,1,class<`lme`>,1
+nlme,anova.lme,0,0,2,"class<`lme`, `nlme`>",1
+nlme,anova.lme,1,0,0,...,1
+nlme,anova.lme,2,0,0,logical,1
+nlme,anova.lme,3,0,0,any,1
+nlme,anova.lme,4,0,0,logical,1
+nlme,anova.lme,5,0,0,any,1
+nlme,anova.lme,6,0,0,any,1
+nlme,anova.lme,7,0,0,logical,1
+nlme,as.data.frame.groupedData,-1,0,0,class<`data.frame`>,1
+nlme,as.data.frame.groupedData,0,0,0,"class<`data.frame`, `groupedData`, `nfGroupedData`, `nffGroupedData`>",1
+nlme,as.data.frame.groupedData,0,0,1,"class<`data.frame`, `groupedData`, `nfGroupedData`, `nfnGroupedData`>",1
+nlme,as.data.frame.groupedData,0,0,2,"class<`data.frame`, `groupedData`, `nmGroupedData`>",1
+nlme,as.data.frame.groupedData,1,0,0,null,1
+nlme,as.data.frame.groupedData,2,0,0,logical,1
+nlme,as.data.frame.groupedData,3,0,0,...,1
+nlme,as.matrix.corStruct,-1,0,0,list<class<`matrix`>>,1
+nlme,as.matrix.corStruct,0,0,0,"class<`corAR1`, `corStruct`>",1
+nlme,as.matrix.corStruct,1,0,0,...,1
+nlme,as.matrix.pdMat,-1,0,0,class<`matrix`>,1
+nlme,as.matrix.pdMat,-1,0,1,list<class<`matrix`>>,1
+nlme,as.matrix.pdMat,0,0,0,"class<`pdLogChol`, `pdMat`, `pdSymm`>",1
+nlme,as.matrix.pdMat,0,0,1,"class<`pdMat`, `pdSymm`>",1
+nlme,as.matrix.pdMat,0,0,2,"class<`pdCompSymm`, `pdMat`>",1
+nlme,as.matrix.pdMat,0,0,3,"class<`pdDiag`, `pdMat`>",1
+nlme,as.matrix.pdMat,0,0,4,class<`reStruct`>,1
+nlme,as.matrix.pdMat,1,0,0,...,1
+nlme,as.matrix.reStruct,-1,0,0,class<`matrix`>,1
+nlme,as.matrix.reStruct,-1,0,1,list<class<`matrix`>>,1
+nlme,as.matrix.reStruct,0,0,0,"class<`pdLogChol`, `pdMat`, `pdSymm`>",1
+nlme,as.matrix.reStruct,0,0,1,"class<`pdMat`, `pdSymm`>",1
+nlme,as.matrix.reStruct,0,0,2,"class<`pdCompSymm`, `pdMat`>",1
+nlme,as.matrix.reStruct,0,0,3,"class<`pdDiag`, `pdMat`>",1
+nlme,as.matrix.reStruct,0,0,4,class<`reStruct`>,1
+nlme,as.matrix.reStruct,1,0,0,...,1
+nlme,asOneFormula,-1,0,0,class<`formula`>,1
+nlme,asOneFormula,0,0,0,...,1
+nlme,asOneFormula,1,0,0,character[],1
+nlme,asOneFormula,1,0,1,list<character>,1
+nlme,asTable,-1,0,0,class<`table`>,1
+nlme,asTable,0,0,0,"class<`data.frame`, `groupedData`, `nfGroupedData`, `nffGroupedData`>",1
+nlme,asTable,0,0,1,"class<`data.frame`, `groupedData`, `nfGroupedData`, `nfnGroupedData`>",1
+nlme,asTable.groupedData,-1,0,0,class<`table`>,1
+nlme,asTable.groupedData,0,0,0,"class<`data.frame`, `groupedData`, `nfGroupedData`, `nffGroupedData`>",1
+nlme,asTable.groupedData,0,0,1,"class<`data.frame`, `groupedData`, `nfGroupedData`, `nfnGroupedData`>",1
+nlme,augPred,-1,0,0,"class<`augPred`, `data.frame`>",1
+nlme,augPred,0,0,0,class<`lme`>,1
+nlme,augPred,0,0,1,"class<`lme`, `nlme`>",1
+nlme,augPred,1,0,0,null,1
+nlme,augPred,2,0,0,any,1
+nlme,augPred,3,0,0,any,1
+nlme,augPred,4,0,0,double,1
+nlme,augPred,5,0,0,...,1
+nlme,augPred.lme,-1,0,0,"class<`augPred`, `data.frame`>",1
+nlme,augPred.lme,0,0,0,class<`lme`>,1
+nlme,augPred.lme,0,0,1,"class<`lme`, `nlme`>",1
+nlme,augPred.lme,1,0,0,null,1
+nlme,augPred.lme,2,0,0,double,1
+nlme,augPred.lme,3,0,0,double,1
+nlme,augPred.lme,4,0,0,double,1
+nlme,augPred.lme,5,0,0,double[],1
+nlme,augPred.lme,5,0,1,null,1
+nlme,augPred.lme,6,0,0,...,1
+nlme,balancedGrouped,-1,0,0,"class<`data.frame`, `groupedData`, `nfGroupedData`, `nffGroupedData`>",1
+nlme,balancedGrouped,-1,0,1,"class<`data.frame`, `groupedData`, `nfGroupedData`, `nfnGroupedData`>",1
+nlme,balancedGrouped,0,0,0,class<`formula`>,1
+nlme,balancedGrouped,1,0,0,class<`table`>,1
+nlme,balancedGrouped,2,0,0,null,1
+nlme,balancedGrouped,2,0,1,list<character>,1
+nlme,balancedGrouped,3,0,0,null,1
+nlme,balancedGrouped,3,0,1,list<character>,1
+nlme,c_deparse,-1,0,0,character,1
+nlme,c_deparse,0,0,0,...,1
+nlme,coef<-,-1,0,0,"class<`corAR1`, `corStruct`>",1
+nlme,coef<-,-1,0,1,"class<`corARMA`, `corStruct`>",1
+nlme,coef<-,-1,0,2,"class<`corCAR1`, `corStruct`>",1
+nlme,coef<-,-1,0,3,"class<`corCompSymm`, `corStruct`>",1
+nlme,coef<-,-1,0,4,"class<`corExp`, `corSpatial`, `corStruct`>",1
+nlme,coef<-,-1,0,5,"class<`corGaus`, `corSpatial`, `corStruct`>",1
+nlme,coef<-,-1,0,6,"class<`corLin`, `corSpatial`, `corStruct`>",1
+nlme,coef<-,-1,0,7,"class<`corNatural`, `corStruct`>",1
+nlme,coef<-,-1,0,8,"class<`corRatio`, `corSpatial`, `corStruct`>",1
+nlme,coef<-,-1,0,9,"class<`corSpatial`, `corSpher`, `corStruct`>",1
+nlme,coef<-,-1,0,10,"class<`corStruct`, `corSymm`>",1
+nlme,coef<-,-1,0,11,"class<`glsStruct`, `gnlsStruct`, `modelStruct`>",1
+nlme,coef<-,-1,0,12,"class<`glsStruct`, `modelStruct`>",1
+nlme,coef<-,-1,0,13,"class<`lmeStruct`, `lmeStructInt`, `modelStruct`>",1
+nlme,coef<-,-1,0,14,"class<`lmeStruct`, `lmeStructInt`, `modelStruct`, `nlmeStruct`>",1
+nlme,coef<-,-1,0,15,"class<`lmeStruct`, `modelStruct`>",1
+nlme,coef<-,-1,0,16,"class<`lmeStruct`, `modelStruct`, `nlmeStruct`>",1
+nlme,coef<-,-1,0,17,"class<`pdBlocked`, `pdMat`>",1
+nlme,coef<-,-1,0,18,"class<`pdCompSymm`, `pdMat`>",1
+nlme,coef<-,-1,0,19,"class<`pdDiag`, `pdMat`>",1
+nlme,coef<-,-1,0,20,"class<`pdIdent`, `pdMat`>",1
+nlme,coef<-,-1,0,21,"class<`pdLogChol`, `pdMat`, `pdSymm`>",1
+nlme,coef<-,-1,0,22,"class<`pdMat`, `pdNatural`>",1
+nlme,coef<-,-1,0,23,"class<`pdMat`, `pdSymm`>",1
+nlme,coef<-,-1,0,24,class<`reStruct`>,1
+nlme,coef<-,-1,0,25,"class<`varFunc`, `varIdent`>",1
+nlme,coef<-,-1,0,26,"class<`varFunc`, `varPower`>",1
+nlme,coef<-,0,0,0,"class<`corAR1`, `corStruct`>",1
+nlme,coef<-,0,0,1,"class<`corARMA`, `corStruct`>",1
+nlme,coef<-,0,0,2,"class<`corCAR1`, `corStruct`>",1
+nlme,coef<-,0,0,3,"class<`corCompSymm`, `corStruct`>",1
+nlme,coef<-,0,0,4,"class<`corExp`, `corSpatial`, `corStruct`>",1
+nlme,coef<-,0,0,5,"class<`corGaus`, `corSpatial`, `corStruct`>",1
+nlme,coef<-,0,0,6,"class<`corLin`, `corSpatial`, `corStruct`>",1
+nlme,coef<-,0,0,7,"class<`corNatural`, `corStruct`>",1
+nlme,coef<-,0,0,8,"class<`corRatio`, `corSpatial`, `corStruct`>",1
+nlme,coef<-,0,0,9,"class<`corSpatial`, `corSpher`, `corStruct`>",1
+nlme,coef<-,0,0,10,"class<`corStruct`, `corSymm`>",1
+nlme,coef<-,0,0,11,"class<`glsStruct`, `gnlsStruct`, `modelStruct`>",1
+nlme,coef<-,0,0,12,"class<`glsStruct`, `modelStruct`>",1
+nlme,coef<-,0,0,13,"class<`lmeStruct`, `lmeStructInt`, `modelStruct`>",1
+nlme,coef<-,0,0,14,"class<`lmeStruct`, `lmeStructInt`, `modelStruct`, `nlmeStruct`>",1
+nlme,coef<-,0,0,15,"class<`lmeStruct`, `modelStruct`>",1
+nlme,coef<-,0,0,16,"class<`lmeStruct`, `modelStruct`, `nlmeStruct`>",1
+nlme,coef<-,0,0,17,"class<`pdBlocked`, `pdMat`>",1
+nlme,coef<-,0,0,18,"class<`pdCompSymm`, `pdMat`>",1
+nlme,coef<-,0,0,19,"class<`pdDiag`, `pdMat`>",1
+nlme,coef<-,0,0,20,"class<`pdIdent`, `pdMat`>",1
+nlme,coef<-,0,0,21,"class<`pdLogChol`, `pdMat`, `pdSymm`>",1
+nlme,coef<-,0,0,22,"class<`pdMat`, `pdNatural`>",1
+nlme,coef<-,0,0,23,"class<`pdMat`, `pdSymm`>",1
+nlme,coef<-,0,0,24,class<`reStruct`>,1
+nlme,coef<-,0,0,25,"class<`varFunc`, `varIdent`>",1
+nlme,coef<-,0,0,26,"class<`varFunc`, `varPower`>",1
+nlme,coef<-,1,0,0,...,1
+nlme,coef<-,2,0,0,double[],1
+nlme,coef<-.corAR1,-1,0,0,"class<`corAR1`, `corStruct`>",1
+nlme,coef<-.corAR1,0,0,0,"class<`corAR1`, `corStruct`>",1
+nlme,coef<-.corAR1,1,0,0,...,1
+nlme,coef<-.corAR1,2,0,0,double,1
+nlme,coef.corAR1,-1,0,0,double,1
+nlme,coef.corAR1,0,0,0,"class<`corAR1`, `corStruct`>",1
+nlme,coef.corAR1,1,0,0,logical,1
+nlme,coef.corAR1,2,0,0,...,1
+nlme,coef<-.corARMA,-1,0,0,"class<`corARMA`, `corStruct`>",1
+nlme,coef<-.corARMA,0,0,0,"class<`corARMA`, `corStruct`>",1
+nlme,coef<-.corARMA,1,0,0,...,1
+nlme,coef<-.corARMA,2,0,0,double[],1
+nlme,coef.corARMA,-1,0,0,double[],1
+nlme,coef.corARMA,0,0,0,"class<`corARMA`, `corStruct`>",1
+nlme,coef.corARMA,1,0,0,logical,1
+nlme,coef.corARMA,2,0,0,...,1
+nlme,coef<-.corCAR1,-1,0,0,"class<`corCAR1`, `corStruct`>",1
+nlme,coef<-.corCAR1,0,0,0,"class<`corCAR1`, `corStruct`>",1
+nlme,coef<-.corCAR1,1,0,0,...,1
+nlme,coef<-.corCAR1,2,0,0,double,1
+nlme,coef.corCAR1,-1,0,0,double,1
+nlme,coef.corCAR1,0,0,0,"class<`corCAR1`, `corStruct`>",1
+nlme,coef.corCAR1,1,0,0,logical,1
+nlme,coef.corCAR1,2,0,0,...,1
+nlme,coef<-.corCompSymm,-1,0,0,"class<`corCompSymm`, `corStruct`>",1
+nlme,coef<-.corCompSymm,0,0,0,"class<`corCompSymm`, `corStruct`>",1
+nlme,coef<-.corCompSymm,1,0,0,...,1
+nlme,coef<-.corCompSymm,2,0,0,double,1
+nlme,coef.corCompSymm,-1,0,0,double,1
+nlme,coef.corCompSymm,0,0,0,"class<`corCompSymm`, `corStruct`>",1
+nlme,coef.corCompSymm,1,0,0,logical,1
+nlme,coef.corCompSymm,2,0,0,...,1
+nlme,coef.corLin,-1,0,0,double[],1
+nlme,coef.corLin,0,0,0,"class<`corLin`, `corSpatial`, `corStruct`>",1
+nlme,coef.corLin,0,0,1,"class<`corSpatial`, `corSpher`, `corStruct`>",1
+nlme,coef.corLin,1,0,0,logical,1
+nlme,coef.corLin,2,0,0,...,1
+nlme,coef<-.corNatural,-1,0,0,"class<`corNatural`, `corStruct`>",1
+nlme,coef<-.corNatural,0,0,0,"class<`corNatural`, `corStruct`>",1
+nlme,coef<-.corNatural,1,0,0,...,1
+nlme,coef<-.corNatural,2,0,0,double[],1
+nlme,coef.corNatural,-1,0,0,double[],1
+nlme,coef.corNatural,0,0,0,"class<`corNatural`, `corStruct`>",1
+nlme,coef.corNatural,1,0,0,logical,1
+nlme,coef.corNatural,2,0,0,...,1
+nlme,coef<-.corSpatial,-1,0,0,"class<`corExp`, `corSpatial`, `corStruct`>",1
+nlme,coef<-.corSpatial,-1,0,1,"class<`corGaus`, `corSpatial`, `corStruct`>",1
+nlme,coef<-.corSpatial,-1,0,2,"class<`corLin`, `corSpatial`, `corStruct`>",1
+nlme,coef<-.corSpatial,-1,0,3,"class<`corRatio`, `corSpatial`, `corStruct`>",1
+nlme,coef<-.corSpatial,-1,0,4,"class<`corSpatial`, `corSpher`, `corStruct`>",1
+nlme,coef<-.corSpatial,0,0,0,"class<`corExp`, `corSpatial`, `corStruct`>",1
+nlme,coef<-.corSpatial,0,0,1,"class<`corGaus`, `corSpatial`, `corStruct`>",1
+nlme,coef<-.corSpatial,0,0,2,"class<`corLin`, `corSpatial`, `corStruct`>",1
+nlme,coef<-.corSpatial,0,0,3,"class<`corRatio`, `corSpatial`, `corStruct`>",1
+nlme,coef<-.corSpatial,0,0,4,"class<`corSpatial`, `corSpher`, `corStruct`>",1
+nlme,coef<-.corSpatial,1,0,0,...,1
+nlme,coef<-.corSpatial,2,0,0,double[],1
+nlme,coef.corSpatial,-1,0,0,double[],1
+nlme,coef.corSpatial,0,0,0,"class<`corExp`, `corSpatial`, `corStruct`>",1
+nlme,coef.corSpatial,0,0,1,"class<`corGaus`, `corSpatial`, `corStruct`>",1
+nlme,coef.corSpatial,0,0,2,"class<`corLin`, `corSpatial`, `corStruct`>",1
+nlme,coef.corSpatial,0,0,3,"class<`corRatio`, `corSpatial`, `corStruct`>",1
+nlme,coef.corSpatial,0,0,4,"class<`corSpatial`, `corSpher`, `corStruct`>",1
+nlme,coef.corSpatial,1,0,0,logical,1
+nlme,coef.corSpatial,2,0,0,...,1
+nlme,coef.corSpher,-1,0,0,double[],1
+nlme,coef.corSpher,0,0,0,"class<`corLin`, `corSpatial`, `corStruct`>",1
+nlme,coef.corSpher,0,0,1,"class<`corSpatial`, `corSpher`, `corStruct`>",1
+nlme,coef.corSpher,1,0,0,logical,1
+nlme,coef.corSpher,2,0,0,...,1
+nlme,coef<-.corSymm,-1,0,0,"class<`corStruct`, `corSymm`>",1
+nlme,coef<-.corSymm,0,0,0,"class<`corStruct`, `corSymm`>",1
+nlme,coef<-.corSymm,1,0,0,...,1
+nlme,coef<-.corSymm,2,0,0,double[],1
+nlme,coef.corSymm,-1,0,0,double[],1
+nlme,coef.corSymm,0,0,0,"class<`corStruct`, `corSymm`>",1
+nlme,coef.corSymm,1,0,0,logical,1
+nlme,coef.corSymm,2,0,0,...,1
+nlme,coef.gls,-1,0,0,double[],1
+nlme,coef.gls,0,0,0,class<`gls`>,1
+nlme,coef.gls,1,0,0,logical,1
+nlme,coef.gls,2,0,0,...,1
+nlme,coef.gnls,-1,0,0,double[],1
+nlme,coef.gnls,0,0,0,"class<`gls`, `gnls`>",1
+nlme,coef.gnls,1,0,0,...,1
+nlme,coef.lme,-1,0,0,"class<`coef.lme`, `data.frame`, `ranef.lme`>",1
+nlme,coef.lme,0,0,0,class<`lme`>,1
+nlme,coef.lme,1,0,0,logical,1
+nlme,coef.lme,2,0,0,integer,1
+nlme,coef.lme,3,0,0,any,1
+nlme,coef.lme,4,0,0,any,1
+nlme,coef.lme,5,0,0,any,1
+nlme,coef.lme,6,0,0,logical,1
+nlme,coef.lme,7,0,0,null,1
+nlme,coef.lmList,-1,0,0,"class<`coef.lmList`, `data.frame`, `ranef.lmList`>",1
+nlme,coef.lmList,0,0,0,"class<`lmList`, `nlsList`>",1
+nlme,coef.lmList,0,0,1,class<`lmList`>,1
+nlme,coef.lmList,1,0,0,logical,1
+nlme,coef.lmList,2,0,0,any,1
+nlme,coef.lmList,3,0,0,any,1
+nlme,coef.lmList,4,0,0,any,1
+nlme,coef.lmList,5,0,0,any,1
+nlme,coef.lmList,6,0,0,...,1
+nlme,coef<-.modelStruct,-1,0,0,"class<`glsStruct`, `gnlsStruct`, `modelStruct`>",1
+nlme,coef<-.modelStruct,-1,0,1,"class<`glsStruct`, `modelStruct`>",1
+nlme,coef<-.modelStruct,-1,0,2,"class<`lmeStruct`, `lmeStructInt`, `modelStruct`>",1
+nlme,coef<-.modelStruct,-1,0,3,"class<`lmeStruct`, `lmeStructInt`, `modelStruct`, `nlmeStruct`>",1
+nlme,coef<-.modelStruct,-1,0,4,"class<`lmeStruct`, `modelStruct`>",1
+nlme,coef<-.modelStruct,-1,0,5,"class<`lmeStruct`, `modelStruct`, `nlmeStruct`>",1
+nlme,coef<-.modelStruct,0,0,0,"class<`glsStruct`, `gnlsStruct`, `modelStruct`>",1
+nlme,coef<-.modelStruct,0,0,1,"class<`glsStruct`, `modelStruct`>",1
+nlme,coef<-.modelStruct,0,0,2,"class<`lmeStruct`, `lmeStructInt`, `modelStruct`>",1
+nlme,coef<-.modelStruct,0,0,3,"class<`lmeStruct`, `lmeStructInt`, `modelStruct`, `nlmeStruct`>",1
+nlme,coef<-.modelStruct,0,0,4,"class<`lmeStruct`, `modelStruct`>",1
+nlme,coef<-.modelStruct,0,0,5,"class<`lmeStruct`, `modelStruct`, `nlmeStruct`>",1
+nlme,coef<-.modelStruct,1,0,0,...,1
+nlme,coef<-.modelStruct,2,0,0,double[],1
+nlme,coef.modelStruct,-1,0,0,double[],1
+nlme,coef.modelStruct,-1,0,1,null,1
+nlme,coef.modelStruct,0,0,0,"class<`glsStruct`, `modelStruct`>",1
+nlme,coef.modelStruct,0,0,1,"class<`glsStruct`, `gnlsStruct`, `modelStruct`>",1
+nlme,coef.modelStruct,0,0,2,"class<`lmeStruct`, `modelStruct`>",1
+nlme,coef.modelStruct,0,0,3,"class<`lmeStruct`, `lmeStructInt`, `modelStruct`>",1
+nlme,coef.modelStruct,0,0,4,"class<`lmeStruct`, `lmeStructInt`, `modelStruct`, `nlmeStruct`>",1
+nlme,coef.modelStruct,0,0,5,"class<`lmeStruct`, `modelStruct`, `nlmeStruct`>",1
+nlme,coef.modelStruct,0,0,6,"class<`pdBlocked`, `pdMat`>",1
+nlme,coef.modelStruct,0,0,7,class<`reStruct`>,1
+nlme,coef.modelStruct,1,0,0,logical,1
+nlme,coef.modelStruct,2,0,0,...,1
+nlme,coef<-.pdBlocked,-1,0,0,"class<`pdBlocked`, `pdMat`>",1
+nlme,coef<-.pdBlocked,0,0,0,"class<`pdBlocked`, `pdMat`>",1
+nlme,coef<-.pdBlocked,1,0,0,...,1
+nlme,coef<-.pdBlocked,2,0,0,double[],1
+nlme,coef.pdBlocked,-1,0,0,double[],1
+nlme,coef.pdBlocked,-1,0,1,null,1
+nlme,coef.pdBlocked,0,0,0,"class<`glsStruct`, `modelStruct`>",1
+nlme,coef.pdBlocked,0,0,1,"class<`glsStruct`, `gnlsStruct`, `modelStruct`>",1
+nlme,coef.pdBlocked,0,0,2,"class<`lmeStruct`, `modelStruct`>",1
+nlme,coef.pdBlocked,0,0,3,"class<`lmeStruct`, `lmeStructInt`, `modelStruct`>",1
+nlme,coef.pdBlocked,0,0,4,"class<`lmeStruct`, `lmeStructInt`, `modelStruct`, `nlmeStruct`>",1
+nlme,coef.pdBlocked,0,0,5,"class<`lmeStruct`, `modelStruct`, `nlmeStruct`>",1
+nlme,coef.pdBlocked,0,0,6,"class<`pdBlocked`, `pdMat`>",1
+nlme,coef.pdBlocked,0,0,7,class<`reStruct`>,1
+nlme,coef.pdBlocked,1,0,0,logical,1
+nlme,coef.pdBlocked,2,0,0,...,1
+nlme,coef.pdCompSymm,-1,0,0,double[],1
+nlme,coef.pdCompSymm,0,0,0,"class<`pdCompSymm`, `pdMat`>",1
+nlme,coef.pdCompSymm,1,0,0,logical,1
+nlme,coef.pdCompSymm,2,0,0,...,1
+nlme,coef.pdDiag,-1,0,0,double[],1
+nlme,coef.pdDiag,0,0,0,"class<`pdDiag`, `pdMat`>",1
+nlme,coef.pdDiag,1,0,0,logical,1
+nlme,coef.pdDiag,2,0,0,...,1
+nlme,coef.pdIdent,-1,0,0,double,1
+nlme,coef.pdIdent,0,0,0,"class<`pdIdent`, `pdMat`>",1
+nlme,coef.pdIdent,1,0,0,logical,1
+nlme,coef.pdIdent,2,0,0,...,1
+nlme,coef<-.pdMat,-1,0,0,"class<`pdCompSymm`, `pdMat`>",1
+nlme,coef<-.pdMat,-1,0,1,"class<`pdDiag`, `pdMat`>",1
+nlme,coef<-.pdMat,-1,0,2,"class<`pdIdent`, `pdMat`>",1
+nlme,coef<-.pdMat,-1,0,3,"class<`pdLogChol`, `pdMat`, `pdSymm`>",1
+nlme,coef<-.pdMat,-1,0,4,"class<`pdMat`, `pdNatural`>",1
+nlme,coef<-.pdMat,-1,0,5,"class<`pdMat`, `pdSymm`>",1
+nlme,coef<-.pdMat,0,0,0,"class<`pdCompSymm`, `pdMat`>",1
+nlme,coef<-.pdMat,0,0,1,"class<`pdDiag`, `pdMat`>",1
+nlme,coef<-.pdMat,0,0,2,"class<`pdIdent`, `pdMat`>",1
+nlme,coef<-.pdMat,0,0,3,"class<`pdLogChol`, `pdMat`, `pdSymm`>",1
+nlme,coef<-.pdMat,0,0,4,"class<`pdMat`, `pdNatural`>",1
+nlme,coef<-.pdMat,0,0,5,"class<`pdMat`, `pdSymm`>",1
+nlme,coef<-.pdMat,1,0,0,...,1
+nlme,coef<-.pdMat,2,0,0,double[],1
+nlme,coef.pdMat,-1,0,0,double[],1
+nlme,coef.pdMat,0,0,0,"class<`pdCompSymm`, `pdMat`>",1
+nlme,coef.pdMat,0,0,1,"class<`pdDiag`, `pdMat`>",1
+nlme,coef.pdMat,0,0,2,"class<`pdLogChol`, `pdMat`, `pdSymm`>",1
+nlme,coef.pdMat,0,0,3,"class<`pdMat`, `pdNatural`>",1
+nlme,coef.pdMat,0,0,4,"class<`pdMat`, `pdSymm`>",1
+nlme,coef.pdMat,0,0,5,"class<`pdIdent`, `pdMat`>",1
+nlme,coef.pdMat,1,0,0,logical,1
+nlme,coef.pdMat,2,0,0,...,1
+nlme,coef.pdNatural,-1,0,0,double[],1
+nlme,coef.pdNatural,0,0,0,"class<`pdMat`, `pdNatural`>",1
+nlme,coef.pdNatural,1,0,0,logical,1
+nlme,coef.pdNatural,2,0,0,...,1
+nlme,coef.pdSymm,-1,0,0,double[],1
+nlme,coef.pdSymm,0,0,0,"class<`pdLogChol`, `pdMat`, `pdSymm`>",1
+nlme,coef.pdSymm,0,0,1,"class<`pdMat`, `pdSymm`>",1
+nlme,coef.pdSymm,1,0,0,logical,1
+nlme,coef.pdSymm,2,0,0,...,1
+nlme,coef<-.reStruct,-1,0,0,class<`reStruct`>,1
+nlme,coef<-.reStruct,0,0,0,class<`reStruct`>,1
+nlme,coef<-.reStruct,1,0,0,...,1
+nlme,coef<-.reStruct,2,0,0,double[],1
+nlme,coef.reStruct,-1,0,0,double[],1
+nlme,coef.reStruct,-1,0,1,null,1
+nlme,coef.reStruct,0,0,0,"class<`glsStruct`, `modelStruct`>",1
+nlme,coef.reStruct,0,0,1,"class<`glsStruct`, `gnlsStruct`, `modelStruct`>",1
+nlme,coef.reStruct,0,0,2,"class<`lmeStruct`, `modelStruct`>",1
+nlme,coef.reStruct,0,0,3,"class<`lmeStruct`, `lmeStructInt`, `modelStruct`>",1
+nlme,coef.reStruct,0,0,4,"class<`lmeStruct`, `lmeStructInt`, `modelStruct`, `nlmeStruct`>",1
+nlme,coef.reStruct,0,0,5,"class<`lmeStruct`, `modelStruct`, `nlmeStruct`>",1
+nlme,coef.reStruct,0,0,6,"class<`pdBlocked`, `pdMat`>",1
+nlme,coef.reStruct,0,0,7,class<`reStruct`>,1
+nlme,coef.reStruct,1,0,0,logical,1
+nlme,coef.reStruct,2,0,0,...,1
+nlme,coef.summary.nlsList,-1,0,0,class<`array`>,1
+nlme,coef.summary.nlsList,0,0,0,"class<`summary.lmList`, `summary.nlsList`>",1
+nlme,coef.summary.nlsList,1,0,0,...,1
+nlme,coef<-.varIdent,-1,0,0,"class<`varFunc`, `varIdent`>",1
+nlme,coef<-.varIdent,0,0,0,"class<`varFunc`, `varIdent`>",1
+nlme,coef<-.varIdent,1,0,0,...,1
+nlme,coef<-.varIdent,2,0,0,double[],1
+nlme,coef.varIdent,-1,0,0,double[],1
+nlme,coef.varIdent,0,0,0,"class<`varFunc`, `varIdent`>",1
+nlme,coef.varIdent,1,0,0,logical,1
+nlme,coef.varIdent,2,0,0,logical,1
+nlme,coef.varIdent,3,0,0,...,1
+nlme,coef<-.varPower,-1,0,0,"class<`varFunc`, `varPower`>",1
+nlme,coef<-.varPower,0,0,0,"class<`varFunc`, `varPower`>",1
+nlme,coef<-.varPower,1,0,0,...,1
+nlme,coef<-.varPower,2,0,0,double,1
+nlme,coef.varPower,-1,0,0,double[],1
+nlme,coef.varPower,0,0,0,"class<`varFunc`, `varPower`>",1
+nlme,coef.varPower,1,0,0,any,1
+nlme,coef.varPower,2,0,0,logical,1
+nlme,coef.varPower,3,0,0,...,1
+nlme,collapse,-1,0,0,"class<`data.frame`, `groupedData`, `nfGroupedData`, `nfnGroupedData`>",1
+nlme,collapse,0,0,0,"class<`data.frame`, `groupedData`, `nmGroupedData`>",1
+nlme,collapse,1,0,0,...,1
+nlme,collapse.groupedData,-1,0,0,"class<`data.frame`, `groupedData`, `nfGroupedData`, `nfnGroupedData`>",1
+nlme,collapse.groupedData,0,0,0,"class<`data.frame`, `groupedData`, `nmGroupedData`>",1
+nlme,collapse.groupedData,1,0,0,character,1
+nlme,collapse.groupedData,1,0,1,double,1
+nlme,collapse.groupedData,2,0,0,character,1
+nlme,collapse.groupedData,2,0,1,double,1
+nlme,collapse.groupedData,3,0,0,null,1
+nlme,collapse.groupedData,4,0,0,null,1
+nlme,collapse.groupedData,4,0,1,class<`formula`>,1
+nlme,collapse.groupedData,5,0,0,class<`formula`>,1
+nlme,collapse.groupedData,5,0,1,null,1
+nlme,collapse.groupedData,6,0,0,any,1
+nlme,collapse.groupedData,7,0,0,null,1
+nlme,compareFits,-1,0,0,class<`compareFits`>,1
+nlme,compareFits,0,0,0,"class<`coef.lmList`, `data.frame`, `ranef.lmList`>",1
+nlme,compareFits,1,0,0,"class<`coef.lme`, `data.frame`, `ranef.lme`>",1
+nlme,compareFits,2,0,0,integer[],1
+nlme,comparePred,-1,0,0,"class<`augPred`, `augPred`, `comparePred`, `data.frame`>",1
+nlme,comparePred,0,0,0,class<`lme`>,1
+nlme,comparePred,1,0,0,class<`lme`>,1
+nlme,comparePred,2,0,0,null,1
+nlme,comparePred,3,0,0,any,1
+nlme,comparePred,4,0,0,any,1
+nlme,comparePred,5,0,0,double,1
+nlme,comparePred,6,0,0,null,1
+nlme,comparePred,7,0,0,...,1
+nlme,comparePred.lme,-1,0,0,"class<`augPred`, `augPred`, `comparePred`, `data.frame`>",1
+nlme,comparePred.lme,0,0,0,class<`lme`>,1
+nlme,comparePred.lme,1,0,0,class<`lme`>,1
+nlme,comparePred.lme,2,0,0,null,1
+nlme,comparePred.lme,3,0,0,any,1
+nlme,comparePred.lme,4,0,0,any,1
+nlme,comparePred.lme,5,0,0,double,1
+nlme,comparePred.lme,6,0,0,null,1
+nlme,comparePred.lme,7,0,0,...,1
+nlme,confint.nlsList,-1,0,0,list<class<`matrix`>>,1
+nlme,confint.nlsList,-1,0,1,list<^logical[] | class<`matrix`>>,1
+nlme,confint.nlsList,0,0,0,"class<`lmList`, `nlsList`>",1
+nlme,confint.nlsList,1,0,0,...,1
+nlme,corAR1,-1,0,0,"class<`corAR1`, `corStruct`>",1
+nlme,corAR1,0,0,0,double,1
+nlme,corAR1,1,0,0,class<`formula`>,1
+nlme,corAR1,2,0,0,logical,1
+nlme,corARMA,-1,0,0,"class<`corARMA`, `corStruct`>",1
+nlme,corARMA,0,0,0,double[],1
+nlme,corARMA,1,0,0,class<`formula`>,1
+nlme,corARMA,2,0,0,double,1
+nlme,corARMA,3,0,0,double,1
+nlme,corARMA,4,0,0,logical,1
+nlme,corCAR1,-1,0,0,"class<`corCAR1`, `corStruct`>",1
+nlme,corCAR1,0,0,0,double,1
+nlme,corCAR1,1,0,0,class<`formula`>,1
+nlme,corCAR1,2,0,0,logical,1
+nlme,corCompSymm,-1,0,0,"class<`corCompSymm`, `corStruct`>",1
+nlme,corCompSymm,0,0,0,double,1
+nlme,corCompSymm,1,0,0,class<`formula`>,1
+nlme,corCompSymm,2,0,0,logical,1
+nlme,corExp,-1,0,0,"class<`corExp`, `corSpatial`, `corStruct`>",1
+nlme,corExp,0,0,0,double[],1
+nlme,corExp,1,0,0,class<`formula`>,1
+nlme,corExp,2,0,0,logical,1
+nlme,corExp,3,0,0,character[],1
+nlme,corExp,4,0,0,logical,1
+nlme,corFactor,-1,0,0,double[],1
+nlme,corFactor,0,0,0,"class<`corAR1`, `corStruct`>",1
+nlme,corFactor,0,0,1,"class<`corARMA`, `corStruct`>",1
+nlme,corFactor,0,0,2,"class<`corCAR1`, `corStruct`>",1
+nlme,corFactor,0,0,3,"class<`corCompSymm`, `corStruct`>",1
+nlme,corFactor,0,0,4,"class<`corExp`, `corSpatial`, `corStruct`>",1
+nlme,corFactor,0,0,5,"class<`corGaus`, `corSpatial`, `corStruct`>",1
+nlme,corFactor,0,0,6,"class<`corLin`, `corSpatial`, `corStruct`>",1
+nlme,corFactor,0,0,7,"class<`corRatio`, `corSpatial`, `corStruct`>",1
+nlme,corFactor,0,0,8,"class<`corSpatial`, `corSpher`, `corStruct`>",1
+nlme,corFactor,0,0,9,"class<`corStruct`, `corSymm`>",1
+nlme,corFactor,1,0,0,...,1
+nlme,corFactor.corAR1,-1,0,0,double[],1
+nlme,corFactor.corAR1,0,0,0,"class<`corAR1`, `corStruct`>",1
+nlme,corFactor.corAR1,1,0,0,...,1
+nlme,corFactor.corARMA,-1,0,0,double[],1
+nlme,corFactor.corARMA,0,0,0,"class<`corARMA`, `corStruct`>",1
+nlme,corFactor.corARMA,1,0,0,...,1
+nlme,corFactor.corCAR1,-1,0,0,double[],1
+nlme,corFactor.corCAR1,0,0,0,"class<`corCAR1`, `corStruct`>",1
+nlme,corFactor.corCAR1,1,0,0,...,1
+nlme,corFactor.corSpatial,-1,0,0,double[],1
+nlme,corFactor.corSpatial,0,0,0,"class<`corExp`, `corSpatial`, `corStruct`>",1
+nlme,corFactor.corSpatial,0,0,1,"class<`corGaus`, `corSpatial`, `corStruct`>",1
+nlme,corFactor.corSpatial,0,0,2,"class<`corLin`, `corSpatial`, `corStruct`>",1
+nlme,corFactor.corSpatial,0,0,3,"class<`corRatio`, `corSpatial`, `corStruct`>",1
+nlme,corFactor.corSpatial,0,0,4,"class<`corSpatial`, `corSpher`, `corStruct`>",1
+nlme,corFactor.corSpatial,1,0,0,...,1
+nlme,corFactor.corStruct,-1,0,0,double[],1
+nlme,corFactor.corStruct,0,0,0,"class<`corCompSymm`, `corStruct`>",1
+nlme,corFactor.corStruct,1,0,0,...,1
+nlme,corFactor.corSymm,-1,0,0,double[],1
+nlme,corFactor.corSymm,0,0,0,"class<`corStruct`, `corSymm`>",1
+nlme,corFactor.corSymm,1,0,0,...,1
+nlme,corGaus,-1,0,0,"class<`corGaus`, `corSpatial`, `corStruct`>",1
+nlme,corGaus,0,0,0,double[],1
+nlme,corGaus,1,0,0,class<`formula`>,1
+nlme,corGaus,2,0,0,logical,1
+nlme,corGaus,3,0,0,character[],1
+nlme,corGaus,4,0,0,logical,1
+nlme,corLin,-1,0,0,"class<`corLin`, `corSpatial`, `corStruct`>",1
+nlme,corLin,0,0,0,double[],1
+nlme,corLin,1,0,0,class<`formula`>,1
+nlme,corLin,2,0,0,logical,1
+nlme,corLin,3,0,0,character[],1
+nlme,corLin,4,0,0,logical,1
+nlme,corMatrix,-1,0,0,class<`matrix`>,1
+nlme,corMatrix,-1,0,1,list<class<`matrix`>>,1
+nlme,corMatrix,0,0,0,"class<`corAR1`, `corStruct`>",1
+nlme,corMatrix,0,0,1,"class<`corExp`, `corSpatial`, `corStruct`>",1
+nlme,corMatrix,0,0,2,"class<`pdLogChol`, `pdMat`, `pdSymm`>",1
+nlme,corMatrix,0,0,3,"class<`pdMat`, `pdSymm`>",1
+nlme,corMatrix,0,0,4,"class<`pdCompSymm`, `pdMat`>",1
+nlme,corMatrix,0,0,5,class<`reStruct`>,1
+nlme,corMatrix,0,0,6,"class<`corARMA`, `corStruct`>",1
+nlme,corMatrix,0,0,7,"class<`corCompSymm`, `corStruct`>",1
+nlme,corMatrix,0,0,8,"class<`corStruct`, `corSymm`>",1
+nlme,corMatrix,1,0,0,...,1
+nlme,corMatrix.corAR1,-1,0,0,class<`matrix`>,1
+nlme,corMatrix.corAR1,-1,0,1,list<class<`matrix`>>,1
+nlme,corMatrix.corAR1,0,0,0,"class<`corAR1`, `corStruct`>",1
+nlme,corMatrix.corAR1,1,0,0,integer[],1
+nlme,corMatrix.corAR1,1,0,1,list<integer[]>,1
+nlme,corMatrix.corAR1,2,0,0,logical,1
+nlme,corMatrix.corAR1,3,0,0,...,1
+nlme,corMatrix.corARMA,-1,0,0,list<class<`matrix`>>,1
+nlme,corMatrix.corARMA,0,0,0,"class<`corARMA`, `corStruct`>",1
+nlme,corMatrix.corARMA,1,0,0,list<integer[]>,1
+nlme,corMatrix.corARMA,2,0,0,logical,1
+nlme,corMatrix.corARMA,3,0,0,...,1
+nlme,corMatrix.corCompSymm,-1,0,0,list<class<`matrix`>>,1
+nlme,corMatrix.corCompSymm,0,0,0,"class<`corCompSymm`, `corStruct`>",1
+nlme,corMatrix.corCompSymm,1,0,0,list<integer[]>,1
+nlme,corMatrix.corCompSymm,2,0,0,logical,1
+nlme,corMatrix.corCompSymm,3,0,0,...,1
+nlme,corMatrix.corSpatial,-1,0,0,class<`matrix`>,1
+nlme,corMatrix.corSpatial,0,0,0,"class<`corExp`, `corSpatial`, `corStruct`>",1
+nlme,corMatrix.corSpatial,1,0,0,double[],1
+nlme,corMatrix.corSpatial,2,0,0,logical,1
+nlme,corMatrix.corSpatial,3,0,0,...,1
+nlme,corMatrix.corSymm,-1,0,0,list<class<`matrix`>>,1
+nlme,corMatrix.corSymm,0,0,0,"class<`corStruct`, `corSymm`>",1
+nlme,corMatrix.corSymm,1,0,0,list<double[]>,1
+nlme,corMatrix.corSymm,2,0,0,logical,1
+nlme,corMatrix.corSymm,3,0,0,...,1
+nlme,corMatrix.pdCompSymm,-1,0,0,class<`matrix`>,1
+nlme,corMatrix.pdCompSymm,0,0,0,"class<`pdCompSymm`, `pdMat`>",1
+nlme,corMatrix.pdCompSymm,1,0,0,...,1
+nlme,corMatrix.pdMat,-1,0,0,class<`matrix`>,1
+nlme,corMatrix.pdMat,0,0,0,"class<`pdLogChol`, `pdMat`, `pdSymm`>",1
+nlme,corMatrix.pdMat,0,0,1,"class<`pdMat`, `pdSymm`>",1
+nlme,corMatrix.pdMat,1,0,0,...,1
+nlme,corMatrix.reStruct,-1,0,0,list<class<`matrix`>>,1
+nlme,corMatrix.reStruct,0,0,0,class<`reStruct`>,1
+nlme,corMatrix.reStruct,1,0,0,...,1
+nlme,corNatural,-1,0,0,"class<`corNatural`, `corStruct`>",1
+nlme,corNatural,0,0,0,double[],1
+nlme,corNatural,1,0,0,class<`formula`>,1
+nlme,corNatural,2,0,0,logical,1
+nlme,corRatio,-1,0,0,"class<`corRatio`, `corSpatial`, `corStruct`>",1
+nlme,corRatio,0,0,0,double[],1
+nlme,corRatio,1,0,0,class<`formula`>,1
+nlme,corRatio,2,0,0,logical,1
+nlme,corRatio,3,0,0,character[],1
+nlme,corRatio,4,0,0,logical,1
+nlme,corSpatial,-1,0,0,"class<`corGaus`, `corSpatial`, `corStruct`>",1
+nlme,corSpatial,0,0,0,double[],1
+nlme,corSpatial,1,0,0,class<`formula`>,1
+nlme,corSpatial,2,0,0,logical,1
+nlme,corSpatial,3,0,0,character,1
+nlme,corSpatial,4,0,0,character,1
+nlme,corSpatial,5,0,0,logical,1
+nlme,corSpher,-1,0,0,"class<`corSpatial`, `corSpher`, `corStruct`>",1
+nlme,corSpher,0,0,0,double[],1
+nlme,corSpher,1,0,0,class<`formula`>,1
+nlme,corSpher,2,0,0,logical,1
+nlme,corSpher,3,0,0,character[],1
+nlme,corSpher,4,0,0,logical,1
+nlme,corSymm,-1,0,0,"class<`corStruct`, `corSymm`>",1
+nlme,corSymm,0,0,0,double[],1
+nlme,corSymm,1,0,0,class<`formula`>,1
+nlme,corSymm,2,0,0,logical,1
+nlme,covariate<-,-1,0,0,"class<`varFunc`, `varPower`>",1
+nlme,covariate<-,0,0,0,"class<`varFunc`, `varPower`>",1
+nlme,covariate<-,1,0,0,double[],1
+nlme,covariate<-.varFunc,-1,0,0,"class<`varFunc`, `varPower`>",1
+nlme,covariate<-.varFunc,0,0,0,"class<`varFunc`, `varPower`>",1
+nlme,covariate<-.varFunc,1,0,0,double[],1
+nlme,deviance.gls,-1,0,0,class<`logLik`>,1
+nlme,deviance.gls,0,0,0,class<`gls`>,1
+nlme,deviance.gls,0,0,1,class<`lme`>,1
+nlme,deviance.gls,1,0,0,...,1
+nlme,deviance.lme,-1,0,0,class<`logLik`>,1
+nlme,deviance.lme,0,0,0,class<`gls`>,1
+nlme,deviance.lme,0,0,1,class<`lme`>,1
+nlme,deviance.lme,1,0,0,...,1
+nlme,Dim,-1,0,0,double[],1
+nlme,Dim,-1,0,1,list<double | class<`table`> | integer[]>,1
+nlme,Dim,-1,0,2,list<double | class<`table`>>,1
+nlme,Dim,-1,0,3,list<class<`table`> | double[]>,1
+nlme,Dim,0,0,0,"class<`pdLogChol`, `pdMat`, `pdSymm`>",1
+nlme,Dim,0,0,1,"class<`pdMat`, `pdNatural`>",1
+nlme,Dim,0,0,2,"class<`pdMat`, `pdSymm`>",1
+nlme,Dim,0,0,3,class<`matrix`>,1
+nlme,Dim,0,0,4,"class<`pdBlocked`, `pdMat`>",1
+nlme,Dim,0,0,5,"class<`pdCompSymm`, `pdMat`>",1
+nlme,Dim,0,0,6,"class<`pdDiag`, `pdMat`>",1
+nlme,Dim,0,0,7,"class<`pdIdent`, `pdMat`>",1
+nlme,Dim,0,0,8,"class<`corAR1`, `corStruct`>",1
+nlme,Dim,0,0,9,"class<`corARMA`, `corStruct`>",1
+nlme,Dim,0,0,10,"class<`corCAR1`, `corStruct`>",1
+nlme,Dim,0,0,11,"class<`corCompSymm`, `corStruct`>",1
+nlme,Dim,0,0,12,"class<`corNatural`, `corStruct`>",1
+nlme,Dim,0,0,13,"class<`corStruct`, `corSymm`>",1
+nlme,Dim,0,0,14,"class<`corExp`, `corSpatial`, `corStruct`>",1
+nlme,Dim,0,0,15,"class<`corGaus`, `corSpatial`, `corStruct`>",1
+nlme,Dim,0,0,16,"class<`corLin`, `corSpatial`, `corStruct`>",1
+nlme,Dim,0,0,17,"class<`corRatio`, `corSpatial`, `corStruct`>",1
+nlme,Dim,0,0,18,"class<`corSpatial`, `corSpher`, `corStruct`>",1
+nlme,Dim,1,0,0,...,1
+nlme,Dim.corSpatial,-1,0,0,list<class<`table`> | double[]>,1
+nlme,Dim.corSpatial,-1,0,1,list<double | class<`table`>>,1
+nlme,Dim.corSpatial,0,0,0,"class<`corExp`, `corSpatial`, `corStruct`>",1
+nlme,Dim.corSpatial,0,0,1,"class<`corGaus`, `corSpatial`, `corStruct`>",1
+nlme,Dim.corSpatial,0,0,2,"class<`corLin`, `corSpatial`, `corStruct`>",1
+nlme,Dim.corSpatial,0,0,3,"class<`corRatio`, `corSpatial`, `corStruct`>",1
+nlme,Dim.corSpatial,0,0,4,"class<`corSpatial`, `corSpher`, `corStruct`>",1
+nlme,Dim.corSpatial,1,0,0,any,1
+nlme,Dim.corSpatial,2,0,0,...,1
+nlme,Dim.corStruct,-1,0,0,list<double | class<`table`> | integer[]>,1
+nlme,Dim.corStruct,-1,0,1,list<double | class<`table`>>,1
+nlme,Dim.corStruct,0,0,0,any,1
+nlme,Dim.corStruct,1,0,0,any,1
+nlme,Dim.corStruct,2,0,0,...,1
+nlme,Dim.default,-1,0,0,integer[],1
+nlme,Dim.default,0,0,0,class<`matrix`>,1
+nlme,Dim.default,1,0,0,...,1
+nlme,Dim.pdCompSymm,-1,0,0,integer[],1
+nlme,Dim.pdCompSymm,0,0,0,"class<`pdCompSymm`, `pdMat`>",1
+nlme,Dim.pdCompSymm,0,0,1,"class<`pdIdent`, `pdMat`>",1
+nlme,Dim.pdCompSymm,1,0,0,...,1
+nlme,Dim.pdDiag,-1,0,0,integer[],1
+nlme,Dim.pdDiag,0,0,0,"class<`pdDiag`, `pdMat`>",1
+nlme,Dim.pdDiag,1,0,0,...,1
+nlme,Dim.pdIdent,-1,0,0,integer[],1
+nlme,Dim.pdIdent,0,0,0,"class<`pdCompSymm`, `pdMat`>",1
+nlme,Dim.pdIdent,0,0,1,"class<`pdIdent`, `pdMat`>",1
+nlme,Dim.pdIdent,1,0,0,...,1
+nlme,Dim.pdMat,-1,0,0,integer[],1
+nlme,Dim.pdMat,0,0,0,"class<`pdBlocked`, `pdMat`>",1
+nlme,Dim.pdMat,1,0,0,...,1
+nlme,Dim.pdNatural,-1,0,0,double[],1
+nlme,Dim.pdNatural,0,0,0,"class<`pdMat`, `pdNatural`>",1
+nlme,Dim.pdNatural,0,0,1,"class<`pdLogChol`, `pdMat`, `pdSymm`>",1
+nlme,Dim.pdNatural,0,0,2,"class<`pdMat`, `pdSymm`>",1
+nlme,Dim.pdNatural,1,0,0,...,1
+nlme,Dim.pdSymm,-1,0,0,double[],1
+nlme,Dim.pdSymm,0,0,0,"class<`pdMat`, `pdNatural`>",1
+nlme,Dim.pdSymm,0,0,1,"class<`pdLogChol`, `pdMat`, `pdSymm`>",1
+nlme,Dim.pdSymm,0,0,2,"class<`pdMat`, `pdSymm`>",1
+nlme,Dim.pdSymm,1,0,0,...,1
+nlme,extractAIC.gls,-1,0,0,double[],1
+nlme,extractAIC.gls,0,0,0,class<`gls`>,1
+nlme,extractAIC.gls,0,0,1,class<`lme`>,1
+nlme,extractAIC.gls,1,0,0,any,1
+nlme,extractAIC.gls,2,0,0,double,1
+nlme,extractAIC.gls,3,0,0,...,1
+nlme,extractAIC.lme,-1,0,0,double[],1
+nlme,extractAIC.lme,0,0,0,class<`gls`>,1
+nlme,extractAIC.lme,0,0,1,class<`lme`>,1
+nlme,extractAIC.lme,1,0,0,any,1
+nlme,extractAIC.lme,2,0,0,double,1
+nlme,extractAIC.lme,3,0,0,...,1
+nlme,fdHess,-1,0,0,list<double[] | class<`matrix`>>,1
+nlme,fdHess,-1,0,1,list<double | class<`matrix`>>,1
+nlme,fdHess,0,0,0,double[],1
+nlme,fdHess,1,0,0,class<`function`>,1
+nlme,fdHess,2,0,0,...,1
+nlme,fdHess,3,0,0,double,1
+nlme,fdHess,4,0,0,double,1
+nlme,fitted.gls,-1,0,0,^double[],1
+nlme,fitted.gls,0,0,0,class<`gls`>,1
+nlme,fitted.gls,0,0,1,"class<`gls`, `gnls`>",1
+nlme,fitted.gls,1,0,0,...,1
+nlme,fitted.glsStruct,-1,0,0,double[],1
+nlme,fitted.glsStruct,0,0,0,"class<`glsStruct`, `modelStruct`>",1
+nlme,fitted.glsStruct,1,0,0,list<double[] | class<`matrix`>>,1
+nlme,fitted.glsStruct,1,0,1,list<class<`logLik`> | double[] | class<`matrix`>>,1
+nlme,fitted.glsStruct,1,0,2,list<class<`matrix`> | double[]>,1
+nlme,fitted.glsStruct,2,0,0,...,1
+nlme,fitted.gnls,-1,0,0,^double[],1
+nlme,fitted.gnls,0,0,0,class<`gls`>,1
+nlme,fitted.gnls,0,0,1,"class<`gls`, `gnls`>",1
+nlme,fitted.gnls,1,0,0,...,1
+nlme,fitted.gnlsStruct,-1,0,0,double[],1
+nlme,fitted.gnlsStruct,0,0,0,"class<`glsStruct`, `gnlsStruct`, `modelStruct`>",1
+nlme,fitted.gnlsStruct,1,0,0,...,1
+nlme,fitted.lme,-1,0,0,class<`matrix`>,1
+nlme,fitted.lme,-1,0,1,^double[],1
+nlme,fitted.lme,0,0,0,class<`lme`>,1
+nlme,fitted.lme,0,0,1,"class<`lme`, `nlme`>",1
+nlme,fitted.lme,1,0,0,integer[],1
+nlme,fitted.lme,1,0,1,double,1
+nlme,fitted.lme,2,0,0,any,1
+nlme,fitted.lme,3,0,0,...,1
+nlme,fitted.lmeStruct,-1,0,0,class<`matrix`>,1
+nlme,fitted.lmeStruct,-1,0,1,double[],1
+nlme,fitted.lmeStruct,0,0,0,"class<`lmeStruct`, `lmeStructInt`, `modelStruct`>",1
+nlme,fitted.lmeStruct,0,0,1,"class<`lmeStruct`, `modelStruct`>",1
+nlme,fitted.lmeStruct,1,0,0,integer[],1
+nlme,fitted.lmeStruct,2,0,0,list<class<`matrix`> | double | list<double[] | list<double[]>>>,1
+nlme,fitted.lmeStruct,2,0,1,list<class<`matrix`> | list<double[] | list<double[]>>>,1
+nlme,fitted.lmeStruct,2,0,2,list<class<`matrix`> | list<double[] | list<double>>>,1
+nlme,fitted.lmeStruct,3,0,0,list<any>,1
+nlme,fitted.lmeStruct,4,0,0,...,1
+nlme,fitted.lmList,-1,0,0,double[],1
+nlme,fitted.lmList,0,0,0,class<`lmList`>,1
+nlme,fitted.lmList,1,0,0,null,1
+nlme,fitted.lmList,2,0,0,logical,1
+nlme,fitted.lmList,3,0,0,...,1
+nlme,fixed.effects,-1,0,0,double[],1
+nlme,fixed.effects,0,0,0,class<`lmList`>,1
+nlme,fixed.effects,0,0,1,class<`lme`>,1
+nlme,fixed.effects,0,0,2,"class<`lme`, `nlme`>",1
+nlme,fixed.effects,1,0,0,...,1
+nlme,fixef,-1,0,0,double[],1
+nlme,fixef,0,0,0,class<`lmList`>,1
+nlme,fixef,0,0,1,class<`lme`>,1
+nlme,fixef,0,0,2,"class<`lme`, `nlme`>",1
+nlme,fixef,1,0,0,...,1
+nlme,fixef.lme,-1,0,0,double[],1
+nlme,fixef.lme,0,0,0,class<`lme`>,1
+nlme,fixef.lme,0,0,1,"class<`lme`, `nlme`>",1
+nlme,fixef.lme,1,0,0,...,1
+nlme,fixef.lmList,-1,0,0,double[],1
+nlme,fixef.lmList,0,0,0,class<`lmList`>,1
+nlme,fixef.lmList,1,0,0,...,1
+nlme,formula.corStruct,-1,0,0,class<`formula`>,1
+nlme,formula.corStruct,0,0,0,"class<`corAR1`, `corStruct`>",1
+nlme,formula.corStruct,0,0,1,"class<`corARMA`, `corStruct`>",1
+nlme,formula.corStruct,0,0,2,"class<`corCAR1`, `corStruct`>",1
+nlme,formula.corStruct,0,0,3,"class<`corCompSymm`, `corStruct`>",1
+nlme,formula.corStruct,0,0,4,"class<`corExp`, `corSpatial`, `corStruct`>",1
+nlme,formula.corStruct,0,0,5,"class<`corGaus`, `corSpatial`, `corStruct`>",1
+nlme,formula.corStruct,0,0,6,"class<`corLin`, `corSpatial`, `corStruct`>",1
+nlme,formula.corStruct,0,0,7,"class<`corRatio`, `corSpatial`, `corStruct`>",1
+nlme,formula.corStruct,0,0,8,"class<`corSpatial`, `corSpher`, `corStruct`>",1
+nlme,formula.corStruct,0,0,9,"class<`corStruct`, `corSymm`>",1
+nlme,formula.corStruct,0,0,10,"class<`data.frame`, `groupedData`, `nfGroupedData`, `nffGroupedData`>",1
+nlme,formula.corStruct,0,0,11,"class<`data.frame`, `groupedData`, `nfGroupedData`, `nfnGroupedData`>",1
+nlme,formula.corStruct,0,0,12,"class<`data.frame`, `groupedData`, `nmGroupedData`>",1
+nlme,formula.corStruct,0,0,13,"class<`varExp`, `varFunc`>",1
+nlme,formula.corStruct,0,0,14,"class<`varFunc`, `varIdent`>",1
+nlme,formula.corStruct,0,0,15,"class<`varFunc`, `varPower`>",1
+nlme,formula.corStruct,1,0,0,...,1
+nlme,formula.gls,-1,0,0,class<`formula`>,1
+nlme,formula.gls,-1,0,1,"class<`formula`, `terms`>",1
+nlme,formula.gls,0,0,0,class<`gls`>,1
+nlme,formula.gls,1,0,0,...,1
+nlme,formula.gnls,-1,0,0,class<`formula`>,1
+nlme,formula.gnls,0,0,0,"class<`gls`, `gnls`>",1
+nlme,formula.gnls,0,0,1,"class<`lme`, `nlme`>",1
+nlme,formula.gnls,1,0,0,...,1
+nlme,formula.groupedData,-1,0,0,class<`formula`>,1
+nlme,formula.groupedData,0,0,0,"class<`corAR1`, `corStruct`>",1
+nlme,formula.groupedData,0,0,1,"class<`corARMA`, `corStruct`>",1
+nlme,formula.groupedData,0,0,2,"class<`corCAR1`, `corStruct`>",1
+nlme,formula.groupedData,0,0,3,"class<`corCompSymm`, `corStruct`>",1
+nlme,formula.groupedData,0,0,4,"class<`corExp`, `corSpatial`, `corStruct`>",1
+nlme,formula.groupedData,0,0,5,"class<`corGaus`, `corSpatial`, `corStruct`>",1
+nlme,formula.groupedData,0,0,6,"class<`corLin`, `corSpatial`, `corStruct`>",1
+nlme,formula.groupedData,0,0,7,"class<`corRatio`, `corSpatial`, `corStruct`>",1
+nlme,formula.groupedData,0,0,8,"class<`corSpatial`, `corSpher`, `corStruct`>",1
+nlme,formula.groupedData,0,0,9,"class<`corStruct`, `corSymm`>",1
+nlme,formula.groupedData,0,0,10,"class<`data.frame`, `groupedData`, `nfGroupedData`, `nffGroupedData`>",1
+nlme,formula.groupedData,0,0,11,"class<`data.frame`, `groupedData`, `nfGroupedData`, `nfnGroupedData`>",1
+nlme,formula.groupedData,0,0,12,"class<`data.frame`, `groupedData`, `nmGroupedData`>",1
+nlme,formula.groupedData,0,0,13,"class<`varExp`, `varFunc`>",1
+nlme,formula.groupedData,0,0,14,"class<`varFunc`, `varIdent`>",1
+nlme,formula.groupedData,0,0,15,"class<`varFunc`, `varPower`>",1
+nlme,formula.groupedData,1,0,0,...,1
+nlme,formula.lme,-1,0,0,class<`formula`>,1
+nlme,formula.lme,-1,0,1,"class<`formula`, `terms`>",1
+nlme,formula.lme,0,0,0,class<`lme`>,1
+nlme,formula.lme,1,0,0,...,1
+nlme,formula.lmList,-1,0,0,class<`formula`>,1
+nlme,formula.lmList,0,0,0,class<`lmList`>,1
+nlme,formula.lmList,1,0,0,...,1
+nlme,formula.modelStruct,-1,0,0,list<any>,1
+nlme,formula.modelStruct,0,0,0,"class<`glsStruct`, `gnlsStruct`, `modelStruct`>",1
+nlme,formula.modelStruct,0,0,1,"class<`glsStruct`, `modelStruct`>",1
+nlme,formula.modelStruct,0,0,2,"class<`lmeStruct`, `modelStruct`>",1
+nlme,formula.modelStruct,0,0,3,"class<`lmeStruct`, `modelStruct`, `nlmeStruct`>",1
+nlme,formula.modelStruct,1,0,0,...,1
+nlme,formula.nlme,-1,0,0,class<`formula`>,1
+nlme,formula.nlme,0,0,0,"class<`gls`, `gnls`>",1
+nlme,formula.nlme,0,0,1,"class<`lme`, `nlme`>",1
+nlme,formula.nlme,1,0,0,...,1
+nlme,formula.pdBlocked,-1,0,0,class<`formula`>,1
+nlme,formula.pdBlocked,-1,0,1,list<class<`formula`>>,1
+nlme,formula.pdBlocked,-1,0,2,null,1
+nlme,formula.pdBlocked,0,0,0,"class<`pdBlocked`, `pdMat`>",1
+nlme,formula.pdBlocked,1,0,0,logical,1
+nlme,formula.pdBlocked,2,0,0,...,1
+nlme,formula.pdMat,-1,0,0,class<`formula`>,1
+nlme,formula.pdMat,-1,0,1,class<`listForm`>,1
+nlme,formula.pdMat,-1,0,2,null,1
+nlme,formula.pdMat,0,0,0,"class<`pdCompSymm`, `pdMat`>",1
+nlme,formula.pdMat,0,0,1,"class<`pdDiag`, `pdMat`>",1
+nlme,formula.pdMat,0,0,2,"class<`pdIdent`, `pdMat`>",1
+nlme,formula.pdMat,0,0,3,"class<`pdLogChol`, `pdMat`, `pdSymm`>",1
+nlme,formula.pdMat,0,0,4,"class<`pdMat`, `pdSymm`>",1
+nlme,formula.pdMat,1,0,0,any,1
+nlme,formula.pdMat,2,0,0,...,1
+nlme,formula.reStruct,-1,0,0,list<class<`formula`>>,1
+nlme,formula.reStruct,-1,0,1,list<class<`listForm`>>,1
+nlme,formula.reStruct,-1,0,2,list<list<class<`formula`>>>,1
+nlme,formula.reStruct,0,0,0,class<`reStruct`>,1
+nlme,formula.reStruct,1,0,0,logical,1
+nlme,formula.reStruct,2,0,0,...,1
+nlme,formula.varFunc,-1,0,0,class<`formula`>,1
+nlme,formula.varFunc,0,0,0,"class<`corAR1`, `corStruct`>",1
+nlme,formula.varFunc,0,0,1,"class<`corARMA`, `corStruct`>",1
+nlme,formula.varFunc,0,0,2,"class<`corCAR1`, `corStruct`>",1
+nlme,formula.varFunc,0,0,3,"class<`corCompSymm`, `corStruct`>",1
+nlme,formula.varFunc,0,0,4,"class<`corExp`, `corSpatial`, `corStruct`>",1
+nlme,formula.varFunc,0,0,5,"class<`corGaus`, `corSpatial`, `corStruct`>",1
+nlme,formula.varFunc,0,0,6,"class<`corLin`, `corSpatial`, `corStruct`>",1
+nlme,formula.varFunc,0,0,7,"class<`corRatio`, `corSpatial`, `corStruct`>",1
+nlme,formula.varFunc,0,0,8,"class<`corSpatial`, `corSpher`, `corStruct`>",1
+nlme,formula.varFunc,0,0,9,"class<`corStruct`, `corSymm`>",1
+nlme,formula.varFunc,0,0,10,"class<`data.frame`, `groupedData`, `nfGroupedData`, `nffGroupedData`>",1
+nlme,formula.varFunc,0,0,11,"class<`data.frame`, `groupedData`, `nfGroupedData`, `nfnGroupedData`>",1
+nlme,formula.varFunc,0,0,12,"class<`data.frame`, `groupedData`, `nmGroupedData`>",1
+nlme,formula.varFunc,0,0,13,"class<`varExp`, `varFunc`>",1
+nlme,formula.varFunc,0,0,14,"class<`varFunc`, `varIdent`>",1
+nlme,formula.varFunc,0,0,15,"class<`varFunc`, `varPower`>",1
+nlme,formula.varFunc,1,0,0,...,1
+nlme,gapply,-1,0,0,integer[],1
+nlme,gapply,0,0,0,"class<`data.frame`, `groupedData`, `nfGroupedData`, `nfnGroupedData`>",1
+nlme,gapply,1,0,0,any,1
+nlme,gapply,2,0,0,class<`function`>,1
+nlme,gapply,3,0,0,class<`formula`>,1
+nlme,gapply,4,0,0,any,1
+nlme,gapply,5,0,0,"class<`factor`, `ordered`>",1
+nlme,gapply,6,0,0,...,1
+nlme,getCovariate,-1,0,0,class<`factor`>,1
+nlme,getCovariate,-1,0,1,double[],1
+nlme,getCovariate,-1,0,2,null,1
+nlme,getCovariate,-1,0,3,list<double[]>,1
+nlme,getCovariate,0,0,0,class<`data.frame`>,1
+nlme,getCovariate,0,0,1,"class<`data.frame`, `groupedData`, `nfGroupedData`, `nffGroupedData`>",1
+nlme,getCovariate,0,0,2,"class<`corExp`, `corSpatial`, `corStruct`>",1
+nlme,getCovariate,0,0,3,"class<`corRatio`, `corSpatial`, `corStruct`>",1
+nlme,getCovariate,0,0,4,"class<`corSpatial`, `corSpher`, `corStruct`>",1
+nlme,getCovariate,0,0,5,"class<`data.frame`, `groupedData`, `nfGroupedData`, `nfnGroupedData`>",1
+nlme,getCovariate,0,0,6,"class<`data.frame`, `groupedData`, `nmGroupedData`>",1
+nlme,getCovariate,0,0,7,"class<`varFunc`, `varPower`>",1
+nlme,getCovariate,0,0,8,"class<`corAR1`, `corStruct`>",1
+nlme,getCovariate,0,0,9,"class<`varExp`, `varFunc`>",1
+nlme,getCovariate,0,0,10,"class<`corGaus`, `corSpatial`, `corStruct`>",1
+nlme,getCovariate,0,0,11,"class<`corLin`, `corSpatial`, `corStruct`>",1
+nlme,getCovariate,0,0,12,"class<`corCAR1`, `corStruct`>",1
+nlme,getCovariate,0,0,13,"class<`corARMA`, `corStruct`>",1
+nlme,getCovariate,0,0,14,"class<`corStruct`, `corSymm`>",1
+nlme,getCovariate,0,0,15,"class<`corCompSymm`, `corStruct`>",1
+nlme,getCovariate,0,0,16,"class<`corNatural`, `corStruct`>",1
+nlme,getCovariate,1,0,0,any,1
+nlme,getCovariate,2,0,0,any,1
+nlme,getCovariate.corSpatial,-1,0,0,double[],1
+nlme,getCovariate.corSpatial,-1,0,1,list<double[]>,1
+nlme,getCovariate.corSpatial,0,0,0,"class<`corExp`, `corSpatial`, `corStruct`>",1
+nlme,getCovariate.corSpatial,0,0,1,"class<`corRatio`, `corSpatial`, `corStruct`>",1
+nlme,getCovariate.corSpatial,0,0,2,"class<`corSpatial`, `corSpher`, `corStruct`>",1
+nlme,getCovariate.corSpatial,0,0,3,"class<`corGaus`, `corSpatial`, `corStruct`>",1
+nlme,getCovariate.corSpatial,0,0,4,"class<`corLin`, `corSpatial`, `corStruct`>",1
+nlme,getCovariate.corSpatial,1,0,0,any,1
+nlme,getCovariate.corSpatial,2,0,0,any,1
+nlme,getCovariate.corStruct,-1,0,0,integer[],1
+nlme,getCovariate.corStruct,-1,0,1,list<double[]>,1
+nlme,getCovariate.corStruct,0,0,0,"class<`corAR1`, `corStruct`>",1
+nlme,getCovariate.corStruct,0,0,1,"class<`corCAR1`, `corStruct`>",1
+nlme,getCovariate.corStruct,0,0,2,"class<`corARMA`, `corStruct`>",1
+nlme,getCovariate.corStruct,0,0,3,"class<`corStruct`, `corSymm`>",1
+nlme,getCovariate.corStruct,0,0,4,"class<`corCompSymm`, `corStruct`>",1
+nlme,getCovariate.corStruct,0,0,5,"class<`corNatural`, `corStruct`>",1
+nlme,getCovariate.corStruct,1,0,0,any,1
+nlme,getCovariate.corStruct,2,0,0,any,1
+nlme,getCovariate.data.frame,-1,0,0,class<`factor`>,1
+nlme,getCovariate.data.frame,-1,0,1,double[],1
+nlme,getCovariate.data.frame,0,0,0,class<`data.frame`>,1
+nlme,getCovariate.data.frame,0,0,1,"class<`data.frame`, `groupedData`, `nfGroupedData`, `nffGroupedData`>",1
+nlme,getCovariate.data.frame,0,0,2,"class<`data.frame`, `groupedData`, `nfGroupedData`, `nfnGroupedData`>",1
+nlme,getCovariate.data.frame,0,0,3,"class<`data.frame`, `groupedData`, `nmGroupedData`>",1
+nlme,getCovariate.data.frame,1,0,0,class<`formula`>,1
+nlme,getCovariate.data.frame,2,0,0,any,1
+nlme,getCovariateFormula,-1,0,0,class<`formula`>,1
+nlme,getCovariateFormula,0,0,0,class<`call`>,1
+nlme,getCovariateFormula,0,0,1,"class<`data.frame`, `groupedData`, `nfGroupedData`, `nffGroupedData`>",1
+nlme,getCovariateFormula,0,0,2,"class<`data.frame`, `groupedData`, `nfGroupedData`, `nfnGroupedData`>",1
+nlme,getCovariateFormula,0,0,3,class<`formula`>,1
+nlme,getCovariateFormula,0,0,4,class<`gls`>,1
+nlme,getCovariateFormula,0,0,5,"class<`gls`, `gnls`>",1
+nlme,getCovariateFormula,0,0,6,"class<`lme`, `nlme`>",1
+nlme,getCovariateFormula,0,0,7,class<`lmList`>,1
+nlme,getCovariateFormula,0,0,8,"class<`varFunc`, `varPower`>",1
+nlme,getCovariate.varFunc,-1,0,0,double[],1
+nlme,getCovariate.varFunc,-1,0,1,null,1
+nlme,getCovariate.varFunc,0,0,0,"class<`varFunc`, `varPower`>",1
+nlme,getCovariate.varFunc,0,0,1,"class<`varExp`, `varFunc`>",1
+nlme,getCovariate.varFunc,1,0,0,any,1
+nlme,getCovariate.varFunc,2,0,0,any,1
+nlme,getData,-1,0,0,"class<`data.frame`, `groupedData`, `nfGroupedData`, `nfnGroupedData`>",1
+nlme,getData,0,0,0,class<`gls`>,1
+nlme,getData,0,0,1,class<`lme`>,1
+nlme,getData,0,0,2,"class<`gls`, `gnls`>",1
+nlme,getData,0,0,3,class<`lmList`>,1
+nlme,getData.gls,-1,0,0,"class<`data.frame`, `groupedData`, `nfGroupedData`, `nfnGroupedData`>",1
+nlme,getData.gls,0,0,0,class<`gls`>,1
+nlme,getData.gls,0,0,1,class<`lme`>,1
+nlme,getData.gnls,-1,0,0,"class<`data.frame`, `groupedData`, `nfGroupedData`, `nfnGroupedData`>",1
+nlme,getData.gnls,0,0,0,"class<`gls`, `gnls`>",1
+nlme,getData.lme,-1,0,0,"class<`data.frame`, `groupedData`, `nfGroupedData`, `nfnGroupedData`>",1
+nlme,getData.lme,0,0,0,class<`gls`>,1
+nlme,getData.lme,0,0,1,class<`lme`>,1
+nlme,getData.lmList,-1,0,0,"class<`data.frame`, `groupedData`, `nfGroupedData`, `nfnGroupedData`>",1
+nlme,getData.lmList,0,0,0,class<`lmList`>,1
+nlme,getFixDF,-1,0,0,list<double[]>,1
+nlme,getFixDF,0,0,0,class<`matrix`>,1
+nlme,getFixDF,1,0,0,class<`data.frame`>,1
+nlme,getFixDF,2,0,0,integer[],1
+nlme,getFixDF,3,0,0,integer[],1
+nlme,getFixDF,3,0,1,list<double[]>,1
+nlme,getFixDF,4,0,0,any,1
+nlme,getGroups,-1,0,0,character[],1
+nlme,getGroups,-1,0,1,class<`data.frame`>,1
+nlme,getGroups,-1,0,2,class<`factor`>,1
+nlme,getGroups,-1,0,3,"class<`factor`, `ordered`>",1
+nlme,getGroups,-1,0,4,null,1
+nlme,getGroups,0,0,0,"class<`varFunc`, `varIdent`>",1
+nlme,getGroups,0,0,1,"class<`varFunc`, `varPower`>",1
+nlme,getGroups,0,0,2,class<`data.frame`>,1
+nlme,getGroups,0,0,3,"class<`data.frame`, `groupedData`, `nmGroupedData`>",1
+nlme,getGroups,0,0,4,class<`lme`>,1
+nlme,getGroups,0,0,5,"class<`data.frame`, `groupedData`, `nfGroupedData`, `nfnGroupedData`>",1
+nlme,getGroups,0,0,6,"class<`corAR1`, `corStruct`>",1
+nlme,getGroups,0,0,7,"class<`corARMA`, `corStruct`>",1
+nlme,getGroups,0,0,8,"class<`corCAR1`, `corStruct`>",1
+nlme,getGroups,0,0,9,"class<`corCompSymm`, `corStruct`>",1
+nlme,getGroups,0,0,10,"class<`corExp`, `corSpatial`, `corStruct`>",1
+nlme,getGroups,0,0,11,"class<`corGaus`, `corSpatial`, `corStruct`>",1
+nlme,getGroups,0,0,12,"class<`corLin`, `corSpatial`, `corStruct`>",1
+nlme,getGroups,0,0,13,"class<`corRatio`, `corSpatial`, `corStruct`>",1
+nlme,getGroups,0,0,14,"class<`corSpatial`, `corSpher`, `corStruct`>",1
+nlme,getGroups,0,0,15,"class<`corStruct`, `corSymm`>",1
+nlme,getGroups,0,0,16,"class<`data.frame`, `groupedData`, `nfGroupedData`, `nffGroupedData`>",1
+nlme,getGroups,0,0,17,class<`gls`>,1
+nlme,getGroups,0,0,18,class<`lmList`>,1
+nlme,getGroups,0,0,19,"class<`lmList`, `nlsList`>",1
+nlme,getGroups,0,0,20,"class<`lme`, `nlme`>",1
+nlme,getGroups,0,0,21,"class<`gls`, `gnls`>",1
+nlme,getGroups,1,0,0,any,1
+nlme,getGroups,2,0,0,any,1
+nlme,getGroups,3,0,0,any,1
+nlme,getGroups,4,0,0,character,1
+nlme,getGroups.corStruct,-1,0,0,"class<`factor`, `ordered`>",1
+nlme,getGroups.corStruct,0,0,0,"class<`corAR1`, `corStruct`>",1
+nlme,getGroups.corStruct,0,0,1,"class<`corARMA`, `corStruct`>",1
+nlme,getGroups.corStruct,0,0,2,"class<`corCAR1`, `corStruct`>",1
+nlme,getGroups.corStruct,0,0,3,"class<`corCompSymm`, `corStruct`>",1
+nlme,getGroups.corStruct,0,0,4,"class<`corExp`, `corSpatial`, `corStruct`>",1
+nlme,getGroups.corStruct,0,0,5,"class<`corGaus`, `corSpatial`, `corStruct`>",1
+nlme,getGroups.corStruct,0,0,6,"class<`corLin`, `corSpatial`, `corStruct`>",1
+nlme,getGroups.corStruct,0,0,7,"class<`corRatio`, `corSpatial`, `corStruct`>",1
+nlme,getGroups.corStruct,0,0,8,"class<`corSpatial`, `corSpher`, `corStruct`>",1
+nlme,getGroups.corStruct,0,0,9,"class<`corStruct`, `corSymm`>",1
+nlme,getGroups.corStruct,1,0,0,any,1
+nlme,getGroups.corStruct,2,0,0,any,1
+nlme,getGroups.corStruct,3,0,0,any,1
+nlme,getGroups.corStruct,4,0,0,any,1
+nlme,getGroups.data.frame,-1,0,0,class<`data.frame`>,1
+nlme,getGroups.data.frame,-1,0,1,class<`factor`>,1
+nlme,getGroups.data.frame,-1,0,2,"class<`factor`, `ordered`>",1
+nlme,getGroups.data.frame,0,0,0,class<`data.frame`>,1
+nlme,getGroups.data.frame,0,0,1,"class<`data.frame`, `groupedData`, `nmGroupedData`>",1
+nlme,getGroups.data.frame,0,0,2,"class<`data.frame`, `groupedData`, `nfGroupedData`, `nfnGroupedData`>",1
+nlme,getGroups.data.frame,0,0,3,"class<`data.frame`, `groupedData`, `nfGroupedData`, `nffGroupedData`>",1
+nlme,getGroups.data.frame,1,0,0,class<`formula`>,1
+nlme,getGroups.data.frame,1,0,1,list<class<`formula`>>,1
+nlme,getGroups.data.frame,2,0,0,any,1
+nlme,getGroups.data.frame,3,0,0,any,1
+nlme,getGroups.data.frame,4,0,0,character,1
+nlme,getGroupsFormula,-1,0,0,class<`formula`>,1
+nlme,getGroupsFormula,-1,0,1,null,1
+nlme,getGroupsFormula,-1,0,2,list<class<`formula`>>,1
+nlme,getGroupsFormula,0,0,0,"class<`corAR1`, `corStruct`>",1
+nlme,getGroupsFormula,0,0,1,"class<`corCompSymm`, `corStruct`>",1
+nlme,getGroupsFormula,0,0,2,"class<`corStruct`, `corSymm`>",1
+nlme,getGroupsFormula,0,0,3,"class<`data.frame`, `groupedData`, `nfGroupedData`, `nffGroupedData`>",1
+nlme,getGroupsFormula,0,0,4,"class<`data.frame`, `groupedData`, `nfGroupedData`, `nfnGroupedData`>",1
+nlme,getGroupsFormula,0,0,5,class<`formula`>,1
+nlme,getGroupsFormula,0,0,6,class<`lmList`>,1
+nlme,getGroupsFormula,0,0,7,"class<`lmList`, `nlsList`>",1
+nlme,getGroupsFormula,0,0,8,class<`reStruct`>,1
+nlme,getGroupsFormula,0,0,9,"class<`varFunc`, `varIdent`>",1
+nlme,getGroupsFormula,0,0,10,"class<`varFunc`, `varPower`>",1
+nlme,getGroupsFormula,0,0,11,"class<`corARMA`, `corStruct`>",1
+nlme,getGroupsFormula,0,0,12,"class<`corCAR1`, `corStruct`>",1
+nlme,getGroupsFormula,0,0,13,"class<`corExp`, `corSpatial`, `corStruct`>",1
+nlme,getGroupsFormula,0,0,14,"class<`corGaus`, `corSpatial`, `corStruct`>",1
+nlme,getGroupsFormula,0,0,15,"class<`corLin`, `corSpatial`, `corStruct`>",1
+nlme,getGroupsFormula,0,0,16,"class<`corRatio`, `corSpatial`, `corStruct`>",1
+nlme,getGroupsFormula,0,0,17,"class<`corSpatial`, `corSpher`, `corStruct`>",1
+nlme,getGroupsFormula,0,0,18,"class<`varExp`, `varFunc`>",1
+nlme,getGroupsFormula,0,0,19,"class<`data.frame`, `groupedData`, `nmGroupedData`>",1
+nlme,getGroupsFormula,1,0,0,logical,1
+nlme,getGroupsFormula,2,0,0,any,1
+nlme,getGroupsFormula.default,-1,0,0,class<`formula`>,1
+nlme,getGroupsFormula.default,-1,0,1,null,1
+nlme,getGroupsFormula.default,-1,0,2,list<class<`formula`>>,1
+nlme,getGroupsFormula.default,0,0,0,"class<`corAR1`, `corStruct`>",1
+nlme,getGroupsFormula.default,0,0,1,"class<`corCompSymm`, `corStruct`>",1
+nlme,getGroupsFormula.default,0,0,2,"class<`corStruct`, `corSymm`>",1
+nlme,getGroupsFormula.default,0,0,3,"class<`data.frame`, `groupedData`, `nfGroupedData`, `nffGroupedData`>",1
+nlme,getGroupsFormula.default,0,0,4,"class<`data.frame`, `groupedData`, `nfGroupedData`, `nfnGroupedData`>",1
+nlme,getGroupsFormula.default,0,0,5,class<`formula`>,1
+nlme,getGroupsFormula.default,0,0,6,"class<`varFunc`, `varIdent`>",1
+nlme,getGroupsFormula.default,0,0,7,"class<`varFunc`, `varPower`>",1
+nlme,getGroupsFormula.default,0,0,8,"class<`corARMA`, `corStruct`>",1
+nlme,getGroupsFormula.default,0,0,9,"class<`corCAR1`, `corStruct`>",1
+nlme,getGroupsFormula.default,0,0,10,"class<`corExp`, `corSpatial`, `corStruct`>",1
+nlme,getGroupsFormula.default,0,0,11,"class<`corGaus`, `corSpatial`, `corStruct`>",1
+nlme,getGroupsFormula.default,0,0,12,"class<`corLin`, `corSpatial`, `corStruct`>",1
+nlme,getGroupsFormula.default,0,0,13,"class<`corRatio`, `corSpatial`, `corStruct`>",1
+nlme,getGroupsFormula.default,0,0,14,"class<`corSpatial`, `corSpher`, `corStruct`>",1
+nlme,getGroupsFormula.default,0,0,15,"class<`varExp`, `varFunc`>",1
+nlme,getGroupsFormula.default,0,0,16,"class<`data.frame`, `groupedData`, `nmGroupedData`>",1
+nlme,getGroupsFormula.default,1,0,0,logical,1
+nlme,getGroupsFormula.default,2,0,0,any,1
+nlme,getGroupsFormula.lmList,-1,0,0,class<`formula`>,1
+nlme,getGroupsFormula.lmList,-1,0,1,list<class<`formula`>>,1
+nlme,getGroupsFormula.lmList,0,0,0,class<`lmList`>,1
+nlme,getGroupsFormula.lmList,0,0,1,"class<`lmList`, `nlsList`>",1
+nlme,getGroupsFormula.lmList,1,0,0,logical,1
+nlme,getGroupsFormula.lmList,2,0,0,any,1
+nlme,getGroupsFormula.reStruct,-1,0,0,class<`formula`>,1
+nlme,getGroupsFormula.reStruct,-1,0,1,null,1
+nlme,getGroupsFormula.reStruct,0,0,0,class<`reStruct`>,1
+nlme,getGroupsFormula.reStruct,1,0,0,logical,1
+nlme,getGroupsFormula.reStruct,2,0,0,any,1
+nlme,getGroups.gls,-1,0,0,"class<`factor`, `ordered`>",1
+nlme,getGroups.gls,-1,0,1,null,1
+nlme,getGroups.gls,0,0,0,class<`gls`>,1
+nlme,getGroups.gls,0,0,1,"class<`gls`, `gnls`>",1
+nlme,getGroups.gls,1,0,0,any,1
+nlme,getGroups.gls,2,0,0,any,1
+nlme,getGroups.gls,3,0,0,any,1
+nlme,getGroups.gls,4,0,0,any,1
+nlme,getGroups.lme,-1,0,0,class<`data.frame`>,1
+nlme,getGroups.lme,-1,0,1,"class<`factor`, `ordered`>",1
+nlme,getGroups.lme,0,0,0,class<`lme`>,1
+nlme,getGroups.lme,0,0,1,"class<`lme`, `nlme`>",1
+nlme,getGroups.lme,1,0,0,any,1
+nlme,getGroups.lme,2,0,0,integer[],1
+nlme,getGroups.lme,2,0,1,double,1
+nlme,getGroups.lme,3,0,0,any,1
+nlme,getGroups.lme,4,0,0,any,1
+nlme,getGroups.lmList,-1,0,0,"class<`factor`, `ordered`>",1
+nlme,getGroups.lmList,0,0,0,class<`lmList`>,1
+nlme,getGroups.lmList,0,0,1,"class<`lmList`, `nlsList`>",1
+nlme,getGroups.lmList,1,0,0,any,1
+nlme,getGroups.lmList,2,0,0,any,1
+nlme,getGroups.lmList,3,0,0,any,1
+nlme,getGroups.lmList,4,0,0,any,1
+nlme,getGroups.varFunc,-1,0,0,character[],1
+nlme,getGroups.varFunc,-1,0,1,null,1
+nlme,getGroups.varFunc,0,0,0,"class<`varFunc`, `varIdent`>",1
+nlme,getGroups.varFunc,0,0,1,"class<`varFunc`, `varPower`>",1
+nlme,getGroups.varFunc,1,0,0,any,1
+nlme,getGroups.varFunc,2,0,0,any,1
+nlme,getGroups.varFunc,3,0,0,any,1
+nlme,getGroups.varFunc,4,0,0,any,1
+nlme,getParsGnls,-1,0,0,class<`matrix`>,1
+nlme,getParsGnls,0,0,0,list<class<`matrix`> | logical>,1
+nlme,getParsGnls,0,0,1,list<logical>,1
+nlme,getParsGnls,1,0,0,list<integer[] | double>,1
+nlme,getParsGnls,1,0,1,list<double>,1
+nlme,getParsGnls,2,0,0,double[],1
+nlme,getParsGnls,3,0,0,integer,1
+nlme,getParsNlme,-1,0,0,class<`matrix`>,1
+nlme,getParsNlme,0,0,0,list<list<class<`matrix`> | list<logical>>>,1
+nlme,getParsNlme,0,0,1,list<list<logical | list<logical>>>,1
+nlme,getParsNlme,0,0,2,list<list<class<`matrix`> | list<logical> | logical | list<logical>>>,1
+nlme,getParsNlme,1,0,0,list<integer[]>,1
+nlme,getParsNlme,1,0,1,list<double>,1
+nlme,getParsNlme,1,0,2,list<integer[] | double>,1
+nlme,getParsNlme,2,0,0,any,1
+nlme,getParsNlme,3,0,0,any,1
+nlme,getParsNlme,4,0,0,any,1
+nlme,getParsNlme,5,0,0,double[],1
+nlme,getParsNlme,6,0,0,any,1
+nlme,getParsNlme,7,0,0,any,1
+nlme,getResponse,-1,0,0,^double[],1
+nlme,getResponse,0,0,0,class<`data.frame`>,1
+nlme,getResponse,0,0,1,"class<`data.frame`, `groupedData`, `nfGroupedData`, `nffGroupedData`>",1
+nlme,getResponse,0,0,2,"class<`data.frame`, `groupedData`, `nfGroupedData`, `nfnGroupedData`>",1
+nlme,getResponse,0,0,3,"class<`lme`, `nlme`>",1
+nlme,getResponse,0,0,4,class<`lme`>,1
+nlme,getResponse,1,0,0,any,1
+nlme,getResponse.data.frame,-1,0,0,^double[],1
+nlme,getResponse.data.frame,0,0,0,class<`data.frame`>,1
+nlme,getResponse.data.frame,0,0,1,"class<`data.frame`, `groupedData`, `nfGroupedData`, `nffGroupedData`>",1
+nlme,getResponse.data.frame,0,0,2,"class<`data.frame`, `groupedData`, `nfGroupedData`, `nfnGroupedData`>",1
+nlme,getResponse.data.frame,1,0,0,class<`formula`>,1
+nlme,getResponseFormula,-1,0,0,class<`formula`>,1
+nlme,getResponseFormula,0,0,0,class<`call`>,1
+nlme,getResponseFormula,0,0,1,"class<`data.frame`, `groupedData`, `nfGroupedData`, `nffGroupedData`>",1
+nlme,getResponseFormula,0,0,2,"class<`data.frame`, `groupedData`, `nfGroupedData`, `nfnGroupedData`>",1
+nlme,getResponseFormula,0,0,3,class<`formula`>,1
+nlme,getResponseFormula,0,0,4,class<`gls`>,1
+nlme,getResponseFormula,0,0,5,"class<`gls`, `gnls`>",1
+nlme,getResponseFormula,0,0,6,class<`lme`>,1
+nlme,getResponseFormula,0,0,7,"class<`lme`, `nlme`>",1
+nlme,getResponseFormula,0,0,8,class<`lmList`>,1
+nlme,getResponse.lme,-1,0,0,double[],1
+nlme,getResponse.lme,0,0,0,"class<`lme`, `nlme`>",1
+nlme,getResponse.lme,0,0,1,class<`lme`>,1
+nlme,getResponse.lme,1,0,0,any,1
+nlme,getVarCov,-1,0,0,"class<`VarCov`, `conditional`>",1
+nlme,getVarCov,-1,0,1,"class<`VarCov`, `marginal`>",1
+nlme,getVarCov,-1,0,2,"class<`VarCov`, `random.effects`>",1
+nlme,getVarCov,0,0,0,class<`lme`>,1
+nlme,getVarCov,0,0,1,class<`gls`>,1
+nlme,getVarCov,1,0,0,...,1
+nlme,getVarCov.gls,-1,0,0,"class<`VarCov`, `marginal`>",1
+nlme,getVarCov.gls,0,0,0,class<`gls`>,1
+nlme,getVarCov.gls,1,0,0,double,1
+nlme,getVarCov.gls,2,0,0,...,1
+nlme,getVarCov.lme,-1,0,0,"class<`VarCov`, `conditional`>",1
+nlme,getVarCov.lme,-1,0,1,"class<`VarCov`, `marginal`>",1
+nlme,getVarCov.lme,-1,0,2,"class<`VarCov`, `random.effects`>",1
+nlme,getVarCov.lme,0,0,0,class<`lme`>,1
+nlme,getVarCov.lme,1,0,0,any,1
+nlme,getVarCov.lme,2,0,0,character[],1
+nlme,getVarCov.lme,3,0,0,...,1
+nlme,gls,-1,0,0,any,1
+nlme,gls,0,0,0,class<`formula`>,1
+nlme,gls,1,0,0,class<`data.frame`>,1
+nlme,gls,1,0,1,"class<`data.frame`, `groupedData`, `nfGroupedData`, `nffGroupedData`>",1
+nlme,gls,1,0,2,"class<`data.frame`, `groupedData`, `nfGroupedData`, `nfnGroupedData`>",1
+nlme,gls,1,0,3,environment,1
+nlme,gls,2,0,0,"class<`corAR1`, `corStruct`>",1
+nlme,gls,2,0,1,"class<`corRatio`, `corSpatial`, `corStruct`>",1
+nlme,gls,2,0,2,"class<`corSpatial`, `corSpher`, `corStruct`>",1
+nlme,gls,2,0,3,null,1
+nlme,gls,2,0,4,"class<`corCompSymm`, `corStruct`>",1
+nlme,gls,2,0,5,"class<`corStruct`, `corSymm`>",1
+nlme,gls,3,0,0,null,1
+nlme,gls,3,0,1,"class<`varFunc`, `varPower`>",1
+nlme,gls,3,0,2,"class<`varFunc`, `varIdent`>",1
+nlme,gls,4,0,0,any,1
+nlme,gls,5,0,0,character[],1
+nlme,gls,6,0,0,class<`function`>,1
+nlme,gls,7,0,0,any,1
+nlme,glsApVar,-1,0,0,class<`matrix`>,1
+nlme,glsApVar,-1,0,1,null,1
+nlme,glsApVar,0,0,0,"class<`glsStruct`, `modelStruct`>",1
+nlme,glsApVar,1,0,0,any,1
+nlme,glsApVar,2,0,0,any,1
+nlme,glsApVar,3,0,0,any,1
+nlme,glsApVar,4,0,0,any,1
+nlme,glsApVar,5,0,0,any,1
+nlme,glsControl,-1,0,0,list<double | character>,1
+nlme,glsControl,0,0,0,double,1
+nlme,glsControl,1,0,0,double,1
+nlme,glsControl,2,0,0,double,1
+nlme,glsControl,3,0,0,double,1
+nlme,glsControl,4,0,0,logical,1
+nlme,glsControl,5,0,0,logical,1
+nlme,glsControl,6,0,0,logical,1
+nlme,glsControl,7,0,0,logical,1
+nlme,glsEstimate,-1,0,0,list<class<`logLik`> | double[] | class<`matrix`>>,1
+nlme,glsEstimate,-1,0,1,list<double[] | class<`matrix`>>,1
+nlme,glsEstimate,-1,0,2,list<class<`matrix`> | double[]>,1
+nlme,glsEstimate,0,0,0,"class<`glsStruct`, `modelStruct`>",1
+nlme,glsEstimate,1,0,0,list<class<`matrix`> | double | list<integer>>,1
+nlme,glsEstimate,2,0,0,list<logical>,1
+nlme,glsStruct,-1,0,0,"class<`glsStruct`, `modelStruct`>",1
+nlme,glsStruct,0,0,0,"class<`corAR1`, `corStruct`>",1
+nlme,glsStruct,0,0,1,"class<`corCompSymm`, `corStruct`>",1
+nlme,glsStruct,0,0,2,"class<`corRatio`, `corSpatial`, `corStruct`>",1
+nlme,glsStruct,0,0,3,"class<`corSpatial`, `corSpher`, `corStruct`>",1
+nlme,glsStruct,0,0,4,"class<`corStruct`, `corSymm`>",1
+nlme,glsStruct,0,0,5,null,1
+nlme,glsStruct,1,0,0,"class<`varFunc`, `varPower`>",1
+nlme,glsStruct,1,0,1,null,1
+nlme,glsStruct,1,0,2,"class<`varFunc`, `varIdent`>",1
+nlme,gnls,-1,0,0,"class<`gls`, `gnls`>",1
+nlme,gnls,0,0,0,class<`formula`>,1
+nlme,gnls,1,0,0,"class<`data.frame`, `groupedData`, `nfGroupedData`, `nfnGroupedData`>",1
+nlme,gnls,2,0,0,any,1
+nlme,gnls,3,0,0,any,1
+nlme,gnls,4,0,0,"class<`corAR1`, `corStruct`>",1
+nlme,gnls,4,0,1,null,1
+nlme,gnls,5,0,0,"class<`varFunc`, `varPower`>",1
+nlme,gnls,5,0,1,null,1
+nlme,gnls,6,0,0,any,1
+nlme,gnls,7,0,0,class<`function`>,1
+nlme,gnlsApVar,-1,0,0,class<`matrix`>,1
+nlme,gnlsApVar,-1,0,1,null,1
+nlme,gnlsApVar,0,0,0,"class<`glsStruct`, `gnlsStruct`, `modelStruct`>",1
+nlme,gnlsApVar,1,0,0,any,1
+nlme,gnlsApVar,2,0,0,any,1
+nlme,gnlsApVar,3,0,0,any,1
+nlme,gnlsApVar,4,0,0,any,1
+nlme,gnlsApVar,5,0,0,logical,1
+nlme,gnlsControl,-1,0,0,list<double | character>,1
+nlme,gnlsControl,0,0,0,double,1
+nlme,gnlsControl,1,0,0,double,1
+nlme,gnlsControl,2,0,0,double,1
+nlme,gnlsControl,3,0,0,double,1
+nlme,gnlsControl,4,0,0,double,1
+nlme,gnlsControl,5,0,0,double,1
+nlme,gnlsControl,6,0,0,double,1
+nlme,gnlsControl,7,0,0,logical,1
+nlme,gnlsStruct,-1,0,0,"class<`glsStruct`, `gnlsStruct`, `modelStruct`>",1
+nlme,gnlsStruct,0,0,0,"class<`corAR1`, `corStruct`>",1
+nlme,gnlsStruct,0,0,1,null,1
+nlme,gnlsStruct,1,0,0,"class<`varFunc`, `varPower`>",1
+nlme,gnlsStruct,1,0,1,null,1
+nlme,groupedData,-1,0,0,"class<`data.frame`, `groupedData`, `nfGroupedData`, `nffGroupedData`>",1
+nlme,groupedData,-1,0,1,"class<`data.frame`, `groupedData`, `nfGroupedData`, `nfnGroupedData`>",1
+nlme,groupedData,-1,0,2,"class<`data.frame`, `groupedData`, `nmGroupedData`>",1
+nlme,groupedData,0,0,0,class<`formula`>,1
+nlme,groupedData,1,0,0,any,1
+nlme,groupedData,2,0,0,logical,1
+nlme,groupedData,2,0,1,list<logical>,1
+nlme,groupedData,3,0,0,any,1
+nlme,groupedData,4,0,0,any,1
+nlme,groupedData,5,0,0,null,1
+nlme,groupedData,6,0,0,any,1
+nlme,groupedData,7,0,0,any,1
+nlme,[.groupedData,-1,0,0,class<`data.frame`>,1
+nlme,[.groupedData,-1,0,1,"class<`data.frame`, `groupedData`, `nfGroupedData`, `nfnGroupedData`>",1
+nlme,[.groupedData,-1,0,2,"class<`data.frame`, `groupedData`, `nmGroupedData`>",1
+nlme,[.groupedData,-1,0,3,class<`factor`>,1
+nlme,[.groupedData,-1,0,4,"class<`factor`, `ordered`>",1
+nlme,[.groupedData,0,0,0,"class<`data.frame`, `groupedData`, `nfGroupedData`, `nfnGroupedData`>",1
+nlme,[.groupedData,0,0,1,"class<`data.frame`, `groupedData`, `nmGroupedData`>",1
+nlme,[.groupedData,0,0,2,"class<`data.frame`, `groupedData`, `nfGroupedData`, `nffGroupedData`>",1
+nlme,[.groupedData,1,0,0,any,1
+nlme,[.groupedData,2,0,0,any,1
+nlme,[.groupedData,3,0,0,any,1
+nlme,gsummary,-1,0,0,class<`data.frame`>,1
+nlme,gsummary,0,0,0,class<`data.frame`>,1
+nlme,gsummary,0,0,1,"class<`data.frame`, `groupedData`, `nfGroupedData`, `nfnGroupedData`>",1
+nlme,gsummary,0,0,2,"class<`data.frame`, `groupedData`, `nmGroupedData`>",1
+nlme,gsummary,1,0,0,any,1
+nlme,gsummary,2,0,0,logical,1
+nlme,gsummary,3,0,0,any,1
+nlme,gsummary,4,0,0,any,1
+nlme,gsummary,5,0,0,class<`factor`>,1
+nlme,gsummary,5,0,1,"class<`factor`, `ordered`>",1
+nlme,gsummary,5,0,2,character[],1
+nlme,gsummary,6,0,0,logical,1
+nlme,gsummary,7,0,0,...,1
+nlme,Initialize,-1,0,0,"class<`corAR1`, `corStruct`>",1
+nlme,Initialize,-1,0,1,"class<`corARMA`, `corStruct`>",1
+nlme,Initialize,-1,0,2,"class<`corCAR1`, `corStruct`>",1
+nlme,Initialize,-1,0,3,"class<`corCompSymm`, `corStruct`>",1
+nlme,Initialize,-1,0,4,"class<`corExp`, `corSpatial`, `corStruct`>",1
+nlme,Initialize,-1,0,5,"class<`corGaus`, `corSpatial`, `corStruct`>",1
+nlme,Initialize,-1,0,6,"class<`corLin`, `corSpatial`, `corStruct`>",1
+nlme,Initialize,-1,0,7,"class<`corRatio`, `corSpatial`, `corStruct`>",1
+nlme,Initialize,-1,0,8,"class<`corSpatial`, `corSpher`, `corStruct`>",1
+nlme,Initialize,-1,0,9,"class<`corStruct`, `corSymm`>",1
+nlme,Initialize,-1,0,10,class<`reStruct`>,1
+nlme,Initialize,-1,0,11,"class<`varFunc`, `varIdent`>",1
+nlme,Initialize,-1,0,12,"class<`varFunc`, `varPower`>",1
+nlme,Initialize,-1,0,13,"class<`glsStruct`, `gnlsStruct`, `modelStruct`>",1
+nlme,Initialize,-1,0,14,"class<`glsStruct`, `modelStruct`>",1
+nlme,Initialize,-1,0,15,"class<`lmeStruct`, `lmeStructInt`, `modelStruct`>",1
+nlme,Initialize,-1,0,16,"class<`lmeStruct`, `lmeStructInt`, `modelStruct`, `nlmeStruct`>",1
+nlme,Initialize,-1,0,17,"class<`lmeStruct`, `modelStruct`>",1
+nlme,Initialize,-1,0,18,"class<`lmeStruct`, `modelStruct`, `nlmeStruct`>",1
+nlme,Initialize,-1,0,19,"class<`varExp`, `varFunc`>",1
+nlme,Initialize,0,0,0,"class<`corAR1`, `corStruct`>",1
+nlme,Initialize,0,0,1,"class<`corARMA`, `corStruct`>",1
+nlme,Initialize,0,0,2,"class<`corCAR1`, `corStruct`>",1
+nlme,Initialize,0,0,3,"class<`corCompSymm`, `corStruct`>",1
+nlme,Initialize,0,0,4,"class<`corExp`, `corSpatial`, `corStruct`>",1
+nlme,Initialize,0,0,5,"class<`corGaus`, `corSpatial`, `corStruct`>",1
+nlme,Initialize,0,0,6,"class<`corLin`, `corSpatial`, `corStruct`>",1
+nlme,Initialize,0,0,7,"class<`corRatio`, `corSpatial`, `corStruct`>",1
+nlme,Initialize,0,0,8,"class<`corSpatial`, `corSpher`, `corStruct`>",1
+nlme,Initialize,0,0,9,"class<`corStruct`, `corSymm`>",1
+nlme,Initialize,0,0,10,class<`reStruct`>,1
+nlme,Initialize,0,0,11,"class<`varFunc`, `varIdent`>",1
+nlme,Initialize,0,0,12,"class<`varFunc`, `varPower`>",1
+nlme,Initialize,0,0,13,"class<`glsStruct`, `gnlsStruct`, `modelStruct`>",1
+nlme,Initialize,0,0,14,"class<`glsStruct`, `modelStruct`>",1
+nlme,Initialize,0,0,15,"class<`lmeStruct`, `modelStruct`>",1
+nlme,Initialize,0,0,16,"class<`lmeStruct`, `modelStruct`, `nlmeStruct`>",1
+nlme,Initialize,0,0,17,"class<`varExp`, `varFunc`>",1
+nlme,Initialize,1,0,0,any,1
+nlme,Initialize,2,0,0,...,1
+nlme,Initialize.corAR1,-1,0,0,"class<`corAR1`, `corStruct`>",1
+nlme,Initialize.corAR1,0,0,0,"class<`corAR1`, `corStruct`>",1
+nlme,Initialize.corAR1,1,0,0,class<`data.frame`>,1
+nlme,Initialize.corAR1,1,0,1,"class<`data.frame`, `groupedData`, `nfGroupedData`, `nfnGroupedData`>",1
+nlme,Initialize.corAR1,2,0,0,...,1
+nlme,Initialize.corARMA,-1,0,0,"class<`corARMA`, `corStruct`>",1
+nlme,Initialize.corARMA,0,0,0,"class<`corARMA`, `corStruct`>",1
+nlme,Initialize.corARMA,1,0,0,class<`data.frame`>,1
+nlme,Initialize.corARMA,1,0,1,"class<`data.frame`, `groupedData`, `nfGroupedData`, `nfnGroupedData`>",1
+nlme,Initialize.corARMA,2,0,0,...,1
+nlme,Initialize.corCAR1,-1,0,0,"class<`corCAR1`, `corStruct`>",1
+nlme,Initialize.corCAR1,0,0,0,"class<`corCAR1`, `corStruct`>",1
+nlme,Initialize.corCAR1,1,0,0,class<`data.frame`>,1
+nlme,Initialize.corCAR1,2,0,0,...,1
+nlme,Initialize.corCompSymm,-1,0,0,"class<`corCompSymm`, `corStruct`>",1
+nlme,Initialize.corCompSymm,0,0,0,"class<`corCompSymm`, `corStruct`>",1
+nlme,Initialize.corCompSymm,1,0,0,class<`data.frame`>,1
+nlme,Initialize.corCompSymm,1,0,1,"class<`data.frame`, `groupedData`, `nfGroupedData`, `nfnGroupedData`>",1
+nlme,Initialize.corCompSymm,2,0,0,...,1
+nlme,Initialize.corLin,-1,0,0,"class<`corLin`, `corSpatial`, `corStruct`>",1
+nlme,Initialize.corLin,0,0,0,"class<`corLin`, `corSpatial`, `corStruct`>",1
+nlme,Initialize.corLin,1,0,0,class<`data.frame`>,1
+nlme,Initialize.corLin,1,0,1,"class<`data.frame`, `groupedData`, `nfGroupedData`, `nfnGroupedData`>",1
+nlme,Initialize.corLin,2,0,0,...,1
+nlme,Initialize.corSpatial,-1,0,0,"class<`corExp`, `corSpatial`, `corStruct`>",1
+nlme,Initialize.corSpatial,-1,0,1,"class<`corGaus`, `corSpatial`, `corStruct`>",1
+nlme,Initialize.corSpatial,-1,0,2,"class<`corRatio`, `corSpatial`, `corStruct`>",1
+nlme,Initialize.corSpatial,0,0,0,"class<`corExp`, `corSpatial`, `corStruct`>",1
+nlme,Initialize.corSpatial,0,0,1,"class<`corGaus`, `corSpatial`, `corStruct`>",1
+nlme,Initialize.corSpatial,0,0,2,"class<`corRatio`, `corSpatial`, `corStruct`>",1
+nlme,Initialize.corSpatial,1,0,0,class<`data.frame`>,1
+nlme,Initialize.corSpatial,1,0,1,"class<`data.frame`, `groupedData`, `nfGroupedData`, `nfnGroupedData`>",1
+nlme,Initialize.corSpatial,2,0,0,...,1
+nlme,Initialize.corSpher,-1,0,0,"class<`corSpatial`, `corSpher`, `corStruct`>",1
+nlme,Initialize.corSpher,0,0,0,"class<`corSpatial`, `corSpher`, `corStruct`>",1
+nlme,Initialize.corSpher,1,0,0,class<`data.frame`>,1
+nlme,Initialize.corSpher,1,0,1,"class<`data.frame`, `groupedData`, `nfGroupedData`, `nfnGroupedData`>",1
+nlme,Initialize.corSpher,2,0,0,...,1
+nlme,Initialize.corStruct,-1,0,0,"class<`corExp`, `corSpatial`, `corStruct`>",1
+nlme,Initialize.corStruct,-1,0,1,"class<`corGaus`, `corSpatial`, `corStruct`>",1
+nlme,Initialize.corStruct,-1,0,2,"class<`corLin`, `corSpatial`, `corStruct`>",1
+nlme,Initialize.corStruct,-1,0,3,"class<`corRatio`, `corSpatial`, `corStruct`>",1
+nlme,Initialize.corStruct,-1,0,4,"class<`corSpatial`, `corSpher`, `corStruct`>",1
+nlme,Initialize.corStruct,-1,0,5,"class<`corAR1`, `corStruct`>",1
+nlme,Initialize.corStruct,-1,0,6,"class<`corARMA`, `corStruct`>",1
+nlme,Initialize.corStruct,-1,0,7,"class<`corCAR1`, `corStruct`>",1
+nlme,Initialize.corStruct,-1,0,8,"class<`corCompSymm`, `corStruct`>",1
+nlme,Initialize.corStruct,-1,0,9,"class<`corStruct`, `corSymm`>",1
+nlme,Initialize.corStruct,0,0,0,"class<`corExp`, `corSpatial`, `corStruct`>",1
+nlme,Initialize.corStruct,0,0,1,"class<`corGaus`, `corSpatial`, `corStruct`>",1
+nlme,Initialize.corStruct,0,0,2,"class<`corLin`, `corSpatial`, `corStruct`>",1
+nlme,Initialize.corStruct,0,0,3,"class<`corRatio`, `corSpatial`, `corStruct`>",1
+nlme,Initialize.corStruct,0,0,4,"class<`corSpatial`, `corSpher`, `corStruct`>",1
+nlme,Initialize.corStruct,0,0,5,"class<`corAR1`, `corStruct`>",1
+nlme,Initialize.corStruct,0,0,6,"class<`corARMA`, `corStruct`>",1
+nlme,Initialize.corStruct,0,0,7,"class<`corCAR1`, `corStruct`>",1
+nlme,Initialize.corStruct,0,0,8,"class<`corCompSymm`, `corStruct`>",1
+nlme,Initialize.corStruct,0,0,9,"class<`corStruct`, `corSymm`>",1
+nlme,Initialize.corStruct,1,0,0,class<`data.frame`>,1
+nlme,Initialize.corStruct,1,0,1,"class<`data.frame`, `groupedData`, `nfGroupedData`, `nfnGroupedData`>",1
+nlme,Initialize.corStruct,2,0,0,...,1
+nlme,Initialize.corSymm,-1,0,0,"class<`corStruct`, `corSymm`>",1
+nlme,Initialize.corSymm,0,0,0,"class<`corStruct`, `corSymm`>",1
+nlme,Initialize.corSymm,1,0,0,class<`data.frame`>,1
+nlme,Initialize.corSymm,1,0,1,"class<`data.frame`, `groupedData`, `nfGroupedData`, `nfnGroupedData`>",1
+nlme,Initialize.corSymm,2,0,0,...,1
+nlme,Initialize.glsStruct,-1,0,0,"class<`glsStruct`, `modelStruct`>",1
+nlme,Initialize.glsStruct,0,0,0,"class<`glsStruct`, `modelStruct`>",1
+nlme,Initialize.glsStruct,1,0,0,any,1
+nlme,Initialize.glsStruct,2,0,0,any,1
+nlme,Initialize.glsStruct,3,0,0,...,1
+nlme,Initialize.gnlsStruct,-1,0,0,"class<`glsStruct`, `gnlsStruct`, `modelStruct`>",1
+nlme,Initialize.gnlsStruct,0,0,0,"class<`glsStruct`, `gnlsStruct`, `modelStruct`>",1
+nlme,Initialize.gnlsStruct,1,0,0,any,1
+nlme,Initialize.gnlsStruct,2,0,0,...,1
+nlme,Initialize.lmeStruct,-1,0,0,"class<`lmeStruct`, `lmeStructInt`, `modelStruct`>",1
+nlme,Initialize.lmeStruct,-1,0,1,"class<`lmeStruct`, `lmeStructInt`, `modelStruct`, `nlmeStruct`>",1
+nlme,Initialize.lmeStruct,-1,0,2,"class<`lmeStruct`, `modelStruct`>",1
+nlme,Initialize.lmeStruct,-1,0,3,"class<`lmeStruct`, `modelStruct`, `nlmeStruct`>",1
+nlme,Initialize.lmeStruct,0,0,0,"class<`lmeStruct`, `modelStruct`>",1
+nlme,Initialize.lmeStruct,0,0,1,"class<`lmeStruct`, `modelStruct`, `nlmeStruct`>",1
+nlme,Initialize.lmeStruct,1,0,0,any,1
+nlme,Initialize.lmeStruct,2,0,0,any,1
+nlme,Initialize.lmeStruct,3,0,0,list<class<`matrix`> | double | list<double[] | list<double[]>>>,1
+nlme,Initialize.lmeStruct,4,0,0,list<double | character>,1
+nlme,Initialize.lmeStruct,5,0,0,...,1
+nlme,Initialize.reStruct,-1,0,0,class<`reStruct`>,1
+nlme,Initialize.reStruct,0,0,0,class<`reStruct`>,1
+nlme,Initialize.reStruct,1,0,0,any,1
+nlme,Initialize.reStruct,2,0,0,list<class<`matrix`> | double | list<double[] | list<double[]>>>,1
+nlme,Initialize.reStruct,3,0,0,list<double | character>,1
+nlme,Initialize.reStruct,4,0,0,...,1
+nlme,Initialize.varExp,-1,0,0,"class<`varExp`, `varFunc`>",1
+nlme,Initialize.varExp,0,0,0,"class<`varExp`, `varFunc`>",1
+nlme,Initialize.varExp,1,0,0,"class<`data.frame`, `groupedData`, `nfGroupedData`, `nfnGroupedData`>",1
+nlme,Initialize.varExp,2,0,0,...,1
+nlme,Initialize.varFunc,-1,0,0,"class<`varExp`, `varFunc`>",1
+nlme,Initialize.varFunc,-1,0,1,"class<`varFunc`, `varPower`>",1
+nlme,Initialize.varFunc,0,0,0,"class<`varExp`, `varFunc`>",1
+nlme,Initialize.varFunc,0,0,1,"class<`varFunc`, `varPower`>",1
+nlme,Initialize.varFunc,1,0,0,"class<`data.frame`, `groupedData`, `nfGroupedData`, `nfnGroupedData`>",1
+nlme,Initialize.varFunc,1,0,1,class<`data.frame`>,1
+nlme,Initialize.varFunc,2,0,0,...,1
+nlme,Initialize.varIdent,-1,0,0,"class<`varFunc`, `varIdent`>",1
+nlme,Initialize.varIdent,0,0,0,"class<`varFunc`, `varIdent`>",1
+nlme,Initialize.varIdent,1,0,0,any,1
+nlme,Initialize.varIdent,2,0,0,...,1
+nlme,Initialize.varPower,-1,0,0,"class<`varFunc`, `varPower`>",1
+nlme,Initialize.varPower,0,0,0,"class<`varFunc`, `varPower`>",1
+nlme,Initialize.varPower,1,0,0,"class<`data.frame`, `groupedData`, `nfGroupedData`, `nfnGroupedData`>",1
+nlme,Initialize.varPower,1,0,1,class<`data.frame`>,1
+nlme,Initialize.varPower,2,0,0,...,1
+nlme,intervals,-1,0,0,class<`intervals.gls`>,1
+nlme,intervals,-1,0,1,class<`intervals.lme`>,1
+nlme,intervals,-1,0,2,class<`intervals.lmList`>,1
+nlme,intervals,0,0,0,class<`gls`>,1
+nlme,intervals,0,0,1,"class<`gls`, `gnls`>",1
+nlme,intervals,0,0,2,class<`lme`>,1
+nlme,intervals,0,0,3,class<`lmList`>,1
+nlme,intervals,0,0,4,"class<`lmList`, `nlsList`>",1
+nlme,intervals,1,0,0,double,1
+nlme,intervals,2,0,0,...,1
+nlme,intervals.gls,-1,0,0,class<`intervals.gls`>,1
+nlme,intervals.gls,0,0,0,class<`gls`>,1
+nlme,intervals.gls,0,0,1,"class<`gls`, `gnls`>",1
+nlme,intervals.gls,1,0,0,double,1
+nlme,intervals.gls,2,0,0,character[],1
+nlme,intervals.gls,3,0,0,...,1
+nlme,intervals.lme,-1,0,0,class<`intervals.lme`>,1
+nlme,intervals.lme,0,0,0,class<`lme`>,1
+nlme,intervals.lme,1,0,0,double,1
+nlme,intervals.lme,2,0,0,character[],1
+nlme,intervals.lme,3,0,0,...,1
+nlme,intervals.lmList,-1,0,0,class<`intervals.lmList`>,1
+nlme,intervals.lmList,0,0,0,class<`lmList`>,1
+nlme,intervals.lmList,0,0,1,"class<`lmList`, `nlsList`>",1
+nlme,intervals.lmList,1,0,0,double,1
+nlme,intervals.lmList,2,0,0,logical,1
+nlme,intervals.lmList,3,0,0,...,1
+nlme,isBalanced,-1,0,0,logical,1
+nlme,isBalanced,0,0,0,"class<`data.frame`, `groupedData`, `nfGroupedData`, `nfnGroupedData`>",1
+nlme,isBalanced,0,0,1,"class<`data.frame`, `groupedData`, `nmGroupedData`>",1
+nlme,isBalanced,1,0,0,logical,1
+nlme,isBalanced,2,0,0,any,1
+nlme,isBalanced.groupedData,-1,0,0,logical,1
+nlme,isBalanced.groupedData,0,0,0,"class<`data.frame`, `groupedData`, `nfGroupedData`, `nfnGroupedData`>",1
+nlme,isBalanced.groupedData,0,0,1,"class<`data.frame`, `groupedData`, `nmGroupedData`>",1
+nlme,isBalanced.groupedData,1,0,0,logical,1
+nlme,isBalanced.groupedData,2,0,0,any,1
+nlme,isInitialized,-1,0,0,logical,1
+nlme,isInitialized,0,0,0,"class<`pdBlocked`, `pdMat`>",1
+nlme,isInitialized,0,0,1,"class<`pdCompSymm`, `pdMat`>",1
+nlme,isInitialized,0,0,2,"class<`pdDiag`, `pdMat`>",1
+nlme,isInitialized,0,0,3,"class<`pdIdent`, `pdMat`>",1
+nlme,isInitialized,0,0,4,"class<`pdLogChol`, `pdMat`, `pdSymm`>",1
+nlme,isInitialized,0,0,5,"class<`pdMat`, `pdSymm`>",1
+nlme,isInitialized,0,0,6,"class<`pdMat`, `pdNatural`>",1
+nlme,isInitialized,0,0,7,class<`reStruct`>,1
+nlme,isInitialized.pdBlocked,-1,0,0,logical,1
+nlme,isInitialized.pdBlocked,0,0,0,"class<`pdBlocked`, `pdMat`>",1
+nlme,isInitialized.pdMat,-1,0,0,logical,1
+nlme,isInitialized.pdMat,0,0,0,"class<`pdCompSymm`, `pdMat`>",1
+nlme,isInitialized.pdMat,0,0,1,"class<`pdDiag`, `pdMat`>",1
+nlme,isInitialized.pdMat,0,0,2,"class<`pdIdent`, `pdMat`>",1
+nlme,isInitialized.pdMat,0,0,3,"class<`pdLogChol`, `pdMat`, `pdSymm`>",1
+nlme,isInitialized.pdMat,0,0,4,"class<`pdMat`, `pdNatural`>",1
+nlme,isInitialized.pdMat,0,0,5,"class<`pdMat`, `pdSymm`>",1
+nlme,isInitialized.reStruct,-1,0,0,logical,1
+nlme,isInitialized.reStruct,0,0,0,class<`reStruct`>,1
+nlme,LDEsysMat,-1,0,0,class<`matrix`>,1
+nlme,LDEsysMat,0,0,0,double[],1
+nlme,LDEsysMat,1,0,0,class<`matrix`>,1
+nlme,lme,-1,0,0,any,1
+nlme,lme,0,0,0,class<`formula`>,1
+nlme,lme,0,0,1,"class<`data.frame`, `groupedData`, `nfGroupedData`, `nfnGroupedData`>",1
+nlme,lme,0,0,2,class<`lmList`>,1
+nlme,lme,1,0,0,any,1
+nlme,lme,2,0,0,any,1
+nlme,lme,3,0,0,null,1
+nlme,lme,4,0,0,null,1
+nlme,lme,4,0,1,"class<`varFunc`, `varIdent`>",1
+nlme,lme,5,0,0,any,1
+nlme,lme,6,0,0,any,1
+nlme,lme,7,0,0,any,1
+nlme,lmeApVar,-1,0,0,character,1
+nlme,lmeApVar,-1,0,1,class<`matrix`>,1
+nlme,lmeApVar,0,0,0,"class<`lmeStruct`, `lmeStructInt`, `modelStruct`>",1
+nlme,lmeApVar,0,0,1,"class<`lmeStruct`, `lmeStructInt`, `modelStruct`, `nlmeStruct`>",1
+nlme,lmeApVar,0,0,2,"class<`lmeStruct`, `modelStruct`>",1
+nlme,lmeApVar,0,0,3,"class<`lmeStruct`, `modelStruct`, `nlmeStruct`>",1
+nlme,lmeApVar,1,0,0,double,1
+nlme,lmeApVar,2,0,0,list<class<`matrix`> | double | list<double[] | list<double[]>>>,1
+nlme,lmeApVar,3,0,0,double,1
+nlme,lmeApVar,4,0,0,double,1
+nlme,lmeApVar,5,0,0,any,1
+nlme,lmeControl,-1,0,0,list<double | character>,1
+nlme,lmeControl,0,0,0,double,1
+nlme,lmeControl,1,0,0,double,1
+nlme,lmeControl,2,0,0,double,1
+nlme,lmeControl,3,0,0,double,1
+nlme,lmeControl,4,0,0,double,1
+nlme,lmeControl,5,0,0,double,1
+nlme,lmeControl,6,0,0,logical,1
+nlme,lmeControl,7,0,0,logical,1
+nlme,lme.formula,-1,0,0,any,1
+nlme,lme.formula,0,0,0,class<`formula`>,1
+nlme,lme.formula,1,0,0,class<`data.frame`>,1
+nlme,lme.formula,1,0,1,"class<`data.frame`, `groupedData`, `nfGroupedData`, `nffGroupedData`>",1
+nlme,lme.formula,1,0,2,"class<`data.frame`, `groupedData`, `nfGroupedData`, `nfnGroupedData`>",1
+nlme,lme.formula,1,0,3,"class<`data.frame`, `groupedData`, `nmGroupedData`>",1
+nlme,lme.formula,2,0,0,class<`formula`>,1
+nlme,lme.formula,2,0,1,"class<`pdBlocked`, `pdMat`>",1
+nlme,lme.formula,2,0,2,"class<`pdCompSymm`, `pdMat`>",1
+nlme,lme.formula,2,0,3,"class<`pdDiag`, `pdMat`>",1
+nlme,lme.formula,2,0,4,"class<`pdMat`, `pdSymm`>",1
+nlme,lme.formula,2,0,5,list<class<`formula`>>,1
+nlme,lme.formula,2,0,6,"list<class<`pdDiag`, `pdMat`>>",1
+nlme,lme.formula,2,0,7,class<`reStruct`>,1
+nlme,lme.formula,3,0,0,null,1
+nlme,lme.formula,3,0,1,"class<`corAR1`, `corStruct`>",1
+nlme,lme.formula,3,0,2,"class<`corARMA`, `corStruct`>",1
+nlme,lme.formula,3,0,3,"class<`corCAR1`, `corStruct`>",1
+nlme,lme.formula,3,0,4,"class<`corExp`, `corSpatial`, `corStruct`>",1
+nlme,lme.formula,3,0,5,"class<`corGaus`, `corSpatial`, `corStruct`>",1
+nlme,lme.formula,3,0,6,"class<`corLin`, `corSpatial`, `corStruct`>",1
+nlme,lme.formula,3,0,7,"class<`corRatio`, `corSpatial`, `corStruct`>",1
+nlme,lme.formula,3,0,8,"class<`corSpatial`, `corSpher`, `corStruct`>",1
+nlme,lme.formula,4,0,0,null,1
+nlme,lme.formula,4,0,1,"class<`varFunc`, `varPower`>",1
+nlme,lme.formula,4,0,2,"class<`varFunc`, `varIdent`>",1
+nlme,lme.formula,5,0,0,any,1
+nlme,lme.formula,6,0,0,character[],1
+nlme,lme.formula,7,0,0,class<`function`>,1
+nlme,lme.groupedData,-1,0,0,class<`lme`>,1
+nlme,lme.groupedData,0,0,0,"class<`data.frame`, `groupedData`, `nfGroupedData`, `nfnGroupedData`>",1
+nlme,lme.groupedData,1,0,0,any,1
+nlme,lme.groupedData,2,0,0,any,1
+nlme,lme.groupedData,3,0,0,null,1
+nlme,lme.groupedData,4,0,0,null,1
+nlme,lme.groupedData,5,0,0,any,1
+nlme,lme.groupedData,6,0,0,any,1
+nlme,lme.groupedData,7,0,0,any,1
+nlme,lme.lmList,-1,0,0,class<`lme`>,1
+nlme,lme.lmList,0,0,0,class<`lmList`>,1
+nlme,lme.lmList,1,0,0,any,1
+nlme,lme.lmList,2,0,0,any,1
+nlme,lme.lmList,3,0,0,null,1
+nlme,lme.lmList,4,0,0,null,1
+nlme,lme.lmList,5,0,0,any,1
+nlme,lme.lmList,6,0,0,any,1
+nlme,lme.lmList,7,0,0,any,1
+nlme,lmeStruct,-1,0,0,"class<`lmeStruct`, `modelStruct`>",1
+nlme,lmeStruct,0,0,0,class<`reStruct`>,1
+nlme,lmeStruct,1,0,0,null,1
+nlme,lmeStruct,1,0,1,"class<`corAR1`, `corStruct`>",1
+nlme,lmeStruct,1,0,2,"class<`corARMA`, `corStruct`>",1
+nlme,lmeStruct,1,0,3,"class<`corCAR1`, `corStruct`>",1
+nlme,lmeStruct,1,0,4,"class<`corExp`, `corSpatial`, `corStruct`>",1
+nlme,lmeStruct,1,0,5,"class<`corGaus`, `corSpatial`, `corStruct`>",1
+nlme,lmeStruct,1,0,6,"class<`corLin`, `corSpatial`, `corStruct`>",1
+nlme,lmeStruct,1,0,7,"class<`corRatio`, `corSpatial`, `corStruct`>",1
+nlme,lmeStruct,1,0,8,"class<`corSpatial`, `corSpher`, `corStruct`>",1
+nlme,lmeStruct,2,0,0,null,1
+nlme,lmeStruct,2,0,1,"class<`varFunc`, `varIdent`>",1
+nlme,lmeStruct,2,0,2,"class<`varFunc`, `varPower`>",1
+nlme,lmList,-1,0,0,class<`lmList`>,1
+nlme,lmList,0,0,0,"class<`data.frame`, `groupedData`, `nfGroupedData`, `nfnGroupedData`>",1
+nlme,lmList,0,0,1,class<`formula`>,1
+nlme,lmList,1,0,0,any,1
+nlme,lmList,2,0,0,any,1
+nlme,lmList,3,0,0,any,1
+nlme,lmList,4,0,0,any,1
+nlme,lmList,5,0,0,logical,1
+nlme,lmList,6,0,0,logical,1
+nlme,lmList.formula,-1,0,0,class<`lmList`>,1
+nlme,lmList.formula,0,0,0,class<`formula`>,1
+nlme,lmList.formula,1,0,0,"class<`data.frame`, `groupedData`, `nfGroupedData`, `nfnGroupedData`>",1
+nlme,lmList.formula,2,0,0,any,1
+nlme,lmList.formula,3,0,0,any,1
+nlme,lmList.formula,4,0,0,class<`function`>,1
+nlme,lmList.formula,5,0,0,logical,1
+nlme,lmList.formula,6,0,0,logical,1
+nlme,lmList.groupedData,-1,0,0,class<`lmList`>,1
+nlme,lmList.groupedData,0,0,0,"class<`data.frame`, `groupedData`, `nfGroupedData`, `nfnGroupedData`>",1
+nlme,lmList.groupedData,1,0,0,any,1
+nlme,lmList.groupedData,2,0,0,any,1
+nlme,lmList.groupedData,3,0,0,any,1
+nlme,lmList.groupedData,4,0,0,any,1
+nlme,lmList.groupedData,5,0,0,logical,1
+nlme,lmList.groupedData,6,0,0,logical,1
+nlme,logDet,-1,0,0,double[],1
+nlme,logDet,0,0,0,"class<`pdDiag`, `pdMat`>",1
+nlme,logDet,0,0,1,"class<`pdMat`, `pdSymm`>",1
+nlme,logDet,0,0,2,"class<`corAR1`, `corStruct`>",1
+nlme,logDet,0,0,3,class<`reStruct`>,1
+nlme,logDet,1,0,0,...,1
+nlme,logDet.corStruct,-1,0,0,double,1
+nlme,logDet.corStruct,0,0,0,"class<`corAR1`, `corStruct`>",1
+nlme,logDet.corStruct,1,0,0,any,1
+nlme,logDet.corStruct,2,0,0,...,1
+nlme,logDet.pdDiag,-1,0,0,double,1
+nlme,logDet.pdDiag,0,0,0,"class<`pdDiag`, `pdMat`>",1
+nlme,logDet.pdDiag,1,0,0,...,1
+nlme,logDet.pdSymm,-1,0,0,double,1
+nlme,logDet.pdSymm,0,0,0,"class<`pdMat`, `pdSymm`>",1
+nlme,logDet.pdSymm,1,0,0,...,1
+nlme,logDet.reStruct,-1,0,0,double[],1
+nlme,logDet.reStruct,0,0,0,class<`reStruct`>,1
+nlme,logDet.reStruct,1,0,0,...,1
+nlme,logLik.corStruct,-1,0,0,double,1
+nlme,logLik.corStruct,0,0,0,"class<`corAR1`, `corStruct`>",1
+nlme,logLik.corStruct,1,0,0,any,1
+nlme,logLik.corStruct,2,0,0,...,1
+nlme,logLik.gls,-1,0,0,class<`logLik`>,1
+nlme,logLik.gls,0,0,0,class<`gls`>,1
+nlme,logLik.gls,1,0,0,any,1
+nlme,logLik.gls,2,0,0,...,1
+nlme,logLik.glsStruct,-1,0,0,double,1
+nlme,logLik.glsStruct,0,0,0,"class<`glsStruct`, `modelStruct`>",1
+nlme,logLik.glsStruct,1,0,0,double[],1
+nlme,logLik.glsStruct,2,0,0,list<class<`matrix`> | double | list<integer>>,1
+nlme,logLik.glsStruct,3,0,0,...,1
+nlme,logLik.gnls,-1,0,0,class<`logLik`>,1
+nlme,logLik.gnls,0,0,0,"class<`gls`, `gnls`>",1
+nlme,logLik.gnls,1,0,0,logical,1
+nlme,logLik.gnls,2,0,0,...,1
+nlme,logLik.gnlsStruct,-1,0,0,class<`logLik`>,1
+nlme,logLik.gnlsStruct,0,0,0,"class<`glsStruct`, `gnlsStruct`, `modelStruct`>",1
+nlme,logLik.gnlsStruct,1,0,0,double[],1
+nlme,logLik.gnlsStruct,2,0,0,list<class<`matrix`> | double | list<integer>>,1
+nlme,logLik.gnlsStruct,3,0,0,...,1
+nlme,logLik.lme,-1,0,0,class<`logLik`>,1
+nlme,logLik.lme,0,0,0,class<`lme`>,1
+nlme,logLik.lme,0,0,1,"class<`lme`, `nlme`>",1
+nlme,logLik.lme,1,0,0,any,1
+nlme,logLik.lme,2,0,0,...,1
+nlme,logLik.lmeStruct,-1,0,0,class<`logLik`>,1
+nlme,logLik.lmeStruct,-1,0,1,double,1
+nlme,logLik.lmeStruct,0,0,0,"class<`lmeStruct`, `modelStruct`>",1
+nlme,logLik.lmeStruct,0,0,1,"class<`lmeStruct`, `modelStruct`, `nlmeStruct`>",1
+nlme,logLik.lmeStruct,1,0,0,double[],1
+nlme,logLik.lmeStruct,2,0,0,list<class<`matrix`> | double | list<double[] | list<double[]>>>,1
+nlme,logLik.lmeStruct,3,0,0,...,1
+nlme,logLik.lmeStructInt,-1,0,0,double,1
+nlme,logLik.lmeStructInt,0,0,0,"class<`lmeStruct`, `lmeStructInt`, `modelStruct`>",1
+nlme,logLik.lmeStructInt,0,0,1,"class<`lmeStruct`, `lmeStructInt`, `modelStruct`, `nlmeStruct`>",1
+nlme,logLik.lmeStructInt,1,0,0,double[],1
+nlme,logLik.lmeStructInt,2,0,0,list<class<`matrix`> | double | list<double[] | list<double[]>>>,1
+nlme,logLik.lmeStructInt,3,0,0,...,1
+nlme,logLik.lmList,-1,0,0,class<`logLik`>,1
+nlme,logLik.lmList,0,0,0,class<`lmList`>,1
+nlme,logLik.lmList,1,0,0,logical,1
+nlme,logLik.lmList,2,0,0,logical,1
+nlme,logLik.lmList,3,0,0,...,1
+nlme,logLik.reStruct,-1,0,0,double,1
+nlme,logLik.reStruct,0,0,0,class<`reStruct`>,1
+nlme,logLik.reStruct,1,0,0,list<any>,1
+nlme,logLik.reStruct,2,0,0,...,1
+nlme,logLik.varFunc,-1,0,0,class<`logLik`>,1
+nlme,logLik.varFunc,-1,0,1,null,1
+nlme,logLik.varFunc,0,0,0,"class<`varFunc`, `varIdent`>",1
+nlme,logLik.varFunc,0,0,1,"class<`varFunc`, `varPower`>",1
+nlme,logLik.varFunc,0,0,2,"class<`varExp`, `varFunc`>",1
+nlme,logLik.varFunc,1,0,0,any,1
+nlme,logLik.varFunc,2,0,0,...,1
+nlme,matrix<-,-1,0,0,"class<`pdBlocked`, `pdMat`>",1
+nlme,matrix<-,-1,0,1,"class<`pdCompSymm`, `pdMat`>",1
+nlme,matrix<-,-1,0,2,"class<`pdDiag`, `pdMat`>",1
+nlme,matrix<-,-1,0,3,"class<`pdIdent`, `pdMat`>",1
+nlme,matrix<-,-1,0,4,"class<`pdLogChol`, `pdMat`, `pdSymm`>",1
+nlme,matrix<-,-1,0,5,"class<`pdMat`, `pdSymm`>",1
+nlme,matrix<-,-1,0,6,class<`reStruct`>,1
+nlme,matrix<-,0,0,0,"class<`pdBlocked`, `pdMat`>",1
+nlme,matrix<-,0,0,1,"class<`pdCompSymm`, `pdMat`>",1
+nlme,matrix<-,0,0,2,"class<`pdDiag`, `pdMat`>",1
+nlme,matrix<-,0,0,3,"class<`pdIdent`, `pdMat`>",1
+nlme,matrix<-,0,0,4,"class<`pdLogChol`, `pdMat`, `pdSymm`>",1
+nlme,matrix<-,0,0,5,"class<`pdMat`, `pdSymm`>",1
+nlme,matrix<-,0,0,6,class<`reStruct`>,1
+nlme,matrix<-,1,0,0,class<`matrix`>,1
+nlme,matrix<-,1,0,1,double,1
+nlme,matrix<-,1,0,2,list<class<`matrix`> | double>,1
+nlme,matrix<-.pdBlocked,-1,0,0,"class<`pdBlocked`, `pdMat`>",1
+nlme,matrix<-.pdBlocked,0,0,0,"class<`pdBlocked`, `pdMat`>",1
+nlme,matrix<-.pdBlocked,1,0,0,class<`matrix`>,1
+nlme,matrix<-.pdMat,-1,0,0,"class<`pdCompSymm`, `pdMat`>",1
+nlme,matrix<-.pdMat,-1,0,1,"class<`pdDiag`, `pdMat`>",1
+nlme,matrix<-.pdMat,-1,0,2,"class<`pdIdent`, `pdMat`>",1
+nlme,matrix<-.pdMat,-1,0,3,"class<`pdLogChol`, `pdMat`, `pdSymm`>",1
+nlme,matrix<-.pdMat,-1,0,4,"class<`pdMat`, `pdSymm`>",1
+nlme,matrix<-.pdMat,0,0,0,"class<`pdCompSymm`, `pdMat`>",1
+nlme,matrix<-.pdMat,0,0,1,"class<`pdDiag`, `pdMat`>",1
+nlme,matrix<-.pdMat,0,0,2,"class<`pdIdent`, `pdMat`>",1
+nlme,matrix<-.pdMat,0,0,3,"class<`pdLogChol`, `pdMat`, `pdSymm`>",1
+nlme,matrix<-.pdMat,0,0,4,"class<`pdMat`, `pdSymm`>",1
+nlme,matrix<-.pdMat,1,0,0,class<`matrix`>,1
+nlme,matrix<-.pdMat,1,0,1,double,1
+nlme,matrix<-.reStruct,-1,0,0,class<`reStruct`>,1
+nlme,matrix<-.reStruct,0,0,0,class<`reStruct`>,1
+nlme,matrix<-.reStruct,1,0,0,class<`matrix`>,1
+nlme,matrix<-.reStruct,1,0,1,list<class<`matrix`> | double>,1
+nlme,MEdecomp,-1,0,0,list<class<`matrix`> | double | list<double[] | list<double[]>>>,1
+nlme,MEdecomp,0,0,0,list<class<`matrix`> | double | list<double[] | list<double[]>>>,1
+nlme,MEdims,-1,0,0,list<double[] | list<double[]>>,1
+nlme,MEdims,-1,0,1,list<double[] | list<double>>,1
+nlme,MEdims,0,0,0,class<`data.frame`>,1
+nlme,MEdims,1,0,0,double[],1
+nlme,MEEM,-1,0,0,class<`reStruct`>,1
+nlme,MEEM,0,0,0,class<`reStruct`>,1
+nlme,MEEM,1,0,0,list<class<`matrix`> | double | list<double[] | list<double[]>>>,1
+nlme,MEEM,2,0,0,double,1
+nlme,MEestimate,-1,0,0,list<any>,1
+nlme,MEestimate,0,0,0,"class<`lmeStruct`, `modelStruct`>",1
+nlme,MEestimate,0,0,1,"class<`lmeStruct`, `lmeStructInt`, `modelStruct`>",1
+nlme,MEestimate,0,0,2,"class<`lmeStruct`, `lmeStructInt`, `modelStruct`, `nlmeStruct`>",1
+nlme,MEestimate,0,0,3,"class<`lmeStruct`, `modelStruct`, `nlmeStruct`>",1
+nlme,MEestimate,1,0,0,class<`data.frame`>,1
+nlme,MEestimate,2,0,0,list<class<`matrix`> | double | list<double[] | list<double[]>>>,1
+nlme,model.matrix.reStruct,-1,0,0,class<`matrix`>,1
+nlme,model.matrix.reStruct,0,0,0,class<`reStruct`>,1
+nlme,model.matrix.reStruct,1,0,0,class<`data.frame`>,1
+nlme,model.matrix.reStruct,1,0,1,"class<`data.frame`, `groupedData`, `nmGroupedData`>",1
+nlme,model.matrix.reStruct,1,0,2,"class<`data.frame`, `groupedData`, `nfGroupedData`, `nfnGroupedData`>",1
+nlme,model.matrix.reStruct,2,0,0,null,1
+nlme,model.matrix.reStruct,3,0,0,...,1
+nlme,Names,-1,0,0,character[],1
+nlme,Names,-1,0,1,list<character[]>,1
+nlme,Names,-1,0,2,null,1
+nlme,Names,0,0,0,"class<`pdIdent`, `pdMat`>",1
+nlme,Names,0,0,1,"class<`pdLogChol`, `pdMat`, `pdSymm`>",1
+nlme,Names,0,0,2,"class<`pdMat`, `pdSymm`>",1
+nlme,Names,0,0,3,class<`formula`>,1
+nlme,Names,0,0,4,class<`listForm`>,1
+nlme,Names,0,0,5,"class<`pdBlocked`, `pdMat`>",1
+nlme,Names,0,0,6,"class<`pdCompSymm`, `pdMat`>",1
+nlme,Names,0,0,7,"class<`pdDiag`, `pdMat`>",1
+nlme,Names,0,0,8,"class<`pdMat`, `pdNatural`>",1
+nlme,Names,0,0,9,class<`reStruct`>,1
+nlme,Names,1,0,0,...,1
+nlme,Names<-,-1,0,0,"class<`pdBlocked`, `pdMat`>",1
+nlme,Names<-,-1,0,1,"class<`pdCompSymm`, `pdMat`>",1
+nlme,Names<-,-1,0,2,"class<`pdDiag`, `pdMat`>",1
+nlme,Names<-,-1,0,3,"class<`pdLogChol`, `pdMat`, `pdSymm`>",1
+nlme,Names<-,-1,0,4,"class<`pdMat`, `pdSymm`>",1
+nlme,Names<-,-1,0,5,class<`reStruct`>,1
+nlme,Names<-,0,0,0,"class<`pdBlocked`, `pdMat`>",1
+nlme,Names<-,0,0,1,"class<`pdCompSymm`, `pdMat`>",1
+nlme,Names<-,0,0,2,"class<`pdDiag`, `pdMat`>",1
+nlme,Names<-,0,0,3,"class<`pdLogChol`, `pdMat`, `pdSymm`>",1
+nlme,Names<-,0,0,4,"class<`pdMat`, `pdSymm`>",1
+nlme,Names<-,0,0,5,class<`reStruct`>,1
+nlme,Names<-,1,0,0,...,1
+nlme,Names<-,2,0,0,character[],1
+nlme,Names<-,2,0,1,list<character[]>,1
+nlme,Names.formula,-1,0,0,character[],1
+nlme,Names.formula,-1,0,1,null,1
+nlme,Names.formula,0,0,0,class<`formula`>,1
+nlme,Names.formula,1,0,0,class<`data.frame`>,1
+nlme,Names.formula,1,0,1,"class<`data.frame`, `groupedData`, `nfGroupedData`, `nfnGroupedData`>",1
+nlme,Names.formula,1,0,2,"class<`data.frame`, `groupedData`, `nmGroupedData`>",1
+nlme,Names.formula,1,0,3,list<any>,1
+nlme,Names.formula,1,0,4,environment,1
+nlme,Names.formula,1,0,5,integer,1
+nlme,Names.formula,1,0,6,null,1
+nlme,Names.formula,2,0,0,any,1
+nlme,Names.formula,3,0,0,...,1
+nlme,Names.listForm,-1,0,0,character[],1
+nlme,Names.listForm,-1,0,1,null,1
+nlme,Names.listForm,0,0,0,class<`listForm`>,1
+nlme,Names.listForm,1,0,0,"class<`data.frame`, `groupedData`, `nfGroupedData`, `nfnGroupedData`>",1
+nlme,Names.listForm,1,0,1,environment,1
+nlme,Names.listForm,1,0,2,integer,1
+nlme,Names.listForm,1,0,3,null,1
+nlme,Names.listForm,2,0,0,any,1
+nlme,Names.listForm,3,0,0,...,1
+nlme,Names<-.pdBlocked,-1,0,0,"class<`pdBlocked`, `pdMat`>",1
+nlme,Names<-.pdBlocked,0,0,0,"class<`pdBlocked`, `pdMat`>",1
+nlme,Names<-.pdBlocked,1,0,0,...,1
+nlme,Names<-.pdBlocked,2,0,0,character[],1
+nlme,Names.pdBlocked,-1,0,0,character[],1
+nlme,Names.pdBlocked,-1,0,1,list<character[]>,1
+nlme,Names.pdBlocked,-1,0,2,null,1
+nlme,Names.pdBlocked,0,0,0,"class<`pdBlocked`, `pdMat`>",1
+nlme,Names.pdBlocked,1,0,0,logical,1
+nlme,Names.pdBlocked,2,0,0,...,1
+nlme,Names<-.pdMat,-1,0,0,"class<`pdCompSymm`, `pdMat`>",1
+nlme,Names<-.pdMat,-1,0,1,"class<`pdDiag`, `pdMat`>",1
+nlme,Names<-.pdMat,-1,0,2,"class<`pdLogChol`, `pdMat`, `pdSymm`>",1
+nlme,Names<-.pdMat,-1,0,3,"class<`pdMat`, `pdSymm`>",1
+nlme,Names<-.pdMat,0,0,0,"class<`pdCompSymm`, `pdMat`>",1
+nlme,Names<-.pdMat,0,0,1,"class<`pdDiag`, `pdMat`>",1
+nlme,Names<-.pdMat,0,0,2,"class<`pdLogChol`, `pdMat`, `pdSymm`>",1
+nlme,Names<-.pdMat,0,0,3,"class<`pdMat`, `pdSymm`>",1
+nlme,Names<-.pdMat,1,0,0,...,1
+nlme,Names<-.pdMat,2,0,0,character[],1
+nlme,Names.pdMat,-1,0,0,character[],1
+nlme,Names.pdMat,0,0,0,"class<`pdCompSymm`, `pdMat`>",1
+nlme,Names.pdMat,0,0,1,"class<`pdDiag`, `pdMat`>",1
+nlme,Names.pdMat,0,0,2,"class<`pdIdent`, `pdMat`>",1
+nlme,Names.pdMat,0,0,3,"class<`pdLogChol`, `pdMat`, `pdSymm`>",1
+nlme,Names.pdMat,0,0,4,"class<`pdMat`, `pdNatural`>",1
+nlme,Names.pdMat,0,0,5,"class<`pdMat`, `pdSymm`>",1
+nlme,Names.pdMat,1,0,0,...,1
+nlme,Names<-.reStruct,-1,0,0,class<`reStruct`>,1
+nlme,Names<-.reStruct,0,0,0,class<`reStruct`>,1
+nlme,Names<-.reStruct,1,0,0,...,1
+nlme,Names<-.reStruct,2,0,0,list<character[]>,1
+nlme,Names.reStruct,-1,0,0,list<character[]>,1
+nlme,Names.reStruct,0,0,0,class<`reStruct`>,1
+nlme,Names.reStruct,1,0,0,...,1
+nlme,needUpdate,-1,0,0,logical,1
+nlme,needUpdate,0,0,0,"class<`corAR1`, `corStruct`>",1
+nlme,needUpdate,0,0,1,"class<`corARMA`, `corStruct`>",1
+nlme,needUpdate,0,0,2,"class<`corCAR1`, `corStruct`>",1
+nlme,needUpdate,0,0,3,"class<`corCompSymm`, `corStruct`>",1
+nlme,needUpdate,0,0,4,"class<`corExp`, `corSpatial`, `corStruct`>",1
+nlme,needUpdate,0,0,5,"class<`corGaus`, `corSpatial`, `corStruct`>",1
+nlme,needUpdate,0,0,6,"class<`corLin`, `corSpatial`, `corStruct`>",1
+nlme,needUpdate,0,0,7,"class<`corRatio`, `corSpatial`, `corStruct`>",1
+nlme,needUpdate,0,0,8,"class<`corSpatial`, `corSpher`, `corStruct`>",1
+nlme,needUpdate,0,0,9,"class<`corStruct`, `corSymm`>",1
+nlme,needUpdate,0,0,10,class<`reStruct`>,1
+nlme,needUpdate,0,0,11,"class<`varFunc`, `varIdent`>",1
+nlme,needUpdate,0,0,12,"class<`varFunc`, `varPower`>",1
+nlme,needUpdate,0,0,13,"class<`glsStruct`, `gnlsStruct`, `modelStruct`>",1
+nlme,needUpdate,0,0,14,"class<`glsStruct`, `modelStruct`>",1
+nlme,needUpdate,0,0,15,"class<`lmeStruct`, `lmeStructInt`, `modelStruct`>",1
+nlme,needUpdate,0,0,16,"class<`lmeStruct`, `lmeStructInt`, `modelStruct`, `nlmeStruct`>",1
+nlme,needUpdate,0,0,17,"class<`lmeStruct`, `modelStruct`>",1
+nlme,needUpdate,0,0,18,"class<`lmeStruct`, `modelStruct`, `nlmeStruct`>",1
+nlme,needUpdate,0,0,19,"class<`varExp`, `varFunc`>",1
+nlme,needUpdate.corStruct,-1,0,0,logical,1
+nlme,needUpdate.corStruct,0,0,0,"class<`corAR1`, `corStruct`>",1
+nlme,needUpdate.corStruct,0,0,1,"class<`corARMA`, `corStruct`>",1
+nlme,needUpdate.corStruct,0,0,2,"class<`corCAR1`, `corStruct`>",1
+nlme,needUpdate.corStruct,0,0,3,"class<`corCompSymm`, `corStruct`>",1
+nlme,needUpdate.corStruct,0,0,4,"class<`corExp`, `corSpatial`, `corStruct`>",1
+nlme,needUpdate.corStruct,0,0,5,"class<`corGaus`, `corSpatial`, `corStruct`>",1
+nlme,needUpdate.corStruct,0,0,6,"class<`corLin`, `corSpatial`, `corStruct`>",1
+nlme,needUpdate.corStruct,0,0,7,"class<`corRatio`, `corSpatial`, `corStruct`>",1
+nlme,needUpdate.corStruct,0,0,8,"class<`corSpatial`, `corSpher`, `corStruct`>",1
+nlme,needUpdate.corStruct,0,0,9,"class<`corStruct`, `corSymm`>",1
+nlme,needUpdate.corStruct,0,0,10,class<`reStruct`>,1
+nlme,needUpdate.corStruct,0,0,11,"class<`varFunc`, `varIdent`>",1
+nlme,needUpdate.default,-1,0,0,logical,1
+nlme,needUpdate.default,0,0,0,"class<`varExp`, `varFunc`>",1
+nlme,needUpdate.default,0,0,1,"class<`varFunc`, `varPower`>",1
+nlme,needUpdate.modelStruct,-1,0,0,logical,1
+nlme,needUpdate.modelStruct,0,0,0,"class<`glsStruct`, `gnlsStruct`, `modelStruct`>",1
+nlme,needUpdate.modelStruct,0,0,1,"class<`glsStruct`, `modelStruct`>",1
+nlme,needUpdate.modelStruct,0,0,2,"class<`lmeStruct`, `lmeStructInt`, `modelStruct`>",1
+nlme,needUpdate.modelStruct,0,0,3,"class<`lmeStruct`, `lmeStructInt`, `modelStruct`, `nlmeStruct`>",1
+nlme,needUpdate.modelStruct,0,0,4,"class<`lmeStruct`, `modelStruct`>",1
+nlme,needUpdate.modelStruct,0,0,5,"class<`lmeStruct`, `modelStruct`, `nlmeStruct`>",1
+nlme,needUpdate.reStruct,-1,0,0,logical,1
+nlme,needUpdate.reStruct,0,0,0,"class<`corAR1`, `corStruct`>",1
+nlme,needUpdate.reStruct,0,0,1,"class<`corARMA`, `corStruct`>",1
+nlme,needUpdate.reStruct,0,0,2,"class<`corCAR1`, `corStruct`>",1
+nlme,needUpdate.reStruct,0,0,3,"class<`corCompSymm`, `corStruct`>",1
+nlme,needUpdate.reStruct,0,0,4,"class<`corExp`, `corSpatial`, `corStruct`>",1
+nlme,needUpdate.reStruct,0,0,5,"class<`corGaus`, `corSpatial`, `corStruct`>",1
+nlme,needUpdate.reStruct,0,0,6,"class<`corLin`, `corSpatial`, `corStruct`>",1
+nlme,needUpdate.reStruct,0,0,7,"class<`corRatio`, `corSpatial`, `corStruct`>",1
+nlme,needUpdate.reStruct,0,0,8,"class<`corSpatial`, `corSpher`, `corStruct`>",1
+nlme,needUpdate.reStruct,0,0,9,"class<`corStruct`, `corSymm`>",1
+nlme,needUpdate.reStruct,0,0,10,class<`reStruct`>,1
+nlme,needUpdate.reStruct,0,0,11,"class<`varFunc`, `varIdent`>",1
+nlme,needUpdate.varIdent,-1,0,0,logical,1
+nlme,needUpdate.varIdent,0,0,0,"class<`corAR1`, `corStruct`>",1
+nlme,needUpdate.varIdent,0,0,1,"class<`corARMA`, `corStruct`>",1
+nlme,needUpdate.varIdent,0,0,2,"class<`corCAR1`, `corStruct`>",1
+nlme,needUpdate.varIdent,0,0,3,"class<`corCompSymm`, `corStruct`>",1
+nlme,needUpdate.varIdent,0,0,4,"class<`corExp`, `corSpatial`, `corStruct`>",1
+nlme,needUpdate.varIdent,0,0,5,"class<`corGaus`, `corSpatial`, `corStruct`>",1
+nlme,needUpdate.varIdent,0,0,6,"class<`corLin`, `corSpatial`, `corStruct`>",1
+nlme,needUpdate.varIdent,0,0,7,"class<`corRatio`, `corSpatial`, `corStruct`>",1
+nlme,needUpdate.varIdent,0,0,8,"class<`corSpatial`, `corSpher`, `corStruct`>",1
+nlme,needUpdate.varIdent,0,0,9,"class<`corStruct`, `corSymm`>",1
+nlme,needUpdate.varIdent,0,0,10,class<`reStruct`>,1
+nlme,needUpdate.varIdent,0,0,11,"class<`varFunc`, `varIdent`>",1
+nlme,nfGroupedData,-1,0,0,"class<`data.frame`, `groupedData`, `nfGroupedData`, `nfnGroupedData`>",1
+nlme,nfGroupedData,0,0,0,class<`formula`>,1
+nlme,nfGroupedData,1,0,0,class<`data.frame`>,1
+nlme,nfGroupedData,2,0,0,logical,1
+nlme,nfGroupedData,3,0,0,class<`function`>,1
+nlme,nfGroupedData,4,0,0,null,1
+nlme,nfGroupedData,5,0,0,null,1
+nlme,nfGroupedData,5,0,1,class<`formula`>,1
+nlme,nfGroupedData,6,0,0,list<character>,1
+nlme,nfGroupedData,7,0,0,list<character>,1
+nlme,nlme,-1,0,0,"class<`lme`, `nlme`>",1
+nlme,nlme,0,0,0,class<`formula`>,1
+nlme,nlme,0,0,1,"class<`lmList`, `nlsList`>",1
+nlme,nlme,1,0,0,any,1
+nlme,nlme,2,0,0,any,1
+nlme,nlme,3,0,0,any,1
+nlme,nlme,4,0,0,any,1
+nlme,nlme,5,0,0,any,1
+nlme,nlme,6,0,0,null,1
+nlme,nlme,7,0,0,null,1
+nlme,nlmeControl,-1,0,0,list<double | character>,1
+nlme,nlmeControl,0,0,0,double,1
+nlme,nlmeControl,1,0,0,double,1
+nlme,nlmeControl,2,0,0,double,1
+nlme,nlmeControl,3,0,0,double,1
+nlme,nlmeControl,4,0,0,double,1
+nlme,nlmeControl,5,0,0,double,1
+nlme,nlmeControl,6,0,0,double,1
+nlme,nlmeControl,7,0,0,double,1
+nlme,nlme.formula,-1,0,0,"class<`lme`, `nlme`>",1
+nlme,nlme.formula,0,0,0,class<`formula`>,1
+nlme,nlme.formula,1,0,0,class<`data.frame`>,1
+nlme,nlme.formula,1,0,1,"class<`data.frame`, `groupedData`, `nfGroupedData`, `nfnGroupedData`>",1
+nlme,nlme.formula,2,0,0,class<`formula`>,1
+nlme,nlme.formula,2,0,1,list<class<`formula`>>,1
+nlme,nlme.formula,3,0,0,any,1
+nlme,nlme.formula,4,0,0,any,1
+nlme,nlme.formula,5,0,0,any,1
+nlme,nlme.formula,6,0,0,null,1
+nlme,nlme.formula,6,0,1,"class<`corAR1`, `corStruct`>",1
+nlme,nlme.formula,6,0,2,"class<`corARMA`, `corStruct`>",1
+nlme,nlme.formula,7,0,0,null,1
+nlme,nlme.nlsList,-1,0,0,"class<`lme`, `nlme`>",1
+nlme,nlme.nlsList,0,0,0,"class<`lmList`, `nlsList`>",1
+nlme,nlme.nlsList,1,0,0,any,1
+nlme,nlme.nlsList,2,0,0,any,1
+nlme,nlme.nlsList,3,0,0,any,1
+nlme,nlme.nlsList,4,0,0,any,1
+nlme,nlme.nlsList,5,0,0,any,1
+nlme,nlme.nlsList,6,0,0,null,1
+nlme,nlme.nlsList,7,0,0,null,1
+nlme,nlmeStruct,-1,0,0,"class<`lmeStruct`, `modelStruct`, `nlmeStruct`>",1
+nlme,nlmeStruct,0,0,0,class<`reStruct`>,1
+nlme,nlmeStruct,1,0,0,null,1
+nlme,nlmeStruct,1,0,1,"class<`corAR1`, `corStruct`>",1
+nlme,nlmeStruct,1,0,2,"class<`corARMA`, `corStruct`>",1
+nlme,nlmeStruct,2,0,0,null,1
+nlme,nlmeStruct,2,0,1,"class<`varFunc`, `varPower`>",1
+nlme,nlsList,-1,0,0,"class<`lmList`, `nlsList`>",1
+nlme,nlsList,0,0,0,class<`formula`>,1
+nlme,nlsList,0,0,1,class<`selfStart`>,1
+nlme,nlsList,1,0,0,"class<`data.frame`, `groupedData`, `nfGroupedData`, `nfnGroupedData`>",1
+nlme,nlsList,2,0,0,any,1
+nlme,nlsList,3,0,0,any,1
+nlme,nlsList,4,0,0,any,1
+nlme,nlsList,5,0,0,any,1
+nlme,nlsList,6,0,0,any,1
+nlme,nlsList,7,0,0,logical,1
+nlme,nlsList.formula,-1,0,0,"class<`lmList`, `nlsList`>",1
+nlme,nlsList.formula,0,0,0,class<`formula`>,1
+nlme,nlsList.formula,1,0,0,"class<`data.frame`, `groupedData`, `nfGroupedData`, `nfnGroupedData`>",1
+nlme,nlsList.formula,2,0,0,null,1
+nlme,nlsList.formula,2,0,1,double[],1
+nlme,nlsList.formula,3,0,0,any,1
+nlme,nlsList.formula,4,0,0,any,1
+nlme,nlsList.formula,5,0,0,any,1
+nlme,nlsList.formula,6,0,0,class<`function`>,1
+nlme,nlsList.formula,7,0,0,logical,1
+nlme,nlsList.selfStart,-1,0,0,"class<`lmList`, `nlsList`>",1
+nlme,nlsList.selfStart,0,0,0,class<`selfStart`>,1
+nlme,nlsList.selfStart,1,0,0,"class<`data.frame`, `groupedData`, `nfGroupedData`, `nfnGroupedData`>",1
+nlme,nlsList.selfStart,2,0,0,any,1
+nlme,nlsList.selfStart,3,0,0,any,1
+nlme,nlsList.selfStart,4,0,0,any,1
+nlme,nlsList.selfStart,5,0,0,any,1
+nlme,nlsList.selfStart,6,0,0,any,1
+nlme,nlsList.selfStart,7,0,0,logical,1
+nlme,nobs.gls,-1,0,0,integer,1
+nlme,nobs.gls,0,0,0,class<`gls`>,1
+nlme,nobs.gls,0,0,1,class<`lme`>,1
+nlme,nobs.gls,1,0,0,...,1
+nlme,nobs.lme,-1,0,0,integer,1
+nlme,nobs.lme,0,0,0,class<`gls`>,1
+nlme,nobs.lme,0,0,1,class<`lme`>,1
+nlme,nobs.lme,1,0,0,...,1
+nlme,nonlinModel,-1,0,0,class<`function`>,1
+nlme,nonlinModel,0,0,0,class<`formula`>,1
+nlme,nonlinModel,1,0,0,environment,1
+nlme,nonlinModel,2,0,0,character[],1
+nlme,pairs.compareFits,-1,0,0,class<`trellis`>,1
+nlme,pairs.compareFits,0,0,0,class<`compareFits`>,1
+nlme,pairs.compareFits,1,0,0,any,1
+nlme,pairs.compareFits,2,0,0,logical,1
+nlme,pairs.compareFits,3,0,0,...,1
+nlme,pairs.lme,-1,0,0,class<`trellis`>,1
+nlme,pairs.lme,0,0,0,class<`lme`>,1
+nlme,pairs.lme,1,0,0,class<`formula`>,1
+nlme,pairs.lme,2,0,0,any,1
+nlme,pairs.lme,3,0,0,double,1
+nlme,pairs.lme,3,0,1,null,1
+nlme,pairs.lme,4,0,0,null,1
+nlme,pairs.lme,5,0,0,logical,1
+nlme,pairs.lme,6,0,0,...,1
+nlme,pairs.lmList,-1,0,0,class<`trellis`>,1
+nlme,pairs.lmList,0,0,0,class<`lmList`>,1
+nlme,pairs.lmList,1,0,0,class<`formula`>,1
+nlme,pairs.lmList,2,0,0,any,1
+nlme,pairs.lmList,3,0,0,double,1
+nlme,pairs.lmList,3,0,1,null,1
+nlme,pairs.lmList,4,0,0,null,1
+nlme,pairs.lmList,5,0,0,logical,1
+nlme,pairs.lmList,6,0,0,...,1
+nlme,pdBlocked,-1,0,0,"class<`pdBlocked`, `pdMat`>",1
+nlme,pdBlocked,0,0,0,list<class<`formula`>>,1
+nlme,pdBlocked,0,0,1,"list<class<`pdIdent`, `pdMat`>>",1
+nlme,pdBlocked,0,0,2,list<character[]>,1
+nlme,pdBlocked,0,0,3,list<class<`matrix`>>,1
+nlme,pdBlocked,1,0,0,null,1
+nlme,pdBlocked,2,0,0,null,1
+nlme,pdBlocked,2,0,1,list<character[]>,1
+nlme,pdBlocked,3,0,0,any,1
+nlme,pdBlocked,4,0,0,character,1
+nlme,pdCompSymm,-1,0,0,"class<`pdCompSymm`, `pdMat`>",1
+nlme,pdCompSymm,0,0,0,class<`formula`>,1
+nlme,pdCompSymm,0,0,1,class<`matrix`>,1
+nlme,pdCompSymm,1,0,0,null,1
+nlme,pdCompSymm,1,0,1,class<`formula`>,1
+nlme,pdCompSymm,2,0,0,null,1
+nlme,pdCompSymm,2,0,1,character[],1
+nlme,pdCompSymm,3,0,0,any,1
+nlme,pdConstruct,-1,0,0,"class<`pdBlocked`, `pdMat`>",1
+nlme,pdConstruct,-1,0,1,"class<`pdCompSymm`, `pdMat`>",1
+nlme,pdConstruct,-1,0,2,"class<`pdDiag`, `pdMat`>",1
+nlme,pdConstruct,-1,0,3,"class<`pdIdent`, `pdMat`>",1
+nlme,pdConstruct,-1,0,4,"class<`pdLogChol`, `pdMat`, `pdSymm`>",1
+nlme,pdConstruct,-1,0,5,"class<`pdMat`, `pdNatural`>",1
+nlme,pdConstruct,-1,0,6,"class<`pdMat`, `pdSymm`>",1
+nlme,pdConstruct,0,0,0,"class<`pdBlocked`, `pdMat`>",1
+nlme,pdConstruct,0,0,1,"class<`pdCompSymm`, `pdMat`>",1
+nlme,pdConstruct,0,0,2,"class<`pdDiag`, `pdMat`>",1
+nlme,pdConstruct,0,0,3,"class<`pdIdent`, `pdMat`>",1
+nlme,pdConstruct,0,0,4,"class<`pdLogChol`, `pdMat`>",1
+nlme,pdConstruct,0,0,5,"class<`pdLogChol`, `pdMat`, `pdSymm`>",1
+nlme,pdConstruct,0,0,6,"class<`pdMat`, `pdNatural`>",1
+nlme,pdConstruct,0,0,7,"class<`pdMat`, `pdSymm`>",1
+nlme,pdConstruct,1,0,0,any,1
+nlme,pdConstruct,2,0,0,any,1
+nlme,pdConstruct,3,0,0,any,1
+nlme,pdConstruct,4,0,0,any,1
+nlme,pdConstruct,5,0,0,...,1
+nlme,pdConstruct.pdBlocked,-1,0,0,"class<`pdBlocked`, `pdMat`>",1
+nlme,pdConstruct.pdBlocked,0,0,0,"class<`pdBlocked`, `pdMat`>",1
+nlme,pdConstruct.pdBlocked,1,0,0,"class<`pdBlocked`, `pdMat`>",1
+nlme,pdConstruct.pdBlocked,1,0,1,double[],1
+nlme,pdConstruct.pdBlocked,1,0,2,list<class<`formula`>>,1
+nlme,pdConstruct.pdBlocked,1,0,3,"list<class<`pdIdent`, `pdMat`>>",1
+nlme,pdConstruct.pdBlocked,1,0,4,list<character[]>,1
+nlme,pdConstruct.pdBlocked,1,0,5,list<class<`matrix`>>,1
+nlme,pdConstruct.pdBlocked,2,0,0,null,1
+nlme,pdConstruct.pdBlocked,2,0,1,list<class<`formula`>>,1
+nlme,pdConstruct.pdBlocked,3,0,0,null,1
+nlme,pdConstruct.pdBlocked,3,0,1,list<character[]>,1
+nlme,pdConstruct.pdBlocked,4,0,0,any,1
+nlme,pdConstruct.pdBlocked,5,0,0,character[],1
+nlme,pdConstruct.pdBlocked,6,0,0,...,1
+nlme,pdConstruct.pdCompSymm,-1,0,0,"class<`pdCompSymm`, `pdMat`>",1
+nlme,pdConstruct.pdCompSymm,0,0,0,"class<`pdCompSymm`, `pdMat`>",1
+nlme,pdConstruct.pdCompSymm,1,0,0,any,1
+nlme,pdConstruct.pdCompSymm,2,0,0,any,1
+nlme,pdConstruct.pdCompSymm,3,0,0,any,1
+nlme,pdConstruct.pdCompSymm,4,0,0,any,1
+nlme,pdConstruct.pdCompSymm,5,0,0,...,1
+nlme,pdConstruct.pdDiag,-1,0,0,"class<`pdDiag`, `pdMat`>",1
+nlme,pdConstruct.pdDiag,0,0,0,"class<`pdDiag`, `pdMat`>",1
+nlme,pdConstruct.pdDiag,1,0,0,any,1
+nlme,pdConstruct.pdDiag,2,0,0,any,1
+nlme,pdConstruct.pdDiag,3,0,0,any,1
+nlme,pdConstruct.pdDiag,4,0,0,any,1
+nlme,pdConstruct.pdDiag,5,0,0,...,1
+nlme,pdConstruct.pdIdent,-1,0,0,"class<`pdIdent`, `pdMat`>",1
+nlme,pdConstruct.pdIdent,0,0,0,"class<`pdIdent`, `pdMat`>",1
+nlme,pdConstruct.pdIdent,1,0,0,any,1
+nlme,pdConstruct.pdIdent,2,0,0,any,1
+nlme,pdConstruct.pdIdent,3,0,0,any,1
+nlme,pdConstruct.pdIdent,4,0,0,any,1
+nlme,pdConstruct.pdIdent,5,0,0,...,1
+nlme,pdConstruct.pdLogChol,-1,0,0,"class<`pdLogChol`, `pdMat`, `pdSymm`>",1
+nlme,pdConstruct.pdLogChol,0,0,0,"class<`pdLogChol`, `pdMat`>",1
+nlme,pdConstruct.pdLogChol,0,0,1,"class<`pdLogChol`, `pdMat`, `pdSymm`>",1
+nlme,pdConstruct.pdLogChol,1,0,0,class<`formula`>,1
+nlme,pdConstruct.pdLogChol,1,0,1,list<class<`formula`>>,1
+nlme,pdConstruct.pdLogChol,1,0,2,"class<`pdLogChol`, `pdMat`, `pdSymm`>",1
+nlme,pdConstruct.pdLogChol,1,0,3,double[],1
+nlme,pdConstruct.pdLogChol,1,0,4,class<`matrix`>,1
+nlme,pdConstruct.pdLogChol,2,0,0,null,1
+nlme,pdConstruct.pdLogChol,2,0,1,class<`formula`>,1
+nlme,pdConstruct.pdLogChol,2,0,2,class<`listForm`>,1
+nlme,pdConstruct.pdLogChol,3,0,0,null,1
+nlme,pdConstruct.pdLogChol,3,0,1,character[],1
+nlme,pdConstruct.pdLogChol,4,0,0,any,1
+nlme,pdConstruct.pdLogChol,5,0,0,...,1
+nlme,pdConstruct.pdMat,-1,0,0,class<`matrix`>,1
+nlme,pdConstruct.pdMat,-1,0,1,"class<`pdLogChol`, `pdMat`>",1
+nlme,pdConstruct.pdMat,-1,0,2,"class<`pdLogChol`, `pdMat`, `pdSymm`>",1
+nlme,pdConstruct.pdMat,-1,0,3,"class<`pdMat`, `pdNatural`>",1
+nlme,pdConstruct.pdMat,-1,0,4,"class<`pdCompSymm`, `pdMat`>",1
+nlme,pdConstruct.pdMat,-1,0,5,"class<`pdDiag`, `pdMat`>",1
+nlme,pdConstruct.pdMat,-1,0,6,"class<`pdIdent`, `pdMat`>",1
+nlme,pdConstruct.pdMat,-1,0,7,"class<`pdMat`, `pdSymm`>",1
+nlme,pdConstruct.pdMat,0,0,0,any,1
+nlme,pdConstruct.pdMat,1,0,0,class<`matrix`>,1
+nlme,pdConstruct.pdMat,1,0,1,class<`formula`>,1
+nlme,pdConstruct.pdMat,1,0,2,list<class<`formula`>>,1
+nlme,pdConstruct.pdMat,1,0,3,"class<`pdLogChol`, `pdMat`, `pdSymm`>",1
+nlme,pdConstruct.pdMat,1,0,4,double[],1
+nlme,pdConstruct.pdMat,1,0,5,"class<`pdMat`, `pdSymm`>",1
+nlme,pdConstruct.pdMat,1,0,6,"class<`pdCompSymm`, `pdMat`>",1
+nlme,pdConstruct.pdMat,1,0,7,"class<`pdDiag`, `pdMat`>",1
+nlme,pdConstruct.pdMat,1,0,8,"class<`pdIdent`, `pdMat`>",1
+nlme,pdConstruct.pdMat,1,0,9,character[],1
+nlme,pdConstruct.pdMat,2,0,0,null,1
+nlme,pdConstruct.pdMat,2,0,1,class<`formula`>,1
+nlme,pdConstruct.pdMat,2,0,2,class<`listForm`>,1
+nlme,pdConstruct.pdMat,3,0,0,character[],1
+nlme,pdConstruct.pdMat,3,0,1,null,1
+nlme,pdConstruct.pdMat,4,0,0,any,1
+nlme,pdConstruct.pdMat,5,0,0,...,1
+nlme,pdConstruct.pdNatural,-1,0,0,"class<`pdMat`, `pdNatural`>",1
+nlme,pdConstruct.pdNatural,0,0,0,"class<`pdMat`, `pdNatural`>",1
+nlme,pdConstruct.pdNatural,1,0,0,class<`matrix`>,1
+nlme,pdConstruct.pdNatural,1,0,1,"class<`pdLogChol`, `pdMat`, `pdSymm`>",1
+nlme,pdConstruct.pdNatural,1,0,2,"class<`pdMat`, `pdSymm`>",1
+nlme,pdConstruct.pdNatural,2,0,0,null,1
+nlme,pdConstruct.pdNatural,2,0,1,class<`formula`>,1
+nlme,pdConstruct.pdNatural,2,0,2,class<`listForm`>,1
+nlme,pdConstruct.pdNatural,3,0,0,null,1
+nlme,pdConstruct.pdNatural,3,0,1,character[],1
+nlme,pdConstruct.pdNatural,4,0,0,any,1
+nlme,pdConstruct.pdNatural,5,0,0,...,1
+nlme,pdConstruct.pdSymm,-1,0,0,"class<`pdMat`, `pdSymm`>",1
+nlme,pdConstruct.pdSymm,0,0,0,"class<`pdMat`, `pdSymm`>",1
+nlme,pdConstruct.pdSymm,1,0,0,any,1
+nlme,pdConstruct.pdSymm,2,0,0,any,1
+nlme,pdConstruct.pdSymm,3,0,0,any,1
+nlme,pdConstruct.pdSymm,4,0,0,any,1
+nlme,pdConstruct.pdSymm,5,0,0,...,1
+nlme,pdDiag,-1,0,0,"class<`pdDiag`, `pdMat`>",1
+nlme,pdDiag,0,0,0,class<`formula`>,1
+nlme,pdDiag,0,0,1,class<`matrix`>,1
+nlme,pdDiag,1,0,0,null,1
+nlme,pdDiag,1,0,1,class<`formula`>,1
+nlme,pdDiag,2,0,0,null,1
+nlme,pdDiag,2,0,1,character[],1
+nlme,pdDiag,3,0,0,any,1
+nlme,pdFactor,-1,0,0,class<`matrix`>,1
+nlme,pdFactor,-1,0,1,double[],1
+nlme,pdFactor,0,0,0,"class<`pdDiag`, `pdMat`>",1
+nlme,pdFactor,0,0,1,"class<`pdBlocked`, `pdMat`>",1
+nlme,pdFactor,0,0,2,"class<`pdCompSymm`, `pdMat`>",1
+nlme,pdFactor,0,0,3,"class<`pdLogChol`, `pdMat`, `pdSymm`>",1
+nlme,pdFactor,0,0,4,"class<`pdMat`, `pdNatural`>",1
+nlme,pdFactor,0,0,5,"class<`pdMat`, `pdSymm`>",1
+nlme,pdFactor,0,0,6,class<`reStruct`>,1
+nlme,pdFactor.pdBlocked,-1,0,0,class<`matrix`>,1
+nlme,pdFactor.pdBlocked,0,0,0,"class<`pdBlocked`, `pdMat`>",1
+nlme,pdFactor.pdCompSymm,-1,0,0,double[],1
+nlme,pdFactor.pdCompSymm,0,0,0,"class<`pdCompSymm`, `pdMat`>",1
+nlme,pdFactor.pdDiag,-1,0,0,class<`matrix`>,1
+nlme,pdFactor.pdDiag,0,0,0,"class<`pdDiag`, `pdMat`>",1
+nlme,pdFactor.pdLogChol,-1,0,0,double[],1
+nlme,pdFactor.pdLogChol,0,0,0,"class<`pdLogChol`, `pdMat`, `pdSymm`>",1
+nlme,pdFactor.pdNatural,-1,0,0,double[],1
+nlme,pdFactor.pdNatural,0,0,0,"class<`pdMat`, `pdNatural`>",1
+nlme,pdFactor.pdSymm,-1,0,0,double[],1
+nlme,pdFactor.pdSymm,0,0,0,"class<`pdMat`, `pdSymm`>",1
+nlme,pdFactor.reStruct,-1,0,0,double[],1
+nlme,pdFactor.reStruct,0,0,0,class<`reStruct`>,1
+nlme,pdIdent,-1,0,0,"class<`pdIdent`, `pdMat`>",1
+nlme,pdIdent,0,0,0,class<`formula`>,1
+nlme,pdIdent,0,0,1,class<`matrix`>,1
+nlme,pdIdent,1,0,0,null,1
+nlme,pdIdent,2,0,0,null,1
+nlme,pdIdent,2,0,1,character[],1
+nlme,pdIdent,3,0,0,any,1
+nlme,pdLogChol,-1,0,0,"class<`pdLogChol`, `pdMat`, `pdSymm`>",1
+nlme,pdLogChol,0,0,0,integer[],1
+nlme,pdLogChol,0,0,1,class<`matrix`>,1
+nlme,pdLogChol,1,0,0,null,1
+nlme,pdLogChol,2,0,0,null,1
+nlme,pdLogChol,2,0,1,character[],1
+nlme,pdLogChol,3,0,0,any,1
+nlme,pdMat,-1,0,0,"class<`pdBlocked`, `pdMat`>",1
+nlme,pdMat,-1,0,1,"class<`pdCompSymm`, `pdMat`>",1
+nlme,pdMat,-1,0,2,"class<`pdDiag`, `pdMat`>",1
+nlme,pdMat,-1,0,3,"class<`pdIdent`, `pdMat`>",1
+nlme,pdMat,-1,0,4,"class<`pdLogChol`, `pdMat`, `pdSymm`>",1
+nlme,pdMat,-1,0,5,"class<`pdMat`, `pdSymm`>",1
+nlme,pdMat,0,0,0,"class<`pdBlocked`, `pdMat`>",1
+nlme,pdMat,0,0,1,"class<`pdCompSymm`, `pdMat`>",1
+nlme,pdMat,0,0,2,"class<`pdDiag`, `pdMat`>",1
+nlme,pdMat,0,0,3,class<`matrix`>,1
+nlme,pdMat,0,0,4,"class<`pdIdent`, `pdMat`>",1
+nlme,pdMat,0,0,5,double[],1
+nlme,pdMat,0,0,6,class<`formula`>,1
+nlme,pdMat,0,0,7,"class<`pdLogChol`, `pdMat`, `pdSymm`>",1
+nlme,pdMat,0,0,8,list<class<`formula`>>,1
+nlme,pdMat,0,0,9,character[],1
+nlme,pdMat,0,0,10,"class<`pdMat`, `pdSymm`>",1
+nlme,pdMat,1,0,0,null,1
+nlme,pdMat,1,0,1,class<`formula`>,1
+nlme,pdMat,2,0,0,null,1
+nlme,pdMat,2,0,1,character[],1
+nlme,pdMat,3,0,0,any,1
+nlme,pdMat,4,0,0,any,1
+nlme,[<-.pdMat,-1,0,0,"class<`pdMat`, `pdSymm`>",1
+nlme,[<-.pdMat,0,0,0,"class<`pdMat`, `pdSymm`>",1
+nlme,[<-.pdMat,1,0,0,integer[],1
+nlme,[<-.pdMat,2,0,0,integer[],1
+nlme,[<-.pdMat,3,0,0,class<`matrix`>,1
+nlme,[.pdMat,-1,0,0,class<`matrix`>,1
+nlme,[.pdMat,0,0,0,"class<`pdMat`, `pdSymm`>",1
+nlme,[.pdMat,1,0,0,double,1
+nlme,[.pdMat,2,0,0,any,1
+nlme,[.pdMat,3,0,0,logical,1
+nlme,pdMatrix,-1,0,0,class<`matrix`>,1
+nlme,pdMatrix,-1,0,1,list<class<`matrix`>>,1
+nlme,pdMatrix,0,0,0,"class<`pdMat`, `pdSymm`>",1
+nlme,pdMatrix,0,0,1,"class<`pdLogChol`, `pdMat`, `pdSymm`>",1
+nlme,pdMatrix,0,0,2,"class<`pdBlocked`, `pdMat`>",1
+nlme,pdMatrix,0,0,3,"class<`pdCompSymm`, `pdMat`>",1
+nlme,pdMatrix,0,0,4,"class<`pdDiag`, `pdMat`>",1
+nlme,pdMatrix,0,0,5,"class<`pdIdent`, `pdMat`>",1
+nlme,pdMatrix,0,0,6,"class<`pdMat`, `pdNatural`>",1
+nlme,pdMatrix,0,0,7,class<`reStruct`>,1
+nlme,pdMatrix,1,0,0,logical,1
+nlme,pdMatrix.pdBlocked,-1,0,0,class<`matrix`>,1
+nlme,pdMatrix.pdBlocked,0,0,0,"class<`pdBlocked`, `pdMat`>",1
+nlme,pdMatrix.pdBlocked,1,0,0,logical,1
+nlme,pdMatrix.pdCompSymm,-1,0,0,class<`matrix`>,1
+nlme,pdMatrix.pdCompSymm,0,0,0,"class<`pdCompSymm`, `pdMat`>",1
+nlme,pdMatrix.pdCompSymm,1,0,0,logical,1
+nlme,pdMatrix.pdDiag,-1,0,0,class<`matrix`>,1
+nlme,pdMatrix.pdDiag,0,0,0,"class<`pdDiag`, `pdMat`>",1
+nlme,pdMatrix.pdDiag,1,0,0,logical,1
+nlme,pdMatrix.pdIdent,-1,0,0,class<`matrix`>,1
+nlme,pdMatrix.pdIdent,0,0,0,"class<`pdIdent`, `pdMat`>",1
+nlme,pdMatrix.pdIdent,1,0,0,logical,1
+nlme,pdMatrix.pdMat,-1,0,0,class<`matrix`>,1
+nlme,pdMatrix.pdMat,0,0,0,"class<`pdLogChol`, `pdMat`, `pdSymm`>",1
+nlme,pdMatrix.pdMat,0,0,1,"class<`pdMat`, `pdSymm`>",1
+nlme,pdMatrix.pdMat,1,0,0,logical,1
+nlme,pdMatrix.pdNatural,-1,0,0,class<`matrix`>,1
+nlme,pdMatrix.pdNatural,0,0,0,"class<`pdMat`, `pdNatural`>",1
+nlme,pdMatrix.pdNatural,1,0,0,logical,1
+nlme,pdMatrix.pdSymm,-1,0,0,class<`matrix`>,1
+nlme,pdMatrix.pdSymm,0,0,0,"class<`pdLogChol`, `pdMat`, `pdSymm`>",1
+nlme,pdMatrix.pdSymm,0,0,1,"class<`pdMat`, `pdSymm`>",1
+nlme,pdMatrix.pdSymm,1,0,0,logical,1
+nlme,pdMatrix.reStruct,-1,0,0,list<class<`matrix`>>,1
+nlme,pdMatrix.reStruct,0,0,0,class<`reStruct`>,1
+nlme,pdMatrix.reStruct,1,0,0,logical,1
+nlme,pdNatural,-1,0,0,"class<`pdMat`, `pdNatural`>",1
+nlme,pdNatural,0,0,0,class<`matrix`>,1
+nlme,pdNatural,0,0,1,"class<`pdLogChol`, `pdMat`, `pdSymm`>",1
+nlme,pdNatural,0,0,2,"class<`pdMat`, `pdSymm`>",1
+nlme,pdNatural,1,0,0,null,1
+nlme,pdNatural,2,0,0,null,1
+nlme,pdNatural,3,0,0,any,1
+nlme,pdSymm,-1,0,0,"class<`pdMat`, `pdSymm`>",1
+nlme,pdSymm,0,0,0,double[],1
+nlme,pdSymm,0,0,1,class<`formula`>,1
+nlme,pdSymm,0,0,2,class<`matrix`>,1
+nlme,pdSymm,1,0,0,null,1
+nlme,pdSymm,1,0,1,class<`formula`>,1
+nlme,pdSymm,2,0,0,null,1
+nlme,pdSymm,2,0,1,character[],1
+nlme,pdSymm,3,0,0,any,1
+nlme,plot.ACF,-1,0,0,class<`trellis`>,1
+nlme,plot.ACF,0,0,0,"class<`ACF`, `data.frame`>",1
+nlme,plot.ACF,1,0,0,double,1
+nlme,plot.ACF,2,0,0,character,1
+nlme,plot.ACF,3,0,0,character,1
+nlme,plot.ACF,4,0,0,logical,1
+nlme,plot.ACF,5,0,0,...,1
+nlme,plot.augPred,-1,0,0,class<`trellis`>,1
+nlme,plot.augPred,0,0,0,"class<`augPred`, `data.frame`>",1
+nlme,plot.augPred,1,0,0,logical,1
+nlme,plot.augPred,2,0,0,logical,1
+nlme,plot.augPred,3,0,0,...,1
+nlme,plot.compareFits,-1,0,0,class<`trellis`>,1
+nlme,plot.compareFits,0,0,0,class<`compareFits`>,1
+nlme,plot.compareFits,1,0,0,any,1
+nlme,plot.compareFits,2,0,0,logical,1
+nlme,plot.compareFits,3,0,0,null,1
+nlme,plot.compareFits,4,0,0,...,1
+nlme,plot.gls,-1,0,0,class<`trellis`>,1
+nlme,plot.gls,0,0,0,class<`gls`>,1
+nlme,plot.gls,0,0,1,"class<`gls`, `gnls`>",1
+nlme,plot.gls,1,0,0,class<`formula`>,1
+nlme,plot.gls,2,0,0,any,1
+nlme,plot.gls,3,0,0,null,1
+nlme,plot.gls,4,0,0,null,1
+nlme,plot.gls,5,0,0,any,1
+nlme,plot.gls,6,0,0,any,1
+nlme,plot.gls,7,0,0,...,1
+nlme,plot.intervals.lmList,-1,0,0,class<`trellis`>,1
+nlme,plot.intervals.lmList,0,0,0,class<`intervals.lmList`>,1
+nlme,plot.intervals.lmList,1,0,0,character,1
+nlme,plot.intervals.lmList,2,0,0,character,1
+nlme,plot.intervals.lmList,3,0,0,class<`function`>,1
+nlme,plot.intervals.lmList,4,0,0,...,1
+nlme,plot.lme,-1,0,0,class<`trellis`>,1
+nlme,plot.lme,0,0,0,class<`gls`>,1
+nlme,plot.lme,0,0,1,"class<`gls`, `gnls`>",1
+nlme,plot.lme,0,0,2,class<`lme`>,1
+nlme,plot.lme,1,0,0,class<`formula`>,1
+nlme,plot.lme,2,0,0,any,1
+nlme,plot.lme,3,0,0,null,1
+nlme,plot.lme,4,0,0,null,1
+nlme,plot.lme,5,0,0,any,1
+nlme,plot.lme,6,0,0,any,1
+nlme,plot.lme,7,0,0,...,1
+nlme,plot.lmList,-1,0,0,class<`trellis`>,1
+nlme,plot.lmList,0,0,0,class<`lmList`>,1
+nlme,plot.lmList,1,0,0,class<`formula`>,1
+nlme,plot.lmList,2,0,0,any,1
+nlme,plot.lmList,3,0,0,null,1
+nlme,plot.lmList,3,0,1,double,1
+nlme,plot.lmList,4,0,0,null,1
+nlme,plot.lmList,5,0,0,any,1
+nlme,plot.lmList,6,0,0,...,1
+nlme,plot.nffGroupedData,-1,0,0,class<`trellis`>,1
+nlme,plot.nffGroupedData,0,0,0,"class<`data.frame`, `groupedData`, `nfGroupedData`, `nffGroupedData`>",1
+nlme,plot.nffGroupedData,1,0,0,null,1
+nlme,plot.nffGroupedData,2,0,0,logical,1
+nlme,plot.nffGroupedData,2,0,1,null,1
+nlme,plot.nffGroupedData,3,0,0,null,1
+nlme,plot.nffGroupedData,4,0,0,character,1
+nlme,plot.nffGroupedData,5,0,0,character,1
+nlme,plot.nffGroupedData,6,0,0,class<`function`>,1
+nlme,plot.nffGroupedData,7,0,0,class<`function`>,1
+nlme,plot.nfnGroupedData,-1,0,0,class<`trellis`>,1
+nlme,plot.nfnGroupedData,0,0,0,"class<`data.frame`, `groupedData`, `nfGroupedData`, `nfnGroupedData`>",1
+nlme,plot.nfnGroupedData,1,0,0,null,1
+nlme,plot.nfnGroupedData,1,0,1,logical,1
+nlme,plot.nfnGroupedData,2,0,0,null,1
+nlme,plot.nfnGroupedData,2,0,1,class<`formula`>,1
+nlme,plot.nfnGroupedData,3,0,0,null,1
+nlme,plot.nfnGroupedData,3,0,1,class<`formula`>,1
+nlme,plot.nfnGroupedData,4,0,0,character,1
+nlme,plot.nfnGroupedData,5,0,0,character,1
+nlme,plot.nfnGroupedData,6,0,0,class<`function`>,1
+nlme,plot.nfnGroupedData,7,0,0,character,1
+nlme,plot.nmGroupedData,-1,0,0,class<`trellis`>,1
+nlme,plot.nmGroupedData,0,0,0,"class<`data.frame`, `groupedData`, `nmGroupedData`>",1
+nlme,plot.nmGroupedData,1,0,0,character,1
+nlme,plot.nmGroupedData,1,0,1,integer,1
+nlme,plot.nmGroupedData,2,0,0,character,1
+nlme,plot.nmGroupedData,3,0,0,null,1
+nlme,plot.nmGroupedData,4,0,0,null,1
+nlme,plot.nmGroupedData,4,0,1,class<`formula`>,1
+nlme,plot.nmGroupedData,5,0,0,class<`formula`>,1
+nlme,plot.nmGroupedData,5,0,1,null,1
+nlme,plot.nmGroupedData,6,0,0,any,1
+nlme,plot.nmGroupedData,7,0,0,null,1
+nlme,plot.ranef.lme,-1,0,0,class<`trellis`>,1
+nlme,plot.ranef.lme,0,0,0,"class<`data.frame`, `ranef.lmList`>",1
+nlme,plot.ranef.lme,0,0,1,"class<`data.frame`, `ranef.lme`>",1
+nlme,plot.ranef.lme,1,0,0,class<`formula`>,1
+nlme,plot.ranef.lme,1,0,1,null,1
+nlme,plot.ranef.lme,2,0,0,logical,1
+nlme,plot.ranef.lme,3,0,0,any,1
+nlme,plot.ranef.lme,4,0,0,any,1
+nlme,plot.ranef.lme,5,0,0,any,1
+nlme,plot.ranef.lme,6,0,0,null,1
+nlme,plot.ranef.lme,6,0,1,character,1
+nlme,plot.ranef.lme,7,0,0,null,1
+nlme,plot.ranef.lme,7,0,1,character,1
+nlme,plot.ranef.lmList,-1,0,0,class<`trellis`>,1
+nlme,plot.ranef.lmList,0,0,0,"class<`data.frame`, `ranef.lmList`>",1
+nlme,plot.ranef.lmList,1,0,0,class<`formula`>,1
+nlme,plot.ranef.lmList,1,0,1,null,1
+nlme,plot.ranef.lmList,2,0,0,logical,1
+nlme,plot.ranef.lmList,3,0,0,any,1
+nlme,plot.ranef.lmList,4,0,0,...,1
+nlme,plot.Variogram,-1,0,0,class<`trellis`>,1
+nlme,plot.Variogram,0,0,0,"class<`Variogram`, `data.frame`>",1
+nlme,plot.Variogram,1,0,0,any,1
+nlme,plot.Variogram,2,0,0,any,1
+nlme,plot.Variogram,3,0,0,null,1
+nlme,plot.Variogram,4,0,0,double,1
+nlme,plot.Variogram,5,0,0,character,1
+nlme,plot.Variogram,6,0,0,character,1
+nlme,plot.Variogram,7,0,0,character,1
+nlme,pooledSD,-1,0,0,double,1
+nlme,pooledSD,0,0,0,class<`lmList`>,1
+nlme,pooledSD,0,0,1,"class<`lmList`, `nlsList`>",1
+nlme,predict.gls,-1,0,0,double[],1
+nlme,predict.gls,0,0,0,class<`gls`>,1
+nlme,predict.gls,1,0,0,class<`data.frame`>,1
+nlme,predict.gls,2,0,0,class<`function`>,1
+nlme,predict.gls,3,0,0,...,1
+nlme,predict.gnls,-1,0,0,double[],1
+nlme,predict.gnls,0,0,0,"class<`gls`, `gnls`>",1
+nlme,predict.gnls,1,0,0,any,1
+nlme,predict.gnls,2,0,0,any,1
+nlme,predict.gnls,3,0,0,null,1
+nlme,predict.gnls,4,0,0,...,1
+nlme,predict.lme,-1,0,0,class<`data.frame`>,1
+nlme,predict.lme,-1,0,1,double[],1
+nlme,predict.lme,0,0,0,class<`lme`>,1
+nlme,predict.lme,1,0,0,any,1
+nlme,predict.lme,2,0,0,double[],1
+nlme,predict.lme,3,0,0,logical,1
+nlme,predict.lme,4,0,0,any,1
+nlme,predict.lme,5,0,0,...,1
+nlme,predict.lmList,-1,0,0,class<`data.frame`>,1
+nlme,predict.lmList,0,0,0,class<`lmList`>,1
+nlme,predict.lmList,1,0,0,any,1
+nlme,predict.lmList,2,0,0,null,1
+nlme,predict.lmList,3,0,0,logical,1
+nlme,predict.lmList,4,0,0,logical,1
+nlme,predict.lmList,5,0,0,logical,1
+nlme,predict.lmList,6,0,0,...,1
+nlme,predict.nlme,-1,0,0,class<`data.frame`>,1
+nlme,predict.nlme,-1,0,1,^double[],1
+nlme,predict.nlme,0,0,0,"class<`lme`, `nlme`>",1
+nlme,predict.nlme,1,0,0,any,1
+nlme,predict.nlme,2,0,0,integer[],1
+nlme,predict.nlme,2,0,1,double,1
+nlme,predict.nlme,3,0,0,logical,1
+nlme,predict.nlme,4,0,0,any,1
+nlme,predict.nlme,5,0,0,null,1
+nlme,predict.nlme,6,0,0,...,1
+nlme,print.compareFits,-1,0,0,class<`compareFits`>,1
+nlme,print.compareFits,0,0,0,class<`compareFits`>,1
+nlme,print.compareFits,1,0,0,...,1
+nlme,print.summary.pdMat,-1,0,0,class<`matrix`>,1
+nlme,print.summary.pdMat,0,0,0,class<`summary.pdMat`>,1
+nlme,print.summary.pdMat,1,0,0,double,1
+nlme,print.summary.pdMat,2,0,0,double,1
+nlme,print.summary.pdMat,3,0,0,null,1
+nlme,print.summary.pdMat,4,0,0,logical,1
+nlme,print.summary.pdMat,5,0,0,...,1
+nlme,print.varFunc,-1,0,0,"class<`varFunc`, `varPower`>",1
+nlme,print.varFunc,0,0,0,"class<`varFunc`, `varPower`>",1
+nlme,print.varFunc,1,0,0,...,1
+nlme,qqnorm.gls,-1,0,0,class<`trellis`>,1
+nlme,qqnorm.gls,0,0,0,class<`gls`>,1
+nlme,qqnorm.gls,1,0,0,class<`formula`>,1
+nlme,qqnorm.gls,2,0,0,double[],1
+nlme,qqnorm.gls,3,0,0,null,1
+nlme,qqnorm.gls,4,0,0,null,1
+nlme,qqnorm.gls,5,0,0,logical,1
+nlme,qqnorm.gls,6,0,0,...,1
+nlme,qqnorm.lme,-1,0,0,class<`trellis`>,1
+nlme,qqnorm.lme,0,0,0,class<`lme`>,1
+nlme,qqnorm.lme,1,0,0,class<`formula`>,1
+nlme,qqnorm.lme,2,0,0,double[],1
+nlme,qqnorm.lme,2,0,1,null,1
+nlme,qqnorm.lme,3,0,0,null,1
+nlme,qqnorm.lme,4,0,0,null,1
+nlme,qqnorm.lme,5,0,0,logical,1
+nlme,qqnorm.lme,6,0,0,...,1
+nlme,random.effects,-1,0,0,"class<`data.frame`, `ranef.lme`>",1
+nlme,random.effects,-1,0,1,"class<`data.frame`, `ranef.lmList`>",1
+nlme,random.effects,0,0,0,class<`lme`>,1
+nlme,random.effects,0,0,1,class<`lmList`>,1
+nlme,random.effects,0,0,2,"class<`lme`, `nlme`>",1
+nlme,random.effects,1,0,0,...,1
+nlme,ranef,-1,0,0,"class<`data.frame`, `ranef.lme`>",1
+nlme,ranef,-1,0,1,"class<`data.frame`, `ranef.lmList`>",1
+nlme,ranef,0,0,0,class<`lme`>,1
+nlme,ranef,0,0,1,class<`lmList`>,1
+nlme,ranef,0,0,2,"class<`lme`, `nlme`>",1
+nlme,ranef,1,0,0,...,1
+nlme,ranef.lme,-1,0,0,"class<`data.frame`, `ranef.lme`>",1
+nlme,ranef.lme,0,0,0,class<`lme`>,1
+nlme,ranef.lme,0,0,1,"class<`lme`, `nlme`>",1
+nlme,ranef.lme,1,0,0,logical,1
+nlme,ranef.lme,2,0,0,integer,1
+nlme,ranef.lme,3,0,0,any,1
+nlme,ranef.lme,4,0,0,any,1
+nlme,ranef.lme,5,0,0,any,1
+nlme,ranef.lme,6,0,0,logical,1
+nlme,ranef.lme,7,0,0,logical,1
+nlme,ranef.lmList,-1,0,0,"class<`data.frame`, `ranef.lmList`>",1
+nlme,ranef.lmList,0,0,0,class<`lmList`>,1
+nlme,ranef.lmList,1,0,0,logical,1
+nlme,ranef.lmList,2,0,0,null,1
+nlme,ranef.lmList,3,0,0,null,1
+nlme,ranef.lmList,4,0,0,any,1
+nlme,ranef.lmList,5,0,0,logical,1
+nlme,ranef.lmList,6,0,0,logical,1
+nlme,ranef.lmList,7,0,0,...,1
+nlme,recalc,-1,0,0,list<any>,1
+nlme,recalc,0,0,0,"class<`corAR1`, `corStruct`>",1
+nlme,recalc,0,0,1,"class<`corCompSymm`, `corStruct`>",1
+nlme,recalc,0,0,2,"class<`corNatural`, `corStruct`>",1
+nlme,recalc,0,0,3,"class<`corStruct`, `corSymm`>",1
+nlme,recalc,0,0,4,"class<`glsStruct`, `modelStruct`>",1
+nlme,recalc,0,0,5,"class<`varFunc`, `varIdent`>",1
+nlme,recalc,0,0,6,"class<`varFunc`, `varPower`>",1
+nlme,recalc,0,0,7,"class<`corRatio`, `corSpatial`, `corStruct`>",1
+nlme,recalc,0,0,8,"class<`corSpatial`, `corSpher`, `corStruct`>",1
+nlme,recalc,0,0,9,"class<`lmeStruct`, `lmeStructInt`, `modelStruct`>",1
+nlme,recalc,0,0,10,"class<`lmeStruct`, `modelStruct`>",1
+nlme,recalc,0,0,11,class<`reStruct`>,1
+nlme,recalc,0,0,12,"class<`lmeStruct`, `lmeStructInt`, `modelStruct`, `nlmeStruct`>",1
+nlme,recalc,0,0,13,"class<`corARMA`, `corStruct`>",1
+nlme,recalc,0,0,14,"class<`corCAR1`, `corStruct`>",1
+nlme,recalc,0,0,15,"class<`lmeStruct`, `modelStruct`, `nlmeStruct`>",1
+nlme,recalc,0,0,16,"class<`corExp`, `corSpatial`, `corStruct`>",1
+nlme,recalc,0,0,17,"class<`corGaus`, `corSpatial`, `corStruct`>",1
+nlme,recalc,0,0,18,"class<`corLin`, `corSpatial`, `corStruct`>",1
+nlme,recalc,0,0,19,"class<`glsStruct`, `gnlsStruct`, `modelStruct`>",1
+nlme,recalc,1,0,0,any,1
+nlme,recalc,2,0,0,...,1
+nlme,recalc.corAR1,-1,0,0,list<any>,1
+nlme,recalc.corAR1,0,0,0,"class<`corAR1`, `corStruct`>",1
+nlme,recalc.corAR1,1,0,0,list<any>,1
+nlme,recalc.corAR1,2,0,0,...,1
+nlme,recalc.corARMA,-1,0,0,list<class<`matrix`> | double | list<double[] | list<double[]>>>,1
+nlme,recalc.corARMA,0,0,0,"class<`corARMA`, `corStruct`>",1
+nlme,recalc.corARMA,1,0,0,list<class<`matrix`> | double | list<double[] | list<double[]>>>,1
+nlme,recalc.corARMA,2,0,0,...,1
+nlme,recalc.corCAR1,-1,0,0,list<class<`matrix`> | double | list<double[] | list<double[]>>>,1
+nlme,recalc.corCAR1,0,0,0,"class<`corCAR1`, `corStruct`>",1
+nlme,recalc.corCAR1,1,0,0,list<class<`matrix`> | double | list<double[] | list<double[]>>>,1
+nlme,recalc.corCAR1,2,0,0,...,1
+nlme,recalc.corCompSymm,-1,0,0,list<any>,1
+nlme,recalc.corCompSymm,0,0,0,"class<`corCompSymm`, `corStruct`>",1
+nlme,recalc.corCompSymm,1,0,0,list<any>,1
+nlme,recalc.corCompSymm,2,0,0,...,1
+nlme,recalc.corNatural,-1,0,0,list<any>,1
+nlme,recalc.corNatural,0,0,0,"class<`corNatural`, `corStruct`>",1
+nlme,recalc.corNatural,1,0,0,list<any>,1
+nlme,recalc.corNatural,2,0,0,...,1
+nlme,recalc.corSpatial,-1,0,0,list<any>,1
+nlme,recalc.corSpatial,0,0,0,"class<`corRatio`, `corSpatial`, `corStruct`>",1
+nlme,recalc.corSpatial,0,0,1,"class<`corSpatial`, `corSpher`, `corStruct`>",1
+nlme,recalc.corSpatial,0,0,2,"class<`corExp`, `corSpatial`, `corStruct`>",1
+nlme,recalc.corSpatial,0,0,3,"class<`corGaus`, `corSpatial`, `corStruct`>",1
+nlme,recalc.corSpatial,0,0,4,"class<`corLin`, `corSpatial`, `corStruct`>",1
+nlme,recalc.corSpatial,1,0,0,list<any>,1
+nlme,recalc.corSpatial,2,0,0,...,1
+nlme,recalc.corSymm,-1,0,0,list<any>,1
+nlme,recalc.corSymm,0,0,0,"class<`corStruct`, `corSymm`>",1
+nlme,recalc.corSymm,1,0,0,list<any>,1
+nlme,recalc.corSymm,2,0,0,...,1
+nlme,recalc.modelStruct,-1,0,0,list<any>,1
+nlme,recalc.modelStruct,0,0,0,"class<`glsStruct`, `modelStruct`>",1
+nlme,recalc.modelStruct,0,0,1,"class<`lmeStruct`, `lmeStructInt`, `modelStruct`>",1
+nlme,recalc.modelStruct,0,0,2,"class<`lmeStruct`, `modelStruct`>",1
+nlme,recalc.modelStruct,0,0,3,"class<`lmeStruct`, `lmeStructInt`, `modelStruct`, `nlmeStruct`>",1
+nlme,recalc.modelStruct,0,0,4,"class<`lmeStruct`, `modelStruct`, `nlmeStruct`>",1
+nlme,recalc.modelStruct,0,0,5,"class<`glsStruct`, `gnlsStruct`, `modelStruct`>",1
+nlme,recalc.modelStruct,1,0,0,list<class<`matrix`> | double | list<integer>>,1
+nlme,recalc.modelStruct,1,0,1,list<class<`matrix`> | double | list<double[] | list<double[]>>>,1
+nlme,recalc.modelStruct,2,0,0,...,1
+nlme,recalc.reStruct,-1,0,0,list<any>,1
+nlme,recalc.reStruct,0,0,0,class<`reStruct`>,1
+nlme,recalc.reStruct,1,0,0,list<any>,1
+nlme,recalc.reStruct,2,0,0,...,1
+nlme,recalc.varFunc,-1,0,0,list<any>,1
+nlme,recalc.varFunc,0,0,0,"class<`varFunc`, `varIdent`>",1
+nlme,recalc.varFunc,0,0,1,"class<`varFunc`, `varPower`>",1
+nlme,recalc.varFunc,1,0,0,list<class<`matrix`> | double | list<integer>>,1
+nlme,recalc.varFunc,1,0,1,list<class<`matrix`> | double | list<double[] | list<double[]>>>,1
+nlme,recalc.varFunc,2,0,0,...,1
+nlme,recalc.varIdent,-1,0,0,list<any>,1
+nlme,recalc.varIdent,0,0,0,"class<`varFunc`, `varIdent`>",1
+nlme,recalc.varIdent,1,0,0,list<class<`matrix`> | double | list<integer>>,1
+nlme,recalc.varIdent,1,0,1,list<class<`matrix`> | double | list<double[] | list<double[]>>>,1
+nlme,recalc.varIdent,2,0,0,...,1
+nlme,residuals.gls,-1,0,0,^double[],1
+nlme,residuals.gls,0,0,0,class<`gls`>,1
+nlme,residuals.gls,0,0,1,"class<`gls`, `gnls`>",1
+nlme,residuals.gls,1,0,0,character[],1
+nlme,residuals.gls,2,0,0,...,1
+nlme,residuals.gnls,-1,0,0,^double[],1
+nlme,residuals.gnls,0,0,0,class<`gls`>,1
+nlme,residuals.gnls,0,0,1,"class<`gls`, `gnls`>",1
+nlme,residuals.gnls,1,0,0,character[],1
+nlme,residuals.gnls,2,0,0,...,1
+nlme,residuals.gnlsStruct,-1,0,0,double[],1
+nlme,residuals.gnlsStruct,0,0,0,"class<`glsStruct`, `gnlsStruct`, `modelStruct`>",1
+nlme,residuals.gnlsStruct,1,0,0,...,1
+nlme,residuals.lme,-1,0,0,class<`matrix`>,1
+nlme,residuals.lme,-1,0,1,^double[],1
+nlme,residuals.lme,-1,0,2,list<double[]>,1
+nlme,residuals.lme,0,0,0,class<`lme`>,1
+nlme,residuals.lme,0,0,1,"class<`lme`, `nlme`>",1
+nlme,residuals.lme,1,0,0,integer[],1
+nlme,residuals.lme,2,0,0,character[],1
+nlme,residuals.lme,3,0,0,logical,1
+nlme,residuals.lme,4,0,0,...,1
+nlme,residuals.lmList,-1,0,0,^double[],1
+nlme,residuals.lmList,0,0,0,"class<`lmList`, `nlsList`>",1
+nlme,residuals.lmList,0,0,1,class<`lmList`>,1
+nlme,residuals.lmList,1,0,0,character[],1
+nlme,residuals.lmList,2,0,0,null,1
+nlme,residuals.lmList,3,0,0,logical,1
+nlme,residuals.lmList,4,0,0,...,1
+nlme,residuals.nlmeStruct,-1,0,0,class<`matrix`>,1
+nlme,residuals.nlmeStruct,0,0,0,"class<`lmeStruct`, `lmeStructInt`, `modelStruct`, `nlmeStruct`>",1
+nlme,residuals.nlmeStruct,0,0,1,"class<`lmeStruct`, `modelStruct`, `nlmeStruct`>",1
+nlme,residuals.nlmeStruct,1,0,0,integer[],1
+nlme,residuals.nlmeStruct,2,0,0,list<class<`matrix`> | double | list<double[] | list<double[]>>>,1
+nlme,residuals.nlmeStruct,3,0,0,...,1
+nlme,reStruct,-1,0,0,class<`reStruct`>,1
+nlme,reStruct,0,0,0,class<`formula`>,1
+nlme,reStruct,0,0,1,class<`reStruct`>,1
+nlme,reStruct,0,0,2,list<class<`formula`>>,1
+nlme,reStruct,0,0,3,"list<class<`pdDiag`, `pdMat`> | class<`formula`>>",1
+nlme,reStruct,0,0,4,"list<class<`pdDiag`, `pdMat`>>",1
+nlme,reStruct,0,0,5,"list<class<`pdMat`, `pdSymm`> | class<`pdDiag`, `pdMat`>>",1
+nlme,reStruct,0,0,6,"class<`pdBlocked`, `pdMat`>",1
+nlme,reStruct,0,0,7,"class<`pdCompSymm`, `pdMat`>",1
+nlme,reStruct,0,0,8,"class<`pdDiag`, `pdMat`>",1
+nlme,reStruct,0,0,9,"class<`pdMat`, `pdSymm`>",1
+nlme,reStruct,1,0,0,character,1
+nlme,reStruct,2,0,0,logical,1
+nlme,reStruct,3,0,0,null,1
+nlme,reStruct,3,0,1,"class<`data.frame`, `groupedData`, `nfGroupedData`, `nfnGroupedData`>",1
+nlme,reStruct,3,0,2,environment,1
+nlme,reStruct,3,0,3,"class<`data.frame`, `groupedData`, `nmGroupedData`>",1
+nlme,[.reStruct,-1,0,0,class<`reStruct`>,1
+nlme,[.reStruct,0,0,0,class<`reStruct`>,1
+nlme,[.reStruct,1,0,0,...,1
+nlme,sigma.gls,-1,0,0,double,1
+nlme,sigma.gls,0,0,0,class<`gls`>,1
+nlme,sigma.gls,0,0,1,class<`lme`>,1
+nlme,sigma.gls,0,0,2,"class<`lme`, `nlme`>",1
+nlme,sigma.gls,1,0,0,...,1
+nlme,sigma.lme,-1,0,0,double,1
+nlme,sigma.lme,0,0,0,class<`gls`>,1
+nlme,sigma.lme,0,0,1,class<`lme`>,1
+nlme,sigma.lme,0,0,2,"class<`lme`, `nlme`>",1
+nlme,sigma.lme,1,0,0,...,1
+nlme,simulate.lme,-1,0,0,class<`simulate.lme`>,1
+nlme,simulate.lme,0,0,0,"list<class<`formula`> | class<`data.frame`, `groupedData`, `nfGroupedData`, `nfnGroupedData`>>",1
+nlme,simulate.lme,0,0,1,class<`lme`>,1
+nlme,simulate.lme,1,0,0,double,1
+nlme,simulate.lme,2,0,0,double,1
+nlme,simulate.lme,3,0,0,any,1
+nlme,simulate.lme,4,0,0,character[],1
+nlme,simulate.lme,5,0,0,double[],1
+nlme,simulate.lme,6,0,0,any,1
+nlme,simulate.lme,7,0,0,...,1
+nlme,solve.pdBlocked,-1,0,0,"class<`pdBlocked`, `pdMat`>",1
+nlme,solve.pdBlocked,0,0,0,"class<`pdBlocked`, `pdMat`>",1
+nlme,solve.pdBlocked,1,0,0,any,1
+nlme,solve.pdBlocked,2,0,0,...,1
+nlme,solve.pdDiag,-1,0,0,"class<`pdDiag`, `pdMat`>",1
+nlme,solve.pdDiag,-1,0,1,"class<`pdIdent`, `pdMat`>",1
+nlme,solve.pdDiag,-1,0,2,"class<`pdMat`, `pdSymm`>",1
+nlme,solve.pdDiag,0,0,0,"class<`pdDiag`, `pdMat`>",1
+nlme,solve.pdDiag,0,0,1,"class<`pdIdent`, `pdMat`>",1
+nlme,solve.pdDiag,0,0,2,"class<`pdMat`, `pdSymm`>",1
+nlme,solve.pdDiag,1,0,0,any,1
+nlme,solve.pdDiag,2,0,0,...,1
+nlme,solve.pdIdent,-1,0,0,"class<`pdDiag`, `pdMat`>",1
+nlme,solve.pdIdent,-1,0,1,"class<`pdIdent`, `pdMat`>",1
+nlme,solve.pdIdent,-1,0,2,"class<`pdMat`, `pdSymm`>",1
+nlme,solve.pdIdent,0,0,0,"class<`pdDiag`, `pdMat`>",1
+nlme,solve.pdIdent,0,0,1,"class<`pdIdent`, `pdMat`>",1
+nlme,solve.pdIdent,0,0,2,"class<`pdMat`, `pdSymm`>",1
+nlme,solve.pdIdent,1,0,0,any,1
+nlme,solve.pdIdent,2,0,0,...,1
+nlme,solve.pdLogChol,-1,0,0,"class<`pdLogChol`, `pdMat`, `pdSymm`>",1
+nlme,solve.pdLogChol,0,0,0,"class<`pdLogChol`, `pdMat`, `pdSymm`>",1
+nlme,solve.pdLogChol,1,0,0,any,1
+nlme,solve.pdLogChol,2,0,0,...,1
+nlme,solve.pdMat,-1,0,0,"class<`pdCompSymm`, `pdMat`>",1
+nlme,solve.pdMat,0,0,0,"class<`pdCompSymm`, `pdMat`>",1
+nlme,solve.pdMat,1,0,0,any,1
+nlme,solve.pdMat,2,0,0,...,1
+nlme,solve.pdNatural,-1,0,0,"class<`pdMat`, `pdNatural`>",1
+nlme,solve.pdNatural,0,0,0,"class<`pdMat`, `pdNatural`>",1
+nlme,solve.pdNatural,1,0,0,any,1
+nlme,solve.pdNatural,2,0,0,...,1
+nlme,solve.pdSymm,-1,0,0,"class<`pdDiag`, `pdMat`>",1
+nlme,solve.pdSymm,-1,0,1,"class<`pdIdent`, `pdMat`>",1
+nlme,solve.pdSymm,-1,0,2,"class<`pdMat`, `pdSymm`>",1
+nlme,solve.pdSymm,0,0,0,"class<`pdDiag`, `pdMat`>",1
+nlme,solve.pdSymm,0,0,1,"class<`pdIdent`, `pdMat`>",1
+nlme,solve.pdSymm,0,0,2,"class<`pdMat`, `pdSymm`>",1
+nlme,solve.pdSymm,1,0,0,any,1
+nlme,solve.pdSymm,2,0,0,...,1
+nlme,solve.reStruct,-1,0,0,class<`reStruct`>,1
+nlme,solve.reStruct,0,0,0,class<`reStruct`>,1
+nlme,solve.reStruct,1,0,0,any,1
+nlme,solve.reStruct,2,0,0,...,1
+nlme,splitFormula,-1,0,0,list<class<`formula`>>,1
+nlme,splitFormula,0,0,0,class<`call`>,1
+nlme,splitFormula,0,0,1,class<`name`>,1
+nlme,splitFormula,0,0,2,class<`formula`>,1
+nlme,splitFormula,1,0,0,any,1
+nlme,summary.corAR1,-1,0,0,class<`summary.corStruct`>,1
+nlme,summary.corAR1,0,0,0,"class<`corAR1`, `corStruct`>",1
+nlme,summary.corAR1,1,0,0,character,1
+nlme,summary.corAR1,2,0,0,...,1
+nlme,summary.corStruct,-1,0,0,class<`summary.corStruct`>,1
+nlme,summary.corStruct,0,0,0,"class<`corAR1`, `corStruct`>",1
+nlme,summary.corStruct,1,0,0,character,1
+nlme,summary.corStruct,2,0,0,...,1
+nlme,summary.gls,-1,0,0,"class<`gls`, `gnls`, `summary.gls`>",1
+nlme,summary.gls,-1,0,1,"class<`gls`, `summary.gls`>",1
+nlme,summary.gls,0,0,0,"class<`gls`, `gnls`>",1
+nlme,summary.gls,0,0,1,class<`gls`>,1
+nlme,summary.gls,1,0,0,logical,1
+nlme,summary.gls,2,0,0,...,1
+nlme,summary.lme,-1,0,0,"class<`lme`, `nlme`, `summary.lme`>",1
+nlme,summary.lme,-1,0,1,"class<`lme`, `summary.lme`>",1
+nlme,summary.lme,0,0,0,"class<`lme`, `nlme`>",1
+nlme,summary.lme,0,0,1,class<`lme`>,1
+nlme,summary.lme,1,0,0,logical,1
+nlme,summary.lme,2,0,0,logical,1
+nlme,summary.lme,3,0,0,...,1
+nlme,summary.lmList,-1,0,0,class<`summary.lmList`>,1
+nlme,summary.lmList,0,0,0,class<`lmList`>,1
+nlme,summary.lmList,0,0,1,"class<`lmList`, `nlsList`>",1
+nlme,summary.lmList,1,0,0,logical,1
+nlme,summary.lmList,2,0,0,...,1
+nlme,summary.modelStruct,-1,0,0,class<`summary.modelStruct`>,1
+nlme,summary.modelStruct,0,0,0,"class<`lmeStruct`, `modelStruct`>",1
+nlme,summary.modelStruct,1,0,0,...,1
+nlme,summary.nlsList,-1,0,0,"class<`summary.lmList`, `summary.nlsList`>",1
+nlme,summary.nlsList,0,0,0,"class<`lmList`, `nlsList`>",1
+nlme,summary.nlsList,1,0,0,...,1
+nlme,summary.pdCompSymm,-1,0,0,class<`summary.pdMat`>,1
+nlme,summary.pdCompSymm,0,0,0,"class<`pdCompSymm`, `pdMat`>",1
+nlme,summary.pdCompSymm,1,0,0,character,1
+nlme,summary.pdCompSymm,2,0,0,...,1
+nlme,summary.pdLogChol,-1,0,0,class<`summary.pdMat`>,1
+nlme,summary.pdLogChol,0,0,0,"class<`pdLogChol`, `pdMat`, `pdSymm`>",1
+nlme,summary.pdLogChol,1,0,0,character,1
+nlme,summary.pdLogChol,2,0,0,...,1
+nlme,summary.pdMat,-1,0,0,class<`summary.pdMat`>,1
+nlme,summary.pdMat,0,0,0,"class<`pdMat`, `pdSymm`>",1
+nlme,summary.pdMat,0,0,1,"class<`pdLogChol`, `pdMat`, `pdSymm`>",1
+nlme,summary.pdMat,0,0,2,"class<`pdCompSymm`, `pdMat`>",1
+nlme,summary.pdMat,1,0,0,character,1
+nlme,summary.pdMat,2,0,0,logical,1
+nlme,summary.pdMat,3,0,0,...,1
+nlme,summary.pdSymm,-1,0,0,class<`summary.pdMat`>,1
+nlme,summary.pdSymm,0,0,0,"class<`pdMat`, `pdSymm`>",1
+nlme,summary.pdSymm,1,0,0,character,1
+nlme,summary.pdSymm,2,0,0,...,1
+nlme,summary.reStruct,-1,0,0,class<`reStruct`>,1
+nlme,summary.reStruct,0,0,0,class<`reStruct`>,1
+nlme,summary.reStruct,1,0,0,...,1
+nlme,summary.varFunc,-1,0,0,class<`summary.varFunc`>,1
+nlme,summary.varFunc,0,0,0,"class<`varFunc`, `varPower`>",1
+nlme,summary.varFunc,1,0,0,character,1
+nlme,summary.varFunc,2,0,0,...,1
+nlme,summary.varPower,-1,0,0,class<`summary.varFunc`>,1
+nlme,summary.varPower,0,0,0,"class<`varFunc`, `varPower`>",1
+nlme,summary.varPower,1,0,0,character,1
+nlme,summary.varPower,2,0,0,...,1
+nlme,svd.d,-1,0,0,double[],1
+nlme,svd.d,0,0,0,class<`matrix`>,1
+nlme,terms.gls,-1,0,0,"class<`formula`, `terms`>",1
+nlme,terms.gls,0,0,0,class<`gls`>,1
+nlme,terms.gls,1,0,0,...,1
+nlme,update.corStruct,-1,0,0,"class<`corAR1`, `corStruct`>",1
+nlme,update.corStruct,-1,0,1,"class<`corExp`, `corSpatial`, `corStruct`>",1
+nlme,update.corStruct,-1,0,2,"class<`corGaus`, `corSpatial`, `corStruct`>",1
+nlme,update.corStruct,-1,0,3,"class<`corLin`, `corSpatial`, `corStruct`>",1
+nlme,update.corStruct,-1,0,4,"class<`corRatio`, `corSpatial`, `corStruct`>",1
+nlme,update.corStruct,-1,0,5,"class<`corSpatial`, `corSpher`, `corStruct`>",1
+nlme,update.corStruct,0,0,0,"class<`corAR1`, `corStruct`>",1
+nlme,update.corStruct,0,0,1,"class<`corExp`, `corSpatial`, `corStruct`>",1
+nlme,update.corStruct,0,0,2,"class<`corGaus`, `corSpatial`, `corStruct`>",1
+nlme,update.corStruct,0,0,3,"class<`corLin`, `corSpatial`, `corStruct`>",1
+nlme,update.corStruct,0,0,4,"class<`corRatio`, `corSpatial`, `corStruct`>",1
+nlme,update.corStruct,0,0,5,"class<`corSpatial`, `corSpher`, `corStruct`>",1
+nlme,update.corStruct,1,0,0,any,1
+nlme,update.corStruct,2,0,0,...,1
+nlme,update.gls,-1,0,0,class<`call`>,1
+nlme,update.gls,-1,0,1,class<`gls`>,1
+nlme,update.gls,0,0,0,class<`gls`>,1
+nlme,update.gls,1,0,0,any,1
+nlme,update.gls,2,0,0,...,1
+nlme,update.gls,3,0,0,logical,1
+nlme,update.gnls,-1,0,0,"class<`gls`, `gnls`>",1
+nlme,update.gnls,0,0,0,"class<`gls`, `gnls`>",1
+nlme,update.gnls,1,0,0,any,1
+nlme,update.gnls,2,0,0,...,1
+nlme,update.gnls,3,0,0,logical,1
+nlme,update.groupedData,-1,0,0,"class<`data.frame`, `groupedData`, `nfGroupedData`, `nfnGroupedData`>",1
+nlme,update.groupedData,0,0,0,"class<`data.frame`, `groupedData`, `nfGroupedData`, `nfnGroupedData`>",1
+nlme,update.groupedData,1,0,0,any,1
+nlme,update.groupedData,2,0,0,any,1
+nlme,update.groupedData,3,0,0,any,1
+nlme,update.groupedData,4,0,0,any,1
+nlme,update.groupedData,5,0,0,any,1
+nlme,update.groupedData,6,0,0,any,1
+nlme,update.groupedData,7,0,0,any,1
+nlme,update.lme,-1,0,0,class<`call`>,1
+nlme,update.lme,-1,0,1,class<`lme`>,1
+nlme,update.lme,0,0,0,class<`lme`>,1
+nlme,update.lme,1,0,0,any,1
+nlme,update.lme,2,0,0,...,1
+nlme,update.lme,3,0,0,logical,1
+nlme,update.modelStruct,-1,0,0,"class<`glsStruct`, `gnlsStruct`, `modelStruct`>",1
+nlme,update.modelStruct,-1,0,1,"class<`glsStruct`, `modelStruct`>",1
+nlme,update.modelStruct,-1,0,2,"class<`lmeStruct`, `modelStruct`>",1
+nlme,update.modelStruct,0,0,0,"class<`glsStruct`, `gnlsStruct`, `modelStruct`>",1
+nlme,update.modelStruct,0,0,1,"class<`glsStruct`, `modelStruct`>",1
+nlme,update.modelStruct,0,0,2,"class<`lmeStruct`, `modelStruct`>",1
+nlme,update.modelStruct,1,0,0,class<`data.frame`>,1
+nlme,update.modelStruct,2,0,0,...,1
+nlme,update.nlme,-1,0,0,"class<`lme`, `nlme`>",1
+nlme,update.nlme,0,0,0,"class<`lme`, `nlme`>",1
+nlme,update.nlme,1,0,0,any,1
+nlme,update.nlme,2,0,0,...,1
+nlme,update.nlme,3,0,0,logical,1
+nlme,update.reStruct,-1,0,0,class<`reStruct`>,1
+nlme,update.reStruct,0,0,0,class<`reStruct`>,1
+nlme,update.reStruct,1,0,0,any,1
+nlme,update.reStruct,2,0,0,...,1
+nlme,update.varFunc,-1,0,0,"class<`varFunc`, `varPower`>",1
+nlme,update.varFunc,0,0,0,"class<`varFunc`, `varPower`>",1
+nlme,update.varFunc,1,0,0,list<any>,1
+nlme,update.varFunc,2,0,0,...,1
+nlme,update.varPower,-1,0,0,"class<`varFunc`, `varPower`>",1
+nlme,update.varPower,0,0,0,"class<`varFunc`, `varPower`>",1
+nlme,update.varPower,1,0,0,list<any>,1
+nlme,update.varPower,2,0,0,...,1
+nlme,varComb,-1,0,0,"class<`varComb`, `varFunc`>",1
+nlme,varComb,0,0,0,...,1
+nlme,varConstPower,-1,0,0,"class<`varConstPower`, `varFunc`>",1
+nlme,varConstPower,0,0,0,double,1
+nlme,varConstPower,1,0,0,double,1
+nlme,varConstPower,2,0,0,class<`formula`>,1
+nlme,varConstPower,3,0,0,null,1
+nlme,VarCorr,-1,0,0,class<`matrix`>,1
+nlme,VarCorr,-1,0,1,class<`VarCorr.lme`>,1
+nlme,VarCorr,0,0,0,"class<`pdLogChol`, `pdMat`, `pdSymm`>",1
+nlme,VarCorr,0,0,1,class<`lme`>,1
+nlme,VarCorr,0,0,2,"class<`lme`, `nlme`>",1
+nlme,VarCorr,1,0,0,double,1
+nlme,VarCorr,2,0,0,...,1
+nlme,VarCorr.lme,-1,0,0,class<`VarCorr.lme`>,1
+nlme,VarCorr.lme,0,0,0,class<`lme`>,1
+nlme,VarCorr.lme,0,0,1,"class<`lme`, `nlme`>",1
+nlme,VarCorr.lme,1,0,0,double,1
+nlme,VarCorr.lme,2,0,0,double,1
+nlme,VarCorr.lme,3,0,0,...,1
+nlme,VarCorr.pdMat,-1,0,0,class<`matrix`>,1
+nlme,VarCorr.pdMat,0,0,0,"class<`pdLogChol`, `pdMat`, `pdSymm`>",1
+nlme,VarCorr.pdMat,1,0,0,double,1
+nlme,VarCorr.pdMat,2,0,0,any,1
+nlme,VarCorr.pdMat,3,0,0,...,1
+nlme,varExp,-1,0,0,"class<`varExp`, `varFunc`>",1
+nlme,varExp,0,0,0,double[],1
+nlme,varExp,1,0,0,class<`formula`>,1
+nlme,varExp,2,0,0,null,1
+nlme,varFixed,-1,0,0,"class<`varFixed`, `varFunc`>",1
+nlme,varFixed,0,0,0,class<`formula`>,1
+nlme,varFunc,-1,0,0,"class<`varFixed`, `varFunc`>",1
+nlme,varFunc,-1,0,1,"class<`varFunc`, `varIdent`>",1
+nlme,varFunc,-1,0,2,"class<`varFunc`, `varPower`>",1
+nlme,varFunc,-1,0,3,null,1
+nlme,varFunc,0,0,0,class<`formula`>,1
+nlme,varFunc,0,0,1,"class<`varFunc`, `varIdent`>",1
+nlme,varFunc,0,0,2,"class<`varFunc`, `varPower`>",1
+nlme,varFunc,0,0,3,null,1
+nlme,varIdent,-1,0,0,"class<`varFunc`, `varIdent`>",1
+nlme,varIdent,0,0,0,double[],1
+nlme,varIdent,1,0,0,class<`formula`>,1
+nlme,varIdent,2,0,0,double,1
+nlme,varIdent,2,0,1,null,1
+nlme,Variogram,-1,0,0,"class<`Variogram`, `data.frame`>",1
+nlme,Variogram,0,0,0,"class<`corExp`, `corSpatial`, `corStruct`>",1
+nlme,Variogram,0,0,1,"class<`corGaus`, `corSpatial`, `corStruct`>",1
+nlme,Variogram,0,0,2,"class<`corLin`, `corSpatial`, `corStruct`>",1
+nlme,Variogram,0,0,3,"class<`corRatio`, `corSpatial`, `corStruct`>",1
+nlme,Variogram,0,0,4,"class<`corSpatial`, `corSpher`, `corStruct`>",1
+nlme,Variogram,0,0,5,double[],1
+nlme,Variogram,0,0,6,class<`gls`>,1
+nlme,Variogram,0,0,7,class<`lme`>,1
+nlme,Variogram,1,0,0,any,1
+nlme,Variogram,2,0,0,...,1
+nlme,Variogram.corExp,-1,0,0,"class<`Variogram`, `data.frame`>",1
+nlme,Variogram.corExp,0,0,0,"class<`corExp`, `corSpatial`, `corStruct`>",1
+nlme,Variogram.corExp,1,0,0,null,1
+nlme,Variogram.corExp,2,0,0,double,1
+nlme,Variogram.corExp,3,0,0,double,1
+nlme,Variogram.corExp,4,0,0,...,1
+nlme,Variogram.corGaus,-1,0,0,"class<`Variogram`, `data.frame`>",1
+nlme,Variogram.corGaus,0,0,0,"class<`corGaus`, `corSpatial`, `corStruct`>",1
+nlme,Variogram.corGaus,1,0,0,null,1
+nlme,Variogram.corGaus,2,0,0,double,1
+nlme,Variogram.corGaus,3,0,0,double,1
+nlme,Variogram.corGaus,4,0,0,...,1
+nlme,Variogram.corLin,-1,0,0,"class<`Variogram`, `data.frame`>",1
+nlme,Variogram.corLin,0,0,0,"class<`corLin`, `corSpatial`, `corStruct`>",1
+nlme,Variogram.corLin,1,0,0,null,1
+nlme,Variogram.corLin,2,0,0,double,1
+nlme,Variogram.corLin,3,0,0,double,1
+nlme,Variogram.corLin,4,0,0,...,1
+nlme,Variogram.corRatio,-1,0,0,"class<`Variogram`, `data.frame`>",1
+nlme,Variogram.corRatio,0,0,0,"class<`corRatio`, `corSpatial`, `corStruct`>",1
+nlme,Variogram.corRatio,1,0,0,null,1
+nlme,Variogram.corRatio,2,0,0,double,1
+nlme,Variogram.corRatio,3,0,0,double,1
+nlme,Variogram.corRatio,4,0,0,...,1
+nlme,Variogram.corSpatial,-1,0,0,"class<`Variogram`, `data.frame`>",1
+nlme,Variogram.corSpatial,0,0,0,"class<`corExp`, `corSpatial`, `corStruct`>",1
+nlme,Variogram.corSpatial,0,0,1,"class<`corGaus`, `corSpatial`, `corStruct`>",1
+nlme,Variogram.corSpatial,0,0,2,"class<`corLin`, `corSpatial`, `corStruct`>",1
+nlme,Variogram.corSpatial,0,0,3,"class<`corRatio`, `corSpatial`, `corStruct`>",1
+nlme,Variogram.corSpatial,0,0,4,"class<`corSpatial`, `corSpher`, `corStruct`>",1
+nlme,Variogram.corSpatial,1,0,0,null,1
+nlme,Variogram.corSpatial,2,0,0,double,1
+nlme,Variogram.corSpatial,3,0,0,double,1
+nlme,Variogram.corSpatial,4,0,0,class<`function`>,1
+nlme,Variogram.corSpatial,5,0,0,...,1
+nlme,Variogram.corSpher,-1,0,0,"class<`Variogram`, `data.frame`>",1
+nlme,Variogram.corSpher,0,0,0,"class<`corSpatial`, `corSpher`, `corStruct`>",1
+nlme,Variogram.corSpher,1,0,0,null,1
+nlme,Variogram.corSpher,2,0,0,double,1
+nlme,Variogram.corSpher,3,0,0,double,1
+nlme,Variogram.corSpher,4,0,0,...,1
+nlme,Variogram.default,-1,0,0,"class<`Variogram`, `data.frame`>",1
+nlme,Variogram.default,0,0,0,double[],1
+nlme,Variogram.default,1,0,0,class<`dist`>,1
+nlme,Variogram.default,2,0,0,...,1
+nlme,Variogram.gls,-1,0,0,"class<`Variogram`, `data.frame`>",1
+nlme,Variogram.gls,0,0,0,class<`gls`>,1
+nlme,Variogram.gls,1,0,0,any,1
+nlme,Variogram.gls,2,0,0,class<`formula`>,1
+nlme,Variogram.gls,3,0,0,character[],1
+nlme,Variogram.gls,4,0,0,any,1
+nlme,Variogram.gls,5,0,0,class<`function`>,1
+nlme,Variogram.gls,6,0,0,any,1
+nlme,Variogram.gls,7,0,0,double,1
+nlme,Variogram.lme,-1,0,0,"class<`Variogram`, `data.frame`>",1
+nlme,Variogram.lme,0,0,0,class<`lme`>,1
+nlme,Variogram.lme,1,0,0,any,1
+nlme,Variogram.lme,2,0,0,class<`formula`>,1
+nlme,Variogram.lme,3,0,0,character[],1
+nlme,Variogram.lme,4,0,0,any,1
+nlme,Variogram.lme,5,0,0,class<`function`>,1
+nlme,Variogram.lme,6,0,0,any,1
+nlme,Variogram.lme,7,0,0,double,1
+nlme,varPower,-1,0,0,"class<`varFunc`, `varPower`>",1
+nlme,varPower,0,0,0,double[],1
+nlme,varPower,1,0,0,class<`formula`>,1
+nlme,varPower,2,0,0,null,1
+nlme,varWeights,-1,0,0,double[],1
+nlme,varWeights,-1,0,1,null,1
+nlme,varWeights,0,0,0,"class<`glsStruct`, `gnlsStruct`, `modelStruct`>",1
+nlme,varWeights,0,0,1,"class<`glsStruct`, `modelStruct`>",1
+nlme,varWeights,0,0,2,"class<`lmeStruct`, `lmeStructInt`, `modelStruct`>",1
+nlme,varWeights,0,0,3,"class<`lmeStruct`, `lmeStructInt`, `modelStruct`, `nlmeStruct`>",1
+nlme,varWeights,0,0,4,"class<`lmeStruct`, `modelStruct`>",1
+nlme,varWeights,0,0,5,"class<`lmeStruct`, `modelStruct`, `nlmeStruct`>",1
+nlme,varWeights,0,0,6,"class<`varFunc`, `varPower`>",1
+nlme,varWeights,0,0,7,"class<`varFunc`, `varIdent`>",1
+nlme,varWeights,0,0,8,"class<`varExp`, `varFunc`>",1
+nlme,varWeights.glsStruct,-1,0,0,double[],1
+nlme,varWeights.glsStruct,0,0,0,"class<`glsStruct`, `gnlsStruct`, `modelStruct`>",1
+nlme,varWeights.glsStruct,0,0,1,"class<`glsStruct`, `modelStruct`>",1
+nlme,varWeights.lmeStruct,-1,0,0,double[],1
+nlme,varWeights.lmeStruct,0,0,0,"class<`lmeStruct`, `lmeStructInt`, `modelStruct`>",1
+nlme,varWeights.lmeStruct,0,0,1,"class<`lmeStruct`, `lmeStructInt`, `modelStruct`, `nlmeStruct`>",1
+nlme,varWeights.lmeStruct,0,0,2,"class<`lmeStruct`, `modelStruct`>",1
+nlme,varWeights.lmeStruct,0,0,3,"class<`lmeStruct`, `modelStruct`, `nlmeStruct`>",1
+nlme,varWeights.varFunc,-1,0,0,double[],1
+nlme,varWeights.varFunc,-1,0,1,null,1
+nlme,varWeights.varFunc,0,0,0,"class<`varFunc`, `varPower`>",1
+nlme,varWeights.varFunc,0,0,1,"class<`varFunc`, `varIdent`>",1
+nlme,varWeights.varFunc,0,0,2,"class<`varExp`, `varFunc`>",1
+nloptr,auglag,-1,0,0,list<double[] | character>,1
+nloptr,auglag,0,0,0,double[],1
+nloptr,auglag,1,0,0,class<`function`>,1
+nloptr,auglag,2,0,0,null,1
+nloptr,auglag,3,0,0,null,1
+nloptr,auglag,4,0,0,null,1
+nloptr,auglag,5,0,0,class<`function`>,1
+nloptr,auglag,5,0,1,null,1
+nloptr,auglag,6,0,0,null,1
+nloptr,auglag,7,0,0,class<`function`>,1
+nloptr,auglag,8,0,0,null,1
+nloptr,auglag,9,0,0,character,1
+nloptr,auglag,10,0,0,double,1
+nloptr,auglag,11,0,0,logical,1
+nloptr,auglag,12,0,0,logical,1
+nloptr,auglag,13,0,0,list<any>,1
+nloptr,auglag,14,0,0,...,1
+nloptr,bobyqa,-1,0,0,list<double[] | character>,1
+nloptr,bobyqa,0,0,0,double[],1
+nloptr,bobyqa,1,0,0,class<`function`>,1
+nloptr,bobyqa,2,0,0,double[],1
+nloptr,bobyqa,3,0,0,double[],1
+nloptr,bobyqa,4,0,0,logical,1
+nloptr,bobyqa,5,0,0,list<any>,1
+nloptr,bobyqa,6,0,0,...,1
+nloptr,ccsaq,-1,0,0,list<double[] | character>,1
+nloptr,ccsaq,0,0,0,double[],1
+nloptr,ccsaq,1,0,0,class<`function`>,1
+nloptr,ccsaq,2,0,0,class<`function`>,1
+nloptr,ccsaq,2,0,1,null,1
+nloptr,ccsaq,3,0,0,null,1
+nloptr,ccsaq,4,0,0,null,1
+nloptr,ccsaq,5,0,0,class<`function`>,1
+nloptr,ccsaq,6,0,0,class<`function`>,1
+nloptr,ccsaq,6,0,1,null,1
+nloptr,ccsaq,7,0,0,logical,1
+nloptr,ccsaq,8,0,0,list<double>,1
+nloptr,ccsaq,9,0,0,...,1
+nloptr,check.derivatives,-1,0,0,list<class<`matrix`>>,1
+nloptr,check.derivatives,-1,0,1,list<double[]>,1
+nloptr,check.derivatives,0,0,0,double[],1
+nloptr,check.derivatives,1,0,0,class<`function`>,1
+nloptr,check.derivatives,2,0,0,class<`function`>,1
+nloptr,check.derivatives,3,0,0,double,1
+nloptr,check.derivatives,4,0,0,character,1
+nloptr,check.derivatives,5,0,0,character,1
+nloptr,check.derivatives,6,0,0,...,1
+nloptr,cobyla,-1,0,0,list<double[] | character>,1
+nloptr,cobyla,0,0,0,double[],1
+nloptr,cobyla,1,0,0,class<`function`>,1
+nloptr,cobyla,2,0,0,null,1
+nloptr,cobyla,3,0,0,null,1
+nloptr,cobyla,4,0,0,class<`function`>,1
+nloptr,cobyla,5,0,0,logical,1
+nloptr,cobyla,6,0,0,list<double>,1
+nloptr,cobyla,7,0,0,...,1
+nloptr,directL,-1,0,0,list<double[] | character>,1
+nloptr,directL,0,0,0,class<`function`>,1
+nloptr,directL,1,0,0,double[],1
+nloptr,directL,2,0,0,double[],1
+nloptr,directL,3,0,0,logical,1
+nloptr,directL,4,0,0,logical,1
+nloptr,directL,5,0,0,logical,1
+nloptr,directL,6,0,0,list<double>,1
+nloptr,directL,7,0,0,...,1
+nloptr,finite.diff,-1,0,0,class<`matrix`>,1
+nloptr,finite.diff,-1,0,1,double[],1
+nloptr,finite.diff,0,0,0,class<`function`>,1
+nloptr,finite.diff,1,0,0,double[],1
+nloptr,finite.diff,2,0,0,integer[],1
+nloptr,finite.diff,3,0,0,double,1
+nloptr,finite.diff,4,0,0,...,1
+nloptr,is.nloptr,-1,0,0,logical,1
+nloptr,is.nloptr,0,0,0,class<`nloptr`>,1
+nloptr,isres,-1,0,0,list<double[] | character>,1
+nloptr,isres,0,0,0,double[],1
+nloptr,isres,1,0,0,class<`function`>,1
+nloptr,isres,2,0,0,double[],1
+nloptr,isres,3,0,0,double[],1
+nloptr,isres,4,0,0,null,1
+nloptr,isres,5,0,0,null,1
+nloptr,isres,6,0,0,double,1
+nloptr,isres,7,0,0,double,1
+nloptr,isres,8,0,0,double,1
+nloptr,isres,9,0,0,logical,1
+nloptr,isres,10,0,0,...,1
+nloptr,lbfgs,-1,0,0,list<double[] | character>,1
+nloptr,lbfgs,0,0,0,double[],1
+nloptr,lbfgs,1,0,0,class<`function`>,1
+nloptr,lbfgs,2,0,0,null,1
+nloptr,lbfgs,3,0,0,double[],1
+nloptr,lbfgs,4,0,0,double[],1
+nloptr,lbfgs,5,0,0,logical,1
+nloptr,lbfgs,6,0,0,list<double>,1
+nloptr,lbfgs,7,0,0,...,1
+nloptr,mlsl,-1,0,0,list<double[] | character>,1
+nloptr,mlsl,0,0,0,double[],1
+nloptr,mlsl,1,0,0,class<`function`>,1
+nloptr,mlsl,2,0,0,null,1
+nloptr,mlsl,3,0,0,double[],1
+nloptr,mlsl,4,0,0,double[],1
+nloptr,mlsl,5,0,0,character,1
+nloptr,mlsl,6,0,0,logical,1
+nloptr,mlsl,7,0,0,logical,1
+nloptr,mlsl,8,0,0,list<double>,1
+nloptr,mlsl,9,0,0,...,1
+nloptr,mma,-1,0,0,list<double[] | character>,1
+nloptr,mma,0,0,0,double[],1
+nloptr,mma,1,0,0,class<`function`>,1
+nloptr,mma,2,0,0,class<`function`>,1
+nloptr,mma,2,0,1,null,1
+nloptr,mma,3,0,0,null,1
+nloptr,mma,4,0,0,null,1
+nloptr,mma,5,0,0,class<`function`>,1
+nloptr,mma,6,0,0,class<`function`>,1
+nloptr,mma,6,0,1,null,1
+nloptr,mma,7,0,0,logical,1
+nloptr,mma,8,0,0,list<double>,1
+nloptr,mma,9,0,0,...,1
+nloptr,neldermead,-1,0,0,list<double[] | character>,1
+nloptr,neldermead,0,0,0,double[],1
+nloptr,neldermead,1,0,0,class<`function`>,1
+nloptr,neldermead,2,0,0,null,1
+nloptr,neldermead,3,0,0,null,1
+nloptr,neldermead,4,0,0,logical,1
+nloptr,neldermead,5,0,0,list<any>,1
+nloptr,neldermead,6,0,0,...,1
+nloptr,newuoa,-1,0,0,list<double[] | character>,1
+nloptr,newuoa,0,0,0,double[],1
+nloptr,newuoa,1,0,0,class<`function`>,1
+nloptr,newuoa,2,0,0,logical,1
+nloptr,newuoa,3,0,0,list<any>,1
+nloptr,newuoa,4,0,0,...,1
+nloptr,nl.grad,-1,0,0,double[],1
+nloptr,nl.grad,0,0,0,double[],1
+nloptr,nl.grad,1,0,0,class<`function`>,1
+nloptr,nl.grad,2,0,0,double,1
+nloptr,nl.grad,3,0,0,...,1
+nloptr,nl.jacobian,-1,0,0,class<`matrix`>,1
+nloptr,nl.jacobian,0,0,0,double[],1
+nloptr,nl.jacobian,1,0,0,class<`function`>,1
+nloptr,nl.jacobian,2,0,0,double,1
+nloptr,nl.jacobian,3,0,0,...,1
+nloptr,nloptr,-1,0,0,class<`nloptr`>,1
+nloptr,nloptr,0,0,0,double[],1
+nloptr,nloptr,1,0,0,class<`function`>,1
+nloptr,nloptr,2,0,0,class<`function`>,1
+nloptr,nloptr,2,0,1,null,1
+nloptr,nloptr,3,0,0,double[],1
+nloptr,nloptr,3,0,1,null,1
+nloptr,nloptr,4,0,0,double[],1
+nloptr,nloptr,4,0,1,null,1
+nloptr,nloptr,5,0,0,class<`function`>,1
+nloptr,nloptr,5,0,1,null,1
+nloptr,nloptr,6,0,0,class<`function`>,1
+nloptr,nloptr,6,0,1,null,1
+nloptr,nloptr,7,0,0,null,1
+nloptr,nloptr,7,0,1,class<`function`>,1
+nloptr,nloptr,8,0,0,null,1
+nloptr,nloptr,8,0,1,class<`function`>,1
+nloptr,nloptr,9,0,0,list<any>,1
+nloptr,nloptr,10,0,0,...,1
+nloptr,nloptr.add.default.options,-1,0,0,list<character | list<character | double[]>>,1
+nloptr,nloptr.add.default.options,0,0,0,list<character | logical>,1
+nloptr,nloptr.add.default.options,0,0,1,list<character>,1
+nloptr,nloptr.add.default.options,0,0,2,list<character | double | class<`function`>>,1
+nloptr,nloptr.add.default.options,0,0,3,list<character | double>,1
+nloptr,nloptr.add.default.options,0,0,4,list<double | character>,1
+nloptr,nloptr.add.default.options,0,0,5,list<null | double | character>,1
+nloptr,nloptr.add.default.options,0,0,6,list<character | double | null>,1
+nloptr,nloptr.add.default.options,1,0,0,double[],1
+nloptr,nloptr.add.default.options,2,0,0,double,1
+nloptr,nloptr.add.default.options,3,0,0,double,1
+nloptr,nloptr.get.default.options,-1,0,0,class<`data.frame`>,1
+nloptr,nloptr.print.options,-1,0,0,null,1
+nloptr,nloptr.print.options,0,0,0,character[],1
+nloptr,nloptr.print.options,0,0,1,null,1
+nloptr,nloptr.print.options,0,0,2,list<character | double>,1
+nloptr,nloptr.print.options,1,0,0,null,1
+nloptr,nloptr.print.options,1,0,1,list<character | double>,1
+nloptr,nl.opts,-1,0,0,list<double | null>,1
+nloptr,nl.opts,-1,0,1,list<null | double>,1
+nloptr,nl.opts,0,0,0,list<any>,1
+nloptr,print.nloptr,-1,0,0,null,1
+nloptr,print.nloptr,0,0,0,class<`nloptr`>,1
+nloptr,print.nloptr,1,0,0,logical,1
+nloptr,print.nloptr,2,0,0,...,1
+nloptr,sbplx,-1,0,0,list<double[] | character>,1
+nloptr,sbplx,0,0,0,double[],1
+nloptr,sbplx,1,0,0,class<`function`>,1
+nloptr,sbplx,2,0,0,null,1
+nloptr,sbplx,3,0,0,null,1
+nloptr,sbplx,4,0,0,logical,1
+nloptr,sbplx,5,0,0,list<any>,1
+nloptr,sbplx,6,0,0,...,1
+nloptr,slsqp,-1,0,0,list<double[] | character>,1
+nloptr,slsqp,0,0,0,double[],1
+nloptr,slsqp,1,0,0,class<`function`>,1
+nloptr,slsqp,2,0,0,null,1
+nloptr,slsqp,3,0,0,null,1
+nloptr,slsqp,4,0,0,null,1
+nloptr,slsqp,5,0,0,class<`function`>,1
+nloptr,slsqp,6,0,0,class<`function`>,1
+nloptr,slsqp,6,0,1,null,1
+nloptr,slsqp,7,0,0,null,1
+nloptr,slsqp,8,0,0,null,1
+nloptr,slsqp,9,0,0,logical,1
+nloptr,slsqp,10,0,0,list<double>,1
+nloptr,slsqp,11,0,0,...,1
+nloptr,stogo,-1,0,0,list<double[] | character>,1
+nloptr,stogo,0,0,0,double[],1
+nloptr,stogo,1,0,0,class<`function`>,1
+nloptr,stogo,2,0,0,null,1
+nloptr,stogo,3,0,0,double[],1
+nloptr,stogo,4,0,0,double[],1
+nloptr,stogo,5,0,0,double,1
+nloptr,stogo,6,0,0,double,1
+nloptr,stogo,7,0,0,logical,1
+nloptr,stogo,8,0,0,logical,1
+nloptr,stogo,9,0,0,...,1
+nloptr,tnewton,-1,0,0,list<double[] | character>,1
+nloptr,tnewton,0,0,0,double[],1
+nloptr,tnewton,1,0,0,class<`function`>,1
+nloptr,tnewton,2,0,0,null,1
+nloptr,tnewton,3,0,0,double[],1
+nloptr,tnewton,4,0,0,double[],1
+nloptr,tnewton,5,0,0,logical,1
+nloptr,tnewton,6,0,0,logical,1
+nloptr,tnewton,7,0,0,logical,1
+nloptr,tnewton,8,0,0,list<double>,1
+nloptr,tnewton,9,0,0,...,1
+nloptr,varmetric,-1,0,0,list<double[] | character>,1
+nloptr,varmetric,0,0,0,double[],1
+nloptr,varmetric,1,0,0,class<`function`>,1
+nloptr,varmetric,2,0,0,null,1
+nloptr,varmetric,3,0,0,logical,1
+nloptr,varmetric,4,0,0,double[],1
+nloptr,varmetric,5,0,0,double[],1
+nloptr,varmetric,6,0,0,logical,1
+nloptr,varmetric,7,0,0,list<double>,1
+nloptr,varmetric,8,0,0,...,1
+nnls,coef.nnls,-1,0,0,double[],1
+nnls,coef.nnls,0,0,0,class<`nnls`>,1
+nnls,coef.nnls,0,0,1,class<`nnnpls`>,1
+nnls,coef.nnls,1,0,0,...,1
+nnls,coef.nnnpls,-1,0,0,double[],1
+nnls,coef.nnnpls,0,0,0,class<`nnls`>,1
+nnls,coef.nnnpls,0,0,1,class<`nnnpls`>,1
+nnls,coef.nnnpls,1,0,0,...,1
+nnls,nnls,-1,0,0,class<`nnls`>,1
+nnls,nnls,0,0,0,class<`matrix`>,1
+nnls,nnls,1,0,0,double[],1
+nnls,nnnpls,-1,0,0,class<`nnnpls`>,1
+nnls,nnnpls,0,0,0,class<`matrix`>,1
+nnls,nnnpls,1,0,0,double[],1
+nnls,nnnpls,2,0,0,double[],1
+norm,.code.to.na,-1,0,0,class<`matrix`>,1
+norm,.code.to.na,0,0,0,class<`matrix`>,1
+norm,.code.to.na,1,0,0,double,1
+norm,da.norm,-1,0,0,double[],1
+norm,da.norm,0,0,0,list<class<`matrix`> | double[]>,1
+norm,da.norm,1,0,0,double[],1
+norm,da.norm,2,0,0,any,1
+norm,da.norm,3,0,0,double,1
+norm,da.norm,4,0,0,logical,1
+norm,da.norm,5,0,0,logical,1
+norm,em.norm,-1,0,0,double[],1
+norm,em.norm,0,0,0,list<class<`matrix`> | double[]>,1
+norm,em.norm,1,0,0,any,1
+norm,em.norm,2,0,0,logical,1
+norm,em.norm,3,0,0,double,1
+norm,em.norm,4,0,0,double,1
+norm,em.norm,5,0,0,any,1
+norm,getparam.norm,-1,0,0,list<double[] | class<`matrix`>>,1
+norm,getparam.norm,0,0,0,list<class<`matrix`> | double[]>,1
+norm,getparam.norm,1,0,0,double[],1
+norm,getparam.norm,2,0,0,logical,1
+norm,imp.norm,-1,0,0,class<`matrix`>,1
+norm,imp.norm,0,0,0,list<class<`matrix`> | double[]>,1
+norm,imp.norm,1,0,0,double[],1
+norm,imp.norm,2,0,0,class<`matrix`>,1
+norm,loglik.norm,-1,0,0,double,1
+norm,loglik.norm,0,0,0,list<class<`matrix`> | double[]>,1
+norm,loglik.norm,1,0,0,double[],1
+norm,logpost.norm,-1,0,0,double,1
+norm,logpost.norm,0,0,0,list<class<`matrix`> | double[]>,1
+norm,logpost.norm,1,0,0,double[],1
+norm,logpost.norm,2,0,0,list<double[] | class<`matrix`>>,1
+norm,makeparam.norm,-1,0,0,double[],1
+norm,makeparam.norm,0,0,0,list<class<`matrix`> | double[]>,1
+norm,makeparam.norm,1,0,0,list<double[] | class<`matrix`>>,1
+norm,mda.norm,-1,0,0,double[],1
+norm,mda.norm,0,0,0,list<class<`matrix`> | double[]>,1
+norm,mda.norm,1,0,0,double[],1
+norm,mda.norm,2,0,0,double,1
+norm,mda.norm,3,0,0,logical,1
+norm,.na.to.snglcode,-1,0,0,class<`matrix`>,1
+norm,.na.to.snglcode,0,0,0,class<`matrix`>,1
+norm,.na.to.snglcode,1,0,0,double,1
+norm,ninvwish,-1,0,0,double[],1
+norm,ninvwish,0,0,0,list<class<`matrix`> | double[]>,1
+norm,ninvwish,1,0,0,list<double[] | class<`matrix`>>,1
+norm,prelim.norm,-1,0,0,list<class<`matrix`> | double[]>,1
+norm,prelim.norm,0,0,0,class<`matrix`>,1
+norm,rngseed,-1,0,0,null,1
+norm,rngseed,0,0,0,double,1
+normalp,dnormp,-1,0,0,double[],1
+normalp,dnormp,0,0,0,double[],1
+normalp,dnormp,1,0,0,double,1
+normalp,dnormp,2,0,0,double,1
+normalp,dnormp,3,0,0,double,1
+normalp,dnormp,4,0,0,logical,1
+normalp,estimatep,-1,0,0,double,1
+normalp,estimatep,0,0,0,double[],1
+normalp,estimatep,1,0,0,double,1
+normalp,estimatep,2,0,0,double,1
+normalp,estimatep,3,0,0,character[],1
+normalp,graphnp,-1,0,0,list<list<double[]>>,1
+normalp,graphnp,0,0,0,double[],1
+normalp,graphnp,1,0,0,double,1
+normalp,graphnp,2,0,0,double,1
+normalp,graphnp,3,0,0,character,1
+normalp,kurtosis,-1,0,0,double[],1
+normalp,kurtosis,0,0,0,double[],1
+normalp,kurtosis,0,0,1,null,1
+normalp,kurtosis,1,0,0,double,1
+normalp,kurtosis,2,0,0,character[],1
+normalp,lmp,-1,0,0,"class<`lm`, `lmp`>",1
+normalp,lmp,0,0,0,class<`formula`>,1
+normalp,lmp,1,0,0,any,1
+normalp,lmp,2,0,0,any,1
+normalp,lmp.default,-1,0,0,"class<`lm`, `lmp`>",1
+normalp,lmp.default,0,0,0,class<`formula`>,1
+normalp,lmp.default,1,0,0,list<any>,1
+normalp,lmp.default,2,0,0,null,1
+normalp,paramp,-1,0,0,class<`paramp`>,1
+normalp,paramp,0,0,0,double[],1
+normalp,paramp,1,0,0,any,1
+normalp,paramp.default,-1,0,0,class<`paramp`>,1
+normalp,paramp.default,0,0,0,double[],1
+normalp,paramp.default,1,0,0,null,1
+normalp,paramp.default,1,0,1,double,1
+normalp,plot.lmp,-1,0,0,list<logical>,1
+normalp,plot.lmp,0,0,0,"class<`lm`, `lmp`>",1
+normalp,plot.lmp,1,0,0,...,1
+normalp,plot.simul.lmp,-1,0,0,list<logical>,1
+normalp,plot.simul.lmp,0,0,0,"class<`simul.lmp`, `simul.mp`>",1
+normalp,plot.simul.lmp,1,0,0,...,1
+normalp,plot.simul.mp,-1,0,0,list<logical>,1
+normalp,plot.simul.mp,0,0,0,class<`simul.mp`>,1
+normalp,plot.simul.mp,1,0,0,...,1
+normalp,pnormp,-1,0,0,double[],1
+normalp,pnormp,0,0,0,double[],1
+normalp,pnormp,1,0,0,double,1
+normalp,pnormp,2,0,0,double,1
+normalp,pnormp,3,0,0,double,1
+normalp,pnormp,4,0,0,logical,1
+normalp,pnormp,5,0,0,logical,1
+normalp,qnormp,-1,0,0,double[],1
+normalp,qnormp,0,0,0,double[],1
+normalp,qnormp,1,0,0,double,1
+normalp,qnormp,2,0,0,double,1
+normalp,qnormp,3,0,0,double,1
+normalp,qnormp,4,0,0,logical,1
+normalp,qnormp,5,0,0,logical,1
+normalp,qqlinep,-1,0,0,null,1
+normalp,qqlinep,0,0,0,double[],1
+normalp,qqlinep,1,0,0,double,1
+normalp,qqlinep,2,0,0,...,1
+normalp,qqnormp,-1,0,0,list<double[]>,1
+normalp,qqnormp,0,0,0,double[],1
+normalp,qqnormp,1,0,0,any,1
+normalp,qqnormp,2,0,0,double,1
+normalp,qqnormp,3,0,0,any,1
+normalp,qqnormp,4,0,0,any,1
+normalp,qqnormp,5,0,0,any,1
+normalp,qqnormp,6,0,0,...,1
+normalp,qqnormp.default,-1,0,0,list<double[]>,1
+normalp,qqnormp.default,0,0,0,double[],1
+normalp,qqnormp.default,1,0,0,any,1
+normalp,qqnormp.default,2,0,0,double,1
+normalp,qqnormp.default,3,0,0,character,1
+normalp,qqnormp.default,4,0,0,character,1
+normalp,qqnormp.default,5,0,0,character,1
+normalp,qqnormp.default,6,0,0,...,1
+normalp,rnormp,-1,0,0,double[],1
+normalp,rnormp,0,0,0,double,1
+normalp,rnormp,1,0,0,double,1
+normalp,rnormp,2,0,0,double,1
+normalp,rnormp,3,0,0,double,1
+normalp,rnormp,4,0,0,character[],1
+normalp,simul.lmp,-1,0,0,"class<`simul.lmp`, `simul.mp`>",1
+normalp,simul.lmp,0,0,0,double,1
+normalp,simul.lmp,1,0,0,double,1
+normalp,simul.lmp,2,0,0,double,1
+normalp,simul.lmp,3,0,0,double[],1
+normalp,simul.lmp,4,0,0,double,1
+normalp,simul.lmp,5,0,0,double,1
+normalp,simul.lmp,6,0,0,double,1
+normalp,simul.lmp,7,0,0,logical,1
+normalp,simul.mp,-1,0,0,class<`simul.mp`>,1
+normalp,simul.mp,0,0,0,double,1
+normalp,simul.mp,1,0,0,double,1
+normalp,simul.mp,2,0,0,double,1
+normalp,simul.mp,3,0,0,double,1
+normalp,simul.mp,4,0,0,double,1
+normalp,summary.lmp,-1,0,0,class<`summary.lmp`>,1
+normalp,summary.lmp,0,0,0,"class<`lm`, `lmp`>",1
+normalp,summary.lmp,1,0,0,...,1
+normalp,summary.simul.lmp,-1,0,0,class<`summary.simul.lmp`>,1
+normalp,summary.simul.lmp,0,0,0,"class<`simul.lmp`, `simul.mp`>",1
+normalp,summary.simul.lmp,1,0,0,...,1
+nortest,ad.test,-1,0,0,class<`htest`>,1
+nortest,ad.test,0,0,0,double[],1
+nortest,cvm.test,-1,0,0,class<`htest`>,1
+nortest,cvm.test,0,0,0,double[],1
+nortest,lillie.test,-1,0,0,class<`htest`>,1
+nortest,lillie.test,0,0,0,double[],1
+nortest,pearson.test,-1,0,0,class<`htest`>,1
+nortest,pearson.test,0,0,0,double[],1
+nortest,pearson.test,1,0,0,double,1
+nortest,pearson.test,2,0,0,logical,1
+nortest,sf.test,-1,0,0,class<`htest`>,1
+nortest,sf.test,0,0,0,double[],1
+numDeriv,genD,-1,0,0,class<`Darray`>,1
+numDeriv,genD,0,0,0,class<`function`>,1
+numDeriv,genD,1,0,0,double[],1
+numDeriv,genD,2,0,0,character,1
+numDeriv,genD,3,0,0,any,1
+numDeriv,genD,4,0,0,...,1
+numDeriv,genD.default,-1,0,0,class<`Darray`>,1
+numDeriv,genD.default,0,0,0,class<`function`>,1
+numDeriv,genD.default,1,0,0,double[],1
+numDeriv,genD.default,2,0,0,character,1
+numDeriv,genD.default,3,0,0,list<any>,1
+numDeriv,genD.default,4,0,0,...,1
+numDeriv,grad,-1,0,0,^double[],1
+numDeriv,grad,-1,0,1,null,1
+numDeriv,grad,0,0,0,class<`function`>,1
+numDeriv,grad,1,0,0,double[],1
+numDeriv,grad,2,0,0,character,1
+numDeriv,grad,3,0,0,^double[],1
+numDeriv,grad,3,0,1,null,1
+numDeriv,grad,4,0,0,any,1
+numDeriv,grad,5,0,0,...,1
+numDeriv,grad.default,-1,0,0,^double[],1
+numDeriv,grad.default,-1,0,1,null,1
+numDeriv,grad.default,0,0,0,class<`function`>,1
+numDeriv,grad.default,1,0,0,double[],1
+numDeriv,grad.default,2,0,0,character,1
+numDeriv,grad.default,3,0,0,^double[],1
+numDeriv,grad.default,3,0,1,null,1
+numDeriv,grad.default,4,0,0,any,1
+numDeriv,grad.default,5,0,0,...,1
+numDeriv,hessian,-1,0,0,class<`matrix`>,1
+numDeriv,hessian,0,0,0,class<`function`>,1
+numDeriv,hessian,1,0,0,double[],1
+numDeriv,hessian,2,0,0,character,1
+numDeriv,hessian,3,0,0,any,1
+numDeriv,hessian,4,0,0,...,1
+numDeriv,hessian.default,-1,0,0,class<`matrix`>,1
+numDeriv,hessian.default,0,0,0,class<`function`>,1
+numDeriv,hessian.default,1,0,0,double[],1
+numDeriv,hessian.default,2,0,0,character,1
+numDeriv,hessian.default,3,0,0,list<any>,1
+numDeriv,hessian.default,4,0,0,...,1
+numDeriv,jacobian,-1,0,0,class<`matrix`>,1
+numDeriv,jacobian,0,0,0,class<`function`>,1
+numDeriv,jacobian,1,0,0,double[],1
+numDeriv,jacobian,2,0,0,character,1
+numDeriv,jacobian,3,0,0,null,1
+numDeriv,jacobian,3,0,1,double,1
+numDeriv,jacobian,4,0,0,any,1
+numDeriv,jacobian,5,0,0,...,1
+numDeriv,jacobian.default,-1,0,0,class<`matrix`>,1
+numDeriv,jacobian.default,0,0,0,class<`function`>,1
+numDeriv,jacobian.default,1,0,0,double[],1
+numDeriv,jacobian.default,2,0,0,character,1
+numDeriv,jacobian.default,3,0,0,null,1
+numDeriv,jacobian.default,3,0,1,double,1
+numDeriv,jacobian.default,4,0,0,any,1
+numDeriv,jacobian.default,5,0,0,...,1
+numbers,agm,-1,0,0,double,1
+numbers,agm,0,0,0,double,1
+numbers,agm,1,0,0,double,1
+numbers,atkin_sieve,-1,0,0,integer[],1
+numbers,atkin_sieve,0,0,0,double,1
+numbers,bracelet,-1,0,0,double,1
+numbers,bracelet,0,0,0,double,1
+numbers,bracelet,1,0,0,double,1
+numbers,catalan,-1,0,0,double,1
+numbers,catalan,0,0,0,integer,1
+numbers,cf2num,-1,0,0,double,1
+numbers,cf2num,0,0,0,double[],1
+numbers,cf2num,1,0,0,double[],1
+numbers,cf2num,2,0,0,double,1
+numbers,cf2num,3,0,0,logical,1
+numbers,chinese,-1,0,0,double,1
+numbers,chinese,0,0,0,double[],1
+numbers,chinese,1,0,0,double[],1
+numbers,collatz,-1,0,0,double[],1
+numbers,collatz,0,0,0,double,1
+numbers,collatz,1,0,0,double,1
+numbers,collatz,2,0,0,double,1
+numbers,collatz,3,0,0,logical,1
+numbers,collatz,4,0,0,logical,1
+numbers,contFrac,-1,0,0,double,1
+numbers,contFrac,-1,0,1,list<double[]>,1
+numbers,contFrac,0,0,0,double[],1
+numbers,contFrac,1,0,0,double,1
+numbers,coprime,-1,0,0,logical,1
+numbers,coprime,0,0,0,double,1
+numbers,coprime,1,0,0,double,1
+numbers,div,-1,0,0,double[],1
+numbers,div,0,0,0,double[],1
+numbers,div,1,0,0,double[],1
+numbers,divisors,-1,0,0,double[],1
+numbers,divisors,0,0,0,double,1
+numbers,dropletE,-1,0,0,character,1
+numbers,dropletE,0,0,0,double,1
+numbers,dropletPi,-1,0,0,character,1
+numbers,dropletPi,0,0,0,double,1
+numbers,egyptian_complete,-1,0,0,double,1
+numbers,egyptian_complete,0,0,0,double,1
+numbers,egyptian_complete,1,0,0,double,1
+numbers,egyptian_complete,2,0,0,logical,1
+numbers,egyptian_methods,-1,0,0,null,1
+numbers,egyptian_methods,0,0,0,double,1
+numbers,egyptian_methods,1,0,0,double,1
+numbers,eulersPhi,-1,0,0,double,1
+numbers,eulersPhi,0,0,0,double,1
+numbers,extGCD,-1,0,0,double[],1
+numbers,extGCD,0,0,0,double,1
+numbers,extGCD,1,0,0,double,1
+numbers,fibonacci,-1,0,0,double[],1
+numbers,fibonacci,0,0,0,double,1
+numbers,fibonacci,1,0,0,logical,1
+numbers,GCD,-1,0,0,double,1
+numbers,GCD,0,0,0,double,1
+numbers,GCD,1,0,0,double,1
+numbers,hermiteNF,-1,0,0,list<class<`matrix`>>,1
+numbers,hermiteNF,0,0,0,class<`matrix`>,1
+numbers,iNthroot,-1,0,0,double,1
+numbers,iNthroot,0,0,0,double,1
+numbers,iNthroot,1,0,0,double,1
+numbers,isIntpower,-1,0,0,double[],1
+numbers,isIntpower,0,0,0,double,1
+numbers,isNatural,-1,0,0,logical[],1
+numbers,isNatural,0,0,0,double[],1
+numbers,isPrime,-1,0,0,class<`matrix`>,1
+numbers,isPrime,-1,0,1,logical[],1
+numbers,isPrime,0,0,0,class<`matrix`>,1
+numbers,isPrime,0,0,1,double[],1
+numbers,isPrimroot,-1,0,0,logical,1
+numbers,isPrimroot,0,0,0,double,1
+numbers,isPrimroot,1,0,0,double,1
+numbers,jacobi_sym,-1,0,0,double,1
+numbers,jacobi_sym,0,0,0,double,1
+numbers,jacobi_sym,1,0,0,double,1
+numbers,LCM,-1,0,0,double,1
+numbers,LCM,0,0,0,double,1
+numbers,LCM,1,0,0,double,1
+numbers,legendre_sym,-1,0,0,double,1
+numbers,legendre_sym,0,0,0,double,1
+numbers,legendre_sym,1,0,0,double,1
+numbers,lucas,-1,0,0,double,1
+numbers,lucas,0,0,0,double,1
+numbers,mersenne,-1,0,0,logical,1
+numbers,mersenne,0,0,0,double,1
+numbers,mGCD,-1,0,0,double,1
+numbers,mGCD,0,0,0,double[],1
+numbers,miller_rabin,-1,0,0,logical,1
+numbers,miller_rabin,0,0,0,double,1
+numbers,mLCM,-1,0,0,double,1
+numbers,mLCM,0,0,0,double[],1
+numbers,mod,-1,0,0,double[],1
+numbers,mod,0,0,0,double[],1
+numbers,mod,1,0,0,double,1
+numbers,modinv,-1,0,0,double,1
+numbers,modinv,0,0,0,double,1
+numbers,modinv,1,0,0,double,1
+numbers,modlin,-1,0,0,double[],1
+numbers,modlin,-1,0,1,null,1
+numbers,modlin,0,0,0,double,1
+numbers,modlin,1,0,0,double,1
+numbers,modlin,2,0,0,double,1
+numbers,modlog,-1,0,0,double,1
+numbers,modlog,0,0,0,double,1
+numbers,modlog,1,0,0,double,1
+numbers,modlog,2,0,0,double,1
+numbers,modorder,-1,0,0,double,1
+numbers,modorder,0,0,0,double,1
+numbers,modorder,1,0,0,double,1
+numbers,modpower,-1,0,0,double,1
+numbers,modpower,0,0,0,double,1
+numbers,modpower,1,0,0,double,1
+numbers,modpower,2,0,0,double,1
+numbers,modsqrt,-1,0,0,double,1
+numbers,modsqrt,0,0,0,double,1
+numbers,modsqrt,1,0,0,double,1
+numbers,necklace,-1,0,0,double,1
+numbers,necklace,0,0,0,double,1
+numbers,necklace,1,0,0,double,1
+numbers,nextPrime,-1,0,0,double,1
+numbers,nextPrime,0,0,0,double,1
+numbers,omega,-1,0,0,double,1
+numbers,omega,0,0,0,double,1
+numbers,Omega,-1,0,0,double,1
+numbers,Omega,0,0,0,double,1
+numbers,ordpn,-1,0,0,double,1
+numbers,ordpn,0,0,0,double,1
+numbers,ordpn,1,0,0,double,1
+numbers,previousPrime,-1,0,0,double,1
+numbers,previousPrime,0,0,0,double,1
+numbers,primeFactors,-1,0,0,double[],1
+numbers,primeFactors,0,0,0,double,1
+numbers,Primes,-1,0,0,double[],1
+numbers,Primes,0,0,0,double,1
+numbers,Primes,1,0,0,null,1
+numbers,Primes,1,0,1,double,1
+numbers,primeSieve,-1,0,0,double[],1
+numbers,primeSieve,0,0,0,double,1
+numbers,primroot,-1,0,0,double,1
+numbers,primroot,0,0,0,double,1
+numbers,primroot,1,0,0,logical,1
+numbers,pythagorean_triples,-1,0,0,class<`matrix`>,1
+numbers,pythagorean_triples,0,0,0,double,1
+numbers,pythagorean_triples,1,0,0,double,1
+numbers,quadratic_residues,-1,0,0,double[],1
+numbers,quadratic_residues,0,0,0,double,1
+numbers,radical,-1,0,0,double,1
+numbers,radical,0,0,0,double,1
+numbers,ratFarey,-1,0,0,double[],1
+numbers,ratFarey,0,0,0,double,1
+numbers,ratFarey,1,0,0,double,1
+numbers,ratFarey,2,0,0,logical,1
+numbers,rem,-1,0,0,double[],1
+numbers,rem,0,0,0,integer[],1
+numbers,rem,0,0,1,double,1
+numbers,rem,1,0,0,double,1
+numbers,twinPrimes,-1,0,0,class<`matrix`>,1
+numbers,twinPrimes,0,0,0,double,1
+numbers,twinPrimes,1,0,0,double,1
+numbers,zeck,-1,0,0,list<double[]>,1
+numbers,zeck,0,0,0,double,1
+officer,absolute_path,-1,0,0,character,1
+officer,absolute_path,0,0,0,character,1
+officer,add_sheet,-1,0,0,class<`rxlsx`>,1
+officer,add_sheet,0,0,0,class<`rxlsx`>,1
+officer,add_sheet,1,0,0,character,1
+officer,add_slide,-1,0,0,class<`rpptx`>,1
+officer,add_slide,0,0,0,class<`rpptx`>,1
+officer,add_slide,1,0,0,character,1
+officer,add_slide,2,0,0,character,1
+officer,annotate_base,-1,0,0,class<`rpptx`>,1
+officer,annotate_base,0,0,0,null,1
+officer,annotate_base,1,0,0,character,1
+officer,as_ph_location,-1,0,0,list<double | character>,1
+officer,as_ph_location,-1,0,1,list<double | character | null>,1
+officer,as_ph_location,0,0,0,class<`data.frame`>,1
+officer,as_ph_location,1,0,0,...,1
+officer,as_xpath_content_sel,-1,0,0,character,1
+officer,as_xpath_content_sel,0,0,0,character,1
+officer,attr_chunk,-1,0,0,character,1
+officer,attr_chunk,0,0,0,character,1
+officer,a_xfrm_str,-1,0,0,character,1
+officer,a_xfrm_str,0,0,0,double,1
+officer,a_xfrm_str,1,0,0,double,1
+officer,a_xfrm_str,2,0,0,double,1
+officer,a_xfrm_str,3,0,0,double,1
+officer,a_xfrm_str,4,0,0,double,1
+officer,a_xfrm_str,4,0,1,null,1
+officer,between,-1,0,0,logical,1
+officer,between,0,0,0,double,1
+officer,between,1,0,0,double,1
+officer,between,2,0,0,integer,1
+officer,block_caption,-1,0,0,"class<`block`, `block_caption`>",1
+officer,block_caption,0,0,0,character,1
+officer,block_caption,1,0,0,character,1
+officer,block_caption,2,0,0,character,1
+officer,block_caption,3,0,0,"class<`run`, `run_autonum`>",1
+officer,block_list,-1,0,0,class<`block_list`>,1
+officer,block_list,0,0,0,...,1
+officer,block_table,-1,0,0,"class<`block`, `block_table`>",1
+officer,block_table,0,0,0,class<`data.frame`>,1
+officer,block_table,1,0,0,character,1
+officer,block_table,1,0,1,null,1
+officer,block_table,2,0,0,logical,1
+officer,block_table,3,0,0,logical,1
+officer,block_table,4,0,0,logical,1
+officer,block_table,5,0,0,logical,1
+officer,block_table,6,0,0,logical,1
+officer,block_table,7,0,0,logical,1
+officer,block_toc,-1,0,0,"class<`block`, `block_toc`>",1
+officer,block_toc,0,0,0,double,1
+officer,block_toc,1,0,0,character,1
+officer,block_toc,1,0,1,null,1
+officer,block_toc,2,0,0,character,1
+officer,body_add,-1,0,0,class<`rdocx`>,1
+officer,body_add,0,0,0,class<`rdocx`>,1
+officer,body_add,1,0,0,character[],1
+officer,body_add,1,0,1,"class<`block`, `block_caption`>",1
+officer,body_add,1,0,2,"class<`block`, `block_toc`>",1
+officer,body_add,1,0,3,class<`block_list`>,1
+officer,body_add,1,0,4,"class<`cot`, `external_img`>",1
+officer,body_add,1,0,5,class<`data.frame`>,1
+officer,body_add,1,0,6,class<`fpar`>,1
+officer,body_add,1,0,7,"class<`gg`, `ggplot`>",1
+officer,body_add,1,0,8,class<`plot_instr`>,1
+officer,body_add,2,0,0,...,1
+officer,body_add.block_caption,-1,0,0,class<`rdocx`>,1
+officer,body_add.block_caption,0,0,0,class<`rdocx`>,1
+officer,body_add.block_caption,1,0,0,"class<`block`, `block_caption`>",1
+officer,body_add.block_caption,1,0,1,"class<`block`, `block_toc`>",1
+officer,body_add.block_caption,2,0,0,...,1
+officer,body_add.block_list,-1,0,0,class<`rdocx`>,1
+officer,body_add.block_list,0,0,0,class<`rdocx`>,1
+officer,body_add.block_list,1,0,0,class<`block_list`>,1
+officer,body_add.block_list,2,0,0,...,1
+officer,body_add_blocks,-1,0,0,class<`rdocx`>,1
+officer,body_add_blocks,0,0,0,class<`rdocx`>,1
+officer,body_add_blocks,1,0,0,class<`block_list`>,1
+officer,body_add_blocks,2,0,0,character,1
+officer,body_add.block_toc,-1,0,0,class<`rdocx`>,1
+officer,body_add.block_toc,0,0,0,class<`rdocx`>,1
+officer,body_add.block_toc,1,0,0,"class<`block`, `block_caption`>",1
+officer,body_add.block_toc,1,0,1,"class<`block`, `block_toc`>",1
+officer,body_add.block_toc,2,0,0,...,1
+officer,body_add_break,-1,0,0,class<`rdocx`>,1
+officer,body_add_break,0,0,0,class<`rdocx`>,1
+officer,body_add_break,1,0,0,character,1
+officer,body_add.character,-1,0,0,class<`rdocx`>,1
+officer,body_add.character,0,0,0,class<`rdocx`>,1
+officer,body_add.character,1,0,0,character[],1
+officer,body_add.character,2,0,0,character,1
+officer,body_add.character,3,0,0,...,1
+officer,body_add.data.frame,-1,0,0,class<`rdocx`>,1
+officer,body_add.data.frame,0,0,0,class<`rdocx`>,1
+officer,body_add.data.frame,1,0,0,class<`data.frame`>,1
+officer,body_add.data.frame,2,0,0,character,1
+officer,body_add.data.frame,3,0,0,logical,1
+officer,body_add.data.frame,4,0,0,logical,1
+officer,body_add.data.frame,5,0,0,logical,1
+officer,body_add.data.frame,6,0,0,logical,1
+officer,body_add.data.frame,7,0,0,logical,1
+officer,body_add_docx,-1,0,0,class<`rdocx`>,1
+officer,body_add_docx,0,0,0,class<`rdocx`>,1
+officer,body_add_docx,1,0,0,character,1
+officer,body_add_docx,2,0,0,character,1
+officer,body_add.external_img,-1,0,0,class<`rdocx`>,1
+officer,body_add.external_img,0,0,0,class<`rdocx`>,1
+officer,body_add.external_img,1,0,0,"class<`cot`, `external_img`>",1
+officer,body_add.external_img,2,0,0,character,1
+officer,body_add.external_img,3,0,0,...,1
+officer,body_add_fpar,-1,0,0,class<`rdocx`>,1
+officer,body_add_fpar,0,0,0,class<`rdocx`>,1
+officer,body_add_fpar,1,0,0,class<`fpar`>,1
+officer,body_add_fpar,2,0,0,null,1
+officer,body_add_fpar,3,0,0,character,1
+officer,body_add.fpar,-1,0,0,class<`rdocx`>,1
+officer,body_add.fpar,0,0,0,class<`rdocx`>,1
+officer,body_add.fpar,1,0,0,class<`fpar`>,1
+officer,body_add.fpar,2,0,0,null,1
+officer,body_add.fpar,3,0,0,...,1
+officer,body_add_gg,-1,0,0,class<`rdocx`>,1
+officer,body_add_gg,0,0,0,class<`rdocx`>,1
+officer,body_add_gg,1,0,0,"class<`gg`, `ggplot`>",1
+officer,body_add_gg,2,0,0,double,1
+officer,body_add_gg,3,0,0,double,1
+officer,body_add_gg,4,0,0,double,1
+officer,body_add_gg,5,0,0,character,1
+officer,body_add_gg,6,0,0,...,1
+officer,body_add.gg,-1,0,0,class<`rdocx`>,1
+officer,body_add.gg,0,0,0,class<`rdocx`>,1
+officer,body_add.gg,1,0,0,"class<`gg`, `ggplot`>",1
+officer,body_add.gg,2,0,0,double,1
+officer,body_add.gg,3,0,0,double,1
+officer,body_add.gg,4,0,0,double,1
+officer,body_add.gg,5,0,0,character,1
+officer,body_add.gg,6,0,0,...,1
+officer,body_add_img,-1,0,0,class<`rdocx`>,1
+officer,body_add_img,0,0,0,class<`rdocx`>,1
+officer,body_add_img,1,0,0,character,1
+officer,body_add_img,2,0,0,null,1
+officer,body_add_img,3,0,0,double,1
+officer,body_add_img,4,0,0,double,1
+officer,body_add_img,5,0,0,character,1
+officer,body_add_par,-1,0,0,class<`rdocx`>,1
+officer,body_add_par,0,0,0,class<`rdocx`>,1
+officer,body_add_par,1,0,0,character,1
+officer,body_add_par,2,0,0,character,1
+officer,body_add_par,2,0,1,null,1
+officer,body_add_par,3,0,0,character,1
+officer,body_add.plot_instr,-1,0,0,class<`rdocx`>,1
+officer,body_add.plot_instr,0,0,0,class<`rdocx`>,1
+officer,body_add.plot_instr,1,0,0,class<`plot_instr`>,1
+officer,body_add.plot_instr,2,0,0,double,1
+officer,body_add.plot_instr,3,0,0,double,1
+officer,body_add.plot_instr,4,0,0,double,1
+officer,body_add.plot_instr,5,0,0,character,1
+officer,body_add.plot_instr,6,0,0,...,1
+officer,body_add_table,-1,0,0,class<`rdocx`>,1
+officer,body_add_table,0,0,0,class<`rdocx`>,1
+officer,body_add_table,1,0,0,class<`data.frame`>,1
+officer,body_add_table,2,0,0,character,1
+officer,body_add_table,3,0,0,character,1
+officer,body_add_table,4,0,0,logical,1
+officer,body_add_table,5,0,0,logical,1
+officer,body_add_table,6,0,0,logical,1
+officer,body_add_table,7,0,0,logical,1
+officer,body_add_toc,-1,0,0,class<`rdocx`>,1
+officer,body_add_toc,0,0,0,class<`rdocx`>,1
+officer,body_add_toc,1,0,0,double,1
+officer,body_add_toc,2,0,0,character,1
+officer,body_add_toc,3,0,0,null,1
+officer,body_add_toc,4,0,0,character,1
+officer,body_add_xml,-1,0,0,class<`rdocx`>,1
+officer,body_add_xml,0,0,0,class<`rdocx`>,1
+officer,body_add_xml,1,0,0,character,1
+officer,body_add_xml,2,0,0,character,1
+officer,body_add_xml2,-1,0,0,class<`rdocx`>,1
+officer,body_add_xml2,0,0,0,class<`rdocx`>,1
+officer,body_add_xml2,1,0,0,character,1
+officer,body_bookmark,-1,0,0,class<`rdocx`>,1
+officer,body_bookmark,0,0,0,class<`rdocx`>,1
+officer,body_bookmark,1,0,0,character,1
+officer,body_default_section,-1,0,0,class<`rdocx`>,1
+officer,body_default_section,0,0,0,class<`rdocx`>,1
+officer,body_default_section,1,0,0,logical,1
+officer,body_default_section,2,0,0,double[],1
+officer,body_end_section,-1,0,0,class<`rdocx`>,1
+officer,body_end_section,0,0,0,class<`rdocx`>,1
+officer,body_end_section,1,0,0,logical,1
+officer,body_end_section,2,0,0,^logical[],1
+officer,body_end_section,3,0,0,double[],1
+officer,body_end_section,4,0,0,double,1
+officer,body_end_section,5,0,0,logical,1
+officer,body_end_section,6,0,0,logical,1
+officer,body_end_section_columns,-1,0,0,class<`rdocx`>,1
+officer,body_end_section_columns,0,0,0,class<`rdocx`>,1
+officer,body_end_section_columns,1,0,0,double[],1
+officer,body_end_section_columns,2,0,0,double,1
+officer,body_end_section_columns,3,0,0,logical,1
+officer,body_end_section_columns_landscape,-1,0,0,class<`rdocx`>,1
+officer,body_end_section_columns_landscape,0,0,0,class<`rdocx`>,1
+officer,body_end_section_columns_landscape,1,0,0,double[],1
+officer,body_end_section_columns_landscape,2,0,0,double,1
+officer,body_end_section_columns_landscape,3,0,0,logical,1
+officer,body_end_section_columns_landscape,4,0,0,double,1
+officer,body_end_section_columns_landscape,5,0,0,double,1
+officer,body_end_section_continuous,-1,0,0,class<`rdocx`>,1
+officer,body_end_section_continuous,0,0,0,class<`rdocx`>,1
+officer,body_end_section_landscape,-1,0,0,class<`rdocx`>,1
+officer,body_end_section_landscape,0,0,0,class<`rdocx`>,1
+officer,body_end_section_landscape,1,0,0,double,1
+officer,body_end_section_landscape,2,0,0,double,1
+officer,body_remove,-1,0,0,class<`rdocx`>,1
+officer,body_remove,0,0,0,class<`rdocx`>,1
+officer,body_replace_all_text,-1,0,0,class<`rdocx`>,1
+officer,body_replace_all_text,0,0,0,class<`rdocx`>,1
+officer,body_replace_all_text,1,0,0,character,1
+officer,body_replace_all_text,2,0,0,character,1
+officer,body_replace_all_text,3,0,0,logical,1
+officer,body_replace_all_text,4,0,0,logical,1
+officer,body_replace_all_text,5,0,0,...,1
+officer,body_replace_text_at_bkm,-1,0,0,class<`rdocx`>,1
+officer,body_replace_text_at_bkm,0,0,0,class<`rdocx`>,1
+officer,body_replace_text_at_bkm,1,0,0,character,1
+officer,body_replace_text_at_bkm,2,0,0,character,1
+officer,bookmark,-1,0,0,character,1
+officer,bookmark,0,0,0,character,1
+officer,bookmark,1,0,0,character,1
+officer,border_wml,-1,0,0,character,1
+officer,border_wml,0,0,0,class<`fp_border`>,1
+officer,border_wml,1,0,0,character,1
+officer,change_styles,-1,0,0,class<`rdocx`>,1
+officer,change_styles,0,0,0,class<`rdocx`>,1
+officer,change_styles,1,0,0,list<character[]>,1
+officer,characterise_df,-1,0,0,class<`data.frame`>,1
+officer,characterise_df,0,0,0,class<`data.frame`>,1
+officer,check_set_bool,-1,0,0,list<double>,1
+officer,check_set_bool,0,0,0,list<double>,1
+officer,check_set_bool,1,0,0,logical,1
+officer,check_set_choice,-1,0,0,class<`fp_border`>,1
+officer,check_set_choice,-1,0,1,list<class<`fp_border`> | character>,1
+officer,check_set_choice,-1,0,2,list<double | character>,1
+officer,check_set_choice,-1,0,3,list<character>,1
+officer,check_set_choice,0,0,0,class<`fp_border`>,1
+officer,check_set_choice,0,0,1,list<class<`fp_border`> | character>,1
+officer,check_set_choice,0,0,2,list<double | character>,1
+officer,check_set_choice,0,0,3,list<character>,1
+officer,check_set_choice,1,0,0,character,1
+officer,check_set_choice,2,0,0,character[],1
+officer,check_set_chr,-1,0,0,list<double | character>,1
+officer,check_set_chr,0,0,0,list<double | character>,1
+officer,check_set_chr,1,0,0,character,1
+officer,check_set_color,-1,0,0,class<`fp_text`>,1
+officer,check_set_color,-1,0,1,list<class<`fp_border`> | character>,1
+officer,check_set_color,-1,0,2,list<double | character>,1
+officer,check_set_color,-1,0,3,list<character>,1
+officer,check_set_color,0,0,0,class<`fp_text`>,1
+officer,check_set_color,0,0,1,list<any>,1
+officer,check_set_color,1,0,0,character,1
+officer,check_set_integer,-1,0,0,class<`fp_border`>,1
+officer,check_set_integer,-1,0,1,class<`fp_cell`>,1
+officer,check_set_integer,-1,0,2,class<`fp_par`>,1
+officer,check_set_integer,0,0,0,class<`fp_border`>,1
+officer,check_set_integer,0,0,1,class<`fp_cell`>,1
+officer,check_set_integer,0,0,2,class<`fp_par`>,1
+officer,check_set_integer,1,0,0,double,1
+officer,check_set_numeric,-1,0,0,list<double>,1
+officer,check_set_numeric,0,0,0,list<any>,1
+officer,check_set_numeric,1,0,0,double,1
+officer,check_spread_border,-1,0,0,list<class<`fp_border`>>,1
+officer,check_spread_border,-1,0,1,list<character | integer | class<`fp_border`>>,1
+officer,check_spread_border,0,0,0,list<any>,1
+officer,check_spread_border,1,0,0,class<`fp_border`>,1
+officer,check_spread_border,2,0,0,character[],1
+officer,check_spread_integer,-1,0,0,list<class<`fp_border`> | character | integer>,1
+officer,check_spread_integer,-1,0,1,list<character | integer>,1
+officer,check_spread_integer,0,0,0,list<class<`fp_border`> | character>,1
+officer,check_spread_integer,0,0,1,list<character>,1
+officer,check_spread_integer,1,0,0,double,1
+officer,check_spread_integer,2,0,0,character[],1
+officer,colalpha,-1,0,0,double,1
+officer,colalpha,0,0,0,character,1
+officer,color_scheme,-1,0,0,class<`data.frame`>,1
+officer,color_scheme,0,0,0,class<`rpptx`>,1
+officer,[<-.core_properties,-1,0,0,class<`core_properties`>,1
+officer,[<-.core_properties,0,0,0,class<`core_properties`>,1
+officer,[<-.core_properties,1,0,0,character,1
+officer,[<-.core_properties,2,0,0,character,1
+officer,[<-.core_properties,3,0,0,character,1
+officer,[.core_properties,-1,0,0,character[],1
+officer,[.core_properties,0,0,0,class<`core_properties`>,1
+officer,[.core_properties,1,0,0,any,1
+officer,[.core_properties,2,0,0,character,1
+officer,cursor_backward,-1,0,0,class<`rdocx`>,1
+officer,cursor_backward,0,0,0,class<`rdocx`>,1
+officer,cursor_begin,-1,0,0,class<`rdocx`>,1
+officer,cursor_begin,0,0,0,class<`rdocx`>,1
+officer,cursor_bookmark,-1,0,0,class<`rdocx`>,1
+officer,cursor_bookmark,0,0,0,class<`rdocx`>,1
+officer,cursor_bookmark,1,0,0,character,1
+officer,cursor_end,-1,0,0,class<`rdocx`>,1
+officer,cursor_end,0,0,0,class<`rdocx`>,1
+officer,cursor_forward,-1,0,0,class<`rdocx`>,1
+officer,cursor_forward,0,0,0,class<`rdocx`>,1
+officer,cursor_reach,-1,0,0,class<`rdocx`>,1
+officer,cursor_reach,0,0,0,class<`rdocx`>,1
+officer,cursor_reach,1,0,0,character,1
+officer,doc_properties,-1,0,0,class<`data.frame`>,1
+officer,doc_properties,0,0,0,class<`rdocx`>,1
+officer,docx_body_relationship,-1,0,0,"class<`R6`, `relationship`>",1
+officer,docx_body_relationship,0,0,0,class<`rdocx`>,1
+officer,docx_body_xml,-1,0,0,"class<`xml_document`, `xml_node`>",1
+officer,docx_body_xml,0,0,0,class<`rdocx`>,1
+officer,docx_bookmarks,-1,0,0,character[],1
+officer,docx_bookmarks,0,0,0,class<`rdocx`>,1
+officer,docx_dim,-1,0,0,list<double[]>,1
+officer,docx_dim,0,0,0,class<`rdocx`>,1
+officer,docxpart_replace_img_at_bkm,-1,0,0,class<`rdocx`>,1
+officer,docxpart_replace_img_at_bkm,0,0,0,class<`rdocx`>,1
+officer,docxpart_replace_img_at_bkm,1,0,0,character,1
+officer,docxpart_replace_img_at_bkm,2,0,0,"class<`cot`, `external_img`>",1
+officer,docxpart_replace_img_at_bkm,3,0,0,character,1
+officer,docx_reference_img,-1,0,0,class<`rdocx`>,1
+officer,docx_reference_img,0,0,0,class<`rdocx`>,1
+officer,docx_reference_img,1,0,0,character[],1
+officer,docx_show_chunk,-1,0,0,class<`rdocx`>,1
+officer,docx_show_chunk,0,0,0,class<`rdocx`>,1
+officer,docx_summary,-1,0,0,class<`data.frame`>,1
+officer,docx_summary,0,0,0,class<`rdocx`>,1
+officer,docxtable_as_tibble,-1,0,0,class<`data.frame`>,1
+officer,docxtable_as_tibble,0,0,0,class<`xml_node`>,1
+officer,docxtable_as_tibble,1,0,0,class<`data.frame`>,1
+officer,embed_img_raster,-1,0,0,class<`data.frame`>,1
+officer,embed_img_raster,0,0,0,class<`xml_node`>,1
+officer,embed_img_raster,1,0,0,character,1
+officer,empty_content,-1,0,0,class<`empty_content`>,1
+officer,external_img,-1,0,0,"class<`cot`, `external_img`>",1
+officer,external_img,0,0,0,character,1
+officer,external_img,1,0,0,double,1
+officer,external_img,2,0,0,double,1
+officer,footers_replace_img_at_bkm,-1,0,0,class<`rdocx`>,1
+officer,footers_replace_img_at_bkm,0,0,0,class<`rdocx`>,1
+officer,footers_replace_img_at_bkm,1,0,0,character,1
+officer,footers_replace_img_at_bkm,2,0,0,"class<`cot`, `external_img`>",1
+officer,footnote_add_xml,-1,0,0,class<`rdocx`>,1
+officer,footnote_add_xml,0,0,0,class<`rdocx`>,1
+officer,footnote_add_xml,1,0,0,character,1
+officer,footnote_add_xml,2,0,0,character,1
+officer,footnote_add_xml,3,0,0,character,1
+officer,format.fp_text,-1,0,0,character,1
+officer,format.fp_text,0,0,0,class<`fp_text`>,1
+officer,format.fp_text,1,0,0,character,1
+officer,format.fp_text,2,0,0,...,1
+officer,fortify_fpar,-1,0,0,"list<class<`cot`, `external_img`>>",1
+officer,fortify_fpar,-1,0,1,"list<class<`cot`, `ftext`> | class<`cot`, `external_img`>>",1
+officer,fortify_fpar,-1,0,2,"list<class<`cot`, `ftext`>>",1
+officer,fortify_fpar,0,0,0,class<`fpar`>,1
+officer,fortify_location,-1,0,0,"class<`location_manual`, `location_str`>",1
+officer,fortify_location,-1,0,1,list<double | character>,1
+officer,fortify_location,-1,0,2,list<double | character | null>,1
+officer,fortify_location,0,0,0,"class<`location_manual`, `location_str`>",1
+officer,fortify_location,0,0,1,"class<`location_str`, `location_template`>",1
+officer,fortify_location,0,0,2,"class<`location_label`, `location_str`>",1
+officer,fortify_location,0,0,3,"class<`location_left`, `location_str`>",1
+officer,fortify_location,0,0,4,"class<`location_right`, `location_str`>",1
+officer,fortify_location,0,0,5,"class<`location_str`, `location_type`>",1
+officer,fortify_location,0,0,6,"class<`location_fullsize`, `location_str`>",1
+officer,fortify_location,1,0,0,any,1
+officer,fortify_location,2,0,0,...,1
+officer,fortify_location.location_fullsize,-1,0,0,list<double | character | null>,1
+officer,fortify_location.location_fullsize,0,0,0,"class<`location_fullsize`, `location_str`>",1
+officer,fortify_location.location_fullsize,1,0,0,class<`rpptx`>,1
+officer,fortify_location.location_fullsize,2,0,0,...,1
+officer,fortify_location.location_label,-1,0,0,list<double | character>,1
+officer,fortify_location.location_label,0,0,0,"class<`location_label`, `location_str`>",1
+officer,fortify_location.location_label,1,0,0,class<`rpptx`>,1
+officer,fortify_location.location_label,2,0,0,...,1
+officer,fortify_location.location_left,-1,0,0,list<double | character>,1
+officer,fortify_location.location_left,0,0,0,"class<`location_left`, `location_str`>",1
+officer,fortify_location.location_left,1,0,0,class<`rpptx`>,1
+officer,fortify_location.location_left,2,0,0,...,1
+officer,fortify_location.location_manual,-1,0,0,"class<`location_manual`, `location_str`>",1
+officer,fortify_location.location_manual,0,0,0,"class<`location_manual`, `location_str`>",1
+officer,fortify_location.location_manual,1,0,0,any,1
+officer,fortify_location.location_manual,2,0,0,...,1
+officer,fortify_location.location_right,-1,0,0,list<double | character>,1
+officer,fortify_location.location_right,0,0,0,"class<`location_right`, `location_str`>",1
+officer,fortify_location.location_right,1,0,0,class<`rpptx`>,1
+officer,fortify_location.location_right,2,0,0,...,1
+officer,fortify_location.location_template,-1,0,0,"class<`location_manual`, `location_str`>",1
+officer,fortify_location.location_template,0,0,0,"class<`location_str`, `location_template`>",1
+officer,fortify_location.location_template,1,0,0,class<`rpptx`>,1
+officer,fortify_location.location_template,2,0,0,...,1
+officer,fortify_location.location_type,-1,0,0,list<double | character>,1
+officer,fortify_location.location_type,0,0,0,"class<`location_str`, `location_type`>",1
+officer,fortify_location.location_type,1,0,0,class<`rpptx`>,1
+officer,fortify_location.location_type,2,0,0,...,1
+officer,fortify_master_xfrm,-1,0,0,class<`data.frame`>,1
+officer,fortify_master_xfrm,0,0,0,class<`data.frame`>,1
+officer,fortify_pml_images,-1,0,0,character,1
+officer,fortify_pml_images,0,0,0,class<`rpptx`>,1
+officer,fortify_pml_images,1,0,0,character,1
+officer,fpar,-1,0,0,class<`fpar`>,1
+officer,fpar,0,0,0,...,1
+officer,fpar,1,0,0,class<`fp_par`>,1
+officer,fpar,2,0,0,class<`fp_text`>,1
+officer,fp_border,-1,0,0,class<`fp_border`>,1
+officer,fp_border,0,0,0,character,1
+officer,fp_border,1,0,0,character,1
+officer,fp_border,2,0,0,double,1
+officer,fp_cell,-1,0,0,class<`fp_cell`>,1
+officer,fp_cell,0,0,0,class<`fp_border`>,1
+officer,fp_cell,1,0,0,any,1
+officer,fp_cell,2,0,0,any,1
+officer,fp_cell,3,0,0,any,1
+officer,fp_cell,4,0,0,any,1
+officer,fp_cell,5,0,0,character,1
+officer,fp_cell,6,0,0,double,1
+officer,fp_cell,7,0,0,any,1
+officer,fp_par,-1,0,0,class<`fp_par`>,1
+officer,fp_par,0,0,0,character,1
+officer,fp_par,1,0,0,double,1
+officer,fp_par,2,0,0,class<`fp_border`>,1
+officer,fp_par,3,0,0,any,1
+officer,fp_par,4,0,0,any,1
+officer,fp_par,5,0,0,any,1
+officer,fp_par,6,0,0,any,1
+officer,fp_par,7,0,0,any,1
+officer,fp_sign,-1,0,0,character,1
+officer,fp_sign,0,0,0,class<`fp_text`>,1
+officer,fp_text,-1,0,0,class<`fp_text`>,1
+officer,fp_text,0,0,0,character,1
+officer,fp_text,1,0,0,double,1
+officer,fp_text,2,0,0,logical,1
+officer,fp_text,3,0,0,logical,1
+officer,fp_text,4,0,0,logical,1
+officer,fp_text,5,0,0,character,1
+officer,fp_text,6,0,0,character,1
+officer,fp_text,7,0,0,character,1
+officer,ftext,-1,0,0,"class<`cot`, `ftext`>",1
+officer,ftext,0,0,0,character,1
+officer,ftext,1,0,0,class<`fp_text`>,1
+officer,get_ph_loc,-1,0,0,list<double | character>,1
+officer,get_ph_loc,0,0,0,class<`rpptx`>,1
+officer,get_ph_loc,1,0,0,character,1
+officer,get_ph_loc,2,0,0,character,1
+officer,get_ph_loc,3,0,0,character,1
+officer,get_ph_loc,4,0,0,any,1
+officer,get_ph_loc,5,0,0,any,1
+officer,get_ph_loc,6,0,0,double,1
+officer,get_ph_loc,6,0,1,null,1
+officer,get_shape_id,-1,0,0,character,1
+officer,get_shape_id,0,0,0,class<`rpptx`>,1
+officer,get_shape_id,1,0,0,any,1
+officer,get_shape_id,2,0,0,double,1
+officer,get_shape_id,3,0,0,character,1
+officer,get_shape_id,3,0,1,null,1
+officer,get_style_id,-1,0,0,character,1
+officer,get_style_id,0,0,0,class<`data.frame`>,1
+officer,get_style_id,1,0,0,character,1
+officer,get_style_id,2,0,0,character,1
+officer,headers_replace_img_at_bkm,-1,0,0,class<`rdocx`>,1
+officer,headers_replace_img_at_bkm,0,0,0,class<`rdocx`>,1
+officer,headers_replace_img_at_bkm,1,0,0,character,1
+officer,headers_replace_img_at_bkm,2,0,0,"class<`cot`, `external_img`>",1
+officer,hex_color,-1,0,0,character,1
+officer,hex_color,0,0,0,character,1
+officer,htmlEscapeCopy,-1,0,0,character[],1
+officer,htmlEscapeCopy,0,0,0,character[],1
+officer,htmlEscapeCopy,1,0,0,logical,1
+officer,is.color,-1,0,0,logical,1
+officer,is.color,0,0,0,character,1
+officer,is_scalar_character,-1,0,0,logical,1
+officer,is_scalar_character,0,0,0,character,1
+officer,is_scalar_logical,-1,0,0,logical,1
+officer,is_scalar_logical,0,0,0,logical,1
+officer,is_transparent,-1,0,0,logical,1
+officer,is_transparent,0,0,0,character,1
+officer,layout_properties,-1,0,0,class<`data.frame`>,1
+officer,layout_properties,0,0,0,class<`rpptx`>,1
+officer,layout_properties,1,0,0,character,1
+officer,layout_properties,1,0,1,null,1
+officer,layout_properties,2,0,0,character,1
+officer,layout_properties,2,0,1,null,1
+officer,layout_summary,-1,0,0,class<`data.frame`>,1
+officer,layout_summary,0,0,0,class<`rpptx`>,1
+officer,length.rdocx,-1,0,0,integer,1
+officer,length.rdocx,0,0,0,class<`rdocx`>,1
+officer,length.rpptx,-1,0,0,integer,1
+officer,length.rpptx,0,0,0,class<`rpptx`>,1
+officer,media_extract,-1,0,0,logical,1
+officer,media_extract,0,0,0,class<`rpptx`>,1
+officer,media_extract,1,0,0,character,1
+officer,media_extract,2,0,0,character,1
+officer,move_slide,-1,0,0,class<`rpptx`>,1
+officer,move_slide,0,0,0,class<`rpptx`>,1
+officer,move_slide,1,0,0,double,1
+officer,move_slide,2,0,0,double,1
+officer,node_content,-1,0,0,class<`data.frame`>,1
+officer,node_content,0,0,0,class<`xml_node`>,1
+officer,node_content,1,0,0,any,1
+officer,on_slide,-1,0,0,class<`rpptx`>,1
+officer,on_slide,0,0,0,class<`rpptx`>,1
+officer,on_slide,1,0,0,double,1
+officer,pack_folder,-1,0,0,character,1
+officer,pack_folder,0,0,0,character,1
+officer,pack_folder,1,0,0,character,1
+officer,page_mar,-1,0,0,class<`page_mar`>,1
+officer,page_mar,0,0,0,double,1
+officer,page_mar,1,0,0,double,1
+officer,page_mar,2,0,0,double,1
+officer,page_mar,3,0,0,double,1
+officer,page_mar,4,0,0,double,1
+officer,page_mar,5,0,0,double,1
+officer,page_mar,6,0,0,double,1
+officer,page_size,-1,0,0,class<`page_size`>,1
+officer,page_size,0,0,0,double,1
+officer,page_size,1,0,0,double,1
+officer,page_size,2,0,0,character,1
+officer,par_as_tibble,-1,0,0,class<`data.frame`>,1
+officer,par_as_tibble,0,0,0,class<`xml_node`>,1
+officer,par_as_tibble,1,0,0,any,1
+officer,part_reference_img,-1,0,0,class<`rdocx`>,1
+officer,part_reference_img,0,0,0,class<`rdocx`>,1
+officer,part_reference_img,1,0,0,character[],1
+officer,part_reference_img,2,0,0,character,1
+officer,ph_add_fpar,-1,0,0,class<`rpptx`>,1
+officer,ph_add_fpar,0,0,0,class<`rpptx`>,1
+officer,ph_add_fpar,1,0,0,class<`fpar`>,1
+officer,ph_add_fpar,2,0,0,character,1
+officer,ph_add_fpar,3,0,0,double,1
+officer,ph_add_fpar,4,0,0,null,1
+officer,ph_add_fpar,5,0,0,character,1
+officer,ph_add_fpar,6,0,0,double,1
+officer,ph_add_fpar,7,0,0,logical,1
+officer,ph_add_par,-1,0,0,class<`rpptx`>,1
+officer,ph_add_par,0,0,0,class<`rpptx`>,1
+officer,ph_add_par,1,0,0,character,1
+officer,ph_add_par,2,0,0,double,1
+officer,ph_add_par,3,0,0,null,1
+officer,ph_add_par,4,0,0,double,1
+officer,ph_add_par,5,0,0,null,1
+officer,ph_add_text,-1,0,0,class<`rpptx`>,1
+officer,ph_add_text,0,0,0,class<`rpptx`>,1
+officer,ph_add_text,1,0,0,character,1
+officer,ph_add_text,2,0,0,character,1
+officer,ph_add_text,3,0,0,double,1
+officer,ph_add_text,4,0,0,null,1
+officer,ph_add_text,5,0,0,character,1
+officer,ph_add_text,5,0,1,null,1
+officer,ph_add_text,6,0,0,class<`fp_text`>,1
+officer,ph_add_text,7,0,0,character,1
+officer,ph_hyperlink,-1,0,0,class<`rpptx`>,1
+officer,ph_hyperlink,0,0,0,class<`rpptx`>,1
+officer,ph_hyperlink,1,0,0,character,1
+officer,ph_hyperlink,2,0,0,double,1
+officer,ph_hyperlink,3,0,0,null,1
+officer,ph_hyperlink,4,0,0,character,1
+officer,ph_hyperlink,5,0,0,character,1
+officer,ph_location,-1,0,0,"class<`location_manual`, `location_str`>",1
+officer,ph_location,0,0,0,double,1
+officer,ph_location,1,0,0,double,1
+officer,ph_location,2,0,0,double,1
+officer,ph_location,3,0,0,double,1
+officer,ph_location,4,0,0,character,1
+officer,ph_location,5,0,0,character,1
+officer,ph_location,5,0,1,null,1
+officer,ph_location,6,0,0,double,1
+officer,ph_location,6,0,1,null,1
+officer,ph_location,7,0,0,...,1
+officer,ph_location_fullsize,-1,0,0,"class<`location_fullsize`, `location_str`>",1
+officer,ph_location_fullsize,0,0,0,character,1
+officer,ph_location_fullsize,1,0,0,...,1
+officer,ph_location_label,-1,0,0,"class<`location_label`, `location_str`>",1
+officer,ph_location_label,0,0,0,character,1
+officer,ph_location_label,1,0,0,null,1
+officer,ph_location_label,2,0,0,...,1
+officer,ph_location_left,-1,0,0,"class<`location_left`, `location_str`>",1
+officer,ph_location_left,0,0,0,null,1
+officer,ph_location_left,1,0,0,...,1
+officer,ph_location_right,-1,0,0,"class<`location_right`, `location_str`>",1
+officer,ph_location_right,0,0,0,null,1
+officer,ph_location_right,1,0,0,...,1
+officer,ph_location_template,-1,0,0,"class<`location_str`, `location_template`>",1
+officer,ph_location_template,0,0,0,double,1
+officer,ph_location_template,1,0,0,double,1
+officer,ph_location_template,2,0,0,double,1
+officer,ph_location_template,3,0,0,double,1
+officer,ph_location_template,4,0,0,character,1
+officer,ph_location_template,5,0,0,character,1
+officer,ph_location_template,6,0,0,double,1
+officer,ph_location_template,7,0,0,...,1
+officer,ph_location_type,-1,0,0,"class<`location_str`, `location_type`>",1
+officer,ph_location_type,0,0,0,character,1
+officer,ph_location_type,1,0,0,logical,1
+officer,ph_location_type,2,0,0,logical,1
+officer,ph_location_type,3,0,0,null,1
+officer,ph_location_type,4,0,0,double,1
+officer,ph_location_type,4,0,1,null,1
+officer,ph_location_type,5,0,0,...,1
+officer,ph_remove,-1,0,0,class<`rpptx`>,1
+officer,ph_remove,0,0,0,class<`rpptx`>,1
+officer,ph_remove,1,0,0,character,1
+officer,ph_remove,2,0,0,double,1
+officer,ph_remove,3,0,0,null,1
+officer,ph_remove,4,0,0,null,1
+officer,ph_slidelink,-1,0,0,class<`rpptx`>,1
+officer,ph_slidelink,0,0,0,class<`rpptx`>,1
+officer,ph_slidelink,1,0,0,character,1
+officer,ph_slidelink,2,0,0,double,1
+officer,ph_slidelink,3,0,0,null,1
+officer,ph_slidelink,4,0,0,character,1
+officer,ph_slidelink,5,0,0,double,1
+officer,ph_with,-1,0,0,class<`rpptx`>,1
+officer,ph_with,0,0,0,class<`rpptx`>,1
+officer,ph_with,1,0,0,character[],1
+officer,ph_with,1,0,1,class<`block_list`>,1
+officer,ph_with,1,0,2,"class<`cot`, `external_img`>",1
+officer,ph_with,1,0,3,class<`data.frame`>,1
+officer,ph_with,1,0,4,class<`empty_content`>,1
+officer,ph_with,1,0,5,class<`fpar`>,1
+officer,ph_with,1,0,6,"class<`gg`, `ggplot`>",1
+officer,ph_with,1,0,7,class<`plot_instr`>,1
+officer,ph_with,1,0,8,class<`unordered_list`>,1
+officer,ph_with,2,0,0,"class<`location_left`, `location_str`>",1
+officer,ph_with,2,0,1,"class<`location_str`, `location_type`>",1
+officer,ph_with,2,0,2,"class<`location_fullsize`, `location_str`>",1
+officer,ph_with,2,0,3,"class<`location_label`, `location_str`>",1
+officer,ph_with,2,0,4,"class<`location_manual`, `location_str`>",1
+officer,ph_with,2,0,5,"class<`location_right`, `location_str`>",1
+officer,ph_with,2,0,6,"class<`location_str`, `location_template`>",1
+officer,ph_with,3,0,0,...,1
+officer,ph_with.block_list,-1,0,0,class<`rpptx`>,1
+officer,ph_with.block_list,0,0,0,class<`rpptx`>,1
+officer,ph_with.block_list,1,0,0,class<`block_list`>,1
+officer,ph_with.block_list,2,0,0,"class<`location_manual`, `location_str`>",1
+officer,ph_with.block_list,2,0,1,"class<`location_str`, `location_type`>",1
+officer,ph_with.block_list,3,0,0,logical,1
+officer,ph_with.block_list,4,0,0,...,1
+officer,ph_with.character,-1,0,0,class<`rpptx`>,1
+officer,ph_with.character,0,0,0,class<`rpptx`>,1
+officer,ph_with.character,1,0,0,character[],1
+officer,ph_with.character,2,0,0,"class<`location_left`, `location_str`>",1
+officer,ph_with.character,2,0,1,"class<`location_str`, `location_type`>",1
+officer,ph_with.character,2,0,2,"class<`location_fullsize`, `location_str`>",1
+officer,ph_with.character,2,0,3,"class<`location_label`, `location_str`>",1
+officer,ph_with.character,2,0,4,"class<`location_manual`, `location_str`>",1
+officer,ph_with.character,2,0,5,"class<`location_right`, `location_str`>",1
+officer,ph_with.character,2,0,6,"class<`location_str`, `location_template`>",1
+officer,ph_with.character,3,0,0,...,1
+officer,ph_with.data.frame,-1,0,0,class<`rpptx`>,1
+officer,ph_with.data.frame,0,0,0,class<`rpptx`>,1
+officer,ph_with.data.frame,1,0,0,class<`data.frame`>,1
+officer,ph_with.data.frame,2,0,0,"class<`location_label`, `location_str`>",1
+officer,ph_with.data.frame,2,0,1,"class<`location_right`, `location_str`>",1
+officer,ph_with.data.frame,2,0,2,"class<`location_str`, `location_type`>",1
+officer,ph_with.data.frame,3,0,0,logical,1
+officer,ph_with.data.frame,4,0,0,logical,1
+officer,ph_with.data.frame,5,0,0,logical,1
+officer,ph_with.data.frame,6,0,0,logical,1
+officer,ph_with.data.frame,7,0,0,logical,1
+officer,ph_with.empty_content,-1,0,0,class<`rpptx`>,1
+officer,ph_with.empty_content,0,0,0,class<`rpptx`>,1
+officer,ph_with.empty_content,1,0,0,class<`empty_content`>,1
+officer,ph_with.empty_content,2,0,0,"class<`location_str`, `location_type`>",1
+officer,ph_with.empty_content,3,0,0,...,1
+officer,ph_with.external_img,-1,0,0,class<`rpptx`>,1
+officer,ph_with.external_img,0,0,0,class<`rpptx`>,1
+officer,ph_with.external_img,1,0,0,"class<`cot`, `external_img`>",1
+officer,ph_with.external_img,2,0,0,"class<`location_fullsize`, `location_str`>",1
+officer,ph_with.external_img,2,0,1,"class<`location_left`, `location_str`>",1
+officer,ph_with.external_img,2,0,2,"class<`location_right`, `location_str`>",1
+officer,ph_with.external_img,2,0,3,"class<`location_str`, `location_type`>",1
+officer,ph_with.external_img,3,0,0,logical,1
+officer,ph_with.external_img,4,0,0,...,1
+officer,ph_with.fpar,-1,0,0,class<`rpptx`>,1
+officer,ph_with.fpar,0,0,0,class<`rpptx`>,1
+officer,ph_with.fpar,1,0,0,class<`fpar`>,1
+officer,ph_with.fpar,2,0,0,"class<`location_manual`, `location_str`>",1
+officer,ph_with.fpar,2,0,1,"class<`location_str`, `location_type`>",1
+officer,ph_with.fpar,3,0,0,...,1
+officer,ph_with.gg,-1,0,0,class<`rpptx`>,1
+officer,ph_with.gg,0,0,0,class<`rpptx`>,1
+officer,ph_with.gg,1,0,0,"class<`gg`, `ggplot`>",1
+officer,ph_with.gg,2,0,0,"class<`location_fullsize`, `location_str`>",1
+officer,ph_with.gg,3,0,0,double,1
+officer,ph_with.gg,4,0,0,...,1
+officer,ph_with.plot_instr,-1,0,0,class<`rpptx`>,1
+officer,ph_with.plot_instr,0,0,0,class<`rpptx`>,1
+officer,ph_with.plot_instr,1,0,0,class<`plot_instr`>,1
+officer,ph_with.plot_instr,2,0,0,"class<`location_fullsize`, `location_str`>",1
+officer,ph_with.plot_instr,3,0,0,double,1
+officer,ph_with.plot_instr,4,0,0,...,1
+officer,ph_with.unordered_list,-1,0,0,class<`rpptx`>,1
+officer,ph_with.unordered_list,0,0,0,class<`rpptx`>,1
+officer,ph_with.unordered_list,1,0,0,class<`unordered_list`>,1
+officer,ph_with.unordered_list,2,0,0,"class<`location_fullsize`, `location_str`>",1
+officer,ph_with.unordered_list,3,0,0,...,1
+officer,pic_pml,-1,0,0,character,1
+officer,pic_pml,0,0,0,double,1
+officer,pic_pml,1,0,0,double,1
+officer,pic_pml,2,0,0,double,1
+officer,pic_pml,3,0,0,double,1
+officer,pic_pml,4,0,0,null,1
+officer,pic_pml,5,0,0,null,1
+officer,pic_pml,6,0,0,character,1
+officer,pic_pml,7,0,0,character,1
+officer,pic_pml,7,0,1,null,1
+officer,plot_instr,-1,0,0,class<`plot_instr`>,1
+officer,plot_instr,0,0,0,any,1
+officer,ppr_pml,-1,0,0,character,1
+officer,ppr_pml,0,0,0,class<`fp_par`>,1
+officer,ppr_wml,-1,0,0,character,1
+officer,ppr_wml,0,0,0,class<`fp_par`>,1
+officer,pptx_par_as_tibble,-1,0,0,class<`data.frame`>,1
+officer,pptx_par_as_tibble,0,0,0,class<`xml_node`>,1
+officer,pptx_summary,-1,0,0,class<`data.frame`>,1
+officer,pptx_summary,0,0,0,character,1
+officer,pptx_summary,0,0,1,class<`rpptx`>,1
+officer,pptxtable_as_tibble,-1,0,0,class<`data.frame`>,1
+officer,pptxtable_as_tibble,0,0,0,class<`xml_node`>,1
+officer,print.fp_text,-1,0,0,null,1
+officer,print.fp_text,0,0,0,class<`fp_text`>,1
+officer,print.fp_text,1,0,0,...,1
+officer,print.rdocx,-1,0,0,character,1
+officer,print.rdocx,-1,0,1,null,1
+officer,print.rdocx,0,0,0,class<`rdocx`>,1
+officer,print.rdocx,1,0,0,character,1
+officer,print.rdocx,1,0,1,null,1
+officer,print.rdocx,2,0,0,...,1
+officer,print.rpptx,-1,0,0,character,1
+officer,print.rpptx,0,0,0,class<`rpptx`>,1
+officer,print.rpptx,1,0,0,character,1
+officer,print.rpptx,2,0,0,...,1
+officer,print.rxlsx,-1,0,0,character,1
+officer,print.rxlsx,0,0,0,class<`rxlsx`>,1
+officer,print.rxlsx,1,0,0,character,1
+officer,print.rxlsx,2,0,0,...,1
+officer,process_sections,-1,0,0,class<`rdocx`>,1
+officer,process_sections,0,0,0,class<`rdocx`>,1
+officer,prop_section,-1,0,0,"class<`prop`, `prop_section`>",1
+officer,prop_section,0,0,0,class<`page_size`>,1
+officer,prop_section,1,0,0,class<`page_mar`>,1
+officer,prop_section,2,0,0,character,1
+officer,p_xfrm_str,-1,0,0,character,1
+officer,p_xfrm_str,0,0,0,double,1
+officer,p_xfrm_str,1,0,0,double,1
+officer,p_xfrm_str,2,0,0,double,1
+officer,p_xfrm_str,3,0,0,double,1
+officer,p_xfrm_str,4,0,0,null,1
+officer,rbind.match.columns,-1,0,0,class<`data.frame`>,1
+officer,rbind.match.columns,0,0,0,list<class<`data.frame`>>,1
+officer,read_core_properties,-1,0,0,class<`core_properties`>,1
+officer,read_core_properties,0,0,0,character,1
+officer,read_docx,-1,0,0,class<`rdocx`>,1
+officer,read_docx,0,0,0,character,1
+officer,read_docx,0,0,1,null,1
+officer,read_docx_styles,-1,0,0,class<`data.frame`>,1
+officer,read_docx_styles,0,0,0,character,1
+officer,read_pptx,-1,0,0,class<`rpptx`>,1
+officer,read_pptx,0,0,0,character,1
+officer,read_pptx,0,0,1,null,1
+officer,read_table_style,-1,0,0,class<`data.frame`>,1
+officer,read_table_style,0,0,0,character,1
+officer,read_theme_colors,-1,0,0,class<`data.frame`>,1
+officer,read_theme_colors,0,0,0,"class<`xml_document`, `xml_node`>",1
+officer,read_theme_colors,1,0,0,character,1
+officer,read_xfrm,-1,0,0,class<`data.frame`>,1
+officer,read_xfrm,0,0,0,class<`xml_nodeset`>,1
+officer,read_xfrm,1,0,0,character,1
+officer,read_xfrm,2,0,0,character,1
+officer,read_xlsx,-1,0,0,class<`rxlsx`>,1
+officer,read_xlsx,0,0,0,null,1
+officer,remove_slide,-1,0,0,class<`rpptx`>,1
+officer,remove_slide,0,0,0,class<`rpptx`>,1
+officer,remove_slide,1,0,0,null,1
+officer,rpr_pml,-1,0,0,character,1
+officer,rpr_pml,0,0,0,class<`fp_text`>,1
+officer,rpr_wml,-1,0,0,character,1
+officer,rpr_wml,0,0,0,class<`fp_text`>,1
+officer,run_autonum,-1,0,0,"class<`run`, `run_autonum`>",1
+officer,run_autonum,0,0,0,character,1
+officer,run_autonum,1,0,0,character,1
+officer,run_autonum,2,0,0,character,1
+officer,run_columnbreak,-1,0,0,"class<`run`, `run_columnbreak`>",1
+officer,run_linebreak,-1,0,0,"class<`run`, `run_linebreak`>",1
+officer,run_pagebreak,-1,0,0,"class<`run`, `run_pagebreak`>",1
+officer,run_reference,-1,0,0,"class<`run`, `run_reference`>",1
+officer,run_reference,0,0,0,character,1
+officer,run_seqfield,-1,0,0,"class<`run`, `run_seqfield`>",1
+officer,run_seqfield,0,0,0,character,1
+officer,runs_to_p_wml,-1,0,0,character,1
+officer,runs_to_p_wml,0,0,0,...,1
+officer,runs_to_p_wml,1,0,0,logical,1
+officer,section_dimensions,-1,0,0,list<integer[]>,1
+officer,section_dimensions,0,0,0,class<`xml_node`>,1
+officer,set_doc_properties,-1,0,0,class<`rdocx`>,1
+officer,set_doc_properties,0,0,0,class<`rdocx`>,1
+officer,set_doc_properties,1,0,0,character,1
+officer,set_doc_properties,2,0,0,character,1
+officer,set_doc_properties,3,0,0,character,1
+officer,set_doc_properties,4,0,0,character,1
+officer,set_doc_properties,5,0,0,"class<`POSIXct`, `POSIXt`>",1
+officer,set_row_span,-1,0,0,class<`data.frame`>,1
+officer,set_row_span,0,0,0,class<`data.frame`>,1
+officer,sheet_select,-1,0,0,class<`rxlsx`>,1
+officer,sheet_select,0,0,0,class<`rxlsx`>,1
+officer,sheet_select,1,0,0,character,1
+officer,sh_props_pml,-1,0,0,character,1
+officer,sh_props_pml,0,0,0,double,1
+officer,sh_props_pml,1,0,0,double,1
+officer,sh_props_pml,2,0,0,double,1
+officer,sh_props_pml,3,0,0,double,1
+officer,sh_props_pml,4,0,0,character,1
+officer,sh_props_pml,4,0,1,null,1
+officer,sh_props_pml,5,0,0,double,1
+officer,sh_props_pml,5,0,1,null,1
+officer,sh_props_pml,6,0,0,character,1
+officer,sh_props_pml,7,0,0,null,1
+officer,sh_props_pml,7,0,1,character,1
+officer,simple_lag,-1,0,0,double[],1
+officer,simple_lag,0,0,0,double[],1
+officer,simple_lag,1,0,0,double,1
+officer,slide_size,-1,0,0,list<double>,1
+officer,slide_size,0,0,0,class<`rpptx`>,1
+officer,slide_summary,-1,0,0,class<`data.frame`>,1
+officer,slide_summary,0,0,0,class<`rpptx`>,1
+officer,slide_summary,1,0,0,double,1
+officer,slide_summary,1,0,1,null,1
+officer,slip_in_column_break,-1,0,0,class<`rdocx`>,1
+officer,slip_in_column_break,0,0,0,class<`rdocx`>,1
+officer,slip_in_column_break,1,0,0,character,1
+officer,slip_in_footnote,-1,0,0,class<`rdocx`>,1
+officer,slip_in_footnote,0,0,0,class<`rdocx`>,1
+officer,slip_in_footnote,1,0,0,character,1
+officer,slip_in_footnote,2,0,0,class<`block_list`>,1
+officer,slip_in_footnote,3,0,0,character,1
+officer,slip_in_img,-1,0,0,class<`rdocx`>,1
+officer,slip_in_img,0,0,0,class<`rdocx`>,1
+officer,slip_in_img,1,0,0,character,1
+officer,slip_in_img,2,0,0,character,1
+officer,slip_in_img,3,0,0,double,1
+officer,slip_in_img,4,0,0,double,1
+officer,slip_in_img,5,0,0,character,1
+officer,slip_in_seqfield,-1,0,0,class<`rdocx`>,1
+officer,slip_in_seqfield,0,0,0,class<`rdocx`>,1
+officer,slip_in_seqfield,1,0,0,character,1
+officer,slip_in_seqfield,2,0,0,character,1
+officer,slip_in_seqfield,3,0,0,character,1
+officer,slip_in_text,-1,0,0,class<`rdocx`>,1
+officer,slip_in_text,0,0,0,class<`rdocx`>,1
+officer,slip_in_text,1,0,0,character,1
+officer,slip_in_text,2,0,0,character,1
+officer,slip_in_text,3,0,0,character,1
+officer,slip_in_text,4,0,0,character,1
+officer,slip_in_text,4,0,1,null,1
+officer,slip_in_xml,-1,0,0,class<`rdocx`>,1
+officer,slip_in_xml,0,0,0,class<`rdocx`>,1
+officer,slip_in_xml,1,0,0,character,1
+officer,slip_in_xml,2,0,0,character,1
+officer,solid_fill,-1,0,0,character,1
+officer,solid_fill,0,0,0,character,1
+officer,solid_fill_pml,-1,0,0,character,1
+officer,solid_fill_pml,0,0,0,character,1
+officer,solid_fill_pml,0,0,1,null,1
+officer,styles_info,-1,0,0,class<`data.frame`>,1
+officer,styles_info,0,0,0,class<`rdocx`>,1
+officer,table_docx,-1,0,0,character,1
+officer,table_docx,0,0,0,class<`data.frame`>,1
+officer,table_docx,1,0,0,logical,1
+officer,table_docx,2,0,0,character,1
+officer,table_docx,3,0,0,logical,1
+officer,table_docx,4,0,0,logical,1
+officer,table_docx,5,0,0,logical,1
+officer,table_docx,6,0,0,logical,1
+officer,table_docx,7,0,0,logical,1
+officer,table_pptx,-1,0,0,character,1
+officer,table_pptx,0,0,0,class<`data.frame`>,1
+officer,table_pptx,1,0,0,character,1
+officer,table_pptx,2,0,0,integer,1
+officer,table_pptx,3,0,0,integer,1
+officer,table_pptx,4,0,0,logical,1
+officer,table_pptx,5,0,0,logical,1
+officer,table_pptx,6,0,0,logical,1
+officer,table_pptx,7,0,0,logical,1
+officer,to_pml,-1,0,0,character,1
+officer,to_pml,0,0,0,"class<`cot`, `ftext`>",1
+officer,to_pml,0,0,1,class<`fpar`>,1
+officer,to_pml,0,0,2,"class<`block`, `block_table`>",1
+officer,to_pml,0,0,3,class<`unordered_list`>,1
+officer,to_pml,1,0,0,logical,1
+officer,to_pml,2,0,0,...,1
+officer,to_pml.block_table,-1,0,0,character,1
+officer,to_pml.block_table,0,0,0,"class<`block`, `block_table`>",1
+officer,to_pml.block_table,1,0,0,logical,1
+officer,to_pml.block_table,2,0,0,double,1
+officer,to_pml.block_table,3,0,0,double,1
+officer,to_pml.block_table,4,0,0,double,1
+officer,to_pml.block_table,5,0,0,double,1
+officer,to_pml.block_table,6,0,0,null,1
+officer,to_pml.block_table,7,0,0,null,1
+officer,to_pml.fpar,-1,0,0,character,1
+officer,to_pml.fpar,0,0,0,class<`fpar`>,1
+officer,to_pml.fpar,1,0,0,logical,1
+officer,to_pml.fpar,2,0,0,...,1
+officer,to_pml.ftext,-1,0,0,character,1
+officer,to_pml.ftext,0,0,0,"class<`cot`, `ftext`>",1
+officer,to_pml.ftext,1,0,0,logical,1
+officer,to_pml.ftext,2,0,0,...,1
+officer,to_pml.unordered_list,-1,0,0,character,1
+officer,to_pml.unordered_list,0,0,0,class<`unordered_list`>,1
+officer,to_pml.unordered_list,1,0,0,logical,1
+officer,to_pml.unordered_list,2,0,0,...,1
+officer,to_wml,-1,0,0,character,1
+officer,to_wml,0,0,0,"class<`cot`, `external_img`>",1
+officer,to_wml,0,0,1,"class<`cot`, `ftext`>",1
+officer,to_wml,0,0,2,"class<`block`, `block_caption`>",1
+officer,to_wml,0,0,3,"class<`block`, `block_table`>",1
+officer,to_wml,0,0,4,"class<`block`, `block_toc`>",1
+officer,to_wml,0,0,5,class<`fpar`>,1
+officer,to_wml,0,0,6,"class<`run`, `run_autonum`>",1
+officer,to_wml,0,0,7,"class<`run`, `run_seqfield`>",1
+officer,to_wml,1,0,0,logical,1
+officer,to_wml,2,0,0,...,1
+officer,to_wml.block_caption,-1,0,0,character,1
+officer,to_wml.block_caption,0,0,0,"class<`block`, `block_caption`>",1
+officer,to_wml.block_caption,1,0,0,logical,1
+officer,to_wml.block_caption,2,0,0,class<`rdocx`>,1
+officer,to_wml.block_caption,3,0,0,...,1
+officer,to_wml.block_table,-1,0,0,character,1
+officer,to_wml.block_table,0,0,0,"class<`block`, `block_table`>",1
+officer,to_wml.block_table,1,0,0,logical,1
+officer,to_wml.block_table,2,0,0,class<`rdocx`>,1
+officer,to_wml.block_table,3,0,0,...,1
+officer,to_wml.block_toc,-1,0,0,character,1
+officer,to_wml.block_toc,0,0,0,"class<`block`, `block_toc`>",1
+officer,to_wml.block_toc,1,0,0,logical,1
+officer,to_wml.block_toc,2,0,0,...,1
+officer,to_wml.external_img,-1,0,0,character,1
+officer,to_wml.external_img,0,0,0,"class<`cot`, `external_img`>",1
+officer,to_wml.external_img,1,0,0,logical,1
+officer,to_wml.external_img,2,0,0,...,1
+officer,to_wml.fpar,-1,0,0,character,1
+officer,to_wml.fpar,0,0,0,class<`fpar`>,1
+officer,to_wml.fpar,1,0,0,logical,1
+officer,to_wml.fpar,2,0,0,null,1
+officer,to_wml.fpar,3,0,0,...,1
+officer,to_wml.ftext,-1,0,0,character,1
+officer,to_wml.ftext,0,0,0,"class<`cot`, `ftext`>",1
+officer,to_wml.ftext,1,0,0,logical,1
+officer,to_wml.ftext,2,0,0,...,1
+officer,to_wml.run_autonum,-1,0,0,character,1
+officer,to_wml.run_autonum,0,0,0,"class<`run`, `run_autonum`>",1
+officer,to_wml.run_autonum,1,0,0,logical,1
+officer,to_wml.run_autonum,2,0,0,...,1
+officer,to_wml.run_pagebreak,-1,0,0,character,1
+officer,to_wml.run_pagebreak,0,0,0,"class<`run`, `run_pagebreak`>",1
+officer,to_wml.run_pagebreak,1,0,0,logical,1
+officer,to_wml.run_pagebreak,2,0,0,...,1
+officer,to_wml.run_seqfield,-1,0,0,character,1
+officer,to_wml.run_seqfield,0,0,0,"class<`run`, `run_seqfield`>",1
+officer,to_wml.run_seqfield,1,0,0,logical,1
+officer,to_wml.run_seqfield,2,0,0,...,1
+officer,unordered_list,-1,0,0,class<`unordered_list`>,1
+officer,unordered_list,0,0,0,character[],1
+officer,unordered_list,1,0,0,double[],1
+officer,unordered_list,2,0,0,class<`fp_text`>,1
+officer,unordered_list,2,0,1,list<class<`fp_text`>>,1
+officer,unpack_folder,-1,0,0,character,1
+officer,unpack_folder,0,0,0,character,1
+officer,unpack_folder,1,0,0,character,1
+officer,update.fp_border,-1,0,0,class<`fp_border`>,1
+officer,update.fp_border,0,0,0,class<`fp_border`>,1
+officer,update.fp_border,1,0,0,any,1
+officer,update.fp_border,2,0,0,character,1
+officer,update.fp_border,3,0,0,double,1
+officer,update.fp_border,4,0,0,...,1
+officer,update.fp_cell,-1,0,0,class<`fp_cell`>,1
+officer,update.fp_cell,0,0,0,class<`fp_cell`>,1
+officer,update.fp_cell,1,0,0,any,1
+officer,update.fp_cell,2,0,0,any,1
+officer,update.fp_cell,3,0,0,any,1
+officer,update.fp_cell,4,0,0,any,1
+officer,update.fp_cell,5,0,0,any,1
+officer,update.fp_cell,6,0,0,any,1
+officer,update.fp_cell,7,0,0,double,1
+officer,update.fp_par,-1,0,0,class<`fp_par`>,1
+officer,update.fp_par,0,0,0,class<`fp_par`>,1
+officer,update.fp_par,1,0,0,any,1
+officer,update.fp_par,2,0,0,any,1
+officer,update.fp_par,3,0,0,any,1
+officer,update.fp_par,4,0,0,double,1
+officer,update.fp_par,5,0,0,any,1
+officer,update.fp_par,6,0,0,any,1
+officer,update.fp_par,7,0,0,any,1
+officer,update.fp_text,-1,0,0,class<`fp_text`>,1
+officer,update.fp_text,0,0,0,class<`fp_text`>,1
+officer,update.fp_text,1,0,0,character,1
+officer,update.fp_text,2,0,0,any,1
+officer,update.fp_text,3,0,0,logical,1
+officer,update.fp_text,4,0,0,logical,1
+officer,update.fp_text,5,0,0,logical,1
+officer,update.fp_text,6,0,0,any,1
+officer,update.fp_text,7,0,0,any,1
+officer,wml_link_images,-1,0,0,character,1
+officer,wml_link_images,0,0,0,class<`rdocx`>,1
+officer,wml_link_images,1,0,0,character,1
+officer,wml_part_link_images,-1,0,0,character,1
+officer,wml_part_link_images,0,0,0,class<`rdocx`>,1
+officer,wml_part_link_images,1,0,0,character,1
+officer,wml_part_link_images,2,0,0,character,1
+officer,write_core_properties,-1,0,0,null,1
+officer,write_core_properties,0,0,0,class<`core_properties`>,1
+officer,write_core_properties,1,0,0,character,1
+officer,xfrmize,-1,0,0,class<`data.frame`>,1
+officer,xfrmize,0,0,0,class<`data.frame`>,1
+officer,xfrmize,1,0,0,class<`data.frame`>,1
+openssl,aes_any,-1,0,0,raw[],1
+openssl,aes_any,0,0,0,raw[],1
+openssl,aes_any,1,0,0,"class<`hash`, `sha256`>",1
+openssl,aes_any,1,0,1,raw[],1
+openssl,aes_any,2,0,0,raw[],1
+openssl,aes_any,3,0,0,logical,1
+openssl,aes_any,4,0,0,character,1
+openssl,aes_cbc_decrypt,-1,0,0,raw[],1
+openssl,aes_cbc_decrypt,0,0,0,raw[],1
+openssl,aes_cbc_decrypt,1,0,0,"class<`hash`, `sha256`>",1
+openssl,aes_cbc_decrypt,1,0,1,raw[],1
+openssl,aes_cbc_decrypt,2,0,0,raw[],1
+openssl,aes_cbc_encrypt,-1,0,0,raw[],1
+openssl,aes_cbc_encrypt,0,0,0,character,1
+openssl,aes_cbc_encrypt,0,0,1,raw[],1
+openssl,aes_cbc_encrypt,1,0,0,raw[],1
+openssl,aes_cbc_encrypt,1,0,1,"class<`hash`, `sha256`>",1
+openssl,aes_cbc_encrypt,2,0,0,raw[],1
+openssl,aes_decrypt,-1,0,0,raw[],1
+openssl,aes_decrypt,0,0,0,raw[],1
+openssl,aes_decrypt,1,0,0,"class<`hash`, `sha256`>",1
+openssl,aes_decrypt,1,0,1,raw[],1
+openssl,aes_decrypt,2,0,0,raw[],1
+openssl,aes_decrypt,3,0,0,character,1
+openssl,aes_encrypt,-1,0,0,raw[],1
+openssl,aes_encrypt,0,0,0,character,1
+openssl,aes_encrypt,0,0,1,raw[],1
+openssl,aes_encrypt,1,0,0,raw[],1
+openssl,aes_encrypt,1,0,1,"class<`hash`, `sha256`>",1
+openssl,aes_encrypt,2,0,0,raw[],1
+openssl,aes_encrypt,3,0,0,character,1
+openssl,as.character.bignum,-1,0,0,character,1
+openssl,as.character.bignum,0,0,0,class<`bignum`>,1
+openssl,as.character.bignum,1,0,0,logical,1
+openssl,as.character.bignum,2,0,0,...,1
+openssl,as.character.hash,-1,0,0,"class<`hash`, `md5`>",1
+openssl,as.character.hash,-1,0,1,"class<`hash`, `sha1`>",1
+openssl,as.character.hash,0,0,0,"class<`hash`, `md5`>",1
+openssl,as.character.hash,0,0,1,"class<`hash`, `sha1`>",1
+openssl,as.character.hash,1,0,0,character,1
+openssl,as.character.hash,2,0,0,...,1
+openssl,as.list.cert,-1,0,0,list<any>,1
+openssl,as.list.cert,0,0,0,class<`cert`>,1
+openssl,as.list.cert,1,0,0,...,1
+openssl,as.list.cert,2,0,0,null,1
+openssl,as.list.key,-1,0,0,list<any>,1
+openssl,as.list.key,0,0,0,"class<`ecdsa`, `key`>",1
+openssl,as.list.key,0,0,1,"class<`ed25519`, `key`>",1
+openssl,as.list.key,0,0,2,"class<`key`, `rsa`>",1
+openssl,as.list.key,0,0,3,"class<`key`, `x25519`>",1
+openssl,as.list.key,1,0,0,...,1
+openssl,as.list.pubkey,-1,0,0,list<any>,1
+openssl,as.list.pubkey,0,0,0,"class<`ed25519`, `pubkey`>",1
+openssl,as.list.pubkey,0,0,1,"class<`pubkey`, `x25519`>",1
+openssl,as.list.pubkey,0,0,2,"class<`ecdsa`, `pubkey`>",1
+openssl,as.list.pubkey,0,0,3,"class<`pubkey`, `rsa`>",1
+openssl,as.list.pubkey,1,0,0,...,1
+openssl,base64_decode,-1,0,0,raw[],1
+openssl,base64_decode,0,0,0,character,1
+openssl,base64_encode,-1,0,0,character,1
+openssl,base64_encode,0,0,0,class<`bignum`>,1
+openssl,base64_encode,0,0,1,raw[],1
+openssl,base64_encode,1,0,0,logical,1
+openssl,bignum,-1,0,0,class<`bignum`>,1
+openssl,bignum,0,0,0,character,1
+openssl,bignum,0,0,1,integer,1
+openssl,bignum,0,0,2,raw[],1
+openssl,bignum,0,0,3,class<`bignum`>,1
+openssl,bignum,1,0,0,logical,1
+openssl,^.bignum,-1,0,0,class<`bignum`>,1
+openssl,^.bignum,0,0,0,class<`bignum`>,1
+openssl,^.bignum,1,0,0,class<`bignum`>,1
+openssl,<.bignum,-1,0,0,logical,1
+openssl,<.bignum,0,0,0,class<`bignum`>,1
+openssl,<.bignum,1,0,0,class<`bignum`>,1
+openssl,==.bignum,-1,0,0,logical,1
+openssl,==.bignum,0,0,0,class<`bignum`>,1
+openssl,==.bignum,1,0,0,class<`bignum`>,1
+openssl,*.bignum,-1,0,0,class<`bignum`>,1
+openssl,*.bignum,0,0,0,class<`bignum`>,1
+openssl,*.bignum,1,0,0,class<`bignum`>,1
+openssl,%/%.bignum,-1,0,0,class<`bignum`>,1
+openssl,%/%.bignum,0,0,0,class<`bignum`>,1
+openssl,%/%.bignum,1,0,0,class<`bignum`>,1
+openssl,%%.bignum,-1,0,0,class<`bignum`>,1
+openssl,%%.bignum,0,0,0,class<`bignum`>,1
+openssl,%%.bignum,1,0,0,class<`bignum`>,1
+openssl,+.bignum,-1,0,0,class<`bignum`>,1
+openssl,+.bignum,0,0,0,class<`bignum`>,1
+openssl,+.bignum,1,0,0,class<`bignum`>,1
+openssl,bignum_mod,-1,0,0,class<`bignum`>,1
+openssl,bignum_mod,0,0,0,class<`bignum`>,1
+openssl,bignum_mod,1,0,0,class<`bignum`>,1
+openssl,bignum_mod_exp,-1,0,0,class<`bignum`>,1
+openssl,bignum_mod_exp,0,0,0,class<`bignum`>,1
+openssl,bignum_mod_exp,1,0,0,class<`bignum`>,1
+openssl,bignum_mod_exp,2,0,0,class<`bignum`>,1
+openssl,bn,-1,0,0,class<`bignum`>,1
+openssl,bn,0,0,0,character,1
+openssl,bn,0,0,1,integer,1
+openssl,bn,0,0,2,raw[],1
+openssl,bn,0,0,3,class<`bignum`>,1
+openssl,bn,1,0,0,logical,1
+openssl,ca_bundle,-1,0,0,list<class<`cert`>>,1
+openssl,cert_info,-1,0,0,list<any>,1
+openssl,cert_info,0,0,0,class<`cert`>,1
+openssl,cert_info,1,0,0,null,1
+openssl,cert_pubkey,-1,0,0,"class<`pubkey`, `rsa`>",1
+openssl,cert_pubkey,0,0,0,class<`cert`>,1
+openssl,cert_verify,-1,0,0,logical,1
+openssl,cert_verify,0,0,0,list<class<`cert`>>,1
+openssl,cert_verify,1,0,0,list<class<`cert`>>,1
+openssl,cert_verify_cert,-1,0,0,logical,1
+openssl,cert_verify_cert,0,0,0,class<`cert`>,1
+openssl,cert_verify_cert,1,0,0,list<class<`cert`>>,1
+openssl,cert_verify_cert,2,0,0,list<class<`cert`>>,1
+openssl,connectionhash,-1,0,0,raw[],1
+openssl,connectionhash,0,0,0,"class<`connection`, `file`>",1
+openssl,connectionhash,1,0,0,character,1
+openssl,connectionhmac,-1,0,0,raw[],1
+openssl,connectionhmac,0,0,0,"class<`connection`, `file`>",1
+openssl,connectionhmac,1,0,0,character,1
+openssl,connectionhmac,2,0,0,raw[],1
+openssl,data_sign,-1,0,0,raw[],1
+openssl,data_sign,0,0,0,raw[],1
+openssl,data_sign,1,0,0,"class<`ed25519`, `key`>",1
+openssl,data_verify,-1,0,0,logical,1
+openssl,data_verify,0,0,0,raw[],1
+openssl,data_verify,1,0,0,raw[],1
+openssl,data_verify,2,0,0,"class<`ed25519`, `pubkey`>",1
+openssl,decompose,-1,0,0,raw[],1
+openssl,decompose,-1,0,1,list<character | class<`bignum`>>,1
+openssl,decompose,-1,0,2,list<class<`bignum`>>,1
+openssl,decompose,0,0,0,"class<`ed25519`, `key`>",1
+openssl,decompose,0,0,1,"class<`ed25519`, `pubkey`>",1
+openssl,decompose,0,0,2,"class<`key`, `x25519`>",1
+openssl,decompose,0,0,3,"class<`pubkey`, `x25519`>",1
+openssl,decompose,0,0,4,"class<`ecdsa`, `pubkey`>",1
+openssl,decompose,0,0,5,"class<`ecdsa`, `key`>",1
+openssl,decompose,0,0,6,"class<`pubkey`, `rsa`>",1
+openssl,decompose,0,0,7,"class<`key`, `rsa`>",1
+openssl,decompose,0,0,8,"class<`dsa`, `pubkey`>",1
+openssl,decompose,1,0,0,...,1
+openssl,decompose.key,-1,0,0,raw[],1
+openssl,decompose.key,-1,0,1,list<character | class<`bignum`>>,1
+openssl,decompose.key,-1,0,2,list<class<`bignum`>>,1
+openssl,decompose.key,0,0,0,"class<`ed25519`, `key`>",1
+openssl,decompose.key,0,0,1,"class<`key`, `x25519`>",1
+openssl,decompose.key,0,0,2,"class<`ecdsa`, `key`>",1
+openssl,decompose.key,0,0,3,"class<`key`, `rsa`>",1
+openssl,decompose.key,1,0,0,...,1
+openssl,decompose.pubkey,-1,0,0,raw[],1
+openssl,decompose.pubkey,-1,0,1,list<character | class<`bignum`>>,1
+openssl,decompose.pubkey,-1,0,2,list<class<`bignum`>>,1
+openssl,decompose.pubkey,0,0,0,"class<`ed25519`, `pubkey`>",1
+openssl,decompose.pubkey,0,0,1,"class<`pubkey`, `x25519`>",1
+openssl,decompose.pubkey,0,0,2,"class<`ecdsa`, `pubkey`>",1
+openssl,decompose.pubkey,0,0,3,"class<`pubkey`, `rsa`>",1
+openssl,decompose.pubkey,0,0,4,"class<`dsa`, `pubkey`>",1
+openssl,decompose.pubkey,1,0,0,...,1
+openssl,decrypt_envelope,-1,0,0,raw[],1
+openssl,decrypt_envelope,0,0,0,raw[],1
+openssl,decrypt_envelope,1,0,0,raw[],1
+openssl,decrypt_envelope,2,0,0,raw[],1
+openssl,decrypt_envelope,3,0,0,"class<`key`, `rsa`>",1
+openssl,decrypt_envelope,4,0,0,any,1
+openssl,default_key,-1,0,0,character,1
+openssl,der_export,-1,0,0,raw[],1
+openssl,der_export,0,0,0,"class<`ecdsa`, `pubkey`>",1
+openssl,der_export,1,0,0,...,1
+openssl,der_export.pubkey,-1,0,0,raw[],1
+openssl,der_export.pubkey,0,0,0,"class<`ecdsa`, `pubkey`>",1
+openssl,der_export.pubkey,1,0,0,...,1
+openssl,derive_pubkey,-1,0,0,"class<`dsa`, `pubkey`>",1
+openssl,derive_pubkey,-1,0,1,"class<`ecdsa`, `pubkey`>",1
+openssl,derive_pubkey,-1,0,2,"class<`ed25519`, `pubkey`>",1
+openssl,derive_pubkey,-1,0,3,"class<`NA`, `pubkey`>",1
+openssl,derive_pubkey,-1,0,4,"class<`pubkey`, `rsa`>",1
+openssl,derive_pubkey,-1,0,5,"class<`pubkey`, `x25519`>",1
+openssl,derive_pubkey,0,0,0,"class<`dsa`, `key`>",1
+openssl,derive_pubkey,0,0,1,"class<`ecdsa`, `key`>",1
+openssl,derive_pubkey,0,0,2,"class<`ed25519`, `key`>",1
+openssl,derive_pubkey,0,0,3,raw[],1
+openssl,derive_pubkey,0,0,4,"class<`key`, `rsa`>",1
+openssl,derive_pubkey,0,0,5,"class<`key`, `x25519`>",1
+openssl,download_ssl_cert,-1,0,0,list<class<`cert`>>,1
+openssl,download_ssl_cert,0,0,0,character,1
+openssl,download_ssl_cert,1,0,0,double,1
+openssl,download_ssl_cert,2,0,0,logical,1
+openssl,dsa_keygen,-1,0,0,"class<`dsa`, `key`>",1
+openssl,dsa_keygen,0,0,0,double,1
+openssl,ec_dh,-1,0,0,raw[],1
+openssl,ec_dh,0,0,0,"class<`key`, `x25519`>",1
+openssl,ec_dh,1,0,0,"class<`pubkey`, `x25519`>",1
+openssl,ec_dh,2,0,0,any,1
+openssl,ecdsa_build,-1,0,0,"class<`ecdsa`, `pubkey`>",1
+openssl,ecdsa_build,0,0,0,list<raw[]>,1
+openssl,ecdsa_parse,-1,0,0,list<class<`bignum`>>,1
+openssl,ecdsa_parse,0,0,0,raw[],1
+openssl,ecdsa_pubkey_build,-1,0,0,raw[],1
+openssl,ecdsa_pubkey_build,0,0,0,class<`bignum`>,1
+openssl,ecdsa_pubkey_build,0,0,1,raw[],1
+openssl,ecdsa_pubkey_build,1,0,0,class<`bignum`>,1
+openssl,ecdsa_pubkey_build,1,0,1,raw[],1
+openssl,ecdsa_pubkey_build,2,0,0,character,1
+openssl,ecdsa_write,-1,0,0,raw[],1
+openssl,ecdsa_write,0,0,0,class<`bignum`>,1
+openssl,ecdsa_write,1,0,0,class<`bignum`>,1
+openssl,ec_keygen,-1,0,0,"class<`ecdsa`, `key`>",1
+openssl,ec_keygen,0,0,0,character[],1
+openssl,ed25519_keygen,-1,0,0,"class<`ed25519`, `key`>",1
+openssl,ed25519_sign,-1,0,0,raw[],1
+openssl,ed25519_sign,0,0,0,raw[],1
+openssl,ed25519_sign,1,0,0,"class<`ed25519`, `key`>",1
+openssl,ed25519_verify,-1,0,0,logical,1
+openssl,ed25519_verify,0,0,0,raw[],1
+openssl,ed25519_verify,1,0,0,raw[],1
+openssl,ed25519_verify,2,0,0,"class<`ed25519`, `pubkey`>",1
+openssl,encrypt_envelope,-1,0,0,list<raw[]>,1
+openssl,encrypt_envelope,0,0,0,raw[],1
+openssl,encrypt_envelope,1,0,0,"class<`pubkey`, `rsa`>",1
+openssl,fingerprint,-1,0,0,"class<`hash`, `md5`>",1
+openssl,fingerprint,-1,0,1,"class<`hash`, `sha1`>",1
+openssl,fingerprint,-1,0,2,"class<`hash`, `sha256`>",1
+openssl,fingerprint,0,0,0,"class<`dsa`, `key`>",1
+openssl,fingerprint,0,0,1,"class<`dsa`, `pubkey`>",1
+openssl,fingerprint,0,0,2,"class<`ecdsa`, `pubkey`>",1
+openssl,fingerprint,0,0,3,"class<`key`, `rsa`>",1
+openssl,fingerprint,0,0,4,"class<`pubkey`, `rsa`>",1
+openssl,fingerprint,1,0,0,any,1
+openssl,fingerprint.key,-1,0,0,"class<`hash`, `md5`>",1
+openssl,fingerprint.key,0,0,0,"class<`dsa`, `key`>",1
+openssl,fingerprint.key,0,0,1,"class<`key`, `rsa`>",1
+openssl,fingerprint.key,1,0,0,class<`function`>,1
+openssl,fingerprint.pubkey,-1,0,0,"class<`hash`, `md5`>",1
+openssl,fingerprint.pubkey,-1,0,1,"class<`hash`, `sha1`>",1
+openssl,fingerprint.pubkey,-1,0,2,"class<`hash`, `sha256`>",1
+openssl,fingerprint.pubkey,0,0,0,"class<`dsa`, `pubkey`>",1
+openssl,fingerprint.pubkey,0,0,1,"class<`ecdsa`, `pubkey`>",1
+openssl,fingerprint.pubkey,0,0,2,"class<`pubkey`, `rsa`>",1
+openssl,fingerprint.pubkey,1,0,0,class<`function`>,1
+openssl,fpdata,-1,0,0,list<raw[]>,1
+openssl,fpdata,0,0,0,"class<`ed25519`, `pubkey`>",1
+openssl,fpdata,0,0,1,"class<`pubkey`, `x25519`>",1
+openssl,fpdata,0,0,2,"class<`ecdsa`, `pubkey`>",1
+openssl,fpdata,0,0,3,"class<`pubkey`, `rsa`>",1
+openssl,fpdata,0,0,4,"class<`dsa`, `pubkey`>",1
+openssl,fpdata,1,0,0,...,1
+openssl,fpdata.dsa,-1,0,0,list<raw[]>,1
+openssl,fpdata.dsa,0,0,0,"class<`dsa`, `pubkey`>",1
+openssl,fpdata.ecdsa,-1,0,0,list<raw[]>,1
+openssl,fpdata.ecdsa,0,0,0,"class<`ecdsa`, `pubkey`>",1
+openssl,fpdata.ed25519,-1,0,0,list<raw[]>,1
+openssl,fpdata.ed25519,0,0,0,"class<`ed25519`, `pubkey`>",1
+openssl,fpdata.rsa,-1,0,0,list<raw[]>,1
+openssl,fpdata.rsa,0,0,0,"class<`pubkey`, `rsa`>",1
+openssl,fpdata.x25519,-1,0,0,list<raw[]>,1
+openssl,fpdata.x25519,0,0,0,"class<`pubkey`, `x25519`>",1
+openssl,hash_sign,-1,0,0,raw[],1
+openssl,hash_sign,0,0,0,"class<`hash`, `md5`>",1
+openssl,hash_sign,0,0,1,"class<`hash`, `sha1`>",1
+openssl,hash_sign,0,0,2,"class<`hash`, `sha256`>",1
+openssl,hash_sign,1,0,0,"class<`key`, `rsa`>",1
+openssl,hash_sign,1,0,1,"class<`ecdsa`, `key`>",1
+openssl,hash_verify,-1,0,0,logical,1
+openssl,hash_verify,0,0,0,"class<`hash`, `md5`>",1
+openssl,hash_verify,0,0,1,"class<`hash`, `sha1`>",1
+openssl,hash_verify,0,0,2,"class<`hash`, `sha256`>",1
+openssl,hash_verify,1,0,0,raw[],1
+openssl,hash_verify,2,0,0,"class<`pubkey`, `rsa`>",1
+openssl,hash_verify,2,0,1,"class<`ecdsa`, `pubkey`>",1
+openssl,hmac_feed,-1,0,0,logical,1
+openssl,hmac_feed,0,0,0,class<`md`>,1
+openssl,hmac_feed,1,0,0,raw[],1
+openssl,hmac_final,-1,0,0,raw[],1
+openssl,hmac_final,0,0,0,class<`md`>,1
+openssl,hmac_init,-1,0,0,class<`md`>,1
+openssl,hmac_init,0,0,0,character,1
+openssl,hmac_init,1,0,0,raw[],1
+openssl,is_positive_integer,-1,0,0,logical,1
+openssl,is_positive_integer,0,0,0,integer,1
+openssl,is_pubkey_str,-1,0,0,logical,1
+openssl,is_pubkey_str,0,0,0,character,1
+openssl,is_pubkey_str,0,0,1,"class<`ecdsa`, `pubkey`>",1
+openssl,is_pubkey_str,0,0,2,"class<`ed25519`, `pubkey`>",1
+openssl,is_pubkey_str,0,0,3,"class<`pubkey`, `rsa`>",1
+openssl,is_pubkey_str,0,0,4,"class<`pubkey`, `x25519`>",1
+openssl,is_pubkey_str,0,0,5,raw[],1
+openssl,is_windows,-1,0,0,logical,1
+openssl,$.key,-1,0,0,"class<`ecdsa`, `pubkey`>",1
+openssl,$.key,-1,0,1,"class<`pubkey`, `rsa`>",1
+openssl,$.key,-1,0,2,"class<`pubkey`, `x25519`>",1
+openssl,$.key,-1,0,3,list<class<`bignum`>>,1
+openssl,$.key,0,0,0,"class<`ecdsa`, `key`>",1
+openssl,$.key,0,0,1,"class<`key`, `rsa`>",1
+openssl,$.key,0,0,2,"class<`key`, `x25519`>",1
+openssl,$.key,0,0,3,"class<`pubkey`, `rsa`>",1
+openssl,$.key,1,0,0,character,1
+openssl,md5,-1,0,0,"class<`hash`, `md5`>",1
+openssl,md5,-1,0,1,"class<`hash`, `hmac`, `md5`>",1
+openssl,md5,0,0,0,raw[],1
+openssl,md5,0,0,1,"class<`connection`, `file`>",1
+openssl,md5,0,0,2,character[],1
+openssl,md5,0,0,3,class<`cert`>,1
+openssl,md5,1,0,0,null,1
+openssl,md5,1,0,1,character,1
+openssl,md_feed,-1,0,0,logical,1
+openssl,md_feed,0,0,0,class<`md`>,1
+openssl,md_feed,1,0,0,raw[],1
+openssl,md_final,-1,0,0,raw[],1
+openssl,md_final,0,0,0,class<`md`>,1
+openssl,md_init,-1,0,0,class<`md`>,1
+openssl,md_init,0,0,0,character,1
+openssl,my_key,-1,0,0,"class<`key`, `rsa`>",1
+openssl,my_pubkey,-1,0,0,"class<`pubkey`, `rsa`>",1
+openssl,normalize_home,-1,0,0,character,1
+openssl,normalize_home,0,0,0,character,1
+openssl,openssl_config,-1,0,0,list<character | logical>,1
+openssl,parse_der_key,-1,0,0,raw[],1
+openssl,parse_der_key,0,0,0,"class<`ecdsa`, `key`>",1
+openssl,parse_der_key,0,0,1,"class<`ed25519`, `key`>",1
+openssl,parse_der_key,0,0,2,"class<`key`, `rsa`>",1
+openssl,parse_der_key,0,0,3,"class<`key`, `x25519`>",1
+openssl,parse_der_pubkey,-1,0,0,raw[],1
+openssl,parse_der_pubkey,0,0,0,"class<`ecdsa`, `pubkey`>",1
+openssl,parse_der_pubkey,0,0,1,"class<`ed25519`, `pubkey`>",1
+openssl,parse_der_pubkey,0,0,2,"class<`pubkey`, `rsa`>",1
+openssl,parse_der_pubkey,0,0,3,"class<`pubkey`, `x25519`>",1
+openssl,parse_der_pubkey,0,0,4,raw[],1
+openssl,parse_hash,-1,0,0,"class<`hash`, `md5`>",1
+openssl,parse_hash,0,0,0,"class<`hash`, `md5`>",1
+openssl,parse_openssh,-1,0,0,"class<`ecdsa`, `pubkey`>",1
+openssl,parse_openssh,0,0,0,raw[],1
+openssl,parse_pem,-1,0,0,list<list<character | raw[]>>,1
+openssl,parse_pem,0,0,0,raw[],1
+openssl,parse_pem_cert,-1,0,0,raw[],1
+openssl,parse_pem_cert,0,0,0,raw[],1
+openssl,parse_pem_cert,1,0,0,any,1
+openssl,parse_pem_key,-1,0,0,raw[],1
+openssl,parse_pem_key,0,0,0,raw[],1
+openssl,parse_pem_key,1,0,0,character,1
+openssl,parse_pem_key,1,0,1,class<`function`>,1
+openssl,path_or_raw,-1,0,0,"class<`hash`, `md5`>",1
+openssl,path_or_raw,-1,0,1,raw[],1
+openssl,path_or_raw,0,0,0,"class<`hash`, `md5`>",1
+openssl,path_or_raw,0,0,1,character,1
+openssl,path_or_raw,0,0,2,raw[],1
+openssl,pem_export,-1,0,0,character,1
+openssl,pem_export,0,0,0,class<`cert`>,1
+openssl,pem_export,0,0,1,"class<`ecdsa`, `key`>",1
+openssl,pem_export,0,0,2,"class<`ecdsa`, `pubkey`>",1
+openssl,pem_export,0,0,3,"class<`key`, `rsa`>",1
+openssl,pem_export,0,0,4,"class<`pubkey`, `rsa`>",1
+openssl,pem_export,1,0,0,...,1
+openssl,pem_export.cert,-1,0,0,character,1
+openssl,pem_export.cert,0,0,0,class<`cert`>,1
+openssl,pem_export.cert,1,0,0,...,1
+openssl,pem_export.key,-1,0,0,character,1
+openssl,pem_export.key,0,0,0,"class<`ecdsa`, `key`>",1
+openssl,pem_export.key,0,0,1,"class<`key`, `rsa`>",1
+openssl,pem_export.key,1,0,0,character,1
+openssl,pem_export.key,1,0,1,null,1
+openssl,pem_export.key,2,0,0,...,1
+openssl,pem_export.pubkey,-1,0,0,character,1
+openssl,pem_export.pubkey,0,0,0,"class<`ecdsa`, `pubkey`>",1
+openssl,pem_export.pubkey,0,0,1,"class<`pubkey`, `rsa`>",1
+openssl,pem_export.pubkey,1,0,0,...,1
+openssl,pem_names,-1,0,0,character,1
+openssl,pem_names,0,0,0,raw[],1
+openssl,print.bignum,-1,0,0,null,1
+openssl,print.bignum,0,0,0,class<`bignum`>,1
+openssl,print.bignum,1,0,0,logical,1
+openssl,print.bignum,2,0,0,...,1
+openssl,print.cert,-1,0,0,null,1
+openssl,print.cert,0,0,0,class<`cert`>,1
+openssl,print.cert,1,0,0,...,1
+openssl,print.key,-1,0,0,null,1
+openssl,print.key,0,0,0,"class<`key`, `rsa`>",1
+openssl,print.key,1,0,0,...,1
+openssl,print.pubkey,-1,0,0,null,1
+openssl,print.pubkey,0,0,0,"class<`ecdsa`, `pubkey`>",1
+openssl,print.pubkey,0,0,1,"class<`pubkey`, `rsa`>",1
+openssl,print.pubkey,1,0,0,...,1
+openssl,priv_decompose.ecdsa,-1,0,0,list<character | class<`bignum`>>,1
+openssl,priv_decompose.ecdsa,0,0,0,"class<`ecdsa`, `key`>",1
+openssl,priv_decompose.ed25519,-1,0,0,raw[],1
+openssl,priv_decompose.ed25519,0,0,0,"class<`ed25519`, `key`>",1
+openssl,priv_decompose.ed25519,0,0,1,"class<`key`, `x25519`>",1
+openssl,priv_decompose.rsa,-1,0,0,list<class<`bignum`>>,1
+openssl,priv_decompose.rsa,0,0,0,"class<`key`, `rsa`>",1
+openssl,priv_decompose.x25519,-1,0,0,raw[],1
+openssl,priv_decompose.x25519,0,0,0,"class<`ed25519`, `key`>",1
+openssl,priv_decompose.x25519,0,0,1,"class<`key`, `x25519`>",1
+openssl,$.pubkey,-1,0,0,"class<`ecdsa`, `pubkey`>",1
+openssl,$.pubkey,-1,0,1,"class<`pubkey`, `rsa`>",1
+openssl,$.pubkey,-1,0,2,"class<`pubkey`, `x25519`>",1
+openssl,$.pubkey,-1,0,3,list<class<`bignum`>>,1
+openssl,$.pubkey,0,0,0,"class<`ecdsa`, `key`>",1
+openssl,$.pubkey,0,0,1,"class<`key`, `rsa`>",1
+openssl,$.pubkey,0,0,2,"class<`key`, `x25519`>",1
+openssl,$.pubkey,0,0,3,"class<`pubkey`, `rsa`>",1
+openssl,$.pubkey,1,0,0,character,1
+openssl,pubkey_bitsize,-1,0,0,integer,1
+openssl,pubkey_bitsize,0,0,0,"class<`ecdsa`, `pubkey`>",1
+openssl,pubkey_bitsize,0,0,1,"class<`ed25519`, `pubkey`>",1
+openssl,pubkey_bitsize,0,0,2,"class<`pubkey`, `rsa`>",1
+openssl,pubkey_bitsize,0,0,3,"class<`pubkey`, `x25519`>",1
+openssl,pubkey_decompose.dsa,-1,0,0,list<class<`bignum`>>,1
+openssl,pubkey_decompose.dsa,0,0,0,"class<`dsa`, `pubkey`>",1
+openssl,pubkey_decompose.ecdsa,-1,0,0,list<character | class<`bignum`>>,1
+openssl,pubkey_decompose.ecdsa,0,0,0,"class<`ecdsa`, `pubkey`>",1
+openssl,pubkey_decompose.ed25519,-1,0,0,raw[],1
+openssl,pubkey_decompose.ed25519,0,0,0,"class<`ed25519`, `pubkey`>",1
+openssl,pubkey_decompose.ed25519,0,0,1,"class<`pubkey`, `x25519`>",1
+openssl,pubkey_decompose.rsa,-1,0,0,list<class<`bignum`>>,1
+openssl,pubkey_decompose.rsa,0,0,0,"class<`pubkey`, `rsa`>",1
+openssl,pubkey_decompose.x25519,-1,0,0,raw[],1
+openssl,pubkey_decompose.x25519,0,0,0,"class<`ed25519`, `pubkey`>",1
+openssl,pubkey_decompose.x25519,0,0,1,"class<`pubkey`, `x25519`>",1
+openssl,pubkey_type,-1,0,0,character,1
+openssl,pubkey_type,0,0,0,class<`pubkey`>,1
+openssl,pubkey_type,0,0,1,"class<`ecdsa`, `pubkey`>",1
+openssl,pubkey_type,0,0,2,"class<`NA`, `pubkey`>",1
+openssl,pubkey_type,0,0,3,"class<`pubkey`, `rsa`>",1
+openssl,pubkey_type,0,0,4,"class<`pubkey`, `x25519`>",1
+openssl,pubkey_type,0,0,5,raw[],1
+openssl,rand_bytes,-1,0,0,raw[],1
+openssl,rand_bytes,0,0,0,double,1
+openssl,rand_num,-1,0,0,double[],1
+openssl,rand_num,0,0,0,double,1
+openssl,rawhash,-1,0,0,raw[],1
+openssl,rawhash,0,0,0,class<`cert`>,1
+openssl,rawhash,0,0,1,raw[],1
+openssl,rawhash,1,0,0,character,1
+openssl,rawhash,2,0,0,null,1
+openssl,rawstringhash,-1,0,0,"class<`hash`, `hmac`, `md5`>",1
+openssl,rawstringhash,-1,0,1,"class<`hash`, `hmac`, `sha1`>",1
+openssl,rawstringhash,-1,0,2,"class<`hash`, `hmac`, `sha256`>",1
+openssl,rawstringhash,-1,0,3,"class<`hash`, `md5`>",1
+openssl,rawstringhash,-1,0,4,"class<`hash`, `sha1`>",1
+openssl,rawstringhash,-1,0,5,"class<`hash`, `sha256`>",1
+openssl,rawstringhash,0,0,0,"class<`connection`, `file`>",1
+openssl,rawstringhash,0,0,1,character[],1
+openssl,rawstringhash,0,0,2,class<`cert`>,1
+openssl,rawstringhash,0,0,3,raw[],1
+openssl,rawstringhash,1,0,0,character,1
+openssl,rawstringhash,2,0,0,character,1
+openssl,rawstringhash,2,0,1,null,1
+openssl,read_cert_bundle,-1,0,0,list<class<`cert`>>,1
+openssl,read_cert_bundle,0,0,0,character,1
+openssl,read_con_buf,-1,0,0,null,1
+openssl,read_con_buf,-1,0,1,raw[],1
+openssl,read_con_buf,0,0,0,"class<`connection`, `rawConnection`>",1
+openssl,read_ed25519_key,-1,0,0,"class<`ed25519`, `key`>",1
+openssl,read_ed25519_key,0,0,0,raw[],1
+openssl,read_ed25519_pubkey,-1,0,0,"class<`ed25519`, `pubkey`>",1
+openssl,read_ed25519_pubkey,0,0,0,raw[],1
+openssl,read_input,-1,0,0,"class<`ecdsa`, `key`>",1
+openssl,read_input,-1,0,1,"class<`ecdsa`, `pubkey`>",1
+openssl,read_input,-1,0,2,"class<`ed25519`, `key`>",1
+openssl,read_input,-1,0,3,"class<`ed25519`, `pubkey`>",1
+openssl,read_input,-1,0,4,"class<`key`, `rsa`>",1
+openssl,read_input,-1,0,5,"class<`key`, `x25519`>",1
+openssl,read_input,-1,0,6,"class<`pubkey`, `rsa`>",1
+openssl,read_input,-1,0,7,"class<`pubkey`, `x25519`>",1
+openssl,read_input,-1,0,8,raw[],1
+openssl,read_input,0,0,0,"class<`ecdsa`, `key`>",1
+openssl,read_input,0,0,1,"class<`ecdsa`, `pubkey`>",1
+openssl,read_input,0,0,2,"class<`ed25519`, `key`>",1
+openssl,read_input,0,0,3,"class<`ed25519`, `pubkey`>",1
+openssl,read_input,0,0,4,"class<`key`, `rsa`>",1
+openssl,read_input,0,0,5,"class<`key`, `x25519`>",1
+openssl,read_input,0,0,6,"class<`pubkey`, `rsa`>",1
+openssl,read_input,0,0,7,"class<`pubkey`, `x25519`>",1
+openssl,read_input,0,0,8,character,1
+openssl,read_input,0,0,9,"class<`connection`, `textConnection`>",1
+openssl,read_input,0,0,10,raw[],1
+openssl,read_key,-1,0,0,"class<`ecdsa`, `key`>",1
+openssl,read_key,-1,0,1,"class<`ed25519`, `key`>",1
+openssl,read_key,-1,0,2,"class<`key`, `rsa`>",1
+openssl,read_key,-1,0,3,"class<`key`, `x25519`>",1
+openssl,read_key,0,0,0,"class<`ecdsa`, `key`>",1
+openssl,read_key,0,0,1,"class<`ed25519`, `key`>",1
+openssl,read_key,0,0,2,character,1
+openssl,read_key,0,0,3,"class<`key`, `rsa`>",1
+openssl,read_key,0,0,4,"class<`key`, `x25519`>",1
+openssl,read_key,1,0,0,any,1
+openssl,read_key,2,0,0,logical,1
+openssl,read_pubkey,-1,0,0,"class<`ecdsa`, `pubkey`>",1
+openssl,read_pubkey,-1,0,1,"class<`ed25519`, `pubkey`>",1
+openssl,read_pubkey,-1,0,2,"class<`pubkey`, `rsa`>",1
+openssl,read_pubkey,-1,0,3,"class<`pubkey`, `x25519`>",1
+openssl,read_pubkey,0,0,0,character,1
+openssl,read_pubkey,0,0,1,"class<`ecdsa`, `pubkey`>",1
+openssl,read_pubkey,0,0,2,raw[],1
+openssl,read_pubkey,0,0,3,"class<`ed25519`, `pubkey`>",1
+openssl,read_pubkey,0,0,4,"class<`pubkey`, `rsa`>",1
+openssl,read_pubkey,0,0,5,"class<`pubkey`, `x25519`>",1
+openssl,read_pubkey,1,0,0,logical,1
+openssl,read_raw_key_ed25519,-1,0,0,raw[],1
+openssl,read_raw_key_ed25519,0,0,0,raw[],1
+openssl,read_raw_pubkey_ed25519,-1,0,0,raw[],1
+openssl,read_raw_pubkey_ed25519,0,0,0,raw[],1
+openssl,rsa_decrypt,-1,0,0,raw[],1
+openssl,rsa_decrypt,0,0,0,raw[],1
+openssl,rsa_decrypt,1,0,0,"class<`key`, `rsa`>",1
+openssl,rsa_decrypt,2,0,0,any,1
+openssl,rsa_encrypt,-1,0,0,raw[],1
+openssl,rsa_encrypt,0,0,0,raw[],1
+openssl,rsa_encrypt,1,0,0,"class<`pubkey`, `rsa`>",1
+openssl,rsa_keygen,-1,0,0,"class<`key`, `rsa`>",1
+openssl,rsa_keygen,0,0,0,double,1
+openssl,sha1,-1,0,0,"class<`hash`, `hmac`, `sha1`>",1
+openssl,sha1,-1,0,1,"class<`hash`, `sha1`>",1
+openssl,sha1,0,0,0,character,1
+openssl,sha1,0,0,1,class<`cert`>,1
+openssl,sha1,1,0,0,character,1
+openssl,sha1,1,0,1,null,1
+openssl,sha256,-1,0,0,"class<`hash`, `hmac`, `sha256`>",1
+openssl,sha256,-1,0,1,"class<`hash`, `sha256`>",1
+openssl,sha256,0,0,0,character[],1
+openssl,sha256,0,0,1,raw[],1
+openssl,sha256,1,0,0,character,1
+openssl,sha256,1,0,1,null,1
+openssl,signature_create,-1,0,0,raw[],1
+openssl,signature_create,0,0,0,character,1
+openssl,signature_create,0,0,1,"class<`hash`, `md5`>",1
+openssl,signature_create,0,0,2,raw[],1
+openssl,signature_create,1,0,0,class<`function`>,1
+openssl,signature_create,1,0,1,null,1
+openssl,signature_create,2,0,0,"class<`key`, `rsa`>",1
+openssl,signature_create,2,0,1,"class<`ecdsa`, `key`>",1
+openssl,signature_create,3,0,0,any,1
+openssl,signature_verify,-1,0,0,logical,1
+openssl,signature_verify,0,0,0,character,1
+openssl,signature_verify,0,0,1,"class<`hash`, `md5`>",1
+openssl,signature_verify,0,0,2,raw[],1
+openssl,signature_verify,1,0,0,raw[],1
+openssl,signature_verify,2,0,0,class<`function`>,1
+openssl,signature_verify,2,0,1,null,1
+openssl,signature_verify,3,0,0,"class<`pubkey`, `rsa`>",1
+openssl,signature_verify,3,0,1,"class<`ecdsa`, `pubkey`>",1
+openssl,split_pem,-1,0,0,character[],1
+openssl,split_pem,0,0,0,raw[],1
+openssl,ssh_build_pubkey,-1,0,0,"class<`ecdsa`, `pubkey`>",1
+openssl,ssh_build_pubkey,0,0,0,raw[],1
+openssl,ssh_parse_data,-1,0,0,list<raw[]>,1
+openssl,ssh_parse_data,0,0,0,raw[],1
+openssl,ssh_pubkey_from_string,-1,0,0,"class<`ecdsa`, `pubkey`>",1
+openssl,ssh_pubkey_from_string,0,0,0,character,1
+openssl,stopifnot,-1,0,0,null,1
+openssl,stopifnot,0,0,0,...,1
+openssl,stringhash,-1,0,0,character[],1
+openssl,stringhash,0,0,0,character[],1
+openssl,stringhash,1,0,0,character,1
+openssl,stringhash,2,0,0,null,1
+openssl,stringhash,2,0,1,raw[],1
+openssl,validate_openssh,-1,0,0,logical,1
+openssl,validate_openssh,0,0,0,character,1
+openssl,write_der,-1,0,0,raw[],1
+openssl,write_der,0,0,0,"class<`ecdsa`, `pubkey`>",1
+openssl,write_der,1,0,0,null,1
+openssl,write_pem,-1,0,0,character,1
+openssl,write_pem,0,0,0,class<`cert`>,1
+openssl,write_pem,0,0,1,"class<`ecdsa`, `key`>",1
+openssl,write_pem,0,0,2,"class<`ecdsa`, `pubkey`>",1
+openssl,write_pem,0,0,3,"class<`key`, `rsa`>",1
+openssl,write_pem,0,0,4,"class<`pubkey`, `rsa`>",1
+openssl,write_pem,1,0,0,null,1
+openssl,write_pem,1,0,1,character,1
+openssl,write_pem,2,0,0,null,1
+openssl,write_pem,2,0,1,character,1
+openssl,write_raw_key,-1,0,0,raw[],1
+openssl,write_raw_key,0,0,0,"class<`ed25519`, `key`>",1
+openssl,write_raw_key,0,0,1,"class<`key`, `x25519`>",1
+openssl,write_raw_pubkey,-1,0,0,raw[],1
+openssl,write_raw_pubkey,0,0,0,"class<`ed25519`, `pubkey`>",1
+openssl,write_raw_pubkey,0,0,1,"class<`pubkey`, `x25519`>",1
+openssl,write_ssh,-1,0,0,character,1
+openssl,write_ssh,0,0,0,"class<`ecdsa`, `pubkey`>",1
+openssl,write_ssh,0,0,1,"class<`pubkey`, `rsa`>",1
+openssl,write_ssh,1,0,0,null,1
+openssl,write_ssh,1,0,1,character,1
+openssl,x25519_diffie_hellman,-1,0,0,raw[],1
+openssl,x25519_diffie_hellman,0,0,0,"class<`key`, `x25519`>",1
+openssl,x25519_diffie_hellman,1,0,0,"class<`pubkey`, `x25519`>",1
+openssl,x25519_keygen,-1,0,0,"class<`key`, `x25519`>",1
+openxlsx,addFilter,-1,0,0,class<`Workbook`>,1
+openxlsx,addFilter,0,0,0,class<`Workbook`>,1
+openxlsx,addFilter,1,0,0,double,1
+openxlsx,addFilter,2,0,0,double,1
+openxlsx,addFilter,3,0,0,integer[],1
+openxlsx,addStyle,-1,0,0,list<list<any>>,1
+openxlsx,addStyle,0,0,0,class<`Workbook`>,1
+openxlsx,addStyle,1,0,0,double,1
+openxlsx,addStyle,1,0,1,character,1
+openxlsx,addStyle,2,0,0,class<`Style`>,1
+openxlsx,addStyle,3,0,0,double,1
+openxlsx,addStyle,3,0,1,integer[],1
+openxlsx,addStyle,4,0,0,double[],1
+openxlsx,addStyle,5,0,0,logical,1
+openxlsx,addStyle,6,0,0,logical,1
+openxlsx,addWorksheet,-1,0,0,integer,1
+openxlsx,addWorksheet,0,0,0,class<`Workbook`>,1
+openxlsx,addWorksheet,1,0,0,character,1
+openxlsx,addWorksheet,2,0,0,logical,1
+openxlsx,addWorksheet,3,0,0,character,1
+openxlsx,addWorksheet,3,0,1,null,1
+openxlsx,addWorksheet,4,0,0,double,1
+openxlsx,addWorksheet,5,0,0,null,1
+openxlsx,addWorksheet,5,0,1,character[],1
+openxlsx,addWorksheet,6,0,0,null,1
+openxlsx,addWorksheet,6,0,1,^character[],1
+openxlsx,addWorksheet,7,0,0,null,1
+openxlsx,addWorksheet,7,0,1,character[],1
+openxlsx,build_cell_merges,-1,0,0,list<any>,1
+openxlsx,build_cell_merges,0,0,0,list<any>,1
+openxlsx,build_cell_types_integer,-1,0,0,^integer[],1
+openxlsx,build_cell_types_integer,-1,0,1,null,1
+openxlsx,build_cell_types_integer,0,0,0,character[],1
+openxlsx,build_cell_types_integer,1,0,0,integer,1
+openxlsx,buildFillList,-1,0,0,list<character | list<character[]>>,1
+openxlsx,buildFillList,0,0,0,character[],1
+openxlsx,buildFontList,-1,0,0,list<list<character>>,1
+openxlsx,buildFontList,0,0,0,character[],1
+openxlsx,build_table_xml,-1,0,0,character,1
+openxlsx,build_table_xml,0,0,0,character,1
+openxlsx,build_table_xml,1,0,0,character,1
+openxlsx,build_table_xml,2,0,0,character,1
+openxlsx,build_table_xml,3,0,0,character[],1
+openxlsx,build_table_xml,4,0,0,logical,1
+openxlsx,build_table_xml,5,0,0,logical,1
+openxlsx,classStyles,-1,0,0,double,1
+openxlsx,classStyles,0,0,0,class<`Workbook`>,1
+openxlsx,classStyles,1,0,0,character,1
+openxlsx,classStyles,1,0,1,double,1
+openxlsx,classStyles,2,0,0,integer,1
+openxlsx,classStyles,3,0,0,double,1
+openxlsx,classStyles,4,0,0,logical,1
+openxlsx,classStyles,5,0,0,integer,1
+openxlsx,classStyles,6,0,0,list<character[]>,1
+openxlsx,classStyles,7,0,0,any,1
+openxlsx,cloneWorksheet,-1,0,0,integer,1
+openxlsx,cloneWorksheet,0,0,0,class<`Workbook`>,1
+openxlsx,cloneWorksheet,1,0,0,character,1
+openxlsx,cloneWorksheet,2,0,0,character,1
+openxlsx,col2hex,-1,0,0,character[],1
+openxlsx,col2hex,0,0,0,character[],1
+openxlsx,conditionalFormatting,-1,0,0,double,1
+openxlsx,conditionalFormatting,0,0,0,class<`Workbook`>,1
+openxlsx,conditionalFormatting,1,0,0,character,1
+openxlsx,conditionalFormatting,2,0,0,double,1
+openxlsx,conditionalFormatting,2,0,1,integer[],1
+openxlsx,conditionalFormatting,3,0,0,integer[],1
+openxlsx,conditionalFormatting,4,0,0,character,1
+openxlsx,conditionalFormatting,4,0,1,double[],1
+openxlsx,conditionalFormatting,4,0,2,null,1
+openxlsx,conditionalFormatting,5,0,0,class<`Style`>,1
+openxlsx,conditionalFormatting,5,0,1,null,1
+openxlsx,conditionalFormatting,5,0,2,character[],1
+openxlsx,conditionalFormatting,6,0,0,character,1
+openxlsx,conditionalFormatting,7,0,0,...,1
+openxlsx,convert_from_excel_ref,-1,0,0,integer[],1
+openxlsx,convert_from_excel_ref,0,0,0,character[],1
+openxlsx,convertFromExcelRef,-1,0,0,integer[],1
+openxlsx,convertFromExcelRef,0,0,0,character[],1
+openxlsx,convertFromExcelRef,0,0,1,double[],1
+openxlsx,convertToDate,-1,0,0,class<`Date`>,1
+openxlsx,convertToDate,0,0,0,^double[],1
+openxlsx,convertToDate,1,0,0,character,1
+openxlsx,convertToDate,2,0,0,...,1
+openxlsx,convertToDateTime,-1,0,0,"class<`POSIXct`, `POSIXt`>",1
+openxlsx,convertToDateTime,0,0,0,^double[],1
+openxlsx,convertToDateTime,1,0,0,character,1
+openxlsx,convertToDateTime,2,0,0,...,1
+openxlsx,convert_to_excel_ref,-1,0,0,character[],1
+openxlsx,convert_to_excel_ref,0,0,0,double[],1
+openxlsx,convert_to_excel_ref,1,0,0,character[],1
+openxlsx,convert_to_excel_ref_expand,-1,0,0,character[],1
+openxlsx,convert_to_excel_ref_expand,0,0,0,double,1
+openxlsx,convert_to_excel_ref_expand,1,0,0,character[],1
+openxlsx,convert_to_excel_ref_expand,2,0,0,character[],1
+openxlsx,copyWorkbook,-1,0,0,class<`Workbook`>,1
+openxlsx,copyWorkbook,0,0,0,class<`Workbook`>,1
+openxlsx,cppReadFile,-1,0,0,character,1
+openxlsx,cppReadFile,0,0,0,character,1
+openxlsx,createComment,-1,0,0,class<`Comment`>,1
+openxlsx,createComment,0,0,0,character[],1
+openxlsx,createComment,1,0,0,character,1
+openxlsx,createComment,2,0,0,list<class<`Style`>>,1
+openxlsx,createComment,2,0,1,null,1
+openxlsx,createComment,3,0,0,logical,1
+openxlsx,createComment,4,0,0,double,1
+openxlsx,createComment,5,0,0,double,1
+openxlsx,createNamedRegion,-1,0,0,character,1
+openxlsx,createNamedRegion,0,0,0,class<`Workbook`>,1
+openxlsx,createNamedRegion,1,0,0,double,1
+openxlsx,createNamedRegion,2,0,0,integer[],1
+openxlsx,createNamedRegion,3,0,0,integer[],1
+openxlsx,createNamedRegion,4,0,0,character,1
+openxlsx,createStyle,-1,0,0,class<`Style`>,1
+openxlsx,createStyle,0,0,0,character,1
+openxlsx,createStyle,0,0,1,null,1
+openxlsx,createStyle,1,0,0,double,1
+openxlsx,createStyle,1,0,1,null,1
+openxlsx,createStyle,2,0,0,character,1
+openxlsx,createStyle,2,0,1,null,1
+openxlsx,createStyle,3,0,0,character,1
+openxlsx,createStyle,4,0,0,null,1
+openxlsx,createStyle,4,0,1,character,1
+openxlsx,createStyle,5,0,0,character[],1
+openxlsx,createStyle,6,0,0,character,1
+openxlsx,createStyle,7,0,0,null,1
+openxlsx,createStyle,7,0,1,character,1
+openxlsx,createWorkbook,-1,0,0,class<`Workbook`>,1
+openxlsx,createWorkbook,0,0,0,character,1
+openxlsx,createWorkbook,1,0,0,character,1
+openxlsx,createWorkbook,1,0,1,null,1
+openxlsx,createWorkbook,2,0,0,character,1
+openxlsx,createWorkbook,2,0,1,null,1
+openxlsx,createWorkbook,3,0,0,character,1
+openxlsx,createWorkbook,3,0,1,null,1
+openxlsx,dataValidation,-1,0,0,double,1
+openxlsx,dataValidation,0,0,0,class<`Workbook`>,1
+openxlsx,dataValidation,1,0,0,double,1
+openxlsx,dataValidation,2,0,0,double,1
+openxlsx,dataValidation,2,0,1,integer[],1
+openxlsx,dataValidation,3,0,0,integer[],1
+openxlsx,dataValidation,4,0,0,character,1
+openxlsx,dataValidation,5,0,0,any,1
+openxlsx,dataValidation,6,0,0,class<`Date`>,1
+openxlsx,dataValidation,6,0,1,"class<`POSIXct`, `POSIXt`>",1
+openxlsx,dataValidation,6,0,2,double[],1
+openxlsx,dataValidation,6,0,3,character,1
+openxlsx,dataValidation,7,0,0,logical,1
+openxlsx,deleteData,-1,0,0,double,1
+openxlsx,deleteData,0,0,0,class<`Workbook`>,1
+openxlsx,deleteData,1,0,0,double,1
+openxlsx,deleteData,2,0,0,character[],1
+openxlsx,deleteData,2,0,1,double[],1
+openxlsx,deleteData,3,0,0,double[],1
+openxlsx,deleteData,4,0,0,logical,1
+openxlsx,freezePane,-1,0,0,character,1
+openxlsx,freezePane,0,0,0,class<`Workbook`>,1
+openxlsx,freezePane,1,0,0,character,1
+openxlsx,freezePane,1,0,1,double,1
+openxlsx,freezePane,2,0,0,double,1
+openxlsx,freezePane,2,0,1,null,1
+openxlsx,freezePane,3,0,0,double,1
+openxlsx,freezePane,3,0,1,null,1
+openxlsx,freezePane,3,0,2,character,1
+openxlsx,freezePane,4,0,0,logical,1
+openxlsx,freezePane,5,0,0,logical,1
+openxlsx,genBaseColStyle,-1,0,0,list<class<`Style`> | logical>,1
+openxlsx,genBaseColStyle,0,0,0,character,1
+openxlsx,genBaseContent_Type,-1,0,0,character[],1
+openxlsx,genBaseCore,-1,0,0,character[],1
+openxlsx,genBaseCore,0,0,0,character,1
+openxlsx,genBaseCore,1,0,0,character,1
+openxlsx,genBaseCore,1,0,1,null,1
+openxlsx,genBaseCore,2,0,0,character,1
+openxlsx,genBaseCore,2,0,1,null,1
+openxlsx,genBaseCore,3,0,0,character,1
+openxlsx,genBaseCore,3,0,1,null,1
+openxlsx,genBasePic,-1,0,0,character,1
+openxlsx,genBasePic,0,0,0,integer,1
+openxlsx,genBaseSheetRels,-1,0,0,character[],1
+openxlsx,genBaseSheetRels,0,0,0,integer,1
+openxlsx,genBaseStyleSheet,-1,0,0,list<null | character[]>,1
+openxlsx,genBaseStyleSheet,0,0,0,null,1
+openxlsx,genBaseStyleSheet,1,0,0,null,1
+openxlsx,genBaseStyleSheet,2,0,0,null,1
+openxlsx,genBaseWorkbook,-1,0,0,list<character | null>,1
+openxlsx,genBaseWorkbook.xml.rels,-1,0,0,character[],1
+openxlsx,genClientData,-1,0,0,character,1
+openxlsx,genClientData,0,0,0,double,1
+openxlsx,genClientData,1,0,0,double,1
+openxlsx,genClientData,2,0,0,logical,1
+openxlsx,genClientData,3,0,0,double,1
+openxlsx,genClientData,4,0,0,double,1
+openxlsx,gen_databar_extlst,-1,0,0,character,1
+openxlsx,gen_databar_extlst,0,0,0,character,1
+openxlsx,gen_databar_extlst,1,0,0,character,1
+openxlsx,gen_databar_extlst,2,0,0,character,1
+openxlsx,gen_databar_extlst,3,0,0,character,1
+openxlsx,gen_databar_extlst,4,0,0,null,1
+openxlsx,gen_databar_extlst,5,0,0,double,1
+openxlsx,gen_databar_extlst,6,0,0,double,1
+openxlsx,genSlicerCachesExtLst,-1,0,0,character,1
+openxlsx,genSlicerCachesExtLst,0,0,0,double,1
+openxlsx,getAttrs,-1,0,0,list<character[]>,1
+openxlsx,getAttrs,0,0,0,character[],1
+openxlsx,getAttrs,1,0,0,character,1
+openxlsx,getAttrsFont,-1,0,0,list<character>,1
+openxlsx,getAttrsFont,0,0,0,character[],1
+openxlsx,getAttrsFont,1,0,0,character,1
+openxlsx,getBaseFont,-1,0,0,list<list<character>>,1
+openxlsx,getBaseFont,0,0,0,class<`Workbook`>,1
+openxlsx,getCellInfo,-1,0,0,list<character[] | integer>,1
+openxlsx,getCellInfo,-1,0,1,list<^character[] | integer>,1
+openxlsx,getCellInfo,0,0,0,character,1
+openxlsx,getCellInfo,1,0,0,character[],1
+openxlsx,getCellInfo,2,0,0,logical,1
+openxlsx,getCellInfo,3,0,0,double,1
+openxlsx,getCellInfo,4,0,0,null,1
+openxlsx,getCellInfo,4,0,1,integer[],1
+openxlsx,getCellInfo,5,0,0,logical,1
+openxlsx,getCellRefs,-1,0,0,character[],1
+openxlsx,getCellRefs,0,0,0,class<`data.frame`>,1
+openxlsx,getChildlessNode,-1,0,0,character[],1
+openxlsx,getChildlessNode,0,0,0,character,1
+openxlsx,getChildlessNode,1,0,0,character,1
+openxlsx,getDefinedNamesSheet,-1,0,0,character,1
+openxlsx,getDefinedNamesSheet,0,0,0,character,1
+openxlsx,getFile,-1,0,0,character,1
+openxlsx,getFile,0,0,0,character,1
+openxlsx,getId,-1,0,0,list<character>,1
+openxlsx,getId,0,0,0,character[],1
+openxlsx,getNodes,-1,0,0,character[],1
+openxlsx,getNodes,0,0,0,character,1
+openxlsx,getNodes,1,0,0,character,1
+openxlsx,getOpenClosedNode,-1,0,0,character,1
+openxlsx,getOpenClosedNode,0,0,0,character,1
+openxlsx,getOpenClosedNode,1,0,0,character,1
+openxlsx,getOpenClosedNode,2,0,0,character,1
+openxlsx,getRId,-1,0,0,list<character>,1
+openxlsx,getRId,0,0,0,character[],1
+openxlsx,get_shared_strings,-1,0,0,character[],1
+openxlsx,get_shared_strings,0,0,0,character,1
+openxlsx,get_shared_strings,1,0,0,logical,1
+openxlsx,getSharedStringsFromFile,-1,0,0,character[],1
+openxlsx,getSharedStringsFromFile,0,0,0,character,1
+openxlsx,getSharedStringsFromFile,1,0,0,logical,1
+openxlsx,getSheetNames,-1,0,0,character[],1
+openxlsx,getSheetNames,0,0,0,character,1
+openxlsx,getStyles,-1,0,0,list<class<`Style`>>,1
+openxlsx,getStyles,0,0,0,class<`Workbook`>,1
+openxlsx,getTables,-1,0,0,character[],1
+openxlsx,getTables,0,0,0,class<`Workbook`>,1
+openxlsx,getTables,1,0,0,character,1
+openxlsx,getTables,1,0,1,double,1
+openxlsx,hashPassword,-1,0,0,character,1
+openxlsx,hashPassword,0,0,0,character,1
+openxlsx,headerFooterSub,-1,0,0,^character[],1
+openxlsx,headerFooterSub,-1,0,1,null,1
+openxlsx,headerFooterSub,0,0,0,^character[],1
+openxlsx,headerFooterSub,0,0,1,null,1
+openxlsx,insertImage,-1,0,0,list<character>,1
+openxlsx,insertImage,0,0,0,class<`Workbook`>,1
+openxlsx,insertImage,1,0,0,character,1
+openxlsx,insertImage,1,0,1,double,1
+openxlsx,insertImage,2,0,0,character,1
+openxlsx,insertImage,3,0,0,double,1
+openxlsx,insertImage,4,0,0,double,1
+openxlsx,insertImage,5,0,0,double,1
+openxlsx,insertImage,6,0,0,double,1
+openxlsx,insertImage,6,0,1,character,1
+openxlsx,insertImage,7,0,0,character,1
+openxlsx,int2col,-1,0,0,character[],1
+openxlsx,int2col,0,0,0,integer[],1
+openxlsx,loadWorkbook,-1,0,0,class<`Workbook`>,1
+openxlsx,loadWorkbook,0,0,0,character,1
+openxlsx,loadWorkbook,1,0,0,null,1
+openxlsx,loadWorkbook,2,0,0,logical,1
+openxlsx,loadworksheets,-1,0,0,class<`Workbook`>,1
+openxlsx,loadworksheets,0,0,0,class<`Workbook`>,1
+openxlsx,loadworksheets,1,0,0,list<class<`Style`>>,1
+openxlsx,loadworksheets,2,0,0,character[],1
+openxlsx,loadworksheets,3,0,0,logical[],1
+openxlsx,mergeCells,-1,0,0,character[],1
+openxlsx,mergeCells,0,0,0,class<`Workbook`>,1
+openxlsx,mergeCells,1,0,0,double,1
+openxlsx,mergeCells,1,0,1,character,1
+openxlsx,mergeCells,2,0,0,double[],1
+openxlsx,mergeCells,3,0,0,double,1
+openxlsx,mergeCells,3,0,1,integer[],1
+openxlsx,modifyBaseFont,-1,0,0,character,1
+openxlsx,modifyBaseFont,0,0,0,class<`Workbook`>,1
+openxlsx,modifyBaseFont,1,0,0,double,1
+openxlsx,modifyBaseFont,2,0,0,character,1
+openxlsx,modifyBaseFont,3,0,0,character,1
+openxlsx,names<-.Workbook,-1,0,0,class<`Workbook`>,1
+openxlsx,names<-.Workbook,0,0,0,class<`Workbook`>,1
+openxlsx,names<-.Workbook,1,0,0,character[],1
+openxlsx,names.Workbook,-1,0,0,character[],1
+openxlsx,names.Workbook,0,0,0,class<`Workbook`>,1
+openxlsx,openxlsxCoerce,-1,0,0,class<`data.frame`>,1
+openxlsx,openxlsxCoerce,0,0,0,class<`data.frame`>,1
+openxlsx,openxlsxCoerce,0,0,1,class<`matrix`>,1
+openxlsx,openxlsxCoerce,0,0,2,character[],1
+openxlsx,openxlsxCoerce,0,0,3,class<`hyperlink`>,1
+openxlsx,openxlsxCoerce,0,0,4,double[],1
+openxlsx,openxlsxCoerce,1,0,0,any,1
+openxlsx,openxlsxCoerce.data.frame,-1,0,0,class<`data.frame`>,1
+openxlsx,openxlsxCoerce.data.frame,0,0,0,class<`data.frame`>,1
+openxlsx,openxlsxCoerce.data.frame,1,0,0,logical,1
+openxlsx,openxlsxCoerce.default,-1,0,0,class<`data.frame`>,1
+openxlsx,openxlsxCoerce.default,0,0,0,character[],1
+openxlsx,openxlsxCoerce.default,0,0,1,double[],1
+openxlsx,openxlsxCoerce.default,1,0,0,any,1
+openxlsx,openxlsxCoerce.hyperlink,-1,0,0,class<`data.frame`>,1
+openxlsx,openxlsxCoerce.hyperlink,0,0,0,class<`hyperlink`>,1
+openxlsx,openxlsxCoerce.hyperlink,1,0,0,any,1
+openxlsx,openxlsxCoerce.matrix,-1,0,0,class<`data.frame`>,1
+openxlsx,openxlsxCoerce.matrix,0,0,0,class<`matrix`>,1
+openxlsx,openxlsxCoerce.matrix,1,0,0,logical,1
+openxlsx,pageBreak,-1,0,0,class<`Workbook`>,1
+openxlsx,pageBreak,0,0,0,class<`Workbook`>,1
+openxlsx,pageBreak,1,0,0,double,1
+openxlsx,pageBreak,2,0,0,double,1
+openxlsx,pageBreak,3,0,0,character,1
+openxlsx,pageSetup,-1,0,0,character[],1
+openxlsx,pageSetup,-1,0,1,null,1
+openxlsx,pageSetup,0,0,0,class<`Workbook`>,1
+openxlsx,pageSetup,1,0,0,character,1
+openxlsx,pageSetup,1,0,1,double,1
+openxlsx,pageSetup,2,0,0,null,1
+openxlsx,pageSetup,2,0,1,character,1
+openxlsx,pageSetup,3,0,0,double,1
+openxlsx,pageSetup,4,0,0,double,1
+openxlsx,pageSetup,5,0,0,double,1
+openxlsx,pageSetup,6,0,0,double,1
+openxlsx,pageSetup,7,0,0,double,1
+openxlsx,protectWorkbook,-1,0,0,character,1
+openxlsx,protectWorkbook,0,0,0,class<`Workbook`>,1
+openxlsx,protectWorkbook,1,0,0,logical,1
+openxlsx,protectWorkbook,2,0,0,character,1
+openxlsx,protectWorkbook,2,0,1,null,1
+openxlsx,protectWorkbook,3,0,0,logical,1
+openxlsx,protectWorkbook,4,0,0,logical,1
+openxlsx,protectWorksheet,-1,0,0,character,1
+openxlsx,protectWorksheet,0,0,0,class<`Workbook`>,1
+openxlsx,protectWorksheet,1,0,0,character,1
+openxlsx,protectWorksheet,2,0,0,logical,1
+openxlsx,protectWorksheet,3,0,0,null,1
+openxlsx,protectWorksheet,4,0,0,null,1
+openxlsx,protectWorksheet,5,0,0,null,1
+openxlsx,protectWorksheet,6,0,0,logical,1
+openxlsx,protectWorksheet,6,0,1,null,1
+openxlsx,protectWorksheet,7,0,0,logical,1
+openxlsx,protectWorksheet,7,0,1,null,1
+openxlsx,read_workbook,-1,0,0,class<`data.frame`>,1
+openxlsx,read_workbook,0,0,0,integer[],1
+openxlsx,read_workbook,1,0,0,integer[],1
+openxlsx,read_workbook,2,0,0,character[],1
+openxlsx,read_workbook,3,0,0,integer[],1
+openxlsx,read_workbook,4,0,0,null,1
+openxlsx,read_workbook,5,0,0,logical,1
+openxlsx,read_workbook,6,0,0,character,1
+openxlsx,read_workbook,7,0,0,logical,1
+openxlsx,readWorkbook,-1,0,0,class<`data.frame`>,1
+openxlsx,readWorkbook,0,0,0,character,1
+openxlsx,readWorkbook,1,0,0,double,1
+openxlsx,readWorkbook,2,0,0,double,1
+openxlsx,readWorkbook,3,0,0,logical,1
+openxlsx,readWorkbook,4,0,0,logical,1
+openxlsx,readWorkbook,5,0,0,logical,1
+openxlsx,readWorkbook,6,0,0,logical,1
+openxlsx,readWorkbook,7,0,0,logical,1
+openxlsx,read.xlsx,-1,0,0,class<`data.frame`>,1
+openxlsx,read.xlsx,0,0,0,character,1
+openxlsx,read.xlsx,1,0,0,double,1
+openxlsx,read.xlsx,2,0,0,double,1
+openxlsx,read.xlsx,3,0,0,logical,1
+openxlsx,read.xlsx,4,0,0,logical,1
+openxlsx,read.xlsx,5,0,0,logical,1
+openxlsx,read.xlsx,6,0,0,logical,1
+openxlsx,read.xlsx,7,0,0,logical,1
+openxlsx,read.xlsx.default,-1,0,0,class<`data.frame`>,1
+openxlsx,read.xlsx.default,0,0,0,character,1
+openxlsx,read.xlsx.default,1,0,0,double,1
+openxlsx,read.xlsx.default,2,0,0,double,1
+openxlsx,read.xlsx.default,3,0,0,logical,1
+openxlsx,read.xlsx.default,4,0,0,logical,1
+openxlsx,read.xlsx.default,5,0,0,logical,1
+openxlsx,read.xlsx.default,6,0,0,logical,1
+openxlsx,read.xlsx.default,7,0,0,logical,1
+openxlsx,removeCellMerge,-1,0,0,character[],1
+openxlsx,removeCellMerge,0,0,0,class<`Workbook`>,1
+openxlsx,removeCellMerge,1,0,0,double,1
+openxlsx,removeCellMerge,2,0,0,double,1
+openxlsx,removeCellMerge,3,0,0,double,1
+openxlsx,removeColWidths,-1,0,0,list<any>,1
+openxlsx,removeColWidths,0,0,0,class<`Workbook`>,1
+openxlsx,removeColWidths,1,0,0,double,1
+openxlsx,removeColWidths,2,0,0,integer[],1
+openxlsx,removeFilter,-1,0,0,class<`Workbook`>,1
+openxlsx,removeFilter,0,0,0,class<`Workbook`>,1
+openxlsx,removeFilter,1,0,0,double,1
+openxlsx,removeFilter,1,0,1,integer[],1
+openxlsx,removeHeadTag,-1,0,0,character,1
+openxlsx,removeHeadTag,0,0,0,character[],1
+openxlsx,removeRowHeights,-1,0,0,character[],1
+openxlsx,removeRowHeights,0,0,0,class<`Workbook`>,1
+openxlsx,removeRowHeights,1,0,0,double,1
+openxlsx,removeRowHeights,2,0,0,integer[],1
+openxlsx,removeTable,-1,0,0,double,1
+openxlsx,removeTable,0,0,0,class<`Workbook`>,1
+openxlsx,removeTable,1,0,0,double,1
+openxlsx,removeTable,2,0,0,character,1
+openxlsx,removeWorksheet,-1,0,0,double,1
+openxlsx,removeWorksheet,0,0,0,class<`Workbook`>,1
+openxlsx,removeWorksheet,1,0,0,double,1
+openxlsx,renameWorksheet,-1,0,0,null,1
+openxlsx,renameWorksheet,0,0,0,class<`Workbook`>,1
+openxlsx,renameWorksheet,1,0,0,double,1
+openxlsx,renameWorksheet,2,0,0,character,1
+openxlsx,replaceIllegalCharacters,-1,0,0,^character[],1
+openxlsx,replaceIllegalCharacters,0,0,0,^character[],1
+openxlsx,replaceStyle,-1,0,0,class<`Style`>,1
+openxlsx,replaceStyle,0,0,0,class<`Workbook`>,1
+openxlsx,replaceStyle,1,0,0,double,1
+openxlsx,replaceStyle,2,0,0,class<`Style`>,1
+openxlsx,replaceXMLEntities,-1,0,0,character[],1
+openxlsx,replaceXMLEntities,0,0,0,character[],1
+openxlsx,setColWidths,-1,0,0,double,1
+openxlsx,setColWidths,0,0,0,class<`Workbook`>,1
+openxlsx,setColWidths,1,0,0,character,1
+openxlsx,setColWidths,1,0,1,double,1
+openxlsx,setColWidths,2,0,0,double[],1
+openxlsx,setColWidths,3,0,0,double[],1
+openxlsx,setColWidths,3,0,1,character,1
+openxlsx,setColWidths,4,0,0,logical[],1
+openxlsx,setColWidths,5,0,0,logical,1
+openxlsx,setHeaderFooter,-1,0,0,list<list<any>>,1
+openxlsx,setHeaderFooter,0,0,0,class<`Workbook`>,1
+openxlsx,setHeaderFooter,1,0,0,double,1
+openxlsx,setHeaderFooter,1,0,1,character,1
+openxlsx,setHeaderFooter,2,0,0,null,1
+openxlsx,setHeaderFooter,2,0,1,character[],1
+openxlsx,setHeaderFooter,3,0,0,null,1
+openxlsx,setHeaderFooter,3,0,1,^character[],1
+openxlsx,setHeaderFooter,4,0,0,null,1
+openxlsx,setHeaderFooter,4,0,1,character[],1
+openxlsx,setHeaderFooter,5,0,0,null,1
+openxlsx,setHeaderFooter,5,0,1,character[],1
+openxlsx,setHeaderFooter,6,0,0,^character[],1
+openxlsx,setHeaderFooter,6,0,1,null,1
+openxlsx,setHeaderFooter,7,0,0,^character[],1
+openxlsx,setHeaderFooter,7,0,1,null,1
+openxlsx,setRowHeights,-1,0,0,character[],1
+openxlsx,setRowHeights,0,0,0,class<`Workbook`>,1
+openxlsx,setRowHeights,1,0,0,character,1
+openxlsx,setRowHeights,1,0,1,double,1
+openxlsx,setRowHeights,2,0,0,double[],1
+openxlsx,setRowHeights,3,0,0,double[],1
+openxlsx,sheetVisibility,-1,0,0,character[],1
+openxlsx,sheetVisibility,0,0,0,class<`Workbook`>,1
+openxlsx,sheetVisibility<-,-1,0,0,class<`Workbook`>,1
+openxlsx,sheetVisibility<-,0,0,0,class<`Workbook`>,1
+openxlsx,sheetVisibility<-,1,0,0,character[],1
+openxlsx,sheetVisible,-1,0,0,logical[],1
+openxlsx,sheetVisible,0,0,0,class<`Workbook`>,1
+openxlsx,sheetVisible<-,-1,0,0,class<`Workbook`>,1
+openxlsx,sheetVisible<-,0,0,0,class<`Workbook`>,1
+openxlsx,sheetVisible<-,1,0,0,logical[],1
+openxlsx,showGridLines,-1,0,0,character,1
+openxlsx,showGridLines,0,0,0,class<`Workbook`>,1
+openxlsx,showGridLines,1,0,0,character,1
+openxlsx,showGridLines,1,0,1,double,1
+openxlsx,showGridLines,2,0,0,logical,1
+openxlsx,validateBorderStyle,-1,0,0,character,1
+openxlsx,validateBorderStyle,0,0,0,character,1
+openxlsx,validateColour,-1,0,0,character[],1
+openxlsx,validateColour,0,0,0,character[],1
+openxlsx,validateColour,1,0,0,character,1
+openxlsx,worksheetOrder,-1,0,0,integer[],1
+openxlsx,worksheetOrder,0,0,0,class<`Workbook`>,1
+openxlsx,worksheetOrder<-,-1,0,0,class<`Workbook`>,1
+openxlsx,worksheetOrder<-,0,0,0,class<`Workbook`>,1
+openxlsx,worksheetOrder<-,1,0,0,double[],1
+openxlsx,writeComment,-1,0,0,class<`Workbook`>,1
+openxlsx,writeComment,0,0,0,class<`Workbook`>,1
+openxlsx,writeComment,1,0,0,double,1
+openxlsx,writeComment,2,0,0,character,1
+openxlsx,writeComment,2,0,1,double,1
+openxlsx,writeComment,3,0,0,double,1
+openxlsx,writeComment,4,0,0,class<`Comment`>,1
+openxlsx,writeComment,5,0,0,null,1
+openxlsx,writeData,-1,0,0,double,1
+openxlsx,writeData,0,0,0,class<`Workbook`>,1
+openxlsx,writeData,1,0,0,character,1
+openxlsx,writeData,1,0,1,double,1
+openxlsx,writeData,2,0,0,character[],1
+openxlsx,writeData,2,0,1,class<`data.frame`>,1
+openxlsx,writeData,2,0,2,class<`hyperlink`>,1
+openxlsx,writeData,2,0,3,"class<`character`, `formula`>",1
+openxlsx,writeData,2,0,4,class<`matrix`>,1
+openxlsx,writeData,2,0,5,double[],1
+openxlsx,writeData,3,0,0,double,1
+openxlsx,writeData,3,0,1,character,1
+openxlsx,writeData,4,0,0,double,1
+openxlsx,writeData,5,0,0,null,1
+openxlsx,writeData,5,0,1,character[],1
+openxlsx,writeData,6,0,0,logical,1
+openxlsx,writeData,7,0,0,logical,1
+openxlsx,writeDataTable,-1,0,0,character[],1
+openxlsx,writeDataTable,0,0,0,class<`Workbook`>,1
+openxlsx,writeDataTable,1,0,0,character,1
+openxlsx,writeDataTable,1,0,1,double,1
+openxlsx,writeDataTable,2,0,0,class<`data.frame`>,1
+openxlsx,writeDataTable,3,0,0,double,1
+openxlsx,writeDataTable,4,0,0,double,1
+openxlsx,writeDataTable,5,0,0,null,1
+openxlsx,writeDataTable,5,0,1,character[],1
+openxlsx,writeDataTable,6,0,0,logical,1
+openxlsx,writeDataTable,7,0,0,logical,1
+openxlsx,writeFormula,-1,0,0,double,1
+openxlsx,writeFormula,0,0,0,class<`Workbook`>,1
+openxlsx,writeFormula,1,0,0,character,1
+openxlsx,writeFormula,1,0,1,double,1
+openxlsx,writeFormula,2,0,0,character[],1
+openxlsx,writeFormula,3,0,0,double,1
+openxlsx,writeFormula,4,0,0,double,1
+openxlsx,writeFormula,5,0,0,null,1
+openxlsx,xml_to_hyperlink,-1,0,0,list<any>,1
+openxlsx,xml_to_hyperlink,0,0,0,list<any>,1
+openxlsx,xml_to_hyperlink,0,0,1,character[],1
+optimx,as.data.frame.opm,-1,0,0,class<`data.frame`>,1
+optimx,as.data.frame.opm,0,0,0,"class<`data.frame`, `opm`>",1
+optimx,as.data.frame.opm,0,0,1,"class<`data.frame`, `optimx`>",1
+optimx,as.data.frame.opm,1,0,0,null,1
+optimx,as.data.frame.opm,2,0,0,logical,1
+optimx,as.data.frame.opm,3,0,0,...,1
+optimx,as.data.frame.optimx,-1,0,0,class<`data.frame`>,1
+optimx,as.data.frame.optimx,0,0,0,"class<`data.frame`, `opm`>",1
+optimx,as.data.frame.optimx,0,0,1,"class<`data.frame`, `optimx`>",1
+optimx,as.data.frame.optimx,1,0,0,null,1
+optimx,as.data.frame.optimx,2,0,0,logical,1
+optimx,as.data.frame.optimx,3,0,0,...,1
+optimx,axsearch,-1,0,0,list<double[] | class<`data.frame`>>,1
+optimx,axsearch,0,0,0,double[],1
+optimx,axsearch,1,0,0,class<`function`>,1
+optimx,axsearch,2,0,0,double,1
+optimx,axsearch,3,0,0,double[],1
+optimx,axsearch,4,0,0,double[],1
+optimx,axsearch,5,0,0,null,1
+optimx,axsearch,6,0,0,double,1
+optimx,axsearch,7,0,0,...,1
+optimx,bmchk,-1,0,0,list<double[] | character[]>,1
+optimx,bmchk,-1,0,1,list<double | character>,1
+optimx,bmchk,0,0,0,double[],1
+optimx,bmchk,1,0,0,double[],1
+optimx,bmchk,1,0,1,null,1
+optimx,bmchk,2,0,0,double[],1
+optimx,bmchk,2,0,1,null,1
+optimx,bmchk,3,0,0,double[],1
+optimx,bmchk,3,0,1,null,1
+optimx,bmchk,4,0,0,double,1
+optimx,bmchk,5,0,0,double,1
+optimx,bmchk,5,0,1,null,1
+optimx,bmchk,6,0,0,any,1
+optimx,bmstep,-1,0,0,double,1
+optimx,bmstep,0,0,0,double[],1
+optimx,bmstep,1,0,0,double[],1
+optimx,bmstep,2,0,0,double[],1
+optimx,bmstep,3,0,0,double[],1
+optimx,bmstep,4,0,0,double[],1
+optimx,bmstep,5,0,0,double,1
+optimx,checksolver,-1,0,0,character,1
+optimx,checksolver,-1,0,1,null,1
+optimx,checksolver,0,0,0,character,1
+optimx,checksolver,1,0,0,character[],1
+optimx,checksolver,2,0,0,any,1
+optimx,cnvtst,-1,0,0,list<double[]>,1
+optimx,cnvtst,0,0,0,any,1
+optimx,cnvtst,1,0,0,any,1
+optimx,cnvtst,2,0,0,any,1
+optimx,cnvtst,3,0,0,any,1
+optimx,cnvtst,4,0,0,any,1
+optimx,cnvtst,5,0,0,any,1
+optimx,cnvtst,6,0,0,double,1
+optimx,cnvtst,6,0,1,class<`matrix`>,1
+optimx,cnvtst,7,0,0,double,1
+optimx,cnvtst,8,0,0,double,1
+optimx,cnvtst,9,0,0,any,1
+optimx,cnvtst,10,0,0,double[],1
+optimx,cnvtst,11,0,0,double,1
+optimx,coef.opm,-1,0,0,class<`matrix`>,1
+optimx,coef.opm,0,0,0,"class<`data.frame`, `opm`>",1
+optimx,coef.opm,0,0,1,"class<`data.frame`, `optimx`>",1
+optimx,coef.opm,1,0,0,...,1
+optimx,coef.optimx,-1,0,0,class<`matrix`>,1
+optimx,coef.optimx,0,0,0,"class<`data.frame`, `opm`>",1
+optimx,coef.optimx,0,0,1,"class<`data.frame`, `optimx`>",1
+optimx,coef.optimx,1,0,0,...,1
+optimx,crash,-1,0,0,list<double[]>,1
+optimx,crash,0,0,0,double[],1
+optimx,crash,1,0,0,double[],1
+optimx,crash,2,0,0,double[],1
+optimx,ctrldefault,-1,0,0,list<character[] | double[]>,1
+optimx,ctrldefault,-1,0,1,list<double | character[]>,1
+optimx,ctrldefault,0,0,0,double,1
+optimx,fnchk,-1,0,0,list<double | character>,1
+optimx,fnchk,-1,0,1,list<null | double | character>,1
+optimx,fnchk,0,0,0,double[],1
+optimx,fnchk,1,0,0,class<`function`>,1
+optimx,fnchk,2,0,0,double,1
+optimx,fnchk,3,0,0,...,1
+optimx,gHgen,-1,0,0,list<double[] | class<`matrix`>>,1
+optimx,gHgen,0,0,0,double[],1
+optimx,gHgen,1,0,0,any,1
+optimx,gHgen,2,0,0,class<`function`>,1
+optimx,gHgen,2,0,1,null,1
+optimx,gHgen,3,0,0,class<`function`>,1
+optimx,gHgen,3,0,1,null,1
+optimx,gHgen,4,0,0,list<double>,1
+optimx,gHgen,5,0,0,...,1
+optimx,gHgenb,-1,0,0,list<double[] | class<`matrix`>>,1
+optimx,gHgenb,0,0,0,double[],1
+optimx,gHgenb,1,0,0,any,1
+optimx,gHgenb,2,0,0,class<`function`>,1
+optimx,gHgenb,2,0,1,null,1
+optimx,gHgenb,3,0,0,class<`function`>,1
+optimx,gHgenb,3,0,1,null,1
+optimx,gHgenb,4,0,0,null,1
+optimx,gHgenb,5,0,0,null,1
+optimx,gHgenb,6,0,0,null,1
+optimx,gHgenb,7,0,0,list<double>,1
+optimx,gHgenb,8,0,0,...,1
+optimx,grback,-1,0,0,double[],1
+optimx,grback,0,0,0,double[],1
+optimx,grback,1,0,0,class<`function`>,1
+optimx,grback,2,0,0,null,1
+optimx,grback,3,0,0,environment,1
+optimx,grback,4,0,0,...,1
+optimx,grcentral,-1,0,0,double[],1
+optimx,grcentral,0,0,0,double[],1
+optimx,grcentral,1,0,0,class<`function`>,1
+optimx,grcentral,2,0,0,null,1
+optimx,grcentral,3,0,0,environment,1
+optimx,grcentral,4,0,0,...,1
+optimx,grchk,-1,0,0,logical,1
+optimx,grchk,0,0,0,double[],1
+optimx,grchk,1,0,0,class<`function`>,1
+optimx,grchk,2,0,0,class<`function`>,1
+optimx,grchk,3,0,0,double,1
+optimx,grchk,4,0,0,double,1
+optimx,grchk,5,0,0,...,1
+optimx,grfwd,-1,0,0,double[],1
+optimx,grfwd,0,0,0,double[],1
+optimx,grfwd,1,0,0,class<`function`>,1
+optimx,grfwd,2,0,0,null,1
+optimx,grfwd,3,0,0,environment,1
+optimx,grfwd,4,0,0,...,1
+optimx,grnd,-1,0,0,double[],1
+optimx,grnd,0,0,0,double[],1
+optimx,grnd,1,0,0,class<`function`>,1
+optimx,grnd,2,0,0,...,1
+optimx,gtims,-1,0,0,double[],1
+optimx,gtims,0,0,0,double[],1
+optimx,gtims,1,0,0,double[],1
+optimx,gtims,2,0,0,double[],1
+optimx,gtims,3,0,0,double,1
+optimx,gtims,4,0,0,double,1
+optimx,gtims,5,0,0,class<`function`>,1
+optimx,gtims,6,0,0,...,1
+optimx,hesschk,-1,0,0,logical,1
+optimx,hesschk,0,0,0,double[],1
+optimx,hesschk,1,0,0,class<`function`>,1
+optimx,hesschk,2,0,0,class<`function`>,1
+optimx,hesschk,3,0,0,class<`function`>,1
+optimx,hesschk,4,0,0,double,1
+optimx,hesschk,5,0,0,double,1
+optimx,hesschk,6,0,0,...,1
+optimx,hjn,-1,0,0,any,1
+optimx,hjn,0,0,0,double[],1
+optimx,hjn,1,0,0,any,1
+optimx,hjn,2,0,0,any,1
+optimx,hjn,3,0,0,double[],1
+optimx,hjn,4,0,0,null,1
+optimx,hjn,4,0,1,double[],1
+optimx,hjn,5,0,0,list<double>,1
+optimx,hjn,5,0,1,list<character[] | double[]>,1
+optimx,hjn,6,0,0,...,1
+optimx,initpc,-1,0,0,list<double[]>,1
+optimx,initpc,0,0,0,double[],1
+optimx,initpc,1,0,0,double,1
+optimx,initpc,2,0,0,any,1
+optimx,kktchk,-1,0,0,list<any>,1
+optimx,kktchk,0,0,0,double[],1
+optimx,kktchk,1,0,0,class<`function`>,1
+optimx,kktchk,2,0,0,character,1
+optimx,kktchk,2,0,1,class<`function`>,1
+optimx,kktchk,3,0,0,null,1
+optimx,kktchk,4,0,0,null,1
+optimx,kktchk,4,0,1,double[],1
+optimx,kktchk,5,0,0,null,1
+optimx,kktchk,5,0,1,double[],1
+optimx,kktchk,6,0,0,logical,1
+optimx,kktchk,7,0,0,list<any>,1
+optimx,kktchk,8,0,0,...,1
+optimx,lin1,-1,0,0,list<double[]>,1
+optimx,lin1,0,0,0,double[],1
+optimx,lin1,1,0,0,double[],1
+optimx,lin1,2,0,0,double,1
+optimx,lin1,3,0,0,double,1
+optimx,lin1,4,0,0,double[],1
+optimx,lin1,5,0,0,class<`function`>,1
+optimx,lin1,6,0,0,...,1
+optimx,lmqn,-1,0,0,list<double[]>,1
+optimx,lmqn,0,0,0,double[],1
+optimx,lmqn,1,0,0,class<`function`>,1
+optimx,lmqn,2,0,0,double,1
+optimx,lmqn,3,0,0,double,1
+optimx,lmqn,4,0,0,double,1
+optimx,lmqn,5,0,0,double,1
+optimx,lmqn,6,0,0,double,1
+optimx,lmqn,7,0,0,...,1
+optimx,lmqnbc,-1,0,0,list<double[]>,1
+optimx,lmqnbc,0,0,0,double[],1
+optimx,lmqnbc,1,0,0,class<`function`>,1
+optimx,lmqnbc,2,0,0,double[],1
+optimx,lmqnbc,3,0,0,double[],1
+optimx,lmqnbc,4,0,0,double,1
+optimx,lmqnbc,5,0,0,double,1
+optimx,lmqnbc,6,0,0,double,1
+optimx,lmqnbc,7,0,0,double,1
+optimx,lmqnbc,8,0,0,double,1
+optimx,lmqnbc,9,0,0,...,1
+optimx,modlnp,-1,0,0,list<double[] | class<`matrix`>>,1
+optimx,modlnp,-1,0,1,list<double[]>,1
+optimx,modlnp,0,0,0,double[],1
+optimx,modlnp,1,0,0,any,1
+optimx,modlnp,2,0,0,double[],1
+optimx,modlnp,3,0,0,double,1
+optimx,modlnp,4,0,0,double,1
+optimx,modlnp,5,0,0,any,1
+optimx,modlnp,6,0,0,double,1
+optimx,modlnp,7,0,0,any,1
+optimx,modlnp,8,0,0,double[],1
+optimx,modlnp,9,0,0,any,1
+optimx,modlnp,10,0,0,...,1
+optimx,modz,-1,0,0,list<double[]>,1
+optimx,modz,0,0,0,double[],1
+optimx,modz,1,0,0,double[],1
+optimx,modz,2,0,0,double[],1
+optimx,modz,3,0,0,double[],1
+optimx,modz,4,0,0,any,1
+optimx,modz,5,0,0,any,1
+optimx,modz,6,0,0,double,1
+optimx,modz,7,0,0,any,1
+optimx,msolve,-1,0,0,list<double[]>,1
+optimx,msolve,0,0,0,double[],1
+optimx,msolve,1,0,0,double,1
+optimx,msolve,2,0,0,any,1
+optimx,msolve,3,0,0,any,1
+optimx,msolve,4,0,0,double[],1
+optimx,multistart,-1,0,0,class<`data.frame`>,1
+optimx,multistart,0,0,0,class<`matrix`>,1
+optimx,multistart,1,0,0,class<`function`>,1
+optimx,multistart,2,0,0,class<`function`>,1
+optimx,multistart,3,0,0,double,1
+optimx,multistart,4,0,0,double,1
+optimx,multistart,5,0,0,character,1
+optimx,multistart,6,0,0,logical,1
+optimx,multistart,7,0,0,list<double>,1
+optimx,multistart,8,0,0,...,1
+optimx,ndia3,-1,0,0,double[],1
+optimx,ndia3,0,0,0,double[],1
+optimx,ndia3,1,0,0,double[],1
+optimx,ndia3,2,0,0,any,1
+optimx,ndia3,3,0,0,double[],1
+optimx,ndia3,4,0,0,any,1
+optimx,opm,-1,0,0,"class<`data.frame`, `opm`>",1
+optimx,opm,0,0,0,double[],1
+optimx,opm,1,0,0,class<`function`>,1
+optimx,opm,2,0,0,character,1
+optimx,opm,2,0,1,class<`function`>,1
+optimx,opm,2,0,2,null,1
+optimx,opm,3,0,0,null,1
+optimx,opm,3,0,1,class<`function`>,1
+optimx,opm,4,0,0,double[],1
+optimx,opm,5,0,0,double[],1
+optimx,opm,6,0,0,character[],1
+optimx,opm,7,0,0,logical,1
+optimx,opm,8,0,0,list<any>,1
+optimx,opm,9,0,0,...,1
+optimx,[.opm,-1,0,0,"class<`data.frame`, `opm`>",1
+optimx,[.opm,-1,0,1,"class<`data.frame`, `optimx`>",1
+optimx,[.opm,-1,0,2,^double[],1
+optimx,[.opm,0,0,0,"class<`data.frame`, `opm`>",1
+optimx,[.opm,0,0,1,"class<`data.frame`, `optimx`>",1
+optimx,[.opm,1,0,0,...,1
+optimx,optchk,-1,0,0,list<null | double[]>,1
+optimx,optchk,0,0,0,double[],1
+optimx,optchk,1,0,0,class<`function`>,1
+optimx,optchk,2,0,0,class<`function`>,1
+optimx,optchk,3,0,0,null,1
+optimx,optchk,4,0,0,double[],1
+optimx,optchk,5,0,0,double[],1
+optimx,optchk,6,0,0,list<character[] | double[]>,1
+optimx,optchk,7,0,0,...,1
+optimx,optimr,-1,0,0,class<`try-error`>,1
+optimx,optimr,-1,0,1,list<any>,1
+optimx,optimr,0,0,0,double[],1
+optimx,optimr,1,0,0,class<`function`>,1
+optimx,optimr,2,0,0,null,1
+optimx,optimr,2,0,1,class<`function`>,1
+optimx,optimr,2,0,2,character,1
+optimx,optimr,3,0,0,null,1
+optimx,optimr,3,0,1,class<`function`>,1
+optimx,optimr,4,0,0,double[],1
+optimx,optimr,5,0,0,double[],1
+optimx,optimr,6,0,0,character,1
+optimx,optimr,7,0,0,logical,1
+optimx,optimr,8,0,0,list<any>,1
+optimx,optimr,9,0,0,...,1
+optimx,optimx,-1,0,0,"class<`data.frame`, `optimx`>",1
+optimx,optimx,0,0,0,double[],1
+optimx,optimx,1,0,0,class<`function`>,1
+optimx,optimx,2,0,0,class<`function`>,1
+optimx,optimx,2,0,1,null,1
+optimx,optimx,3,0,0,class<`function`>,1
+optimx,optimx,3,0,1,null,1
+optimx,optimx,4,0,0,double,1
+optimx,optimx,5,0,0,double,1
+optimx,optimx,6,0,0,any,1
+optimx,optimx,7,0,0,null,1
+optimx,optimx,8,0,0,logical,1
+optimx,optimx,9,0,0,list<any>,1
+optimx,optimx,10,0,0,...,1
+optimx,[.optimx,-1,0,0,"class<`data.frame`, `opm`>",1
+optimx,[.optimx,-1,0,1,"class<`data.frame`, `optimx`>",1
+optimx,[.optimx,-1,0,2,^double[],1
+optimx,[.optimx,0,0,0,"class<`data.frame`, `opm`>",1
+optimx,[.optimx,0,0,1,"class<`data.frame`, `optimx`>",1
+optimx,[.optimx,1,0,0,...,1
+optimx,optimx.check,-1,0,0,list<logical>,1
+optimx,optimx.check,0,0,0,double[],1
+optimx,optimx.check,1,0,0,class<`function`>,1
+optimx,optimx.check,2,0,0,class<`function`>,1
+optimx,optimx.check,2,0,1,null,1
+optimx,optimx.check,3,0,0,class<`function`>,1
+optimx,optimx.check,3,0,1,null,1
+optimx,optimx.check,4,0,0,double,1
+optimx,optimx.check,5,0,0,double,1
+optimx,optimx.check,6,0,0,any,1
+optimx,optimx.check,7,0,0,list<double>,1
+optimx,optimx.check,8,0,0,logical,1
+optimx,optimx.check,9,0,0,any,1
+optimx,optimx.check,10,0,0,...,1
+optimx,optimx.run,-1,0,0,class<`data.frame`>,1
+optimx,optimx.run,0,0,0,double[],1
+optimx,optimx.run,1,0,0,class<`function`>,1
+optimx,optimx.run,2,0,0,class<`function`>,1
+optimx,optimx.run,2,0,1,null,1
+optimx,optimx.run,3,0,0,class<`function`>,1
+optimx,optimx.run,3,0,1,null,1
+optimx,optimx.run,4,0,0,double,1
+optimx,optimx.run,5,0,0,double,1
+optimx,optimx.run,6,0,0,character[],1
+optimx,optimx.run,7,0,0,null,1
+optimx,optimx.run,8,0,0,logical,1
+optimx,optimx.run,9,0,0,list<double>,1
+optimx,optimx.run,10,0,0,...,1
+optimx,optimx.setup,-1,0,0,list<any>,1
+optimx,optimx.setup,0,0,0,double[],1
+optimx,optimx.setup,1,0,0,class<`function`>,1
+optimx,optimx.setup,2,0,0,null,1
+optimx,optimx.setup,2,0,1,class<`function`>,1
+optimx,optimx.setup,3,0,0,null,1
+optimx,optimx.setup,3,0,1,class<`function`>,1
+optimx,optimx.setup,4,0,0,double,1
+optimx,optimx.setup,5,0,0,double,1
+optimx,optimx.setup,6,0,0,any,1
+optimx,optimx.setup,7,0,0,any,1
+optimx,optimx.setup,8,0,0,any,1
+optimx,optimx.setup,9,0,0,list<any>,1
+optimx,optimx.setup,10,0,0,...,1
+optimx,polyopt,-1,0,0,class<`data.frame`>,1
+optimx,polyopt,0,0,0,double[],1
+optimx,polyopt,1,0,0,class<`function`>,1
+optimx,polyopt,2,0,0,class<`function`>,1
+optimx,polyopt,3,0,0,double,1
+optimx,polyopt,4,0,0,double,1
+optimx,polyopt,5,0,0,class<`data.frame`>,1
+optimx,polyopt,6,0,0,logical,1
+optimx,polyopt,7,0,0,list<double>,1
+optimx,polyopt,8,0,0,...,1
+optimx,proptimr,-1,0,0,null,1
+optimx,proptimr,0,0,0,list<any>,1
+optimx,Rcgmin,-1,0,0,list<double[] | null | character>,1
+optimx,Rcgmin,-1,0,1,list<double[] | character>,1
+optimx,Rcgmin,0,0,0,double[],1
+optimx,Rcgmin,1,0,0,any,1
+optimx,Rcgmin,2,0,0,null,1
+optimx,Rcgmin,2,0,1,class<`function`>,1
+optimx,Rcgmin,3,0,0,null,1
+optimx,Rcgmin,3,0,1,double[],1
+optimx,Rcgmin,4,0,0,null,1
+optimx,Rcgmin,4,0,1,double[],1
+optimx,Rcgmin,5,0,0,null,1
+optimx,Rcgmin,5,0,1,double[],1
+optimx,Rcgmin,6,0,0,list<any>,1
+optimx,Rcgmin,7,0,0,...,1
+optimx,Rcgminb,-1,0,0,list<double[] | character>,1
+optimx,Rcgminb,0,0,0,double[],1
+optimx,Rcgminb,1,0,0,class<`function`>,1
+optimx,Rcgminb,2,0,0,class<`function`>,1
+optimx,Rcgminb,3,0,0,double[],1
+optimx,Rcgminb,4,0,0,double[],1
+optimx,Rcgminb,5,0,0,double[],1
+optimx,Rcgminb,6,0,0,list<any>,1
+optimx,Rcgminb,7,0,0,...,1
+optimx,Rcgminu,-1,0,0,list<double[] | null | character>,1
+optimx,Rcgminu,-1,0,1,list<double[] | character>,1
+optimx,Rcgminu,0,0,0,double[],1
+optimx,Rcgminu,1,0,0,any,1
+optimx,Rcgminu,2,0,0,character,1
+optimx,Rcgminu,2,0,1,class<`function`>,1
+optimx,Rcgminu,3,0,0,list<any>,1
+optimx,Rcgminu,4,0,0,...,1
+optimx,Rvmmin,-1,0,0,list<double[] | character>,1
+optimx,Rvmmin,0,0,0,double[],1
+optimx,Rvmmin,1,0,0,class<`function`>,1
+optimx,Rvmmin,2,0,0,class<`function`>,1
+optimx,Rvmmin,2,0,1,null,1
+optimx,Rvmmin,2,0,2,character,1
+optimx,Rvmmin,3,0,0,double[],1
+optimx,Rvmmin,3,0,1,null,1
+optimx,Rvmmin,4,0,0,double[],1
+optimx,Rvmmin,4,0,1,null,1
+optimx,Rvmmin,5,0,0,double[],1
+optimx,Rvmmin,5,0,1,null,1
+optimx,Rvmmin,6,0,0,list<any>,1
+optimx,Rvmmin,7,0,0,...,1
+optimx,Rvmminb,-1,0,0,list<double[] | character>,1
+optimx,Rvmminb,0,0,0,double[],1
+optimx,Rvmminb,1,0,0,class<`function`>,1
+optimx,Rvmminb,2,0,0,character,1
+optimx,Rvmminb,2,0,1,class<`function`>,1
+optimx,Rvmminb,3,0,0,double[],1
+optimx,Rvmminb,4,0,0,double[],1
+optimx,Rvmminb,5,0,0,double[],1
+optimx,Rvmminb,6,0,0,list<any>,1
+optimx,Rvmminb,7,0,0,...,1
+optimx,Rvmminu,-1,0,0,list<double[] | character>,1
+optimx,Rvmminu,0,0,0,double[],1
+optimx,Rvmminu,1,0,0,class<`function`>,1
+optimx,Rvmminu,2,0,0,character,1
+optimx,Rvmminu,2,0,1,class<`function`>,1
+optimx,Rvmminu,3,0,0,list<any>,1
+optimx,Rvmminu,4,0,0,...,1
+optimx,scalecheck,-1,0,0,list<double | null>,1
+optimx,scalecheck,0,0,0,double[],1
+optimx,scalecheck,1,0,0,double,1
+optimx,scalecheck,2,0,0,double,1
+optimx,scalecheck,3,0,0,any,1
+optimx,scalechk,-1,0,0,list<double>,1
+optimx,scalechk,0,0,0,double[],1
+optimx,scalechk,1,0,0,double[],1
+optimx,scalechk,2,0,0,double[],1
+optimx,scalechk,3,0,0,logical,1
+optimx,scalechk,3,0,1,null,1
+optimx,scalechk,4,0,0,logical,1
+optimx,snewton,-1,0,0,list<any>,1
+optimx,snewton,0,0,0,double[],1
+optimx,snewton,1,0,0,class<`function`>,1
+optimx,snewton,2,0,0,class<`function`>,1
+optimx,snewton,3,0,0,class<`function`>,1
+optimx,snewton,4,0,0,list<double>,1
+optimx,snewton,5,0,0,...,1
+optimx,snewtonm,-1,0,0,list<any>,1
+optimx,snewtonm,0,0,0,double[],1
+optimx,snewtonm,1,0,0,class<`function`>,1
+optimx,snewtonm,2,0,0,class<`function`>,1
+optimx,snewtonm,3,0,0,class<`function`>,1
+optimx,snewtonm,4,0,0,list<double>,1
+optimx,snewtonm,5,0,0,...,1
+optimx,ssbfgs,-1,0,0,double[],1
+optimx,ssbfgs,0,0,0,double[],1
+optimx,ssbfgs,1,0,0,double[],1
+optimx,ssbfgs,2,0,0,double[],1
+optimx,ssbfgs,3,0,0,double,1
+optimx,ssbfgs,4,0,0,double,1
+optimx,ssbfgs,5,0,0,double,1
+optimx,ssbfgs,6,0,0,double,1
+optimx,step1,-1,0,0,double,1
+optimx,step1,0,0,0,double,1
+optimx,step1,1,0,0,class<`matrix`>,1
+optimx,step1,1,0,1,double,1
+optimx,step1,2,0,0,double,1
+optimx,stpmax,-1,0,0,double,1
+optimx,stpmax,0,0,0,double,1
+optimx,stpmax,1,0,0,double,1
+optimx,stpmax,2,0,0,double[],1
+optimx,stpmax,3,0,0,double[],1
+optimx,stpmax,4,0,0,double[],1
+optimx,stpmax,5,0,0,any,1
+optimx,stpmax,6,0,0,any,1
+optimx,summary.opm,-1,0,0,"class<`data.frame`, `opm`>",1
+optimx,summary.opm,-1,0,1,"class<`data.frame`, `optimx`>",1
+optimx,summary.opm,0,0,0,"class<`data.frame`, `opm`>",1
+optimx,summary.opm,0,0,1,"class<`data.frame`, `optimx`>",1
+optimx,summary.opm,1,0,0,any,1
+optimx,summary.opm,2,0,0,double,1
+optimx,summary.opm,2,0,1,integer[],1
+optimx,summary.opm,3,0,0,...,1
+optimx,summary.optimx,-1,0,0,"class<`data.frame`, `opm`>",1
+optimx,summary.optimx,-1,0,1,"class<`data.frame`, `optimx`>",1
+optimx,summary.optimx,0,0,0,"class<`data.frame`, `opm`>",1
+optimx,summary.optimx,0,0,1,"class<`data.frame`, `optimx`>",1
+optimx,summary.optimx,1,0,0,any,1
+optimx,summary.optimx,2,0,0,double,1
+optimx,summary.optimx,2,0,1,integer[],1
+optimx,summary.optimx,3,0,0,...,1
+optimx,tn,-1,0,0,list<double[]>,1
+optimx,tn,0,0,0,double[],1
+optimx,tn,1,0,0,class<`function`>,1
+optimx,tn,2,0,0,double,1
+optimx,tn,3,0,0,...,1
+optimx,tnbc,-1,0,0,list<double[]>,1
+optimx,tnbc,0,0,0,double[],1
+optimx,tnbc,1,0,0,class<`function`>,1
+optimx,tnbc,2,0,0,double[],1
+optimx,tnbc,3,0,0,double[],1
+optimx,tnbc,4,0,0,double,1
+optimx,tnbc,5,0,0,...,1
+optimx,ztime,-1,0,0,double[],1
+optimx,ztime,0,0,0,double[],1
+optimx,ztime,1,0,0,double[],1
+ordinal,addterm.clm2,-1,0,0,"class<`anova`, `data.frame`>",1
+ordinal,addterm.clm2,0,0,0,class<`clm2`>,1
+ordinal,addterm.clm2,1,0,0,class<`formula`>,1
+ordinal,addterm.clm2,2,0,0,double,1
+ordinal,addterm.clm2,3,0,0,character,1
+ordinal,addterm.clm2,4,0,0,double,1
+ordinal,addterm.clm2,5,0,0,logical,1
+ordinal,addterm.clm2,6,0,0,logical,1
+ordinal,addterm.clm2,7,0,0,character,1
+ordinal,adjust_contrast_for_param,-1,0,0,list<class<`matrix`>>,1
+ordinal,adjust_contrast_for_param,0,0,0,class<`clm`>,1
+ordinal,adjust_contrast_for_param,1,0,0,list<class<`matrix`>>,1
+ordinal,anova.clm,-1,0,0,any,1
+ordinal,anova.clm,0,0,0,class<`clm`>,1
+ordinal,anova.clm,1,0,0,...,1
+ordinal,anova.clm,2,0,0,any,1
+ordinal,anova.clm2,-1,0,0,"class<`Anova`, `data.frame`>",1
+ordinal,anova.clm2,0,0,0,"class<`clm2`, `clmm2`>",1
+ordinal,anova.clm2,0,0,1,class<`clm2`>,1
+ordinal,anova.clm2,1,0,0,...,1
+ordinal,anova.clm2,2,0,0,character[],1
+ordinal,anova.clmm2,-1,0,0,"class<`Anova`, `data.frame`>",1
+ordinal,anova.clmm2,0,0,0,"class<`clm2`, `clmm2`>",1
+ordinal,anova.clmm2,1,0,0,...,1
+ordinal,anova.clmm2,2,0,0,any,1
+ordinal,checkArgs.clm,-1,0,0,null,1
+ordinal,checkArgs.clm,0,0,0,class<`call`>,1
+ordinal,checkContrasts,-1,0,0,null,1
+ordinal,checkContrasts,0,0,0,"class<`formula`, `terms`>",1
+ordinal,checkContrasts,1,0,0,list<character>,1
+ordinal,checkContrasts,1,0,1,character[],1
+ordinal,checkContrasts,1,0,2,null,1
+ordinal,clm,-1,0,0,any,1
+ordinal,clm,0,0,0,any,1
+ordinal,clm,1,0,0,any,1
+ordinal,clm,2,0,0,any,1
+ordinal,clm,3,0,0,any,1
+ordinal,clm,4,0,0,any,1
+ordinal,clm,5,0,0,any,1
+ordinal,clm,6,0,0,any,1
+ordinal,clm,7,0,0,logical,1
+ordinal,clm2,-1,0,0,class<`clm2`>,1
+ordinal,clm2,-1,0,1,environment,1
+ordinal,clm2,0,0,0,any,1
+ordinal,clm2,1,0,0,any,1
+ordinal,clm2,2,0,0,any,1
+ordinal,clm2,3,0,0,any,1
+ordinal,clm2,4,0,0,any,1
+ordinal,clm2,5,0,0,any,1
+ordinal,clm2,6,0,0,any,1
+ordinal,clm2,7,0,0,any,1
+ordinal,clm2.control,-1,0,0,list<character | double | list<double>>,1
+ordinal,clm2.control,0,0,0,character[],1
+ordinal,clm2.control,1,0,0,...,1
+ordinal,clm2.control,2,0,0,double,1
+ordinal,clm2.control,3,0,0,double,1
+ordinal,clm2.control,4,0,0,double,1
+ordinal,clm2.control,5,0,0,double,1
+ordinal,clm2.control,6,0,0,double,1
+ordinal,clm.control,-1,0,0,list<character | double>,1
+ordinal,clm.control,-1,0,1,list<character | double | list<integer>>,1
+ordinal,clm.control,0,0,0,character[],1
+ordinal,clm.control,1,0,0,character[],1
+ordinal,clm.control,2,0,0,character[],1
+ordinal,clm.control,3,0,0,...,1
+ordinal,clm.control,4,0,0,integer,1
+ordinal,clm.control,5,0,0,integer,1
+ordinal,clm.control,6,0,0,double,1
+ordinal,clm.control,7,0,0,integer,1
+ordinal,clm.finalize,-1,0,0,list<any>,1
+ordinal,clm.finalize,0,0,0,list<double[] | class<`matrix`> | character>,1
+ordinal,clm.finalize,0,0,1,list<double[] | class<`matrix`> | list<double[] | character>>,1
+ordinal,clm.finalize,0,0,2,list<double[] | class<`matrix`> | list<double[] | null>>,1
+ordinal,clm.finalize,1,0,0,double[],1
+ordinal,clm.finalize,2,0,0,list<character[]>,1
+ordinal,clm.finalize,3,0,0,list<double[]>,1
+ordinal,clm.fit,-1,0,0,class<`clm.fit`>,1
+ordinal,clm.fit,0,0,0,"class<`factor`, `ordered`>",1
+ordinal,clm.fit,0,0,1,list<any>,1
+ordinal,clm.fit,1,0,0,...,1
+ordinal,clm.fit.default,-1,0,0,class<`clm.fit`>,1
+ordinal,clm.fit.default,-1,0,1,environment,1
+ordinal,clm.fit.default,0,0,0,list<any>,1
+ordinal,clm.fit.default,1,0,0,...,1
+ordinal,clm.fit.factor,-1,0,0,class<`clm.fit`>,1
+ordinal,clm.fit.factor,0,0,0,"class<`factor`, `ordered`>",1
+ordinal,clm.fit.factor,1,0,0,any,1
+ordinal,clm.fit.factor,2,0,0,any,1
+ordinal,clm.fit.factor,3,0,0,any,1
+ordinal,clm.fit.factor,4,0,0,any,1
+ordinal,clm.fit.factor,5,0,0,any,1
+ordinal,clm.fit.factor,6,0,0,any,1
+ordinal,clm.fit.factor,7,0,0,list<any>,1
+ordinal,clm.fit.flex,-1,0,0,list<double[] | class<`matrix`> | list<double[] | character>>,1
+ordinal,clm.fit.flex,0,0,0,environment,1
+ordinal,clm.fit.flex,1,0,0,any,1
+ordinal,clm.fit.NR,-1,0,0,any,1
+ordinal,clm.fit.NR,0,0,0,environment,1
+ordinal,clm.fit.NR,1,0,0,list<any>,1
+ordinal,clm.fit.optim,-1,0,0,list<double[] | class<`matrix`> | list<double[] | character>>,1
+ordinal,clm.fit.optim,-1,0,1,list<double[] | class<`matrix`> | list<double[] | null>>,1
+ordinal,clm.fit.optim,0,0,0,environment,1
+ordinal,clm.fit.optim,1,0,0,character,1
+ordinal,clm.fit.optim,2,0,0,list<integer>,1
+ordinal,clm.grad,-1,0,0,class<`matrix`>,1
+ordinal,clm.grad,0,0,0,environment,1
+ordinal,clm.grad_direct,-1,0,0,class<`matrix`>,1
+ordinal,clm.grad_direct,0,0,0,environment,1
+ordinal,clm.grad_direct,1,0,0,double[],1
+ordinal,clm.hess,-1,0,0,class<`matrix`>,1
+ordinal,clm.hess,0,0,0,environment,1
+ordinal,clmm,-1,0,0,any,1
+ordinal,clmm,0,0,0,class<`formula`>,1
+ordinal,clmm,1,0,0,any,1
+ordinal,clmm,2,0,0,any,1
+ordinal,clmm,3,0,0,any,1
+ordinal,clmm,4,0,0,any,1
+ordinal,clmm,5,0,0,any,1
+ordinal,clmm,6,0,0,any,1
+ordinal,clmm,7,0,0,logical,1
+ordinal,clmm2,-1,0,0,"class<`clm2`, `clmm2`>",1
+ordinal,clmm2,0,0,0,any,1
+ordinal,clmm2,1,0,0,any,1
+ordinal,clmm2,2,0,0,any,1
+ordinal,clmm2,3,0,0,any,1
+ordinal,clmm2,4,0,0,any,1
+ordinal,clmm2,5,0,0,any,1
+ordinal,clmm2,6,0,0,any,1
+ordinal,clmm2,7,0,0,any,1
+ordinal,clmm2.control,-1,0,0,list<character | list<double | character>>,1
+ordinal,clmm2.control,0,0,0,character[],1
+ordinal,clmm2.control,1,0,0,...,1
+ordinal,clmm2.control,2,0,0,double,1
+ordinal,clmm2.control,3,0,0,double,1
+ordinal,clmm2.control,4,0,0,double,1
+ordinal,clmm2.control,5,0,0,double,1
+ordinal,clmm2.control,6,0,0,character[],1
+ordinal,clmm.control,-1,0,0,list<character | logical | list<double | character | double>>,1
+ordinal,clmm.control,0,0,0,character[],1
+ordinal,clmm.control,1,0,0,...,1
+ordinal,clmm.control,2,0,0,double,1
+ordinal,clmm.control,3,0,0,double,1
+ordinal,clmm.control,4,0,0,double,1
+ordinal,clmm.control,5,0,0,double,1
+ordinal,clmm.control,6,0,0,logical,1
+ordinal,clmm.control,7,0,0,character[],1
+ordinal,clmm.finalize,-1,0,0,class<`clmm`>,1
+ordinal,clmm.finalize,0,0,0,list<any>,1
+ordinal,clmm.finalize,1,0,0,list<any>,1
+ordinal,clmm.finalize,2,0,0,list<class<`matrix`> | double | character[]>,1
+ordinal,clmm.finalize,3,0,0,logical,1
+ordinal,clmm.fit.env,-1,0,0,list<any>,1
+ordinal,clmm.fit.env,0,0,0,environment,1
+ordinal,clmm.fit.env,1,0,0,list<double>,1
+ordinal,clmm.fit.env,2,0,0,character,1
+ordinal,clmm.fit.env,3,0,0,logical,1
+ordinal,clmm.fit.ssr,-1,0,0,list<double[] | class<`matrix`> | list<class<`matrix`> | double[] | character | double>>,1
+ordinal,clmm.fit.ssr,0,0,0,environment,1
+ordinal,clmm.fit.ssr,1,0,0,list<double>,1
+ordinal,clmm.fit.ssr,2,0,0,character,1
+ordinal,clmm.fit.ssr,3,0,0,logical,1
+ordinal,clmm.formulae,-1,0,0,list<class<`formula`>>,1
+ordinal,clmm.formulae,0,0,0,class<`formula`>,1
+ordinal,clmm.frames,-1,0,0,list<any>,1
+ordinal,clmm.frames,0,0,0,class<`call`>,1
+ordinal,clmm.frames,1,0,0,list<class<`formula`>>,1
+ordinal,clmm.frames,2,0,0,null,1
+ordinal,clm.newRho,-1,0,0,environment,1
+ordinal,clm.newRho,0,0,0,environment,1
+ordinal,clm.newRho,1,0,0,class<`factor`>,1
+ordinal,clm.newRho,1,0,1,"class<`factor`, `ordered`>",1
+ordinal,clm.newRho,2,0,0,class<`matrix`>,1
+ordinal,clm.newRho,3,0,0,null,1
+ordinal,clm.newRho,3,0,1,class<`matrix`>,1
+ordinal,clm.newRho,4,0,0,class<`matrix`>,1
+ordinal,clm.newRho,4,0,1,null,1
+ordinal,clm.newRho,5,0,0,double[],1
+ordinal,clm.newRho,6,0,0,double[],1
+ordinal,clm.newRho,7,0,0,double[],1
+ordinal,clm.newRho,7,0,1,null,1
+ordinal,clm.nll,-1,0,0,double,1
+ordinal,clm.nll,0,0,0,environment,1
+ordinal,clm.nll,1,0,0,any,1
+ordinal,clm.nll.flex,-1,0,0,double,1
+ordinal,clm.nll.flex,0,0,0,environment,1
+ordinal,clm.nll.flex,1,0,0,any,1
+ordinal,clm.start,-1,0,0,double[],1
+ordinal,clm.start,0,0,0,character[],1
+ordinal,clm.start,1,0,0,character,1
+ordinal,clm.start,2,0,0,class<`matrix`>,1
+ordinal,clm.start,3,0,0,class<`matrix`>,1
+ordinal,clm.start,3,0,1,null,1
+ordinal,clm.start,4,0,0,null,1
+ordinal,clm.start,5,0,0,logical,1
+ordinal,coef.clm,-1,0,0,^double[],1
+ordinal,coef.clm,0,0,0,class<`clm`>,1
+ordinal,coef.clm,1,0,0,logical,1
+ordinal,coef.clm,2,0,0,...,1
+ordinal,coef.summary.clm,-1,0,0,class<`matrix`>,1
+ordinal,coef.summary.clm,0,0,0,class<`summary.clm`>,1
+ordinal,coef.summary.clm,1,0,0,logical,1
+ordinal,coef.summary.clm,2,0,0,...,1
+ordinal,condVar,-1,0,0,list<class<`data.frame`>>,1
+ordinal,condVar,0,0,0,class<`clmm`>,1
+ordinal,condVar,1,0,0,...,1
+ordinal,condVar.clmm,-1,0,0,list<class<`data.frame`>>,1
+ordinal,condVar.clmm,0,0,0,class<`clmm`>,1
+ordinal,condVar.clmm,1,0,0,...,1
+ordinal,confint.clm,-1,0,0,class<`matrix`>,1
+ordinal,confint.clm,0,0,0,class<`clm`>,1
+ordinal,confint.clm,1,0,0,any,1
+ordinal,confint.clm,2,0,0,double,1
+ordinal,confint.clm,3,0,0,character[],1
+ordinal,confint.clm,4,0,0,logical,1
+ordinal,confint.clm,5,0,0,...,1
+ordinal,confint.profile.clm,-1,0,0,class<`matrix`>,1
+ordinal,confint.profile.clm,0,0,0,class<`profile.clm`>,1
+ordinal,confint.profile.clm,1,0,0,integer[],1
+ordinal,confint.profile.clm,2,0,0,double,1
+ordinal,confint.profile.clm,3,0,0,...,1
+ordinal,confint.profile.clm2,-1,0,0,class<`matrix`>,1
+ordinal,confint.profile.clm2,0,0,0,"class<`profile`, `profile.clmm2`>",1
+ordinal,confint.profile.clm2,0,0,1,"class<`profile`, `profile.clm2`>",1
+ordinal,confint.profile.clm2,1,0,0,integer[],1
+ordinal,confint.profile.clm2,2,0,0,double,1
+ordinal,confint.profile.clm2,3,0,0,...,1
+ordinal,confint.profile.clmm2,-1,0,0,class<`matrix`>,1
+ordinal,confint.profile.clmm2,0,0,0,"class<`profile`, `profile.clmm2`>",1
+ordinal,confint.profile.clmm2,1,0,0,integer,1
+ordinal,confint.profile.clmm2,2,0,0,double,1
+ordinal,confint.profile.clmm2,3,0,0,...,1
+ordinal,containment,-1,0,0,list<character[]>,1
+ordinal,containment,0,0,0,class<`clm`>,1
+ordinal,contestMD,-1,0,0,class<`data.frame`>,1
+ordinal,contestMD,0,0,0,class<`clm`>,1
+ordinal,contestMD,1,0,0,class<`matrix`>,1
+ordinal,contestMD,2,0,0,double,1
+ordinal,contestMD,3,0,0,any,1
+ordinal,contestMD,4,0,0,...,1
+ordinal,conv.check,-1,0,0,list<any>,1
+ordinal,conv.check,0,0,0,list<any>,1
+ordinal,conv.check,1,0,0,list<character | double>,1
+ordinal,conv.check,1,0,1,list<character | double | list<integer>>,1
+ordinal,conv.check,2,0,0,any,1
+ordinal,conv.check,3,0,0,any,1
+ordinal,conv.check,4,0,0,...,1
+ordinal,convergence,-1,0,0,class<`convergence.clm`>,1
+ordinal,convergence,0,0,0,class<`clm`>,1
+ordinal,convergence,1,0,0,...,1
+ordinal,convergence.clm,-1,0,0,class<`convergence.clm`>,1
+ordinal,convergence.clm,0,0,0,class<`clm`>,1
+ordinal,convergence.clm,1,0,0,any,1
+ordinal,convergence.clm,2,0,0,double,1
+ordinal,convergence.clm,3,0,0,...,1
+ordinal,cor.dec,-1,0,0,integer[],1
+ordinal,cor.dec,0,0,0,double[],1
+ordinal,dAO,-1,0,0,double[],1
+ordinal,dAO,0,0,0,double[],1
+ordinal,dAO,1,0,0,double,1
+ordinal,dAO,2,0,0,logical,1
+ordinal,Deparse,-1,0,0,character,1
+ordinal,Deparse,0,0,0,class<`call`>,1
+ordinal,Deparse,0,0,1,class<`formula`>,1
+ordinal,Deparse,0,0,2,class<`name`>,1
+ordinal,Deparse,0,0,3,double,1
+ordinal,Deparse,0,0,4,null,1
+ordinal,Deparse,1,0,0,integer,1
+ordinal,Deparse,2,0,0,logical,1
+ordinal,Deparse,3,0,0,character[],1
+ordinal,Deparse,4,0,0,integer,1
+ordinal,deriv12,-1,0,0,list<double[] | class<`matrix`>>,1
+ordinal,deriv12,0,0,0,class<`function`>,1
+ordinal,deriv12,1,0,0,double[],1
+ordinal,deriv12,2,0,0,double,1
+ordinal,deriv12,3,0,0,null,1
+ordinal,deriv12,4,0,0,...,1
+ordinal,dgumbel,-1,0,0,double[],1
+ordinal,dgumbel,0,0,0,double[],1
+ordinal,dgumbel,1,0,0,double,1
+ordinal,dgumbel,2,0,0,double,1
+ordinal,dgumbel,3,0,0,logical,1
+ordinal,dgumbel,4,0,0,logical,1
+ordinal,dlgamma,-1,0,0,double[],1
+ordinal,dlgamma,0,0,0,double[],1
+ordinal,dlgamma,1,0,0,double,1
+ordinal,dlgamma,2,0,0,logical,1
+ordinal,doolittle,-1,0,0,list<class<`matrix`>>,1
+ordinal,doolittle,0,0,0,class<`matrix`>,1
+ordinal,doolittle,1,0,0,double,1
+ordinal,drop.coef,-1,0,0,class<`matrix`>,1
+ordinal,drop.coef,0,0,0,class<`matrix`>,1
+ordinal,drop.coef,1,0,0,logical,1
+ordinal,drop.coef2,-1,0,0,any,1
+ordinal,drop.coef2,0,0,0,class<`matrix`>,1
+ordinal,drop.coef2,1,0,0,double,1
+ordinal,drop.coef2,2,0,0,logical,1
+ordinal,drop.coef2,3,0,0,logical,1
+ordinal,drop.cols,-1,0,0,any,1
+ordinal,drop.cols,0,0,0,list<any>,1
+ordinal,drop.cols,1,0,0,logical,1
+ordinal,drop.cols,2,0,0,logical,1
+ordinal,dropterm.clm2,-1,0,0,"class<`anova`, `data.frame`>",1
+ordinal,dropterm.clm2,0,0,0,class<`clm2`>,1
+ordinal,dropterm.clm2,1,0,0,any,1
+ordinal,dropterm.clm2,2,0,0,double,1
+ordinal,dropterm.clm2,3,0,0,character,1
+ordinal,dropterm.clm2,4,0,0,double,1
+ordinal,dropterm.clm2,5,0,0,logical,1
+ordinal,dropterm.clm2,6,0,0,logical,1
+ordinal,dropterm.clm2,7,0,0,character[],1
+ordinal,ensure_full_rank,-1,0,0,class<`matrix`>,1
+ordinal,ensure_full_rank,0,0,0,class<`matrix`>,1
+ordinal,ensure_full_rank,1,0,0,double,1
+ordinal,ensure_full_rank,2,0,0,logical,1
+ordinal,ensure_full_rank,3,0,0,logical,1
+ordinal,expandSlash,-1,0,0,list<class<`call`>>,1
+ordinal,expandSlash,0,0,0,list<class<`call`>>,1
+ordinal,extractAIC.clm,-1,0,0,double[],1
+ordinal,extractAIC.clm,0,0,0,class<`clm`>,1
+ordinal,extractAIC.clm,1,0,0,any,1
+ordinal,extractAIC.clm,2,0,0,double,1
+ordinal,extractAIC.clm,3,0,0,...,1
+ordinal,extractAIC.clm2,-1,0,0,double[],1
+ordinal,extractAIC.clm2,0,0,0,class<`clm2`>,1
+ordinal,extractAIC.clm2,1,0,0,any,1
+ordinal,extractAIC.clm2,2,0,0,double,1
+ordinal,extractAIC.clm2,3,0,0,...,1
+ordinal,extract_contrasts_type3,-1,0,0,list<class<`matrix`>>,1
+ordinal,extract_contrasts_type3,0,0,0,class<`clm`>,1
+ordinal,extract_contrasts_type3,1,0,0,class<`matrix`>,1
+ordinal,fe.start,-1,0,0,double[],1
+ordinal,fe.start,0,0,0,list<any>,1
+ordinal,fe.start,1,0,0,character,1
+ordinal,fe.start,2,0,0,character,1
+ordinal,finalizeRho,-1,0,0,list<any>,1
+ordinal,finalizeRho,0,0,0,environment,1
+ordinal,finalizeRhoM,-1,0,0,list<any>,1
+ordinal,finalizeRhoM,0,0,0,environment,1
+ordinal,findbars,-1,0,0,class<`call`>,1
+ordinal,findbars,-1,0,1,list<class<`call`>>,1
+ordinal,findbars,-1,0,2,null,1
+ordinal,findbars,0,0,0,class<`(`>,1
+ordinal,findbars,0,0,1,class<`call`>,1
+ordinal,findbars,0,0,2,class<`name`>,1
+ordinal,fitCLM,-1,0,0,null,1
+ordinal,fitCLM,0,0,0,environment,1
+ordinal,format.perc,-1,0,0,character[],1
+ordinal,format.perc,0,0,0,double[],1
+ordinal,format.perc,1,0,0,double,1
+ordinal,formatTheta,-1,0,0,list<class<`data.frame`> | class<`matrix`> | logical>,1
+ordinal,formatTheta,-1,0,1,list<class<`matrix`> | logical>,1
+ordinal,formatTheta,-1,0,2,list<logical>,1
+ordinal,formatTheta,0,0,0,any,1
+ordinal,formatTheta,1,0,0,any,1
+ordinal,formatTheta,2,0,0,list<any>,1
+ordinal,formatTheta,3,0,0,any,1
+ordinal,format_tJac,-1,0,0,class<`matrix`>,1
+ordinal,format_tJac,0,0,0,class<`matrix`>,1
+ordinal,format_tJac,1,0,0,character[],1
+ordinal,format_tJac,2,0,0,character[],1
+ordinal,gauss.hermite,-1,0,0,list<double[]>,1
+ordinal,gauss.hermite,0,0,0,integer,1
+ordinal,gcauchy,-1,0,0,double[],1
+ordinal,gcauchy,0,0,0,integer[],1
+ordinal,get_clmDesign,-1,0,0,any,1
+ordinal,get_clmDesign,0,0,0,class<`data.frame`>,1
+ordinal,get_clmDesign,1,0,0,"list<class<`formula`, `terms`>>",1
+ordinal,get_clmDesign,2,0,0,list<character>,1
+ordinal,get_clmDesign,2,0,1,null,1
+ordinal,get_clmDesign,2,0,2,character[],1
+ordinal,get_clmDM,-1,0,0,list<class<`matrix`> | double[]>,1
+ordinal,get_clmDM,0,0,0,class<`data.frame`>,1
+ordinal,get_clmDM,1,0,0,"class<`formula`, `terms`>",1
+ordinal,get_clmDM,2,0,0,any,1
+ordinal,get_clmDM,3,0,0,logical,1
+ordinal,get_clmDM,4,0,0,character,1
+ordinal,get_clmDM,5,0,0,logical,1
+ordinal,get_clmFormulas,-1,0,0,list<class<`formula`>>,1
+ordinal,get_clmFormulas,0,0,0,class<`call`>,1
+ordinal,get_clmFormulas,1,0,0,environment,1
+ordinal,get_clmInfoTab,-1,0,0,class<`data.frame`>,1
+ordinal,get_clmInfoTab,0,0,0,list<any>,1
+ordinal,get_clmInfoTab,1,0,0,...,1
+ordinal,get_clm.mf,-1,0,0,any,1
+ordinal,get_clm.mf,0,0,0,class<`call`>,1
+ordinal,get_clm.mf,1,0,0,class<`formula`>,1
+ordinal,get_clm.mf,2,0,0,any,1
+ordinal,get_clm.mf,3,0,0,environment,1
+ordinal,get_clmRho,-1,0,0,environment,1
+ordinal,get_clmRho,0,0,0,class<`clm`>,1
+ordinal,get_clmRho,1,0,0,...,1
+ordinal,get_clmRho.clm,-1,0,0,environment,1
+ordinal,get_clmRho.clm,0,0,0,class<`clm`>,1
+ordinal,get_clmRho.clm,1,0,0,any,1
+ordinal,get_clmRho.clm,2,0,0,...,1
+ordinal,get_clmRho.default,-1,0,0,environment,1
+ordinal,get_clmRho.default,0,0,0,class<`data.frame`>,1
+ordinal,get_clmRho.default,1,0,0,"list<class<`formula`, `terms`>>",1
+ordinal,get_clmRho.default,2,0,0,list<character>,1
+ordinal,get_clmRho.default,2,0,1,null,1
+ordinal,get_clmRho.default,3,0,0,character,1
+ordinal,get_clmRho.default,4,0,0,character,1
+ordinal,get_clmRho.default,5,0,0,any,1
+ordinal,get_clmRho.default,6,0,0,null,1
+ordinal,get_clmRho.default,7,0,0,list<character | double>,1
+ordinal,get_clmTerms,-1,0,0,"list<class<`formula`, `terms`>>",1
+ordinal,get_clmTerms,0,0,0,class<`call`>,1
+ordinal,get_clmTerms,1,0,0,list<class<`formula`>>,1
+ordinal,get_clmTerms,2,0,0,environment,1
+ordinal,get_clmY,-1,0,0,"list<class<`factor`, `ordered`> | character[]>",1
+ordinal,get_clmY,-1,0,1,list<class<`factor`> | character[]>,1
+ordinal,get_clmY,0,0,0,class<`data.frame`>,1
+ordinal,get_clmY,1,0,0,double[],1
+ordinal,get_contrast_coding,-1,0,0,list<character>,1
+ordinal,get_contrast_coding,0,0,0,class<`clm`>,1
+ordinal,get_contrast_coding,1,0,0,character,1
+ordinal,getContrasts,-1,0,0,character[],1
+ordinal,getContrasts,-1,0,1,list<any>,1
+ordinal,getContrasts,-1,0,2,null,1
+ordinal,getContrasts,0,0,0,any,1
+ordinal,getContrasts,1,0,0,character[],1
+ordinal,getContrasts,1,0,1,list<character>,1
+ordinal,getContrasts,1,0,2,null,1
+ordinal,get_contrasts_marginal,-1,0,0,list<class<`matrix`>>,1
+ordinal,get_contrasts_marginal,0,0,0,class<`clm`>,1
+ordinal,get_contrasts_marginal,1,0,0,character[],1
+ordinal,get_contrasts_marginal,1,0,1,null,1
+ordinal,get_contrasts_type1,-1,0,0,list<class<`matrix`>>,1
+ordinal,get_contrasts_type1,0,0,0,class<`clm`>,1
+ordinal,get_contrasts_type2,-1,0,0,list<class<`matrix`>>,1
+ordinal,get_contrasts_type2,0,0,0,class<`clm`>,1
+ordinal,get_contrasts_type2,1,0,0,character[],1
+ordinal,get_contrasts_type2_unfolded,-1,0,0,list<class<`matrix`>>,1
+ordinal,get_contrasts_type2_unfolded,0,0,0,class<`clm`>,1
+ordinal,get_contrasts_type2_unfolded,1,0,0,null,1
+ordinal,get_contrasts_type3,-1,0,0,list<class<`matrix`>>,1
+ordinal,get_contrasts_type3,0,0,0,class<`clm`>,1
+ordinal,get_contrasts_type3,1,0,0,null,1
+ordinal,getCtrlArgs,-1,0,0,list<character | logical | list<double | character | double>>,1
+ordinal,getCtrlArgs,0,0,0,list<any>,1
+ordinal,getCtrlArgs,1,0,0,list<any>,1
+ordinal,getDims,-1,0,0,list<integer[] | double>,1
+ordinal,getDims,-1,0,1,list<double>,1
+ordinal,getDims,0,0,0,list<any>,1
+ordinal,getDims,1,0,0,list<class<`matrix`> | double | character[]>,1
+ordinal,getDims,2,0,0,list<logical | list<class<`factor`> | integer[] | double | list<class<`dgCMatrix`> | class<`matrix`>>>>,1
+ordinal,getDims,2,0,1,list<logical | list<class<`factor`> | double | list<class<`dgCMatrix`> | class<`matrix`>>>>,1
+ordinal,getFittedC,-1,0,0,double[],1
+ordinal,getFittedC,0,0,0,double[],1
+ordinal,getFittedC,1,0,0,double[],1
+ordinal,getFittedC,2,0,0,character,1
+ordinal,getFittedC,3,0,0,double,1
+ordinal,getFullForm,-1,0,0,class<`formula`>,1
+ordinal,getFullForm,0,0,0,class<`formula`>,1
+ordinal,getFullForm,1,0,0,...,1
+ordinal,getFullForm,2,0,0,any,1
+ordinal,getGnll,-1,0,0,double[],1
+ordinal,getGnll,0,0,0,environment,1
+ordinal,getGnll,1,0,0,any,1
+ordinal,getHnll,-1,0,0,class<`matrix`>,1
+ordinal,getHnll,0,0,0,environment,1
+ordinal,getHnll,1,0,0,double[],1
+ordinal,getLambda,-1,0,0,class<`ddiMatrix`>,1
+ordinal,getLambda,0,0,0,list<class<`matrix`>>,1
+ordinal,getLambda,1,0,0,integer[],1
+ordinal,get_model_matrix,-1,0,0,class<`matrix`>,1
+ordinal,get_model_matrix,0,0,0,class<`clm`>,1
+ordinal,get_model_matrix,1,0,0,character,1
+ordinal,get_model_matrix,2,0,0,character,1
+ordinal,getNLA,-1,0,0,double,1
+ordinal,getNLA,0,0,0,environment,1
+ordinal,getNLA,1,0,0,double[],1
+ordinal,getNLA,2,0,0,logical[],1
+ordinal,getNll,-1,0,0,double,1
+ordinal,getNll,0,0,0,environment,1
+ordinal,getNll,1,0,0,any,1
+ordinal,getOffset,-1,0,0,double[],1
+ordinal,getOffset,0,0,0,class<`data.frame`>,1
+ordinal,getOffset,1,0,0,"class<`formula`, `terms`>",1
+ordinal,getOffsetStd,-1,0,0,double[],1
+ordinal,getOffsetStd,0,0,0,class<`data.frame`>,1
+ordinal,getPar,-1,0,0,double[],1
+ordinal,getPar,0,0,0,environment,1
+ordinal,getPar.clmm,-1,0,0,double[],1
+ordinal,getPar.clmm,0,0,0,environment,1
+ordinal,get_rdX,-1,0,0,class<`matrix`>,1
+ordinal,get_rdX,0,0,0,class<`clm`>,1
+ordinal,get_rdX,1,0,0,logical,1
+ordinal,getREterms,-1,0,0,list<logical | list<class<`factor`> | integer[] | double | list<class<`dgCMatrix`> | class<`matrix`>>>>,1
+ordinal,getREterms,-1,0,1,list<logical | list<class<`factor`> | double | list<class<`dgCMatrix`> | class<`matrix`>>>>,1
+ordinal,getREterms,0,0,0,list<any>,1
+ordinal,getREterms,1,0,0,class<`formula`>,1
+ordinal,get.se,-1,0,0,double[],1
+ordinal,get.se,0,0,0,environment,1
+ordinal,get.se,1,0,0,class<`matrix`>,1
+ordinal,get.se,2,0,0,character,1
+ordinal,getThetamat,-1,0,0,list<class<`data.frame`>>,1
+ordinal,getThetamat,0,0,0,"class<`formula`, `terms`>",1
+ordinal,getThetamat,1,0,0,^double[],1
+ordinal,getThetamat,2,0,0,any,1
+ordinal,getThetamat,3,0,0,any,1
+ordinal,getThetamat,4,0,0,class<`matrix`>,1
+ordinal,getThetamat,5,0,0,any,1
+ordinal,getThetamat,6,0,0,any,1
+ordinal,getWeights,-1,0,0,double[],1
+ordinal,getWeights,0,0,0,class<`data.frame`>,1
+ordinal,getX,-1,0,0,class<`matrix`>,1
+ordinal,getX,0,0,0,class<`data.frame`>,1
+ordinal,getX,1,0,0,class<`data.frame`>,1
+ordinal,getX,2,0,0,null,1
+ordinal,getY,-1,0,0,"class<`factor`, `ordered`>",1
+ordinal,getY,0,0,0,class<`data.frame`>,1
+ordinal,getZt,-1,0,0,class<`dgCMatrix`>,1
+ordinal,getZt,0,0,0,list<list<class<`dgCMatrix`> | class<`matrix`>>>,1
+ordinal,ggumbel,-1,0,0,double[],1
+ordinal,ggumbel,0,0,0,double[],1
+ordinal,ggumbel,1,0,0,logical,1
+ordinal,glgamma,-1,0,0,double[],1
+ordinal,glgamma,0,0,0,integer[],1
+ordinal,glgamma,1,0,0,double,1
+ordinal,glogis,-1,0,0,double[],1
+ordinal,glogis,0,0,0,integer[],1
+ordinal,gnorm,-1,0,0,double[],1
+ordinal,gnorm,0,0,0,integer[],1
+ordinal,grad.lambda,-1,0,0,double,1
+ordinal,grad.lambda,0,0,0,environment,1
+ordinal,grad.lambda,1,0,0,double,1
+ordinal,grad.lambda,2,0,0,character,1
+ordinal,grad.lambda,3,0,0,double,1
+ordinal,grad.u,-1,0,0,class<`dgeMatrix`>,1
+ordinal,grad.u,0,0,0,environment,1
+ordinal,hess.u,-1,0,0,logical,1
+ordinal,hess.u,0,0,0,environment,1
+ordinal,logLik.clm,-1,0,0,class<`logLik`>,1
+ordinal,logLik.clm,0,0,0,class<`clm`>,1
+ordinal,logLik.clm,1,0,0,...,1
+ordinal,makeThresholds,-1,0,0,list<class<`matrix`> | double | character[]>,1
+ordinal,makeThresholds,-1,0,1,list<class<`matrix`> | double | character>,1
+ordinal,makeThresholds,0,0,0,character[],1
+ordinal,makeThresholds,1,0,0,character,1
+ordinal,makeThresholds2,-1,0,0,null,1
+ordinal,makeThresholds2,0,0,0,environment,1
+ordinal,makeThresholds2,1,0,0,character,1
+ordinal,makeThresholds2,2,0,0,...,1
+ordinal,model.frame.clm,-1,0,0,class<`data.frame`>,1
+ordinal,model.frame.clm,0,0,0,class<`clm`>,1
+ordinal,model.frame.clm,1,0,0,...,1
+ordinal,model_matrix,-1,0,0,class<`matrix`>,1
+ordinal,model_matrix,0,0,0,class<`clm`>,1
+ordinal,model_matrix,1,0,0,...,1
+ordinal,model.matrix.clm,-1,0,0,list<class<`matrix`>>,1
+ordinal,model.matrix.clm,0,0,0,class<`clm`>,1
+ordinal,model.matrix.clm,1,0,0,character[],1
+ordinal,model.matrix.clm,2,0,0,...,1
+ordinal,myhess,-1,0,0,class<`matrix`>,1
+ordinal,myhess,0,0,0,class<`function`>,1
+ordinal,myhess,1,0,0,double[],1
+ordinal,myhess,2,0,0,null,1
+ordinal,myhess,3,0,0,double,1
+ordinal,myhess,4,0,0,...,1
+ordinal,namedList,-1,0,0,list<any>,1
+ordinal,namedList,0,0,0,...,1
+ordinal,.negLogLikBase,-1,0,0,null,1
+ordinal,.negLogLikBase,0,0,0,environment,1
+ordinal,.negLogLikMfast,-1,0,0,double,1
+ordinal,.negLogLikMfast,0,0,0,environment,1
+ordinal,newRho,-1,0,0,environment,1
+ordinal,newRho,0,0,0,environment,1
+ordinal,newRho,1,0,0,class<`matrix`>,1
+ordinal,newRho,2,0,0,class<`matrix`>,1
+ordinal,newRho,3,0,0,class<`matrix`>,1
+ordinal,newRho,4,0,0,"class<`factor`, `ordered`>",1
+ordinal,newRho,4,0,1,class<`factor`>,1
+ordinal,newRho,5,0,0,double[],1
+ordinal,newRho,6,0,0,double[],1
+ordinal,newRho,7,0,0,double[],1
+ordinal,nllBase.uC,-1,0,0,null,1
+ordinal,nllBase.uC,0,0,0,environment,1
+ordinal,nllFast.u,-1,0,0,double,1
+ordinal,nllFast.u,0,0,0,environment,1
+ordinal,nll.u,-1,0,0,double,1
+ordinal,nll.u,0,0,0,environment,1
+ordinal,nobars,-1,0,0,class<`call`>,1
+ordinal,nobars,-1,0,1,class<`formula`>,1
+ordinal,nobars,-1,0,2,class<`name`>,1
+ordinal,nobars,-1,0,3,null,1
+ordinal,nobars,0,0,0,class<`call`>,1
+ordinal,nobars,0,0,1,class<`formula`>,1
+ordinal,nobars,0,0,2,class<`name`>,1
+ordinal,nobars,0,0,3,class<`(`>,1
+ordinal,nobs.clm,-1,0,0,double,1
+ordinal,nobs.clm,0,0,0,class<`clm`>,1
+ordinal,nobs.clm,1,0,0,...,1
+ordinal,nominal_test,-1,0,0,"class<`anova`, `data.frame`>",1
+ordinal,nominal_test,0,0,0,class<`clm`>,1
+ordinal,nominal_test,1,0,0,...,1
+ordinal,nominal_test.clm,-1,0,0,"class<`anova`, `data.frame`>",1
+ordinal,nominal_test.clm,0,0,0,class<`clm`>,1
+ordinal,nominal_test.clm,1,0,0,any,1
+ordinal,nominal_test.clm,2,0,0,logical,1
+ordinal,nominal_test.clm,3,0,0,...,1
+ordinal,pAO,-1,0,0,double[],1
+ordinal,pAO,0,0,0,double[],1
+ordinal,pAO,1,0,0,double,1
+ordinal,pAO,2,0,0,logical,1
+ordinal,par2ST,-1,0,0,list<class<`matrix`>>,1
+ordinal,par2ST,0,0,0,double[],1
+ordinal,par2ST,1,0,0,list<class<`matrix`>>,1
+ordinal,paratBoundary2,-1,0,0,integer[],1
+ordinal,paratBoundary2,0,0,0,environment,1
+ordinal,paratBoundary2,0,0,1,list<any>,1
+ordinal,paratBoundary2,1,0,0,double,1
+ordinal,parConstraints,-1,0,0,double[],1
+ordinal,parConstraints,0,0,0,environment,1
+ordinal,pgumbel,-1,0,0,double[],1
+ordinal,pgumbel,0,0,0,double[],1
+ordinal,pgumbel,1,0,0,double,1
+ordinal,pgumbel,2,0,0,double,1
+ordinal,pgumbel,3,0,0,logical,1
+ordinal,pgumbel,4,0,0,logical,1
+ordinal,plgamma,-1,0,0,double[],1
+ordinal,plgamma,0,0,0,double[],1
+ordinal,plgamma,1,0,0,double,1
+ordinal,plgamma,2,0,0,logical,1
+ordinal,plot.profile.clm,-1,0,0,list<list<double[]>>,1
+ordinal,plot.profile.clm,0,0,0,class<`profile.clm`>,1
+ordinal,plot.profile.clm,1,0,0,double,1
+ordinal,plot.profile.clm,1,0,1,integer[],1
+ordinal,plot.profile.clm,2,0,0,double[],1
+ordinal,plot.profile.clm,3,0,0,logical,1
+ordinal,plot.profile.clm,4,0,0,logical,1
+ordinal,plot.profile.clm,5,0,0,logical,1
+ordinal,plot.profile.clm,6,0,0,logical,1
+ordinal,plot.profile.clm,7,0,0,logical,1
+ordinal,plot.profile.clm2,-1,0,0,"class<`profile`, `profile.clmm2`>",1
+ordinal,plot.profile.clm2,-1,0,1,"class<`profile`, `profile.clm2`>",1
+ordinal,plot.profile.clm2,0,0,0,"class<`profile`, `profile.clmm2`>",1
+ordinal,plot.profile.clm2,0,0,1,"class<`profile`, `profile.clm2`>",1
+ordinal,plot.profile.clm2,1,0,0,integer[],1
+ordinal,plot.profile.clm2,2,0,0,double[],1
+ordinal,plot.profile.clm2,3,0,0,logical,1
+ordinal,plot.profile.clm2,4,0,0,logical,1
+ordinal,plot.profile.clm2,5,0,0,logical,1
+ordinal,plot.profile.clm2,6,0,0,double,1
+ordinal,plot.profile.clm2,7,0,0,...,1
+ordinal,plot.profile.clmm2,-1,0,0,"class<`profile`, `profile.clmm2`>",1
+ordinal,plot.profile.clmm2,0,0,0,"class<`profile`, `profile.clmm2`>",1
+ordinal,plot.profile.clmm2,1,0,0,integer,1
+ordinal,plot.profile.clmm2,2,0,0,double[],1
+ordinal,plot.profile.clmm2,3,0,0,logical,1
+ordinal,plot.profile.clmm2,4,0,0,logical,1
+ordinal,plot.profile.clmm2,5,0,0,logical,1
+ordinal,plot.profile.clmm2,6,0,0,double,1
+ordinal,plot.profile.clmm2,7,0,0,...,1
+ordinal,plot.slice.clm,-1,0,0,null,1
+ordinal,plot.slice.clm,0,0,0,class<`slice.clm`>,1
+ordinal,plot.slice.clm,1,0,0,double,1
+ordinal,plot.slice.clm,1,0,1,integer[],1
+ordinal,plot.slice.clm,2,0,0,character[],1
+ordinal,plot.slice.clm,3,0,0,logical,1
+ordinal,plot.slice.clm,4,0,0,logical,1
+ordinal,plot.slice.clm,5,0,0,...,1
+ordinal,predict.clm,-1,0,0,any,1
+ordinal,predict.clm,0,0,0,class<`clm`>,1
+ordinal,predict.clm,1,0,0,any,1
+ordinal,predict.clm,2,0,0,logical,1
+ordinal,predict.clm,3,0,0,logical,1
+ordinal,predict.clm,4,0,0,double,1
+ordinal,predict.clm,5,0,0,character[],1
+ordinal,predict.clm,6,0,0,any,1
+ordinal,predict.clm,7,0,0,...,1
+ordinal,predict.clm2,-1,0,0,double[],1
+ordinal,predict.clm2,0,0,0,"class<`clm2`, `clmm2`>",1
+ordinal,predict.clm2,1,0,0,class<`data.frame`>,1
+ordinal,predict.clm2,2,0,0,...,1
+ordinal,print.conv.check,-1,0,0,character,1
+ordinal,print.conv.check,-1,0,1,null,1
+ordinal,print.conv.check,0,0,0,list<any>,1
+ordinal,print.conv.check,1,0,0,character,1
+ordinal,print.conv.check,2,0,0,...,1
+ordinal,prob.predict.clm,-1,0,0,list<double[]>,1
+ordinal,prob.predict.clm,0,0,0,environment,1
+ordinal,prob.predict.clm,1,0,0,any,1
+ordinal,prob.predict.clm,2,0,0,logical,1
+ordinal,prob.predict.clm,3,0,0,logical,1
+ordinal,prob.predict.clm,4,0,0,any,1
+ordinal,profile.clm,-1,0,0,class<`profile.clm`>,1
+ordinal,profile.clm,0,0,0,class<`clm`>,1
+ordinal,profile.clm,1,0,0,integer[],1
+ordinal,profile.clm,2,0,0,integer[],1
+ordinal,profile.clm,3,0,0,double,1
+ordinal,profile.clm,4,0,0,double,1
+ordinal,profile.clm,5,0,0,double,1
+ordinal,profile.clm,6,0,0,logical,1
+ordinal,profile.clm,7,0,0,double,1
+ordinal,profile.clm2,-1,0,0,"class<`profile`, `profile.clm2`>",1
+ordinal,profile.clm2,0,0,0,class<`clm2`>,1
+ordinal,profile.clm2,1,0,0,double[],1
+ordinal,profile.clm2,2,0,0,double[],1
+ordinal,profile.clm2,3,0,0,logical,1
+ordinal,profile.clm2,4,0,0,double,1
+ordinal,profile.clm2,5,0,0,double,1
+ordinal,profile.clm2,6,0,0,any,1
+ordinal,profile.clm2,7,0,0,double,1
+ordinal,profile.clm.beta,-1,0,0,list<class<`data.frame`>>,1
+ordinal,profile.clm.beta,0,0,0,class<`clm`>,1
+ordinal,profile.clm.beta,1,0,0,integer[],1
+ordinal,profile.clm.beta,2,0,0,double,1
+ordinal,profile.clm.beta,3,0,0,double,1
+ordinal,profile.clm.beta,4,0,0,double,1
+ordinal,profile.clm.beta,5,0,0,logical,1
+ordinal,profile.clm.beta,6,0,0,double,1
+ordinal,profile.clm.beta,7,0,0,list<any>,1
+ordinal,profile.clmm2,-1,0,0,"class<`profile`, `profile.clmm2`>",1
+ordinal,profile.clmm2,0,0,0,"class<`clm2`, `clmm2`>",1
+ordinal,profile.clmm2,1,0,0,double,1
+ordinal,profile.clmm2,2,0,0,double[],1
+ordinal,profile.clmm2,3,0,0,double,1
+ordinal,profile.clmm2,4,0,0,double,1
+ordinal,profile.clmm2,5,0,0,...,1
+ordinal,profile.clm.zeta,-1,0,0,list<class<`data.frame`>>,1
+ordinal,profile.clm.zeta,0,0,0,class<`clm`>,1
+ordinal,profile.clm.zeta,1,0,0,integer,1
+ordinal,profile.clm.zeta,2,0,0,double,1
+ordinal,profile.clm.zeta,3,0,0,double,1
+ordinal,profile.clm.zeta,4,0,0,double,1
+ordinal,profile.clm.zeta,5,0,0,logical,1
+ordinal,profile.clm.zeta,6,0,0,double,1
+ordinal,profile.clm.zeta,7,0,0,list<any>,1
+ordinal,profileLambda,-1,0,0,class<`data.frame`>,1
+ordinal,profileLambda,0,0,0,class<`clm2`>,1
+ordinal,profileLambda,1,0,0,character,1
+ordinal,profileLambda,2,0,0,any,1
+ordinal,profileLambda,3,0,0,double,1
+ordinal,profileLambda,4,0,0,double,1
+ordinal,profileLambda,5,0,0,...,1
+ordinal,qgumbel,-1,0,0,double[],1
+ordinal,qgumbel,0,0,0,double[],1
+ordinal,qgumbel,1,0,0,double,1
+ordinal,qgumbel,2,0,0,double,1
+ordinal,qgumbel,3,0,0,logical,1
+ordinal,qgumbel,4,0,0,logical,1
+ordinal,ranef,-1,0,0,list<class<`data.frame`>>,1
+ordinal,ranef,0,0,0,class<`clmm`>,1
+ordinal,ranef,1,0,0,...,1
+ordinal,ranef.clmm,-1,0,0,list<class<`data.frame`>>,1
+ordinal,ranef.clmm,0,0,0,class<`clmm`>,1
+ordinal,ranef.clmm,1,0,0,logical,1
+ordinal,ranef.clmm,2,0,0,...,1
+ordinal,rbindall,-1,0,0,class<`data.frame`>,1
+ordinal,rbindall,0,0,0,...,1
+ordinal,response.name,-1,0,0,character,1
+ordinal,response.name,0,0,0,"class<`formula`, `terms`>",1
+ordinal,rgumbel,-1,0,0,double[],1
+ordinal,rgumbel,0,0,0,double,1
+ordinal,rgumbel,1,0,0,double,1
+ordinal,rgumbel,2,0,0,double,1
+ordinal,rgumbel,3,0,0,logical,1
+ordinal,rho.clm2clmm,-1,0,0,double,1
+ordinal,rho.clm2clmm,0,0,0,environment,1
+ordinal,rho.clm2clmm,1,0,0,list<logical | list<class<`factor`> | integer[] | double | list<class<`dgCMatrix`> | class<`matrix`>>>>,1
+ordinal,rho.clm2clmm,2,0,0,list<double | character>,1
+ordinal,rho.clm2clmm.ssr,-1,0,0,list<class<`matrix`>>,1
+ordinal,rho.clm2clmm.ssr,0,0,0,environment,1
+ordinal,rho.clm2clmm.ssr,1,0,0,list<logical | list<class<`factor`> | double | list<class<`dgCMatrix`> | class<`matrix`>>>>,1
+ordinal,rho.clm2clmm.ssr,2,0,0,list<double | character>,1
+ordinal,scale_test,-1,0,0,"class<`anova`, `data.frame`>",1
+ordinal,scale_test,0,0,0,class<`clm`>,1
+ordinal,scale_test,1,0,0,...,1
+ordinal,scale_test.clm,-1,0,0,"class<`anova`, `data.frame`>",1
+ordinal,scale_test.clm,0,0,0,class<`clm`>,1
+ordinal,scale_test.clm,1,0,0,any,1
+ordinal,scale_test.clm,2,0,0,logical,1
+ordinal,scale_test.clm,3,0,0,...,1
+ordinal,set.AGQ,-1,0,0,any,1
+ordinal,set.AGQ,0,0,0,any,1
+ordinal,set.AGQ,1,0,0,integer,1
+ordinal,set.AGQ,2,0,0,any,1
+ordinal,set.AGQ,3,0,0,any,1
+ordinal,setLinks,-1,0,0,double,1
+ordinal,setLinks,-1,0,1,null,1
+ordinal,setLinks,0,0,0,environment,1
+ordinal,setLinks,1,0,0,character,1
+ordinal,setPar.clmm,-1,0,0,list<class<`matrix`>>,1
+ordinal,setPar.clmm,0,0,0,environment,1
+ordinal,setPar.clmm,1,0,0,double[],1
+ordinal,setPar.clmm,2,0,0,logical[],1
+ordinal,set.start,-1,0,0,any,1
+ordinal,set.start,0,0,0,environment,1
+ordinal,set.start,1,0,0,any,1
+ordinal,set.start,2,0,0,logical,1
+ordinal,set.start,3,0,0,any,1
+ordinal,set.start,4,0,0,any,1
+ordinal,set.start,5,0,0,list<any>,1
+ordinal,setStart,-1,0,0,double[],1
+ordinal,setStart,0,0,0,environment,1
+ordinal,signif.digits,-1,0,0,integer[],1
+ordinal,signif.digits,0,0,0,double[],1
+ordinal,signif.digits,1,0,0,double[],1
+ordinal,single_anova,-1,0,0,any,1
+ordinal,single_anova,0,0,0,class<`clm`>,1
+ordinal,single_anova,1,0,0,character[],1
+ordinal,single_anova,1,0,1,double,1
+ordinal,slashTerms,-1,0,0,class<`call`>,1
+ordinal,slashTerms,-1,0,1,class<`name`>,1
+ordinal,slashTerms,0,0,0,class<`call`>,1
+ordinal,slashTerms,0,0,1,class<`name`>,1
+ordinal,slice,-1,0,0,class<`slice.clm`>,1
+ordinal,slice,0,0,0,class<`clm`>,1
+ordinal,slice,1,0,0,...,1
+ordinal,slice.clm,-1,0,0,class<`slice.clm`>,1
+ordinal,slice.clm,0,0,0,class<`clm`>,1
+ordinal,slice.clm,1,0,0,integer[],1
+ordinal,slice.clm,2,0,0,double,1
+ordinal,slice.clm,3,0,0,double,1
+ordinal,slice.clm,4,0,0,logical,1
+ordinal,slice.clm,5,0,0,...,1
+ordinal,ST2par,-1,0,0,double[],1
+ordinal,ST2par,0,0,0,list<class<`matrix`>>,1
+ordinal,start.beta,-1,0,0,double[],1
+ordinal,start.beta,0,0,0,class<`matrix`>,1
+ordinal,start.beta,1,0,0,logical,1
+ordinal,start.threshold,-1,0,0,double[],1
+ordinal,start.threshold,0,0,0,character[],1
+ordinal,start.threshold,1,0,0,character,1
+ordinal,STconstraints,-1,0,0,integer[],1
+ordinal,STconstraints,0,0,0,list<class<`matrix`>>,1
+ordinal,STstart,-1,0,0,list<class<`matrix`>>,1
+ordinal,STstart,0,0,0,list<class<`matrix`>>,1
+ordinal,subbars,-1,0,0,class<`(`>,1
+ordinal,subbars,-1,0,1,class<`call`>,1
+ordinal,subbars,-1,0,2,class<`formula`>,1
+ordinal,subbars,-1,0,3,class<`name`>,1
+ordinal,subbars,-1,0,4,double,1
+ordinal,subbars,0,0,0,class<`(`>,1
+ordinal,subbars,0,0,1,class<`call`>,1
+ordinal,subbars,0,0,2,class<`formula`>,1
+ordinal,subbars,0,0,3,class<`name`>,1
+ordinal,subbars,0,0,4,double,1
+ordinal,summary.clm,-1,0,0,class<`summary.clm`>,1
+ordinal,summary.clm,0,0,0,class<`clm`>,1
+ordinal,summary.clm,1,0,0,double,1
+ordinal,summary.clm,2,0,0,...,1
+ordinal,summary.clm2,-1,0,0,class<`summary.clm2`>,1
+ordinal,summary.clm2,0,0,0,class<`clm2`>,1
+ordinal,summary.clm2,1,0,0,double,1
+ordinal,summary.clm2,2,0,0,logical,1
+ordinal,summary.clm2,3,0,0,...,1
+ordinal,summary.clmm,-1,0,0,class<`summary.clmm`>,1
+ordinal,summary.clmm,0,0,0,class<`clmm`>,1
+ordinal,summary.clmm,1,0,0,logical,1
+ordinal,summary.clmm,2,0,0,...,1
+ordinal,summary.clmm2,-1,0,0,class<`summary.clmm2`>,1
+ordinal,summary.clmm2,0,0,0,"class<`clm2`, `clmm2`>",1
+ordinal,summary.clmm2,1,0,0,double,1
+ordinal,summary.clmm2,2,0,0,logical,1
+ordinal,summary.clmm2,3,0,0,...,1
+ordinal,term2colX,-1,0,0,list<double[]>,1
+ordinal,term2colX,0,0,0,"class<`formula`, `terms`>",1
+ordinal,term2colX,1,0,0,class<`matrix`>,1
+ordinal,term_contain,-1,0,0,logical[],1
+ordinal,term_contain,0,0,0,character,1
+ordinal,term_contain,1,0,0,class<`matrix`>,1
+ordinal,term_contain,2,0,0,character[],1
+ordinal,term_contain,3,0,0,character[],1
+ordinal,terms.clm,-1,0,0,"class<`formula`, `terms`>",1
+ordinal,terms.clm,-1,0,1,"list<class<`formula`, `terms`>>",1
+ordinal,terms.clm,0,0,0,class<`clm`>,1
+ordinal,terms.clm,1,0,0,character[],1
+ordinal,terms.clm,2,0,0,...,1
+ordinal,test_no_ranef,-1,0,0,null,1
+ordinal,test_no_ranef,0,0,0,list<list<class<`dgCMatrix`> | class<`matrix`>>>,1
+ordinal,test_no_ranef,1,0,0,list<any>,1
+ordinal,test_no_ranef,2,0,0,character,1
+ordinal,update.clm2,-1,0,0,class<`clm2`>,1
+ordinal,update.clm2,-1,0,1,environment,1
+ordinal,update.clm2,0,0,0,class<`clm2`>,1
+ordinal,update.clm2,1,0,0,any,1
+ordinal,update.clm2,2,0,0,any,1
+ordinal,update.clm2,3,0,0,any,1
+ordinal,update.clm2,4,0,0,any,1
+ordinal,update.clm2,5,0,0,...,1
+ordinal,update.clm2,6,0,0,logical,1
+ordinal,update.clmm2,-1,0,0,"class<`clm2`, `clmm2`>",1
+ordinal,update.clmm2,0,0,0,"class<`clm2`, `clmm2`>",1
+ordinal,update.clmm2,1,0,0,any,1
+ordinal,update.clmm2,2,0,0,any,1
+ordinal,update.clmm2,3,0,0,any,1
+ordinal,update.clmm2,4,0,0,any,1
+ordinal,update.clmm2,5,0,0,...,1
+ordinal,update.clmm2,6,0,0,logical,1
+ordinal,update.u,-1,0,0,logical,1
+ordinal,update.u,0,0,0,environment,1
+ordinal,update.uC,-1,0,0,logical,1
+ordinal,update.uC,0,0,0,environment,1
+ordinal,VarCorr,-1,0,0,list<class<`matrix`>>,1
+ordinal,VarCorr,0,0,0,class<`clmm`>,1
+ordinal,VarCorr,1,0,0,...,1
+ordinal,VarCorr.clmm,-1,0,0,list<class<`matrix`>>,1
+ordinal,VarCorr.clmm,0,0,0,class<`clmm`>,1
+ordinal,VarCorr.clmm,1,0,0,...,1
+ordinal,varcov,-1,0,0,list<class<`matrix`>>,1
+ordinal,varcov,0,0,0,class<`clmm`>,1
+ordinal,varcov,1,0,0,logical,1
+ordinal,varcov,2,0,0,any,1
+ordinal,varcov,3,0,0,...,1
+ordinal,vcov.clm,-1,0,0,class<`matrix`>,1
+ordinal,vcov.clm,0,0,0,class<`clmm`>,1
+ordinal,vcov.clm,0,0,1,class<`clm`>,1
+ordinal,vcov.clm,1,0,0,any,1
+ordinal,vcov.clm,2,0,0,character[],1
+ordinal,vcov.clm,3,0,0,...,1
+ordinal,vcov.clm2,-1,0,0,class<`matrix`>,1
+ordinal,vcov.clm2,0,0,0,class<`clm2`>,1
+ordinal,vcov.clm2,1,0,0,...,1
+ordinal,vcov.clmm,-1,0,0,class<`matrix`>,1
+ordinal,vcov.clmm,0,0,0,class<`clmm`>,1
+ordinal,vcov.clmm,1,0,0,...,1
+ordinal,vcov.clmm2,-1,0,0,class<`matrix`>,1
+ordinal,vcov.clmm2,0,0,0,"class<`clm2`, `clmm2`>",1
+ordinal,vcov.clmm2,1,0,0,...,1
+orthopolynom,chebyshev.c.inner.products,-1,0,0,double[],1
+orthopolynom,chebyshev.c.inner.products,0,0,0,double,1
+orthopolynom,chebyshev.c.polynomials,-1,0,0,list<class<`polynomial`>>,1
+orthopolynom,chebyshev.c.polynomials,0,0,0,double,1
+orthopolynom,chebyshev.c.polynomials,1,0,0,logical,1
+orthopolynom,chebyshev.c.recurrences,-1,0,0,class<`data.frame`>,1
+orthopolynom,chebyshev.c.recurrences,0,0,0,double,1
+orthopolynom,chebyshev.c.recurrences,1,0,0,logical,1
+orthopolynom,chebyshev.c.weight,-1,0,0,double[],1
+orthopolynom,chebyshev.c.weight,0,0,0,double[],1
+orthopolynom,chebyshev.s.inner.products,-1,0,0,double[],1
+orthopolynom,chebyshev.s.inner.products,0,0,0,double,1
+orthopolynom,chebyshev.s.polynomials,-1,0,0,list<class<`polynomial`>>,1
+orthopolynom,chebyshev.s.polynomials,0,0,0,double,1
+orthopolynom,chebyshev.s.polynomials,1,0,0,logical,1
+orthopolynom,chebyshev.s.recurrences,-1,0,0,class<`data.frame`>,1
+orthopolynom,chebyshev.s.recurrences,0,0,0,double,1
+orthopolynom,chebyshev.s.recurrences,1,0,0,logical,1
+orthopolynom,chebyshev.s.weight,-1,0,0,double[],1
+orthopolynom,chebyshev.s.weight,0,0,0,double[],1
+orthopolynom,chebyshev.t.inner.products,-1,0,0,double[],1
+orthopolynom,chebyshev.t.inner.products,0,0,0,double,1
+orthopolynom,chebyshev.t.polynomials,-1,0,0,list<class<`polynomial`>>,1
+orthopolynom,chebyshev.t.polynomials,0,0,0,double,1
+orthopolynom,chebyshev.t.polynomials,1,0,0,logical,1
+orthopolynom,chebyshev.t.recurrences,-1,0,0,class<`data.frame`>,1
+orthopolynom,chebyshev.t.recurrences,0,0,0,double,1
+orthopolynom,chebyshev.t.recurrences,1,0,0,logical,1
+orthopolynom,chebyshev.t.weight,-1,0,0,double[],1
+orthopolynom,chebyshev.t.weight,0,0,0,double[],1
+orthopolynom,chebyshev.u.inner.products,-1,0,0,double[],1
+orthopolynom,chebyshev.u.inner.products,0,0,0,double,1
+orthopolynom,chebyshev.u.polynomials,-1,0,0,list<class<`polynomial`>>,1
+orthopolynom,chebyshev.u.polynomials,0,0,0,double,1
+orthopolynom,chebyshev.u.polynomials,1,0,0,logical,1
+orthopolynom,chebyshev.u.recurrences,-1,0,0,class<`data.frame`>,1
+orthopolynom,chebyshev.u.recurrences,0,0,0,double,1
+orthopolynom,chebyshev.u.recurrences,1,0,0,logical,1
+orthopolynom,chebyshev.u.weight,-1,0,0,double[],1
+orthopolynom,chebyshev.u.weight,0,0,0,double[],1
+orthopolynom,gegenbauer.inner.products,-1,0,0,double[],1
+orthopolynom,gegenbauer.inner.products,0,0,0,double,1
+orthopolynom,gegenbauer.inner.products,1,0,0,double,1
+orthopolynom,gegenbauer.polynomials,-1,0,0,list<class<`polynomial`>>,1
+orthopolynom,gegenbauer.polynomials,0,0,0,double,1
+orthopolynom,gegenbauer.polynomials,1,0,0,double,1
+orthopolynom,gegenbauer.polynomials,2,0,0,logical,1
+orthopolynom,gegenbauer.recurrences,-1,0,0,class<`data.frame`>,1
+orthopolynom,gegenbauer.recurrences,0,0,0,double,1
+orthopolynom,gegenbauer.recurrences,1,0,0,double,1
+orthopolynom,gegenbauer.recurrences,2,0,0,logical,1
+orthopolynom,gegenbauer.weight,-1,0,0,double[],1
+orthopolynom,gegenbauer.weight,0,0,0,double[],1
+orthopolynom,gegenbauer.weight,1,0,0,double,1
+orthopolynom,ghermite.h.inner.products,-1,0,0,double[],1
+orthopolynom,ghermite.h.inner.products,0,0,0,double,1
+orthopolynom,ghermite.h.inner.products,1,0,0,double,1
+orthopolynom,ghermite.h.polynomials,-1,0,0,list<class<`polynomial`>>,1
+orthopolynom,ghermite.h.polynomials,0,0,0,double,1
+orthopolynom,ghermite.h.polynomials,1,0,0,double,1
+orthopolynom,ghermite.h.polynomials,2,0,0,logical,1
+orthopolynom,ghermite.h.recurrences,-1,0,0,class<`data.frame`>,1
+orthopolynom,ghermite.h.recurrences,0,0,0,double,1
+orthopolynom,ghermite.h.recurrences,1,0,0,double,1
+orthopolynom,ghermite.h.recurrences,2,0,0,logical,1
+orthopolynom,ghermite.h.weight,-1,0,0,double[],1
+orthopolynom,ghermite.h.weight,0,0,0,double[],1
+orthopolynom,ghermite.h.weight,1,0,0,double,1
+orthopolynom,glaguerre.inner.products,-1,0,0,double[],1
+orthopolynom,glaguerre.inner.products,0,0,0,double,1
+orthopolynom,glaguerre.inner.products,1,0,0,double,1
+orthopolynom,glaguerre.polynomials,-1,0,0,list<class<`polynomial`>>,1
+orthopolynom,glaguerre.polynomials,0,0,0,double,1
+orthopolynom,glaguerre.polynomials,1,0,0,double,1
+orthopolynom,glaguerre.polynomials,2,0,0,logical,1
+orthopolynom,glaguerre.recurrences,-1,0,0,class<`data.frame`>,1
+orthopolynom,glaguerre.recurrences,0,0,0,double,1
+orthopolynom,glaguerre.recurrences,1,0,0,double,1
+orthopolynom,glaguerre.recurrences,2,0,0,logical,1
+orthopolynom,glaguerre.weight,-1,0,0,double[],1
+orthopolynom,glaguerre.weight,0,0,0,double[],1
+orthopolynom,glaguerre.weight,1,0,0,double,1
+orthopolynom,hermite.he.inner.products,-1,0,0,double[],1
+orthopolynom,hermite.he.inner.products,0,0,0,double,1
+orthopolynom,hermite.he.polynomials,-1,0,0,list<class<`polynomial`>>,1
+orthopolynom,hermite.he.polynomials,0,0,0,double,1
+orthopolynom,hermite.he.polynomials,1,0,0,logical,1
+orthopolynom,hermite.he.recurrences,-1,0,0,class<`data.frame`>,1
+orthopolynom,hermite.he.recurrences,0,0,0,double,1
+orthopolynom,hermite.he.recurrences,1,0,0,logical,1
+orthopolynom,hermite.he.weight,-1,0,0,double[],1
+orthopolynom,hermite.he.weight,0,0,0,double[],1
+orthopolynom,hermite.h.inner.products,-1,0,0,double[],1
+orthopolynom,hermite.h.inner.products,0,0,0,double,1
+orthopolynom,hermite.h.polynomials,-1,0,0,list<class<`polynomial`>>,1
+orthopolynom,hermite.h.polynomials,0,0,0,double,1
+orthopolynom,hermite.h.polynomials,1,0,0,logical,1
+orthopolynom,hermite.h.recurrences,-1,0,0,class<`data.frame`>,1
+orthopolynom,hermite.h.recurrences,0,0,0,double,1
+orthopolynom,hermite.h.recurrences,1,0,0,logical,1
+orthopolynom,hermite.h.weight,-1,0,0,double[],1
+orthopolynom,hermite.h.weight,0,0,0,double[],1
+orthopolynom,jacobi.g.inner.products,-1,0,0,double[],1
+orthopolynom,jacobi.g.inner.products,0,0,0,double,1
+orthopolynom,jacobi.g.inner.products,1,0,0,double,1
+orthopolynom,jacobi.g.inner.products,2,0,0,double,1
+orthopolynom,jacobi.g.polynomials,-1,0,0,list<class<`polynomial`>>,1
+orthopolynom,jacobi.g.polynomials,0,0,0,double,1
+orthopolynom,jacobi.g.polynomials,1,0,0,double,1
+orthopolynom,jacobi.g.polynomials,2,0,0,double,1
+orthopolynom,jacobi.g.polynomials,3,0,0,logical,1
+orthopolynom,jacobi.g.recurrences,-1,0,0,class<`data.frame`>,1
+orthopolynom,jacobi.g.recurrences,0,0,0,double,1
+orthopolynom,jacobi.g.recurrences,1,0,0,double,1
+orthopolynom,jacobi.g.recurrences,2,0,0,double,1
+orthopolynom,jacobi.g.recurrences,3,0,0,logical,1
+orthopolynom,jacobi.g.weight,-1,0,0,double[],1
+orthopolynom,jacobi.g.weight,0,0,0,double[],1
+orthopolynom,jacobi.g.weight,1,0,0,double,1
+orthopolynom,jacobi.g.weight,2,0,0,double,1
+orthopolynom,jacobi.matrices,-1,0,0,list<double | class<`matrix`>>,1
+orthopolynom,jacobi.matrices,0,0,0,class<`data.frame`>,1
+orthopolynom,jacobi.p.inner.products,-1,0,0,double[],1
+orthopolynom,jacobi.p.inner.products,0,0,0,double,1
+orthopolynom,jacobi.p.inner.products,1,0,0,double,1
+orthopolynom,jacobi.p.inner.products,2,0,0,double,1
+orthopolynom,jacobi.p.polynomials,-1,0,0,list<class<`polynomial`>>,1
+orthopolynom,jacobi.p.polynomials,0,0,0,double,1
+orthopolynom,jacobi.p.polynomials,1,0,0,double,1
+orthopolynom,jacobi.p.polynomials,2,0,0,double,1
+orthopolynom,jacobi.p.polynomials,3,0,0,logical,1
+orthopolynom,jacobi.p.recurrences,-1,0,0,class<`data.frame`>,1
+orthopolynom,jacobi.p.recurrences,0,0,0,double,1
+orthopolynom,jacobi.p.recurrences,1,0,0,double,1
+orthopolynom,jacobi.p.recurrences,2,0,0,double,1
+orthopolynom,jacobi.p.recurrences,3,0,0,logical,1
+orthopolynom,jacobi.p.weight,-1,0,0,double[],1
+orthopolynom,jacobi.p.weight,0,0,0,double[],1
+orthopolynom,jacobi.p.weight,1,0,0,double,1
+orthopolynom,jacobi.p.weight,2,0,0,double,1
+orthopolynom,laguerre.inner.products,-1,0,0,double[],1
+orthopolynom,laguerre.inner.products,0,0,0,double,1
+orthopolynom,laguerre.polynomials,-1,0,0,list<class<`polynomial`>>,1
+orthopolynom,laguerre.polynomials,0,0,0,double,1
+orthopolynom,laguerre.polynomials,1,0,0,logical,1
+orthopolynom,laguerre.recurrences,-1,0,0,class<`data.frame`>,1
+orthopolynom,laguerre.recurrences,0,0,0,double,1
+orthopolynom,laguerre.recurrences,1,0,0,logical,1
+orthopolynom,laguerre.weight,-1,0,0,double[],1
+orthopolynom,laguerre.weight,0,0,0,double[],1
+orthopolynom,legendre.inner.products,-1,0,0,double[],1
+orthopolynom,legendre.inner.products,0,0,0,double,1
+orthopolynom,legendre.polynomials,-1,0,0,list<class<`polynomial`>>,1
+orthopolynom,legendre.polynomials,0,0,0,double,1
+orthopolynom,legendre.polynomials,1,0,0,logical,1
+orthopolynom,legendre.recurrences,-1,0,0,class<`data.frame`>,1
+orthopolynom,legendre.recurrences,0,0,0,double,1
+orthopolynom,legendre.recurrences,1,0,0,logical,1
+orthopolynom,legendre.weight,-1,0,0,double[],1
+orthopolynom,legendre.weight,0,0,0,double[],1
+orthopolynom,lpochhammer,-1,0,0,double,1
+orthopolynom,lpochhammer,0,0,0,double,1
+orthopolynom,lpochhammer,1,0,0,double,1
+orthopolynom,monic.polynomial.recurrences,-1,0,0,class<`data.frame`>,1
+orthopolynom,monic.polynomial.recurrences,0,0,0,class<`data.frame`>,1
+orthopolynom,monic.polynomials,-1,0,0,list<class<`polynomial`>>,1
+orthopolynom,monic.polynomials,0,0,0,class<`data.frame`>,1
+orthopolynom,orthogonal.polynomials,-1,0,0,list<class<`polynomial`>>,1
+orthopolynom,orthogonal.polynomials,0,0,0,class<`data.frame`>,1
+orthopolynom,orthonormal.polynomials,-1,0,0,list<class<`polynomial`>>,1
+orthopolynom,orthonormal.polynomials,0,0,0,class<`data.frame`>,1
+orthopolynom,orthonormal.polynomials,1,0,0,class<`polynomial`>,1
+orthopolynom,pochhammer,-1,0,0,double,1
+orthopolynom,pochhammer,0,0,0,double,1
+orthopolynom,pochhammer,1,0,0,double,1
+orthopolynom,polynomial.coefficients,-1,0,0,list<double[]>,1
+orthopolynom,polynomial.coefficients,0,0,0,list<class<`polynomial`>>,1
+orthopolynom,polynomial.derivatives,-1,0,0,list<class<`polynomial`>>,1
+orthopolynom,polynomial.derivatives,0,0,0,list<class<`polynomial`>>,1
+orthopolynom,polynomial.functions,-1,0,0,list<class<`function`>>,1
+orthopolynom,polynomial.functions,0,0,0,list<class<`polynomial`>>,1
+orthopolynom,polynomial.functions,1,0,0,...,1
+orthopolynom,polynomial.integrals,-1,0,0,list<class<`polynomial`>>,1
+orthopolynom,polynomial.integrals,0,0,0,list<class<`polynomial`>>,1
+orthopolynom,polynomial.orders,-1,0,0,double[],1
+orthopolynom,polynomial.orders,0,0,0,list<class<`polynomial`>>,1
+orthopolynom,polynomial.powers,-1,0,0,list<double[]>,1
+orthopolynom,polynomial.powers,0,0,0,list<class<`polynomial`>>,1
+orthopolynom,polynomial.roots,-1,0,0,list<null | double[]>,1
+orthopolynom,polynomial.roots,0,0,0,class<`data.frame`>,1
+orthopolynom,polynomial.values,-1,0,0,list<double[]>,1
+orthopolynom,polynomial.values,0,0,0,list<class<`polynomial`>>,1
+orthopolynom,polynomial.values,1,0,0,double[],1
+orthopolynom,scaleX,-1,0,0,double[],1
+orthopolynom,scaleX,0,0,0,double[],1
+orthopolynom,scaleX,1,0,0,double,1
+orthopolynom,scaleX,2,0,0,double,1
+orthopolynom,scaleX,3,0,0,double,1
+orthopolynom,scaleX,4,0,0,double,1
+orthopolynom,schebyshev.t.inner.products,-1,0,0,double[],1
+orthopolynom,schebyshev.t.inner.products,0,0,0,double,1
+orthopolynom,schebyshev.t.polynomials,-1,0,0,list<class<`polynomial`>>,1
+orthopolynom,schebyshev.t.polynomials,0,0,0,double,1
+orthopolynom,schebyshev.t.polynomials,1,0,0,logical,1
+orthopolynom,schebyshev.t.recurrences,-1,0,0,class<`data.frame`>,1
+orthopolynom,schebyshev.t.recurrences,0,0,0,double,1
+orthopolynom,schebyshev.t.recurrences,1,0,0,logical,1
+orthopolynom,schebyshev.t.weight,-1,0,0,double[],1
+orthopolynom,schebyshev.t.weight,0,0,0,double[],1
+orthopolynom,schebyshev.u.inner.products,-1,0,0,double[],1
+orthopolynom,schebyshev.u.inner.products,0,0,0,double,1
+orthopolynom,schebyshev.u.polynomials,-1,0,0,list<class<`polynomial`>>,1
+orthopolynom,schebyshev.u.polynomials,0,0,0,double,1
+orthopolynom,schebyshev.u.polynomials,1,0,0,logical,1
+orthopolynom,schebyshev.u.recurrences,-1,0,0,class<`data.frame`>,1
+orthopolynom,schebyshev.u.recurrences,0,0,0,double,1
+orthopolynom,schebyshev.u.recurrences,1,0,0,logical,1
+orthopolynom,schebyshev.u.weight,-1,0,0,double[],1
+orthopolynom,schebyshev.u.weight,0,0,0,double[],1
+orthopolynom,slegendre.inner.products,-1,0,0,double[],1
+orthopolynom,slegendre.inner.products,0,0,0,double,1
+orthopolynom,slegendre.polynomials,-1,0,0,list<class<`polynomial`>>,1
+orthopolynom,slegendre.polynomials,0,0,0,double,1
+orthopolynom,slegendre.polynomials,1,0,0,logical,1
+orthopolynom,slegendre.recurrences,-1,0,0,class<`data.frame`>,1
+orthopolynom,slegendre.recurrences,0,0,0,double,1
+orthopolynom,slegendre.recurrences,1,0,0,logical,1
+orthopolynom,slegendre.weight,-1,0,0,double[],1
+orthopolynom,slegendre.weight,0,0,0,double[],1
+orthopolynom,spherical.inner.products,-1,0,0,double[],1
+orthopolynom,spherical.inner.products,0,0,0,double,1
+orthopolynom,spherical.polynomials,-1,0,0,list<class<`polynomial`>>,1
+orthopolynom,spherical.polynomials,0,0,0,double,1
+orthopolynom,spherical.polynomials,1,0,0,logical,1
+orthopolynom,spherical.recurrences,-1,0,0,class<`data.frame`>,1
+orthopolynom,spherical.recurrences,0,0,0,double,1
+orthopolynom,spherical.recurrences,1,0,0,logical,1
+orthopolynom,spherical.weight,-1,0,0,double[],1
+orthopolynom,spherical.weight,0,0,0,double[],1
+orthopolynom,ultraspherical.inner.products,-1,0,0,double[],1
+orthopolynom,ultraspherical.inner.products,0,0,0,double,1
+orthopolynom,ultraspherical.inner.products,1,0,0,double,1
+orthopolynom,ultraspherical.polynomials,-1,0,0,list<class<`polynomial`>>,1
+orthopolynom,ultraspherical.polynomials,0,0,0,double,1
+orthopolynom,ultraspherical.polynomials,1,0,0,double,1
+orthopolynom,ultraspherical.polynomials,2,0,0,logical,1
+orthopolynom,ultraspherical.recurrences,-1,0,0,class<`data.frame`>,1
+orthopolynom,ultraspherical.recurrences,0,0,0,double,1
+orthopolynom,ultraspherical.recurrences,1,0,0,double,1
+orthopolynom,ultraspherical.recurrences,2,0,0,logical,1
+orthopolynom,ultraspherical.weight,-1,0,0,double[],1
+orthopolynom,ultraspherical.weight,0,0,0,double[],1
+orthopolynom,ultraspherical.weight,1,0,0,double,1
+outliers,chisq.out.test,-1,0,0,class<`htest`>,1
+outliers,chisq.out.test,0,0,0,double[],1
+outliers,chisq.out.test,1,0,0,double,1
+outliers,chisq.out.test,2,0,0,logical,1
+outliers,cochran.test,-1,0,0,class<`htest`>,1
+outliers,cochran.test,0,0,0,class<`formula`>,1
+outliers,cochran.test,0,0,1,double[],1
+outliers,cochran.test,1,0,0,class<`data.frame`>,1
+outliers,cochran.test,1,0,1,double[],1
+outliers,cochran.test,2,0,0,logical,1
+outliers,dixon.test,-1,0,0,class<`htest`>,1
+outliers,dixon.test,0,0,0,double[],1
+outliers,dixon.test,1,0,0,double,1
+outliers,dixon.test,2,0,0,logical,1
+outliers,dixon.test,3,0,0,logical,1
+outliers,grubbs.test,-1,0,0,class<`htest`>,1
+outliers,grubbs.test,0,0,0,double[],1
+outliers,grubbs.test,1,0,0,double,1
+outliers,grubbs.test,2,0,0,logical,1
+outliers,grubbs.test,3,0,0,logical,1
+outliers,outlier,-1,0,0,class<`matrix`>,1
+outliers,outlier,-1,0,1,double[],1
+outliers,outlier,0,0,0,double[],1
+outliers,outlier,0,0,1,class<`matrix`>,1
+outliers,outlier,1,0,0,logical,1
+outliers,outlier,2,0,0,logical,1
+outliers,pcochran,-1,0,0,double,1
+outliers,pcochran,0,0,0,double,1
+outliers,pcochran,1,0,0,double,1
+outliers,pcochran,2,0,0,double,1
+outliers,pdixon,-1,0,0,double,1
+outliers,pdixon,0,0,0,double,1
+outliers,pdixon,1,0,0,integer,1
+outliers,pdixon,2,0,0,double,1
+outliers,pgrubbs,-1,0,0,double,1
+outliers,pgrubbs,0,0,0,double,1
+outliers,pgrubbs,1,0,0,integer,1
+outliers,pgrubbs,2,0,0,double,1
+outliers,qcochran,-1,0,0,double,1
+outliers,qcochran,0,0,0,double,1
+outliers,qcochran,1,0,0,double,1
+outliers,qcochran,2,0,0,double,1
+outliers,qdixon,-1,0,0,double,1
+outliers,qdixon,0,0,0,double,1
+outliers,qdixon,1,0,0,integer,1
+outliers,qdixon,2,0,0,double,1
+outliers,qdixon,3,0,0,logical,1
+outliers,qgrubbs,-1,0,0,double,1
+outliers,qgrubbs,0,0,0,double,1
+outliers,qgrubbs,1,0,0,integer,1
+outliers,qgrubbs,2,0,0,double,1
+outliers,qgrubbs,3,0,0,logical,1
+outliers,qtable,-1,0,0,double,1
+outliers,qtable,0,0,0,double,1
+outliers,qtable,1,0,0,double[],1
+outliers,qtable,2,0,0,double[],1
+outliers,rm.outlier,-1,0,0,double[],1
+outliers,rm.outlier,-1,0,1,class<`matrix`>,1
+outliers,rm.outlier,0,0,0,double[],1
+outliers,rm.outlier,0,0,1,class<`matrix`>,1
+outliers,rm.outlier,1,0,0,logical,1
+outliers,rm.outlier,2,0,0,any,1
+outliers,rm.outlier,3,0,0,logical,1
+outliers,scores,-1,0,0,double[],1
+outliers,scores,0,0,0,double[],1
+outliers,scores,1,0,0,character[],1
+outliers,scores,2,0,0,double,1
+outliers,scores,2,0,1,null,1
+outliers,scores,3,0,0,null,1
+pROC,are.paired,-1,0,0,logical,1
+pROC,are.paired,0,0,0,...,1
+pROC,are.paired.roc,-1,0,0,logical,1
+pROC,are.paired.roc,0,0,0,class<`smooth.roc`>,1
+pROC,are.paired.roc,0,0,1,class<`roc`>,1
+pROC,are.paired.roc,1,0,0,class<`roc`>,1
+pROC,are.paired.roc,2,0,0,logical,1
+pROC,are.paired.roc,3,0,0,logical,1
+pROC,are.paired.roc,4,0,0,logical,1
+pROC,are.paired.roc,5,0,0,logical,1
+pROC,are.paired.roc,6,0,0,...,1
+pROC,are.paired.smooth.roc,-1,0,0,logical,1
+pROC,are.paired.smooth.roc,0,0,0,class<`smooth.roc`>,1
+pROC,are.paired.smooth.roc,1,0,0,class<`roc`>,1
+pROC,are.paired.smooth.roc,2,0,0,...,1
+pROC,auc,-1,0,0,"class<`auc`, `numeric`>",1
+pROC,auc,0,0,0,...,1
+pROC,auc.default,-1,0,0,"class<`auc`, `numeric`>",1
+pROC,auc.default,0,0,0,class<`factor`>,1
+pROC,auc.default,1,0,0,double[],1
+pROC,auc.default,2,0,0,...,1
+pROC,auc.multiclass.roc,-1,0,0,"class<`multiclass.auc`, `numeric`>",1
+pROC,auc.multiclass.roc,0,0,0,class<`multiclass.roc`>,1
+pROC,auc.multiclass.roc,1,0,0,...,1
+pROC,auc.mv.multiclass.roc,-1,0,0,"class<`mv.multiclass.auc`, `numeric`>",1
+pROC,auc.mv.multiclass.roc,0,0,0,class<`mv.multiclass.roc`>,1
+pROC,auc.mv.multiclass.roc,1,0,0,...,1
+pROC,auc.roc,-1,0,0,"class<`auc`, `numeric`>",1
+pROC,auc.roc,0,0,0,class<`roc`>,1
+pROC,auc.roc,0,0,1,class<`smooth.roc`>,1
+pROC,auc.roc,1,0,0,double[],1
+pROC,auc.roc,2,0,0,any,1
+pROC,auc.roc,3,0,0,logical,1
+pROC,auc.roc,4,0,0,logical,1
+pROC,auc.roc,5,0,0,...,1
+pROC,auc.smooth.roc,-1,0,0,"class<`auc`, `numeric`>",1
+pROC,auc.smooth.roc,0,0,0,class<`smooth.roc`>,1
+pROC,auc.smooth.roc,1,0,0,...,1
+pROC,cdagger,-1,0,0,double,1
+pROC,cdagger,0,0,0,double,1
+pROC,cdagger,1,0,0,double,1
+pROC,cdagger,2,0,0,double,1
+pROC,cddagger,-1,0,0,double,1
+pROC,cddagger,0,0,0,double,1
+pROC,ci,-1,0,0,"class<`ci`, `ci.auc`, `numeric`>",1
+pROC,ci,0,0,0,...,1
+pROC,ci.auc,-1,0,0,"class<`ci`, `ci.auc`, `numeric`>",1
+pROC,ci.auc,0,0,0,...,1
+pROC,ci.auc.auc,-1,0,0,"class<`ci`, `ci.auc`, `numeric`>",1
+pROC,ci.auc.auc,0,0,0,"class<`auc`, `numeric`>",1
+pROC,ci.auc.auc,1,0,0,...,1
+pROC,ci.auc.bootstrap,-1,0,0,double[],1
+pROC,ci.auc.bootstrap,0,0,0,class<`roc`>,1
+pROC,ci.auc.bootstrap,1,0,0,double,1
+pROC,ci.auc.bootstrap,2,0,0,double,1
+pROC,ci.auc.bootstrap,3,0,0,logical,1
+pROC,ci.auc.bootstrap,4,0,0,character,1
+pROC,ci.auc.bootstrap,5,0,0,logical,1
+pROC,ci.auc.bootstrap,6,0,0,...,1
+pROC,ci.auc.delong,-1,0,0,double[],1
+pROC,ci.auc.delong,0,0,0,class<`roc`>,1
+pROC,ci.auc.delong,1,0,0,double,1
+pROC,ci.auc.roc,-1,0,0,"class<`ci`, `ci.auc`, `numeric`>",1
+pROC,ci.auc.roc,0,0,0,class<`roc`>,1
+pROC,ci.auc.roc,1,0,0,double,1
+pROC,ci.auc.roc,2,0,0,character[],1
+pROC,ci.auc.roc,2,0,1,null,1
+pROC,ci.auc.roc,3,0,0,double,1
+pROC,ci.auc.roc,4,0,0,logical,1
+pROC,ci.auc.roc,5,0,0,logical,1
+pROC,ci.auc.roc,6,0,0,any,1
+pROC,ci.auc.roc,7,0,0,logical,1
+pROC,ci.auc.smooth.roc,-1,0,0,"class<`ci`, `ci.auc`, `numeric`>",1
+pROC,ci.auc.smooth.roc,0,0,0,class<`smooth.roc`>,1
+pROC,ci.auc.smooth.roc,1,0,0,double,1
+pROC,ci.auc.smooth.roc,2,0,0,double,1
+pROC,ci.auc.smooth.roc,3,0,0,logical,1
+pROC,ci.auc.smooth.roc,4,0,0,logical,1
+pROC,ci.auc.smooth.roc,5,0,0,character,1
+pROC,ci.auc.smooth.roc,6,0,0,logical,1
+pROC,ci.auc.smooth.roc,7,0,0,...,1
+pROC,ci.coords,-1,0,0,"class<`ci`, `ci.coords`, `list`>",1
+pROC,ci.coords,0,0,0,...,1
+pROC,ci.coords.roc,-1,0,0,"class<`ci`, `ci.coords`, `list`>",1
+pROC,ci.coords.roc,0,0,0,class<`roc`>,1
+pROC,ci.coords.roc,1,0,0,character,1
+pROC,ci.coords.roc,1,0,1,double[],1
+pROC,ci.coords.roc,2,0,0,character,1
+pROC,ci.coords.roc,3,0,0,character[],1
+pROC,ci.coords.roc,4,0,0,any,1
+pROC,ci.coords.roc,5,0,0,any,1
+pROC,ci.coords.roc,6,0,0,character[],1
+pROC,ci.coords.roc,7,0,0,double,1
+pROC,ci.coords.smooth.roc,-1,0,0,"class<`ci`, `ci.coords`, `list`>",1
+pROC,ci.coords.smooth.roc,0,0,0,class<`smooth.roc`>,1
+pROC,ci.coords.smooth.roc,1,0,0,double,1
+pROC,ci.coords.smooth.roc,2,0,0,character,1
+pROC,ci.coords.smooth.roc,3,0,0,character[],1
+pROC,ci.coords.smooth.roc,4,0,0,any,1
+pROC,ci.coords.smooth.roc,5,0,0,double[],1
+pROC,ci.coords.smooth.roc,6,0,0,character[],1
+pROC,ci.coords.smooth.roc,7,0,0,double,1
+pROC,ci.roc,-1,0,0,"class<`ci`, `ci.auc`, `numeric`>",1
+pROC,ci.roc,0,0,0,class<`roc`>,1
+pROC,ci.roc,1,0,0,character[],1
+pROC,ci.roc,2,0,0,...,1
+pROC,ci.se,-1,0,0,"class<`ci`, `ci.se`, `matrix`>",1
+pROC,ci.se,0,0,0,...,1
+pROC,ci.se.roc,-1,0,0,"class<`ci`, `ci.se`, `matrix`>",1
+pROC,ci.se.roc,0,0,0,class<`roc`>,1
+pROC,ci.se.roc,1,0,0,double[],1
+pROC,ci.se.roc,2,0,0,double,1
+pROC,ci.se.roc,3,0,0,double,1
+pROC,ci.se.roc,4,0,0,logical,1
+pROC,ci.se.roc,5,0,0,character,1
+pROC,ci.se.roc,6,0,0,logical,1
+pROC,ci.se.roc,7,0,0,...,1
+pROC,ci.se.smooth.roc,-1,0,0,"class<`ci`, `ci.se`, `matrix`>",1
+pROC,ci.se.smooth.roc,0,0,0,class<`smooth.roc`>,1
+pROC,ci.se.smooth.roc,1,0,0,double[],1
+pROC,ci.se.smooth.roc,2,0,0,double,1
+pROC,ci.se.smooth.roc,3,0,0,double,1
+pROC,ci.se.smooth.roc,4,0,0,logical,1
+pROC,ci.se.smooth.roc,5,0,0,character,1
+pROC,ci.se.smooth.roc,6,0,0,logical,1
+pROC,ci.se.smooth.roc,7,0,0,...,1
+pROC,ci.sp,-1,0,0,"class<`ci`, `ci.sp`, `matrix`>",1
+pROC,ci.sp,0,0,0,...,1
+pROC,ci.sp.roc,-1,0,0,"class<`ci`, `ci.sp`, `matrix`>",1
+pROC,ci.sp.roc,0,0,0,class<`roc`>,1
+pROC,ci.sp.roc,1,0,0,double[],1
+pROC,ci.sp.roc,2,0,0,double,1
+pROC,ci.sp.roc,3,0,0,double,1
+pROC,ci.sp.roc,4,0,0,logical,1
+pROC,ci.sp.roc,5,0,0,character,1
+pROC,ci.sp.roc,6,0,0,logical,1
+pROC,ci.sp.roc,7,0,0,...,1
+pROC,ci.sp.smooth.roc,-1,0,0,"class<`ci`, `ci.sp`, `matrix`>",1
+pROC,ci.sp.smooth.roc,0,0,0,class<`smooth.roc`>,1
+pROC,ci.sp.smooth.roc,1,0,0,double[],1
+pROC,ci.sp.smooth.roc,2,0,0,double,1
+pROC,ci.sp.smooth.roc,3,0,0,double,1
+pROC,ci.sp.smooth.roc,4,0,0,logical,1
+pROC,ci.sp.smooth.roc,5,0,0,character,1
+pROC,ci.sp.smooth.roc,6,0,0,logical,1
+pROC,ci.sp.smooth.roc,7,0,0,...,1
+pROC,ci.thresholds,-1,0,0,"class<`ci`, `ci.thresholds`, `list`>",1
+pROC,ci.thresholds,0,0,0,...,1
+pROC,ci.thresholds.roc,-1,0,0,"class<`ci`, `ci.thresholds`, `list`>",1
+pROC,ci.thresholds.roc,0,0,0,class<`roc`>,1
+pROC,ci.thresholds.roc,1,0,0,double,1
+pROC,ci.thresholds.roc,2,0,0,double,1
+pROC,ci.thresholds.roc,3,0,0,logical,1
+pROC,ci.thresholds.roc,4,0,0,character,1
+pROC,ci.thresholds.roc,4,0,1,double[],1
+pROC,ci.thresholds.roc,5,0,0,character,1
+pROC,ci.thresholds.roc,6,0,0,logical,1
+pROC,ci.thresholds.roc,7,0,0,...,1
+pROC,compute.pair.AUC,-1,0,0,class<`roc`>,1
+pROC,compute.pair.AUC,0,0,0,class<`data.frame`>,1
+pROC,compute.pair.AUC,0,0,1,class<`matrix`>,1
+pROC,compute.pair.AUC,1,0,0,character,1
+pROC,compute.pair.AUC,2,0,0,character,1
+pROC,compute.pair.AUC,3,0,0,class<`factor`>,1
+pROC,compute.pair.AUC,4,0,0,any,1
+pROC,compute.pair.AUC,5,0,0,logical,1
+pROC,compute.pair.AUC,6,0,0,character,1
+pROC,compute.pair.AUC,7,0,0,...,1
+pROC,coords,-1,0,0,class<`data.frame`>,1
+pROC,coords,-1,0,1,class<`matrix`>,1
+pROC,coords,0,0,0,...,1
+pROC,coords.roc,-1,0,0,class<`data.frame`>,1
+pROC,coords.roc,-1,0,1,class<`matrix`>,1
+pROC,coords.roc,-1,0,2,double,1
+pROC,coords.roc,0,0,0,class<`smooth.roc`>,1
+pROC,coords.roc,0,0,1,class<`roc`>,1
+pROC,coords.roc,1,0,0,character,1
+pROC,coords.roc,1,0,1,double[],1
+pROC,coords.roc,2,0,0,character[],1
+pROC,coords.roc,3,0,0,character[],1
+pROC,coords.roc,4,0,0,logical,1
+pROC,coords.roc,5,0,0,logical,1
+pROC,coords.roc,6,0,0,any,1
+pROC,coords.roc,7,0,0,any,1
+pROC,coords.smooth.roc,-1,0,0,double,1
+pROC,coords.smooth.roc,-1,0,1,class<`data.frame`>,1
+pROC,coords.smooth.roc,0,0,0,class<`smooth.roc`>,1
+pROC,coords.smooth.roc,1,0,0,double,1
+pROC,coords.smooth.roc,2,0,0,character,1
+pROC,coords.smooth.roc,3,0,0,character[],1
+pROC,coords.smooth.roc,4,0,0,logical,1
+pROC,coords.smooth.roc,5,0,0,logical,1
+pROC,coords.smooth.roc,6,0,0,any,1
+pROC,coords.smooth.roc,7,0,0,any,1
+pROC,cov,-1,0,0,double,1
+pROC,cov,0,0,0,...,1
+pROC,cov.auc,-1,0,0,double,1
+pROC,cov.auc,0,0,0,"class<`auc`, `numeric`>",1
+pROC,cov.auc,1,0,0,class<`roc`>,1
+pROC,cov.auc,2,0,0,...,1
+pROC,cov.default,-1,0,0,double,1
+pROC,cov.default,0,0,0,...,1
+pROC,cov.params.obuchowski,-1,0,0,double,1
+pROC,cov.params.obuchowski,0,0,0,double,1
+pROC,cov.params.obuchowski,1,0,0,double,1
+pROC,cov.params.obuchowski,2,0,0,double,1
+pROC,cov.params.obuchowski,3,0,0,double,1
+pROC,cov.params.obuchowski,4,0,0,double,1
+pROC,cov.params.obuchowski,5,0,0,double,1
+pROC,cov.params.obuchowski,6,0,0,double,1
+pROC,cov.params.obuchowski,7,0,0,any,1
+pROC,cov.roc,-1,0,0,double,1
+pROC,cov.roc,0,0,0,class<`roc`>,1
+pROC,cov.roc,1,0,0,class<`roc`>,1
+pROC,cov.roc,2,0,0,character[],1
+pROC,cov.roc,3,0,0,logical,1
+pROC,cov.roc,4,0,0,double,1
+pROC,cov.roc,5,0,0,logical,1
+pROC,cov.roc,6,0,0,logical,1
+pROC,cov.roc,7,0,0,any,1
+pROC,cov.roc.obuchowski,-1,0,0,double,1
+pROC,cov.roc.obuchowski,0,0,0,class<`roc`>,1
+pROC,cov.roc.obuchowski,1,0,0,class<`roc`>,1
+pROC,covvar,-1,0,0,list<double>,1
+pROC,covvar,0,0,0,class<`roc`>,1
+pROC,covvar,1,0,0,class<`roc`>,1
+pROC,covvar,2,0,0,character[],1
+pROC,covvar,3,0,0,...,1
+pROC,delong.paired.test,-1,0,0,double,1
+pROC,delong.paired.test,0,0,0,class<`roc`>,1
+pROC,delong.paired.test,1,0,0,class<`roc`>,1
+pROC,delongPlacements,-1,0,0,list<double[]>,1
+pROC,delongPlacements,0,0,0,class<`roc`>,1
+pROC,delongPlacementsCpp,-1,0,0,list<double[]>,1
+pROC,delongPlacementsCpp,0,0,0,class<`roc`>,1
+pROC,expr1,-1,0,0,double,1
+pROC,expr1,0,0,0,double,1
+pROC,expr1,1,0,0,double,1
+pROC,expr2,-1,0,0,double,1
+pROC,expr2,0,0,0,double,1
+pROC,expr3,-1,0,0,double,1
+pROC,expr3,0,0,0,double,1
+pROC,expr3,1,0,0,double,1
+pROC,expr4,-1,0,0,double,1
+pROC,expr4,0,0,0,double,1
+pROC,expr4,1,0,0,double,1
+pROC,f.full,-1,0,0,double,1
+pROC,f.full,0,0,0,double,1
+pROC,f.full,1,0,0,double,1
+pROC,f.partial,-1,0,0,double,1
+pROC,f.partial,0,0,0,double,1
+pROC,f.partial,1,0,0,double,1
+pROC,f.partial,2,0,0,double,1
+pROC,f.partial,3,0,0,double,1
+pROC,get.aes.for.ggplot,-1,0,0,"list<class<`uneval`> | class<`Scale`, `ScaleContinuous`, `ScaleContinuousPosition`, `gg`, `ggproto`>>",1
+pROC,get.aes.for.ggplot,0,0,0,class<`roc`>,1
+pROC,get.aes.for.ggplot,1,0,0,logical,1
+pROC,get.aes.for.ggplot,2,0,0,character[],1
+pROC,get.aes.for.ggplot,2,0,1,null,1
+pROC,get.coords.for.ggplot,-1,0,0,class<`data.frame`>,1
+pROC,get.coords.for.ggplot,0,0,0,class<`roc`>,1
+pROC,g.full,-1,0,0,double,1
+pROC,g.full,0,0,0,double,1
+pROC,g.full,1,0,0,double,1
+pROC,ggroc,-1,0,0,"class<`gg`, `ggplot`>",1
+pROC,ggroc,0,0,0,class<`roc`>,1
+pROC,ggroc,0,0,1,list<class<`roc`>>,1
+pROC,ggroc,1,0,0,...,1
+pROC,ggroc.list,-1,0,0,"class<`gg`, `ggplot`>",1
+pROC,ggroc.list,0,0,0,list<class<`roc`>>,1
+pROC,ggroc.list,1,0,0,any,1
+pROC,ggroc.list,2,0,0,logical,1
+pROC,ggroc.list,3,0,0,...,1
+pROC,ggroc.roc,-1,0,0,"class<`gg`, `ggplot`>",1
+pROC,ggroc.roc,0,0,0,class<`roc`>,1
+pROC,ggroc.roc,1,0,0,logical,1
+pROC,ggroc.roc,2,0,0,...,1
+pROC,g.partial,-1,0,0,double,1
+pROC,g.partial,0,0,0,double,1
+pROC,g.partial,1,0,0,double,1
+pROC,g.partial,2,0,0,double,1
+pROC,g.partial,3,0,0,double,1
+pROC,has.partial.auc,-1,0,0,logical,1
+pROC,has.partial.auc,-1,0,1,null,1
+pROC,has.partial.auc,0,0,0,"class<`auc`, `numeric`>",1
+pROC,has.partial.auc,0,0,1,class<`roc`>,1
+pROC,has.partial.auc,0,0,2,class<`smooth.roc`>,1
+pROC,has.partial.auc.auc,-1,0,0,logical,1
+pROC,has.partial.auc.auc,-1,0,1,null,1
+pROC,has.partial.auc.auc,0,0,0,"class<`auc`, `numeric`>",1
+pROC,has.partial.auc.auc,0,0,1,null,1
+pROC,has.partial.auc.roc,-1,0,0,logical,1
+pROC,has.partial.auc.roc,-1,0,1,null,1
+pROC,has.partial.auc.roc,0,0,0,class<`smooth.roc`>,1
+pROC,has.partial.auc.roc,0,0,1,class<`roc`>,1
+pROC,has.partial.auc.smooth.roc,-1,0,0,logical,1
+pROC,has.partial.auc.smooth.roc,0,0,0,class<`smooth.roc`>,1
+pROC,lines.roc,-1,0,0,class<`roc`>,1
+pROC,lines.roc,0,0,0,class<`roc`>,1
+pROC,lines.roc,1,0,0,...,1
+pROC,lines.roc.roc,-1,0,0,class<`roc`>,1
+pROC,lines.roc.roc,0,0,0,class<`roc`>,1
+pROC,lines.roc.roc,1,0,0,double,1
+pROC,lines.roc.roc,2,0,0,...,1
+pROC,load.ggplot2,-1,0,0,logical,1
+pROC,load.suggested.package,-1,0,0,logical,1
+pROC,load.suggested.package,0,0,0,character,1
+pROC,Math.auc,-1,0,0,double,1
+pROC,Math.auc,0,0,0,"class<`auc`, `numeric`>",1
+pROC,Math.auc,1,0,0,...,1
+pROC,Math.ci.auc,-1,0,0,double[],1
+pROC,Math.ci.auc,0,0,0,"class<`ci`, `ci.auc`, `numeric`>",1
+pROC,Math.ci.auc,1,0,0,...,1
+pROC,multiclass.roc,-1,0,0,class<`multiclass.roc`>,1
+pROC,multiclass.roc,-1,0,1,class<`mv.multiclass.roc`>,1
+pROC,multiclass.roc,0,0,0,...,1
+pROC,multiclass.roc.default,-1,0,0,class<`mv.multiclass.roc`>,1
+pROC,multiclass.roc.default,-1,0,1,class<`multiclass.roc`>,1
+pROC,multiclass.roc.default,0,0,0,class<`factor`>,1
+pROC,multiclass.roc.default,0,0,1,"class<`factor`, `ordered`>",1
+pROC,multiclass.roc.default,1,0,0,class<`data.frame`>,1
+pROC,multiclass.roc.default,1,0,1,double[],1
+pROC,multiclass.roc.default,1,0,2,class<`matrix`>,1
+pROC,multiclass.roc.default,2,0,0,character[],1
+pROC,multiclass.roc.default,2,0,1,double[],1
+pROC,multiclass.roc.default,3,0,0,logical,1
+pROC,multiclass.roc.default,4,0,0,any,1
+pROC,multiclass.roc.default,5,0,0,...,1
+pROC,multiclass.roc.formula,-1,0,0,class<`mv.multiclass.roc`>,1
+pROC,multiclass.roc.formula,0,0,0,class<`formula`>,1
+pROC,multiclass.roc.formula,1,0,0,class<`data.frame`>,1
+pROC,multiclass.roc.formula,2,0,0,...,1
+pROC,multiclass.roc.multivariate,-1,0,0,class<`mv.multiclass.roc`>,1
+pROC,multiclass.roc.multivariate,0,0,0,class<`factor`>,1
+pROC,multiclass.roc.multivariate,1,0,0,class<`matrix`>,1
+pROC,multiclass.roc.multivariate,1,0,1,class<`data.frame`>,1
+pROC,multiclass.roc.multivariate,2,0,0,character[],1
+pROC,multiclass.roc.multivariate,3,0,0,logical,1
+pROC,multiclass.roc.multivariate,4,0,0,character,1
+pROC,multiclass.roc.multivariate,5,0,0,...,1
+pROC,multiclass.roc.univariate,-1,0,0,class<`multiclass.roc`>,1
+pROC,multiclass.roc.univariate,0,0,0,"class<`factor`, `ordered`>",1
+pROC,multiclass.roc.univariate,1,0,0,double[],1
+pROC,multiclass.roc.univariate,2,0,0,character[],1
+pROC,multiclass.roc.univariate,2,0,1,double[],1
+pROC,multiclass.roc.univariate,3,0,0,logical,1
+pROC,multiclass.roc.univariate,4,0,0,character,1
+pROC,multiclass.roc.univariate,5,0,0,...,1
+pROC,ncases.obuchowski,-1,0,0,double,1
+pROC,ncases.obuchowski,0,0,0,class<`roc`>,1
+pROC,ncases.obuchowski,1,0,0,class<`roc`>,1
+pROC,ncases.obuchowski,2,0,0,double,1
+pROC,ncases.obuchowski,3,0,0,double,1
+pROC,ncases.obuchowski,4,0,0,character[],1
+pROC,ncases.obuchowski,5,0,0,...,1
+pROC,ncases.obuchowski.params,-1,0,0,double,1
+pROC,ncases.obuchowski.params,0,0,0,list<double>,1
+pROC,ncases.obuchowski.params,1,0,0,double,1
+pROC,ncases.obuchowski.params,2,0,0,double,1
+pROC,ncases.obuchowski.params,3,0,0,double,1
+pROC,Ops.auc,-1,0,0,double,1
+pROC,Ops.auc,0,0,0,"class<`auc`, `numeric`>",1
+pROC,Ops.auc,0,0,1,double,1
+pROC,Ops.auc,1,0,0,double,1
+pROC,Ops.auc,1,0,1,"class<`auc`, `numeric`>",1
+pROC,Ops.ci.auc,-1,0,0,double[],1
+pROC,Ops.ci.auc,0,0,0,"class<`ci`, `ci.auc`, `numeric`>",1
+pROC,Ops.ci.auc,1,0,0,double,1
+pROC,plot.ci.se,-1,0,0,"class<`ci`, `ci.se`, `matrix`>",1
+pROC,plot.ci.se,0,0,0,"class<`ci`, `ci.se`, `matrix`>",1
+pROC,plot.ci.se,1,0,0,character[],1
+pROC,plot.ci.se,2,0,0,double,1
+pROC,plot.ci.se,3,0,0,character,1
+pROC,plot.ci.se,4,0,0,logical,1
+pROC,plot.ci.se,5,0,0,...,1
+pROC,plot.ci.sp,-1,0,0,"class<`ci`, `ci.sp`, `matrix`>",1
+pROC,plot.ci.sp,0,0,0,"class<`ci`, `ci.sp`, `matrix`>",1
+pROC,plot.ci.sp,1,0,0,character[],1
+pROC,plot.ci.sp,2,0,0,double,1
+pROC,plot.ci.sp,3,0,0,character,1
+pROC,plot.ci.sp,4,0,0,logical,1
+pROC,plot.ci.sp,5,0,0,...,1
+pROC,plot.ci.thresholds,-1,0,0,"class<`ci`, `ci.thresholds`, `list`>",1
+pROC,plot.ci.thresholds,0,0,0,"class<`ci`, `ci.thresholds`, `list`>",1
+pROC,plot.ci.thresholds,1,0,0,double,1
+pROC,plot.ci.thresholds,2,0,0,character,1
+pROC,plot.ci.thresholds,3,0,0,...,1
+pROC,plot.roc,-1,0,0,class<`roc`>,1
+pROC,plot.roc,0,0,0,class<`factor`>,1
+pROC,plot.roc,0,0,1,class<`roc`>,1
+pROC,plot.roc,1,0,0,...,1
+pROC,plot.roc.default,-1,0,0,class<`roc`>,1
+pROC,plot.roc.default,0,0,0,class<`factor`>,1
+pROC,plot.roc.default,1,0,0,double[],1
+pROC,plot.roc.default,2,0,0,...,1
+pROC,plot.roc.roc,-1,0,0,class<`roc`>,1
+pROC,plot.roc.roc,0,0,0,class<`roc`>,1
+pROC,plot.roc.roc,1,0,0,logical,1
+pROC,plot.roc.roc,2,0,0,logical,1
+pROC,plot.roc.roc,3,0,0,logical,1
+pROC,plot.roc.roc,4,0,0,logical,1
+pROC,plot.roc.roc,5,0,0,any,1
+pROC,plot.roc.roc,6,0,0,any,1
+pROC,plot.roc.roc,7,0,0,any,1
+pROC,plot.smooth.roc,-1,0,0,class<`smooth.roc`>,1
+pROC,plot.smooth.roc,0,0,0,class<`smooth.roc`>,1
+pROC,plot.smooth.roc,1,0,0,...,1
+pROC,power.roc.test,-1,0,0,class<`power.htest`>,1
+pROC,power.roc.test,0,0,0,...,1
+pROC,power.roc.test.list,-1,0,0,class<`power.htest`>,1
+pROC,power.roc.test.list,0,0,0,list<double>,1
+pROC,power.roc.test.list,1,0,0,null,1
+pROC,power.roc.test.list,2,0,0,double,1
+pROC,power.roc.test.list,2,0,1,null,1
+pROC,power.roc.test.list,3,0,0,double,1
+pROC,power.roc.test.list,3,0,1,null,1
+pROC,power.roc.test.list,4,0,0,null,1
+pROC,power.roc.test.list,4,0,1,double,1
+pROC,power.roc.test.list,5,0,0,double,1
+pROC,power.roc.test.list,6,0,0,character[],1
+pROC,power.roc.test.list,7,0,0,...,1
+pROC,power.roc.test.numeric,-1,0,0,class<`power.htest`>,1
+pROC,power.roc.test.numeric,0,0,0,"class<`auc`, `numeric`>",1
+pROC,power.roc.test.numeric,0,0,1,double,1
+pROC,power.roc.test.numeric,0,0,2,null,1
+pROC,power.roc.test.numeric,1,0,0,null,1
+pROC,power.roc.test.numeric,1,0,1,double,1
+pROC,power.roc.test.numeric,2,0,0,null,1
+pROC,power.roc.test.numeric,2,0,1,double,1
+pROC,power.roc.test.numeric,3,0,0,double,1
+pROC,power.roc.test.numeric,3,0,1,null,1
+pROC,power.roc.test.numeric,4,0,0,null,1
+pROC,power.roc.test.numeric,4,0,1,double,1
+pROC,power.roc.test.numeric,5,0,0,double,1
+pROC,power.roc.test.numeric,6,0,0,character[],1
+pROC,power.roc.test.numeric,7,0,0,...,1
+pROC,power.roc.test.roc,-1,0,0,class<`power.htest`>,1
+pROC,power.roc.test.roc,0,0,0,class<`roc`>,1
+pROC,power.roc.test.roc,1,0,0,any,1
+pROC,power.roc.test.roc,2,0,0,double,1
+pROC,power.roc.test.roc,2,0,1,null,1
+pROC,power.roc.test.roc,3,0,0,double,1
+pROC,power.roc.test.roc,3,0,1,null,1
+pROC,power.roc.test.roc,4,0,0,character[],1
+pROC,power.roc.test.roc,5,0,0,logical,1
+pROC,power.roc.test.roc,6,0,0,any,1
+pROC,power.roc.test.roc,7,0,0,...,1
+pROC,print.auc,-1,0,0,"class<`auc`, `numeric`>",1
+pROC,print.auc,0,0,0,"class<`auc`, `numeric`>",1
+pROC,print.auc,1,0,0,double,1
+pROC,print.auc,2,0,0,...,1
+pROC,print.ci.auc,-1,0,0,"class<`ci`, `ci.auc`, `numeric`>",1
+pROC,print.ci.auc,0,0,0,"class<`ci`, `ci.auc`, `numeric`>",1
+pROC,print.ci.auc,1,0,0,double,1
+pROC,print.ci.auc,2,0,0,...,1
+pROC,print.dataline,-1,0,0,null,1
+pROC,print.dataline,0,0,0,class<`roc`>,1
+pROC,print.roc,-1,0,0,class<`roc`>,1
+pROC,print.roc,0,0,0,class<`roc`>,1
+pROC,print.roc,1,0,0,double,1
+pROC,print.roc,2,0,0,logical,1
+pROC,print.roc,3,0,0,...,1
+pROC,print.smooth.roc,-1,0,0,class<`smooth.roc`>,1
+pROC,print.smooth.roc,0,0,0,class<`smooth.roc`>,1
+pROC,print.smooth.roc,1,0,0,double,1
+pROC,print.smooth.roc,2,0,0,logical,1
+pROC,print.smooth.roc,3,0,0,...,1
+pROC,remove.ci.attributes,-1,0,0,double[],1
+pROC,remove.ci.attributes,0,0,0,"class<`ci`, `ci.auc`, `numeric`>",1
+pROC,remove.ci.attributes,0,0,1,double,1
+pROC,roc,-1,0,0,class<`roc`>,1
+pROC,roc,-1,0,1,class<`smooth.roc`>,1
+pROC,roc,-1,0,2,list<class<`roc`>>,1
+pROC,roc,0,0,0,...,1
+pROC,roc.cc.nochecks,-1,0,0,class<`roc`>,1
+pROC,roc.cc.nochecks,-1,0,1,class<`smooth.roc`>,1
+pROC,roc.cc.nochecks,0,0,0,double[],1
+pROC,roc.cc.nochecks,1,0,0,double[],1
+pROC,roc.cc.nochecks,2,0,0,logical,1
+pROC,roc.cc.nochecks,3,0,0,character,1
+pROC,roc.cc.nochecks,4,0,0,class<`function`>,1
+pROC,roc.cc.nochecks,5,0,0,logical,1
+pROC,roc.cc.nochecks,6,0,0,any,1
+pROC,roc.cc.nochecks,7,0,0,any,1
+pROC,roc.default,-1,0,0,class<`roc`>,1
+pROC,roc.default,-1,0,1,class<`smooth.roc`>,1
+pROC,roc.default,0,0,0,any,1
+pROC,roc.default,1,0,0,any,1
+pROC,roc.default,2,0,0,any,1
+pROC,roc.default,3,0,0,any,1
+pROC,roc.default,4,0,0,any,1
+pROC,roc.default,5,0,0,any,1
+pROC,roc.default,6,0,0,any,1
+pROC,roc.default,7,0,0,logical,1
+pROC,roc.formula,-1,0,0,class<`roc`>,1
+pROC,roc.formula,-1,0,1,list<class<`roc`>>,1
+pROC,roc.formula,0,0,0,class<`formula`>,1
+pROC,roc.formula,1,0,0,any,1
+pROC,roc.formula,2,0,0,...,1
+pROC,roc.test,-1,0,0,class<`htest`>,1
+pROC,roc.test,0,0,0,...,1
+pROC,roc.test.auc,-1,0,0,class<`htest`>,1
+pROC,roc.test.auc,0,0,0,"class<`auc`, `numeric`>",1
+pROC,roc.test.auc,1,0,0,class<`roc`>,1
+pROC,roc.test.auc,2,0,0,...,1
+pROC,roc.test.default,-1,0,0,class<`htest`>,1
+pROC,roc.test.default,0,0,0,class<`factor`>,1
+pROC,roc.test.default,1,0,0,class<`data.frame`>,1
+pROC,roc.test.default,1,0,1,double[],1
+pROC,roc.test.default,2,0,0,null,1
+pROC,roc.test.default,2,0,1,"class<`factor`, `ordered`>",1
+pROC,roc.test.default,3,0,0,logical,1
+pROC,roc.test.default,4,0,0,null,1
+pROC,roc.test.default,5,0,0,...,1
+pROC,roc.test.roc,-1,0,0,class<`htest`>,1
+pROC,roc.test.roc,0,0,0,class<`roc`>,1
+pROC,roc.test.roc,1,0,0,class<`roc`>,1
+pROC,roc.test.roc,2,0,0,character[],1
+pROC,roc.test.roc,2,0,1,null,1
+pROC,roc.test.roc,3,0,0,null,1
+pROC,roc.test.roc,4,0,0,null,1
+pROC,roc.test.roc,5,0,0,character[],1
+pROC,roc.test.roc,6,0,0,null,1
+pROC,roc.test.roc,7,0,0,logical,1
+pROC,roc.utils.calc.coords,-1,0,0,class<`matrix`>,1
+pROC,roc.utils.calc.coords,0,0,0,double,1
+pROC,roc.utils.calc.coords,1,0,0,^double[],1
+pROC,roc.utils.calc.coords,1,0,1,null,1
+pROC,roc.utils.calc.coords,2,0,0,double[],1
+pROC,roc.utils.calc.coords,3,0,0,double[],1
+pROC,roc.utils.calc.coords,4,0,0,integer,1
+pROC,roc.utils.calc.coords,5,0,0,integer,1
+pROC,roc.utils.calc.coords,6,0,0,double[],1
+pROC,roc.utils.extract.formula,-1,0,0,list<class<`factor`> | character[] | class<`data.frame`>>,1
+pROC,roc.utils.extract.formula,-1,0,1,list<character | class<`factor`> | class<`data.frame`>>,1
+pROC,roc.utils.extract.formula,0,0,0,class<`formula`>,1
+pROC,roc.utils.extract.formula,1,0,0,any,1
+pROC,roc.utils.extract.formula,2,0,0,logical,1
+pROC,roc.utils.extract.formula,3,0,0,class<`call`>,1
+pROC,roc.utils.extract.formula,4,0,0,...,1
+pROC,roc.utils.get.progress.bar,-1,0,0,list<class<`function`>>,1
+pROC,roc.utils.get.progress.bar,0,0,0,character,1
+pROC,roc.utils.get.progress.bar,1,0,0,character,1
+pROC,roc.utils.get.progress.bar,2,0,0,character,1
+pROC,roc.utils.get.progress.bar,3,0,0,any,1
+pROC,roc.utils.get.progress.bar,4,0,0,any,1
+pROC,roc.utils.get.progress.bar,5,0,0,any,1
+pROC,roc.utils.get.progress.bar,6,0,0,...,1
+pROC,roc.utils.is.perfect.curve,-1,0,0,logical,1
+pROC,roc.utils.is.perfect.curve,0,0,0,class<`roc`>,1
+pROC,roc.utils.is.perfect.curve,0,0,1,class<`smooth.roc`>,1
+pROC,roc.utils.match.coords.ret.args,-1,0,0,character[],1
+pROC,roc.utils.match.coords.ret.args,0,0,0,character[],1
+pROC,roc.utils.match.coords.ret.args,1,0,0,logical,1
+pROC,roc.utils.max.partial.auc,-1,0,0,double,1
+pROC,roc.utils.max.partial.auc,0,0,0,double[],1
+pROC,roc.utils.max.partial.auc,1,0,0,any,1
+pROC,roc.utils.max.thresholds.idx,-1,0,0,logical[],1
+pROC,roc.utils.max.thresholds.idx,0,0,0,double[],1
+pROC,roc.utils.max.thresholds.idx,1,0,0,double[],1
+pROC,roc.utils.max.thresholds.idx,2,0,0,double[],1
+pROC,roc.utils.min.partial.auc,-1,0,0,double,1
+pROC,roc.utils.min.partial.auc,0,0,0,double[],1
+pROC,roc.utils.min.partial.auc,1,0,0,logical,1
+pROC,roc.utils.optim.crit,-1,0,0,double[],1
+pROC,roc.utils.optim.crit,0,0,0,double[],1
+pROC,roc.utils.optim.crit,1,0,0,double[],1
+pROC,roc.utils.optim.crit,2,0,0,any,1
+pROC,roc.utils.optim.crit,3,0,0,double[],1
+pROC,roc.utils.optim.crit,4,0,0,character,1
+pROC,roc.utils.thresholds,-1,0,0,double[],1
+pROC,roc.utils.thresholds,0,0,0,double[],1
+pROC,roc.utils.thresholds,1,0,0,any,1
+pROC,roc.utils.thr.idx,-1,0,0,double,1
+pROC,roc.utils.thr.idx,0,0,0,class<`roc`>,1
+pROC,roc.utils.thr.idx,1,0,0,double,1
+pROC,roc.utils.unpercent,-1,0,0,"class<`auc`, `numeric`>",1
+pROC,roc.utils.unpercent,-1,0,1,class<`roc`>,1
+pROC,roc.utils.unpercent,0,0,0,"class<`auc`, `numeric`>",1
+pROC,roc.utils.unpercent,0,0,1,class<`roc`>,1
+pROC,roc.utils.unpercent.auc,-1,0,0,"class<`auc`, `numeric`>",1
+pROC,roc.utils.unpercent.auc,0,0,0,"class<`auc`, `numeric`>",1
+pROC,roc.utils.unpercent.roc,-1,0,0,class<`roc`>,1
+pROC,roc.utils.unpercent.roc,0,0,0,class<`roc`>,1
+pROC,smooth,-1,0,0,class<`smooth.roc`>,1
+pROC,smooth,0,0,0,...,1
+pROC,smooth.roc,-1,0,0,class<`smooth.roc`>,1
+pROC,smooth.roc,0,0,0,class<`roc`>,1
+pROC,smooth.roc,1,0,0,character[],1
+pROC,smooth.roc,2,0,0,double,1
+pROC,smooth.roc,3,0,0,character,1
+pROC,smooth.roc,4,0,0,null,1
+pROC,smooth.roc,4,0,1,character,1
+pROC,smooth.roc,4,0,2,class<`function`>,1
+pROC,smooth.roc,5,0,0,null,1
+pROC,smooth.roc,5,0,1,character,1
+pROC,smooth.roc,5,0,2,class<`function`>,1
+pROC,smooth.roc,5,0,3,double[],1
+pROC,smooth.roc,6,0,0,null,1
+pROC,smooth.roc,6,0,1,character,1
+pROC,smooth.roc,6,0,2,class<`function`>,1
+pROC,smooth.roc,6,0,3,double[],1
+pROC,smooth.roc,7,0,0,null,1
+pROC,smooth.roc,7,0,1,list<double>,1
+pROC,smooth.roc.binormal,-1,0,0,list<double[] | class<`lm`>>,1
+pROC,smooth.roc.binormal,0,0,0,class<`roc`>,1
+pROC,smooth.roc.binormal,1,0,0,double,1
+pROC,smooth.roc.density,-1,0,0,list<double[]>,1
+pROC,smooth.roc.density,0,0,0,class<`roc`>,1
+pROC,smooth.roc.density,1,0,0,any,1
+pROC,smooth.roc.density,2,0,0,double[],1
+pROC,smooth.roc.density,2,0,1,class<`function`>,1
+pROC,smooth.roc.density,2,0,2,null,1
+pROC,smooth.roc.density,3,0,0,double[],1
+pROC,smooth.roc.density,3,0,1,class<`function`>,1
+pROC,smooth.roc.density,3,0,2,null,1
+pROC,smooth.roc.density,4,0,0,any,1
+pROC,smooth.roc.density,5,0,0,double,1
+pROC,smooth.roc.density,6,0,0,double,1
+pROC,smooth.roc.density,7,0,0,any,1
+pROC,smooth.roc.fitdistr,-1,0,0,list<double[] | class<`fitdistr`>>,1
+pROC,smooth.roc.fitdistr,0,0,0,class<`roc`>,1
+pROC,smooth.roc.fitdistr,1,0,0,any,1
+pROC,smooth.roc.fitdistr,2,0,0,character,1
+pROC,smooth.roc.fitdistr,2,0,1,class<`function`>,1
+pROC,smooth.roc.fitdistr,3,0,0,character,1
+pROC,smooth.roc.fitdistr,3,0,1,class<`function`>,1
+pROC,smooth.roc.fitdistr,4,0,0,null,1
+pROC,smooth.roc.fitdistr,4,0,1,list<double>,1
+pROC,smooth.roc.fitdistr,5,0,0,null,1
+pROC,smooth.roc.fitdistr,5,0,1,list<double>,1
+pROC,smooth.roc.fitdistr,6,0,0,...,1
+pROC,smooth.roc.logcondens,-1,0,0,list<double[] | list<double[] | class<`dlc`>>>,1
+pROC,smooth.roc.logcondens,0,0,0,class<`roc`>,1
+pROC,smooth.roc.logcondens,1,0,0,double,1
+pROC,smooth.roc.logcondens.smooth,-1,0,0,list<double[] | list<double[] | class<`dlc`>>>,1
+pROC,smooth.roc.logcondens.smooth,0,0,0,class<`roc`>,1
+pROC,smooth.roc.logcondens.smooth,1,0,0,double,1
+pROC,solve.nd,-1,0,0,double,1
+pROC,solve.nd,0,0,0,double,1
+pROC,solve.nd,1,0,0,double,1
+pROC,solve.nd,2,0,0,double,1
+pROC,solve.nd,3,0,0,double,1
+pROC,solve.nd,4,0,0,double,1
+pROC,solve.zalpha,-1,0,0,double,1
+pROC,solve.zalpha,0,0,0,double,1
+pROC,solve.zalpha,1,0,0,double,1
+pROC,solve.zalpha,2,0,0,double,1
+pROC,solve.zalpha,3,0,0,double,1
+pROC,solve.zalpha,4,0,0,double,1
+pROC,solve.zbeta,-1,0,0,double,1
+pROC,solve.zbeta,0,0,0,double,1
+pROC,solve.zbeta,1,0,0,double,1
+pROC,solve.zbeta,2,0,0,double,1
+pROC,solve.zbeta,3,0,0,double,1
+pROC,solve.zbeta,4,0,0,double,1
+pROC,sort.roc,-1,0,0,class<`roc`>,1
+pROC,sort.roc,0,0,0,class<`roc`>,1
+pROC,sort.smooth.roc,-1,0,0,class<`smooth.roc`>,1
+pROC,sort.smooth.roc,0,0,0,class<`smooth.roc`>,1
+pROC,stratified.ci.coords,-1,0,0,class<`matrix`>,1
+pROC,stratified.ci.coords,0,0,0,class<`roc`>,1
+pROC,stratified.ci.coords,1,0,0,character,1
+pROC,stratified.ci.coords,1,0,1,double[],1
+pROC,stratified.ci.coords,2,0,0,character,1
+pROC,stratified.ci.coords,3,0,0,character[],1
+pROC,stratified.ci.coords,4,0,0,any,1
+pROC,stratified.ci.coords,5,0,0,any,1
+pROC,stratified.ci.coords,6,0,0,any,1
+pROC,stratified.ci.smooth.coords,-1,0,0,class<`matrix`>,1
+pROC,stratified.ci.smooth.coords,0,0,0,class<`roc`>,1
+pROC,stratified.ci.smooth.coords,1,0,0,double,1
+pROC,stratified.ci.smooth.coords,2,0,0,character,1
+pROC,stratified.ci.smooth.coords,3,0,0,character[],1
+pROC,stratified.ci.smooth.coords,4,0,0,any,1
+pROC,stratified.ci.smooth.coords,5,0,0,double[],1
+pROC,stratified.ci.smooth.coords,6,0,0,class<`call`>,1
+pROC,stratified.ci.smooth.coords,7,0,0,any,1
+pROC,var,-1,0,0,double,1
+pROC,var,0,0,0,...,1
+pROC,var0.delta.covvar,-1,0,0,double,1
+pROC,var0.delta.covvar,0,0,0,list<double>,1
+pROC,var.auc,-1,0,0,double,1
+pROC,var.auc,0,0,0,"class<`auc`, `numeric`>",1
+pROC,var.auc,1,0,0,...,1
+pROC,var.default,-1,0,0,double,1
+pROC,var.default,0,0,0,...,1
+pROC,var.delta.covvar,-1,0,0,double,1
+pROC,var.delta.covvar,0,0,0,list<double>,1
+pROC,var.params.obuchowski,-1,0,0,double,1
+pROC,var.params.obuchowski,0,0,0,double,1
+pROC,var.params.obuchowski,1,0,0,double,1
+pROC,var.params.obuchowski,2,0,0,double,1
+pROC,var.params.obuchowski,3,0,0,any,1
+pROC,var.params.obuchowski,4,0,0,any,1
+pROC,var.roc,-1,0,0,double,1
+pROC,var.roc,0,0,0,class<`roc`>,1
+pROC,var.roc,1,0,0,character[],1
+pROC,var.roc,2,0,0,double,1
+pROC,var.roc,3,0,0,logical,1
+pROC,var.roc,4,0,0,logical,1
+pROC,var.roc,5,0,0,any,1
+pROC,var.roc,6,0,0,logical,1
+pROC,var.roc,7,0,0,...,1
+pROC,var.roc.obuchowski,-1,0,0,double,1
+pROC,var.roc.obuchowski,0,0,0,class<`roc`>,1
+pROC,var.theta.obuchowski,-1,0,0,double,1
+pROC,var.theta.obuchowski,0,0,0,double,1
+pROC,var.theta.obuchowski,1,0,0,double,1
+pROC,zalpha.obuchowski,-1,0,0,double,1
+pROC,zalpha.obuchowski,0,0,0,class<`roc`>,1
+pROC,zalpha.obuchowski,1,0,0,class<`roc`>,1
+pROC,zalpha.obuchowski,2,0,0,double,1
+pROC,zalpha.obuchowski,3,0,0,character[],1
+pROC,zalpha.obuchowski,4,0,0,...,1
+pROC,zalpha.obuchowski.params,-1,0,0,double,1
+pROC,zalpha.obuchowski.params,0,0,0,list<double>,1
+pROC,zalpha.obuchowski.params,1,0,0,double,1
+pROC,zalpha.obuchowski.params,2,0,0,double,1
+pROC,zalpha.obuchowski.params,3,0,0,double,1
+pROC,zbeta.obuchowski,-1,0,0,double,1
+pROC,zbeta.obuchowski,0,0,0,class<`roc`>,1
+pROC,zbeta.obuchowski,1,0,0,class<`roc`>,1
+pROC,zbeta.obuchowski,2,0,0,double,1
+pROC,zbeta.obuchowski,3,0,0,character[],1
+pROC,zbeta.obuchowski,4,0,0,...,1
+pROC,zbeta.obuchowski.params,-1,0,0,double,1
+pROC,zbeta.obuchowski.params,0,0,0,list<double>,1
+pROC,zbeta.obuchowski.params,1,0,0,double,1
+pROC,zbeta.obuchowski.params,2,0,0,double,1
+pROC,zbeta.obuchowski.params,3,0,0,double,1
+paradox,assert_id,-1,0,0,character,1
+paradox,assert_id,0,0,0,character,1
+paradox,assert_param,-1,0,0,"class<`Param`, `ParamDbl`, `R6`>",1
+paradox,assert_param,-1,0,1,"class<`Param`, `ParamFct`, `R6`>",1
+paradox,assert_param,0,0,0,"class<`Param`, `ParamDbl`, `R6`>",1
+paradox,assert_param,0,0,1,"class<`Param`, `ParamFct`, `R6`>",1
+paradox,assert_param,1,0,0,character,1
+paradox,assert_param,2,0,0,logical,1
+paradox,assert_param,3,0,0,logical,1
+paradox,assert_param_set,-1,0,0,"class<`ParamSet`, `R6`>",1
+paradox,assert_param_set,0,0,0,"class<`ParamSet`, `R6`>",1
+paradox,assert_param_set,1,0,0,character,1
+paradox,assert_param_set,2,0,0,logical,1
+paradox,assert_param_set,3,0,0,logical,1
+paradox,assert_param_set,4,0,0,logical,1
+paradox,generate_design_grid,-1,0,0,"class<`Design`, `R6`>",1
+paradox,generate_design_grid,0,0,0,"class<`ParamSet`, `R6`>",1
+paradox,generate_design_grid,1,0,0,double,1
+paradox,generate_design_grid,2,0,0,null,1
+paradox,generate_design_lhs,-1,0,0,"class<`Design`, `R6`>",1
+paradox,generate_design_lhs,0,0,0,"class<`ParamSet`, `R6`>",1
+paradox,generate_design_lhs,1,0,0,double,1
+paradox,generate_design_lhs,2,0,0,null,1
+paradox,generate_design_random,-1,0,0,"class<`Design`, `R6`>",1
+paradox,generate_design_random,0,0,0,"class<`ParamSet`, `R6`>",1
+paradox,generate_design_random,1,0,0,double,1
+paradox,is_nodefault,-1,0,0,logical,1
+paradox,is_nodefault,0,0,0,"class<`NoDefault`, `R6`>",1
+paradox,is_nodefault,0,0,1,double,1
+parallelMap,assignInFunctionNamespace,-1,0,0,null,1
+parallelMap,assignInFunctionNamespace,0,0,0,class<`function`>,1
+parallelMap,assignInFunctionNamespace,1,0,0,list<any>,1
+parallelMap,assignInFunctionNamespace,2,0,0,environment,1
+parallelMap,checkResultsAndStopWithErrorsMessages,-1,0,0,null,1
+parallelMap,checkResultsAndStopWithErrorsMessages,0,0,0,list<integer>,1
+parallelMap,getExtraPackages,-1,0,0,character[],1
+parallelMap,getExtraPackages,0,0,0,character,1
+parallelMap,getPMDefOptCpus,-1,0,0,null,1
+parallelMap,getPMDefOptCpus,0,0,0,any,1
+parallelMap,getPMDefOption,-1,0,0,character,1
+parallelMap,getPMDefOption,-1,0,1,logical,1
+parallelMap,getPMDefOption,-1,0,2,null,1
+parallelMap,getPMDefOption,0,0,0,character,1
+parallelMap,getPMDefOption,1,0,0,character,1
+parallelMap,getPMDefOption,1,0,1,logical,1
+parallelMap,getPMDefOption,1,0,2,null,1
+parallelMap,getPMDefOptLevel,-1,0,0,null,1
+parallelMap,getPMDefOptLevel,0,0,0,any,1
+parallelMap,getPMDefOptLogging,-1,0,0,logical,1
+parallelMap,getPMDefOptLogging,0,0,0,any,1
+parallelMap,getPMDefOptMode,-1,0,0,character,1
+parallelMap,getPMDefOptMode,0,0,0,any,1
+parallelMap,getPMDefOptShowInfo,-1,0,0,logical,1
+parallelMap,getPMDefOptShowInfo,0,0,0,any,1
+parallelMap,getPMDefOptSocketHosts,-1,0,0,null,1
+parallelMap,getPMDefOptSocketHosts,0,0,0,any,1
+parallelMap,getPMDefOptStorageDir,-1,0,0,character,1
+parallelMap,getPMDefOptStorageDir,0,0,0,any,1
+parallelMap,getPMOptCpus,-1,0,0,null,1
+parallelMap,getPMOption,-1,0,0,character,1
+parallelMap,getPMOption,-1,0,1,integer,1
+parallelMap,getPMOption,-1,0,2,list<any>,1
+parallelMap,getPMOption,-1,0,3,null,1
+parallelMap,getPMOption,0,0,0,character,1
+parallelMap,getPMOption,1,0,0,any,1
+parallelMap,getPMOptLoadBalancing,-1,0,0,logical,1
+parallelMap,getPMOptLogging,-1,0,0,logical,1
+parallelMap,getPMOptMode,-1,0,0,character,1
+parallelMap,getPMOptNextMap,-1,0,0,integer,1
+parallelMap,getPMOptStatus,-1,0,0,character,1
+parallelMap,isModeBatchJobs,-1,0,0,logical,1
+parallelMap,isModeBatchtools,-1,0,0,logical,1
+parallelMap,isModeLocal,-1,0,0,logical,1
+parallelMap,isModeMPI,-1,0,0,logical,1
+parallelMap,isModeMulticore,-1,0,0,logical,1
+parallelMap,isModeSocket,-1,0,0,logical,1
+parallelMap,isStatusStarted,-1,0,0,logical,1
+parallelMap,makeMulticoreCluster,-1,0,0,logical,1
+parallelMap,makeMulticoreCluster,0,0,0,logical,1
+parallelMap,makeMulticoreCluster,1,0,0,logical,1
+parallelMap,makeMulticoreCluster,2,0,0,logical,1
+parallelMap,makeMulticoreCluster,3,0,0,logical,1
+parallelMap,parallelGetRegisteredLevels,-1,0,0,character[],1
+parallelMap,parallelGetRegisteredLevels,0,0,0,logical,1
+parallelMap,parallelMap,-1,0,0,list<integer>,1
+parallelMap,parallelMap,0,0,0,class<`function`>,1
+parallelMap,parallelMap,1,0,0,...,1
+parallelMap,parallelMap,2,0,0,list<any>,1
+parallelMap,parallelMap,3,0,0,logical,1
+parallelMap,parallelMap,4,0,0,logical,1
+parallelMap,parallelMap,5,0,0,null,1
+parallelMap,parallelMap,6,0,0,null,1
+parallelMap,parallelMap,7,0,0,null,1
+parallelMap,parallelStart,-1,0,0,null,1
+parallelMap,parallelStart,0,0,0,any,1
+parallelMap,parallelStart,1,0,0,any,1
+parallelMap,parallelStart,2,0,0,any,1
+parallelMap,parallelStart,3,0,0,list<any>,1
+parallelMap,parallelStart,4,0,0,list<any>,1
+parallelMap,parallelStart,5,0,0,any,1
+parallelMap,parallelStart,6,0,0,any,1
+parallelMap,parallelStart,7,0,0,any,1
+parallelMap,parallelStart,8,0,0,logical,1
+parallelMap,parallelStart,9,0,0,any,1
+parallelMap,parallelStart,10,0,0,logical,1
+parallelMap,parallelStart,11,0,0,...,1
+parallelMap,parallelStop,-1,0,0,null,1
+parallelMap,showStartupMsg,-1,0,0,null,1
+parallelMap,showStartupMsg,0,0,0,character,1
+parallelMap,showStartupMsg,1,0,0,any,1
+parallelMap,showStartupMsg,2,0,0,any,1
+party,cforest,-1,0,0,class<`RandomForest`>,1
+party,cforest,0,0,0,class<`formula`>,1
+party,cforest,1,0,0,class<`data.frame`>,1
+party,cforest,2,0,0,null,1
+party,cforest,3,0,0,null,1
+party,cforest,3,0,1,class<`matrix`>,1
+party,cforest,4,0,0,class<`ForestControl`>,1
+party,cforest,5,0,0,class<`function`>,1
+party,cforest,6,0,0,class<`function`>,1
+party,cforest,7,0,0,null,1
+party,cforest_classical,-1,0,0,class<`ForestControl`>,1
+party,cforest_classical,0,0,0,...,1
+party,cforest_control,-1,0,0,class<`ForestControl`>,1
+party,cforest_control,0,0,0,character,1
+party,cforest_control,1,0,0,character,1
+party,cforest_control,2,0,0,double,1
+party,cforest_control,3,0,0,logical,1
+party,cforest_control,4,0,0,double,1
+party,cforest_control,5,0,0,double,1
+party,cforest_control,6,0,0,logical,1
+party,cforest_control,7,0,0,double,1
+party,cforestfit,-1,0,0,class<`RandomForest`>,1
+party,cforestfit,0,0,0,class<`LearningSampleFormula`>,1
+party,cforestfit,0,0,1,class<`LearningSample`>,1
+party,cforestfit,1,0,0,class<`ForestControl`>,1
+party,cforestfit,2,0,0,null,1
+party,cforestfit,3,0,0,...,1
+party,cforest_unbiased,-1,0,0,class<`ForestControl`>,1
+party,cforest_unbiased,0,0,0,...,1
+party,coef.mob,-1,0,0,class<`matrix`>,1
+party,coef.mob,0,0,0,class<`mob`>,1
+party,coef.mob,1,0,0,null,1
+party,coef.mob,2,0,0,...,1
+party,conditional_perm,-1,0,0,integer[],1
+party,conditional_perm,0,0,0,character[],1
+party,conditional_perm,1,0,0,character[],1
+party,conditional_perm,2,0,0,any,1
+party,conditional_perm,3,0,0,list<null | double[] | list<any>>,1
+party,conditional_perm,3,0,1,list<null | double | list<any>>,1
+party,conditional_perm,4,0,0,logical[],1
+party,copyslots,-1,0,0,class<`ForestControl`>,1
+party,copyslots,0,0,0,class<`TreeControl`>,1
+party,copyslots,1,0,0,class<`ForestControl`>,1
+party,create_cond_list,-1,0,0,character[],1
+party,create_cond_list,-1,0,1,null,1
+party,create_cond_list,0,0,0,logical,1
+party,create_cond_list,1,0,0,any,1
+party,create_cond_list,2,0,0,any,1
+party,create_cond_list,3,0,0,any,1
+party,ctree,-1,0,0,class<`BinaryTree`>,1
+party,ctree,0,0,0,class<`formula`>,1
+party,ctree,1,0,0,class<`data.frame`>,1
+party,ctree,2,0,0,null,1
+party,ctree,3,0,0,null,1
+party,ctree,4,0,0,class<`TreeControl`>,1
+party,ctree,5,0,0,class<`function`>,1
+party,ctree,6,0,0,class<`function`>,1
+party,ctree,7,0,0,null,1
+party,ctree_control,-1,0,0,class<`TreeControl`>,1
+party,ctree_control,0,0,0,character[],1
+party,ctree_control,1,0,0,character[],1
+party,ctree_control,2,0,0,double,1
+party,ctree_control,3,0,0,double,1
+party,ctree_control,4,0,0,double,1
+party,ctree_control,5,0,0,logical,1
+party,ctree_control,6,0,0,double,1
+party,ctree_control,7,0,0,double,1
+party,ctreefit,-1,0,0,class<`BinaryTree`>,1
+party,ctreefit,0,0,0,class<`LearningSampleFormula`>,1
+party,ctreefit,0,0,1,class<`LearningSample`>,1
+party,ctreefit,1,0,0,class<`TreeControl`>,1
+party,ctreefit,2,0,0,null,1
+party,ctreefit,3,0,0,...,1
+party,cutpoints_list,-1,0,0,double[],1
+party,cutpoints_list,-1,0,1,null,1
+party,cutpoints_list,0,0,0,list<null | double[] | list<any>>,1
+party,cutpoints_list,0,0,1,list<null | double | list<any>>,1
+party,cutpoints_list,1,0,0,integer,1
+party,deviance.mob,-1,0,0,double,1
+party,deviance.mob,0,0,0,class<`mob`>,1
+party,deviance.mob,1,0,0,null,1
+party,deviance.mob,2,0,0,...,1
+party,dostep,-1,0,0,list<double[]>,1
+party,dostep,0,0,0,double[],1
+party,dostep,1,0,0,double[],1
+party,ExpectCovarInfluence,-1,0,0,class<`ExpectCovarInfluence`>,1
+party,ExpectCovarInfluence,0,0,0,class<`matrix`>,1
+party,ExpectCovarInfluence,1,0,0,double[],1
+party,ExpectCovarLinearStatistic,-1,0,0,class<`ExpectCovar`>,1
+party,ExpectCovarLinearStatistic,0,0,0,class<`matrix`>,1
+party,ExpectCovarLinearStatistic,1,0,0,class<`matrix`>,1
+party,ExpectCovarLinearStatistic,2,0,0,double[],1
+party,ff_trafo,-1,0,0,class<`matrix`>,1
+party,ff_trafo,0,0,0,class<`factor`>,1
+party,ff_trafo,0,0,1,"class<`factor`, `ordered`>",1
+party,fitted.mob,-1,0,0,double[],1
+party,fitted.mob,0,0,0,class<`mob`>,1
+party,fitted.mob,1,0,0,...,1
+party,initVariableFrame,-1,0,0,class<`ResponseFrame`>,1
+party,initVariableFrame,-1,0,1,class<`VariableFrame`>,1
+party,initVariableFrame,0,0,0,class<`data.frame`>,1
+party,initVariableFrame,0,0,1,class<`matrix`>,1
+party,initVariableFrame,1,0,0,...,1
+party,initVariableFrame,-1,1,0,class<`ResponseFrame`>,1
+party,initVariableFrame,-1,1,1,class<`VariableFrame`>,1
+party,initVariableFrame,0,1,0,class<`data.frame`>,1
+party,initVariableFrame,1,1,0,...,1
+party,initVariableFrame,-1,2,0,class<`VariableFrame`>,1
+party,initVariableFrame,0,2,0,class<`matrix`>,1
+party,initVariableFrame,1,2,0,...,1
+party,isequal,-1,0,0,logical,1
+party,isequal,0,0,0,class<`factor`>,1
+party,isequal,0,0,1,class<`matrix`>,1
+party,isequal,0,0,2,double[],1
+party,isequal,0,0,3,list<class<`survfit`>>,1
+party,isequal,0,0,4,list<double[]>,1
+party,isequal,1,0,0,class<`factor`>,1
+party,isequal,1,0,1,class<`matrix`>,1
+party,isequal,1,0,2,double[],1
+party,isequal,1,0,3,list<class<`survfit`>>,1
+party,isequal,1,0,4,list<double[]>,1
+party,LearningSample,-1,0,0,class<`LearningSample`>,1
+party,LearningSample,0,0,0,class<`matrix`>,1
+party,LearningSample,1,0,0,...,1
+party,LearningSample,-1,1,0,class<`LearningSample`>,1
+party,LearningSample,0,1,0,class<`matrix`>,1
+party,LearningSample,1,1,0,...,1
+party,LinearStatistic,-1,0,0,double[],1
+party,LinearStatistic,0,0,0,class<`matrix`>,1
+party,LinearStatistic,1,0,0,class<`matrix`>,1
+party,LinearStatistic,2,0,0,double[],1
+party,logLik.mob,-1,0,0,class<`logLik`>,1
+party,logLik.mob,0,0,0,class<`mob`>,1
+party,logLik.mob,1,0,0,null,1
+party,logLik.mob,2,0,0,...,1
+party,maxabsTestStatistic,-1,0,0,double,1
+party,maxabsTestStatistic,0,0,0,double[],1
+party,maxabsTestStatistic,1,0,0,double[],1
+party,maxabsTestStatistic,2,0,0,class<`matrix`>,1
+party,maxabsTestStatistic,3,0,0,double,1
+party,maxdepth,-1,0,0,double,1
+party,maxdepth,0,0,0,class<`SplittingNode`>,1
+party,maxdepth,0,0,1,class<`TerminalModelNode`>,1
+party,maxdepth,0,0,2,class<`TerminalNode`>,1
+party,mob,-1,0,0,class<`mob`>,1
+party,mob,0,0,0,class<`formula`>,1
+party,mob,1,0,0,any,1
+party,mob,2,0,0,class<`data.frame`>,1
+party,mob,3,0,0,class<`standardGeneric`>,1
+party,mob,4,0,0,class<`StatModel`>,1
+party,mob,5,0,0,class<`mob_control`>,1
+party,mob,6,0,0,...,1
+party,mob_control,-1,0,0,class<`mob_control`>,1
+party,mob_control,0,0,0,double,1
+party,mob_control,1,0,0,logical,1
+party,mob_control,2,0,0,double,1
+party,mob_control,3,0,0,double,1
+party,mob_control,4,0,0,class<`function`>,1
+party,mob_control,5,0,0,logical,1
+party,mob_control,6,0,0,null,1
+party,mob_control,7,0,0,logical,1
+party,mob_fit_checksplit,-1,0,0,logical,1
+party,mob_fit_checksplit,0,0,0,logical[],1
+party,mob_fit_checksplit,1,0,0,double[],1
+party,mob_fit_checksplit,2,0,0,double,1
+party,mob_fit_childweights,-1,0,0,list<double[]>,1
+party,mob_fit_childweights,0,0,0,class<`SplittingNode`>,1
+party,mob_fit_childweights,1,0,0,class<`ModelEnvFormula`>,1
+party,mob_fit_childweights,2,0,0,double[],1
+party,mob_fit_fluctests,-1,0,0,list<double[]>,1
+party,mob_fit_fluctests,0,0,0,"class<`glinearModel`, `glm`, `lm`>",1
+party,mob_fit_fluctests,0,0,1,"class<`linearModel`, `lm`>",1
+party,mob_fit_fluctests,1,0,0,class<`ModelEnvFormula`>,1
+party,mob_fit_fluctests,2,0,0,double,1
+party,mob_fit_fluctests,3,0,0,double,1
+party,mob_fit_fluctests,4,0,0,logical,1
+party,mob_fit_fluctests,5,0,0,null,1
+party,mob_fit_getlevels,-1,0,0,class<`matrix`>,1
+party,mob_fit_getlevels,0,0,0,class<`factor`>,1
+party,mob_fit_getlevels,0,0,1,"class<`factor`, `ordered`>",1
+party,mob_fit_getobjfun,-1,0,0,double,1
+party,mob_fit_getobjfun,0,0,0,"class<`glinearModel`, `glm`, `lm`>",1
+party,mob_fit_getobjfun,0,0,1,"class<`linearModel`, `lm`>",1
+party,mob_fit_getobjfun,1,0,0,any,1
+party,mob_fit_getobjfun,2,0,0,double[],1
+party,mob_fit_getobjfun,3,0,0,logical[],1
+party,mob_fit_getobjfun,4,0,0,class<`function`>,1
+party,mob_fit_setupnode,-1,0,0,class<`SplittingNode`>,1
+party,mob_fit_setupnode,-1,0,1,class<`TerminalModelNode`>,1
+party,mob_fit_setupnode,0,0,0,any,1
+party,mob_fit_setupnode,1,0,0,any,1
+party,mob_fit_setupnode,2,0,0,double[],1
+party,mob_fit_setupnode,3,0,0,class<`mob_control`>,1
+party,mob_fit_splitnode,-1,0,0,class<`orderedSplit`>,1
+party,mob_fit_splitnode,-1,0,1,logical,1
+party,mob_fit_splitnode,0,0,0,"class<`factor`, `ordered`>",1
+party,mob_fit_splitnode,0,0,1,double[],1
+party,mob_fit_splitnode,0,0,2,class<`factor`>,1
+party,mob_fit_splitnode,1,0,0,any,1
+party,mob_fit_splitnode,2,0,0,any,1
+party,mob_fit_splitnode,3,0,0,double[],1
+party,mob_fit_splitnode,4,0,0,double,1
+party,mob_fit_splitnode,5,0,0,any,1
+party,mob_fit_splitnode,6,0,0,any,1
+party,MPinv,-1,0,0,class<`matrix`>,1
+party,MPinv,0,0,0,class<`matrix`>,1
+party,MPinv,1,0,0,double,1
+party,mysurvfit,-1,0,0,class<`survfit`>,1
+party,mysurvfit,0,0,0,class<`Surv`>,1
+party,mysurvfit,1,0,0,double[],1
+party,mysurvfit,2,0,0,...,1
+party,newinputs,-1,0,0,class<`VariableFrame`>,1
+party,newinputs,0,0,0,class<`LearningSample`>,1
+party,newinputs,0,0,1,class<`LearningSampleFormula`>,1
+party,newinputs,1,0,0,class<`matrix`>,1
+party,newinputs,1,0,1,class<`data.frame`>,1
+party,newinputs,1,0,2,null,1
+party,node_boxplot,-1,0,0,class<`function`>,1
+party,node_boxplot,0,0,0,class<`BinaryTree`>,1
+party,node_boxplot,1,0,0,character,1
+party,node_boxplot,2,0,0,any,1
+party,node_boxplot,3,0,0,double,1
+party,node_boxplot,4,0,0,null,1
+party,node_boxplot,5,0,0,double,1
+party,node_boxplot,6,0,0,double,1
+party,node_boxplot,7,0,0,logical,1
+party,node_hist,-1,0,0,class<`function`>,1
+party,node_hist,0,0,0,class<`BinaryTree`>,1
+party,node_hist,1,0,0,character,1
+party,node_hist,2,0,0,character,1
+party,node_hist,3,0,0,logical,1
+party,node_hist,4,0,0,logical,1
+party,node_hist,5,0,0,double[],1
+party,node_hist,5,0,1,null,1
+party,node_hist,6,0,0,double,1
+party,node_hist,7,0,0,double,1
+party,nodes,-1,0,0,list<class<`SplittingNode`>>,1
+party,nodes,0,0,0,class<`BinaryTree`>,1
+party,nodes,1,0,0,double[],1
+party,nodes,2,0,0,...,1
+party,nodes,-1,1,0,list<class<`TerminalModelNode`>>,1
+party,nodes,0,1,0,class<`mob`>,1
+party,nodes,1,1,0,integer[],1
+party,nodes,2,1,0,...,1
+party,nodes,-1,2,0,list<class<`TerminalModelNode`>>,1
+party,nodes,0,2,0,class<`mob`>,1
+party,nodes,1,2,0,double,1
+party,nodes,2,2,0,...,1
+party,nodes,-1,3,0,list<class<`SplittingNode`>>,1
+party,nodes,-1,3,1,list<class<`TerminalNode`>>,1
+party,nodes,0,3,0,class<`BinaryTree`>,1
+party,nodes,1,3,0,integer[],1
+party,nodes,2,3,0,...,1
+party,nodes,-1,4,0,list<class<`SplittingNode`>>,1
+party,nodes,-1,4,1,list<class<`TerminalModelNode`>>,1
+party,nodes,-1,4,2,list<class<`TerminalNode`>>,1
+party,nodes,0,4,0,class<`BinaryTree`>,1
+party,nodes,0,4,1,class<`mob`>,1
+party,nodes,1,4,0,double[],1
+party,nodes,2,4,0,...,1
+party,node_surv,-1,0,0,class<`function`>,1
+party,node_surv,0,0,0,class<`BinaryTree`>,1
+party,node_surv,1,0,0,double,1
+party,node_surv,2,0,0,logical,1
+party,node_surv,3,0,0,...,1
+party,nterminal,-1,0,0,double,1
+party,nterminal,0,0,0,class<`SplittingNode`>,1
+party,nterminal,0,0,1,class<`TerminalModelNode`>,1
+party,nterminal,0,0,2,class<`TerminalNode`>,1
+party,PermutedLinearStatistic,-1,0,0,double[],1
+party,PermutedLinearStatistic,0,0,0,class<`matrix`>,1
+party,PermutedLinearStatistic,1,0,0,class<`matrix`>,1
+party,PermutedLinearStatistic,2,0,0,integer[],1
+party,PermutedLinearStatistic,3,0,0,integer[],1
+party,plot.BinaryTree,-1,0,0,null,1
+party,plot.BinaryTree,0,0,0,class<`mob`>,1
+party,plot.BinaryTree,0,0,1,class<`BinaryTree`>,1
+party,plot.BinaryTree,1,0,0,null,1
+party,plot.BinaryTree,2,0,0,character[],1
+party,plot.BinaryTree,3,0,0,class<`grapcon_generator`>,1
+party,plot.BinaryTree,3,0,1,class<`function`>,1
+party,plot.BinaryTree,3,0,2,null,1
+party,plot.BinaryTree,4,0,0,any,1
+party,plot.BinaryTree,5,0,0,class<`grapcon_generator`>,1
+party,plot.BinaryTree,6,0,0,list<any>,1
+party,plot.BinaryTree,7,0,0,class<`grapcon_generator`>,1
+party,plot.BinaryTree,7,0,1,class<`function`>,1
+party,plot.mob,-1,0,0,null,1
+party,plot.mob,0,0,0,class<`mob`>,1
+party,plot.mob,1,0,0,class<`grapcon_generator`>,1
+party,plot.mob,2,0,0,double,1
+party,plot.mob,2,0,1,null,1
+party,plot.mob,3,0,0,...,1
+party,plotTree,-1,0,0,null,1
+party,plotTree,0,0,0,class<`SplittingNode`>,1
+party,plotTree,0,0,1,class<`TerminalModelNode`>,1
+party,plotTree,0,0,2,class<`TerminalNode`>,1
+party,plotTree,1,0,0,double[],1
+party,plotTree,2,0,0,double[],1
+party,plotTree,3,0,0,any,1
+party,plotTree,4,0,0,any,1
+party,plotTree,5,0,0,class<`function`>,1
+party,plotTree,6,0,0,any,1
+party,plotTree,7,0,0,any,1
+party,predict.BinaryTree,-1,0,0,class<`factor`>,1
+party,predict.BinaryTree,-1,0,1,class<`matrix`>,1
+party,predict.BinaryTree,-1,0,2,integer[],1
+party,predict.BinaryTree,-1,0,3,list<double[]>,1
+party,predict.BinaryTree,0,0,0,class<`BinaryTree`>,1
+party,predict.BinaryTree,1,0,0,...,1
+party,predict.mob,-1,0,0,double[],1
+party,predict.mob,0,0,0,class<`mob`>,1
+party,predict.mob,1,0,0,null,1
+party,predict.mob,2,0,0,character[],1
+party,predict.mob,3,0,0,...,1
+party,predict.RandomForest,-1,0,0,class<`factor`>,1
+party,predict.RandomForest,0,0,0,class<`RandomForest`>,1
+party,predict.RandomForest,1,0,0,logical,1
+party,predict.RandomForest,2,0,0,logical,1
+party,predict.RandomForest,3,0,0,...,1
+party,prettysplit,-1,0,0,class<`orderedSplit`>,1
+party,prettysplit,-1,0,1,class<`nominalSplit`>,1
+party,prettysplit,0,0,0,list<double | null>,1
+party,prettysplit,0,0,1,list<double[]>,1
+party,prettysplit,0,0,2,list<integer[] | null>,1
+party,prettysplit,0,0,3,list<double[] | null>,1
+party,prettysplit,1,0,0,character[],1
+party,prettysplit,1,0,1,null,1
+party,prettysplit,2,0,0,list<null>,1
+party,prettysplit,2,0,1,list<character[] | null>,1
+party,prettysplit,2,0,2,null,1
+party,prettysplit,2,0,3,list<null | character[]>,1
+party,prettysplit,2,0,4,list<character[]>,1
+party,prettytree,-1,0,0,class<`SplittingNode`>,1
+party,prettytree,-1,0,1,class<`TerminalNode`>,1
+party,prettytree,0,0,0,list<null | double | list<any>>,1
+party,prettytree,0,0,1,list<double[] | list<any>>,1
+party,prettytree,0,0,2,list<double[] | null | list<any>>,1
+party,prettytree,0,0,3,list<double[] | null | list<double[] | null>>,1
+party,prettytree,1,0,0,character[],1
+party,prettytree,1,0,1,null,1
+party,prettytree,2,0,0,any,1
+party,print.BinaryTree,-1,0,0,null,1
+party,print.BinaryTree,0,0,0,class<`BinaryTree`>,1
+party,print.BinaryTree,1,0,0,...,1
+party,print.orderedSplit,-1,0,0,null,1
+party,print.orderedSplit,0,0,0,class<`orderedSplit`>,1
+party,print.orderedSplit,1,0,0,logical,1
+party,print.orderedSplit,2,0,0,...,1
+party,print.SplittingNode,-1,0,0,null,1
+party,print.SplittingNode,0,0,0,class<`SplittingNode`>,1
+party,print.SplittingNode,1,0,0,double,1
+party,print.SplittingNode,2,0,0,...,1
+party,print.TerminalNode,-1,0,0,null,1
+party,print.TerminalNode,0,0,0,class<`TerminalNode`>,1
+party,print.TerminalNode,1,0,0,double,1
+party,print.TerminalNode,2,0,0,...,1
+party,proximity,-1,0,0,class<`matrix`>,1
+party,proximity,0,0,0,class<`RandomForest`>,1
+party,proximity,1,0,0,null,1
+party,ptrafo,-1,0,0,class<`matrix`>,1
+party,ptrafo,0,0,0,class<`data.frame`>,1
+party,ptrafo,1,0,0,any,1
+party,ptrafo,2,0,0,any,1
+party,ptrafo,3,0,0,any,1
+party,ptrafo,4,0,0,any,1
+party,ptrafo,5,0,0,null,1
+party,qsvd,-1,0,0,list<class<`matrix`> | double[]>,1
+party,qsvd,0,0,0,class<`matrix`>,1
+party,quadformTestStatistic,-1,0,0,double,1
+party,quadformTestStatistic,0,0,0,double[],1
+party,quadformTestStatistic,1,0,0,double[],1
+party,quadformTestStatistic,2,0,0,class<`matrix`>,1
+party,quadformTestStatistic,3,0,0,double,1
+party,.resample,-1,0,0,integer[],1
+party,.resample,0,0,0,integer[],1
+party,.resample,1,0,0,...,1
+party,residuals.mob,-1,0,0,double[],1
+party,residuals.mob,0,0,0,class<`mob`>,1
+party,residuals.mob,1,0,0,...,1
+party,response,-1,0,0,class<`data.frame`>,1
+party,response,0,0,0,class<`mob`>,1
+party,response,1,0,0,...,1
+party,response,-1,1,0,class<`data.frame`>,1
+party,response,0,1,0,class<`BinaryTree`>,1
+party,response,1,1,0,...,1
+party,response,-1,2,0,class<`data.frame`>,1
+party,response,0,2,0,class<`mob`>,1
+party,response,0,2,1,class<`BinaryTree`>,1
+party,response,1,2,0,...,1
+party,reweight,-1,0,0,"class<`glinearModel`, `glm`, `lm`>",1
+party,reweight,-1,0,1,"class<`linearModel`, `lm`>",1
+party,reweight,0,0,0,"class<`glinearModel`, `glm`, `lm`>",1
+party,reweight,0,0,1,"class<`linearModel`, `lm`>",1
+party,reweight,1,0,0,double[],1
+party,reweight,2,0,0,...,1
+party,reweight.glinearModel,-1,0,0,"class<`glinearModel`, `glm`, `lm`>",1
+party,reweight.glinearModel,0,0,0,"class<`glinearModel`, `glm`, `lm`>",1
+party,reweight.glinearModel,1,0,0,double[],1
+party,reweight.glinearModel,2,0,0,...,1
+party,reweight.linearModel,-1,0,0,"class<`linearModel`, `lm`>",1
+party,reweight.linearModel,0,0,0,"class<`linearModel`, `lm`>",1
+party,reweight.linearModel,1,0,0,double[],1
+party,reweight.linearModel,2,0,0,...,1
+party,.R_get_nodeID,-1,0,0,integer[],1
+party,.R_get_nodeID,0,0,0,class<`SplittingNode`>,1
+party,.R_get_nodeID,1,0,0,class<`VariableFrame`>,1
+party,.R_get_nodeID,2,0,0,any,1
+party,.R_predict,-1,0,0,list<double[]>,1
+party,.R_predict,0,0,0,list<null | double[] | list<any>>,1
+party,.R_predict,0,0,1,list<null | double | list<any>>,1
+party,.R_predict,1,0,0,class<`VariableFrame`>,1
+party,.R_predict,2,0,0,double,1
+party,.R_predict,3,0,0,integer,1
+party,sctest.mob,-1,0,0,class<`matrix`>,1
+party,sctest.mob,0,0,0,class<`mob`>,1
+party,sctest.mob,1,0,0,double,1
+party,sctest.mob,2,0,0,...,1
+party,summary.mob,-1,0,0,class<`summary.lm`>,1
+party,summary.mob,-1,0,1,list<class<`summary.glm`>>,1
+party,summary.mob,-1,0,2,list<class<`summary.lm`>>,1
+party,summary.mob,0,0,0,class<`mob`>,1
+party,summary.mob,1,0,0,double,1
+party,summary.mob,1,0,1,null,1
+party,summary.mob,2,0,0,...,1
+party,terminal_nodeIDs,-1,0,0,integer[],1
+party,terminal_nodeIDs,0,0,0,class<`SplittingNode`>,1
+party,terminal_nodeIDs,0,0,1,class<`TerminalModelNode`>,1
+party,treeresponse,-1,0,0,list<class<`matrix`>>,1
+party,treeresponse,-1,0,1,list<class<`survfit`>>,1
+party,treeresponse,-1,0,2,list<double[]>,1
+party,treeresponse,0,0,0,class<`RandomForest`>,1
+party,treeresponse,0,0,1,class<`BinaryTree`>,1
+party,treeresponse,1,0,0,...,1
+party,treeresponse,-1,1,0,list<class<`survfit`>>,1
+party,treeresponse,-1,1,1,list<double[]>,1
+party,treeresponse,0,1,0,class<`BinaryTree`>,1
+party,treeresponse,1,1,0,...,1
+party,treeresponse,-1,2,0,list<class<`matrix`>>,1
+party,treeresponse,-1,2,1,list<class<`survfit`>>,1
+party,treeresponse,0,2,0,class<`RandomForest`>,1
+party,treeresponse,1,2,0,...,1
+party,varIDs,-1,0,0,integer[],1
+party,varIDs,0,0,0,list<null | double[] | list<any>>,1
+party,varIDs,0,0,1,list<null | double | list<any>>,1
+party,varimp,-1,0,0,double[],1
+party,varimp,0,0,0,class<`RandomForest`>,1
+party,varimp,1,0,0,double,1
+party,varimp,2,0,0,logical,1
+party,varimp,3,0,0,double,1
+party,varimp,4,0,0,double,1
+party,varimp,5,0,0,logical,1
+party,varimp,6,0,0,any,1
+party,weights.BinaryTree,-1,0,0,list<double[]>,1
+party,weights.BinaryTree,0,0,0,class<`BinaryTree`>,1
+party,weights.BinaryTree,1,0,0,null,1
+party,weights.BinaryTree,2,0,0,...,1
+party,weights.mob,-1,0,0,double[],1
+party,weights.mob,0,0,0,class<`mob`>,1
+party,weights.mob,1,0,0,null,1
+party,weights.mob,2,0,0,...,1
+party,where,-1,0,0,integer[],1
+party,where,0,0,0,class<`BinaryTree`>,1
+party,where,1,0,0,...,1
+party,where,-1,1,0,integer[],1
+party,where,0,1,0,class<`BinaryTree`>,1
+party,where,1,1,0,...,1
+pastecs,abund,-1,0,0,any,1
+pastecs,abund,0,0,0,class<`data.frame`>,1
+pastecs,abund,0,0,1,integer[],1
+pastecs,abund,0,0,2,character,1
+pastecs,abund,1,0,0,double,1
+pastecs,AutoD2,-1,0,0,class<`D2`>,1
+pastecs,AutoD2,0,0,0,"class<`matrix`, `mts`, `ts`>",1
+pastecs,AutoD2,1,0,0,double[],1
+pastecs,AutoD2,2,0,0,double,1
+pastecs,AutoD2,3,0,0,logical,1
+pastecs,AutoD2,4,0,0,logical,1
+pastecs,AutoD2,5,0,0,...,1
+pastecs,buysbal,-1,0,0,class<`matrix`>,1
+pastecs,buysbal,0,0,0,double[],1
+pastecs,buysbal,1,0,0,double[],1
+pastecs,buysbal,2,0,0,double,1
+pastecs,buysbal,3,0,0,character,1
+pastecs,buysbal,4,0,0,character,1
+pastecs,buysbal,5,0,0,character,1
+pastecs,buysbal,6,0,0,logical,1
+pastecs,CenterD2,-1,0,0,class<`D2`>,1
+pastecs,CenterD2,0,0,0,"class<`matrix`, `mts`, `ts`>",1
+pastecs,CenterD2,1,0,0,double,1
+pastecs,CenterD2,2,0,0,logical,1
+pastecs,CenterD2,3,0,0,logical,1
+pastecs,CenterD2,4,0,0,character,1
+pastecs,CenterD2,5,0,0,double,1
+pastecs,CenterD2,6,0,0,logical,1
+pastecs,CenterD2,7,0,0,double,1
+pastecs,CrossD2,-1,0,0,class<`D2`>,1
+pastecs,CrossD2,0,0,0,"class<`matrix`, `mts`, `ts`>",1
+pastecs,CrossD2,1,0,0,"class<`matrix`, `mts`, `ts`>",1
+pastecs,CrossD2,2,0,0,double[],1
+pastecs,CrossD2,3,0,0,double,1
+pastecs,CrossD2,4,0,0,logical,1
+pastecs,CrossD2,5,0,0,logical,1
+pastecs,CrossD2,6,0,0,...,1
+pastecs,daystoyears,-1,0,0,double[],1
+pastecs,daystoyears,0,0,0,double[],1
+pastecs,daystoyears,1,0,0,character,1
+pastecs,daystoyears,1,0,1,null,1
+pastecs,daystoyears,2,0,0,character,1
+pastecs,decaverage,-1,0,0,class<`tsd`>,1
+pastecs,decaverage,0,0,0,class<`ts`>,1
+pastecs,decaverage,1,0,0,character,1
+pastecs,decaverage,2,0,0,double,1
+pastecs,decaverage,3,0,0,double,1
+pastecs,decaverage,4,0,0,double,1
+pastecs,decaverage,5,0,0,character,1
+pastecs,decaverage,6,0,0,null,1
+pastecs,deccensus,-1,0,0,class<`tsd`>,1
+pastecs,deccensus,0,0,0,class<`ts`>,1
+pastecs,deccensus,1,0,0,character,1
+pastecs,deccensus,2,0,0,logical,1
+pastecs,decdiff,-1,0,0,class<`tsd`>,1
+pastecs,decdiff,0,0,0,class<`ts`>,1
+pastecs,decdiff,1,0,0,character,1
+pastecs,decdiff,2,0,0,double,1
+pastecs,decdiff,3,0,0,double,1
+pastecs,decdiff,4,0,0,character,1
+pastecs,decevf,-1,0,0,class<`tsd`>,1
+pastecs,decevf,0,0,0,class<`ts`>,1
+pastecs,decevf,1,0,0,character,1
+pastecs,decevf,2,0,0,double,1
+pastecs,decevf,3,0,0,double,1
+pastecs,decloess,-1,0,0,class<`tsd`>,1
+pastecs,decloess,0,0,0,class<`ts`>,1
+pastecs,decloess,1,0,0,character,1
+pastecs,decloess,2,0,0,double,1
+pastecs,decloess,2,0,1,character,1
+pastecs,decloess,3,0,0,double,1
+pastecs,decloess,4,0,0,null,1
+pastecs,decloess,5,0,0,double,1
+pastecs,decloess,6,0,0,logical,1
+pastecs,decloess,7,0,0,logical,1
+pastecs,decmedian,-1,0,0,class<`tsd`>,1
+pastecs,decmedian,0,0,0,class<`ts`>,1
+pastecs,decmedian,1,0,0,character,1
+pastecs,decmedian,2,0,0,double,1
+pastecs,decmedian,3,0,0,double,1
+pastecs,decmedian,4,0,0,character,1
+pastecs,decreg,-1,0,0,class<`tsd`>,1
+pastecs,decreg,0,0,0,class<`ts`>,1
+pastecs,decreg,1,0,0,double[],1
+pastecs,decreg,2,0,0,character,1
+pastecs,disjoin,-1,0,0,class<`matrix`>,1
+pastecs,disjoin,0,0,0,class<`factor`>,1
+pastecs,disto,-1,0,0,class<`data.frame`>,1
+pastecs,disto,0,0,0,class<`data.frame`>,1
+pastecs,disto,1,0,0,double,1
+pastecs,disto,2,0,0,logical,1
+pastecs,disto,3,0,0,null,1
+pastecs,escouf,-1,0,0,class<`escouf`>,1
+pastecs,escouf,0,0,0,class<`data.frame`>,1
+pastecs,escouf,1,0,0,double,1
+pastecs,escouf,2,0,0,logical,1
+pastecs,extract,-1,0,0,class<`data.frame`>,1
+pastecs,extract,-1,0,1,"class<`matrix`, `mts`, `ts`>",1
+pastecs,extract,-1,0,2,class<`ts`>,1
+pastecs,extract,0,0,0,class<`abund`>,1
+pastecs,extract,0,0,1,class<`escouf`>,1
+pastecs,extract,0,0,2,class<`tsd`>,1
+pastecs,extract,0,0,3,class<`turnogram`>,1
+pastecs,extract,0,0,4,class<`regul`>,1
+pastecs,extract,1,0,0,any,1
+pastecs,extract,2,0,0,...,1
+pastecs,extract.abund,-1,0,0,class<`data.frame`>,1
+pastecs,extract.abund,0,0,0,class<`abund`>,1
+pastecs,extract.abund,1,0,0,any,1
+pastecs,extract.abund,2,0,0,logical,1
+pastecs,extract.abund,3,0,0,...,1
+pastecs,extract.escouf,-1,0,0,class<`data.frame`>,1
+pastecs,extract.escouf,0,0,0,class<`escouf`>,1
+pastecs,extract.escouf,1,0,0,any,1
+pastecs,extract.escouf,2,0,0,double,1
+pastecs,extract.escouf,3,0,0,...,1
+pastecs,extract.regul,-1,0,0,class<`ts`>,1
+pastecs,extract.regul,0,0,0,class<`regul`>,1
+pastecs,extract.regul,1,0,0,any,1
+pastecs,extract.regul,2,0,0,character,1
+pastecs,extract.regul,3,0,0,...,1
+pastecs,extract.tsd,-1,0,0,"class<`matrix`, `mts`, `ts`>",1
+pastecs,extract.tsd,0,0,0,class<`tsd`>,1
+pastecs,extract.tsd,1,0,0,any,1
+pastecs,extract.tsd,2,0,0,integer[],1
+pastecs,extract.tsd,2,0,1,null,1
+pastecs,extract.tsd,3,0,0,character,1
+pastecs,extract.tsd,4,0,0,...,1
+pastecs,extract.turnogram,-1,0,0,class<`ts`>,1
+pastecs,extract.turnogram,0,0,0,class<`turnogram`>,1
+pastecs,extract.turnogram,1,0,0,any,1
+pastecs,extract.turnogram,2,0,0,double,1
+pastecs,extract.turnogram,3,0,0,character,1
+pastecs,extract.turnogram,4,0,0,double,1
+pastecs,extract.turnogram,5,0,0,...,1
+pastecs,first,-1,0,0,double,1
+pastecs,first,-1,0,1,null,1
+pastecs,first,0,0,0,^double[],1
+pastecs,first,1,0,0,logical,1
+pastecs,GetUnitText,-1,0,0,character,1
+pastecs,GetUnitText,0,0,0,"class<`matrix`, `mts`, `ts`>",1
+pastecs,GetUnitText,0,0,1,class<`ts`>,1
+pastecs,is.tseries,-1,0,0,logical,1
+pastecs,is.tseries,0,0,0,"class<`matrix`, `mts`, `ts`>",1
+pastecs,is.tseries,0,0,1,class<`regul`>,1
+pastecs,is.tseries,0,0,2,class<`ts`>,1
+pastecs,is.tseries,0,0,3,double[],1
+pastecs,last,-1,0,0,double,1
+pastecs,last,-1,0,1,null,1
+pastecs,last,0,0,0,^double[],1
+pastecs,last,1,0,0,logical,1
+pastecs,lines.abund,-1,0,0,double[],1
+pastecs,lines.abund,0,0,0,class<`abund`>,1
+pastecs,lines.abund,1,0,0,double,1
+pastecs,lines.abund,2,0,0,logical,1
+pastecs,lines.abund,3,0,0,logical,1
+pastecs,lines.abund,4,0,0,double,1
+pastecs,lines.abund,5,0,0,double,1
+pastecs,lines.abund,6,0,0,...,1
+pastecs,lines.escouf,-1,0,0,double[],1
+pastecs,lines.escouf,0,0,0,class<`escouf`>,1
+pastecs,lines.escouf,1,0,0,double,1
+pastecs,lines.escouf,2,0,0,logical,1
+pastecs,lines.escouf,3,0,0,logical,1
+pastecs,lines.escouf,4,0,0,logical,1
+pastecs,lines.escouf,5,0,0,double,1
+pastecs,lines.escouf,6,0,0,double,1
+pastecs,lines.escouf,7,0,0,...,1
+pastecs,lines.stat.slide,-1,0,0,null,1
+pastecs,lines.stat.slide,0,0,0,class<`stat.slide`>,1
+pastecs,lines.stat.slide,1,0,0,character,1
+pastecs,lines.stat.slide,2,0,0,double,1
+pastecs,lines.stat.slide,3,0,0,double,1
+pastecs,lines.stat.slide,4,0,0,...,1
+pastecs,lines.turnpoints,-1,0,0,null,1
+pastecs,lines.turnpoints,0,0,0,class<`turnpoints`>,1
+pastecs,lines.turnpoints,1,0,0,logical,1
+pastecs,lines.turnpoints,2,0,0,logical,1
+pastecs,lines.turnpoints,3,0,0,logical,1
+pastecs,lines.turnpoints,4,0,0,double[],1
+pastecs,lines.turnpoints,5,0,0,double[],1
+pastecs,lines.turnpoints,6,0,0,...,1
+pastecs,local.trend,-1,0,0,"class<`local.trend`, `ts`>",1
+pastecs,local.trend,0,0,0,double[],1
+pastecs,local.trend,1,0,0,double,1
+pastecs,local.trend,2,0,0,logical,1
+pastecs,local.trend,3,0,0,character,1
+pastecs,local.trend,4,0,0,integer[],1
+pastecs,local.trend,5,0,0,integer[],1
+pastecs,local.trend,6,0,0,character,1
+pastecs,local.trend,7,0,0,character,1
+pastecs,match.tol,-1,0,0,^double[],1
+pastecs,match.tol,0,0,0,double[],1
+pastecs,match.tol,1,0,0,double[],1
+pastecs,match.tol,2,0,0,null,1
+pastecs,match.tol,3,0,0,character,1
+pastecs,match.tol,4,0,0,double,1
+pastecs,pennington,-1,0,0,double[],1
+pastecs,pennington,0,0,0,double[],1
+pastecs,pennington,1,0,0,character,1
+pastecs,pennington,2,0,0,logical,1
+pastecs,pgleissberg,-1,0,0,double[],1
+pastecs,pgleissberg,0,0,0,double[],1
+pastecs,pgleissberg,1,0,0,double[],1
+pastecs,pgleissberg,2,0,0,logical,1
+pastecs,pgleissberg,3,0,0,logical,1
+pastecs,plot.abund,-1,0,0,null,1
+pastecs,plot.abund,0,0,0,class<`abund`>,1
+pastecs,plot.abund,1,0,0,null,1
+pastecs,plot.abund,2,0,0,logical,1
+pastecs,plot.abund,3,0,0,logical,1
+pastecs,plot.abund,4,0,0,double,1
+pastecs,plot.abund,5,0,0,double,1
+pastecs,plot.abund,6,0,0,logical,1
+pastecs,plot.abund,7,0,0,character[],1
+pastecs,plot.escouf,-1,0,0,null,1
+pastecs,plot.escouf,0,0,0,class<`escouf`>,1
+pastecs,plot.escouf,1,0,0,null,1
+pastecs,plot.escouf,2,0,0,logical,1
+pastecs,plot.escouf,3,0,0,logical,1
+pastecs,plot.escouf,4,0,0,logical,1
+pastecs,plot.escouf,5,0,0,double,1
+pastecs,plot.escouf,6,0,0,double,1
+pastecs,plot.escouf,7,0,0,logical,1
+pastecs,plot.regul,-1,0,0,null,1
+pastecs,plot.regul,0,0,0,class<`regul`>,1
+pastecs,plot.regul,1,0,0,double,1
+pastecs,plot.regul,2,0,0,double[],1
+pastecs,plot.regul,3,0,0,character[],1
+pastecs,plot.regul,4,0,0,logical,1
+pastecs,plot.regul,5,0,0,logical,1
+pastecs,plot.regul,6,0,0,any,1
+pastecs,plot.regul,7,0,0,any,1
+pastecs,plot.stat.slide,-1,0,0,null,1
+pastecs,plot.stat.slide,-1,0,1,list<list<double[]>>,1
+pastecs,plot.stat.slide,0,0,0,class<`stat.slide`>,1
+pastecs,plot.stat.slide,1,0,0,character,1
+pastecs,plot.stat.slide,2,0,0,double[],1
+pastecs,plot.stat.slide,3,0,0,character[],1
+pastecs,plot.stat.slide,4,0,0,logical,1
+pastecs,plot.stat.slide,5,0,0,any,1
+pastecs,plot.stat.slide,6,0,0,any,1
+pastecs,plot.stat.slide,7,0,0,character,1
+pastecs,plot.tsd,-1,0,0,null,1
+pastecs,plot.tsd,0,0,0,class<`tsd`>,1
+pastecs,plot.tsd,1,0,0,double,1
+pastecs,plot.tsd,2,0,0,logical,1
+pastecs,plot.tsd,3,0,0,logical,1
+pastecs,plot.tsd,4,0,0,double[],1
+pastecs,plot.tsd,5,0,0,character,1
+pastecs,plot.tsd,6,0,0,character[],1
+pastecs,plot.tsd,7,0,0,logical,1
+pastecs,plot.turnpoints,-1,0,0,null,1
+pastecs,plot.turnpoints,0,0,0,class<`turnpoints`>,1
+pastecs,plot.turnpoints,1,0,0,double,1
+pastecs,plot.turnpoints,2,0,0,logical,1
+pastecs,plot.turnpoints,3,0,0,double,1
+pastecs,plot.turnpoints,4,0,0,double,1
+pastecs,plot.turnpoints,5,0,0,character,1
+pastecs,plot.turnpoints,6,0,0,character,1
+pastecs,plot.turnpoints,7,0,0,character,1
+pastecs,regarea,-1,0,0,list<double[]>,1
+pastecs,regarea,0,0,0,double[],1
+pastecs,regarea,1,0,0,double[],1
+pastecs,regarea,2,0,0,double,1
+pastecs,regarea,3,0,0,double,1
+pastecs,regarea,4,0,0,double,1
+pastecs,regarea,5,0,0,double,1
+pastecs,regarea,6,0,0,double,1
+pastecs,regarea,7,0,0,logical,1
+pastecs,regconst,-1,0,0,list<double[]>,1
+pastecs,regconst,0,0,0,double[],1
+pastecs,regconst,1,0,0,double[],1
+pastecs,regconst,2,0,0,double,1
+pastecs,regconst,3,0,0,double,1
+pastecs,regconst,4,0,0,double,1
+pastecs,regconst,5,0,0,double,1
+pastecs,regconst,6,0,0,double,1
+pastecs,reglin,-1,0,0,list<double[]>,1
+pastecs,reglin,0,0,0,double[],1
+pastecs,reglin,1,0,0,double[],1
+pastecs,reglin,2,0,0,double,1
+pastecs,reglin,3,0,0,double,1
+pastecs,reglin,4,0,0,double,1
+pastecs,reglin,5,0,0,double,1
+pastecs,regspline,-1,0,0,list<double[]>,1
+pastecs,regspline,0,0,0,double[],1
+pastecs,regspline,1,0,0,double[],1
+pastecs,regspline,2,0,0,double,1
+pastecs,regspline,3,0,0,double,1
+pastecs,regspline,4,0,0,double,1
+pastecs,regspline,5,0,0,double,1
+pastecs,regspline,6,0,0,logical,1
+pastecs,regul,-1,0,0,class<`regul`>,1
+pastecs,regul,0,0,0,double[],1
+pastecs,regul,1,0,0,class<`data.frame`>,1
+pastecs,regul,1,0,1,double[],1
+pastecs,regul,2,0,0,double,1
+pastecs,regul,3,0,0,double,1
+pastecs,regul,4,0,0,character,1
+pastecs,regul,5,0,0,double,1
+pastecs,regul,5,0,1,null,1
+pastecs,regul,6,0,0,double,1
+pastecs,regul,7,0,0,character,1
+pastecs,regul,7,0,1,null,1
+pastecs,regul.adj,-1,0,0,list<double[]>,1
+pastecs,regul.adj,0,0,0,double[],1
+pastecs,regul.adj,1,0,0,double,1
+pastecs,regul.adj,2,0,0,null,1
+pastecs,regul.adj,3,0,0,double,1
+pastecs,regul.adj,4,0,0,double,1
+pastecs,regul.adj,5,0,0,character,1
+pastecs,regul.adj,6,0,0,double,1
+pastecs,regul.adj,7,0,0,double[],1
+pastecs,regul.screen,-1,0,0,list<double[] | class<`matrix`>>,1
+pastecs,regul.screen,0,0,0,double[],1
+pastecs,regul.screen,1,0,0,null,1
+pastecs,regul.screen,2,0,0,integer[],1
+pastecs,regul.screen,3,0,0,null,1
+pastecs,regul.screen,4,0,0,integer[],1
+pastecs,regul.screen,5,0,0,double,1
+pastecs,regul.screen,6,0,0,character,1
+pastecs,specs,-1,0,0,class<`specs.regul`>,1
+pastecs,specs,0,0,0,class<`regul`>,1
+pastecs,specs,1,0,0,...,1
+pastecs,specs.regul,-1,0,0,class<`specs.regul`>,1
+pastecs,specs.regul,0,0,0,class<`regul`>,1
+pastecs,specs.regul,1,0,0,...,1
+pastecs,stat.desc,-1,0,0,class<`data.frame`>,1
+pastecs,stat.desc,0,0,0,class<`data.frame`>,1
+pastecs,stat.desc,1,0,0,logical,1
+pastecs,stat.desc,2,0,0,logical,1
+pastecs,stat.desc,3,0,0,logical,1
+pastecs,stat.desc,4,0,0,double,1
+pastecs,stat.pen,-1,0,0,class<`data.frame`>,1
+pastecs,stat.pen,0,0,0,class<`data.frame`>,1
+pastecs,stat.pen,1,0,0,logical,1
+pastecs,stat.pen,2,0,0,logical,1
+pastecs,stat.slide,-1,0,0,class<`stat.slide`>,1
+pastecs,stat.slide,0,0,0,integer[],1
+pastecs,stat.slide,1,0,0,double[],1
+pastecs,stat.slide,2,0,0,double[],1
+pastecs,stat.slide,2,0,1,null,1
+pastecs,stat.slide,3,0,0,any,1
+pastecs,stat.slide,4,0,0,null,1
+pastecs,stat.slide,4,0,1,double,1
+pastecs,stat.slide,5,0,0,null,1
+pastecs,stat.slide,6,0,0,any,1
+pastecs,stat.slide,7,0,0,logical,1
+pastecs,summary.abund,-1,0,0,"class<`abund`, `summary.abund`>",1
+pastecs,summary.abund,0,0,0,class<`abund`>,1
+pastecs,summary.abund,1,0,0,...,1
+pastecs,summary.escouf,-1,0,0,"class<`escouf`, `summary.escouf`>",1
+pastecs,summary.escouf,0,0,0,class<`escouf`>,1
+pastecs,summary.escouf,1,0,0,...,1
+pastecs,summary.turnogram,-1,0,0,"class<`summary.turnogram`, `turnogram`>",1
+pastecs,summary.turnogram,0,0,0,class<`turnogram`>,1
+pastecs,summary.turnogram,1,0,0,...,1
+pastecs,summary.turnpoints,-1,0,0,"class<`summary.turnpoints`, `turnpoints`>",1
+pastecs,summary.turnpoints,0,0,0,class<`turnpoints`>,1
+pastecs,summary.turnpoints,1,0,0,...,1
+pastecs,trend.test,-1,0,0,class<`boot`>,1
+pastecs,trend.test,-1,0,1,class<`htest`>,1
+pastecs,trend.test,0,0,0,double[],1
+pastecs,trend.test,1,0,0,double,1
+pastecs,tsd,-1,0,0,class<`tsd`>,1
+pastecs,tsd,0,0,0,"class<`matrix`, `mts`, `ts`>",1
+pastecs,tsd,1,0,0,null,1
+pastecs,tsd,2,0,0,character,1
+pastecs,tsd,3,0,0,character,1
+pastecs,tsd,4,0,0,double,1
+pastecs,tsd,5,0,0,integer[],1
+pastecs,tsd,6,0,0,double,1
+pastecs,tsd,7,0,0,double,1
+pastecs,tseries,-1,0,0,"class<`matrix`, `mts`, `ts`>",1
+pastecs,tseries,-1,0,1,class<`ts`>,1
+pastecs,tseries,0,0,0,class<`regul`>,1
+pastecs,turnogram,-1,0,0,class<`turnogram`>,1
+pastecs,turnogram,0,0,0,class<`ts`>,1
+pastecs,turnogram,1,0,0,double[],1
+pastecs,turnogram,2,0,0,double,1
+pastecs,turnogram,3,0,0,logical,1
+pastecs,turnogram,4,0,0,logical,1
+pastecs,turnogram,5,0,0,class<`function`>,1
+pastecs,turnogram,6,0,0,logical,1
+pastecs,turnogram,7,0,0,double,1
+pastecs,turnpoints,-1,0,0,class<`turnpoints`>,1
+pastecs,turnpoints,0,0,0,double[],1
+pastecs,turnpoints,1,0,0,logical,1
+pastecs,vario,-1,0,0,class<`data.frame`>,1
+pastecs,vario,0,0,0,double[],1
+pastecs,vario,1,0,0,double,1
+pastecs,vario,2,0,0,logical,1
+pastecs,vario,3,0,0,null,1
+pastecs,yearstodays,-1,0,0,double[],1
+pastecs,yearstodays,0,0,0,double[],1
+pastecs,yearstodays,1,0,0,double,1
+pastecs,yearstodays,1,0,1,null,1
+paws.common,build,-1,0,0,any,1
+paws.common,build,0,0,0,any,1
+paws.common,check_config_file_region,-1,0,0,null,1
+paws.common,check_config_file_region,0,0,0,any,1
+paws.common,check_os_region,-1,0,0,character,1
+paws.common,check_r_env_region,-1,0,0,character,1
+paws.common,client_config,-1,0,0,any,1
+paws.common,client_config,0,0,0,any,1
+paws.common,client_config,1,0,0,any,1
+paws.common,client_config,2,0,0,null,1
+paws.common,Config,-1,0,0,class<`struct`>,1
+paws.common,Config,0,0,0,class<`struct`>,1
+paws.common,Config,1,0,0,character,1
+paws.common,Config,2,0,0,character,1
+paws.common,Config,3,0,0,logical,1
+paws.common,Config,4,0,0,character,1
+paws.common,Config,5,0,0,logical,1
+paws.common,Config,6,0,0,double,1
+paws.common,Config,7,0,0,null,1
+paws.common,Config,8,0,0,logical,1
+paws.common,Config,9,0,0,logical,1
+paws.common,Config,10,0,0,logical,1
+paws.common,Config,11,0,0,logical,1
+paws.common,Config,12,0,0,logical,1
+paws.common,Config,13,0,0,logical,1
+paws.common,Config,14,0,0,logical,1
+paws.common,Config,15,0,0,logical,1
+paws.common,Config,16,0,0,null,1
+paws.common,Config,17,0,0,logical,1
+paws.common,get_aws_path,-1,0,0,character,1
+paws.common,get_os_env_variable,-1,0,0,character,1
+paws.common,get_os_env_variable,0,0,0,character,1
+paws.common,get_region,-1,0,0,any,1
+paws.common,get_region,0,0,0,any,1
+paws.common,Handler,-1,0,0,list<class<`function`> | character>,1
+paws.common,Handler,0,0,0,class<`function`>,1
+paws.common,Handler,1,0,0,character,1
+paws.common,HandlerList,-1,0,0,list<null | list<list<class<`function`> | character>>>,1
+paws.common,HandlerList,0,0,0,...,1
+paws.common,HandlerList,1,0,0,null,1
+paws.common,Handlers,-1,0,0,class<`struct`>,1
+paws.common,Handlers,0,0,0,list<null | list<list<class<`function`> | character>>>,1
+paws.common,Handlers,1,0,0,list<null | list<list<class<`function`> | character>>>,1
+paws.common,Handlers,2,0,0,list<null | list<list<class<`function`> | character>>>,1
+paws.common,Handlers,3,0,0,list<null | list<list<class<`function`> | character>>>,1
+paws.common,Handlers,4,0,0,list<null | list<list<class<`function`> | character>>>,1
+paws.common,Handlers,5,0,0,list<null | list<list<class<`function`> | character>>>,1
+paws.common,Handlers,6,0,0,list<null | list<list<class<`function`> | character>>>,1
+paws.common,Handlers,7,0,0,list<null | list<list<class<`function`> | character>>>,1
+paws.common,Handlers,8,0,0,list<null | list<any>>,1
+paws.common,Handlers,9,0,0,list<null | list<any>>,1
+paws.common,Handlers,10,0,0,list<null | list<any>>,1
+paws.common,is_empty,-1,0,0,logical,1
+paws.common,is_empty,0,0,0,double,1
+paws.common,is_empty,0,0,1,list<any>,1
+paws.common,is_empty,0,0,2,character,1
+paws.common,is_empty,0,0,3,null,1
+paws.common,is_empty.character,-1,0,0,logical,1
+paws.common,is_empty.character,0,0,0,character,1
+paws.common,is_empty.default,-1,0,0,logical,1
+paws.common,is_empty.default,0,0,0,double,1
+paws.common,is_empty.default,0,0,1,null,1
+paws.common,is_empty.list,-1,0,0,logical,1
+paws.common,is_empty.list,0,0,0,list<double>,1
+paws.common,is_empty.list,0,0,1,list<list<any>>,1
+paws.common,new_handlers,-1,0,0,class<`struct`>,1
+paws.common,new_handlers,0,0,0,character,1
+paws.common,new_handlers,1,0,0,character,1
+paws.common,new_operation,-1,0,0,class<`struct`>,1
+paws.common,new_operation,0,0,0,character,1
+paws.common,new_operation,1,0,0,character,1
+paws.common,new_operation,2,0,0,character,1
+paws.common,new_operation,3,0,0,list<any>,1
+paws.common,new_operation,4,0,0,null,1
+paws.common,new_service,-1,0,0,any,1
+paws.common,new_service,0,0,0,any,1
+paws.common,new_service,1,0,0,any,1
+paws.common,new_service,2,0,0,null,1
+paws.common,new_session,-1,0,0,class<`struct`>,1
+paws.common,populate,-1,0,0,character,1
+paws.common,populate,-1,0,1,class<`struct`>,1
+paws.common,populate,-1,0,2,double,1
+paws.common,populate,-1,0,3,list<double>,1
+paws.common,populate,0,0,0,character,1
+paws.common,populate,0,0,1,list<character>,1
+paws.common,populate,0,0,2,list<character | list<list<character>>>,1
+paws.common,populate,0,0,3,list<list<character>>,1
+paws.common,populate,0,0,4,double,1
+paws.common,populate,0,0,5,list<double>,1
+paws.common,populate,1,0,0,character,1
+paws.common,populate,1,0,1,class<`struct`>,1
+paws.common,populate,1,0,2,null,1
+paws.common,populate,1,0,3,list<null>,1
+paws.common,send_request,-1,0,0,any,1
+paws.common,send_request,0,0,0,any,1
+paws.common,Session,-1,0,0,class<`struct`>,1
+paws.common,Session,0,0,0,class<`struct`>,1
+paws.common,Session,1,0,0,class<`struct`>,1
+paws.common,set_config,-1,0,0,list<list<class<`struct`>>>,1
+paws.common,set_config,0,0,0,list<any>,1
+paws.common,set_config,1,0,0,list<character | list<list<character>>>,1
+paws.common,sign,-1,0,0,any,1
+paws.common,sign,0,0,0,any,1
+paws.common,$.struct,-1,0,0,character,1
+paws.common,$.struct,-1,0,1,class<`struct`>,1
+paws.common,$.struct,0,0,0,class<`struct`>,1
+paws.common,$.struct,1,0,0,character,1
+paws.common,tag_add,-1,0,0,character,1
+paws.common,tag_add,-1,0,1,class<`function`>,1
+paws.common,tag_add,-1,0,2,class<`struct`>,1
+paws.common,tag_add,-1,0,3,double,1
+paws.common,tag_add,-1,0,4,list<any>,1
+paws.common,tag_add,-1,0,5,logical[],1
+paws.common,tag_add,0,0,0,character,1
+paws.common,tag_add,0,0,1,class<`function`>,1
+paws.common,tag_add,0,0,2,class<`struct`>,1
+paws.common,tag_add,0,0,3,double,1
+paws.common,tag_add,0,0,4,list<any>,1
+paws.common,tag_add,0,0,5,logical[],1
+paws.common,tag_add,1,0,0,list<character>,1
+paws.common,tag_annotate,-1,0,0,character,1
+paws.common,tag_annotate,-1,0,1,class<`function`>,1
+paws.common,tag_annotate,-1,0,2,class<`struct`>,1
+paws.common,tag_annotate,-1,0,3,double,1
+paws.common,tag_annotate,-1,0,4,list<class<`function`>>,1
+paws.common,tag_annotate,-1,0,5,logical[],1
+paws.common,tag_annotate,0,0,0,character,1
+paws.common,tag_annotate,0,0,1,class<`function`>,1
+paws.common,tag_annotate,0,0,2,class<`struct`>,1
+paws.common,tag_annotate,0,0,3,double,1
+paws.common,tag_annotate,0,0,4,list<class<`function`>>,1
+paws.common,tag_annotate,0,0,5,null,1
+paws.common,tag_del,-1,0,0,list<any>,1
+paws.common,tag_del,0,0,0,list<any>,1
+paws.common,tag_del,1,0,0,null,1
+paws.common,tag_get,-1,0,0,character,1
+paws.common,tag_get,0,0,0,character,1
+paws.common,tag_get,0,0,1,class<`struct`>,1
+paws.common,tag_get,0,0,2,list<any>,1
+paws.common,tag_get,0,0,3,null,1
+paws.common,tag_get,1,0,0,character,1
+paws.common,tag_has,-1,0,0,logical,1
+paws.common,tag_has,0,0,0,list<any>,1
+paws.common,tag_has,1,0,0,character,1
+pbapply,closepb,-1,0,0,null,1
+pbapply,closepb,0,0,0,"class<`timerProgressBar`, `txtProgressBar`>",1
+pbapply,closepb,0,0,1,class<`txtProgressBar`>,1
+pbapply,closepb,0,0,2,null,1
+pbapply,dopb,-1,0,0,logical,1
+pbapply,getTimeAsString,-1,0,0,character,1
+pbapply,getTimeAsString,0,0,0,double,1
+pbapply,getTimeAsString,0,0,1,null,1
+pbapply,pbapply,-1,0,0,class<`array`>,1
+pbapply,pbapply,-1,0,1,class<`matrix`>,1
+pbapply,pbapply,-1,0,2,double[],1
+pbapply,pbapply,-1,0,3,list<class<`table`>>,1
+pbapply,pbapply,-1,0,4,list<integer[]>,1
+pbapply,pbapply,0,0,0,class<`array`>,1
+pbapply,pbapply,0,0,1,class<`matrix`>,1
+pbapply,pbapply,1,0,0,integer[],1
+pbapply,pbapply,1,0,1,double,1
+pbapply,pbapply,2,0,0,class<`function`>,1
+pbapply,pbapply,3,0,0,...,1
+pbapply,pbapply,4,0,0,null,1
+pbapply,pbapply,4,0,1,"class<`SOCKcluster`, `cluster`>",1
+pbapply,pblapply,-1,0,0,list<any>,1
+pbapply,pblapply,0,0,0,character[],1
+pbapply,pblapply,0,0,1,double[],1
+pbapply,pblapply,0,0,2,list<double[]>,1
+pbapply,pblapply,1,0,0,class<`function`>,1
+pbapply,pblapply,2,0,0,...,1
+pbapply,pblapply,3,0,0,any,1
+pbapply,pbmapply,-1,0,0,list<double[]>,1
+pbapply,pbmapply,-1,0,1,list<character>,1
+pbapply,pbmapply,0,0,0,class<`function`>,1
+pbapply,pbmapply,1,0,0,...,1
+pbapply,pbmapply,2,0,0,list<double>,1
+pbapply,pbmapply,2,0,1,null,1
+pbapply,pbmapply,3,0,0,logical,1
+pbapply,pbmapply,4,0,0,logical,1
+pbapply,pboptions,-1,0,0,list<character | double>,1
+pbapply,pboptions,0,0,0,...,1
+pbapply,pbreplicate,-1,0,0,class<`matrix`>,1
+pbapply,pbreplicate,-1,0,1,double[],1
+pbapply,pbreplicate,0,0,0,double,1
+pbapply,pbreplicate,1,0,0,any,1
+pbapply,pbreplicate,2,0,0,character,1
+pbapply,pbreplicate,3,0,0,null,1
+pbapply,pbreplicate,3,0,1,"class<`SOCKcluster`, `cluster`>",1
+pbapply,pbreplicate,3,0,2,integer,1
+pbapply,pbsapply,-1,0,0,class<`array`>,1
+pbapply,pbsapply,-1,0,1,class<`matrix`>,1
+pbapply,pbsapply,-1,0,2,double[],1
+pbapply,pbsapply,-1,0,3,list<any>,1
+pbapply,pbsapply,0,0,0,double[],1
+pbapply,pbsapply,0,0,1,list<double[]>,1
+pbapply,pbsapply,0,0,2,character[],1
+pbapply,pbsapply,1,0,0,class<`function`>,1
+pbapply,pbsapply,2,0,0,...,1
+pbapply,pbsapply,3,0,0,character,1
+pbapply,pbsapply,3,0,1,logical,1
+pbapply,pbsapply,4,0,0,logical,1
+pbapply,pbsapply,5,0,0,null,1
+pbapply,pbsapply,5,0,1,"class<`SOCKcluster`, `cluster`>",1
+pbapply,pbsapply,5,0,2,integer,1
+pbapply,pbtypes,-1,0,0,character[],1
+pbapply,setpb,-1,0,0,double,1
+pbapply,setpb,-1,0,1,null,1
+pbapply,setpb,0,0,0,any,1
+pbapply,setpb,1,0,0,any,1
+pbapply,splitpb,-1,0,0,list<integer[]>,1
+pbapply,splitpb,0,0,0,double,1
+pbapply,splitpb,1,0,0,double,1
+pbapply,splitpb,2,0,0,null,1
+pbapply,splitpb,2,0,1,double,1
+pbapply,startpb,-1,0,0,"class<`timerProgressBar`, `txtProgressBar`>",1
+pbapply,startpb,-1,0,1,class<`txtProgressBar`>,1
+pbapply,startpb,-1,0,2,null,1
+pbapply,startpb,0,0,0,double,1
+pbapply,startpb,1,0,0,any,1
+pbapply,timerProgressBar,-1,0,0,"class<`timerProgressBar`, `txtProgressBar`>",1
+pbapply,timerProgressBar,0,0,0,double,1
+pbapply,timerProgressBar,1,0,0,double,1
+pbapply,timerProgressBar,2,0,0,double,1
+pbapply,timerProgressBar,3,0,0,character,1
+pbapply,timerProgressBar,4,0,0,double,1
+pbapply,timerProgressBar,4,0,1,null,1
+pbapply,timerProgressBar,5,0,0,any,1
+pbapply,timerProgressBar,6,0,0,any,1
+pbapply,timerProgressBar,7,0,0,double,1
+pbapply,timerProgressBar,8,0,0,character,1
+pbapply,timerProgressBar,9,0,0,double,1
+pdist,as.matrix.pdist,-1,0,0,class<`matrix`>,1
+pdist,as.matrix.pdist,0,0,0,class<`pdist`>,1
+pdist,as.matrix.pdist,1,0,0,...,1
+pdist,pdist,-1,0,0,class<`pdist`>,1
+pdist,pdist,0,0,0,class<`matrix`>,1
+pdist,pdist,1,0,0,null,1
+pdist,pdist,2,0,0,integer[],1
+pdist,pdist,3,0,0,integer[],1
+permute,allFree,-1,0,0,class<`matrix`>,1
+permute,allFree,0,0,0,integer,1
+permute,allFree,1,0,0,integer[],1
+permute,allGrid,-1,0,0,class<`matrix`>,1
+permute,allGrid,0,0,0,integer,1
+permute,allGrid,1,0,0,double,1
+permute,allGrid,2,0,0,any,1
+permute,allGrid,3,0,0,double,1
+permute,allGrid,4,0,0,logical,1
+permute,allGrid,5,0,0,any,1
+permute,allPerms,-1,0,0,"class<`allPerms`, `matrix`, `permutationMatrix`>",1
+permute,allPerms,0,0,0,character[],1
+permute,allPerms,0,0,1,double[],1
+permute,allPerms,1,0,0,class<`how`>,1
+permute,allPerms,2,0,0,logical,1
+permute,allSeries,-1,0,0,class<`matrix`>,1
+permute,allSeries,0,0,0,integer,1
+permute,allSeries,1,0,0,double,1
+permute,allSeries,2,0,0,logical,1
+permute,allStrata,-1,0,0,class<`matrix`>,1
+permute,allStrata,0,0,0,integer,1
+permute,allStrata,1,0,0,class<`how`>,1
+permute,as.allPerms,-1,0,0,"class<`allPerms`, `matrix`>",1
+permute,as.allPerms,0,0,0,"class<`allPerms`, `matrix`, `permutationMatrix`>",1
+permute,as.allPerms,1,0,0,class<`how`>,1
+permute,as.matrix.allPerms,-1,0,0,class<`matrix`>,1
+permute,as.matrix.allPerms,0,0,0,"class<`allPerms`, `matrix`, `permutationMatrix`>",1
+permute,as.matrix.allPerms,1,0,0,...,1
+permute,as.matrix.permutationMatrix,-1,0,0,class<`matrix`>,1
+permute,as.matrix.permutationMatrix,0,0,0,"class<`matrix`, `permutationMatrix`>",1
+permute,as.matrix.permutationMatrix,1,0,0,...,1
+permute,Blocks,-1,0,0,list<class<`factor`>>,1
+permute,Blocks,0,0,0,class<`factor`>,1
+permute,cbindAllPerms,-1,0,0,class<`matrix`>,1
+permute,cbindAllPerms,0,0,0,list<class<`matrix`>>,1
+permute,check,-1,0,0,any,1
+permute,check,0,0,0,character[],1
+permute,check,0,0,1,class<`data.frame`>,1
+permute,check,0,0,2,double[],1
+permute,check,1,0,0,class<`how`>,1
+permute,check,2,0,0,any,1
+permute,doAllPerms,-1,0,0,class<`matrix`>,1
+permute,doAllPerms,0,0,0,integer[],1
+permute,doAllPerms,1,0,0,class<`factor`>,1
+permute,doAllPerms,1,0,1,null,1
+permute,doAllPerms,2,0,0,character,1
+permute,doAllPerms,3,0,0,any,1
+permute,doAllPerms,4,0,0,any,1
+permute,doAllPerms,5,0,0,any,1
+permute,doAllPerms,6,0,0,any,1
+permute,doAllPerms,7,0,0,any,1
+permute,doShuffle,-1,0,0,integer[],1
+permute,doShuffle,0,0,0,integer[],1
+permute,doShuffle,1,0,0,class<`how`>,1
+permute,doShuffleSet,-1,0,0,class<`matrix`>,1
+permute,doShuffleSet,0,0,0,integer[],1
+permute,doShuffleSet,1,0,0,double,1
+permute,doShuffleSet,2,0,0,class<`how`>,1
+permute,fixupCall,-1,0,0,class<`how`>,1
+permute,fixupCall,-1,0,1,class<`Plots`>,1
+permute,fixupCall,-1,0,2,class<`Within`>,1
+permute,fixupCall,0,0,0,class<`how`>,1
+permute,fixupCall,0,0,1,class<`Plots`>,1
+permute,fixupCall,0,0,2,class<`Within`>,1
+permute,fixupCall,1,0,0,character,1
+permute,fixupCall,2,0,0,"class<`allPerms`, `matrix`>",1
+permute,fixupCall,2,0,1,class<`call`>,1
+permute,fixupCall,2,0,2,double,1
+permute,fixupCall,2,0,3,null,1
+permute,fixupCall,2,0,4,character,1
+permute,fixupCall,2,0,5,class<`factor`>,1
+permute,getAllperms,-1,0,0,any,1
+permute,getAllperms,0,0,0,class<`how`>,1
+permute,getAllperms,0,0,1,integer[],1
+permute,getAllperms,1,0,0,...,1
+permute,getAllperms.default,-1,0,0,any,1
+permute,getAllperms.default,0,0,0,integer[],1
+permute,getAllperms.default,1,0,0,...,1
+permute,getAllperms.how,-1,0,0,"class<`allPerms`, `matrix`>",1
+permute,getAllperms.how,-1,0,1,null,1
+permute,getAllperms.how,0,0,0,class<`how`>,1
+permute,getAllperms.how,1,0,0,...,1
+permute,getBlocks,-1,0,0,any,1
+permute,getBlocks,0,0,0,class<`how`>,1
+permute,getBlocks,0,0,1,integer[],1
+permute,getBlocks,1,0,0,...,1
+permute,getBlocks.default,-1,0,0,any,1
+permute,getBlocks.default,0,0,0,integer[],1
+permute,getBlocks.default,1,0,0,...,1
+permute,getBlocks.how,-1,0,0,class<`factor`>,1
+permute,getBlocks.how,-1,0,1,null,1
+permute,getBlocks.how,0,0,0,class<`how`>,1
+permute,getBlocks.how,1,0,0,...,1
+permute,getCol,-1,0,0,double,1
+permute,getCol,-1,0,1,null,1
+permute,getCol,0,0,0,class<`how`>,1
+permute,getCol,0,0,1,class<`Plots`>,1
+permute,getCol,0,0,2,class<`Within`>,1
+permute,getCol,1,0,0,...,1
+permute,getCol.how,-1,0,0,double,1
+permute,getCol.how,-1,0,1,null,1
+permute,getCol.how,0,0,0,class<`how`>,1
+permute,getCol.how,1,0,0,character,1
+permute,getCol.how,2,0,0,...,1
+permute,getCol.Plots,-1,0,0,integer,1
+permute,getCol.Plots,0,0,0,class<`Plots`>,1
+permute,getCol.Plots,0,0,1,class<`Within`>,1
+permute,getCol.Plots,1,0,0,...,1
+permute,getCol.Within,-1,0,0,integer,1
+permute,getCol.Within,0,0,0,class<`Plots`>,1
+permute,getCol.Within,0,0,1,class<`Within`>,1
+permute,getCol.Within,1,0,0,...,1
+permute,getComplete,-1,0,0,any,1
+permute,getComplete,0,0,0,integer[],1
+permute,getComplete,0,0,1,class<`how`>,1
+permute,getComplete,1,0,0,...,1
+permute,getComplete.default,-1,0,0,any,1
+permute,getComplete.default,0,0,0,integer[],1
+permute,getComplete.default,1,0,0,...,1
+permute,getComplete.how,-1,0,0,logical,1
+permute,getComplete.how,0,0,0,class<`how`>,1
+permute,getComplete.how,1,0,0,...,1
+permute,getConstant,-1,0,0,any,1
+permute,getConstant,0,0,0,integer[],1
+permute,getConstant,0,0,1,class<`how`>,1
+permute,getConstant,0,0,2,class<`Within`>,1
+permute,getConstant,1,0,0,...,1
+permute,getConstant.default,-1,0,0,any,1
+permute,getConstant.default,0,0,0,integer[],1
+permute,getConstant.default,1,0,0,...,1
+permute,getConstant.how,-1,0,0,logical,1
+permute,getConstant.how,0,0,0,class<`how`>,1
+permute,getConstant.how,1,0,0,...,1
+permute,getConstant.Within,-1,0,0,logical,1
+permute,getConstant.Within,0,0,0,class<`Within`>,1
+permute,getConstant.Within,1,0,0,...,1
+permute,getControl,-1,0,0,any,1
+permute,getControl,0,0,0,"class<`allPerms`, `matrix`, `permutationMatrix`>",1
+permute,getControl,0,0,1,class<`check`>,1
+permute,getControl,0,0,2,integer[],1
+permute,getControl,1,0,0,...,1
+permute,getControl.allPerms,-1,0,0,class<`how`>,1
+permute,getControl.allPerms,0,0,0,"class<`allPerms`, `matrix`, `permutationMatrix`>",1
+permute,getControl.allPerms,1,0,0,...,1
+permute,getControl.default,-1,0,0,any,1
+permute,getControl.default,0,0,0,class<`check`>,1
+permute,getControl.default,0,0,1,integer[],1
+permute,getControl.default,1,0,0,...,1
+permute,getDim,-1,0,0,double[],1
+permute,getDim,-1,0,1,null,1
+permute,getDim,0,0,0,class<`how`>,1
+permute,getDim,0,0,1,class<`Plots`>,1
+permute,getDim,0,0,2,class<`Within`>,1
+permute,getDim,1,0,0,...,1
+permute,getDim.how,-1,0,0,double[],1
+permute,getDim.how,-1,0,1,null,1
+permute,getDim.how,0,0,0,class<`how`>,1
+permute,getDim.how,1,0,0,character,1
+permute,getDim.how,2,0,0,...,1
+permute,getDim.Plots,-1,0,0,integer[],1
+permute,getDim.Plots,0,0,0,class<`Plots`>,1
+permute,getDim.Plots,0,0,1,class<`Within`>,1
+permute,getDim.Plots,1,0,0,...,1
+permute,getDim.Within,-1,0,0,integer[],1
+permute,getDim.Within,0,0,0,class<`Plots`>,1
+permute,getDim.Within,0,0,1,class<`Within`>,1
+permute,getDim.Within,1,0,0,...,1
+permute,getHow,-1,0,0,any,1
+permute,getHow,0,0,0,"class<`allPerms`, `matrix`, `permutationMatrix`>",1
+permute,getHow,0,0,1,class<`check`>,1
+permute,getHow,0,0,2,integer[],1
+permute,getHow,1,0,0,...,1
+permute,getMake,-1,0,0,any,1
+permute,getMake,0,0,0,integer[],1
+permute,getMake,0,0,1,class<`how`>,1
+permute,getMake,1,0,0,...,1
+permute,getMake.default,-1,0,0,any,1
+permute,getMake.default,0,0,0,integer[],1
+permute,getMake.default,1,0,0,...,1
+permute,getMake.how,-1,0,0,logical,1
+permute,getMake.how,0,0,0,class<`how`>,1
+permute,getMake.how,1,0,0,...,1
+permute,getMaxperm,-1,0,0,any,1
+permute,getMaxperm,0,0,0,class<`how`>,1
+permute,getMaxperm,0,0,1,integer[],1
+permute,getMaxperm,1,0,0,...,1
+permute,getMaxperm.default,-1,0,0,any,1
+permute,getMaxperm.default,0,0,0,integer[],1
+permute,getMaxperm.default,1,0,0,...,1
+permute,getMaxperm.how,-1,0,0,double,1
+permute,getMaxperm.how,0,0,0,class<`how`>,1
+permute,getMaxperm.how,1,0,0,...,1
+permute,getMinperm,-1,0,0,any,1
+permute,getMinperm,0,0,0,class<`how`>,1
+permute,getMinperm,0,0,1,integer[],1
+permute,getMinperm,1,0,0,...,1
+permute,getMinperm.default,-1,0,0,any,1
+permute,getMinperm.default,0,0,0,integer[],1
+permute,getMinperm.default,1,0,0,...,1
+permute,getMinperm.how,-1,0,0,double,1
+permute,getMinperm.how,0,0,0,class<`how`>,1
+permute,getMinperm.how,1,0,0,...,1
+permute,getMirror,-1,0,0,any,1
+permute,getMirror,0,0,0,integer[],1
+permute,getMirror,0,0,1,class<`how`>,1
+permute,getMirror,0,0,2,class<`Plots`>,1
+permute,getMirror,0,0,3,class<`Within`>,1
+permute,getMirror,1,0,0,...,1
+permute,getMirror.default,-1,0,0,any,1
+permute,getMirror.default,0,0,0,integer[],1
+permute,getMirror.default,1,0,0,...,1
+permute,getMirror.how,-1,0,0,logical,1
+permute,getMirror.how,0,0,0,class<`how`>,1
+permute,getMirror.how,1,0,0,character,1
+permute,getMirror.how,2,0,0,...,1
+permute,getMirror.Plots,-1,0,0,logical,1
+permute,getMirror.Plots,0,0,0,class<`Plots`>,1
+permute,getMirror.Plots,0,0,1,class<`Within`>,1
+permute,getMirror.Plots,1,0,0,...,1
+permute,getMirror.Within,-1,0,0,logical,1
+permute,getMirror.Within,0,0,0,class<`Plots`>,1
+permute,getMirror.Within,0,0,1,class<`Within`>,1
+permute,getMirror.Within,1,0,0,...,1
+permute,getNperm,-1,0,0,any,1
+permute,getNperm,0,0,0,class<`how`>,1
+permute,getNperm,0,0,1,integer[],1
+permute,getNperm,1,0,0,...,1
+permute,getNperm.default,-1,0,0,any,1
+permute,getNperm.default,0,0,0,integer[],1
+permute,getNperm.default,1,0,0,...,1
+permute,getNperm.how,-1,0,0,double,1
+permute,getNperm.how,0,0,0,class<`how`>,1
+permute,getNperm.how,1,0,0,...,1
+permute,getObserved,-1,0,0,any,1
+permute,getObserved,0,0,0,integer[],1
+permute,getObserved,0,0,1,class<`how`>,1
+permute,getObserved,1,0,0,...,1
+permute,getObserved.default,-1,0,0,any,1
+permute,getObserved.default,0,0,0,integer[],1
+permute,getObserved.default,1,0,0,...,1
+permute,getObserved.how,-1,0,0,logical,1
+permute,getObserved.how,0,0,0,class<`how`>,1
+permute,getObserved.how,1,0,0,...,1
+permute,getPlots,-1,0,0,any,1
+permute,getPlots,0,0,0,class<`how`>,1
+permute,getPlots,0,0,1,integer[],1
+permute,getPlots,1,0,0,...,1
+permute,getPlots.default,-1,0,0,any,1
+permute,getPlots.default,0,0,0,integer[],1
+permute,getPlots.default,1,0,0,...,1
+permute,getPlots.how,-1,0,0,class<`Plots`>,1
+permute,getPlots.how,0,0,0,class<`how`>,1
+permute,getPlots.how,1,0,0,...,1
+permute,getRow,-1,0,0,double,1
+permute,getRow,-1,0,1,null,1
+permute,getRow,0,0,0,class<`how`>,1
+permute,getRow,0,0,1,class<`Plots`>,1
+permute,getRow,0,0,2,class<`Within`>,1
+permute,getRow,1,0,0,...,1
+permute,getRow.how,-1,0,0,double,1
+permute,getRow.how,-1,0,1,null,1
+permute,getRow.how,0,0,0,class<`how`>,1
+permute,getRow.how,1,0,0,character,1
+permute,getRow.how,2,0,0,...,1
+permute,getRow.Plots,-1,0,0,integer,1
+permute,getRow.Plots,0,0,0,class<`Plots`>,1
+permute,getRow.Plots,0,0,1,class<`Within`>,1
+permute,getRow.Plots,1,0,0,...,1
+permute,getRow.Within,-1,0,0,integer,1
+permute,getRow.Within,0,0,0,class<`Plots`>,1
+permute,getRow.Within,0,0,1,class<`Within`>,1
+permute,getRow.Within,1,0,0,...,1
+permute,getStrata,-1,0,0,any,1
+permute,getStrata,0,0,0,class<`how`>,1
+permute,getStrata,0,0,1,class<`Plots`>,1
+permute,getStrata,0,0,2,integer[],1
+permute,getStrata,1,0,0,...,1
+permute,getStrata.default,-1,0,0,any,1
+permute,getStrata.default,0,0,0,integer[],1
+permute,getStrata.default,1,0,0,...,1
+permute,getStrata.how,-1,0,0,class<`factor`>,1
+permute,getStrata.how,-1,0,1,null,1
+permute,getStrata.how,0,0,0,class<`how`>,1
+permute,getStrata.how,1,0,0,character[],1
+permute,getStrata.how,2,0,0,logical,1
+permute,getStrata.how,3,0,0,...,1
+permute,getStrata.Plots,-1,0,0,class<`factor`>,1
+permute,getStrata.Plots,0,0,0,class<`Plots`>,1
+permute,getStrata.Plots,1,0,0,logical,1
+permute,getStrata.Plots,2,0,0,...,1
+permute,getType,-1,0,0,any,1
+permute,getType,0,0,0,class<`how`>,1
+permute,getType,0,0,1,class<`Plots`>,1
+permute,getType,0,0,2,class<`Within`>,1
+permute,getType,0,0,3,integer[],1
+permute,getType,1,0,0,...,1
+permute,getType.default,-1,0,0,any,1
+permute,getType.default,0,0,0,integer[],1
+permute,getType.default,1,0,0,...,1
+permute,getType.how,-1,0,0,character,1
+permute,getType.how,0,0,0,class<`how`>,1
+permute,getType.how,1,0,0,character,1
+permute,getType.how,2,0,0,...,1
+permute,getType.Plots,-1,0,0,character,1
+permute,getType.Plots,0,0,0,class<`Plots`>,1
+permute,getType.Plots,0,0,1,class<`Within`>,1
+permute,getType.Plots,1,0,0,...,1
+permute,getType.Within,-1,0,0,character,1
+permute,getType.Within,0,0,0,class<`Plots`>,1
+permute,getType.Within,0,0,1,class<`Within`>,1
+permute,getType.Within,1,0,0,...,1
+permute,getWithin,-1,0,0,any,1
+permute,getWithin,0,0,0,class<`how`>,1
+permute,getWithin,0,0,1,integer[],1
+permute,getWithin,1,0,0,...,1
+permute,getWithin.default,-1,0,0,any,1
+permute,getWithin.default,0,0,0,integer[],1
+permute,getWithin.default,1,0,0,...,1
+permute,getWithin.how,-1,0,0,class<`Within`>,1
+permute,getWithin.how,0,0,0,class<`how`>,1
+permute,getWithin.how,1,0,0,...,1
+permute,how,-1,0,0,class<`how`>,1
+permute,how,0,0,0,class<`Within`>,1
+permute,how,1,0,0,class<`Plots`>,1
+permute,how,2,0,0,class<`factor`>,1
+permute,how,2,0,1,null,1
+permute,how,3,0,0,double,1
+permute,how,4,0,0,logical,1
+permute,how,5,0,0,double,1
+permute,how,6,0,0,double,1
+permute,how,7,0,0,null,1
+permute,nobs.character,-1,0,0,integer,1
+permute,nobs.character,0,0,0,character[],1
+permute,nobs.character,0,0,1,class<`factor`>,1
+permute,nobs.character,0,0,2,double[],1
+permute,nobs.character,1,0,0,...,1
+permute,nobs.data.frame,-1,0,0,integer,1
+permute,nobs.data.frame,0,0,0,class<`data.frame`>,1
+permute,nobs.data.frame,0,0,1,class<`matrix`>,1
+permute,nobs.data.frame,1,0,0,...,1
+permute,nobs.factor,-1,0,0,integer,1
+permute,nobs.factor,0,0,0,character[],1
+permute,nobs.factor,0,0,1,class<`factor`>,1
+permute,nobs.factor,0,0,2,double[],1
+permute,nobs.factor,1,0,0,...,1
+permute,nobs.integer,-1,0,0,integer,1
+permute,nobs.integer,0,0,0,integer[],1
+permute,nobs.integer,1,0,0,...,1
+permute,nobs.matrix,-1,0,0,integer,1
+permute,nobs.matrix,0,0,0,class<`data.frame`>,1
+permute,nobs.matrix,0,0,1,class<`matrix`>,1
+permute,nobs.matrix,1,0,0,...,1
+permute,nobs.numeric,-1,0,0,integer,1
+permute,nobs.numeric,0,0,0,character[],1
+permute,nobs.numeric,0,0,1,class<`factor`>,1
+permute,nobs.numeric,0,0,2,double[],1
+permute,nobs.numeric,1,0,0,...,1
+permute,numPerms,-1,0,0,double,1
+permute,numPerms,0,0,0,character[],1
+permute,numPerms,0,0,1,class<`data.frame`>,1
+permute,numPerms,0,0,2,double[],1
+permute,numPerms,1,0,0,class<`how`>,1
+permute,permute,-1,0,0,integer[],1
+permute,permute,0,0,0,any,1
+permute,permute,1,0,0,any,1
+permute,permute,2,0,0,class<`how`>,1
+permute,Plots,-1,0,0,class<`Plots`>,1
+permute,Plots,0,0,0,class<`factor`>,1
+permute,Plots,0,0,1,integer[],1
+permute,Plots,0,0,2,null,1
+permute,Plots,1,0,0,character[],1
+permute,Plots,2,0,0,logical,1
+permute,Plots,3,0,0,null,1
+permute,Plots,3,0,1,double,1
+permute,Plots,4,0,0,null,1
+permute,Plots,4,0,1,double,1
+permute,print.how,-1,0,0,null,1
+permute,print.how,0,0,0,class<`how`>,1
+permute,print.how,1,0,0,...,1
+permute,print.permutationMatrix,-1,0,0,class<`matrix`>,1
+permute,print.permutationMatrix,0,0,0,"class<`matrix`, `permutationMatrix`>",1
+permute,print.permutationMatrix,1,0,0,...,1
+permute,print.summary.allPerms,-1,0,0,class<`matrix`>,1
+permute,print.summary.allPerms,0,0,0,class<`summary.allPerms`>,1
+permute,print.summary.allPerms,1,0,0,...,1
+permute,setAllperms<-,-1,0,0,any,1
+permute,setAllperms<-,0,0,0,class<`how`>,1
+permute,setAllperms<-,0,0,1,integer[],1
+permute,setAllperms<-,1,0,0,"class<`allPerms`, `matrix`, `permutationMatrix`>",1
+permute,setAllperms<-,1,0,1,integer[],1
+permute,setAllperms<-.default,-1,0,0,any,1
+permute,setAllperms<-.default,0,0,0,integer[],1
+permute,setAllperms<-.default,1,0,0,integer[],1
+permute,setAllperms<-.how,-1,0,0,class<`how`>,1
+permute,setAllperms<-.how,0,0,0,class<`how`>,1
+permute,setAllperms<-.how,1,0,0,"class<`allPerms`, `matrix`, `permutationMatrix`>",1
+permute,setBlocks<-,-1,0,0,any,1
+permute,setBlocks<-,0,0,0,class<`how`>,1
+permute,setBlocks<-,0,0,1,integer[],1
+permute,setBlocks<-,1,0,0,null,1
+permute,setBlocks<-,1,0,1,logical,1
+permute,setBlocks<-.default,-1,0,0,any,1
+permute,setBlocks<-.default,0,0,0,integer[],1
+permute,setBlocks<-.default,1,0,0,logical,1
+permute,setBlocks<-.how,-1,0,0,class<`how`>,1
+permute,setBlocks<-.how,0,0,0,class<`how`>,1
+permute,setBlocks<-.how,1,0,0,null,1
+permute,setCol<-,-1,0,0,any,1
+permute,setCol<-,0,0,0,class<`Plots`>,1
+permute,setCol<-,0,0,1,class<`Within`>,1
+permute,setCol<-,0,0,2,class<`how`>,1
+permute,setCol<-,0,0,3,integer[],1
+permute,setCol<-,1,0,0,double,1
+permute,setCol<-.default,-1,0,0,any,1
+permute,setCol<-.default,0,0,0,integer[],1
+permute,setCol<-.default,1,0,0,double,1
+permute,setCol<-.how,-1,0,0,any,1
+permute,setCol<-.how,0,0,0,class<`how`>,1
+permute,setCol<-.how,1,0,0,double,1
+permute,setCol<-.Plots,-1,0,0,class<`Plots`>,1
+permute,setCol<-.Plots,-1,0,1,class<`Within`>,1
+permute,setCol<-.Plots,0,0,0,class<`Plots`>,1
+permute,setCol<-.Plots,0,0,1,class<`Within`>,1
+permute,setCol<-.Plots,1,0,0,double,1
+permute,setCol<-.Within,-1,0,0,class<`Plots`>,1
+permute,setCol<-.Within,-1,0,1,class<`Within`>,1
+permute,setCol<-.Within,0,0,0,class<`Plots`>,1
+permute,setCol<-.Within,0,0,1,class<`Within`>,1
+permute,setCol<-.Within,1,0,0,double,1
+permute,setComplete<-,-1,0,0,any,1
+permute,setComplete<-,0,0,0,class<`how`>,1
+permute,setComplete<-,0,0,1,integer[],1
+permute,setComplete<-,1,0,0,logical,1
+permute,setComplete<-.default,-1,0,0,any,1
+permute,setComplete<-.default,0,0,0,integer[],1
+permute,setComplete<-.default,1,0,0,logical,1
+permute,setComplete<-.how,-1,0,0,class<`how`>,1
+permute,setComplete<-.how,0,0,0,class<`how`>,1
+permute,setComplete<-.how,1,0,0,logical,1
+permute,setConstant<-,-1,0,0,any,1
+permute,setConstant<-,0,0,0,class<`Within`>,1
+permute,setConstant<-,0,0,1,class<`how`>,1
+permute,setConstant<-,0,0,2,class<`Plots`>,1
+permute,setConstant<-,0,0,3,integer[],1
+permute,setConstant<-,1,0,0,logical,1
+permute,setConstant<-,1,0,1,character,1
+permute,setConstant<-.default,-1,0,0,any,1
+permute,setConstant<-.default,0,0,0,integer[],1
+permute,setConstant<-.default,1,0,0,character,1
+permute,setConstant<-.how,-1,0,0,any,1
+permute,setConstant<-.how,0,0,0,class<`how`>,1
+permute,setConstant<-.how,1,0,0,logical,1
+permute,setConstant<-.Plots,-1,0,0,any,1
+permute,setConstant<-.Plots,0,0,0,class<`Plots`>,1
+permute,setConstant<-.Plots,1,0,0,logical,1
+permute,setConstant<-.Within,-1,0,0,class<`Within`>,1
+permute,setConstant<-.Within,0,0,0,class<`Within`>,1
+permute,setConstant<-.Within,1,0,0,logical,1
+permute,setDim<-,-1,0,0,any,1
+permute,setDim<-,0,0,0,class<`Plots`>,1
+permute,setDim<-,0,0,1,class<`Within`>,1
+permute,setDim<-,0,0,2,class<`how`>,1
+permute,setDim<-,0,0,3,integer[],1
+permute,setDim<-,1,0,0,double[],1
+permute,setDim<-.default,-1,0,0,any,1
+permute,setDim<-.default,0,0,0,integer[],1
+permute,setDim<-.default,1,0,0,double[],1
+permute,setDim<-.how,-1,0,0,any,1
+permute,setDim<-.how,0,0,0,class<`how`>,1
+permute,setDim<-.how,1,0,0,double[],1
+permute,setDim<-.Plots,-1,0,0,class<`Plots`>,1
+permute,setDim<-.Plots,-1,0,1,class<`Within`>,1
+permute,setDim<-.Plots,0,0,0,class<`Plots`>,1
+permute,setDim<-.Plots,0,0,1,class<`Within`>,1
+permute,setDim<-.Plots,1,0,0,double[],1
+permute,setDim<-.Within,-1,0,0,class<`Plots`>,1
+permute,setDim<-.Within,-1,0,1,class<`Within`>,1
+permute,setDim<-.Within,0,0,0,class<`Plots`>,1
+permute,setDim<-.Within,0,0,1,class<`Within`>,1
+permute,setDim<-.Within,1,0,0,double[],1
+permute,setMake<-,-1,0,0,any,1
+permute,setMake<-,0,0,0,class<`how`>,1
+permute,setMake<-,0,0,1,integer[],1
+permute,setMake<-,1,0,0,logical,1
+permute,setMake<-.default,-1,0,0,any,1
+permute,setMake<-.default,0,0,0,integer[],1
+permute,setMake<-.default,1,0,0,logical,1
+permute,setMake<-.how,-1,0,0,class<`how`>,1
+permute,setMake<-.how,0,0,0,class<`how`>,1
+permute,setMake<-.how,1,0,0,logical,1
+permute,setMaxperm<-,-1,0,0,any,1
+permute,setMaxperm<-,0,0,0,class<`how`>,1
+permute,setMaxperm<-,0,0,1,integer[],1
+permute,setMaxperm<-,1,0,0,double,1
+permute,setMaxperm<-.default,-1,0,0,any,1
+permute,setMaxperm<-.default,0,0,0,integer[],1
+permute,setMaxperm<-.default,1,0,0,double,1
+permute,setMaxperm<-.how,-1,0,0,class<`how`>,1
+permute,setMaxperm<-.how,0,0,0,class<`how`>,1
+permute,setMaxperm<-.how,1,0,0,double,1
+permute,setMinperm<-,-1,0,0,any,1
+permute,setMinperm<-,0,0,0,class<`how`>,1
+permute,setMinperm<-,0,0,1,integer[],1
+permute,setMinperm<-,1,0,0,double,1
+permute,setMinperm<-.default,-1,0,0,any,1
+permute,setMinperm<-.default,0,0,0,integer[],1
+permute,setMinperm<-.default,1,0,0,double,1
+permute,setMinperm<-.how,-1,0,0,class<`how`>,1
+permute,setMinperm<-.how,0,0,0,class<`how`>,1
+permute,setMinperm<-.how,1,0,0,double,1
+permute,setMirror<-,-1,0,0,any,1
+permute,setMirror<-,0,0,0,class<`Plots`>,1
+permute,setMirror<-,0,0,1,class<`Within`>,1
+permute,setMirror<-,0,0,2,class<`how`>,1
+permute,setMirror<-,0,0,3,integer[],1
+permute,setMirror<-,1,0,0,logical,1
+permute,setMirror<-.default,-1,0,0,any,1
+permute,setMirror<-.default,0,0,0,integer[],1
+permute,setMirror<-.default,1,0,0,logical,1
+permute,setMirror<-.how,-1,0,0,any,1
+permute,setMirror<-.how,0,0,0,class<`how`>,1
+permute,setMirror<-.how,1,0,0,logical,1
+permute,setMirror<-.Plots,-1,0,0,class<`Plots`>,1
+permute,setMirror<-.Plots,-1,0,1,class<`Within`>,1
+permute,setMirror<-.Plots,0,0,0,class<`Plots`>,1
+permute,setMirror<-.Plots,0,0,1,class<`Within`>,1
+permute,setMirror<-.Plots,1,0,0,logical,1
+permute,setMirror<-.Within,-1,0,0,class<`Plots`>,1
+permute,setMirror<-.Within,-1,0,1,class<`Within`>,1
+permute,setMirror<-.Within,0,0,0,class<`Plots`>,1
+permute,setMirror<-.Within,0,0,1,class<`Within`>,1
+permute,setMirror<-.Within,1,0,0,logical,1
+permute,setNperm<-,-1,0,0,any,1
+permute,setNperm<-,0,0,0,class<`how`>,1
+permute,setNperm<-,0,0,1,integer[],1
+permute,setNperm<-,1,0,0,double,1
+permute,setNperm<-.default,-1,0,0,any,1
+permute,setNperm<-.default,0,0,0,integer[],1
+permute,setNperm<-.default,1,0,0,double,1
+permute,setNperm<-.how,-1,0,0,class<`how`>,1
+permute,setNperm<-.how,0,0,0,class<`how`>,1
+permute,setNperm<-.how,1,0,0,double,1
+permute,setObserved<-,-1,0,0,any,1
+permute,setObserved<-,0,0,0,class<`how`>,1
+permute,setObserved<-,0,0,1,integer[],1
+permute,setObserved<-,1,0,0,logical,1
+permute,setObserved<-.default,-1,0,0,any,1
+permute,setObserved<-.default,0,0,0,integer[],1
+permute,setObserved<-.default,1,0,0,logical,1
+permute,setObserved<-.how,-1,0,0,class<`how`>,1
+permute,setObserved<-.how,0,0,0,class<`how`>,1
+permute,setObserved<-.how,1,0,0,logical,1
+permute,setPlots<-,-1,0,0,any,1
+permute,setPlots<-,0,0,0,class<`how`>,1
+permute,setPlots<-,0,0,1,integer[],1
+permute,setPlots<-,1,0,0,class<`Plots`>,1
+permute,setPlots<-.default,-1,0,0,any,1
+permute,setPlots<-.default,0,0,0,integer[],1
+permute,setPlots<-.default,1,0,0,class<`Plots`>,1
+permute,setPlots<-.how,-1,0,0,class<`how`>,1
+permute,setPlots<-.how,0,0,0,class<`how`>,1
+permute,setPlots<-.how,1,0,0,class<`Plots`>,1
+permute,setRow<-,-1,0,0,any,1
+permute,setRow<-,0,0,0,class<`Plots`>,1
+permute,setRow<-,0,0,1,class<`Within`>,1
+permute,setRow<-,0,0,2,class<`how`>,1
+permute,setRow<-,0,0,3,integer[],1
+permute,setRow<-,1,0,0,double,1
+permute,setRow<-.default,-1,0,0,any,1
+permute,setRow<-.default,0,0,0,integer[],1
+permute,setRow<-.default,1,0,0,double,1
+permute,setRow<-.how,-1,0,0,any,1
+permute,setRow<-.how,0,0,0,class<`how`>,1
+permute,setRow<-.how,1,0,0,double,1
+permute,setRow<-.Plots,-1,0,0,class<`Plots`>,1
+permute,setRow<-.Plots,-1,0,1,class<`Within`>,1
+permute,setRow<-.Plots,0,0,0,class<`Plots`>,1
+permute,setRow<-.Plots,0,0,1,class<`Within`>,1
+permute,setRow<-.Plots,1,0,0,double,1
+permute,setRow<-.Within,-1,0,0,class<`Plots`>,1
+permute,setRow<-.Within,-1,0,1,class<`Within`>,1
+permute,setRow<-.Within,0,0,0,class<`Plots`>,1
+permute,setRow<-.Within,0,0,1,class<`Within`>,1
+permute,setRow<-.Within,1,0,0,double,1
+permute,setStrata<-,-1,0,0,any,1
+permute,setStrata<-,0,0,0,class<`how`>,1
+permute,setStrata<-,0,0,1,class<`Plots`>,1
+permute,setStrata<-,0,0,2,integer[],1
+permute,setStrata<-,1,0,0,class<`factor`>,1
+permute,setStrata<-.default,-1,0,0,any,1
+permute,setStrata<-.default,0,0,0,integer[],1
+permute,setStrata<-.default,1,0,0,class<`factor`>,1
+permute,setStrata<-.how,-1,0,0,class<`how`>,1
+permute,setStrata<-.how,0,0,0,class<`how`>,1
+permute,setStrata<-.how,1,0,0,class<`factor`>,1
+permute,setStrata<-.Plots,-1,0,0,class<`Plots`>,1
+permute,setStrata<-.Plots,0,0,0,class<`Plots`>,1
+permute,setStrata<-.Plots,1,0,0,class<`factor`>,1
+permute,setType<-,-1,0,0,any,1
+permute,setType<-,0,0,0,class<`Plots`>,1
+permute,setType<-,0,0,1,class<`Within`>,1
+permute,setType<-,0,0,2,class<`how`>,1
+permute,setType<-,0,0,3,integer[],1
+permute,setType<-,1,0,0,character,1
+permute,setType<-.default,-1,0,0,any,1
+permute,setType<-.default,0,0,0,integer[],1
+permute,setType<-.default,1,0,0,character,1
+permute,setType<-.how,-1,0,0,any,1
+permute,setType<-.how,0,0,0,class<`how`>,1
+permute,setType<-.how,1,0,0,character,1
+permute,setType<-.Plots,-1,0,0,any,1
+permute,setType<-.Plots,0,0,0,class<`Plots`>,1
+permute,setType<-.Plots,0,0,1,class<`Within`>,1
+permute,setType<-.Plots,1,0,0,character,1
+permute,setType<-.Within,-1,0,0,any,1
+permute,setType<-.Within,0,0,0,class<`Plots`>,1
+permute,setType<-.Within,0,0,1,class<`Within`>,1
+permute,setType<-.Within,1,0,0,character,1
+permute,setWithin<-,-1,0,0,any,1
+permute,setWithin<-,0,0,0,class<`how`>,1
+permute,setWithin<-,0,0,1,integer[],1
+permute,setWithin<-,1,0,0,class<`Within`>,1
+permute,setWithin<-.default,-1,0,0,any,1
+permute,setWithin<-.default,0,0,0,integer[],1
+permute,setWithin<-.default,1,0,0,class<`Within`>,1
+permute,setWithin<-.how,-1,0,0,class<`how`>,1
+permute,setWithin<-.how,0,0,0,class<`how`>,1
+permute,setWithin<-.how,1,0,0,class<`Within`>,1
+permute,shuffle,-1,0,0,integer[],1
+permute,shuffle,0,0,0,character[],1
+permute,shuffle,0,0,1,class<`data.frame`>,1
+permute,shuffle,0,0,2,class<`factor`>,1
+permute,shuffle,0,0,3,class<`matrix`>,1
+permute,shuffle,0,0,4,double,1
+permute,shuffle,0,0,5,integer[],1
+permute,shuffle,1,0,0,class<`how`>,1
+permute,shuffleFree,-1,0,0,integer[],1
+permute,shuffleFree,0,0,0,double,1
+permute,shuffleFree,0,0,1,integer[],1
+permute,shuffleFree,1,0,0,double,1
+permute,shuffleGrid,-1,0,0,double[],1
+permute,shuffleGrid,0,0,0,double,1
+permute,shuffleGrid,1,0,0,double,1
+permute,shuffleGrid,2,0,0,logical,1
+permute,shuffleGrid,3,0,0,double,1
+permute,shuffleGrid,3,0,1,null,1
+permute,shuffleGrid,4,0,0,double,1
+permute,shuffleGrid,4,0,1,null,1
+permute,shuffleGrid,5,0,0,null,1
+permute,shuffleGrid,5,0,1,logical[],1
+permute,shuffleNoStrata,-1,0,0,double[],1
+permute,shuffleNoStrata,0,0,0,any,1
+permute,shuffleNoStrata,1,0,0,class<`how`>,1
+permute,shuffleSeries,-1,0,0,integer[],1
+permute,shuffleSeries,0,0,0,integer[],1
+permute,shuffleSeries,1,0,0,logical,1
+permute,shuffleSeries,2,0,0,integer,1
+permute,shuffleSeries,2,0,1,null,1
+permute,shuffleSeries,3,0,0,logical,1
+permute,shuffleSeries,3,0,1,null,1
+permute,shuffleSet,-1,0,0,"class<`matrix`, `permutationMatrix`>",1
+permute,shuffleSet,0,0,0,double,1
+permute,shuffleSet,0,0,1,character[],1
+permute,shuffleSet,0,0,2,class<`data.frame`>,1
+permute,shuffleSet,0,0,3,class<`factor`>,1
+permute,shuffleSet,0,0,4,class<`matrix`>,1
+permute,shuffleSet,0,0,5,integer[],1
+permute,shuffleSet,1,0,0,any,1
+permute,shuffleSet,2,0,0,class<`how`>,1
+permute,shuffleSet,3,0,0,logical,1
+permute,shuffleSet,4,0,0,logical,1
+permute,shuffleStrata,-1,0,0,any,1
+permute,shuffleStrata,0,0,0,class<`factor`>,1
+permute,shuffleStrata,1,0,0,character,1
+permute,shuffleStrata,2,0,0,any,1
+permute,shuffleStrata,3,0,0,null,1
+permute,shuffleStrata,4,0,0,any,1
+permute,shuffleStrata,5,0,0,any,1
+permute,shuffleStrata,6,0,0,any,1
+permute,shuffleStrata,7,0,0,null,1
+permute,summary.allPerms,-1,0,0,class<`summary.allPerms`>,1
+permute,summary.allPerms,0,0,0,"class<`allPerms`, `matrix`, `permutationMatrix`>",1
+permute,summary.allPerms,1,0,0,...,1
+permute,update.how,-1,0,0,class<`how`>,1
+permute,update.how,0,0,0,class<`how`>,1
+permute,update.how,1,0,0,...,1
+permute,update.how,2,0,0,logical,1
+permute,update.Plots,-1,0,0,class<`Plots`>,1
+permute,update.Plots,0,0,0,class<`Plots`>,1
+permute,update.Plots,1,0,0,...,1
+permute,update.Plots,2,0,0,logical,1
+permute,Within,-1,0,0,class<`Within`>,1
+permute,Within,0,0,0,character[],1
+permute,Within,1,0,0,logical,1
+permute,Within,2,0,0,logical,1
+permute,Within,3,0,0,null,1
+permute,Within,3,0,1,double,1
+permute,Within,4,0,0,null,1
+permute,Within,4,0,1,double,1
+pheatmap,cluster_mat,-1,0,0,class<`hclust`>,1
+pheatmap,cluster_mat,0,0,0,any,1
+pheatmap,cluster_mat,1,0,0,class<`dist`>,1
+pheatmap,cluster_mat,1,0,1,character,1
+pheatmap,cluster_mat,2,0,0,character,1
+pheatmap,convert_annotations,-1,0,0,class<`matrix`>,1
+pheatmap,convert_annotations,0,0,0,class<`data.frame`>,1
+pheatmap,convert_annotations,1,0,0,list<character[]>,1
+pheatmap,draw_annotation_legend,-1,0,0,"class<`gDesc`, `gTree`, `grob`>",1
+pheatmap,draw_annotation_legend,0,0,0,list<integer[] | class<`factor`>>,1
+pheatmap,draw_annotation_legend,1,0,0,list<character[]>,1
+pheatmap,draw_annotation_legend,2,0,0,character,1
+pheatmap,draw_annotation_legend,3,0,0,...,1
+pheatmap,draw_annotation_names,-1,0,0,"class<`gDesc`, `grob`, `text`>",1
+pheatmap,draw_annotation_names,0,0,0,class<`data.frame`>,1
+pheatmap,draw_annotation_names,1,0,0,double,1
+pheatmap,draw_annotation_names,2,0,0,logical,1
+pheatmap,draw_annotation_names,3,0,0,any,1
+pheatmap,draw_annotation_names,4,0,0,any,1
+pheatmap,draw_annotation_names,5,0,0,any,1
+pheatmap,draw_annotations,-1,0,0,"class<`gDesc`, `grob`, `rect`>",1
+pheatmap,draw_annotations,0,0,0,class<`matrix`>,1
+pheatmap,draw_annotations,1,0,0,character,1
+pheatmap,draw_annotations,2,0,0,integer,1
+pheatmap,draw_annotations,2,0,1,null,1
+pheatmap,draw_annotations,3,0,0,double,1
+pheatmap,draw_annotations,4,0,0,logical,1
+pheatmap,draw_dendrogram,-1,0,0,"class<`gDesc`, `grob`, `polyline`>",1
+pheatmap,draw_dendrogram,0,0,0,class<`hclust`>,1
+pheatmap,draw_dendrogram,1,0,0,integer,1
+pheatmap,draw_dendrogram,1,0,1,null,1
+pheatmap,draw_dendrogram,2,0,0,logical,1
+pheatmap,draw_legend,-1,0,0,"class<`gDesc`, `gTree`, `grob`>",1
+pheatmap,draw_legend,0,0,0,character[],1
+pheatmap,draw_legend,1,0,0,double[],1
+pheatmap,draw_legend,2,0,0,double[],1
+pheatmap,draw_legend,3,0,0,...,1
+pheatmap,draw_main,-1,0,0,"class<`gDesc`, `grob`, `text`>",1
+pheatmap,draw_main,0,0,0,character,1
+pheatmap,draw_main,1,0,0,...,1
+pheatmap,draw_matrix,-1,0,0,"class<`gDesc`, `gTree`, `grob`>",1
+pheatmap,draw_matrix,0,0,0,class<`matrix`>,1
+pheatmap,draw_matrix,1,0,0,character,1
+pheatmap,draw_matrix,2,0,0,double[],1
+pheatmap,draw_matrix,2,0,1,null,1
+pheatmap,draw_matrix,3,0,0,integer,1
+pheatmap,draw_matrix,3,0,1,null,1
+pheatmap,draw_matrix,4,0,0,class<`matrix`>,1
+pheatmap,draw_matrix,5,0,0,any,1
+pheatmap,draw_matrix,6,0,0,any,1
+pheatmap,find_coordinates,-1,0,0,list<class<`unit`>>,1
+pheatmap,find_coordinates,-1,0,1,"list<class<`unit`, `unit.arithmetic`>>",1
+pheatmap,find_coordinates,0,0,0,integer,1
+pheatmap,find_coordinates,1,0,0,null,1
+pheatmap,find_coordinates,1,0,1,double[],1
+pheatmap,find_coordinates,2,0,0,double[],1
+pheatmap,find_gaps,-1,0,0,integer,1
+pheatmap,find_gaps,0,0,0,class<`hclust`>,1
+pheatmap,find_gaps,1,0,0,double,1
+pheatmap,generate_annotation_colours,-1,0,0,list<character[]>,1
+pheatmap,generate_annotation_colours,0,0,0,list<class<`factor`> | integer[]>,1
+pheatmap,generate_annotation_colours,1,0,0,null,1
+pheatmap,generate_annotation_colours,1,0,1,list<character[]>,1
+pheatmap,generate_annotation_colours,2,0,0,logical,1
+pheatmap,generate_breaks,-1,0,0,double[],1
+pheatmap,generate_breaks,0,0,0,class<`matrix`>,1
+pheatmap,generate_breaks,0,0,1,double[],1
+pheatmap,generate_breaks,1,0,0,integer,1
+pheatmap,generate_breaks,2,0,0,logical,1
+pheatmap,heatmap_motor,-1,0,0,"class<`gDesc`, `gTree`, `grob`, `gtable`>",1
+pheatmap,heatmap_motor,0,0,0,class<`matrix`>,1
+pheatmap,heatmap_motor,1,0,0,character,1
+pheatmap,heatmap_motor,2,0,0,double,1
+pheatmap,heatmap_motor,2,0,1,null,1
+pheatmap,heatmap_motor,3,0,0,double,1
+pheatmap,heatmap_motor,3,0,1,null,1
+pheatmap,heatmap_motor,4,0,0,class<`hclust`>,1
+pheatmap,heatmap_motor,5,0,0,class<`hclust`>,1
+pheatmap,heatmap_motor,5,0,1,null,1
+pheatmap,heatmap_motor,6,0,0,double,1
+pheatmap,heatmap_motor,7,0,0,double,1
+pheatmap,heatmap_motor,8,0,0,character,1
+pheatmap,heatmap_motor,8,0,1,null,1
+pheatmap,heatmap_motor,9,0,0,any,1
+pheatmap,heatmap_motor,10,0,0,any,1
+pheatmap,heatmap_motor,11,0,0,any,1
+pheatmap,heatmap_motor,12,0,0,any,1
+pheatmap,heatmap_motor,13,0,0,double[],1
+pheatmap,heatmap_motor,13,0,1,null,1
+pheatmap,heatmap_motor,14,0,0,null,1
+pheatmap,heatmap_motor,14,0,1,class<`data.frame`>,1
+pheatmap,heatmap_motor,15,0,0,null,1
+pheatmap,heatmap_motor,15,0,1,class<`data.frame`>,1
+pheatmap,is.na2,-1,0,0,logical,1
+pheatmap,is.na2,0,0,0,character[],1
+pheatmap,is.na2,0,0,1,class<`data.frame`>,1
+pheatmap,is.na2,0,0,2,class<`factor`>,1
+pheatmap,is.na2,0,0,3,class<`hclust`>,1
+pheatmap,is.na2,0,0,4,double[],1
+pheatmap,is.na2,0,0,5,null,1
+pheatmap,is.na2,0,0,6,list<character[]>,1
+pheatmap,lo,-1,0,0,"list<class<`gDesc`, `gTree`, `grob`, `gtable`> | double>",1
+pheatmap,lo,0,0,0,character[],1
+pheatmap,lo,1,0,0,character[],1
+pheatmap,lo,2,0,0,integer,1
+pheatmap,lo,3,0,0,integer,1
+pheatmap,lo,4,0,0,double,1
+pheatmap,lo,4,0,1,null,1
+pheatmap,lo,5,0,0,double,1
+pheatmap,lo,5,0,1,null,1
+pheatmap,lo,6,0,0,double,1
+pheatmap,lo,7,0,0,double,1
+pheatmap,lo,8,0,0,double[],1
+pheatmap,lo,8,0,1,null,1
+pheatmap,lo,9,0,0,null,1
+pheatmap,lo,9,0,1,class<`data.frame`>,1
+pheatmap,lo,10,0,0,null,1
+pheatmap,lo,10,0,1,class<`data.frame`>,1
+pheatmap,lo,11,0,0,any,1
+pheatmap,lo,12,0,0,any,1
+pheatmap,lo,13,0,0,logical,1
+pheatmap,lo,14,0,0,logical,1
+pheatmap,lo,15,0,0,character,1
+pheatmap,lo,15,0,1,null,1
+pheatmap,pheatmap,-1,0,0,class<`pheatmap`>,1
+pheatmap,pheatmap,0,0,0,class<`matrix`>,1
+pheatmap,pheatmap,1,0,0,character[],1
+pheatmap,pheatmap,2,0,0,double,1
+pheatmap,pheatmap,2,0,1,null,1
+pheatmap,pheatmap,3,0,0,null,1
+pheatmap,pheatmap,4,0,0,character,1
+pheatmap,pheatmap,5,0,0,null,1
+pheatmap,pheatmap,5,0,1,double,1
+pheatmap,pheatmap,6,0,0,null,1
+pheatmap,pheatmap,6,0,1,double,1
+pheatmap,pheatmap,7,0,0,character,1
+pheatmap,pheatmap,8,0,0,logical,1
+pheatmap,pheatmap,9,0,0,logical,1
+pheatmap,pheatmap,10,0,0,character,1
+pheatmap,pheatmap,10,0,1,class<`dist`>,1
+pheatmap,pheatmap,11,0,0,character,1
+pheatmap,pheatmap,11,0,1,class<`dist`>,1
+pheatmap,pheatmap,12,0,0,character,1
+pheatmap,pheatmap,13,0,0,class<`function`>,1
+pheatmap,pheatmap,14,0,0,null,1
+pheatmap,pheatmap,15,0,0,null,1
+pheatmap,pheatmap,15,0,1,double,1
+pheatmap,scale_colours,-1,0,0,class<`matrix`>,1
+pheatmap,scale_colours,0,0,0,class<`matrix`>,1
+pheatmap,scale_colours,1,0,0,character[],1
+pheatmap,scale_colours,2,0,0,double[],1
+pheatmap,scale_colours,3,0,0,character,1
+pheatmap,scale_mat,-1,0,0,class<`matrix`>,1
+pheatmap,scale_mat,0,0,0,class<`matrix`>,1
+pheatmap,scale_mat,1,0,0,character,1
+pheatmap,scale_rows,-1,0,0,class<`matrix`>,1
+pheatmap,scale_rows,0,0,0,class<`matrix`>,1
+pheatmap,scale_vec_colours,-1,0,0,character[],1
+pheatmap,scale_vec_colours,0,0,0,double[],1
+pheatmap,scale_vec_colours,1,0,0,character[],1
+pheatmap,scale_vec_colours,2,0,0,double[],1
+pheatmap,scale_vec_colours,3,0,0,character,1
+phonTools,anova.rcr,-1,0,0,class<`anova.rcr`>,1
+phonTools,anova.rcr,0,0,0,class<`rcr`>,1
+phonTools,anova.rcr,1,0,0,...,1
+phonTools,combocalc,-1,0,0,double,1
+phonTools,combocalc,0,0,0,double,1
+phonTools,combocalc,1,0,0,double,1
+phonTools,combocalc,2,0,0,logical,1
+phonTools,combocalc,3,0,0,logical,1
+phonTools,createtemplate,-1,0,0,class<`template`>,1
+phonTools,createtemplate,0,0,0,class<`data.frame`>,1
+phonTools,createtemplate,1,0,0,class<`factor`>,1
+phonTools,errorbars,-1,0,0,null,1
+phonTools,errorbars,0,0,0,integer[],1
+phonTools,errorbars,1,0,0,integer[],1
+phonTools,errorbars,2,0,0,double,1
+phonTools,errorbars,3,0,0,double,1
+phonTools,errorbars,4,0,0,double,1
+phonTools,errorbars,5,0,0,logical,1
+phonTools,errorbars,6,0,0,...,1
+phonTools,fastacf,-1,0,0,class<`data.frame`>,1
+phonTools,fastacf,0,0,0,double[],1
+phonTools,fastacf,1,0,0,double,1
+phonTools,fastacf,2,0,0,character,1
+phonTools,fastacf,3,0,0,logical,1
+phonTools,fastacf,4,0,0,logical,1
+phonTools,Ffilter,-1,0,0,double[],1
+phonTools,Ffilter,0,0,0,double[],1
+phonTools,Ffilter,1,0,0,double[],1
+phonTools,Ffilter,2,0,0,double[],1
+phonTools,Ffilter,3,0,0,double,1
+phonTools,Ffilter,4,0,0,double,1
+phonTools,Ffilter,5,0,0,logical,1
+phonTools,findformants,-1,0,0,class<`data.frame`>,1
+phonTools,findformants,0,0,0,class<`sound`>,1
+phonTools,findformants,0,0,1,double[],1
+phonTools,findformants,1,0,0,double,1
+phonTools,findformants,2,0,0,null,1
+phonTools,findformants,2,0,1,double,1
+phonTools,findformants,3,0,0,double,1
+phonTools,findformants,4,0,0,double,1
+phonTools,findformants,5,0,0,logical,1
+phonTools,findformants,6,0,0,logical,1
+phonTools,findformants,7,0,0,logical,1
+phonTools,FIRfilter,-1,0,0,double[],1
+phonTools,FIRfilter,0,0,0,double[],1
+phonTools,FIRfilter,1,0,0,double,1
+phonTools,FIRfilter,2,0,0,double,1
+phonTools,FIRfilter,3,0,0,double,1
+phonTools,FIRfilter,4,0,0,double,1
+phonTools,FIRfilter,5,0,0,logical,1
+phonTools,FIRfilter,6,0,0,double[],1
+phonTools,FIRfilter,7,0,0,logical,1
+phonTools,formanttrack,-1,0,0,class<`data.frame`>,1
+phonTools,formanttrack,0,0,0,class<`sound`>,1
+phonTools,formanttrack,1,0,0,double,1
+phonTools,formanttrack,2,0,0,double,1
+phonTools,formanttrack,3,0,0,double,1
+phonTools,formanttrack,4,0,0,double,1
+phonTools,formanttrack,5,0,0,double,1
+phonTools,formanttrack,6,0,0,double,1
+phonTools,formanttrack,7,0,0,double,1
+phonTools,freqresponse,-1,0,0,class<`data.frame`>,1
+phonTools,freqresponse,0,0,0,double[],1
+phonTools,freqresponse,1,0,0,double[],1
+phonTools,freqresponse,2,0,0,double,1
+phonTools,freqresponse,3,0,0,logical,1
+phonTools,freqresponse,4,0,0,logical,1
+phonTools,freqresponse,5,0,0,double,1
+phonTools,freqresponse,6,0,0,...,1
+phonTools,hotelling.test,-1,0,0,class<`hotelling.test`>,1
+phonTools,hotelling.test,0,0,0,class<`data.frame`>,1
+phonTools,hotelling.test,1,0,0,class<`data.frame`>,1
+phonTools,hotelling.test,1,0,1,null,1
+phonTools,imputeformants,-1,0,0,double[],1
+phonTools,imputeformants,0,0,0,double[],1
+phonTools,imputeformants,1,0,0,double[],1
+phonTools,imputeformants,2,0,0,class<`factor`>,1
+phonTools,interpolate,-1,0,0,class<`data.frame`>,1
+phonTools,interpolate,0,0,0,double[],1
+phonTools,interpolate,1,0,0,double[],1
+phonTools,interpolate,2,0,0,double,1
+phonTools,interpolate,3,0,0,double,1
+phonTools,interpolate,4,0,0,logical,1
+phonTools,interpolate,5,0,0,character,1
+phonTools,interpolate,6,0,0,...,1
+phonTools,ipainfo,-1,0,0,list<any>,1
+phonTools,ipainfo,0,0,0,any,1
+phonTools,ldboundary,-1,0,0,double[],1
+phonTools,ldboundary,0,0,0,double[],1
+phonTools,ldboundary,1,0,0,double[],1
+phonTools,ldboundary,2,0,0,class<`matrix`>,1
+phonTools,ldboundary,3,0,0,double,1
+phonTools,ldboundary,4,0,0,double,1
+phonTools,ldboundary,5,0,0,logical,1
+phonTools,ldboundary,6,0,0,...,1
+phonTools,ldclassify,-1,0,0,class<`factor`>,1
+phonTools,ldclassify,0,0,0,class<`data.frame`>,1
+phonTools,ldclassify,1,0,0,class<`matrix`>,1
+phonTools,ldclassify,2,0,0,class<`matrix`>,1
+phonTools,ldclassify,3,0,0,null,1
+phonTools,ldclassify,4,0,0,character,1
+phonTools,lpc,-1,0,0,double[],1
+phonTools,lpc,0,0,0,class<`sound`>,1
+phonTools,lpc,0,0,1,class<`ts`>,1
+phonTools,lpc,0,0,2,double[],1
+phonTools,lpc,1,0,0,double,1
+phonTools,lpc,2,0,0,any,1
+phonTools,lpc,3,0,0,logical,1
+phonTools,lpc,4,0,0,logical,1
+phonTools,lpc,5,0,0,logical,1
+phonTools,makeFIR,-1,0,0,double[],1
+phonTools,makeFIR,0,0,0,double[],1
+phonTools,makeFIR,1,0,0,double[],1
+phonTools,makeFIR,2,0,0,double,1
+phonTools,makeFIR,3,0,0,double[],1
+phonTools,makeFIR,3,0,1,null,1
+phonTools,makeFIR,4,0,0,character,1
+phonTools,makeFIR,5,0,0,logical,1
+phonTools,makeFIR,6,0,0,character,1
+phonTools,makesound,-1,0,0,class<`sound`>,1
+phonTools,makesound,0,0,0,double[],1
+phonTools,makesound,1,0,0,any,1
+phonTools,makesound,2,0,0,double,1
+phonTools,multiplot,-1,0,0,null,1
+phonTools,multiplot,0,0,0,double,1
+phonTools,multiplot,1,0,0,character,1
+phonTools,multiplot,2,0,0,double[],1
+phonTools,multiplot,3,0,0,logical,1
+phonTools,normalize,-1,0,0,class<`data.frame`>,1
+phonTools,normalize,0,0,0,class<`data.frame`>,1
+phonTools,normalize,1,0,0,integer[],1
+phonTools,normalize,2,0,0,class<`factor`>,1
+phonTools,normalize,3,0,0,character,1
+phonTools,normalize,4,0,0,character[],1
+phonTools,normalize,4,0,1,null,1
+phonTools,ntypes,-1,0,0,integer,1
+phonTools,ntypes,0,0,0,class<`factor`>,1
+phonTools,peakfind,-1,0,0,double,1
+phonTools,peakfind,-1,0,1,integer[],1
+phonTools,peakfind,0,0,0,double[],1
+phonTools,peakfind,1,0,0,logical,1
+phonTools,phasor,-1,0,0,null,1
+phonTools,phasor,0,0,0,complex[],1
+phonTools,phasor,1,0,0,logical,1
+phonTools,phasor,2,0,0,logical,1
+phonTools,phasor,3,0,0,logical,1
+phonTools,phasor,4,0,0,any,1
+phonTools,phasor,5,0,0,any,1
+phonTools,phasor,6,0,0,...,1
+phonTools,pitchtrack,-1,0,0,class<`data.frame`>,1
+phonTools,pitchtrack,-1,0,1,double[],1
+phonTools,pitchtrack,0,0,0,class<`sound`>,1
+phonTools,pitchtrack,0,0,1,double[],1
+phonTools,pitchtrack,1,0,0,double[],1
+phonTools,pitchtrack,2,0,0,double,1
+phonTools,pitchtrack,3,0,0,double,1
+phonTools,pitchtrack,4,0,0,double,1
+phonTools,pitchtrack,5,0,0,logical,1
+phonTools,pitchtrack,6,0,0,logical,1
+phonTools,pitchtrack,7,0,0,double,1
+phonTools,plot.sound,-1,0,0,null,1
+phonTools,plot.sound,0,0,0,class<`sound`>,1
+phonTools,plot.sound,1,0,0,...,1
+phonTools,plot.spectrogram,-1,0,0,null,1
+phonTools,plot.spectrogram,0,0,0,class<`spectrogram`>,1
+phonTools,plot.spectrogram,1,0,0,any,1
+phonTools,plot.spectrogram,2,0,0,double[],1
+phonTools,plot.spectrogram,3,0,0,any,1
+phonTools,plot.spectrogram,4,0,0,logical,1
+phonTools,plot.spectrogram,5,0,0,...,1
+phonTools,plot.template,-1,0,0,null,1
+phonTools,plot.template,0,0,0,class<`template`>,1
+phonTools,plot.template,1,0,0,logical,1
+phonTools,plot.template,2,0,0,logical,1
+phonTools,plot.template,3,0,0,...,1
+phonTools,polezero,-1,0,0,null,1
+phonTools,polezero,0,0,0,double[],1
+phonTools,polezero,1,0,0,double[],1
+phonTools,polezero,2,0,0,...,1
+phonTools,powertrack,-1,0,0,class<`data.frame`>,1
+phonTools,powertrack,0,0,0,class<`sound`>,1
+phonTools,powertrack,1,0,0,double,1
+phonTools,powertrack,2,0,0,double,1
+phonTools,powertrack,3,0,0,double,1
+phonTools,powertrack,4,0,0,logical,1
+phonTools,powertrack,5,0,0,logical,1
+phonTools,powertrack,6,0,0,...,1
+phonTools,preemphasis,-1,0,0,class<`ts`>,1
+phonTools,preemphasis,-1,0,1,double[],1
+phonTools,preemphasis,0,0,0,class<`ts`>,1
+phonTools,preemphasis,0,0,1,double[],1
+phonTools,preemphasis,1,0,0,double,1
+phonTools,preemphasis,2,0,0,any,1
+phonTools,preemphasis,3,0,0,logical,1
+phonTools,preemphasis,4,0,0,double,1
+phonTools,PSTM,-1,0,0,class<`data.frame`>,1
+phonTools,PSTM,-1,0,1,list<class<`data.frame`>>,1
+phonTools,PSTM,0,0,0,class<`data.frame`>,1
+phonTools,PSTM,1,0,0,integer[],1
+phonTools,PSTM,2,0,0,class<`template`>,1
+phonTools,PSTM,3,0,0,logical,1
+phonTools,pwelch,-1,0,0,class<`matrix`>,1
+phonTools,pwelch,0,0,0,double[],1
+phonTools,pwelch,1,0,0,double,1
+phonTools,pwelch,2,0,0,double,1
+phonTools,pwelch,3,0,0,double,1
+phonTools,pwelch,4,0,0,character,1
+phonTools,pwelch,5,0,0,logical,1
+phonTools,pwelch,6,0,0,double,1
+phonTools,pwelch,7,0,0,double,1
+phonTools,rcr,-1,0,0,class<`rcr`>,1
+phonTools,rcr,0,0,0,class<`formula`>,1
+phonTools,rcr,1,0,0,integer[],1
+phonTools,rcr,2,0,0,class<`data.frame`>,1
+phonTools,rcr,3,0,0,...,1
+phonTools,reduce.fraction,-1,0,0,double[],1
+phonTools,reduce.fraction,0,0,0,double[],1
+phonTools,resample,-1,0,0,class<`ts`>,1
+phonTools,resample,-1,0,1,double[],1
+phonTools,resample,0,0,0,class<`ts`>,1
+phonTools,resample,0,0,1,double[],1
+phonTools,resample,1,0,0,double,1
+phonTools,resample,2,0,0,double,1
+phonTools,resample,3,0,0,double,1
+phonTools,resample,4,0,0,double,1
+phonTools,resample,5,0,0,logical,1
+phonTools,rmvtnorm,-1,0,0,class<`matrix`>,1
+phonTools,rmvtnorm,0,0,0,double,1
+phonTools,rmvtnorm,1,0,0,double,1
+phonTools,rmvtnorm,2,0,0,double[],1
+phonTools,rmvtnorm,3,0,0,double,1
+phonTools,rotate,-1,0,0,class<`matrix`>,1
+phonTools,rotate,-1,0,1,complex[],1
+phonTools,rotate,0,0,0,class<`matrix`>,1
+phonTools,rotate,0,0,1,complex[],1
+phonTools,rotate,1,0,0,double,1
+phonTools,rotate,2,0,0,logical,1
+phonTools,rotate,3,0,0,logical,1
+phonTools,sdellipse,-1,0,0,class<`matrix`>,1
+phonTools,sdellipse,0,0,0,class<`matrix`>,1
+phonTools,sdellipse,1,0,0,double,1
+phonTools,sdellipse,2,0,0,double,1
+phonTools,sdellipse,3,0,0,logical,1
+phonTools,sdellipse,4,0,0,logical,1
+phonTools,sdellipse,5,0,0,double[],1
+phonTools,sdellipse,5,0,1,null,1
+phonTools,sdellipse,6,0,0,logical,1
+phonTools,sdellipse,7,0,0,...,1
+phonTools,sinc,-1,0,0,double[],1
+phonTools,sinc,0,0,0,double[],1
+phonTools,sinc,1,0,0,logical,1
+phonTools,sinusoid,-1,0,0,class<`data.frame`>,1
+phonTools,sinusoid,0,0,0,double[],1
+phonTools,sinusoid,1,0,0,double[],1
+phonTools,sinusoid,2,0,0,double,1
+phonTools,sinusoid,3,0,0,double[],1
+phonTools,sinusoid,4,0,0,double,1
+phonTools,sinusoid,5,0,0,logical,1
+phonTools,sinusoid,6,0,0,logical,1
+phonTools,sinusoid,7,0,0,null,1
+phonTools,spectralslice,-1,0,0,class<`matrix`>,1
+phonTools,spectralslice,0,0,0,class<`sound`>,1
+phonTools,spectralslice,0,0,1,class<`ts`>,1
+phonTools,spectralslice,0,0,2,double[],1
+phonTools,spectralslice,1,0,0,double,1
+phonTools,spectralslice,2,0,0,any,1
+phonTools,spectralslice,3,0,0,logical,1
+phonTools,spectralslice,4,0,0,logical,1
+phonTools,spectralslice,5,0,0,character,1
+phonTools,spectralslice,6,0,0,double,1
+phonTools,spectralslice,7,0,0,logical,1
+phonTools,spectrogram,-1,0,0,class<`spectrogram`>,1
+phonTools,spectrogram,0,0,0,class<`sound`>,1
+phonTools,spectrogram,0,0,1,class<`ts`>,1
+phonTools,spectrogram,1,0,0,any,1
+phonTools,spectrogram,2,0,0,double,1
+phonTools,spectrogram,3,0,0,double,1
+phonTools,spectrogram,4,0,0,double,1
+phonTools,spectrogram,5,0,0,double,1
+phonTools,spectrogram,6,0,0,double,1
+phonTools,spectrogram,7,0,0,logical,1
+phonTools,summary.rcr,-1,0,0,class<`summary.rcr`>,1
+phonTools,summary.rcr,0,0,0,class<`rcr`>,1
+phonTools,summary.rcr,1,0,0,...,1
+phonTools,synthfilter,-1,0,0,class<`ts`>,1
+phonTools,synthfilter,-1,0,1,double[],1
+phonTools,synthfilter,0,0,0,class<`ts`>,1
+phonTools,synthfilter,0,0,1,double[],1
+phonTools,synthfilter,1,0,0,double[],1
+phonTools,synthfilter,2,0,0,any,1
+phonTools,synthfilter,3,0,0,logical,1
+phonTools,synthfilter,4,0,0,double,1
+phonTools,vowelplot,-1,0,0,null,1
+phonTools,vowelplot,0,0,0,double[],1
+phonTools,vowelplot,1,0,0,double[],1
+phonTools,vowelplot,2,0,0,class<`factor`>,1
+phonTools,vowelplot,3,0,0,null,1
+phonTools,vowelplot,4,0,0,null,1
+phonTools,vowelplot,5,0,0,logical,1
+phonTools,vowelplot,6,0,0,logical,1
+phonTools,vowelplot,7,0,0,double,1
+phonTools,vowelsynth,-1,0,0,class<`sound`>,1
+phonTools,vowelsynth,-1,0,1,double[],1
+phonTools,vowelsynth,0,0,0,double[],1
+phonTools,vowelsynth,1,0,0,double[],1
+phonTools,vowelsynth,2,0,0,double,1
+phonTools,vowelsynth,3,0,0,double[],1
+phonTools,vowelsynth,4,0,0,double,1
+phonTools,vowelsynth,5,0,0,logical,1
+phonTools,vowelsynth,6,0,0,logical,1
+phonTools,vowelsynth,7,0,0,double,1
+phonTools,vplot,-1,0,0,null,1
+phonTools,vplot,0,0,0,integer[],1
+phonTools,vplot,1,0,0,integer[],1
+phonTools,vplot,2,0,0,class<`factor`>,1
+phonTools,vplot,3,0,0,null,1
+phonTools,vplot,4,0,0,null,1
+phonTools,vplot,5,0,0,logical,1
+phonTools,vplot,6,0,0,double,1
+phonTools,vplot,7,0,0,logical,1
+phonTools,windowfunc,-1,0,0,double[],1
+phonTools,windowfunc,0,0,0,class<`ts`>,1
+phonTools,windowfunc,0,0,1,double[],1
+phonTools,windowfunc,1,0,0,character,1
+phonTools,windowfunc,2,0,0,any,1
+phonTools,writesound,-1,0,0,null,1
+phonTools,writesound,0,0,0,double[],1
+phonTools,writesound,1,0,0,character,1
+phonTools,writesound,2,0,0,double,1
+phonTools,xsampatoIPA,-1,0,0,class<`hexmode`>,1
+phonTools,xsampatoIPA,0,0,0,character[],1
+phonTools,xsampatoIPA,0,0,1,class<`factor`>,1
+phonTools,xsampatoIPA,1,0,0,logical,1
+phonTools,xsampatoIPA,2,0,0,logical,1
+phonTools,zeros,-1,0,0,class<`matrix`>,1
+phonTools,zeros,-1,0,1,double[],1
+phonTools,zeros,0,0,0,double[],1
+phonTools,zeros,1,0,0,double,1
+phylobase,addData,-1,0,0,class<`phylo4d`>,1
+phylobase,addData,0,0,0,class<`phylo4d`>,1
+phylobase,addData,1,0,0,...,1
+phylobase,addData,-1,1,0,class<`phylo4d`>,1
+phylobase,addData,0,1,0,class<`phylo4d`>,1
+phylobase,addData,1,1,0,...,1
+phylobase,ancestor,-1,0,0,^integer[],1
+phylobase,ancestor,0,0,0,class<`phylo4`>,1
+phylobase,ancestor,0,0,1,class<`phylo4d`>,1
+phylobase,ancestor,1,0,0,integer[],1
+phylobase,ancestor,1,0,1,character,1
+phylobase,ancestor,1,0,2,double,1
+phylobase,ancestors,-1,0,0,integer[],1
+phylobase,ancestors,0,0,0,class<`phylo4d`>,1
+phylobase,ancestors,0,0,1,class<`phylo4`>,1
+phylobase,ancestors,1,0,0,character,1
+phylobase,ancestors,1,0,1,double,1
+phylobase,ancestors,2,0,0,character[],1
+phylobase,as_phylo4vcov,-1,0,0,class<`phylo4vcov`>,1
+phylobase,as_phylo4vcov,0,0,0,class<`phylo4`>,1
+phylobase,as_phylo4vcov,1,0,0,...,1
+phylobase,.bubLegendGrob,-1,0,0,"class<`bubLegend`, `gDesc`, `grob`>",1
+phylobase,.bubLegendGrob,0,0,0,class<`data.frame`>,1
+phylobase,.bubLegendGrob,1,0,0,class<`matrix`>,1
+phylobase,checkPhylo4,-1,0,0,character,1
+phylobase,checkPhylo4,-1,0,1,logical,1
+phylobase,checkPhylo4,0,0,0,class<`phylo4`>,1
+phylobase,checkPhylo4,0,0,1,class<`phylo4d`>,1
+phylobase,checkPhylo4Data,-1,0,0,logical,1
+phylobase,checkPhylo4Data,0,0,0,class<`phylo4d`>,1
+phylobase,checkTree,-1,0,0,character,1
+phylobase,checkTree,-1,0,1,logical,1
+phylobase,checkTree,0,0,0,class<`phylo4`>,1
+phylobase,checkTree,0,0,1,class<`phylo4d`>,1
+phylobase,checkTreeCpp,-1,0,0,list<character>,1
+phylobase,checkTreeCpp,0,0,0,class<`phylo4`>,1
+phylobase,checkTreeCpp,0,0,1,class<`phylo4d`>,1
+phylobase,checkTreeCpp,1,0,0,list<character>,1
+phylobase,children,-1,0,0,integer[],1
+phylobase,children,0,0,0,class<`phylo4d`>,1
+phylobase,children,1,0,0,character,1
+phylobase,children,1,0,1,double,1
+phylobase,.createEdge,-1,0,0,^character[],1
+phylobase,.createEdge,-1,0,1,^double[],1
+phylobase,.createEdge,0,0,0,null,1
+phylobase,.createEdge,0,0,1,^character[],1
+phylobase,.createEdge,0,0,2,^double[],1
+phylobase,.createEdge,1,0,0,class<`matrix`>,1
+phylobase,.createEdge,2,0,0,character,1
+phylobase,.createEdge,3,0,0,any,1
+phylobase,.createLabels,-1,0,0,any,1
+phylobase,.createLabels,0,0,0,any,1
+phylobase,.createLabels,1,0,0,integer,1
+phylobase,.createLabels,2,0,0,any,1
+phylobase,.createLabels,3,0,0,any,1
+phylobase,.createLabels,4,0,0,character,1
+phylobase,depthTips,-1,0,0,double[],1
+phylobase,depthTips,0,0,0,class<`phylo4`>,1
+phylobase,depthTips,-1,1,0,double[],1
+phylobase,depthTips,0,1,0,class<`phylo4`>,1
+phylobase,descendants,-1,0,0,integer[],1
+phylobase,descendants,-1,0,1,list<any>,1
+phylobase,descendants,0,0,0,class<`phylo4d`>,1
+phylobase,descendants,0,0,1,class<`phylo4`>,1
+phylobase,descendants,1,0,0,double,1
+phylobase,descendants,1,0,1,character,1
+phylobase,descendants,2,0,0,character[],1
+phylobase,edgeId,-1,0,0,character[],1
+phylobase,edgeId,0,0,0,class<`phylo4d`>,1
+phylobase,edgeId,1,0,0,character[],1
+phylobase,edgeId,-1,1,0,character[],1
+phylobase,edgeId,0,1,0,class<`phylo4`>,1
+phylobase,edgeId,1,1,0,character[],1
+phylobase,edgeId,-1,2,0,character[],1
+phylobase,edgeId,0,2,0,class<`phylo4`>,1
+phylobase,edgeId,0,2,1,class<`phylo4d`>,1
+phylobase,edgeId,1,2,0,character[],1
+phylobase,edgeLabels,-1,0,0,^character[],1
+phylobase,edgeLabels,0,0,0,class<`phylo4`>,1
+phylobase,edgeLabels,-1,1,0,^character[],1
+phylobase,edgeLabels,0,1,0,class<`phylo4`>,1
+phylobase,edgeLabels<-,-1,0,0,class<`phylo4`>,1
+phylobase,edgeLabels<-,0,0,0,class<`phylo4`>,1
+phylobase,edgeLabels<-,1,0,0,...,1
+phylobase,edgeLabels<-,2,0,0,^character[],1
+phylobase,edgeLabels<-,-1,1,0,class<`phylo4`>,1
+phylobase,edgeLabels<-,0,1,0,class<`phylo4`>,1
+phylobase,edgeLabels<-,1,1,0,...,1
+phylobase,edgeLabels<-,2,1,0,^character[],1
+phylobase,edgeLength,-1,0,0,^double[],1
+phylobase,edgeLength,-1,0,1,null,1
+phylobase,edgeLength,0,0,0,class<`phylo4`>,1
+phylobase,edgeLength,1,0,0,...,1
+phylobase,edgeLength,-1,1,0,^double[],1
+phylobase,edgeLength,-1,1,1,null,1
+phylobase,edgeLength,0,1,0,class<`phylo4d`>,1
+phylobase,edgeLength,1,1,0,...,1
+phylobase,edgeLength,-1,2,0,^double[],1
+phylobase,edgeLength,-1,2,1,null,1
+phylobase,edgeLength,0,2,0,class<`phylo4`>,1
+phylobase,edgeLength,0,2,1,class<`phylo4d`>,1
+phylobase,edgeLength,1,2,0,...,1
+phylobase,edgeLength<-,-1,0,0,class<`phylo4`>,1
+phylobase,edgeLength<-,-1,0,1,class<`phylo4d`>,1
+phylobase,edgeLength<-,0,0,0,class<`phylo4`>,1
+phylobase,edgeLength<-,0,0,1,class<`phylo4d`>,1
+phylobase,edgeLength<-,1,0,0,double,1
+phylobase,edgeLength<-,2,0,0,...,1
+phylobase,edgeLength<-,3,0,0,^double[],1
+phylobase,edgeLength<-,3,0,1,null,1
+phylobase,edgeLength<-,-1,1,0,class<`phylo4`>,1
+phylobase,edgeLength<-,0,1,0,class<`phylo4`>,1
+phylobase,edgeLength<-,1,1,0,logical,1
+phylobase,edgeLength<-,2,1,0,...,1
+phylobase,edgeLength<-,3,1,0,double[],1
+phylobase,edgeLength<-,-1,2,0,class<`phylo4d`>,1
+phylobase,edgeLength<-,0,2,0,class<`phylo4d`>,1
+phylobase,edgeLength<-,1,2,0,double,1
+phylobase,edgeLength<-,2,2,0,...,1
+phylobase,edgeLength<-,3,2,0,^double[],1
+phylobase,edgeLength<-,3,2,1,null,1
+phylobase,edgeOrder,-1,0,0,character,1
+phylobase,edgeOrder,0,0,0,class<`phylo4`>,1
+phylobase,edgeOrder,0,0,1,class<`phylo4d`>,1
+phylobase,edgeOrder,1,0,0,...,1
+phylobase,edgeOrder,-1,1,0,character,1
+phylobase,edgeOrder,0,1,0,class<`phylo4`>,1
+phylobase,edgeOrder,1,1,0,...,1
+phylobase,edgeOrder,-1,2,0,character,1
+phylobase,edgeOrder,0,2,0,class<`phylo4d`>,1
+phylobase,edgeOrder,1,2,0,...,1
+phylobase,edges,-1,0,0,class<`matrix`>,1
+phylobase,edges,0,0,0,class<`phylo4`>,1
+phylobase,edges,0,0,1,class<`phylo4d`>,1
+phylobase,edges,1,0,0,...,1
+phylobase,edges,-1,1,0,class<`matrix`>,1
+phylobase,edges,0,1,0,class<`phylo4`>,1
+phylobase,edges,1,1,0,...,1
+phylobase,edges,-1,2,0,class<`matrix`>,1
+phylobase,edges,0,2,0,class<`phylo4d`>,1
+phylobase,edges,1,2,0,...,1
+phylobase,extractTree,-1,0,0,class<`phylo4`>,1
+phylobase,extractTree,0,0,0,class<`phylo4d`>,1
+phylobase,formatData,-1,0,0,any,1
+phylobase,formatData,0,0,0,class<`phylo4`>,1
+phylobase,formatData,0,0,1,class<`phylo4d`>,1
+phylobase,formatData,1,0,0,class<`data.frame`>,1
+phylobase,formatData,1,0,1,null,1
+phylobase,formatData,1,0,2,integer[],1
+phylobase,formatData,2,0,0,character,1
+phylobase,formatData,3,0,0,logical,1
+phylobase,formatData,4,0,0,logical,1
+phylobase,formatData,5,0,0,any,1
+phylobase,formatData,6,0,0,double,1
+phylobase,formatData,7,0,0,any,1
+phylobase,.genlab,-1,0,0,character[],1
+phylobase,.genlab,0,0,0,character,1
+phylobase,.genlab,1,0,0,integer,1
+phylobase,getAllNodesFast,-1,0,0,integer[],1
+phylobase,getAllNodesFast,0,0,0,class<`matrix`>,1
+phylobase,getEdge,-1,0,0,character[],1
+phylobase,getEdge,0,0,0,class<`phylo4d`>,1
+phylobase,getEdge,1,0,0,any,1
+phylobase,getEdge,2,0,0,character[],1
+phylobase,getEdge,3,0,0,character[],1
+phylobase,getEdge,-1,1,0,character[],1
+phylobase,getEdge,0,1,0,class<`phylo4`>,1
+phylobase,getEdge,0,1,1,class<`phylo4d`>,1
+phylobase,getEdge,1,1,0,any,1
+phylobase,getEdge,2,1,0,character[],1
+phylobase,getEdge,3,1,0,character[],1
+phylobase,getEdge,-1,2,0,character[],1
+phylobase,getEdge,0,2,0,class<`phylo4`>,1
+phylobase,getEdge,1,2,0,double,1
+phylobase,getEdge,2,2,0,character[],1
+phylobase,getEdge,3,2,0,character[],1
+phylobase,getNode,-1,0,0,^integer[],1
+phylobase,getNode,-1,0,1,null,1
+phylobase,getNode,0,0,0,class<`phylo4`>,1
+phylobase,getNode,0,0,1,class<`phylo4d`>,1
+phylobase,getNode,1,0,0,any,1
+phylobase,getNode,2,0,0,character[],1
+phylobase,getNode,3,0,0,character[],1
+phylobase,getNode,-1,1,0,^integer[],1
+phylobase,getNode,-1,1,1,null,1
+phylobase,getNode,0,1,0,class<`phylo4d`>,1
+phylobase,getNode,1,1,0,any,1
+phylobase,getNode,2,1,0,character[],1
+phylobase,getNode,3,1,0,character[],1
+phylobase,getNode,-1,2,0,^integer[],1
+phylobase,getNode,-1,2,1,null,1
+phylobase,getNode,0,2,0,class<`phylo4`>,1
+phylobase,getNode,1,2,0,character[],1
+phylobase,getNode,1,2,1,double[],1
+phylobase,getNode,2,2,0,character[],1
+phylobase,getNode,3,2,0,character[],1
+phylobase,hasDuplicatedLabels,-1,0,0,logical,1
+phylobase,hasDuplicatedLabels,0,0,0,class<`phylo4`>,1
+phylobase,hasDuplicatedLabels,0,0,1,class<`phylo4d`>,1
+phylobase,hasDuplicatedLabels,1,0,0,any,1
+phylobase,hasDuplicatedLabels,-1,1,0,logical,1
+phylobase,hasDuplicatedLabels,0,1,0,class<`phylo4d`>,1
+phylobase,hasDuplicatedLabels,1,1,0,any,1
+phylobase,hasDuplicatedLabels,-1,2,0,logical,1
+phylobase,hasDuplicatedLabels,0,2,0,class<`phylo4`>,1
+phylobase,hasDuplicatedLabels,1,2,0,any,1
+phylobase,hasDuplicatedLabelsCpp,-1,0,0,logical,1
+phylobase,hasDuplicatedLabelsCpp,0,0,0,^character[],1
+phylobase,hasEdgeLabels,-1,0,0,logical,1
+phylobase,hasEdgeLabels,0,0,0,class<`phylo4`>,1
+phylobase,hasEdgeLabels,-1,1,0,logical,1
+phylobase,hasEdgeLabels,0,1,0,class<`phylo4`>,1
+phylobase,hasEdgeLabels,0,1,1,class<`phylo4d`>,1
+phylobase,hasEdgeLabels,-1,2,0,logical,1
+phylobase,hasEdgeLabels,0,2,0,class<`phylo4d`>,1
+phylobase,hasEdgeLength,-1,0,0,logical,1
+phylobase,hasEdgeLength,0,0,0,class<`phylo4`>,1
+phylobase,hasEdgeLength,0,0,1,class<`phylo4d`>,1
+phylobase,hasEdgeLength,-1,1,0,logical,1
+phylobase,hasEdgeLength,0,1,0,class<`phylo4`>,1
+phylobase,hasEdgeLength,-1,2,0,logical,1
+phylobase,hasEdgeLength,0,2,0,class<`phylo4d`>,1
+phylobase,hasNodeData,-1,0,0,logical,1
+phylobase,hasNodeData,0,0,0,class<`phylo4d`>,1
+phylobase,hasNodeData,-1,1,0,logical,1
+phylobase,hasNodeData,0,1,0,class<`phylo4d`>,1
+phylobase,hasNodeLabels,-1,0,0,logical,1
+phylobase,hasNodeLabels,0,0,0,class<`phylo4`>,1
+phylobase,hasNodeLabels,0,0,1,class<`phylo4d`>,1
+phylobase,hasNodeLabels,-1,1,0,logical,1
+phylobase,hasNodeLabels,0,1,0,class<`phylo4`>,1
+phylobase,hasNodeLabels,-1,2,0,logical,1
+phylobase,hasNodeLabels,0,2,0,class<`phylo4d`>,1
+phylobase,hasPoly,-1,0,0,logical,1
+phylobase,hasPoly,0,0,0,class<`phylo4d`>,1
+phylobase,hasPoly,-1,1,0,logical,1
+phylobase,hasPoly,0,1,0,class<`phylo4`>,1
+phylobase,hasPoly,0,1,1,class<`phylo4d`>,1
+phylobase,hasPoly,-1,2,0,logical,1
+phylobase,hasPoly,0,2,0,class<`phylo4`>,1
+phylobase,hasRetic,-1,0,0,logical,1
+phylobase,hasRetic,0,0,0,class<`phylo4d`>,1
+phylobase,hasRetic,-1,1,0,logical,1
+phylobase,hasRetic,0,1,0,class<`phylo4`>,1
+phylobase,hasRetic,-1,2,0,logical,1
+phylobase,hasRetic,0,2,0,class<`phylo4`>,1
+phylobase,hasRetic,0,2,1,class<`phylo4d`>,1
+phylobase,hasSingle,-1,0,0,logical,1
+phylobase,hasSingle,0,0,0,class<`phylo4d`>,1
+phylobase,hasSingle,-1,1,0,logical,1
+phylobase,hasSingle,0,1,0,class<`phylo4`>,1
+phylobase,hasSingle,0,1,1,class<`phylo4d`>,1
+phylobase,hasSingle,-1,2,0,logical,1
+phylobase,hasSingle,0,2,0,class<`phylo4`>,1
+phylobase,hasTipData,-1,0,0,logical,1
+phylobase,hasTipData,0,0,0,class<`phylo4d`>,1
+phylobase,hasTipData,-1,1,0,logical,1
+phylobase,hasTipData,0,1,0,class<`phylo4d`>,1
+phylobase,head,-1,0,0,class<`data.frame`>,1
+phylobase,head,0,0,0,class<`phylo4`>,1
+phylobase,head,1,0,0,...,1
+phylobase,internalEdges,-1,0,0,logical[],1
+phylobase,internalEdges,0,0,0,class<`phylo4d`>,1
+phylobase,internalEdges,-1,1,0,logical[],1
+phylobase,internalEdges,0,1,0,class<`phylo4d`>,1
+phylobase,isRooted,-1,0,0,logical,1
+phylobase,isRooted,0,0,0,class<`phylo4`>,1
+phylobase,isRooted,-1,1,0,logical,1
+phylobase,isRooted,0,1,0,class<`phylo4d`>,1
+phylobase,isRooted,-1,2,0,logical,1
+phylobase,isRooted,0,2,0,class<`phylo4`>,1
+phylobase,isRooted,0,2,1,class<`phylo4d`>,1
+phylobase,isUltrametric,-1,0,0,logical,1
+phylobase,isUltrametric,0,0,0,class<`phylo4d`>,1
+phylobase,isUltrametric,1,0,0,double,1
+phylobase,isUltrametric,-1,1,0,logical,1
+phylobase,isUltrametric,0,1,0,class<`phylo4`>,1
+phylobase,isUltrametric,0,1,1,class<`phylo4d`>,1
+phylobase,isUltrametric,1,1,0,double,1
+phylobase,isUltrametric,-1,2,0,logical,1
+phylobase,isUltrametric,0,2,0,class<`phylo4`>,1
+phylobase,isUltrametric,1,2,0,double,1
+phylobase,labels,-1,0,0,^character[],1
+phylobase,labels,0,0,0,class<`phylo4d`>,1
+phylobase,labels,1,0,0,...,1
+phylobase,labels,-1,1,0,^character[],1
+phylobase,labels,0,1,0,class<`phylo4`>,1
+phylobase,labels,1,1,0,...,1
+phylobase,labels<-,-1,0,0,class<`phylo4`>,1
+phylobase,labels<-,0,0,0,class<`phylo4`>,1
+phylobase,labels<-,1,0,0,character,1
+phylobase,labels<-,2,0,0,any,1
+phylobase,labels<-,3,0,0,...,1
+phylobase,labels<-,4,0,0,character[],1
+phylobase,labels<-,-1,1,0,class<`phylo4`>,1
+phylobase,labels<-,-1,1,1,class<`phylo4d`>,1
+phylobase,labels<-,0,1,0,class<`phylo4`>,1
+phylobase,labels<-,0,1,1,class<`phylo4d`>,1
+phylobase,labels<-,1,1,0,character,1
+phylobase,labels<-,2,1,0,any,1
+phylobase,labels<-,3,1,0,...,1
+phylobase,labels<-,4,1,0,character[],1
+phylobase,labels<-,-1,2,0,class<`phylo4d`>,1
+phylobase,labels<-,0,2,0,class<`phylo4d`>,1
+phylobase,labels<-,1,2,0,character,1
+phylobase,labels<-,2,2,0,any,1
+phylobase,labels<-,3,2,0,...,1
+phylobase,labels<-,4,2,0,character[],1
+phylobase,MRCA,-1,0,0,integer,1
+phylobase,MRCA,0,0,0,class<`phylo4d`>,1
+phylobase,MRCA,1,0,0,...,1
+phylobase,MRCA,-1,1,0,integer,1
+phylobase,MRCA,0,1,0,class<`phylo`>,1
+phylobase,MRCA,0,1,1,class<`phylo4d`>,1
+phylobase,MRCA,0,1,2,class<`phylo4`>,1
+phylobase,MRCA,1,1,0,...,1
+phylobase,MRCA,-1,2,0,integer,1
+phylobase,MRCA,0,2,0,class<`phylo4`>,1
+phylobase,MRCA,1,2,0,...,1
+phylobase,MRCA,-1,3,0,integer,1
+phylobase,MRCA,0,3,0,class<`phylo`>,1
+phylobase,MRCA,1,3,0,...,1
+phylobase,nData,-1,0,0,integer,1
+phylobase,nData,0,0,0,class<`phylo4d`>,1
+phylobase,nData,-1,1,0,integer,1
+phylobase,nData,0,1,0,class<`phylo4d`>,1
+phylobase,nEdges,-1,0,0,integer,1
+phylobase,nEdges,0,0,0,class<`phylo4d`>,1
+phylobase,nEdges,-1,1,0,integer,1
+phylobase,nEdges,0,1,0,class<`phylo4`>,1
+phylobase,nEdges,-1,2,0,integer,1
+phylobase,nEdges,0,2,0,class<`phylo4`>,1
+phylobase,nEdges,0,2,1,class<`phylo4d`>,1
+phylobase,nNodes,-1,0,0,integer,1
+phylobase,nNodes,0,0,0,class<`phylo4`>,1
+phylobase,nNodes,0,0,1,class<`phylo4d`>,1
+phylobase,nNodes,-1,1,0,integer,1
+phylobase,nNodes,0,1,0,class<`phylo4d`>,1
+phylobase,nNodes,-1,2,0,integer,1
+phylobase,nNodes,0,2,0,class<`phylo4`>,1
+phylobase,nodeDepth,-1,0,0,double[],1
+phylobase,nodeDepth,0,0,0,class<`phylo4`>,1
+phylobase,nodeDepth,1,0,0,integer[],1
+phylobase,nodeDepth,1,0,1,double,1
+phylobase,nodeDepth,-1,1,0,double[],1
+phylobase,nodeDepth,0,1,0,class<`phylo4`>,1
+phylobase,nodeDepth,1,1,0,integer[],1
+phylobase,nodeDepth,1,1,1,double,1
+phylobase,nodeHeight,-1,0,0,double[],1
+phylobase,nodeHeight,0,0,0,class<`phylo4d`>,1
+phylobase,nodeHeight,1,0,0,integer[],1
+phylobase,nodeHeight,2,0,0,character,1
+phylobase,nodeHeight,-1,1,0,double[],1
+phylobase,nodeHeight,0,1,0,class<`phylo4d`>,1
+phylobase,nodeHeight,0,1,1,class<`phylo4`>,1
+phylobase,nodeHeight,1,1,0,integer[],1
+phylobase,nodeHeight,2,1,0,character,1
+phylobase,nodeHeight,-1,2,0,double[],1
+phylobase,nodeHeight,0,2,0,class<`phylo4`>,1
+phylobase,nodeHeight,1,2,0,integer[],1
+phylobase,nodeHeight,2,2,0,character,1
+phylobase,nodeId,-1,0,0,integer[],1
+phylobase,nodeId,0,0,0,class<`phylo4d`>,1
+phylobase,nodeId,1,0,0,character,1
+phylobase,nodeId,-1,1,0,integer[],1
+phylobase,nodeId,0,1,0,class<`phylo4`>,1
+phylobase,nodeId,0,1,1,class<`phylo4d`>,1
+phylobase,nodeId,1,1,0,character,1
+phylobase,nodeId,-1,2,0,integer[],1
+phylobase,nodeId,0,2,0,class<`phylo4`>,1
+phylobase,nodeId,1,2,0,character,1
+phylobase,nodeLabels,-1,0,0,^character[],1
+phylobase,nodeLabels,0,0,0,class<`phylo4`>,1
+phylobase,nodeLabels,-1,1,0,^character[],1
+phylobase,nodeLabels,0,1,0,class<`phylo4`>,1
+phylobase,nodeLabels,0,1,1,class<`phylo4d`>,1
+phylobase,nodeLabels,-1,2,0,^character[],1
+phylobase,nodeLabels,0,2,0,class<`phylo4d`>,1
+phylobase,nodeLabels<-,-1,0,0,class<`phylo4`>,1
+phylobase,nodeLabels<-,-1,0,1,class<`phylo4d`>,1
+phylobase,nodeLabels<-,0,0,0,class<`phylo4`>,1
+phylobase,nodeLabels<-,0,0,1,class<`phylo4d`>,1
+phylobase,nodeLabels<-,1,0,0,...,1
+phylobase,nodeLabels<-,2,0,0,character[],1
+phylobase,nodeLabels<-,-1,1,0,class<`phylo4`>,1
+phylobase,nodeLabels<-,0,1,0,class<`phylo4`>,1
+phylobase,nodeLabels<-,1,1,0,...,1
+phylobase,nodeLabels<-,2,1,0,character[],1
+phylobase,nodeLabels<-,-1,2,0,class<`phylo4d`>,1
+phylobase,nodeLabels<-,0,2,0,class<`phylo4d`>,1
+phylobase,nodeLabels<-,1,2,0,...,1
+phylobase,nodeLabels<-,2,2,0,character[],1
+phylobase,nodeType,-1,0,0,character[],1
+phylobase,nodeType,0,0,0,class<`phylo4`>,1
+phylobase,nodeType,-1,1,0,character[],1
+phylobase,nodeType,0,1,0,class<`phylo4`>,1
+phylobase,nodeType,0,1,1,class<`phylo4d`>,1
+phylobase,nodeType,-1,2,0,character[],1
+phylobase,nodeType,0,2,0,class<`phylo4d`>,1
+phylobase,nTips,-1,0,0,integer,1
+phylobase,nTips,0,0,0,class<`phylo4`>,1
+phylobase,nTips,-1,1,0,integer,1
+phylobase,nTips,0,1,0,class<`phylo`>,1
+phylobase,nTips,0,1,1,class<`phylo4`>,1
+phylobase,nTips,0,1,2,class<`phylo4d`>,1
+phylobase,nTips,-1,2,0,integer,1
+phylobase,nTips,0,2,0,class<`phylo4d`>,1
+phylobase,nTips,-1,3,0,integer,1
+phylobase,nTips,0,3,0,class<`phylo`>,1
+phylobase,nTipsFastCpp,-1,0,0,integer,1
+phylobase,nTipsFastCpp,0,0,0,integer[],1
+phylobase,orderIndex,-1,0,0,^integer[],1
+phylobase,orderIndex,0,0,0,class<`phylo4`>,1
+phylobase,orderIndex,0,0,1,class<`phylo4d`>,1
+phylobase,orderIndex,1,0,0,character,1
+phylobase,phylo4,-1,0,0,class<`phylo4`>,1
+phylobase,phylo4,0,0,0,class<`phylo`>,1
+phylobase,phylo4,1,0,0,...,1
+phylobase,phylo4,-1,1,0,any,1
+phylobase,phylo4,0,1,0,class<`matrix`>,1
+phylobase,phylo4,1,1,0,...,1
+phylobase,phylo4,-1,2,0,any,1
+phylobase,phylo4,0,2,0,class<`matrix`>,1
+phylobase,phylo4,0,2,1,class<`phylo`>,1
+phylobase,phylo4,1,2,0,...,1
+phylobase,phylo4d,-1,0,0,any,1
+phylobase,phylo4d,0,0,0,class<`phylo`>,1
+phylobase,phylo4d,0,0,1,class<`phylo4`>,1
+phylobase,phylo4d,1,0,0,...,1
+phylobase,phylo4d,-1,1,0,any,1
+phylobase,phylo4d,0,1,0,class<`phylo`>,1
+phylobase,phylo4d,1,1,0,...,1
+phylobase,phylo4d,-1,2,0,any,1
+phylobase,phylo4d,0,2,0,class<`phylo4`>,1
+phylobase,phylo4d,1,2,0,...,1
+phylobase,.phylo4Data,-1,0,0,class<`data.frame`>,1
+phylobase,.phylo4Data,0,0,0,class<`phylo4`>,1
+phylobase,.phylo4Data,0,0,1,class<`phylo4d`>,1
+phylobase,.phylo4Data,1,0,0,class<`data.frame`>,1
+phylobase,.phylo4Data,1,0,1,null,1
+phylobase,.phylo4Data,2,0,0,class<`data.frame`>,1
+phylobase,.phylo4Data,2,0,1,null,1
+phylobase,.phylo4Data,3,0,0,class<`data.frame`>,1
+phylobase,.phylo4Data,3,0,1,null,1
+phylobase,.phylo4Data,4,0,0,logical,1
+phylobase,.phylo4ToDataFrame,-1,0,0,class<`data.frame`>,1
+phylobase,.phylo4ToDataFrame,0,0,0,class<`phylo4d`>,1
+phylobase,.phylo4ToDataFrame,0,0,1,class<`phylo4`>,1
+phylobase,.phylo4ToDataFrame,1,0,0,character[],1
+phylobase,phylobase.options,-1,0,0,list<character>,1
+phylobase,phylobase.options,0,0,0,...,1
+phylobase,phylobubbles,-1,0,0,"class<`path`, `vpPath`>",1
+phylobase,phylobubbles,0,0,0,character,1
+phylobase,phylobubbles,1,0,0,character,1
+phylobase,phylobubbles,2,0,0,logical,1
+phylobase,phylobubbles,3,0,0,double,1
+phylobase,phylobubbles,4,0,0,character,1
+phylobase,phylobubbles,5,0,0,character,1
+phylobase,phylobubbles,6,0,0,any,1
+phylobase,phylobubbles,7,0,0,double,1
+phylobase,phyloXXYY,-1,0,0,list<double[] | class<`phylo4d`> | list<^double[]>>,1
+phylobase,phyloXXYY,-1,0,1,list<double[] | class<`phylo4`> | list<^double[]>>,1
+phylobase,phyloXXYY,0,0,0,class<`phylo4d`>,1
+phylobase,phyloXXYY,0,0,1,class<`phylo4`>,1
+phylobase,phyloXXYY,1,0,0,null,1
+phylobase,plot,-1,0,0,any,1
+phylobase,plot,0,0,0,class<`phylo4`>,1
+phylobase,plot,1,0,0,any,1
+phylobase,plot,2,0,0,...,1
+phylobase,plot,-1,1,0,"class<`path`, `vpPath`>",1
+phylobase,plot,0,1,0,class<`phylo4d`>,1
+phylobase,plot,1,1,0,any,1
+phylobase,plot,2,1,0,...,1
+phylobase,plotOneTree,-1,0,0,"class<`path`, `vpPath`>",1
+phylobase,plotOneTree,0,0,0,list<double[] | class<`phylo4d`> | list<^double[]>>,1
+phylobase,plotOneTree,0,0,1,list<double[] | class<`phylo4`> | list<^double[]>>,1
+phylobase,plotOneTree,1,0,0,character,1
+phylobase,plotOneTree,2,0,0,logical,1
+phylobase,plotOneTree,3,0,0,logical,1
+phylobase,plotOneTree,4,0,0,character,1
+phylobase,plotOneTree,5,0,0,character,1
+phylobase,plotOneTree,6,0,0,any,1
+phylobase,plotOneTree,7,0,0,double,1
+phylobase,print,-1,0,0,class<`data.frame`>,1
+phylobase,print,0,0,0,class<`phylo4d`>,1
+phylobase,print,1,0,0,...,1
+phylobase,print,-1,1,0,class<`data.frame`>,1
+phylobase,print,0,1,0,class<`phylo4`>,1
+phylobase,print,1,1,0,...,1
+phylobase,prune,-1,0,0,class<`phylo4d`>,1
+phylobase,prune,0,0,0,class<`phylo4d`>,1
+phylobase,prune,1,0,0,...,1
+phylobase,prune,-1,1,0,class<`phylo4`>,1
+phylobase,prune,-1,1,1,class<`phylo4d`>,1
+phylobase,prune,0,1,0,class<`phylo4`>,1
+phylobase,prune,0,1,1,class<`phylo4d`>,1
+phylobase,prune,1,1,0,...,1
+phylobase,prune,-1,2,0,class<`phylo4`>,1
+phylobase,prune,0,2,0,class<`phylo4`>,1
+phylobase,prune,1,2,0,...,1
+phylobase,reorder,-1,0,0,class<`phylo4`>,1
+phylobase,reorder,0,0,0,class<`phylo4`>,1
+phylobase,reorder,1,0,0,...,1
+phylobase,reorder,-1,1,0,class<`phylo4d`>,1
+phylobase,reorder,0,1,0,class<`phylo4d`>,1
+phylobase,reorder,1,1,0,...,1
+phylobase,rootNode,-1,0,0,integer,1
+phylobase,rootNode,0,0,0,class<`phylo4d`>,1
+phylobase,rootNode,-1,1,0,integer,1
+phylobase,rootNode,0,1,0,class<`phylo4`>,1
+phylobase,rootNode,-1,2,0,integer,1
+phylobase,rootNode,0,2,0,class<`phylo4`>,1
+phylobase,rootNode,0,2,1,class<`phylo4d`>,1
+phylobase,shortestPath,-1,0,0,integer[],1
+phylobase,shortestPath,0,0,0,class<`phylo4d`>,1
+phylobase,shortestPath,1,0,0,character,1
+phylobase,shortestPath,1,0,1,double,1
+phylobase,shortestPath,2,0,0,character,1
+phylobase,shortestPath,-1,1,0,integer[],1
+phylobase,shortestPath,0,1,0,class<`phylo4d`>,1
+phylobase,shortestPath,1,1,0,character,1
+phylobase,shortestPath,1,1,1,double,1
+phylobase,shortestPath,2,1,0,character,1
+phylobase,.shortestPathInt,-1,0,0,integer[],1
+phylobase,.shortestPathInt,0,0,0,class<`phylo4d`>,1
+phylobase,.shortestPathInt,1,0,0,character,1
+phylobase,.shortestPathInt,1,0,1,double,1
+phylobase,.shortestPathInt,2,0,0,character,1
+phylobase,siblings,-1,0,0,integer[],1
+phylobase,siblings,0,0,0,class<`phylo4d`>,1
+phylobase,siblings,1,0,0,double,1
+phylobase,siblings,2,0,0,logical,1
+phylobase,subset,-1,0,0,class<`phylo4d`>,1
+phylobase,subset,0,0,0,class<`phylo4d`>,1
+phylobase,subset,1,0,0,...,1
+phylobase,subset,-1,1,0,class<`phylo4`>,1
+phylobase,subset,0,1,0,class<`phylo4`>,1
+phylobase,subset,1,1,0,...,1
+phylobase,sumEdgeLength,-1,0,0,double,1
+phylobase,sumEdgeLength,0,0,0,class<`phylo4d`>,1
+phylobase,sumEdgeLength,1,0,0,integer[],1
+phylobase,sumEdgeLength,-1,1,0,double,1
+phylobase,sumEdgeLength,0,1,0,class<`phylo4`>,1
+phylobase,sumEdgeLength,1,1,0,integer[],1
+phylobase,sumEdgeLength,-1,2,0,double,1
+phylobase,sumEdgeLength,0,2,0,class<`phylo4`>,1
+phylobase,sumEdgeLength,0,2,1,class<`phylo4d`>,1
+phylobase,sumEdgeLength,1,2,0,integer[],1
+phylobase,summary,-1,0,0,list<^integer[] | character[]>,1
+phylobase,summary,-1,0,1,"list<character | double | class<`summaryDefault`, `table`>>",1
+phylobase,summary,0,0,0,class<`phylo4`>,1
+phylobase,summary,1,0,0,...,1
+phylobase,summary,-1,1,0,list<any>,1
+phylobase,summary,0,1,0,class<`phylo4d`>,1
+phylobase,summary,1,1,0,...,1
+phylobase,tabulateTips,-1,0,0,integer[],1
+phylobase,tabulateTips,0,0,0,integer[],1
+phylobase,tdata,-1,0,0,class<`data.frame`>,1
+phylobase,tdata,0,0,0,class<`phylo4d`>,1
+phylobase,tdata,1,0,0,...,1
+phylobase,tdata,-1,1,0,class<`data.frame`>,1
+phylobase,tdata,0,1,0,class<`phylo4d`>,1
+phylobase,tdata,1,1,0,...,1
+phylobase,tdata<-,-1,0,0,class<`phylo4d`>,1
+phylobase,tdata<-,0,0,0,class<`phylo4d`>,1
+phylobase,tdata<-,1,0,0,...,1
+phylobase,tdata<-,2,0,0,class<`data.frame`>,1
+phylobase,tdata<-,2,0,1,integer[],1
+phylobase,tdata<-,-1,1,0,class<`phylo4d`>,1
+phylobase,tdata<-,0,1,0,class<`phylo4d`>,1
+phylobase,tdata<-,1,1,0,...,1
+phylobase,tdata<-,2,1,0,class<`data.frame`>,1
+phylobase,tdata<-,2,1,1,integer[],1
+phylobase,terminalEdges,-1,0,0,logical[],1
+phylobase,terminalEdges,0,0,0,class<`phylo4d`>,1
+phylobase,terminalEdges,-1,1,0,logical[],1
+phylobase,terminalEdges,0,1,0,class<`phylo4d`>,1
+phylobase,tipData,-1,0,0,class<`data.frame`>,1
+phylobase,tipData,0,0,0,class<`phylo4d`>,1
+phylobase,tipData,1,0,0,...,1
+phylobase,tipData,-1,1,0,class<`data.frame`>,1
+phylobase,tipData,0,1,0,class<`phylo4d`>,1
+phylobase,tipData,1,1,0,...,1
+phylobase,tipData<-,-1,0,0,class<`phylo4d`>,1
+phylobase,tipData<-,0,0,0,class<`phylo4d`>,1
+phylobase,tipData<-,1,0,0,...,1
+phylobase,tipData<-,2,0,0,class<`data.frame`>,1
+phylobase,tipData<-,2,0,1,integer[],1
+phylobase,tipData<-,-1,1,0,class<`phylo4d`>,1
+phylobase,tipData<-,0,1,0,class<`phylo4d`>,1
+phylobase,tipData<-,1,1,0,...,1
+phylobase,tipData<-,2,1,0,class<`data.frame`>,1
+phylobase,tipData<-,2,1,1,integer[],1
+phylobase,tip.data.plot,-1,0,0,"class<`path`, `vpPath`>",1
+phylobase,tip.data.plot,0,0,0,list<double[] | class<`phylo4d`> | list<^double[]>>,1
+phylobase,tip.data.plot,1,0,0,character,1
+phylobase,tip.data.plot,2,0,0,logical,1
+phylobase,tip.data.plot,3,0,0,logical,1
+phylobase,tip.data.plot,4,0,0,double,1
+phylobase,tip.data.plot,5,0,0,class<`function`>,1
+phylobase,tip.data.plot,6,0,0,character,1
+phylobase,tip.data.plot,7,0,0,character,1
+phylobase,tipLabels,-1,0,0,character[],1
+phylobase,tipLabels,0,0,0,class<`phylo4d`>,1
+phylobase,tipLabels,-1,1,0,character[],1
+phylobase,tipLabels,0,1,0,class<`phylo4`>,1
+phylobase,tipLabels,0,1,1,class<`phylo4d`>,1
+phylobase,tipLabels,-1,2,0,character[],1
+phylobase,tipLabels,0,2,0,class<`phylo4`>,1
+phylobase,tipLabels<-,-1,0,0,class<`phylo4`>,1
+phylobase,tipLabels<-,0,0,0,class<`phylo4`>,1
+phylobase,tipLabels<-,1,0,0,...,1
+phylobase,tipLabels<-,2,0,0,character[],1
+phylobase,tipLabels<-,-1,1,0,class<`phylo4d`>,1
+phylobase,tipLabels<-,0,1,0,class<`phylo4d`>,1
+phylobase,tipLabels<-,1,1,0,...,1
+phylobase,tipLabels<-,2,1,0,character[],1
+phylobase,tipLabels<-,-1,2,0,class<`phylo4`>,1
+phylobase,tipLabels<-,-1,2,1,class<`phylo4d`>,1
+phylobase,tipLabels<-,0,2,0,class<`phylo4`>,1
+phylobase,tipLabels<-,0,2,1,class<`phylo4d`>,1
+phylobase,tipLabels<-,1,2,0,...,1
+phylobase,tipLabels<-,2,2,0,character[],1
+phylobase,tipsFast,-1,0,0,integer[],1
+phylobase,tipsFast,0,0,0,integer[],1
+phylobase,treePlot,-1,0,0,any,1
+phylobase,treePlot,0,0,0,class<`phylo4`>,1
+phylobase,treePlot,0,0,1,class<`phylo4d`>,1
+phylobase,treePlot,1,0,0,any,1
+phylobase,treePlot,2,0,0,logical,1
+phylobase,treePlot,3,0,0,logical,1
+phylobase,treePlot,4,0,0,null,1
+phylobase,treePlot,5,0,0,any,1
+phylobase,treePlot,6,0,0,double,1
+phylobase,treePlot,7,0,0,character,1
+phylobase,treePlot,7,0,1,class<`function`>,1
+pillar,align,-1,0,0,character[],1
+pillar,align,0,0,0,character[],1
+pillar,align,0,0,1,class<`pillar_ornament`>,1
+pillar,align,1,0,0,double,1
+pillar,align,1,0,1,null,1
+pillar,align,2,0,0,character[],1
+pillar,all_pillars_fit,-1,0,0,logical,1
+pillar,all_pillars_fit,0,0,0,class<`data.frame`>,1
+pillar,assemble_decimal,-1,0,0,character[],1
+pillar,assemble_decimal,0,0,0,list<character[] | double[] | ^integer[]>,1
+pillar,assign_crayon_styles,-1,0,0,class<`function`>,1
+pillar,big_mark,-1,0,0,character[],1
+pillar,big_mark,0,0,0,integer[],1
+pillar,big_mark,1,0,0,...,1
+pillar,bind_rows,-1,0,0,class<`data.frame`>,1
+pillar,bind_rows,0,0,0,list<class<`data.frame`>>,1
+pillar,cat_line,-1,0,0,null,1
+pillar,cat_line,0,0,0,...,1
+pillar,check_sigfig,-1,0,0,integer,1
+pillar,check_sigfig,0,0,0,double,1
+pillar,colonnade,-1,0,0,class<`pillar_colonnade`>,1
+pillar,colonnade,0,0,0,list<character>,1
+pillar,colonnade,0,0,1,class<`data.frame`>,1
+pillar,colonnade,0,0,2,list<integer[] | character[]>,1
+pillar,colonnade,0,0,3,list<integer[]>,1
+pillar,colonnade,1,0,0,logical,1
+pillar,colonnade,2,0,0,null,1
+pillar,colonnade,2,0,1,double,1
+pillar,colonnade,3,0,0,...,1
+pillar,colonnade_compute_tiered_col_widths,-1,0,0,class<`data.frame`>,1
+pillar,colonnade_compute_tiered_col_widths,0,0,0,list<class<`pillar_capital`>>,1
+pillar,colonnade_compute_tiered_col_widths,0,0,1,list<class<`pillar`>>,1
+pillar,colonnade_compute_tiered_col_widths,1,0,0,double,1
+pillar,colonnade_compute_tiered_col_widths_df,-1,0,0,class<`data.frame`>,1
+pillar,colonnade_compute_tiered_col_widths_df,0,0,0,class<`data.frame`>,1
+pillar,colonnade_compute_tiered_col_widths_df,1,0,0,double,1
+pillar,colonnade_compute_tiered_col_widths_df,2,0,0,any,1
+pillar,colonnade_distribute_space,-1,0,0,integer,1
+pillar,colonnade_distribute_space,0,0,0,double,1
+pillar,colonnade_distribute_space,1,0,0,null,1
+pillar,colonnade_distribute_space,2,0,0,any,1
+pillar,colonnade_distribute_space_df,-1,0,0,class<`data.frame`>,1
+pillar,colonnade_distribute_space_df,0,0,0,class<`data.frame`>,1
+pillar,colonnade_distribute_space_df,1,0,0,double,1
+pillar,colonnade_get_width,-1,0,0,class<`data.frame`>,1
+pillar,colonnade_get_width,0,0,0,class<`pillar_colonnade`>,1
+pillar,colonnade_get_width,1,0,0,double,1
+pillar,colonnade_get_width,2,0,0,integer,1
+pillar,compat_lengths,-1,0,0,null,1
+pillar,compute_exp,-1,0,0,^integer[],1
+pillar,compute_exp,0,0,0,^double[],1
+pillar,compute_exp,1,0,0,integer,1
+pillar,compute_rhs_digits,-1,0,0,double[],1
+pillar,compute_rhs_digits,0,0,0,^double[],1
+pillar,compute_rhs_digits,1,0,0,integer,1
+pillar,crayon_grey_0.6,-1,0,0,character[],1
+pillar,crayon_grey_0.6,0,0,0,...,1
+pillar,crayon_grey_0.8,-1,0,0,character[],1
+pillar,crayon_grey_0.8,0,0,0,...,1
+pillar,crayon_italic,-1,0,0,character[],1
+pillar,crayon_italic,0,0,0,...,1
+pillar,crayon_red,-1,0,0,character[],1
+pillar,crayon_red,0,0,0,...,1
+pillar,crayon_underline,-1,0,0,character[],1
+pillar,crayon_underline,0,0,0,...,1
+pillar,diff_to_trunc,-1,0,0,^double[],1
+pillar,diff_to_trunc,0,0,0,^double[],1
+pillar,dim2,-1,0,0,integer[],1
+pillar,dim2,0,0,0,class<`matrix`>,1
+pillar,dim2,0,0,1,class<`table`>,1
+pillar,dim2,0,0,2,class<`Date`>,1
+pillar,dim2,0,0,3,"class<`POSIXct`, `POSIXt`>",1
+pillar,dim2,0,0,4,integer[],1
+pillar,dim_desc,-1,0,0,character,1
+pillar,dim_desc,0,0,0,class<`Date`>,1
+pillar,dim_desc,0,0,1,class<`matrix`>,1
+pillar,dim_desc,0,0,2,"class<`POSIXct`, `POSIXt`>",1
+pillar,dim_desc,0,0,3,class<`table`>,1
+pillar,dim_desc,0,0,4,integer[],1
+pillar,distribute_pillars,-1,0,0,class<`data.frame`>,1
+pillar,distribute_pillars,0,0,0,double,1
+pillar,distribute_pillars,1,0,0,double,1
+pillar,expect_known_display,-1,0,0,class<`pillar_vertical`>,1
+pillar,expect_known_display,0,0,0,any,1
+pillar,expect_known_display,1,0,0,character,1
+pillar,expect_known_display,2,0,0,...,1
+pillar,expect_known_display,3,0,0,integer,1
+pillar,expect_known_display,4,0,0,logical,1
+pillar,extra_cols,-1,0,0,character,1
+pillar,extra_cols,0,0,0,class<`pillar_squeezed_colonnade`>,1
+pillar,extra_cols,1,0,0,...,1
+pillar,extra_cols.pillar_squeezed_colonnade,-1,0,0,character,1
+pillar,extra_cols.pillar_squeezed_colonnade,0,0,0,class<`pillar_squeezed_colonnade`>,1
+pillar,extra_cols.pillar_squeezed_colonnade,1,0,0,...,1
+pillar,extra_cols.pillar_squeezed_colonnade,2,0,0,double,1
+pillar,flatten_colonnade,-1,0,0,list<character>,1
+pillar,flatten_colonnade,-1,0,1,list<integer[] | character[]>,1
+pillar,flatten_colonnade,-1,0,2,list<integer[]>,1
+pillar,flatten_colonnade,-1,0,3,list<double[] | class<`factor`>>,1
+pillar,flatten_colonnade,0,0,0,list<character>,1
+pillar,flatten_colonnade,0,0,1,list<integer[] | character[]>,1
+pillar,flatten_colonnade,0,0,2,list<integer[]>,1
+pillar,flatten_colonnade,0,0,3,class<`data.frame`>,1
+pillar,format_dec,-1,0,0,character[],1
+pillar,format_dec,0,0,0,list<character[] | double[] | ^integer[]>,1
+pillar,format_decimal,-1,0,0,list<character[] | double[] | ^integer[]>,1
+pillar,format_decimal,-1,0,1,list<character | double | null>,1
+pillar,format_decimal,-1,0,2,list<character[] | ^double[]>,1
+pillar,format_decimal,0,0,0,^double[],1
+pillar,format_decimal,1,0,0,double,1
+pillar,format_decimal,2,0,0,...,1
+pillar,format_exp,-1,0,0,character[],1
+pillar,format_exp,0,0,0,list<character[] | double[] | ^integer[]>,1
+pillar,format_full_pillar_title,-1,0,0,character,1
+pillar,format_full_pillar_title,0,0,0,character,1
+pillar,format_full_pillar_type,-1,0,0,character,1
+pillar,format_full_pillar_type,0,0,0,integer[],1
+pillar,format_lhs,-1,0,0,character[],1
+pillar,format_lhs,0,0,0,list<character[] | double[] | ^integer[]>,1
+pillar,format_mantissa,-1,0,0,character[],1
+pillar,format_mantissa,0,0,0,list<character[] | double[] | ^integer[]>,1
+pillar,format_neg,-1,0,0,character[],1
+pillar,format_neg,0,0,0,list<character[] | double[] | ^integer[]>,1
+pillar,format.pillar,-1,0,0,class<`pillar_vertical`>,1
+pillar,format.pillar,0,0,0,class<`pillar`>,1
+pillar,format.pillar,1,0,0,null,1
+pillar,format.pillar,2,0,0,...,1
+pillar,format.pillar_capital,-1,0,0,character[],1
+pillar,format.pillar_capital,0,0,0,class<`pillar_capital`>,1
+pillar,format.pillar_capital,1,0,0,any,1
+pillar,format.pillar_capital,2,0,0,...,1
+pillar,format.pillar_colonnade,-1,0,0,class<`pillar_vertical`>,1
+pillar,format.pillar_colonnade,0,0,0,class<`pillar_colonnade`>,1
+pillar,format.pillar_colonnade,1,0,0,...,1
+pillar,format.pillar_rif_shaft,-1,0,0,class<`pillar_ornament`>,1
+pillar,format.pillar_rif_shaft,0,0,0,"class<`pillar_rif_shaft`, `pillar_shaft`>",1
+pillar,format.pillar_rif_shaft,1,0,0,integer,1
+pillar,format.pillar_rif_shaft,2,0,0,...,1
+pillar,format.pillar_rif_title,-1,0,0,character[],1
+pillar,format.pillar_rif_title,0,0,0,class<`pillar_rif_title`>,1
+pillar,format.pillar_rif_title,1,0,0,any,1
+pillar,format.pillar_rif_title,2,0,0,...,1
+pillar,format.pillar_rif_type,-1,0,0,character,1
+pillar,format.pillar_rif_type,0,0,0,class<`pillar_rif_type`>,1
+pillar,format.pillar_rif_type,1,0,0,any,1
+pillar,format.pillar_rif_type,2,0,0,...,1
+pillar,format.pillar_shaft_decimal,-1,0,0,class<`pillar_ornament`>,1
+pillar,format.pillar_shaft_decimal,0,0,0,"class<`pillar_shaft`, `pillar_shaft_decimal`>",1
+pillar,format.pillar_shaft_decimal,1,0,0,integer,1
+pillar,format.pillar_shaft_decimal,2,0,0,...,1
+pillar,format.pillar_shaft_simple,-1,0,0,class<`pillar_ornament`>,1
+pillar,format.pillar_shaft_simple,0,0,0,"class<`pillar_shaft`, `pillar_shaft_simple`>",1
+pillar,format.pillar_shaft_simple,1,0,0,double,1
+pillar,format.pillar_shaft_simple,2,0,0,...,1
+pillar,format.pillar_squeezed_colonnade,-1,0,0,class<`pillar_vertical`>,1
+pillar,format.pillar_squeezed_colonnade,0,0,0,class<`pillar_squeezed_colonnade`>,1
+pillar,format.pillar_squeezed_colonnade,1,0,0,...,1
+pillar,format.pillar_title,-1,0,0,character[],1
+pillar,format.pillar_title,0,0,0,class<`pillar_title`>,1
+pillar,format.pillar_title,1,0,0,any,1
+pillar,format.pillar_title,2,0,0,...,1
+pillar,format.pillar_type,-1,0,0,character,1
+pillar,format.pillar_type,0,0,0,class<`pillar_type`>,1
+pillar,format.pillar_type,1,0,0,double,1
+pillar,format.pillar_type,1,0,1,null,1
+pillar,format.pillar_type,2,0,0,...,1
+pillar,format_rhs,-1,0,0,character[],1
+pillar,format_rhs,0,0,0,list<character[] | double[] | ^integer[]>,1
+pillar,format_scientific,-1,0,0,list<character[] | double[]>,1
+pillar,format_scientific,-1,0,1,list<character | double>,1
+pillar,format_scientific,-1,0,2,list<character[] | ^double[]>,1
+pillar,format_scientific,0,0,0,^double[],1
+pillar,format_scientific,1,0,0,double,1
+pillar,format_title,-1,0,0,character[],1
+pillar,format_title,0,0,0,character[],1
+pillar,format_title,1,0,0,double,1
+pillar,format_type_sum,-1,0,0,character,1
+pillar,format_type_sum,0,0,0,character,1
+pillar,format_type_sum,0,0,1,class<`type_sum_accel`>,1
+pillar,format_type_sum,0,0,2,double,1
+pillar,format_type_sum,1,0,0,double,1
+pillar,format_type_sum,1,0,1,null,1
+pillar,format_type_sum,2,0,0,...,1
+pillar,format_type_sum.default,-1,0,0,character,1
+pillar,format_type_sum.default,0,0,0,character,1
+pillar,format_type_sum.default,0,0,1,double,1
+pillar,format_type_sum.default,1,0,0,double,1
+pillar,format_type_sum.default,1,0,1,null,1
+pillar,format_type_sum.default,2,0,0,...,1
+pillar,get_decimal_width,-1,0,0,double,1
+pillar,get_decimal_width,0,0,0,list<character[] | double[]>,1
+pillar,get_decimal_width,0,0,1,list<character | double>,1
+pillar,get_decimal_width,0,0,2,list<character[] | double[] | ^integer[]>,1
+pillar,get_decimal_width,0,0,3,list<character | double | null>,1
+pillar,get_decimal_width,0,0,4,list<character[] | ^double[]>,1
+pillar,get_ellipsis,-1,0,0,character,1
+pillar,get_extent,-1,0,0,integer[],1
+pillar,get_extent,0,0,0,character[],1
+pillar,get_extent,0,0,1,class<`pillar_ornament`>,1
+pillar,get_extent,0,0,2,class<`pillar_vertical`>,1
+pillar,get_max_extent,-1,0,0,integer,1
+pillar,get_max_extent,0,0,0,character[],1
+pillar,get_max_extent,0,0,1,class<`pillar_vertical`>,1
+pillar,get_min_title_width,-1,0,0,integer,1
+pillar,get_min_title_width,0,0,0,integer,1
+pillar,get_min_width,-1,0,0,integer,1
+pillar,get_min_width,0,0,0,class<`pillar_capital`>,1
+pillar,get_min_width,0,0,1,"class<`pillar_shaft`, `pillar_shaft_decimal`>",1
+pillar,get_min_width,0,0,2,"class<`pillar_shaft`, `pillar_shaft_simple`>",1
+pillar,get_min_width,0,0,3,class<`pillar_title`>,1
+pillar,get_min_width,0,0,4,class<`pillar_type`>,1
+pillar,get_min_width,0,0,5,list<character[] | double[]>,1
+pillar,get_min_width,0,0,6,list<character | double>,1
+pillar,get_min_width,0,0,7,list<character[] | double[] | ^integer[]>,1
+pillar,get_min_width,0,0,8,list<character | double | null>,1
+pillar,get_min_width,0,0,9,list<character[] | ^double[]>,1
+pillar,get_min_width,0,0,10,class<`pillar_rif_title`>,1
+pillar,get_min_width,0,0,11,class<`pillar_rif_type`>,1
+pillar,get_min_widths,-1,0,0,integer[],1
+pillar,get_min_widths,0,0,0,class<`pillar`>,1
+pillar,get_min_widths,0,0,1,class<`pillar_capital`>,1
+pillar,get_min_widths,0,0,2,list<list<character[] | double[] | ^integer[] | character[] | double[]>>,1
+pillar,get_min_widths,0,0,3,list<list<character | double | null | character | double>>,1
+pillar,get_min_widths,0,0,4,list<list<character[] | ^double[]>>,1
+pillar,get_pillar_type,-1,0,0,character,1
+pillar,get_pillar_type,-1,0,1,class<`type_sum_accel`>,1
+pillar,get_pillar_type,0,0,0,^character[],1
+pillar,get_pillar_type,0,0,1,class<`Date`>,1
+pillar,get_pillar_type,0,0,2,class<`factor`>,1
+pillar,get_pillar_type,0,0,3,"class<`POSIXct`, `POSIXt`>",1
+pillar,get_pillar_type,0,0,4,^double[],1
+pillar,get_pillar_type,0,0,5,class<`accel`>,1
+pillar,get_rowid_from_colonnade,-1,0,0,class<`pillar`>,1
+pillar,get_rowid_from_colonnade,0,0,0,class<`pillar_colonnade`>,1
+pillar,get_tier_widths,-1,0,0,double,1
+pillar,get_tier_widths,0,0,0,double,1
+pillar,get_tier_widths,1,0,0,any,1
+pillar,get_tier_widths,2,0,0,integer,1
+pillar,get_tier_widths,3,0,0,integer,1
+pillar,get_width,-1,0,0,integer,1
+pillar,get_width,-1,0,1,null,1
+pillar,get_width,0,0,0,class<`pillar_capital`>,1
+pillar,get_width,0,0,1,"class<`pillar_rif_shaft`, `pillar_shaft`>",1
+pillar,get_width,0,0,2,"class<`pillar_shaft`, `pillar_shaft_decimal`>",1
+pillar,get_width,0,0,3,"class<`pillar_shaft`, `pillar_shaft_simple`>",1
+pillar,get_width,0,0,4,class<`pillar_title`>,1
+pillar,get_width,0,0,5,class<`pillar_type`>,1
+pillar,get_width,0,0,6,class<`pillar_colonnade`>,1
+pillar,get_width,0,0,7,class<`pillar_rif_title`>,1
+pillar,get_width,0,0,8,class<`pillar_rif_type`>,1
+pillar,get_width,0,0,9,list<character[] | double[]>,1
+pillar,get_width,0,0,10,list<character | double>,1
+pillar,get_width,0,0,11,list<character[] | double[] | ^integer[]>,1
+pillar,get_width,0,0,12,list<character | double | null>,1
+pillar,get_width,0,0,13,list<character[] | ^double[]>,1
+pillar,get_width,0,0,14,class<`pillar`>,1
+pillar,get_widths,-1,0,0,integer[],1
+pillar,get_widths,0,0,0,class<`pillar`>,1
+pillar,get_widths,0,0,1,class<`pillar_capital`>,1
+pillar,has_color,-1,0,0,logical,1
+pillar,has_color,0,0,0,logical,1
+pillar,is_ambiguous_string,-1,0,0,logical[],1
+pillar,is_ambiguous_string,0,0,0,^character[],1
+pillar,is_syntactic,-1,0,0,logical[],1
+pillar,is_syntactic,0,0,0,null,1
+pillar,is_syntactic,0,0,1,character,1
+pillar,is_vector_s3,-1,0,0,logical,1
+pillar,is_vector_s3,0,0,0,class<`Date`>,1
+pillar,is_vector_s3,0,0,1,class<`function`>,1
+pillar,is_vector_s3,0,0,2,class<`matrix`>,1
+pillar,is_vector_s3,0,0,3,"class<`POSIXct`, `POSIXt`>",1
+pillar,is_vector_s3,0,0,4,integer[],1
+pillar,is_vector_s3.Date,-1,0,0,logical,1
+pillar,is_vector_s3.Date,0,0,0,class<`Date`>,1
+pillar,is_vector_s3.Date,0,0,1,"class<`POSIXct`, `POSIXt`>",1
+pillar,is_vector_s3.default,-1,0,0,logical,1
+pillar,is_vector_s3.default,0,0,0,class<`function`>,1
+pillar,is_vector_s3.default,0,0,1,class<`matrix`>,1
+pillar,is_vector_s3.default,0,0,2,integer[],1
+pillar,is_vector_s3.POSIXct,-1,0,0,logical,1
+pillar,is_vector_s3.POSIXct,0,0,0,class<`Date`>,1
+pillar,is_vector_s3.POSIXct,0,0,1,"class<`POSIXct`, `POSIXt`>",1
+pillar,make_style_fast,-1,0,0,class<`function`>,1
+pillar,make_style_fast,0,0,0,...,1
+pillar,make_style_fast_16,-1,0,0,class<`function`>,1
+pillar,make_style_fast_16,0,0,0,...,1
+pillar,map,-1,0,0,list<character[]>,1
+pillar,map,-1,0,1,list<class<`pillar_capital`>>,1
+pillar,map,-1,0,2,"list<class<`pillar_shaft`, `pillar_shaft_simple`>>",1
+pillar,map,-1,0,3,list<integer[]>,1
+pillar,map,-1,0,4,list<list<list<character[]>>>,1
+pillar,map,-1,0,5,"list<class<`pillar_shaft`, `pillar_shaft_decimal`>>",1
+pillar,map,0,0,0,list<character[]>,1
+pillar,map,0,0,1,list<list<character>>,1
+pillar,map,0,0,2,double[],1
+pillar,map,0,0,3,list<class<`pillar`>>,1
+pillar,map,0,0,4,list<class<`pillar_capital`>>,1
+pillar,map,0,0,5,class<`pillar_squeezed_colonnade`>,1
+pillar,map,0,0,6,list<class<`data.frame`>>,1
+pillar,map,0,0,7,list<list<list<character[]>>>,1
+pillar,map,0,0,8,list<integer[]>,1
+pillar,map,1,0,0,class<`function`>,1
+pillar,map,2,0,0,...,1
+pillar,map2,-1,0,0,list<character[]>,1
+pillar,map2,-1,0,1,list<class<`pillar`>>,1
+pillar,map2,-1,0,2,list<integer[]>,1
+pillar,map2,-1,0,3,list<list<integer[] | character[]>>,1
+pillar,map2,-1,0,4,list<list<integer[]>>,1
+pillar,map2,-1,0,5,list<list<double[] | class<`factor`>>>,1
+pillar,map2,-1,0,6,list<class<`data.frame`>>,1
+pillar,map2,-1,0,7,list<class<`pillar_capital`>>,1
+pillar,map2,-1,0,8,list<list<character[]>>,1
+pillar,map2,0,0,0,list<character[]>,1
+pillar,map2,0,0,1,list<class<`pillar_capital`>>,1
+pillar,map2,0,0,2,double[],1
+pillar,map2,0,0,3,list<integer[] | character[]>,1
+pillar,map2,0,0,4,list<integer[]>,1
+pillar,map2,0,0,5,list<class<`pillar`>>,1
+pillar,map2,0,0,6,class<`data.frame`>,1
+pillar,map2,0,0,7,list<class<`data.frame`>>,1
+pillar,map2,1,0,0,list<integer[]>,1
+pillar,map2,1,0,1,"list<class<`pillar_shaft`, `pillar_shaft_simple`>>",1
+pillar,map2,1,0,2,double[],1
+pillar,map2,1,0,3,list<null>,1
+pillar,map2,1,0,4,character[],1
+pillar,map2,1,0,5,"list<class<`pillar_shaft`, `pillar_shaft_decimal`>>",1
+pillar,map2,2,0,0,class<`function`>,1
+pillar,map2,3,0,0,...,1
+pillar,map2_chr,-1,0,0,character,1
+pillar,map2_chr,0,0,0,list<integer[]>,1
+pillar,map2_chr,1,0,0,character,1
+pillar,map2_chr,2,0,0,class<`function`>,1
+pillar,map2_chr,3,0,0,...,1
+pillar,map_chr,-1,0,0,character[],1
+pillar,map_chr,0,0,0,list<character[]>,1
+pillar,map_chr,1,0,0,class<`function`>,1
+pillar,map_chr,2,0,0,...,1
+pillar,map_chr_named,-1,0,0,character,1
+pillar,map_chr_named,0,0,0,list<integer[]>,1
+pillar,map_chr_named,1,0,0,class<`function`>,1
+pillar,map_int,-1,0,0,integer[],1
+pillar,map_int,0,0,0,list<integer[]>,1
+pillar,map_int,0,0,1,class<`pillar`>,1
+pillar,map_int,0,0,2,list<list<character[] | double[] | ^integer[] | character[] | double[]>>,1
+pillar,map_int,0,0,3,list<list<character | double | null | character | double>>,1
+pillar,map_int,0,0,4,list<list<character[] | ^double[]>>,1
+pillar,map_int,0,0,5,class<`pillar_capital`>,1
+pillar,map_int,1,0,0,class<`function`>,1
+pillar,map_int,2,0,0,...,1
+pillar,map_mold,-1,0,0,character[],1
+pillar,map_mold,-1,0,1,integer[],1
+pillar,map_mold,0,0,0,list<character[]>,1
+pillar,map_mold,0,0,1,list<integer[]>,1
+pillar,map_mold,0,0,2,class<`pillar`>,1
+pillar,map_mold,0,0,3,list<list<character[] | double[] | ^integer[] | character[] | double[]>>,1
+pillar,map_mold,0,0,4,list<list<character | double | null | character | double>>,1
+pillar,map_mold,0,0,5,list<list<character[] | ^double[]>>,1
+pillar,map_mold,0,0,6,class<`pillar_capital`>,1
+pillar,map_mold,1,0,0,class<`function`>,1
+pillar,map_mold,2,0,0,character,1
+pillar,map_mold,2,0,1,integer,1
+pillar,map_mold,3,0,0,...,1
+pillar,map_named,-1,0,0,list<class<`pillar_capital`>>,1
+pillar,map_named,0,0,0,list<character>,1
+pillar,map_named,0,0,1,list<integer[]>,1
+pillar,map_named,1,0,0,class<`function`>,1
+pillar,mult_sign,-1,0,0,character,1
+pillar,new_colonnade_sqeezed,-1,0,0,class<`pillar_squeezed_colonnade`>,1
+pillar,new_colonnade_sqeezed,0,0,0,list<list<list<character[]>>>,1
+pillar,new_colonnade_sqeezed,1,0,0,class<`pillar_colonnade`>,1
+pillar,new_colonnade_sqeezed,2,0,0,integer[],1
+pillar,new_ornament,-1,0,0,class<`pillar_ornament`>,1
+pillar,new_ornament,0,0,0,character[],1
+pillar,new_ornament,1,0,0,null,1
+pillar,new_ornament,1,0,1,double,1
+pillar,new_ornament,2,0,0,character,1
+pillar,new_pillar,-1,0,0,class<`pillar`>,1
+pillar,new_pillar,0,0,0,class<`pillar_capital`>,1
+pillar,new_pillar,1,0,0,"class<`pillar_rif_shaft`, `pillar_shaft`>",1
+pillar,new_pillar,1,0,1,"class<`pillar_shaft`, `pillar_shaft_decimal`>",1
+pillar,new_pillar,1,0,2,"class<`pillar_shaft`, `pillar_shaft_simple`>",1
+pillar,new_pillar,2,0,0,null,1
+pillar,new_pillar,2,0,1,double,1
+pillar,new_pillar_capital,-1,0,0,class<`pillar_capital`>,1
+pillar,new_pillar_capital,0,0,0,class<`pillar_rif_title`>,1
+pillar,new_pillar_capital,0,0,1,class<`pillar_title`>,1
+pillar,new_pillar_capital,1,0,0,class<`pillar_rif_type`>,1
+pillar,new_pillar_capital,1,0,1,class<`pillar_type`>,1
+pillar,new_pillar_shaft,-1,0,0,"class<`pillar_rif_shaft`, `pillar_shaft`>",1
+pillar,new_pillar_shaft,-1,0,1,"class<`pillar_shaft`, `pillar_shaft_decimal`>",1
+pillar,new_pillar_shaft,-1,0,2,"class<`pillar_shaft`, `pillar_shaft_simple`>",1
+pillar,new_pillar_shaft,0,0,0,list<integer>,1
+pillar,new_pillar_shaft,0,0,1,list<list<character[] | double[] | ^integer[] | character[] | double[]>>,1
+pillar,new_pillar_shaft,0,0,2,list<list<character | double | null | character | double>>,1
+pillar,new_pillar_shaft,0,0,3,list<list<character[] | ^double[]>>,1
+pillar,new_pillar_shaft,0,0,4,list<^character[]>,1
+pillar,new_pillar_shaft,0,0,5,list<null>,1
+pillar,new_pillar_shaft,0,0,6,list<class<`pillar_vertical`>>,1
+pillar,new_pillar_shaft,1,0,0,...,1
+pillar,new_pillar_shaft,2,0,0,double,1
+pillar,new_pillar_shaft,3,0,0,integer,1
+pillar,new_pillar_shaft,3,0,1,null,1
+pillar,new_pillar_shaft,4,0,0,character,1
+pillar,new_pillar_shaft,5,0,0,null,1
+pillar,new_pillar_shaft_simple,-1,0,0,"class<`pillar_shaft`, `pillar_shaft_simple`>",1
+pillar,new_pillar_shaft_simple,0,0,0,^character[],1
+pillar,new_pillar_shaft_simple,0,0,1,null,1
+pillar,new_pillar_shaft_simple,0,0,2,class<`pillar_vertical`>,1
+pillar,new_pillar_shaft_simple,1,0,0,...,1
+pillar,new_pillar_shaft_simple,2,0,0,double,1
+pillar,new_pillar_shaft_simple,3,0,0,character,1
+pillar,new_pillar_shaft_simple,4,0,0,null,1
+pillar,new_pillar_shaft_simple,4,0,1,integer,1
+pillar,new_pillar_shaft_simple,5,0,0,null,1
+pillar,new_pillar_shaft_simple,5,0,1,character,1
+pillar,new_pillar_shaft_simple,6,0,0,double,1
+pillar,new_pillar_title,-1,0,0,class<`pillar_title`>,1
+pillar,new_pillar_title,0,0,0,character[],1
+pillar,new_pillar_title,0,0,1,null,1
+pillar,new_pillar_title,1,0,0,...,1
+pillar,new_pillar_type,-1,0,0,class<`pillar_type`>,1
+pillar,new_pillar_type,0,0,0,^character[],1
+pillar,new_pillar_type,0,0,1,class<`accel`>,1
+pillar,new_pillar_type,0,0,2,class<`Date`>,1
+pillar,new_pillar_type,0,0,3,class<`factor`>,1
+pillar,new_pillar_type,0,0,4,"class<`POSIXct`, `POSIXt`>",1
+pillar,new_pillar_type,0,0,5,^double[],1
+pillar,new_pillar_type,1,0,0,...,1
+pillar,new_vertical,-1,0,0,class<`pillar_vertical`>,1
+pillar,new_vertical,0,0,0,^character[],1
+pillar,new_vertical,1,0,0,...,1
+pillar,new_vertical,2,0,0,null,1
+pillar,obj_sum,-1,0,0,character,1
+pillar,obj_sum,0,0,0,class<`Date`>,1
+pillar,obj_sum,0,0,1,class<`function`>,1
+pillar,obj_sum,0,0,2,class<`matrix`>,1
+pillar,obj_sum,0,0,3,"class<`POSIXct`, `POSIXt`>",1
+pillar,obj_sum,0,0,4,integer[],1
+pillar,obj_sum.default,-1,0,0,character,1
+pillar,obj_sum.default,0,0,0,class<`Date`>,1
+pillar,obj_sum.default,0,0,1,class<`function`>,1
+pillar,obj_sum.default,0,0,2,class<`matrix`>,1
+pillar,obj_sum.default,0,0,3,"class<`POSIXct`, `POSIXt`>",1
+pillar,obj_sum.default,0,0,4,integer[],1
+pillar,pillar,-1,0,0,class<`pillar`>,1
+pillar,pillar,0,0,0,^character[],1
+pillar,pillar,0,0,1,class<`accel`>,1
+pillar,pillar,0,0,2,class<`Date`>,1
+pillar,pillar,0,0,3,class<`factor`>,1
+pillar,pillar,0,0,4,"class<`POSIXct`, `POSIXt`>",1
+pillar,pillar,0,0,5,^double[],1
+pillar,pillar,1,0,0,null,1
+pillar,pillar,1,0,1,character,1
+pillar,pillar,2,0,0,null,1
+pillar,pillar,2,0,1,double,1
+pillar,pillar,3,0,0,...,1
+pillar,pillar_capital,-1,0,0,class<`pillar_capital`>,1
+pillar,pillar_capital,0,0,0,^character[],1
+pillar,pillar_capital,0,0,1,class<`accel`>,1
+pillar,pillar_capital,0,0,2,class<`Date`>,1
+pillar,pillar_capital,0,0,3,class<`factor`>,1
+pillar,pillar_capital,0,0,4,"class<`POSIXct`, `POSIXt`>",1
+pillar,pillar_capital,0,0,5,^double[],1
+pillar,pillar_capital,1,0,0,null,1
+pillar,pillar_capital,1,0,1,character,1
+pillar,pillar_capital,2,0,0,...,1
+pillar,pillar_format_parts,-1,0,0,list<character[]>,1
+pillar,pillar_format_parts,0,0,0,class<`pillar`>,1
+pillar,pillar_format_parts,1,0,0,double,1
+pillar,pillar_format_parts,2,0,0,...,1
+pillar,pillar_get_width,-1,0,0,integer,1
+pillar,pillar_get_width,0,0,0,class<`pillar`>,1
+pillar,pillar_get_width,1,0,0,null,1
+pillar,pillar_na,-1,0,0,character,1
+pillar,pillar_na,0,0,0,logical,1
+pillar,pillar_shaft,-1,0,0,"class<`pillar_shaft`, `pillar_shaft_simple`>",1
+pillar,pillar_shaft,-1,0,1,"class<`pillar_shaft`, `pillar_shaft_decimal`>",1
+pillar,pillar_shaft,0,0,0,^double[],1
+pillar,pillar_shaft,0,0,1,class<`Date`>,1
+pillar,pillar_shaft,0,0,2,"class<`POSIXct`, `POSIXt`>",1
+pillar,pillar_shaft,0,0,3,null,1
+pillar,pillar_shaft,0,0,4,^character[],1
+pillar,pillar_shaft,0,0,5,class<`accel`>,1
+pillar,pillar_shaft,0,0,6,class<`factor`>,1
+pillar,pillar_shaft,0,0,7,class<`pillar_vertical`>,1
+pillar,pillar_shaft,1,0,0,...,1
+pillar,pillar_shaft.character,-1,0,0,"class<`pillar_shaft`, `pillar_shaft_simple`>",1
+pillar,pillar_shaft.character,0,0,0,^character[],1
+pillar,pillar_shaft.character,1,0,0,...,1
+pillar,pillar_shaft.character,2,0,0,integer,1
+pillar,pillar_shaft.Date,-1,0,0,"class<`pillar_shaft`, `pillar_shaft_simple`>",1
+pillar,pillar_shaft.Date,0,0,0,class<`Date`>,1
+pillar,pillar_shaft.Date,1,0,0,...,1
+pillar,pillar_shaft.default,-1,0,0,"class<`pillar_shaft`, `pillar_shaft_simple`>",1
+pillar,pillar_shaft.default,0,0,0,class<`accel`>,1
+pillar,pillar_shaft.default,1,0,0,...,1
+pillar,pillar_shaft.factor,-1,0,0,"class<`pillar_shaft`, `pillar_shaft_simple`>",1
+pillar,pillar_shaft.factor,0,0,0,class<`factor`>,1
+pillar,pillar_shaft.factor,1,0,0,...,1
+pillar,pillar_shaft.logical,-1,0,0,"class<`pillar_shaft`, `pillar_shaft_simple`>",1
+pillar,pillar_shaft.logical,0,0,0,^logical[],1
+pillar,pillar_shaft.logical,0,0,1,null,1
+pillar,pillar_shaft.logical,1,0,0,...,1
+pillar,pillar_shaft.numeric,-1,0,0,"class<`pillar_shaft`, `pillar_shaft_decimal`>",1
+pillar,pillar_shaft.numeric,0,0,0,^double[],1
+pillar,pillar_shaft.numeric,1,0,0,...,1
+pillar,pillar_shaft.numeric,2,0,0,double,1
+pillar,pillar_shaft.pillar_vertical,-1,0,0,"class<`pillar_shaft`, `pillar_shaft_simple`>",1
+pillar,pillar_shaft.pillar_vertical,0,0,0,class<`pillar_vertical`>,1
+pillar,pillar_shaft.pillar_vertical,1,0,0,...,1
+pillar,pillar_shaft.pillar_vertical,2,0,0,integer,1
+pillar,pillar_shaft.pillar_vertical,3,0,0,double,1
+pillar,pillar_shaft.POSIXt,-1,0,0,"class<`pillar_shaft`, `pillar_shaft_simple`>",1
+pillar,pillar_shaft.POSIXt,0,0,0,"class<`POSIXct`, `POSIXt`>",1
+pillar,pillar_shaft.POSIXt,1,0,0,...,1
+pillar,print.pillar,-1,0,0,class<`pillar_vertical`>,1
+pillar,print.pillar,0,0,0,class<`pillar`>,1
+pillar,print.pillar,0,0,1,class<`pillar_colonnade`>,1
+pillar,print.pillar,1,0,0,...,1
+pillar,print.pillar_colonnade,-1,0,0,class<`pillar_vertical`>,1
+pillar,print.pillar_colonnade,0,0,0,class<`pillar`>,1
+pillar,print.pillar_colonnade,0,0,1,class<`pillar_colonnade`>,1
+pillar,print.pillar_colonnade,1,0,0,...,1
+pillar,print.pillar_vertical,-1,0,0,class<`pillar_vertical`>,1
+pillar,print.pillar_vertical,0,0,0,class<`pillar_vertical`>,1
+pillar,print.pillar_vertical,1,0,0,...,1
+pillar,register_s3_method,-1,0,0,null,1
+pillar,register_s3_method,0,0,0,character,1
+pillar,register_s3_method,1,0,0,character,1
+pillar,register_s3_method,2,0,0,character,1
+pillar,register_s3_method,3,0,0,null,1
+pillar,rif_capital,-1,0,0,class<`pillar_capital`>,1
+pillar,rif_capital,0,0,0,logical,1
+pillar,rif_capital,1,0,0,logical,1
+pillar,rif_capital,2,0,0,...,1
+pillar,rif_shaft,-1,0,0,"class<`pillar_rif_shaft`, `pillar_shaft`>",1
+pillar,rif_shaft,0,0,0,integer,1
+pillar,rif_shaft,1,0,0,...,1
+pillar,rif_title,-1,0,0,class<`pillar_rif_title`>,1
+pillar,rif_title,0,0,0,logical,1
+pillar,rif_title,1,0,0,...,1
+pillar,rif_type,-1,0,0,class<`pillar_rif_type`>,1
+pillar,rif_type,0,0,0,logical,1
+pillar,rif_type,1,0,0,...,1
+pillar,rowidformat,-1,0,0,class<`pillar`>,1
+pillar,rowidformat,0,0,0,integer,1
+pillar,rowidformat,1,0,0,logical,1
+pillar,rowidformat,2,0,0,logical,1
+pillar,rowidformat,3,0,0,...,1
+pillar,safe_signif,-1,0,0,^double[],1
+pillar,safe_signif,0,0,0,^double[],1
+pillar,safe_signif,1,0,0,double[],1
+pillar,set_min_width,-1,0,0,class<`pillar_capital`>,1
+pillar,set_min_width,-1,0,1,"class<`pillar_rif_shaft`, `pillar_shaft`>",1
+pillar,set_min_width,-1,0,2,"class<`pillar_shaft`, `pillar_shaft_decimal`>",1
+pillar,set_min_width,-1,0,3,"class<`pillar_shaft`, `pillar_shaft_simple`>",1
+pillar,set_min_width,-1,0,4,class<`pillar_title`>,1
+pillar,set_min_width,-1,0,5,class<`pillar_type`>,1
+pillar,set_min_width,0,0,0,class<`pillar_capital`>,1
+pillar,set_min_width,0,0,1,"class<`pillar_rif_shaft`, `pillar_shaft`>",1
+pillar,set_min_width,0,0,2,"class<`pillar_shaft`, `pillar_shaft_decimal`>",1
+pillar,set_min_width,0,0,3,"class<`pillar_shaft`, `pillar_shaft_simple`>",1
+pillar,set_min_width,0,0,4,class<`pillar_title`>,1
+pillar,set_min_width,0,0,5,class<`pillar_type`>,1
+pillar,set_min_width,1,0,0,integer,1
+pillar,set_min_width,1,0,1,null,1
+pillar,set_width,-1,0,0,class<`pillar`>,1
+pillar,set_width,-1,0,1,class<`pillar_capital`>,1
+pillar,set_width,-1,0,2,class<`pillar_colonnade`>,1
+pillar,set_width,-1,0,3,class<`pillar_ornament`>,1
+pillar,set_width,-1,0,4,"class<`pillar_rif_shaft`, `pillar_shaft`>",1
+pillar,set_width,-1,0,5,class<`pillar_rif_title`>,1
+pillar,set_width,-1,0,6,class<`pillar_rif_type`>,1
+pillar,set_width,-1,0,7,"class<`pillar_shaft`, `pillar_shaft_decimal`>",1
+pillar,set_width,-1,0,8,"class<`pillar_shaft`, `pillar_shaft_simple`>",1
+pillar,set_width,-1,0,9,class<`pillar_title`>,1
+pillar,set_width,-1,0,10,class<`pillar_type`>,1
+pillar,set_width,-1,0,11,list<character[] | double[]>,1
+pillar,set_width,-1,0,12,list<character | double>,1
+pillar,set_width,-1,0,13,list<character[] | double[] | ^integer[]>,1
+pillar,set_width,-1,0,14,list<character | double | null>,1
+pillar,set_width,-1,0,15,list<character[] | ^double[]>,1
+pillar,set_width,0,0,0,class<`pillar`>,1
+pillar,set_width,0,0,1,class<`pillar_capital`>,1
+pillar,set_width,0,0,2,class<`pillar_colonnade`>,1
+pillar,set_width,0,0,3,class<`pillar_ornament`>,1
+pillar,set_width,0,0,4,"class<`pillar_rif_shaft`, `pillar_shaft`>",1
+pillar,set_width,0,0,5,class<`pillar_rif_title`>,1
+pillar,set_width,0,0,6,class<`pillar_rif_type`>,1
+pillar,set_width,0,0,7,"class<`pillar_shaft`, `pillar_shaft_decimal`>",1
+pillar,set_width,0,0,8,"class<`pillar_shaft`, `pillar_shaft_simple`>",1
+pillar,set_width,0,0,9,class<`pillar_title`>,1
+pillar,set_width,0,0,10,class<`pillar_type`>,1
+pillar,set_width,0,0,11,list<character[] | double[]>,1
+pillar,set_width,0,0,12,list<character | double>,1
+pillar,set_width,0,0,13,list<character[] | double[] | ^integer[]>,1
+pillar,set_width,0,0,14,list<character | double | null>,1
+pillar,set_width,0,0,15,list<character[] | ^double[]>,1
+pillar,set_width,1,0,0,null,1
+pillar,set_width,1,0,1,double,1
+pillar,size_sum,-1,0,0,character,1
+pillar,size_sum,0,0,0,class<`Date`>,1
+pillar,size_sum,0,0,1,class<`function`>,1
+pillar,size_sum,0,0,2,class<`matrix`>,1
+pillar,size_sum,0,0,3,"class<`POSIXct`, `POSIXt`>",1
+pillar,size_sum,0,0,4,integer[],1
+pillar,spaces_around,-1,0,0,character,1
+pillar,spaces_around,0,0,0,character,1
+pillar,split_decimal,-1,0,0,list<character[] | double[]>,1
+pillar,split_decimal,-1,0,1,list<character | double>,1
+pillar,split_decimal,-1,0,2,list<character[] | double[] | ^integer[]>,1
+pillar,split_decimal,-1,0,3,list<character | double | null>,1
+pillar,split_decimal,-1,0,4,list<character[] | ^double[]>,1
+pillar,split_decimal,0,0,0,^double[],1
+pillar,split_decimal,1,0,0,double,1
+pillar,split_decimal,2,0,0,logical,1
+pillar,squeeze,-1,0,0,class<`pillar_squeezed_colonnade`>,1
+pillar,squeeze,0,0,0,class<`pillar_colonnade`>,1
+pillar,squeeze,1,0,0,double,1
+pillar,squeeze,1,0,1,null,1
+pillar,squeeze,2,0,0,...,1
+pillar,str_trunc,-1,0,0,character[],1
+pillar,str_trunc,0,0,0,character[],1
+pillar,str_trunc,1,0,0,double,1
+pillar,style_bold,-1,0,0,character[],1
+pillar,style_bold,0,0,0,character[],1
+pillar,style_hint,-1,0,0,character[],1
+pillar,style_hint,0,0,0,double[],1
+pillar,style_hint,0,0,1,^character[],1
+pillar,style_hint,0,0,2,class<`type_sum_accel`>,1
+pillar,style_na,-1,0,0,character,1
+pillar,style_na,0,0,0,character,1
+pillar,style_neg,-1,0,0,character[],1
+pillar,style_neg,0,0,0,double[],1
+pillar,style_neg,0,0,1,^character[],1
+pillar,style_neg,0,0,2,class<`type_sum_accel`>,1
+pillar,style_num,-1,0,0,character[],1
+pillar,style_num,0,0,0,character[],1
+pillar,style_num,1,0,0,logical[],1
+pillar,style_num,2,0,0,logical[],1
+pillar,style_rowid,-1,0,0,character[],1
+pillar,style_rowid,0,0,0,character[],1
+pillar,style_star,-1,0,0,character[],1
+pillar,style_star,0,0,0,character[],1
+pillar,style_subtle,-1,0,0,character[],1
+pillar,style_subtle,0,0,0,double[],1
+pillar,style_subtle,0,0,1,^character[],1
+pillar,style_subtle,0,0,2,class<`type_sum_accel`>,1
+pillar,style_subtle_num,-1,0,0,character[],1
+pillar,style_subtle_num,0,0,0,character[],1
+pillar,style_subtle_num,0,0,1,double[],1
+pillar,style_subtle_num,1,0,0,logical[],1
+pillar,style_title,-1,0,0,character[],1
+pillar,style_title,0,0,0,character[],1
+pillar,style_type,-1,0,0,character,1
+pillar,style_type,0,0,0,character,1
+pillar,supernum,-1,0,0,character[],1
+pillar,supernum,0,0,0,^integer[],1
+pillar,tick,-1,0,0,logical[],1
+pillar,tick,0,0,0,character[],1
+pillar,tick,0,0,1,null,1
+pillar,tick_if_needed,-1,0,0,character,1
+pillar,tick_if_needed,-1,0,1,null,1
+pillar,tick_if_needed,0,0,0,character,1
+pillar,tick_if_needed,0,0,1,null,1
+pillar,type_sum,-1,0,0,character,1
+pillar,type_sum,-1,0,1,class<`type_sum_accel`>,1
+pillar,type_sum,0,0,0,^character[],1
+pillar,type_sum,0,0,1,class<`Date`>,1
+pillar,type_sum,0,0,2,class<`factor`>,1
+pillar,type_sum,0,0,3,class<`function`>,1
+pillar,type_sum,0,0,4,class<`matrix`>,1
+pillar,type_sum,0,0,5,"class<`POSIXct`, `POSIXt`>",1
+pillar,type_sum,0,0,6,^double[],1
+pillar,type_sum,0,0,7,class<`accel`>,1
+pillar,type_sum.default,-1,0,0,character,1
+pillar,type_sum.default,0,0,0,^character[],1
+pillar,type_sum.default,0,0,1,class<`Date`>,1
+pillar,type_sum.default,0,0,2,class<`function`>,1
+pillar,type_sum.default,0,0,3,class<`matrix`>,1
+pillar,type_sum.default,0,0,4,"class<`POSIXct`, `POSIXt`>",1
+pillar,type_sum.default,0,0,5,^double[],1
+pillar,type_sum.factor,-1,0,0,character,1
+pillar,type_sum.factor,0,0,0,class<`factor`>,1
+pillar,vec_is,-1,0,0,logical,1
+pillar,vec_is,0,0,0,...,1
+pixmap,addChannels,-1,0,0,class<`pixmapGrey`>,1
+pixmap,addChannels,0,0,0,class<`pixmapRGB`>,1
+pixmap,addChannels,1,0,0,double[],1
+pixmap,addChannels,1,0,1,null,1
+pixmap,addChannels,-1,1,0,class<`pixmapGrey`>,1
+pixmap,addChannels,0,1,0,class<`pixmapRGB`>,1
+pixmap,addChannels,1,1,0,double[],1
+pixmap,addChannels,1,1,1,null,1
+pixmap,addlogo,-1,0,0,class<`pixmapRGB`>,1
+pixmap,addlogo,0,0,0,class<`pixmapRGB`>,1
+pixmap,addlogo,1,0,0,...,1
+pixmap,addlogo,-1,1,0,class<`pixmapRGB`>,1
+pixmap,addlogo,0,1,0,class<`pixmapRGB`>,1
+pixmap,addlogo,1,1,0,...,1
+pixmap,.getCellres,-1,0,0,double[],1
+pixmap,.getCellres,0,0,0,double[],1
+pixmap,.getCellres,1,0,0,logical,1
+pixmap,.getCellres,2,0,0,double[],1
+pixmap,getChannels,-1,0,0,class<`array`>,1
+pixmap,getChannels,0,0,0,class<`pixmapRGB`>,1
+pixmap,getChannels,1,0,0,character[],1
+pixmap,getChannels,-1,1,0,class<`array`>,1
+pixmap,getChannels,-1,1,1,class<`matrix`>,1
+pixmap,getChannels,0,1,0,class<`pixmapRGB`>,1
+pixmap,getChannels,0,1,1,class<`pixmapGrey`>,1
+pixmap,getChannels,1,1,0,character[],1
+pixmap,getChannels,-1,2,0,class<`matrix`>,1
+pixmap,getChannels,0,2,0,class<`pixmapGrey`>,1
+pixmap,getChannels,1,2,0,character,1
+pixmap,pixmap,-1,0,0,class<`pixmap`>,1
+pixmap,pixmap,0,0,0,any,1
+pixmap,pixmap,1,0,0,double,1
+pixmap,pixmap,2,0,0,double,1
+pixmap,pixmap,2,0,1,null,1
+pixmap,pixmap,3,0,0,double[],1
+pixmap,pixmap,3,0,1,null,1
+pixmap,pixmap,4,0,0,logical,1
+pixmap,pixmap,5,0,0,null,1
+pixmap,pixmapGrey,-1,0,0,class<`pixmapGrey`>,1
+pixmap,pixmapGrey,0,0,0,class<`matrix`>,1
+pixmap,pixmapGrey,1,0,0,...,1
+pixmap,pixmapIndexed,-1,0,0,class<`pixmapIndexed`>,1
+pixmap,pixmapIndexed,0,0,0,class<`matrix`>,1
+pixmap,pixmapIndexed,0,0,1,integer[],1
+pixmap,pixmapIndexed,1,0,0,character[],1
+pixmap,pixmapIndexed,1,0,1,class<`function`>,1
+pixmap,pixmapIndexed,2,0,0,...,1
+pixmap,pixmapRGB,-1,0,0,class<`pixmapRGB`>,1
+pixmap,pixmapRGB,0,0,0,double[],1
+pixmap,pixmapRGB,1,0,0,...,1
+pixmap,plot,-1,0,0,null,1
+pixmap,plot,0,0,0,class<`pixmapGrey`>,1
+pixmap,plot,1,0,0,any,1
+pixmap,plot,2,0,0,...,1
+pixmap,plot,-1,1,0,null,1
+pixmap,plot,0,1,0,class<`pixmapRGB`>,1
+pixmap,plot,1,1,0,any,1
+pixmap,plot,2,1,0,...,1
+pixmap,plot,-1,2,0,null,1
+pixmap,plot,0,2,0,class<`pixmapIndexed`>,1
+pixmap,plot,1,2,0,any,1
+pixmap,plot,2,2,0,...,1
+pixmap,read.pnm,-1,0,0,class<`pixmapGrey`>,1
+pixmap,read.pnm,-1,0,1,class<`pixmapRGB`>,1
+pixmap,read.pnm,0,0,0,character,1
+pixmap,read.pnm,1,0,0,...,1
+pixmap,read.pnmdata,-1,0,0,class<`pixmapGrey`>,1
+pixmap,read.pnmdata,-1,0,1,class<`pixmapRGB`>,1
+pixmap,read.pnmdata,0,0,0,"class<`connection`, `file`>",1
+pixmap,read.pnmdata,1,0,0,list<double | character>,1
+pixmap,read.pnmdata,2,0,0,...,1
+pixmap,read.pnmhead,-1,0,0,list<double | character>,1
+pixmap,read.pnmhead,0,0,0,"class<`connection`, `file`>",1
+pixmap,write.pnm,-1,0,0,integer,1
+pixmap,write.pnm,0,0,0,class<`pixmapIndexed`>,1
+pixmap,write.pnm,1,0,0,character,1
+pixmap,write.pnm,2,0,0,logical,1
+pixmap,write.pnm,3,0,0,null,1
+pixmap,write.pnm,4,0,0,double,1
+pkgload,all_named,-1,0,0,logical,1
+pkgload,all_named,0,0,0,pairlist,1
+pkgload,compact,-1,0,0,list<any>,1
+pkgload,compact,0,0,0,list<null>,1
+pkgload,compact,0,0,1,list<null | class<`for`>>,1
+pkgload,compact,0,0,2,list<null | class<`if`>>,1
+pkgload,compact,0,0,3,list<null | class<`<-`>>,1
+pkgload,comp_lang,-1,0,0,logical,1
+pkgload,comp_lang,0,0,0,character,1
+pkgload,comp_lang,0,0,1,class<`<-`>,1
+pkgload,comp_lang,0,0,2,class<`{`>,1
+pkgload,comp_lang,0,0,3,class<`call`>,1
+pkgload,comp_lang,0,0,4,class<`for`>,1
+pkgload,comp_lang,0,0,5,class<`if`>,1
+pkgload,comp_lang,0,0,6,class<`name`>,1
+pkgload,comp_lang,0,0,7,null,1
+pkgload,comp_lang,0,0,8,pairlist,1
+pkgload,comp_lang,0,0,9,class<`(`>,1
+pkgload,comp_lang,0,0,10,double,1
+pkgload,comp_lang,1,0,0,class<`call`>,1
+pkgload,comp_lang,1,0,1,class<`<-`>,1
+pkgload,comp_lang,1,0,2,class<`for`>,1
+pkgload,comp_lang,1,0,3,class<`if`>,1
+pkgload,comp_lang,2,0,0,any,1
+pkgload,dir.exists,-1,0,0,logical[],1
+pkgload,dir.exists,0,0,0,character[],1
+pkgload,extract_lang,-1,0,0,class<`<-`>,1
+pkgload,extract_lang,-1,0,1,class<`for`>,1
+pkgload,extract_lang,-1,0,2,class<`if`>,1
+pkgload,extract_lang,-1,0,3,null,1
+pkgload,extract_lang,0,0,0,class<`{`>,1
+pkgload,extract_lang,0,0,1,class<`<-`>,1
+pkgload,extract_lang,0,0,2,class<`if`>,1
+pkgload,extract_lang,0,0,3,class<`for`>,1
+pkgload,extract_lang,0,0,4,character,1
+pkgload,extract_lang,0,0,5,class<`(`>,1
+pkgload,extract_lang,0,0,6,class<`call`>,1
+pkgload,extract_lang,0,0,7,class<`name`>,1
+pkgload,extract_lang,0,0,8,double,1
+pkgload,extract_lang,0,0,9,null,1
+pkgload,extract_lang,0,0,10,pairlist,1
+pkgload,extract_lang,1,0,0,class<`function`>,1
+pkgload,extract_lang,2,0,0,...,1
+pkgload,f,-1,0,0,logical,1
+pkgload,f,0,0,0,character,1
+pkgload,f,0,0,1,class<`<-`>,1
+pkgload,f,0,0,2,class<`{`>,1
+pkgload,f,0,0,3,class<`call`>,1
+pkgload,f,0,0,4,class<`for`>,1
+pkgload,f,0,0,5,class<`if`>,1
+pkgload,f,0,0,6,class<`name`>,1
+pkgload,f,0,0,7,null,1
+pkgload,f,0,0,8,pairlist,1
+pkgload,f,0,0,9,class<`(`>,1
+pkgload,f,0,0,10,double,1
+pkgload,f,1,0,0,class<`call`>,1
+pkgload,f,1,0,1,class<`<-`>,1
+pkgload,f,1,0,2,class<`for`>,1
+pkgload,f,1,0,3,class<`if`>,1
+pkgload,f,2,0,0,any,1
+pkgload,f,-1,1,0,character,1
+pkgload,f,-1,1,1,class<`<-`>,1
+pkgload,f,-1,1,2,class<`(`>,1
+pkgload,f,-1,1,3,class<`{`>,1
+pkgload,f,-1,1,4,class<`call`>,1
+pkgload,f,-1,1,5,class<`for`>,1
+pkgload,f,-1,1,6,class<`if`>,1
+pkgload,f,-1,1,7,class<`name`>,1
+pkgload,f,-1,1,8,double,1
+pkgload,f,-1,1,9,null,1
+pkgload,f,-1,1,10,pairlist,1
+pkgload,f,0,1,0,character,1
+pkgload,f,0,1,1,class<`<-`>,1
+pkgload,f,0,1,2,class<`(`>,1
+pkgload,f,0,1,3,class<`{`>,1
+pkgload,f,0,1,4,class<`call`>,1
+pkgload,f,0,1,5,class<`for`>,1
+pkgload,f,0,1,6,class<`if`>,1
+pkgload,f,0,1,7,class<`name`>,1
+pkgload,f,0,1,8,double,1
+pkgload,f,0,1,9,null,1
+pkgload,f,0,1,10,pairlist,1
+pkgload,f,1,1,0,character,1
+pkgload,f,-1,2,0,character,1
+pkgload,f,-1,2,1,class<`<-`>,1
+pkgload,f,-1,2,2,class<`{`>,1
+pkgload,f,-1,2,3,class<`call`>,1
+pkgload,f,-1,2,4,class<`name`>,1
+pkgload,f,-1,2,5,integer,1
+pkgload,f,-1,2,6,null,1
+pkgload,f,-1,2,7,pairlist,1
+pkgload,f,0,2,0,character,1
+pkgload,f,0,2,1,class<`<-`>,1
+pkgload,f,0,2,2,class<`{`>,1
+pkgload,f,0,2,3,class<`call`>,1
+pkgload,f,0,2,4,class<`name`>,1
+pkgload,f,0,2,5,integer,1
+pkgload,f,0,2,6,null,1
+pkgload,f,0,2,7,pairlist,1
+pkgload,f,-1,3,0,character,1
+pkgload,f,-1,3,1,class<`<-`>,1
+pkgload,f,-1,3,2,class<`{`>,1
+pkgload,f,-1,3,3,class<`call`>,1
+pkgload,f,-1,3,4,class<`for`>,1
+pkgload,f,-1,3,5,class<`if`>,1
+pkgload,f,-1,3,6,class<`name`>,1
+pkgload,f,0,3,0,character,1
+pkgload,f,0,3,1,class<`<-`>,1
+pkgload,f,0,3,2,class<`{`>,1
+pkgload,f,0,3,3,class<`call`>,1
+pkgload,f,0,3,4,class<`for`>,1
+pkgload,f,0,3,5,class<`if`>,1
+pkgload,f,0,3,6,class<`name`>,1
+pkgload,has_tests,-1,0,0,logical,1
+pkgload,inst,-1,0,0,character,1
+pkgload,inst,0,0,0,character,1
+pkgload,is_installed,-1,0,0,logical,1
+pkgload,is_installed,0,0,0,character,1
+pkgload,is_installed,1,0,0,double,1
+pkgload,load_namespace_for1,-1,0,0,class<`for`>,1
+pkgload,load_namespace_for2,-1,0,0,class<`for`>,1
+pkgload,load_namespace_for3,-1,0,0,class<`for`>,1
+pkgload,make_function,-1,0,0,class<`function`>,1
+pkgload,make_function,0,0,0,list<class<`name`>>,1
+pkgload,make_function,1,0,0,class<`{`>,1
+pkgload,make_function,2,0,0,environment,1
+pkgload,modify_lang,-1,0,0,character,1
+pkgload,modify_lang,-1,0,1,class<`<-`>,1
+pkgload,modify_lang,-1,0,2,class<`(`>,1
+pkgload,modify_lang,-1,0,3,class<`{`>,1
+pkgload,modify_lang,-1,0,4,class<`call`>,1
+pkgload,modify_lang,-1,0,5,class<`for`>,1
+pkgload,modify_lang,-1,0,6,class<`if`>,1
+pkgload,modify_lang,-1,0,7,class<`name`>,1
+pkgload,modify_lang,-1,0,8,double,1
+pkgload,modify_lang,-1,0,9,null,1
+pkgload,modify_lang,-1,0,10,pairlist,1
+pkgload,modify_lang,0,0,0,character,1
+pkgload,modify_lang,0,0,1,class<`<-`>,1
+pkgload,modify_lang,0,0,2,class<`(`>,1
+pkgload,modify_lang,0,0,3,class<`{`>,1
+pkgload,modify_lang,0,0,4,class<`call`>,1
+pkgload,modify_lang,0,0,5,class<`for`>,1
+pkgload,modify_lang,0,0,6,class<`if`>,1
+pkgload,modify_lang,0,0,7,class<`name`>,1
+pkgload,modify_lang,0,0,8,double,1
+pkgload,modify_lang,0,0,9,null,1
+pkgload,modify_lang,0,0,10,pairlist,1
+pkgload,modify_lang,1,0,0,class<`function`>,1
+pkgload,modify_lang,2,0,0,...,1
+pkgload,parse_deps,-1,0,0,class<`data.frame`>,1
+pkgload,parse_deps,0,0,0,character,1
+pkgload,pkgtest,-1,0,0,character,1
+pkgload,pkgtest,0,0,0,character,1
+pkgload,wrap_inner_loop,-1,0,0,class<`for`>,1
+pkgload,wrap_inner_loop,0,0,0,class<`for`>,1
+plot3D,add2Dplist,-1,0,0,"class<`list`, `plist`>",1
+plot3D,add2Dplist,0,0,0,"class<`list`, `plist`>",1
+plot3D,add2Dplist,0,0,1,null,1
+plot3D,add2Dplist,1,0,0,character,1
+plot3D,add2Dplist,2,0,0,...,1
+plot3D,addimg,-1,0,0,class<`poly`>,1
+plot3D,addimg,0,0,0,class<`poly`>,1
+plot3D,addimg,0,0,1,null,1
+plot3D,addimg,1,0,0,class<`matrix`>,1
+plot3D,addimg,1,0,1,double[],1
+plot3D,addimg,2,0,0,class<`matrix`>,1
+plot3D,addimg,2,0,1,double[],1
+plot3D,addimg,3,0,0,class<`matrix`>,1
+plot3D,addimg,4,0,0,class<`matrix`>,1
+plot3D,addimg,5,0,0,"class<`list`, `plist`>",1
+plot3D,addimg,6,0,0,character[],1
+plot3D,addimg,7,0,0,character,1
+plot3D,addimg,8,0,0,null,1
+plot3D,addimg,9,0,0,character,1
+plot3D,addimg,9,0,1,null,1
+plot3D,addimg,10,0,0,logical,1
+plot3D,addimg,10,0,1,null,1
+plot3D,addimg,11,0,0,double,1
+plot3D,addimg,12,0,0,double,1
+plot3D,addimg,13,0,0,double,1
+plot3D,addimg,14,0,0,double[],1
+plot3D,addimg,14,0,1,null,1
+plot3D,addimg,15,0,0,double,1
+plot3D,addlines,-1,0,0,class<`segments`>,1
+plot3D,addlines,0,0,0,class<`segments`>,1
+plot3D,addlines,0,0,1,null,1
+plot3D,addlines,1,0,0,double[],1
+plot3D,addlines,2,0,0,double[],1
+plot3D,addlines,3,0,0,double[],1
+plot3D,addlines,4,0,0,"class<`list`, `plist`>",1
+plot3D,addlines,5,0,0,character,1
+plot3D,addlines,6,0,0,character,1
+plot3D,addlines,7,0,0,double,1
+plot3D,addlines,8,0,0,double,1
+plot3D,addlines,9,0,0,double,1
+plot3D,addlines,10,0,0,double,1
+plot3D,addlines,11,0,0,null,1
+plot3D,addlines,12,0,0,logical,1
+plot3D,addlines,13,0,0,logical,1
+plot3D,addlines,14,0,0,...,1
+plot3D,add.poly,-1,0,0,list<any>,1
+plot3D,add.poly,0,0,0,list<any>,1
+plot3D,add.poly,1,0,0,class<`matrix`>,1
+plot3D,add.poly,2,0,0,class<`matrix`>,1
+plot3D,add.poly,3,0,0,class<`matrix`>,1
+plot3D,add.poly,4,0,0,double[],1
+plot3D,add.poly,5,0,0,character[],1
+plot3D,add.poly,6,0,0,character,1
+plot3D,add.poly,7,0,0,null,1
+plot3D,add.poly,8,0,0,double[],1
+plot3D,add.poly,9,0,0,logical,1
+plot3D,add.poly,10,0,0,null,1
+plot3D,add.poly,10,0,1,character,1
+plot3D,add.poly,11,0,0,double,1
+plot3D,add.poly,12,0,0,double,1
+plot3D,add.poly,13,0,0,...,1
+plot3D,addPoly,-1,0,0,class<`poly`>,1
+plot3D,addPoly,0,0,0,class<`poly`>,1
+plot3D,addPoly,0,0,1,null,1
+plot3D,addPoly,1,0,0,class<`poly`>,1
+plot3D,addraster,-1,0,0,null,1
+plot3D,addraster,0,0,0,double[],1
+plot3D,addraster,1,0,0,double[],1
+plot3D,addraster,2,0,0,class<`matrix`>,1
+plot3D,addraster,3,0,0,null,1
+plot3D,addraster,4,0,0,null,1
+plot3D,addraster,5,0,0,double,1
+plot3D,addraster,6,0,0,list<any>,1
+plot3D,addslice,-1,0,0,class<`poly`>,1
+plot3D,addslice,0,0,0,null,1
+plot3D,addslice,1,0,0,class<`array`>,1
+plot3D,addslice,1,0,1,double[],1
+plot3D,addslice,2,0,0,class<`array`>,1
+plot3D,addslice,2,0,1,double[],1
+plot3D,addslice,3,0,0,class<`array`>,1
+plot3D,addslice,3,0,1,double[],1
+plot3D,addslice,4,0,0,class<`array`>,1
+plot3D,addslice,5,0,0,class<`matrix`>,1
+plot3D,addslice,5,0,1,double[],1
+plot3D,addslice,6,0,0,class<`matrix`>,1
+plot3D,addslice,6,0,1,double[],1
+plot3D,addslice,7,0,0,null,1
+plot3D,addslice,7,0,1,class<`matrix`>,1
+plot3D,addslice,7,0,2,double[],1
+plot3D,addslice,8,0,0,"class<`list`, `plist`>",1
+plot3D,addslice,9,0,0,character[],1
+plot3D,addslice,10,0,0,character,1
+plot3D,addslice,11,0,0,null,1
+plot3D,addslice,12,0,0,null,1
+plot3D,addslice,12,0,1,character,1
+plot3D,addslice,13,0,0,logical,1
+plot3D,addslice,14,0,0,double,1
+plot3D,addslice,15,0,0,double,1
+plot3D,alpha3D,-1,0,0,"class<`list`, `plist`>",1
+plot3D,alpha3D,0,0,0,"class<`list`, `plist`>",1
+plot3D,alpha3D,1,0,0,double,1
+plot3D,alpha.col,-1,0,0,character[],1
+plot3D,alpha.col,0,0,0,^character[],1
+plot3D,alpha.col,0,0,1,double[],1
+plot3D,alpha.col,1,0,0,double,1
+plot3D,Arrow,-1,0,0,null,1
+plot3D,Arrow,0,0,0,double[],1
+plot3D,Arrow,1,0,0,double[],1
+plot3D,Arrow,2,0,0,double[],1
+plot3D,Arrow,3,0,0,double[],1
+plot3D,Arrow,4,0,0,double[],1
+plot3D,Arrow,5,0,0,double[],1
+plot3D,Arrow,6,0,0,double[],1
+plot3D,Arrow,7,0,0,double,1
+plot3D,Arrow,8,0,0,character,1
+plot3D,Arrow,9,0,0,character[],1
+plot3D,Arrow,10,0,0,double[],1
+plot3D,Arrow,11,0,0,double[],1
+plot3D,Arrow,12,0,0,...,1
+plot3D,Arrow.head,-1,0,0,null,1
+plot3D,Arrow.head,0,0,0,double[],1
+plot3D,Arrow.head,1,0,0,double[],1
+plot3D,Arrow.head,2,0,0,double[],1
+plot3D,Arrow.head,3,0,0,double[],1
+plot3D,Arrow.head,4,0,0,double[],1
+plot3D,Arrow.head,5,0,0,double,1
+plot3D,Arrow.head,6,0,0,character,1
+plot3D,Arrow.head,7,0,0,character[],1
+plot3D,Arrow.head,8,0,0,double[],1
+plot3D,Arrow.head,9,0,0,double[],1
+plot3D,Arrow.head,10,0,0,double,1
+plot3D,arrows2D,-1,0,0,list<double[]>,1
+plot3D,arrows2D,0,0,0,double[],1
+plot3D,arrows2D,1,0,0,double[],1
+plot3D,arrows2D,2,0,0,double[],1
+plot3D,arrows2D,3,0,0,double[],1
+plot3D,arrows2D,4,0,0,...,1
+plot3D,arrows2D,5,0,0,integer[],1
+plot3D,arrows2D,6,0,0,null,1
+plot3D,arrows2D,7,0,0,character,1
+plot3D,arrows2D,8,0,0,null,1
+plot3D,arrows2D,9,0,0,null,1
+plot3D,arrows2D,10,0,0,null,1
+plot3D,arrows2D,11,0,0,null,1
+plot3D,arrows2D,12,0,0,character,1
+plot3D,arrows2D,13,0,0,logical,1
+plot3D,arrows2D,14,0,0,logical,1
+plot3D,arrows3D,-1,0,0,class<`matrix`>,1
+plot3D,arrows3D,0,0,0,class<`array`>,1
+plot3D,arrows3D,0,0,1,class<`matrix`>,1
+plot3D,arrows3D,0,0,2,double[],1
+plot3D,arrows3D,1,0,0,class<`array`>,1
+plot3D,arrows3D,1,0,1,class<`matrix`>,1
+plot3D,arrows3D,1,0,2,double[],1
+plot3D,arrows3D,2,0,0,class<`array`>,1
+plot3D,arrows3D,2,0,1,class<`matrix`>,1
+plot3D,arrows3D,2,0,2,double[],1
+plot3D,arrows3D,3,0,0,class<`array`>,1
+plot3D,arrows3D,3,0,1,class<`matrix`>,1
+plot3D,arrows3D,3,0,2,double[],1
+plot3D,arrows3D,4,0,0,class<`array`>,1
+plot3D,arrows3D,4,0,1,class<`matrix`>,1
+plot3D,arrows3D,4,0,2,double[],1
+plot3D,arrows3D,5,0,0,class<`array`>,1
+plot3D,arrows3D,5,0,1,class<`matrix`>,1
+plot3D,arrows3D,5,0,2,double[],1
+plot3D,arrows3D,6,0,0,...,1
+plot3D,arrows3D,7,0,0,class<`array`>,1
+plot3D,arrows3D,7,0,1,null,1
+plot3D,arrows3D,7,0,2,integer[],1
+plot3D,arrows3D,8,0,0,double,1
+plot3D,arrows3D,9,0,0,double,1
+plot3D,arrows3D,10,0,0,character[],1
+plot3D,arrows3D,10,0,1,null,1
+plot3D,arrows3D,11,0,0,character,1
+plot3D,arrows3D,12,0,0,null,1
+plot3D,arrows3D,13,0,0,null,1
+plot3D,arrows3D,13,0,1,logical,1
+plot3D,arrows3D,14,0,0,null,1
+plot3D,arrows3D,15,0,0,null,1
+plot3D,ArrType,-1,0,0,null,1
+plot3D,ArrType,0,0,0,double[],1
+plot3D,ArrType,1,0,0,double[],1
+plot3D,ArrType,2,0,0,double[],1
+plot3D,ArrType,3,0,0,double[],1
+plot3D,ArrType,4,0,0,double[],1
+plot3D,ArrType,5,0,0,double[],1
+plot3D,ArrType,6,0,0,double[],1
+plot3D,ArrType,7,0,0,double,1
+plot3D,ArrType,8,0,0,character[],1
+plot3D,ArrType,9,0,0,character[],1
+plot3D,ArrType,10,0,0,double[],1
+plot3D,ArrType,11,0,0,double[],1
+plot3D,ArrType,12,0,0,...,1
+plot3D,border3D,-1,0,0,class<`matrix`>,1
+plot3D,border3D,0,0,0,double[],1
+plot3D,border3D,1,0,0,double[],1
+plot3D,border3D,2,0,0,double[],1
+plot3D,border3D,3,0,0,double[],1
+plot3D,border3D,4,0,0,double[],1
+plot3D,border3D,5,0,0,double[],1
+plot3D,border3D,6,0,0,...,1
+plot3D,border3D,7,0,0,null,1
+plot3D,border3D,8,0,0,double,1
+plot3D,border3D,9,0,0,double,1
+plot3D,border3D,10,0,0,character[],1
+plot3D,border3D,11,0,0,character,1
+plot3D,border3D,12,0,0,null,1
+plot3D,border3D,13,0,0,null,1
+plot3D,border3D,14,0,0,null,1
+plot3D,border3D,15,0,0,null,1
+plot3D,box3D,-1,0,0,class<`matrix`>,1
+plot3D,box3D,0,0,0,double[],1
+plot3D,box3D,1,0,0,double[],1
+plot3D,box3D,2,0,0,double[],1
+plot3D,box3D,3,0,0,double[],1
+plot3D,box3D,4,0,0,double[],1
+plot3D,box3D,5,0,0,double[],1
+plot3D,box3D,6,0,0,...,1
+plot3D,box3D,7,0,0,null,1
+plot3D,box3D,8,0,0,double,1
+plot3D,box3D,9,0,0,double,1
+plot3D,box3D,10,0,0,character[],1
+plot3D,box3D,11,0,0,character,1
+plot3D,box3D,12,0,0,null,1
+plot3D,box3D,13,0,0,character,1
+plot3D,box3D,14,0,0,logical,1
+plot3D,box3D,15,0,0,null,1
+plot3D,changeres,-1,0,0,list<double[] | class<`matrix`>>,1
+plot3D,changeres,-1,0,1,list<double[] | class<`matrix`> | null>,1
+plot3D,changeres,0,0,0,double,1
+plot3D,changeres,1,0,0,double[],1
+plot3D,changeres,1,0,1,class<`array`>,1
+plot3D,changeres,2,0,0,double[],1
+plot3D,changeres,2,0,1,class<`array`>,1
+plot3D,changeres,3,0,0,class<`matrix`>,1
+plot3D,changeres,4,0,0,class<`matrix`>,1
+plot3D,changeres,4,0,1,null,1
+plot3D,changeres,5,0,0,logical,1
+plot3D,changeres_vec,-1,0,0,list<double[] | class<`matrix`>>,1
+plot3D,changeres_vec,-1,0,1,list<double[] | class<`matrix`> | null>,1
+plot3D,changeres_vec,0,0,0,double,1
+plot3D,changeres_vec,1,0,0,double[],1
+plot3D,changeres_vec,1,0,1,class<`array`>,1
+plot3D,changeres_vec,2,0,0,double[],1
+plot3D,changeres_vec,2,0,1,class<`array`>,1
+plot3D,changeres_vec,3,0,0,class<`matrix`>,1
+plot3D,changeres_vec,4,0,0,class<`matrix`>,1
+plot3D,changeres_vec,4,0,1,null,1
+plot3D,changeres_vec,5,0,0,logical,1
+plot3D,check.args,-1,0,0,list<logical | character[] | list<any>>,1
+plot3D,check.args,-1,0,1,list<logical | character | list<any>>,1
+plot3D,check.args,-1,0,2,list<logical | character>,1
+plot3D,check.args,-1,0,3,list<logical | character[] | list<character>>,1
+plot3D,check.args,-1,0,4,list<logical | character | list<character[]>>,1
+plot3D,check.args,-1,0,5,list<logical | character | list<double | character>>,1
+plot3D,check.args,-1,0,6,list<double | list<any>>,1
+plot3D,check.args,0,0,0,list<character[]>,1
+plot3D,check.args,0,0,1,logical,1
+plot3D,check.args,0,0,2,list<double | character>,1
+plot3D,check.args,0,0,3,list<double>,1
+plot3D,check.breaks,-1,0,0,double[],1
+plot3D,check.breaks,-1,0,1,null,1
+plot3D,check.breaks,0,0,0,double[],1
+plot3D,check.breaks,0,0,1,null,1
+plot3D,check.breaks,1,0,0,any,1
+plot3D,check.CI,-1,0,0,list<any>,1
+plot3D,check.CI,0,0,0,list<double | class<`matrix`> | character>,1
+plot3D,check.CI,0,0,1,list<double | class<`matrix`>>,1
+plot3D,check.CI,0,0,2,list<class<`matrix`>>,1
+plot3D,check.CI,0,0,3,list<class<`matrix`> | double>,1
+plot3D,check.CI,1,0,0,integer,1
+plot3D,check.CI,2,0,0,double,1
+plot3D,check.colkey,-1,0,0,list<character | null | double[]>,1
+plot3D,check.colkey,-1,0,1,list<null | double[]>,1
+plot3D,check.colkey,-1,0,2,list<null | double[] | character[]>,1
+plot3D,check.colkey,0,0,0,list<double | character>,1
+plot3D,check.colkey,0,0,1,list<double[] | character[]>,1
+plot3D,check.colkey,0,0,2,list<null | double[] | character[]>,1
+plot3D,check.colkey,0,0,3,list<double[]>,1
+plot3D,check.colkey,0,0,4,null,1
+plot3D,check.colkey,0,0,5,list<null | double[]>,1
+plot3D,check.colkey,1,0,0,logical,1
+plot3D,checkcolors,-1,0,0,list<character[] | class<`array`> | double[]>,1
+plot3D,checkcolors,-1,0,1,list<character[] | class<`matrix`> | double[]>,1
+plot3D,checkcolors,0,0,0,class<`array`>,1
+plot3D,checkcolors,0,0,1,class<`matrix`>,1
+plot3D,checkcolors,1,0,0,character[],1
+plot3D,checkcolors,2,0,0,character,1
+plot3D,checkcolors,3,0,0,double[],1
+plot3D,check.colvar.2,-1,0,0,list<class<`matrix`> | character[]>,1
+plot3D,check.colvar.2,0,0,0,class<`matrix`>,1
+plot3D,check.colvar.2,1,0,0,class<`matrix`>,1
+plot3D,check.colvar.2,2,0,0,character[],1
+plot3D,check.colvar.2,3,0,0,null,1
+plot3D,check.colvar.2,4,0,0,double,1
+plot3D,check.colvar.2,4,0,1,null,1
+plot3D,check.colvar.persp,-1,0,0,list<class<`matrix`> | character[]>,1
+plot3D,check.colvar.persp,-1,0,1,list<null | character[]>,1
+plot3D,check.colvar.persp,-1,0,2,list<null | ^logical[]>,1
+plot3D,check.colvar.persp,0,0,0,class<`matrix`>,1
+plot3D,check.colvar.persp,0,0,1,null,1
+plot3D,check.colvar.persp,1,0,0,any,1
+plot3D,check.colvar.persp,2,0,0,character[],1
+plot3D,check.colvar.persp,2,0,1,null,1
+plot3D,check.colvar.persp,3,0,0,any,1
+plot3D,check.colvar.persp,4,0,0,any,1
+plot3D,check.colvar.persp,5,0,0,null,1
+plot3D,check.colvar.persp,5,0,1,double,1
+plot3D,checklim,-1,0,0,double[],1
+plot3D,checklim,0,0,0,double[],1
+plot3D,check.plt,-1,0,0,double[],1
+plot3D,check.plt,0,0,0,double[],1
+plot3D,check.shade,-1,0,0,list<double | character>,1
+plot3D,check.shade,-1,0,1,list<double | null | character>,1
+plot3D,check.shade,-1,0,2,list<null | double | character>,1
+plot3D,check.shade,0,0,0,list<double>,1
+plot3D,check.shade,0,0,1,list<double | character>,1
+plot3D,check.shade,0,0,2,list<double | null>,1
+plot3D,check.shade,0,0,3,list<double | null | character>,1
+plot3D,check.shade,0,0,4,list<null | double>,1
+plot3D,check.shade,1,0,0,logical,1
+plot3D,check.shade,1,0,1,list<double>,1
+plot3D,check.shade,1,0,2,null,1
+plot3D,colkey,-1,0,0,list<double[]>,1
+plot3D,colkey,0,0,0,character[],1
+plot3D,colkey,0,0,1,null,1
+plot3D,colkey,1,0,0,double[],1
+plot3D,colkey,2,0,0,null,1
+plot3D,colkey,2,0,1,character[],1
+plot3D,colkey,3,0,0,logical,1
+plot3D,colkey,4,0,0,logical,1
+plot3D,colkey,5,0,0,null,1
+plot3D,colkey,6,0,0,null,1
+plot3D,colkey,6,0,1,character,1
+plot3D,colkey,7,0,0,null,1
+plot3D,colkey,7,0,1,double,1
+plot3D,colkey,8,0,0,null,1
+plot3D,colkey,8,0,1,double,1
+plot3D,colkey,9,0,0,null,1
+plot3D,colkey,9,0,1,double,1
+plot3D,colkey,10,0,0,null,1
+plot3D,colkey,10,0,1,double,1
+plot3D,colkey,11,0,0,double,1
+plot3D,colkey,12,0,0,double,1
+plot3D,colkey,13,0,0,double,1
+plot3D,colkey,14,0,0,double,1
+plot3D,colkey,15,0,0,double,1
+plot3D,color3D,-1,0,0,class<`poly`>,1
+plot3D,color3D,-1,0,1,list<any>,1
+plot3D,color3D,0,0,0,class<`poly`>,1
+plot3D,color3D,0,0,1,list<any>,1
+plot3D,color3D,1,0,0,list<double>,1
+plot3D,color3D,2,0,0,list<null | double>,1
+plot3D,color3D,2,0,1,list<double | character>,1
+plot3D,color3D,2,0,2,list<double | null | character>,1
+plot3D,color3D,3,0,0,logical,1
+plot3D,color3D,3,0,1,null,1
+plot3D,color3D,4,0,0,double,1
+plot3D,color3D,4,0,1,null,1
+plot3D,color.panels,-1,0,0,null,1
+plot3D,color.panels,0,0,0,logical[],1
+plot3D,color.panels,1,0,0,double[],1
+plot3D,color.panels,2,0,0,double[],1
+plot3D,color.panels,3,0,0,double[],1
+plot3D,color.panels,4,0,0,class<`matrix`>,1
+plot3D,color.panels,5,0,0,character,1
+plot3D,color.panels,6,0,0,double,1
+plot3D,color.panels,7,0,0,character,1
+plot3D,contour2D,-1,0,0,list<double[]>,1
+plot3D,contour2D,0,0,0,class<`matrix`>,1
+plot3D,contour2D,1,0,0,double[],1
+plot3D,contour2D,2,0,0,double[],1
+plot3D,contour2D,3,0,0,...,1
+plot3D,contour2D,4,0,0,character,1
+plot3D,contour2D,4,0,1,null,1
+plot3D,contour2D,5,0,0,character,1
+plot3D,contour2D,5,0,1,null,1
+plot3D,contour2D,6,0,0,null,1
+plot3D,contour2D,6,0,1,logical,1
+plot3D,contour2D,6,0,2,list<double[]>,1
+plot3D,contour2D,7,0,0,double,1
+plot3D,contour2D,8,0,0,null,1
+plot3D,contour2D,9,0,0,logical,1
+plot3D,contour2D,10,0,0,logical,1
+plot3D,contour3D,-1,0,0,class<`matrix`>,1
+plot3D,contour3D,0,0,0,double[],1
+plot3D,contour3D,0,0,1,null,1
+plot3D,contour3D,1,0,0,double[],1
+plot3D,contour3D,1,0,1,class<`matrix`>,1
+plot3D,contour3D,1,0,2,null,1
+plot3D,contour3D,2,0,0,double,1
+plot3D,contour3D,2,0,1,integer[],1
+plot3D,contour3D,2,0,2,null,1
+plot3D,contour3D,2,0,3,class<`matrix`>,1
+plot3D,contour3D,3,0,0,...,1
+plot3D,contour3D,4,0,0,class<`matrix`>,1
+plot3D,contour3D,5,0,0,double,1
+plot3D,contour3D,6,0,0,double,1
+plot3D,contour3D,7,0,0,null,1
+plot3D,contour3D,7,0,1,character,1
+plot3D,contour3D,8,0,0,logical,1
+plot3D,contour3D,8,0,1,null,1
+plot3D,contour3D,8,0,2,list<double[]>,1
+plot3D,contour3D,9,0,0,null,1
+plot3D,contour3D,10,0,0,double[],1
+plot3D,contour3D,10,0,1,null,1
+plot3D,contour3D,11,0,0,any,1
+plot3D,contour3D,12,0,0,character,1
+plot3D,contour3D,13,0,0,double,1
+plot3D,contour3D,14,0,0,logical,1
+plot3D,contour3D,15,0,0,logical,1
+plot3D,contourfunc,-1,0,0,class<`segments`>,1
+plot3D,contourfunc,0,0,0,list<logical | character[] | list<any>>,1
+plot3D,contourfunc,0,0,1,list<logical | character | list<any>>,1
+plot3D,contourfunc,0,0,2,list<logical | character[] | list<character>>,1
+plot3D,contourfunc,0,0,3,list<logical | character | list<double | character>>,1
+plot3D,contourfunc,0,0,4,list<double | list<character | double[]>>,1
+plot3D,contourfunc,0,0,5,list<double | list<character[] | integer[]>>,1
+plot3D,contourfunc,0,0,6,list<character | list<double | character | integer[]>>,1
+plot3D,contourfunc,0,0,7,list<double | list<double | character[] | integer[]>>,1
+plot3D,contourfunc,0,0,8,list<character | list<double | character[] | integer[]>>,1
+plot3D,contourfunc,0,0,9,list<double | list<double | character | integer[]>>,1
+plot3D,contourfunc,1,0,0,double[],1
+plot3D,contourfunc,2,0,0,double[],1
+plot3D,contourfunc,3,0,0,any,1
+plot3D,contourfunc,4,0,0,"class<`list`, `plist`>",1
+plot3D,contourfunc,5,0,0,class<`matrix`>,1
+plot3D,contourfunc,6,0,0,double[],1
+plot3D,contourfunc,7,0,0,null,1
+plot3D,contourfunc,7,0,1,double,1
+plot3D,contourfunc,8,0,0,logical,1
+plot3D,ContourLines,-1,0,0,list<list<double[]>>,1
+plot3D,ContourLines,0,0,0,double[],1
+plot3D,ContourLines,1,0,0,double[],1
+plot3D,ContourLines,2,0,0,class<`matrix`>,1
+plot3D,ContourLines,3,0,0,double,1
+plot3D,ContourLines,4,0,0,double[],1
+plot3D,createcolors,-1,0,0,list<^character[]>,1
+plot3D,createcolors,-1,0,1,list<character[] | ^logical[]>,1
+plot3D,createcolors,-1,0,2,list<character | null>,1
+plot3D,createcolors,-1,0,3,list<class<`matrix`>>,1
+plot3D,createcolors,-1,0,4,list<null | character>,1
+plot3D,createcolors,0,0,0,logical,1
+plot3D,createcolors,0,0,1,null,1
+plot3D,createcolors,1,0,0,null,1
+plot3D,createcolors,1,0,1,character,1
+plot3D,createcolors,2,0,0,character[],1
+plot3D,createcolors,2,0,1,^logical[],1
+plot3D,createcolors,2,0,2,class<`matrix`>,1
+plot3D,createisosurf,-1,0,0,class<`matrix`>,1
+plot3D,createisosurf,0,0,0,double[],1
+plot3D,createisosurf,1,0,0,double[],1
+plot3D,createisosurf,2,0,0,double[],1
+plot3D,createisosurf,3,0,0,class<`array`>,1
+plot3D,createisosurf,4,0,0,double,1
+plot3D,createpoly,-1,0,0,list<class<`matrix`>>,1
+plot3D,createpoly,0,0,0,class<`matrix`>,1
+plot3D,createpoly,1,0,0,class<`matrix`>,1
+plot3D,createpoly,2,0,0,class<`matrix`>,1
+plot3D,createpoly,3,0,0,integer[],1
+plot3D,createpoly,4,0,0,integer[],1
+plot3D,createpoly,5,0,0,logical,1
+plot3D,createsegms,-1,0,0,class<`segments`>,1
+plot3D,createsegms,0,0,0,double[],1
+plot3D,createsegms,0,0,1,null,1
+plot3D,createsegms,1,0,0,double[],1
+plot3D,createsegms,1,0,1,null,1
+plot3D,createsegms,2,0,0,double,1
+plot3D,createsegms,2,0,1,class<`matrix`>,1
+plot3D,createsegms,3,0,0,class<`matrix`>,1
+plot3D,createsegms,4,0,0,character[],1
+plot3D,createsegms,5,0,0,list<logical | null | list<any>>,1
+plot3D,createsegms,5,0,1,list<logical | null | list<character | double[] | double | double | null | character>>,1
+plot3D,createsegms,6,0,0,character[],1
+plot3D,createsegms,7,0,0,double[],1
+plot3D,createsegms,8,0,0,double,1
+plot3D,createsegms,9,0,0,"class<`list`, `plist`>",1
+plot3D,createsegms,10,0,0,double[],1
+plot3D,createsegms,11,0,0,logical,1
+plot3D,createsurfs,-1,0,0,list<class<`matrix`>>,1
+plot3D,createsurfs,-1,0,1,list<class<`matrix`> | null>,1
+plot3D,createsurfs,0,0,0,double[],1
+plot3D,createsurfs,0,0,1,null,1
+plot3D,createsurfs,1,0,0,double[],1
+plot3D,createsurfs,1,0,1,null,1
+plot3D,createsurfs,2,0,0,double,1
+plot3D,createsurfs,3,0,0,class<`matrix`>,1
+plot3D,createsurfs,3,0,1,null,1
+plot3D,createsurfs,4,0,0,any,1
+plot3D,createsurfs,5,0,0,double,1
+plot3D,createvoxel,-1,0,0,list<class<`array`> | double[]>,1
+plot3D,createvoxel,-1,0,1,list<double[]>,1
+plot3D,createvoxel,0,0,0,class<`array`>,1
+plot3D,createvoxel,0,0,1,double[],1
+plot3D,createvoxel,1,0,0,class<`array`>,1
+plot3D,createvoxel,1,0,1,double[],1
+plot3D,createvoxel,2,0,0,class<`array`>,1
+plot3D,createvoxel,2,0,1,double[],1
+plot3D,createvoxel,3,0,0,class<`array`>,1
+plot3D,createvoxel,4,0,0,double,1
+plot3D,createvoxel,5,0,0,double,1
+plot3D,createvoxel,6,0,0,character,1
+plot3D,drawallcols,-1,0,0,null,1
+plot3D,drawallcols,0,0,0,"class<`list`, `plist`>",1
+plot3D,drawcolkey,-1,0,0,null,1
+plot3D,drawcolkey,-1,0,1,list<logical>,1
+plot3D,drawcolkey,0,0,0,list<null | character | double[]>,1
+plot3D,drawcolkey,0,0,1,list<null | double[]>,1
+plot3D,drawcolkey,0,0,2,list<null | double[] | character[]>,1
+plot3D,drawcolkey,0,0,3,list<null | character[] | double[]>,1
+plot3D,drawcolkey,0,0,4,list<character | null | double[]>,1
+plot3D,drawcolkey,1,0,0,any,1
+plot3D,drawcolkey,2,0,0,any,1
+plot3D,drawcolkey,3,0,0,any,1
+plot3D,drawcolkey,4,0,0,any,1
+plot3D,drawcolkey,5,0,0,logical,1
+plot3D,drawfullbox,-1,0,0,null,1
+plot3D,drawfullbox,0,0,0,"class<`list`, `plist`>",1
+plot3D,expanddotslist,-1,0,0,list<character>,1
+plot3D,expanddotslist,-1,0,1,list<double[]>,1
+plot3D,expanddotslist,-1,0,2,null,1
+plot3D,expanddotslist,0,0,0,list<character>,1
+plot3D,expanddotslist,0,0,1,list<double[]>,1
+plot3D,expanddotslist,0,0,2,null,1
+plot3D,expanddotslist,1,0,0,any,1
+plot3D,expand.sort,-1,0,0,list<integer[]>,1
+plot3D,expand.sort,0,0,0,integer[],1
+plot3D,expand.sort,1,0,0,double[],1
+plot3D,extend,-1,0,0,double[],1
+plot3D,extend,0,0,0,double[],1
+plot3D,extend,-1,1,0,class<`matrix`>,1
+plot3D,extend,0,1,0,class<`matrix`>,1
+plot3D,extend,1,1,0,logical,1
+plot3D,extend.na,-1,0,0,class<`matrix`>,1
+plot3D,extend.na,0,0,0,class<`matrix`>,1
+plot3D,extendvec,-1,0,0,double[],1
+plot3D,extendvec,0,0,0,double[],1
+plot3D,facetcols,-1,0,0,character[],1
+plot3D,facetcols,0,0,0,class<`matrix`>,1
+plot3D,facetcols,1,0,0,class<`matrix`>,1
+plot3D,facetcols,2,0,0,class<`matrix`>,1
+plot3D,facetcols,3,0,0,character[],1
+plot3D,facetcols,4,0,0,list<double | character>,1
+plot3D,facetcols,4,0,1,list<double | null | character>,1
+plot3D,facetcols,5,0,0,logical,1
+plot3D,facetcolsImage,-1,0,0,character[],1
+plot3D,facetcolsImage,0,0,0,class<`matrix`>,1
+plot3D,facetcolsImage,0,0,1,double[],1
+plot3D,facetcolsImage,1,0,0,class<`matrix`>,1
+plot3D,facetcolsImage,1,0,1,double[],1
+plot3D,facetcolsImage,2,0,0,class<`matrix`>,1
+plot3D,facetcolsImage,3,0,0,null,1
+plot3D,facetcolsImage,4,0,0,null,1
+plot3D,facetcolsImage,5,0,0,null,1
+plot3D,facetcolsImage,6,0,0,double,1
+plot3D,facetcolsImage,6,0,1,null,1
+plot3D,facetcolsImage,7,0,0,logical,1
+plot3D,facetcolsImage,8,0,0,null,1
+plot3D,facetcolsImage,9,0,0,double,1
+plot3D,facetcolsImage,10,0,0,double,1
+plot3D,facetcolsImage,11,0,0,character[],1
+plot3D,facetcolsImage,12,0,0,any,1
+plot3D,facetcols.light,-1,0,0,character[],1
+plot3D,facetcols.light,0,0,0,double[],1
+plot3D,facetcols.light,1,0,0,list<class<`matrix`>>,1
+plot3D,facetcols.light,1,0,1,list<double[]>,1
+plot3D,facetcols.light,2,0,0,character[],1
+plot3D,facetcols.light,3,0,0,list<double | null | character>,1
+plot3D,facetcols.light,3,0,1,list<null | character>,1
+plot3D,facetcols.light,3,0,2,list<double | character>,1
+plot3D,facetcols.light,3,0,3,list<null | double | character>,1
+plot3D,facetcols.shade,-1,0,0,character[],1
+plot3D,facetcols.shade,0,0,0,double[],1
+plot3D,facetcols.shade,1,0,0,list<class<`matrix`>>,1
+plot3D,facetcols.shade,1,0,1,list<double[]>,1
+plot3D,facetcols.shade,2,0,0,^character[],1
+plot3D,facetcols.shade,3,0,0,double,1
+plot3D,facetcols.shadelight,-1,0,0,character[],1
+plot3D,facetcols.shadelight,0,0,0,double[],1
+plot3D,facetcols.shadelight,1,0,0,list<class<`matrix`>>,1
+plot3D,facetcols.shadelight,1,0,1,list<double[]>,1
+plot3D,facetcols.shadelight,2,0,0,^character[],1
+plot3D,facetcols.shadelight,3,0,0,list<double | character>,1
+plot3D,facetcols.shadelight,3,0,1,list<double | null | character>,1
+plot3D,facetcols.shadelight,3,0,2,list<null | character>,1
+plot3D,facetcols.shadelight,3,0,3,list<null | double | character>,1
+plot3D,facetcols.tri,-1,0,0,character[],1
+plot3D,facetcols.tri,0,0,0,class<`matrix`>,1
+plot3D,facetcols.tri,1,0,0,character[],1
+plot3D,facetcols.tri,2,0,0,list<double | character>,1
+plot3D,facetcols.tri,2,0,1,list<double | null | character>,1
+plot3D,FindInterval,-1,0,0,double[],1
+plot3D,FindInterval,0,0,0,class<`matrix`>,1
+plot3D,FindInterval,0,0,1,double[],1
+plot3D,FindInterval,1,0,0,class<`array`>,1
+plot3D,FindInterval,1,0,1,double[],1
+plot3D,FindInterval,2,0,0,...,1
+plot3D,getplist,-1,0,0,"class<`list`, `plist`>",1
+plot3D,gg2.col,-1,0,0,character[],1
+plot3D,gg2.col,0,0,0,double,1
+plot3D,gg2.col,1,0,0,double,1
+plot3D,gg.col,-1,0,0,character[],1
+plot3D,gg.col,0,0,0,double,1
+plot3D,gg.col,1,0,0,double,1
+plot3D,grid.panels,-1,0,0,null,1
+plot3D,grid.panels,0,0,0,logical[],1
+plot3D,grid.panels,1,0,0,double[],1
+plot3D,grid.panels,2,0,0,double[],1
+plot3D,grid.panels,3,0,0,double[],1
+plot3D,grid.panels,4,0,0,class<`matrix`>,1
+plot3D,grid.panels,5,0,0,character,1
+plot3D,grid.panels,6,0,0,null,1
+plot3D,grid.panels,7,0,0,double,1
+plot3D,hist3D,-1,0,0,class<`matrix`>,1
+plot3D,hist3D,0,0,0,double[],1
+plot3D,hist3D,1,0,0,double[],1
+plot3D,hist3D,2,0,0,class<`matrix`>,1
+plot3D,hist3D,3,0,0,...,1
+plot3D,hist3D,4,0,0,class<`matrix`>,1
+plot3D,hist3D,5,0,0,double,1
+plot3D,hist3D,6,0,0,double,1
+plot3D,hist3D,7,0,0,character,1
+plot3D,hist3D,7,0,1,null,1
+plot3D,hist3D,8,0,0,character,1
+plot3D,hist3D,9,0,0,null,1
+plot3D,hist3D,10,0,0,character,1
+plot3D,hist3D,10,0,1,null,1
+plot3D,hist3D,11,0,0,logical,1
+plot3D,hist3D,11,0,1,null,1
+plot3D,hist3D,12,0,0,null,1
+plot3D,hist3D,13,0,0,logical,1
+plot3D,hist3D,14,0,0,logical,1
+plot3D,hist3D,15,0,0,null,1
+plot3D,image2D,-1,0,0,null,1
+plot3D,image2D,-1,0,1,list<double[]>,1
+plot3D,image2D,0,0,0,class<`array`>,1
+plot3D,image2D,0,0,1,list<class<`matrix`>>,1
+plot3D,image2D,0,0,2,class<`matrix`>,1
+plot3D,image2D,0,0,3,list<double[] | class<`matrix`>>,1
+plot3D,image2D,1,0,0,...,1
+plot3D,image2D.array,-1,0,0,null,1
+plot3D,image2D.array,0,0,0,class<`array`>,1
+plot3D,image2D.array,1,0,0,double[],1
+plot3D,image2D.array,2,0,0,any,1
+plot3D,image2D.array,3,0,0,null,1
+plot3D,image2D.array,4,0,0,...,1
+plot3D,image2D.list,-1,0,0,null,1
+plot3D,image2D.list,-1,0,1,list<double[]>,1
+plot3D,image2D.list,0,0,0,list<class<`matrix`>>,1
+plot3D,image2D.list,0,0,1,list<double[] | class<`matrix`>>,1
+plot3D,image2D.list,1,0,0,...,1
+plot3D,image2D.matrix,-1,0,0,list<double[]>,1
+plot3D,image2D.matrix,0,0,0,class<`matrix`>,1
+plot3D,image2D.matrix,1,0,0,double[],1
+plot3D,image2D.matrix,1,0,1,class<`array`>,1
+plot3D,image2D.matrix,1,0,2,class<`matrix`>,1
+plot3D,image2D.matrix,2,0,0,double[],1
+plot3D,image2D.matrix,2,0,1,class<`array`>,1
+plot3D,image2D.matrix,2,0,2,class<`matrix`>,1
+plot3D,image2D.matrix,3,0,0,any,1
+plot3D,image2D.matrix,4,0,0,...,1
+plot3D,image2D.matrix,5,0,0,null,1
+plot3D,image2D.matrix,5,0,1,character[],1
+plot3D,image2D.matrix,6,0,0,character,1
+plot3D,image2D.matrix,7,0,0,null,1
+plot3D,image2D.matrix,7,0,1,double[],1
+plot3D,image2D.matrix,8,0,0,null,1
+plot3D,image2D.matrix,8,0,1,character,1
+plot3D,image2D.matrix,9,0,0,logical,1
+plot3D,image2D.matrix,10,0,0,logical,1
+plot3D,image2D.matrix,10,0,1,list<double | character>,1
+plot3D,image2D.matrix,10,0,2,list<double[]>,1
+plot3D,image2D.matrix,10,0,3,list<double | character[]>,1
+plot3D,image2D.matrix,10,0,4,list<character | double>,1
+plot3D,image2D.matrix,11,0,0,null,1
+plot3D,image2D.matrix,11,0,1,logical,1
+plot3D,image2D.matrix,11,0,2,list<double | character>,1
+plot3D,image2D.matrix,11,0,3,list<double>,1
+plot3D,image2D.matrix,12,0,0,double,1
+plot3D,image2D.matrix,13,0,0,null,1
+plot3D,image2D.matrix,13,0,1,character[],1
+plot3D,image2D.matrix,14,0,0,logical,1
+plot3D,image2D.matrix,15,0,0,null,1
+plot3D,image2D.matrix,15,0,1,double,1
+plot3D,image3D,-1,0,0,class<`matrix`>,1
+plot3D,image3D,0,0,0,double[],1
+plot3D,image3D,0,0,1,null,1
+plot3D,image3D,1,0,0,double[],1
+plot3D,image3D,1,0,1,null,1
+plot3D,image3D,2,0,0,double[],1
+plot3D,image3D,2,0,1,null,1
+plot3D,image3D,3,0,0,...,1
+plot3D,image3D,4,0,0,class<`matrix`>,1
+plot3D,image3D,4,0,1,null,1
+plot3D,image3D,5,0,0,double,1
+plot3D,image3D,6,0,0,double,1
+plot3D,image3D,7,0,0,null,1
+plot3D,image3D,7,0,1,character,1
+plot3D,image3D,8,0,0,character,1
+plot3D,image3D,9,0,0,null,1
+plot3D,image3D,10,0,0,null,1
+plot3D,image3D,10,0,1,character,1
+plot3D,image3D,11,0,0,logical,1
+plot3D,image3D,11,0,1,null,1
+plot3D,image3D,12,0,0,null,1
+plot3D,image3D,12,0,1,logical,1
+plot3D,image3D,12,0,2,list<double>,1
+plot3D,image3D,13,0,0,double,1
+plot3D,image3D,14,0,0,null,1
+plot3D,image3D,15,0,0,null,1
+plot3D,image3D,15,0,1,double[],1
+plot3D,ImageOcean,-1,0,0,list<double[]>,1
+plot3D,ImageOcean,0,0,0,...,1
+plot3D,initplist,-1,0,0,"class<`list`, `plist`>",1
+plot3D,initplist,-1,0,1,null,1
+plot3D,initplist,0,0,0,logical,1
+plot3D,is.colkey,-1,0,0,logical,1
+plot3D,is.colkey,0,0,0,logical,1
+plot3D,is.colkey,0,0,1,null,1
+plot3D,is.colkey,0,0,2,list<double[]>,1
+plot3D,is.colkey,0,0,3,list<double[] | character[]>,1
+plot3D,is.colkey,0,0,4,list<double | character>,1
+plot3D,is.colkey,0,0,5,list<null | double[] | character[]>,1
+plot3D,is.colkey,0,0,6,list<null | double[]>,1
+plot3D,is.colkey,1,0,0,any,1
+plot3D,isosurf3D,-1,0,0,class<`matrix`>,1
+plot3D,isosurf3D,0,0,0,double[],1
+plot3D,isosurf3D,1,0,0,double[],1
+plot3D,isosurf3D,2,0,0,double[],1
+plot3D,isosurf3D,3,0,0,class<`array`>,1
+plot3D,isosurf3D,4,0,0,...,1
+plot3D,isosurf3D,5,0,0,double,1
+plot3D,isosurf3D,6,0,0,double,1
+plot3D,isosurf3D,7,0,0,double[],1
+plot3D,isosurf3D,8,0,0,class<`function`>,1
+plot3D,isosurf3D,9,0,0,character[],1
+plot3D,isosurf3D,10,0,0,null,1
+plot3D,isosurf3D,10,0,1,character,1
+plot3D,isosurf3D,11,0,0,logical,1
+plot3D,isosurf3D,12,0,0,null,1
+plot3D,isosurf3D,13,0,0,null,1
+plot3D,isosurf3D,14,0,0,character,1
+plot3D,isosurf3D,14,0,1,null,1
+plot3D,isosurf3D,15,0,0,character,1
+plot3D,ispresent,-1,0,0,logical,1
+plot3D,ispresent,0,0,0,character[],1
+plot3D,ispresent,0,0,1,class<`array`>,1
+plot3D,ispresent,0,0,2,class<`matrix`>,1
+plot3D,ispresent,0,0,3,double[],1
+plot3D,ispresent,0,0,4,^logical[],1
+plot3D,ispresent,0,0,5,null,1
+plot3D,jet2.col,-1,0,0,character[],1
+plot3D,jet2.col,0,0,0,double,1
+plot3D,jet2.col,1,0,0,double,1
+plot3D,jet.col,-1,0,0,character[],1
+plot3D,jet.col,0,0,0,double,1
+plot3D,jet.col,1,0,0,double,1
+plot3D,key.parleg,-1,0,0,list<null | double[] | character[]>,1
+plot3D,key.parleg,-1,0,1,list<null | character | double[]>,1
+plot3D,key.parleg,-1,0,2,list<null | character[] | double[]>,1
+plot3D,key.parleg,-1,0,3,list<null | double[]>,1
+plot3D,key.parleg,-1,0,4,list<character | null | double[]>,1
+plot3D,key.parleg,0,0,0,list<any>,1
+plot3D,key.parleg,1,0,0,logical,1
+plot3D,lines2D,-1,0,0,list<double[]>,1
+plot3D,lines2D,0,0,0,class<`ts`>,1
+plot3D,lines2D,1,0,0,class<`ts`>,1
+plot3D,lines2D,2,0,0,...,1
+plot3D,mapimg,-1,0,0,"class<`list`, `plist`>",1
+plot3D,mapimg,0,0,0,"class<`list`, `plist`>",1
+plot3D,meangrid,-1,0,0,class<`matrix`>,1
+plot3D,meangrid,0,0,0,class<`matrix`>,1
+plot3D,meangrid,1,0,0,logical,1
+plot3D,meangrid.na,-1,0,0,class<`matrix`>,1
+plot3D,meangrid.na,0,0,0,class<`matrix`>,1
+plot3D,mesh,-1,0,0,list<class<`array`>>,1
+plot3D,mesh,-1,0,1,list<class<`matrix`>>,1
+plot3D,mesh,0,0,0,class<`array`>,1
+plot3D,mesh,0,0,1,double[],1
+plot3D,mesh,1,0,0,class<`array`>,1
+plot3D,mesh,1,0,1,double[],1
+plot3D,mesh,2,0,0,class<`array`>,1
+plot3D,mesh,2,0,1,double[],1
+plot3D,mesh,2,0,2,null,1
+plot3D,Mgrid.array,-1,0,0,list<class<`array`>>,1
+plot3D,Mgrid.array,0,0,0,class<`array`>,1
+plot3D,Mgrid.array,0,0,1,double[],1
+plot3D,Mgrid.array,1,0,0,class<`array`>,1
+plot3D,Mgrid.array,1,0,1,double[],1
+plot3D,Mgrid.array,2,0,0,class<`array`>,1
+plot3D,Mgrid.array,2,0,1,double[],1
+plot3D,Mgrid.matrix,-1,0,0,list<class<`matrix`>>,1
+plot3D,Mgrid.matrix,0,0,0,class<`array`>,1
+plot3D,Mgrid.matrix,0,0,1,double[],1
+plot3D,Mgrid.matrix,1,0,0,class<`array`>,1
+plot3D,Mgrid.matrix,1,0,1,double[],1
+plot3D,newlim,-1,0,0,double[],1
+plot3D,newlim,0,0,0,^double[],1
+plot3D,normal.matrix,-1,0,0,list<class<`matrix`>>,1
+plot3D,normal.matrix,0,0,0,class<`matrix`>,1
+plot3D,normal.matrix,1,0,0,class<`matrix`>,1
+plot3D,normal.matrix,2,0,0,class<`matrix`>,1
+plot3D,normal.matrix,3,0,0,logical,1
+plot3D,normal.matrix,4,0,0,logical,1
+plot3D,normal.points,-1,0,0,list<double[]>,1
+plot3D,normal.points,0,0,0,class<`matrix`>,1
+plot3D,normal.points,1,0,0,class<`matrix`>,1
+plot3D,normal.points,2,0,0,class<`matrix`>,1
+plot3D,normal.points,3,0,0,class<`matrix`>,1
+plot3D,normal.points.tri,-1,0,0,list<double[]>,1
+plot3D,normal.points.tri,0,0,0,class<`matrix`>,1
+plot3D,normal.points.tri,1,0,0,class<`matrix`>,1
+plot3D,normal.points.tri,2,0,0,class<`matrix`>,1
+plot3D,overrulepar,-1,0,0,list<double | character>,1
+plot3D,overrulepar,-1,0,1,list<double | character | null>,1
+plot3D,overrulepar,-1,0,2,list<double | null>,1
+plot3D,overrulepar,-1,0,3,list<null | double[] | character[]>,1
+plot3D,overrulepar,-1,0,4,list<null | double[]>,1
+plot3D,overrulepar,0,0,0,list<double | character | null>,1
+plot3D,overrulepar,0,0,1,list<double | null>,1
+plot3D,overrulepar,1,0,0,list<any>,1
+plot3D,paintit,-1,0,0,class<`poly`>,1
+plot3D,paintit,0,0,0,class<`matrix`>,1
+plot3D,paintit,0,0,1,null,1
+plot3D,paintit,1,0,0,class<`matrix`>,1
+plot3D,paintit,2,0,0,class<`matrix`>,1
+plot3D,paintit,3,0,0,class<`matrix`>,1
+plot3D,paintit,4,0,0,"class<`list`, `plist`>",1
+plot3D,paintit,5,0,0,character[],1
+plot3D,paintit,5,0,1,^logical[],1
+plot3D,paintit,6,0,0,character,1
+plot3D,paintit,7,0,0,double[],1
+plot3D,paintit,7,0,1,null,1
+plot3D,paintit,8,0,0,character,1
+plot3D,paintit,8,0,1,null,1
+plot3D,paintit,9,0,0,logical,1
+plot3D,paintit,9,0,1,null,1
+plot3D,paintit,10,0,0,double,1
+plot3D,paintit,10,0,1,null,1
+plot3D,paintit,11,0,0,double,1
+plot3D,paintit,11,0,1,null,1
+plot3D,paintit,12,0,0,list<logical | null | list<any>>,1
+plot3D,paintit,12,0,1,list<double | list<any>>,1
+plot3D,paintit,12,0,2,list<logical | null | list<character | double[] | double | double | null | character>>,1
+plot3D,paintit,13,0,0,logical,1
+plot3D,paintit,14,0,0,logical,1
+plot3D,paintit,15,0,0,null,1
+plot3D,paintit,15,0,1,double[],1
+plot3D,persp3D,-1,0,0,class<`matrix`>,1
+plot3D,persp3D,0,0,0,class<`matrix`>,1
+plot3D,persp3D,0,0,1,double[],1
+plot3D,persp3D,1,0,0,class<`matrix`>,1
+plot3D,persp3D,1,0,1,double[],1
+plot3D,persp3D,2,0,0,class<`matrix`>,1
+plot3D,persp3D,3,0,0,...,1
+plot3D,persp3D,4,0,0,class<`matrix`>,1
+plot3D,persp3D,4,0,1,null,1
+plot3D,persp3D,5,0,0,double,1
+plot3D,persp3D,6,0,0,double,1
+plot3D,persp3D,7,0,0,null,1
+plot3D,persp3D,7,0,1,character[],1
+plot3D,persp3D,8,0,0,character,1
+plot3D,persp3D,9,0,0,null,1
+plot3D,persp3D,9,0,1,double[],1
+plot3D,persp3D,10,0,0,null,1
+plot3D,persp3D,10,0,1,character,1
+plot3D,persp3D,11,0,0,logical,1
+plot3D,persp3D,11,0,1,null,1
+plot3D,persp3D,12,0,0,null,1
+plot3D,persp3D,12,0,1,logical,1
+plot3D,persp3D,12,0,2,list<double>,1
+plot3D,persp3D,13,0,0,double,1
+plot3D,persp3D,14,0,0,logical,1
+plot3D,persp3D,14,0,1,list<character[]>,1
+plot3D,persp3D,14,0,2,list<double>,1
+plot3D,persp3D,15,0,0,logical,1
+plot3D,persp3D,15,0,1,list<character[]>,1
+plot3D,persp3D,15,0,2,list<double | character>,1
+plot3D,perspbox,-1,0,0,class<`matrix`>,1
+plot3D,perspbox,0,0,0,class<`matrix`>,1
+plot3D,perspbox,0,0,1,double[],1
+plot3D,perspbox,1,0,0,class<`matrix`>,1
+plot3D,perspbox,1,0,1,double[],1
+plot3D,perspbox,2,0,0,class<`matrix`>,1
+plot3D,perspbox,2,0,1,double[],1
+plot3D,perspbox,3,0,0,character[],1
+plot3D,perspbox,4,0,0,...,1
+plot3D,perspbox,5,0,0,character,1
+plot3D,perspbox,6,0,0,null,1
+plot3D,perspbox,6,0,1,character,1
+plot3D,perspbox,7,0,0,double,1
+plot3D,perspbox,8,0,0,null,1
+plot3D,perspbox,8,0,1,character,1
+plot3D,perspbox,9,0,0,double,1
+plot3D,perspbox,10,0,0,double,1
+plot3D,perspbox,11,0,0,double,1
+plot3D,perspbox,12,0,0,character[],1
+plot3D,perspbox,12,0,1,null,1
+plot3D,perspbox,13,0,0,list<null | double[]>,1
+plot3D,perspbox,13,0,1,null,1
+plot3D,perspbox,13,0,2,list<double>,1
+plot3D,perspbox,13,0,3,logical,1
+plot3D,perspbox,13,0,4,list<null | double[] | character[]>,1
+plot3D,perspbox,14,0,0,logical,1
+plot3D,plistcolkey,-1,0,0,"class<`list`, `plist`>",1
+plot3D,plistcolkey,0,0,0,"class<`list`, `plist`>",1
+plot3D,plistcolkey,1,0,0,list<null | double[] | character[]>,1
+plot3D,plistcolkey,1,0,1,list<null | double[]>,1
+plot3D,plistcolkey,2,0,0,character[],1
+plot3D,plistcolkey,3,0,0,double[],1
+plot3D,plistcolkey,4,0,0,null,1
+plot3D,plistcolkey,4,0,1,character[],1
+plot3D,plistcolkey,5,0,0,logical,1
+plot3D,plistcolkey,6,0,0,logical,1
+plot3D,plistcolkey,7,0,0,character,1
+plot3D,plistcolkey,8,0,0,null,1
+plot3D,plistcolkey,8,0,1,double[],1
+plot3D,plot2D,-1,0,0,list<double[]>,1
+plot3D,plot2D,0,0,0,double[],1
+plot3D,plot2D,1,0,0,double[],1
+plot3D,plot2D,2,0,0,double[],1
+plot3D,plot2D,3,0,0,double[],1
+plot3D,plot2D,4,0,0,...,1
+plot3D,plot2D,5,0,0,integer[],1
+plot3D,plot2D,6,0,0,null,1
+plot3D,plot2D,7,0,0,character,1
+plot3D,plot2D,8,0,0,null,1
+plot3D,plot2D,9,0,0,logical,1
+plot3D,plot2D,9,0,1,null,1
+plot3D,plot2D,10,0,0,null,1
+plot3D,plot2D,11,0,0,null,1
+plot3D,plot2D,12,0,0,logical,1
+plot3D,plot2D,13,0,0,logical,1
+plot3D,plot2D,14,0,0,character,1
+plot3D,plotbox,-1,0,0,"class<`list`, `plist`>",1
+plot3D,plotbox,-1,0,1,list<any>,1
+plot3D,plotbox,0,0,0,"class<`list`, `plist`>",1
+plot3D,plotbox,0,0,1,list<any>,1
+plot3D,plot.CI.2d,-1,0,0,null,1
+plot3D,plot.CI.2d,0,0,0,list<any>,1
+plot3D,plot.CI.2d,1,0,0,double[],1
+plot3D,plot.CI.2d,2,0,0,double[],1
+plot3D,plot.CI.2d,3,0,0,any,1
+plot3D,plotdev,-1,0,0,"class<`list`, `plist`>",1
+plot3D,plotdev,0,0,0,...,1
+plot3D,plotlist3D,-1,0,0,list<null>,1
+plot3D,plotlist3D,-1,0,1,null,1
+plot3D,plotlist3D,0,0,0,"class<`list`, `plist`>",1
+plot3D,plot.plist,-1,0,0,"class<`list`, `plist`>",1
+plot3D,plot.plist,0,0,0,"class<`list`, `plist`>",1
+plot3D,plot.plist,1,0,0,...,1
+plot3D,plot.struct.3D,-1,0,0,"class<`list`, `plist`>",1
+plot3D,plot.struct.3D,0,0,0,"class<`list`, `plist`>",1
+plot3D,plot.struct.3D,1,0,0,class<`pt`>,1
+plot3D,plot.struct.3D,1,0,1,null,1
+plot3D,plot.struct.3D,2,0,0,null,1
+plot3D,plot.struct.3D,2,0,1,class<`CIpt`>,1
+plot3D,plot.struct.3D,3,0,0,class<`poly`>,1
+plot3D,plot.struct.3D,3,0,1,null,1
+plot3D,plot.struct.3D,4,0,0,null,1
+plot3D,plot.struct.3D,4,0,1,class<`segments`>,1
+plot3D,plot.struct.3D,5,0,0,null,1
+plot3D,plot.struct.3D,5,0,1,list<double[] | character[] | ^logical[]>,1
+plot3D,plot.struct.3D,6,0,0,null,1
+plot3D,plot.struct.3D,6,0,1,class<`arr`>,1
+plot3D,plot.struct.3D,7,0,0,null,1
+plot3D,plot.struct.3D,8,0,0,logical,1
+plot3D,points3D,-1,0,0,class<`matrix`>,1
+plot3D,points3D,0,0,0,class<`array`>,1
+plot3D,points3D,0,0,1,double[],1
+plot3D,points3D,1,0,0,class<`array`>,1
+plot3D,points3D,1,0,1,double[],1
+plot3D,points3D,2,0,0,class<`array`>,1
+plot3D,points3D,2,0,1,double[],1
+plot3D,points3D,3,0,0,...,1
+plot3D,polyfill,-1,0,0,class<`poly`>,1
+plot3D,polyfill,0,0,0,class<`matrix`>,1
+plot3D,polyfill,1,0,0,class<`matrix`>,1
+plot3D,polyfill,2,0,0,class<`matrix`>,1
+plot3D,polyfill,3,0,0,character[],1
+plot3D,polyfill,3,0,1,^logical[],1
+plot3D,polyfill,4,0,0,any,1
+plot3D,polyfill,5,0,0,logical,1
+plot3D,polyfill,5,0,1,null,1
+plot3D,polyfill,6,0,0,character,1
+plot3D,polyfill,6,0,1,null,1
+plot3D,polyfill,7,0,0,list<double[]>,1
+plot3D,polyfill,8,0,0,double,1
+plot3D,polyfill,8,0,1,null,1
+plot3D,polyfill,9,0,0,double,1
+plot3D,polyfill,9,0,1,null,1
+plot3D,polyfill,10,0,0,double[],1
+plot3D,polyfill,11,0,0,null,1
+plot3D,polyfill,11,0,1,double,1
+plot3D,polyfill2D,-1,0,0,class<`poly`>,1
+plot3D,polyfill2D,0,0,0,class<`matrix`>,1
+plot3D,polyfill2D,1,0,0,class<`matrix`>,1
+plot3D,polyfill2D,2,0,0,character[],1
+plot3D,polyfill2D,3,0,0,logical,1
+plot3D,polyfill2D,4,0,0,character,1
+plot3D,polyfill2D,4,0,1,null,1
+plot3D,polyfill2D,5,0,0,null,1
+plot3D,polyfill2D,6,0,0,null,1
+plot3D,polyfill2D,7,0,0,logical,1
+plot3D,polygon2D,-1,0,0,null,1
+plot3D,polygon2D,-1,0,1,list<double[]>,1
+plot3D,polygon2D,0,0,0,^double[],1
+plot3D,polygon2D,1,0,0,^double[],1
+plot3D,polygon2D,2,0,0,...,1
+plot3D,polygon2D,3,0,0,null,1
+plot3D,polygon2D,3,0,1,integer[],1
+plot3D,polygon2D,4,0,0,null,1
+plot3D,polygon2D,4,0,1,character[],1
+plot3D,polygon2D,5,0,0,character,1
+plot3D,polygon2D,6,0,0,null,1
+plot3D,polygon2D,7,0,0,null,1
+plot3D,polygon2D,7,0,1,character,1
+plot3D,polygon2D,8,0,0,logical,1
+plot3D,polygon2D,9,0,0,null,1
+plot3D,polygon2D,10,0,0,null,1
+plot3D,polygon2D,11,0,0,null,1
+plot3D,polygon2D,12,0,0,logical,1
+plot3D,polygon2D,13,0,0,logical,1
+plot3D,polygon3D,-1,0,0,class<`matrix`>,1
+plot3D,polygon3D,0,0,0,^double[],1
+plot3D,polygon3D,1,0,0,^double[],1
+plot3D,polygon3D,2,0,0,^double[],1
+plot3D,polygon3D,3,0,0,...,1
+plot3D,polygon3D,4,0,0,null,1
+plot3D,polygon3D,5,0,0,double,1
+plot3D,polygon3D,6,0,0,double,1
+plot3D,polygon3D,7,0,0,character[],1
+plot3D,polygon3D,7,0,1,null,1
+plot3D,polygon3D,8,0,0,character,1
+plot3D,polygon3D,9,0,0,null,1
+plot3D,polygon3D,10,0,0,character,1
+plot3D,polygon3D,10,0,1,null,1
+plot3D,polygon3D,11,0,0,logical,1
+plot3D,polygon3D,12,0,0,null,1
+plot3D,polygon3D,13,0,0,null,1
+plot3D,polygon3D,14,0,0,null,1
+plot3D,polygon3D,15,0,0,null,1
+plot3D,proj3D,-1,0,0,"class<`list`, `plist`>",1
+plot3D,proj3D,0,0,0,"class<`list`, `plist`>",1
+plot3D,proj3D,1,0,0,list<null | double>,1
+plot3D,proj3D,1,0,1,list<null | double[]>,1
+plot3D,proj3D,1,0,2,list<double | null>,1
+plot3D,project,-1,0,0,double[],1
+plot3D,project,0,0,0,class<`array`>,1
+plot3D,project,0,0,1,class<`matrix`>,1
+plot3D,project,0,0,2,double[],1
+plot3D,project,1,0,0,class<`array`>,1
+plot3D,project,1,0,1,class<`matrix`>,1
+plot3D,project,1,0,2,double[],1
+plot3D,project,2,0,0,any,1
+plot3D,project,3,0,0,"class<`list`, `plist`>",1
+plot3D,project,4,0,0,logical,1
+plot3D,ramp.col,-1,0,0,character[],1
+plot3D,ramp.col,0,0,0,character[],1
+plot3D,ramp.col,1,0,0,double,1
+plot3D,ramp.col,2,0,0,double,1
+plot3D,rect2D,-1,0,0,list<double[]>,1
+plot3D,rect2D,0,0,0,double[],1
+plot3D,rect2D,1,0,0,double[],1
+plot3D,rect2D,2,0,0,double[],1
+plot3D,rect2D,3,0,0,double[],1
+plot3D,rect2D,4,0,0,...,1
+plot3D,rect2D,5,0,0,integer[],1
+plot3D,rect2D,6,0,0,null,1
+plot3D,rect2D,7,0,0,character,1
+plot3D,rect2D,8,0,0,null,1
+plot3D,rect2D,9,0,0,null,1
+plot3D,rect2D,10,0,0,null,1
+plot3D,rect2D,11,0,0,null,1
+plot3D,rect2D,12,0,0,logical,1
+plot3D,rect2D,13,0,0,logical,1
+plot3D,rect3D,-1,0,0,class<`matrix`>,1
+plot3D,rect3D,0,0,0,double[],1
+plot3D,rect3D,1,0,0,double[],1
+plot3D,rect3D,2,0,0,double[],1
+plot3D,rect3D,3,0,0,double[],1
+plot3D,rect3D,4,0,0,double[],1
+plot3D,rect3D,4,0,1,null,1
+plot3D,rect3D,5,0,0,null,1
+plot3D,rect3D,5,0,1,double,1
+plot3D,rect3D,6,0,0,...,1
+plot3D,rect3D,7,0,0,null,1
+plot3D,rect3D,8,0,0,double,1
+plot3D,rect3D,9,0,0,double,1
+plot3D,rect3D,10,0,0,character[],1
+plot3D,rect3D,10,0,1,null,1
+plot3D,rect3D,11,0,0,character,1
+plot3D,rect3D,12,0,0,null,1
+plot3D,rect3D,13,0,0,character,1
+plot3D,rect3D,14,0,0,logical,1
+plot3D,rect3D,14,0,1,null,1
+plot3D,rect3D,15,0,0,null,1
+plot3D,remapxy,-1,0,0,class<`matrix`>,1
+plot3D,remapxy,0,0,0,class<`matrix`>,1
+plot3D,remapxy,1,0,0,class<`array`>,1
+plot3D,remapxy,1,0,1,double[],1
+plot3D,remapxy,2,0,0,class<`array`>,1
+plot3D,remapxy,2,0,1,double[],1
+plot3D,remapxy,3,0,0,double[],1
+plot3D,remapxy,4,0,0,double[],1
+plot3D,remapxy,5,0,0,logical,1
+plot3D,ribbon3D,-1,0,0,class<`matrix`>,1
+plot3D,ribbon3D,0,0,0,double[],1
+plot3D,ribbon3D,1,0,0,double[],1
+plot3D,ribbon3D,2,0,0,class<`matrix`>,1
+plot3D,ribbon3D,3,0,0,...,1
+plot3D,ribbon3D,4,0,0,class<`matrix`>,1
+plot3D,ribbon3D,5,0,0,double,1
+plot3D,ribbon3D,6,0,0,double,1
+plot3D,ribbon3D,7,0,0,character,1
+plot3D,ribbon3D,7,0,1,null,1
+plot3D,ribbon3D,8,0,0,character,1
+plot3D,ribbon3D,9,0,0,null,1
+plot3D,ribbon3D,10,0,0,character,1
+plot3D,ribbon3D,10,0,1,null,1
+plot3D,ribbon3D,11,0,0,logical,1
+plot3D,ribbon3D,12,0,0,null,1
+plot3D,ribbon3D,12,0,1,list<double>,1
+plot3D,ribbon3D,13,0,0,double,1
+plot3D,ribbon3D,14,0,0,logical,1
+plot3D,ribbon3D,15,0,0,logical,1
+plot3D,scatter2D,-1,0,0,list<double[]>,1
+plot3D,scatter2D,0,0,0,class<`matrix`>,1
+plot3D,scatter2D,0,0,1,class<`ts`>,1
+plot3D,scatter2D,0,0,2,double[],1
+plot3D,scatter2D,1,0,0,class<`matrix`>,1
+plot3D,scatter2D,1,0,1,class<`ts`>,1
+plot3D,scatter2D,1,0,2,double[],1
+plot3D,scatter2D,2,0,0,...,1
+plot3D,scatter2D,3,0,0,class<`matrix`>,1
+plot3D,scatter2D,3,0,1,class<`ts`>,1
+plot3D,scatter2D,3,0,2,null,1
+plot3D,scatter2D,3,0,3,double[],1
+plot3D,scatter2D,4,0,0,null,1
+plot3D,scatter2D,4,0,1,character[],1
+plot3D,scatter2D,5,0,0,character,1
+plot3D,scatter2D,6,0,0,null,1
+plot3D,scatter2D,7,0,0,null,1
+plot3D,scatter2D,7,0,1,logical,1
+plot3D,scatter2D,8,0,0,null,1
+plot3D,scatter2D,8,0,1,double[],1
+plot3D,scatter2D,9,0,0,null,1
+plot3D,scatter2D,9,0,1,character,1
+plot3D,scatter2D,10,0,0,null,1
+plot3D,scatter2D,10,0,1,list<double | class<`matrix`>>,1
+plot3D,scatter2D,10,0,2,list<double | class<`matrix`> | character>,1
+plot3D,scatter2D,11,0,0,logical,1
+plot3D,scatter2D,12,0,0,logical,1
+plot3D,scatter3D,-1,0,0,class<`matrix`>,1
+plot3D,scatter3D,0,0,0,class<`array`>,1
+plot3D,scatter3D,0,0,1,class<`matrix`>,1
+plot3D,scatter3D,0,0,2,double[],1
+plot3D,scatter3D,1,0,0,class<`array`>,1
+plot3D,scatter3D,1,0,1,class<`matrix`>,1
+plot3D,scatter3D,1,0,2,double[],1
+plot3D,scatter3D,2,0,0,class<`array`>,1
+plot3D,scatter3D,2,0,1,class<`matrix`>,1
+plot3D,scatter3D,2,0,2,double[],1
+plot3D,scatter3D,3,0,0,...,1
+plot3D,scatter3D,4,0,0,class<`array`>,1
+plot3D,scatter3D,4,0,1,double[],1
+plot3D,scatter3D,5,0,0,double,1
+plot3D,scatter3D,6,0,0,double,1
+plot3D,scatter3D,7,0,0,character[],1
+plot3D,scatter3D,7,0,1,null,1
+plot3D,scatter3D,8,0,0,character,1
+plot3D,scatter3D,9,0,0,null,1
+plot3D,scatter3D,10,0,0,logical,1
+plot3D,scatter3D,10,0,1,null,1
+plot3D,scatter3D,10,0,2,list<double[] | character[]>,1
+plot3D,scatter3D,10,0,3,list<double>,1
+plot3D,scatter3D,11,0,0,null,1
+plot3D,scatter3D,11,0,1,class<`function`>,1
+plot3D,scatter3D,12,0,0,null,1
+plot3D,scatter3D,12,0,1,double[],1
+plot3D,scatter3D,13,0,0,null,1
+plot3D,scatter3D,13,0,1,character[],1
+plot3D,scatter3D,14,0,0,character,1
+plot3D,scatter3D,15,0,0,null,1
+plot3D,scatter3D,15,0,1,list<class<`matrix`>>,1
+plot3D,scatter3D,15,0,2,list<class<`matrix`> | double>,1
+plot3D,segments2D,-1,0,0,list<double[]>,1
+plot3D,segments2D,0,0,0,double[],1
+plot3D,segments2D,1,0,0,double[],1
+plot3D,segments2D,2,0,0,double[],1
+plot3D,segments2D,3,0,0,double[],1
+plot3D,segments2D,4,0,0,...,1
+plot3D,segments2D,5,0,0,integer[],1
+plot3D,segments2D,6,0,0,null,1
+plot3D,segments2D,7,0,0,character,1
+plot3D,segments2D,8,0,0,null,1
+plot3D,segments2D,9,0,0,logical,1
+plot3D,segments2D,10,0,0,null,1
+plot3D,segments2D,11,0,0,null,1
+plot3D,segments2D,12,0,0,logical,1
+plot3D,segments2D,13,0,0,logical,1
+plot3D,segments3D,-1,0,0,class<`matrix`>,1
+plot3D,segments3D,0,0,0,class<`matrix`>,1
+plot3D,segments3D,0,0,1,double[],1
+plot3D,segments3D,1,0,0,class<`matrix`>,1
+plot3D,segments3D,1,0,1,double[],1
+plot3D,segments3D,2,0,0,class<`matrix`>,1
+plot3D,segments3D,2,0,1,double[],1
+plot3D,segments3D,3,0,0,class<`matrix`>,1
+plot3D,segments3D,3,0,1,double[],1
+plot3D,segments3D,4,0,0,class<`matrix`>,1
+plot3D,segments3D,4,0,1,double[],1
+plot3D,segments3D,5,0,0,double[],1
+plot3D,segments3D,6,0,0,...,1
+plot3D,segments3D,7,0,0,null,1
+plot3D,segments3D,7,0,1,integer[],1
+plot3D,segments3D,8,0,0,double,1
+plot3D,segments3D,9,0,0,double,1
+plot3D,segments3D,10,0,0,character,1
+plot3D,segments3D,10,0,1,null,1
+plot3D,segments3D,11,0,0,character,1
+plot3D,segments3D,12,0,0,null,1
+plot3D,segments3D,13,0,0,null,1
+plot3D,segments3D,14,0,0,null,1
+plot3D,segments3D,15,0,0,null,1
+plot3D,selectplist,-1,0,0,"class<`list`, `plist`>",1
+plot3D,selectplist,0,0,0,"class<`list`, `plist`>",1
+plot3D,selectplist,1,0,0,class<`function`>,1
+plot3D,setalpha,-1,0,0,^character[],1
+plot3D,setalpha,-1,0,1,null,1
+plot3D,setalpha,0,0,0,^character[],1
+plot3D,setalpha,0,0,1,double[],1
+plot3D,setalpha,0,0,2,null,1
+plot3D,setalpha,1,0,0,any,1
+plot3D,setdots,-1,0,0,list<double[] | character[]>,1
+plot3D,setdots,0,0,0,list<double[] | character[] | class<`matrix`>>,1
+plot3D,setdots,1,0,0,integer,1
+plot3D,setlim,-1,0,0,list<double>,1
+plot3D,setlim,0,0,0,double[],1
+plot3D,setlim,1,0,0,double[],1
+plot3D,setlim,2,0,0,double[],1
+plot3D,setlim,3,0,0,logical,1
+plot3D,setlim,3,0,1,null,1
+plot3D,setlim,4,0,0,double,1
+plot3D,setlim,4,0,1,null,1
+plot3D,setplist,-1,0,0,"class<`list`, `plist`>",1
+plot3D,setplist,0,0,0,"class<`list`, `plist`>",1
+plot3D,setplotpar,-1,0,0,logical,1
+plot3D,setplotpar,0,0,0,list<class<`array`> | character[] | double[]>,1
+plot3D,setplotpar,0,0,1,list<class<`array`> | character | double[]>,1
+plot3D,setplotpar,0,0,2,list<class<`array`> | double[] | character[]>,1
+plot3D,setplotpar,0,0,3,list<class<`array`> | double[] | character>,1
+plot3D,setplotpar,1,0,0,integer,1
+plot3D,setplotpar,2,0,0,null,1
+plot3D,setuplight,-1,0,0,class<`matrix`>,1
+plot3D,setuplight,0,0,0,double,1
+plot3D,setuplight,1,0,0,double,1
+plot3D,slice3D,-1,0,0,class<`matrix`>,1
+plot3D,slice3D,0,0,0,class<`array`>,1
+plot3D,slice3D,0,0,1,double[],1
+plot3D,slice3D,1,0,0,class<`array`>,1
+plot3D,slice3D,1,0,1,double[],1
+plot3D,slice3D,2,0,0,class<`array`>,1
+plot3D,slice3D,2,0,1,double[],1
+plot3D,slice3D,3,0,0,class<`array`>,1
+plot3D,slice3D,4,0,0,...,1
+plot3D,slice3D,5,0,0,double,1
+plot3D,slice3D,6,0,0,double,1
+plot3D,slice3D,7,0,0,class<`matrix`>,1
+plot3D,slice3D,7,0,1,double[],1
+plot3D,slice3D,8,0,0,class<`matrix`>,1
+plot3D,slice3D,8,0,1,double[],1
+plot3D,slice3D,9,0,0,null,1
+plot3D,slice3D,9,0,1,class<`matrix`>,1
+plot3D,slice3D,9,0,2,double[],1
+plot3D,slice3D,10,0,0,null,1
+plot3D,slice3D,11,0,0,character,1
+plot3D,slice3D,12,0,0,null,1
+plot3D,slice3D,13,0,0,null,1
+plot3D,slice3D,13,0,1,character,1
+plot3D,slice3D,14,0,0,logical,1
+plot3D,slice3D,15,0,0,list<double>,1
+plot3D,slice3D,15,0,1,null,1
+plot3D,slicecont3D,-1,0,0,class<`matrix`>,1
+plot3D,slicecont3D,0,0,0,double[],1
+plot3D,slicecont3D,1,0,0,double[],1
+plot3D,slicecont3D,2,0,0,double[],1
+plot3D,slicecont3D,3,0,0,class<`array`>,1
+plot3D,slicecont3D,4,0,0,...,1
+plot3D,slicecont3D,5,0,0,double,1
+plot3D,slicecont3D,6,0,0,double,1
+plot3D,slicecont3D,7,0,0,null,1
+plot3D,slicecont3D,8,0,0,double[],1
+plot3D,slicecont3D,9,0,0,null,1
+plot3D,slicecont3D,10,0,0,null,1
+plot3D,slicecont3D,11,0,0,null,1
+plot3D,slicecont3D,12,0,0,character,1
+plot3D,slicecont3D,13,0,0,null,1
+plot3D,slicecont3D,14,0,0,character,1
+plot3D,slicecont3D,15,0,0,logical,1
+plot3D,Sortlist,-1,0,0,list<double[]>,1
+plot3D,Sortlist,0,0,0,class<`matrix`>,1
+plot3D,Sortlist,1,0,0,class<`matrix`>,1
+plot3D,Sortlist,2,0,0,any,1
+plot3D,Sortlist,3,0,0,"class<`list`, `plist`>",1
+plot3D,Sortlist,4,0,0,logical,1
+plot3D,sortlistvec,-1,0,0,list<double[]>,1
+plot3D,sortlistvec,0,0,0,double[],1
+plot3D,sortlistvec,1,0,0,double[],1
+plot3D,sortlistvec,2,0,0,any,1
+plot3D,sortlistvec,3,0,0,"class<`list`, `plist`>",1
+plot3D,sortlistvec,4,0,0,logical,1
+plot3D,spheresurf3D,-1,0,0,class<`matrix`>,1
+plot3D,spheresurf3D,0,0,0,class<`matrix`>,1
+plot3D,spheresurf3D,1,0,0,...,1
+plot3D,spheresurf3D,2,0,0,double,1
+plot3D,spheresurf3D,3,0,0,double,1
+plot3D,spheresurf3D,4,0,0,null,1
+plot3D,spheresurf3D,5,0,0,character,1
+plot3D,spheresurf3D,6,0,0,null,1
+plot3D,spheresurf3D,7,0,0,null,1
+plot3D,spheresurf3D,8,0,0,logical,1
+plot3D,spheresurf3D,9,0,0,logical,1
+plot3D,spheresurf3D,10,0,0,logical,1
+plot3D,spheresurf3D,10,0,1,null,1
+plot3D,spheresurf3D,11,0,0,double,1
+plot3D,spheresurf3D,12,0,0,null,1
+plot3D,spheresurf3D,13,0,0,null,1
+plot3D,spheresurf3D,14,0,0,null,1
+plot3D,spheresurf3D,15,0,0,character,1
+plot3D,splitdotpersp,-1,0,0,list<double | list<any>>,1
+plot3D,splitdotpersp,-1,0,1,list<double | list<character | double[] | double | double | null | character>>,1
+plot3D,splitdotpersp,-1,0,2,list<logical | null | list<null | character | double[] | character | double | double | null | character>>,1
+plot3D,splitdotpersp,-1,0,3,list<logical | null | list<any>>,1
+plot3D,splitdotpersp,-1,0,4,list<logical | null | list<character | double[] | double | double | null | character>>,1
+plot3D,splitdotpersp,-1,0,5,list<logical | null | list<character | double[] | class<`array`> | character | double | double | null | character>>,1
+plot3D,splitdotpersp,-1,0,6,list<logical | null | list<character | double[] | character | double | double | null | character>>,1
+plot3D,splitdotpersp,-1,0,7,list<logical | null | list<character | double[] | character | double | null | character>>,1
+plot3D,splitdotpersp,-1,0,8,list<logical | null | list<double[] | character | double | double | null | character>>,1
+plot3D,splitdotpersp,-1,0,9,list<logical | null | list<character | double[] | integer[] | double | null | character>>,1
+plot3D,splitdotpersp,-1,0,10,list<logical | null | list<character | double[] | double[] | double | null | character>>,1
+plot3D,splitdotpersp,-1,0,11,list<logical | null | list<character | double[] | double | null | character>>,1
+plot3D,splitdotpersp,-1,0,12,list<logical | null | list<character | double[] | double | character | double | null | character>>,1
+plot3D,splitdotpersp,0,0,0,list<any>,1
+plot3D,splitdotpersp,1,0,0,character,1
+plot3D,splitdotpersp,1,0,1,null,1
+plot3D,splitdotpersp,2,0,0,logical,1
+plot3D,splitdotpersp,2,0,1,null,1
+plot3D,splitdotpersp,2,0,2,list<double>,1
+plot3D,splitdotpersp,3,0,0,any,1
+plot3D,splitdotpersp,4,0,0,any,1
+plot3D,splitdotpersp,5,0,0,any,1
+plot3D,splitdotpersp,6,0,0,null,1
+plot3D,splitdotpersp,6,0,1,"class<`list`, `plist`>",1
+plot3D,splitdotpersp,7,0,0,double,1
+plot3D,splitdotpersp,7,0,1,null,1
+plot3D,splitdotpersp,8,0,0,double,1
+plot3D,splitdotpersp,9,0,0,double,1
+plot3D,splitdotpersp,10,0,0,null,1
+plot3D,splitdotpersp,10,0,1,double[],1
+plot3D,splitpardots,-1,0,0,list<null | logical | list<any>>,1
+plot3D,splitpardots,-1,0,1,list<null | double | list<any>>,1
+plot3D,splitpardots,-1,0,2,list<null | logical | list<double | character>>,1
+plot3D,splitpardots,-1,0,3,list<null | logical | list<double[] | character>>,1
+plot3D,splitpardots,-1,0,4,list<null | logical | list<double | character | character>>,1
+plot3D,splitpardots,-1,0,5,list<null | double | list<double | character>>,1
+plot3D,splitpardots,-1,0,6,list<null | logical | list<double[] | character | double[]>>,1
+plot3D,splitpardots,-1,0,7,list<null | logical | list<double[] | double[] | character>>,1
+plot3D,splitpardots,-1,0,8,list<null | logical | list<character | double | character>>,1
+plot3D,splitpardots,-1,0,9,list<null | logical | list<character | character | double>>,1
+plot3D,splitpardots,0,0,0,list<any>,1
+plot3D,start2Dplot,-1,0,0,list<any>,1
+plot3D,start2Dplot,0,0,0,list<any>,1
+plot3D,start2Dplot,1,0,0,class<`matrix`>,1
+plot3D,start2Dplot,1,0,1,class<`ts`>,1
+plot3D,start2Dplot,1,0,2,^double[],1
+plot3D,start2Dplot,2,0,0,class<`matrix`>,1
+plot3D,start2Dplot,2,0,1,class<`ts`>,1
+plot3D,start2Dplot,2,0,2,^double[],1
+plot3D,surf3D,-1,0,0,class<`matrix`>,1
+plot3D,surf3D,0,0,0,class<`matrix`>,1
+plot3D,surf3D,1,0,0,class<`matrix`>,1
+plot3D,surf3D,2,0,0,class<`matrix`>,1
+plot3D,surf3D,3,0,0,...,1
+plot3D,surf3D,4,0,0,class<`matrix`>,1
+plot3D,surf3D,4,0,1,null,1
+plot3D,surf3D,5,0,0,any,1
+plot3D,surf3D,6,0,0,any,1
+plot3D,surf3D,7,0,0,null,1
+plot3D,surf3D,7,0,1,character,1
+plot3D,surf3D,8,0,0,character,1
+plot3D,surf3D,9,0,0,null,1
+plot3D,surf3D,10,0,0,null,1
+plot3D,surf3D,10,0,1,character,1
+plot3D,surf3D,11,0,0,logical,1
+plot3D,surf3D,11,0,1,null,1
+plot3D,surf3D,12,0,0,any,1
+plot3D,surf3D,13,0,0,null,1
+plot3D,surf3D,14,0,0,null,1
+plot3D,surf3D,14,0,1,double[],1
+plot3D,surf3D,15,0,0,any,1
+plot3D,text2D,-1,0,0,list<double[]>,1
+plot3D,text2D,0,0,0,double[],1
+plot3D,text2D,1,0,0,double[],1
+plot3D,text2D,2,0,0,character[],1
+plot3D,text2D,3,0,0,...,1
+plot3D,text2D,4,0,0,double[],1
+plot3D,text2D,5,0,0,null,1
+plot3D,text2D,6,0,0,character,1
+plot3D,text2D,7,0,0,null,1
+plot3D,text2D,8,0,0,null,1
+plot3D,text2D,9,0,0,null,1
+plot3D,text2D,10,0,0,character,1
+plot3D,text2D,11,0,0,logical,1
+plot3D,text2D,12,0,0,logical,1
+plot3D,text3D,-1,0,0,class<`matrix`>,1
+plot3D,text3D,0,0,0,double[],1
+plot3D,text3D,1,0,0,double[],1
+plot3D,text3D,2,0,0,double[],1
+plot3D,text3D,3,0,0,character[],1
+plot3D,text3D,4,0,0,...,1
+plot3D,text3D,5,0,0,null,1
+plot3D,text3D,5,0,1,integer[],1
+plot3D,text3D,6,0,0,double,1
+plot3D,text3D,7,0,0,double,1
+plot3D,text3D,8,0,0,character[],1
+plot3D,text3D,8,0,1,null,1
+plot3D,text3D,9,0,0,character,1
+plot3D,text3D,10,0,0,null,1
+plot3D,text3D,11,0,0,logical,1
+plot3D,text3D,11,0,1,null,1
+plot3D,text3D,12,0,0,null,1
+plot3D,text3D,13,0,0,null,1
+plot3D,text3D,14,0,0,null,1
+plot3D,text3D,14,0,1,character[],1
+plot3D,text3D,15,0,0,character,1
+plot3D,trans3D,-1,0,0,list<class<`array`>>,1
+plot3D,trans3D,-1,0,1,list<class<`matrix`>>,1
+plot3D,trans3D,-1,0,2,list<double[]>,1
+plot3D,trans3D,0,0,0,class<`array`>,1
+plot3D,trans3D,0,0,1,class<`matrix`>,1
+plot3D,trans3D,0,0,2,double[],1
+plot3D,trans3D,1,0,0,class<`array`>,1
+plot3D,trans3D,1,0,1,class<`matrix`>,1
+plot3D,trans3D,1,0,2,double[],1
+plot3D,trans3D,2,0,0,class<`array`>,1
+plot3D,trans3D,2,0,1,class<`matrix`>,1
+plot3D,trans3D,2,0,2,double[],1
+plot3D,trans3D,3,0,0,class<`matrix`>,1
+plot3D,transmat,-1,0,0,class<`matrix`>,1
+plot3D,transmat,0,0,0,double,1
+plot3D,transmat,1,0,0,double,1
+plot3D,transmat,2,0,0,list<double>,1
+plot3D,transmat,3,0,0,double,1
+plot3D,transmat,3,0,1,null,1
+plot3D,transmat,4,0,0,double,1
+plot3D,transmat,4,0,1,null,1
+plot3D,triangle3D,-1,0,0,class<`matrix`>,1
+plot3D,triangle3D,0,0,0,class<`matrix`>,1
+plot3D,triangle3D,1,0,0,null,1
+plot3D,triangle3D,2,0,0,...,1
+plot3D,triangle3D,3,0,0,double,1
+plot3D,triangle3D,4,0,0,double,1
+plot3D,triangle3D,5,0,0,character,1
+plot3D,triangle3D,6,0,0,character,1
+plot3D,triangle3D,7,0,0,null,1
+plot3D,triangle3D,8,0,0,null,1
+plot3D,triangle3D,9,0,0,logical,1
+plot3D,triangle3D,10,0,0,null,1
+plot3D,triangle3D,11,0,0,null,1
+plot3D,triangle3D,12,0,0,logical,1
+plot3D,triangle3D,13,0,0,double,1
+plot3D,triangle3D,14,0,0,double,1
+plot3D,triangle3D,15,0,0,double,1
+plot3D,update.3D,-1,0,0,"class<`list`, `plist`>",1
+plot3D,update.3D,0,0,0,"class<`list`, `plist`>",1
+plot3D,update.3D,1,0,0,class<`pt`>,1
+plot3D,update.3D,1,0,1,null,1
+plot3D,update.3D,2,0,0,null,1
+plot3D,update.3D,2,0,1,class<`CIpt`>,1
+plot3D,update.3D,3,0,0,class<`poly`>,1
+plot3D,update.3D,3,0,1,null,1
+plot3D,update.3D,4,0,0,null,1
+plot3D,update.3D,4,0,1,class<`segments`>,1
+plot3D,update.3D,5,0,0,null,1
+plot3D,update.3D,5,0,1,list<double[] | character[] | ^logical[]>,1
+plot3D,update.3D,6,0,0,null,1
+plot3D,update.3D,6,0,1,class<`arr`>,1
+plot3D,update.3D,7,0,0,any,1
+plot3D,update.3D,8,0,0,logical,1
+plot3D,variablecol,-1,0,0,character[],1
+plot3D,variablecol,0,0,0,class<`array`>,1
+plot3D,variablecol,0,0,1,class<`matrix`>,1
+plot3D,variablecol,0,0,2,class<`ts`>,1
+plot3D,variablecol,0,0,3,double[],1
+plot3D,variablecol,1,0,0,character[],1
+plot3D,variablecol,2,0,0,character,1
+plot3D,variablecol,3,0,0,double[],1
+plot3D,variablecol,4,0,0,null,1
+plot3D,visibility,-1,0,0,logical[],1
+plot3D,visibility,0,0,0,double[],1
+plot3D,visibility,1,0,0,double[],1
+plot3D,visibility,2,0,0,double[],1
+plot3D,visibility,3,0,0,class<`matrix`>,1
+plot3D,voxel3D,-1,0,0,class<`matrix`>,1
+plot3D,voxel3D,0,0,0,double[],1
+plot3D,voxel3D,1,0,0,double[],1
+plot3D,voxel3D,2,0,0,double[],1
+plot3D,voxel3D,3,0,0,class<`array`>,1
+plot3D,voxel3D,4,0,0,...,1
+plot3D,voxel3D,5,0,0,double,1
+plot3D,voxel3D,6,0,0,double,1
+plot3D,voxel3D,7,0,0,double,1
+plot3D,voxel3D,8,0,0,double,1
+plot3D,voxel3D,9,0,0,character,1
+plot3D,voxel3D,10,0,0,null,1
+plot3D,voxel3D,11,0,0,character,1
+plot3D,voxel3D,12,0,0,null,1
+plot3D,voxel3D,13,0,0,logical,1
+plot3D,voxel3D,14,0,0,null,1
+plot3D,voxel3D,15,0,0,character,1
+plot3D,XYimage,-1,0,0,class<`poly`>,1
+plot3D,XYimage,0,0,0,class<`poly`>,1
+plot3D,XYimage,1,0,0,list<logical | character | list<any>>,1
+plot3D,XYimage,1,0,1,list<logical | character | list<character[]>>,1
+plot3D,XYimage,1,0,2,list<double | list<any>>,1
+plot3D,XYimage,2,0,0,double[],1
+plot3D,XYimage,3,0,0,double[],1
+plot3D,XYimage,4,0,0,class<`matrix`>,1
+plot3D,XYimage,5,0,0,"class<`list`, `plist`>",1
+plot3D,XYimage,6,0,0,any,1
+plot3D,XYimage,7,0,0,null,1
+plotly,%||%,-1,0,0,character[],1
+plotly,%||%,-1,0,1,class<`AsIs`>,1
+plotly,%||%,-1,0,2,"class<`character`, `plotly_default`>",1
+plotly,%||%,-1,0,3,class<`colorway`>,1
+plotly,%||%,-1,0,4,class<`Date`>,1
+plotly,%||%,-1,0,5,"class<`element`, `element_blank`>",1
+plotly,%||%,-1,0,6,"class<`element`, `element_line`>",1
+plotly,%||%,-1,0,7,"class<`element`, `element_text`>",1
+plotly,%||%,-1,0,8,class<`formula`>,1
+plotly,%||%,-1,0,9,"class<`formula`, `quosure`>",1
+plotly,%||%,-1,0,10,"class<`list`, `plotly_default`>",1
+plotly,%||%,-1,0,11,"class<`logical`, `plotly_default`>",1
+plotly,%||%,-1,0,12,class<`matrix`>,1
+plotly,%||%,-1,0,13,"class<`numeric`, `plotly_default`>",1
+plotly,%||%,-1,0,14,class<`ts`>,1
+plotly,%||%,-1,0,15,class<`unit`>,1
+plotly,%||%,-1,0,16,double[],1
+plotly,%||%,-1,0,17,list<any>,1
+plotly,%||%,-1,0,18,null,1
+plotly,%||%,0,0,0,character[],1
+plotly,%||%,0,0,1,null,1
+plotly,%||%,0,0,2,class<`waiver`>,1
+plotly,%||%,0,0,3,class<`AsIs`>,1
+plotly,%||%,0,0,4,class<`colorway`>,1
+plotly,%||%,0,0,5,class<`Date`>,1
+plotly,%||%,0,0,6,"class<`element`, `element_text`>",1
+plotly,%||%,0,0,7,class<`formula`>,1
+plotly,%||%,0,0,8,"class<`logical`, `plotly_default`>",1
+plotly,%||%,0,0,9,class<`matrix`>,1
+plotly,%||%,0,0,10,double[],1
+plotly,%||%,0,0,11,list<any>,1
+plotly,%||%,1,0,0,any,1
+plotly,%()%,-1,0,0,character[],1
+plotly,%()%,-1,0,1,double[],1
+plotly,%()%,0,0,0,null,1
+plotly,%()%,1,0,0,character[],1
+plotly,%()%,1,0,1,double[],1
+plotly,add_data,-1,0,0,"class<`htmlwidget`, `plotly`>",1
+plotly,add_data,0,0,0,"class<`htmlwidget`, `plotly`>",1
+plotly,add_data,1,0,0,class<`data.frame`>,1
+plotly,add_data,1,0,1,"class<`data.frame`, `plotly_data`, `spec_tbl_df`, `tbl`, `tbl_df`>",1
+plotly,add_data,1,0,2,"class<`data.frame`, `spec_tbl_df`, `tbl`, `tbl_df`>",1
+plotly,add_data,1,0,3,null,1
+plotly,add_heatmap,-1,0,0,"class<`htmlwidget`, `plotly`>",1
+plotly,add_heatmap,0,0,0,"class<`htmlwidget`, `plotly`>",1
+plotly,add_heatmap,1,0,0,null,1
+plotly,add_heatmap,2,0,0,null,1
+plotly,add_heatmap,3,0,0,null,1
+plotly,add_heatmap,4,0,0,...,1
+plotly,add_heatmap,5,0,0,null,1
+plotly,add_heatmap,6,0,0,logical,1
+plotly,add_lines,-1,0,0,"class<`htmlwidget`, `plotly`>",1
+plotly,add_lines,0,0,0,"class<`htmlwidget`, `plotly`>",1
+plotly,add_lines,1,0,0,null,1
+plotly,add_lines,2,0,0,null,1
+plotly,add_lines,3,0,0,null,1
+plotly,add_lines,4,0,0,...,1
+plotly,add_lines,5,0,0,null,1
+plotly,add_lines,6,0,0,logical,1
+plotly,add_markers,-1,0,0,"class<`htmlwidget`, `plotly`>",1
+plotly,add_markers,0,0,0,"class<`htmlwidget`, `plotly`>",1
+plotly,add_markers,1,0,0,class<`formula`>,1
+plotly,add_markers,1,0,1,double,1
+plotly,add_markers,1,0,2,null,1
+plotly,add_markers,2,0,0,class<`formula`>,1
+plotly,add_markers,2,0,1,double,1
+plotly,add_markers,2,0,2,null,1
+plotly,add_markers,3,0,0,null,1
+plotly,add_markers,4,0,0,...,1
+plotly,add_markers,5,0,0,null,1
+plotly,add_markers,6,0,0,logical,1
+plotly,add_paths,-1,0,0,"class<`htmlwidget`, `plotly`>",1
+plotly,add_paths,0,0,0,"class<`htmlwidget`, `plotly`>",1
+plotly,add_paths,1,0,0,null,1
+plotly,add_paths,2,0,0,null,1
+plotly,add_paths,3,0,0,null,1
+plotly,add_paths,4,0,0,...,1
+plotly,add_paths,5,0,0,null,1
+plotly,add_paths,6,0,0,logical,1
+plotly,add_ribbons,-1,0,0,"class<`htmlwidget`, `plotly`>",1
+plotly,add_ribbons,0,0,0,"class<`htmlwidget`, `plotly`>",1
+plotly,add_ribbons,1,0,0,null,1
+plotly,add_ribbons,2,0,0,class<`formula`>,1
+plotly,add_ribbons,3,0,0,class<`formula`>,1
+plotly,add_ribbons,4,0,0,...,1
+plotly,add_ribbons,5,0,0,null,1
+plotly,add_ribbons,6,0,0,logical,1
+plotly,add_text,-1,0,0,"class<`htmlwidget`, `plotly`>",1
+plotly,add_text,0,0,0,"class<`htmlwidget`, `plotly`>",1
+plotly,add_text,1,0,0,null,1
+plotly,add_text,2,0,0,null,1
+plotly,add_text,3,0,0,null,1
+plotly,add_text,4,0,0,character,1
+plotly,add_text,5,0,0,...,1
+plotly,add_text,6,0,0,null,1
+plotly,add_text,7,0,0,logical,1
+plotly,add_trace,-1,0,0,"class<`htmlwidget`, `plotly`>",1
+plotly,add_trace,0,0,0,"class<`htmlwidget`, `plotly`>",1
+plotly,add_trace,1,0,0,...,1
+plotly,add_trace,2,0,0,null,1
+plotly,add_trace,3,0,0,logical,1
+plotly,add_trace_classed,-1,0,0,"class<`htmlwidget`, `plotly`>",1
+plotly,add_trace_classed,0,0,0,"class<`htmlwidget`, `plotly`>",1
+plotly,add_trace_classed,1,0,0,character[],1
+plotly,add_trace_classed,2,0,0,...,1
+plotly,aes2plotly,-1,0,0,character,1
+plotly,aes2plotly,-1,0,1,double,1
+plotly,aes2plotly,0,0,0,"class<`GeomBar`, `data.frame`>",1
+plotly,aes2plotly,0,0,1,"class<`GeomLine`, `GeomPath`, `data.frame`>",1
+plotly,aes2plotly,0,0,2,"class<`GeomPath`, `GeomSmooth`, `data.frame`>",1
+plotly,aes2plotly,0,0,3,"class<`GeomPoint`, `data.frame`>",1
+plotly,aes2plotly,0,0,4,"class<`GeomPolygon`, `GeomSmooth`, `data.frame`>",1
+plotly,aes2plotly,1,0,0,any,1
+plotly,aes2plotly,2,0,0,character,1
+plotly,alpha_inherit,-1,0,0,"class<`character`, `colorway`, `plotly_default`>",1
+plotly,alpha_inherit,0,0,0,"class<`colorway`, `plotly_default`>",1
+plotly,alpha_inherit,1,0,0,"class<`character`, `colorway`, `plotly_default`>",1
+plotly,animation_opts,-1,0,0,"class<`htmlwidget`, `plotly`>",1
+plotly,animation_opts,0,0,0,"class<`htmlwidget`, `plotly`>",1
+plotly,animation_opts,1,0,0,double,1
+plotly,animation_opts,2,0,0,double,1
+plotly,animation_opts,3,0,0,character,1
+plotly,animation_opts,4,0,0,logical,1
+plotly,animation_opts,5,0,0,character,1
+plotly,animation_opts_format,-1,0,0,list<character | list<double | character | double>>,1
+plotly,animation_opts_format,0,0,0,double,1
+plotly,animation_opts_format,1,0,0,double,1
+plotly,animation_opts_format,2,0,0,character,1
+plotly,animation_opts_format,3,0,0,logical,1
+plotly,animation_opts_format,4,0,0,character,1
+plotly,arrange_safe,-1,0,0,"class<`data.frame`, `tbl`, `tbl_df`>",1
+plotly,arrange_safe,0,0,0,"class<`data.frame`, `tbl`, `tbl_df`>",1
+plotly,arrange_safe,1,0,0,character[],1
+plotly,as_widget,-1,0,0,"class<`htmlwidget`, `plotly`>",1
+plotly,as_widget,0,0,0,list<character | list<any>>,1
+plotly,as_widget,0,0,1,list<character | logical | list<any>>,1
+plotly,as_widget,0,0,2,list<list<character | list<double>>>,1
+plotly,as_widget,0,0,3,list<character | list<class<`function`> | null | list<double> | list<double[]>>>,1
+plotly,as_widget,0,0,4,list<character | list<class<`function`> | null | list<double> | list<class<`formula`> | double[]>>>,1
+plotly,as_widget,0,0,5,list<character | list<class<`function`> | null | list<double> | list<class<`formula`> | class<`AsIs`> | double[]>>>,1
+plotly,as_widget,0,0,6,list<character | list<class<`function`> | null | list<double> | list<character[] | class<`matrix`> | double[]>>>,1
+plotly,as_widget,0,0,7,list<character | list<class<`function`> | null | list<double> | list<class<`Date`> | double[]>>>,1
+plotly,as_widget,0,0,8,list<character | list<class<`function`> | null | list<double> | list<class<`formula`> | character | double[]>>>,1
+plotly,as_widget,0,0,9,list<character | list<class<`function`> | null | list<double> | list<class<`ts`> | double[]>>>,1
+plotly,as_widget,0,0,10,list<character | list<class<`function`> | null | list<double> | list<double[] | list<character | list<double | character>>>>>,1
+plotly,as_widget,0,0,11,list<character | list<class<`function`> | null | list<double> | list<double[] | list<character | list<character | double>>>>>,1
+plotly,as_widget,1,0,0,...,1
+plotly,attrs_name_check,-1,0,0,character[],1
+plotly,attrs_name_check,0,0,0,character[],1
+plotly,attrs_name_check,1,0,0,character[],1
+plotly,attrs_name_check,2,0,0,any,1
+plotly,attrs_selected,-1,0,0,list<double>,1
+plotly,attrs_selected,-1,0,1,list<character | double | list<character>>,1
+plotly,attrs_selected,0,0,0,double,1
+plotly,attrs_selected,1,0,0,...,1
+plotly,bbox,-1,0,0,list<double>,1
+plotly,bbox,0,0,0,character,1
+plotly,bbox,1,0,0,double,1
+plotly,bbox,2,0,0,double,1
+plotly,bboxes2range,-1,0,0,null,1
+plotly,bboxes2range,0,0,0,list<null>,1
+plotly,bboxes2range,1,0,0,...,1
+plotly,br,-1,0,0,character,1
+plotly,cartesian2geo,-1,0,0,"class<`htmlwidget`, `plotly`>",1
+plotly,cartesian2geo,0,0,0,"class<`htmlwidget`, `plotly`>",1
+plotly,coerce_attr_defaults,-1,0,0,"class<`list`, `plotly_heatmap`>",1
+plotly,coerce_attr_defaults,-1,0,1,"class<`list`, `plotly_line`>",1
+plotly,coerce_attr_defaults,-1,0,2,list<double[] | character>,1
+plotly,coerce_attr_defaults,-1,0,3,list<class<`Date`> | double[] | character>,1
+plotly,coerce_attr_defaults,-1,0,4,list<character[] | double[]>,1
+plotly,coerce_attr_defaults,-1,0,5,list<double[] | character | list<character | list<double | character>>>,1
+plotly,coerce_attr_defaults,0,0,0,"class<`list`, `plotly_heatmap`>",1
+plotly,coerce_attr_defaults,0,0,1,"class<`list`, `plotly_line`>",1
+plotly,coerce_attr_defaults,0,0,2,list<double[] | character>,1
+plotly,coerce_attr_defaults,0,0,3,list<class<`Date`> | double[] | character>,1
+plotly,coerce_attr_defaults,0,0,4,list<character[] | double[]>,1
+plotly,coerce_attr_defaults,0,0,5,list<double[] | character | list<character | list<double | character>>>,1
+plotly,coerce_attr_defaults,1,0,0,any,1
+plotly,colorbar,-1,0,0,"class<`htmlwidget`, `plotly`>",1
+plotly,colorbar,0,0,0,"class<`htmlwidget`, `plotly`>",1
+plotly,colorbar,1,0,0,...,1
+plotly,colorbar,2,0,0,double[],1
+plotly,colorbar,2,0,1,null,1
+plotly,colorbar,3,0,0,double,1
+plotly,colorbar_built,-1,0,0,"class<`htmlwidget`, `plotly`>",1
+plotly,colorbar_built,0,0,0,"class<`htmlwidget`, `plotly`>",1
+plotly,colorbar_built,1,0,0,...,1
+plotly,colorbar_built,2,0,0,double[],1
+plotly,colorbar_built,2,0,1,null,1
+plotly,colorbar_built,3,0,0,double,1
+plotly,colorscale_json,-1,0,0,"class<`matrix`, `plotly_default`>",1
+plotly,colorscale_json,-1,0,1,null,1
+plotly,colorscale_json,0,0,0,"class<`matrix`, `plotly_default`>",1
+plotly,colorscale_json,0,0,1,null,1
+plotly,colorway,-1,0,0,list<class<`colorway`>>,1
+plotly,colorway,0,0,0,"class<`htmlwidget`, `plotly`>",1
+plotly,colorway,0,0,1,null,1
+plotly,colorway_retrain,-1,0,0,list<list<any>>,1
+plotly,colorway_retrain,0,0,0,list<list<any>>,1
+plotly,colorway_retrain,1,0,0,list<class<`colorway`>>,1
+plotly,colourPickerLib,-1,0,0,class<`html_dependency`>,1
+plotly,compact,-1,0,0,list<any>,1
+plotly,compact,0,0,0,list<any>,1
+plotly,config,-1,0,0,"class<`htmlwidget`, `plotly`>",1
+plotly,config,0,0,0,"class<`htmlwidget`, `plotly`>",1
+plotly,config,1,0,0,...,1
+plotly,config,2,0,0,logical,1
+plotly,config,3,0,0,logical,1
+plotly,config,4,0,0,character,1
+plotly,config,4,0,1,null,1
+plotly,config,5,0,0,null,1
+plotly,config,5,0,1,character,1
+plotly,crosstalk_key,-1,0,0,character,1
+plotly,%|D|%,-1,0,0,"class<`character`, `plotly_default`>",1
+plotly,%|D|%,-1,0,1,"class<`logical`, `plotly_default`>",1
+plotly,%|D|%,-1,0,2,"class<`numeric`, `plotly_default`>",1
+plotly,%|D|%,-1,0,3,logical,1
+plotly,%|D|%,-1,0,4,null,1
+plotly,%|D|%,0,0,0,null,1
+plotly,%|D|%,0,0,1,"class<`logical`, `plotly_default`>",1
+plotly,%|D|%,0,0,2,logical,1
+plotly,%|D|%,1,0,0,any,1
+plotly,default,-1,0,0,"class<`character`, `plotly_default`>",1
+plotly,default,-1,0,1,"class<`colorway`, `plotly_default`>",1
+plotly,default,-1,0,2,"class<`list`, `plotly_default`>",1
+plotly,default,-1,0,3,"class<`logical`, `plotly_default`>",1
+plotly,default,-1,0,4,"class<`matrix`, `plotly_default`>",1
+plotly,default,-1,0,5,"class<`numeric`, `plotly_default`>",1
+plotly,default,0,0,0,character,1
+plotly,default,0,0,1,class<`colorway`>,1
+plotly,default,0,0,2,null,1
+plotly,default,0,0,3,class<`matrix`>,1
+plotly,default,0,0,4,double[],1
+plotly,deparse2,-1,0,0,character,1
+plotly,deparse2,-1,0,1,null,1
+plotly,deparse2,0,0,0,class<`formula`>,1
+plotly,deparse2,0,0,1,character[],1
+plotly,deparse2,0,0,2,class<`AsIs`>,1
+plotly,deparse2,0,0,3,class<`matrix`>,1
+plotly,deparse2,0,0,4,integer[],1
+plotly,deparse2,0,0,5,null,1
+plotly,dependency_dir,-1,0,0,character,1
+plotly,dependency_dir,0,0,0,...,1
+plotly,dots2plots,-1,0,0,"list<class<`htmlwidget`, `plotly`>>",1
+plotly,dots2plots,0,0,0,...,1
+plotly,easingOpts,-1,0,0,character[],1
+plotly,ensure_one,-1,0,0,character,1
+plotly,ensure_one,-1,0,1,list<character | double | list<double>>,1
+plotly,ensure_one,-1,0,2,list<logical>,1
+plotly,ensure_one,0,0,0,list<list<character[] | list<any>>>,1
+plotly,ensure_one,1,0,0,character,1
+plotly,faced,-1,0,0,character,1
+plotly,faced,0,0,0,character,1
+plotly,faced,1,0,0,character,1
+plotly,filter_.plotly,-1,0,0,"class<`htmlwidget`, `plotly`>",1
+plotly,filter_.plotly,0,0,0,"class<`htmlwidget`, `plotly`>",1
+plotly,filter_.plotly,1,0,0,...,1
+plotly,filter_.plotly,2,0,0,class<`lazy_dots`>,1
+plotly,fit_bounds,-1,0,0,"class<`htmlwidget`, `plotly`>",1
+plotly,fit_bounds,0,0,0,"class<`htmlwidget`, `plotly`>",1
+plotly,fortify.SharedData,-1,0,0,"class<`data.frame`, `tbl`, `tbl_df`>",1
+plotly,fortify.SharedData,0,0,0,"class<`R6`, `SharedData`>",1
+plotly,fortify.SharedData,1,0,0,any,1
+plotly,fortify.SharedData,2,0,0,...,1
+plotly,geo2cartesian,-1,0,0,"class<`htmlwidget`, `plotly`>",1
+plotly,geo2cartesian,0,0,0,"class<`htmlwidget`, `plotly`>",1
+plotly,geom2trace.GeomBar,-1,0,0,list<double[] | character[] | list<logical | character | list<double | character>>>,1
+plotly,geom2trace.GeomBar,0,0,0,"class<`GeomBar`, `data.frame`>",1
+plotly,geom2trace.GeomBar,1,0,0,list<any>,1
+plotly,geom2trace.GeomBar,2,0,0,"class<`gg`, `ggplot`>",1
+plotly,geom2trace.GeomPath,-1,0,0,list<double[] | character[] | list<double | character>>,1
+plotly,geom2trace.GeomPath,-1,0,1,list<^double[] | ^character[] | list<double | character>>,1
+plotly,geom2trace.GeomPath,0,0,0,"class<`GeomPath`, `GeomSmooth`, `data.frame`>",1
+plotly,geom2trace.GeomPath,0,0,1,"class<`GeomLine`, `GeomPath`, `data.frame`>",1
+plotly,geom2trace.GeomPath,1,0,0,list<any>,1
+plotly,geom2trace.GeomPath,2,0,0,"class<`gg`, `ggplot`>",1
+plotly,geom2trace.GeomPoint,-1,0,0,list<double[] | character[] | list<character | double | list<double | character>>>,1
+plotly,geom2trace.GeomPoint,0,0,0,"class<`GeomPoint`, `data.frame`>",1
+plotly,geom2trace.GeomPoint,1,0,0,list<logical | character | list<character>>,1
+plotly,geom2trace.GeomPoint,2,0,0,"class<`gg`, `ggplot`>",1
+plotly,geom2trace.GeomPolygon,-1,0,0,list<double[] | character[] | list<double | character>>,1
+plotly,geom2trace.GeomPolygon,0,0,0,"class<`GeomPolygon`, `GeomSmooth`, `data.frame`>",1
+plotly,geom2trace.GeomPolygon,1,0,0,list<any>,1
+plotly,geom2trace.GeomPolygon,2,0,0,"class<`gg`, `ggplot`>",1
+plotly,get_domain,-1,0,0,character,1
+plotly,get_domain,0,0,0,character,1
+plotly,get_domains,-1,0,0,class<`data.frame`>,1
+plotly,get_domains,0,0,0,integer,1
+plotly,get_domains,1,0,0,double,1
+plotly,get_domains,2,0,0,double[],1
+plotly,get_domains,3,0,0,null,1
+plotly,get_domains,4,0,0,null,1
+plotly,getLevels,-1,0,0,logical[],1
+plotly,getLevels,0,0,0,^logical[],1
+plotly,getLevels,0,0,1,null,1
+plotly,getUnitType,-1,0,0,character,1
+plotly,getUnitType,0,0,0,class<`unit`>,1
+plotly,gg2list,-1,0,0,list<character | list<any>>,1
+plotly,gg2list,0,0,0,"class<`gg`, `ggplot`>",1
+plotly,gg2list,1,0,0,null,1
+plotly,gg2list,2,0,0,null,1
+plotly,gg2list,3,0,0,character,1
+plotly,gg2list,4,0,0,logical,1
+plotly,gg2list,5,0,0,double,1
+plotly,gg2list,6,0,0,logical,1
+plotly,gg2list,7,0,0,character,1
+plotly,ggfun,-1,0,0,class<`function`>,1
+plotly,ggfun,-1,0,1,"class<`Geom`, `GeomBar`, `GeomRect`, `gg`, `ggproto`>",1
+plotly,ggfun,-1,0,2,"class<`Geom`, `GeomPath`, `gg`, `ggproto`>",1
+plotly,ggfun,-1,0,3,"class<`Geom`, `GeomPoint`, `gg`, `ggproto`>",1
+plotly,ggfun,-1,0,4,"class<`Geom`, `GeomPolygon`, `gg`, `ggproto`>",1
+plotly,ggfun,0,0,0,character,1
+plotly,ggplotly,-1,0,0,"class<`htmlwidget`, `plotly`>",1
+plotly,ggplotly,0,0,0,"class<`gg`, `ggplot`>",1
+plotly,ggplotly,1,0,0,null,1
+plotly,ggplotly,2,0,0,null,1
+plotly,ggplotly,3,0,0,character,1
+plotly,ggplotly,4,0,0,logical,1
+plotly,ggplotly,5,0,0,double,1
+plotly,ggplotly,6,0,0,logical,1
+plotly,ggplotly,7,0,0,character,1
+plotly,ggplotly.ggplot,-1,0,0,"class<`htmlwidget`, `plotly`>",1
+plotly,ggplotly.ggplot,0,0,0,"class<`gg`, `ggplot`>",1
+plotly,ggplotly.ggplot,1,0,0,null,1
+plotly,ggplotly.ggplot,2,0,0,null,1
+plotly,ggplotly.ggplot,3,0,0,character,1
+plotly,ggplotly.ggplot,4,0,0,logical,1
+plotly,ggplotly.ggplot,5,0,0,double,1
+plotly,ggplotly.ggplot,6,0,0,logical,1
+plotly,ggplotly.ggplot,7,0,0,character,1
+plotly,ggtype,-1,0,0,character,1
+plotly,ggtype,0,0,0,"class<`Layer`, `LayerInstance`, `gg`, `ggproto`>",1
+plotly,ggtype,1,0,0,character,1
+plotly,glTypes,-1,0,0,character[],1
+plotly,group2NA,-1,0,0,class<`data.frame`>,1
+plotly,group2NA,-1,0,1,"class<`data.frame`, `tbl`, `tbl_df`>",1
+plotly,group2NA,-1,0,2,"class<`GeomLine`, `GeomPath`, `data.frame`>",1
+plotly,group2NA,-1,0,3,"class<`GeomPath`, `GeomSmooth`, `data.frame`>",1
+plotly,group2NA,-1,0,4,"class<`GeomPolygon`, `GeomSmooth`, `data.frame`>",1
+plotly,group2NA,0,0,0,class<`data.frame`>,1
+plotly,group2NA,0,0,1,"class<`data.frame`, `tbl`, `tbl_df`>",1
+plotly,group2NA,0,0,2,"class<`GeomLine`, `GeomPath`, `data.frame`>",1
+plotly,group2NA,0,0,3,"class<`GeomPath`, `GeomSmooth`, `data.frame`>",1
+plotly,group2NA,0,0,4,"class<`GeomPolygon`, `GeomSmooth`, `data.frame`>",1
+plotly,group2NA,1,0,0,any,1
+plotly,group2NA,2,0,0,character,1
+plotly,group2NA,2,0,1,null,1
+plotly,group2NA,3,0,0,any,1
+plotly,group2NA,4,0,0,any,1
+plotly,groups.plotly,-1,0,0,list<class<`name`>>,1
+plotly,groups.plotly,0,0,0,"class<`htmlwidget`, `plotly`>",1
+plotly,has_attr,-1,0,0,logical[],1
+plotly,has_attr,0,0,0,character[],1
+plotly,has_attr,1,0,0,character,1
+plotly,has_color_array,-1,0,0,logical[],1
+plotly,has_color_array,0,0,0,character[],1
+plotly,has_color_array,1,0,0,character,1
+plotly,has_colorbar,-1,0,0,logical,1
+plotly,has_colorbar,0,0,0,"class<`htmlwidget`, `plotly`>",1
+plotly,has_facet,-1,0,0,logical,1
+plotly,has_facet,0,0,0,"class<`gg`, `ggplot`>",1
+plotly,has_fill,-1,0,0,logical,1
+plotly,has_fill,0,0,0,class<`plotly_colorbar`>,1
+plotly,has_fill,0,0,1,"class<`plotly_colorbar`, `zcolor`>",1
+plotly,has_fill,0,0,2,list<any>,1
+plotly,has_group,-1,0,0,logical,1
+plotly,has_group,0,0,0,"class<`list`, `plotly_heatmap`>",1
+plotly,has_group,0,0,1,"class<`list`, `plotly_line`>",1
+plotly,has_group,0,0,2,list<any>,1
+plotly,has_legend,-1,0,0,logical,1
+plotly,has_legend,0,0,0,"class<`htmlwidget`, `plotly`>",1
+plotly,has_line,-1,0,0,logical[],1
+plotly,has_line,0,0,0,character[],1
+plotly,has_line,1,0,0,any,1
+plotly,has_text,-1,0,0,logical[],1
+plotly,has_text,0,0,0,character[],1
+plotly,has_text,1,0,0,any,1
+plotly,hide_colorbar,-1,0,0,"class<`htmlwidget`, `plotly`>",1
+plotly,hide_colorbar,0,0,0,"class<`htmlwidget`, `plotly`>",1
+plotly,hide_legend,-1,0,0,"class<`htmlwidget`, `plotly`>",1
+plotly,hide_legend,0,0,0,"class<`htmlwidget`, `plotly`>",1
+plotly,highlight,-1,0,0,"class<`htmlwidget`, `plotly`>",1
+plotly,highlight,0,0,0,"class<`htmlwidget`, `plotly`>",1
+plotly,highlight,1,0,0,character,1
+plotly,highlight,2,0,0,any,1
+plotly,highlight,3,0,0,logical,1
+plotly,highlight,4,0,0,logical,1
+plotly,highlight,5,0,0,character[],1
+plotly,highlight,5,0,1,null,1
+plotly,highlight,6,0,0,logical,1
+plotly,highlight,7,0,0,null,1
+plotly,highlight_defaults,-1,0,0,list<character | double | list<double>>,1
+plotly,highlight_key,-1,0,0,"class<`R6`, `SharedData`>",1
+plotly,highlight_key,0,0,0,...,1
+plotly,hover_on,-1,0,0,character,1
+plotly,hover_on,0,0,0,"class<`GeomBar`, `data.frame`>",1
+plotly,hover_on,0,0,1,"class<`GeomLine`, `data.frame`>",1
+plotly,hover_on,0,0,2,"class<`GeomLine`, `GeomPath`, `data.frame`>",1
+plotly,hover_on,0,0,3,"class<`GeomPath`, `GeomSmooth`, `data.frame`>",1
+plotly,hover_on,0,0,4,"class<`GeomPoint`, `data.frame`>",1
+plotly,hover_on,0,0,5,"class<`GeomPolygon`, `GeomSmooth`, `data.frame`>",1
+plotly,hover_on,0,0,6,"class<`GeomSmooth`, `data.frame`>",1
+plotly,i,-1,0,0,character[],1
+plotly,i,-1,0,1,class<`Date`>,1
+plotly,i,-1,0,2,class<`matrix`>,1
+plotly,i,-1,0,3,double[],1
+plotly,i,-1,0,4,null,1
+plotly,i,0,0,0,character[],1
+plotly,i,0,0,1,class<`Date`>,1
+plotly,i,0,0,2,class<`matrix`>,1
+plotly,i,0,0,3,double[],1
+plotly,i,0,0,4,null,1
+plotly,is3d,-1,0,0,logical,1
+plotly,is3d,0,0,0,character,1
+plotly,is_blank,-1,0,0,logical,1
+plotly,is_blank,0,0,0,character[],1
+plotly,is_blank,0,0,1,"class<`element`, `element_blank`>",1
+plotly,is_blank,0,0,2,"class<`element`, `element_line`>",1
+plotly,is_blank,0,0,3,"class<`element`, `element_text`>",1
+plotly,is_blank,0,0,4,class<`waiver`>,1
+plotly,is_blank,0,0,5,list<any>,1
+plotly,is_blank,0,0,6,null,1
+plotly,is.colorbar,-1,0,0,logical,1
+plotly,is.colorbar,0,0,0,class<`plotly_colorbar`>,1
+plotly,is.colorbar,0,0,1,"class<`plotly_colorbar`, `zcolor`>",1
+plotly,is.colorbar,0,0,2,list<any>,1
+plotly,is.default,-1,0,0,logical,1
+plotly,is.default,0,0,0,"class<`character`, `plotly_default`>",1
+plotly,is.default,0,0,1,"class<`logical`, `plotly_default`>",1
+plotly,is.default,0,0,2,null,1
+plotly,is.default,0,0,3,character,1
+plotly,is.default,0,0,4,"class<`character`, `colorway`, `plotly_default`>",1
+plotly,is.default,0,0,5,"class<`matrix`, `plotly_default`>",1
+plotly,is.default,0,0,6,"class<`numeric`, `plotly_default`>",1
+plotly,is.default,0,0,7,double[],1
+plotly,is.discrete,-1,0,0,logical,1
+plotly,is.discrete,0,0,0,character[],1
+plotly,is.discrete,0,0,1,class<`AsIs`>,1
+plotly,is.discrete,0,0,2,class<`Date`>,1
+plotly,is.discrete,0,0,3,class<`matrix`>,1
+plotly,is.discrete,0,0,4,double[],1
+plotly,is.discrete,0,0,5,null,1
+plotly,is_geo,-1,0,0,logical,1
+plotly,is_geo,0,0,0,"class<`htmlwidget`, `plotly`>",1
+plotly,is_mapbox,-1,0,0,logical,1
+plotly,is_mapbox,0,0,0,"class<`htmlwidget`, `plotly`>",1
+plotly,is.plotly,-1,0,0,logical,1
+plotly,is.plotly,0,0,0,character,1
+plotly,is.plotly,0,0,1,"class<`data.frame`, `rowwise_df`, `tbl`, `tbl_df`>",1
+plotly,is.plotly,0,0,2,"class<`data.frame`, `tbl`, `tbl_df`>",1
+plotly,is.plotly,0,0,3,"class<`htmlwidget`, `plotly`>",1
+plotly,is.plotly,0,0,4,double,1
+plotly,is.plotly,0,0,5,"list<class<`htmlwidget`, `plotly`>>",1
+plotly,is_rstudio,-1,0,0,logical,1
+plotly,is_sf,-1,0,0,logical,1
+plotly,is_sf,0,0,0,"class<`data.frame`, `plotly_data`>",1
+plotly,is_sf,0,0,1,"class<`data.frame`, `plotly_data`, `spec_tbl_df`, `tbl`, `tbl_df`>",1
+plotly,is_sf,0,0,2,"class<`data.frame`, `plotly_data`, `tbl`, `tbl_df`>",1
+plotly,is_subplot,-1,0,0,logical,1
+plotly,is_subplot,0,0,0,"class<`htmlwidget`, `plotly`>",1
+plotly,is_tidy,-1,0,0,logical,1
+plotly,is_tidy,0,0,0,"class<`list`, `plotly_heatmap`>",1
+plotly,is_tidy,0,0,1,"class<`list`, `plotly_line`>",1
+plotly,is_tidy,0,0,2,list<double[] | character>,1
+plotly,is_tidy,0,0,3,list<class<`Date`> | double[] | character>,1
+plotly,is_tidy,0,0,4,list<character[] | double[]>,1
+plotly,is_tidy,0,0,5,list<double[] | character | list<character | list<double | character>>>,1
+plotly,is_type,-1,0,0,logical,1
+plotly,is_type,0,0,0,"class<`htmlwidget`, `plotly`>",1
+plotly,is_type,1,0,0,character,1
+plotly,layers2layout,-1,0,0,list<character | list<double | character | double>>,1
+plotly,layers2layout,0,0,0,list<character | list<double | character | double>>,1
+plotly,layers2layout,1,0,0,"list<class<`Layer`, `LayerInstance`, `gg`, `ggproto`>>",1
+plotly,layers2layout,2,0,0,any,1
+plotly,layers2traces,-1,0,0,list<list<double[] | character[] | list<logical | character | list<double | character>>>>,1
+plotly,layers2traces,-1,0,1,list<list<double[] | character[] | list<character | double | list<double | character>> | double[] | character[] | list<double | character>>>,1
+plotly,layers2traces,-1,0,2,list<list<double[] | character[] | list<character | double | list<double | character>>>>,1
+plotly,layers2traces,-1,0,3,list<list<^double[] | ^character[] | list<double | character>>>,1
+plotly,layers2traces,0,0,0,list<class<`data.frame`>>,1
+plotly,layers2traces,1,0,0,any,1
+plotly,layers2traces,2,0,0,"class<`Layout`, `gg`, `ggproto`>",1
+plotly,layers2traces,3,0,0,"class<`gg`, `ggplot`>",1
+plotly,layout,-1,0,0,"class<`htmlwidget`, `plotly`>",1
+plotly,layout,0,0,0,"class<`htmlwidget`, `plotly`>",1
+plotly,layout,1,0,0,...,1
+plotly,layout,2,0,0,null,1
+plotly,layout.plotly,-1,0,0,"class<`htmlwidget`, `plotly`>",1
+plotly,layout.plotly,0,0,0,"class<`htmlwidget`, `plotly`>",1
+plotly,layout.plotly,1,0,0,...,1
+plotly,layout.plotly,2,0,0,null,1
+plotly,list2df,-1,0,0,class<`data.frame`>,1
+plotly,list2df,0,0,0,list<double[]>,1
+plotly,list2df,1,0,0,any,1
+plotly,locale_dependency,-1,0,0,class<`html_dependency`>,1
+plotly,locale_dependency,0,0,0,character,1
+plotly,lty2dash,-1,0,0,character[],1
+plotly,lty2dash,0,0,0,double,1
+plotly,lty2dash,0,0,1,null,1
+plotly,make_panel_border,-1,0,0,list<list<any>>,1
+plotly,make_panel_border,0,0,0,double[],1
+plotly,make_panel_border,1,0,0,double[],1
+plotly,make_panel_border,2,0,0,list<any>,1
+plotly,map_color,-1,0,0,"list<class<`plotly_colorbar`, `zcolor`>>",1
+plotly,map_color,-1,0,1,list<list<any>>,1
+plotly,map_color,-1,0,2,list<class<`plotly_colorbar`> | list<any>>,1
+plotly,map_color,0,0,0,"list<class<`plotly_colorbar`, `zcolor`>>",1
+plotly,map_color,0,0,1,list<list<any>>,1
+plotly,map_color,0,0,2,list<class<`plotly_colorbar`> | list<any>>,1
+plotly,map_color,1,0,0,logical,1
+plotly,map_color,2,0,0,any,1
+plotly,map_color,3,0,0,any,1
+plotly,map_color,4,0,0,character,1
+plotly,map_linetype,-1,0,0,list<list<any>>,1
+plotly,map_linetype,0,0,0,list<list<any>>,1
+plotly,map_size,-1,0,0,list<list<any>>,1
+plotly,map_size,0,0,0,list<list<any>>,1
+plotly,map_size,1,0,0,logical,1
+plotly,map_symbol,-1,0,0,list<list<any>>,1
+plotly,map_symbol,0,0,0,list<list<any>>,1
+plotly,mathjax_cdn,-1,0,0,class<`html_dependency`>,1
+plotly,mm2pixels,-1,0,0,double[],1
+plotly,mm2pixels,0,0,0,double,1
+plotly,mm2pixels,0,0,1,class<`unit`>,1
+plotly,modify_list,-1,0,0,list<any>,1
+plotly,modify_list,0,0,0,null,1
+plotly,modify_list,0,0,1,list<any>,1
+plotly,modify_list,1,0,0,list<any>,1
+plotly,modify_list,1,0,1,null,1
+plotly,modify_list,2,0,0,...,1
+plotly,mutate_.plotly,-1,0,0,"class<`htmlwidget`, `plotly`>",1
+plotly,mutate_.plotly,0,0,0,"class<`htmlwidget`, `plotly`>",1
+plotly,mutate_.plotly,1,0,0,...,1
+plotly,mutate_.plotly,2,0,0,class<`lazy_dots`>,1
+plotly,names2,-1,0,0,character[],1
+plotly,names2,0,0,0,list<any>,1
+plotly,names2,0,0,1,null,1
+plotly,new_id,-1,0,0,character,1
+plotly,npscales,-1,0,0,character[],1
+plotly,plot_geo,-1,0,0,"class<`htmlwidget`, `plotly`>",1
+plotly,plot_geo,0,0,0,"class<`data.frame`, `grouped_df`, `tbl`, `tbl_df`>",1
+plotly,plot_geo,1,0,0,...,1
+plotly,plot_geo,2,0,0,logical,1
+plotly,plot_ly,-1,0,0,"class<`htmlwidget`, `plotly`>",1
+plotly,plot_ly,0,0,0,class<`data.frame`>,1
+plotly,plot_ly,0,0,1,"class<`data.frame`, `grouped_df`, `tbl`, `tbl_df`>",1
+plotly,plot_ly,0,0,2,"class<`data.frame`, `spec_tbl_df`, `tbl`, `tbl_df`>",1
+plotly,plot_ly,0,0,3,"class<`data.frame`, `tbl`, `tbl_df`>",1
+plotly,plot_ly,1,0,0,...,1
+plotly,plot_ly,2,0,0,null,1
+plotly,plot_ly,3,0,0,any,1
+plotly,plot_ly,4,0,0,any,1
+plotly,plot_ly,5,0,0,null,1
+plotly,plot_ly,6,0,0,null,1
+plotly,plot_ly,7,0,0,any,1
+plotly,plotly_build,-1,0,0,"class<`htmlwidget`, `plotly`>",1
+plotly,plotly_build,0,0,0,"class<`gg`, `ggplot`>",1
+plotly,plotly_build,0,0,1,"class<`htmlwidget`, `plotly`>",1
+plotly,plotly_build,1,0,0,logical,1
+plotly,plotly_build.gg,-1,0,0,"class<`htmlwidget`, `plotly`>",1
+plotly,plotly_build.gg,0,0,0,"class<`gg`, `ggplot`>",1
+plotly,plotly_build.gg,1,0,0,logical,1
+plotly,plotly_build.plotly,-1,0,0,"class<`htmlwidget`, `plotly`>",1
+plotly,plotly_build.plotly,0,0,0,"class<`htmlwidget`, `plotly`>",1
+plotly,plotly_build.plotly,1,0,0,logical,1
+plotly,plotly_data,-1,0,0,"class<`data.frame`, `grouped_df`, `plotly_data`, `tbl`, `tbl_df`>",1
+plotly,plotly_data,-1,0,1,"class<`data.frame`, `plotly_data`>",1
+plotly,plotly_data,-1,0,2,"class<`data.frame`, `plotly_data`, `spec_tbl_df`, `tbl`, `tbl_df`>",1
+plotly,plotly_data,-1,0,3,"class<`data.frame`, `plotly_data`, `tbl`, `tbl_df`>",1
+plotly,plotly_data,0,0,0,"class<`htmlwidget`, `plotly`>",1
+plotly,plotly_data,1,0,0,character,1
+plotly,plotlyHtmlwidgetsCSS,-1,0,0,class<`html_dependency`>,1
+plotly,plotlyjsBundle,-1,0,0,class<`html_dependency`>,1
+plotly,plotlyjsBundle,0,0,0,"class<`htmlwidget`, `plotly`>",1
+plotly,plotlyjsBundleIDX,-1,0,0,integer,1
+plotly,plotlyjsBundleIDX,0,0,0,"class<`htmlwidget`, `plotly`>",1
+plotly,plotly_json,-1,0,0,class<`json`>,1
+plotly,plotly_json,0,0,0,"class<`htmlwidget`, `plotly`>",1
+plotly,plotly_json,1,0,0,logical,1
+plotly,plotly_json,2,0,0,logical,1
+plotly,plotly_json,3,0,0,...,1
+plotly,plotlyMainBundle,-1,0,0,class<`html_dependency`>,1
+plotly,populate_categorical_axes,-1,0,0,"class<`htmlwidget`, `plotly`>",1
+plotly,populate_categorical_axes,0,0,0,"class<`htmlwidget`, `plotly`>",1
+plotly,prefix_class,-1,0,0,"class<`character`, `colorway`, `plotly_default`>",1
+plotly,prefix_class,-1,0,1,"class<`character`, `plotly_default`>",1
+plotly,prefix_class,-1,0,2,"class<`colorway`, `plotly_default`>",1
+plotly,prefix_class,-1,0,3,"class<`data.frame`, `grouped_df`, `plotly_data`, `tbl`, `tbl_df`>",1
+plotly,prefix_class,-1,0,4,"class<`data.frame`, `plotly_data`>",1
+plotly,prefix_class,-1,0,5,"class<`data.frame`, `plotly_data`, `spec_tbl_df`, `tbl`, `tbl_df`>",1
+plotly,prefix_class,-1,0,6,"class<`data.frame`, `plotly_data`, `tbl`, `tbl_df`>",1
+plotly,prefix_class,-1,0,7,"class<`GeomBar`, `data.frame`>",1
+plotly,prefix_class,-1,0,8,"class<`GeomLine`, `data.frame`>",1
+plotly,prefix_class,-1,0,9,"class<`GeomLine`, `GeomPath`, `data.frame`>",1
+plotly,prefix_class,-1,0,10,"class<`GeomPath`, `GeomSmooth`, `data.frame`>",1
+plotly,prefix_class,-1,0,11,"class<`GeomPoint`, `data.frame`>",1
+plotly,prefix_class,-1,0,12,"class<`GeomPolygon`, `GeomSmooth`, `data.frame`>",1
+plotly,prefix_class,-1,0,13,"class<`GeomSmooth`, `data.frame`>",1
+plotly,prefix_class,-1,0,14,"class<`list`, `plotly_default`>",1
+plotly,prefix_class,-1,0,15,"class<`list`, `plotly_heatmap`>",1
+plotly,prefix_class,-1,0,16,"class<`list`, `plotly_line`>",1
+plotly,prefix_class,-1,0,17,"class<`list`, `plotly_path`>",1
+plotly,prefix_class,-1,0,18,"class<`list`, `plotly_polygon`, `plotly_ribbon`>",1
+plotly,prefix_class,-1,0,19,"class<`logical`, `plotly_default`>",1
+plotly,prefix_class,-1,0,20,"class<`matrix`, `plotly_default`>",1
+plotly,prefix_class,-1,0,21,"class<`numeric`, `plotly_default`>",1
+plotly,prefix_class,-1,0,22,"class<`TeX`, `character`>",1
+plotly,prefix_class,0,0,0,"class<`character`, `plotly_default`>",1
+plotly,prefix_class,0,0,1,character,1
+plotly,prefix_class,0,0,2,"class<`colorway`, `plotly_default`>",1
+plotly,prefix_class,0,0,3,class<`colorway`>,1
+plotly,prefix_class,0,0,4,"class<`data.frame`, `grouped_df`, `tbl`, `tbl_df`>",1
+plotly,prefix_class,0,0,5,class<`data.frame`>,1
+plotly,prefix_class,0,0,6,"class<`data.frame`, `plotly_data`, `spec_tbl_df`, `tbl`, `tbl_df`>",1
+plotly,prefix_class,0,0,7,"class<`data.frame`, `spec_tbl_df`, `tbl`, `tbl_df`>",1
+plotly,prefix_class,0,0,8,"class<`data.frame`, `tbl`, `tbl_df`>",1
+plotly,prefix_class,0,0,9,"class<`GeomLine`, `data.frame`>",1
+plotly,prefix_class,0,0,10,"class<`GeomSmooth`, `data.frame`>",1
+plotly,prefix_class,0,0,11,list<any>,1
+plotly,prefix_class,0,0,12,null,1
+plotly,prefix_class,0,0,13,class<`matrix`>,1
+plotly,prefix_class,0,0,14,double[],1
+plotly,prefix_class,1,0,0,character[],1
+plotly,rangeslider,-1,0,0,"class<`htmlwidget`, `plotly`>",1
+plotly,rangeslider,0,0,0,"class<`htmlwidget`, `plotly`>",1
+plotly,rangeslider,1,0,0,class<`Date`>,1
+plotly,rangeslider,1,0,1,null,1
+plotly,rangeslider,2,0,0,class<`Date`>,1
+plotly,rangeslider,2,0,1,null,1
+plotly,rangeslider,3,0,0,...,1
+plotly,raster2uri,-1,0,0,character,1
+plotly,raster2uri,0,0,0,class<`raster`>,1
+plotly,raster2uri,1,0,0,...,1
+plotly,rect2shape,-1,0,0,list<character | null | list<null | double | character[]>>,1
+plotly,rect2shape,0,0,0,"class<`element`, `element_blank`>",1
+plotly,registerFrames,-1,0,0,"class<`htmlwidget`, `plotly`>",1
+plotly,registerFrames,0,0,0,"class<`htmlwidget`, `plotly`>",1
+plotly,registerFrames,1,0,0,any,1
+plotly,relay_type,-1,0,0,character,1
+plotly,relay_type,0,0,0,character,1
+plotly,retain,-1,0,0,character,1
+plotly,retain,-1,0,1,"class<`character`, `colorway`, `plotly_default`>",1
+plotly,retain,-1,0,2,"class<`character`, `plotly_default`>",1
+plotly,retain,-1,0,3,"class<`logical`, `plotly_default`>",1
+plotly,retain,-1,0,4,"class<`matrix`, `plotly_default`>",1
+plotly,retain,-1,0,5,"class<`numeric`, `plotly_default`>",1
+plotly,retain,-1,0,6,double[],1
+plotly,retain,-1,0,7,null,1
+plotly,retain,0,0,0,character[],1
+plotly,retain,0,0,1,"class<`character`, `colorway`, `plotly_default`>",1
+plotly,retain,0,0,2,"class<`character`, `plotly_default`>",1
+plotly,retain,0,0,3,"class<`logical`, `plotly_default`>",1
+plotly,retain,0,0,4,"class<`matrix`, `plotly_default`>",1
+plotly,retain,0,0,5,"class<`numeric`, `plotly_default`>",1
+plotly,retain,0,0,6,double[],1
+plotly,retain,0,0,7,null,1
+plotly,retain,1,0,0,class<`function`>,1
+plotly,rgb2hex,-1,0,0,character[],1
+plotly,rgb2hex,0,0,0,character[],1
+plotly,rgb2hex,0,0,1,"class<`character`, `colorway`, `plotly_default`>",1
+plotly,ribbon_dat,-1,0,0,"class<`GeomSmooth`, `data.frame`>",1
+plotly,ribbon_dat,0,0,0,"class<`GeomSmooth`, `data.frame`>",1
+plotly,rm_asis,-1,0,0,^character[],1
+plotly,rm_asis,-1,0,1,^double[],1
+plotly,rm_asis,-1,0,2,null,1
+plotly,rm_asis,-1,0,3,list<any>,1
+plotly,rm_asis,0,0,0,^character[],1
+plotly,rm_asis,0,0,1,^double[],1
+plotly,rm_asis,0,0,2,null,1
+plotly,rm_asis,0,0,3,list<any>,1
+plotly,schema,-1,0,0,list<list<character[] | list<character | list<character | list<any> | character[] | character[] | list<any> | character[]>> | character | list<list<character | list<character>>> | list<any>>>,1
+plotly,schema,0,0,0,logical,1
+plotly,schema,1,0,0,...,1
+plotly,set_last_plot,-1,0,0,"class<`htmlwidget`, `plotly`>",1
+plotly,set_last_plot,0,0,0,"class<`htmlwidget`, `plotly`>",1
+plotly,shiny_defaults_set,-1,0,0,"class<`htmlwidget`, `plotly`>",1
+plotly,shiny_defaults_set,0,0,0,"class<`htmlwidget`, `plotly`>",1
+plotly,shiny_event_defaults,-1,0,0,character[],1
+plotly,showRGB,-1,0,0,null,1
+plotly,showRGB,0,0,0,character[],1
+plotly,showRGB,1,0,0,...,1
+plotly,slice_.plotly,-1,0,0,"class<`htmlwidget`, `plotly`>",1
+plotly,slice_.plotly,0,0,0,"class<`htmlwidget`, `plotly`>",1
+plotly,slice_.plotly,1,0,0,...,1
+plotly,slice_.plotly,2,0,0,class<`lazy_dots`>,1
+plotly,special_attrs,-1,0,0,null,1
+plotly,special_attrs,0,0,0,"class<`list`, `plotly_heatmap`>",1
+plotly,special_attrs,0,0,1,"class<`list`, `plotly_line`>",1
+plotly,special_attrs,0,0,2,list<double[] | character>,1
+plotly,special_attrs,0,0,3,list<class<`Date`> | double[] | character>,1
+plotly,special_attrs,0,0,4,list<character[] | double[]>,1
+plotly,special_attrs,0,0,5,list<double[] | character | list<character | list<double | character>>>,1
+plotly,split_on,-1,0,0,character[],1
+plotly,split_on,-1,0,1,null,1
+plotly,split_on,0,0,0,"class<`GeomBar`, `data.frame`>",1
+plotly,split_on,0,0,1,"class<`GeomLine`, `GeomPath`, `data.frame`>",1
+plotly,split_on,0,0,2,"class<`GeomPath`, `GeomSmooth`, `data.frame`>",1
+plotly,split_on,0,0,3,"class<`GeomPolygon`, `GeomSmooth`, `data.frame`>",1
+plotly,split_on,0,0,4,"class<`GeomPoint`, `data.frame`>",1
+plotly,style,-1,0,0,"class<`htmlwidget`, `plotly`>",1
+plotly,style,0,0,0,"class<`htmlwidget`, `plotly`>",1
+plotly,style,1,0,0,...,1
+plotly,style,2,0,0,double[],1
+plotly,style,2,0,1,null,1
+plotly,subplot,-1,0,0,"class<`htmlwidget`, `plotly`>",1
+plotly,subplot,0,0,0,...,1
+plotly,subplot,1,0,0,double,1
+plotly,subplot,2,0,0,null,1
+plotly,subplot,3,0,0,null,1
+plotly,subplot,4,0,0,double,1
+plotly,subplot,5,0,0,logical,1
+plotly,subplot,6,0,0,logical,1
+plotly,subplot,7,0,0,logical,1
+plotly,supply_defaults,-1,0,0,"class<`htmlwidget`, `plotly`>",1
+plotly,supply_defaults,0,0,0,"class<`htmlwidget`, `plotly`>",1
+plotly,supply_highlight_attrs,-1,0,0,"class<`htmlwidget`, `plotly`>",1
+plotly,supply_highlight_attrs,0,0,0,"class<`htmlwidget`, `plotly`>",1
+plotly,TeX,-1,0,0,"class<`TeX`, `character`>",1
+plotly,TeX,0,0,0,character,1
+plotly,text2font,-1,0,0,list<character | double>,1
+plotly,text2font,0,0,0,"class<`element`, `element_text`>",1
+plotly,text2font,1,0,0,character,1
+plotly,to_basic,-1,0,0,"class<`GeomBar`, `data.frame`>",1
+plotly,to_basic,-1,0,1,"class<`GeomLine`, `GeomPath`, `data.frame`>",1
+plotly,to_basic,-1,0,2,"class<`GeomPoint`, `data.frame`>",1
+plotly,to_basic,-1,0,3,"list<class<`GeomPath`, `GeomSmooth`, `data.frame`> | class<`GeomPolygon`, `GeomSmooth`, `data.frame`>>",1
+plotly,to_basic,0,0,0,"class<`GeomBar`, `data.frame`>",1
+plotly,to_basic,0,0,1,"class<`GeomLine`, `data.frame`>",1
+plotly,to_basic,0,0,2,"class<`GeomPoint`, `data.frame`>",1
+plotly,to_basic,0,0,3,"class<`GeomSmooth`, `data.frame`>",1
+plotly,to_basic,1,0,0,any,1
+plotly,to_basic,2,0,0,any,1
+plotly,to_basic,3,0,0,any,1
+plotly,to_basic,4,0,0,any,1
+plotly,to_basic,5,0,0,...,1
+plotly,to_basic.default,-1,0,0,"class<`GeomBar`, `data.frame`>",1
+plotly,to_basic.default,-1,0,1,"class<`GeomPoint`, `data.frame`>",1
+plotly,to_basic.default,0,0,0,"class<`GeomBar`, `data.frame`>",1
+plotly,to_basic.default,0,0,1,"class<`GeomPoint`, `data.frame`>",1
+plotly,to_basic.default,1,0,0,any,1
+plotly,to_basic.default,2,0,0,any,1
+plotly,to_basic.default,3,0,0,any,1
+plotly,to_basic.default,4,0,0,any,1
+plotly,to_basic.default,5,0,0,...,1
+plotly,to_basic.GeomLine,-1,0,0,"class<`GeomLine`, `GeomPath`, `data.frame`>",1
+plotly,to_basic.GeomLine,0,0,0,"class<`GeomLine`, `data.frame`>",1
+plotly,to_basic.GeomLine,1,0,0,any,1
+plotly,to_basic.GeomLine,2,0,0,any,1
+plotly,to_basic.GeomLine,3,0,0,any,1
+plotly,to_basic.GeomLine,4,0,0,any,1
+plotly,to_basic.GeomLine,5,0,0,...,1
+plotly,to_basic.GeomSmooth,-1,0,0,"list<class<`GeomPath`, `GeomSmooth`, `data.frame`> | class<`GeomPolygon`, `GeomSmooth`, `data.frame`>>",1
+plotly,to_basic.GeomSmooth,0,0,0,"class<`GeomSmooth`, `data.frame`>",1
+plotly,to_basic.GeomSmooth,1,0,0,any,1
+plotly,to_basic.GeomSmooth,2,0,0,any,1
+plotly,to_basic.GeomSmooth,3,0,0,list<any>,1
+plotly,to_basic.GeomSmooth,4,0,0,any,1
+plotly,to_basic.GeomSmooth,5,0,0,...,1
+plotly,to_JSON,-1,0,0,class<`json`>,1
+plotly,to_JSON,0,0,0,list<character[] | list<any>>,1
+plotly,to_JSON,1,0,0,...,1
+plotly,to_milliseconds,-1,0,0,double,1
+plotly,to_milliseconds,-1,0,1,null,1
+plotly,to_milliseconds,0,0,0,class<`Date`>,1
+plotly,to_milliseconds,0,0,1,null,1
+plotly,toRGB,-1,0,0,character[],1
+plotly,toRGB,-1,0,1,null,1
+plotly,toRGB,0,0,0,null,1
+plotly,toRGB,0,0,1,character[],1
+plotly,toRGB,0,0,2,"class<`colorway`, `plotly_default`>",1
+plotly,toRGB,0,0,3,class<`AsIs`>,1
+plotly,toRGB,0,0,4,class<`colorway`>,1
+plotly,toRGB,1,0,0,any,1
+plotly,toWebGL,-1,0,0,"class<`htmlwidget`, `plotly`>",1
+plotly,toWebGL,0,0,0,"class<`gg`, `ggplot`>",1
+plotly,traceify,-1,0,0,list<list<any>>,1
+plotly,traceify,0,0,0,list<any>,1
+plotly,traceify,1,0,0,null,1
+plotly,traceify,1,0,1,character[],1
+plotly,trace_replace,-1,0,0,list<any>,1
+plotly,trace_replace,0,0,0,list<any>,1
+plotly,trace_replace,1,0,0,character[],1
+plotly,trace_replace,2,0,0,character,1
+plotly,trace_replace,2,0,1,list<double>,1
+plotly,trace_replace,2,0,2,double,1
+plotly,trace_replace,2,0,3,list<list<character>>,1
+plotly,train_data,-1,0,0,"class<`data.frame`, `tbl`, `tbl_df`>",1
+plotly,train_data,0,0,0,"class<`data.frame`, `tbl`, `tbl_df`>",1
+plotly,train_data,1,0,0,"class<`list`, `plotly_line`>",1
+plotly,train_data,1,0,1,list<class<`Date`> | double[] | character>,1
+plotly,train_data,1,0,2,list<double[] | character>,1
+plotly,train_data,1,0,3,list<character[] | double[]>,1
+plotly,train_data,1,0,4,list<double[] | character | list<character | list<double | character>>>,1
+plotly,translate_linebreaks,-1,0,0,"class<`htmlwidget`, `plotly`>",1
+plotly,translate_linebreaks,0,0,0,"class<`htmlwidget`, `plotly`>",1
+plotly,tryFALSE,-1,0,0,logical,1
+plotly,tryFALSE,0,0,0,any,1
+plotly,try_library,-1,0,0,null,1
+plotly,try_library,0,0,0,character,1
+plotly,try_library,1,0,0,character,1
+plotly,tryNULL,-1,0,0,character[],1
+plotly,tryNULL,-1,0,1,double,1
+plotly,tryNULL,-1,0,2,null,1
+plotly,tryNULL,-1,0,3,list<double>,1
+plotly,tryNULL,0,0,0,any,1
+plotly,typedArrayPolyfill,-1,0,0,class<`html_dependency`>,1
+plotly,uniq,-1,0,0,"class<`matrix`, `plotly_default`>",1
+plotly,uniq,-1,0,1,double[],1
+plotly,uniq,-1,0,2,null,1
+plotly,uniq,-1,0,3,class<`matrix`>,1
+plotly,uniq,-1,0,4,^character[],1
+plotly,uniq,0,0,0,"class<`character`, `colorway`, `plotly_default`>",1
+plotly,uniq,0,0,1,"class<`character`, `plotly_default`>",1
+plotly,uniq,0,0,2,"class<`matrix`, `plotly_default`>",1
+plotly,uniq,0,0,3,"class<`numeric`, `plotly_default`>",1
+plotly,uniq,0,0,4,"class<`logical`, `plotly_default`>",1
+plotly,uniq,0,0,5,null,1
+plotly,uniq,0,0,6,class<`AsIs`>,1
+plotly,uniq,0,0,7,class<`matrix`>,1
+plotly,uniq,0,0,8,^character[],1
+plotly,uniq,0,0,9,^double[],1
+plotly,unitConvert,-1,0,0,double[],1
+plotly,unitConvert,0,0,0,"class<`margin`, `unit`>",1
+plotly,unitConvert,0,0,1,"class<`element`, `element_blank`>",1
+plotly,unitConvert,0,0,2,"class<`element`, `element_line`>",1
+plotly,unitConvert,0,0,3,"class<`element`, `element_text`>",1
+plotly,unitConvert,0,0,4,class<`unit`>,1
+plotly,unitConvert,0,0,5,double,1
+plotly,unitConvert,1,0,0,character,1
+plotly,unitConvert,2,0,0,character[],1
+plotly,user_specified,-1,0,0,logical,1
+plotly,user_specified,0,0,0,null,1
+plotly,user_specified,0,0,1,list<any>,1
+plotly,verify_arrays,-1,0,0,"class<`htmlwidget`, `plotly`>",1
+plotly,verify_arrays,0,0,0,"class<`htmlwidget`, `plotly`>",1
+plotly,verify_attr,-1,0,0,"class<`list`, `plotly_default`>",1
+plotly,verify_attr,-1,0,1,class<`plotly_colorbar`>,1
+plotly,verify_attr,-1,0,2,"class<`plotly_colorbar`, `zcolor`>",1
+plotly,verify_attr,-1,0,3,list<any>,1
+plotly,verify_attr,0,0,0,"class<`list`, `plotly_default`>",1
+plotly,verify_attr,0,0,1,class<`plotly_colorbar`>,1
+plotly,verify_attr,0,0,2,"class<`plotly_colorbar`, `zcolor`>",1
+plotly,verify_attr,0,0,3,list<any>,1
+plotly,verify_attr,1,0,0,any,1
+plotly,verify_attr,2,0,0,any,1
+plotly,verify_attr_names,-1,0,0,"class<`htmlwidget`, `plotly`>",1
+plotly,verify_attr_names,0,0,0,"class<`htmlwidget`, `plotly`>",1
+plotly,verify_attr_spec,-1,0,0,"class<`htmlwidget`, `plotly`>",1
+plotly,verify_attr_spec,0,0,0,"class<`htmlwidget`, `plotly`>",1
+plotly,verify_colorscale,-1,0,0,"class<`htmlwidget`, `plotly`>",1
+plotly,verify_colorscale,0,0,0,"class<`htmlwidget`, `plotly`>",1
+plotly,verify_guides,-1,0,0,"class<`htmlwidget`, `plotly`>",1
+plotly,verify_guides,0,0,0,"class<`htmlwidget`, `plotly`>",1
+plotly,verify_hovermode,-1,0,0,"class<`htmlwidget`, `plotly`>",1
+plotly,verify_hovermode,0,0,0,"class<`htmlwidget`, `plotly`>",1
+plotly,verify_key_type,-1,0,0,"class<`htmlwidget`, `plotly`>",1
+plotly,verify_key_type,0,0,0,"class<`htmlwidget`, `plotly`>",1
+plotly,verify_mathjax,-1,0,0,"class<`htmlwidget`, `plotly`>",1
+plotly,verify_mathjax,0,0,0,"class<`htmlwidget`, `plotly`>",1
+plotly,verify_mode,-1,0,0,"class<`htmlwidget`, `plotly`>",1
+plotly,verify_mode,0,0,0,"class<`htmlwidget`, `plotly`>",1
+plotly,verify_orientation,-1,0,0,"class<`list`, `plotly_heatmap`>",1
+plotly,verify_orientation,-1,0,1,"class<`list`, `plotly_line`>",1
+plotly,verify_orientation,-1,0,2,list<double[] | character>,1
+plotly,verify_orientation,-1,0,3,list<class<`Date`> | double[] | character>,1
+plotly,verify_orientation,-1,0,4,list<character[] | double[]>,1
+plotly,verify_orientation,-1,0,5,list<double[] | character | list<character | list<double | character>>>,1
+plotly,verify_orientation,0,0,0,"class<`list`, `plotly_heatmap`>",1
+plotly,verify_orientation,0,0,1,"class<`list`, `plotly_line`>",1
+plotly,verify_orientation,0,0,2,list<double[] | character>,1
+plotly,verify_orientation,0,0,3,list<class<`Date`> | double[] | character>,1
+plotly,verify_orientation,0,0,4,list<character[] | double[]>,1
+plotly,verify_orientation,0,0,5,list<double[] | character | list<character | list<double | character>>>,1
+plotly,verify_partial_bundle,-1,0,0,"class<`htmlwidget`, `plotly`>",1
+plotly,verify_partial_bundle,0,0,0,"class<`htmlwidget`, `plotly`>",1
+plotly,verify_scattergl_platform,-1,0,0,"class<`htmlwidget`, `plotly`>",1
+plotly,verify_scattergl_platform,0,0,0,"class<`htmlwidget`, `plotly`>",1
+plotly,verify_showlegend,-1,0,0,"class<`htmlwidget`, `plotly`>",1
+plotly,verify_showlegend,0,0,0,"class<`htmlwidget`, `plotly`>",1
+plotly,verify_type,-1,0,0,"class<`list`, `plotly_heatmap`>",1
+plotly,verify_type,-1,0,1,"class<`list`, `plotly_line`>",1
+plotly,verify_type,-1,0,2,list<double[] | character>,1
+plotly,verify_type,-1,0,3,list<class<`Date`> | double[] | character>,1
+plotly,verify_type,-1,0,4,list<character[] | double[]>,1
+plotly,verify_type,-1,0,5,list<double[] | character | list<character | list<double | character>>>,1
+plotly,verify_type,0,0,0,"class<`list`, `plotly_heatmap`>",1
+plotly,verify_type,0,0,1,"class<`list`, `plotly_line`>",1
+plotly,verify_type,0,0,2,list<double[]>,1
+plotly,verify_type,0,0,3,list<class<`Date`> | double[]>,1
+plotly,verify_type,0,0,4,list<character[] | double[]>,1
+plotly,verify_type,0,0,5,list<double[] | list<character | list<double | character>>>,1
+plotly,verifyUnit,-1,0,0,"class<`margin`, `unit`>",1
+plotly,verifyUnit,-1,0,1,class<`unit`>,1
+plotly,verifyUnit,0,0,0,"class<`margin`, `unit`>",1
+plotly,verifyUnit,0,0,1,"class<`element`, `element_blank`>",1
+plotly,verifyUnit,0,0,2,"class<`element`, `element_line`>",1
+plotly,verifyUnit,0,0,3,"class<`element`, `element_text`>",1
+plotly,verifyUnit,0,0,4,class<`unit`>,1
+plotly,verifyUnit,0,0,5,double,1
+plotly,verify_webgl,-1,0,0,"class<`htmlwidget`, `plotly`>",1
+plotly,verify_webgl,0,0,0,"class<`htmlwidget`, `plotly`>",1
+plotrix,ablineclip,-1,0,0,null,1
+plotrix,ablineclip,0,0,0,class<`lm`>,1
+plotrix,ablineclip,0,0,1,null,1
+plotrix,ablineclip,1,0,0,null,1
+plotrix,ablineclip,2,0,0,null,1
+plotrix,ablineclip,2,0,1,double,1
+plotrix,ablineclip,3,0,0,null,1
+plotrix,ablineclip,3,0,1,double,1
+plotrix,ablineclip,4,0,0,null,1
+plotrix,ablineclip,5,0,0,null,1
+plotrix,ablineclip,6,0,0,logical,1
+plotrix,ablineclip,7,0,0,double,1
+plotrix,ablineclip,7,0,1,null,1
+plotrix,ablineclip,8,0,0,double,1
+plotrix,ablineclip,8,0,1,null,1
+plotrix,ablineclip,9,0,0,null,1
+plotrix,ablineclip,9,0,1,double,1
+plotrix,ablineclip,10,0,0,null,1
+plotrix,ablineclip,10,0,1,double,1
+plotrix,ablineclip,11,0,0,...,1
+plotrix,addtable2plot,-1,0,0,list<logical>,1
+plotrix,addtable2plot,0,0,0,double,1
+plotrix,addtable2plot,1,0,0,double,1
+plotrix,addtable2plot,2,0,0,class<`data.frame`>,1
+plotrix,addtable2plot,3,0,0,any,1
+plotrix,addtable2plot,4,0,0,character,1
+plotrix,addtable2plot,5,0,0,class<`matrix`>,1
+plotrix,addtable2plot,6,0,0,double,1
+plotrix,addtable2plot,7,0,0,double,1
+plotrix,addtable2plot,8,0,0,double,1
+plotrix,addtable2plot,9,0,0,double,1
+plotrix,addtable2plot,10,0,0,double,1
+plotrix,addtable2plot,11,0,0,any,1
+plotrix,addtable2plot,12,0,0,character,1
+plotrix,addtable2plot,13,0,0,logical,1
+plotrix,addtable2plot,14,0,0,logical,1
+plotrix,addtable2plot,15,0,0,logical,1
+plotrix,arctext,-1,0,0,list<double>,1
+plotrix,arctext,0,0,0,character,1
+plotrix,arctext,1,0,0,double[],1
+plotrix,arctext,2,0,0,double,1
+plotrix,arctext,3,0,0,double,1
+plotrix,arctext,3,0,1,null,1
+plotrix,arctext,4,0,0,any,1
+plotrix,arctext,5,0,0,null,1
+plotrix,arctext,6,0,0,double,1
+plotrix,arctext,7,0,0,logical,1
+plotrix,arctext,8,0,0,double,1
+plotrix,arctext,8,0,1,null,1
+plotrix,arctext,9,0,0,...,1
+plotrix,axis.break,-1,0,0,list<logical>,1
+plotrix,axis.break,0,0,0,double,1
+plotrix,axis.break,1,0,0,double,1
+plotrix,axis.break,1,0,1,null,1
+plotrix,axis.break,2,0,0,null,1
+plotrix,axis.break,3,0,0,character,1
+plotrix,axis.break,4,0,0,character,1
+plotrix,axis.break,5,0,0,character,1
+plotrix,axis.break,6,0,0,double,1
+plotrix,axis.mult,-1,0,0,null,1
+plotrix,axis.mult,0,0,0,double,1
+plotrix,axis.mult,1,0,0,null,1
+plotrix,axis.mult,2,0,0,any,1
+plotrix,axis.mult,3,0,0,double,1
+plotrix,axis.mult,4,0,0,character,1
+plotrix,axis.mult,5,0,0,any,1
+plotrix,axis.mult,6,0,0,null,1
+plotrix,axis.mult,7,0,0,...,1
+plotrix,barlabels,-1,0,0,list<logical>,1
+plotrix,barlabels,0,0,0,class<`matrix`>,1
+plotrix,barlabels,0,0,1,double[],1
+plotrix,barlabels,1,0,0,class<`matrix`>,1
+plotrix,barlabels,1,0,1,double[],1
+plotrix,barlabels,2,0,0,class<`matrix`>,1
+plotrix,barlabels,2,0,1,null,1
+plotrix,barlabels,3,0,0,double,1
+plotrix,barlabels,4,0,0,double,1
+plotrix,barlabels,5,0,0,double,1
+plotrix,barlabels,6,0,0,double,1
+plotrix,barlabels,7,0,0,...,1
+plotrix,barNest,-1,0,0,class<`brklist`>,1
+plotrix,barNest,0,0,0,class<`formula`>,1
+plotrix,barNest,1,0,0,class<`data.frame`>,1
+plotrix,barNest,2,0,0,character[],1
+plotrix,barNest,3,0,0,null,1
+plotrix,barNest,3,0,1,double[],1
+plotrix,barNest,4,0,0,character,1
+plotrix,barNest,5,0,0,character,1
+plotrix,barNest,6,0,0,character,1
+plotrix,barNest,7,0,0,double,1
+plotrix,barNest,8,0,0,logical,1
+plotrix,barNest,9,0,0,list<character[]>,1
+plotrix,barNest,10,0,0,double,1
+plotrix,barNest,11,0,0,null,1
+plotrix,barNest,12,0,0,logical,1
+plotrix,barNest,13,0,0,logical,1
+plotrix,barNest,14,0,0,null,1
+plotrix,barNest,15,0,0,logical,1
+plotrix,barp,-1,0,0,list<class<`matrix`>>,1
+plotrix,barp,-1,0,1,list<double[]>,1
+plotrix,barp,0,0,0,class<`data.frame`>,1
+plotrix,barp,0,0,1,class<`matrix`>,1
+plotrix,barp,0,0,2,double[],1
+plotrix,barp,1,0,0,double,1
+plotrix,barp,2,0,0,character[],1
+plotrix,barp,2,0,1,null,1
+plotrix,barp,3,0,0,character[],1
+plotrix,barp,3,0,1,null,1
+plotrix,barp,4,0,0,list<double>,1
+plotrix,barp,4,0,1,null,1
+plotrix,barp,5,0,0,character[],1
+plotrix,barp,5,0,1,null,1
+plotrix,barp,5,0,2,double[],1
+plotrix,barp,6,0,0,any,1
+plotrix,barp,7,0,0,character,1
+plotrix,barp,7,0,1,null,1
+plotrix,barp,8,0,0,character,1
+plotrix,barp,9,0,0,character,1
+plotrix,barp,10,0,0,null,1
+plotrix,barp,11,0,0,double[],1
+plotrix,barp,11,0,1,null,1
+plotrix,barp,12,0,0,null,1
+plotrix,barp,13,0,0,logical,1
+plotrix,barp,14,0,0,logical,1
+plotrix,barp,15,0,0,integer[],1
+plotrix,barp,15,0,1,null,1
+plotrix,battleship.plot,-1,0,0,list<double[]>,1
+plotrix,battleship.plot,0,0,0,class<`matrix`>,1
+plotrix,battleship.plot,1,0,0,double[],1
+plotrix,battleship.plot,2,0,0,character,1
+plotrix,battleship.plot,3,0,0,character,1
+plotrix,battleship.plot,4,0,0,character,1
+plotrix,battleship.plot,5,0,0,character,1
+plotrix,battleship.plot,6,0,0,character,1
+plotrix,battleship.plot,7,0,0,character[],1
+plotrix,battleship.plot,8,0,0,character[],1
+plotrix,battleship.plot,9,0,0,double,1
+plotrix,battleship.plot,10,0,0,double,1
+plotrix,battleship.plot,11,0,0,double,1
+plotrix,binciW,-1,0,0,double[],1
+plotrix,binciW,0,0,0,double,1
+plotrix,binciW,1,0,0,double,1
+plotrix,binciW,2,0,0,double,1
+plotrix,binciW,3,0,0,logical,1
+plotrix,binciWl,-1,0,0,double,1
+plotrix,binciWl,0,0,0,class<`factor`>,1
+plotrix,binciWl,0,0,1,double,1
+plotrix,binciWl,0,0,2,logical[],1
+plotrix,binciWl,1,0,0,any,1
+plotrix,binciWl,2,0,0,double,1
+plotrix,binciWl,3,0,0,character,1
+plotrix,binciWl,3,0,1,logical,1
+plotrix,binciWl,4,0,0,logical,1
+plotrix,binciWu,-1,0,0,double,1
+plotrix,binciWu,0,0,0,class<`factor`>,1
+plotrix,binciWu,0,0,1,logical[],1
+plotrix,binciWu,1,0,0,any,1
+plotrix,binciWu,2,0,0,double,1
+plotrix,binciWu,3,0,0,character,1
+plotrix,binciWu,3,0,1,logical,1
+plotrix,binciWu,4,0,0,logical,1
+plotrix,bin.wind.records,-1,0,0,class<`matrix`>,1
+plotrix,bin.wind.records,0,0,0,integer[],1
+plotrix,bin.wind.records,1,0,0,integer[],1
+plotrix,bin.wind.records,2,0,0,double,1
+plotrix,bin.wind.records,3,0,0,logical,1
+plotrix,bin.wind.records,4,0,0,double[],1
+plotrix,boxed.labels,-1,0,0,list<double>,1
+plotrix,boxed.labels,0,0,0,double[],1
+plotrix,boxed.labels,0,0,1,null,1
+plotrix,boxed.labels,0,0,2,list<double>,1
+plotrix,boxed.labels,1,0,0,double[],1
+plotrix,boxed.labels,1,0,1,null,1
+plotrix,boxed.labels,2,0,0,character[],1
+plotrix,boxed.labels,2,0,1,double[],1
+plotrix,boxed.labels,2,0,2,null,1
+plotrix,boxed.labels,3,0,0,character[],1
+plotrix,boxed.labels,4,0,0,logical,1
+plotrix,boxed.labels,5,0,0,double,1
+plotrix,boxed.labels,6,0,0,double,1
+plotrix,boxed.labels,7,0,0,double,1
+plotrix,boxed.labels,8,0,0,double,1
+plotrix,boxed.labels,9,0,0,double[],1
+plotrix,boxed.labels,10,0,0,logical,1
+plotrix,boxed.labels,11,0,0,logical,1
+plotrix,boxed.labels,12,0,0,...,1
+plotrix,box.heresy,-1,0,0,null,1
+plotrix,box.heresy,0,0,0,double[],1
+plotrix,box.heresy,1,0,0,any,1
+plotrix,box.heresy,2,0,0,double[],1
+plotrix,box.heresy,3,0,0,double[],1
+plotrix,box.heresy,4,0,0,double[],1
+plotrix,box.heresy,5,0,0,double[],1
+plotrix,box.heresy,6,0,0,null,1
+plotrix,box.heresy,6,0,1,double[],1
+plotrix,box.heresy,7,0,0,logical,1
+plotrix,box.heresy,8,0,0,null,1
+plotrix,box.heresy,9,0,0,double,1
+plotrix,box.heresy,10,0,0,character,1
+plotrix,box.heresy,11,0,0,character,1
+plotrix,box.heresy,12,0,0,character,1
+plotrix,box.heresy,13,0,0,null,1
+plotrix,box.heresy,13,0,1,character[],1
+plotrix,box.heresy,14,0,0,character,1
+plotrix,box.heresy,15,0,0,null,1
+plotrix,brkdnNest,-1,0,0,class<`brklist`>,1
+plotrix,brkdnNest,0,0,0,class<`formula`>,1
+plotrix,brkdnNest,1,0,0,class<`data.frame`>,1
+plotrix,brkdnNest,2,0,0,character[],1
+plotrix,brkdnNest,3,0,0,character,1
+plotrix,brkdnNest,4,0,0,character,1
+plotrix,brkdnNest,4,0,1,logical,1
+plotrix,brkdn.plot,-1,0,0,list<class<`matrix`>>,1
+plotrix,brkdn.plot,0,0,0,character,1
+plotrix,brkdn.plot,0,0,1,class<`formula`>,1
+plotrix,brkdn.plot,1,0,0,character,1
+plotrix,brkdn.plot,1,0,1,null,1
+plotrix,brkdn.plot,2,0,0,character,1
+plotrix,brkdn.plot,2,0,1,null,1
+plotrix,brkdn.plot,3,0,0,class<`data.frame`>,1
+plotrix,brkdn.plot,4,0,0,character,1
+plotrix,brkdn.plot,5,0,0,character,1
+plotrix,brkdn.plot,6,0,0,null,1
+plotrix,brkdn.plot,7,0,0,logical,1
+plotrix,brkdn.plot,8,0,0,character,1
+plotrix,brkdn.plot,9,0,0,null,1
+plotrix,brkdn.plot,9,0,1,character,1
+plotrix,brkdn.plot,10,0,0,null,1
+plotrix,brkdn.plot,10,0,1,character,1
+plotrix,brkdn.plot,11,0,0,null,1
+plotrix,brkdn.plot,11,0,1,character[],1
+plotrix,brkdn.plot,12,0,0,null,1
+plotrix,brkdn.plot,13,0,0,character,1
+plotrix,brkdn.plot,14,0,0,integer[],1
+plotrix,brkdn.plot,15,0,0,double,1
+plotrix,brkdn.plot,15,0,1,integer[],1
+plotrix,bumpchart,-1,0,0,list<double[]>,1
+plotrix,bumpchart,0,0,0,class<`matrix`>,1
+plotrix,bumpchart,1,0,0,character[],1
+plotrix,bumpchart,2,0,0,character[],1
+plotrix,bumpchart,3,0,0,logical,1
+plotrix,bumpchart,4,0,0,double[],1
+plotrix,bumpchart,5,0,0,double,1
+plotrix,bumpchart,6,0,0,character[],1
+plotrix,bumpchart,7,0,0,integer[],1
+plotrix,bumpchart,7,0,1,double,1
+plotrix,bumpchart,8,0,0,double,1
+plotrix,bumpchart,9,0,0,logical,1
+plotrix,bumpchart,10,0,0,...,1
+plotrix,categoryReshape,-1,0,0,class<`data.frame`>,1
+plotrix,categoryReshape,0,0,0,class<`data.frame`>,1
+plotrix,centipede.plot,-1,0,0,class<`matrix`>,1
+plotrix,centipede.plot,0,0,0,class<`matrix`>,1
+plotrix,centipede.plot,1,0,0,character,1
+plotrix,centipede.plot,2,0,0,character,1
+plotrix,centipede.plot,3,0,0,any,1
+plotrix,centipede.plot,4,0,0,character[],1
+plotrix,centipede.plot,4,0,1,null,1
+plotrix,centipede.plot,5,0,0,character[],1
+plotrix,centipede.plot,5,0,1,null,1
+plotrix,centipede.plot,6,0,0,logical,1
+plotrix,centipede.plot,7,0,0,character,1
+plotrix,centipede.plot,8,0,0,null,1
+plotrix,centipede.plot,9,0,0,double,1
+plotrix,centipede.plot,10,0,0,double,1
+plotrix,centipede.plot,11,0,0,null,1
+plotrix,centipede.plot,12,0,0,character,1
+plotrix,centipede.plot,13,0,0,double[],1
+plotrix,centipede.plot,13,0,1,null,1
+plotrix,centipede.plot,14,0,0,character,1
+plotrix,centipede.plot,15,0,0,character,1
+plotrix,clean.args,-1,0,0,list<any>,1
+plotrix,clean.args,0,0,0,list<character | double[]>,1
+plotrix,clean.args,0,0,1,list<double>,1
+plotrix,clean.args,0,0,2,list<double[] | character>,1
+plotrix,clean.args,1,0,0,class<`function`>,1
+plotrix,clean.args,2,0,0,logical,1
+plotrix,clean.args,3,0,0,character[],1
+plotrix,clean.args,3,0,1,null,1
+plotrix,clean.args,4,0,0,logical,1
+plotrix,clock24.plot,-1,0,0,list<double[] | character>,1
+plotrix,clock24.plot,0,0,0,double[],1
+plotrix,clock24.plot,1,0,0,double[],1
+plotrix,clock24.plot,2,0,0,any,1
+plotrix,clock24.plot,3,0,0,logical,1
+plotrix,clock24.plot,4,0,0,null,1
+plotrix,clock24.plot,5,0,0,character,1
+plotrix,clock24.plot,6,0,0,...,1
+plotrix,clplot,-1,0,0,list<double[] | class<`matrix`>>,1
+plotrix,clplot,0,0,0,integer[],1
+plotrix,clplot,1,0,0,double[],1
+plotrix,clplot,2,0,0,character,1
+plotrix,clplot,3,0,0,character,1
+plotrix,clplot,4,0,0,double[],1
+plotrix,clplot,5,0,0,character[],1
+plotrix,clplot,6,0,0,double,1
+plotrix,clplot,7,0,0,logical,1
+plotrix,clplot,8,0,0,...,1
+plotrix,clustered.dotplots,-1,0,0,null,1
+plotrix,clustered.dotplots,0,0,0,character[],1
+plotrix,clustered.dotplots,0,0,1,double[],1
+plotrix,clustered.dotplots,1,0,0,character[],1
+plotrix,clustered.dotplots,1,0,1,double[],1
+plotrix,clustered.dotplots,2,0,0,double[],1
+plotrix,clustered.dotplots,3,0,0,character,1
+plotrix,clustered.dotplots,4,0,0,character,1
+plotrix,clustered.dotplots,5,0,0,character,1
+plotrix,clustered.dotplots,6,0,0,character,1
+plotrix,clustered.dotplots,7,0,0,double,1
+plotrix,clustered.dotplots,8,0,0,double,1
+plotrix,clustered.dotplots,9,0,0,logical,1
+plotrix,clustered.dotplots,10,0,0,double,1
+plotrix,clustered.dotplots,11,0,0,...,1
+plotrix,cluster.overplot,-1,0,0,list<double[] | character[]>,1
+plotrix,cluster.overplot,0,0,0,class<`matrix`>,1
+plotrix,cluster.overplot,1,0,0,any,1
+plotrix,cluster.overplot,2,0,0,double[],1
+plotrix,cluster.overplot,3,0,0,null,1
+plotrix,cluster.overplot,4,0,0,...,1
+plotrix,color2D.matplot,-1,0,0,list<character | double[]>,1
+plotrix,color2D.matplot,0,0,0,class<`matrix`>,1
+plotrix,color2D.matplot,0,0,1,class<`table`>,1
+plotrix,color2D.matplot,1,0,0,any,1
+plotrix,color2D.matplot,2,0,0,any,1
+plotrix,color2D.matplot,3,0,0,any,1
+plotrix,color2D.matplot,4,0,0,double[],1
+plotrix,color2D.matplot,4,0,1,null,1
+plotrix,color2D.matplot,5,0,0,null,1
+plotrix,color2D.matplot,5,0,1,class<`matrix`>,1
+plotrix,color2D.matplot,6,0,0,logical,1
+plotrix,color2D.matplot,7,0,0,double,1
+plotrix,color2D.matplot,8,0,0,character,1
+plotrix,color2D.matplot,9,0,0,character,1
+plotrix,color2D.matplot,10,0,0,logical,1
+plotrix,color2D.matplot,11,0,0,logical,1
+plotrix,color2D.matplot,12,0,0,logical,1
+plotrix,color2D.matplot,13,0,0,null,1
+plotrix,color2D.matplot,14,0,0,double,1
+plotrix,color2D.matplot,15,0,0,class<`matrix`>,1
+plotrix,color2D.matplot,15,0,1,character,1
+plotrix,color2D.matplot,15,0,2,null,1
+plotrix,color.axis,-1,0,0,null,1
+plotrix,color.axis,0,0,0,double,1
+plotrix,color.axis,1,0,0,double[],1
+plotrix,color.axis,2,0,0,double[],1
+plotrix,color.axis,3,0,0,character,1
+plotrix,color.axis,4,0,0,double,1
+plotrix,color.axis,4,0,1,null,1
+plotrix,color.axis,5,0,0,double,1
+plotrix,color.axis,6,0,0,double,1
+plotrix,color.axis,7,0,0,double,1
+plotrix,color.gradient,-1,0,0,character[],1
+plotrix,color.gradient,0,0,0,double[],1
+plotrix,color.gradient,1,0,0,double[],1
+plotrix,color.gradient,2,0,0,double[],1
+plotrix,color.gradient,3,0,0,double,1
+plotrix,color.id,-1,0,0,character,1
+plotrix,color.id,0,0,0,character,1
+plotrix,color.legend,-1,0,0,list<double>,1
+plotrix,color.legend,0,0,0,double,1
+plotrix,color.legend,1,0,0,double,1
+plotrix,color.legend,2,0,0,double,1
+plotrix,color.legend,3,0,0,double,1
+plotrix,color.legend,4,0,0,character[],1
+plotrix,color.legend,4,0,1,double[],1
+plotrix,color.legend,5,0,0,character[],1
+plotrix,color.legend,6,0,0,double,1
+plotrix,color.legend,7,0,0,character,1
+plotrix,color.legend,8,0,0,character,1
+plotrix,color.legend,9,0,0,...,1
+plotrix,color.scale,-1,0,0,character[],1
+plotrix,color.scale,-1,0,1,class<`matrix`>,1
+plotrix,color.scale,0,0,0,double[],1
+plotrix,color.scale,0,0,1,class<`matrix`>,1
+plotrix,color.scale,1,0,0,any,1
+plotrix,color.scale,2,0,0,any,1
+plotrix,color.scale,3,0,0,any,1
+plotrix,color.scale,4,0,0,double,1
+plotrix,color.scale,5,0,0,null,1
+plotrix,color.scale,5,0,1,integer[],1
+plotrix,color.scale,6,0,0,null,1
+plotrix,color.scale,7,0,0,double[],1
+plotrix,color.scale,7,0,1,null,1
+plotrix,color.scale,8,0,0,character,1
+plotrix,color.scale.lines,-1,0,0,null,1
+plotrix,color.scale.lines,0,0,0,double[],1
+plotrix,color.scale.lines,1,0,0,double[],1
+plotrix,color.scale.lines,2,0,0,any,1
+plotrix,color.scale.lines,3,0,0,any,1
+plotrix,color.scale.lines,4,0,0,any,1
+plotrix,color.scale.lines,5,0,0,null,1
+plotrix,color.scale.lines,5,0,1,double[],1
+plotrix,color.scale.lines,6,0,0,double[],1
+plotrix,color.scale.lines,6,0,1,null,1
+plotrix,color.scale.lines,7,0,0,...,1
+plotrix,corner.label,-1,0,0,list<double>,1
+plotrix,corner.label,0,0,0,character,1
+plotrix,corner.label,0,0,1,null,1
+plotrix,corner.label,1,0,0,double,1
+plotrix,corner.label,2,0,0,double,1
+plotrix,corner.label,3,0,0,null,1
+plotrix,corner.label,4,0,0,null,1
+plotrix,corner.label,5,0,0,logical,1
+plotrix,corner.label,6,0,0,...,1
+plotrix,count.overplot,-1,0,0,null,1
+plotrix,count.overplot,0,0,0,class<`matrix`>,1
+plotrix,count.overplot,1,0,0,any,1
+plotrix,count.overplot,2,0,0,null,1
+plotrix,count.overplot,3,0,0,character,1
+plotrix,count.overplot,4,0,0,character,1
+plotrix,count.overplot,5,0,0,...,1
+plotrix,cylindrect,-1,0,0,class<`matrix`>,1
+plotrix,cylindrect,0,0,0,double[],1
+plotrix,cylindrect,1,0,0,double[],1
+plotrix,cylindrect,2,0,0,double[],1
+plotrix,cylindrect,3,0,0,class<`data.frame`>,1
+plotrix,cylindrect,3,0,1,double[],1
+plotrix,cylindrect,4,0,0,character[],1
+plotrix,cylindrect,5,0,0,character,1
+plotrix,cylindrect,5,0,1,null,1
+plotrix,cylindrect,6,0,0,character,1
+plotrix,cylindrect,7,0,0,double,1
+plotrix,dendroPlot,-1,0,0,null,1
+plotrix,dendroPlot,0,0,0,list<double[] | class<`factor`>>,1
+plotrix,dendroPlot,1,0,0,list<double>,1
+plotrix,dendroPlot,2,0,0,double,1
+plotrix,dendroPlot,3,0,0,character,1
+plotrix,dendroPlot,4,0,0,double,1
+plotrix,dendroPlot,5,0,0,double[],1
+plotrix,dendroPlot,5,0,1,null,1
+plotrix,dendroPlot,6,0,0,null,1
+plotrix,dendroPlot,7,0,0,...,1
+plotrix,densityGrid,-1,0,0,null,1
+plotrix,densityGrid,0,0,0,list<class<`matrix`>>,1
+plotrix,densityGrid,1,0,0,null,1
+plotrix,densityGrid,2,0,0,null,1
+plotrix,densityGrid,3,0,0,null,1
+plotrix,densityGrid,4,0,0,double[],1
+plotrix,densityGrid,5,0,0,double[],1
+plotrix,densityGrid,6,0,0,double[],1
+plotrix,densityGrid,7,0,0,double[],1
+plotrix,densityGrid,8,0,0,double[],1
+plotrix,densityGrid,9,0,0,double,1
+plotrix,densityGrid,10,0,0,double,1
+plotrix,densityGrid,11,0,0,double,1
+plotrix,densityGrid,12,0,0,logical,1
+plotrix,diamondplot,-1,0,0,list<character | double[] | null>,1
+plotrix,diamondplot,0,0,0,class<`data.frame`>,1
+plotrix,diamondplot,1,0,0,character,1
+plotrix,diamondplot,2,0,0,class<`function`>,1
+plotrix,diamondplot,3,0,0,character,1
+plotrix,diamondplot,4,0,0,...,1
+plotrix,dispersion,-1,0,0,null,1
+plotrix,dispersion,0,0,0,double[],1
+plotrix,dispersion,1,0,0,double[],1
+plotrix,dispersion,2,0,0,double[],1
+plotrix,dispersion,2,0,1,null,1
+plotrix,dispersion,3,0,0,double[],1
+plotrix,dispersion,3,0,1,null,1
+plotrix,dispersion,4,0,0,logical,1
+plotrix,dispersion,5,0,0,any,1
+plotrix,dispersion,6,0,0,null,1
+plotrix,dispersion,7,0,0,character,1
+plotrix,dispersion,8,0,0,null,1
+plotrix,dispersion,8,0,1,character,1
+plotrix,dispersion,9,0,0,null,1
+plotrix,dispersion,9,0,1,double,1
+plotrix,dispersion,10,0,0,null,1
+plotrix,dispersion,10,0,1,double,1
+plotrix,dispersion,11,0,0,null,1
+plotrix,dispersion,12,0,0,character,1
+plotrix,dispersion,12,0,1,integer,1
+plotrix,dispersion,13,0,0,logical,1
+plotrix,dispersion,14,0,0,...,1
+plotrix,draw.arc,-1,0,0,class<`data.frame`>,1
+plotrix,draw.arc,0,0,0,double,1
+plotrix,draw.arc,1,0,0,double,1
+plotrix,draw.arc,2,0,0,double[],1
+plotrix,draw.arc,3,0,0,double,1
+plotrix,draw.arc,4,0,0,double[],1
+plotrix,draw.arc,5,0,0,double,1
+plotrix,draw.arc,6,0,0,double[],1
+plotrix,draw.arc,7,0,0,double,1
+plotrix,draw.arc,8,0,0,character,1
+plotrix,draw.arc,8,0,1,integer[],1
+plotrix,draw.arc,9,0,0,null,1
+plotrix,draw.arc,9,0,1,double,1
+plotrix,draw.arc,10,0,0,...,1
+plotrix,draw.circle,-1,0,0,list<double[]>,1
+plotrix,draw.circle,0,0,0,double,1
+plotrix,draw.circle,1,0,0,double,1
+plotrix,draw.circle,2,0,0,double[],1
+plotrix,draw.circle,3,0,0,double,1
+plotrix,draw.circle,4,0,0,character,1
+plotrix,draw.circle,4,0,1,null,1
+plotrix,draw.circle,5,0,0,character[],1
+plotrix,draw.circle,5,0,1,null,1
+plotrix,draw.circle,6,0,0,double,1
+plotrix,draw.circle,7,0,0,null,1
+plotrix,draw.circle,7,0,1,double,1
+plotrix,draw.circle,8,0,0,double,1
+plotrix,draw.circle,9,0,0,double,1
+plotrix,draw.ellipse,-1,0,0,null,1
+plotrix,draw.ellipse,0,0,0,double[],1
+plotrix,draw.ellipse,1,0,0,double[],1
+plotrix,draw.ellipse,2,0,0,double[],1
+plotrix,draw.ellipse,3,0,0,double[],1
+plotrix,draw.ellipse,4,0,0,double[],1
+plotrix,draw.ellipse,5,0,0,class<`matrix`>,1
+plotrix,draw.ellipse,5,0,1,null,1
+plotrix,draw.ellipse,6,0,0,logical,1
+plotrix,draw.ellipse,7,0,0,logical,1
+plotrix,draw.ellipse,8,0,0,double[],1
+plotrix,draw.ellipse,9,0,0,double[],1
+plotrix,draw.ellipse,9,0,1,null,1
+plotrix,draw.ellipse,10,0,0,null,1
+plotrix,draw.ellipse,10,0,1,double[],1
+plotrix,draw.ellipse,11,0,0,double,1
+plotrix,draw.ellipse,12,0,0,double,1
+plotrix,draw.ellipse,13,0,0,...,1
+plotrix,drawNestedBars,-1,0,0,null,1
+plotrix,drawNestedBars,0,0,0,class<`brklist`>,1
+plotrix,drawNestedBars,0,0,1,list<list<double[] | class<`matrix`>>>,1
+plotrix,drawNestedBars,0,0,2,list<list<^double[] | class<`matrix`> | double[] | class<`matrix`>>>,1
+plotrix,drawNestedBars,0,0,3,list<list<double[] | class<`matrix`> | integer[] | class<`matrix`>>>,1
+plotrix,drawNestedBars,0,0,4,list<list<^double[]>>,1
+plotrix,drawNestedBars,0,0,5,list<list<double | null>>,1
+plotrix,drawNestedBars,0,0,6,list<list<integer[] | class<`matrix`>>>,1
+plotrix,drawNestedBars,0,0,7,list<list<null | ^double[] | double[]>>,1
+plotrix,drawNestedBars,0,0,8,list<list<null | double>>,1
+plotrix,drawNestedBars,1,0,0,double,1
+plotrix,drawNestedBars,2,0,0,double,1
+plotrix,drawNestedBars,3,0,0,any,1
+plotrix,drawNestedBars,4,0,0,logical,1
+plotrix,drawNestedBars,5,0,0,any,1
+plotrix,drawNestedBars,6,0,0,list<character[]>,1
+plotrix,drawNestedBars,7,0,0,double,1
+plotrix,drawNestedBars,8,0,0,double,1
+plotrix,drawNestedBars,9,0,0,double,1
+plotrix,drawNestedBars,10,0,0,any,1
+plotrix,drawNestedBars,11,0,0,list<character[]>,1
+plotrix,drawNestedBars,12,0,0,logical,1
+plotrix,drawNestedBars,13,0,0,any,1
+plotrix,draw.radial.line,-1,0,0,null,1
+plotrix,draw.radial.line,0,0,0,double,1
+plotrix,draw.radial.line,1,0,0,double,1
+plotrix,draw.radial.line,2,0,0,double[],1
+plotrix,draw.radial.line,3,0,0,double,1
+plotrix,draw.radial.line,4,0,0,double,1
+plotrix,draw.radial.line,4,0,1,null,1
+plotrix,draw.radial.line,5,0,0,logical,1
+plotrix,draw.radial.line,6,0,0,character,1
+plotrix,draw.radial.line,6,0,1,null,1
+plotrix,draw.radial.line,7,0,0,double,1
+plotrix,draw.radial.line,7,0,1,null,1
+plotrix,draw.radial.line,8,0,0,...,1
+plotrix,drawSectorAnnulus,-1,0,0,null,1
+plotrix,drawSectorAnnulus,0,0,0,double,1
+plotrix,drawSectorAnnulus,1,0,0,double,1
+plotrix,drawSectorAnnulus,2,0,0,double,1
+plotrix,drawSectorAnnulus,3,0,0,double,1
+plotrix,drawSectorAnnulus,4,0,0,character,1
+plotrix,drawSectorAnnulus,5,0,0,double,1
+plotrix,draw.tilted.sector,-1,0,0,double,1
+plotrix,draw.tilted.sector,0,0,0,double,1
+plotrix,draw.tilted.sector,1,0,0,double,1
+plotrix,draw.tilted.sector,2,0,0,null,1
+plotrix,draw.tilted.sector,3,0,0,double,1
+plotrix,draw.tilted.sector,4,0,0,double,1
+plotrix,draw.tilted.sector,5,0,0,double,1
+plotrix,draw.tilted.sector,6,0,0,double,1
+plotrix,draw.tilted.sector,7,0,0,double,1
+plotrix,draw.tilted.sector,8,0,0,character,1
+plotrix,draw.tilted.sector,9,0,0,character,1
+plotrix,draw.tilted.sector,10,0,0,double,1
+plotrix,draw.tilted.sector,11,0,0,double,1
+plotrix,ehplot,-1,0,0,null,1
+plotrix,ehplot,0,0,0,double[],1
+plotrix,ehplot,1,0,0,class<`factor`>,1
+plotrix,ehplot,2,0,0,double,1
+plotrix,ehplot,3,0,0,double,1
+plotrix,ehplot,4,0,0,logical,1
+plotrix,ehplot,5,0,0,logical,1
+plotrix,ehplot,6,0,0,logical,1
+plotrix,ehplot,7,0,0,character,1
+plotrix,ehplot,8,0,0,character,1
+plotrix,ehplot,9,0,0,character,1
+plotrix,ehplot,10,0,0,character[],1
+plotrix,ehplot,11,0,0,logical,1
+plotrix,ehplot,12,0,0,logical,1
+plotrix,ehplot,13,0,0,...,1
+plotrix,election,-1,0,0,class<`data.frame`>,1
+plotrix,election,0,0,0,class<`data.frame`>,1
+plotrix,election,1,0,0,class<`data.frame`>,1
+plotrix,election,2,0,0,class<`formula`>,1
+plotrix,election,3,0,0,character[],1
+plotrix,emptyspace,-1,0,0,list<double>,1
+plotrix,emptyspace,0,0,0,double[],1
+plotrix,emptyspace,0,0,1,list<class<`matrix`>>,1
+plotrix,emptyspace,1,0,0,double[],1
+plotrix,emptyspace,1,0,1,null,1
+plotrix,fan.plot,-1,0,0,double[],1
+plotrix,fan.plot,0,0,0,double[],1
+plotrix,fan.plot,1,0,0,double,1
+plotrix,fan.plot,2,0,0,double,1
+plotrix,fan.plot,3,0,0,null,1
+plotrix,fan.plot,4,0,0,null,1
+plotrix,fan.plot,5,0,0,double,1
+plotrix,fan.plot,6,0,0,character[],1
+plotrix,fan.plot,7,0,0,null,1
+plotrix,fan.plot,8,0,0,double,1
+plotrix,fan.plot,9,0,0,character,1
+plotrix,fan.plot,10,0,0,double,1
+plotrix,fan.plot,11,0,0,character,1
+plotrix,fan.plot,12,0,0,double,1
+plotrix,fan.plot,13,0,0,logical,1
+plotrix,fan.plot,14,0,0,...,1
+plotrix,feather.plot,-1,0,0,list<double[]>,1
+plotrix,feather.plot,0,0,0,double[],1
+plotrix,feather.plot,1,0,0,double[],1
+plotrix,feather.plot,2,0,0,any,1
+plotrix,feather.plot,3,0,0,double,1
+plotrix,feather.plot,4,0,0,logical,1
+plotrix,feather.plot,5,0,0,character,1
+plotrix,feather.plot,6,0,0,character,1
+plotrix,feather.plot,7,0,0,character,1
+plotrix,feather.plot,8,0,0,character,1
+plotrix,feather.plot,9,0,0,character,1
+plotrix,feather.plot,10,0,0,integer[],1
+plotrix,feather.plot,11,0,0,...,1
+plotrix,fill.corner,-1,0,0,class<`matrix`>,1
+plotrix,fill.corner,0,0,0,character[],1
+plotrix,fill.corner,1,0,0,double,1
+plotrix,fill.corner,2,0,0,double,1
+plotrix,fill.corner,3,0,0,null,1
+plotrix,floating.pie,-1,0,0,double[],1
+plotrix,floating.pie,0,0,0,double,1
+plotrix,floating.pie,1,0,0,double,1
+plotrix,floating.pie,2,0,0,double[],1
+plotrix,floating.pie,3,0,0,double,1
+plotrix,floating.pie,4,0,0,double,1
+plotrix,floating.pie,5,0,0,character[],1
+plotrix,floating.pie,5,0,1,null,1
+plotrix,floating.pie,6,0,0,double,1
+plotrix,floating.pie,7,0,0,logical,1
+plotrix,floating.pie,8,0,0,any,1
+plotrix,floating.pie,9,0,0,double[],1
+plotrix,floating.pie,10,0,0,...,1
+plotrix,fullaxis,-1,0,0,double[],1
+plotrix,fullaxis,0,0,0,double,1
+plotrix,fullaxis,1,0,0,double[],1
+plotrix,fullaxis,1,0,1,null,1
+plotrix,fullaxis,2,0,0,character[],1
+plotrix,fullaxis,2,0,1,logical,1
+plotrix,fullaxis,3,0,0,null,1
+plotrix,fullaxis,4,0,0,double,1
+plotrix,fullaxis,4,0,1,null,1
+plotrix,fullaxis,5,0,0,logical,1
+plotrix,fullaxis,6,0,0,null,1
+plotrix,fullaxis,7,0,0,character,1
+plotrix,fullaxis,8,0,0,double,1
+plotrix,fullaxis,9,0,0,any,1
+plotrix,fullaxis,10,0,0,character,1
+plotrix,fullaxis,11,0,0,null,1
+plotrix,fullaxis,12,0,0,null,1
+plotrix,fullaxis,13,0,0,null,1
+plotrix,fullaxis,14,0,0,...,1
+plotrix,furc,-1,0,0,null,1
+plotrix,furc,0,0,0,class<`dendrite`>,1
+plotrix,furc,1,0,0,double,1
+plotrix,furc,2,0,0,double[],1
+plotrix,furc,3,0,0,logical,1
+plotrix,furc,4,0,0,double,1
+plotrix,furc,5,0,0,double,1
+plotrix,furc,6,0,0,character[],1
+plotrix,gantt.chart,-1,0,0,"list<character[] | class<`POSIXct`, `POSIXt`> | double[]>",1
+plotrix,gantt.chart,-1,0,1,list<character[] | double[]>,1
+plotrix,gantt.chart,0,0,0,"list<character[] | class<`POSIXct`, `POSIXt`> | double[]>",1
+plotrix,gantt.chart,0,0,1,list<character[] | double[]>,1
+plotrix,gantt.chart,1,0,0,character,1
+plotrix,gantt.chart,2,0,0,"class<`POSIXct`, `POSIXt`>",1
+plotrix,gantt.chart,2,0,1,null,1
+plotrix,gantt.chart,3,0,0,null,1
+plotrix,gantt.chart,3,0,1,character[],1
+plotrix,gantt.chart,3,0,2,double[],1
+plotrix,gantt.chart,4,0,0,logical,1
+plotrix,gantt.chart,5,0,0,"class<`POSIXct`, `POSIXt`>",1
+plotrix,gantt.chart,5,0,1,integer[],1
+plotrix,gantt.chart,6,0,0,character[],1
+plotrix,gantt.chart,6,0,1,integer[],1
+plotrix,gantt.chart,7,0,0,character,1
+plotrix,gantt.chart,8,0,0,double,1
+plotrix,gantt.chart,9,0,0,logical,1
+plotrix,gantt.chart,10,0,0,character,1
+plotrix,gantt.chart,11,0,0,character,1
+plotrix,gantt.chart,12,0,0,logical,1
+plotrix,gantt.chart,13,0,0,double,1
+plotrix,gantt.chart,14,0,0,null,1
+plotrix,gantt.chart,14,0,1,character,1
+plotrix,gantt.chart,15,0,0,character,1
+plotrix,gap.barplot,-1,0,0,integer[],1
+plotrix,gap.barplot,0,0,0,double[],1
+plotrix,gap.barplot,1,0,0,double[],1
+plotrix,gap.barplot,2,0,0,any,1
+plotrix,gap.barplot,3,0,0,any,1
+plotrix,gap.barplot,4,0,0,any,1
+plotrix,gap.barplot,5,0,0,double[],1
+plotrix,gap.barplot,6,0,0,null,1
+plotrix,gap.barplot,7,0,0,null,1
+plotrix,gap.barplot,8,0,0,character,1
+plotrix,gap.barplot,9,0,0,character,1
+plotrix,gap.barplot,10,0,0,logical,1
+plotrix,gap.barplot,11,0,0,null,1
+plotrix,gap.barplot,12,0,0,...,1
+plotrix,gap.boxplot,-1,0,0,list<class<`matrix`> | double[] | character[]>,1
+plotrix,gap.boxplot,0,0,0,list<double[]>,1
+plotrix,gap.boxplot,1,0,0,...,1
+plotrix,gap.boxplot,2,0,0,list<double[]>,1
+plotrix,gap.boxplot,3,0,0,double,1
+plotrix,gap.boxplot,4,0,0,null,1
+plotrix,gap.boxplot,5,0,0,logical,1
+plotrix,gap.boxplot,6,0,0,logical,1
+plotrix,gap.boxplot,7,0,0,logical,1
+plotrix,gap.boxplot,8,0,0,any,1
+plotrix,gap.boxplot,9,0,0,null,1
+plotrix,gap.boxplot,10,0,0,null,1
+plotrix,gap.boxplot,11,0,0,logical,1
+plotrix,gap.boxplot,12,0,0,character,1
+plotrix,gap.boxplot,13,0,0,null,1
+plotrix,gap.boxplot,14,0,0,character,1
+plotrix,gap.boxplot,15,0,0,null,1
+plotrix,gap.plot,-1,0,0,null,1
+plotrix,gap.plot,0,0,0,double[],1
+plotrix,gap.plot,1,0,0,any,1
+plotrix,gap.plot,2,0,0,double[],1
+plotrix,gap.plot,3,0,0,character,1
+plotrix,gap.plot,4,0,0,character,1
+plotrix,gap.plot,5,0,0,character,1
+plotrix,gap.plot,6,0,0,double,1
+plotrix,gap.plot,7,0,0,double[],1
+plotrix,gap.plot,8,0,0,double[],1
+plotrix,gap.plot,9,0,0,any,1
+plotrix,gap.plot,10,0,0,double[],1
+plotrix,gap.plot,10,0,1,null,1
+plotrix,gap.plot,11,0,0,any,1
+plotrix,gap.plot,12,0,0,null,1
+plotrix,gap.plot,12,0,1,double[],1
+plotrix,gap.plot,13,0,0,double[],1
+plotrix,gap.plot,14,0,0,character[],1
+plotrix,gap.plot,14,0,1,double[],1
+plotrix,gap.plot,15,0,0,double[],1
+plotrix,get_axispos3d,-1,0,0,class<`matrix`>,1
+plotrix,get_axispos3d,0,0,0,character,1
+plotrix,get_axispos3d,1,0,0,class<`matrix`>,1
+plotrix,get_axispos3d,2,0,0,double[],1
+plotrix,get_axispos3d,3,0,0,null,1
+plotrix,get_axispos3d,4,0,0,double,1
+plotrix,get.breaks,-1,0,0,integer[],1
+plotrix,get.breaks,0,0,0,any,1
+plotrix,get.breaks,1,0,0,integer[],1
+plotrix,getFigCtr,-1,0,0,double[],1
+plotrix,getFigCtr,0,0,0,double[],1
+plotrix,get.gantt.info,-1,0,0,list<null>,1
+plotrix,get.gantt.info,0,0,0,character,1
+plotrix,getMarginWidth,-1,0,0,list<double>,1
+plotrix,getMarginWidth,0,0,0,double,1
+plotrix,getMarginWidth,1,0,0,character[],1
+plotrix,getMarginWidth,2,0,0,logical,1
+plotrix,get.segs,-1,0,0,class<`matrix`>,1
+plotrix,get.segs,0,0,0,list<double[]>,1
+plotrix,get.segs,1,0,0,character,1
+plotrix,get.segs,2,0,0,character,1
+plotrix,get.segs,3,0,0,character,1
+plotrix,getYmult,-1,0,0,double,1
+plotrix,gradient.rect,-1,0,0,character[],1
+plotrix,gradient.rect,0,0,0,double[],1
+plotrix,gradient.rect,1,0,0,double[],1
+plotrix,gradient.rect,2,0,0,double[],1
+plotrix,gradient.rect,3,0,0,class<`data.frame`>,1
+plotrix,gradient.rect,3,0,1,double[],1
+plotrix,gradient.rect,4,0,0,any,1
+plotrix,gradient.rect,5,0,0,any,1
+plotrix,gradient.rect,6,0,0,any,1
+plotrix,gradient.rect,7,0,0,null,1
+plotrix,gradient.rect,7,0,1,character[],1
+plotrix,gradient.rect,8,0,0,any,1
+plotrix,gradient.rect,9,0,0,character,1
+plotrix,gradient.rect,10,0,0,character,1
+plotrix,gradient.rect,10,0,1,null,1
+plotrix,hexagon,-1,0,0,null,1
+plotrix,hexagon,0,0,0,double,1
+plotrix,hexagon,1,0,0,integer,1
+plotrix,hexagon,2,0,0,double,1
+plotrix,hexagon,3,0,0,character,1
+plotrix,hexagon,4,0,0,null,1
+plotrix,histStack,-1,0,0,null,1
+plotrix,histStack,-1,0,1,list<list<double[]>>,1
+plotrix,histStack,0,0,0,class<`formula`>,1
+plotrix,histStack,1,0,0,...,1
+plotrix,histStack.default,-1,0,0,null,1
+plotrix,histStack.default,-1,0,1,list<list<double[]>>,1
+plotrix,histStack.default,0,0,0,double[],1
+plotrix,histStack.default,1,0,0,class<`factor`>,1
+plotrix,histStack.default,2,0,0,character,1
+plotrix,histStack.default,3,0,0,character,1
+plotrix,histStack.default,3,0,1,integer[],1
+plotrix,histStack.default,4,0,0,logical,1
+plotrix,histStack.default,5,0,0,character,1
+plotrix,histStack.default,6,0,0,character,1
+plotrix,histStack.default,7,0,0,null,1
+plotrix,histStack.default,7,0,1,character,1
+plotrix,histStack.default,7,0,2,double[],1
+plotrix,histStack.default,8,0,0,any,1
+plotrix,histStack.default,9,0,0,...,1
+plotrix,histStack.formula,-1,0,0,null,1
+plotrix,histStack.formula,-1,0,1,list<list<double[]>>,1
+plotrix,histStack.formula,0,0,0,class<`formula`>,1
+plotrix,histStack.formula,1,0,0,class<`data.frame`>,1
+plotrix,histStack.formula,2,0,0,character,1
+plotrix,histStack.formula,3,0,0,character,1
+plotrix,histStack.formula,3,0,1,integer[],1
+plotrix,histStack.formula,4,0,0,logical,1
+plotrix,histStack.formula,5,0,0,character,1
+plotrix,histStack.formula,6,0,0,character,1
+plotrix,histStack.formula,7,0,0,null,1
+plotrix,histStack.formula,7,0,1,character,1
+plotrix,histStack.formula,7,0,2,double[],1
+plotrix,histStack.formula,8,0,0,double,1
+plotrix,histStack.formula,9,0,0,...,1
+plotrix,intersectDiagram,-1,0,0,class<`intersectList`>,1
+plotrix,intersectDiagram,0,0,0,class<`intersectList`>,1
+plotrix,intersectDiagram,0,0,1,class<`matrix`>,1
+plotrix,intersectDiagram,1,0,0,logical,1
+plotrix,intersectDiagram,2,0,0,logical,1
+plotrix,intersectDiagram,3,0,0,null,1
+plotrix,intersectDiagram,4,0,0,character,1
+plotrix,intersectDiagram,5,0,0,double[],1
+plotrix,intersectDiagram,6,0,0,character,1
+plotrix,intersectDiagram,7,0,0,double,1
+plotrix,intersectDiagram,8,0,0,null,1
+plotrix,intersectDiagram,8,0,1,character[],1
+plotrix,intersectDiagram,9,0,0,null,1
+plotrix,intersectDiagram,9,0,1,double,1
+plotrix,intersectDiagram,10,0,0,logical,1
+plotrix,intersectDiagram,11,0,0,character,1
+plotrix,intersectDiagram,11,0,1,null,1
+plotrix,intersectDiagram,12,0,0,character,1
+plotrix,jiggle,-1,0,0,double[],1
+plotrix,jiggle,0,0,0,double,1
+plotrix,jiggle,1,0,0,double[],1
+plotrix,joyPlot,-1,0,0,list<double[]>,1
+plotrix,joyPlot,0,0,0,list<class<`density`>>,1
+plotrix,joyPlot,1,0,0,double[],1
+plotrix,joyPlot,2,0,0,double[],1
+plotrix,joyPlot,3,0,0,null,1
+plotrix,joyPlot,4,0,0,null,1
+plotrix,joyPlot,4,0,1,character[],1
+plotrix,joyPlot,5,0,0,character,1
+plotrix,joyPlot,6,0,0,character,1
+plotrix,joyPlot,7,0,0,character,1
+plotrix,joyPlot,8,0,0,double[],1
+plotrix,joyPlot,9,0,0,null,1
+plotrix,joyPlot,9,0,1,character[],1
+plotrix,joyPlot,10,0,0,null,1
+plotrix,joyPlot,11,0,0,null,1
+plotrix,kiteChart,-1,0,0,list<double[]>,1
+plotrix,kiteChart,0,0,0,class<`matrix`>,1
+plotrix,kiteChart,1,0,0,null,1
+plotrix,kiteChart,2,0,0,null,1
+plotrix,kiteChart,3,0,0,logical,1
+plotrix,kiteChart,4,0,0,character,1
+plotrix,kiteChart,5,0,0,character,1
+plotrix,kiteChart,6,0,0,character,1
+plotrix,kiteChart,7,0,0,character,1
+plotrix,kiteChart,8,0,0,null,1
+plotrix,kiteChart,9,0,0,null,1
+plotrix,kiteChart,10,0,0,character[],1
+plotrix,kiteChart,11,0,0,logical,1
+plotrix,kiteChart,12,0,0,double[],1
+plotrix,kiteChart,13,0,0,double[],1
+plotrix,kiteChart,13,0,1,null,1
+plotrix,kiteChart,14,0,0,double[],1
+plotrix,kiteChart,15,0,0,double[],1
+plotrix,labbePlot,-1,0,0,null,1
+plotrix,labbePlot,0,0,0,list<class<`table`> | double[]>,1
+plotrix,labbePlot,0,0,1,list<double[]>,1
+plotrix,labbePlot,1,0,0,character,1
+plotrix,labbePlot,2,0,0,character,1
+plotrix,labbePlot,3,0,0,character,1
+plotrix,labbePlot,4,0,0,list<character>,1
+plotrix,labbePlot,5,0,0,list<character>,1
+plotrix,labbePlot,6,0,0,double,1
+plotrix,labbePlot,7,0,0,logical,1
+plotrix,labbePlot,8,0,0,...,1
+plotrix,ladderplot,-1,0,0,null,1
+plotrix,ladderplot,0,0,0,class<`data.frame`>,1
+plotrix,ladderplot,1,0,0,...,1
+plotrix,ladderplot.default,-1,0,0,null,1
+plotrix,ladderplot.default,0,0,0,class<`data.frame`>,1
+plotrix,ladderplot.default,1,0,0,logical,1
+plotrix,ladderplot.default,2,0,0,double,1
+plotrix,ladderplot.default,2,0,1,integer[],1
+plotrix,ladderplot.default,3,0,0,double,1
+plotrix,ladderplot.default,4,0,0,double,1
+plotrix,ladderplot.default,5,0,0,double[],1
+plotrix,ladderplot.default,6,0,0,double[],1
+plotrix,ladderplot.default,7,0,0,logical,1
+plotrix,ladderplot.default,8,0,0,logical,1
+plotrix,ladderplot.default,9,0,0,...,1
+plotrix,legendg,-1,0,0,list<list<double[]>>,1
+plotrix,legendg,0,0,0,double,1
+plotrix,legendg,1,0,0,double,1
+plotrix,legendg,2,0,0,character[],1
+plotrix,legendg,3,0,0,list<double | integer[]>,1
+plotrix,legendg,3,0,1,null,1
+plotrix,legendg,4,0,0,any,1
+plotrix,legendg,5,0,0,any,1
+plotrix,legendg,6,0,0,any,1
+plotrix,legendg,7,0,0,any,1
+plotrix,legendg,8,0,0,null,1
+plotrix,legendg,8,0,1,list<character[]>,1
+plotrix,legendg,8,0,2,list<double | integer[]>,1
+plotrix,legendg,9,0,0,double,1
+plotrix,legendg,10,0,0,null,1
+plotrix,legendg,11,0,0,character,1
+plotrix,legendg,12,0,0,character,1
+plotrix,legendg,13,0,0,double,1
+plotrix,legendg,14,0,0,character,1
+plotrix,legendg,15,0,0,any,1
+plotrix,lengthKey,-1,0,0,list<logical>,1
+plotrix,lengthKey,0,0,0,double,1
+plotrix,lengthKey,1,0,0,double,1
+plotrix,lengthKey,2,0,0,double[],1
+plotrix,lengthKey,3,0,0,double,1
+plotrix,listDepth,-1,0,0,double,1
+plotrix,listDepth,0,0,0,class<`dendrite`>,1
+plotrix,listDepth,0,0,1,integer,1
+plotrix,listDepth,0,0,2,list<integer | null>,1
+plotrix,listDepth,0,0,3,null,1
+plotrix,makeDendrite,-1,0,0,class<`dendrite`>,1
+plotrix,makeDendrite,0,0,0,class<`data.frame`>,1
+plotrix,makeDendrite,0,0,1,class<`dendrite`>,1
+plotrix,makeDendrite,0,0,2,class<`factor`>,1
+plotrix,makeDensityMatrix,-1,0,0,list<class<`matrix`>>,1
+plotrix,makeDensityMatrix,0,0,0,integer[],1
+plotrix,makeDensityMatrix,1,0,0,integer[],1
+plotrix,makeDensityMatrix,2,0,0,double[],1
+plotrix,makeDensityMatrix,3,0,0,double,1
+plotrix,makeDensityMatrix,4,0,0,double,1
+plotrix,makeDensityMatrix,5,0,0,character[],1
+plotrix,makeDensityMatrix,6,0,0,double[],1
+plotrix,makeDensityMatrix,7,0,0,double[],1
+plotrix,makeDensityMatrix,8,0,0,logical,1
+plotrix,makeIntersectList,-1,0,0,class<`intersectList`>,1
+plotrix,makeIntersectList,0,0,0,class<`data.frame`>,1
+plotrix,makeIntersectList,0,0,1,class<`matrix`>,1
+plotrix,makeIntersectList,1,0,0,null,1
+plotrix,makeIntersectList,2,0,0,character,1
+plotrix,maxEmptyRect,-1,0,0,list<double[]>,1
+plotrix,maxEmptyRect,0,0,0,double[],1
+plotrix,maxEmptyRect,1,0,0,double[],1
+plotrix,maxEmptyRect,2,0,0,double[],1
+plotrix,maxEmptyRect,3,0,0,double[],1
+plotrix,mtext3d,-1,0,0,null,1
+plotrix,mtext3d,0,0,0,character,1
+plotrix,mtext3d,1,0,0,class<`matrix`>,1
+plotrix,mtext3d,2,0,0,character,1
+plotrix,mtext3d,2,0,1,expression,1
+plotrix,mtext3d,3,0,0,null,1
+plotrix,mtext3d,4,0,0,double,1
+plotrix,mtext3d,5,0,0,null,1
+plotrix,mtext3d,6,0,0,...,1
+plotrix,multhist,-1,0,0,list<class<`histogram`> | class<`matrix`>>,1
+plotrix,multhist,0,0,0,list<double[]>,1
+plotrix,multhist,1,0,0,logical,1
+plotrix,multhist,2,0,0,null,1
+plotrix,multhist,3,0,0,any,1
+plotrix,multhist,4,0,0,logical,1
+plotrix,multhist,5,0,0,...,1
+plotrix,multsymbolbox,-1,0,0,null,1
+plotrix,multsymbolbox,0,0,0,double[],1
+plotrix,multsymbolbox,1,0,0,double[],1
+plotrix,multsymbolbox,2,0,0,double[],1
+plotrix,multsymbolbox,3,0,0,double[],1
+plotrix,multsymbolbox,4,0,0,double[],1
+plotrix,multsymbolbox,5,0,0,double,1
+plotrix,multsymbolbox,6,0,0,character[],1
+plotrix,multsymbolbox,7,0,0,character[],1
+plotrix,multsymbolbox,8,0,0,logical,1
+plotrix,multsymbolbox,9,0,0,logical,1
+plotrix,multsymbolbox,10,0,0,...,1
+plotrix,oz.windrose,-1,0,0,null,1
+plotrix,oz.windrose,0,0,0,class<`matrix`>,1
+plotrix,oz.windrose,1,0,0,double,1
+plotrix,oz.windrose,2,0,0,double[],1
+plotrix,oz.windrose,3,0,0,double,1
+plotrix,oz.windrose,4,0,0,character[],1
+plotrix,oz.windrose,5,0,0,null,1
+plotrix,oz.windrose,6,0,0,logical,1
+plotrix,oz.windrose,7,0,0,null,1
+plotrix,oz.windrose,8,0,0,...,1
+plotrix,oz.windrose.legend,-1,0,0,null,1
+plotrix,oz.windrose.legend,0,0,0,double,1
+plotrix,oz.windrose.legend,1,0,0,double,1
+plotrix,oz.windrose.legend,2,0,0,character[],1
+plotrix,oz.windrose.legend,3,0,0,double[],1
+plotrix,oz.windrose.legend,3,0,1,null,1
+plotrix,oz.windrose.legend,4,0,0,double,1
+plotrix,oz.windrose.legend,4,0,1,null,1
+plotrix,p2p_arrows,-1,0,0,null,1
+plotrix,p2p_arrows,0,0,0,integer[],1
+plotrix,p2p_arrows,1,0,0,double[],1
+plotrix,p2p_arrows,2,0,0,double[],1
+plotrix,p2p_arrows,3,0,0,double[],1
+plotrix,p2p_arrows,4,0,0,double,1
+plotrix,p2p_arrows,5,0,0,any,1
+plotrix,p2p_arrows,6,0,0,...,1
+plotrix,panes,-1,0,0,list<double[]>,1
+plotrix,panes,0,0,0,class<`matrix`>,1
+plotrix,panes,1,0,0,double[],1
+plotrix,panes,2,0,0,double[],1
+plotrix,panes,3,0,0,double,1
+plotrix,panes,4,0,0,double,1
+plotrix,panes,5,0,0,any,1
+plotrix,panes,6,0,0,any,1
+plotrix,pasteCols,-1,0,0,character[],1
+plotrix,pasteCols,0,0,0,class<`matrix`>,1
+plotrix,pasteCols,1,0,0,character,1
+plotrix,paxis3d,-1,0,0,null,1
+plotrix,paxis3d,0,0,0,character,1
+plotrix,paxis3d,1,0,0,class<`matrix`>,1
+plotrix,paxis3d,2,0,0,double[],1
+plotrix,paxis3d,2,0,1,null,1
+plotrix,paxis3d,3,0,0,logical,1
+plotrix,paxis3d,4,0,0,logical,1
+plotrix,paxis3d,5,0,0,null,1
+plotrix,paxis3d,6,0,0,double,1
+plotrix,paxis3d,7,0,0,double,1
+plotrix,paxis3d,8,0,0,double,1
+plotrix,paxis3d,9,0,0,null,1
+plotrix,paxis3d,10,0,0,...,1
+plotrix,perspx,-1,0,0,class<`matrix`>,1
+plotrix,perspx,0,0,0,integer[],1
+plotrix,perspx,1,0,0,integer[],1
+plotrix,perspx,2,0,0,class<`matrix`>,1
+plotrix,perspx,3,0,0,...,1
+plotrix,pie3D,-1,0,0,double[],1
+plotrix,pie3D,0,0,0,double[],1
+plotrix,pie3D,1,0,0,null,1
+plotrix,pie3D,2,0,0,double,1
+plotrix,pie3D,3,0,0,double,1
+plotrix,pie3D,4,0,0,double,1
+plotrix,pie3D,5,0,0,double,1
+plotrix,pie3D,6,0,0,character,1
+plotrix,pie3D,7,0,0,character[],1
+plotrix,pie3D,7,0,1,null,1
+plotrix,pie3D,8,0,0,character[],1
+plotrix,pie3D,8,0,1,null,1
+plotrix,pie3D,9,0,0,double[],1
+plotrix,pie3D,9,0,1,null,1
+plotrix,pie3D,10,0,0,any,1
+plotrix,pie3D,11,0,0,double,1
+plotrix,pie3D,12,0,0,null,1
+plotrix,pie3D,13,0,0,double,1
+plotrix,pie3D,14,0,0,double,1
+plotrix,pie3D,15,0,0,double[],1
+plotrix,pie3D.labels,-1,0,0,list<double>,1
+plotrix,pie3D.labels,0,0,0,double[],1
+plotrix,pie3D.labels,1,0,0,double,1
+plotrix,pie3D.labels,2,0,0,double,1
+plotrix,pie3D.labels,3,0,0,double,1
+plotrix,pie3D.labels,4,0,0,character[],1
+plotrix,pie3D.labels,5,0,0,character,1
+plotrix,pie3D.labels,6,0,0,double,1
+plotrix,pie3D.labels,7,0,0,double,1
+plotrix,pie3D.labels,8,0,0,double,1
+plotrix,pie.labels,-1,0,0,list<logical>,1
+plotrix,pie.labels,0,0,0,double,1
+plotrix,pie.labels,1,0,0,double,1
+plotrix,pie.labels,2,0,0,double[],1
+plotrix,pie.labels,3,0,0,character[],1
+plotrix,pie.labels,4,0,0,double,1
+plotrix,pie.labels,5,0,0,character,1
+plotrix,pie.labels,6,0,0,logical,1
+plotrix,pie.labels,7,0,0,double,1
+plotrix,pie.labels,8,0,0,logical,1
+plotrix,pie.labels,9,0,0,double[],1
+plotrix,pie.labels,10,0,0,...,1
+plotrix,plot_bg,-1,0,0,null,1
+plotrix,plot_bg,0,0,0,character,1
+plotrix,plotCI,-1,0,0,list<class<`matrix`> | class<`by`>>,1
+plotrix,plotCI,-1,0,1,list<double[]>,1
+plotrix,plotCI,0,0,0,class<`matrix`>,1
+plotrix,plotCI,0,0,1,integer[],1
+plotrix,plotCI,1,0,0,class<`by`>,1
+plotrix,plotCI,1,0,1,double[],1
+plotrix,plotCI,2,0,0,class<`by`>,1
+plotrix,plotCI,2,0,1,double[],1
+plotrix,plotCI,3,0,0,class<`by`>,1
+plotrix,plotCI,3,0,1,double[],1
+plotrix,plotCI,4,0,0,null,1
+plotrix,plotCI,5,0,0,null,1
+plotrix,plotCI,6,0,0,character,1
+plotrix,plotCI,7,0,0,double,1
+plotrix,plotCI,8,0,0,double,1
+plotrix,plotCI,9,0,0,character,1
+plotrix,plotCI,10,0,0,logical,1
+plotrix,plotCI,11,0,0,null,1
+plotrix,plotCI,11,0,1,character,1
+plotrix,plotCI,12,0,0,any,1
+plotrix,plotCI,13,0,0,...,1
+plotrix,plot.dendrite,-1,0,0,list<double[]>,1
+plotrix,plot.dendrite,0,0,0,class<`dendrite`>,1
+plotrix,plot.dendrite,1,0,0,character[],1
+plotrix,plot.dendrite,2,0,0,character,1
+plotrix,plot.dendrite,3,0,0,double[],1
+plotrix,plot.dendrite,4,0,0,double,1
+plotrix,plot.dendrite,5,0,0,character[],1
+plotrix,plot.dendrite,6,0,0,...,1
+plotrix,plotH,-1,0,0,class<`matrix`>,1
+plotrix,plotH,-1,0,1,null,1
+plotrix,plotH,0,0,0,character[],1
+plotrix,plotH,0,0,1,class<`formula`>,1
+plotrix,plotH,0,0,2,double[],1
+plotrix,plotH,1,0,0,...,1
+plotrix,plotH.default,-1,0,0,null,1
+plotrix,plotH.default,-1,0,1,class<`matrix`>,1
+plotrix,plotH.default,0,0,0,double[],1
+plotrix,plotH.default,0,0,1,character[],1
+plotrix,plotH.default,1,0,0,double[],1
+plotrix,plotH.default,1,0,1,class<`by`>,1
+plotrix,plotH.default,2,0,0,character,1
+plotrix,plotH.default,3,0,0,character,1
+plotrix,plotH.default,4,0,0,double,1
+plotrix,plotH.default,5,0,0,double[],1
+plotrix,plotH.default,5,0,1,null,1
+plotrix,plotH.default,6,0,0,character,1
+plotrix,plotH.default,7,0,0,...,1
+plotrix,plotH.formula,-1,0,0,null,1
+plotrix,plotH.formula,0,0,0,class<`formula`>,1
+plotrix,plotH.formula,1,0,0,class<`data.frame`>,1
+plotrix,plotH.formula,2,0,0,character,1
+plotrix,plotH.formula,3,0,0,character,1
+plotrix,plotH.formula,4,0,0,...,1
+plotrix,polar.plot,-1,0,0,list<double[] | character>,1
+plotrix,polar.plot,0,0,0,double[],1
+plotrix,polar.plot,1,0,0,double[],1
+plotrix,polar.plot,2,0,0,any,1
+plotrix,polar.plot,3,0,0,null,1
+plotrix,polar.plot,4,0,0,double,1
+plotrix,polar.plot,5,0,0,logical,1
+plotrix,polar.plot,6,0,0,character,1
+plotrix,polar.plot,7,0,0,...,1
+plotrix,polygon.shadow,-1,0,0,null,1
+plotrix,polygon.shadow,0,0,0,double[],1
+plotrix,polygon.shadow,1,0,0,double[],1
+plotrix,polygon.shadow,2,0,0,double[],1
+plotrix,polygon.shadow,2,0,1,null,1
+plotrix,polygon.shadow,3,0,0,double[],1
+plotrix,polygon.shadow,3,0,1,null,1
+plotrix,polygon.shadow,4,0,0,character[],1
+plotrix,print.brklist,-1,0,0,null,1
+plotrix,print.brklist,0,0,0,class<`brklist`>,1
+plotrix,print.brklist,1,0,0,...,1
+plotrix,propbrk,-1,0,0,double,1
+plotrix,propbrk,0,0,0,class<`factor`>,1
+plotrix,propbrk,0,0,1,character[],1
+plotrix,propbrk,1,0,0,character,1
+plotrix,propbrk,2,0,0,logical,1
+plotrix,psegments3d,-1,0,0,null,1
+plotrix,psegments3d,0,0,0,double[],1
+plotrix,psegments3d,1,0,0,double[],1
+plotrix,psegments3d,2,0,0,double[],1
+plotrix,psegments3d,3,0,0,class<`matrix`>,1
+plotrix,psegments3d,4,0,0,...,1
+plotrix,ptext3d,-1,0,0,null,1
+plotrix,ptext3d,0,0,0,double[],1
+plotrix,ptext3d,1,0,0,double[],1
+plotrix,ptext3d,2,0,0,double[],1
+plotrix,ptext3d,3,0,0,character[],1
+plotrix,ptext3d,3,0,1,expression,1
+plotrix,ptext3d,4,0,0,class<`matrix`>,1
+plotrix,ptext3d,5,0,0,...,1
+plotrix,pyramid.plot,-1,0,0,double[],1
+plotrix,pyramid.plot,0,0,0,class<`matrix`>,1
+plotrix,pyramid.plot,0,0,1,double[],1
+plotrix,pyramid.plot,1,0,0,class<`matrix`>,1
+plotrix,pyramid.plot,1,0,1,double[],1
+plotrix,pyramid.plot,2,0,0,character[],1
+plotrix,pyramid.plot,3,0,0,character[],1
+plotrix,pyramid.plot,4,0,0,character,1
+plotrix,pyramid.plot,5,0,0,double[],1
+plotrix,pyramid.plot,5,0,1,null,1
+plotrix,pyramid.plot,6,0,0,double[],1
+plotrix,pyramid.plot,6,0,1,null,1
+plotrix,pyramid.plot,7,0,0,character,1
+plotrix,pyramid.plot,8,0,0,character[],1
+plotrix,pyramid.plot,9,0,0,character[],1
+plotrix,pyramid.plot,10,0,0,double,1
+plotrix,pyramid.plot,11,0,0,double,1
+plotrix,pyramid.plot,12,0,0,double[],1
+plotrix,pyramid.plot,13,0,0,double,1
+plotrix,pyramid.plot,14,0,0,logical,1
+plotrix,pyramid.plot,15,0,0,any,1
+plotrix,radial.grid,-1,0,0,list<logical>,1
+plotrix,radial.grid,0,0,0,character[],1
+plotrix,radial.grid,0,0,1,integer[],1
+plotrix,radial.grid,0,0,2,null,1
+plotrix,radial.grid,1,0,0,double[],1
+plotrix,radial.grid,2,0,0,logical,1
+plotrix,radial.grid,3,0,0,double[],1
+plotrix,radial.grid,4,0,0,double,1
+plotrix,radial.grid,5,0,0,logical,1
+plotrix,radial.grid,6,0,0,double,1
+plotrix,radial.grid,7,0,0,double[],1
+plotrix,radial.grid,8,0,0,character,1
+plotrix,radial.grid,9,0,0,character,1
+plotrix,radial.grid,10,0,0,character,1
+plotrix,radial.grid,11,0,0,logical,1
+plotrix,radial.grid,12,0,0,logical,1
+plotrix,radial.pie,-1,0,0,list<double[] | character>,1
+plotrix,radial.pie,0,0,0,double[],1
+plotrix,radial.pie,0,0,1,list<integer[]>,1
+plotrix,radial.pie,1,0,0,null,1
+plotrix,radial.pie,2,0,0,null,1
+plotrix,radial.pie,3,0,0,any,1
+plotrix,radial.pie,4,0,0,any,1
+plotrix,radial.pie,5,0,0,any,1
+plotrix,radial.pie,6,0,0,double,1
+plotrix,radial.pie,7,0,0,character[],1
+plotrix,radial.pie,7,0,1,integer[],1
+plotrix,radial.pie,8,0,0,null,1
+plotrix,radial.pie,9,0,0,logical,1
+plotrix,radial.pie,10,0,0,double,1
+plotrix,radial.pie,11,0,0,logical,1
+plotrix,radial.pie,12,0,0,double,1
+plotrix,radial.pie,13,0,0,null,1
+plotrix,radial.pie,14,0,0,character,1
+plotrix,radial.pie,15,0,0,character,1
+plotrix,radial.plot,-1,0,0,list<double[] | character>,1
+plotrix,radial.plot,0,0,0,class<`matrix`>,1
+plotrix,radial.plot,0,0,1,double[],1
+plotrix,radial.plot,1,0,0,double[],1
+plotrix,radial.plot,1,0,1,null,1
+plotrix,radial.plot,2,0,0,any,1
+plotrix,radial.plot,3,0,0,double[],1
+plotrix,radial.plot,3,0,1,null,1
+plotrix,radial.plot,4,0,0,logical,1
+plotrix,radial.plot,5,0,0,any,1
+plotrix,radial.plot,6,0,0,logical,1
+plotrix,radial.plot,7,0,0,character,1
+plotrix,radial.plot,8,0,0,double,1
+plotrix,radial.plot,9,0,0,character,1
+plotrix,radial.plot,10,0,0,character,1
+plotrix,radial.plot,11,0,0,character,1
+plotrix,radial.plot,12,0,0,character,1
+plotrix,radial.plot,12,0,1,integer[],1
+plotrix,radial.plot,12,0,2,double,1
+plotrix,radial.plot,13,0,0,character,1
+plotrix,radial.plot,14,0,0,double,1
+plotrix,radial.plot,14,0,1,integer[],1
+plotrix,radial.plot,15,0,0,any,1
+plotrix,radial.plot.labels,-1,0,0,null,1
+plotrix,radial.plot.labels,0,0,0,double[],1
+plotrix,radial.plot.labels,1,0,0,double[],1
+plotrix,radial.plot.labels,2,0,0,character,1
+plotrix,radial.plot.labels,3,0,0,null,1
+plotrix,radial.plot.labels,4,0,0,double,1
+plotrix,radial.plot.labels,5,0,0,logical,1
+plotrix,radial.plot.labels,6,0,0,character[],1
+plotrix,radial.plot.labels,7,0,0,null,1
+plotrix,radial.plot.labels,8,0,0,double,1
+plotrix,radial.plot.labels,8,0,1,null,1
+plotrix,radial.plot.labels,9,0,0,...,1
+plotrix,radialtext,-1,0,0,list<double>,1
+plotrix,radialtext,0,0,0,character,1
+plotrix,radialtext,1,0,0,double[],1
+plotrix,radialtext,2,0,0,double,1
+plotrix,radialtext,2,0,1,null,1
+plotrix,radialtext,3,0,0,double,1
+plotrix,radialtext,4,0,0,null,1
+plotrix,radialtext,4,0,1,double,1
+plotrix,radialtext,5,0,0,double,1
+plotrix,radialtext,6,0,0,double,1
+plotrix,radialtext,6,0,1,null,1
+plotrix,radialtext,7,0,0,double,1
+plotrix,radialtext,8,0,0,double,1
+plotrix,radialtext,9,0,0,logical,1
+plotrix,radialtext,10,0,0,double,1
+plotrix,radialtext,10,0,1,null,1
+plotrix,radialtext,11,0,0,...,1
+plotrix,raw.means.plot,-1,0,0,null,1
+plotrix,raw.means.plot,-1,0,1,list<double[]>,1
+plotrix,raw.means.plot,0,0,0,class<`data.frame`>,1
+plotrix,raw.means.plot,1,0,0,double,1
+plotrix,raw.means.plot,1,0,1,character,1
+plotrix,raw.means.plot,2,0,0,double,1
+plotrix,raw.means.plot,2,0,1,character,1
+plotrix,raw.means.plot,3,0,0,double,1
+plotrix,raw.means.plot,3,0,1,character,1
+plotrix,raw.means.plot,4,0,0,logical,1
+plotrix,raw.means.plot,5,0,0,any,1
+plotrix,raw.means.plot,6,0,0,double,1
+plotrix,raw.means.plot,7,0,0,null,1
+plotrix,raw.means.plot,8,0,0,double,1
+plotrix,raw.means.plot,9,0,0,integer[],1
+plotrix,raw.means.plot,10,0,0,integer[],1
+plotrix,raw.means.plot,11,0,0,character,1
+plotrix,raw.means.plot,12,0,0,null,1
+plotrix,raw.means.plot,13,0,0,character,1
+plotrix,raw.means.plot,14,0,0,character[],1
+plotrix,raw.means.plot,15,0,0,character,1
+plotrix,rectFill,-1,0,0,null,1
+plotrix,rectFill,0,0,0,double[],1
+plotrix,rectFill,1,0,0,double[],1
+plotrix,rectFill,2,0,0,double[],1
+plotrix,rectFill,3,0,0,double[],1
+plotrix,rectFill,4,0,0,character,1
+plotrix,rectFill,5,0,0,character,1
+plotrix,rectFill,5,0,1,integer[],1
+plotrix,rectFill,6,0,0,null,1
+plotrix,rectFill,6,0,1,double[],1
+plotrix,rectFill,7,0,0,null,1
+plotrix,rectFill,7,0,1,double[],1
+plotrix,rectFill,8,0,0,integer[],1
+plotrix,rectFill,8,0,1,character[],1
+plotrix,rectFill,9,0,0,double,1
+plotrix,rectFill,10,0,0,character,1
+plotrix,rectFill,10,0,1,integer[],1
+plotrix,rectFill,11,0,0,...,1
+plotrix,remove.args,-1,0,0,list<double>,1
+plotrix,remove.args,0,0,0,list<double>,1
+plotrix,remove.args,1,0,0,class<`function`>,1
+plotrix,rescale,-1,0,0,class<`matrix`>,1
+plotrix,rescale,-1,0,1,double[],1
+plotrix,rescale,0,0,0,class<`matrix`>,1
+plotrix,rescale,0,0,1,double[],1
+plotrix,rescale,1,0,0,double[],1
+plotrix,revaxis,-1,0,0,null,1
+plotrix,revaxis,0,0,0,double[],1
+plotrix,revaxis,1,0,0,double[],1
+plotrix,revaxis,2,0,0,logical,1
+plotrix,revaxis,3,0,0,logical,1
+plotrix,revaxis,4,0,0,double,1
+plotrix,revaxis,5,0,0,double,1
+plotrix,revaxis,6,0,0,null,1
+plotrix,revaxis,7,0,0,null,1
+plotrix,revaxis,8,0,0,null,1
+plotrix,revaxis,9,0,0,...,1
+plotrix,ruginv,-1,0,0,double[],1
+plotrix,ruginv,0,0,0,double[],1
+plotrix,ruginv,1,0,0,double,1
+plotrix,ruginv,2,0,0,double,1
+plotrix,ruginv,3,0,0,double,1
+plotrix,ruginv,4,0,0,character,1
+plotrix,ruginv,5,0,0,character,1
+plotrix,ruginv,6,0,0,logical,1
+plotrix,ruginv,7,0,0,...,1
+plotrix,seats,-1,0,0,class<`data.frame`>,1
+plotrix,seats,0,0,0,double,1
+plotrix,seats,1,0,0,double,1
+plotrix,seats,2,0,0,double,1
+plotrix,size_n_color,-1,0,0,list<double[]>,1
+plotrix,size_n_color,0,0,0,class<`matrix`>,1
+plotrix,size_n_color,0,0,1,double[],1
+plotrix,size_n_color,1,0,0,class<`matrix`>,1
+plotrix,size_n_color,1,0,1,double[],1
+plotrix,size_n_color,2,0,0,class<`matrix`>,1
+plotrix,size_n_color,2,0,1,double[],1
+plotrix,size_n_color,3,0,0,character,1
+plotrix,size_n_color,3,0,1,null,1
+plotrix,size_n_color,4,0,0,class<`matrix`>,1
+plotrix,size_n_color,4,0,1,character[],1
+plotrix,size_n_color,5,0,0,character,1
+plotrix,size_n_color,6,0,0,null,1
+plotrix,size_n_color,6,0,1,double[],1
+plotrix,size_n_color,7,0,0,character,1
+plotrix,size_n_color,8,0,0,double[],1
+plotrix,size_n_color,9,0,0,integer[],1
+plotrix,size_n_color,9,0,1,null,1
+plotrix,size_n_color,10,0,0,double,1
+plotrix,size_n_color,11,0,0,double,1
+plotrix,size_n_color,12,0,0,logical,1
+plotrix,size_n_color,13,0,0,double[],1
+plotrix,size_n_color,13,0,1,null,1
+plotrix,size_n_color,14,0,0,character,1
+plotrix,size_n_color,15,0,0,null,1
+plotrix,size_n_color,15,0,1,double[],1
+plotrix,sizeplot,-1,0,0,null,1
+plotrix,sizeplot,0,0,0,double[],1
+plotrix,sizeplot,1,0,0,double[],1
+plotrix,sizeplot,2,0,0,double,1
+plotrix,sizeplot,3,0,0,double,1
+plotrix,sizeplot,4,0,0,logical,1
+plotrix,sizeplot,5,0,0,any,1
+plotrix,sizeplot,6,0,0,logical,1
+plotrix,sizeplot,7,0,0,...,1
+plotrix,sizetree,-1,0,0,null,1
+plotrix,sizetree,-1,0,1,list<double[]>,1
+plotrix,sizetree,0,0,0,class<`data.frame`>,1
+plotrix,sizetree,1,0,0,double,1
+plotrix,sizetree,2,0,0,any,1
+plotrix,sizetree,3,0,0,double,1
+plotrix,sizetree,4,0,0,any,1
+plotrix,sizetree,5,0,0,any,1
+plotrix,sizetree,6,0,0,logical,1
+plotrix,sizetree,7,0,0,logical,1
+plotrix,sizetree,8,0,0,logical,1
+plotrix,sizetree,9,0,0,list<character[]>,1
+plotrix,sizetree,9,0,1,null,1
+plotrix,sizetree,10,0,0,any,1
+plotrix,sizetree,11,0,0,null,1
+plotrix,sizetree,11,0,1,character[],1
+plotrix,sizetree,12,0,0,any,1
+plotrix,sizetree,13,0,0,...,1
+plotrix,sliceArray,-1,0,0,class<`matrix`>,1
+plotrix,sliceArray,0,0,0,class<`array`>,1
+plotrix,sliceArray,1,0,0,double,1
+plotrix,smoothColors,-1,0,0,character[],1
+plotrix,smoothColors,0,0,0,...,1
+plotrix,smoothColors,1,0,0,null,1
+plotrix,soil.texture,-1,0,0,null,1
+plotrix,soil.texture,-1,0,1,list<double[]>,1
+plotrix,soil.texture,0,0,0,null,1
+plotrix,soil.texture,0,0,1,class<`data.frame`>,1
+plotrix,soil.texture,1,0,0,character,1
+plotrix,soil.texture,2,0,0,double[],1
+plotrix,soil.texture,3,0,0,character[],1
+plotrix,soil.texture,4,0,0,list<double[]>,1
+plotrix,soil.texture,5,0,0,logical,1
+plotrix,soil.texture,6,0,0,logical,1
+plotrix,soil.texture,7,0,0,character,1
+plotrix,soil.texture,8,0,0,any,1
+plotrix,soil.texture,9,0,0,logical,1
+plotrix,soil.texture,10,0,0,character,1
+plotrix,soil.texture,11,0,0,character,1
+plotrix,soil.texture,12,0,0,character,1
+plotrix,soil.texture,13,0,0,double,1
+plotrix,soil.texture,14,0,0,logical,1
+plotrix,soil.texture,15,0,0,logical,1
+plotrix,soil.texture.uk,-1,0,0,list<double[]>,1
+plotrix,soil.texture.uk,0,0,0,class<`data.frame`>,1
+plotrix,soil.texture.uk,1,0,0,character,1
+plotrix,soil.texture.uk,2,0,0,double[],1
+plotrix,soil.texture.uk,3,0,0,character[],1
+plotrix,soil.texture.uk,4,0,0,list<double[]>,1
+plotrix,soil.texture.uk,5,0,0,logical,1
+plotrix,soil.texture.uk,6,0,0,logical,1
+plotrix,soil.texture.uk,7,0,0,character,1
+plotrix,soil.texture.uk,8,0,0,any,1
+plotrix,soil.texture.uk,9,0,0,logical,1
+plotrix,soil.texture.uk,10,0,0,character,1
+plotrix,soil.texture.uk,11,0,0,character,1
+plotrix,soil.texture.uk,12,0,0,character,1
+plotrix,soil.texture.uk,13,0,0,double,1
+plotrix,soil.texture.uk,14,0,0,logical,1
+plotrix,soil.texture.uk,15,0,0,logical,1
+plotrix,spread.labels,-1,0,0,null,1
+plotrix,spread.labels,0,0,0,double[],1
+plotrix,spread.labels,1,0,0,double[],1
+plotrix,spread.labels,2,0,0,character[],1
+plotrix,spread.labels,2,0,1,class<`factor`>,1
+plotrix,spread.labels,3,0,0,null,1
+plotrix,spread.labels,4,0,0,null,1
+plotrix,spread.labels,5,0,0,logical,1
+plotrix,spread.labels,6,0,0,any,1
+plotrix,spread.labels,7,0,0,double,1
+plotrix,spread.labels,8,0,0,...,1
+plotrix,spreadout,-1,0,0,^double[],1
+plotrix,spreadout,0,0,0,^double[],1
+plotrix,spreadout,1,0,0,double,1
+plotrix,stackpoly,-1,0,0,null,1
+plotrix,stackpoly,0,0,0,class<`matrix`>,1
+plotrix,stackpoly,0,0,1,double[],1
+plotrix,stackpoly,1,0,0,null,1
+plotrix,stackpoly,2,0,0,character,1
+plotrix,stackpoly,3,0,0,character,1
+plotrix,stackpoly,4,0,0,character,1
+plotrix,stackpoly,5,0,0,null,1
+plotrix,stackpoly,5,0,1,double[],1
+plotrix,stackpoly,6,0,0,character[],1
+plotrix,stackpoly,6,0,1,null,1
+plotrix,stackpoly,7,0,0,null,1
+plotrix,stackpoly,8,0,0,null,1
+plotrix,stackpoly,8,0,1,double[],1
+plotrix,stackpoly,9,0,0,double,1
+plotrix,stackpoly,10,0,0,double,1
+plotrix,stackpoly,11,0,0,character,1
+plotrix,stackpoly,11,0,1,null,1
+plotrix,stackpoly,12,0,0,null,1
+plotrix,stackpoly,12,0,1,character,1
+plotrix,stackpoly,13,0,0,logical,1
+plotrix,stackpoly,14,0,0,logical,1
+plotrix,stackpoly,15,0,0,logical,1
+plotrix,staircase.plot,-1,0,0,list<character>,1
+plotrix,staircase.plot,0,0,0,double[],1
+plotrix,staircase.plot,1,0,0,logical[],1
+plotrix,staircase.plot,2,0,0,character[],1
+plotrix,staircase.plot,3,0,0,double,1
+plotrix,staircase.plot,4,0,0,character,1
+plotrix,staircase.plot,5,0,0,null,1
+plotrix,staircase.plot,6,0,0,character,1
+plotrix,staircase.plot,7,0,0,integer[],1
+plotrix,staircase.plot,8,0,0,character,1
+plotrix,staircase.plot,9,0,0,character,1
+plotrix,staircase.plot,10,0,0,double,1
+plotrix,staircase.plot,11,0,0,logical,1
+plotrix,staircase.plot,12,0,0,logical,1
+plotrix,staircase.plot,13,0,0,double,1
+plotrix,staircase.plot,14,0,0,character,1
+plotrix,staircase.plot,15,0,0,character,1
+plotrix,staircasePlot,-1,0,0,list<character>,1
+plotrix,staircasePlot,0,0,0,double[],1
+plotrix,staircasePlot,1,0,0,logical[],1
+plotrix,staircasePlot,2,0,0,character[],1
+plotrix,staircasePlot,3,0,0,double,1
+plotrix,staircasePlot,4,0,0,character,1
+plotrix,staircasePlot,5,0,0,null,1
+plotrix,staircasePlot,6,0,0,list<character | integer[]>,1
+plotrix,staircasePlot,6,0,1,list<character | null>,1
+plotrix,staircasePlot,7,0,0,character,1
+plotrix,staircasePlot,8,0,0,character,1
+plotrix,staircasePlot,9,0,0,double,1
+plotrix,staircasePlot,10,0,0,logical,1
+plotrix,staircasePlot,11,0,0,logical,1
+plotrix,staircasePlot,12,0,0,double,1
+plotrix,staircasePlot,13,0,0,character,1
+plotrix,staircasePlot,14,0,0,character,1
+plotrix,staircasePlot,15,0,0,...,1
+plotrix,starPie,-1,0,0,null,1
+plotrix,starPie,0,0,0,integer[],1
+plotrix,starPie,1,0,0,double[],1
+plotrix,starPie,2,0,0,double,1
+plotrix,starPie,3,0,0,class<`matrix`>,1
+plotrix,starPie,4,0,0,null,1
+plotrix,starPie,5,0,0,any,1
+plotrix,starPie,6,0,0,null,1
+plotrix,starPie,7,0,0,logical,1
+plotrix,starPie,8,0,0,character[],1
+plotrix,starPie,9,0,0,double,1
+plotrix,staxlab,-1,0,0,null,1
+plotrix,staxlab,-1,0,1,list<logical>,1
+plotrix,staxlab,0,0,0,double,1
+plotrix,staxlab,1,0,0,double[],1
+plotrix,staxlab,2,0,0,character[],1
+plotrix,staxlab,2,0,1,double[],1
+plotrix,staxlab,3,0,0,double,1
+plotrix,staxlab,4,0,0,double,1
+plotrix,staxlab,5,0,0,double,1
+plotrix,staxlab,6,0,0,null,1
+plotrix,staxlab,6,0,1,double,1
+plotrix,staxlab,7,0,0,double,1
+plotrix,staxlab,8,0,0,double,1
+plotrix,staxlab,9,0,0,...,1
+plotrix,std.error,-1,0,0,double,1
+plotrix,std.error,0,0,0,double[],1
+plotrix,std.error,1,0,0,logical,1
+plotrix,sumbrk,-1,0,0,integer,1
+plotrix,sumbrk,0,0,0,character[],1
+plotrix,sumbrk,1,0,0,character,1
+plotrix,sumbrk,2,0,0,logical,1
+plotrix,sumDendrite,-1,0,0,double,1
+plotrix,sumDendrite,0,0,0,class<`dendrite`>,1
+plotrix,symbolbarplot,-1,0,0,double[],1
+plotrix,symbolbarplot,0,0,0,class<`matrix`>,1
+plotrix,symbolbarplot,1,0,0,double,1
+plotrix,symbolbarplot,2,0,0,null,1
+plotrix,symbolbarplot,3,0,0,null,1
+plotrix,symbolbarplot,4,0,0,null,1
+plotrix,symbolbarplot,5,0,0,logical,1
+plotrix,symbolbarplot,6,0,0,logical,1
+plotrix,symbolbarplot,7,0,0,character[],1
+plotrix,symbolbarplot,8,0,0,any,1
+plotrix,symbolbarplot,9,0,0,null,1
+plotrix,symbolbarplot,10,0,0,null,1
+plotrix,symbolbarplot,11,0,0,null,1
+plotrix,symbolbarplot,12,0,0,null,1
+plotrix,symbolbarplot,13,0,0,null,1
+plotrix,symbolbarplot,14,0,0,null,1
+plotrix,symbolbarplot,15,0,0,logical,1
+plotrix,symbolbox,-1,0,0,null,1
+plotrix,symbolbox,0,0,0,double,1
+plotrix,symbolbox,1,0,0,double,1
+plotrix,symbolbox,2,0,0,double,1
+plotrix,symbolbox,3,0,0,double,1
+plotrix,symbolbox,4,0,0,double,1
+plotrix,symbolbox,5,0,0,double,1
+plotrix,symbolbox,6,0,0,character,1
+plotrix,symbolbox,7,0,0,character,1
+plotrix,symbolbox,8,0,0,logical,1
+plotrix,symbolbox,9,0,0,logical,1
+plotrix,symbolbox,10,0,0,...,1
+plotrix,tab.title,-1,0,0,list<double>,1
+plotrix,tab.title,0,0,0,character,1
+plotrix,tab.title,1,0,0,character,1
+plotrix,tab.title,2,0,0,character,1
+plotrix,tab.title,3,0,0,character,1
+plotrix,tab.title,4,0,0,double,1
+plotrix,tab.title,5,0,0,double,1
+plotrix,tab.title,6,0,0,double,1
+plotrix,tab.title,7,0,0,double,1
+plotrix,taylor.diagram,-1,0,0,list<double[] | character>,1
+plotrix,taylor.diagram,0,0,0,double[],1
+plotrix,taylor.diagram,1,0,0,double[],1
+plotrix,taylor.diagram,2,0,0,logical,1
+plotrix,taylor.diagram,3,0,0,character,1
+plotrix,taylor.diagram,4,0,0,double,1
+plotrix,taylor.diagram,5,0,0,logical,1
+plotrix,taylor.diagram,6,0,0,character,1
+plotrix,taylor.diagram,7,0,0,character,1
+plotrix,taylor.diagram,8,0,0,character,1
+plotrix,taylor.diagram,9,0,0,logical,1
+plotrix,taylor.diagram,10,0,0,double,1
+plotrix,taylor.diagram,11,0,0,double,1
+plotrix,taylor.diagram,12,0,0,double,1
+plotrix,taylor.diagram,13,0,0,logical,1
+plotrix,taylor.diagram,14,0,0,character,1
+plotrix,taylor.diagram,15,0,0,any,1
+plotrix,textbox,-1,0,0,double[],1
+plotrix,textbox,0,0,0,double[],1
+plotrix,textbox,1,0,0,double,1
+plotrix,textbox,2,0,0,character[],1
+plotrix,textbox,3,0,0,character[],1
+plotrix,textbox,4,0,0,double,1
+plotrix,textbox,5,0,0,double,1
+plotrix,textbox,6,0,0,logical,1
+plotrix,textbox,7,0,0,double[],1
+plotrix,textbox,8,0,0,null,1
+plotrix,textbox,8,0,1,double,1
+plotrix,textbox,9,0,0,null,1
+plotrix,textbox,10,0,0,character,1
+plotrix,textbox,10,0,1,null,1
+plotrix,textbox,11,0,0,character,1
+plotrix,textbox,11,0,1,null,1
+plotrix,textbox,12,0,0,character,1
+plotrix,textbox,12,0,1,null,1
+plotrix,textbox,13,0,0,double,1
+plotrix,textbox,13,0,1,null,1
+plotrix,textbox,14,0,0,double,1
+plotrix,textbox,15,0,0,character,1
+plotrix,textbox,15,0,1,double,1
+plotrix,thigmophobe,-1,0,0,integer[],1
+plotrix,thigmophobe,0,0,0,double[],1
+plotrix,thigmophobe,1,0,0,double[],1
+plotrix,thigmophobe,2,0,0,integer[],1
+plotrix,thigmophobe,3,0,0,logical,1
+plotrix,thigmophobe,4,0,0,logical,1
+plotrix,thigmophobe,5,0,0,double[],1
+plotrix,thigmophobe,6,0,0,double[],1
+plotrix,thigmophobe,7,0,0,double,1
+plotrix,thigmophobe,8,0,0,double,1
+plotrix,thigmophobe.labels,-1,0,0,list<logical>,1
+plotrix,thigmophobe.labels,0,0,0,double[],1
+plotrix,thigmophobe.labels,1,0,0,double[],1
+plotrix,thigmophobe.labels,2,0,0,character[],1
+plotrix,thigmophobe.labels,3,0,0,null,1
+plotrix,thigmophobe.labels,4,0,0,...,1
+plotrix,triax.abline,-1,0,0,null,1
+plotrix,triax.abline,0,0,0,double,1
+plotrix,triax.abline,0,0,1,null,1
+plotrix,triax.abline,1,0,0,null,1
+plotrix,triax.abline,1,0,1,double,1
+plotrix,triax.abline,2,0,0,null,1
+plotrix,triax.abline,2,0,1,double,1
+plotrix,triax.abline,3,0,0,character,1
+plotrix,triax.abline,4,0,0,character,1
+plotrix,triax.abline,5,0,0,logical,1
+plotrix,triax.fill,-1,0,0,null,1
+plotrix,triax.fill,0,0,0,list<double[]>,1
+plotrix,triax.frame,-1,0,0,null,1
+plotrix,triax.frame,0,0,0,double[],1
+plotrix,triax.frame,1,0,0,character[],1
+plotrix,triax.frame,1,0,1,null,1
+plotrix,triax.frame,2,0,0,null,1
+plotrix,triax.frame,2,0,1,list<double[]>,1
+plotrix,triax.frame,3,0,0,character,1
+plotrix,triax.frame,4,0,0,double,1
+plotrix,triax.frame,5,0,0,double,1
+plotrix,triax.frame,6,0,0,logical,1
+plotrix,triax.frame,7,0,0,logical,1
+plotrix,triax.frame,8,0,0,any,1
+plotrix,triax.frame,9,0,0,any,1
+plotrix,triax.frame,10,0,0,logical,1
+plotrix,triax.plot,-1,0,0,list<null | list<character | double[]>>,1
+plotrix,triax.plot,-1,0,1,list<list<double[] | character | double[]>>,1
+plotrix,triax.plot,-1,0,2,list<list<double | character | double[]>>,1
+plotrix,triax.plot,0,0,0,null,1
+plotrix,triax.plot,0,0,1,class<`data.frame`>,1
+plotrix,triax.plot,1,0,0,character,1
+plotrix,triax.plot,2,0,0,double[],1
+plotrix,triax.plot,3,0,0,character[],1
+plotrix,triax.plot,3,0,1,null,1
+plotrix,triax.plot,4,0,0,list<double[]>,1
+plotrix,triax.plot,4,0,1,null,1
+plotrix,triax.plot,5,0,0,character,1
+plotrix,triax.plot,6,0,0,double,1
+plotrix,triax.plot,7,0,0,double,1
+plotrix,triax.plot,8,0,0,logical,1
+plotrix,triax.plot,9,0,0,logical,1
+plotrix,triax.plot,10,0,0,any,1
+plotrix,triax.plot,11,0,0,any,1
+plotrix,triax.plot,12,0,0,logical,1
+plotrix,triax.plot,13,0,0,logical,1
+plotrix,triax.plot,14,0,0,logical,1
+plotrix,triax.plot,15,0,0,null,1
+plotrix,triax.points,-1,0,0,list<double[]>,1
+plotrix,triax.points,0,0,0,class<`data.frame`>,1
+plotrix,triax.points,1,0,0,logical,1
+plotrix,triax.points,2,0,0,logical,1
+plotrix,triax.points,3,0,0,null,1
+plotrix,triax.points,4,0,0,character,1
+plotrix,triax.points,4,0,1,double[],1
+plotrix,triax.points,5,0,0,double,1
+plotrix,triax.points,6,0,0,character,1
+plotrix,triax.points,7,0,0,logical,1
+plotrix,triax.points,8,0,0,...,1
+plotrix,tsxpos,-1,0,0,double[],1
+plotrix,tsxpos,0,0,0,class<`ts`>,1
+plotrix,tsxpos,1,0,0,any,1
+plotrix,tsxpos,2,0,0,any,1
+plotrix,twoord.plot,-1,0,0,list<double[] | character>,1
+plotrix,twoord.plot,0,0,0,double[],1
+plotrix,twoord.plot,1,0,0,double[],1
+plotrix,twoord.plot,2,0,0,double[],1
+plotrix,twoord.plot,3,0,0,double[],1
+plotrix,twoord.plot,4,0,0,null,1
+plotrix,twoord.plot,5,0,0,character,1
+plotrix,twoord.plot,6,0,0,null,1
+plotrix,twoord.plot,7,0,0,double[],1
+plotrix,twoord.plot,7,0,1,null,1
+plotrix,twoord.plot,8,0,0,double[],1
+plotrix,twoord.plot,8,0,1,null,1
+plotrix,twoord.plot,9,0,0,double[],1
+plotrix,twoord.plot,10,0,0,double,1
+plotrix,twoord.plot,11,0,0,double,1
+plotrix,twoord.plot,12,0,0,character,1
+plotrix,twoord.plot,13,0,0,null,1
+plotrix,twoord.plot,13,0,1,integer[],1
+plotrix,twoord.plot,14,0,0,character,1
+plotrix,twoord.plot,15,0,0,null,1
+plotrix,twoord.plot,15,0,1,double,1
+plotrix,twoord.stackplot,-1,0,0,null,1
+plotrix,twoord.stackplot,-1,0,1,list<double[]>,1
+plotrix,twoord.stackplot,0,0,0,integer[],1
+plotrix,twoord.stackplot,1,0,0,integer[],1
+plotrix,twoord.stackplot,2,0,0,class<`matrix`>,1
+plotrix,twoord.stackplot,3,0,0,class<`matrix`>,1
+plotrix,twoord.stackplot,4,0,0,character[],1
+plotrix,twoord.stackplot,5,0,0,character[],1
+plotrix,twoord.stackplot,6,0,0,character[],1
+plotrix,twoord.stackplot,7,0,0,character[],1
+plotrix,twoord.stackplot,8,0,0,character,1
+plotrix,twoord.stackplot,9,0,0,character,1
+plotrix,twoord.stackplot,10,0,0,character,1
+plotrix,twoord.stackplot,11,0,0,character,1
+plotrix,twoord.stackplot,12,0,0,...,1
+plotrix,twoord.stackplot,13,0,0,double,1
+plotrix,twoord.stackplot,13,0,1,null,1
+plotrix,twoord.stackplot,14,0,0,double,1
+plotrix,twoord.stackplot,15,0,0,logical,1
+plotrix,valid.n,-1,0,0,integer,1
+plotrix,valid.n,0,0,0,class<`factor`>,1
+plotrix,valid.n,0,0,1,double[],1
+plotrix,valid.n,0,0,2,^integer[],1
+plotrix,valid.n,0,0,3,character[],1
+plotrix,valid.n,1,0,0,logical,1
+plotrix,vectorField,-1,0,0,null,1
+plotrix,vectorField,0,0,0,class<`matrix`>,1
+plotrix,vectorField,0,0,1,double[],1
+plotrix,vectorField,1,0,0,class<`matrix`>,1
+plotrix,vectorField,1,0,1,double[],1
+plotrix,vectorField,2,0,0,null,1
+plotrix,vectorField,2,0,1,integer[],1
+plotrix,vectorField,3,0,0,null,1
+plotrix,vectorField,3,0,1,integer[],1
+plotrix,vectorField,4,0,0,double,1
+plotrix,vectorField,5,0,0,double,1
+plotrix,vectorField,6,0,0,character,1
+plotrix,vectorField,7,0,0,character[],1
+plotrix,violin_plot,-1,0,0,null,1
+plotrix,violin_plot,0,0,0,class<`data.frame`>,1
+plotrix,violin_plot,0,0,1,class<`matrix`>,1
+plotrix,violin_plot,0,0,2,double[],1
+plotrix,violin_plot,1,0,0,any,1
+plotrix,violin_plot,2,0,0,logical,1
+plotrix,violin_plot,3,0,0,logical,1
+plotrix,violin_plot,4,0,0,any,1
+plotrix,violin_plot,5,0,0,any,1
+plotrix,violin_plot,6,0,0,double,1
+plotrix,violin_plot,7,0,0,logical,1
+plotrix,violin_plot,8,0,0,logical,1
+plotrix,violin_plot,9,0,0,double,1
+plotrix,violin_plot,10,0,0,character,1
+plotrix,violin_plot,11,0,0,logical,1
+plotrix,violin_plot,12,0,0,null,1
+plotrix,violin_plot,13,0,0,double,1
+plotrix,violin_plot,14,0,0,any,1
+plotrix,violin_plot,15,0,0,any,1
+plotrix,weighted.hist,-1,0,0,list<double[] | class<`matrix`> | character>,1
+plotrix,weighted.hist,0,0,0,integer[],1
+plotrix,weighted.hist,1,0,0,double[],1
+plotrix,weighted.hist,2,0,0,integer[],1
+plotrix,weighted.hist,3,0,0,null,1
+plotrix,weighted.hist,4,0,0,logical,1
+plotrix,weighted.hist,5,0,0,logical,1
+plotrix,weighted.hist,6,0,0,null,1
+plotrix,weighted.hist,7,0,0,null,1
+plotrix,weighted.hist,8,0,0,logical,1
+plotrix,weighted.hist,9,0,0,...,1
+plotrix,zoomInPlot,-1,0,0,list<null | integer[]>,1
+plotrix,zoomInPlot,0,0,0,double[],1
+plotrix,zoomInPlot,1,0,0,double[],1
+plotrix,zoomInPlot,2,0,0,null,1
+plotrix,zoomInPlot,3,0,0,null,1
+plotrix,zoomInPlot,4,0,0,double[],1
+plotrix,zoomInPlot,5,0,0,double[],1
+plotrix,zoomInPlot,6,0,0,null,1
+plotrix,zoomInPlot,7,0,0,character,1
+plotrix,zoomInPlot,8,0,0,double,1
+plotrix,zoomInPlot,9,0,0,...,1
+pls,cancorr,-1,0,0,list<class<`matrix`> | double>,1
+pls,cancorr,0,0,0,class<`matrix`>,1
+pls,cancorr,1,0,0,class<`AsIs`>,1
+pls,cancorr,1,0,1,class<`matrix`>,1
+pls,cancorr,2,0,0,null,1
+pls,cancorr,3,0,0,logical,1
+pls,coef.mvr,-1,0,0,class<`array`>,1
+pls,coef.mvr,0,0,0,class<`mvr`>,1
+pls,coef.mvr,1,0,0,any,1
+pls,coef.mvr,2,0,0,any,1
+pls,coef.mvr,3,0,0,logical,1
+pls,coef.mvr,4,0,0,...,1
+pls,compnames,-1,0,0,character[],1
+pls,compnames,0,0,0,class<`mvr`>,1
+pls,compnames,1,0,0,any,1
+pls,compnames,2,0,0,logical,1
+pls,compnames,3,0,0,...,1
+pls,cppls,-1,0,0,class<`mvr`>,1
+pls,cppls,0,0,0,...,1
+pls,cppls,1,0,0,any,1
+pls,cppls,2,0,0,any,1
+pls,cppls,3,0,0,character,1
+pls,crossval,-1,0,0,class<`mvr`>,1
+pls,crossval,0,0,0,class<`mvr`>,1
+pls,crossval,1,0,0,double,1
+pls,crossval,2,0,0,character[],1
+pls,crossval,3,0,0,any,1
+pls,crossval,4,0,0,logical,1
+pls,crossval,5,0,0,double,1
+pls,crossval,6,0,0,...,1
+pls,cvsegments,-1,0,0,list<double[]>,1
+pls,cvsegments,0,0,0,double,1
+pls,cvsegments,1,0,0,any,1
+pls,cvsegments,2,0,0,double,1
+pls,cvsegments,3,0,0,double,1
+pls,cvsegments,4,0,0,character[],1
+pls,delete.intercept,-1,0,0,class<`matrix`>,1
+pls,delete.intercept,0,0,0,class<`matrix`>,1
+pls,explvar,-1,0,0,double[],1
+pls,explvar,0,0,0,class<`mvr`>,1
+pls,explvar,0,0,1,class<`scores`>,1
+pls,fitted.mvr,-1,0,0,class<`array`>,1
+pls,fitted.mvr,0,0,0,class<`mvr`>,1
+pls,fitted.mvr,1,0,0,...,1
+pls,jack.test,-1,0,0,class<`jacktest`>,1
+pls,jack.test,0,0,0,class<`mvr`>,1
+pls,jack.test,1,0,0,double,1
+pls,jack.test,2,0,0,logical,1
+pls,lapplyFunc,-1,0,0,list<list<any>>,1
+pls,lapplyFunc,0,0,0,null,1
+pls,lapplyFunc,1,0,0,integer[],1
+pls,lapplyFunc,2,0,0,class<`function`>,1
+pls,lapplyFunc,3,0,0,any,1
+pls,loadingplot.default,-1,0,0,null,1
+pls,loadingplot.default,0,0,0,class<`mvr`>,1
+pls,loadingplot.default,1,0,0,integer[],1
+pls,loadingplot.default,2,0,0,logical,1
+pls,loadingplot.default,3,0,0,character,1
+pls,loadingplot.default,4,0,0,logical,1
+pls,loadingplot.default,5,0,0,any,1
+pls,loadingplot.default,6,0,0,any,1
+pls,loadingplot.default,7,0,0,null,1
+pls,loadingplot.default,8,0,0,any,1
+pls,loadingplot.default,9,0,0,null,1
+pls,loadingplot.default,10,0,0,any,1
+pls,loadingplot.default,11,0,0,character,1
+pls,loadingplot.default,12,0,0,character,1
+pls,loadingplot.default,13,0,0,any,1
+pls,loadingplot.default,14,0,0,logical,1
+pls,loadingplot.default,15,0,0,any,1
+pls,loadings,-1,0,0,class<`loadings`>,1
+pls,loadings,0,0,0,class<`mvr`>,1
+pls,loadings,1,0,0,...,1
+pls,loadings.default,-1,0,0,class<`loadings`>,1
+pls,loadings.default,0,0,0,class<`mvr`>,1
+pls,loadings.default,1,0,0,...,1
+pls,makepredictcall.msc,-1,0,0,class<`call`>,1
+pls,makepredictcall.msc,0,0,0,"class<`matrix`, `msc`>",1
+pls,makepredictcall.msc,1,0,0,class<`call`>,1
+pls,makepredictcall.stdized,-1,0,0,class<`call`>,1
+pls,makepredictcall.stdized,0,0,0,"class<`matrix`, `stdized`>",1
+pls,makepredictcall.stdized,1,0,0,class<`call`>,1
+pls,model.frame.mvr,-1,0,0,class<`data.frame`>,1
+pls,model.frame.mvr,0,0,0,class<`mvr`>,1
+pls,model.frame.mvr,1,0,0,...,1
+pls,model.matrix.mvr,-1,0,0,class<`matrix`>,1
+pls,model.matrix.mvr,0,0,0,class<`mvr`>,1
+pls,model.matrix.mvr,1,0,0,...,1
+pls,msc,-1,0,0,"class<`matrix`, `msc`>",1
+pls,msc,0,0,0,class<`AsIs`>,1
+pls,msc,0,0,1,class<`matrix`>,1
+pls,msc,1,0,0,double[],1
+pls,msc,1,0,1,null,1
+pls,MSEP,-1,0,0,class<`mvrVal`>,1
+pls,MSEP,0,0,0,class<`mvr`>,1
+pls,MSEP,1,0,0,...,1
+pls,MSEP.mvr,-1,0,0,class<`mvrVal`>,1
+pls,MSEP.mvr,0,0,0,class<`mvr`>,1
+pls,MSEP.mvr,1,0,0,any,1
+pls,MSEP.mvr,2,0,0,any,1
+pls,MSEP.mvr,3,0,0,any,1
+pls,MSEP.mvr,4,0,0,any,1
+pls,MSEP.mvr,5,0,0,any,1
+pls,MSEP.mvr,6,0,0,logical,1
+pls,MSEP.mvr,7,0,0,...,1
+pls,mvr,-1,0,0,class<`mvr`>,1
+pls,mvr,0,0,0,any,1
+pls,mvr,1,0,0,double,1
+pls,mvr,2,0,0,any,1
+pls,mvr,3,0,0,any,1
+pls,mvr,4,0,0,any,1
+pls,mvr,5,0,0,any,1
+pls,mvr,6,0,0,character,1
+pls,mvr,7,0,0,logical,1
+pls,mvr,8,0,0,logical,1
+pls,mvr,9,0,0,character[],1
+pls,mvr,10,0,0,logical,1
+pls,mvr,11,0,0,logical,1
+pls,mvr,12,0,0,logical,1
+pls,mvr,13,0,0,...,1
+pls,mvrCv,-1,0,0,list<any>,1
+pls,mvrCv,0,0,0,class<`matrix`>,1
+pls,mvrCv,1,0,0,class<`AsIs`>,1
+pls,mvrCv,1,0,1,class<`matrix`>,1
+pls,mvrCv,2,0,0,double,1
+pls,mvrCv,3,0,0,null,1
+pls,mvrCv,4,0,0,null,1
+pls,mvrCv,5,0,0,character,1
+pls,mvrCv,6,0,0,logical,1
+pls,mvrCv,7,0,0,list<integer>,1
+pls,mvrCv,7,0,1,double,1
+pls,mvrCv,8,0,0,any,1
+pls,mvrCv,9,0,0,any,1
+pls,mvrCv,10,0,0,logical,1
+pls,mvrCv,11,0,0,logical,1
+pls,mvrCv,12,0,0,...,1
+pls,mvrValstats,-1,0,0,list<any>,1
+pls,mvrValstats,0,0,0,class<`mvr`>,1
+pls,mvrValstats,1,0,0,character[],1
+pls,mvrValstats,2,0,0,any,1
+pls,mvrValstats,3,0,0,integer[],1
+pls,mvrValstats,4,0,0,any,1
+pls,mvrValstats,5,0,0,logical,1
+pls,mvrValstats,6,0,0,logical,1
+pls,mvrValstats,7,0,0,...,1
+pls,norm,-1,0,0,double,1
+pls,norm,0,0,0,class<`matrix`>,1
+pls,pcr,-1,0,0,class<`mvr`>,1
+pls,pcr,0,0,0,...,1
+pls,pcr,1,0,0,character,1
+pls,plot.mvr,-1,0,0,class<`matrix`>,1
+pls,plot.mvr,-1,0,1,null,1
+pls,plot.mvr,0,0,0,class<`mvr`>,1
+pls,plot.mvr,1,0,0,character[],1
+pls,plot.mvr,2,0,0,...,1
+pls,plot.mvrVal,-1,0,0,null,1
+pls,plot.mvrVal,0,0,0,class<`mvrVal`>,1
+pls,plot.mvrVal,1,0,0,any,1
+pls,plot.mvrVal,2,0,0,any,1
+pls,plot.mvrVal,3,0,0,character,1
+pls,plot.mvrVal,4,0,0,integer[],1
+pls,plot.mvrVal,5,0,0,double,1
+pls,plot.mvrVal,6,0,0,integer[],1
+pls,plot.mvrVal,7,0,0,double,1
+pls,plot.mvrVal,8,0,0,integer[],1
+pls,plot.mvrVal,9,0,0,character,1
+pls,plot.mvrVal,10,0,0,character,1
+pls,plot.mvrVal,11,0,0,character,1
+pls,plot.mvrVal,12,0,0,any,1
+pls,plot.mvrVal,13,0,0,any,1
+pls,plot.mvrVal,14,0,0,...,1
+pls,pls.options,-1,0,0,list<character | null | double>,1
+pls,pls.options,-1,0,1,list<character>,1
+pls,pls.options,0,0,0,...,1
+pls,plsr,-1,0,0,class<`mvr`>,1
+pls,plsr,0,0,0,...,1
+pls,plsr,1,0,0,character,1
+pls,predict.msc,-1,0,0,"class<`matrix`, `msc`>",1
+pls,predict.msc,0,0,0,"class<`matrix`, `msc`>",1
+pls,predict.msc,1,0,0,class<`matrix`>,1
+pls,predict.msc,2,0,0,...,1
+pls,predict.mvr,-1,0,0,class<`array`>,1
+pls,predict.mvr,-1,0,1,class<`matrix`>,1
+pls,predict.mvr,0,0,0,class<`mvr`>,1
+pls,predict.mvr,1,0,0,any,1
+pls,predict.mvr,2,0,0,any,1
+pls,predict.mvr,3,0,0,any,1
+pls,predict.mvr,4,0,0,character[],1
+pls,predict.mvr,5,0,0,any,1
+pls,predict.mvr,6,0,0,...,1
+pls,predict.stdized,-1,0,0,"class<`matrix`, `stdized`>",1
+pls,predict.stdized,0,0,0,"class<`matrix`, `stdized`>",1
+pls,predict.stdized,1,0,0,class<`matrix`>,1
+pls,predict.stdized,2,0,0,...,1
+pls,prednames,-1,0,0,character[],1
+pls,prednames,0,0,0,class<`mvr`>,1
+pls,prednames,1,0,0,logical,1
+pls,predplot,-1,0,0,class<`matrix`>,1
+pls,predplot,0,0,0,class<`mvr`>,1
+pls,predplot,1,0,0,...,1
+pls,predplot.mvr,-1,0,0,class<`matrix`>,1
+pls,predplot.mvr,0,0,0,class<`mvr`>,1
+pls,predplot.mvr,1,0,0,double,1
+pls,predplot.mvr,2,0,0,any,1
+pls,predplot.mvr,3,0,0,any,1
+pls,predplot.mvr,4,0,0,any,1
+pls,predplot.mvr,5,0,0,any,1
+pls,predplot.mvr,6,0,0,character,1
+pls,predplot.mvr,7,0,0,character,1
+pls,predplot.mvr,8,0,0,any,1
+pls,predplot.mvr,9,0,0,any,1
+pls,predplot.mvr,10,0,0,...,1
+pls,predplot.mvr,11,0,0,any,1
+pls,predplot.mvr,12,0,0,any,1
+pls,predplotXy,-1,0,0,class<`matrix`>,1
+pls,predplotXy,0,0,0,double[],1
+pls,predplotXy,1,0,0,double[],1
+pls,predplotXy,2,0,0,logical,1
+pls,predplotXy,3,0,0,any,1
+pls,predplotXy,4,0,0,character,1
+pls,predplotXy,5,0,0,character,1
+pls,predplotXy,6,0,0,character,1
+pls,predplotXy,7,0,0,character,1
+pls,predplotXy,8,0,0,character,1
+pls,predplotXy,9,0,0,null,1
+pls,predplotXy,10,0,0,null,1
+pls,predplotXy,11,0,0,...,1
+pls,print.mvrVal,-1,0,0,class<`mvrVal`>,1
+pls,print.mvrVal,0,0,0,class<`mvrVal`>,1
+pls,print.mvrVal,1,0,0,double,1
+pls,print.mvrVal,2,0,0,double,1
+pls,print.mvrVal,3,0,0,...,1
+pls,R2,-1,0,0,class<`mvrVal`>,1
+pls,R2,0,0,0,class<`mvr`>,1
+pls,R2,1,0,0,...,1
+pls,R2.mvr,-1,0,0,class<`mvrVal`>,1
+pls,R2.mvr,0,0,0,class<`mvr`>,1
+pls,R2.mvr,1,0,0,character,1
+pls,R2.mvr,2,0,0,any,1
+pls,R2.mvr,3,0,0,any,1
+pls,R2.mvr,4,0,0,any,1
+pls,R2.mvr,5,0,0,logical,1
+pls,R2.mvr,6,0,0,logical,1
+pls,R2.mvr,7,0,0,...,1
+pls,randomiz.test,-1,0,0,double,1
+pls,randomiz.test,0,0,0,double[],1
+pls,randomiz.test,1,0,0,double[],1
+pls,randomiz.test,2,0,0,double,1
+pls,Rcal,-1,0,0,list<class<`matrix`> | double[]>,1
+pls,Rcal,-1,0,1,list<class<`matrix`> | double>,1
+pls,Rcal,0,0,0,class<`matrix`>,1
+pls,Rcal,1,0,0,class<`matrix`>,1
+pls,Rcal,2,0,0,class<`AsIs`>,1
+pls,Rcal,2,0,1,class<`matrix`>,1
+pls,Rcal,3,0,0,null,1
+pls,residuals.mvr,-1,0,0,class<`array`>,1
+pls,residuals.mvr,0,0,0,class<`mvr`>,1
+pls,residuals.mvr,1,0,0,...,1
+pls,respnames,-1,0,0,character,1
+pls,respnames,0,0,0,class<`mvr`>,1
+pls,RMSEP,-1,0,0,class<`mvrVal`>,1
+pls,RMSEP,0,0,0,class<`mvr`>,1
+pls,RMSEP,1,0,0,...,1
+pls,RMSEP.mvr,-1,0,0,class<`mvrVal`>,1
+pls,RMSEP.mvr,0,0,0,class<`mvr`>,1
+pls,RMSEP.mvr,1,0,0,...,1
+pls,scoreplot.default,-1,0,0,null,1
+pls,scoreplot.default,0,0,0,class<`mvr`>,1
+pls,scoreplot.default,1,0,0,integer[],1
+pls,scoreplot.default,2,0,0,any,1
+pls,scoreplot.default,3,0,0,logical,1
+pls,scoreplot.default,4,0,0,character,1
+pls,scoreplot.default,5,0,0,any,1
+pls,scoreplot.default,6,0,0,any,1
+pls,scoreplot.default,7,0,0,...,1
+pls,scores,-1,0,0,class<`scores`>,1
+pls,scores,0,0,0,class<`mvr`>,1
+pls,scores,1,0,0,...,1
+pls,scores.default,-1,0,0,class<`scores`>,1
+pls,scores.default,0,0,0,class<`mvr`>,1
+pls,scores.default,1,0,0,...,1
+pls,selectNcomp,-1,0,0,double,1
+pls,selectNcomp,0,0,0,class<`mvr`>,1
+pls,selectNcomp,1,0,0,character,1
+pls,selectNcomp,2,0,0,double,1
+pls,selectNcomp,3,0,0,double,1
+pls,selectNcomp,4,0,0,double,1
+pls,selectNcomp,5,0,0,logical,1
+pls,selectNcomp,6,0,0,...,1
+pls,simpls.fit,-1,0,0,list<class<`array`> | double[]>,1
+pls,simpls.fit,0,0,0,class<`AsIs`>,1
+pls,simpls.fit,1,0,0,double[],1
+pls,simpls.fit,2,0,0,double,1
+pls,simpls.fit,3,0,0,logical,1
+pls,simpls.fit,4,0,0,logical,1
+pls,simpls.fit,5,0,0,...,1
+pls,stdize,-1,0,0,"class<`matrix`, `stdized`>",1
+pls,stdize,0,0,0,class<`matrix`>,1
+pls,stdize,1,0,0,double[],1
+pls,stdize,2,0,0,double[],1
+pls,summary.mvr,-1,0,0,null,1
+pls,summary.mvr,0,0,0,class<`mvr`>,1
+pls,summary.mvr,1,0,0,character[],1
+pls,summary.mvr,2,0,0,double,1
+pls,summary.mvr,3,0,0,double,1
+pls,summary.mvr,4,0,0,...,1
+pls,var.jack,-1,0,0,class<`array`>,1
+pls,var.jack,0,0,0,class<`mvr`>,1
+pls,var.jack,1,0,0,double,1
+pls,var.jack,2,0,0,logical,1
+pls,var.jack,3,0,0,logical,1
+plyr,.,-1,0,0,class<`quoted`>,1
+plyr,.,0,0,0,...,1
+plyr,.,1,0,0,environment,1
+plyr,aaply,-1,0,0,class<`array`>,1
+plyr,aaply,-1,0,1,class<`matrix`>,1
+plyr,aaply,-1,0,2,double[],1
+plyr,aaply,0,0,0,class<`array`>,1
+plyr,aaply,0,0,1,class<`data.frame`>,1
+plyr,aaply,1,0,0,double[],1
+plyr,aaply,2,0,0,class<`function`>,1
+plyr,aaply,3,0,0,...,1
+plyr,aaply,4,0,0,logical,1
+plyr,aaply,5,0,0,character,1
+plyr,aaply,6,0,0,logical,1
+plyr,aaply,7,0,0,logical,1
+plyr,adply,-1,0,0,class<`data.frame`>,1
+plyr,adply,0,0,0,class<`data.frame`>,1
+plyr,adply,1,0,0,double,1
+plyr,adply,2,0,0,class<`function`>,1
+plyr,adply,3,0,0,...,1
+plyr,adply,4,0,0,logical,1
+plyr,adply,5,0,0,character,1
+plyr,adply,6,0,0,logical,1
+plyr,adply,7,0,0,logical,1
+plyr,allocate_column,-1,0,0,list<class<`function`>>,1
+plyr,allocate_column,0,0,0,character[],1
+plyr,allocate_column,0,0,1,double[],1
+plyr,allocate_column,0,0,2,^integer[],1
+plyr,allocate_column,1,0,0,integer,1
+plyr,allocate_column,2,0,0,any,1
+plyr,allocate_column,3,0,0,any,1
+plyr,alply,-1,0,0,list<class<`lm`>>,1
+plyr,alply,-1,0,1,list<class<`table`>>,1
+plyr,alply,-1,0,2,list<double[]>,1
+plyr,alply,0,0,0,class<`array`>,1
+plyr,alply,0,0,1,class<`data.frame`>,1
+plyr,alply,1,0,0,integer[],1
+plyr,alply,1,0,1,double,1
+plyr,alply,2,0,0,class<`function`>,1
+plyr,alply,3,0,0,...,1
+plyr,alply,4,0,0,logical,1
+plyr,alply,5,0,0,character,1
+plyr,alply,6,0,0,logical,1
+plyr,alply,7,0,0,logical,1
+plyr,amv_dim,-1,0,0,integer[],1
+plyr,amv_dim,0,0,0,class<`array`>,1
+plyr,amv_dim,0,0,1,class<`data.frame`>,1
+plyr,amv_dim,0,0,2,class<`matrix`>,1
+plyr,amv_dim,0,0,3,character,1
+plyr,amv_dim,0,0,4,double[],1
+plyr,amv_dimnames,-1,0,0,list<character[]>,1
+plyr,amv_dimnames,-1,0,1,list<integer[] | character[]>,1
+plyr,amv_dimnames,-1,0,2,list<integer[]>,1
+plyr,amv_dimnames,0,0,0,class<`data.frame`>,1
+plyr,amv_dimnames,0,0,1,double[],1
+plyr,amv_dimnames,0,0,2,class<`matrix`>,1
+plyr,amv_dimnames,0,0,3,character,1
+plyr,amv_dimnames,0,0,4,class<`array`>,1
+plyr,arrange,-1,0,0,class<`data.frame`>,1
+plyr,arrange,0,0,0,class<`data.frame`>,1
+plyr,arrange,1,0,0,...,1
+plyr,as.data.frame.function,-1,0,0,class<`function`>,1
+plyr,as.data.frame.function,0,0,0,class<`function`>,1
+plyr,as.data.frame.function,1,0,0,any,1
+plyr,as.data.frame.function,2,0,0,any,1
+plyr,as.data.frame.function,3,0,0,...,1
+plyr,as.list.indexed,-1,0,0,"class<`list`, `split`>",1
+plyr,as.list.indexed,0,0,0,"class<`indexed`, `indexed_df`, `list`, `split`>",1
+plyr,as.list.indexed,1,0,0,...,1
+plyr,as.quoted,-1,0,0,class<`quoted`>,1
+plyr,as.quoted,0,0,0,character[],1
+plyr,as.quoted,0,0,1,class<`formula`>,1
+plyr,as.quoted,0,0,2,class<`quoted`>,1
+plyr,as.quoted,1,0,0,any,1
+plyr,as.quoted.character,-1,0,0,class<`quoted`>,1
+plyr,as.quoted.character,0,0,0,character[],1
+plyr,as.quoted.character,1,0,0,environment,1
+plyr,as.quoted.formula,-1,0,0,class<`quoted`>,1
+plyr,as.quoted.formula,0,0,0,class<`formula`>,1
+plyr,as.quoted.formula,1,0,0,environment,1
+plyr,as.quoted.quoted,-1,0,0,class<`quoted`>,1
+plyr,as.quoted.quoted,0,0,0,class<`quoted`>,1
+plyr,as.quoted.quoted,1,0,0,any,1
+plyr,catcolwise,-1,0,0,class<`function`>,1
+plyr,catcolwise,0,0,0,any,1
+plyr,catcolwise,1,0,0,...,1
+plyr,cat_line,-1,0,0,null,1
+plyr,cat_line,0,0,0,...,1
+plyr,colwise,-1,0,0,class<`data.frame`>,1
+plyr,colwise,0,0,0,class<`data.frame`>,1
+plyr,colwise,1,0,0,...,1
+plyr,colwise,-1,1,0,class<`function`>,1
+plyr,colwise,0,1,0,any,1
+plyr,colwise,1,1,0,character[],1
+plyr,colwise,1,1,1,class<`formula`>,1
+plyr,colwise,1,1,2,class<`function`>,1
+plyr,colwise,1,1,3,class<`quoted`>,1
+plyr,colwise,2,1,0,...,1
+plyr,compact,-1,0,0,list<class<`data.frame`>>,1
+plyr,compact,0,0,0,list<class<`data.frame`>>,1
+plyr,count,-1,0,0,class<`data.frame`>,1
+plyr,count,0,0,0,class<`data.frame`>,1
+plyr,count,1,0,0,character[],1
+plyr,count,2,0,0,null,1
+plyr,count,2,0,1,character,1
+plyr,create_progress_bar,-1,0,0,list<class<`function`>>,1
+plyr,create_progress_bar,0,0,0,character,1
+plyr,create_progress_bar,0,0,1,list<class<`function`>>,1
+plyr,create_progress_bar,1,0,0,...,1
+plyr,daply,-1,0,0,class<`matrix`>,1
+plyr,daply,-1,0,1,integer[],1
+plyr,daply,0,0,0,class<`data.frame`>,1
+plyr,daply,1,0,0,class<`quoted`>,1
+plyr,daply,2,0,0,class<`function`>,1
+plyr,daply,3,0,0,...,1
+plyr,daply,4,0,0,character,1
+plyr,daply,5,0,0,logical,1
+plyr,daply,6,0,0,logical,1
+plyr,daply,7,0,0,logical,1
+plyr,ddply,-1,0,0,class<`data.frame`>,1
+plyr,ddply,0,0,0,class<`data.frame`>,1
+plyr,ddply,1,0,0,class<`quoted`>,1
+plyr,ddply,1,0,1,character,1
+plyr,ddply,1,0,2,class<`formula`>,1
+plyr,ddply,2,0,0,class<`function`>,1
+plyr,ddply,2,0,1,character[],1
+plyr,ddply,3,0,0,...,1
+plyr,ddply,4,0,0,character,1
+plyr,ddply,5,0,0,logical,1
+plyr,ddply,6,0,0,logical,1
+plyr,ddply,7,0,0,logical,1
+plyr,desc,-1,0,0,double[],1
+plyr,desc,0,0,0,class<`Date`>,1
+plyr,desc,0,0,1,double[],1
+plyr,desc,0,0,2,class<`factor`>,1
+plyr,dim.idf,-1,0,0,integer[],1
+plyr,dim.idf,0,0,0,"class<`environment`, `idf`>",1
+plyr,dims,-1,0,0,integer,1
+plyr,dims,0,0,0,class<`array`>,1
+plyr,dims,0,0,1,class<`data.frame`>,1
+plyr,dims,0,0,2,class<`matrix`>,1
+plyr,dims,0,0,3,character,1
+plyr,dims,0,0,4,double[],1
+plyr,dlply,-1,0,0,"class<`list`, `split`>",1
+plyr,dlply,-1,0,1,list<class<`data.frame`>>,1
+plyr,dlply,-1,0,2,list<class<`lm`>>,1
+plyr,dlply,-1,0,3,list<integer>,1
+plyr,dlply,0,0,0,class<`data.frame`>,1
+plyr,dlply,0,0,1,"class<`environment`, `idf`>",1
+plyr,dlply,1,0,0,character[],1
+plyr,dlply,1,0,1,class<`quoted`>,1
+plyr,dlply,2,0,0,null,1
+plyr,dlply,2,0,1,class<`function`>,1
+plyr,dlply,3,0,0,...,1
+plyr,dlply,4,0,0,character,1
+plyr,dlply,5,0,0,logical,1
+plyr,dlply,6,0,0,logical,1
+plyr,dlply,7,0,0,logical,1
+plyr,each,-1,0,0,double[],1
+plyr,each,0,0,0,double[],1
+plyr,each,1,0,0,...,1
+plyr,each,-1,1,0,class<`function`>,1
+plyr,each,0,1,0,...,1
+plyr,empty,-1,0,0,logical,1
+plyr,empty,0,0,0,class<`data.frame`>,1
+plyr,eval.quoted,-1,0,0,list<class<`factor`>>,1
+plyr,eval.quoted,-1,0,1,list<^double[]>,1
+plyr,eval.quoted,-1,0,2,list<character[]>,1
+plyr,eval.quoted,-1,0,3,list<character[] | integer[]>,1
+plyr,eval.quoted,0,0,0,class<`quoted`>,1
+plyr,eval.quoted,1,0,0,class<`data.frame`>,1
+plyr,eval.quoted,1,0,1,"class<`environment`, `idf`>",1
+plyr,eval.quoted,2,0,0,null,1
+plyr,eval.quoted,3,0,0,logical,1
+plyr,extract_rows,-1,0,0,class<`data.frame`>,1
+plyr,extract_rows,-1,0,1,"class<`environment`, `idf`>",1
+plyr,extract_rows,0,0,0,class<`data.frame`>,1
+plyr,extract_rows,0,0,1,"class<`environment`, `idf`>",1
+plyr,extract_rows,1,0,0,integer[],1
+plyr,failwith,-1,0,0,class<`function`>,1
+plyr,failwith,0,0,0,null,1
+plyr,failwith,1,0,0,class<`function`>,1
+plyr,failwith,2,0,0,logical,1
+plyr,id,-1,0,0,integer[],1
+plyr,id,0,0,0,class<`data.frame`>,1
+plyr,id,0,0,1,list<class<`factor`>>,1
+plyr,id,0,0,2,list<^double[]>,1
+plyr,id,0,0,3,list<character[]>,1
+plyr,id,1,0,0,any,1
+plyr,idata.frame,-1,0,0,"class<`environment`, `idf`>",1
+plyr,idata.frame,0,0,0,class<`data.frame`>,1
+plyr,[.idf,-1,0,0,"class<`environment`, `idf`>",1
+plyr,[.idf,0,0,0,"class<`environment`, `idf`>",1
+plyr,[.idf,1,0,0,integer[],1
+plyr,[.idf,2,0,0,any,1
+plyr,[.idf,3,0,0,logical,1
+plyr,id_var,-1,0,0,integer[],1
+plyr,id_var,0,0,0,character[],1
+plyr,id_var,0,0,1,class<`factor`>,1
+plyr,id_var,0,0,2,^double[],1
+plyr,id_var,1,0,0,any,1
+plyr,[[.indexed_array,-1,0,0,class<`data.frame`>,1
+plyr,[[.indexed_array,-1,0,1,class<`matrix`>,1
+plyr,[[.indexed_array,-1,0,2,double[],1
+plyr,[[.indexed_array,0,0,0,"class<`indexed`, `indexed_array`, `list`, `split`>",1
+plyr,[[.indexed_array,1,0,0,integer,1
+plyr,indexed_array,-1,0,0,"class<`indexed`, `indexed_array`>",1
+plyr,indexed_array,0,0,0,environment,1
+plyr,indexed_array,1,0,0,class<`data.frame`>,1
+plyr,[[.indexed_df,-1,0,0,class<`data.frame`>,1
+plyr,[[.indexed_df,-1,0,1,"class<`environment`, `idf`>",1
+plyr,[[.indexed_df,0,0,0,"class<`indexed`, `indexed_df`, `list`, `split`>",1
+plyr,[[.indexed_df,1,0,0,integer,1
+plyr,indexed_df,-1,0,0,"class<`indexed`, `indexed_df`>",1
+plyr,indexed_df,0,0,0,class<`data.frame`>,1
+plyr,indexed_df,0,0,1,"class<`environment`, `idf`>",1
+plyr,indexed_df,1,0,0,list<integer[]>,1
+plyr,indexed_df,2,0,0,character[],1
+plyr,is.discrete,-1,0,0,logical,1
+plyr,is.discrete,0,0,0,character[],1
+plyr,is.discrete,0,0,1,class<`factor`>,1
+plyr,is.discrete,0,0,2,integer[],1
+plyr,is.quoted,-1,0,0,logical,1
+plyr,is.quoted,0,0,0,class<`quoted`>,1
+plyr,join,-1,0,0,class<`data.frame`>,1
+plyr,join,0,0,0,class<`data.frame`>,1
+plyr,join,1,0,0,class<`data.frame`>,1
+plyr,join,2,0,0,character,1
+plyr,join,2,0,1,null,1
+plyr,join,3,0,0,character,1
+plyr,join,4,0,0,character,1
+plyr,.join_all,-1,0,0,class<`data.frame`>,1
+plyr,.join_all,0,0,0,class<`data.frame`>,1
+plyr,.join_all,1,0,0,class<`data.frame`>,1
+plyr,.join_all,2,0,0,character,1
+plyr,.join_all,3,0,0,character,1
+plyr,join_all,-1,0,0,class<`data.frame`>,1
+plyr,join_all,0,0,0,list<class<`data.frame`>>,1
+plyr,join_all,1,0,0,character,1
+plyr,join_all,1,0,1,null,1
+plyr,join_all,2,0,0,character,1
+plyr,join_all,3,0,0,character,1
+plyr,join_ids,-1,0,0,list<integer[]>,1
+plyr,join_ids,0,0,0,class<`data.frame`>,1
+plyr,join_ids,1,0,0,class<`data.frame`>,1
+plyr,join_ids,2,0,0,character,1
+plyr,join_ids,3,0,0,logical,1
+plyr,join.keys,-1,0,0,list<integer[]>,1
+plyr,join.keys,0,0,0,class<`data.frame`>,1
+plyr,join.keys,1,0,0,class<`data.frame`>,1
+plyr,join.keys,2,0,0,character,1
+plyr,laply,-1,0,0,character[],1
+plyr,laply,-1,0,1,class<`array`>,1
+plyr,laply,-1,0,2,class<`matrix`>,1
+plyr,laply,-1,0,3,double[],1
+plyr,laply,0,0,0,class<`call`>,1
+plyr,laply,0,0,1,"class<`indexed`, `indexed_array`, `list`, `split`>",1
+plyr,laply,0,0,2,integer[],1
+plyr,laply,0,0,3,list<class<`lm`>>,1
+plyr,laply,0,0,4,"class<`indexed`, `indexed_df`, `list`, `split`>",1
+plyr,laply,0,0,5,character[],1
+plyr,laply,0,0,6,class<`data.frame`>,1
+plyr,laply,0,0,7,list<character>,1
+plyr,laply,0,0,8,list<class<`function`>>,1
+plyr,laply,1,0,0,class<`function`>,1
+plyr,laply,2,0,0,...,1
+plyr,laply,3,0,0,character,1
+plyr,laply,4,0,0,logical,1
+plyr,laply,5,0,0,logical,1
+plyr,laply,6,0,0,logical,1
+plyr,laply,7,0,0,any,1
+plyr,ldply,-1,0,0,class<`data.frame`>,1
+plyr,ldply,0,0,0,class<`data.frame`>,1
+plyr,ldply,0,0,1,"class<`indexed`, `indexed_array`, `list`, `split`>",1
+plyr,ldply,0,0,2,"class<`indexed`, `indexed_df`, `list`, `split`>",1
+plyr,ldply,0,0,3,list<class<`lm`>>,1
+plyr,ldply,1,0,0,class<`function`>,1
+plyr,ldply,1,0,1,character[],1
+plyr,ldply,2,0,0,...,1
+plyr,ldply,3,0,0,character,1
+plyr,ldply,4,0,0,logical,1
+plyr,ldply,5,0,0,logical,1
+plyr,ldply,6,0,0,any,1
+plyr,ldply,7,0,0,null,1
+plyr,length.indexed,-1,0,0,integer,1
+plyr,length.indexed,0,0,0,"class<`indexed`, `indexed_df`, `list`, `split`>",1
+plyr,length.indexed_array,-1,0,0,integer,1
+plyr,length.indexed_array,0,0,0,"class<`indexed`, `indexed_array`, `list`, `split`>",1
+plyr,list_to_array,-1,0,0,character[],1
+plyr,list_to_array,-1,0,1,class<`array`>,1
+plyr,list_to_array,-1,0,2,class<`matrix`>,1
+plyr,list_to_array,-1,0,3,double[],1
+plyr,list_to_array,0,0,0,list<character>,1
+plyr,list_to_array,0,0,1,list<class<`matrix`>>,1
+plyr,list_to_array,0,0,2,list<double[]>,1
+plyr,list_to_array,0,0,3,list<class<`data.frame`>>,1
+plyr,list_to_array,1,0,0,null,1
+plyr,list_to_array,1,0,1,class<`data.frame`>,1
+plyr,list_to_array,2,0,0,logical,1
+plyr,list_to_dataframe,-1,0,0,class<`data.frame`>,1
+plyr,list_to_dataframe,0,0,0,list<class<`data.frame`>>,1
+plyr,list_to_dataframe,0,0,1,list<double[]>,1
+plyr,list_to_dataframe,1,0,0,class<`data.frame`>,1
+plyr,list_to_dataframe,1,0,1,null,1
+plyr,list_to_dataframe,2,0,0,character,1
+plyr,list_to_dataframe,2,0,1,null,1
+plyr,list_to_dataframe,3,0,0,any,1
+plyr,list_to_vector,-1,0,0,double[],1
+plyr,list_to_vector,0,0,0,list<double>,1
+plyr,llply,-1,0,0,"class<`list`, `split`>",1
+plyr,llply,-1,0,1,list<any>,1
+plyr,llply,0,0,0,"class<`indexed`, `indexed_df`, `list`, `split`>",1
+plyr,llply,0,0,1,integer[],1
+plyr,llply,0,0,2,list<any>,1
+plyr,llply,0,0,3,character[],1
+plyr,llply,0,0,4,"class<`indexed`, `indexed_array`, `list`, `split`>",1
+plyr,llply,0,0,5,class<`data.frame`>,1
+plyr,llply,1,0,0,null,1
+plyr,llply,1,0,1,class<`function`>,1
+plyr,llply,1,0,2,character[],1
+plyr,llply,2,0,0,...,1
+plyr,llply,3,0,0,any,1
+plyr,llply,4,0,0,any,1
+plyr,llply,5,0,0,any,1
+plyr,llply,6,0,0,any,1
+plyr,loop_apply,-1,0,0,list<class<`data.frame`>>,1
+plyr,loop_apply,-1,0,1,list<class<`lm`>>,1
+plyr,loop_apply,-1,0,2,list<class<`matrix`>>,1
+plyr,loop_apply,-1,0,3,list<class<`table`>>,1
+plyr,loop_apply,-1,0,4,list<double[]>,1
+plyr,loop_apply,0,0,0,integer,1
+plyr,loop_apply,1,0,0,class<`function`>,1
+plyr,loop_apply,2,0,0,environment,1
+plyr,l_ply,-1,0,0,null,1
+plyr,l_ply,0,0,0,class<`data.frame`>,1
+plyr,l_ply,0,0,1,integer[],1
+plyr,l_ply,0,0,2,list<double[]>,1
+plyr,l_ply,1,0,0,class<`function`>,1
+plyr,l_ply,2,0,0,...,1
+plyr,l_ply,3,0,0,character,1
+plyr,l_ply,3,0,1,list<class<`function`>>,1
+plyr,l_ply,4,0,0,logical,1
+plyr,l_ply,5,0,0,logical,1
+plyr,l_ply,6,0,0,logical,1
+plyr,l_ply,7,0,0,null,1
+plyr,make_assignment_call,-1,0,0,class<`call`>,1
+plyr,make_assignment_call,0,0,0,integer,1
+plyr,make_names,-1,0,0,character[],1
+plyr,make_names,0,0,0,class<`data.frame`>,1
+plyr,make_names,0,0,1,double[],1
+plyr,make_names,0,0,2,list<^double[]>,1
+plyr,make_names,0,0,3,list<class<`factor`>>,1
+plyr,make_names,0,0,4,list<character[] | integer[]>,1
+plyr,make_names,0,0,5,list<character[] | ^integer[] | double[]>,1
+plyr,make_names,0,0,6,list<character[]>,1
+plyr,make_names,1,0,0,character,1
+plyr,maply,-1,0,0,class<`array`>,1
+plyr,maply,0,0,0,class<`data.frame`>,1
+plyr,maply,0,0,1,class<`matrix`>,1
+plyr,maply,1,0,0,class<`function`>,1
+plyr,maply,2,0,0,...,1
+plyr,maply,3,0,0,logical,1
+plyr,maply,4,0,0,character,1
+plyr,maply,5,0,0,logical,1
+plyr,maply,6,0,0,logical,1
+plyr,maply,7,0,0,logical,1
+plyr,mapvalues,-1,0,0,character[],1
+plyr,mapvalues,-1,0,1,class<`factor`>,1
+plyr,mapvalues,-1,0,2,double[],1
+plyr,mapvalues,0,0,0,character[],1
+plyr,mapvalues,0,0,1,class<`factor`>,1
+plyr,mapvalues,0,0,2,double[],1
+plyr,mapvalues,1,0,0,character[],1
+plyr,mapvalues,1,0,1,double[],1
+plyr,mapvalues,2,0,0,character[],1
+plyr,mapvalues,2,0,1,double[],1
+plyr,mapvalues,3,0,0,logical,1
+plyr,match_df,-1,0,0,class<`data.frame`>,1
+plyr,match_df,0,0,0,class<`data.frame`>,1
+plyr,match_df,1,0,0,class<`data.frame`>,1
+plyr,match_df,2,0,0,character,1
+plyr,.matrix_to_df,-1,0,0,class<`data.frame`>,1
+plyr,.matrix_to_df,0,0,0,class<`matrix`>,1
+plyr,mdply,-1,0,0,class<`data.frame`>,1
+plyr,mdply,0,0,0,class<`data.frame`>,1
+plyr,mdply,0,0,1,class<`matrix`>,1
+plyr,mdply,1,0,0,class<`function`>,1
+plyr,mdply,2,0,0,...,1
+plyr,mdply,3,0,0,logical,1
+plyr,mdply,4,0,0,character,1
+plyr,mdply,5,0,0,logical,1
+plyr,mdply,6,0,0,logical,1
+plyr,mdply,7,0,0,null,1
+plyr,mlply,-1,0,0,list<double[]>,1
+plyr,mlply,0,0,0,class<`matrix`>,1
+plyr,mlply,1,0,0,class<`function`>,1
+plyr,mlply,2,0,0,...,1
+plyr,mlply,3,0,0,logical,1
+plyr,mlply,4,0,0,character,1
+plyr,mlply,5,0,0,logical,1
+plyr,mlply,6,0,0,logical,1
+plyr,mlply,7,0,0,null,1
+plyr,mutate,-1,0,0,class<`data.frame`>,1
+plyr,mutate,0,0,0,class<`data.frame`>,1
+plyr,mutate,1,0,0,...,1
+plyr,name_rows,-1,0,0,class<`data.frame`>,1
+plyr,name_rows,0,0,0,class<`data.frame`>,1
+plyr,names.indexed,-1,0,0,character[],1
+plyr,names.indexed,0,0,0,"class<`indexed`, `indexed_df`, `list`, `split`>",1
+plyr,names.indexed_array,-1,0,0,character[],1
+plyr,names.indexed_array,0,0,0,"class<`indexed`, `indexed_array`, `list`, `split`>",1
+plyr,names.quoted,-1,0,0,character[],1
+plyr,names.quoted,0,0,0,class<`quoted`>,1
+plyr,ninteraction,-1,0,0,integer[],1
+plyr,ninteraction,0,0,0,class<`data.frame`>,1
+plyr,ninteraction,0,0,1,list<class<`factor`>>,1
+plyr,ninteraction,0,0,2,list<^double[]>,1
+plyr,ninteraction,0,0,3,list<character[]>,1
+plyr,ninteraction,1,0,0,any,1
+plyr,nlevels,-1,0,0,double,1
+plyr,nlevels,0,0,0,integer[],1
+plyr,numcolwise,-1,0,0,class<`data.frame`>,1
+plyr,numcolwise,0,0,0,class<`data.frame`>,1
+plyr,numcolwise,1,0,0,...,1
+plyr,numcolwise,-1,1,0,class<`function`>,1
+plyr,numcolwise,0,1,0,any,1
+plyr,numcolwise,1,1,0,...,1
+plyr,output_template,-1,0,0,list<list<class<`function`>>>,1
+plyr,output_template,0,0,0,list<class<`data.frame`>>,1
+plyr,output_template,1,0,0,integer,1
+plyr,progress_text,-1,0,0,list<class<`function`>>,1
+plyr,progress_text,0,0,0,double,1
+plyr,progress_text,1,0,0,...,1
+plyr,quickdf,-1,0,0,class<`data.frame`>,1
+plyr,quickdf,0,0,0,list<class<`factor`>>,1
+plyr,quickdf,0,0,1,list<^double[]>,1
+plyr,quickdf,0,0,2,list<character[]>,1
+plyr,quickdf,0,0,3,list<character[] | integer[]>,1
+plyr,quickdf,0,0,4,list<character[] | ^integer[] | double[]>,1
+plyr,raply,-1,0,0,class<`array`>,1
+plyr,raply,-1,0,1,class<`matrix`>,1
+plyr,raply,-1,0,2,double[],1
+plyr,raply,0,0,0,double,1
+plyr,raply,1,0,0,any,1
+plyr,raply,2,0,0,character,1
+plyr,raply,3,0,0,logical,1
+plyr,rbind.fill,-1,0,0,class<`data.frame`>,1
+plyr,rbind.fill,0,0,0,...,1
+plyr,rbind.fill.matrix,-1,0,0,class<`matrix`>,1
+plyr,rbind.fill.matrix,0,0,0,...,1
+plyr,rdply,-1,0,0,class<`data.frame`>,1
+plyr,rdply,0,0,0,double,1
+plyr,rdply,1,0,0,any,1
+plyr,rdply,2,0,0,character,1
+plyr,rdply,3,0,0,null,1
+plyr,reduce_dim,-1,0,0,character[],1
+plyr,reduce_dim,-1,0,1,class<`array`>,1
+plyr,reduce_dim,-1,0,2,class<`matrix`>,1
+plyr,reduce_dim,-1,0,3,double[],1
+plyr,reduce_dim,0,0,0,class<`matrix`>,1
+plyr,reduce_dim,0,0,1,class<`array`>,1
+plyr,rename,-1,0,0,class<`data.frame`>,1
+plyr,rename,-1,0,1,double[],1
+plyr,rename,0,0,0,class<`data.frame`>,1
+plyr,rename,0,0,1,double[],1
+plyr,rename,1,0,0,character,1
+plyr,rename,2,0,0,logical,1
+plyr,rename,3,0,0,logical,1
+plyr,revalue,-1,0,0,character[],1
+plyr,revalue,-1,0,1,class<`factor`>,1
+plyr,revalue,0,0,0,character[],1
+plyr,revalue,0,0,1,class<`factor`>,1
+plyr,revalue,1,0,0,character[],1
+plyr,revalue,2,0,0,logical,1
+plyr,rlply,-1,0,0,list<class<`lm`>>,1
+plyr,rlply,0,0,0,double,1
+plyr,rlply,1,0,0,any,1
+plyr,rlply,2,0,0,character,1
+plyr,.rlply_worker,-1,0,0,list<class<`data.frame`>>,1
+plyr,.rlply_worker,-1,0,1,list<class<`lm`>>,1
+plyr,.rlply_worker,-1,0,2,list<class<`matrix`>>,1
+plyr,.rlply_worker,-1,0,3,list<double[]>,1
+plyr,.rlply_worker,-1,0,4,null,1
+plyr,.rlply_worker,0,0,0,double,1
+plyr,.rlply_worker,1,0,0,character,1
+plyr,.rlply_worker,2,0,0,class<`function`>,1
+plyr,.rlply_worker,3,0,0,logical,1
+plyr,.rlply_worker,4,0,0,logical,1
+plyr,round_any,-1,0,0,"class<`POSIXct`, `POSIXt`>",1
+plyr,round_any,-1,0,1,double[],1
+plyr,round_any,0,0,0,"class<`POSIXct`, `POSIXt`>",1
+plyr,round_any,0,0,1,double[],1
+plyr,round_any,1,0,0,double,1
+plyr,round_any,2,0,0,any,1
+plyr,round_any.numeric,-1,0,0,double[],1
+plyr,round_any.numeric,0,0,0,double[],1
+plyr,round_any.numeric,1,0,0,double,1
+plyr,round_any.numeric,2,0,0,class<`function`>,1
+plyr,round_any.POSIXct,-1,0,0,"class<`POSIXct`, `POSIXt`>",1
+plyr,round_any.POSIXct,0,0,0,"class<`POSIXct`, `POSIXt`>",1
+plyr,round_any.POSIXct,1,0,0,double,1
+plyr,round_any.POSIXct,2,0,0,class<`function`>,1
+plyr,r_ply,-1,0,0,null,1
+plyr,r_ply,0,0,0,double,1
+plyr,r_ply,1,0,0,any,1
+plyr,r_ply,2,0,0,character,1
+plyr,r_ply,3,0,0,logical,1
+plyr,show_time,-1,0,0,character,1
+plyr,show_time,0,0,0,double,1
+plyr,splat,-1,0,0,class<`data.frame`>,1
+plyr,splat,-1,0,1,double[],1
+plyr,splat,0,0,0,class<`data.frame`>,1
+plyr,splat,1,0,0,...,1
+plyr,splat,-1,1,0,class<`function`>,1
+plyr,splat,0,1,0,any,1
+plyr,split_indices,-1,0,0,list<integer[]>,1
+plyr,split_indices,0,0,0,integer[],1
+plyr,split_indices,1,0,0,double,1
+plyr,split_labels,-1,0,0,class<`data.frame`>,1
+plyr,split_labels,0,0,0,list<class<`factor`>>,1
+plyr,split_labels,0,0,1,list<^double[]>,1
+plyr,split_labels,0,0,2,list<character[]>,1
+plyr,split_labels,1,0,0,logical,1
+plyr,split_labels,2,0,0,any,1
+plyr,splitter_a,-1,0,0,"class<`indexed`, `indexed_array`, `list`, `split`>",1
+plyr,splitter_a,0,0,0,class<`array`>,1
+plyr,splitter_a,0,0,1,class<`data.frame`>,1
+plyr,splitter_a,1,0,0,double[],1
+plyr,splitter_a,2,0,0,any,1
+plyr,splitter_a,3,0,0,null,1
+plyr,splitter_d,-1,0,0,"class<`indexed`, `indexed_df`, `list`, `split`>",1
+plyr,splitter_d,0,0,0,class<`data.frame`>,1
+plyr,splitter_d,0,0,1,"class<`environment`, `idf`>",1
+plyr,splitter_d,1,0,0,class<`quoted`>,1
+plyr,splitter_d,2,0,0,logical,1
+plyr,strip_splits,-1,0,0,class<`data.frame`>,1
+plyr,strip_splits,0,0,0,class<`data.frame`>,1
+plyr,str_rep,-1,0,0,character,1
+plyr,str_rep,0,0,0,character,1
+plyr,str_rep,1,0,0,double,1
+plyr,summarise,-1,0,0,class<`data.frame`>,1
+plyr,summarise,0,0,0,class<`data.frame`>,1
+plyr,summarise,1,0,0,...,1
+plyr,take,-1,0,0,class<`array`>,1
+plyr,take,-1,0,1,class<`matrix`>,1
+plyr,take,0,0,0,class<`array`>,1
+plyr,take,1,0,0,double,1
+plyr,take,2,0,0,double,1
+plyr,take,3,0,0,logical,1
+plyr,try_default,-1,0,0,double,1
+plyr,try_default,-1,0,1,null,1
+plyr,try_default,0,0,0,any,1
+plyr,try_default,1,0,0,null,1
+plyr,try_default,2,0,0,logical,1
+plyr,txtTimerBar,-1,0,0,class<`txtProgressBar`>,1
+plyr,txtTimerBar,0,0,0,integer,1
+plyr,unrowname,-1,0,0,class<`data.frame`>,1
+plyr,unrowname,0,0,0,class<`data.frame`>,1
+plyr,vaggregate,-1,0,0,class<`matrix`>,1
+plyr,vaggregate,-1,0,1,double[],1
+plyr,vaggregate,-1,0,2,^integer[],1
+plyr,vaggregate,0,0,0,double[],1
+plyr,vaggregate,1,0,0,class<`factor`>,1
+plyr,vaggregate,1,0,1,integer[],1
+plyr,vaggregate,2,0,0,class<`function`>,1
+plyr,vaggregate,3,0,0,...,1
+plyr,vaggregate,4,0,0,^double[],1
+plyr,vaggregate,4,0,1,null,1
+plyr,vaggregate,5,0,0,double,1
+plyr,.wrapped_expr_to_fun,-1,0,0,list<class<`function`> | class<`data.frame`>>,1
+plyr,.wrapped_expr_to_fun,-1,0,1,list<class<`function`> | class<`histogram`>>,1
+plyr,.wrapped_expr_to_fun,-1,0,2,list<class<`function`> | class<`lm`>>,1
+plyr,.wrapped_expr_to_fun,-1,0,3,list<class<`function`> | class<`matrix`>>,1
+plyr,.wrapped_expr_to_fun,-1,0,4,list<class<`function`> | double[]>,1
+plyr,.wrapped_expr_to_fun,-1,0,5,list<class<`function`> | double>,1
+plyr,.wrapped_expr_to_fun,-1,0,6,list<class<`function`> | null>,1
+plyr,.wrapped_expr_to_fun,0,0,0,class<`function`>,1
+poLCA,poLCA,-1,0,0,class<`poLCA`>,1
+poLCA,poLCA,0,0,0,class<`formula`>,1
+poLCA,poLCA,1,0,0,class<`data.frame`>,1
+poLCA,poLCA,2,0,0,double,1
+poLCA,poLCA,3,0,0,double,1
+poLCA,poLCA,4,0,0,logical,1
+poLCA,poLCA,5,0,0,double,1
+poLCA,poLCA,6,0,0,logical,1
+poLCA,poLCA,7,0,0,null,1
+poLCA,poLCA,7,0,1,list<class<`matrix`>>,1
+poLCA,poLCA,8,0,0,double,1
+poLCA,poLCA,9,0,0,logical,1
+poLCA,poLCA,10,0,0,logical,1
+poLCA,poLCA.compress,-1,0,0,list<class<`matrix`> | double[]>,1
+poLCA,poLCA.compress,0,0,0,class<`matrix`>,1
+poLCA,poLCA.dLL2dBeta.C,-1,0,0,list<double[] | class<`matrix`>>,1
+poLCA,poLCA.dLL2dBeta.C,0,0,0,class<`matrix`>,1
+poLCA,poLCA.dLL2dBeta.C,1,0,0,class<`matrix`>,1
+poLCA,poLCA.dLL2dBeta.C,2,0,0,class<`matrix`>,1
+poLCA,poLCA.entropy,-1,0,0,double,1
+poLCA,poLCA.entropy,0,0,0,class<`poLCA`>,1
+poLCA,poLCA.postClass.C,-1,0,0,class<`matrix`>,1
+poLCA,poLCA.postClass.C,0,0,0,class<`matrix`>,1
+poLCA,poLCA.postClass.C,1,0,0,list<double[]>,1
+poLCA,poLCA.postClass.C,2,0,0,class<`matrix`>,1
+poLCA,poLCA.posterior,-1,0,0,class<`matrix`>,1
+poLCA,poLCA.posterior,0,0,0,class<`poLCA`>,1
+poLCA,poLCA.posterior,1,0,0,class<`matrix`>,1
+poLCA,poLCA.posterior,1,0,1,double[],1
+poLCA,poLCA.posterior,2,0,0,class<`matrix`>,1
+poLCA,poLCA.posterior,2,0,1,null,1
+poLCA,poLCA.posterior,2,0,2,double[],1
+poLCA,poLCA.predcell,-1,0,0,class<`matrix`>,1
+poLCA,poLCA.predcell,0,0,0,class<`poLCA`>,1
+poLCA,poLCA.predcell,1,0,0,class<`data.frame`>,1
+poLCA,poLCA.predcell,1,0,1,class<`matrix`>,1
+poLCA,poLCA.predcell,1,0,2,double[],1
+poLCA,poLCA.probHat.C,-1,0,0,double[],1
+poLCA,poLCA.probHat.C,0,0,0,class<`matrix`>,1
+poLCA,poLCA.probHat.C,1,0,0,class<`matrix`>,1
+poLCA,poLCA.probHat.C,2,0,0,list<double[]>,1
+poLCA,poLCA.reorder,-1,0,0,list<class<`matrix`>>,1
+poLCA,poLCA.reorder,0,0,0,list<class<`matrix`>>,1
+poLCA,poLCA.reorder,1,0,0,integer[],1
+poLCA,poLCA.se,-1,0,0,list<double[] | class<`matrix`> | list<class<`matrix`>>>,1
+poLCA,poLCA.se,-1,0,1,list<null | list<class<`matrix`>>>,1
+poLCA,poLCA.se,0,0,0,class<`matrix`>,1
+poLCA,poLCA.se,1,0,0,any,1
+poLCA,poLCA.se,2,0,0,list<class<`matrix`>>,1
+poLCA,poLCA.se,3,0,0,class<`matrix`>,1
+poLCA,poLCA.se,4,0,0,class<`matrix`>,1
+poLCA,poLCA.simdata,-1,0,0,list<any>,1
+poLCA,poLCA.simdata,0,0,0,double,1
+poLCA,poLCA.simdata,1,0,0,null,1
+poLCA,poLCA.simdata,1,0,1,list<class<`matrix`>>,1
+poLCA,poLCA.simdata,2,0,0,double,1
+poLCA,poLCA.simdata,3,0,0,double,1
+poLCA,poLCA.simdata,4,0,0,null,1
+poLCA,poLCA.simdata,5,0,0,null,1
+poLCA,poLCA.simdata,6,0,0,double,1
+poLCA,poLCA.simdata,7,0,0,class<`matrix`>,1
+poLCA,poLCA.simdata,7,0,1,null,1
+poLCA,poLCA.simdata,8,0,0,null,1
+poLCA,poLCA.simdata,8,0,1,double[],1
+poLCA,poLCA.simdata,9,0,0,logical,1
+poLCA,poLCA.simdata,10,0,0,null,1
+poLCA,poLCA.table,-1,0,0,class<`matrix`>,1
+poLCA,poLCA.table,0,0,0,class<`formula`>,1
+poLCA,poLCA.table,1,0,0,list<any>,1
+poLCA,poLCA.table,2,0,0,class<`poLCA`>,1
+poLCA,poLCA.unvectorize,-1,0,0,list<class<`matrix`>>,1
+poLCA,poLCA.unvectorize,0,0,0,list<double[]>,1
+poLCA,poLCA.updatePrior,-1,0,0,class<`matrix`>,1
+poLCA,poLCA.updatePrior,0,0,0,class<`matrix`>,1
+poLCA,poLCA.updatePrior,0,0,1,double[],1
+poLCA,poLCA.updatePrior,1,0,0,class<`matrix`>,1
+poLCA,poLCA.updatePrior,2,0,0,double,1
+poLCA,poLCA.vectorize,-1,0,0,list<double[]>,1
+poLCA,poLCA.vectorize,0,0,0,list<class<`matrix`>>,1
+poLCA,poLCA.ylik.C,-1,0,0,class<`matrix`>,1
+poLCA,poLCA.ylik.C,0,0,0,list<double[]>,1
+poLCA,poLCA.ylik.C,1,0,0,class<`matrix`>,1
+poLCA,poLCA.ylik.C,1,0,1,class<`data.frame`>,1
+poLCA,print.poLCA,-1,0,0,class<`poLCA`>,1
+poLCA,print.poLCA,0,0,0,class<`poLCA`>,1
+poLCA,print.poLCA,1,0,0,...,1
+poLCA,rmulti,-1,0,0,double[],1
+poLCA,rmulti,0,0,0,class<`matrix`>,1
+poLCA,rmulti,0,0,1,double[],1
+polyclip,aspolygonlist,-1,0,0,list<list<double[]>>,1
+polyclip,aspolygonlist,0,0,0,list<list<double[]>>,1
+polyclip,ensuredouble,-1,0,0,list<list<double[]>>,1
+polyclip,ensuredouble,0,0,0,list<list<double[]>>,1
+polyclip,ensurexydouble,-1,0,0,list<double[]>,1
+polyclip,ensurexydouble,0,0,0,list<integer[]>,1
+polyclip,ensurexydouble,0,0,1,list<double>,1
+polyclip,pointinpolygon,-1,0,0,integer,1
+polyclip,pointinpolygon,0,0,0,list<double>,1
+polyclip,pointinpolygon,1,0,0,list<integer[]>,1
+polyclip,pointinpolygon,2,0,0,any,1
+polyclip,pointinpolygon,3,0,0,any,1
+polyclip,pointinpolygon,4,0,0,any,1
+polyclip,polyclip,-1,0,0,list<list<double[]>>,1
+polyclip,polyclip,0,0,0,list<list<integer[]>>,1
+polyclip,polyclip,1,0,0,list<list<double[]>>,1
+polyclip,polyclip,2,0,0,character[],1
+polyclip,polyclip,3,0,0,...,1
+polyclip,polyclip,4,0,0,any,1
+polyclip,polyclip,5,0,0,any,1
+polyclip,polyclip,6,0,0,any,1
+polyclip,polyclip,7,0,0,character[],1
+polyclip,polyclip,8,0,0,character[],1
+polyclip,polyclip,9,0,0,logical,1
+polyclip,polylineoffset,-1,0,0,list<list<double[]>>,1
+polyclip,polylineoffset,0,0,0,list<list<double[]>>,1
+polyclip,polylineoffset,1,0,0,double,1
+polyclip,polylineoffset,2,0,0,...,1
+polyclip,polylineoffset,3,0,0,any,1
+polyclip,polylineoffset,4,0,0,any,1
+polyclip,polylineoffset,5,0,0,any,1
+polyclip,polylineoffset,6,0,0,double,1
+polyclip,polylineoffset,7,0,0,double,1
+polyclip,polylineoffset,8,0,0,character,1
+polyclip,polylineoffset,9,0,0,character,1
+polyclip,polyminkowski,-1,0,0,list<list<double[]>>,1
+polyclip,polyminkowski,0,0,0,list<list<double[]>>,1
+polyclip,polyminkowski,1,0,0,list<list<double[]>>,1
+polyclip,polyminkowski,2,0,0,...,1
+polyclip,polyminkowski,3,0,0,any,1
+polyclip,polyminkowski,4,0,0,any,1
+polyclip,polyminkowski,5,0,0,any,1
+polyclip,polyminkowski,6,0,0,logical,1
+polyclip,polyoffset,-1,0,0,list<list<double[]>>,1
+polyclip,polyoffset,0,0,0,list<list<double[]>>,1
+polyclip,polyoffset,1,0,0,double,1
+polyclip,polyoffset,2,0,0,...,1
+polyclip,polyoffset,3,0,0,any,1
+polyclip,polyoffset,4,0,0,any,1
+polyclip,polyoffset,5,0,0,any,1
+polyclip,polyoffset,6,0,0,double,1
+polyclip,polyoffset,7,0,0,double,1
+polyclip,polyoffset,8,0,0,character,1
+polyclip,polysimplify,-1,0,0,list<list<double[]>>,1
+polyclip,polysimplify,0,0,0,list<list<double[]>>,1
+polyclip,polysimplify,1,0,0,...,1
+polyclip,polysimplify,2,0,0,any,1
+polyclip,polysimplify,3,0,0,any,1
+polyclip,polysimplify,4,0,0,any,1
+polyclip,polysimplify,5,0,0,character,1
+polyclip,validpoly,-1,0,0,logical,1
+polyclip,validpoly,0,0,0,list<list<double[]>>,1
+polyclip,validxy,-1,0,0,logical,1
+polyclip,validxy,0,0,0,list<double>,1
+polyclip,validxy,0,0,1,list<integer[]>,1
+polyclip,xrange,-1,0,0,integer[],1
+polyclip,xrange,0,0,0,list<integer[]>,1
+polyclip,yrange,-1,0,0,integer[],1
+polyclip,yrange,0,0,0,list<integer[]>,1
+polycor,binBvn,-1,0,0,class<`matrix`>,1
+polycor,binBvn,0,0,0,double,1
+polycor,binBvn,1,0,0,double[],1
+polycor,binBvn,2,0,0,double[],1
+polycor,binBvn,3,0,0,any,1
+polycor,chisq,-1,0,0,double,1
+polycor,chisq,0,0,0,double[],1
+polycor,chisq,1,0,0,class<`matrix`>,1
+polycor,chisq,1,0,1,double[],1
+polycor,chisq,2,0,0,double,1
+polycor,chisq,3,0,0,any,1
+polycor,chisq,4,0,0,any,1
+polycor,chisq,5,0,0,double,1
+polycor,chisq,6,0,0,double,1
+polycor,hetcor,-1,0,0,class<`hetcor`>,1
+polycor,hetcor,0,0,0,class<`data.frame`>,1
+polycor,hetcor,0,0,1,double[],1
+polycor,hetcor,1,0,0,...,1
+polycor,hetcor,2,0,0,logical,1
+polycor,hetcor,3,0,0,logical,1
+polycor,hetcor,4,0,0,any,1
+polycor,hetcor,5,0,0,double,1
+polycor,hetcor,6,0,0,logical,1
+polycor,hetcor.data.frame,-1,0,0,class<`hetcor`>,1
+polycor,hetcor.data.frame,0,0,0,class<`data.frame`>,1
+polycor,hetcor.data.frame,1,0,0,logical,1
+polycor,hetcor.data.frame,2,0,0,logical,1
+polycor,hetcor.data.frame,3,0,0,character[],1
+polycor,hetcor.data.frame,4,0,0,double,1
+polycor,hetcor.data.frame,5,0,0,logical,1
+polycor,hetcor.data.frame,6,0,0,...,1
+polycor,hetcor.default,-1,0,0,class<`hetcor`>,1
+polycor,hetcor.default,0,0,0,double[],1
+polycor,hetcor.default,1,0,0,...,1
+polycor,hetcor.default,2,0,0,logical,1
+polycor,hetcor.default,3,0,0,logical,1
+polycor,hetcor.default,4,0,0,character[],1
+polycor,hetcor.default,5,0,0,double,1
+polycor,hetcor.default,6,0,0,logical,1
+polycor,polychor,-1,0,0,class<`polycor`>,1
+polycor,polychor,-1,0,1,double,1
+polycor,polychor,0,0,0,class<`factor`>,1
+polycor,polychor,1,0,0,class<`factor`>,1
+polycor,polychor,2,0,0,logical,1
+polycor,polychor,3,0,0,any,1
+polycor,polychor,4,0,0,logical,1
+polycor,polychor,5,0,0,double,1
+polycor,polyserial,-1,0,0,class<`polycor`>,1
+polycor,polyserial,-1,0,1,double,1
+polycor,polyserial,0,0,0,double[],1
+polycor,polyserial,1,0,0,class<`factor`>,1
+polycor,polyserial,2,0,0,logical,1
+polycor,polyserial,3,0,0,any,1
+polycor,polyserial,4,0,0,logical,1
+polycor,polyserial,5,0,0,double,1
+polycor,polyserial,6,0,0,double,1
+polynom,accumulate,-1,0,0,class<`polynomial`>,1
+polynom,accumulate,0,0,0,any,1
+polynom,accumulate,1,0,0,class<`polynomial`>,1
+polynom,accumulate,2,0,0,class<`polylist`>,1
+polynom,accumulate,3,0,0,logical,1
+polynom,as.character.polynomial,-1,0,0,character,1
+polynom,as.character.polynomial,0,0,0,class<`polynomial`>,1
+polynom,as.character.polynomial,1,0,0,logical,1
+polynom,as.character.polynomial,2,0,0,...,1
+polynom,as.function.polynomial,-1,0,0,class<`function`>,1
+polynom,as.function.polynomial,0,0,0,class<`polynomial`>,1
+polynom,as.function.polynomial,1,0,0,...,1
+polynom,as.polylist,-1,0,0,class<`polylist`>,1
+polynom,as.polylist,0,0,0,list<class<`polynomial`>>,1
+polynom,as.polynomial,-1,0,0,class<`polynomial`>,1
+polynom,as.polynomial,0,0,0,double[],1
+polynom,as.polynomial,0,0,1,class<`polynomial`>,1
+polynom,change.origin,-1,0,0,class<`polynomial`>,1
+polynom,change.origin,0,0,0,class<`polynomial`>,1
+polynom,change.origin,1,0,0,double,1
+polynom,coef.polynomial,-1,0,0,double[],1
+polynom,coef.polynomial,0,0,0,class<`polynomial`>,1
+polynom,coef.polynomial,1,0,0,...,1
+polynom,c.polylist,-1,0,0,class<`polylist`>,1
+polynom,c.polylist,0,0,0,...,1
+polynom,c.polylist,1,0,0,logical,1
+polynom,.degree,-1,0,0,double,1
+polynom,.degree,0,0,0,class<`polynomial`>,1
+polynom,deriv.polylist,-1,0,0,class<`polylist`>,1
+polynom,deriv.polylist,0,0,0,class<`polylist`>,1
+polynom,deriv.polylist,1,0,0,...,1
+polynom,deriv.polynomial,-1,0,0,class<`polynomial`>,1
+polynom,deriv.polynomial,0,0,0,class<`polynomial`>,1
+polynom,deriv.polynomial,1,0,0,...,1
+polynom,GCD,-1,0,0,class<`polynomial`>,1
+polynom,GCD,0,0,0,...,1
+polynom,.GCD2,-1,0,0,class<`polynomial`>,1
+polynom,.GCD2,0,0,0,any,1
+polynom,.GCD2,1,0,0,class<`polynomial`>,1
+polynom,GCD.polylist,-1,0,0,class<`polynomial`>,1
+polynom,GCD.polylist,0,0,0,...,1
+polynom,integral,-1,0,0,class<`polynomial`>,1
+polynom,integral,-1,0,1,class<`polylist`>,1
+polynom,integral,0,0,0,class<`polynomial`>,1
+polynom,integral,0,0,1,class<`polylist`>,1
+polynom,integral,1,0,0,...,1
+polynom,integral.polylist,-1,0,0,class<`polylist`>,1
+polynom,integral.polylist,0,0,0,class<`polylist`>,1
+polynom,integral.polylist,1,0,0,...,1
+polynom,integral.polynomial,-1,0,0,class<`polynomial`>,1
+polynom,integral.polynomial,0,0,0,class<`polynomial`>,1
+polynom,integral.polynomial,1,0,0,null,1
+polynom,integral.polynomial,2,0,0,...,1
+polynom,is.polylist,-1,0,0,logical,1
+polynom,is.polylist,0,0,0,class<`polylist`>,1
+polynom,is.polylist,0,0,1,class<`polynomial`>,1
+polynom,is.polylist,0,0,2,list<class<`polynomial`>>,1
+polynom,is.polynomial,-1,0,0,logical,1
+polynom,is.polynomial,0,0,0,class<`polynomial`>,1
+polynom,is.polynomial,0,0,1,double[],1
+polynom,.is_zero_polynomial,-1,0,0,logical,1
+polynom,.is_zero_polynomial,0,0,0,class<`polynomial`>,1
+polynom,LCM,-1,0,0,class<`polynomial`>,1
+polynom,LCM,0,0,0,...,1
+polynom,LCM.polylist,-1,0,0,class<`polynomial`>,1
+polynom,LCM.polylist,0,0,0,...,1
+polynom,lines.polynomial,-1,0,0,null,1
+polynom,lines.polynomial,0,0,0,class<`polynomial`>,1
+polynom,lines.polynomial,1,0,0,double,1
+polynom,lines.polynomial,2,0,0,null,1
+polynom,lines.polynomial,3,0,0,null,1
+polynom,lines.polynomial,4,0,0,...,1
+polynom,Math.polynomial,-1,0,0,class<`polynomial`>,1
+polynom,Math.polynomial,0,0,0,class<`polynomial`>,1
+polynom,Math.polynomial,1,0,0,...,1
+polynom,Ops.polynomial,-1,0,0,class<`polynomial`>,1
+polynom,Ops.polynomial,-1,0,1,logical,1
+polynom,Ops.polynomial,0,0,0,class<`polynomial`>,1
+polynom,Ops.polynomial,0,0,1,double,1
+polynom,Ops.polynomial,1,0,0,class<`polynomial`>,1
+polynom,Ops.polynomial,1,0,1,double,1
+polynom,plot.polylist,-1,0,0,null,1
+polynom,plot.polylist,0,0,0,class<`polylist`>,1
+polynom,plot.polylist,1,0,0,any,1
+polynom,plot.polylist,2,0,0,double[],1
+polynom,plot.polylist,3,0,0,character,1
+polynom,plot.polylist,4,0,0,double,1
+polynom,plot.polylist,5,0,0,...,1
+polynom,plot.polylist,6,0,0,character,1
+polynom,plot.polylist,7,0,0,character,1
+polynom,plot.polynomial,-1,0,0,null,1
+polynom,plot.polynomial,0,0,0,class<`polynomial`>,1
+polynom,plot.polynomial,1,0,0,any,1
+polynom,plot.polynomial,2,0,0,double[],1
+polynom,plot.polynomial,3,0,0,character,1
+polynom,plot.polynomial,4,0,0,double,1
+polynom,plot.polynomial,5,0,0,...,1
+polynom,plot.polynomial,6,0,0,character,1
+polynom,plot.polynomial,7,0,0,character,1
+polynom,points.polynomial,-1,0,0,null,1
+polynom,points.polynomial,0,0,0,class<`polynomial`>,1
+polynom,points.polynomial,1,0,0,double,1
+polynom,points.polynomial,2,0,0,...,1
+polynom,poly.calc,-1,0,0,class<`polylist`>,1
+polynom,poly.calc,-1,0,1,class<`polynomial`>,1
+polynom,poly.calc,0,0,0,class<`summary.polynomial`>,1
+polynom,poly.calc,0,0,1,complex[],1
+polynom,poly.calc,1,0,0,any,1
+polynom,poly.calc,2,0,0,any,1
+polynom,poly.calc,3,0,0,any,1
+polynom,poly.from.roots,-1,0,0,class<`polynomial`>,1
+polynom,poly.from.roots,0,0,0,...,1
+polynom,poly.from.values,-1,0,0,class<`polylist`>,1
+polynom,poly.from.values,-1,0,1,class<`polynomial`>,1
+polynom,poly.from.values,0,0,0,class<`summary.polynomial`>,1
+polynom,poly.from.values,0,0,1,complex[],1
+polynom,poly.from.values,1,0,0,any,1
+polynom,poly.from.values,2,0,0,any,1
+polynom,poly.from.values,3,0,0,any,1
+polynom,polylist,-1,0,0,class<`polylist`>,1
+polynom,polylist,0,0,0,...,1
+polynom,[.polylist,-1,0,0,class<`polylist`>,1
+polynom,[.polylist,0,0,0,class<`polylist`>,1
+polynom,[.polylist,1,0,0,double[],1
+polynom,.polylist_from_list,-1,0,0,class<`polylist`>,1
+polynom,.polylist_from_list,0,0,0,list<any>,1
+polynom,polynomial,-1,0,0,class<`polynomial`>,1
+polynom,polynomial,0,0,0,class<`polynomial`>,1
+polynom,polynomial,0,0,1,complex[],1
+polynom,poly.orth,-1,0,0,class<`polylist`>,1
+polynom,poly.orth,0,0,0,double[],1
+polynom,poly.orth,1,0,0,double,1
+polynom,poly.orth,2,0,0,logical,1
+polynom,predict.polynomial,-1,0,0,double[],1
+polynom,predict.polynomial,0,0,0,class<`polynomial`>,1
+polynom,predict.polynomial,1,0,0,double[],1
+polynom,predict.polynomial,2,0,0,...,1
+polynom,print.polynomial,-1,0,0,class<`polynomial`>,1
+polynom,print.polynomial,0,0,0,class<`polynomial`>,1
+polynom,print.polynomial,1,0,0,integer,1
+polynom,print.polynomial,2,0,0,logical,1
+polynom,print.polynomial,3,0,0,...,1
+polynom,rep.polylist,-1,0,0,class<`polylist`>,1
+polynom,rep.polylist,0,0,0,class<`polylist`>,1
+polynom,rep.polylist,1,0,0,double,1
+polynom,rep.polylist,2,0,0,...,1
+polynom,solve.polynomial,-1,0,0,complex[],1
+polynom,solve.polynomial,0,0,0,class<`polynomial`>,1
+polynom,solve.polynomial,1,0,0,any,1
+polynom,solve.polynomial,2,0,0,...,1
+polynom,Summary.polylist,-1,0,0,class<`polynomial`>,1
+polynom,Summary.polylist,0,0,0,...,1
+polynom,Summary.polylist,1,0,0,logical,1
+polynom,summary.polynomial,-1,0,0,class<`summary.polynomial`>,1
+polynom,summary.polynomial,0,0,0,class<`polynomial`>,1
+polynom,summary.polynomial,1,0,0,...,1
+polynom,unique.polylist,-1,0,0,class<`polylist`>,1
+polynom,unique.polylist,0,0,0,class<`polylist`>,1
+polynom,unique.polylist,1,0,0,logical,1
+polynom,unique.polylist,2,0,0,...,1
+ppcor,pcor,-1,0,0,list<class<`matrix`> | double | character>,1
+ppcor,pcor,0,0,0,class<`data.frame`>,1
+ppcor,pcor,1,0,0,character[],1
+ppcor,pcor.test,-1,0,0,class<`data.frame`>,1
+ppcor,pcor.test,0,0,0,double[],1
+ppcor,pcor.test,1,0,0,double[],1
+ppcor,pcor.test,2,0,0,class<`data.frame`>,1
+ppcor,pcor.test,3,0,0,character[],1
+ppcor,spcor,-1,0,0,list<class<`matrix`> | double | character>,1
+ppcor,spcor,0,0,0,class<`data.frame`>,1
+ppcor,spcor,1,0,0,character[],1
+ppcor,spcor.test,-1,0,0,class<`data.frame`>,1
+ppcor,spcor.test,0,0,0,double[],1
+ppcor,spcor.test,1,0,0,double[],1
+ppcor,spcor.test,2,0,0,class<`data.frame`>,1
+ppcor,spcor.test,3,0,0,character[],1
+prettyunits,%+%,-1,0,0,character,1
+prettyunits,%+%,0,0,0,character,1
+prettyunits,%+%,0,0,1,double,1
+prettyunits,%+%,1,0,0,character,1
+prettyunits,assert_diff_time,-1,0,0,null,1
+prettyunits,assert_diff_time,0,0,0,class<`difftime`>,1
+prettyunits,assert_string,-1,0,0,null,1
+prettyunits,assert_string,0,0,0,character,1
+prettyunits,compute_bytes,-1,0,0,class<`data.frame`>,1
+prettyunits,compute_bytes,0,0,0,double[],1
+prettyunits,compute_bytes,1,0,0,character,1
+prettyunits,parse_ms,-1,0,0,class<`data.frame`>,1
+prettyunits,parse_ms,0,0,0,double[],1
+prettyunits,pretty_bytes,-1,0,0,character[],1
+prettyunits,pretty_bytes,0,0,0,double[],1
+prettyunits,pretty_bytes,1,0,0,character[],1
+prettyunits,pretty_dt,-1,0,0,character,1
+prettyunits,pretty_dt,0,0,0,class<`difftime`>,1
+prettyunits,pretty_dt,1,0,0,logical,1
+prettyunits,pretty_ms,-1,0,0,character[],1
+prettyunits,pretty_ms,0,0,0,double[],1
+prettyunits,pretty_ms,1,0,0,logical,1
+prettyunits,pretty_sec,-1,0,0,character[],1
+prettyunits,pretty_sec,0,0,0,double[],1
+prettyunits,pretty_sec,1,0,0,logical,1
+prettyunits,%s%,-1,0,0,character,1
+prettyunits,%s%,0,0,0,character,1
+prettyunits,%s%,1,0,0,double,1
+prettyunits,time_ago,-1,0,0,character,1
+prettyunits,time_ago,0,0,0,"class<`POSIXct`, `POSIXt`>",1
+prettyunits,time_ago,1,0,0,character[],1
+prettyunits,trim,-1,0,0,character[],1
+prettyunits,trim,0,0,0,character[],1
+prettyunits,vague_dt,-1,0,0,character,1
+prettyunits,vague_dt,0,0,0,class<`difftime`>,1
+prettyunits,vague_dt,1,0,0,character[],1
+processx,%||%,-1,0,0,logical,1
+processx,%||%,0,0,0,null,1
+processx,%||%,1,0,0,logical,1
+processx,assert_that,-1,0,0,logical,1
+processx,assert_that,0,0,0,...,1
+processx,assert_that,1,0,0,environment,1
+processx,assert_that,2,0,0,null,1
+processx,check_result,-1,0,0,logical,1
+processx,check_result,0,0,0,logical,1
+processx,default_pty_options,-1,0,0,list<logical>,1
+processx,format_unix_time,-1,0,0,"class<`POSIXct`, `POSIXt`>",1
+processx,format_unix_time,0,0,0,double,1
+processx,get_id,-1,0,0,character,1
+processx,get_private,-1,0,0,environment,1
+processx,get_private,0,0,0,"class<`R6`, `process`>",1
+processx,is_connection_list,-1,0,0,logical,1
+processx,is_connection_list,0,0,0,list<any>,1
+processx,is_flag,-1,0,0,logical,1
+processx,is_flag,0,0,0,logical,1
+processx,is_integerish_scalar,-1,0,0,logical,1
+processx,is_integerish_scalar,0,0,0,double,1
+processx,is_list_of_pollables,-1,0,0,logical,1
+processx,is_list_of_pollables,0,0,0,"list<class<`R6`, `process`>>",1
+processx,is_named,-1,0,0,logical,1
+processx,is_named,0,0,0,list<any>,1
+processx,is_string,-1,0,0,logical,1
+processx,is_string,0,0,0,character,1
+processx,is_string_or_null,-1,0,0,logical,1
+processx,is_string_or_null,0,0,0,character,1
+processx,is_string_or_null,0,0,1,null,1
+processx,is_time_interval,-1,0,0,logical,1
+processx,is_time_interval,0,0,0,double,1
+processx,poll,-1,0,0,list<character[]>,1
+processx,poll,0,0,0,"list<class<`R6`, `process`>>",1
+processx,poll,1,0,0,double,1
+processx,process_close_connections,-1,0,0,null,1
+processx,process_close_connections,0,0,0,any,1
+processx,process_close_connections,1,0,0,environment,1
+processx,process_get_error_connection,-1,0,0,class<`processx_connection`>,1
+processx,process_get_error_connection,0,0,0,"class<`R6`, `process`>",1
+processx,process_get_error_connection,1,0,0,environment,1
+processx,process_get_exit_status,-1,0,0,integer,1
+processx,process_get_exit_status,0,0,0,any,1
+processx,process_get_exit_status,1,0,0,environment,1
+processx,process_get_output_connection,-1,0,0,class<`processx_connection`>,1
+processx,process_get_output_connection,0,0,0,"class<`R6`, `process`>",1
+processx,process_get_output_connection,1,0,0,environment,1
+processx,process_get_short_name,-1,0,0,character,1
+processx,process_get_short_name,0,0,0,any,1
+processx,process_get_short_name,1,0,0,environment,1
+processx,process_get_start_time,-1,0,0,"class<`POSIXct`, `POSIXt`>",1
+processx,process_get_start_time,0,0,0,any,1
+processx,process_get_start_time,1,0,0,environment,1
+processx,process_has_error_connection,-1,0,0,logical,1
+processx,process_has_error_connection,0,0,0,any,1
+processx,process_has_error_connection,1,0,0,environment,1
+processx,process_has_output_connection,-1,0,0,logical,1
+processx,process_has_output_connection,0,0,0,any,1
+processx,process_has_output_connection,1,0,0,environment,1
+processx,process_initialize,-1,0,0,"class<`R6`, `process`>",1
+processx,process_initialize,0,0,0,"class<`R6`, `process`>",1
+processx,process_initialize,1,0,0,environment,1
+processx,process_initialize,2,0,0,character,1
+processx,process_initialize,3,0,0,character[],1
+processx,process_initialize,4,0,0,null,1
+processx,process_initialize,5,0,0,character,1
+processx,process_initialize,6,0,0,character,1
+processx,process_initialize,7,0,0,logical,1
+processx,process_initialize,8,0,0,list<any>,1
+processx,process_initialize,9,0,0,list<any>,1
+processx,process_initialize,10,0,0,null,1
+processx,process_initialize,11,0,0,null,1
+processx,process_initialize,12,0,0,logical,1
+processx,process_initialize,13,0,0,logical,1
+processx,process_initialize,14,0,0,null,1
+processx,process_initialize,15,0,0,logical,1
+processx,process_initialize,16,0,0,logical,1
+processx,process_initialize,17,0,0,logical,1
+processx,process_initialize,18,0,0,logical,1
+processx,process_initialize,19,0,0,character,1
+processx,process_is_alive,-1,0,0,logical,1
+processx,process_is_alive,0,0,0,any,1
+processx,process_is_alive,1,0,0,environment,1
+processx,process_is_incompelete_error,-1,0,0,logical,1
+processx,process_is_incompelete_error,0,0,0,"class<`R6`, `process`>",1
+processx,process_is_incompelete_error,1,0,0,environment,1
+processx,process_is_incompelete_output,-1,0,0,logical,1
+processx,process_is_incompelete_output,0,0,0,"class<`R6`, `process`>",1
+processx,process_is_incompelete_output,1,0,0,environment,1
+processx,process_kill,-1,0,0,logical,1
+processx,process_kill,0,0,0,any,1
+processx,process_kill,1,0,0,environment,1
+processx,process_kill,2,0,0,double,1
+processx,process_kill,3,0,0,logical,1
+processx,process_poll_io,-1,0,0,character[],1
+processx,process_poll_io,0,0,0,"class<`R6`, `process`>",1
+processx,process_poll_io,1,0,0,any,1
+processx,process_poll_io,2,0,0,double,1
+processx,process_read_error,-1,0,0,character,1
+processx,process_read_error,0,0,0,"class<`R6`, `process`>",1
+processx,process_read_error,1,0,0,environment,1
+processx,process_read_error,2,0,0,double,1
+processx,process_read_output,-1,0,0,character,1
+processx,process_read_output,0,0,0,"class<`R6`, `process`>",1
+processx,process_read_output,1,0,0,environment,1
+processx,process_read_output,2,0,0,double,1
+processx,process_wait,-1,0,0,"class<`R6`, `process`>",1
+processx,process_wait,0,0,0,"class<`R6`, `process`>",1
+processx,process_wait,1,0,0,environment,1
+processx,process_wait,2,0,0,double,1
+processx,run,-1,0,0,list<integer | character>,1
+processx,run,0,0,0,character,1
+processx,run,1,0,0,character[],1
+processx,run,2,0,0,logical,1
+processx,run,3,0,0,null,1
+processx,run,4,0,0,logical,1
+processx,run,5,0,0,logical,1
+processx,run,6,0,0,logical,1
+processx,run,7,0,0,double,1
+processx,run,8,0,0,null,1
+processx,run,9,0,0,null,1
+processx,run,10,0,0,null,1
+processx,run,11,0,0,null,1
+processx,run,12,0,0,logical,1
+processx,run,13,0,0,null,1
+processx,run,14,0,0,logical,1
+processx,run,15,0,0,logical,1
+processx,run,16,0,0,character,1
+processx,run,17,0,0,logical,1
+processx,run,18,0,0,...,1
+processx,run_manage,-1,0,0,list<integer | character>,1
+processx,run_manage,0,0,0,"class<`R6`, `process`>",1
+processx,run_manage,1,0,0,double,1
+processx,run_manage,2,0,0,logical,1
+processx,run_manage,3,0,0,any,1
+processx,run_manage,4,0,0,any,1
+processx,run_manage,5,0,0,any,1
+processx,run_manage,6,0,0,any,1
+processx,run_manage,7,0,0,environment,1
+processx,see_if,-1,0,0,logical,1
+processx,see_if,0,0,0,...,1
+processx,see_if,1,0,0,environment,1
+processx,see_if,2,0,0,any,1
+processx,set_names,-1,0,0,character[],1
+processx,set_names,0,0,0,character[],1
+processx,set_names,1,0,0,character[],1
+processx,supervisor_reset,-1,0,0,null,1
+processx,supervisor_running,-1,0,0,logical,1
+prodlim,atRisk,-1,0,0,list<null>,1
+prodlim,atRisk,0,0,0,class<`prodlim`>,1
+prodlim,atRisk,1,0,0,class<`data.frame`>,1
+prodlim,atRisk,1,0,1,null,1
+prodlim,atRisk,2,0,0,double[],1
+prodlim,atRisk,3,0,0,any,1
+prodlim,atRisk,4,0,0,character[],1
+prodlim,atRisk,4,0,1,double[],1
+prodlim,atRisk,5,0,0,double,1
+prodlim,atRisk,5,0,1,null,1
+prodlim,atRisk,6,0,0,any,1
+prodlim,atRisk,7,0,0,any,1
+prodlim,backGround,-1,0,0,null,1
+prodlim,backGround,0,0,0,any,1
+prodlim,backGround,1,0,0,any,1
+prodlim,backGround,2,0,0,character[],1
+prodlim,backGround,3,0,0,character,1
+prodlim,backGround,4,0,0,double[],1
+prodlim,backGround,5,0,0,null,1
+prodlim,backGround,5,0,1,double[],1
+prodlim,backGround,6,0,0,character,1
+prodlim,centerBoxes,-1,0,0,double[],1
+prodlim,centerBoxes,0,0,0,double,1
+prodlim,centerBoxes,1,0,0,double[],1
+prodlim,centerBoxes,2,0,0,double,1
+prodlim,centerBoxes,3,0,0,double[],1
+prodlim,checkCauses,-1,0,0,any,1
+prodlim,checkCauses,0,0,0,character[],1
+prodlim,checkCauses,0,0,1,integer[],1
+prodlim,checkCauses,0,0,2,double,1
+prodlim,checkCauses,1,0,0,class<`prodlim`>,1
+prodlim,confInt,-1,0,0,list<null>,1
+prodlim,confInt,0,0,0,class<`prodlim`>,1
+prodlim,confInt,1,0,0,double[],1
+prodlim,confInt,2,0,0,null,1
+prodlim,confInt,2,0,1,class<`data.frame`>,1
+prodlim,confInt,3,0,0,character,1
+prodlim,confInt,4,0,0,character,1
+prodlim,confInt,5,0,0,character,1
+prodlim,confInt,5,0,1,null,1
+prodlim,confInt,6,0,0,double,1
+prodlim,confInt,6,0,1,character[],1
+prodlim,confInt,6,0,2,integer[],1
+prodlim,confInt,7,0,0,double[],1
+prodlim,crModel,-1,0,0,class<`lvm`>,1
+prodlim,dimColor,-1,0,0,character,1
+prodlim,dimColor,0,0,0,character,1
+prodlim,dimColor,0,0,1,double,1
+prodlim,dimColor,0,0,2,null,1
+prodlim,dimColor,1,0,0,double,1
+prodlim,EventHistory.frame,-1,0,0,class<`EventHistory.frame`>,1
+prodlim,EventHistory.frame,0,0,0,class<`formula`>,1
+prodlim,EventHistory.frame,1,0,0,class<`data.frame`>,1
+prodlim,EventHistory.frame,1,0,1,"class<`data.frame`, `data.table`>",1
+prodlim,EventHistory.frame,1,0,2,list<double[]>,1
+prodlim,EventHistory.frame,2,0,0,logical,1
+prodlim,EventHistory.frame,3,0,0,character[],1
+prodlim,EventHistory.frame,4,0,0,logical,1
+prodlim,EventHistory.frame,5,0,0,logical,1
+prodlim,EventHistory.frame,6,0,0,character[],1
+prodlim,EventHistory.frame,7,0,0,any,1
+prodlim,extract.name.from.special,-1,0,0,character[],1
+prodlim,extract.name.from.special,0,0,0,character[],1
+prodlim,extract.name.from.special,1,0,0,character,1
+prodlim,findArrow,-1,0,0,list<double[]>,1
+prodlim,findArrow,0,0,0,double[],1
+prodlim,findArrow,1,0,0,double[],1
+prodlim,findArrow,2,0,0,double[],1
+prodlim,findArrow,3,0,0,double[],1
+prodlim,findArrow,4,0,0,logical,1
+prodlim,getEvent,-1,0,0,class<`factor`>,1
+prodlim,getEvent,0,0,0,class<`Hist`>,1
+prodlim,getEvent,1,0,0,character,1
+prodlim,getEvent,2,0,0,character,1
+prodlim,getStates,-1,0,0,character[],1
+prodlim,getStates,0,0,0,class<`prodlim`>,1
+prodlim,getStates,0,0,1,class<`Hist`>,1
+prodlim,getStates,1,0,0,...,1
+prodlim,getStates.Hist,-1,0,0,character[],1
+prodlim,getStates.Hist,0,0,0,class<`Hist`>,1
+prodlim,getStates.Hist,1,0,0,...,1
+prodlim,getStates.prodlim,-1,0,0,character[],1
+prodlim,getStates.prodlim,0,0,0,class<`prodlim`>,1
+prodlim,getStates.prodlim,1,0,0,...,1
+prodlim,Hist,-1,0,0,class<`Hist`>,1
+prodlim,Hist,0,0,0,double[],1
+prodlim,Hist,0,0,1,list<^double[]>,1
+prodlim,Hist,1,0,0,any,1
+prodlim,Hist,2,0,0,null,1
+prodlim,Hist,2,0,1,double[],1
+prodlim,Hist,3,0,0,null,1
+prodlim,Hist,3,0,1,double[],1
+prodlim,Hist,4,0,0,character,1
+prodlim,Hist,4,0,1,double,1
+prodlim,Hist,5,0,0,logical,1
+prodlim,[.Hist,-1,0,0,class<`Hist`>,1
+prodlim,[.Hist,-1,0,1,double[],1
+prodlim,[.Hist,0,0,0,class<`Hist`>,1
+prodlim,[.Hist,1,0,0,any,1
+prodlim,[.Hist,2,0,0,any,1
+prodlim,[.Hist,3,0,0,logical,1
+prodlim,IntIndex,-1,0,0,list<integer[] | class<`matrix`>>,1
+prodlim,IntIndex,0,0,0,class<`matrix`>,1
+prodlim,IntIndex,1,0,0,double[],1
+prodlim,IntIndex,2,0,0,double[],1
+prodlim,jackknife,-1,0,0,class<`matrix`>,1
+prodlim,jackknife,0,0,0,class<`prodlim`>,1
+prodlim,jackknife,1,0,0,double[],1
+prodlim,jackknife,2,0,0,any,1
+prodlim,jackknife,3,0,0,logical,1
+prodlim,jackknife,4,0,0,...,1
+prodlim,jackknife.competing.risks,-1,0,0,class<`matrix`>,1
+prodlim,jackknife.competing.risks,0,0,0,class<`prodlim`>,1
+prodlim,jackknife.competing.risks,1,0,0,double[],1
+prodlim,jackknife.competing.risks,2,0,0,character,1
+prodlim,jackknife.competing.risks,3,0,0,logical,1
+prodlim,jackknife.competing.risks,4,0,0,...,1
+prodlim,jackknife.survival,-1,0,0,class<`matrix`>,1
+prodlim,jackknife.survival,0,0,0,class<`prodlim`>,1
+prodlim,jackknife.survival,1,0,0,double[],1
+prodlim,jackknife.survival,2,0,0,logical,1
+prodlim,jackknife.survival,3,0,0,...,1
+prodlim,leaveOneOut.competing.risks,-1,0,0,class<`matrix`>,1
+prodlim,leaveOneOut.competing.risks,0,0,0,class<`prodlim`>,1
+prodlim,leaveOneOut.competing.risks,1,0,0,double[],1
+prodlim,leaveOneOut.competing.risks,2,0,0,character,1
+prodlim,leaveOneOut.competing.risks,3,0,0,...,1
+prodlim,leaveOneOut.survival,-1,0,0,class<`matrix`>,1
+prodlim,leaveOneOut.survival,0,0,0,class<`prodlim`>,1
+prodlim,leaveOneOut.survival,1,0,0,double[],1
+prodlim,leaveOneOut.survival,2,0,0,double,1
+prodlim,leaveOneOut.survival,3,0,0,...,1
+prodlim,lifeTab,-1,0,0,class<`matrix`>,1
+prodlim,lifeTab,-1,0,1,list<class<`matrix`>>,1
+prodlim,lifeTab,-1,0,2,list<list<class<`matrix`>>>,1
+prodlim,lifeTab,0,0,0,class<`prodlim`>,1
+prodlim,lifeTab,1,0,0,...,1
+prodlim,lifeTab.competing.risks,-1,0,0,list<class<`matrix`>>,1
+prodlim,lifeTab.competing.risks,-1,0,1,list<list<class<`matrix`>>>,1
+prodlim,lifeTab.competing.risks,0,0,0,class<`prodlim`>,1
+prodlim,lifeTab.competing.risks,1,0,0,double[],1
+prodlim,lifeTab.competing.risks,2,0,0,character[],1
+prodlim,lifeTab.competing.risks,3,0,0,null,1
+prodlim,lifeTab.competing.risks,3,0,1,class<`data.frame`>,1
+prodlim,lifeTab.competing.risks,4,0,0,list<character[]>,1
+prodlim,lifeTab.competing.risks,4,0,1,null,1
+prodlim,lifeTab.competing.risks,5,0,0,integer,1
+prodlim,lifeTab.competing.risks,6,0,0,logical,1
+prodlim,lifeTab.competing.risks,7,0,0,logical,1
+prodlim,lifeTab.survival,-1,0,0,class<`matrix`>,1
+prodlim,lifeTab.survival,-1,0,1,list<class<`matrix`>>,1
+prodlim,lifeTab.survival,0,0,0,class<`prodlim`>,1
+prodlim,lifeTab.survival,1,0,0,double[],1
+prodlim,lifeTab.survival,2,0,0,any,1
+prodlim,lifeTab.survival,3,0,0,list<character[]>,1
+prodlim,lifeTab.survival,3,0,1,null,1
+prodlim,lifeTab.survival,4,0,0,integer,1
+prodlim,lifeTab.survival,5,0,0,logical,1
+prodlim,lifeTab.survival,6,0,0,logical,1
+prodlim,List2Matrix,-1,0,0,class<`matrix`>,1
+prodlim,List2Matrix,-1,0,1,class<`data.frame`>,1
+prodlim,List2Matrix,0,0,0,list<class<`matrix`>>,1
+prodlim,List2Matrix,0,0,1,list<class<`data.frame`>>,1
+prodlim,List2Matrix,0,0,2,list<list<class<`matrix`>>>,1
+prodlim,List2Matrix,1,0,0,double,1
+prodlim,List2Matrix,2,0,0,character[],1
+prodlim,meanNeighbors,-1,0,0,class<`data.frame`>,1
+prodlim,meanNeighbors,0,0,0,integer[],1
+prodlim,meanNeighbors,1,0,0,double[],1
+prodlim,meanNeighbors,2,0,0,...,1
+prodlim,model.design,-1,0,0,list<class<`data.frame`>>,1
+prodlim,model.design,-1,0,1,list<class<`data.frame`> | class<`matrix`>>,1
+prodlim,model.design,-1,0,2,list<class<`matrix`> | class<`data.frame`>>,1
+prodlim,model.design,-1,0,3,list<class<`matrix`>>,1
+prodlim,model.design,-1,0,4,list<null | class<`data.frame`>>,1
+prodlim,model.design,-1,0,5,list<null | class<`matrix`>>,1
+prodlim,model.design,0,0,0,"class<`formula`, `terms`>",1
+prodlim,model.design,1,0,0,class<`data.frame`>,1
+prodlim,model.design,2,0,0,null,1
+prodlim,model.design,2,0,1,list<integer[]>,1
+prodlim,model.design,3,0,0,logical,1
+prodlim,model.design,4,0,0,double,1
+prodlim,model.design,5,0,0,any,1
+prodlim,model.design,6,0,0,logical,1
+prodlim,model.design,7,0,0,logical,1
+prodlim,model.design,7,0,1,character,1
+prodlim,neighborhood,-1,0,0,class<`neighborhood`>,1
+prodlim,neighborhood,0,0,0,double[],1
+prodlim,neighborhood,1,0,0,null,1
+prodlim,neighborhood,2,0,0,character,1
+prodlim,neighbors,-1,0,0,list<class<`neighborhood`> | list<double[]>>,1
+prodlim,neighbors,0,0,0,integer[],1
+prodlim,neighbors,1,0,0,double[],1
+prodlim,neighbors,2,0,0,...,1
+prodlim,parseSpecialNames,-1,0,0,null,1
+prodlim,parseSpecialNames,-1,0,1,list<list<double | character>>,1
+prodlim,parseSpecialNames,-1,0,2,list<null>,1
+prodlim,parseSpecialNames,-1,0,3,list<list<character>>,1
+prodlim,parseSpecialNames,-1,0,4,list<list<character | double | character>>,1
+prodlim,parseSpecialNames,-1,0,5,list<list<double>>,1
+prodlim,parseSpecialNames,-1,0,6,list<list<character | character | null>>,1
+prodlim,parseSpecialNames,-1,0,7,list<list<character | double>>,1
+prodlim,parseSpecialNames,0,0,0,character[],1
+prodlim,parseSpecialNames,1,0,0,character,1
+prodlim,parseSpecialNames,2,0,0,any,1
+prodlim,PercentAxis,-1,0,0,double[],1
+prodlim,PercentAxis,0,0,0,double,1
+prodlim,PercentAxis,1,0,0,double[],1
+prodlim,PercentAxis,2,0,0,...,1
+prodlim,PetoInt,-1,0,0,class<`matrix`>,1
+prodlim,PetoInt,0,0,0,double[],1
+prodlim,PetoInt,1,0,0,double[],1
+prodlim,PetoInt,2,0,0,double[],1
+prodlim,plotCompetingRiskModel,-1,0,0,list<list<any>>,1
+prodlim,plotCompetingRiskModel,0,0,0,any,1
+prodlim,plotCompetingRiskModel,1,0,0,logical,1
+prodlim,plotCompetingRiskModel,2,0,0,...,1
+prodlim,plot.Hist,-1,0,0,list<list<any>>,1
+prodlim,plot.Hist,0,0,0,class<`Hist`>,1
+prodlim,plot.Hist,1,0,0,any,1
+prodlim,plot.Hist,2,0,0,any,1
+prodlim,plot.Hist,3,0,0,any,1
+prodlim,plot.Hist,4,0,0,any,1
+prodlim,plot.Hist,5,0,0,character,1
+prodlim,plot.Hist,6,0,0,character,1
+prodlim,plot.Hist,7,0,0,any,1
+prodlim,plotIllnessDeathModel,-1,0,0,list<list<any>>,1
+prodlim,plotIllnessDeathModel,0,0,0,any,1
+prodlim,plotIllnessDeathModel,1,0,0,double,1
+prodlim,plotIllnessDeathModel,2,0,0,logical,1
+prodlim,plotIllnessDeathModel,3,0,0,...,1
+prodlim,plot.prodlim,-1,0,0,any,1
+prodlim,plot.prodlim,0,0,0,class<`prodlim`>,1
+prodlim,plot.prodlim,1,0,0,any,1
+prodlim,plot.prodlim,2,0,0,any,1
+prodlim,plot.prodlim,3,0,0,any,1
+prodlim,plot.prodlim,4,0,0,any,1
+prodlim,plot.prodlim,5,0,0,logical,1
+prodlim,plot.prodlim,6,0,0,any,1
+prodlim,plot.prodlim,7,0,0,any,1
+prodlim,predictAbsrisk,-1,0,0,any,1
+prodlim,predictAbsrisk,0,0,0,class<`prodlim`>,1
+prodlim,predictAbsrisk,1,0,0,double[],1
+prodlim,predictAbsrisk,2,0,0,any,1
+prodlim,predictAbsrisk,3,0,0,double,1
+prodlim,predictAbsrisk,4,0,0,any,1
+prodlim,predictAbsrisk,5,0,0,character,1
+prodlim,predictAbsrisk,5,0,1,double,1
+prodlim,predictAbsrisk,6,0,0,...,1
+prodlim,predictList,-1,0,0,list<any>,1
+prodlim,predictList,0,0,0,class<`prodlim`>,1
+prodlim,predictList,1,0,0,double[],1
+prodlim,predictList,2,0,0,any,1
+prodlim,predictList,3,0,0,double,1
+prodlim,predict.prodlim,-1,0,0,any,1
+prodlim,predict.prodlim,0,0,0,class<`prodlim`>,1
+prodlim,predict.prodlim,1,0,0,double[],1
+prodlim,predict.prodlim,2,0,0,any,1
+prodlim,predict.prodlim,3,0,0,double,1
+prodlim,predict.prodlim,4,0,0,any,1
+prodlim,predict.prodlim,5,0,0,character,1
+prodlim,predict.prodlim,6,0,0,logical,1
+prodlim,predict.prodlim,7,0,0,any,1
+prodlim,predictSurv,-1,0,0,class<`matrix`>,1
+prodlim,predictSurv,-1,0,1,^double[],1
+prodlim,predictSurv,-1,0,2,list<^double[]>,1
+prodlim,predictSurv,0,0,0,class<`prodlim`>,1
+prodlim,predictSurv,1,0,0,double[],1
+prodlim,predictSurv,2,0,0,any,1
+prodlim,predictSurv,3,0,0,double,1
+prodlim,predictSurv,4,0,0,character,1
+prodlim,predictSurv,5,0,0,any,1
+prodlim,predictSurvIndividual,-1,0,0,double[],1
+prodlim,predictSurvIndividual,0,0,0,class<`prodlim`>,1
+prodlim,predictSurvIndividual,1,0,0,double,1
+prodlim,print.Hist,-1,0,0,list<double[] | class<`table`> | class<`data.frame`>>,1
+prodlim,print.Hist,0,0,0,class<`Hist`>,1
+prodlim,print.Hist,1,0,0,...,1
+prodlim,print.prodlim,-1,0,0,null,1
+prodlim,print.prodlim,0,0,0,class<`prodlim`>,1
+prodlim,print.prodlim,1,0,0,...,1
+prodlim,print.quantile.prodlim,-1,0,0,class<`quantile.prodlim`>,1
+prodlim,print.quantile.prodlim,0,0,0,class<`quantile.prodlim`>,1
+prodlim,print.quantile.prodlim,1,0,0,double,1
+prodlim,print.quantile.prodlim,2,0,0,character,1
+prodlim,print.quantile.prodlim,3,0,0,...,1
+prodlim,print.summary.prodlim,-1,0,0,class<`matrix`>,1
+prodlim,print.summary.prodlim,-1,0,1,list<class<`matrix`>>,1
+prodlim,print.summary.prodlim,0,0,0,class<`summary.prodlim`>,1
+prodlim,print.summary.prodlim,1,0,0,double,1
+prodlim,print.summary.prodlim,2,0,0,...,1
+prodlim,prodlim,-1,0,0,class<`prodlim`>,1
+prodlim,prodlim,0,0,0,class<`formula`>,1
+prodlim,prodlim,1,0,0,class<`data.frame`>,1
+prodlim,prodlim,1,0,1,"class<`data.frame`, `data.table`>",1
+prodlim,prodlim,1,0,2,list<double[]>,1
+prodlim,prodlim,2,0,0,any,1
+prodlim,prodlim,3,0,0,null,1
+prodlim,prodlim,4,0,0,logical,1
+prodlim,prodlim,5,0,0,double,1
+prodlim,prodlim,6,0,0,null,1
+prodlim,prodlim,7,0,0,any,1
+prodlim,prodlimIcensSurv,-1,0,0,class<`prodlim`>,1
+prodlim,prodlimIcensSurv,0,0,0,class<`Hist`>,1
+prodlim,prodlimIcensSurv,1,0,0,any,1
+prodlim,prodlimIcensSurv,2,0,0,double,1
+prodlim,prodlimIcensSurv,3,0,0,double,1
+prodlim,prodlimIcensSurv,4,0,0,logical,1
+prodlim,prodlimIcensSurv,5,0,0,any,1
+prodlim,quantile.prodlim,-1,0,0,class<`quantile.prodlim`>,1
+prodlim,quantile.prodlim,0,0,0,class<`prodlim`>,1
+prodlim,quantile.prodlim,1,0,0,any,1
+prodlim,quantile.prodlim,2,0,0,double,1
+prodlim,quantile.prodlim,3,0,0,...,1
+prodlim,redist,-1,0,0,list<class<`prodlim`> | class<`matrix`>>,1
+prodlim,redist,0,0,0,double[],1
+prodlim,redist,1,0,0,double[],1
+prodlim,row.match,-1,0,0,integer[],1
+prodlim,row.match,0,0,0,class<`data.frame`>,1
+prodlim,row.match,0,0,1,character[],1
+prodlim,row.match,1,0,0,class<`data.frame`>,1
+prodlim,row.match,2,0,0,null,1
+prodlim,SimCompRisk,-1,0,0,class<`data.frame`>,1
+prodlim,SimCompRisk,0,0,0,double,1
+prodlim,SimCompRisk,1,0,0,...,1
+prodlim,SimSurv,-1,0,0,class<`data.frame`>,1
+prodlim,SimSurv,0,0,0,double,1
+prodlim,SimSurv,1,0,0,...,1
+prodlim,sindex,-1,0,0,integer[],1
+prodlim,sindex,0,0,0,double[],1
+prodlim,sindex,1,0,0,double[],1
+prodlim,sindex,2,0,0,character,1
+prodlim,sindex,3,0,0,logical,1
+prodlim,SmartControl,-1,0,0,list<list<any>>,1
+prodlim,SmartControl,0,0,0,list<any>,1
+prodlim,SmartControl,1,0,0,character[],1
+prodlim,SmartControl,2,0,0,any,1
+prodlim,SmartControl,3,0,0,list<class<`data.frame`>>,1
+prodlim,SmartControl,3,0,1,list<class<`data.frame`> | list<double[]>>,1
+prodlim,SmartControl,3,0,2,list<list<any>>,1
+prodlim,SmartControl,4,0,0,any,1
+prodlim,SmartControl,5,0,0,any,1
+prodlim,SmartControl,6,0,0,logical,1
+prodlim,SmartControl,7,0,0,any,1
+prodlim,stopTime,-1,0,0,class<`Hist`>,1
+prodlim,stopTime,-1,0,1,class<`Surv`>,1
+prodlim,stopTime,0,0,0,class<`Hist`>,1
+prodlim,stopTime,0,0,1,class<`Surv`>,1
+prodlim,stopTime,1,0,0,double,1
+prodlim,strip.terms,-1,0,0,"class<`formula`, `terms`>",1
+prodlim,strip.terms,0,0,0,"class<`formula`, `terms`>",1
+prodlim,strip.terms,1,0,0,character[],1
+prodlim,strip.terms,2,0,0,null,1
+prodlim,strip.terms,2,0,1,list<character[]>,1
+prodlim,strip.terms,3,0,0,character,1
+prodlim,strip.terms,3,0,1,null,1
+prodlim,strip.terms,4,0,0,list<list<double>>,1
+prodlim,strip.terms,4,0,1,null,1
+prodlim,strip.terms,4,0,2,list<null>,1
+prodlim,strip.terms,4,0,3,list<list<character>>,1
+prodlim,strip.terms,5,0,0,logical,1
+prodlim,summary.Hist,-1,0,0,list<class<`table`> | class<`data.frame`>>,1
+prodlim,summary.Hist,-1,0,1,list<double[] | class<`table`> | class<`data.frame`>>,1
+prodlim,summary.Hist,0,0,0,class<`Hist`>,1
+prodlim,summary.Hist,1,0,0,logical,1
+prodlim,summary.Hist,2,0,0,...,1
+prodlim,summary.prodlim,-1,0,0,any,1
+prodlim,summary.prodlim,0,0,0,class<`prodlim`>,1
+prodlim,summary.prodlim,1,0,0,any,1
+prodlim,summary.prodlim,2,0,0,any,1
+prodlim,summary.prodlim,3,0,0,double,1
+prodlim,summary.prodlim,4,0,0,any,1
+prodlim,summary.prodlim,5,0,0,any,1
+prodlim,summary.prodlim,6,0,0,logical,1
+prodlim,summary.prodlim,7,0,0,logical,1
+prodlim,survModel,-1,0,0,class<`lvm`>,1
+promises,%...>%,-1,0,0,class<`promise`>,1
+promises,%...>%,0,0,0,"class<`ClusterFuture`, `Future`, `MultiprocessFuture`, `MultisessionFuture`, `environment`>",1
+promises,%...>%,0,0,1,class<`promise`>,1
+promises,%...>%,1,0,0,any,1
+promises,%...!%,-1,0,0,class<`promise`>,1
+promises,%...!%,0,0,0,"class<`ClusterFuture`, `Future`, `MultiprocessFuture`, `MultisessionFuture`, `environment`>",1
+promises,%...!%,1,0,0,any,1
+promises,as.promise,-1,0,0,class<`promise`>,1
+promises,as.promise,0,0,0,"class<`ClusterFuture`, `Future`, `MultiprocessFuture`, `MultisessionFuture`, `environment`>",1
+promises,as.promise,0,0,1,class<`promise`>,1
+promises,as.promise.Future,-1,0,0,class<`promise`>,1
+promises,as.promise.Future,0,0,0,"class<`ClusterFuture`, `Future`, `MultiprocessFuture`, `MultisessionFuture`, `environment`>",1
+promises,as.promise.promise,-1,0,0,class<`promise`>,1
+promises,as.promise.promise,0,0,0,class<`promise`>,1
+promises,catch,-1,0,0,class<`promise`>,1
+promises,catch,0,0,0,"class<`ClusterFuture`, `Future`, `MultiprocessFuture`, `MultisessionFuture`, `environment`>",1
+promises,catch,0,0,1,class<`promise`>,1
+promises,catch,1,0,0,class<`function`>,1
+promises,catch,2,0,0,logical,1
+promises,current_promise_domain,-1,0,0,null,1
+promises,has.visible,-1,0,0,logical,1
+promises,has.visible,0,0,0,class<`function`>,1
+promises,is_colexpr,-1,0,0,logical,1
+promises,is_colexpr,0,0,0,class<`call`>,1
+promises,is_first,-1,0,0,logical,1
+promises,is_first,0,0,0,class<`call`>,1
+promises,is_function,-1,0,0,logical,1
+promises,is_function,0,0,0,class<`call`>,1
+promises,is_function,0,0,1,class<`function`>,1
+promises,is_funexpr,-1,0,0,logical,1
+promises,is_funexpr,0,0,0,class<`{`>,1
+promises,is_funexpr,0,0,1,class<`call`>,1
+promises,is_funexpr,0,0,2,class<`function`>,1
+promises,is_lambda,-1,0,0,logical,1
+promises,is_lambda,0,0,0,class<`call`>,1
+promises,is_lambda,0,0,1,class<`function`>,1
+promises,is_parenthesized,-1,0,0,logical,1
+promises,is_parenthesized,0,0,0,class<`(`>,1
+promises,is_parenthesized,0,0,1,class<`{`>,1
+promises,is_parenthesized,0,0,2,class<`call`>,1
+promises,is.promising,-1,0,0,logical,1
+promises,is.promising,0,0,0,"class<`condition`, `error`, `simpleError`>",1
+promises,is.promising,0,0,1,class<`data.frame`>,1
+promises,is.promising,0,0,2,class<`promise`>,1
+promises,is.promising,0,0,3,double,1
+promises,normalizeOnFulfilled,-1,0,0,class<`function`>,1
+promises,normalizeOnFulfilled,-1,0,1,null,1
+promises,normalizeOnFulfilled,0,0,0,class<`function`>,1
+promises,normalizeOnFulfilled,0,0,1,"class<`function`, `rlang_lambda_function`>",1
+promises,normalizeOnFulfilled,0,0,2,null,1
+promises,normalizeOnRejected,-1,0,0,class<`function`>,1
+promises,normalizeOnRejected,-1,0,1,"class<`function`, `rlang_lambda_function`>",1
+promises,normalizeOnRejected,-1,0,2,null,1
+promises,normalizeOnRejected,0,0,0,class<`function`>,1
+promises,normalizeOnRejected,0,0,1,"class<`function`, `rlang_lambda_function`>",1
+promises,normalizeOnRejected,0,0,2,null,1
+promises,pipeify_rhs,-1,0,0,class<`function`>,1
+promises,pipeify_rhs,0,0,0,class<`(`>,1
+promises,pipeify_rhs,0,0,1,class<`{`>,1
+promises,pipeify_rhs,0,0,2,class<`call`>,1
+promises,pipeify_rhs,1,0,0,environment,1
+promises,prepare_first,-1,0,0,class<`call`>,1
+promises,prepare_first,0,0,0,class<`call`>,1
+promises,promise,-1,0,0,class<`promise`>,1
+promises,promise,0,0,0,class<`formula`>,1
+promises,promise,0,0,1,class<`function`>,1
+promises,promise_all,-1,0,0,class<`promise`>,1
+promises,promise_all,0,0,0,...,1
+promises,promise_all,1,0,0,null,1
+promises,promise_map,-1,0,0,class<`promise`>,1
+promises,promise_map,0,0,0,list<double>,1
+promises,promise_map,1,0,0,class<`function`>,1
+promises,promise_map,2,0,0,...,1
+promises,promise_race,-1,0,0,class<`promise`>,1
+promises,promise_race,0,0,0,...,1
+promises,promise_race,1,0,0,null,1
+promises,promise_reduce,-1,0,0,class<`promise`>,1
+promises,promise_reduce,0,0,0,integer[],1
+promises,promise_reduce,1,0,0,any,1
+promises,promise_reduce,2,0,0,...,1
+promises,promise_reduce,3,0,0,double,1
+promises,promise_reject,-1,0,0,class<`promise`>,1
+promises,promise_reject,0,0,0,character,1
+promises,promise_resolve,-1,0,0,class<`promise`>,1
+promises,promise_resolve,0,0,0,class<`data.frame`>,1
+promises,promise_resolve,0,0,1,class<`promise`>,1
+promises,promise_resolve,0,0,2,double,1
+promises,reject,-1,0,0,null,1
+promises,reject,0,0,0,character,1
+promises,resolve,-1,0,0,null,1
+promises,resolve,0,0,0,class<`data.frame`>,1
+promises,resolve,0,0,1,class<`promise`>,1
+promises,resolve,0,0,2,double,1
+promises,%...T>%,-1,0,0,class<`promise`>,1
+promises,%...T>%,0,0,0,class<`promise`>,1
+promises,%...T>%,1,0,0,any,1
+promises,%...T!%,-1,0,0,class<`promise`>,1
+promises,%...T!%,0,0,0,class<`promise`>,1
+promises,%...T!%,1,0,0,any,1
+promises,then,-1,0,0,class<`promise`>,1
+promises,then,0,0,0,"class<`ClusterFuture`, `Future`, `MultiprocessFuture`, `MultisessionFuture`, `environment`>",1
+promises,then,0,0,1,class<`promise`>,1
+promises,then,1,0,0,class<`function`>,1
+promises,then,1,0,1,class<`formula`>,1
+promises,then,2,0,0,null,1
+promises,then,2,0,1,class<`formula`>,1
+promises,then,2,0,2,class<`function`>,1
+promises,tryCatch,-1,0,0,class<`function`>,1
+promises,tryCatch,-1,0,1,class<`promise`>,1
+promises,tryCatch,-1,0,2,list<class<`function`>>,1
+promises,tryCatch,-1,0,3,list<class<`promise`>>,1
+promises,tryCatch,-1,0,4,null,1
+promises,tryCatch,0,0,0,class<`function`>,1
+promises,tryCatch,0,0,1,class<`promise`>,1
+promises,tryCatch,0,0,2,list<class<`function`>>,1
+promises,tryCatch,0,0,3,list<class<`promise`>>,1
+promises,tryCatch,0,0,4,null,1
+promises,tryCatch,1,0,0,...,1
+promises,tryCatch,2,0,0,any,1
+promises,without_promise_domain,-1,0,0,class<`promise`>,1
+promises,without_promise_domain,0,0,0,class<`promise`>,1
+promises,with_promise_domain,-1,0,0,class<`promise`>,1
+promises,with_promise_domain,0,0,0,null,1
+promises,with_promise_domain,1,0,0,class<`promise`>,1
+promises,with_promise_domain,2,0,0,logical,1
+proxy,.abcd_and_binary,-1,0,0,null,1
+proxy,.abcd_and_binary,0,0,0,"class<`proxy_registry_entry`, `registry_entry`>",1
+proxy,.abcd_and_binary,0,0,1,list<any>,1
+proxy,as.data.frame.proxy_registry,-1,0,0,class<`data.frame`>,1
+proxy,as.data.frame.proxy_registry,0,0,0,"class<`pr_DB`, `proxy_registry`>",1
+proxy,as.data.frame.proxy_registry,0,0,1,class<`proxy_registry`>,1
+proxy,as.data.frame.proxy_registry,1,0,0,...,1
+proxy,as.dist,-1,0,0,class<`dist`>,1
+proxy,as.dist,0,0,0,class<`matrix`>,1
+proxy,as.dist,1,0,0,null,1
+proxy,as.matrix,-1,0,0,class<`matrix`>,1
+proxy,as.matrix,0,0,0,character[],1
+proxy,as.matrix,0,0,1,double[],1
+proxy,as.matrix,0,0,2,class<`data.frame`>,1
+proxy,as.matrix,0,0,3,class<`dist`>,1
+proxy,as.matrix,0,0,4,"class<`dist`, `simil`>",1
+proxy,as.matrix,1,0,0,...,1
+proxy,as_matrix_dist,-1,0,0,class<`matrix`>,1
+proxy,as_matrix_dist,0,0,0,class<`dist`>,1
+proxy,as_matrix_dist,0,0,1,"class<`dist`, `simil`>",1
+proxy,as_matrix_dist,1,0,0,...,1
+proxy,as.matrix.dist,-1,0,0,class<`matrix`>,1
+proxy,as.matrix.dist,0,0,0,class<`dist`>,1
+proxy,as.matrix.dist,1,0,0,double,1
+proxy,as.matrix.dist,2,0,0,...,1
+proxy,as.matrix.simil,-1,0,0,class<`matrix`>,1
+proxy,as.matrix.simil,0,0,0,"class<`dist`, `simil`>",1
+proxy,as.matrix.simil,1,0,0,double,1
+proxy,as.matrix.simil,2,0,0,...,1
+proxy,as.simil,-1,0,0,"class<`dist`, `simil`>",1
+proxy,as.simil,0,0,0,class<`dist`>,1
+proxy,as.simil,1,0,0,class<`function`>,1
+proxy,col.dist,-1,0,0,integer[],1
+proxy,col.dist,0,0,0,class<`dist`>,1
+proxy,dim.dist,-1,0,0,integer[],1
+proxy,dim.dist,0,0,0,class<`dist`>,1
+proxy,dimnames<-.dist,-1,0,0,class<`dist`>,1
+proxy,dimnames<-.dist,0,0,0,class<`dist`>,1
+proxy,dimnames<-.dist,1,0,0,character[],1
+proxy,dimnames.dist,-1,0,0,character[],1
+proxy,dimnames.dist,0,0,0,class<`dist`>,1
+proxy,dist,-1,0,0,class<`crossdist`>,1
+proxy,dist,-1,0,1,class<`dist`>,1
+proxy,dist,-1,0,2,class<`pairdist`>,1
+proxy,dist,0,0,0,character[],1
+proxy,dist,0,0,1,class<`matrix`>,1
+proxy,dist,0,0,2,class<`data.frame`>,1
+proxy,dist,0,0,3,list<double[]>,1
+proxy,dist,1,0,0,character[],1
+proxy,dist,1,0,1,class<`matrix`>,1
+proxy,dist,1,0,2,class<`data.frame`>,1
+proxy,dist,1,0,3,list<double[]>,1
+proxy,dist,1,0,4,null,1
+proxy,dist,1,0,5,class<`function`>,1
+proxy,dist,2,0,0,character,1
+proxy,dist,2,0,1,null,1
+proxy,dist,3,0,0,...,1
+proxy,dist,4,0,0,logical,1
+proxy,dist,5,0,0,logical,1
+proxy,dist,6,0,0,logical,1
+proxy,dist,7,0,0,logical,1
+proxy,dist,8,0,0,logical,1
+proxy,dist,9,0,0,logical,1
+proxy,[[.dist,-1,0,0,class<`dist`>,1
+proxy,[[.dist,0,0,0,class<`dist`>,1
+proxy,[[.dist,1,0,0,double[],1
+proxy,[[.dist,2,0,0,...,1
+proxy,.FUNCall,-1,0,0,class<`function`>,1
+proxy,.FUNCall,0,0,0,any,1
+proxy,.functions_to_characters,-1,0,0,"class<`proxy_registry_entry`, `registry_entry`>",1
+proxy,.functions_to_characters,-1,0,1,"class<`registry_entry`, `simple.list`>",1
+proxy,.functions_to_characters,0,0,0,"class<`proxy_registry_entry`, `registry_entry`>",1
+proxy,.functions_to_characters,0,0,1,"class<`registry_entry`, `simple.list`>",1
+proxy,length.proxy_registry,-1,0,0,integer,1
+proxy,length.proxy_registry,0,0,0,"class<`pr_DB`, `proxy_registry`>",1
+proxy,names<-.dist,-1,0,0,class<`dist`>,1
+proxy,names<-.dist,0,0,0,class<`dist`>,1
+proxy,names<-.dist,1,0,0,character[],1
+proxy,names.dist,-1,0,0,character[],1
+proxy,names.dist,0,0,0,class<`dist`>,1
+proxy,pr_Canberra_prefun,-1,0,0,list<any>,1
+proxy,pr_Canberra_prefun,0,0,0,class<`matrix`>,1
+proxy,pr_Canberra_prefun,1,0,0,class<`matrix`>,1
+proxy,pr_Canberra_prefun,1,0,1,null,1
+proxy,pr_Canberra_prefun,2,0,0,logical,1
+proxy,pr_Canberra_prefun,3,0,0,list<any>,1
+proxy,pr_Canberra_prefun,4,0,0,"class<`proxy_registry_entry`, `registry_entry`>",1
+proxy,pr_cos_prefun,-1,0,0,list<any>,1
+proxy,pr_cos_prefun,0,0,0,class<`matrix`>,1
+proxy,pr_cos_prefun,1,0,0,class<`matrix`>,1
+proxy,pr_cos_prefun,1,0,1,null,1
+proxy,pr_cos_prefun,2,0,0,logical,1
+proxy,pr_cos_prefun,3,0,0,list<any>,1
+proxy,pr_cos_prefun,4,0,0,"class<`proxy_registry_entry`, `registry_entry`>",1
+proxy,pr_eDice_prefun,-1,0,0,list<any>,1
+proxy,pr_eDice_prefun,0,0,0,class<`matrix`>,1
+proxy,pr_eDice_prefun,1,0,0,class<`matrix`>,1
+proxy,pr_eDice_prefun,1,0,1,null,1
+proxy,pr_eDice_prefun,2,0,0,logical,1
+proxy,pr_eDice_prefun,3,0,0,list<any>,1
+proxy,pr_eDice_prefun,4,0,0,"class<`proxy_registry_entry`, `registry_entry`>",1
+proxy,pr_eJaccard_prefun,-1,0,0,list<any>,1
+proxy,pr_eJaccard_prefun,0,0,0,class<`matrix`>,1
+proxy,pr_eJaccard_prefun,1,0,0,class<`matrix`>,1
+proxy,pr_eJaccard_prefun,1,0,1,null,1
+proxy,pr_eJaccard_prefun,2,0,0,logical,1
+proxy,pr_eJaccard_prefun,3,0,0,list<any>,1
+proxy,pr_eJaccard_prefun,4,0,0,"class<`proxy_registry_entry`, `registry_entry`>",1
+proxy,pr_Euclidean_prefun,-1,0,0,list<any>,1
+proxy,pr_Euclidean_prefun,0,0,0,class<`matrix`>,1
+proxy,pr_Euclidean_prefun,0,0,1,list<double[]>,1
+proxy,pr_Euclidean_prefun,1,0,0,class<`matrix`>,1
+proxy,pr_Euclidean_prefun,1,0,1,null,1
+proxy,pr_Euclidean_prefun,1,0,2,list<double[]>,1
+proxy,pr_Euclidean_prefun,2,0,0,logical,1
+proxy,pr_Euclidean_prefun,3,0,0,list<any>,1
+proxy,pr_Euclidean_prefun,4,0,0,"class<`proxy_registry_entry`, `registry_entry`>",1
+proxy,pr_fJaccard_prefun,-1,0,0,list<any>,1
+proxy,pr_fJaccard_prefun,0,0,0,class<`matrix`>,1
+proxy,pr_fJaccard_prefun,1,0,0,class<`matrix`>,1
+proxy,pr_fJaccard_prefun,1,0,1,null,1
+proxy,pr_fJaccard_prefun,2,0,0,logical,1
+proxy,pr_fJaccard_prefun,3,0,0,list<any>,1
+proxy,pr_fJaccard_prefun,4,0,0,"class<`proxy_registry_entry`, `registry_entry`>",1
+proxy,pr_Gower_prefun,-1,0,0,list<any>,1
+proxy,pr_Gower_prefun,0,0,0,class<`matrix`>,1
+proxy,pr_Gower_prefun,1,0,0,class<`matrix`>,1
+proxy,pr_Gower_prefun,1,0,1,null,1
+proxy,pr_Gower_prefun,2,0,0,logical,1
+proxy,pr_Gower_prefun,3,0,0,list<any>,1
+proxy,pr_Gower_prefun,4,0,0,"class<`proxy_registry_entry`, `registry_entry`>",1
+proxy,pr_Jaccard_prefun,-1,0,0,list<any>,1
+proxy,pr_Jaccard_prefun,0,0,0,class<`matrix`>,1
+proxy,pr_Jaccard_prefun,1,0,0,class<`matrix`>,1
+proxy,pr_Jaccard_prefun,1,0,1,null,1
+proxy,pr_Jaccard_prefun,2,0,0,logical,1
+proxy,pr_Jaccard_prefun,3,0,0,list<any>,1
+proxy,pr_Jaccard_prefun,4,0,0,"class<`proxy_registry_entry`, `registry_entry`>",1
+proxy,pr_Levenshtein_prefun,-1,0,0,list<any>,1
+proxy,pr_Levenshtein_prefun,0,0,0,class<`matrix`>,1
+proxy,pr_Levenshtein_prefun,1,0,0,class<`matrix`>,1
+proxy,pr_Levenshtein_prefun,1,0,1,null,1
+proxy,pr_Levenshtein_prefun,2,0,0,logical,1
+proxy,pr_Levenshtein_prefun,3,0,0,list<any>,1
+proxy,pr_Levenshtein_prefun,4,0,0,"class<`proxy_registry_entry`, `registry_entry`>",1
+proxy,pr_Mahalanobis_prefun,-1,0,0,list<any>,1
+proxy,pr_Mahalanobis_prefun,0,0,0,class<`matrix`>,1
+proxy,pr_Mahalanobis_prefun,1,0,0,class<`matrix`>,1
+proxy,pr_Mahalanobis_prefun,1,0,1,null,1
+proxy,pr_Mahalanobis_prefun,2,0,0,logical,1
+proxy,pr_Mahalanobis_prefun,3,0,0,list<any>,1
+proxy,pr_Mahalanobis_prefun,4,0,0,"class<`proxy_registry_entry`, `registry_entry`>",1
+proxy,pr_Manhattan_prefun,-1,0,0,list<any>,1
+proxy,pr_Manhattan_prefun,0,0,0,class<`matrix`>,1
+proxy,pr_Manhattan_prefun,1,0,0,class<`matrix`>,1
+proxy,pr_Manhattan_prefun,1,0,1,null,1
+proxy,pr_Manhattan_prefun,2,0,0,logical,1
+proxy,pr_Manhattan_prefun,3,0,0,list<any>,1
+proxy,pr_Manhattan_prefun,4,0,0,"class<`proxy_registry_entry`, `registry_entry`>",1
+proxy,pr_Minkowski_prefun,-1,0,0,list<any>,1
+proxy,pr_Minkowski_prefun,0,0,0,class<`matrix`>,1
+proxy,pr_Minkowski_prefun,1,0,0,class<`matrix`>,1
+proxy,pr_Minkowski_prefun,1,0,1,null,1
+proxy,pr_Minkowski_prefun,2,0,0,logical,1
+proxy,pr_Minkowski_prefun,3,0,0,list<double>,1
+proxy,pr_Minkowski_prefun,4,0,0,"class<`proxy_registry_entry`, `registry_entry`>",1
+proxy,[[.proxy_registry,-1,0,0,"class<`proxy_registry_entry`, `registry_entry`>",1
+proxy,[[.proxy_registry,-1,0,1,"class<`registry_entry`, `simple.list`>",1
+proxy,[[.proxy_registry,0,0,0,"class<`pr_DB`, `proxy_registry`>",1
+proxy,[[.proxy_registry,0,0,1,class<`proxy_registry`>,1
+proxy,[[.proxy_registry,1,0,0,character,1
+proxy,pr_simil2dist,-1,0,0,class<`dist`>,1
+proxy,pr_simil2dist,-1,0,1,class<`matrix`>,1
+proxy,pr_simil2dist,-1,0,2,double[],1
+proxy,pr_simil2dist,0,0,0,class<`dist`>,1
+proxy,pr_simil2dist,0,0,1,class<`matrix`>,1
+proxy,pr_simil2dist,0,0,2,double[],1
+proxy,pr_supremum_prefun,-1,0,0,list<any>,1
+proxy,pr_supremum_prefun,0,0,0,class<`matrix`>,1
+proxy,pr_supremum_prefun,1,0,0,class<`matrix`>,1
+proxy,pr_supremum_prefun,1,0,1,null,1
+proxy,pr_supremum_prefun,2,0,0,logical,1
+proxy,pr_supremum_prefun,3,0,0,list<any>,1
+proxy,pr_supremum_prefun,4,0,0,"class<`proxy_registry_entry`, `registry_entry`>",1
+proxy,row.dist,-1,0,0,integer[],1
+proxy,row.dist,0,0,0,class<`dist`>,1
+proxy,rowMeans.dist,-1,0,0,double[],1
+proxy,rowMeans.dist,0,0,0,class<`dist`>,1
+proxy,rowMeans.dist,1,0,0,logical,1
+proxy,rowMeans.dist,2,0,0,logical,1
+proxy,rowSums.dist,-1,0,0,double[],1
+proxy,rowSums.dist,0,0,0,class<`dist`>,1
+proxy,rowSums.dist,1,0,0,logical,1
+proxy,subset.dist,-1,0,0,class<`dist`>,1
+proxy,subset.dist,0,0,0,class<`dist`>,1
+proxy,subset.dist,1,0,0,double[],1
+proxy,subset.dist,2,0,0,...,1
+proxy,summary.pr_DB,-1,0,0,class<`summary.pr_DB`>,1
+proxy,summary.pr_DB,0,0,0,"class<`pr_DB`, `proxy_registry`>",1
+proxy,summary.pr_DB,1,0,0,character[],1
+proxy,summary.pr_DB,2,0,0,...,1
+proxy,summary.proxy_registry,-1,0,0,class<`data.frame`>,1
+proxy,summary.proxy_registry,0,0,0,class<`proxy_registry`>,1
+proxy,summary.proxy_registry,1,0,0,...,1
+pryr,%||%,-1,0,0,character[],1
+pryr,%||%,0,0,0,character[],1
+pryr,%||%,1,0,0,any,1
+pryr,%.%,-1,0,0,class<`function`>,1
+pryr,%.%,0,0,0,class<`function`>,1
+pryr,%.%,1,0,0,class<`function`>,1
+pryr,%<a-%,-1,0,0,null,1
+pryr,%<a-%,0,0,0,any,1
+pryr,%<a-%,1,0,0,any,1
+pryr,address,-1,0,0,character,1
+pryr,address,0,0,0,any,1
+pryr,address2,-1,0,0,character,1
+pryr,address2,0,0,0,class<`name`>,1
+pryr,address2,1,0,0,environment,1
+pryr,all_named,-1,0,0,logical,1
+pryr,all_named,0,0,0,pairlist,1
+pryr,as.envlist,-1,0,0,class<`envlist`>,1
+pryr,as.envlist,0,0,0,list<environment>,1
+pryr,ast,-1,0,0,null,1
+pryr,ast,0,0,0,any,1
+pryr,binary_repr,-1,0,0,character,1
+pryr,binary_repr,0,0,0,character,1
+pryr,binary_repr,0,0,1,null,1
+pryr,bits,-1,0,0,character,1
+pryr,bits,0,0,0,character,1
+pryr,bits,0,0,1,null,1
+pryr,bits,1,0,0,logical,1
+pryr,bytes,-1,0,0,character,1
+pryr,bytes,0,0,0,character,1
+pryr,bytes,0,0,1,double,1
+pryr,bytes,0,0,2,null,1
+pryr,bytes,1,0,0,logical,1
+pryr,%<c-%,-1,0,0,double,1
+pryr,%<c-%,0,0,0,any,1
+pryr,%<c-%,1,0,0,double,1
+pryr,call_tree,-1,0,0,null,1
+pryr,call_tree,0,0,0,class<`call`>,1
+pryr,call_tree,0,0,1,class<`if`>,1
+pryr,call_tree,0,0,2,expression,1
+pryr,call_tree,1,0,0,integer,1
+pryr,check_name,-1,0,0,class<`name`>,1
+pryr,check_name,0,0,0,class<`name`>,1
+pryr,compact,-1,0,0,list<character[]>,1
+pryr,compact,0,0,0,list<character[] | null>,1
+pryr,compact,0,0,1,list<null | character[]>,1
+pryr,compare_size,-1,0,0,double[],1
+pryr,compare_size,0,0,0,class<`formula`>,1
+pryr,compare_size,0,0,1,list<integer[]>,1
+pryr,compose,-1,0,0,double,1
+pryr,compose,0,0,0,...,1
+pryr,compose,-1,1,0,class<`function`>,1
+pryr,compose,0,1,0,...,1
+pryr,%<d-%,-1,0,0,null,1
+pryr,%<d-%,0,0,0,any,1
+pryr,%<d-%,1,0,0,any,1
+pryr,dots,-1,0,0,list<double | class<`name`>>,1
+pryr,dots,0,0,0,...,1
+pryr,enclosing_env,-1,0,0,environment,1
+pryr,enclosing_env,0,0,0,character,1
+pryr,[.envlist,-1,0,0,class<`envlist`>,1
+pryr,[.envlist,0,0,0,class<`envlist`>,1
+pryr,[.envlist,1,0,0,double,1
+pryr,[.envlist,1,0,1,integer[],1
+pryr,f,-1,0,0,class<`function`>,1
+pryr,f,0,0,0,...,1
+pryr,f,1,0,0,environment,1
+pryr,fget,-1,0,0,class<`function`>,1
+pryr,fget,0,0,0,character,1
+pryr,fget,1,0,0,environment,1
+pryr,find_funs,-1,0,0,character[],1
+pryr,find_funs,0,0,0,character,1
+pryr,find_funs,1,0,0,class<`function`>,1
+pryr,find_funs,2,0,0,character,1
+pryr,find_funs,3,0,0,...,1
+pryr,find_generic,-1,0,0,character[],1
+pryr,find_generic,-1,0,1,null,1
+pryr,find_generic,0,0,0,character,1
+pryr,find_generic,1,0,0,any,1
+pryr,find_uses,-1,0,0,list<character[]>,1
+pryr,find_uses,0,0,0,character[],1
+pryr,find_uses,1,0,0,character[],1
+pryr,find_uses,2,0,0,logical,1
+pryr,ftype,-1,0,0,character[],1
+pryr,ftype,0,0,0,class<`function`>,1
+pryr,fun_body,-1,0,0,character[],1
+pryr,fun_body,0,0,0,class<`function`>,1
+pryr,fun_calls,-1,0,0,character[],1
+pryr,fun_calls,-1,0,1,null,1
+pryr,fun_calls,0,0,0,any,1
+pryr,hex_repr,-1,0,0,character,1
+pryr,hex_repr,0,0,0,character,1
+pryr,hex_repr,0,0,1,double,1
+pryr,hex_repr,0,0,2,null,1
+pryr,internal_generics,-1,0,0,character[],1
+pryr,internal_name,-1,0,0,character,1
+pryr,internal_name,0,0,0,class<`function`>,1
+pryr,is_active_binding,-1,0,0,logical,1
+pryr,is_active_binding,0,0,0,any,1
+pryr,is_internal,-1,0,0,logical,1
+pryr,is_internal,0,0,0,class<`function`>,1
+pryr,is_internal_generic,-1,0,0,logical,1
+pryr,is_internal_generic,0,0,0,character,1
+pryr,is_promise,-1,0,0,logical,1
+pryr,is_promise,0,0,0,any,1
+pryr,is_promise2,-1,0,0,logical,1
+pryr,is_promise2,0,0,0,class<`name`>,1
+pryr,is_promise2,1,0,0,environment,1
+pryr,is_s3_generic,-1,0,0,logical,1
+pryr,is_s3_generic,0,0,0,character,1
+pryr,is_s3_generic,1,0,0,environment,1
+pryr,is_s3_method,-1,0,0,logical,1
+pryr,is_s3_method,0,0,0,character,1
+pryr,is_s3_method,1,0,0,any,1
+pryr,make_call,-1,0,0,class<`call`>,1
+pryr,make_call,0,0,0,character,1
+pryr,make_call,0,0,1,class<`call`>,1
+pryr,make_call,0,0,2,class<`name`>,1
+pryr,make_call,1,0,0,...,1
+pryr,make_call,2,0,0,list<any>,1
+pryr,make_function,-1,0,0,class<`function`>,1
+pryr,make_function,0,0,0,pairlist,1
+pryr,make_function,0,0,1,list<class<`name`>>,1
+pryr,make_function,0,0,2,list<class<`name`> | double>,1
+pryr,make_function,1,0,0,class<`call`>,1
+pryr,make_function,1,0,1,class<`{`>,1
+pryr,make_function,2,0,0,environment,1
+pryr,matched_calls,-1,0,0,character[],1
+pryr,matched_calls,-1,0,1,null,1
+pryr,matched_calls,0,0,0,class<`function`>,1
+pryr,matched_calls,0,0,1,class<`selfStart`>,1
+pryr,matched_calls,0,0,2,character[],1
+pryr,matched_calls,0,0,3,class<`simple.list`>,1
+pryr,matched_calls,0,0,4,class<`SweaveSyntax`>,1
+pryr,matched_calls,0,0,5,double,1
+pryr,matched_calls,1,0,0,any,1
+pryr,matched_calls,2,0,0,any,1
+pryr,mem_change,-1,0,0,class<`bytes`>,1
+pryr,mem_change,0,0,0,any,1
+pryr,mem_used,-1,0,0,class<`bytes`>,1
+pryr,method_from_call,-1,0,0,class<`function`>,1
+pryr,method_from_call,-1,0,1,class<`MethodDefinition`>,1
+pryr,method_from_call,0,0,0,any,1
+pryr,method_from_call,1,0,0,environment,1
+pryr,modify_call,-1,0,0,class<`call`>,1
+pryr,modify_call,0,0,0,class<`call`>,1
+pryr,modify_call,1,0,0,list<class<`name`>>,1
+pryr,modify_call,1,0,1,list<null>,1
+pryr,modify_call,1,0,2,list<double>,1
+pryr,modify_lang,-1,0,0,class<`<-`>,1
+pryr,modify_lang,-1,0,1,class<`call`>,1
+pryr,modify_lang,-1,0,2,class<`function`>,1
+pryr,modify_lang,-1,0,3,class<`name`>,1
+pryr,modify_lang,-1,0,4,double,1
+pryr,modify_lang,-1,0,5,expression,1
+pryr,modify_lang,-1,0,6,list<any>,1
+pryr,modify_lang,-1,0,7,pairlist,1
+pryr,modify_lang,0,0,0,class<`<-`>,1
+pryr,modify_lang,0,0,1,class<`call`>,1
+pryr,modify_lang,0,0,2,class<`function`>,1
+pryr,modify_lang,0,0,3,class<`name`>,1
+pryr,modify_lang,0,0,4,double,1
+pryr,modify_lang,0,0,5,expression,1
+pryr,modify_lang,0,0,6,list<any>,1
+pryr,modify_lang,0,0,7,pairlist,1
+pryr,modify_lang,1,0,0,class<`function`>,1
+pryr,modify_lang,2,0,0,...,1
+pryr,named2,-1,0,0,integer,1
+pryr,named2,0,0,0,class<`name`>,1
+pryr,named2,1,0,0,environment,1
+pryr,named_dots,-1,0,0,list<double | class<`name`>>,1
+pryr,named_dots,0,0,0,...,1
+pryr,names_c,-1,0,0,class<`data.frame`>,1
+pryr,node_size,-1,0,0,integer,1
+pryr,object_size,-1,0,0,class<`bytes`>,1
+pryr,object_size,0,0,0,...,1
+pryr,object_size,1,0,0,environment,1
+pryr,object_sizes,-1,0,0,double,1
+pryr,object_sizes,0,0,0,list<class<`formula`>>,1
+pryr,object_sizes,0,0,1,list<integer[] | list<integer[]>>,1
+pryr,object_sizes,0,0,2,list<integer[]>,1
+pryr,object_sizes,0,0,3,list<list<integer[]>>,1
+pryr,object_sizes,1,0,0,environment,1
+pryr,otype,-1,0,0,character,1
+pryr,otype,0,0,0,class<`data.frame`>,1
+pryr,otype,0,0,1,integer[],1
+pryr,parent_promise,-1,0,0,class<`call`>,1
+pryr,parent_promise,0,0,0,any,1
+pryr,parenv,-1,0,0,environment,1
+pryr,parenv,0,0,0,class<`function`>,1
+pryr,parenv,1,0,0,double,1
+pryr,parenvs,-1,0,0,class<`envlist`>,1
+pryr,parenvs,0,0,0,class<`function`>,1
+pryr,parenvs,0,0,1,environment,1
+pryr,parenvs,1,0,0,logical,1
+pryr,partial,-1,0,0,class<`function`>,1
+pryr,partial,0,0,0,class<`function`>,1
+pryr,partial,1,0,0,...,1
+pryr,partial,2,0,0,environment,1
+pryr,partial,3,0,0,logical,1
+pryr,primitive_name,-1,0,0,character,1
+pryr,primitive_name,0,0,0,class<`function`>,1
+pryr,print.envlist,-1,0,0,class<`envlist`>,1
+pryr,print.envlist,0,0,0,class<`envlist`>,1
+pryr,print.envlist,1,0,0,logical,1
+pryr,print.envlist,2,0,0,logical,1
+pryr,print.envlist,3,0,0,...,1
+pryr,promise_code,-1,0,0,class<`call`>,1
+pryr,promise_code,-1,0,1,class<`name`>,1
+pryr,promise_code,0,0,0,class<`name`>,1
+pryr,promise_code,1,0,0,environment,1
+pryr,rebind,-1,0,0,double,1
+pryr,rebind,0,0,0,character,1
+pryr,rebind,1,0,0,double,1
+pryr,rebind,2,0,0,environment,1
+pryr,refs,-1,0,0,integer,1
+pryr,refs,0,0,0,any,1
+pryr,show_bytes,-1,0,0,class<`bytes`>,1
+pryr,show_bytes,0,0,0,class<`bytes`>,1
+pryr,show_bytes,0,0,1,double,1
+pryr,show_c_source,-1,0,0,null,1
+pryr,show_c_source,0,0,0,any,1
+pryr,slice,-1,0,0,character,1
+pryr,slice,0,0,0,character,1
+pryr,slice,1,0,0,integer,1
+pryr,slice,2,0,0,character,1
+pryr,standardise_call,-1,0,0,class<`call`>,1
+pryr,standardise_call,0,0,0,class<`call`>,1
+pryr,standardise_call,1,0,0,environment,1
+pryr,stop_list,-1,0,0,character[],1
+pryr,str_trunc,-1,0,0,character,1
+pryr,str_trunc,0,0,0,character,1
+pryr,str_trunc,1,0,0,double,1
+pryr,subs,-1,0,0,class<`call`>,1
+pryr,subs,0,0,0,any,1
+pryr,subs,1,0,0,environment,1
+pryr,substitute_q,-1,0,0,class<`call`>,1
+pryr,substitute_q,0,0,0,class<`call`>,1
+pryr,substitute_q,1,0,0,environment,1
+pryr,substitute_q,1,0,1,list<double>,1
+pryr,substitute_q,1,0,2,list<double | character[]>,1
+pryr,to_env,-1,0,0,environment,1
+pryr,to_env,0,0,0,character,1
+pryr,to_env,0,0,1,class<`function`>,1
+pryr,to_env,0,0,2,environment,1
+pryr,to_env,0,0,3,list<double>,1
+pryr,to_env,0,0,4,list<double | character[]>,1
+pryr,to_env,1,0,0,logical,1
+pryr,track_copy,-1,0,0,class<`function`>,1
+pryr,track_copy,0,0,0,any,1
+pryr,track_copy,1,0,0,environment,1
+pryr,track_copy,2,0,0,logical,1
+pryr,tree,-1,0,0,character,1
+pryr,tree,0,0,0,class<`{`>,1
+pryr,tree,0,0,1,class<`call`>,1
+pryr,tree,0,0,2,class<`name`>,1
+pryr,tree,0,0,3,double,1
+pryr,tree,0,0,4,null,1
+pryr,tree,0,0,5,pairlist,1
+pryr,tree,0,0,6,class<`if`>,1
+pryr,tree,1,0,0,double,1
+pryr,tree,2,0,0,double,1
+pryr,tree,3,0,0,character,1
+pryr,typename,-1,0,0,character,1
+pryr,typename,0,0,0,any,1
+pryr,typename2,-1,0,0,character,1
+pryr,typename2,0,0,0,class<`name`>,1
+pryr,typename2,1,0,0,environment,1
+pryr,unenclose,-1,0,0,class<`function`>,1
+pryr,unenclose,0,0,0,class<`function`>,1
+pryr,uneval,-1,0,0,class<`call`>,1
+pryr,uneval,0,0,0,any,1
+pryr,where,-1,0,0,environment,1
+pryr,where,0,0,0,character,1
+pryr,where,1,0,0,environment,1
+purrr,%@%,-1,0,0,character[],1
+purrr,%@%,0,0,0,class<`factor`>,1
+purrr,%@%,0,0,1,class<`data.frame`>,1
+purrr,%@%,1,0,0,character,1
+purrr,accum_index,-1,0,0,integer[],1
+purrr,accum_index,0,0,0,list<character | null>,1
+purrr,accum_index,0,0,1,list<integer | null>,1
+purrr,accum_index,0,0,2,list<null | character>,1
+purrr,accum_index,0,0,3,list<null | integer>,1
+purrr,accum_index,1,0,0,logical,1
+purrr,accum_init,-1,0,0,list<character | null>,1
+purrr,accum_init,-1,0,1,list<integer | null>,1
+purrr,accum_init,-1,0,2,list<null | character>,1
+purrr,accum_init,-1,0,3,list<null | integer>,1
+purrr,accum_init,0,0,0,character,1
+purrr,accum_init,0,0,1,integer,1
+purrr,accum_init,1,0,0,integer[],1
+purrr,accum_init,2,0,0,logical,1
+purrr,accumulate,-1,0,0,character[],1
+purrr,accumulate,-1,0,1,integer[],1
+purrr,accumulate,0,0,0,character[],1
+purrr,accumulate,0,0,1,integer[],1
+purrr,accumulate,1,0,0,class<`function`>,1
+purrr,accumulate,2,0,0,...,1
+purrr,accumulate,3,0,0,any,1
+purrr,accumulate,4,0,0,character[],1
+purrr,accumulate2,-1,0,0,list<character>,1
+purrr,accumulate2,0,0,0,character[],1
+purrr,accumulate2,1,0,0,character[],1
+purrr,accumulate2,2,0,0,class<`function`>,1
+purrr,accumulate2,3,0,0,...,1
+purrr,accumulate2,4,0,0,any,1
+purrr,accumulate_names,-1,0,0,null,1
+purrr,accumulate_names,0,0,0,null,1
+purrr,accumulate_names,1,0,0,any,1
+purrr,accumulate_names,2,0,0,any,1
+purrr,array_branch,-1,0,0,list<class<`matrix`>>,1
+purrr,array_branch,-1,0,1,list<integer[]>,1
+purrr,array_branch,0,0,0,class<`array`>,1
+purrr,array_branch,0,0,1,integer[],1
+purrr,array_branch,0,0,2,class<`matrix`>,1
+purrr,array_branch,1,0,0,null,1
+purrr,array_branch,1,0,1,double[],1
+purrr,array_tree,-1,0,0,list<list<integer[]>>,1
+purrr,array_tree,-1,0,1,list<list<list<integer>>>,1
+purrr,array_tree,-1,0,2,list<integer[]>,1
+purrr,array_tree,0,0,0,class<`array`>,1
+purrr,array_tree,0,0,1,integer[],1
+purrr,array_tree,0,0,2,class<`matrix`>,1
+purrr,array_tree,1,0,0,double[],1
+purrr,array_tree,1,0,1,null,1
+purrr,as_invoke_function,-1,0,0,character[],1
+purrr,as_invoke_function,-1,0,1,list<class<`function`>>,1
+purrr,as_invoke_function,0,0,0,character[],1
+purrr,as_invoke_function,0,0,1,list<class<`function`>>,1
+purrr,as_mapper,-1,0,0,class<`function`>,1
+purrr,as_mapper,-1,0,1,"class<`function`, `purrr_function_compose`>",1
+purrr,as_mapper,-1,0,2,"class<`function`, `purrr_function_partial`>",1
+purrr,as_mapper,-1,0,3,"class<`function`, `rlang_lambda_function`>",1
+purrr,as_mapper,0,0,0,character[],1
+purrr,as_mapper,0,0,1,class<`function`>,1
+purrr,as_mapper,0,0,2,double[],1
+purrr,as_mapper,0,0,3,list<character | double>,1
+purrr,as_mapper,0,0,4,list<double | character>,1
+purrr,as_mapper,0,0,5,list<double | class<`function`>>,1
+purrr,as_mapper,0,0,6,"class<`function`, `purrr_function_compose`>",1
+purrr,as_mapper,0,0,7,"class<`function`, `purrr_function_partial`>",1
+purrr,as_mapper,0,0,8,class<`formula`>,1
+purrr,as_mapper,0,0,9,"class<`function`, `rlang_lambda_function`>",1
+purrr,as_mapper,1,0,0,...,1
+purrr,as_mapper.character,-1,0,0,class<`function`>,1
+purrr,as_mapper.character,0,0,0,character[],1
+purrr,as_mapper.character,0,0,1,double[],1
+purrr,as_mapper.character,1,0,0,...,1
+purrr,as_mapper.character,2,0,0,any,1
+purrr,as_mapper.character,3,0,0,null,1
+purrr,as_mapper.character,3,0,1,character,1
+purrr,as_mapper.default,-1,0,0,class<`function`>,1
+purrr,as_mapper.default,-1,0,1,"class<`function`, `purrr_function_compose`>",1
+purrr,as_mapper.default,-1,0,2,"class<`function`, `purrr_function_partial`>",1
+purrr,as_mapper.default,-1,0,3,"class<`function`, `rlang_lambda_function`>",1
+purrr,as_mapper.default,0,0,0,class<`function`>,1
+purrr,as_mapper.default,0,0,1,"class<`function`, `purrr_function_compose`>",1
+purrr,as_mapper.default,0,0,2,"class<`function`, `purrr_function_partial`>",1
+purrr,as_mapper.default,0,0,3,class<`formula`>,1
+purrr,as_mapper.default,0,0,4,"class<`function`, `rlang_lambda_function`>",1
+purrr,as_mapper.default,1,0,0,...,1
+purrr,as_mapper.list,-1,0,0,class<`function`>,1
+purrr,as_mapper.list,0,0,0,list<character | double>,1
+purrr,as_mapper.list,0,0,1,list<double | character>,1
+purrr,as_mapper.list,0,0,2,list<double | class<`function`>>,1
+purrr,as_mapper.list,1,0,0,...,1
+purrr,as_mapper.list,2,0,0,any,1
+purrr,as_mapper.list,3,0,0,null,1
+purrr,as_mapper.list,3,0,1,character,1
+purrr,as_mapper.numeric,-1,0,0,class<`function`>,1
+purrr,as_mapper.numeric,0,0,0,character[],1
+purrr,as_mapper.numeric,0,0,1,double[],1
+purrr,as_mapper.numeric,1,0,0,...,1
+purrr,as_mapper.numeric,2,0,0,any,1
+purrr,as_mapper.numeric,3,0,0,null,1
+purrr,as_mapper.numeric,3,0,1,character,1
+purrr,as_predicate,-1,0,0,class<`function`>,1
+purrr,as_predicate,0,0,0,character,1
+purrr,as_predicate,0,0,1,class<`formula`>,1
+purrr,as_predicate,0,0,2,class<`function`>,1
+purrr,as_predicate,0,0,3,"class<`function`, `purrr_function_compose`>",1
+purrr,as_predicate,0,0,4,"class<`function`, `purrr_function_partial`>",1
+purrr,as_predicate,1,0,0,...,1
+purrr,as_predicate,2,0,0,logical,1
+purrr,as_predicate,3,0,0,logical,1
+purrr,assign_in,-1,0,0,list<list<character | list<double | character>>>,1
+purrr,assign_in,-1,0,1,list<list<double>>,1
+purrr,assign_in,0,0,0,list<list<character | list<double | character>>>,1
+purrr,assign_in,0,0,1,list<list<double>>,1
+purrr,assign_in,1,0,0,list<double | character>,1
+purrr,assign_in,2,0,0,character,1
+purrr,assign_in,2,0,1,double,1
+purrr,as_vector,-1,0,0,character[],1
+purrr,as_vector,-1,0,1,double[],1
+purrr,as_vector,0,0,0,list<character>,1
+purrr,as_vector,0,0,1,list<double>,1
+purrr,as_vector,0,0,2,list<integer[]>,1
+purrr,as_vector,1,0,0,character,1
+purrr,as_vector,1,0,1,null,1
+purrr,as_vector,1,0,2,integer[],1
+purrr,at_selection,-1,0,0,character[],1
+purrr,at_selection,-1,0,1,double[],1
+purrr,at_selection,0,0,0,any,1
+purrr,at_selection,1,0,0,character[],1
+purrr,at_selection,1,0,1,double[],1
+purrr,attr_getter,-1,0,0,class<`function`>,1
+purrr,attr_getter,0,0,0,character,1
+purrr,can_coerce,-1,0,0,logical,1
+purrr,can_coerce,0,0,0,list<character>,1
+purrr,can_coerce,0,0,1,list<integer[]>,1
+purrr,can_coerce,1,0,0,character,1
+purrr,can_coerce,1,0,1,integer[],1
+purrr,can_simplify,-1,0,0,logical,1
+purrr,can_simplify,0,0,0,list<character>,1
+purrr,can_simplify,0,0,1,"list<class<`condition`, `error`, `simpleError`> | null>",1
+purrr,can_simplify,0,0,2,list<double>,1
+purrr,can_simplify,0,0,3,list<integer[]>,1
+purrr,can_simplify,0,0,4,list<null | double>,1
+purrr,can_simplify,1,0,0,any,1
+purrr,capture_error,-1,0,0,list<double | null>,1
+purrr,capture_error,-1,0,1,"list<null | class<`condition`, `error`, `simpleError`>>",1
+purrr,capture_error,0,0,0,any,1
+purrr,capture_error,1,0,0,any,1
+purrr,capture_error,2,0,0,any,1
+purrr,check_tibble,-1,0,0,null,1
+purrr,chuck,-1,0,0,any,1
+purrr,chuck,0,0,0,list<list<character | list<double | character>>>,1
+purrr,chuck,0,0,1,list<list<double>>,1
+purrr,chuck,0,0,2,list<character | list<double | character>>,1
+purrr,chuck,1,0,0,...,1
+purrr,compact,-1,0,0,list<list<integer>>,1
+purrr,compact,-1,0,1,list<list<integer | character>>,1
+purrr,compact,-1,0,2,list<list<character>>,1
+purrr,compact,-1,0,3,list<character | null>,1
+purrr,compact,0,0,0,list<any>,1
+purrr,compact,1,0,0,class<`function`>,1
+purrr,compose,-1,0,0,double,1
+purrr,compose,0,0,0,double,1
+purrr,compose,0,0,1,null,1
+purrr,compose,-1,1,0,"class<`function`, `purrr_function_compose`>",1
+purrr,compose,0,1,0,...,1
+purrr,compose,1,1,0,character[],1
+purrr,cross,-1,0,0,list<list<integer>>,1
+purrr,cross,-1,0,1,list<list<integer | character>>,1
+purrr,cross,-1,0,2,list<list<character>>,1
+purrr,cross,0,0,0,list<integer[]>,1
+purrr,cross,0,0,1,list<integer[] | character[]>,1
+purrr,cross,0,0,2,list<character[]>,1
+purrr,cross,1,0,0,class<`function`>,1
+purrr,cross,1,0,1,null,1
+purrr,cross2,-1,0,0,list<list<integer>>,1
+purrr,cross2,0,0,0,integer[],1
+purrr,cross2,1,0,0,integer[],1
+purrr,cross2,2,0,0,class<`function`>,1
+purrr,cross_df,-1,0,0,"class<`data.frame`, `tbl`, `tbl_df`>",1
+purrr,cross_df,0,0,0,list<character[]>,1
+purrr,cross_df,1,0,0,null,1
+purrr,detect,-1,0,0,integer,1
+purrr,detect,-1,0,1,list<double>,1
+purrr,detect,0,0,0,integer[],1
+purrr,detect,0,0,1,list<list<double>>,1
+purrr,detect,1,0,0,class<`function`>,1
+purrr,detect,1,0,1,character,1
+purrr,detect,2,0,0,...,1
+purrr,detect,3,0,0,character[],1
+purrr,detect,4,0,0,null,1
+purrr,detect,5,0,0,null,1
+purrr,detect_index,-1,0,0,integer,1
+purrr,detect_index,0,0,0,integer[],1
+purrr,detect_index,0,0,1,list<list<double>>,1
+purrr,detect_index,1,0,0,class<`function`>,1
+purrr,detect_index,1,0,1,"class<`function`, `purrr_function_compose`>",1
+purrr,detect_index,1,0,2,character,1
+purrr,detect_index,2,0,0,...,1
+purrr,detect_index,3,0,0,character[],1
+purrr,detect_index,4,0,0,null,1
+purrr,discard,-1,0,0,list<list<integer | character>>,1
+purrr,discard,-1,0,1,list<list<integer[]>>,1
+purrr,discard,-1,0,2,list<list<character>>,1
+purrr,discard,-1,0,3,list<character | null>,1
+purrr,discard,0,0,0,list<any>,1
+purrr,discard,1,0,0,class<`function`>,1
+purrr,discard,1,0,1,character,1
+purrr,discard,2,0,0,...,1
+purrr,every,-1,0,0,logical,1
+purrr,every,0,0,0,list<integer[] | double>,1
+purrr,every,1,0,0,class<`function`>,1
+purrr,every,2,0,0,...,1
+purrr,find_extract_default,-1,0,0,character,1
+purrr,find_extract_default,-1,0,1,null,1
+purrr,find_extract_default,0,0,0,any,1
+purrr,find_extract_default,1,0,0,character,1
+purrr,find_extract_default,1,0,1,null,1
+purrr,flatten,-1,0,0,list<class<`matrix`>>,1
+purrr,flatten,-1,0,1,list<integer[] | character[]>,1
+purrr,flatten,-1,0,2,list<character[]>,1
+purrr,flatten,-1,0,3,list<double[]>,1
+purrr,flatten,0,0,0,list<list<class<`matrix`>>>,1
+purrr,flatten,0,0,1,class<`array`>,1
+purrr,flatten,0,0,2,list<integer[]>,1
+purrr,flatten,0,0,3,class<`matrix`>,1
+purrr,flatten,0,0,4,list<list<integer[]>>,1
+purrr,flatten,0,0,5,list<list<integer[] | character[]>>,1
+purrr,flatten,0,0,6,list<list<character[]>>,1
+purrr,flatten,0,0,7,list<class<`data.frame`> | list<double[]>>,1
+purrr,flatten_int,-1,0,0,integer[],1
+purrr,flatten_int,0,0,0,list<integer[]>,1
+purrr,has_element,-1,0,0,logical,1
+purrr,has_element,0,0,0,list<integer[] | double>,1
+purrr,has_element,1,0,0,double,1
+purrr,has_element,1,0,1,integer[],1
+purrr,has_names,-1,0,0,logical,1
+purrr,has_names,0,0,0,"class<`list`, `quosures`>",1
+purrr,head_while,-1,0,0,integer[],1
+purrr,head_while,0,0,0,integer[],1
+purrr,head_while,1,0,0,class<`function`>,1
+purrr,head_while,2,0,0,...,1
+purrr,imap_chr,-1,0,0,character[],1
+purrr,imap_chr,0,0,0,integer[],1
+purrr,imap_chr,1,0,0,class<`formula`>,1
+purrr,imap_chr,2,0,0,...,1
+purrr,index,-1,0,0,integer[],1
+purrr,index,0,0,0,integer[],1
+purrr,index,0,0,1,list<list<double>>,1
+purrr,index,1,0,0,character,1
+purrr,index,2,0,0,null,1
+purrr,index,3,0,0,character,1
+purrr,insistently,-1,0,0,class<`function`>,1
+purrr,insistently,0,0,0,class<`function`>,1
+purrr,insistently,1,0,0,"class<`purrr_rate`, `purrr_rate_backoff`>",1
+purrr,insistently,1,0,1,"class<`purrr_rate`, `purrr_rate_delay`>",1
+purrr,insistently,2,0,0,logical,1
+purrr,invoke,-1,0,0,double[],1
+purrr,invoke,-1,0,1,character,1
+purrr,invoke,0,0,0,character,1
+purrr,invoke,0,0,1,class<`function`>,1
+purrr,invoke,1,0,0,null,1
+purrr,invoke,1,0,1,list<character>,1
+purrr,invoke,1,0,2,list<^double[]>,1
+purrr,invoke,2,0,0,...,1
+purrr,invoke,3,0,0,environment,1
+purrr,invoke,3,0,1,null,1
+purrr,invoke_map,-1,0,0,list<double[]>,1
+purrr,invoke_map,0,0,0,list<class<`function`>>,1
+purrr,invoke_map,0,0,1,character[],1
+purrr,invoke_map,1,0,0,list<list<double>>,1
+purrr,invoke_map,1,0,1,list<null>,1
+purrr,invoke_map,2,0,0,...,1
+purrr,invoke_map,3,0,0,null,1
+purrr,invoke_map_dbl,-1,0,0,double[],1
+purrr,invoke_map_dbl,0,0,0,list<class<`function`>>,1
+purrr,invoke_map_dbl,1,0,0,list<null>,1
+purrr,invoke_map_dbl,2,0,0,...,1
+purrr,invoke_map_dbl,3,0,0,null,1
+purrr,inv_which,-1,0,0,logical[],1
+purrr,inv_which,0,0,0,class<`data.frame`>,1
+purrr,inv_which,0,0,1,list<integer[] | character[]>,1
+purrr,inv_which,1,0,0,double[],1
+purrr,inv_which,1,0,1,character[],1
+purrr,is_bool,-1,0,0,logical,1
+purrr,is_bool,0,0,0,logical,1
+purrr,is_index,-1,0,0,logical,1
+purrr,is_index,0,0,0,character,1
+purrr,is_index,0,0,1,double,1
+purrr,is_mold,-1,0,0,logical,1
+purrr,is_mold,0,0,0,character,1
+purrr,is_mold,0,0,1,integer[],1
+purrr,is_names,-1,0,0,logical,1
+purrr,is_names,0,0,0,character[],1
+purrr,is_number,-1,0,0,logical,1
+purrr,is_number,0,0,0,double,1
+purrr,is_quantity,-1,0,0,logical,1
+purrr,is_quantity,0,0,0,double,1
+purrr,is_rate,-1,0,0,logical,1
+purrr,is_rate,0,0,0,"class<`purrr_rate`, `purrr_rate_backoff`>",1
+purrr,is_rate,0,0,1,"class<`purrr_rate`, `purrr_rate_delay`>",1
+purrr,iwalk,-1,0,0,class<`data.frame`>,1
+purrr,iwalk,0,0,0,class<`data.frame`>,1
+purrr,iwalk,1,0,0,class<`formula`>,1
+purrr,iwalk,2,0,0,...,1
+purrr,keep,-1,0,0,list<integer[]>,1
+purrr,keep,-1,0,1,list<list<integer[]>>,1
+purrr,keep,-1,0,2,list<list<double>>,1
+purrr,keep,0,0,0,list<integer[]>,1
+purrr,keep,0,0,1,list<list<integer[]>>,1
+purrr,keep,0,0,2,list<list<double>>,1
+purrr,keep,1,0,0,class<`formula`>,1
+purrr,keep,1,0,1,class<`function`>,1
+purrr,keep,1,0,2,character,1
+purrr,keep,1,0,3,"class<`function`, `purrr_function_compose`>",1
+purrr,keep,2,0,0,...,1
+purrr,lift,-1,0,0,double,1
+purrr,lift,0,0,0,class<`data.frame`>,1
+purrr,lift,0,0,1,list<any>,1
+purrr,lift,1,0,0,...,1
+purrr,lift,-1,1,0,class<`function`>,1
+purrr,lift,0,1,0,class<`function`>,1
+purrr,lift,1,1,0,...,1
+purrr,lift,2,1,0,logical,1
+purrr,lift_dl,-1,0,0,double,1
+purrr,lift_dl,0,0,0,class<`data.frame`>,1
+purrr,lift_dl,0,0,1,list<any>,1
+purrr,lift_dl,1,0,0,...,1
+purrr,lift_dl,-1,1,0,class<`function`>,1
+purrr,lift_dl,0,1,0,class<`function`>,1
+purrr,lift_dl,1,1,0,...,1
+purrr,lift_dl,2,1,0,logical,1
+purrr,lift_ld,-1,0,0,list<list<integer | character>>,1
+purrr,lift_ld,-1,0,1,double,1
+purrr,lift_ld,-1,0,2,list<list<integer>>,1
+purrr,lift_ld,0,0,0,...,1
+purrr,lift_ld,-1,1,0,class<`function`>,1
+purrr,lift_ld,0,1,0,class<`function`>,1
+purrr,lift_ld,1,1,0,...,1
+purrr,lift_lv,-1,0,0,character,1
+purrr,lift_lv,0,0,0,character[],1
+purrr,lift_lv,1,0,0,...,1
+purrr,lift_lv,-1,1,0,class<`function`>,1
+purrr,lift_lv,0,1,0,class<`function`>,1
+purrr,lift_lv,1,1,0,...,1
+purrr,lift_vd,-1,0,0,double,1
+purrr,lift_vd,-1,0,1,character[],1
+purrr,lift_vd,0,0,0,...,1
+purrr,lift_vd,-1,1,0,class<`function`>,1
+purrr,lift_vd,0,1,0,class<`function`>,1
+purrr,lift_vd,1,1,0,...,1
+purrr,lift_vd,2,1,0,any,1
+purrr,list_along,-1,0,0,list<null>,1
+purrr,list_along,0,0,0,list<class<`formula`>>,1
+purrr,list_along,0,0,1,"list<class<`formula`, `quosure`>>",1
+purrr,list_along,0,0,2,class<`data.frame`>,1
+purrr,list_along,0,0,3,integer[],1
+purrr,list_merge,-1,0,0,list<double[] | list<double[]>>,1
+purrr,list_merge,0,0,0,list<integer[] | double | list<double>>,1
+purrr,list_merge,1,0,0,...,1
+purrr,list_modify,-1,0,0,list<integer[] | double>,1
+purrr,list_modify,-1,0,1,list<integer[] | double | list<double>>,1
+purrr,list_modify,-1,0,2,list<integer[] | double | list<integer[] | double>>,1
+purrr,list_modify,0,0,0,list<integer[] | double | list<double>>,1
+purrr,list_modify,1,0,0,...,1
+purrr,list_recurse,-1,0,0,list<double[]>,1
+purrr,list_recurse,-1,0,1,list<integer[] | double>,1
+purrr,list_recurse,-1,0,2,list<double[] | list<double[]>>,1
+purrr,list_recurse,-1,0,3,list<integer[] | double | list<double>>,1
+purrr,list_recurse,-1,0,4,list<integer[] | double | list<integer[] | double>>,1
+purrr,list_recurse,0,0,0,list<double>,1
+purrr,list_recurse,0,0,1,list<integer[] | double | list<double>>,1
+purrr,list_recurse,1,0,0,list<integer[] | double>,1
+purrr,list_recurse,1,0,1,class<`rlang_zap`>,1
+purrr,list_recurse,1,0,2,list<integer[]>,1
+purrr,list_recurse,1,0,3,list<double | list<integer[] | double>>,1
+purrr,list_recurse,1,0,4,list<double>,1
+purrr,list_recurse,1,0,5,list<class<`rlang_zap`>>,1
+purrr,list_recurse,1,0,6,list<list<integer[]>>,1
+purrr,list_recurse,1,0,7,list<double | class<`rlang_zap`>>,1
+purrr,list_recurse,2,0,0,any,1
+purrr,lmap,-1,0,0,list<integer[] | character[]>,1
+purrr,lmap,0,0,0,list<integer[] | character[]>,1
+purrr,lmap,1,0,0,class<`function`>,1
+purrr,lmap,2,0,0,...,1
+purrr,lmap_at,-1,0,0,"class<`data.frame`, `tbl`, `tbl_df`>",1
+purrr,lmap_at,-1,0,1,list<integer[] | character[]>,1
+purrr,lmap_at,0,0,0,class<`data.frame`>,1
+purrr,lmap_at,0,0,1,list<integer[] | character[]>,1
+purrr,lmap_at,1,0,0,character[],1
+purrr,lmap_at,1,0,1,integer[],1
+purrr,lmap_at,2,0,0,class<`function`>,1
+purrr,lmap_at,3,0,0,...,1
+purrr,lmap_if,-1,0,0,"class<`data.frame`, `tbl`, `tbl_df`>",1
+purrr,lmap_if,-1,0,1,list<integer[] | character[]>,1
+purrr,lmap_if,0,0,0,class<`data.frame`>,1
+purrr,lmap_if,0,0,1,list<integer[] | character[]>,1
+purrr,lmap_if,1,0,0,class<`function`>,1
+purrr,lmap_if,2,0,0,class<`function`>,1
+purrr,lmap_if,3,0,0,...,1
+purrr,lmap_if,4,0,0,null,1
+purrr,map,-1,0,0,any,1
+purrr,map,0,0,0,list<integer[]>,1
+purrr,map,0,0,1,list<list<any>>,1
+purrr,map,0,0,2,list<class<`function`>>,1
+purrr,map,0,0,3,"list<class<`function`> | class<`function`, `purrr_function_compose`>>",1
+purrr,map,0,0,4,list<class<`function`> | class<`formula`>>,1
+purrr,map,0,0,5,"list<class<`function`> | class<`function`, `rlang_lambda_function`>>",1
+purrr,map,0,0,6,list<class<`formula`>>,1
+purrr,map,0,0,7,double[],1
+purrr,map,0,0,8,list<character | double>,1
+purrr,map,0,0,9,list<class<`lm`>>,1
+purrr,map,0,0,10,list<class<`data.frame`>>,1
+purrr,map,0,0,11,"class<`data.frame`, `tbl`, `tbl_df`>",1
+purrr,map,0,0,12,class<`data.frame`>,1
+purrr,map,0,0,13,"list<class<`formula`, `quosure`>>",1
+purrr,map,1,0,0,class<`function`>,1
+purrr,map,1,0,1,double[],1
+purrr,map,1,0,2,list<double | character>,1
+purrr,map,1,0,3,class<`formula`>,1
+purrr,map,1,0,4,character,1
+purrr,map,1,0,5,list<character | double>,1
+purrr,map,1,0,6,"class<`function`, `rlang_lambda_function`>",1
+purrr,map,2,0,0,...,1
+purrr,map2,-1,0,0,list<class<`data.frame`>>,1
+purrr,map2,-1,0,1,list<double[]>,1
+purrr,map2,-1,0,2,list<list<character[]>>,1
+purrr,map2,-1,0,3,list<null>,1
+purrr,map2,0,0,0,double[],1
+purrr,map2,0,0,1,list<double>,1
+purrr,map2,0,0,2,list<class<`function`>>,1
+purrr,map2,0,0,3,character[],1
+purrr,map2,0,0,4,list<class<`lm`>>,1
+purrr,map2,0,0,5,list<list<character[]>>,1
+purrr,map2,0,0,6,class<`data.frame`>,1
+purrr,map2,1,0,0,double[],1
+purrr,map2,1,0,1,list<double>,1
+purrr,map2,1,0,2,list<list<double>>,1
+purrr,map2,1,0,3,list<null>,1
+purrr,map2,1,0,4,list<class<`data.frame`>>,1
+purrr,map2,1,0,5,character[],1
+purrr,map2,2,0,0,class<`function`>,1
+purrr,map2,2,0,1,class<`formula`>,1
+purrr,map2,2,0,2,"class<`function`, `rlang_lambda_function`>",1
+purrr,map2,3,0,0,...,1
+purrr,map2_chr,-1,0,0,character[],1
+purrr,map2_chr,0,0,0,integer[],1
+purrr,map2_chr,1,0,0,integer[],1
+purrr,map2_chr,2,0,0,"class<`function`, `rlang_lambda_function`>",1
+purrr,map2_chr,3,0,0,...,1
+purrr,map2_dbl,-1,0,0,double[],1
+purrr,map2_dbl,0,0,0,double[],1
+purrr,map2_dbl,0,0,1,list<class<`function`>>,1
+purrr,map2_dbl,1,0,0,double[],1
+purrr,map2_dbl,1,0,1,list<null>,1
+purrr,map2_dbl,2,0,0,class<`function`>,1
+purrr,map2_dbl,3,0,0,...,1
+purrr,map2_dfc,-1,0,0,class<`data.frame`>,1
+purrr,map2_dfc,0,0,0,double[],1
+purrr,map2_dfc,1,0,0,double[],1
+purrr,map2_dfc,2,0,0,class<`function`>,1
+purrr,map2_dfc,3,0,0,...,1
+purrr,map2_dfr,-1,0,0,class<`data.frame`>,1
+purrr,map2_dfr,0,0,0,double[],1
+purrr,map2_dfr,1,0,0,double[],1
+purrr,map2_dfr,2,0,0,class<`function`>,1
+purrr,map2_dfr,3,0,0,...,1
+purrr,map2_dfr,4,0,0,null,1
+purrr,map_at,-1,0,0,list<double[] | character[]>,1
+purrr,map_at,-1,0,1,list<double[]>,1
+purrr,map_at,0,0,0,class<`data.frame`>,1
+purrr,map_at,1,0,0,character,1
+purrr,map_at,1,0,1,double[],1
+purrr,map_at,2,0,0,class<`function`>,1
+purrr,map_at,3,0,0,...,1
+purrr,map_chr,-1,0,0,character[],1
+purrr,map_chr,0,0,0,list<list<character>>,1
+purrr,map_chr,0,0,1,character[],1
+purrr,map_chr,1,0,0,class<`formula`>,1
+purrr,map_chr,1,0,1,class<`function`>,1
+purrr,map_chr,2,0,0,...,1
+purrr,map_dbl,-1,0,0,^double[],1
+purrr,map_dbl,0,0,0,list<character | double>,1
+purrr,map_dbl,0,0,1,list<double[]>,1
+purrr,map_dbl,0,0,2,list<list<double[]>>,1
+purrr,map_dbl,0,0,3,list<class<`summary.lm`>>,1
+purrr,map_dbl,0,0,4,class<`data.frame`>,1
+purrr,map_dbl,1,0,0,class<`function`>,1
+purrr,map_dbl,1,0,1,class<`formula`>,1
+purrr,map_dbl,1,0,2,character,1
+purrr,map_dbl,2,0,0,...,1
+purrr,map_depth,-1,0,0,list<list<character>>,1
+purrr,map_depth,0,0,0,list<list<integer[]>>,1
+purrr,map_depth,1,0,0,double,1
+purrr,map_depth,2,0,0,class<`function`>,1
+purrr,map_depth,3,0,0,...,1
+purrr,map_depth,4,0,0,logical,1
+purrr,map_depth_rec,-1,0,0,list<list<character>>,1
+purrr,map_depth_rec,-1,0,1,list<character>,1
+purrr,map_depth_rec,0,0,0,list<list<integer[]>>,1
+purrr,map_depth_rec,0,0,1,list<integer[]>,1
+purrr,map_depth_rec,1,0,0,double,1
+purrr,map_depth_rec,2,0,0,class<`function`>,1
+purrr,map_depth_rec,3,0,0,...,1
+purrr,map_depth_rec,4,0,0,any,1
+purrr,map_depth_rec,5,0,0,logical,1
+purrr,map_dfr,-1,0,0,class<`data.frame`>,1
+purrr,map_dfr,0,0,0,list<class<`lm`>>,1
+purrr,map_dfr,1,0,0,class<`formula`>,1
+purrr,map_dfr,2,0,0,...,1
+purrr,map_dfr,3,0,0,null,1
+purrr,map_if,-1,0,0,list<double[] | character[]>,1
+purrr,map_if,-1,0,1,list<integer[] | character[]>,1
+purrr,map_if,-1,0,2,"list<class<`formula`, `quosure`>>",1
+purrr,map_if,-1,0,3,list<double>,1
+purrr,map_if,0,0,0,class<`data.frame`>,1
+purrr,map_if,0,0,1,list<class<`formula`>>,1
+purrr,map_if,0,0,2,"list<class<`formula`, `quosure`>>",1
+purrr,map_if,1,0,0,class<`function`>,1
+purrr,map_if,1,0,1,logical,1
+purrr,map_if,2,0,0,class<`function`>,1
+purrr,map_if,3,0,0,...,1
+purrr,map_if,4,0,0,null,1
+purrr,map_if,4,0,1,class<`function`>,1
+purrr,map_int,-1,0,0,^integer[],1
+purrr,map_int,0,0,0,integer[],1
+purrr,map_int,0,0,1,list<any>,1
+purrr,map_int,1,0,0,character,1
+purrr,map_int,1,0,1,double,1
+purrr,map_int,1,0,2,list<character | double>,1
+purrr,map_int,1,0,3,class<`function`>,1
+purrr,map_int,2,0,0,...,1
+purrr,map_lgl,-1,0,0,logical[],1
+purrr,map_lgl,0,0,0,list<any>,1
+purrr,map_lgl,0,0,1,class<`data.frame`>,1
+purrr,map_lgl,1,0,0,class<`function`>,1
+purrr,map_lgl,1,0,1,character,1
+purrr,map_lgl,2,0,0,...,1
+purrr,maybe_as_data_frame,-1,0,0,"class<`data.frame`, `tbl`, `tbl_df`>",1
+purrr,maybe_as_data_frame,-1,0,1,list<integer[] | character[]>,1
+purrr,maybe_as_data_frame,0,0,0,list<double[]>,1
+purrr,maybe_as_data_frame,0,0,1,list<integer[] | character[]>,1
+purrr,maybe_as_data_frame,1,0,0,class<`data.frame`>,1
+purrr,maybe_as_data_frame,1,0,1,list<integer[] | character[]>,1
+purrr,maybe_zap,-1,0,0,double[],1
+purrr,maybe_zap,-1,0,1,null,1
+purrr,maybe_zap,0,0,0,double[],1
+purrr,maybe_zap,0,0,1,class<`rlang_zap`>,1
+purrr,modify,-1,0,0,integer[],1
+purrr,modify,-1,0,1,list<integer[]>,1
+purrr,modify,-1,0,2,list<list<integer[]>>,1
+purrr,modify,-1,0,3,list<list<list<character>>>,1
+purrr,modify,-1,0,4,list<list<list<integer[]>>>,1
+purrr,modify,-1,0,5,list<list<character>>,1
+purrr,modify,0,0,0,integer[],1
+purrr,modify,0,0,1,list<list<list<integer[]>>>,1
+purrr,modify,0,0,2,list<integer[]>,1
+purrr,modify,0,0,3,list<list<integer[]>>,1
+purrr,modify,1,0,0,class<`function`>,1
+purrr,modify,1,0,1,character[],1
+purrr,modify,1,0,2,"class<`function`, `rlang_lambda_function`>",1
+purrr,modify,2,0,0,...,1
+purrr,modify2,-1,0,0,integer[],1
+purrr,modify2,0,0,0,integer[],1
+purrr,modify2,1,0,0,logical[],1
+purrr,modify2,2,0,0,class<`formula`>,1
+purrr,modify2,3,0,0,...,1
+purrr,modify2.integer,-1,0,0,integer[],1
+purrr,modify2.integer,0,0,0,integer[],1
+purrr,modify2.integer,1,0,0,logical[],1
+purrr,modify2.integer,2,0,0,class<`formula`>,1
+purrr,modify2.integer,3,0,0,...,1
+purrr,modify_at,-1,0,0,class<`data.frame`>,1
+purrr,modify_at,0,0,0,class<`data.frame`>,1
+purrr,modify_at,1,0,0,character[],1
+purrr,modify_at,1,0,1,double[],1
+purrr,modify_at,2,0,0,class<`function`>,1
+purrr,modify_at,3,0,0,...,1
+purrr,modify_at.default,-1,0,0,class<`data.frame`>,1
+purrr,modify_at.default,0,0,0,class<`data.frame`>,1
+purrr,modify_at.default,1,0,0,character[],1
+purrr,modify_at.default,1,0,1,double[],1
+purrr,modify_at.default,2,0,0,class<`function`>,1
+purrr,modify_at.default,3,0,0,...,1
+purrr,modify_base,-1,0,0,integer[],1
+purrr,modify_base,0,0,0,class<`function`>,1
+purrr,modify_base,1,0,0,integer[],1
+purrr,modify_base,2,0,0,logical[],1
+purrr,modify_base,3,0,0,class<`formula`>,1
+purrr,modify_base,4,0,0,...,1
+purrr,modify.default,-1,0,0,list<integer[]>,1
+purrr,modify.default,-1,0,1,list<list<integer[]>>,1
+purrr,modify.default,-1,0,2,list<list<list<character>>>,1
+purrr,modify.default,-1,0,3,list<list<list<integer[]>>>,1
+purrr,modify.default,-1,0,4,list<list<character>>,1
+purrr,modify.default,0,0,0,list<list<list<integer[]>>>,1
+purrr,modify.default,0,0,1,list<integer[]>,1
+purrr,modify.default,0,0,2,list<list<integer[]>>,1
+purrr,modify.default,1,0,0,character[],1
+purrr,modify.default,1,0,1,class<`function`>,1
+purrr,modify.default,1,0,2,"class<`function`, `rlang_lambda_function`>",1
+purrr,modify.default,2,0,0,...,1
+purrr,modify_depth,-1,0,0,list<list<integer[]>>,1
+purrr,modify_depth,-1,0,1,list<list<list<character>>>,1
+purrr,modify_depth,-1,0,2,list<list<list<integer[]>>>,1
+purrr,modify_depth,0,0,0,list<list<list<integer[]>>>,1
+purrr,modify_depth,1,0,0,double,1
+purrr,modify_depth,2,0,0,character,1
+purrr,modify_depth,2,0,1,class<`formula`>,1
+purrr,modify_depth,2,0,2,class<`function`>,1
+purrr,modify_depth,3,0,0,...,1
+purrr,modify_depth,4,0,0,any,1
+purrr,modify_depth.default,-1,0,0,list<list<integer[]>>,1
+purrr,modify_depth.default,-1,0,1,list<list<list<character>>>,1
+purrr,modify_depth.default,-1,0,2,list<list<list<integer[]>>>,1
+purrr,modify_depth.default,0,0,0,list<list<list<integer[]>>>,1
+purrr,modify_depth.default,1,0,0,double,1
+purrr,modify_depth.default,2,0,0,character,1
+purrr,modify_depth.default,2,0,1,class<`formula`>,1
+purrr,modify_depth.default,2,0,2,class<`function`>,1
+purrr,modify_depth.default,3,0,0,...,1
+purrr,modify_depth.default,4,0,0,logical,1
+purrr,modify_depth_rec,-1,0,0,integer[],1
+purrr,modify_depth_rec,-1,0,1,list<list<integer[]>>,1
+purrr,modify_depth_rec,-1,0,2,list<list<list<character>>>,1
+purrr,modify_depth_rec,-1,0,3,list<list<list<integer[]>>>,1
+purrr,modify_depth_rec,-1,0,4,list<integer[]>,1
+purrr,modify_depth_rec,-1,0,5,list<list<character>>,1
+purrr,modify_depth_rec,0,0,0,integer[],1
+purrr,modify_depth_rec,0,0,1,list<list<list<integer[]>>>,1
+purrr,modify_depth_rec,0,0,2,list<integer[]>,1
+purrr,modify_depth_rec,0,0,3,list<list<integer[]>>,1
+purrr,modify_depth_rec,1,0,0,double,1
+purrr,modify_depth_rec,2,0,0,class<`function`>,1
+purrr,modify_depth_rec,2,0,1,"class<`function`, `rlang_lambda_function`>",1
+purrr,modify_depth_rec,3,0,0,...,1
+purrr,modify_depth_rec,4,0,0,any,1
+purrr,modify_depth_rec,5,0,0,logical,1
+purrr,modify_if,-1,0,0,class<`data.frame`>,1
+purrr,modify_if,-1,0,1,list<list<double>>,1
+purrr,modify_if,-1,0,2,list<list<character[]>>,1
+purrr,modify_if,0,0,0,class<`data.frame`>,1
+purrr,modify_if,0,0,1,list<list<integer>>,1
+purrr,modify_if,0,0,2,list<character[] | list<character>>,1
+purrr,modify_if,1,0,0,class<`function`>,1
+purrr,modify_if,1,0,1,logical[],1
+purrr,modify_if,1,0,2,character,1
+purrr,modify_if,2,0,0,class<`function`>,1
+purrr,modify_if,2,0,1,class<`formula`>,1
+purrr,modify_if,3,0,0,...,1
+purrr,modify_if,4,0,0,class<`function`>,1
+purrr,modify_if,4,0,1,null,1
+purrr,modify_if.default,-1,0,0,class<`data.frame`>,1
+purrr,modify_if.default,-1,0,1,list<list<double>>,1
+purrr,modify_if.default,-1,0,2,list<list<character[]>>,1
+purrr,modify_if.default,0,0,0,class<`data.frame`>,1
+purrr,modify_if.default,0,0,1,list<list<integer>>,1
+purrr,modify_if.default,0,0,2,list<character[] | list<character>>,1
+purrr,modify_if.default,1,0,0,class<`function`>,1
+purrr,modify_if.default,1,0,1,logical[],1
+purrr,modify_if.default,1,0,2,character,1
+purrr,modify_if.default,2,0,0,class<`function`>,1
+purrr,modify_if.default,2,0,1,class<`formula`>,1
+purrr,modify_if.default,3,0,0,...,1
+purrr,modify_if.default,4,0,0,class<`function`>,1
+purrr,modify_if.default,4,0,1,null,1
+purrr,modify_in,-1,0,0,list<list<double>>,1
+purrr,modify_in,0,0,0,list<list<double>>,1
+purrr,modify_in,1,0,0,list<double | character>,1
+purrr,modify_in,2,0,0,class<`formula`>,1
+purrr,modify_in,2,0,1,class<`function`>,1
+purrr,modify_in,3,0,0,...,1
+purrr,modify.integer,-1,0,0,integer[],1
+purrr,modify.integer,0,0,0,integer[],1
+purrr,modify.integer,1,0,0,class<`function`>,1
+purrr,modify.integer,2,0,0,...,1
+purrr,negate,-1,0,0,"class<`function`, `purrr_function_compose`>",1
+purrr,negate,0,0,0,character,1
+purrr,negate,0,0,1,class<`formula`>,1
+purrr,negate,0,0,2,class<`function`>,1
+purrr,negate,0,0,3,"class<`function`, `purrr_function_compose`>",1
+purrr,new_rate,-1,0,0,"class<`purrr_rate`, `purrr_rate_backoff`>",1
+purrr,new_rate,-1,0,1,"class<`purrr_rate`, `purrr_rate_delay`>",1
+purrr,new_rate,0,0,0,character,1
+purrr,new_rate,1,0,0,...,1
+purrr,new_rate,2,0,0,logical,1
+purrr,new_rate,3,0,0,double,1
+purrr,partial,-1,0,0,"class<`function`, `purrr_function_partial`>",1
+purrr,partial,0,0,0,class<`function`>,1
+purrr,partial,0,0,1,"class<`function`, `purrr_function_partial`>",1
+purrr,partial,1,0,0,...,1
+purrr,partial,2,0,0,null,1
+purrr,partial,3,0,0,null,1
+purrr,partial,4,0,0,null,1
+purrr,paste_line,-1,0,0,character,1
+purrr,paste_line,0,0,0,...,1
+purrr,pluck,-1,0,0,character,1
+purrr,pluck,-1,0,1,double,1
+purrr,pluck,-1,0,2,integer[],1
+purrr,pluck,-1,0,3,list<character | list<double | character>>,1
+purrr,pluck,-1,0,4,null,1
+purrr,pluck,-1,0,5,list<double | character>,1
+purrr,pluck,0,0,0,character[],1
+purrr,pluck,0,0,1,class<`summary.lm`>,1
+purrr,pluck,0,0,2,integer[],1
+purrr,pluck,0,0,3,list<any>,1
+purrr,pluck,1,0,0,...,1
+purrr,pluck,2,0,0,null,1
+purrr,pluck,2,0,1,character,1
+purrr,pluck<-,-1,0,0,list<list<character | list<double | character>>>,1
+purrr,pluck<-,0,0,0,list<list<character | list<double | character>>>,1
+purrr,pluck<-,1,0,0,...,1
+purrr,pluck<-,2,0,0,character,1
+purrr,plucker,-1,0,0,class<`function`>,1
+purrr,plucker,0,0,0,list<character>,1
+purrr,plucker,0,0,1,list<character | double>,1
+purrr,plucker,0,0,2,list<double | character>,1
+purrr,plucker,0,0,3,list<double | class<`function`>>,1
+purrr,plucker,0,0,4,list<double>,1
+purrr,plucker,1,0,0,null,1
+purrr,plucker,1,0,1,character,1
+purrr,pmap,-1,0,0,list<character>,1
+purrr,pmap,-1,0,1,list<double>,1
+purrr,pmap,0,0,0,class<`data.frame`>,1
+purrr,pmap,0,0,1,list<integer[]>,1
+purrr,pmap,0,0,2,list<list<double>>,1
+purrr,pmap,1,0,0,class<`function`>,1
+purrr,pmap,2,0,0,...,1
+purrr,pmap_chr,-1,0,0,character[],1
+purrr,pmap_chr,0,0,0,class<`data.frame`>,1
+purrr,pmap_chr,1,0,0,class<`function`>,1
+purrr,pmap_chr,2,0,0,...,1
+purrr,pmap_dbl,-1,0,0,double[],1
+purrr,pmap_dbl,0,0,0,class<`data.frame`>,1
+purrr,pmap_dbl,1,0,0,class<`function`>,1
+purrr,pmap_dbl,2,0,0,...,1
+purrr,possibly,-1,0,0,class<`function`>,1
+purrr,possibly,0,0,0,class<`function`>,1
+purrr,possibly,1,0,0,double,1
+purrr,possibly,1,0,1,null,1
+purrr,possibly,2,0,0,logical,1
+purrr,prepend,-1,0,0,list<character | integer>,1
+purrr,prepend,-1,0,1,list<integer | character>,1
+purrr,prepend,-1,0,2,list<integer>,1
+purrr,prepend,0,0,0,list<any>,1
+purrr,prepend,1,0,0,character,1
+purrr,prepend,1,0,1,list<character>,1
+purrr,prepend,1,0,2,list<integer>,1
+purrr,prepend,2,0,0,null,1
+purrr,prepend,2,0,1,double,1
+purrr,probe,-1,0,0,logical[],1
+purrr,probe,0,0,0,class<`data.frame`>,1
+purrr,probe,0,0,1,list<any>,1
+purrr,probe,1,0,0,logical[],1
+purrr,probe,1,0,1,class<`formula`>,1
+purrr,probe,1,0,2,class<`function`>,1
+purrr,probe,1,0,3,character,1
+purrr,probe,1,0,4,"class<`function`, `purrr_function_compose`>",1
+purrr,probe,2,0,0,...,1
+purrr,quo_invert,-1,0,0,"class<`formula`, `quosure`>",1
+purrr,quo_invert,0,0,0,"class<`formula`, `quosure`>",1
+purrr,quo_is_constant,-1,0,0,logical,1
+purrr,quo_is_constant,0,0,0,"class<`formula`, `quosure`>",1
+purrr,rate_backoff,-1,0,0,"class<`purrr_rate`, `purrr_rate_backoff`>",1
+purrr,rate_backoff,0,0,0,double,1
+purrr,rate_backoff,1,0,0,double,1
+purrr,rate_backoff,2,0,0,double,1
+purrr,rate_backoff,3,0,0,double,1
+purrr,rate_backoff,4,0,0,logical,1
+purrr,rate_bump_count,-1,0,0,"class<`purrr_rate`, `purrr_rate_backoff`>",1
+purrr,rate_bump_count,-1,0,1,"class<`purrr_rate`, `purrr_rate_delay`>",1
+purrr,rate_bump_count,0,0,0,"class<`purrr_rate`, `purrr_rate_backoff`>",1
+purrr,rate_bump_count,0,0,1,"class<`purrr_rate`, `purrr_rate_delay`>",1
+purrr,rate_bump_count,1,0,0,integer,1
+purrr,rate_count,-1,0,0,integer,1
+purrr,rate_count,0,0,0,"class<`purrr_rate`, `purrr_rate_backoff`>",1
+purrr,rate_count,0,0,1,"class<`purrr_rate`, `purrr_rate_delay`>",1
+purrr,rate_delay,-1,0,0,"class<`purrr_rate`, `purrr_rate_delay`>",1
+purrr,rate_delay,0,0,0,double,1
+purrr,rate_delay,1,0,0,double,1
+purrr,rate_reset,-1,0,0,"class<`purrr_rate`, `purrr_rate_backoff`>",1
+purrr,rate_reset,-1,0,1,"class<`purrr_rate`, `purrr_rate_delay`>",1
+purrr,rate_reset,0,0,0,"class<`purrr_rate`, `purrr_rate_backoff`>",1
+purrr,rate_reset,0,0,1,"class<`purrr_rate`, `purrr_rate_delay`>",1
+purrr,rate_sleep,-1,0,0,any,1
+purrr,rate_sleep,0,0,0,"class<`purrr_rate`, `purrr_rate_backoff`>",1
+purrr,rate_sleep,0,0,1,"class<`purrr_rate`, `purrr_rate_delay`>",1
+purrr,rate_sleep,1,0,0,any,1
+purrr,rate_sleep_impl,-1,0,0,null,1
+purrr,rate_sleep_impl,0,0,0,"class<`purrr_rate`, `purrr_rate_backoff`>",1
+purrr,rate_sleep_impl,0,0,1,"class<`purrr_rate`, `purrr_rate_delay`>",1
+purrr,rate_sleep_impl,1,0,0,double,1
+purrr,rate_sleep_impl,2,0,0,logical,1
+purrr,rate_sleep.purrr_rate_backoff,-1,0,0,null,1
+purrr,rate_sleep.purrr_rate_backoff,0,0,0,"class<`purrr_rate`, `purrr_rate_backoff`>",1
+purrr,rate_sleep.purrr_rate_backoff,1,0,0,logical,1
+purrr,rate_sleep.purrr_rate_delay,-1,0,0,null,1
+purrr,rate_sleep.purrr_rate_delay,0,0,0,"class<`purrr_rate`, `purrr_rate_delay`>",1
+purrr,rate_sleep.purrr_rate_delay,1,0,0,logical,1
+purrr,rbernoulli,-1,0,0,logical[],1
+purrr,rbernoulli,0,0,0,double,1
+purrr,rbernoulli,1,0,0,double,1
+purrr,rdunif,-1,0,0,double[],1
+purrr,rdunif,0,0,0,double,1
+purrr,rdunif,1,0,0,double,1
+purrr,rdunif,2,0,0,double,1
+purrr,recycle_args,-1,0,0,list<integer[]>,1
+purrr,recycle_args,0,0,0,list<integer[]>,1
+purrr,reduce,-1,0,0,character[],1
+purrr,reduce,-1,0,1,class<`call`>,1
+purrr,reduce,-1,0,2,integer,1
+purrr,reduce,-1,0,3,list<integer | list<integer | list<integer>>>,1
+purrr,reduce,0,0,0,list<character[]>,1
+purrr,reduce,0,0,1,character[],1
+purrr,reduce,0,0,2,list<double | character>,1
+purrr,reduce,0,0,3,integer[],1
+purrr,reduce,1,0,0,class<`function`>,1
+purrr,reduce,2,0,0,...,1
+purrr,reduce,3,0,0,any,1
+purrr,reduce,4,0,0,character[],1
+purrr,reduce2,-1,0,0,character[],1
+purrr,reduce2,0,0,0,list<double[]>,1
+purrr,reduce2,0,0,1,character[],1
+purrr,reduce2,1,0,0,list<double[]>,1
+purrr,reduce2,1,0,1,character[],1
+purrr,reduce2,2,0,0,class<`function`>,1
+purrr,reduce2,3,0,0,...,1
+purrr,reduce2,4,0,0,any,1
+purrr,reduce2_impl,-1,0,0,character[],1
+purrr,reduce2_impl,-1,0,1,list<character>,1
+purrr,reduce2_impl,0,0,0,list<double[]>,1
+purrr,reduce2_impl,0,0,1,character[],1
+purrr,reduce2_impl,1,0,0,list<double[]>,1
+purrr,reduce2_impl,1,0,1,character[],1
+purrr,reduce2_impl,2,0,0,class<`function`>,1
+purrr,reduce2_impl,3,0,0,...,1
+purrr,reduce2_impl,4,0,0,any,1
+purrr,reduce2_impl,5,0,0,logical,1
+purrr,reduce2_impl,6,0,0,logical,1
+purrr,reduce_early,-1,0,0,character,1
+purrr,reduce_early,-1,0,1,list<character>,1
+purrr,reduce_early,0,0,0,"class<`rlang_box`, `rlang_box_done`>",1
+purrr,reduce_early,1,0,0,any,1
+purrr,reduce_early,2,0,0,logical,1
+purrr,reduce_early,3,0,0,any,1
+purrr,reduce_early,4,0,0,any,1
+purrr,reduce_early,5,0,0,any,1
+purrr,reduce_impl,-1,0,0,character[],1
+purrr,reduce_impl,-1,0,1,class<`call`>,1
+purrr,reduce_impl,-1,0,2,integer,1
+purrr,reduce_impl,-1,0,3,list<character>,1
+purrr,reduce_impl,-1,0,4,list<integer>,1
+purrr,reduce_impl,-1,0,5,list<integer | list<integer | list<integer>>>,1
+purrr,reduce_impl,0,0,0,list<character[]>,1
+purrr,reduce_impl,0,0,1,character[],1
+purrr,reduce_impl,0,0,2,list<double | character>,1
+purrr,reduce_impl,0,0,3,integer[],1
+purrr,reduce_impl,1,0,0,class<`function`>,1
+purrr,reduce_impl,2,0,0,...,1
+purrr,reduce_impl,3,0,0,any,1
+purrr,reduce_impl,4,0,0,character[],1
+purrr,reduce_impl,5,0,0,logical,1
+purrr,reduce_index,-1,0,0,integer[],1
+purrr,reduce_index,0,0,0,character[],1
+purrr,reduce_index,0,0,1,integer[],1
+purrr,reduce_index,0,0,2,list<double | character>,1
+purrr,reduce_index,0,0,3,list<double[]>,1
+purrr,reduce_index,0,0,4,list<character[]>,1
+purrr,reduce_index,1,0,0,any,1
+purrr,reduce_index,2,0,0,logical,1
+purrr,reduce_init,-1,0,0,character[],1
+purrr,reduce_init,-1,0,1,class<`name`>,1
+purrr,reduce_init,-1,0,2,double[],1
+purrr,reduce_init,0,0,0,any,1
+purrr,reduce_init,1,0,0,any,1
+purrr,reduce_init,2,0,0,any,1
+purrr,reduce_subset_call,-1,0,0,class<`call`>,1
+purrr,reduce_subset_call,0,0,0,class<`name`>,1
+purrr,reduce_subset_call,1,0,0,list<double | character>,1
+purrr,rerun,-1,0,0,list<double[]>,1
+purrr,rerun,-1,0,1,list<list<double[]>>,1
+purrr,rerun,0,0,0,double,1
+purrr,rerun,1,0,0,...,1
+purrr,safely,-1,0,0,class<`function`>,1
+purrr,safely,0,0,0,class<`function`>,1
+purrr,safely,1,0,0,null,1
+purrr,safely,2,0,0,logical,1
+purrr,seq_len2,-1,0,0,integer[],1
+purrr,seq_len2,0,0,0,double,1
+purrr,seq_len2,1,0,0,integer,1
+purrr,signal_rate_init,-1,0,0,null,1
+purrr,signal_rate_init,0,0,0,"class<`purrr_rate`, `purrr_rate_backoff`>",1
+purrr,signal_rate_init,0,0,1,"class<`purrr_rate`, `purrr_rate_delay`>",1
+purrr,signal_rate_retry,-1,0,0,null,1
+purrr,signal_rate_retry,0,0,0,"class<`purrr_rate`, `purrr_rate_backoff`>",1
+purrr,signal_rate_retry,0,0,1,"class<`purrr_rate`, `purrr_rate_delay`>",1
+purrr,signal_rate_retry,1,0,0,double,1
+purrr,signal_rate_retry,2,0,0,logical,1
+purrr,signal_soft_deprecated,-1,0,0,null,1
+purrr,signal_soft_deprecated,0,0,0,character,1
+purrr,signal_soft_deprecated,1,0,0,character,1
+purrr,signal_soft_deprecated,2,0,0,environment,1
+purrr,silver,-1,0,0,character,1
+purrr,silver,0,0,0,character,1
+purrr,simplify_all,-1,0,0,list<double[]>,1
+purrr,simplify_all,-1,0,1,list<character[]>,1
+purrr,simplify_all,-1,0,2,"list<^double[] | list<class<`condition`, `error`, `simpleError`> | null>>",1
+purrr,simplify_all,0,0,0,list<list<double>>,1
+purrr,simplify_all,0,0,1,list<list<character>>,1
+purrr,simplify_all,0,0,2,"list<list<null | double | class<`condition`, `error`, `simpleError`> | null>>",1
+purrr,simplify_all,1,0,0,null,1
+purrr,slowly,-1,0,0,class<`function`>,1
+purrr,slowly,0,0,0,class<`formula`>,1
+purrr,slowly,1,0,0,"class<`purrr_rate`, `purrr_rate_delay`>",1
+purrr,slowly,2,0,0,logical,1
+purrr,some,-1,0,0,logical,1
+purrr,some,0,0,0,list<integer[] | double>,1
+purrr,some,1,0,0,class<`function`>,1
+purrr,some,2,0,0,...,1
+purrr,splice,-1,0,0,list<character[]>,1
+purrr,splice,0,0,0,...,1
+purrr,splice_if,-1,0,0,list<character[]>,1
+purrr,splice_if,0,0,0,list<character[] | list<character>>,1
+purrr,splice_if,1,0,0,class<`function`>,1
+purrr,stop_rate_excess,-1,0,0,any,1
+purrr,stop_rate_excess,0,0,0,"class<`purrr_rate`, `purrr_rate_backoff`>",1
+purrr,stop_rate_excess,0,0,1,"class<`purrr_rate`, `purrr_rate_delay`>",1
+purrr,tail_while,-1,0,0,integer[],1
+purrr,tail_while,0,0,0,integer[],1
+purrr,tail_while,1,0,0,class<`function`>,1
+purrr,tail_while,1,0,1,"class<`function`, `purrr_function_compose`>",1
+purrr,tail_while,2,0,0,...,1
+purrr,transpose,-1,0,0,list<list<character>>,1
+purrr,transpose,-1,0,1,list<list<double[]>>,1
+purrr,transpose,-1,0,2,"list<list<null | double | class<`condition`, `error`, `simpleError`> | null>>",1
+purrr,transpose,-1,0,3,list<list<double | character | null>>,1
+purrr,transpose,-1,0,4,list<list<double | character | null | null | character>>,1
+purrr,transpose,0,0,0,"class<`data.frame`, `tbl`, `tbl_df`>",1
+purrr,transpose,0,0,1,list<list<double[]>>,1
+purrr,transpose,0,0,2,list<integer[]>,1
+purrr,transpose,0,0,3,list<list<character>>,1
+purrr,transpose,0,0,4,"list<list<null | class<`condition`, `error`, `simpleError`> | double | null>>",1
+purrr,transpose,0,0,5,list<list<double | character | character | double>>,1
+purrr,transpose,1,0,0,null,1
+purrr,transpose,1,0,1,character[],1
+purrr,update_list,-1,0,0,list<double>,1
+purrr,update_list,0,0,0,list<integer>,1
+purrr,update_list,1,0,0,...,1
+purrr,vec_depth,-1,0,0,integer,1
+purrr,vec_depth,0,0,0,double,1
+purrr,vec_depth,0,0,1,list<any>,1
+purrr,vec_index,-1,0,0,character[],1
+purrr,vec_index,-1,0,1,integer[],1
+purrr,vec_index,0,0,0,class<`data.frame`>,1
+purrr,vec_index,0,0,1,integer[],1
+purrr,walk2,-1,0,0,class<`data.frame`>,1
+purrr,walk2,0,0,0,class<`data.frame`>,1
+purrr,walk2,1,0,0,character[],1
+purrr,walk2,2,0,0,"class<`function`, `rlang_lambda_function`>",1
+purrr,walk2,3,0,0,...,1
+purrr,warn_deprecated,-1,0,0,character,1
+purrr,warn_deprecated,-1,0,1,null,1
+purrr,warn_deprecated,0,0,0,any,1
+purrr,warn_deprecated,1,0,0,character,1
+purrr,when,-1,0,0,class<`data.frame`>,1
+purrr,when,-1,0,1,double,1
+purrr,when,0,0,0,class<`data.frame`>,1
+purrr,when,0,0,1,integer[],1
+purrr,when,1,0,0,...,1
+qdapRegex,%|%,-1,0,0,character,1
+qdapRegex,%|%,0,0,0,character,1
+qdapRegex,%|%,1,0,0,character,1
+qdapRegex,%+%,-1,0,0,character,1
+qdapRegex,%+%,0,0,0,character,1
+qdapRegex,%+%,1,0,0,character,1
+qdapRegex,as_count,-1,0,0,class<`data.frame`>,1
+qdapRegex,as_count,0,0,0,"class<`extracted`, `list`>",1
+qdapRegex,as_count,1,0,0,...,1
+qdapRegex,as_numeric,-1,0,0,list<double[] | null>,1
+qdapRegex,as_numeric,0,0,0,"class<`extracted`, `list`>",1
+qdapRegex,as_numeric2,-1,0,0,^double[],1
+qdapRegex,as_numeric2,0,0,0,"class<`extracted`, `list`>",1
+qdapRegex,as_time,-1,0,0,list<character[]>,1
+qdapRegex,as_time,-1,0,1,list<character[] | null>,1
+qdapRegex,as_time,-1,0,2,"list<class<`POSIXlt`, `POSIXt`>>",1
+qdapRegex,as_time,0,0,0,"class<`extracted`, `list`>",1
+qdapRegex,as_time,1,0,0,logical,1
+qdapRegex,as_time,2,0,0,logical,1
+qdapRegex,bind,-1,0,0,character[],1
+qdapRegex,bind,0,0,0,...,1
+qdapRegex,bind,1,0,0,character,1
+qdapRegex,bind,2,0,0,character,1
+qdapRegex,bind,3,0,0,any,1
+qdapRegex,bind_or,-1,0,0,character,1
+qdapRegex,bind_or,0,0,0,...,1
+qdapRegex,bind_or,1,0,0,logical,1
+qdapRegex,bind_or,2,0,0,character,1
+qdapRegex,bind_or,3,0,0,character,1
+qdapRegex,bracket_convert,-1,0,0,list<character[]>,1
+qdapRegex,bracket_convert,0,0,0,character[],1
+qdapRegex,cheat,-1,0,0,class<`data.frame`>,1
+qdapRegex,cheat,0,0,0,class<`data.frame`>,1
+qdapRegex,cheat,1,0,0,logical,1
+qdapRegex,clean,-1,0,0,^character[],1
+qdapRegex,clean,0,0,0,^character[],1
+qdapRegex,distribute,-1,0,0,character[],1
+qdapRegex,distribute,0,0,0,character[],1
+qdapRegex,distribute,1,0,0,logical,1
+qdapRegex,escape,-1,0,0,"class<`character`, `escape`>",1
+qdapRegex,escape,0,0,0,character,1
+qdapRegex,ex_abbreviation,-1,0,0,"class<`extracted`, `list`>",1
+qdapRegex,ex_abbreviation,0,0,0,character[],1
+qdapRegex,ex_abbreviation,1,0,0,logical,1
+qdapRegex,ex_abbreviation,2,0,0,logical,1
+qdapRegex,ex_abbreviation,3,0,0,character,1
+qdapRegex,ex_abbreviation,4,0,0,character,1
+qdapRegex,ex_abbreviation,5,0,0,logical,1
+qdapRegex,ex_abbreviation,6,0,0,null,1
+qdapRegex,ex_abbreviation,7,0,0,...,1
+qdapRegex,ex_angle,-1,0,0,"class<`extracted`, `list`>",1
+qdapRegex,ex_angle,0,0,0,character,1
+qdapRegex,ex_angle,1,0,0,character,1
+qdapRegex,ex_angle,2,0,0,logical,1
+qdapRegex,ex_angle,3,0,0,logical,1
+qdapRegex,ex_angle,4,0,0,character,1
+qdapRegex,ex_angle,5,0,0,logical,1
+qdapRegex,ex_angle,6,0,0,logical,1
+qdapRegex,ex_angle,7,0,0,null,1
+qdapRegex,ex_angle,8,0,0,...,1
+qdapRegex,ex_between,-1,0,0,"class<`extracted`, `list`>",1
+qdapRegex,ex_between,0,0,0,character[],1
+qdapRegex,ex_between,1,0,0,character[],1
+qdapRegex,ex_between,2,0,0,character[],1
+qdapRegex,ex_between,3,0,0,logical,1
+qdapRegex,ex_between,4,0,0,logical,1
+qdapRegex,ex_between,5,0,0,logical,1
+qdapRegex,ex_between,6,0,0,character,1
+qdapRegex,ex_between,7,0,0,logical,1
+qdapRegex,ex_between,8,0,0,logical,1
+qdapRegex,ex_between,9,0,0,null,1
+qdapRegex,ex_between,10,0,0,...,1
+qdapRegex,ex_between_multiple,-1,0,0,"class<`extracted`, `list`>",1
+qdapRegex,ex_between_multiple,-1,0,1,list<character[]>,1
+qdapRegex,ex_between_multiple,0,0,0,character[],1
+qdapRegex,ex_between_multiple,1,0,0,character[],1
+qdapRegex,ex_between_multiple,2,0,0,character[],1
+qdapRegex,ex_between_multiple,3,0,0,logical,1
+qdapRegex,ex_between_multiple,4,0,0,logical,1
+qdapRegex,ex_between_multiple,5,0,0,logical,1
+qdapRegex,ex_between_multiple,6,0,0,character,1
+qdapRegex,ex_between_multiple,7,0,0,logical,1
+qdapRegex,ex_between_multiple,8,0,0,logical,1
+qdapRegex,ex_between_multiple,9,0,0,logical,1
+qdapRegex,ex_bracket,-1,0,0,"class<`extracted`, `list`>",1
+qdapRegex,ex_bracket,0,0,0,character[],1
+qdapRegex,ex_bracket,1,0,0,character[],1
+qdapRegex,ex_bracket,2,0,0,logical,1
+qdapRegex,ex_bracket,3,0,0,logical,1
+qdapRegex,ex_bracket,4,0,0,character,1
+qdapRegex,ex_bracket,5,0,0,logical,1
+qdapRegex,ex_bracket,6,0,0,logical,1
+qdapRegex,ex_bracket,7,0,0,null,1
+qdapRegex,ex_bracket,8,0,0,...,1
+qdapRegex,ex_caps,-1,0,0,"class<`extracted`, `list`>",1
+qdapRegex,ex_caps,0,0,0,character,1
+qdapRegex,ex_caps,1,0,0,logical,1
+qdapRegex,ex_caps,2,0,0,logical,1
+qdapRegex,ex_caps,3,0,0,character,1
+qdapRegex,ex_caps,4,0,0,character,1
+qdapRegex,ex_caps,5,0,0,logical,1
+qdapRegex,ex_caps,6,0,0,null,1
+qdapRegex,ex_caps,7,0,0,...,1
+qdapRegex,ex_caps_phrase,-1,0,0,"class<`extracted`, `list`>",1
+qdapRegex,ex_caps_phrase,0,0,0,character[],1
+qdapRegex,ex_caps_phrase,1,0,0,logical,1
+qdapRegex,ex_caps_phrase,2,0,0,logical,1
+qdapRegex,ex_caps_phrase,3,0,0,character,1
+qdapRegex,ex_caps_phrase,4,0,0,character,1
+qdapRegex,ex_caps_phrase,5,0,0,logical,1
+qdapRegex,ex_caps_phrase,6,0,0,null,1
+qdapRegex,ex_caps_phrase,7,0,0,...,1
+qdapRegex,ex_citation,-1,0,0,"class<`extracted`, `list`>",1
+qdapRegex,ex_citation,0,0,0,character[],1
+qdapRegex,ex_citation,1,0,0,logical,1
+qdapRegex,ex_citation,2,0,0,logical,1
+qdapRegex,ex_citation,3,0,0,character,1
+qdapRegex,ex_citation,4,0,0,character,1
+qdapRegex,ex_citation,5,0,0,logical,1
+qdapRegex,ex_citation,6,0,0,null,1
+qdapRegex,ex_citation,7,0,0,...,1
+qdapRegex,ex_citation_tex,-1,0,0,"class<`extracted`, `list`>",1
+qdapRegex,ex_citation_tex,0,0,0,character[],1
+qdapRegex,ex_citation_tex,1,0,0,logical,1
+qdapRegex,ex_citation_tex,2,0,0,logical,1
+qdapRegex,ex_citation_tex,3,0,0,character,1
+qdapRegex,ex_citation_tex,4,0,0,character,1
+qdapRegex,ex_citation_tex,5,0,0,logical,1
+qdapRegex,ex_citation_tex,6,0,0,logical,1
+qdapRegex,ex_citation_tex,7,0,0,logical,1
+qdapRegex,ex_citation_tex,8,0,0,null,1
+qdapRegex,ex_citation_tex,9,0,0,...,1
+qdapRegex,ex_city_state,-1,0,0,"class<`extracted`, `list`>",1
+qdapRegex,ex_city_state,0,0,0,character,1
+qdapRegex,ex_city_state,1,0,0,logical,1
+qdapRegex,ex_city_state,2,0,0,logical,1
+qdapRegex,ex_city_state,3,0,0,character,1
+qdapRegex,ex_city_state,4,0,0,character,1
+qdapRegex,ex_city_state,5,0,0,logical,1
+qdapRegex,ex_city_state,6,0,0,null,1
+qdapRegex,ex_city_state,7,0,0,...,1
+qdapRegex,ex_city_state_zip,-1,0,0,"class<`extracted`, `list`>",1
+qdapRegex,ex_city_state_zip,0,0,0,character,1
+qdapRegex,ex_city_state_zip,1,0,0,logical,1
+qdapRegex,ex_city_state_zip,2,0,0,logical,1
+qdapRegex,ex_city_state_zip,3,0,0,character,1
+qdapRegex,ex_city_state_zip,4,0,0,character,1
+qdapRegex,ex_city_state_zip,5,0,0,logical,1
+qdapRegex,ex_city_state_zip,6,0,0,null,1
+qdapRegex,ex_city_state_zip,7,0,0,...,1
+qdapRegex,ex_curly,-1,0,0,"class<`extracted`, `list`>",1
+qdapRegex,ex_curly,0,0,0,character,1
+qdapRegex,ex_curly,1,0,0,character,1
+qdapRegex,ex_curly,2,0,0,logical,1
+qdapRegex,ex_curly,3,0,0,logical,1
+qdapRegex,ex_curly,4,0,0,character,1
+qdapRegex,ex_curly,5,0,0,logical,1
+qdapRegex,ex_curly,6,0,0,logical,1
+qdapRegex,ex_curly,7,0,0,null,1
+qdapRegex,ex_curly,8,0,0,...,1
+qdapRegex,ex_date,-1,0,0,"class<`extracted`, `list`>",1
+qdapRegex,ex_date,0,0,0,character[],1
+qdapRegex,ex_date,1,0,0,logical,1
+qdapRegex,ex_date,2,0,0,logical,1
+qdapRegex,ex_date,3,0,0,character,1
+qdapRegex,ex_date,4,0,0,character,1
+qdapRegex,ex_date,5,0,0,logical,1
+qdapRegex,ex_date,6,0,0,null,1
+qdapRegex,ex_date,7,0,0,...,1
+qdapRegex,ex_default,-1,0,0,"class<`extracted`, `list`>",1
+qdapRegex,ex_default,0,0,0,character[],1
+qdapRegex,ex_default,1,0,0,logical,1
+qdapRegex,ex_default,2,0,0,logical,1
+qdapRegex,ex_default,3,0,0,character,1
+qdapRegex,ex_default,4,0,0,character,1
+qdapRegex,ex_default,5,0,0,logical,1
+qdapRegex,ex_default,6,0,0,any,1
+qdapRegex,ex_default,7,0,0,...,1
+qdapRegex,ex_email,-1,0,0,"class<`extracted`, `list`>",1
+qdapRegex,ex_email,0,0,0,character[],1
+qdapRegex,ex_email,1,0,0,logical,1
+qdapRegex,ex_email,2,0,0,logical,1
+qdapRegex,ex_email,3,0,0,character,1
+qdapRegex,ex_email,4,0,0,character,1
+qdapRegex,ex_email,5,0,0,logical,1
+qdapRegex,ex_email,6,0,0,null,1
+qdapRegex,ex_email,7,0,0,...,1
+qdapRegex,ex_emoticon,-1,0,0,"class<`extracted`, `list`>",1
+qdapRegex,ex_emoticon,0,0,0,character[],1
+qdapRegex,ex_emoticon,1,0,0,logical,1
+qdapRegex,ex_emoticon,2,0,0,logical,1
+qdapRegex,ex_emoticon,3,0,0,character,1
+qdapRegex,ex_emoticon,4,0,0,character,1
+qdapRegex,ex_emoticon,5,0,0,logical,1
+qdapRegex,ex_emoticon,6,0,0,null,1
+qdapRegex,ex_emoticon,7,0,0,...,1
+qdapRegex,ex_endmark,-1,0,0,"class<`extracted`, `list`>",1
+qdapRegex,ex_endmark,0,0,0,character[],1
+qdapRegex,ex_endmark,1,0,0,logical,1
+qdapRegex,ex_endmark,2,0,0,logical,1
+qdapRegex,ex_endmark,3,0,0,character,1
+qdapRegex,ex_endmark,4,0,0,character,1
+qdapRegex,ex_endmark,5,0,0,logical,1
+qdapRegex,ex_endmark,6,0,0,null,1
+qdapRegex,ex_endmark,7,0,0,...,1
+qdapRegex,ex_hash,-1,0,0,"class<`extracted`, `list`>",1
+qdapRegex,ex_hash,0,0,0,character[],1
+qdapRegex,ex_hash,1,0,0,logical,1
+qdapRegex,ex_hash,2,0,0,logical,1
+qdapRegex,ex_hash,3,0,0,character,1
+qdapRegex,ex_hash,4,0,0,character,1
+qdapRegex,ex_hash,5,0,0,logical,1
+qdapRegex,ex_hash,6,0,0,null,1
+qdapRegex,ex_hash,7,0,0,...,1
+qdapRegex,ex_nchar_words,-1,0,0,"class<`extracted`, `list`>",1
+qdapRegex,ex_nchar_words,0,0,0,character,1
+qdapRegex,ex_nchar_words,1,0,0,double,1
+qdapRegex,ex_nchar_words,2,0,0,logical,1
+qdapRegex,ex_nchar_words,3,0,0,logical,1
+qdapRegex,ex_nchar_words,4,0,0,character,1
+qdapRegex,ex_nchar_words,5,0,0,character,1
+qdapRegex,ex_nchar_words,6,0,0,logical,1
+qdapRegex,ex_nchar_words,7,0,0,null,1
+qdapRegex,ex_nchar_words,8,0,0,...,1
+qdapRegex,ex_non_ascii,-1,0,0,"class<`extracted`, `list`>",1
+qdapRegex,ex_non_ascii,0,0,0,character[],1
+qdapRegex,ex_non_ascii,1,0,0,logical,1
+qdapRegex,ex_non_ascii,2,0,0,logical,1
+qdapRegex,ex_non_ascii,3,0,0,character,1
+qdapRegex,ex_non_ascii,4,0,0,character,1
+qdapRegex,ex_non_ascii,5,0,0,logical,1
+qdapRegex,ex_non_ascii,6,0,0,null,1
+qdapRegex,ex_non_ascii,7,0,0,logical,1
+qdapRegex,ex_non_ascii,8,0,0,...,1
+qdapRegex,ex_non_words,-1,0,0,"class<`extracted`, `list`>",1
+qdapRegex,ex_non_words,0,0,0,^character[],1
+qdapRegex,ex_non_words,1,0,0,logical,1
+qdapRegex,ex_non_words,2,0,0,logical,1
+qdapRegex,ex_non_words,3,0,0,character,1
+qdapRegex,ex_non_words,4,0,0,character,1
+qdapRegex,ex_non_words,5,0,0,logical,1
+qdapRegex,ex_non_words,6,0,0,any,1
+qdapRegex,ex_non_words,7,0,0,...,1
+qdapRegex,ex_number,-1,0,0,"class<`extracted`, `list`>",1
+qdapRegex,ex_number,0,0,0,character[],1
+qdapRegex,ex_number,1,0,0,logical,1
+qdapRegex,ex_number,2,0,0,logical,1
+qdapRegex,ex_number,3,0,0,character,1
+qdapRegex,ex_number,4,0,0,character,1
+qdapRegex,ex_number,5,0,0,logical,1
+qdapRegex,ex_number,6,0,0,null,1
+qdapRegex,ex_number,7,0,0,...,1
+qdapRegex,ex_percent,-1,0,0,"class<`extracted`, `list`>",1
+qdapRegex,ex_percent,0,0,0,character[],1
+qdapRegex,ex_percent,1,0,0,logical,1
+qdapRegex,ex_percent,2,0,0,logical,1
+qdapRegex,ex_percent,3,0,0,character,1
+qdapRegex,ex_percent,4,0,0,character,1
+qdapRegex,ex_percent,5,0,0,logical,1
+qdapRegex,ex_percent,6,0,0,null,1
+qdapRegex,ex_percent,7,0,0,...,1
+qdapRegex,ex_phone,-1,0,0,"class<`extracted`, `list`>",1
+qdapRegex,ex_phone,0,0,0,character[],1
+qdapRegex,ex_phone,1,0,0,logical,1
+qdapRegex,ex_phone,2,0,0,logical,1
+qdapRegex,ex_phone,3,0,0,character,1
+qdapRegex,ex_phone,4,0,0,character,1
+qdapRegex,ex_phone,5,0,0,logical,1
+qdapRegex,ex_phone,6,0,0,null,1
+qdapRegex,ex_phone,7,0,0,...,1
+qdapRegex,explain,-1,0,0,"class<`character`, `explain`>",1
+qdapRegex,explain,0,0,0,character,1
+qdapRegex,explain,1,0,0,logical,1
+qdapRegex,explain,2,0,0,logical,1
+qdapRegex,explain,3,0,0,any,1
+qdapRegex,ex_postal_code,-1,0,0,"class<`extracted`, `list`>",1
+qdapRegex,ex_postal_code,0,0,0,character[],1
+qdapRegex,ex_postal_code,1,0,0,logical,1
+qdapRegex,ex_postal_code,2,0,0,logical,1
+qdapRegex,ex_postal_code,3,0,0,character,1
+qdapRegex,ex_postal_code,4,0,0,character,1
+qdapRegex,ex_postal_code,5,0,0,logical,1
+qdapRegex,ex_postal_code,6,0,0,null,1
+qdapRegex,ex_postal_code,7,0,0,...,1
+qdapRegex,ex_repeated_characters,-1,0,0,"class<`extracted`, `list`>",1
+qdapRegex,ex_repeated_characters,0,0,0,character,1
+qdapRegex,ex_repeated_characters,1,0,0,logical,1
+qdapRegex,ex_repeated_characters,2,0,0,logical,1
+qdapRegex,ex_repeated_characters,3,0,0,character,1
+qdapRegex,ex_repeated_characters,4,0,0,character,1
+qdapRegex,ex_repeated_characters,5,0,0,logical,1
+qdapRegex,ex_repeated_characters,6,0,0,null,1
+qdapRegex,ex_repeated_characters,7,0,0,...,1
+qdapRegex,ex_repeated_phrases,-1,0,0,"class<`extracted`, `list`>",1
+qdapRegex,ex_repeated_phrases,0,0,0,character[],1
+qdapRegex,ex_repeated_phrases,1,0,0,logical,1
+qdapRegex,ex_repeated_phrases,2,0,0,logical,1
+qdapRegex,ex_repeated_phrases,3,0,0,character,1
+qdapRegex,ex_repeated_phrases,4,0,0,character,1
+qdapRegex,ex_repeated_phrases,5,0,0,logical,1
+qdapRegex,ex_repeated_phrases,6,0,0,null,1
+qdapRegex,ex_repeated_phrases,7,0,0,...,1
+qdapRegex,ex_repeated_words,-1,0,0,"class<`extracted`, `list`>",1
+qdapRegex,ex_repeated_words,0,0,0,character[],1
+qdapRegex,ex_repeated_words,1,0,0,logical,1
+qdapRegex,ex_repeated_words,2,0,0,logical,1
+qdapRegex,ex_repeated_words,3,0,0,character,1
+qdapRegex,ex_repeated_words,4,0,0,character,1
+qdapRegex,ex_repeated_words,5,0,0,logical,1
+qdapRegex,ex_repeated_words,6,0,0,null,1
+qdapRegex,ex_repeated_words,7,0,0,...,1
+qdapRegex,ex_round,-1,0,0,"class<`extracted`, `list`>",1
+qdapRegex,ex_round,0,0,0,character,1
+qdapRegex,ex_round,1,0,0,character,1
+qdapRegex,ex_round,2,0,0,logical,1
+qdapRegex,ex_round,3,0,0,logical,1
+qdapRegex,ex_round,4,0,0,character,1
+qdapRegex,ex_round,5,0,0,logical,1
+qdapRegex,ex_round,6,0,0,logical,1
+qdapRegex,ex_round,7,0,0,null,1
+qdapRegex,ex_round,8,0,0,...,1
+qdapRegex,ex_square,-1,0,0,"class<`extracted`, `list`>",1
+qdapRegex,ex_square,0,0,0,character,1
+qdapRegex,ex_square,1,0,0,character,1
+qdapRegex,ex_square,2,0,0,logical,1
+qdapRegex,ex_square,3,0,0,logical,1
+qdapRegex,ex_square,4,0,0,character,1
+qdapRegex,ex_square,5,0,0,logical,1
+qdapRegex,ex_square,6,0,0,logical,1
+qdapRegex,ex_square,7,0,0,null,1
+qdapRegex,ex_square,8,0,0,...,1
+qdapRegex,ext,-1,0,0,"class<`extracted`, `list`>",1
+qdapRegex,ext,0,0,0,list<character[]>,1
+qdapRegex,ext,0,0,1,list<character[] | null>,1
+qdapRegex,ext,0,0,2,list<character | null>,1
+qdapRegex,ext,0,0,3,list<null | character[]>,1
+qdapRegex,ext,0,0,4,list<null | character>,1
+qdapRegex,ex_tag,-1,0,0,"class<`extracted`, `list`>",1
+qdapRegex,ex_tag,0,0,0,character[],1
+qdapRegex,ex_tag,1,0,0,logical,1
+qdapRegex,ex_tag,2,0,0,logical,1
+qdapRegex,ex_tag,3,0,0,character,1
+qdapRegex,ex_tag,4,0,0,character,1
+qdapRegex,ex_tag,5,0,0,logical,1
+qdapRegex,ex_tag,6,0,0,null,1
+qdapRegex,ex_tag,7,0,0,...,1
+qdapRegex,ex_time,-1,0,0,"class<`extracted`, `list`>",1
+qdapRegex,ex_time,0,0,0,character[],1
+qdapRegex,ex_time,1,0,0,logical,1
+qdapRegex,ex_time,2,0,0,logical,1
+qdapRegex,ex_time,3,0,0,character,1
+qdapRegex,ex_time,4,0,0,character,1
+qdapRegex,ex_time,5,0,0,logical,1
+qdapRegex,ex_time,6,0,0,any,1
+qdapRegex,ex_time,7,0,0,...,1
+qdapRegex,ex_title_name,-1,0,0,"class<`extracted`, `list`>",1
+qdapRegex,ex_title_name,0,0,0,character[],1
+qdapRegex,ex_title_name,1,0,0,logical,1
+qdapRegex,ex_title_name,2,0,0,logical,1
+qdapRegex,ex_title_name,3,0,0,character,1
+qdapRegex,ex_title_name,4,0,0,character,1
+qdapRegex,ex_title_name,5,0,0,logical,1
+qdapRegex,ex_title_name,6,0,0,null,1
+qdapRegex,ex_title_name,7,0,0,...,1
+qdapRegex,ex_transcript_time,-1,0,0,"class<`extracted`, `list`>",1
+qdapRegex,ex_transcript_time,0,0,0,character[],1
+qdapRegex,ex_transcript_time,1,0,0,logical,1
+qdapRegex,ex_transcript_time,2,0,0,logical,1
+qdapRegex,ex_transcript_time,3,0,0,character,1
+qdapRegex,ex_transcript_time,4,0,0,character,1
+qdapRegex,ex_transcript_time,5,0,0,logical,1
+qdapRegex,ex_transcript_time,6,0,0,null,1
+qdapRegex,ex_transcript_time,7,0,0,...,1
+qdapRegex,ex_twitter_url,-1,0,0,"class<`extracted`, `list`>",1
+qdapRegex,ex_twitter_url,0,0,0,character[],1
+qdapRegex,ex_twitter_url,1,0,0,logical,1
+qdapRegex,ex_twitter_url,2,0,0,logical,1
+qdapRegex,ex_twitter_url,3,0,0,character,1
+qdapRegex,ex_twitter_url,4,0,0,character,1
+qdapRegex,ex_twitter_url,5,0,0,logical,1
+qdapRegex,ex_twitter_url,6,0,0,null,1
+qdapRegex,ex_twitter_url,7,0,0,...,1
+qdapRegex,ex_url,-1,0,0,"class<`extracted`, `list`>",1
+qdapRegex,ex_url,0,0,0,character,1
+qdapRegex,ex_url,1,0,0,logical,1
+qdapRegex,ex_url,2,0,0,logical,1
+qdapRegex,ex_url,3,0,0,character,1
+qdapRegex,ex_url,4,0,0,character,1
+qdapRegex,ex_url,5,0,0,logical,1
+qdapRegex,ex_url,6,0,0,null,1
+qdapRegex,ex_url,7,0,0,...,1
+qdapRegex,ex_zip,-1,0,0,"class<`extracted`, `list`>",1
+qdapRegex,ex_zip,0,0,0,character[],1
+qdapRegex,ex_zip,1,0,0,logical,1
+qdapRegex,ex_zip,2,0,0,logical,1
+qdapRegex,ex_zip,3,0,0,character,1
+qdapRegex,ex_zip,4,0,0,character,1
+qdapRegex,ex_zip,5,0,0,logical,1
+qdapRegex,ex_zip,6,0,0,null,1
+qdapRegex,ex_zip,7,0,0,...,1
+qdapRegex,.genX,-1,0,0,character[],1
+qdapRegex,.genX,0,0,0,character[],1
+qdapRegex,.genX,1,0,0,character[],1
+qdapRegex,.genX,2,0,0,character[],1
+qdapRegex,.genX,3,0,0,null,1
+qdapRegex,.genX,4,0,0,logical,1
+qdapRegex,.genX,5,0,0,character,1
+qdapRegex,.genX,6,0,0,logical,1
+qdapRegex,.genXtract,-1,0,0,"class<`extracted`, `list`>",1
+qdapRegex,.genXtract,-1,0,1,list<character[]>,1
+qdapRegex,.genXtract,0,0,0,character[],1
+qdapRegex,.genXtract,1,0,0,character[],1
+qdapRegex,.genXtract,2,0,0,character[],1
+qdapRegex,.genXtract,3,0,0,logical,1
+qdapRegex,.genXtract,4,0,0,any,1
+qdapRegex,.genXtract,5,0,0,logical,1
+qdapRegex,grab,-1,0,0,character,1
+qdapRegex,grab,0,0,0,character,1
+qdapRegex,grab,1,0,0,any,1
+qdapRegex,group,-1,0,0,character[],1
+qdapRegex,group,0,0,0,...,1
+qdapRegex,group,1,0,0,character,1
+qdapRegex,group,2,0,0,character,1
+qdapRegex,group,3,0,0,any,1
+qdapRegex,group_or,-1,0,0,character,1
+qdapRegex,group_or,0,0,0,...,1
+qdapRegex,group_or,1,0,0,logical,1
+qdapRegex,is.regex,-1,0,0,logical,1
+qdapRegex,is.regex,0,0,0,character,1
+qdapRegex,is.regex,0,0,1,"class<`character`, `regexr`>",1
+qdapRegex,L,-1,0,0,list<character>,1
+qdapRegex,L,0,0,0,character[],1
+qdapRegex,L,1,0,0,...,1
+qdapRegex,.mgsub,-1,0,0,character[],1
+qdapRegex,.mgsub,0,0,0,character[],1
+qdapRegex,.mgsub,1,0,0,character[],1
+qdapRegex,.mgsub,2,0,0,character[],1
+qdapRegex,.mgsub,3,0,0,logical,1
+qdapRegex,.mgsub,4,0,0,logical,1
+qdapRegex,.mgsub,5,0,0,logical,1
+qdapRegex,.mgsub,6,0,0,...,1
+qdapRegex,pastex,-1,0,0,character,1
+qdapRegex,pastex,0,0,0,...,1
+qdapRegex,pastex,1,0,0,character,1
+qdapRegex,pastex,2,0,0,any,1
+qdapRegex,reg_check,-1,0,0,character,1
+qdapRegex,reg_check,-1,0,1,"class<`character`, `escape`>",1
+qdapRegex,reg_check,-1,0,2,"class<`character`, `regexr`>",1
+qdapRegex,reg_check,0,0,0,character,1
+qdapRegex,reg_check,0,0,1,double,1
+qdapRegex,reg_check,0,0,2,list<character[]>,1
+qdapRegex,reg_check,0,0,3,"class<`character`, `escape`>",1
+qdapRegex,reg_check,1,0,0,any,1
+qdapRegex,reg_check,2,0,0,any,1
+qdapRegex,reg_check,3,0,0,any,1
+qdapRegex,reg_check_sprintf,-1,0,0,character,1
+qdapRegex,reg_check_sprintf,0,0,0,character,1
+qdapRegex,reg_check_sprintf,1,0,0,null,1
+qdapRegex,reg_check_sprintf,2,0,0,character,1
+qdapRegex,reg_check_sprintf,2,0,1,double,1
+qdapRegex,reg_check_sprintf,3,0,0,"list<class<`character`, `regexr`> | character>",1
+qdapRegex,reg_check_sprintf2,-1,0,0,character,1
+qdapRegex,reg_check_sprintf2,0,0,0,character,1
+qdapRegex,reg_check_sprintf2,1,0,0,null,1
+qdapRegex,reg_check_sprintf2,2,0,0,...,1
+qdapRegex,reg_check_sprintf2,3,0,0,"list<class<`character`, `regexr`> | character>",1
+qdapRegex,rm_,-1,0,0,class<`function`>,1
+qdapRegex,rm_,0,0,0,...,1
+qdapRegex,rm_abbreviation,-1,0,0,character[],1
+qdapRegex,rm_abbreviation,0,0,0,character[],1
+qdapRegex,rm_abbreviation,1,0,0,logical,1
+qdapRegex,rm_abbreviation,2,0,0,logical,1
+qdapRegex,rm_abbreviation,3,0,0,character,1
+qdapRegex,rm_abbreviation,4,0,0,character,1
+qdapRegex,rm_abbreviation,5,0,0,logical,1
+qdapRegex,rm_abbreviation,6,0,0,null,1
+qdapRegex,rm_abbreviation,7,0,0,...,1
+qdapRegex,rm_angle,-1,0,0,character,1
+qdapRegex,rm_angle,0,0,0,character,1
+qdapRegex,rm_angle,1,0,0,character,1
+qdapRegex,rm_angle,2,0,0,logical,1
+qdapRegex,rm_angle,3,0,0,logical,1
+qdapRegex,rm_angle,4,0,0,character,1
+qdapRegex,rm_angle,5,0,0,logical,1
+qdapRegex,rm_angle,6,0,0,logical,1
+qdapRegex,rm_angle,7,0,0,null,1
+qdapRegex,rm_angle,8,0,0,...,1
+qdapRegex,rm_between,-1,0,0,character[],1
+qdapRegex,rm_between,-1,0,1,"class<`extracted`, `list`>",1
+qdapRegex,rm_between,0,0,0,character[],1
+qdapRegex,rm_between,1,0,0,character[],1
+qdapRegex,rm_between,2,0,0,character[],1
+qdapRegex,rm_between,3,0,0,logical,1
+qdapRegex,rm_between,4,0,0,logical,1
+qdapRegex,rm_between,5,0,0,any,1
+qdapRegex,rm_between,6,0,0,any,1
+qdapRegex,rm_between,7,0,0,logical,1
+qdapRegex,rm_between,8,0,0,logical,1
+qdapRegex,rm_between,9,0,0,null,1
+qdapRegex,rm_between,10,0,0,...,1
+qdapRegex,rm_between_double_quote,-1,0,0,list<character[]>,1
+qdapRegex,rm_between_double_quote,0,0,0,character,1
+qdapRegex,rm_between_multiple,-1,0,0,character[],1
+qdapRegex,rm_between_multiple,0,0,0,character[],1
+qdapRegex,rm_between_multiple,1,0,0,character[],1
+qdapRegex,rm_between_multiple,2,0,0,character[],1
+qdapRegex,rm_between_multiple,3,0,0,logical,1
+qdapRegex,rm_between_multiple,4,0,0,logical,1
+qdapRegex,rm_between_multiple,5,0,0,logical,1
+qdapRegex,rm_between_multiple,6,0,0,character,1
+qdapRegex,rm_between_multiple,7,0,0,logical,1
+qdapRegex,rm_between_multiple,8,0,0,logical,1
+qdapRegex,rm_between_multiple,9,0,0,logical,1
+qdapRegex,rm_between_quote,-1,0,0,list<character[]>,1
+qdapRegex,rm_between_quote,0,0,0,character,1
+qdapRegex,rm_between_quote,1,0,0,character,1
+qdapRegex,rm_between_subber,-1,0,0,character,1
+qdapRegex,rm_between_subber,0,0,0,character,1
+qdapRegex,rm_between_subber,1,0,0,character,1
+qdapRegex,rm_between_subber,2,0,0,logical,1
+qdapRegex,rm_between_subber,3,0,0,null,1
+qdapRegex,rm_between_subber,4,0,0,logical,1
+qdapRegex,rm_bracket,-1,0,0,character[],1
+qdapRegex,rm_bracket,0,0,0,character[],1
+qdapRegex,rm_bracket,1,0,0,character[],1
+qdapRegex,rm_bracket,2,0,0,logical,1
+qdapRegex,rm_bracket,3,0,0,logical,1
+qdapRegex,rm_bracket,4,0,0,character,1
+qdapRegex,rm_bracket,5,0,0,logical,1
+qdapRegex,rm_bracket,6,0,0,logical,1
+qdapRegex,rm_bracket,7,0,0,null,1
+qdapRegex,rm_bracket,8,0,0,...,1
+qdapRegex,rm_caps,-1,0,0,character,1
+qdapRegex,rm_caps,0,0,0,character,1
+qdapRegex,rm_caps,1,0,0,logical,1
+qdapRegex,rm_caps,2,0,0,logical,1
+qdapRegex,rm_caps,3,0,0,character,1
+qdapRegex,rm_caps,4,0,0,character,1
+qdapRegex,rm_caps,5,0,0,logical,1
+qdapRegex,rm_caps,6,0,0,null,1
+qdapRegex,rm_caps,7,0,0,...,1
+qdapRegex,rm_caps_phrase,-1,0,0,character[],1
+qdapRegex,rm_caps_phrase,0,0,0,character[],1
+qdapRegex,rm_caps_phrase,1,0,0,logical,1
+qdapRegex,rm_caps_phrase,2,0,0,logical,1
+qdapRegex,rm_caps_phrase,3,0,0,character,1
+qdapRegex,rm_caps_phrase,4,0,0,character,1
+qdapRegex,rm_caps_phrase,5,0,0,logical,1
+qdapRegex,rm_caps_phrase,6,0,0,null,1
+qdapRegex,rm_caps_phrase,7,0,0,...,1
+qdapRegex,rm_citation,-1,0,0,character[],1
+qdapRegex,rm_citation,0,0,0,character[],1
+qdapRegex,rm_citation,1,0,0,logical,1
+qdapRegex,rm_citation,2,0,0,logical,1
+qdapRegex,rm_citation,3,0,0,character,1
+qdapRegex,rm_citation,4,0,0,character,1
+qdapRegex,rm_citation,5,0,0,logical,1
+qdapRegex,rm_citation,6,0,0,null,1
+qdapRegex,rm_citation,7,0,0,...,1
+qdapRegex,rm_citation_tex,-1,0,0,character[],1
+qdapRegex,rm_citation_tex,0,0,0,character[],1
+qdapRegex,rm_citation_tex,1,0,0,logical,1
+qdapRegex,rm_citation_tex,2,0,0,logical,1
+qdapRegex,rm_citation_tex,3,0,0,character,1
+qdapRegex,rm_citation_tex,4,0,0,character,1
+qdapRegex,rm_citation_tex,5,0,0,logical,1
+qdapRegex,rm_citation_tex,6,0,0,any,1
+qdapRegex,rm_citation_tex,7,0,0,logical,1
+qdapRegex,rm_citation_tex,8,0,0,null,1
+qdapRegex,rm_citation_tex,9,0,0,...,1
+qdapRegex,rm_city_state,-1,0,0,character,1
+qdapRegex,rm_city_state,0,0,0,character,1
+qdapRegex,rm_city_state,1,0,0,logical,1
+qdapRegex,rm_city_state,2,0,0,logical,1
+qdapRegex,rm_city_state,3,0,0,character,1
+qdapRegex,rm_city_state,4,0,0,character,1
+qdapRegex,rm_city_state,5,0,0,logical,1
+qdapRegex,rm_city_state,6,0,0,null,1
+qdapRegex,rm_city_state,7,0,0,...,1
+qdapRegex,rm_city_state_zip,-1,0,0,character,1
+qdapRegex,rm_city_state_zip,0,0,0,character,1
+qdapRegex,rm_city_state_zip,1,0,0,logical,1
+qdapRegex,rm_city_state_zip,2,0,0,logical,1
+qdapRegex,rm_city_state_zip,3,0,0,character,1
+qdapRegex,rm_city_state_zip,4,0,0,character,1
+qdapRegex,rm_city_state_zip,5,0,0,logical,1
+qdapRegex,rm_city_state_zip,6,0,0,null,1
+qdapRegex,rm_city_state_zip,7,0,0,...,1
+qdapRegex,rm_curly,-1,0,0,character,1
+qdapRegex,rm_curly,-1,0,1,"class<`extracted`, `list`>",1
+qdapRegex,rm_curly,0,0,0,character[],1
+qdapRegex,rm_curly,1,0,0,character,1
+qdapRegex,rm_curly,2,0,0,logical,1
+qdapRegex,rm_curly,3,0,0,logical,1
+qdapRegex,rm_curly,4,0,0,character,1
+qdapRegex,rm_curly,5,0,0,logical,1
+qdapRegex,rm_curly,6,0,0,logical,1
+qdapRegex,rm_curly,7,0,0,null,1
+qdapRegex,rm_curly,8,0,0,...,1
+qdapRegex,rm_date,-1,0,0,character,1
+qdapRegex,rm_date,0,0,0,character,1
+qdapRegex,rm_date,1,0,0,logical,1
+qdapRegex,rm_date,2,0,0,logical,1
+qdapRegex,rm_date,3,0,0,character,1
+qdapRegex,rm_date,4,0,0,character,1
+qdapRegex,rm_date,5,0,0,logical,1
+qdapRegex,rm_date,6,0,0,null,1
+qdapRegex,rm_date,7,0,0,...,1
+qdapRegex,rm_default,-1,0,0,character[],1
+qdapRegex,rm_default,-1,0,1,"class<`extracted`, `list`>",1
+qdapRegex,rm_default,0,0,0,character[],1
+qdapRegex,rm_default,1,0,0,logical,1
+qdapRegex,rm_default,2,0,0,any,1
+qdapRegex,rm_default,3,0,0,character,1
+qdapRegex,rm_default,3,0,1,"class<`character`, `escape`>",1
+qdapRegex,rm_default,4,0,0,any,1
+qdapRegex,rm_default,5,0,0,logical,1
+qdapRegex,rm_default,6,0,0,any,1
+qdapRegex,rm_default,7,0,0,...,1
+qdapRegex,rm_dollar,-1,0,0,"class<`extracted`, `list`>",1
+qdapRegex,rm_dollar,0,0,0,character[],1
+qdapRegex,rm_dollar,1,0,0,logical,1
+qdapRegex,rm_dollar,2,0,0,logical,1
+qdapRegex,rm_dollar,3,0,0,character,1
+qdapRegex,rm_dollar,4,0,0,character,1
+qdapRegex,rm_dollar,5,0,0,logical,1
+qdapRegex,rm_dollar,6,0,0,any,1
+qdapRegex,rm_dollar,7,0,0,...,1
+qdapRegex,rm_email,-1,0,0,character,1
+qdapRegex,rm_email,0,0,0,character,1
+qdapRegex,rm_email,1,0,0,logical,1
+qdapRegex,rm_email,2,0,0,logical,1
+qdapRegex,rm_email,3,0,0,character,1
+qdapRegex,rm_email,4,0,0,character,1
+qdapRegex,rm_email,5,0,0,logical,1
+qdapRegex,rm_email,6,0,0,null,1
+qdapRegex,rm_email,7,0,0,...,1
+qdapRegex,rm_emoticon,-1,0,0,character[],1
+qdapRegex,rm_emoticon,0,0,0,character[],1
+qdapRegex,rm_emoticon,1,0,0,logical,1
+qdapRegex,rm_emoticon,2,0,0,logical,1
+qdapRegex,rm_emoticon,3,0,0,character,1
+qdapRegex,rm_emoticon,4,0,0,character,1
+qdapRegex,rm_emoticon,5,0,0,logical,1
+qdapRegex,rm_emoticon,6,0,0,null,1
+qdapRegex,rm_emoticon,7,0,0,...,1
+qdapRegex,rm_endmark,-1,0,0,character[],1
+qdapRegex,rm_endmark,0,0,0,character[],1
+qdapRegex,rm_endmark,1,0,0,logical,1
+qdapRegex,rm_endmark,2,0,0,logical,1
+qdapRegex,rm_endmark,3,0,0,character,1
+qdapRegex,rm_endmark,4,0,0,character,1
+qdapRegex,rm_endmark,5,0,0,logical,1
+qdapRegex,rm_endmark,6,0,0,null,1
+qdapRegex,rm_endmark,7,0,0,...,1
+qdapRegex,rm_hash,-1,0,0,character[],1
+qdapRegex,rm_hash,0,0,0,character[],1
+qdapRegex,rm_hash,1,0,0,logical,1
+qdapRegex,rm_hash,2,0,0,logical,1
+qdapRegex,rm_hash,3,0,0,character,1
+qdapRegex,rm_hash,4,0,0,character,1
+qdapRegex,rm_hash,5,0,0,logical,1
+qdapRegex,rm_hash,6,0,0,null,1
+qdapRegex,rm_hash,7,0,0,...,1
+qdapRegex,rm_nchar_words,-1,0,0,character,1
+qdapRegex,rm_nchar_words,0,0,0,character,1
+qdapRegex,rm_nchar_words,1,0,0,character,1
+qdapRegex,rm_nchar_words,1,0,1,double,1
+qdapRegex,rm_nchar_words,2,0,0,logical,1
+qdapRegex,rm_nchar_words,3,0,0,logical,1
+qdapRegex,rm_nchar_words,4,0,0,character,1
+qdapRegex,rm_nchar_words,5,0,0,character,1
+qdapRegex,rm_nchar_words,6,0,0,logical,1
+qdapRegex,rm_nchar_words,7,0,0,null,1
+qdapRegex,rm_nchar_words,8,0,0,...,1
+qdapRegex,rm_non_ascii,-1,0,0,character[],1
+qdapRegex,rm_non_ascii,0,0,0,character[],1
+qdapRegex,rm_non_ascii,1,0,0,logical,1
+qdapRegex,rm_non_ascii,2,0,0,logical,1
+qdapRegex,rm_non_ascii,3,0,0,character,1
+qdapRegex,rm_non_ascii,4,0,0,character,1
+qdapRegex,rm_non_ascii,5,0,0,logical,1
+qdapRegex,rm_non_ascii,6,0,0,null,1
+qdapRegex,rm_non_ascii,7,0,0,logical,1
+qdapRegex,rm_non_ascii,8,0,0,...,1
+qdapRegex,rm_non_words,-1,0,0,^character[],1
+qdapRegex,rm_non_words,0,0,0,^character[],1
+qdapRegex,rm_non_words,1,0,0,logical,1
+qdapRegex,rm_non_words,2,0,0,logical,1
+qdapRegex,rm_non_words,3,0,0,character,1
+qdapRegex,rm_non_words,4,0,0,character,1
+qdapRegex,rm_non_words,5,0,0,logical,1
+qdapRegex,rm_non_words,6,0,0,null,1
+qdapRegex,rm_non_words,7,0,0,...,1
+qdapRegex,rm_number,-1,0,0,character[],1
+qdapRegex,rm_number,0,0,0,character[],1
+qdapRegex,rm_number,1,0,0,logical,1
+qdapRegex,rm_number,2,0,0,logical,1
+qdapRegex,rm_number,3,0,0,character,1
+qdapRegex,rm_number,4,0,0,character,1
+qdapRegex,rm_number,5,0,0,logical,1
+qdapRegex,rm_number,6,0,0,null,1
+qdapRegex,rm_number,7,0,0,...,1
+qdapRegex,rm_percent,-1,0,0,character[],1
+qdapRegex,rm_percent,0,0,0,character[],1
+qdapRegex,rm_percent,1,0,0,logical,1
+qdapRegex,rm_percent,2,0,0,logical,1
+qdapRegex,rm_percent,3,0,0,character,1
+qdapRegex,rm_percent,4,0,0,character,1
+qdapRegex,rm_percent,5,0,0,logical,1
+qdapRegex,rm_percent,6,0,0,null,1
+qdapRegex,rm_percent,7,0,0,...,1
+qdapRegex,rm_phone,-1,0,0,character[],1
+qdapRegex,rm_phone,0,0,0,character[],1
+qdapRegex,rm_phone,1,0,0,logical,1
+qdapRegex,rm_phone,2,0,0,logical,1
+qdapRegex,rm_phone,3,0,0,character,1
+qdapRegex,rm_phone,4,0,0,character,1
+qdapRegex,rm_phone,5,0,0,logical,1
+qdapRegex,rm_phone,6,0,0,null,1
+qdapRegex,rm_phone,7,0,0,...,1
+qdapRegex,rm_postal_code,-1,0,0,character[],1
+qdapRegex,rm_postal_code,0,0,0,character[],1
+qdapRegex,rm_postal_code,1,0,0,logical,1
+qdapRegex,rm_postal_code,2,0,0,logical,1
+qdapRegex,rm_postal_code,3,0,0,character,1
+qdapRegex,rm_postal_code,4,0,0,character,1
+qdapRegex,rm_postal_code,5,0,0,logical,1
+qdapRegex,rm_postal_code,6,0,0,null,1
+qdapRegex,rm_postal_code,7,0,0,...,1
+qdapRegex,rm_repeated_characters,-1,0,0,character,1
+qdapRegex,rm_repeated_characters,0,0,0,character,1
+qdapRegex,rm_repeated_characters,1,0,0,logical,1
+qdapRegex,rm_repeated_characters,2,0,0,logical,1
+qdapRegex,rm_repeated_characters,3,0,0,character,1
+qdapRegex,rm_repeated_characters,4,0,0,character,1
+qdapRegex,rm_repeated_characters,5,0,0,logical,1
+qdapRegex,rm_repeated_characters,6,0,0,null,1
+qdapRegex,rm_repeated_characters,7,0,0,...,1
+qdapRegex,rm_repeated_phrases,-1,0,0,character[],1
+qdapRegex,rm_repeated_phrases,0,0,0,character[],1
+qdapRegex,rm_repeated_phrases,1,0,0,logical,1
+qdapRegex,rm_repeated_phrases,2,0,0,logical,1
+qdapRegex,rm_repeated_phrases,3,0,0,character,1
+qdapRegex,rm_repeated_phrases,4,0,0,character,1
+qdapRegex,rm_repeated_phrases,5,0,0,logical,1
+qdapRegex,rm_repeated_phrases,6,0,0,null,1
+qdapRegex,rm_repeated_phrases,7,0,0,...,1
+qdapRegex,rm_repeated_words,-1,0,0,character[],1
+qdapRegex,rm_repeated_words,0,0,0,character[],1
+qdapRegex,rm_repeated_words,1,0,0,logical,1
+qdapRegex,rm_repeated_words,2,0,0,logical,1
+qdapRegex,rm_repeated_words,3,0,0,character,1
+qdapRegex,rm_repeated_words,4,0,0,character,1
+qdapRegex,rm_repeated_words,5,0,0,logical,1
+qdapRegex,rm_repeated_words,6,0,0,null,1
+qdapRegex,rm_repeated_words,7,0,0,...,1
+qdapRegex,rm_round,-1,0,0,character,1
+qdapRegex,rm_round,0,0,0,character,1
+qdapRegex,rm_round,1,0,0,character,1
+qdapRegex,rm_round,2,0,0,logical,1
+qdapRegex,rm_round,3,0,0,logical,1
+qdapRegex,rm_round,4,0,0,character,1
+qdapRegex,rm_round,5,0,0,logical,1
+qdapRegex,rm_round,6,0,0,logical,1
+qdapRegex,rm_round,7,0,0,null,1
+qdapRegex,rm_round,8,0,0,...,1
+qdapRegex,rm_square,-1,0,0,character,1
+qdapRegex,rm_square,0,0,0,character,1
+qdapRegex,rm_square,1,0,0,character,1
+qdapRegex,rm_square,2,0,0,logical,1
+qdapRegex,rm_square,3,0,0,logical,1
+qdapRegex,rm_square,4,0,0,character,1
+qdapRegex,rm_square,5,0,0,logical,1
+qdapRegex,rm_square,6,0,0,logical,1
+qdapRegex,rm_square,7,0,0,null,1
+qdapRegex,rm_square,8,0,0,...,1
+qdapRegex,rm_tag,-1,0,0,character[],1
+qdapRegex,rm_tag,0,0,0,character[],1
+qdapRegex,rm_tag,1,0,0,logical,1
+qdapRegex,rm_tag,2,0,0,logical,1
+qdapRegex,rm_tag,3,0,0,character,1
+qdapRegex,rm_tag,4,0,0,character,1
+qdapRegex,rm_tag,5,0,0,logical,1
+qdapRegex,rm_tag,6,0,0,null,1
+qdapRegex,rm_tag,7,0,0,...,1
+qdapRegex,rm_time,-1,0,0,character[],1
+qdapRegex,rm_time,0,0,0,character[],1
+qdapRegex,rm_time,1,0,0,logical,1
+qdapRegex,rm_time,2,0,0,logical,1
+qdapRegex,rm_time,3,0,0,character,1
+qdapRegex,rm_time,4,0,0,character,1
+qdapRegex,rm_time,5,0,0,logical,1
+qdapRegex,rm_time,6,0,0,null,1
+qdapRegex,rm_time,7,0,0,...,1
+qdapRegex,rm_title_name,-1,0,0,character[],1
+qdapRegex,rm_title_name,0,0,0,character[],1
+qdapRegex,rm_title_name,1,0,0,logical,1
+qdapRegex,rm_title_name,2,0,0,logical,1
+qdapRegex,rm_title_name,3,0,0,character,1
+qdapRegex,rm_title_name,4,0,0,character,1
+qdapRegex,rm_title_name,5,0,0,logical,1
+qdapRegex,rm_title_name,6,0,0,null,1
+qdapRegex,rm_title_name,7,0,0,...,1
+qdapRegex,rm_transcript_time,-1,0,0,character[],1
+qdapRegex,rm_transcript_time,0,0,0,character[],1
+qdapRegex,rm_transcript_time,1,0,0,logical,1
+qdapRegex,rm_transcript_time,2,0,0,logical,1
+qdapRegex,rm_transcript_time,3,0,0,character,1
+qdapRegex,rm_transcript_time,4,0,0,character,1
+qdapRegex,rm_transcript_time,5,0,0,logical,1
+qdapRegex,rm_transcript_time,6,0,0,null,1
+qdapRegex,rm_transcript_time,7,0,0,...,1
+qdapRegex,rm_twitter_url,-1,0,0,character[],1
+qdapRegex,rm_twitter_url,-1,0,1,"class<`extracted`, `list`>",1
+qdapRegex,rm_twitter_url,0,0,0,character[],1
+qdapRegex,rm_twitter_url,1,0,0,logical,1
+qdapRegex,rm_twitter_url,2,0,0,logical,1
+qdapRegex,rm_twitter_url,3,0,0,character,1
+qdapRegex,rm_twitter_url,4,0,0,character,1
+qdapRegex,rm_twitter_url,5,0,0,logical,1
+qdapRegex,rm_twitter_url,6,0,0,null,1
+qdapRegex,rm_twitter_url,7,0,0,...,1
+qdapRegex,rm_url,-1,0,0,character,1
+qdapRegex,rm_url,0,0,0,character,1
+qdapRegex,rm_url,1,0,0,logical,1
+qdapRegex,rm_url,2,0,0,logical,1
+qdapRegex,rm_url,3,0,0,character,1
+qdapRegex,rm_url,4,0,0,character,1
+qdapRegex,rm_url,5,0,0,logical,1
+qdapRegex,rm_url,6,0,0,null,1
+qdapRegex,rm_url,7,0,0,...,1
+qdapRegex,rm_white,-1,0,0,character[],1
+qdapRegex,rm_white,0,0,0,character[],1
+qdapRegex,rm_white,1,0,0,logical,1
+qdapRegex,rm_white,2,0,0,logical,1
+qdapRegex,rm_white,3,0,0,character,1
+qdapRegex,rm_white,4,0,0,character,1
+qdapRegex,rm_white,5,0,0,logical,1
+qdapRegex,rm_white,6,0,0,null,1
+qdapRegex,rm_white,7,0,0,...,1
+qdapRegex,rm_white_bracket,-1,0,0,character[],1
+qdapRegex,rm_white_bracket,0,0,0,character[],1
+qdapRegex,rm_white_bracket,1,0,0,logical,1
+qdapRegex,rm_white_bracket,2,0,0,logical,1
+qdapRegex,rm_white_bracket,3,0,0,character,1
+qdapRegex,rm_white_bracket,4,0,0,character,1
+qdapRegex,rm_white_bracket,5,0,0,logical,1
+qdapRegex,rm_white_bracket,6,0,0,null,1
+qdapRegex,rm_white_bracket,7,0,0,...,1
+qdapRegex,rm_white_colon,-1,0,0,character[],1
+qdapRegex,rm_white_colon,0,0,0,character[],1
+qdapRegex,rm_white_colon,1,0,0,logical,1
+qdapRegex,rm_white_colon,2,0,0,logical,1
+qdapRegex,rm_white_colon,3,0,0,character,1
+qdapRegex,rm_white_colon,4,0,0,character,1
+qdapRegex,rm_white_colon,5,0,0,logical,1
+qdapRegex,rm_white_colon,6,0,0,null,1
+qdapRegex,rm_white_colon,7,0,0,...,1
+qdapRegex,rm_white_comma,-1,0,0,character[],1
+qdapRegex,rm_white_comma,0,0,0,character[],1
+qdapRegex,rm_white_comma,1,0,0,logical,1
+qdapRegex,rm_white_comma,2,0,0,logical,1
+qdapRegex,rm_white_comma,3,0,0,character,1
+qdapRegex,rm_white_comma,4,0,0,character,1
+qdapRegex,rm_white_comma,5,0,0,logical,1
+qdapRegex,rm_white_comma,6,0,0,null,1
+qdapRegex,rm_white_comma,7,0,0,...,1
+qdapRegex,rm_white_endmark,-1,0,0,character[],1
+qdapRegex,rm_white_endmark,0,0,0,character[],1
+qdapRegex,rm_white_endmark,1,0,0,logical,1
+qdapRegex,rm_white_endmark,2,0,0,logical,1
+qdapRegex,rm_white_endmark,3,0,0,character,1
+qdapRegex,rm_white_endmark,4,0,0,character,1
+qdapRegex,rm_white_endmark,5,0,0,logical,1
+qdapRegex,rm_white_endmark,6,0,0,null,1
+qdapRegex,rm_white_endmark,7,0,0,...,1
+qdapRegex,rm_white_lead,-1,0,0,character[],1
+qdapRegex,rm_white_lead,0,0,0,character[],1
+qdapRegex,rm_white_lead,1,0,0,logical,1
+qdapRegex,rm_white_lead,2,0,0,logical,1
+qdapRegex,rm_white_lead,3,0,0,character,1
+qdapRegex,rm_white_lead,4,0,0,character,1
+qdapRegex,rm_white_lead,5,0,0,logical,1
+qdapRegex,rm_white_lead,6,0,0,null,1
+qdapRegex,rm_white_lead,7,0,0,...,1
+qdapRegex,rm_white_lead_trail,-1,0,0,character[],1
+qdapRegex,rm_white_lead_trail,0,0,0,character[],1
+qdapRegex,rm_white_lead_trail,1,0,0,logical,1
+qdapRegex,rm_white_lead_trail,2,0,0,logical,1
+qdapRegex,rm_white_lead_trail,3,0,0,character,1
+qdapRegex,rm_white_lead_trail,4,0,0,character,1
+qdapRegex,rm_white_lead_trail,5,0,0,logical,1
+qdapRegex,rm_white_lead_trail,6,0,0,null,1
+qdapRegex,rm_white_lead_trail,7,0,0,...,1
+qdapRegex,rm_white_multiple,-1,0,0,character[],1
+qdapRegex,rm_white_multiple,0,0,0,character[],1
+qdapRegex,rm_white_multiple,1,0,0,logical,1
+qdapRegex,rm_white_multiple,2,0,0,logical,1
+qdapRegex,rm_white_multiple,3,0,0,character,1
+qdapRegex,rm_white_multiple,4,0,0,character,1
+qdapRegex,rm_white_multiple,5,0,0,logical,1
+qdapRegex,rm_white_multiple,6,0,0,null,1
+qdapRegex,rm_white_multiple,7,0,0,...,1
+qdapRegex,rm_white_punctuation,-1,0,0,character[],1
+qdapRegex,rm_white_punctuation,0,0,0,character[],1
+qdapRegex,rm_white_punctuation,1,0,0,logical,1
+qdapRegex,rm_white_punctuation,2,0,0,logical,1
+qdapRegex,rm_white_punctuation,3,0,0,character,1
+qdapRegex,rm_white_punctuation,4,0,0,character,1
+qdapRegex,rm_white_punctuation,5,0,0,logical,1
+qdapRegex,rm_white_punctuation,6,0,0,null,1
+qdapRegex,rm_white_punctuation,7,0,0,...,1
+qdapRegex,rm_white_trail,-1,0,0,character[],1
+qdapRegex,rm_white_trail,0,0,0,character[],1
+qdapRegex,rm_white_trail,1,0,0,logical,1
+qdapRegex,rm_white_trail,2,0,0,logical,1
+qdapRegex,rm_white_trail,3,0,0,character,1
+qdapRegex,rm_white_trail,4,0,0,character,1
+qdapRegex,rm_white_trail,5,0,0,logical,1
+qdapRegex,rm_white_trail,6,0,0,null,1
+qdapRegex,rm_white_trail,7,0,0,...,1
+qdapRegex,rm_zip,-1,0,0,character[],1
+qdapRegex,rm_zip,0,0,0,character[],1
+qdapRegex,rm_zip,1,0,0,logical,1
+qdapRegex,rm_zip,2,0,0,logical,1
+qdapRegex,rm_zip,3,0,0,character,1
+qdapRegex,rm_zip,4,0,0,character,1
+qdapRegex,rm_zip,5,0,0,logical,1
+qdapRegex,rm_zip,6,0,0,null,1
+qdapRegex,rm_zip,7,0,0,...,1
+qdapRegex,S,-1,0,0,character,1
+qdapRegex,S,0,0,0,character,1
+qdapRegex,S,1,0,0,...,1
+qdapRegex,TC,-1,0,0,list<character>,1
+qdapRegex,TC,0,0,0,character[],1
+qdapRegex,TC,1,0,0,null,1
+qdapRegex,TC,2,0,0,...,1
+qdapRegex,Trim,-1,0,0,null,1
+qdapRegex,Trim,-1,0,1,^character[],1
+qdapRegex,Trim,0,0,0,null,1
+qdapRegex,Trim,0,0,1,^character[],1
+qdapRegex,U,-1,0,0,list<character>,1
+qdapRegex,U,0,0,0,character[],1
+qdapRegex,U,1,0,0,...,1
+qdapRegex,validate,-1,0,0,class<`function`>,1
+qdapRegex,validate,0,0,0,any,1
+qdapRegex,validate,1,0,0,logical,1
+qdapRegex,validate,2,0,0,logical,1
+qdapRegex,validate,3,0,0,logical,1
+qdapRegex,validate,4,0,0,any,1
+quadprog,solve.QP,-1,0,0,list<double[]>,1
+quadprog,solve.QP,0,0,0,class<`matrix`>,1
+quadprog,solve.QP,1,0,0,double[],1
+quadprog,solve.QP,2,0,0,class<`matrix`>,1
+quadprog,solve.QP,3,0,0,double[],1
+quadprog,solve.QP,4,0,0,double,1
+quadprog,solve.QP,5,0,0,logical,1
+quadprog,solve.QP.compact,-1,0,0,list<double[]>,1
+quadprog,solve.QP.compact,0,0,0,class<`matrix`>,1
+quadprog,solve.QP.compact,1,0,0,double[],1
+quadprog,solve.QP.compact,2,0,0,class<`matrix`>,1
+quadprog,solve.QP.compact,3,0,0,class<`matrix`>,1
+quadprog,solve.QP.compact,4,0,0,double[],1
+quadprog,solve.QP.compact,5,0,0,double,1
+quadprog,solve.QP.compact,6,0,0,logical,1
+quantreg,akj,-1,0,0,list<double[]>,1
+quantreg,akj,0,0,0,class<`matrix`>,1
+quantreg,akj,0,0,1,double[],1
+quantreg,akj,1,0,0,double[],1
+quantreg,akj,2,0,0,double[],1
+quantreg,akj,3,0,0,double,1
+quantreg,akj,4,0,0,double,1
+quantreg,akj,5,0,0,double,1
+quantreg,akj,6,0,0,double,1
+quantreg,anova.rq,-1,0,0,class<`anova.rq`>,1
+quantreg,anova.rq,0,0,0,"class<`dynrq`, `rq`>",1
+quantreg,anova.rq,0,0,1,class<`rq`>,1
+quantreg,anova.rq,1,0,0,...,1
+quantreg,anova.rq,2,0,0,character,1
+quantreg,anova.rq,3,0,0,logical,1
+quantreg,anova.rq,4,0,0,character,1
+quantreg,anova.rq,5,0,0,character,1
+quantreg,anova.rq,6,0,0,logical,1
+quantreg,anova.rq,7,0,0,double,1
+quantreg,anova.rqlist,-1,0,0,class<`anova.rq`>,1
+quantreg,anova.rqlist,0,0,0,"list<class<`dynrq`, `rq`>>",1
+quantreg,anova.rqlist,0,0,1,list<class<`rq`>>,1
+quantreg,anova.rqlist,1,0,0,...,1
+quantreg,anova.rqlist,2,0,0,character,1
+quantreg,anova.rqlist,3,0,0,any,1
+quantreg,anova.rqlist,4,0,0,any,1
+quantreg,anova.rqlist,5,0,0,character,1
+quantreg,anova.rqlist,6,0,0,any,1
+quantreg,anova.rqlist,7,0,0,double,1
+quantreg,bandwidth.rq,-1,0,0,double,1
+quantreg,bandwidth.rq,0,0,0,double,1
+quantreg,bandwidth.rq,1,0,0,double,1
+quantreg,bandwidth.rq,2,0,0,logical,1
+quantreg,bandwidth.rq,3,0,0,double,1
+quantreg,boot.crq,-1,0,0,list<class<`array`> | double | character>,1
+quantreg,boot.crq,0,0,0,class<`matrix`>,1
+quantreg,boot.crq,1,0,0,double[],1
+quantreg,boot.crq,2,0,0,double[],1
+quantreg,boot.crq,3,0,0,double[],1
+quantreg,boot.crq,4,0,0,character,1
+quantreg,boot.crq,5,0,0,character,1
+quantreg,boot.crq,6,0,0,double,1
+quantreg,boot.crq,7,0,0,any,1
+quantreg,boot.rq,-1,0,0,list<class<`matrix`>>,1
+quantreg,boot.rq,0,0,0,class<`matrix`>,1
+quantreg,boot.rq,1,0,0,double[],1
+quantreg,boot.rq,2,0,0,double,1
+quantreg,boot.rq,3,0,0,double,1
+quantreg,boot.rq,4,0,0,character,1
+quantreg,boot.rq,5,0,0,any,1
+quantreg,boot.rq,6,0,0,null,1
+quantreg,boot.rq,7,0,0,null,1
+quantreg,boot.rq.pwy,-1,0,0,class<`matrix`>,1
+quantreg,boot.rq.pwy,0,0,0,class<`matrix`>,1
+quantreg,boot.rq.pwy,1,0,0,class<`matrix`>,1
+quantreg,boot.rq.pwy,2,0,0,double[],1
+quantreg,boot.rq.pwy,3,0,0,double,1
+quantreg,boot.rq.pwy,4,0,0,double,1
+quantreg,boot.rq.xy,-1,0,0,class<`matrix`>,1
+quantreg,boot.rq.xy,0,0,0,class<`matrix`>,1
+quantreg,boot.rq.xy,1,0,0,double[],1
+quantreg,boot.rq.xy,2,0,0,class<`matrix`>,1
+quantreg,boot.rq.xy,3,0,0,double,1
+quantreg,boot.rq.xy,4,0,0,double,1
+quantreg,coef.crq,-1,0,0,class<`matrix`>,1
+quantreg,coef.crq,0,0,0,class<`crq`>,1
+quantreg,coef.crq,1,0,0,double[],1
+quantreg,coef.crq,2,0,0,...,1
+quantreg,combos,-1,0,0,class<`matrix`>,1
+quantreg,combos,0,0,0,double,1
+quantreg,combos,1,0,0,double,1
+quantreg,crq,-1,0,0,class<`crq`>,1
+quantreg,crq,0,0,0,class<`formula`>,1
+quantreg,crq,1,0,0,any,1
+quantreg,crq,2,0,0,any,1
+quantreg,crq,3,0,0,any,1
+quantreg,crq,4,0,0,any,1
+quantreg,crq,5,0,0,any,1
+quantreg,crq,6,0,0,character,1
+quantreg,crq,7,0,0,null,1
+quantreg,crq.fit.por,-1,0,0,class<`crq`>,1
+quantreg,crq.fit.por,0,0,0,class<`matrix`>,1
+quantreg,crq.fit.por,1,0,0,double[],1
+quantreg,crq.fit.por,2,0,0,double[],1
+quantreg,crq.fit.por,3,0,0,double[],1
+quantreg,crq.fit.por,3,0,1,null,1
+quantreg,crq.fit.por,4,0,0,any,1
+quantreg,crq.fit.por,5,0,0,character,1
+quantreg,crq.fit.pow,-1,0,0,list<double[] | class<`matrix`>>,1
+quantreg,crq.fit.pow,0,0,0,class<`matrix`>,1
+quantreg,crq.fit.pow,1,0,0,double[],1
+quantreg,crq.fit.pow,2,0,0,double[],1
+quantreg,crq.fit.pow,3,0,0,double,1
+quantreg,crq.fit.pow,4,0,0,null,1
+quantreg,crq.fit.pow,5,0,0,any,1
+quantreg,crq.fit.pow,6,0,0,logical,1
+quantreg,crq.fit.pow,7,0,0,double,1
+quantreg,Curv,-1,0,0,class<`Surv`>,1
+quantreg,Curv,0,0,0,double[],1
+quantreg,Curv,1,0,0,double[],1
+quantreg,Curv,2,0,0,character[],1
+quantreg,dither,-1,0,0,double[],1
+quantreg,dither,0,0,0,integer[],1
+quantreg,dither,1,0,0,character,1
+quantreg,dither,2,0,0,double,1
+quantreg,dynrq,-1,0,0,"class<`dynrq`, `rq`>",1
+quantreg,dynrq,-1,0,1,"class<`dynrqs`, `rqs`>",1
+quantreg,dynrq,0,0,0,class<`formula`>,1
+quantreg,dynrq,1,0,0,double[],1
+quantreg,dynrq,2,0,0,any,1
+quantreg,dynrq,3,0,0,any,1
+quantreg,dynrq,4,0,0,any,1
+quantreg,dynrq,5,0,0,any,1
+quantreg,dynrq,6,0,0,character,1
+quantreg,dynrq,7,0,0,null,1
+quantreg,formula.rq,-1,0,0,class<`formula`>,1
+quantreg,formula.rq,0,0,0,"class<`dynrq`, `rq`>",1
+quantreg,formula.rq,0,0,1,class<`rq`>,1
+quantreg,formula.rq,1,0,0,...,1
+quantreg,KhmaladzeTest,-1,0,0,class<`KhmaladzeTest`>,1
+quantreg,KhmaladzeTest,0,0,0,class<`formula`>,1
+quantreg,KhmaladzeTest,1,0,0,class<`data.frame`>,1
+quantreg,KhmaladzeTest,2,0,0,double[],1
+quantreg,KhmaladzeTest,3,0,0,character,1
+quantreg,KhmaladzeTest,4,0,0,double[],1
+quantreg,KhmaladzeTest,5,0,0,double,1
+quantreg,KhmaladzeTest,6,0,0,...,1
+quantreg,kselect,-1,0,0,double[],1
+quantreg,kselect,0,0,0,double[],1
+quantreg,kselect,1,0,0,double[],1
+quantreg,kuantile,-1,0,0,class<`kuantile`>,1
+quantreg,kuantile,0,0,0,double[],1
+quantreg,kuantile,1,0,0,double[],1
+quantreg,kuantile,2,0,0,logical,1
+quantreg,kuantile,3,0,0,logical,1
+quantreg,kuantile,4,0,0,double,1
+quantreg,kuantile,5,0,0,...,1
+quantreg,kunique,-1,0,0,list<double[]>,1
+quantreg,kunique,0,0,0,double[],1
+quantreg,kunique,1,0,0,logical[],1
+quantreg,lm.fit.recursive,-1,0,0,class<`matrix`>,1
+quantreg,lm.fit.recursive,0,0,0,double[],1
+quantreg,lm.fit.recursive,1,0,0,double[],1
+quantreg,lm.fit.recursive,2,0,0,logical,1
+quantreg,lprq,-1,0,0,list<double[]>,1
+quantreg,lprq,0,0,0,double[],1
+quantreg,lprq,1,0,0,double[],1
+quantreg,lprq,2,0,0,double,1
+quantreg,lprq,3,0,0,double,1
+quantreg,lprq,4,0,0,double,1
+quantreg,nlrq,-1,0,0,class<`nlrq`>,1
+quantreg,nlrq,0,0,0,class<`formula`>,1
+quantreg,nlrq,1,0,0,list<double[]>,1
+quantreg,nlrq,2,0,0,any,1
+quantreg,nlrq,3,0,0,double,1
+quantreg,nlrq,4,0,0,any,1
+quantreg,nlrq,5,0,0,logical,1
+quantreg,nlrq,6,0,0,character,1
+quantreg,nlrq.control,-1,0,0,list<double>,1
+quantreg,nlrq.control,0,0,0,double,1
+quantreg,nlrq.control,1,0,0,double,1
+quantreg,nlrq.control,2,0,0,double,1
+quantreg,nlrq.control,3,0,0,double,1
+quantreg,nlrq.control,4,0,0,double,1
+quantreg,nlrq.control,5,0,0,double,1
+quantreg,nlrqModel,-1,0,0,class<`nlrqModel`>,1
+quantreg,nlrqModel,0,0,0,class<`formula`>,1
+quantreg,nlrqModel,1,0,0,double,1
+quantreg,nlrqModel,2,0,0,list<double[]>,1
+quantreg,nlrqModel,3,0,0,double[],1
+quantreg,plot.KhmaladzeTest,-1,0,0,list<integer[]>,1
+quantreg,plot.KhmaladzeTest,0,0,0,class<`KhmaladzeTest`>,1
+quantreg,plot.KhmaladzeTest,1,0,0,...,1
+quantreg,plot.qss1,-1,0,0,double[],1
+quantreg,plot.qss1,0,0,0,class<`matrix`>,1
+quantreg,plot.qss1,1,0,0,logical,1
+quantreg,plot.qss1,2,0,0,logical,1
+quantreg,plot.qss1,3,0,0,logical,1
+quantreg,plot.qss1,4,0,0,...,1
+quantreg,plot.qss2,-1,0,0,list<double[]>,1
+quantreg,plot.qss2,0,0,0,class<`matrix`>,1
+quantreg,plot.qss2,1,0,0,character,1
+quantreg,plot.qss2,2,0,0,double,1
+quantreg,plot.qss2,3,0,0,null,1
+quantreg,plot.qss2,4,0,0,...,1
+quantreg,plot.rqs,-1,0,0,class<`matrix`>,1
+quantreg,plot.rqs,0,0,0,class<`rqs`>,1
+quantreg,plot.rqs,1,0,0,double,1
+quantreg,plot.rqs,1,0,1,null,1
+quantreg,plot.rqs,2,0,0,logical,1
+quantreg,plot.rqs,3,0,0,null,1
+quantreg,plot.rqs,4,0,0,double[],1
+quantreg,plot.rqs,4,0,1,null,1
+quantreg,plot.rqs,5,0,0,null,1
+quantreg,plot.rqs,6,0,0,character,1
+quantreg,plot.rqs,6,0,1,null,1
+quantreg,plot.rqs,7,0,0,integer[],1
+quantreg,plot.rqss,-1,0,0,null,1
+quantreg,plot.rqss,0,0,0,class<`rqss`>,1
+quantreg,plot.rqss,1,0,0,logical,1
+quantreg,plot.rqss,2,0,0,logical,1
+quantreg,plot.rqss,3,0,0,null,1
+quantreg,plot.rqss,4,0,0,double,1
+quantreg,plot.rqss,5,0,0,logical,1
+quantreg,plot.rqss,6,0,0,logical,1
+quantreg,plot.rqss,7,0,0,null,1
+quantreg,plot.summary.rqs,-1,0,0,class<`array`>,1
+quantreg,plot.summary.rqs,0,0,0,class<`summary.rqs`>,1
+quantreg,plot.summary.rqs,1,0,0,double,1
+quantreg,plot.summary.rqs,1,0,1,null,1
+quantreg,plot.summary.rqs,2,0,0,double,1
+quantreg,plot.summary.rqs,3,0,0,logical,1
+quantreg,plot.summary.rqs,4,0,0,null,1
+quantreg,plot.summary.rqs,5,0,0,double[],1
+quantreg,plot.summary.rqs,5,0,1,null,1
+quantreg,plot.summary.rqs,6,0,0,null,1
+quantreg,plot.summary.rqs,7,0,0,character,1
+quantreg,plot.summary.rqs,7,0,1,null,1
+quantreg,predict.nlrq,-1,0,0,double[],1
+quantreg,predict.nlrq,0,0,0,class<`nlrq`>,1
+quantreg,predict.nlrq,1,0,0,list<integer[]>,1
+quantreg,predict.nlrq,2,0,0,...,1
+quantreg,predict.qss1,-1,0,0,list<double[] | class<`matrix`> | class<`matrix.csr`>>,1
+quantreg,predict.qss1,0,0,0,class<`qss1`>,1
+quantreg,predict.qss1,1,0,0,class<`data.frame`>,1
+quantreg,predict.qss1,2,0,0,...,1
+quantreg,predict.qss2,-1,0,0,list<double[] | class<`matrix.csr`>>,1
+quantreg,predict.qss2,0,0,0,class<`matrix`>,1
+quantreg,predict.qss2,1,0,0,class<`data.frame`>,1
+quantreg,predict.qss2,2,0,0,...,1
+quantreg,predict.rq,-1,0,0,double[],1
+quantreg,predict.rq,0,0,0,class<`rq`>,1
+quantreg,predict.rq,1,0,0,class<`data.frame`>,1
+quantreg,predict.rq,2,0,0,character,1
+quantreg,predict.rq,3,0,0,character[],1
+quantreg,predict.rq,4,0,0,double,1
+quantreg,predict.rq,5,0,0,class<`function`>,1
+quantreg,predict.rq,6,0,0,...,1
+quantreg,predict.rq.process,-1,0,0,"class<`function`, `stepfun`>",1
+quantreg,predict.rq.process,0,0,0,class<`rq.process`>,1
+quantreg,predict.rq.process,1,0,0,list<double>,1
+quantreg,predict.rq.process,2,0,0,character,1
+quantreg,predict.rq.process,3,0,0,logical,1
+quantreg,predict.rq.process,4,0,0,class<`function`>,1
+quantreg,predict.rq.process,5,0,0,...,1
+quantreg,predict.rqs,-1,0,0,"list<class<`function`, `stepfun`>>",1
+quantreg,predict.rqs,0,0,0,class<`rqs`>,1
+quantreg,predict.rqs,1,0,0,class<`data.frame`>,1
+quantreg,predict.rqs,2,0,0,character,1
+quantreg,predict.rqs,3,0,0,logical,1
+quantreg,predict.rqs,4,0,0,class<`function`>,1
+quantreg,predict.rqs,5,0,0,...,1
+quantreg,predict.rqss,-1,0,0,class<`matrix`>,1
+quantreg,predict.rqss,0,0,0,class<`rqss`>,1
+quantreg,predict.rqss,1,0,0,class<`data.frame`>,1
+quantreg,predict.rqss,2,0,0,character,1
+quantreg,predict.rqss,3,0,0,double,1
+quantreg,predict.rqss,4,0,0,...,1
+quantreg,qrisk,-1,0,0,list<double[]>,1
+quantreg,qrisk,0,0,0,class<`matrix`>,1
+quantreg,qrisk,1,0,0,double[],1
+quantreg,qrisk,2,0,0,double[],1
+quantreg,qrisk,3,0,0,double,1
+quantreg,qrisk,4,0,0,class<`matrix`>,1
+quantreg,qrisk,4,0,1,null,1
+quantreg,qrisk,5,0,0,double[],1
+quantreg,qrisk,5,0,1,null,1
+quantreg,qrisk,6,0,0,double,1
+quantreg,qss,-1,0,0,list<any>,1
+quantreg,qss,0,0,0,double[],1
+quantreg,qss,0,0,1,class<`matrix`>,1
+quantreg,qss,1,0,0,character,1
+quantreg,qss,2,0,0,double,1
+quantreg,qss,3,0,0,double,1
+quantreg,qss,4,0,0,null,1
+quantreg,qss,5,0,0,any,1
+quantreg,qss1,-1,0,0,list<any>,1
+quantreg,qss1,0,0,0,double[],1
+quantreg,qss1,1,0,0,character,1
+quantreg,qss1,2,0,0,double,1
+quantreg,qss1,3,0,0,any,1
+quantreg,qss1,4,0,0,any,1
+quantreg,qss1,5,0,0,any,1
+quantreg,qss2,-1,0,0,list<any>,1
+quantreg,qss2,0,0,0,class<`matrix`>,1
+quantreg,qss2,1,0,0,any,1
+quantreg,qss2,2,0,0,character,1
+quantreg,qss2,3,0,0,double,1
+quantreg,qss2,4,0,0,double,1
+quantreg,qss2,5,0,0,null,1
+quantreg,qss2,6,0,0,any,1
+quantreg,ranks,-1,0,0,list<double[]>,1
+quantreg,ranks,0,0,0,class<`rq.process`>,1
+quantreg,ranks,1,0,0,character,1
+quantreg,ranks,2,0,0,double,1
+quantreg,ranks,3,0,0,null,1
+quantreg,rearrange,-1,0,0,"class<`function`, `stepfun`>",1
+quantreg,rearrange,-1,0,1,"list<class<`function`, `stepfun`>>",1
+quantreg,rearrange,0,0,0,"class<`function`, `stepfun`>",1
+quantreg,rearrange,0,0,1,"list<class<`function`, `stepfun`>>",1
+quantreg,rearrange,1,0,0,any,1
+quantreg,rearrange,2,0,0,any,1
+quantreg,rq,-1,0,0,"class<`lassorq`, `rq`>",1
+quantreg,rq,-1,0,1,class<`rq`>,1
+quantreg,rq,-1,0,2,class<`rq.process`>,1
+quantreg,rq,-1,0,3,class<`rqs`>,1
+quantreg,rq,-1,0,4,"class<`rq`, `scadrq`>",1
+quantreg,rq,0,0,0,class<`formula`>,1
+quantreg,rq,1,0,0,double[],1
+quantreg,rq,2,0,0,any,1
+quantreg,rq,3,0,0,any,1
+quantreg,rq,4,0,0,any,1
+quantreg,rq,5,0,0,any,1
+quantreg,rq,6,0,0,character,1
+quantreg,rq,7,0,0,logical,1
+quantreg,rq.fit,-1,0,0,list<any>,1
+quantreg,rq.fit,0,0,0,class<`matrix`>,1
+quantreg,rq.fit,1,0,0,double[],1
+quantreg,rq.fit,1,0,1,class<`ts`>,1
+quantreg,rq.fit,1,0,2,class<`zoo`>,1
+quantreg,rq.fit,2,0,0,double,1
+quantreg,rq.fit,3,0,0,character,1
+quantreg,rq.fit,4,0,0,...,1
+quantreg,rq.fit.br,-1,0,0,list<class<`matrix`> | class<`ts`>>,1
+quantreg,rq.fit.br,-1,0,1,list<class<`matrix`> | double[]>,1
+quantreg,rq.fit.br,-1,0,2,list<double[] | class<`matrix`>>,1
+quantreg,rq.fit.br,-1,0,3,list<double[] | class<`matrix`> | class<`ts`>>,1
+quantreg,rq.fit.br,-1,0,4,list<double[] | class<`matrix`> | class<`zoo`>>,1
+quantreg,rq.fit.br,-1,0,5,list<class<`matrix`> | class<`ts`> | double[]>,1
+quantreg,rq.fit.br,-1,0,6,list<class<`matrix`>>,1
+quantreg,rq.fit.br,0,0,0,class<`matrix`>,1
+quantreg,rq.fit.br,1,0,0,class<`ts`>,1
+quantreg,rq.fit.br,1,0,1,double[],1
+quantreg,rq.fit.br,1,0,2,class<`zoo`>,1
+quantreg,rq.fit.br,2,0,0,double,1
+quantreg,rq.fit.br,3,0,0,double,1
+quantreg,rq.fit.br,4,0,0,logical,1
+quantreg,rq.fit.br,5,0,0,logical,1
+quantreg,rq.fit.br,6,0,0,logical,1
+quantreg,rq.fit.br,7,0,0,logical,1
+quantreg,rq.fit.fnb,-1,0,0,list<double[] | class<`matrix`>>,1
+quantreg,rq.fit.fnb,-1,0,1,list<double[] | class<`ts`>>,1
+quantreg,rq.fit.fnb,-1,0,2,list<double | class<`ts`>>,1
+quantreg,rq.fit.fnb,0,0,0,class<`matrix`>,1
+quantreg,rq.fit.fnb,1,0,0,double[],1
+quantreg,rq.fit.fnb,1,0,1,class<`ts`>,1
+quantreg,rq.fit.fnb,2,0,0,double,1
+quantreg,rq.fit.fnb,3,0,0,double[],1
+quantreg,rq.fit.fnb,4,0,0,double,1
+quantreg,rq.fit.fnb,5,0,0,double,1
+quantreg,rq.fit.fnc,-1,0,0,list<double[] | class<`matrix`>>,1
+quantreg,rq.fit.fnc,0,0,0,class<`matrix`>,1
+quantreg,rq.fit.fnc,1,0,0,double[],1
+quantreg,rq.fit.fnc,2,0,0,class<`matrix`>,1
+quantreg,rq.fit.fnc,3,0,0,double[],1
+quantreg,rq.fit.fnc,4,0,0,double,1
+quantreg,rq.fit.fnc,5,0,0,double,1
+quantreg,rq.fit.fnc,6,0,0,double,1
+quantreg,rq.fit.hogg,-1,0,0,list<double[]>,1
+quantreg,rq.fit.hogg,0,0,0,class<`matrix`>,1
+quantreg,rq.fit.hogg,1,0,0,double[],1
+quantreg,rq.fit.hogg,2,0,0,double[],1
+quantreg,rq.fit.hogg,3,0,0,double[],1
+quantreg,rq.fit.hogg,4,0,0,class<`matrix`>,1
+quantreg,rq.fit.hogg,5,0,0,double[],1
+quantreg,rq.fit.hogg,6,0,0,double,1
+quantreg,rq.fit.hogg,7,0,0,double,1
+quantreg,rq.fit.lasso,-1,0,0,list<double[] | class<`matrix`>>,1
+quantreg,rq.fit.lasso,0,0,0,class<`matrix`>,1
+quantreg,rq.fit.lasso,1,0,0,double[],1
+quantreg,rq.fit.lasso,2,0,0,double,1
+quantreg,rq.fit.lasso,3,0,0,double[],1
+quantreg,rq.fit.lasso,4,0,0,double,1
+quantreg,rq.fit.lasso,5,0,0,double,1
+quantreg,rq.fit.scad,-1,0,0,list<double[] | class<`matrix`>>,1
+quantreg,rq.fit.scad,0,0,0,class<`matrix`>,1
+quantreg,rq.fit.scad,1,0,0,double[],1
+quantreg,rq.fit.scad,2,0,0,double,1
+quantreg,rq.fit.scad,3,0,0,double,1
+quantreg,rq.fit.scad,4,0,0,double,1
+quantreg,rq.fit.scad,5,0,0,character,1
+quantreg,rq.fit.scad,6,0,0,double,1
+quantreg,rq.fit.scad,7,0,0,double,1
+quantreg,rq.fit.sfn,-1,0,0,list<double[] | class<`matrix`> | list<double>>,1
+quantreg,rq.fit.sfn,-1,0,1,list<double[] | class<`matrix`> | list<null | double>>,1
+quantreg,rq.fit.sfn,0,0,0,class<`matrix.csr`>,1
+quantreg,rq.fit.sfn,1,0,0,double[],1
+quantreg,rq.fit.sfn,2,0,0,double,1
+quantreg,rq.fit.sfn,3,0,0,class<`matrix`>,1
+quantreg,rq.fit.sfn,3,0,1,double[],1
+quantreg,rq.fit.sfn,4,0,0,any,1
+quantreg,rq.fit.sfnc,-1,0,0,any,1
+quantreg,rq.fit.sfnc,0,0,0,class<`matrix.csr`>,1
+quantreg,rq.fit.sfnc,1,0,0,double[],1
+quantreg,rq.fit.sfnc,2,0,0,class<`matrix.csr`>,1
+quantreg,rq.fit.sfnc,3,0,0,double[],1
+quantreg,rq.fit.sfnc,4,0,0,double,1
+quantreg,rq.fit.sfnc,5,0,0,double[],1
+quantreg,rq.fit.sfnc,5,0,1,class<`matrix`>,1
+quantreg,rq.fit.sfnc,6,0,0,any,1
+quantreg,rqProcess,-1,0,0,class<`rqProcess`>,1
+quantreg,rqProcess,0,0,0,class<`formula`>,1
+quantreg,rqProcess,1,0,0,class<`data.frame`>,1
+quantreg,rqProcess,2,0,0,double[],1
+quantreg,rqProcess,3,0,0,character,1
+quantreg,rqProcess,4,0,0,...,1
+quantreg,rqss,-1,0,0,class<`rqss`>,1
+quantreg,rqss,0,0,0,class<`formula`>,1
+quantreg,rqss,1,0,0,double,1
+quantreg,rqss,2,0,0,class<`data.frame`>,1
+quantreg,rqss,2,0,1,environment,1
+quantreg,rqss,3,0,0,any,1
+quantreg,rqss,4,0,0,any,1
+quantreg,rqss,5,0,0,character,1
+quantreg,rqss,6,0,0,null,1
+quantreg,rqss,7,0,0,null,1
+quantreg,rqss.fit,-1,0,0,list<double[] | class<`matrix`> | list<double>>,1
+quantreg,rqss.fit,0,0,0,class<`matrix.csr`>,1
+quantreg,rqss.fit,1,0,0,double[],1
+quantreg,rqss.fit,2,0,0,any,1
+quantreg,rqss.fit,3,0,0,character,1
+quantreg,rqss.fit,4,0,0,class<`matrix`>,1
+quantreg,rqss.fit,5,0,0,list<double>,1
+quantreg,rqss.fit,6,0,0,...,1
+quantreg,rq.wfit,-1,0,0,list<class<`matrix`> | double[]>,1
+quantreg,rq.wfit,-1,0,1,list<double[] | class<`matrix`>>,1
+quantreg,rq.wfit,0,0,0,class<`matrix`>,1
+quantreg,rq.wfit,1,0,0,double[],1
+quantreg,rq.wfit,2,0,0,double,1
+quantreg,rq.wfit,3,0,0,double[],1
+quantreg,rq.wfit,4,0,0,character,1
+quantreg,rq.wfit,5,0,0,...,1
+quantreg,sfn.control,-1,0,0,list<null | double>,1
+quantreg,sfn.control,0,0,0,null,1
+quantreg,sfn.control,1,0,0,null,1
+quantreg,sfn.control,2,0,0,null,1
+quantreg,sfn.control,3,0,0,double,1
+quantreg,sfn.control,4,0,0,double,1
+quantreg,sfn.control,5,0,0,double,1
+quantreg,sfn.control,6,0,0,logical,1
+quantreg,sfnMessage,-1,0,0,character,1
+quantreg,sfnMessage,0,0,0,integer,1
+quantreg,srisk,-1,0,0,list<double[] | class<`matrix`>>,1
+quantreg,srisk,0,0,0,class<`matrix`>,1
+quantreg,srisk,1,0,0,double,1
+quantreg,srisk,2,0,0,double,1
+quantreg,srisk,3,0,0,double,1
+quantreg,srisk,4,0,0,double,1
+quantreg,summary.crq,-1,0,0,class<`summary.crqs`>,1
+quantreg,summary.crq,0,0,0,class<`crq`>,1
+quantreg,summary.crq,1,0,0,double[],1
+quantreg,summary.crq,2,0,0,double,1
+quantreg,summary.crq,3,0,0,character,1
+quantreg,summary.crq,4,0,0,logical,1
+quantreg,summary.crq,5,0,0,...,1
+quantreg,summary.dynrqs,-1,0,0,"class<`summary.dynrqs`, `summary.rqs`>",1
+quantreg,summary.dynrqs,0,0,0,"class<`dynrqs`, `rqs`>",1
+quantreg,summary.dynrqs,1,0,0,null,1
+quantreg,summary.dynrqs,2,0,0,null,1
+quantreg,summary.dynrqs,3,0,0,...,1
+quantreg,summary.rq,-1,0,0,class<`summary.rq`>,1
+quantreg,summary.rq,0,0,0,"class<`dynrq`, `rq`>",1
+quantreg,summary.rq,0,0,1,class<`rq`>,1
+quantreg,summary.rq,1,0,0,character,1
+quantreg,summary.rq,1,0,1,null,1
+quantreg,summary.rq,2,0,0,logical,1
+quantreg,summary.rq,3,0,0,logical,1
+quantreg,summary.rq,4,0,0,any,1
+quantreg,summary.rq,5,0,0,double,1
+quantreg,summary.rq,6,0,0,...,1
+quantreg,summary.rqs,-1,0,0,"class<`summary.dynrqs`, `summary.rqs`>",1
+quantreg,summary.rqs,-1,0,1,class<`summary.rqs`>,1
+quantreg,summary.rqs,0,0,0,"class<`dynrqs`, `rqs`>",1
+quantreg,summary.rqs,0,0,1,class<`rqs`>,1
+quantreg,summary.rqs,1,0,0,...,1
+quantreg,summary.rqss,-1,0,0,class<`summary.rqss`>,1
+quantreg,summary.rqss,0,0,0,class<`rqss`>,1
+quantreg,summary.rqss,1,0,0,logical,1
+quantreg,summary.rqss,2,0,0,double,1
+quantreg,summary.rqss,3,0,0,...,1
+quantreg,triogram.fidelity,-1,0,0,list<double[] | class<`matrix.csr`> | null>,1
+quantreg,triogram.fidelity,0,0,0,double[],1
+quantreg,triogram.fidelity,1,0,0,double[],1
+quantreg,triogram.fidelity,2,0,0,double,1
+quantreg,triogram.fidelity,3,0,0,null,1
+quantreg,triogram.penalty,-1,0,0,class<`matrix.csr`>,1
+quantreg,triogram.penalty,0,0,0,double[],1
+quantreg,triogram.penalty,1,0,0,double[],1
+quantreg,triogram.penalty,2,0,0,double,1
+quantreg,untangle.specials,-1,0,0,list<character | integer>,1
+quantreg,untangle.specials,0,0,0,"class<`formula`, `terms`>",1
+quantreg,untangle.specials,1,0,0,character,1
+quantreg,untangle.specials,2,0,0,double,1
+rARPACK,eigs,-1,0,0,list<complex[] | class<`matrix`>>,1
+rARPACK,eigs,-1,0,1,list<complex[] | null>,1
+rARPACK,eigs,0,0,0,class<`dgCMatrix`>,1
+rARPACK,eigs,0,0,1,class<`dgRMatrix`>,1
+rARPACK,eigs,0,0,2,class<`function`>,1
+rARPACK,eigs,0,0,3,class<`matrix`>,1
+rARPACK,eigs,0,0,4,class<`dgeMatrix`>,1
+rARPACK,eigs,1,0,0,double,1
+rARPACK,eigs,2,0,0,character,1
+rARPACK,eigs,3,0,0,null,1
+rARPACK,eigs,4,0,0,list<any>,1
+rARPACK,eigs,5,0,0,...,1
+rARPACK,eigs_sym,-1,0,0,list<double[] | class<`matrix`>>,1
+rARPACK,eigs_sym,0,0,0,class<`matrix`>,1
+rARPACK,eigs_sym,1,0,0,double,1
+rARPACK,eigs_sym,2,0,0,character,1
+rARPACK,eigs_sym,3,0,0,double,1
+rARPACK,eigs_sym,3,0,1,null,1
+rARPACK,eigs_sym,4,0,0,list<any>,1
+rARPACK,eigs_sym,5,0,0,logical,1
+rARPACK,eigs_sym,6,0,0,...,1
+rARPACK,svds,-1,0,0,list<double[] | class<`matrix`>>,1
+rARPACK,svds,-1,0,1,list<double[] | null | class<`matrix`>>,1
+rARPACK,svds,-1,0,2,list<double[] | null>,1
+rARPACK,svds,0,0,0,class<`dgCMatrix`>,1
+rARPACK,svds,0,0,1,class<`matrix`>,1
+rARPACK,svds,0,0,2,class<`dgRMatrix`>,1
+rARPACK,svds,1,0,0,double,1
+rARPACK,svds,2,0,0,double,1
+rARPACK,svds,3,0,0,double,1
+rARPACK,svds,4,0,0,list<any>,1
+rARPACK,svds,5,0,0,...,1
+rTensor,as.tensor,-1,0,0,class<`Tensor`>,1
+rTensor,as.tensor,0,0,0,class<`array`>,1
+rTensor,as.tensor,0,0,1,class<`matrix`>,1
+rTensor,as.tensor,0,0,2,double[],1
+rTensor,as.tensor,1,0,0,logical,1
+rTensor,cp,-1,0,0,list<double[] | class<`Tensor`> | list<class<`matrix`>>>,1
+rTensor,cp,0,0,0,class<`Tensor`>,1
+rTensor,cp,1,0,0,double,1
+rTensor,cp,2,0,0,double,1
+rTensor,cp,3,0,0,double,1
+rTensor,fnorm,-1,0,0,double,1
+rTensor,fnorm,0,0,0,class<`Tensor`>,1
+rTensor,fnorm,-1,1,0,double,1
+rTensor,fnorm,0,1,0,class<`Tensor`>,1
+rTensor,fold,-1,0,0,class<`Tensor`>,1
+rTensor,fold,0,0,0,class<`matrix`>,1
+rTensor,fold,0,0,1,class<`Tensor`>,1
+rTensor,fold,1,0,0,double,1
+rTensor,fold,1,0,1,integer[],1
+rTensor,fold,2,0,0,double[],1
+rTensor,fold,3,0,0,double[],1
+rTensor,hadamard_list,-1,0,0,class<`matrix`>,1
+rTensor,hadamard_list,0,0,0,list<class<`matrix`>>,1
+rTensor,head,-1,0,0,double[],1
+rTensor,head,0,0,0,class<`Tensor`>,1
+rTensor,head,1,0,0,...,1
+rTensor,hosvd,-1,0,0,list<class<`Tensor`> | double | list<class<`matrix`>>>,1
+rTensor,hosvd,0,0,0,class<`Tensor`>,1
+rTensor,hosvd,1,0,0,double[],1
+rTensor,hosvd,1,0,1,null,1
+rTensor,innerProd,-1,0,0,double,1
+rTensor,innerProd,0,0,0,class<`Tensor`>,1
+rTensor,innerProd,1,0,0,class<`Tensor`>,1
+rTensor,innerProd,-1,1,0,double,1
+rTensor,innerProd,0,1,0,class<`Tensor`>,1
+rTensor,innerProd,1,1,0,class<`Tensor`>,1
+rTensor,.is_zero_tensor,-1,0,0,logical,1
+rTensor,.is_zero_tensor,0,0,0,class<`Tensor`>,1
+rTensor,k_fold,-1,0,0,class<`Tensor`>,1
+rTensor,k_fold,0,0,0,class<`Tensor`>,1
+rTensor,k_fold,0,0,1,class<`matrix`>,1
+rTensor,k_fold,1,0,0,double,1
+rTensor,k_fold,2,0,0,double[],1
+rTensor,khatri_rao,-1,0,0,class<`matrix`>,1
+rTensor,khatri_rao,0,0,0,class<`matrix`>,1
+rTensor,khatri_rao,1,0,0,class<`matrix`>,1
+rTensor,khatri_rao_list,-1,0,0,class<`matrix`>,1
+rTensor,khatri_rao_list,0,0,0,list<class<`matrix`>>,1
+rTensor,khatri_rao_list,1,0,0,logical,1
+rTensor,kronecker_list,-1,0,0,class<`array`>,1
+rTensor,kronecker_list,-1,0,1,class<`matrix`>,1
+rTensor,kronecker_list,0,0,0,list<double[]>,1
+rTensor,kronecker_list,0,0,1,list<class<`matrix`>>,1
+rTensor,k_unfold,-1,0,0,class<`Tensor`>,1
+rTensor,k_unfold,0,0,0,class<`Tensor`>,1
+rTensor,k_unfold,1,0,0,double,1
+rTensor,k_unfold,-1,1,0,class<`Tensor`>,1
+rTensor,k_unfold,0,1,0,class<`Tensor`>,1
+rTensor,k_unfold,1,1,0,double,1
+rTensor,matvec,-1,0,0,class<`Tensor`>,1
+rTensor,matvec,0,0,0,class<`Tensor`>,1
+rTensor,matvec,-1,1,0,class<`Tensor`>,1
+rTensor,matvec,0,1,0,class<`Tensor`>,1
+rTensor,modeMean,-1,0,0,class<`Tensor`>,1
+rTensor,modeMean,0,0,0,class<`Tensor`>,1
+rTensor,modeMean,1,0,0,double,1
+rTensor,modeMean,2,0,0,logical,1
+rTensor,modeMean,-1,1,0,class<`Tensor`>,1
+rTensor,modeMean,0,1,0,class<`Tensor`>,1
+rTensor,modeMean,1,1,0,double,1
+rTensor,modeMean,2,1,0,logical,1
+rTensor,modeSum,-1,0,0,class<`Tensor`>,1
+rTensor,modeSum,0,0,0,class<`Tensor`>,1
+rTensor,modeSum,1,0,0,double,1
+rTensor,modeSum,2,0,0,logical,1
+rTensor,modeSum,-1,1,0,class<`Tensor`>,1
+rTensor,modeSum,0,1,0,class<`Tensor`>,1
+rTensor,modeSum,1,1,0,double,1
+rTensor,modeSum,2,1,0,logical,1
+rTensor,mpca,-1,0,0,list<class<`Tensor`> | double[] | list<class<`matrix`> | null>>,1
+rTensor,mpca,0,0,0,class<`Tensor`>,1
+rTensor,mpca,1,0,0,double[],1
+rTensor,mpca,2,0,0,double,1
+rTensor,mpca,3,0,0,double,1
+rTensor,plot_orl,-1,0,0,null,1
+rTensor,plot_orl,0,0,0,double,1
+rTensor,plot_orl,1,0,0,double,1
+rTensor,print,-1,0,0,double[],1
+rTensor,print,0,0,0,class<`Tensor`>,1
+rTensor,print,1,0,0,...,1
+rTensor,pvd,-1,0,0,list<any>,1
+rTensor,pvd,0,0,0,class<`Tensor`>,1
+rTensor,pvd,1,0,0,double[],1
+rTensor,pvd,2,0,0,double[],1
+rTensor,pvd,3,0,0,double,1
+rTensor,pvd,4,0,0,double,1
+rTensor,rand_tensor,-1,0,0,class<`Tensor`>,1
+rTensor,rand_tensor,0,0,0,double[],1
+rTensor,rand_tensor,1,0,0,logical,1
+rTensor,rs_fold,-1,0,0,class<`Tensor`>,1
+rTensor,rs_fold,0,0,0,class<`Tensor`>,1
+rTensor,rs_fold,0,0,1,class<`matrix`>,1
+rTensor,rs_fold,1,0,0,double,1
+rTensor,rs_fold,2,0,0,double[],1
+rTensor,rs_unfold,-1,0,0,class<`Tensor`>,1
+rTensor,rs_unfold,0,0,0,class<`Tensor`>,1
+rTensor,rs_unfold,1,0,0,double,1
+rTensor,rs_unfold,-1,1,0,class<`Tensor`>,1
+rTensor,rs_unfold,0,1,0,class<`Tensor`>,1
+rTensor,rs_unfold,1,1,0,double,1
+rTensor,.superdiagonal_tensor,-1,0,0,class<`Tensor`>,1
+rTensor,.superdiagonal_tensor,0,0,0,integer,1
+rTensor,.superdiagonal_tensor,1,0,0,double,1
+rTensor,.superdiagonal_tensor,2,0,0,double[],1
+rTensor,t,-1,0,0,class<`Tensor`>,1
+rTensor,t,0,0,0,class<`Tensor`>,1
+rTensor,tail,-1,0,0,double[],1
+rTensor,tail,0,0,0,class<`Tensor`>,1
+rTensor,tail,1,0,0,...,1
+rTensor,t_mult,-1,0,0,class<`Tensor`>,1
+rTensor,t_mult,0,0,0,class<`Tensor`>,1
+rTensor,t_mult,1,0,0,class<`Tensor`>,1
+rTensor,tperm,-1,0,0,class<`Tensor`>,1
+rTensor,tperm,0,0,0,class<`Tensor`>,1
+rTensor,tperm,1,0,0,any,1
+rTensor,tperm,2,0,0,...,1
+rTensor,tperm,-1,1,0,class<`Tensor`>,1
+rTensor,tperm,0,1,0,class<`Tensor`>,1
+rTensor,tperm,1,1,0,any,1
+rTensor,tperm,2,1,0,...,1
+rTensor,t_svd,-1,0,0,list<class<`Tensor`>>,1
+rTensor,t_svd,0,0,0,class<`Tensor`>,1
+rTensor,t_svd_reconstruct,-1,0,0,class<`Tensor`>,1
+rTensor,t_svd_reconstruct,0,0,0,list<class<`Tensor`>>,1
+rTensor,ttl,-1,0,0,class<`Tensor`>,1
+rTensor,ttl,0,0,0,class<`Tensor`>,1
+rTensor,ttl,1,0,0,list<class<`matrix`>>,1
+rTensor,ttl,2,0,0,double[],1
+rTensor,ttm,-1,0,0,class<`Tensor`>,1
+rTensor,ttm,0,0,0,class<`Tensor`>,1
+rTensor,ttm,1,0,0,class<`matrix`>,1
+rTensor,ttm,2,0,0,double,1
+rTensor,tucker,-1,0,0,list<class<`Tensor`> | double[] | list<class<`matrix`>>>,1
+rTensor,tucker,0,0,0,class<`Tensor`>,1
+rTensor,tucker,1,0,0,double[],1
+rTensor,tucker,2,0,0,double,1
+rTensor,tucker,3,0,0,double,1
+rTensor,unfold,-1,0,0,class<`Tensor`>,1
+rTensor,unfold,0,0,0,class<`Tensor`>,1
+rTensor,unfold,1,0,0,double[],1
+rTensor,unfold,2,0,0,double[],1
+rTensor,unfold,-1,1,0,class<`Tensor`>,1
+rTensor,unfold,0,1,0,class<`Tensor`>,1
+rTensor,unfold,1,1,0,double[],1
+rTensor,unfold,2,1,0,double[],1
+rTensor,unmatvec,-1,0,0,class<`Tensor`>,1
+rTensor,unmatvec,0,0,0,class<`Tensor`>,1
+rTensor,unmatvec,1,0,0,double[],1
+rTensor,vec,-1,0,0,double[],1
+rTensor,vec,0,0,0,class<`Tensor`>,1
+rTensor,vec,-1,1,0,double[],1
+rTensor,vec,0,1,0,class<`Tensor`>,1
+randomForest,classCenter,-1,0,0,class<`matrix`>,1
+randomForest,classCenter,0,0,0,class<`data.frame`>,1
+randomForest,classCenter,1,0,0,class<`factor`>,1
+randomForest,classCenter,2,0,0,class<`matrix`>,1
+randomForest,classCenter,3,0,0,double,1
+randomForest,combine,-1,0,0,"class<`randomForest`, `randomForest.formula`>",1
+randomForest,combine,0,0,0,...,1
+randomForest,getTree,-1,0,0,class<`data.frame`>,1
+randomForest,getTree,0,0,0,class<`randomForest`>,1
+randomForest,getTree,1,0,0,double,1
+randomForest,getTree,2,0,0,logical,1
+randomForest,grow,-1,0,0,"class<`randomForest`, `randomForest.formula`>",1
+randomForest,grow,0,0,0,"class<`randomForest`, `randomForest.formula`>",1
+randomForest,grow,1,0,0,...,1
+randomForest,grow.randomForest,-1,0,0,"class<`randomForest`, `randomForest.formula`>",1
+randomForest,grow.randomForest,0,0,0,"class<`randomForest`, `randomForest.formula`>",1
+randomForest,grow.randomForest,1,0,0,double,1
+randomForest,grow.randomForest,2,0,0,...,1
+randomForest,importance,-1,0,0,class<`matrix`>,1
+randomForest,importance,0,0,0,class<`randomForest`>,1
+randomForest,importance,0,0,1,"class<`randomForest`, `randomForest.formula`>",1
+randomForest,importance,1,0,0,...,1
+randomForest,importance.randomForest,-1,0,0,class<`matrix`>,1
+randomForest,importance.randomForest,0,0,0,class<`randomForest`>,1
+randomForest,importance.randomForest,0,0,1,"class<`randomForest`, `randomForest.formula`>",1
+randomForest,importance.randomForest,1,0,0,double,1
+randomForest,importance.randomForest,1,0,1,null,1
+randomForest,importance.randomForest,2,0,0,any,1
+randomForest,importance.randomForest,3,0,0,logical,1
+randomForest,importance.randomForest,4,0,0,...,1
+randomForest,margin,-1,0,0,class<`margin`>,1
+randomForest,margin,0,0,0,"class<`matrix`, `votes`>",1
+randomForest,margin,0,0,1,"class<`randomForest`, `randomForest.formula`>",1
+randomForest,margin,1,0,0,...,1
+randomForest,margin.default,-1,0,0,class<`margin`>,1
+randomForest,margin.default,0,0,0,"class<`matrix`, `votes`>",1
+randomForest,margin.default,1,0,0,class<`factor`>,1
+randomForest,margin.default,2,0,0,...,1
+randomForest,margin.randomForest,-1,0,0,class<`margin`>,1
+randomForest,margin.randomForest,0,0,0,"class<`randomForest`, `randomForest.formula`>",1
+randomForest,margin.randomForest,1,0,0,...,1
+randomForest,MDSplot,-1,0,0,list<class<`matrix`> | double[] | null>,1
+randomForest,MDSplot,0,0,0,class<`randomForest`>,1
+randomForest,MDSplot,0,0,1,"class<`randomForest`, `randomForest.formula`>",1
+randomForest,MDSplot,1,0,0,class<`factor`>,1
+randomForest,MDSplot,2,0,0,double,1
+randomForest,MDSplot,3,0,0,null,1
+randomForest,MDSplot,3,0,1,double[],1
+randomForest,MDSplot,4,0,0,double[],1
+randomForest,MDSplot,5,0,0,...,1
+randomForest,na.roughfix,-1,0,0,class<`data.frame`>,1
+randomForest,na.roughfix,0,0,0,class<`data.frame`>,1
+randomForest,na.roughfix,1,0,0,...,1
+randomForest,na.roughfix.data.frame,-1,0,0,class<`data.frame`>,1
+randomForest,na.roughfix.data.frame,0,0,0,class<`data.frame`>,1
+randomForest,na.roughfix.data.frame,1,0,0,...,1
+randomForest,outlier,-1,0,0,double[],1
+randomForest,outlier,0,0,0,class<`randomForest`>,1
+randomForest,outlier,1,0,0,...,1
+randomForest,outlier.default,-1,0,0,double[],1
+randomForest,outlier.default,0,0,0,class<`matrix`>,1
+randomForest,outlier.default,1,0,0,class<`factor`>,1
+randomForest,outlier.default,2,0,0,...,1
+randomForest,outlier.randomForest,-1,0,0,double[],1
+randomForest,outlier.randomForest,0,0,0,class<`randomForest`>,1
+randomForest,outlier.randomForest,1,0,0,...,1
+randomForest,partialPlot,-1,0,0,list<double[]>,1
+randomForest,partialPlot,0,0,0,"class<`randomForest`, `randomForest.formula`>",1
+randomForest,partialPlot,1,0,0,...,1
+randomForest,partialPlot.randomForest,-1,0,0,list<double[]>,1
+randomForest,partialPlot.randomForest,0,0,0,"class<`randomForest`, `randomForest.formula`>",1
+randomForest,partialPlot.randomForest,1,0,0,class<`data.frame`>,1
+randomForest,partialPlot.randomForest,2,0,0,any,1
+randomForest,partialPlot.randomForest,3,0,0,any,1
+randomForest,partialPlot.randomForest,4,0,0,any,1
+randomForest,partialPlot.randomForest,5,0,0,logical,1
+randomForest,partialPlot.randomForest,6,0,0,logical,1
+randomForest,partialPlot.randomForest,7,0,0,double,1
+randomForest,partialPlot.randomForest,8,0,0,logical,1
+randomForest,partialPlot.randomForest,9,0,0,character,1
+randomForest,partialPlot.randomForest,10,0,0,character,1
+randomForest,partialPlot.randomForest,11,0,0,character,1
+randomForest,partialPlot.randomForest,12,0,0,...,1
+randomForest,plot.margin,-1,0,0,null,1
+randomForest,plot.margin,0,0,0,class<`margin`>,1
+randomForest,plot.margin,1,0,0,logical,1
+randomForest,plot.margin,2,0,0,...,1
+randomForest,plot.randomForest,-1,0,0,double[],1
+randomForest,plot.randomForest,0,0,0,"class<`randomForest`, `randomForest.formula`>",1
+randomForest,plot.randomForest,1,0,0,character,1
+randomForest,plot.randomForest,2,0,0,character,1
+randomForest,plot.randomForest,3,0,0,...,1
+randomForest,predict.randomForest,-1,0,0,class<`factor`>,1
+randomForest,predict.randomForest,-1,0,1,"class<`matrix`, `votes`>",1
+randomForest,predict.randomForest,-1,0,2,double[],1
+randomForest,predict.randomForest,-1,0,3,list<class<`factor`> | class<`matrix`>>,1
+randomForest,predict.randomForest,0,0,0,class<`randomForest`>,1
+randomForest,predict.randomForest,0,0,1,"class<`randomForest`, `randomForest.formula`>",1
+randomForest,predict.randomForest,1,0,0,class<`matrix`>,1
+randomForest,predict.randomForest,1,0,1,class<`data.frame`>,1
+randomForest,predict.randomForest,2,0,0,character,1
+randomForest,predict.randomForest,3,0,0,logical,1
+randomForest,predict.randomForest,4,0,0,logical,1
+randomForest,predict.randomForest,5,0,0,logical,1
+randomForest,predict.randomForest,6,0,0,logical,1
+randomForest,predict.randomForest,7,0,0,any,1
+randomForest,predict.randomForest,8,0,0,...,1
+randomForest,print.randomForest,-1,0,0,null,1
+randomForest,print.randomForest,0,0,0,"class<`randomForest`, `randomForest.formula`>",1
+randomForest,print.randomForest,1,0,0,...,1
+randomForest,randomForest,-1,0,0,class<`randomForest`>,1
+randomForest,randomForest,-1,0,1,"class<`randomForest`, `randomForest.formula`>",1
+randomForest,randomForest,0,0,0,any,1
+randomForest,randomForest,1,0,0,...,1
+randomForest,randomForest.default,-1,0,0,class<`randomForest`>,1
+randomForest,randomForest.default,0,0,0,class<`data.frame`>,1
+randomForest,randomForest.default,0,0,1,class<`matrix`>,1
+randomForest,randomForest.default,1,0,0,class<`factor`>,1
+randomForest,randomForest.default,1,0,1,double[],1
+randomForest,randomForest.default,1,0,2,null,1
+randomForest,randomForest.default,2,0,0,null,1
+randomForest,randomForest.default,2,0,1,class<`data.frame`>,1
+randomForest,randomForest.default,3,0,0,null,1
+randomForest,randomForest.default,3,0,1,class<`factor`>,1
+randomForest,randomForest.default,4,0,0,double,1
+randomForest,randomForest.default,5,0,0,double,1
+randomForest,randomForest.default,6,0,0,logical,1
+randomForest,randomForest.default,7,0,0,null,1
+randomForest,randomForest.default,8,0,0,any,1
+randomForest,randomForest.default,9,0,0,any,1
+randomForest,randomForest.default,10,0,0,double[],1
+randomForest,randomForest.default,11,0,0,double,1
+randomForest,randomForest.default,12,0,0,double,1
+randomForest,randomForest.default,12,0,1,null,1
+randomForest,randomForest.default,13,0,0,logical,1
+randomForest,randomForest.default,14,0,0,logical,1
+randomForest,randomForest.default,15,0,0,double,1
+randomForest,randomForest.formula,-1,0,0,"class<`randomForest`, `randomForest.formula`>",1
+randomForest,randomForest.formula,0,0,0,class<`formula`>,1
+randomForest,randomForest.formula,1,0,0,any,1
+randomForest,randomForest.formula,2,0,0,...,1
+randomForest,randomForest.formula,3,0,0,any,1
+randomForest,randomForest.formula,4,0,0,class<`function`>,1
+randomForest,rfcv,-1,0,0,list<double[] | list<class<`factor`>>>,1
+randomForest,rfcv,0,0,0,class<`data.frame`>,1
+randomForest,rfcv,1,0,0,class<`factor`>,1
+randomForest,rfcv,2,0,0,double,1
+randomForest,rfcv,3,0,0,character,1
+randomForest,rfcv,4,0,0,double,1
+randomForest,rfcv,5,0,0,class<`function`>,1
+randomForest,rfcv,6,0,0,logical,1
+randomForest,rfcv,7,0,0,...,1
+randomForest,rfImpute,-1,0,0,class<`data.frame`>,1
+randomForest,rfImpute,0,0,0,class<`formula`>,1
+randomForest,rfImpute,1,0,0,...,1
+randomForest,rfImpute.default,-1,0,0,class<`data.frame`>,1
+randomForest,rfImpute.default,0,0,0,class<`data.frame`>,1
+randomForest,rfImpute.default,1,0,0,class<`factor`>,1
+randomForest,rfImpute.default,2,0,0,double,1
+randomForest,rfImpute.default,3,0,0,double,1
+randomForest,rfImpute.default,4,0,0,...,1
+randomForest,rfImpute.formula,-1,0,0,class<`data.frame`>,1
+randomForest,rfImpute.formula,0,0,0,class<`formula`>,1
+randomForest,rfImpute.formula,1,0,0,any,1
+randomForest,rfImpute.formula,2,0,0,...,1
+randomForest,rfImpute.formula,3,0,0,any,1
+randomForest,treesize,-1,0,0,double[],1
+randomForest,treesize,0,0,0,"class<`randomForest`, `randomForest.formula`>",1
+randomForest,treesize,1,0,0,logical,1
+randomForest,tuneRF,-1,0,0,class<`matrix`>,1
+randomForest,tuneRF,0,0,0,class<`data.frame`>,1
+randomForest,tuneRF,1,0,0,class<`factor`>,1
+randomForest,tuneRF,2,0,0,double,1
+randomForest,tuneRF,3,0,0,double,1
+randomForest,tuneRF,4,0,0,double,1
+randomForest,tuneRF,5,0,0,double,1
+randomForest,tuneRF,6,0,0,logical,1
+randomForest,tuneRF,7,0,0,logical,1
+randomForest,tuneRF,8,0,0,logical,1
+randomForest,tuneRF,9,0,0,...,1
+randomForest,varImpPlot,-1,0,0,class<`matrix`>,1
+randomForest,varImpPlot,0,0,0,"class<`randomForest`, `randomForest.formula`>",1
+randomForest,varImpPlot,1,0,0,logical,1
+randomForest,varImpPlot,2,0,0,double,1
+randomForest,varImpPlot,3,0,0,null,1
+randomForest,varImpPlot,4,0,0,null,1
+randomForest,varImpPlot,5,0,0,logical,1
+randomForest,varImpPlot,6,0,0,character,1
+randomForest,varImpPlot,7,0,0,...,1
+randomForest,varUsed,-1,0,0,double[],1
+randomForest,varUsed,0,0,0,"class<`randomForest`, `randomForest.formula`>",1
+randomForest,varUsed,1,0,0,logical,1
+randomForest,varUsed,2,0,0,logical,1
+randtoolbox,bit2int,-1,0,0,double,1
+randtoolbox,bit2int,0,0,0,class<`matrix`>,1
+randtoolbox,bit2int,0,0,1,double[],1
+randtoolbox,bit2unitreal,-1,0,0,double,1
+randtoolbox,bit2unitreal,0,0,0,class<`matrix`>,1
+randtoolbox,bits.to.real,-1,0,0,double,1
+randtoolbox,bits.to.real,0,0,0,class<`matrix`>,1
+randtoolbox,bits.to.real,0,0,1,double[],1
+randtoolbox,coll.test,-1,0,0,list<double[]>,1
+randtoolbox,coll.test,0,0,0,class<`function`>,1
+randtoolbox,coll.test,1,0,0,double,1
+randtoolbox,coll.test,2,0,0,double,1
+randtoolbox,coll.test,3,0,0,double,1
+randtoolbox,coll.test,4,0,0,double,1
+randtoolbox,coll.test,5,0,0,logical,1
+randtoolbox,coll.test,6,0,0,...,1
+randtoolbox,coll.test.sparse,-1,0,0,class<`data.frame`>,1
+randtoolbox,coll.test.sparse,0,0,0,class<`function`>,1
+randtoolbox,coll.test.sparse,1,0,0,double,1
+randtoolbox,coll.test.sparse,2,0,0,double,1
+randtoolbox,coll.test.sparse,3,0,0,double,1
+randtoolbox,coll.test.sparse,4,0,0,double,1
+randtoolbox,coll.test.sparse,5,0,0,...,1
+randtoolbox,congruRand,-1,0,0,double[],1
+randtoolbox,congruRand,0,0,0,double,1
+randtoolbox,congruRand,1,0,0,double,1
+randtoolbox,congruRand,2,0,0,double,1
+randtoolbox,congruRand,3,0,0,double,1
+randtoolbox,congruRand,4,0,0,double,1
+randtoolbox,congruRand,5,0,0,any,1
+randtoolbox,freq.test,-1,0,0,list<double[]>,1
+randtoolbox,freq.test,0,0,0,double[],1
+randtoolbox,freq.test,1,0,0,integer[],1
+randtoolbox,freq.test,2,0,0,logical,1
+randtoolbox,gap.test,-1,0,0,list<double[]>,1
+randtoolbox,gap.test,0,0,0,double[],1
+randtoolbox,gap.test,1,0,0,double,1
+randtoolbox,gap.test,2,0,0,double,1
+randtoolbox,gap.test,3,0,0,logical,1
+randtoolbox,get.description,-1,0,0,list<character[] | integer[]>,1
+randtoolbox,getParameters,-1,0,0,list<double[] | class<`matrix`>>,1
+randtoolbox,getParameters,-1,0,1,list<double[] | class<`matrix`> | null>,1
+randtoolbox,getParameters,0,0,0,character,1
+randtoolbox,get.primes,-1,0,0,integer[],1
+randtoolbox,get.primes,0,0,0,double,1
+randtoolbox,.getrandtoolboxEnv,-1,0,0,any,1
+randtoolbox,.getrandtoolboxEnv,0,0,0,character,1
+randtoolbox,.getrandtoolboxEnv,1,0,0,character,1
+randtoolbox,getWELLState,-1,0,0,class<`matrix`>,1
+randtoolbox,halton,-1,0,0,any,1
+randtoolbox,halton,0,0,0,double,1
+randtoolbox,halton,1,0,0,double,1
+randtoolbox,halton,2,0,0,logical,1
+randtoolbox,halton,3,0,0,logical,1
+randtoolbox,halton,4,0,0,logical,1
+randtoolbox,halton,5,0,0,logical,1
+randtoolbox,halton,6,0,0,character,1
+randtoolbox,halton,7,0,0,double,1
+randtoolbox,hex.to.bits,-1,0,0,double[],1
+randtoolbox,hex.to.bits,0,0,0,character,1
+randtoolbox,int2bit,-1,0,0,double[],1
+randtoolbox,int2bit,0,0,0,double,1
+randtoolbox,int.to.bits,-1,0,0,class<`matrix`>,1
+randtoolbox,int.to.bits,0,0,0,integer[],1
+randtoolbox,knuthTAOCP,-1,0,0,class<`matrix`>,1
+randtoolbox,knuthTAOCP,-1,0,1,double[],1
+randtoolbox,knuthTAOCP,0,0,0,double,1
+randtoolbox,knuthTAOCP,1,0,0,double,1
+randtoolbox,order.test,-1,0,0,list<double[]>,1
+randtoolbox,order.test,0,0,0,double[],1
+randtoolbox,order.test,1,0,0,double,1
+randtoolbox,order.test,2,0,0,logical,1
+randtoolbox,permut,-1,0,0,class<`matrix`>,1
+randtoolbox,permut,0,0,0,double,1
+randtoolbox,poker.test,-1,0,0,list<double[]>,1
+randtoolbox,poker.test,0,0,0,double[],1
+randtoolbox,poker.test,1,0,0,double,1
+randtoolbox,poker.test,2,0,0,logical,1
+randtoolbox,put.description,-1,0,0,null,1
+randtoolbox,put.description,0,0,0,list<character[] | integer[]>,1
+randtoolbox,rngWELLScriptR,-1,0,0,double[],1
+randtoolbox,rngWELLScriptR,-1,0,1,list<double[] | class<`matrix`>>,1
+randtoolbox,rngWELLScriptR,0,0,0,double,1
+randtoolbox,rngWELLScriptR,1,0,0,class<`matrix`>,1
+randtoolbox,rngWELLScriptR,2,0,0,character,1
+randtoolbox,rngWELLScriptR,3,0,0,logical,1
+randtoolbox,serial.test,-1,0,0,list<double[]>,1
+randtoolbox,serial.test,0,0,0,double[],1
+randtoolbox,serial.test,1,0,0,double,1
+randtoolbox,serial.test,2,0,0,logical,1
+randtoolbox,set.generator,-1,0,0,null,1
+randtoolbox,set.generator,0,0,0,character,1
+randtoolbox,set.generator,1,0,0,null,1
+randtoolbox,set.generator,2,0,0,double,1
+randtoolbox,set.generator,2,0,1,null,1
+randtoolbox,set.generator,3,0,0,...,1
+randtoolbox,set.generator,4,0,0,logical,1
+randtoolbox,.setrandtoolboxEnv,-1,0,0,null,1
+randtoolbox,.setrandtoolboxEnv,0,0,0,...,1
+randtoolbox,setSeed,-1,0,0,null,1
+randtoolbox,setSeed,0,0,0,double,1
+randtoolbox,SFMT,-1,0,0,double[],1
+randtoolbox,SFMT,0,0,0,double,1
+randtoolbox,SFMT,1,0,0,double,1
+randtoolbox,SFMT,2,0,0,double,1
+randtoolbox,SFMT,3,0,0,logical,1
+randtoolbox,SFMT,4,0,0,double,1
+randtoolbox,SFMT,5,0,0,logical,1
+randtoolbox,sobol,-1,0,0,class<`matrix`>,1
+randtoolbox,sobol,-1,0,1,double[],1
+randtoolbox,sobol,0,0,0,double,1
+randtoolbox,sobol,0,0,1,integer[],1
+randtoolbox,sobol,1,0,0,double,1
+randtoolbox,sobol,2,0,0,logical,1
+randtoolbox,sobol,3,0,0,double,1
+randtoolbox,sobol,4,0,0,double,1
+randtoolbox,sobol,5,0,0,logical,1
+randtoolbox,sobol,6,0,0,logical,1
+randtoolbox,sobol,7,0,0,character,1
+randtoolbox,sobol,8,0,0,double,1
+randtoolbox,sobol.basic,-1,0,0,double[],1
+randtoolbox,sobol.basic,0,0,0,double,1
+randtoolbox,sobol.basic,1,0,0,double[],1
+randtoolbox,sobol.basic,2,0,0,double,1
+randtoolbox,sobol.basic,3,0,0,class<`matrix`>,1
+randtoolbox,sobol.basic,3,0,1,double[],1
+randtoolbox,sobol.basic,4,0,0,logical,1
+randtoolbox,sobol.basic,5,0,0,character[],1
+randtoolbox,sobol.directions,-1,0,0,class<`matrix`>,1
+randtoolbox,sobol.directions,0,0,0,any,1
+randtoolbox,sobol.directions,1,0,0,double,1
+randtoolbox,sobol.directions,2,0,0,class<`matrix`>,1
+randtoolbox,sobol.directions,3,0,0,double,1
+randtoolbox,sobol.directions,4,0,0,logical,1
+randtoolbox,sobol.R,-1,0,0,class<`matrix`>,1
+randtoolbox,sobol.R,0,0,0,double,1
+randtoolbox,sobol.R,1,0,0,double,1
+randtoolbox,sobol.R,2,0,0,logical,1
+randtoolbox,stirling,-1,0,0,double[],1
+randtoolbox,stirling,0,0,0,double,1
+randtoolbox,torus,-1,0,0,any,1
+randtoolbox,torus,0,0,0,double,1
+randtoolbox,torus,1,0,0,double,1
+randtoolbox,torus,2,0,0,any,1
+randtoolbox,torus,3,0,0,logical,1
+randtoolbox,torus,4,0,0,logical,1
+randtoolbox,torus,5,0,0,logical,1
+randtoolbox,torus,6,0,0,logical,1
+randtoolbox,torus,7,0,0,double,1
+randtoolbox,WELL,-1,0,0,double[],1
+randtoolbox,WELL,0,0,0,double,1
+randtoolbox,WELL,1,0,0,double,1
+randtoolbox,WELL,2,0,0,double,1
+randtoolbox,WELL,3,0,0,logical,1
+randtoolbox,WELL,4,0,0,character,1
+rcdd,addHeq,-1,0,0,class<`matrix`>,1
+rcdd,addHeq,0,0,0,integer[],1
+rcdd,addHeq,1,0,0,character,1
+rcdd,addHeq,1,0,1,double,1
+rcdd,addHeq,2,0,0,class<`matrix`>,1
+rcdd,addHin,-1,0,0,class<`matrix`>,1
+rcdd,addHin,0,0,0,double[],1
+rcdd,addHin,1,0,0,double,1
+rcdd,addHin,2,0,0,class<`matrix`>,1
+rcdd,allfaces,-1,0,0,list<list<integer[] | character[]>>,1
+rcdd,allfaces,-1,0,1,list<list<double[]>>,1
+rcdd,allfaces,0,0,0,class<`matrix`>,1
+rcdd,d2q,-1,0,0,character[],1
+rcdd,d2q,-1,0,1,"class<`bar`, `baz`, `foo`>",1
+rcdd,d2q,-1,0,2,class<`matrix`>,1
+rcdd,d2q,0,0,0,double[],1
+rcdd,d2q,0,0,1,"class<`bar`, `baz`, `foo`>",1
+rcdd,d2q,0,0,2,class<`matrix`>,1
+rcdd,linearity,-1,0,0,integer[],1
+rcdd,linearity,0,0,0,class<`matrix`>,1
+rcdd,linearity,1,0,0,character,1
+rcdd,lpcdd,-1,0,0,list<character[]>,1
+rcdd,lpcdd,-1,0,1,list<character | double[]>,1
+rcdd,lpcdd,0,0,0,class<`matrix`>,1
+rcdd,lpcdd,1,0,0,character[],1
+rcdd,lpcdd,1,0,1,double[],1
+rcdd,lpcdd,2,0,0,character,1
+rcdd,lpcdd,2,0,1,double,1
+rcdd,lpcdd,3,0,0,logical,1
+rcdd,lpcdd,4,0,0,character[],1
+rcdd,makeH,-1,0,0,class<`matrix`>,1
+rcdd,makeH,0,0,0,any,1
+rcdd,makeH,1,0,0,any,1
+rcdd,makeH,2,0,0,any,1
+rcdd,makeH,3,0,0,any,1
+rcdd,makeH,4,0,0,null,1
+rcdd,makeH,4,0,1,class<`matrix`>,1
+rcdd,makeV,-1,0,0,class<`matrix`>,1
+rcdd,makeV,0,0,0,any,1
+rcdd,makeV,1,0,0,any,1
+rcdd,makeV,2,0,0,any,1
+rcdd,makeV,3,0,0,null,1
+rcdd,q2d,-1,0,0,class<`matrix`>,1
+rcdd,q2d,-1,0,1,double[],1
+rcdd,q2d,0,0,0,class<`matrix`>,1
+rcdd,q2d,0,0,1,character[],1
+rcdd,q2q,-1,0,0,character[],1
+rcdd,q2q,-1,0,1,class<`matrix`>,1
+rcdd,q2q,0,0,0,character[],1
+rcdd,q2q,0,0,1,class<`matrix`>,1
+rcdd,qabs,-1,0,0,class<`matrix`>,1
+rcdd,qabs,0,0,0,class<`matrix`>,1
+rcdd,qdq,-1,0,0,character[],1
+rcdd,qdq,-1,0,1,class<`matrix`>,1
+rcdd,qdq,0,0,0,character[],1
+rcdd,qdq,0,0,1,class<`matrix`>,1
+rcdd,qdq,1,0,0,character[],1
+rcdd,qdq,1,0,1,double[],1
+rcdd,qgram,-1,0,0,class<`matrix`>,1
+rcdd,qgram,0,0,0,class<`matrix`>,1
+rcdd,qgram,1,0,0,logical,1
+rcdd,qmatmult,-1,0,0,class<`matrix`>,1
+rcdd,qmatmult,0,0,0,class<`matrix`>,1
+rcdd,qmatmult,1,0,0,class<`matrix`>,1
+rcdd,qmax,-1,0,0,character,1
+rcdd,qmax,0,0,0,character[],1
+rcdd,qmin,-1,0,0,character,1
+rcdd,qmin,0,0,0,character[],1
+rcdd,qmq,-1,0,0,class<`matrix`>,1
+rcdd,qmq,-1,0,1,character[],1
+rcdd,qmq,0,0,0,class<`matrix`>,1
+rcdd,qmq,0,0,1,character[],1
+rcdd,qmq,0,0,2,integer[],1
+rcdd,qmq,1,0,0,class<`matrix`>,1
+rcdd,qmq,1,0,1,character[],1
+rcdd,qmq,1,0,2,double,1
+rcdd,qneg,-1,0,0,character[],1
+rcdd,qneg,-1,0,1,class<`matrix`>,1
+rcdd,qneg,0,0,0,character[],1
+rcdd,qneg,0,0,1,integer[],1
+rcdd,qneg,0,0,2,class<`matrix`>,1
+rcdd,qpq,-1,0,0,character[],1
+rcdd,qpq,0,0,0,character[],1
+rcdd,qpq,0,0,1,double[],1
+rcdd,qpq,1,0,0,character[],1
+rcdd,qpq,1,0,1,class<`matrix`>,1
+rcdd,qprod,-1,0,0,character,1
+rcdd,qprod,0,0,0,character[],1
+rcdd,qsign,-1,0,0,integer[],1
+rcdd,qsign,0,0,0,character[],1
+rcdd,qsign,0,0,1,integer[],1
+rcdd,qsum,-1,0,0,character,1
+rcdd,qsum,0,0,0,character[],1
+rcdd,qxq,-1,0,0,character[],1
+rcdd,qxq,-1,0,1,class<`matrix`>,1
+rcdd,qxq,0,0,0,character[],1
+rcdd,qxq,0,0,1,class<`matrix`>,1
+rcdd,qxq,1,0,0,character[],1
+rcdd,qxq,1,0,1,double[],1
+rcdd,redundant,-1,0,0,list<class<`matrix`> | integer[]>,1
+rcdd,redundant,0,0,0,class<`matrix`>,1
+rcdd,redundant,1,0,0,character[],1
+rcdd,scdd,-1,0,0,any,1
+rcdd,scdd,0,0,0,class<`matrix`>,1
+rcdd,scdd,1,0,0,logical,1
+rcdd,scdd,2,0,0,logical,1
+rcdd,scdd,3,0,0,logical,1
+rcdd,scdd,4,0,0,logical,1
+rcdd,scdd,5,0,0,character[],1
+rcdd,scdd,6,0,0,character[],1
+rcdd,scdd,7,0,0,character[],1
+rcdd,validcdd,-1,0,0,logical,1
+rcdd,validcdd,0,0,0,class<`matrix`>,1
+rcdd,validcdd,1,0,0,character[],1
+rcdd,z2q,-1,0,0,character[],1
+rcdd,z2q,-1,0,1,class<`matrix`>,1
+rcdd,z2q,0,0,0,character[],1
+rcdd,z2q,0,0,1,integer[],1
+rcdd,z2q,0,0,2,double,1
+rcdd,z2q,0,0,3,class<`matrix`>,1
+rcdd,z2q,1,0,0,character[],1
+rcdd,z2q,1,0,1,class<`matrix`>,1
+rcdd,z2q,1,0,2,double[],1
+rcdd,z2q,2,0,0,logical,1
+readbitmap,image_type,-1,0,0,character,1
+readbitmap,image_type,0,0,0,character,1
+readbitmap,image_type,1,0,0,logical,1
+readbitmap,read.bitmap,-1,0,0,class<`array`>,1
+readbitmap,read.bitmap,0,0,0,character,1
+readbitmap,read.bitmap,1,0,0,any,1
+readbitmap,read.bitmap,2,0,0,logical,1
+readbitmap,read.bitmap,3,0,0,...,1
+readr,%||%,-1,0,0,character[],1
+readr,%||%,-1,0,1,logical,1
+readr,%||%,0,0,0,character[],1
+readr,%||%,0,0,1,null,1
+readr,%||%,1,0,0,any,1
+readr,as_chunk_callback,-1,0,0,"class<`AccumulateCallback`, `ChunkCallback`, `R6`>",1
+readr,as_chunk_callback,-1,0,1,"class<`ChunkCallback`, `DataFrameCallback`, `R6`>",1
+readr,as_chunk_callback,-1,0,2,"class<`ChunkCallback`, `ListCallback`, `R6`>",1
+readr,as_chunk_callback,-1,0,3,"class<`ChunkCallback`, `R6`, `SideEffectChunkCallback`>",1
+readr,as_chunk_callback,0,0,0,"class<`AccumulateCallback`, `ChunkCallback`, `R6`>",1
+readr,as_chunk_callback,0,0,1,"class<`ChunkCallback`, `DataFrameCallback`, `R6`>",1
+readr,as_chunk_callback,0,0,2,"class<`ChunkCallback`, `ListCallback`, `R6`>",1
+readr,as_chunk_callback,0,0,3,"class<`ChunkCallback`, `R6`, `SideEffectChunkCallback`>",1
+readr,as_chunk_callback,0,0,4,class<`function`>,1
+readr,as_chunk_callback.ChunkCallback,-1,0,0,"class<`AccumulateCallback`, `ChunkCallback`, `R6`>",1
+readr,as_chunk_callback.ChunkCallback,-1,0,1,"class<`ChunkCallback`, `DataFrameCallback`, `R6`>",1
+readr,as_chunk_callback.ChunkCallback,-1,0,2,"class<`ChunkCallback`, `ListCallback`, `R6`>",1
+readr,as_chunk_callback.ChunkCallback,-1,0,3,"class<`ChunkCallback`, `R6`, `SideEffectChunkCallback`>",1
+readr,as_chunk_callback.ChunkCallback,-1,0,4,^double[],1
+readr,as_chunk_callback.ChunkCallback,0,0,0,"class<`AccumulateCallback`, `ChunkCallback`, `R6`>",1
+readr,as_chunk_callback.ChunkCallback,0,0,1,"class<`ChunkCallback`, `DataFrameCallback`, `R6`>",1
+readr,as_chunk_callback.ChunkCallback,0,0,2,"class<`ChunkCallback`, `ListCallback`, `R6`>",1
+readr,as_chunk_callback.ChunkCallback,0,0,3,"class<`ChunkCallback`, `R6`, `SideEffectChunkCallback`>",1
+readr,as_chunk_callback.ChunkCallback,0,0,4,^double[],1
+readr,as_chunk_callback.function,-1,0,0,"class<`ChunkCallback`, `R6`, `SideEffectChunkCallback`>",1
+readr,as_chunk_callback.function,0,0,0,class<`function`>,1
+readr,as.col_spec,-1,0,0,class<`col_spec`>,1
+readr,as.col_spec,0,0,0,character,1
+readr,as.col_spec,0,0,1,class<`col_spec`>,1
+readr,as.col_spec,0,0,2,"list<class<`collector`, `collector_double`> | class<`collector`, `collector_character`>>",1
+readr,as.col_spec,0,0,3,"list<class<`collector`, `collector_double`>>",1
+readr,as.col_spec,0,0,4,null,1
+readr,as.col_spec.character,-1,0,0,class<`col_spec`>,1
+readr,as.col_spec.character,0,0,0,character,1
+readr,as.col_spec.col_spec,-1,0,0,class<`col_spec`>,1
+readr,as.col_spec.col_spec,0,0,0,class<`col_spec`>,1
+readr,as.col_spec.list,-1,0,0,class<`col_spec`>,1
+readr,as.col_spec.list,0,0,0,"list<class<`collector`, `collector_double`> | class<`collector`, `collector_character`>>",1
+readr,as.col_spec.list,0,0,1,"list<class<`collector`, `collector_double`>>",1
+readr,as.col_spec.NULL,-1,0,0,class<`col_spec`>,1
+readr,as.col_spec.NULL,0,0,0,null,1
+readr,check_callback_fun,-1,0,0,null,1
+readr,check_callback_fun,0,0,0,class<`function`>,1
+readr,check_callback_fun,1,0,0,double,1
+readr,check_callback_fun,2,0,0,character,1
+readr,check_callback_fun,2,0,1,null,1
+readr,check_encoding,-1,0,0,logical,1
+readr,check_encoding,0,0,0,character,1
+readr,check_guess_max,-1,0,0,double,1
+readr,check_guess_max,0,0,0,double,1
+readr,check_guess_max,1,0,0,double,1
+readr,check_path,-1,0,0,character,1
+readr,check_path,0,0,0,character,1
+readr,check_tz,-1,0,0,logical,1
+readr,check_tz,0,0,0,character,1
+readr,col_character,-1,0,0,"class<`collector`, `collector_character`>",1
+readr,col_date,-1,0,0,"class<`collector`, `collector_date`>",1
+readr,col_date,0,0,0,character,1
+readr,col_datetime,-1,0,0,"class<`collector`, `collector_datetime`>",1
+readr,col_datetime,0,0,0,character,1
+readr,col_double,-1,0,0,"class<`collector`, `collector_double`>",1
+readr,col_factor,-1,0,0,"class<`collector`, `collector_factor`>",1
+readr,col_factor,0,0,0,character[],1
+readr,col_factor,0,0,1,null,1
+readr,col_factor,1,0,0,logical,1
+readr,col_factor,2,0,0,logical,1
+readr,col_guess,-1,0,0,"class<`collector`, `collector_guess`>",1
+readr,col_integer,-1,0,0,"class<`collector`, `collector_integer`>",1
+readr,collector,-1,0,0,"class<`collector`, `collector_character`>",1
+readr,collector,-1,0,1,"class<`collector`, `collector_date`>",1
+readr,collector,-1,0,2,"class<`collector`, `collector_datetime`>",1
+readr,collector,-1,0,3,"class<`collector`, `collector_double`>",1
+readr,collector,-1,0,4,"class<`collector`, `collector_factor`>",1
+readr,collector,-1,0,5,"class<`collector`, `collector_guess`>",1
+readr,collector,-1,0,6,"class<`collector`, `collector_integer`>",1
+readr,collector,-1,0,7,"class<`collector`, `collector_logical`>",1
+readr,collector,-1,0,8,"class<`collector`, `collector_number`>",1
+readr,collector,-1,0,9,"class<`collector`, `collector_skip`>",1
+readr,collector,-1,0,10,"class<`collector`, `collector_time`>",1
+readr,collector,0,0,0,character,1
+readr,collector,1,0,0,...,1
+readr,collector_find,-1,0,0,"class<`collector`, `collector_character`>",1
+readr,collector_find,-1,0,1,"class<`collector`, `collector_date`>",1
+readr,collector_find,-1,0,2,"class<`collector`, `collector_double`>",1
+readr,collector_find,-1,0,3,"class<`collector`, `collector_logical`>",1
+readr,collector_find,-1,0,4,"class<`collector`, `collector_number`>",1
+readr,collector_find,0,0,0,character,1
+readr,collectorGuess,-1,0,0,character,1
+readr,collectorGuess,0,0,0,^character[],1
+readr,collectorGuess,1,0,0,class<`locale`>,1
+readr,collectorGuess,2,0,0,logical,1
+readr,col_logical,-1,0,0,"class<`collector`, `collector_logical`>",1
+readr,col_number,-1,0,0,"class<`collector`, `collector_number`>",1
+readr,colourise_cols,-1,0,0,character,1
+readr,colourise_cols,0,0,0,character,1
+readr,colourise_cols,1,0,0,logical,1
+readr,cols,-1,0,0,class<`col_spec`>,1
+readr,cols,0,0,0,...,1
+readr,cols,1,0,0,"class<`collector`, `collector_character`>",1
+readr,cols,1,0,1,"class<`collector`, `collector_guess`>",1
+readr,cols,1,0,2,"class<`collector`, `collector_skip`>",1
+readr,cols_condense,-1,0,0,class<`col_spec`>,1
+readr,cols_condense,0,0,0,class<`col_spec`>,1
+readr,col_skip,-1,0,0,"class<`collector`, `collector_skip`>",1
+readr,cols_only,-1,0,0,class<`col_spec`>,1
+readr,cols_only,0,0,0,...,1
+readr,col_spec,-1,0,0,class<`col_spec`>,1
+readr,col_spec,0,0,0,list<any>,1
+readr,col_spec,1,0,0,"class<`collector`, `collector_character`>",1
+readr,col_spec,1,0,1,"class<`collector`, `collector_guess`>",1
+readr,col_spec,1,0,2,"class<`collector`, `collector_skip`>",1
+readr,col_spec_standardise,-1,0,0,class<`col_spec`>,1
+readr,col_spec_standardise,0,0,0,any,1
+readr,col_spec_standardise,1,0,0,character[],1
+readr,col_spec_standardise,1,0,1,logical,1
+readr,col_spec_standardise,2,0,0,null,1
+readr,col_spec_standardise,2,0,1,character,1
+readr,col_spec_standardise,2,0,2,class<`col_spec`>,1
+readr,col_spec_standardise,2,0,3,"list<class<`collector`, `collector_double`> | class<`collector`, `collector_character`>>",1
+readr,col_spec_standardise,2,0,4,"list<class<`collector`, `collector_double`>>",1
+readr,col_spec_standardise,3,0,0,null,1
+readr,col_spec_standardise,3,0,1,list<character>,1
+readr,col_spec_standardise,4,0,0,character,1
+readr,col_spec_standardise,5,0,0,double,1
+readr,col_spec_standardise,6,0,0,any,1
+readr,col_spec_standardise,7,0,0,any,1
+readr,col_spec_standardise,8,0,0,any,1
+readr,col_spec_standardise,9,0,0,any,1
+readr,col_spec_standardise,10,0,0,logical,1
+readr,col_time,-1,0,0,"class<`collector`, `collector_time`>",1
+readr,col_time,0,0,0,character,1
+readr,count_fields,-1,0,0,integer[],1
+readr,count_fields,0,0,0,character,1
+readr,count_fields,1,0,0,class<`tokenizer_delim`>,1
+readr,count_fields,2,0,0,double,1
+readr,count_fields,3,0,0,integer,1
+readr,count_fields_,-1,0,0,integer[],1
+readr,count_fields_,0,0,0,"class<`source`, `source_file`>",1
+readr,count_fields_,1,0,0,class<`tokenizer_delim`>,1
+readr,count_fields_,2,0,0,integer,1
+readr,datasource,-1,0,0,"class<`source`, `source_file`>",1
+readr,datasource,-1,0,1,"class<`source`, `source_raw`>",1
+readr,datasource,-1,0,2,"class<`source`, `source_string`>",1
+readr,datasource,0,0,0,character,1
+readr,datasource,0,0,1,"class<`connection`, `rawConnection`>",1
+readr,datasource,0,0,2,"class<`source`, `source_file`>",1
+readr,datasource,0,0,3,raw[],1
+readr,datasource,1,0,0,double,1
+readr,datasource,2,0,0,any,1
+readr,datasource,3,0,0,character,1
+readr,datasource_connection,-1,0,0,"class<`source`, `source_file`>",1
+readr,datasource_connection,0,0,0,"class<`bzfile`, `connection`>",1
+readr,datasource_connection,0,0,1,"class<`connection`, `rawConnection`>",1
+readr,datasource_connection,0,0,2,"class<`connection`, `unz`>",1
+readr,datasource_connection,1,0,0,double,1
+readr,datasource_connection,2,0,0,logical,1
+readr,datasource_connection,3,0,0,character,1
+readr,datasource_file,-1,0,0,"class<`source`, `source_file`>",1
+readr,datasource_file,0,0,0,character,1
+readr,datasource_file,1,0,0,double,1
+readr,datasource_file,2,0,0,logical,1
+readr,datasource_file,3,0,0,character,1
+readr,datasource_file,4,0,0,...,1
+readr,datasource_raw,-1,0,0,"class<`source`, `source_raw`>",1
+readr,datasource_raw,0,0,0,raw[],1
+readr,datasource_raw,1,0,0,double,1
+readr,datasource_raw,2,0,0,logical,1
+readr,datasource_raw,3,0,0,character,1
+readr,datasource_string,-1,0,0,"class<`source`, `source_string`>",1
+readr,datasource_string,0,0,0,character,1
+readr,datasource_string,1,0,0,double,1
+readr,datasource_string,2,0,0,logical,1
+readr,datasource_string,3,0,0,character,1
+readr,date_names,-1,0,0,class<`date_names`>,1
+readr,date_names,0,0,0,character[],1
+readr,date_names,1,0,0,character[],1
+readr,date_names,2,0,0,character[],1
+readr,date_names,3,0,0,character[],1
+readr,date_names,4,0,0,character[],1
+readr,date_names_lang,-1,0,0,class<`date_names`>,1
+readr,date_names_lang,0,0,0,character,1
+readr,default_locale,-1,0,0,class<`locale`>,1
+readr,empty_file,-1,0,0,logical,1
+readr,empty_file,0,0,0,character,1
+readr,format.col_spec,-1,0,0,character,1
+readr,format.col_spec,0,0,0,class<`col_spec`>,1
+readr,format.col_spec,1,0,0,double,1
+readr,format.col_spec,2,0,0,null,1
+readr,format.col_spec,3,0,0,logical,1
+readr,format.col_spec,4,0,0,...,1
+readr,format_csv,-1,0,0,character,1
+readr,format_csv,0,0,0,class<`data.frame`>,1
+readr,format_csv,1,0,0,character,1
+readr,format_csv,2,0,0,logical,1
+readr,format_csv,3,0,0,logical,1
+readr,format_csv,4,0,0,character,1
+readr,format_delim,-1,0,0,character,1
+readr,format_delim,0,0,0,class<`data.frame`>,1
+readr,format_delim,1,0,0,character,1
+readr,format_delim,2,0,0,character,1
+readr,format_delim,3,0,0,any,1
+readr,format_delim,4,0,0,logical,1
+readr,format_delim,5,0,0,character,1
+readr,format_tsv,-1,0,0,character,1
+readr,format_tsv,0,0,0,class<`data.frame`>,1
+readr,format_tsv,1,0,0,character,1
+readr,format_tsv,2,0,0,logical,1
+readr,format_tsv,3,0,0,logical,1
+readr,format_tsv,4,0,0,character,1
+readr,fwf_col_names,-1,0,0,character[],1
+readr,fwf_col_names,0,0,0,character[],1
+readr,fwf_col_names,0,0,1,null,1
+readr,fwf_col_names,1,0,0,integer,1
+readr,fwf_cols,-1,0,0,"class<`data.frame`, `tbl`, `tbl_df`>",1
+readr,fwf_cols,0,0,0,...,1
+readr,fwf_empty,-1,0,0,list<^integer[] | character[]>,1
+readr,fwf_empty,0,0,0,character,1
+readr,fwf_empty,0,0,1,"class<`source`, `source_file`>",1
+readr,fwf_empty,1,0,0,double,1
+readr,fwf_empty,2,0,0,any,1
+readr,fwf_empty,3,0,0,character[],1
+readr,fwf_empty,3,0,1,null,1
+readr,fwf_empty,4,0,0,character,1
+readr,fwf_empty,5,0,0,double,1
+readr,fwf_positions,-1,0,0,"class<`data.frame`, `tbl`, `tbl_df`>",1
+readr,fwf_positions,0,0,0,double[],1
+readr,fwf_positions,1,0,0,double[],1
+readr,fwf_positions,2,0,0,character[],1
+readr,fwf_widths,-1,0,0,"class<`data.frame`, `tbl`, `tbl_df`>",1
+readr,fwf_widths,0,0,0,double[],1
+readr,fwf_widths,1,0,0,character[],1
+readr,guess_encoding,-1,0,0,"class<`data.frame`, `tbl`, `tbl_df`>",1
+readr,guess_encoding,0,0,0,character,1
+readr,guess_encoding,0,0,1,list<raw[]>,1
+readr,guess_encoding,0,0,2,raw[],1
+readr,guess_encoding,1,0,0,double,1
+readr,guess_encoding,2,0,0,double,1
+readr,guess_header,-1,0,0,list<character[] | double>,1
+readr,guess_header,-1,0,1,list<character | double>,1
+readr,guess_header,-1,0,2,list<^character[] | double>,1
+readr,guess_header,0,0,0,"class<`source`, `source_file`>",1
+readr,guess_header,0,0,1,"class<`source`, `source_string`>",1
+readr,guess_header,1,0,0,class<`tokenizer_delim`>,1
+readr,guess_header,1,0,1,class<`tokenizer_fwf`>,1
+readr,guess_header,1,0,2,class<`tokenizer_log`>,1
+readr,guess_header,2,0,0,class<`locale`>,1
+readr,guess_header_,-1,0,0,list<character[] | double>,1
+readr,guess_header_,-1,0,1,list<character | double>,1
+readr,guess_header_,-1,0,2,list<^character[] | double>,1
+readr,guess_header_,0,0,0,"class<`source`, `source_file`>",1
+readr,guess_header_,0,0,1,"class<`source`, `source_string`>",1
+readr,guess_header_,1,0,0,class<`tokenizer_delim`>,1
+readr,guess_header_,1,0,1,class<`tokenizer_fwf`>,1
+readr,guess_header_,1,0,2,class<`tokenizer_log`>,1
+readr,guess_header_,2,0,0,class<`locale`>,1
+readr,guess_parser,-1,0,0,character,1
+readr,guess_parser,0,0,0,^character[],1
+readr,guess_parser,1,0,0,class<`locale`>,1
+readr,guess_parser,2,0,0,logical,1
+readr,guess_types,-1,0,0,character[],1
+readr,guess_types,0,0,0,"class<`source`, `source_file`>",1
+readr,guess_types,0,0,1,"class<`source`, `source_string`>",1
+readr,guess_types,1,0,0,class<`tokenizer_delim`>,1
+readr,guess_types,1,0,1,class<`tokenizer_fwf`>,1
+readr,guess_types,1,0,2,class<`tokenizer_log`>,1
+readr,guess_types,2,0,0,class<`locale`>,1
+readr,guess_types,3,0,0,double,1
+readr,guess_types,4,0,0,double,1
+readr,guess_types_,-1,0,0,character[],1
+readr,guess_types_,0,0,0,"class<`source`, `source_file`>",1
+readr,guess_types_,0,0,1,"class<`source`, `source_string`>",1
+readr,guess_types_,1,0,0,class<`tokenizer_delim`>,1
+readr,guess_types_,1,0,1,class<`tokenizer_fwf`>,1
+readr,guess_types_,1,0,2,class<`tokenizer_log`>,1
+readr,guess_types_,2,0,0,class<`locale`>,1
+readr,guess_types_,3,0,0,double,1
+readr,is.collector,-1,0,0,logical,1
+readr,is.collector,0,0,0,"class<`collector`, `collector_character`>",1
+readr,is.collector,0,0,1,"class<`collector`, `collector_date`>",1
+readr,is.collector,0,0,2,"class<`collector`, `collector_double`>",1
+readr,is.collector,0,0,3,"class<`collector`, `collector_integer`>",1
+readr,is.collector,0,0,4,"class<`collector`, `collector_number`>",1
+readr,is.collector,0,0,5,"class<`collector`, `collector_skip`>",1
+readr,is.collector,0,0,6,"class<`collector`, `collector_guess`>",1
+readr,is.connection,-1,0,0,logical,1
+readr,is.connection,0,0,0,character,1
+readr,is.connection,0,0,1,"class<`bzfile`, `connection`>",1
+readr,is.connection,0,0,2,"class<`connection`, `rawConnection`>",1
+readr,is.connection,0,0,3,"class<`connection`, `unz`>",1
+readr,is.connection,0,0,4,raw[],1
+readr,is.date_names,-1,0,0,logical,1
+readr,is.date_names,0,0,0,class<`date_names`>,1
+readr,is_integerish,-1,0,0,logical,1
+readr,is_integerish,0,0,0,double,1
+readr,is.locale,-1,0,0,logical,1
+readr,is.locale,0,0,0,class<`locale`>,1
+readr,is_named,-1,0,0,logical,1
+readr,is_named,0,0,0,character,1
+readr,is_syntactic,-1,0,0,logical,1
+readr,is_syntactic,0,0,0,character,1
+readr,is_url,-1,0,0,logical,1
+readr,is_url,0,0,0,character,1
+readr,keep_character_col_types,-1,0,0,null,1
+readr,keep_character_col_types,0,0,0,any,1
+readr,keep_character_col_types,1,0,0,null,1
+readr,locale,-1,0,0,class<`locale`>,1
+readr,locale,0,0,0,character,1
+readr,locale,0,0,1,class<`date_names`>,1
+readr,locale,1,0,0,character,1
+readr,locale,2,0,0,character,1
+readr,locale,3,0,0,character,1
+readr,locale,4,0,0,character,1
+readr,locale,5,0,0,character,1
+readr,locale,6,0,0,character,1
+readr,locale,7,0,0,logical,1
+readr,melt_csv,-1,0,0,"class<`data.frame`, `tbl`, `tbl_df`>",1
+readr,melt_csv,0,0,0,character,1
+readr,melt_csv,1,0,0,class<`locale`>,1
+readr,melt_csv,2,0,0,character[],1
+readr,melt_csv,3,0,0,logical,1
+readr,melt_csv,4,0,0,character,1
+readr,melt_csv,5,0,0,character,1
+readr,melt_csv,6,0,0,logical,1
+readr,melt_csv,7,0,0,double,1
+readr,melt_csv,8,0,0,double,1
+readr,melt_csv,9,0,0,logical,1
+readr,melt_csv,10,0,0,logical,1
+readr,melt_csv2,-1,0,0,"class<`data.frame`, `tbl`, `tbl_df`>",1
+readr,melt_csv2,0,0,0,character,1
+readr,melt_csv2,1,0,0,class<`locale`>,1
+readr,melt_csv2,2,0,0,character[],1
+readr,melt_csv2,3,0,0,logical,1
+readr,melt_csv2,4,0,0,character,1
+readr,melt_csv2,5,0,0,character,1
+readr,melt_csv2,6,0,0,logical,1
+readr,melt_csv2,7,0,0,double,1
+readr,melt_csv2,8,0,0,double,1
+readr,melt_csv2,9,0,0,logical,1
+readr,melt_csv2,10,0,0,logical,1
+readr,melt_csv_chunked,-1,0,0,"class<`data.frame`, `tbl`, `tbl_df`>",1
+readr,melt_csv_chunked,0,0,0,character,1
+readr,melt_csv_chunked,1,0,0,"class<`ChunkCallback`, `DataFrameCallback`, `R6`>",1
+readr,melt_csv_chunked,2,0,0,double,1
+readr,melt_csv_chunked,3,0,0,class<`locale`>,1
+readr,melt_csv_chunked,4,0,0,character[],1
+readr,melt_csv_chunked,5,0,0,logical,1
+readr,melt_csv_chunked,6,0,0,character,1
+readr,melt_csv_chunked,7,0,0,character,1
+readr,melt_csv_chunked,8,0,0,logical,1
+readr,melt_csv_chunked,9,0,0,double,1
+readr,melt_csv_chunked,10,0,0,logical,1
+readr,melt_csv_chunked,11,0,0,logical,1
+readr,melt_delim,-1,0,0,"class<`data.frame`, `tbl`, `tbl_df`>",1
+readr,melt_delim,0,0,0,character,1
+readr,melt_delim,1,0,0,character,1
+readr,melt_delim,2,0,0,character,1
+readr,melt_delim,3,0,0,logical,1
+readr,melt_delim,4,0,0,logical,1
+readr,melt_delim,5,0,0,class<`locale`>,1
+readr,melt_delim,6,0,0,character[],1
+readr,melt_delim,7,0,0,logical,1
+readr,melt_delim,8,0,0,character,1
+readr,melt_delim,9,0,0,logical,1
+readr,melt_delim,10,0,0,double,1
+readr,melt_delim,11,0,0,double,1
+readr,melt_delim,12,0,0,logical,1
+readr,melt_delim,13,0,0,logical,1
+readr,melt_delimited,-1,0,0,"class<`data.frame`, `tbl`, `tbl_df`>",1
+readr,melt_delimited,0,0,0,character,1
+readr,melt_delimited,1,0,0,class<`tokenizer_delim`>,1
+readr,melt_delimited,2,0,0,class<`locale`>,1
+readr,melt_delimited,3,0,0,double,1
+readr,melt_delimited,4,0,0,logical,1
+readr,melt_delimited,5,0,0,character,1
+readr,melt_delimited,6,0,0,double,1
+readr,melt_delimited,7,0,0,logical,1
+readr,melt_delimited_chunked,-1,0,0,"class<`data.frame`, `tbl`, `tbl_df`>",1
+readr,melt_delimited_chunked,0,0,0,character,1
+readr,melt_delimited_chunked,1,0,0,"class<`ChunkCallback`, `DataFrameCallback`, `R6`>",1
+readr,melt_delimited_chunked,2,0,0,double,1
+readr,melt_delimited_chunked,3,0,0,class<`tokenizer_delim`>,1
+readr,melt_delimited_chunked,4,0,0,class<`locale`>,1
+readr,melt_delimited_chunked,5,0,0,double,1
+readr,melt_delimited_chunked,6,0,0,logical,1
+readr,melt_delimited_chunked,7,0,0,character,1
+readr,melt_delimited_chunked,8,0,0,logical,1
+readr,melt_fwf,-1,0,0,"class<`data.frame`, `tbl`, `tbl_df`>",1
+readr,melt_fwf,0,0,0,character,1
+readr,melt_fwf,1,0,0,"class<`data.frame`, `tbl`, `tbl_df`>",1
+readr,melt_fwf,1,0,1,list<^integer[] | character[]>,1
+readr,melt_fwf,2,0,0,class<`locale`>,1
+readr,melt_fwf,3,0,0,character[],1
+readr,melt_fwf,4,0,0,character,1
+readr,melt_fwf,5,0,0,logical,1
+readr,melt_fwf,6,0,0,double,1
+readr,melt_fwf,7,0,0,double,1
+readr,melt_fwf,8,0,0,logical,1
+readr,melt_fwf,9,0,0,logical,1
+readr,melt_table,-1,0,0,"class<`data.frame`, `tbl`, `tbl_df`>",1
+readr,melt_table,0,0,0,character,1
+readr,melt_table,1,0,0,class<`locale`>,1
+readr,melt_table,2,0,0,character,1
+readr,melt_table,3,0,0,double,1
+readr,melt_table,4,0,0,double,1
+readr,melt_table,5,0,0,double,1
+readr,melt_table,6,0,0,logical,1
+readr,melt_table,7,0,0,character,1
+readr,melt_table,8,0,0,logical,1
+readr,melt_tokens,-1,0,0,"class<`data.frame`, `tbl`, `tbl_df`>",1
+readr,melt_tokens,0,0,0,"class<`source`, `source_file`>",1
+readr,melt_tokens,0,0,1,"class<`source`, `source_string`>",1
+readr,melt_tokens,1,0,0,class<`tokenizer_delim`>,1
+readr,melt_tokens,1,0,1,class<`tokenizer_fwf`>,1
+readr,melt_tokens,2,0,0,class<`locale`>,1
+readr,melt_tokens,3,0,0,double,1
+readr,melt_tokens,4,0,0,logical,1
+readr,melt_tokens_,-1,0,0,"class<`data.frame`, `tbl`, `tbl_df`>",1
+readr,melt_tokens_,0,0,0,"class<`source`, `source_file`>",1
+readr,melt_tokens_,0,0,1,"class<`source`, `source_string`>",1
+readr,melt_tokens_,1,0,0,class<`tokenizer_delim`>,1
+readr,melt_tokens_,1,0,1,class<`tokenizer_fwf`>,1
+readr,melt_tokens_,2,0,0,"list<class<`collector`, `collector_double`> | class<`collector`, `collector_character`>>",1
+readr,melt_tokens_,3,0,0,class<`locale`>,1
+readr,melt_tokens_,4,0,0,double,1
+readr,melt_tokens_,5,0,0,logical,1
+readr,melt_tokens_chunked,-1,0,0,"class<`data.frame`, `tbl`, `tbl_df`>",1
+readr,melt_tokens_chunked,0,0,0,"class<`source`, `source_file`>",1
+readr,melt_tokens_chunked,1,0,0,"class<`ChunkCallback`, `DataFrameCallback`, `R6`>",1
+readr,melt_tokens_chunked,2,0,0,double,1
+readr,melt_tokens_chunked,3,0,0,class<`tokenizer_delim`>,1
+readr,melt_tokens_chunked,4,0,0,class<`locale`>,1
+readr,melt_tokens_chunked,5,0,0,logical,1
+readr,melt_tokens_chunked_,-1,0,0,null,1
+readr,melt_tokens_chunked_,0,0,0,"class<`source`, `source_file`>",1
+readr,melt_tokens_chunked_,1,0,0,"class<`ChunkCallback`, `DataFrameCallback`, `R6`>",1
+readr,melt_tokens_chunked_,2,0,0,double,1
+readr,melt_tokens_chunked_,3,0,0,class<`tokenizer_delim`>,1
+readr,melt_tokens_chunked_,4,0,0,"list<class<`collector`, `collector_double`> | class<`collector`, `collector_character`>>",1
+readr,melt_tokens_chunked_,5,0,0,class<`locale`>,1
+readr,melt_tokens_chunked_,6,0,0,logical,1
+readr,melt_tsv,-1,0,0,"class<`data.frame`, `tbl`, `tbl_df`>",1
+readr,melt_tsv,0,0,0,character,1
+readr,melt_tsv,1,0,0,class<`locale`>,1
+readr,melt_tsv,2,0,0,character[],1
+readr,melt_tsv,3,0,0,logical,1
+readr,melt_tsv,4,0,0,character,1
+readr,melt_tsv,5,0,0,character,1
+readr,melt_tsv,6,0,0,logical,1
+readr,melt_tsv,7,0,0,double,1
+readr,melt_tsv,8,0,0,double,1
+readr,melt_tsv,9,0,0,logical,1
+readr,melt_tsv,10,0,0,logical,1
+readr,name_problems,-1,0,0,"class<`data.frame`, `spec_tbl_df`, `tbl`, `tbl_df`>",1
+readr,name_problems,0,0,0,"class<`data.frame`, `spec_tbl_df`, `tbl`, `tbl_df`>",1
+readr,name_problems,1,0,0,any,1
+readr,name_problems,2,0,0,any,1
+readr,new_datasource,-1,0,0,"class<`source`, `source_file`>",1
+readr,new_datasource,-1,0,1,"class<`source`, `source_raw`>",1
+readr,new_datasource,-1,0,2,"class<`source`, `source_string`>",1
+readr,new_datasource,0,0,0,character,1
+readr,new_datasource,1,0,0,character,1
+readr,new_datasource,1,0,1,raw[],1
+readr,new_datasource,2,0,0,double,1
+readr,new_datasource,3,0,0,logical,1
+readr,new_datasource,4,0,0,character,1
+readr,new_datasource,5,0,0,...,1
+readr,n_problems,-1,0,0,double,1
+readr,n_problems,0,0,0,character,1
+readr,n_problems,0,0,1,"class<`data.frame`, `spec_tbl_df`, `tbl`, `tbl_df`>",1
+readr,n_problems,0,0,2,"class<`data.frame`, `tbl`, `tbl_df`>",1
+readr,n_problems,0,0,3,class<`Date`>,1
+readr,n_problems,0,0,4,"class<`difftime`, `hms`>",1
+readr,n_problems,0,0,5,class<`factor`>,1
+readr,n_problems,0,0,6,"class<`POSIXct`, `POSIXt`>",1
+readr,n_problems,0,0,7,^double[],1
+readr,output_column,-1,0,0,character,1
+readr,output_column,0,0,0,"class<`POSIXct`, `POSIXt`>",1
+readr,output_column.default,-1,0,0,character[],1
+readr,output_column.default,0,0,0,class<`factor`>,1
+readr,output_column.double,-1,0,0,"class<`AccumulateCallback`, `ChunkCallback`, `R6`>",1
+readr,output_column.double,-1,0,1,"class<`ChunkCallback`, `DataFrameCallback`, `R6`>",1
+readr,output_column.double,-1,0,2,"class<`ChunkCallback`, `ListCallback`, `R6`>",1
+readr,output_column.double,-1,0,3,"class<`ChunkCallback`, `R6`, `SideEffectChunkCallback`>",1
+readr,output_column.double,-1,0,4,^double[],1
+readr,output_column.double,0,0,0,"class<`AccumulateCallback`, `ChunkCallback`, `R6`>",1
+readr,output_column.double,0,0,1,"class<`ChunkCallback`, `DataFrameCallback`, `R6`>",1
+readr,output_column.double,0,0,2,"class<`ChunkCallback`, `ListCallback`, `R6`>",1
+readr,output_column.double,0,0,3,"class<`ChunkCallback`, `R6`, `SideEffectChunkCallback`>",1
+readr,output_column.double,0,0,4,^double[],1
+readr,output_column.POSIXt,-1,0,0,character,1
+readr,output_column.POSIXt,0,0,0,"class<`POSIXct`, `POSIXt`>",1
+readr,parse_character,-1,0,0,character,1
+readr,parse_character,0,0,0,character,1
+readr,parse_character,1,0,0,character[],1
+readr,parse_character,2,0,0,class<`locale`>,1
+readr,parse_character,3,0,0,logical,1
+readr,parse_date,-1,0,0,class<`Date`>,1
+readr,parse_date,0,0,0,character,1
+readr,parse_date,1,0,0,character,1
+readr,parse_date,2,0,0,character[],1
+readr,parse_date,3,0,0,class<`locale`>,1
+readr,parse_date,4,0,0,logical,1
+readr,parse_datetime,-1,0,0,"class<`POSIXct`, `POSIXt`>",1
+readr,parse_datetime,0,0,0,character[],1
+readr,parse_datetime,1,0,0,character,1
+readr,parse_datetime,2,0,0,character[],1
+readr,parse_datetime,3,0,0,class<`locale`>,1
+readr,parse_datetime,4,0,0,logical,1
+readr,parse_double,-1,0,0,^double[],1
+readr,parse_double,0,0,0,character[],1
+readr,parse_double,1,0,0,character[],1
+readr,parse_double,2,0,0,class<`locale`>,1
+readr,parse_double,3,0,0,logical,1
+readr,parse_factor,-1,0,0,class<`factor`>,1
+readr,parse_factor,0,0,0,character[],1
+readr,parse_factor,1,0,0,character[],1
+readr,parse_factor,1,0,1,null,1
+readr,parse_factor,2,0,0,logical,1
+readr,parse_factor,3,0,0,character[],1
+readr,parse_factor,4,0,0,class<`locale`>,1
+readr,parse_factor,5,0,0,logical,1
+readr,parse_factor,6,0,0,logical,1
+readr,parse_guess,-1,0,0,character,1
+readr,parse_guess,-1,0,1,class<`Date`>,1
+readr,parse_guess,-1,0,2,double[],1
+readr,parse_guess,0,0,0,character[],1
+readr,parse_guess,1,0,0,character[],1
+readr,parse_guess,2,0,0,class<`locale`>,1
+readr,parse_guess,3,0,0,logical,1
+readr,parse_guess,4,0,0,logical,1
+readr,parse_integer,-1,0,0,^integer[],1
+readr,parse_integer,0,0,0,character[],1
+readr,parse_integer,1,0,0,character[],1
+readr,parse_integer,2,0,0,class<`locale`>,1
+readr,parse_integer,3,0,0,logical,1
+readr,parse_logical,-1,0,0,logical[],1
+readr,parse_logical,0,0,0,character[],1
+readr,parse_logical,1,0,0,character[],1
+readr,parse_logical,2,0,0,class<`locale`>,1
+readr,parse_logical,3,0,0,logical,1
+readr,parse_number,-1,0,0,double[],1
+readr,parse_number,0,0,0,character[],1
+readr,parse_number,1,0,0,character[],1
+readr,parse_number,2,0,0,class<`locale`>,1
+readr,parse_number,3,0,0,logical,1
+readr,parse_time,-1,0,0,"class<`difftime`, `hms`>",1
+readr,parse_time,0,0,0,character,1
+readr,parse_time,1,0,0,character,1
+readr,parse_time,2,0,0,character[],1
+readr,parse_time,3,0,0,class<`locale`>,1
+readr,parse_time,4,0,0,logical,1
+readr,parse_vector,-1,0,0,character,1
+readr,parse_vector,-1,0,1,class<`Date`>,1
+readr,parse_vector,-1,0,2,"class<`difftime`, `hms`>",1
+readr,parse_vector,-1,0,3,class<`factor`>,1
+readr,parse_vector,-1,0,4,"class<`POSIXct`, `POSIXt`>",1
+readr,parse_vector,-1,0,5,^double[],1
+readr,parse_vector,0,0,0,character[],1
+readr,parse_vector,1,0,0,character,1
+readr,parse_vector,1,0,1,"class<`collector`, `collector_character`>",1
+readr,parse_vector,1,0,2,"class<`collector`, `collector_date`>",1
+readr,parse_vector,1,0,3,"class<`collector`, `collector_time`>",1
+readr,parse_vector,1,0,4,"class<`collector`, `collector_factor`>",1
+readr,parse_vector,1,0,5,"class<`collector`, `collector_datetime`>",1
+readr,parse_vector,1,0,6,"class<`collector`, `collector_double`>",1
+readr,parse_vector,1,0,7,"class<`collector`, `collector_number`>",1
+readr,parse_vector,1,0,8,"class<`collector`, `collector_integer`>",1
+readr,parse_vector,1,0,9,"class<`collector`, `collector_logical`>",1
+readr,parse_vector,2,0,0,character[],1
+readr,parse_vector,3,0,0,class<`locale`>,1
+readr,parse_vector,4,0,0,logical,1
+readr,parse_vector_,-1,0,0,character,1
+readr,parse_vector_,-1,0,1,class<`Date`>,1
+readr,parse_vector_,-1,0,2,"class<`difftime`, `hms`>",1
+readr,parse_vector_,-1,0,3,class<`factor`>,1
+readr,parse_vector_,-1,0,4,"class<`POSIXct`, `POSIXt`>",1
+readr,parse_vector_,-1,0,5,^double[],1
+readr,parse_vector_,0,0,0,character[],1
+readr,parse_vector_,1,0,0,"class<`collector`, `collector_character`>",1
+readr,parse_vector_,1,0,1,"class<`collector`, `collector_date`>",1
+readr,parse_vector_,1,0,2,"class<`collector`, `collector_time`>",1
+readr,parse_vector_,1,0,3,"class<`collector`, `collector_factor`>",1
+readr,parse_vector_,1,0,4,"class<`collector`, `collector_datetime`>",1
+readr,parse_vector_,1,0,5,"class<`collector`, `collector_double`>",1
+readr,parse_vector_,1,0,6,"class<`collector`, `collector_number`>",1
+readr,parse_vector_,1,0,7,"class<`collector`, `collector_integer`>",1
+readr,parse_vector_,1,0,8,"class<`collector`, `collector_logical`>",1
+readr,parse_vector_,2,0,0,class<`locale`>,1
+readr,parse_vector_,3,0,0,character[],1
+readr,parse_vector_,4,0,0,logical,1
+readr,problems,-1,0,0,"class<`data.frame`, `tbl_df`>",1
+readr,problems,-1,0,1,"class<`data.frame`, `tbl`, `tbl_df`>",1
+readr,problems,0,0,0,"class<`data.frame`, `spec_tbl_df`, `tbl`, `tbl_df`>",1
+readr,problems,0,0,1,^integer[],1
+readr,probs,-1,0,0,"class<`data.frame`, `tbl`, `tbl_df`>",1
+readr,probs,-1,0,1,null,1
+readr,probs,0,0,0,"class<`data.frame`, `spec_tbl_df`, `tbl`, `tbl_df`>",1
+readr,probs,0,0,1,class<`factor`>,1
+readr,probs,0,0,2,"class<`POSIXct`, `POSIXt`>",1
+readr,probs,0,0,3,^double[],1
+readr,probs,0,0,4,character,1
+readr,probs,0,0,5,"class<`data.frame`, `tbl`, `tbl_df`>",1
+readr,probs,0,0,6,class<`Date`>,1
+readr,probs,0,0,7,"class<`difftime`, `hms`>",1
+readr,read_connection,-1,0,0,character,1
+readr,read_connection,0,0,0,"class<`bzfile`, `connection`>",1
+readr,read_connection,0,0,1,"class<`connection`, `rawConnection`>",1
+readr,read_connection,0,0,2,"class<`connection`, `unz`>",1
+readr,read_connection_,-1,0,0,character,1
+readr,read_connection_,0,0,0,"class<`bzfile`, `connection`>",1
+readr,read_connection_,0,0,1,"class<`connection`, `rawConnection`>",1
+readr,read_connection_,0,0,2,"class<`connection`, `unz`>",1
+readr,read_connection_,1,0,0,character,1
+readr,read_connection_,2,0,0,double,1
+readr,read_csv,-1,0,0,"class<`data.frame`, `spec_tbl_df`, `tbl`, `tbl_df`>",1
+readr,read_csv,0,0,0,character,1
+readr,read_csv,1,0,0,logical,1
+readr,read_csv,2,0,0,"list<class<`collector`, `collector_double`>>",1
+readr,read_csv,2,0,1,null,1
+readr,read_csv,2,0,2,character,1
+readr,read_csv,2,0,3,class<`col_spec`>,1
+readr,read_csv,2,0,4,"list<class<`collector`, `collector_double`> | class<`collector`, `collector_character`>>",1
+readr,read_csv,3,0,0,class<`locale`>,1
+readr,read_csv,4,0,0,character[],1
+readr,read_csv,5,0,0,logical,1
+readr,read_csv,6,0,0,character,1
+readr,read_csv,7,0,0,character,1
+readr,read_csv,8,0,0,logical,1
+readr,read_csv,9,0,0,double,1
+readr,read_csv,10,0,0,double,1
+readr,read_csv,11,0,0,any,1
+readr,read_csv,12,0,0,logical,1
+readr,read_csv,13,0,0,logical,1
+readr,read_csv2,-1,0,0,"class<`data.frame`, `spec_tbl_df`, `tbl`, `tbl_df`>",1
+readr,read_csv2,0,0,0,character,1
+readr,read_csv2,1,0,0,logical,1
+readr,read_csv2,2,0,0,null,1
+readr,read_csv2,3,0,0,class<`locale`>,1
+readr,read_csv2,4,0,0,character[],1
+readr,read_csv2,5,0,0,logical,1
+readr,read_csv2,6,0,0,character,1
+readr,read_csv2,7,0,0,character,1
+readr,read_csv2,8,0,0,logical,1
+readr,read_csv2,9,0,0,double,1
+readr,read_csv2,10,0,0,double,1
+readr,read_csv2,11,0,0,double,1
+readr,read_csv2,12,0,0,logical,1
+readr,read_csv2,13,0,0,logical,1
+readr,read_csv_chunked,-1,0,0,"class<`data.frame`, `tbl`, `tbl_df`>",1
+readr,read_csv_chunked,-1,0,1,double,1
+readr,read_csv_chunked,-1,0,2,list<double[]>,1
+readr,read_csv_chunked,0,0,0,character,1
+readr,read_csv_chunked,1,0,0,"class<`ChunkCallback`, `DataFrameCallback`, `R6`>",1
+readr,read_csv_chunked,1,0,1,"class<`AccumulateCallback`, `ChunkCallback`, `R6`>",1
+readr,read_csv_chunked,1,0,2,"class<`ChunkCallback`, `ListCallback`, `R6`>",1
+readr,read_csv_chunked,2,0,0,double,1
+readr,read_csv_chunked,3,0,0,logical,1
+readr,read_csv_chunked,4,0,0,null,1
+readr,read_csv_chunked,5,0,0,class<`locale`>,1
+readr,read_csv_chunked,6,0,0,character[],1
+readr,read_csv_chunked,7,0,0,logical,1
+readr,read_csv_chunked,8,0,0,character,1
+readr,read_csv_chunked,9,0,0,character,1
+readr,read_csv_chunked,10,0,0,logical,1
+readr,read_csv_chunked,11,0,0,double,1
+readr,read_csv_chunked,12,0,0,double,1
+readr,read_csv_chunked,13,0,0,logical,1
+readr,read_csv_chunked,14,0,0,logical,1
+readr,read_delim,-1,0,0,"class<`data.frame`, `spec_tbl_df`, `tbl`, `tbl_df`>",1
+readr,read_delim,0,0,0,character,1
+readr,read_delim,1,0,0,character,1
+readr,read_delim,2,0,0,character,1
+readr,read_delim,3,0,0,logical,1
+readr,read_delim,4,0,0,logical,1
+readr,read_delim,5,0,0,logical,1
+readr,read_delim,6,0,0,null,1
+readr,read_delim,7,0,0,class<`locale`>,1
+readr,read_delim,8,0,0,character[],1
+readr,read_delim,9,0,0,logical,1
+readr,read_delim,10,0,0,character,1
+readr,read_delim,11,0,0,logical,1
+readr,read_delim,12,0,0,double,1
+readr,read_delim,13,0,0,double,1
+readr,read_delim,14,0,0,double,1
+readr,read_delim,15,0,0,logical,1
+readr,read_delimited,-1,0,0,"class<`data.frame`, `spec_tbl_df`, `tbl`, `tbl_df`>",1
+readr,read_delimited,0,0,0,character,1
+readr,read_delimited,1,0,0,class<`tokenizer_delim`>,1
+readr,read_delimited,1,0,1,class<`tokenizer_log`>,1
+readr,read_delimited,2,0,0,logical,1
+readr,read_delimited,3,0,0,"list<class<`collector`, `collector_double`>>",1
+readr,read_delimited,3,0,1,null,1
+readr,read_delimited,3,0,2,character,1
+readr,read_delimited,3,0,3,class<`col_spec`>,1
+readr,read_delimited,3,0,4,"list<class<`collector`, `collector_double`> | class<`collector`, `collector_character`>>",1
+readr,read_delimited,4,0,0,class<`locale`>,1
+readr,read_delimited,5,0,0,double,1
+readr,read_delimited,6,0,0,logical,1
+readr,read_delimited,7,0,0,character,1
+readr,read_delimited,8,0,0,double,1
+readr,read_delimited,9,0,0,any,1
+readr,read_delimited,10,0,0,logical,1
+readr,read_delimited_chunked,-1,0,0,"class<`data.frame`, `tbl`, `tbl_df`>",1
+readr,read_delimited_chunked,-1,0,1,double,1
+readr,read_delimited_chunked,-1,0,2,list<double[]>,1
+readr,read_delimited_chunked,0,0,0,character,1
+readr,read_delimited_chunked,1,0,0,"class<`ChunkCallback`, `DataFrameCallback`, `R6`>",1
+readr,read_delimited_chunked,1,0,1,"class<`AccumulateCallback`, `ChunkCallback`, `R6`>",1
+readr,read_delimited_chunked,1,0,2,"class<`ChunkCallback`, `ListCallback`, `R6`>",1
+readr,read_delimited_chunked,2,0,0,double,1
+readr,read_delimited_chunked,3,0,0,class<`tokenizer_delim`>,1
+readr,read_delimited_chunked,4,0,0,logical,1
+readr,read_delimited_chunked,5,0,0,null,1
+readr,read_delimited_chunked,6,0,0,class<`locale`>,1
+readr,read_delimited_chunked,7,0,0,double,1
+readr,read_delimited_chunked,8,0,0,logical,1
+readr,read_delimited_chunked,9,0,0,character,1
+readr,read_delimited_chunked,10,0,0,double,1
+readr,read_delimited_chunked,11,0,0,logical,1
+readr,read_file,-1,0,0,character,1
+readr,read_file,0,0,0,character,1
+readr,read_file,1,0,0,class<`locale`>,1
+readr,read_file_,-1,0,0,character,1
+readr,read_file_,0,0,0,"class<`source`, `source_file`>",1
+readr,read_file_,1,0,0,class<`locale`>,1
+readr,read_file_raw,-1,0,0,raw[],1
+readr,read_file_raw,0,0,0,character,1
+readr,read_file_raw_,-1,0,0,raw[],1
+readr,read_file_raw_,0,0,0,"class<`source`, `source_file`>",1
+readr,read_fwf,-1,0,0,"class<`data.frame`, `spec_tbl_df`, `tbl`, `tbl_df`>",1
+readr,read_fwf,0,0,0,character,1
+readr,read_fwf,1,0,0,"class<`data.frame`, `tbl`, `tbl_df`>",1
+readr,read_fwf,1,0,1,list<^integer[] | character[]>,1
+readr,read_fwf,2,0,0,null,1
+readr,read_fwf,3,0,0,class<`locale`>,1
+readr,read_fwf,4,0,0,character[],1
+readr,read_fwf,5,0,0,character,1
+readr,read_fwf,6,0,0,logical,1
+readr,read_fwf,7,0,0,double,1
+readr,read_fwf,8,0,0,double,1
+readr,read_fwf,9,0,0,double,1
+readr,read_fwf,10,0,0,logical,1
+readr,read_fwf,11,0,0,logical,1
+readr,read_lines,-1,0,0,character[],1
+readr,read_lines,0,0,0,character,1
+readr,read_lines,1,0,0,double,1
+readr,read_lines,2,0,0,logical,1
+readr,read_lines,3,0,0,double,1
+readr,read_lines,4,0,0,class<`locale`>,1
+readr,read_lines,5,0,0,character[],1
+readr,read_lines,6,0,0,logical,1
+readr,read_lines_,-1,0,0,character[],1
+readr,read_lines_,0,0,0,"class<`source`, `source_file`>",1
+readr,read_lines_,0,0,1,"class<`source`, `source_string`>",1
+readr,read_lines_,1,0,0,class<`locale`>,1
+readr,read_lines_,2,0,0,character[],1
+readr,read_lines_,3,0,0,double,1
+readr,read_lines_,4,0,0,logical,1
+readr,read_lines_,5,0,0,logical,1
+readr,read_lines_chunked,-1,0,0,null,1
+readr,read_lines_chunked,0,0,0,character,1
+readr,read_lines_chunked,1,0,0,"class<`ChunkCallback`, `R6`, `SideEffectChunkCallback`>",1
+readr,read_lines_chunked,1,0,1,class<`function`>,1
+readr,read_lines_chunked,2,0,0,double,1
+readr,read_lines_chunked,3,0,0,double,1
+readr,read_lines_chunked,4,0,0,class<`locale`>,1
+readr,read_lines_chunked,5,0,0,character[],1
+readr,read_lines_chunked,6,0,0,logical,1
+readr,read_lines_chunked_,-1,0,0,null,1
+readr,read_lines_chunked_,0,0,0,"class<`source`, `source_file`>",1
+readr,read_lines_chunked_,1,0,0,class<`locale`>,1
+readr,read_lines_chunked_,2,0,0,character[],1
+readr,read_lines_chunked_,3,0,0,double,1
+readr,read_lines_chunked_,4,0,0,"class<`ChunkCallback`, `R6`, `SideEffectChunkCallback`>",1
+readr,read_lines_chunked_,5,0,0,logical,1
+readr,read_lines_chunked_,6,0,0,logical,1
+readr,read_lines_raw,-1,0,0,list<raw[]>,1
+readr,read_lines_raw,0,0,0,character,1
+readr,read_lines_raw,1,0,0,double,1
+readr,read_lines_raw,2,0,0,double,1
+readr,read_lines_raw,3,0,0,logical,1
+readr,read_lines_raw_,-1,0,0,list<raw[]>,1
+readr,read_lines_raw_,0,0,0,"class<`source`, `source_string`>",1
+readr,read_lines_raw_,0,0,1,"class<`source`, `source_file`>",1
+readr,read_lines_raw_,1,0,0,double,1
+readr,read_lines_raw_,2,0,0,logical,1
+readr,read_log,-1,0,0,"class<`data.frame`, `spec_tbl_df`, `tbl`, `tbl_df`>",1
+readr,read_log,0,0,0,character,1
+readr,read_log,1,0,0,logical,1
+readr,read_log,2,0,0,null,1
+readr,read_log,3,0,0,double,1
+readr,read_log,4,0,0,double,1
+readr,read_log,5,0,0,logical,1
+readr,read_rds,-1,0,0,class<`data.frame`>,1
+readr,read_rds,0,0,0,character,1
+readr,readr_example,-1,0,0,character[],1
+readr,readr_example,0,0,0,null,1
+readr,readr_example,0,0,1,character,1
+readr,read_table,-1,0,0,"class<`data.frame`, `spec_tbl_df`, `tbl`, `tbl_df`>",1
+readr,read_table,0,0,0,character,1
+readr,read_table,1,0,0,logical,1
+readr,read_table,2,0,0,null,1
+readr,read_table,3,0,0,class<`locale`>,1
+readr,read_table,4,0,0,character,1
+readr,read_table,5,0,0,double,1
+readr,read_table,6,0,0,double,1
+readr,read_table,7,0,0,double,1
+readr,read_table,8,0,0,logical,1
+readr,read_table,9,0,0,character,1
+readr,read_table,10,0,0,logical,1
+readr,read_tokens,-1,0,0,"class<`data.frame`, `spec_tbl_df`, `tbl`, `tbl_df`>",1
+readr,read_tokens,0,0,0,"class<`source`, `source_file`>",1
+readr,read_tokens,0,0,1,"class<`source`, `source_string`>",1
+readr,read_tokens,1,0,0,class<`tokenizer_delim`>,1
+readr,read_tokens,1,0,1,class<`tokenizer_fwf`>,1
+readr,read_tokens,1,0,2,class<`tokenizer_log`>,1
+readr,read_tokens,2,0,0,"list<class<`collector`, `collector_character`>>",1
+readr,read_tokens,2,0,1,"list<class<`collector`, `collector_double`>>",1
+readr,read_tokens,2,0,2,"list<class<`collector`, `collector_double`> | class<`collector`, `collector_date`>>",1
+readr,read_tokens,2,0,3,"list<class<`collector`, `collector_double`> | class<`collector`, `collector_logical`>>",1
+readr,read_tokens,2,0,4,"list<class<`collector`, `collector_double`> | class<`collector`, `collector_character`>>",1
+readr,read_tokens,2,0,5,"list<class<`collector`, `collector_character`> | class<`collector`, `collector_double`>>",1
+readr,read_tokens,2,0,6,"list<class<`collector`, `collector_character`> | class<`collector`, `collector_logical`> | class<`collector`, `collector_double`>>",1
+readr,read_tokens,3,0,0,character[],1
+readr,read_tokens,4,0,0,class<`locale`>,1
+readr,read_tokens,5,0,0,double,1
+readr,read_tokens,6,0,0,logical,1
+readr,read_tokens_,-1,0,0,"class<`data.frame`, `spec_tbl_df`, `tbl`, `tbl_df`>",1
+readr,read_tokens_,0,0,0,"class<`source`, `source_file`>",1
+readr,read_tokens_,0,0,1,"class<`source`, `source_string`>",1
+readr,read_tokens_,1,0,0,class<`tokenizer_delim`>,1
+readr,read_tokens_,1,0,1,class<`tokenizer_fwf`>,1
+readr,read_tokens_,1,0,2,class<`tokenizer_log`>,1
+readr,read_tokens_,2,0,0,"list<class<`collector`, `collector_character`>>",1
+readr,read_tokens_,2,0,1,"list<class<`collector`, `collector_double`>>",1
+readr,read_tokens_,2,0,2,"list<class<`collector`, `collector_double`> | class<`collector`, `collector_date`>>",1
+readr,read_tokens_,2,0,3,"list<class<`collector`, `collector_double`> | class<`collector`, `collector_logical`>>",1
+readr,read_tokens_,2,0,4,"list<class<`collector`, `collector_double`> | class<`collector`, `collector_character`>>",1
+readr,read_tokens_,2,0,5,"list<class<`collector`, `collector_character`> | class<`collector`, `collector_double`>>",1
+readr,read_tokens_,2,0,6,"list<class<`collector`, `collector_character`> | class<`collector`, `collector_logical`> | class<`collector`, `collector_double`>>",1
+readr,read_tokens_,3,0,0,character[],1
+readr,read_tokens_,4,0,0,class<`locale`>,1
+readr,read_tokens_,5,0,0,double,1
+readr,read_tokens_,6,0,0,logical,1
+readr,read_tokens_chunked,-1,0,0,"class<`data.frame`, `tbl`, `tbl_df`>",1
+readr,read_tokens_chunked,-1,0,1,double,1
+readr,read_tokens_chunked,-1,0,2,list<double[]>,1
+readr,read_tokens_chunked,0,0,0,"class<`source`, `source_file`>",1
+readr,read_tokens_chunked,1,0,0,"class<`ChunkCallback`, `DataFrameCallback`, `R6`>",1
+readr,read_tokens_chunked,1,0,1,"class<`AccumulateCallback`, `ChunkCallback`, `R6`>",1
+readr,read_tokens_chunked,1,0,2,"class<`ChunkCallback`, `ListCallback`, `R6`>",1
+readr,read_tokens_chunked,2,0,0,double,1
+readr,read_tokens_chunked,3,0,0,class<`tokenizer_delim`>,1
+readr,read_tokens_chunked,4,0,0,"list<class<`collector`, `collector_double`>>",1
+readr,read_tokens_chunked,5,0,0,character[],1
+readr,read_tokens_chunked,6,0,0,class<`locale`>,1
+readr,read_tokens_chunked,7,0,0,logical,1
+readr,read_tokens_chunked_,-1,0,0,null,1
+readr,read_tokens_chunked_,0,0,0,"class<`source`, `source_file`>",1
+readr,read_tokens_chunked_,1,0,0,"class<`AccumulateCallback`, `ChunkCallback`, `R6`>",1
+readr,read_tokens_chunked_,1,0,1,"class<`ChunkCallback`, `DataFrameCallback`, `R6`>",1
+readr,read_tokens_chunked_,1,0,2,"class<`ChunkCallback`, `ListCallback`, `R6`>",1
+readr,read_tokens_chunked_,2,0,0,double,1
+readr,read_tokens_chunked_,3,0,0,class<`tokenizer_delim`>,1
+readr,read_tokens_chunked_,4,0,0,"list<class<`collector`, `collector_double`>>",1
+readr,read_tokens_chunked_,5,0,0,character[],1
+readr,read_tokens_chunked_,6,0,0,class<`locale`>,1
+readr,read_tokens_chunked_,7,0,0,logical,1
+readr,read_tsv,-1,0,0,"class<`data.frame`, `spec_tbl_df`, `tbl`, `tbl_df`>",1
+readr,read_tsv,0,0,0,character,1
+readr,read_tsv,1,0,0,logical,1
+readr,read_tsv,2,0,0,null,1
+readr,read_tsv,3,0,0,class<`locale`>,1
+readr,read_tsv,4,0,0,character[],1
+readr,read_tsv,5,0,0,logical,1
+readr,read_tsv,6,0,0,character,1
+readr,read_tsv,7,0,0,character,1
+readr,read_tsv,8,0,0,logical,1
+readr,read_tsv,9,0,0,double,1
+readr,read_tsv,10,0,0,double,1
+readr,read_tsv,11,0,0,double,1
+readr,read_tsv,12,0,0,logical,1
+readr,read_tsv,13,0,0,logical,1
+readr,register_s3_method,-1,0,0,null,1
+readr,register_s3_method,0,0,0,character,1
+readr,register_s3_method,1,0,0,character,1
+readr,register_s3_method,2,0,0,character,1
+readr,register_s3_method,3,0,0,null,1
+readr,show_cols_spec,-1,0,0,null,1
+readr,show_cols_spec,0,0,0,class<`col_spec`>,1
+readr,show_cols_spec,1,0,0,double,1
+readr,show_progress,-1,0,0,logical,1
+readr,source_name,-1,0,0,character,1
+readr,source_name,0,0,0,character,1
+readr,spec,-1,0,0,class<`col_spec`>,1
+readr,spec,0,0,0,"class<`data.frame`, `spec_tbl_df`, `tbl`, `tbl_df`>",1
+readr,spec_csv,-1,0,0,class<`col_spec`>,1
+readr,spec_csv,0,0,0,character,1
+readr,spec_csv,1,0,0,logical,1
+readr,spec_csv,2,0,0,null,1
+readr,spec_csv,3,0,0,class<`locale`>,1
+readr,spec_csv,4,0,0,character[],1
+readr,spec_csv,5,0,0,logical,1
+readr,spec_csv,6,0,0,character,1
+readr,spec_csv,7,0,0,character,1
+readr,spec_csv,8,0,0,logical,1
+readr,spec_csv,9,0,0,double,1
+readr,spec_csv,10,0,0,double,1
+readr,spec_csv,11,0,0,double,1
+readr,spec_csv,12,0,0,logical,1
+readr,spec_csv,13,0,0,logical,1
+readr,[.spec_tbl_df,-1,0,0,"class<`data.frame`, `tbl`, `tbl_df`>",1
+readr,[.spec_tbl_df,0,0,0,"class<`data.frame`, `spec_tbl_df`, `tbl`, `tbl_df`>",1
+readr,[.spec_tbl_df,1,0,0,...,1
+readr,standardise_escape,-1,0,0,integer,1
+readr,standardise_escape,0,0,0,character,1
+readr,standardise_path,-1,0,0,character,1
+readr,standardise_path,-1,0,1,"class<`bzfile`, `connection`>",1
+readr,standardise_path,-1,0,2,"class<`connection`, `file`>",1
+readr,standardise_path,-1,0,3,"class<`connection`, `gzfile`>",1
+readr,standardise_path,-1,0,4,"class<`connection`, `unz`>",1
+readr,standardise_path,-1,0,5,"class<`connection`, `xzfile`>",1
+readr,standardise_path,-1,0,6,null,1
+readr,standardise_path,0,0,0,character,1
+readr,standardise_path,0,0,1,null,1
+readr,standardise_path,1,0,0,logical,1
+readr,str.col_spec,-1,0,0,null,1
+readr,str.col_spec,0,0,0,class<`col_spec`>,1
+readr,str.col_spec,1,0,0,...,1
+readr,str.col_spec,2,0,0,character,1
+readr,stream_delim,-1,0,0,character,1
+readr,stream_delim,0,0,0,class<`data.frame`>,1
+readr,stream_delim,1,0,0,character,1
+readr,stream_delim,1,0,1,null,1
+readr,stream_delim,2,0,0,any,1
+readr,stream_delim,3,0,0,logical,1
+readr,stream_delim,4,0,0,...,1
+readr,stream_delim,5,0,0,character,1
+readr,stream_delim_,-1,0,0,character,1
+readr,stream_delim_,0,0,0,class<`data.frame`>,1
+readr,stream_delim_,1,0,0,"class<`bzfile`, `connection`>",1
+readr,stream_delim_,1,0,1,"class<`connection`, `file`>",1
+readr,stream_delim_,1,0,2,"class<`connection`, `gzfile`>",1
+readr,stream_delim_,1,0,3,"class<`connection`, `xzfile`>",1
+readr,stream_delim_,1,0,4,null,1
+readr,stream_delim_,2,0,0,character,1
+readr,stream_delim_,3,0,0,character,1
+readr,stream_delim_,4,0,0,logical,1
+readr,stream_delim_,5,0,0,logical,1
+readr,stream_delim_,6,0,0,integer,1
+readr,tokenize,-1,0,0,list<character[]>,1
+readr,tokenize,0,0,0,character,1
+readr,tokenize,1,0,0,class<`tokenizer_delim`>,1
+readr,tokenize,2,0,0,double,1
+readr,tokenize,3,0,0,double,1
+readr,tokenize_,-1,0,0,list<character[]>,1
+readr,tokenize_,0,0,0,"class<`source`, `source_string`>",1
+readr,tokenize_,1,0,0,class<`tokenizer_delim`>,1
+readr,tokenize_,2,0,0,double,1
+readr,tokenizer_csv,-1,0,0,class<`tokenizer_delim`>,1
+readr,tokenizer_csv,0,0,0,character[],1
+readr,tokenizer_csv,1,0,0,logical,1
+readr,tokenizer_csv,2,0,0,character,1
+readr,tokenizer_csv,3,0,0,character,1
+readr,tokenizer_csv,4,0,0,logical,1
+readr,tokenizer_csv,5,0,0,logical,1
+readr,tokenizer_delim,-1,0,0,class<`tokenizer_delim`>,1
+readr,tokenizer_delim,0,0,0,character,1
+readr,tokenizer_delim,1,0,0,character,1
+readr,tokenizer_delim,2,0,0,character[],1
+readr,tokenizer_delim,3,0,0,logical,1
+readr,tokenizer_delim,4,0,0,character,1
+readr,tokenizer_delim,5,0,0,logical,1
+readr,tokenizer_delim,6,0,0,logical,1
+readr,tokenizer_delim,7,0,0,logical,1
+readr,tokenizer_delim,8,0,0,logical,1
+readr,tokenizer_fwf,-1,0,0,class<`tokenizer_fwf`>,1
+readr,tokenizer_fwf,0,0,0,double[],1
+readr,tokenizer_fwf,1,0,0,double[],1
+readr,tokenizer_fwf,1,0,1,^integer[],1
+readr,tokenizer_fwf,2,0,0,character[],1
+readr,tokenizer_fwf,3,0,0,character,1
+readr,tokenizer_fwf,4,0,0,logical,1
+readr,tokenizer_fwf,5,0,0,logical,1
+readr,tokenizer_log,-1,0,0,class<`tokenizer_log`>,1
+readr,tokenizer_tsv,-1,0,0,class<`tokenizer_delim`>,1
+readr,tokenizer_tsv,0,0,0,character[],1
+readr,tokenizer_tsv,1,0,0,logical,1
+readr,tokenizer_tsv,2,0,0,character,1
+readr,tokenizer_tsv,3,0,0,character,1
+readr,tokenizer_tsv,4,0,0,logical,1
+readr,tokenizer_tsv,5,0,0,logical,1
+readr,type_convert,-1,0,0,class<`data.frame`>,1
+readr,type_convert,-1,0,1,"class<`data.frame`, `spec_tbl_df`, `tbl`, `tbl_df`>",1
+readr,type_convert,0,0,0,class<`data.frame`>,1
+readr,type_convert,0,0,1,"class<`data.frame`, `spec_tbl_df`, `tbl`, `tbl_df`>",1
+readr,type_convert,1,0,0,null,1
+readr,type_convert,2,0,0,character[],1
+readr,type_convert,3,0,0,logical,1
+readr,type_convert,4,0,0,class<`locale`>,1
+readr,type_convert_col,-1,0,0,^double[],1
+readr,type_convert_col,0,0,0,character[],1
+readr,type_convert_col,1,0,0,"class<`collector`, `collector_double`>",1
+readr,type_convert_col,2,0,0,class<`locale`>,1
+readr,type_convert_col,3,0,0,integer,1
+readr,type_convert_col,4,0,0,character[],1
+readr,type_convert_col,5,0,0,logical,1
+readr,warn_problems,-1,0,0,character,1
+readr,warn_problems,-1,0,1,"class<`data.frame`, `spec_tbl_df`, `tbl`, `tbl_df`>",1
+readr,warn_problems,-1,0,2,"class<`data.frame`, `tbl`, `tbl_df`>",1
+readr,warn_problems,-1,0,3,class<`Date`>,1
+readr,warn_problems,-1,0,4,"class<`difftime`, `hms`>",1
+readr,warn_problems,-1,0,5,class<`factor`>,1
+readr,warn_problems,-1,0,6,"class<`POSIXct`, `POSIXt`>",1
+readr,warn_problems,-1,0,7,^double[],1
+readr,warn_problems,0,0,0,character,1
+readr,warn_problems,0,0,1,"class<`data.frame`, `spec_tbl_df`, `tbl`, `tbl_df`>",1
+readr,warn_problems,0,0,2,"class<`data.frame`, `tbl`, `tbl_df`>",1
+readr,warn_problems,0,0,3,class<`Date`>,1
+readr,warn_problems,0,0,4,"class<`difftime`, `hms`>",1
+readr,warn_problems,0,0,5,class<`factor`>,1
+readr,warn_problems,0,0,6,"class<`POSIXct`, `POSIXt`>",1
+readr,warn_problems,0,0,7,^double[],1
+readr,whitespaceColumns,-1,0,0,list<integer[]>,1
+readr,whitespaceColumns,0,0,0,"class<`source`, `source_file`>",1
+readr,whitespaceColumns,1,0,0,double,1
+readr,whitespaceColumns,2,0,0,character,1
+readr,write_csv,-1,0,0,class<`data.frame`>,1
+readr,write_csv,0,0,0,class<`data.frame`>,1
+readr,write_csv,1,0,0,character,1
+readr,write_csv,2,0,0,character,1
+readr,write_csv,3,0,0,logical,1
+readr,write_csv,4,0,0,logical,1
+readr,write_csv,5,0,0,character,1
+readr,write_delim,-1,0,0,class<`data.frame`>,1
+readr,write_delim,0,0,0,class<`data.frame`>,1
+readr,write_delim,1,0,0,character,1
+readr,write_delim,2,0,0,character,1
+readr,write_delim,3,0,0,character,1
+readr,write_delim,4,0,0,logical,1
+readr,write_delim,5,0,0,logical,1
+readr,write_delim,6,0,0,character,1
+readr,write_file,-1,0,0,character,1
+readr,write_file,0,0,0,character,1
+readr,write_file,1,0,0,character,1
+readr,write_file,2,0,0,logical,1
+readr,write_file_,-1,0,0,null,1
+readr,write_file_,0,0,0,character,1
+readr,write_file_,1,0,0,"class<`connection`, `file`>",1
+readr,write_lines,-1,0,0,^character[],1
+readr,write_lines,0,0,0,^integer[],1
+readr,write_lines,0,0,1,character[],1
+readr,write_lines,1,0,0,character,1
+readr,write_lines,2,0,0,character,1
+readr,write_lines,3,0,0,character,1
+readr,write_lines,4,0,0,logical,1
+readr,write_lines_,-1,0,0,null,1
+readr,write_lines_,0,0,0,^character[],1
+readr,write_lines_,1,0,0,"class<`connection`, `file`>",1
+readr,write_lines_,2,0,0,character,1
+readr,write_lines_,3,0,0,character,1
+readr,write_rds,-1,0,0,class<`data.frame`>,1
+readr,write_rds,0,0,0,class<`data.frame`>,1
+readr,write_rds,1,0,0,character,1
+readr,write_rds,2,0,0,character[],1
+readr,write_rds,3,0,0,...,1
+readr,write_tsv,-1,0,0,class<`data.frame`>,1
+readr,write_tsv,0,0,0,class<`data.frame`>,1
+readr,write_tsv,1,0,0,character,1
+readr,write_tsv,2,0,0,character,1
+readr,write_tsv,3,0,0,logical,1
+readr,write_tsv,4,0,0,logical,1
+readr,write_tsv,5,0,0,character,1
+readr,zipfile,-1,0,0,"class<`connection`, `unz`>",1
+readr,zipfile,0,0,0,character,1
+readr,zipfile,1,0,0,character,1
+readxl,check_bool,-1,0,0,logical,1
+readxl,check_bool,0,0,0,logical,1
+readxl,check_bool,1,0,0,character,1
+readxl,check_col_types,-1,0,0,character[],1
+readxl,check_col_types,0,0,0,character[],1
+readxl,check_col_types,0,0,1,null,1
+readxl,check_file,-1,0,0,character,1
+readxl,check_file,0,0,0,character,1
+readxl,check_format,-1,0,0,character,1
+readxl,check_format,0,0,0,character,1
+readxl,check_guess_max,-1,0,0,double,1
+readxl,check_guess_max,0,0,0,double,1
+readxl,check_guess_max,1,0,0,double,1
+readxl,check_non_negative_integer,-1,0,0,double,1
+readxl,check_non_negative_integer,0,0,0,double,1
+readxl,check_non_negative_integer,1,0,0,character,1
+readxl,excel_format,-1,0,0,^character[],1
+readxl,excel_format,0,0,0,character[],1
+readxl,excel_format,1,0,0,logical,1
+readxl,excel_sheets,-1,0,0,character[],1
+readxl,excel_sheets,0,0,0,character,1
+readxl,format_from_ext,-1,0,0,^character[],1
+readxl,format_from_ext,0,0,0,character[],1
+readxl,format_from_signature,-1,0,0,character[],1
+readxl,format_from_signature,-1,0,1,null,1
+readxl,format_from_signature,0,0,0,character[],1
+readxl,is_integerish,-1,0,0,logical,1
+readxl,is_integerish,0,0,0,double,1
+readxl,is_string,-1,0,0,logical,1
+readxl,is_string,0,0,0,character,1
+readxl,read_excel,-1,0,0,"class<`data.frame`, `tbl`, `tbl_df`>",1
+readxl,read_excel,0,0,0,character,1
+readxl,read_excel,1,0,0,character,1
+readxl,read_excel,1,0,1,double,1
+readxl,read_excel,1,0,2,null,1
+readxl,read_excel,2,0,0,null,1
+readxl,read_excel,2,0,1,character,1
+readxl,read_excel,2,0,2,"class<`cell_limits`, `list`>",1
+readxl,read_excel,3,0,0,logical,1
+readxl,read_excel,4,0,0,character[],1
+readxl,read_excel,4,0,1,null,1
+readxl,read_excel,5,0,0,character,1
+readxl,read_excel,6,0,0,logical,1
+readxl,read_excel,7,0,0,double,1
+readxl,read_excel,8,0,0,double,1
+readxl,read_excel,9,0,0,double,1
+readxl,read_excel,10,0,0,logical,1
+readxl,read_excel,11,0,0,character,1
+readxl,read_excel,11,0,1,class<`formula`>,1
+readxl,read_excel,11,0,2,class<`function`>,1
+readxl,read_excel_,-1,0,0,"class<`data.frame`, `tbl`, `tbl_df`>",1
+readxl,read_excel_,0,0,0,character,1
+readxl,read_excel_,1,0,0,character,1
+readxl,read_excel_,1,0,1,double,1
+readxl,read_excel_,1,0,2,null,1
+readxl,read_excel_,2,0,0,null,1
+readxl,read_excel_,2,0,1,character,1
+readxl,read_excel_,2,0,2,"class<`cell_limits`, `list`>",1
+readxl,read_excel_,3,0,0,logical,1
+readxl,read_excel_,4,0,0,character[],1
+readxl,read_excel_,4,0,1,null,1
+readxl,read_excel_,5,0,0,character,1
+readxl,read_excel_,6,0,0,logical,1
+readxl,read_excel_,7,0,0,any,1
+readxl,read_excel_,8,0,0,any,1
+readxl,read_excel_,9,0,0,double,1
+readxl,read_excel_,10,0,0,logical,1
+readxl,read_excel_,11,0,0,character,1
+readxl,read_excel_,11,0,1,class<`formula`>,1
+readxl,read_excel_,11,0,2,class<`function`>,1
+readxl,read_excel_,12,0,0,character,1
+readxl,readxl_example,-1,0,0,character[],1
+readxl,readxl_example,0,0,0,null,1
+readxl,readxl_example,0,0,1,character,1
+readxl,readxl_progress,-1,0,0,logical,1
+readxl,set_readxl_names,-1,0,0,"class<`data.frame`, `tbl`, `tbl_df`>",1
+readxl,set_readxl_names,0,0,0,list<^character[] | ^logical[]>,1
+readxl,set_readxl_names,0,0,1,list<double[]>,1
+readxl,set_readxl_names,0,0,2,list<double[] | character[]>,1
+readxl,set_readxl_names,0,0,3,list<^character[]>,1
+readxl,set_readxl_names,0,0,4,list<^logical[] | character[]>,1
+readxl,set_readxl_names,0,0,5,list<character[] | double[]>,1
+readxl,set_readxl_names,0,0,6,"list<character[] | double[] | class<`POSIXct`, `POSIXt`>>",1
+readxl,set_readxl_names,0,0,7,"list<character[] | list<character | class<`POSIXct`, `POSIXt`> | double>>",1
+readxl,set_readxl_names,0,0,8,list<null | character>,1
+readxl,set_readxl_names,0,0,9,list<double | character>,1
+readxl,set_readxl_names,1,0,0,character,1
+readxl,set_readxl_names,1,0,1,class<`function`>,1
+readxl,set_readxl_names,1,0,2,class<`formula`>,1
+readxl,standardise_limits,-1,0,0,double[],1
+readxl,standardise_limits,0,0,0,character,1
+readxl,standardise_limits,0,0,1,"class<`cell_limits`, `list`>",1
+readxl,standardise_limits,0,0,2,null,1
+readxl,standardise_limits,1,0,0,any,1
+readxl,standardise_limits,2,0,0,any,1
+readxl,standardise_limits,3,0,0,any,1
+readxl,standardise_sheet,-1,0,0,double,1
+readxl,standardise_sheet,0,0,0,double,1
+readxl,standardise_sheet,0,0,1,null,1
+readxl,standardise_sheet,0,0,2,character,1
+readxl,standardise_sheet,1,0,0,null,1
+readxl,standardise_sheet,1,0,1,character,1
+readxl,standardise_sheet,1,0,2,"class<`cell_limits`, `list`>",1
+readxl,standardise_sheet,2,0,0,any,1
+readxl,xls_sheets,-1,0,0,character[],1
+readxl,xls_sheets,0,0,0,character,1
+readxl,xlsx_sheets,-1,0,0,character[],1
+readxl,xlsx_sheets,0,0,0,character,1
+rematch2,re_exec,-1,0,0,"class<`data.frame`, `tbl`, `tbl_df`>",1
+rematch2,re_exec,0,0,0,character[],1
+rematch2,re_exec,1,0,0,character,1
+rematch2,re_exec,2,0,0,logical,1
+rematch2,re_exec,3,0,0,...,1
+rematch2,re_exec_all,-1,0,0,"class<`data.frame`, `tbl`, `tbl_df`>",1
+rematch2,re_exec_all,0,0,0,character[],1
+rematch2,re_exec_all,1,0,0,character,1
+rematch2,re_exec_all,2,0,0,logical,1
+rematch2,re_exec_all,3,0,0,...,1
+rematch2,re_match,-1,0,0,"class<`data.frame`, `tbl`, `tbl_df`>",1
+rematch2,re_match,0,0,0,character[],1
+rematch2,re_match,1,0,0,character,1
+rematch2,re_match,2,0,0,logical,1
+rematch2,re_match,3,0,0,...,1
+rematch2,re_match_all,-1,0,0,"class<`data.frame`, `tbl`, `tbl_df`>",1
+rematch2,re_match_all,0,0,0,character[],1
+rematch2,re_match_all,1,0,0,character,1
+rematch2,re_match_all,2,0,0,logical,1
+rematch2,re_match_all,3,0,0,...,1
+rematch2,$.rematch_allrecords,-1,0,0,list<character[]>,1
+rematch2,$.rematch_allrecords,-1,0,1,list<integer[]>,1
+rematch2,$.rematch_allrecords,0,0,0,class<`rematch_allrecords`>,1
+rematch2,$.rematch_allrecords,1,0,0,character,1
+rematch2,$.rematch_records,-1,0,0,character[],1
+rematch2,$.rematch_records,-1,0,1,integer[],1
+rematch2,$.rematch_records,0,0,0,class<`rematch_records`>,1
+rematch2,$.rematch_records,1,0,0,character,1
+rentrez,as.data.frame.eInfoList,-1,0,0,class<`data.frame`>,1
+rentrez,as.data.frame.eInfoList,0,0,0,"class<`eInfoLink`, `eInfoList`, `list`>",1
+rentrez,as.data.frame.eInfoList,1,0,0,...,1
+rentrez,check_xml_errors,-1,0,0,null,1
+rentrez,check_xml_errors,0,0,0,"class<`XMLAbstractDocument`, `XMLInternalDocument`>",1
+rentrez,entrez_check,-1,0,0,any,1
+rentrez,entrez_check,0,0,0,class<`response`>,1
+rentrez,entrez_citmatch,-1,0,0,character[],1
+rentrez,entrez_citmatch,0,0,0,character[],1
+rentrez,entrez_citmatch,1,0,0,character,1
+rentrez,entrez_citmatch,2,0,0,character,1
+rentrez,entrez_citmatch,3,0,0,null,1
+rentrez,entrez_db_links,-1,0,0,"class<`eInfoLink`, `eInfoList`, `list`>",1
+rentrez,entrez_db_links,0,0,0,character,1
+rentrez,entrez_db_links,1,0,0,null,1
+rentrez,entrez_dbs,-1,0,0,any,1
+rentrez,entrez_dbs,0,0,0,null,1
+rentrez,entrez_db_searchable,-1,0,0,"class<`eInfoList`, `eInfoSearch`, `list`>",1
+rentrez,entrez_db_searchable,0,0,0,character,1
+rentrez,entrez_db_searchable,1,0,0,null,1
+rentrez,entrez_db_summary,-1,0,0,"class<`character`, `eInfoEntry`>",1
+rentrez,entrez_db_summary,0,0,0,character,1
+rentrez,entrez_db_summary,1,0,0,null,1
+rentrez,entrez_email,-1,0,0,character,1
+rentrez,entrez_global_query,-1,0,0,^double[],1
+rentrez,entrez_global_query,0,0,0,character,1
+rentrez,entrez_global_query,1,0,0,null,1
+rentrez,entrez_global_query,2,0,0,...,1
+rentrez,entrez_info,-1,0,0,any,1
+rentrez,entrez_info,0,0,0,character,1
+rentrez,entrez_info,0,0,1,null,1
+rentrez,entrez_info,1,0,0,null,1
+rentrez,entrez_link,-1,0,0,any,1
+rentrez,entrez_link,0,0,0,character,1
+rentrez,entrez_link,1,0,0,null,1
+rentrez,entrez_link,2,0,0,character,1
+rentrez,entrez_link,3,0,0,character,1
+rentrez,entrez_link,4,0,0,character,1
+rentrez,entrez_link,5,0,0,logical,1
+rentrez,entrez_link,6,0,0,null,1
+rentrez,entrez_link,7,0,0,...,1
+rentrez,entrez_search,-1,0,0,any,1
+rentrez,entrez_search,0,0,0,character,1
+rentrez,entrez_search,1,0,0,character,1
+rentrez,entrez_search,2,0,0,null,1
+rentrez,entrez_search,3,0,0,character,1
+rentrez,entrez_search,4,0,0,logical,1
+rentrez,entrez_search,5,0,0,...,1
+rentrez,entrez_summary,-1,0,0,"class<`esummary_list`, `list`>",1
+rentrez,entrez_summary,0,0,0,character,1
+rentrez,entrez_summary,1,0,0,character[],1
+rentrez,entrez_summary,2,0,0,null,1
+rentrez,entrez_summary,3,0,0,character[],1
+rentrez,entrez_summary,4,0,0,logical,1
+rentrez,entrez_summary,5,0,0,null,1
+rentrez,entrez_summary,6,0,0,null,1
+rentrez,entrez_summary,7,0,0,...,1
+rentrez,entrez_tool,-1,0,0,character,1
+rentrez,extract_from_esummary,-1,0,0,character[],1
+rentrez,extract_from_esummary,-1,0,1,class<`matrix`>,1
+rentrez,extract_from_esummary,-1,0,2,list<list<character>>,1
+rentrez,extract_from_esummary,0,0,0,"class<`esummary_list`, `list`>",1
+rentrez,extract_from_esummary,1,0,0,character,1
+rentrez,extract_from_esummary,2,0,0,logical,1
+rentrez,extract_from_esummary.esummary_list,-1,0,0,character[],1
+rentrez,extract_from_esummary.esummary_list,-1,0,1,class<`matrix`>,1
+rentrez,extract_from_esummary.esummary_list,-1,0,2,list<list<character>>,1
+rentrez,extract_from_esummary.esummary_list,0,0,0,"class<`esummary_list`, `list`>",1
+rentrez,extract_from_esummary.esummary_list,1,0,0,character,1
+rentrez,extract_from_esummary.esummary_list,2,0,0,logical,1
+rentrez,id_or_webenv,-1,0,0,list<character[]>,1
+rentrez,is_entrez_key_set,-1,0,0,logical,1
+rentrez,.last,-1,0,0,character,1
+rentrez,.last,0,0,0,character,1
+rentrez,linkout_urls,-1,0,0,list<character[]>,1
+rentrez,linkout_urls,0,0,0,"class<`elink`, `list`>",1
+rentrez,make_elink_fxn,-1,0,0,class<`function`>,1
+rentrez,make_elink_fxn,0,0,0,character,1
+rentrez,make_entrez_query,-1,0,0,any,1
+rentrez,make_entrez_query,0,0,0,character,1
+rentrez,make_entrez_query,1,0,0,null,1
+rentrez,make_entrez_query,2,0,0,character,1
+rentrez,make_entrez_query,3,0,0,logical,1
+rentrez,make_entrez_query,4,0,0,logical,1
+rentrez,make_entrez_query,5,0,0,...,1
+rentrez,parse_elink,-1,0,0,"class<`elink`, `list`>",1
+rentrez,parse_elink,0,0,0,"class<`XMLAbstractDocument`, `XMLInternalDocument`>",1
+rentrez,parse_elink,1,0,0,character,1
+rentrez,parse_elink,2,0,0,any,1
+rentrez,parse_elink,3,0,0,any,1
+rentrez,parse_esearch,-1,0,0,"class<`esearch`, `list`>",1
+rentrez,parse_esearch,0,0,0,"class<`XMLAbstractDocument`, `XMLInternalDocument`>",1
+rentrez,parse_esearch,1,0,0,logical,1
+rentrez,parse_esearch.XMLInternalDocument,-1,0,0,"class<`esearch`, `list`>",1
+rentrez,parse_esearch.XMLInternalDocument,0,0,0,"class<`XMLAbstractDocument`, `XMLInternalDocument`>",1
+rentrez,parse_esearch.XMLInternalDocument,1,0,0,logical,1
+rentrez,parse_esummary,-1,0,0,"class<`esummary_list`, `list`>",1
+rentrez,parse_esummary,0,0,0,list<list<character | character[] | list<any>>>,1
+rentrez,parse_esummary,0,0,1,list<list<character | character[] | list<character | class<`data.frame`> | list<character>>>>,1
+rentrez,parse_esummary,1,0,0,any,1
+rentrez,parse_esummary,2,0,0,logical,1
+rentrez,parse_esummary.list,-1,0,0,"class<`esummary_list`, `list`>",1
+rentrez,parse_esummary.list,0,0,0,list<list<character | character[] | list<any>>>,1
+rentrez,parse_esummary.list,0,0,1,list<list<character | character[] | list<character | class<`data.frame`> | list<character>>>>,1
+rentrez,parse_esummary.list,1,0,0,any,1
+rentrez,parse_esummary.list,2,0,0,logical,1
+rentrez,parse_response,-1,0,0,"class<`XMLAbstractDocument`, `XMLInternalDocument`>",1
+rentrez,parse_response,-1,0,1,list<list<character | character[] | list<any>>>,1
+rentrez,parse_response,-1,0,2,list<list<character | character[] | list<character | class<`data.frame`> | list<character>>>>,1
+rentrez,parse_response,0,0,0,character,1
+rentrez,parse_response,1,0,0,character,1
+rentrez,sleep_time,-1,0,0,double,1
+rentrez,sleep_time,0,0,0,list<character>,1
+rentrez,sleep_time,0,0,1,list<character | double>,1
+rentrez,sleep_time,0,0,2,list<null | character>,1
+reshape,add.all.combinations,-1,0,0,class<`data.frame`>,1
+reshape,add.all.combinations,0,0,0,class<`data.frame`>,1
+reshape,add.all.combinations,1,0,0,list<null>,1
+reshape,add.all.combinations,1,0,1,list<character[]>,1
+reshape,add.all.combinations,1,0,2,list<character[] | null>,1
+reshape,add.all.combinations,1,0,3,list<character | null>,1
+reshape,add.all.combinations,2,0,0,null,1
+reshape,add.all.combinations,2,0,1,^double[],1
+reshape,all.vars.character,-1,0,0,list<null | list<character>>,1
+reshape,all.vars.character,-1,0,1,list<character[] | list<character>>,1
+reshape,all.vars.character,-1,0,2,list<character | list<character>>,1
+reshape,all.vars.character,-1,0,3,list<null | list<character[]>>,1
+reshape,all.vars.character,-1,0,4,list<character | list<character[] | null>>,1
+reshape,all.vars.character,-1,0,5,list<character | list<character[]>>,1
+reshape,all.vars.character,-1,0,6,list<character | list<character | null>>,1
+reshape,all.vars.character,-1,0,7,list<null | list<character | null>>,1
+reshape,all.vars.character,-1,0,8,list<null | list<null | character[]>>,1
+reshape,all.vars.character,0,0,0,character,1
+reshape,all.vars.character,1,0,0,character,1
+reshape,as.data.frame.cast_matrix,-1,0,0,"class<`cast_df`, `data.frame`>",1
+reshape,as.data.frame.cast_matrix,0,0,0,"class<`cast_matrix`, `matrix`>",1
+reshape,as.data.frame.cast_matrix,1,0,0,any,1
+reshape,as.data.frame.cast_matrix,2,0,0,any,1
+reshape,as.data.frame.cast_matrix,3,0,0,...,1
+reshape,cast,-1,0,0,class<`array`>,1
+reshape,cast,-1,0,1,"class<`cast_df`, `data.frame`>",1
+reshape,cast,0,0,0,class<`data.frame`>,1
+reshape,cast,1,0,0,class<`formula`>,1
+reshape,cast,1,0,1,character,1
+reshape,cast,2,0,0,class<`function`>,1
+reshape,cast,2,0,1,null,1
+reshape,cast,2,0,2,list<class<`function`>>,1
+reshape,cast,3,0,0,...,1
+reshape,cast,4,0,0,logical,1
+reshape,cast,4,0,1,character[],1
+reshape,cast,5,0,0,any,1
+reshape,cast,6,0,0,logical,1
+reshape,cast,7,0,0,null,1
+reshape,cast,7,0,1,double,1
+reshape,cast_matrix,-1,0,0,"class<`cast_matrix`, `matrix`>",1
+reshape,cast_matrix,0,0,0,class<`matrix`>,1
+reshape,cast_matrix,1,0,0,list<class<`data.frame`>>,1
+reshape,cast_parse_formula,-1,0,0,list<null | list<character>>,1
+reshape,cast_parse_formula,-1,0,1,list<character[] | list<character>>,1
+reshape,cast_parse_formula,-1,0,2,list<character | list<character>>,1
+reshape,cast_parse_formula,-1,0,3,list<null | list<character[]>>,1
+reshape,cast_parse_formula,-1,0,4,list<character[] | list<character[] | null>>,1
+reshape,cast_parse_formula,-1,0,5,list<character | list<character | null>>,1
+reshape,cast_parse_formula,-1,0,6,list<null | list<character | null>>,1
+reshape,cast_parse_formula,0,0,0,character,1
+reshape,cast_parse_formula,1,0,0,character[],1
+reshape,check_formula,-1,0,0,null,1
+reshape,check_formula,0,0,0,character,1
+reshape,check_formula,1,0,0,character[],1
+reshape,combine_factor,-1,0,0,class<`factor`>,1
+reshape,combine_factor,0,0,0,class<`factor`>,1
+reshape,combine_factor,1,0,0,double[],1
+reshape,combine_factor,2,0,0,character,1
+reshape,compute.margins,-1,0,0,class<`data.frame`>,1
+reshape,compute.margins,0,0,0,any,1
+reshape,compute.margins,1,0,0,list<character | double[]>,1
+reshape,compute.margins,1,0,1,list<character[]>,1
+reshape,compute.margins,1,0,2,list<double[]>,1
+reshape,compute.margins,1,0,3,null,1
+reshape,compute.margins,2,0,0,any,1
+reshape,compute.margins,3,0,0,any,1
+reshape,compute.margins,4,0,0,...,1
+reshape,compute.margins,5,0,0,any,1
+reshape,condense,-1,0,0,class<`data.frame`>,1
+reshape,condense,0,0,0,class<`data.frame`>,1
+reshape,condense,1,0,0,character[],1
+reshape,condense,1,0,1,double[],1
+reshape,condense,2,0,0,class<`function`>,1
+reshape,condense,3,0,0,...,1
+reshape,dim_names,-1,0,0,class<`data.frame`>,1
+reshape,dim_names,0,0,0,any,1
+reshape,dim_names,1,0,0,null,1
+reshape,dim_names,1,0,1,character[],1
+reshape,expand,-1,0,0,class<`data.frame`>,1
+reshape,expand,0,0,0,class<`data.frame`>,1
+reshape,expand.grid.df,-1,0,0,class<`data.frame`>,1
+reshape,expand.grid.df,0,0,0,...,1
+reshape,expand.grid.df,1,0,0,logical,1
+reshape,funstofun,-1,0,0,class<`function`>,1
+reshape,funstofun,0,0,0,...,1
+reshape,funstofun,-1,1,0,double[],1
+reshape,funstofun,0,1,0,double[],1
+reshape,funstofun,1,1,0,...,1
+reshape,guess_value,-1,0,0,character,1
+reshape,guess_value,0,0,0,class<`data.frame`>,1
+reshape,margin.vars,-1,0,0,list<character | double[]>,1
+reshape,margin.vars,-1,0,1,list<character[]>,1
+reshape,margin.vars,-1,0,2,list<double[]>,1
+reshape,margin.vars,-1,0,3,null,1
+reshape,margin.vars,0,0,0,list<character[]>,1
+reshape,margin.vars,0,0,1,list<character[] | null>,1
+reshape,margin.vars,0,0,2,list<character | null>,1
+reshape,margin.vars,1,0,0,any,1
+reshape,melt,-1,0,0,class<`data.frame`>,1
+reshape,melt,0,0,0,class<`array`>,1
+reshape,melt,0,0,1,class<`matrix`>,1
+reshape,melt,0,0,2,double,1
+reshape,melt,0,0,3,integer[],1
+reshape,melt,0,0,4,list<list<integer>>,1
+reshape,melt,0,0,5,list<integer[]>,1
+reshape,melt,0,0,6,list<class<`matrix`> | class<`array`>>,1
+reshape,melt,0,0,7,list<class<`matrix`>>,1
+reshape,melt,0,0,8,list<integer[] | class<`matrix`>>,1
+reshape,melt,0,0,9,list<double | list<integer[] | list<integer>>>,1
+reshape,melt,0,0,10,class<`data.frame`>,1
+reshape,melt,0,0,11,"class<`data.frame`, `groupedData`, `nfGroupedData`, `nfnGroupedData`>",1
+reshape,melt,1,0,0,...,1
+reshape,melt.array,-1,0,0,class<`data.frame`>,1
+reshape,melt.array,0,0,0,class<`array`>,1
+reshape,melt.array,0,0,1,class<`matrix`>,1
+reshape,melt.array,1,0,0,character[],1
+reshape,melt.array,1,0,1,null,1
+reshape,melt.array,2,0,0,...,1
+reshape,melt_check,-1,0,0,list<character[]>,1
+reshape,melt_check,0,0,0,class<`data.frame`>,1
+reshape,melt_check,0,0,1,"class<`data.frame`, `groupedData`, `nfGroupedData`, `nfnGroupedData`>",1
+reshape,melt_check,1,0,0,any,1
+reshape,melt_check,2,0,0,any,1
+reshape,melt.data.frame,-1,0,0,class<`data.frame`>,1
+reshape,melt.data.frame,0,0,0,class<`data.frame`>,1
+reshape,melt.data.frame,0,0,1,"class<`data.frame`, `groupedData`, `nfGroupedData`, `nfnGroupedData`>",1
+reshape,melt.data.frame,1,0,0,any,1
+reshape,melt.data.frame,2,0,0,any,1
+reshape,melt.data.frame,3,0,0,character,1
+reshape,melt.data.frame,4,0,0,logical,1
+reshape,melt.data.frame,5,0,0,logical,1
+reshape,melt.data.frame,6,0,0,...,1
+reshape,melt.default,-1,0,0,class<`data.frame`>,1
+reshape,melt.default,0,0,0,double,1
+reshape,melt.default,0,0,1,integer[],1
+reshape,melt.default,1,0,0,...,1
+reshape,melt.list,-1,0,0,class<`data.frame`>,1
+reshape,melt.list,0,0,0,list<class<`matrix`> | class<`array`>>,1
+reshape,melt.list,0,0,1,list<class<`matrix`>>,1
+reshape,melt.list,0,0,2,list<integer[] | class<`matrix`>>,1
+reshape,melt.list,0,0,3,list<list<integer>>,1
+reshape,melt.list,0,0,4,list<double | list<integer[] | list<integer>>>,1
+reshape,melt.list,0,0,5,list<integer[]>,1
+reshape,melt.list,1,0,0,...,1
+reshape,melt.list,2,0,0,double,1
+reshape,melt.matrix,-1,0,0,class<`data.frame`>,1
+reshape,melt.matrix,0,0,0,class<`array`>,1
+reshape,melt.matrix,0,0,1,class<`matrix`>,1
+reshape,melt.matrix,1,0,0,character[],1
+reshape,melt.matrix,1,0,1,null,1
+reshape,melt.matrix,2,0,0,...,1
+reshape,nested.by,-1,0,0,class<`array`>,1
+reshape,nested.by,0,0,0,class<`data.frame`>,1
+reshape,nested.by,1,0,0,class<`data.frame`>,1
+reshape,nested.by,1,0,1,list<class<`factor`>>,1
+reshape,nested.by,2,0,0,class<`function`>,1
+reshape,nested.by,3,0,0,...,1
+reshape,nulldefault,-1,0,0,character[],1
+reshape,nulldefault,-1,0,1,integer[],1
+reshape,nulldefault,0,0,0,character[],1
+reshape,nulldefault,0,0,1,null,1
+reshape,nulldefault,1,0,0,any,1
+reshape,rcolnames,-1,0,0,class<`data.frame`>,1
+reshape,rcolnames,0,0,0,"class<`cast_matrix`, `matrix`>",1
+reshape,rdimnames,-1,0,0,list<class<`data.frame`>>,1
+reshape,rdimnames,0,0,0,"class<`cast_matrix`, `matrix`>",1
+reshape,rdimnames<-,-1,0,0,class<`matrix`>,1
+reshape,rdimnames<-,0,0,0,class<`matrix`>,1
+reshape,rdimnames<-,1,0,0,list<class<`data.frame`>>,1
+reshape,recast,-1,0,0,"class<`cast_df`, `data.frame`>",1
+reshape,recast,0,0,0,class<`data.frame`>,1
+reshape,recast,1,0,0,class<`formula`>,1
+reshape,recast,2,0,0,...,1
+reshape,recast,3,0,0,integer[],1
+reshape,recast,4,0,0,any,1
+reshape,rename,-1,0,0,class<`data.frame`>,1
+reshape,rename,-1,0,1,list<double>,1
+reshape,rename,0,0,0,class<`data.frame`>,1
+reshape,rename,0,0,1,list<double>,1
+reshape,rename,1,0,0,character[],1
+reshape,reshape1,-1,0,0,class<`array`>,1
+reshape,reshape1,-1,0,1,"class<`cast_df`, `data.frame`>",1
+reshape,reshape1,0,0,0,class<`data.frame`>,1
+reshape,reshape1,1,0,0,list<character[]>,1
+reshape,reshape1,1,0,1,list<character[] | null>,1
+reshape,reshape1,1,0,2,list<character | null>,1
+reshape,reshape1,2,0,0,class<`function`>,1
+reshape,reshape1,2,0,1,null,1
+reshape,reshape1,3,0,0,any,1
+reshape,reshape1,4,0,0,logical,1
+reshape,reshape1,5,0,0,null,1
+reshape,reshape1,5,0,1,double,1
+reshape,reshape1,6,0,0,logical,1
+reshape,reshape1,7,0,0,...,1
+reshape,round_any,-1,0,0,double,1
+reshape,round_any,0,0,0,double,1
+reshape,round_any,1,0,0,double,1
+reshape,round_any,2,0,0,class<`function`>,1
+reshape,rrownames,-1,0,0,class<`data.frame`>,1
+reshape,rrownames,0,0,0,"class<`cast_matrix`, `matrix`>",1
+reshape,sort_df,-1,0,0,class<`data.frame`>,1
+reshape,sort_df,0,0,0,class<`data.frame`>,1
+reshape,sort_df,1,0,0,character[],1
+reshape,sparseby,-1,0,0,class<`matrix`>,1
+reshape,sparseby,0,0,0,class<`data.frame`>,1
+reshape,sparseby,0,0,1,class<`matrix`>,1
+reshape,sparseby,1,0,0,double[],1
+reshape,sparseby,1,0,1,list<double[]>,1
+reshape,sparseby,2,0,0,class<`function`>,1
+reshape,sparseby,3,0,0,...,1
+reshape,sparseby,4,0,0,logical,1
+reshape2,%||%,-1,0,0,^character[],1
+reshape2,%||%,-1,0,1,integer[],1
+reshape2,%||%,0,0,0,^character[],1
+reshape2,%||%,0,0,1,null,1
+reshape2,%||%,1,0,0,any,1
+reshape2,acast,-1,0,0,class<`array`>,1
+reshape2,acast,-1,0,1,class<`matrix`>,1
+reshape2,acast,0,0,0,class<`data.frame`>,1
+reshape2,acast,1,0,0,class<`formula`>,1
+reshape2,acast,2,0,0,null,1
+reshape2,acast,2,0,1,class<`function`>,1
+reshape2,acast,3,0,0,...,1
+reshape2,acast,4,0,0,null,1
+reshape2,acast,4,0,1,character,1
+reshape2,acast,4,0,2,logical,1
+reshape2,acast,5,0,0,null,1
+reshape2,acast,5,0,1,class<`quoted`>,1
+reshape2,acast,6,0,0,null,1
+reshape2,acast,6,0,1,double,1
+reshape2,acast,7,0,0,logical,1
+reshape2,acast,8,0,0,character,1
+reshape2,add_margins,-1,0,0,class<`data.frame`>,1
+reshape2,add_margins,0,0,0,class<`data.frame`>,1
+reshape2,add_margins,1,0,0,list<character[]>,1
+reshape2,add_margins,2,0,0,character[],1
+reshape2,add_margins,2,0,1,logical,1
+reshape2,all_identical,-1,0,0,logical,1
+reshape2,all_identical,0,0,0,list<null>,1
+reshape2,array_names,-1,0,0,character[],1
+reshape2,array_names,0,0,0,class<`data.frame`>,1
+reshape2,cast,-1,0,0,list<class<`array`> | list<class<`data.frame`>>>,1
+reshape2,cast,-1,0,1,list<class<`matrix`> | list<class<`data.frame`>>>,1
+reshape2,cast,0,0,0,class<`data.frame`>,1
+reshape2,cast,1,0,0,list<class<`quoted`>>,1
+reshape2,cast,2,0,0,null,1
+reshape2,cast,2,0,1,class<`function`>,1
+reshape2,cast,3,0,0,...,1
+reshape2,cast,4,0,0,null,1
+reshape2,cast,4,0,1,class<`quoted`>,1
+reshape2,cast,5,0,0,null,1
+reshape2,cast,5,0,1,double,1
+reshape2,cast,6,0,0,logical,1
+reshape2,cast,7,0,0,character,1
+reshape2,cast,8,0,0,any,1
+reshape2,colsplit,-1,0,0,class<`data.frame`>,1
+reshape2,colsplit,0,0,0,character[],1
+reshape2,colsplit,1,0,0,character,1
+reshape2,colsplit,2,0,0,character[],1
+reshape2,dcast,-1,0,0,class<`data.frame`>,1
+reshape2,dcast,0,0,0,class<`data.frame`>,1
+reshape2,dcast,1,0,0,class<`formula`>,1
+reshape2,dcast,2,0,0,class<`function`>,1
+reshape2,dcast,2,0,1,null,1
+reshape2,dcast,3,0,0,...,1
+reshape2,dcast,4,0,0,character[],1
+reshape2,dcast,4,0,1,logical,1
+reshape2,dcast,4,0,2,null,1
+reshape2,dcast,5,0,0,null,1
+reshape2,dcast,5,0,1,class<`quoted`>,1
+reshape2,dcast,6,0,0,null,1
+reshape2,dcast,7,0,0,logical,1
+reshape2,dcast,8,0,0,character,1
+reshape2,guess_value,-1,0,0,character,1
+reshape2,guess_value,0,0,0,class<`data.frame`>,1
+reshape2,is.string,-1,0,0,logical,1
+reshape2,is.string,0,0,0,character,1
+reshape2,margins,-1,0,0,list<null | character[]>,1
+reshape2,margins,0,0,0,list<character[]>,1
+reshape2,margins,1,0,0,character[],1
+reshape2,margins,1,0,1,logical,1
+reshape2,melt,-1,0,0,class<`data.frame`>,1
+reshape2,melt,0,0,0,class<`array`>,1
+reshape2,melt,0,0,1,class<`matrix`>,1
+reshape2,melt,0,0,2,double,1
+reshape2,melt,0,0,3,integer[],1
+reshape2,melt,0,0,4,null,1
+reshape2,melt,0,0,5,list<integer[]>,1
+reshape2,melt,0,0,6,list<list<integer>>,1
+reshape2,melt,0,0,7,class<`data.frame`>,1
+reshape2,melt,0,0,8,"class<`data.frame`, `groupedData`, `nfGroupedData`, `nfnGroupedData`>",1
+reshape2,melt,0,0,9,list<class<`matrix`> | class<`array`>>,1
+reshape2,melt,0,0,10,list<class<`matrix`>>,1
+reshape2,melt,0,0,11,list<integer[] | class<`matrix`>>,1
+reshape2,melt,0,0,12,list<integer | null>,1
+reshape2,melt,0,0,13,list<double | list<integer[] | list<integer>>>,1
+reshape2,melt,1,0,0,...,1
+reshape2,melt,2,0,0,logical,1
+reshape2,melt,3,0,0,character,1
+reshape2,melt.array,-1,0,0,class<`data.frame`>,1
+reshape2,melt.array,0,0,0,class<`array`>,1
+reshape2,melt.array,0,0,1,class<`matrix`>,1
+reshape2,melt.array,1,0,0,character[],1
+reshape2,melt.array,1,0,1,null,1
+reshape2,melt.array,2,0,0,...,1
+reshape2,melt.array,3,0,0,logical,1
+reshape2,melt.array,4,0,0,logical,1
+reshape2,melt.array,5,0,0,character,1
+reshape2,melt_check,-1,0,0,list<character[]>,1
+reshape2,melt_check,0,0,0,class<`data.frame`>,1
+reshape2,melt_check,0,0,1,"class<`data.frame`, `groupedData`, `nfGroupedData`, `nfnGroupedData`>",1
+reshape2,melt_check,1,0,0,any,1
+reshape2,melt_check,2,0,0,any,1
+reshape2,melt_check,3,0,0,character,1
+reshape2,melt_check,4,0,0,character,1
+reshape2,melt_dataframe,-1,0,0,class<`data.frame`>,1
+reshape2,melt_dataframe,0,0,0,class<`data.frame`>,1
+reshape2,melt_dataframe,0,0,1,"class<`data.frame`, `groupedData`, `nfGroupedData`, `nfnGroupedData`>",1
+reshape2,melt_dataframe,1,0,0,integer[],1
+reshape2,melt_dataframe,2,0,0,integer[],1
+reshape2,melt_dataframe,3,0,0,character,1
+reshape2,melt_dataframe,4,0,0,character,1
+reshape2,melt_dataframe,5,0,0,null,1
+reshape2,melt_dataframe,6,0,0,logical,1
+reshape2,melt_dataframe,7,0,0,logical,1
+reshape2,melt.data.frame,-1,0,0,class<`data.frame`>,1
+reshape2,melt.data.frame,0,0,0,class<`data.frame`>,1
+reshape2,melt.data.frame,0,0,1,"class<`data.frame`, `groupedData`, `nfGroupedData`, `nfnGroupedData`>",1
+reshape2,melt.data.frame,1,0,0,any,1
+reshape2,melt.data.frame,2,0,0,any,1
+reshape2,melt.data.frame,3,0,0,character,1
+reshape2,melt.data.frame,4,0,0,...,1
+reshape2,melt.data.frame,5,0,0,logical,1
+reshape2,melt.data.frame,6,0,0,character,1
+reshape2,melt.data.frame,7,0,0,logical,1
+reshape2,melt.default,-1,0,0,class<`data.frame`>,1
+reshape2,melt.default,0,0,0,double,1
+reshape2,melt.default,0,0,1,integer[],1
+reshape2,melt.default,0,0,2,null,1
+reshape2,melt.default,1,0,0,...,1
+reshape2,melt.default,2,0,0,logical,1
+reshape2,melt.default,3,0,0,character,1
+reshape2,melt.list,-1,0,0,class<`data.frame`>,1
+reshape2,melt.list,0,0,0,list<class<`matrix`> | class<`array`>>,1
+reshape2,melt.list,0,0,1,list<class<`matrix`>>,1
+reshape2,melt.list,0,0,2,list<integer[] | class<`matrix`>>,1
+reshape2,melt.list,0,0,3,list<integer | null>,1
+reshape2,melt.list,0,0,4,list<integer[]>,1
+reshape2,melt.list,0,0,5,list<list<integer>>,1
+reshape2,melt.list,0,0,6,list<double | list<integer[] | list<integer>>>,1
+reshape2,melt.list,1,0,0,...,1
+reshape2,melt.list,2,0,0,double,1
+reshape2,melt.matrix,-1,0,0,class<`data.frame`>,1
+reshape2,melt.matrix,0,0,0,class<`array`>,1
+reshape2,melt.matrix,0,0,1,class<`matrix`>,1
+reshape2,melt.matrix,1,0,0,character[],1
+reshape2,melt.matrix,1,0,1,null,1
+reshape2,melt.matrix,2,0,0,...,1
+reshape2,melt.matrix,3,0,0,logical,1
+reshape2,melt.matrix,4,0,0,logical,1
+reshape2,melt.matrix,5,0,0,character,1
+reshape2,normalize_melt_arguments,-1,0,0,list<null | logical>,1
+reshape2,normalize_melt_arguments,0,0,0,class<`data.frame`>,1
+reshape2,normalize_melt_arguments,0,0,1,"class<`data.frame`, `groupedData`, `nfGroupedData`, `nfnGroupedData`>",1
+reshape2,normalize_melt_arguments,1,0,0,integer[],1
+reshape2,normalize_melt_arguments,2,0,0,logical,1
+reshape2,parse_formula,-1,0,0,list<class<`quoted`>>,1
+reshape2,parse_formula,0,0,0,class<`formula`>,1
+reshape2,parse_formula,0,0,1,list<class<`quoted`>>,1
+reshape2,parse_formula,1,0,0,any,1
+reshape2,parse_formula,2,0,0,any,1
+reshape2,recast,-1,0,0,class<`data.frame`>,1
+reshape2,recast,0,0,0,class<`data.frame`>,1
+reshape2,recast,1,0,0,class<`formula`>,1
+reshape2,recast,2,0,0,...,1
+reshape2,recast,3,0,0,integer[],1
+reshape2,recast,4,0,0,any,1
+reshape2,upto,-1,0,0,character[],1
+reshape2,upto,0,0,0,character,1
+reshape2,upto,1,0,0,character[],1
+rex,%==%,-1,0,0,logical,1
+rex,%==%,0,0,0,logical,1
+rex,%==%,1,0,0,logical,1
+rex,add_options,-1,0,0,character,1
+rex,add_options,-1,0,1,class<`regex`>,1
+rex,add_options,0,0,0,character,1
+rex,add_options,0,0,1,class<`regex`>,1
+rex,add_options,1,0,0,null,1
+rex,add_options,1,0,1,character,1
+rex,add_type,-1,0,0,class<`regex`>,1
+rex,add_type,0,0,0,class<`regex`>,1
+rex,add_type,1,0,0,character[],1
+rex,as.character.regex,-1,0,0,class<`regex`>,1
+rex,as.character.regex,0,0,0,class<`regex`>,1
+rex,as.character.regex,1,0,0,...,1
+rex,at_least,-1,0,0,class<`regex`>,1
+rex,at_least,0,0,0,class<`regex`>,1
+rex,at_least,1,0,0,double,1
+rex,at_least,2,0,0,character[],1
+rex,auto_name,-1,0,0,character[],1
+rex,auto_name,0,0,0,character[],1
+rex,between,-1,0,0,class<`regex`>,1
+rex,between,0,0,0,"class<`character_class`, `regex`>",1
+rex,between,0,0,1,class<`regex`>,1
+rex,between,1,0,0,double,1
+rex,between,2,0,0,double,1
+rex,between,2,0,1,character,1
+rex,between,3,0,0,character[],1
+rex,capture,-1,0,0,class<`regex`>,1
+rex,capture,0,0,0,...,1
+rex,capture,1,0,0,character,1
+rex,capture,1,0,1,null,1
+rex,capture_group,-1,0,0,class<`regex`>,1
+rex,capture_group,0,0,0,character,1
+rex,capture_group,0,0,1,double,1
+rex,character_class,-1,0,0,"class<`character_class`, `regex`>",1
+rex,character_class,0,0,0,character,1
+rex,character_class,0,0,1,class<`regex`>,1
+rex,character_class_escape,-1,0,0,class<`regex`>,1
+rex,character_class_escape,-1,0,1,list<class<`regex`>>,1
+rex,character_class_escape,0,0,0,character,1
+rex,character_class_escape,0,0,1,list<character>,1
+rex,character_class_escape,0,0,2,list<class<`regex`>>,1
+rex,character_class_escape,0,0,3,class<`regex`>,1
+rex,character_class_escape.character,-1,0,0,class<`regex`>,1
+rex,character_class_escape.character,0,0,0,character,1
+rex,character_class_escape_dots,-1,0,0,character[],1
+rex,character_class_escape_dots,0,0,0,...,1
+rex,character_class_escape.list,-1,0,0,list<class<`regex`>>,1
+rex,character_class_escape.list,0,0,0,list<character>,1
+rex,character_class_escape.list,0,0,1,list<class<`regex`>>,1
+rex,character_class_escape.regex,-1,0,0,class<`regex`>,1
+rex,character_class_escape.regex,0,0,0,class<`regex`>,1
+rex,escape,-1,0,0,class<`regex`>,1
+rex,escape,-1,0,1,list<class<`regex`>>,1
+rex,escape,0,0,0,character,1
+rex,escape,0,0,1,"class<`character_class`, `regex`>",1
+rex,escape,0,0,2,class<`regex`>,1
+rex,escape,0,0,3,list<character | class<`regex`>>,1
+rex,escape,0,0,4,list<class<`regex`> | character>,1
+rex,escape,0,0,5,list<class<`regex`>>,1
+rex,escape,0,0,6,list<character>,1
+rex,escape,0,0,7,"list<class<`character_class`, `regex`>>",1
+rex,escape,0,0,8,"list<class<`regex`> | class<`character_class`, `regex`>>",1
+rex,escape.character,-1,0,0,class<`regex`>,1
+rex,escape.character,0,0,0,character,1
+rex,escape.character_class,-1,0,0,class<`regex`>,1
+rex,escape.character_class,0,0,0,"class<`character_class`, `regex`>",1
+rex,escape_dots,-1,0,0,character[],1
+rex,escape_dots,0,0,0,...,1
+rex,escape.list,-1,0,0,list<class<`regex`>>,1
+rex,escape.list,0,0,0,list<character | class<`regex`>>,1
+rex,escape.list,0,0,1,list<class<`regex`> | character>,1
+rex,escape.list,0,0,2,list<class<`regex`>>,1
+rex,escape.list,0,0,3,list<character>,1
+rex,escape.list,0,0,4,"list<class<`character_class`, `regex`>>",1
+rex,escape.list,0,0,5,"list<class<`regex`> | class<`character_class`, `regex`>>",1
+rex,escape.regex,-1,0,0,class<`regex`>,1
+rex,escape.regex,0,0,0,class<`regex`>,1
+rex,except,-1,0,0,class<`regex`>,1
+rex,except,0,0,0,...,1
+rex,except_some_of,-1,0,0,class<`regex`>,1
+rex,except_some_of,0,0,0,...,1
+rex,except_some_of,1,0,0,character[],1
+rex,group,-1,0,0,class<`regex`>,1
+rex,group,0,0,0,...,1
+rex,%if_next_is%,-1,0,0,class<`regex`>,1
+rex,%if_next_is%,0,0,0,character,1
+rex,%if_next_is%,0,0,1,"class<`character_class`, `regex`>",1
+rex,%if_next_is%,1,0,0,character,1
+rex,%if_next_is%,1,0,1,"class<`character_class`, `regex`>",1
+rex,%if_next_isnt%,-1,0,0,class<`regex`>,1
+rex,%if_next_isnt%,0,0,0,"class<`character_class`, `regex`>",1
+rex,%if_next_isnt%,1,0,0,"class<`character_class`, `regex`>",1
+rex,%if_prev_is%,-1,0,0,class<`regex`>,1
+rex,%if_prev_is%,0,0,0,character,1
+rex,%if_prev_is%,1,0,0,character,1
+rex,match_args,-1,0,0,character,1
+rex,match_args,0,0,0,character,1
+rex,match_args,1,0,0,character[],1
+rex,maybe,-1,0,0,class<`regex`>,1
+rex,maybe,0,0,0,...,1
+rex,maybe,1,0,0,any,1
+rex,no_capture,-1,0,0,logical,1
+rex,no_capture,0,0,0,integer[],1
+rex,none_of,-1,0,0,class<`regex`>,1
+rex,none_of,0,0,0,...,1
+rex,one_of,-1,0,0,class<`regex`>,1
+rex,one_of,0,0,0,...,1
+rex,one_or_more,-1,0,0,class<`regex`>,1
+rex,one_or_more,0,0,0,...,1
+rex,one_or_more,1,0,0,character[],1
+rex,or,-1,0,0,class<`regex`>,1
+rex,or,0,0,0,...,1
+rex,%or%,-1,0,0,class<`regex`>,1
+rex,%or%,0,0,0,list<character | class<`regex`>>,1
+rex,%or%,1,0,0,character,1
+rex,p,-1,0,0,class<`regex`>,1
+rex,p,0,0,0,...,1
+rex,range,-1,0,0,"class<`character_class`, `regex`>",1
+rex,range,0,0,0,character,1
+rex,range,1,0,0,character,1
+rex,regex,-1,0,0,class<`regex`>,1
+rex,regex,0,0,0,character,1
+rex,regex,0,0,1,class<`regex`>,1
+rex,regex,1,0,0,...,1
+rex,register,-1,0,0,environment,1
+rex,register,0,0,0,...,1
+rex,re_matches,-1,0,0,class<`data.frame`>,1
+rex,re_matches,-1,0,1,logical[],1
+rex,re_matches,0,0,0,character[],1
+rex,re_matches,1,0,0,class<`regex`>,1
+rex,re_matches,2,0,0,logical,1
+rex,re_matches,3,0,0,null,1
+rex,re_matches,4,0,0,logical,1
+rex,re_matches,5,0,0,...,1
+rex,re_substitutes,-1,0,0,character[],1
+rex,re_substitutes,0,0,0,character[],1
+rex,re_substitutes,1,0,0,character,1
+rex,re_substitutes,2,0,0,character,1
+rex,re_substitutes,3,0,0,logical,1
+rex,re_substitutes,4,0,0,character,1
+rex,re_substitutes,4,0,1,null,1
+rex,re_substitutes,5,0,0,...,1
+rex,rex,-1,0,0,class<`regex`>,1
+rex,rex,0,0,0,...,1
+rex,rex,1,0,0,any,1
+rex,rex_,-1,0,0,class<`regex`>,1
+rex,rex_,0,0,0,class<`lazy_dots`>,1
+rex,rex_,1,0,0,any,1
+rex,sanitize,-1,0,0,character,1
+rex,sanitize,0,0,0,character,1
+rex,sanitize,1,0,0,character[],1
+rex,zero_or_more,-1,0,0,class<`regex`>,1
+rex,zero_or_more,0,0,0,...,1
+rex,zero_or_more,1,0,0,character[],1
+rgdal,assertClass,-1,0,0,class<`GDALDriver`>,1
+rgdal,assertClass,-1,0,1,class<`GDALRasterBand`>,1
+rgdal,assertClass,-1,0,2,class<`GDALReadOnlyDataset`>,1
+rgdal,assertClass,-1,0,3,class<`GDALTransientDataset`>,1
+rgdal,assertClass,0,0,0,class<`GDALDriver`>,1
+rgdal,assertClass,0,0,1,class<`GDALRasterBand`>,1
+rgdal,assertClass,0,0,2,class<`GDALReadOnlyDataset`>,1
+rgdal,assertClass,0,0,3,class<`GDALTransientDataset`>,1
+rgdal,assertClass,1,0,0,character,1
+rgdal,checkCRSArgs,-1,0,0,list<logical | character>,1
+rgdal,checkCRSArgs,0,0,0,character,1
+rgdal,close.SpatialGDAL,-1,0,0,null,1
+rgdal,close.SpatialGDAL,0,0,0,class<`SpatialGDAL`>,1
+rgdal,close.SpatialGDAL,1,0,0,...,1
+rgdal,create2GDAL,-1,0,0,any,1
+rgdal,create2GDAL,0,0,0,class<`SpatialGridDataFrame`>,1
+rgdal,create2GDAL,1,0,0,character,1
+rgdal,create2GDAL,2,0,0,character,1
+rgdal,create2GDAL,3,0,0,null,1
+rgdal,create2GDAL,4,0,0,any,1
+rgdal,create2GDAL,5,0,0,any,1
+rgdal,create2GDAL,6,0,0,any,1
+rgdal,create2GDAL,7,0,0,any,1
+rgdal,CRSargs,-1,0,0,character,1
+rgdal,CRSargs,0,0,0,class<`CRS`>,1
+rgdal,GDAL.close,-1,0,0,null,1
+rgdal,GDAL.close,0,0,0,class<`GDALReadOnlyDataset`>,1
+rgdal,GDAL.close,0,0,1,class<`GDALTransientDataset`>,1
+rgdal,gdalDrivers,-1,0,0,class<`data.frame`>,1
+rgdal,GDAL_iconv,-1,0,0,logical,1
+rgdal,GDALinfo,-1,0,0,class<`GDALobj`>,1
+rgdal,GDALinfo,0,0,0,character,1
+rgdal,GDALinfo,1,0,0,logical,1
+rgdal,GDALinfo,2,0,0,logical,1
+rgdal,GDALinfo,3,0,0,logical,1
+rgdal,GDALinfo,4,0,0,logical,1
+rgdal,GDALinfo,5,0,0,logical,1
+rgdal,GDALinfo,6,0,0,null,1
+rgdal,GDALinfo,7,0,0,logical,1
+rgdal,GDAL.open,-1,0,0,any,1
+rgdal,GDAL.open,0,0,0,character,1
+rgdal,GDAL.open,1,0,0,logical,1
+rgdal,GDAL.open,2,0,0,logical,1
+rgdal,GDAL.open,3,0,0,null,1
+rgdal,GDAL.open,4,0,0,null,1
+rgdal,getCPLConfigOption,-1,0,0,null,1
+rgdal,getCPLConfigOption,0,0,0,character,1
+rgdal,getDescription,-1,0,0,character,1
+rgdal,getDescription,0,0,0,class<`GDALReadOnlyDataset`>,1
+rgdal,getDriver,-1,0,0,class<`GDALDriver`>,1
+rgdal,getDriver,0,0,0,class<`GDALReadOnlyDataset`>,1
+rgdal,getDriverLongName,-1,0,0,character,1
+rgdal,getDriverLongName,0,0,0,class<`GDALDriver`>,1
+rgdal,getDriverName,-1,0,0,character,1
+rgdal,getDriverName,0,0,0,class<`GDALDriver`>,1
+rgdal,getGDALCheckVersion,-1,0,0,logical,1
+rgdal,getGDAL_DATA_Path,-1,0,0,character,1
+rgdal,getGDALDriverNames,-1,0,0,class<`data.frame`>,1
+rgdal,getGDALVersionInfo,-1,0,0,character,1
+rgdal,getGDALVersionInfo,0,0,0,character,1
+rgdal,getGDALwithGEOS,-1,0,0,logical,1
+rgdal,getGeoTransFunc,-1,0,0,class<`function`>,1
+rgdal,getGeoTransFunc,0,0,0,class<`GDALReadOnlyDataset`>,1
+rgdal,get_OVERRIDE_PROJ_DATUM_WITH_TOWGS84,-1,0,0,logical,1
+rgdal,getPROJ4libPath,-1,0,0,character,1
+rgdal,getPROJ4VersionInfo,-1,0,0,character,1
+rgdal,getProjectionRef,-1,0,0,character,1
+rgdal,getProjectionRef,0,0,0,class<`GDALReadOnlyDataset`>,1
+rgdal,getProjectionRef,1,0,0,null,1
+rgdal,getRasterBand,-1,0,0,class<`GDALRasterBand`>,1
+rgdal,getRasterBand,0,0,0,class<`GDALReadOnlyDataset`>,1
+rgdal,getRasterBand,0,0,1,class<`GDALTransientDataset`>,1
+rgdal,getRasterBand,1,0,0,double,1
+rgdal,getRasterBlockSize,-1,0,0,integer[],1
+rgdal,getRasterBlockSize,0,0,0,class<`GDALRasterBand`>,1
+rgdal,getRasterData,-1,0,0,any,1
+rgdal,getRasterData,0,0,0,class<`GDALTransientDataset`>,1
+rgdal,getRasterData,0,0,1,class<`GDALReadOnlyDataset`>,1
+rgdal,getRasterData,1,0,0,double,1
+rgdal,getRasterData,1,0,1,null,1
+rgdal,getRasterData,2,0,0,double[],1
+rgdal,getRasterData,3,0,0,double[],1
+rgdal,getRasterData,4,0,0,double[],1
+rgdal,getRasterData,5,0,0,double[],1
+rgdal,getRasterData,6,0,0,logical,1
+rgdal,getRasterData,7,0,0,logical,1
+rgdal,getRasterTable,-1,0,0,class<`data.frame`>,1
+rgdal,getRasterTable,0,0,0,class<`GDALReadOnlyDataset`>,1
+rgdal,getRasterTable,1,0,0,null,1
+rgdal,getRasterTable,2,0,0,double[],1
+rgdal,getRasterTable,3,0,0,integer[],1
+rgdal,isObjPtrNULL,-1,0,0,logical,1
+rgdal,isObjPtrNULL,0,0,0,class<`GDALTransientDataset`>,1
+rgdal,llgridlines,-1,0,0,null,1
+rgdal,llgridlines,0,0,0,class<`SpatialPointsDataFrame`>,1
+rgdal,llgridlines,1,0,0,any,1
+rgdal,llgridlines,2,0,0,any,1
+rgdal,llgridlines,3,0,0,double,1
+rgdal,llgridlines,4,0,0,double,1
+rgdal,llgridlines,5,0,0,double,1
+rgdal,llgridlines,6,0,0,character,1
+rgdal,llgridlines,7,0,0,character,1
+rgdal,load_stuff,-1,0,0,null,1
+rgdal,local_RGDAL_Init,-1,0,0,null,1
+rgdal,make_EPSG,-1,0,0,class<`data.frame`>,1
+rgdal,make_EPSG,0,0,0,any,1
+rgdal,.normalize_if_path,-1,0,0,character,1
+rgdal,.normalize_if_path,0,0,0,character,1
+rgdal,.normalize_if_path,1,0,0,null,1
+rgdal,ogrDeleteDataSource,-1,0,0,null,1
+rgdal,ogrDeleteDataSource,0,0,0,character,1
+rgdal,ogrDeleteDataSource,1,0,0,character,1
+rgdal,ogrDeleteLayer,-1,0,0,any,1
+rgdal,ogrDeleteLayer,0,0,0,character,1
+rgdal,ogrDeleteLayer,1,0,0,character,1
+rgdal,ogrDeleteLayer,2,0,0,character,1
+rgdal,ogrDrivers,-1,0,0,class<`data.frame`>,1
+rgdal,ogrFIDs,-1,0,0,integer[],1
+rgdal,ogrFIDs,0,0,0,character,1
+rgdal,ogrFIDs,1,0,0,character,1
+rgdal,ogrInfo,-1,0,0,any,1
+rgdal,ogrInfo,0,0,0,character,1
+rgdal,ogrInfo,1,0,0,any,1
+rgdal,ogrInfo,2,0,0,null,1
+rgdal,ogrInfo,3,0,0,logical,1
+rgdal,ogrInfo,4,0,0,any,1
+rgdal,ogrInfo,5,0,0,null,1
+rgdal,ogrInfo,5,0,1,character,1
+rgdal,ogrListLayers,-1,0,0,character[],1
+rgdal,ogrListLayers,0,0,0,character,1
+rgdal,OGRSpatialRef,-1,0,0,any,1
+rgdal,OGRSpatialRef,0,0,0,character,1
+rgdal,OGRSpatialRef,1,0,0,character,1
+rgdal,open.SpatialGDAL,-1,0,0,class<`SpatialGDAL`>,1
+rgdal,open.SpatialGDAL,0,0,0,character,1
+rgdal,open.SpatialGDAL,1,0,0,...,1
+rgdal,open.SpatialGDAL,2,0,0,logical,1
+rgdal,open.SpatialGDAL,3,0,0,null,1
+rgdal,open.SpatialGDAL,4,0,0,null,1
+rgdal,project,-1,0,0,any,1
+rgdal,project,0,0,0,class<`matrix`>,1
+rgdal,project,1,0,0,character,1
+rgdal,project,2,0,0,logical,1
+rgdal,project,3,0,0,logical,1
+rgdal,project,4,0,0,logical,1
+rgdal,project,5,0,0,logical,1
+rgdal,projInfo,-1,0,0,class<`data.frame`>,1
+rgdal,projInfo,0,0,0,character,1
+rgdal,projNAD,-1,0,0,logical,1
+rgdal,putRasterData,-1,0,0,class<`GDALRasterBand`>,1
+rgdal,putRasterData,0,0,0,class<`GDALTransientDataset`>,1
+rgdal,putRasterData,1,0,0,class<`matrix`>,1
+rgdal,putRasterData,2,0,0,integer,1
+rgdal,putRasterData,3,0,0,double[],1
+rgdal,readGDAL,-1,0,0,any,1
+rgdal,readGDAL,0,0,0,character,1
+rgdal,readGDAL,1,0,0,any,1
+rgdal,readGDAL,2,0,0,any,1
+rgdal,readGDAL,3,0,0,any,1
+rgdal,readGDAL,4,0,0,any,1
+rgdal,readGDAL,5,0,0,null,1
+rgdal,readGDAL,6,0,0,...,1
+rgdal,readGDAL,7,0,0,double[],1
+rgdal,readOGR,-1,0,0,any,1
+rgdal,readOGR,0,0,0,character,1
+rgdal,readOGR,1,0,0,any,1
+rgdal,readOGR,2,0,0,logical,1
+rgdal,readOGR,3,0,0,null,1
+rgdal,readOGR,4,0,0,any,1
+rgdal,readOGR,5,0,0,logical,1
+rgdal,readOGR,6,0,0,logical,1
+rgdal,readOGR,7,0,0,logical,1
+rgdal,RGB2PCT,-1,0,0,list<class<`GDALTransientDataset`> | character[]>,1
+rgdal,RGB2PCT,0,0,0,class<`GDALTransientDataset`>,1
+rgdal,RGB2PCT,1,0,0,integer[],1
+rgdal,RGB2PCT,2,0,0,character,1
+rgdal,RGB2PCT,3,0,0,double,1
+rgdal,RGB2PCT,4,0,0,logical,1
+rgdal,.setCollectorFun,-1,0,0,null,1
+rgdal,.setCollectorFun,0,0,0,externalptr,1
+rgdal,.setCollectorFun,1,0,0,class<`function`>,1
+rgdal,.setCollectorFun,1,0,1,null,1
+rgdal,SGDF2PCT,-1,0,0,list<double[] | character[]>,1
+rgdal,SGDF2PCT,0,0,0,class<`SpatialGridDataFrame`>,1
+rgdal,SGDF2PCT,1,0,0,double,1
+rgdal,SGDF2PCT,2,0,0,logical,1
+rgdal,showEPSG,-1,0,0,character,1
+rgdal,showEPSG,0,0,0,character,1
+rgdal,showP4,-1,0,0,character,1
+rgdal,showP4,0,0,0,character,1
+rgdal,showP4,1,0,0,logical,1
+rgdal,showWKT,-1,0,0,character,1
+rgdal,showWKT,0,0,0,character,1
+rgdal,showWKT,1,0,0,null,1
+rgdal,showWKT,2,0,0,logical,1
+rgdal,.spTransform_Line,-1,0,0,class<`Line`>,1
+rgdal,.spTransform_Line,0,0,0,class<`Line`>,1
+rgdal,.spTransform_Line,1,0,0,character,1
+rgdal,.spTransform_Line,2,0,0,character,1
+rgdal,.spTransform_Line,3,0,0,any,1
+rgdal,.spTransform_Line,4,0,0,any,1
+rgdal,.spTransform_Line,5,0,0,integer,1
+rgdal,.spTransform_Lines,-1,0,0,class<`Lines`>,1
+rgdal,.spTransform_Lines,0,0,0,class<`Lines`>,1
+rgdal,.spTransform_Lines,1,0,0,character,1
+rgdal,.spTransform_Lines,2,0,0,character,1
+rgdal,.spTransform_Lines,3,0,0,any,1
+rgdal,.spTransform_Lines,4,0,0,integer,1
+rgdal,.spTransform_Polygon,-1,0,0,class<`Polygon`>,1
+rgdal,.spTransform_Polygon,0,0,0,class<`Polygon`>,1
+rgdal,.spTransform_Polygon,1,0,0,character,1
+rgdal,.spTransform_Polygon,2,0,0,character,1
+rgdal,.spTransform_Polygon,3,0,0,any,1
+rgdal,.spTransform_Polygon,4,0,0,any,1
+rgdal,.spTransform_Polygon,5,0,0,integer,1
+rgdal,.spTransform_Polygons,-1,0,0,class<`Polygons`>,1
+rgdal,.spTransform_Polygons,0,0,0,class<`Polygons`>,1
+rgdal,.spTransform_Polygons,1,0,0,character,1
+rgdal,.spTransform_Polygons,2,0,0,character,1
+rgdal,.spTransform_Polygons,3,0,0,any,1
+rgdal,.spTransform_Polygons,4,0,0,integer,1
+rgdal,vec2RGB,-1,0,0,class<`matrix`>,1
+rgdal,vec2RGB,0,0,0,^double[],1
+rgdal,vec2RGB,1,0,0,double[],1
+rgdal,vec2RGB,2,0,0,character[],1
+rgdal,version_sp_linkingTo,-1,0,0,character,1
+rgdal,writeGDAL,-1,0,0,any,1
+rgdal,writeGDAL,0,0,0,class<`SpatialGridDataFrame`>,1
+rgdal,writeGDAL,1,0,0,character,1
+rgdal,writeGDAL,2,0,0,character,1
+rgdal,writeGDAL,3,0,0,character,1
+rgdal,writeGDAL,4,0,0,null,1
+rgdal,writeGDAL,5,0,0,character,1
+rgdal,writeGDAL,5,0,1,null,1
+rgdal,writeGDAL,6,0,0,character,1
+rgdal,writeGDAL,7,0,0,logical,1
+rgdal,writeOGR,-1,0,0,any,1
+rgdal,writeOGR,0,0,0,any,1
+rgdal,writeOGR,1,0,0,character,1
+rgdal,writeOGR,2,0,0,character,1
+rgdal,writeOGR,3,0,0,character,1
+rgdal,writeOGR,4,0,0,null,1
+rgdal,writeOGR,4,0,1,character,1
+rgdal,writeOGR,5,0,0,null,1
+rgdal,writeOGR,5,0,1,character,1
+rgdal,writeOGR,6,0,0,logical,1
+rgdal,writeOGR,7,0,0,null,1
+rgeos,append.poly,-1,0,0,class<`gpc.poly`>,1
+rgeos,append.poly,0,0,0,class<`gpc.poly.nohole`>,1
+rgeos,append.poly,1,0,0,class<`gpc.poly.nohole`>,1
+rgeos,append.poly,-1,1,0,class<`gpc.poly`>,1
+rgeos,append.poly,0,1,0,class<`gpc.poly`>,1
+rgeos,append.poly,1,1,0,class<`gpc.poly`>,1
+rgeos,append.poly,-1,2,0,class<`gpc.poly`>,1
+rgeos,append.poly,0,2,0,class<`gpc.poly`>,1
+rgeos,append.poly,0,2,1,class<`gpc.poly.nohole`>,1
+rgeos,append.poly,1,2,0,class<`gpc.poly`>,1
+rgeos,append.poly,1,2,1,class<`gpc.poly.nohole`>,1
+rgeos,area.poly,-1,0,0,double,1
+rgeos,area.poly,0,0,0,class<`gpc.poly`>,1
+rgeos,area.poly,1,0,0,...,1
+rgeos,area.poly,-1,1,0,double,1
+rgeos,area.poly,0,1,0,class<`gpc.poly`>,1
+rgeos,area.poly,1,1,0,...,1
+rgeos,bbox2SP,-1,0,0,class<`SpatialPolygons`>,1
+rgeos,bbox2SP,0,0,0,any,1
+rgeos,bbox2SP,1,0,0,any,1
+rgeos,bbox2SP,2,0,0,any,1
+rgeos,bbox2SP,3,0,0,any,1
+rgeos,bbox2SP,4,0,0,null,1
+rgeos,bbox2SP,4,0,1,class<`matrix`>,1
+rgeos,bbox2SP,5,0,0,class<`CRS`>,1
+rgeos,.bboxSRs,-1,0,0,class<`matrix`>,1
+rgeos,.bboxSRs,0,0,0,list<class<`Ring`>>,1
+rgeos,checkP4S,-1,0,0,class<`CRS`>,1
+rgeos,checkP4S,0,0,0,null,1
+rgeos,createPolygonsComment,-1,0,0,character,1
+rgeos,createPolygonsComment,0,0,0,class<`Polygons`>,1
+rgeos,createSPComment,-1,0,0,class<`SpatialPolygons`>,1
+rgeos,createSPComment,0,0,0,class<`SpatialPolygons`>,1
+rgeos,createSPComment,1,0,0,null,1
+rgeos,createSPComment,2,0,0,logical,1
+rgeos,gArea,-1,0,0,double[],1
+rgeos,gArea,0,0,0,class<`SpatialLines`>,1
+rgeos,gArea,0,0,1,class<`SpatialPoints`>,1
+rgeos,gArea,0,0,2,class<`SpatialPolygons`>,1
+rgeos,gArea,0,0,3,class<`SpatialRings`>,1
+rgeos,gArea,1,0,0,logical,1
+rgeos,gBinarySTRtreeQuery,-1,0,0,list<integer[]>,1
+rgeos,gBinarySTRtreeQuery,-1,0,1,list<null | integer[]>,1
+rgeos,gBinarySTRtreeQuery,0,0,0,class<`SpatialPolygonsDataFrame`>,1
+rgeos,gBinarySTRtreeQuery,0,0,1,class<`SpatialLinesDataFrame`>,1
+rgeos,gBinarySTRtreeQuery,1,0,0,class<`SpatialPoints`>,1
+rgeos,gBinarySTRtreeQuery,1,0,1,class<`SpatialLines`>,1
+rgeos,gBinarySTRtreeQuery,1,0,2,class<`SpatialPolygons`>,1
+rgeos,gBoundary,-1,0,0,class<`SpatialLines`>,1
+rgeos,gBoundary,-1,0,1,class<`SpatialPoints`>,1
+rgeos,gBoundary,0,0,0,class<`SpatialPolygons`>,1
+rgeos,gBoundary,0,0,1,class<`SpatialLines`>,1
+rgeos,gBoundary,1,0,0,logical,1
+rgeos,gBoundary,2,0,0,null,1
+rgeos,gBuffer,-1,0,0,class<`SpatialPolygons`>,1
+rgeos,gBuffer,-1,0,1,class<`SpatialPolygonsDataFrame`>,1
+rgeos,gBuffer,0,0,0,class<`SpatialLines`>,1
+rgeos,gBuffer,0,0,1,class<`SpatialPolygons`>,1
+rgeos,gBuffer,0,0,2,class<`SpatialPolygonsDataFrame`>,1
+rgeos,gBuffer,1,0,0,logical,1
+rgeos,gBuffer,2,0,0,null,1
+rgeos,gBuffer,2,0,1,character[],1
+rgeos,gBuffer,3,0,0,double[],1
+rgeos,gBuffer,4,0,0,double,1
+rgeos,gBuffer,5,0,0,character,1
+rgeos,gBuffer,6,0,0,character,1
+rgeos,gBuffer,7,0,0,double,1
+rgeos,gCentroid,-1,0,0,class<`SpatialPoints`>,1
+rgeos,gCentroid,0,0,0,class<`SpatialPolygons`>,1
+rgeos,gCentroid,1,0,0,logical,1
+rgeos,gCentroid,2,0,0,null,1
+rgeos,gContains,-1,0,0,class<`matrix`>,1
+rgeos,gContains,-1,0,1,logical,1
+rgeos,gContains,0,0,0,class<`SpatialPolygons`>,1
+rgeos,gContains,0,0,1,class<`SpatialLines`>,1
+rgeos,gContains,1,0,0,class<`SpatialPolygons`>,1
+rgeos,gContains,1,0,1,class<`SpatialPoints`>,1
+rgeos,gContains,1,0,2,class<`SpatialLines`>,1
+rgeos,gContains,2,0,0,logical,1
+rgeos,gContains,3,0,0,logical,1
+rgeos,gContains,4,0,0,logical,1
+rgeos,gContains,5,0,0,logical,1
+rgeos,gContains,6,0,0,logical,1
+rgeos,gContainsProperly,-1,0,0,logical,1
+rgeos,gContainsProperly,0,0,0,class<`SpatialLines`>,1
+rgeos,gContainsProperly,0,0,1,class<`SpatialPolygons`>,1
+rgeos,gContainsProperly,1,0,0,class<`SpatialPoints`>,1
+rgeos,gContainsProperly,1,0,1,class<`SpatialLines`>,1
+rgeos,gContainsProperly,1,0,2,class<`SpatialPolygons`>,1
+rgeos,gContainsProperly,2,0,0,logical,1
+rgeos,gContainsProperly,3,0,0,logical,1
+rgeos,gContainsProperly,4,0,0,logical,1
+rgeos,gConvexHull,-1,0,0,class<`SpatialPolygons`>,1
+rgeos,gConvexHull,0,0,0,class<`SpatialPolygons`>,1
+rgeos,gConvexHull,1,0,0,logical,1
+rgeos,gConvexHull,2,0,0,null,1
+rgeos,gCoveredBy,-1,0,0,logical,1
+rgeos,gCoveredBy,0,0,0,class<`SpatialPolygons`>,1
+rgeos,gCoveredBy,1,0,0,class<`SpatialPolygons`>,1
+rgeos,gCoveredBy,2,0,0,logical,1
+rgeos,gCoveredBy,3,0,0,logical,1
+rgeos,gCoveredBy,4,0,0,logical,1
+rgeos,gCovers,-1,0,0,logical,1
+rgeos,gCovers,0,0,0,class<`SpatialLines`>,1
+rgeos,gCovers,0,0,1,class<`SpatialPolygons`>,1
+rgeos,gCovers,1,0,0,class<`SpatialPoints`>,1
+rgeos,gCovers,1,0,1,class<`SpatialLines`>,1
+rgeos,gCovers,1,0,2,class<`SpatialPolygons`>,1
+rgeos,gCovers,2,0,0,logical,1
+rgeos,gCovers,3,0,0,logical,1
+rgeos,gCovers,4,0,0,logical,1
+rgeos,gCrosses,-1,0,0,logical,1
+rgeos,gCrosses,0,0,0,class<`SpatialLines`>,1
+rgeos,gCrosses,0,0,1,class<`SpatialPolygons`>,1
+rgeos,gCrosses,1,0,0,class<`SpatialLines`>,1
+rgeos,gCrosses,1,0,1,class<`SpatialPoints`>,1
+rgeos,gCrosses,1,0,2,class<`SpatialPolygons`>,1
+rgeos,gCrosses,2,0,0,logical,1
+rgeos,gCrosses,3,0,0,logical,1
+rgeos,gCrosses,4,0,0,logical,1
+rgeos,gDelaunayTriangulation,-1,0,0,class<`SpatialLines`>,1
+rgeos,gDelaunayTriangulation,-1,0,1,class<`SpatialPolygons`>,1
+rgeos,gDelaunayTriangulation,0,0,0,class<`SpatialPointsDataFrame`>,1
+rgeos,gDelaunayTriangulation,1,0,0,double,1
+rgeos,gDelaunayTriangulation,2,0,0,logical,1
+rgeos,gDifference,-1,0,0,any,1
+rgeos,gDifference,0,0,0,class<`SpatialPolygons`>,1
+rgeos,gDifference,1,0,0,class<`SpatialPolygons`>,1
+rgeos,gDifference,2,0,0,logical,1
+rgeos,gDifference,3,0,0,null,1
+rgeos,gDifference,4,0,0,logical,1
+rgeos,gDifference,5,0,0,logical,1
+rgeos,gDifference,6,0,0,null,1
+rgeos,gDisjoint,-1,0,0,logical,1
+rgeos,gDisjoint,0,0,0,class<`SpatialLines`>,1
+rgeos,gDisjoint,0,0,1,class<`SpatialPolygons`>,1
+rgeos,gDisjoint,1,0,0,class<`SpatialPoints`>,1
+rgeos,gDisjoint,1,0,1,class<`SpatialLines`>,1
+rgeos,gDisjoint,1,0,2,class<`SpatialPolygons`>,1
+rgeos,gDisjoint,2,0,0,logical,1
+rgeos,gDisjoint,3,0,0,logical,1
+rgeos,gDisjoint,4,0,0,logical,1
+rgeos,gDistance,-1,0,0,class<`matrix`>,1
+rgeos,gDistance,-1,0,1,double,1
+rgeos,gDistance,0,0,0,class<`SpatialLines`>,1
+rgeos,gDistance,0,0,1,class<`SpatialPoints`>,1
+rgeos,gDistance,0,0,2,class<`SpatialPolygons`>,1
+rgeos,gDistance,1,0,0,class<`SpatialPolygons`>,1
+rgeos,gDistance,1,0,1,class<`SpatialPoints`>,1
+rgeos,gDistance,1,0,2,class<`SpatialLines`>,1
+rgeos,gDistance,1,0,3,null,1
+rgeos,gDistance,2,0,0,logical,1
+rgeos,gDistance,3,0,0,logical,1
+rgeos,gDistance,4,0,0,null,1
+rgeos,gEnvelope,-1,0,0,class<`SpatialPoints`>,1
+rgeos,gEnvelope,-1,0,1,class<`SpatialPolygons`>,1
+rgeos,gEnvelope,0,0,0,class<`SpatialPoints`>,1
+rgeos,gEnvelope,0,0,1,class<`SpatialLines`>,1
+rgeos,gEnvelope,0,0,2,class<`SpatialPolygons`>,1
+rgeos,gEnvelope,1,0,0,logical,1
+rgeos,gEnvelope,2,0,0,null,1
+rgeos,gEquals,-1,0,0,logical,1
+rgeos,gEquals,0,0,0,class<`SpatialLines`>,1
+rgeos,gEquals,0,0,1,class<`SpatialPoints`>,1
+rgeos,gEquals,0,0,2,class<`SpatialPolygons`>,1
+rgeos,gEquals,1,0,0,class<`SpatialLines`>,1
+rgeos,gEquals,1,0,1,class<`SpatialPoints`>,1
+rgeos,gEquals,1,0,2,class<`SpatialPolygons`>,1
+rgeos,gEquals,2,0,0,logical,1
+rgeos,gEquals,3,0,0,logical,1
+rgeos,gEquals,4,0,0,logical,1
+rgeos,gEqualsExact,-1,0,0,logical,1
+rgeos,gEqualsExact,0,0,0,class<`SpatialLines`>,1
+rgeos,gEqualsExact,0,0,1,class<`SpatialPoints`>,1
+rgeos,gEqualsExact,0,0,2,class<`SpatialPolygons`>,1
+rgeos,gEqualsExact,1,0,0,class<`SpatialLines`>,1
+rgeos,gEqualsExact,1,0,1,class<`SpatialPoints`>,1
+rgeos,gEqualsExact,1,0,2,class<`SpatialPolygons`>,1
+rgeos,gEqualsExact,2,0,0,double,1
+rgeos,gEqualsExact,3,0,0,logical,1
+rgeos,gEqualsExact,4,0,0,logical,1
+rgeos,gEqualsExact,5,0,0,logical,1
+rgeos,get.bbox,-1,0,0,list<double[]>,1
+rgeos,get.bbox,0,0,0,class<`gpc.poly`>,1
+rgeos,get.bbox,-1,1,0,list<double[]>,1
+rgeos,get.bbox,0,1,0,class<`gpc.poly`>,1
+rgeos,get_do_poly_check,-1,0,0,logical,1
+rgeos,get_RGEOS_CheckValidity,-1,0,0,integer,1
+rgeos,get_RGEOS_DENSE,-1,0,0,logical,1
+rgeos,get_RGEOS_dropSlivers,-1,0,0,logical,1
+rgeos,get_RGEOS_polyThreshold,-1,0,0,double,1
+rgeos,get_RGEOS_STR,-1,0,0,logical,1
+rgeos,get_RGEOS_warnSlivers,-1,0,0,logical,1
+rgeos,getScale,-1,0,0,double,1
+rgeos,gInterpolate,-1,0,0,any,1
+rgeos,gInterpolate,0,0,0,class<`SpatialLines`>,1
+rgeos,gInterpolate,0,0,1,class<`SpatialLinesDataFrame`>,1
+rgeos,gInterpolate,1,0,0,double[],1
+rgeos,gInterpolate,2,0,0,logical,1
+rgeos,gIntersection,-1,0,0,any,1
+rgeos,gIntersection,0,0,0,class<`SpatialLines`>,1
+rgeos,gIntersection,0,0,1,class<`SpatialPolygons`>,1
+rgeos,gIntersection,0,0,2,class<`SpatialLinesDataFrame`>,1
+rgeos,gIntersection,1,0,0,class<`SpatialLines`>,1
+rgeos,gIntersection,1,0,1,class<`SpatialPolygons`>,1
+rgeos,gIntersection,2,0,0,logical,1
+rgeos,gIntersection,3,0,0,null,1
+rgeos,gIntersection,4,0,0,any,1
+rgeos,gIntersection,5,0,0,logical,1
+rgeos,gIntersection,6,0,0,logical,1
+rgeos,gIntersection,7,0,0,null,1
+rgeos,gIntersection,7,0,1,integer,1
+rgeos,gIntersects,-1,0,0,class<`matrix`>,1
+rgeos,gIntersects,-1,0,1,logical,1
+rgeos,gIntersects,0,0,0,class<`SpatialPoints`>,1
+rgeos,gIntersects,0,0,1,class<`SpatialPolygons`>,1
+rgeos,gIntersects,0,0,2,class<`SpatialLines`>,1
+rgeos,gIntersects,1,0,0,class<`SpatialPolygons`>,1
+rgeos,gIntersects,1,0,1,class<`SpatialPoints`>,1
+rgeos,gIntersects,1,0,2,class<`SpatialLines`>,1
+rgeos,gIntersects,2,0,0,logical[],1
+rgeos,gIntersects,3,0,0,logical,1
+rgeos,gIntersects,4,0,0,logical,1
+rgeos,gIntersects,5,0,0,logical,1
+rgeos,gIsEmpty,-1,0,0,any,1
+rgeos,gIsEmpty,0,0,0,any,1
+rgeos,gIsEmpty,1,0,0,logical,1
+rgeos,gIsRing,-1,0,0,logical,1
+rgeos,gIsRing,0,0,0,class<`SpatialLines`>,1
+rgeos,gIsRing,0,0,1,class<`SpatialPolygons`>,1
+rgeos,gIsRing,0,0,2,class<`SpatialRings`>,1
+rgeos,gIsRing,1,0,0,logical,1
+rgeos,gIsSimple,-1,0,0,logical,1
+rgeos,gIsSimple,0,0,0,class<`SpatialLines`>,1
+rgeos,gIsSimple,0,0,1,class<`SpatialPoints`>,1
+rgeos,gIsSimple,0,0,2,class<`SpatialPolygons`>,1
+rgeos,gIsSimple,1,0,0,logical,1
+rgeos,gIsValid,-1,0,0,character,1
+rgeos,gIsValid,-1,0,1,logical[],1
+rgeos,gIsValid,0,0,0,class<`SpatialPolygons`>,1
+rgeos,gIsValid,0,0,1,class<`SpatialRings`>,1
+rgeos,gIsValid,1,0,0,logical,1
+rgeos,gIsValid,2,0,0,logical,1
+rgeos,gLength,-1,0,0,double,1
+rgeos,gLength,0,0,0,class<`SpatialLines`>,1
+rgeos,gLength,0,0,1,class<`SpatialPoints`>,1
+rgeos,gLength,0,0,2,class<`SpatialPolygons`>,1
+rgeos,gLength,1,0,0,logical,1
+rgeos,gLineMerge,-1,0,0,class<`SpatialLines`>,1
+rgeos,gLineMerge,0,0,0,class<`SpatialLines`>,1
+rgeos,gLineMerge,1,0,0,logical,1
+rgeos,gLineMerge,2,0,0,null,1
+rgeos,gNearestPoints,-1,0,0,class<`SpatialPoints`>,1
+rgeos,gNearestPoints,-1,0,1,null,1
+rgeos,gNearestPoints,0,0,0,class<`SpatialLines`>,1
+rgeos,gNearestPoints,0,0,1,class<`SpatialPoints`>,1
+rgeos,gNearestPoints,0,0,2,class<`SpatialPointsDataFrame`>,1
+rgeos,gNearestPoints,1,0,0,class<`SpatialPoints`>,1
+rgeos,gNearestPoints,1,0,1,class<`SpatialLines`>,1
+rgeos,gNearestPoints,1,0,2,class<`SpatialPolygons`>,1
+rgeos,gNearestPoints,1,0,3,class<`SpatialLinesDataFrame`>,1
+rgeos,gNode,-1,0,0,class<`SpatialLines`>,1
+rgeos,gNode,0,0,0,class<`SpatialLines`>,1
+rgeos,gOverlaps,-1,0,0,logical,1
+rgeos,gOverlaps,0,0,0,class<`SpatialLines`>,1
+rgeos,gOverlaps,0,0,1,class<`SpatialPolygons`>,1
+rgeos,gOverlaps,1,0,0,class<`SpatialLines`>,1
+rgeos,gOverlaps,1,0,1,class<`SpatialPoints`>,1
+rgeos,gOverlaps,1,0,2,class<`SpatialPolygons`>,1
+rgeos,gOverlaps,2,0,0,logical,1
+rgeos,gOverlaps,3,0,0,logical,1
+rgeos,gOverlaps,4,0,0,logical,1
+rgeos,gPointOnSurface,-1,0,0,any,1
+rgeos,gPointOnSurface,0,0,0,class<`SpatialLines`>,1
+rgeos,gPointOnSurface,0,0,1,class<`SpatialPoints`>,1
+rgeos,gPointOnSurface,0,0,2,class<`SpatialPolygons`>,1
+rgeos,gPointOnSurface,1,0,0,logical,1
+rgeos,gPointOnSurface,2,0,0,null,1
+rgeos,gPolygonize,-1,0,0,class<`SpatialLines`>,1
+rgeos,gPolygonize,-1,0,1,class<`SpatialPolygons`>,1
+rgeos,gPolygonize,-1,0,2,null,1
+rgeos,gPolygonize,0,0,0,list<class<`SpatialLines`>>,1
+rgeos,gPolygonize,0,0,1,class<`SpatialLines`>,1
+rgeos,gPolygonize,1,0,0,logical,1
+rgeos,gProject,-1,0,0,any,1
+rgeos,gProject,0,0,0,class<`SpatialLines`>,1
+rgeos,gProject,0,0,1,class<`SpatialLinesDataFrame`>,1
+rgeos,gProject,1,0,0,class<`SpatialPoints`>,1
+rgeos,gProject,1,0,1,class<`SpatialPointsDataFrame`>,1
+rgeos,gProject,2,0,0,logical,1
+rgeos,gRelate,-1,0,0,character,1
+rgeos,gRelate,0,0,0,class<`SpatialPolygons`>,1
+rgeos,gRelate,1,0,0,class<`SpatialPolygons`>,1
+rgeos,gRelate,2,0,0,null,1
+rgeos,gRelate,3,0,0,logical,1
+rgeos,gRelate,4,0,0,logical,1
+rgeos,gSimplify,-1,0,0,class<`SpatialLines`>,1
+rgeos,gSimplify,-1,0,1,class<`SpatialPolygons`>,1
+rgeos,gSimplify,0,0,0,class<`SpatialLines`>,1
+rgeos,gSimplify,0,0,1,class<`SpatialPolygons`>,1
+rgeos,gSimplify,1,0,0,double,1
+rgeos,gSimplify,2,0,0,logical,1
+rgeos,gSymdifference,-1,0,0,any,1
+rgeos,gSymdifference,0,0,0,class<`SpatialPolygons`>,1
+rgeos,gSymdifference,1,0,0,class<`SpatialPolygons`>,1
+rgeos,gSymdifference,2,0,0,logical,1
+rgeos,gSymdifference,3,0,0,null,1
+rgeos,gSymdifference,4,0,0,logical,1
+rgeos,gSymdifference,5,0,0,logical,1
+rgeos,gSymdifference,6,0,0,null,1
+rgeos,gTopoDim,-1,0,0,integer,1
+rgeos,gTopoDim,0,0,0,class<`SpatialLines`>,1
+rgeos,gTopoDim,0,0,1,class<`SpatialLinesDataFrame`>,1
+rgeos,gTopoDim,0,0,2,class<`SpatialPolygons`>,1
+rgeos,gTouches,-1,0,0,class<`matrix`>,1
+rgeos,gTouches,-1,0,1,logical,1
+rgeos,gTouches,0,0,0,class<`SpatialPointsDataFrame`>,1
+rgeos,gTouches,0,0,1,class<`SpatialLines`>,1
+rgeos,gTouches,0,0,2,class<`SpatialPolygons`>,1
+rgeos,gTouches,1,0,0,class<`SpatialLines`>,1
+rgeos,gTouches,1,0,1,class<`SpatialPolygons`>,1
+rgeos,gTouches,2,0,0,logical,1
+rgeos,gTouches,3,0,0,logical,1
+rgeos,gTouches,4,0,0,logical,1
+rgeos,gUnarySTRtreeQuery,-1,0,0,list<integer[] | null>,1
+rgeos,gUnarySTRtreeQuery,-1,0,1,list<null | integer[]>,1
+rgeos,gUnarySTRtreeQuery,0,0,0,class<`SpatialPolygonsDataFrame`>,1
+rgeos,gUnarySTRtreeQuery,0,0,1,class<`Polygons`>,1
+rgeos,gUnarySTRtreeQuery,0,0,2,class<`SpatialLinesDataFrame`>,1
+rgeos,gUnaryUnion,-1,0,0,class<`SpatialPolygons`>,1
+rgeos,gUnaryUnion,0,0,0,class<`SpatialPolygons`>,1
+rgeos,gUnaryUnion,0,0,1,class<`SpatialPolygonsDataFrame`>,1
+rgeos,gUnaryUnion,1,0,0,character[],1
+rgeos,gUnaryUnion,1,0,1,class<`factor`>,1
+rgeos,gUnaryUnion,2,0,0,integer,1
+rgeos,gUnaryUnion,2,0,1,null,1
+rgeos,gUnion,-1,0,0,any,1
+rgeos,gUnion,0,0,0,class<`SpatialPolygons`>,1
+rgeos,gUnion,1,0,0,class<`SpatialPolygons`>,1
+rgeos,gUnion,2,0,0,logical,1
+rgeos,gUnion,3,0,0,null,1
+rgeos,gUnion,4,0,0,logical,1
+rgeos,gUnion,5,0,0,logical,1
+rgeos,gUnion,6,0,0,null,1
+rgeos,gWithin,-1,0,0,logical,1
+rgeos,gWithin,0,0,0,class<`SpatialPolygons`>,1
+rgeos,gWithin,1,0,0,class<`SpatialPolygons`>,1
+rgeos,gWithin,2,0,0,logical,1
+rgeos,gWithin,3,0,0,logical,1
+rgeos,gWithin,4,0,0,logical,1
+rgeos,init_RGEOS,-1,0,0,externalptr,1
+rgeos,intersect,-1,0,0,class<`gpc.poly`>,1
+rgeos,intersect,0,0,0,class<`gpc.poly.nohole`>,1
+rgeos,intersect,1,0,0,class<`gpc.poly.nohole`>,1
+rgeos,intersect,-1,1,0,class<`gpc.poly`>,1
+rgeos,intersect,0,1,0,class<`gpc.poly`>,1
+rgeos,intersect,1,1,0,class<`gpc.poly`>,1
+rgeos,labpos.maxdist,-1,0,0,double[],1
+rgeos,labpos.maxdist,0,0,0,class<`SpatialPolygons`>,1
+rgeos,labpos.maxdist,1,0,0,double,1
+rgeos,labpos.maxdist,2,0,0,double,1
+rgeos,labpos.maxdist,3,0,0,double,1
+rgeos,listifyMatrix,-1,0,0,list<integer>,1
+rgeos,listifyMatrix,0,0,0,integer,1
+rgeos,notAllComments,-1,0,0,logical,1
+rgeos,notAllComments,0,0,0,class<`SpatialPolygons`>,1
+rgeos,overGeomGeom,-1,0,0,integer,1
+rgeos,overGeomGeom,0,0,0,class<`SpatialPolygons`>,1
+rgeos,overGeomGeom,1,0,0,class<`SpatialPolygons`>,1
+rgeos,overGeomGeom,2,0,0,logical,1
+rgeos,overGeomGeom,3,0,0,null,1
+rgeos,overGeomGeom,4,0,0,...,1
+rgeos,overGeomGeom,5,0,0,double,1
+rgeos,plot,-1,0,0,list<null>,1
+rgeos,plot,0,0,0,class<`gpc.poly`>,1
+rgeos,plot,1,0,0,any,1
+rgeos,plot,2,0,0,...,1
+rgeos,plot,-1,1,0,null,1
+rgeos,plot,0,1,0,class<`SpatialRings`>,1
+rgeos,plot,1,1,0,any,1
+rgeos,plot,2,1,0,...,1
+rgeos,plotSpatialRings,-1,0,0,null,1
+rgeos,plotSpatialRings,0,0,0,class<`SpatialRings`>,1
+rgeos,plotSpatialRings,1,0,0,null,1
+rgeos,plotSpatialRings,2,0,0,null,1
+rgeos,plotSpatialRings,3,0,0,double,1
+rgeos,plotSpatialRings,4,0,0,double,1
+rgeos,plotSpatialRings,5,0,0,double,1
+rgeos,plotSpatialRings,6,0,0,logical,1
+rgeos,plotSpatialRings,7,0,0,logical,1
+rgeos,plotSpatialRings,8,0,0,...,1
+rgeos,plotSpatialRings,9,0,0,logical,1
+rgeos,poly_findInBoxGEOS,-1,0,0,list<integer[] | null>,1
+rgeos,poly_findInBoxGEOS,0,0,0,class<`SpatialPolygonsDataFrame`>,1
+rgeos,poly_findInBoxGEOS,1,0,0,logical,1
+rgeos,polygonsLabel,-1,0,0,class<`matrix`>,1
+rgeos,polygonsLabel,0,0,0,class<`SpatialPolygons`>,1
+rgeos,polygonsLabel,1,0,0,character[],1
+rgeos,polygonsLabel,2,0,0,character,1
+rgeos,polygonsLabel,3,0,0,double,1
+rgeos,polygonsLabel,4,0,0,character,1
+rgeos,polygonsLabel,5,0,0,double,1
+rgeos,polygonsLabel,6,0,0,logical,1
+rgeos,polygonsLabel,7,0,0,...,1
+rgeos,read.polyfile,-1,0,0,class<`gpc.poly`>,1
+rgeos,read.polyfile,-1,0,1,class<`gpc.poly.nohole`>,1
+rgeos,read.polyfile,0,0,0,character,1
+rgeos,read.polyfile,1,0,0,logical,1
+rgeos,readWKT,-1,0,0,any,1
+rgeos,readWKT,0,0,0,character,1
+rgeos,readWKT,1,0,0,null,1
+rgeos,readWKT,2,0,0,null,1
+rgeos,RGEOSBinPredFunc,-1,0,0,character,1
+rgeos,RGEOSBinPredFunc,-1,0,1,class<`matrix`>,1
+rgeos,RGEOSBinPredFunc,-1,0,2,logical,1
+rgeos,RGEOSBinPredFunc,0,0,0,class<`SpatialPolygons`>,1
+rgeos,RGEOSBinPredFunc,0,0,1,class<`SpatialPoints`>,1
+rgeos,RGEOSBinPredFunc,0,0,2,class<`SpatialPointsDataFrame`>,1
+rgeos,RGEOSBinPredFunc,0,0,3,class<`SpatialLines`>,1
+rgeos,RGEOSBinPredFunc,1,0,0,class<`SpatialPolygons`>,1
+rgeos,RGEOSBinPredFunc,1,0,1,class<`SpatialLines`>,1
+rgeos,RGEOSBinPredFunc,1,0,2,class<`SpatialPoints`>,1
+rgeos,RGEOSBinPredFunc,2,0,0,logical[],1
+rgeos,RGEOSBinPredFunc,3,0,0,character,1
+rgeos,RGEOSBinPredFunc,4,0,0,null,1
+rgeos,RGEOSBinPredFunc,4,0,1,double,1
+rgeos,RGEOSBinTopoFunc,-1,0,0,any,1
+rgeos,RGEOSBinTopoFunc,0,0,0,class<`SpatialLines`>,1
+rgeos,RGEOSBinTopoFunc,0,0,1,class<`SpatialPolygons`>,1
+rgeos,RGEOSBinTopoFunc,0,0,2,class<`SpatialLinesDataFrame`>,1
+rgeos,RGEOSBinTopoFunc,1,0,0,class<`SpatialLines`>,1
+rgeos,RGEOSBinTopoFunc,1,0,1,class<`SpatialPolygons`>,1
+rgeos,RGEOSBinTopoFunc,2,0,0,logical,1
+rgeos,RGEOSBinTopoFunc,3,0,0,null,1
+rgeos,RGEOSBinTopoFunc,4,0,0,logical,1
+rgeos,RGEOSBinTopoFunc,5,0,0,logical,1
+rgeos,RGEOSBinTopoFunc,6,0,0,character,1
+rgeos,RGEOSDistanceFunc,-1,0,0,class<`matrix`>,1
+rgeos,RGEOSDistanceFunc,-1,0,1,double,1
+rgeos,RGEOSDistanceFunc,0,0,0,class<`SpatialLines`>,1
+rgeos,RGEOSDistanceFunc,0,0,1,class<`SpatialPoints`>,1
+rgeos,RGEOSDistanceFunc,0,0,2,class<`SpatialPolygons`>,1
+rgeos,RGEOSDistanceFunc,1,0,0,class<`SpatialPolygons`>,1
+rgeos,RGEOSDistanceFunc,1,0,1,class<`SpatialPoints`>,1
+rgeos,RGEOSDistanceFunc,1,0,2,class<`SpatialLines`>,1
+rgeos,RGEOSDistanceFunc,1,0,3,null,1
+rgeos,RGEOSDistanceFunc,2,0,0,logical,1
+rgeos,RGEOSDistanceFunc,3,0,0,character,1
+rgeos,RGEOSDistanceFunc,4,0,0,double,1
+rgeos,RGEOSMiscFunc,-1,0,0,double[],1
+rgeos,RGEOSMiscFunc,0,0,0,class<`SpatialLines`>,1
+rgeos,RGEOSMiscFunc,0,0,1,class<`SpatialPoints`>,1
+rgeos,RGEOSMiscFunc,0,0,2,class<`SpatialPolygons`>,1
+rgeos,RGEOSMiscFunc,0,0,3,class<`SpatialRings`>,1
+rgeos,RGEOSMiscFunc,1,0,0,logical,1
+rgeos,RGEOSMiscFunc,2,0,0,character,1
+rgeos,RGEOSUnaryPredFunc,-1,0,0,any,1
+rgeos,RGEOSUnaryPredFunc,0,0,0,any,1
+rgeos,RGEOSUnaryPredFunc,1,0,0,logical,1
+rgeos,RGEOSUnaryPredFunc,2,0,0,character,1
+rgeos,Ring,-1,0,0,class<`Ring`>,1
+rgeos,Ring,0,0,0,class<`matrix`>,1
+rgeos,Ring,1,0,0,character,1
+rgeos,row.names,-1,0,0,character[],1
+rgeos,row.names,0,0,0,class<`SpatialRings`>,1
+rgeos,setdiff,-1,0,0,class<`gpc.poly`>,1
+rgeos,setdiff,0,0,0,class<`gpc.poly.nohole`>,1
+rgeos,setdiff,1,0,0,class<`gpc.poly.nohole`>,1
+rgeos,set_RGEOS_DENSE,-1,0,0,logical,1
+rgeos,set_RGEOS_DENSE,0,0,0,logical,1
+rgeos,set_RGEOS_dropSlivers,-1,0,0,logical,1
+rgeos,set_RGEOS_dropSlivers,0,0,0,logical,1
+rgeos,set_RGEOS_HANDLE,-1,0,0,externalptr,1
+rgeos,set_RGEOS_HANDLE,0,0,0,externalptr,1
+rgeos,set_RGEOS_polyThreshold,-1,0,0,double,1
+rgeos,set_RGEOS_polyThreshold,0,0,0,double,1
+rgeos,set_RGEOS_STR,-1,0,0,logical,1
+rgeos,set_RGEOS_STR,0,0,0,logical,1
+rgeos,set_RGEOS_warnSlivers,-1,0,0,logical,1
+rgeos,set_RGEOS_warnSlivers,0,0,0,logical,1
+rgeos,setScale,-1,0,0,double,1
+rgeos,setScale,0,0,0,double,1
+rgeos,SpatialRings,-1,0,0,class<`SpatialRings`>,1
+rgeos,SpatialRings,0,0,0,list<class<`Ring`>>,1
+rgeos,SpatialRings,1,0,0,class<`CRS`>,1
+rgeos,TopologyFunc,-1,0,0,any,1
+rgeos,TopologyFunc,0,0,0,class<`SpatialPolygons`>,1
+rgeos,TopologyFunc,0,0,1,class<`SpatialLines`>,1
+rgeos,TopologyFunc,0,0,2,class<`SpatialPoints`>,1
+rgeos,TopologyFunc,1,0,0,null,1
+rgeos,TopologyFunc,2,0,0,logical,1
+rgeos,TopologyFunc,3,0,0,character,1
+rgeos,translate,-1,0,0,class<`SpatialLines`>,1
+rgeos,translate,-1,0,1,class<`SpatialPoints`>,1
+rgeos,translate,-1,0,2,class<`SpatialPolygons`>,1
+rgeos,translate,-1,0,3,class<`SpatialRings`>,1
+rgeos,translate,0,0,0,class<`SpatialLines`>,1
+rgeos,translate,0,0,1,class<`SpatialPoints`>,1
+rgeos,translate,0,0,2,class<`SpatialPolygons`>,1
+rgeos,translate,0,0,3,class<`SpatialRings`>,1
+rgeos,union,-1,0,0,class<`gpc.poly`>,1
+rgeos,union,0,0,0,class<`gpc.poly.nohole`>,1
+rgeos,union,1,0,0,class<`gpc.poly.nohole`>,1
+rgeos,version_GEOS,-1,0,0,character,1
+rgeos,version_GEOS,0,0,0,logical,1
+rgeos,version_GEOS0,-1,0,0,character,1
+rgeos,version_sp_linkingTo,-1,0,0,character,1
+rgeos,writeWKT,-1,0,0,character[],1
+rgeos,writeWKT,0,0,0,class<`SpatialCollections`>,1
+rgeos,writeWKT,0,0,1,class<`SpatialLines`>,1
+rgeos,writeWKT,0,0,2,class<`SpatialPoints`>,1
+rgeos,writeWKT,0,0,3,class<`SpatialPolygons`>,1
+rgeos,writeWKT,1,0,0,logical,1
+rio,characterize,-1,0,0,^character[],1
+rio,characterize,-1,0,1,class<`data.frame`>,1
+rio,characterize,0,0,0,class<`data.frame`>,1
+rio,characterize,0,0,1,double[],1
+rio,characterize,1,0,0,...,1
+rio,characterize.data.frame,-1,0,0,class<`data.frame`>,1
+rio,characterize.data.frame,0,0,0,class<`data.frame`>,1
+rio,characterize.data.frame,1,0,0,...,1
+rio,characterize.default,-1,0,0,^character[],1
+rio,characterize.default,0,0,0,double[],1
+rio,characterize.default,1,0,0,...,1
+rio,compress_out,-1,0,0,character,1
+rio,compress_out,0,0,0,character,1
+rio,compress_out,1,0,0,"class<`character`, `rio_csv`>",1
+rio,compress_out,2,0,0,character,1
+rio,convert,-1,0,0,character,1
+rio,convert,0,0,0,character,1
+rio,convert,1,0,0,character,1
+rio,convert,2,0,0,list<any>,1
+rio,convert,3,0,0,list<any>,1
+rio,export,-1,0,0,character,1
+rio,export,0,0,0,character[],1
+rio,export,0,0,1,class<`data.frame`>,1
+rio,export,0,0,2,list<class<`data.frame`>>,1
+rio,export,1,0,0,any,1
+rio,export,2,0,0,any,1
+rio,export,3,0,0,...,1
+rio,.export,-1,0,0,character,1
+rio,.export,-1,0,1,class<`data.frame`>,1
+rio,.export,-1,0,2,class<`Workbook`>,1
+rio,.export,-1,0,3,null,1
+rio,.export,0,0,0,"class<`character`, `rio_dump`>",1
+rio,.export,0,0,1,"class<`character`, `rio_dta`>",1
+rio,.export,0,0,2,"class<`character`, `rio_sav`>",1
+rio,.export,0,0,3,"class<`character`, `rio_xlsx`>",1
+rio,.export,0,0,4,"class<`character`, `rio_csv`>",1
+rio,.export,0,0,5,"class<`character`, `rio_json`>",1
+rio,.export,0,0,6,"class<`character`, `rio_rdata`>",1
+rio,.export,0,0,7,"class<`character`, `rio_rds`>",1
+rio,.export,0,0,8,"class<`character`, `rio_tsv`>",1
+rio,.export,1,0,0,class<`data.frame`>,1
+rio,.export,1,0,1,list<class<`data.frame`>>,1
+rio,.export,1,0,2,character[],1
+rio,.export,2,0,0,...,1
+rio,export_delim,-1,0,0,null,1
+rio,export_delim,0,0,0,"class<`character`, `rio_csv`>",1
+rio,export_delim,0,0,1,"class<`character`, `rio_tsv`>",1
+rio,export_delim,1,0,0,class<`data.frame`>,1
+rio,export_delim,2,0,0,logical,1
+rio,export_delim,3,0,0,character,1
+rio,export_delim,4,0,0,logical,1
+rio,export_delim,5,0,0,logical,1
+rio,export_delim,6,0,0,...,1
+rio,.export.rio_csv,-1,0,0,null,1
+rio,.export.rio_csv,0,0,0,"class<`character`, `rio_csv`>",1
+rio,.export.rio_csv,1,0,0,class<`data.frame`>,1
+rio,.export.rio_csv,2,0,0,character,1
+rio,.export.rio_csv,3,0,0,character,1
+rio,.export.rio_csv,4,0,0,...,1
+rio,.export.rio_dta,-1,0,0,class<`data.frame`>,1
+rio,.export.rio_dta,0,0,0,"class<`character`, `rio_dta`>",1
+rio,.export.rio_dta,1,0,0,class<`data.frame`>,1
+rio,.export.rio_dta,2,0,0,...,1
+rio,.export.rio_dump,-1,0,0,character,1
+rio,.export.rio_dump,0,0,0,"class<`character`, `rio_dump`>",1
+rio,.export.rio_dump,1,0,0,class<`data.frame`>,1
+rio,.export.rio_dump,2,0,0,...,1
+rio,.export.rio_json,-1,0,0,null,1
+rio,.export.rio_json,0,0,0,"class<`character`, `rio_json`>",1
+rio,.export.rio_json,1,0,0,class<`data.frame`>,1
+rio,.export.rio_json,2,0,0,...,1
+rio,.export.rio_rdata,-1,0,0,null,1
+rio,.export.rio_rdata,0,0,0,"class<`character`, `rio_rdata`>",1
+rio,.export.rio_rdata,1,0,0,character[],1
+rio,.export.rio_rdata,1,0,1,list<class<`data.frame`>>,1
+rio,.export.rio_rdata,2,0,0,...,1
+rio,.export.rio_rds,-1,0,0,null,1
+rio,.export.rio_rds,0,0,0,"class<`character`, `rio_rds`>",1
+rio,.export.rio_rds,1,0,0,class<`data.frame`>,1
+rio,.export.rio_rds,2,0,0,...,1
+rio,.export.rio_sav,-1,0,0,class<`data.frame`>,1
+rio,.export.rio_sav,0,0,0,"class<`character`, `rio_sav`>",1
+rio,.export.rio_sav,1,0,0,class<`data.frame`>,1
+rio,.export.rio_sav,2,0,0,...,1
+rio,.export.rio_tsv,-1,0,0,null,1
+rio,.export.rio_tsv,0,0,0,"class<`character`, `rio_tsv`>",1
+rio,.export.rio_tsv,1,0,0,class<`data.frame`>,1
+rio,.export.rio_tsv,2,0,0,...,1
+rio,.export.rio_xlsx,-1,0,0,class<`Workbook`>,1
+rio,.export.rio_xlsx,0,0,0,"class<`character`, `rio_xlsx`>",1
+rio,.export.rio_xlsx,1,0,0,list<class<`data.frame`>>,1
+rio,.export.rio_xlsx,2,0,0,any,1
+rio,.export.rio_xlsx,3,0,0,...,1
+rio,factorize,-1,0,0,class<`data.frame`>,1
+rio,factorize,-1,0,1,class<`factor`>,1
+rio,factorize,0,0,0,class<`data.frame`>,1
+rio,factorize,0,0,1,double[],1
+rio,factorize,1,0,0,...,1
+rio,factorize.data.frame,-1,0,0,class<`data.frame`>,1
+rio,factorize.data.frame,0,0,0,class<`data.frame`>,1
+rio,factorize.data.frame,1,0,0,...,1
+rio,factorize.default,-1,0,0,class<`factor`>,1
+rio,factorize.default,0,0,0,double[],1
+rio,factorize.default,1,0,0,...,1
+rio,find_compress,-1,0,0,list<character>,1
+rio,find_compress,-1,0,1,list<character | null>,1
+rio,find_compress,0,0,0,character,1
+rio,gather_attrs,-1,0,0,class<`data.frame`>,1
+rio,gather_attrs,0,0,0,class<`data.frame`>,1
+rio,get_ext,-1,0,0,character,1
+rio,get_ext,0,0,0,character,1
+rio,get_type,-1,0,0,character,1
+rio,get_type,0,0,0,character,1
+rio,import,-1,0,0,class<`data.frame`>,1
+rio,import,-1,0,1,"class<`data.frame`, `data.table`>",1
+rio,import,-1,0,2,"class<`data.frame`, `tbl`, `tbl_df`>",1
+rio,import,0,0,0,character,1
+rio,import,1,0,0,any,1
+rio,import,2,0,0,any,1
+rio,import,3,0,0,any,1
+rio,import,4,0,0,...,1
+rio,.import,-1,0,0,class<`data.frame`>,1
+rio,.import,-1,0,1,"class<`data.frame`, `tbl`, `tbl_df`>",1
+rio,.import,0,0,0,"class<`character`, `rio_csv`>",1
+rio,.import,0,0,1,"class<`character`, `rio_rds`>",1
+rio,.import,0,0,2,"class<`character`, `rio_tsv`>",1
+rio,.import,0,0,3,"class<`character`, `rio_dta`>",1
+rio,.import,0,0,4,"class<`character`, `rio_sav`>",1
+rio,.import,0,0,5,"class<`character`, `rio_xlsx`>",1
+rio,.import,1,0,0,...,1
+rio,import_delim,-1,0,0,class<`data.frame`>,1
+rio,import_delim,0,0,0,"class<`character`, `rio_csv`>",1
+rio,import_delim,0,0,1,"class<`character`, `rio_tsv`>",1
+rio,import_delim,1,0,0,double,1
+rio,import_delim,2,0,0,logical,1
+rio,import_delim,3,0,0,character,1
+rio,import_delim,4,0,0,character,1
+rio,import_delim,5,0,0,logical,1
+rio,import_delim,6,0,0,logical,1
+rio,import_delim,7,0,0,...,1
+rio,import_list,-1,0,0,class<`data.frame`>,1
+rio,import_list,-1,0,1,list<class<`data.frame`>>,1
+rio,import_list,0,0,0,character[],1
+rio,import_list,1,0,0,any,1
+rio,import_list,2,0,0,any,1
+rio,import_list,3,0,0,logical,1
+rio,import_list,4,0,0,character,1
+rio,import_list,5,0,0,logical,1
+rio,import_list,6,0,0,...,1
+rio,.import.rio_csv,-1,0,0,class<`data.frame`>,1
+rio,.import.rio_csv,0,0,0,"class<`character`, `rio_csv`>",1
+rio,.import.rio_csv,1,0,0,character,1
+rio,.import.rio_csv,2,0,0,double,1
+rio,.import.rio_csv,3,0,0,logical,1
+rio,.import.rio_csv,4,0,0,character,1
+rio,.import.rio_csv,5,0,0,...,1
+rio,.import.rio_dta,-1,0,0,"class<`data.frame`, `tbl`, `tbl_df`>",1
+rio,.import.rio_dta,0,0,0,"class<`character`, `rio_dta`>",1
+rio,.import.rio_dta,1,0,0,logical,1
+rio,.import.rio_dta,2,0,0,logical,1
+rio,.import.rio_dta,3,0,0,logical,1
+rio,.import.rio_dta,4,0,0,logical,1
+rio,.import.rio_dta,5,0,0,...,1
+rio,.import.rio_rds,-1,0,0,class<`data.frame`>,1
+rio,.import.rio_rds,0,0,0,"class<`character`, `rio_rds`>",1
+rio,.import.rio_rds,1,0,0,double,1
+rio,.import.rio_rds,2,0,0,...,1
+rio,.import.rio_sav,-1,0,0,"class<`data.frame`, `tbl`, `tbl_df`>",1
+rio,.import.rio_sav,0,0,0,"class<`character`, `rio_sav`>",1
+rio,.import.rio_sav,1,0,0,double,1
+rio,.import.rio_sav,2,0,0,logical,1
+rio,.import.rio_sav,3,0,0,logical,1
+rio,.import.rio_sav,4,0,0,logical,1
+rio,.import.rio_sav,5,0,0,...,1
+rio,.import.rio_tsv,-1,0,0,class<`data.frame`>,1
+rio,.import.rio_tsv,0,0,0,"class<`character`, `rio_tsv`>",1
+rio,.import.rio_tsv,1,0,0,character,1
+rio,.import.rio_tsv,2,0,0,double,1
+rio,.import.rio_tsv,3,0,0,logical,1
+rio,.import.rio_tsv,4,0,0,character,1
+rio,.import.rio_tsv,5,0,0,...,1
+rio,.import.rio_xlsx,-1,0,0,"class<`data.frame`, `tbl`, `tbl_df`>",1
+rio,.import.rio_xlsx,0,0,0,"class<`character`, `rio_xlsx`>",1
+rio,.import.rio_xlsx,1,0,0,character,1
+rio,.import.rio_xlsx,1,0,1,integer,1
+rio,.import.rio_xlsx,2,0,0,logical,1
+rio,.import.rio_xlsx,3,0,0,...,1
+rio,remote_to_local,-1,0,0,character,1
+rio,remote_to_local,0,0,0,character,1
+rio,remote_to_local,1,0,0,any,1
+rio,restore_labelled,-1,0,0,class<`data.frame`>,1
+rio,restore_labelled,0,0,0,class<`data.frame`>,1
+rio,set_class,-1,0,0,class<`data.frame`>,1
+rio,set_class,-1,0,1,"class<`data.frame`, `data.table`>",1
+rio,set_class,-1,0,2,"class<`data.frame`, `tbl`, `tbl_df`>",1
+rio,set_class,0,0,0,"class<`data.frame`, `tbl`, `tbl_df`>",1
+rio,set_class,0,0,1,class<`data.frame`>,1
+rio,set_class,0,0,2,"class<`data.frame`, `data.table`>",1
+rio,set_class,1,0,0,character,1
+rio,standardize_attributes,-1,0,0,"class<`data.frame`, `tbl`, `tbl_df`>",1
+rio,standardize_attributes,0,0,0,"class<`data.frame`, `tbl`, `tbl_df`>",1
+rlist,args_env,-1,0,0,environment,1
+rlist,args_env,0,0,0,...,1
+rlist,args_env,1,0,0,environment,1
+rlist,createCallClosure,-1,0,0,class<`function`>,1
+rlist,createCallClosure,0,0,0,any,1
+rlist,createListClosure,-1,0,0,class<`function`>,1
+rlist,createListClosure,0,0,0,any,1
+rlist,createListClosure,1,0,0,any,1
+rlist,dots,-1,0,0,list<class<`call`>>,1
+rlist,dots,-1,0,1,list<class<`name`> | class<`call`>>,1
+rlist,dots,-1,0,2,list<class<`name`>>,1
+rlist,dots,-1,0,3,list<class<`name`> | class<`(`>>,1
+rlist,dots,0,0,0,...,1
+rlist,.evalwith,-1,0,0,null,1
+rlist,.evalwith,-1,0,1,list<double | character[] | list<double>>,1
+rlist,.evalwith,-1,0,2,list<character | double>,1
+rlist,.evalwith,-1,0,3,list<list<character | list<double>>>,1
+rlist,.evalwith,-1,0,4,list<character | list<double>>,1
+rlist,.evalwith,-1,0,5,list<double>,1
+rlist,.evalwith,0,0,0,character[],1
+rlist,.evalwith,0,0,1,double[],1
+rlist,.evalwith,0,0,2,list<double | character[] | list<double>>,1
+rlist,.evalwith,0,0,3,list<character | double>,1
+rlist,.evalwith,0,0,4,list<list<character | list<double>>>,1
+rlist,.evalwith,0,0,5,list<character | list<double>>,1
+rlist,getnames,-1,0,0,character[],1
+rlist,getnames,0,0,0,list<class<`name`> | class<`call`>>,1
+rlist,getnames,0,0,1,list<class<`name`>>,1
+rlist,getnames,0,0,2,list<double[]>,1
+rlist,getnames,0,0,3,list<list<list<character | list<double>>>>,1
+rlist,getnames,0,0,4,list<list<double | character[] | list<double>>>,1
+rlist,getnames,0,0,5,list<list<character | double>>,1
+rlist,getnames,0,0,6,list<list<character | list<double>>>,1
+rlist,getnames,0,0,7,list<character[]>,1
+rlist,getnames,0,0,8,double[],1
+rlist,getnames,1,0,0,any,1
+rlist,is.empty,-1,0,0,logical,1
+rlist,is.empty,0,0,0,double[],1
+rlist,is.empty,0,0,1,list<any>,1
+rlist,is.error,-1,0,0,logical,1
+rlist,is.error,0,0,0,class<`try-error`>,1
+rlist,is.error,0,0,1,double,1
+rlist,is.formula,-1,0,0,logical,1
+rlist,is.formula,0,0,0,class<`call`>,1
+rlist,is.formula,0,0,1,class<`name`>,1
+rlist,lambda,-1,0,0,class<`lambda_expression`>,1
+rlist,lambda,0,0,0,class<`call`>,1
+rlist,lambda,0,0,1,class<`lambda_expression`>,1
+rlist,lambda,0,0,2,class<`name`>,1
+rlist,List,-1,0,0,"class<`List`, `environment`>",1
+rlist,List,0,0,0,any,1
+rlist,[<-.List,-1,0,0,"class<`List`, `environment`>",1
+rlist,[<-.List,0,0,0,"class<`List`, `environment`>",1
+rlist,[<-.List,1,0,0,...,1
+rlist,[<-.List,2,0,0,null,1
+rlist,[<-.List,2,0,1,double,1
+rlist,[.List,-1,0,0,"class<`List`, `environment`>",1
+rlist,[.List,-1,0,1,double,1
+rlist,[.List,-1,0,2,list<double>,1
+rlist,[.List,0,0,0,"class<`List`, `environment`>",1
+rlist,[.List,1,0,0,...,1
+rlist,[[<-.List,-1,0,0,"class<`List`, `environment`>",1
+rlist,[[<-.List,0,0,0,"class<`List`, `environment`>",1
+rlist,[[<-.List,1,0,0,...,1
+rlist,[[<-.List,2,0,0,null,1
+rlist,[[<-.List,2,0,1,double,1
+rlist,[[.List,-1,0,0,"class<`List`, `environment`>",1
+rlist,[[.List,-1,0,1,double,1
+rlist,[[.List,-1,0,2,list<double>,1
+rlist,[[.List,0,0,0,"class<`List`, `environment`>",1
+rlist,[[.List,1,0,0,...,1
+rlist,$<-.List,-1,0,0,"class<`List`, `environment`>",1
+rlist,$<-.List,0,0,0,"class<`List`, `environment`>",1
+rlist,$<-.List,1,0,0,...,1
+rlist,$<-.List,2,0,0,null,1
+rlist,$<-.List,2,0,1,double,1
+rlist,list.all,-1,0,0,logical,1
+rlist,list.all,-1,0,1,null,1
+rlist,list.all,0,0,0,list<list<character | list<double>>>,1
+rlist,list.all,1,0,0,any,1
+rlist,list.all,2,0,0,logical,1
+rlist,list.any,-1,0,0,logical,1
+rlist,list.any,0,0,0,list<list<character | list<double>>>,1
+rlist,list.any,1,0,0,any,1
+rlist,list.any,2,0,0,logical,1
+rlist,list.cases,-1,0,0,character[],1
+rlist,list.cases,-1,0,1,double[],1
+rlist,list.cases,0,0,0,list<list<character | list<double>>>,1
+rlist,list.cases,0,0,1,list<character[]>,1
+rlist,list.cases,1,0,0,any,1
+rlist,list.cases,2,0,0,logical,1
+rlist,list.cases,3,0,0,logical,1
+rlist,list.cbind,-1,0,0,class<`data.frame`>,1
+rlist,list.cbind,0,0,0,list<class<`data.frame`>>,1
+rlist,list.class,-1,0,0,list<list<list<double | character[] | list<double>>>>,1
+rlist,list.class,0,0,0,list<list<double | character[] | list<double>>>,1
+rlist,list.class,1,0,0,...,1
+rlist,list.class,2,0,0,logical,1
+rlist,list.clean,-1,0,0,list<any>,1
+rlist,list.clean,0,0,0,list<null>,1
+rlist,list.clean,0,0,1,list<null | character[]>,1
+rlist,list.clean,0,0,2,list<character[]>,1
+rlist,list.clean,0,0,3,list<character | null>,1
+rlist,list.clean,0,0,4,list<character[] | null>,1
+rlist,list.clean,0,0,5,list<^double[] | null>,1
+rlist,list.clean,0,0,6,list<double[] | null>,1
+rlist,list.clean,0,0,7,list<double | null>,1
+rlist,list.clean,0,0,8,list<null | double | list<null | character[]>>,1
+rlist,list.clean,0,0,9,list<class<`data.frame`>>,1
+rlist,list.clean,0,0,10,list<list<double>>,1
+rlist,list.clean,0,0,11,list<double>,1
+rlist,list.clean,0,0,12,list<list<character | list<double>>>,1
+rlist,list.clean,1,0,0,class<`function`>,1
+rlist,list.clean,2,0,0,logical,1
+rlist,list.common,-1,0,0,character[],1
+rlist,list.common,0,0,0,list<list<character | list<double>>>,1
+rlist,list.common,0,0,1,list<character[]>,1
+rlist,list.common,1,0,0,any,1
+rlist,list.count,-1,0,0,integer,1
+rlist,list.count,0,0,0,list<list<character | list<double>>>,1
+rlist,list.count,1,0,0,any,1
+rlist,list.do,-1,0,0,class<`data.frame`>,1
+rlist,list.do,-1,0,1,class<`matrix`>,1
+rlist,list.do,0,0,0,list<class<`data.frame`>>,1
+rlist,list.do,0,0,1,list<double[]>,1
+rlist,list.do,1,0,0,character,1
+rlist,list.do,1,0,1,class<`function`>,1
+rlist,list.do,2,0,0,...,1
+rlist,list.exclude,-1,0,0,list<list<character | list<double>>>,1
+rlist,list.exclude,0,0,0,list<list<character | list<double>>>,1
+rlist,list.exclude,1,0,0,any,1
+rlist,list.expand,-1,0,0,list<list<character[] | list<double | character>>>,1
+rlist,list.expand,-1,0,1,list<list<double[] | character>>,1
+rlist,list.expand,-1,0,2,list<list<integer | character>>,1
+rlist,list.expand,0,0,0,...,1
+rlist,list.filter,-1,0,0,list<list<character | list<double>>>,1
+rlist,list.filter,0,0,0,list<list<character | list<double>>>,1
+rlist,list.filter,1,0,0,...,1
+rlist,list.find,-1,0,0,list<list<character | list<double>>>,1
+rlist,list.find,0,0,0,list<list<character | list<double>>>,1
+rlist,list.find,1,0,0,any,1
+rlist,list.find,2,0,0,double,1
+rlist,list.findi,-1,0,0,integer[],1
+rlist,list.findi,0,0,0,list<list<character | list<double>>>,1
+rlist,list.findi,1,0,0,any,1
+rlist,list.findi,2,0,0,double,1
+rlist,list.findi.internal,-1,0,0,integer[],1
+rlist,list.findi.internal,0,0,0,list<list<character | list<double>>>,1
+rlist,list.findi.internal,1,0,0,class<`call`>,1
+rlist,list.findi.internal,2,0,0,environment,1
+rlist,list.findi.internal,3,0,0,double,1
+rlist,list.findi.internal,4,0,0,logical,1
+rlist,list.first,-1,0,0,null,1
+rlist,list.first,-1,0,1,list<character | list<double>>,1
+rlist,list.first,0,0,0,list<list<character | list<double>>>,1
+rlist,list.first,1,0,0,any,1
+rlist,list.first.internal,-1,0,0,list<logical>,1
+rlist,list.first.internal,-1,0,1,list<logical | list<character | list<double>>>,1
+rlist,list.first.internal,-1,0,2,list<null | list<character | list<double>>>,1
+rlist,list.first.internal,0,0,0,list<list<character | list<double>>>,1
+rlist,list.first.internal,1,0,0,class<`call`>,1
+rlist,list.first.internal,1,0,1,class<`lambda_expression`>,1
+rlist,list.first.internal,2,0,0,environment,1
+rlist,list.first.internal,3,0,0,logical,1
+rlist,list.flatten,-1,0,0,list<double | character>,1
+rlist,list.flatten,-1,0,1,list<double>,1
+rlist,list.flatten,-1,0,2,list<character>,1
+rlist,list.flatten,0,0,0,list<double | list<double | double | list<character>>>,1
+rlist,list.flatten,0,0,1,list<double | list<character | double>>,1
+rlist,list.flatten,1,0,0,logical,1
+rlist,list.flatten,2,0,0,character,1
+rlist,List_get,-1,0,0,"class<`List`, `environment`>",1
+rlist,List_get,-1,0,1,double,1
+rlist,List_get,-1,0,2,list<double>,1
+rlist,List_get,0,0,0,any,1
+rlist,List_get,1,0,0,list<double>,1
+rlist,List_get,1,0,1,double,1
+rlist,List_get,2,0,0,pairlist,1
+rlist,List_get,3,0,0,any,1
+rlist,list.group,-1,0,0,list<list<list<character | list<double>>>>,1
+rlist,list.group,0,0,0,list<list<character | list<double>>>,1
+rlist,list.group,1,0,0,...,1
+rlist,list.group,2,0,0,logical,1
+rlist,list.group.internal,-1,0,0,list<list<list<character | list<double>>>>,1
+rlist,list.group.internal,-1,0,1,list<list<list<double | character[] | list<double>>>>,1
+rlist,list.group.internal,-1,0,2,list<list<double | character[] | list<double>>>,1
+rlist,list.group.internal,-1,0,3,list<list<character | list<double>>>,1
+rlist,list.group.internal,0,0,0,list<list<character | list<double>>>,1
+rlist,list.group.internal,0,0,1,list<list<double | character[] | list<double>>>,1
+rlist,list.group.internal,1,0,0,list<any>,1
+rlist,list.group.internal,2,0,0,any,1
+rlist,list.group.internal,3,0,0,any,1
+rlist,list.group.internal,4,0,0,any,1
+rlist,list.group.internal,5,0,0,any,1
+rlist,list.is,-1,0,0,logical[],1
+rlist,list.is,0,0,0,list<list<character | list<double>>>,1
+rlist,list.is,1,0,0,any,1
+rlist,list.is,2,0,0,logical,1
+rlist,list.is.internal,-1,0,0,logical[],1
+rlist,list.is.internal,0,0,0,list<list<character | list<double>>>,1
+rlist,list.is.internal,1,0,0,class<`call`>,1
+rlist,list.is.internal,2,0,0,environment,1
+rlist,list.iter,-1,0,0,list<list<character | list<double>>>,1
+rlist,list.iter,0,0,0,list<list<character | list<double>>>,1
+rlist,list.iter,1,0,0,any,1
+rlist,list.join,-1,0,0,list<list<character | double>>,1
+rlist,list.join,0,0,0,list<list<character | double>>,1
+rlist,list.join,1,0,0,list<list<character | double>>,1
+rlist,list.join,2,0,0,any,1
+rlist,list.join,3,0,0,any,1
+rlist,list.join,4,0,0,...,1
+rlist,list.join,5,0,0,logical,1
+rlist,list.last,-1,0,0,null,1
+rlist,list.last,-1,0,1,list<character | list<double>>,1
+rlist,list.last,0,0,0,list<list<character | list<double>>>,1
+rlist,list.last,1,0,0,any,1
+rlist,list.map,-1,0,0,list<double>,1
+rlist,list.map,-1,0,1,list<double | null>,1
+rlist,list.map,-1,0,2,list<character>,1
+rlist,list.map,-1,0,3,list<list<double>>,1
+rlist,list.map,0,0,0,list<double[]>,1
+rlist,list.map,0,0,1,list<list<list<character | list<double>>>>,1
+rlist,list.map,0,0,2,list<list<character | list<double>>>,1
+rlist,list.map,1,0,0,any,1
+rlist,list.map.internal,-1,0,0,any,1
+rlist,list.map.internal,0,0,0,list<list<character | list<double>>>,1
+rlist,list.map.internal,0,0,1,list<character[]>,1
+rlist,list.map.internal,0,0,2,double[],1
+rlist,list.map.internal,0,0,3,list<list<character | double>>,1
+rlist,list.map.internal,0,0,4,list<double[]>,1
+rlist,list.map.internal,0,0,5,list<list<list<character | list<double>>>>,1
+rlist,list.map.internal,0,0,6,list<list<double | character[] | list<double>>>,1
+rlist,list.map.internal,1,0,0,class<`call`>,1
+rlist,list.map.internal,1,0,1,class<`lambda_expression`>,1
+rlist,list.map.internal,1,0,2,class<`name`>,1
+rlist,list.map.internal,2,0,0,environment,1
+rlist,list.map.internal,3,0,0,class<`function`>,1
+rlist,list.map.internal,4,0,0,environment,1
+rlist,list.map.internal,4,0,1,null,1
+rlist,list.mapv,-1,0,0,character[],1
+rlist,list.mapv,-1,0,1,double[],1
+rlist,list.mapv,0,0,0,list<list<character | list<double>>>,1
+rlist,list.mapv,1,0,0,any,1
+rlist,list.mapv,2,0,0,any,1
+rlist,list.mapv,3,0,0,logical,1
+rlist,list.match,-1,0,0,list<list<character | list<double>>>,1
+rlist,list.match,0,0,0,list<list<character | list<double>>>,1
+rlist,list.match,1,0,0,character,1
+rlist,list.match,2,0,0,...,1
+rlist,list.merge,-1,0,0,list<double | list<double>>,1
+rlist,list.merge,0,0,0,...,1
+rlist,list.names,-1,0,0,character[],1
+rlist,list.names,-1,0,1,double[],1
+rlist,list.names,-1,0,2,null,1
+rlist,list.names,-1,0,3,list<list<character | double>>,1
+rlist,list.names,0,0,0,double[],1
+rlist,list.names,0,0,1,list<list<character | double>>,1
+rlist,list.names,1,0,0,any,1
+rlist,list.order,-1,0,0,integer[],1
+rlist,list.order,0,0,0,list<list<character | list<double>>>,1
+rlist,list.order,1,0,0,...,1
+rlist,list.order,2,0,0,logical,1
+rlist,list.order,3,0,0,logical,1
+rlist,list.order.internal,-1,0,0,integer[],1
+rlist,list.order.internal,0,0,0,list<list<character | list<double>>>,1
+rlist,list.order.internal,1,0,0,list<class<`call`>>,1
+rlist,list.order.internal,1,0,1,list<class<`name`> | class<`(`>>,1
+rlist,list.order.internal,2,0,0,environment,1
+rlist,list.order.internal,3,0,0,logical,1
+rlist,list.order.internal,3,0,1,null,1
+rlist,list.parse,-1,0,0,list<list<integer | class<`factor`>>>,1
+rlist,list.parse,-1,0,1,list<list<character | logical>>,1
+rlist,list.parse,-1,0,2,list<list<double>>,1
+rlist,list.parse,0,0,0,class<`data.frame`>,1
+rlist,list.parse,0,0,1,character,1
+rlist,list.parse,0,0,2,class<`matrix`>,1
+rlist,list.parse,1,0,0,...,1
+rlist,list.parse.character,-1,0,0,list<list<character | logical>>,1
+rlist,list.parse.character,0,0,0,character,1
+rlist,list.parse.character,1,0,0,character,1
+rlist,list.parse.character,2,0,0,...,1
+rlist,list.parse.data.frame,-1,0,0,list<list<integer | class<`factor`>>>,1
+rlist,list.parse.data.frame,0,0,0,class<`data.frame`>,1
+rlist,list.parse.data.frame,1,0,0,...,1
+rlist,list.parse.matrix,-1,0,0,list<list<double>>,1
+rlist,list.parse.matrix,0,0,0,class<`matrix`>,1
+rlist,list.parse.matrix,1,0,0,...,1
+rlist,list.prepend,-1,0,0,list<double[]>,1
+rlist,list.prepend,0,0,0,list<double>,1
+rlist,list.prepend,1,0,0,...,1
+rlist,list.rbind,-1,0,0,class<`data.frame`>,1
+rlist,list.rbind,-1,0,1,class<`matrix`>,1
+rlist,list.rbind,0,0,0,list<class<`data.frame`>>,1
+rlist,list.rbind,0,0,1,list<double[]>,1
+rlist,list.remove,-1,0,0,list<list<character | list<double>>>,1
+rlist,list.remove,0,0,0,list<list<character | list<double>>>,1
+rlist,list.remove,1,0,0,character,1
+rlist,list.remove,1,0,1,double[],1
+rlist,list.reverse,-1,0,0,list<double>,1
+rlist,list.reverse,0,0,0,list<double>,1
+rlist,list.sample,-1,0,0,list<double[]>,1
+rlist,list.sample,0,0,0,list<double[]>,1
+rlist,list.sample,1,0,0,double,1
+rlist,list.sample,2,0,0,logical,1
+rlist,list.sample,3,0,0,any,1
+rlist,list.sample,4,0,0,null,1
+rlist,list.search,-1,0,0,list<any>,1
+rlist,list.search,0,0,0,list<list<character | double | character[] | double[] | character[] | ^double[]>>,1
+rlist,list.search,0,0,1,list<list<character[] | double>>,1
+rlist,list.search,0,0,2,list<list<character | double>>,1
+rlist,list.search,1,0,0,any,1
+rlist,list.search,2,0,0,character,1
+rlist,list.search,3,0,0,any,1
+rlist,list.search,4,0,0,logical,1
+rlist,list.select,-1,0,0,list<list<character>>,1
+rlist,list.select,-1,0,1,list<list<character | double[]>>,1
+rlist,list.select,-1,0,2,list<list<character | list<double>>>,1
+rlist,list.select,0,0,0,list<list<character | list<double>>>,1
+rlist,list.select,1,0,0,...,1
+rlist,List_set,-1,0,0,"class<`List`, `environment`>",1
+rlist,List_set,0,0,0,class<`name`>,1
+rlist,List_set,1,0,0,list<double>,1
+rlist,List_set,2,0,0,pairlist,1
+rlist,List_set,3,0,0,double,1
+rlist,List_set,3,0,1,null,1
+rlist,List_set,4,0,0,environment,1
+rlist,list.skip,-1,0,0,list<double>,1
+rlist,list.skip,0,0,0,list<double>,1
+rlist,list.skip,1,0,0,double,1
+rlist,list.skipWhile,-1,0,0,list<list<character | list<double>>>,1
+rlist,list.skipWhile,0,0,0,list<list<character | list<double>>>,1
+rlist,list.skipWhile,1,0,0,any,1
+rlist,list.sort,-1,0,0,list<list<character | list<double>>>,1
+rlist,list.sort,0,0,0,list<list<character | list<double>>>,1
+rlist,list.sort,1,0,0,...,1
+rlist,list.sort,2,0,0,null,1
+rlist,list.table,-1,0,0,class<`table`>,1
+rlist,list.table,0,0,0,list<list<character | list<double>>>,1
+rlist,list.table,1,0,0,...,1
+rlist,list.table,2,0,0,list<character[]>,1
+rlist,list.take,-1,0,0,list<double>,1
+rlist,list.take,0,0,0,list<double>,1
+rlist,list.take,1,0,0,double,1
+rlist,list.take,2,0,0,logical,1
+rlist,list.takeWhile,-1,0,0,list<any>,1
+rlist,list.takeWhile,0,0,0,list<list<character | list<double>>>,1
+rlist,list.takeWhile,1,0,0,any,1
+rlist,list.ungroup,-1,0,0,list<list<list<double>>>,1
+rlist,list.ungroup,-1,0,1,list<list<double>>,1
+rlist,list.ungroup,-1,0,2,list<list<character | list<double>>>,1
+rlist,list.ungroup,0,0,0,list<list<list<list<double>>>>,1
+rlist,list.ungroup,0,0,1,list<list<list<character | list<double>>>>,1
+rlist,list.ungroup,1,0,0,double,1
+rlist,list.ungroup,2,0,0,...,1
+rlist,list.ungroup,3,0,0,logical,1
+rlist,list.ungroup,4,0,0,logical,1
+rlist,list.unzip,-1,0,0,list<^double[]>,1
+rlist,list.unzip,-1,0,1,list<^double[] | list<double>>,1
+rlist,list.unzip,-1,0,2,list<double[] | class<`data.frame`> | class<`matrix`>>,1
+rlist,list.unzip,0,0,0,list<list<double>>,1
+rlist,list.unzip,0,0,1,list<list<double | character[] | list<list<character>>>>,1
+rlist,list.unzip,1,0,0,character[],1
+rlist,list.unzip,2,0,0,...,1
+rlist,list.unzip,3,0,0,character,1
+rlist,list.unzip,4,0,0,null,1
+rlist,list.update,-1,0,0,list<list<character | list<double>>>,1
+rlist,list.update,-1,0,1,list<list<character | integer | list<double>>>,1
+rlist,list.update,-1,0,2,list<list<character | double | list<double>>>,1
+rlist,list.update,0,0,0,list<list<character | list<double>>>,1
+rlist,list.update,1,0,0,...,1
+rlist,list.update,2,0,0,logical,1
+rlist,list.which,-1,0,0,integer[],1
+rlist,list.which,0,0,0,list<list<character | list<double>>>,1
+rlist,list.which,1,0,0,any,1
+rlist,list.zip,-1,0,0,list<list<double | character>>,1
+rlist,list.zip,0,0,0,...,1
+rlist,list.zip,1,0,0,logical,1
+rlist,list.zip,2,0,0,logical,1
+rlist,map,-1,0,0,any,1
+rlist,map,0,0,0,class<`function`>,1
+rlist,map,1,0,0,list<integer[] | character[] | list<list<character | list<double>>>>,1
+rlist,map,1,0,1,list<integer[] | character | list<character[]>>,1
+rlist,map,1,0,2,list<double[] | character>,1
+rlist,map,1,0,3,list<integer[] | character | list<list<character | double>>>,1
+rlist,map,1,0,4,class<`data.frame`>,1
+rlist,map,1,0,5,list<list<double | character>>,1
+rlist,map,1,0,6,list<integer[] | character[] | list<double[]>>,1
+rlist,map,1,0,7,list<integer[] | character[] | list<list<list<character | list<double>>>>>,1
+rlist,map,1,0,8,list<integer[] | character[] | list<list<double | character[] | list<double>>>>,1
+rlist,map,1,0,9,list<integer[] | character[] | list<list<character | double>>>,1
+rlist,map,1,0,10,list<integer | character | list<list<character | list<double>>>>,1
+rlist,map,1,0,11,list<list<list<character | double>>>,1
+rlist,map,1,0,12,list<list<list<character | list<double> | double>>>,1
+rlist,map,1,0,13,list<list<integer | list<character | list<double>>>>,1
+rlist,map,1,0,14,list<list<double | list<character | list<double>>>>,1
+rlist,map,1,0,15,list<integer[] | character[] | list<character[]>>,1
+rlist,map,2,0,0,null,1
+rlist,map,3,0,0,logical,1
+rlist,ndots,-1,0,0,logical,1
+rlist,ndots,0,0,0,pairlist,1
+rlist,reduce,-1,0,0,character[],1
+rlist,reduce,-1,0,1,class<`data.frame`>,1
+rlist,reduce,-1,0,2,class<`matrix`>,1
+rlist,reduce,-1,0,3,^double[],1
+rlist,reduce,-1,0,4,list<double | list<double>>,1
+rlist,reduce,-1,0,5,list<double>,1
+rlist,reduce,-1,0,6,list<list<character | list<double>>>,1
+rlist,reduce,0,0,0,class<`function`>,1
+rlist,reduce,1,0,0,list<character[]>,1
+rlist,reduce,1,0,1,list<class<`function`>>,1
+rlist,reduce,1,0,2,list<list<double | list<double>>>,1
+rlist,reduce,1,0,3,list<class<`call`>>,1
+rlist,reduce,2,0,0,character[],1
+rlist,reduce,2,0,1,list<any>,1
+rlist,reduce,3,0,0,...,1
+rlist,set_argnames,-1,0,0,list<list<double | character>>,1
+rlist,set_argnames,-1,0,1,list<class<`name`>>,1
+rlist,set_argnames,-1,0,2,list<class<`name`> | class<`call`>>,1
+rlist,set_argnames,0,0,0,list<class<`name`>>,1
+rlist,set_argnames,0,0,1,list<class<`name`> | class<`call`>>,1
+rlist,set_argnames,1,0,0,list<list<double | character>>,1
+rlist,set_argnames,1,0,1,list<class<`name`>>,1
+rlist,set_argnames,1,0,2,list<class<`name`> | class<`call`>>,1
+rlist,subset.list,-1,0,0,list<class<`data.frame`>>,1
+rlist,subset.list,-1,0,1,list<list<double>>,1
+rlist,subset.list,-1,0,2,list<double>,1
+rlist,subset.list,-1,0,3,list<list<character | list<double>>>,1
+rlist,subset.list,0,0,0,list<list<character | list<double>>>,1
+rlist,subset.list,1,0,0,any,1
+rlist,subset.list,2,0,0,any,1
+rlist,subset.list,3,0,0,...,1
+rlist,tryEval,-1,0,0,double,1
+rlist,tryEval,-1,0,1,null,1
+rlist,tryEval,0,0,0,any,1
+rlist,tryEval,1,0,0,null,1
+rlist,tryGet,-1,0,0,double,1
+rlist,tryGet,0,0,0,any,1
+rlist,tryGet,1,0,0,double,1
+rlist,tryGet,2,0,0,...,1
+rlist,tryGet,3,0,0,environment,1
+rlist,tryWithCondition,-1,0,0,null,1
+rlist,tryWithCondition,-1,0,1,list<null>,1
+rlist,tryWithCondition,-1,0,2,list<null | list<null | list<character | list<double>>>>,1
+rlist,tryWithCondition,0,0,0,any,1
+rlist,tryWithCondition,1,0,0,...,1
+roxygen2,%||%,-1,0,0,character,1
+roxygen2,%||%,-1,0,1,null,1
+roxygen2,%||%,0,0,0,character,1
+roxygen2,%||%,0,0,1,null,1
+roxygen2,%||%,1,0,0,any,1
+roxygen2,add_linkrefs_to_md,-1,0,0,character,1
+roxygen2,add_linkrefs_to_md,0,0,0,character,1
+roxygen2,add_s3_metadata,-1,0,0,class<`function`>,1
+roxygen2,add_s3_metadata,0,0,0,class<`function`>,1
+roxygen2,add_s3_metadata,1,0,0,character,1
+roxygen2,add_s3_metadata,2,0,0,environment,1
+roxygen2,add_s3_metadata,3,0,0,null,1
+roxygen2,args_call,-1,0,0,character,1
+roxygen2,args_call,0,0,0,character,1
+roxygen2,args_call,1,0,0,character[],1
+roxygen2,args_string,-1,0,0,character[],1
+roxygen2,args_string,0,0,0,character[],1
+roxygen2,auto_backtick,-1,0,0,character[],1
+roxygen2,auto_backtick,0,0,0,character[],1
+roxygen2,block_evaluate,-1,0,0,class<`roxy_block`>,1
+roxygen2,block_evaluate,0,0,0,class<`roxy_block`>,1
+roxygen2,block_evaluate,1,0,0,any,1
+roxygen2,block_find_object,-1,0,0,"class<`roxy_block`, `roxy_block_function`, `roxy_block_object`>",1
+roxygen2,block_find_object,0,0,0,class<`roxy_block`>,1
+roxygen2,block_find_object,1,0,0,environment,1
+roxygen2,block_get_tag,-1,0,0,null,1
+roxygen2,block_get_tag,0,0,0,class<`roxy_block`>,1
+roxygen2,block_get_tag,0,0,1,"class<`roxy_block`, `roxy_block_function`, `roxy_block_object`>",1
+roxygen2,block_get_tag,1,0,0,character,1
+roxygen2,block_get_tags,-1,0,0,list<any>,1
+roxygen2,block_get_tags,0,0,0,class<`roxy_block`>,1
+roxygen2,block_get_tags,0,0,1,"class<`roxy_block`, `roxy_block_function`, `roxy_block_object`>",1
+roxygen2,block_get_tags,1,0,0,character,1
+roxygen2,block_get_tag_value,-1,0,0,null,1
+roxygen2,block_get_tag_value,0,0,0,class<`roxy_block`>,1
+roxygen2,block_get_tag_value,1,0,0,character,1
+roxygen2,block_has_tags,-1,0,0,logical,1
+roxygen2,block_has_tags,0,0,0,"class<`roxy_block`, `roxy_block_function`, `roxy_block_object`>",1
+roxygen2,block_has_tags,1,0,0,character[],1
+roxygen2,block_tags,-1,0,0,character[],1
+roxygen2,block_tags,0,0,0,class<`roxy_block`>,1
+roxygen2,block_tags,0,0,1,"class<`roxy_block`, `roxy_block_function`, `roxy_block_object`>",1
+roxygen2,block_to_rd,-1,0,0,"class<`R6`, `RoxyTopic`>",1
+roxygen2,block_to_rd,0,0,0,"class<`roxy_block`, `roxy_block_function`, `roxy_block_object`>",1
+roxygen2,block_to_rd,1,0,0,any,1
+roxygen2,block_to_rd,2,0,0,any,1
+roxygen2,block_to_rd.roxy_block,-1,0,0,"class<`R6`, `RoxyTopic`>",1
+roxygen2,block_to_rd.roxy_block,0,0,0,"class<`roxy_block`, `roxy_block_function`, `roxy_block_object`>",1
+roxygen2,block_to_rd.roxy_block,1,0,0,any,1
+roxygen2,block_to_rd.roxy_block,2,0,0,any,1
+roxygen2,calls_use_method,-1,0,0,logical,1
+roxygen2,calls_use_method,0,0,0,class<`{`>,1
+roxygen2,calls_use_method,0,0,1,class<`call`>,1
+roxygen2,calls_use_method,0,0,2,class<`name`>,1
+roxygen2,can_parse,-1,0,0,logical,1
+roxygen2,can_parse,0,0,0,character,1
+roxygen2,comments,-1,0,0,list<class<`srcref`>>,1
+roxygen2,comments,0,0,0,list<class<`srcref`>>,1
+roxygen2,compact,-1,0,0,list<any>,1
+roxygen2,compact,0,0,0,list<any>,1
+roxygen2,double_escape_md,-1,0,0,character,1
+roxygen2,double_escape_md,0,0,0,character,1
+roxygen2,env_file,-1,0,0,environment,1
+roxygen2,env_file,0,0,0,character,1
+roxygen2,escape,-1,0,0,class<`rd`>,1
+roxygen2,escape,0,0,0,character[],1
+roxygen2,escape.character,-1,0,0,class<`rd`>,1
+roxygen2,escape.character,0,0,0,character[],1
+roxygen2,escape_comment,-1,0,0,character,1
+roxygen2,escape_comment,0,0,0,character,1
+roxygen2,escape_rd_for_md,-1,0,0,character,1
+roxygen2,escape_rd_for_md,0,0,0,character,1
+roxygen2,find_all_rd_tags,-1,0,0,class<`data.frame`>,1
+roxygen2,find_all_rd_tags,0,0,0,character,1
+roxygen2,find_all_tag_names,-1,0,0,class<`data.frame`>,1
+roxygen2,find_all_tag_names,0,0,0,character,1
+roxygen2,find_fragile_rd_tags,-1,0,0,class<`data.frame`>,1
+roxygen2,find_fragile_rd_tags,0,0,0,character,1
+roxygen2,find_fragile_rd_tags,1,0,0,character[],1
+roxygen2,find_generic,-1,0,0,null,1
+roxygen2,find_generic,0,0,0,character,1
+roxygen2,find_generic,1,0,0,any,1
+roxygen2,function_usage,-1,0,0,class<`rd`>,1
+roxygen2,function_usage,0,0,0,character,1
+roxygen2,function_usage,1,0,0,pairlist,1
+roxygen2,function_usage,2,0,0,class<`function`>,1
+roxygen2,get_documented_params,-1,0,0,character[],1
+roxygen2,get_documented_params,0,0,0,"class<`R6`, `RoxyTopic`>",1
+roxygen2,get_documented_params,1,0,0,logical,1
+roxygen2,get_md_linkrefs,-1,0,0,character[],1
+roxygen2,get_md_linkrefs,0,0,0,character,1
+roxygen2,has_quotes,-1,0,0,logical[],1
+roxygen2,has_quotes,0,0,0,character[],1
+roxygen2,internal_f,-1,0,0,class<`function`>,1
+roxygen2,internal_f,0,0,0,character,1
+roxygen2,internal_f,1,0,0,character,1
+roxygen2,invert,-1,0,0,null,1
+roxygen2,invert,0,0,0,list<any>,1
+roxygen2,is_infix_fun,-1,0,0,logical,1
+roxygen2,is_infix_fun,0,0,0,character,1
+roxygen2,is_replacement_fun,-1,0,0,logical,1
+roxygen2,is_replacement_fun,0,0,0,character,1
+roxygen2,is.roclet,-1,0,0,logical,1
+roxygen2,is.roclet,0,0,0,"class<`roclet`, `roclet_memo`>",1
+roxygen2,is.roclet,0,0,1,"class<`roclet`, `roclet_rd`>",1
+roxygen2,is_roxy_block,-1,0,0,logical,1
+roxygen2,is_roxy_block,0,0,0,class<`roxy_block`>,1
+roxygen2,is_s3_generic,-1,0,0,logical,1
+roxygen2,is_s3_generic,0,0,0,character,1
+roxygen2,is_s3_generic,1,0,0,environment,1
+roxygen2,is_syntactic,-1,0,0,logical[],1
+roxygen2,is_syntactic,0,0,0,character[],1
+roxygen2,make_as_character_rd,-1,0,0,class<`function`>,1
+roxygen2,make_random_string,-1,0,0,character,1
+roxygen2,make_random_string,0,0,0,double,1
+roxygen2,markdown,-1,0,0,character,1
+roxygen2,markdown,0,0,0,character,1
+roxygen2,markdown,1,0,0,"class<`roxy_tag`, `roxy_tag_tip`>",1
+roxygen2,markdown,1,0,1,"class<`roxy_tag`, `roxy_tag_title`>",1
+roxygen2,markdown,2,0,0,logical,1
+roxygen2,markdown_activate,-1,0,0,logical,1
+roxygen2,markdown_activate,0,0,0,"list<class<`roxy_tag`, `roxy_tag_`> | class<`roxy_tag`, `roxy_tag_param`> | class<`roxy_tag`, `roxy_tag_export`>>",1
+roxygen2,markdown_activate,0,0,1,"list<class<`roxy_tag`, `roxy_tag_`> | class<`roxy_tag`, `roxy_tag_tip`> | class<`roxy_tag`, `roxy_tag_md`>>",1
+roxygen2,markdown_activate,0,0,2,"list<class<`roxy_tag`, `roxy_tag_memo`>>",1
+roxygen2,markdown_if_active,-1,0,0,character,1
+roxygen2,markdown_if_active,0,0,0,character,1
+roxygen2,markdown_if_active,1,0,0,any,1
+roxygen2,markdown_if_active,2,0,0,logical,1
+roxygen2,markdown_on,-1,0,0,logical,1
+roxygen2,markdown_on,0,0,0,logical,1
+roxygen2,markdown_on,0,0,1,null,1
+roxygen2,md_to_mdxml,-1,0,0,"class<`xml_document`, `xml_node`>",1
+roxygen2,md_to_mdxml,0,0,0,character,1
+roxygen2,md_to_mdxml,1,0,0,...,1
+roxygen2,mdxml_children_to_rd,-1,0,0,character,1
+roxygen2,mdxml_children_to_rd,0,0,0,class<`xml_node`>,1
+roxygen2,mdxml_children_to_rd,1,0,0,any,1
+roxygen2,mdxml_children_to_rd_top,-1,0,0,character,1
+roxygen2,mdxml_children_to_rd_top,0,0,0,"class<`xml_document`, `xml_node`>",1
+roxygen2,mdxml_children_to_rd_top,1,0,0,environment,1
+roxygen2,mdxml_close_sections,-1,0,0,character,1
+roxygen2,mdxml_close_sections,0,0,0,environment,1
+roxygen2,mdxml_close_sections,1,0,0,integer,1
+roxygen2,mdxml_code,-1,0,0,character,1
+roxygen2,mdxml_code,0,0,0,class<`xml_node`>,1
+roxygen2,mdxml_code,1,0,0,any,1
+roxygen2,merge.rd_section,-1,0,0,"class<`rd_section`, `rd_section_tip`>",1
+roxygen2,merge.rd_section,0,0,0,"class<`rd_section`, `rd_section_tip`>",1
+roxygen2,merge.rd_section,1,0,0,"class<`rd_section`, `rd_section_tip`>",1
+roxygen2,merge.rd_section,2,0,0,...,1
+roxygen2,needs_doc,-1,0,0,logical,1
+roxygen2,needs_doc,0,0,0,"class<`roxy_block`, `roxy_block_function`, `roxy_block_object`>",1
+roxygen2,nice_name,-1,0,0,character,1
+roxygen2,nice_name,0,0,0,character,1
+roxygen2,object,-1,0,0,"class<`function`, `object`>",1
+roxygen2,object,0,0,0,class<`function`>,1
+roxygen2,object,1,0,0,character,1
+roxygen2,object,2,0,0,character,1
+roxygen2,object_defaults,-1,0,0,"list<class<`roxy_tag`, `roxy_tag_usage`> | class<`roxy_tag`, `roxy_tag_.formals`>>",1
+roxygen2,object_defaults,0,0,0,"class<`function`, `object`>",1
+roxygen2,object_defaults.function,-1,0,0,"list<class<`roxy_tag`, `roxy_tag_usage`> | class<`roxy_tag`, `roxy_tag_.formals`>>",1
+roxygen2,object_defaults.function,0,0,0,"class<`function`, `object`>",1
+roxygen2,object_from_call,-1,0,0,"class<`function`, `object`>",1
+roxygen2,object_from_call,0,0,0,class<`<-`>,1
+roxygen2,object_from_call,1,0,0,environment,1
+roxygen2,object_from_call,2,0,0,class<`roxy_block`>,1
+roxygen2,object_from_call,3,0,0,any,1
+roxygen2,object_from_name,-1,0,0,"class<`function`, `object`>",1
+roxygen2,object_from_name,0,0,0,character,1
+roxygen2,object_from_name,1,0,0,environment,1
+roxygen2,object_from_name,2,0,0,class<`roxy_block`>,1
+roxygen2,object_topic,-1,0,0,character,1
+roxygen2,object_topic,0,0,0,any,1
+roxygen2,object_topic,1,0,0,character,1
+roxygen2,object_topic,2,0,0,character,1
+roxygen2,object_usage,-1,0,0,class<`rd`>,1
+roxygen2,object_usage,0,0,0,"class<`function`, `object`>",1
+roxygen2,object_usage.function,-1,0,0,class<`rd`>,1
+roxygen2,object_usage.function,0,0,0,"class<`function`, `object`>",1
+roxygen2,order_blocks,-1,0,0,"list<class<`roxy_block`, `roxy_block_function`, `roxy_block_object`>>",1
+roxygen2,order_blocks,0,0,0,"list<class<`roxy_block`, `roxy_block_function`, `roxy_block_object`>>",1
+roxygen2,parse_description,-1,0,0,list<any>,1
+roxygen2,parse_description,0,0,0,"list<class<`roxy_tag`, `roxy_tag_memo`>>",1
+roxygen2,parse_description,0,0,1,"list<class<`roxy_tag`, `roxy_tag_`> | class<`roxy_tag`, `roxy_tag_param`> | class<`roxy_tag`, `roxy_tag_export`>>",1
+roxygen2,parse_description,0,0,2,"list<class<`roxy_tag`, `roxy_tag_`> | class<`roxy_tag`, `roxy_tag_tip`> | class<`roxy_tag`, `roxy_tag_md`>>",1
+roxygen2,parse_file,-1,0,0,"list<class<`roxy_block`, `roxy_block_function`, `roxy_block_object`>>",1
+roxygen2,parse_file,0,0,0,character,1
+roxygen2,parse_file,1,0,0,environment,1
+roxygen2,parse_file,2,0,0,character,1
+roxygen2,parser_assignment,-1,0,0,"class<`function`, `object`>",1
+roxygen2,parser_assignment,0,0,0,class<`<-`>,1
+roxygen2,parser_assignment,1,0,0,environment,1
+roxygen2,parser_assignment,2,0,0,class<`roxy_block`>,1
+roxygen2,parse_tags,-1,0,0,list<any>,1
+roxygen2,parse_tags,0,0,0,"list<class<`roxy_tag`, `roxy_tag_memo`>>",1
+roxygen2,parse_tags,0,0,1,"list<class<`roxy_tag`, `roxy_tag_`> | class<`roxy_tag`, `roxy_tag_param`> | class<`roxy_tag`, `roxy_tag_export`>>",1
+roxygen2,parse_tags,0,0,2,"list<class<`roxy_tag`, `roxy_tag_`> | class<`roxy_tag`, `roxy_tag_tip`> | class<`roxy_tag`, `roxy_tag_md`>>",1
+roxygen2,parse_text,-1,0,0,"list<class<`roxy_block`, `roxy_block_function`, `roxy_block_object`>>",1
+roxygen2,parse_text,0,0,0,character,1
+roxygen2,parse_text,1,0,0,environment,1
+roxygen2,process_templates,-1,0,0,"class<`roxy_block`, `roxy_block_function`, `roxy_block_object`>",1
+roxygen2,process_templates,0,0,0,"class<`roxy_block`, `roxy_block_function`, `roxy_block_object`>",1
+roxygen2,process_templates,1,0,0,any,1
+roxygen2,protect_rd_tags,-1,0,0,character,1
+roxygen2,protect_rd_tags,0,0,0,character,1
+roxygen2,protect_rd_tags,1,0,0,class<`data.frame`>,1
+roxygen2,rd,-1,0,0,class<`rd`>,1
+roxygen2,rd,0,0,0,character[],1
+roxygen2,rdComplete,-1,0,0,logical,1
+roxygen2,rdComplete,0,0,0,character,1
+roxygen2,rdComplete,1,0,0,logical,1
+roxygen2,rd_roclet,-1,0,0,"class<`roclet`, `roclet_rd`>",1
+roxygen2,rd_section,-1,0,0,"class<`rd_section`, `rd_section_alias`>",1
+roxygen2,rd_section,-1,0,1,"class<`rd_section`, `rd_section_backref`>",1
+roxygen2,rd_section,-1,0,2,"class<`rd_section`, `rd_section_description`>",1
+roxygen2,rd_section,-1,0,3,"class<`rd_section`, `rd_section_formals`>",1
+roxygen2,rd_section,-1,0,4,"class<`rd_section`, `rd_section_name`>",1
+roxygen2,rd_section,-1,0,5,"class<`rd_section`, `rd_section_tip`>",1
+roxygen2,rd_section,-1,0,6,"class<`rd_section`, `rd_section_title`>",1
+roxygen2,rd_section,-1,0,7,"class<`rd_section`, `rd_section_usage`>",1
+roxygen2,rd_section,-1,0,8,null,1
+roxygen2,rd_section,0,0,0,character,1
+roxygen2,rd_section,1,0,0,character[],1
+roxygen2,rd_section,1,0,1,class<`rd`>,1
+roxygen2,rd_section,1,0,2,null,1
+roxygen2,read_lines,-1,0,0,character[],1
+roxygen2,read_lines,0,0,0,character,1
+roxygen2,read_lines,1,0,0,integer,1
+roxygen2,roclet,-1,0,0,"class<`roclet`, `roclet_memo`>",1
+roxygen2,roclet,-1,0,1,"class<`roclet`, `roclet_rd`>",1
+roxygen2,roclet,0,0,0,character,1
+roxygen2,roclet,1,0,0,...,1
+roxygen2,roclet_find,-1,0,0,"class<`roclet`, `roclet_rd`>",1
+roxygen2,roclet_find,0,0,0,character,1
+roxygen2,roclet_output,-1,0,0,null,1
+roxygen2,roclet_output,0,0,0,"class<`roclet`, `roclet_memo`>",1
+roxygen2,roclet_output,1,0,0,list<character[]>,1
+roxygen2,roclet_output,2,0,0,any,1
+roxygen2,roclet_output,3,0,0,...,1
+roxygen2,roclet_process,-1,0,0,"list<class<`R6`, `RoxyTopic`>>",1
+roxygen2,roclet_process,-1,0,1,list<character[]>,1
+roxygen2,roclet_process,0,0,0,"class<`roclet`, `roclet_rd`>",1
+roxygen2,roclet_process,0,0,1,"class<`roclet`, `roclet_memo`>",1
+roxygen2,roclet_process,1,0,0,"list<class<`roxy_block`, `roxy_block_function`, `roxy_block_object`>>",1
+roxygen2,roclet_process,2,0,0,any,1
+roxygen2,roclet_process,3,0,0,character,1
+roxygen2,roclet_process.roclet_rd,-1,0,0,"list<class<`R6`, `RoxyTopic`>>",1
+roxygen2,roclet_process.roclet_rd,0,0,0,"class<`roclet`, `roclet_rd`>",1
+roxygen2,roclet_process.roclet_rd,1,0,0,"list<class<`roxy_block`, `roxy_block_function`, `roxy_block_object`>>",1
+roxygen2,roclet_process.roclet_rd,2,0,0,any,1
+roxygen2,roclet_process.roclet_rd,3,0,0,character,1
+roxygen2,roc_proc_text,-1,0,0,"list<class<`R6`, `RoxyTopic`>>",1
+roxygen2,roc_proc_text,-1,0,1,list<character[]>,1
+roxygen2,roc_proc_text,0,0,0,"class<`roclet`, `roclet_rd`>",1
+roxygen2,roc_proc_text,0,0,1,"class<`roclet`, `roclet_memo`>",1
+roxygen2,roc_proc_text,1,0,0,character,1
+roxygen2,roxy_block,-1,0,0,class<`roxy_block`>,1
+roxygen2,roxy_block,0,0,0,list<any>,1
+roxygen2,roxy_block,1,0,0,character,1
+roxygen2,roxy_block,2,0,0,integer,1
+roxygen2,roxy_block,3,0,0,class<`<-`>,1
+roxygen2,roxy_block,4,0,0,null,1
+roxygen2,roxy_meta_get,-1,0,0,logical,1
+roxygen2,roxy_meta_get,-1,0,1,null,1
+roxygen2,roxy_meta_get,0,0,0,character,1
+roxygen2,roxy_meta_get,1,0,0,logical,1
+roxygen2,roxy_meta_get,1,0,1,null,1
+roxygen2,roxy_meta_set,-1,0,0,class<`rlang_zap`>,1
+roxygen2,roxy_meta_set,-1,0,1,environment,1
+roxygen2,roxy_meta_set,-1,0,2,null,1
+roxygen2,roxy_meta_set,0,0,0,character,1
+roxygen2,roxy_meta_set,1,0,0,environment,1
+roxygen2,roxy_meta_set,1,0,1,null,1
+roxygen2,roxy_tag,-1,0,0,"class<`roxy_tag`, `roxy_tag_backref`>",1
+roxygen2,roxy_tag,-1,0,1,"class<`roxy_tag`, `roxy_tag_description`>",1
+roxygen2,roxy_tag,-1,0,2,"class<`roxy_tag`, `roxy_tag_.formals`>",1
+roxygen2,roxy_tag,-1,0,3,"class<`roxy_tag`, `roxy_tag_name`>",1
+roxygen2,roxy_tag,-1,0,4,"class<`roxy_tag`, `roxy_tag_title`>",1
+roxygen2,roxy_tag,-1,0,5,"class<`roxy_tag`, `roxy_tag_usage`>",1
+roxygen2,roxy_tag,0,0,0,character,1
+roxygen2,roxy_tag,1,0,0,character,1
+roxygen2,roxy_tag,1,0,1,null,1
+roxygen2,roxy_tag,2,0,0,null,1
+roxygen2,roxy_tag,2,0,1,character[],1
+roxygen2,roxy_tag,2,0,2,class<`rd`>,1
+roxygen2,roxy_tag,3,0,0,null,1
+roxygen2,roxy_tag,3,0,1,character,1
+roxygen2,roxy_tag,4,0,0,null,1
+roxygen2,roxy_tag,4,0,1,double,1
+roxygen2,roxy_tag_parse.roxy_tag_description,-1,0,0,"class<`roxy_tag`, `roxy_tag_description`>",1
+roxygen2,roxy_tag_parse.roxy_tag_description,0,0,0,"class<`roxy_tag`, `roxy_tag_description`>",1
+roxygen2,roxy_tag_parse.roxy_tag_export,-1,0,0,"class<`roxy_tag`, `roxy_tag_export`>",1
+roxygen2,roxy_tag_parse.roxy_tag_export,0,0,0,"class<`roxy_tag`, `roxy_tag_export`>",1
+roxygen2,roxy_tag_parse.roxy_tag_md,-1,0,0,"class<`roxy_tag`, `roxy_tag_md`>",1
+roxygen2,roxy_tag_parse.roxy_tag_md,0,0,0,"class<`roxy_tag`, `roxy_tag_md`>",1
+roxygen2,roxy_tag_parse.roxy_tag_param,-1,0,0,"class<`roxy_tag`, `roxy_tag_param`>",1
+roxygen2,roxy_tag_parse.roxy_tag_param,0,0,0,"class<`roxy_tag`, `roxy_tag_param`>",1
+roxygen2,roxy_tag_parse.roxy_tag_title,-1,0,0,"class<`roxy_tag`, `roxy_tag_title`>",1
+roxygen2,roxy_tag_parse.roxy_tag_title,0,0,0,"class<`roxy_tag`, `roxy_tag_title`>",1
+roxygen2,roxy_tag_rd,-1,0,0,"class<`rd_section`, `rd_section_backref`>",1
+roxygen2,roxy_tag_rd,-1,0,1,"class<`rd_section`, `rd_section_formals`>",1
+roxygen2,roxy_tag_rd,-1,0,2,"class<`rd_section`, `rd_section_tip`>",1
+roxygen2,roxy_tag_rd,-1,0,3,"class<`rd_section`, `rd_section_title`>",1
+roxygen2,roxy_tag_rd,-1,0,4,"class<`rd_section`, `rd_section_usage`>",1
+roxygen2,roxy_tag_rd,-1,0,5,null,1
+roxygen2,roxy_tag_rd,0,0,0,"class<`roxy_tag`, `roxy_tag_backref`>",1
+roxygen2,roxy_tag_rd,0,0,1,"class<`roxy_tag`, `roxy_tag_.formals`>",1
+roxygen2,roxy_tag_rd,0,0,2,"class<`roxy_tag`, `roxy_tag_tip`>",1
+roxygen2,roxy_tag_rd,0,0,3,"class<`roxy_tag`, `roxy_tag_title`>",1
+roxygen2,roxy_tag_rd,0,0,4,"class<`roxy_tag`, `roxy_tag_usage`>",1
+roxygen2,roxy_tag_rd,0,0,5,"class<`roxy_tag`, `roxy_tag_md`>",1
+roxygen2,roxy_tag_rd,1,0,0,any,1
+roxygen2,roxy_tag_rd,2,0,0,any,1
+roxygen2,roxy_tag_rd.default,-1,0,0,null,1
+roxygen2,roxy_tag_rd.default,0,0,0,"class<`roxy_tag`, `roxy_tag_md`>",1
+roxygen2,roxy_tag_rd.default,1,0,0,any,1
+roxygen2,roxy_tag_rd.default,2,0,0,any,1
+roxygen2,roxy_tag_rd.roxy_tag_backref,-1,0,0,"class<`rd_section`, `rd_section_backref`>",1
+roxygen2,roxy_tag_rd.roxy_tag_backref,0,0,0,"class<`roxy_tag`, `roxy_tag_backref`>",1
+roxygen2,roxy_tag_rd.roxy_tag_backref,1,0,0,any,1
+roxygen2,roxy_tag_rd.roxy_tag_backref,2,0,0,any,1
+roxygen2,roxy_tag_rd.roxy_tag_.formals,-1,0,0,"class<`rd_section`, `rd_section_formals`>",1
+roxygen2,roxy_tag_rd.roxy_tag_.formals,0,0,0,"class<`roxy_tag`, `roxy_tag_.formals`>",1
+roxygen2,roxy_tag_rd.roxy_tag_.formals,1,0,0,any,1
+roxygen2,roxy_tag_rd.roxy_tag_.formals,2,0,0,any,1
+roxygen2,roxy_tag_rd.roxy_tag_title,-1,0,0,"class<`rd_section`, `rd_section_title`>",1
+roxygen2,roxy_tag_rd.roxy_tag_title,0,0,0,"class<`roxy_tag`, `roxy_tag_title`>",1
+roxygen2,roxy_tag_rd.roxy_tag_title,1,0,0,any,1
+roxygen2,roxy_tag_rd.roxy_tag_title,2,0,0,any,1
+roxygen2,roxy_tag_rd.roxy_tag_usage,-1,0,0,"class<`rd_section`, `rd_section_usage`>",1
+roxygen2,roxy_tag_rd.roxy_tag_usage,0,0,0,"class<`roxy_tag`, `roxy_tag_usage`>",1
+roxygen2,roxy_tag_rd.roxy_tag_usage,1,0,0,any,1
+roxygen2,roxy_tag_rd.roxy_tag_usage,2,0,0,any,1
+roxygen2,strip,-1,0,0,character,1
+roxygen2,strip,0,0,0,character,1
+roxygen2,str_sub_same,-1,0,0,character,1
+roxygen2,str_sub_same,0,0,0,character,1
+roxygen2,str_sub_same,1,0,0,class<`data.frame`>,1
+roxygen2,str_sub_same,2,0,0,any,1
+roxygen2,tag_markdown,-1,0,0,"class<`roxy_tag`, `roxy_tag_tip`>",1
+roxygen2,tag_markdown,-1,0,1,"class<`roxy_tag`, `roxy_tag_title`>",1
+roxygen2,tag_markdown,0,0,0,"class<`roxy_tag`, `roxy_tag_tip`>",1
+roxygen2,tag_markdown,0,0,1,"class<`roxy_tag`, `roxy_tag_title`>",1
+roxygen2,tag_markdown_with_sections,-1,0,0,"class<`roxy_tag`, `roxy_tag_description`>",1
+roxygen2,tag_markdown_with_sections,0,0,0,"class<`roxy_tag`, `roxy_tag_description`>",1
+roxygen2,tag_name_description,-1,0,0,"class<`roxy_tag`, `roxy_tag_param`>",1
+roxygen2,tag_name_description,0,0,0,"class<`roxy_tag`, `roxy_tag_param`>",1
+roxygen2,tag_toggle,-1,0,0,"class<`roxy_tag`, `roxy_tag_md`>",1
+roxygen2,tag_toggle,0,0,0,"class<`roxy_tag`, `roxy_tag_md`>",1
+roxygen2,tag_two_part,-1,0,0,"class<`roxy_tag`, `roxy_tag_param`>",1
+roxygen2,tag_two_part,0,0,0,"class<`roxy_tag`, `roxy_tag_param`>",1
+roxygen2,tag_two_part,1,0,0,character,1
+roxygen2,tag_two_part,2,0,0,character,1
+roxygen2,tag_two_part,3,0,0,logical,1
+roxygen2,tag_two_part,4,0,0,logical,1
+roxygen2,tag_words_line,-1,0,0,"class<`roxy_tag`, `roxy_tag_export`>",1
+roxygen2,tag_words_line,0,0,0,"class<`roxy_tag`, `roxy_tag_export`>",1
+roxygen2,tokenise_block,-1,0,0,"list<class<`roxy_tag`, `roxy_tag_`> | class<`roxy_tag`, `roxy_tag_param`> | class<`roxy_tag`, `roxy_tag_export`>>",1
+roxygen2,tokenise_block,-1,0,1,"list<class<`roxy_tag`, `roxy_tag_`> | class<`roxy_tag`, `roxy_tag_tip`> | class<`roxy_tag`, `roxy_tag_md`>>",1
+roxygen2,tokenise_block,-1,0,2,"list<class<`roxy_tag`, `roxy_tag_memo`>>",1
+roxygen2,tokenise_block,0,0,0,character[],1
+roxygen2,tokenise_block,1,0,0,character,1
+roxygen2,tokenise_block,2,0,0,integer,1
+roxygen2,tokenize_file,-1,0,0,list<class<`roxy_block`>>,1
+roxygen2,tokenize_file,0,0,0,character,1
+roxygen2,tokenize_file,1,0,0,character,1
+roxygen2,topic_add_describe_in,-1,0,0,null,1
+roxygen2,topic_add_describe_in,0,0,0,any,1
+roxygen2,topic_add_describe_in,1,0,0,"class<`roxy_block`, `roxy_block_function`, `roxy_block_object`>",1
+roxygen2,topic_add_describe_in,2,0,0,any,1
+roxygen2,topic_add_name_aliases,-1,0,0,null,1
+roxygen2,topic_add_name_aliases,0,0,0,"class<`R6`, `RoxyTopic`>",1
+roxygen2,topic_add_name_aliases,1,0,0,"class<`roxy_block`, `roxy_block_function`, `roxy_block_object`>",1
+roxygen2,topic_add_name_aliases,2,0,0,character,1
+roxygen2,topics_add_default_description,-1,0,0,null,1
+roxygen2,topics_add_default_description,0,0,0,"class<`R6`, `RoxyTopics`>",1
+roxygen2,topics_fix_params_order,-1,0,0,null,1
+roxygen2,topics_fix_params_order,0,0,0,"class<`R6`, `RoxyTopics`>",1
+roxygen2,topics_process_family,-1,0,0,null,1
+roxygen2,topics_process_family,0,0,0,"class<`R6`, `RoxyTopics`>",1
+roxygen2,topics_process_family,1,0,0,any,1
+roxygen2,topics_process_inherit,-1,0,0,null,1
+roxygen2,topics_process_inherit,0,0,0,"class<`R6`, `RoxyTopics`>",1
+roxygen2,topics_process_inherit,1,0,0,any,1
+roxygen2,trim_docstring,-1,0,0,character,1
+roxygen2,trim_docstring,0,0,0,character,1
+roxygen2,usage_args,-1,0,0,character[],1
+roxygen2,usage_args,0,0,0,pairlist,1
+roxygen2,uuid,-1,0,0,character,1
+roxygen2,uuid,0,0,0,double,1
+roxygen2,wrap_usage,-1,0,0,class<`rd`>,1
+roxygen2,wrap_usage,0,0,0,character,1
+roxygen2,wrap_usage,1,0,0,class<`function`>,1
+roxygen2,wrap_usage,2,0,0,pairlist,1
+roxygen2,wrap_usage,3,0,0,null,1
+roxygen2,wrap_usage,4,0,0,integer,1
+roxygen2,write_lines,-1,0,0,integer,1
+roxygen2,write_lines,0,0,0,character,1
+roxygen2,write_lines,1,0,0,character,1
+roxygen2,write_lines,2,0,0,character,1
+rpart,descendants,-1,0,0,class<`matrix`>,1
+rpart,descendants,0,0,0,double[],1
+rpart,descendants,1,0,0,logical,1
+rpart,formatg,-1,0,0,character[],1
+rpart,formatg,-1,0,1,class<`matrix`>,1
+rpart,formatg,0,0,0,double[],1
+rpart,formatg,0,0,1,class<`matrix`>,1
+rpart,formatg,1,0,0,any,1
+rpart,formatg,2,0,0,character,1
+rpart,importance,-1,0,0,double[],1
+rpart,importance,0,0,0,list<any>,1
+rpart,importance,0,0,1,class<`rpart`>,1
+rpart,labels.rpart,-1,0,0,character[],1
+rpart,labels.rpart,0,0,0,class<`rpart`>,1
+rpart,labels.rpart,1,0,0,double,1
+rpart,labels.rpart,2,0,0,any,1
+rpart,labels.rpart,3,0,0,any,1
+rpart,labels.rpart,4,0,0,logical,1
+rpart,labels.rpart,5,0,0,...,1
+rpart,meanvar,-1,0,0,list<double[] | character[]>,1
+rpart,meanvar,0,0,0,class<`rpart`>,1
+rpart,meanvar,1,0,0,...,1
+rpart,meanvar.rpart,-1,0,0,list<double[] | character[]>,1
+rpart,meanvar.rpart,0,0,0,class<`rpart`>,1
+rpart,meanvar.rpart,1,0,0,character,1
+rpart,meanvar.rpart,2,0,0,character,1
+rpart,meanvar.rpart,3,0,0,...,1
+rpart,node.match,-1,0,0,integer[],1
+rpart,node.match,0,0,0,double[],1
+rpart,node.match,1,0,0,double[],1
+rpart,node.match,2,0,0,any,1
+rpart,node.match,3,0,0,logical,1
+rpart,path.rpart,-1,0,0,list<character[]>,1
+rpart,path.rpart,0,0,0,class<`rpart`>,1
+rpart,path.rpart,1,0,0,double[],1
+rpart,path.rpart,2,0,0,double,1
+rpart,path.rpart,3,0,0,logical,1
+rpart,plot.rpart,-1,0,0,list<double[]>,1
+rpart,plot.rpart,0,0,0,class<`rpart`>,1
+rpart,plot.rpart,1,0,0,logical,1
+rpart,plot.rpart,2,0,0,double,1
+rpart,plot.rpart,3,0,0,logical,1
+rpart,plot.rpart,4,0,0,any,1
+rpart,plot.rpart,5,0,0,double,1
+rpart,plot.rpart,6,0,0,double,1
+rpart,plot.rpart,7,0,0,...,1
+rpart,predict.rpart,-1,0,0,class<`factor`>,1
+rpart,predict.rpart,-1,0,1,class<`matrix`>,1
+rpart,predict.rpart,-1,0,2,double[],1
+rpart,predict.rpart,0,0,0,class<`rpart`>,1
+rpart,predict.rpart,1,0,0,any,1
+rpart,predict.rpart,2,0,0,character[],1
+rpart,predict.rpart,3,0,0,any,1
+rpart,predict.rpart,4,0,0,...,1
+rpart,pred.rpart,-1,0,0,double[],1
+rpart,pred.rpart,0,0,0,class<`rpart`>,1
+rpart,pred.rpart,1,0,0,"class<`matrix`, `rpart.matrix`>",1
+rpart,printcp,-1,0,0,class<`matrix`>,1
+rpart,printcp,0,0,0,class<`rpart`>,1
+rpart,printcp,1,0,0,integer,1
+rpart,print.rpart,-1,0,0,class<`rpart`>,1
+rpart,print.rpart,0,0,0,class<`rpart`>,1
+rpart,print.rpart,1,0,0,integer,1
+rpart,print.rpart,2,0,0,integer,1
+rpart,print.rpart,3,0,0,any,1
+rpart,print.rpart,4,0,0,integer,1
+rpart,print.rpart,5,0,0,...,1
+rpart,prune,-1,0,0,class<`rpart`>,1
+rpart,prune,0,0,0,class<`rpart`>,1
+rpart,prune,1,0,0,...,1
+rpart,prune.rpart,-1,0,0,class<`rpart`>,1
+rpart,prune.rpart,0,0,0,class<`rpart`>,1
+rpart,prune.rpart,1,0,0,double,1
+rpart,prune.rpart,2,0,0,...,1
+rpart,residuals.rpart,-1,0,0,double[],1
+rpart,residuals.rpart,0,0,0,class<`rpart`>,1
+rpart,residuals.rpart,1,0,0,character[],1
+rpart,residuals.rpart,2,0,0,...,1
+rpart,rpart,-1,0,0,class<`rpart`>,1
+rpart,rpart,0,0,0,any,1
+rpart,rpart,1,0,0,any,1
+rpart,rpart,2,0,0,any,1
+rpart,rpart,3,0,0,any,1
+rpart,rpart,4,0,0,class<`function`>,1
+rpart,rpart,5,0,0,any,1
+rpart,rpart,6,0,0,logical,1
+rpart,rpart,7,0,0,logical,1
+rpart,rpart.branch,-1,0,0,list<class<`matrix`>>,1
+rpart,rpart.branch,0,0,0,double[],1
+rpart,rpart.branch,1,0,0,double[],1
+rpart,rpart.branch,2,0,0,double[],1
+rpart,rpart.branch,3,0,0,any,1
+rpart,rpartcallback,-1,0,0,list<class<`{`> | environment>,1
+rpart,rpartcallback,0,0,0,list<class<`function`>>,1
+rpart,rpartcallback,1,0,0,integer,1
+rpart,rpartcallback,2,0,0,list<double[] | class<`function`>>,1
+rpart,rpartcallback,2,0,1,list<double[] | null | class<`function`>>,1
+rpart,rpartcallback,2,0,2,list<double>,1
+rpart,rpartcallback,2,0,3,list<double | null>,1
+rpart,rpartco,-1,0,0,list<double[]>,1
+rpart,rpartco,0,0,0,class<`rpart`>,1
+rpart,rpartco,1,0,0,any,1
+rpart,rpart.control,-1,0,0,list<double | integer[]>,1
+rpart,rpart.control,-1,0,1,list<double>,1
+rpart,rpart.control,0,0,0,double,1
+rpart,rpart.control,1,0,0,double,1
+rpart,rpart.control,2,0,0,double,1
+rpart,rpart.control,3,0,0,double,1
+rpart,rpart.control,4,0,0,double,1
+rpart,rpart.control,5,0,0,double,1
+rpart,rpart.control,6,0,0,integer[],1
+rpart,rpart.control,6,0,1,double,1
+rpart,rpart.control,7,0,0,integer,1
+rpart,rpart.exp,-1,0,0,list<class<`matrix`> | integer[] | class<`function`>>,1
+rpart,rpart.exp,0,0,0,class<`Surv`>,1
+rpart,rpart.exp,1,0,0,null,1
+rpart,rpart.exp,2,0,0,any,1
+rpart,rpart.exp,3,0,0,any,1
+rpart,rpart.matrix,-1,0,0,"class<`matrix`, `rpart.matrix`>",1
+rpart,rpart.matrix,0,0,0,class<`data.frame`>,1
+rpart,rsq.rpart,-1,0,0,null,1
+rpart,rsq.rpart,0,0,0,class<`rpart`>,1
+rpart,snip.rpart,-1,0,0,class<`rpart`>,1
+rpart,snip.rpart,0,0,0,class<`rpart`>,1
+rpart,snip.rpart,1,0,0,double,1
+rpart,snip.rpart,1,0,1,integer[],1
+rpart,string.bounding.box,-1,0,0,list<integer[]>,1
+rpart,string.bounding.box,0,0,0,character[],1
+rpart,summary.rpart,-1,0,0,class<`rpart`>,1
+rpart,summary.rpart,0,0,0,class<`rpart`>,1
+rpart,summary.rpart,1,0,0,double,1
+rpart,summary.rpart,2,0,0,integer,1
+rpart,summary.rpart,3,0,0,any,1
+rpart,summary.rpart,4,0,0,...,1
+rpart,text.rpart,-1,0,0,null,1
+rpart,text.rpart,0,0,0,class<`rpart`>,1
+rpart,text.rpart,1,0,0,logical,1
+rpart,text.rpart,2,0,0,any,1
+rpart,text.rpart,3,0,0,class<`function`>,1
+rpart,text.rpart,4,0,0,logical,1
+rpart,text.rpart,5,0,0,null,1
+rpart,text.rpart,6,0,0,integer,1
+rpart,text.rpart,7,0,0,logical,1
+rpart,tree.depth,-1,0,0,double[],1
+rpart,tree.depth,0,0,0,double[],1
+rpart,xpred.rpart,-1,0,0,class<`array`>,1
+rpart,xpred.rpart,-1,0,1,class<`matrix`>,1
+rpart,xpred.rpart,0,0,0,class<`rpart`>,1
+rpart,xpred.rpart,1,0,0,integer[],1
+rpart,xpred.rpart,2,0,0,any,1
+rpart,xpred.rpart,3,0,0,logical,1
+rprojroot,check_testfun,-1,0,0,list<class<`function`>>,1
+rprojroot,check_testfun,0,0,0,class<`function`>,1
+rprojroot,has_file,-1,0,0,class<`root_criterion`>,1
+rprojroot,has_file,0,0,0,character,1
+rprojroot,has_file,1,0,0,null,1
+rprojroot,has_file,2,0,0,integer,1
+rprojroot,make_find_root_file,-1,0,0,class<`function`>,1
+rprojroot,make_find_root_file,0,0,0,class<`root_criterion`>,1
+rprojroot,root_criterion,-1,0,0,class<`root_criterion`>,1
+rprojroot,root_criterion,0,0,0,class<`function`>,1
+rprojroot,root_criterion,1,0,0,character,1
+rprojroot,root_criterion,2,0,0,null,1
+rprojroot,thisfile_source,-1,0,0,character,1
+rrcov,.allcovClass,-1,0,0,class<`allcov`>,1
+rrcov,.allcovClass,0,0,0,class<`matrix`>,1
+rrcov,.allcovClass,1,0,0,class<`factor`>,1
+rrcov,.allcovMcd,-1,0,0,class<`allcov`>,1
+rrcov,.allcovMcd,0,0,0,class<`matrix`>,1
+rrcov,.allcovMcd,1,0,0,class<`factor`>,1
+rrcov,.allcovMcd,2,0,0,character,1
+rrcov,.allcovMcd,2,0,1,class<`CovControlOgk`>,1
+rrcov,.allcovMcd,3,0,0,...,1
+rrcov,arpLim,-1,0,0,double[],1
+rrcov,arpLim,0,0,0,class<`PsiBwt`>,1
+rrcov,arpLim,-1,1,0,double[],1
+rrcov,arpLim,0,1,0,class<`PsiBwt`>,1
+rrcov,biplot,-1,0,0,null,1
+rrcov,biplot,0,0,0,class<`PcaClassic`>,1
+rrcov,biplot,1,0,0,...,1
+rrcov,biplot,-1,1,0,null,1
+rrcov,biplot,0,1,0,class<`PcaProj`>,1
+rrcov,biplot,1,1,0,...,1
+rrcov,biplot,-1,2,0,null,1
+rrcov,biplot,0,2,0,class<`PcaCov`>,1
+rrcov,biplot,1,2,0,...,1
+rrcov,biplot,-1,3,0,null,1
+rrcov,biplot,0,3,0,class<`PcaLocantore`>,1
+rrcov,biplot,1,3,0,...,1
+rrcov,biplot,-1,4,0,null,1
+rrcov,biplot,0,4,0,class<`PcaGrid`>,1
+rrcov,biplot,1,4,0,...,1
+rrcov,biplot,-1,5,0,null,1
+rrcov,biplot,0,5,0,class<`PcaHubert`>,1
+rrcov,biplot,1,5,0,...,1
+rrcov,.biplot,-1,0,0,null,1
+rrcov,.biplot,0,0,0,class<`matrix`>,1
+rrcov,.biplot,1,0,0,class<`matrix`>,1
+rrcov,.biplot,2,0,0,any,1
+rrcov,.biplot,3,0,0,logical,1
+rrcov,.biplot,4,0,0,any,1
+rrcov,.biplot,5,0,0,double[],1
+rrcov,.biplot,6,0,0,null,1
+rrcov,.biplot,7,0,0,null,1
+rrcov,.check_vars_numeric,-1,0,0,logical,1
+rrcov,.check_vars_numeric,0,0,0,class<`data.frame`>,1
+rrcov,.chiInt,-1,0,0,double,1
+rrcov,.chiInt,0,0,0,integer,1
+rrcov,.chiInt,1,0,0,double,1
+rrcov,.chiInt,2,0,0,double,1
+rrcov,.chiInt2,-1,0,0,double,1
+rrcov,.chiInt2,0,0,0,integer,1
+rrcov,.chiInt2,1,0,0,double,1
+rrcov,.chiInt2,2,0,0,double,1
+rrcov,.chiInt2D,-1,0,0,double,1
+rrcov,.chiInt2D,0,0,0,integer,1
+rrcov,.chiInt2D,1,0,0,double,1
+rrcov,.chiInt2D,2,0,0,double,1
+rrcov,.chiIntD,-1,0,0,double,1
+rrcov,.chiIntD,0,0,0,integer,1
+rrcov,.chiIntD,1,0,0,double,1
+rrcov,.chiIntD,2,0,0,double,1
+rrcov,.classPC,-1,0,0,list<double[] | class<`matrix`>>,1
+rrcov,.classPC,-1,0,1,list<double[] | class<`matrix`> | null>,1
+rrcov,.classPC,-1,0,2,list<double | null>,1
+rrcov,.classPC,0,0,0,class<`matrix`>,1
+rrcov,.classPC,1,0,0,logical,1
+rrcov,.classPC,2,0,0,logical,1
+rrcov,.classPC,3,0,0,logical,1
+rrcov,.classPC,4,0,0,logical,1
+rrcov,.classPC,5,0,0,logical,1
+rrcov,.confusion,-1,0,0,class<`table`>,1
+rrcov,.confusion,0,0,0,class<`factor`>,1
+rrcov,.confusion,1,0,0,class<`factor`>,1
+rrcov,.confusion,2,0,0,null,1
+rrcov,.confusion,3,0,0,logical,1
+rrcov,Cov,-1,0,0,class<`CovClassic`>,1
+rrcov,Cov,0,0,0,class<`matrix`>,1
+rrcov,Cov,1,0,0,logical,1
+rrcov,CovClassic,-1,0,0,class<`CovClassic`>,1
+rrcov,CovClassic,0,0,0,class<`data.frame`>,1
+rrcov,CovClassic,0,0,1,class<`matrix`>,1
+rrcov,CovClassic,1,0,0,logical,1
+rrcov,CovControlMcd,-1,0,0,class<`CovControlMcd`>,1
+rrcov,CovControlMcd,0,0,0,double,1
+rrcov,CovControlMcd,1,0,0,double,1
+rrcov,CovControlMcd,2,0,0,null,1
+rrcov,CovControlMcd,3,0,0,double,1
+rrcov,CovControlMcd,4,0,0,null,1
+rrcov,CovControlMcd,5,0,0,logical,1
+rrcov,CovControlMcd,6,0,0,logical,1
+rrcov,CovControlMest,-1,0,0,class<`CovControlMest`>,1
+rrcov,CovControlMest,0,0,0,double,1
+rrcov,CovControlMest,1,0,0,double,1
+rrcov,CovControlMest,2,0,0,double,1
+rrcov,CovControlMest,3,0,0,double,1
+rrcov,CovControlMMest,-1,0,0,class<`CovControlMMest`>,1
+rrcov,CovControlMMest,0,0,0,double,1
+rrcov,CovControlMMest,1,0,0,double,1
+rrcov,CovControlMMest,2,0,0,double,1
+rrcov,CovControlMMest,3,0,0,class<`CovControlSest`>,1
+rrcov,CovControlMMest,4,0,0,logical,1
+rrcov,CovControlMMest,5,0,0,double,1
+rrcov,CovControlMrcd,-1,0,0,class<`CovControlMrcd`>,1
+rrcov,CovControlMrcd,0,0,0,double,1
+rrcov,CovControlMrcd,1,0,0,null,1
+rrcov,CovControlMrcd,2,0,0,double,1
+rrcov,CovControlMrcd,3,0,0,null,1
+rrcov,CovControlMrcd,4,0,0,character[],1
+rrcov,CovControlMrcd,5,0,0,double,1
+rrcov,CovControlMrcd,6,0,0,logical,1
+rrcov,CovControlMve,-1,0,0,class<`CovControlMve`>,1
+rrcov,CovControlMve,0,0,0,double,1
+rrcov,CovControlMve,1,0,0,double,1
+rrcov,CovControlMve,2,0,0,null,1
+rrcov,CovControlMve,3,0,0,logical,1
+rrcov,CovControlOgk,-1,0,0,class<`CovControlOgk`>,1
+rrcov,CovControlOgk,0,0,0,double,1
+rrcov,CovControlOgk,1,0,0,double,1
+rrcov,CovControlOgk,2,0,0,null,1
+rrcov,CovControlOgk,3,0,0,class<`function`>,1
+rrcov,CovControlOgk,4,0,0,character,1
+rrcov,CovControlOgk,5,0,0,character,1
+rrcov,CovControlSde,-1,0,0,class<`CovControlSde`>,1
+rrcov,CovControlSde,0,0,0,double,1
+rrcov,CovControlSde,1,0,0,double,1
+rrcov,CovControlSde,2,0,0,double,1
+rrcov,CovControlSde,3,0,0,double,1
+rrcov,CovControlSde,4,0,0,double,1
+rrcov,CovControlSde,5,0,0,null,1
+rrcov,CovControlSde,6,0,0,logical,1
+rrcov,CovControlSde,7,0,0,double,1
+rrcov,CovControlSest,-1,0,0,class<`CovControlSest`>,1
+rrcov,CovControlSest,0,0,0,double,1
+rrcov,CovControlSest,1,0,0,double,1
+rrcov,CovControlSest,2,0,0,double,1
+rrcov,CovControlSest,3,0,0,double,1
+rrcov,CovControlSest,4,0,0,double,1
+rrcov,CovControlSest,5,0,0,null,1
+rrcov,CovControlSest,6,0,0,logical,1
+rrcov,CovControlSest,7,0,0,double,1
+rrcov,CovMcd,-1,0,0,class<`CovMcd`>,1
+rrcov,CovMcd,0,0,0,class<`data.frame`>,1
+rrcov,CovMcd,0,0,1,"class<`data.frame`, `groupedData`, `nfGroupedData`, `nfnGroupedData`>",1
+rrcov,CovMcd,0,0,2,class<`matrix`>,1
+rrcov,CovMcd,1,0,0,logical,1
+rrcov,CovMcd,2,0,0,double,1
+rrcov,CovMcd,3,0,0,character,1
+rrcov,CovMcd,3,0,1,double,1
+rrcov,CovMcd,4,0,0,any,1
+rrcov,CovMcd,5,0,0,any,1
+rrcov,CovMcd,6,0,0,null,1
+rrcov,CovMcd,7,0,0,logical,1
+rrcov,CovMest,-1,0,0,class<`CovMest`>,1
+rrcov,CovMest,0,0,0,class<`data.frame`>,1
+rrcov,CovMest,0,0,1,class<`matrix`>,1
+rrcov,CovMest,1,0,0,double,1
+rrcov,CovMest,2,0,0,double,1
+rrcov,CovMest,3,0,0,double,1
+rrcov,CovMest,4,0,0,double,1
+rrcov,CovMest,5,0,0,any,1
+rrcov,CovMest,6,0,0,any,1
+rrcov,CovMest,7,0,0,any,1
+rrcov,CovMMest,-1,0,0,class<`CovMMest`>,1
+rrcov,CovMMest,0,0,0,class<`data.frame`>,1
+rrcov,CovMMest,0,0,1,"class<`data.frame`, `groupedData`, `nfGroupedData`, `nfnGroupedData`>",1
+rrcov,CovMMest,0,0,2,class<`matrix`>,1
+rrcov,CovMMest,1,0,0,double,1
+rrcov,CovMMest,2,0,0,double,1
+rrcov,CovMMest,3,0,0,logical,1
+rrcov,CovMMest,4,0,0,double,1
+rrcov,CovMMest,5,0,0,logical,1
+rrcov,CovMMest,6,0,0,double,1
+rrcov,CovMMest,7,0,0,any,1
+rrcov,CovMrcd,-1,0,0,class<`CovMrcd`>,1
+rrcov,CovMrcd,0,0,0,class<`data.frame`>,1
+rrcov,CovMrcd,0,0,1,"class<`data.frame`, `groupedData`, `nfGroupedData`, `nfnGroupedData`>",1
+rrcov,CovMrcd,0,0,2,class<`matrix`>,1
+rrcov,CovMrcd,1,0,0,double,1
+rrcov,CovMrcd,2,0,0,null,1
+rrcov,CovMrcd,3,0,0,double,1
+rrcov,CovMrcd,4,0,0,null,1
+rrcov,CovMrcd,5,0,0,logical,1
+rrcov,CovMrcd,6,0,0,null,1
+rrcov,CovMrcd,7,0,0,character,1
+rrcov,CovMve,-1,0,0,class<`CovMve`>,1
+rrcov,CovMve,0,0,0,class<`data.frame`>,1
+rrcov,CovMve,0,0,1,class<`matrix`>,1
+rrcov,CovMve,1,0,0,double,1
+rrcov,CovMve,2,0,0,double,1
+rrcov,CovMve,3,0,0,null,1
+rrcov,CovMve,4,0,0,logical,1
+rrcov,CovMve,5,0,0,any,1
+rrcov,covMWcd,-1,0,0,class<`mwcd`>,1
+rrcov,covMWcd,0,0,0,class<`matrix`>,1
+rrcov,covMWcd,1,0,0,class<`factor`>,1
+rrcov,covMWcd,2,0,0,double,1
+rrcov,CovOgk,-1,0,0,class<`CovOgk`>,1
+rrcov,CovOgk,0,0,0,class<`data.frame`>,1
+rrcov,CovOgk,0,0,1,class<`matrix`>,1
+rrcov,CovOgk,1,0,0,double,1
+rrcov,CovOgk,2,0,0,double,1
+rrcov,CovOgk,3,0,0,any,1
+rrcov,CovRobust,-1,0,0,class<`CovMcd`>,1
+rrcov,CovRobust,-1,0,1,class<`CovMest`>,1
+rrcov,CovRobust,-1,0,2,class<`CovOgk`>,1
+rrcov,CovRobust,-1,0,3,class<`CovSde`>,1
+rrcov,CovRobust,-1,0,4,class<`CovSest`>,1
+rrcov,CovRobust,0,0,0,class<`matrix`>,1
+rrcov,CovRobust,0,0,1,class<`data.frame`>,1
+rrcov,CovRobust,1,0,0,any,1
+rrcov,CovRobust,2,0,0,class<`function`>,1
+rrcov,.covRobustControl,-1,0,0,class<`CovControlMcd`>,1
+rrcov,.covRobustControl,-1,0,1,class<`CovControlMest`>,1
+rrcov,.covRobustControl,-1,0,2,class<`CovControlOgk`>,1
+rrcov,.covRobustControl,-1,0,3,class<`CovControlSde`>,1
+rrcov,.covRobustControl,-1,0,4,class<`CovControlSest`>,1
+rrcov,.covRobustControl,0,0,0,any,1
+rrcov,.covRobustControl,1,0,0,any,1
+rrcov,.covRobustControl,2,0,0,any,1
+rrcov,..covSBic,-1,0,0,list<double[] | class<`matrix`> | character>,1
+rrcov,..covSBic,0,0,0,class<`matrix`>,1
+rrcov,..covSBic,1,0,0,any,1
+rrcov,..covSBic,2,0,0,double,1
+rrcov,..covSBic,3,0,0,double,1
+rrcov,..covSBic,4,0,0,any,1
+rrcov,..covSBic,5,0,0,any,1
+rrcov,..covSBic,6,0,0,double,1
+rrcov,..covSBic,7,0,0,null,1
+rrcov,CovSde,-1,0,0,class<`CovSde`>,1
+rrcov,CovSde,0,0,0,class<`data.frame`>,1
+rrcov,CovSde,0,0,1,class<`matrix`>,1
+rrcov,CovSde,1,0,0,any,1
+rrcov,CovSde,2,0,0,any,1
+rrcov,CovSde,3,0,0,double,1
+rrcov,CovSde,4,0,0,double,1
+rrcov,CovSde,5,0,0,double,1
+rrcov,CovSde,6,0,0,null,1
+rrcov,CovSde,7,0,0,logical,1
+rrcov,CovSest,-1,0,0,class<`CovSest`>,1
+rrcov,CovSest,0,0,0,class<`data.frame`>,1
+rrcov,CovSest,0,0,1,"class<`data.frame`, `groupedData`, `nfGroupedData`, `nfnGroupedData`>",1
+rrcov,CovSest,0,0,2,class<`matrix`>,1
+rrcov,CovSest,1,0,0,double,1
+rrcov,CovSest,2,0,0,double,1
+rrcov,CovSest,3,0,0,double,1
+rrcov,CovSest,4,0,0,double,1
+rrcov,CovSest,5,0,0,double,1
+rrcov,CovSest,6,0,0,null,1
+rrcov,CovSest,7,0,0,logical,1
+rrcov,..covSRocke,-1,0,0,list<double[] | class<`matrix`> | character>,1
+rrcov,..covSRocke,0,0,0,class<`matrix`>,1
+rrcov,..covSRocke,1,0,0,double,1
+rrcov,..covSRocke,2,0,0,double,1
+rrcov,..covSRocke,3,0,0,double,1
+rrcov,..covSRocke,4,0,0,any,1
+rrcov,..covSRocke,5,0,0,any,1
+rrcov,..covSRocke,6,0,0,double,1
+rrcov,..covSRocke,7,0,0,null,1
+rrcov,..covSURREAL,-1,0,0,list<double[] | class<`matrix`> | character>,1
+rrcov,..covSURREAL,0,0,0,class<`matrix`>,1
+rrcov,..covSURREAL,1,0,0,double,1
+rrcov,..covSURREAL,2,0,0,double,1
+rrcov,..covSURREAL,3,0,0,double,1
+rrcov,..covSURREAL,4,0,0,any,1
+rrcov,..covSURREAL,5,0,0,any,1
+rrcov,.crit.od,-1,0,0,double,1
+rrcov,.crit.od,0,0,0,double[],1
+rrcov,.crit.od,1,0,0,double,1
+rrcov,.crit.od,2,0,0,logical,1
+rrcov,.crit.od,3,0,0,any,1
+rrcov,.crit.od,4,0,0,logical,1
+rrcov,..CSloc,-1,0,0,list<double[] | class<`matrix`> | character>,1
+rrcov,..CSloc,0,0,0,class<`matrix`>,1
+rrcov,..CSloc,1,0,0,double,1
+rrcov,..CSloc,2,0,0,double,1
+rrcov,..CSloc,3,0,0,double,1
+rrcov,..CSloc,4,0,0,double,1
+rrcov,..CSloc,5,0,0,double,1
+rrcov,..CSloc,6,0,0,any,1
+rrcov,csolve,-1,0,0,class<`PsiBwt`>,1
+rrcov,csolve,0,0,0,class<`PsiBwt`>,1
+rrcov,csolve,-1,1,0,class<`PsiBwt`>,1
+rrcov,csolve,0,1,0,class<`PsiBwt`>,1
+rrcov,.csolve.bw.MM,-1,0,0,double,1
+rrcov,.csolve.bw.MM,0,0,0,integer,1
+rrcov,.csolve.bw.MM,1,0,0,double,1
+rrcov,.csolve.bw.MM,2,0,0,logical,1
+rrcov,.csolve.bw.S,-1,0,0,list<double>,1
+rrcov,.csolve.bw.S,0,0,0,double,1
+rrcov,.csolve.bw.S,1,0,0,integer,1
+rrcov,.detmrcd,-1,0,0,list<double[] | class<`matrix`> | null>,1
+rrcov,.detmrcd,0,0,0,class<`matrix`>,1
+rrcov,.detmrcd,1,0,0,null,1
+rrcov,.detmrcd,2,0,0,double,1
+rrcov,.detmrcd,3,0,0,null,1
+rrcov,.detmrcd,4,0,0,double,1
+rrcov,.detmrcd,5,0,0,double,1
+rrcov,.detmrcd,6,0,0,double,1
+rrcov,.detmrcd,7,0,0,double,1
+rrcov,..detSloc,-1,0,0,list<any>,1
+rrcov,..detSloc,0,0,0,class<`matrix`>,1
+rrcov,..detSloc,1,0,0,null,1
+rrcov,..detSloc,2,0,0,logical,1
+rrcov,..detSloc,3,0,0,logical,1
+rrcov,..detSloc,4,0,0,class<`function`>,1
+rrcov,..detSloc,5,0,0,double,1
+rrcov,..detSloc,6,0,0,logical,1
+rrcov,..detSloc,7,0,0,double,1
+rrcov,.distances,-1,0,0,class<`PcaClassic`>,1
+rrcov,.distances,-1,0,1,class<`PcaCov`>,1
+rrcov,.distances,-1,0,2,class<`PcaGrid`>,1
+rrcov,.distances,-1,0,3,class<`PcaHubert`>,1
+rrcov,.distances,-1,0,4,class<`PcaLocantore`>,1
+rrcov,.distances,-1,0,5,class<`PcaProj`>,1
+rrcov,.distances,0,0,0,class<`matrix`>,1
+rrcov,.distances,0,0,1,class<`data.frame`>,1
+rrcov,.distances,1,0,0,integer,1
+rrcov,.distances,2,0,0,class<`PcaClassic`>,1
+rrcov,.distances,2,0,1,class<`PcaCov`>,1
+rrcov,.distances,2,0,2,class<`PcaGrid`>,1
+rrcov,.distances,2,0,3,class<`PcaHubert`>,1
+rrcov,.distances,2,0,4,class<`PcaLocantore`>,1
+rrcov,.distances,2,0,5,class<`PcaProj`>,1
+rrcov,.distances,3,0,0,double,1
+rrcov,erho,-1,0,0,double,1
+rrcov,erho,0,0,0,class<`PsiBwt`>,1
+rrcov,erho,-1,1,0,double,1
+rrcov,erho,0,1,0,class<`PsiBwt`>,1
+rrcov,erhoLim,-1,0,0,double,1
+rrcov,erhoLim,0,0,0,class<`PsiBwt`>,1
+rrcov,erhoLim,-1,1,0,double,1
+rrcov,erhoLim,0,1,0,class<`PsiBwt`>,1
+rrcov,erhoLimD,-1,0,0,double,1
+rrcov,erhoLimD,0,0,0,class<`PsiBwt`>,1
+rrcov,erhoLimD,-1,1,0,double,1
+rrcov,erhoLimD,0,1,0,class<`PsiBwt`>,1
+rrcov,extradir,-1,0,0,class<`matrix`>,1
+rrcov,extradir,0,0,0,class<`matrix`>,1
+rrcov,extradir,1,0,0,any,1
+rrcov,extradir,2,0,0,logical,1
+rrcov,.fastmve,-1,0,0,list<double[] | class<`matrix`>>,1
+rrcov,.fastmve,0,0,0,class<`matrix`>,1
+rrcov,.fastmve,1,0,0,double,1
+rrcov,.fastmve,2,0,0,double,1
+rrcov,.getApprox,-1,0,0,list<double>,1
+rrcov,.getApprox,0,0,0,integer,1
+rrcov,.getApprox,1,0,0,integer,1
+rrcov,getCenter,-1,0,0,double[],1
+rrcov,getCenter,0,0,0,class<`CovMve`>,1
+rrcov,getCenter,-1,1,0,double[],1
+rrcov,getCenter,0,1,0,class<`CovClassic`>,1
+rrcov,getCenter,-1,2,0,double[],1
+rrcov,getCenter,0,2,0,class<`CovClassic`>,1
+rrcov,getCenter,0,2,1,class<`CovMcd`>,1
+rrcov,getCenter,0,2,2,class<`CovSest`>,1
+rrcov,getCenter,0,2,3,class<`CovMest`>,1
+rrcov,getCenter,0,2,4,class<`CovMMest`>,1
+rrcov,getCenter,0,2,5,class<`CovOgk`>,1
+rrcov,getCenter,0,2,6,class<`CovSde`>,1
+rrcov,getCenter,0,2,7,class<`CovMrcd`>,1
+rrcov,getCenter,0,2,8,class<`CovMve`>,1
+rrcov,getCenter,-1,3,0,double[],1
+rrcov,getCenter,0,3,0,class<`CovMcd`>,1
+rrcov,getCenter,-1,4,0,double[],1
+rrcov,getCenter,0,4,0,class<`CovOgk`>,1
+rrcov,getCenter,-1,5,0,double[],1
+rrcov,getCenter,0,5,0,class<`CovSde`>,1
+rrcov,getCenter,-1,6,0,double[],1
+rrcov,getCenter,0,6,0,class<`CovMMest`>,1
+rrcov,getCenter,-1,7,0,double[],1
+rrcov,getCenter,0,7,0,class<`CovMest`>,1
+rrcov,getCenter,-1,8,0,double[],1
+rrcov,getCenter,0,8,0,class<`CovMrcd`>,1
+rrcov,getCenter,-1,9,0,double[],1
+rrcov,getCenter,0,9,0,class<`CovSest`>,1
+rrcov,getCorr,-1,0,0,class<`matrix`>,1
+rrcov,getCorr,0,0,0,class<`CovSest`>,1
+rrcov,getCorr,-1,1,0,class<`matrix`>,1
+rrcov,getCorr,0,1,0,class<`CovMcd`>,1
+rrcov,getCorr,-1,2,0,class<`matrix`>,1
+rrcov,getCorr,0,2,0,class<`CovClassic`>,1
+rrcov,getCorr,0,2,1,class<`CovMcd`>,1
+rrcov,getCorr,0,2,2,class<`CovOgk`>,1
+rrcov,getCorr,0,2,3,class<`CovSest`>,1
+rrcov,getCorr,-1,3,0,class<`matrix`>,1
+rrcov,getCorr,0,3,0,class<`CovClassic`>,1
+rrcov,getCorr,-1,4,0,class<`matrix`>,1
+rrcov,getCorr,0,4,0,class<`CovOgk`>,1
+rrcov,getCov,-1,0,0,class<`matrix`>,1
+rrcov,getCov,0,0,0,class<`CovOgk`>,1
+rrcov,getCov,-1,1,0,class<`matrix`>,1
+rrcov,getCov,0,1,0,class<`CovSest`>,1
+rrcov,getCov,-1,2,0,class<`matrix`>,1
+rrcov,getCov,0,2,0,class<`CovMest`>,1
+rrcov,getCov,-1,3,0,class<`matrix`>,1
+rrcov,getCov,0,3,0,class<`CovMcd`>,1
+rrcov,getCov,-1,4,0,class<`matrix`>,1
+rrcov,getCov,0,4,0,class<`CovMve`>,1
+rrcov,getCov,-1,5,0,class<`matrix`>,1
+rrcov,getCov,0,5,0,class<`CovClassic`>,1
+rrcov,getCov,-1,6,0,class<`matrix`>,1
+rrcov,getCov,0,6,0,class<`CovSde`>,1
+rrcov,getCov,-1,7,0,class<`matrix`>,1
+rrcov,getCov,0,7,0,class<`CovClassic`>,1
+rrcov,getCov,0,7,1,class<`CovMcd`>,1
+rrcov,getCov,0,7,2,class<`CovMest`>,1
+rrcov,getCov,0,7,3,class<`CovMMest`>,1
+rrcov,getCov,0,7,4,class<`CovMrcd`>,1
+rrcov,getCov,0,7,5,class<`CovMve`>,1
+rrcov,getCov,0,7,6,class<`CovOgk`>,1
+rrcov,getCov,0,7,7,class<`CovSde`>,1
+rrcov,getCov,0,7,8,class<`CovSest`>,1
+rrcov,getCov,-1,8,0,class<`matrix`>,1
+rrcov,getCov,0,8,0,class<`CovMMest`>,1
+rrcov,getCov,-1,9,0,class<`matrix`>,1
+rrcov,getCov,0,9,0,class<`CovMrcd`>,1
+rrcov,getData,-1,0,0,class<`matrix`>,1
+rrcov,getData,0,0,0,class<`CovClassic`>,1
+rrcov,getData,0,0,1,class<`CovMcd`>,1
+rrcov,getData,0,0,2,class<`CovMest`>,1
+rrcov,getData,0,0,3,class<`CovMMest`>,1
+rrcov,getData,0,0,4,class<`CovOgk`>,1
+rrcov,getData,0,0,5,class<`CovSde`>,1
+rrcov,getData,0,0,6,class<`CovSest`>,1
+rrcov,getData,-1,1,0,class<`matrix`>,1
+rrcov,getData,0,1,0,class<`CovMest`>,1
+rrcov,getData,-1,2,0,class<`matrix`>,1
+rrcov,getData,0,2,0,class<`CovOgk`>,1
+rrcov,getData,-1,3,0,class<`matrix`>,1
+rrcov,getData,0,3,0,class<`CovSest`>,1
+rrcov,getData,-1,4,0,class<`matrix`>,1
+rrcov,getData,0,4,0,class<`CovSde`>,1
+rrcov,getData,-1,5,0,class<`matrix`>,1
+rrcov,getData,0,5,0,class<`CovMMest`>,1
+rrcov,getData,-1,6,0,class<`matrix`>,1
+rrcov,getData,0,6,0,class<`CovClassic`>,1
+rrcov,getData,-1,7,0,class<`matrix`>,1
+rrcov,getData,0,7,0,class<`CovMcd`>,1
+rrcov,getDet,-1,0,0,double,1
+rrcov,getDet,0,0,0,class<`CovSest`>,1
+rrcov,getDet,-1,1,0,double,1
+rrcov,getDet,0,1,0,class<`CovSest`>,1
+rrcov,getDistance,-1,0,0,double[],1
+rrcov,getDistance,0,0,0,class<`CovMcd`>,1
+rrcov,getDistance,-1,1,0,double[],1
+rrcov,getDistance,0,1,0,class<`CovClassic`>,1
+rrcov,getDistance,0,1,1,class<`CovMcd`>,1
+rrcov,getDistance,0,1,2,class<`CovMest`>,1
+rrcov,getDistance,0,1,3,class<`CovMMest`>,1
+rrcov,getDistance,0,1,4,class<`CovOgk`>,1
+rrcov,getDistance,0,1,5,class<`CovSde`>,1
+rrcov,getDistance,0,1,6,class<`CovSest`>,1
+rrcov,getDistance,-1,2,0,double[],1
+rrcov,getDistance,0,2,0,class<`CovSde`>,1
+rrcov,getDistance,-1,3,0,double[],1
+rrcov,getDistance,0,3,0,class<`CovMMest`>,1
+rrcov,getDistance,-1,4,0,double[],1
+rrcov,getDistance,0,4,0,class<`CovClassic`>,1
+rrcov,getDistance,-1,5,0,double[],1
+rrcov,getDistance,0,5,0,class<`CovSest`>,1
+rrcov,getDistance,-1,6,0,double[],1
+rrcov,getDistance,0,6,0,class<`CovMest`>,1
+rrcov,getDistance,-1,7,0,double[],1
+rrcov,getDistance,0,7,0,class<`CovOgk`>,1
+rrcov,getEigenvalues,-1,0,0,double[],1
+rrcov,getEigenvalues,0,0,0,class<`PcaCov`>,1
+rrcov,getEigenvalues,-1,1,0,double[],1
+rrcov,getEigenvalues,0,1,0,class<`PcaHubert`>,1
+rrcov,getEigenvalues,-1,2,0,double[],1
+rrcov,getEigenvalues,0,2,0,class<`PcaClassic`>,1
+rrcov,getEigenvalues,-1,3,0,double[],1
+rrcov,getEigenvalues,0,3,0,class<`PcaGrid`>,1
+rrcov,getEigenvalues,-1,4,0,double[],1
+rrcov,getEigenvalues,0,4,0,class<`PcaClassic`>,1
+rrcov,getEigenvalues,0,4,1,class<`PcaCov`>,1
+rrcov,getEigenvalues,0,4,2,class<`PcaGrid`>,1
+rrcov,getEigenvalues,0,4,3,class<`PcaHubert`>,1
+rrcov,getEigenvalues,0,4,4,class<`PcaLocantore`>,1
+rrcov,getEigenvalues,0,4,5,class<`PcaProj`>,1
+rrcov,getEigenvalues,-1,5,0,double[],1
+rrcov,getEigenvalues,0,5,0,class<`PcaLocantore`>,1
+rrcov,getEigenvalues,-1,6,0,double[],1
+rrcov,getEigenvalues,0,6,0,class<`PcaProj`>,1
+rrcov,getEllipse,-1,0,0,class<`matrix`>,1
+rrcov,getEllipse,0,0,0,double[],1
+rrcov,getEllipse,1,0,0,class<`matrix`>,1
+rrcov,getEllipse,2,0,0,double,1
+rrcov,getEvals,-1,0,0,double[],1
+rrcov,getEvals,0,0,0,class<`CovClassic`>,1
+rrcov,getEvals,-1,1,0,double[],1
+rrcov,getEvals,0,1,0,class<`CovMcd`>,1
+rrcov,getEvals,-1,2,0,double[],1
+rrcov,getEvals,0,2,0,class<`CovMest`>,1
+rrcov,getEvals,-1,3,0,double[],1
+rrcov,getEvals,0,3,0,class<`CovClassic`>,1
+rrcov,getEvals,0,3,1,class<`CovMcd`>,1
+rrcov,getEvals,0,3,2,class<`CovMest`>,1
+rrcov,getLoadings,-1,0,0,class<`matrix`>,1
+rrcov,getLoadings,0,0,0,class<`PcaCov`>,1
+rrcov,getLoadings,-1,1,0,class<`matrix`>,1
+rrcov,getLoadings,0,1,0,class<`PcaClassic`>,1
+rrcov,getLoadings,-1,2,0,class<`matrix`>,1
+rrcov,getLoadings,0,2,0,class<`PcaClassic`>,1
+rrcov,getLoadings,0,2,1,class<`PcaCov`>,1
+rrcov,getLoadings,0,2,2,class<`PcaGrid`>,1
+rrcov,getLoadings,0,2,3,class<`PcaHubert`>,1
+rrcov,getLoadings,0,2,4,class<`PcaLocantore`>,1
+rrcov,getLoadings,0,2,5,class<`PcaProj`>,1
+rrcov,getLoadings,-1,3,0,class<`matrix`>,1
+rrcov,getLoadings,0,3,0,class<`PcaLocantore`>,1
+rrcov,getLoadings,-1,4,0,class<`matrix`>,1
+rrcov,getLoadings,0,4,0,class<`PcaProj`>,1
+rrcov,getLoadings,-1,5,0,class<`matrix`>,1
+rrcov,getLoadings,0,5,0,class<`PcaGrid`>,1
+rrcov,getLoadings,-1,6,0,class<`matrix`>,1
+rrcov,getLoadings,0,6,0,class<`PcaHubert`>,1
+rrcov,getMeth,-1,0,0,character,1
+rrcov,getMeth,0,0,0,class<`CovSest`>,1
+rrcov,getMeth,-1,1,0,character,1
+rrcov,getMeth,0,1,0,class<`CovOgk`>,1
+rrcov,getMeth,-1,2,0,character,1
+rrcov,getMeth,0,2,0,class<`CovMcd`>,1
+rrcov,getMeth,0,2,1,class<`CovMest`>,1
+rrcov,getMeth,0,2,2,class<`CovOgk`>,1
+rrcov,getMeth,0,2,3,class<`CovSest`>,1
+rrcov,getMeth,0,2,4,class<`CovSde`>,1
+rrcov,getMeth,-1,3,0,character,1
+rrcov,getMeth,0,3,0,class<`CovMcd`>,1
+rrcov,getMeth,-1,4,0,character,1
+rrcov,getMeth,0,4,0,class<`CovMest`>,1
+rrcov,getMeth,-1,5,0,character,1
+rrcov,getMeth,0,5,0,class<`CovSde`>,1
+rrcov,getPrcomp,-1,0,0,class<`prcomp`>,1
+rrcov,getPrcomp,0,0,0,class<`PcaClassic`>,1
+rrcov,getPrcomp,-1,1,0,class<`prcomp`>,1
+rrcov,getPrcomp,0,1,0,class<`PcaLocantore`>,1
+rrcov,getPrcomp,-1,2,0,class<`prcomp`>,1
+rrcov,getPrcomp,0,2,0,class<`PcaCov`>,1
+rrcov,getPrcomp,-1,3,0,class<`prcomp`>,1
+rrcov,getPrcomp,0,3,0,class<`PcaHubert`>,1
+rrcov,getPrcomp,-1,4,0,class<`prcomp`>,1
+rrcov,getPrcomp,0,4,0,class<`PcaClassic`>,1
+rrcov,getPrcomp,0,4,1,class<`PcaCov`>,1
+rrcov,getPrcomp,0,4,2,class<`PcaHubert`>,1
+rrcov,getPrcomp,0,4,3,class<`PcaLocantore`>,1
+rrcov,getScores,-1,0,0,class<`matrix`>,1
+rrcov,getScores,0,0,0,class<`PcaClassic`>,1
+rrcov,getScores,0,0,1,class<`PcaCov`>,1
+rrcov,getScores,0,0,2,class<`PcaGrid`>,1
+rrcov,getScores,0,0,3,class<`PcaHubert`>,1
+rrcov,getScores,0,0,4,class<`PcaLocantore`>,1
+rrcov,getScores,0,0,5,class<`PcaProj`>,1
+rrcov,getScores,-1,1,0,class<`matrix`>,1
+rrcov,getScores,0,1,0,class<`PcaHubert`>,1
+rrcov,getScores,-1,2,0,class<`matrix`>,1
+rrcov,getScores,0,2,0,class<`PcaCov`>,1
+rrcov,getScores,-1,3,0,class<`matrix`>,1
+rrcov,getScores,0,3,0,class<`PcaProj`>,1
+rrcov,getScores,-1,4,0,class<`matrix`>,1
+rrcov,getScores,0,4,0,class<`PcaLocantore`>,1
+rrcov,getScores,-1,5,0,class<`matrix`>,1
+rrcov,getScores,0,5,0,class<`PcaClassic`>,1
+rrcov,getScores,-1,6,0,class<`matrix`>,1
+rrcov,getScores,0,6,0,class<`PcaGrid`>,1
+rrcov,getSdev,-1,0,0,double[],1
+rrcov,getSdev,0,0,0,class<`PcaGrid`>,1
+rrcov,getSdev,-1,1,0,double[],1
+rrcov,getSdev,0,1,0,class<`PcaClassic`>,1
+rrcov,getSdev,-1,2,0,double[],1
+rrcov,getSdev,0,2,0,class<`PcaClassic`>,1
+rrcov,getSdev,0,2,1,class<`PcaGrid`>,1
+rrcov,getShape,-1,0,0,class<`matrix`>,1
+rrcov,getShape,0,0,0,class<`CovSest`>,1
+rrcov,getShape,-1,1,0,class<`matrix`>,1
+rrcov,getShape,0,1,0,class<`CovSest`>,1
+rrcov,isClassic,-1,0,0,logical,1
+rrcov,isClassic,0,0,0,class<`CovSest`>,1
+rrcov,isClassic,-1,1,0,logical,1
+rrcov,isClassic,0,1,0,class<`CovSest`>,1
+rrcov,isSingular,-1,0,0,logical,1
+rrcov,isSingular,0,0,0,class<`CovSde`>,1
+rrcov,isSingular,-1,1,0,logical,1
+rrcov,isSingular,0,1,0,class<`CovClassic`>,1
+rrcov,isSingular,-1,2,0,logical,1
+rrcov,isSingular,0,2,0,class<`CovMest`>,1
+rrcov,isSingular,-1,3,0,logical,1
+rrcov,isSingular,0,3,0,class<`CovSest`>,1
+rrcov,isSingular,-1,4,0,logical,1
+rrcov,isSingular,0,4,0,class<`CovMMest`>,1
+rrcov,isSingular,-1,5,0,logical,1
+rrcov,isSingular,0,5,0,class<`CovMcd`>,1
+rrcov,isSingular,-1,6,0,logical,1
+rrcov,isSingular,0,6,0,class<`CovClassic`>,1
+rrcov,isSingular,0,6,1,class<`CovMcd`>,1
+rrcov,isSingular,0,6,2,class<`CovMest`>,1
+rrcov,isSingular,0,6,3,class<`CovMMest`>,1
+rrcov,isSingular,0,6,4,class<`CovSde`>,1
+rrcov,isSingular,0,6,5,class<`CovSest`>,1
+rrcov,.isSingular,-1,0,0,logical,1
+rrcov,.isSingular,0,0,0,class<`matrix`>,1
+rrcov,.iter.bic,-1,0,0,list<double[] | class<`matrix`>>,1
+rrcov,.iter.bic,0,0,0,class<`matrix`>,1
+rrcov,.iter.bic,1,0,0,double[],1
+rrcov,.iter.bic,2,0,0,class<`matrix`>,1
+rrcov,.iter.bic,3,0,0,double,1
+rrcov,.iter.bic,4,0,0,double,1
+rrcov,.iter.bic,5,0,0,logical,1
+rrcov,iterM,-1,0,0,list<double[] | class<`matrix`>>,1
+rrcov,iterM,0,0,0,class<`PsiBwt`>,1
+rrcov,iterM,1,0,0,class<`matrix`>,1
+rrcov,iterM,2,0,0,double[],1
+rrcov,iterM,3,0,0,class<`matrix`>,1
+rrcov,iterM,4,0,0,double,1
+rrcov,iterM,5,0,0,double,1
+rrcov,iterM,-1,1,0,list<double[] | class<`matrix`>>,1
+rrcov,iterM,0,1,0,class<`PsiBwt`>,1
+rrcov,iterM,1,1,0,class<`matrix`>,1
+rrcov,iterM,2,1,0,double[],1
+rrcov,iterM,3,1,0,class<`matrix`>,1
+rrcov,iterM,4,1,0,double,1
+rrcov,iterM,5,1,0,double,1
+rrcov,.iter.rocke,-1,0,0,list<double[] | class<`matrix`>>,1
+rrcov,.iter.rocke,0,0,0,class<`matrix`>,1
+rrcov,.iter.rocke,1,0,0,double[],1
+rrcov,.iter.rocke,2,0,0,class<`matrix`>,1
+rrcov,.iter.rocke,3,0,0,double,1
+rrcov,.iter.rocke,4,0,0,double,1
+rrcov,.iter.rocke,5,0,0,double,1
+rrcov,.iter.rocke,6,0,0,logical,1
+rrcov,.kappa.s,-1,0,0,double,1
+rrcov,.kappa.s,0,0,0,double,1
+rrcov,.kappa.s,1,0,0,integer,1
+rrcov,label,-1,0,0,null,1
+rrcov,label,0,0,0,integer[],1
+rrcov,label,1,0,0,double[],1
+rrcov,label,2,0,0,double,1
+rrcov,label,3,0,0,double,1
+rrcov,.label,-1,0,0,null,1
+rrcov,.label,0,0,0,any,1
+rrcov,.label,1,0,0,any,1
+rrcov,.label,2,0,0,integer,1
+rrcov,.label,3,0,0,any,1
+rrcov,label.dd,-1,0,0,null,1
+rrcov,label.dd,0,0,0,double[],1
+rrcov,label.dd,1,0,0,double[],1
+rrcov,label.dd,2,0,0,double,1
+rrcov,label.dd,3,0,0,double,1
+rrcov,label.dd,4,0,0,double,1
+rrcov,LdaClassic,-1,0,0,class<`LdaClassic`>,1
+rrcov,LdaClassic,0,0,0,class<`data.frame`>,1
+rrcov,LdaClassic,0,0,1,class<`formula`>,1
+rrcov,LdaClassic,1,0,0,...,1
+rrcov,LdaClassic.default,-1,0,0,class<`LdaClassic`>,1
+rrcov,LdaClassic.default,0,0,0,class<`matrix`>,1
+rrcov,LdaClassic.default,0,0,1,class<`data.frame`>,1
+rrcov,LdaClassic.default,1,0,0,class<`factor`>,1
+rrcov,LdaClassic.default,2,0,0,double[],1
+rrcov,LdaClassic.default,3,0,0,double,1
+rrcov,LdaClassic.default,4,0,0,...,1
+rrcov,LdaClassic.formula,-1,0,0,class<`LdaClassic`>,1
+rrcov,LdaClassic.formula,0,0,0,class<`formula`>,1
+rrcov,LdaClassic.formula,1,0,0,any,1
+rrcov,LdaClassic.formula,2,0,0,...,1
+rrcov,LdaClassic.formula,3,0,0,any,1
+rrcov,LdaClassic.formula,4,0,0,any,1
+rrcov,Linda,-1,0,0,class<`Linda`>,1
+rrcov,Linda,0,0,0,class<`data.frame`>,1
+rrcov,Linda,0,0,1,class<`formula`>,1
+rrcov,Linda,1,0,0,...,1
+rrcov,Linda.default,-1,0,0,class<`Linda`>,1
+rrcov,Linda.default,0,0,0,class<`matrix`>,1
+rrcov,Linda.default,0,0,1,class<`data.frame`>,1
+rrcov,Linda.default,1,0,0,class<`factor`>,1
+rrcov,Linda.default,1,0,1,double[],1
+rrcov,Linda.default,2,0,0,double[],1
+rrcov,Linda.default,3,0,0,double,1
+rrcov,Linda.default,4,0,0,character[],1
+rrcov,Linda.default,5,0,0,double,1
+rrcov,Linda.default,6,0,0,logical,1
+rrcov,Linda.default,7,0,0,any,1
+rrcov,Linda.formula,-1,0,0,class<`Linda`>,1
+rrcov,Linda.formula,0,0,0,class<`formula`>,1
+rrcov,Linda.formula,1,0,0,any,1
+rrcov,Linda.formula,2,0,0,...,1
+rrcov,Linda.formula,3,0,0,any,1
+rrcov,Linda.formula,4,0,0,any,1
+rrcov,mtxconfusion,-1,0,0,class<`table`>,1
+rrcov,mtxconfusion,0,0,0,class<`factor`>,1
+rrcov,mtxconfusion,1,0,0,class<`factor`>,1
+rrcov,mtxconfusion,2,0,0,null,1
+rrcov,mtxconfusion,3,0,0,logical,1
+rrcov,.myddplot,-1,0,0,null,1
+rrcov,.myddplot,0,0,0,double[],1
+rrcov,.myddplot,1,0,0,double[],1
+rrcov,.myddplot,2,0,0,double,1
+rrcov,.myddplot,3,0,0,any,1
+rrcov,.myddplot,4,0,0,character,1
+rrcov,.myddplot,5,0,0,character,1
+rrcov,.myddplot,6,0,0,character,1
+rrcov,.myddplot,7,0,0,integer[],1
+rrcov,.mydistplot,-1,0,0,null,1
+rrcov,.mydistplot,0,0,0,double[],1
+rrcov,.mydistplot,1,0,0,double,1
+rrcov,.mydistplot,2,0,0,logical,1
+rrcov,.mydistplot,3,0,0,any,1
+rrcov,.mydistplot,4,0,0,null,1
+rrcov,.mydistplot,4,0,1,double[],1
+rrcov,.mydistplot,5,0,0,character,1
+rrcov,.mydistplot,6,0,0,character,1
+rrcov,.mydistplot,7,0,0,character,1
+rrcov,.myellipse,-1,0,0,null,1
+rrcov,.myellipse,0,0,0,class<`matrix`>,1
+rrcov,.myellipse,1,0,0,list<class<`matrix`> | double[]>,1
+rrcov,.myellipse,2,0,0,null,1
+rrcov,.myellipse,3,0,0,double,1
+rrcov,.myellipse,4,0,0,logical,1
+rrcov,.myellipse,5,0,0,double,1
+rrcov,.myellipse,6,0,0,character,1
+rrcov,.myellipse,7,0,0,character,1
+rrcov,myPcaPrint,-1,0,0,class<`PcaClassic`>,1
+rrcov,myPcaPrint,-1,0,1,class<`PcaHubert`>,1
+rrcov,myPcaPrint,0,0,0,class<`PcaClassic`>,1
+rrcov,myPcaPrint,0,0,1,class<`PcaHubert`>,1
+rrcov,myPcaPrint,1,0,0,logical,1
+rrcov,myPcaPrint,2,0,0,logical,1
+rrcov,myPcaPrint,3,0,0,...,1
+rrcov,.mypredictLda,-1,0,0,class<`PredictLda`>,1
+rrcov,.mypredictLda,0,0,0,double[],1
+rrcov,.mypredictLda,1,0,0,character[],1
+rrcov,.mypredictLda,2,0,0,class<`matrix`>,1
+rrcov,.mypredictLda,3,0,0,double[],1
+rrcov,.mypredictLda,4,0,0,class<`matrix`>,1
+rrcov,.mypredictQda,-1,0,0,class<`PredictQda`>,1
+rrcov,.mypredictQda,0,0,0,double[],1
+rrcov,.mypredictQda,1,0,0,character[],1
+rrcov,.mypredictQda,2,0,0,class<`matrix`>,1
+rrcov,.mypredictQda,3,0,0,class<`array`>,1
+rrcov,.mypredictQda,4,0,0,double[],1
+rrcov,.mypredictQda,5,0,0,class<`matrix`>,1
+rrcov,myscreeplot,-1,0,0,null,1
+rrcov,myscreeplot,0,0,0,any,1
+rrcov,myscreeplot,1,0,0,class<`CovClassic`>,1
+rrcov,.myscreeplot,-1,0,0,null,1
+rrcov,.myscreeplot,0,0,0,any,1
+rrcov,.myscreeplot,1,0,0,class<`CovClassic`>,1
+rrcov,PcaClassic,-1,0,0,class<`PcaClassic`>,1
+rrcov,PcaClassic,0,0,0,class<`data.frame`>,1
+rrcov,PcaClassic,0,0,1,class<`formula`>,1
+rrcov,PcaClassic,0,0,2,class<`matrix`>,1
+rrcov,PcaClassic,1,0,0,...,1
+rrcov,PcaClassic.default,-1,0,0,class<`PcaClassic`>,1
+rrcov,PcaClassic.default,0,0,0,class<`matrix`>,1
+rrcov,PcaClassic.default,0,0,1,class<`data.frame`>,1
+rrcov,PcaClassic.default,1,0,0,double,1
+rrcov,PcaClassic.default,2,0,0,double,1
+rrcov,PcaClassic.default,3,0,0,logical,1
+rrcov,PcaClassic.default,4,0,0,logical,1
+rrcov,PcaClassic.default,5,0,0,double,1
+rrcov,PcaClassic.default,6,0,0,logical,1
+rrcov,PcaClassic.default,7,0,0,...,1
+rrcov,PcaClassic.formula,-1,0,0,class<`PcaClassic`>,1
+rrcov,PcaClassic.formula,0,0,0,class<`formula`>,1
+rrcov,PcaClassic.formula,1,0,0,class<`data.frame`>,1
+rrcov,PcaClassic.formula,2,0,0,any,1
+rrcov,PcaClassic.formula,3,0,0,any,1
+rrcov,PcaClassic.formula,4,0,0,...,1
+rrcov,PcaCov,-1,0,0,class<`PcaCov`>,1
+rrcov,PcaCov,0,0,0,class<`data.frame`>,1
+rrcov,PcaCov,0,0,1,class<`formula`>,1
+rrcov,PcaCov,0,0,2,class<`matrix`>,1
+rrcov,PcaCov,1,0,0,...,1
+rrcov,PcaCov.default,-1,0,0,class<`PcaCov`>,1
+rrcov,PcaCov.default,0,0,0,class<`matrix`>,1
+rrcov,PcaCov.default,0,0,1,class<`data.frame`>,1
+rrcov,PcaCov.default,1,0,0,double,1
+rrcov,PcaCov.default,2,0,0,integer,1
+rrcov,PcaCov.default,3,0,0,class<`CovControlMcd`>,1
+rrcov,PcaCov.default,3,0,1,class<`CovControlSest`>,1
+rrcov,PcaCov.default,3,0,2,null,1
+rrcov,PcaCov.default,3,0,3,class<`CovControlOgk`>,1
+rrcov,PcaCov.default,4,0,0,logical,1
+rrcov,PcaCov.default,5,0,0,logical,1
+rrcov,PcaCov.default,6,0,0,double,1
+rrcov,PcaCov.default,7,0,0,logical,1
+rrcov,PcaCov.formula,-1,0,0,class<`PcaCov`>,1
+rrcov,PcaCov.formula,0,0,0,class<`formula`>,1
+rrcov,PcaCov.formula,1,0,0,class<`data.frame`>,1
+rrcov,PcaCov.formula,2,0,0,any,1
+rrcov,PcaCov.formula,3,0,0,any,1
+rrcov,PcaCov.formula,4,0,0,...,1
+rrcov,pca.ddplot,-1,0,0,class<`PcaClassic`>,1
+rrcov,pca.ddplot,-1,0,1,class<`PcaCov`>,1
+rrcov,pca.ddplot,-1,0,2,class<`PcaHubert`>,1
+rrcov,pca.ddplot,-1,0,3,class<`PcaLocantore`>,1
+rrcov,pca.ddplot,0,0,0,class<`PcaClassic`>,1
+rrcov,pca.ddplot,0,0,1,class<`PcaCov`>,1
+rrcov,pca.ddplot,0,0,2,class<`PcaHubert`>,1
+rrcov,pca.ddplot,0,0,3,class<`PcaLocantore`>,1
+rrcov,pca.ddplot,1,0,0,double,1
+rrcov,pca.ddplot,2,0,0,double,1
+rrcov,pca.ddplot,3,0,0,any,1
+rrcov,pca.ddplot,4,0,0,any,1
+rrcov,pca.ddplot,5,0,0,any,1
+rrcov,pca.ddplot,6,0,0,double,1
+rrcov,pca.ddplot,7,0,0,...,1
+rrcov,pca.distances,-1,0,0,class<`PcaClassic`>,1
+rrcov,pca.distances,-1,0,1,class<`PcaCov`>,1
+rrcov,pca.distances,-1,0,2,class<`PcaGrid`>,1
+rrcov,pca.distances,-1,0,3,class<`PcaHubert`>,1
+rrcov,pca.distances,-1,0,4,class<`PcaLocantore`>,1
+rrcov,pca.distances,-1,0,5,class<`PcaProj`>,1
+rrcov,pca.distances,0,0,0,class<`PcaClassic`>,1
+rrcov,pca.distances,0,0,1,class<`PcaCov`>,1
+rrcov,pca.distances,0,0,2,class<`PcaGrid`>,1
+rrcov,pca.distances,0,0,3,class<`PcaHubert`>,1
+rrcov,pca.distances,0,0,4,class<`PcaLocantore`>,1
+rrcov,pca.distances,0,0,5,class<`PcaProj`>,1
+rrcov,pca.distances,1,0,0,class<`matrix`>,1
+rrcov,pca.distances,1,0,1,class<`data.frame`>,1
+rrcov,pca.distances,2,0,0,integer,1
+rrcov,pca.distances,3,0,0,double,1
+rrcov,pca.distplot,-1,0,0,class<`PcaClassic`>,1
+rrcov,pca.distplot,-1,0,1,class<`PcaCov`>,1
+rrcov,pca.distplot,-1,0,2,class<`PcaHubert`>,1
+rrcov,pca.distplot,-1,0,3,class<`PcaLocantore`>,1
+rrcov,pca.distplot,0,0,0,class<`PcaClassic`>,1
+rrcov,pca.distplot,0,0,1,class<`PcaCov`>,1
+rrcov,pca.distplot,0,0,2,class<`PcaHubert`>,1
+rrcov,pca.distplot,0,0,3,class<`PcaLocantore`>,1
+rrcov,pca.distplot,1,0,0,double,1
+rrcov,pca.distplot,2,0,0,any,1
+rrcov,pca.distplot,3,0,0,double,1
+rrcov,pca.distplot,4,0,0,...,1
+rrcov,PcaGrid,-1,0,0,class<`PcaGrid`>,1
+rrcov,PcaGrid,0,0,0,class<`formula`>,1
+rrcov,PcaGrid,0,0,1,class<`matrix`>,1
+rrcov,PcaGrid,1,0,0,...,1
+rrcov,PcaGrid.default,-1,0,0,class<`PcaGrid`>,1
+rrcov,PcaGrid.default,0,0,0,class<`matrix`>,1
+rrcov,PcaGrid.default,1,0,0,double,1
+rrcov,PcaGrid.default,2,0,0,integer,1
+rrcov,PcaGrid.default,3,0,0,logical,1
+rrcov,PcaGrid.default,4,0,0,any,1
+rrcov,PcaGrid.default,5,0,0,double,1
+rrcov,PcaGrid.default,6,0,0,logical,1
+rrcov,PcaGrid.default,7,0,0,...,1
+rrcov,PcaGrid.formula,-1,0,0,class<`PcaGrid`>,1
+rrcov,PcaGrid.formula,0,0,0,class<`formula`>,1
+rrcov,PcaGrid.formula,1,0,0,class<`data.frame`>,1
+rrcov,PcaGrid.formula,2,0,0,any,1
+rrcov,PcaGrid.formula,3,0,0,any,1
+rrcov,PcaGrid.formula,4,0,0,...,1
+rrcov,PcaHubert,-1,0,0,class<`PcaHubert`>,1
+rrcov,PcaHubert,0,0,0,class<`data.frame`>,1
+rrcov,PcaHubert,0,0,1,class<`formula`>,1
+rrcov,PcaHubert,0,0,2,class<`matrix`>,1
+rrcov,PcaHubert,1,0,0,...,1
+rrcov,PcaHubert.default,-1,0,0,class<`PcaHubert`>,1
+rrcov,PcaHubert.default,0,0,0,class<`matrix`>,1
+rrcov,PcaHubert.default,0,0,1,class<`data.frame`>,1
+rrcov,PcaHubert.default,1,0,0,double,1
+rrcov,PcaHubert.default,2,0,0,double,1
+rrcov,PcaHubert.default,3,0,0,double,1
+rrcov,PcaHubert.default,4,0,0,logical,1
+rrcov,PcaHubert.default,5,0,0,double,1
+rrcov,PcaHubert.default,6,0,0,logical,1
+rrcov,PcaHubert.default,7,0,0,logical,1
+rrcov,PcaHubert.formula,-1,0,0,class<`PcaHubert`>,1
+rrcov,PcaHubert.formula,0,0,0,class<`formula`>,1
+rrcov,PcaHubert.formula,1,0,0,class<`data.frame`>,1
+rrcov,PcaHubert.formula,2,0,0,any,1
+rrcov,PcaHubert.formula,3,0,0,any,1
+rrcov,PcaHubert.formula,4,0,0,...,1
+rrcov,PcaLocantore,-1,0,0,class<`PcaLocantore`>,1
+rrcov,PcaLocantore,0,0,0,class<`data.frame`>,1
+rrcov,PcaLocantore,0,0,1,class<`formula`>,1
+rrcov,PcaLocantore,0,0,2,class<`matrix`>,1
+rrcov,PcaLocantore,1,0,0,...,1
+rrcov,PcaLocantore.default,-1,0,0,class<`PcaLocantore`>,1
+rrcov,PcaLocantore.default,0,0,0,class<`matrix`>,1
+rrcov,PcaLocantore.default,0,0,1,class<`data.frame`>,1
+rrcov,PcaLocantore.default,1,0,0,double,1
+rrcov,PcaLocantore.default,2,0,0,integer,1
+rrcov,PcaLocantore.default,3,0,0,double,1
+rrcov,PcaLocantore.default,4,0,0,any,1
+rrcov,PcaLocantore.default,5,0,0,logical,1
+rrcov,PcaLocantore.default,6,0,0,logical,1
+rrcov,PcaLocantore.default,7,0,0,double,1
+rrcov,PcaLocantore.formula,-1,0,0,class<`PcaLocantore`>,1
+rrcov,PcaLocantore.formula,0,0,0,class<`formula`>,1
+rrcov,PcaLocantore.formula,1,0,0,class<`data.frame`>,1
+rrcov,PcaLocantore.formula,2,0,0,any,1
+rrcov,PcaLocantore.formula,3,0,0,any,1
+rrcov,PcaLocantore.formula,4,0,0,...,1
+rrcov,PcaProj,-1,0,0,class<`PcaProj`>,1
+rrcov,PcaProj,0,0,0,class<`matrix`>,1
+rrcov,PcaProj,1,0,0,...,1
+rrcov,PcaProj.default,-1,0,0,class<`PcaProj`>,1
+rrcov,PcaProj.default,0,0,0,class<`matrix`>,1
+rrcov,PcaProj.default,1,0,0,double,1
+rrcov,PcaProj.default,2,0,0,integer,1
+rrcov,PcaProj.default,3,0,0,logical,1
+rrcov,PcaProj.default,4,0,0,any,1
+rrcov,PcaProj.default,5,0,0,double,1
+rrcov,PcaProj.default,6,0,0,logical,1
+rrcov,PcaProj.default,7,0,0,...,1
+rrcov,pca.scoreplot,-1,0,0,null,1
+rrcov,pca.scoreplot,0,0,0,class<`PcaHubert`>,1
+rrcov,pca.scoreplot,1,0,0,double,1
+rrcov,pca.scoreplot,2,0,0,double,1
+rrcov,pca.scoreplot,3,0,0,any,1
+rrcov,pca.scoreplot,4,0,0,double,1
+rrcov,pca.scoreplot,5,0,0,...,1
+rrcov,plot,-1,0,0,null,1
+rrcov,plot,0,0,0,class<`CovMest`>,1
+rrcov,plot,1,0,0,any,1
+rrcov,plot,2,0,0,...,1
+rrcov,plot,-1,1,0,class<`PcaClassic`>,1
+rrcov,plot,0,1,0,class<`PcaClassic`>,1
+rrcov,plot,1,1,0,any,1
+rrcov,plot,2,1,0,...,1
+rrcov,plot,-1,2,0,null,1
+rrcov,plot,0,2,0,class<`CovMcd`>,1
+rrcov,plot,1,2,0,any,1
+rrcov,plot,2,2,0,...,1
+rrcov,plot,-1,3,0,null,1
+rrcov,plot,0,3,0,class<`CovSde`>,1
+rrcov,plot,1,3,0,any,1
+rrcov,plot,2,3,0,...,1
+rrcov,plot,-1,4,0,class<`PcaLocantore`>,1
+rrcov,plot,0,4,0,class<`PcaLocantore`>,1
+rrcov,plot,1,4,0,any,1
+rrcov,plot,2,4,0,...,1
+rrcov,plot,-1,5,0,class<`PcaCov`>,1
+rrcov,plot,0,5,0,class<`PcaCov`>,1
+rrcov,plot,1,5,0,any,1
+rrcov,plot,2,5,0,...,1
+rrcov,plot,-1,6,0,null,1
+rrcov,plot,0,6,0,class<`CovSest`>,1
+rrcov,plot,1,6,0,any,1
+rrcov,plot,2,6,0,...,1
+rrcov,plot,-1,7,0,null,1
+rrcov,plot,0,7,0,class<`CovMMest`>,1
+rrcov,plot,1,7,0,any,1
+rrcov,plot,2,7,0,...,1
+rrcov,plot,-1,8,0,null,1
+rrcov,plot,0,8,0,class<`CovClassic`>,1
+rrcov,plot,1,8,0,any,1
+rrcov,plot,2,8,0,...,1
+rrcov,plot,-1,9,0,class<`PcaHubert`>,1
+rrcov,plot,0,9,0,class<`PcaHubert`>,1
+rrcov,plot,1,9,0,any,1
+rrcov,plot,2,9,0,...,1
+rrcov,predict,-1,0,0,class<`PredictQda`>,1
+rrcov,predict,0,0,0,class<`QdaCov`>,1
+rrcov,predict,1,0,0,...,1
+rrcov,predict,-1,1,0,class<`PredictLda`>,1
+rrcov,predict,0,1,0,class<`Linda`>,1
+rrcov,predict,1,1,0,...,1
+rrcov,predict,-1,2,0,class<`PredictQda`>,1
+rrcov,predict,0,2,0,class<`QdaClassic`>,1
+rrcov,predict,1,2,0,...,1
+rrcov,predict,-1,3,0,class<`PredictLda`>,1
+rrcov,predict,0,3,0,class<`LdaClassic`>,1
+rrcov,predict,1,3,0,...,1
+rrcov,psi,-1,0,0,double[],1
+rrcov,psi,0,0,0,class<`PsiBwt`>,1
+rrcov,psi,1,0,0,double[],1
+rrcov,psi,-1,1,0,double[],1
+rrcov,psi,0,1,0,class<`PsiBwt`>,1
+rrcov,psi,1,1,0,double[],1
+rrcov,QdaClassic,-1,0,0,class<`QdaClassic`>,1
+rrcov,QdaClassic,0,0,0,class<`formula`>,1
+rrcov,QdaClassic,1,0,0,...,1
+rrcov,QdaClassic.default,-1,0,0,class<`QdaClassic`>,1
+rrcov,QdaClassic.default,0,0,0,class<`matrix`>,1
+rrcov,QdaClassic.default,1,0,0,class<`factor`>,1
+rrcov,QdaClassic.default,2,0,0,double[],1
+rrcov,QdaClassic.default,3,0,0,double,1
+rrcov,QdaClassic.default,4,0,0,...,1
+rrcov,QdaClassic.formula,-1,0,0,class<`QdaClassic`>,1
+rrcov,QdaClassic.formula,0,0,0,class<`formula`>,1
+rrcov,QdaClassic.formula,1,0,0,any,1
+rrcov,QdaClassic.formula,2,0,0,...,1
+rrcov,QdaClassic.formula,3,0,0,any,1
+rrcov,QdaClassic.formula,4,0,0,any,1
+rrcov,QdaCov,-1,0,0,class<`QdaCov`>,1
+rrcov,QdaCov,0,0,0,class<`formula`>,1
+rrcov,QdaCov,1,0,0,...,1
+rrcov,QdaCov.default,-1,0,0,class<`QdaCov`>,1
+rrcov,QdaCov.default,0,0,0,class<`matrix`>,1
+rrcov,QdaCov.default,1,0,0,class<`factor`>,1
+rrcov,QdaCov.default,2,0,0,double[],1
+rrcov,QdaCov.default,3,0,0,double,1
+rrcov,QdaCov.default,4,0,0,any,1
+rrcov,QdaCov.default,5,0,0,...,1
+rrcov,QdaCov.formula,-1,0,0,class<`QdaCov`>,1
+rrcov,QdaCov.formula,0,0,0,class<`formula`>,1
+rrcov,QdaCov.formula,1,0,0,any,1
+rrcov,QdaCov.formula,2,0,0,...,1
+rrcov,QdaCov.formula,3,0,0,any,1
+rrcov,QdaCov.formula,4,0,0,any,1
+rrcov,.qqplot,-1,0,0,null,1
+rrcov,.qqplot,0,0,0,double[],1
+rrcov,.qqplot,1,0,0,integer,1
+rrcov,.qqplot,2,0,0,double,1
+rrcov,.qqplot,3,0,0,logical,1
+rrcov,.qqplot,4,0,0,any,1
+rrcov,.qqplot,5,0,0,expression,1
+rrcov,.qqplot,6,0,0,expression,1
+rrcov,.qqplot,7,0,0,character,1
+rrcov,restimate,-1,0,0,class<`CovMcd`>,1
+rrcov,restimate,0,0,0,class<`CovControlMcd`>,1
+rrcov,restimate,1,0,0,class<`data.frame`>,1
+rrcov,restimate,1,0,1,class<`matrix`>,1
+rrcov,restimate,2,0,0,...,1
+rrcov,restimate,-1,1,0,class<`CovSest`>,1
+rrcov,restimate,0,1,0,class<`CovControlSest`>,1
+rrcov,restimate,1,1,0,class<`data.frame`>,1
+rrcov,restimate,1,1,1,class<`matrix`>,1
+rrcov,restimate,2,1,0,...,1
+rrcov,restimate,-1,2,0,class<`CovOgk`>,1
+rrcov,restimate,0,2,0,class<`CovControlOgk`>,1
+rrcov,restimate,1,2,0,class<`data.frame`>,1
+rrcov,restimate,1,2,1,class<`matrix`>,1
+rrcov,restimate,2,2,0,...,1
+rrcov,restimate,-1,3,0,class<`CovMcd`>,1
+rrcov,restimate,-1,3,1,class<`CovMest`>,1
+rrcov,restimate,-1,3,2,class<`CovOgk`>,1
+rrcov,restimate,-1,3,3,class<`CovSest`>,1
+rrcov,restimate,-1,3,4,class<`CovSde`>,1
+rrcov,restimate,0,3,0,class<`CovControlMcd`>,1
+rrcov,restimate,0,3,1,class<`CovControlMest`>,1
+rrcov,restimate,0,3,2,class<`CovControlOgk`>,1
+rrcov,restimate,0,3,3,class<`CovControlSest`>,1
+rrcov,restimate,0,3,4,class<`CovControlSde`>,1
+rrcov,restimate,1,3,0,class<`data.frame`>,1
+rrcov,restimate,1,3,1,class<`matrix`>,1
+rrcov,restimate,2,3,0,...,1
+rrcov,restimate,-1,4,0,class<`CovMest`>,1
+rrcov,restimate,0,4,0,class<`CovControlMest`>,1
+rrcov,restimate,1,4,0,class<`matrix`>,1
+rrcov,restimate,2,4,0,...,1
+rrcov,restimate,-1,5,0,class<`CovSde`>,1
+rrcov,restimate,0,5,0,class<`CovControlSde`>,1
+rrcov,restimate,1,5,0,class<`matrix`>,1
+rrcov,restimate,2,5,0,...,1
+rrcov,.rrpairs,-1,0,0,null,1
+rrcov,.rrpairs,0,0,0,class<`CovSest`>,1
+rrcov,.rrpairs,1,0,0,character,1
+rrcov,.rrpairs,2,0,0,character,1
+rrcov,.rrpairs,3,0,0,character,1
+rrcov,.rrpairs,4,0,0,character,1
+rrcov,.rrpairs,5,0,0,...,1
+rrcov,scorePlot,-1,0,0,null,1
+rrcov,scorePlot,0,0,0,class<`PcaHubert`>,1
+rrcov,scorePlot,1,0,0,...,1
+rrcov,scorePlot,-1,1,0,null,1
+rrcov,scorePlot,0,1,0,class<`PcaHubert`>,1
+rrcov,scorePlot,1,1,0,...,1
+rrcov,screeplot,-1,0,0,null,1
+rrcov,screeplot,0,0,0,class<`PcaHubert`>,1
+rrcov,screeplot,1,0,0,...,1
+rrcov,screeplot,-1,1,0,null,1
+rrcov,screeplot,0,1,0,class<`PcaClassic`>,1
+rrcov,screeplot,1,1,0,...,1
+rrcov,screeplot,-1,2,0,null,1
+rrcov,screeplot,0,2,0,class<`PcaLocantore`>,1
+rrcov,screeplot,1,2,0,...,1
+rrcov,screeplot,-1,3,0,null,1
+rrcov,screeplot,0,3,0,class<`PcaCov`>,1
+rrcov,screeplot,1,3,0,...,1
+rrcov,.signflip,-1,0,0,class<`matrix`>,1
+rrcov,.signflip,-1,0,1,double,1
+rrcov,.signflip,0,0,0,class<`matrix`>,1
+rrcov,.signflip,0,0,1,double,1
+rrcov,spatial.median,-1,0,0,list<double[]>,1
+rrcov,spatial.median,0,0,0,class<`matrix`>,1
+rrcov,spatial.median,1,0,0,double,1
+rrcov,summary,-1,0,0,class<`SummaryCovRobust`>,1
+rrcov,summary,0,0,0,class<`CovMest`>,1
+rrcov,summary,1,0,0,...,1
+rrcov,summary,-1,1,0,class<`SummaryCovRobust`>,1
+rrcov,summary,0,1,0,class<`CovSde`>,1
+rrcov,summary,1,1,0,...,1
+rrcov,summary,-1,2,0,class<`SummaryCovRobust`>,1
+rrcov,summary,0,2,0,class<`CovSest`>,1
+rrcov,summary,1,2,0,...,1
+rrcov,summary,-1,3,0,class<`SummaryCovRobust`>,1
+rrcov,summary,0,3,0,class<`CovMcd`>,1
+rrcov,summary,1,3,0,...,1
+rrcov,summary,-1,4,0,class<`SummaryCov`>,1
+rrcov,summary,0,4,0,class<`CovClassic`>,1
+rrcov,summary,1,4,0,...,1
+rrcov,summary,-1,5,0,class<`SummaryCovRobust`>,1
+rrcov,summary,0,5,0,class<`CovMMest`>,1
+rrcov,summary,1,5,0,...,1
+rrcov,summary,-1,6,0,class<`SummaryPca`>,1
+rrcov,summary,0,6,0,class<`PcaClassic`>,1
+rrcov,summary,1,6,0,...,1
+rrcov,summary,-1,7,0,class<`SummaryCovRobust`>,1
+rrcov,summary,0,7,0,class<`CovMrcd`>,1
+rrcov,summary,1,7,0,...,1
+rrcov,summary,-1,8,0,class<`SummaryPca`>,1
+rrcov,summary,0,8,0,class<`PcaGrid`>,1
+rrcov,summary,1,8,0,...,1
+rrcov,T2.test,-1,0,0,class<`htest`>,1
+rrcov,T2.test,0,0,0,class<`data.frame`>,1
+rrcov,T2.test,0,0,1,class<`formula`>,1
+rrcov,T2.test,0,0,2,class<`matrix`>,1
+rrcov,T2.test,1,0,0,...,1
+rrcov,T2.test.default,-1,0,0,class<`htest`>,1
+rrcov,T2.test.default,0,0,0,class<`data.frame`>,1
+rrcov,T2.test.default,0,0,1,class<`matrix`>,1
+rrcov,T2.test.default,1,0,0,null,1
+rrcov,T2.test.default,1,0,1,class<`data.frame`>,1
+rrcov,T2.test.default,1,0,2,class<`matrix`>,1
+rrcov,T2.test.default,2,0,0,double,1
+rrcov,T2.test.default,3,0,0,double,1
+rrcov,T2.test.default,4,0,0,character[],1
+rrcov,T2.test.default,5,0,0,...,1
+rrcov,T2.test.formula,-1,0,0,class<`htest`>,1
+rrcov,T2.test.formula,0,0,0,class<`formula`>,1
+rrcov,T2.test.formula,1,0,0,any,1
+rrcov,T2.test.formula,2,0,0,any,1
+rrcov,T2.test.formula,3,0,0,any,1
+rrcov,T2.test.formula,4,0,0,...,1
+rrcov,.tolellipse,-1,0,0,null,1
+rrcov,.tolellipse,0,0,0,class<`CovMcd`>,1
+rrcov,.tolellipse,1,0,0,class<`CovClassic`>,1
+rrcov,.tolellipse,2,0,0,double,1
+rrcov,.tolellipse,3,0,0,any,1
+rrcov,.tolellipse,4,0,0,any,1
+rrcov,.tolellipse,5,0,0,character,1
+rrcov,.tolellipse,6,0,0,character,1
+rrcov,.tolellipse,7,0,0,character,1
+rrcov,.tomatrix,-1,0,0,class<`matrix`>,1
+rrcov,.tomatrix,0,0,0,class<`data.frame`>,1
+rrcov,.tomatrix,0,0,1,class<`matrix`>,1
+rrcov,.tomatrix,1,0,0,logical,1
+rrcov,unimcd,-1,0,0,list<logical[] | double>,1
+rrcov,unimcd,0,0,0,double[],1
+rrcov,unimcd,1,0,0,double,1
+rrcov,vt,-1,0,0,double[],1
+rrcov,vt,0,0,0,class<`PsiBwt`>,1
+rrcov,vt,1,0,0,double[],1
+rrcov,vt,-1,1,0,double[],1
+rrcov,vt,0,1,0,class<`PsiBwt`>,1
+rrcov,vt,1,1,0,double[],1
+rrcov,.wcovClass,-1,0,0,class<`wcov`>,1
+rrcov,.wcovClass,0,0,0,class<`matrix`>,1
+rrcov,.wcovClass,1,0,0,class<`factor`>,1
+rrcov,.wcovClass,2,0,0,character[],1
+rrcov,.wcovMcd,-1,0,0,class<`wcov`>,1
+rrcov,.wcovMcd,0,0,0,class<`matrix`>,1
+rrcov,.wcovMcd,1,0,0,class<`factor`>,1
+rrcov,.wcovMcd,1,0,1,double[],1
+rrcov,.wcovMcd,2,0,0,character,1
+rrcov,.wcovMcd,3,0,0,double,1
+rrcov,.wcovMcd,4,0,0,logical,1
+rrcov,.wcovMcd,5,0,0,class<`CovControlMcd`>,1
+rrcov,.wcovMwcd,-1,0,0,class<`wcov`>,1
+rrcov,.wcovMwcd,0,0,0,class<`matrix`>,1
+rrcov,.wcovMwcd,1,0,0,class<`factor`>,1
+rrcov,.wcovMwcd,2,0,0,double,1
+rrcov,.wcovMwcd,3,0,0,logical,1
+rrcov,.wcov.wt,-1,0,0,class<`wcov`>,1
+rrcov,.wcov.wt,0,0,0,class<`matrix`>,1
+rrcov,.wcov.wt,1,0,0,class<`factor`>,1
+rrcov,.wcov.wt,2,0,0,double[],1
+rrcov,.wilks,-1,0,0,list<integer[] | double | class<`matrix`>>,1
+rrcov,.wilks,0,0,0,class<`matrix`>,1
+rrcov,.wilks,1,0,0,class<`factor`>,1
+rrcov,.wilks,2,0,0,character,1
+rrcov,.wilks,3,0,0,any,1
+rrcov,Wilks.test,-1,0,0,class<`htest`>,1
+rrcov,Wilks.test,0,0,0,class<`data.frame`>,1
+rrcov,Wilks.test,0,0,1,class<`formula`>,1
+rrcov,Wilks.test,0,0,2,class<`matrix`>,1
+rrcov,Wilks.test,1,0,0,...,1
+rrcov,Wilks.test.data.frame,-1,0,0,class<`htest`>,1
+rrcov,Wilks.test.data.frame,0,0,0,class<`data.frame`>,1
+rrcov,Wilks.test.data.frame,1,0,0,...,1
+rrcov,Wilks.test.default,-1,0,0,class<`htest`>,1
+rrcov,Wilks.test.default,0,0,0,class<`matrix`>,1
+rrcov,Wilks.test.default,1,0,0,class<`factor`>,1
+rrcov,Wilks.test.default,2,0,0,character[],1
+rrcov,Wilks.test.default,3,0,0,character[],1
+rrcov,Wilks.test.default,4,0,0,double,1
+rrcov,Wilks.test.default,4,0,1,null,1
+rrcov,Wilks.test.default,5,0,0,double,1
+rrcov,Wilks.test.default,5,0,1,null,1
+rrcov,Wilks.test.default,6,0,0,null,1
+rrcov,Wilks.test.default,7,0,0,null,1
+rrcov,Wilks.test.formula,-1,0,0,class<`htest`>,1
+rrcov,Wilks.test.formula,0,0,0,class<`formula`>,1
+rrcov,Wilks.test.formula,1,0,0,any,1
+rrcov,Wilks.test.formula,2,0,0,...,1
+rrcov,Wilks.test.formula,3,0,0,any,1
+rrcov,Wilks.test.formula,4,0,0,any,1
+rrcov,Wilks.test.matrix,-1,0,0,class<`htest`>,1
+rrcov,Wilks.test.matrix,0,0,0,class<`matrix`>,1
+rrcov,Wilks.test.matrix,1,0,0,class<`factor`>,1
+rrcov,Wilks.test.matrix,2,0,0,...,1
+rrcov,Wilks.test.matrix,3,0,0,any,1
+rrcov,Wilks.test.matrix,4,0,0,any,1
+rrcov,wt,-1,0,0,double[],1
+rrcov,wt,0,0,0,class<`PsiBwt`>,1
+rrcov,wt,1,0,0,double[],1
+rrcov,wt,-1,1,0,double[],1
+rrcov,wt,0,1,0,class<`PsiBwt`>,1
+rrcov,wt,1,1,0,double[],1
+rrcov,.xpc,-1,0,0,class<`princomp`>,1
+rrcov,.xpc,0,0,0,class<`data.frame`>,1
+rrcov,.xpc,0,0,1,class<`matrix`>,1
+rrcov,.xpc,1,0,0,list<class<`matrix`> | double[]>,1
+rrcov,.xpc,2,0,0,logical,1
+rrcov,.xpc,3,0,0,logical,1
+rrcov,.xydistplot,-1,0,0,class<`trellis`>,1
+rrcov,.xydistplot,0,0,0,class<`CovSest`>,1
+rrcov,.xydistplot,1,0,0,double,1
+rrcov,.xydistplot,2,0,0,character,1
+rrcov,.xydistplot,3,0,0,character,1
+rrcov,.xydistplot,4,0,0,character,1
+rrcov,.xydistplot,5,0,0,character,1
+rrcov,.xydistplot,6,0,0,any,1
+rrcov,.xydistplot,7,0,0,...,1
+rsample,add_class,-1,0,0,"class<`apparent`, `data.frame`, `rset`, `tbl`, `tbl_df`>",1
+rsample,add_class,-1,0,1,"class<`boot_split`, `rsplit`>",1
+rsample,add_class,-1,0,2,"class<`bootstraps`, `data.frame`, `nested_cv`, `rset`, `tbl`, `tbl_df`>",1
+rsample,add_class,-1,0,3,"class<`bootstraps`, `data.frame`, `rset`, `tbl`, `tbl_df`>",1
+rsample,add_class,-1,0,4,"class<`data.frame`, `group_vfold_cv`, `rset`, `tbl`, `tbl_df`>",1
+rsample,add_class,-1,0,5,"class<`data.frame`, `loo_cv`, `rset`, `tbl`, `tbl_df`>",1
+rsample,add_class,-1,0,6,"class<`data.frame`, `mc_cv`, `rset`, `tbl`, `tbl_df`>",1
+rsample,add_class,-1,0,7,"class<`data.frame`, `nested_cv`, `rset`, `tbl`, `tbl_df`, `vfold_cv`>",1
+rsample,add_class,-1,0,8,"class<`data.frame`, `rolling_origin`, `rset`, `tbl`, `tbl_df`>",1
+rsample,add_class,-1,0,9,"class<`data.frame`, `rset`, `tbl`, `tbl_df`, `vfold_cv`>",1
+rsample,add_class,-1,0,10,"class<`group_vfold_split`, `rsplit`>",1
+rsample,add_class,-1,0,11,"class<`mc_split`, `rsplit`>",1
+rsample,add_class,-1,0,12,"class<`rof_split`, `rsplit`>",1
+rsample,add_class,-1,0,13,"class<`rsplit`, `vfold_split`>",1
+rsample,add_class,0,0,0,"class<`data.frame`, `tbl`, `tbl_df`>",1
+rsample,add_class,0,0,1,class<`rsplit`>,1
+rsample,add_class,0,0,2,"class<`bootstraps`, `data.frame`, `rset`, `tbl`, `tbl_df`>",1
+rsample,add_class,0,0,3,"class<`data.frame`, `rset`, `tbl`, `tbl_df`, `vfold_cv`>",1
+rsample,add_class,1,0,0,character[],1
+rsample,add_class,2,0,0,logical,1
+rsample,add_resample_id,-1,0,0,any,1
+rsample,add_resample_id,0,0,0,any,1
+rsample,add_resample_id,1,0,0,any,1
+rsample,add_resample_id,2,0,0,double,1
+rsample,add_resample_id,2,0,1,logical[],1
+rsample,analysis,-1,0,0,class<`data.frame`>,1
+rsample,analysis,-1,0,1,"class<`data.frame`, `tbl`, `tbl_df`>",1
+rsample,analysis,0,0,0,"class<`boot_split`, `rsplit`>",1
+rsample,analysis,0,0,1,"class<`mc_split`, `rsplit`>",1
+rsample,analysis,0,0,2,"class<`rsplit`, `vfold_split`>",1
+rsample,analysis,0,0,3,"class<`rof_split`, `rsplit`>",1
+rsample,analysis,0,0,4,class<`rsplit`>,1
+rsample,analysis,1,0,0,...,1
+rsample,apparent,-1,0,0,"class<`apparent`, `data.frame`, `rset`, `tbl`, `tbl_df`>",1
+rsample,apparent,0,0,0,class<`data.frame`>,1
+rsample,apparent,1,0,0,...,1
+rsample,as.data.frame.rsplit,-1,0,0,class<`data.frame`>,1
+rsample,as.data.frame.rsplit,-1,0,1,"class<`data.frame`, `tbl`, `tbl_df`>",1
+rsample,as.data.frame.rsplit,0,0,0,"class<`boot_split`, `rsplit`>",1
+rsample,as.data.frame.rsplit,0,0,1,"class<`group_vfold_split`, `rsplit`>",1
+rsample,as.data.frame.rsplit,0,0,2,"class<`mc_split`, `rsplit`>",1
+rsample,as.data.frame.rsplit,0,0,3,"class<`rsplit`, `vfold_split`>",1
+rsample,as.data.frame.rsplit,0,0,4,"class<`rof_split`, `rsplit`>",1
+rsample,as.data.frame.rsplit,0,0,5,class<`rsplit`>,1
+rsample,as.data.frame.rsplit,1,0,0,null,1
+rsample,as.data.frame.rsplit,2,0,0,logical,1
+rsample,as.data.frame.rsplit,3,0,0,character,1
+rsample,as.data.frame.rsplit,4,0,0,...,1
+rsample,as.integer.rsplit,-1,0,0,integer[],1
+rsample,as.integer.rsplit,0,0,0,"class<`boot_split`, `rsplit`>",1
+rsample,as.integer.rsplit,0,0,1,"class<`group_vfold_split`, `rsplit`>",1
+rsample,as.integer.rsplit,0,0,2,"class<`mc_split`, `rsplit`>",1
+rsample,as.integer.rsplit,0,0,3,"class<`rof_split`, `rsplit`>",1
+rsample,as.integer.rsplit,0,0,4,class<`rsplit`>,1
+rsample,as.integer.rsplit,0,0,5,"class<`rsplit`, `vfold_split`>",1
+rsample,as.integer.rsplit,1,0,0,character,1
+rsample,as.integer.rsplit,2,0,0,...,1
+rsample,assessment,-1,0,0,class<`data.frame`>,1
+rsample,assessment,-1,0,1,"class<`data.frame`, `tbl`, `tbl_df`>",1
+rsample,assessment,0,0,0,"class<`group_vfold_split`, `rsplit`>",1
+rsample,assessment,0,0,1,"class<`mc_split`, `rsplit`>",1
+rsample,assessment,0,0,2,"class<`rsplit`, `vfold_split`>",1
+rsample,assessment,0,0,3,"class<`rof_split`, `rsplit`>",1
+rsample,assessment,1,0,0,...,1
+rsample,boot_splits,-1,0,0,"list<character[] | list<class<`boot_split`, `rsplit`>>>",1
+rsample,boot_splits,0,0,0,class<`data.frame`>,1
+rsample,boot_splits,1,0,0,double,1
+rsample,boot_splits,2,0,0,null,1
+rsample,boot_splits,2,0,1,character,1
+rsample,boot_splits,3,0,0,any,1
+rsample,bootstraps,-1,0,0,"class<`bootstraps`, `data.frame`, `rset`, `tbl`, `tbl_df`>",1
+rsample,bootstraps,0,0,0,class<`data.frame`>,1
+rsample,bootstraps,1,0,0,double,1
+rsample,bootstraps,2,0,0,character,1
+rsample,bootstraps,2,0,1,null,1
+rsample,bootstraps,3,0,0,double,1
+rsample,bootstraps,4,0,0,logical,1
+rsample,bootstraps,5,0,0,...,1
+rsample,complement,-1,0,0,integer[],1
+rsample,complement,0,0,0,"class<`boot_split`, `rsplit`>",1
+rsample,complement,0,0,1,"class<`group_vfold_split`, `rsplit`>",1
+rsample,complement,0,0,2,"class<`mc_split`, `rsplit`>",1
+rsample,complement,0,0,3,"class<`rof_split`, `rsplit`>",1
+rsample,complement,0,0,4,"class<`rsplit`, `vfold_split`>",1
+rsample,complement,1,0,0,...,1
+rsample,complement.boot_split,-1,0,0,integer[],1
+rsample,complement.boot_split,0,0,0,"class<`boot_split`, `rsplit`>",1
+rsample,complement.boot_split,1,0,0,...,1
+rsample,complement.group_vfold_split,-1,0,0,integer[],1
+rsample,complement.group_vfold_split,0,0,0,"class<`group_vfold_split`, `rsplit`>",1
+rsample,complement.group_vfold_split,0,0,1,"class<`mc_split`, `rsplit`>",1
+rsample,complement.group_vfold_split,0,0,2,"class<`rsplit`, `vfold_split`>",1
+rsample,complement.group_vfold_split,1,0,0,...,1
+rsample,complement.mc_split,-1,0,0,integer[],1
+rsample,complement.mc_split,0,0,0,"class<`group_vfold_split`, `rsplit`>",1
+rsample,complement.mc_split,0,0,1,"class<`mc_split`, `rsplit`>",1
+rsample,complement.mc_split,0,0,2,"class<`rsplit`, `vfold_split`>",1
+rsample,complement.mc_split,1,0,0,...,1
+rsample,complement.rof_split,-1,0,0,integer[],1
+rsample,complement.rof_split,0,0,0,"class<`rof_split`, `rsplit`>",1
+rsample,complement.rof_split,1,0,0,...,1
+rsample,complement.vfold_split,-1,0,0,integer[],1
+rsample,complement.vfold_split,0,0,0,"class<`group_vfold_split`, `rsplit`>",1
+rsample,complement.vfold_split,0,0,1,"class<`mc_split`, `rsplit`>",1
+rsample,complement.vfold_split,0,0,2,"class<`rsplit`, `vfold_split`>",1
+rsample,complement.vfold_split,1,0,0,...,1
+rsample,form_pred,-1,0,0,character[],1
+rsample,form_pred,0,0,0,class<`formula`>,1
+rsample,form_pred,0,0,1,"class<`formula`, `terms`>",1
+rsample,form_pred,1,0,0,...,1
+rsample,gather.rset,-1,0,0,class<`data.frame`>,1
+rsample,gather.rset,0,0,0,"class<`data.frame`, `rset`, `tbl`, `tbl_df`, `vfold_cv`>",1
+rsample,gather.rset,1,0,0,null,1
+rsample,gather.rset,2,0,0,null,1
+rsample,gather.rset,3,0,0,...,1
+rsample,gather.rset,4,0,0,logical,1
+rsample,gather.rset,5,0,0,logical,1
+rsample,gather.rset,6,0,0,logical,1
+rsample,group_vfold_cv,-1,0,0,"class<`data.frame`, `group_vfold_cv`, `rset`, `tbl`, `tbl_df`>",1
+rsample,group_vfold_cv,0,0,0,class<`data.frame`>,1
+rsample,group_vfold_cv,1,0,0,character,1
+rsample,group_vfold_cv,2,0,0,null,1
+rsample,group_vfold_cv,2,0,1,double,1
+rsample,group_vfold_cv,3,0,0,...,1
+rsample,group_vfold_splits,-1,0,0,"class<`data.frame`, `tbl`, `tbl_df`>",1
+rsample,group_vfold_splits,0,0,0,class<`data.frame`>,1
+rsample,group_vfold_splits,1,0,0,character,1
+rsample,group_vfold_splits,2,0,0,double,1
+rsample,group_vfold_splits,2,0,1,null,1
+rsample,initial_split,-1,0,0,"class<`mc_split`, `rsplit`>",1
+rsample,initial_split,0,0,0,class<`data.frame`>,1
+rsample,initial_split,1,0,0,double,1
+rsample,initial_split,2,0,0,null,1
+rsample,initial_split,3,0,0,double,1
+rsample,initial_split,4,0,0,...,1
+rsample,initial_time_split,-1,0,0,class<`rsplit`>,1
+rsample,initial_time_split,0,0,0,"class<`data.frame`, `tbl`, `tbl_df`>",1
+rsample,initial_time_split,1,0,0,double,1
+rsample,initial_time_split,2,0,0,...,1
+rsample,is_rset,-1,0,0,logical,1
+rsample,is_rset,0,0,0,"class<`data.frame`, `rset`, `tbl`, `tbl_df`, `vfold_cv`>",1
+rsample,labels.rsplit,-1,0,0,"class<`data.frame`, `tbl`, `tbl_df`>",1
+rsample,labels.rsplit,0,0,0,"class<`boot_split`, `rsplit`>",1
+rsample,labels.rsplit,0,0,1,"class<`rsplit`, `vfold_split`>",1
+rsample,labels.rsplit,1,0,0,...,1
+rsample,labels.vfold_cv,-1,0,0,any,1
+rsample,labels.vfold_cv,0,0,0,"class<`data.frame`, `rset`, `tbl`, `tbl_df`, `vfold_cv`>",1
+rsample,labels.vfold_cv,0,0,1,"class<`data.frame`, `nested_cv`, `rset`, `tbl`, `tbl_df`, `vfold_cv`>",1
+rsample,labels.vfold_cv,1,0,0,logical,1
+rsample,labels.vfold_cv,2,0,0,...,1
+rsample,loo_cv,-1,0,0,"class<`data.frame`, `loo_cv`, `rset`, `tbl`, `tbl_df`>",1
+rsample,loo_cv,0,0,0,class<`data.frame`>,1
+rsample,loo_cv,1,0,0,...,1
+rsample,make_strata,-1,0,0,class<`factor`>,1
+rsample,make_strata,0,0,0,character[],1
+rsample,make_strata,0,0,1,class<`factor`>,1
+rsample,make_strata,0,0,2,double[],1
+rsample,make_strata,1,0,0,any,1
+rsample,make_strata,2,0,0,double,1
+rsample,make_strata,3,0,0,double,1
+rsample,make_strata,4,0,0,double,1
+rsample,maybe_rset,-1,0,0,"class<`data.frame`, `tbl`, `tbl_df`>",1
+rsample,maybe_rset,0,0,0,"class<`data.frame`, `rset`, `tbl`, `tbl_df`, `vfold_cv`>",1
+rsample,maybe_rset,1,0,0,any,1
+rsample,maybe_rset,2,0,0,any,1
+rsample,mc_cv,-1,0,0,"class<`data.frame`, `mc_cv`, `rset`, `tbl`, `tbl_df`>",1
+rsample,mc_cv,0,0,0,class<`data.frame`>,1
+rsample,mc_cv,1,0,0,double,1
+rsample,mc_cv,2,0,0,double,1
+rsample,mc_cv,3,0,0,any,1
+rsample,mc_cv,4,0,0,any,1
+rsample,mc_cv,5,0,0,...,1
+rsample,mc_splits,-1,0,0,"list<character[] | list<class<`mc_split`, `rsplit`>>>",1
+rsample,mc_splits,-1,0,1,"list<character | list<class<`mc_split`, `rsplit`>>>",1
+rsample,mc_splits,0,0,0,class<`data.frame`>,1
+rsample,mc_splits,1,0,0,double,1
+rsample,mc_splits,2,0,0,double,1
+rsample,mc_splits,3,0,0,null,1
+rsample,mc_splits,3,0,1,character,1
+rsample,mc_splits,4,0,0,any,1
+rsample,names0,-1,0,0,character[],1
+rsample,names0,0,0,0,double,1
+rsample,names0,1,0,0,character,1
+rsample,nested_cv,-1,0,0,"class<`bootstraps`, `data.frame`, `nested_cv`, `rset`, `tbl`, `tbl_df`>",1
+rsample,nested_cv,-1,0,1,"class<`data.frame`, `nested_cv`, `rset`, `tbl`, `tbl_df`, `vfold_cv`>",1
+rsample,nested_cv,0,0,0,any,1
+rsample,nested_cv,1,0,0,any,1
+rsample,nested_cv,2,0,0,any,1
+rsample,new_rset,-1,0,0,"class<`bootstraps`, `data.frame`, `rset`, `tbl`, `tbl_df`>",1
+rsample,new_rset,-1,0,1,"class<`data.frame`, `group_vfold_cv`, `rset`, `tbl`, `tbl_df`>",1
+rsample,new_rset,-1,0,2,"class<`data.frame`, `loo_cv`, `rset`, `tbl`, `tbl_df`>",1
+rsample,new_rset,-1,0,3,"class<`data.frame`, `mc_cv`, `rset`, `tbl`, `tbl_df`>",1
+rsample,new_rset,-1,0,4,"class<`data.frame`, `rolling_origin`, `rset`, `tbl`, `tbl_df`>",1
+rsample,new_rset,-1,0,5,"class<`data.frame`, `rset`, `tbl`, `tbl_df`, `vfold_cv`>",1
+rsample,new_rset,0,0,0,"list<class<`boot_split`, `rsplit`> | class<`apparent_split`, `rsplit`>>",1
+rsample,new_rset,0,0,1,"list<class<`boot_split`, `rsplit`>>",1
+rsample,new_rset,0,0,2,"list<class<`group_vfold_split`, `rsplit`>>",1
+rsample,new_rset,0,0,3,"list<class<`loo_split`, `rsplit`>>",1
+rsample,new_rset,0,0,4,"list<class<`mc_split`, `rsplit`>>",1
+rsample,new_rset,0,0,5,"list<class<`rof_split`, `rsplit`>>",1
+rsample,new_rset,0,0,6,"list<class<`rsplit`, `vfold_split`>>",1
+rsample,new_rset,1,0,0,character[],1
+rsample,new_rset,1,0,1,"class<`data.frame`, `tbl`, `tbl_df`>",1
+rsample,new_rset,2,0,0,list<double>,1
+rsample,new_rset,2,0,1,list<null | character>,1
+rsample,new_rset,2,0,2,list<double | character>,1
+rsample,new_rset,2,0,3,null,1
+rsample,new_rset,3,0,0,character[],1
+rsample,populate,-1,0,0,"class<`rsplit`, `vfold_split`>",1
+rsample,populate,-1,0,1,"class<`data.frame`, `rset`, `tbl`, `tbl_df`, `vfold_cv`>",1
+rsample,populate,0,0,0,"class<`rsplit`, `vfold_split`>",1
+rsample,populate,0,0,1,"class<`data.frame`, `rset`, `tbl`, `tbl_df`, `vfold_cv`>",1
+rsample,populate,1,0,0,...,1
+rsample,populate.rset,-1,0,0,"class<`data.frame`, `rset`, `tbl`, `tbl_df`, `vfold_cv`>",1
+rsample,populate.rset,0,0,0,"class<`data.frame`, `rset`, `tbl`, `tbl_df`, `vfold_cv`>",1
+rsample,populate.rset,1,0,0,...,1
+rsample,populate.rsplit,-1,0,0,"class<`rsplit`, `vfold_split`>",1
+rsample,populate.rsplit,0,0,0,"class<`rsplit`, `vfold_split`>",1
+rsample,populate.rsplit,1,0,0,...,1
+rsample,register_s3_method,-1,0,0,null,1
+rsample,register_s3_method,0,0,0,character,1
+rsample,register_s3_method,1,0,0,character,1
+rsample,register_s3_method,2,0,0,character,1
+rsample,register_s3_method,3,0,0,null,1
+rsample,rolling_origin,-1,0,0,"class<`data.frame`, `rolling_origin`, `rset`, `tbl`, `tbl_df`>",1
+rsample,rolling_origin,0,0,0,class<`data.frame`>,1
+rsample,rolling_origin,0,0,1,"class<`data.frame`, `tbl`, `tbl_df`>",1
+rsample,rolling_origin,1,0,0,double,1
+rsample,rolling_origin,2,0,0,double,1
+rsample,rolling_origin,3,0,0,logical,1
+rsample,rolling_origin,4,0,0,double,1
+rsample,rolling_origin,5,0,0,...,1
+rsample,rsplit,-1,0,0,class<`rsplit`>,1
+rsample,rsplit,0,0,0,class<`data.frame`>,1
+rsample,rsplit,0,0,1,"class<`data.frame`, `tbl`, `tbl_df`>",1
+rsample,rsplit,1,0,0,integer[],1
+rsample,rsplit,2,0,0,integer[],1
+rsample,rsplit,2,0,1,null,1
+rsample,select.rset,-1,0,0,"class<`data.frame`, `tbl`, `tbl_df`>",1
+rsample,select.rset,0,0,0,"class<`data.frame`, `rset`, `tbl`, `tbl_df`, `vfold_cv`>",1
+rsample,select.rset,1,0,0,...,1
+rsample,strata_check,-1,0,0,null,1
+rsample,strata_check,0,0,0,character,1
+rsample,strata_check,0,0,1,null,1
+rsample,strata_check,1,0,0,any,1
+rsample,testing,-1,0,0,class<`data.frame`>,1
+rsample,testing,0,0,0,"class<`mc_split`, `rsplit`>",1
+rsample,tidy.rset,-1,0,0,"class<`data.frame`, `tbl`, `tbl_df`>",1
+rsample,tidy.rset,0,0,0,"class<`bootstraps`, `data.frame`, `rset`, `tbl`, `tbl_df`>",1
+rsample,tidy.rset,0,0,1,"class<`data.frame`, `mc_cv`, `rset`, `tbl`, `tbl_df`>",1
+rsample,tidy.rset,0,0,2,"class<`data.frame`, `rolling_origin`, `rset`, `tbl`, `tbl_df`>",1
+rsample,tidy.rset,1,0,0,...,1
+rsample,tidy.rsplit,-1,0,0,"class<`data.frame`, `tbl`, `tbl_df`>",1
+rsample,tidy.rsplit,0,0,0,"class<`boot_split`, `rsplit`>",1
+rsample,tidy.rsplit,0,0,1,"class<`mc_split`, `rsplit`>",1
+rsample,tidy.rsplit,0,0,2,"class<`rof_split`, `rsplit`>",1
+rsample,tidy.rsplit,0,0,3,"class<`rsplit`, `vfold_split`>",1
+rsample,tidy.rsplit,1,0,0,logical,1
+rsample,tidy.rsplit,2,0,0,...,1
+rsample,tidy.vfold_cv,-1,0,0,"class<`data.frame`, `tbl`, `tbl_df`>",1
+rsample,tidy.vfold_cv,0,0,0,"class<`data.frame`, `rset`, `tbl`, `tbl_df`, `vfold_cv`>",1
+rsample,tidy.vfold_cv,1,0,0,...,1
+rsample,training,-1,0,0,class<`data.frame`>,1
+rsample,training,-1,0,1,"class<`data.frame`, `tbl`, `tbl_df`>",1
+rsample,training,0,0,0,"class<`mc_split`, `rsplit`>",1
+rsample,training,0,0,1,class<`rsplit`>,1
+rsample,vfold_cv,-1,0,0,"class<`data.frame`, `rset`, `tbl`, `tbl_df`, `vfold_cv`>",1
+rsample,vfold_cv,0,0,0,class<`data.frame`>,1
+rsample,vfold_cv,1,0,0,double,1
+rsample,vfold_cv,2,0,0,double,1
+rsample,vfold_cv,3,0,0,character,1
+rsample,vfold_cv,3,0,1,null,1
+rsample,vfold_cv,4,0,0,double,1
+rsample,vfold_cv,5,0,0,...,1
+rsample,vfold_splits,-1,0,0,"class<`data.frame`, `tbl`, `tbl_df`>",1
+rsample,vfold_splits,0,0,0,class<`data.frame`>,1
+rsample,vfold_splits,1,0,0,double,1
+rsample,vfold_splits,2,0,0,character,1
+rsample,vfold_splits,2,0,1,null,1
+rsample,vfold_splits,3,0,0,any,1
+rsdmx,addSDMXServiceProvider,-1,0,0,class<`SDMXServiceProviders`>,1
+rsdmx,addSDMXServiceProvider,0,0,0,class<`SDMXServiceProvider`>,1
+rsdmx,as.data.frame.SDMXGenericData,-1,0,0,class<`data.frame`>,1
+rsdmx,as.data.frame.SDMXGenericData,0,0,0,class<`SDMXMessageGroup`>,1
+rsdmx,as.data.frame.SDMXGenericData,1,0,0,null,1
+rsdmx,as.data.frame.SDMXGenericData,2,0,0,logical,1
+rsdmx,as.data.frame.SDMXGenericData,3,0,0,logical,1
+rsdmx,as.data.frame.SDMXGenericData,4,0,0,...,1
+rsdmx,as.data.frame.SDMXMessageGroup,-1,0,0,class<`data.frame`>,1
+rsdmx,as.data.frame.SDMXMessageGroup,0,0,0,class<`SDMXMessageGroup`>,1
+rsdmx,as.data.frame.SDMXMessageGroup,1,0,0,null,1
+rsdmx,as.data.frame.SDMXMessageGroup,2,0,0,logical,1
+rsdmx,as.data.frame.SDMXMessageGroup,3,0,0,logical,1
+rsdmx,as.data.frame.SDMXMessageGroup,4,0,0,...,1
+rsdmx,as.data.frame.SDMXServiceProviders,-1,0,0,class<`data.frame`>,1
+rsdmx,as.data.frame.SDMXServiceProviders,0,0,0,class<`SDMXServiceProviders`>,1
+rsdmx,as.data.frame.SDMXServiceProviders,1,0,0,...,1
+rsdmx,class.SDMXMessageGroup,-1,0,0,character,1
+rsdmx,class.SDMXMessageGroup,0,0,0,"class<`XMLAbstractDocument`, `XMLInternalDocument`>",1
+rsdmx,codelists.SDMXCodelists,-1,0,0,list<class<`SDMXCodelist`>>,1
+rsdmx,codelists.SDMXCodelists,0,0,0,"class<`XMLAbstractDocument`, `XMLInternalDocument`>",1
+rsdmx,codelists.SDMXCodelists,1,0,0,class<`data.frame`>,1
+rsdmx,dsdRef.SDMXData,-1,0,0,character,1
+rsdmx,dsdRef.SDMXData,-1,0,1,null,1
+rsdmx,dsdRef.SDMXData,0,0,0,"class<`XMLAbstractDocument`, `XMLInternalDocument`>",1
+rsdmx,dsdRef.SDMXData,1,0,0,class<`data.frame`>,1
+rsdmx,encodeSDMXOutput,-1,0,0,class<`data.frame`>,1
+rsdmx,encodeSDMXOutput,0,0,0,class<`data.frame`>,1
+rsdmx,findNamespace,-1,0,0,character[],1
+rsdmx,findNamespace,0,0,0,class<`data.frame`>,1
+rsdmx,findNamespace,1,0,0,character,1
+rsdmx,findSDMXServiceProvider,-1,0,0,class<`SDMXServiceProvider`>,1
+rsdmx,findSDMXServiceProvider,0,0,0,character,1
+rsdmx,getNamespaces,-1,0,0,class<`data.frame`>,1
+rsdmx,getNamespaces,0,0,0,class<`SDMXGenericData`>,1
+rsdmx,getNamespaces,0,0,1,class<`SDMXMessageGroup`>,1
+rsdmx,getNamespaces,-1,1,0,class<`data.frame`>,1
+rsdmx,getNamespaces,0,1,0,class<`SDMXMessageGroup`>,1
+rsdmx,getNamespaces,-1,2,0,class<`data.frame`>,1
+rsdmx,getNamespaces,0,2,0,class<`SDMXGenericData`>,1
+rsdmx,getSDMXServiceProviders,-1,0,0,class<`SDMXServiceProviders`>,1
+rsdmx,getStructureType,-1,0,0,character,1
+rsdmx,getStructureType,0,0,0,class<`SDMXStructureType`>,1
+rsdmx,getStructureType,-1,1,0,character,1
+rsdmx,getStructureType,0,1,0,class<`SDMXStructureType`>,1
+rsdmx,isRegistryInterfaceEnvelope,-1,0,0,logical,1
+rsdmx,isRegistryInterfaceEnvelope,0,0,0,"class<`XMLAbstractDocument`, `XMLInternalDocument`>",1
+rsdmx,isRegistryInterfaceEnvelope,1,0,0,logical,1
+rsdmx,isSoapRequestEnvelope,-1,0,0,logical,1
+rsdmx,isSoapRequestEnvelope,0,0,0,"class<`XMLAbstractDocument`, `XMLInternalDocument`>",1
+rsdmx,isSoapRequestEnvelope,1,0,0,any,1
+rsdmx,namespaces.SDMX,-1,0,0,class<`data.frame`>,1
+rsdmx,namespaces.SDMX,0,0,0,"class<`XMLAbstractDocument`, `XMLInternalDocument`>",1
+rsdmx,readSDMX,-1,0,0,any,1
+rsdmx,readSDMX,0,0,0,character,1
+rsdmx,readSDMX,0,0,1,null,1
+rsdmx,readSDMX,1,0,0,logical,1
+rsdmx,readSDMX,2,0,0,logical,1
+rsdmx,readSDMX,3,0,0,null,1
+rsdmx,readSDMX,4,0,0,null,1
+rsdmx,readSDMX,4,0,1,character,1
+rsdmx,readSDMX,5,0,0,null,1
+rsdmx,readSDMX,6,0,0,null,1
+rsdmx,readSDMX,7,0,0,null,1
+rsdmx,readSDMX,7,0,1,character,1
+rsdmx,saveSDMX,-1,0,0,null,1
+rsdmx,saveSDMX,0,0,0,class<`SDMXCodelists`>,1
+rsdmx,saveSDMX,0,0,1,class<`SDMXMessageGroup`>,1
+rsdmx,saveSDMX,1,0,0,character,1
+rsdmx,SDMX,-1,0,0,class<`SDMX`>,1
+rsdmx,SDMX,0,0,0,"class<`XMLAbstractDocument`, `XMLInternalDocument`>",1
+rsdmx,SDMX,1,0,0,class<`data.frame`>,1
+rsdmx,SDMXCodelists,-1,0,0,class<`SDMXCodelists`>,1
+rsdmx,SDMXCodelists,0,0,0,"class<`XMLAbstractDocument`, `XMLInternalDocument`>",1
+rsdmx,SDMXCodelists,1,0,0,class<`data.frame`>,1
+rsdmx,SDMXData,-1,0,0,class<`SDMXData`>,1
+rsdmx,SDMXData,0,0,0,"class<`XMLAbstractDocument`, `XMLInternalDocument`>",1
+rsdmx,SDMXData,1,0,0,class<`data.frame`>,1
+rsdmx,SDMXDotStatRequestBuilder,-1,0,0,class<`SDMXDotStatRequestBuilder`>,1
+rsdmx,SDMXDotStatRequestBuilder,0,0,0,character,1
+rsdmx,SDMXDotStatRequestBuilder,1,0,0,character,1
+rsdmx,SDMXDotStatRequestBuilder,2,0,0,null,1
+rsdmx,SDMXDotStatRequestBuilder,3,0,0,list<any>,1
+rsdmx,SDMXDotStatRequestBuilder,4,0,0,logical,1
+rsdmx,SDMXDotStatRequestBuilder,5,0,0,logical,1
+rsdmx,SDMXFooter,-1,0,0,class<`SDMXFooter`>,1
+rsdmx,SDMXFooter,0,0,0,any,1
+rsdmx,SDMXFooter,1,0,0,class<`data.frame`>,1
+rsdmx,SDMXGenericData,-1,0,0,class<`SDMXGenericData`>,1
+rsdmx,SDMXGenericData,0,0,0,"class<`XMLAbstractDocument`, `XMLInternalDocument`>",1
+rsdmx,SDMXGenericData,1,0,0,class<`data.frame`>,1
+rsdmx,SDMXHeader,-1,0,0,class<`SDMXHeader`>,1
+rsdmx,SDMXHeader,0,0,0,"class<`XMLAbstractDocument`, `XMLInternalDocument`>",1
+rsdmx,SDMXHeader,1,0,0,class<`data.frame`>,1
+rsdmx,SDMXMessageGroup,-1,0,0,class<`SDMXMessageGroup`>,1
+rsdmx,SDMXMessageGroup,0,0,0,"class<`XMLAbstractDocument`, `XMLInternalDocument`>",1
+rsdmx,SDMXMessageGroup,1,0,0,class<`data.frame`>,1
+rsdmx,SDMXRequestBuilder,-1,0,0,class<`SDMXRequestBuilder`>,1
+rsdmx,SDMXRequestBuilder,0,0,0,character,1
+rsdmx,SDMXRequestBuilder,1,0,0,character,1
+rsdmx,SDMXRequestBuilder,2,0,0,null,1
+rsdmx,SDMXRequestBuilder,3,0,0,list<class<`function`>>,1
+rsdmx,SDMXRequestBuilder,4,0,0,list<class<`function`>>,1
+rsdmx,SDMXRequestBuilder,5,0,0,logical,1
+rsdmx,SDMXRequestBuilder,6,0,0,list<any>,1
+rsdmx,SDMXRequestParams,-1,0,0,class<`SDMXRequestParams`>,1
+rsdmx,SDMXRequestParams,0,0,0,character,1
+rsdmx,SDMXRequestParams,1,0,0,character,1
+rsdmx,SDMXRequestParams,2,0,0,null,1
+rsdmx,SDMXRequestParams,3,0,0,character,1
+rsdmx,SDMXRequestParams,4,0,0,character,1
+rsdmx,SDMXRequestParams,4,0,1,null,1
+rsdmx,SDMXRequestParams,5,0,0,character,1
+rsdmx,SDMXRequestParams,6,0,0,character,1
+rsdmx,SDMXRequestParams,6,0,1,null,1
+rsdmx,SDMXRequestParams,7,0,0,character,1
+rsdmx,SDMXRequestParams,7,0,1,null,1
+rsdmx,SDMXREST20RequestBuilder,-1,0,0,class<`SDMXREST20RequestBuilder`>,1
+rsdmx,SDMXREST20RequestBuilder,0,0,0,character,1
+rsdmx,SDMXREST20RequestBuilder,1,0,0,character,1
+rsdmx,SDMXREST20RequestBuilder,2,0,0,null,1
+rsdmx,SDMXREST20RequestBuilder,3,0,0,logical,1
+rsdmx,SDMXREST20RequestBuilder,4,0,0,list<any>,1
+rsdmx,SDMXREST20RequestBuilder,5,0,0,logical,1
+rsdmx,SDMXREST20RequestBuilder,6,0,0,logical,1
+rsdmx,SDMXREST21RequestBuilder,-1,0,0,class<`SDMXREST21RequestBuilder`>,1
+rsdmx,SDMXREST21RequestBuilder,0,0,0,character,1
+rsdmx,SDMXREST21RequestBuilder,1,0,0,character,1
+rsdmx,SDMXREST21RequestBuilder,2,0,0,character,1
+rsdmx,SDMXREST21RequestBuilder,2,0,1,null,1
+rsdmx,SDMXREST21RequestBuilder,3,0,0,logical,1
+rsdmx,SDMXREST21RequestBuilder,4,0,0,list<any>,1
+rsdmx,SDMXREST21RequestBuilder,5,0,0,logical,1
+rsdmx,SDMXREST21RequestBuilder,6,0,0,logical,1
+rsdmx,SDMXSchema,-1,0,0,class<`SDMXSchema`>,1
+rsdmx,SDMXSchema,0,0,0,any,1
+rsdmx,SDMXSchema,1,0,0,class<`data.frame`>,1
+rsdmx,SDMXServiceProvider,-1,0,0,class<`SDMXServiceProvider`>,1
+rsdmx,SDMXServiceProvider,0,0,0,character,1
+rsdmx,SDMXServiceProvider,1,0,0,character,1
+rsdmx,SDMXServiceProvider,2,0,0,character,1
+rsdmx,SDMXServiceProvider,3,0,0,character,1
+rsdmx,SDMXServiceProvider,3,0,1,null,1
+rsdmx,SDMXServiceProvider,4,0,0,class<`SDMXDotStatRequestBuilder`>,1
+rsdmx,SDMXServiceProvider,4,0,1,class<`SDMXRequestBuilder`>,1
+rsdmx,SDMXServiceProvider,4,0,2,class<`SDMXREST21RequestBuilder`>,1
+rsdmx,SDMXServiceProvider,4,0,3,class<`SDMXREST20RequestBuilder`>,1
+rsdmx,SDMXStructureType,-1,0,0,class<`SDMXStructureType`>,1
+rsdmx,SDMXStructureType,0,0,0,"class<`XMLAbstractDocument`, `XMLInternalDocument`>",1
+rsdmx,SDMXStructureType,1,0,0,class<`data.frame`>,1
+rsdmx,SDMXStructureType,2,0,0,any,1
+rsdmx,SDMXType,-1,0,0,class<`SDMXType`>,1
+rsdmx,SDMXType,0,0,0,"class<`XMLAbstractDocument`, `XMLInternalDocument`>",1
+rsdmx,setSDMXServiceProviders,-1,0,0,class<`SDMXServiceProviders`>,1
+rsdmx,type.SDMXStructureType,-1,0,0,character,1
+rsdmx,type.SDMXStructureType,-1,0,1,null,1
+rsdmx,type.SDMXStructureType,0,0,0,"class<`XMLAbstractDocument`, `XMLInternalDocument`>",1
+rsdmx,type.SDMXStructureType,1,0,0,class<`data.frame`>,1
+rsdmx,type.SDMXStructureType,2,0,0,any,1
+rsdmx,type.SDMXType,-1,0,0,character,1
+rsdmx,type.SDMXType,0,0,0,"class<`XMLAbstractDocument`, `XMLInternalDocument`>",1
+rsdmx,version.SDMXSchema,-1,0,0,character,1
+rsdmx,version.SDMXSchema,0,0,0,any,1
+rsdmx,version.SDMXSchema,1,0,0,class<`data.frame`>,1
+rsm,as.coded.data,-1,0,0,"class<`coded.data`, `data.frame`>",1
+rsm,as.coded.data,0,0,0,"class<`coded.data`, `data.frame`>",1
+rsm,as.coded.data,0,0,1,class<`data.frame`>,1
+rsm,as.coded.data,1,0,0,...,1
+rsm,as.coded.data,2,0,0,list<class<`formula`>>,1
+rsm,as.coded.data,3,0,0,character,1
+rsm,bbd,-1,0,0,"class<`coded.data`, `data.frame`>",1
+rsm,bbd,0,0,0,double,1
+rsm,bbd,0,0,1,class<`formula`>,1
+rsm,bbd,1,0,0,double,1
+rsm,bbd,2,0,0,logical,1
+rsm,bbd,2,0,1,character,1
+rsm,bbd,3,0,0,logical,1
+rsm,bbd,4,0,0,any,1
+rsm,.block.indices,-1,0,0,list<integer[]>,1
+rsm,.block.indices,0,0,0,"class<`coded.data`, `data.frame`>",1
+rsm,.block.indices,0,0,1,class<`data.frame`>,1
+rsm,canonical,-1,0,0,list<double[] | class<`eigen`>>,1
+rsm,canonical,0,0,0,"class<`lm`, `rsm`>",1
+rsm,canonical,1,0,0,double,1
+rsm,canonical.path,-1,0,0,class<`data.frame`>,1
+rsm,canonical.path,0,0,0,"class<`lm`, `rsm`>",1
+rsm,canonical.path,1,0,0,double,1
+rsm,canonical.path,2,0,0,double[],1
+rsm,canonical.path,3,0,0,logical,1
+rsm,canonical.path,4,0,0,double,1
+rsm,ccd,-1,0,0,"class<`coded.data`, `data.frame`>",1
+rsm,ccd,0,0,0,class<`formula`>,1
+rsm,ccd,0,0,1,double,1
+rsm,ccd,1,0,0,any,1
+rsm,ccd,2,0,0,character,1
+rsm,ccd,2,0,1,class<`formula`>,1
+rsm,ccd,3,0,0,double[],1
+rsm,ccd,4,0,0,character,1
+rsm,ccd,5,0,0,double,1
+rsm,ccd,6,0,0,double,1
+rsm,ccd,7,0,0,logical,1
+rsm,ccd.pick,-1,0,0,class<`data.frame`>,1
+rsm,ccd.pick,0,0,0,double,1
+rsm,ccd.pick,1,0,0,double[],1
+rsm,ccd.pick,2,0,0,integer[],1
+rsm,ccd.pick,3,0,0,double[],1
+rsm,ccd.pick,4,0,0,integer[],1
+rsm,ccd.pick,5,0,0,double,1
+rsm,ccd.pick,6,0,0,integer[],1
+rsm,ccd.pick,6,0,1,double,1
+rsm,ccd.pick,7,0,0,double,1
+rsm,code2val,-1,0,0,class<`data.frame`>,1
+rsm,code2val,-1,0,1,double[],1
+rsm,code2val,0,0,0,class<`data.frame`>,1
+rsm,code2val,0,0,1,double[],1
+rsm,code2val,1,0,0,list<class<`formula`>>,1
+rsm,[.coded.data,-1,0,0,"class<`coded.data`, `data.frame`>",1
+rsm,[.coded.data,-1,0,1,class<`data.frame`>,1
+rsm,[.coded.data,0,0,0,"class<`coded.data`, `data.frame`>",1
+rsm,[.coded.data,0,0,1,class<`data.frame`>,1
+rsm,[.coded.data,1,0,0,...,1
+rsm,coded.data,-1,0,0,"class<`coded.data`, `data.frame`>",1
+rsm,coded.data,0,0,0,class<`data.frame`>,1
+rsm,coded.data,1,0,0,...,1
+rsm,coded.data,2,0,0,list<any>,1
+rsm,coded.data,3,0,0,character,1
+rsm,codings,-1,0,0,list<class<`formula`>>,1
+rsm,codings,0,0,0,"class<`coded.data`, `data.frame`>",1
+rsm,codings,0,0,1,"class<`lm`, `rsm`>",1
+rsm,codings<-,-1,0,0,"class<`coded.data`, `data.frame`>",1
+rsm,codings<-,0,0,0,"class<`coded.data`, `data.frame`>",1
+rsm,codings<-,1,0,0,list<class<`formula`>>,1
+rsm,codings.coded.data,-1,0,0,list<class<`formula`>>,1
+rsm,codings.coded.data,0,0,0,"class<`coded.data`, `data.frame`>",1
+rsm,codings.rsm,-1,0,0,list<class<`formula`>>,1
+rsm,codings.rsm,0,0,0,"class<`lm`, `rsm`>",1
+rsm,contour.lm,-1,0,0,list<list<double[] | class<`matrix`> | character[]>>,1
+rsm,contour.lm,0,0,0,"class<`lm`, `rsm`>",1
+rsm,contour.lm,1,0,0,class<`formula`>,1
+rsm,contour.lm,2,0,0,any,1
+rsm,contour.lm,3,0,0,any,1
+rsm,contour.lm,4,0,0,any,1
+rsm,contour.lm,5,0,0,any,1
+rsm,contour.lm,6,0,0,any,1
+rsm,contour.lm,7,0,0,logical,1
+rsm,cube,-1,0,0,"class<`coded.data`, `data.frame`>",1
+rsm,cube,0,0,0,class<`formula`>,1
+rsm,cube,0,0,1,double,1
+rsm,cube,1,0,0,any,1
+rsm,cube,2,0,0,double,1
+rsm,cube,3,0,0,double,1
+rsm,cube,4,0,0,any,1
+rsm,cube,5,0,0,logical,1
+rsm,cube,6,0,0,any,1
+rsm,cube,7,0,0,double,1
+rsm,decode.data,-1,0,0,class<`data.frame`>,1
+rsm,decode.data,0,0,0,"class<`coded.data`, `data.frame`>",1
+rsm,decode.data,0,0,1,class<`data.frame`>,1
+rsm,djoin,-1,0,0,"class<`coded.data`, `data.frame`>",1
+rsm,djoin,0,0,0,"class<`coded.data`, `data.frame`>",1
+rsm,djoin,1,0,0,"class<`coded.data`, `data.frame`>",1
+rsm,djoin,1,0,1,class<`call`>,1
+rsm,djoin,1,0,2,class<`data.frame`>,1
+rsm,djoin,2,0,0,...,1
+rsm,djoin,3,0,0,any,1
+rsm,djoin,4,0,0,any,1
+rsm,dupe,-1,0,0,"class<`coded.data`, `data.frame`>",1
+rsm,dupe,0,0,0,"class<`coded.data`, `data.frame`>",1
+rsm,dupe,1,0,0,logical,1
+rsm,dupe,2,0,0,any,1
+rsm,FO,-1,0,0,class<`matrix`>,1
+rsm,FO,0,0,0,...,1
+rsm,foldover,-1,0,0,"class<`coded.data`, `data.frame`>",1
+rsm,foldover,0,0,0,"class<`coded.data`, `data.frame`>",1
+rsm,foldover,1,0,0,any,1
+rsm,foldover,2,0,0,any,1
+rsm,foldover,3,0,0,logical,1
+rsm,is.coded.data,-1,0,0,logical,1
+rsm,is.coded.data,0,0,0,"class<`coded.data`, `data.frame`>",1
+rsm,is.coded.data,0,0,1,class<`data.frame`>,1
+rsm,loftest,-1,0,0,"class<`anova`, `data.frame`>",1
+rsm,loftest,0,0,0,"class<`lm`, `rsm`>",1
+rsm,model.data,-1,0,0,"class<`coded.data`, `data.frame`>",1
+rsm,model.data,-1,0,1,class<`data.frame`>,1
+rsm,model.data,0,0,0,"class<`lm`, `rsm`>",1
+rsm,model.data,0,0,1,class<`lm`>,1
+rsm,model.data,1,0,0,logical,1
+rsm,names<-.coded.data,-1,0,0,"class<`coded.data`, `data.frame`>",1
+rsm,names<-.coded.data,0,0,0,"class<`coded.data`, `data.frame`>",1
+rsm,names<-.coded.data,1,0,0,character[],1
+rsm,.orth.moments,-1,0,0,class<`matrix`>,1
+rsm,.orth.moments,0,0,0,"class<`coded.data`, `data.frame`>",1
+rsm,.parse.coding,-1,0,0,list<character[] | double[]>,1
+rsm,.parse.coding,0,0,0,class<`formula`>,1
+rsm,PE,-1,0,0,class<`factor`>,1
+rsm,PE,0,0,0,...,1
+rsm,PQ,-1,0,0,class<`matrix`>,1
+rsm,PQ,0,0,0,...,1
+rsm,print.coded.data,-1,0,0,"class<`coded.data`, `data.frame`>",1
+rsm,print.coded.data,0,0,0,"class<`coded.data`, `data.frame`>",1
+rsm,print.coded.data,1,0,0,...,1
+rsm,print.coded.data,2,0,0,logical,1
+rsm,.randomize,-1,0,0,"class<`coded.data`, `data.frame`>",1
+rsm,.randomize,-1,0,1,class<`data.frame`>,1
+rsm,.randomize,0,0,0,"class<`coded.data`, `data.frame`>",1
+rsm,.randomize,0,0,1,class<`data.frame`>,1
+rsm,.randomize,1,0,0,logical,1
+rsm,recode.data,-1,0,0,"class<`coded.data`, `data.frame`>",1
+rsm,recode.data,0,0,0,"class<`coded.data`, `data.frame`>",1
+rsm,recode.data,1,0,0,...,1
+rsm,recode.data,2,0,0,list<class<`formula`>>,1
+rsm,register_s3_method,-1,0,0,null,1
+rsm,register_s3_method,0,0,0,character,1
+rsm,register_s3_method,1,0,0,character,1
+rsm,register_s3_method,2,0,0,character,1
+rsm,.rot.moments,-1,0,0,double[],1
+rsm,.rot.moments,0,0,0,"class<`coded.data`, `data.frame`>",1
+rsm,.rsdesattr,-1,0,0,list<character[] | class<`call`>>,1
+rsm,.rsdesattr,-1,0,1,list<character | class<`call`>>,1
+rsm,.rsdesattr,0,0,0,"class<`coded.data`, `data.frame`>",1
+rsm,.rsdesattr,0,0,1,class<`data.frame`>,1
+rsm,.rsdesattr,1,0,0,character[],1
+rsm,.rsdesattr,2,0,0,character,1
+rsm,.rsdesattr,3,0,0,class<`call`>,1
+rsm,rsm,-1,0,0,"class<`lm`, `rsm`>",1
+rsm,rsm,0,0,0,class<`formula`>,1
+rsm,rsm,1,0,0,"class<`coded.data`, `data.frame`>",1
+rsm,rsm,2,0,0,...,1
+rsm,SO,-1,0,0,class<`matrix`>,1
+rsm,SO,0,0,0,...,1
+rsm,star,-1,0,0,class<`call`>,1
+rsm,star,-1,0,1,"class<`coded.data`, `data.frame`>",1
+rsm,star,0,0,0,any,1
+rsm,star,1,0,0,double,1
+rsm,star,2,0,0,character,1
+rsm,star,3,0,0,double,1
+rsm,star,4,0,0,logical,1
+rsm,stdorder,-1,0,0,"class<`coded.data`, `data.frame`>",1
+rsm,stdorder,0,0,0,"class<`coded.data`, `data.frame`>",1
+rsm,steepest,-1,0,0,class<`data.frame`>,1
+rsm,steepest,0,0,0,"class<`lm`, `rsm`>",1
+rsm,steepest,1,0,0,double[],1
+rsm,steepest,2,0,0,logical,1
+rsm,summary.rsm,-1,0,0,"class<`summary.lm`, `summary.rsm`>",1
+rsm,summary.rsm,0,0,0,"class<`lm`, `rsm`>",1
+rsm,summary.rsm,1,0,0,character[],1
+rsm,summary.rsm,2,0,0,...,1
+rsm,truenames,-1,0,0,character[],1
+rsm,truenames,0,0,0,"class<`coded.data`, `data.frame`>",1
+rsm,truenames.coded.data,-1,0,0,character[],1
+rsm,truenames.coded.data,0,0,0,"class<`coded.data`, `data.frame`>",1
+rsm,TWI,-1,0,0,class<`matrix`>,1
+rsm,TWI,0,0,0,...,1
+rsm,TWI,1,0,0,any,1
+rsm,varfcn,-1,0,0,class<`data.frame`>,1
+rsm,varfcn,0,0,0,"class<`coded.data`, `data.frame`>",1
+rsm,varfcn,1,0,0,class<`formula`>,1
+rsm,varfcn,2,0,0,double[],1
+rsm,varfcn,3,0,0,any,1
+rsm,varfcn,4,0,0,logical,1
+rsm,varfcn,5,0,0,logical,1
+rsm,varfcn,6,0,0,any,1
+rsm,varfcn,7,0,0,...,1
+rstantools,.central_intervals,-1,0,0,class<`matrix`>,1
+rstantools,.central_intervals,0,0,0,class<`matrix`>,1
+rstantools,.central_intervals,1,0,0,double,1
+rstantools,posterior_interval,-1,0,0,class<`matrix`>,1
+rstantools,posterior_interval,0,0,0,class<`matrix`>,1
+rstantools,posterior_interval,1,0,0,...,1
+rstantools,posterior_interval.default,-1,0,0,class<`matrix`>,1
+rstantools,posterior_interval.default,0,0,0,class<`matrix`>,1
+rstantools,posterior_interval.default,1,0,0,double,1
+rstantools,posterior_interval.default,2,0,0,...,1
+rstantools,.pred_errors,-1,0,0,class<`matrix`>,1
+rstantools,.pred_errors,0,0,0,class<`matrix`>,1
+rstantools,.pred_errors,1,0,0,double[],1
+rstantools,predictive_error,-1,0,0,class<`matrix`>,1
+rstantools,predictive_error,0,0,0,class<`matrix`>,1
+rstantools,predictive_error,1,0,0,...,1
+rstantools,predictive_error.default,-1,0,0,class<`matrix`>,1
+rstantools,predictive_error.default,0,0,0,class<`matrix`>,1
+rstantools,predictive_error.default,1,0,0,double[],1
+rstantools,predictive_error.default,2,0,0,...,1
+rstantools,predictive_interval,-1,0,0,class<`matrix`>,1
+rstantools,predictive_interval,0,0,0,class<`matrix`>,1
+rstantools,predictive_interval,1,0,0,...,1
+rstantools,predictive_interval.default,-1,0,0,class<`matrix`>,1
+rstantools,predictive_interval.default,0,0,0,class<`matrix`>,1
+rstantools,predictive_interval.default,1,0,0,double,1
+rstantools,predictive_interval.default,2,0,0,...,1
+rsvg,rsvg,-1,0,0,any,1
+rsvg,rsvg,0,0,0,character,1
+rsvg,rsvg,1,0,0,null,1
+rsvg,rsvg,2,0,0,double,1
+rsvg,rsvg_raw,-1,0,0,any,1
+rsvg,rsvg_raw,0,0,0,character,1
+rsvg,rsvg_raw,1,0,0,null,1
+rsvg,rsvg_raw,2,0,0,double,1
+rsvg,svg_data,-1,0,0,raw[],1
+rsvg,svg_data,0,0,0,character,1
+rtf,.add.color.table,-1,0,0,character,1
+rtf,.add.font.table,-1,0,0,character,1
+rtf,.add.header,-1,0,0,character,1
+rtf,.add.header,0,0,0,character,1
+rtf,.add.header,1,0,0,character,1
+rtf,.add.header,2,0,0,double,1
+rtf,.add.header,3,0,0,double,1
+rtf,.add.header,4,0,0,null,1
+rtf,addHeader,-1,0,0,character,1
+rtf,addHeader,0,0,0,...,1
+rtf,addHeader.RTF,-1,0,0,character,1
+rtf,addHeader.RTF,0,0,0,"class<`Object`, `RTF`>",1
+rtf,addHeader.RTF,1,0,0,character,1
+rtf,addHeader.RTF,2,0,0,character,1
+rtf,addHeader.RTF,3,0,0,null,1
+rtf,addHeader.RTF,4,0,0,null,1
+rtf,addHeader.RTF,5,0,0,...,1
+rtf,.add.merged.table.row,-1,0,0,character,1
+rtf,.add.merged.table.row,0,0,0,character[],1
+rtf,.add.merged.table.row,1,0,0,double[],1
+rtf,.add.merged.table.row,2,0,0,character,1
+rtf,.add.merged.table.row,3,0,0,double,1
+rtf,.add.merged.table.row,4,0,0,logical,1
+rtf,.add.merged.table.row,5,0,0,double,1
+rtf,.add.merged.table.row,6,0,0,logical,1
+rtf,.add.merged.table.row,7,0,0,logical,1
+rtf,.add.newline,-1,0,0,character,1
+rtf,.add.newline,0,0,0,double,1
+rtf,.add.newline,1,0,0,double,1
+rtf,addNewLine,-1,0,0,character,1
+rtf,addNewLine,0,0,0,...,1
+rtf,addNewLine.RTF,-1,0,0,character,1
+rtf,addNewLine.RTF,0,0,0,"class<`Object`, `RTF`>",1
+rtf,addNewLine.RTF,1,0,0,double,1
+rtf,addNewLine.RTF,2,0,0,...,1
+rtf,.add.page.break,-1,0,0,character,1
+rtf,.add.page.break,0,0,0,double,1
+rtf,.add.page.break,1,0,0,double,1
+rtf,.add.page.break,2,0,0,double[],1
+rtf,addPageBreak,-1,0,0,double,1
+rtf,addPageBreak,0,0,0,...,1
+rtf,addPageBreak.RTF,-1,0,0,double,1
+rtf,addPageBreak.RTF,0,0,0,"class<`Object`, `RTF`>",1
+rtf,addPageBreak.RTF,1,0,0,double,1
+rtf,addPageBreak.RTF,2,0,0,double,1
+rtf,addPageBreak.RTF,3,0,0,double[],1
+rtf,addPageBreak.RTF,4,0,0,...,1
+rtf,.add.page.margins,-1,0,0,character,1
+rtf,.add.page.margins,0,0,0,double[],1
+rtf,.add.page.numbers,-1,0,0,character,1
+rtf,.add.paper.size,-1,0,0,character,1
+rtf,.add.paper.size,0,0,0,double,1
+rtf,.add.paper.size,1,0,0,double,1
+rtf,addParagraph,-1,0,0,character,1
+rtf,addParagraph,0,0,0,...,1
+rtf,addParagraph.RTF,-1,0,0,character,1
+rtf,addParagraph.RTF,0,0,0,"class<`Object`, `RTF`>",1
+rtf,addParagraph.RTF,1,0,0,...,1
+rtf,addPlot,-1,0,0,integer,1
+rtf,addPlot,0,0,0,...,1
+rtf,addPlot.RTF,-1,0,0,integer,1
+rtf,addPlot.RTF,0,0,0,"class<`Object`, `RTF`>",1
+rtf,addPlot.RTF,1,0,0,class<`function`>,1
+rtf,addPlot.RTF,2,0,0,double,1
+rtf,addPlot.RTF,3,0,0,double,1
+rtf,addPlot.RTF,4,0,0,double,1
+rtf,addPlot.RTF,5,0,0,...,1
+rtf,.add.png,-1,0,0,any,1
+rtf,.add.png,0,0,0,character,1
+rtf,.add.png,1,0,0,any,1
+rtf,.add.png,2,0,0,any,1
+rtf,.add.png,3,0,0,logical,1
+rtf,addSessionInfo,-1,0,0,double,1
+rtf,addSessionInfo,0,0,0,...,1
+rtf,addSessionInfo.RTF,-1,0,0,double,1
+rtf,addSessionInfo.RTF,0,0,0,"class<`Object`, `RTF`>",1
+rtf,addSessionInfo.RTF,1,0,0,logical,1
+rtf,addSessionInfo.RTF,2,0,0,...,1
+rtf,.add.table,-1,0,0,character,1
+rtf,.add.table,0,0,0,class<`data.frame`>,1
+rtf,.add.table,0,0,1,class<`table`>,1
+rtf,.add.table,1,0,0,double[],1
+rtf,.add.table,1,0,1,null,1
+rtf,.add.table,2,0,0,null,1
+rtf,.add.table,3,0,0,any,1
+rtf,.add.table,4,0,0,double,1
+rtf,.add.table,5,0,0,any,1
+rtf,.add.table,6,0,0,double,1
+rtf,.add.table,7,0,0,any,1
+rtf,.add.table,8,0,0,any,1
+rtf,.add.table,9,0,0,null,1
+rtf,.add.table,10,0,0,null,1
+rtf,addTable,-1,0,0,character,1
+rtf,addTable,0,0,0,...,1
+rtf,.add.table.header.row,-1,0,0,character,1
+rtf,.add.table.header.row,0,0,0,character[],1
+rtf,.add.table.header.row,1,0,0,double[],1
+rtf,.add.table.header.row,2,0,0,null,1
+rtf,.add.table.header.row,3,0,0,double,1
+rtf,.add.table.header.row,4,0,0,logical,1
+rtf,.add.table.header.row,5,0,0,double,1
+rtf,.add.table.row,-1,0,0,character,1
+rtf,.add.table.row,0,0,0,character[],1
+rtf,.add.table.row,1,0,0,double[],1
+rtf,.add.table.row,2,0,0,null,1
+rtf,.add.table.row,3,0,0,double,1
+rtf,.add.table.row,4,0,0,logical,1
+rtf,.add.table.row,5,0,0,double,1
+rtf,.add.table.row,6,0,0,logical,1
+rtf,.add.table.row,7,0,0,logical,1
+rtf,.add.table.row,8,0,0,null,1
+rtf,.add.table.row,9,0,0,null,1
+rtf,addTable.RTF,-1,0,0,character,1
+rtf,addTable.RTF,0,0,0,"class<`Object`, `RTF`>",1
+rtf,addTable.RTF,1,0,0,class<`data.frame`>,1
+rtf,addTable.RTF,1,0,1,class<`table`>,1
+rtf,addTable.RTF,2,0,0,double[],1
+rtf,addTable.RTF,2,0,1,null,1
+rtf,addTable.RTF,3,0,0,null,1
+rtf,addTable.RTF,4,0,0,null,1
+rtf,addTable.RTF,5,0,0,double,1
+rtf,addTable.RTF,6,0,0,logical,1
+rtf,addTable.RTF,7,0,0,character,1
+rtf,addTable.RTF,8,0,0,null,1
+rtf,addTable.RTF,9,0,0,null,1
+rtf,addTable.RTF,10,0,0,...,1
+rtf,.add.text,-1,0,0,character,1
+rtf,.add.text,0,0,0,character,1
+rtf,addText,-1,0,0,character,1
+rtf,addText,0,0,0,...,1
+rtf,addText.RTF,-1,0,0,character,1
+rtf,addText.RTF,0,0,0,"class<`Object`, `RTF`>",1
+rtf,addText.RTF,1,0,0,...,1
+rtf,addText.RTF,2,0,0,logical,1
+rtf,addText.RTF,3,0,0,logical,1
+rtf,addTrellisObject,-1,0,0,any,1
+rtf,addTrellisObject,0,0,0,...,1
+rtf,addTrellisObject.RTF,-1,0,0,any,1
+rtf,addTrellisObject.RTF,0,0,0,"class<`Object`, `RTF`>",1
+rtf,addTrellisObject.RTF,1,0,0,class<`trellis`>,1
+rtf,addTrellisObject.RTF,2,0,0,double,1
+rtf,addTrellisObject.RTF,3,0,0,double,1
+rtf,addTrellisObject.RTF,4,0,0,double,1
+rtf,addTrellisObject.RTF,5,0,0,null,1
+rtf,addTrellisObject.RTF,6,0,0,...,1
+rtf,.convert,-1,0,0,character[],1
+rtf,.convert,0,0,0,character[],1
+rtf,decreaseIndent,-1,0,0,double,1
+rtf,decreaseIndent,0,0,0,...,1
+rtf,decreaseIndent.RTF,-1,0,0,double,1
+rtf,decreaseIndent.RTF,0,0,0,"class<`Object`, `RTF`>",1
+rtf,decreaseIndent.RTF,1,0,0,...,1
+rtf,done,-1,0,0,null,1
+rtf,done,0,0,0,...,1
+rtf,done.RTF,-1,0,0,null,1
+rtf,done.RTF,0,0,0,"class<`Object`, `RTF`>",1
+rtf,done.RTF,1,0,0,...,1
+rtf,.end.paragraph,-1,0,0,character,1
+rtf,endParagraph,-1,0,0,character,1
+rtf,endParagraph,0,0,0,...,1
+rtf,endParagraph.RTF,-1,0,0,character,1
+rtf,endParagraph.RTF,0,0,0,"class<`Object`, `RTF`>",1
+rtf,endParagraph.RTF,1,0,0,...,1
+rtf,.end.rtf,-1,0,0,character,1
+rtf,.get.space.before.after,-1,0,0,character,1
+rtf,.get.space.before.after,0,0,0,null,1
+rtf,.get.space.before.after,1,0,0,null,1
+rtf,.get.TOC.level,-1,0,0,character,1
+rtf,.get.TOC.level,0,0,0,null,1
+rtf,increaseIndent,-1,0,0,double,1
+rtf,increaseIndent,0,0,0,...,1
+rtf,increaseIndent.RTF,-1,0,0,double,1
+rtf,increaseIndent.RTF,0,0,0,"class<`Object`, `RTF`>",1
+rtf,increaseIndent.RTF,1,0,0,...,1
+rtf,.max.col.nchar,-1,0,0,integer[],1
+rtf,.max.col.nchar,0,0,0,class<`data.frame`>,1
+rtf,.max.col.nchar,1,0,0,logical,1
+rtf,.max.col.nchar,2,0,0,logical,1
+rtf,.optimize.col.widths,-1,0,0,double[],1
+rtf,.optimize.col.widths,0,0,0,class<`data.frame`>,1
+rtf,.optimize.col.widths,1,0,0,logical,1
+rtf,.optimize.col.widths,2,0,0,double,1
+rtf,.optimize.col.widths,3,0,0,double,1
+rtf,.optimize.col.widths,4,0,0,double,1
+rtf,RTF,-1,0,0,"class<`Object`, `RTF`>",1
+rtf,RTF,0,0,0,character,1
+rtf,RTF,1,0,0,double,1
+rtf,RTF,2,0,0,double,1
+rtf,RTF,3,0,0,double[],1
+rtf,RTF,4,0,0,double,1
+rtf,.rtf.plot,-1,0,0,character,1
+rtf,.rtf.plot,0,0,0,class<`function`>,1
+rtf,.rtf.plot,1,0,0,character,1
+rtf,.rtf.plot,2,0,0,double,1
+rtf,.rtf.plot,3,0,0,double,1
+rtf,.rtf.plot,4,0,0,double,1
+rtf,.rtf.plot,5,0,0,...,1
+rtf,.rtf.trellis.object,-1,0,0,any,1
+rtf,.rtf.trellis.object,0,0,0,class<`trellis`>,1
+rtf,.rtf.trellis.object,1,0,0,character,1
+rtf,.rtf.trellis.object,2,0,0,double,1
+rtf,.rtf.trellis.object,3,0,0,double,1
+rtf,.rtf.trellis.object,4,0,0,double,1
+rtf,.rtf.trellis.object,5,0,0,null,1
+rtf,.rtf.trellis.object,6,0,0,...,1
+rtf,.start.paragraph,-1,0,0,character,1
+rtf,.start.paragraph,0,0,0,double,1
+rtf,.start.paragraph,1,0,0,double,1
+rtf,startParagraph,-1,0,0,character,1
+rtf,startParagraph,0,0,0,...,1
+rtf,startParagraph.RTF,-1,0,0,character,1
+rtf,startParagraph.RTF,0,0,0,"class<`Object`, `RTF`>",1
+rtf,startParagraph.RTF,1,0,0,...,1
+rtf,.start.rtf,-1,0,0,character,1
+rtf,.start.rtf,0,0,0,double,1
+rtf,.start.rtf,1,0,0,double,1
+rtf,.start.rtf,2,0,0,double[],1
+sampling,.as_int,-1,0,0,double,1
+sampling,.as_int,0,0,0,double,1
+sampling,balancedcluster,-1,0,0,class<`matrix`>,1
+sampling,balancedcluster,0,0,0,class<`matrix`>,1
+sampling,balancedcluster,1,0,0,double,1
+sampling,balancedcluster,2,0,0,double[],1
+sampling,balancedcluster,3,0,0,double,1
+sampling,balancedcluster,4,0,0,logical,1
+sampling,balancedcluster,5,0,0,double,1
+sampling,balancedstratification,-1,0,0,double[],1
+sampling,balancedstratification,0,0,0,class<`matrix`>,1
+sampling,balancedstratification,1,0,0,double[],1
+sampling,balancedstratification,2,0,0,double[],1
+sampling,balancedstratification,3,0,0,logical,1
+sampling,balancedstratification,4,0,0,double,1
+sampling,balancedtwostage,-1,0,0,class<`matrix`>,1
+sampling,balancedtwostage,0,0,0,class<`matrix`>,1
+sampling,balancedtwostage,1,0,0,double,1
+sampling,balancedtwostage,2,0,0,double,1
+sampling,balancedtwostage,3,0,0,double,1
+sampling,balancedtwostage,4,0,0,double[],1
+sampling,balancedtwostage,5,0,0,logical,1
+sampling,balancedtwostage,6,0,0,double,1
+sampling,calib,-1,0,0,double[],1
+sampling,calib,0,0,0,class<`matrix`>,1
+sampling,calib,1,0,0,double[],1
+sampling,calib,2,0,0,double[],1
+sampling,calib,3,0,0,double[],1
+sampling,calib,4,0,0,character,1
+sampling,calib,5,0,0,any,1
+sampling,calib,6,0,0,logical,1
+sampling,calib,7,0,0,double,1
+sampling,calibev,-1,0,0,list<double>,1
+sampling,calibev,0,0,0,double[],1
+sampling,calibev,1,0,0,class<`matrix`>,1
+sampling,calibev,2,0,0,double[],1
+sampling,calibev,3,0,0,class<`matrix`>,1
+sampling,calibev,4,0,0,double[],1
+sampling,calibev,5,0,0,double[],1
+sampling,calibev,6,0,0,double[],1
+sampling,calibev,7,0,0,logical,1
+sampling,calibev,8,0,0,double,1
+sampling,checkcalibration,-1,0,0,list<character | double>,1
+sampling,checkcalibration,0,0,0,class<`matrix`>,1
+sampling,checkcalibration,0,0,1,double[],1
+sampling,checkcalibration,1,0,0,double[],1
+sampling,checkcalibration,2,0,0,double[],1
+sampling,checkcalibration,3,0,0,double[],1
+sampling,checkcalibration,4,0,0,double,1
+sampling,cleanstrata,-1,0,0,integer[],1
+sampling,cleanstrata,0,0,0,double[],1
+sampling,cluster,-1,0,0,class<`data.frame`>,1
+sampling,cluster,0,0,0,class<`data.frame`>,1
+sampling,cluster,1,0,0,character,1
+sampling,cluster,2,0,0,double,1
+sampling,cluster,3,0,0,character,1
+sampling,cluster,4,0,0,any,1
+sampling,cluster,5,0,0,logical,1
+sampling,disjunctive,-1,0,0,class<`matrix`>,1
+sampling,disjunctive,0,0,0,double[],1
+sampling,fastflightcube,-1,0,0,double[],1
+sampling,fastflightcube,0,0,0,class<`matrix`>,1
+sampling,fastflightcube,1,0,0,double[],1
+sampling,fastflightcube,2,0,0,double,1
+sampling,fastflightcube,3,0,0,logical,1
+sampling,gencalib,-1,0,0,double[],1
+sampling,gencalib,0,0,0,class<`matrix`>,1
+sampling,gencalib,0,0,1,double[],1
+sampling,gencalib,1,0,0,class<`matrix`>,1
+sampling,gencalib,1,0,1,double[],1
+sampling,gencalib,2,0,0,double[],1
+sampling,gencalib,3,0,0,double[],1
+sampling,gencalib,4,0,0,double[],1
+sampling,gencalib,5,0,0,character,1
+sampling,gencalib,6,0,0,any,1
+sampling,gencalib,7,0,0,logical,1
+sampling,gencalib,8,0,0,double,1
+sampling,gencalib,9,0,0,double,1
+sampling,getdata,-1,0,0,class<`data.frame`>,1
+sampling,getdata,-1,0,1,list<class<`data.frame`>>,1
+sampling,getdata,0,0,0,class<`data.frame`>,1
+sampling,getdata,0,0,1,class<`factor`>,1
+sampling,getdata,1,0,0,class<`data.frame`>,1
+sampling,getdata,1,0,1,double[],1
+sampling,getdata,1,0,2,list<class<`data.frame`>>,1
+sampling,Hajekestimator,-1,0,0,class<`matrix`>,1
+sampling,Hajekestimator,0,0,0,double[],1
+sampling,Hajekestimator,1,0,0,double[],1
+sampling,Hajekestimator,2,0,0,integer,1
+sampling,Hajekestimator,2,0,1,null,1
+sampling,Hajekestimator,3,0,0,character,1
+sampling,Hajekstrata,-1,0,0,class<`matrix`>,1
+sampling,Hajekstrata,0,0,0,integer[],1
+sampling,Hajekstrata,1,0,0,double[],1
+sampling,Hajekstrata,2,0,0,integer[],1
+sampling,Hajekstrata,3,0,0,class<`table`>,1
+sampling,Hajekstrata,4,0,0,character,1
+sampling,Hajekstrata,5,0,0,logical,1
+sampling,HTestimator,-1,0,0,class<`matrix`>,1
+sampling,HTestimator,0,0,0,double[],1
+sampling,HTestimator,1,0,0,double[],1
+sampling,HTstrata,-1,0,0,class<`matrix`>,1
+sampling,HTstrata,0,0,0,integer[],1
+sampling,HTstrata,1,0,0,double[],1
+sampling,HTstrata,2,0,0,integer[],1
+sampling,HTstrata,3,0,0,logical,1
+sampling,inclusionprobabilities,-1,0,0,double[],1
+sampling,inclusionprobabilities,0,0,0,double[],1
+sampling,inclusionprobabilities,1,0,0,double,1
+sampling,inclusionprobastrata,-1,0,0,double[],1
+sampling,inclusionprobastrata,0,0,0,double[],1
+sampling,inclusionprobastrata,1,0,0,double[],1
+sampling,landingcube,-1,0,0,double[],1
+sampling,landingcube,0,0,0,class<`matrix`>,1
+sampling,landingcube,1,0,0,double[],1
+sampling,landingcube,2,0,0,double[],1
+sampling,landingcube,3,0,0,logical,1
+sampling,mstage,-1,0,0,list<class<`data.frame`>>,1
+sampling,mstage,0,0,0,class<`data.frame`>,1
+sampling,mstage,1,0,0,list<character>,1
+sampling,mstage,1,0,1,character[],1
+sampling,mstage,2,0,0,any,1
+sampling,mstage,3,0,0,list<class<`table`> | double[]>,1
+sampling,mstage,3,0,1,list<double[]>,1
+sampling,mstage,4,0,0,list<character>,1
+sampling,mstage,4,0,1,character[],1
+sampling,mstage,5,0,0,any,1
+sampling,mstage,6,0,0,logical,1
+sampling,postest,-1,0,0,double,1
+sampling,postest,0,0,0,class<`data.frame`>,1
+sampling,postest,1,0,0,double[],1
+sampling,postest,2,0,0,double[],1
+sampling,postest,3,0,0,double[],1
+sampling,postest,3,0,1,class<`matrix`>,1
+sampling,postest,4,0,0,logical,1
+sampling,poststrata,-1,0,0,list<class<`data.frame`> | integer>,1
+sampling,poststrata,0,0,0,class<`data.frame`>,1
+sampling,poststrata,1,0,0,character[],1
+sampling,ratioest,-1,0,0,double,1
+sampling,ratioest,0,0,0,double[],1
+sampling,ratioest,1,0,0,double[],1
+sampling,ratioest,2,0,0,double,1
+sampling,ratioest,3,0,0,double[],1
+sampling,ratioest_strata,-1,0,0,double,1
+sampling,ratioest_strata,0,0,0,double[],1
+sampling,ratioest_strata,1,0,0,double[],1
+sampling,ratioest_strata,2,0,0,double[],1
+sampling,ratioest_strata,3,0,0,double[],1
+sampling,ratioest_strata,4,0,0,integer[],1
+sampling,ratioest_strata,5,0,0,logical,1
+sampling,regest,-1,0,0,class<`regest`>,1
+sampling,regest,0,0,0,class<`formula`>,1
+sampling,regest,1,0,0,double,1
+sampling,regest,1,0,1,integer[],1
+sampling,regest,2,0,0,any,1
+sampling,regest,3,0,0,class<`matrix`>,1
+sampling,regest,4,0,0,double,1
+sampling,regest,5,0,0,double[],1
+sampling,regest_strata,-1,0,0,double,1
+sampling,regest_strata,0,0,0,any,1
+sampling,regest_strata,1,0,0,double[],1
+sampling,regest_strata,2,0,0,double[],1
+sampling,regest_strata,3,0,0,double[],1
+sampling,regest_strata,4,0,0,class<`matrix`>,1
+sampling,regest_strata,5,0,0,double[],1
+sampling,regest_strata,6,0,0,logical,1
+sampling,rhg,-1,0,0,class<`data.frame`>,1
+sampling,rhg,0,0,0,class<`data.frame`>,1
+sampling,rhg,1,0,0,character[],1
+sampling,rhg_strata,-1,0,0,class<`data.frame`>,1
+sampling,rhg_strata,0,0,0,class<`data.frame`>,1
+sampling,rhg_strata,1,0,0,character[],1
+sampling,rmodel,-1,0,0,class<`data.frame`>,1
+sampling,rmodel,0,0,0,any,1
+sampling,rmodel,1,0,0,any,1
+sampling,rmodel,2,0,0,class<`data.frame`>,1
+sampling,samplecube,-1,0,0,double[],1
+sampling,samplecube,0,0,0,class<`matrix`>,1
+sampling,samplecube,1,0,0,double[],1
+sampling,samplecube,2,0,0,double,1
+sampling,samplecube,3,0,0,logical,1
+sampling,samplecube,4,0,0,double,1
+sampling,srswor,-1,0,0,double[],1
+sampling,srswor,0,0,0,double,1
+sampling,srswor,1,0,0,double,1
+sampling,srswor1,-1,0,0,double[],1
+sampling,srswor1,0,0,0,double,1
+sampling,srswor1,1,0,0,double,1
+sampling,srswr,-1,0,0,integer[],1
+sampling,srswr,0,0,0,double,1
+sampling,srswr,1,0,0,double,1
+sampling,strata,-1,0,0,class<`data.frame`>,1
+sampling,strata,0,0,0,class<`data.frame`>,1
+sampling,strata,1,0,0,null,1
+sampling,strata,1,0,1,character[],1
+sampling,strata,2,0,0,double[],1
+sampling,strata,2,0,1,class<`table`>,1
+sampling,strata,3,0,0,character,1
+sampling,strata,4,0,0,any,1
+sampling,strata,5,0,0,logical,1
+sampling,UPbrewer,-1,0,0,double[],1
+sampling,UPbrewer,0,0,0,double[],1
+sampling,UPbrewer,1,0,0,double,1
+sampling,UPmaxentropy,-1,0,0,double[],1
+sampling,UPmaxentropy,0,0,0,double[],1
+sampling,UPmaxentropypi2,-1,0,0,class<`matrix`>,1
+sampling,UPmaxentropypi2,0,0,0,double[],1
+sampling,UPMEpik2frompikw,-1,0,0,class<`matrix`>,1
+sampling,UPMEpik2frompikw,0,0,0,double[],1
+sampling,UPMEpik2frompikw,1,0,0,double[],1
+sampling,UPMEpikfromq,-1,0,0,double[],1
+sampling,UPMEpikfromq,0,0,0,class<`matrix`>,1
+sampling,UPMEpiktildefrompik,-1,0,0,double[],1
+sampling,UPMEpiktildefrompik,0,0,0,double[],1
+sampling,UPMEpiktildefrompik,1,0,0,double,1
+sampling,UPMEqfromw,-1,0,0,class<`matrix`>,1
+sampling,UPMEqfromw,0,0,0,double[],1
+sampling,UPMEqfromw,1,0,0,double,1
+sampling,UPMEsfromq,-1,0,0,double[],1
+sampling,UPMEsfromq,0,0,0,class<`matrix`>,1
+sampling,UPmidzuno,-1,0,0,double[],1
+sampling,UPmidzuno,0,0,0,double[],1
+sampling,UPmidzuno,1,0,0,double,1
+sampling,UPmidzunopi2,-1,0,0,class<`matrix`>,1
+sampling,UPmidzunopi2,0,0,0,double[],1
+sampling,UPminimalsupport,-1,0,0,double[],1
+sampling,UPminimalsupport,0,0,0,double[],1
+sampling,UPmultinomial,-1,0,0,integer[],1
+sampling,UPmultinomial,0,0,0,double[],1
+sampling,UPopips,-1,0,0,integer[],1
+sampling,UPopips,0,0,0,double[],1
+sampling,UPopips,1,0,0,character,1
+sampling,UPpivotal,-1,0,0,double[],1
+sampling,UPpivotal,0,0,0,double[],1
+sampling,UPpivotal,1,0,0,double,1
+sampling,UPpoisson,-1,0,0,double[],1
+sampling,UPpoisson,0,0,0,double[],1
+sampling,UPrandompivotal,-1,0,0,double[],1
+sampling,UPrandompivotal,0,0,0,double[],1
+sampling,UPrandompivotal,1,0,0,double,1
+sampling,UPrandomsystematic,-1,0,0,double[],1
+sampling,UPrandomsystematic,0,0,0,double[],1
+sampling,UPrandomsystematic,1,0,0,double,1
+sampling,UPsampford,-1,0,0,double[],1
+sampling,UPsampford,0,0,0,double[],1
+sampling,UPsampford,1,0,0,double,1
+sampling,UPsampford,2,0,0,double,1
+sampling,UPsampfordpi2,-1,0,0,class<`matrix`>,1
+sampling,UPsampfordpi2,0,0,0,double[],1
+sampling,UPsystematic,-1,0,0,double[],1
+sampling,UPsystematic,0,0,0,double[],1
+sampling,UPsystematic,1,0,0,double,1
+sampling,UPsystematicpi2,-1,0,0,class<`matrix`>,1
+sampling,UPsystematicpi2,0,0,0,double[],1
+sampling,UPtille,-1,0,0,double[],1
+sampling,UPtille,0,0,0,double[],1
+sampling,UPtille,1,0,0,double,1
+sampling,UPtillepi2,-1,0,0,class<`matrix`>,1
+sampling,UPtillepi2,0,0,0,double[],1
+sampling,UPtillepi2,1,0,0,double,1
+sampling,varest,-1,0,0,double,1
+sampling,varest,0,0,0,double[],1
+sampling,varest,1,0,0,class<`matrix`>,1
+sampling,varest,1,0,1,null,1
+sampling,varest,2,0,0,double[],1
+sampling,varest,3,0,0,double[],1
+sampling,varest,3,0,1,null,1
+sampling,varHT,-1,0,0,double,1
+sampling,varHT,0,0,0,double[],1
+sampling,varHT,1,0,0,class<`matrix`>,1
+sampling,varHT,2,0,0,double,1
+sampling,vartaylor_ratio,-1,0,0,list<double>,1
+sampling,vartaylor_ratio,0,0,0,integer[],1
+sampling,vartaylor_ratio,1,0,0,integer[],1
+sampling,vartaylor_ratio,2,0,0,class<`matrix`>,1
+sampling,writesample,-1,0,0,class<`matrix`>,1
+sampling,writesample,-1,0,1,double,1
+sampling,writesample,0,0,0,double,1
+sampling,writesample,1,0,0,double,1
+scales,%||%,-1,0,0,double[],1
+scales,%||%,0,0,0,null,1
+scales,%||%,0,0,1,double,1
+scales,%||%,0,0,2,integer[],1
+scales,%||%,1,0,0,any,1
+scales,alpha,-1,0,0,character[],1
+scales,alpha,0,0,0,character[],1
+scales,alpha,1,0,0,double[],1
+scales,area_pal,-1,0,0,class<`function`>,1
+scales,area_pal,0,0,0,double[],1
+scales,asn_trans,-1,0,0,class<`trans`>,1
+scales,as.trans,-1,0,0,class<`trans`>,1
+scales,as.trans,0,0,0,character,1
+scales,as.trans,0,0,1,class<`trans`>,1
+scales,atanh_trans,-1,0,0,class<`trans`>,1
+scales,boxcox_trans,-1,0,0,class<`trans`>,1
+scales,boxcox_trans,0,0,0,double,1
+scales,boxcox_trans,1,0,0,double,1
+scales,breaks_extended,-1,0,0,class<`function`>,1
+scales,breaks_extended,0,0,0,double,1
+scales,breaks_extended,1,0,0,...,1
+scales,breaks_log,-1,0,0,class<`function`>,1
+scales,breaks_log,0,0,0,double,1
+scales,breaks_log,1,0,0,double,1
+scales,breaks_pretty,-1,0,0,class<`function`>,1
+scales,breaks_pretty,0,0,0,double,1
+scales,breaks_pretty,1,0,0,...,1
+scales,breaks_width,-1,0,0,class<`function`>,1
+scales,breaks_width,0,0,0,character,1
+scales,breaks_width,0,0,1,double,1
+scales,breaks_width,1,0,0,double,1
+scales,brewer_pal,-1,0,0,^character[],1
+scales,brewer_pal,0,0,0,double,1
+scales,brewer_pal,-1,1,0,class<`function`>,1
+scales,brewer_pal,0,1,0,character,1
+scales,brewer_pal,1,1,0,character,1
+scales,brewer_pal,1,1,1,double,1
+scales,brewer_pal,2,1,0,double,1
+scales,calcLevels,-1,0,0,character[],1
+scales,calcLevels,-1,0,1,integer[],1
+scales,calcLevels,0,0,0,character[],1
+scales,calcLevels,0,0,1,class<`factor`>,1
+scales,calcLevels,0,0,2,integer[],1
+scales,calcLevels,1,0,0,any,1
+scales,cbreaks,-1,0,0,list<double[] | character[]>,1
+scales,cbreaks,-1,0,1,list<double[] | expression>,1
+scales,cbreaks,-1,0,2,list<double[] | list<class<`name`>>>,1
+scales,cbreaks,0,0,0,double[],1
+scales,cbreaks,1,0,0,class<`function`>,1
+scales,cbreaks,1,0,1,double[],1
+scales,cbreaks,2,0,0,class<`function`>,1
+scales,cbreaks,2,0,1,double[],1
+scales,cbreaks,2,0,2,expression,1
+scales,censor,-1,0,0,^double[],1
+scales,censor,0,0,0,^double[],1
+scales,censor,1,0,0,double[],1
+scales,censor,2,0,0,logical,1
+scales,clevels,-1,0,0,character[],1
+scales,clevels,0,0,0,class<`factor`>,1
+scales,clevels,1,0,0,logical,1
+scales,clevels,2,0,0,logical,1
+scales,col2hcl,-1,0,0,character[],1
+scales,col2hcl,0,0,0,character[],1
+scales,col2hcl,1,0,0,double[],1
+scales,col2hcl,1,0,1,null,1
+scales,col2hcl,2,0,0,null,1
+scales,col2hcl,2,0,1,double[],1
+scales,col2hcl,3,0,0,null,1
+scales,col2hcl,3,0,1,double[],1
+scales,col2hcl,4,0,0,null,1
+scales,col2hcl,4,0,1,double[],1
+scales,col_bin,-1,0,0,character[],1
+scales,col_bin,0,0,0,double[],1
+scales,col_bin,-1,1,0,class<`function`>,1
+scales,col_bin,0,1,0,character,1
+scales,col_bin,1,1,0,integer[],1
+scales,col_bin,1,1,1,null,1
+scales,col_bin,2,1,0,double,1
+scales,col_bin,3,1,0,logical,1
+scales,col_bin,4,1,0,character,1
+scales,col_bin,5,1,0,logical,1
+scales,col_bin,6,1,0,logical,1
+scales,col_bin,7,1,0,logical,1
+scales,col_factor,-1,0,0,class<`function`>,1
+scales,col_factor,0,0,0,character,1
+scales,col_factor,1,0,0,any,1
+scales,col_factor,2,0,0,null,1
+scales,col_factor,2,0,1,character[],1
+scales,col_factor,3,0,0,logical,1
+scales,col_factor,4,0,0,character,1
+scales,col_factor,5,0,0,any,1
+scales,col_factor,6,0,0,any,1
+scales,col_factor,-1,1,0,character[],1
+scales,col_factor,0,1,0,character[],1
+scales,col_factor,0,1,1,class<`factor`>,1
+scales,col_factor,0,1,2,integer[],1
+scales,col_numeric,-1,0,0,class<`function`>,1
+scales,col_numeric,0,0,0,character,1
+scales,col_numeric,1,0,0,null,1
+scales,col_numeric,2,0,0,character,1
+scales,col_numeric,3,0,0,logical,1
+scales,col_numeric,4,0,0,logical,1
+scales,col_numeric,-1,1,0,character[],1
+scales,col_numeric,0,1,0,double[],1
+scales,colour_ramp,-1,0,0,class<`function`>,1
+scales,colour_ramp,0,0,0,character[],1
+scales,colour_ramp,1,0,0,null,1
+scales,colour_ramp,2,0,0,logical,1
+scales,col_quantile,-1,0,0,character[],1
+scales,col_quantile,0,0,0,double[],1
+scales,col_quantile,-1,1,0,class<`function`>,1
+scales,col_quantile,0,1,0,character,1
+scales,col_quantile,1,1,0,null,1
+scales,col_quantile,2,1,0,double,1
+scales,col_quantile,3,1,0,double[],1
+scales,col_quantile,4,1,0,character,1
+scales,col_quantile,5,1,0,logical,1
+scales,col_quantile,6,1,0,logical,1
+scales,col_quantile,7,1,0,logical,1
+scales,comma_format,-1,0,0,class<`function`>,1
+scales,comma_format,0,0,0,null,1
+scales,comma_format,1,0,0,double,1
+scales,comma_format,2,0,0,character,1
+scales,comma_format,3,0,0,character,1
+scales,comma_format,4,0,0,character,1
+scales,comma_format,5,0,0,character,1
+scales,comma_format,6,0,0,logical,1
+scales,comma_format,7,0,0,any,1
+scales,comma_format,8,0,0,...,1
+scales,cscale,-1,0,0,character[],1
+scales,cscale,-1,0,1,double[],1
+scales,cscale,0,0,0,double[],1
+scales,cscale,1,0,0,class<`function`>,1
+scales,cscale,2,0,0,null,1
+scales,cscale,3,0,0,class<`trans`>,1
+scales,date_breaks,-1,0,0,class<`function`>,1
+scales,date_breaks,0,0,0,character,1
+scales,date_format,-1,0,0,class<`function`>,1
+scales,date_format,0,0,0,character,1
+scales,date_format,1,0,0,character,1
+scales,date_trans,-1,0,0,class<`trans`>,1
+scales,demo_continuous,-1,0,0,"class<`gg`, `ggplot`>",1
+scales,demo_continuous,0,0,0,double[],1
+scales,demo_continuous,1,0,0,...,1
+scales,demo_datetime,-1,0,0,"class<`gg`, `ggplot`>",1
+scales,demo_datetime,0,0,0,"class<`POSIXct`, `POSIXt`>",1
+scales,demo_datetime,1,0,0,...,1
+scales,demo_discrete,-1,0,0,"class<`gg`, `ggplot`>",1
+scales,demo_discrete,0,0,0,character[],1
+scales,demo_discrete,1,0,0,...,1
+scales,demo_ggplot,-1,0,0,"class<`gg`, `ggplot`>",1
+scales,demo_ggplot,0,0,0,character[],1
+scales,demo_ggplot,0,0,1,"class<`POSIXct`, `POSIXt`>",1
+scales,demo_ggplot,0,0,2,double[],1
+scales,demo_ggplot,1,0,0,character,1
+scales,demo_ggplot,2,0,0,...,1
+scales,demo_log10,-1,0,0,"class<`gg`, `ggplot`>",1
+scales,demo_log10,0,0,0,double[],1
+scales,demo_log10,1,0,0,...,1
+scales,dichromat_pal,-1,0,0,class<`function`>,1
+scales,dichromat_pal,0,0,0,character,1
+scales,dichromat_pal,-1,1,0,character[],1
+scales,dichromat_pal,0,1,0,double,1
+scales,discrete_range,-1,0,0,character[],1
+scales,discrete_range,0,0,0,null,1
+scales,discrete_range,1,0,0,class<`factor`>,1
+scales,discrete_range,2,0,0,logical,1
+scales,discrete_range,3,0,0,logical,1
+scales,div_gradient_pal,-1,0,0,character[],1
+scales,div_gradient_pal,0,0,0,double[],1
+scales,div_gradient_pal,-1,1,0,class<`function`>,1
+scales,div_gradient_pal,0,1,0,character,1
+scales,div_gradient_pal,1,1,0,character,1
+scales,div_gradient_pal,2,1,0,character,1
+scales,div_gradient_pal,3,1,0,character,1
+scales,dollar,-1,0,0,character[],1
+scales,dollar,0,0,0,double[],1
+scales,dollar,1,0,0,null,1
+scales,dollar,2,0,0,double,1
+scales,dollar,3,0,0,character,1
+scales,dollar,4,0,0,character,1
+scales,dollar,5,0,0,character,1
+scales,dollar,6,0,0,character,1
+scales,dollar,7,0,0,logical,1
+scales,dollar,8,0,0,double,1
+scales,dollar,9,0,0,logical,1
+scales,dollar,10,0,0,...,1
+scales,dollar_format,-1,0,0,class<`function`>,1
+scales,dollar_format,0,0,0,null,1
+scales,dollar_format,1,0,0,double,1
+scales,dollar_format,2,0,0,character,1
+scales,dollar_format,3,0,0,character,1
+scales,dollar_format,4,0,0,character,1
+scales,dollar_format,5,0,0,character,1
+scales,dollar_format,6,0,0,logical,1
+scales,dollar_format,7,0,0,double,1
+scales,dollar_format,8,0,0,logical,1
+scales,dollar_format,9,0,0,...,1
+scales,dscale,-1,0,0,character[],1
+scales,dscale,0,0,0,class<`factor`>,1
+scales,dscale,1,0,0,class<`function`>,1
+scales,dscale,2,0,0,null,1
+scales,extended_breaks,-1,0,0,class<`function`>,1
+scales,extended_breaks,0,0,0,double,1
+scales,extended_breaks,1,0,0,...,1
+scales,extended_breaks,-1,1,0,double[],1
+scales,extended_breaks,0,1,0,double[],1
+scales,extended_breaks,1,1,0,double,1
+scales,filterNA,-1,0,0,class<`function`>,1
+scales,filterNA,0,0,0,class<`function`>,1
+scales,filterNA,1,0,0,any,1
+scales,filterRange,-1,0,0,class<`function`>,1
+scales,filterRange,0,0,0,class<`function`>,1
+scales,filterRGB,-1,0,0,class<`function`>,1
+scales,filterRGB,0,0,0,class<`function`>,1
+scales,filterZeroLength,-1,0,0,class<`function`>,1
+scales,filterZeroLength,0,0,0,class<`function`>,1
+scales,force_all,-1,0,0,list<any>,1
+scales,force_all,0,0,0,...,1
+scales,format_format,-1,0,0,class<`function`>,1
+scales,format_format,0,0,0,...,1
+scales,getBins,-1,0,0,double[],1
+scales,getBins,0,0,0,integer[],1
+scales,getBins,0,0,1,null,1
+scales,getBins,1,0,0,any,1
+scales,getBins,2,0,0,double[],1
+scales,getBins,3,0,0,any,1
+scales,getLevels,-1,0,0,character[],1
+scales,getLevels,-1,0,1,integer[],1
+scales,getLevels,-1,0,2,null,1
+scales,getLevels,0,0,0,any,1
+scales,getLevels,1,0,0,any,1
+scales,getLevels,2,0,0,character[],1
+scales,getLevels,2,0,1,null,1
+scales,getLevels,2,0,2,integer[],1
+scales,getLevels,3,0,0,any,1
+scales,gradient_n_pal,-1,0,0,character[],1
+scales,gradient_n_pal,0,0,0,double[],1
+scales,gradient_n_pal,-1,1,0,class<`function`>,1
+scales,gradient_n_pal,0,1,0,character[],1
+scales,gradient_n_pal,1,1,0,null,1
+scales,gradient_n_pal,2,1,0,character,1
+scales,grey_pal,-1,0,0,character[],1
+scales,grey_pal,0,0,0,double,1
+scales,grey_pal,-1,1,0,class<`function`>,1
+scales,grey_pal,0,1,0,double,1
+scales,grey_pal,1,1,0,double,1
+scales,hms_trans,-1,0,0,class<`trans`>,1
+scales,hue_pal,-1,0,0,class<`function`>,1
+scales,hue_pal,0,0,0,double[],1
+scales,hue_pal,1,0,0,double,1
+scales,hue_pal,2,0,0,double,1
+scales,hue_pal,3,0,0,double,1
+scales,hue_pal,4,0,0,double,1
+scales,hue_pal,-1,1,0,character[],1
+scales,hue_pal,0,1,0,double,1
+scales,identity_trans,-1,0,0,class<`trans`>,1
+scales,is.discrete,-1,0,0,logical,1
+scales,is.discrete,0,0,0,class<`factor`>,1
+scales,is.trans,-1,0,0,logical,1
+scales,is.trans,0,0,0,character,1
+scales,is.trans,0,0,1,class<`trans`>,1
+scales,label_bytes,-1,0,0,class<`function`>,1
+scales,label_bytes,0,0,0,character,1
+scales,label_bytes,1,0,0,double,1
+scales,label_bytes,2,0,0,...,1
+scales,label_comma,-1,0,0,class<`function`>,1
+scales,label_comma,0,0,0,null,1
+scales,label_comma,1,0,0,double,1
+scales,label_comma,2,0,0,character,1
+scales,label_comma,3,0,0,character,1
+scales,label_comma,4,0,0,character,1
+scales,label_comma,5,0,0,character,1
+scales,label_comma,6,0,0,logical,1
+scales,label_comma,7,0,0,any,1
+scales,label_comma,8,0,0,...,1
+scales,label_date_short,-1,0,0,class<`function`>,1
+scales,label_date_short,0,0,0,character[],1
+scales,label_date_short,1,0,0,character,1
+scales,label_dollar,-1,0,0,class<`function`>,1
+scales,label_dollar,0,0,0,null,1
+scales,label_dollar,1,0,0,double,1
+scales,label_dollar,2,0,0,character,1
+scales,label_dollar,3,0,0,character,1
+scales,label_dollar,4,0,0,character,1
+scales,label_dollar,5,0,0,character,1
+scales,label_dollar,6,0,0,logical,1
+scales,label_dollar,7,0,0,double,1
+scales,label_dollar,8,0,0,logical,1
+scales,label_dollar,9,0,0,...,1
+scales,label_math,-1,0,0,class<`function`>,1
+scales,label_math,0,0,0,any,1
+scales,label_math,1,0,0,any,1
+scales,label_number,-1,0,0,class<`function`>,1
+scales,label_number,0,0,0,null,1
+scales,label_number,1,0,0,double,1
+scales,label_number,2,0,0,character,1
+scales,label_number,3,0,0,character,1
+scales,label_number,4,0,0,character,1
+scales,label_number,5,0,0,character,1
+scales,label_number,6,0,0,logical,1
+scales,label_number,7,0,0,...,1
+scales,label_number_auto,-1,0,0,class<`function`>,1
+scales,label_number_si,-1,0,0,class<`function`>,1
+scales,label_number_si,0,0,0,double,1
+scales,label_number_si,1,0,0,character,1
+scales,label_number_si,1,0,1,null,1
+scales,label_number_si,2,0,0,null,1
+scales,label_number_si,3,0,0,...,1
+scales,label_ordinal,-1,0,0,class<`function`>,1
+scales,label_ordinal,0,0,0,character,1
+scales,label_ordinal,1,0,0,character,1
+scales,label_ordinal,2,0,0,character,1
+scales,label_ordinal,3,0,0,list<character>,1
+scales,label_ordinal,4,0,0,...,1
+scales,label_parse,-1,0,0,class<`function`>,1
+scales,label_percent,-1,0,0,class<`function`>,1
+scales,label_percent,0,0,0,null,1
+scales,label_percent,1,0,0,double,1
+scales,label_percent,2,0,0,character,1
+scales,label_percent,3,0,0,character,1
+scales,label_percent,4,0,0,character,1
+scales,label_percent,5,0,0,character,1
+scales,label_percent,6,0,0,logical,1
+scales,label_percent,7,0,0,...,1
+scales,label_pvalue,-1,0,0,class<`function`>,1
+scales,label_pvalue,0,0,0,double,1
+scales,label_pvalue,1,0,0,character,1
+scales,label_pvalue,2,0,0,any,1
+scales,label_pvalue,3,0,0,logical,1
+scales,label_scientific,-1,0,0,class<`function`>,1
+scales,label_scientific,0,0,0,double,1
+scales,label_scientific,1,0,0,double,1
+scales,label_scientific,2,0,0,character,1
+scales,label_scientific,3,0,0,character,1
+scales,label_scientific,4,0,0,character,1
+scales,label_scientific,5,0,0,logical,1
+scales,label_scientific,6,0,0,...,1
+scales,label_wrap,-1,0,0,class<`function`>,1
+scales,label_wrap,0,0,0,double,1
+scales,lines.trans,-1,0,0,null,1
+scales,lines.trans,0,0,0,class<`trans`>,1
+scales,lines.trans,1,0,0,...,1
+scales,lines.trans,2,0,0,double[],1
+scales,log10_trans,-1,0,0,class<`trans`>,1
+scales,log1p_trans,-1,0,0,class<`trans`>,1
+scales,log2_trans,-1,0,0,class<`trans`>,1
+scales,log_breaks,-1,0,0,class<`function`>,1
+scales,log_breaks,0,0,0,double,1
+scales,log_breaks,1,0,0,double,1
+scales,logit_trans,-1,0,0,class<`trans`>,1
+scales,log_trans,-1,0,0,class<`trans`>,1
+scales,log_trans,0,0,0,double,1
+scales,map_continuous,-1,0,0,character[],1
+scales,map_continuous,-1,0,1,double[],1
+scales,map_continuous,0,0,0,class<`function`>,1
+scales,map_continuous,1,0,0,double[],1
+scales,map_continuous,2,0,0,double[],1
+scales,map_continuous,3,0,0,any,1
+scales,map_continuous,4,0,0,class<`function`>,1
+scales,map_discrete,-1,0,0,character[],1
+scales,map_discrete,0,0,0,class<`function`>,1
+scales,map_discrete,1,0,0,class<`factor`>,1
+scales,map_discrete,2,0,0,character[],1
+scales,map_discrete,3,0,0,any,1
+scales,math_format,-1,0,0,class<`function`>,1
+scales,math_format,0,0,0,any,1
+scales,math_format,1,0,0,any,1
+scales,modulus_trans,-1,0,0,class<`trans`>,1
+scales,modulus_trans,0,0,0,double,1
+scales,modulus_trans,1,0,0,double,1
+scales,muted,-1,0,0,character,1
+scales,muted,0,0,0,character,1
+scales,muted,1,0,0,double,1
+scales,muted,2,0,0,double,1
+scales,needs_cents,-1,0,0,logical,1
+scales,needs_cents,0,0,0,double[],1
+scales,needs_cents,1,0,0,double,1
+scales,number,-1,0,0,character[],1
+scales,number,0,0,0,double[],1
+scales,number,1,0,0,double,1
+scales,number,1,0,1,null,1
+scales,number,2,0,0,double,1
+scales,number,3,0,0,character,1
+scales,number,4,0,0,character,1
+scales,number,5,0,0,character,1
+scales,number,6,0,0,character,1
+scales,number,7,0,0,logical,1
+scales,number,8,0,0,...,1
+scales,number_format,-1,0,0,class<`function`>,1
+scales,number_format,0,0,0,null,1
+scales,number_format,1,0,0,double,1
+scales,number_format,2,0,0,character,1
+scales,number_format,3,0,0,character,1
+scales,number_format,4,0,0,character,1
+scales,number_format,5,0,0,character,1
+scales,number_format,6,0,0,logical,1
+scales,number_format,7,0,0,...,1
+scales,ordinal_english,-1,0,0,list<character>,1
+scales,ordinal_french,-1,0,0,list<character>,1
+scales,pal_name,-1,0,0,character,1
+scales,pal_name,0,0,0,character,1
+scales,pal_name,0,0,1,double,1
+scales,pal_name,1,0,0,any,1
+scales,percent_format,-1,0,0,class<`function`>,1
+scales,percent_format,0,0,0,null,1
+scales,percent_format,1,0,0,double,1
+scales,percent_format,2,0,0,character,1
+scales,percent_format,3,0,0,character,1
+scales,percent_format,4,0,0,character,1
+scales,percent_format,5,0,0,character,1
+scales,percent_format,6,0,0,logical,1
+scales,percent_format,7,0,0,...,1
+scales,plot.trans,-1,0,0,null,1
+scales,plot.trans,0,0,0,class<`trans`>,1
+scales,plot.trans,1,0,0,any,1
+scales,plot.trans,2,0,0,...,1
+scales,plot.trans,3,0,0,double[],1
+scales,plot.trans,4,0,0,null,1
+scales,precision,-1,0,0,double,1
+scales,precision,0,0,0,double[],1
+scales,probability_trans,-1,0,0,class<`trans`>,1
+scales,probability_trans,0,0,0,character,1
+scales,probability_trans,1,0,0,...,1
+scales,probit_trans,-1,0,0,class<`trans`>,1
+scales,pseudo_log_trans,-1,0,0,class<`trans`>,1
+scales,pseudo_log_trans,0,0,0,double,1
+scales,pseudo_log_trans,1,0,0,any,1
+scales,reciprocal_trans,-1,0,0,class<`trans`>,1
+scales,regular_minor_breaks,-1,0,0,double[],1
+scales,regular_minor_breaks,0,0,0,double[],1
+scales,regular_minor_breaks,1,0,0,double[],1
+scales,regular_minor_breaks,2,0,0,double,1
+scales,regular_minor_breaks,-1,1,0,class<`function`>,1
+scales,regular_minor_breaks,0,1,0,logical,1
+scales,rescale,-1,0,0,double[],1
+scales,rescale,0,0,0,double[],1
+scales,rescale,1,0,0,any,1
+scales,rescale,2,0,0,any,1
+scales,rescale,3,0,0,...,1
+scales,rescale_max,-1,0,0,double[],1
+scales,rescale_max,0,0,0,double[],1
+scales,rescale_max,1,0,0,double[],1
+scales,rescale_max,2,0,0,double[],1
+scales,rescale_mid,-1,0,0,double[],1
+scales,rescale_mid,0,0,0,double[],1
+scales,rescale_mid,1,0,0,any,1
+scales,rescale_mid,2,0,0,any,1
+scales,rescale_mid,3,0,0,any,1
+scales,rescale_mid,4,0,0,...,1
+scales,rescale_mid.numeric,-1,0,0,double[],1
+scales,rescale_mid.numeric,0,0,0,double[],1
+scales,rescale_mid.numeric,1,0,0,double[],1
+scales,rescale_mid.numeric,2,0,0,double[],1
+scales,rescale_mid.numeric,3,0,0,double,1
+scales,rescale_mid.numeric,4,0,0,...,1
+scales,rescale_none,-1,0,0,integer[],1
+scales,rescale_none,0,0,0,integer[],1
+scales,rescale_none,1,0,0,...,1
+scales,rescale.numeric,-1,0,0,double[],1
+scales,rescale.numeric,0,0,0,double[],1
+scales,rescale.numeric,1,0,0,double[],1
+scales,rescale.numeric,2,0,0,double[],1
+scales,rescale.numeric,3,0,0,...,1
+scales,rescale_pal,-1,0,0,class<`function`>,1
+scales,rescale_pal,0,0,0,double[],1
+scales,reverse_trans,-1,0,0,class<`trans`>,1
+scales,round_any,-1,0,0,double[],1
+scales,round_any,0,0,0,double[],1
+scales,round_any,1,0,0,double,1
+scales,round_any,2,0,0,any,1
+scales,round_any.numeric,-1,0,0,double[],1
+scales,round_any.numeric,0,0,0,double[],1
+scales,round_any.numeric,1,0,0,double,1
+scales,round_any.numeric,2,0,0,class<`function`>,1
+scales,safePaletteFunc,-1,0,0,class<`function`>,1
+scales,safePaletteFunc,0,0,0,character,1
+scales,safePaletteFunc,1,0,0,any,1
+scales,safePaletteFunc,2,0,0,logical,1
+scales,safePaletteFunc,3,0,0,double,1
+scales,safePaletteFunc,3,0,1,null,1
+scales,scientific,-1,0,0,character[],1
+scales,scientific,0,0,0,double[],1
+scales,scientific,1,0,0,double,1
+scales,scientific,2,0,0,double,1
+scales,scientific,3,0,0,character,1
+scales,scientific,4,0,0,character,1
+scales,scientific,5,0,0,character,1
+scales,scientific,6,0,0,logical,1
+scales,scientific,7,0,0,...,1
+scales,scientific_format,-1,0,0,class<`function`>,1
+scales,scientific_format,0,0,0,double,1
+scales,scientific_format,1,0,0,double,1
+scales,scientific_format,2,0,0,character,1
+scales,scientific_format,3,0,0,character,1
+scales,scientific_format,4,0,0,character,1
+scales,scientific_format,5,0,0,logical,1
+scales,scientific_format,6,0,0,...,1
+scales,seq_gradient_pal,-1,0,0,character[],1
+scales,seq_gradient_pal,0,0,0,double[],1
+scales,seq_gradient_pal,-1,1,0,class<`function`>,1
+scales,seq_gradient_pal,0,1,0,character,1
+scales,seq_gradient_pal,1,1,0,character,1
+scales,seq_gradient_pal,2,1,0,character,1
+scales,show_col,-1,0,0,null,1
+scales,show_col,0,0,0,^character[],1
+scales,show_col,1,0,0,logical,1
+scales,show_col,2,0,0,null,1
+scales,show_col,3,0,0,double,1
+scales,sqrt_trans,-1,0,0,class<`trans`>,1
+scales,squish,-1,0,0,^double[],1
+scales,squish,0,0,0,^double[],1
+scales,squish,1,0,0,double[],1
+scales,squish,2,0,0,logical,1
+scales,squish_infinite,-1,0,0,double[],1
+scales,squish_infinite,0,0,0,double[],1
+scales,squish_infinite,1,0,0,double[],1
+scales,time_breaks,-1,0,0,class<`function`>,1
+scales,time_breaks,0,0,0,double,1
+scales,time_trans,-1,0,0,class<`trans`>,1
+scales,time_trans,0,0,0,null,1
+scales,toPaletteFunc,-1,0,0,class<`function`>,1
+scales,toPaletteFunc,0,0,0,character,1
+scales,toPaletteFunc,1,0,0,logical,1
+scales,toPaletteFunc,2,0,0,double,1
+scales,toPaletteFunc,2,0,1,null,1
+scales,toPaletteFunc.character,-1,0,0,class<`function`>,1
+scales,toPaletteFunc.character,0,0,0,character,1
+scales,toPaletteFunc.character,1,0,0,logical,1
+scales,toPaletteFunc.character,2,0,0,double,1
+scales,toPaletteFunc.character,2,0,1,null,1
+scales,train_continuous,-1,0,0,double[],1
+scales,train_continuous,0,0,0,double[],1
+scales,train_continuous,1,0,0,null,1
+scales,train_discrete,-1,0,0,character[],1
+scales,train_discrete,0,0,0,class<`factor`>,1
+scales,train_discrete,1,0,0,null,1
+scales,train_discrete,2,0,0,logical,1
+scales,train_discrete,3,0,0,logical,1
+scales,trans_breaks,-1,0,0,double[],1
+scales,trans_breaks,0,0,0,double[],1
+scales,trans_breaks,1,0,0,double,1
+scales,trans_breaks,-1,1,0,class<`function`>,1
+scales,trans_breaks,0,1,0,character,1
+scales,trans_breaks,0,1,1,class<`function`>,1
+scales,trans_breaks,1,1,0,class<`function`>,1
+scales,trans_breaks,2,1,0,double,1
+scales,trans_breaks,3,1,0,...,1
+scales,trans_format,-1,0,0,class<`function`>,1
+scales,trans_format,0,0,0,character,1
+scales,trans_format,1,0,0,class<`function`>,1
+scales,trans_new,-1,0,0,class<`trans`>,1
+scales,trans_new,0,0,0,character,1
+scales,trans_new,1,0,0,character,1
+scales,trans_new,1,0,1,class<`function`>,1
+scales,trans_new,2,0,0,character,1
+scales,trans_new,2,0,1,class<`function`>,1
+scales,trans_new,3,0,0,class<`function`>,1
+scales,trans_new,4,0,0,class<`function`>,1
+scales,trans_new,5,0,0,class<`function`>,1
+scales,trans_new,6,0,0,double[],1
+scales,trans_two_sided,-1,0,0,double[],1
+scales,trans_two_sided,0,0,0,double[],1
+scales,trans_two_sided,1,0,0,class<`function`>,1
+scales,trans_two_sided,2,0,0,class<`function`>,1
+scales,unit_format,-1,0,0,class<`function`>,1
+scales,unit_format,0,0,0,null,1
+scales,unit_format,1,0,0,double,1
+scales,unit_format,2,0,0,character,1
+scales,unit_format,3,0,0,character,1
+scales,unit_format,4,0,0,character,1
+scales,unit_format,5,0,0,character,1
+scales,unit_format,6,0,0,character,1
+scales,unit_format,7,0,0,character,1
+scales,unit_format,8,0,0,logical,1
+scales,unit_format,9,0,0,...,1
+scales,viridis_pal,-1,0,0,class<`function`>,1
+scales,viridis_pal,0,0,0,double,1
+scales,viridis_pal,1,0,0,double,1
+scales,viridis_pal,2,0,0,double,1
+scales,viridis_pal,3,0,0,double,1
+scales,viridis_pal,4,0,0,character,1
+scales,viridis_pal,-1,1,0,character[],1
+scales,viridis_pal,0,1,0,double,1
+scales,withColorAttr,-1,0,0,class<`function`>,1
+scales,withColorAttr,0,0,0,character,1
+scales,withColorAttr,1,0,0,list<double[] | character>,1
+scales,withColorAttr,1,0,1,list<double | character>,1
+scales,withColorAttr,1,0,2,list<character>,1
+scales,withColorAttr,2,0,0,class<`function`>,1
+scales,yj_trans,-1,0,0,class<`trans`>,1
+scales,yj_trans,0,0,0,double,1
+scales,zero_range,-1,0,0,logical,1
+scales,zero_range,-1,0,1,null,1
+scales,zero_range,0,0,0,^double[],1
+scales,zero_range,1,0,0,any,1
+selectr,css_to_xpath,-1,0,0,character,1
+selectr,css_to_xpath,0,0,0,character,1
+selectr,css_to_xpath,1,0,0,character,1
+selectr,css_to_xpath,2,0,0,character,1
+selectr,first_class_name,-1,0,0,character,1
+selectr,first_class_name,0,0,0,"class<`ClassSelector`, `R6`>",1
+selectr,first_class_name,0,0,1,"class<`CombinedSelector`, `R6`>",1
+selectr,first_class_name,0,0,2,"class<`Element`, `R6`>",1
+selectr,first_class_name,0,0,3,"class<`Hash`, `R6`>",1
+selectr,first_class_name,0,0,4,"class<`Pseudo`, `R6`>",1
+selectr,first_class_name,0,0,5,"class<`R6`, `Selector`>",1
+selectr,formatNS,-1,0,0,character[],1
+selectr,formatNS,0,0,0,character[],1
+selectr,formatNSPrefix,-1,0,0,character,1
+selectr,formatNSPrefix,0,0,0,character[],1
+selectr,formatNSPrefix,1,0,0,character,1
+selectr,is_safe_name,-1,0,0,logical,1
+selectr,is_safe_name,0,0,0,character,1
+selectr,match_hash,-1,0,0,^integer[],1
+selectr,match_hash,0,0,0,character,1
+selectr,match_ident,-1,0,0,^integer[],1
+selectr,match_ident,0,0,0,character,1
+selectr,match_number,-1,0,0,^integer[],1
+selectr,match_number,0,0,0,character,1
+selectr,match_whitespace,-1,0,0,^integer[],1
+selectr,match_whitespace,0,0,0,character,1
+selectr,parse,-1,0,0,"list<class<`R6`, `Selector`>>",1
+selectr,parse,0,0,0,character,1
+selectr,parse_selector,-1,0,0,"list<class<`ClassSelector`, `R6`> | null>",1
+selectr,parse_selector,-1,0,1,"list<class<`CombinedSelector`, `R6`> | null>",1
+selectr,parse_selector,-1,0,2,"list<class<`Element`, `R6`> | null>",1
+selectr,parse_selector,-1,0,3,"list<class<`Pseudo`, `R6`> | null>",1
+selectr,parse_selector,0,0,0,"class<`R6`, `TokenStream`>",1
+selectr,parse_selector_group,-1,0,0,"list<class<`R6`, `Selector`>>",1
+selectr,parse_selector_group,0,0,0,"class<`R6`, `TokenStream`>",1
+selectr,parse_simple_selector,-1,0,0,"list<class<`ClassSelector`, `R6`> | null>",1
+selectr,parse_simple_selector,-1,0,1,"list<class<`Element`, `R6`> | null>",1
+selectr,parse_simple_selector,-1,0,2,"list<class<`Hash`, `R6`> | null>",1
+selectr,parse_simple_selector,-1,0,3,"list<class<`Pseudo`, `R6`> | null>",1
+selectr,parse_simple_selector,0,0,0,"class<`R6`, `TokenStream`>",1
+selectr,parse_simple_selector,1,0,0,logical,1
+selectr,querySelector,-1,0,0,"class<`XMLAbstractNode`, `XMLInternalElementNode`, `XMLInternalNode`>",1
+selectr,querySelector,-1,0,1,class<`xml_node`>,1
+selectr,querySelector,-1,0,2,null,1
+selectr,querySelector,0,0,0,"class<`XMLAbstractDocument`, `XMLInternalDocument`>",1
+selectr,querySelector,0,0,1,"class<`xml_document`, `xml_node`>",1
+selectr,querySelector,1,0,0,character,1
+selectr,querySelector,2,0,0,character,1
+selectr,querySelector,2,0,1,null,1
+selectr,querySelector,3,0,0,...,1
+selectr,querySelectorAll,-1,0,0,class<`xml_nodeset`>,1
+selectr,querySelectorAll,-1,0,1,class<`XMLNodeSet`>,1
+selectr,querySelectorAll,0,0,0,"class<`xml_document`, `xml_node`>",1
+selectr,querySelectorAll,0,0,1,"class<`XMLAbstractDocument`, `XMLInternalDocument`>",1
+selectr,querySelectorAll,0,0,2,"class<`XMLAbstractNode`, `XMLInternalElementNode`, `XMLInternalNode`>",1
+selectr,querySelectorAll,1,0,0,character,1
+selectr,querySelectorAll,2,0,0,character[],1
+selectr,querySelectorAll,2,0,1,null,1
+selectr,querySelectorAll,3,0,0,...,1
+selectr,querySelectorAllNS,-1,0,0,class<`xml_nodeset`>,1
+selectr,querySelectorAllNS,-1,0,1,class<`XMLNodeSet`>,1
+selectr,querySelectorAllNS,0,0,0,"class<`xml_document`, `xml_node`>",1
+selectr,querySelectorAllNS,0,0,1,"class<`XMLAbstractDocument`, `XMLInternalDocument`>",1
+selectr,querySelectorAllNS,1,0,0,character,1
+selectr,querySelectorAllNS,2,0,0,character[],1
+selectr,querySelectorAllNS,3,0,0,character,1
+selectr,querySelectorAllNS,4,0,0,...,1
+selectr,querySelectorAllNS.XMLInternalDocument,-1,0,0,class<`XMLNodeSet`>,1
+selectr,querySelectorAllNS.XMLInternalDocument,0,0,0,"class<`XMLAbstractDocument`, `XMLInternalDocument`>",1
+selectr,querySelectorAllNS.XMLInternalDocument,1,0,0,character,1
+selectr,querySelectorAllNS.XMLInternalDocument,2,0,0,character[],1
+selectr,querySelectorAllNS.XMLInternalDocument,3,0,0,character,1
+selectr,querySelectorAllNS.XMLInternalDocument,4,0,0,...,1
+selectr,querySelectorAllNS.xml_node,-1,0,0,class<`xml_nodeset`>,1
+selectr,querySelectorAllNS.xml_node,0,0,0,"class<`xml_document`, `xml_node`>",1
+selectr,querySelectorAllNS.xml_node,1,0,0,character,1
+selectr,querySelectorAllNS.xml_node,2,0,0,character[],1
+selectr,querySelectorAllNS.xml_node,3,0,0,character,1
+selectr,querySelectorAllNS.xml_node,4,0,0,...,1
+selectr,querySelectorAll.XMLInternalDocument,-1,0,0,class<`XMLNodeSet`>,1
+selectr,querySelectorAll.XMLInternalDocument,0,0,0,"class<`XMLAbstractDocument`, `XMLInternalDocument`>",1
+selectr,querySelectorAll.XMLInternalDocument,1,0,0,character,1
+selectr,querySelectorAll.XMLInternalDocument,2,0,0,character[],1
+selectr,querySelectorAll.XMLInternalDocument,2,0,1,null,1
+selectr,querySelectorAll.XMLInternalDocument,3,0,0,...,1
+selectr,querySelectorAll.XMLInternalNode,-1,0,0,class<`XMLNodeSet`>,1
+selectr,querySelectorAll.XMLInternalNode,0,0,0,"class<`XMLAbstractNode`, `XMLInternalElementNode`, `XMLInternalNode`>",1
+selectr,querySelectorAll.XMLInternalNode,1,0,0,character,1
+selectr,querySelectorAll.XMLInternalNode,2,0,0,character[],1
+selectr,querySelectorAll.XMLInternalNode,2,0,1,null,1
+selectr,querySelectorAll.XMLInternalNode,3,0,0,...,1
+selectr,querySelectorAll.xml_node,-1,0,0,class<`xml_nodeset`>,1
+selectr,querySelectorAll.xml_node,0,0,0,"class<`xml_document`, `xml_node`>",1
+selectr,querySelectorAll.xml_node,1,0,0,character,1
+selectr,querySelectorAll.xml_node,2,0,0,character[],1
+selectr,querySelectorAll.xml_node,2,0,1,null,1
+selectr,querySelectorAll.xml_node,3,0,0,...,1
+selectr,querySelectorNS,-1,0,0,"class<`XMLAbstractNode`, `XMLInternalElementNode`, `XMLInternalNode`>",1
+selectr,querySelectorNS,-1,0,1,class<`xml_node`>,1
+selectr,querySelectorNS,0,0,0,"class<`XMLAbstractDocument`, `XMLInternalDocument`>",1
+selectr,querySelectorNS,0,0,1,"class<`xml_document`, `xml_node`>",1
+selectr,querySelectorNS,1,0,0,character,1
+selectr,querySelectorNS,2,0,0,character,1
+selectr,querySelectorNS,3,0,0,character,1
+selectr,querySelectorNS,4,0,0,...,1
+selectr,querySelectorNS.XMLInternalDocument,-1,0,0,"class<`XMLAbstractNode`, `XMLInternalElementNode`, `XMLInternalNode`>",1
+selectr,querySelectorNS.XMLInternalDocument,0,0,0,"class<`XMLAbstractDocument`, `XMLInternalDocument`>",1
+selectr,querySelectorNS.XMLInternalDocument,1,0,0,character,1
+selectr,querySelectorNS.XMLInternalDocument,2,0,0,character,1
+selectr,querySelectorNS.XMLInternalDocument,3,0,0,character,1
+selectr,querySelectorNS.XMLInternalDocument,4,0,0,...,1
+selectr,querySelectorNS.xml_node,-1,0,0,class<`xml_node`>,1
+selectr,querySelectorNS.xml_node,0,0,0,"class<`xml_document`, `xml_node`>",1
+selectr,querySelectorNS.xml_node,1,0,0,character,1
+selectr,querySelectorNS.xml_node,2,0,0,character,1
+selectr,querySelectorNS.xml_node,3,0,0,character,1
+selectr,querySelectorNS.xml_node,4,0,0,...,1
+selectr,querySelector.XMLInternalDocument,-1,0,0,"class<`XMLAbstractNode`, `XMLInternalElementNode`, `XMLInternalNode`>",1
+selectr,querySelector.XMLInternalDocument,-1,0,1,null,1
+selectr,querySelector.XMLInternalDocument,0,0,0,"class<`XMLAbstractDocument`, `XMLInternalDocument`>",1
+selectr,querySelector.XMLInternalDocument,1,0,0,character,1
+selectr,querySelector.XMLInternalDocument,2,0,0,character,1
+selectr,querySelector.XMLInternalDocument,2,0,1,null,1
+selectr,querySelector.XMLInternalDocument,3,0,0,...,1
+selectr,querySelector.xml_node,-1,0,0,class<`xml_node`>,1
+selectr,querySelector.xml_node,-1,0,1,null,1
+selectr,querySelector.xml_node,0,0,0,"class<`xml_document`, `xml_node`>",1
+selectr,querySelector.xml_node,1,0,0,character,1
+selectr,querySelector.xml_node,2,0,0,character,1
+selectr,querySelector.xml_node,2,0,1,null,1
+selectr,querySelector.xml_node,3,0,0,...,1
+selectr,reg_s3_method,-1,0,0,null,1
+selectr,reg_s3_method,0,0,0,character,1
+selectr,reg_s3_method,1,0,0,character,1
+selectr,reg_s3_method,2,0,0,character,1
+selectr,reg_s3_method,3,0,0,class<`function`>,1
+selectr,sub_simple_escape,-1,0,0,character,1
+selectr,sub_simple_escape,0,0,0,character,1
+selectr,sub_unicode_escape,-1,0,0,character,1
+selectr,sub_unicode_escape,0,0,0,character,1
+selectr,token_equality,-1,0,0,logical,1
+selectr,token_equality,0,0,0,"class<`EOFToken`, `R6`, `Token`>",1
+selectr,token_equality,0,0,1,"class<`R6`, `Token`>",1
+selectr,token_equality,1,0,0,character,1
+selectr,token_equality,2,0,0,character,1
+selectr,token_equality,2,0,1,null,1
+selectr,tokenize,-1,0,0,"list<class<`R6`, `Token`> | class<`EOFToken`, `R6`, `Token`>>",1
+selectr,tokenize,0,0,0,character,1
+selectr,validateNS,-1,0,0,null,1
+selectr,validateNS,0,0,0,character[],1
+selectr,validateNS,0,0,1,class<`xml_namespace`>,1
+selectr,xpath_literal,-1,0,0,character,1
+selectr,xpath_literal,0,0,0,character,1
+sessioninfo,%||%,-1,0,0,character,1
+sessioninfo,%||%,0,0,0,character,1
+sessioninfo,%||%,1,0,0,null,1
+sessioninfo,dependent_packages,-1,0,0,class<`data.frame`>,1
+sessioninfo,dependent_packages,0,0,0,character,1
+sessioninfo,dependent_packages,1,0,0,null,1
+sessioninfo,dep_types_hard,-1,0,0,character[],1
+sessioninfo,find_deps,-1,0,0,character[],1
+sessioninfo,find_deps,0,0,0,character,1
+sessioninfo,find_deps,1,0,0,class<`matrix`>,1
+sessioninfo,find_deps,2,0,0,character[],1
+sessioninfo,find_deps,3,0,0,character[],1
+sessioninfo,find_deps,4,0,0,logical,1
+sessioninfo,interpret_dependencies,-1,0,0,list<character[]>,1
+sessioninfo,interpret_dependencies,0,0,0,null,1
+sessioninfo,is_na_scalar,-1,0,0,logical,1
+sessioninfo,is_na_scalar,0,0,0,null,1
+sessioninfo,loaded_packages,-1,0,0,class<`data.frame`>,1
+sessioninfo,os_name,-1,0,0,character,1
+sessioninfo,package_info,-1,0,0,"class<`data.frame`, `packages_info`>",1
+sessioninfo,package_info,0,0,0,character,1
+sessioninfo,package_info,0,0,1,null,1
+sessioninfo,package_info,1,0,0,logical,1
+sessioninfo,package_info,2,0,0,null,1
+sessioninfo,pkg_lib_paths,-1,0,0,character[],1
+sessioninfo,platform_info,-1,0,0,class<`platform_info`>,1
+sessioninfo,session_info,-1,0,0,class<`session_info`>,1
+sessioninfo,session_info,0,0,0,character,1
+sessioninfo,session_info,0,0,1,null,1
+sessioninfo,session_info,1,0,0,logical,1
+sessioninfo,sort_ci,-1,0,0,character[],1
+sessioninfo,sort_ci,0,0,0,character[],1
+sets,%..%,-1,0,0,class<`interval`>,1
+sets,%..%,0,0,0,double,1
+sets,%..%,0,0,1,null,1
+sets,%..%,1,0,0,double,1
+sets,%..%,1,0,1,null,1
+sets,.apply_connector_to_list_of_gsets_and_support,-1,0,0,double[],1
+sets,.apply_connector_to_list_of_gsets_and_support,-1,0,1,list<double[]>,1
+sets,.apply_connector_to_list_of_gsets_and_support,0,0,0,"list<class<`cset`, `gset`>>",1
+sets,.apply_connector_to_list_of_gsets_and_support,0,0,1,"list<class<`cset`, `gset`> | class<`cset`, `gset`, `set`>>",1
+sets,.apply_connector_to_list_of_gsets_and_support,0,0,2,"list<class<`cset`, `gset`, `set`> | class<`cset`, `gset`>>",1
+sets,.apply_connector_to_list_of_gsets_and_support,0,0,3,"list<class<`cset`, `gset`, `set`>>",1
+sets,.apply_connector_to_list_of_gsets_and_support,0,0,4,"list<class<`cset`, `gset`, `set`> | integer>",1
+sets,.apply_connector_to_list_of_gsets_and_support,1,0,0,"class<`cset`, `gset`, `set`>",1
+sets,.apply_connector_to_list_of_gsets_and_support,1,0,1,"class<`cset`, `gset`>",1
+sets,.apply_connector_to_list_of_gsets_and_support,1,0,2,integer[],1
+sets,.apply_connector_to_list_of_gsets_and_support,1,0,3,double,1
+sets,.apply_connector_to_list_of_gsets_and_support,2,0,0,class<`function`>,1
+sets,.apply_connector_to_list_of_gsets_and_support,3,0,0,class<`function`>,1
+sets,.apply_connector_to_list_of_gsets_and_support,4,0,0,logical,1
+sets,.as.character,-1,0,0,character[],1
+sets,.as.character,0,0,0,list<character>,1
+sets,.as.character,0,0,1,list<character | double>,1
+sets,.as.character,0,0,2,list<character | double | list<double>>,1
+sets,.as.character,0,0,3,list<character | integer>,1
+sets,.as.character,0,0,4,"list<class<`cset`, `gset`>>",1
+sets,.as.character,0,0,5,"list<class<`cset`, `gset`> | class<`cset`, `gset`, `set`>>",1
+sets,.as.character,0,0,6,list<class<`element`>>,1
+sets,.as.character,0,0,7,list<class<`function`> | double | list<double>>,1
+sets,.as.character,0,0,8,list<class<`matrix`>>,1
+sets,.as.character,0,0,9,list<class<`tuple`>>,1
+sets,.as.character,0,0,10,list<double>,1
+sets,.as.character,0,0,11,list<integer | class<`matrix`>>,1
+sets,.as.character,0,0,12,"list<class<`cset`, `gset`, `set`>>",1
+sets,.as.character,0,0,13,list<class<`function`>>,1
+sets,.as.character,0,0,14,list<list<double>>,1
+sets,.as.character,-1,1,0,character[],1
+sets,.as.character,0,1,0,character[],1
+sets,.as.character,0,1,1,list<any>,1
+sets,.as.character,1,1,0,...,1
+sets,as.character.cset,-1,0,0,character[],1
+sets,as.character.cset,0,0,0,class<`cset`>,1
+sets,as.character.cset,1,0,0,...,1
+sets,as.cset,-1,0,0,class<`cset`>,1
+sets,as.cset,-1,0,1,"class<`cset`, `gset`>",1
+sets,as.cset,0,0,0,"class<`factor`, `ordered`>",1
+sets,as.cset,0,0,1,character[],1
+sets,as.cset.character,-1,0,0,class<`cset`>,1
+sets,as.cset.character,-1,0,1,"class<`cset`, `gset`>",1
+sets,as.cset.character,0,0,0,character[],1
+sets,as.cset.ordered,-1,0,0,class<`cset`>,1
+sets,as.cset.ordered,0,0,0,"class<`factor`, `ordered`>",1
+sets,as.gset,-1,0,0,"class<`cset`, `gset`>",1
+sets,as.gset,-1,0,1,"class<`cset`, `gset`, `set`>",1
+sets,as.gset,0,0,0,character[],1
+sets,as.gset,0,0,1,"class<`cset`, `gset`>",1
+sets,as.gset,0,0,2,"class<`factor`, `ordered`>",1
+sets,as.gset,0,0,3,list<class<`matrix`>>,1
+sets,as.gset,0,0,4,"class<`cset`, `gset`, `set`>",1
+sets,as.gset,0,0,5,double[],1
+sets,.as.gset.atomic,-1,0,0,"class<`cset`, `gset`>",1
+sets,.as.gset.atomic,-1,0,1,"class<`cset`, `gset`, `set`>",1
+sets,.as.gset.atomic,0,0,0,character[],1
+sets,.as.gset.atomic,0,0,1,"class<`factor`, `ordered`>",1
+sets,.as.gset.atomic,0,0,2,double[],1
+sets,.as.gset.atomic,1,0,0,class<`function`>,1
+sets,as.gset.character,-1,0,0,"class<`cset`, `gset`>",1
+sets,as.gset.character,-1,0,1,"class<`cset`, `gset`, `set`>",1
+sets,as.gset.character,0,0,0,character[],1
+sets,as.gset.integer,-1,0,0,"class<`cset`, `gset`, `set`>",1
+sets,as.gset.integer,0,0,0,integer[],1
+sets,as.gset.list,-1,0,0,"class<`cset`, `gset`>",1
+sets,as.gset.list,0,0,0,list<class<`matrix`>>,1
+sets,as.gset.numeric,-1,0,0,"class<`cset`, `gset`>",1
+sets,as.gset.numeric,-1,0,1,"class<`cset`, `gset`, `set`>",1
+sets,as.gset.numeric,0,0,0,double[],1
+sets,as.gset.ordered,-1,0,0,"class<`cset`, `gset`>",1
+sets,as.gset.ordered,0,0,0,"class<`factor`, `ordered`>",1
+sets,as.interval,-1,0,0,class<`interval`>,1
+sets,as.interval,0,0,0,class<`interval`>,1
+sets,as.interval,0,0,1,list<any>,1
+sets,as.interval,0,0,2,"class<`cset`, `gset`, `set`>",1
+sets,as.interval,0,0,3,double,1
+sets,as.interval,0,0,4,null,1
+sets,as.interval.interval,-1,0,0,class<`interval`>,1
+sets,as.interval.interval,0,0,0,class<`interval`>,1
+sets,as.interval.list,-1,0,0,class<`interval`>,1
+sets,as.interval.list,0,0,0,list<any>,1
+sets,as.interval.NULL,-1,0,0,class<`interval`>,1
+sets,as.interval.NULL,0,0,0,null,1
+sets,as.interval.numeric,-1,0,0,class<`interval`>,1
+sets,as.interval.numeric,0,0,0,double,1
+sets,as.interval.set,-1,0,0,class<`interval`>,1
+sets,as.interval.set,0,0,0,"class<`cset`, `gset`, `set`>",1
+sets,.as.list,-1,0,0,list<any>,1
+sets,.as.list,0,0,0,"class<`cset`, `gset`, `set`>",1
+sets,.as.list,0,0,1,list<any>,1
+sets,.as.list,0,0,2,class<`cset`>,1
+sets,.as.list,0,0,3,"class<`cset`, `gset`>",1
+sets,.as.list,0,0,4,^character[],1
+sets,.as.list,0,0,5,"class<`factor`, `ordered`>",1
+sets,.as.list,0,0,6,class<`tuple`>,1
+sets,.as.list,0,0,7,^double[],1
+sets,.as.list,0,0,8,class<`table`>,1
+sets,.as.list,1,0,0,...,1
+sets,.as.list.cset,-1,0,0,list<character>,1
+sets,.as.list.cset,-1,0,1,list<character | double>,1
+sets,.as.list.cset,-1,0,2,list<double>,1
+sets,.as.list.cset,0,0,0,class<`cset`>,1
+sets,.as.list.cset,1,0,0,...,1
+sets,as.list.cset,-1,0,0,list<character>,1
+sets,as.list.cset,-1,0,1,list<double>,1
+sets,as.list.cset,0,0,0,class<`cset`>,1
+sets,as.list.cset,1,0,0,...,1
+sets,.as.list.default,-1,0,0,list<any>,1
+sets,.as.list.default,0,0,0,list<any>,1
+sets,.as.list.default,0,0,1,^character[],1
+sets,.as.list.default,0,0,2,"class<`factor`, `ordered`>",1
+sets,.as.list.default,0,0,3,class<`tuple`>,1
+sets,.as.list.default,0,0,4,^double[],1
+sets,.as.list.default,0,0,5,class<`table`>,1
+sets,.as.list.default,1,0,0,...,1
+sets,as.list.gset,-1,0,0,list<character>,1
+sets,as.list.gset,-1,0,1,"list<class<`cset`, `gset`, `set`>>",1
+sets,as.list.gset,-1,0,2,list<double>,1
+sets,as.list.gset,-1,0,3,list<character | double>,1
+sets,as.list.gset,-1,0,4,list<character | integer>,1
+sets,as.list.gset,-1,0,5,"list<class<`cset`, `gset`>>",1
+sets,as.list.gset,-1,0,6,"list<class<`cset`, `gset`> | class<`cset`, `gset`, `set`>>",1
+sets,as.list.gset,-1,0,7,"list<class<`cset`, `gset`, `set`> | class<`tuple`>>",1
+sets,as.list.gset,-1,0,8,list<class<`function`> | double | list<double>>,1
+sets,as.list.gset,-1,0,9,list<class<`fuzzy_rule`>>,1
+sets,as.list.gset,-1,0,10,list<character | class<`tuple`> | list<list<list<double>>>>,1
+sets,as.list.gset,-1,0,11,"list<class<`fuzzy_variable`, `tuple`>>",1
+sets,as.list.gset,0,0,0,"class<`cset`, `gset`>",1
+sets,as.list.gset,0,0,1,"class<`cset`, `gset`, `set`>",1
+sets,as.list.gset,1,0,0,...,1
+sets,as.list.set,-1,0,0,list<character>,1
+sets,as.list.set,-1,0,1,"list<class<`cset`, `gset`, `set`>>",1
+sets,as.list.set,-1,0,2,list<double>,1
+sets,as.list.set,-1,0,3,list<character | double>,1
+sets,as.list.set,-1,0,4,list<character | integer>,1
+sets,as.list.set,-1,0,5,"list<class<`cset`, `gset`>>",1
+sets,as.list.set,-1,0,6,"list<class<`cset`, `gset`> | class<`cset`, `gset`, `set`>>",1
+sets,as.list.set,-1,0,7,"list<class<`cset`, `gset`, `set`> | class<`tuple`>>",1
+sets,as.list.set,-1,0,8,list<class<`function`> | double | list<double>>,1
+sets,as.list.set,-1,0,9,list<class<`fuzzy_rule`>>,1
+sets,as.list.set,-1,0,10,list<character | class<`tuple`> | list<list<list<double>>>>,1
+sets,as.list.set,-1,0,11,"list<class<`fuzzy_variable`, `tuple`>>",1
+sets,as.list.set,0,0,0,"class<`cset`, `gset`>",1
+sets,as.list.set,0,0,1,"class<`cset`, `gset`, `set`>",1
+sets,as.list.set,1,0,0,...,1
+sets,as.list.tuple,-1,0,0,list<class<`charfun_generator`>>,1
+sets,as.list.tuple,-1,0,1,"list<class<`cset`, `gset`>>",1
+sets,as.list.tuple,-1,0,2,list<double>,1
+sets,as.list.tuple,0,0,0,class<`tuple`>,1
+sets,as.list.tuple,0,0,1,"class<`fuzzy_variable`, `tuple`>",1
+sets,as.list.tuple,1,0,0,...,1
+sets,as.set,-1,0,0,"class<`cset`, `gset`, `set`>",1
+sets,as.set,0,0,0,character[],1
+sets,as.set,0,0,1,"class<`cset`, `gset`>",1
+sets,as.set,0,0,2,"class<`cset`, `gset`, `set`>",1
+sets,as.set,0,0,3,"class<`factor`, `ordered`>",1
+sets,as.set,0,0,4,double[],1
+sets,as.set,0,0,5,list<character | double>,1
+sets,as.set,0,0,6,list<character | integer>,1
+sets,as.set,0,0,7,"list<class<`cset`, `gset`>>",1
+sets,as.set,0,0,8,"list<class<`cset`, `gset`> | class<`cset`, `gset`, `set`>>",1
+sets,as.set,0,0,9,list<class<`tuple`>>,1
+sets,as.set,0,0,10,list<double>,1
+sets,as.set,0,0,11,"list<class<`cset`, `gset`, `set`> | class<`cset`, `gset`>>",1
+sets,as.tuple,-1,0,0,class<`tuple`>,1
+sets,as.tuple,0,0,0,integer[],1
+sets,as.tuple,0,0,1,"list<class<`cset`, `gset`>>",1
+sets,as.tuple,0,0,2,list<character>,1
+sets,as.tuple,0,0,3,list<integer>,1
+sets,as.tuple.integer,-1,0,0,class<`tuple`>,1
+sets,as.tuple.integer,0,0,0,integer[],1
+sets,as.tuple.list,-1,0,0,class<`tuple`>,1
+sets,as.tuple.list,0,0,0,list<character>,1
+sets,as.tuple.list,0,0,1,"list<class<`cset`, `gset`>>",1
+sets,as.tuple.list,0,0,2,list<integer>,1
+sets,binary_closure,-1,0,0,class<`matrix`>,1
+sets,binary_closure,0,0,0,class<`matrix`>,1
+sets,binary_closure,1,0,0,character[],1
+sets,binary_reduction,-1,0,0,class<`matrix`>,1
+sets,binary_reduction,0,0,0,class<`matrix`>,1
+sets,binary_reduction,1,0,0,character,1
+sets,.bounds,-1,0,0,character,1
+sets,.bounds,0,0,0,logical,1
+sets,.bounds,1,0,0,logical,1
+sets,.canonicalize_interval,-1,0,0,list<list<double>>,1
+sets,.canonicalize_interval,0,0,0,list<list<double>>,1
+sets,.canonicalize_interval,1,0,0,logical,1
+sets,.canonicalize_memberships,-1,0,0,class<`table`>,1
+sets,.canonicalize_memberships,-1,0,1,double[],1
+sets,.canonicalize_memberships,-1,0,2,"list<class<`cset`, `gset`>>",1
+sets,.canonicalize_memberships,-1,0,3,"list<class<`cset`, `gset`> | class<`cset`, `gset`, `set`>>",1
+sets,.canonicalize_memberships,-1,0,4,"list<class<`cset`, `gset`, `set`> | class<`cset`, `gset`>>",1
+sets,.canonicalize_memberships,-1,0,5,"list<class<`cset`, `gset`, `set`>>",1
+sets,.canonicalize_memberships,0,0,0,class<`table`>,1
+sets,.canonicalize_memberships,0,0,1,double[],1
+sets,.canonicalize_memberships,0,0,2,list<double[]>,1
+sets,.canonicalize_memberships,0,0,3,"list<class<`cset`, `gset`>>",1
+sets,.canonicalize_memberships,0,0,4,"list<double[] | class<`cset`, `gset`>>",1
+sets,.canonicalize_memberships,0,0,5,"list<class<`cset`, `gset`, `set`>>",1
+sets,canonicalize_set_and_mapping,-1,0,0,"list<class<`cset`, `gset`, `set`> | class<`matrix`> | integer[]>",1
+sets,canonicalize_set_and_mapping,-1,0,1,"list<class<`cset`, `gset`, `set`> | class<`table`> | integer[]>",1
+sets,canonicalize_set_and_mapping,-1,0,2,"list<class<`cset`, `gset`, `set`> | double[]>",1
+sets,canonicalize_set_and_mapping,-1,0,3,"list<class<`cset`, `gset`, `set`> | double>",1
+sets,canonicalize_set_and_mapping,-1,0,4,"list<class<`cset`, `gset`, `set`> | integer[]>",1
+sets,canonicalize_set_and_mapping,-1,0,5,"list<class<`cset`, `gset`, `set`> | integer>",1
+sets,canonicalize_set_and_mapping,-1,0,6,"list<class<`cset`, `gset`, `set`> | integer[] | list<character>>",1
+sets,canonicalize_set_and_mapping,-1,0,7,"list<class<`cset`, `gset`, `set`> | integer[] | list<class<`cset`, `gset`, `set`> | class<`cset`, `gset`>>>",1
+sets,canonicalize_set_and_mapping,-1,0,8,"list<class<`cset`, `gset`, `set`> | integer[] | list<class<`cset`, `gset`, `set`>>>",1
+sets,canonicalize_set_and_mapping,-1,0,9,"list<class<`cset`, `gset`, `set`> | integer | list<class<`cset`, `gset`, `set`>>>",1
+sets,canonicalize_set_and_mapping,0,0,0,list<class<`function`> | character | double>,1
+sets,canonicalize_set_and_mapping,0,0,1,list<class<`matrix`>>,1
+sets,canonicalize_set_and_mapping,0,0,2,list<integer | class<`matrix`>>,1
+sets,canonicalize_set_and_mapping,0,0,3,character[],1
+sets,canonicalize_set_and_mapping,0,0,4,"class<`cset`, `gset`>",1
+sets,canonicalize_set_and_mapping,0,0,5,"class<`cset`, `gset`, `set`>",1
+sets,canonicalize_set_and_mapping,0,0,6,double[],1
+sets,canonicalize_set_and_mapping,0,0,7,list<character>,1
+sets,canonicalize_set_and_mapping,0,0,8,list<double>,1
+sets,canonicalize_set_and_mapping,0,0,9,"list<class<`factor`, `ordered`>>",1
+sets,canonicalize_set_and_mapping,1,0,0,class<`matrix`>,1
+sets,canonicalize_set_and_mapping,1,0,1,class<`table`>,1
+sets,canonicalize_set_and_mapping,1,0,2,double[],1
+sets,canonicalize_set_and_mapping,1,0,3,list<character>,1
+sets,canonicalize_set_and_mapping,1,0,4,"list<class<`cset`, `gset`, `set`> | class<`cset`, `gset`>>",1
+sets,canonicalize_set_and_mapping,1,0,5,"list<class<`cset`, `gset`, `set`>>",1
+sets,canonicalize_set_and_mapping,2,0,0,double,1
+sets,canonicalize_set_and_mapping,2,0,1,null,1
+sets,.cartesian_product,-1,0,0,list<list<character>>,1
+sets,.cartesian_product,-1,0,1,list<list<double>>,1
+sets,.cartesian_product,0,0,0,list<list<character>>,1
+sets,.cartesian_product,0,0,1,list<double[]>,1
+sets,.cartesian_product,0,0,2,"list<class<`cset`, `gset`, `set`>>",1
+sets,charfun_generator,-1,0,0,class<`charfun_generator`>,1
+sets,charfun_generator,0,0,0,any,1
+sets,charfun_generator,1,0,0,double,1
+sets,.check_matchfun,-1,0,0,class<`function`>,1
+sets,.check_matchfun,0,0,0,list<class<`cset`>>,1
+sets,.check_matchfun,0,0,1,"list<class<`cset`, `gset`>>",1
+sets,.check_matchfun,0,0,2,"list<class<`cset`, `gset`, `set`>>",1
+sets,.check_matchfun,0,0,3,"list<class<`cset`, `gset`, `set`> | integer>",1
+sets,.check_orderfun,-1,0,0,class<`function`>,1
+sets,.check_orderfun,0,0,0,list<class<`cset`>>,1
+sets,.check_orderfun,0,0,1,"list<class<`cset`, `gset`>>",1
+sets,.check_orderfun,0,0,2,"list<class<`cset`, `gset`, `set`>>",1
+sets,.check_orderfun,0,0,3,"list<class<`cset`, `gset`, `set`> | integer>",1
+sets,c.interval,-1,0,0,class<`interval`>,1
+sets,c.interval,0,0,0,...,1
+sets,closure,-1,0,0,"class<`cset`, `gset`, `set`>",1
+sets,closure,0,0,0,"class<`cset`, `gset`, `set`>",1
+sets,closure,1,0,0,any,1
+sets,closure,2,0,0,...,1
+sets,closure.set,-1,0,0,"class<`cset`, `gset`, `set`>",1
+sets,closure.set,0,0,0,"class<`cset`, `gset`, `set`>",1
+sets,closure.set,1,0,0,character[],1
+sets,closure.set,2,0,0,...,1
+sets,.create_hash,-1,0,0,environment,1
+sets,.create_hash,-1,0,1,null,1
+sets,.create_hash,0,0,0,list<any>,1
+sets,cset,-1,0,0,class<`cset`>,1
+sets,cset,-1,0,1,"class<`cset`, `gset`>",1
+sets,cset,-1,0,2,"class<`cset`, `gset`, `set`>",1
+sets,cset,0,0,0,"class<`cset`, `gset`>",1
+sets,cset,0,0,1,character[],1
+sets,cset,0,0,2,"class<`cset`, `gset`, `set`>",1
+sets,cset,0,0,3,double[],1
+sets,cset,1,0,0,integer[],1
+sets,cset,1,0,1,class<`function`>,1
+sets,cset,1,0,2,null,1
+sets,cset,2,0,0,null,1
+sets,cset,2,0,1,class<`function`>,1
+sets,c.set,-1,0,0,"class<`cset`, `gset`, `set`>",1
+sets,c.set,0,0,0,...,1
+sets,cset_bound,-1,0,0,double,1
+sets,cset_bound,0,0,0,"class<`cset`, `gset`>",1
+sets,cset_bound,0,0,1,class<`cset`>,1
+sets,cset_bound,0,0,2,"class<`cset`, `gset`, `set`>",1
+sets,cset_cardinality,-1,0,0,double,1
+sets,cset_cardinality,0,0,0,"class<`cset`, `gset`>",1
+sets,cset_cardinality,0,0,1,class<`cset`>,1
+sets,cset_cardinality,0,0,2,"class<`cset`, `gset`, `set`>",1
+sets,cset_cardinality,1,0,0,character[],1
+sets,cset_cardinality,2,0,0,any,1
+sets,cset_cartesian,-1,0,0,"class<`cset`, `gset`>",1
+sets,cset_cartesian,-1,0,1,"class<`cset`, `gset`, `set`>",1
+sets,cset_cartesian,0,0,0,...,1
+sets,cset_charfun,-1,0,0,double,1
+sets,cset_charfun,0,0,0,double,1
+sets,cset_charfun,-1,1,0,class<`cset_charfun`>,1
+sets,cset_charfun,0,1,0,class<`cset`>,1
+sets,cset_combn,-1,0,0,"class<`cset`, `gset`, `set`>",1
+sets,cset_combn,0,0,0,"class<`cset`, `gset`, `set`>",1
+sets,cset_combn,1,0,0,integer,1
+sets,cset_complement,-1,0,0,class<`cset`>,1
+sets,cset_complement,-1,0,1,"class<`cset`, `gset`>",1
+sets,cset_complement,0,0,0,class<`cset`>,1
+sets,cset_complement,0,0,1,"class<`cset`, `gset`>",1
+sets,cset_complement,0,0,2,"class<`cset`, `gset`, `set`>",1
+sets,cset_complement,1,0,0,class<`cset`>,1
+sets,cset_complement,1,0,1,null,1
+sets,cset_contains_element,-1,0,0,logical,1
+sets,cset_contains_element,0,0,0,class<`cset`>,1
+sets,cset_contains_element,1,0,0,integer,1
+sets,cset_difference,-1,0,0,"class<`cset`, `gset`>",1
+sets,cset_difference,-1,0,1,"class<`cset`, `gset`, `set`>",1
+sets,cset_difference,0,0,0,...,1
+sets,cset_intersection,-1,0,0,class<`cset`>,1
+sets,cset_intersection,-1,0,1,"class<`cset`, `gset`>",1
+sets,cset_intersection,0,0,0,...,1
+sets,cset_is_empty,-1,0,0,logical,1
+sets,cset_is_empty,0,0,0,class<`cset`>,1
+sets,cset_is_empty,0,0,1,"class<`cset`, `gset`>",1
+sets,cset_is_empty,1,0,0,logical,1
+sets,cset_is_equal,-1,0,0,logical,1
+sets,cset_is_equal,0,0,0,"class<`cset`, `gset`, `set`>",1
+sets,cset_is_equal,1,0,0,"class<`cset`, `gset`, `set`>",1
+sets,cset_is_equal,2,0,0,logical,1
+sets,cset_is_fuzzy_multiset,-1,0,0,logical,1
+sets,cset_is_fuzzy_multiset,0,0,0,"class<`cset`, `gset`>",1
+sets,cset_is_multiset,-1,0,0,logical,1
+sets,cset_is_multiset,0,0,0,"class<`cset`, `gset`>",1
+sets,cset_is_multiset,1,0,0,logical,1
+sets,cset_is_proper_subset,-1,0,0,logical,1
+sets,cset_is_proper_subset,0,0,0,"class<`cset`, `gset`, `set`>",1
+sets,cset_is_proper_subset,1,0,0,"class<`cset`, `gset`, `set`>",1
+sets,cset_is_proper_subset,2,0,0,logical,1
+sets,cset_is_set_or_fuzzy_set,-1,0,0,logical,1
+sets,cset_is_set_or_fuzzy_set,0,0,0,"class<`cset`, `gset`>",1
+sets,cset_is_set_or_fuzzy_set,1,0,0,logical,1
+sets,cset_is_set_or_multiset,-1,0,0,logical,1
+sets,cset_is_set_or_multiset,0,0,0,"class<`cset`, `gset`>",1
+sets,cset_is_set_or_multiset,1,0,0,logical,1
+sets,cset_is_subset,-1,0,0,logical,1
+sets,cset_is_subset,0,0,0,class<`cset`>,1
+sets,cset_is_subset,0,0,1,"class<`cset`, `gset`, `set`>",1
+sets,cset_is_subset,1,0,0,class<`cset`>,1
+sets,cset_is_subset,1,0,1,"class<`cset`, `gset`, `set`>",1
+sets,cset_is_subset,2,0,0,logical,1
+sets,cset_matchfun,-1,0,0,class<`function`>,1
+sets,cset_matchfun,0,0,0,class<`cset`>,1
+sets,cset_matchfun,0,0,1,"class<`cset`, `gset`>",1
+sets,cset_matchfun,0,0,2,"class<`cset`, `gset`, `set`>",1
+sets,cset_matchfun,0,0,3,integer,1
+sets,cset_memberships,-1,0,0,double[],1
+sets,cset_memberships,-1,0,1,"list<class<`cset`, `gset`, `set`>>",1
+sets,cset_memberships,-1,0,2,class<`table`>,1
+sets,cset_memberships,-1,0,3,list<double[]>,1
+sets,cset_memberships,0,0,0,class<`cset`>,1
+sets,cset_memberships,0,0,1,"class<`cset`, `gset`>",1
+sets,cset_memberships,0,0,2,"class<`cset`, `gset`, `set`>",1
+sets,cset_memberships,0,0,3,class<`tuple`>,1
+sets,cset_memberships,1,0,0,null,1
+sets,cset_memberships,1,0,1,character[],1
+sets,cset_orderfun,-1,0,0,class<`function`>,1
+sets,cset_orderfun,0,0,0,class<`cset`>,1
+sets,cset_orderfun,0,0,1,"class<`cset`, `gset`>",1
+sets,cset_orderfun,0,0,2,"class<`cset`, `gset`, `set`>",1
+sets,cset_orderfun,0,0,3,integer,1
+sets,cset_power,-1,0,0,"class<`cset`, `gset`>",1
+sets,cset_power,0,0,0,"class<`cset`, `gset`, `set`>",1
+sets,cset_sum,-1,0,0,"class<`cset`, `gset`>",1
+sets,cset_sum,-1,0,1,"class<`cset`, `gset`, `set`>",1
+sets,cset_sum,0,0,0,...,1
+sets,cset_union,-1,0,0,class<`cset`>,1
+sets,cset_union,-1,0,1,"class<`cset`, `gset`>",1
+sets,cset_union,0,0,0,...,1
+sets,cset_universe,-1,0,0,"class<`cset`, `gset`, `set`>",1
+sets,cset_universe,0,0,0,class<`cset`>,1
+sets,cset_universe,0,0,1,"class<`cset`, `gset`>",1
+sets,cset_universe,0,0,2,"class<`cset`, `gset`, `set`>",1
+sets,c.tuple,-1,0,0,class<`tuple`>,1
+sets,c.tuple,0,0,0,...,1
+sets,cut.gset,-1,0,0,"class<`cset`, `gset`, `set`>",1
+sets,cut.gset,0,0,0,"class<`cset`, `gset`>",1
+sets,cut.gset,1,0,0,double,1
+sets,cut.gset,2,0,0,character[],1
+sets,cut.gset,3,0,0,logical,1
+sets,cut.gset,4,0,0,...,1
+sets,%D%,-1,0,0,"class<`cset`, `gset`, `set`>",1
+sets,%D%,0,0,0,"class<`cset`, `gset`, `set`>",1
+sets,%D%,1,0,0,"class<`cset`, `gset`, `set`>",1
+sets,.distfunL1,-1,0,0,double,1
+sets,.distfunL1,0,0,0,"class<`cset`, `gset`>",1
+sets,.distfunL1,1,0,0,"class<`cset`, `gset`>",1
+sets,.distfunL2,-1,0,0,double,1
+sets,.distfunL2,0,0,0,"class<`cset`, `gset`>",1
+sets,.distfunL2,1,0,0,"class<`cset`, `gset`>",1
+sets,.domain_is_numeric,-1,0,0,logical,1
+sets,.domain_is_numeric,0,0,0,"class<`cset`, `gset`>",1
+sets,.domain_is_numeric,0,0,1,"class<`cset`, `gset`, `set`>",1
+sets,.duplicated_by_matchfun,-1,0,0,logical[],1
+sets,.duplicated_by_matchfun,0,0,0,"class<`cset`, `gset`>",1
+sets,.duplicated_by_matchfun,0,0,1,"class<`cset`, `gset`, `set`>",1
+sets,.duplicated_by_matchfun,1,0,0,class<`function`>,1
+sets,e,-1,0,0,class<`element`>,1
+sets,e,0,0,0,character,1
+sets,e,0,0,1,integer,1
+sets,e,1,0,0,double,1
+sets,%e%,-1,0,0,logical[],1
+sets,%e%,0,0,0,integer[],1
+sets,%e%,0,0,1,class<`tuple`>,1
+sets,%e%,1,0,0,"class<`cset`, `gset`, `set`>",1
+sets,%e%,1,0,1,class<`cset`>,1
+sets,.empty_interval,-1,0,0,class<`interval`>,1
+sets,.exact_match,-1,0,0,null,1
+sets,.exact_match,-1,0,1,^integer[],1
+sets,.exact_match,0,0,0,list<class<`matrix`>>,1
+sets,.exact_match,0,0,1,list<class<`tuple`>>,1
+sets,.exact_match,0,0,2,double[],1
+sets,.exact_match,0,0,3,class<`cset`>,1
+sets,.exact_match,0,0,4,"class<`cset`, `gset`>",1
+sets,.exact_match,0,0,5,"class<`cset`, `gset`, `set`>",1
+sets,.exact_match,0,0,6,list<character>,1
+sets,.exact_match,0,0,7,list<character | double>,1
+sets,.exact_match,0,0,8,list<double>,1
+sets,.exact_match,0,0,9,character,1
+sets,.exact_match,0,0,10,list<class<`element`>>,1
+sets,.exact_match,0,0,11,list<class<`function`>>,1
+sets,.exact_match,0,0,12,list<list<double>>,1
+sets,.exact_match,1,0,0,"class<`cset`, `gset`, `set`>",1
+sets,.exact_match,1,0,1,double[],1
+sets,.exact_match,1,0,2,class<`cset`>,1
+sets,.exact_match,1,0,3,"class<`cset`, `gset`>",1
+sets,.exact_match,1,0,4,character[],1
+sets,.exact_match,1,0,5,list<any>,1
+sets,.expand,-1,0,0,"class<`cset`, `gset`, `set`>",1
+sets,.expand,0,0,0,"class<`cset`, `gset`, `set`>",1
+sets,.expand,0,0,1,integer[],1
+sets,.expand,0,0,2,null,1
+sets,.expand_membership,-1,0,0,double[],1
+sets,.expand_membership,0,0,0,"class<`cset`, `gset`>",1
+sets,.expand_membership,0,0,1,"class<`cset`, `gset`, `set`>",1
+sets,.expand_membership,0,0,2,double,1
+sets,.expand_membership,1,0,0,logical,1
+sets,.expand_membership,2,0,0,double,1
+sets,.expand_membership,3,0,0,logical,1
+sets,format.cset,-1,0,0,character,1
+sets,format.cset,0,0,0,class<`cset`>,1
+sets,format.cset,1,0,0,...,1
+sets,format.element,-1,0,0,character,1
+sets,format.element,0,0,0,class<`element`>,1
+sets,format.element,1,0,0,...,1
+sets,format.gset,-1,0,0,character,1
+sets,format.gset,0,0,0,"class<`cset`, `gset`>",1
+sets,format.gset,1,0,0,...,1
+sets,.format_or_class,-1,0,0,character,1
+sets,.format_or_class,0,0,0,character,1
+sets,.format_or_class,0,0,1,"class<`cset`, `gset`, `set`>",1
+sets,.format_or_class,0,0,2,class<`tuple`>,1
+sets,.format_or_class,0,0,3,double,1
+sets,.format_or_class,0,0,4,integer[],1
+sets,.format_or_class,0,0,5,list<double>,1
+sets,.format_or_class,0,0,6,list<list<list<double>>>,1
+sets,.format_or_class,1,0,0,double,1
+sets,.format_or_class,2,0,0,...,1
+sets,format.set,-1,0,0,character,1
+sets,format.set,0,0,0,"class<`cset`, `gset`, `set`>",1
+sets,format.set,1,0,0,...,1
+sets,.format_set_or_tuple,-1,0,0,character,1
+sets,.format_set_or_tuple,0,0,0,"class<`cset`, `gset`, `set`>",1
+sets,.format_set_or_tuple,0,0,1,class<`tuple`>,1
+sets,.format_set_or_tuple,0,0,2,list<character>,1
+sets,.format_set_or_tuple,0,0,3,list<character | double>,1
+sets,.format_set_or_tuple,0,0,4,list<class<`element`>>,1
+sets,.format_set_or_tuple,1,0,0,character,1
+sets,.format_set_or_tuple,2,0,0,character,1
+sets,.format_set_or_tuple,3,0,0,...,1
+sets,format.tuple,-1,0,0,character,1
+sets,format.tuple,0,0,0,class<`tuple`>,1
+sets,format.tuple,1,0,0,...,1
+sets,FUN,-1,0,0,class<`function`>,1
+sets,FUN,0,0,0,any,1
+sets,FUN,1,0,0,any,1
+sets,FUN,2,0,0,any,1
+sets,FUN,3,0,0,double,1
+sets,FUN,4,0,0,any,1
+sets,FUN,-1,1,0,"class<`cset`, `gset`>",1
+sets,FUN,-1,1,1,"class<`cset`, `gset`, `set`>",1
+sets,FUN,0,1,0,character[],1
+sets,FUN,0,1,1,"class<`cset`, `gset`>",1
+sets,FUN,0,1,2,"class<`factor`, `ordered`>",1
+sets,FUN,0,1,3,list<class<`matrix`>>,1
+sets,FUN,0,1,4,"class<`cset`, `gset`, `set`>",1
+sets,FUN,0,1,5,double[],1
+sets,FUN,-1,2,0,class<`interval`>,1
+sets,FUN,0,2,0,class<`interval`>,1
+sets,FUN,0,2,1,list<any>,1
+sets,FUN,0,2,2,"class<`cset`, `gset`, `set`>",1
+sets,FUN,0,2,3,double,1
+sets,FUN,0,2,4,null,1
+sets,FUN,-1,3,0,list<any>,1
+sets,FUN,0,3,0,"class<`cset`, `gset`, `set`>",1
+sets,FUN,0,3,1,list<any>,1
+sets,FUN,0,3,2,class<`cset`>,1
+sets,FUN,0,3,3,"class<`cset`, `gset`>",1
+sets,FUN,0,3,4,^character[],1
+sets,FUN,0,3,5,"class<`factor`, `ordered`>",1
+sets,FUN,0,3,6,class<`tuple`>,1
+sets,FUN,0,3,7,^double[],1
+sets,FUN,0,3,8,class<`table`>,1
+sets,FUN,1,3,0,...,1
+sets,FUN,-1,4,0,"class<`cset`, `gset`, `set`>",1
+sets,FUN,0,4,0,character[],1
+sets,FUN,0,4,1,"class<`cset`, `gset`>",1
+sets,FUN,0,4,2,"class<`cset`, `gset`, `set`>",1
+sets,FUN,0,4,3,"class<`factor`, `ordered`>",1
+sets,FUN,0,4,4,double[],1
+sets,FUN,0,4,5,list<character | double>,1
+sets,FUN,0,4,6,list<character | integer>,1
+sets,FUN,0,4,7,"list<class<`cset`, `gset`>>",1
+sets,FUN,0,4,8,"list<class<`cset`, `gset`> | class<`cset`, `gset`, `set`>>",1
+sets,FUN,0,4,9,list<class<`tuple`>>,1
+sets,FUN,0,4,10,list<double>,1
+sets,FUN,0,4,11,"list<class<`cset`, `gset`, `set`> | class<`cset`, `gset`>>",1
+sets,FUN,-1,5,0,class<`tuple`>,1
+sets,FUN,0,5,0,integer[],1
+sets,FUN,0,5,1,"list<class<`cset`, `gset`>>",1
+sets,FUN,0,5,2,list<character>,1
+sets,FUN,0,5,3,list<integer>,1
+sets,FUN,-1,6,0,class<`cset`>,1
+sets,FUN,-1,6,1,"class<`cset`, `gset`>",1
+sets,FUN,-1,6,2,"class<`cset`, `gset`, `set`>",1
+sets,FUN,0,6,0,"class<`cset`, `gset`>",1
+sets,FUN,0,6,1,character[],1
+sets,FUN,0,6,2,"class<`cset`, `gset`, `set`>",1
+sets,FUN,0,6,3,double[],1
+sets,FUN,1,6,0,integer[],1
+sets,FUN,1,6,1,class<`function`>,1
+sets,FUN,1,6,2,null,1
+sets,FUN,2,6,0,null,1
+sets,FUN,2,6,1,class<`function`>,1
+sets,FUN,-1,7,0,logical,1
+sets,FUN,0,7,0,"class<`cset`, `gset`>",1
+sets,FUN,-1,8,0,logical,1
+sets,FUN,0,8,0,"class<`cset`, `gset`>",1
+sets,FUN,1,8,0,logical,1
+sets,FUN,-1,9,0,double[],1
+sets,FUN,-1,9,1,"list<class<`cset`, `gset`, `set`>>",1
+sets,FUN,-1,9,2,class<`table`>,1
+sets,FUN,-1,9,3,list<double[]>,1
+sets,FUN,0,9,0,class<`cset`>,1
+sets,FUN,0,9,1,"class<`cset`, `gset`>",1
+sets,FUN,0,9,2,"class<`cset`, `gset`, `set`>",1
+sets,FUN,0,9,3,class<`tuple`>,1
+sets,FUN,1,9,0,null,1
+sets,FUN,1,9,1,character[],1
+sets,FUN,-1,10,0,"class<`cset`, `gset`, `set`>",1
+sets,FUN,0,10,0,class<`cset`>,1
+sets,FUN,0,10,1,"class<`cset`, `gset`>",1
+sets,FUN,0,10,2,"class<`cset`, `gset`, `set`>",1
+sets,FUN,-1,11,0,class<`table`>,1
+sets,FUN,-1,11,1,double[],1
+sets,FUN,-1,11,2,"list<class<`cset`, `gset`, `set`>>",1
+sets,FUN,-1,11,3,"class<`cset`, `gset`, `set`>",1
+sets,FUN,-1,11,4,"list<class<`cset`, `gset`, `set`> | class<`cset`, `gset`>>",1
+sets,FUN,0,11,0,"class<`cset`, `gset`>",1
+sets,FUN,0,11,1,class<`cset`>,1
+sets,FUN,0,11,2,"class<`cset`, `gset`, `set`>",1
+sets,FUN,0,11,3,list<character>,1
+sets,FUN,0,11,4,class<`element`>,1
+sets,FUN,0,11,5,list<double>,1
+sets,FUN,0,11,6,double[],1
+sets,FUN,-1,12,0,double[],1
+sets,FUN,0,12,0,"class<`cset`, `gset`>",1
+sets,FUN,0,12,1,"class<`cset`, `gset`, `set`>",1
+sets,FUN,0,12,2,double,1
+sets,FUN,1,12,0,logical,1
+sets,FUN,2,12,0,double,1
+sets,FUN,3,12,0,logical,1
+sets,FUN,-1,13,0,logical,1
+sets,FUN,0,13,0,class<`interval`>,1
+sets,FUN,-1,14,0,logical,1
+sets,FUN,0,14,0,class<`cset`>,1
+sets,FUN,0,14,1,"class<`cset`, `gset`>",1
+sets,FUN,0,14,2,"class<`cset`, `gset`, `set`>",1
+sets,FUN,1,14,0,logical,1
+sets,FUN,-1,15,0,double[],1
+sets,FUN,0,15,0,double[],1
+sets,FUN,-1,16,0,character,1
+sets,FUN,0,16,0,class<`interval`>,1
+sets,FUN,-1,17,0,logical[],1
+sets,FUN,0,17,0,"class<`cset`, `gset`, `set`>",1
+sets,FUN,-1,18,0,"class<`cset`, `gset`>",1
+sets,FUN,0,18,0,double,1
+sets,FUN,-1,19,0,logical,1
+sets,FUN,0,19,0,class<`cset`>,1
+sets,FUN,0,19,1,"class<`cset`, `gset`>",1
+sets,FUN,0,19,2,"class<`cset`, `gset`, `set`>",1
+sets,FUN,0,19,3,list<character>,1
+sets,FUN,0,19,4,list<integer>,1
+sets,FUN,0,19,5,double,1
+sets,FUN,1,19,0,logical,1
+sets,FUN,-1,20,0,logical,1
+sets,FUN,0,20,0,"class<`cset`, `gset`>",1
+sets,FUN,0,20,1,"class<`cset`, `gset`, `set`>",1
+sets,FUN,0,20,2,list<character>,1
+sets,FUN,0,20,3,double[],1
+sets,FUN,1,20,0,logical,1
+sets,FUN,-1,21,0,double,1
+sets,FUN,0,21,0,"class<`cset`, `gset`>",1
+sets,FUN,1,21,0,character,1
+sets,FUN,-1,22,0,logical,1
+sets,FUN,0,22,0,"class<`cset`, `gset`>",1
+sets,FUN,0,22,1,"class<`cset`, `gset`, `set`>",1
+sets,FUN,0,22,2,class<`cset`>,1
+sets,FUN,-1,23,0,logical,1
+sets,FUN,0,23,0,list<character>,1
+sets,FUN,0,23,1,"class<`cset`, `gset`>",1
+sets,FUN,1,23,0,logical,1
+sets,FUN,-1,24,0,"class<`cset`, `gset`, `set`>",1
+sets,FUN,0,24,0,logical[],1
+sets,FUN,-1,25,0,character,1
+sets,FUN,0,25,0,character,1
+sets,FUN,0,25,1,"class<`cset`, `gset`, `set`>",1
+sets,FUN,0,25,2,class<`element`>,1
+sets,FUN,0,25,3,class<`function`>,1
+sets,FUN,0,25,4,class<`tuple`>,1
+sets,FUN,0,25,5,double,1
+sets,FUN,0,25,6,integer[],1
+sets,FUN,0,25,7,list<double>,1
+sets,FUN,0,25,8,list<list<list<double>>>,1
+sets,FUN,0,25,9,class<`matrix`>,1
+sets,FUN,1,25,0,any,1
+sets,FUN,2,25,0,...,1
+sets,FUN,-1,26,0,"class<`cset`, `gset`, `set`>",1
+sets,FUN,0,26,0,"class<`cset`, `gset`>",1
+sets,FUN,0,26,1,"class<`cset`, `gset`, `set`>",1
+sets,FUN,-1,27,0,double,1
+sets,FUN,0,27,0,double[],1
+sets,FUN,-1,28,0,double,1
+sets,FUN,0,28,0,"class<`cset`, `gset`>",1
+sets,FUN,0,28,1,"class<`cset`, `gset`, `set`>",1
+sets,FUN,-1,29,0,integer,1
+sets,FUN,-1,29,1,null,1
+sets,FUN,0,29,0,character,1
+sets,FUN,0,29,1,"class<`cset`, `gset`>",1
+sets,FUN,0,29,2,"class<`cset`, `gset`, `set`>",1
+sets,FUN,0,29,3,class<`element`>,1
+sets,FUN,0,29,4,class<`function`>,1
+sets,FUN,0,29,5,class<`matrix`>,1
+sets,FUN,0,29,6,class<`tuple`>,1
+sets,FUN,0,29,7,double,1
+sets,FUN,0,29,8,list<double>,1
+sets,FUN,-1,30,0,double[],1
+sets,FUN,0,30,0,"class<`cset`, `gset`>",1
+sets,FUN,-1,31,0,logical,1
+sets,FUN,0,31,0,class<`cset`>,1
+sets,FUN,0,31,1,"class<`cset`, `gset`>",1
+sets,FUN,0,31,2,"class<`cset`, `gset`, `set`>",1
+sets,FUN,0,31,3,integer,1
+sets,FUN,-1,32,0,"class<`cset`, `gset`>",1
+sets,FUN,0,32,0,class<`fuzzy_rule`>,1
+sets,FUN,-1,33,0,logical,1
+sets,FUN,0,33,0,class<`interval`>,1
+sets,FUN,-1,34,0,"class<`cset`, `gset`, `set`>",1
+sets,FUN,0,34,0,integer,1
+sets,FUN,-1,35,0,class<`cset`>,1
+sets,FUN,-1,35,1,"class<`cset`, `gset`>",1
+sets,FUN,-1,35,2,"class<`cset`, `gset`, `set`>",1
+sets,FUN,0,35,0,class<`cset`>,1
+sets,FUN,0,35,1,"class<`cset`, `gset`>",1
+sets,FUN,0,35,2,"class<`cset`, `gset`, `set`>",1
+sets,FUN,-1,36,0,double,1
+sets,FUN,0,36,0,"class<`cset`, `gset`, `set`>",1
+sets,FUN,-1,37,0,any,1
+sets,FUN,0,37,0,list<double>,1
+sets,FUN,-1,38,0,double[],1
+sets,FUN,0,38,0,integer,1
+sets,FUN,-1,39,0,logical,1
+sets,FUN,0,39,0,"class<`cset`, `gset`>",1
+sets,FUN,0,39,1,"class<`cset`, `gset`, `set`>",1
+sets,FUN,0,39,2,class<`cset`>,1
+sets,FUN,0,39,3,class<`element`>,1
+sets,FUN,0,39,4,double,1
+sets,FUN,-1,40,0,logical,1
+sets,FUN,0,40,0,class<`cset`>,1
+sets,FUN,0,40,1,"class<`cset`, `gset`>",1
+sets,FUN,0,40,2,"class<`cset`, `gset`, `set`>",1
+sets,FUN,0,40,3,integer,1
+sets,FUN,-1,41,0,logical,1
+sets,FUN,0,41,0,"class<`cset`, `gset`>",1
+sets,FUN,0,41,1,"class<`cset`, `gset`, `set`>",1
+sets,FUN,0,41,2,integer,1
+sets,FUN,0,41,3,list<character>,1
+sets,FUN,-1,42,0,class<`tuple`>,1
+sets,FUN,-1,42,1,list<double>,1
+sets,FUN,0,42,0,class<`tuple`>,1
+sets,FUN,0,42,1,double,1
+sets,FUN,-1,43,0,logical,1
+sets,FUN,0,43,0,double,1
+sets,FUN,-1,44,0,integer[],1
+sets,FUN,0,44,0,character[],1
+sets,FUN,0,44,1,list<any>,1
+sets,FUN,1,44,0,any,1
+sets,FUN,2,44,0,...,1
+sets,FUN,-1,45,0,class<`interval`>,1
+sets,FUN,0,45,0,double,1
+sets,FUN,0,45,1,null,1
+sets,FUN,1,45,0,any,1
+sets,FUN,2,45,0,character[],1
+sets,FUN,3,45,0,null,1
+sets,FUN,3,45,1,character,1
+sets,FUN,-1,46,0,"class<`cset`, `gset`>",1
+sets,FUN,0,46,0,"class<`cset`, `gset`, `set`>",1
+sets,FUN,-1,47,0,double,1
+sets,FUN,0,47,0,integer,1
+sets,FUN,-1,48,0,class<`call`>,1
+sets,FUN,0,48,0,class<`fuzzy_rule`>,1
+sets,FUN,-1,49,0,"class<`cset`, `gset`>",1
+sets,FUN,0,49,0,double,1
+sets,FUN,-1,50,0,list<double>,1
+sets,FUN,0,50,0,integer,1
+sets,FUN,-1,51,0,integer,1
+sets,FUN,0,51,0,class<`interval`>,1
+sets,FUN,-1,52,0,double[],1
+sets,FUN,0,52,0,double[],1
+sets,FUN,-1,53,0,double,1
+sets,FUN,0,53,0,"class<`cset`, `gset`>",1
+sets,FUN,0,53,1,list<character>,1
+sets,FUN,0,53,2,"class<`cset`, `gset`, `set`>",1
+sets,FUN,0,53,3,double,1
+sets,FUN,0,53,4,class<`cset`>,1
+sets,FUN,1,53,0,character[],1
+sets,FUN,2,53,0,any,1
+sets,FUN,-1,54,0,double[],1
+sets,FUN,-1,54,1,"list<class<`cset`, `gset`, `set`> | class<`cset`, `gset`>>",1
+sets,FUN,-1,54,2,"list<class<`cset`, `gset`, `set`> | class<`cset`, `gset`> | double>",1
+sets,FUN,-1,54,3,"list<class<`cset`, `gset`, `set`> | double>",1
+sets,FUN,-1,54,4,"list<class<`cset`, `gset`, `set`>>",1
+sets,FUN,-1,54,5,"list<class<`cset`, `gset`, `set`> | double | class<`cset`, `gset`>>",1
+sets,FUN,-1,54,6,"list<double | class<`cset`, `gset`, `set`>>",1
+sets,FUN,0,54,0,"class<`cset`, `gset`>",1
+sets,FUN,0,54,1,"class<`cset`, `gset`, `set`>",1
+sets,FUN,0,54,2,integer,1
+sets,FUN,0,54,3,class<`cset`>,1
+sets,FUN,1,54,0,"class<`cset`, `gset`>",1
+sets,FUN,1,54,1,"class<`cset`, `gset`, `set`>",1
+sets,FUN,1,54,2,integer[],1
+sets,FUN,1,54,3,double,1
+sets,FUN,2,54,0,class<`function`>,1
+sets,FUN,-1,55,0,logical,1
+sets,FUN,0,55,0,"class<`cset`, `gset`>",1
+sets,FUN,0,55,1,"class<`cset`, `gset`, `set`>",1
+sets,FUN,0,55,2,class<`cset`>,1
+sets,FUN,0,55,3,integer[],1
+sets,FUN,-1,56,0,logical[],1
+sets,FUN,0,56,0,"class<`cset`, `gset`>",1
+sets,FUN,0,56,1,"class<`cset`, `gset`, `set`>",1
+sets,FUN,-1,57,0,double[],1
+sets,FUN,0,57,0,double[],1
+sets,FUN,0,57,1,"list<class<`cset`, `gset`, `set`> | class<`cset`, `gset`>>",1
+sets,FUN,0,57,2,"list<class<`cset`, `gset`, `set`> | class<`cset`, `gset`> | double>",1
+sets,FUN,0,57,3,"list<class<`cset`, `gset`, `set`> | double>",1
+sets,FUN,0,57,4,"list<class<`cset`, `gset`, `set`>>",1
+sets,FUN,0,57,5,"list<class<`cset`, `gset`, `set`> | double | class<`cset`, `gset`>>",1
+sets,FUN,0,57,6,"list<double | class<`cset`, `gset`, `set`>>",1
+sets,FUN,-1,58,0,double,1
+sets,FUN,0,58,0,list<double>,1
+sets,FUN,-1,59,0,any,1
+sets,FUN,0,59,0,class<`interval`>,1
+sets,FUN,1,59,0,any,1
+sets,FUN,2,59,0,double,1
+sets,FUN,-1,60,0,class<`interval`>,1
+sets,FUN,0,60,0,double,1
+sets,FUN,-1,61,0,logical,1
+sets,FUN,0,61,0,"class<`cset`, `gset`>",1
+sets,FUN,0,61,1,"class<`cset`, `gset`, `set`>",1
+sets,FUN,-1,62,0,class<`interval`>,1
+sets,FUN,0,62,0,class<`interval`>,1
+sets,FUN,0,62,1,integer,1
+sets,FUN,-1,63,0,class<`function`>,1
+sets,FUN,0,63,0,any,1
+sets,FUN,1,63,0,double,1
+sets,FUN,2,63,0,double,1
+sets,FUN,3,63,0,logical,1
+sets,FUN,-1,64,0,character,1
+sets,FUN,0,64,0,"class<`fuzzy_variable`, `tuple`>",1
+sets,FUN,-1,65,0,logical[],1
+sets,FUN,0,65,0,logical[],1
+sets,fuzzy_inference,-1,0,0,"class<`cset`, `gset`>",1
+sets,fuzzy_inference,0,0,0,class<`fuzzy_system`>,1
+sets,fuzzy_inference,1,0,0,list<double>,1
+sets,fuzzy_inference,2,0,0,character[],1
+sets,fuzzy_logic,-1,0,0,class<`fuzzy_logic_family`>,1
+sets,fuzzy_logic,0,0,0,any,1
+sets,fuzzy_logic,1,0,0,...,1
+sets,fuzzy_logic_family,-1,0,0,class<`fuzzy_logic_family`>,1
+sets,fuzzy_logic_family,0,0,0,character,1
+sets,fuzzy_logic_family,1,0,0,class<`function`>,1
+sets,fuzzy_logic_family,2,0,0,class<`function`>,1
+sets,fuzzy_logic_family,3,0,0,class<`function`>,1
+sets,fuzzy_logic_family,4,0,0,class<`function`>,1
+sets,fuzzy_logic_family,5,0,0,null,1
+sets,fuzzy_logic_family,6,0,0,list<logical>,1
+sets,fuzzy_normal,-1,0,0,class<`function`>,1
+sets,fuzzy_normal,0,0,0,any,1
+sets,fuzzy_normal,1,0,0,any,1
+sets,fuzzy_normal,2,0,0,any,1
+sets,fuzzy_normal,3,0,0,double,1
+sets,fuzzy_normal,4,0,0,any,1
+sets,fuzzy_normal_gset,-1,0,0,"class<`cset`, `gset`>",1
+sets,fuzzy_normal_gset,0,0,0,null,1
+sets,fuzzy_normal_gset,1,0,0,double,1
+sets,fuzzy_normal_gset,2,0,0,logical,1
+sets,fuzzy_normal_gset,3,0,0,double,1
+sets,fuzzy_normal_gset,4,0,0,double,1
+sets,fuzzy_normal_gset,5,0,0,integer[],1
+sets,fuzzy_normal_gset,5,0,1,null,1
+sets,fuzzy_partition,-1,0,0,"class<`fuzzy_variable`, `tuple`>",1
+sets,fuzzy_partition,0,0,0,double[],1
+sets,fuzzy_partition,1,0,0,class<`charfun_generator`>,1
+sets,fuzzy_partition,2,0,0,null,1
+sets,fuzzy_partition,3,0,0,...,1
+sets,fuzzy_pi3,-1,0,0,class<`function`>,1
+sets,fuzzy_pi3,0,0,0,any,1
+sets,fuzzy_pi3,1,0,0,any,1
+sets,fuzzy_pi3,2,0,0,any,1
+sets,fuzzy_pi3,3,0,0,double,1
+sets,fuzzy_pi3,4,0,0,any,1
+sets,fuzzy_pi3_gset,-1,0,0,"class<`cset`, `gset`>",1
+sets,fuzzy_pi3_gset,0,0,0,null,1
+sets,fuzzy_pi3_gset,1,0,0,double,1
+sets,fuzzy_pi3_gset,2,0,0,double,1
+sets,fuzzy_pi3_gset,3,0,0,double,1
+sets,fuzzy_pi3_gset,4,0,0,null,1
+sets,fuzzy_pi3_gset,5,0,0,logical,1
+sets,fuzzy_rule,-1,0,0,class<`fuzzy_rule`>,1
+sets,fuzzy_rule,0,0,0,any,1
+sets,fuzzy_rule,1,0,0,any,1
+sets,fuzzy_system,-1,0,0,class<`fuzzy_system`>,1
+sets,fuzzy_system,0,0,0,"class<`cset`, `gset`, `set`>",1
+sets,fuzzy_system,1,0,0,"class<`cset`, `gset`, `set`>",1
+sets,fuzzy_trapezoid,-1,0,0,class<`function`>,1
+sets,fuzzy_trapezoid,0,0,0,double[],1
+sets,fuzzy_trapezoid,1,0,0,double[],1
+sets,fuzzy_trapezoid,2,0,0,any,1
+sets,fuzzy_trapezoid_gset,-1,0,0,"class<`cset`, `gset`>",1
+sets,fuzzy_trapezoid_gset,0,0,0,double[],1
+sets,fuzzy_trapezoid_gset,1,0,0,double[],1
+sets,fuzzy_trapezoid_gset,2,0,0,null,1
+sets,fuzzy_trapezoid_gset,3,0,0,logical,1
+sets,fuzzy_tuple,-1,0,0,class<`tuple`>,1
+sets,fuzzy_tuple,0,0,0,class<`charfun_generator`>,1
+sets,fuzzy_tuple,1,0,0,double[],1
+sets,fuzzy_tuple,2,0,0,...,1
+sets,fuzzy_tuple,3,0,0,null,1
+sets,fuzzy_tuple,4,0,0,null,1
+sets,fuzzy_tuple,4,0,1,character[],1
+sets,fuzzy_two_normals,-1,0,0,class<`function`>,1
+sets,fuzzy_two_normals,0,0,0,null,1
+sets,fuzzy_two_normals,1,0,0,double[],1
+sets,fuzzy_two_normals,2,0,0,logical[],1
+sets,fuzzy_two_normals,3,0,0,double,1
+sets,fuzzy_two_normals,4,0,0,any,1
+sets,fuzzy_two_normals_gset,-1,0,0,"class<`cset`, `gset`>",1
+sets,fuzzy_two_normals_gset,0,0,0,null,1
+sets,fuzzy_two_normals_gset,1,0,0,double[],1
+sets,fuzzy_two_normals_gset,2,0,0,logical[],1
+sets,fuzzy_two_normals_gset,3,0,0,double,1
+sets,fuzzy_two_normals_gset,4,0,0,double,1
+sets,fuzzy_two_normals_gset,5,0,0,null,1
+sets,fuzzy_variable,-1,0,0,"class<`fuzzy_variable`, `tuple`>",1
+sets,fuzzy_variable,0,0,0,...,1
+sets,.get_bound,-1,0,0,double,1
+sets,.get_bound,0,0,0,"class<`cset`, `gset`>",1
+sets,.get_bound,0,0,1,class<`cset`>,1
+sets,.get_bound,0,0,2,"class<`cset`, `gset`, `set`>",1
+sets,.get_memberships,-1,0,0,class<`table`>,1
+sets,.get_memberships,-1,0,1,double[],1
+sets,.get_memberships,-1,0,2,"list<class<`cset`, `gset`, `set`>>",1
+sets,.get_memberships,-1,0,3,"class<`cset`, `gset`, `set`>",1
+sets,.get_memberships,-1,0,4,"list<class<`cset`, `gset`, `set`> | class<`cset`, `gset`>>",1
+sets,.get_memberships,0,0,0,"class<`cset`, `gset`>",1
+sets,.get_memberships,0,0,1,class<`cset`>,1
+sets,.get_memberships,0,0,2,"class<`cset`, `gset`, `set`>",1
+sets,.get_memberships,0,0,3,list<character>,1
+sets,.get_memberships,0,0,4,class<`element`>,1
+sets,.get_memberships,0,0,5,list<double>,1
+sets,.get_memberships,0,0,6,double[],1
+sets,.get_support,-1,0,0,character[],1
+sets,.get_support,-1,0,1,double[],1
+sets,.get_support,-1,0,2,list<character | double>,1
+sets,.get_support,-1,0,3,list<character | integer>,1
+sets,.get_support,-1,0,4,"list<class<`cset`, `gset`>>",1
+sets,.get_support,-1,0,5,"list<class<`cset`, `gset`> | class<`cset`, `gset`, `set`>>",1
+sets,.get_support,-1,0,6,"list<class<`cset`, `gset`, `set`>>",1
+sets,.get_support,-1,0,7,list<double>,1
+sets,.get_support,0,0,0,"class<`cset`, `gset`>",1
+sets,.get_support,0,0,1,"class<`cset`, `gset`, `set`>",1
+sets,.get_support,0,0,2,class<`cset`>,1
+sets,.get_support,0,0,3,integer,1
+sets,.get_universe,-1,0,0,"class<`cset`, `gset`, `set`>",1
+sets,.get_universe,0,0,0,class<`cset`>,1
+sets,.get_universe,0,0,1,"class<`cset`, `gset`>",1
+sets,.get_universe,0,0,2,"class<`cset`, `gset`, `set`>",1
+sets,gset,-1,0,0,"class<`cset`, `gset`>",1
+sets,gset,-1,0,1,"class<`cset`, `gset`, `set`>",1
+sets,gset,0,0,0,character[],1
+sets,gset,0,0,1,"class<`cset`, `gset`, `set`>",1
+sets,gset,0,0,2,double[],1
+sets,gset,0,0,3,list<character>,1
+sets,gset,0,0,4,list<integer | class<`matrix`>>,1
+sets,gset,0,0,5,list<integer>,1
+sets,gset,0,0,6,null,1
+sets,gset,1,0,0,double[],1
+sets,gset,1,0,1,"list<double[] | class<`cset`, `gset`>>",1
+sets,gset,1,0,2,list<double[]>,1
+sets,gset,1,0,3,"list<class<`cset`, `gset`>>",1
+sets,gset,1,0,4,"list<class<`cset`, `gset`, `set`>>",1
+sets,gset,1,0,5,class<`table`>,1
+sets,gset,1,0,6,null,1
+sets,gset,2,0,0,null,1
+sets,gset,2,0,1,class<`function`>,1
+sets,gset,3,0,0,null,1
+sets,gset,3,0,1,list<class<`element`>>,1
+sets,gset,4,0,0,null,1
+sets,gset,4,0,1,character[],1
+sets,gset,4,0,2,"class<`cset`, `gset`, `set`>",1
+sets,gset,4,0,3,double[],1
+sets,gset,5,0,0,null,1
+sets,gset,5,0,1,double,1
+sets,[.gset,-1,0,0,"class<`cset`, `gset`>",1
+sets,[.gset,0,0,0,"class<`cset`, `gset`>",1
+sets,[.gset,1,0,0,character[],1
+sets,[[<-.gset,-1,0,0,"class<`cset`, `gset`>",1
+sets,[[<-.gset,0,0,0,"class<`cset`, `gset`>",1
+sets,[[<-.gset,1,0,0,class<`matrix`>,1
+sets,[[<-.gset,2,0,0,integer,1
+sets,gset_bound,-1,0,0,double,1
+sets,gset_bound,0,0,0,"class<`cset`, `gset`>",1
+sets,gset_bound,0,0,1,class<`cset`>,1
+sets,gset_bound,0,0,2,"class<`cset`, `gset`, `set`>",1
+sets,gset_cardinality,-1,0,0,double,1
+sets,gset_cardinality,0,0,0,"class<`cset`, `gset`>",1
+sets,gset_cardinality,0,0,1,list<character>,1
+sets,gset_cardinality,0,0,2,"class<`cset`, `gset`, `set`>",1
+sets,gset_cardinality,0,0,3,double,1
+sets,gset_cardinality,0,0,4,class<`cset`>,1
+sets,gset_cardinality,1,0,0,character[],1
+sets,gset_cardinality,2,0,0,any,1
+sets,gset_cartesian,-1,0,0,"class<`cset`, `gset`>",1
+sets,gset_cartesian,-1,0,1,"class<`cset`, `gset`, `set`>",1
+sets,gset_cartesian,0,0,0,...,1
+sets,gset_combn,-1,0,0,"class<`cset`, `gset`, `set`>",1
+sets,gset_combn,0,0,0,"class<`cset`, `gset`, `set`>",1
+sets,gset_combn,1,0,0,integer,1
+sets,.gset_complement,-1,0,0,"class<`cset`, `gset`>",1
+sets,.gset_complement,0,0,0,"class<`cset`, `gset`>",1
+sets,.gset_complement,0,0,1,class<`cset`>,1
+sets,.gset_complement,0,0,2,"class<`cset`, `gset`, `set`>",1
+sets,.gset_complement,1,0,0,"class<`cset`, `gset`, `set`>",1
+sets,.gset_complement,2,0,0,double,1
+sets,gset_complement,-1,0,0,"class<`cset`, `gset`>",1
+sets,gset_complement,-1,0,1,"class<`cset`, `gset`, `set`>",1
+sets,gset_complement,0,0,0,"class<`cset`, `gset`>",1
+sets,gset_complement,0,0,1,"class<`cset`, `gset`, `set`>",1
+sets,gset_complement,1,0,0,"class<`cset`, `gset`>",1
+sets,gset_complement,1,0,1,null,1
+sets,gset_concentrate,-1,0,0,"class<`cset`, `gset`>",1
+sets,gset_concentrate,0,0,0,"class<`cset`, `gset`>",1
+sets,gset_defuzzify,-1,0,0,double,1
+sets,gset_defuzzify,0,0,0,"class<`cset`, `gset`>",1
+sets,gset_defuzzify,1,0,0,character,1
+sets,gset_difference,-1,0,0,"class<`cset`, `gset`>",1
+sets,gset_difference,-1,0,1,"class<`cset`, `gset`, `set`>",1
+sets,gset_difference,0,0,0,...,1
+sets,gset_dilate,-1,0,0,"class<`cset`, `gset`>",1
+sets,gset_dilate,0,0,0,"class<`cset`, `gset`>",1
+sets,gset_dissimilarity,-1,0,0,double,1
+sets,gset_dissimilarity,0,0,0,"class<`cset`, `gset`>",1
+sets,gset_dissimilarity,1,0,0,"class<`cset`, `gset`>",1
+sets,gset_dissimilarity,2,0,0,character,1
+sets,gset_height,-1,0,0,double,1
+sets,gset_height,0,0,0,"class<`cset`, `gset`>",1
+sets,gset_height,1,0,0,logical,1
+sets,gset_intersection,-1,0,0,"class<`cset`, `gset`>",1
+sets,gset_intersection,-1,0,1,"class<`cset`, `gset`, `set`>",1
+sets,gset_intersection,0,0,0,...,1
+sets,gset_is_crisp,-1,0,0,logical,1
+sets,gset_is_crisp,0,0,0,"class<`cset`, `gset`>",1
+sets,gset_is_crisp,0,0,1,"class<`cset`, `gset`, `set`>",1
+sets,gset_is_crisp,0,0,2,list<character>,1
+sets,gset_is_crisp,0,0,3,double[],1
+sets,gset_is_crisp,1,0,0,logical,1
+sets,gset_is_empty,-1,0,0,logical,1
+sets,gset_is_empty,0,0,0,"class<`cset`, `gset`>",1
+sets,gset_is_empty,0,0,1,"class<`cset`, `gset`, `set`>",1
+sets,gset_is_empty,1,0,0,logical,1
+sets,gset_is_equal,-1,0,0,logical,1
+sets,gset_is_equal,0,0,0,"class<`cset`, `gset`, `set`>",1
+sets,gset_is_equal,1,0,0,"class<`cset`, `gset`, `set`>",1
+sets,gset_is_equal,2,0,0,logical,1
+sets,gset_is_fuzzy_multiset,-1,0,0,logical,1
+sets,gset_is_fuzzy_multiset,0,0,0,"class<`cset`, `gset`>",1
+sets,gset_is_fuzzy_multiset,0,0,1,"class<`cset`, `gset`, `set`>",1
+sets,gset_is_fuzzy_multiset,0,0,2,integer,1
+sets,gset_is_fuzzy_multiset,0,0,3,list<character>,1
+sets,gset_is_fuzzy_set,-1,0,0,logical,1
+sets,gset_is_fuzzy_set,0,0,0,list<character>,1
+sets,gset_is_fuzzy_set,0,0,1,"class<`cset`, `gset`>",1
+sets,gset_is_fuzzy_set,1,0,0,logical,1
+sets,gset_is_multiset,-1,0,0,logical,1
+sets,gset_is_multiset,0,0,0,"class<`cset`, `gset`>",1
+sets,gset_is_multiset,1,0,0,any,1
+sets,gset_is_proper_subset,-1,0,0,logical,1
+sets,gset_is_proper_subset,0,0,0,"class<`cset`, `gset`, `set`>",1
+sets,gset_is_proper_subset,1,0,0,"class<`cset`, `gset`, `set`>",1
+sets,gset_is_proper_subset,2,0,0,logical,1
+sets,gset_is_set,-1,0,0,logical,1
+sets,gset_is_set,0,0,0,class<`cset`>,1
+sets,gset_is_set,0,0,1,"class<`cset`, `gset`>",1
+sets,gset_is_set,0,0,2,"class<`cset`, `gset`, `set`>",1
+sets,gset_is_set,0,0,3,list<character>,1
+sets,gset_is_set,0,0,4,list<integer>,1
+sets,gset_is_set,0,0,5,double,1
+sets,gset_is_set,1,0,0,logical,1
+sets,gset_is_set_or_fuzzy_set,-1,0,0,logical,1
+sets,gset_is_set_or_fuzzy_set,0,0,0,"class<`cset`, `gset`>",1
+sets,gset_is_set_or_fuzzy_set,1,0,0,any,1
+sets,gset_is_subset,-1,0,0,logical,1
+sets,gset_is_subset,0,0,0,"class<`cset`, `gset`, `set`>",1
+sets,gset_is_subset,1,0,0,"class<`cset`, `gset`, `set`>",1
+sets,gset_is_subset,2,0,0,logical,1
+sets,gset_mean,-1,0,0,"class<`cset`, `gset`>",1
+sets,gset_mean,0,0,0,"class<`cset`, `gset`>",1
+sets,gset_mean,0,0,1,"class<`cset`, `gset`, `set`>",1
+sets,gset_mean,1,0,0,"class<`cset`, `gset`>",1
+sets,gset_mean,1,0,1,"class<`cset`, `gset`, `set`>",1
+sets,gset_mean,2,0,0,character[],1
+sets,gset_memberships,-1,0,0,double[],1
+sets,gset_memberships,-1,0,1,"list<class<`cset`, `gset`, `set`>>",1
+sets,gset_memberships,-1,0,2,class<`table`>,1
+sets,gset_memberships,-1,0,3,list<double[]>,1
+sets,gset_memberships,0,0,0,class<`cset`>,1
+sets,gset_memberships,0,0,1,"class<`cset`, `gset`>",1
+sets,gset_memberships,0,0,2,"class<`cset`, `gset`, `set`>",1
+sets,gset_memberships,0,0,3,class<`tuple`>,1
+sets,gset_memberships,1,0,0,null,1
+sets,gset_memberships,1,0,1,character[],1
+sets,gset_normalize,-1,0,0,"class<`cset`, `gset`>",1
+sets,gset_normalize,0,0,0,"class<`cset`, `gset`>",1
+sets,gset_normalize,1,0,0,double,1
+sets,gset_peak,-1,0,0,"class<`cset`, `gset`, `set`>",1
+sets,gset_peak,0,0,0,"class<`cset`, `gset`>",1
+sets,gset_peak,1,0,0,logical,1
+sets,gset_product,-1,0,0,"class<`cset`, `gset`>",1
+sets,gset_product,0,0,0,...,1
+sets,gset_similarity,-1,0,0,double,1
+sets,gset_similarity,0,0,0,"class<`cset`, `gset`>",1
+sets,gset_similarity,0,0,1,"class<`cset`, `gset`, `set`>",1
+sets,gset_similarity,1,0,0,"class<`cset`, `gset`>",1
+sets,gset_similarity,1,0,1,"class<`cset`, `gset`, `set`>",1
+sets,gset_similarity,2,0,0,character,1
+sets,gset_sum,-1,0,0,"class<`cset`, `gset`>",1
+sets,gset_sum,-1,0,1,"class<`cset`, `gset`, `set`>",1
+sets,gset_sum,0,0,0,...,1
+sets,gset_support,-1,0,0,"class<`cset`, `gset`, `set`>",1
+sets,gset_support,0,0,0,"class<`cset`, `gset`>",1
+sets,gset_support,0,0,1,"class<`cset`, `gset`, `set`>",1
+sets,gset_transform_memberships,-1,0,0,"class<`cset`, `gset`>",1
+sets,gset_transform_memberships,0,0,0,"class<`cset`, `gset`>",1
+sets,gset_transform_memberships,1,0,0,class<`function`>,1
+sets,gset_transform_memberships,2,0,0,...,1
+sets,gset_union,-1,0,0,"class<`cset`, `gset`>",1
+sets,gset_union,-1,0,1,"class<`cset`, `gset`, `set`>",1
+sets,gset_union,0,0,0,...,1
+sets,gset_universe,-1,0,0,"class<`cset`, `gset`, `set`>",1
+sets,gset_universe,0,0,0,class<`cset`>,1
+sets,gset_universe,0,0,1,"class<`cset`, `gset`>",1
+sets,gset_universe,0,0,2,"class<`cset`, `gset`, `set`>",1
+sets,.I.,-1,0,0,double[],1
+sets,.I.,0,0,0,double[],1
+sets,.I.,1,0,0,double[],1
+sets,integers,-1,0,0,class<`interval`>,1
+sets,integers,0,0,0,double,1
+sets,integers,0,0,1,null,1
+sets,integers,1,0,0,double,1
+sets,integers,1,0,1,null,1
+sets,integers2reals,-1,0,0,any,1
+sets,integers2reals,0,0,0,class<`interval`>,1
+sets,integers2reals,1,0,0,any,1
+sets,integers2reals,2,0,0,double,1
+sets,interval,-1,0,0,class<`interval`>,1
+sets,interval,0,0,0,double,1
+sets,interval,0,0,1,null,1
+sets,interval,1,0,0,any,1
+sets,interval,2,0,0,character[],1
+sets,interval,3,0,0,null,1
+sets,interval,3,0,1,character,1
+sets,[[.interval,-1,0,0,class<`interval`>,1
+sets,[[.interval,0,0,0,class<`interval`>,1
+sets,[[.interval,1,0,0,integer,1
+sets,interval_complement,-1,0,0,any,1
+sets,interval_complement,0,0,0,class<`interval`>,1
+sets,interval_complement,1,0,0,class<`interval`>,1
+sets,interval_complement,1,0,1,null,1
+sets,interval_difference,-1,0,0,class<`interval`>,1
+sets,interval_difference,0,0,0,...,1
+sets,interval_division,-1,0,0,class<`interval`>,1
+sets,interval_division,0,0,0,...,1
+sets,interval_domain,-1,0,0,character,1
+sets,interval_domain,0,0,0,class<`interval`>,1
+sets,interval_intersection,-1,0,0,class<`interval`>,1
+sets,interval_intersection,0,0,0,...,1
+sets,interval_is_bounded,-1,0,0,logical,1
+sets,interval_is_bounded,0,0,0,class<`interval`>,1
+sets,interval_is_degenerate,-1,0,0,logical,1
+sets,interval_is_degenerate,0,0,0,class<`interval`>,1
+sets,interval_is_empty,-1,0,0,logical,1
+sets,interval_is_empty,0,0,0,class<`interval`>,1
+sets,interval_is_equal,-1,0,0,logical,1
+sets,interval_is_equal,0,0,0,class<`interval`>,1
+sets,interval_is_equal,1,0,0,class<`interval`>,1
+sets,interval_is_half_bounded,-1,0,0,logical,1
+sets,interval_is_half_bounded,0,0,0,class<`interval`>,1
+sets,interval_is_left_bounded,-1,0,0,logical,1
+sets,interval_is_left_bounded,0,0,0,class<`interval`>,1
+sets,interval_is_left_closed,-1,0,0,logical,1
+sets,interval_is_left_closed,0,0,0,class<`interval`>,1
+sets,interval_is_proper_subinterval,-1,0,0,logical,1
+sets,interval_is_proper_subinterval,0,0,0,class<`interval`>,1
+sets,interval_is_proper_subinterval,1,0,0,class<`interval`>,1
+sets,interval_is_right_bounded,-1,0,0,logical,1
+sets,interval_is_right_bounded,0,0,0,class<`interval`>,1
+sets,interval_is_right_closed,-1,0,0,logical,1
+sets,interval_is_right_closed,0,0,0,class<`interval`>,1
+sets,interval_is_right_unbounded,-1,0,0,logical,1
+sets,interval_is_right_unbounded,0,0,0,class<`interval`>,1
+sets,interval_is_subinterval,-1,0,0,logical,1
+sets,interval_is_subinterval,0,0,0,class<`interval`>,1
+sets,interval_is_subinterval,1,0,0,class<`interval`>,1
+sets,interval_is_uncountable,-1,0,0,logical,1
+sets,interval_is_uncountable,0,0,0,class<`interval`>,1
+sets,.interval_ops,-1,0,0,class<`interval`>,1
+sets,.interval_ops,0,0,0,list<class<`interval`>>,1
+sets,.interval_ops,0,0,1,list<class<`interval`> | integer>,1
+sets,.interval_ops,1,0,0,any,1
+sets,interval_product,-1,0,0,class<`interval`>,1
+sets,interval_product,0,0,0,...,1
+sets,interval_sum,-1,0,0,class<`interval`>,1
+sets,interval_sum,0,0,0,...,1
+sets,interval_union,-1,0,0,class<`interval`>,1
+sets,interval_union,0,0,0,...,1
+sets,%is%,-1,0,0,double,1
+sets,%is%,0,0,0,"class<`cset`, `gset`>",1
+sets,%is%,1,0,0,double,1
+sets,is.charfun_generator,-1,0,0,logical,1
+sets,is.charfun_generator,0,0,0,class<`charfun_generator`>,1
+sets,is.charfun_generator,0,0,1,"class<`cset`, `gset`>",1
+sets,is.charfun_generator,0,0,2,class<`function`>,1
+sets,is.cset,-1,0,0,logical,1
+sets,is.cset,0,0,0,"class<`cset`, `gset`>",1
+sets,is.cset,0,0,1,"class<`cset`, `gset`, `set`>",1
+sets,is.cset,0,0,2,class<`cset`>,1
+sets,is.cset,0,0,3,class<`element`>,1
+sets,is.cset,0,0,4,double,1
+sets,is_element,-1,0,0,logical,1
+sets,is_element,0,0,0,character,1
+sets,is_element,0,0,1,class<`element`>,1
+sets,is_element,0,0,2,double,1
+sets,is_element,0,0,3,integer[],1
+sets,is.gset,-1,0,0,logical,1
+sets,is.gset,0,0,0,"class<`cset`, `gset`>",1
+sets,is.gset,0,0,1,"class<`cset`, `gset`, `set`>",1
+sets,is.gset,0,0,2,class<`cset`>,1
+sets,is.gset,0,0,3,integer[],1
+sets,is.interval,-1,0,0,logical,1
+sets,is.interval,0,0,0,character[],1
+sets,is.interval,0,0,1,"class<`cset`, `gset`, `set`>",1
+sets,is.interval,0,0,2,double[],1
+sets,is.set,-1,0,0,logical,1
+sets,is.set,0,0,0,"class<`cset`, `gset`>",1
+sets,is.set,0,0,1,"class<`cset`, `gset`, `set`>",1
+sets,is.set,0,0,2,class<`cset`>,1
+sets,is.tuple,-1,0,0,logical,1
+sets,is.tuple,0,0,0,class<`cset`>,1
+sets,is.tuple,0,0,1,"class<`cset`, `gset`>",1
+sets,is.tuple,0,0,2,"class<`cset`, `gset`, `set`>",1
+sets,is.tuple,0,0,3,class<`element`>,1
+sets,is.tuple,0,0,4,class<`tuple`>,1
+sets,is.tuple,0,0,5,double,1
+sets,is.tuple,0,0,6,integer[],1
+sets,LABEL,-1,0,0,character,1
+sets,LABEL,0,0,0,character,1
+sets,LABEL,0,0,1,"class<`cset`, `gset`, `set`>",1
+sets,LABEL,0,0,2,class<`element`>,1
+sets,LABEL,0,0,3,class<`function`>,1
+sets,LABEL,0,0,4,class<`tuple`>,1
+sets,LABEL,0,0,5,double,1
+sets,LABEL,0,0,6,integer[],1
+sets,LABEL,0,0,7,list<double>,1
+sets,LABEL,0,0,8,list<list<list<double>>>,1
+sets,LABEL,0,0,9,class<`matrix`>,1
+sets,LABEL,1,0,0,any,1
+sets,LABEL,2,0,0,...,1
+sets,LABEL.character,-1,0,0,character,1
+sets,LABEL.character,0,0,0,character,1
+sets,LABEL.character,1,0,0,null,1
+sets,LABEL.character,2,0,0,logical,1
+sets,LABEL.character,3,0,0,...,1
+sets,LABEL.default,-1,0,0,character,1
+sets,LABEL.default,0,0,0,class<`function`>,1
+sets,LABEL.default,1,0,0,any,1
+sets,LABEL.default,2,0,0,...,1
+sets,LABEL.element,-1,0,0,character,1
+sets,LABEL.element,0,0,0,class<`element`>,1
+sets,LABEL.element,1,0,0,any,1
+sets,LABEL.element,2,0,0,...,1
+sets,LABEL.integer,-1,0,0,character,1
+sets,LABEL.integer,0,0,0,integer[],1
+sets,LABEL.integer,0,0,1,double,1
+sets,LABEL.integer,1,0,0,null,1
+sets,LABEL.integer,2,0,0,...,1
+sets,LABEL.list,-1,0,0,character,1
+sets,LABEL.list,0,0,0,list<double>,1
+sets,LABEL.list,0,0,1,list<list<list<double>>>,1
+sets,LABEL.list,1,0,0,null,1
+sets,LABEL.list,2,0,0,...,1
+sets,LABEL.matrix,-1,0,0,character,1
+sets,LABEL.matrix,0,0,0,class<`matrix`>,1
+sets,LABEL.matrix,1,0,0,null,1
+sets,LABEL.matrix,2,0,0,...,1
+sets,LABEL.numeric,-1,0,0,character,1
+sets,LABEL.numeric,0,0,0,integer[],1
+sets,LABEL.numeric,0,0,1,double,1
+sets,LABEL.numeric,1,0,0,null,1
+sets,LABEL.numeric,2,0,0,...,1
+sets,LABELS,-1,0,0,character[],1
+sets,LABELS,0,0,0,character[],1
+sets,LABELS,0,0,1,"class<`cset`, `gset`>",1
+sets,LABELS,0,0,2,"class<`cset`, `gset`, `set`>",1
+sets,LABELS,0,0,3,class<`tuple`>,1
+sets,LABELS,0,0,4,integer[],1
+sets,LABELS,0,0,5,list<character>,1
+sets,LABELS,0,0,6,list<character | double>,1
+sets,LABELS,0,0,7,"list<class<`cset`, `gset`, `set`>>",1
+sets,LABELS,0,0,8,list<class<`element`>>,1
+sets,LABELS,0,0,9,list<class<`function`> | double | list<double>>,1
+sets,LABELS,0,0,10,list<double>,1
+sets,LABELS,0,0,11,list<double | character | integer[]>,1
+sets,LABELS,0,0,12,"list<class<`cset`, `gset`> | class<`cset`, `gset`, `set`>>",1
+sets,LABELS,0,0,13,list<list<double>>,1
+sets,LABELS,1,0,0,null,1
+sets,LABELS,2,0,0,character,1
+sets,LABELS,3,0,0,logical,1
+sets,LABELS,4,0,0,null,1
+sets,LABELS,4,0,1,double,1
+sets,LABELS,5,0,0,...,1
+sets,LABEL.set,-1,0,0,character,1
+sets,LABEL.set,0,0,0,"class<`cset`, `gset`, `set`>",1
+sets,LABEL.set,0,0,1,class<`tuple`>,1
+sets,LABEL.set,1,0,0,double,1
+sets,LABEL.set,1,0,1,null,1
+sets,LABEL.set,2,0,0,...,1
+sets,LABEL.tuple,-1,0,0,character,1
+sets,LABEL.tuple,0,0,0,"class<`cset`, `gset`, `set`>",1
+sets,LABEL.tuple,0,0,1,class<`tuple`>,1
+sets,LABEL.tuple,1,0,0,double,1
+sets,LABEL.tuple,1,0,1,null,1
+sets,LABEL.tuple,2,0,0,...,1
+sets,length.cset,-1,0,0,integer,1
+sets,length.cset,0,0,0,class<`cset`>,1
+sets,length.cset,0,0,1,"class<`cset`, `gset`>",1
+sets,length.cset,0,0,2,^character[],1
+sets,length.cset,0,0,3,"class<`cset`, `gset`, `set`>",1
+sets,length.cset,0,0,4,"class<`factor`, `ordered`>",1
+sets,length.cset,0,0,5,class<`table`>,1
+sets,length.cset,0,0,6,class<`tuple`>,1
+sets,length.cset,0,0,7,^double[],1
+sets,length.cset,0,0,8,list<any>,1
+sets,length.gset,-1,0,0,integer,1
+sets,length.gset,0,0,0,class<`cset`>,1
+sets,length.gset,0,0,1,"class<`cset`, `gset`>",1
+sets,length.gset,0,0,2,^character[],1
+sets,length.gset,0,0,3,"class<`cset`, `gset`, `set`>",1
+sets,length.gset,0,0,4,"class<`factor`, `ordered`>",1
+sets,length.gset,0,0,5,class<`table`>,1
+sets,length.gset,0,0,6,class<`tuple`>,1
+sets,length.gset,0,0,7,^double[],1
+sets,length.gset,0,0,8,list<any>,1
+sets,length.interval,-1,0,0,integer,1
+sets,length.interval,0,0,0,class<`interval`>,1
+sets,length.set,-1,0,0,integer,1
+sets,length.set,0,0,0,class<`cset`>,1
+sets,length.set,0,0,1,"class<`cset`, `gset`>",1
+sets,length.set,0,0,2,^character[],1
+sets,length.set,0,0,3,"class<`cset`, `gset`, `set`>",1
+sets,length.set,0,0,4,"class<`factor`, `ordered`>",1
+sets,length.set,0,0,5,class<`table`>,1
+sets,length.set,0,0,6,class<`tuple`>,1
+sets,length.set,0,0,7,^double[],1
+sets,length.set,0,0,8,list<any>,1
+sets,lengths.set,-1,0,0,integer[],1
+sets,lengths.set,0,0,0,"class<`cset`, `gset`, `set`>",1
+sets,lengths.set,1,0,0,logical,1
+sets,lines.gset,-1,0,0,"class<`cset`, `gset`>",1
+sets,lines.gset,0,0,0,"class<`cset`, `gset`>",1
+sets,lines.gset,1,0,0,character,1
+sets,lines.gset,2,0,0,double,1
+sets,lines.gset,2,0,1,character,1
+sets,lines.gset,3,0,0,logical,1
+sets,lines.gset,4,0,0,"class<`cset`, `gset`, `set`>",1
+sets,lines.gset,4,0,1,null,1
+sets,lines.gset,5,0,0,...,1
+sets,lines.tuple,-1,0,0,class<`tuple`>,1
+sets,lines.tuple,0,0,0,class<`tuple`>,1
+sets,lines.tuple,1,0,0,character[],1
+sets,lines.tuple,1,0,1,double,1
+sets,lines.tuple,1,0,2,integer[],1
+sets,lines.tuple,2,0,0,any,1
+sets,lines.tuple,3,0,0,...,1
+sets,.list_order,-1,0,0,integer[],1
+sets,.list_order,0,0,0,character[],1
+sets,.list_order,0,0,1,list<any>,1
+sets,.list_order,1,0,0,any,1
+sets,.list_order,2,0,0,...,1
+sets,.list_sort,-1,0,0,list<any>,1
+sets,.list_sort,0,0,0,list<any>,1
+sets,.list_sort,1,0,0,logical,1
+sets,.list_sort,2,0,0,...,1
+sets,.list_unique,-1,0,0,list<any>,1
+sets,.list_unique,0,0,0,list<any>,1
+sets,.list_unique,0,0,1,character[],1
+sets,.list_unique,0,0,2,"class<`factor`, `ordered`>",1
+sets,.lookup_elements,-1,0,0,integer[],1
+sets,.lookup_elements,0,0,0,"class<`cset`, `gset`>",1
+sets,.lookup_elements,0,0,1,"class<`cset`, `gset`, `set`>",1
+sets,.lookup_elements,1,0,0,character[],1
+sets,.lookup_elements,1,0,1,list<character | double>,1
+sets,.lookup_elements,1,0,2,double[],1
+sets,.lookup_elements,1,0,3,list<class<`matrix`>>,1
+sets,.lookup_elements,1,0,4,list<class<`function`>>,1
+sets,.lookup_elements,1,0,5,list<list<double>>,1
+sets,.lookup_elements,2,0,0,class<`function`>,1
+sets,.make_cset_from_gset_and_orderfun_and_matchfun,-1,0,0,class<`cset`>,1
+sets,.make_cset_from_gset_and_orderfun_and_matchfun,-1,0,1,"class<`cset`, `gset`>",1
+sets,.make_cset_from_gset_and_orderfun_and_matchfun,-1,0,2,"class<`cset`, `gset`, `set`>",1
+sets,.make_cset_from_gset_and_orderfun_and_matchfun,0,0,0,"class<`cset`, `gset`>",1
+sets,.make_cset_from_gset_and_orderfun_and_matchfun,0,0,1,"class<`cset`, `gset`, `set`>",1
+sets,.make_cset_from_gset_and_orderfun_and_matchfun,1,0,0,integer[],1
+sets,.make_cset_from_gset_and_orderfun_and_matchfun,1,0,1,class<`function`>,1
+sets,.make_cset_from_gset_and_orderfun_and_matchfun,1,0,2,null,1
+sets,.make_cset_from_gset_and_orderfun_and_matchfun,2,0,0,null,1
+sets,.make_cset_from_gset_and_orderfun_and_matchfun,2,0,1,class<`function`>,1
+sets,.make_element_from_support_and_memberships,-1,0,0,class<`element`>,1
+sets,.make_element_from_support_and_memberships,0,0,0,character,1
+sets,.make_element_from_support_and_memberships,0,0,1,class<`matrix`>,1
+sets,.make_element_from_support_and_memberships,0,0,2,double,1
+sets,.make_element_from_support_and_memberships,1,0,0,double,1
+sets,.make_element_from_support_and_memberships,1,0,1,"class<`cset`, `gset`, `set`>",1
+sets,.make_gset_by_support_and_memberships,-1,0,0,"class<`cset`, `gset`>",1
+sets,.make_gset_by_support_and_memberships,-1,0,1,"class<`cset`, `gset`, `set`>",1
+sets,.make_gset_by_support_and_memberships,0,0,0,"class<`cset`, `gset`, `set`>",1
+sets,.make_gset_by_support_and_memberships,0,0,1,list<any>,1
+sets,.make_gset_by_support_and_memberships,1,0,0,class<`table`>,1
+sets,.make_gset_by_support_and_memberships,1,0,1,double[],1
+sets,.make_gset_by_support_and_memberships,1,0,2,"list<class<`cset`, `gset`, `set`> | class<`cset`, `gset`>>",1
+sets,.make_gset_by_support_and_memberships,1,0,3,"list<class<`cset`, `gset`, `set`>>",1
+sets,.make_gset_by_support_and_memberships,1,0,4,null,1
+sets,.make_gset_by_support_and_memberships,2,0,0,null,1
+sets,.make_gset_by_support_and_memberships,2,0,1,character[],1
+sets,.make_gset_by_support_and_memberships,2,0,2,"class<`cset`, `gset`, `set`>",1
+sets,.make_gset_by_support_and_memberships,2,0,3,double[],1
+sets,.make_gset_by_support_and_memberships,3,0,0,any,1
+sets,.make_gset_from_list,-1,0,0,"class<`cset`, `gset`>",1
+sets,.make_gset_from_list,0,0,0,"list<class<`cset`, `gset`, `set`>>",1
+sets,.make_gset_from_list_of_gsets_and_support_and_connector,-1,0,0,"class<`cset`, `gset`>",1
+sets,.make_gset_from_list_of_gsets_and_support_and_connector,-1,0,1,"class<`cset`, `gset`, `set`>",1
+sets,.make_gset_from_list_of_gsets_and_support_and_connector,0,0,0,"list<class<`cset`, `gset`>>",1
+sets,.make_gset_from_list_of_gsets_and_support_and_connector,0,0,1,"list<class<`cset`, `gset`> | class<`cset`, `gset`, `set`>>",1
+sets,.make_gset_from_list_of_gsets_and_support_and_connector,0,0,2,"list<class<`cset`, `gset`, `set`> | class<`cset`, `gset`>>",1
+sets,.make_gset_from_list_of_gsets_and_support_and_connector,0,0,3,"list<class<`cset`, `gset`, `set`>>",1
+sets,.make_gset_from_list_of_gsets_and_support_and_connector,0,0,4,"list<class<`cset`, `gset`, `set`> | integer>",1
+sets,.make_gset_from_list_of_gsets_and_support_and_connector,1,0,0,"class<`cset`, `gset`, `set`>",1
+sets,.make_gset_from_list_of_gsets_and_support_and_connector,1,0,1,"class<`cset`, `gset`>",1
+sets,.make_gset_from_list_of_gsets_and_support_and_connector,2,0,0,class<`function`>,1
+sets,.make_gset_from_list_of_gsets_and_support_and_connector,3,0,0,class<`function`>,1
+sets,.make_gset_from_list_of_gsets_and_support_and_connector,4,0,0,logical,1
+sets,.make_gset_from_support_and_memberships,-1,0,0,"class<`cset`, `gset`>",1
+sets,.make_gset_from_support_and_memberships,-1,0,1,"class<`cset`, `gset`, `set`>",1
+sets,.make_gset_from_support_and_memberships,0,0,0,^character[],1
+sets,.make_gset_from_support_and_memberships,0,0,1,"class<`cset`, `gset`>",1
+sets,.make_gset_from_support_and_memberships,0,0,2,"class<`cset`, `gset`, `set`>",1
+sets,.make_gset_from_support_and_memberships,0,0,3,"class<`factor`, `ordered`>",1
+sets,.make_gset_from_support_and_memberships,0,0,4,^double[],1
+sets,.make_gset_from_support_and_memberships,0,0,5,list<character>,1
+sets,.make_gset_from_support_and_memberships,0,0,6,list<class<`matrix`>>,1
+sets,.make_gset_from_support_and_memberships,0,0,7,list<integer | class<`matrix`>>,1
+sets,.make_gset_from_support_and_memberships,0,0,8,list<integer>,1
+sets,.make_gset_from_support_and_memberships,1,0,0,double[],1
+sets,.make_gset_from_support_and_memberships,1,0,1,"list<double[] | class<`cset`, `gset`>>",1
+sets,.make_gset_from_support_and_memberships,1,0,2,list<double[]>,1
+sets,.make_gset_from_support_and_memberships,1,0,3,"list<class<`cset`, `gset`>>",1
+sets,.make_gset_from_support_and_memberships,1,0,4,"list<class<`cset`, `gset`, `set`>>",1
+sets,.make_gset_from_support_and_memberships,1,0,5,class<`table`>,1
+sets,.make_gset_from_support_and_memberships,1,0,6,null,1
+sets,.make_gset_from_support_and_memberships,2,0,0,null,1
+sets,.make_gset_from_support_and_memberships,2,0,1,"class<`cset`, `gset`, `set`>",1
+sets,.make_gset_from_support_and_memberships,2,0,2,double[],1
+sets,.make_gset_from_support_and_memberships,2,0,3,character[],1
+sets,.make_gset_from_support_and_memberships,3,0,0,any,1
+sets,.make_interval_from_list_and_domain,-1,0,0,class<`interval`>,1
+sets,.make_interval_from_list_and_domain,0,0,0,list<any>,1
+sets,.make_interval_from_list_and_domain,1,0,0,character,1
+sets,.make_interval_from_list_and_domain,1,0,1,null,1
+sets,.make_list_of_elements_from_cset,-1,0,0,list<class<`element`>>,1
+sets,.make_list_of_elements_from_cset,0,0,0,class<`cset`>,1
+sets,.make_list_of_elements_from_cset,0,0,1,"class<`cset`, `gset`>",1
+sets,.make_matchfun_from_equalityfun,-1,0,0,class<`function`>,1
+sets,.make_matchfun_from_equalityfun,0,0,0,class<`function`>,1
+sets,.make_set_from_list,-1,0,0,"class<`cset`, `gset`, `set`>",1
+sets,.make_set_from_list,0,0,0,"class<`cset`, `gset`, `set`>",1
+sets,.make_set_from_list,0,0,1,list<any>,1
+sets,.make_set_of_tuples_from_list_of_lists,-1,0,0,"class<`cset`, `gset`, `set`>",1
+sets,.make_set_of_tuples_from_list_of_lists,0,0,0,list<list<character>>,1
+sets,.make_set_of_tuples_from_list_of_lists,0,0,1,list<list<integer>>,1
+sets,.make_set_with_order,-1,0,0,"list<class<`cset`, `gset`, `set`> | integer[]>",1
+sets,.make_set_with_order,-1,0,1,"list<class<`cset`, `gset`, `set`> | integer>",1
+sets,.make_set_with_order,0,0,0,"class<`cset`, `gset`, `set`>",1
+sets,.make_set_with_order,1,0,0,integer[],1
+sets,make_set_with_order,-1,0,0,"list<class<`cset`, `gset`, `set`> | integer[]>",1
+sets,make_set_with_order,-1,0,1,"list<class<`cset`, `gset`, `set`> | integer>",1
+sets,make_set_with_order,0,0,0,character[],1
+sets,make_set_with_order,0,0,1,"class<`cset`, `gset`>",1
+sets,make_set_with_order,0,0,2,"class<`cset`, `gset`, `set`>",1
+sets,make_set_with_order,0,0,3,"class<`factor`, `ordered`>",1
+sets,make_set_with_order,0,0,4,double[],1
+sets,make_set_with_order,0,0,5,list<character>,1
+sets,make_set_with_order,0,0,6,list<character | double>,1
+sets,make_set_with_order,0,0,7,list<character | integer>,1
+sets,make_set_with_order,0,0,8,"list<class<`cset`, `gset`>>",1
+sets,make_set_with_order,0,0,9,"list<class<`cset`, `gset`> | class<`cset`, `gset`, `set`>>",1
+sets,make_set_with_order,0,0,10,"list<class<`cset`, `gset`, `set`> | class<`cset`, `gset`>>",1
+sets,make_set_with_order,0,0,11,"list<class<`factor`, `ordered`>>",1
+sets,make_set_with_order,0,0,12,list<class<`function`> | character | double>,1
+sets,make_set_with_order,0,0,13,list<class<`matrix`>>,1
+sets,make_set_with_order,0,0,14,list<class<`tuple`>>,1
+sets,make_set_with_order,0,0,15,list<double>,1
+sets,make_set_with_order,0,0,16,list<integer | class<`matrix`>>,1
+sets,make_set_with_order.character,-1,0,0,"list<class<`cset`, `gset`, `set`> | integer[]>",1
+sets,make_set_with_order.character,-1,0,1,"list<class<`cset`, `gset`, `set`> | integer>",1
+sets,make_set_with_order.character,0,0,0,character[],1
+sets,make_set_with_order.character,0,0,1,list<character>,1
+sets,make_set_with_order.character,0,0,2,list<character | double>,1
+sets,make_set_with_order.character,0,0,3,list<character | integer>,1
+sets,make_set_with_order.character,0,0,4,"list<class<`cset`, `gset`>>",1
+sets,make_set_with_order.character,0,0,5,"list<class<`cset`, `gset`> | class<`cset`, `gset`, `set`>>",1
+sets,make_set_with_order.character,0,0,6,"list<class<`cset`, `gset`, `set`> | class<`cset`, `gset`>>",1
+sets,make_set_with_order.character,0,0,7,"list<class<`factor`, `ordered`>>",1
+sets,make_set_with_order.character,0,0,8,list<class<`function`> | character | double>,1
+sets,make_set_with_order.character,0,0,9,list<class<`matrix`>>,1
+sets,make_set_with_order.character,0,0,10,list<class<`tuple`>>,1
+sets,make_set_with_order.character,0,0,11,list<double>,1
+sets,make_set_with_order.character,0,0,12,list<integer | class<`matrix`>>,1
+sets,make_set_with_order.character,0,0,13,"class<`factor`, `ordered`>",1
+sets,make_set_with_order.gset,-1,0,0,"list<class<`cset`, `gset`, `set`> | integer[]>",1
+sets,make_set_with_order.gset,0,0,0,"class<`cset`, `gset`>",1
+sets,make_set_with_order.integer,-1,0,0,"list<class<`cset`, `gset`, `set`> | integer[]>",1
+sets,make_set_with_order.integer,-1,0,1,"list<class<`cset`, `gset`, `set`> | integer>",1
+sets,make_set_with_order.integer,0,0,0,double[],1
+sets,make_set_with_order.list,-1,0,0,"list<class<`cset`, `gset`, `set`> | integer[]>",1
+sets,make_set_with_order.list,-1,0,1,"list<class<`cset`, `gset`, `set`> | integer>",1
+sets,make_set_with_order.list,0,0,0,character[],1
+sets,make_set_with_order.list,0,0,1,list<character>,1
+sets,make_set_with_order.list,0,0,2,list<character | double>,1
+sets,make_set_with_order.list,0,0,3,list<character | integer>,1
+sets,make_set_with_order.list,0,0,4,"list<class<`cset`, `gset`>>",1
+sets,make_set_with_order.list,0,0,5,"list<class<`cset`, `gset`> | class<`cset`, `gset`, `set`>>",1
+sets,make_set_with_order.list,0,0,6,"list<class<`cset`, `gset`, `set`> | class<`cset`, `gset`>>",1
+sets,make_set_with_order.list,0,0,7,"list<class<`factor`, `ordered`>>",1
+sets,make_set_with_order.list,0,0,8,list<class<`function`> | character | double>,1
+sets,make_set_with_order.list,0,0,9,list<class<`matrix`>>,1
+sets,make_set_with_order.list,0,0,10,list<class<`tuple`>>,1
+sets,make_set_with_order.list,0,0,11,list<double>,1
+sets,make_set_with_order.list,0,0,12,list<integer | class<`matrix`>>,1
+sets,make_set_with_order.list,0,0,13,"class<`factor`, `ordered`>",1
+sets,make_set_with_order.numeric,-1,0,0,"list<class<`cset`, `gset`, `set`> | integer[]>",1
+sets,make_set_with_order.numeric,-1,0,1,"list<class<`cset`, `gset`, `set`> | integer>",1
+sets,make_set_with_order.numeric,0,0,0,double[],1
+sets,make_set_with_order.ordered,-1,0,0,"list<class<`cset`, `gset`, `set`> | integer[]>",1
+sets,make_set_with_order.ordered,-1,0,1,"list<class<`cset`, `gset`, `set`> | integer>",1
+sets,make_set_with_order.ordered,0,0,0,character[],1
+sets,make_set_with_order.ordered,0,0,1,list<character>,1
+sets,make_set_with_order.ordered,0,0,2,list<character | double>,1
+sets,make_set_with_order.ordered,0,0,3,list<character | integer>,1
+sets,make_set_with_order.ordered,0,0,4,"list<class<`cset`, `gset`>>",1
+sets,make_set_with_order.ordered,0,0,5,"list<class<`cset`, `gset`> | class<`cset`, `gset`, `set`>>",1
+sets,make_set_with_order.ordered,0,0,6,"list<class<`cset`, `gset`, `set`> | class<`cset`, `gset`>>",1
+sets,make_set_with_order.ordered,0,0,7,"list<class<`factor`, `ordered`>>",1
+sets,make_set_with_order.ordered,0,0,8,list<class<`function`> | character | double>,1
+sets,make_set_with_order.ordered,0,0,9,list<class<`matrix`>>,1
+sets,make_set_with_order.ordered,0,0,10,list<class<`tuple`>>,1
+sets,make_set_with_order.ordered,0,0,11,list<double>,1
+sets,make_set_with_order.ordered,0,0,12,list<integer | class<`matrix`>>,1
+sets,make_set_with_order.ordered,0,0,13,"class<`factor`, `ordered`>",1
+sets,make_set_with_order.set,-1,0,0,"list<class<`cset`, `gset`, `set`> | integer[]>",1
+sets,make_set_with_order.set,-1,0,1,"list<class<`cset`, `gset`, `set`> | integer>",1
+sets,make_set_with_order.set,0,0,0,"class<`cset`, `gset`, `set`>",1
+sets,.make_tuple_from_list,-1,0,0,class<`tuple`>,1
+sets,.make_tuple_from_list,0,0,0,list<character | double>,1
+sets,.make_tuple_from_list,0,0,1,list<character>,1
+sets,.make_tuple_from_list,0,0,2,list<class<`charfun_generator`>>,1
+sets,.make_tuple_from_list,0,0,3,"list<class<`cset`, `gset`>>",1
+sets,.make_tuple_from_list,0,0,4,list<double>,1
+sets,matchfun,-1,0,0,null,1
+sets,matchfun,-1,0,1,^integer[],1
+sets,matchfun,0,0,0,list<class<`matrix`>>,1
+sets,matchfun,0,0,1,list<class<`tuple`>>,1
+sets,matchfun,0,0,2,double[],1
+sets,matchfun,0,0,3,class<`cset`>,1
+sets,matchfun,0,0,4,"class<`cset`, `gset`>",1
+sets,matchfun,0,0,5,"class<`cset`, `gset`, `set`>",1
+sets,matchfun,0,0,6,list<character>,1
+sets,matchfun,0,0,7,list<character | double>,1
+sets,matchfun,0,0,8,list<double>,1
+sets,matchfun,0,0,9,character,1
+sets,matchfun,0,0,10,list<class<`element`>>,1
+sets,matchfun,0,0,11,list<class<`function`>>,1
+sets,matchfun,0,0,12,list<list<double>>,1
+sets,matchfun,1,0,0,"class<`cset`, `gset`, `set`>",1
+sets,matchfun,1,0,1,double[],1
+sets,matchfun,1,0,2,class<`cset`>,1
+sets,matchfun,1,0,3,"class<`cset`, `gset`>",1
+sets,matchfun,1,0,4,character[],1
+sets,matchfun,1,0,5,list<any>,1
+sets,matchfun,-1,1,0,class<`function`>,1
+sets,matchfun,0,1,0,class<`function`>,1
+sets,.matchfun,-1,0,0,class<`function`>,1
+sets,.matchfun,-1,0,1,null,1
+sets,.matchfun,0,0,0,class<`cset`>,1
+sets,.matchfun,0,0,1,"class<`cset`, `gset`>",1
+sets,.matchfun,0,0,2,"class<`cset`, `gset`, `set`>",1
+sets,.matchfun,0,0,3,integer,1
+sets,.maximal_domain,-1,0,0,character,1
+sets,.maximal_domain,0,0,0,list<class<`interval`>>,1
+sets,max.interval,-1,0,0,double,1
+sets,max.interval,0,0,0,...,1
+sets,mean.gset,-1,0,0,double,1
+sets,mean.gset,0,0,0,"class<`cset`, `gset`>",1
+sets,mean.gset,1,0,0,...,1
+sets,mean.gset,2,0,0,logical,1
+sets,mean.interval,-1,0,0,class<`interval`>,1
+sets,mean.interval,0,0,0,...,1
+sets,mean.set,-1,0,0,double,1
+sets,mean.set,0,0,0,"class<`cset`, `gset`, `set`>",1
+sets,mean.set,1,0,0,...,1
+sets,median.gset,-1,0,0,double,1
+sets,median.gset,0,0,0,"class<`cset`, `gset`>",1
+sets,median.gset,1,0,0,logical,1
+sets,median.gset,2,0,0,...,1
+sets,median.set,-1,0,0,double,1
+sets,median.set,0,0,0,"class<`cset`, `gset`, `set`>",1
+sets,median.set,1,0,0,logical,1
+sets,median.set,2,0,0,...,1
+sets,.memberships_for_support,-1,0,0,double[],1
+sets,.memberships_for_support,-1,0,1,"list<class<`cset`, `gset`, `set`> | class<`cset`, `gset`>>",1
+sets,.memberships_for_support,-1,0,2,"list<class<`cset`, `gset`, `set`> | class<`cset`, `gset`> | double>",1
+sets,.memberships_for_support,-1,0,3,"list<class<`cset`, `gset`, `set`> | double>",1
+sets,.memberships_for_support,-1,0,4,"list<class<`cset`, `gset`, `set`>>",1
+sets,.memberships_for_support,-1,0,5,"list<class<`cset`, `gset`, `set`> | double | class<`cset`, `gset`>>",1
+sets,.memberships_for_support,-1,0,6,"list<double | class<`cset`, `gset`, `set`>>",1
+sets,.memberships_for_support,0,0,0,"class<`cset`, `gset`>",1
+sets,.memberships_for_support,0,0,1,"class<`cset`, `gset`, `set`>",1
+sets,.memberships_for_support,0,0,2,integer,1
+sets,.memberships_for_support,0,0,3,class<`cset`>,1
+sets,.memberships_for_support,1,0,0,"class<`cset`, `gset`>",1
+sets,.memberships_for_support,1,0,1,"class<`cset`, `gset`, `set`>",1
+sets,.memberships_for_support,1,0,2,integer[],1
+sets,.memberships_for_support,1,0,3,double,1
+sets,.memberships_for_support,2,0,0,class<`function`>,1
+sets,.minimal_domain,-1,0,0,character,1
+sets,.minimal_domain,0,0,0,list<class<`interval`>>,1
+sets,min.interval,-1,0,0,double,1
+sets,min.interval,0,0,0,...,1
+sets,.multiplicities,-1,0,0,double[],1
+sets,.multiplicities,0,0,0,double[],1
+sets,.multiplicities,0,0,1,"list<class<`cset`, `gset`, `set`> | class<`cset`, `gset`>>",1
+sets,.N.,-1,0,0,double[],1
+sets,.N.,0,0,0,double[],1
+sets,naturals,-1,0,0,class<`interval`>,1
+sets,naturals,0,0,0,null,1
+sets,naturals,1,0,0,null,1
+sets,naturals0,-1,0,0,class<`interval`>,1
+sets,naturals0,0,0,0,null,1
+sets,naturals0,1,0,0,null,1
+sets,Ops.cset,-1,0,0,class<`cset`>,1
+sets,Ops.cset,-1,0,1,"class<`cset`, `gset`>",1
+sets,Ops.cset,-1,0,2,"class<`cset`, `gset`, `set`>",1
+sets,Ops.cset,-1,0,3,logical,1
+sets,Ops.cset,0,0,0,class<`cset`>,1
+sets,Ops.cset,0,0,1,double,1
+sets,Ops.cset,0,0,2,"class<`cset`, `gset`>",1
+sets,Ops.cset,0,0,3,"class<`cset`, `gset`, `set`>",1
+sets,Ops.cset,1,0,0,any,1
+sets,Ops_gset,-1,0,0,"class<`cset`, `gset`>",1
+sets,Ops_gset,-1,0,1,"class<`cset`, `gset`, `set`>",1
+sets,Ops_gset,-1,0,2,logical,1
+sets,Ops_gset,0,0,0,"class<`cset`, `gset`>",1
+sets,Ops_gset,0,0,1,"class<`cset`, `gset`, `set`>",1
+sets,Ops_gset,1,0,0,any,1
+sets,Ops_gset,2,0,0,character,1
+sets,Ops_gset,3,0,0,any,1
+sets,Ops.interval,-1,0,0,class<`interval`>,1
+sets,Ops.interval,-1,0,1,logical,1
+sets,Ops.interval,0,0,0,class<`interval`>,1
+sets,Ops.interval,1,0,0,any,1
+sets,Ops_set,-1,0,0,"class<`cset`, `gset`>",1
+sets,Ops_set,-1,0,1,"class<`cset`, `gset`, `set`>",1
+sets,Ops_set,-1,0,2,logical,1
+sets,Ops_set,0,0,0,"class<`cset`, `gset`, `set`>",1
+sets,Ops_set,1,0,0,any,1
+sets,Ops_set,2,0,0,character,1
+sets,Ops_set,3,0,0,any,1
+sets,Ops.tuple,-1,0,0,class<`tuple`>,1
+sets,Ops.tuple,0,0,0,class<`tuple`>,1
+sets,Ops.tuple,1,0,0,class<`tuple`>,1
+sets,.orderfun,-1,0,0,class<`function`>,1
+sets,.orderfun,-1,0,1,null,1
+sets,.orderfun,0,0,0,class<`cset`>,1
+sets,.orderfun,0,0,1,"class<`cset`, `gset`>",1
+sets,.orderfun,0,0,2,"class<`cset`, `gset`, `set`>",1
+sets,.orderfun,0,0,3,integer,1
+sets,pair,-1,0,0,class<`tuple`>,1
+sets,pair,0,0,0,...,1
+sets,plot.charfun_generator,-1,0,0,class<`tuple`>,1
+sets,plot.charfun_generator,0,0,0,class<`charfun_generator`>,1
+sets,plot.charfun_generator,1,0,0,null,1
+sets,plot.charfun_generator,2,0,0,...,1
+sets,plot.fuzzy_system,-1,0,0,class<`fuzzy_system`>,1
+sets,plot.fuzzy_system,0,0,0,class<`fuzzy_system`>,1
+sets,plot.fuzzy_system,1,0,0,class<`function`>,1
+sets,plot.fuzzy_system,2,0,0,...,1
+sets,plot.fuzzy_variable,-1,0,0,"class<`fuzzy_variable`, `tuple`>",1
+sets,plot.fuzzy_variable,0,0,0,"class<`fuzzy_variable`, `tuple`>",1
+sets,plot.fuzzy_variable,1,0,0,double,1
+sets,plot.fuzzy_variable,2,0,0,...,1
+sets,plot.gset,-1,0,0,"class<`cset`, `gset`>",1
+sets,plot.gset,-1,0,1,class<`tuple`>,1
+sets,plot.gset,0,0,0,"class<`cset`, `gset`>",1
+sets,plot.gset,1,0,0,null,1
+sets,plot.gset,2,0,0,null,1
+sets,plot.gset,3,0,0,character,1
+sets,plot.gset,4,0,0,character,1
+sets,plot.gset,5,0,0,...,1
+sets,plot.tuple,-1,0,0,"class<`fuzzy_variable`, `tuple`>",1
+sets,plot.tuple,-1,0,1,class<`tuple`>,1
+sets,plot.tuple,0,0,0,"class<`fuzzy_variable`, `tuple`>",1
+sets,plot.tuple,0,0,1,class<`tuple`>,1
+sets,plot.tuple,1,0,0,character,1
+sets,plot.tuple,2,0,0,null,1
+sets,plot.tuple,3,0,0,character,1
+sets,plot.tuple,4,0,0,character,1
+sets,plot.tuple,5,0,0,character[],1
+sets,plot.tuple,5,0,1,double,1
+sets,plot.tuple,5,0,2,integer[],1
+sets,plot.tuple,6,0,0,logical,1
+sets,plot.tuple,7,0,0,...,1
+sets,print.cset,-1,0,0,class<`cset`>,1
+sets,print.cset,0,0,0,class<`cset`>,1
+sets,print.cset,1,0,0,...,1
+sets,print.fuzzy_rule,-1,0,0,class<`fuzzy_rule`>,1
+sets,print.fuzzy_rule,0,0,0,class<`fuzzy_rule`>,1
+sets,print.fuzzy_rule,1,0,0,...,1
+sets,print.fuzzy_system,-1,0,0,class<`fuzzy_system`>,1
+sets,print.fuzzy_system,0,0,0,class<`fuzzy_system`>,1
+sets,print.fuzzy_system,1,0,0,...,1
+sets,print.gset,-1,0,0,class<`cset`>,1
+sets,print.gset,-1,0,1,"class<`cset`, `gset`>",1
+sets,print.gset,-1,0,2,"class<`cset`, `gset`, `set`>",1
+sets,print.gset,0,0,0,class<`cset`>,1
+sets,print.gset,0,0,1,"class<`cset`, `gset`>",1
+sets,print.gset,0,0,2,"class<`cset`, `gset`, `set`>",1
+sets,print.gset,1,0,0,...,1
+sets,print.set,-1,0,0,class<`cset`>,1
+sets,print.set,-1,0,1,"class<`cset`, `gset`>",1
+sets,print.set,-1,0,2,"class<`cset`, `gset`, `set`>",1
+sets,print.set,0,0,0,class<`cset`>,1
+sets,print.set,0,0,1,"class<`cset`, `gset`>",1
+sets,print.set,0,0,2,"class<`cset`, `gset`, `set`>",1
+sets,print.set,1,0,0,...,1
+sets,range.interval,-1,0,0,double[],1
+sets,range.interval,0,0,0,...,1
+sets,reals,-1,0,0,class<`interval`>,1
+sets,reals,0,0,0,double,1
+sets,reals,0,0,1,null,1
+sets,reals,1,0,0,double,1
+sets,reals,1,0,1,null,1
+sets,reals,2,0,0,character[],1
+sets,reals2integers,-1,0,0,class<`interval`>,1
+sets,reals2integers,0,0,0,class<`interval`>,1
+sets,reduction,-1,0,0,"class<`cset`, `gset`, `set`>",1
+sets,reduction,0,0,0,"class<`cset`, `gset`, `set`>",1
+sets,reduction,1,0,0,any,1
+sets,reduction,2,0,0,...,1
+sets,reduction.set,-1,0,0,"class<`cset`, `gset`, `set`>",1
+sets,reduction.set,0,0,0,"class<`cset`, `gset`, `set`>",1
+sets,reduction.set,1,0,0,character[],1
+sets,reduction.set,2,0,0,...,1
+sets,rep.gset,-1,0,0,"class<`cset`, `gset`>",1
+sets,rep.gset,-1,0,1,"class<`cset`, `gset`, `set`>",1
+sets,rep.gset,0,0,0,"class<`cset`, `gset`>",1
+sets,rep.gset,1,0,0,...,1
+sets,rep.tuple,-1,0,0,class<`tuple`>,1
+sets,rep.tuple,0,0,0,class<`tuple`>,1
+sets,rep.tuple,1,0,0,...,1
+sets,.S.,-1,0,0,double[],1
+sets,.S.,0,0,0,double[],1
+sets,.S.,1,0,0,double[],1
+sets,set,-1,0,0,"class<`cset`, `gset`, `set`>",1
+sets,set,0,0,0,...,1
+sets,.set,-1,0,0,"class<`cset`, `gset`, `set`>",1
+sets,.set,0,0,0,...,1
+sets,[<-.set,-1,0,0,"class<`cset`, `gset`, `set`>",1
+sets,[<-.set,0,0,0,"class<`cset`, `gset`, `set`>",1
+sets,[<-.set,1,0,0,double[],1
+sets,[<-.set,2,0,0,character[],1
+sets,[.set,-1,0,0,"class<`cset`, `gset`, `set`>",1
+sets,[.set,0,0,0,"class<`cset`, `gset`, `set`>",1
+sets,[.set,1,0,0,list<character | double>,1
+sets,[[<-.set,-1,0,0,"class<`cset`, `gset`, `set`>",1
+sets,[[<-.set,0,0,0,"class<`cset`, `gset`, `set`>",1
+sets,[[<-.set,1,0,0,class<`function`>,1
+sets,[[<-.set,1,0,1,list<double>,1
+sets,[[<-.set,2,0,0,character,1
+sets,[[.set,-1,0,0,double,1
+sets,[[.set,0,0,0,"class<`cset`, `gset`, `set`>",1
+sets,[[.set,1,0,0,character,1
+sets,.set_bound,-1,0,0,"class<`cset`, `gset`>",1
+sets,.set_bound,0,0,0,"class<`cset`, `gset`>",1
+sets,.set_bound,1,0,0,double,1
+sets,set_cardinality,-1,0,0,integer,1
+sets,set_cardinality,0,0,0,class<`cset`>,1
+sets,set_cardinality,0,0,1,"class<`cset`, `gset`>",1
+sets,set_cardinality,0,0,2,^character[],1
+sets,set_cardinality,0,0,3,"class<`cset`, `gset`, `set`>",1
+sets,set_cardinality,0,0,4,"class<`factor`, `ordered`>",1
+sets,set_cardinality,0,0,5,class<`table`>,1
+sets,set_cardinality,0,0,6,class<`tuple`>,1
+sets,set_cardinality,0,0,7,^double[],1
+sets,set_cardinality,0,0,8,list<any>,1
+sets,set_cartesian,-1,0,0,"class<`cset`, `gset`, `set`>",1
+sets,set_cartesian,0,0,0,...,1
+sets,set_combn,-1,0,0,"class<`cset`, `gset`, `set`>",1
+sets,set_combn,0,0,0,"class<`cset`, `gset`, `set`>",1
+sets,set_combn,1,0,0,double,1
+sets,set_complement,-1,0,0,"class<`cset`, `gset`, `set`>",1
+sets,set_complement,0,0,0,class<`cset`>,1
+sets,set_complement,0,0,1,"class<`cset`, `gset`>",1
+sets,set_complement,0,0,2,"class<`cset`, `gset`, `set`>",1
+sets,set_complement,1,0,0,"class<`cset`, `gset`, `set`>",1
+sets,set_complement,1,0,1,class<`cset`>,1
+sets,.set_complement_using_matchfun,-1,0,0,"class<`cset`, `gset`, `set`>",1
+sets,.set_complement_using_matchfun,0,0,0,class<`cset`>,1
+sets,.set_complement_using_matchfun,0,0,1,"class<`cset`, `gset`>",1
+sets,.set_complement_using_matchfun,0,0,2,"class<`cset`, `gset`, `set`>",1
+sets,.set_complement_using_matchfun,1,0,0,"class<`cset`, `gset`, `set`>",1
+sets,.set_complement_using_matchfun,1,0,1,class<`cset`>,1
+sets,.set_complement_using_matchfun,2,0,0,class<`function`>,1
+sets,set_contains_element,-1,0,0,logical[],1
+sets,set_contains_element,0,0,0,"class<`cset`, `gset`, `set`>",1
+sets,set_contains_element,1,0,0,integer[],1
+sets,set_contains_element,1,0,1,class<`tuple`>,1
+sets,set_dissimilarity,-1,0,0,double,1
+sets,set_dissimilarity,0,0,0,"class<`cset`, `gset`, `set`>",1
+sets,set_dissimilarity,1,0,0,"class<`cset`, `gset`, `set`>",1
+sets,set_dissimilarity,2,0,0,character[],1
+sets,.set_intersection,-1,0,0,"class<`cset`, `gset`, `set`>",1
+sets,.set_intersection,0,0,0,list<class<`cset`>>,1
+sets,.set_intersection,0,0,1,"list<class<`cset`, `gset`>>",1
+sets,.set_intersection,0,0,2,"list<class<`cset`, `gset`> | class<`cset`, `gset`, `set`>>",1
+sets,.set_intersection,0,0,3,"list<class<`cset`, `gset`, `set`> | class<`cset`, `gset`>>",1
+sets,.set_intersection,0,0,4,"list<class<`cset`, `gset`, `set`>>",1
+sets,.set_intersection,1,0,0,any,1
+sets,set_intersection,-1,0,0,"class<`cset`, `gset`, `set`>",1
+sets,set_intersection,0,0,0,...,1
+sets,set_is_empty,-1,0,0,logical,1
+sets,set_is_empty,0,0,0,class<`cset`>,1
+sets,set_is_empty,0,0,1,"class<`cset`, `gset`>",1
+sets,set_is_empty,0,0,2,"class<`cset`, `gset`, `set`>",1
+sets,set_is_equal,-1,0,0,logical,1
+sets,set_is_equal,0,0,0,"class<`cset`, `gset`, `set`>",1
+sets,set_is_equal,1,0,0,"class<`cset`, `gset`, `set`>",1
+sets,set_is_proper_subset,-1,0,0,logical,1
+sets,set_is_proper_subset,0,0,0,"class<`cset`, `gset`, `set`>",1
+sets,set_is_proper_subset,1,0,0,"class<`cset`, `gset`, `set`>",1
+sets,set_is_subset,-1,0,0,logical,1
+sets,set_is_subset,0,0,0,class<`cset`>,1
+sets,set_is_subset,0,0,1,"class<`cset`, `gset`, `set`>",1
+sets,set_is_subset,1,0,0,class<`cset`>,1
+sets,set_is_subset,1,0,1,"class<`cset`, `gset`, `set`>",1
+sets,.set_memberships,-1,0,0,"class<`cset`, `gset`>",1
+sets,.set_memberships,0,0,0,"class<`cset`, `gset`>",1
+sets,.set_memberships,1,0,0,double[],1
+sets,.set_memberships,1,0,1,"list<class<`cset`, `gset`>>",1
+sets,set_outer,-1,0,0,class<`matrix`>,1
+sets,set_outer,0,0,0,character[],1
+sets,set_outer,0,0,1,"class<`cset`, `gset`>",1
+sets,set_outer,0,0,2,"class<`cset`, `gset`, `set`>",1
+sets,set_outer,0,0,3,list<list<double>>,1
+sets,set_outer,0,0,4,"list<class<`cset`, `gset`> | class<`cset`, `gset`, `set`>>",1
+sets,set_outer,0,0,5,class<`tuple`>,1
+sets,set_outer,0,0,6,integer[],1
+sets,set_outer,1,0,0,"list<class<`cset`, `gset`> | class<`cset`, `gset`, `set`>>",1
+sets,set_outer,1,0,1,class<`function`>,1
+sets,set_outer,1,0,2,"class<`cset`, `gset`, `set`>",1
+sets,set_outer,1,0,3,list<list<double>>,1
+sets,set_outer,1,0,4,class<`tuple`>,1
+sets,set_outer,1,0,5,integer[],1
+sets,set_outer,2,0,0,class<`function`>,1
+sets,set_outer,2,0,1,character,1
+sets,set_outer,3,0,0,...,1
+sets,set_outer,4,0,0,logical,1
+sets,set_outer,5,0,0,logical,1
+sets,set_similarity,-1,0,0,double,1
+sets,set_similarity,0,0,0,"class<`cset`, `gset`, `set`>",1
+sets,set_similarity,1,0,0,"class<`cset`, `gset`, `set`>",1
+sets,set_similarity,2,0,0,character,1
+sets,sets_options,-1,0,0,character,1
+sets,sets_options,-1,0,1,class<`function`>,1
+sets,sets_options,-1,0,2,double[],1
+sets,sets_options,-1,0,3,null,1
+sets,sets_options,-1,0,4,list<logical | character>,1
+sets,sets_options,0,0,0,any,1
+sets,sets_options,1,0,0,any,1
+sets,set_symdiff,-1,0,0,"class<`cset`, `gset`, `set`>",1
+sets,set_symdiff,0,0,0,...,1
+sets,set_union,-1,0,0,"class<`cset`, `gset`, `set`>",1
+sets,set_union,0,0,0,...,1
+sets,.set_universe,-1,0,0,"class<`cset`, `gset`>",1
+sets,.set_universe,0,0,0,"class<`cset`, `gset`>",1
+sets,.set_universe,1,0,0,"class<`cset`, `gset`, `set`>",1
+sets,.simplify_interval,-1,0,0,list<list<double>>,1
+sets,.simplify_interval,0,0,0,list<list<double>>,1
+sets,.simplify_interval,1,0,0,logical,1
+sets,.sort_interval,-1,0,0,list<list<double>>,1
+sets,.sort_interval,0,0,0,list<list<double>>,1
+sets,.stop_if_memberships_are_invalid,-1,0,0,null,1
+sets,.stop_if_memberships_are_invalid,0,0,0,class<`table`>,1
+sets,.stop_if_memberships_are_invalid,0,0,1,double[],1
+sets,.stop_if_memberships_are_invalid,0,0,2,"list<class<`cset`, `gset`>>",1
+sets,.stop_if_memberships_are_invalid,0,0,3,"list<class<`cset`, `gset`, `set`>>",1
+sets,.stop_if_memberships_are_invalid,0,0,4,"list<double[] | class<`cset`, `gset`>>",1
+sets,.stop_if_memberships_are_invalid,0,0,5,list<double[]>,1
+sets,.stop_if_memberships_are_invalid,1,0,0,null,1
+sets,.stop_if_memberships_are_invalid,1,0,1,character,1
+sets,.structure,-1,0,0,class<`cset`>,1
+sets,.structure,-1,0,1,class<`cset_charfun`>,1
+sets,.structure,-1,0,2,"class<`cset`, `gset`>",1
+sets,.structure,-1,0,3,"class<`cset`, `gset`, `set`>",1
+sets,.structure,-1,0,4,class<`element`>,1
+sets,.structure,-1,0,5,class<`fuzzy_logic_family`>,1
+sets,.structure,-1,0,6,class<`fuzzy_rule`>,1
+sets,.structure,-1,0,7,class<`fuzzy_system`>,1
+sets,.structure,-1,0,8,"class<`fuzzy_variable`, `tuple`>",1
+sets,.structure,-1,0,9,class<`interval`>,1
+sets,.structure,-1,0,10,class<`tuple`>,1
+sets,.structure,-1,0,11,list<character>,1
+sets,.structure,-1,0,12,list<double>,1
+sets,.structure,0,0,0,"class<`cset`, `gset`>",1
+sets,.structure,0,0,1,"class<`cset`, `gset`, `set`>",1
+sets,.structure,0,0,2,class<`function`>,1
+sets,.structure,0,0,3,list<any>,1
+sets,.structure,0,0,4,class<`tuple`>,1
+sets,.structure,1,0,0,...,1
+sets,Summary.set,-1,0,0,double,1
+sets,Summary.set,-1,0,1,integer[],1
+sets,Summary.set,0,0,0,...,1
+sets,Summary.set,1,0,0,logical,1
+sets,Summary.tuple,-1,0,0,double,1
+sets,Summary.tuple,0,0,0,...,1
+sets,Summary.tuple,1,0,0,logical,1
+sets,.T.,-1,0,0,double[],1
+sets,.T.,0,0,0,double[],1
+sets,.T.,1,0,0,double[],1
+sets,triple,-1,0,0,class<`tuple`>,1
+sets,triple,0,0,0,...,1
+sets,tuple,-1,0,0,class<`tuple`>,1
+sets,tuple,0,0,0,...,1
+sets,tuple_is_ntuple,-1,0,0,logical,1
+sets,tuple_is_ntuple,0,0,0,class<`tuple`>,1
+sets,tuple_is_ntuple,1,0,0,double,1
+sets,tuple_is_triple,-1,0,0,logical,1
+sets,tuple_is_triple,0,0,0,class<`tuple`>,1
+sets,tuple_outer,-1,0,0,class<`matrix`>,1
+sets,tuple_outer,0,0,0,character[],1
+sets,tuple_outer,0,0,1,"class<`cset`, `gset`>",1
+sets,tuple_outer,0,0,2,"class<`cset`, `gset`, `set`>",1
+sets,tuple_outer,0,0,3,list<list<double>>,1
+sets,tuple_outer,0,0,4,"list<class<`cset`, `gset`> | class<`cset`, `gset`, `set`>>",1
+sets,tuple_outer,0,0,5,class<`tuple`>,1
+sets,tuple_outer,0,0,6,integer[],1
+sets,tuple_outer,1,0,0,"list<class<`cset`, `gset`> | class<`cset`, `gset`, `set`>>",1
+sets,tuple_outer,1,0,1,class<`function`>,1
+sets,tuple_outer,1,0,2,"class<`cset`, `gset`, `set`>",1
+sets,tuple_outer,1,0,3,list<list<double>>,1
+sets,tuple_outer,1,0,4,class<`tuple`>,1
+sets,tuple_outer,1,0,5,integer[],1
+sets,tuple_outer,2,0,0,class<`function`>,1
+sets,tuple_outer,2,0,1,character,1
+sets,tuple_outer,3,0,0,...,1
+sets,tuple_outer,4,0,0,logical,1
+sets,tuple_outer,5,0,0,logical,1
+settings,clone_and_merge,-1,0,0,class<`function`>,1
+settings,clone_and_merge,0,0,0,class<`function`>,1
+settings,clone_and_merge,1,0,0,...,1
+settings,inlist,-1,0,0,class<`function`>,1
+settings,inlist,0,0,0,...,1
+settings,inrange,-1,0,0,class<`function`>,1
+settings,inrange,0,0,0,double,1
+settings,inrange,1,0,0,double,1
+settings,is_setting,-1,0,0,logical,1
+settings,is_setting,0,0,0,...,1
+settings,options_manager,-1,0,0,class<`function`>,1
+settings,options_manager,0,0,0,...,1
+settings,options_manager,1,0,0,any,1
+settings,reset,-1,0,0,list<double>,1
+settings,reset,-1,0,1,list<double | character>,1
+settings,reset,0,0,0,class<`function`>,1
+settings,reset_options,-1,0,0,list<any>,1
+settings,reset_par,-1,0,0,list<character | double[] | null>,1
+settings,stop_if_reserved,-1,0,0,logical[],1
+settings,stop_if_reserved,0,0,0,...,1
+sfsmisc,%||%,-1,0,0,character[],1
+sfsmisc,%||%,-1,0,1,null,1
+sfsmisc,%||%,0,0,0,character[],1
+sfsmisc,%||%,0,0,1,null,1
+sfsmisc,%||%,1,0,0,any,1
+sfsmisc,AsciiToInt,-1,0,0,^integer[],1
+sfsmisc,AsciiToInt,0,0,0,character[],1
+sfsmisc,as.intBase,-1,0,0,double[],1
+sfsmisc,as.intBase,0,0,0,character[],1
+sfsmisc,as.intBase,0,0,1,class<`basedInt`>,1
+sfsmisc,as.intBase,1,0,0,any,1
+sfsmisc,as.integer.basedInt,-1,0,0,double[],1
+sfsmisc,as.integer.basedInt,0,0,0,class<`basedInt`>,1
+sfsmisc,as.integer.basedInt,1,0,0,...,1
+sfsmisc,axTexpr,-1,0,0,expression,1
+sfsmisc,axTexpr,0,0,0,double,1
+sfsmisc,axTexpr,1,0,0,double[],1
+sfsmisc,axTexpr,2,0,0,null,1
+sfsmisc,axTexpr,3,0,0,null,1
+sfsmisc,axTexpr,4,0,0,null,1
+sfsmisc,axTexpr,5,0,0,logical,1
+sfsmisc,bi2int,-1,0,0,double[],1
+sfsmisc,bi2int,0,0,0,list<integer[]>,1
+sfsmisc,bi2int,0,0,1,class<`array`>,1
+sfsmisc,bi2int,1,0,0,any,1
+sfsmisc,capture.and.write,-1,0,0,character[],1
+sfsmisc,capture.and.write,0,0,0,class<`matrix`>,1
+sfsmisc,capture.and.write,1,0,0,double,1
+sfsmisc,capture.and.write,2,0,0,double,1
+sfsmisc,capture.and.write,3,0,0,double,1
+sfsmisc,capture.and.write,3,0,1,null,1
+sfsmisc,capture.and.write,4,0,0,any,1
+sfsmisc,capture.and.write,5,0,0,character,1
+sfsmisc,capture.and.write,6,0,0,double,1
+sfsmisc,ccat,-1,0,0,character,1
+sfsmisc,ccat,0,0,0,...,1
+sfsmisc,chars8bit,-1,0,0,character[],1
+sfsmisc,chars8bit,0,0,0,integer[],1
+sfsmisc,code2n,-1,0,0,double[],1
+sfsmisc,code2n,0,0,0,character[],1
+sfsmisc,code2n,1,0,0,double,1
+sfsmisc,code2n,2,0,0,character[],1
+sfsmisc,compresid2way,-1,0,0,list<class<`data.frame`> | list<double[]>>,1
+sfsmisc,compresid2way,0,0,0,"class<`aov`, `lm`>",1
+sfsmisc,compresid2way,0,0,1,class<`formula`>,1
+sfsmisc,compresid2way,1,0,0,null,1
+sfsmisc,compresid2way,1,0,1,class<`data.frame`>,1
+sfsmisc,compresid2way,2,0,0,integer[],1
+sfsmisc,compresid2way,2,0,1,character[],1
+sfsmisc,compresid2way,3,0,0,logical,1
+sfsmisc,compresid2way,4,0,0,logical,1
+sfsmisc,compresid2way,5,0,0,null,1
+sfsmisc,compresid2way,6,0,0,null,1
+sfsmisc,compresid2way,7,0,0,null,1
+sfsmisc,cum.Vert.funkt,-1,0,0,list<double[]>,1
+sfsmisc,cum.Vert.funkt,0,0,0,double[],1
+sfsmisc,cum.Vert.funkt,1,0,0,logical,1
+sfsmisc,cum.Vert.funkt,2,0,0,logical,1
+sfsmisc,cum.Vert.funkt,3,0,0,logical,1
+sfsmisc,cum.Vert.funkt,4,0,0,logical,1
+sfsmisc,cum.Vert.funkt,5,0,0,character,1
+sfsmisc,cum.Vert.funkt,6,0,0,character,1
+sfsmisc,cum.Vert.funkt,7,0,0,...,1
+sfsmisc,D1D2,-1,0,0,list<double[]>,1
+sfsmisc,D1D2,0,0,0,double[],1
+sfsmisc,D1D2,1,0,0,double[],1
+sfsmisc,D1D2,2,0,0,double[],1
+sfsmisc,D1D2,3,0,0,double,1
+sfsmisc,D1D2,4,0,0,integer[],1
+sfsmisc,D1D2,5,0,0,null,1
+sfsmisc,D1ss,-1,0,0,double[],1
+sfsmisc,D1ss,0,0,0,double[],1
+sfsmisc,D1ss,1,0,0,double[],1
+sfsmisc,D1ss,2,0,0,double[],1
+sfsmisc,D1ss,3,0,0,double,1
+sfsmisc,D1ss,4,0,0,null,1
+sfsmisc,D2ss,-1,0,0,list<double[]>,1
+sfsmisc,D2ss,0,0,0,double[],1
+sfsmisc,D2ss,1,0,0,double[],1
+sfsmisc,D2ss,2,0,0,double[],1
+sfsmisc,D2ss,3,0,0,double,1
+sfsmisc,D2ss,4,0,0,null,1
+sfsmisc,dDA,-1,0,0,class<`dDA`>,1
+sfsmisc,dDA,0,0,0,class<`data.frame`>,1
+sfsmisc,dDA,0,0,1,class<`matrix`>,1
+sfsmisc,dDA,1,0,0,double[],1
+sfsmisc,dDA,2,0,0,logical,1
+sfsmisc,dev.latex,-1,0,0,list<list<double[]>>,1
+sfsmisc,dev.latex,0,0,0,character,1
+sfsmisc,dev.latex,1,0,0,class<`function`>,1
+sfsmisc,dev.latex,2,0,0,double,1
+sfsmisc,dev.latex,3,0,0,double,1
+sfsmisc,dev.latex,4,0,0,logical,1
+sfsmisc,dev.latex,5,0,0,logical,1
+sfsmisc,dev.latex,6,0,0,character,1
+sfsmisc,dev.latex,7,0,0,null,1
+sfsmisc,diagDA,-1,0,0,^integer[],1
+sfsmisc,diagDA,0,0,0,class<`matrix`>,1
+sfsmisc,diagDA,0,0,1,class<`data.frame`>,1
+sfsmisc,diagDA,1,0,0,double[],1
+sfsmisc,diagDA,2,0,0,class<`matrix`>,1
+sfsmisc,diagDA,2,0,1,class<`data.frame`>,1
+sfsmisc,diagDA,3,0,0,logical,1
+sfsmisc,diagX,-1,0,0,class<`matrix`>,1
+sfsmisc,diagX,0,0,0,double,1
+sfsmisc,digitsBase,-1,0,0,class<`basedInt`>,1
+sfsmisc,digitsBase,0,0,0,double[],1
+sfsmisc,digitsBase,1,0,0,double,1
+sfsmisc,digitsBase,2,0,0,double,1
+sfsmisc,Duplicated,-1,0,0,^integer[],1
+sfsmisc,Duplicated,0,0,0,integer[],1
+sfsmisc,Duplicated,1,0,0,logical,1
+sfsmisc,Duplicated,2,0,0,logical,1
+sfsmisc,Duplicated,3,0,0,null,1
+sfsmisc,eaxis,-1,0,0,double[],1
+sfsmisc,eaxis,-1,0,1,null,1
+sfsmisc,eaxis,0,0,0,double,1
+sfsmisc,eaxis,1,0,0,double[],1
+sfsmisc,eaxis,2,0,0,logical,1
+sfsmisc,eaxis,2,0,1,null,1
+sfsmisc,eaxis,2,0,2,expression,1
+sfsmisc,eaxis,3,0,0,null,1
+sfsmisc,eaxis,4,0,0,any,1
+sfsmisc,eaxis,5,0,0,any,1
+sfsmisc,eaxis,6,0,0,null,1
+sfsmisc,eaxis,6,0,1,logical,1
+sfsmisc,eaxis,7,0,0,null,1
+sfsmisc,ecdf.ksCI,-1,0,0,list<double[]>,1
+sfsmisc,ecdf.ksCI,0,0,0,double[],1
+sfsmisc,ecdf.ksCI,1,0,0,null,1
+sfsmisc,ecdf.ksCI,2,0,0,null,1
+sfsmisc,ecdf.ksCI,3,0,0,character,1
+sfsmisc,ecdf.ksCI,4,0,0,character,1
+sfsmisc,ecdf.ksCI,5,0,0,...,1
+sfsmisc,ellipsePoints,-1,0,0,class<`matrix`>,1
+sfsmisc,ellipsePoints,0,0,0,double,1
+sfsmisc,ellipsePoints,1,0,0,double,1
+sfsmisc,ellipsePoints,2,0,0,double,1
+sfsmisc,ellipsePoints,3,0,0,double[],1
+sfsmisc,ellipsePoints,4,0,0,double,1
+sfsmisc,ellipsePoints,5,0,0,logical,1
+sfsmisc,empty.dimnames,-1,0,0,class<`basedInt`>,1
+sfsmisc,empty.dimnames,-1,0,1,class<`matrix`>,1
+sfsmisc,empty.dimnames,0,0,0,class<`basedInt`>,1
+sfsmisc,empty.dimnames,0,0,1,class<`matrix`>,1
+sfsmisc,errbar,-1,0,0,null,1
+sfsmisc,errbar,0,0,0,integer[],1
+sfsmisc,errbar,1,0,0,double[],1
+sfsmisc,errbar,2,0,0,double[],1
+sfsmisc,errbar,3,0,0,double[],1
+sfsmisc,errbar,4,0,0,double,1
+sfsmisc,errbar,5,0,0,double[],1
+sfsmisc,errbar,6,0,0,character,1
+sfsmisc,errbar,7,0,0,character,1
+sfsmisc,factorize,-1,0,0,list<class<`matrix`>>,1
+sfsmisc,factorize,0,0,0,double[],1
+sfsmisc,factorize,1,0,0,logical,1
+sfsmisc,f.robftest,-1,0,0,class<`htest`>,1
+sfsmisc,f.robftest,0,0,0,"class<`lm`, `rlm`>",1
+sfsmisc,f.robftest,1,0,0,double,1
+sfsmisc,funEnv,-1,0,0,environment,1
+sfsmisc,funEnv,0,0,0,...,1
+sfsmisc,funEnv,1,0,0,null,1
+sfsmisc,funEnv,2,0,0,environment,1
+sfsmisc,funEnv,3,0,0,logical,1
+sfsmisc,funEnv,4,0,0,integer,1
+sfsmisc,hatMat,-1,0,0,class<`matrix`>,1
+sfsmisc,hatMat,-1,0,1,double,1
+sfsmisc,hatMat,0,0,0,integer[],1
+sfsmisc,hatMat,1,0,0,logical,1
+sfsmisc,hatMat,2,0,0,class<`function`>,1
+sfsmisc,hatMat,3,0,0,...,1
+sfsmisc,histBxp,-1,0,0,null,1
+sfsmisc,histBxp,0,0,0,double[],1
+sfsmisc,histBxp,1,0,0,any,1
+sfsmisc,histBxp,2,0,0,any,1
+sfsmisc,histBxp,3,0,0,logical,1
+sfsmisc,histBxp,4,0,0,logical,1
+sfsmisc,histBxp,5,0,0,character,1
+sfsmisc,histBxp,6,0,0,...,1
+sfsmisc,histBxp,7,0,0,double,1
+sfsmisc,integrate.xy,-1,0,0,double,1
+sfsmisc,integrate.xy,0,0,0,double[],1
+sfsmisc,integrate.xy,1,0,0,double[],1
+sfsmisc,integrate.xy,2,0,0,any,1
+sfsmisc,integrate.xy,3,0,0,any,1
+sfsmisc,integrate.xy,4,0,0,logical,1
+sfsmisc,integrate.xy,5,0,0,double,1
+sfsmisc,inv.seq,-1,0,0,class<`call`>,1
+sfsmisc,inv.seq,0,0,0,double[],1
+sfsmisc,is.whole,-1,0,0,class<`array`>,1
+sfsmisc,is.whole,-1,0,1,class<`matrix`>,1
+sfsmisc,is.whole,-1,0,2,logical[],1
+sfsmisc,is.whole,0,0,0,class<`array`>,1
+sfsmisc,is.whole,0,0,1,class<`matrix`>,1
+sfsmisc,is.whole,0,0,2,complex[],1
+sfsmisc,is.whole,1,0,0,any,1
+sfsmisc,iterate.lin.recursion,-1,0,0,double[],1
+sfsmisc,iterate.lin.recursion,0,0,0,double,1
+sfsmisc,iterate.lin.recursion,0,0,1,integer[],1
+sfsmisc,iterate.lin.recursion,1,0,0,double[],1
+sfsmisc,iterate.lin.recursion,2,0,0,double,1
+sfsmisc,iterate.lin.recursion,3,0,0,double,1
+sfsmisc,KSd,-1,0,0,double[],1
+sfsmisc,KSd,0,0,0,double[],1
+sfsmisc,last,-1,0,0,^double[],1
+sfsmisc,last,-1,0,1,null,1
+sfsmisc,last,0,0,0,^double[],1
+sfsmisc,last,1,0,0,double,1
+sfsmisc,last,2,0,0,logical,1
+sfsmisc,linesHyperb.lm,-1,0,0,null,1
+sfsmisc,linesHyperb.lm,0,0,0,class<`lm`>,1
+sfsmisc,linesHyperb.lm,1,0,0,double,1
+sfsmisc,linesHyperb.lm,2,0,0,logical,1
+sfsmisc,linesHyperb.lm,3,0,0,double,1
+sfsmisc,linesHyperb.lm,4,0,0,character,1
+sfsmisc,linesHyperb.lm,4,0,1,double,1
+sfsmisc,linesHyperb.lm,5,0,0,double,1
+sfsmisc,linesHyperb.lm,6,0,0,logical,1
+sfsmisc,lseq,-1,0,0,double[],1
+sfsmisc,lseq,0,0,0,double,1
+sfsmisc,lseq,1,0,0,double,1
+sfsmisc,lseq,2,0,0,double,1
+sfsmisc,margin2table,-1,0,0,"class<`margin2table`, `table`>",1
+sfsmisc,margin2table,0,0,0,class<`matrix`>,1
+sfsmisc,margin2table,0,0,1,class<`table`>,1
+sfsmisc,margin2table,1,0,0,character,1
+sfsmisc,margin2table,2,0,0,logical,1
+sfsmisc,mat2tex,-1,0,0,null,1
+sfsmisc,mat2tex,0,0,0,class<`matrix`>,1
+sfsmisc,mat2tex,1,0,0,character,1
+sfsmisc,mat2tex,1,0,1,"class<`connection`, `terminal`>",1
+sfsmisc,mat2tex,2,0,0,character,1
+sfsmisc,mat2tex,3,0,0,character,1
+sfsmisc,mat2tex,4,0,0,character[],1
+sfsmisc,mat2tex,5,0,0,logical,1
+sfsmisc,mat2tex,6,0,0,double,1
+sfsmisc,mat2tex,7,0,0,any,1
+sfsmisc,missingCh,-1,0,0,logical,1
+sfsmisc,missingCh,0,0,0,character,1
+sfsmisc,missingCh,1,0,0,environment,1
+sfsmisc,mpl,-1,0,0,double[],1
+sfsmisc,mpl,0,0,0,class<`data.frame`>,1
+sfsmisc,mpl,1,0,0,...,1
+sfsmisc,mult.fig,-1,0,0,list<list<double[]>>,1
+sfsmisc,mult.fig,0,0,0,any,1
+sfsmisc,mult.fig,1,0,0,any,1
+sfsmisc,mult.fig,2,0,0,any,1
+sfsmisc,mult.fig,3,0,0,double[],1
+sfsmisc,mult.fig,4,0,0,double[],1
+sfsmisc,mult.fig,5,0,0,double[],1
+sfsmisc,mult.fig,6,0,0,double[],1
+sfsmisc,mult.fig,7,0,0,character,1
+sfsmisc,mult.fig,7,0,1,expression,1
+sfsmisc,mult.fig,7,0,2,null,1
+sfsmisc,n.code,-1,0,0,character[],1
+sfsmisc,n.code,0,0,0,double[],1
+sfsmisc,n.code,1,0,0,double,1
+sfsmisc,n.code,2,0,0,character[],1
+sfsmisc,nearcor,-1,0,0,class<`nearcor`>,1
+sfsmisc,nearcor,0,0,0,class<`matrix`>,1
+sfsmisc,nearcor,1,0,0,double,1
+sfsmisc,nearcor,2,0,0,double,1
+sfsmisc,nearcor,3,0,0,double,1
+sfsmisc,nearcor,4,0,0,double,1
+sfsmisc,nearcor,5,0,0,logical,1
+sfsmisc,n.plot,-1,0,0,character[],1
+sfsmisc,n.plot,0,0,0,class<`data.frame`>,1
+sfsmisc,n.plot,0,0,1,double[],1
+sfsmisc,n.plot,1,0,0,null,1
+sfsmisc,n.plot,1,0,1,double[],1
+sfsmisc,n.plot,2,0,0,null,1
+sfsmisc,n.plot,2,0,1,character,1
+sfsmisc,n.plot,3,0,0,logical,1
+sfsmisc,n.plot,4,0,0,null,1
+sfsmisc,n.plot,4,0,1,character,1
+sfsmisc,n.plot,5,0,0,null,1
+sfsmisc,n.plot,5,0,1,character,1
+sfsmisc,n.plot,6,0,0,character,1
+sfsmisc,n.plot,7,0,0,double,1
+sfsmisc,nr.sign.chg,-1,0,0,integer,1
+sfsmisc,nr.sign.chg,0,0,0,integer[],1
+sfsmisc,p.arrows,-1,0,0,null,1
+sfsmisc,p.arrows,0,0,0,double[],1
+sfsmisc,p.arrows,1,0,0,double[],1
+sfsmisc,p.arrows,2,0,0,double[],1
+sfsmisc,p.arrows,3,0,0,double[],1
+sfsmisc,p.arrows,4,0,0,double,1
+sfsmisc,p.arrows,5,0,0,double,1
+sfsmisc,p.arrows,6,0,0,character,1
+sfsmisc,p.arrows,7,0,0,...,1
+sfsmisc,paste.vec,-1,0,0,character,1
+sfsmisc,paste.vec,0,0,0,integer[],1
+sfsmisc,paste.vec,1,0,0,integer,1
+sfsmisc,p.datum,-1,0,0,null,1
+sfsmisc,p.datum,0,0,0,logical,1
+sfsmisc,p.datum,1,0,0,double,1
+sfsmisc,p.datum,2,0,0,...,1
+sfsmisc,p.dchisq,-1,0,0,null,1
+sfsmisc,p.dchisq,0,0,0,double,1
+sfsmisc,p.dchisq,1,0,0,character,1
+sfsmisc,p.dchisq,2,0,0,...,1
+sfsmisc,p.dgamma,-1,0,0,null,1
+sfsmisc,p.dgamma,0,0,0,integer,1
+sfsmisc,p.dgamma,1,0,0,character,1
+sfsmisc,p.dgamma,2,0,0,...,1
+sfsmisc,p.dnorm,-1,0,0,null,1
+sfsmisc,p.dnorm,0,0,0,double,1
+sfsmisc,p.dnorm,1,0,0,double,1
+sfsmisc,p.dnorm,2,0,0,character,1
+sfsmisc,p.dnorm,3,0,0,logical,1
+sfsmisc,p.dnorm,4,0,0,character,1
+sfsmisc,p.dnorm,5,0,0,...,1
+sfsmisc,p.hboxp,-1,0,0,null,1
+sfsmisc,p.hboxp,0,0,0,double[],1
+sfsmisc,p.hboxp,1,0,0,double[],1
+sfsmisc,p.hboxp,2,0,0,any,1
+sfsmisc,p.hboxp,3,0,0,double,1
+sfsmisc,p.hboxp,4,0,0,double,1
+sfsmisc,p.hboxp,5,0,0,double,1
+sfsmisc,p.hboxp,6,0,0,double,1
+sfsmisc,p.hboxp,7,0,0,double,1
+sfsmisc,pkgLibs,-1,0,0,list<list<character[]>>,1
+sfsmisc,pkgLibs,0,0,0,character[],1
+sfsmisc,pkgLibs,1,0,0,character,1
+sfsmisc,plotDS,-1,0,0,null,1
+sfsmisc,plotDS,0,0,0,double[],1
+sfsmisc,plotDS,1,0,0,double[],1
+sfsmisc,plotDS,2,0,0,double[],1
+sfsmisc,plotDS,2,0,1,list<double[]>,1
+sfsmisc,plotDS,3,0,0,character,1
+sfsmisc,plotDS,4,0,0,character,1
+sfsmisc,plotDS,5,0,0,double[],1
+sfsmisc,plotDS,6,0,0,logical,1
+sfsmisc,plotDS,7,0,0,logical,1
+sfsmisc,plotStep,-1,0,0,list<double[]>,1
+sfsmisc,plotStep,0,0,0,double[],1
+sfsmisc,plotStep,1,0,0,any,1
+sfsmisc,plotStep,2,0,0,logical,1
+sfsmisc,plotStep,3,0,0,logical,1
+sfsmisc,plotStep,4,0,0,logical,1
+sfsmisc,plotStep,5,0,0,logical,1
+sfsmisc,plotStep,6,0,0,logical,1
+sfsmisc,plotStep,7,0,0,logical,1
+sfsmisc,polyn.eval,-1,0,0,class<`matrix`>,1
+sfsmisc,polyn.eval,-1,0,1,double[],1
+sfsmisc,polyn.eval,0,0,0,class<`matrix`>,1
+sfsmisc,polyn.eval,0,0,1,double[],1
+sfsmisc,polyn.eval,1,0,0,any,1
+sfsmisc,posdefify,-1,0,0,class<`matrix`>,1
+sfsmisc,posdefify,0,0,0,class<`matrix`>,1
+sfsmisc,posdefify,1,0,0,character[],1
+sfsmisc,posdefify,2,0,0,logical,1
+sfsmisc,posdefify,3,0,0,class<`eigen`>,1
+sfsmisc,posdefify,4,0,0,double,1
+sfsmisc,p.profileTraces,-1,0,0,null,1
+sfsmisc,p.profileTraces,0,0,0,"class<`profile`, `profile.nls`>",1
+sfsmisc,p.profileTraces,1,0,0,double,1
+sfsmisc,p.profileTraces,2,0,0,character,1
+sfsmisc,predict.dDA,-1,0,0,^integer[],1
+sfsmisc,predict.dDA,0,0,0,class<`dDA`>,1
+sfsmisc,predict.dDA,1,0,0,class<`matrix`>,1
+sfsmisc,predict.dDA,1,0,1,class<`data.frame`>,1
+sfsmisc,predict.dDA,2,0,0,logical,1
+sfsmisc,predict.dDA,3,0,0,...,1
+sfsmisc,p.res.2fact,-1,0,0,null,1
+sfsmisc,p.res.2fact,0,0,0,class<`factor`>,1
+sfsmisc,p.res.2fact,1,0,0,class<`factor`>,1
+sfsmisc,p.res.2fact,2,0,0,double[],1
+sfsmisc,p.res.2fact,3,0,0,any,1
+sfsmisc,p.res.2fact,4,0,0,logical,1
+sfsmisc,p.res.2fact,5,0,0,null,1
+sfsmisc,p.res.2fact,5,0,1,character,1
+sfsmisc,p.res.2fact,6,0,0,null,1
+sfsmisc,p.res.2fact,6,0,1,character,1
+sfsmisc,p.res.2fact,7,0,0,character,1
+sfsmisc,p.res.2x,-1,0,0,null,1
+sfsmisc,p.res.2x,0,0,0,class<`formula`>,1
+sfsmisc,p.res.2x,0,0,1,double[],1
+sfsmisc,p.res.2x,1,0,0,...,1
+sfsmisc,p.res.2x.default,-1,0,0,null,1
+sfsmisc,p.res.2x.default,0,0,0,double[],1
+sfsmisc,p.res.2x.default,1,0,0,double[],1
+sfsmisc,p.res.2x.default,2,0,0,double[],1
+sfsmisc,p.res.2x.default,3,0,0,null,1
+sfsmisc,p.res.2x.default,3,0,1,double,1
+sfsmisc,p.res.2x.default,4,0,0,double,1
+sfsmisc,p.res.2x.default,5,0,0,double,1
+sfsmisc,p.res.2x.default,6,0,0,character[],1
+sfsmisc,p.res.2x.default,6,0,1,integer[],1
+sfsmisc,p.res.2x.default,7,0,0,character,1
+sfsmisc,p.res.2x.default,7,0,1,null,1
+sfsmisc,p.res.2x.formula,-1,0,0,null,1
+sfsmisc,p.res.2x.formula,0,0,0,class<`formula`>,1
+sfsmisc,p.res.2x.formula,1,0,0,class<`lm`>,1
+sfsmisc,p.res.2x.formula,2,0,0,character,1
+sfsmisc,p.res.2x.formula,3,0,0,null,1
+sfsmisc,p.res.2x.formula,4,0,0,null,1
+sfsmisc,p.res.2x.formula,5,0,0,...,1
+sfsmisc,pretty10exp,-1,0,0,character[],1
+sfsmisc,pretty10exp,-1,0,1,expression,1
+sfsmisc,pretty10exp,0,0,0,double[],1
+sfsmisc,pretty10exp,1,0,0,logical,1
+sfsmisc,pretty10exp,2,0,0,double[],1
+sfsmisc,pretty10exp,2,0,1,character,1
+sfsmisc,pretty10exp,3,0,0,double,1
+sfsmisc,pretty10exp,4,0,0,any,1
+sfsmisc,pretty10exp,5,0,0,character[],1
+sfsmisc,pretty10exp,6,0,0,character[],1
+sfsmisc,primes,-1,0,0,integer[],1
+sfsmisc,primes,0,0,0,double,1
+sfsmisc,primes,1,0,0,null,1
+sfsmisc,print.margin2table,-1,0,0,"class<`margin2table`, `table`>",1
+sfsmisc,print.margin2table,0,0,0,"class<`margin2table`, `table`>",1
+sfsmisc,print.margin2table,1,0,0,double,1
+sfsmisc,print.margin2table,2,0,0,logical,1
+sfsmisc,print.margin2table,3,0,0,logical,1
+sfsmisc,print.margin2table,4,0,0,...,1
+sfsmisc,printTable2,-1,0,0,list<class<`table`> | class<`matrix`> | double>,1
+sfsmisc,printTable2,0,0,0,class<`table`>,1
+sfsmisc,printTable2,1,0,0,double,1
+sfsmisc,p.scales,-1,0,0,class<`matrix`>,1
+sfsmisc,p.scales,0,0,0,double,1
+sfsmisc,p.scales,1,0,0,double,1
+sfsmisc,ps.end,-1,0,0,character,1
+sfsmisc,ps.end,0,0,0,logical,1
+sfsmisc,ps.end,1,0,0,character,1
+sfsmisc,ps.end,2,0,0,any,1
+sfsmisc,ps.latex,-1,0,0,list<list<double[]>>,1
+sfsmisc,ps.latex,0,0,0,character,1
+sfsmisc,ps.latex,1,0,0,double,1
+sfsmisc,ps.latex,2,0,0,double,1
+sfsmisc,ps.latex,3,0,0,logical,1
+sfsmisc,ps.latex,4,0,0,logical,1
+sfsmisc,ps.latex,5,0,0,character,1
+sfsmisc,ps.latex,6,0,0,null,1
+sfsmisc,ps.latex,7,0,0,double[],1
+sfsmisc,p.tachoPlot,-1,0,0,null,1
+sfsmisc,p.tachoPlot,0,0,0,double[],1
+sfsmisc,p.tachoPlot,1,0,0,double[],1
+sfsmisc,p.tachoPlot,2,0,0,double[],1
+sfsmisc,p.tachoPlot,3,0,0,double[],1
+sfsmisc,p.tachoPlot,4,0,0,any,1
+sfsmisc,p.tachoPlot,5,0,0,character[],1
+sfsmisc,p.tachoPlot,6,0,0,logical,1
+sfsmisc,p.tachoPlot,7,0,0,logical,1
+sfsmisc,p.ts,-1,0,0,null,1
+sfsmisc,p.ts,0,0,0,"class<`matrix`, `mts`, `ts`>",1
+sfsmisc,p.ts,0,0,1,class<`ts`>,1
+sfsmisc,p.ts,0,0,2,double[],1
+sfsmisc,p.ts,1,0,0,double,1
+sfsmisc,p.ts,2,0,0,any,1
+sfsmisc,p.ts,3,0,0,null,1
+sfsmisc,p.ts,3,0,1,class<`Date`>,1
+sfsmisc,p.ts,4,0,0,logical,1
+sfsmisc,p.ts,5,0,0,logical,1
+sfsmisc,p.ts,6,0,0,any,1
+sfsmisc,p.ts,7,0,0,null,1
+sfsmisc,quadrant,-1,0,0,double[],1
+sfsmisc,quadrant,0,0,0,class<`matrix`>,1
+sfsmisc,quadrant,1,0,0,null,1
+sfsmisc,QUnif,-1,0,0,class<`matrix`>,1
+sfsmisc,QUnif,0,0,0,double,1
+sfsmisc,QUnif,1,0,0,double,1
+sfsmisc,QUnif,2,0,0,double,1
+sfsmisc,QUnif,3,0,0,double,1
+sfsmisc,QUnif,4,0,0,double,1
+sfsmisc,QUnif,5,0,0,double,1
+sfsmisc,QUnif,6,0,0,logical,1
+sfsmisc,read.org.table,-1,0,0,class<`data.frame`>,1
+sfsmisc,read.org.table,0,0,0,any,1
+sfsmisc,read.org.table,1,0,0,logical,1
+sfsmisc,read.org.table,2,0,0,double,1
+sfsmisc,read.org.table,3,0,0,character,1
+sfsmisc,read.org.table,4,0,0,character,1
+sfsmisc,read.org.table,5,0,0,character,1
+sfsmisc,read.org.table,6,0,0,...,1
+sfsmisc,repChar,-1,0,0,character,1
+sfsmisc,repChar,0,0,0,character,1
+sfsmisc,repChar,1,0,0,double,1
+sfsmisc,rot2,-1,0,0,class<`matrix`>,1
+sfsmisc,rot2,0,0,0,class<`matrix`>,1
+sfsmisc,rot2,0,0,1,double[],1
+sfsmisc,rot2,1,0,0,double,1
+sfsmisc,rotn,-1,0,0,character[],1
+sfsmisc,rotn,0,0,0,character[],1
+sfsmisc,rotn,1,0,0,double,1
+sfsmisc,roundfixS,-1,0,0,class<`difftime`>,1
+sfsmisc,roundfixS,-1,0,1,double[],1
+sfsmisc,roundfixS,0,0,0,class<`difftime`>,1
+sfsmisc,roundfixS,0,0,1,double[],1
+sfsmisc,roundfixS,1,0,0,character[],1
+sfsmisc,rrange,-1,0,0,double[],1
+sfsmisc,rrange,0,0,0,double[],1
+sfsmisc,rrange,1,0,0,double,1
+sfsmisc,rrange,2,0,0,double,1
+sfsmisc,rrange,3,0,0,logical,1
+sfsmisc,seqXtend,-1,0,0,class<`Date`>,1
+sfsmisc,seqXtend,-1,0,1,double[],1
+sfsmisc,seqXtend,0,0,0,class<`Date`>,1
+sfsmisc,seqXtend,0,0,1,double[],1
+sfsmisc,seqXtend,1,0,0,double,1
+sfsmisc,seqXtend,2,0,0,character[],1
+sfsmisc,seqXtend,3,0,0,null,1
+sfsmisc,seqXtend,4,0,0,null,1
+sfsmisc,sessionInfoX,-1,0,0,class<`sessionInfoX`>,1
+sfsmisc,sessionInfoX,0,0,0,character,1
+sfsmisc,sessionInfoX,0,0,1,null,1
+sfsmisc,sessionInfoX,1,0,0,logical,1
+sfsmisc,sessionInfoX,2,0,0,logical,1
+sfsmisc,.set.eps_view,-1,0,0,list<null>,1
+sfsmisc,sHalton,-1,0,0,double[],1
+sfsmisc,sHalton,0,0,0,double,1
+sfsmisc,sHalton,1,0,0,double,1
+sfsmisc,sHalton,2,0,0,double,1
+sfsmisc,sHalton,3,0,0,double,1
+sfsmisc,signi,-1,0,0,double[],1
+sfsmisc,signi,0,0,0,double[],1
+sfsmisc,signi,1,0,0,double,1
+sfsmisc,sourceAttach,-1,0,0,environment,1
+sfsmisc,sourceAttach,0,0,0,character,1
+sfsmisc,sourceAttach,1,0,0,double,1
+sfsmisc,sourceAttach,2,0,0,character,1
+sfsmisc,sourceAttach,3,0,0,logical,1
+sfsmisc,sourceAttach,4,0,0,logical,1
+sfsmisc,strcodes,-1,0,0,list<integer | null>,1
+sfsmisc,strcodes,-1,0,1,list<^integer[]>,1
+sfsmisc,strcodes,0,0,0,character[],1
+sfsmisc,strcodes,1,0,0,character[],1
+sfsmisc,str_data,-1,0,0,list<list<any>>,1
+sfsmisc,str_data,0,0,0,character[],1
+sfsmisc,str_data,1,0,0,any,1
+sfsmisc,str_data,2,0,0,...,1
+sfsmisc,Sys.cpuinfo,-1,0,0,class<`simple.list`>,1
+sfsmisc,Sys.memGB,-1,0,0,double,1
+sfsmisc,Sys.memGB,0,0,0,character,1
+sfsmisc,Sys.MIPS,-1,0,0,double,1
+sfsmisc,Sys.procinfo,-1,0,0,class<`simple.list`>,1
+sfsmisc,Sys.procinfo,0,0,0,character,1
+sfsmisc,Sys.ps,-1,0,0,character[],1
+sfsmisc,Sys.ps,0,0,0,integer,1
+sfsmisc,Sys.ps,1,0,0,character[],1
+sfsmisc,Sys.ps,2,0,0,logical,1
+sfsmisc,Sys.ps,3,0,0,character,1
+sfsmisc,Sys.ps,4,0,0,logical,1
+sfsmisc,Sys.ps,5,0,0,any,1
+sfsmisc,Sys.ps.cmd,-1,0,0,character,1
+sfsmisc,Sys.sizes,-1,0,0,integer[],1
+sfsmisc,Sys.sizes,0,0,0,integer,1
+sfsmisc,Sys.sizes,1,0,0,character,1
+sfsmisc,TA.plot,-1,0,0,null,1
+sfsmisc,TA.plot,0,0,0,"class<`aov`, `lm`>",1
+sfsmisc,TA.plot,0,0,1,"class<`glm`, `lm`>",1
+sfsmisc,TA.plot,0,0,2,class<`lm`>,1
+sfsmisc,TA.plot,1,0,0,double[],1
+sfsmisc,TA.plot,2,0,0,double[],1
+sfsmisc,TA.plot,3,0,0,null,1
+sfsmisc,TA.plot,3,0,1,character,1
+sfsmisc,TA.plot,4,0,0,character,1
+sfsmisc,TA.plot,5,0,0,character,1
+sfsmisc,TA.plot,6,0,0,logical,1
+sfsmisc,TA.plot,7,0,0,logical,1
+sfsmisc,tapplySimpl,-1,0,0,class<`array`>,1
+sfsmisc,tapplySimpl,0,0,0,double[],1
+sfsmisc,tapplySimpl,1,0,0,"list<class<`factor`, `ordered`>>",1
+sfsmisc,tapplySimpl,2,0,0,class<`function`>,1
+sfsmisc,tapplySimpl,3,0,0,...,1
+sfsmisc,toLatex.numeric,-1,0,0,character[],1
+sfsmisc,toLatex.numeric,0,0,0,double[],1
+sfsmisc,toLatex.numeric,1,0,0,double,1
+sfsmisc,toLatex.numeric,2,0,0,logical,1
+sfsmisc,toLatex.numeric,3,0,0,character,1
+sfsmisc,toLatex.numeric,4,0,0,...,1
+sfsmisc,u.boxplot.x,-1,0,0,double[],1
+sfsmisc,u.boxplot.x,0,0,0,double,1
+sfsmisc,u.boxplot.x,1,0,0,double[],1
+sfsmisc,u.boxplot.x,2,0,0,double,1
+sfsmisc,u.date,-1,0,0,character,1
+sfsmisc,u.date,0,0,0,logical,1
+sfsmisc,u.datumdecode,-1,0,0,class<`matrix`>,1
+sfsmisc,u.datumdecode,-1,0,1,double[],1
+sfsmisc,u.datumdecode,0,0,0,double[],1
+sfsmisc,u.datumdecode,1,0,0,character[],1
+sfsmisc,u.Datumvonheute,-1,0,0,character,1
+sfsmisc,u.Datumvonheute,0,0,0,double,1
+sfsmisc,u.Datumvonheute,1,0,0,double,1
+sfsmisc,u.log,-1,0,0,double[],1
+sfsmisc,u.log,0,0,0,double[],1
+sfsmisc,u.log,1,0,0,double,1
+sfsmisc,unif,-1,0,0,double[],1
+sfsmisc,unif,0,0,0,double,1
+sfsmisc,unif,1,0,0,double,1
+sfsmisc,uniqueL,-1,0,0,list<double[]>,1
+sfsmisc,uniqueL,0,0,0,double[],1
+sfsmisc,uniqueL,1,0,0,logical[],1
+sfsmisc,uniqueL,2,0,0,logical,1
+sfsmisc,u.sys,-1,0,0,character[],1
+sfsmisc,u.sys,0,0,0,...,1
+sfsmisc,u.sys,1,0,0,logical,1
+sfsmisc,vcat,-1,0,0,character,1
+sfsmisc,vcat,0,0,0,double[],1
+sfsmisc,vcat,1,0,0,character,1
+sfsmisc,wrapFormula,-1,0,0,class<`formula`>,1
+sfsmisc,wrapFormula,0,0,0,class<`formula`>,1
+sfsmisc,wrapFormula,1,0,0,class<`data.frame`>,1
+sfsmisc,wrapFormula,2,0,0,character,1
+sfsmisc,xy.grid,-1,0,0,class<`matrix`>,1
+sfsmisc,xy.grid,0,0,0,integer[],1
+sfsmisc,xy.grid,1,0,0,double[],1
+sfsmisc,xy.unique.x,-1,0,0,class<`matrix`>,1
+sfsmisc,xy.unique.x,0,0,0,double[],1
+sfsmisc,xy.unique.x,1,0,0,integer[],1
+sfsmisc,xy.unique.x,2,0,0,any,1
+sfsmisc,xy.unique.x,3,0,0,class<`function`>,1
+sfsmisc,xy.unique.x,4,0,0,...,1
+shape,Arrowhead,-1,0,0,null,1
+shape,Arrowhead,0,0,0,double[],1
+shape,Arrowhead,1,0,0,double[],1
+shape,Arrowhead,2,0,0,double[],1
+shape,Arrowhead,3,0,0,double[],1
+shape,Arrowhead,4,0,0,any,1
+shape,Arrowhead,5,0,0,double,1
+shape,Arrowhead,6,0,0,character,1
+shape,Arrowhead,7,0,0,character,1
+shape,Arrowhead,7,0,1,integer[],1
+shape,Arrowhead,8,0,0,double,1
+shape,Arrowhead,9,0,0,character[],1
+shape,Arrowhead,9,0,1,integer[],1
+shape,Arrowhead,10,0,0,double,1
+shape,Arrowhead,11,0,0,double,1
+shape,Arrowhead,12,0,0,...,1
+shape,Arrows,-1,0,0,null,1
+shape,Arrows,0,0,0,double[],1
+shape,Arrows,1,0,0,double[],1
+shape,Arrows,2,0,0,double[],1
+shape,Arrows,3,0,0,double[],1
+shape,Arrows,4,0,0,double,1
+shape,Arrows,5,0,0,double[],1
+shape,Arrows,6,0,0,any,1
+shape,Arrows,7,0,0,double,1
+shape,Arrows,8,0,0,character,1
+shape,Arrows,9,0,0,logical,1
+shape,Arrows,10,0,0,character,1
+shape,Arrows,11,0,0,any,1
+shape,Arrows,12,0,0,double,1
+shape,Arrows,13,0,0,any,1
+shape,Arrows,14,0,0,double,1
+shape,Arrows,15,0,0,double,1
+shape,Arrows,16,0,0,...,1
+shape,colorlegend,-1,0,0,list<double[]>,1
+shape,colorlegend,0,0,0,character[],1
+shape,colorlegend,1,0,0,double[],1
+shape,colorlegend,2,0,0,double,1
+shape,colorlegend,2,0,1,null,1
+shape,colorlegend,3,0,0,double,1
+shape,colorlegend,3,0,1,null,1
+shape,colorlegend,4,0,0,null,1
+shape,colorlegend,4,0,1,double[],1
+shape,colorlegend,5,0,0,logical,1
+shape,colorlegend,6,0,0,double[],1
+shape,colorlegend,7,0,0,double[],1
+shape,colorlegend,8,0,0,null,1
+shape,colorlegend,8,0,1,character,1
+shape,colorlegend,9,0,0,double,1
+shape,colorlegend,10,0,0,character,1
+shape,colorlegend,11,0,0,character,1
+shape,colorlegend,12,0,0,double,1
+shape,colorlegend,13,0,0,logical,1
+shape,colorlegend,14,0,0,...,1
+shape,cylindersegment,-1,0,0,null,1
+shape,cylindersegment,0,0,0,double,1
+shape,cylindersegment,1,0,0,double,1
+shape,cylindersegment,2,0,0,double,1
+shape,cylindersegment,3,0,0,double,1
+shape,cylindersegment,4,0,0,double,1
+shape,cylindersegment,5,0,0,double[],1
+shape,cylindersegment,6,0,0,double,1
+shape,cylindersegment,7,0,0,double,1
+shape,cylindersegment,8,0,0,character,1
+shape,cylindersegment,9,0,0,double,1
+shape,cylindersegment,10,0,0,...,1
+shape,drapecol,-1,0,0,character[],1
+shape,drapecol,0,0,0,class<`matrix`>,1
+shape,drapecol,1,0,0,character[],1
+shape,drapecol,2,0,0,character,1
+shape,drapecol,3,0,0,null,1
+shape,emptyplot,-1,0,0,null,1
+shape,emptyplot,0,0,0,double[],1
+shape,emptyplot,1,0,0,double[],1
+shape,emptyplot,2,0,0,double,1
+shape,emptyplot,3,0,0,logical,1
+shape,emptyplot,4,0,0,character,1
+shape,emptyplot,4,0,1,null,1
+shape,emptyplot,5,0,0,...,1
+shape,femmecol,-1,0,0,character[],1
+shape,femmecol,0,0,0,double,1
+shape,filledcircle,-1,0,0,null,1
+shape,filledcircle,0,0,0,double,1
+shape,filledcircle,1,0,0,double,1
+shape,filledcircle,2,0,0,double[],1
+shape,filledcircle,3,0,0,double,1
+shape,filledcircle,4,0,0,double,1
+shape,filledcircle,5,0,0,double,1
+shape,filledcircle,6,0,0,character[],1
+shape,filledcircle,6,0,1,double,1
+shape,filledcircle,7,0,0,null,1
+shape,filledcircle,8,0,0,null,1
+shape,filledcircle,9,0,0,double,1
+shape,filledcircle,10,0,0,null,1
+shape,filledcircle,11,0,0,...,1
+shape,filledcylinder,-1,0,0,null,1
+shape,filledcylinder,0,0,0,double,1
+shape,filledcylinder,1,0,0,double,1
+shape,filledcylinder,2,0,0,double,1
+shape,filledcylinder,3,0,0,character[],1
+shape,filledcylinder,4,0,0,character,1
+shape,filledcylinder,4,0,1,null,1
+shape,filledcylinder,5,0,0,double,1
+shape,filledcylinder,6,0,0,null,1
+shape,filledcylinder,6,0,1,character,1
+shape,filledcylinder,7,0,0,double,1
+shape,filledcylinder,8,0,0,any,1
+shape,filledcylinder,9,0,0,double[],1
+shape,filledcylinder,10,0,0,double,1
+shape,filledcylinder,11,0,0,double,1
+shape,filledcylinder,12,0,0,double,1
+shape,filledcylinder,13,0,0,character[],1
+shape,filledcylinder,13,0,1,null,1
+shape,filledcylinder,14,0,0,null,1
+shape,filledcylinder,15,0,0,...,1
+shape,filledellipse,-1,0,0,null,1
+shape,filledellipse,0,0,0,double,1
+shape,filledellipse,1,0,0,double,1
+shape,filledellipse,2,0,0,double,1
+shape,filledellipse,3,0,0,double,1
+shape,filledellipse,3,0,1,null,1
+shape,filledellipse,4,0,0,double[],1
+shape,filledellipse,4,0,1,class<`matrix`>,1
+shape,filledellipse,5,0,0,double,1
+shape,filledellipse,6,0,0,double,1
+shape,filledellipse,7,0,0,double,1
+shape,filledellipse,8,0,0,double,1
+shape,filledellipse,9,0,0,character[],1
+shape,filledellipse,9,0,1,double,1
+shape,filledellipse,10,0,0,null,1
+shape,filledellipse,10,0,1,class<`matrix`>,1
+shape,filledellipse,11,0,0,any,1
+shape,filledellipse,12,0,0,any,1
+shape,filledellipse,13,0,0,null,1
+shape,filledellipse,14,0,0,...,1
+shape,filledmultigonal,-1,0,0,null,1
+shape,filledmultigonal,0,0,0,double[],1
+shape,filledmultigonal,1,0,0,double,1
+shape,filledmultigonal,2,0,0,double,1
+shape,filledmultigonal,3,0,0,double,1
+shape,filledmultigonal,4,0,0,character[],1
+shape,filledmultigonal,5,0,0,null,1
+shape,filledmultigonal,6,0,0,null,1
+shape,filledmultigonal,7,0,0,double,1
+shape,filledmultigonal,8,0,0,null,1
+shape,filledmultigonal,8,0,1,character,1
+shape,filledmultigonal,9,0,0,double,1
+shape,filledmultigonal,10,0,0,...,1
+shape,filledrectangle,-1,0,0,null,1
+shape,filledrectangle,0,0,0,double[],1
+shape,filledrectangle,1,0,0,double,1
+shape,filledrectangle,2,0,0,double,1
+shape,filledrectangle,3,0,0,character[],1
+shape,filledrectangle,4,0,0,null,1
+shape,filledrectangle,5,0,0,null,1
+shape,filledrectangle,6,0,0,double,1
+shape,filledrectangle,7,0,0,null,1
+shape,filledrectangle,8,0,0,double,1
+shape,filledrectangle,9,0,0,...,1
+shape,filledshape,-1,0,0,null,1
+shape,filledshape,0,0,0,class<`matrix`>,1
+shape,filledshape,1,0,0,class<`matrix`>,1
+shape,filledshape,1,0,1,double[],1
+shape,filledshape,2,0,0,character[],1
+shape,filledshape,2,0,1,double,1
+shape,filledshape,3,0,0,null,1
+shape,filledshape,3,0,1,class<`matrix`>,1
+shape,filledshape,4,0,0,any,1
+shape,filledshape,5,0,0,null,1
+shape,filledshape,5,0,1,character,1
+shape,filledshape,6,0,0,any,1
+shape,filledshape,7,0,0,...,1
+shape,getellipse,-1,0,0,class<`matrix`>,1
+shape,getellipse,0,0,0,double,1
+shape,getellipse,1,0,0,double,1
+shape,getellipse,2,0,0,double[],1
+shape,getellipse,2,0,1,class<`matrix`>,1
+shape,getellipse,3,0,0,double,1
+shape,getellipse,4,0,0,double,1
+shape,getellipse,5,0,0,double,1
+shape,getellipse,6,0,0,double,1
+shape,graycol,-1,0,0,character[],1
+shape,graycol,0,0,0,double,1
+shape,graycol,1,0,0,double[],1
+shape,greycol,-1,0,0,character[],1
+shape,greycol,0,0,0,double,1
+shape,greycol,1,0,0,double[],1
+shape,intpalette,-1,0,0,character[],1
+shape,intpalette,0,0,0,character[],1
+shape,intpalette,0,0,1,class<`matrix`>,1
+shape,intpalette,1,0,0,double,1
+shape,intpalette,2,0,0,null,1
+shape,intpalette,2,0,1,double[],1
+shape,intpalette,3,0,0,null,1
+shape,intpalette,3,0,1,double[],1
+shape,plotcircle,-1,0,0,null,1
+shape,plotcircle,0,0,0,double,1
+shape,plotcircle,1,0,0,...,1
+shape,plotellipse,-1,0,0,null,1
+shape,plotellipse,0,0,0,double,1
+shape,plotellipse,1,0,0,double,1
+shape,plotellipse,2,0,0,double[],1
+shape,plotellipse,3,0,0,double,1
+shape,plotellipse,4,0,0,double,1
+shape,plotellipse,5,0,0,double,1
+shape,plotellipse,6,0,0,double,1
+shape,plotellipse,7,0,0,character,1
+shape,plotellipse,8,0,0,double,1
+shape,plotellipse,9,0,0,character,1
+shape,plotellipse,10,0,0,character,1
+shape,plotellipse,10,0,1,null,1
+shape,plotellipse,11,0,0,logical,1
+shape,plotellipse,12,0,0,double,1
+shape,plotellipse,13,0,0,any,1
+shape,plotellipse,14,0,0,character,1
+shape,plotellipse,15,0,0,double[],1
+shape,plotellipse,16,0,0,double,1
+shape,plotellipse,17,0,0,double,1
+shape,plotellipse,18,0,0,character[],1
+shape,plotellipse,19,0,0,...,1
+shape,rotatexy,-1,0,0,class<`matrix`>,1
+shape,rotatexy,0,0,0,class<`matrix`>,1
+shape,rotatexy,0,0,1,double[],1
+shape,rotatexy,1,0,0,double,1
+shape,rotatexy,2,0,0,class<`matrix`>,1
+shape,rotatexy,2,0,1,double[],1
+shape,rotatexy,3,0,0,logical,1
+shape,roundrect,-1,0,0,null,1
+shape,roundrect,0,0,0,double[],1
+shape,roundrect,1,0,0,double,1
+shape,roundrect,2,0,0,double,1
+shape,roundrect,3,0,0,double,1
+shape,roundrect,4,0,0,double,1
+shape,roundrect,5,0,0,character[],1
+shape,roundrect,5,0,1,integer,1
+shape,roundrect,6,0,0,character,1
+shape,roundrect,7,0,0,double,1
+shape,roundrect,8,0,0,double,1
+shape,roundrect,9,0,0,...,1
+shape,shadepalette,-1,0,0,character[],1
+shape,shadepalette,0,0,0,double,1
+shape,shadepalette,1,0,0,character,1
+shape,shadepalette,2,0,0,character,1
+shape,shadepalette,3,0,0,double[],1
+shape,textflag,-1,0,0,null,1
+shape,textflag,0,0,0,double[],1
+shape,textflag,1,0,0,double,1
+shape,textflag,2,0,0,double,1
+shape,textflag,3,0,0,double,1
+shape,textflag,4,0,0,double,1
+shape,textflag,5,0,0,character[],1
+shape,textflag,6,0,0,character,1
+shape,textflag,7,0,0,character,1
+shape,textflag,8,0,0,double,1
+shape,textflag,9,0,0,double,1
+shape,textflag,10,0,0,character,1
+shape,textflag,11,0,0,logical,1
+shape,textflag,12,0,0,character,1
+shape,textflag,12,0,1,null,1
+shape,textflag,13,0,0,...,1
+shape,val2col,-1,0,0,list<character[] | double[]>,1
+shape,val2col,-1,0,1,list<character | double[]>,1
+shape,val2col,-1,0,2,list<double[]>,1
+shape,val2col,0,0,0,class<`matrix`>,1
+shape,val2col,0,0,1,null,1
+shape,val2col,1,0,0,any,1
+shape,val2col,2,0,0,character[],1
+shape,val2col,2,0,1,double,1
+shape,writelabel,-1,0,0,null,1
+shape,writelabel,0,0,0,character,1
+shape,writelabel,1,0,0,double,1
+shape,writelabel,2,0,0,double,1
+shape,writelabel,3,0,0,double,1
+shape,writelabel,4,0,0,double,1
+shape,writelabel,5,0,0,...,1
+shinyWidgets,addSpinner,-1,0,0,"class<`list`, `shiny.tag.list`>",1
+shinyWidgets,addSpinner,0,0,0,class<`shiny.tag`>,1
+shinyWidgets,addSpinner,1,0,0,character,1
+shinyWidgets,addSpinner,2,0,0,character,1
+shinyWidgets,get_style,-1,0,0,list<character>,1
+shinyWidgets,get_style,0,0,0,class<`shiny.tag`>,1
+signal,an,-1,0,0,complex,1
+signal,an,0,0,0,double,1
+signal,Arma,-1,0,0,class<`Arma`>,1
+signal,Arma,0,0,0,double[],1
+signal,Arma,1,0,0,double[],1
+signal,as.Arma,-1,0,0,class<`Arma`>,1
+signal,as.Arma,0,0,0,class<`Zpg`>,1
+signal,as.Arma,1,0,0,...,1
+signal,as.Arma.Zpg,-1,0,0,class<`Arma`>,1
+signal,as.Arma.Zpg,0,0,0,class<`Zpg`>,1
+signal,as.Arma.Zpg,1,0,0,...,1
+signal,bartlett,-1,0,0,double[],1
+signal,bartlett,0,0,0,double,1
+signal,bilinear,-1,0,0,class<`Zpg`>,1
+signal,bilinear,0,0,0,class<`Zpg`>,1
+signal,bilinear,0,0,1,complex[],1
+signal,bilinear,1,0,0,...,1
+signal,bilinear.default,-1,0,0,class<`Zpg`>,1
+signal,bilinear.default,0,0,0,complex[],1
+signal,bilinear.default,1,0,0,complex[],1
+signal,bilinear.default,2,0,0,complex,1
+signal,bilinear.default,3,0,0,double,1
+signal,bilinear.default,4,0,0,...,1
+signal,bilinear.Zpg,-1,0,0,class<`Zpg`>,1
+signal,bilinear.Zpg,0,0,0,class<`Zpg`>,1
+signal,bilinear.Zpg,1,0,0,double,1
+signal,bilinear.Zpg,2,0,0,...,1
+signal,blackman,-1,0,0,double[],1
+signal,blackman,0,0,0,double,1
+signal,boxcar,-1,0,0,double[],1
+signal,boxcar,0,0,0,double,1
+signal,butter,-1,0,0,class<`Arma`>,1
+signal,butter,0,0,0,class<`FilterOfOrder`>,1
+signal,butter,0,0,1,double,1
+signal,butter,1,0,0,...,1
+signal,butter.default,-1,0,0,class<`Arma`>,1
+signal,butter.default,0,0,0,double,1
+signal,butter.default,1,0,0,double,1
+signal,butter.default,2,0,0,character[],1
+signal,butter.default,3,0,0,character[],1
+signal,butter.default,4,0,0,...,1
+signal,butter.FilterOfOrder,-1,0,0,class<`Arma`>,1
+signal,butter.FilterOfOrder,0,0,0,class<`FilterOfOrder`>,1
+signal,butter.FilterOfOrder,1,0,0,...,1
+signal,buttord,-1,0,0,class<`FilterOfOrder`>,1
+signal,buttord,0,0,0,double,1
+signal,buttord,1,0,0,double,1
+signal,buttord,2,0,0,double,1
+signal,buttord,3,0,0,double,1
+signal,cheb,-1,0,0,double[],1
+signal,cheb,0,0,0,double,1
+signal,cheb,1,0,0,double[],1
+signal,cheb1ord,-1,0,0,class<`FilterOfOrder`>,1
+signal,cheb1ord,0,0,0,double,1
+signal,cheb1ord,1,0,0,double,1
+signal,cheb1ord,2,0,0,double,1
+signal,cheb1ord,3,0,0,double,1
+signal,chebwin,-1,0,0,double[],1
+signal,chebwin,0,0,0,double,1
+signal,chebwin,1,0,0,double,1
+signal,cheby1,-1,0,0,class<`Arma`>,1
+signal,cheby1,0,0,0,class<`FilterOfOrder`>,1
+signal,cheby1,0,0,1,double,1
+signal,cheby1,1,0,0,...,1
+signal,cheby1.default,-1,0,0,class<`Arma`>,1
+signal,cheby1.default,0,0,0,double,1
+signal,cheby1.default,1,0,0,double,1
+signal,cheby1.default,2,0,0,double,1
+signal,cheby1.default,3,0,0,character[],1
+signal,cheby1.default,4,0,0,character[],1
+signal,cheby1.default,5,0,0,...,1
+signal,cheby1.FilterOfOrder,-1,0,0,class<`Arma`>,1
+signal,cheby1.FilterOfOrder,0,0,0,class<`FilterOfOrder`>,1
+signal,cheby1.FilterOfOrder,1,0,0,double,1
+signal,cheby1.FilterOfOrder,2,0,0,double,1
+signal,cheby1.FilterOfOrder,3,0,0,character,1
+signal,cheby1.FilterOfOrder,4,0,0,...,1
+signal,cheby2,-1,0,0,class<`Arma`>,1
+signal,cheby2,0,0,0,double,1
+signal,cheby2,1,0,0,...,1
+signal,cheby2.default,-1,0,0,class<`Arma`>,1
+signal,cheby2.default,0,0,0,double,1
+signal,cheby2.default,1,0,0,double,1
+signal,cheby2.default,2,0,0,double,1
+signal,cheby2.default,3,0,0,character[],1
+signal,cheby2.default,4,0,0,character[],1
+signal,cheby2.default,5,0,0,...,1
+signal,chirp,-1,0,0,double[],1
+signal,chirp,0,0,0,double[],1
+signal,chirp,1,0,0,double,1
+signal,chirp,2,0,0,double,1
+signal,chirp,3,0,0,double,1
+signal,chirp,4,0,0,character[],1
+signal,chirp,5,0,0,double,1
+signal,conv,-1,0,0,complex[],1
+signal,conv,0,0,0,complex[],1
+signal,conv,1,0,0,complex[],1
+signal,decimate,-1,0,0,double[],1
+signal,decimate,0,0,0,double[],1
+signal,decimate,1,0,0,double,1
+signal,decimate,2,0,0,double,1
+signal,decimate,3,0,0,character,1
+signal,ellip,-1,0,0,class<`Arma`>,1
+signal,ellip,0,0,0,class<`FilterOfOrder`>,1
+signal,ellip,0,0,1,double,1
+signal,ellip,1,0,0,...,1
+signal,ellip.default,-1,0,0,class<`Arma`>,1
+signal,ellip.default,0,0,0,double,1
+signal,ellip.default,1,0,0,double,1
+signal,ellip.default,2,0,0,double,1
+signal,ellip.default,3,0,0,double,1
+signal,ellip.default,4,0,0,character[],1
+signal,ellip.default,5,0,0,character[],1
+signal,ellip.default,6,0,0,...,1
+signal,ellip.FilterOfOrder,-1,0,0,class<`Arma`>,1
+signal,ellip.FilterOfOrder,0,0,0,class<`FilterOfOrder`>,1
+signal,ellip.FilterOfOrder,1,0,0,double,1
+signal,ellip.FilterOfOrder,2,0,0,double,1
+signal,ellip.FilterOfOrder,3,0,0,double,1
+signal,ellip.FilterOfOrder,4,0,0,character,1
+signal,ellip.FilterOfOrder,5,0,0,...,1
+signal,ellipke,-1,0,0,list<class<`array`>>,1
+signal,ellipke,0,0,0,double[],1
+signal,ellipke,1,0,0,double,1
+signal,ellipord,-1,0,0,class<`FilterOfOrder`>,1
+signal,ellipord,0,0,0,double,1
+signal,ellipord,1,0,0,double,1
+signal,ellipord,2,0,0,double,1
+signal,ellipord,3,0,0,double,1
+signal,fftfilt,-1,0,0,double[],1
+signal,fftfilt,0,0,0,class<`Ma`>,1
+signal,fftfilt,0,0,1,double[],1
+signal,fftfilt,1,0,0,double[],1
+signal,fftfilt,2,0,0,null,1
+signal,filter,-1,0,0,class<`ts`>,1
+signal,filter,-1,0,1,double[],1
+signal,filter,0,0,0,double[],1
+signal,filter,0,0,1,class<`Arma`>,1
+signal,filter,0,0,2,class<`MedianFilter`>,1
+signal,filter,1,0,0,...,1
+signal,filter,-1,1,0,logical[],1
+signal,filter,0,1,0,character[],1
+signal,filter.Arma,-1,0,0,class<`ts`>,1
+signal,filter.Arma,0,0,0,class<`Arma`>,1
+signal,filter.Arma,1,0,0,double[],1
+signal,filter.Arma,2,0,0,...,1
+signal,filter.default,-1,0,0,class<`ts`>,1
+signal,filter.default,0,0,0,double[],1
+signal,filter.default,1,0,0,double[],1
+signal,filter.default,2,0,0,double[],1
+signal,filter.default,3,0,0,any,1
+signal,filter.default,4,0,0,any,1
+signal,filter.default,5,0,0,any,1
+signal,filter.default,6,0,0,...,1
+signal,filter.MedianFilter,-1,0,0,double[],1
+signal,filter.MedianFilter,0,0,0,class<`MedianFilter`>,1
+signal,filter.MedianFilter,1,0,0,double[],1
+signal,filter.MedianFilter,2,0,0,...,1
+signal,FilterOfOrder,-1,0,0,class<`FilterOfOrder`>,1
+signal,FilterOfOrder,0,0,0,double,1
+signal,FilterOfOrder,1,0,0,double[],1
+signal,FilterOfOrder,2,0,0,character,1
+signal,FilterOfOrder,3,0,0,...,1
+signal,filtfilt,-1,0,0,double[],1
+signal,filtfilt,0,0,0,class<`Arma`>,1
+signal,filtfilt,0,0,1,double[],1
+signal,filtfilt,1,0,0,...,1
+signal,filtfilt.Arma,-1,0,0,double[],1
+signal,filtfilt.Arma,0,0,0,class<`Arma`>,1
+signal,filtfilt.Arma,1,0,0,double[],1
+signal,filtfilt.Arma,2,0,0,...,1
+signal,filtfilt.default,-1,0,0,double[],1
+signal,filtfilt.default,0,0,0,double[],1
+signal,filtfilt.default,1,0,0,double[],1
+signal,filtfilt.default,2,0,0,double[],1
+signal,filtfilt.default,3,0,0,...,1
+signal,fir1,-1,0,0,class<`Ma`>,1
+signal,fir1,0,0,0,double,1
+signal,fir1,1,0,0,double[],1
+signal,fir1,2,0,0,character[],1
+signal,fir1,3,0,0,double[],1
+signal,fir1,4,0,0,character,1
+signal,fir1,4,0,1,logical,1
+signal,fir2,-1,0,0,class<`Ma`>,1
+signal,fir2,0,0,0,double,1
+signal,fir2,1,0,0,double[],1
+signal,fir2,2,0,0,double[],1
+signal,fir2,3,0,0,double,1
+signal,fir2,4,0,0,double,1
+signal,fir2,5,0,0,double[],1
+signal,flattopwin,-1,0,0,double[],1
+signal,flattopwin,0,0,0,double,1
+signal,flattopwin,1,0,0,character[],1
+signal,freqs,-1,0,0,class<`freqs`>,1
+signal,freqs,0,0,0,double[],1
+signal,freqs,1,0,0,...,1
+signal,freqs.default,-1,0,0,class<`freqs`>,1
+signal,freqs.default,0,0,0,double[],1
+signal,freqs.default,1,0,0,double[],1
+signal,freqs.default,2,0,0,double[],1
+signal,freqs.default,3,0,0,...,1
+signal,freqz,-1,0,0,class<`freqz`>,1
+signal,freqz,0,0,0,class<`Arma`>,1
+signal,freqz,0,0,1,class<`Ma`>,1
+signal,freqz,0,0,2,double[],1
+signal,freqz,1,0,0,...,1
+signal,freqz.Arma,-1,0,0,class<`freqz`>,1
+signal,freqz.Arma,0,0,0,class<`Arma`>,1
+signal,freqz.Arma,1,0,0,...,1
+signal,freqz.default,-1,0,0,class<`freqz`>,1
+signal,freqz.default,0,0,0,class<`Ma`>,1
+signal,freqz.default,0,0,1,double[],1
+signal,freqz.default,1,0,0,double[],1
+signal,freqz.default,2,0,0,double,1
+signal,freqz.default,3,0,0,null,1
+signal,freqz.default,4,0,0,double,1
+signal,freqz.default,5,0,0,...,1
+signal,freqz.Ma,-1,0,0,class<`freqz`>,1
+signal,freqz.Ma,0,0,0,class<`Ma`>,1
+signal,freqz.Ma,1,0,0,...,1
+signal,gausswin,-1,0,0,double[],1
+signal,gausswin,0,0,0,double,1
+signal,gausswin,1,0,0,double,1
+signal,grpdelay,-1,0,0,class<`grpdelay`>,1
+signal,grpdelay,0,0,0,class<`Arma`>,1
+signal,grpdelay,0,0,1,complex[],1
+signal,grpdelay,1,0,0,...,1
+signal,grpdelay.Arma,-1,0,0,class<`grpdelay`>,1
+signal,grpdelay.Arma,0,0,0,class<`Arma`>,1
+signal,grpdelay.Arma,1,0,0,...,1
+signal,grpdelay.default,-1,0,0,class<`grpdelay`>,1
+signal,grpdelay.default,0,0,0,complex[],1
+signal,grpdelay.default,1,0,0,complex[],1
+signal,grpdelay.default,2,0,0,double,1
+signal,grpdelay.default,3,0,0,logical,1
+signal,grpdelay.default,4,0,0,double,1
+signal,grpdelay.default,5,0,0,...,1
+signal,hamming,-1,0,0,double[],1
+signal,hamming,0,0,0,double,1
+signal,hanning,-1,0,0,double[],1
+signal,hanning,0,0,0,double,1
+signal,ifft,-1,0,0,complex[],1
+signal,ifft,0,0,0,complex[],1
+signal,impz,-1,0,0,class<`impz`>,1
+signal,impz,0,0,0,class<`Arma`>,1
+signal,impz,0,0,1,double[],1
+signal,impz,1,0,0,...,1
+signal,impz.Arma,-1,0,0,class<`impz`>,1
+signal,impz.Arma,0,0,0,class<`Arma`>,1
+signal,impz.Arma,1,0,0,...,1
+signal,impz.default,-1,0,0,class<`impz`>,1
+signal,impz.default,0,0,0,double[],1
+signal,impz.default,1,0,0,double[],1
+signal,impz.default,2,0,0,null,1
+signal,impz.default,3,0,0,double,1
+signal,impz.default,4,0,0,...,1
+signal,interp,-1,0,0,double[],1
+signal,interp,0,0,0,double[],1
+signal,interp,1,0,0,double,1
+signal,interp,2,0,0,double,1
+signal,interp,3,0,0,double,1
+signal,interp1,-1,0,0,^double[],1
+signal,interp1,0,0,0,integer[],1
+signal,interp1,1,0,0,double[],1
+signal,interp1,2,0,0,double[],1
+signal,interp1,3,0,0,character,1
+signal,interp1,4,0,0,logical,1
+signal,interp1,5,0,0,...,1
+signal,kaiser,-1,0,0,double[],1
+signal,kaiser,0,0,0,double,1
+signal,kaiser,1,0,0,double,1
+signal,kaiserord,-1,0,0,class<`FilterOfOrder`>,1
+signal,kaiserord,0,0,0,double[],1
+signal,kaiserord,1,0,0,double[],1
+signal,kaiserord,2,0,0,double,1
+signal,kaiserord,3,0,0,double,1
+signal,Ma,-1,0,0,class<`Ma`>,1
+signal,Ma,0,0,0,class<`Ma`>,1
+signal,Ma,0,0,1,double[],1
+signal,medfilt1,-1,0,0,double[],1
+signal,medfilt1,0,0,0,double[],1
+signal,medfilt1,1,0,0,double,1
+signal,medfilt1,2,0,0,...,1
+signal,MedianFilter,-1,0,0,class<`MedianFilter`>,1
+signal,MedianFilter,0,0,0,double,1
+signal,mkpp,-1,0,0,class<`pp`>,1
+signal,mkpp,0,0,0,integer[],1
+signal,mkpp,1,0,0,class<`matrix`>,1
+signal,mkpp,2,0,0,double,1
+signal,ncauer,-1,0,0,class<`Zpg`>,1
+signal,ncauer,0,0,0,double,1
+signal,ncauer,1,0,0,double,1
+signal,ncauer,2,0,0,double,1
+signal,pchip,-1,0,0,double[],1
+signal,pchip,0,0,0,integer[],1
+signal,pchip,1,0,0,double[],1
+signal,pchip,2,0,0,double[],1
+signal,plot.grpdelay,-1,0,0,null,1
+signal,plot.grpdelay,0,0,0,class<`grpdelay`>,1
+signal,plot.grpdelay,1,0,0,character,1
+signal,plot.grpdelay,2,0,0,character,1
+signal,plot.grpdelay,3,0,0,character,1
+signal,plot.grpdelay,4,0,0,...,1
+signal,poly,-1,0,0,complex[],1
+signal,poly,0,0,0,complex[],1
+signal,poly,0,0,1,class<`matrix`>,1
+signal,polyval,-1,0,0,complex[],1
+signal,polyval,0,0,0,double[],1
+signal,polyval,0,0,1,class<`Ma`>,1
+signal,polyval,1,0,0,complex[],1
+signal,postpad,-1,0,0,complex[],1
+signal,postpad,0,0,0,complex[],1
+signal,postpad,0,0,1,class<`Ma`>,1
+signal,postpad,1,0,0,double,1
+signal,ppval,-1,0,0,double[],1
+signal,ppval,0,0,0,class<`pp`>,1
+signal,ppval,1,0,0,double[],1
+signal,print.grpdelay,-1,0,0,class<`grpdelay`>,1
+signal,print.grpdelay,0,0,0,class<`grpdelay`>,1
+signal,print.grpdelay,1,0,0,...,1
+signal,remez,-1,0,0,class<`Ma`>,1
+signal,remez,0,0,0,double,1
+signal,remez,1,0,0,double[],1
+signal,remez,2,0,0,double[],1
+signal,remez,3,0,0,double[],1
+signal,remez,4,0,0,character[],1
+signal,remez,5,0,0,double,1
+signal,resample,-1,0,0,double[],1
+signal,resample,0,0,0,double[],1
+signal,resample,1,0,0,integer,1
+signal,resample,2,0,0,double,1
+signal,resample,3,0,0,double,1
+signal,roots,-1,0,0,complex[],1
+signal,roots,0,0,0,double[],1
+signal,roots,1,0,0,character[],1
+signal,sftrans,-1,0,0,class<`Zpg`>,1
+signal,sftrans,0,0,0,class<`Zpg`>,1
+signal,sftrans,1,0,0,...,1
+signal,sftrans.default,-1,0,0,class<`Zpg`>,1
+signal,sftrans.default,0,0,0,complex[],1
+signal,sftrans.default,1,0,0,complex[],1
+signal,sftrans.default,2,0,0,complex,1
+signal,sftrans.default,3,0,0,double,1
+signal,sftrans.default,4,0,0,logical,1
+signal,sftrans.default,5,0,0,...,1
+signal,sftrans.Zpg,-1,0,0,class<`Zpg`>,1
+signal,sftrans.Zpg,0,0,0,class<`Zpg`>,1
+signal,sftrans.Zpg,1,0,0,double,1
+signal,sftrans.Zpg,2,0,0,logical,1
+signal,sftrans.Zpg,3,0,0,...,1
+signal,sgolay,-1,0,0,class<`sgolayFilter`>,1
+signal,sgolay,0,0,0,double,1
+signal,sgolay,1,0,0,double,1
+signal,sgolay,2,0,0,double,1
+signal,sgolay,3,0,0,any,1
+signal,sgolayfilt,-1,0,0,double[],1
+signal,sgolayfilt,0,0,0,double[],1
+signal,sgolayfilt,1,0,0,double,1
+signal,sgolayfilt,2,0,0,double,1
+signal,sgolayfilt,3,0,0,double,1
+signal,sgolayfilt,4,0,0,double,1
+signal,sinc,-1,0,0,double[],1
+signal,sinc,0,0,0,double[],1
+signal,specgram,-1,0,0,class<`specgram`>,1
+signal,specgram,0,0,0,class<`matrix`>,1
+signal,specgram,0,0,1,double[],1
+signal,specgram,1,0,0,double,1
+signal,specgram,2,0,0,double,1
+signal,specgram,3,0,0,double[],1
+signal,specgram,4,0,0,double,1
+signal,triang,-1,0,0,double[],1
+signal,triang,0,0,0,double,1
+signal,unwrap,-1,0,0,double[],1
+signal,unwrap,0,0,0,double[],1
+signal,unwrap,1,0,0,double,1
+signal,unwrap,2,0,0,double,1
+signal,Zpg,-1,0,0,class<`Zpg`>,1
+signal,Zpg,0,0,0,complex[],1
+signal,Zpg,1,0,0,complex[],1
+signal,Zpg,2,0,0,complex,1
+signal,zplane,-1,0,0,null,1
+signal,zplane,0,0,0,class<`Arma`>,1
+signal,zplane,0,0,1,class<`Zpg`>,1
+signal,zplane,0,0,2,double[],1
+signal,zplane,1,0,0,...,1
+signal,zplane.Arma,-1,0,0,null,1
+signal,zplane.Arma,0,0,0,class<`Arma`>,1
+signal,zplane.Arma,1,0,0,...,1
+signal,zplane.default,-1,0,0,null,1
+signal,zplane.default,0,0,0,double[],1
+signal,zplane.default,1,0,0,double[],1
+signal,zplane.default,2,0,0,...,1
+signal,zplane.Zpg,-1,0,0,null,1
+signal,zplane.Zpg,0,0,0,class<`Zpg`>,1
+signal,zplane.Zpg,1,0,0,...,1
+sjlabelled,add_labels,-1,0,0,^double[],1
+sjlabelled,add_labels,-1,0,1,class<`data.frame`>,1
+sjlabelled,add_labels,-1,0,2,class<`haven_labelled`>,1
+sjlabelled,add_labels,0,0,0,^double[],1
+sjlabelled,add_labels,0,0,1,class<`data.frame`>,1
+sjlabelled,add_labels,0,0,2,class<`haven_labelled`>,1
+sjlabelled,add_labels,1,0,0,...,1
+sjlabelled,add_labels,2,0,0,null,1
+sjlabelled,add_labels,2,0,1,double[],1
+sjlabelled,add_labels_helper,-1,0,0,class<`haven_labelled`>,1
+sjlabelled,add_labels_helper,-1,0,1,^double[],1
+sjlabelled,add_labels_helper,0,0,0,class<`haven_labelled`>,1
+sjlabelled,add_labels_helper,0,0,1,^double[],1
+sjlabelled,add_labels_helper,1,0,0,null,1
+sjlabelled,add_labels_helper,1,0,1,double[],1
+sjlabelled,as_factor,-1,0,0,class<`data.frame`>,1
+sjlabelled,as_factor,-1,0,1,class<`factor`>,1
+sjlabelled,as_factor,0,0,0,class<`data.frame`>,1
+sjlabelled,as_factor,0,0,1,^double[],1
+sjlabelled,as_factor,1,0,0,...,1
+sjlabelled,as_factor.data.frame,-1,0,0,class<`data.frame`>,1
+sjlabelled,as_factor.data.frame,0,0,0,class<`data.frame`>,1
+sjlabelled,as_factor.data.frame,1,0,0,...,1
+sjlabelled,as_factor.data.frame,2,0,0,logical,1
+sjlabelled,as_factor.default,-1,0,0,class<`factor`>,1
+sjlabelled,as_factor.default,0,0,0,^double[],1
+sjlabelled,as_factor.default,1,0,0,logical,1
+sjlabelled,as_factor.default,2,0,0,...,1
+sjlabelled,as_label,-1,0,0,class<`data.frame`>,1
+sjlabelled,as_label,-1,0,1,class<`factor`>,1
+sjlabelled,as_label,-1,0,2,^double[],1
+sjlabelled,as_label,0,0,0,class<`data.frame`>,1
+sjlabelled,as_label,0,0,1,character[],1
+sjlabelled,as_label,0,0,2,class<`factor`>,1
+sjlabelled,as_label,0,0,3,class<`haven_labelled`>,1
+sjlabelled,as_label,0,0,4,^double[],1
+sjlabelled,as_label,1,0,0,...,1
+sjlabelled,as_label.data.frame,-1,0,0,class<`data.frame`>,1
+sjlabelled,as_label.data.frame,0,0,0,class<`data.frame`>,1
+sjlabelled,as_label.data.frame,1,0,0,...,1
+sjlabelled,as_label.data.frame,2,0,0,logical,1
+sjlabelled,as_label.data.frame,3,0,0,logical,1
+sjlabelled,as_label.data.frame,4,0,0,null,1
+sjlabelled,as_label.data.frame,5,0,0,logical,1
+sjlabelled,as_label.data.frame,6,0,0,logical,1
+sjlabelled,as_label.data.frame,7,0,0,logical,1
+sjlabelled,as_label.default,-1,0,0,class<`factor`>,1
+sjlabelled,as_label.default,-1,0,1,^double[],1
+sjlabelled,as_label.default,0,0,0,character[],1
+sjlabelled,as_label.default,0,0,1,class<`factor`>,1
+sjlabelled,as_label.default,0,0,2,class<`haven_labelled`>,1
+sjlabelled,as_label.default,0,0,3,^double[],1
+sjlabelled,as_label.default,1,0,0,logical,1
+sjlabelled,as_label.default,2,0,0,logical,1
+sjlabelled,as_label.default,3,0,0,null,1
+sjlabelled,as_label.default,3,0,1,character,1
+sjlabelled,as_label.default,4,0,0,logical,1
+sjlabelled,as_label.default,5,0,0,logical,1
+sjlabelled,as_label.default,6,0,0,logical,1
+sjlabelled,as_label.default,7,0,0,...,1
+sjlabelled,as_label_helper,-1,0,0,class<`factor`>,1
+sjlabelled,as_label_helper,-1,0,1,^double[],1
+sjlabelled,as_label_helper,0,0,0,character[],1
+sjlabelled,as_label_helper,0,0,1,class<`factor`>,1
+sjlabelled,as_label_helper,0,0,2,class<`haven_labelled`>,1
+sjlabelled,as_label_helper,0,0,3,^double[],1
+sjlabelled,as_label_helper,1,0,0,any,1
+sjlabelled,as_label_helper,2,0,0,logical,1
+sjlabelled,as_label_helper,3,0,0,null,1
+sjlabelled,as_label_helper,3,0,1,character,1
+sjlabelled,as_label_helper,4,0,0,logical,1
+sjlabelled,as_label_helper,5,0,0,logical,1
+sjlabelled,as_label_helper,6,0,0,logical,1
+sjlabelled,as_labelled,-1,0,0,class<`haven_labelled`>,1
+sjlabelled,as_labelled,-1,0,1,"class<`haven_labelled`, `numeric`>",1
+sjlabelled,as_labelled,-1,0,2,double[],1
+sjlabelled,as_labelled,0,0,0,^double[],1
+sjlabelled,as_labelled,1,0,0,logical,1
+sjlabelled,as_labelled,2,0,0,logical,1
+sjlabelled,as_labelled,3,0,0,logical,1
+sjlabelled,as_labelled.default,-1,0,0,class<`haven_labelled`>,1
+sjlabelled,as_labelled.default,-1,0,1,"class<`haven_labelled`, `numeric`>",1
+sjlabelled,as_labelled.default,-1,0,2,double[],1
+sjlabelled,as_labelled.default,0,0,0,^double[],1
+sjlabelled,as_labelled.default,1,0,0,logical,1
+sjlabelled,as_labelled.default,2,0,0,logical,1
+sjlabelled,as_labelled.default,3,0,0,logical,1
+sjlabelled,as_labelled_helper,-1,0,0,class<`haven_labelled`>,1
+sjlabelled,as_labelled_helper,-1,0,1,"class<`haven_labelled`, `numeric`>",1
+sjlabelled,as_labelled_helper,-1,0,2,double[],1
+sjlabelled,as_labelled_helper,0,0,0,^double[],1
+sjlabelled,as_labelled_helper,1,0,0,any,1
+sjlabelled,as_labelled_helper,2,0,0,any,1
+sjlabelled,as_labelled_helper,3,0,0,any,1
+sjlabelled,as_numeric,-1,0,0,class<`data.frame`>,1
+sjlabelled,as_numeric,-1,0,1,^double[],1
+sjlabelled,as_numeric,0,0,0,class<`data.frame`>,1
+sjlabelled,as_numeric,0,0,1,class<`factor`>,1
+sjlabelled,as_numeric,0,0,2,"class<`factor`, `ordered`>",1
+sjlabelled,as_numeric,1,0,0,...,1
+sjlabelled,as_numeric.data.frame,-1,0,0,class<`data.frame`>,1
+sjlabelled,as_numeric.data.frame,0,0,0,class<`data.frame`>,1
+sjlabelled,as_numeric.data.frame,1,0,0,...,1
+sjlabelled,as_numeric.data.frame,2,0,0,null,1
+sjlabelled,as_numeric.data.frame,3,0,0,logical,1
+sjlabelled,as_numeric.data.frame,4,0,0,logical,1
+sjlabelled,as_numeric.default,-1,0,0,^double[],1
+sjlabelled,as_numeric.default,0,0,0,class<`factor`>,1
+sjlabelled,as_numeric.default,0,0,1,^double[],1
+sjlabelled,as_numeric.default,0,0,2,"class<`factor`, `ordered`>",1
+sjlabelled,as_numeric.default,1,0,0,null,1
+sjlabelled,as_numeric.default,1,0,1,double,1
+sjlabelled,as_numeric.default,2,0,0,any,1
+sjlabelled,as_numeric.default,3,0,0,logical,1
+sjlabelled,as_numeric.default,4,0,0,...,1
+sjlabelled,as_numeric_helper,-1,0,0,^double[],1
+sjlabelled,as_numeric_helper,0,0,0,class<`factor`>,1
+sjlabelled,as_numeric_helper,0,0,1,^double[],1
+sjlabelled,as_numeric_helper,0,0,2,"class<`factor`, `ordered`>",1
+sjlabelled,as_numeric_helper,1,0,0,any,1
+sjlabelled,as_numeric_helper,2,0,0,any,1
+sjlabelled,as_numeric_helper,3,0,0,any,1
+sjlabelled,convert_case,-1,0,0,character[],1
+sjlabelled,convert_case,-1,0,1,null,1
+sjlabelled,convert_case,0,0,0,character[],1
+sjlabelled,convert_case,0,0,1,null,1
+sjlabelled,convert_case,1,0,0,character,1
+sjlabelled,convert_case,1,0,1,null,1
+sjlabelled,convert_case,2,0,0,logical,1
+sjlabelled,convert_case,3,0,0,...,1
+sjlabelled,copy_labels,-1,0,0,class<`data.frame`>,1
+sjlabelled,copy_labels,0,0,0,class<`data.frame`>,1
+sjlabelled,copy_labels,1,0,0,null,1
+sjlabelled,copy_labels,1,0,1,class<`data.frame`>,1
+sjlabelled,copy_labels,2,0,0,...,1
+sjlabelled,drop_labels,-1,0,0,class<`haven_labelled`>,1
+sjlabelled,drop_labels,-1,0,1,^double[],1
+sjlabelled,drop_labels,0,0,0,class<`haven_labelled`>,1
+sjlabelled,drop_labels,0,0,1,^double[],1
+sjlabelled,drop_labels,1,0,0,...,1
+sjlabelled,drop_labels,2,0,0,logical,1
+sjlabelled,drop_labels_helper,-1,0,0,class<`haven_labelled`>,1
+sjlabelled,drop_labels_helper,-1,0,1,^double[],1
+sjlabelled,drop_labels_helper,0,0,0,class<`haven_labelled`>,1
+sjlabelled,drop_labels_helper,0,0,1,^double[],1
+sjlabelled,drop_labels_helper,1,0,0,logical,1
+sjlabelled,fill_labels,-1,0,0,class<`haven_labelled`>,1
+sjlabelled,fill_labels,-1,0,1,^double[],1
+sjlabelled,fill_labels,0,0,0,class<`haven_labelled`>,1
+sjlabelled,fill_labels,0,0,1,^double[],1
+sjlabelled,fill_labels,1,0,0,...,1
+sjlabelled,fill_labels_helper,-1,0,0,class<`haven_labelled`>,1
+sjlabelled,fill_labels_helper,-1,0,1,^double[],1
+sjlabelled,fill_labels_helper,0,0,0,class<`haven_labelled`>,1
+sjlabelled,fill_labels_helper,0,0,1,^double[],1
+sjlabelled,.get_dot_data,-1,0,0,character[],1
+sjlabelled,.get_dot_data,-1,0,1,class<`data.frame`>,1
+sjlabelled,.get_dot_data,-1,0,2,class<`factor`>,1
+sjlabelled,.get_dot_data,-1,0,3,class<`haven_labelled`>,1
+sjlabelled,.get_dot_data,-1,0,4,^double[],1
+sjlabelled,.get_dot_data,0,0,0,character[],1
+sjlabelled,.get_dot_data,0,0,1,class<`data.frame`>,1
+sjlabelled,.get_dot_data,0,0,2,class<`factor`>,1
+sjlabelled,.get_dot_data,0,0,3,class<`haven_labelled`>,1
+sjlabelled,.get_dot_data,0,0,4,^double[],1
+sjlabelled,.get_dot_data,1,0,0,any,1
+sjlabelled,.get_dot_data,2,0,0,logical,1
+sjlabelled,get_label,-1,0,0,null,1
+sjlabelled,get_label,-1,0,1,character[],1
+sjlabelled,get_label,0,0,0,class<`factor`>,1
+sjlabelled,get_label,0,0,1,^double[],1
+sjlabelled,get_label,0,0,2,list<^double[]>,1
+sjlabelled,get_label,0,0,3,class<`data.frame`>,1
+sjlabelled,get_label,0,0,4,character[],1
+sjlabelled,get_label,0,0,5,"class<`factor`, `ordered`>",1
+sjlabelled,get_label,0,0,6,class<`haven_labelled`>,1
+sjlabelled,get_label,1,0,0,...,1
+sjlabelled,get_label,2,0,0,any,1
+sjlabelled,get_label,3,0,0,null,1
+sjlabelled,get_label,3,0,1,character,1
+sjlabelled,get_label.data.frame,-1,0,0,character[],1
+sjlabelled,get_label.data.frame,0,0,0,class<`data.frame`>,1
+sjlabelled,get_label.data.frame,1,0,0,...,1
+sjlabelled,get_label.data.frame,2,0,0,any,1
+sjlabelled,get_label.data.frame,3,0,0,null,1
+sjlabelled,get_label.data.frame,3,0,1,character,1
+sjlabelled,get_label.default,-1,0,0,character,1
+sjlabelled,get_label.default,-1,0,1,null,1
+sjlabelled,get_label.default,0,0,0,class<`factor`>,1
+sjlabelled,get_label.default,0,0,1,^double[],1
+sjlabelled,get_label.default,0,0,2,character[],1
+sjlabelled,get_label.default,0,0,3,"class<`factor`, `ordered`>",1
+sjlabelled,get_label.default,0,0,4,class<`haven_labelled`>,1
+sjlabelled,get_label.default,1,0,0,...,1
+sjlabelled,get_label.default,2,0,0,null,1
+sjlabelled,get_label.default,2,0,1,character,1
+sjlabelled,get_label.default,3,0,0,null,1
+sjlabelled,get_label.list,-1,0,0,character[],1
+sjlabelled,get_label.list,0,0,0,list<^double[]>,1
+sjlabelled,get_label.list,1,0,0,...,1
+sjlabelled,get_label.list,2,0,0,null,1
+sjlabelled,get_label.list,3,0,0,null,1
+sjlabelled,get_labels,-1,0,0,character[],1
+sjlabelled,get_labels,-1,0,1,null,1
+sjlabelled,get_labels,-1,0,2,list<character[]>,1
+sjlabelled,get_labels,-1,0,3,list<null | character[]>,1
+sjlabelled,get_labels,-1,0,4,list<character[] | null>,1
+sjlabelled,get_labels,0,0,0,^double[],1
+sjlabelled,get_labels,0,0,1,class<`factor`>,1
+sjlabelled,get_labels,0,0,2,character[],1
+sjlabelled,get_labels,0,0,3,class<`haven_labelled`>,1
+sjlabelled,get_labels,0,0,4,list<^double[]>,1
+sjlabelled,get_labels,0,0,5,"class<`factor`, `ordered`>",1
+sjlabelled,get_labels,0,0,6,class<`data.frame`>,1
+sjlabelled,get_labels,1,0,0,any,1
+sjlabelled,get_labels,2,0,0,any,1
+sjlabelled,get_labels,3,0,0,any,1
+sjlabelled,get_labels,4,0,0,any,1
+sjlabelled,get_labels,5,0,0,logical,1
+sjlabelled,get_labels.data.frame,-1,0,0,list<null | character[]>,1
+sjlabelled,get_labels.data.frame,-1,0,1,list<character[] | null>,1
+sjlabelled,get_labels.data.frame,-1,0,2,list<character[]>,1
+sjlabelled,get_labels.data.frame,0,0,0,class<`data.frame`>,1
+sjlabelled,get_labels.data.frame,1,0,0,logical,1
+sjlabelled,get_labels.data.frame,2,0,0,null,1
+sjlabelled,get_labels.data.frame,2,0,1,character,1
+sjlabelled,get_labels.data.frame,3,0,0,logical,1
+sjlabelled,get_labels.data.frame,4,0,0,logical,1
+sjlabelled,get_labels.data.frame,5,0,0,logical,1
+sjlabelled,get_labels.default,-1,0,0,character[],1
+sjlabelled,get_labels.default,-1,0,1,null,1
+sjlabelled,get_labels.default,0,0,0,character[],1
+sjlabelled,get_labels.default,0,0,1,class<`factor`>,1
+sjlabelled,get_labels.default,0,0,2,class<`haven_labelled`>,1
+sjlabelled,get_labels.default,0,0,3,^double[],1
+sjlabelled,get_labels.default,0,0,4,"class<`factor`, `ordered`>",1
+sjlabelled,get_labels.default,1,0,0,any,1
+sjlabelled,get_labels.default,2,0,0,any,1
+sjlabelled,get_labels.default,3,0,0,any,1
+sjlabelled,get_labels.default,4,0,0,any,1
+sjlabelled,get_labels.default,5,0,0,logical,1
+sjlabelled,get_labels_helper,-1,0,0,character[],1
+sjlabelled,get_labels_helper,-1,0,1,null,1
+sjlabelled,get_labels_helper,0,0,0,^double[],1
+sjlabelled,get_labels_helper,0,0,1,character[],1
+sjlabelled,get_labels_helper,0,0,2,class<`factor`>,1
+sjlabelled,get_labels_helper,0,0,3,class<`haven_labelled`>,1
+sjlabelled,get_labels_helper,0,0,4,"class<`factor`, `ordered`>",1
+sjlabelled,get_labels_helper,1,0,0,any,1
+sjlabelled,get_labels_helper,2,0,0,any,1
+sjlabelled,get_labels_helper,3,0,0,any,1
+sjlabelled,get_labels_helper,4,0,0,any,1
+sjlabelled,get_labels_helper,5,0,0,logical,1
+sjlabelled,get_labels.list,-1,0,0,list<character[]>,1
+sjlabelled,get_labels.list,0,0,0,list<^double[]>,1
+sjlabelled,get_labels.list,1,0,0,logical,1
+sjlabelled,get_labels.list,2,0,0,null,1
+sjlabelled,get_labels.list,3,0,0,logical,1
+sjlabelled,get_labels.list,4,0,0,logical,1
+sjlabelled,get_labels.list,5,0,0,logical,1
+sjlabelled,get_na,-1,0,0,null,1
+sjlabelled,get_na,-1,0,1,character[],1
+sjlabelled,get_na,-1,0,2,^double[],1
+sjlabelled,get_na,-1,0,3,list<^double[]>,1
+sjlabelled,get_na,-1,0,4,list<^double[] | null>,1
+sjlabelled,get_na,0,0,0,^double[],1
+sjlabelled,get_na,0,0,1,class<`factor`>,1
+sjlabelled,get_na,0,0,2,class<`haven_labelled`>,1
+sjlabelled,get_na,0,0,3,character[],1
+sjlabelled,get_na,0,0,4,class<`data.frame`>,1
+sjlabelled,get_na,1,0,0,logical,1
+sjlabelled,get_na.data.frame,-1,0,0,list<^double[]>,1
+sjlabelled,get_na.data.frame,-1,0,1,list<^double[] | null>,1
+sjlabelled,get_na.data.frame,0,0,0,class<`data.frame`>,1
+sjlabelled,get_na.data.frame,1,0,0,logical,1
+sjlabelled,get_na.default,-1,0,0,character[],1
+sjlabelled,get_na.default,-1,0,1,^double[],1
+sjlabelled,get_na.default,-1,0,2,null,1
+sjlabelled,get_na.default,0,0,0,class<`factor`>,1
+sjlabelled,get_na.default,0,0,1,class<`haven_labelled`>,1
+sjlabelled,get_na.default,0,0,2,^double[],1
+sjlabelled,get_na.default,0,0,3,character[],1
+sjlabelled,get_na.default,1,0,0,logical,1
+sjlabelled,get_na_helper,-1,0,0,^double[],1
+sjlabelled,get_na_helper,-1,0,1,null,1
+sjlabelled,get_na_helper,-1,0,2,character[],1
+sjlabelled,get_na_helper,0,0,0,^double[],1
+sjlabelled,get_na_helper,0,0,1,class<`haven_labelled`>,1
+sjlabelled,get_na_helper,0,0,2,class<`factor`>,1
+sjlabelled,get_na_helper,0,0,3,character[],1
+sjlabelled,get_na_helper,1,0,0,any,1
+sjlabelled,get_value_range,-1,0,0,list<double>,1
+sjlabelled,get_value_range,0,0,0,class<`factor`>,1
+sjlabelled,get_value_range,0,0,1,class<`haven_labelled`>,1
+sjlabelled,get_value_range,0,0,2,^double[],1
+sjlabelled,get_values,-1,0,0,character[],1
+sjlabelled,get_values,-1,0,1,double[],1
+sjlabelled,get_values,-1,0,2,null,1
+sjlabelled,get_values,-1,0,3,list<character[]>,1
+sjlabelled,get_values,0,0,0,class<`haven_labelled`>,1
+sjlabelled,get_values,0,0,1,^double[],1
+sjlabelled,get_values,0,0,2,class<`factor`>,1
+sjlabelled,get_values,0,0,3,class<`data.frame`>,1
+sjlabelled,get_values,1,0,0,logical,1
+sjlabelled,get_values,2,0,0,any,1
+sjlabelled,get_values.data.frame,-1,0,0,list<character[]>,1
+sjlabelled,get_values.data.frame,0,0,0,class<`data.frame`>,1
+sjlabelled,get_values.data.frame,1,0,0,logical,1
+sjlabelled,get_values.data.frame,2,0,0,logical,1
+sjlabelled,get_values.default,-1,0,0,character[],1
+sjlabelled,get_values.default,-1,0,1,double[],1
+sjlabelled,get_values.default,-1,0,2,null,1
+sjlabelled,get_values.default,0,0,0,class<`haven_labelled`>,1
+sjlabelled,get_values.default,0,0,1,^double[],1
+sjlabelled,get_values.default,0,0,2,class<`factor`>,1
+sjlabelled,get_values.default,1,0,0,logical,1
+sjlabelled,get_values.default,2,0,0,any,1
+sjlabelled,get_values_helper,-1,0,0,character[],1
+sjlabelled,get_values_helper,-1,0,1,double[],1
+sjlabelled,get_values_helper,-1,0,2,null,1
+sjlabelled,get_values_helper,0,0,0,class<`haven_labelled`>,1
+sjlabelled,get_values_helper,0,0,1,^double[],1
+sjlabelled,get_values_helper,0,0,2,class<`factor`>,1
+sjlabelled,get_values_helper,1,0,0,any,1
+sjlabelled,get_values_helper,2,0,0,any,1
+sjlabelled,isempty,-1,0,0,logical,1
+sjlabelled,isempty,0,0,0,character,1
+sjlabelled,isempty,0,0,1,^double[],1
+sjlabelled,isempty,0,0,2,null,1
+sjlabelled,isempty,1,0,0,logical,1
+sjlabelled,is_labelled,-1,0,0,logical,1
+sjlabelled,is_labelled,0,0,0,class<`factor`>,1
+sjlabelled,is_labelled,0,0,1,^double[],1
+sjlabelled,.is_num_chr,-1,0,0,logical,1
+sjlabelled,.is_num_chr,0,0,0,character[],1
+sjlabelled,.is_num_chr,0,0,1,double[],1
+sjlabelled,.is_num_fac,-1,0,0,logical,1
+sjlabelled,.is_num_fac,0,0,0,character[],1
+sjlabelled,.is_num_fac,0,0,1,double[],1
+sjlabelled,is.num.fac,-1,0,0,logical,1
+sjlabelled,is.num.fac,0,0,0,class<`factor`>,1
+sjlabelled,is.num.fac,0,0,1,"class<`factor`, `ordered`>",1
+sjlabelled,label_to_colnames,-1,0,0,class<`data.frame`>,1
+sjlabelled,label_to_colnames,0,0,0,class<`data.frame`>,1
+sjlabelled,obj_has_name,-1,0,0,logical,1
+sjlabelled,obj_has_name,0,0,0,class<`data.frame`>,1
+sjlabelled,obj_has_name,1,0,0,character,1
+sjlabelled,prepare.labels,-1,0,0,character[],1
+sjlabelled,prepare.labels,0,0,0,character[],1
+sjlabelled,prepare.labels,1,0,0,logical[],1
+sjlabelled,prepare.labels,2,0,0,character,1
+sjlabelled,remove_all_labels,-1,0,0,class<`data.frame`>,1
+sjlabelled,remove_all_labels,-1,0,1,class<`factor`>,1
+sjlabelled,remove_all_labels,-1,0,2,integer[],1
+sjlabelled,remove_all_labels,0,0,0,class<`data.frame`>,1
+sjlabelled,remove_all_labels,0,0,1,class<`factor`>,1
+sjlabelled,remove_all_labels,0,0,2,integer[],1
+sjlabelled,remove_all_labels.data.frame,-1,0,0,class<`data.frame`>,1
+sjlabelled,remove_all_labels.data.frame,0,0,0,class<`data.frame`>,1
+sjlabelled,remove_all_labels.default,-1,0,0,class<`factor`>,1
+sjlabelled,remove_all_labels.default,-1,0,1,integer[],1
+sjlabelled,remove_all_labels.default,0,0,0,class<`factor`>,1
+sjlabelled,remove_all_labels.default,0,0,1,integer[],1
+sjlabelled,remove_all_labels_helper,-1,0,0,class<`factor`>,1
+sjlabelled,remove_all_labels_helper,-1,0,1,integer[],1
+sjlabelled,remove_all_labels_helper,0,0,0,class<`factor`>,1
+sjlabelled,remove_all_labels_helper,0,0,1,integer[],1
+sjlabelled,remove_label,-1,0,0,class<`data.frame`>,1
+sjlabelled,remove_label,0,0,0,class<`data.frame`>,1
+sjlabelled,remove_label,1,0,0,...,1
+sjlabelled,remove_labels,-1,0,0,class<`haven_labelled`>,1
+sjlabelled,remove_labels,-1,0,1,^double[],1
+sjlabelled,remove_labels,0,0,0,class<`haven_labelled`>,1
+sjlabelled,remove_labels,0,0,1,^double[],1
+sjlabelled,remove_labels,1,0,0,...,1
+sjlabelled,remove_labels,2,0,0,null,1
+sjlabelled,remove_labels,2,0,1,double,1
+sjlabelled,remove_labels,2,0,2,character[],1
+sjlabelled,remove_labels_helper,-1,0,0,class<`haven_labelled`>,1
+sjlabelled,remove_labels_helper,-1,0,1,^double[],1
+sjlabelled,remove_labels_helper,0,0,0,class<`haven_labelled`>,1
+sjlabelled,remove_labels_helper,0,0,1,^double[],1
+sjlabelled,remove_labels_helper,1,0,0,null,1
+sjlabelled,remove_labels_helper,1,0,1,double,1
+sjlabelled,remove_labels_helper,1,0,2,character[],1
+sjlabelled,replace_labels,-1,0,0,class<`haven_labelled`>,1
+sjlabelled,replace_labels,-1,0,1,^double[],1
+sjlabelled,replace_labels,0,0,0,class<`haven_labelled`>,1
+sjlabelled,replace_labels,0,0,1,^double[],1
+sjlabelled,replace_labels,1,0,0,...,1
+sjlabelled,replace_labels,2,0,0,null,1
+sjlabelled,response_labels,-1,0,0,character,1
+sjlabelled,response_labels,0,0,0,class<`lm`>,1
+sjlabelled,response_labels,1,0,0,null,1
+sjlabelled,response_labels,2,0,0,logical,1
+sjlabelled,response_labels,3,0,0,logical,1
+sjlabelled,response_labels,4,0,0,...,1
+sjlabelled,set_label,-1,0,0,class<`data.frame`>,1
+sjlabelled,set_label,-1,0,1,class<`factor`>,1
+sjlabelled,set_label,-1,0,2,^double[],1
+sjlabelled,set_label,-1,0,3,list<integer[]>,1
+sjlabelled,set_label,0,0,0,class<`data.frame`>,1
+sjlabelled,set_label,0,0,1,class<`factor`>,1
+sjlabelled,set_label,0,0,2,^double[],1
+sjlabelled,set_label,0,0,3,list<integer[]>,1
+sjlabelled,set_label,1,0,0,character[],1
+sjlabelled,set_label,1,0,1,null,1
+sjlabelled,set_label<-,-1,0,0,class<`factor`>,1
+sjlabelled,set_label<-,-1,0,1,integer[],1
+sjlabelled,set_label<-,0,0,0,class<`factor`>,1
+sjlabelled,set_label<-,0,0,1,integer[],1
+sjlabelled,set_label<-,1,0,0,character,1
+sjlabelled,set_label<-.default,-1,0,0,class<`factor`>,1
+sjlabelled,set_label<-.default,-1,0,1,integer[],1
+sjlabelled,set_label<-.default,0,0,0,class<`factor`>,1
+sjlabelled,set_label<-.default,0,0,1,integer[],1
+sjlabelled,set_label<-.default,1,0,0,character,1
+sjlabelled,set_labels,-1,0,0,^double[],1
+sjlabelled,set_labels,-1,0,1,character[],1
+sjlabelled,set_labels,-1,0,2,class<`data.frame`>,1
+sjlabelled,set_labels,-1,0,3,class<`factor`>,1
+sjlabelled,set_labels,-1,0,4,class<`haven_labelled`>,1
+sjlabelled,set_labels,0,0,0,^double[],1
+sjlabelled,set_labels,0,0,1,character[],1
+sjlabelled,set_labels,0,0,2,class<`data.frame`>,1
+sjlabelled,set_labels,0,0,3,class<`factor`>,1
+sjlabelled,set_labels,0,0,4,class<`haven_labelled`>,1
+sjlabelled,set_labels,1,0,0,...,1
+sjlabelled,set_labels,2,0,0,null,1
+sjlabelled,set_labels,2,0,1,character[],1
+sjlabelled,set_labels,2,0,2,list<character[]>,1
+sjlabelled,set_labels,2,0,3,^double[],1
+sjlabelled,set_labels,3,0,0,any,1
+sjlabelled,set_labels,4,0,0,any,1
+sjlabelled,set_labels,5,0,0,logical,1
+sjlabelled,set_labels_helper,-1,0,0,character[],1
+sjlabelled,set_labels_helper,-1,0,1,class<`factor`>,1
+sjlabelled,set_labels_helper,-1,0,2,class<`haven_labelled`>,1
+sjlabelled,set_labels_helper,-1,0,3,^double[],1
+sjlabelled,set_labels_helper,0,0,0,character[],1
+sjlabelled,set_labels_helper,0,0,1,class<`factor`>,1
+sjlabelled,set_labels_helper,0,0,2,class<`haven_labelled`>,1
+sjlabelled,set_labels_helper,0,0,3,^double[],1
+sjlabelled,set_labels_helper,1,0,0,character[],1
+sjlabelled,set_labels_helper,1,0,1,^double[],1
+sjlabelled,set_labels_helper,1,0,2,null,1
+sjlabelled,set_labels_helper,2,0,0,any,1
+sjlabelled,set_labels_helper,3,0,0,any,1
+sjlabelled,set_labels_helper,4,0,0,any,1
+sjlabelled,set_labels_helper,5,0,0,null,1
+sjlabelled,set_labels_helper,5,0,1,character,1
+sjlabelled,set_na,-1,0,0,class<`data.frame`>,1
+sjlabelled,set_na,-1,0,1,class<`factor`>,1
+sjlabelled,set_na,-1,0,2,^double[],1
+sjlabelled,set_na,0,0,0,class<`data.frame`>,1
+sjlabelled,set_na,0,0,1,class<`factor`>,1
+sjlabelled,set_na,0,0,2,^double[],1
+sjlabelled,set_na,1,0,0,...,1
+sjlabelled,set_na,2,0,0,character[],1
+sjlabelled,set_na,2,0,1,double[],1
+sjlabelled,set_na,2,0,2,list<double[]>,1
+sjlabelled,set_na,3,0,0,logical,1
+sjlabelled,set_na,4,0,0,logical,1
+sjlabelled,set_na_helper,-1,0,0,class<`factor`>,1
+sjlabelled,set_na_helper,-1,0,1,^double[],1
+sjlabelled,set_na_helper,0,0,0,class<`factor`>,1
+sjlabelled,set_na_helper,0,0,1,^double[],1
+sjlabelled,set_na_helper,1,0,0,double[],1
+sjlabelled,set_na_helper,1,0,1,list<double[]>,1
+sjlabelled,set_na_helper,1,0,2,character[],1
+sjlabelled,set_na_helper,2,0,0,any,1
+sjlabelled,set_na_helper,3,0,0,logical,1
+sjlabelled,set_na_helper,4,0,0,any,1
+sjlabelled,string_contains,-1,0,0,integer[],1
+sjlabelled,string_contains,0,0,0,character,1
+sjlabelled,string_contains,1,0,0,character[],1
+sjlabelled,string_starts_with,-1,0,0,integer[],1
+sjlabelled,string_starts_with,0,0,0,character,1
+sjlabelled,string_starts_with,1,0,0,character[],1
+sjlabelled,term_labels,-1,0,0,character[],1
+sjlabelled,term_labels,0,0,0,class<`lm`>,1
+sjlabelled,term_labels,1,0,0,logical,1
+sjlabelled,term_labels,2,0,0,null,1
+sjlabelled,term_labels,3,0,0,character[],1
+sjlabelled,term_labels,4,0,0,...,1
+sjlabelled,tidy_labels,-1,0,0,integer[],1
+sjlabelled,tidy_labels,0,0,0,integer[],1
+sjlabelled,tidy_labels,1,0,0,...,1
+sjlabelled,tidy_labels,2,0,0,character,1
+sjlabelled,tidy_labels,3,0,0,logical,1
+sjlabelled,tidy_labels_helper,-1,0,0,integer[],1
+sjlabelled,tidy_labels_helper,0,0,0,integer[],1
+sjlabelled,tidy_labels_helper,1,0,0,any,1
+sjlabelled,tidy_labels_helper,2,0,0,logical,1
+sjlabelled,to_fac_helper,-1,0,0,class<`factor`>,1
+sjlabelled,to_fac_helper,0,0,0,^double[],1
+sjlabelled,to_fac_helper,1,0,0,logical,1
+sjlabelled,val_labels,-1,0,0,class<`data.frame`>,1
+sjlabelled,val_labels,0,0,0,class<`data.frame`>,1
+sjlabelled,val_labels,1,0,0,...,1
+sjlabelled,val_labels,2,0,0,logical,1
+sjlabelled,val_labels,3,0,0,logical,1
+sjlabelled,val_labels,4,0,0,logical,1
+sjlabelled,var_labels,-1,0,0,class<`data.frame`>,1
+sjlabelled,var_labels,0,0,0,class<`data.frame`>,1
+sjlabelled,var_labels,1,0,0,...,1
+sjlabelled,zap_labels,-1,0,0,class<`data.frame`>,1
+sjlabelled,zap_labels,-1,0,1,^double[],1
+sjlabelled,zap_labels,0,0,0,class<`data.frame`>,1
+sjlabelled,zap_labels,0,0,1,^double[],1
+sjlabelled,zap_labels,1,0,0,...,1
+sjlabelled,zap_labels_helper,-1,0,0,^double[],1
+sjlabelled,zap_labels_helper,0,0,0,^double[],1
+sjlabelled,zap_na_tags,-1,0,0,class<`haven_labelled`>,1
+sjlabelled,zap_na_tags,-1,0,1,^double[],1
+sjlabelled,zap_na_tags,0,0,0,class<`haven_labelled`>,1
+sjlabelled,zap_na_tags,0,0,1,^double[],1
+sjlabelled,zap_na_tags,1,0,0,...,1
+sjlabelled,zap_na_tags_helper,-1,0,0,class<`haven_labelled`>,1
+sjlabelled,zap_na_tags_helper,-1,0,1,^double[],1
+sjlabelled,zap_na_tags_helper,0,0,0,class<`haven_labelled`>,1
+sjlabelled,zap_na_tags_helper,0,0,1,^double[],1
+sjlabelled,zap_unlabelled,-1,0,0,^double[],1
+sjlabelled,zap_unlabelled,0,0,0,^double[],1
+sjlabelled,zap_unlabelled,1,0,0,...,1
+sjlabelled,zap_unlabelled_helper,-1,0,0,^double[],1
+sjlabelled,zap_unlabelled_helper,0,0,0,^double[],1
+slam,abind_simple_sparse_array,-1,0,0,class<`simple_sparse_array`>,1
+slam,abind_simple_sparse_array,0,0,0,...,1
+slam,abind_simple_sparse_array,1,0,0,integer,1
+slam,as.array.simple_sparse_array,-1,0,0,class<`array`>,1
+slam,as.array.simple_sparse_array,-1,0,1,class<`matrix`>,1
+slam,as.array.simple_sparse_array,0,0,0,class<`simple_sparse_array`>,1
+slam,as.array.simple_sparse_array,1,0,0,...,1
+slam,as.array.simple_triplet_matrix,-1,0,0,class<`matrix`>,1
+slam,as.array.simple_triplet_matrix,0,0,0,class<`simple_triplet_matrix`>,1
+slam,as.array.simple_triplet_matrix,1,0,0,...,1
+slam,as.matrix.simple_triplet_matrix,-1,0,0,class<`matrix`>,1
+slam,as.matrix.simple_triplet_matrix,0,0,0,class<`simple_triplet_matrix`>,1
+slam,as.matrix.simple_triplet_matrix,1,0,0,...,1
+slam,as.simple_sparse_array,-1,0,0,class<`simple_sparse_array`>,1
+slam,as.simple_sparse_array,0,0,0,class<`array`>,1
+slam,as.simple_sparse_array,0,0,1,class<`matrix`>,1
+slam,as.simple_sparse_array,0,0,2,class<`simple_sparse_array`>,1
+slam,as.simple_sparse_array,0,0,3,class<`simple_triplet_matrix`>,1
+slam,as.simple_sparse_array,0,0,4,integer[],1
+slam,as.simple_sparse_array.array,-1,0,0,class<`simple_sparse_array`>,1
+slam,as.simple_sparse_array.array,0,0,0,class<`array`>,1
+slam,as.simple_sparse_array.array,0,0,1,class<`matrix`>,1
+slam,as.simple_sparse_array.default,-1,0,0,class<`simple_sparse_array`>,1
+slam,as.simple_sparse_array.default,0,0,0,integer[],1
+slam,as.simple_sparse_array.matrix,-1,0,0,class<`simple_sparse_array`>,1
+slam,as.simple_sparse_array.matrix,0,0,0,class<`array`>,1
+slam,as.simple_sparse_array.matrix,0,0,1,class<`matrix`>,1
+slam,as.simple_sparse_array.simple_triplet_matrix,-1,0,0,class<`simple_sparse_array`>,1
+slam,as.simple_sparse_array.simple_triplet_matrix,0,0,0,class<`simple_triplet_matrix`>,1
+slam,as.simple_triplet_matrix,-1,0,0,class<`simple_triplet_matrix`>,1
+slam,as.simple_triplet_matrix,0,0,0,class<`matrix`>,1
+slam,as.simple_triplet_matrix,0,0,1,class<`simple_sparse_array`>,1
+slam,as.simple_triplet_matrix,0,0,2,class<`simple_triplet_matrix`>,1
+slam,as.simple_triplet_matrix.matrix,-1,0,0,class<`simple_triplet_matrix`>,1
+slam,as.simple_triplet_matrix.matrix,0,0,0,class<`matrix`>,1
+slam,as.simple_triplet_matrix.simple_sparse_array,-1,0,0,class<`simple_triplet_matrix`>,1
+slam,as.simple_triplet_matrix.simple_sparse_array,0,0,0,class<`simple_sparse_array`>,1
+slam,as.vector.simple_sparse_array,-1,0,0,double[],1
+slam,as.vector.simple_sparse_array,-1,0,1,null,1
+slam,as.vector.simple_sparse_array,0,0,0,class<`simple_sparse_array`>,1
+slam,as.vector.simple_sparse_array,1,0,0,character,1
+slam,as.vector.simple_triplet_matrix,-1,0,0,double[],1
+slam,as.vector.simple_triplet_matrix,0,0,0,class<`simple_triplet_matrix`>,1
+slam,as.vector.simple_triplet_matrix,1,0,0,character,1
+slam,colapply_simple_triplet_matrix,-1,0,0,any,1
+slam,colapply_simple_triplet_matrix,0,0,0,class<`simple_triplet_matrix`>,1
+slam,colapply_simple_triplet_matrix,1,0,0,class<`function`>,1
+slam,colapply_simple_triplet_matrix,2,0,0,...,1
+slam,col_means,-1,0,0,^double[],1
+slam,col_means,0,0,0,class<`matrix`>,1
+slam,col_means,0,0,1,class<`simple_triplet_matrix`>,1
+slam,col_means,1,0,0,logical,1
+slam,col_means,2,0,0,double,1
+slam,col_means,3,0,0,...,1
+slam,col_means.default,-1,0,0,^double[],1
+slam,col_means.default,0,0,0,class<`matrix`>,1
+slam,col_means.default,1,0,0,logical,1
+slam,col_means.default,2,0,0,double,1
+slam,col_means.default,3,0,0,...,1
+slam,col_means.simple_triplet_matrix,-1,0,0,^double[],1
+slam,col_means.simple_triplet_matrix,0,0,0,class<`simple_triplet_matrix`>,1
+slam,col_means.simple_triplet_matrix,1,0,0,logical,1
+slam,col_means.simple_triplet_matrix,2,0,0,double,1
+slam,col_means.simple_triplet_matrix,3,0,0,...,1
+slam,col_norms,-1,0,0,integer[],1
+slam,col_norms,0,0,0,class<`matrix`>,1
+slam,col_norms,1,0,0,double,1
+slam,col_sums,-1,0,0,^double[],1
+slam,col_sums,0,0,0,class<`simple_triplet_matrix`>,1
+slam,col_sums,0,0,1,class<`matrix`>,1
+slam,col_sums,1,0,0,logical,1
+slam,col_sums,2,0,0,double,1
+slam,col_sums,3,0,0,...,1
+slam,col_sums.default,-1,0,0,^double[],1
+slam,col_sums.default,0,0,0,class<`matrix`>,1
+slam,col_sums.default,1,0,0,logical,1
+slam,col_sums.default,2,0,0,double,1
+slam,col_sums.default,3,0,0,...,1
+slam,col_sums.simple_triplet_matrix,-1,0,0,^double[],1
+slam,col_sums.simple_triplet_matrix,0,0,0,class<`simple_triplet_matrix`>,1
+slam,col_sums.simple_triplet_matrix,1,0,0,logical,1
+slam,col_sums.simple_triplet_matrix,2,0,0,double,1
+slam,col_sums.simple_triplet_matrix,3,0,0,...,1
+slam,crossapply_simple_triplet_matrix,-1,0,0,any,1
+slam,crossapply_simple_triplet_matrix,0,0,0,class<`matrix`>,1
+slam,crossapply_simple_triplet_matrix,0,0,1,class<`simple_triplet_matrix`>,1
+slam,crossapply_simple_triplet_matrix,1,0,0,class<`simple_triplet_matrix`>,1
+slam,crossapply_simple_triplet_matrix,1,0,1,class<`matrix`>,1
+slam,crossapply_simple_triplet_matrix,1,0,2,null,1
+slam,crossapply_simple_triplet_matrix,2,0,0,class<`function`>,1
+slam,crossapply_simple_triplet_matrix,2,0,1,character,1
+slam,crossapply_simple_triplet_matrix,3,0,0,...,1
+slam,crossprod_simple_triplet_matrix,-1,0,0,class<`matrix`>,1
+slam,crossprod_simple_triplet_matrix,0,0,0,class<`matrix`>,1
+slam,crossprod_simple_triplet_matrix,0,0,1,class<`simple_triplet_matrix`>,1
+slam,crossprod_simple_triplet_matrix,1,0,0,class<`simple_triplet_matrix`>,1
+slam,crossprod_simple_triplet_matrix,1,0,1,class<`matrix`>,1
+slam,crossprod_simple_triplet_matrix,1,0,2,null,1
+slam,dimnames<-.simple_sparse_array,-1,0,0,class<`simple_sparse_array`>,1
+slam,dimnames<-.simple_sparse_array,-1,0,1,class<`simple_triplet_matrix`>,1
+slam,dimnames<-.simple_sparse_array,0,0,0,class<`simple_sparse_array`>,1
+slam,dimnames<-.simple_sparse_array,0,0,1,class<`simple_triplet_matrix`>,1
+slam,dimnames<-.simple_sparse_array,1,0,0,null,1
+slam,dimnames<-.simple_sparse_array,1,0,1,list<character[]>,1
+slam,dimnames<-.simple_sparse_array,1,0,2,list<character[] | null>,1
+slam,dimnames<-.simple_sparse_array,1,0,3,list<null | character[]>,1
+slam,dimnames<-.simple_sparse_array,1,0,4,list<null>,1
+slam,dimnames.simple_sparse_array,-1,0,0,null,1
+slam,dimnames.simple_sparse_array,-1,0,1,list<character[]>,1
+slam,dimnames.simple_sparse_array,-1,0,2,list<character[] | null>,1
+slam,dimnames.simple_sparse_array,-1,0,3,list<null | character[]>,1
+slam,dimnames.simple_sparse_array,-1,0,4,list<null | character>,1
+slam,dimnames.simple_sparse_array,-1,0,5,list<null>,1
+slam,dimnames.simple_sparse_array,0,0,0,class<`simple_sparse_array`>,1
+slam,dimnames.simple_sparse_array,0,0,1,class<`simple_triplet_matrix`>,1
+slam,dimnames<-.simple_triplet_matrix,-1,0,0,class<`simple_sparse_array`>,1
+slam,dimnames<-.simple_triplet_matrix,-1,0,1,class<`simple_triplet_matrix`>,1
+slam,dimnames<-.simple_triplet_matrix,0,0,0,class<`simple_sparse_array`>,1
+slam,dimnames<-.simple_triplet_matrix,0,0,1,class<`simple_triplet_matrix`>,1
+slam,dimnames<-.simple_triplet_matrix,1,0,0,null,1
+slam,dimnames<-.simple_triplet_matrix,1,0,1,list<character[]>,1
+slam,dimnames<-.simple_triplet_matrix,1,0,2,list<character[] | null>,1
+slam,dimnames<-.simple_triplet_matrix,1,0,3,list<null | character[]>,1
+slam,dimnames<-.simple_triplet_matrix,1,0,4,list<null>,1
+slam,dimnames.simple_triplet_matrix,-1,0,0,null,1
+slam,dimnames.simple_triplet_matrix,-1,0,1,list<character[]>,1
+slam,dimnames.simple_triplet_matrix,-1,0,2,list<character[] | null>,1
+slam,dimnames.simple_triplet_matrix,-1,0,3,list<null | character[]>,1
+slam,dimnames.simple_triplet_matrix,-1,0,4,list<null | character>,1
+slam,dimnames.simple_triplet_matrix,-1,0,5,list<null>,1
+slam,dimnames.simple_triplet_matrix,0,0,0,class<`simple_sparse_array`>,1
+slam,dimnames.simple_triplet_matrix,0,0,1,class<`simple_triplet_matrix`>,1
+slam,dim<-.simple_sparse_array,-1,0,0,class<`simple_sparse_array`>,1
+slam,dim<-.simple_sparse_array,0,0,0,class<`simple_sparse_array`>,1
+slam,dim<-.simple_sparse_array,1,0,0,double[],1
+slam,dim.simple_sparse_array,-1,0,0,integer[],1
+slam,dim.simple_sparse_array,0,0,0,class<`simple_sparse_array`>,1
+slam,dim<-.simple_triplet_matrix,-1,0,0,class<`simple_triplet_matrix`>,1
+slam,dim<-.simple_triplet_matrix,0,0,0,class<`simple_triplet_matrix`>,1
+slam,dim<-.simple_triplet_matrix,1,0,0,double[],1
+slam,dim.simple_triplet_matrix,-1,0,0,integer[],1
+slam,dim.simple_triplet_matrix,0,0,0,class<`simple_triplet_matrix`>,1
+slam,drop_simple_sparse_array,-1,0,0,class<`simple_sparse_array`>,1
+slam,drop_simple_sparse_array,-1,0,1,integer[],1
+slam,drop_simple_sparse_array,0,0,0,class<`simple_sparse_array`>,1
+slam,extend_simple_sparse_array,-1,0,0,class<`simple_sparse_array`>,1
+slam,extend_simple_sparse_array,0,0,0,class<`simple_sparse_array`>,1
+slam,extend_simple_sparse_array,1,0,0,integer[],1
+slam,is.numeric.simple_triplet_matrix,-1,0,0,logical,1
+slam,is.numeric.simple_triplet_matrix,0,0,0,class<`simple_triplet_matrix`>,1
+slam,is.simple_sparse_array,-1,0,0,logical,1
+slam,is.simple_sparse_array,0,0,0,class<`simple_sparse_array`>,1
+slam,is.simple_triplet_matrix,-1,0,0,logical,1
+slam,is.simple_triplet_matrix,0,0,0,class<`matrix`>,1
+slam,is.simple_triplet_matrix,0,0,1,class<`simple_sparse_array`>,1
+slam,is.simple_triplet_matrix,0,0,2,class<`simple_triplet_matrix`>,1
+slam,is.simple_triplet_matrix,0,0,3,^double[],1
+slam,matprod_simple_triplet_matrix,-1,0,0,class<`matrix`>,1
+slam,matprod_simple_triplet_matrix,0,0,0,class<`matrix`>,1
+slam,matprod_simple_triplet_matrix,0,0,1,class<`simple_triplet_matrix`>,1
+slam,matprod_simple_triplet_matrix,1,0,0,class<`simple_triplet_matrix`>,1
+slam,matprod_simple_triplet_matrix,1,0,1,class<`matrix`>,1
+slam,.means_simple_triplet_matrix,-1,0,0,^double[],1
+slam,.means_simple_triplet_matrix,0,0,0,class<`simple_triplet_matrix`>,1
+slam,.means_simple_triplet_matrix,1,0,0,integer,1
+slam,.means_simple_triplet_matrix,2,0,0,logical,1
+slam,Ops.simple_triplet_matrix,-1,0,0,class<`simple_triplet_matrix`>,1
+slam,Ops.simple_triplet_matrix,0,0,0,class<`matrix`>,1
+slam,Ops.simple_triplet_matrix,0,0,1,class<`simple_triplet_matrix`>,1
+slam,Ops.simple_triplet_matrix,1,0,0,any,1
+slam,reduce_simple_sparse_array,-1,0,0,class<`simple_sparse_array`>,1
+slam,reduce_simple_sparse_array,0,0,0,class<`simple_sparse_array`>,1
+slam,reduce_simple_sparse_array,1,0,0,logical,1
+slam,reduce_simple_sparse_array,2,0,0,logical,1
+slam,rollup,-1,0,0,class<`array`>,1
+slam,rollup,-1,0,1,class<`matrix`>,1
+slam,rollup,-1,0,2,class<`simple_sparse_array`>,1
+slam,rollup,-1,0,3,class<`simple_triplet_matrix`>,1
+slam,rollup,0,0,0,class<`array`>,1
+slam,rollup,0,0,1,class<`matrix`>,1
+slam,rollup,0,0,2,class<`simple_sparse_array`>,1
+slam,rollup,0,0,3,class<`simple_triplet_matrix`>,1
+slam,rollup,1,0,0,integer[],1
+slam,rollup,2,0,0,any,1
+slam,rollup,3,0,0,any,1
+slam,rollup,4,0,0,...,1
+slam,rollup.array,-1,0,0,class<`array`>,1
+slam,rollup.array,-1,0,1,class<`matrix`>,1
+slam,rollup.array,0,0,0,class<`array`>,1
+slam,rollup.array,0,0,1,class<`matrix`>,1
+slam,rollup.array,1,0,0,integer[],1
+slam,rollup.array,2,0,0,null,1
+slam,rollup.array,2,0,1,^double[],1
+slam,rollup.array,2,0,2,list<double[]>,1
+slam,rollup.array,3,0,0,class<`function`>,1
+slam,rollup.array,4,0,0,...,1
+slam,rollup.array,5,0,0,logical,1
+slam,rollup.array,6,0,0,character,1
+slam,rollup.matrix,-1,0,0,class<`array`>,1
+slam,rollup.matrix,-1,0,1,class<`matrix`>,1
+slam,rollup.matrix,0,0,0,class<`array`>,1
+slam,rollup.matrix,0,0,1,class<`matrix`>,1
+slam,rollup.matrix,1,0,0,integer[],1
+slam,rollup.matrix,2,0,0,null,1
+slam,rollup.matrix,2,0,1,^double[],1
+slam,rollup.matrix,2,0,2,list<double[]>,1
+slam,rollup.matrix,3,0,0,class<`function`>,1
+slam,rollup.matrix,4,0,0,...,1
+slam,rollup.matrix,5,0,0,logical,1
+slam,rollup.matrix,6,0,0,character,1
+slam,rollup.simple_sparse_array,-1,0,0,class<`simple_sparse_array`>,1
+slam,rollup.simple_sparse_array,0,0,0,class<`simple_sparse_array`>,1
+slam,rollup.simple_sparse_array,1,0,0,integer[],1
+slam,rollup.simple_sparse_array,2,0,0,null,1
+slam,rollup.simple_sparse_array,2,0,1,list<double[]>,1
+slam,rollup.simple_sparse_array,2,0,2,^double[],1
+slam,rollup.simple_sparse_array,3,0,0,class<`function`>,1
+slam,rollup.simple_sparse_array,4,0,0,...,1
+slam,rollup.simple_sparse_array,5,0,0,logical,1
+slam,rollup.simple_sparse_array,6,0,0,character[],1
+slam,rollup.simple_sparse_array,7,0,0,character,1
+slam,rollup.simple_triplet_matrix,-1,0,0,class<`simple_triplet_matrix`>,1
+slam,rollup.simple_triplet_matrix,0,0,0,class<`simple_triplet_matrix`>,1
+slam,rollup.simple_triplet_matrix,1,0,0,integer,1
+slam,rollup.simple_triplet_matrix,2,0,0,double[],1
+slam,rollup.simple_triplet_matrix,2,0,1,^integer[],1
+slam,rollup.simple_triplet_matrix,2,0,2,null,1
+slam,rollup.simple_triplet_matrix,2,0,3,list<integer[]>,1
+slam,rollup.simple_triplet_matrix,3,0,0,class<`function`>,1
+slam,rollup.simple_triplet_matrix,4,0,0,...,1
+slam,rollup.simple_triplet_matrix,5,0,0,logical,1
+slam,rowapply_simple_triplet_matrix,-1,0,0,double[],1
+slam,rowapply_simple_triplet_matrix,-1,0,1,list<integer[]>,1
+slam,rowapply_simple_triplet_matrix,0,0,0,class<`simple_triplet_matrix`>,1
+slam,rowapply_simple_triplet_matrix,1,0,0,class<`function`>,1
+slam,rowapply_simple_triplet_matrix,2,0,0,...,1
+slam,row_means,-1,0,0,^double[],1
+slam,row_means,0,0,0,class<`matrix`>,1
+slam,row_means,0,0,1,class<`simple_triplet_matrix`>,1
+slam,row_means,1,0,0,logical,1
+slam,row_means,2,0,0,double,1
+slam,row_means,3,0,0,...,1
+slam,row_means.default,-1,0,0,^double[],1
+slam,row_means.default,0,0,0,class<`matrix`>,1
+slam,row_means.default,1,0,0,logical,1
+slam,row_means.default,2,0,0,double,1
+slam,row_means.default,3,0,0,...,1
+slam,row_means.simple_triplet_matrix,-1,0,0,^double[],1
+slam,row_means.simple_triplet_matrix,0,0,0,class<`simple_triplet_matrix`>,1
+slam,row_means.simple_triplet_matrix,1,0,0,logical,1
+slam,row_means.simple_triplet_matrix,2,0,0,double,1
+slam,row_means.simple_triplet_matrix,3,0,0,...,1
+slam,row_norms,-1,0,0,double[],1
+slam,row_norms,0,0,0,class<`matrix`>,1
+slam,row_norms,1,0,0,double,1
+slam,row_sums,-1,0,0,any,1
+slam,row_sums,0,0,0,class<`simple_triplet_matrix`>,1
+slam,row_sums,0,0,1,class<`matrix`>,1
+slam,row_sums,1,0,0,logical,1
+slam,row_sums,2,0,0,double,1
+slam,row_sums,3,0,0,...,1
+slam,row_sums.default,-1,0,0,^double[],1
+slam,row_sums.default,0,0,0,class<`matrix`>,1
+slam,row_sums.default,1,0,0,logical,1
+slam,row_sums.default,2,0,0,double,1
+slam,row_sums.default,3,0,0,...,1
+slam,row_sums.simple_triplet_matrix,-1,0,0,any,1
+slam,row_sums.simple_triplet_matrix,0,0,0,class<`simple_triplet_matrix`>,1
+slam,row_sums.simple_triplet_matrix,1,0,0,logical,1
+slam,row_sums.simple_triplet_matrix,2,0,0,double,1
+slam,row_sums.simple_triplet_matrix,3,0,0,...,1
+slam,[<-.simple_sparse_array,-1,0,0,any,1
+slam,[<-.simple_sparse_array,0,0,0,class<`simple_sparse_array`>,1
+slam,[<-.simple_sparse_array,1,0,0,...,1
+slam,[<-.simple_sparse_array,2,0,0,double[],1
+slam,[<-.simple_sparse_array,2,0,1,class<`simple_triplet_matrix`>,1
+slam,[<-.simple_sparse_array,2,0,2,null,1
+slam,[.simple_sparse_array,-1,0,0,any,1
+slam,[.simple_sparse_array,0,0,0,class<`simple_sparse_array`>,1
+slam,[.simple_sparse_array,1,0,0,...,1
+slam,simple_sparse_array,-1,0,0,class<`simple_sparse_array`>,1
+slam,simple_sparse_array,0,0,0,class<`matrix`>,1
+slam,simple_sparse_array,0,0,1,integer[],1
+slam,simple_sparse_array,1,0,0,class<`array`>,1
+slam,simple_sparse_array,1,0,1,^complex[],1
+slam,simple_sparse_array,1,0,2,null,1
+slam,simple_sparse_array,2,0,0,double[],1
+slam,simple_sparse_array,2,0,1,null,1
+slam,simple_sparse_array,3,0,0,null,1
+slam,simple_sparse_array,3,0,1,list<null | character>,1
+slam,simple_sparse_array,3,0,2,list<character[]>,1
+slam,simple_sparse_array,3,0,3,list<character | null>,1
+slam,simple_sparse_array,3,0,4,list<character[] | null>,1
+slam,simple_sparse_array,3,0,5,list<null | character[]>,1
+slam,simple_sparse_array,3,0,6,list<null>,1
+slam,simple_sparse_zero_array,-1,0,0,class<`simple_sparse_array`>,1
+slam,simple_sparse_zero_array,0,0,0,double[],1
+slam,simple_sparse_zero_array,1,0,0,character,1
+slam,simple_triplet_diag_matrix,-1,0,0,class<`simple_triplet_matrix`>,1
+slam,simple_triplet_diag_matrix,0,0,0,double,1
+slam,simple_triplet_diag_matrix,0,0,1,integer[],1
+slam,simple_triplet_diag_matrix,1,0,0,double,1
+slam,[<-.simple_triplet_matrix,-1,0,0,class<`simple_triplet_matrix`>,1
+slam,[<-.simple_triplet_matrix,0,0,0,class<`simple_triplet_matrix`>,1
+slam,[<-.simple_triplet_matrix,1,0,0,...,1
+slam,[<-.simple_triplet_matrix,2,0,0,double,1
+slam,[<-.simple_triplet_matrix,2,0,1,integer[],1
+slam,[.simple_triplet_matrix,-1,0,0,any,1
+slam,[.simple_triplet_matrix,0,0,0,class<`simple_triplet_matrix`>,1
+slam,[.simple_triplet_matrix,1,0,0,any,1
+slam,[.simple_triplet_matrix,2,0,0,any,1
+slam,[.simple_triplet_matrix,3,0,0,logical,1
+slam,simple_triplet_matrix,-1,0,0,class<`simple_triplet_matrix`>,1
+slam,simple_triplet_matrix,0,0,0,double[],1
+slam,simple_triplet_matrix,1,0,0,double[],1
+slam,simple_triplet_matrix,2,0,0,^complex[],1
+slam,simple_triplet_matrix,3,0,0,double,1
+slam,simple_triplet_matrix,4,0,0,double,1
+slam,simple_triplet_matrix,5,0,0,null,1
+slam,simple_triplet_matrix,5,0,1,list<character[]>,1
+slam,simple_triplet_matrix,5,0,2,list<null | character>,1
+slam,simple_triplet_matrix,5,0,3,list<character[] | null>,1
+slam,simple_triplet_matrix,5,0,4,list<null | character[]>,1
+slam,simple_triplet_zero_matrix,-1,0,0,class<`simple_triplet_matrix`>,1
+slam,simple_triplet_zero_matrix,0,0,0,double,1
+slam,simple_triplet_zero_matrix,1,0,0,double,1
+slam,simple_triplet_zero_matrix,2,0,0,character,1
+slam,slam_options,-1,0,0,double,1
+slam,slam_options,-1,0,1,list<double>,1
+slam,slam_options,0,0,0,any,1
+slam,slam_options,1,0,0,any,1
+slam,split.simple_triplet_matrix,-1,0,0,list<class<`simple_triplet_matrix`>>,1
+slam,split.simple_triplet_matrix,0,0,0,class<`simple_triplet_matrix`>,1
+slam,split.simple_triplet_matrix,1,0,0,^double[],1
+slam,split.simple_triplet_matrix,2,0,0,logical,1
+slam,split.simple_triplet_matrix,3,0,0,double,1
+slam,split.simple_triplet_matrix,4,0,0,...,1
+slam,.stm_as_subscript,-1,0,0,any,1
+slam,.stm_as_subscript,0,0,0,class<`matrix`>,1
+slam,.stm_as_subscript,0,0,1,class<`simple_triplet_matrix`>,1
+slam,.stm_as_subscript,0,0,2,class<`simple_sparse_array`>,1
+slam,.stm_as_subscript,0,0,3,^double[],1
+slam,.stm_as_subscript,1,0,0,any,1
+slam,.stm_as_subscript,2,0,0,logical,1
+slam,.stm_as_subscript,3,0,0,...,1
+slam,tcrossapply_simple_triplet_matrix,-1,0,0,class<`matrix`>,1
+slam,tcrossapply_simple_triplet_matrix,0,0,0,class<`matrix`>,1
+slam,tcrossapply_simple_triplet_matrix,0,0,1,class<`simple_triplet_matrix`>,1
+slam,tcrossapply_simple_triplet_matrix,1,0,0,class<`simple_triplet_matrix`>,1
+slam,tcrossapply_simple_triplet_matrix,2,0,0,class<`function`>,1
+slam,tcrossapply_simple_triplet_matrix,3,0,0,...,1
+slam,.tcrossprod_bailout,-1,0,0,class<`matrix`>,1
+slam,.tcrossprod_bailout,0,0,0,class<`simple_triplet_matrix`>,1
+slam,.tcrossprod_bailout,1,0,0,class<`matrix`>,1
+slam,.tcrossprod_bailout,1,0,1,class<`simple_triplet_matrix`>,1
+slam,.tcrossprod_bailout,1,0,2,null,1
+slam,.tcrossprod_bailout,2,0,0,logical,1
+slam,.tcrossprod_simple_triplet_matrix,-1,0,0,class<`matrix`>,1
+slam,.tcrossprod_simple_triplet_matrix,0,0,0,class<`simple_triplet_matrix`>,1
+slam,.tcrossprod_simple_triplet_matrix,1,0,0,class<`matrix`>,1
+slam,.tcrossprod_simple_triplet_matrix,1,0,1,class<`simple_triplet_matrix`>,1
+slam,.tcrossprod_simple_triplet_matrix,1,0,2,null,1
+slam,.tcrossprod_simple_triplet_matrix,2,0,0,logical,1
+slam,.tcrossprod_simple_triplet_matrix,3,0,0,logical,1
+slam,.tcrossprod_simple_triplet_matrix,4,0,0,logical,1
+slam,tcrossprod_simple_triplet_matrix,-1,0,0,class<`matrix`>,1
+slam,tcrossprod_simple_triplet_matrix,0,0,0,class<`matrix`>,1
+slam,tcrossprod_simple_triplet_matrix,0,0,1,class<`simple_triplet_matrix`>,1
+slam,tcrossprod_simple_triplet_matrix,1,0,0,class<`simple_triplet_matrix`>,1
+slam,tcrossprod_simple_triplet_matrix,1,0,1,class<`matrix`>,1
+slam,tcrossprod_simple_triplet_matrix,1,0,2,null,1
+slam,t.simple_triplet_matrix,-1,0,0,class<`simple_triplet_matrix`>,1
+slam,t.simple_triplet_matrix,0,0,0,class<`simple_triplet_matrix`>,1
+sn,affineTransSECdistr,-1,0,0,class<`SECdistrMv`>,1
+sn,affineTransSECdistr,0,0,0,class<`SECdistrMv`>,1
+sn,affineTransSECdistr,1,0,0,double[],1
+sn,affineTransSECdistr,2,0,0,class<`matrix`>,1
+sn,affineTransSECdistr,3,0,0,any,1
+sn,affineTransSECdistr,4,0,0,any,1
+sn,affineTransSECdistr,5,0,0,logical,1
+sn,b,-1,0,0,double,1
+sn,b,-1,0,1,null,1
+sn,b,0,0,0,double,1
+sn,b,0,0,1,null,1
+sn,conditionalSECdistr,-1,0,0,class<`SECdistrMv`>,1
+sn,conditionalSECdistr,0,0,0,class<`SECdistrMv`>,1
+sn,conditionalSECdistr,1,0,0,double,1
+sn,conditionalSECdistr,2,0,0,double,1
+sn,conditionalSECdistr,3,0,0,any,1
+sn,conditionalSECdistr,4,0,0,logical,1
+sn,cp2dp,-1,0,0,double[],1
+sn,cp2dp,-1,0,1,list<double[] | class<`matrix`>>,1
+sn,cp2dp,0,0,0,double[],1
+sn,cp2dp,0,0,1,list<double[] | class<`matrix`>>,1
+sn,cp2dp,1,0,0,character,1
+sn,cp2dpMv,-1,0,0,list<double[] | class<`matrix`>>,1
+sn,cp2dpMv,0,0,0,list<double[] | class<`matrix`>>,1
+sn,cp2dpMv,1,0,0,character,1
+sn,cp2dpMv,2,0,0,logical,1
+sn,cp2dpMv,3,0,0,double,1
+sn,cp2dpUv,-1,0,0,double[],1
+sn,cp2dpUv,0,0,0,double[],1
+sn,cp2dpUv,1,0,0,character,1
+sn,cp2dpUv,2,0,0,logical,1
+sn,cp2dpUv,3,0,0,double,1
+sn,delta.etc,-1,0,0,double[],1
+sn,delta.etc,-1,0,1,list<double[] | class<`matrix`>>,1
+sn,delta.etc,0,0,0,double[],1
+sn,delta.etc,1,0,0,null,1
+sn,delta.etc,1,0,1,class<`matrix`>,1
+sn,dmsn,-1,0,0,double[],1
+sn,dmsn,0,0,0,class<`matrix`>,1
+sn,dmsn,1,0,0,double[],1
+sn,dmsn,2,0,0,class<`matrix`>,1
+sn,dmsn,3,0,0,double[],1
+sn,dmsn,4,0,0,double,1
+sn,dmsn,5,0,0,null,1
+sn,dmsn,6,0,0,logical,1
+sn,dmst,-1,0,0,double[],1
+sn,dmst,-1,0,1,null,1
+sn,dmst,0,0,0,any,1
+sn,dmst,1,0,0,any,1
+sn,dmst,2,0,0,any,1
+sn,dmst,3,0,0,any,1
+sn,dmst,4,0,0,double,1
+sn,dmst,5,0,0,list<double[] | class<`matrix`>>,1
+sn,dmst,5,0,1,null,1
+sn,dmst,6,0,0,logical,1
+sn,dp2cp,-1,0,0,double[],1
+sn,dp2cp,-1,0,1,list<double[] | class<`matrix`>>,1
+sn,dp2cp,-1,0,2,list<double[]>,1
+sn,dp2cp,0,0,0,any,1
+sn,dp2cp,1,0,0,any,1
+sn,dp2cp,2,0,0,null,1
+sn,dp2cp,2,0,1,class<`SECdistrUv`>,1
+sn,dp2cp,2,0,2,class<`SECdistrMv`>,1
+sn,dp2cp,3,0,0,character,1
+sn,dp2cp,4,0,0,null,1
+sn,dp2cp,4,0,1,double,1
+sn,dp2cpMv,-1,0,0,list<class<`matrix`> | double[]>,1
+sn,dp2cpMv,-1,0,1,list<double[]>,1
+sn,dp2cpMv,-1,0,2,list<double[] | class<`matrix`>>,1
+sn,dp2cpMv,-1,0,3,list<double[] | class<`matrix`> | list<double[] | class<`matrix`>>>,1
+sn,dp2cpMv,-1,0,4,list<double[] | class<`matrix`> | list<null | double[] | class<`matrix`>>>,1
+sn,dp2cpMv,0,0,0,list<class<`matrix`> | double[]>,1
+sn,dp2cpMv,0,0,1,list<double[] | class<`matrix`>>,1
+sn,dp2cpMv,1,0,0,character,1
+sn,dp2cpMv,2,0,0,character,1
+sn,dp2cpMv,3,0,0,null,1
+sn,dp2cpMv,4,0,0,logical,1
+sn,dp2cpMv,5,0,0,null,1
+sn,dp2cpMv,5,0,1,double,1
+sn,dp2cpUv,-1,0,0,double[],1
+sn,dp2cpUv,0,0,0,double[],1
+sn,dp2cpUv,1,0,0,character,1
+sn,dp2cpUv,2,0,0,character,1
+sn,dp2cpUv,3,0,0,null,1
+sn,dp2cpUv,3,0,1,double,1
+sn,dp2op,-1,0,0,list<class<`matrix`> | double[]>,1
+sn,dp2op,0,0,0,list<class<`matrix`> | double[]>,1
+sn,dp2op,1,0,0,character,1
+sn,dplist2optpar,-1,0,0,double[],1
+sn,dplist2optpar,0,0,0,list<class<`matrix`> | double[]>,1
+sn,dplist2optpar,1,0,0,null,1
+sn,dsc,-1,0,0,double[],1
+sn,dsc,0,0,0,double[],1
+sn,dsc,1,0,0,double,1
+sn,dsc,2,0,0,double,1
+sn,dsc,3,0,0,double,1
+sn,dsc,4,0,0,null,1
+sn,dsc,5,0,0,logical,1
+sn,dsn,-1,0,0,double[],1
+sn,dsn,0,0,0,class<`matrix`>,1
+sn,dsn,0,0,1,double[],1
+sn,dsn,1,0,0,double[],1
+sn,dsn,2,0,0,double,1
+sn,dsn,3,0,0,double,1
+sn,dsn,4,0,0,double,1
+sn,dsn,5,0,0,double[],1
+sn,dsn,5,0,1,null,1
+sn,dsn,6,0,0,logical,1
+sn,dst,-1,0,0,double[],1
+sn,dst,0,0,0,double[],1
+sn,dst,1,0,0,double[],1
+sn,dst,2,0,0,double,1
+sn,dst,3,0,0,double,1
+sn,dst,4,0,0,double,1
+sn,dst,5,0,0,double[],1
+sn,dst,5,0,1,null,1
+sn,dst,6,0,0,logical,1
+sn,dSymmModulated,-1,0,0,double[],1
+sn,dSymmModulated,0,0,0,double[],1
+sn,dSymmModulated,1,0,0,double,1
+sn,dSymmModulated,2,0,0,double,1
+sn,dSymmModulated,3,0,0,character,1
+sn,dSymmModulated,4,0,0,character,1
+sn,dSymmModulated,5,0,0,class<`function`>,1
+sn,dSymmModulated,6,0,0,any,1
+sn,dSymmModulated,7,0,0,any,1
+sn,dSymmModulated,8,0,0,character,1
+sn,dSymmModulated,9,0,0,logical,1
+sn,dSymmModulated,10,0,0,...,1
+sn,duplicationMatrix,-1,0,0,class<`matrix`>,1
+sn,duplicationMatrix,0,0,0,integer,1
+sn,extractSECdistr,-1,0,0,class<`SECdistrMv`>,1
+sn,extractSECdistr,-1,0,1,class<`SECdistrUv`>,1
+sn,extractSECdistr,0,0,0,class<`mselm`>,1
+sn,extractSECdistr,0,0,1,class<`selm`>,1
+sn,extractSECdistr,1,0,0,any,1
+sn,extractSECdistr,2,0,0,any,1
+sn,fitted,-1,0,0,class<`matrix`>,1
+sn,fitted,0,0,0,class<`mselm`>,1
+sn,fitted,1,0,0,...,1
+sn,fitted,-1,1,0,double[],1
+sn,fitted,0,1,0,class<`selm`>,1
+sn,fitted,1,1,0,...,1
+sn,force.symmetry,-1,0,0,class<`matrix`>,1
+sn,force.symmetry,0,0,0,class<`matrix`>,1
+sn,force.symmetry,1,0,0,double,1
+sn,makeSECdistr,-1,0,0,class<`SECdistrMv`>,1
+sn,makeSECdistr,-1,0,1,class<`SECdistrUv`>,1
+sn,makeSECdistr,0,0,0,list<class<`matrix`> | double[]>,1
+sn,makeSECdistr,0,0,1,list<double[] | class<`matrix`>>,1
+sn,makeSECdistr,0,0,2,double[],1
+sn,makeSECdistr,1,0,0,character,1
+sn,makeSECdistr,2,0,0,any,1
+sn,makeSECdistr,3,0,0,any,1
+sn,marginalSECdistr,-1,0,0,class<`SECdistrMv`>,1
+sn,marginalSECdistr,-1,0,1,class<`SECdistrUv`>,1
+sn,marginalSECdistr,0,0,0,class<`SECdistrMv`>,1
+sn,marginalSECdistr,1,0,0,double[],1
+sn,marginalSECdistr,2,0,0,any,1
+sn,marginalSECdistr,3,0,0,logical,1
+sn,mean,-1,0,0,double[],1
+sn,mean,0,0,0,class<`SECdistrMv`>,1
+sn,mean,1,0,0,...,1
+sn,mean,-1,1,0,double,1
+sn,mean,0,1,0,class<`SECdistrUv`>,1
+sn,mean,1,1,0,...,1
+sn,modeSECdistr,-1,0,0,double[],1
+sn,modeSECdistr,0,0,0,any,1
+sn,modeSECdistr,1,0,0,any,1
+sn,modeSECdistr,2,0,0,class<`SECdistrMv`>,1
+sn,modeSECdistr,2,0,1,null,1
+sn,modeSECdistrMv,-1,0,0,double[],1
+sn,modeSECdistrMv,0,0,0,list<double[] | class<`matrix`>>,1
+sn,modeSECdistrMv,0,0,1,list<class<`matrix`> | double[]>,1
+sn,modeSECdistrMv,1,0,0,character,1
+sn,modeSECdistrUv,-1,0,0,double,1
+sn,modeSECdistrUv,0,0,0,double[],1
+sn,modeSECdistrUv,1,0,0,character,1
+sn,msn.cp2dp,-1,0,0,list<double[] | class<`matrix`>>,1
+sn,msn.cp2dp,0,0,0,list<double[] | class<`matrix`>>,1
+sn,msn.cp2dp,1,0,0,any,1
+sn,msn.dev,-1,0,0,double,1
+sn,msn.dev,0,0,0,double[],1
+sn,msn.dev,1,0,0,class<`matrix`>,1
+sn,msn.dev,2,0,0,class<`matrix`>,1
+sn,msn.dev,3,0,0,double[],1
+sn,msn.dev,4,0,0,logical,1
+sn,msn.dp2cp,-1,0,0,list<class<`matrix`> | double[]>,1
+sn,msn.dp2cp,-1,0,1,list<double[] | class<`matrix`> | list<double[] | class<`matrix`>>>,1
+sn,msn.dp2cp,-1,0,2,list<double[] | class<`matrix`>>,1
+sn,msn.dp2cp,0,0,0,list<class<`matrix`> | double[]>,1
+sn,msn.dp2cp,0,0,1,list<double[] | class<`matrix`>>,1
+sn,msn.dp2cp,1,0,0,logical,1
+sn,msn.mle,-1,0,0,list<class<`call`> | double | list<class<`matrix`> | double[] | double | double[] | null | character>>,1
+sn,msn.mle,-1,0,1,list<class<`call`> | double | list<class<`matrix`> | double[] | double | double[] | character>>,1
+sn,msn.mle,0,0,0,class<`matrix`>,1
+sn,msn.mle,1,0,0,class<`matrix`>,1
+sn,msn.mle,2,0,0,null,1
+sn,msn.mle,3,0,0,any,1
+sn,msn.mle,4,0,0,logical,1
+sn,msn.mle,5,0,0,character,1
+sn,msn.mle,6,0,0,list<any>,1
+sn,msn.moment.fit,-1,0,0,list<double[] | class<`matrix`>>,1
+sn,msn.moment.fit,0,0,0,class<`matrix`>,1
+sn,mst.cp2dp,-1,0,0,list<double[] | class<`matrix`>>,1
+sn,mst.cp2dp,0,0,0,list<double[] | class<`matrix`>>,1
+sn,mst.cp2dp,1,0,0,any,1
+sn,mst.cp2dp,2,0,0,any,1
+sn,mst.cp2dp,3,0,0,logical,1
+sn,mst.dp2cp,-1,0,0,null,1
+sn,mst.dp2cp,-1,0,1,list<class<`matrix`>>,1
+sn,mst.dp2cp,-1,0,2,list<class<`matrix`> | double[]>,1
+sn,mst.dp2cp,-1,0,3,list<class<`matrix`> | double>,1
+sn,mst.dp2cp,-1,0,4,list<double[]>,1
+sn,mst.dp2cp,-1,0,5,list<double[] | class<`matrix`>>,1
+sn,mst.dp2cp,-1,0,6,list<double[] | class<`matrix`> | list<null | double[] | class<`matrix`>>>,1
+sn,mst.dp2cp,0,0,0,list<class<`matrix`> | double[]>,1
+sn,mst.dp2cp,0,0,1,list<class<`matrix`> | double>,1
+sn,mst.dp2cp,1,0,0,character,1
+sn,mst.dp2cp,2,0,0,null,1
+sn,mst.dp2cp,3,0,0,any,1
+sn,mst.dp2cp,4,0,0,logical,1
+sn,mst.dp2cp,5,0,0,null,1
+sn,mst.dp2cp,5,0,1,double,1
+sn,mst.gamma2M,-1,0,0,double,1
+sn,mst.gamma2M,0,0,0,double,1
+sn,mst.gamma2M,1,0,0,double,1
+sn,mst.gamma2M,2,0,0,integer,1
+sn,mst.mardia,-1,0,0,double[],1
+sn,mst.mardia,0,0,0,double,1
+sn,mst.mardia,1,0,0,double,1
+sn,mst.mardia,2,0,0,integer,1
+sn,mst.mple,-1,0,0,list<class<`call`> | double | list<class<`matrix`> | double[] | null | double | double[] | character>>,1
+sn,mst.mple,-1,0,1,list<class<`call`> | double | list<any>>,1
+sn,mst.mple,0,0,0,class<`matrix`>,1
+sn,mst.mple,1,0,0,class<`matrix`>,1
+sn,mst.mple,2,0,0,null,1
+sn,mst.mple,3,0,0,double[],1
+sn,mst.mple,4,0,0,null,1
+sn,mst.mple,5,0,0,logical,1
+sn,mst.mple,6,0,0,null,1
+sn,mst.mple,7,0,0,logical,1
+sn,mst.mple,8,0,0,character,1
+sn,mst.mple,9,0,0,list<any>,1
+sn,mst.theta.jacobian,-1,0,0,list<class<`matrix`>>,1
+sn,mst.theta.jacobian,0,0,0,double[],1
+sn,mst.theta.jacobian,1,0,0,integer,1
+sn,mst.theta.jacobian,2,0,0,integer,1
+sn,mst.theta.jacobian,3,0,0,character,1
+sn,op2dp,-1,0,0,list<double[] | class<`matrix`>>,1
+sn,op2dp,-1,0,1,list<class<`matrix`> | double[]>,1
+sn,op2dp,0,0,0,list<double[] | class<`matrix`>>,1
+sn,op2dp,0,0,1,list<class<`matrix`> | double[]>,1
+sn,op2dp,1,0,0,character,1
+sn,optpar2dplist,-1,0,0,list<class<`matrix`> | double[] | list<class<`matrix`> | double[]>>,1
+sn,optpar2dplist,0,0,0,double[],1
+sn,optpar2dplist,1,0,0,integer,1
+sn,optpar2dplist,2,0,0,integer,1
+sn,optpar2dplist,3,0,0,null,1
+sn,optpar2dplist,3,0,1,character[],1
+sn,optpar2dplist,4,0,0,null,1
+sn,optpar2dplist,4,0,1,character[],1
+sn,param.names,-1,0,0,character[],1
+sn,param.names,0,0,0,character,1
+sn,param.names,1,0,0,character,1
+sn,param.names,2,0,0,double,1
+sn,param.names,3,0,0,character[],1
+sn,param.names,3,0,1,null,1
+sn,param.names,4,0,0,any,1
+sn,plot2D.SymmModulated,-1,0,0,list<double[] | class<`matrix`>>,1
+sn,plot2D.SymmModulated,0,0,0,class<`matrix`>,1
+sn,plot2D.SymmModulated,1,0,0,double[],1
+sn,plot2D.SymmModulated,2,0,0,double[],1
+sn,plot2D.SymmModulated,3,0,0,class<`matrix`>,1
+sn,plot2D.SymmModulated,4,0,0,character,1
+sn,plot2D.SymmModulated,5,0,0,character,1
+sn,plot2D.SymmModulated,6,0,0,class<`function`>,1
+sn,plot2D.SymmModulated,7,0,0,null,1
+sn,plot2D.SymmModulated,8,0,0,null,1
+sn,plot2D.SymmModulated,9,0,0,character,1
+sn,plot2D.SymmModulated,10,0,0,...,1
+sn,plot.SECdistrBv,-1,0,0,list<any>,1
+sn,plot.SECdistrBv,0,0,0,class<`SECdistrMv`>,1
+sn,plot.SECdistrBv,1,0,0,class<`matrix`>,1
+sn,plot.SECdistrBv,2,0,0,double[],1
+sn,plot.SECdistrBv,3,0,0,double[],1
+sn,plot.SECdistrBv,4,0,0,character[],1
+sn,plot.SECdistrBv,5,0,0,expression,1
+sn,plot.SECdistrBv,5,0,1,character[],1
+sn,plot.SECdistrBv,6,0,0,character,1
+sn,plot.SECdistrBv,7,0,0,class<`matrix`>,1
+sn,plot.SECdistrBv,7,0,1,null,1
+sn,plot.SECdistrBv,8,0,0,any,1
+sn,plot.SECdistrBv,9,0,0,character,1
+sn,plot.SECdistrBv,10,0,0,...,1
+sn,pmsn,-1,0,0,double[],1
+sn,pmsn,0,0,0,class<`matrix`>,1
+sn,pmsn,0,0,1,double[],1
+sn,pmsn,1,0,0,double[],1
+sn,pmsn,2,0,0,class<`matrix`>,1
+sn,pmsn,3,0,0,double[],1
+sn,pmsn,4,0,0,double,1
+sn,pmsn,5,0,0,null,1
+sn,pmsn,6,0,0,...,1
+sn,pmst,-1,0,0,double,1
+sn,pmst,0,0,0,double[],1
+sn,pmst,1,0,0,double[],1
+sn,pmst,2,0,0,class<`matrix`>,1
+sn,pmst,3,0,0,double[],1
+sn,pmst,4,0,0,double,1
+sn,pmst,5,0,0,null,1
+sn,pmst,6,0,0,...,1
+sn,profile.selm,-1,0,0,list<any>,1
+sn,profile.selm,0,0,0,class<`selm`>,1
+sn,profile.selm,1,0,0,character,1
+sn,profile.selm,2,0,0,character[],1
+sn,profile.selm,3,0,0,double[],1
+sn,profile.selm,3,0,1,list<double[]>,1
+sn,profile.selm,4,0,0,any,1
+sn,profile.selm,5,0,0,list<any>,1
+sn,profile.selm,6,0,0,logical,1
+sn,profile.selm,7,0,0,logical,1
+sn,profile.selm,8,0,0,any,1
+sn,profile.selm,9,0,0,logical,1
+sn,profile.selm,10,0,0,...,1
+sn,psc,-1,0,0,double[],1
+sn,psc,0,0,0,double[],1
+sn,psc,1,0,0,double,1
+sn,psc,2,0,0,double,1
+sn,psc,3,0,0,double,1
+sn,psc,4,0,0,null,1
+sn,psn,-1,0,0,double[],1
+sn,psn,0,0,0,double[],1
+sn,psn,1,0,0,double,1
+sn,psn,2,0,0,double,1
+sn,psn,3,0,0,double,1
+sn,psn,4,0,0,double,1
+sn,psn,5,0,0,double[],1
+sn,psn,5,0,1,null,1
+sn,psn,6,0,0,any,1
+sn,psn,7,0,0,...,1
+sn,pst,-1,0,0,double[],1
+sn,pst,0,0,0,double[],1
+sn,pst,1,0,0,double,1
+sn,pst,2,0,0,double,1
+sn,pst,3,0,0,double,1
+sn,pst,4,0,0,double,1
+sn,pst,5,0,0,double[],1
+sn,pst,5,0,1,null,1
+sn,pst,6,0,0,double,1
+sn,pst,7,0,0,...,1
+sn,pst_int,-1,0,0,double[],1
+sn,pst_int,0,0,0,double[],1
+sn,pst_int,1,0,0,double,1
+sn,pst_int,2,0,0,double,1
+sn,pst_int,3,0,0,double,1
+sn,pst_int,4,0,0,double,1
+sn,qsc,-1,0,0,double[],1
+sn,qsc,0,0,0,double[],1
+sn,qsc,1,0,0,double,1
+sn,qsc,2,0,0,double,1
+sn,qsc,3,0,0,double,1
+sn,qsc,4,0,0,null,1
+sn,qsn,-1,0,0,double[],1
+sn,qsn,0,0,0,double[],1
+sn,qsn,1,0,0,double,1
+sn,qsn,2,0,0,double,1
+sn,qsn,3,0,0,double,1
+sn,qsn,4,0,0,double,1
+sn,qsn,5,0,0,null,1
+sn,qsn,6,0,0,double,1
+sn,qsn,7,0,0,character,1
+sn,qsn,8,0,0,...,1
+sn,qst,-1,0,0,double[],1
+sn,qst,0,0,0,double[],1
+sn,qst,1,0,0,double,1
+sn,qst,2,0,0,double,1
+sn,qst,3,0,0,double,1
+sn,qst,4,0,0,double,1
+sn,qst,5,0,0,double,1
+sn,qst,6,0,0,null,1
+sn,qst,7,0,0,double,1
+sn,qst,8,0,0,...,1
+sn,qst_bounds,-1,0,0,class<`matrix`>,1
+sn,qst_bounds,0,0,0,double[],1
+sn,qst_bounds,1,0,0,double,1
+sn,qst_bounds,2,0,0,double,1
+sn,residuals,-1,0,0,class<`matrix`>,1
+sn,residuals,0,0,0,class<`mselm`>,1
+sn,residuals,1,0,0,...,1
+sn,residuals,-1,1,0,double[],1
+sn,residuals,0,1,0,class<`selm`>,1
+sn,residuals,1,1,0,...,1
+sn,residuals.mselm,-1,0,0,class<`matrix`>,1
+sn,residuals.mselm,0,0,0,class<`mselm`>,1
+sn,residuals.mselm,1,0,0,character,1
+sn,residuals.mselm,2,0,0,...,1
+sn,rmsn,-1,0,0,class<`matrix`>,1
+sn,rmsn,0,0,0,double,1
+sn,rmsn,1,0,0,any,1
+sn,rmsn,2,0,0,any,1
+sn,rmsn,3,0,0,any,1
+sn,rmsn,4,0,0,double,1
+sn,rmsn,5,0,0,list<double[] | class<`matrix`>>,1
+sn,rmsn,5,0,1,null,1
+sn,rmst,-1,0,0,class<`matrix`>,1
+sn,rmst,0,0,0,double,1
+sn,rmst,1,0,0,double[],1
+sn,rmst,2,0,0,class<`matrix`>,1
+sn,rmst,3,0,0,double[],1
+sn,rmst,4,0,0,double,1
+sn,rmst,5,0,0,null,1
+sn,rsc,-1,0,0,double[],1
+sn,rsc,0,0,0,double,1
+sn,rsc,1,0,0,double,1
+sn,rsc,2,0,0,double,1
+sn,rsc,3,0,0,double,1
+sn,rsc,4,0,0,null,1
+sn,rsn,-1,0,0,double[],1
+sn,rsn,0,0,0,double,1
+sn,rsn,1,0,0,double,1
+sn,rsn,2,0,0,double,1
+sn,rsn,3,0,0,double,1
+sn,rsn,4,0,0,double,1
+sn,rsn,5,0,0,double[],1
+sn,rsn,5,0,1,null,1
+sn,rst,-1,0,0,double[],1
+sn,rst,0,0,0,double,1
+sn,rst,1,0,0,double,1
+sn,rst,2,0,0,double,1
+sn,rst,3,0,0,double,1
+sn,rst,4,0,0,double,1
+sn,rst,5,0,0,null,1
+sn,rSymmModulated,-1,0,0,double[],1
+sn,rSymmModulated,0,0,0,double,1
+sn,rSymmModulated,1,0,0,double,1
+sn,rSymmModulated,2,0,0,double,1
+sn,rSymmModulated,3,0,0,character,1
+sn,rSymmModulated,4,0,0,character,1
+sn,rSymmModulated,5,0,0,class<`function`>,1
+sn,rSymmModulated,6,0,0,double,1
+sn,rSymmModulated,7,0,0,double,1
+sn,rSymmModulated,8,0,0,character,1
+sn,rSymmModulated,9,0,0,...,1
+sn,sd,-1,0,0,double,1
+sn,sd,0,0,0,class<`SECdistrUv`>,1
+sn,sd,1,0,0,...,1
+sn,sd,-1,1,0,double,1
+sn,sd,0,1,0,class<`SECdistrUv`>,1
+sn,sd,1,1,0,...,1
+sn,selm,-1,0,0,class<`mselm`>,1
+sn,selm,-1,0,1,class<`selm`>,1
+sn,selm,0,0,0,class<`formula`>,1
+sn,selm,1,0,0,character,1
+sn,selm,2,0,0,any,1
+sn,selm,3,0,0,any,1
+sn,selm,4,0,0,any,1
+sn,selm,5,0,0,any,1
+sn,selm,6,0,0,null,1
+sn,selm,7,0,0,list<any>,1
+sn,selm,8,0,0,character,1
+sn,selm,9,0,0,null,1
+sn,selm,9,0,1,character,1
+sn,selm,10,0,0,logical,1
+sn,selm,11,0,0,logical,1
+sn,selm,12,0,0,logical,1
+sn,selm,13,0,0,null,1
+sn,selm,14,0,0,any,1
+sn,selm,15,0,0,...,1
+sn,selm.fit,-1,0,0,list<any>,1
+sn,selm.fit,0,0,0,class<`matrix`>,1
+sn,selm.fit,1,0,0,double[],1
+sn,selm.fit,1,0,1,class<`matrix`>,1
+sn,selm.fit,2,0,0,character,1
+sn,selm.fit,3,0,0,null,1
+sn,selm.fit,4,0,0,double[],1
+sn,selm.fit,5,0,0,list<any>,1
+sn,selm.fit,6,0,0,null,1
+sn,selm.fit,7,0,0,list<any>,1
+sn,seqLog,-1,0,0,double[],1
+sn,seqLog,0,0,0,double,1
+sn,seqLog,1,0,0,double,1
+sn,seqLog,2,0,0,double,1
+sn,seqLog,3,0,0,logical,1
+sn,sn.cumulants,-1,0,0,class<`matrix`>,1
+sn,sn.cumulants,-1,0,1,double[],1
+sn,sn.cumulants,0,0,0,double,1
+sn,sn.cumulants,1,0,0,double,1
+sn,sn.cumulants,2,0,0,double[],1
+sn,sn.cumulants,3,0,0,double,1
+sn,sn.cumulants,4,0,0,null,1
+sn,sn.cumulants,4,0,1,double[],1
+sn,sn.cumulants,5,0,0,double,1
+sn,sn.infoMv,-1,0,0,list<character | class<`matrix`> | list<class<`matrix`> | double[] | class<`matrix`> | double[] | null>>,1
+sn,sn.infoMv,0,0,0,list<class<`matrix`> | double[]>,1
+sn,sn.infoMv,1,0,0,class<`matrix`>,1
+sn,sn.infoMv,2,0,0,class<`matrix`>,1
+sn,sn.infoMv,3,0,0,double[],1
+sn,sn.infoMv,4,0,0,null,1
+sn,sn.infoMv,5,0,0,double,1
+sn,sn.infoMv,6,0,0,logical,1
+sn,sn.infoUv,-1,0,0,list<any>,1
+sn,sn.infoUv,0,0,0,double[],1
+sn,sn.infoUv,0,0,1,null,1
+sn,sn.infoUv,1,0,0,null,1
+sn,sn.infoUv,1,0,1,double[],1
+sn,sn.infoUv,2,0,0,null,1
+sn,sn.infoUv,2,0,1,class<`matrix`>,1
+sn,sn.infoUv,3,0,0,any,1
+sn,sn.infoUv,4,0,0,any,1
+sn,sn.infoUv,5,0,0,null,1
+sn,sn.infoUv,5,0,1,character,1
+sn,sn.infoUv,6,0,0,double,1
+sn,sn.mple,-1,0,0,list<class<`call`> | double[] | list<double[] | character>>,1
+sn,sn.mple,0,0,0,class<`matrix`>,1
+sn,sn.mple,1,0,0,double[],1
+sn,sn.mple,2,0,0,null,1
+sn,sn.mple,3,0,0,any,1
+sn,sn.mple,4,0,0,character,1
+sn,sn.mple,4,0,1,null,1
+sn,sn.mple,5,0,0,logical,1
+sn,sn.mple,6,0,0,character[],1
+sn,sn.mple,7,0,0,null,1
+sn,sn.mple,7,0,1,list<any>,1
+sn,sn.pdev.gh,-1,0,0,double[],1
+sn,sn.pdev.gh,0,0,0,double[],1
+sn,sn.pdev.gh,1,0,0,class<`matrix`>,1
+sn,sn.pdev.gh,2,0,0,double[],1
+sn,sn.pdev.gh,3,0,0,double[],1
+sn,sn.pdev.gh,4,0,0,class<`function`>,1
+sn,sn.pdev.gh,4,0,1,null,1
+sn,sn.pdev.gh,5,0,0,logical,1
+sn,sn.pdev.gh,6,0,0,logical,1
+sn,st.cp2dp,-1,0,0,double[],1
+sn,st.cp2dp,-1,0,1,null,1
+sn,st.cp2dp,0,0,0,double[],1
+sn,st.cp2dp,1,0,0,character,1
+sn,st.cp2dp,2,0,0,null,1
+sn,st.cp2dp,3,0,0,any,1
+sn,st.cp2dp,4,0,0,double,1
+sn,st.cp2dp,5,0,0,logical,1
+sn,st.cumulants,-1,0,0,^double[],1
+sn,st.cumulants,0,0,0,double,1
+sn,st.cumulants,1,0,0,double,1
+sn,st.cumulants,2,0,0,double,1
+sn,st.cumulants,3,0,0,double,1
+sn,st.cumulants,4,0,0,double[],1
+sn,st.cumulants,4,0,1,null,1
+sn,st.cumulants,5,0,0,double,1
+sn,st.dp2cp,-1,0,0,double[],1
+sn,st.dp2cp,0,0,0,double[],1
+sn,st.dp2cp,1,0,0,character,1
+sn,st.dp2cp,2,0,0,null,1
+sn,st.dp2cp,2,0,1,double,1
+sn,st.dp2cp,3,0,0,logical,1
+sn,st.dp2cp,4,0,0,double,1
+sn,st.dp2cp,4,0,1,null,1
+sn,st.gamma1,-1,0,0,double[],1
+sn,st.gamma1,0,0,0,double[],1
+sn,st.gamma1,1,0,0,double,1
+sn,st.gamma2,-1,0,0,double,1
+sn,st.gamma2,0,0,0,double,1
+sn,st.gamma2,1,0,0,double,1
+sn,st.infoMv,-1,0,0,list<any>,1
+sn,st.infoMv,0,0,0,list<class<`matrix`> | double[]>,1
+sn,st.infoMv,0,0,1,list<class<`matrix`> | double>,1
+sn,st.infoMv,1,0,0,class<`matrix`>,1
+sn,st.infoMv,2,0,0,class<`matrix`>,1
+sn,st.infoMv,3,0,0,double[],1
+sn,st.infoMv,4,0,0,null,1
+sn,st.infoMv,5,0,0,logical,1
+sn,st.infoMv,6,0,0,null,1
+sn,st.infoMv,7,0,0,double,1
+sn,st.infoUv,-1,0,0,list<any>,1
+sn,st.infoUv,0,0,0,double[],1
+sn,st.infoUv,1,0,0,null,1
+sn,st.infoUv,2,0,0,class<`matrix`>,1
+sn,st.infoUv,3,0,0,double[],1
+sn,st.infoUv,4,0,0,double[],1
+sn,st.infoUv,5,0,0,null,1
+sn,st.infoUv,5,0,1,double,1
+sn,st.infoUv,6,0,0,logical,1
+sn,st.infoUv,7,0,0,null,1
+sn,st.infoUv,8,0,0,double,1
+sn,st.mple,-1,0,0,list<any>,1
+sn,st.mple,0,0,0,class<`matrix`>,1
+sn,st.mple,1,0,0,double[],1
+sn,st.mple,2,0,0,null,1
+sn,st.mple,3,0,0,any,1
+sn,st.mple,4,0,0,null,1
+sn,st.mple,4,0,1,double,1
+sn,st.mple,5,0,0,logical,1
+sn,st.mple,6,0,0,null,1
+sn,st.mple,6,0,1,character,1
+sn,st.mple,7,0,0,logical,1
+sn,st.mple,8,0,0,character[],1
+sn,st.mple,9,0,0,null,1
+sn,st.mple,9,0,1,list<any>,1
+sn,st.pdev.gh,-1,0,0,double[],1
+sn,st.pdev.gh,0,0,0,double[],1
+sn,st.pdev.gh,1,0,0,class<`matrix`>,1
+sn,st.pdev.gh,2,0,0,double[],1
+sn,st.pdev.gh,3,0,0,double[],1
+sn,st.pdev.gh,4,0,0,null,1
+sn,st.pdev.gh,4,0,1,double,1
+sn,st.pdev.gh,5,0,0,logical,1
+sn,st.pdev.gh,6,0,0,null,1
+sn,st.pdev.gh,7,0,0,logical,1
+sn,st.pdev.gh,8,0,0,logical,1
+sn,T.Owen,-1,0,0,double[],1
+sn,T.Owen,0,0,0,double[],1
+sn,T.Owen,1,0,0,double,1
+sn,T.Owen,2,0,0,double,1
+sn,T.Owen,3,0,0,double,1
+sn,vech,-1,0,0,double[],1
+sn,vech,0,0,0,class<`matrix`>,1
+sn,vech2mat,-1,0,0,class<`matrix`>,1
+sn,vech2mat,0,0,0,double[],1
+sn,weights.mselm,-1,0,0,null,1
+sn,weights.mselm,0,0,0,class<`mselm`>,1
+sn,weights.mselm,0,0,1,class<`selm`>,1
+sn,weights.mselm,1,0,0,...,1
+sn,weights.selm,-1,0,0,null,1
+sn,weights.selm,0,0,0,class<`mselm`>,1
+sn,weights.selm,0,0,1,class<`selm`>,1
+sn,weights.selm,1,0,0,...,1
+sn,zeta,-1,0,0,class<`matrix`>,1
+sn,zeta,-1,0,1,double[],1
+sn,zeta,0,0,0,double,1
+sn,zeta,1,0,0,class<`matrix`>,1
+sn,zeta,1,0,1,double[],1
+snakecase,abbreviation_internal,-1,0,0,^character[],1
+snakecase,abbreviation_internal,0,0,0,^character[],1
+snakecase,abbreviation_internal,1,0,0,null,1
+snakecase,abbreviation_internal,1,0,1,character[],1
+snakecase,parse1_pat_cap_smalls,-1,0,0,^character[],1
+snakecase,parse1_pat_cap_smalls,0,0,0,^character[],1
+snakecase,parse2_pat_digits,-1,0,0,^character[],1
+snakecase,parse2_pat_digits,0,0,0,^character[],1
+snakecase,parse3_pat_caps,-1,0,0,^character[],1
+snakecase,parse3_pat_caps,0,0,0,^character[],1
+snakecase,parse4_pat_cap,-1,0,0,^character[],1
+snakecase,parse4_pat_cap,0,0,0,^character[],1
+snakecase,parse5_pat_non_alnums,-1,0,0,^character[],1
+snakecase,parse5_pat_non_alnums,0,0,0,^character[],1
+snakecase,parse6_mark_digits,-1,0,0,character,1
+snakecase,parse6_mark_digits,0,0,0,character,1
+snakecase,parse7_pat_caps_smalls,-1,0,0,character,1
+snakecase,parse7_pat_caps_smalls,0,0,0,character,1
+snakecase,parse8_pat_smalls_after_non_alnums,-1,0,0,character,1
+snakecase,parse8_pat_smalls_after_non_alnums,0,0,0,character,1
+snakecase,preprocess_internal,-1,0,0,^character[],1
+snakecase,preprocess_internal,0,0,0,^character[],1
+snakecase,preprocess_internal,1,0,0,character,1
+snakecase,replace_special_characters_internal,-1,0,0,character[],1
+snakecase,replace_special_characters_internal,0,0,0,character[],1
+snakecase,replace_special_characters_internal,1,0,0,character[],1
+snakecase,replace_special_characters_internal,2,0,0,any,1
+snakecase,to_any_case,-1,0,0,^character[],1
+snakecase,to_any_case,0,0,0,^character[],1
+snakecase,to_any_case,1,0,0,character[],1
+snakecase,to_any_case,2,0,0,null,1
+snakecase,to_any_case,2,0,1,character[],1
+snakecase,to_any_case,3,0,0,any,1
+snakecase,to_any_case,4,0,0,any,1
+snakecase,to_any_case,5,0,0,any,1
+snakecase,to_any_case,6,0,0,character[],1
+snakecase,to_any_case,7,0,0,any,1
+snakecase,to_any_case,8,0,0,null,1
+snakecase,to_any_case,8,0,1,character,1
+snakecase,to_lower_camel_case,-1,0,0,^character[],1
+snakecase,to_lower_camel_case,0,0,0,^character[],1
+snakecase,to_lower_camel_case,1,0,0,null,1
+snakecase,to_lower_camel_case,2,0,0,character,1
+snakecase,to_lower_camel_case,3,0,0,double,1
+snakecase,to_lower_camel_case,4,0,0,null,1
+snakecase,to_lower_camel_case,5,0,0,character,1
+snakecase,to_lower_camel_case,6,0,0,null,1
+snakecase,to_lower_camel_case,7,0,0,null,1
+snakecase,to_lower_camel_case,8,0,0,null,1
+snakecase,to_lower_upper_case,-1,0,0,^character[],1
+snakecase,to_lower_upper_case,0,0,0,^character[],1
+snakecase,to_lower_upper_case,1,0,0,null,1
+snakecase,to_lower_upper_case,2,0,0,character,1
+snakecase,to_lower_upper_case,3,0,0,double,1
+snakecase,to_lower_upper_case,4,0,0,null,1
+snakecase,to_lower_upper_case,5,0,0,character,1
+snakecase,to_lower_upper_case,6,0,0,null,1
+snakecase,to_lower_upper_case,7,0,0,null,1
+snakecase,to_lower_upper_case,8,0,0,null,1
+snakecase,to_mixed_case,-1,0,0,^character[],1
+snakecase,to_mixed_case,0,0,0,^character[],1
+snakecase,to_mixed_case,1,0,0,null,1
+snakecase,to_mixed_case,2,0,0,character,1
+snakecase,to_mixed_case,3,0,0,double,1
+snakecase,to_mixed_case,4,0,0,null,1
+snakecase,to_mixed_case,5,0,0,character,1
+snakecase,to_mixed_case,6,0,0,null,1
+snakecase,to_mixed_case,6,0,1,character,1
+snakecase,to_mixed_case,7,0,0,null,1
+snakecase,to_mixed_case,8,0,0,null,1
+snakecase,to_parsed_case,-1,0,0,^character[],1
+snakecase,to_parsed_case,0,0,0,^character[],1
+snakecase,to_parsed_case,1,0,0,null,1
+snakecase,to_parsed_case,2,0,0,character,1
+snakecase,to_parsed_case,3,0,0,double,1
+snakecase,to_parsed_case,4,0,0,null,1
+snakecase,to_parsed_case,5,0,0,character,1
+snakecase,to_parsed_case,6,0,0,null,1
+snakecase,to_parsed_case,7,0,0,null,1
+snakecase,to_parsed_case,8,0,0,null,1
+snakecase,to_parsed_case_internal,-1,0,0,^character[],1
+snakecase,to_parsed_case_internal,0,0,0,^character[],1
+snakecase,to_parsed_case_internal,1,0,0,double,1
+snakecase,to_parsed_case_internal,2,0,0,any,1
+snakecase,to_parsed_case_internal,3,0,0,null,1
+snakecase,to_parsed_case_internal,3,0,1,character[],1
+snakecase,to_parsed_case_internal,4,0,0,any,1
+snakecase,to_random_case,-1,0,0,character[],1
+snakecase,to_random_case,0,0,0,^character[],1
+snakecase,to_random_case,1,0,0,null,1
+snakecase,to_random_case,2,0,0,character,1
+snakecase,to_random_case,3,0,0,double,1
+snakecase,to_random_case,4,0,0,null,1
+snakecase,to_random_case,5,0,0,character,1
+snakecase,to_random_case,6,0,0,null,1
+snakecase,to_random_case,7,0,0,null,1
+snakecase,to_random_case,8,0,0,null,1
+snakecase,to_screaming_snake_case,-1,0,0,^character[],1
+snakecase,to_screaming_snake_case,0,0,0,^character[],1
+snakecase,to_screaming_snake_case,1,0,0,null,1
+snakecase,to_screaming_snake_case,2,0,0,character,1
+snakecase,to_screaming_snake_case,3,0,0,double,1
+snakecase,to_screaming_snake_case,4,0,0,null,1
+snakecase,to_screaming_snake_case,5,0,0,character,1
+snakecase,to_screaming_snake_case,6,0,0,null,1
+snakecase,to_screaming_snake_case,6,0,1,character,1
+snakecase,to_screaming_snake_case,7,0,0,null,1
+snakecase,to_screaming_snake_case,8,0,0,null,1
+snakecase,to_sentence_case,-1,0,0,^character[],1
+snakecase,to_sentence_case,0,0,0,^character[],1
+snakecase,to_sentence_case,1,0,0,null,1
+snakecase,to_sentence_case,2,0,0,character,1
+snakecase,to_sentence_case,3,0,0,double,1
+snakecase,to_sentence_case,4,0,0,null,1
+snakecase,to_sentence_case,5,0,0,character,1
+snakecase,to_sentence_case,6,0,0,null,1
+snakecase,to_sentence_case,7,0,0,null,1
+snakecase,to_sentence_case,8,0,0,null,1
+snakecase,to_snake_case,-1,0,0,^character[],1
+snakecase,to_snake_case,0,0,0,^character[],1
+snakecase,to_snake_case,1,0,0,null,1
+snakecase,to_snake_case,1,0,1,character[],1
+snakecase,to_snake_case,2,0,0,character,1
+snakecase,to_snake_case,3,0,0,double,1
+snakecase,to_snake_case,4,0,0,null,1
+snakecase,to_snake_case,5,0,0,character,1
+snakecase,to_snake_case,6,0,0,null,1
+snakecase,to_snake_case,6,0,1,character,1
+snakecase,to_snake_case,7,0,0,null,1
+snakecase,to_snake_case,8,0,0,null,1
+snakecase,to_swap_case,-1,0,0,^character[],1
+snakecase,to_swap_case,0,0,0,^character[],1
+snakecase,to_swap_case,1,0,0,null,1
+snakecase,to_swap_case,2,0,0,character,1
+snakecase,to_swap_case,3,0,0,double,1
+snakecase,to_swap_case,4,0,0,null,1
+snakecase,to_swap_case,5,0,0,character,1
+snakecase,to_swap_case,6,0,0,null,1
+snakecase,to_swap_case,7,0,0,null,1
+snakecase,to_swap_case,8,0,0,null,1
+snakecase,to_title_case,-1,0,0,^character[],1
+snakecase,to_title_case,0,0,0,^character[],1
+snakecase,to_title_case,1,0,0,null,1
+snakecase,to_title_case,1,0,1,character,1
+snakecase,to_title_case,2,0,0,character,1
+snakecase,to_title_case,3,0,0,double,1
+snakecase,to_title_case,4,0,0,null,1
+snakecase,to_title_case,5,0,0,character,1
+snakecase,to_title_case,6,0,0,null,1
+snakecase,to_title_case,7,0,0,null,1
+snakecase,to_title_case,8,0,0,null,1
+snakecase,to_upper_camel_case,-1,0,0,^character[],1
+snakecase,to_upper_camel_case,0,0,0,^character[],1
+snakecase,to_upper_camel_case,1,0,0,null,1
+snakecase,to_upper_camel_case,1,0,1,character,1
+snakecase,to_upper_camel_case,2,0,0,character,1
+snakecase,to_upper_camel_case,3,0,0,double,1
+snakecase,to_upper_camel_case,4,0,0,null,1
+snakecase,to_upper_camel_case,5,0,0,character,1
+snakecase,to_upper_camel_case,6,0,0,null,1
+snakecase,to_upper_camel_case,6,0,1,character,1
+snakecase,to_upper_camel_case,7,0,0,null,1
+snakecase,to_upper_camel_case,8,0,0,null,1
+snakecase,to_upper_lower_case,-1,0,0,^character[],1
+snakecase,to_upper_lower_case,0,0,0,^character[],1
+snakecase,to_upper_lower_case,1,0,0,null,1
+snakecase,to_upper_lower_case,2,0,0,character,1
+snakecase,to_upper_lower_case,3,0,0,double,1
+snakecase,to_upper_lower_case,4,0,0,null,1
+snakecase,to_upper_lower_case,5,0,0,character,1
+snakecase,to_upper_lower_case,6,0,0,null,1
+snakecase,to_upper_lower_case,7,0,0,null,1
+snakecase,to_upper_lower_case,8,0,0,null,1
+sodium,auth_decrypt,-1,0,0,raw[],1
+sodium,auth_decrypt,0,0,0,raw[],1
+sodium,auth_decrypt,1,0,0,raw[],1
+sodium,auth_decrypt,2,0,0,raw[],1
+sodium,auth_decrypt,3,0,0,raw[],1
+sodium,auth_encrypt,-1,0,0,raw[],1
+sodium,auth_encrypt,0,0,0,raw[],1
+sodium,auth_encrypt,1,0,0,raw[],1
+sodium,auth_encrypt,2,0,0,raw[],1
+sodium,auth_encrypt,3,0,0,raw[],1
+sodium,bin2hex,-1,0,0,character,1
+sodium,bin2hex,0,0,0,raw[],1
+sodium,chacha20,-1,0,0,raw[],1
+sodium,chacha20,0,0,0,double,1
+sodium,chacha20,1,0,0,raw[],1
+sodium,chacha20,2,0,0,raw[],1
+sodium,data_decrypt,-1,0,0,raw[],1
+sodium,data_decrypt,0,0,0,raw[],1
+sodium,data_decrypt,1,0,0,raw[],1
+sodium,data_decrypt,2,0,0,raw[],1
+sodium,data_encrypt,-1,0,0,raw[],1
+sodium,data_encrypt,0,0,0,raw[],1
+sodium,data_encrypt,1,0,0,raw[],1
+sodium,data_encrypt,2,0,0,raw[],1
+sodium,data_tag,-1,0,0,raw[],1
+sodium,data_tag,0,0,0,raw[],1
+sodium,data_tag,1,0,0,raw[],1
+sodium,diffie_hellman,-1,0,0,raw[],1
+sodium,diffie_hellman,0,0,0,raw[],1
+sodium,diffie_hellman,1,0,0,raw[],1
+sodium,hash,-1,0,0,raw[],1
+sodium,hash,0,0,0,raw[],1
+sodium,hash,1,0,0,null,1
+sodium,hash,1,0,1,raw[],1
+sodium,hash,2,0,0,double,1
+sodium,hex2bin,-1,0,0,raw[],1
+sodium,hex2bin,0,0,0,character,1
+sodium,hex2bin,1,0,0,character,1
+sodium,keygen,-1,0,0,raw[],1
+sodium,keygen,0,0,0,raw[],1
+sodium,password_store,-1,0,0,character,1
+sodium,password_store,0,0,0,character,1
+sodium,password_verify,-1,0,0,logical,1
+sodium,password_verify,0,0,0,character,1
+sodium,password_verify,1,0,0,character,1
+sodium,pubkey,-1,0,0,raw[],1
+sodium,pubkey,0,0,0,raw[],1
+sodium,random,-1,0,0,raw[],1
+sodium,random,0,0,0,double,1
+sodium,salsa20,-1,0,0,raw[],1
+sodium,salsa20,0,0,0,double,1
+sodium,salsa20,1,0,0,raw[],1
+sodium,salsa20,2,0,0,raw[],1
+sodium,scrypt,-1,0,0,raw[],1
+sodium,scrypt,0,0,0,raw[],1
+sodium,scrypt,1,0,0,raw[],1
+sodium,scrypt,2,0,0,double,1
+sodium,sha256,-1,0,0,raw[],1
+sodium,sha256,0,0,0,raw[],1
+sodium,sha256,1,0,0,null,1
+sodium,sha256,1,0,1,raw[],1
+sodium,sha512,-1,0,0,raw[],1
+sodium,sha512,0,0,0,raw[],1
+sodium,sha512,1,0,0,null,1
+sodium,sha512,1,0,1,raw[],1
+sodium,shorthash,-1,0,0,raw[],1
+sodium,shorthash,0,0,0,raw[],1
+sodium,shorthash,1,0,0,raw[],1
+sodium,sig_keygen,-1,0,0,raw[],1
+sodium,sig_keygen,0,0,0,raw[],1
+sodium,sig_pubkey,-1,0,0,raw[],1
+sodium,sig_pubkey,0,0,0,raw[],1
+sodium,sig_sign,-1,0,0,raw[],1
+sodium,sig_sign,0,0,0,raw[],1
+sodium,sig_sign,1,0,0,raw[],1
+sodium,sig_verify,-1,0,0,logical,1
+sodium,sig_verify,0,0,0,raw[],1
+sodium,sig_verify,1,0,0,raw[],1
+sodium,sig_verify,2,0,0,raw[],1
+sodium,simple_decrypt,-1,0,0,raw[],1
+sodium,simple_decrypt,0,0,0,raw[],1
+sodium,simple_decrypt,1,0,0,raw[],1
+sodium,simple_encrypt,-1,0,0,raw[],1
+sodium,simple_encrypt,0,0,0,raw[],1
+sodium,simple_encrypt,1,0,0,raw[],1
+sodium,xsalsa20,-1,0,0,raw[],1
+sodium,xsalsa20,0,0,0,double,1
+sodium,xsalsa20,1,0,0,raw[],1
+sodium,xsalsa20,2,0,0,raw[],1
+som,ciplot,-1,0,0,null,1
+som,ciplot,0,0,0,double[],1
+som,ciplot,1,0,0,double[],1
+som,ciplot,2,0,0,double[],1
+som,ciplot,3,0,0,double,1
+som,ciplot,4,0,0,double,1
+som,ciplot,5,0,0,double[],1
+som,filtering,-1,0,0,class<`matrix`>,1
+som,filtering,0,0,0,class<`data.frame`>,1
+som,filtering,1,0,0,double,1
+som,filtering,2,0,0,double,1
+som,filtering,3,0,0,double,1
+som,filtering,4,0,0,double,1
+som,inrange,-1,0,0,logical[],1
+som,inrange,0,0,0,double[],1
+som,inrange,1,0,0,double[],1
+som,normalize,-1,0,0,class<`matrix`>,1
+som,normalize,0,0,0,class<`matrix`>,1
+som,normalize,1,0,0,logical,1
+som,plotcell,-1,0,0,null,1
+som,plotcell,0,0,0,double,1
+som,plotcell,1,0,0,integer,1
+som,plotcell,2,0,0,class<`matrix`>,1
+som,plotcell,2,0,1,double[],1
+som,plotcell,3,0,0,double[],1
+som,plotcell,4,0,0,integer,1
+som,plotcell,5,0,0,double,1
+som,plotcell,6,0,0,double[],1
+som,plotcell,7,0,0,double,1
+som,plot.som,-1,0,0,null,1
+som,plot.som,0,0,0,class<`som`>,1
+som,plot.som,1,0,0,double,1
+som,plot.som,2,0,0,double[],1
+som,plot.som,3,0,0,logical,1
+som,plot.som,4,0,0,double,1
+som,plot.som,5,0,0,double,1
+som,plot.som,6,0,0,character,1
+som,plot.som,7,0,0,character,1
+som,plot.som,8,0,0,...,1
+som,qerror,-1,0,0,double,1
+som,qerror,0,0,0,class<`som`>,1
+som,qerror,1,0,0,double,1
+som,som,-1,0,0,class<`som`>,1
+som,som,0,0,0,class<`matrix`>,1
+som,som,1,0,0,double,1
+som,som,2,0,0,double,1
+som,som,3,0,0,character,1
+som,som,4,0,0,null,1
+som,som,5,0,0,character,1
+som,som,6,0,0,character,1
+som,som,7,0,0,character,1
+som,som,8,0,0,null,1
+som,som,9,0,0,null,1
+som,som,10,0,0,double,1
+som,som,11,0,0,null,1
+som,somgrids,-1,0,0,null,1
+som,somgrids,0,0,0,double,1
+som,somgrids,1,0,0,double,1
+som,somgrids,2,0,0,logical,1
+som,somgrids,3,0,0,double,1
+som,somgrids,4,0,0,logical,1
+som,somgrids,5,0,0,double,1
+som,somgrids,6,0,0,double[],1
+som,som.init,-1,0,0,class<`matrix`>,1
+som,som.init,0,0,0,class<`matrix`>,1
+som,som.init,1,0,0,double,1
+som,som.init,2,0,0,double,1
+som,som.init,3,0,0,character,1
+som,som.par,-1,0,0,list<double[]>,1
+som,som.par,0,0,0,class<`som`>,1
+som,somsum,-1,0,0,class<`data.frame`>,1
+som,somsum,0,0,0,list<any>,1
+spam,adjacency.landkreis,-1,0,0,class<`spam`>,1
+spam,adjacency.landkreis,0,0,0,character,1
+spam,all.equal,-1,0,0,logical,1
+spam,all.equal,0,0,0,class<`matrix`>,1
+spam,all.equal,1,0,0,class<`spam`>,1
+spam,all.equal,2,0,0,...,1
+spam,all.equal,-1,1,0,character[],1
+spam,all.equal,-1,1,1,logical,1
+spam,all.equal,0,1,0,class<`spam`>,1
+spam,all.equal,1,1,0,class<`spam`>,1
+spam,all.equal,2,1,0,...,1
+spam,all.equal,-1,2,0,logical,1
+spam,all.equal,0,2,0,class<`spam`>,1
+spam,all.equal,1,2,0,class<`matrix`>,1
+spam,all.equal,2,2,0,...,1
+spam,all.equal.spam,-1,0,0,character[],1
+spam,all.equal.spam,-1,0,1,logical,1
+spam,all.equal.spam,0,0,0,class<`spam`>,1
+spam,all.equal.spam,1,0,0,class<`spam`>,1
+spam,all.equal.spam,2,0,0,any,1
+spam,all.equal.spam,3,0,0,null,1
+spam,all.equal.spam,4,0,0,logical,1
+spam,all.equal.spam,5,0,0,...,1
+spam,apply.spam,-1,0,0,class<`matrix`>,1
+spam,apply.spam,-1,0,1,class<`spam`>,1
+spam,apply.spam,-1,0,2,double[],1
+spam,apply.spam,-1,0,3,list<class<`table`>>,1
+spam,apply.spam,-1,0,4,list<double[]>,1
+spam,apply.spam,0,0,0,class<`spam`>,1
+spam,apply.spam,1,0,0,double[],1
+spam,apply.spam,1,0,1,null,1
+spam,apply.spam,2,0,0,class<`function`>,1
+spam,apply.spam,3,0,0,...,1
+spam,as.matrix,-1,0,0,class<`matrix`>,1
+spam,as.matrix,0,0,0,class<`spam`>,1
+spam,as.matrix,1,0,0,...,1
+spam,as.matrix.spam,-1,0,0,class<`matrix`>,1
+spam,as.matrix.spam,0,0,0,class<`spam`>,1
+spam,as.matrix.spam,1,0,0,...,1
+spam,assign.spam,-1,0,0,class<`spam`>,1
+spam,assign.spam,0,0,0,class<`spam`>,1
+spam,assign.spam,1,0,0,class<`matrix`>,1
+spam,assign.spam,1,0,1,double,1
+spam,assign.spam,1,0,2,integer[],1
+spam,assign.spam,2,0,0,null,1
+spam,assign.spam,2,0,1,double,1
+spam,assign.spam,2,0,2,integer[],1
+spam,assign.spam,3,0,0,double[],1
+spam,assign.spam,3,0,1,class<`matrix`>,1
+spam,as.spam,-1,0,0,class<`spam`>,1
+spam,as.spam,0,0,0,class<`matrix`>,1
+spam,as.spam,1,0,0,double,1
+spam,as.spam,-1,1,0,class<`spam`>,1
+spam,as.spam,0,1,0,class<`spam.chol.NgPeyton`>,1
+spam,as.spam,1,1,0,double,1
+spam,as.spam,-1,2,0,class<`spam`>,1
+spam,as.spam,0,2,0,class<`matrix`>,1
+spam,as.spam,1,2,0,double,1
+spam,as.spam,-1,3,0,class<`spam`>,1
+spam,as.spam,0,3,0,class<`dist`>,1
+spam,as.spam,0,3,1,class<`matrix`>,1
+spam,as.spam,0,3,2,class<`spam`>,1
+spam,as.spam,0,3,3,class<`spam.chol.NgPeyton`>,1
+spam,as.spam,0,3,4,^double[],1
+spam,as.spam,1,3,0,double,1
+spam,as.spam,-1,4,0,class<`spam`>,1
+spam,as.spam,0,4,0,^double[],1
+spam,as.spam,1,4,0,double,1
+spam,as.spam,-1,5,0,class<`spam`>,1
+spam,as.spam,0,5,0,integer[],1
+spam,as.spam,1,5,0,double,1
+spam,as.spam,-1,6,0,class<`spam`>,1
+spam,as.spam,0,6,0,class<`dist`>,1
+spam,as.spam,1,6,0,double,1
+spam,as.spam,-1,7,0,class<`spam`>,1
+spam,as.spam,0,7,0,class<`spam`>,1
+spam,as.spam,1,7,0,double,1
+spam,as.spam.matrix,-1,0,0,class<`spam`>,1
+spam,as.spam.matrix,0,0,0,class<`matrix`>,1
+spam,as.spam.matrix,1,0,0,double,1
+spam,as.spam.spam,-1,0,0,class<`spam`>,1
+spam,as.spam.spam,0,0,0,class<`spam`>,1
+spam,as.spam.spam,1,0,0,double,1
+spam,backsolve,-1,0,0,class<`matrix`>,1
+spam,backsolve,-1,0,1,double[],1
+spam,backsolve,0,0,0,class<`spam.chol.NgPeyton`>,1
+spam,backsolve,1,0,0,class<`matrix`>,1
+spam,backsolve,1,0,1,double[],1
+spam,backsolve,2,0,0,...,1
+spam,backsolve,-1,1,0,class<`matrix`>,1
+spam,backsolve,0,1,0,class<`matrix`>,1
+spam,backsolve,1,1,0,class<`matrix`>,1
+spam,backsolve,2,1,0,...,1
+spam,backsolve,-1,2,0,class<`matrix`>,1
+spam,backsolve,-1,2,1,double[],1
+spam,backsolve,0,2,0,class<`matrix`>,1
+spam,backsolve,0,2,1,class<`spam.chol.NgPeyton`>,1
+spam,backsolve,1,2,0,class<`matrix`>,1
+spam,backsolve,1,2,1,double[],1
+spam,backsolve,2,2,0,...,1
+spam,bandwidth,-1,0,0,integer[],1
+spam,bandwidth,0,0,0,class<`spam`>,1
+spam,bdiag.spam,-1,0,0,class<`spam`>,1
+spam,bdiag.spam,0,0,0,...,1
+spam,cbind,-1,0,0,class<`spam`>,1
+spam,cbind,0,0,0,...,1
+spam,cbind,1,0,0,double,1
+spam,cbind.spam,-1,0,0,class<`spam`>,1
+spam,cbind.spam,0,0,0,...,1
+spam,cbind.spam,1,0,0,double,1
+spam,checkpivot,-1,0,0,null,1
+spam,checkpivot,0,0,0,double[],1
+spam,checkpivot,1,0,0,integer,1
+spam,checkpivot,2,0,0,character,1
+spam,chol,-1,0,0,class<`spam.chol.NgPeyton`>,1
+spam,chol,0,0,0,class<`spam`>,1
+spam,chol,1,0,0,...,1
+spam,chol,-1,1,0,class<`spam.chol.NgPeyton`>,1
+spam,chol,0,1,0,class<`spam`>,1
+spam,chol,1,1,0,...,1
+spam,chol.spam,-1,0,0,class<`spam.chol.NgPeyton`>,1
+spam,chol.spam,0,0,0,class<`spam`>,1
+spam,chol.spam,1,0,0,character,1
+spam,chol.spam,1,0,1,integer[],1
+spam,chol.spam,2,0,0,character,1
+spam,chol.spam,3,0,0,list<any>,1
+spam,chol.spam,4,0,0,double,1
+spam,chol.spam,5,0,0,null,1
+spam,chol.spam,6,0,0,...,1
+spam,circulant.spam,-1,0,0,class<`spam`>,1
+spam,circulant.spam,0,0,0,double[],1
+spam,circulant.spam,1,0,0,null,1
+spam,circulant.spam,2,0,0,double,1
+spam,cleanup,-1,0,0,class<`spam`>,1
+spam,cleanup,0,0,0,class<`spam`>,1
+spam,cleanup,1,0,0,double,1
+spam,colSums,-1,0,0,double[],1
+spam,colSums,0,0,0,class<`spam`>,1
+spam,colSums,1,0,0,logical,1
+spam,colSums,2,0,0,double,1
+spam,colSums,3,0,0,...,1
+spam,cov.sph,-1,0,0,class<`spam`>,1
+spam,cov.sph,0,0,0,class<`spam`>,1
+spam,cov.sph,1,0,0,double[],1
+spam,cov.sph,2,0,0,...,1
+spam,cov.sph,3,0,0,double,1
+spam,crossprod.spam,-1,0,0,class<`matrix`>,1
+spam,crossprod.spam,0,0,0,class<`spam`>,1
+spam,crossprod.spam,1,0,0,integer[],1
+spam,%d+%,-1,0,0,class<`spam`>,1
+spam,%d+%,0,0,0,integer[],1
+spam,%d+%,1,0,0,class<`spam`>,1
+spam,%d+%,2,0,0,...,1
+spam,%d+%,-1,1,0,class<`matrix`>,1
+spam,%d+%,0,1,0,integer[],1
+spam,%d+%,1,1,0,class<`matrix`>,1
+spam,%d+%,2,1,0,...,1
+spam,%d+%,-1,2,0,class<`matrix`>,1
+spam,%d+%,-1,2,1,class<`spam`>,1
+spam,%d+%,0,2,0,integer[],1
+spam,%d+%,1,2,0,class<`matrix`>,1
+spam,%d+%,1,2,1,class<`spam`>,1
+spam,%d+%,2,2,0,...,1
+spam,det,-1,0,0,double,1
+spam,det,0,0,0,class<`spam`>,1
+spam,det,0,0,1,class<`spam.chol.NgPeyton`>,1
+spam,det,1,0,0,...,1
+spam,determinant,-1,0,0,class<`det`>,1
+spam,determinant,0,0,0,class<`spam.chol.NgPeyton`>,1
+spam,determinant,1,0,0,logical,1
+spam,determinant,2,0,0,...,1
+spam,determinant,-1,1,0,class<`det`>,1
+spam,determinant,0,1,0,class<`spam`>,1
+spam,determinant,1,1,0,logical,1
+spam,determinant,2,1,0,...,1
+spam,determinant.spam.chol.NgPeyton,-1,0,0,class<`det`>,1
+spam,determinant.spam.chol.NgPeyton,0,0,0,class<`spam.chol.NgPeyton`>,1
+spam,determinant.spam.chol.NgPeyton,1,0,0,logical,1
+spam,determinant.spam.chol.NgPeyton,2,0,0,...,1
+spam,diag,-1,0,0,double[],1
+spam,diag,0,0,0,class<`spam`>,1
+spam,diag,1,0,0,any,1
+spam,diag,2,0,0,any,1
+spam,diag,3,0,0,logical,1
+spam,diag<-,-1,0,0,class<`spam`>,1
+spam,diag<-,0,0,0,class<`spam`>,1
+spam,diag<-,1,0,0,double[],1
+spam,diag.of.spam,-1,0,0,double[],1
+spam,diag.of.spam,0,0,0,class<`spam`>,1
+spam,diag.of.spam,1,0,0,any,1
+spam,diag.of.spam,2,0,0,any,1
+spam,diag.spam,-1,0,0,class<`spam`>,1
+spam,diag.spam,-1,0,1,double[],1
+spam,diag.spam,0,0,0,double[],1
+spam,diag.spam,0,0,1,class<`spam`>,1
+spam,diag.spam,1,0,0,any,1
+spam,diag.spam,2,0,0,any,1
+spam,diag.spam<-,-1,0,0,class<`spam`>,1
+spam,diag.spam<-,0,0,0,class<`spam`>,1
+spam,diag.spam<-,1,0,0,double[],1
+spam,diff.spam,-1,0,0,class<`spam`>,1
+spam,diff.spam,0,0,0,class<`spam`>,1
+spam,diff.spam,1,0,0,double,1
+spam,diff.spam,2,0,0,double,1
+spam,diff.spam,3,0,0,...,1
+spam,display,-1,0,0,null,1
+spam,display,0,0,0,class<`spam`>,1
+spam,display,1,0,0,...,1
+spam,display,-1,1,0,null,1
+spam,display,0,1,0,class<`spam`>,1
+spam,display,1,1,0,...,1
+spam,display.spam,-1,0,0,null,1
+spam,display.spam,0,0,0,class<`spam`>,1
+spam,display.spam,1,0,0,character[],1
+spam,display.spam,2,0,0,character,1
+spam,display.spam,3,0,0,character,1
+spam,display.spam,4,0,0,double,1
+spam,display.spam,5,0,0,character,1
+spam,display.spam,6,0,0,...,1
+spam,eigen_approx,-1,0,0,list<null | double[]>,1
+spam,eigen_approx,0,0,0,class<`spam`>,1
+spam,eigen_approx,1,0,0,double,1
+spam,eigen_approx,2,0,0,double,1
+spam,eigen_approx,3,0,0,double,1
+spam,eigen_approx,4,0,0,character,1
+spam,eigen_approx,5,0,0,logical,1
+spam,eigen_approx,6,0,0,logical,1
+spam,eigen_approx,7,0,0,character,1
+spam,eigen.spam,-1,0,0,list<^double[] | null>,1
+spam,eigen.spam,0,0,0,class<`spam`>,1
+spam,eigen.spam,1,0,0,double,1
+spam,eigen.spam,2,0,0,any,1
+spam,eigen.spam,3,0,0,logical,1
+spam,eigen.spam,4,0,0,list<character>,1
+spam,.format.spam,-1,0,0,list<character>,1
+spam,.format.spam,0,0,0,class<`spam`>,1
+spam,.format.spam,0,0,1,class<`spam.chol.NgPeyton`>,1
+spam,.format.spam,1,0,0,...,1
+spam,.format.spam,2,0,0,logical,1
+spam,forwardsolve,-1,0,0,class<`matrix`>,1
+spam,forwardsolve,-1,0,1,double[],1
+spam,forwardsolve,0,0,0,class<`spam.chol.NgPeyton`>,1
+spam,forwardsolve,1,0,0,class<`matrix`>,1
+spam,forwardsolve,1,0,1,double[],1
+spam,forwardsolve,2,0,0,...,1
+spam,forwardsolve,-1,1,0,class<`matrix`>,1
+spam,forwardsolve,-1,1,1,double[],1
+spam,forwardsolve,0,1,0,class<`spam.chol.NgPeyton`>,1
+spam,forwardsolve,1,1,0,class<`matrix`>,1
+spam,forwardsolve,1,1,1,double[],1
+spam,forwardsolve,2,1,0,...,1
+spam,germany.plot,-1,0,0,null,1
+spam,germany.plot,0,0,0,double[],1
+spam,germany.plot,1,0,0,integer[],1
+spam,germany.plot,1,0,1,null,1
+spam,germany.plot,2,0,0,double[],1
+spam,germany.plot,3,0,0,logical,1
+spam,germany.plot,4,0,0,null,1
+spam,germany.plot,5,0,0,double,1
+spam,germany.plot,6,0,0,double,1
+spam,germany.plot,7,0,0,logical,1
+spam,germany.plot,8,0,0,...,1
+spam,getEigenval,-1,0,0,list<^double[]>,1
+spam,getEigenval,0,0,0,double[],1
+spam,getEigenval,1,0,0,integer,1
+spam,getEigenval,2,0,0,integer,1
+spam,getEigenval,3,0,0,integer,1
+spam,getEigenval,4,0,0,logical,1
+spam,grid_trace2,-1,0,0,"class<`gDesc`, `gTree`, `grob`>",1
+spam,grid_trace2,0,0,0,double[],1
+spam,grid_trace2,1,0,0,double[],1
+spam,grid_trace2,2,0,0,null,1
+spam,grid_trace2,3,0,0,null,1
+spam,grid_trace2,4,0,0,null,1
+spam,grid_trace2,5,0,0,character,1
+spam,grid_trace2,6,0,0,character,1
+spam,grid_trace2,7,0,0,character,1
+spam,grid_trace2,8,0,0,double[],1
+spam,grid_trace2,9,0,0,null,1
+spam,grid_trace2,10,0,0,logical,1
+spam,grid_trace2,11,0,0,class<`unit`>,1
+spam,grid_trace2,12,0,0,class<`unit`>,1
+spam,grid_trace2,13,0,0,class<`unit`>,1
+spam,grid_trace2,14,0,0,class<`unit`>,1
+spam,grid_trace2,15,0,0,logical,1
+spam,grid_zoom,-1,0,0,"class<`gDesc`, `gTree`, `grob`>",1
+spam,grid_zoom,0,0,0,"class<`gDesc`, `grob`, `points`>",1
+spam,grid_zoom,0,0,1,"class<`gDesc`, `gTree`, `grob`>",1
+spam,grid_zoom,1,0,0,class<`viewport`>,1
+spam,grid_zoom,2,0,0,character,1
+spam,grid_zoom,3,0,0,any,1
+spam,grid_zoom,4,0,0,any,1
+spam,grid_zoom,5,0,0,double[],1
+spam,grid_zoom,6,0,0,double[],1
+spam,grid_zoom,7,0,0,double[],1
+spam,grid_zoom,8,0,0,logical,1
+spam,grid_zoom,9,0,0,double,1
+spam,grid_zoom,10,0,0,character,1
+spam,grid_zoom,11,0,0,logical,1
+spam,grid_zoom,12,0,0,character,1
+spam,grid_zoom,13,0,0,class<`gpar`>,1
+spam,grid_zoom,14,0,0,null,1
+spam,grid_zoom,14,0,1,class<`gpar`>,1
+spam,grid_zoom,15,0,0,"class<`axis`, `gDesc`, `gTree`, `grob`, `xaxis`>",1
+spam,grid_zoom,15,0,1,null,1
+spam,head,-1,0,0,class<`matrix`>,1
+spam,head,0,0,0,class<`spam`>,1
+spam,head,1,0,0,...,1
+spam,image,-1,0,0,null,1
+spam,image,0,0,0,class<`spam`>,1
+spam,image,1,0,0,...,1
+spam,image.spam,-1,0,0,null,1
+spam,image.spam,0,0,0,class<`spam`>,1
+spam,image.spam,1,0,0,double[],1
+spam,image.spam,2,0,0,any,1
+spam,image.spam,3,0,0,any,1
+spam,image.spam,4,0,0,any,1
+spam,image.spam,5,0,0,any,1
+spam,image.spam,6,0,0,any,1
+spam,image.spam,7,0,0,logical,1
+spam,image.spam,8,0,0,character,1
+spam,image.spam,9,0,0,character,1
+spam,image.spam,10,0,0,any,1
+spam,image.spam,11,0,0,any,1
+spam,image.spam,12,0,0,any,1
+spam,image.spam,13,0,0,logical,1
+spam,image.spam,14,0,0,any,1
+spam,image.spam,15,0,0,...,1
+spam,inefficiencywarning,-1,0,0,null,1
+spam,inefficiencywarning,0,0,0,any,1
+spam,inefficiencywarning,1,0,0,double,1
+spam,is.spam,-1,0,0,logical,1
+spam,is.spam,0,0,0,class<`matrix`>,1
+spam,is.spam,0,0,1,class<`spam`>,1
+spam,is.spam,0,0,2,double[],1
+spam,isSymmetric,-1,0,0,logical,1
+spam,isSymmetric,0,0,0,class<`spam`>,1
+spam,isSymmetric,1,0,0,...,1
+spam,isSymmetric.spam,-1,0,0,logical,1
+spam,isSymmetric.spam,0,0,0,class<`spam`>,1
+spam,isSymmetric.spam,1,0,0,double,1
+spam,isSymmetric.spam,2,0,0,...,1
+spam,kronecker,-1,0,0,class<`spam`>,1
+spam,kronecker,0,0,0,class<`spam`>,1
+spam,kronecker,1,0,0,class<`spam`>,1
+spam,kronecker,2,0,0,character,1
+spam,kronecker,3,0,0,logical,1
+spam,kronecker,4,0,0,...,1
+spam,kronecker,-1,1,0,class<`spam`>,1
+spam,kronecker,0,1,0,class<`spam`>,1
+spam,kronecker,1,1,0,class<`matrix`>,1
+spam,kronecker,2,1,0,character,1
+spam,kronecker,3,1,0,logical,1
+spam,kronecker,4,1,0,...,1
+spam,kronecker.spam,-1,0,0,class<`spam`>,1
+spam,kronecker.spam,0,0,0,class<`matrix`>,1
+spam,kronecker.spam,1,0,0,class<`matrix`>,1
+spam,kronecker.spam,2,0,0,character,1
+spam,kronecker.spam,3,0,0,logical,1
+spam,kronecker.spam,4,0,0,...,1
+spam,lower.tri,-1,0,0,class<`spam`>,1
+spam,lower.tri,0,0,0,class<`spam`>,1
+spam,lower.tri,1,0,0,logical,1
+spam,matrix_add_spammatrix,-1,0,0,class<`matrix`>,1
+spam,matrix_add_spammatrix,0,0,0,class<`spam`>,1
+spam,matrix_add_spammatrix,1,0,0,class<`matrix`>,1
+spam,matrix_sub_matrixspam,-1,0,0,class<`matrix`>,1
+spam,matrix_sub_matrixspam,0,0,0,class<`matrix`>,1
+spam,matrix_sub_matrixspam,1,0,0,class<`spam`>,1
+spam,mle.nomean.spam,-1,0,0,list<double[] | character>,1
+spam,mle.nomean.spam,0,0,0,class<`matrix`>,1
+spam,mle.nomean.spam,1,0,0,class<`spam`>,1
+spam,mle.nomean.spam,2,0,0,class<`function`>,1
+spam,mle.nomean.spam,3,0,0,double[],1
+spam,mle.nomean.spam,4,0,0,double[],1
+spam,mle.nomean.spam,5,0,0,double[],1
+spam,mle.nomean.spam,6,0,0,null,1
+spam,mle.nomean.spam,7,0,0,null,1
+spam,mle.nomean.spam,8,0,0,logical,1
+spam,mle.nomean.spam,9,0,0,...,1
+spam,mle.spam,-1,0,0,list<double[] | character>,1
+spam,mle.spam,0,0,0,double[],1
+spam,mle.spam,1,0,0,class<`matrix`>,1
+spam,mle.spam,2,0,0,class<`spam`>,1
+spam,mle.spam,3,0,0,class<`function`>,1
+spam,mle.spam,4,0,0,double[],1
+spam,mle.spam,5,0,0,double[],1
+spam,mle.spam,6,0,0,double[],1
+spam,mle.spam,7,0,0,double[],1
+spam,mle.spam,8,0,0,null,1
+spam,mle.spam,9,0,0,null,1
+spam,mle.spam,10,0,0,logical,1
+spam,mle.spam,11,0,0,...,1
+spam,nearest.dist,-1,0,0,class<`spam`>,1
+spam,nearest.dist,0,0,0,class<`data.frame`>,1
+spam,nearest.dist,0,0,1,class<`matrix`>,1
+spam,nearest.dist,1,0,0,null,1
+spam,nearest.dist,2,0,0,character,1
+spam,nearest.dist,3,0,0,double,1
+spam,nearest.dist,4,0,0,logical,1
+spam,nearest.dist,4,0,1,null,1
+spam,nearest.dist,5,0,0,double,1
+spam,nearest.dist,6,0,0,logical,1
+spam,nearest.dist,7,0,0,null,1
+spam,neg2loglikelihood.spam,-1,0,0,double,1
+spam,neg2loglikelihood.spam,0,0,0,double[],1
+spam,neg2loglikelihood.spam,1,0,0,class<`matrix`>,1
+spam,neg2loglikelihood.spam,2,0,0,class<`spam`>,1
+spam,neg2loglikelihood.spam,3,0,0,class<`function`>,1
+spam,neg2loglikelihood.spam,4,0,0,double[],1
+spam,neg2loglikelihood.spam,5,0,0,double[],1
+spam,neg2loglikelihood.spam,6,0,0,null,1
+spam,neg2loglikelihood.spam,7,0,0,...,1
+spam,.newSpam,-1,0,0,class<`spam`>,1
+spam,.newSpam,0,0,0,^double[],1
+spam,.newSpam,1,0,0,double[],1
+spam,.newSpam,2,0,0,double[],1
+spam,.newSpam,2,0,1,null,1
+spam,.newSpam,3,0,0,double[],1
+spam,.newSpam,4,0,0,logical,1
+spam,norm,-1,0,0,double,1
+spam,norm,0,0,0,class<`matrix`>,1
+spam,norm,1,0,0,character,1
+spam,norm,2,0,0,...,1
+spam,norm,-1,1,0,double,1
+spam,norm,0,1,0,class<`matrix`>,1
+spam,norm,1,1,0,any,1
+spam,norm,2,1,0,...,1
+spam,norm,-1,2,0,double,1
+spam,norm,0,2,0,double[],1
+spam,norm,1,2,0,any,1
+spam,norm,2,2,0,...,1
+spam,norm,-1,3,0,double,1
+spam,norm,0,3,0,class<`spam`>,1
+spam,norm,1,3,0,any,1
+spam,norm,2,3,0,...,1
+spam,norm.spam,-1,0,0,double,1
+spam,norm.spam,0,0,0,class<`spam`>,1
+spam,norm.spam,1,0,0,character,1
+spam,norm.spam,2,0,0,...,1
+spam,ordering,-1,0,0,integer[],1
+spam,ordering,0,0,0,class<`spam.chol.NgPeyton`>,1
+spam,ordering,1,0,0,logical,1
+spam,ordering,-1,1,0,integer[],1
+spam,ordering,0,1,0,class<`spam.chol.NgPeyton`>,1
+spam,ordering,1,1,0,logical,1
+spam,pad<-,-1,0,0,class<`spam`>,1
+spam,pad<-,0,0,0,class<`spam`>,1
+spam,pad<-,1,0,0,double[],1
+spam,pad<-,-1,1,0,class<`spam`>,1
+spam,pad<-,0,1,0,class<`spam`>,1
+spam,pad<-,1,1,0,double[],1
+spam,.par.check.cov,-1,0,0,double[],1
+spam,.par.check.cov,0,0,0,double[],1
+spam,.par.check.cov,1,0,0,double,1
+spam,permutation,-1,0,0,class<`spam`>,1
+spam,permutation,0,0,0,class<`spam`>,1
+spam,permutation,1,0,0,double[],1
+spam,permutation,2,0,0,double[],1
+spam,permutation,3,0,0,logical,1
+spam,permutation,4,0,0,logical,1
+spam,permutation,-1,1,0,class<`spam`>,1
+spam,permutation,0,1,0,class<`spam`>,1
+spam,permutation,1,1,0,double[],1
+spam,permutation,2,1,0,double[],1
+spam,permutation,3,1,0,logical,1
+spam,permutation,4,1,0,logical,1
+spam,precmat.GMRFreglat,-1,0,0,class<`spam`>,1
+spam,precmat.GMRFreglat,0,0,0,double,1
+spam,precmat.GMRFreglat,1,0,0,double,1
+spam,precmat.GMRFreglat,2,0,0,double[],1
+spam,precmat.GMRFreglat,3,0,0,character,1
+spam,precmat.GMRFreglat,4,0,0,double,1
+spam,precmat.IGMRFirreglat,-1,0,0,class<`spam`>,1
+spam,precmat.IGMRFirreglat,0,0,0,class<`matrix`>,1
+spam,precmat.IGMRFirreglat,0,0,1,class<`spam`>,1
+spam,precmat.IGMRFirreglat,1,0,0,double,1
+spam,precmat.IGMRFreglat,-1,0,0,class<`spam`>,1
+spam,precmat.IGMRFreglat,0,0,0,double,1
+spam,precmat.IGMRFreglat,1,0,0,double,1
+spam,precmat.IGMRFreglat,2,0,0,double,1
+spam,precmat.IGMRFreglat,3,0,0,double,1
+spam,precmat.RW1,-1,0,0,class<`spam`>,1
+spam,precmat.RW1,0,0,0,double,1
+spam,precmat.RW2,-1,0,0,class<`spam`>,1
+spam,precmat.RW2,0,0,0,double,1
+spam,precmat.season,-1,0,0,class<`spam`>,1
+spam,precmat.season,0,0,0,double,1
+spam,precmat.season,1,0,0,double,1
+spam,print,-1,0,0,null,1
+spam,print,0,0,0,class<`spam`>,1
+spam,print,1,0,0,...,1
+spam,rbind,-1,0,0,class<`spam`>,1
+spam,rbind,0,0,0,...,1
+spam,rbind,1,0,0,double,1
+spam,rep_len64,-1,0,0,double[],1
+spam,rep_len64,0,0,0,double[],1
+spam,rep_len64,1,0,0,double,1
+spam,rep_len64,2,0,0,any,1
+spam,rmvnorm.canonical,-1,0,0,class<`matrix`>,1
+spam,rmvnorm.canonical,0,0,0,double,1
+spam,rmvnorm.canonical,1,0,0,double[],1
+spam,rmvnorm.canonical,2,0,0,class<`spam`>,1
+spam,rmvnorm.canonical,3,0,0,class<`spam.chol.NgPeyton`>,1
+spam,rmvnorm.canonical,3,0,1,null,1
+spam,rmvnorm.canonical,4,0,0,...,1
+spam,rmvnorm.spam,-1,0,0,class<`matrix`>,1
+spam,rmvnorm.spam,0,0,0,double,1
+spam,rmvnorm.spam,1,0,0,class<`matrix`>,1
+spam,rmvnorm.spam,2,0,0,class<`spam`>,1
+spam,rmvnorm.spam,3,0,0,null,1
+spam,rmvnorm.spam,4,0,0,...,1
+spam,rowpointers<-,-1,0,0,class<`spam`>,1
+spam,rowpointers<-,0,0,0,class<`spam`>,1
+spam,rowpointers<-,1,0,0,double[],1
+spam,rowSums,-1,0,0,double[],1
+spam,rowSums,0,0,0,class<`spam`>,1
+spam,rowSums,1,0,0,logical,1
+spam,rowSums,2,0,0,double,1
+spam,rowSums,3,0,0,...,1
+spam,setMode,-1,0,0,integer,1
+spam,setMode,0,0,0,character,1
+spam,setMode,1,0,0,logical,1
+spam,setMode,2,0,0,logical,1
+spam,solve,-1,0,0,class<`matrix`>,1
+spam,solve,-1,0,1,double[],1
+spam,solve,0,0,0,class<`spam`>,1
+spam,solve,1,0,0,any,1
+spam,solve,2,0,0,...,1
+spam,solve.spam,-1,0,0,double[],1
+spam,solve.spam,0,0,0,class<`spam`>,1
+spam,solve.spam,0,0,1,class<`spam.chol.NgPeyton`>,1
+spam,solve.spam,1,0,0,double[],1
+spam,solve.spam,1,0,1,class<`matrix`>,1
+spam,solve.spam,2,0,0,class<`spam.chol.NgPeyton`>,1
+spam,solve.spam,2,0,1,null,1
+spam,solve.spam,3,0,0,...,1
+spam,spam,-1,0,0,class<`spam`>,1
+spam,spam,0,0,0,list<double[]>,1
+spam,spam,1,0,0,double,1
+spam,spam,2,0,0,double,1
+spam,spam,3,0,0,double,1
+spam,spam,-1,1,0,class<`spam`>,1
+spam,spam,0,1,0,double[],1
+spam,spam,0,1,1,list<double[]>,1
+spam,spam,1,1,0,double,1
+spam,spam,2,1,0,double,1
+spam,spam,3,1,0,double,1
+spam,spam,-1,2,0,class<`spam`>,1
+spam,spam,0,2,0,double[],1
+spam,spam,1,2,0,double,1
+spam,spam,2,2,0,double,1
+spam,spam,3,2,0,double,1
+spam,spam,-1,3,0,class<`spam`>,1
+spam,spam,0,3,0,integer[],1
+spam,spam,1,3,0,double,1
+spam,spam,2,3,0,double,1
+spam,spam,3,3,0,double,1
+spam,spam,-1,4,0,class<`spam`>,1
+spam,spam,0,4,0,double,1
+spam,spam,1,4,0,double,1
+spam,spam,2,4,0,double,1
+spam,spam,3,4,0,double,1
+spam,spam_add,-1,0,0,class<`spam`>,1
+spam,spam_add,0,0,0,class<`spam`>,1
+spam,spam_add,1,0,0,class<`spam`>,1
+spam,spam_add,2,0,0,double,1
+spam,spam.list,-1,0,0,class<`spam`>,1
+spam,spam.list,0,0,0,list<double[]>,1
+spam,spam.list,1,0,0,double,1
+spam,spam.list,2,0,0,double,1
+spam,spam.list,3,0,0,double,1
+spam,spam.numeric,-1,0,0,class<`spam`>,1
+spam,spam.numeric,0,0,0,double[],1
+spam,spam.numeric,1,0,0,integer,1
+spam,spam.numeric,2,0,0,double,1
+spam,spam.numeric,3,0,0,double,1
+spam,spam_random,-1,0,0,class<`spam`>,1
+spam,spam_random,0,0,0,double,1
+spam,spam_random,1,0,0,double,1
+spam,spam_random,2,0,0,double,1
+spam,spam_random,3,0,0,class<`function`>,1
+spam,spam_random,3,0,1,null,1
+spam,spam_random,4,0,0,double,1
+spam,spam_random,4,0,1,null,1
+spam,spam_random,5,0,0,logical,1
+spam,spam_random,6,0,0,logical,1
+spam,spam_random,7,0,0,logical,1
+spam,spam_random,8,0,0,...,1
+spam,subset_rows.spam,-1,0,0,class<`spam`>,1
+spam,subset_rows.spam,0,0,0,class<`spam`>,1
+spam,subset_rows.spam,1,0,0,double,1
+spam,subset_rows.spam,1,0,1,integer[],1
+spam,subset_rows.spam,2,0,0,...,1
+spam,subset_rows.spam,3,0,0,logical,1
+spam,subset.spam,-1,0,0,class<`spam`>,1
+spam,subset.spam,0,0,0,class<`spam`>,1
+spam,subset.spam,1,0,0,double[],1
+spam,subset.spam,2,0,0,double[],1
+spam,subset.spam,3,0,0,...,1
+spam,subset.spam,4,0,0,logical,1
+spam,summary,-1,0,0,class<`summary.spam.chol.NgPeyton`>,1
+spam,summary,0,0,0,class<`spam.chol.NgPeyton`>,1
+spam,summary,1,0,0,...,1
+spam,summary,-1,1,0,class<`summary.spam`>,1
+spam,summary,0,1,0,class<`spam`>,1
+spam,summary,1,1,0,...,1
+spam,t,-1,0,0,class<`spam`>,1
+spam,t,0,0,0,class<`spam`>,1
+spam,tail,-1,0,0,class<`matrix`>,1
+spam,tail,0,0,0,class<`spam`>,1
+spam,tail,1,0,0,...,1
+spam,toeplitz.spam,-1,0,0,class<`spam`>,1
+spam,toeplitz.spam,0,0,0,double[],1
+spam,toeplitz.spam,1,0,0,double[],1
+spam,toeplitz.spam,1,0,1,null,1
+spam,toeplitz.spam,2,0,0,double,1
+spam,triplet,-1,0,0,list<double[]>,1
+spam,triplet,-1,0,1,list<class<`matrix`> | double[]>,1
+spam,triplet,0,0,0,class<`spam`>,1
+spam,triplet,1,0,0,logical,1
+spam,t.spam,-1,0,0,class<`spam`>,1
+spam,t.spam,0,0,0,class<`spam`>,1
+spam,update.spam.chol.NgPeyton,-1,0,0,class<`spam.chol.NgPeyton`>,1
+spam,update.spam.chol.NgPeyton,-1,0,1,null,1
+spam,update.spam.chol.NgPeyton,0,0,0,class<`spam.chol.NgPeyton`>,1
+spam,update.spam.chol.NgPeyton,1,0,0,class<`spam`>,1
+spam,update.spam.chol.NgPeyton,2,0,0,...,1
+spam,upper.tri,-1,0,0,class<`spam`>,1
+spam,upper.tri,0,0,0,class<`spam`>,1
+spam,upper.tri,1,0,0,logical,1
+spam,validate_spam,-1,0,0,logical,1
+spam,validate_spam,0,0,0,class<`spam`>,1
+splitstackshape,charMat,-1,0,0,class<`matrix`>,1
+splitstackshape,charMat,0,0,0,list<character[]>,1
+splitstackshape,charMat,1,0,0,double,1
+splitstackshape,charMat,1,0,1,null,1
+splitstackshape,charMat,2,0,0,character,1
+splitstackshape,concat.split,-1,0,0,class<`data.frame`>,1
+splitstackshape,concat.split,-1,0,1,"class<`data.frame`, `data.table`>",1
+splitstackshape,concat.split,0,0,0,class<`data.frame`>,1
+splitstackshape,concat.split,1,0,0,double,1
+splitstackshape,concat.split,1,0,1,character,1
+splitstackshape,concat.split,2,0,0,character,1
+splitstackshape,concat.split,3,0,0,character,1
+splitstackshape,concat.split,4,0,0,character,1
+splitstackshape,concat.split,4,0,1,null,1
+splitstackshape,concat.split,5,0,0,character,1
+splitstackshape,concat.split,5,0,1,null,1
+splitstackshape,concat.split,6,0,0,logical,1
+splitstackshape,concat.split,7,0,0,logical,1
+splitstackshape,concat.split,8,0,0,null,1
+splitstackshape,concat.split,8,0,1,double,1
+splitstackshape,concat.split,9,0,0,...,1
+splitstackshape,concat.split.expanded,-1,0,0,class<`data.frame`>,1
+splitstackshape,concat.split.expanded,0,0,0,class<`data.frame`>,1
+splitstackshape,concat.split.expanded,1,0,0,character,1
+splitstackshape,concat.split.expanded,1,0,1,double,1
+splitstackshape,concat.split.expanded,2,0,0,character,1
+splitstackshape,concat.split.expanded,3,0,0,null,1
+splitstackshape,concat.split.expanded,3,0,1,character,1
+splitstackshape,concat.split.expanded,4,0,0,character,1
+splitstackshape,concat.split.expanded,5,0,0,logical,1
+splitstackshape,concat.split.expanded,6,0,0,logical,1
+splitstackshape,concat.split.expanded,7,0,0,null,1
+splitstackshape,concat.split.expanded,7,0,1,double,1
+splitstackshape,concat.split.list,-1,0,0,class<`data.frame`>,1
+splitstackshape,concat.split.list,0,0,0,class<`data.frame`>,1
+splitstackshape,concat.split.list,1,0,0,character,1
+splitstackshape,concat.split.list,1,0,1,double,1
+splitstackshape,concat.split.list,2,0,0,character,1
+splitstackshape,concat.split.list,3,0,0,logical,1
+splitstackshape,concat.split.list,4,0,0,logical,1
+splitstackshape,cSplit,-1,0,0,"class<`data.frame`, `data.table`>",1
+splitstackshape,cSplit,0,0,0,class<`data.frame`>,1
+splitstackshape,cSplit,1,0,0,character[],1
+splitstackshape,cSplit,1,0,1,double,1
+splitstackshape,cSplit,2,0,0,character[],1
+splitstackshape,cSplit,3,0,0,character,1
+splitstackshape,cSplit,4,0,0,logical,1
+splitstackshape,cSplit,5,0,0,logical,1
+splitstackshape,cSplit,6,0,0,logical,1
+splitstackshape,cSplit,7,0,0,null,1
+splitstackshape,cSplit,8,0,0,logical,1
+splitstackshape,cSplit_e,-1,0,0,class<`data.frame`>,1
+splitstackshape,cSplit_e,0,0,0,class<`data.frame`>,1
+splitstackshape,cSplit_e,1,0,0,character,1
+splitstackshape,cSplit_e,1,0,1,double,1
+splitstackshape,cSplit_e,2,0,0,character,1
+splitstackshape,cSplit_e,3,0,0,null,1
+splitstackshape,cSplit_e,3,0,1,character,1
+splitstackshape,cSplit_e,4,0,0,character,1
+splitstackshape,cSplit_e,5,0,0,logical,1
+splitstackshape,cSplit_e,6,0,0,logical,1
+splitstackshape,cSplit_e,7,0,0,null,1
+splitstackshape,cSplit_e,7,0,1,double,1
+splitstackshape,cSplit_l,-1,0,0,class<`data.frame`>,1
+splitstackshape,cSplit_l,0,0,0,class<`data.frame`>,1
+splitstackshape,cSplit_l,1,0,0,character,1
+splitstackshape,cSplit_l,1,0,1,double,1
+splitstackshape,cSplit_l,2,0,0,character,1
+splitstackshape,cSplit_l,3,0,0,logical,1
+splitstackshape,cSplit_l,4,0,0,logical,1
+splitstackshape,expandRows,-1,0,0,class<`data.frame`>,1
+splitstackshape,expandRows,-1,0,1,"class<`data.frame`, `data.table`>",1
+splitstackshape,expandRows,0,0,0,class<`data.frame`>,1
+splitstackshape,expandRows,0,0,1,"class<`data.frame`, `data.table`>",1
+splitstackshape,expandRows,1,0,0,character,1
+splitstackshape,expandRows,1,0,1,double[],1
+splitstackshape,expandRows,2,0,0,logical,1
+splitstackshape,expandRows,3,0,0,logical,1
+splitstackshape,getanID,-1,0,0,"class<`data.frame`, `data.table`>",1
+splitstackshape,getanID,0,0,0,class<`data.frame`>,1
+splitstackshape,getanID,1,0,0,character[],1
+splitstackshape,getanID,1,0,1,integer[],1
+splitstackshape,listCol_l,-1,0,0,"class<`data.frame`, `data.table`>",1
+splitstackshape,listCol_l,0,0,0,class<`data.frame`>,1
+splitstackshape,listCol_l,1,0,0,character,1
+splitstackshape,listCol_l,2,0,0,logical,1
+splitstackshape,listCol_w,-1,0,0,"class<`data.frame`, `data.table`>",1
+splitstackshape,listCol_w,0,0,0,class<`data.frame`>,1
+splitstackshape,listCol_w,1,0,0,character,1
+splitstackshape,listCol_w,2,0,0,logical,1
+splitstackshape,listCol_w,3,0,0,null,1
+splitstackshape,merged.stack,-1,0,0,"class<`data.frame`, `data.table`>",1
+splitstackshape,merged.stack,0,0,0,class<`data.frame`>,1
+splitstackshape,merged.stack,1,0,0,null,1
+splitstackshape,merged.stack,2,0,0,character[],1
+splitstackshape,merged.stack,3,0,0,character,1
+splitstackshape,merged.stack,4,0,0,logical,1
+splitstackshape,merged.stack,5,0,0,...,1
+splitstackshape,Names,-1,0,0,character[],1
+splitstackshape,Names,0,0,0,class<`data.frame`>,1
+splitstackshape,Names,0,0,1,"class<`data.frame`, `data.table`>",1
+splitstackshape,Names,1,0,0,character[],1
+splitstackshape,Names,1,0,1,integer[],1
+splitstackshape,Names,1,0,2,double,1
+splitstackshape,numMat,-1,0,0,class<`matrix`>,1
+splitstackshape,numMat,0,0,0,list<character[]>,1
+splitstackshape,numMat,1,0,0,null,1
+splitstackshape,numMat,1,0,1,double,1
+splitstackshape,numMat,2,0,0,character,1
+splitstackshape,othernames,-1,0,0,character[],1
+splitstackshape,othernames,0,0,0,class<`data.frame`>,1
+splitstackshape,othernames,1,0,0,character[],1
+splitstackshape,.pad,-1,0,0,character[],1
+splitstackshape,.pad,0,0,0,integer[],1
+splitstackshape,Reshape,-1,0,0,"class<`data.frame`, `data.table`>",1
+splitstackshape,Reshape,0,0,0,class<`data.frame`>,1
+splitstackshape,Reshape,1,0,0,character[],1
+splitstackshape,Reshape,2,0,0,character[],1
+splitstackshape,Reshape,3,0,0,character,1
+splitstackshape,Reshape,4,0,0,any,1
+splitstackshape,Reshape,5,0,0,...,1
+splitstackshape,s_frac,-1,0,0,"class<`data.frame`, `data.table`>",1
+splitstackshape,s_frac,0,0,0,"class<`data.frame`, `data.table`>",1
+splitstackshape,s_frac,1,0,0,character[],1
+splitstackshape,s_frac,2,0,0,double,1
+splitstackshape,s_n,-1,0,0,"class<`data.frame`, `data.table`>",1
+splitstackshape,s_n,0,0,0,"class<`data.frame`, `data.table`>",1
+splitstackshape,s_n,1,0,0,character[],1
+splitstackshape,s_n,2,0,0,double[],1
+splitstackshape,Stacked,-1,0,0,"list<class<`data.frame`, `data.table`>>",1
+splitstackshape,Stacked,0,0,0,class<`data.frame`>,1
+splitstackshape,Stacked,1,0,0,character[],1
+splitstackshape,Stacked,1,0,1,null,1
+splitstackshape,Stacked,2,0,0,character[],1
+splitstackshape,Stacked,3,0,0,character,1
+splitstackshape,Stacked,4,0,0,logical,1
+splitstackshape,Stacked,5,0,0,logical,1
+splitstackshape,Stacked,6,0,0,logical,1
+splitstackshape,Stacked,7,0,0,...,1
+splitstackshape,stratified,-1,0,0,"class<`data.frame`, `data.table`>",1
+splitstackshape,stratified,0,0,0,class<`data.frame`>,1
+splitstackshape,stratified,1,0,0,character[],1
+splitstackshape,stratified,1,0,1,double,1
+splitstackshape,stratified,2,0,0,double[],1
+splitstackshape,stratified,3,0,0,null,1
+splitstackshape,stratified,3,0,1,list<character[]>,1
+splitstackshape,stratified,4,0,0,logical,1
+splitstackshape,stratified,5,0,0,logical,1
+splitstackshape,stratified,6,0,0,logical,1
+splitstackshape,stratified,7,0,0,...,1
+splitstackshape,strat_sub,-1,0,0,"class<`data.frame`, `data.table`>",1
+splitstackshape,strat_sub,0,0,0,"class<`data.frame`, `data.table`>",1
+splitstackshape,strat_sub,1,0,0,list<character[]>,1
+splitstackshape,.stripWhite,-1,0,0,^character[],1
+splitstackshape,.stripWhite,0,0,0,^character[],1
+splitstackshape,.stripWhite,0,0,1,class<`factor`>,1
+splitstackshape,.stripWhite,1,0,0,character,1
+ssanv,find.calibrated.beta,-1,0,0,double,1
+ssanv,find.calibrated.beta,0,0,0,double,1
+ssanv,find.calibrated.beta,1,0,0,double,1
+ssanv,find.calibrated.beta,2,0,0,any,1
+ssanv,ss.fromdata.neff,-1,0,0,class<`power.htest`>,1
+ssanv,ss.fromdata.neff,0,0,0,double,1
+ssanv,ss.fromdata.neff,1,0,0,double,1
+ssanv,ss.fromdata.neff,2,0,0,double,1
+ssanv,ss.fromdata.neff,3,0,0,double,1
+ssanv,ss.fromdata.neff,4,0,0,double,1
+ssanv,ss.fromdata.neff,5,0,0,double,1
+ssanv,ss.fromdata.neff,6,0,0,double,1
+ssanv,ss.fromdata.neff,7,0,0,null,1
+ssanv,ss.fromdata.neff,8,0,0,character[],1
+ssanv,ss.fromdata.neff,9,0,0,double,1
+ssanv,ss.fromdata.neff,10,0,0,double,1
+ssanv,ss.fromdata.neff,11,0,0,double,1
+ssanv,ss.fromdata.nvar,-1,0,0,class<`power.htest`>,1
+ssanv,ss.fromdata.nvar,0,0,0,double,1
+ssanv,ss.fromdata.nvar,1,0,0,double,1
+ssanv,ss.fromdata.nvar,2,0,0,null,1
+ssanv,ss.fromdata.nvar,3,0,0,double,1
+ssanv,ss.fromdata.nvar,4,0,0,double,1
+ssanv,ss.fromdata.nvar,5,0,0,double,1
+ssanv,ss.fromdata.nvar,6,0,0,double,1
+ssanv,ss.fromdata.nvar,7,0,0,double,1
+ssanv,ss.fromdata.nvar,8,0,0,double,1
+ssanv,ss.fromdata.nvar,9,0,0,character[],1
+ssanv,ss.fromdata.pois,-1,0,0,class<`power.htest`>,1
+ssanv,ss.fromdata.pois,0,0,0,double,1
+ssanv,ss.fromdata.pois,1,0,0,double,1
+ssanv,ss.fromdata.pois,2,0,0,double,1
+ssanv,ss.fromdata.pois,3,0,0,double,1
+ssanv,ss.fromdata.pois,4,0,0,double,1
+ssanv,ss.fromdata.pois,5,0,0,double,1
+ssanv,ss.fromdata.pois,6,0,0,double,1
+ssanv,ss.fromdata.pois,7,0,0,null,1
+ssanv,ss.fromdata.pois,8,0,0,character[],1
+ssanv,ss.fromdata.pois,9,0,0,double,1
+ssanv,ss.fromdata.pois,10,0,0,double,1
+ssanv,ss.nonadh,-1,0,0,class<`power.htest`>,1
+ssanv,ss.nonadh,0,0,0,double,1
+ssanv,ss.nonadh,0,0,1,null,1
+ssanv,ss.nonadh,1,0,0,double,1
+ssanv,ss.nonadh,1,0,1,null,1
+ssanv,ss.nonadh,2,0,0,null,1
+ssanv,ss.nonadh,2,0,1,double,1
+ssanv,ss.nonadh,3,0,0,double,1
+ssanv,ss.nonadh,4,0,0,double,1
+ssanv,ss.nonadh,5,0,0,double,1
+ssanv,ss.nonadh,6,0,0,double,1
+ssanv,ss.nonadh,7,0,0,double,1
+ssanv,ss.nonadh,8,0,0,double,1
+ssanv,ss.nonadh,9,0,0,double,1
+ssanv,ss.nonadh,10,0,0,double,1
+ssanv,ss.nonadh,11,0,0,character[],1
+ssanv,ss.nonadh,12,0,0,character,1
+ssanv,ss.nonadh,12,0,1,null,1
+ssanv,ss.nonadh,13,0,0,any,1
+ssanv,uniroot.integer,-1,0,0,list<double>,1
+ssanv,uniroot.integer,0,0,0,class<`function`>,1
+ssanv,uniroot.integer,1,0,0,double[],1
+ssanv,uniroot.integer,2,0,0,double,1
+ssanv,uniroot.integer,3,0,0,double,1
+ssanv,uniroot.integer,4,0,0,double,1
+ssanv,uniroot.integer,5,0,0,logical,1
+ssanv,uniroot.integer,6,0,0,logical,1
+ssanv,uniroot.integer,7,0,0,logical,1
+ssanv,uniroot.integer,8,0,0,double,1
+ssanv,uniroot.integer,9,0,0,...,1
+stabledist,cospi2,-1,0,0,double[],1
+stabledist,cospi2,0,0,0,double[],1
+stabledist,C.stable.tail,-1,0,0,double,1
+stabledist,C.stable.tail,0,0,0,double,1
+stabledist,C.stable.tail,1,0,0,logical,1
+stabledist,dPareto,-1,0,0,double[],1
+stabledist,dPareto,0,0,0,double[],1
+stabledist,dPareto,1,0,0,double,1
+stabledist,dPareto,2,0,0,double,1
+stabledist,dPareto,3,0,0,logical,1
+stabledist,dstable,-1,0,0,double[],1
+stabledist,dstable,0,0,0,double[],1
+stabledist,dstable,1,0,0,double,1
+stabledist,dstable,2,0,0,double,1
+stabledist,dstable,3,0,0,double,1
+stabledist,dstable,4,0,0,double,1
+stabledist,dstable,5,0,0,double,1
+stabledist,dstable,6,0,0,logical,1
+stabledist,dstable,7,0,0,double,1
+stabledist,dstable,8,0,0,null,1
+stabledist,dstable,9,0,0,double,1
+stabledist,.e.minus,-1,0,0,double,1
+stabledist,.e.minus,0,0,0,double,1
+stabledist,.e.minus,1,0,0,double,1
+stabledist,.e.plus,-1,0,0,double,1
+stabledist,.e.plus,0,0,0,double,1
+stabledist,.e.plus,1,0,0,double,1
+stabledist,.FCT1,-1,0,0,double,1
+stabledist,.FCT1,0,0,0,double,1
+stabledist,.FCT1,1,0,0,any,1
+stabledist,.FCT1,2,0,0,any,1
+stabledist,.FCT1,3,0,0,any,1
+stabledist,.FCT1,4,0,0,logical,1
+stabledist,.FCT1,5,0,0,any,1
+stabledist,.FCT1,6,0,0,any,1
+stabledist,.FCT1,7,0,0,any,1
+stabledist,.FCT1,8,0,0,any,1
+stabledist,.fct2,-1,0,0,double,1
+stabledist,.fct2,0,0,0,double,1
+stabledist,.fct2,1,0,0,double,1
+stabledist,.fct2,2,0,0,logical,1
+stabledist,.fct2,3,0,0,double,1
+stabledist,.fct2,4,0,0,double,1
+stabledist,.fct2,5,0,0,logical,1
+stabledist,.FCT2,-1,0,0,double,1
+stabledist,.FCT2,0,0,0,double,1
+stabledist,.FCT2,1,0,0,double,1
+stabledist,.FCT2,2,0,0,any,1
+stabledist,.FCT2,3,0,0,any,1
+stabledist,.FCT2,4,0,0,logical,1
+stabledist,.FCT2,5,0,0,any,1
+stabledist,.integrate2,-1,0,0,double,1
+stabledist,.integrate2,0,0,0,class<`function`>,1
+stabledist,.integrate2,1,0,0,double,1
+stabledist,.integrate2,2,0,0,double,1
+stabledist,.integrate2,3,0,0,...,1
+stabledist,.integrate2,4,0,0,double,1
+stabledist,.integrate2,5,0,0,double,1
+stabledist,.integrate2,6,0,0,double,1
+stabledist,.integrate2,7,0,0,logical,1
+stabledist,.om,-1,0,0,double,1
+stabledist,.om,0,0,0,any,1
+stabledist,.om,1,0,0,double,1
+stabledist,pi2..,-1,0,0,double,1
+stabledist,pi2..,0,0,0,double,1
+stabledist,pPareto,-1,0,0,double[],1
+stabledist,pPareto,0,0,0,double[],1
+stabledist,pPareto,1,0,0,double,1
+stabledist,pPareto,2,0,0,double,1
+stabledist,pPareto,3,0,0,logical,1
+stabledist,pPareto,4,0,0,logical,1
+stabledist,pstable,-1,0,0,double[],1
+stabledist,pstable,0,0,0,double[],1
+stabledist,pstable,1,0,0,double,1
+stabledist,pstable,2,0,0,double,1
+stabledist,pstable,3,0,0,double,1
+stabledist,pstable,4,0,0,double,1
+stabledist,pstable,5,0,0,double,1
+stabledist,pstable,6,0,0,logical,1
+stabledist,pstable,7,0,0,logical,1
+stabledist,pstable,8,0,0,logical,1
+stabledist,pstable,9,0,0,double,1
+stabledist,pstable,10,0,0,double,1
+stabledist,qstable,-1,0,0,double[],1
+stabledist,qstable,0,0,0,double[],1
+stabledist,qstable,1,0,0,double,1
+stabledist,qstable,2,0,0,double,1
+stabledist,qstable,3,0,0,double,1
+stabledist,qstable,4,0,0,double,1
+stabledist,qstable,5,0,0,double,1
+stabledist,qstable,6,0,0,logical,1
+stabledist,qstable,7,0,0,logical,1
+stabledist,qstable,8,0,0,double,1
+stabledist,qstable,9,0,0,double,1
+stabledist,qstable,10,0,0,double,1
+stabledist,qstable,11,0,0,double,1
+stabledist,qstable,12,0,0,double,1
+stabledist,R.D.Cval,-1,0,0,double,1
+stabledist,R.D.Cval,0,0,0,double,1
+stabledist,R.D.Cval,1,0,0,logical,1
+stabledist,R.D.Lval,-1,0,0,double,1
+stabledist,R.D.Lval,0,0,0,double,1
+stabledist,R.D.Lval,1,0,0,logical,1
+stabledist,R.DT.CIv,-1,0,0,double,1
+stabledist,R.DT.CIv,0,0,0,double,1
+stabledist,R.DT.CIv,1,0,0,logical,1
+stabledist,R.DT.CIv,2,0,0,logical,1
+stabledist,R.DT.qIv,-1,0,0,double,1
+stabledist,R.DT.qIv,0,0,0,double,1
+stabledist,R.DT.qIv,1,0,0,logical,1
+stabledist,R.DT.qIv,2,0,0,logical,1
+stabledist,rstable,-1,0,0,double[],1
+stabledist,rstable,0,0,0,double,1
+stabledist,rstable,1,0,0,double,1
+stabledist,rstable,2,0,0,double,1
+stabledist,rstable,3,0,0,double,1
+stabledist,rstable,4,0,0,double,1
+stabledist,rstable,5,0,0,double,1
+stabledist,stableMode,-1,0,0,double,1
+stabledist,stableMode,0,0,0,double,1
+stabledist,stableMode,1,0,0,double,1
+stabledist,stableMode,2,0,0,double,1
+stabledist,stableMode,3,0,0,any,1
+stabledist,tanpi2,-1,0,0,double[],1
+stabledist,tanpi2,0,0,0,double[],1
+stabledist,.unirootNA,-1,0,0,double,1
+stabledist,.unirootNA,-1,0,1,null,1
+stabledist,.unirootNA,0,0,0,class<`function`>,1
+stabledist,.unirootNA,1,0,0,double[],1
+stabledist,.unirootNA,2,0,0,...,1
+stabledist,.unirootNA,3,0,0,double,1
+stabledist,.unirootNA,4,0,0,double,1
+stabledist,.unirootNA,5,0,0,double,1
+stabledist,.unirootNA,6,0,0,double,1
+stabledist,.unirootNA,7,0,0,any,1
+stabledist,.unirootNA,8,0,0,logical,1
+stabledist,.unirootNA,9,0,0,any,1
+stabledist,.unirootNA,10,0,0,any,1
+stabledist,.unirootNA,11,0,0,any,1
+stabledist,x.exp.m.x,-1,0,0,double[],1
+stabledist,x.exp.m.x,0,0,0,double[],1
+startupmsg,buildStartupMessage,-1,0,0,null,1
+startupmsg,buildStartupMessage,0,0,0,...,1
+startupmsg,buildStartupMessage,1,0,0,character,1
+startupmsg,buildStartupMessage,2,0,0,character,1
+startupmsg,buildStartupMessage,2,0,1,null,1
+startupmsg,buildStartupMessage,3,0,0,null,1
+startupmsg,buildStartupMessage,4,0,0,logical,1
+startupmsg,buildStartupMessage,5,0,0,null,1
+startupmsg,buildStartupMessage,5,0,1,character[],1
+startupmsg,buildStartupMessage,6,0,0,null,1
+startupmsg,buildStartupMessage,7,0,0,any,1
+startupmsg,infoShow,-1,0,0,null,1
+startupmsg,infoShow,0,0,0,character,1
+startupmsg,infoShow,1,0,0,character,1
+startupmsg,infoShow,2,0,0,any,1
+startupmsg,mystartupMessage,-1,0,0,null,1
+startupmsg,mystartupMessage,0,0,0,...,1
+startupmsg,mystartupMessage,1,0,0,null,1
+startupmsg,mystartupMessage,2,0,0,character,1
+startupmsg,mystartupMessage,3,0,0,character,1
+startupmsg,mystartupMessage,4,0,0,any,1
+startupmsg,mystartupMessage,5,0,0,logical,1
+startupmsg,NEWS,-1,0,0,null,1
+startupmsg,NEWS,0,0,0,character,1
+startupmsg,NEWS,1,0,0,null,1
+startupmsg,onlytypeStartupMessages,-1,0,0,null,1
+startupmsg,onlytypeStartupMessages,0,0,0,null,1
+startupmsg,onlytypeStartupMessages,1,0,0,character[],1
+startupmsg,pointertoNEWS,-1,0,0,character,1
+startupmsg,pointertoNEWS,-1,0,1,null,1
+startupmsg,pointertoNEWS,0,0,0,character,1
+startupmsg,pointertoNEWS,1,0,0,any,1
+startupmsg,readURLInformation,-1,0,0,null,1
+startupmsg,readURLInformation,0,0,0,character,1
+startupmsg,readURLInformation,1,0,0,character,1
+startupmsg,readURLInformation,1,0,1,null,1
+startupmsg,readVersionInformation,-1,0,0,list<character>,1
+startupmsg,readVersionInformation,0,0,0,character,1
+startupmsg,readVersionInformation,1,0,0,character,1
+startupmsg,readVersionInformation,1,0,1,null,1
+startupmsg,startupEndline,-1,0,0,logical,1
+startupmsg,startupEndline,0,0,0,"class<`StartupMessage`, `condition`, `message`, `packageStartupMessage`, `simpleMessage`>",1
+startupmsg,startupMessage,-1,0,0,null,1
+startupmsg,startupMessage,0,0,0,...,1
+startupmsg,startupMessage,1,0,0,null,1
+startupmsg,startupMessage,2,0,0,character,1
+startupmsg,startupMessage,3,0,0,character,1
+startupmsg,startupMessage,4,0,0,logical,1
+startupmsg,StartupMessage,-1,0,0,"class<`StartupMessage`, `condition`, `message`, `packageStartupMessage`, `simpleMessage`>",1
+startupmsg,StartupMessage,0,0,0,character,1
+startupmsg,StartupMessage,1,0,0,class<`call`>,1
+startupmsg,StartupMessage,2,0,0,character,1
+startupmsg,StartupMessage,3,0,0,character,1
+startupmsg,StartupMessage,4,0,0,logical,1
+startupmsg,startupPackage,-1,0,0,character,1
+startupmsg,startupPackage,0,0,0,"class<`StartupMessage`, `condition`, `message`, `packageStartupMessage`, `simpleMessage`>",1
+startupmsg,startupType,-1,0,0,character,1
+startupmsg,startupType,0,0,0,"class<`StartupMessage`, `condition`, `message`, `packageStartupMessage`, `simpleMessage`>",1
+startupmsg,suppressStartupMessages,-1,0,0,null,1
+startupmsg,suppressStartupMessages,0,0,0,null,1
+statmod,canonic.digamma,-1,0,0,double[],1
+statmod,canonic.digamma,0,0,0,double[],1
+statmod,compareGrowthCurves,-1,0,0,class<`data.frame`>,1
+statmod,compareGrowthCurves,0,0,0,class<`factor`>,1
+statmod,compareGrowthCurves,1,0,0,class<`matrix`>,1
+statmod,compareGrowthCurves,2,0,0,null,1
+statmod,compareGrowthCurves,3,0,0,double,1
+statmod,compareGrowthCurves,4,0,0,class<`function`>,1
+statmod,compareGrowthCurves,5,0,0,null,1
+statmod,compareGrowthCurves,6,0,0,logical,1
+statmod,compareGrowthCurves,7,0,0,character,1
+statmod,compareTwoGrowthCurves,-1,0,0,list<double>,1
+statmod,compareTwoGrowthCurves,0,0,0,character[],1
+statmod,compareTwoGrowthCurves,1,0,0,class<`matrix`>,1
+statmod,compareTwoGrowthCurves,2,0,0,double,1
+statmod,compareTwoGrowthCurves,3,0,0,class<`function`>,1
+statmod,cumulant.digamma,-1,0,0,double[],1
+statmod,cumulant.digamma,0,0,0,double[],1
+statmod,d2cumulant.digamma,-1,0,0,double[],1
+statmod,d2cumulant.digamma,0,0,0,double[],1
+statmod,Digamma,-1,0,0,list<character | class<`function`> | expression>,1
+statmod,Digamma,0,0,0,character,1
+statmod,.dinvgauss,-1,0,0,double[],1
+statmod,.dinvgauss,0,0,0,double[],1
+statmod,.dinvgauss,1,0,0,null,1
+statmod,.dinvgauss,2,0,0,double[],1
+statmod,.dinvgauss,3,0,0,logical,1
+statmod,elda,-1,0,0,class<`limdil`>,1
+statmod,elda,0,0,0,double[],1
+statmod,elda,1,0,0,double[],1
+statmod,elda,2,0,0,double[],1
+statmod,elda,3,0,0,double[],1
+statmod,elda,4,0,0,logical,1
+statmod,elda,5,0,0,double,1
+statmod,elda,6,0,0,logical,1
+statmod,eldaOneGroup,-1,0,0,list<double[]>,1
+statmod,eldaOneGroup,0,0,0,double[],1
+statmod,eldaOneGroup,1,0,0,double[],1
+statmod,eldaOneGroup,2,0,0,double[],1
+statmod,eldaOneGroup,3,0,0,logical,1
+statmod,eldaOneGroup,4,0,0,double,1
+statmod,eldaOneGroup,5,0,0,double,1
+statmod,eldaOneGroup,6,0,0,double,1
+statmod,eldaOneGroup,7,0,0,logical,1
+statmod,fitNBP,-1,0,0,list<class<`matrix`> | double>,1
+statmod,fitNBP,0,0,0,class<`matrix`>,1
+statmod,fitNBP,1,0,0,double[],1
+statmod,fitNBP,2,0,0,double[],1
+statmod,fitNBP,3,0,0,double,1
+statmod,fitNBP,4,0,0,double,1
+statmod,fitNBP,5,0,0,logical,1
+statmod,forward,-1,0,0,double[],1
+statmod,forward,0,0,0,double[],1
+statmod,forward,1,0,0,class<`matrix`>,1
+statmod,forward,2,0,0,null,1
+statmod,forward,3,0,0,logical,1
+statmod,forward,4,0,0,integer,1
+statmod,gauss.quad,-1,0,0,list<double[]>,1
+statmod,gauss.quad,0,0,0,double,1
+statmod,gauss.quad,1,0,0,character,1
+statmod,gauss.quad,2,0,0,double,1
+statmod,gauss.quad,3,0,0,double,1
+statmod,gauss.quad.prob,-1,0,0,list<double[]>,1
+statmod,gauss.quad.prob,0,0,0,double,1
+statmod,gauss.quad.prob,1,0,0,character,1
+statmod,gauss.quad.prob,2,0,0,double,1
+statmod,gauss.quad.prob,3,0,0,double,1
+statmod,gauss.quad.prob,4,0,0,double,1
+statmod,gauss.quad.prob,5,0,0,double,1
+statmod,gauss.quad.prob,6,0,0,double,1
+statmod,gauss.quad.prob,7,0,0,double,1
+statmod,glmgam.fit,-1,0,0,list<double[]>,1
+statmod,glmgam.fit,0,0,0,class<`matrix`>,1
+statmod,glmgam.fit,0,0,1,double[],1
+statmod,glmgam.fit,1,0,0,double[],1
+statmod,glmgam.fit,1,0,1,class<`matrix`>,1
+statmod,glmgam.fit,2,0,0,null,1
+statmod,glmgam.fit,2,0,1,double[],1
+statmod,glmgam.fit,3,0,0,double,1
+statmod,glmgam.fit,4,0,0,double,1
+statmod,glmgam.fit,5,0,0,logical,1
+statmod,glmnb.fit,-1,0,0,list<double[] | character>,1
+statmod,glmnb.fit,0,0,0,class<`matrix`>,1
+statmod,glmnb.fit,1,0,0,double[],1
+statmod,glmnb.fit,2,0,0,double[],1
+statmod,glmnb.fit,3,0,0,null,1
+statmod,glmnb.fit,4,0,0,double[],1
+statmod,glmnb.fit,5,0,0,null,1
+statmod,glmnb.fit,6,0,0,character,1
+statmod,glmnb.fit,7,0,0,double,1
+statmod,glmnb.fit,8,0,0,double,1
+statmod,glmnb.fit,9,0,0,logical,1
+statmod,glm.scoretest,-1,0,0,double,1
+statmod,glm.scoretest,0,0,0,"class<`glm`, `lm`>",1
+statmod,glm.scoretest,1,0,0,double[],1
+statmod,glm.scoretest,2,0,0,null,1
+statmod,hommel.test,-1,0,0,logical[],1
+statmod,hommel.test,0,0,0,double[],1
+statmod,hommel.test,1,0,0,double,1
+statmod,logmdigamma,-1,0,0,double,1
+statmod,logmdigamma,0,0,0,double,1
+statmod,matvec,-1,0,0,class<`matrix`>,1
+statmod,matvec,0,0,0,class<`matrix`>,1
+statmod,matvec,1,0,0,double[],1
+statmod,meanT,-1,0,0,double,1
+statmod,meanT,0,0,0,class<`matrix`>,1
+statmod,meanT,1,0,0,class<`matrix`>,1
+statmod,meanval.digamma,-1,0,0,double[],1
+statmod,meanval.digamma,0,0,0,double[],1
+statmod,mixedModel2,-1,0,0,list<double[]>,1
+statmod,mixedModel2,0,0,0,any,1
+statmod,mixedModel2,1,0,0,any,1
+statmod,mixedModel2,2,0,0,null,1
+statmod,mixedModel2,3,0,0,logical,1
+statmod,mixedModel2,4,0,0,any,1
+statmod,mixedModel2,5,0,0,null,1
+statmod,mixedModel2,6,0,0,null,1
+statmod,mixedModel2,7,0,0,double,1
+statmod,mixedModel2,8,0,0,double,1
+statmod,mixedModel2,9,0,0,logical,1
+statmod,mixedModel2Fit,-1,0,0,list<double[]>,1
+statmod,mixedModel2Fit,0,0,0,double[],1
+statmod,mixedModel2Fit,1,0,0,class<`matrix`>,1
+statmod,mixedModel2Fit,2,0,0,class<`matrix`>,1
+statmod,mixedModel2Fit,3,0,0,null,1
+statmod,mixedModel2Fit,4,0,0,logical,1
+statmod,mixedModel2Fit,5,0,0,double,1
+statmod,mixedModel2Fit,6,0,0,double,1
+statmod,mixedModel2Fit,7,0,0,logical,1
+statmod,mscale,-1,0,0,double,1
+statmod,mscale,0,0,0,double[],1
+statmod,mscale,1,0,0,logical,1
+statmod,permp,-1,0,0,double[],1
+statmod,permp,0,0,0,integer[],1
+statmod,permp,1,0,0,double,1
+statmod,permp,2,0,0,any,1
+statmod,permp,3,0,0,any,1
+statmod,permp,4,0,0,null,1
+statmod,permp,4,0,1,double,1
+statmod,permp,5,0,0,character,1
+statmod,permp,6,0,0,logical,1
+statmod,pinvgauss,-1,0,0,^double[],1
+statmod,pinvgauss,0,0,0,^double[],1
+statmod,pinvgauss,1,0,0,^double[],1
+statmod,pinvgauss,2,0,0,null,1
+statmod,pinvgauss,3,0,0,double,1
+statmod,pinvgauss,4,0,0,logical,1
+statmod,pinvgauss,5,0,0,logical,1
+statmod,.pinvgauss,-1,0,0,double[],1
+statmod,.pinvgauss,0,0,0,double[],1
+statmod,.pinvgauss,1,0,0,double[],1
+statmod,.pinvgauss,1,0,1,null,1
+statmod,.pinvgauss,2,0,0,double[],1
+statmod,.pinvgauss,3,0,0,logical,1
+statmod,.pinvgauss,4,0,0,logical,1
+statmod,plot.limdil,-1,0,0,list<double[] | class<`factor`>>,1
+statmod,plot.limdil,0,0,0,class<`limdil`>,1
+statmod,plot.limdil,1,0,0,null,1
+statmod,plot.limdil,2,0,0,double,1
+statmod,plot.limdil,3,0,0,double,1
+statmod,plot.limdil,4,0,0,character,1
+statmod,plot.limdil,5,0,0,...,1
+statmod,power.fisher.test,-1,0,0,double,1
+statmod,power.fisher.test,0,0,0,double,1
+statmod,power.fisher.test,1,0,0,double,1
+statmod,power.fisher.test,2,0,0,double,1
+statmod,power.fisher.test,3,0,0,double,1
+statmod,power.fisher.test,4,0,0,double,1
+statmod,power.fisher.test,5,0,0,double,1
+statmod,power.fisher.test,6,0,0,character,1
+statmod,.psi.hampel,-1,0,0,double[],1
+statmod,.psi.hampel,0,0,0,double[],1
+statmod,.psi.hampel,1,0,0,double,1
+statmod,.psi.hampel,2,0,0,double,1
+statmod,.psi.hampel,3,0,0,double,1
+statmod,qinvgauss,-1,0,0,^double[],1
+statmod,qinvgauss,0,0,0,double[],1
+statmod,qinvgauss,1,0,0,^double[],1
+statmod,qinvgauss,2,0,0,null,1
+statmod,qinvgauss,3,0,0,double,1
+statmod,qinvgauss,4,0,0,logical,1
+statmod,qinvgauss,5,0,0,logical,1
+statmod,qinvgauss,6,0,0,integer,1
+statmod,qinvgauss,7,0,0,double,1
+statmod,qinvgauss,8,0,0,logical,1
+statmod,qres.default,-1,0,0,double[],1
+statmod,qres.default,0,0,0,"class<`glm`, `lm`>",1
+statmod,qres.default,1,0,0,double,1
+statmod,qres.default,1,0,1,null,1
+statmod,qres.gamma,-1,0,0,double[],1
+statmod,qres.gamma,0,0,0,"class<`glm`, `lm`>",1
+statmod,qres.gamma,1,0,0,double,1
+statmod,qresiduals,-1,0,0,double[],1
+statmod,qresiduals,0,0,0,"class<`glm`, `lm`>",1
+statmod,qresiduals,0,0,1,"class<`glm`, `lm`, `negbin`>",1
+statmod,qresiduals,1,0,0,null,1
+statmod,qresiduals,1,0,1,double,1
+statmod,qres.nbinom,-1,0,0,double[],1
+statmod,qres.nbinom,0,0,0,"class<`glm`, `lm`>",1
+statmod,qres.nbinom,0,0,1,"class<`glm`, `lm`, `negbin`>",1
+statmod,qres.pois,-1,0,0,double[],1
+statmod,qres.pois,0,0,0,"class<`glm`, `lm`>",1
+statmod,remlscore,-1,0,0,list<double[] | class<`matrix`>>,1
+statmod,remlscore,0,0,0,double[],1
+statmod,remlscore,1,0,0,class<`matrix`>,1
+statmod,remlscore,2,0,0,class<`matrix`>,1
+statmod,remlscore,3,0,0,logical,1
+statmod,remlscore,4,0,0,double,1
+statmod,remlscore,5,0,0,double,1
+statmod,remlscoregamma,-1,0,0,list<double[] | class<`matrix`>>,1
+statmod,remlscoregamma,0,0,0,double[],1
+statmod,remlscoregamma,1,0,0,class<`matrix`>,1
+statmod,remlscoregamma,2,0,0,class<`matrix`>,1
+statmod,remlscoregamma,3,0,0,character,1
+statmod,remlscoregamma,4,0,0,character,1
+statmod,remlscoregamma,5,0,0,logical,1
+statmod,remlscoregamma,6,0,0,double,1
+statmod,remlscoregamma,7,0,0,double,1
+statmod,.rho.hampel,-1,0,0,double[],1
+statmod,.rho.hampel,0,0,0,double[],1
+statmod,.rho.hampel,1,0,0,double,1
+statmod,.rho.hampel,2,0,0,double,1
+statmod,.rho.hampel,3,0,0,double,1
+statmod,rinvgauss,-1,0,0,^double[],1
+statmod,rinvgauss,0,0,0,double,1
+statmod,rinvgauss,1,0,0,^double[],1
+statmod,rinvgauss,2,0,0,null,1
+statmod,rinvgauss,3,0,0,^double[],1
+statmod,sage.test,-1,0,0,double[],1
+statmod,sage.test,0,0,0,double[],1
+statmod,sage.test,1,0,0,double[],1
+statmod,sage.test,2,0,0,double,1
+statmod,sage.test,3,0,0,double,1
+statmod,tweedie,-1,0,0,class<`family`>,1
+statmod,tweedie,0,0,0,double,1
+statmod,tweedie,1,0,0,double,1
+statmod,unitdeviance.digamma,-1,0,0,double[],1
+statmod,unitdeviance.digamma,0,0,0,double[],1
+statmod,unitdeviance.digamma,1,0,0,double[],1
+statmod,vecmat,-1,0,0,class<`matrix`>,1
+statmod,vecmat,0,0,0,class<`matrix`>,1
+statmod,vecmat,0,0,1,double[],1
+statmod,vecmat,1,0,0,class<`matrix`>,1
+statnet.common,all_identical,-1,0,0,logical,1
+statnet.common,all_identical,0,0,0,integer[],1
+statnet.common,all_identical,0,0,1,list<character>,1
+statnet.common,all.rle,-1,0,0,logical,1
+statnet.common,all.rle,0,0,0,...,1
+statnet.common,all.rle,1,0,0,logical,1
+statnet.common,any.rle,-1,0,0,logical,1
+statnet.common,any.rle,0,0,0,...,1
+statnet.common,any.rle,1,0,0,logical,1
+statnet.common,append_rhs.formula,-1,0,0,class<`formula`>,1
+statnet.common,append_rhs.formula,0,0,0,class<`formula`>,1
+statnet.common,append_rhs.formula,1,0,0,class<`formula`>,1
+statnet.common,append_rhs.formula,1,0,1,list<class<`name`>>,1
+statnet.common,append_rhs.formula,2,0,0,logical,1
+statnet.common,as.linwmatrix,-1,0,0,"class<`linwmatrix`, `matrix`, `wmatrix`>",1
+statnet.common,as.linwmatrix,0,0,0,"class<`logwmatrix`, `matrix`, `wmatrix`>",1
+statnet.common,as.linwmatrix,0,0,1,class<`matrix`>,1
+statnet.common,as.linwmatrix,1,0,0,...,1
+statnet.common,as.linwmatrix.logwmatrix,-1,0,0,"class<`linwmatrix`, `matrix`, `wmatrix`>",1
+statnet.common,as.linwmatrix.logwmatrix,0,0,0,"class<`logwmatrix`, `matrix`, `wmatrix`>",1
+statnet.common,as.linwmatrix.logwmatrix,1,0,0,...,1
+statnet.common,as.linwmatrix.matrix,-1,0,0,"class<`linwmatrix`, `matrix`, `wmatrix`>",1
+statnet.common,as.linwmatrix.matrix,0,0,0,class<`matrix`>,1
+statnet.common,as.linwmatrix.matrix,1,0,0,null,1
+statnet.common,as.linwmatrix.matrix,2,0,0,...,1
+statnet.common,as.logwmatrix,-1,0,0,"class<`logwmatrix`, `matrix`, `wmatrix`>",1
+statnet.common,as.logwmatrix,0,0,0,"class<`linwmatrix`, `matrix`, `wmatrix`>",1
+statnet.common,as.logwmatrix,0,0,1,class<`matrix`>,1
+statnet.common,as.logwmatrix,1,0,0,...,1
+statnet.common,as.logwmatrix.linwmatrix,-1,0,0,"class<`logwmatrix`, `matrix`, `wmatrix`>",1
+statnet.common,as.logwmatrix.linwmatrix,0,0,0,"class<`linwmatrix`, `matrix`, `wmatrix`>",1
+statnet.common,as.logwmatrix.linwmatrix,1,0,0,...,1
+statnet.common,as.logwmatrix.matrix,-1,0,0,"class<`logwmatrix`, `matrix`, `wmatrix`>",1
+statnet.common,as.logwmatrix.matrix,0,0,0,class<`matrix`>,1
+statnet.common,as.logwmatrix.matrix,1,0,0,null,1
+statnet.common,as.logwmatrix.matrix,2,0,0,...,1
+statnet.common,as.rle,-1,0,0,class<`rle`>,1
+statnet.common,as.rle,0,0,0,class<`rle`>,1
+statnet.common,as.rle.rle,-1,0,0,class<`rle`>,1
+statnet.common,as.rle.rle,0,0,0,class<`rle`>,1
+statnet.common,binop.rle,-1,0,0,class<`rle`>,1
+statnet.common,binop.rle,0,0,0,class<`rle`>,1
+statnet.common,binop.rle,1,0,0,class<`rle`>,1
+statnet.common,binop.rle,2,0,0,class<`function`>,1
+statnet.common,.check_lengths,-1,0,0,null,1
+statnet.common,.check_lengths,0,0,0,class<`rle`>,1
+statnet.common,.check_lengths,1,0,0,class<`rle`>,1
+statnet.common,colMeans.mcmc.list,-1,0,0,double[],1
+statnet.common,colMeans.mcmc.list,0,0,0,class<`mcmc.list`>,1
+statnet.common,colMeans.mcmc.list,1,0,0,...,1
+statnet.common,compact.rle,-1,0,0,class<`rle`>,1
+statnet.common,compact.rle,0,0,0,class<`rle`>,1
+statnet.common,compress.data.frame,-1,0,0,list<class<`data.frame`> | double[] | character[]>,1
+statnet.common,compress.data.frame,0,0,0,class<`data.frame`>,1
+statnet.common,compress_rows,-1,0,0,"class<`linwmatrix`, `matrix`, `wmatrix`>",1
+statnet.common,compress_rows,-1,0,1,"class<`logwmatrix`, `matrix`, `wmatrix`>",1
+statnet.common,compress_rows,0,0,0,"class<`linwmatrix`, `matrix`, `wmatrix`>",1
+statnet.common,compress_rows,0,0,1,"class<`logwmatrix`, `matrix`, `wmatrix`>",1
+statnet.common,compress_rows,1,0,0,...,1
+statnet.common,compress_rows.linwmatrix,-1,0,0,"class<`linwmatrix`, `matrix`, `wmatrix`>",1
+statnet.common,compress_rows.linwmatrix,0,0,0,"class<`linwmatrix`, `matrix`, `wmatrix`>",1
+statnet.common,compress_rows.linwmatrix,1,0,0,...,1
+statnet.common,compress_rows.logwmatrix,-1,0,0,"class<`logwmatrix`, `matrix`, `wmatrix`>",1
+statnet.common,compress_rows.logwmatrix,0,0,0,"class<`logwmatrix`, `matrix`, `wmatrix`>",1
+statnet.common,compress_rows.logwmatrix,1,0,0,...,1
+statnet.common,control.remap,-1,0,0,"class<`control.list`, `list`, `test`>",1
+statnet.common,control.remap,0,0,0,"class<`control.list`, `list`, `test`>",1
+statnet.common,control.remap,1,0,0,character,1
+statnet.common,control.remap,2,0,0,character,1
+statnet.common,c.rle,-1,0,0,class<`rle`>,1
+statnet.common,c.rle,0,0,0,...,1
+statnet.common,decompress.data.frame,-1,0,0,class<`data.frame`>,1
+statnet.common,decompress.data.frame,0,0,0,list<class<`data.frame`> | double[] | character[]>,1
+statnet.common,.Deprecate_method,-1,0,0,character,1
+statnet.common,.Deprecate_method,-1,0,1,null,1
+statnet.common,.Deprecate_method,0,0,0,character,1
+statnet.common,.Deprecate_method,1,0,0,character,1
+statnet.common,.Deprecate_once,-1,0,0,character,1
+statnet.common,.Deprecate_once,-1,0,1,null,1
+statnet.common,.Deprecate_once,0,0,0,...,1
+statnet.common,despace,-1,0,0,character,1
+statnet.common,despace,0,0,0,character,1
+statnet.common,ERRVL,-1,0,0,double,1
+statnet.common,ERRVL,0,0,0,...,1
+statnet.common,eval_lhs.formula,-1,0,0,double,1
+statnet.common,eval_lhs.formula,0,0,0,class<`formula`>,1
+statnet.common,EVL,-1,0,0,double,1
+statnet.common,EVL,0,0,0,...,1
+statnet.common,filter_rhs.formula,-1,0,0,class<`formula`>,1
+statnet.common,filter_rhs.formula,0,0,0,class<`formula`>,1
+statnet.common,filter_rhs.formula,1,0,0,class<`function`>,1
+statnet.common,filter_rhs.formula,2,0,0,...,1
+statnet.common,forkTimeout,-1,0,0,logical,1
+statnet.common,forkTimeout,-1,0,1,null,1
+statnet.common,forkTimeout,0,0,0,any,1
+statnet.common,forkTimeout,1,0,0,double,1
+statnet.common,forkTimeout,2,0,0,any,1
+statnet.common,forkTimeout,3,0,0,null,1
+statnet.common,is.na.rle,-1,0,0,class<`rle`>,1
+statnet.common,is.na.rle,0,0,0,class<`rle`>,1
+statnet.common,lapply.mcmc.list,-1,0,0,class<`mcmc.list`>,1
+statnet.common,lapply.mcmc.list,0,0,0,class<`mcmc.list`>,1
+statnet.common,lapply.mcmc.list,1,0,0,class<`function`>,1
+statnet.common,lapply.mcmc.list,2,0,0,...,1
+statnet.common,length.rle,-1,0,0,double,1
+statnet.common,length.rle,0,0,0,class<`rle`>,1
+statnet.common,list_rhs.formula,-1,0,0,list<class<`name`>>,1
+statnet.common,list_rhs.formula,0,0,0,class<`formula`>,1
+statnet.common,log_mean_exp,-1,0,0,double,1
+statnet.common,log_mean_exp,0,0,0,double[],1
+statnet.common,log_mean_exp,1,0,0,logical,1
+statnet.common,log_sum_exp,-1,0,0,double,1
+statnet.common,log_sum_exp,0,0,0,double[],1
+statnet.common,log_sum_exp,1,0,0,logical,1
+statnet.common,lweighted.mean,-1,0,0,double[],1
+statnet.common,lweighted.mean,0,0,0,class<`matrix`>,1
+statnet.common,lweighted.mean,0,0,1,double[],1
+statnet.common,lweighted.mean,1,0,0,double[],1
+statnet.common,lweighted.var,-1,0,0,class<`matrix`>,1
+statnet.common,lweighted.var,-1,0,1,double,1
+statnet.common,lweighted.var,0,0,0,class<`matrix`>,1
+statnet.common,lweighted.var,0,0,1,double[],1
+statnet.common,lweighted.var,1,0,0,double[],1
+statnet.common,mean.rle,-1,0,0,double,1
+statnet.common,mean.rle,0,0,0,class<`rle`>,1
+statnet.common,mean.rle,1,0,0,logical,1
+statnet.common,mean.rle,2,0,0,...,1
+statnet.common,message_print,-1,0,0,null,1
+statnet.common,message_print,0,0,0,...,1
+statnet.common,message_print,1,0,0,null,1
+statnet.common,NVL,-1,0,0,class<`name`>,1
+statnet.common,NVL,-1,0,1,double[],1
+statnet.common,NVL,-1,0,2,null,1
+statnet.common,NVL,0,0,0,...,1
+statnet.common,NVL<-,-1,0,0,double,1
+statnet.common,NVL<-,0,0,0,double,1
+statnet.common,NVL<-,0,0,1,null,1
+statnet.common,NVL<-,1,0,0,double,1
+statnet.common,NVL2,-1,0,0,character,1
+statnet.common,NVL2,0,0,0,double,1
+statnet.common,NVL2,0,0,1,null,1
+statnet.common,NVL2,1,0,0,character,1
+statnet.common,NVL2,2,0,0,character,1
+statnet.common,NVL3,-1,0,0,character,1
+statnet.common,NVL3,-1,0,1,double,1
+statnet.common,NVL3,0,0,0,null,1
+statnet.common,NVL3,0,0,1,double,1
+statnet.common,NVL3,1,0,0,any,1
+statnet.common,NVL3,2,0,0,character,1
+statnet.common,once,-1,0,0,class<`function`>,1
+statnet.common,once,0,0,0,any,1
+statnet.common,once,1,0,0,double,1
+statnet.common,once,2,0,0,double,1
+statnet.common,order,-1,0,0,integer[],1
+statnet.common,order,0,0,0,...,1
+statnet.common,order,1,0,0,logical,1
+statnet.common,order,2,0,0,logical,1
+statnet.common,order.data.frame,-1,0,0,integer[],1
+statnet.common,order.data.frame,0,0,0,...,1
+statnet.common,order.data.frame,1,0,0,logical,1
+statnet.common,order.data.frame,2,0,0,logical,1
+statnet.common,order.default,-1,0,0,integer[],1
+statnet.common,order.default,0,0,0,...,1
+statnet.common,order.default,1,0,0,logical,1
+statnet.common,order.default,2,0,0,logical,1
+statnet.common,order.matrix,-1,0,0,integer[],1
+statnet.common,order.matrix,0,0,0,...,1
+statnet.common,order.matrix,1,0,0,logical,1
+statnet.common,order.matrix,2,0,0,logical,1
+statnet.common,paste.and,-1,0,0,character,1
+statnet.common,paste.and,0,0,0,double,1
+statnet.common,paste.and,0,0,1,integer[],1
+statnet.common,paste.and,0,0,2,null,1
+statnet.common,paste.and,1,0,0,character,1
+statnet.common,paste.and,2,0,0,character,1
+statnet.common,paste.and,3,0,0,character,1
+statnet.common,persistEval,-1,0,0,double,1
+statnet.common,persistEval,0,0,0,class<`{`>,1
+statnet.common,persistEval,0,0,1,class<`if`>,1
+statnet.common,persistEval,1,0,0,double,1
+statnet.common,persistEval,2,0,0,class<`{`>,1
+statnet.common,persistEval,2,0,1,class<`call`>,1
+statnet.common,persistEval,3,0,0,environment,1
+statnet.common,persistEval,4,0,0,environment,1
+statnet.common,persistEval,5,0,0,logical,1
+statnet.common,persistEvalQ,-1,0,0,double,1
+statnet.common,persistEvalQ,0,0,0,any,1
+statnet.common,persistEvalQ,1,0,0,double,1
+statnet.common,persistEvalQ,2,0,0,any,1
+statnet.common,persistEvalQ,3,0,0,environment,1
+statnet.common,persistEvalQ,4,0,0,environment,1
+statnet.common,persistEvalQ,5,0,0,logical,1
+statnet.common,.recurse_summation,-1,0,0,list<class<`name`>>,1
+statnet.common,.recurse_summation,0,0,0,class<`call`>,1
+statnet.common,.recurse_summation,0,0,1,class<`name`>,1
+statnet.common,.recurse_summation,1,0,0,double,1
+statnet.common,rep.rle,-1,0,0,class<`rle`>,1
+statnet.common,rep.rle,0,0,0,class<`rle`>,1
+statnet.common,rep.rle,1,0,0,...,1
+statnet.common,rep.rle,2,0,0,character,1
+statnet.common,rep.rle,3,0,0,logical,1
+statnet.common,^.rle,-1,0,0,class<`rle`>,1
+statnet.common,^.rle,0,0,0,class<`rle`>,1
+statnet.common,^.rle,1,0,0,class<`rle`>,1
+statnet.common,<=.rle,-1,0,0,class<`rle`>,1
+statnet.common,<=.rle,0,0,0,class<`rle`>,1
+statnet.common,<=.rle,1,0,0,class<`rle`>,1
+statnet.common,<.rle,-1,0,0,class<`rle`>,1
+statnet.common,<.rle,0,0,0,class<`rle`>,1
+statnet.common,<.rle,1,0,0,class<`rle`>,1
+statnet.common,==.rle,-1,0,0,class<`rle`>,1
+statnet.common,==.rle,0,0,0,class<`rle`>,1
+statnet.common,==.rle,1,0,0,class<`rle`>,1
+statnet.common,>=.rle,-1,0,0,class<`rle`>,1
+statnet.common,>=.rle,0,0,0,class<`rle`>,1
+statnet.common,>=.rle,1,0,0,class<`rle`>,1
+statnet.common,>.rle,-1,0,0,class<`rle`>,1
+statnet.common,>.rle,0,0,0,class<`rle`>,1
+statnet.common,>.rle,1,0,0,class<`rle`>,1
+statnet.common,|.rle,-1,0,0,class<`rle`>,1
+statnet.common,|.rle,0,0,0,class<`rle`>,1
+statnet.common,|.rle,1,0,0,class<`rle`>,1
+statnet.common,-.rle,-1,0,0,class<`rle`>,1
+statnet.common,-.rle,0,0,0,class<`rle`>,1
+statnet.common,-.rle,1,0,0,any,1
+statnet.common,!=.rle,-1,0,0,class<`rle`>,1
+statnet.common,!=.rle,0,0,0,class<`rle`>,1
+statnet.common,!=.rle,1,0,0,class<`rle`>,1
+statnet.common,!.rle,-1,0,0,class<`rle`>,1
+statnet.common,!.rle,0,0,0,class<`rle`>,1
+statnet.common,/.rle,-1,0,0,class<`rle`>,1
+statnet.common,/.rle,0,0,0,class<`rle`>,1
+statnet.common,/.rle,1,0,0,class<`rle`>,1
+statnet.common,*.rle,-1,0,0,class<`rle`>,1
+statnet.common,*.rle,0,0,0,class<`rle`>,1
+statnet.common,*.rle,1,0,0,class<`rle`>,1
+statnet.common,&.rle,-1,0,0,class<`rle`>,1
+statnet.common,&.rle,0,0,0,class<`rle`>,1
+statnet.common,&.rle,1,0,0,class<`rle`>,1
+statnet.common,%/%.rle,-1,0,0,class<`rle`>,1
+statnet.common,%/%.rle,0,0,0,class<`rle`>,1
+statnet.common,%/%.rle,1,0,0,class<`rle`>,1
+statnet.common,%%.rle,-1,0,0,class<`rle`>,1
+statnet.common,%%.rle,0,0,0,class<`rle`>,1
+statnet.common,%%.rle,1,0,0,class<`rle`>,1
+statnet.common,+.rle,-1,0,0,class<`rle`>,1
+statnet.common,+.rle,0,0,0,class<`rle`>,1
+statnet.common,+.rle,1,0,0,any,1
+statnet.common,rowweights,-1,0,0,double[],1
+statnet.common,rowweights,0,0,0,"class<`logwmatrix`, `matrix`, `wmatrix`>",1
+statnet.common,rowweights,1,0,0,...,1
+statnet.common,rowweights<-,-1,0,0,"class<`linwmatrix`, `matrix`, `wmatrix`>",1
+statnet.common,rowweights<-,0,0,0,class<`matrix`>,1
+statnet.common,rowweights<-,1,0,0,...,1
+statnet.common,rowweights<-,2,0,0,double[],1
+statnet.common,rowweights.logwmatrix,-1,0,0,double[],1
+statnet.common,rowweights.logwmatrix,0,0,0,"class<`logwmatrix`, `matrix`, `wmatrix`>",1
+statnet.common,rowweights.logwmatrix,1,0,0,...,1
+statnet.common,rowweights<-.matrix,-1,0,0,"class<`linwmatrix`, `matrix`, `wmatrix`>",1
+statnet.common,rowweights<-.matrix,0,0,0,class<`matrix`>,1
+statnet.common,rowweights<-.matrix,1,0,0,...,1
+statnet.common,rowweights<-.matrix,2,0,0,double[],1
+statnet.common,.run_mul,-1,0,0,integer[],1
+statnet.common,.run_mul,0,0,0,integer,1
+statnet.common,.run_mul,1,0,0,integer,1
+statnet.common,set.control.class,-1,0,0,"class<`control.list`, `list`, `test`>",1
+statnet.common,set.control.class,0,0,0,character,1
+statnet.common,set.control.class,1,0,0,list<double>,1
+statnet.common,sort.data.frame,-1,0,0,class<`data.frame`>,1
+statnet.common,sort.data.frame,0,0,0,class<`data.frame`>,1
+statnet.common,sort.data.frame,1,0,0,logical,1
+statnet.common,sort.data.frame,2,0,0,...,1
+statnet.common,sum.rle,-1,0,0,double,1
+statnet.common,sum.rle,0,0,0,...,1
+statnet.common,sum.rle,1,0,0,logical,1
+statnet.common,sweep_cols.matrix,-1,0,0,class<`matrix`>,1
+statnet.common,sweep_cols.matrix,0,0,0,class<`matrix`>,1
+statnet.common,sweep_cols.matrix,1,0,0,double[],1
+statnet.common,sweep_cols.matrix,2,0,0,logical,1
+statnet.common,sweep.mcmc.list,-1,0,0,class<`mcmc.list`>,1
+statnet.common,sweep.mcmc.list,0,0,0,class<`mcmc.list`>,1
+statnet.common,sweep.mcmc.list,1,0,0,integer[],1
+statnet.common,sweep.mcmc.list,2,0,0,character,1
+statnet.common,sweep.mcmc.list,3,0,0,logical,1
+statnet.common,sweep.mcmc.list,4,0,0,...,1
+statnet.common,ult,-1,0,0,character,1
+statnet.common,ult,-1,0,1,class<`call`>,1
+statnet.common,ult,-1,0,2,integer,1
+statnet.common,ult,0,0,0,character[],1
+statnet.common,ult,0,0,1,class<`formula`>,1
+statnet.common,ult,0,0,2,integer[],1
+statnet.common,ult,1,0,0,double,1
+statnet.common,ult<-,-1,0,0,class<`formula`>,1
+statnet.common,ult<-,-1,0,1,double[],1
+statnet.common,ult<-,0,0,0,class<`formula`>,1
+statnet.common,ult<-,0,0,1,double[],1
+statnet.common,ult<-,1,0,0,double,1
+statnet.common,ult<-,2,0,0,class<`call`>,1
+statnet.common,ult<-,2,0,1,double,1
+statnet.common,unwhich,-1,0,0,logical[],1
+statnet.common,unwhich,0,0,0,integer[],1
+statnet.common,unwhich,1,0,0,double,1
+statnet.common,vector.namesmatch,-1,0,0,list<double>,1
+statnet.common,vector.namesmatch,0,0,0,list<double>,1
+statnet.common,vector.namesmatch,1,0,0,character[],1
+statnet.common,vector.namesmatch,2,0,0,null,1
+statnet.common,[<-.wmatrix,-1,0,0,"class<`logwmatrix`, `matrix`, `wmatrix`>",1
+statnet.common,[<-.wmatrix,0,0,0,"class<`logwmatrix`, `matrix`, `wmatrix`>",1
+statnet.common,[<-.wmatrix,1,0,0,double,1
+statnet.common,[<-.wmatrix,2,0,0,any,1
+statnet.common,[<-.wmatrix,3,0,0,...,1
+statnet.common,[<-.wmatrix,4,0,0,integer[],1
+statnet.common,[.wmatrix,-1,0,0,"class<`linwmatrix`, `matrix`, `wmatrix`>",1
+statnet.common,[.wmatrix,-1,0,1,"class<`logwmatrix`, `matrix`, `wmatrix`>",1
+statnet.common,[.wmatrix,0,0,0,"class<`linwmatrix`, `matrix`, `wmatrix`>",1
+statnet.common,[.wmatrix,0,0,1,"class<`logwmatrix`, `matrix`, `wmatrix`>",1
+statnet.common,[.wmatrix,1,0,0,any,1
+statnet.common,[.wmatrix,2,0,0,any,1
+statnet.common,[.wmatrix,3,0,0,...,1
+statnet.common,[.wmatrix,4,0,0,logical,1
+storr,%||%,-1,0,0,character,1
+storr,%||%,0,0,0,character,1
+storr,%||%,0,0,1,null,1
+storr,%||%,1,0,0,any,1
+storr,assert_character,-1,0,0,null,1
+storr,assert_character,0,0,0,character,1
+storr,assert_character,1,0,0,any,1
+storr,assert_environment,-1,0,0,null,1
+storr,assert_environment,0,0,0,environment,1
+storr,assert_environment,1,0,0,any,1
+storr,assert_function,-1,0,0,null,1
+storr,assert_function,0,0,0,class<`function`>,1
+storr,assert_function,1,0,0,any,1
+storr,assert_length,-1,0,0,null,1
+storr,assert_length,0,0,0,double[],1
+storr,assert_length,0,0,1,list<any>,1
+storr,assert_length,1,0,0,integer,1
+storr,assert_length,2,0,0,any,1
+storr,assert_list,-1,0,0,null,1
+storr,assert_list,0,0,0,list<environment>,1
+storr,assert_list,1,0,0,any,1
+storr,assert_logical,-1,0,0,null,1
+storr,assert_logical,0,0,0,logical,1
+storr,assert_logical,1,0,0,any,1
+storr,assert_probably_storr_driver,-1,0,0,"class<`R6`, `driver_environment`>",1
+storr,assert_probably_storr_driver,-1,0,1,"class<`R6`, `driver_rds`>",1
+storr,assert_probably_storr_driver,0,0,0,"class<`R6`, `driver_environment`>",1
+storr,assert_probably_storr_driver,0,0,1,"class<`R6`, `driver_rds`>",1
+storr,assert_probably_storr_driver,1,0,0,any,1
+storr,assert_raw,-1,0,0,null,1
+storr,assert_raw,0,0,0,raw[],1
+storr,assert_raw,1,0,0,any,1
+storr,assert_scalar,-1,0,0,null,1
+storr,assert_scalar,0,0,0,character,1
+storr,assert_scalar,0,0,1,logical,1
+storr,assert_scalar,1,0,0,any,1
+storr,assert_scalar_character,-1,0,0,null,1
+storr,assert_scalar_character,0,0,0,character,1
+storr,assert_scalar_character,1,0,0,any,1
+storr,assert_scalar_logical,-1,0,0,null,1
+storr,assert_scalar_logical,0,0,0,logical,1
+storr,assert_scalar_logical,1,0,0,any,1
+storr,assert_valid_table_name,-1,0,0,null,1
+storr,assert_valid_table_name,0,0,0,character,1
+storr,assert_valid_table_name,1,0,0,any,1
+storr,check_external_fetch_hook,-1,0,0,class<`function`>,1
+storr,check_external_fetch_hook,0,0,0,class<`function`>,1
+storr,check_length,-1,0,0,integer,1
+storr,check_length,0,0,0,character[],1
+storr,check_length,1,0,0,character[],1
+storr,ConfigError,-1,0,0,"class<`ConfigError`, `condition`, `error`>",1
+storr,ConfigError,0,0,0,character,1
+storr,ConfigError,1,0,0,character,1
+storr,ConfigError,2,0,0,character,1
+storr,dbi_connection_factory,-1,0,0,class<`function`>,1
+storr,dbi_connection_factory,0,0,0,class<`SQLiteDriver`>,1
+storr,dbi_connection_factory,0,0,1,null,1
+storr,dbi_connection_factory,1,0,0,character,1
+storr,dbi_connection_factory,1,0,1,null,1
+storr,dbi_supports_binary,-1,0,0,logical,1
+storr,dbi_supports_binary,0,0,0,class<`SQLiteConnection`>,1
+storr,dbi_use_binary,-1,0,0,logical,1
+storr,dbi_use_binary,0,0,0,class<`SQLiteConnection`>,1
+storr,dbi_use_binary,1,0,0,character,1
+storr,dbi_use_binary,2,0,0,null,1
+storr,decode64,-1,0,0,character[],1
+storr,decode64,0,0,0,character[],1
+storr,decode64,1,0,0,character,1
+storr,decode64,2,0,0,character,1
+storr,decode64,3,0,0,any,1
+storr,dir_create,-1,0,0,logical,1
+storr,dir_create,-1,0,1,null,1
+storr,dir_create,0,0,0,character,1
+storr,dquote,-1,0,0,character,1
+storr,dquote,0,0,0,character,1
+storr,driver_classes,-1,0,0,character[],1
+storr,driver_dbi,-1,0,0,"class<`R6`, `driver_DBI`>",1
+storr,driver_dbi,0,0,0,character,1
+storr,driver_dbi,1,0,0,character,1
+storr,driver_dbi,2,0,0,class<`SQLiteConnection`>,1
+storr,driver_dbi,2,0,1,class<`SQLiteDriver`>,1
+storr,driver_dbi,3,0,0,null,1
+storr,driver_dbi,3,0,1,character,1
+storr,driver_dbi,4,0,0,null,1
+storr,driver_dbi,5,0,0,null,1
+storr,driver_dbi_dialect,-1,0,0,character,1
+storr,driver_dbi_dialect,0,0,0,class<`SQLiteConnection`>,1
+storr,driver_dbi_sql_compat,-1,0,0,list<character>,1
+storr,driver_dbi_sql_compat,0,0,0,character,1
+storr,driver_dbi_sql_compat,1,0,0,character,1
+storr,driver_dbi_sql_compat,2,0,0,character,1
+storr,driver_environment,-1,0,0,any,1
+storr,driver_environment,0,0,0,null,1
+storr,driver_environment,0,0,1,environment,1
+storr,driver_environment,1,0,0,null,1
+storr,driver_environment,1,0,1,character,1
+storr,driver_multistorr,-1,0,0,"class<`R6`, `driver_multistorr`>",1
+storr,driver_multistorr,0,0,0,"class<`R6`, `driver_environment`>",1
+storr,driver_multistorr,1,0,0,"class<`R6`, `driver_rds`>",1
+storr,driver_rds,-1,0,0,"class<`R6`, `driver_rds`>",1
+storr,driver_rds,0,0,0,character,1
+storr,driver_rds,1,0,0,null,1
+storr,driver_rds,2,0,0,logical,1
+storr,driver_rds,2,0,1,null,1
+storr,driver_rds,3,0,0,null,1
+storr,driver_rds,4,0,0,null,1
+storr,driver_rds_config,-1,0,0,character,1
+storr,driver_rds_config,-1,0,1,logical,1
+storr,driver_rds_config,0,0,0,character,1
+storr,driver_rds_config,1,0,0,character,1
+storr,driver_rds_config,2,0,0,null,1
+storr,driver_rds_config,2,0,1,logical,1
+storr,driver_rds_config,3,0,0,character,1
+storr,driver_rds_config,3,0,1,logical,1
+storr,driver_rds_config,4,0,0,logical,1
+storr,driver_rds_config_file,-1,0,0,character,1
+storr,driver_rds_config_file,0,0,0,character,1
+storr,driver_rds_config_file,1,0,0,character,1
+storr,dummy_test,-1,0,0,logical,1
+storr,encode64,-1,0,0,character,1
+storr,encode64,0,0,0,character,1
+storr,encode64,1,0,0,character,1
+storr,encode64,2,0,0,character,1
+storr,encode64,3,0,0,any,1
+storr,exists0,-1,0,0,any,1
+storr,exists0,0,0,0,any,1
+storr,exists0,1,0,0,any,1
+storr,export_names,-1,0,0,character[],1
+storr,export_names,0,0,0,character[],1
+storr,fetch_hook_read,-1,0,0,class<`function`>,1
+storr,fetch_hook_read,0,0,0,class<`function`>,1
+storr,fetch_hook_read,1,0,0,class<`function`>,1
+storr,file_remove,-1,0,0,logical,1
+storr,file_remove,0,0,0,character,1
+storr,HashError,-1,0,0,"class<`HashError`, `condition`, `error`>",1
+storr,HashError,0,0,0,character,1
+storr,HashError,1,0,0,any,1
+storr,is_storr,-1,0,0,logical,1
+storr,is_storr,0,0,0,"class<`R6`, `storr`>",1
+storr,is_storr,0,0,1,"class<`R6`, `storr`, `storr_external`>",1
+storr,is_storr,0,0,2,environment,1
+storr,is_storr,0,0,3,list<any>,1
+storr,join_key_namespace,-1,0,0,list<integer | character[]>,1
+storr,join_key_namespace,-1,0,1,list<integer | character>,1
+storr,join_key_namespace,0,0,0,character[],1
+storr,join_key_namespace,1,0,0,character[],1
+storr,KeyError,-1,0,0,"class<`KeyError`, `condition`, `error`>",1
+storr,KeyError,0,0,0,character,1
+storr,KeyError,1,0,0,character,1
+storr,KeyError,2,0,0,any,1
+storr,KeyErrorExternal,-1,0,0,"class<`KeyError`, `KeyErrorExternal`, `condition`, `error`>",1
+storr,KeyErrorExternal,0,0,0,character,1
+storr,KeyErrorExternal,1,0,0,character,1
+storr,KeyErrorExternal,2,0,0,"class<`condition`, `error`, `simpleError`>",1
+storr,make_do_mget,-1,0,0,class<`function`>,1
+storr,make_do_mget,0,0,0,"class<`R6`, `storr`>",1
+storr,make_do_mget,0,0,1,"class<`R6`, `storr`, `storr_external`>",1
+storr,make_do_mget,0,0,2,environment,1
+storr,make_do_mset,-1,0,0,class<`function`>,1
+storr,make_do_mset,0,0,0,"class<`R6`, `storr`>",1
+storr,make_do_mset,0,0,1,environment,1
+storr,make_do_mset,0,0,2,list<any>,1
+storr,make_hash_serialized_object,-1,0,0,character,1
+storr,make_hash_serialized_object,0,0,0,raw[],1
+storr,make_hash_serialized_object,-1,1,0,class<`function`>,1
+storr,make_hash_serialized_object,0,1,0,character,1
+storr,make_hash_serialized_object,1,1,0,logical,1
+storr,make_serialize_object,-1,0,0,raw[],1
+storr,make_serialize_object,0,0,0,character[],1
+storr,make_serialize_object,0,0,1,class<`data.frame`>,1
+storr,make_serialize_object,0,0,2,class<`function`>,1
+storr,make_serialize_object,0,0,3,double[],1
+storr,make_serialize_object,0,0,4,list<character>,1
+storr,make_serialize_object,-1,1,0,class<`function`>,1
+storr,make_serialize_object,0,1,0,logical,1
+storr,make_serialize_object,1,1,0,logical,1
+storr,make_serialize_object,2,1,0,logical,1
+storr,make_serialize_object,3,1,0,any,1
+storr,match_value,-1,0,0,character,1
+storr,match_value,0,0,0,character,1
+storr,match_value,1,0,0,character[],1
+storr,match_value,2,0,0,character,1
+storr,rm0,-1,0,0,logical[],1
+storr,rm0,0,0,0,character[],1
+storr,rm0,1,0,0,any,1
+storr,serialize_to_raw,-1,0,0,raw[],1
+storr,serialize_to_raw,0,0,0,character[],1
+storr,serialize_to_raw,0,0,1,class<`data.frame`>,1
+storr,serialize_to_raw,0,0,2,class<`function`>,1
+storr,serialize_to_raw,0,0,3,double[],1
+storr,serialize_to_raw,0,0,4,list<double>,1
+storr,serialize_to_raw,0,0,5,list<character>,1
+storr,serialize_to_raw,1,0,0,logical,1
+storr,serialize_to_raw,2,0,0,logical,1
+storr,storr,-1,0,0,"class<`R6`, `storr`>",1
+storr,storr,0,0,0,"class<`R6`, `driver_environment`>",1
+storr,storr,0,0,1,"class<`R6`, `driver_DBI`>",1
+storr,storr,0,0,2,"class<`R6`, `driver_multistorr`>",1
+storr,storr,0,0,3,"class<`R6`, `driver_rds`>",1
+storr,storr,1,0,0,character,1
+storr,storr_copy,-1,0,0,"list<class<`matrix`> | class<`R6`, `storr`>>",1
+storr,storr_copy,-1,0,1,list<class<`matrix`> | environment>,1
+storr,storr_copy,-1,0,2,list<class<`matrix`> | list<double[]>>,1
+storr,storr_copy,0,0,0,"class<`R6`, `storr`>",1
+storr,storr_copy,0,0,1,environment,1
+storr,storr_copy,0,0,2,list<any>,1
+storr,storr_copy,1,0,0,"class<`R6`, `storr`>",1
+storr,storr_copy,1,0,1,"class<`R6`, `storr`, `storr_external`>",1
+storr,storr_copy,1,0,2,environment,1
+storr,storr_copy,2,0,0,character,1
+storr,storr_copy,2,0,1,null,1
+storr,storr_copy,3,0,0,character[],1
+storr,storr_copy,4,0,0,any,1
+storr,storr_environment,-1,0,0,"class<`R6`, `storr`>",1
+storr,storr_environment,0,0,0,null,1
+storr,storr_environment,1,0,0,null,1
+storr,storr_environment,2,0,0,character,1
+storr,storr_external,-1,0,0,"class<`R6`, `storr`, `storr_external`>",1
+storr,storr_external,0,0,0,"class<`R6`, `driver_environment`>",1
+storr,storr_external,1,0,0,class<`function`>,1
+storr,storr_external,2,0,0,character,1
+storr,storr_gc,-1,0,0,character[],1
+storr,storr_gc,0,0,0,"class<`R6`, `driver_environment`>",1
+storr,storr_gc,0,0,1,"class<`R6`, `driver_rds`>",1
+storr,storr_gc,1,0,0,any,1
+storr,storr_mset_hash,-1,0,0,null,1
+storr,storr_mset_hash,0,0,0,"class<`R6`, `storr`>",1
+storr,storr_mset_hash,1,0,0,character[],1
+storr,storr_mset_hash,2,0,0,character[],1
+storr,storr_mset_hash,3,0,0,character[],1
+storr,storr_rds,-1,0,0,"class<`R6`, `storr`>",1
+storr,storr_rds,0,0,0,character,1
+storr,storr_rds,1,0,0,null,1
+storr,storr_rds,2,0,0,logical,1
+storr,storr_rds,2,0,1,null,1
+storr,storr_rds,3,0,0,null,1
+storr,storr_rds,4,0,0,null,1
+storr,storr_rds,5,0,0,character,1
+storr,storr_traits,-1,0,0,list<character | logical>,1
+storr,storr_traits,0,0,0,list<character>,1
+storr,storr_traits,0,0,1,list<character | logical>,1
+storr,storr_traits_default,-1,0,0,list<character | logical>,1
+storr,storr_used_hashes,-1,0,0,character[],1
+storr,storr_used_hashes,0,0,0,"class<`R6`, `driver_environment`>",1
+storr,storr_used_hashes,0,0,1,"class<`R6`, `driver_rds`>",1
+storr,test_driver,-1,0,0,class<`data.frame`>,1
+storr,test_driver,0,0,0,class<`function`>,1
+storr,test_driver_finish,-1,0,0,class<`data.frame`>,1
+storr,test_driver_finish,0,0,0,class<`data.frame`>,1
+storr,test_driver_finish,1,0,0,logical,1
+storr,try_write_lines,-1,0,0,logical,1
+storr,try_write_lines,0,0,0,character,1
+storr,try_write_lines,1,0,0,character,1
+storr,try_write_lines,2,0,0,...,1
+storr,try_write_lines,3,0,0,character,1
+storr,try_write_serialized_rds,-1,0,0,logical,1
+storr,try_write_serialized_rds,0,0,0,raw[],1
+storr,try_write_serialized_rds,1,0,0,character,1
+storr,try_write_serialized_rds,2,0,0,logical,1
+storr,try_write_serialized_rds,3,0,0,character,1
+storr,try_write_serialized_rds,4,0,0,double,1
+storr,unserialize_safe,-1,0,0,double[],1
+storr,unserialize_safe,-1,0,1,list<character>,1
+storr,unserialize_safe,0,0,0,raw[],1
+storr,vcapply,-1,0,0,^character[],1
+storr,vcapply,-1,0,1,null,1
+storr,vcapply,0,0,0,integer[],1
+storr,vcapply,0,0,1,character[],1
+storr,vcapply,0,0,2,list<any>,1
+storr,vcapply,1,0,0,class<`function`>,1
+storr,vcapply,2,0,0,...,1
+storr,viapply,-1,0,0,integer[],1
+storr,viapply,0,0,0,character[],1
+storr,viapply,1,0,0,class<`function`>,1
+storr,viapply,2,0,0,...,1
+storr,vlapply,-1,0,0,any,1
+storr,vlapply,0,0,0,any,1
+storr,vlapply,1,0,0,class<`function`>,1
+storr,vlapply,2,0,0,...,1
+storr,write_if_missing,-1,0,0,null,1
+storr,write_if_missing,0,0,0,any,1
+storr,write_if_missing,1,0,0,character,1
+storr,write_lines,-1,0,0,logical,1
+storr,write_lines,0,0,0,character,1
+storr,write_lines,1,0,0,character,1
+storr,write_lines,2,0,0,...,1
+storr,write_lines,3,0,0,character,1
+storr,write_serialized_rds,-1,0,0,logical,1
+storr,write_serialized_rds,0,0,0,raw[],1
+storr,write_serialized_rds,1,0,0,character,1
+storr,write_serialized_rds,2,0,0,logical,1
+storr,write_serialized_rds,3,0,0,character,1
+storr,write_serialized_rds,4,0,0,double,1
+stringdist,ain,-1,0,0,logical,1
+stringdist,ain,0,0,0,character,1
+stringdist,ain,1,0,0,character[],1
+stringdist,ain,2,0,0,...,1
+stringdist,all_int,-1,0,0,logical,1
+stringdist,all_int,0,0,0,list<any>,1
+stringdist,amatch,-1,0,0,^integer[],1
+stringdist,amatch,-1,0,1,null,1
+stringdist,amatch,0,0,0,character[],1
+stringdist,amatch,0,0,1,null,1
+stringdist,amatch,1,0,0,character[],1
+stringdist,amatch,1,0,1,^logical[],1
+stringdist,amatch,1,0,2,null,1
+stringdist,amatch,2,0,0,null,1
+stringdist,amatch,2,0,1,double,1
+stringdist,amatch,3,0,0,logical,1
+stringdist,amatch,4,0,0,character[],1
+stringdist,amatch,5,0,0,logical,1
+stringdist,amatch,6,0,0,double[],1
+stringdist,amatch,7,0,0,double,1
+stringdist,amatch,8,0,0,double,1
+stringdist,amatch,9,0,0,double,1
+stringdist,amatch,10,0,0,double,1
+stringdist,amatch,11,0,0,double,1
+stringdist,do_dist,-1,0,0,^double[],1
+stringdist,do_dist,-1,0,1,null,1
+stringdist,do_dist,0,0,0,character[],1
+stringdist,do_dist,0,0,1,list<^integer[]>,1
+stringdist,do_dist,0,0,2,null,1
+stringdist,do_dist,1,0,0,^character[],1
+stringdist,do_dist,1,0,1,list<null | integer[]>,1
+stringdist,do_dist,1,0,2,list<^integer[] | null>,1
+stringdist,do_dist,1,0,3,list<integer[]>,1
+stringdist,do_dist,1,0,4,null,1
+stringdist,do_dist,2,0,0,character,1
+stringdist,do_dist,3,0,0,double[],1
+stringdist,do_dist,4,0,0,double,1
+stringdist,do_dist,5,0,0,double,1
+stringdist,do_dist,6,0,0,double,1
+stringdist,do_dist,7,0,0,logical,1
+stringdist,do_dist,8,0,0,integer,1
+stringdist,ensure_int_list,-1,0,0,list<any>,1
+stringdist,ensure_int_list,0,0,0,list<any>,1
+stringdist,ensure_int_list,0,0,1,double[],1
+stringdist,int2char,-1,0,0,^character[],1
+stringdist,int2char,0,0,0,list<integer[] | null>,1
+stringdist,int2char,0,0,1,list<integer[]>,1
+stringdist,lengths,-1,0,0,integer[],1
+stringdist,lengths,0,0,0,character[],1
+stringdist,lengths,0,0,1,list<^integer[] | null>,1
+stringdist,lengths,0,0,2,list<integer[]>,1
+stringdist,lengths,1,0,0,...,1
+stringdist,lengths.character,-1,0,0,integer[],1
+stringdist,lengths.character,0,0,0,character[],1
+stringdist,lengths.character,1,0,0,character,1
+stringdist,lengths.character,2,0,0,...,1
+stringdist,lengths.list,-1,0,0,integer[],1
+stringdist,lengths.list,0,0,0,list<^integer[] | null>,1
+stringdist,lengths.list,0,0,1,list<integer[]>,1
+stringdist,lengths.list,1,0,0,...,1
+stringdist,listwarning,-1,0,0,character,1
+stringdist,listwarning,0,0,0,character,1
+stringdist,listwarning,1,0,0,character,1
+stringdist,lower_tri,-1,0,0,class<`dist`>,1
+stringdist,lower_tri,0,0,0,^character[],1
+stringdist,lower_tri,0,0,1,list<integer[]>,1
+stringdist,lower_tri,1,0,0,character,1
+stringdist,lower_tri,2,0,0,logical,1
+stringdist,lower_tri,3,0,0,double[],1
+stringdist,lower_tri,4,0,0,double,1
+stringdist,lower_tri,5,0,0,double,1
+stringdist,lower_tri,6,0,0,double,1
+stringdist,lower_tri,7,0,0,character,1
+stringdist,lower_tri,8,0,0,integer,1
+stringdist,normalize_dist,-1,0,0,^double[],1
+stringdist,normalize_dist,0,0,0,^double[],1
+stringdist,normalize_dist,1,0,0,any,1
+stringdist,normalize_dist,2,0,0,any,1
+stringdist,normalize_dist,3,0,0,character,1
+stringdist,normalize_dist,4,0,0,any,1
+stringdist,normalize_dist,5,0,0,any,1
+stringdist,phonetic,-1,0,0,^character[],1
+stringdist,phonetic,0,0,0,^character[],1
+stringdist,phonetic,1,0,0,character,1
+stringdist,phonetic,2,0,0,logical,1
+stringdist,printable_ascii,-1,0,0,logical[],1
+stringdist,printable_ascii,0,0,0,character[],1
+stringdist,printable_ascii,0,0,1,null,1
+stringdist,qgrams,-1,0,0,class<`matrix`>,1
+stringdist,qgrams,0,0,0,...,1
+stringdist,qgrams,1,0,0,null,1
+stringdist,qgrams,2,0,0,double,1
+stringdist,qgrams,3,0,0,logical,1
+stringdist,qgrams,4,0,0,logical,1
+stringdist,seq_ain,-1,0,0,logical,1
+stringdist,seq_ain,0,0,0,list<integer[]>,1
+stringdist,seq_ain,1,0,0,list<integer[]>,1
+stringdist,seq_ain,2,0,0,...,1
+stringdist,seq_amatch,-1,0,0,^integer[],1
+stringdist,seq_amatch,-1,0,1,null,1
+stringdist,seq_amatch,0,0,0,list<^integer[] | null>,1
+stringdist,seq_amatch,0,0,1,list<integer[]>,1
+stringdist,seq_amatch,0,0,2,double[],1
+stringdist,seq_amatch,0,0,3,list<null>,1
+stringdist,seq_amatch,1,0,0,list<integer[]>,1
+stringdist,seq_amatch,1,0,1,double[],1
+stringdist,seq_amatch,2,0,0,null,1
+stringdist,seq_amatch,2,0,1,double,1
+stringdist,seq_amatch,3,0,0,logical,1
+stringdist,seq_amatch,4,0,0,character[],1
+stringdist,seq_amatch,5,0,0,double[],1
+stringdist,seq_amatch,6,0,0,double,1
+stringdist,seq_amatch,7,0,0,double,1
+stringdist,seq_amatch,8,0,0,double,1
+stringdist,seq_amatch,9,0,0,double,1
+stringdist,seq_amatch,10,0,0,double,1
+stringdist,seq_dist,-1,0,0,any,1
+stringdist,seq_dist,0,0,0,list<any>,1
+stringdist,seq_dist,0,0,1,double[],1
+stringdist,seq_dist,1,0,0,list<any>,1
+stringdist,seq_dist,1,0,1,double[],1
+stringdist,seq_dist,2,0,0,character[],1
+stringdist,seq_dist,3,0,0,double[],1
+stringdist,seq_dist,4,0,0,double,1
+stringdist,seq_dist,5,0,0,double,1
+stringdist,seq_dist,6,0,0,double,1
+stringdist,seq_dist,7,0,0,double,1
+stringdist,seq_distmatrix,-1,0,0,class<`dist`>,1
+stringdist,seq_distmatrix,-1,0,1,class<`matrix`>,1
+stringdist,seq_distmatrix,0,0,0,double[],1
+stringdist,seq_distmatrix,0,0,1,list<double[]>,1
+stringdist,seq_distmatrix,1,0,0,any,1
+stringdist,seq_distmatrix,2,0,0,character[],1
+stringdist,seq_distmatrix,3,0,0,double[],1
+stringdist,seq_distmatrix,4,0,0,double,1
+stringdist,seq_distmatrix,5,0,0,double,1
+stringdist,seq_distmatrix,6,0,0,double,1
+stringdist,seq_distmatrix,7,0,0,character[],1
+stringdist,seq_distmatrix,8,0,0,double,1
+stringdist,seq_qgrams,-1,0,0,class<`matrix`>,1
+stringdist,seq_qgrams,0,0,0,...,1
+stringdist,seq_qgrams,1,0,0,null,1
+stringdist,seq_qgrams,2,0,0,double,1
+stringdist,seq_sim,-1,0,0,^double[],1
+stringdist,seq_sim,0,0,0,list<^integer[] | null>,1
+stringdist,seq_sim,0,0,1,list<double[]>,1
+stringdist,seq_sim,1,0,0,list<double[]>,1
+stringdist,seq_sim,2,0,0,character[],1
+stringdist,seq_sim,3,0,0,double,1
+stringdist,seq_sim,4,0,0,...,1
+stringdist,setnames,-1,0,0,list<^character[]>,1
+stringdist,setnames,-1,0,1,list<list<integer[]>>,1
+stringdist,setnames,-1,0,2,list<list<^integer[] | null>>,1
+stringdist,setnames,-1,0,3,list<null>,1
+stringdist,setnames,0,0,0,list<^character[]>,1
+stringdist,setnames,0,0,1,list<list<integer[]>>,1
+stringdist,setnames,0,0,2,list<list<^integer[] | null>>,1
+stringdist,setnames,0,0,3,list<null>,1
+stringdist,setNames,-1,0,0,character[],1
+stringdist,setNames,-1,0,1,list<^character[]>,1
+stringdist,setNames,-1,0,2,list<list<integer[]>>,1
+stringdist,setNames,-1,0,3,list<list<^integer[] | null>>,1
+stringdist,setNames,-1,0,4,list<null>,1
+stringdist,setNames,0,0,0,character[],1
+stringdist,setNames,0,0,1,list<^character[]>,1
+stringdist,setNames,0,0,2,list<list<integer[]>>,1
+stringdist,setNames,0,0,3,list<list<^integer[] | null>>,1
+stringdist,setNames,0,0,4,list<null>,1
+stringdist,setNames,1,0,0,character[],1
+stringdist,stringdist,-1,0,0,any,1
+stringdist,stringdist,0,0,0,^character[],1
+stringdist,stringdist,0,0,1,list<character>,1
+stringdist,stringdist,0,0,2,null,1
+stringdist,stringdist,1,0,0,character[],1
+stringdist,stringdist,1,0,1,list<character>,1
+stringdist,stringdist,1,0,2,null,1
+stringdist,stringdist,2,0,0,any,1
+stringdist,stringdist,3,0,0,logical,1
+stringdist,stringdist,4,0,0,double[],1
+stringdist,stringdist,5,0,0,double,1
+stringdist,stringdist,6,0,0,double,1
+stringdist,stringdist,7,0,0,double,1
+stringdist,stringdist,8,0,0,any,1
+stringdist,stringdistmatrix,-1,0,0,class<`dist`>,1
+stringdist,stringdistmatrix,-1,0,1,class<`matrix`>,1
+stringdist,stringdistmatrix,0,0,0,^character[],1
+stringdist,stringdistmatrix,0,0,1,list<character>,1
+stringdist,stringdistmatrix,1,0,0,any,1
+stringdist,stringdistmatrix,2,0,0,character[],1
+stringdist,stringdistmatrix,3,0,0,logical,1
+stringdist,stringdistmatrix,4,0,0,double[],1
+stringdist,stringdistmatrix,5,0,0,double,1
+stringdist,stringdistmatrix,6,0,0,double,1
+stringdist,stringdistmatrix,7,0,0,double,1
+stringdist,stringdistmatrix,8,0,0,character[],1
+stringdist,stringdistmatrix,8,0,1,logical,1
+stringdist,stringdistmatrix,9,0,0,double,1
+stringdist,stringsim,-1,0,0,double[],1
+stringdist,stringsim,0,0,0,character[],1
+stringdist,stringsim,1,0,0,character[],1
+stringdist,stringsim,2,0,0,character[],1
+stringdist,stringsim,3,0,0,logical,1
+stringdist,stringsim,4,0,0,double,1
+stringdist,stringsim,5,0,0,...,1
+stringr,as_bare_character,-1,0,0,character,1
+stringr,as_bare_character,0,0,0,character,1
+stringr,boundary,-1,0,0,"class<`boundary`, `character`, `pattern`>",1
+stringr,boundary,0,0,0,character,1
+stringr,boundary,1,0,0,null,1
+stringr,boundary,2,0,0,...,1
+stringr,coll,-1,0,0,"class<`character`, `coll`, `pattern`>",1
+stringr,coll,0,0,0,character,1
+stringr,coll,1,0,0,logical,1
+stringr,coll,2,0,0,character,1
+stringr,coll,3,0,0,...,1
+stringr,eval_interp_matches,-1,0,0,list<character>,1
+stringr,eval_interp_matches,0,0,0,character[],1
+stringr,eval_interp_matches,1,0,0,class<`data.frame`>,1
+stringr,eval_interp_matches,1,0,1,environment,1
+stringr,eval_interp_matches,1,0,2,list<double>,1
+stringr,extract_expressions,-1,0,0,list<expression>,1
+stringr,extract_expressions,0,0,0,character[],1
+stringr,extract_formats,-1,0,0,character[],1
+stringr,extract_formats,0,0,0,character[],1
+stringr,fixed,-1,0,0,"class<`character`, `fixed`, `pattern`>",1
+stringr,fixed,0,0,0,character,1
+stringr,fixed,1,0,0,logical,1
+stringr,fix_replacement,-1,0,0,character[],1
+stringr,fix_replacement,-1,0,1,null,1
+stringr,fix_replacement,0,0,0,character[],1
+stringr,fix_replacement,0,0,1,null,1
+stringr,interp_placeholders,-1,0,0,list<integer[] | character[]>,1
+stringr,interp_placeholders,-1,0,1,list<integer | character>,1
+stringr,interp_placeholders,0,0,0,character,1
+stringr,invert_match,-1,0,0,class<`matrix`>,1
+stringr,invert_match,0,0,0,class<`matrix`>,1
+stringr,opts,-1,0,0,null,1
+stringr,opts,-1,0,1,list<logical>,1
+stringr,opts,-1,0,2,list<character | integer>,1
+stringr,opts,-1,0,3,list<character>,1
+stringr,opts,-1,0,4,list<character | logical>,1
+stringr,opts,0,0,0,character[],1
+stringr,opts,0,0,1,"class<`character`, `pattern`, `regex`>",1
+stringr,opts,0,0,2,"class<`character`, `fixed`, `pattern`>",1
+stringr,opts,0,0,3,"class<`character`, `coll`, `pattern`>",1
+stringr,opts,0,0,4,"class<`boundary`, `character`, `pattern`>",1
+stringr,regex,-1,0,0,"class<`character`, `pattern`, `regex`>",1
+stringr,regex,0,0,0,character,1
+stringr,regex,1,0,0,logical,1
+stringr,regex,2,0,0,logical,1
+stringr,regex,3,0,0,logical,1
+stringr,regex,4,0,0,logical,1
+stringr,regex,5,0,0,...,1
+stringr,str_c,-1,0,0,^character[],1
+stringr,str_c,0,0,0,...,1
+stringr,str_c,1,0,0,character,1
+stringr,str_c,2,0,0,character,1
+stringr,str_c,2,0,1,null,1
+stringr,str_conv,-1,0,0,character,1
+stringr,str_conv,0,0,0,character,1
+stringr,str_conv,1,0,0,character,1
+stringr,str_count,-1,0,0,integer[],1
+stringr,str_count,0,0,0,character[],1
+stringr,str_count,1,0,0,character[],1
+stringr,str_count,1,0,1,"class<`character`, `fixed`, `pattern`>",1
+stringr,str_count,1,0,2,"class<`boundary`, `character`, `pattern`>",1
+stringr,str_detect,-1,0,0,^logical[],1
+stringr,str_detect,0,0,0,^character[],1
+stringr,str_detect,1,0,0,"class<`character`, `coll`, `pattern`>",1
+stringr,str_detect,1,0,1,"class<`character`, `fixed`, `pattern`>",1
+stringr,str_detect,1,0,2,"class<`character`, `pattern`, `regex`>",1
+stringr,str_detect,1,0,3,character[],1
+stringr,str_detect,2,0,0,logical,1
+stringr,str_dup,-1,0,0,character[],1
+stringr,str_dup,0,0,0,character[],1
+stringr,str_dup,1,0,0,double[],1
+stringr,str_ends,-1,0,0,logical[],1
+stringr,str_ends,0,0,0,character[],1
+stringr,str_ends,1,0,0,character,1
+stringr,str_ends,2,0,0,logical,1
+stringr,str_extract,-1,0,0,^character[],1
+stringr,str_extract,0,0,0,^character[],1
+stringr,str_extract,1,0,0,character[],1
+stringr,str_extract_all,-1,0,0,class<`matrix`>,1
+stringr,str_extract_all,-1,0,1,list<character[]>,1
+stringr,str_extract_all,-1,0,2,list<character[] | null>,1
+stringr,str_extract_all,0,0,0,^character[],1
+stringr,str_extract_all,1,0,0,character,1
+stringr,str_extract_all,1,0,1,"class<`boundary`, `character`, `pattern`>",1
+stringr,str_extract_all,1,0,2,"class<`character`, `pattern`, `regex`>",1
+stringr,str_extract_all,2,0,0,logical,1
+stringr,str_flatten,-1,0,0,character,1
+stringr,str_flatten,0,0,0,character[],1
+stringr,str_flatten,1,0,0,character,1
+stringr,str_glue,-1,0,0,"class<`character`, `glue`>",1
+stringr,str_glue,0,0,0,...,1
+stringr,str_glue,1,0,0,character,1
+stringr,str_glue,2,0,0,environment,1
+stringr,str_glue_data,-1,0,0,"class<`character`, `glue`>",1
+stringr,str_glue_data,0,0,0,class<`data.frame`>,1
+stringr,str_glue_data,1,0,0,...,1
+stringr,str_glue_data,2,0,0,character,1
+stringr,str_glue_data,3,0,0,environment,1
+stringr,str_glue_data,4,0,0,character,1
+stringr,str_interp,-1,0,0,character,1
+stringr,str_interp,0,0,0,character[],1
+stringr,str_interp,1,0,0,environment,1
+stringr,str_interp,1,0,1,class<`data.frame`>,1
+stringr,str_interp,1,0,2,list<double>,1
+stringr,str_length,-1,0,0,^integer[],1
+stringr,str_length,-1,0,1,null,1
+stringr,str_length,0,0,0,^character[],1
+stringr,str_length,0,0,1,class<`factor`>,1
+stringr,str_length,0,0,2,null,1
+stringr,str_locate,-1,0,0,class<`matrix`>,1
+stringr,str_locate,0,0,0,character[],1
+stringr,str_locate,1,0,0,character[],1
+stringr,str_locate_all,-1,0,0,list<class<`matrix`>>,1
+stringr,str_locate_all,0,0,0,character[],1
+stringr,str_locate_all,1,0,0,character[],1
+stringr,str_locate_all,1,0,1,"class<`character`, `fixed`, `pattern`>",1
+stringr,str_match,-1,0,0,class<`matrix`>,1
+stringr,str_match,0,0,0,^character[],1
+stringr,str_match,1,0,0,character,1
+stringr,str_match,1,0,1,"class<`character`, `pattern`, `regex`>",1
+stringr,str_match_all,-1,0,0,list<class<`matrix`>>,1
+stringr,str_match_all,0,0,0,^character[],1
+stringr,str_match_all,1,0,0,character,1
+stringr,str_order,-1,0,0,integer[],1
+stringr,str_order,0,0,0,character[],1
+stringr,str_order,1,0,0,logical,1
+stringr,str_order,2,0,0,logical,1
+stringr,str_order,3,0,0,character,1
+stringr,str_order,4,0,0,logical,1
+stringr,str_order,5,0,0,...,1
+stringr,str_pad,-1,0,0,character[],1
+stringr,str_pad,0,0,0,character[],1
+stringr,str_pad,1,0,0,double[],1
+stringr,str_pad,2,0,0,character[],1
+stringr,str_pad,3,0,0,character[],1
+stringr,str_remove,-1,0,0,character[],1
+stringr,str_remove,0,0,0,character[],1
+stringr,str_remove,1,0,0,character,1
+stringr,str_remove_all,-1,0,0,character[],1
+stringr,str_remove_all,0,0,0,character[],1
+stringr,str_remove_all,1,0,0,character,1
+stringr,str_replace,-1,0,0,character[],1
+stringr,str_replace,0,0,0,character[],1
+stringr,str_replace,1,0,0,character[],1
+stringr,str_replace,2,0,0,character[],1
+stringr,str_replace_all,-1,0,0,^character[],1
+stringr,str_replace_all,0,0,0,character[],1
+stringr,str_replace_all,1,0,0,character[],1
+stringr,str_replace_all,2,0,0,any,1
+stringr,str_replace_na,-1,0,0,character[],1
+stringr,str_replace_na,0,0,0,^character[],1
+stringr,str_replace_na,1,0,0,character,1
+stringr,str_sort,-1,0,0,character[],1
+stringr,str_sort,0,0,0,character[],1
+stringr,str_sort,1,0,0,logical,1
+stringr,str_sort,2,0,0,logical,1
+stringr,str_sort,3,0,0,character,1
+stringr,str_sort,4,0,0,logical,1
+stringr,str_sort,5,0,0,...,1
+stringr,str_split,-1,0,0,class<`matrix`>,1
+stringr,str_split,-1,0,1,list<character[]>,1
+stringr,str_split,0,0,0,character[],1
+stringr,str_split,1,0,0,character,1
+stringr,str_split,1,0,1,"class<`boundary`, `character`, `pattern`>",1
+stringr,str_split,2,0,0,double,1
+stringr,str_split,3,0,0,logical,1
+stringr,str_split_fixed,-1,0,0,class<`matrix`>,1
+stringr,str_split_fixed,0,0,0,character[],1
+stringr,str_split_fixed,1,0,0,character,1
+stringr,str_split_fixed,2,0,0,double,1
+stringr,str_squish,-1,0,0,character,1
+stringr,str_squish,0,0,0,character,1
+stringr,str_starts,-1,0,0,logical[],1
+stringr,str_starts,0,0,0,character[],1
+stringr,str_starts,1,0,0,character,1
+stringr,str_starts,2,0,0,logical,1
+stringr,str_sub,-1,0,0,character[],1
+stringr,str_sub,0,0,0,character[],1
+stringr,str_sub,1,0,0,class<`matrix`>,1
+stringr,str_sub,1,0,1,double[],1
+stringr,str_sub,2,0,0,any,1
+stringr,str_sub<-,-1,0,0,character[],1
+stringr,str_sub<-,-1,0,1,null,1
+stringr,str_sub<-,0,0,0,character[],1
+stringr,str_sub<-,1,0,0,class<`matrix`>,1
+stringr,str_sub<-,1,0,1,double,1
+stringr,str_sub<-,2,0,0,any,1
+stringr,str_sub<-,3,0,0,logical,1
+stringr,str_sub<-,4,0,0,character[],1
+stringr,str_sub<-,4,0,1,null,1
+stringr,str_subset,-1,0,0,character[],1
+stringr,str_subset,0,0,0,^character[],1
+stringr,str_subset,1,0,0,character,1
+stringr,str_subset,1,0,1,"class<`character`, `coll`, `pattern`>",1
+stringr,str_subset,2,0,0,logical,1
+stringr,str_to_lower,-1,0,0,character,1
+stringr,str_to_lower,0,0,0,character,1
+stringr,str_to_lower,1,0,0,character,1
+stringr,str_to_sentence,-1,0,0,character,1
+stringr,str_to_sentence,0,0,0,character,1
+stringr,str_to_sentence,1,0,0,character,1
+stringr,str_to_title,-1,0,0,character,1
+stringr,str_to_title,0,0,0,character,1
+stringr,str_to_title,1,0,0,character,1
+stringr,str_to_upper,-1,0,0,character,1
+stringr,str_to_upper,0,0,0,character,1
+stringr,str_to_upper,1,0,0,character,1
+stringr,str_transform_all,-1,0,0,character[],1
+stringr,str_transform_all,0,0,0,character[],1
+stringr,str_transform_all,1,0,0,character,1
+stringr,str_transform_all,2,0,0,class<`function`>,1
+stringr,str_trim,-1,0,0,character[],1
+stringr,str_trim,0,0,0,character[],1
+stringr,str_trim,1,0,0,character[],1
+stringr,str_trunc,-1,0,0,character[],1
+stringr,str_trunc,0,0,0,character[],1
+stringr,str_trunc,1,0,0,double,1
+stringr,str_trunc,2,0,0,character[],1
+stringr,str_trunc,3,0,0,character,1
+stringr,str_view,-1,0,0,"class<`htmlwidget`, `str_view`>",1
+stringr,str_view,0,0,0,character[],1
+stringr,str_view,1,0,0,character,1
+stringr,str_view,2,0,0,logical,1
+stringr,str_view,2,0,1,null,1
+stringr,str_view_all,-1,0,0,"class<`htmlwidget`, `str_view`>",1
+stringr,str_view_all,0,0,0,character[],1
+stringr,str_view_all,1,0,0,character,1
+stringr,str_view_all,2,0,0,null,1
+stringr,str_view_widget,-1,0,0,"class<`htmlwidget`, `str_view`>",1
+stringr,str_view_widget,0,0,0,character[],1
+stringr,str_which,-1,0,0,integer[],1
+stringr,str_which,0,0,0,^character[],1
+stringr,str_which,1,0,0,character,1
+stringr,str_which,2,0,0,logical,1
+stringr,str_wrap,-1,0,0,character,1
+stringr,str_wrap,0,0,0,character,1
+stringr,str_wrap,1,0,0,double,1
+stringr,str_wrap,2,0,0,double,1
+stringr,str_wrap,3,0,0,double,1
+stringr,type,-1,0,0,character,1
+stringr,type,0,0,0,character[],1
+stringr,type,0,0,1,"class<`boundary`, `character`, `pattern`>",1
+stringr,type,0,0,2,"class<`character`, `coll`, `pattern`>",1
+stringr,type,0,0,3,"class<`character`, `fixed`, `pattern`>",1
+stringr,type,0,0,4,"class<`character`, `pattern`, `regex`>",1
+stringr,type.boundary,-1,0,0,character,1
+stringr,type.boundary,0,0,0,"class<`boundary`, `character`, `pattern`>",1
+stringr,type.character,-1,0,0,character,1
+stringr,type.character,0,0,0,character[],1
+stringr,type.coll,-1,0,0,character,1
+stringr,type.coll,0,0,0,"class<`character`, `coll`, `pattern`>",1
+stringr,type.fixed,-1,0,0,character,1
+stringr,type.fixed,0,0,0,"class<`character`, `fixed`, `pattern`>",1
+stringr,type.regex,-1,0,0,character,1
+stringr,type.regex,0,0,0,"class<`character`, `pattern`, `regex`>",1
+stringr,word,-1,0,0,character[],1
+stringr,word,0,0,0,character[],1
+stringr,word,1,0,0,double,1
+stringr,word,1,0,1,integer[],1
+stringr,word,2,0,0,double,1
+stringr,word,2,0,1,integer[],1
+stringr,word,3,0,0,"class<`character`, `fixed`, `pattern`>",1
+strucchange,AIC.breakpointsfull,-1,0,0,double[],1
+strucchange,AIC.breakpointsfull,0,0,0,"class<`breakpoints`, `breakpointsfull`>",1
+strucchange,AIC.breakpointsfull,1,0,0,null,1
+strucchange,AIC.breakpointsfull,2,0,0,...,1
+strucchange,AIC.breakpointsfull,3,0,0,double,1
+strucchange,boundary,-1,0,0,class<`ts`>,1
+strucchange,boundary,0,0,0,class<`efp`>,1
+strucchange,boundary,0,0,1,class<`Fstats`>,1
+strucchange,boundary,0,0,2,class<`mefp`>,1
+strucchange,boundary,1,0,0,...,1
+strucchange,boundary,-1,1,0,double[],1
+strucchange,boundary,0,1,0,double[],1
+strucchange,boundary.efp,-1,0,0,class<`ts`>,1
+strucchange,boundary.efp,0,0,0,class<`efp`>,1
+strucchange,boundary.efp,1,0,0,double,1
+strucchange,boundary.efp,2,0,0,logical,1
+strucchange,boundary.efp,3,0,0,character,1
+strucchange,boundary.efp,4,0,0,...,1
+strucchange,boundary.Fstats,-1,0,0,class<`ts`>,1
+strucchange,boundary.Fstats,0,0,0,class<`Fstats`>,1
+strucchange,boundary.Fstats,1,0,0,double,1
+strucchange,boundary.Fstats,2,0,0,logical,1
+strucchange,boundary.Fstats,3,0,0,logical,1
+strucchange,boundary.Fstats,4,0,0,any,1
+strucchange,boundary.Fstats,5,0,0,...,1
+strucchange,boundary.mefp,-1,0,0,class<`ts`>,1
+strucchange,boundary.mefp,0,0,0,class<`mefp`>,1
+strucchange,boundary.mefp,1,0,0,...,1
+strucchange,breakdates,-1,0,0,character[],1
+strucchange,breakdates,-1,0,1,class<`matrix`>,1
+strucchange,breakdates,-1,0,2,double[],1
+strucchange,breakdates,0,0,0,class<`breakpoints`>,1
+strucchange,breakdates,0,0,1,class<`confint.breakpoints`>,1
+strucchange,breakdates,0,0,2,"class<`breakpoints`, `breakpointsfull`>",1
+strucchange,breakdates,1,0,0,logical,1
+strucchange,breakdates,1,0,1,null,1
+strucchange,breakdates,2,0,0,...,1
+strucchange,breakdates.breakpoints,-1,0,0,character[],1
+strucchange,breakdates.breakpoints,-1,0,1,double[],1
+strucchange,breakdates.breakpoints,0,0,0,class<`breakpoints`>,1
+strucchange,breakdates.breakpoints,0,0,1,"class<`breakpoints`, `breakpointsfull`>",1
+strucchange,breakdates.breakpoints,1,0,0,logical,1
+strucchange,breakdates.breakpoints,1,0,1,null,1
+strucchange,breakdates.breakpoints,2,0,0,null,1
+strucchange,breakdates.breakpoints,3,0,0,...,1
+strucchange,breakdates.confint.breakpoints,-1,0,0,class<`matrix`>,1
+strucchange,breakdates.confint.breakpoints,0,0,0,class<`confint.breakpoints`>,1
+strucchange,breakdates.confint.breakpoints,1,0,0,logical,1
+strucchange,breakdates.confint.breakpoints,2,0,0,...,1
+strucchange,breakfactor,-1,0,0,class<`factor`>,1
+strucchange,breakfactor,0,0,0,class<`breakpoints`>,1
+strucchange,breakfactor,0,0,1,"class<`breakpoints`, `breakpointsfull`>",1
+strucchange,breakfactor,1,0,0,null,1
+strucchange,breakfactor,1,0,1,double,1
+strucchange,breakfactor,2,0,0,null,1
+strucchange,breakfactor,2,0,1,character,1
+strucchange,breakfactor,3,0,0,...,1
+strucchange,breakpoints,-1,0,0,class<`breakpoints`>,1
+strucchange,breakpoints,-1,0,1,"class<`breakpoints`, `breakpointsfull`>",1
+strucchange,breakpoints,0,0,0,"class<`breakpoints`, `breakpointsfull`>",1
+strucchange,breakpoints,0,0,1,class<`Fstats`>,1
+strucchange,breakpoints,0,0,2,class<`formula`>,1
+strucchange,breakpoints,1,0,0,...,1
+strucchange,breakpoints.breakpointsfull,-1,0,0,class<`breakpoints`>,1
+strucchange,breakpoints.breakpointsfull,0,0,0,"class<`breakpoints`, `breakpointsfull`>",1
+strucchange,breakpoints.breakpointsfull,1,0,0,double,1
+strucchange,breakpoints.breakpointsfull,1,0,1,null,1
+strucchange,breakpoints.breakpointsfull,2,0,0,...,1
+strucchange,breakpoints.formula,-1,0,0,"class<`breakpoints`, `breakpointsfull`>",1
+strucchange,breakpoints.formula,0,0,0,class<`formula`>,1
+strucchange,breakpoints.formula,1,0,0,double,1
+strucchange,breakpoints.formula,2,0,0,double,1
+strucchange,breakpoints.formula,2,0,1,null,1
+strucchange,breakpoints.formula,3,0,0,"class<`matrix`, `mts`, `ts`>",1
+strucchange,breakpoints.formula,3,0,1,class<`data.frame`>,1
+strucchange,breakpoints.formula,3,0,2,list<any>,1
+strucchange,breakpoints.formula,4,0,0,character[],1
+strucchange,breakpoints.formula,5,0,0,...,1
+strucchange,breakpoints.Fstats,-1,0,0,class<`breakpoints`>,1
+strucchange,breakpoints.Fstats,0,0,0,class<`Fstats`>,1
+strucchange,breakpoints.Fstats,1,0,0,...,1
+strucchange,catL2BB,-1,0,0,class<`efpFunctional`>,1
+strucchange,catL2BB,0,0,0,class<`gefp`>,1
+strucchange,coef.breakpointsfull,-1,0,0,class<`matrix`>,1
+strucchange,coef.breakpointsfull,0,0,0,"class<`breakpoints`, `breakpointsfull`>",1
+strucchange,coef.breakpointsfull,1,0,0,double,1
+strucchange,coef.breakpointsfull,2,0,0,null,1
+strucchange,coef.breakpointsfull,3,0,0,...,1
+strucchange,confint.breakpointsfull,-1,0,0,class<`confint.breakpoints`>,1
+strucchange,confint.breakpointsfull,0,0,0,"class<`breakpoints`, `breakpointsfull`>",1
+strucchange,confint.breakpointsfull,1,0,0,null,1
+strucchange,confint.breakpointsfull,2,0,0,double,1
+strucchange,confint.breakpointsfull,3,0,0,double,1
+strucchange,confint.breakpointsfull,3,0,1,null,1
+strucchange,confint.breakpointsfull,4,0,0,logical,1
+strucchange,confint.breakpointsfull,5,0,0,logical,1
+strucchange,confint.breakpointsfull,6,0,0,class<`function`>,1
+strucchange,confint.breakpointsfull,6,0,1,null,1
+strucchange,confint.breakpointsfull,7,0,0,logical,1
+strucchange,efp,-1,0,0,class<`efp`>,1
+strucchange,efp,0,0,0,class<`formula`>,1
+strucchange,efp,1,0,0,class<`data.frame`>,1
+strucchange,efp,1,0,1,"class<`matrix`, `mts`, `ts`>",1
+strucchange,efp,1,0,2,list<any>,1
+strucchange,efp,2,0,0,character[],1
+strucchange,efp,3,0,0,any,1
+strucchange,efp,4,0,0,logical,1
+strucchange,efp,5,0,0,logical,1
+strucchange,efp,6,0,0,logical,1
+strucchange,efp,7,0,0,null,1
+strucchange,efpFunctional,-1,0,0,class<`efpFunctional`>,1
+strucchange,efpFunctional,0,0,0,list<class<`function`>>,1
+strucchange,efpFunctional,1,0,0,class<`function`>,1
+strucchange,efpFunctional,2,0,0,class<`function`>,1
+strucchange,efpFunctional,3,0,0,class<`function`>,1
+strucchange,efpFunctional,4,0,0,class<`function`>,1
+strucchange,efpFunctional,4,0,1,null,1
+strucchange,efpFunctional,5,0,0,character,1
+strucchange,efpFunctional,6,0,0,double,1
+strucchange,efpFunctional,7,0,0,double,1
+strucchange,fitted.breakpointsfull,-1,0,0,class<`ts`>,1
+strucchange,fitted.breakpointsfull,0,0,0,"class<`breakpoints`, `breakpointsfull`>",1
+strucchange,fitted.breakpointsfull,1,0,0,double,1
+strucchange,fitted.breakpointsfull,2,0,0,...,1
+strucchange,Fstats,-1,0,0,class<`Fstats`>,1
+strucchange,Fstats,0,0,0,class<`formula`>,1
+strucchange,Fstats,1,0,0,double[],1
+strucchange,Fstats,2,0,0,double[],1
+strucchange,Fstats,2,0,1,null,1
+strucchange,Fstats,3,0,0,"class<`matrix`, `mts`, `ts`>",1
+strucchange,Fstats,3,0,1,list<any>,1
+strucchange,Fstats,3,0,2,class<`data.frame`>,1
+strucchange,Fstats,4,0,0,null,1
+strucchange,gefp,-1,0,0,class<`gefp`>,1
+strucchange,gefp,0,0,0,...,1
+strucchange,gefp,1,0,0,class<`function`>,1
+strucchange,gefp,1,0,1,null,1
+strucchange,gefp,2,0,0,class<`function`>,1
+strucchange,gefp,3,0,0,class<`function`>,1
+strucchange,gefp,3,0,1,null,1
+strucchange,gefp,4,0,0,logical,1
+strucchange,gefp,5,0,0,any,1
+strucchange,gefp,6,0,0,null,1
+strucchange,gefp,6,0,1,class<`formula`>,1
+strucchange,gefp,6,0,2,integer[],1
+strucchange,gefp,7,0,0,null,1
+strucchange,lines.breakpoints,-1,0,0,null,1
+strucchange,lines.breakpoints,0,0,0,class<`breakpoints`>,1
+strucchange,lines.breakpoints,0,0,1,"class<`breakpoints`, `breakpointsfull`>",1
+strucchange,lines.breakpoints,1,0,0,null,1
+strucchange,lines.breakpoints,1,0,1,double,1
+strucchange,lines.breakpoints,2,0,0,double,1
+strucchange,lines.breakpoints,3,0,0,...,1
+strucchange,lines.confint.breakpoints,-1,0,0,null,1
+strucchange,lines.confint.breakpoints,0,0,0,class<`confint.breakpoints`>,1
+strucchange,lines.confint.breakpoints,1,0,0,double,1
+strucchange,lines.confint.breakpoints,2,0,0,double,1
+strucchange,lines.confint.breakpoints,3,0,0,double,1
+strucchange,lines.confint.breakpoints,4,0,0,double,1
+strucchange,lines.confint.breakpoints,5,0,0,null,1
+strucchange,lines.confint.breakpoints,6,0,0,logical,1
+strucchange,lines.confint.breakpoints,7,0,0,...,1
+strucchange,lines.efp,-1,0,0,null,1
+strucchange,lines.efp,0,0,0,class<`efp`>,1
+strucchange,lines.efp,1,0,0,character,1
+strucchange,lines.efp,2,0,0,...,1
+strucchange,logLik.breakpoints,-1,0,0,class<`logLik`>,1
+strucchange,logLik.breakpoints,0,0,0,class<`breakpoints`>,1
+strucchange,logLik.breakpoints,1,0,0,...,1
+strucchange,maxMOSUM,-1,0,0,class<`efpFunctional`>,1
+strucchange,maxMOSUM,0,0,0,double,1
+strucchange,mefp,-1,0,0,class<`mefp`>,1
+strucchange,mefp,0,0,0,class<`efp`>,1
+strucchange,mefp,0,0,1,class<`formula`>,1
+strucchange,mefp,1,0,0,...,1
+strucchange,mefp.efp,-1,0,0,class<`mefp`>,1
+strucchange,mefp.efp,0,0,0,class<`efp`>,1
+strucchange,mefp.efp,1,0,0,double,1
+strucchange,mefp.efp,2,0,0,character[],1
+strucchange,mefp.efp,3,0,0,any,1
+strucchange,mefp.efp,4,0,0,any,1
+strucchange,mefp.efp,5,0,0,any,1
+strucchange,mefp.efp,6,0,0,null,1
+strucchange,mefp.efp,6,0,1,logical,1
+strucchange,mefp.efp,7,0,0,null,1
+strucchange,mefp.efp,7,0,1,class<`function`>,1
+strucchange,mefp.formula,-1,0,0,class<`mefp`>,1
+strucchange,mefp.formula,0,0,0,class<`formula`>,1
+strucchange,mefp.formula,1,0,0,character,1
+strucchange,mefp.formula,2,0,0,class<`data.frame`>,1
+strucchange,mefp.formula,2,0,1,"class<`matrix`, `mts`, `ts`>",1
+strucchange,mefp.formula,2,0,2,list<any>,1
+strucchange,mefp.formula,3,0,0,double,1
+strucchange,mefp.formula,4,0,0,double,1
+strucchange,mefp.formula,5,0,0,character[],1
+strucchange,mefp.formula,6,0,0,double,1
+strucchange,mefp.formula,7,0,0,any,1
+strucchange,monitor,-1,0,0,class<`mefp`>,1
+strucchange,monitor,0,0,0,class<`mefp`>,1
+strucchange,monitor,1,0,0,class<`data.frame`>,1
+strucchange,monitor,1,0,1,null,1
+strucchange,monitor,2,0,0,logical,1
+strucchange,ordL2BB,-1,0,0,class<`efpFunctional`>,1
+strucchange,ordL2BB,0,0,0,class<`gefp`>,1
+strucchange,ordL2BB,1,0,0,null,1
+strucchange,ordL2BB,2,0,0,double,1
+strucchange,ordL2BB,3,0,0,double[],1
+strucchange,ordL2BB,4,0,0,...,1
+strucchange,ordwmax,-1,0,0,class<`efpFunctional`>,1
+strucchange,ordwmax,0,0,0,class<`gefp`>,1
+strucchange,ordwmax,1,0,0,any,1
+strucchange,ordwmax,2,0,0,...,1
+strucchange,pargmaxV,-1,0,0,double,1
+strucchange,pargmaxV,0,0,0,double,1
+strucchange,pargmaxV,1,0,0,double,1
+strucchange,pargmaxV,2,0,0,double,1
+strucchange,pargmaxV,3,0,0,double,1
+strucchange,plot.breakpointsfull,-1,0,0,class<`summary.breakpointsfull`>,1
+strucchange,plot.breakpointsfull,0,0,0,"class<`breakpoints`, `breakpointsfull`>",1
+strucchange,plot.breakpointsfull,1,0,0,null,1
+strucchange,plot.breakpointsfull,2,0,0,...,1
+strucchange,plot.efp,-1,0,0,null,1
+strucchange,plot.efp,0,0,0,class<`efp`>,1
+strucchange,plot.efp,1,0,0,double,1
+strucchange,plot.efp,2,0,0,logical,1
+strucchange,plot.efp,3,0,0,logical,1
+strucchange,plot.efp,4,0,0,character,1
+strucchange,plot.efp,4,0,1,null,1
+strucchange,plot.efp,5,0,0,null,1
+strucchange,plot.efp,6,0,0,null,1
+strucchange,plot.efp,7,0,0,character,1
+strucchange,plot.Fstats,-1,0,0,null,1
+strucchange,plot.Fstats,0,0,0,class<`Fstats`>,1
+strucchange,plot.Fstats,1,0,0,logical,1
+strucchange,plot.Fstats,2,0,0,logical,1
+strucchange,plot.Fstats,3,0,0,double,1
+strucchange,plot.Fstats,4,0,0,logical,1
+strucchange,plot.Fstats,5,0,0,logical,1
+strucchange,plot.Fstats,6,0,0,character,1
+strucchange,plot.Fstats,7,0,0,null,1
+strucchange,plot.gefp,-1,0,0,class<`zoo`>,1
+strucchange,plot.gefp,-1,0,1,null,1
+strucchange,plot.gefp,0,0,0,class<`gefp`>,1
+strucchange,plot.gefp,1,0,0,double,1
+strucchange,plot.gefp,2,0,0,class<`efpFunctional`>,1
+strucchange,plot.gefp,3,0,0,...,1
+strucchange,plot.mefp,-1,0,0,null,1
+strucchange,plot.mefp,0,0,0,class<`mefp`>,1
+strucchange,plot.mefp,1,0,0,logical,1
+strucchange,plot.mefp,2,0,0,character,1
+strucchange,plot.mefp,2,0,1,null,1
+strucchange,plot.mefp,3,0,0,null,1
+strucchange,plot.mefp,4,0,0,character,1
+strucchange,plot.mefp,5,0,0,null,1
+strucchange,plot.mefp,6,0,0,...,1
+strucchange,plot.summary.breakpointsfull,-1,0,0,class<`summary.breakpointsfull`>,1
+strucchange,plot.summary.breakpointsfull,0,0,0,class<`summary.breakpointsfull`>,1
+strucchange,plot.summary.breakpointsfull,1,0,0,character,1
+strucchange,plot.summary.breakpointsfull,2,0,0,double[],1
+strucchange,plot.summary.breakpointsfull,3,0,0,logical,1
+strucchange,plot.summary.breakpointsfull,4,0,0,character,1
+strucchange,plot.summary.breakpointsfull,5,0,0,character,1
+strucchange,plot.summary.breakpointsfull,6,0,0,character,1
+strucchange,plot.summary.breakpointsfull,7,0,0,...,1
+strucchange,pvalue.efp,-1,0,0,double,1
+strucchange,pvalue.efp,0,0,0,double,1
+strucchange,pvalue.efp,1,0,0,character,1
+strucchange,pvalue.efp,2,0,0,any,1
+strucchange,pvalue.efp,3,0,0,character,1
+strucchange,pvalue.efp,4,0,0,any,1
+strucchange,pvalue.efp,5,0,0,any,1
+strucchange,pvalue.Fstats,-1,0,0,double,1
+strucchange,pvalue.Fstats,0,0,0,double,1
+strucchange,pvalue.Fstats,1,0,0,character,1
+strucchange,pvalue.Fstats,2,0,0,integer,1
+strucchange,pvalue.Fstats,3,0,0,double,1
+strucchange,recresid,-1,0,0,double[],1
+strucchange,recresid,0,0,0,class<`formula`>,1
+strucchange,recresid,0,0,1,class<`matrix`>,1
+strucchange,recresid,1,0,0,...,1
+strucchange,recresid.default,-1,0,0,double[],1
+strucchange,recresid.default,0,0,0,class<`matrix`>,1
+strucchange,recresid.default,1,0,0,double[],1
+strucchange,recresid.default,2,0,0,double,1
+strucchange,recresid.default,3,0,0,integer,1
+strucchange,recresid.default,4,0,0,any,1
+strucchange,recresid.default,5,0,0,double,1
+strucchange,recresid.default,6,0,0,character[],1
+strucchange,recresid.default,7,0,0,...,1
+strucchange,recresid.formula,-1,0,0,double[],1
+strucchange,recresid.formula,0,0,0,class<`formula`>,1
+strucchange,recresid.formula,1,0,0,list<any>,1
+strucchange,recresid.formula,2,0,0,...,1
+strucchange,residuals.breakpointsfull,-1,0,0,class<`ts`>,1
+strucchange,residuals.breakpointsfull,0,0,0,"class<`breakpoints`, `breakpointsfull`>",1
+strucchange,residuals.breakpointsfull,1,0,0,double,1
+strucchange,residuals.breakpointsfull,1,0,1,null,1
+strucchange,residuals.breakpointsfull,2,0,0,...,1
+strucchange,root.matrix,-1,0,0,class<`matrix`>,1
+strucchange,root.matrix,0,0,0,class<`matrix`>,1
+strucchange,sctest,-1,0,0,class<`htest`>,1
+strucchange,sctest,0,0,0,class<`efp`>,1
+strucchange,sctest,0,0,1,class<`formula`>,1
+strucchange,sctest,0,0,2,class<`Fstats`>,1
+strucchange,sctest,0,0,3,class<`gefp`>,1
+strucchange,sctest,0,0,4,"class<`glm`, `lm`>",1
+strucchange,sctest,1,0,0,...,1
+strucchange,sctest.default,-1,0,0,class<`htest`>,1
+strucchange,sctest.default,0,0,0,"class<`glm`, `lm`>",1
+strucchange,sctest.default,1,0,0,integer[],1
+strucchange,sctest.default,2,0,0,character,1
+strucchange,sctest.default,3,0,0,null,1
+strucchange,sctest.default,4,0,0,class<`function`>,1
+strucchange,sctest.default,5,0,0,logical,1
+strucchange,sctest.default,6,0,0,logical,1
+strucchange,sctest.default,7,0,0,null,1
+strucchange,sctest.efp,-1,0,0,class<`htest`>,1
+strucchange,sctest.efp,0,0,0,class<`efp`>,1
+strucchange,sctest.efp,1,0,0,logical,1
+strucchange,sctest.efp,2,0,0,character[],1
+strucchange,sctest.efp,3,0,0,...,1
+strucchange,sctest.formula,-1,0,0,class<`htest`>,1
+strucchange,sctest.formula,0,0,0,class<`formula`>,1
+strucchange,sctest.formula,1,0,0,character,1
+strucchange,sctest.formula,2,0,0,double,1
+strucchange,sctest.formula,3,0,0,logical,1
+strucchange,sctest.formula,4,0,0,character[],1
+strucchange,sctest.formula,5,0,0,double,1
+strucchange,sctest.formula,6,0,0,double,1
+strucchange,sctest.formula,6,0,1,null,1
+strucchange,sctest.formula,7,0,0,double,1
+strucchange,sctest.Fstats,-1,0,0,class<`htest`>,1
+strucchange,sctest.Fstats,0,0,0,class<`Fstats`>,1
+strucchange,sctest.Fstats,1,0,0,character[],1
+strucchange,sctest.Fstats,2,0,0,logical,1
+strucchange,sctest.Fstats,3,0,0,...,1
+strucchange,sctest.gefp,-1,0,0,class<`htest`>,1
+strucchange,sctest.gefp,0,0,0,class<`gefp`>,1
+strucchange,sctest.gefp,1,0,0,class<`efpFunctional`>,1
+strucchange,sctest.gefp,2,0,0,...,1
+strucchange,solveCrossprod,-1,0,0,class<`matrix`>,1
+strucchange,solveCrossprod,0,0,0,class<`matrix`>,1
+strucchange,solveCrossprod,1,0,0,character[],1
+strucchange,summary.breakpointsfull,-1,0,0,class<`summary.breakpointsfull`>,1
+strucchange,summary.breakpointsfull,0,0,0,"class<`breakpoints`, `breakpointsfull`>",1
+strucchange,summary.breakpointsfull,1,0,0,null,1
+strucchange,summary.breakpointsfull,2,0,0,logical,1
+strucchange,summary.breakpointsfull,3,0,0,null,1
+strucchange,summary.breakpointsfull,4,0,0,...,1
+strucchange,supLM,-1,0,0,class<`efpFunctional`>,1
+strucchange,supLM,0,0,0,double,1
+strucchange,supLM,1,0,0,null,1
+strucchange,time.gefp,-1,0,0,class<`Date`>,1
+strucchange,time.gefp,-1,0,1,double[],1
+strucchange,time.gefp,0,0,0,class<`gefp`>,1
+strucchange,time.gefp,1,0,0,...,1
+strucchange,vcov.breakpointsfull,-1,0,0,list<class<`matrix`>>,1
+strucchange,vcov.breakpointsfull,0,0,0,"class<`breakpoints`, `breakpointsfull`>",1
+strucchange,vcov.breakpointsfull,1,0,0,double,1
+strucchange,vcov.breakpointsfull,2,0,0,null,1
+strucchange,vcov.breakpointsfull,3,0,0,logical,1
+strucchange,vcov.breakpointsfull,4,0,0,logical,1
+strucchange,vcov.breakpointsfull,5,0,0,null,1
+strucchange,vcov.breakpointsfull,5,0,1,class<`function`>,1
+strucchange,vcov.breakpointsfull,6,0,0,logical,1
+strucchange,vcov.breakpointsfull,7,0,0,...,1
+subplex,subplex,-1,0,0,any,1
+subplex,subplex,0,0,0,any,1
+subplex,subplex,1,0,0,double,1
+subplex,subplex,1,0,1,class<`function`>,1
+subplex,subplex,1,0,2,character,1
+subplex,subplex,2,0,0,list<any>,1
+subplex,subplex,3,0,0,logical,1
+subplex,subplex,4,0,0,...,1
+survRM2,plot.rmst2,-1,0,0,null,1
+survRM2,plot.rmst2,0,0,0,class<`rmst2`>,1
+survRM2,plot.rmst2,1,0,0,character,1
+survRM2,plot.rmst2,2,0,0,character,1
+survRM2,plot.rmst2,3,0,0,character,1
+survRM2,plot.rmst2,4,0,0,character,1
+survRM2,plot.rmst2,5,0,0,character,1
+survRM2,plot.rmst2,6,0,0,double,1
+survRM2,plot.rmst2,7,0,0,double,1
+survRM2,print.rmst2,-1,0,0,class<`rmst2`>,1
+survRM2,print.rmst2,0,0,0,class<`rmst2`>,1
+survRM2,print.rmst2,1,0,0,double,1
+survRM2,print.rmst2,2,0,0,...,1
+survRM2,rmst1,-1,0,0,class<`rmst1`>,1
+survRM2,rmst1,0,0,0,double[],1
+survRM2,rmst1,1,0,0,double[],1
+survRM2,rmst1,2,0,0,double,1
+survRM2,rmst1,3,0,0,double,1
+survRM2,rmst2,-1,0,0,class<`rmst2`>,1
+survRM2,rmst2,0,0,0,double[],1
+survRM2,rmst2,1,0,0,double[],1
+survRM2,rmst2,2,0,0,double[],1
+survRM2,rmst2,3,0,0,double,1
+survRM2,rmst2,4,0,0,class<`data.frame`>,1
+survRM2,rmst2,4,0,1,null,1
+survRM2,rmst2,5,0,0,double,1
+survRM2,rmst2reg,-1,0,0,class<`matrix`>,1
+survRM2,rmst2reg,0,0,0,double[],1
+survRM2,rmst2reg,1,0,0,double[],1
+survRM2,rmst2reg,2,0,0,class<`matrix`>,1
+survRM2,rmst2reg,3,0,0,double[],1
+survRM2,rmst2reg,4,0,0,double,1
+survRM2,rmst2reg,5,0,0,character,1
+survRM2,rmst2reg,6,0,0,double,1
+survRM2,rmst2.sample.data,-1,0,0,class<`data.frame`>,1
+svglite,%||%,-1,0,0,integer[],1
+svglite,%||%,0,0,0,null,1
+svglite,%||%,1,0,0,integer[],1
+svglite,alias_lookup,-1,0,0,character[],1
+svglite,compact,-1,0,0,list<any>,1
+svglite,compact,-1,0,1,character,1
+svglite,compact,0,0,0,list<any>,1
+svglite,compact,0,0,1,character,1
+svglite,get_svg_content,-1,0,0,character,1
+svglite,get_svg_content,0,0,0,externalptr,1
+svglite,htmlSVG,-1,0,0,"class<`character`, `html`>",1
+svglite,htmlSVG,0,0,0,class<`histogram`>,1
+svglite,htmlSVG,0,0,1,null,1
+svglite,htmlSVG,1,0,0,...,1
+svglite,ilapply,-1,0,0,list<any>,1
+svglite,ilapply,0,0,0,list<any>,1
+svglite,ilapply,1,0,0,class<`function`>,1
+svglite,ilapply,2,0,0,...,1
+svglite,inlineSVG,-1,0,0,character,1
+svglite,inlineSVG,0,0,0,class<`histogram`>,1
+svglite,inlineSVG,0,0,1,null,1
+svglite,inlineSVG,1,0,0,...,1
+svglite,inlineSVG,2,0,0,null,1
+svglite,inlineSVG,2,0,1,double,1
+svglite,inlineSVG,3,0,0,null,1
+svglite,inlineSVG,3,0,1,double,1
+svglite,is_scalar_character,-1,0,0,logical,1
+svglite,is_scalar_character,0,0,0,character,1
+svglite,plot_dim,-1,0,0,double[],1
+svglite,plot_dim,0,0,0,double[],1
+svglite,plot_dim,0,0,1,^logical[],1
+svglite,stringSVG,-1,0,0,class<`svg`>,1
+svglite,stringSVG,0,0,0,null,1
+svglite,stringSVG,1,0,0,...,1
+svglite,svglite,-1,0,0,logical,1
+svglite,svglite,0,0,0,character,1
+svglite,svglite,1,0,0,double,1
+svglite,svglite,2,0,0,double,1
+svglite,svglite,3,0,0,character,1
+svglite,svglite,4,0,0,double,1
+svglite,svglite,5,0,0,logical,1
+svglite,svglite,6,0,0,list<any>,1
+svglite,svglite,7,0,0,list<any>,1
+svglite,svglite_,-1,0,0,logical,1
+svglite,svglite_,0,0,0,character,1
+svglite,svglite_,1,0,0,character,1
+svglite,svglite_,2,0,0,double,1
+svglite,svglite_,3,0,0,double,1
+svglite,svglite_,4,0,0,double,1
+svglite,svglite_,5,0,0,logical,1
+svglite,svglite_,6,0,0,list<list<any>>,1
+svglite,svgstring,-1,0,0,class<`function`>,1
+svglite,svgstring,0,0,0,double,1
+svglite,svgstring,1,0,0,double,1
+svglite,svgstring,2,0,0,character,1
+svglite,svgstring,3,0,0,double,1
+svglite,svgstring,4,0,0,logical,1
+svglite,svgstring,5,0,0,list<any>,1
+svglite,svgstring,6,0,0,list<any>,1
+svglite,svgstring_,-1,0,0,externalptr,1
+svglite,svgstring_,0,0,0,environment,1
+svglite,svgstring_,1,0,0,character,1
+svglite,svgstring_,2,0,0,double,1
+svglite,svgstring_,3,0,0,double,1
+svglite,svgstring_,4,0,0,double,1
+svglite,svgstring_,5,0,0,logical,1
+svglite,svgstring_,6,0,0,list<list<any>>,1
+svglite,validate_aliases,-1,0,0,list<list<any>>,1
+svglite,validate_aliases,0,0,0,list<any>,1
+svglite,validate_aliases,1,0,0,list<any>,1
+svglite,xmlSVG,-1,0,0,"class<`xml_document`, `xml_node`>",1
+svglite,xmlSVG,0,0,0,null,1
+svglite,xmlSVG,1,0,0,...,1
+svglite,xmlSVG,2,0,0,logical,1
+svglite,xmlSVG,3,0,0,double,1
+svglite,xmlSVG,4,0,0,double,1
+sys,as_text,-1,0,0,character,1
+sys,as_text,0,0,0,raw[],1
+sys,as_text,1,0,0,...,1
+sys,exec_background,-1,0,0,integer,1
+sys,exec_background,0,0,0,character,1
+sys,exec_background,1,0,0,character,1
+sys,exec_background,2,0,0,logical,1
+sys,exec_background,3,0,0,logical,1
+sys,exec_background,4,0,0,null,1
+sys,exec_internal,-1,0,0,list<integer | raw[]>,1
+sys,exec_internal,0,0,0,character,1
+sys,exec_internal,1,0,0,null,1
+sys,exec_internal,2,0,0,null,1
+sys,exec_internal,3,0,0,logical,1
+sys,exec_internal,4,0,0,double,1
+sys,exec_status,-1,0,0,integer,1
+sys,exec_status,0,0,0,integer,1
+sys,exec_status,1,0,0,logical,1
+sys,execute,-1,0,0,integer,1
+sys,execute,0,0,0,character,1
+sys,execute,1,0,0,character[],1
+sys,execute,1,0,1,null,1
+sys,execute,2,0,0,class<`function`>,1
+sys,execute,2,0,1,logical,1
+sys,execute,3,0,0,class<`function`>,1
+sys,execute,3,0,1,logical,1
+sys,execute,4,0,0,null,1
+sys,execute,4,0,1,character,1
+sys,execute,5,0,0,logical,1
+sys,execute,6,0,0,double,1
+sys,exec_wait,-1,0,0,integer,1
+sys,exec_wait,0,0,0,character,1
+sys,exec_wait,1,0,0,character[],1
+sys,exec_wait,1,0,1,null,1
+sys,exec_wait,2,0,0,"class<`connection`, `terminal`>",1
+sys,exec_wait,2,0,1,"class<`connection`, `rawConnection`>",1
+sys,exec_wait,3,0,0,"class<`connection`, `terminal`>",1
+sys,exec_wait,3,0,1,"class<`connection`, `rawConnection`>",1
+sys,exec_wait,4,0,0,null,1
+sys,exec_wait,4,0,1,character,1
+sys,exec_wait,5,0,0,double,1
+sys,rbin,-1,0,0,character,1
+sys,r_wait,-1,0,0,integer,1
+sys,r_wait,0,0,0,character[],1
+sys,r_wait,1,0,0,"class<`connection`, `terminal`>",1
+sys,r_wait,2,0,0,"class<`connection`, `terminal`>",1
+sys,r_wait,3,0,0,null,1
+sys,r_wait,3,0,1,character,1
+tensor,tensor,-1,0,0,class<`array`>,1
+tensor,tensor,-1,0,1,class<`matrix`>,1
+tensor,tensor,-1,0,2,double,1
+tensor,tensor,0,0,0,class<`array`>,1
+tensor,tensor,0,0,1,class<`matrix`>,1
+tensor,tensor,1,0,0,class<`matrix`>,1
+tensor,tensor,2,0,0,double[],1
+tensor,tensor,3,0,0,double[],1
+testit,%==%,-1,0,0,logical,1
+testit,%==%,0,0,0,double,1
+testit,%==%,0,0,1,integer[],1
+testit,%==%,0,0,2,null,1
+testit,%==%,1,0,0,double,1
+testit,%==%,1,0,1,integer[],1
+testit,%==%,1,0,2,null,1
+testit,all_true,-1,0,0,logical,1
+testit,all_true,0,0,0,character,1
+testit,all_true,0,0,1,logical[],1
+testit,assert,-1,0,0,list<null | class<`function`> | list<null>>,1
+testit,assert,-1,0,1,null,1
+testit,assert,0,0,0,any,1
+testit,assert,1,0,0,...,1
+testit,assert2,-1,0,0,any,1
+testit,assert2,0,0,0,character,1
+testit,assert2,0,0,1,null,1
+testit,assert2,1,0,0,class<`call`>,1
+testit,assert2,2,0,0,environment,1
+testit,assert2,3,0,0,logical,1
+testit,available_dir,-1,0,0,any,1
+testit,available_dir,0,0,0,character[],1
+testit,deparse_key,-1,0,0,character,1
+testit,deparse_key,0,0,0,character,1
+testit,deparse_key,0,0,1,class<`call`>,1
+testit,deparse_key,0,0,2,class<`if`>,1
+testit,deparse_key,0,0,3,double,1
+testit,has_error,-1,0,0,logical,1
+testit,has_error,0,0,0,any,1
+testit,has_error,1,0,0,any,1
+testit,has_warning,-1,0,0,logical,1
+testit,has_warning,0,0,0,character,1
+testit,has_warning,0,0,1,double,1
+testit,has_warning,0,0,2,integer[],1
+testit,insert_identical,-1,0,0,any,1
+testit,one_expression,-1,0,0,logical,1
+testit,one_expression,0,0,0,class<`call`>,1
+testit,sys.source2,-1,0,0,null,1
+testit,sys.source2,0,0,0,character,1
+testit,sys.source2,1,0,0,environment,1
+testit,sys.source2,2,0,0,environment,1
+testit,test_pkg,-1,0,0,null,1
+testit,test_pkg,0,0,0,character,1
+testit,test_pkg,1,0,0,character[],1
+tframe,as.tframe,-1,0,0,"class<`tframe`, `tstframe`>",1
+tframe,as.tframe,0,0,0,...,1
+tframe,checktframeConsistent,-1,0,0,logical,1
+tframe,checktframeConsistent,0,0,0,"class<`tframe`, `tstframe`>",1
+tframe,checktframeConsistent,1,0,0,double[],1
+tframe,checktframeConsistent.default,-1,0,0,logical,1
+tframe,checktframeConsistent.default,0,0,0,"class<`tframe`, `tstframe`>",1
+tframe,checktframeConsistent.default,1,0,0,double[],1
+tframe,classed,-1,0,0,"class<`tframe`, `tstframe`>",1
+tframe,classed,0,0,0,double[],1
+tframe,classed,1,0,0,character[],1
+tframe,earliestEnd,-1,0,0,double[],1
+tframe,earliestEnd,0,0,0,"class<`matrix`, `mts`, `ts`>",1
+tframe,earliestEnd,0,0,1,class<`ts`>,1
+tframe,earliestEnd,1,0,0,...,1
+tframe,earliestEndIndex,-1,0,0,double,1
+tframe,earliestEndIndex,0,0,0,"class<`tframe`, `tstframe`>",1
+tframe,earliestEndIndex,0,0,1,class<`ts`>,1
+tframe,earliestEndIndex,0,0,2,"class<`matrix`, `mts`, `ts`>",1
+tframe,earliestEndIndex,1,0,0,...,1
+tframe,earliestEndIndex.default,-1,0,0,double,1
+tframe,earliestEndIndex.default,0,0,0,class<`ts`>,1
+tframe,earliestEndIndex.default,0,0,1,"class<`matrix`, `mts`, `ts`>",1
+tframe,earliestEndIndex.default,1,0,0,...,1
+tframe,earliestEndIndex.tframe,-1,0,0,double,1
+tframe,earliestEndIndex.tframe,0,0,0,"class<`tframe`, `tstframe`>",1
+tframe,earliestEndIndex.tframe,1,0,0,...,1
+tframe,earliestStart,-1,0,0,double[],1
+tframe,earliestStart,0,0,0,"class<`matrix`, `mts`, `ts`>",1
+tframe,earliestStart,0,0,1,class<`ts`>,1
+tframe,earliestStart,1,0,0,...,1
+tframe,earliestStartIndex,-1,0,0,double,1
+tframe,earliestStartIndex,0,0,0,"class<`matrix`, `mts`, `ts`>",1
+tframe,earliestStartIndex,0,0,1,"class<`tframe`, `tstframe`>",1
+tframe,earliestStartIndex,0,0,2,class<`ts`>,1
+tframe,earliestStartIndex,1,0,0,...,1
+tframe,earliestStartIndex.default,-1,0,0,double,1
+tframe,earliestStartIndex.default,0,0,0,"class<`matrix`, `mts`, `ts`>",1
+tframe,earliestStartIndex.default,0,0,1,class<`ts`>,1
+tframe,earliestStartIndex.default,1,0,0,...,1
+tframe,earliestStartIndex.tframe,-1,0,0,double,1
+tframe,earliestStartIndex.tframe,0,0,0,"class<`tframe`, `tstframe`>",1
+tframe,earliestStartIndex.tframe,1,0,0,...,1
+tframe,end.tframe,-1,0,0,double[],1
+tframe,end.tframe,0,0,0,"class<`tframe`, `tstframe`>",1
+tframe,end.tframe,1,0,0,...,1
+tframe,is.tframe,-1,0,0,logical,1
+tframe,is.tframe,0,0,0,class<`matrix`>,1
+tframe,is.tframe,0,0,1,"class<`matrix`, `mts`, `ts`>",1
+tframe,is.tframe,0,0,2,"class<`tframe`, `tstframe`>",1
+tframe,is.tframe,0,0,3,class<`ts`>,1
+tframe,is.tframe,0,0,4,double[],1
+tframe,is.tframe,0,0,5,list<double[]>,1
+tframe,is.tframed,-1,0,0,logical,1
+tframe,is.tframed,0,0,0,class<`matrix`>,1
+tframe,is.tframed,0,0,1,"class<`matrix`, `mts`, `ts`>",1
+tframe,is.tframed.default,-1,0,0,logical,1
+tframe,is.tframed.default,0,0,0,class<`matrix`>,1
+tframe,is.tframed.ts,-1,0,0,logical,1
+tframe,is.tframed.ts,0,0,0,"class<`matrix`, `mts`, `ts`>",1
+tframe,latestEnd,-1,0,0,double[],1
+tframe,latestEnd,0,0,0,"class<`matrix`, `mts`, `ts`>",1
+tframe,latestEnd,0,0,1,class<`ts`>,1
+tframe,latestEnd,1,0,0,...,1
+tframe,latestEndIndex,-1,0,0,double,1
+tframe,latestEndIndex,0,0,0,"class<`matrix`, `mts`, `ts`>",1
+tframe,latestEndIndex,0,0,1,"class<`tframe`, `tstframe`>",1
+tframe,latestEndIndex,0,0,2,class<`ts`>,1
+tframe,latestEndIndex,1,0,0,...,1
+tframe,latestEndIndex.default,-1,0,0,double,1
+tframe,latestEndIndex.default,0,0,0,"class<`matrix`, `mts`, `ts`>",1
+tframe,latestEndIndex.default,0,0,1,class<`ts`>,1
+tframe,latestEndIndex.default,1,0,0,...,1
+tframe,latestEndIndex.tframe,-1,0,0,double,1
+tframe,latestEndIndex.tframe,0,0,0,"class<`tframe`, `tstframe`>",1
+tframe,latestEndIndex.tframe,1,0,0,...,1
+tframe,latestStart,-1,0,0,double[],1
+tframe,latestStart,0,0,0,"class<`matrix`, `mts`, `ts`>",1
+tframe,latestStart,0,0,1,class<`ts`>,1
+tframe,latestStart,1,0,0,...,1
+tframe,latestStartIndex,-1,0,0,double,1
+tframe,latestStartIndex,0,0,0,"class<`matrix`, `mts`, `ts`>",1
+tframe,latestStartIndex,0,0,1,"class<`tframe`, `tstframe`>",1
+tframe,latestStartIndex,0,0,2,class<`ts`>,1
+tframe,latestStartIndex,1,0,0,...,1
+tframe,latestStartIndex.default,-1,0,0,double,1
+tframe,latestStartIndex.default,0,0,0,"class<`matrix`, `mts`, `ts`>",1
+tframe,latestStartIndex.default,0,0,1,class<`ts`>,1
+tframe,latestStartIndex.default,1,0,0,...,1
+tframe,latestStartIndex.tframe,-1,0,0,double,1
+tframe,latestStartIndex.tframe,0,0,0,"class<`tframe`, `tstframe`>",1
+tframe,latestStartIndex.tframe,1,0,0,...,1
+tframe,nseries,-1,0,0,integer,1
+tframe,nseries,0,0,0,class<`matrix`>,1
+tframe,nseries,0,0,1,"class<`matrix`, `mts`, `ts`>",1
+tframe,nseries,0,0,2,class<`ts`>,1
+tframe,nseries.default,-1,0,0,integer,1
+tframe,nseries.default,0,0,0,class<`matrix`>,1
+tframe,nseries.default,0,0,1,"class<`matrix`, `mts`, `ts`>",1
+tframe,nseries.default,0,0,2,class<`ts`>,1
+tframe,selectSeries,-1,0,0,class<`matrix`>,1
+tframe,selectSeries,0,0,0,class<`matrix`>,1
+tframe,selectSeries,1,0,0,double[],1
+tframe,selectSeries.default,-1,0,0,class<`matrix`>,1
+tframe,selectSeries.default,0,0,0,class<`matrix`>,1
+tframe,selectSeries.default,1,0,0,double[],1
+tframe,seriesNames,-1,0,0,character[],1
+tframe,seriesNames,0,0,0,class<`matrix`>,1
+tframe,seriesNames,0,0,1,"class<`matrix`, `mts`, `ts`>",1
+tframe,seriesNames,0,0,2,class<`ts`>,1
+tframe,seriesNames,0,0,3,double[],1
+tframe,seriesNames<-,-1,0,0,class<`matrix`>,1
+tframe,seriesNames<-,-1,0,1,"class<`matrix`, `mts`, `ts`>",1
+tframe,seriesNames<-,-1,0,2,class<`ts`>,1
+tframe,seriesNames<-,0,0,0,class<`matrix`>,1
+tframe,seriesNames<-,0,0,1,"class<`matrix`, `mts`, `ts`>",1
+tframe,seriesNames<-,0,0,2,class<`ts`>,1
+tframe,seriesNames<-,1,0,0,character[],1
+tframe,seriesNames<-,1,0,1,null,1
+tframe,seriesNames<-.default,-1,0,0,class<`matrix`>,1
+tframe,seriesNames<-.default,0,0,0,class<`matrix`>,1
+tframe,seriesNames<-.default,1,0,0,character[],1
+tframe,seriesNames<-.default,1,0,1,null,1
+tframe,seriesNames.default,-1,0,0,character[],1
+tframe,seriesNames.default,0,0,0,class<`matrix`>,1
+tframe,seriesNames.default,0,0,1,"class<`matrix`, `mts`, `ts`>",1
+tframe,seriesNames.default,0,0,2,class<`ts`>,1
+tframe,seriesNames.default,0,0,3,double[],1
+tframe,seriesNames<-.ts,-1,0,0,"class<`matrix`, `mts`, `ts`>",1
+tframe,seriesNames<-.ts,-1,0,1,class<`ts`>,1
+tframe,seriesNames<-.ts,0,0,0,"class<`matrix`, `mts`, `ts`>",1
+tframe,seriesNames<-.ts,0,0,1,class<`ts`>,1
+tframe,seriesNames<-.ts,1,0,0,character[],1
+tframe,splice,-1,0,0,"class<`matrix`, `mts`, `ts`>",1
+tframe,splice,-1,0,1,class<`ts`>,1
+tframe,splice,0,0,0,"class<`matrix`, `mts`, `ts`>",1
+tframe,splice,0,0,1,class<`ts`>,1
+tframe,splice,1,0,0,"class<`matrix`, `mts`, `ts`>",1
+tframe,splice,1,0,1,class<`ts`>,1
+tframe,splice,2,0,0,...,1
+tframe,splice.default,-1,0,0,"class<`matrix`, `mts`, `ts`>",1
+tframe,splice.default,-1,0,1,class<`ts`>,1
+tframe,splice.default,0,0,0,"class<`matrix`, `mts`, `ts`>",1
+tframe,splice.default,0,0,1,class<`ts`>,1
+tframe,splice.default,1,0,0,"class<`matrix`, `mts`, `ts`>",1
+tframe,splice.default,1,0,1,class<`ts`>,1
+tframe,splice.default,2,0,0,...,1
+tframe,tbind,-1,0,0,"class<`matrix`, `mts`, `ts`>",1
+tframe,tbind,-1,0,1,class<`ts`>,1
+tframe,tbind,0,0,0,class<`ts`>,1
+tframe,tbind,0,0,1,double[],1
+tframe,tbind,1,0,0,...,1
+tframe,tbind,2,0,0,logical,1
+tframe,tbind,3,0,0,logical,1
+tframe,tbind,4,0,0,logical,1
+tframe,tbind.default,-1,0,0,"class<`matrix`, `mts`, `ts`>",1
+tframe,tbind.default,-1,0,1,class<`ts`>,1
+tframe,tbind.default,0,0,0,double[],1
+tframe,tbind.default,1,0,0,...,1
+tframe,tbind.default,2,0,0,logical,1
+tframe,tbind.default,3,0,0,logical,1
+tframe,tbind.default,4,0,0,logical,1
+tframe,tbind.ts,-1,0,0,"class<`matrix`, `mts`, `ts`>",1
+tframe,tbind.ts,0,0,0,class<`ts`>,1
+tframe,tbind.ts,1,0,0,...,1
+tframe,tbind.ts,2,0,0,logical,1
+tframe,tbind.ts,3,0,0,logical,1
+tframe,tbind.ts,4,0,0,logical,1
+tframe,testEqual,-1,0,0,logical,1
+tframe,testEqual,0,0,0,class<`matrix`>,1
+tframe,testEqual,0,0,1,"class<`matrix`, `mts`, `ts`>",1
+tframe,testEqual,0,0,2,"class<`tframe`, `tstframe`>",1
+tframe,testEqual,1,0,0,class<`matrix`>,1
+tframe,testEqual,1,0,1,integer[],1
+tframe,testEqual,1,0,2,"class<`matrix`, `mts`, `ts`>",1
+tframe,testEqual,1,0,3,"class<`tframe`, `tstframe`>",1
+tframe,testEqual,2,0,0,double,1
+tframe,testEqual.default,-1,0,0,logical,1
+tframe,testEqual.default,0,0,0,"class<`tframe`, `tstframe`>",1
+tframe,testEqual.default,1,0,0,"class<`tframe`, `tstframe`>",1
+tframe,testEqual.default,2,0,0,double,1
+tframe,testEqual.matrix,-1,0,0,logical,1
+tframe,testEqual.matrix,0,0,0,class<`matrix`>,1
+tframe,testEqual.matrix,0,0,1,"class<`matrix`, `mts`, `ts`>",1
+tframe,testEqual.matrix,1,0,0,class<`matrix`>,1
+tframe,testEqual.matrix,1,0,1,integer[],1
+tframe,testEqual.matrix,1,0,2,"class<`matrix`, `mts`, `ts`>",1
+tframe,testEqual.matrix,2,0,0,double,1
+tframe,testEqual.numeric,-1,0,0,logical,1
+tframe,testEqual.numeric,0,0,0,class<`matrix`>,1
+tframe,testEqual.numeric,0,0,1,"class<`matrix`, `mts`, `ts`>",1
+tframe,testEqual.numeric,0,0,2,"class<`tframe`, `tstframe`>",1
+tframe,testEqual.numeric,1,0,0,class<`matrix`>,1
+tframe,testEqual.numeric,1,0,1,"class<`matrix`, `mts`, `ts`>",1
+tframe,testEqual.numeric,1,0,2,"class<`tframe`, `tstframe`>",1
+tframe,testEqual.numeric,2,0,0,double,1
+tframe,testEqualtframes,-1,0,0,logical,1
+tframe,testEqualtframes,0,0,0,null,1
+tframe,testEqualtframes,1,0,0,null,1
+tframe,testEqualtframes.default,-1,0,0,logical,1
+tframe,testEqualtframes.default,0,0,0,null,1
+tframe,testEqualtframes.default,1,0,0,null,1
+tframe,tfend,-1,0,0,double[],1
+tframe,tfend,-1,0,1,null,1
+tframe,tfend,0,0,0,"class<`matrix`, `mts`, `ts`>",1
+tframe,tfend,0,0,1,"class<`tframe`, `tstframe`>",1
+tframe,tfend,0,0,2,class<`ts`>,1
+tframe,tfend,0,0,3,double[],1
+tframe,tfend,0,0,4,null,1
+tframe,tfend.default,-1,0,0,double[],1
+tframe,tfend.default,-1,0,1,null,1
+tframe,tfend.default,0,0,0,"class<`matrix`, `mts`, `ts`>",1
+tframe,tfend.default,0,0,1,class<`ts`>,1
+tframe,tfend.default,0,0,2,double[],1
+tframe,tfend.default,0,0,3,null,1
+tframe,tfend.tstframe,-1,0,0,double[],1
+tframe,tfend.tstframe,0,0,0,"class<`tframe`, `tstframe`>",1
+tframe,tfExpand,-1,0,0,"class<`tframe`, `tstframe`>",1
+tframe,tfExpand,0,0,0,"class<`tframe`, `tstframe`>",1
+tframe,tfExpand,1,0,0,double,1
+tframe,tfExpand,2,0,0,double,1
+tframe,tfExpand.tframe,-1,0,0,"class<`tframe`, `tstframe`>",1
+tframe,tfExpand.tframe,0,0,0,"class<`tframe`, `tstframe`>",1
+tframe,tfExpand.tframe,1,0,0,double,1
+tframe,tfExpand.tframe,2,0,0,double,1
+tframe,tffrequency,-1,0,0,double,1
+tframe,tffrequency,0,0,0,"class<`matrix`, `mts`, `ts`>",1
+tframe,tffrequency,0,0,1,"class<`tframe`, `tstframe`>",1
+tframe,tffrequency,0,0,2,class<`ts`>,1
+tframe,tffrequency,0,0,3,double[],1
+tframe,tffrequency.default,-1,0,0,double,1
+tframe,tffrequency.default,0,0,0,"class<`matrix`, `mts`, `ts`>",1
+tframe,tffrequency.default,0,0,1,"class<`tframe`, `tstframe`>",1
+tframe,tffrequency.default,0,0,2,class<`ts`>,1
+tframe,tffrequency.default,0,0,3,double[],1
+tframe,tfL,-1,0,0,"class<`matrix`, `mts`, `ts`>",1
+tframe,tfL,-1,0,1,"class<`tframe`, `tstframe`>",1
+tframe,tfL,-1,0,2,class<`ts`>,1
+tframe,tfL,0,0,0,"class<`matrix`, `mts`, `ts`>",1
+tframe,tfL,0,0,1,"class<`tframe`, `tstframe`>",1
+tframe,tfL,0,0,2,class<`ts`>,1
+tframe,tfL,0,0,3,integer[],1
+tframe,tfL,1,0,0,double,1
+tframe,tfL.default,-1,0,0,"class<`matrix`, `mts`, `ts`>",1
+tframe,tfL.default,-1,0,1,class<`ts`>,1
+tframe,tfL.default,0,0,0,"class<`matrix`, `mts`, `ts`>",1
+tframe,tfL.default,0,0,1,class<`ts`>,1
+tframe,tfL.default,0,0,2,integer[],1
+tframe,tfL.default,1,0,0,double,1
+tframe,tfL.tframe,-1,0,0,"class<`tframe`, `tstframe`>",1
+tframe,tfL.tframe,0,0,0,"class<`tframe`, `tstframe`>",1
+tframe,tfL.tframe,1,0,0,double,1
+tframe,tfprint,-1,0,0,class<`ts`>,1
+tframe,tfprint,0,0,0,class<`ts`>,1
+tframe,tfprint,1,0,0,...,1
+tframe,tfprint.default,-1,0,0,class<`ts`>,1
+tframe,tfprint.default,0,0,0,class<`ts`>,1
+tframe,tfprint.default,1,0,0,...,1
+tframe,tframe,-1,0,0,"class<`tframe`, `tstframe`>",1
+tframe,tframe,-1,0,1,null,1
+tframe,tframe,0,0,0,"class<`matrix`, `mts`, `ts`>",1
+tframe,tframe,0,0,1,class<`ts`>,1
+tframe,tframe,0,0,2,class<`matrix`>,1
+tframe,tframe<-,-1,0,0,class<`matrix`>,1
+tframe,tframe<-,-1,0,1,"class<`matrix`, `mts`, `ts`>",1
+tframe,tframe<-,-1,0,2,class<`ts`>,1
+tframe,tframe<-,0,0,0,class<`matrix`>,1
+tframe,tframe<-,0,0,1,"class<`matrix`, `mts`, `ts`>",1
+tframe,tframe<-,0,0,2,class<`ts`>,1
+tframe,tframe<-,0,0,3,double[],1
+tframe,tframe<-,1,0,0,null,1
+tframe,tframe<-,1,0,1,"class<`matrix`, `mts`, `ts`>",1
+tframe,tframe<-,1,0,2,"class<`tframe`, `tstframe`>",1
+tframe,tframe<-,1,0,3,list<double[]>,1
+tframe,tframed,-1,0,0,class<`matrix`>,1
+tframe,tframed,-1,0,1,"class<`matrix`, `mts`, `ts`>",1
+tframe,tframed,-1,0,2,class<`ts`>,1
+tframe,tframed,0,0,0,class<`matrix`>,1
+tframe,tframed,0,0,1,"class<`matrix`, `mts`, `ts`>",1
+tframe,tframed,0,0,2,class<`ts`>,1
+tframe,tframed,0,0,3,double[],1
+tframe,tframed,1,0,0,null,1
+tframe,tframed,1,0,1,"class<`matrix`, `mts`, `ts`>",1
+tframe,tframed,1,0,2,"class<`tframe`, `tstframe`>",1
+tframe,tframed,1,0,3,list<double[]>,1
+tframe,tframed,2,0,0,null,1
+tframe,tframed,3,0,0,...,1
+tframe,tframed.default,-1,0,0,class<`matrix`>,1
+tframe,tframed.default,-1,0,1,"class<`matrix`, `mts`, `ts`>",1
+tframe,tframed.default,-1,0,2,class<`ts`>,1
+tframe,tframed.default,0,0,0,class<`matrix`>,1
+tframe,tframed.default,0,0,1,"class<`matrix`, `mts`, `ts`>",1
+tframe,tframed.default,0,0,2,class<`ts`>,1
+tframe,tframed.default,0,0,3,double[],1
+tframe,tframed.default,1,0,0,null,1
+tframe,tframed.default,1,0,1,"class<`matrix`, `mts`, `ts`>",1
+tframe,tframed.default,1,0,2,"class<`tframe`, `tstframe`>",1
+tframe,tframed.default,1,0,3,list<double[]>,1
+tframe,tframed.default,2,0,0,null,1
+tframe,tframed.default,3,0,0,null,1
+tframe,tframed.default,3,0,1,double[],1
+tframe,tframed.default,4,0,0,null,1
+tframe,tframed.default,5,0,0,...,1
+tframe,tframe.default,-1,0,0,null,1
+tframe,tframe.default,0,0,0,class<`matrix`>,1
+tframe,tframe.ts,-1,0,0,"class<`tframe`, `tstframe`>",1
+tframe,tframe.ts,0,0,0,"class<`matrix`, `mts`, `ts`>",1
+tframe,tframe.ts,0,0,1,class<`ts`>,1
+tframe,tfSet,-1,0,0,"class<`matrix`, `mts`, `ts`>",1
+tframe,tfSet,-1,0,1,class<`ts`>,1
+tframe,tfSet,0,0,0,"class<`matrix`, `mts`, `ts`>",1
+tframe,tfSet,0,0,1,"class<`tframe`, `tstframe`>",1
+tframe,tfSet,0,0,2,list<double[]>,1
+tframe,tfSet,1,0,0,class<`matrix`>,1
+tframe,tfSet,1,0,1,"class<`matrix`, `mts`, `ts`>",1
+tframe,tfSet,1,0,2,class<`ts`>,1
+tframe,tfSet,1,0,3,double[],1
+tframe,tfSet.default,-1,0,0,"class<`matrix`, `mts`, `ts`>",1
+tframe,tfSet.default,0,0,0,"class<`matrix`, `mts`, `ts`>",1
+tframe,tfSet.default,1,0,0,class<`matrix`>,1
+tframe,tfSet.list,-1,0,0,"class<`matrix`, `mts`, `ts`>",1
+tframe,tfSet.list,-1,0,1,class<`ts`>,1
+tframe,tfSet.list,0,0,0,list<double[]>,1
+tframe,tfSet.list,1,0,0,"class<`matrix`, `mts`, `ts`>",1
+tframe,tfSet.list,1,0,1,class<`matrix`>,1
+tframe,tfSet.list,1,0,2,class<`ts`>,1
+tframe,tfSet.tstframe,-1,0,0,"class<`matrix`, `mts`, `ts`>",1
+tframe,tfSet.tstframe,-1,0,1,class<`ts`>,1
+tframe,tfSet.tstframe,0,0,0,list<double[]>,1
+tframe,tfSet.tstframe,0,0,1,"class<`tframe`, `tstframe`>",1
+tframe,tfSet.tstframe,1,0,0,"class<`matrix`, `mts`, `ts`>",1
+tframe,tfSet.tstframe,1,0,1,class<`matrix`>,1
+tframe,tfSet.tstframe,1,0,2,class<`ts`>,1
+tframe,tfSet.tstframe,1,0,3,double[],1
+tframe,tfspan,-1,0,0,"class<`tframe`, `tstframe`>",1
+tframe,tfspan,0,0,0,class<`ts`>,1
+tframe,tfspan,1,0,0,...,1
+tframe,tfstart,-1,0,0,double[],1
+tframe,tfstart,0,0,0,"class<`matrix`, `mts`, `ts`>",1
+tframe,tfstart,0,0,1,"class<`tframe`, `tstframe`>",1
+tframe,tfstart,0,0,2,class<`ts`>,1
+tframe,tfstart,0,0,3,double[],1
+tframe,tfstart.default,-1,0,0,double[],1
+tframe,tfstart.default,0,0,0,"class<`matrix`, `mts`, `ts`>",1
+tframe,tfstart.default,0,0,1,class<`ts`>,1
+tframe,tfstart.default,0,0,2,double[],1
+tframe,tfstart.tstframe,-1,0,0,double[],1
+tframe,tfstart.tstframe,0,0,0,"class<`tframe`, `tstframe`>",1
+tframe,tftime,-1,0,0,class<`ts`>,1
+tframe,tftime,0,0,0,"class<`tframe`, `tstframe`>",1
+tframe,tftime.default,-1,0,0,class<`ts`>,1
+tframe,tftime.default,0,0,0,"class<`tframe`, `tstframe`>",1
+tframe,tfTruncate,-1,0,0,"class<`matrix`, `mts`, `ts`>",1
+tframe,tfTruncate,-1,0,1,"class<`tframe`, `tstframe`>",1
+tframe,tfTruncate,-1,0,2,class<`ts`>,1
+tframe,tfTruncate,0,0,0,"class<`matrix`, `mts`, `ts`>",1
+tframe,tfTruncate,0,0,1,"class<`tframe`, `tstframe`>",1
+tframe,tfTruncate,0,0,2,class<`ts`>,1
+tframe,tfTruncate,1,0,0,double,1
+tframe,tfTruncate,2,0,0,double,1
+tframe,tfTruncate,2,0,1,null,1
+tframe,tfTruncate.default,-1,0,0,"class<`matrix`, `mts`, `ts`>",1
+tframe,tfTruncate.default,-1,0,1,class<`ts`>,1
+tframe,tfTruncate.default,0,0,0,"class<`matrix`, `mts`, `ts`>",1
+tframe,tfTruncate.default,0,0,1,class<`ts`>,1
+tframe,tfTruncate.default,1,0,0,double,1
+tframe,tfTruncate.default,2,0,0,double,1
+tframe,tfTruncate.default,2,0,1,null,1
+tframe,tfTruncate.tframe,-1,0,0,"class<`tframe`, `tstframe`>",1
+tframe,tfTruncate.tframe,0,0,0,"class<`tframe`, `tstframe`>",1
+tframe,tfTruncate.tframe,1,0,0,double,1
+tframe,tfTruncate.tframe,2,0,0,double,1
+tframe,tfTruncate.tframe,2,0,1,null,1
+tframe,tfUnSet,-1,0,0,class<`matrix`>,1
+tframe,tfUnSet,0,0,0,class<`matrix`>,1
+tframe,tfUnSet.default,-1,0,0,class<`matrix`>,1
+tframe,tfUnSet.default,0,0,0,class<`matrix`>,1
+tframe,tfwindow,-1,0,0,"class<`matrix`, `mts`, `ts`>",1
+tframe,tfwindow,-1,0,1,class<`ts`>,1
+tframe,tfwindow,0,0,0,"class<`matrix`, `mts`, `ts`>",1
+tframe,tfwindow,0,0,1,class<`ts`>,1
+tframe,tfwindow,1,0,0,null,1
+tframe,tfwindow,1,0,1,"class<`tframe`, `tstframe`>",1
+tframe,tfwindow,2,0,0,any,1
+tframe,tfwindow,3,0,0,any,1
+tframe,tfwindow,4,0,0,logical,1
+tframe,tfwindow.ts,-1,0,0,"class<`matrix`, `mts`, `ts`>",1
+tframe,tfwindow.ts,-1,0,1,class<`ts`>,1
+tframe,tfwindow.ts,0,0,0,"class<`matrix`, `mts`, `ts`>",1
+tframe,tfwindow.ts,0,0,1,class<`ts`>,1
+tframe,tfwindow.ts,1,0,0,null,1
+tframe,tfwindow.ts,1,0,1,"class<`tframe`, `tstframe`>",1
+tframe,tfwindow.ts,2,0,0,double[],1
+tframe,tfwindow.ts,3,0,0,double[],1
+tframe,tfwindow.ts,3,0,1,null,1
+tframe,tfwindow.ts,4,0,0,logical,1
+tframe,time.tframe,-1,0,0,class<`ts`>,1
+tframe,time.tframe,0,0,0,"class<`tframe`, `tstframe`>",1
+tframe,time.tframe,1,0,0,...,1
+tframe,Tobs,-1,0,0,double,1
+tframe,Tobs,0,0,0,"class<`tframe`, `tstframe`>",1
+tframe,Tobs,0,0,1,"class<`matrix`, `mts`, `ts`>",1
+tframe,Tobs,0,0,2,class<`ts`>,1
+tframe,Tobs,0,0,3,double[],1
+tframe,Tobs.default,-1,0,0,integer,1
+tframe,Tobs.default,0,0,0,"class<`matrix`, `mts`, `ts`>",1
+tframe,Tobs.default,0,0,1,class<`ts`>,1
+tframe,Tobs.default,0,0,2,double[],1
+tframe,Tobs.tframe,-1,0,0,double,1
+tframe,Tobs.tframe,0,0,0,"class<`tframe`, `tstframe`>",1
+tframe,trimNA,-1,0,0,"class<`matrix`, `mts`, `ts`>",1
+tframe,trimNA,0,0,0,"class<`matrix`, `mts`, `ts`>",1
+tframe,trimNA,1,0,0,logical,1
+tframe,trimNA,2,0,0,logical,1
+tframe,trimNA.default,-1,0,0,"class<`matrix`, `mts`, `ts`>",1
+tframe,trimNA.default,0,0,0,"class<`matrix`, `mts`, `ts`>",1
+tframe,trimNA.default,1,0,0,logical,1
+tframe,trimNA.default,2,0,0,logical,1
+tibble,add_column,-1,0,0,class<`data.frame`>,1
+tibble,add_column,-1,0,1,"class<`data.frame`, `tbl`, `tbl_df`>",1
+tibble,add_column,0,0,0,class<`data.frame`>,1
+tibble,add_column,0,0,1,"class<`data.frame`, `tbl`, `tbl_df`>",1
+tibble,add_column,1,0,0,...,1
+tibble,add_column,2,0,0,double,1
+tibble,add_column,2,0,1,null,1
+tibble,add_column,3,0,0,null,1
+tibble,add_row,-1,0,0,"class<`data.frame`, `tbl`, `tbl_df`>",1
+tibble,add_row,0,0,0,"class<`data.frame`, `tbl`, `tbl_df`>",1
+tibble,add_row,1,0,0,...,1
+tibble,add_row,2,0,0,double,1
+tibble,add_row,2,0,1,null,1
+tibble,add_row,3,0,0,null,1
+tibble,append_pos,-1,0,0,character[],1
+tibble,append_pos,0,0,0,character[],1
+tibble,append_pos,1,0,0,logical[],1
+tibble,as.data.frame.tbl_df,-1,0,0,class<`data.frame`>,1
+tibble,as.data.frame.tbl_df,0,0,0,"class<`data.frame`, `tbl`, `tbl_df`>",1
+tibble,as.data.frame.tbl_df,1,0,0,null,1
+tibble,as.data.frame.tbl_df,2,0,0,logical,1
+tibble,as.data.frame.tbl_df,3,0,0,...,1
+tibble,as_tibble,-1,0,0,"class<`data.frame`, `tbl`, `tbl_df`>",1
+tibble,as_tibble,0,0,0,class<`data.frame`>,1
+tibble,as_tibble,0,0,1,list<integer[] | character[]>,1
+tibble,as_tibble,0,0,2,list<double[]>,1
+tibble,as_tibble,0,0,3,class<`matrix`>,1
+tibble,as_tibble,1,0,0,...,1
+tibble,as_tibble,2,0,0,null,1
+tibble,as_tibble,3,0,0,any,1
+tibble,as_tibble,4,0,0,any,1
+tibble,as_tibble.data.frame,-1,0,0,"class<`data.frame`, `tbl`, `tbl_df`>",1
+tibble,as_tibble.data.frame,0,0,0,class<`data.frame`>,1
+tibble,as_tibble.data.frame,1,0,0,null,1
+tibble,as_tibble.data.frame,2,0,0,...,1
+tibble,as_tibble.data.frame,3,0,0,null,1
+tibble,as_tibble.data.frame,4,0,0,character[],1
+tibble,as_tibble.data.frame,5,0,0,null,1
+tibble,as_tibble.list,-1,0,0,"class<`data.frame`, `tbl`, `tbl_df`>",1
+tibble,as_tibble.list,0,0,0,list<double[]>,1
+tibble,as_tibble.list,0,0,1,list<character[] | double[]>,1
+tibble,as_tibble.list,0,0,2,list<double[] | class<`factor`>>,1
+tibble,as_tibble.list,0,0,3,list<integer[] | character[]>,1
+tibble,as_tibble.list,1,0,0,null,1
+tibble,as_tibble.list,2,0,0,...,1
+tibble,as_tibble.list,3,0,0,integer,1
+tibble,as_tibble.list,3,0,1,null,1
+tibble,as_tibble.list,4,0,0,character[],1
+tibble,as_tibble.matrix,-1,0,0,"class<`data.frame`, `tbl`, `tbl_df`>",1
+tibble,as_tibble.matrix,0,0,0,class<`matrix`>,1
+tibble,as_tibble.matrix,1,0,0,...,1
+tibble,as_tibble.matrix,2,0,0,null,1
+tibble,as_tibble.matrix,3,0,0,null,1
+tibble,big_mark,-1,0,0,character,1
+tibble,big_mark,0,0,0,double,1
+tibble,big_mark,1,0,0,...,1
+tibble,bullets,-1,0,0,character,1
+tibble,bullets,0,0,0,character,1
+tibble,bullets,1,0,0,...,1
+tibble,bullets,2,0,0,character,1
+tibble,cat_line,-1,0,0,null,1
+tibble,cat_line,0,0,0,...,1
+tibble,check_minimal,-1,0,0,character[],1
+tibble,check_minimal,0,0,0,character[],1
+tibble,check_names_before_after,-1,0,0,double,1
+tibble,check_names_before_after,-1,0,1,null,1
+tibble,check_names_before_after,0,0,0,double,1
+tibble,check_names_before_after,0,0,1,null,1
+tibble,check_names_before_after,1,0,0,any,1
+tibble,check_names_before_after_character,-1,0,0,integer[],1
+tibble,check_names_before_after_character,0,0,0,character[],1
+tibble,check_names_before_after_character,1,0,0,character[],1
+tibble,check_names_df,-1,0,0,integer[],1
+tibble,check_names_df,0,0,0,character[],1
+tibble,check_names_df,0,0,1,integer[],1
+tibble,check_names_df,1,0,0,"class<`data.frame`, `tbl`, `tbl_df`>",1
+tibble,check_names_df_numeric,-1,0,0,integer[],1
+tibble,check_names_df_numeric,0,0,0,integer[],1
+tibble,check_names_df_numeric,1,0,0,"class<`data.frame`, `tbl`, `tbl_df`>",1
+tibble,check_names_non_na,-1,0,0,character[],1
+tibble,check_names_non_na,0,0,0,character[],1
+tibble,check_names_non_na,1,0,0,any,1
+tibble,check_names_non_null,-1,0,0,character[],1
+tibble,check_names_non_null,0,0,0,character[],1
+tibble,check_names_non_null,1,0,0,any,1
+tibble,check_unique,-1,0,0,any,1
+tibble,check_unique,0,0,0,character[],1
+tibble,check_valid_cols,-1,0,0,any,1
+tibble,check_valid_cols,0,0,0,list<any>,1
+tibble,collapse,-1,0,0,character,1
+tibble,collapse,0,0,0,character[],1
+tibble,col_lengths,-1,0,0,integer[],1
+tibble,col_lengths,0,0,0,list<integer[] | character[]>,1
+tibble,col_lengths,0,0,1,list<double[]>,1
+tibble,col_lengths,0,0,2,list<character[] | double[]>,1
+tibble,col_lengths,0,0,3,list<double[] | class<`factor`>>,1
+tibble,column_to_rownames,-1,0,0,class<`data.frame`>,1
+tibble,column_to_rownames,0,0,0,"class<`data.frame`, `tbl`, `tbl_df`>",1
+tibble,column_to_rownames,1,0,0,character,1
+tibble,commas,-1,0,0,character,1
+tibble,commas,0,0,0,character,1
+tibble,compat_name_repair,-1,0,0,character[],1
+tibble,compat_name_repair,0,0,0,character[],1
+tibble,compat_name_repair,1,0,0,null,1
+tibble,deframe,-1,0,0,integer[],1
+tibble,deframe,-1,0,1,list<integer>,1
+tibble,deframe,0,0,0,"class<`data.frame`, `tbl`, `tbl_df`>",1
+tibble,describe_repair,-1,0,0,null,1
+tibble,describe_repair,0,0,0,character[],1
+tibble,describe_repair,1,0,0,character[],1
+tibble,dim_desc,-1,0,0,character,1
+tibble,dim_desc,0,0,0,"class<`data.frame`, `tbl`, `tbl_df`>",1
+tibble,enframe,-1,0,0,"class<`data.frame`, `tbl`, `tbl_df`>",1
+tibble,enframe,0,0,0,double[],1
+tibble,enframe,0,0,1,list<double | integer[]>,1
+tibble,enframe,1,0,0,character,1
+tibble,enframe,1,0,1,null,1
+tibble,enframe,2,0,0,character,1
+tibble,error_column_names_must_be_unique,-1,0,0,character,1
+tibble,error_column_names_must_be_unique,0,0,0,character,1
+tibble,error_column_names_must_be_unique,1,0,0,logical,1
+tibble,error_inconsistent_cols,-1,0,0,character,1
+tibble,error_inconsistent_cols,0,0,0,null,1
+tibble,error_inconsistent_cols,1,0,0,character[],1
+tibble,error_inconsistent_cols,2,0,0,integer[],1
+tibble,error_inconsistent_cols,3,0,0,character,1
+tibble,error_time_column_must_be_posixct,-1,0,0,character,1
+tibble,error_time_column_must_be_posixct,0,0,0,character,1
+tibble,expand_vecs,-1,0,0,list<double[]>,1
+tibble,expand_vecs,-1,0,1,list<character[]>,1
+tibble,expand_vecs,0,0,0,list<double[]>,1
+tibble,expand_vecs,0,0,1,list<character[]>,1
+tibble,expand_vecs,1,0,0,integer,1
+tibble,extract_frame_data_from_dots,-1,0,0,list<character[] | list<character | double>>,1
+tibble,extract_frame_data_from_dots,-1,0,1,list<character[] | list<character | integer[]>>,1
+tibble,extract_frame_data_from_dots,-1,0,2,list<character[] | list<double>>,1
+tibble,extract_frame_data_from_dots,0,0,0,...,1
+tibble,extract_frame_names_from_dots,-1,0,0,character[],1
+tibble,extract_frame_names_from_dots,0,0,0,list<class<`formula`> | character | double>,1
+tibble,extract_frame_names_from_dots,0,0,1,list<class<`formula`> | character | integer[]>,1
+tibble,extract_frame_names_from_dots,0,0,2,list<class<`formula`> | double>,1
+tibble,fast_nrow,-1,0,0,integer,1
+tibble,fast_nrow,0,0,0,"class<`data.frame`, `tbl`, `tbl_df`>",1
+tibble,format_body,-1,0,0,class<`pillar_vertical`>,1
+tibble,format_body,0,0,0,class<`pillar_squeezed_colonnade`>,1
+tibble,format_comment,-1,0,0,character[],1
+tibble,format_comment,0,0,0,character[],1
+tibble,format_comment,1,0,0,any,1
+tibble,format_extra_vars,-1,0,0,character,1
+tibble,format_extra_vars,0,0,0,^character[],1
+tibble,format_footer,-1,0,0,character[],1
+tibble,format_footer,0,0,0,"class<`trunc_mat`, `trunc_mat_data.frame`, `trunc_mat_tbl`, `trunc_mat_tbl_df`>",1
+tibble,format_footer,1,0,0,class<`pillar_squeezed_colonnade`>,1
+tibble,format_footer_cols,-1,0,0,character,1
+tibble,format_footer_cols,-1,0,1,null,1
+tibble,format_footer_cols,0,0,0,any,1
+tibble,format_footer_cols,1,0,0,^character[],1
+tibble,format_footer_rows,-1,0,0,character,1
+tibble,format_footer_rows,-1,0,1,null,1
+tibble,format_footer_rows,0,0,0,"class<`trunc_mat`, `trunc_mat_data.frame`, `trunc_mat_tbl`, `trunc_mat_tbl_df`>",1
+tibble,format_header,-1,0,0,character,1
+tibble,format_header,0,0,0,"class<`trunc_mat`, `trunc_mat_data.frame`, `trunc_mat_tbl`, `trunc_mat_tbl_df`>",1
+tibble,format.tbl,-1,0,0,character[],1
+tibble,format.tbl,0,0,0,"class<`data.frame`, `tbl`, `tbl_df`>",1
+tibble,format.tbl,1,0,0,...,1
+tibble,format.tbl,2,0,0,double,1
+tibble,format.tbl,2,0,1,null,1
+tibble,format.tbl,3,0,0,null,1
+tibble,format.tbl,3,0,1,double,1
+tibble,format.tbl,4,0,0,double,1
+tibble,format.tbl,4,0,1,null,1
+tibble,format.trunc_mat,-1,0,0,character[],1
+tibble,format.trunc_mat,0,0,0,"class<`trunc_mat`, `trunc_mat_data.frame`, `trunc_mat_tbl`, `trunc_mat_tbl_df`>",1
+tibble,format.trunc_mat,1,0,0,null,1
+tibble,format.trunc_mat,2,0,0,...,1
+tibble,format_v,-1,0,0,character[],1
+tibble,format_v,0,0,0,character[],1
+tibble,format_v,0,0,1,"class<`POSIXct`, `POSIXt`>",1
+tibble,format_v,0,0,2,double[],1
+tibble,format_v.character,-1,0,0,character[],1
+tibble,format_v.character,0,0,0,character[],1
+tibble,format_v.default,-1,0,0,character[],1
+tibble,format_v.default,0,0,0,"class<`POSIXct`, `POSIXt`>",1
+tibble,format_v.default,0,0,1,double[],1
+tibble,frame_matrix,-1,0,0,class<`matrix`>,1
+tibble,frame_matrix,0,0,0,...,1
+tibble,glimpse,-1,0,0,class<`data.frame`>,1
+tibble,glimpse,-1,0,1,"class<`data.frame`, `tbl`, `tbl_df`>",1
+tibble,glimpse,0,0,0,class<`data.frame`>,1
+tibble,glimpse,0,0,1,"class<`data.frame`, `tbl`, `tbl_df`>",1
+tibble,glimpse,1,0,0,null,1
+tibble,glimpse,2,0,0,...,1
+tibble,glimpse.data.frame,-1,0,0,class<`data.frame`>,1
+tibble,glimpse.data.frame,-1,0,1,"class<`data.frame`, `tbl`, `tbl_df`>",1
+tibble,glimpse.data.frame,0,0,0,class<`data.frame`>,1
+tibble,glimpse.data.frame,0,0,1,"class<`data.frame`, `tbl`, `tbl_df`>",1
+tibble,glimpse.data.frame,1,0,0,null,1
+tibble,glimpse.data.frame,2,0,0,...,1
+tibble,glimpse.tbl,-1,0,0,class<`data.frame`>,1
+tibble,glimpse.tbl,-1,0,1,"class<`data.frame`, `tbl`, `tbl_df`>",1
+tibble,glimpse.tbl,0,0,0,class<`data.frame`>,1
+tibble,glimpse.tbl,0,0,1,"class<`data.frame`, `tbl`, `tbl_df`>",1
+tibble,glimpse.tbl,1,0,0,null,1
+tibble,glimpse.tbl,2,0,0,...,1
+tibble,guess_nrow,-1,0,0,double,1
+tibble,guess_nrow,0,0,0,any,1
+tibble,guess_nrow,1,0,0,double,1
+tibble,guess_nrow,1,0,1,null,1
+tibble,has_dim,-1,0,0,logical,1
+tibble,has_dim,0,0,0,character[],1
+tibble,has_dim,0,0,1,class<`factor`>,1
+tibble,has_dim,0,0,2,class<`latlon`>,1
+tibble,has_dim,0,0,3,double[],1
+tibble,has_nonnull_names,-1,0,0,logical,1
+tibble,has_nonnull_names,0,0,0,character[],1
+tibble,has_nonnull_names,0,0,1,class<`factor`>,1
+tibble,has_nonnull_names,0,0,2,class<`latlon`>,1
+tibble,has_nonnull_names,0,0,3,double[],1
+tibble,has_null_names,-1,0,0,logical,1
+tibble,has_null_names,0,0,0,character[],1
+tibble,has_null_names,0,0,1,class<`factor`>,1
+tibble,has_null_names,0,0,2,class<`latlon`>,1
+tibble,has_null_names,0,0,3,double[],1
+tibble,has_rownames,-1,0,0,logical,1
+tibble,has_rownames,0,0,0,class<`data.frame`>,1
+tibble,has_rownames,0,0,1,"class<`data.frame`, `tbl`, `tbl_df`>",1
+tibble,has_tibble_arg,-1,0,0,logical,1
+tibble,has_tibble_arg,0,0,0,character,1
+tibble,invalid_df,-1,0,0,character,1
+tibble,invalid_df,0,0,0,character,1
+tibble,invalid_df,1,0,0,character,1
+tibble,invalid_df,2,0,0,...,1
+tibble,is_syntactic,-1,0,0,logical[],1
+tibble,is_syntactic,0,0,0,character[],1
+tibble,justify,-1,0,0,character[],1
+tibble,justify,0,0,0,character[],1
+tibble,justify,1,0,0,logical,1
+tibble,justify,2,0,0,character,1
+tibble,limit_pos_range,-1,0,0,double,1
+tibble,limit_pos_range,0,0,0,double,1
+tibble,limit_pos_range,1,0,0,integer,1
+tibble,lst,-1,0,0,list<character[] | double[]>,1
+tibble,lst,-1,0,1,list<integer[] | character[]>,1
+tibble,lst,-1,0,2,list<double[]>,1
+tibble,lst,-1,0,3,list<double | integer[]>,1
+tibble,lst,0,0,0,...,1
+tibble,lst_quos,-1,0,0,list<integer[] | list<any>>,1
+tibble,lst_quos,-1,0,1,list<integer[] | list<character[] | double[]>>,1
+tibble,lst_quos,-1,0,2,list<integer[] | list<double>>,1
+tibble,lst_quos,-1,0,3,list<integer | list<integer[]>>,1
+tibble,lst_quos,-1,0,4,list<integer[] | list<double[]>>,1
+tibble,lst_quos,-1,0,5,list<integer[] | list<integer[] | character[]>>,1
+tibble,lst_quos,-1,0,6,list<integer[] | list<integer[]>>,1
+tibble,lst_quos,-1,0,7,"list<integer[] | list<integer[] | class<`data.frame`, `tbl`, `tbl_df`>>>",1
+tibble,lst_quos,-1,0,8,list<integer[] | list<integer[] | class<`matrix`>>>,1
+tibble,lst_quos,-1,0,9,list<integer | list<list<integer>>>,1
+tibble,lst_quos,-1,0,10,list<integer | list<double>>,1
+tibble,lst_quos,-1,0,11,"list<integer | list<class<`data.frame`, `tbl`, `tbl_df`>>>",1
+tibble,lst_quos,-1,0,12,list<integer | list<character[]>>,1
+tibble,lst_quos,-1,0,13,list<integer[] | list<double | integer[]>>,1
+tibble,lst_quos,-1,0,14,list<integer[] | list<integer[] | list<integer[]>>>,1
+tibble,lst_quos,-1,0,15,list<integer | list<list<class<`matrix`>>>>,1
+tibble,lst_quos,-1,0,16,"list<integer | list<class<`POSIXlt`, `POSIXt`>>>",1
+tibble,lst_quos,0,0,0,"class<`list`, `quosures`>",1
+tibble,lst_quos,1,0,0,any,1
+tibble,lst_to_tibble,-1,0,0,any,1
+tibble,lst_to_tibble,0,0,0,list<any>,1
+tibble,lst_to_tibble,1,0,0,any,1
+tibble,lst_to_tibble,2,0,0,character[],1
+tibble,lst_to_tibble,2,0,1,class<`function`>,1
+tibble,lst_to_tibble,2,0,2,class<`formula`>,1
+tibble,lst_to_tibble,3,0,0,any,1
+tibble,make_syntactic,-1,0,0,character[],1
+tibble,make_syntactic,0,0,0,character[],1
+tibble,map,-1,0,0,list<any>,1
+tibble,map,0,0,0,"class<`data.frame`, `tbl`, `tbl_df`>",1
+tibble,map,0,0,1,list<any>,1
+tibble,map,0,0,2,pairlist,1
+tibble,map,0,0,3,class<`data.frame`>,1
+tibble,map,1,0,0,class<`function`>,1
+tibble,map,2,0,0,...,1
+tibble,map2,-1,0,0,list<character>,1
+tibble,map2,0,0,0,character[],1
+tibble,map2,1,0,0,list<character>,1
+tibble,map2,2,0,0,class<`function`>,1
+tibble,map2,3,0,0,...,1
+tibble,map2_chr,-1,0,0,character[],1
+tibble,map2_chr,0,0,0,character[],1
+tibble,map2_chr,1,0,0,list<character>,1
+tibble,map2_chr,2,0,0,class<`function`>,1
+tibble,map2_chr,3,0,0,...,1
+tibble,map_chr,-1,0,0,character[],1
+tibble,map_chr,0,0,0,character[],1
+tibble,map_chr,0,0,1,integer[],1
+tibble,map_chr,0,0,2,class<`data.frame`>,1
+tibble,map_chr,0,0,3,list<class<`pillar_type`>>,1
+tibble,map_chr,1,0,0,class<`function`>,1
+tibble,map_chr,2,0,0,...,1
+tibble,map_int,-1,0,0,integer[],1
+tibble,map_int,0,0,0,list<integer[] | character[]>,1
+tibble,map_int,0,0,1,list<double[]>,1
+tibble,map_int,0,0,2,list<character[] | double[]>,1
+tibble,map_int,0,0,3,list<double[] | class<`factor`>>,1
+tibble,map_int,1,0,0,class<`function`>,1
+tibble,map_int,2,0,0,...,1
+tibble,map_lgl,-1,0,0,logical[],1
+tibble,map_lgl,0,0,0,list<any>,1
+tibble,map_lgl,1,0,0,class<`function`>,1
+tibble,map_lgl,2,0,0,...,1
+tibble,map_mold,-1,0,0,character[],1
+tibble,map_mold,-1,0,1,integer[],1
+tibble,map_mold,0,0,0,character[],1
+tibble,map_mold,0,0,1,integer[],1
+tibble,map_mold,0,0,2,class<`data.frame`>,1
+tibble,map_mold,0,0,3,list<any>,1
+tibble,map_mold,1,0,0,class<`function`>,1
+tibble,map_mold,2,0,0,character,1
+tibble,map_mold,2,0,1,integer,1
+tibble,map_mold,3,0,0,...,1
+tibble,matrixToDataFrame,-1,0,0,class<`data.frame`>,1
+tibble,matrixToDataFrame,0,0,0,class<`matrix`>,1
+tibble,minimal_names,-1,0,0,character[],1
+tibble,minimal_names,0,0,0,character[],1
+tibble,minimal_names,0,0,1,null,1
+tibble,minimal_names,1,0,0,any,1
+tibble,mult_sign,-1,0,0,character,1
+tibble,nchar_width,-1,0,0,integer[],1
+tibble,nchar_width,0,0,0,character[],1
+tibble,needs_dim,-1,0,0,logical,1
+tibble,needs_dim,0,0,0,character[],1
+tibble,needs_dim,0,0,1,"class<`data.frame`, `tbl`, `tbl_df`>",1
+tibble,needs_dim,0,0,2,class<`factor`>,1
+tibble,needs_dim,0,0,3,class<`latlon`>,1
+tibble,needs_dim,0,0,4,class<`matrix`>,1
+tibble,needs_dim,0,0,5,"class<`POSIXlt`, `POSIXt`>",1
+tibble,needs_dim,0,0,6,double[],1
+tibble,needs_dim,0,0,7,list<class<`latlon`>>,1
+tibble,needs_dim,0,0,8,list<class<`matrix`>>,1
+tibble,needs_dim,0,0,9,list<integer[]>,1
+tibble,new_tibble,-1,0,0,"class<`data.frame`, `tbl`, `tbl_df`>",1
+tibble,new_tibble,0,0,0,class<`data.frame`>,1
+tibble,new_tibble,0,0,1,list<any>,1
+tibble,new_tibble,1,0,0,...,1
+tibble,new_tibble,2,0,0,double,1
+tibble,new_tibble,3,0,0,null,1
+tibble,new_tibble,4,0,0,null,1
+tibble,pluralise,-1,0,0,character,1
+tibble,pluralise,0,0,0,character,1
+tibble,pluralise,1,0,0,^character[],1
+tibble,pluralise_commas,-1,0,0,character,1
+tibble,pluralise_commas,0,0,0,character,1
+tibble,pluralise_commas,1,0,0,character,1
+tibble,pluralise_commas,2,0,0,...,1
+tibble,pluralise_n,-1,0,0,character[],1
+tibble,pluralise_n,0,0,0,character[],1
+tibble,pluralise_n,1,0,0,double,1
+tibble,pos_from_before_after,-1,0,0,double,1
+tibble,pos_from_before_after,0,0,0,double,1
+tibble,pos_from_before_after,0,0,1,null,1
+tibble,pos_from_before_after,1,0,0,null,1
+tibble,pos_from_before_after,2,0,0,integer,1
+tibble,pos_from_before_after_names,-1,0,0,double,1
+tibble,pos_from_before_after_names,0,0,0,double,1
+tibble,pos_from_before_after_names,0,0,1,null,1
+tibble,pos_from_before_after_names,1,0,0,null,1
+tibble,pos_from_before_after_names,2,0,0,character[],1
+tibble,pre_dots,-1,0,0,character[],1
+tibble,pre_dots,0,0,0,character[],1
+tibble,print.tbl,-1,0,0,"class<`data.frame`, `tbl`, `tbl_df`>",1
+tibble,print.tbl,0,0,0,"class<`data.frame`, `tbl`, `tbl_df`>",1
+tibble,print.tbl,1,0,0,...,1
+tibble,print.tbl,2,0,0,double,1
+tibble,print.tbl,2,0,1,null,1
+tibble,print.tbl,3,0,0,null,1
+tibble,print.tbl,3,0,1,double,1
+tibble,print.tbl,4,0,0,double,1
+tibble,print.tbl,4,0,1,null,1
+tibble,raw_rownames,-1,0,0,character[],1
+tibble,raw_rownames,-1,0,1,^integer[],1
+tibble,raw_rownames,0,0,0,class<`data.frame`>,1
+tibble,rbind_at,-1,0,0,"class<`data.frame`, `tbl`, `tbl_df`>",1
+tibble,rbind_at,0,0,0,"class<`data.frame`, `tbl`, `tbl_df`>",1
+tibble,rbind_at,1,0,0,"class<`data.frame`, `tbl`, `tbl_df`>",1
+tibble,rbind_at,2,0,0,double,1
+tibble,recycle_columns,-1,0,0,any,1
+tibble,recycle_columns,0,0,0,list<any>,1
+tibble,recycle_columns,1,0,0,double,1
+tibble,recycle_columns,1,0,1,null,1
+tibble,recycle_columns,2,0,0,integer[],1
+tibble,re_match,-1,0,0,class<`data.frame`>,1
+tibble,re_match,0,0,0,character[],1
+tibble,re_match,1,0,0,character,1
+tibble,re_match,2,0,0,logical,1
+tibble,re_match,3,0,0,...,1
+tibble,remove_rownames,-1,0,0,class<`data.frame`>,1
+tibble,remove_rownames,-1,0,1,"class<`data.frame`, `tbl`, `tbl_df`>",1
+tibble,remove_rownames,0,0,0,class<`data.frame`>,1
+tibble,remove_rownames,0,0,1,"class<`data.frame`, `tbl`, `tbl_df`>",1
+tibble,repaired_names,-1,0,0,any,1
+tibble,repaired_names,0,0,0,any,1
+tibble,repaired_names,1,0,0,class<`formula`>,1
+tibble,repaired_names,1,0,1,character[],1
+tibble,repaired_names,1,0,2,class<`function`>,1
+tibble,row.names<-.tbl_df,-1,0,0,"class<`data.frame`, `tbl`, `tbl_df`>",1
+tibble,row.names<-.tbl_df,0,0,0,"class<`data.frame`, `tbl`, `tbl_df`>",1
+tibble,row.names<-.tbl_df,1,0,0,null,1
+tibble,rownames_to_column,-1,0,0,class<`data.frame`>,1
+tibble,rownames_to_column,0,0,0,class<`data.frame`>,1
+tibble,rownames_to_column,1,0,0,character,1
+tibble,safe_match,-1,0,0,integer[],1
+tibble,safe_match,0,0,0,character[],1
+tibble,safe_match,1,0,0,character[],1
+tibble,set_minimal_names,-1,0,0,list<any>,1
+tibble,set_minimal_names,0,0,0,list<any>,1
+tibble,set_repaired_names,-1,0,0,any,1
+tibble,set_repaired_names,0,0,0,list<any>,1
+tibble,set_repaired_names,1,0,0,character[],1
+tibble,set_repaired_names,1,0,1,class<`function`>,1
+tibble,set_repaired_names,1,0,2,class<`formula`>,1
+tibble,set_tibble_subclass,-1,0,0,"class<`data.frame`, `tbl`, `tbl_df`>",1
+tibble,set_tibble_subclass,0,0,0,list<any>,1
+tibble,set_tibble_subclass,1,0,0,double,1
+tibble,set_tibble_subclass,2,0,0,null,1
+tibble,shrink_mat,-1,0,0,list<class<`pillar_colonnade`> | double>,1
+tibble,shrink_mat,-1,0,1,list<class<`pillar_colonnade`> | integer>,1
+tibble,shrink_mat,0,0,0,class<`data.frame`>,1
+tibble,shrink_mat,1,0,0,integer,1
+tibble,shrink_mat,2,0,0,double,1
+tibble,shrink_mat,3,0,0,logical,1
+tibble,some,-1,0,0,logical,1
+tibble,some,0,0,0,list<character>,1
+tibble,some,0,0,1,list<double>,1
+tibble,some,0,0,2,list<integer[]>,1
+tibble,some,1,0,0,class<`function`>,1
+tibble,some,2,0,0,...,1
+tibble,spaces_around,-1,0,0,character,1
+tibble,spaces_around,0,0,0,character,1
+tibble,strip_pos,-1,0,0,character[],1
+tibble,strip_pos,0,0,0,character[],1
+tibble,str_trunc,-1,0,0,character[],1
+tibble,str_trunc,0,0,0,character[],1
+tibble,str_trunc,1,0,0,double[],1
+tibble,strwrap2,-1,0,0,character[],1
+tibble,strwrap2,0,0,0,character,1
+tibble,strwrap2,1,0,0,double,1
+tibble,strwrap2,2,0,0,double,1
+tibble,[.tbl_df,-1,0,0,"class<`data.frame`, `tbl`, `tbl_df`>",1
+tibble,[.tbl_df,-1,0,1,integer[],1
+tibble,[.tbl_df,0,0,0,"class<`data.frame`, `tbl`, `tbl_df`>",1
+tibble,[.tbl_df,1,0,0,any,1
+tibble,[.tbl_df,2,0,0,any,1
+tibble,[.tbl_df,3,0,0,logical,1
+tibble,[[.tbl_df,-1,0,0,character[],1
+tibble,[[.tbl_df,-1,0,1,double,1
+tibble,[[.tbl_df,-1,0,2,integer[],1
+tibble,[[.tbl_df,-1,0,3,list<class<`matrix`>>,1
+tibble,[[.tbl_df,-1,0,4,list<integer>,1
+tibble,[[.tbl_df,-1,0,5,null,1
+tibble,[[.tbl_df,0,0,0,"class<`data.frame`, `tbl`, `tbl_df`>",1
+tibble,[[.tbl_df,1,0,0,character,1
+tibble,[[.tbl_df,1,0,1,double,1
+tibble,[[.tbl_df,2,0,0,any,1
+tibble,[[.tbl_df,3,0,0,...,1
+tibble,[[.tbl_df,4,0,0,logical,1
+tibble,$.tbl_df,-1,0,0,class<`latlon`>,1
+tibble,$.tbl_df,-1,0,1,double,1
+tibble,$.tbl_df,-1,0,2,integer[],1
+tibble,$.tbl_df,-1,0,3,null,1
+tibble,$.tbl_df,0,0,0,"class<`data.frame`, `tbl`, `tbl_df`>",1
+tibble,$.tbl_df,1,0,0,character,1
+tibble,tbl_sum,-1,0,0,character,1
+tibble,tbl_sum,0,0,0,"class<`data.frame`, `tbl`, `tbl_df`>",1
+tibble,tbl_sum,0,0,1,class<`data.frame`>,1
+tibble,tbl_sum.default,-1,0,0,character,1
+tibble,tbl_sum.default,0,0,0,class<`data.frame`>,1
+tibble,tbl_sum.tbl,-1,0,0,character,1
+tibble,tbl_sum.tbl,0,0,0,"class<`data.frame`, `tbl`, `tbl_df`>",1
+tibble,tibble,-1,0,0,any,1
+tibble,tibble,0,0,0,...,1
+tibble,tibble,1,0,0,double,1
+tibble,tibble,1,0,1,null,1
+tibble,tibble,2,0,0,character[],1
+tibble,tibble,2,0,1,class<`formula`>,1
+tibble,tibble,2,0,2,class<`function`>,1
+tibble,tibble_glimpse_width,-1,0,0,integer,1
+tibble,tibble_glimpse_width,0,0,0,null,1
+tibble,tibble_opt,-1,0,0,integer,1
+tibble,tibble_opt,-1,0,1,null,1
+tibble,tibble_opt,0,0,0,character,1
+tibble,tibble_width,-1,0,0,double,1
+tibble,tibble_width,0,0,0,double,1
+tibble,tibble_width,0,0,1,null,1
+tibble,tick,-1,0,0,character[],1
+tibble,tick,-1,0,1,logical[],1
+tibble,tick,0,0,0,character[],1
+tibble,tick_if_needed,-1,0,0,character[],1
+tibble,tick_if_needed,0,0,0,character[],1
+tibble,tribble,-1,0,0,"class<`data.frame`, `tbl`, `tbl_df`>",1
+tibble,tribble,0,0,0,...,1
+tibble,trunc_mat,-1,0,0,"class<`trunc_mat`, `trunc_mat_data.frame`>",1
+tibble,trunc_mat,-1,0,1,"class<`trunc_mat`, `trunc_mat_data.frame`, `trunc_mat_tbl`, `trunc_mat_tbl_df`>",1
+tibble,trunc_mat,0,0,0,class<`data.frame`>,1
+tibble,trunc_mat,0,0,1,"class<`data.frame`, `tbl`, `tbl_df`>",1
+tibble,trunc_mat,1,0,0,null,1
+tibble,trunc_mat,1,0,1,double,1
+tibble,trunc_mat,2,0,0,null,1
+tibble,trunc_mat,2,0,1,double,1
+tibble,trunc_mat,3,0,0,null,1
+tibble,trunc_mat,3,0,1,double,1
+tibble,turn_frame_data_into_frame_matrix,-1,0,0,class<`matrix`>,1
+tibble,turn_frame_data_into_frame_matrix,0,0,0,character[],1
+tibble,turn_frame_data_into_frame_matrix,1,0,0,list<double>,1
+tibble,turn_frame_data_into_tibble,-1,0,0,"class<`data.frame`, `tbl`, `tbl_df`>",1
+tibble,turn_frame_data_into_tibble,0,0,0,character[],1
+tibble,turn_frame_data_into_tibble,1,0,0,list<character | double>,1
+tibble,turn_frame_data_into_tibble,1,0,1,list<character | integer[]>,1
+tibble,turn_matrix_into_column_list,-1,0,0,list<character[] | double[]>,1
+tibble,turn_matrix_into_column_list,-1,0,1,list<character[] | list<integer[]>>,1
+tibble,turn_matrix_into_column_list,0,0,0,class<`matrix`>,1
+tibble,two_to_three_dots,-1,0,0,character[],1
+tibble,two_to_three_dots,0,0,0,character[],1
+tibble,unique_names,-1,0,0,character[],1
+tibble,unique_names,0,0,0,character[],1
+tibble,unique_names,1,0,0,logical,1
+tibble,unique_names,2,0,0,class<`function`>,1
+tibble,update_tibble_attrs,-1,0,0,list<any>,1
+tibble,update_tibble_attrs,0,0,0,list<any>,1
+tibble,update_tibble_attrs,1,0,0,...,1
+tibble,use_repair,-1,0,0,character,1
+tibble,use_repair,0,0,0,logical,1
+tibble,validate_rectangular_shape,-1,0,0,null,1
+tibble,validate_rectangular_shape,0,0,0,character[],1
+tibble,validate_rectangular_shape,1,0,0,list<character | double>,1
+tibble,validate_rectangular_shape,1,0,1,list<character | integer[]>,1
+tibble,validate_rectangular_shape,1,0,2,list<double>,1
+tibble,vec_restore_tbl_df_with_nr,-1,0,0,"class<`data.frame`, `tbl`, `tbl_df`>",1
+tibble,vec_restore_tbl_df_with_nr,0,0,0,list<any>,1
+tibble,vec_restore_tbl_df_with_nr,1,0,0,"class<`data.frame`, `tbl`, `tbl_df`>",1
+tibble,vec_restore_tbl_df_with_nr,2,0,0,integer,1
+tibble,warningc,-1,0,0,character,1
+tibble,warningc,0,0,0,...,1
+tidyr,all_identical,-1,0,0,logical,1
+tidyr,all_identical,0,0,0,list<null>,1
+tidyr,append_col,-1,0,0,"class<`data.frame`, `tbl`, `tbl_df`>",1
+tidyr,append_col,0,0,0,"class<`data.frame`, `tbl`, `tbl_df`>",1
+tidyr,append_col,1,0,0,character[],1
+tidyr,append_col,2,0,0,character,1
+tidyr,append_col,3,0,0,integer,1
+tidyr,append_df,-1,0,0,class<`data.frame`>,1
+tidyr,append_df,-1,0,1,"class<`data.frame`, `tbl`, `tbl_df`>",1
+tidyr,append_df,0,0,0,class<`data.frame`>,1
+tidyr,append_df,0,0,1,"class<`data.frame`, `tbl`, `tbl_df`>",1
+tidyr,append_df,1,0,0,"class<`data.frame`, `tbl`, `tbl_df`>",1
+tidyr,append_df,1,0,1,list<^character[]>,1
+tidyr,append_df,2,0,0,character,1
+tidyr,append_df,2,0,1,integer,1
+tidyr,append_df,3,0,0,logical,1
+tidyr,as_tibble_matrix,-1,0,0,"class<`data.frame`, `tbl`, `tbl_df`>",1
+tidyr,as_tibble_matrix,0,0,0,class<`factor`>,1
+tidyr,as_tibble_matrix,0,0,1,class<`matrix`>,1
+tidyr,build_longer_spec,-1,0,0,"class<`data.frame`, `tbl`, `tbl_df`>",1
+tidyr,build_longer_spec,0,0,0,class<`data.frame`>,1
+tidyr,build_longer_spec,0,0,1,"class<`data.frame`, `spec_tbl_df`, `tbl`, `tbl_df`>",1
+tidyr,build_longer_spec,0,0,2,"class<`data.frame`, `tbl`, `tbl_df`>",1
+tidyr,build_longer_spec,1,0,0,any,1
+tidyr,build_longer_spec,2,0,0,character[],1
+tidyr,build_longer_spec,3,0,0,any,1
+tidyr,build_longer_spec,4,0,0,null,1
+tidyr,build_longer_spec,4,0,1,character,1
+tidyr,build_longer_spec,5,0,0,null,1
+tidyr,build_longer_spec,5,0,1,character,1
+tidyr,build_longer_spec,6,0,0,character,1
+tidyr,build_longer_spec,6,0,1,null,1
+tidyr,build_longer_spec,7,0,0,list<any>,1
+tidyr,build_longer_spec,7,0,1,null,1
+tidyr,build_wider_spec,-1,0,0,"class<`data.frame`, `tbl`, `tbl_df`>",1
+tidyr,build_wider_spec,0,0,0,"class<`data.frame`, `spec_tbl_df`, `tbl`, `tbl_df`>",1
+tidyr,build_wider_spec,0,0,1,"class<`data.frame`, `tbl`, `tbl_df`>",1
+tidyr,build_wider_spec,1,0,0,any,1
+tidyr,build_wider_spec,2,0,0,any,1
+tidyr,build_wider_spec,3,0,0,character,1
+tidyr,build_wider_spec,4,0,0,character,1
+tidyr,check_key,-1,0,0,character,1
+tidyr,check_key,0,0,0,any,1
+tidyr,check_replacement,-1,0,0,null,1
+tidyr,check_replacement,0,0,0,character,1
+tidyr,check_replacement,0,0,1,double,1
+tidyr,check_replacement,0,0,2,list<double>,1
+tidyr,check_replacement,1,0,0,any,1
+tidyr,check_spec,-1,0,0,"class<`data.frame`, `tbl`, `tbl_df`>",1
+tidyr,check_spec,0,0,0,"class<`data.frame`, `tbl`, `tbl_df`>",1
+tidyr,chop,-1,0,0,"class<`data.frame`, `tbl`, `tbl_df`>",1
+tidyr,chop,0,0,0,"class<`data.frame`, `tbl`, `tbl_df`>",1
+tidyr,chop,1,0,0,any,1
+tidyr,col_names,-1,0,0,character[],1
+tidyr,col_names,0,0,0,class<`data.frame`>,1
+tidyr,col_names,1,0,0,null,1
+tidyr,complete,-1,0,0,"class<`data.frame`, `tbl`, `tbl_df`>",1
+tidyr,complete,0,0,0,"class<`data.frame`, `tbl`, `tbl_df`>",1
+tidyr,complete,1,0,0,...,1
+tidyr,complete,2,0,0,any,1
+tidyr,complete_cases,-1,0,0,logical[],1
+tidyr,complete_cases,0,0,0,"class<`data.frame`, `tbl`, `tbl_df`>",1
+tidyr,complete_cases,1,0,0,any,1
+tidyr,complete.data.frame,-1,0,0,"class<`data.frame`, `tbl`, `tbl_df`>",1
+tidyr,complete.data.frame,0,0,0,"class<`data.frame`, `tbl`, `tbl_df`>",1
+tidyr,complete.data.frame,1,0,0,...,1
+tidyr,complete.data.frame,2,0,0,list<any>,1
+tidyr,crossing,-1,0,0,"class<`data.frame`, `tbl`, `tbl_df`>",1
+tidyr,crossing,0,0,0,...,1
+tidyr,deduplicate_names,-1,0,0,"class<`data.frame`, `tbl`, `tbl_df`>",1
+tidyr,deduplicate_names,0,0,0,"class<`data.frame`, `tbl`, `tbl_df`>",1
+tidyr,deduplicate_names,1,0,0,class<`data.frame`>,1
+tidyr,deduplicate_names,1,0,1,"class<`data.frame`, `spec_tbl_df`, `tbl`, `tbl_df`>",1
+tidyr,deduplicate_names,1,0,2,"class<`data.frame`, `tbl`, `tbl_df`>",1
+tidyr,dots_cols,-1,0,0,list<class<`data.frame`> | integer[]>,1
+tidyr,dots_cols,-1,0,1,list<list<class<`formula`> | class<`data.frame`>>>,1
+tidyr,dots_cols,-1,0,2,"list<double[] | class<`data.frame`, `tbl`, `tbl_df`>>",1
+tidyr,dots_cols,-1,0,3,list<double[] | character[]>,1
+tidyr,dots_cols,-1,0,4,"list<class<`data.frame`, `tbl`, `tbl_df`> | double[]>",1
+tidyr,dots_cols,-1,0,5,"list<class<`data.frame`, `tbl`, `tbl_df`>>",1
+tidyr,dots_cols,-1,0,6,list<character[] | integer[]>,1
+tidyr,dots_cols,-1,0,7,list<double[]>,1
+tidyr,dots_cols,-1,0,8,list<class<`matrix`>>,1
+tidyr,dots_cols,-1,0,9,list<^character[]>,1
+tidyr,dots_cols,0,0,0,...,1
+tidyr,dots_cols,1,0,0,null,1
+tidyr,dots_cols,1,0,1,"class<`data.frame`, `tbl`, `tbl_df`>",1
+tidyr,dots_cols,1,0,2,class<`data.frame`>,1
+tidyr,drop_cols,-1,0,0,class<`data.frame`>,1
+tidyr,drop_cols,-1,0,1,"class<`data.frame`, `spec_tbl_df`, `tbl`, `tbl_df`>",1
+tidyr,drop_cols,-1,0,2,"class<`data.frame`, `tbl`, `tbl_df`>",1
+tidyr,drop_cols,0,0,0,class<`data.frame`>,1
+tidyr,drop_cols,0,0,1,"class<`data.frame`, `spec_tbl_df`, `tbl`, `tbl_df`>",1
+tidyr,drop_cols,0,0,2,"class<`data.frame`, `tbl`, `tbl_df`>",1
+tidyr,drop_cols,1,0,0,character[],1
+tidyr,drop_cols,1,0,1,integer[],1
+tidyr,drop_na,-1,0,0,"class<`data.frame`, `tbl`, `tbl_df`>",1
+tidyr,drop_na,0,0,0,"class<`data.frame`, `tbl`, `tbl_df`>",1
+tidyr,drop_na,1,0,0,...,1
+tidyr,drop_na.data.frame,-1,0,0,"class<`data.frame`, `tbl`, `tbl_df`>",1
+tidyr,drop_na.data.frame,0,0,0,"class<`data.frame`, `tbl`, `tbl_df`>",1
+tidyr,drop_na.data.frame,1,0,0,...,1
+tidyr,drop_null,-1,0,0,list<any>,1
+tidyr,drop_null,0,0,0,list<null>,1
+tidyr,drop_null,0,0,1,list<class<`data.frame`>>,1
+tidyr,drop_null,0,0,2,"list<class<`data.frame`, `tbl`, `tbl_df`>>",1
+tidyr,drop_null,0,0,3,list<character[]>,1
+tidyr,drop_null,0,0,4,list<class<`vctrs_unspecified`>>,1
+tidyr,drop_null,0,0,5,list<integer[]>,1
+tidyr,ensym2,-1,0,0,class<`name`>,1
+tidyr,ensym2,0,0,0,any,1
+tidyr,expand,-1,0,0,"class<`data.frame`, `tbl`, `tbl_df`>",1
+tidyr,expand,0,0,0,class<`data.frame`>,1
+tidyr,expand,0,0,1,"class<`data.frame`, `tbl`, `tbl_df`>",1
+tidyr,expand,1,0,0,...,1
+tidyr,expand.data.frame,-1,0,0,"class<`data.frame`, `tbl`, `tbl_df`>",1
+tidyr,expand.data.frame,0,0,0,class<`data.frame`>,1
+tidyr,expand.data.frame,0,0,1,"class<`data.frame`, `tbl`, `tbl_df`>",1
+tidyr,expand.data.frame,1,0,0,...,1
+tidyr,expand_grid,-1,0,0,"class<`data.frame`, `tbl`, `tbl_df`>",1
+tidyr,expand_grid,0,0,0,...,1
+tidyr,extract,-1,0,0,class<`data.frame`>,1
+tidyr,extract,0,0,0,class<`data.frame`>,1
+tidyr,extract,1,0,0,any,1
+tidyr,extract,2,0,0,character[],1
+tidyr,extract,3,0,0,character,1
+tidyr,extract,4,0,0,logical,1
+tidyr,extract,5,0,0,logical,1
+tidyr,extract,6,0,0,...,1
+tidyr,extract.data.frame,-1,0,0,class<`data.frame`>,1
+tidyr,extract.data.frame,0,0,0,class<`data.frame`>,1
+tidyr,extract.data.frame,1,0,0,any,1
+tidyr,extract.data.frame,2,0,0,character[],1
+tidyr,extract.data.frame,3,0,0,character,1
+tidyr,extract.data.frame,4,0,0,logical,1
+tidyr,extract.data.frame,5,0,0,logical,1
+tidyr,extract.data.frame,6,0,0,...,1
+tidyr,fill,-1,0,0,class<`data.frame`>,1
+tidyr,fill,0,0,0,class<`data.frame`>,1
+tidyr,fill,1,0,0,...,1
+tidyr,fill,2,0,0,any,1
+tidyr,fill.data.frame,-1,0,0,class<`data.frame`>,1
+tidyr,fill.data.frame,0,0,0,class<`data.frame`>,1
+tidyr,fill.data.frame,1,0,0,...,1
+tidyr,fill.data.frame,2,0,0,character[],1
+tidyr,flatten_at,-1,0,0,"class<`data.frame`, `tbl`, `tbl_df`>",1
+tidyr,flatten_at,-1,0,1,list<character[] | double[]>,1
+tidyr,flatten_at,-1,0,2,list<character[] | double[] | list<integer[] | double>>,1
+tidyr,flatten_at,-1,0,3,list<character[]>,1
+tidyr,flatten_at,-1,0,4,list<character[] | list<character[]>>,1
+tidyr,flatten_at,-1,0,5,list<^double[]>,1
+tidyr,flatten_at,-1,0,6,list<double[] | character[]>,1
+tidyr,flatten_at,-1,0,7,list<character[] | double[] | ^logical[]>,1
+tidyr,flatten_at,-1,0,8,"list<integer[] | class<`data.frame`, `tbl`, `tbl_df`>>",1
+tidyr,flatten_at,0,0,0,"class<`data.frame`, `tbl`, `tbl_df`>",1
+tidyr,flatten_at,1,0,0,logical[],1
+tidyr,flatten_nested,-1,0,0,"class<`data.frame`, `tbl`, `tbl_df`>",1
+tidyr,flatten_nested,0,0,0,"class<`data.frame`, `tbl`, `tbl_df`>",1
+tidyr,flatten_nested,1,0,0,logical[],1
+tidyr,full_seq,-1,0,0,double[],1
+tidyr,full_seq,0,0,0,double[],1
+tidyr,full_seq,1,0,0,double,1
+tidyr,full_seq,2,0,0,double,1
+tidyr,full_seq.numeric,-1,0,0,double[],1
+tidyr,full_seq.numeric,0,0,0,double[],1
+tidyr,full_seq.numeric,1,0,0,double,1
+tidyr,full_seq.numeric,2,0,0,double,1
+tidyr,gather,-1,0,0,class<`data.frame`>,1
+tidyr,gather,-1,0,1,"class<`data.frame`, `grouped_df`, `tbl`, `tbl_df`>",1
+tidyr,gather,-1,0,2,"class<`data.frame`, `tbl`, `tbl_df`>",1
+tidyr,gather,0,0,0,class<`data.frame`>,1
+tidyr,gather,0,0,1,"class<`data.frame`, `grouped_df`, `tbl`, `tbl_df`>",1
+tidyr,gather,0,0,2,"class<`data.frame`, `tbl`, `tbl_df`>",1
+tidyr,gather,1,0,0,any,1
+tidyr,gather,2,0,0,any,1
+tidyr,gather,3,0,0,...,1
+tidyr,gather,4,0,0,logical,1
+tidyr,gather,5,0,0,logical,1
+tidyr,gather,6,0,0,logical,1
+tidyr,gather.data.frame,-1,0,0,class<`data.frame`>,1
+tidyr,gather.data.frame,-1,0,1,"class<`data.frame`, `grouped_df`, `tbl`, `tbl_df`>",1
+tidyr,gather.data.frame,-1,0,2,"class<`data.frame`, `tbl`, `tbl_df`>",1
+tidyr,gather.data.frame,0,0,0,class<`data.frame`>,1
+tidyr,gather.data.frame,0,0,1,"class<`data.frame`, `grouped_df`, `tbl`, `tbl_df`>",1
+tidyr,gather.data.frame,0,0,2,"class<`data.frame`, `tbl`, `tbl_df`>",1
+tidyr,gather.data.frame,1,0,0,any,1
+tidyr,gather.data.frame,2,0,0,any,1
+tidyr,gather.data.frame,3,0,0,...,1
+tidyr,gather.data.frame,4,0,0,logical,1
+tidyr,gather.data.frame,5,0,0,logical,1
+tidyr,gather.data.frame,6,0,0,logical,1
+tidyr,hoist,-1,0,0,"class<`data.frame`, `tbl`, `tbl_df`>",1
+tidyr,hoist,0,0,0,"class<`data.frame`, `tbl`, `tbl_df`>",1
+tidyr,hoist,1,0,0,any,1
+tidyr,hoist,2,0,0,...,1
+tidyr,hoist,3,0,0,logical,1
+tidyr,hoist,4,0,0,logical,1
+tidyr,hoist,5,0,0,list<any>,1
+tidyr,id,-1,0,0,integer[],1
+tidyr,id,0,0,0,class<`data.frame`>,1
+tidyr,id,0,0,1,list<integer[]>,1
+tidyr,id,1,0,0,any,1
+tidyr,id_var,-1,0,0,integer[],1
+tidyr,id_var,0,0,0,character[],1
+tidyr,id_var,0,0,1,class<`Date`>,1
+tidyr,id_var,0,0,2,class<`factor`>,1
+tidyr,id_var,0,0,3,double[],1
+tidyr,id_var,1,0,0,any,1
+tidyr,imap,-1,0,0,list<any>,1
+tidyr,imap,0,0,0,list<any>,1
+tidyr,imap,0,0,1,"class<`data.frame`, `tbl`, `tbl_df`>",1
+tidyr,imap,1,0,0,class<`function`>,1
+tidyr,imap,2,0,0,...,1
+tidyr,index,-1,0,0,character[],1
+tidyr,index,0,0,0,double[],1
+tidyr,is_complete,-1,0,0,logical[],1
+tidyr,is_complete,0,0,0,^character[],1
+tidyr,is_complete,0,0,1,^double[],1
+tidyr,is_complete,0,0,2,list<integer[] | null>,1
+tidyr,list_indices,-1,0,0,character,1
+tidyr,list_indices,0,0,0,integer[],1
+tidyr,list_indices,1,0,0,double,1
+tidyr,melt_dataframe,-1,0,0,class<`data.frame`>,1
+tidyr,melt_dataframe,0,0,0,class<`data.frame`>,1
+tidyr,melt_dataframe,0,0,1,"class<`data.frame`, `grouped_df`, `tbl`, `tbl_df`>",1
+tidyr,melt_dataframe,0,0,2,"class<`data.frame`, `tbl`, `tbl_df`>",1
+tidyr,melt_dataframe,1,0,0,integer,1
+tidyr,melt_dataframe,2,0,0,integer[],1
+tidyr,melt_dataframe,3,0,0,character,1
+tidyr,melt_dataframe,4,0,0,character,1
+tidyr,melt_dataframe,5,0,0,^double[],1
+tidyr,melt_dataframe,6,0,0,logical,1
+tidyr,melt_dataframe,7,0,0,logical,1
+tidyr,nest,-1,0,0,"class<`data.frame`, `grouped_df`, `tbl`, `tbl_df`>",1
+tidyr,nest,-1,0,1,"class<`data.frame`, `tbl`, `tbl_df`>",1
+tidyr,nest,0,0,0,"class<`data.frame`, `grouped_df`, `tbl`, `tbl_df`>",1
+tidyr,nest,0,0,1,class<`data.frame`>,1
+tidyr,nest,0,0,2,"class<`data.frame`, `tbl`, `tbl_df`>",1
+tidyr,nest,1,0,0,...,1
+tidyr,nest,2,0,0,any,1
+tidyr,nest.data.frame,-1,0,0,"class<`data.frame`, `tbl`, `tbl_df`>",1
+tidyr,nest.data.frame,0,0,0,class<`data.frame`>,1
+tidyr,nest.data.frame,1,0,0,...,1
+tidyr,nest.data.frame,2,0,0,any,1
+tidyr,nest.grouped_df,-1,0,0,"class<`data.frame`, `grouped_df`, `tbl`, `tbl_df`>",1
+tidyr,nest.grouped_df,0,0,0,"class<`data.frame`, `grouped_df`, `tbl`, `tbl_df`>",1
+tidyr,nest.grouped_df,1,0,0,...,1
+tidyr,nest.grouped_df,2,0,0,any,1
+tidyr,nesting,-1,0,0,"class<`data.frame`, `tbl`, `tbl_df`>",1
+tidyr,nesting,0,0,0,...,1
+tidyr,nest_legacy,-1,0,0,"class<`data.frame`, `tbl`, `tbl_df`>",1
+tidyr,nest_legacy,0,0,0,class<`data.frame`>,1
+tidyr,nest_legacy,0,0,1,"class<`data.frame`, `tbl`, `tbl_df`>",1
+tidyr,nest_legacy,1,0,0,...,1
+tidyr,nest_legacy,2,0,0,character,1
+tidyr,nest_legacy.data.frame,-1,0,0,"class<`data.frame`, `tbl`, `tbl_df`>",1
+tidyr,nest_legacy.data.frame,0,0,0,class<`data.frame`>,1
+tidyr,nest_legacy.data.frame,1,0,0,...,1
+tidyr,nest_legacy.data.frame,2,0,0,character,1
+tidyr,nest_legacy.tbl_df,-1,0,0,"class<`data.frame`, `tbl`, `tbl_df`>",1
+tidyr,nest_legacy.tbl_df,0,0,0,"class<`data.frame`, `tbl`, `tbl_df`>",1
+tidyr,nest_legacy.tbl_df,1,0,0,...,1
+tidyr,nest_legacy.tbl_df,2,0,0,any,1
+tidyr,nest.tbl_df,-1,0,0,"class<`data.frame`, `tbl`, `tbl_df`>",1
+tidyr,nest.tbl_df,0,0,0,"class<`data.frame`, `grouped_df`, `tbl`, `tbl_df`>",1
+tidyr,nest.tbl_df,0,0,1,"class<`data.frame`, `tbl`, `tbl_df`>",1
+tidyr,nest.tbl_df,1,0,0,...,1
+tidyr,nest.tbl_df,2,0,0,any,1
+tidyr,normalize_melt_arguments,-1,0,0,list<^double[]>,1
+tidyr,normalize_melt_arguments,0,0,0,class<`data.frame`>,1
+tidyr,normalize_melt_arguments,0,0,1,"class<`data.frame`, `grouped_df`, `tbl`, `tbl_df`>",1
+tidyr,normalize_melt_arguments,0,0,2,"class<`data.frame`, `tbl`, `tbl_df`>",1
+tidyr,normalize_melt_arguments,1,0,0,integer[],1
+tidyr,pack,-1,0,0,"class<`data.frame`, `tbl`, `tbl_df`>",1
+tidyr,pack,0,0,0,"class<`data.frame`, `tbl`, `tbl_df`>",1
+tidyr,pack,1,0,0,...,1
+tidyr,pivot_longer,-1,0,0,"class<`data.frame`, `tbl`, `tbl_df`>",1
+tidyr,pivot_longer,0,0,0,class<`data.frame`>,1
+tidyr,pivot_longer,0,0,1,"class<`data.frame`, `spec_tbl_df`, `tbl`, `tbl_df`>",1
+tidyr,pivot_longer,0,0,2,"class<`data.frame`, `tbl`, `tbl_df`>",1
+tidyr,pivot_longer,1,0,0,any,1
+tidyr,pivot_longer,2,0,0,character[],1
+tidyr,pivot_longer,3,0,0,null,1
+tidyr,pivot_longer,3,0,1,character,1
+tidyr,pivot_longer,4,0,0,null,1
+tidyr,pivot_longer,4,0,1,character,1
+tidyr,pivot_longer,5,0,0,character,1
+tidyr,pivot_longer,5,0,1,null,1
+tidyr,pivot_longer,6,0,0,list<any>,1
+tidyr,pivot_longer,7,0,0,character,1
+tidyr,pivot_longer_spec,-1,0,0,"class<`data.frame`, `tbl`, `tbl_df`>",1
+tidyr,pivot_longer_spec,0,0,0,class<`data.frame`>,1
+tidyr,pivot_longer_spec,0,0,1,"class<`data.frame`, `spec_tbl_df`, `tbl`, `tbl_df`>",1
+tidyr,pivot_longer_spec,0,0,2,"class<`data.frame`, `tbl`, `tbl_df`>",1
+tidyr,pivot_longer_spec,1,0,0,"class<`data.frame`, `tbl`, `tbl_df`>",1
+tidyr,pivot_longer_spec,2,0,0,character,1
+tidyr,pivot_longer_spec,3,0,0,logical,1
+tidyr,pivot_longer_spec,4,0,0,list<any>,1
+tidyr,pivot_wider,-1,0,0,"class<`data.frame`, `tbl`, `tbl_df`>",1
+tidyr,pivot_wider,0,0,0,"class<`data.frame`, `spec_tbl_df`, `tbl`, `tbl_df`>",1
+tidyr,pivot_wider,0,0,1,"class<`data.frame`, `tbl`, `tbl_df`>",1
+tidyr,pivot_wider,1,0,0,any,1
+tidyr,pivot_wider,2,0,0,any,1
+tidyr,pivot_wider,3,0,0,character,1
+tidyr,pivot_wider,4,0,0,character,1
+tidyr,pivot_wider,5,0,0,character,1
+tidyr,pivot_wider,6,0,0,any,1
+tidyr,pivot_wider,7,0,0,null,1
+tidyr,pivot_wider,7,0,1,list<double>,1
+tidyr,pivot_wider_spec,-1,0,0,"class<`data.frame`, `tbl`, `tbl_df`>",1
+tidyr,pivot_wider_spec,0,0,0,"class<`data.frame`, `spec_tbl_df`, `tbl`, `tbl_df`>",1
+tidyr,pivot_wider_spec,0,0,1,"class<`data.frame`, `tbl`, `tbl_df`>",1
+tidyr,pivot_wider_spec,1,0,0,"class<`data.frame`, `tbl`, `tbl_df`>",1
+tidyr,pivot_wider_spec,2,0,0,character,1
+tidyr,pivot_wider_spec,3,0,0,any,1
+tidyr,pivot_wider_spec,4,0,0,null,1
+tidyr,pivot_wider_spec,4,0,1,list<double>,1
+tidyr,pivot_wider_spec,5,0,0,null,1
+tidyr,pivot_wider_spec,5,0,1,list<class<`function`>>,1
+tidyr,reconstruct_tibble,-1,0,0,class<`data.frame`>,1
+tidyr,reconstruct_tibble,-1,0,1,"class<`data.frame`, `grouped_df`, `tbl`, `tbl_df`>",1
+tidyr,reconstruct_tibble,-1,0,2,"class<`data.frame`, `tbl`, `tbl_df`>",1
+tidyr,reconstruct_tibble,0,0,0,class<`data.frame`>,1
+tidyr,reconstruct_tibble,0,0,1,"class<`data.frame`, `grouped_df`, `tbl`, `tbl_df`>",1
+tidyr,reconstruct_tibble,0,0,2,"class<`data.frame`, `spec_tbl_df`, `tbl`, `tbl_df`>",1
+tidyr,reconstruct_tibble,0,0,3,"class<`data.frame`, `tbl`, `tbl_df`>",1
+tidyr,reconstruct_tibble,1,0,0,class<`data.frame`>,1
+tidyr,reconstruct_tibble,1,0,1,"class<`data.frame`, `tbl`, `tbl_df`>",1
+tidyr,reconstruct_tibble,2,0,0,any,1
+tidyr,replace_na,-1,0,0,character[],1
+tidyr,replace_na,-1,0,1,"class<`data.frame`, `tbl`, `tbl_df`>",1
+tidyr,replace_na,-1,0,2,double[],1
+tidyr,replace_na,0,0,0,^character[],1
+tidyr,replace_na,0,0,1,"class<`data.frame`, `tbl`, `tbl_df`>",1
+tidyr,replace_na,0,0,2,^double[],1
+tidyr,replace_na,1,0,0,character,1
+tidyr,replace_na,1,0,1,list<any>,1
+tidyr,replace_na,1,0,2,double,1
+tidyr,replace_na,2,0,0,...,1
+tidyr,replace_na.data.frame,-1,0,0,"class<`data.frame`, `tbl`, `tbl_df`>",1
+tidyr,replace_na.data.frame,0,0,0,"class<`data.frame`, `tbl`, `tbl_df`>",1
+tidyr,replace_na.data.frame,1,0,0,list<any>,1
+tidyr,replace_na.data.frame,2,0,0,...,1
+tidyr,replace_na.default,-1,0,0,character[],1
+tidyr,replace_na.default,-1,0,1,double[],1
+tidyr,replace_na.default,0,0,0,^character[],1
+tidyr,replace_na.default,0,0,1,^double[],1
+tidyr,replace_na.default,1,0,0,character,1
+tidyr,replace_na.default,1,0,1,double,1
+tidyr,replace_na.default,2,0,0,...,1
+tidyr,separate,-1,0,0,class<`data.frame`>,1
+tidyr,separate,-1,0,1,"class<`data.frame`, `tbl`, `tbl_df`>",1
+tidyr,separate,0,0,0,class<`data.frame`>,1
+tidyr,separate,0,0,1,"class<`data.frame`, `tbl`, `tbl_df`>",1
+tidyr,separate,1,0,0,any,1
+tidyr,separate,2,0,0,^character[],1
+tidyr,separate,3,0,0,character,1
+tidyr,separate,4,0,0,logical,1
+tidyr,separate,5,0,0,logical,1
+tidyr,separate,6,0,0,character,1
+tidyr,separate,7,0,0,character,1
+tidyr,separate.data.frame,-1,0,0,class<`data.frame`>,1
+tidyr,separate.data.frame,-1,0,1,"class<`data.frame`, `tbl`, `tbl_df`>",1
+tidyr,separate.data.frame,0,0,0,class<`data.frame`>,1
+tidyr,separate.data.frame,0,0,1,"class<`data.frame`, `tbl`, `tbl_df`>",1
+tidyr,separate.data.frame,1,0,0,any,1
+tidyr,separate.data.frame,2,0,0,^character[],1
+tidyr,separate.data.frame,3,0,0,character,1
+tidyr,separate.data.frame,4,0,0,logical,1
+tidyr,separate.data.frame,5,0,0,logical,1
+tidyr,separate.data.frame,6,0,0,character,1
+tidyr,separate.data.frame,7,0,0,character,1
+tidyr,separate_rows,-1,0,0,class<`data.frame`>,1
+tidyr,separate_rows,0,0,0,class<`data.frame`>,1
+tidyr,separate_rows,1,0,0,...,1
+tidyr,separate_rows,2,0,0,character,1
+tidyr,separate_rows,3,0,0,logical,1
+tidyr,separate_rows.data.frame,-1,0,0,class<`data.frame`>,1
+tidyr,separate_rows.data.frame,0,0,0,class<`data.frame`>,1
+tidyr,separate_rows.data.frame,1,0,0,...,1
+tidyr,separate_rows.data.frame,2,0,0,character,1
+tidyr,separate_rows.data.frame,3,0,0,logical,1
+tidyr,seq_nrow,-1,0,0,integer[],1
+tidyr,seq_nrow,0,0,0,"class<`data.frame`, `tbl`, `tbl_df`>",1
+tidyr,simplifyPieces,-1,0,0,list<integer[] | list<^character[]>>,1
+tidyr,simplifyPieces,-1,0,1,list<integer | list<^character[]>>,1
+tidyr,simplifyPieces,-1,0,2,list<integer[] | list<character[]>>,1
+tidyr,simplifyPieces,0,0,0,list<character[] | null>,1
+tidyr,simplifyPieces,0,0,1,list<null | character[]>,1
+tidyr,simplifyPieces,0,0,2,list<character[]>,1
+tidyr,simplifyPieces,1,0,0,integer,1
+tidyr,simplifyPieces,2,0,0,logical,1
+tidyr,sorted_unique,-1,0,0,"class<`data.frame`, `tbl`, `tbl_df`>",1
+tidyr,sorted_unique,-1,0,1,double[],1
+tidyr,sorted_unique,-1,0,2,list<class<`formula`>>,1
+tidyr,sorted_unique,-1,0,3,list<class<`data.frame`>>,1
+tidyr,sorted_unique,0,0,0,"class<`data.frame`, `tbl`, `tbl_df`>",1
+tidyr,sorted_unique,0,0,1,double[],1
+tidyr,sorted_unique,0,0,2,list<class<`formula`>>,1
+tidyr,sorted_unique,0,0,3,list<class<`data.frame`>>,1
+tidyr,split_labels,-1,0,0,class<`data.frame`>,1
+tidyr,split_labels,0,0,0,class<`data.frame`>,1
+tidyr,split_labels,1,0,0,integer[],1
+tidyr,split_labels,2,0,0,logical,1
+tidyr,spread,-1,0,0,class<`data.frame`>,1
+tidyr,spread,0,0,0,class<`data.frame`>,1
+tidyr,spread,1,0,0,any,1
+tidyr,spread,2,0,0,any,1
+tidyr,spread,3,0,0,null,1
+tidyr,spread,4,0,0,logical,1
+tidyr,spread,5,0,0,logical,1
+tidyr,spread,6,0,0,null,1
+tidyr,spread.data.frame,-1,0,0,class<`data.frame`>,1
+tidyr,spread.data.frame,0,0,0,class<`data.frame`>,1
+tidyr,spread.data.frame,1,0,0,any,1
+tidyr,spread.data.frame,2,0,0,any,1
+tidyr,spread.data.frame,3,0,0,null,1
+tidyr,spread.data.frame,4,0,0,logical,1
+tidyr,spread.data.frame,5,0,0,logical,1
+tidyr,spread.data.frame,6,0,0,null,1
+tidyr,str_extract,-1,0,0,"class<`data.frame`, `tbl`, `tbl_df`>",1
+tidyr,str_extract,0,0,0,^character[],1
+tidyr,str_extract,1,0,0,character[],1
+tidyr,str_extract,2,0,0,character,1
+tidyr,str_extract,3,0,0,logical,1
+tidyr,strike,-1,0,0,character[],1
+tidyr,strike,-1,0,1,list<character[]>,1
+tidyr,strike,0,0,0,character[],1
+tidyr,strike,0,0,1,list<character[]>,1
+tidyr,strike,1,0,0,list<integer>,1
+tidyr,strike,1,0,1,character,1
+tidyr,strike,1,0,2,list<character | integer>,1
+tidyr,str_separate,-1,0,0,"class<`data.frame`, `tbl`, `tbl_df`>",1
+tidyr,str_separate,0,0,0,^character[],1
+tidyr,str_separate,1,0,0,^character[],1
+tidyr,str_separate,2,0,0,character,1
+tidyr,str_separate,3,0,0,logical,1
+tidyr,str_separate,4,0,0,character,1
+tidyr,str_separate,5,0,0,character,1
+tidyr,str_split_fixed,-1,0,0,list<^character[]>,1
+tidyr,str_split_fixed,0,0,0,^character[],1
+tidyr,str_split_fixed,1,0,0,character,1
+tidyr,str_split_fixed,2,0,0,integer,1
+tidyr,str_split_fixed,3,0,0,character,1
+tidyr,str_split_fixed,4,0,0,character,1
+tidyr,unchop,-1,0,0,any,1
+tidyr,unchop,0,0,0,class<`data.frame`>,1
+tidyr,unchop,0,0,1,"class<`data.frame`, `tbl`, `tbl_df`>",1
+tidyr,unchop,1,0,0,any,1
+tidyr,unchop,2,0,0,logical,1
+tidyr,unchop,3,0,0,null,1
+tidyr,unchop,3,0,1,"class<`data.frame`, `tbl`, `tbl_df`>",1
+tidyr,uncount,-1,0,0,"class<`data.frame`, `tbl`, `tbl_df`>",1
+tidyr,uncount,0,0,0,"class<`data.frame`, `tbl`, `tbl_df`>",1
+tidyr,uncount,1,0,0,any,1
+tidyr,uncount,2,0,0,logical,1
+tidyr,uncount,3,0,0,character,1
+tidyr,uncount,3,0,1,null,1
+tidyr,unite,-1,0,0,"class<`data.frame`, `tbl`, `tbl_df`>",1
+tidyr,unite,0,0,0,"class<`data.frame`, `tbl`, `tbl_df`>",1
+tidyr,unite,1,0,0,character,1
+tidyr,unite,2,0,0,...,1
+tidyr,unite,3,0,0,character,1
+tidyr,unite,4,0,0,logical,1
+tidyr,unite,5,0,0,logical,1
+tidyr,unite.data.frame,-1,0,0,"class<`data.frame`, `tbl`, `tbl_df`>",1
+tidyr,unite.data.frame,0,0,0,"class<`data.frame`, `tbl`, `tbl_df`>",1
+tidyr,unite.data.frame,1,0,0,character,1
+tidyr,unite.data.frame,2,0,0,...,1
+tidyr,unite.data.frame,3,0,0,character,1
+tidyr,unite.data.frame,4,0,0,logical,1
+tidyr,unite.data.frame,5,0,0,logical,1
+tidyr,unnest,-1,0,0,"class<`data.frame`, `tbl`, `tbl_df`>",1
+tidyr,unnest,0,0,0,"class<`data.frame`, `tbl`, `tbl_df`>",1
+tidyr,unnest,1,0,0,any,1
+tidyr,unnest,2,0,0,...,1
+tidyr,unnest,3,0,0,logical,1
+tidyr,unnest,4,0,0,null,1
+tidyr,unnest,5,0,0,null,1
+tidyr,unnest,6,0,0,character,1
+tidyr,unnest,6,0,1,class<`function`>,1
+tidyr,unnest,7,0,0,any,1
+tidyr,unnest.data.frame,-1,0,0,"class<`data.frame`, `tbl`, `tbl_df`>",1
+tidyr,unnest.data.frame,0,0,0,"class<`data.frame`, `tbl`, `tbl_df`>",1
+tidyr,unnest.data.frame,1,0,0,any,1
+tidyr,unnest.data.frame,2,0,0,...,1
+tidyr,unnest.data.frame,3,0,0,logical,1
+tidyr,unnest.data.frame,4,0,0,null,1
+tidyr,unnest.data.frame,5,0,0,null,1
+tidyr,unnest.data.frame,6,0,0,character,1
+tidyr,unnest.data.frame,6,0,1,class<`function`>,1
+tidyr,unnest.data.frame,7,0,0,character,1
+tidyr,unnest_legacy,-1,0,0,"class<`data.frame`, `tbl`, `tbl_df`>",1
+tidyr,unnest_legacy,0,0,0,"class<`data.frame`, `tbl`, `tbl_df`>",1
+tidyr,unnest_legacy,1,0,0,...,1
+tidyr,unnest_legacy,2,0,0,null,1
+tidyr,unnest_legacy,3,0,0,null,1
+tidyr,unnest_legacy,4,0,0,null,1
+tidyr,unnest_legacy,5,0,0,null,1
+tidyr,unnest_legacy.data.frame,-1,0,0,"class<`data.frame`, `tbl`, `tbl_df`>",1
+tidyr,unnest_legacy.data.frame,0,0,0,"class<`data.frame`, `tbl`, `tbl_df`>",1
+tidyr,unnest_legacy.data.frame,1,0,0,...,1
+tidyr,unnest_legacy.data.frame,2,0,0,null,1
+tidyr,unnest_legacy.data.frame,3,0,0,null,1
+tidyr,unnest_legacy.data.frame,4,0,0,null,1
+tidyr,unnest_legacy.data.frame,5,0,0,null,1
+tidyr,unnest_longer,-1,0,0,"class<`data.frame`, `tbl`, `tbl_df`>",1
+tidyr,unnest_longer,0,0,0,"class<`data.frame`, `tbl`, `tbl_df`>",1
+tidyr,unnest_longer,1,0,0,any,1
+tidyr,unnest_longer,2,0,0,null,1
+tidyr,unnest_longer,3,0,0,null,1
+tidyr,unnest_longer,4,0,0,null,1
+tidyr,unnest_longer,5,0,0,character,1
+tidyr,unnest_longer,6,0,0,logical,1
+tidyr,unnest_longer,7,0,0,list<any>,1
+tidyr,unnest_wider,-1,0,0,"class<`data.frame`, `tbl`, `tbl_df`>",1
+tidyr,unnest_wider,0,0,0,"class<`data.frame`, `tbl`, `tbl_df`>",1
+tidyr,unnest_wider,1,0,0,any,1
+tidyr,unnest_wider,2,0,0,null,1
+tidyr,unnest_wider,3,0,0,logical,1
+tidyr,unnest_wider,4,0,0,character,1
+tidyr,unnest_wider,5,0,0,list<any>,1
+tidyr,unpack,-1,0,0,"class<`data.frame`, `tbl`, `tbl_df`>",1
+tidyr,unpack,0,0,0,"class<`data.frame`, `tbl`, `tbl_df`>",1
+tidyr,unpack,1,0,0,any,1
+tidyr,unpack,2,0,0,character,1
+tidyr,unpack,2,0,1,null,1
+tidyr,unpack,3,0,0,character,1
+tidyr,unpack,3,0,1,class<`function`>,1
+tidyr,update_cols,-1,0,0,class<`data.frame`>,1
+tidyr,update_cols,-1,0,1,"class<`data.frame`, `tbl`, `tbl_df`>",1
+tidyr,update_cols,0,0,0,class<`data.frame`>,1
+tidyr,update_cols,0,0,1,"class<`data.frame`, `tbl`, `tbl_df`>",1
+tidyr,update_cols,1,0,0,class<`data.frame`>,1
+tidyr,update_cols,1,0,1,"class<`data.frame`, `tbl`, `tbl_df`>",1
+tidyr,update_cols,1,0,2,list<class<`data.frame`>>,1
+tidyr,update_cols,1,0,3,"list<class<`data.frame`, `tbl`, `tbl_df`>>",1
+tidyr,vals_dedup,-1,0,0,class<`data.frame`>,1
+tidyr,vals_dedup,-1,0,1,list<class<`data.frame`> | character[]>,1
+tidyr,vals_dedup,-1,0,2,list<class<`data.frame`> | double[]>,1
+tidyr,vals_dedup,-1,0,3,list<class<`data.frame`> | ^double[]>,1
+tidyr,vals_dedup,-1,0,4,list<class<`data.frame`> | integer[]>,1
+tidyr,vals_dedup,-1,0,5,list<class<`data.frame`> | logical[]>,1
+tidyr,vals_dedup,0,0,0,class<`data.frame`>,1
+tidyr,vals_dedup,1,0,0,character[],1
+tidyr,vals_dedup,1,0,1,^double[],1
+tidyr,vals_dedup,2,0,0,any,1
+tidyr,vals_dedup,3,0,0,null,1
+tidyr,vals_dedup,3,0,1,class<`function`>,1
+tidyr,vec_fill_fun,-1,0,0,class<`function`>,1
+tidyr,vec_fill_fun,0,0,0,character[],1
+tidyr,vec_repeat,-1,0,0,character[],1
+tidyr,vec_repeat,-1,0,1,integer[],1
+tidyr,vec_repeat,-1,0,2,"class<`data.frame`, `tbl`, `tbl_df`>",1
+tidyr,vec_repeat,0,0,0,character[],1
+tidyr,vec_repeat,0,0,1,integer[],1
+tidyr,vec_repeat,0,0,2,"class<`data.frame`, `tbl`, `tbl_df`>",1
+tidyr,vec_repeat,1,0,0,double,1
+tidyr,vec_repeat,2,0,0,double,1
+tidyr,vec_simplify,-1,0,0,^character[],1
+tidyr,vec_simplify,-1,0,1,list<character[]>,1
+tidyr,vec_simplify,0,0,0,list<character | class<`vctrs_unspecified`>>,1
+tidyr,vec_simplify,0,0,1,list<character[]>,1
+tidyr,wrap_error_names,-1,0,0,"class<`data.frame`, `tbl`, `tbl_df`>",1
+tidyr,wrap_error_names,0,0,0,"class<`data.frame`, `tbl`, `tbl_df`>",1
+tidyr,wrap_vec,-1,0,0,"class<`data.frame`, `tbl`, `tbl_df`>",1
+tidyr,wrap_vec,0,0,0,^character[],1
+tidyr,wrap_vec,0,0,1,^double[],1
+tidyr,wrap_vec,0,0,2,list<double[]>,1
+tidyr,wrap_vec,1,0,0,character[],1
+tidyselect,all_of,-1,0,0,character[],1
+tidyselect,all_of,0,0,0,character[],1
+tidyselect,any_of,-1,0,0,integer,1
+tidyselect,any_of,0,0,0,character[],1
+tidyselect,any_of,1,0,0,...,1
+tidyselect,any_of,2,0,0,character[],1
+tidyselect,are_empty_name,-1,0,0,logical[],1
+tidyselect,are_empty_name,0,0,0,character[],1
+tidyselect,as_indices_impl,-1,0,0,any,1
+tidyselect,as_indices_impl,0,0,0,character[],1
+tidyselect,as_indices_impl,0,0,1,integer[],1
+tidyselect,as_indices_impl,1,0,0,any,1
+tidyselect,as_indices_impl,2,0,0,logical,1
+tidyselect,as_indices_sel_impl,-1,0,0,any,1
+tidyselect,as_indices_sel_impl,0,0,0,character[],1
+tidyselect,as_indices_sel_impl,0,0,1,integer[],1
+tidyselect,as_indices_sel_impl,1,0,0,any,1
+tidyselect,as_indices_sel_impl,2,0,0,logical,1
+tidyselect,as_indices_sel_impl,3,0,0,any,1
+tidyselect,call_expand_dots,-1,0,0,class<`call`>,1
+tidyselect,call_expand_dots,0,0,0,class<`call`>,1
+tidyselect,call_expand_dots,1,0,0,any,1
+tidyselect,call_kind,-1,0,0,character,1
+tidyselect,call_kind,0,0,0,class<`call`>,1
+tidyselect,c_arg_kind,-1,0,0,character,1
+tidyselect,c_arg_kind,0,0,0,"class<`formula`, `quosure`>",1
+tidyselect,c_arg_kind,0,0,1,class<`name`>,1
+tidyselect,check_match,-1,0,0,null,1
+tidyselect,check_match,0,0,0,character[],1
+tidyselect,check_missing,-1,0,0,null,1
+tidyselect,check_missing,0,0,0,integer[],1
+tidyselect,check_negative,-1,0,0,null,1
+tidyselect,check_negative,0,0,0,integer[],1
+tidyselect,chr_as_locations,-1,0,0,any,1
+tidyselect,chr_as_locations,0,0,0,character[],1
+tidyselect,chr_as_locations,1,0,0,character[],1
+tidyselect,combine_names,-1,0,0,integer,1
+tidyselect,combine_names,0,0,0,integer,1
+tidyselect,combine_names,1,0,0,class<`name`>,1
+tidyselect,combine_names,2,0,0,class<`function`>,1
+tidyselect,combine_names,3,0,0,logical,1
+tidyselect,contains,-1,0,0,integer[],1
+tidyselect,contains,0,0,0,character,1
+tidyselect,contains,1,0,0,logical,1
+tidyselect,contains,2,0,0,character[],1
+tidyselect,ends_with,-1,0,0,integer[],1
+tidyselect,ends_with,0,0,0,character,1
+tidyselect,ends_with,1,0,0,logical,1
+tidyselect,ends_with,2,0,0,character[],1
+tidyselect,eval_and,-1,0,0,integer,1
+tidyselect,eval_and,0,0,0,class<`call`>,1
+tidyselect,eval_and,1,0,0,environment,1
+tidyselect,eval_and,2,0,0,environment,1
+tidyselect,eval_bang,-1,0,0,integer[],1
+tidyselect,eval_bang,0,0,0,class<`call`>,1
+tidyselect,eval_bang,1,0,0,environment,1
+tidyselect,eval_bang,2,0,0,environment,1
+tidyselect,eval_c,-1,0,0,any,1
+tidyselect,eval_c,0,0,0,class<`call`>,1
+tidyselect,eval_c,1,0,0,environment,1
+tidyselect,eval_c,2,0,0,any,1
+tidyselect,eval_colon,-1,0,0,integer[],1
+tidyselect,eval_colon,0,0,0,class<`call`>,1
+tidyselect,eval_colon,1,0,0,environment,1
+tidyselect,eval_colon,2,0,0,any,1
+tidyselect,eval_context,-1,0,0,character[],1
+tidyselect,eval_context,-1,0,1,integer[],1
+tidyselect,eval_context,0,0,0,class<`call`>,1
+tidyselect,eval_context,1,0,0,environment,1
+tidyselect,eval_or,-1,0,0,integer[],1
+tidyselect,eval_or,0,0,0,class<`call`>,1
+tidyselect,eval_or,1,0,0,environment,1
+tidyselect,eval_or,2,0,0,environment,1
+tidyselect,eval_rename,-1,0,0,any,1
+tidyselect,eval_rename,0,0,0,class<`call`>,1
+tidyselect,eval_rename,0,0,1,class<`name`>,1
+tidyselect,eval_rename,1,0,0,class<`data.frame`>,1
+tidyselect,eval_rename,2,0,0,environment,1
+tidyselect,eval_rename,3,0,0,...,1
+tidyselect,eval_rename,4,0,0,logical,1
+tidyselect,eval_rename,5,0,0,null,1
+tidyselect,eval_select,-1,0,0,integer[],1
+tidyselect,eval_select,0,0,0,class<`call`>,1
+tidyselect,eval_select,1,0,0,class<`data.frame`>,1
+tidyselect,eval_select,2,0,0,environment,1
+tidyselect,eval_select,3,0,0,...,1
+tidyselect,eval_select,4,0,0,null,1
+tidyselect,eval_select,5,0,0,null,1
+tidyselect,eval_select,6,0,0,logical,1
+tidyselect,eval_select,7,0,0,null,1
+tidyselect,eval_select_impl,-1,0,0,integer[],1
+tidyselect,eval_select_impl,-1,0,1,list<any>,1
+tidyselect,eval_select_impl,0,0,0,null,1
+tidyselect,eval_select_impl,0,0,1,class<`data.frame`>,1
+tidyselect,eval_select_impl,1,0,0,character[],1
+tidyselect,eval_select_impl,2,0,0,class<`call`>,1
+tidyselect,eval_select_impl,2,0,1,"class<`formula`, `quosure`>",1
+tidyselect,eval_select_impl,3,0,0,character[],1
+tidyselect,eval_select_impl,3,0,1,null,1
+tidyselect,eval_select_impl,4,0,0,character[],1
+tidyselect,eval_select_impl,4,0,1,null,1
+tidyselect,eval_select_impl,5,0,0,logical,1
+tidyselect,eval_select_impl,6,0,0,class<`function`>,1
+tidyselect,eval_select_impl,6,0,1,null,1
+tidyselect,eval_select_impl,7,0,0,logical,1
+tidyselect,eval_select_impl,7,0,1,null,1
+tidyselect,eval_slash,-1,0,0,integer,1
+tidyselect,eval_slash,0,0,0,class<`call`>,1
+tidyselect,eval_slash,1,0,0,environment,1
+tidyselect,eval_slash,2,0,0,environment,1
+tidyselect,eval_sym,-1,0,0,integer,1
+tidyselect,eval_sym,0,0,0,class<`name`>,1
+tidyselect,eval_sym,1,0,0,environment,1
+tidyselect,eval_sym,2,0,0,any,1
+tidyselect,eval_sym,3,0,0,logical,1
+tidyselect,everything,-1,0,0,integer[],1
+tidyselect,everything,0,0,0,character[],1
+tidyselect,expr_kind,-1,0,0,character,1
+tidyselect,expr_kind,0,0,0,class<`call`>,1
+tidyselect,expr_kind,0,0,1,class<`name`>,1
+tidyselect,expr_kind,0,0,2,integer[],1
+tidyselect,flat_map_int,-1,0,0,integer[],1
+tidyselect,flat_map_int,0,0,0,character[],1
+tidyselect,flat_map_int,1,0,0,class<`function`>,1
+tidyselect,flat_map_int,2,0,0,...,1
+tidyselect,instrument_base_errors,-1,0,0,any,1
+tidyselect,instrument_base_errors,0,0,0,any,1
+tidyselect,is_character,-1,0,0,logical,1
+tidyselect,is_character,0,0,0,character[],1
+tidyselect,is_character,1,0,0,null,1
+tidyselect,is_data_dups,-1,0,0,logical,1
+tidyselect,is_data_dups,0,0,0,integer,1
+tidyselect,isNamespaceLoaded,-1,0,0,logical,1
+tidyselect,isNamespaceLoaded,0,0,0,character,1
+tidyselect,is_negated,-1,0,0,logical,1
+tidyselect,is_negated,0,0,0,"class<`formula`, `quosure`>",1
+tidyselect,is_negated,0,0,1,class<`name`>,1
+tidyselect,is_negated_colon,-1,0,0,logical,1
+tidyselect,is_negated_colon,0,0,0,class<`call`>,1
+tidyselect,is_negated_colon,0,0,1,"class<`formula`, `quosure`>",1
+tidyselect,is_negated_colon,0,0,2,class<`name`>,1
+tidyselect,last_col,-1,0,0,integer,1
+tidyselect,last_col,0,0,0,double,1
+tidyselect,last_col,1,0,0,character[],1
+tidyselect,local_data,-1,0,0,null,1
+tidyselect,local_data,0,0,0,class<`data.frame`>,1
+tidyselect,local_data,0,0,1,null,1
+tidyselect,local_data,1,0,0,environment,1
+tidyselect,local_vars,-1,0,0,character[],1
+tidyselect,local_vars,-1,0,1,null,1
+tidyselect,local_vars,0,0,0,character[],1
+tidyselect,local_vars,1,0,0,environment,1
+tidyselect,loc_validate,-1,0,0,integer[],1
+tidyselect,loc_validate,0,0,0,integer[],1
+tidyselect,loc_validate,1,0,0,character[],1
+tidyselect,matches,-1,0,0,integer[],1
+tidyselect,matches,0,0,0,character,1
+tidyselect,matches,1,0,0,logical,1
+tidyselect,matches,2,0,0,logical,1
+tidyselect,matches,3,0,0,character[],1
+tidyselect,match_vars,-1,0,0,integer[],1
+tidyselect,match_vars,0,0,0,character[],1
+tidyselect,match_vars,1,0,0,character[],1
+tidyselect,maybe_hotpatch_dplyr,-1,0,0,logical,1
+tidyselect,maybe_hotpatch_dplyr,0,0,0,...,1
+tidyselect,named,-1,0,0,integer[],1
+tidyselect,named,0,0,0,integer[],1
+tidyselect,node_compact_missing,-1,0,0,class<`call`>,1
+tidyselect,node_compact_missing,0,0,0,class<`call`>,1
+tidyselect,node_poke_tail,-1,0,0,"class<`list`, `quosures`>",1
+tidyselect,node_poke_tail,0,0,0,"class<`list`, `quosures`>",1
+tidyselect,node_poke_tail,1,0,0,null,1
+tidyselect,node_tail,-1,0,0,"class<`list`, `quosures`>",1
+tidyselect,node_tail,0,0,0,"class<`list`, `quosures`>",1
+tidyselect,one_of,-1,0,0,integer[],1
+tidyselect,one_of,0,0,0,...,1
+tidyselect,one_of,1,0,0,character[],1
+tidyselect,peek_vars,-1,0,0,character[],1
+tidyselect,peek_vars,0,0,0,...,1
+tidyselect,peek_vars,1,0,0,character,1
+tidyselect,peek_vars,1,0,1,null,1
+tidyselect,poke_data,-1,0,0,null,1
+tidyselect,poke_data,-1,0,1,class<`data.frame`>,1
+tidyselect,poke_data,0,0,0,class<`data.frame`>,1
+tidyselect,poke_data,0,0,1,null,1
+tidyselect,poke_vars,-1,0,0,character[],1
+tidyselect,poke_vars,-1,0,1,null,1
+tidyselect,poke_vars,0,0,0,character[],1
+tidyselect,poke_vars,0,0,1,null,1
+tidyselect,propagate_names,-1,0,0,class<`data.frame`>,1
+tidyselect,propagate_names,0,0,0,class<`data.frame`>,1
+tidyselect,propagate_names,1,0,0,any,1
+tidyselect,pull_as_location2,-1,0,0,integer,1
+tidyselect,pull_as_location2,0,0,0,double,1
+tidyselect,pull_as_location2,1,0,0,integer,1
+tidyselect,pull_as_location2,2,0,0,any,1
+tidyselect,quo_get_expr2,-1,0,0,class<`call`>,1
+tidyselect,quo_get_expr2,-1,0,1,class<`name`>,1
+tidyselect,quo_get_expr2,0,0,0,class<`call`>,1
+tidyselect,quo_get_expr2,0,0,1,"class<`formula`, `quosure`>",1
+tidyselect,quo_get_expr2,0,0,2,class<`name`>,1
+tidyselect,quo_get_expr2,1,0,0,any,1
+tidyselect,reduce_sels,-1,0,0,any,1
+tidyselect,reduce_sels,0,0,0,pairlist,1
+tidyselect,reduce_sels,0,0,1,"class<`list`, `quosures`>",1
+tidyselect,reduce_sels,1,0,0,environment,1
+tidyselect,reduce_sels,2,0,0,any,1
+tidyselect,reduce_sels,3,0,0,class<`call`>,1
+tidyselect,reduce_sels,3,0,1,integer[],1
+tidyselect,rename_impl,-1,0,0,any,1
+tidyselect,rename_impl,0,0,0,class<`data.frame`>,1
+tidyselect,rename_impl,1,0,0,character[],1
+tidyselect,rename_impl,2,0,0,"class<`formula`, `quosure`>",1
+tidyselect,rename_impl,3,0,0,logical,1
+tidyselect,rename_impl,4,0,0,null,1
+tidyselect,scoped_vars,-1,0,0,character[],1
+tidyselect,scoped_vars,-1,0,1,null,1
+tidyselect,scoped_vars,0,0,0,character[],1
+tidyselect,scoped_vars,1,0,0,environment,1
+tidyselect,sel_complement,-1,0,0,integer[],1
+tidyselect,sel_complement,0,0,0,integer[],1
+tidyselect,sel_complement,1,0,0,character[],1
+tidyselect,sel_diff,-1,0,0,integer[],1
+tidyselect,sel_diff,0,0,0,integer[],1
+tidyselect,sel_diff,1,0,0,integer[],1
+tidyselect,sel_diff,2,0,0,character[],1
+tidyselect,sel_intersect,-1,0,0,integer,1
+tidyselect,sel_intersect,0,0,0,integer[],1
+tidyselect,sel_intersect,1,0,0,integer[],1
+tidyselect,sel_operation,-1,0,0,integer[],1
+tidyselect,sel_operation,0,0,0,integer[],1
+tidyselect,sel_operation,1,0,0,integer[],1
+tidyselect,sel_operation,2,0,0,class<`function`>,1
+tidyselect,sel_union,-1,0,0,integer[],1
+tidyselect,sel_union,0,0,0,integer[],1
+tidyselect,sel_union,1,0,0,integer[],1
+tidyselect,sel_unique,-1,0,0,integer[],1
+tidyselect,sel_unique,0,0,0,integer[],1
+tidyselect,set_diff,-1,0,0,integer[],1
+tidyselect,set_diff,0,0,0,integer[],1
+tidyselect,set_diff,1,0,0,integer[],1
+tidyselect,set_intersect,-1,0,0,character,1
+tidyselect,set_intersect,-1,0,1,integer,1
+tidyselect,set_intersect,0,0,0,character[],1
+tidyselect,set_intersect,0,0,1,integer[],1
+tidyselect,set_intersect,1,0,0,^character[],1
+tidyselect,set_intersect,1,0,1,integer[],1
+tidyselect,set_union,-1,0,0,class<`data.frame`>,1
+tidyselect,set_union,-1,0,1,integer[],1
+tidyselect,set_union,0,0,0,class<`data.frame`>,1
+tidyselect,set_union,0,0,1,integer[],1
+tidyselect,set_union,1,0,0,class<`data.frame`>,1
+tidyselect,set_union,1,0,1,integer[],1
+tidyselect,starts_with,-1,0,0,integer[],1
+tidyselect,starts_with,0,0,0,character[],1
+tidyselect,starts_with,1,0,0,logical,1
+tidyselect,starts_with,2,0,0,character[],1
+tidyselect,subscript_action,-1,0,0,character,1
+tidyselect,subscript_action,0,0,0,character,1
+tidyselect,unnegate,-1,0,0,"class<`formula`, `quosure`>",1
+tidyselect,unnegate,0,0,0,"class<`formula`, `quosure`>",1
+tidyselect,validate_type,-1,0,0,character,1
+tidyselect,validate_type,0,0,0,character,1
+tidyselect,vars_pull,-1,0,0,character,1
+tidyselect,vars_pull,0,0,0,character[],1
+tidyselect,vars_pull,1,0,0,any,1
+tidyselect,vars_select,-1,0,0,any,1
+tidyselect,vars_select,0,0,0,character[],1
+tidyselect,vars_select,1,0,0,...,1
+tidyselect,vars_select,2,0,0,character[],1
+tidyselect,vars_select,3,0,0,character[],1
+tidyselect,vars_select,4,0,0,logical,1
+tidyselect,vars_select_eval,-1,0,0,any,1
+tidyselect,vars_select_eval,0,0,0,any,1
+tidyselect,vars_select_eval,1,0,0,class<`call`>,1
+tidyselect,vars_select_eval,1,0,1,"class<`formula`, `quosure`>",1
+tidyselect,vars_select_eval,2,0,0,logical,1
+tidyselect,vars_select_eval,3,0,0,null,1
+tidyselect,vars_select_eval,3,0,1,class<`data.frame`>,1
+tidyselect,vars_select_eval,4,0,0,class<`function`>,1
+tidyselect,vars_select_eval,4,0,1,null,1
+tidyselect,vars_select_eval,5,0,0,logical,1
+tidyselect,vars_select_eval,5,0,1,null,1
+tidyselect,vars_select_eval,6,0,0,any,1
+tidyselect,vars_validate,-1,0,0,character[],1
+tidyselect,vars_validate,0,0,0,character[],1
+tidyselect,vec_is_coercible,-1,0,0,logical,1
+tidyselect,vec_is_coercible,0,0,0,character[],1
+tidyselect,vec_is_coercible,1,0,0,character[],1
+tidyselect,vec_is_coercible,2,0,0,...,1
+tidyselect,vec_is_coercible,3,0,0,character,1
+tidyselect,vec_is_coercible,4,0,0,character,1
+tidyselect,walk_data_tree,-1,0,0,any,1
+tidyselect,walk_data_tree,0,0,0,class<`call`>,1
+tidyselect,walk_data_tree,0,0,1,"class<`formula`, `quosure`>",1
+tidyselect,walk_data_tree,0,0,2,class<`name`>,1
+tidyselect,walk_data_tree,0,0,3,integer[],1
+tidyselect,walk_data_tree,1,0,0,environment,1
+tidyselect,walk_data_tree,2,0,0,any,1
+tidyselect,walk_data_tree,3,0,0,logical,1
+tidyselect,walk_operand,-1,0,0,integer[],1
+tidyselect,walk_operand,0,0,0,class<`call`>,1
+tidyselect,walk_operand,1,0,0,environment,1
+tidyselect,walk_operand,2,0,0,environment,1
+tidyselect,which_vars,-1,0,0,integer[],1
+tidyselect,which_vars,0,0,0,character,1
+tidyselect,which_vars,1,0,0,character[],1
+tidyselect,with_subscript_errors,-1,0,0,any,1
+tidyselect,with_subscript_errors,0,0,0,any,1
+tidyselect,with_subscript_errors,1,0,0,any,1
+tidyselect,with_vars,-1,0,0,integer[],1
+tidyselect,with_vars,0,0,0,character[],1
+tidyselect,with_vars,1,0,0,integer[],1
+tidytext,augment.LDA,-1,0,0,"class<`data.frame`, `tbl`, `tbl_df`>",1
+tidytext,augment.LDA,0,0,0,class<`LDA_VEM`>,1
+tidytext,augment.LDA,1,0,0,"class<`DocumentTermMatrix`, `simple_triplet_matrix`>",1
+tidytext,augment.LDA,2,0,0,...,1
+tidytext,augment_topicmodels,-1,0,0,"class<`data.frame`, `tbl`, `tbl_df`>",1
+tidytext,augment_topicmodels,0,0,0,class<`LDA_VEM`>,1
+tidytext,augment_topicmodels,1,0,0,"class<`DocumentTermMatrix`, `simple_triplet_matrix`>",1
+tidytext,augment_topicmodels,2,0,0,...,1
+tidytext,bind_tf_idf,-1,0,0,"class<`data.frame`, `tbl`, `tbl_df`>",1
+tidytext,bind_tf_idf,0,0,0,"class<`data.frame`, `tbl`, `tbl_df`>",1
+tidytext,bind_tf_idf,1,0,0,any,1
+tidytext,bind_tf_idf,2,0,0,any,1
+tidytext,bind_tf_idf,3,0,0,any,1
+tidytext,bind_tf_idf.data.frame,-1,0,0,"class<`data.frame`, `tbl`, `tbl_df`>",1
+tidytext,bind_tf_idf.data.frame,0,0,0,"class<`data.frame`, `tbl`, `tbl_df`>",1
+tidytext,bind_tf_idf.data.frame,1,0,0,any,1
+tidytext,bind_tf_idf.data.frame,2,0,0,any,1
+tidytext,bind_tf_idf.data.frame,3,0,0,any,1
+tidytext,cast_dfm,-1,0,0,class<`dfm`>,1
+tidytext,cast_dfm,0,0,0,"class<`data.frame`, `tbl`, `tbl_df`>",1
+tidytext,cast_dfm,1,0,0,any,1
+tidytext,cast_dfm,2,0,0,any,1
+tidytext,cast_dfm,3,0,0,any,1
+tidytext,cast_dfm,4,0,0,...,1
+tidytext,cast_dtm,-1,0,0,"class<`DocumentTermMatrix`, `simple_triplet_matrix`>",1
+tidytext,cast_dtm,0,0,0,"class<`data.frame`, `tbl`, `tbl_df`>",1
+tidytext,cast_dtm,1,0,0,any,1
+tidytext,cast_dtm,2,0,0,any,1
+tidytext,cast_dtm,3,0,0,any,1
+tidytext,cast_dtm,4,0,0,"class<`WeightFunction`, `function`>",1
+tidytext,cast_dtm,5,0,0,...,1
+tidytext,cast_sparse,-1,0,0,class<`dgCMatrix`>,1
+tidytext,cast_sparse,0,0,0,"class<`data.frame`, `tbl`, `tbl_df`>",1
+tidytext,cast_sparse,1,0,0,any,1
+tidytext,cast_sparse,2,0,0,any,1
+tidytext,cast_sparse,3,0,0,any,1
+tidytext,cast_sparse,4,0,0,...,1
+tidytext,cast_tdm,-1,0,0,"class<`TermDocumentMatrix`, `simple_triplet_matrix`>",1
+tidytext,cast_tdm,0,0,0,"class<`data.frame`, `tbl`, `tbl_df`>",1
+tidytext,cast_tdm,1,0,0,any,1
+tidytext,cast_tdm,2,0,0,any,1
+tidytext,cast_tdm,3,0,0,any,1
+tidytext,cast_tdm,4,0,0,"class<`WeightFunction`, `function`>",1
+tidytext,cast_tdm,5,0,0,...,1
+tidytext,get_sentiments,-1,0,0,"class<`data.frame`, `tbl`, `tbl_df`>",1
+tidytext,get_sentiments,0,0,0,character,1
+tidytext,get_stopwords,-1,0,0,"class<`data.frame`, `tbl`, `tbl_df`>",1
+tidytext,get_stopwords,0,0,0,character,1
+tidytext,get_stopwords,1,0,0,character,1
+tidytext,reorder_within,-1,0,0,class<`factor`>,1
+tidytext,reorder_within,0,0,0,character[],1
+tidytext,reorder_within,1,0,0,double[],1
+tidytext,reorder_within,2,0,0,integer[],1
+tidytext,reorder_within,3,0,0,class<`standardGeneric`>,1
+tidytext,reorder_within,4,0,0,character,1
+tidytext,reorder_within,5,0,0,...,1
+tidytext,scale_x_reordered,-1,0,0,"class<`Scale`, `ScaleDiscrete`, `ScaleDiscretePosition`, `gg`, `ggproto`>",1
+tidytext,scale_x_reordered,0,0,0,...,1
+tidytext,scale_x_reordered,1,0,0,character,1
+tidytext,tidy.corpus,-1,0,0,"class<`data.frame`, `tbl`, `tbl_df`>",1
+tidytext,tidy.corpus,0,0,0,class<`corpus`>,1
+tidytext,tidy.corpus,1,0,0,...,1
+tidytext,tidy.Corpus,-1,0,0,"class<`data.frame`, `tbl`, `tbl_df`>",1
+tidytext,tidy.Corpus,0,0,0,"class<`Corpus`, `VCorpus`>",1
+tidytext,tidy.Corpus,1,0,0,character,1
+tidytext,tidy.Corpus,1,0,1,null,1
+tidytext,tidy.Corpus,2,0,0,...,1
+tidytext,tidy.dfm,-1,0,0,"class<`data.frame`, `tbl`, `tbl_df`>",1
+tidytext,tidy.dfm,0,0,0,class<`dfm`>,1
+tidytext,tidy.dfm,1,0,0,...,1
+tidytext,tidy.DocumentTermMatrix,-1,0,0,"class<`data.frame`, `tbl`, `tbl_df`>",1
+tidytext,tidy.DocumentTermMatrix,0,0,0,"class<`DocumentTermMatrix`, `simple_triplet_matrix`>",1
+tidytext,tidy.DocumentTermMatrix,1,0,0,...,1
+tidytext,tidy.LDA,-1,0,0,"class<`data.frame`, `tbl`, `tbl_df`>",1
+tidytext,tidy.LDA,0,0,0,class<`LDA_VEM`>,1
+tidytext,tidy.LDA,1,0,0,character[],1
+tidytext,tidy.LDA,2,0,0,logical,1
+tidytext,tidy.LDA,3,0,0,...,1
+tidytext,tidy.simple_triplet_matrix,-1,0,0,"class<`data.frame`, `tbl`, `tbl_df`>",1
+tidytext,tidy.simple_triplet_matrix,0,0,0,"class<`DocumentTermMatrix`, `simple_triplet_matrix`>",1
+tidytext,tidy.simple_triplet_matrix,0,0,1,class<`simple_triplet_matrix`>,1
+tidytext,tidy.simple_triplet_matrix,1,0,0,character[],1
+tidytext,tidy.simple_triplet_matrix,1,0,1,null,1
+tidytext,tidy.simple_triplet_matrix,2,0,0,character[],1
+tidytext,tidy.simple_triplet_matrix,2,0,1,null,1
+tidytext,tidy.simple_triplet_matrix,3,0,0,...,1
+tidytext,tidy_topicmodels,-1,0,0,"class<`data.frame`, `tbl`, `tbl_df`>",1
+tidytext,tidy_topicmodels,0,0,0,class<`LDA_VEM`>,1
+tidytext,tidy_topicmodels,1,0,0,character[],1
+tidytext,tidy_topicmodels,2,0,0,logical,1
+tidytext,tidy_topicmodels,3,0,0,...,1
+tidytext,tidy_triplet,-1,0,0,"class<`data.frame`, `tbl`, `tbl_df`>",1
+tidytext,tidy_triplet,0,0,0,any,1
+tidytext,tidy_triplet,1,0,0,list<double[]>,1
+tidytext,tidy_triplet,1,0,1,"class<`data.frame`, `sparseSummary`>",1
+tidytext,tidy_triplet,2,0,0,character[],1
+tidytext,tidy_triplet,2,0,1,null,1
+tidytext,tidy_triplet,3,0,0,character[],1
+tidytext,tidy_triplet,3,0,1,null,1
+tidytext,unnest_characters,-1,0,0,"class<`data.frame`, `tbl`, `tbl_df`>",1
+tidytext,unnest_characters,0,0,0,"class<`data.frame`, `tbl`, `tbl_df`>",1
+tidytext,unnest_characters,1,0,0,any,1
+tidytext,unnest_characters,2,0,0,any,1
+tidytext,unnest_characters,3,0,0,logical,1
+tidytext,unnest_characters,4,0,0,character[],1
+tidytext,unnest_characters,5,0,0,logical,1
+tidytext,unnest_characters,6,0,0,logical,1
+tidytext,unnest_characters,7,0,0,null,1
+tidytext,unnest_character_shingles,-1,0,0,"class<`data.frame`, `tbl`, `tbl_df`>",1
+tidytext,unnest_character_shingles,0,0,0,"class<`data.frame`, `tbl`, `tbl_df`>",1
+tidytext,unnest_character_shingles,1,0,0,any,1
+tidytext,unnest_character_shingles,2,0,0,any,1
+tidytext,unnest_character_shingles,3,0,0,double,1
+tidytext,unnest_character_shingles,4,0,0,double,1
+tidytext,unnest_character_shingles,5,0,0,logical,1
+tidytext,unnest_character_shingles,6,0,0,character[],1
+tidytext,unnest_character_shingles,7,0,0,logical,1
+tidytext,unnest_ptb,-1,0,0,"class<`data.frame`, `tbl`, `tbl_df`>",1
+tidytext,unnest_ptb,0,0,0,"class<`data.frame`, `tbl`, `tbl_df`>",1
+tidytext,unnest_ptb,1,0,0,any,1
+tidytext,unnest_ptb,2,0,0,any,1
+tidytext,unnest_ptb,3,0,0,character[],1
+tidytext,unnest_ptb,4,0,0,logical,1
+tidytext,unnest_ptb,5,0,0,logical,1
+tidytext,unnest_ptb,6,0,0,null,1
+tidytext,unnest_ptb,7,0,0,...,1
+tidytext,unnest_tokens,-1,0,0,"class<`data.frame`, `grouped_df`, `tbl`, `tbl_df`>",1
+tidytext,unnest_tokens,-1,0,1,"class<`data.frame`, `tbl`, `tbl_df`>",1
+tidytext,unnest_tokens,0,0,0,"class<`data.frame`, `grouped_df`, `tbl`, `tbl_df`>",1
+tidytext,unnest_tokens,0,0,1,"class<`data.frame`, `tbl`, `tbl_df`>",1
+tidytext,unnest_tokens,1,0,0,any,1
+tidytext,unnest_tokens,2,0,0,any,1
+tidytext,unnest_tokens,3,0,0,character,1
+tidytext,unnest_tokens,3,0,1,class<`function`>,1
+tidytext,unnest_tokens,4,0,0,any,1
+tidytext,unnest_tokens,5,0,0,logical,1
+tidytext,unnest_tokens,6,0,0,logical,1
+tidytext,unnest_tokens,7,0,0,null,1
+tidytext,unnest_tokens,7,0,1,logical,1
+tidytext,unnest_tokens.data.frame,-1,0,0,"class<`data.frame`, `grouped_df`, `tbl`, `tbl_df`>",1
+tidytext,unnest_tokens.data.frame,-1,0,1,"class<`data.frame`, `tbl`, `tbl_df`>",1
+tidytext,unnest_tokens.data.frame,0,0,0,"class<`data.frame`, `grouped_df`, `tbl`, `tbl_df`>",1
+tidytext,unnest_tokens.data.frame,0,0,1,"class<`data.frame`, `tbl`, `tbl_df`>",1
+tidytext,unnest_tokens.data.frame,1,0,0,any,1
+tidytext,unnest_tokens.data.frame,2,0,0,any,1
+tidytext,unnest_tokens.data.frame,3,0,0,character,1
+tidytext,unnest_tokens.data.frame,3,0,1,class<`function`>,1
+tidytext,unnest_tokens.data.frame,4,0,0,character[],1
+tidytext,unnest_tokens.data.frame,5,0,0,logical,1
+tidytext,unnest_tokens.data.frame,6,0,0,logical,1
+tidytext,unnest_tokens.data.frame,7,0,0,null,1
+tidytext,unnest_tokens.data.frame,7,0,1,logical,1
+tidytext,unnest_tweets,-1,0,0,"class<`data.frame`, `tbl`, `tbl_df`>",1
+tidytext,unnest_tweets,0,0,0,"class<`data.frame`, `tbl`, `tbl_df`>",1
+tidytext,unnest_tweets,1,0,0,any,1
+tidytext,unnest_tweets,2,0,0,any,1
+tidytext,unnest_tweets,3,0,0,logical,1
+tidytext,unnest_tweets,4,0,0,logical,1
+tidytext,unnest_tweets,5,0,0,character[],1
+tidytext,unnest_tweets,6,0,0,logical,1
+tidytext,unnest_tweets,7,0,0,logical,1
+timeSeries,%||%,-1,0,0,character[],1
+timeSeries,%||%,-1,0,1,double[],1
+timeSeries,%||%,0,0,0,character[],1
+timeSeries,%||%,0,0,1,null,1
+timeSeries,%||%,0,0,2,double[],1
+timeSeries,%||%,1,0,0,any,1
+timeSeries,aggregate,-1,0,0,class<`timeSeries`>,1
+timeSeries,aggregate,0,0,0,class<`timeSeries`>,1
+timeSeries,aggregate,1,0,0,...,1
+timeSeries,.aggregate.timeSeries,-1,0,0,class<`timeSeries`>,1
+timeSeries,.aggregate.timeSeries,0,0,0,class<`timeSeries`>,1
+timeSeries,.aggregate.timeSeries,1,0,0,class<`timeDate`>,1
+timeSeries,.aggregate.timeSeries,2,0,0,class<`function`>,1
+timeSeries,.aggregate.timeSeries,3,0,0,...,1
+timeSeries,alignDailySeries,-1,0,0,class<`timeSeries`>,1
+timeSeries,alignDailySeries,0,0,0,class<`timeSeries`>,1
+timeSeries,alignDailySeries,1,0,0,character[],1
+timeSeries,alignDailySeries,2,0,0,logical,1
+timeSeries,alignDailySeries,3,0,0,null,1
+timeSeries,alignDailySeries,4,0,0,character,1
+timeSeries,alignDailySeries,5,0,0,character,1
+timeSeries,alignDailySeries,6,0,0,...,1
+timeSeries,.align.timeSeries,-1,0,0,class<`timeSeries`>,1
+timeSeries,.align.timeSeries,0,0,0,class<`timeSeries`>,1
+timeSeries,.align.timeSeries,1,0,0,character,1
+timeSeries,.align.timeSeries,2,0,0,character,1
+timeSeries,.align.timeSeries,3,0,0,character[],1
+timeSeries,.align.timeSeries,4,0,0,logical,1
+timeSeries,.align.timeSeries,5,0,0,...,1
+timeSeries,.appendList,-1,0,0,list<any>,1
+timeSeries,.appendList,0,0,0,list<any>,1
+timeSeries,.appendList,0,0,1,null,1
+timeSeries,.appendList,1,0,0,null,1
+timeSeries,apply,-1,0,0,class<`matrix`>,1
+timeSeries,apply,-1,0,1,class<`timeSeries`>,1
+timeSeries,apply,0,0,0,class<`timeSeries`>,1
+timeSeries,apply,1,0,0,double,1
+timeSeries,apply,2,0,0,class<`function`>,1
+timeSeries,apply,2,0,1,class<`standardGeneric`>,1
+timeSeries,apply,3,0,0,...,1
+timeSeries,applySeries,-1,0,0,class<`timeSeries`>,1
+timeSeries,applySeries,0,0,0,class<`timeSeries`>,1
+timeSeries,applySeries,1,0,0,class<`timeDate`>,1
+timeSeries,applySeries,2,0,0,class<`timeDate`>,1
+timeSeries,applySeries,3,0,0,any,1
+timeSeries,applySeries,4,0,0,class<`function`>,1
+timeSeries,applySeries,5,0,0,null,1
+timeSeries,applySeries,6,0,0,character,1
+timeSeries,applySeries,7,0,0,character,1
+timeSeries,as.data.frame,-1,0,0,class<`data.frame`>,1
+timeSeries,as.data.frame,0,0,0,class<`timeSeries`>,1
+timeSeries,as.data.frame,1,0,0,null,1
+timeSeries,as.data.frame,2,0,0,logical,1
+timeSeries,as.data.frame,3,0,0,...,1
+timeSeries,.as.data.frame.timeSeries,-1,0,0,class<`data.frame`>,1
+timeSeries,.as.data.frame.timeSeries,0,0,0,class<`timeSeries`>,1
+timeSeries,.as.data.frame.timeSeries,1,0,0,null,1
+timeSeries,.as.data.frame.timeSeries,2,0,0,any,1
+timeSeries,.as.data.frame.timeSeries,3,0,0,...,1
+timeSeries,as.data.frame.timeSeries,-1,0,0,class<`data.frame`>,1
+timeSeries,as.data.frame.timeSeries,0,0,0,class<`timeSeries`>,1
+timeSeries,as.data.frame.timeSeries,1,0,0,...,1
+timeSeries,as.list,-1,0,0,list<double[]>,1
+timeSeries,as.list,0,0,0,class<`timeSeries`>,1
+timeSeries,as.list,1,0,0,...,1
+timeSeries,.as.list.timeSeries,-1,0,0,list<double[]>,1
+timeSeries,.as.list.timeSeries,0,0,0,class<`timeSeries`>,1
+timeSeries,.as.list.timeSeries,1,0,0,...,1
+timeSeries,as.matrix,-1,0,0,class<`matrix`>,1
+timeSeries,as.matrix,0,0,0,class<`timeSeries`>,1
+timeSeries,as.matrix,1,0,0,...,1
+timeSeries,.as.matrix.timeSeries,-1,0,0,class<`matrix`>,1
+timeSeries,.as.matrix.timeSeries,0,0,0,class<`timeSeries`>,1
+timeSeries,.as.matrix.timeSeries,1,0,0,...,1
+timeSeries,as.timeSeries,-1,0,0,class<`timeSeries`>,1
+timeSeries,as.timeSeries,0,0,0,character,1
+timeSeries,as.timeSeries,0,0,1,class<`data.frame`>,1
+timeSeries,as.timeSeries,0,0,2,class<`matrix`>,1
+timeSeries,as.timeSeries,0,0,3,class<`timeSeries`>,1
+timeSeries,as.timeSeries,1,0,0,...,1
+timeSeries,as.timeSeries.character,-1,0,0,class<`timeSeries`>,1
+timeSeries,as.timeSeries.character,0,0,0,character,1
+timeSeries,as.timeSeries.character,1,0,0,...,1
+timeSeries,as.timeSeries.data.frame,-1,0,0,class<`timeSeries`>,1
+timeSeries,as.timeSeries.data.frame,0,0,0,class<`data.frame`>,1
+timeSeries,as.timeSeries.data.frame,1,0,0,...,1
+timeSeries,as.timeSeries.default,-1,0,0,class<`timeSeries`>,1
+timeSeries,as.timeSeries.default,0,0,0,class<`matrix`>,1
+timeSeries,as.timeSeries.default,0,0,1,class<`timeSeries`>,1
+timeSeries,as.timeSeries.default,1,0,0,...,1
+timeSeries,attach,-1,0,0,environment,1
+timeSeries,attach,0,0,0,class<`timeSeries`>,1
+timeSeries,attach,1,0,0,double,1
+timeSeries,attach,2,0,0,character,1
+timeSeries,attach,3,0,0,logical,1
+timeSeries,.axTicksByTime2,-1,0,0,double[],1
+timeSeries,.axTicksByTime2,0,0,0,class<`timeSeries`>,1
+timeSeries,.axTicksByTime2,1,0,0,character,1
+timeSeries,.axTicksByTime2,2,0,0,double,1
+timeSeries,.axTicksByTime2,3,0,0,logical,1
+timeSeries,.axTicksByTime2,4,0,0,logical,1
+timeSeries,.axTicksByTime2,5,0,0,logical,1
+timeSeries,.axTicksByTime2,6,0,0,double,1
+timeSeries,.axTicksByTime2,7,0,0,double,1
+timeSeries,colCummaxs,-1,0,0,class<`matrix`>,1
+timeSeries,colCummaxs,-1,0,1,class<`timeSeries`>,1
+timeSeries,colCummaxs,0,0,0,class<`matrix`>,1
+timeSeries,colCummaxs,0,0,1,class<`timeSeries`>,1
+timeSeries,colCummaxs,1,0,0,logical,1
+timeSeries,colCummaxs,2,0,0,...,1
+timeSeries,colCummaxs,-1,1,0,class<`matrix`>,1
+timeSeries,colCummaxs,0,1,0,class<`matrix`>,1
+timeSeries,colCummaxs,1,1,0,logical,1
+timeSeries,colCummaxs,2,1,0,...,1
+timeSeries,colCummaxs,-1,2,0,class<`timeSeries`>,1
+timeSeries,colCummaxs,0,2,0,class<`timeSeries`>,1
+timeSeries,colCummaxs,1,2,0,logical,1
+timeSeries,colCummaxs,2,2,0,...,1
+timeSeries,colCumprods,-1,0,0,class<`matrix`>,1
+timeSeries,colCumprods,0,0,0,class<`matrix`>,1
+timeSeries,colCumprods,1,0,0,logical,1
+timeSeries,colCumprods,2,0,0,...,1
+timeSeries,colCumprods,-1,1,0,class<`timeSeries`>,1
+timeSeries,colCumprods,0,1,0,class<`timeSeries`>,1
+timeSeries,colCumprods,1,1,0,logical,1
+timeSeries,colCumprods,2,1,0,...,1
+timeSeries,colCumprods,-1,2,0,class<`matrix`>,1
+timeSeries,colCumprods,-1,2,1,class<`timeSeries`>,1
+timeSeries,colCumprods,0,2,0,class<`matrix`>,1
+timeSeries,colCumprods,0,2,1,class<`timeSeries`>,1
+timeSeries,colCumprods,1,2,0,logical,1
+timeSeries,colCumprods,2,2,0,...,1
+timeSeries,colCumsums,-1,0,0,class<`timeSeries`>,1
+timeSeries,colCumsums,0,0,0,class<`timeSeries`>,1
+timeSeries,colCumsums,1,0,0,logical,1
+timeSeries,colCumsums,2,0,0,...,1
+timeSeries,colCumsums,-1,1,0,class<`matrix`>,1
+timeSeries,colCumsums,0,1,0,class<`matrix`>,1
+timeSeries,colCumsums,1,1,0,logical,1
+timeSeries,colCumsums,2,1,0,...,1
+timeSeries,colCumsums,-1,2,0,class<`matrix`>,1
+timeSeries,colCumsums,-1,2,1,class<`timeSeries`>,1
+timeSeries,colCumsums,0,2,0,class<`matrix`>,1
+timeSeries,colCumsums,0,2,1,class<`timeSeries`>,1
+timeSeries,colCumsums,1,2,0,logical,1
+timeSeries,colCumsums,2,2,0,...,1
+timeSeries,colnames,-1,0,0,character[],1
+timeSeries,colnames,0,0,0,class<`timeSeries`>,1
+timeSeries,colnames,1,0,0,logical,1
+timeSeries,colnames,2,0,0,character,1
+timeSeries,colnames<-,-1,0,0,class<`timeSeries`>,1
+timeSeries,colnames<-,0,0,0,class<`timeSeries`>,1
+timeSeries,colnames<-,1,0,0,character[],1
+timeSeries,.colorwheelPalette,-1,0,0,character[],1
+timeSeries,.colorwheelPalette,0,0,0,double,1
+timeSeries,colQuantiles,-1,0,0,double[],1
+timeSeries,colQuantiles,0,0,0,class<`matrix`>,1
+timeSeries,colQuantiles,1,0,0,double,1
+timeSeries,colQuantiles,2,0,0,...,1
+timeSeries,colStats,-1,0,0,double[],1
+timeSeries,colStats,0,0,0,class<`matrix`>,1
+timeSeries,colStats,1,0,0,character,1
+timeSeries,colStats,1,0,1,class<`function`>,1
+timeSeries,colStats,2,0,0,...,1
+timeSeries,comment,-1,0,0,character,1
+timeSeries,comment,0,0,0,class<`timeSeries`>,1
+timeSeries,comment<-,-1,0,0,class<`timeSeries`>,1
+timeSeries,comment<-,0,0,0,class<`timeSeries`>,1
+timeSeries,comment<-,1,0,0,character,1
+timeSeries,countMonthlyRecords,-1,0,0,class<`timeSeries`>,1
+timeSeries,countMonthlyRecords,0,0,0,class<`timeSeries`>,1
+timeSeries,cumulated,-1,0,0,class<`timeSeries`>,1
+timeSeries,cumulated,0,0,0,class<`timeSeries`>,1
+timeSeries,cumulated,1,0,0,...,1
+timeSeries,cumulated.default,-1,0,0,class<`timeSeries`>,1
+timeSeries,cumulated.default,0,0,0,class<`timeSeries`>,1
+timeSeries,cumulated.default,1,0,0,character[],1
+timeSeries,cumulated.default,2,0,0,logical,1
+timeSeries,cumulated.default,3,0,0,...,1
+timeSeries,daily2monthly,-1,0,0,class<`timeSeries`>,1
+timeSeries,daily2monthly,0,0,0,class<`timeSeries`>,1
+timeSeries,daily2monthly,1,0,0,logical,1
+timeSeries,daily2weekly,-1,0,0,class<`timeSeries`>,1
+timeSeries,daily2weekly,0,0,0,class<`timeSeries`>,1
+timeSeries,daily2weekly,1,0,0,character,1
+timeSeries,daily2weekly,2,0,0,logical,1
+timeSeries,description,-1,0,0,character,1
+timeSeries,diff,-1,0,0,class<`timeSeries`>,1
+timeSeries,diff,0,0,0,class<`timeSeries`>,1
+timeSeries,diff,1,0,0,...,1
+timeSeries,.diff.timeSeries,-1,0,0,class<`timeSeries`>,1
+timeSeries,.diff.timeSeries,0,0,0,class<`timeSeries`>,1
+timeSeries,.diff.timeSeries,1,0,0,double,1
+timeSeries,.diff.timeSeries,2,0,0,double,1
+timeSeries,.diff.timeSeries,3,0,0,logical,1
+timeSeries,.diff.timeSeries,4,0,0,any,1
+timeSeries,.diff.timeSeries,5,0,0,...,1
+timeSeries,drawdowns,-1,0,0,class<`timeSeries`>,1
+timeSeries,drawdowns,0,0,0,class<`timeSeries`>,1
+timeSeries,drawdowns,1,0,0,...,1
+timeSeries,drawdownsStats,-1,0,0,any,1
+timeSeries,drawdownsStats,0,0,0,class<`timeSeries`>,1
+timeSeries,drawdownsStats,1,0,0,...,1
+timeSeries,dummySeries,-1,0,0,class<`timeSeries`>,1
+timeSeries,dummySeries,0,0,0,...,1
+timeSeries,durations,-1,0,0,class<`timeSeries`>,1
+timeSeries,durations,0,0,0,class<`timeSeries`>,1
+timeSeries,durations,1,0,0,logical,1
+timeSeries,durations,2,0,0,character,1
+timeSeries,end,-1,0,0,class<`timeDate`>,1
+timeSeries,end,0,0,0,class<`timeSeries`>,1
+timeSeries,end,1,0,0,...,1
+timeSeries,endOfPeriodBenchmarks,-1,0,0,null,1
+timeSeries,endOfPeriodBenchmarks,0,0,0,class<`timeSeries`>,1
+timeSeries,endOfPeriodBenchmarks,1,0,0,double,1
+timeSeries,endOfPeriodBenchmarks,2,0,0,character[],1
+timeSeries,endOfPeriodSeries,-1,0,0,class<`timeSeries`>,1
+timeSeries,endOfPeriodSeries,0,0,0,class<`timeSeries`>,1
+timeSeries,endOfPeriodSeries,1,0,0,character,1
+timeSeries,endOfPeriodStats,-1,0,0,class<`data.frame`>,1
+timeSeries,endOfPeriodStats,0,0,0,class<`timeSeries`>,1
+timeSeries,endOfPeriodStats,1,0,0,character,1
+timeSeries,.endpoints2,-1,0,0,double[],1
+timeSeries,.endpoints2,0,0,0,class<`timeSeries`>,1
+timeSeries,.endpoints2,1,0,0,character,1
+timeSeries,.endpoints2,2,0,0,double,1
+timeSeries,.end.timeSeries,-1,0,0,class<`timeDate`>,1
+timeSeries,.end.timeSeries,0,0,0,class<`timeSeries`>,1
+timeSeries,.end.timeSeries,1,0,0,...,1
+timeSeries,.extract.turnpointsPastecs,-1,0,0,double[],1
+timeSeries,.extract.turnpointsPastecs,0,0,0,class<`turnpoints`>,1
+timeSeries,.extract.turnpointsPastecs,1,0,0,any,1
+timeSeries,.extract.turnpointsPastecs,2,0,0,double,1
+timeSeries,.extract.turnpointsPastecs,3,0,0,double,1
+timeSeries,.extract.turnpointsPastecs,4,0,0,double,1
+timeSeries,.extract.turnpointsPastecs,5,0,0,...,1
+timeSeries,filter,-1,0,0,class<`timeSeries`>,1
+timeSeries,filter,0,0,0,class<`timeSeries`>,1
+timeSeries,filter,1,0,0,double[],1
+timeSeries,filter,2,0,0,character[],1
+timeSeries,filter,3,0,0,double,1
+timeSeries,filter,4,0,0,logical,1
+timeSeries,filter,5,0,0,null,1
+timeSeries,filter,-1,1,0,logical[],1
+timeSeries,filter,0,1,0,character[],1
+timeSeries,.findIndex,-1,0,0,integer[],1
+timeSeries,.findIndex,0,0,0,"class<`POSIXct`, `POSIXt`>",1
+timeSeries,.findIndex,1,0,0,double[],1
+timeSeries,getAttributes,-1,0,0,null,1
+timeSeries,getAttributes,-1,0,1,list<list<character>>,1
+timeSeries,getAttributes,0,0,0,class<`timeSeries`>,1
+timeSeries,getFinCenter,-1,0,0,character,1
+timeSeries,getFinCenter,0,0,0,class<`timeSeries`>,1
+timeSeries,getTime,-1,0,0,class<`timeDate`>,1
+timeSeries,getTime,0,0,0,class<`timeSeries`>,1
+timeSeries,getUnits,-1,0,0,character[],1
+timeSeries,getUnits,0,0,0,class<`timeSeries`>,1
+timeSeries,getUnits.default,-1,0,0,character[],1
+timeSeries,getUnits.default,0,0,0,class<`timeSeries`>,1
+timeSeries,hclustColnames,-1,0,0,character[],1
+timeSeries,hclustColnames,0,0,0,class<`timeSeries`>,1
+timeSeries,hclustColnames,1,0,0,character[],1
+timeSeries,hclustColnames,2,0,0,...,1
+timeSeries,head,-1,0,0,class<`timeSeries`>,1
+timeSeries,head,0,0,0,class<`timeSeries`>,1
+timeSeries,head,1,0,0,...,1
+timeSeries,.head.timeSeries,-1,0,0,class<`timeSeries`>,1
+timeSeries,.head.timeSeries,0,0,0,class<`timeSeries`>,1
+timeSeries,.head.timeSeries,1,0,0,double,1
+timeSeries,.head.timeSeries,2,0,0,logical,1
+timeSeries,.head.timeSeries,3,0,0,...,1
+timeSeries,index2wealth,-1,0,0,class<`timeSeries`>,1
+timeSeries,index2wealth,0,0,0,class<`timeSeries`>,1
+timeSeries,interpNA,-1,0,0,class<`matrix`>,1
+timeSeries,interpNA,0,0,0,class<`matrix`>,1
+timeSeries,interpNA,1,0,0,character,1
+timeSeries,interpNA,2,0,0,...,1
+timeSeries,isMultivariate,-1,0,0,logical,1
+timeSeries,isMultivariate,0,0,0,class<`timeSeries`>,1
+timeSeries,is.signalSeries,-1,0,0,logical,1
+timeSeries,is.signalSeries,0,0,0,class<`timeSeries`>,1
+timeSeries,is.timeSeries,-1,0,0,logical,1
+timeSeries,is.timeSeries,0,0,0,class<`timeSeries`>,1
+timeSeries,is.timeSeries,0,0,1,double[],1
+timeSeries,is.timeSeries,0,0,2,null,1
+timeSeries,isUnivariate,-1,0,0,logical,1
+timeSeries,isUnivariate,0,0,0,class<`timeSeries`>,1
+timeSeries,is.unsorted,-1,0,0,logical,1
+timeSeries,is.unsorted,0,0,0,class<`timeSeries`>,1
+timeSeries,is.unsorted,1,0,0,logical,1
+timeSeries,is.unsorted,2,0,0,logical,1
+timeSeries,lag,-1,0,0,class<`timeSeries`>,1
+timeSeries,lag,0,0,0,class<`timeSeries`>,1
+timeSeries,lag,1,0,0,...,1
+timeSeries,merge,-1,0,0,class<`timeSeries`>,1
+timeSeries,merge,0,0,0,class<`timeSeries`>,1
+timeSeries,merge,1,0,0,class<`matrix`>,1
+timeSeries,merge,2,0,0,...,1
+timeSeries,merge,-1,1,0,class<`timeSeries`>,1
+timeSeries,merge,0,1,0,class<`timeSeries`>,1
+timeSeries,merge,1,1,0,double[],1
+timeSeries,merge,2,1,0,...,1
+timeSeries,merge,-1,2,0,class<`timeSeries`>,1
+timeSeries,merge,0,2,0,class<`timeSeries`>,1
+timeSeries,merge,1,2,0,any,1
+timeSeries,merge,2,2,0,...,1
+timeSeries,merge,-1,3,0,class<`timeSeries`>,1
+timeSeries,merge,0,3,0,class<`timeSeries`>,1
+timeSeries,merge,1,3,0,class<`timeSeries`>,1
+timeSeries,merge,2,3,0,...,1
+timeSeries,.merge.timeSeries,-1,0,0,class<`timeSeries`>,1
+timeSeries,.merge.timeSeries,0,0,0,class<`timeSeries`>,1
+timeSeries,.merge.timeSeries,1,0,0,class<`timeSeries`>,1
+timeSeries,.merge.timeSeries,2,0,0,...,1
+timeSeries,midquotes,-1,0,0,class<`timeSeries`>,1
+timeSeries,midquotes,0,0,0,class<`timeSeries`>,1
+timeSeries,midquotes,1,0,0,character[],1
+timeSeries,na.contiguous,-1,0,0,class<`timeSeries`>,1
+timeSeries,na.contiguous,0,0,0,class<`timeSeries`>,1
+timeSeries,na.contiguous,1,0,0,...,1
+timeSeries,na.omit,-1,0,0,class<`timeSeries`>,1
+timeSeries,na.omit,0,0,0,class<`timeSeries`>,1
+timeSeries,na.omit,1,0,0,...,1
+timeSeries,.na.omit.timeSeries,-1,0,0,class<`timeSeries`>,1
+timeSeries,.na.omit.timeSeries,0,0,0,class<`timeSeries`>,1
+timeSeries,.na.omit.timeSeries,1,0,0,character[],1
+timeSeries,.na.omit.timeSeries,2,0,0,character[],1
+timeSeries,.na.omit.timeSeries,3,0,0,...,1
+timeSeries,orderStatistics,-1,0,0,list<class<`timeSeries`>>,1
+timeSeries,orderStatistics,0,0,0,class<`timeSeries`>,1
+timeSeries,outlier,-1,0,0,class<`timeSeries`>,1
+timeSeries,outlier,0,0,0,class<`timeSeries`>,1
+timeSeries,outlier,1,0,0,double,1
+timeSeries,outlier,2,0,0,logical,1
+timeSeries,outlier,3,0,0,...,1
+timeSeries,outlier,-1,1,0,class<`timeSeries`>,1
+timeSeries,outlier,0,1,0,class<`timeSeries`>,1
+timeSeries,outlier,1,1,0,double,1
+timeSeries,outlier,2,1,0,logical,1
+timeSeries,outlier,3,1,0,...,1
+timeSeries,.periodicity2,-1,0,0,list<any>,1
+timeSeries,.periodicity2,0,0,0,class<`timeSeries`>,1
+timeSeries,.plot.timeSeries,-1,0,0,null,1
+timeSeries,.plot.timeSeries,0,0,0,class<`timeSeries`>,1
+timeSeries,.plot.timeSeries,1,0,0,any,1
+timeSeries,.plot.timeSeries,2,0,0,character,1
+timeSeries,.plot.timeSeries,2,0,1,null,1
+timeSeries,.plot.timeSeries,3,0,0,character[],1
+timeSeries,.plot.timeSeries,4,0,0,character,1
+timeSeries,.plot.timeSeries,5,0,0,class<`timeDate`>,1
+timeSeries,.plot.timeSeries,5,0,1,character[],1
+timeSeries,.plot.timeSeries,5,0,2,double[],1
+timeSeries,.plot.timeSeries,6,0,0,any,1
+timeSeries,.plot.timeSeries,7,0,0,any,1
+timeSeries,.plotTimeSeries,-1,0,0,null,1
+timeSeries,.plotTimeSeries,0,0,0,class<`timeSeries`>,1
+timeSeries,.plotTimeSeries,1,0,0,any,1
+timeSeries,.plotTimeSeries,2,0,0,character[],1
+timeSeries,.plotTimeSeries,3,0,0,any,1
+timeSeries,.plotTimeSeries,4,0,0,any,1
+timeSeries,.plotTimeSeries,5,0,0,any,1
+timeSeries,.plotTimeSeries,6,0,0,any,1
+timeSeries,.plotTimeSeries,7,0,0,any,1
+timeSeries,.plot.turnpointsPastecs,-1,0,0,null,1
+timeSeries,.plot.turnpointsPastecs,0,0,0,class<`turnpoints`>,1
+timeSeries,.plot.turnpointsPastecs,1,0,0,double,1
+timeSeries,.plot.turnpointsPastecs,2,0,0,logical,1
+timeSeries,.plot.turnpointsPastecs,3,0,0,double,1
+timeSeries,.plot.turnpointsPastecs,4,0,0,double,1
+timeSeries,.plot.turnpointsPastecs,5,0,0,character,1
+timeSeries,.plot.turnpointsPastecs,6,0,0,character,1
+timeSeries,.plot.turnpointsPastecs,7,0,0,character,1
+timeSeries,.points.timeSeries,-1,0,0,class<`timeSeries`>,1
+timeSeries,.points.timeSeries,0,0,0,class<`timeSeries`>,1
+timeSeries,.points.timeSeries,1,0,0,character,1
+timeSeries,.points.timeSeries,1,0,1,null,1
+timeSeries,.points.timeSeries,2,0,0,...,1
+timeSeries,pretty.timeSeries,-1,0,0,class<`timeDate`>,1
+timeSeries,pretty.timeSeries,-1,0,1,double[],1
+timeSeries,pretty.timeSeries,0,0,0,class<`timeSeries`>,1
+timeSeries,pretty.timeSeries,1,0,0,double,1
+timeSeries,pretty.timeSeries,2,0,0,any,1
+timeSeries,pretty.timeSeries,3,0,0,double,1
+timeSeries,pretty.timeSeries,4,0,0,double,1
+timeSeries,pretty.timeSeries,5,0,0,any,1
+timeSeries,pretty.timeSeries,6,0,0,double,1
+timeSeries,pretty.timeSeries,7,0,0,...,1
+timeSeries,print,-1,0,0,class<`timeSeries`>,1
+timeSeries,print,0,0,0,class<`timeSeries`>,1
+timeSeries,print,1,0,0,...,1
+timeSeries,rank,-1,0,0,class<`timeSeries`>,1
+timeSeries,rank,0,0,0,class<`timeSeries`>,1
+timeSeries,rank,1,0,0,logical,1
+timeSeries,rank,2,0,0,character[],1
+timeSeries,removeNA,-1,0,0,class<`matrix`>,1
+timeSeries,removeNA,0,0,0,class<`matrix`>,1
+timeSeries,removeNA,1,0,0,...,1
+timeSeries,returns,-1,0,0,class<`timeSeries`>,1
+timeSeries,returns,0,0,0,class<`timeSeries`>,1
+timeSeries,returns,1,0,0,...,1
+timeSeries,returns,-1,1,0,class<`matrix`>,1
+timeSeries,returns,-1,1,1,class<`timeSeries`>,1
+timeSeries,returns,0,1,0,class<`matrix`>,1
+timeSeries,returns,0,1,1,class<`timeSeries`>,1
+timeSeries,returns,1,1,0,...,1
+timeSeries,returns,-1,2,0,class<`matrix`>,1
+timeSeries,returns,0,2,0,class<`matrix`>,1
+timeSeries,returns,1,2,0,...,1
+timeSeries,returns0,-1,0,0,class<`timeSeries`>,1
+timeSeries,returns0,0,0,0,class<`timeSeries`>,1
+timeSeries,returns0,1,0,0,...,1
+timeSeries,rev,-1,0,0,class<`timeSeries`>,1
+timeSeries,rev,0,0,0,class<`timeSeries`>,1
+timeSeries,.rev.timeSeries,-1,0,0,class<`timeSeries`>,1
+timeSeries,.rev.timeSeries,0,0,0,class<`timeSeries`>,1
+timeSeries,rollMean,-1,0,0,class<`timeSeries`>,1
+timeSeries,rollMean,0,0,0,class<`timeSeries`>,1
+timeSeries,rollMean,1,0,0,double,1
+timeSeries,rollMean,2,0,0,logical,1
+timeSeries,rollMean,3,0,0,any,1
+timeSeries,rollMean,4,0,0,...,1
+timeSeries,rollMonthlySeries,-1,0,0,class<`timeSeries`>,1
+timeSeries,rollMonthlySeries,0,0,0,class<`timeSeries`>,1
+timeSeries,rollMonthlySeries,1,0,0,character,1
+timeSeries,rollMonthlySeries,2,0,0,character,1
+timeSeries,rollMonthlySeries,3,0,0,class<`function`>,1
+timeSeries,rollMonthlySeries,4,0,0,...,1
+timeSeries,rollMonthlyWindows,-1,0,0,list<class<`timeDate`>>,1
+timeSeries,rollMonthlyWindows,0,0,0,class<`timeSeries`>,1
+timeSeries,rollMonthlyWindows,1,0,0,character,1
+timeSeries,rollMonthlyWindows,2,0,0,character,1
+timeSeries,rowCumsums,-1,0,0,class<`matrix`>,1
+timeSeries,rowCumsums,0,0,0,class<`matrix`>,1
+timeSeries,rowCumsums,1,0,0,logical,1
+timeSeries,rowCumsums,2,0,0,...,1
+timeSeries,rowCumsums,-1,1,0,class<`matrix`>,1
+timeSeries,rowCumsums,0,1,0,class<`matrix`>,1
+timeSeries,rowCumsums,1,1,0,logical,1
+timeSeries,rowCumsums,2,1,0,...,1
+timeSeries,rownames,-1,0,0,character[],1
+timeSeries,rownames,-1,0,1,null,1
+timeSeries,rownames,0,0,0,class<`timeSeries`>,1
+timeSeries,rownames,1,0,0,logical,1
+timeSeries,rownames,2,0,0,character,1
+timeSeries,rownames<-,-1,0,0,class<`timeSeries`>,1
+timeSeries,rownames<-,0,0,0,class<`timeSeries`>,1
+timeSeries,rownames<-,1,0,0,class<`timeDate`>,1
+timeSeries,runlengths,-1,0,0,class<`timeSeries`>,1
+timeSeries,runlengths,0,0,0,class<`timeSeries`>,1
+timeSeries,runlengths,1,0,0,...,1
+timeSeries,.scale.timeSeries,-1,0,0,class<`timeSeries`>,1
+timeSeries,.scale.timeSeries,0,0,0,class<`timeSeries`>,1
+timeSeries,.scale.timeSeries,1,0,0,logical,1
+timeSeries,.scale.timeSeries,2,0,0,logical,1
+timeSeries,scale.timeSeries,-1,0,0,class<`timeSeries`>,1
+timeSeries,scale.timeSeries,0,0,0,class<`timeSeries`>,1
+timeSeries,scale.timeSeries,1,0,0,logical,1
+timeSeries,scale.timeSeries,2,0,0,logical,1
+timeSeries,series,-1,0,0,class<`matrix`>,1
+timeSeries,series,0,0,0,class<`timeSeries`>,1
+timeSeries,series,-1,1,0,class<`matrix`>,1
+timeSeries,series,0,1,0,class<`timeSeries`>,1
+timeSeries,series<-,-1,0,0,class<`timeSeries`>,1
+timeSeries,series<-,0,0,0,class<`timeSeries`>,1
+timeSeries,series<-,1,0,0,class<`matrix`>,1
+timeSeries,series<-,1,0,1,double[],1
+timeSeries,series<-,-1,1,0,class<`timeSeries`>,1
+timeSeries,series<-,0,1,0,class<`timeSeries`>,1
+timeSeries,series<-,1,1,0,double[],1
+timeSeries,series<-,-1,2,0,class<`timeSeries`>,1
+timeSeries,series<-,0,2,0,class<`timeSeries`>,1
+timeSeries,series<-,1,2,0,class<`matrix`>,1
+timeSeries,setAttributes<-,-1,0,0,class<`timeSeries`>,1
+timeSeries,setAttributes<-,0,0,0,class<`timeSeries`>,1
+timeSeries,setAttributes<-,1,0,0,list<character>,1
+timeSeries,setDataPart,-1,0,0,class<`timeSeries`>,1
+timeSeries,setDataPart,0,0,0,class<`timeSeries`>,1
+timeSeries,setDataPart,1,0,0,class<`matrix`>,1
+timeSeries,setDataPart,2,0,0,logical,1
+timeSeries,setFinCenter<-,-1,0,0,class<`timeSeries`>,1
+timeSeries,setFinCenter<-,0,0,0,class<`timeSeries`>,1
+timeSeries,setFinCenter<-,1,0,0,character,1
+timeSeries,setTime<-,-1,0,0,class<`timeSeries`>,1
+timeSeries,setTime<-,0,0,0,class<`timeSeries`>,1
+timeSeries,setTime<-,1,0,0,class<`timeDate`>,1
+timeSeries,setUnits<-,-1,0,0,class<`timeSeries`>,1
+timeSeries,setUnits<-,0,0,0,class<`timeSeries`>,1
+timeSeries,setUnits<-,1,0,0,character[],1
+timeSeries,.signalSeries,-1,0,0,class<`timeSeries`>,1
+timeSeries,.signalSeries,0,0,0,class<`matrix`>,1
+timeSeries,.signalSeries,1,0,0,any,1
+timeSeries,.signalSeries,2,0,0,null,1
+timeSeries,.signalSeries,2,0,1,character[],1
+timeSeries,.signalSeries,3,0,0,any,1
+timeSeries,.signalSeries,4,0,0,character,1
+timeSeries,.signalSeries,5,0,0,character,1
+timeSeries,.signalSeries,6,0,0,class<`data.frame`>,1
+timeSeries,.signalSeries,7,0,0,null,1
+timeSeries,smoothLowess,-1,0,0,class<`timeSeries`>,1
+timeSeries,smoothLowess,0,0,0,class<`timeSeries`>,1
+timeSeries,smoothLowess,1,0,0,double,1
+timeSeries,smoothLowess,2,0,0,...,1
+timeSeries,smoothSpline,-1,0,0,class<`timeSeries`>,1
+timeSeries,smoothSpline,0,0,0,class<`timeSeries`>,1
+timeSeries,smoothSpline,1,0,0,double,1
+timeSeries,smoothSpline,2,0,0,...,1
+timeSeries,smoothSupsmu,-1,0,0,class<`timeSeries`>,1
+timeSeries,smoothSupsmu,0,0,0,class<`timeSeries`>,1
+timeSeries,smoothSupsmu,1,0,0,double,1
+timeSeries,smoothSupsmu,2,0,0,...,1
+timeSeries,sort,-1,0,0,class<`timeSeries`>,1
+timeSeries,sort,0,0,0,class<`timeSeries`>,1
+timeSeries,sort,1,0,0,logical,1
+timeSeries,sort,2,0,0,...,1
+timeSeries,sortColnames,-1,0,0,character[],1
+timeSeries,sortColnames,0,0,0,class<`timeSeries`>,1
+timeSeries,sortColnames,1,0,0,...,1
+timeSeries,.sort.timeSeries,-1,0,0,class<`timeSeries`>,1
+timeSeries,.sort.timeSeries,0,0,0,class<`timeSeries`>,1
+timeSeries,.sort.timeSeries,1,0,0,logical,1
+timeSeries,.sort.timeSeries,2,0,0,...,1
+timeSeries,splits,-1,0,0,class<`timeSeries`>,1
+timeSeries,splits,0,0,0,class<`timeSeries`>,1
+timeSeries,splits,1,0,0,double,1
+timeSeries,splits,2,0,0,logical,1
+timeSeries,splits,3,0,0,...,1
+timeSeries,spreads,-1,0,0,class<`timeSeries`>,1
+timeSeries,spreads,0,0,0,class<`timeSeries`>,1
+timeSeries,spreads,1,0,0,character[],1
+timeSeries,spreads,2,0,0,null,1
+timeSeries,start,-1,0,0,class<`timeDate`>,1
+timeSeries,start,0,0,0,class<`timeSeries`>,1
+timeSeries,start,1,0,0,...,1
+timeSeries,.start.timeSeries,-1,0,0,class<`timeDate`>,1
+timeSeries,.start.timeSeries,0,0,0,class<`timeSeries`>,1
+timeSeries,.start.timeSeries,1,0,0,...,1
+timeSeries,str,-1,0,0,null,1
+timeSeries,str,0,0,0,class<`timeSeries`>,1
+timeSeries,str,1,0,0,...,1
+timeSeries,.str.timeSeries,-1,0,0,null,1
+timeSeries,.str.timeSeries,0,0,0,class<`timeSeries`>,1
+timeSeries,.str.timeSeries,1,0,0,...,1
+timeSeries,.subset_timeSeries,-1,0,0,class<`timeSeries`>,1
+timeSeries,.subset_timeSeries,0,0,0,class<`timeSeries`>,1
+timeSeries,.subset_timeSeries,1,0,0,double[],1
+timeSeries,.subset_timeSeries,2,0,0,double[],1
+timeSeries,substituteNA,-1,0,0,class<`matrix`>,1
+timeSeries,substituteNA,0,0,0,class<`matrix`>,1
+timeSeries,substituteNA,1,0,0,character,1
+timeSeries,substituteNA,2,0,0,...,1
+timeSeries,.summary.turnpointsPastecs,-1,0,0,class<`turnpoints`>,1
+timeSeries,.summary.turnpointsPastecs,0,0,0,class<`turnpoints`>,1
+timeSeries,.summary.turnpointsPastecs,1,0,0,...,1
+timeSeries,t,-1,0,0,class<`matrix`>,1
+timeSeries,t,0,0,0,class<`timeSeries`>,1
+timeSeries,time,-1,0,0,class<`timeDate`>,1
+timeSeries,time,-1,0,1,integer[],1
+timeSeries,time,0,0,0,class<`timeSeries`>,1
+timeSeries,time,1,0,0,...,1
+timeSeries,time<-,-1,0,0,class<`timeSeries`>,1
+timeSeries,time<-,0,0,0,class<`timeSeries`>,1
+timeSeries,time<-,1,0,0,class<`timeDate`>,1
+timeSeries,timeSeries,-1,0,0,class<`timeSeries`>,1
+timeSeries,timeSeries,0,0,0,any,1
+timeSeries,timeSeries,1,0,0,any,1
+timeSeries,timeSeries,2,0,0,character[],1
+timeSeries,timeSeries,2,0,1,null,1
+timeSeries,timeSeries,3,0,0,any,1
+timeSeries,timeSeries,4,0,0,character,1
+timeSeries,timeSeries,5,0,0,any,1
+timeSeries,timeSeries,6,0,0,class<`data.frame`>,1
+timeSeries,timeSeries,7,0,0,character,1
+timeSeries,timeSeries,7,0,1,null,1
+timeSeries,timeSeries,-1,1,0,class<`timeSeries`>,1
+timeSeries,timeSeries,0,1,0,class<`matrix`>,1
+timeSeries,timeSeries,1,1,0,"class<`POSIXct`, `POSIXt`>",1
+timeSeries,timeSeries,2,1,0,null,1
+timeSeries,timeSeries,3,1,0,any,1
+timeSeries,timeSeries,4,1,0,character,1
+timeSeries,timeSeries,5,1,0,character,1
+timeSeries,timeSeries,6,1,0,class<`data.frame`>,1
+timeSeries,timeSeries,7,1,0,null,1
+timeSeries,timeSeries,-1,2,0,class<`timeSeries`>,1
+timeSeries,timeSeries,0,2,0,class<`matrix`>,1
+timeSeries,timeSeries,1,2,0,null,1
+timeSeries,timeSeries,2,2,0,character[],1
+timeSeries,timeSeries,3,2,0,null,1
+timeSeries,timeSeries,4,2,0,character,1
+timeSeries,timeSeries,5,2,0,any,1
+timeSeries,timeSeries,6,2,0,class<`data.frame`>,1
+timeSeries,timeSeries,7,2,0,null,1
+timeSeries,timeSeries,-1,3,0,class<`timeSeries`>,1
+timeSeries,timeSeries,0,3,0,class<`matrix`>,1
+timeSeries,timeSeries,1,3,0,any,1
+timeSeries,timeSeries,2,3,0,character[],1
+timeSeries,timeSeries,2,3,1,null,1
+timeSeries,timeSeries,3,3,0,null,1
+timeSeries,timeSeries,3,3,1,character,1
+timeSeries,timeSeries,4,3,0,character,1
+timeSeries,timeSeries,5,3,0,character,1
+timeSeries,timeSeries,6,3,0,class<`data.frame`>,1
+timeSeries,timeSeries,7,3,0,null,1
+timeSeries,timeSeries,7,3,1,character,1
+timeSeries,timeSeries,-1,4,0,class<`timeSeries`>,1
+timeSeries,timeSeries,0,4,0,class<`matrix`>,1
+timeSeries,timeSeries,1,4,0,class<`timeDate`>,1
+timeSeries,timeSeries,2,4,0,character[],1
+timeSeries,timeSeries,2,4,1,null,1
+timeSeries,timeSeries,3,4,0,any,1
+timeSeries,timeSeries,4,4,0,character,1
+timeSeries,timeSeries,5,4,0,character,1
+timeSeries,timeSeries,6,4,0,class<`data.frame`>,1
+timeSeries,timeSeries,7,4,0,null,1
+timeSeries,timeSeries,-1,5,0,class<`timeSeries`>,1
+timeSeries,timeSeries,0,5,0,class<`matrix`>,1
+timeSeries,timeSeries,1,5,0,character[],1
+timeSeries,timeSeries,2,5,0,character[],1
+timeSeries,timeSeries,2,5,1,null,1
+timeSeries,timeSeries,3,5,0,character,1
+timeSeries,timeSeries,3,5,1,null,1
+timeSeries,timeSeries,4,5,0,character,1
+timeSeries,timeSeries,5,5,0,character,1
+timeSeries,timeSeries,6,5,0,class<`data.frame`>,1
+timeSeries,timeSeries,7,5,0,character,1
+timeSeries,timeSeries,7,5,1,null,1
+timeSeries,timeSeries,-1,6,0,class<`timeSeries`>,1
+timeSeries,timeSeries,0,6,0,class<`timeSeries`>,1
+timeSeries,timeSeries,1,6,0,any,1
+timeSeries,timeSeries,2,6,0,null,1
+timeSeries,timeSeries,3,6,0,null,1
+timeSeries,timeSeries,4,6,0,character,1
+timeSeries,timeSeries,5,6,0,character,1
+timeSeries,timeSeries,6,6,0,class<`data.frame`>,1
+timeSeries,timeSeries,7,6,0,null,1
+timeSeries,timeSeries,-1,7,0,class<`timeSeries`>,1
+timeSeries,timeSeries,0,7,0,integer[],1
+timeSeries,timeSeries,1,7,0,"class<`POSIXct`, `POSIXt`>",1
+timeSeries,timeSeries,2,7,0,null,1
+timeSeries,timeSeries,3,7,0,null,1
+timeSeries,timeSeries,4,7,0,character,1
+timeSeries,timeSeries,5,7,0,character,1
+timeSeries,timeSeries,6,7,0,class<`data.frame`>,1
+timeSeries,timeSeries,7,7,0,null,1
+timeSeries,timeSeries,-1,8,0,class<`timeSeries`>,1
+timeSeries,timeSeries,0,8,0,any,1
+timeSeries,timeSeries,1,8,0,any,1
+timeSeries,timeSeries,2,8,0,null,1
+timeSeries,timeSeries,3,8,0,null,1
+timeSeries,timeSeries,4,8,0,character,1
+timeSeries,timeSeries,5,8,0,character,1
+timeSeries,timeSeries,6,8,0,class<`data.frame`>,1
+timeSeries,timeSeries,7,8,0,null,1
+timeSeries,timeSeries,-1,9,0,class<`timeSeries`>,1
+timeSeries,timeSeries,0,9,0,double[],1
+timeSeries,timeSeries,1,9,0,class<`timeDate`>,1
+timeSeries,timeSeries,2,9,0,character,1
+timeSeries,timeSeries,2,9,1,null,1
+timeSeries,timeSeries,3,9,0,null,1
+timeSeries,timeSeries,4,9,0,character,1
+timeSeries,timeSeries,5,9,0,character,1
+timeSeries,timeSeries,6,9,0,class<`data.frame`>,1
+timeSeries,timeSeries,7,9,0,null,1
+timeSeries,timeSeries,-1,10,0,class<`timeSeries`>,1
+timeSeries,timeSeries,0,10,0,class<`matrix`>,1
+timeSeries,timeSeries,1,10,0,integer[],1
+timeSeries,timeSeries,2,10,0,null,1
+timeSeries,timeSeries,3,10,0,any,1
+timeSeries,timeSeries,4,10,0,character,1
+timeSeries,timeSeries,5,10,0,character,1
+timeSeries,timeSeries,6,10,0,class<`data.frame`>,1
+timeSeries,timeSeries,7,10,0,null,1
+timeSeries,timeSeries,-1,11,0,class<`timeSeries`>,1
+timeSeries,timeSeries,0,11,0,^integer[],1
+timeSeries,timeSeries,1,11,0,class<`timeDate`>,1
+timeSeries,timeSeries,2,11,0,character,1
+timeSeries,timeSeries,2,11,1,null,1
+timeSeries,timeSeries,3,11,0,null,1
+timeSeries,timeSeries,4,11,0,character,1
+timeSeries,timeSeries,5,11,0,character,1
+timeSeries,timeSeries,6,11,0,class<`data.frame`>,1
+timeSeries,timeSeries,7,11,0,null,1
+timeSeries,timeSeries,-1,12,0,class<`timeSeries`>,1
+timeSeries,timeSeries,0,12,0,class<`matrix`>,1
+timeSeries,timeSeries,1,12,0,double[],1
+timeSeries,timeSeries,2,12,0,character[],1
+timeSeries,timeSeries,2,12,1,null,1
+timeSeries,timeSeries,3,12,0,any,1
+timeSeries,timeSeries,4,12,0,character,1
+timeSeries,timeSeries,5,12,0,character,1
+timeSeries,timeSeries,6,12,0,class<`data.frame`>,1
+timeSeries,timeSeries,7,12,0,null,1
+timeSeries,timeSeries,-1,13,0,class<`timeSeries`>,1
+timeSeries,timeSeries,0,13,0,integer[],1
+timeSeries,timeSeries,1,13,0,integer[],1
+timeSeries,timeSeries,2,13,0,null,1
+timeSeries,timeSeries,3,13,0,null,1
+timeSeries,timeSeries,4,13,0,character,1
+timeSeries,timeSeries,5,13,0,character,1
+timeSeries,timeSeries,6,13,0,class<`data.frame`>,1
+timeSeries,timeSeries,7,13,0,null,1
+timeSeries,.timeSeries,-1,0,0,class<`timeSeries`>,1
+timeSeries,.timeSeries,0,0,0,class<`matrix`>,1
+timeSeries,.timeSeries,1,0,0,double[],1
+timeSeries,.timeSeries,2,0,0,character[],1
+timeSeries,.timeSeries,2,0,1,null,1
+timeSeries,.timeSeries,3,0,0,any,1
+timeSeries,.timeSeries,4,0,0,character,1
+timeSeries,.timeSeries,5,0,0,character,1
+timeSeries,.timeSeries,6,0,0,class<`data.frame`>,1
+timeSeries,.timeSeries,7,0,0,character,1
+timeSeries,.timeSeries,7,0,1,null,1
+timeSeries,.time.timeSeries,-1,0,0,class<`timeDate`>,1
+timeSeries,.time.timeSeries,-1,0,1,integer[],1
+timeSeries,.time.timeSeries,0,0,0,class<`timeSeries`>,1
+timeSeries,.time.timeSeries,1,0,0,...,1
+timeSeries,time<-.timeSeries,-1,0,0,class<`timeSeries`>,1
+timeSeries,time<-.timeSeries,0,0,0,class<`timeSeries`>,1
+timeSeries,time<-.timeSeries,1,0,0,class<`timeDate`>,1
+timeSeries,.turnpointsPastecs,-1,0,0,class<`turnpoints`>,1
+timeSeries,.turnpointsPastecs,0,0,0,double[],1
+timeSeries,turns,-1,0,0,class<`timeSeries`>,1
+timeSeries,turns,0,0,0,class<`timeSeries`>,1
+timeSeries,turns,1,0,0,...,1
+timeSeries,turnsStats,-1,0,0,class<`turnpoints`>,1
+timeSeries,turnsStats,0,0,0,class<`timeSeries`>,1
+timeSeries,turnsStats,1,0,0,logical,1
+timeSeries,.validity_timeSeries,-1,0,0,logical,1
+timeSeries,.validity_timeSeries,0,0,0,class<`timeSeries`>,1
+timeSeries,window,-1,0,0,class<`timeSeries`>,1
+timeSeries,window,0,0,0,class<`timeSeries`>,1
+timeSeries,window,1,0,0,...,1
+timeSeries,.window.timeSeries,-1,0,0,class<`timeSeries`>,1
+timeSeries,.window.timeSeries,0,0,0,class<`timeSeries`>,1
+timeSeries,.window.timeSeries,1,0,0,character,1
+timeSeries,.window.timeSeries,2,0,0,character,1
+timeSeries,.window.timeSeries,3,0,0,...,1
+timeSeries,.xtplot.timeSeries,-1,0,0,null,1
+timeSeries,.xtplot.timeSeries,0,0,0,class<`timeSeries`>,1
+timeSeries,.xtplot.timeSeries,1,0,0,null,1
+timeSeries,.xtplot.timeSeries,2,0,0,null,1
+timeSeries,.xtplot.timeSeries,3,0,0,character[],1
+timeSeries,.xtplot.timeSeries,4,0,0,character,1
+timeSeries,.xtplot.timeSeries,5,0,0,character,1
+timeSeries,.xtplot.timeSeries,6,0,0,any,1
+timeSeries,.xtplot.timeSeries,7,0,0,any,1
+tm,as.character.PlainTextDocument,-1,0,0,character[],1
+tm,as.character.PlainTextDocument,0,0,0,"class<`PlainTextDocument`, `TextDocument`>",1
+tm,as.character.PlainTextDocument,1,0,0,...,1
+tm,as.list.VCorpus,-1,0,0,"list<class<`PlainTextDocument`, `TextDocument`>>",1
+tm,as.list.VCorpus,0,0,0,"class<`Corpus`, `VCorpus`>",1
+tm,as.list.VCorpus,1,0,0,...,1
+tm,as.TermDocumentMatrix.TermDocumentMatrix,-1,0,0,"class<`TermDocumentMatrix`, `simple_triplet_matrix`>",1
+tm,as.TermDocumentMatrix.TermDocumentMatrix,0,0,0,"class<`TermDocumentMatrix`, `simple_triplet_matrix`>",1
+tm,as.TermDocumentMatrix.TermDocumentMatrix,1,0,0,...,1
+tm,as.VCorpus,-1,0,0,"class<`Corpus`, `VCorpus`>",1
+tm,as.VCorpus,0,0,0,"list<class<`PlainTextDocument`, `TextDocument`>>",1
+tm,as.VCorpus.list,-1,0,0,"class<`Corpus`, `VCorpus`>",1
+tm,as.VCorpus.list,0,0,0,"list<class<`PlainTextDocument`, `TextDocument`>>",1
+tm,Boost_tokenizer,-1,0,0,character[],1
+tm,Boost_tokenizer,0,0,0,"class<`PlainTextDocument`, `TextDocument`>",1
+tm,Boost_Tokenizer,-1,0,0,character[],1
+tm,Boost_Tokenizer,0,0,0,character,1
+tm,close.SimpleSource,-1,0,0,"class<`DirSource`, `SimpleSource`, `Source`>",1
+tm,close.SimpleSource,-1,0,1,"class<`SimpleSource`, `Source`, `URISource`>",1
+tm,close.SimpleSource,-1,0,2,"class<`SimpleSource`, `Source`, `VectorSource`>",1
+tm,close.SimpleSource,-1,0,3,"class<`SimpleSource`, `Source`, `XMLSource`>",1
+tm,close.SimpleSource,0,0,0,"class<`DirSource`, `SimpleSource`, `Source`>",1
+tm,close.SimpleSource,0,0,1,"class<`SimpleSource`, `Source`, `URISource`>",1
+tm,close.SimpleSource,0,0,2,"class<`SimpleSource`, `Source`, `VectorSource`>",1
+tm,close.SimpleSource,0,0,3,"class<`SimpleSource`, `Source`, `XMLSource`>",1
+tm,close.SimpleSource,1,0,0,...,1
+tm,close.ZipSource,-1,0,0,"class<`SimpleSource`, `Source`, `ZipSource`>",1
+tm,close.ZipSource,0,0,0,"class<`SimpleSource`, `Source`, `ZipSource`>",1
+tm,close.ZipSource,1,0,0,...,1
+tm,content<-.PlainTextDocument,-1,0,0,"class<`PlainTextDocument`, `TextDocument`>",1
+tm,content<-.PlainTextDocument,0,0,0,"class<`PlainTextDocument`, `TextDocument`>",1
+tm,content<-.PlainTextDocument,1,0,0,character,1
+tm,content.PlainTextDocument,-1,0,0,character[],1
+tm,content.PlainTextDocument,-1,0,1,"class<`xml_document`, `xml_node`>",1
+tm,content.PlainTextDocument,0,0,0,"class<`PlainTextDocument`, `TextDocument`>",1
+tm,content.PlainTextDocument,0,0,1,"class<`Corpus`, `SimpleCorpus`>",1
+tm,content.PlainTextDocument,0,0,2,"class<`TextDocument`, `XMLTextDocument`>",1
+tm,content.SimpleCorpus,-1,0,0,character[],1
+tm,content.SimpleCorpus,-1,0,1,"class<`xml_document`, `xml_node`>",1
+tm,content.SimpleCorpus,0,0,0,"class<`PlainTextDocument`, `TextDocument`>",1
+tm,content.SimpleCorpus,0,0,1,"class<`Corpus`, `SimpleCorpus`>",1
+tm,content.SimpleCorpus,0,0,2,"class<`TextDocument`, `XMLTextDocument`>",1
+tm,content_transformer,-1,0,0,"class<`content_transformer`, `function`>",1
+tm,content_transformer,0,0,0,any,1
+tm,content_transformer,-1,1,0,"class<`PlainTextDocument`, `TextDocument`>",1
+tm,content_transformer,0,1,0,"class<`PlainTextDocument`, `TextDocument`>",1
+tm,content_transformer,1,1,0,...,1
+tm,content.VCorpus,-1,0,0,"list<class<`PlainTextDocument`, `TextDocument`>>",1
+tm,content.VCorpus,0,0,0,"class<`Corpus`, `VCorpus`>",1
+tm,content<-.XMLTextDocument,-1,0,0,"class<`TextDocument`, `XMLTextDocument`>",1
+tm,content<-.XMLTextDocument,0,0,0,"class<`TextDocument`, `XMLTextDocument`>",1
+tm,content<-.XMLTextDocument,1,0,0,"class<`xml_document`, `xml_node`>",1
+tm,content.XMLTextDocument,-1,0,0,character[],1
+tm,content.XMLTextDocument,-1,0,1,"class<`xml_document`, `xml_node`>",1
+tm,content.XMLTextDocument,0,0,0,"class<`PlainTextDocument`, `TextDocument`>",1
+tm,content.XMLTextDocument,0,0,1,"class<`Corpus`, `SimpleCorpus`>",1
+tm,content.XMLTextDocument,0,0,2,"class<`TextDocument`, `XMLTextDocument`>",1
+tm,Corpus,-1,0,0,"class<`Corpus`, `SimpleCorpus`>",1
+tm,Corpus,-1,0,1,"class<`Corpus`, `VCorpus`>",1
+tm,Corpus,0,0,0,"class<`DataframeSource`, `SimpleSource`, `Source`>",1
+tm,Corpus,0,0,1,"class<`SimpleSource`, `Source`, `ZipSource`>",1
+tm,Corpus,1,0,0,list<class<`function`> | character>,1
+tm,CorpusMeta,-1,0,0,class<`CorpusMeta`>,1
+tm,CorpusMeta,0,0,0,...,1
+tm,CorpusMeta,1,0,0,null,1
+tm,CorpusMeta,1,0,1,list<character>,1
+tm,c.TermDocumentMatrix,-1,0,0,"class<`TermDocumentMatrix`, `simple_triplet_matrix`>",1
+tm,c.TermDocumentMatrix,0,0,0,...,1
+tm,c.TermDocumentMatrix,1,0,0,logical,1
+tm,c.TextDocument,-1,0,0,"class<`Corpus`, `VCorpus`>",1
+tm,c.TextDocument,0,0,0,...,1
+tm,c.TextDocument,1,0,0,logical,1
+tm,cum_vocabulary_size,-1,0,0,double[],1
+tm,cum_vocabulary_size,0,0,0,"class<`DocumentTermMatrix`, `simple_triplet_matrix`>",1
+tm,c.VCorpus,-1,0,0,"class<`Corpus`, `VCorpus`>",1
+tm,c.VCorpus,0,0,0,...,1
+tm,c.VCorpus,1,0,0,logical,1
+tm,DataframeSource,-1,0,0,"class<`DataframeSource`, `SimpleSource`, `Source`>",1
+tm,DataframeSource,0,0,0,class<`data.frame`>,1
+tm,DirSource,-1,0,0,"class<`DirSource`, `SimpleSource`, `Source`>",1
+tm,DirSource,0,0,0,character,1
+tm,DirSource,1,0,0,character,1
+tm,DirSource,2,0,0,null,1
+tm,DirSource,3,0,0,logical,1
+tm,DirSource,4,0,0,logical,1
+tm,DirSource,5,0,0,character,1
+tm,Docs,-1,0,0,character[],1
+tm,Docs,0,0,0,"class<`TermDocumentMatrix`, `simple_triplet_matrix`>",1
+tm,Docs.TermDocumentMatrix,-1,0,0,character[],1
+tm,Docs.TermDocumentMatrix,0,0,0,"class<`TermDocumentMatrix`, `simple_triplet_matrix`>",1
+tm,Docs.TermDocumentMatrix,0,0,1,"class<`DocumentTermMatrix`, `simple_triplet_matrix`>",1
+tm,DocumentTermMatrix,-1,0,0,"class<`DocumentTermMatrix`, `simple_triplet_matrix`>",1
+tm,DocumentTermMatrix,0,0,0,"class<`Corpus`, `VCorpus`>",1
+tm,DocumentTermMatrix,1,0,0,list<any>,1
+tm,[.DocumentTermMatrix,-1,0,0,"class<`DocumentTermMatrix`, `simple_triplet_matrix`>",1
+tm,[.DocumentTermMatrix,-1,0,1,"class<`TermDocumentMatrix`, `simple_triplet_matrix`>",1
+tm,[.DocumentTermMatrix,0,0,0,"class<`DocumentTermMatrix`, `simple_triplet_matrix`>",1
+tm,[.DocumentTermMatrix,0,0,1,"class<`TermDocumentMatrix`, `simple_triplet_matrix`>",1
+tm,[.DocumentTermMatrix,1,0,0,any,1
+tm,[.DocumentTermMatrix,2,0,0,any,1
+tm,[.DocumentTermMatrix,3,0,0,...,1
+tm,[.DocumentTermMatrix,4,0,0,any,1
+tm,DublinCore,-1,0,0,class<`TextDocumentMeta`>,1
+tm,DublinCore,0,0,0,"class<`PlainTextDocument`, `TextDocument`>",1
+tm,DublinCore,1,0,0,null,1
+tm,DublinCore<-,-1,0,0,"class<`PlainTextDocument`, `TextDocument`>",1
+tm,DublinCore<-,0,0,0,"class<`PlainTextDocument`, `TextDocument`>",1
+tm,DublinCore<-,1,0,0,character,1
+tm,DublinCore<-,2,0,0,character,1
+tm,eoi,-1,0,0,logical,1
+tm,eoi,0,0,0,"class<`SimpleSource`, `Source`, `XMLSource`>",1
+tm,eoi.SimpleSource,-1,0,0,logical,1
+tm,eoi.SimpleSource,0,0,0,"class<`SimpleSource`, `Source`, `XMLSource`>",1
+tm,filter_global_bounds,-1,0,0,class<`simple_triplet_matrix`>,1
+tm,filter_global_bounds,0,0,0,class<`simple_triplet_matrix`>,1
+tm,filter_global_bounds,1,0,0,null,1
+tm,findAssocs,-1,0,0,list<double[]>,1
+tm,findAssocs,0,0,0,"class<`DocumentTermMatrix`, `simple_triplet_matrix`>",1
+tm,findAssocs,0,0,1,class<`matrix`>,1
+tm,findAssocs,0,0,2,"class<`TermDocumentMatrix`, `simple_triplet_matrix`>",1
+tm,findAssocs,1,0,0,character[],1
+tm,findAssocs,2,0,0,double[],1
+tm,findAssocs.DocumentTermMatrix,-1,0,0,list<double[]>,1
+tm,findAssocs.DocumentTermMatrix,0,0,0,"class<`DocumentTermMatrix`, `simple_triplet_matrix`>",1
+tm,findAssocs.DocumentTermMatrix,1,0,0,character[],1
+tm,findAssocs.DocumentTermMatrix,2,0,0,double[],1
+tm,findAssocs.matrix,-1,0,0,list<double[]>,1
+tm,findAssocs.matrix,0,0,0,class<`matrix`>,1
+tm,findAssocs.matrix,1,0,0,character[],1
+tm,findAssocs.matrix,2,0,0,double[],1
+tm,findAssocs.TermDocumentMatrix,-1,0,0,list<double[]>,1
+tm,findAssocs.TermDocumentMatrix,0,0,0,"class<`TermDocumentMatrix`, `simple_triplet_matrix`>",1
+tm,findAssocs.TermDocumentMatrix,1,0,0,character[],1
+tm,findAssocs.TermDocumentMatrix,2,0,0,double[],1
+tm,findFreqTerms,-1,0,0,character[],1
+tm,findFreqTerms,0,0,0,"class<`DocumentTermMatrix`, `simple_triplet_matrix`>",1
+tm,findFreqTerms,0,0,1,"class<`TermDocumentMatrix`, `simple_triplet_matrix`>",1
+tm,findFreqTerms,1,0,0,double,1
+tm,findFreqTerms,2,0,0,double,1
+tm,findMostFreqTerms,-1,0,0,integer[],1
+tm,findMostFreqTerms,-1,0,1,list<double[]>,1
+tm,findMostFreqTerms,0,0,0,"class<`integer`, `term_frequency`>",1
+tm,findMostFreqTerms,0,0,1,"class<`DocumentTermMatrix`, `simple_triplet_matrix`>",1
+tm,findMostFreqTerms,1,0,0,integer,1
+tm,findMostFreqTerms,2,0,0,...,1
+tm,findMostFreqTerms.DocumentTermMatrix,-1,0,0,list<double[]>,1
+tm,findMostFreqTerms.DocumentTermMatrix,0,0,0,"class<`DocumentTermMatrix`, `simple_triplet_matrix`>",1
+tm,findMostFreqTerms.DocumentTermMatrix,1,0,0,integer,1
+tm,findMostFreqTerms.DocumentTermMatrix,2,0,0,null,1
+tm,findMostFreqTerms.DocumentTermMatrix,2,0,1,integer[],1
+tm,findMostFreqTerms.DocumentTermMatrix,3,0,0,...,1
+tm,findMostFreqTerms.term_frequency,-1,0,0,integer[],1
+tm,findMostFreqTerms.term_frequency,0,0,0,"class<`integer`, `term_frequency`>",1
+tm,findMostFreqTerms.term_frequency,1,0,0,integer,1
+tm,findMostFreqTerms.term_frequency,2,0,0,...,1
+tm,format.PlainTextDocument,-1,0,0,character[],1
+tm,format.PlainTextDocument,0,0,0,"class<`PlainTextDocument`, `TextDocument`>",1
+tm,format.PlainTextDocument,1,0,0,...,1
+tm,format.SimpleCorpus,-1,0,0,character[],1
+tm,format.SimpleCorpus,0,0,0,"class<`Corpus`, `SimpleCorpus`>",1
+tm,format.SimpleCorpus,0,0,1,"class<`Corpus`, `VCorpus`>",1
+tm,format.SimpleCorpus,1,0,0,...,1
+tm,.format_TextDocument,-1,0,0,character[],1
+tm,.format_TextDocument,0,0,0,"class<`PlainTextDocument`, `TextDocument`>",1
+tm,.format_TextDocument,1,0,0,...,1
+tm,format.VCorpus,-1,0,0,character[],1
+tm,format.VCorpus,0,0,0,"class<`Corpus`, `SimpleCorpus`>",1
+tm,format.VCorpus,0,0,1,"class<`Corpus`, `VCorpus`>",1
+tm,format.VCorpus,1,0,0,...,1
+tm,getElem,-1,0,0,list<character | null>,1
+tm,getElem,-1,0,1,list<class<`data.frame`> | null>,1
+tm,getElem,-1,0,2,list<class<`xml_node`> | character>,1
+tm,getElem,0,0,0,"class<`SimpleSource`, `Source`, `VectorSource`>",1
+tm,getElem,0,0,1,"class<`DataframeSource`, `SimpleSource`, `Source`>",1
+tm,getElem,0,0,2,"class<`SimpleSource`, `Source`, `XMLSource`>",1
+tm,getElem.DataframeSource,-1,0,0,list<class<`data.frame`> | null>,1
+tm,getElem.DataframeSource,0,0,0,"class<`DataframeSource`, `SimpleSource`, `Source`>",1
+tm,getElem.VectorSource,-1,0,0,list<character | null>,1
+tm,getElem.VectorSource,0,0,0,"class<`SimpleSource`, `Source`, `VectorSource`>",1
+tm,getElem.XMLSource,-1,0,0,list<class<`xml_node`> | character>,1
+tm,getElem.XMLSource,0,0,0,"class<`SimpleSource`, `Source`, `XMLSource`>",1
+tm,getTokenizers,-1,0,0,character[],1
+tm,getTransformations,-1,0,0,character[],1
+tm,Heaps_plot,-1,0,0,double[],1
+tm,Heaps_plot,0,0,0,"class<`DocumentTermMatrix`, `simple_triplet_matrix`>",1
+tm,Heaps_plot,1,0,0,character,1
+tm,Heaps_plot,2,0,0,...,1
+tm,inspect,-1,0,0,"class<`Corpus`, `SimpleCorpus`>",1
+tm,inspect,-1,0,1,"class<`Corpus`, `VCorpus`>",1
+tm,inspect,-1,0,2,class<`matrix`>,1
+tm,inspect,-1,0,3,"class<`PlainTextDocument`, `TextDocument`>",1
+tm,inspect,0,0,0,"class<`Corpus`, `SimpleCorpus`>",1
+tm,inspect,0,0,1,"class<`Corpus`, `VCorpus`>",1
+tm,inspect,0,0,2,"class<`DocumentTermMatrix`, `simple_triplet_matrix`>",1
+tm,inspect,0,0,3,"class<`TermDocumentMatrix`, `simple_triplet_matrix`>",1
+tm,inspect,0,0,4,"class<`PlainTextDocument`, `TextDocument`>",1
+tm,inspect.DocumentTermMatrix,-1,0,0,class<`matrix`>,1
+tm,inspect.DocumentTermMatrix,0,0,0,"class<`DocumentTermMatrix`, `simple_triplet_matrix`>",1
+tm,inspect.DocumentTermMatrix,0,0,1,"class<`TermDocumentMatrix`, `simple_triplet_matrix`>",1
+tm,inspect.SimpleCorpus,-1,0,0,"class<`Corpus`, `SimpleCorpus`>",1
+tm,inspect.SimpleCorpus,-1,0,1,"class<`Corpus`, `VCorpus`>",1
+tm,inspect.SimpleCorpus,0,0,0,"class<`Corpus`, `SimpleCorpus`>",1
+tm,inspect.SimpleCorpus,0,0,1,"class<`Corpus`, `VCorpus`>",1
+tm,inspect.TermDocumentMatrix,-1,0,0,class<`matrix`>,1
+tm,inspect.TermDocumentMatrix,0,0,0,"class<`DocumentTermMatrix`, `simple_triplet_matrix`>",1
+tm,inspect.TermDocumentMatrix,0,0,1,"class<`TermDocumentMatrix`, `simple_triplet_matrix`>",1
+tm,inspect.TextDocument,-1,0,0,"class<`PlainTextDocument`, `TextDocument`>",1
+tm,inspect.TextDocument,0,0,0,"class<`PlainTextDocument`, `TextDocument`>",1
+tm,inspect.VCorpus,-1,0,0,"class<`Corpus`, `SimpleCorpus`>",1
+tm,inspect.VCorpus,-1,0,1,"class<`Corpus`, `VCorpus`>",1
+tm,inspect.VCorpus,0,0,0,"class<`Corpus`, `SimpleCorpus`>",1
+tm,inspect.VCorpus,0,0,1,"class<`Corpus`, `VCorpus`>",1
+tm,length.SimpleCorpus,-1,0,0,integer,1
+tm,length.SimpleCorpus,0,0,0,"class<`Corpus`, `SimpleCorpus`>",1
+tm,length.SimpleCorpus,0,0,1,"class<`Corpus`, `VCorpus`>",1
+tm,length.SimpleSource,-1,0,0,integer,1
+tm,length.SimpleSource,0,0,0,"class<`DirSource`, `SimpleSource`, `Source`>",1
+tm,length.SimpleSource,0,0,1,"class<`SimpleSource`, `Source`, `URISource`>",1
+tm,length.SimpleSource,0,0,2,"class<`SimpleSource`, `Source`, `VectorSource`>",1
+tm,length.SimpleSource,0,0,3,"class<`SimpleSource`, `Source`, `XMLSource`>",1
+tm,length.SimpleSource,0,0,4,"class<`SimpleSource`, `Source`, `ZipSource`>",1
+tm,length.VCorpus,-1,0,0,integer,1
+tm,length.VCorpus,0,0,0,"class<`Corpus`, `SimpleCorpus`>",1
+tm,length.VCorpus,0,0,1,"class<`Corpus`, `VCorpus`>",1
+tm,map_IETF_Snowball,-1,0,0,character,1
+tm,map_IETF_Snowball,-1,0,1,null,1
+tm,map_IETF_Snowball,0,0,0,character,1
+tm,.map_name_index,-1,0,0,double,1
+tm,.map_name_index,0,0,0,any,1
+tm,.map_name_index,1,0,0,double,1
+tm,.map_name_index,1,0,1,character,1
+tm,materialize,-1,0,0,"class<`Corpus`, `VCorpus`>",1
+tm,materialize,0,0,0,"class<`Corpus`, `VCorpus`>",1
+tm,materialize,1,0,0,double,1
+tm,MC_tokenizer,-1,0,0,character[],1
+tm,MC_tokenizer,0,0,0,"class<`PlainTextDocument`, `TextDocument`>",1
+tm,meta<-.PlainTextDocument,-1,0,0,"class<`PlainTextDocument`, `TextDocument`>",1
+tm,meta<-.PlainTextDocument,-1,0,1,"class<`TextDocument`, `XMLTextDocument`>",1
+tm,meta<-.PlainTextDocument,0,0,0,"class<`PlainTextDocument`, `TextDocument`>",1
+tm,meta<-.PlainTextDocument,0,0,1,"class<`TextDocument`, `XMLTextDocument`>",1
+tm,meta<-.PlainTextDocument,1,0,0,character,1
+tm,meta<-.PlainTextDocument,2,0,0,...,1
+tm,meta<-.PlainTextDocument,3,0,0,character[],1
+tm,meta<-.PlainTextDocument,3,0,1,"class<`POSIXlt`, `POSIXt`>",1
+tm,meta<-.PlainTextDocument,3,0,2,null,1
+tm,meta.PlainTextDocument,-1,0,0,character[],1
+tm,meta.PlainTextDocument,-1,0,1,"class<`POSIXlt`, `POSIXt`>",1
+tm,meta.PlainTextDocument,-1,0,2,class<`TextDocumentMeta`>,1
+tm,meta.PlainTextDocument,-1,0,3,null,1
+tm,meta.PlainTextDocument,0,0,0,"class<`PlainTextDocument`, `TextDocument`>",1
+tm,meta.PlainTextDocument,0,0,1,"class<`TextDocument`, `XMLTextDocument`>",1
+tm,meta.PlainTextDocument,1,0,0,character,1
+tm,meta.PlainTextDocument,1,0,1,null,1
+tm,meta.PlainTextDocument,2,0,0,...,1
+tm,meta.SimpleCorpus,-1,0,0,character[],1
+tm,meta.SimpleCorpus,-1,0,1,class<`CorpusMeta`>,1
+tm,meta.SimpleCorpus,-1,0,2,class<`data.frame`>,1
+tm,meta.SimpleCorpus,0,0,0,"class<`Corpus`, `SimpleCorpus`>",1
+tm,meta.SimpleCorpus,1,0,0,character,1
+tm,meta.SimpleCorpus,1,0,1,null,1
+tm,meta.SimpleCorpus,2,0,0,any,1
+tm,meta.SimpleCorpus,3,0,0,...,1
+tm,meta<-.VCorpus,-1,0,0,"class<`Corpus`, `VCorpus`>",1
+tm,meta<-.VCorpus,0,0,0,"class<`Corpus`, `VCorpus`>",1
+tm,meta<-.VCorpus,1,0,0,character,1
+tm,meta<-.VCorpus,2,0,0,character[],1
+tm,meta<-.VCorpus,3,0,0,...,1
+tm,meta<-.VCorpus,4,0,0,character[],1
+tm,meta<-.VCorpus,4,0,1,integer[],1
+tm,meta.VCorpus,-1,0,0,class<`CorpusMeta`>,1
+tm,meta.VCorpus,-1,0,1,class<`data.frame`>,1
+tm,meta.VCorpus,-1,0,2,list<character>,1
+tm,meta.VCorpus,0,0,0,"class<`Corpus`, `VCorpus`>",1
+tm,meta.VCorpus,1,0,0,null,1
+tm,meta.VCorpus,1,0,1,character,1
+tm,meta.VCorpus,2,0,0,any,1
+tm,meta.VCorpus,3,0,0,...,1
+tm,meta<-.XMLTextDocument,-1,0,0,"class<`PlainTextDocument`, `TextDocument`>",1
+tm,meta<-.XMLTextDocument,-1,0,1,"class<`TextDocument`, `XMLTextDocument`>",1
+tm,meta<-.XMLTextDocument,0,0,0,"class<`PlainTextDocument`, `TextDocument`>",1
+tm,meta<-.XMLTextDocument,0,0,1,"class<`TextDocument`, `XMLTextDocument`>",1
+tm,meta<-.XMLTextDocument,1,0,0,character,1
+tm,meta<-.XMLTextDocument,2,0,0,...,1
+tm,meta<-.XMLTextDocument,3,0,0,character[],1
+tm,meta<-.XMLTextDocument,3,0,1,"class<`POSIXlt`, `POSIXt`>",1
+tm,meta<-.XMLTextDocument,3,0,2,null,1
+tm,meta.XMLTextDocument,-1,0,0,character[],1
+tm,meta.XMLTextDocument,-1,0,1,"class<`POSIXlt`, `POSIXt`>",1
+tm,meta.XMLTextDocument,-1,0,2,class<`TextDocumentMeta`>,1
+tm,meta.XMLTextDocument,-1,0,3,null,1
+tm,meta.XMLTextDocument,0,0,0,"class<`PlainTextDocument`, `TextDocument`>",1
+tm,meta.XMLTextDocument,0,0,1,"class<`TextDocument`, `XMLTextDocument`>",1
+tm,meta.XMLTextDocument,1,0,0,character,1
+tm,meta.XMLTextDocument,1,0,1,null,1
+tm,meta.XMLTextDocument,2,0,0,...,1
+tm,nDocs,-1,0,0,integer,1
+tm,nDocs,0,0,0,"class<`TermDocumentMatrix`, `simple_triplet_matrix`>",1
+tm,nDocs.TermDocumentMatrix,-1,0,0,integer,1
+tm,nDocs.TermDocumentMatrix,0,0,0,"class<`TermDocumentMatrix`, `simple_triplet_matrix`>",1
+tm,nTerms,-1,0,0,integer,1
+tm,nTerms,0,0,0,"class<`TermDocumentMatrix`, `simple_triplet_matrix`>",1
+tm,nTerms.TermDocumentMatrix,-1,0,0,integer,1
+tm,nTerms.TermDocumentMatrix,0,0,0,"class<`TermDocumentMatrix`, `simple_triplet_matrix`>",1
+tm,open.SimpleSource,-1,0,0,"class<`DirSource`, `SimpleSource`, `Source`>",1
+tm,open.SimpleSource,-1,0,1,"class<`SimpleSource`, `Source`, `URISource`>",1
+tm,open.SimpleSource,-1,0,2,"class<`SimpleSource`, `Source`, `VectorSource`>",1
+tm,open.SimpleSource,-1,0,3,"class<`SimpleSource`, `Source`, `XMLSource`>",1
+tm,open.SimpleSource,0,0,0,"class<`DirSource`, `SimpleSource`, `Source`>",1
+tm,open.SimpleSource,0,0,1,"class<`SimpleSource`, `Source`, `URISource`>",1
+tm,open.SimpleSource,0,0,2,"class<`SimpleSource`, `Source`, `VectorSource`>",1
+tm,open.SimpleSource,0,0,3,"class<`SimpleSource`, `Source`, `XMLSource`>",1
+tm,open.SimpleSource,1,0,0,...,1
+tm,open.ZipSource,-1,0,0,"class<`SimpleSource`, `Source`, `ZipSource`>",1
+tm,open.ZipSource,0,0,0,"class<`SimpleSource`, `Source`, `ZipSource`>",1
+tm,open.ZipSource,1,0,0,...,1
+tm,PDF_Date_to_POSIXt,-1,0,0,"class<`POSIXlt`, `POSIXt`>",1
+tm,PDF_Date_to_POSIXt,0,0,0,character,1
+tm,pGetElem,-1,0,0,list<list<character[]>>,1
+tm,pGetElem,-1,0,1,list<list<character | null>>,1
+tm,pGetElem,-1,0,2,list<list<null | character>>,1
+tm,pGetElem,-1,0,3,list<list<raw[] | character>>,1
+tm,pGetElem,0,0,0,"class<`SimpleSource`, `Source`, `URISource`>",1
+tm,pGetElem,0,0,1,"class<`DirSource`, `SimpleSource`, `Source`>",1
+tm,pGetElem,0,0,2,"class<`SimpleSource`, `Source`, `ZipSource`>",1
+tm,pGetElem,0,0,3,"class<`SimpleSource`, `Source`, `VectorSource`>",1
+tm,pGetElem.DirSource,-1,0,0,list<list<character[]>>,1
+tm,pGetElem.DirSource,-1,0,1,list<list<raw[] | character>>,1
+tm,pGetElem.DirSource,0,0,0,"class<`DirSource`, `SimpleSource`, `Source`>",1
+tm,pGetElem.URISource,-1,0,0,list<list<character[]>>,1
+tm,pGetElem.URISource,-1,0,1,list<list<null | character>>,1
+tm,pGetElem.URISource,0,0,0,"class<`SimpleSource`, `Source`, `URISource`>",1
+tm,pGetElem.VectorSource,-1,0,0,list<list<character | null>>,1
+tm,pGetElem.VectorSource,0,0,0,"class<`SimpleSource`, `Source`, `VectorSource`>",1
+tm,pGetElem.ZipSource,-1,0,0,list<list<character[]>>,1
+tm,pGetElem.ZipSource,0,0,0,"class<`SimpleSource`, `Source`, `ZipSource`>",1
+tm,PlainTextDocument,-1,0,0,"class<`PlainTextDocument`, `TextDocument`>",1
+tm,PlainTextDocument,0,0,0,character[],1
+tm,PlainTextDocument,1,0,0,character[],1
+tm,PlainTextDocument,1,0,1,null,1
+tm,PlainTextDocument,2,0,0,"class<`POSIXlt`, `POSIXt`>",1
+tm,PlainTextDocument,2,0,1,"class<`POSIXct`, `POSIXt`>",1
+tm,PlainTextDocument,3,0,0,character[],1
+tm,PlainTextDocument,3,0,1,null,1
+tm,PlainTextDocument,4,0,0,character[],1
+tm,PlainTextDocument,4,0,1,null,1
+tm,PlainTextDocument,5,0,0,character[],1
+tm,PlainTextDocument,6,0,0,character[],1
+tm,PlainTextDocument,7,0,0,character[],1
+tm,prepareReader,-1,0,0,list<character | class<`function`>>,1
+tm,prepareReader,-1,0,1,list<class<`function`> | character>,1
+tm,prepareReader,0,0,0,list<character>,1
+tm,prepareReader,0,0,1,list<class<`function`> | character>,1
+tm,prepareReader,0,0,2,list<class<`function`>>,1
+tm,prepareReader,1,0,0,any,1
+tm,prepareReader,2,0,0,...,1
+tm,print.DocumentTermMatrix,-1,0,0,"class<`DocumentTermMatrix`, `simple_triplet_matrix`>",1
+tm,print.DocumentTermMatrix,-1,0,1,"class<`TermDocumentMatrix`, `simple_triplet_matrix`>",1
+tm,print.DocumentTermMatrix,0,0,0,"class<`DocumentTermMatrix`, `simple_triplet_matrix`>",1
+tm,print.DocumentTermMatrix,0,0,1,"class<`TermDocumentMatrix`, `simple_triplet_matrix`>",1
+tm,print.DocumentTermMatrix,1,0,0,...,1
+tm,print.TermDocumentMatrix,-1,0,0,"class<`DocumentTermMatrix`, `simple_triplet_matrix`>",1
+tm,print.TermDocumentMatrix,-1,0,1,"class<`TermDocumentMatrix`, `simple_triplet_matrix`>",1
+tm,print.TermDocumentMatrix,0,0,0,"class<`DocumentTermMatrix`, `simple_triplet_matrix`>",1
+tm,print.TermDocumentMatrix,0,0,1,"class<`TermDocumentMatrix`, `simple_triplet_matrix`>",1
+tm,print.TermDocumentMatrix,1,0,0,...,1
+tm,processURI,-1,0,0,character,1
+tm,processURI,0,0,0,character,1
+tm,read_all_bytes,-1,0,0,raw[],1
+tm,read_all_bytes,0,0,0,character,1
+tm,read_all_bytes,1,0,0,any,1
+tm,readContent,-1,0,0,character[],1
+tm,readContent,-1,0,1,null,1
+tm,readContent,-1,0,2,raw[],1
+tm,readContent,0,0,0,any,1
+tm,readContent,1,0,0,any,1
+tm,readContent,2,0,0,character,1
+tm,readDataframe,-1,0,0,"class<`PlainTextDocument`, `TextDocument`>",1
+tm,readDataframe,0,0,0,list<class<`data.frame`> | null>,1
+tm,readDataframe,1,0,0,character,1
+tm,readDataframe,2,0,0,null,1
+tm,reader,-1,0,0,"class<`PlainTextDocument`, `TextDocument`>",1
+tm,reader,0,0,0,list<null | character>,1
+tm,reader,0,0,1,list<character>,1
+tm,reader,1,0,0,character,1
+tm,reader,2,0,0,any,1
+tm,reader,-1,1,0,class<`function`>,1
+tm,reader,0,1,0,"class<`DataframeSource`, `SimpleSource`, `Source`>",1
+tm,reader,0,1,1,"class<`DirSource`, `SimpleSource`, `Source`>",1
+tm,reader,0,1,2,"class<`SimpleSource`, `Source`, `URISource`>",1
+tm,reader,0,1,3,"class<`SimpleSource`, `Source`, `VectorSource`>",1
+tm,reader,0,1,4,"class<`SimpleSource`, `Source`, `XMLSource`>",1
+tm,reader,0,1,5,"class<`SimpleSource`, `Source`, `ZipSource`>",1
+tm,reader.SimpleSource,-1,0,0,class<`function`>,1
+tm,reader.SimpleSource,0,0,0,"class<`DataframeSource`, `SimpleSource`, `Source`>",1
+tm,reader.SimpleSource,0,0,1,"class<`DirSource`, `SimpleSource`, `Source`>",1
+tm,reader.SimpleSource,0,0,2,"class<`SimpleSource`, `Source`, `URISource`>",1
+tm,reader.SimpleSource,0,0,3,"class<`SimpleSource`, `Source`, `VectorSource`>",1
+tm,reader.SimpleSource,0,0,4,"class<`SimpleSource`, `Source`, `XMLSource`>",1
+tm,reader.SimpleSource,0,0,5,"class<`SimpleSource`, `Source`, `ZipSource`>",1
+tm,readPDF,-1,0,0,class<`function`>,1
+tm,readPDF,0,0,0,character,1
+tm,readPDF,1,0,0,list<null>,1
+tm,readPlain,-1,0,0,"class<`PlainTextDocument`, `TextDocument`>",1
+tm,readPlain,0,0,0,list<character | null>,1
+tm,readPlain,1,0,0,character,1
+tm,readPlain,2,0,0,character,1
+tm,readRCV1,-1,0,0,"class<`TextDocument`, `XMLTextDocument`>",1
+tm,readRCV1,0,0,0,list<raw[]>,1
+tm,readRCV1,1,0,0,character,1
+tm,readRCV1,2,0,0,character,1
+tm,readTagged,-1,0,0,class<`function`>,1
+tm,readTagged,0,0,0,...,1
+tm,readTagged,-1,1,0,"class<`TaggedTextDocument`, `TextDocument`>",1
+tm,readTagged,0,1,0,list<character | null>,1
+tm,readTagged,1,1,0,character,1
+tm,readTagged,2,1,0,character,1
+tm,readXML,-1,0,0,class<`function`>,1
+tm,readXML,0,0,0,list<list<character | character | class<`function`>>>,1
+tm,readXML,1,0,0,"class<`PlainTextDocument`, `TextDocument`>",1
+tm,removeNumbers,-1,0,0,"class<`PlainTextDocument`, `TextDocument`>",1
+tm,removeNumbers,0,0,0,"class<`PlainTextDocument`, `TextDocument`>",1
+tm,removeNumbers,1,0,0,...,1
+tm,removeNumbers.PlainTextDocument,-1,0,0,"class<`PlainTextDocument`, `TextDocument`>",1
+tm,removeNumbers.PlainTextDocument,0,0,0,"class<`PlainTextDocument`, `TextDocument`>",1
+tm,removeNumbers.PlainTextDocument,1,0,0,...,1
+tm,removePunctuation,-1,0,0,"class<`PlainTextDocument`, `TextDocument`>",1
+tm,removePunctuation,0,0,0,"class<`PlainTextDocument`, `TextDocument`>",1
+tm,removePunctuation,1,0,0,...,1
+tm,removePunctuation.character,-1,0,0,character[],1
+tm,removePunctuation.character,0,0,0,character[],1
+tm,removePunctuation.character,1,0,0,logical,1
+tm,removePunctuation.character,2,0,0,logical,1
+tm,removePunctuation.character,3,0,0,logical,1
+tm,removePunctuation.character,4,0,0,...,1
+tm,removePunctuation.PlainTextDocument,-1,0,0,"class<`PlainTextDocument`, `TextDocument`>",1
+tm,removePunctuation.PlainTextDocument,0,0,0,"class<`PlainTextDocument`, `TextDocument`>",1
+tm,removePunctuation.PlainTextDocument,1,0,0,...,1
+tm,removeSparseTerms,-1,0,0,"class<`DocumentTermMatrix`, `simple_triplet_matrix`>",1
+tm,removeSparseTerms,-1,0,1,"class<`TermDocumentMatrix`, `simple_triplet_matrix`>",1
+tm,removeSparseTerms,0,0,0,"class<`DocumentTermMatrix`, `simple_triplet_matrix`>",1
+tm,removeSparseTerms,0,0,1,"class<`TermDocumentMatrix`, `simple_triplet_matrix`>",1
+tm,removeSparseTerms,1,0,0,double,1
+tm,removeWords,-1,0,0,"class<`PlainTextDocument`, `TextDocument`>",1
+tm,removeWords,0,0,0,"class<`PlainTextDocument`, `TextDocument`>",1
+tm,removeWords,1,0,0,character[],1
+tm,removeWords.PlainTextDocument,-1,0,0,"class<`PlainTextDocument`, `TextDocument`>",1
+tm,removeWords.PlainTextDocument,0,0,0,"class<`PlainTextDocument`, `TextDocument`>",1
+tm,removeWords.PlainTextDocument,1,0,0,...,1
+tm,sample.TermDocumentMatrix,-1,0,0,"class<`DocumentTermMatrix`, `simple_triplet_matrix`>",1
+tm,sample.TermDocumentMatrix,-1,0,1,"class<`TermDocumentMatrix`, `simple_triplet_matrix`>",1
+tm,sample.TermDocumentMatrix,0,0,0,"class<`DocumentTermMatrix`, `simple_triplet_matrix`>",1
+tm,sample.TermDocumentMatrix,0,0,1,"class<`TermDocumentMatrix`, `simple_triplet_matrix`>",1
+tm,sample.TermDocumentMatrix,1,0,0,double,1
+tm,scan_tokenizer,-1,0,0,character[],1
+tm,scan_tokenizer,0,0,0,character,1
+tm,scan_tokenizer,0,0,1,"class<`PlainTextDocument`, `TextDocument`>",1
+tm,SimpleCorpus,-1,0,0,"class<`Corpus`, `SimpleCorpus`>",1
+tm,SimpleCorpus,0,0,0,"class<`DataframeSource`, `SimpleSource`, `Source`>",1
+tm,SimpleCorpus,0,0,1,"class<`DirSource`, `SimpleSource`, `Source`>",1
+tm,SimpleCorpus,0,0,2,"class<`SimpleSource`, `Source`, `VectorSource`>",1
+tm,SimpleCorpus,1,0,0,list<class<`function`> | character>,1
+tm,SimpleCorpus,1,0,1,list<character>,1
+tm,[[.SimpleCorpus,-1,0,0,"class<`PlainTextDocument`, `TextDocument`>",1
+tm,[[.SimpleCorpus,0,0,0,"class<`Corpus`, `SimpleCorpus`>",1
+tm,[[.SimpleCorpus,1,0,0,double,1
+tm,SimpleSource,-1,0,0,"class<`DataframeSource`, `SimpleSource`, `Source`>",1
+tm,SimpleSource,-1,0,1,"class<`DirSource`, `SimpleSource`, `Source`>",1
+tm,SimpleSource,-1,0,2,"class<`SimpleSource`, `Source`, `URISource`>",1
+tm,SimpleSource,-1,0,3,"class<`SimpleSource`, `Source`, `VectorSource`>",1
+tm,SimpleSource,-1,0,4,"class<`SimpleSource`, `Source`, `XMLSource`>",1
+tm,SimpleSource,-1,0,5,"class<`SimpleSource`, `Source`, `ZipSource`>",1
+tm,SimpleSource,0,0,0,character,1
+tm,SimpleSource,1,0,0,double,1
+tm,SimpleSource,2,0,0,double,1
+tm,SimpleSource,3,0,0,class<`function`>,1
+tm,SimpleSource,4,0,0,...,1
+tm,SimpleSource,5,0,0,character,1
+tm,.SimpleTripletMatrix,-1,0,0,class<`simple_triplet_matrix`>,1
+tm,.SimpleTripletMatrix,0,0,0,double[],1
+tm,.SimpleTripletMatrix,1,0,0,double[],1
+tm,.SimpleTripletMatrix,2,0,0,double[],1
+tm,.SimpleTripletMatrix,3,0,0,character[],1
+tm,.SimpleTripletMatrix,4,0,0,"class<`Corpus`, `SimpleCorpus`>",1
+tm,.SimpleTripletMatrix,4,0,1,"class<`Corpus`, `VCorpus`>",1
+tm,stemCompletion,-1,0,0,character[],1
+tm,stemCompletion,0,0,0,character[],1
+tm,stemCompletion,1,0,0,"class<`Corpus`, `VCorpus`>",1
+tm,stemCompletion,2,0,0,character[],1
+tm,stemDocument,-1,0,0,"class<`PlainTextDocument`, `TextDocument`>",1
+tm,stemDocument,0,0,0,"class<`PlainTextDocument`, `TextDocument`>",1
+tm,stemDocument,1,0,0,character,1
+tm,stemDocument.PlainTextDocument,-1,0,0,"class<`PlainTextDocument`, `TextDocument`>",1
+tm,stemDocument.PlainTextDocument,0,0,0,"class<`PlainTextDocument`, `TextDocument`>",1
+tm,stemDocument.PlainTextDocument,1,0,0,character,1
+tm,stepNext,-1,0,0,"class<`DataframeSource`, `SimpleSource`, `Source`>",1
+tm,stepNext,-1,0,1,"class<`SimpleSource`, `Source`, `VectorSource`>",1
+tm,stepNext,-1,0,2,"class<`SimpleSource`, `Source`, `XMLSource`>",1
+tm,stepNext,0,0,0,"class<`DataframeSource`, `SimpleSource`, `Source`>",1
+tm,stepNext,0,0,1,"class<`SimpleSource`, `Source`, `VectorSource`>",1
+tm,stepNext,0,0,2,"class<`SimpleSource`, `Source`, `XMLSource`>",1
+tm,stepNext.SimpleSource,-1,0,0,"class<`DataframeSource`, `SimpleSource`, `Source`>",1
+tm,stepNext.SimpleSource,-1,0,1,"class<`SimpleSource`, `Source`, `VectorSource`>",1
+tm,stepNext.SimpleSource,-1,0,2,"class<`SimpleSource`, `Source`, `XMLSource`>",1
+tm,stepNext.SimpleSource,0,0,0,"class<`DataframeSource`, `SimpleSource`, `Source`>",1
+tm,stepNext.SimpleSource,0,0,1,"class<`SimpleSource`, `Source`, `VectorSource`>",1
+tm,stepNext.SimpleSource,0,0,2,"class<`SimpleSource`, `Source`, `XMLSource`>",1
+tm,stopwords,-1,0,0,character[],1
+tm,stopwords,0,0,0,character,1
+tm,stripWhitespace,-1,0,0,"class<`PlainTextDocument`, `TextDocument`>",1
+tm,stripWhitespace,0,0,0,"class<`PlainTextDocument`, `TextDocument`>",1
+tm,stripWhitespace.PlainTextDocument,-1,0,0,"class<`PlainTextDocument`, `TextDocument`>",1
+tm,stripWhitespace.PlainTextDocument,0,0,0,"class<`PlainTextDocument`, `TextDocument`>",1
+tm,stripWhitespace.PlainTextDocument,1,0,0,...,1
+tm,.table,-1,0,0,integer[],1
+tm,.table,0,0,0,character[],1
+tm,tdm,-1,0,0,list<double[] | character[]>,1
+tm,tdm,0,0,0,character[],1
+tm,tdm,1,0,0,logical,1
+tm,tdm,2,0,0,logical,1
+tm,tdm,3,0,0,character[],1
+tm,tdm,4,0,0,character[],1
+tm,tdm,5,0,0,integer,1
+tm,tdm,6,0,0,integer,1
+tm,tdm,7,0,0,integer,1
+tm,t.DocumentTermMatrix,-1,0,0,"class<`TermDocumentMatrix`, `simple_triplet_matrix`>",1
+tm,t.DocumentTermMatrix,-1,0,1,"class<`DocumentTermMatrix`, `simple_triplet_matrix`>",1
+tm,t.DocumentTermMatrix,0,0,0,"class<`DocumentTermMatrix`, `simple_triplet_matrix`>",1
+tm,t.DocumentTermMatrix,0,0,1,"class<`TermDocumentMatrix`, `simple_triplet_matrix`>",1
+tm,TermDocumentMatrix,-1,0,0,"class<`TermDocumentMatrix`, `simple_triplet_matrix`>",1
+tm,TermDocumentMatrix,0,0,0,"class<`Corpus`, `SimpleCorpus`>",1
+tm,TermDocumentMatrix,0,0,1,"class<`Corpus`, `VCorpus`>",1
+tm,TermDocumentMatrix,1,0,0,any,1
+tm,.TermDocumentMatrix,-1,0,0,"class<`TermDocumentMatrix`, `simple_triplet_matrix`>",1
+tm,.TermDocumentMatrix,0,0,0,class<`simple_triplet_matrix`>,1
+tm,.TermDocumentMatrix,1,0,0,character[],1
+tm,.TermDocumentMatrix,1,0,1,class<`function`>,1
+tm,.TermDocumentMatrix,1,0,2,null,1
+tm,[.TermDocumentMatrix,-1,0,0,"class<`DocumentTermMatrix`, `simple_triplet_matrix`>",1
+tm,[.TermDocumentMatrix,-1,0,1,"class<`TermDocumentMatrix`, `simple_triplet_matrix`>",1
+tm,[.TermDocumentMatrix,0,0,0,"class<`DocumentTermMatrix`, `simple_triplet_matrix`>",1
+tm,[.TermDocumentMatrix,0,0,1,"class<`TermDocumentMatrix`, `simple_triplet_matrix`>",1
+tm,[.TermDocumentMatrix,1,0,0,any,1
+tm,[.TermDocumentMatrix,2,0,0,any,1
+tm,[.TermDocumentMatrix,3,0,0,...,1
+tm,[.TermDocumentMatrix,4,0,0,any,1
+tm,TermDocumentMatrix.SimpleCorpus,-1,0,0,"class<`TermDocumentMatrix`, `simple_triplet_matrix`>",1
+tm,TermDocumentMatrix.SimpleCorpus,0,0,0,"class<`Corpus`, `SimpleCorpus`>",1
+tm,TermDocumentMatrix.SimpleCorpus,1,0,0,list<logical>,1
+tm,TermDocumentMatrix.VCorpus,-1,0,0,"class<`TermDocumentMatrix`, `simple_triplet_matrix`>",1
+tm,TermDocumentMatrix.VCorpus,0,0,0,"class<`Corpus`, `VCorpus`>",1
+tm,TermDocumentMatrix.VCorpus,1,0,0,list<any>,1
+tm,termFreq,-1,0,0,"class<`integer`, `term_frequency`>",1
+tm,termFreq,0,0,0,"class<`PlainTextDocument`, `TextDocument`>",1
+tm,termFreq,1,0,0,list<any>,1
+tm,Terms,-1,0,0,character[],1
+tm,Terms,0,0,0,"class<`DocumentTermMatrix`, `simple_triplet_matrix`>",1
+tm,Terms,0,0,1,"class<`TermDocumentMatrix`, `simple_triplet_matrix`>",1
+tm,Terms.DocumentTermMatrix,-1,0,0,character[],1
+tm,Terms.DocumentTermMatrix,0,0,0,"class<`TermDocumentMatrix`, `simple_triplet_matrix`>",1
+tm,Terms.DocumentTermMatrix,0,0,1,"class<`DocumentTermMatrix`, `simple_triplet_matrix`>",1
+tm,Terms.TermDocumentMatrix,-1,0,0,character[],1
+tm,Terms.TermDocumentMatrix,0,0,0,"class<`TermDocumentMatrix`, `simple_triplet_matrix`>",1
+tm,TextDocumentMeta,-1,0,0,class<`TextDocumentMeta`>,1
+tm,TextDocumentMeta,0,0,0,character[],1
+tm,TextDocumentMeta,0,0,1,null,1
+tm,TextDocumentMeta,1,0,0,"class<`POSIXlt`, `POSIXt`>",1
+tm,TextDocumentMeta,1,0,1,"class<`POSIXct`, `POSIXt`>",1
+tm,TextDocumentMeta,2,0,0,character[],1
+tm,TextDocumentMeta,2,0,1,null,1
+tm,TextDocumentMeta,3,0,0,character[],1
+tm,TextDocumentMeta,3,0,1,null,1
+tm,TextDocumentMeta,4,0,0,character[],1
+tm,TextDocumentMeta,5,0,0,character[],1
+tm,TextDocumentMeta,6,0,0,character[],1
+tm,TextDocumentMeta,7,0,0,...,1
+tm,tm_filter,-1,0,0,"class<`Corpus`, `VCorpus`>",1
+tm,tm_filter,0,0,0,"class<`Corpus`, `VCorpus`>",1
+tm,tm_filter,1,0,0,class<`function`>,1
+tm,tm_filter,2,0,0,...,1
+tm,tm_filter.VCorpus,-1,0,0,"class<`Corpus`, `VCorpus`>",1
+tm,tm_filter.VCorpus,0,0,0,"class<`Corpus`, `VCorpus`>",1
+tm,tm_filter.VCorpus,1,0,0,class<`function`>,1
+tm,tm_filter.VCorpus,2,0,0,...,1
+tm,tm_index,-1,0,0,logical[],1
+tm,tm_index,0,0,0,"class<`Corpus`, `VCorpus`>",1
+tm,tm_index,1,0,0,class<`function`>,1
+tm,tm_index,2,0,0,...,1
+tm,tm_index.VCorpus,-1,0,0,logical[],1
+tm,tm_index.VCorpus,0,0,0,"class<`Corpus`, `VCorpus`>",1
+tm,tm_index.VCorpus,1,0,0,class<`function`>,1
+tm,tm_index.VCorpus,2,0,0,...,1
+tm,tm_map,-1,0,0,"class<`Corpus`, `VCorpus`>",1
+tm,tm_map,0,0,0,"class<`Corpus`, `VCorpus`>",1
+tm,tm_map,1,0,0,any,1
+tm,tm_map,2,0,0,...,1
+tm,tm_map.VCorpus,-1,0,0,"class<`Corpus`, `VCorpus`>",1
+tm,tm_map.VCorpus,0,0,0,"class<`Corpus`, `VCorpus`>",1
+tm,tm_map.VCorpus,1,0,0,any,1
+tm,tm_map.VCorpus,2,0,0,...,1
+tm,tm_map.VCorpus,3,0,0,logical,1
+tm,tm_parLapply,-1,0,0,"list<class<`integer`, `term_frequency`>>",1
+tm,tm_parLapply,-1,0,1,"list<class<`PlainTextDocument`, `TextDocument`>>",1
+tm,tm_parLapply,-1,0,2,list<logical>,1
+tm,tm_parLapply,0,0,0,"list<class<`PlainTextDocument`, `TextDocument`>>",1
+tm,tm_parLapply,1,0,0,class<`function`>,1
+tm,tm_parLapply,1,0,1,"class<`content_transformer`, `function`>",1
+tm,tm_parLapply,2,0,0,...,1
+tm,tm_parLapply_engine,-1,0,0,null,1
+tm,tm_parLapply_engine,0,0,0,any,1
+tm,tm_reduce,-1,0,0,"class<`PlainTextDocument`, `TextDocument`>",1
+tm,tm_reduce,0,0,0,"class<`PlainTextDocument`, `TextDocument`>",1
+tm,tm_reduce,1,0,0,list<class<`function`>>,1
+tm,tm_reduce,2,0,0,...,1
+tm,tm_term_score,-1,0,0,integer,1
+tm,tm_term_score,0,0,0,"class<`integer`, `term_frequency`>",1
+tm,tm_term_score,0,0,1,"class<`PlainTextDocument`, `TextDocument`>",1
+tm,tm_term_score,1,0,0,character[],1
+tm,tm_term_score,2,0,0,any,1
+tm,tm_term_score.PlainTextDocument,-1,0,0,integer,1
+tm,tm_term_score.PlainTextDocument,0,0,0,"class<`PlainTextDocument`, `TextDocument`>",1
+tm,tm_term_score.PlainTextDocument,1,0,0,character[],1
+tm,tm_term_score.PlainTextDocument,2,0,0,class<`function`>,1
+tm,tm_term_score.term_frequency,-1,0,0,integer,1
+tm,tm_term_score.term_frequency,0,0,0,"class<`integer`, `term_frequency`>",1
+tm,tm_term_score.term_frequency,1,0,0,character[],1
+tm,tm_term_score.term_frequency,2,0,0,class<`function`>,1
+tm,t.TermDocumentMatrix,-1,0,0,"class<`TermDocumentMatrix`, `simple_triplet_matrix`>",1
+tm,t.TermDocumentMatrix,-1,0,1,"class<`DocumentTermMatrix`, `simple_triplet_matrix`>",1
+tm,t.TermDocumentMatrix,0,0,0,"class<`DocumentTermMatrix`, `simple_triplet_matrix`>",1
+tm,t.TermDocumentMatrix,0,0,1,"class<`TermDocumentMatrix`, `simple_triplet_matrix`>",1
+tm,URISource,-1,0,0,"class<`SimpleSource`, `Source`, `URISource`>",1
+tm,URISource,0,0,0,character[],1
+tm,URISource,1,0,0,character,1
+tm,URISource,2,0,0,character,1
+tm,VCorpus,-1,0,0,"class<`Corpus`, `VCorpus`>",1
+tm,VCorpus,0,0,0,"class<`DirSource`, `SimpleSource`, `Source`>",1
+tm,VCorpus,0,0,1,"class<`SimpleSource`, `Source`, `URISource`>",1
+tm,VCorpus,0,0,2,"class<`SimpleSource`, `Source`, `VectorSource`>",1
+tm,VCorpus,0,0,3,"class<`SimpleSource`, `Source`, `XMLSource`>",1
+tm,VCorpus,0,0,4,"class<`SimpleSource`, `Source`, `ZipSource`>",1
+tm,VCorpus,1,0,0,list<character>,1
+tm,VCorpus,1,0,1,list<class<`function`>>,1
+tm,VCorpus,1,0,2,list<class<`function`> | character>,1
+tm,[.VCorpus,-1,0,0,"class<`Corpus`, `VCorpus`>",1
+tm,[.VCorpus,0,0,0,"class<`Corpus`, `VCorpus`>",1
+tm,[.VCorpus,1,0,0,integer[],1
+tm,[[<-.VCorpus,-1,0,0,"class<`Corpus`, `VCorpus`>",1
+tm,[[<-.VCorpus,0,0,0,"class<`Corpus`, `VCorpus`>",1
+tm,[[<-.VCorpus,1,0,0,double,1
+tm,[[<-.VCorpus,2,0,0,"class<`PlainTextDocument`, `TextDocument`>",1
+tm,[[.VCorpus,-1,0,0,"class<`PlainTextDocument`, `TextDocument`>",1
+tm,[[.VCorpus,0,0,0,"class<`Corpus`, `VCorpus`>",1
+tm,[[.VCorpus,1,0,0,character,1
+tm,[[.VCorpus,1,0,1,double,1
+tm,VectorSource,-1,0,0,"class<`SimpleSource`, `Source`, `VectorSource`>",1
+tm,VectorSource,0,0,0,character[],1
+tm,WeightFunction,-1,0,0,"class<`WeightFunction`, `function`>",1
+tm,WeightFunction,0,0,0,class<`function`>,1
+tm,WeightFunction,1,0,0,character,1
+tm,WeightFunction,2,0,0,character,1
+tm,weightSMART,-1,0,0,"class<`TermDocumentMatrix`, `simple_triplet_matrix`>",1
+tm,weightSMART,0,0,0,"class<`TermDocumentMatrix`, `simple_triplet_matrix`>",1
+tm,weightSMART,1,0,0,character,1
+tm,weightSMART,2,0,0,list<any>,1
+tm,weightTfIdf,-1,0,0,"class<`TermDocumentMatrix`, `simple_triplet_matrix`>",1
+tm,weightTfIdf,0,0,0,"class<`TermDocumentMatrix`, `simple_triplet_matrix`>",1
+tm,weightTfIdf,1,0,0,logical,1
+tm,words.character,-1,0,0,character[],1
+tm,words.character,0,0,0,character,1
+tm,words.character,0,0,1,"class<`PlainTextDocument`, `TextDocument`>",1
+tm,words.character,1,0,0,...,1
+tm,words.PlainTextDocument,-1,0,0,character[],1
+tm,words.PlainTextDocument,0,0,0,character,1
+tm,words.PlainTextDocument,0,0,1,"class<`PlainTextDocument`, `TextDocument`>",1
+tm,words.PlainTextDocument,1,0,0,...,1
+tm,.xml_content,-1,0,0,character[],1
+tm,.xml_content,-1,0,1,"class<`POSIXlt`, `POSIXt`>",1
+tm,.xml_content,0,0,0,any,1
+tm,.xml_content,1,0,0,list<character>,1
+tm,.xml_content,1,0,1,list<character | class<`function`>>,1
+tm,XMLSource,-1,0,0,"class<`SimpleSource`, `Source`, `XMLSource`>",1
+tm,XMLSource,0,0,0,character,1
+tm,XMLSource,1,0,0,class<`function`>,1
+tm,XMLSource,2,0,0,class<`function`>,1
+tm,XMLTextDocument,-1,0,0,"class<`TextDocument`, `XMLTextDocument`>",1
+tm,XMLTextDocument,0,0,0,"class<`xml_document`, `xml_node`>",1
+tm,XMLTextDocument,1,0,0,character[],1
+tm,XMLTextDocument,2,0,0,"class<`POSIXlt`, `POSIXt`>",1
+tm,XMLTextDocument,3,0,0,character[],1
+tm,XMLTextDocument,4,0,0,character,1
+tm,XMLTextDocument,5,0,0,character,1
+tm,XMLTextDocument,6,0,0,character,1
+tm,XMLTextDocument,7,0,0,character[],1
+tm,Zipf_plot,-1,0,0,double[],1
+tm,Zipf_plot,0,0,0,"class<`DocumentTermMatrix`, `simple_triplet_matrix`>",1
+tm,Zipf_plot,1,0,0,character,1
+tm,Zipf_plot,2,0,0,...,1
+tm,ZipSource,-1,0,0,"class<`SimpleSource`, `Source`, `ZipSource`>",1
+tm,ZipSource,0,0,0,character,1
+tm,ZipSource,1,0,0,null,1
+tm,ZipSource,2,0,0,logical,1
+tm,ZipSource,3,0,0,logical,1
+tm,ZipSource,4,0,0,character,1
+tokenizers,check_input,-1,0,0,null,1
+tokenizers,check_input,0,0,0,character[],1
+tokenizers,check_input,0,0,1,list<character>,1
+tokenizers,chunk_individual_text,-1,0,0,list<character>,1
+tokenizers,chunk_individual_text,0,0,0,character,1
+tokenizers,chunk_individual_text,1,0,0,double,1
+tokenizers,chunk_individual_text,2,0,0,character,1
+tokenizers,chunk_individual_text,3,0,0,...,1
+tokenizers,chunk_text,-1,0,0,list<character>,1
+tokenizers,chunk_text,0,0,0,character,1
+tokenizers,chunk_text,1,0,0,double,1
+tokenizers,chunk_text,2,0,0,character,1
+tokenizers,chunk_text,3,0,0,...,1
+tokenizers,count_characters,-1,0,0,integer,1
+tokenizers,count_characters,0,0,0,character,1
+tokenizers,count_sentences,-1,0,0,integer,1
+tokenizers,count_sentences,0,0,0,character,1
+tokenizers,count_words,-1,0,0,integer,1
+tokenizers,count_words,0,0,0,character,1
+tokenizers,generate_ngrams_batch,-1,0,0,list<character[]>,1
+tokenizers,generate_ngrams_batch,0,0,0,list<character[]>,1
+tokenizers,generate_ngrams_batch,1,0,0,double,1
+tokenizers,generate_ngrams_batch,2,0,0,double,1
+tokenizers,generate_ngrams_batch,3,0,0,character[],1
+tokenizers,generate_ngrams_batch,4,0,0,character,1
+tokenizers,simplify_list,-1,0,0,character[],1
+tokenizers,simplify_list,-1,0,1,list<character[]>,1
+tokenizers,simplify_list,0,0,0,list<character[]>,1
+tokenizers,simplify_list,1,0,0,logical,1
+tokenizers,skip_ngrams_vectorised,-1,0,0,list<character[]>,1
+tokenizers,skip_ngrams_vectorised,0,0,0,list<character[]>,1
+tokenizers,skip_ngrams_vectorised,1,0,0,list<double[]>,1
+tokenizers,skip_ngrams_vectorised,2,0,0,character[],1
+tokenizers,tokenize_characters,-1,0,0,list<character[]>,1
+tokenizers,tokenize_characters,0,0,0,character,1
+tokenizers,tokenize_characters,1,0,0,logical,1
+tokenizers,tokenize_characters,2,0,0,logical,1
+tokenizers,tokenize_characters,3,0,0,logical,1
+tokenizers,tokenize_characters.default,-1,0,0,list<character[]>,1
+tokenizers,tokenize_characters.default,0,0,0,character,1
+tokenizers,tokenize_characters.default,1,0,0,logical,1
+tokenizers,tokenize_characters.default,2,0,0,logical,1
+tokenizers,tokenize_characters.default,3,0,0,logical,1
+tokenizers,tokenize_character_shingles,-1,0,0,list<character[]>,1
+tokenizers,tokenize_character_shingles,0,0,0,character,1
+tokenizers,tokenize_character_shingles,1,0,0,double,1
+tokenizers,tokenize_character_shingles,2,0,0,any,1
+tokenizers,tokenize_character_shingles,3,0,0,logical,1
+tokenizers,tokenize_character_shingles,4,0,0,logical,1
+tokenizers,tokenize_character_shingles,5,0,0,logical,1
+tokenizers,tokenize_character_shingles.default,-1,0,0,list<character[]>,1
+tokenizers,tokenize_character_shingles.default,0,0,0,character,1
+tokenizers,tokenize_character_shingles.default,1,0,0,double,1
+tokenizers,tokenize_character_shingles.default,2,0,0,double,1
+tokenizers,tokenize_character_shingles.default,3,0,0,logical,1
+tokenizers,tokenize_character_shingles.default,4,0,0,logical,1
+tokenizers,tokenize_character_shingles.default,5,0,0,logical,1
+tokenizers,tokenize_lines,-1,0,0,list<character[]>,1
+tokenizers,tokenize_lines,0,0,0,character,1
+tokenizers,tokenize_lines,1,0,0,logical,1
+tokenizers,tokenize_lines.default,-1,0,0,list<character[]>,1
+tokenizers,tokenize_lines.default,0,0,0,character,1
+tokenizers,tokenize_lines.default,1,0,0,logical,1
+tokenizers,tokenize_ngrams,-1,0,0,list<character[]>,1
+tokenizers,tokenize_ngrams,0,0,0,character[],1
+tokenizers,tokenize_ngrams,0,0,1,list<character>,1
+tokenizers,tokenize_ngrams,1,0,0,logical,1
+tokenizers,tokenize_ngrams,2,0,0,double,1
+tokenizers,tokenize_ngrams,3,0,0,any,1
+tokenizers,tokenize_ngrams,4,0,0,any,1
+tokenizers,tokenize_ngrams,5,0,0,character,1
+tokenizers,tokenize_ngrams,6,0,0,logical,1
+tokenizers,tokenize_ngrams.default,-1,0,0,list<character[]>,1
+tokenizers,tokenize_ngrams.default,0,0,0,character[],1
+tokenizers,tokenize_ngrams.default,0,0,1,list<character>,1
+tokenizers,tokenize_ngrams.default,1,0,0,logical,1
+tokenizers,tokenize_ngrams.default,2,0,0,double,1
+tokenizers,tokenize_ngrams.default,3,0,0,double,1
+tokenizers,tokenize_ngrams.default,4,0,0,character[],1
+tokenizers,tokenize_ngrams.default,5,0,0,character,1
+tokenizers,tokenize_ngrams.default,6,0,0,logical,1
+tokenizers,tokenize_paragraphs,-1,0,0,list<character[]>,1
+tokenizers,tokenize_paragraphs,0,0,0,character,1
+tokenizers,tokenize_paragraphs,1,0,0,character,1
+tokenizers,tokenize_paragraphs,2,0,0,logical,1
+tokenizers,tokenize_paragraphs.default,-1,0,0,list<character[]>,1
+tokenizers,tokenize_paragraphs.default,0,0,0,character,1
+tokenizers,tokenize_paragraphs.default,1,0,0,character,1
+tokenizers,tokenize_paragraphs.default,2,0,0,logical,1
+tokenizers,tokenize_ptb,-1,0,0,list<character[]>,1
+tokenizers,tokenize_ptb,0,0,0,list<character>,1
+tokenizers,tokenize_ptb,0,0,1,character[],1
+tokenizers,tokenize_ptb,1,0,0,logical,1
+tokenizers,tokenize_ptb,2,0,0,logical,1
+tokenizers,tokenize_ptb.default,-1,0,0,list<character[]>,1
+tokenizers,tokenize_ptb.default,0,0,0,list<character>,1
+tokenizers,tokenize_ptb.default,0,0,1,character[],1
+tokenizers,tokenize_ptb.default,1,0,0,logical,1
+tokenizers,tokenize_ptb.default,2,0,0,logical,1
+tokenizers,tokenize_sentences,-1,0,0,list<character[]>,1
+tokenizers,tokenize_sentences,0,0,0,character,1
+tokenizers,tokenize_sentences,1,0,0,logical,1
+tokenizers,tokenize_sentences,2,0,0,logical,1
+tokenizers,tokenize_sentences,3,0,0,logical,1
+tokenizers,tokenize_sentences.default,-1,0,0,list<character[]>,1
+tokenizers,tokenize_sentences.default,0,0,0,character,1
+tokenizers,tokenize_sentences.default,1,0,0,logical,1
+tokenizers,tokenize_sentences.default,2,0,0,logical,1
+tokenizers,tokenize_sentences.default,3,0,0,logical,1
+tokenizers,tokenize_skip_ngrams,-1,0,0,list<character[]>,1
+tokenizers,tokenize_skip_ngrams,0,0,0,character,1
+tokenizers,tokenize_skip_ngrams,1,0,0,logical,1
+tokenizers,tokenize_skip_ngrams,2,0,0,double,1
+tokenizers,tokenize_skip_ngrams,3,0,0,double,1
+tokenizers,tokenize_skip_ngrams,4,0,0,double,1
+tokenizers,tokenize_skip_ngrams,5,0,0,any,1
+tokenizers,tokenize_skip_ngrams,6,0,0,logical,1
+tokenizers,tokenize_skip_ngrams.default,-1,0,0,list<character[]>,1
+tokenizers,tokenize_skip_ngrams.default,0,0,0,character,1
+tokenizers,tokenize_skip_ngrams.default,1,0,0,logical,1
+tokenizers,tokenize_skip_ngrams.default,2,0,0,double,1
+tokenizers,tokenize_skip_ngrams.default,3,0,0,double,1
+tokenizers,tokenize_skip_ngrams.default,4,0,0,double,1
+tokenizers,tokenize_skip_ngrams.default,5,0,0,character[],1
+tokenizers,tokenize_skip_ngrams.default,6,0,0,logical,1
+tokenizers,tokenize_tweets,-1,0,0,list<character[]>,1
+tokenizers,tokenize_tweets,0,0,0,character,1
+tokenizers,tokenize_tweets,1,0,0,logical,1
+tokenizers,tokenize_tweets,2,0,0,null,1
+tokenizers,tokenize_tweets,3,0,0,logical,1
+tokenizers,tokenize_tweets,4,0,0,logical,1
+tokenizers,tokenize_tweets,5,0,0,logical,1
+tokenizers,tokenize_tweets.default,-1,0,0,list<character[]>,1
+tokenizers,tokenize_tweets.default,0,0,0,character,1
+tokenizers,tokenize_tweets.default,1,0,0,logical,1
+tokenizers,tokenize_tweets.default,2,0,0,null,1
+tokenizers,tokenize_tweets.default,3,0,0,logical,1
+tokenizers,tokenize_tweets.default,4,0,0,logical,1
+tokenizers,tokenize_tweets.default,5,0,0,logical,1
+tokenizers,tokenize_words,-1,0,0,character[],1
+tokenizers,tokenize_words,-1,0,1,list<character[]>,1
+tokenizers,tokenize_words,0,0,0,character[],1
+tokenizers,tokenize_words,0,0,1,list<character>,1
+tokenizers,tokenize_words,1,0,0,logical,1
+tokenizers,tokenize_words,2,0,0,null,1
+tokenizers,tokenize_words,2,0,1,character[],1
+tokenizers,tokenize_words,3,0,0,logical,1
+tokenizers,tokenize_words,4,0,0,logical,1
+tokenizers,tokenize_words,5,0,0,logical,1
+tokenizers,tokenize_words.default,-1,0,0,character[],1
+tokenizers,tokenize_words.default,-1,0,1,list<character[]>,1
+tokenizers,tokenize_words.default,0,0,0,character[],1
+tokenizers,tokenize_words.default,0,0,1,list<character>,1
+tokenizers,tokenize_words.default,1,0,0,logical,1
+tokenizers,tokenize_words.default,2,0,0,null,1
+tokenizers,tokenize_words.default,2,0,1,character[],1
+tokenizers,tokenize_words.default,3,0,0,logical,1
+tokenizers,tokenize_words.default,4,0,0,logical,1
+tokenizers,tokenize_words.default,5,0,0,logical,1
+tokenizers,tokenize_word_stems,-1,0,0,list<character[]>,1
+tokenizers,tokenize_word_stems,0,0,0,character,1
+tokenizers,tokenize_word_stems,1,0,0,character,1
+tokenizers,tokenize_word_stems,2,0,0,null,1
+tokenizers,tokenize_word_stems,3,0,0,logical,1
+tokenizers,tokenize_word_stems.default,-1,0,0,list<character[]>,1
+tokenizers,tokenize_word_stems.default,0,0,0,character,1
+tokenizers,tokenize_word_stems.default,1,0,0,character,1
+tokenizers,tokenize_word_stems.default,2,0,0,null,1
+tokenizers,tokenize_word_stems.default,3,0,0,logical,1
+topicmodels,CTM,-1,0,0,class<`CTM_VEM`>,1
+topicmodels,CTM,0,0,0,"class<`DocumentTermMatrix`, `simple_triplet_matrix`>",1
+topicmodels,CTM,1,0,0,double,1
+topicmodels,CTM,2,0,0,character,1
+topicmodels,CTM,3,0,0,null,1
+topicmodels,CTM,3,0,1,list<double | list<double>>,1
+topicmodels,CTM,4,0,0,null,1
+topicmodels,CTM,5,0,0,...,1
+topicmodels,dtm2ldaformat,-1,0,0,list<character[] | list<class<`matrix`>>>,1
+topicmodels,dtm2ldaformat,0,0,0,"class<`DocumentTermMatrix`, `simple_triplet_matrix`>",1
+topicmodels,dtm2ldaformat,1,0,0,logical,1
+topicmodels,get_df,-1,0,0,double,1
+topicmodels,get_df,0,0,0,class<`CTM_VEM`>,1
+topicmodels,get_df,0,0,1,class<`LDA_Gibbs`>,1
+topicmodels,get_df,0,0,2,class<`LDA_VEM`>,1
+topicmodels,get_df,1,0,0,...,1
+topicmodels,get_df,-1,1,0,integer,1
+topicmodels,get_df,0,1,0,class<`LDA_Gibbs`>,1
+topicmodels,get_df,1,1,0,...,1
+topicmodels,get_df,-1,2,0,double,1
+topicmodels,get_df,0,2,0,class<`CTM_VEM`>,1
+topicmodels,get_df,1,2,0,...,1
+topicmodels,get_df,-1,3,0,integer,1
+topicmodels,get_df,0,3,0,class<`LDA_VEM`>,1
+topicmodels,get_df,1,3,0,...,1
+topicmodels,init_TopicModelcontrol,-1,0,0,list<any>,1
+topicmodels,init_TopicModelcontrol,0,0,0,class<`CTM_VEMcontrol`>,1
+topicmodels,init_TopicModelcontrol,0,0,1,class<`LDA_Gibbscontrol`>,1
+topicmodels,init_TopicModelcontrol,0,0,2,class<`LDA_VEMcontrol`>,1
+topicmodels,init_TopicModelcontrol,1,0,0,any,1
+topicmodels,init_TopicModelcontrol,2,0,0,any,1
+topicmodels,init_TopicModelcontrol,3,0,0,any,1
+topicmodels,init_TopicModelcontrol,4,0,0,...,1
+topicmodels,LDA,-1,0,0,class<`LDA_VEM`>,1
+topicmodels,LDA,-1,0,1,class<`LDA_Gibbs`>,1
+topicmodels,LDA,0,0,0,"class<`DocumentTermMatrix`, `simple_triplet_matrix`>",1
+topicmodels,LDA,1,0,0,any,1
+topicmodels,LDA,2,0,0,character,1
+topicmodels,LDA,3,0,0,class<`LDA_VEMcontrol`>,1
+topicmodels,LDA,3,0,1,list<double>,1
+topicmodels,LDA,4,0,0,class<`LDA_VEM`>,1
+topicmodels,LDA,4,0,1,null,1
+topicmodels,LDA,5,0,0,...,1
+topicmodels,ldaformat2dtm,-1,0,0,"class<`DocumentTermMatrix`, `simple_triplet_matrix`>",1
+topicmodels,ldaformat2dtm,0,0,0,list<class<`matrix`>>,1
+topicmodels,ldaformat2dtm,1,0,0,character[],1
+topicmodels,ldaformat2dtm,2,0,0,logical,1
+topicmodels,.list2control,-1,0,0,class<`CTM_VEMcontrol`>,1
+topicmodels,.list2control,-1,0,1,class<`LDA_Gibbscontrol`>,1
+topicmodels,.list2control,-1,0,2,class<`LDA_VEMcontrol`>,1
+topicmodels,.list2control,-1,0,3,class<`OPTcontrol`>,1
+topicmodels,.list2control,0,0,0,list<any>,1
+topicmodels,.list2control,1,0,0,character,1
+topicmodels,match_terms,-1,0,0,"class<`DocumentTermMatrix`, `simple_triplet_matrix`>",1
+topicmodels,match_terms,0,0,0,"class<`DocumentTermMatrix`, `simple_triplet_matrix`>",1
+topicmodels,match_terms,1,0,0,class<`LDA_VEM`>,1
+topicmodels,most_likely,-1,0,0,class<`matrix`>,1
+topicmodels,most_likely,-1,0,1,integer[],1
+topicmodels,most_likely,0,0,0,class<`LDA_VEM`>,1
+topicmodels,most_likely,1,0,0,character,1
+topicmodels,most_likely,2,0,0,any,1
+topicmodels,most_likely,3,0,0,any,1
+topicmodels,most_likely,4,0,0,...,1
+topicmodels,terms,-1,0,0,class<`matrix`>,1
+topicmodels,terms,0,0,0,class<`LDA_VEM`>,1
+topicmodels,terms,1,0,0,...,1
+topicmodels,topics,-1,0,0,integer[],1
+topicmodels,topics,0,0,0,class<`LDA_VEM`>,1
+topicmodels,topics,1,0,0,...,1
+topicmodels,topics,-1,1,0,integer[],1
+topicmodels,topics,0,1,0,class<`LDA_VEM`>,1
+topicmodels,topics,1,1,0,...,1
+triangle,dltriangle,-1,0,0,double,1
+triangle,dltriangle,0,0,0,double,1
+triangle,dltriangle,1,0,0,double,1
+triangle,dltriangle,2,0,0,double,1
+triangle,dltriangle,3,0,0,double,1
+triangle,dltriangle,4,0,0,double,1
+triangle,dtriangle,-1,0,0,double,1
+triangle,dtriangle,0,0,0,double,1
+triangle,dtriangle,1,0,0,double,1
+triangle,dtriangle,2,0,0,double,1
+triangle,dtriangle,3,0,0,double,1
+triangle,pltriangle,-1,0,0,double,1
+triangle,pltriangle,0,0,0,double,1
+triangle,pltriangle,1,0,0,double,1
+triangle,pltriangle,2,0,0,double,1
+triangle,pltriangle,3,0,0,double,1
+triangle,pltriangle,4,0,0,double,1
+triangle,ptriangle,-1,0,0,double,1
+triangle,ptriangle,0,0,0,double,1
+triangle,ptriangle,1,0,0,double,1
+triangle,ptriangle,2,0,0,double,1
+triangle,ptriangle,3,0,0,double,1
+triangle,qltriangle,-1,0,0,double,1
+triangle,qltriangle,0,0,0,double,1
+triangle,qltriangle,1,0,0,double,1
+triangle,qltriangle,2,0,0,double,1
+triangle,qltriangle,3,0,0,double,1
+triangle,qltriangle,4,0,0,double,1
+triangle,qtriangle,-1,0,0,double,1
+triangle,qtriangle,0,0,0,double,1
+triangle,qtriangle,1,0,0,double,1
+triangle,qtriangle,2,0,0,double,1
+triangle,qtriangle,3,0,0,double,1
+triangle,rltriangle,-1,0,0,double[],1
+triangle,rltriangle,0,0,0,double,1
+triangle,rltriangle,1,0,0,double,1
+triangle,rltriangle,2,0,0,double,1
+triangle,rltriangle,3,0,0,double,1
+triangle,rltriangle,4,0,0,double,1
+triangle,rtriangle,-1,0,0,double[],1
+triangle,rtriangle,0,0,0,double,1
+triangle,rtriangle,1,0,0,double,1
+triangle,rtriangle,2,0,0,double,1
+triangle,rtriangle,3,0,0,double,1
+truncdist,dtrunc,-1,0,0,double[],1
+truncdist,dtrunc,0,0,0,double[],1
+truncdist,dtrunc,1,0,0,character,1
+truncdist,dtrunc,2,0,0,double,1
+truncdist,dtrunc,3,0,0,double,1
+truncdist,dtrunc,4,0,0,...,1
+truncdist,extrunc,-1,0,0,double,1
+truncdist,extrunc,0,0,0,character,1
+truncdist,extrunc,1,0,0,double,1
+truncdist,extrunc,2,0,0,double,1
+truncdist,extrunc,3,0,0,...,1
+truncdist,ptrunc,-1,0,0,double[],1
+truncdist,ptrunc,0,0,0,double[],1
+truncdist,ptrunc,1,0,0,character,1
+truncdist,ptrunc,2,0,0,double,1
+truncdist,ptrunc,3,0,0,double,1
+truncdist,ptrunc,4,0,0,...,1
+truncdist,qqtrunc,-1,0,0,double,1
+truncdist,qqtrunc,0,0,0,double[],1
+truncdist,qqtrunc,1,0,0,character,1
+truncdist,qqtrunc,2,0,0,double,1
+truncdist,qqtrunc,3,0,0,double,1
+truncdist,qqtrunc,4,0,0,character,1
+truncdist,qqtrunc,5,0,0,character,1
+truncdist,qqtrunc,6,0,0,character,1
+truncdist,qqtrunc,7,0,0,...,1
+truncdist,qtrunc,-1,0,0,double[],1
+truncdist,qtrunc,0,0,0,double[],1
+truncdist,qtrunc,1,0,0,character,1
+truncdist,qtrunc,2,0,0,double,1
+truncdist,qtrunc,3,0,0,double,1
+truncdist,qtrunc,4,0,0,...,1
+truncdist,rtrunc,-1,0,0,double[],1
+truncdist,rtrunc,0,0,0,double,1
+truncdist,rtrunc,1,0,0,character,1
+truncdist,rtrunc,2,0,0,double,1
+truncdist,rtrunc,3,0,0,double,1
+truncdist,rtrunc,4,0,0,...,1
+truncdist,vartrunc,-1,0,0,double,1
+truncdist,vartrunc,0,0,0,character,1
+truncdist,vartrunc,1,0,0,double,1
+truncdist,vartrunc,2,0,0,double,1
+truncdist,vartrunc,3,0,0,...,1
+trust,check.objfun.output,-1,0,0,logical,1
+trust,check.objfun.output,0,0,0,list<double[] | class<`matrix`>>,1
+trust,check.objfun.output,0,0,1,list<double>,1
+trust,check.objfun.output,1,0,0,logical,1
+trust,check.objfun.output,2,0,0,any,1
+trust,norm,-1,0,0,double,1
+trust,norm,0,0,0,double[],1
+trust,trust,-1,0,0,any,1
+trust,trust,0,0,0,class<`function`>,1
+trust,trust,1,0,0,double[],1
+trust,trust,2,0,0,double,1
+trust,trust,3,0,0,double,1
+trust,trust,4,0,0,any,1
+trust,trust,5,0,0,double,1
+trust,trust,6,0,0,any,1
+trust,trust,7,0,0,any,1
+trust,trust,8,0,0,logical,1
+trust,trust,9,0,0,logical,1
+trust,trust,10,0,0,...,1
+tseries,adf.test,-1,0,0,class<`htest`>,1
+tseries,adf.test,0,0,0,double[],1
+tseries,adf.test,1,0,0,character[],1
+tseries,adf.test,2,0,0,double,1
+tseries,approx.irts,-1,0,0,class<`irts`>,1
+tseries,approx.irts,0,0,0,class<`irts`>,1
+tseries,approx.irts,1,0,0,"class<`POSIXct`, `POSIXt`>",1
+tseries,approx.irts,2,0,0,...,1
+tseries,arma,-1,0,0,class<`arma`>,1
+tseries,arma,0,0,0,class<`ts`>,1
+tseries,arma,1,0,0,double[],1
+tseries,arma,2,0,0,null,1
+tseries,arma,2,0,1,list<double[]>,1
+tseries,arma,2,0,2,list<double[] | null>,1
+tseries,arma,3,0,0,null,1
+tseries,arma,4,0,0,logical,1
+tseries,arma,5,0,0,null,1
+tseries,arma,6,0,0,double,1
+tseries,arma,7,0,0,...,1
+tseries,as.irts,-1,0,0,class<`irts`>,1
+tseries,as.irts,0,0,0,class<`matrix`>,1
+tseries,as.irts.default,-1,0,0,class<`irts`>,1
+tseries,as.irts.default,0,0,0,class<`matrix`>,1
+tseries,bds.test,-1,0,0,class<`bdstest`>,1
+tseries,bds.test,0,0,0,class<`ts`>,1
+tseries,bds.test,0,0,1,double[],1
+tseries,bds.test,1,0,0,double,1
+tseries,bds.test,2,0,0,double[],1
+tseries,bds.test,3,0,0,logical,1
+tseries,boot.sample,-1,0,0,double[],1
+tseries,boot.sample,0,0,0,integer[],1
+tseries,boot.sample,1,0,0,double,1
+tseries,boot.sample,2,0,0,double,1
+tseries,daysecond,-1,0,0,double[],1
+tseries,daysecond,0,0,0,class<`irts`>,1
+tseries,daysecond,1,0,0,character,1
+tseries,fftsurr,-1,0,0,double[],1
+tseries,fftsurr,0,0,0,class<`ts`>,1
+tseries,garch,-1,0,0,class<`garch`>,1
+tseries,garch,0,0,0,class<`ts`>,1
+tseries,garch,1,0,0,double[],1
+tseries,garch,2,0,0,null,1
+tseries,garch,3,0,0,list<any>,1
+tseries,garch,4,0,0,...,1
+tseries,garch.control,-1,0,0,list<any>,1
+tseries,garch.control,0,0,0,double,1
+tseries,garch.control,1,0,0,logical,1
+tseries,garch.control,2,0,0,null,1
+tseries,garch.control,3,0,0,character[],1
+tseries,garch.control,4,0,0,double,1
+tseries,garch.control,5,0,0,double,1
+tseries,garch.control,6,0,0,double,1
+tseries,garch.control,7,0,0,double,1
+tseries,get.hist.quote,-1,0,0,"class<`matrix`, `mts`, `ts`>",1
+tseries,get.hist.quote,-1,0,1,class<`zoo`>,1
+tseries,get.hist.quote,0,0,0,character,1
+tseries,get.hist.quote,1,0,0,any,1
+tseries,get.hist.quote,2,0,0,any,1
+tseries,get.hist.quote,3,0,0,character[],1
+tseries,get.hist.quote,4,0,0,character,1
+tseries,get.hist.quote,5,0,0,null,1
+tseries,get.hist.quote,6,0,0,character,1
+tseries,get.hist.quote,7,0,0,character,1
+tseries,irts,-1,0,0,class<`irts`>,1
+tseries,irts,0,0,0,double[],1
+tseries,irts,1,0,0,class<`matrix`>,1
+tseries,irts,1,0,1,double[],1
+tseries,[.irts,-1,0,0,class<`irts`>,1
+tseries,[.irts,0,0,0,class<`irts`>,1
+tseries,[.irts,1,0,0,any,1
+tseries,[.irts,2,0,0,any,1
+tseries,[.irts,3,0,0,...,1
+tseries,is.businessday,-1,0,0,logical[],1
+tseries,is.businessday,0,0,0,class<`irts`>,1
+tseries,is.businessday,1,0,0,character,1
+tseries,is.irts,-1,0,0,logical,1
+tseries,is.irts,0,0,0,class<`irts`>,1
+tseries,is.weekend,-1,0,0,logical[],1
+tseries,is.weekend,0,0,0,class<`irts`>,1
+tseries,is.weekend,1,0,0,character,1
+tseries,jarque.bera.test,-1,0,0,class<`htest`>,1
+tseries,jarque.bera.test,0,0,0,class<`ts`>,1
+tseries,jarque.bera.test,0,0,1,double[],1
+tseries,kpss.test,-1,0,0,class<`htest`>,1
+tseries,kpss.test,0,0,0,double[],1
+tseries,kpss.test,1,0,0,character[],1
+tseries,kpss.test,2,0,0,logical,1
+tseries,lines.irts,-1,0,0,class<`irts`>,1
+tseries,lines.irts,0,0,0,class<`irts`>,1
+tseries,lines.irts,1,0,0,character,1
+tseries,lines.irts,2,0,0,...,1
+tseries,maxdrawdown,-1,0,0,list<double>,1
+tseries,maxdrawdown,0,0,0,class<`ts`>,1
+tseries,maxdrawdown,0,0,1,integer[],1
+tseries,na.remove,-1,0,0,class<`ts`>,1
+tseries,na.remove,0,0,0,class<`ts`>,1
+tseries,na.remove,1,0,0,...,1
+tseries,na.remove.default,-1,0,0,double[],1
+tseries,na.remove.default,0,0,0,class<`ts`>,1
+tseries,na.remove.default,1,0,0,...,1
+tseries,na.remove.ts,-1,0,0,class<`ts`>,1
+tseries,na.remove.ts,0,0,0,class<`ts`>,1
+tseries,na.remove.ts,1,0,0,...,1
+tseries,plot.arma,-1,0,0,class<`arma`>,1
+tseries,plot.arma,0,0,0,class<`arma`>,1
+tseries,plot.arma,1,0,0,logical,1
+tseries,plot.arma,2,0,0,...,1
+tseries,plot.garch,-1,0,0,class<`garch`>,1
+tseries,plot.garch,0,0,0,class<`garch`>,1
+tseries,plot.garch,1,0,0,logical,1
+tseries,plot.garch,2,0,0,...,1
+tseries,plot.irts,-1,0,0,class<`irts`>,1
+tseries,plot.irts,0,0,0,class<`irts`>,1
+tseries,plot.irts,1,0,0,character,1
+tseries,plot.irts,2,0,0,any,1
+tseries,plot.irts,3,0,0,character,1
+tseries,plot.irts,4,0,0,null,1
+tseries,plot.irts,5,0,0,null,1
+tseries,plot.irts,6,0,0,null,1
+tseries,plot.irts,7,0,0,any,1
+tseries,plotOHLC,-1,0,0,null,1
+tseries,plotOHLC,0,0,0,"class<`matrix`, `mts`, `ts`>",1
+tseries,plotOHLC,1,0,0,null,1
+tseries,plotOHLC,2,0,0,null,1
+tseries,plotOHLC,3,0,0,character,1
+tseries,plotOHLC,4,0,0,character,1
+tseries,plotOHLC,5,0,0,character,1
+tseries,plotOHLC,6,0,0,character,1
+tseries,plotOHLC,7,0,0,logical,1
+tseries,points.irts,-1,0,0,class<`irts`>,1
+tseries,points.irts,0,0,0,class<`irts`>,1
+tseries,points.irts,1,0,0,character,1
+tseries,points.irts,2,0,0,...,1
+tseries,portfolio.optim,-1,0,0,list<double[]>,1
+tseries,portfolio.optim,0,0,0,class<`matrix`>,1
+tseries,portfolio.optim,0,0,1,"class<`zoo`, `zooreg`>",1
+tseries,portfolio.optim,1,0,0,...,1
+tseries,portfolio.optim.default,-1,0,0,list<double[]>,1
+tseries,portfolio.optim.default,0,0,0,class<`matrix`>,1
+tseries,portfolio.optim.default,0,0,1,"class<`zoo`, `zooreg`>",1
+tseries,portfolio.optim.default,1,0,0,double,1
+tseries,portfolio.optim.default,2,0,0,logical,1
+tseries,portfolio.optim.default,3,0,0,logical,1
+tseries,portfolio.optim.default,4,0,0,double,1
+tseries,portfolio.optim.default,5,0,0,null,1
+tseries,portfolio.optim.default,6,0,0,null,1
+tseries,portfolio.optim.default,7,0,0,class<`matrix`>,1
+tseries,po.test,-1,0,0,class<`htest`>,1
+tseries,po.test,0,0,0,"class<`matrix`, `mts`, `ts`>",1
+tseries,po.test,1,0,0,logical,1
+tseries,po.test,2,0,0,logical,1
+tseries,pp.test,-1,0,0,class<`htest`>,1
+tseries,pp.test,0,0,0,double[],1
+tseries,pp.test,1,0,0,character[],1
+tseries,pp.test,2,0,0,character[],1
+tseries,pp.test,3,0,0,logical,1
+tseries,quadmap,-1,0,0,class<`ts`>,1
+tseries,quadmap,0,0,0,double,1
+tseries,quadmap,1,0,0,double,1
+tseries,quadmap,2,0,0,double,1
+tseries,read.matrix,-1,0,0,class<`matrix`>,1
+tseries,read.matrix,-1,0,1,double[],1
+tseries,read.matrix,0,0,0,character,1
+tseries,read.matrix,1,0,0,logical,1
+tseries,read.matrix,2,0,0,character,1
+tseries,read.matrix,3,0,0,double,1
+tseries,read.ts,-1,0,0,class<`ts`>,1
+tseries,read.ts,0,0,0,character,1
+tseries,read.ts,1,0,0,logical,1
+tseries,read.ts,2,0,0,character,1
+tseries,read.ts,3,0,0,double,1
+tseries,read.ts,4,0,0,...,1
+tseries,residuals.arma,-1,0,0,class<`ts`>,1
+tseries,residuals.arma,0,0,0,class<`arma`>,1
+tseries,residuals.arma,1,0,0,...,1
+tseries,runs.test,-1,0,0,class<`htest`>,1
+tseries,runs.test,0,0,0,class<`factor`>,1
+tseries,runs.test,1,0,0,character[],1
+tseries,seqplot.ts,-1,0,0,null,1
+tseries,seqplot.ts,0,0,0,"class<`matrix`, `mts`, `ts`>",1
+tseries,seqplot.ts,1,0,0,"class<`matrix`, `mts`, `ts`>",1
+tseries,seqplot.ts,2,0,0,character,1
+tseries,seqplot.ts,3,0,0,character,1
+tseries,seqplot.ts,4,0,0,character,1
+tseries,seqplot.ts,5,0,0,character,1
+tseries,seqplot.ts,6,0,0,double,1
+tseries,seqplot.ts,7,0,0,double,1
+tseries,sharpe,-1,0,0,double,1
+tseries,sharpe,0,0,0,class<`ts`>,1
+tseries,sharpe,1,0,0,double,1
+tseries,sharpe,2,0,0,double,1
+tseries,sterling,-1,0,0,double,1
+tseries,sterling,0,0,0,class<`ts`>,1
+tseries,summary.arma,-1,0,0,class<`summary.arma`>,1
+tseries,summary.arma,0,0,0,class<`arma`>,1
+tseries,summary.arma,1,0,0,...,1
+tseries,summary.garch,-1,0,0,class<`summary.garch`>,1
+tseries,summary.garch,0,0,0,class<`garch`>,1
+tseries,summary.garch,1,0,0,...,1
+tseries,surrogate,-1,0,0,class<`resample.statistic`>,1
+tseries,surrogate,-1,0,1,integer[],1
+tseries,surrogate,0,0,0,class<`ts`>,1
+tseries,surrogate,0,0,1,integer[],1
+tseries,surrogate,1,0,0,double,1
+tseries,surrogate,2,0,0,logical,1
+tseries,surrogate,3,0,0,logical,1
+tseries,surrogate,4,0,0,class<`function`>,1
+tseries,surrogate,4,0,1,null,1
+tseries,surrogate,5,0,0,...,1
+tseries,terasvirta.test,-1,0,0,class<`htest`>,1
+tseries,terasvirta.test,0,0,0,class<`matrix`>,1
+tseries,terasvirta.test,0,0,1,class<`ts`>,1
+tseries,terasvirta.test,0,0,2,double[],1
+tseries,terasvirta.test,1,0,0,...,1
+tseries,terasvirta.test.default,-1,0,0,class<`htest`>,1
+tseries,terasvirta.test.default,0,0,0,class<`matrix`>,1
+tseries,terasvirta.test.default,0,0,1,double[],1
+tseries,terasvirta.test.default,1,0,0,double[],1
+tseries,terasvirta.test.default,2,0,0,character[],1
+tseries,terasvirta.test.default,3,0,0,logical,1
+tseries,terasvirta.test.default,4,0,0,...,1
+tseries,terasvirta.test.ts,-1,0,0,class<`htest`>,1
+tseries,terasvirta.test.ts,0,0,0,class<`ts`>,1
+tseries,terasvirta.test.ts,1,0,0,double,1
+tseries,terasvirta.test.ts,2,0,0,character[],1
+tseries,terasvirta.test.ts,3,0,0,logical,1
+tseries,terasvirta.test.ts,4,0,0,...,1
+tseries,time.irts,-1,0,0,"class<`POSIXct`, `POSIXt`>",1
+tseries,time.irts,0,0,0,class<`irts`>,1
+tseries,time.irts,1,0,0,...,1
+tseries,tsbootstrap,-1,0,0,class<`resample.statistic`>,1
+tseries,tsbootstrap,0,0,0,class<`ts`>,1
+tseries,tsbootstrap,1,0,0,double,1
+tseries,tsbootstrap,2,0,0,class<`function`>,1
+tseries,tsbootstrap,3,0,0,double,1
+tseries,tsbootstrap,4,0,0,null,1
+tseries,tsbootstrap,5,0,0,character[],1
+tseries,tsbootstrap,6,0,0,...,1
+tseries,value,-1,0,0,class<`matrix`>,1
+tseries,value,-1,0,1,double[],1
+tseries,value,0,0,0,class<`irts`>,1
+tseries,value,1,0,0,...,1
+tseries,value.irts,-1,0,0,class<`matrix`>,1
+tseries,value.irts,-1,0,1,double[],1
+tseries,value.irts,0,0,0,class<`irts`>,1
+tseries,value.irts,1,0,0,...,1
+tseries,weekday,-1,0,0,integer[],1
+tseries,weekday,0,0,0,class<`irts`>,1
+tseries,weekday,1,0,0,character,1
+tseries,white.test,-1,0,0,class<`htest`>,1
+tseries,white.test,0,0,0,class<`matrix`>,1
+tseries,white.test,0,0,1,class<`ts`>,1
+tseries,white.test,0,0,2,double[],1
+tseries,white.test,1,0,0,...,1
+tseries,white.test.default,-1,0,0,class<`htest`>,1
+tseries,white.test.default,0,0,0,class<`matrix`>,1
+tseries,white.test.default,0,0,1,double[],1
+tseries,white.test.default,1,0,0,double[],1
+tseries,white.test.default,2,0,0,double,1
+tseries,white.test.default,3,0,0,double,1
+tseries,white.test.default,4,0,0,double,1
+tseries,white.test.default,5,0,0,character[],1
+tseries,white.test.default,6,0,0,logical,1
+tseries,white.test.default,7,0,0,...,1
+tseries,white.test.ts,-1,0,0,class<`htest`>,1
+tseries,white.test.ts,0,0,0,class<`ts`>,1
+tseries,white.test.ts,1,0,0,double,1
+tseries,white.test.ts,2,0,0,double,1
+tseries,white.test.ts,3,0,0,double,1
+tseries,white.test.ts,4,0,0,double,1
+tseries,white.test.ts,5,0,0,character[],1
+tseries,white.test.ts,6,0,0,logical,1
+tseries,white.test.ts,7,0,0,...,1
+ucminf,ucminf,-1,0,0,list<double[] | character>,1
+ucminf,ucminf,0,0,0,double[],1
+ucminf,ucminf,1,0,0,class<`function`>,1
+ucminf,ucminf,2,0,0,class<`function`>,1
+ucminf,ucminf,3,0,0,...,1
+ucminf,ucminf,4,0,0,list<double>,1
+ucminf,ucminf,5,0,0,double,1
+units,%|%,-1,0,0,character,1
+units,%|%,0,0,0,character,1
+units,%|%,0,0,1,null,1
+units,%|%,1,0,0,character,1
+units,all.equal.units,-1,0,0,logical,1
+units,all.equal.units,0,0,0,class<`units`>,1
+units,all.equal.units,1,0,0,class<`units`>,1
+units,all.equal.units,2,0,0,...,1
+units,are_convertible,-1,0,0,logical,1
+units,are_convertible,0,0,0,character,1
+units,are_convertible,1,0,0,character,1
+units,are_exponents_implicit,-1,0,0,logical,1
+units,are_exponents_implicit,0,0,0,character,1
+units,as.character.symbolic_units,-1,0,0,character,1
+units,as.character.symbolic_units,0,0,0,class<`symbolic_units`>,1
+units,as.character.symbolic_units,1,0,0,...,1
+units,as.character.symbolic_units,2,0,0,any,1
+units,as.character.symbolic_units,3,0,0,logical,1
+units,as.character.symbolic_units,4,0,0,character,1
+units,as.data.frame.units,-1,0,0,class<`data.frame`>,1
+units,as.data.frame.units,0,0,0,class<`units`>,1
+units,as.data.frame.units,1,0,0,null,1
+units,as.data.frame.units,2,0,0,logical,1
+units,as.data.frame.units,3,0,0,...,1
+units,as_difftime,-1,0,0,class<`difftime`>,1
+units,as_difftime,0,0,0,class<`units`>,1
+units,.as.mixed_units,-1,0,0,class<`mixed_units`>,1
+units,.as.mixed_units,0,0,0,list<class<`units`>>,1
+units,.as.units,-1,0,0,class<`units`>,1
+units,.as.units,0,0,0,class<`units`>,1
+units,.as.units,0,0,1,double[],1
+units,.as.units,1,0,0,class<`symbolic_units`>,1
+units,.as.units,2,0,0,any,1
+units,as_units,-1,0,0,class<`units`>,1
+units,as_units,-1,0,1,null,1
+units,as_units,0,0,0,character,1
+units,as_units,0,0,1,class<`call`>,1
+units,as_units,0,0,2,class<`difftime`>,1
+units,as_units,0,0,3,class<`name`>,1
+units,as_units,0,0,4,class<`symbolic_units`>,1
+units,as_units,0,0,5,class<`units`>,1
+units,as_units,0,0,6,double[],1
+units,as_units,0,0,7,null,1
+units,as_units,1,0,0,...,1
+units,as_units.call,-1,0,0,class<`units`>,1
+units,as_units.call,0,0,0,class<`call`>,1
+units,as_units.call,0,0,1,class<`name`>,1
+units,as_units.call,1,0,0,logical,1
+units,as_units.call,2,0,0,...,1
+units,as_units.character,-1,0,0,class<`units`>,1
+units,as_units.character,0,0,0,character,1
+units,as_units.character,1,0,0,logical,1
+units,as_units.character,2,0,0,logical,1
+units,as_units.character,2,0,1,null,1
+units,as_units.character,3,0,0,logical,1
+units,as_units.character,4,0,0,...,1
+units,as_units.default,-1,0,0,class<`units`>,1
+units,as_units.default,-1,0,1,null,1
+units,as_units.default,0,0,0,double[],1
+units,as_units.default,0,0,1,null,1
+units,as_units.default,1,0,0,any,1
+units,as_units.default,2,0,0,...,1
+units,as_units.difftime,-1,0,0,class<`units`>,1
+units,as_units.difftime,0,0,0,class<`difftime`>,1
+units,as_units.difftime,1,0,0,any,1
+units,as_units.difftime,2,0,0,...,1
+units,as_units.name,-1,0,0,class<`units`>,1
+units,as_units.name,0,0,0,class<`call`>,1
+units,as_units.name,0,0,1,class<`name`>,1
+units,as_units.name,1,0,0,logical,1
+units,as_units.name,2,0,0,...,1
+units,as_units.symbolic_units,-1,0,0,class<`units`>,1
+units,as_units.symbolic_units,0,0,0,class<`symbolic_units`>,1
+units,as_units.symbolic_units,1,0,0,any,1
+units,as_units.symbolic_units,2,0,0,...,1
+units,as_units.units,-1,0,0,class<`units`>,1
+units,as_units.units,0,0,0,class<`units`>,1
+units,as_units.units,1,0,0,any,1
+units,as_units.units,2,0,0,...,1
+units,backtick,-1,0,0,character,1
+units,backtick,0,0,0,character,1
+units,boxplot.units,-1,0,0,list<class<`matrix`> | double[] | character>,1
+units,boxplot.units,0,0,0,class<`units`>,1
+units,boxplot.units,1,0,0,...,1
+units,boxplot.units,2,0,0,logical,1
+units,check_unit_format,-1,0,0,character,1
+units,check_unit_format,0,0,0,character,1
+units,convert,-1,0,0,double[],1
+units,convert,0,0,0,class<`units`>,1
+units,convert,1,0,0,character,1
+units,convert,2,0,0,character,1
+units,convert_implicit_to_explicit_exponents,-1,0,0,character,1
+units,convert_implicit_to_explicit_exponents,0,0,0,character,1
+units,c.units,-1,0,0,class<`units`>,1
+units,c.units,0,0,0,...,1
+units,c.units,1,0,0,logical,1
+units,c.units,2,0,0,any,1
+units,deparse_unit,-1,0,0,character,1
+units,deparse_unit,0,0,0,class<`units`>,1
+units,drop_units,-1,0,0,class<`data.frame`>,1
+units,drop_units,-1,0,1,double[],1
+units,drop_units,0,0,0,class<`data.frame`>,1
+units,drop_units,0,0,1,class<`units`>,1
+units,drop_units.data.frame,-1,0,0,class<`data.frame`>,1
+units,drop_units.data.frame,0,0,0,class<`data.frame`>,1
+units,drop_units.units,-1,0,0,double[],1
+units,drop_units.units,0,0,0,class<`units`>,1
+units,%empty%,-1,0,0,character[],1
+units,%empty%,0,0,0,character[],1
+units,%empty%,1,0,0,character,1
+units,.get_ud_db_all,-1,0,0,class<`data.frame`>,1
+units,.get_ud_prefixes_xml,-1,0,0,"class<`xml_document`, `xml_node`>",1
+units,.get_ud_xml_dir,-1,0,0,character,1
+units,.get_ud_xml_dir,0,0,0,logical,1
+units,hist.units,-1,0,0,class<`histogram`>,1
+units,hist.units,0,0,0,class<`units`>,1
+units,hist.units,1,0,0,null,1
+units,hist.units,2,0,0,character,1
+units,hist.units,3,0,0,...,1
+units,install_conversion_constant,-1,0,0,null,1
+units,install_conversion_constant,0,0,0,character,1
+units,install_conversion_constant,1,0,0,character,1
+units,install_conversion_constant,2,0,0,double,1
+units,install_conversion_offset,-1,0,0,null,1
+units,install_conversion_offset,0,0,0,character,1
+units,install_conversion_offset,1,0,0,character,1
+units,install_conversion_offset,2,0,0,double,1
+units,install_symbolic_unit,-1,0,0,null,1
+units,install_symbolic_unit,0,0,0,character,1
+units,install_symbolic_unit,1,0,0,logical,1
+units,install_symbolic_unit,2,0,0,logical,1
+units,is_udunits_time,-1,0,0,logical,1
+units,is_udunits_time,0,0,0,character,1
+units,log10.units,-1,0,0,class<`units`>,1
+units,log10.units,0,0,0,class<`units`>,1
+units,log2.units,-1,0,0,class<`units`>,1
+units,log2.units,0,0,0,class<`units`>,1
+units,make_unit_label,-1,0,0,character,1
+units,make_unit_label,-1,0,1,expression,1
+units,make_unit_label,0,0,0,character,1
+units,make_unit_label,1,0,0,class<`units`>,1
+units,make_unit_label,2,0,0,any,1
+units,make_unit_label,3,0,0,character[],1
+units,make_unit_label,4,0,0,logical,1
+units,make_units,-1,0,0,class<`units`>,1
+units,make_units,0,0,0,any,1
+units,make_units,1,0,0,logical,1
+units,Math.units,-1,0,0,class<`units`>,1
+units,Math.units,-1,0,1,double[],1
+units,Math.units,0,0,0,class<`units`>,1
+units,Math.units,1,0,0,...,1
+units,.message_where_udunits_db,-1,0,0,null,1
+units,mixed_units,-1,0,0,class<`mixed_units`>,1
+units,mixed_units,0,0,0,class<`units`>,1
+units,mixed_units,0,0,1,double[],1
+units,mixed_units,1,0,0,any,1
+units,mixed_units,2,0,0,...,1
+units,mixed_units.numeric,-1,0,0,class<`mixed_units`>,1
+units,mixed_units.numeric,0,0,0,double[],1
+units,mixed_units.numeric,1,0,0,character[],1
+units,mixed_units.numeric,2,0,0,...,1
+units,mixed_units.units,-1,0,0,class<`mixed_units`>,1
+units,mixed_units.units,0,0,0,class<`units`>,1
+units,mixed_units.units,1,0,0,any,1
+units,mixed_units.units,2,0,0,...,1
+units,Ops.symbolic_units,-1,0,0,logical,1
+units,Ops.symbolic_units,0,0,0,class<`symbolic_units`>,1
+units,Ops.symbolic_units,1,0,0,class<`symbolic_units`>,1
+units,Ops.units,-1,0,0,class<`units`>,1
+units,Ops.units,0,0,0,class<`units`>,1
+units,Ops.units,0,0,1,double[],1
+units,Ops.units,1,0,0,class<`units`>,1
+units,Ops.units,1,0,1,double,1
+units,pcc,-1,0,0,character,1
+units,pcc,0,0,0,...,1
+units,plot.units,-1,0,0,null,1
+units,plot.units,0,0,0,class<`units`>,1
+units,plot.units,1,0,0,any,1
+units,plot.units,2,0,0,null,1
+units,plot.units,3,0,0,null,1
+units,plot.units,4,0,0,...,1
+units,.pretty_print_sequence,-1,0,0,character,1
+units,.pretty_print_sequence,0,0,0,character[],1
+units,.pretty_print_sequence,1,0,0,character,1
+units,.pretty_print_sequence,2,0,0,logical,1
+units,.pretty_print_sequence,3,0,0,character,1
+units,R_convert_doubles,-1,0,0,double[],1
+units,R_convert_doubles,0,0,0,externalptr,1
+units,R_convert_doubles,1,0,0,externalptr,1
+units,R_convert_doubles,2,0,0,double[],1
+units,.read_ud_db,-1,0,0,"class<`xml_document`, `xml_node`>",1
+units,.read_ud_db,0,0,0,character,1
+units,.read_ud_db,1,0,0,character,1
+units,.read_ud_db_as_dataframe,-1,0,0,class<`data.frame`>,1
+units,.read_ud_db_as_dataframe,0,0,0,character,1
+units,R_ut_are_convertible,-1,0,0,logical,1
+units,R_ut_are_convertible,0,0,0,externalptr,1
+units,R_ut_are_convertible,1,0,0,externalptr,1
+units,R_ut_format,-1,0,0,character,1
+units,R_ut_format,0,0,0,externalptr,1
+units,R_ut_format,1,0,0,logical,1
+units,R_ut_format,2,0,0,logical,1
+units,R_ut_format,3,0,0,logical,1
+units,R_ut_get_name,-1,0,0,character,1
+units,R_ut_get_name,0,0,0,character,1
+units,R_ut_get_symbol,-1,0,0,character,1
+units,R_ut_get_symbol,0,0,0,character,1
+units,R_ut_log,-1,0,0,externalptr,1
+units,R_ut_log,0,0,0,externalptr,1
+units,R_ut_log,1,0,0,double,1
+units,R_ut_new_dimensionless_unit,-1,0,0,null,1
+units,R_ut_new_dimensionless_unit,0,0,0,character,1
+units,R_ut_offset,-1,0,0,null,1
+units,R_ut_offset,0,0,0,character,1
+units,R_ut_offset,1,0,0,character,1
+units,R_ut_offset,2,0,0,double,1
+units,R_ut_parse,-1,0,0,any,1
+units,R_ut_parse,0,0,0,character,1
+units,R_ut_scale,-1,0,0,null,1
+units,R_ut_scale,0,0,0,character,1
+units,R_ut_scale,1,0,0,character,1
+units,R_ut_scale,2,0,0,double,1
+units,R_ut_set_encoding,-1,0,0,null,1
+units,R_ut_set_encoding,0,0,0,character,1
+units,.same_units,-1,0,0,logical,1
+units,.same_units,0,0,0,class<`symbolic_units`>,1
+units,.same_units,1,0,0,class<`symbolic_units`>,1
+units,seq.units,-1,0,0,class<`units`>,1
+units,seq.units,0,0,0,any,1
+units,seq.units,1,0,0,any,1
+units,seq.units,2,0,0,any,1
+units,seq.units,3,0,0,null,1
+units,seq.units,3,0,1,double,1
+units,seq.units,4,0,0,null,1
+units,seq.units,5,0,0,...,1
+units,.setopt,-1,0,0,character[],1
+units,.setopt,-1,0,1,logical,1
+units,.setopt,-1,0,2,null,1
+units,.setopt,0,0,0,character[],1
+units,.setopt,0,0,1,logical,1
+units,.setopt,0,0,2,null,1
+units,set_units,-1,0,0,class<`mixed_units`>,1
+units,set_units,-1,0,1,class<`units`>,1
+units,set_units,-1,0,2,double,1
+units,set_units,0,0,0,class<`mixed_units`>,1
+units,set_units,0,0,1,class<`matrix`>,1
+units,set_units,0,0,2,class<`units`>,1
+units,set_units,0,0,3,double[],1
+units,set_units,1,0,0,any,1
+units,set_units,2,0,0,...,1
+units,set_units,3,0,0,any,1
+units,set_units.mixed_units,-1,0,0,class<`mixed_units`>,1
+units,set_units.mixed_units,0,0,0,list<class<`units`>>,1
+units,set_units.mixed_units,0,0,1,class<`mixed_units`>,1
+units,set_units.mixed_units,1,0,0,character[],1
+units,set_units.mixed_units,2,0,0,...,1
+units,set_units.mixed_units,3,0,0,character,1
+units,set_units.numeric,-1,0,0,class<`units`>,1
+units,set_units.numeric,-1,0,1,double,1
+units,set_units.numeric,0,0,0,class<`matrix`>,1
+units,set_units.numeric,0,0,1,double[],1
+units,set_units.numeric,0,0,2,class<`units`>,1
+units,set_units.numeric,1,0,0,any,1
+units,set_units.numeric,2,0,0,...,1
+units,set_units.numeric,3,0,0,any,1
+units,set_units.units,-1,0,0,class<`units`>,1
+units,set_units.units,-1,0,1,double,1
+units,set_units.units,0,0,0,class<`matrix`>,1
+units,set_units.units,0,0,1,double[],1
+units,set_units.units,0,0,2,class<`units`>,1
+units,set_units.units,1,0,0,any,1
+units,set_units.units,2,0,0,...,1
+units,set_units.units,3,0,0,any,1
+units,.simplify_units,-1,0,0,class<`units`>,1
+units,.simplify_units,0,0,0,class<`units`>,1
+units,.simplify_units,1,0,0,class<`symbolic_units`>,1
+units,summary.units,-1,0,0,"class<`summaryDefault`, `table`>",1
+units,summary.units,0,0,0,class<`units`>,1
+units,summary.units,1,0,0,...,1
+units,Summary.units,-1,0,0,class<`units`>,1
+units,Summary.units,0,0,0,...,1
+units,Summary.units,1,0,0,logical,1
+units,symbolic_unit,-1,0,0,class<`units`>,1
+units,symbolic_unit,0,0,0,character,1
+units,symbolic_unit,1,0,0,logical,1
+units,.symbolic_units,-1,0,0,class<`symbolic_units`>,1
+units,.symbolic_units,0,0,0,character[],1
+units,.symbolic_units,1,0,0,character[],1
+units,ud_are_convertible,-1,0,0,logical,1
+units,ud_are_convertible,0,0,0,character,1
+units,ud_are_convertible,0,0,1,class<`symbolic_units`>,1
+units,ud_are_convertible,1,0,0,character,1
+units,ud_are_convertible,1,0,1,class<`symbolic_units`>,1
+units,ud_convert,-1,0,0,double[],1
+units,ud_convert,0,0,0,double[],1
+units,ud_convert,1,0,0,character,1
+units,ud_convert,2,0,0,character,1
+units,.ud_db_xml_list_as_dataframe,-1,0,0,class<`data.frame`>,1
+units,.ud_db_xml_list_as_dataframe,0,0,0,"class<`xml_document`, `xml_node`>",1
+units,ud_get_symbol,-1,0,0,character,1
+units,ud_get_symbol,0,0,0,character,1
+units,ud_is_parseable,-1,0,0,logical,1
+units,ud_is_parseable,0,0,0,character,1
+units,ud_set_encoding,-1,0,0,null,1
+units,ud_set_encoding,0,0,0,character,1
+units,udunits_init,-1,0,0,null,1
+units,udunits_init,0,0,0,character,1
+units,[.units,-1,0,0,class<`units`>,1
+units,[.units,0,0,0,class<`units`>,1
+units,[.units,1,0,0,double,1
+units,[.units,1,0,1,integer[],1
+units,[.units,2,0,0,any,1
+units,[.units,3,0,0,...,1
+units,[.units,4,0,0,logical,1
+units,.units_are_convertible,-1,0,0,logical,1
+units,.units_are_convertible,0,0,0,list<class<`units`>>,1
+units,.units_are_convertible,1,0,0,class<`symbolic_units`>,1
+units,units<-.numeric,-1,0,0,class<`units`>,1
+units,units<-.numeric,-1,0,1,double,1
+units,units<-.numeric,0,0,0,class<`matrix`>,1
+units,units<-.numeric,0,0,1,double[],1
+units,units<-.numeric,1,0,0,class<`units`>,1
+units,units<-.numeric,1,0,1,class<`symbolic_units`>,1
+units,units<-.numeric,1,0,2,character,1
+units,units<-.numeric,1,0,3,class<`call`>,1
+units,units<-.numeric,1,0,4,null,1
+units,units_options,-1,0,0,list<logical>,1
+units,units_options,-1,0,1,character[],1
+units,units_options,-1,0,2,logical,1
+units,units_options,-1,0,3,list<character[]>,1
+units,units_options,-1,0,4,list<character[] | logical>,1
+units,units_options,-1,0,5,list<null>,1
+units,units_options,-1,0,6,list<character[] | logical | null>,1
+units,units_options,0,0,0,...,1
+units,units_options,1,0,0,any,1
+units,units_options,2,0,0,any,1
+units,units_options,3,0,0,any,1
+units,units_options,4,0,0,any,1
+units,units_options,5,0,0,any,1
+units,units_options,6,0,0,any,1
+units,units_options,7,0,0,any,1
+units,units_options,8,0,0,any,1
+units,units_options,9,0,0,any,1
+units,units_options,10,0,0,any,1
+units,.units.simplify,-1,0,0,logical,1
+units,.units.simplify,-1,0,1,null,1
+units,units<-.units,-1,0,0,class<`mixed_units`>,1
+units,units<-.units,-1,0,1,class<`units`>,1
+units,units<-.units,-1,0,2,double,1
+units,units<-.units,0,0,0,class<`units`>,1
+units,units<-.units,1,0,0,character[],1
+units,units<-.units,1,0,1,class<`symbolic_units`>,1
+units,units<-.units,1,0,2,class<`units`>,1
+units,units<-.units,1,0,3,null,1
+units,units.units,-1,0,0,class<`symbolic_units`>,1
+units,units.units,0,0,0,class<`units`>,1
+units,valid_udunits,-1,0,0,"class<`data.frame`, `tbl`, `tbl_df`>",1
+units,valid_udunits,0,0,0,logical,1
+units,valid_udunits_prefixes,-1,0,0,"class<`data.frame`, `tbl`, `tbl_df`>",1
+units,valid_udunits_prefixes,0,0,0,logical,1
+units,with.units database,-1,0,0,class<`units`>,1
+units,with.units database,0,0,0,class<`units database`>,1
+units,with.units database,1,0,0,any,1
+units,with.units database,2,0,0,...,1
+urca,ablrtest,-1,0,0,class<`cajo.test`>,1
+urca,ablrtest,0,0,0,class<`ca.jo`>,1
+urca,ablrtest,1,0,0,class<`matrix`>,1
+urca,ablrtest,2,0,0,class<`matrix`>,1
+urca,ablrtest,3,0,0,double,1
+urca,alphaols,-1,0,0,class<`lm`>,1
+urca,alphaols,-1,0,1,"class<`lm`, `mlm`>",1
+urca,alphaols,0,0,0,class<`ca.jo`>,1
+urca,alphaols,1,0,0,double,1
+urca,alphaols,1,0,1,null,1
+urca,alrtest,-1,0,0,class<`cajo.test`>,1
+urca,alrtest,0,0,0,class<`ca.jo`>,1
+urca,alrtest,1,0,0,class<`matrix`>,1
+urca,alrtest,2,0,0,double,1
+urca,bh5lrtest,-1,0,0,class<`cajo.test`>,1
+urca,bh5lrtest,0,0,0,class<`ca.jo`>,1
+urca,bh5lrtest,1,0,0,double[],1
+urca,bh5lrtest,2,0,0,double,1
+urca,bh6lrtest,-1,0,0,class<`cajo.test`>,1
+urca,bh6lrtest,0,0,0,class<`ca.jo`>,1
+urca,bh6lrtest,1,0,0,class<`matrix`>,1
+urca,bh6lrtest,2,0,0,double,1
+urca,bh6lrtest,3,0,0,double,1
+urca,bh6lrtest,4,0,0,double,1
+urca,bh6lrtest,5,0,0,double,1
+urca,blrtest,-1,0,0,class<`cajo.test`>,1
+urca,blrtest,0,0,0,class<`ca.jo`>,1
+urca,blrtest,1,0,0,class<`matrix`>,1
+urca,blrtest,2,0,0,double,1
+urca,ca.jo,-1,0,0,class<`ca.jo`>,1
+urca,ca.jo,0,0,0,class<`data.frame`>,1
+urca,ca.jo,0,0,1,class<`matrix`>,1
+urca,ca.jo,1,0,0,character[],1
+urca,ca.jo,2,0,0,character[],1
+urca,ca.jo,3,0,0,double,1
+urca,ca.jo,4,0,0,character[],1
+urca,ca.jo,5,0,0,double,1
+urca,ca.jo,6,0,0,null,1
+urca,ca.jo,6,0,1,class<`matrix`>,1
+urca,cajolst,-1,0,0,class<`ca.jo`>,1
+urca,cajolst,0,0,0,class<`data.frame`>,1
+urca,cajolst,1,0,0,logical,1
+urca,cajolst,2,0,0,double,1
+urca,cajolst,3,0,0,double,1
+urca,cajools,-1,0,0,"class<`lm`, `mlm`>",1
+urca,cajools,0,0,0,class<`ca.jo`>,1
+urca,cajools,1,0,0,null,1
+urca,cajorls,-1,0,0,"list<class<`lm`, `mlm`> | class<`matrix`>>",1
+urca,cajorls,0,0,0,class<`ca.jo`>,1
+urca,cajorls,1,0,0,double,1
+urca,cajorls,2,0,0,null,1
+urca,ca.po,-1,0,0,class<`ca.po`>,1
+urca,ca.po,0,0,0,class<`matrix`>,1
+urca,ca.po,1,0,0,character[],1
+urca,ca.po,2,0,0,character[],1
+urca,ca.po,3,0,0,character,1
+urca,ca.po,4,0,0,null,1
+urca,lttest,-1,0,0,class<`matrix`>,1
+urca,lttest,0,0,0,class<`ca.jo`>,1
+urca,lttest,1,0,0,double,1
+urca,plot,-1,0,0,list<list<double[]>>,1
+urca,plot,0,0,0,class<`ur.za`>,1
+urca,plot,1,0,0,any,1
+urca,plot,2,0,0,...,1
+urca,plot,-1,1,0,class<`acf`>,1
+urca,plot,0,1,0,class<`ur.sp`>,1
+urca,plot,1,1,0,any,1
+urca,plot,2,1,0,...,1
+urca,plot,-1,2,0,class<`acf`>,1
+urca,plot,0,2,0,class<`ur.pp`>,1
+urca,plot,1,2,0,any,1
+urca,plot,2,2,0,...,1
+urca,plot,-1,3,0,class<`acf`>,1
+urca,plot,0,3,0,class<`ur.ers`>,1
+urca,plot,1,3,0,any,1
+urca,plot,2,3,0,...,1
+urca,plot,-1,4,0,class<`acf`>,1
+urca,plot,0,4,0,class<`ur.kpss`>,1
+urca,plot,1,4,0,any,1
+urca,plot,2,4,0,...,1
+urca,plot,-1,5,0,null,1
+urca,plot,0,5,0,class<`ca.jo`>,1
+urca,plot,1,5,0,any,1
+urca,plot,2,5,0,...,1
+urca,plotres,-1,0,0,null,1
+urca,plotres,0,0,0,class<`ca.jo`>,1
+urca,punitroot,-1,0,0,double,1
+urca,punitroot,0,0,0,double,1
+urca,punitroot,1,0,0,double,1
+urca,punitroot,2,0,0,character,1
+urca,punitroot,3,0,0,character,1
+urca,punitroot,4,0,0,logical,1
+urca,qunitroot,-1,0,0,double[],1
+urca,qunitroot,0,0,0,double[],1
+urca,qunitroot,1,0,0,double,1
+urca,qunitroot,2,0,0,character,1
+urca,qunitroot,3,0,0,character,1
+urca,qunitroot,4,0,0,logical,1
+urca,.spcv,-1,0,0,double,1
+urca,.spcv,0,0,0,integer,1
+urca,.spcv,1,0,0,character,1
+urca,.spcv,2,0,0,double,1
+urca,.spcv,3,0,0,double,1
+urca,.strsplitUrcval,-1,0,0,list<character[]>,1
+urca,.strsplitUrcval,0,0,0,character[],1
+urca,.strsplitUrcval,1,0,0,character,1
+urca,summary,-1,0,0,class<`sumurca`>,1
+urca,summary,0,0,0,class<`ca.jo`>,1
+urca,summary,1,0,0,...,1
+urca,summary,-1,1,0,class<`sumurca`>,1
+urca,summary,0,1,0,class<`ur.kpss`>,1
+urca,summary,1,1,0,...,1
+urca,summary,-1,2,0,class<`sumurca`>,1
+urca,summary,0,2,0,class<`cajo.test`>,1
+urca,summary,1,2,0,...,1
+urca,summary,-1,3,0,class<`sumurca`>,1
+urca,summary,0,3,0,class<`ur.ers`>,1
+urca,summary,1,3,0,...,1
+urca,summary,-1,4,0,class<`sumurca`>,1
+urca,summary,0,4,0,class<`ur.df`>,1
+urca,summary,1,4,0,...,1
+urca,summary,-1,5,0,class<`sumurca`>,1
+urca,summary,0,5,0,class<`ur.sp`>,1
+urca,summary,1,5,0,...,1
+urca,summary,-1,6,0,class<`sumurca`>,1
+urca,summary,0,6,0,class<`ca.po`>,1
+urca,summary,1,6,0,...,1
+urca,summary,-1,7,0,class<`sumurca`>,1
+urca,summary,0,7,0,class<`ur.pp`>,1
+urca,summary,1,7,0,...,1
+urca,summary,-1,8,0,class<`sumurca`>,1
+urca,summary,0,8,0,class<`ur.za`>,1
+urca,summary,1,8,0,...,1
+urca,unitrootTable,-1,0,0,class<`matrix`>,1
+urca,unitrootTable,0,0,0,character,1
+urca,unitrootTable,1,0,0,character[],1
+urca,.urcval,-1,0,0,double,1
+urca,.urcval,0,0,0,double,1
+urca,.urcval,1,0,0,double,1
+urca,.urcval,2,0,0,double,1
+urca,.urcval,3,0,0,double,1
+urca,.urcval,4,0,0,double,1
+urca,.urcval,5,0,0,double,1
+urca,ur.df,-1,0,0,class<`ur.df`>,1
+urca,ur.df,0,0,0,double[],1
+urca,ur.df,1,0,0,character,1
+urca,ur.df,2,0,0,double,1
+urca,ur.df,3,0,0,character[],1
+urca,ur.ers,-1,0,0,class<`ur.ers`>,1
+urca,ur.ers,0,0,0,double[],1
+urca,ur.ers,1,0,0,character,1
+urca,ur.ers,2,0,0,character,1
+urca,ur.ers,3,0,0,double,1
+urca,ur.kpss,-1,0,0,class<`ur.kpss`>,1
+urca,ur.kpss,0,0,0,double[],1
+urca,ur.kpss,1,0,0,character,1
+urca,ur.kpss,2,0,0,character,1
+urca,ur.kpss,3,0,0,null,1
+urca,ur.pp,-1,0,0,class<`ur.pp`>,1
+urca,ur.pp,0,0,0,double[],1
+urca,ur.pp,1,0,0,character,1
+urca,ur.pp,2,0,0,character,1
+urca,ur.pp,3,0,0,character,1
+urca,ur.pp,4,0,0,null,1
+urca,ur.sp,-1,0,0,class<`ur.sp`>,1
+urca,ur.sp,0,0,0,double[],1
+urca,ur.sp,1,0,0,character,1
+urca,ur.sp,2,0,0,double,1
+urca,ur.sp,3,0,0,double,1
+urca,ur.za,-1,0,0,class<`ur.za`>,1
+urca,ur.za,0,0,0,double[],1
+urca,ur.za,1,0,0,character,1
+urca,ur.za,2,0,0,double,1
+urltools,domain,-1,0,0,character,1
+urltools,domain,0,0,0,character,1
+urltools,domain<-,-1,0,0,character,1
+urltools,domain<-,0,0,0,character,1
+urltools,domain<-,1,0,0,character,1
+urltools,domain<-,-1,1,0,character,1
+urltools,domain<-,0,1,0,character,1
+urltools,domain<-,1,1,0,character,1
+urltools,finalise_suffixes,-1,0,0,class<`data.frame`>,1
+urltools,finalise_suffixes,0,0,0,character,1
+urltools,finalise_suffixes,1,0,0,character,1
+urltools,finalise_suffixes,2,0,0,logical,1
+urltools,finalise_suffixes,3,0,0,logical,1
+urltools,fragment,-1,0,0,character,1
+urltools,fragment,0,0,0,character,1
+urltools,fragment<-,-1,0,0,character,1
+urltools,fragment<-,0,0,0,character,1
+urltools,fragment<-,1,0,0,character,1
+urltools,fragment<-,1,0,1,null,1
+urltools,fragment<-,-1,1,0,character,1
+urltools,fragment<-,0,1,0,character,1
+urltools,fragment<-,1,1,0,character,1
+urltools,fragment<-,1,1,1,null,1
+urltools,get_component_,-1,0,0,character,1
+urltools,get_component_,0,0,0,character,1
+urltools,get_component_,1,0,0,double,1
+urltools,get_credentials,-1,0,0,class<`data.frame`>,1
+urltools,get_credentials,0,0,0,character,1
+urltools,host_extract,-1,0,0,class<`data.frame`>,1
+urltools,host_extract,0,0,0,character,1
+urltools,host_extract_,-1,0,0,character,1
+urltools,host_extract_,0,0,0,character,1
+urltools,parameters,-1,0,0,character,1
+urltools,parameters,0,0,0,character,1
+urltools,parameters<-,-1,0,0,character,1
+urltools,parameters<-,0,0,0,character,1
+urltools,parameters<-,1,0,0,character,1
+urltools,parameters<-,1,0,1,null,1
+urltools,parameters<-,-1,1,0,character,1
+urltools,parameters<-,0,1,0,character,1
+urltools,parameters<-,1,1,0,character,1
+urltools,parameters<-,1,1,1,null,1
+urltools,param_get,-1,0,0,class<`data.frame`>,1
+urltools,param_get,0,0,0,character,1
+urltools,param_get,1,0,0,character[],1
+urltools,param_remove,-1,0,0,character,1
+urltools,param_remove,0,0,0,character,1
+urltools,param_remove,1,0,0,character[],1
+urltools,param_set,-1,0,0,character,1
+urltools,param_set,0,0,0,character,1
+urltools,param_set,1,0,0,character,1
+urltools,param_set,2,0,0,character,1
+urltools,path,-1,0,0,character,1
+urltools,path,0,0,0,character,1
+urltools,path<-,-1,0,0,character,1
+urltools,path<-,0,0,0,character,1
+urltools,path<-,1,0,0,character,1
+urltools,path<-,1,0,1,null,1
+urltools,path<-,-1,1,0,character,1
+urltools,path<-,0,1,0,character,1
+urltools,path<-,1,1,0,character,1
+urltools,path<-,1,1,1,null,1
+urltools,port,-1,0,0,character,1
+urltools,port,0,0,0,character,1
+urltools,port<-,-1,0,0,character,1
+urltools,port<-,0,0,0,character,1
+urltools,port<-,1,0,0,character,1
+urltools,port<-,1,0,1,null,1
+urltools,port<-,-1,1,0,character,1
+urltools,port<-,0,1,0,character,1
+urltools,port<-,1,1,0,character,1
+urltools,port<-,1,1,1,null,1
+urltools,puny_decode,-1,0,0,character,1
+urltools,puny_decode,0,0,0,character,1
+urltools,puny_encode,-1,0,0,character,1
+urltools,puny_encode,0,0,0,character,1
+urltools,reverse_strings,-1,0,0,character[],1
+urltools,reverse_strings,0,0,0,character[],1
+urltools,rm_component_,-1,0,0,character,1
+urltools,rm_component_,0,0,0,character,1
+urltools,rm_component_,1,0,0,double,1
+urltools,scheme,-1,0,0,character,1
+urltools,scheme,0,0,0,character,1
+urltools,scheme<-,-1,0,0,character,1
+urltools,scheme<-,-1,0,1,null,1
+urltools,scheme<-,0,0,0,character,1
+urltools,scheme<-,1,0,0,character,1
+urltools,scheme<-,1,0,1,null,1
+urltools,scheme<-,-1,1,0,character,1
+urltools,scheme<-,-1,1,1,null,1
+urltools,scheme<-,0,1,0,character,1
+urltools,scheme<-,1,1,0,character,1
+urltools,scheme<-,1,1,1,null,1
+urltools,set_component_,-1,0,0,character,1
+urltools,set_component_,0,0,0,character,1
+urltools,set_component_,1,0,0,double,1
+urltools,set_component_,2,0,0,character,1
+urltools,set_component_f,-1,0,0,character,1
+urltools,set_component_f,0,0,0,character,1
+urltools,set_component_f,1,0,0,double,1
+urltools,set_component_f,2,0,0,character,1
+urltools,set_component_f,3,0,0,character,1
+urltools,set_component_r,-1,0,0,character,1
+urltools,set_component_r,-1,0,1,null,1
+urltools,set_component_r,0,0,0,character,1
+urltools,set_component_r,1,0,0,double,1
+urltools,set_component_r,2,0,0,character,1
+urltools,set_component_r,2,0,1,null,1
+urltools,set_component_r,3,0,0,character,1
+urltools,strip_credentials,-1,0,0,character,1
+urltools,strip_credentials,0,0,0,character,1
+urltools,suffix_extract,-1,0,0,class<`data.frame`>,1
+urltools,suffix_extract,0,0,0,character,1
+urltools,suffix_extract,1,0,0,null,1
+urltools,suffix_load,-1,0,0,"list<class<`externalptr`, `string_trie`, `trie`> | character[]>",1
+urltools,suffix_load,0,0,0,null,1
+urltools,tld_extract,-1,0,0,class<`data.frame`>,1
+urltools,tld_extract,0,0,0,character,1
+urltools,tld_extract,1,0,0,character[],1
+urltools,tld_extract,1,0,1,null,1
+urltools,tld_extract_,-1,0,0,character,1
+urltools,tld_extract_,0,0,0,character,1
+urltools,tld_refresh,-1,0,0,character[],1
+urltools,url_compose,-1,0,0,character,1
+urltools,url_compose,0,0,0,class<`data.frame`>,1
+urltools,url_decode,-1,0,0,character,1
+urltools,url_decode,0,0,0,character,1
+urltools,url_encode,-1,0,0,character,1
+urltools,url_encode,0,0,0,character,1
+urltools,url_parse,-1,0,0,class<`data.frame`>,1
+urltools,url_parse,0,0,0,character,1
+utf8,as_character_scalar,-1,0,0,character,1
+utf8,as_character_scalar,-1,0,1,null,1
+utf8,as_character_scalar,0,0,0,any,1
+utf8,as_character_scalar,1,0,0,character,1
+utf8,as_character_scalar,1,0,1,null,1
+utf8,as_character_scalar,2,0,0,logical,1
+utf8,as_character_vector,-1,0,0,character,1
+utf8,as_character_vector,0,0,0,any,1
+utf8,as_character_vector,1,0,0,character,1
+utf8,as_character_vector,2,0,0,logical,1
+utf8,as_chars,-1,0,0,integer,1
+utf8,as_chars,-1,0,1,null,1
+utf8,as_chars,0,0,0,any,1
+utf8,as_chars,1,0,0,double,1
+utf8,as_chars,1,0,1,null,1
+utf8,as_enum,-1,0,0,character,1
+utf8,as_enum,0,0,0,any,1
+utf8,as_enum,1,0,0,character,1
+utf8,as_enum,2,0,0,character[],1
+utf8,as_integer_scalar,-1,0,0,integer,1
+utf8,as_integer_scalar,-1,0,1,null,1
+utf8,as_integer_scalar,0,0,0,any,1
+utf8,as_integer_scalar,1,0,0,double,1
+utf8,as_integer_scalar,1,0,1,null,1
+utf8,as_integer_scalar,2,0,0,logical,1
+utf8,as_integer_vector,-1,0,0,integer,1
+utf8,as_integer_vector,0,0,0,any,1
+utf8,as_integer_vector,1,0,0,double,1
+utf8,as_integer_vector,2,0,0,logical,1
+utf8,as_justify,-1,0,0,character,1
+utf8,as_justify,0,0,0,character,1
+utf8,as_justify,1,0,0,character,1
+utf8,as_max_print,-1,0,0,integer,1
+utf8,as_max_print,-1,0,1,null,1
+utf8,as_max_print,0,0,0,any,1
+utf8,as_max_print,1,0,0,double,1
+utf8,as_max_print,1,0,1,null,1
+utf8,as_na_print,-1,0,0,null,1
+utf8,as_na_print,0,0,0,character,1
+utf8,as_na_print,1,0,0,null,1
+utf8,as_nonnegative,-1,0,0,integer,1
+utf8,as_nonnegative,-1,0,1,null,1
+utf8,as_nonnegative,0,0,0,any,1
+utf8,as_nonnegative,1,0,0,double,1
+utf8,as_nonnegative,1,0,1,null,1
+utf8,as_option,-1,0,0,logical,1
+utf8,as_option,0,0,0,any,1
+utf8,as_option,1,0,0,logical,1
+utf8,as_output_utf8,-1,0,0,logical,1
+utf8,as_output_utf8,0,0,0,character,1
+utf8,as_output_utf8,1,0,0,logical,1
+utf8,as_output_utf8,1,0,1,null,1
+utf8,as_print_gap,-1,0,0,null,1
+utf8,as_print_gap,0,0,0,character,1
+utf8,as_print_gap,1,0,0,null,1
+utf8,as_style,-1,0,0,character,1
+utf8,as_style,-1,0,1,null,1
+utf8,as_style,0,0,0,character,1
+utf8,as_style,1,0,0,character,1
+utf8,as_style,1,0,1,null,1
+utf8,as_utf8,-1,0,0,character[],1
+utf8,as_utf8,0,0,0,character[],1
+utf8,as_utf8,1,0,0,logical,1
+utf8,element_width,-1,0,0,integer,1
+utf8,element_width,0,0,0,character,1
+utf8,element_width,1,0,0,logical,1
+utf8,element_width,2,0,0,any,1
+utf8,element_width,3,0,0,logical,1
+utf8,output_ansi,-1,0,0,logical,1
+utf8,output_utf8,-1,0,0,logical,1
+utf8,print_matrix,-1,0,0,integer,1
+utf8,print_matrix,0,0,0,class<`matrix`>,1
+utf8,print_matrix,1,0,0,logical,1
+utf8,print_matrix,2,0,0,null,1
+utf8,print_matrix,3,0,0,integer,1
+utf8,print_matrix,4,0,0,logical,1
+utf8,print_matrix,5,0,0,integer,1
+utf8,print_matrix,6,0,0,character,1
+utf8,print_matrix,7,0,0,character,1
+utf8,print_matrix,8,0,0,null,1
+utf8,print_matrix,9,0,0,logical,1
+utf8,print_matrix,10,0,0,logical,1
+utf8,print_matrix,11,0,0,logical,1
+utf8,print_table,-1,0,0,integer,1
+utf8,print_table,0,0,0,class<`matrix`>,1
+utf8,print_table,1,0,0,integer,1
+utf8,print_table,2,0,0,logical,1
+utf8,print_table,3,0,0,null,1
+utf8,print_table,4,0,0,integer,1
+utf8,print_table,5,0,0,logical,1
+utf8,print_table,6,0,0,integer,1
+utf8,print_table,7,0,0,character,1
+utf8,print_table,7,0,1,null,1
+utf8,print_table,8,0,0,character,1
+utf8,print_table,8,0,1,null,1
+utf8,print_table,9,0,0,null,1
+utf8,print_table,10,0,0,logical,1
+utf8,print_table,11,0,0,logical,1
+utf8,print_table,12,0,0,logical,1
+utf8,print_vector,-1,0,0,integer,1
+utf8,print_vector,0,0,0,character,1
+utf8,print_vector,1,0,0,logical,1
+utf8,print_vector,2,0,0,null,1
+utf8,print_vector,3,0,0,integer,1
+utf8,print_vector,4,0,0,logical,1
+utf8,print_vector,5,0,0,integer,1
+utf8,print_vector,6,0,0,null,1
+utf8,print_vector,7,0,0,null,1
+utf8,print_vector,8,0,0,null,1
+utf8,print_vector,9,0,0,logical,1
+utf8,print_vector,10,0,0,logical,1
+utf8,print_vector,11,0,0,logical,1
+utf8,print_vector_unnamed,-1,0,0,integer,1
+utf8,print_vector_unnamed,0,0,0,character,1
+utf8,print_vector_unnamed,1,0,0,logical,1
+utf8,print_vector_unnamed,2,0,0,null,1
+utf8,print_vector_unnamed,3,0,0,integer,1
+utf8,print_vector_unnamed,4,0,0,logical,1
+utf8,print_vector_unnamed,5,0,0,integer,1
+utf8,print_vector_unnamed,6,0,0,null,1
+utf8,print_vector_unnamed,7,0,0,null,1
+utf8,print_vector_unnamed,8,0,0,null,1
+utf8,print_vector_unnamed,9,0,0,logical,1
+utf8,print_vector_unnamed,10,0,0,logical,1
+utf8,print_vector_unnamed,11,0,0,logical,1
+utf8,set_dimnames,-1,0,0,class<`matrix`>,1
+utf8,set_dimnames,0,0,0,class<`matrix`>,1
+utf8,utf8_encode,-1,0,0,character[],1
+utf8,utf8_encode,0,0,0,character[],1
+utf8,utf8_encode,1,0,0,integer,1
+utf8,utf8_encode,2,0,0,logical,1
+utf8,utf8_encode,3,0,0,character,1
+utf8,utf8_encode,4,0,0,null,1
+utf8,utf8_encode,4,0,1,character,1
+utf8,utf8_encode,5,0,0,logical,1
+utf8,utf8_encode,6,0,0,null,1
+utf8,utf8_format,-1,0,0,character[],1
+utf8,utf8_format,-1,0,1,class<`matrix`>,1
+utf8,utf8_format,0,0,0,character[],1
+utf8,utf8_format,0,0,1,class<`matrix`>,1
+utf8,utf8_format,1,0,0,logical,1
+utf8,utf8_format,2,0,0,double,1
+utf8,utf8_format,2,0,1,null,1
+utf8,utf8_format,3,0,0,character,1
+utf8,utf8_format,4,0,0,double,1
+utf8,utf8_format,4,0,1,null,1
+utf8,utf8_format,5,0,0,logical,1
+utf8,utf8_format,6,0,0,logical,1
+utf8,utf8_format,7,0,0,null,1
+utf8,utf8_format,8,0,0,null,1
+utf8,utf8_format,9,0,0,null,1
+utf8,utf8_format,9,0,1,logical,1
+utf8,utf8_format,10,0,0,...,1
+utf8,utf8_normalize,-1,0,0,character[],1
+utf8,utf8_normalize,0,0,0,character[],1
+utf8,utf8_normalize,1,0,0,logical,1
+utf8,utf8_normalize,2,0,0,logical,1
+utf8,utf8_normalize,3,0,0,logical,1
+utf8,utf8_normalize,4,0,0,logical,1
+utf8,utf8_print,-1,0,0,character,1
+utf8,utf8_print,-1,0,1,class<`matrix`>,1
+utf8,utf8_print,0,0,0,character,1
+utf8,utf8_print,0,0,1,class<`matrix`>,1
+utf8,utf8_print,1,0,0,double,1
+utf8,utf8_print,1,0,1,null,1
+utf8,utf8_print,2,0,0,logical,1
+utf8,utf8_print,3,0,0,null,1
+utf8,utf8_print,4,0,0,null,1
+utf8,utf8_print,5,0,0,logical,1
+utf8,utf8_print,6,0,0,null,1
+utf8,utf8_print,7,0,0,null,1
+utf8,utf8_print,7,0,1,character,1
+utf8,utf8_print,8,0,0,null,1
+utf8,utf8_print,8,0,1,character,1
+utf8,utf8_print,9,0,0,null,1
+utf8,utf8_print,10,0,0,logical,1
+utf8,utf8_print,11,0,0,logical,1
+utf8,utf8_print,12,0,0,null,1
+utf8,utf8_print,13,0,0,...,1
+utf8,utf8_valid,-1,0,0,logical[],1
+utf8,utf8_valid,0,0,0,character[],1
+utf8,utf8_width,-1,0,0,^integer[],1
+utf8,utf8_width,0,0,0,character[],1
+utf8,utf8_width,1,0,0,logical,1
+utf8,utf8_width,2,0,0,logical,1
+utf8,utf8_width,3,0,0,null,1
+utf8,utf8_width,3,0,1,logical,1
+utf8,with_rethrow,-1,0,0,logical,1
+utf8,with_rethrow,0,0,0,logical,1
+uuid,UUIDgenerate,-1,0,0,character[],1
+uuid,UUIDgenerate,0,0,0,null,1
+uuid,UUIDgenerate,0,0,1,logical,1
+uuid,UUIDgenerate,1,0,0,double,1
+validate,~,-1,0,0,logical[],1
+validate,~,0,0,0,any,1
+validate,~,1,0,0,any,1
+validate,add_assignment,-1,0,0,class<`call`>,1
+validate,add_assignment,0,0,0,class<`call`>,1
+validate,add_assignment,1,0,0,environment,1
+validate,addcoef,-1,0,0,double,1
+validate,addcoef,0,0,0,character,1
+validate,addcoef,1,0,0,double,1
+validate,addcoef,2,0,0,environment,1
+validate,aggregate,-1,0,0,class<`data.frame`>,1
+validate,aggregate,0,0,0,class<`validation`>,1
+validate,aggregate,1,0,0,...,1
+validate,all_complete,-1,0,0,logical,1
+validate,all_complete,0,0,0,...,1
+validate,all_numeric,-1,0,0,logical,1
+validate,all_numeric,0,0,0,any,1
+validate,all_numeric,1,0,0,null,1
+validate,all_numeric,1,0,1,environment,1
+validate,all_unique,-1,0,0,logical,1
+validate,all_unique,0,0,0,...,1
+validate,as.data.frame,-1,0,0,class<`data.frame`>,1
+validate,as.data.frame,0,0,0,class<`validation`>,1
+validate,as.data.frame,1,0,0,null,1
+validate,as.data.frame,2,0,0,logical,1
+validate,as.data.frame,3,0,0,...,1
+validate,as.data.frame,-1,1,0,class<`data.frame`>,1
+validate,as.data.frame,0,1,0,class<`indication`>,1
+validate,as.data.frame,1,1,0,null,1
+validate,as.data.frame,2,1,0,logical,1
+validate,as.data.frame,3,1,0,...,1
+validate,as.data.frame,-1,2,0,class<`data.frame`>,1
+validate,as.data.frame,0,2,0,class<`validatorComparison`>,1
+validate,as.data.frame,1,2,0,null,1
+validate,as.data.frame,2,2,0,logical,1
+validate,as.data.frame,3,2,0,...,1
+validate,as.data.frame,-1,3,0,class<`data.frame`>,1
+validate,as.data.frame,0,3,0,class<`cellComparison`>,1
+validate,as.data.frame,1,3,0,null,1
+validate,as.data.frame,2,3,0,logical,1
+validate,as.data.frame,3,3,0,...,1
+validate,as.data.frame,-1,4,0,class<`data.frame`>,1
+validate,as.data.frame,0,4,0,class<`validator`>,1
+validate,as.data.frame,1,4,0,null,1
+validate,as.data.frame,2,4,0,logical,1
+validate,as.data.frame,3,4,0,...,1
+validate,as.data.frame,-1,5,0,class<`data.frame`>,1
+validate,as.data.frame,0,5,0,class<`indicator`>,1
+validate,as.data.frame,1,5,0,null,1
+validate,as.data.frame,2,5,0,logical,1
+validate,as.data.frame,3,5,0,...,1
+validate,as.list.expressionset,-1,0,0,"list<list<list<character[] | class<`POSIXct`, `POSIXt`> | list<character>>>>",1
+validate,as.list.expressionset,0,0,0,class<`validator`>,1
+validate,as.list.expressionset,1,0,0,logical,1
+validate,as.list.expressionset,2,0,0,...,1
+validate,as_yaml,-1,0,0,character,1
+validate,as_yaml,0,0,0,class<`validator`>,1
+validate,as_yaml,1,0,0,...,1
+validate,as_yaml,-1,1,0,character,1
+validate,as_yaml,0,1,0,class<`validator`>,1
+validate,as_yaml,1,1,0,...,1
+validate,barplot,-1,0,0,double[],1
+validate,barplot,0,0,0,class<`validatorComparison`>,1
+validate,barplot,1,0,0,...,1
+validate,barplot,-1,1,0,list<double[]>,1
+validate,barplot,0,1,0,class<`validation`>,1
+validate,barplot,1,1,0,...,1
+validate,barplot,-1,2,0,double[],1
+validate,barplot,0,2,0,class<`cellComparison`>,1
+validate,barplot,1,2,0,...,1
+validate,.blocks_expressionset,-1,0,0,list<integer[]>,1
+validate,.blocks_expressionset,0,0,0,class<`validator`>,1
+validate,bp_leg_pos,-1,0,0,double,1
+validate,bp_leg_pos,0,0,0,double[],1
+validate,capture,-1,0,0,class<`function`>,1
+validate,capture,0,0,0,any,1
+validate,capture,1,0,0,any,1
+validate,cell_diff,-1,0,0,double[],1
+validate,cell_diff,0,0,0,class<`data.frame`>,1
+validate,cell_diff,1,0,0,null,1
+validate,cell_diff,1,0,1,class<`data.frame`>,1
+validate,cells,-1,0,0,class<`cellComparison`>,1
+validate,cells,0,0,0,...,1
+validate,cells,1,0,0,null,1
+validate,cells,2,0,0,character[],1
+validate,check_primitives,-1,0,0,null,1
+validate,check_that,-1,0,0,class<`validation`>,1
+validate,check_that,0,0,0,...,1
+validate,check_that,-1,1,0,class<`validation`>,1
+validate,check_that,0,1,0,class<`data.frame`>,1
+validate,check_that,1,1,0,...,1
+validate,coefficients,-1,0,0,double[],1
+validate,coefficients,0,0,0,double,1
+validate,coefficients,0,0,1,class<`call`>,1
+validate,coefficients,0,0,2,class<`name`>,1
+validate,coefficients,1,0,0,double,1
+validate,coefficients,2,0,0,environment,1
+validate,compare,-1,0,0,class<`validatorComparison`>,1
+validate,compare,0,0,0,class<`validator`>,1
+validate,compare,1,0,0,...,1
+validate,compare,-1,1,0,class<`validatorComparison`>,1
+validate,compare,0,1,0,class<`validator`>,1
+validate,compare,1,1,0,...,1
+validate,confront,-1,0,0,class<`validation`>,1
+validate,confront,0,0,0,...,1
+validate,confront,-1,1,0,class<`validation`>,1
+validate,confront,0,1,0,class<`data.frame`>,1
+validate,confront,1,1,0,class<`validator`>,1
+validate,confront,2,1,0,list<character[]>,1
+validate,confront,2,1,1,list<integer[]>,1
+validate,confront,2,1,2,list<class<`data.frame`>>,1
+validate,confront,3,1,0,...,1
+validate,confront,-1,2,0,class<`indication`>,1
+validate,confront,0,2,0,class<`data.frame`>,1
+validate,confront,1,2,0,class<`indicator`>,1
+validate,confront,2,2,0,any,1
+validate,confront,3,2,0,...,1
+validate,confront,-1,3,0,class<`validation`>,1
+validate,confront,0,3,0,class<`data.frame`>,1
+validate,confront,1,3,0,class<`validator`>,1
+validate,confront,2,3,0,class<`data.frame`>,1
+validate,confront,3,3,0,...,1
+validate,confront,-1,4,0,class<`indication`>,1
+validate,confront,0,4,0,class<`data.frame`>,1
+validate,confront,1,4,0,class<`indicator`>,1
+validate,confront,2,4,0,list<class<`data.frame`>>,1
+validate,confront,3,4,0,...,1
+validate,confront,-1,5,0,class<`indication`>,1
+validate,confront,0,5,0,class<`data.frame`>,1
+validate,confront,1,5,0,class<`indicator`>,1
+validate,confront,2,5,0,class<`data.frame`>,1
+validate,confront,3,5,0,...,1
+validate,confront,-1,6,0,class<`indication`>,1
+validate,confront,0,6,0,class<`data.frame`>,1
+validate,confront,1,6,0,class<`indicator`>,1
+validate,confront,2,6,0,environment,1
+validate,confront,3,6,0,...,1
+validate,confront,-1,7,0,any,1
+validate,confront,0,7,0,class<`data.frame`>,1
+validate,confront,1,7,0,class<`indicator`>,1
+validate,confront,1,7,1,class<`validator`>,1
+validate,confront,2,7,0,any,1
+validate,confront,3,7,0,...,1
+validate,confront,-1,8,0,class<`validation`>,1
+validate,confront,0,8,0,class<`data.frame`>,1
+validate,confront,1,8,0,class<`validator`>,1
+validate,confront,2,8,0,environment,1
+validate,confront,3,8,0,...,1
+validate,confront,-1,9,0,any,1
+validate,confront,0,9,0,class<`data.frame`>,1
+validate,confront,1,9,0,class<`validator`>,1
+validate,confront,2,9,0,any,1
+validate,confront,3,9,0,...,1
+validate,confrontation_nerrs,-1,0,0,integer,1
+validate,confrontation_nerrs,0,0,0,class<`validation`>,1
+validate,confrontation_nwarn,-1,0,0,integer,1
+validate,confrontation_nwarn,0,0,0,class<`validation`>,1
+validate,confront_work,-1,0,0,any,1
+validate,confront_work,0,0,0,class<`indicator`>,1
+validate,confront_work,0,0,1,class<`validator`>,1
+validate,confront_work,1,0,0,any,1
+validate,confront_work,2,0,0,any,1
+validate,confront_work,3,0,0,character,1
+validate,confront_work,4,0,0,...,1
+validate,created,-1,0,0,"class<`POSIXct`, `POSIXt`>",1
+validate,created,0,0,0,class<`validator`>,1
+validate,created,1,0,0,...,1
+validate,created,-1,1,0,"class<`POSIXct`, `POSIXt`>",1
+validate,created,0,1,0,class<`validator`>,1
+validate,created,0,1,1,class<`rule`>,1
+validate,created,1,1,0,...,1
+validate,created,-1,2,0,"class<`POSIXct`, `POSIXt`>",1
+validate,created,0,2,0,class<`rule`>,1
+validate,created,1,2,0,...,1
+validate,created<-,-1,0,0,class<`rule`>,1
+validate,created<-,-1,0,1,class<`validator`>,1
+validate,created<-,0,0,0,class<`rule`>,1
+validate,created<-,0,0,1,class<`validator`>,1
+validate,created<-,1,0,0,"class<`POSIXct`, `POSIXt`>",1
+validate,created<-,-1,1,0,class<`validator`>,1
+validate,created<-,0,1,0,class<`validator`>,1
+validate,created<-,1,1,0,"class<`POSIXct`, `POSIXt`>",1
+validate,created<-,-1,2,0,class<`rule`>,1
+validate,created<-,0,2,0,class<`rule`>,1
+validate,created<-,1,2,0,"class<`POSIXct`, `POSIXt`>",1
+validate,description,-1,0,0,character[],1
+validate,description,0,0,0,class<`validator`>,1
+validate,description,1,0,0,...,1
+validate,description,-1,1,0,character[],1
+validate,description,0,1,0,class<`validator`>,1
+validate,description,0,1,1,class<`rule`>,1
+validate,description,1,1,0,...,1
+validate,description,-1,2,0,character,1
+validate,description,0,2,0,class<`rule`>,1
+validate,description,1,2,0,...,1
+validate,description<-,-1,0,0,class<`validator`>,1
+validate,description<-,0,0,0,class<`validator`>,1
+validate,description<-,1,0,0,character[],1
+validate,description<-,-1,1,0,class<`rule`>,1
+validate,description<-,0,1,0,class<`rule`>,1
+validate,description<-,1,1,0,character,1
+validate,description<-,-1,2,0,class<`rule`>,1
+validate,description<-,-1,2,1,class<`validator`>,1
+validate,description<-,0,2,0,class<`rule`>,1
+validate,description<-,0,2,1,class<`validator`>,1
+validate,description<-,1,2,0,character[],1
+validate,errors,-1,0,0,list<character>,1
+validate,errors,0,0,0,class<`indication`>,1
+validate,errors,0,0,1,class<`validation`>,1
+validate,errors,1,0,0,...,1
+validate,errors,-1,1,0,list<character>,1
+validate,errors,0,1,0,class<`validation`>,1
+validate,errors,1,1,0,...,1
+validate,errors,-1,2,0,list<character>,1
+validate,errors,0,2,0,class<`indication`>,1
+validate,errors,1,2,0,...,1
+validate,event,-1,0,0,^character[],1
+validate,event,0,0,0,class<`validation`>,1
+validate,event,-1,1,0,^character[],1
+validate,event,0,1,0,class<`validation`>,1
+validate,event<-,-1,0,0,class<`validation`>,1
+validate,event<-,0,0,0,class<`validation`>,1
+validate,event<-,1,0,0,character[],1
+validate,event<-,-1,1,0,class<`validation`>,1
+validate,event<-,0,1,0,class<`validation`>,1
+validate,event<-,1,1,0,character[],1
+validate,execute,-1,0,0,any,1
+validate,execute,0,0,0,list<any>,1
+validate,execute,1,0,0,any,1
+validate,execute,2,0,0,any,1
+validate,exists_any,-1,0,0,^logical[],1
+validate,exists_any,0,0,0,any,1
+validate,exists_any,1,0,0,...,1
+validate,exists_any,2,0,0,logical,1
+validate,exists_one,-1,0,0,^logical[],1
+validate,exists_one,0,0,0,any,1
+validate,exists_one,1,0,0,...,1
+validate,exists_one,2,0,0,logical,1
+validate,expand_assignments,-1,0,0,list<any>,1
+validate,expand_assignments,0,0,0,list<any>,1
+validate,expand_groups,-1,0,0,list<class<`call`>>,1
+validate,expand_groups,-1,0,1,null,1
+validate,expand_groups,-1,0,2,list<class<`call`> | class<`{`>>,1
+validate,expand_groups,-1,0,3,list<class<`call`> | class<`if`>>,1
+validate,expand_groups,-1,0,4,list<class<`if`>>,1
+validate,expand_groups,-1,0,5,list<class<`{`>>,1
+validate,expand_groups,0,0,0,list<any>,1
+validate,export_yaml,-1,0,0,null,1
+validate,export_yaml,0,0,0,class<`validator`>,1
+validate,export_yaml,1,0,0,character,1
+validate,export_yaml,2,0,0,...,1
+validate,export_yaml,-1,1,0,null,1
+validate,export_yaml,0,1,0,class<`validator`>,1
+validate,export_yaml,1,1,0,character,1
+validate,export_yaml,2,1,0,...,1
+validate,expr,-1,0,0,class<`call`>,1
+validate,expr,-1,0,1,class<`{`>,1
+validate,expr,-1,0,2,class<`if`>,1
+validate,expr,0,0,0,class<`rule`>,1
+validate,expr,1,0,0,...,1
+validate,expr,-1,1,0,class<`call`>,1
+validate,expr,-1,1,1,class<`{`>,1
+validate,expr,-1,1,2,class<`if`>,1
+validate,expr,0,1,0,class<`rule`>,1
+validate,expr,1,1,0,...,1
+validate,extract_names,-1,0,0,character[],1
+validate,extract_names,0,0,0,list<any>,1
+validate,extract_names,1,0,0,character,1
+validate,factory,-1,0,0,any,1
+validate,factory,0,0,0,...,1
+validate,factory,-1,1,0,class<`function`>,1
+validate,factory,0,1,0,any,1
+validate,factory,1,1,0,class<`standardGeneric`>,1
+validate,factory,1,1,1,class<`function`>,1
+validate,factory,-1,2,0,list<double | character | null>,1
+validate,factory,-1,2,1,list<null | character>,1
+validate,factory,-1,2,2,list<double[] | null>,1
+validate,factory,-1,2,3,list<double | null>,1
+validate,factory,-1,2,4,list<integer | null>,1
+validate,factory,-1,2,5,list<logical[] | character | null>,1
+validate,factory,-1,2,6,list<logical[] | null>,1
+validate,factory,-1,2,7,list<logical | null>,1
+validate,factory,-1,2,8,list<^logical[] | null>,1
+validate,factory,0,2,0,...,1
+validate,failed_confrontations,-1,0,0,integer,1
+validate,failed_confrontations,0,0,0,class<`validation`>,1
+validate,fails,-1,0,0,double[],1
+validate,fails,0,0,0,class<`validation`>,1
+validate,filter_yrf_options,-1,0,0,character[],1
+validate,filter_yrf_options,-1,0,1,null,1
+validate,filter_yrf_options,0,0,0,character[],1
+validate,.get_exprs,-1,0,0,list<any>,1
+validate,.get_exprs,0,0,0,class<`validator`>,1
+validate,.get_exprs,0,0,1,class<`indicator`>,1
+validate,.get_exprs,1,0,0,...,1
+validate,.get_exprs,2,0,0,logical,1
+validate,.get_exprs,3,0,0,logical,1
+validate,.get_exprs,4,0,0,logical,1
+validate,.get_exprs,5,0,0,logical,1
+validate,.get_exprs,6,0,0,logical,1
+validate,.get_exprs,7,0,0,double,1
+validate,get_filestack_yml,-1,0,0,character[],1
+validate,get_filestack_yml,0,0,0,character,1
+validate,get_linear_coefficients,-1,0,0,list<class<`matrix`> | character>,1
+validate,get_linear_coefficients,0,0,0,class<`validator`>,1
+validate,get_linear_coefficients,1,0,0,logical,1
+validate,get_linear_coefficients,2,0,0,...,1
+validate,get_stat,-1,0,0,^double[],1
+validate,get_stat,0,0,0,class<`indication`>,1
+validate,get_stat,1,0,0,class<`function`>,1
+validate,get_stat,2,0,0,...,1
+validate,has_error,-1,0,0,logical[],1
+validate,has_error,0,0,0,class<`indication`>,1
+validate,has_error,0,0,1,class<`validation`>,1
+validate,has_warning,-1,0,0,logical[],1
+validate,has_warning,0,0,0,class<`indication`>,1
+validate,has_warning,0,0,1,class<`validation`>,1
+validate,indicator,-1,0,0,class<`indicator`>,1
+validate,indicator,0,0,0,...,1
+validate,indicator,1,0,0,any,1
+validate,indicator,2,0,0,any,1
+validate,.ini_expressionset_cli,-1,0,0,list<any>,1
+validate,.ini_expressionset_cli,0,0,0,class<`indicator`>,1
+validate,.ini_expressionset_cli,0,0,1,class<`validator`>,1
+validate,.ini_expressionset_cli,1,0,0,...,1
+validate,.ini_expressionset_cli,2,0,0,character,1
+validate,.ini_expressionset_df,-1,0,0,any,1
+validate,.ini_expressionset_df,0,0,0,any,1
+validate,.ini_expressionset_df,1,0,0,class<`data.frame`>,1
+validate,.ini_expressionset_df,2,0,0,character,1
+validate,.ini_expressionset_yml,-1,0,0,null,1
+validate,.ini_expressionset_yml,-1,0,1,list<character | double | null>,1
+validate,.ini_expressionset_yml,0,0,0,class<`indicator`>,1
+validate,.ini_expressionset_yml,0,0,1,class<`validator`>,1
+validate,.ini_expressionset_yml,1,0,0,character,1
+validate,.ini_expressionset_yml,2,0,0,character,1
+validate,ini_indicator,-1,0,0,class<`function`>,1
+validate,ini_indicator,-1,0,1,null,1
+validate,ini_indicator,0,0,0,class<`indicator`>,1
+validate,ini_indicator,1,0,0,...,1
+validate,ini_indicator,2,0,0,any,1
+validate,ini_indicator,3,0,0,any,1
+validate,ini_validator,-1,0,0,any,1
+validate,ini_validator,0,0,0,any,1
+validate,ini_validator,1,0,0,...,1
+validate,ini_validator,2,0,0,any,1
+validate,ini_validator,3,0,0,any,1
+validate,int_values,-1,0,0,class<`matrix`>,1
+validate,int_values,-1,0,1,list<class<`matrix`>>,1
+validate,int_values,-1,0,2,logical,1
+validate,int_values,-1,0,3,list<double[]>,1
+validate,int_values,-1,0,4,list<^logical[]>,1
+validate,int_values,0,0,0,class<`indication`>,1
+validate,int_values,0,0,1,class<`validation`>,1
+validate,int_values,1,0,0,logical,1
+validate,int_values,2,0,0,logical,1
+validate,int_values,3,0,0,...,1
+validate,is.assignment,-1,0,0,list<any>,1
+validate,is.assignment,-1,0,1,logical[],1
+validate,is.assignment,0,0,0,list<any>,1
+validate,is_complete,-1,0,0,logical[],1
+validate,is_complete,0,0,0,...,1
+validate,is_full_path,-1,0,0,logical[],1
+validate,is_full_path,0,0,0,character[],1
+validate,is_full_path,0,0,1,null,1
+validate,is_null,-1,0,0,logical[],1
+validate,is_null,0,0,0,class<`indication`>,1
+validate,is_null,0,0,1,class<`validation`>,1
+validate,is_r,-1,0,0,logical,1
+validate,is_r,0,0,0,character,1
+validate,is_tran_assign,-1,0,0,logical[],1
+validate,is_tran_assign,0,0,0,class<`rule`>,1
+validate,is_tran_assign,0,0,1,class<`validator`>,1
+validate,is_tran_assign,1,0,0,...,1
+validate,is_tran_assign,-1,1,0,logical[],1
+validate,is_tran_assign,0,1,0,class<`validator`>,1
+validate,is_tran_assign,1,1,0,...,1
+validate,is_unique,-1,0,0,logical[],1
+validate,is_unique,0,0,0,...,1
+validate,is_yaml,-1,0,0,logical,1
+validate,is_yaml,0,0,0,character,1
+validate,label,-1,0,0,character,1
+validate,label,0,0,0,class<`rule`>,1
+validate,label,1,0,0,...,1
+validate,label,-1,1,0,character[],1
+validate,label,0,1,0,class<`rule`>,1
+validate,label,0,1,1,class<`validator`>,1
+validate,label,1,1,0,...,1
+validate,label,-1,2,0,character[],1
+validate,label,0,2,0,class<`validator`>,1
+validate,label,1,2,0,...,1
+validate,label<-,-1,0,0,class<`rule`>,1
+validate,label<-,-1,0,1,class<`validator`>,1
+validate,label<-,0,0,0,class<`rule`>,1
+validate,label<-,0,0,1,class<`validator`>,1
+validate,label<-,1,0,0,character[],1
+validate,label<-,-1,1,0,class<`rule`>,1
+validate,label<-,0,1,0,class<`rule`>,1
+validate,label<-,1,1,0,character,1
+validate,label<-,-1,2,0,class<`validator`>,1
+validate,label<-,0,2,0,class<`validator`>,1
+validate,label<-,1,2,0,character[],1
+validate,lbj_cells,-1,0,0,class<`lbj_cells`>,1
+validate,lbj_cells,0,0,0,...,1
+validate,lbj_rules,-1,0,0,class<`lbj_rules`>,1
+validate,lbj_rules,0,0,0,...,1
+validate,left,-1,0,0,character,1
+validate,left,-1,0,1,class<`(`>,1
+validate,left,-1,0,2,class<`call`>,1
+validate,left,-1,0,3,class<`name`>,1
+validate,left,-1,0,4,double,1
+validate,left,-1,0,5,null,1
+validate,left,0,0,0,class<`call`>,1
+validate,linear,-1,0,0,logical[],1
+validate,linear,0,0,0,class<`rule`>,1
+validate,linear,0,0,1,class<`validator`>,1
+validate,linear,1,0,0,...,1
+validate,linear,-1,1,0,logical[],1
+validate,linear,0,1,0,class<`validator`>,1
+validate,linear,1,1,0,...,1
+validate,linear_call,-1,0,0,logical,1
+validate,linear_call,0,0,0,class<`call`>,1
+validate,linear_call,0,0,1,character,1
+validate,linear_call,0,0,2,class<`<-`>,1
+validate,linear_call,0,0,3,class<`(`>,1
+validate,linear_call,0,0,4,class<`{`>,1
+validate,linear_call,0,0,5,class<`if`>,1
+validate,linear_call,0,0,6,class<`name`>,1
+validate,linear_call,0,0,7,double,1
+validate,linear_call,0,0,8,null,1
+validate,make_listnames,-1,0,0,character[],1
+validate,make_listnames,0,0,0,list<class<`data.frame`>>,1
+validate,make_listnames,1,0,0,character[],1
+validate,match_cells,-1,0,0,list<class<`data.frame`>>,1
+validate,match_cells,0,0,0,...,1
+validate,match_cells,1,0,0,null,1
+validate,match_cells,2,0,0,character,1
+validate,meta,-1,0,0,class<`data.frame`>,1
+validate,meta,0,0,0,class<`indicator`>,1
+validate,meta,1,0,0,...,1
+validate,meta,-1,1,0,class<`data.frame`>,1
+validate,meta,-1,1,1,list<any>,1
+validate,meta,0,1,0,class<`indicator`>,1
+validate,meta,0,1,1,class<`validator`>,1
+validate,meta,0,1,2,class<`rule`>,1
+validate,meta,1,1,0,...,1
+validate,meta,-1,2,0,class<`data.frame`>,1
+validate,meta,0,2,0,class<`validator`>,1
+validate,meta,1,2,0,...,1
+validate,meta,-1,3,0,list<any>,1
+validate,meta,0,3,0,class<`rule`>,1
+validate,meta,1,3,0,...,1
+validate,meta<-,-1,0,0,class<`validator`>,1
+validate,meta<-,0,0,0,class<`validator`>,1
+validate,meta<-,1,0,0,character,1
+validate,meta<-,2,0,0,character,1
+validate,meta<-,2,0,1,double,1
+validate,meta<-,2,0,2,integer[],1
+validate,meta<-,-1,1,0,class<`rule`>,1
+validate,meta<-,-1,1,1,class<`validator`>,1
+validate,meta<-,0,1,0,class<`rule`>,1
+validate,meta<-,0,1,1,class<`validator`>,1
+validate,meta<-,1,1,0,character,1
+validate,meta<-,2,1,0,character,1
+validate,meta<-,2,1,1,double,1
+validate,meta<-,2,1,2,integer[],1
+validate,meta<-,-1,2,0,class<`rule`>,1
+validate,meta<-,0,2,0,class<`rule`>,1
+validate,meta<-,1,2,0,character,1
+validate,meta<-,2,2,0,character,1
+validate,meta<-,2,2,1,double,1
+validate,namecheck,-1,0,0,environment,1
+validate,namecheck,0,0,0,environment,1
+validate,nas,-1,0,0,double[],1
+validate,nas,0,0,0,class<`indication`>,1
+validate,nas,0,0,1,class<`validation`>,1
+validate,node,-1,0,0,class<`name`>,1
+validate,node,-1,0,1,null,1
+validate,node,0,0,0,class<`<-`>,1
+validate,node,0,0,1,class<`(`>,1
+validate,node,0,0,2,class<`{`>,1
+validate,node,0,0,3,class<`call`>,1
+validate,node,0,0,4,class<`if`>,1
+validate,node,0,0,5,class<`name`>,1
+validate,node,0,0,6,double,1
+validate,node,0,0,7,null,1
+validate,npos,-1,0,0,double,1
+validate,npos,0,0,0,integer,1
+validate,options_from_yml,-1,0,0,null,1
+validate,options_from_yml,-1,0,1,list<character>,1
+validate,options_from_yml,0,0,0,character,1
+validate,origin,-1,0,0,character[],1
+validate,origin,0,0,0,class<`rule`>,1
+validate,origin,0,0,1,class<`validator`>,1
+validate,origin,1,0,0,...,1
+validate,origin,-1,1,0,character,1
+validate,origin,0,1,0,class<`rule`>,1
+validate,origin,1,1,0,...,1
+validate,origin,-1,2,0,character[],1
+validate,origin,0,2,0,class<`validator`>,1
+validate,origin,1,2,0,...,1
+validate,origin<-,-1,0,0,class<`rule`>,1
+validate,origin<-,0,0,0,class<`rule`>,1
+validate,origin<-,1,0,0,character,1
+validate,origin<-,-1,1,0,class<`validator`>,1
+validate,origin<-,0,1,0,class<`validator`>,1
+validate,origin<-,1,1,0,character[],1
+validate,origin<-,-1,2,0,class<`rule`>,1
+validate,origin<-,-1,2,1,class<`validator`>,1
+validate,origin<-,0,2,0,class<`rule`>,1
+validate,origin<-,0,2,1,class<`validator`>,1
+validate,origin<-,1,2,0,character[],1
+validate,outcheck,-1,0,0,class<`function`>,1
+validate,outcheck,0,0,0,any,1
+validate,outcheck,-1,1,0,any,1
+validate,outcheck,0,1,0,...,1
+validate,output,-1,0,0,environment,1
+validate,parse_yrf_include,-1,0,0,character[],1
+validate,parse_yrf_include,-1,0,1,null,1
+validate,parse_yrf_include,0,0,0,character,1
+validate,.parse_yrf_options,-1,0,0,null,1
+validate,.parse_yrf_options,-1,0,1,list<character>,1
+validate,.parse_yrf_options,0,0,0,character[],1
+validate,passes,-1,0,0,double[],1
+validate,passes,0,0,0,class<`validation`>,1
+validate,plot,-1,0,0,class<`factor`>,1
+validate,plot,-1,0,1,null,1
+validate,plot,0,0,0,class<`validator`>,1
+validate,plot,1,0,0,any,1
+validate,plot,2,0,0,...,1
+validate,plot,-1,1,0,list<double[]>,1
+validate,plot,0,1,0,class<`validation`>,1
+validate,plot,1,1,0,any,1
+validate,plot,2,1,0,...,1
+validate,plot,-1,2,0,null,1
+validate,plot,0,2,0,class<`cellComparison`>,1
+validate,plot,1,2,0,any,1
+validate,plot,2,2,0,...,1
+validate,plot,-1,3,0,null,1
+validate,plot,0,3,0,class<`validatorComparison`>,1
+validate,plot,1,3,0,any,1
+validate,plot,2,3,0,...,1
+validate,.readlines_utf8,-1,0,0,character[],1
+validate,.readlines_utf8,0,0,0,character,1
+validate,.readlines_utf8,1,0,0,character,1
+validate,recycle,-1,0,0,character[],1
+validate,recycle,-1,0,1,"class<`POSIXct`, `POSIXt`>",1
+validate,recycle,0,0,0,character[],1
+validate,recycle,0,0,1,"class<`POSIXct`, `POSIXt`>",1
+validate,recycle,1,0,0,class<`indicator`>,1
+validate,recycle,1,0,1,class<`validator`>,1
+validate,replace_if,-1,0,0,class<`call`>,1
+validate,replace_if,0,0,0,class<`if`>,1
+validate,replace_linear_restriction,-1,0,0,any,1
+validate,replace_linear_restriction,0,0,0,any,1
+validate,replace_linear_restriction,1,0,0,any,1
+validate,replace_linear_restriction,2,0,0,any,1
+validate,replace_linear_restriction,3,0,0,character,1
+validate,reset,-1,0,0,list<character | double | null>,1
+validate,reset,0,0,0,class<`standardGeneric`>,1
+validate,reset,-1,1,0,list<character | double | null>,1
+validate,reset,0,1,0,class<`validator`>,1
+validate,reset,-1,2,0,list<character | double | null>,1
+validate,reset,0,2,0,class<`standardGeneric`>,1
+validate,reset,0,2,1,class<`validator`>,1
+validate,right,-1,0,0,character,1
+validate,right,-1,0,1,class<`call`>,1
+validate,right,-1,0,2,class<`name`>,1
+validate,right,-1,0,3,double,1
+validate,right,0,0,0,class<`call`>,1
+validate,rule,-1,0,0,class<`rule`>,1
+validate,rule,0,0,0,...,1
+validate,rules_diff,-1,0,0,double[],1
+validate,rules_diff,0,0,0,class<`validator`>,1
+validate,rules_diff,1,0,0,class<`data.frame`>,1
+validate,rules_diff,2,0,0,class<`data.frame`>,1
+validate,rules_diff,2,0,1,null,1
+validate,rules_from_yrf_file,-1,0,0,list<class<`rule`>>,1
+validate,rules_from_yrf_file,-1,0,1,null,1
+validate,rules_from_yrf_file,0,0,0,character,1
+validate,rules_from_yrf_file,1,0,0,character,1
+validate,run_validation_file,-1,0,0,"class<`list`, `validations`>",1
+validate,run_validation_file,0,0,0,character,1
+validate,run_validation_file,1,0,0,logical,1
+validate,setNames,-1,0,0,character,1
+validate,setNames,-1,0,1,class<`data.frame`>,1
+validate,setNames,-1,0,2,"class<`POSIXct`, `POSIXt`>",1
+validate,setNames,-1,0,3,double[],1
+validate,setNames,-1,0,4,list<any>,1
+validate,setNames,0,0,0,character,1
+validate,setNames,0,0,1,class<`data.frame`>,1
+validate,setNames,0,0,2,"class<`POSIXct`, `POSIXt`>",1
+validate,setNames,0,0,3,double[],1
+validate,setNames,0,0,4,list<any>,1
+validate,setNames,1,0,0,character[],1
+validate,setNames,1,0,1,list<any>,1
+validate,.show_confrontation,-1,0,0,null,1
+validate,.show_confrontation,0,0,0,class<`validation`>,1
+validate,.show_expressionset,-1,0,0,null,1
+validate,.show_expressionset,0,0,0,class<`validator`>,1
+validate,simplify_list,-1,0,0,list<class<`matrix`>>,1
+validate,simplify_list,0,0,0,list<double>,1
+validate,simplify_list,0,0,1,list<^logical[]>,1
+validate,simplify_list,0,0,2,list<null>,1
+validate,simplify_list,0,0,3,list<class<`array`>>,1
+validate,sort,-1,0,0,class<`data.frame`>,1
+validate,sort,0,0,0,class<`validation`>,1
+validate,sort,1,0,0,logical,1
+validate,sort,2,0,0,...,1
+validate,substitute_assignments,-1,0,0,class<`{`>,1
+validate,substitute_assignments,-1,0,1,class<`call`>,1
+validate,substitute_assignments,-1,0,2,class<`if`>,1
+validate,substitute_assignments,0,0,0,class<`{`>,1
+validate,substitute_assignments,0,0,1,class<`call`>,1
+validate,substitute_assignments,0,0,2,class<`if`>,1
+validate,substitute_assignments,1,0,0,environment,1
+validate,summary,-1,0,0,class<`data.frame`>,1
+validate,summary,0,0,0,class<`validator`>,1
+validate,summary,1,0,0,...,1
+validate,summary,-1,1,0,class<`data.frame`>,1
+validate,summary,0,1,0,class<`indication`>,1
+validate,summary,1,1,0,...,1
+validate,summary,-1,2,0,class<`data.frame`>,1
+validate,summary,0,2,0,class<`validation`>,1
+validate,summary,1,2,0,...,1
+validate,summary.validations,-1,0,0,class<`data.frame`>,1
+validate,summary.validations,0,0,0,"class<`list`, `validations`>",1
+validate,summary.validations,1,0,0,...,1
+validate,validating,-1,0,0,logical[],1
+validate,validating,0,0,0,class<`rule`>,1
+validate,validating,0,0,1,class<`validator`>,1
+validate,validating,1,0,0,...,1
+validate,validating,-1,1,0,logical[],1
+validate,validating,0,1,0,class<`validator`>,1
+validate,validating,1,1,0,...,1
+validate,validating_call,-1,0,0,logical,1
+validate,validating_call,0,0,0,class<`call`>,1
+validate,validating_call,0,0,1,class<`if`>,1
+validate,validating_call,0,0,2,class<`name`>,1
+validate,validator,-1,0,0,any,1
+validate,validator,0,0,0,...,1
+validate,validator,1,0,0,any,1
+validate,validator,2,0,0,any,1
+validate,valid_yaml,-1,0,0,logical,1
+validate,valid_yaml,0,0,0,character,1
+validate,values,-1,0,0,class<`matrix`>,1
+validate,values,-1,0,1,list<class<`matrix`>>,1
+validate,values,-1,0,2,logical,1
+validate,values,-1,0,3,list<double[]>,1
+validate,values,-1,0,4,list<^logical[]>,1
+validate,values,0,0,0,class<`indication`>,1
+validate,values,0,0,1,class<`validation`>,1
+validate,values,1,0,0,...,1
+validate,values,-1,1,0,class<`matrix`>,1
+validate,values,-1,1,1,list<double[]>,1
+validate,values,0,1,0,class<`indication`>,1
+validate,values,1,1,0,...,1
+validate,values,-1,2,0,class<`matrix`>,1
+validate,values,-1,2,1,list<class<`matrix`>>,1
+validate,values,-1,2,2,logical,1
+validate,values,-1,2,3,list<^logical[]>,1
+validate,values,0,2,0,class<`validation`>,1
+validate,values,1,2,0,...,1
+validate,var_from_call,-1,0,0,character[],1
+validate,var_from_call,-1,0,1,null,1
+validate,var_from_call,0,0,0,class<`call`>,1
+validate,var_from_call,0,0,1,class<`if`>,1
+validate,var_group,-1,0,0,class<`function`>,1
+validate,var_group,0,0,0,...,1
+validate,variables,-1,0,0,character[],1
+validate,variables,-1,0,1,class<`matrix`>,1
+validate,variables,-1,0,2,null,1
+validate,variables,0,0,0,class<`data.frame`>,1
+validate,variables,0,0,1,class<`rule`>,1
+validate,variables,0,0,2,class<`validator`>,1
+validate,variables,0,0,3,environment,1
+validate,variables,0,0,4,list<double[]>,1
+validate,variables,1,0,0,...,1
+validate,variables,-1,1,0,character[],1
+validate,variables,0,1,0,list<double[]>,1
+validate,variables,1,1,0,...,1
+validate,variables,-1,2,0,character[],1
+validate,variables,-1,2,1,class<`matrix`>,1
+validate,variables,0,2,0,class<`validator`>,1
+validate,variables,1,2,0,...,1
+validate,variables,-1,3,0,character[],1
+validate,variables,-1,3,1,null,1
+validate,variables,0,3,0,class<`rule`>,1
+validate,variables,1,3,0,...,1
+validate,variables,-1,4,0,character[],1
+validate,variables,0,4,0,class<`data.frame`>,1
+validate,variables,1,4,0,...,1
+validate,variables,-1,5,0,character[],1
+validate,variables,0,5,0,environment,1
+validate,variables,1,5,0,...,1
+validate,vectorize,-1,0,0,class<`(`>,1
+validate,vectorize,-1,0,1,class<`call`>,1
+validate,vectorize,-1,0,2,class<`{`>,1
+validate,vectorize,-1,0,3,character,1
+validate,vectorize,-1,0,4,class<`name`>,1
+validate,vectorize,-1,0,5,double,1
+validate,vectorize,-1,0,6,null,1
+validate,vectorize,0,0,0,class<`(`>,1
+validate,vectorize,0,0,1,class<`call`>,1
+validate,vectorize,0,0,2,class<`if`>,1
+validate,vectorize,0,0,3,class<`{`>,1
+validate,vectorize,0,0,4,character,1
+validate,vectorize,0,0,5,class<`name`>,1
+validate,vectorize,0,0,6,double,1
+validate,vectorize,0,0,7,null,1
+validate,%vin%,-1,0,0,any,1
+validate,%vin%,0,0,0,any,1
+validate,%vin%,1,0,0,any,1
+validate,voptions,-1,0,0,character,1
+validate,voptions,-1,0,1,class<`function`>,1
+validate,voptions,-1,0,2,null,1
+validate,voptions,-1,0,3,list<character | double | null>,1
+validate,voptions,0,0,0,character,1
+validate,voptions,0,0,1,class<`validator`>,1
+validate,voptions,0,0,2,class<`indicator`>,1
+validate,voptions,0,0,3,null,1
+validate,voptions,1,0,0,...,1
+validate,voptions,-1,1,0,character,1
+validate,voptions,-1,1,1,null,1
+validate,voptions,0,1,0,character,1
+validate,voptions,1,1,0,...,1
+validate,voptions,-1,2,0,list<character | double | null>,1
+validate,voptions,0,2,0,null,1
+validate,voptions,1,2,0,...,1
+validate,voptions,-1,3,0,class<`function`>,1
+validate,voptions,0,3,0,class<`indicator`>,1
+validate,voptions,1,3,0,...,1
+validate,voptions,-1,4,0,character,1
+validate,voptions,-1,4,1,class<`function`>,1
+validate,voptions,-1,4,2,list<character | double | null>,1
+validate,voptions,0,4,0,class<`validator`>,1
+validate,voptions,1,4,0,...,1
+validate,warnf,-1,0,0,character,1
+validate,warnf,0,0,0,character,1
+validate,warnf,1,0,0,...,1
+validate,warnings,-1,0,0,list<any>,1
+validate,warnings,0,0,0,...,1
+validate,warnings,-1,1,0,list<character>,1
+validate,warnings,0,1,0,...,1
+validate,which.call,-1,0,0,list<any>,1
+validate,which.call,0,0,0,any,1
+validate,which.call,1,0,0,any,1
+validate,which.call,2,0,0,any,1
+validate,which.call,3,0,0,environment,1
+validate,yaml_blocks,-1,0,0,list<character>,1
+validate,yaml_blocks,-1,0,1,list<null>,1
+validate,yaml_blocks,-1,0,2,list<character | list<character[]>>,1
+validate,yaml_blocks,-1,0,3,list<list<character | list<list<character>>>>,1
+validate,yaml_blocks,-1,0,4,list<character | list<list<character>>>,1
+validate,yaml_blocks,-1,0,5,list<list<list<list<character | list<character>>>>>,1
+validate,yaml_blocks,-1,0,6,list<list<list<list<character>>>>,1
+validate,yaml_blocks,0,0,0,character[],1
+validate,yrf_block_type,-1,0,0,character,1
+validate,yrf_block_type,-1,0,1,null,1
+validate,yrf_block_type,0,0,0,character,1
+validate,yrf_block_type,0,0,1,list<character[]>,1
+validate,yrf_block_type,0,0,2,list<list<character>>,1
+validate,yrf_block_type,0,0,3,list<list<list<character | list<character>>>>,1
+validate,yrf_block_type,0,0,4,list<list<list<character>>>,1
+validate,yrf_block_type,0,0,5,null,1
+variables,as.data.frame.var,-1,0,0,class<`data.frame`>,1
+variables,as.data.frame.var,0,0,0,"class<`continuous_var`, `numeric_var`, `var`>",1
+variables,as.data.frame.var,0,0,1,"class<`discrete_var`, `numeric_var`, `var`>",1
+variables,as.data.frame.var,0,0,2,"class<`factor_var`, `ordered_var`, `var`>",1
+variables,as.data.frame.var,0,0,3,"class<`factor_var`, `var`>",1
+variables,as.data.frame.var,0,0,4,class<`vars`>,1
+variables,as.data.frame.var,1,0,0,null,1
+variables,as.data.frame.var,2,0,0,logical,1
+variables,as.data.frame.var,3,0,0,double,1
+variables,as.data.frame.var,4,0,0,...,1
+variables,as.data.frame.vars,-1,0,0,class<`data.frame`>,1
+variables,as.data.frame.vars,0,0,0,"class<`continuous_var`, `numeric_var`, `var`>",1
+variables,as.data.frame.vars,0,0,1,"class<`discrete_var`, `numeric_var`, `var`>",1
+variables,as.data.frame.vars,0,0,2,"class<`factor_var`, `ordered_var`, `var`>",1
+variables,as.data.frame.vars,0,0,3,"class<`factor_var`, `var`>",1
+variables,as.data.frame.vars,0,0,4,class<`vars`>,1
+variables,as.data.frame.vars,1,0,0,null,1
+variables,as.data.frame.vars,2,0,0,logical,1
+variables,as.data.frame.vars,3,0,0,double,1
+variables,as.data.frame.vars,4,0,0,...,1
+variables,as.vars,-1,0,0,class<`vars`>,1
+variables,as.vars,0,0,0,class<`data.frame`>,1
+variables,as.vars.data.frame,-1,0,0,class<`vars`>,1
+variables,as.vars.data.frame,0,0,0,class<`data.frame`>,1
+variables,bounds,-1,0,0,list<double[]>,1
+variables,bounds,-1,0,1,"list<double[] | class<`factor`, `ordered`> | null>",1
+variables,bounds,-1,0,2,list<null>,1
+variables,bounds,-1,0,3,"list<class<`factor`, `ordered`>>",1
+variables,bounds,0,0,0,"class<`continuous_var`, `numeric_var`, `var`>",1
+variables,bounds,0,0,1,"class<`discrete_var`, `numeric_var`, `var`>",1
+variables,bounds,0,0,2,class<`vars`>,1
+variables,bounds,0,0,3,"class<`factor_var`, `var`>",1
+variables,bounds,0,0,4,"class<`factor_var`, `ordered_var`, `var`>",1
+variables,bounds.continuous_var,-1,0,0,list<double[]>,1
+variables,bounds.continuous_var,0,0,0,"class<`continuous_var`, `numeric_var`, `var`>",1
+variables,bounds.default,-1,0,0,list<null>,1
+variables,bounds.default,0,0,0,"class<`factor_var`, `var`>",1
+variables,bounds.discrete_var,-1,0,0,list<double[]>,1
+variables,bounds.discrete_var,0,0,0,"class<`discrete_var`, `numeric_var`, `var`>",1
+variables,bounds.ordered_var,-1,0,0,"list<class<`factor`, `ordered`>>",1
+variables,bounds.ordered_var,0,0,0,"class<`factor_var`, `ordered_var`, `var`>",1
+variables,bounds.vars,-1,0,0,"list<double[] | class<`factor`, `ordered`> | null>",1
+variables,bounds.vars,0,0,0,class<`vars`>,1
+variables,check,-1,0,0,logical,1
+variables,check,0,0,0,class<`vars`>,1
+variables,check,0,0,1,"class<`continuous_var`, `numeric_var`, `var`>",1
+variables,check,0,0,2,"class<`discrete_var`, `numeric_var`, `var`>",1
+variables,check,0,0,3,"class<`factor_var`, `ordered_var`, `var`>",1
+variables,check,0,0,4,"class<`factor_var`, `var`>",1
+variables,check,1,0,0,class<`data.frame`>,1
+variables,check.continuous_var,-1,0,0,logical,1
+variables,check.continuous_var,0,0,0,"class<`continuous_var`, `numeric_var`, `var`>",1
+variables,check.continuous_var,1,0,0,class<`data.frame`>,1
+variables,check.discrete_var,-1,0,0,logical,1
+variables,check.discrete_var,0,0,0,"class<`discrete_var`, `numeric_var`, `var`>",1
+variables,check.discrete_var,1,0,0,class<`data.frame`>,1
+variables,check.factor_var,-1,0,0,logical,1
+variables,check.factor_var,0,0,0,"class<`factor_var`, `var`>",1
+variables,check.factor_var,1,0,0,class<`data.frame`>,1
+variables,check.ordered_var,-1,0,0,logical,1
+variables,check.ordered_var,0,0,0,"class<`factor_var`, `ordered_var`, `var`>",1
+variables,check.ordered_var,1,0,0,class<`data.frame`>,1
+variables,check.vars,-1,0,0,logical,1
+variables,check.vars,0,0,0,class<`vars`>,1
+variables,check.vars,1,0,0,class<`data.frame`>,1
+variables,c.var,-1,0,0,class<`vars`>,1
+variables,c.var,0,0,0,...,1
+variables,desc,-1,0,0,character[],1
+variables,desc,0,0,0,"class<`continuous_var`, `numeric_var`, `var`>",1
+variables,desc,0,0,1,"class<`discrete_var`, `numeric_var`, `var`>",1
+variables,desc,0,0,2,"class<`factor_var`, `ordered_var`, `var`>",1
+variables,desc,0,0,3,"class<`factor_var`, `var`>",1
+variables,desc,0,0,4,class<`vars`>,1
+variables,desc.var,-1,0,0,character,1
+variables,desc.var,0,0,0,"class<`continuous_var`, `numeric_var`, `var`>",1
+variables,desc.var,0,0,1,"class<`discrete_var`, `numeric_var`, `var`>",1
+variables,desc.var,0,0,2,"class<`factor_var`, `ordered_var`, `var`>",1
+variables,desc.var,0,0,3,"class<`factor_var`, `var`>",1
+variables,desc.vars,-1,0,0,character[],1
+variables,desc.vars,0,0,0,class<`vars`>,1
+variables,factor_var,-1,0,0,"class<`factor_var`, `var`>",1
+variables,factor_var,0,0,0,character,1
+variables,factor_var,1,0,0,character,1
+variables,factor_var,1,0,1,null,1
+variables,factor_var,2,0,0,character[],1
+variables,is.bounded,-1,0,0,logical[],1
+variables,is.bounded,0,0,0,"class<`continuous_var`, `numeric_var`, `var`>",1
+variables,is.bounded,0,0,1,"class<`discrete_var`, `numeric_var`, `var`>",1
+variables,is.bounded,0,0,2,"class<`factor_var`, `ordered_var`, `var`>",1
+variables,is.bounded,0,0,3,"class<`factor_var`, `var`>",1
+variables,is.bounded,0,0,4,class<`vars`>,1
+variables,is.bounded.continuous_var,-1,0,0,logical,1
+variables,is.bounded.continuous_var,0,0,0,"class<`continuous_var`, `numeric_var`, `var`>",1
+variables,is.bounded.var,-1,0,0,logical,1
+variables,is.bounded.var,0,0,0,"class<`discrete_var`, `numeric_var`, `var`>",1
+variables,is.bounded.var,0,0,1,"class<`factor_var`, `ordered_var`, `var`>",1
+variables,is.bounded.var,0,0,2,"class<`factor_var`, `var`>",1
+variables,is.bounded.vars,-1,0,0,logical[],1
+variables,is.bounded.vars,0,0,0,class<`vars`>,1
+variables,levels.discrete_var,-1,0,0,double[],1
+variables,levels.discrete_var,0,0,0,"class<`discrete_var`, `numeric_var`, `var`>",1
+variables,levels.factor_var,-1,0,0,character[],1
+variables,levels.factor_var,0,0,0,"class<`factor_var`, `ordered_var`, `var`>",1
+variables,levels.factor_var,0,0,1,"class<`factor_var`, `var`>",1
+variables,levels.var,-1,0,0,null,1
+variables,levels.var,0,0,0,"class<`continuous_var`, `numeric_var`, `var`>",1
+variables,mkgrid,-1,0,0,list<double[]>,1
+variables,mkgrid,-1,0,1,list<class<`factor`>>,1
+variables,mkgrid,-1,0,2,"list<class<`factor`, `ordered`>>",1
+variables,mkgrid,-1,0,3,"list<double[] | class<`factor`, `ordered`> | class<`factor`>>",1
+variables,mkgrid,-1,0,4,list<class<`factor`> | double[]>,1
+variables,mkgrid,0,0,0,"class<`continuous_var`, `numeric_var`, `var`>",1
+variables,mkgrid,0,0,1,"class<`discrete_var`, `numeric_var`, `var`>",1
+variables,mkgrid,0,0,2,"class<`factor_var`, `var`>",1
+variables,mkgrid,0,0,3,"class<`factor_var`, `ordered_var`, `var`>",1
+variables,mkgrid,0,0,4,class<`vars`>,1
+variables,mkgrid,1,0,0,...,1
+variables,mkgrid.continuous_var,-1,0,0,list<double[]>,1
+variables,mkgrid.continuous_var,0,0,0,"class<`continuous_var`, `numeric_var`, `var`>",1
+variables,mkgrid.continuous_var,1,0,0,double,1
+variables,mkgrid.continuous_var,2,0,0,...,1
+variables,mkgrid.var,-1,0,0,list<double[]>,1
+variables,mkgrid.var,-1,0,1,list<class<`factor`>>,1
+variables,mkgrid.var,-1,0,2,"list<class<`factor`, `ordered`>>",1
+variables,mkgrid.var,0,0,0,"class<`discrete_var`, `numeric_var`, `var`>",1
+variables,mkgrid.var,0,0,1,"class<`factor_var`, `var`>",1
+variables,mkgrid.var,0,0,2,"class<`factor_var`, `ordered_var`, `var`>",1
+variables,mkgrid.var,1,0,0,...,1
+variables,mkgrid.vars,-1,0,0,"list<double[] | class<`factor`, `ordered`> | class<`factor`>>",1
+variables,mkgrid.vars,-1,0,1,list<class<`factor`> | double[]>,1
+variables,mkgrid.vars,0,0,0,class<`vars`>,1
+variables,mkgrid.vars,1,0,0,...,1
+variables,numeric_var,-1,0,0,"class<`continuous_var`, `numeric_var`, `var`>",1
+variables,numeric_var,-1,0,1,"class<`discrete_var`, `numeric_var`, `var`>",1
+variables,numeric_var,0,0,0,character,1
+variables,numeric_var,1,0,0,character,1
+variables,numeric_var,1,0,1,null,1
+variables,numeric_var,2,0,0,character,1
+variables,numeric_var,2,0,1,null,1
+variables,numeric_var,3,0,0,double[],1
+variables,numeric_var,4,0,0,any,1
+variables,numeric_var,5,0,0,double[],1
+variables,numeric_var,5,0,1,null,1
+variables,ordered_var,-1,0,0,"class<`factor_var`, `ordered_var`, `var`>",1
+variables,ordered_var,0,0,0,character,1
+variables,ordered_var,1,0,0,character,1
+variables,ordered_var,2,0,0,character[],1
+variables,support,-1,0,0,list<double[]>,1
+variables,support,-1,0,1,list<class<`factor`>>,1
+variables,support,-1,0,2,"list<class<`factor`, `ordered`>>",1
+variables,support,-1,0,3,"list<double[] | class<`factor`, `ordered`> | class<`factor`>>",1
+variables,support,-1,0,4,list<class<`factor`> | double[]>,1
+variables,support,0,0,0,"class<`continuous_var`, `numeric_var`, `var`>",1
+variables,support,0,0,1,"class<`discrete_var`, `numeric_var`, `var`>",1
+variables,support,0,0,2,"class<`factor_var`, `var`>",1
+variables,support,0,0,3,"class<`factor_var`, `ordered_var`, `var`>",1
+variables,support,0,0,4,class<`vars`>,1
+variables,support.var,-1,0,0,list<double[]>,1
+variables,support.var,-1,0,1,list<class<`factor`>>,1
+variables,support.var,-1,0,2,"list<class<`factor`, `ordered`>>",1
+variables,support.var,0,0,0,"class<`continuous_var`, `numeric_var`, `var`>",1
+variables,support.var,0,0,1,"class<`discrete_var`, `numeric_var`, `var`>",1
+variables,support.var,0,0,2,"class<`factor_var`, `var`>",1
+variables,support.var,0,0,3,"class<`factor_var`, `ordered_var`, `var`>",1
+variables,support.vars,-1,0,0,"list<double[] | class<`factor`, `ordered`> | class<`factor`>>",1
+variables,support.vars,-1,0,1,list<class<`factor`> | double[]>,1
+variables,support.vars,0,0,0,class<`vars`>,1
+variables,unit,-1,0,0,null,1
+variables,unit,-1,0,1,^character[],1
+variables,unit,0,0,0,"class<`continuous_var`, `numeric_var`, `var`>",1
+variables,unit,0,0,1,"class<`discrete_var`, `numeric_var`, `var`>",1
+variables,unit,0,0,2,"class<`factor_var`, `ordered_var`, `var`>",1
+variables,unit,0,0,3,"class<`factor_var`, `var`>",1
+variables,unit,0,0,4,class<`vars`>,1
+variables,unit.numeric_var,-1,0,0,character,1
+variables,unit.numeric_var,0,0,0,"class<`continuous_var`, `numeric_var`, `var`>",1
+variables,unit.numeric_var,0,0,1,"class<`discrete_var`, `numeric_var`, `var`>",1
+variables,unit.var,-1,0,0,null,1
+variables,unit.var,0,0,0,"class<`factor_var`, `ordered_var`, `var`>",1
+variables,unit.var,0,0,1,"class<`factor_var`, `var`>",1
+variables,unit.vars,-1,0,0,^character[],1
+variables,unit.vars,0,0,0,class<`vars`>,1
+variables,.var,-1,0,0,class<`var`>,1
+variables,.var,0,0,0,character,1
+variables,.var,1,0,0,character,1
+variables,.var,1,0,1,null,1
+variables,variable.names.var,-1,0,0,character,1
+variables,variable.names.var,0,0,0,"class<`continuous_var`, `numeric_var`, `var`>",1
+variables,variable.names.var,0,0,1,"class<`discrete_var`, `numeric_var`, `var`>",1
+variables,variable.names.var,0,0,2,"class<`factor_var`, `ordered_var`, `var`>",1
+variables,variable.names.var,0,0,3,"class<`factor_var`, `var`>",1
+variables,variable.names.var,1,0,0,...,1
+variables,variable.names.vars,-1,0,0,character[],1
+variables,variable.names.vars,0,0,0,class<`vars`>,1
+variables,variable.names.vars,1,0,0,...,1
+vcd,agreementplot,-1,0,0,list<class<`matrix`> | double[]>,1
+vcd,agreementplot,-1,0,1,list<class<`matrix`> | double>,1
+vcd,agreementplot,0,0,0,class<`matrix`>,1
+vcd,agreementplot,0,0,1,class<`table`>,1
+vcd,agreementplot,1,0,0,...,1
+vcd,agreementplot.default,-1,0,0,list<class<`matrix`> | double[]>,1
+vcd,agreementplot.default,-1,0,1,list<class<`matrix`> | double>,1
+vcd,agreementplot.default,0,0,0,class<`matrix`>,1
+vcd,agreementplot.default,0,0,1,class<`table`>,1
+vcd,agreementplot.default,1,0,0,logical,1
+vcd,agreementplot.default,2,0,0,character,1
+vcd,agreementplot.default,2,0,1,null,1
+vcd,agreementplot.default,3,0,0,double[],1
+vcd,agreementplot.default,4,0,0,double[],1
+vcd,agreementplot.default,5,0,0,logical,1
+vcd,agreementplot.default,6,0,0,logical,1
+vcd,agreementplot.default,7,0,0,character,1
+vcd,array3d,-1,0,0,class<`array`>,1
+vcd,array3d,-1,0,1,class<`table`>,1
+vcd,array3d,0,0,0,class<`table`>,1
+vcd,array3d,1,0,0,character,1
+vcd,as.array.loddsratio,-1,0,0,class<`matrix`>,1
+vcd,as.array.loddsratio,-1,0,1,double[],1
+vcd,as.array.loddsratio,0,0,0,class<`loddsratio`>,1
+vcd,as.array.loddsratio,1,0,0,logical,1
+vcd,as.array.loddsratio,2,0,0,...,1
+vcd,as.data.frame.loddsratio,-1,0,0,class<`data.frame`>,1
+vcd,as.data.frame.loddsratio,0,0,0,class<`loddsratio`>,1
+vcd,as.data.frame.loddsratio,1,0,0,null,1
+vcd,as.data.frame.loddsratio,2,0,0,any,1
+vcd,as.data.frame.loddsratio,3,0,0,logical,1
+vcd,as.data.frame.loddsratio,4,0,0,...,1
+vcd,as_matrix_ftable,-1,0,0,class<`matrix`>,1
+vcd,as_matrix_ftable,0,0,0,"class<`ftable`, `structable`>",1
+vcd,as_matrix_ftable,1,0,0,character,1
+vcd,as_matrix_ftable,2,0,0,...,1
+vcd,as.matrix.structable,-1,0,0,class<`matrix`>,1
+vcd,as.matrix.structable,0,0,0,"class<`ftable`, `structable`>",1
+vcd,as.matrix.structable,1,0,0,character,1
+vcd,as.matrix.structable,2,0,0,...,1
+vcd,assoc,-1,0,0,"class<`ftable`, `structable`>",1
+vcd,assoc,0,0,0,class<`formula`>,1
+vcd,assoc,0,0,1,"class<`ftable`, `structable`>",1
+vcd,assoc,0,0,2,class<`loglm`>,1
+vcd,assoc,0,0,3,class<`table`>,1
+vcd,assoc,0,0,4,"class<`table`, `xtabs`>",1
+vcd,assoc,1,0,0,...,1
+vcd,assoc.default,-1,0,0,"class<`ftable`, `structable`>",1
+vcd,assoc.default,0,0,0,"class<`ftable`, `structable`>",1
+vcd,assoc.default,0,0,1,class<`table`>,1
+vcd,assoc.default,0,0,2,"class<`table`, `xtabs`>",1
+vcd,assoc.default,1,0,0,null,1
+vcd,assoc.default,2,0,0,null,1
+vcd,assoc.default,3,0,0,logical,1
+vcd,assoc.default,4,0,0,null,1
+vcd,assoc.default,5,0,0,null,1
+vcd,assoc.default,5,0,1,double[],1
+vcd,assoc.default,6,0,0,class<`function`>,1
+vcd,assoc.default,7,0,0,any,1
+vcd,assoc.formula,-1,0,0,"class<`ftable`, `structable`>",1
+vcd,assoc.formula,0,0,0,class<`formula`>,1
+vcd,assoc.formula,1,0,0,"class<`ftable`, `structable`>",1
+vcd,assoc.formula,1,0,1,class<`table`>,1
+vcd,assoc.formula,2,0,0,...,1
+vcd,assoc.formula,3,0,0,null,1
+vcd,assoc.formula,4,0,0,null,1
+vcd,assoc.formula,5,0,0,null,1
+vcd,assoc.formula,6,0,0,null,1
+vcd,assoc.loglm,-1,0,0,"class<`ftable`, `structable`>",1
+vcd,assoc.loglm,0,0,0,class<`loglm`>,1
+vcd,assoc.loglm,1,0,0,...,1
+vcd,assocstats,-1,0,0,class<`assocstats`>,1
+vcd,assocstats,-1,0,1,list<class<`assocstats`>>,1
+vcd,assocstats,0,0,0,"class<`table`, `xtabs`>",1
+vcd,assocstats,0,0,1,class<`table`>,1
+vcd,assocstats,0,0,2,class<`matrix`>,1
+vcd,as.table.structable,-1,0,0,class<`table`>,1
+vcd,as.table.structable,0,0,0,"class<`ftable`, `structable`>",1
+vcd,as.table.structable,1,0,0,...,1
+vcd,as.vector.structable,-1,0,0,double[],1
+vcd,as.vector.structable,0,0,0,"class<`ftable`, `structable`>",1
+vcd,as.vector.structable,1,0,0,...,1
+vcd,binreg_plot,-1,0,0,null,1
+vcd,binreg_plot,0,0,0,"class<`glm`, `lm`>",1
+vcd,binreg_plot,1,0,0,character,1
+vcd,binreg_plot,1,0,1,null,1
+vcd,binreg_plot,2,0,0,null,1
+vcd,binreg_plot,2,0,1,character,1
+vcd,binreg_plot,3,0,0,null,1
+vcd,binreg_plot,3,0,1,character,1
+vcd,binreg_plot,4,0,0,null,1
+vcd,binreg_plot,4,0,1,double[],1
+vcd,binreg_plot,5,0,0,null,1
+vcd,binreg_plot,6,0,0,null,1
+vcd,binreg_plot,7,0,0,character[],1
+vcd,cd_plot,-1,0,0,list<class<`function`>>,1
+vcd,cd_plot,0,0,0,class<`formula`>,1
+vcd,cd_plot,0,0,1,integer[],1
+vcd,cd_plot,1,0,0,...,1
+vcd,cd_plot.default,-1,0,0,list<class<`function`>>,1
+vcd,cd_plot.default,0,0,0,integer[],1
+vcd,cd_plot.default,1,0,0,class<`factor`>,1
+vcd,cd_plot.default,1,0,1,"class<`factor`, `ordered`>",1
+vcd,cd_plot.default,2,0,0,logical,1
+vcd,cd_plot.default,3,0,0,any,1
+vcd,cd_plot.default,4,0,0,double,1
+vcd,cd_plot.default,4,0,1,character,1
+vcd,cd_plot.default,5,0,0,double,1
+vcd,cd_plot.default,6,0,0,null,1
+vcd,cd_plot.default,7,0,0,null,1
+vcd,cd_plot.formula,-1,0,0,list<class<`function`>>,1
+vcd,cd_plot.formula,0,0,0,class<`formula`>,1
+vcd,cd_plot.formula,1,0,0,class<`data.frame`>,1
+vcd,cd_plot.formula,2,0,0,logical,1
+vcd,cd_plot.formula,3,0,0,double,1
+vcd,cd_plot.formula,4,0,0,double,1
+vcd,cd_plot.formula,4,0,1,character,1
+vcd,cd_plot.formula,5,0,0,double,1
+vcd,cd_plot.formula,6,0,0,null,1
+vcd,cd_plot.formula,7,0,0,null,1
+vcd,coef.lodds,-1,0,0,double[],1
+vcd,coef.lodds,0,0,0,class<`lodds`>,1
+vcd,coef.lodds,0,0,1,class<`loddsratio`>,1
+vcd,coef.lodds,1,0,0,logical,1
+vcd,coef.lodds,2,0,0,...,1
+vcd,coef.loddsratio,-1,0,0,double[],1
+vcd,coef.loddsratio,0,0,0,class<`lodds`>,1
+vcd,coef.loddsratio,0,0,1,class<`loddsratio`>,1
+vcd,coef.loddsratio,1,0,0,logical,1
+vcd,coef.loddsratio,2,0,0,...,1
+vcd,coindep_test,-1,0,0,"class<`coindep_test`, `htest`>",1
+vcd,coindep_test,0,0,0,class<`matrix`>,1
+vcd,coindep_test,0,0,1,class<`table`>,1
+vcd,coindep_test,0,0,2,"class<`table`, `xtabs`>",1
+vcd,coindep_test,1,0,0,null,1
+vcd,coindep_test,1,0,1,character,1
+vcd,coindep_test,1,0,2,double[],1
+vcd,coindep_test,2,0,0,double,1
+vcd,coindep_test,3,0,0,class<`function`>,1
+vcd,coindep_test,4,0,0,class<`function`>,1
+vcd,coindep_test,5,0,0,character[],1
+vcd,coindep_test,6,0,0,logical,1
+vcd,confint.Kappa,-1,0,0,class<`matrix`>,1
+vcd,confint.Kappa,0,0,0,class<`Kappa`>,1
+vcd,confint.Kappa,1,0,0,any,1
+vcd,confint.Kappa,2,0,0,double,1
+vcd,confint.Kappa,3,0,0,...,1
+vcd,confint.lodds,-1,0,0,class<`matrix`>,1
+vcd,confint.lodds,0,0,0,class<`lodds`>,1
+vcd,confint.lodds,0,0,1,class<`loddsratio`>,1
+vcd,confint.lodds,1,0,0,any,1
+vcd,confint.lodds,2,0,0,double,1
+vcd,confint.lodds,3,0,0,logical,1
+vcd,confint.lodds,4,0,0,...,1
+vcd,confint.loddsratio,-1,0,0,class<`matrix`>,1
+vcd,confint.loddsratio,0,0,0,class<`lodds`>,1
+vcd,confint.loddsratio,0,0,1,class<`loddsratio`>,1
+vcd,confint.loddsratio,1,0,0,any,1
+vcd,confint.loddsratio,2,0,0,double,1
+vcd,confint.loddsratio,3,0,0,logical,1
+vcd,confint.loddsratio,4,0,0,...,1
+vcd,cotab_coindep,-1,0,0,class<`function`>,1
+vcd,cotab_coindep,0,0,0,class<`table`>,1
+vcd,cotab_coindep,1,0,0,character,1
+vcd,cotab_coindep,2,0,0,character[],1
+vcd,cotab_coindep,3,0,0,null,1
+vcd,cotab_coindep,4,0,0,double,1
+vcd,cotab_coindep,5,0,0,any,1
+vcd,cotab_coindep,6,0,0,null,1
+vcd,cotab_coindep,7,0,0,null,1
+vcd,co_table,-1,0,0,list<class<`table`>>,1
+vcd,co_table,0,0,0,class<`table`>,1
+vcd,co_table,0,0,1,"class<`table`, `xtabs`>",1
+vcd,co_table,0,0,2,class<`array`>,1
+vcd,co_table,0,0,3,class<`matrix`>,1
+vcd,co_table,1,0,0,character[],1
+vcd,co_table,1,0,1,double[],1
+vcd,co_table,2,0,0,character,1
+vcd,cotabplot,-1,0,0,class<`table`>,1
+vcd,cotabplot,-1,0,1,"class<`table`, `xtabs`>",1
+vcd,cotabplot,0,0,0,class<`array`>,1
+vcd,cotabplot,0,0,1,class<`formula`>,1
+vcd,cotabplot,0,0,2,class<`table`>,1
+vcd,cotabplot,0,0,3,"class<`table`, `xtabs`>",1
+vcd,cotabplot,1,0,0,...,1
+vcd,cotabplot.default,-1,0,0,class<`table`>,1
+vcd,cotabplot.default,-1,0,1,"class<`table`, `xtabs`>",1
+vcd,cotabplot.default,0,0,0,class<`array`>,1
+vcd,cotabplot.default,0,0,1,class<`table`>,1
+vcd,cotabplot.default,0,0,2,"class<`table`, `xtabs`>",1
+vcd,cotabplot.default,1,0,0,null,1
+vcd,cotabplot.default,1,0,1,character[],1
+vcd,cotabplot.default,2,0,0,class<`grapcon_generator`>,1
+vcd,cotabplot.default,2,0,1,class<`function`>,1
+vcd,cotabplot.default,3,0,0,any,1
+vcd,cotabplot.default,4,0,0,double[],1
+vcd,cotabplot.default,5,0,0,null,1
+vcd,cotabplot.default,6,0,0,class<`gpar`>,1
+vcd,cotabplot.default,7,0,0,class<`gpar`>,1
+vcd,cotabplot.formula,-1,0,0,class<`table`>,1
+vcd,cotabplot.formula,-1,0,1,"class<`table`, `xtabs`>",1
+vcd,cotabplot.formula,0,0,0,class<`formula`>,1
+vcd,cotabplot.formula,1,0,0,"class<`ftable`, `structable`>",1
+vcd,cotabplot.formula,1,0,1,class<`table`>,1
+vcd,cotabplot.formula,1,0,2,class<`data.frame`>,1
+vcd,cotabplot.formula,1,0,3,"class<`table`, `xtabs`>",1
+vcd,cotabplot.formula,2,0,0,...,1
+vcd,dim.loddsratio,-1,0,0,integer[],1
+vcd,dim.loddsratio,0,0,0,class<`loddsratio`>,1
+vcd,dim.loddsratio,1,0,0,...,1
+vcd,dimnames.loddsratio,-1,0,0,list<character[]>,1
+vcd,dimnames.loddsratio,0,0,0,class<`loddsratio`>,1
+vcd,dimnames.loddsratio,1,0,0,...,1
+vcd,dimnames.structable,-1,0,0,list<character[]>,1
+vcd,dimnames.structable,0,0,0,"class<`ftable`, `structable`>",1
+vcd,dim.structable,-1,0,0,integer[],1
+vcd,dim.structable,0,0,0,"class<`ftable`, `structable`>",1
+vcd,distplot,-1,0,0,class<`data.frame`>,1
+vcd,distplot,0,0,0,class<`table`>,1
+vcd,distplot,0,0,1,"class<`table`, `xtabs`>",1
+vcd,distplot,0,0,2,integer[],1
+vcd,distplot,1,0,0,character[],1
+vcd,distplot,2,0,0,double,1
+vcd,distplot,2,0,1,null,1
+vcd,distplot,3,0,0,null,1
+vcd,distplot,3,0,1,double,1
+vcd,distplot,4,0,0,logical,1
+vcd,distplot,5,0,0,null,1
+vcd,distplot,6,0,0,null,1
+vcd,distplot,7,0,0,logical,1
+vcd,doubledecker,-1,0,0,"class<`ftable`, `structable`>",1
+vcd,doubledecker,0,0,0,class<`formula`>,1
+vcd,doubledecker,0,0,1,class<`table`>,1
+vcd,doubledecker,1,0,0,...,1
+vcd,doubledecker.default,-1,0,0,"class<`ftable`, `structable`>",1
+vcd,doubledecker.default,0,0,0,class<`table`>,1
+vcd,doubledecker.default,0,0,1,"class<`table`, `xtabs`>",1
+vcd,doubledecker.default,1,0,0,integer,1
+vcd,doubledecker.default,1,0,1,character,1
+vcd,doubledecker.default,2,0,0,double[],1
+vcd,doubledecker.default,3,0,0,class<`gpar`>,1
+vcd,doubledecker.default,4,0,0,class<`grapcon_generator`>,1
+vcd,doubledecker.default,5,0,0,class<`grapcon_generator`>,1
+vcd,doubledecker.default,6,0,0,null,1
+vcd,doubledecker.default,7,0,0,logical,1
+vcd,doubledecker.formula,-1,0,0,"class<`ftable`, `structable`>",1
+vcd,doubledecker.formula,0,0,0,class<`formula`>,1
+vcd,doubledecker.formula,1,0,0,class<`table`>,1
+vcd,doubledecker.formula,1,0,1,"class<`table`, `xtabs`>",1
+vcd,doubledecker.formula,2,0,0,...,1
+vcd,doubledecker.formula,3,0,0,null,1
+vcd,fitted.goodfit,-1,0,0,double[],1
+vcd,fitted.goodfit,0,0,0,class<`goodfit`>,1
+vcd,fitted.goodfit,1,0,0,...,1
+vcd,fourfold,-1,0,0,null,1
+vcd,fourfold,0,0,0,class<`table`>,1
+vcd,fourfold,1,0,0,character[],1
+vcd,fourfold,2,0,0,double,1
+vcd,fourfold,3,0,0,character[],1
+vcd,fourfold,4,0,0,any,1
+vcd,fourfold,5,0,0,double,1
+vcd,fourfold,6,0,0,null,1
+vcd,fourfold,7,0,0,null,1
+vcd,goodfit,-1,0,0,class<`goodfit`>,1
+vcd,goodfit,0,0,0,class<`table`>,1
+vcd,goodfit,0,0,1,"class<`table`, `xtabs`>",1
+vcd,goodfit,0,0,2,integer[],1
+vcd,goodfit,1,0,0,character[],1
+vcd,goodfit,2,0,0,character[],1
+vcd,goodfit,3,0,0,null,1
+vcd,goodfit,3,0,1,list<double>,1
+vcd,grid_barplot,-1,0,0,integer[],1
+vcd,grid_barplot,0,0,0,double[],1
+vcd,grid_barplot,1,0,0,double,1
+vcd,grid_barplot,2,0,0,double[],1
+vcd,grid_barplot,3,0,0,character[],1
+vcd,grid_barplot,3,0,1,integer[],1
+vcd,grid_barplot,4,0,0,null,1
+vcd,grid_barplot,5,0,0,double[],1
+vcd,grid_barplot,5,0,1,null,1
+vcd,grid_barplot,6,0,0,character,1
+vcd,grid_barplot,7,0,0,character,1
+vcd,grid_legend,-1,0,0,"class<`frame`, `gDesc`, `gTree`, `grob`>",1
+vcd,grid_legend,0,0,0,character,1
+vcd,grid_legend,0,0,1,class<`unit`>,1
+vcd,grid_legend,0,0,2,double,1
+vcd,grid_legend,1,0,0,any,1
+vcd,grid_legend,2,0,0,^double[],1
+vcd,grid_legend,2,0,1,null,1
+vcd,grid_legend,2,0,2,character[],1
+vcd,grid_legend,3,0,0,double[],1
+vcd,grid_legend,3,0,1,character[],1
+vcd,grid_legend,4,0,0,character[],1
+vcd,grid_legend,5,0,0,logical,1
+vcd,grid_legend,6,0,0,class<`unit`>,1
+vcd,grid_legend,7,0,0,class<`unit`>,1
+vcd,hcl2hex,-1,0,0,character[],1
+vcd,hcl2hex,0,0,0,double[],1
+vcd,hcl2hex,1,0,0,double[],1
+vcd,hcl2hex,2,0,0,double[],1
+vcd,hcl2hex,3,0,0,logical,1
+vcd,hls,-1,0,0,character,1
+vcd,hls,0,0,0,double,1
+vcd,hls,1,0,0,double,1
+vcd,hls,2,0,0,double,1
+vcd,image.loddsratio,-1,0,0,"class<`ftable`, `structable`>",1
+vcd,image.loddsratio,0,0,0,class<`loddsratio`>,1
+vcd,image.loddsratio,1,0,0,null,1
+vcd,image.loddsratio,2,0,0,class<`grapcon_generator`>,1
+vcd,image.loddsratio,3,0,0,any,1
+vcd,image.loddsratio,4,0,0,null,1
+vcd,image.loddsratio,5,0,0,class<`function`>,1
+vcd,image.loddsratio,6,0,0,null,1
+vcd,image.loddsratio,7,0,0,...,1
+vcd,independence_table,-1,0,0,class<`array`>,1
+vcd,independence_table,-1,0,1,class<`matrix`>,1
+vcd,independence_table,0,0,0,class<`array`>,1
+vcd,independence_table,0,0,1,class<`table`>,1
+vcd,independence_table,1,0,0,character[],1
+vcd,is.structable,-1,0,0,logical,1
+vcd,is.structable,0,0,0,character[],1
+vcd,is.structable,0,0,1,class<`array`>,1
+vcd,is.structable,0,0,2,class<`data.frame`>,1
+vcd,is.structable,0,0,3,"class<`ftable`, `structable`>",1
+vcd,is.structable,0,0,4,class<`matrix`>,1
+vcd,is.structable,0,0,5,class<`table`>,1
+vcd,is.structable,0,0,6,"class<`table`, `xtabs`>",1
+vcd,is.structable,0,0,7,double[],1
+vcd,is.structable,0,0,8,null,1
+vcd,is.structable,0,0,9,list<character[]>,1
+vcd,Kappa,-1,0,0,class<`Kappa`>,1
+vcd,Kappa,0,0,0,class<`table`>,1
+vcd,Kappa,1,0,0,character[],1
+vcd,labeling_border,-1,0,0,"class<`path`, `vpPath`>",1
+vcd,labeling_border,0,0,0,list<character[]>,1
+vcd,labeling_border,1,0,0,logical[],1
+vcd,labeling_border,2,0,0,any,1
+vcd,labeling_border,3,0,0,character,1
+vcd,labeling_border,-1,1,0,class<`function`>,1
+vcd,labeling_border,0,1,0,any,1
+vcd,labeling_border,1,1,0,any,1
+vcd,labeling_border,2,1,0,null,1
+vcd,labeling_border,2,1,1,list<character[]>,1
+vcd,labeling_border,3,1,0,character[],1
+vcd,labeling_border,3,1,1,null,1
+vcd,labeling_border,4,1,0,any,1
+vcd,labeling_border,5,1,0,logical,1
+vcd,labeling_border,6,1,0,any,1
+vcd,labeling_border,7,1,0,any,1
+vcd,labeling_cboxed,-1,0,0,class<`function`>,1
+vcd,labeling_cboxed,0,0,0,logical,1
+vcd,labeling_cboxed,1,0,0,logical,1
+vcd,labeling_cboxed,2,0,0,logical,1
+vcd,labeling_cboxed,3,0,0,character,1
+vcd,labeling_cboxed,4,0,0,...,1
+vcd,labeling_cells,-1,0,0,class<`function`>,1
+vcd,labeling_cells,0,0,0,any,1
+vcd,labeling_cells,1,0,0,logical,1
+vcd,labeling_cells,2,0,0,logical,1
+vcd,labeling_cells,3,0,0,logical,1
+vcd,labeling_cells,4,0,0,any,1
+vcd,labeling_cells,5,0,0,character,1
+vcd,labeling_cells,6,0,0,character,1
+vcd,labeling_cells,7,0,0,character,1
+vcd,labeling_cells,-1,1,0,"class<`path`, `vpPath`>",1
+vcd,labeling_cells,0,1,0,list<character[]>,1
+vcd,labeling_cells,0,1,1,class<`table`>,1
+vcd,labeling_cells,1,1,0,any,1
+vcd,labeling_cells,2,1,0,any,1
+vcd,labeling_cells,3,1,0,character,1
+vcd,labeling_conditional,-1,0,0,class<`function`>,1
+vcd,labeling_conditional,0,0,0,...,1
+vcd,labeling_lboxed,-1,0,0,class<`function`>,1
+vcd,labeling_lboxed,0,0,0,logical,1
+vcd,labeling_lboxed,1,0,0,logical,1
+vcd,labeling_lboxed,2,0,0,logical,1
+vcd,labeling_lboxed,3,0,0,character,1
+vcd,labeling_lboxed,4,0,0,character,1
+vcd,labeling_lboxed,5,0,0,logical,1
+vcd,labeling_lboxed,6,0,0,...,1
+vcd,labeling_left,-1,0,0,class<`function`>,1
+vcd,labeling_left,0,0,0,logical,1
+vcd,labeling_left,1,0,0,character,1
+vcd,labeling_left,2,0,0,character,1
+vcd,labeling_left,3,0,0,character,1
+vcd,labeling_left,4,0,0,...,1
+vcd,labeling_list,-1,0,0,class<`function`>,1
+vcd,labeling_list,0,0,0,any,1
+vcd,labeling_list,1,0,0,character,1
+vcd,labeling_list,2,0,0,character,1
+vcd,labeling_list,3,0,0,character,1
+vcd,labeling_list,4,0,0,character,1
+vcd,labeling_list,5,0,0,any,1
+vcd,labeling_list,6,0,0,logical,1
+vcd,labeling_list,7,0,0,double,1
+vcd,labeling_values,-1,0,0,class<`function`>,1
+vcd,labeling_values,0,0,0,character,1
+vcd,labeling_values,1,0,0,double,1
+vcd,labeling_values,2,0,0,double,1
+vcd,labeling_values,3,0,0,logical,1
+vcd,labeling_values,4,0,0,...,1
+vcd,length.structable,-1,0,0,integer,1
+vcd,length.structable,0,0,0,"class<`ftable`, `structable`>",1
+vcd,lodds,-1,0,0,class<`lodds`>,1
+vcd,lodds,0,0,0,class<`matrix`>,1
+vcd,lodds,1,0,0,...,1
+vcd,lodds.default,-1,0,0,class<`lodds`>,1
+vcd,lodds.default,0,0,0,class<`matrix`>,1
+vcd,lodds.default,1,0,0,null,1
+vcd,lodds.default,2,0,0,null,1
+vcd,lodds.default,3,0,0,logical,1
+vcd,lodds.default,4,0,0,null,1
+vcd,lodds.default,5,0,0,logical,1
+vcd,lodds.default,6,0,0,...,1
+vcd,loddsratio,-1,0,0,class<`loddsratio`>,1
+vcd,loddsratio,0,0,0,class<`formula`>,1
+vcd,loddsratio,0,0,1,class<`matrix`>,1
+vcd,loddsratio,0,0,2,class<`table`>,1
+vcd,loddsratio,0,0,3,"class<`table`, `xtabs`>",1
+vcd,loddsratio,1,0,0,...,1
+vcd,loddsratio.default,-1,0,0,class<`loddsratio`>,1
+vcd,loddsratio.default,0,0,0,"class<`table`, `xtabs`>",1
+vcd,loddsratio.default,0,0,1,class<`matrix`>,1
+vcd,loddsratio.default,0,0,2,class<`table`>,1
+vcd,loddsratio.default,1,0,0,null,1
+vcd,loddsratio.default,2,0,0,logical,1
+vcd,loddsratio.default,3,0,0,null,1
+vcd,loddsratio.default,3,0,1,double,1
+vcd,loddsratio.default,3,0,2,integer[],1
+vcd,loddsratio.default,4,0,0,logical,1
+vcd,loddsratio.default,5,0,0,...,1
+vcd,loddsratio.formula,-1,0,0,class<`loddsratio`>,1
+vcd,loddsratio.formula,0,0,0,class<`formula`>,1
+vcd,loddsratio.formula,1,0,0,class<`data.frame`>,1
+vcd,loddsratio.formula,2,0,0,...,1
+vcd,loddsratio.formula,3,0,0,null,1
+vcd,loddsratio.formula,4,0,0,null,1
+vcd,make_header,-1,0,0,character[],1
+vcd,make_header,0,0,0,class<`loddsratio`>,1
+vcd,mar_table,-1,0,0,class<`matrix`>,1
+vcd,mar_table,0,0,0,class<`table`>,1
+vcd,.massage_args,-1,0,0,list<character[]>,1
+vcd,.massage_args,-1,0,1,list<character[] | class<`name`>>,1
+vcd,.massage_args,-1,0,2,list<character | class<`name`>>,1
+vcd,.massage_args,-1,0,3,list<class<`name`> | character>,1
+vcd,.massage_args,-1,0,4,list<class<`name`> | double>,1
+vcd,.massage_args,-1,0,5,list<class<`name`> | integer>,1
+vcd,.massage_args,-1,0,6,list<double | class<`name`>>,1
+vcd,.massage_args,-1,0,7,list<double[]>,1
+vcd,.massage_args,-1,0,8,list<double | integer[]>,1
+vcd,.massage_args,0,0,0,...,1
+vcd,mosaic,-1,0,0,"class<`ftable`, `structable`>",1
+vcd,mosaic,0,0,0,class<`formula`>,1
+vcd,mosaic,0,0,1,"class<`ftable`, `structable`>",1
+vcd,mosaic,0,0,2,class<`table`>,1
+vcd,mosaic,0,0,3,"class<`table`, `xtabs`>",1
+vcd,mosaic,0,0,4,class<`matrix`>,1
+vcd,mosaic,1,0,0,...,1
+vcd,mosaic.default,-1,0,0,"class<`ftable`, `structable`>",1
+vcd,mosaic.default,0,0,0,class<`table`>,1
+vcd,mosaic.default,0,0,1,"class<`table`, `xtabs`>",1
+vcd,mosaic.default,0,0,2,"class<`ftable`, `structable`>",1
+vcd,mosaic.default,0,0,3,class<`matrix`>,1
+vcd,mosaic.default,1,0,0,null,1
+vcd,mosaic.default,1,0,1,character,1
+vcd,mosaic.default,1,0,2,double[],1
+vcd,mosaic.default,2,0,0,null,1
+vcd,mosaic.default,2,0,1,logical[],1
+vcd,mosaic.default,3,0,0,null,1
+vcd,mosaic.default,3,0,1,character[],1
+vcd,mosaic.default,4,0,0,null,1
+vcd,mosaic.default,4,0,1,class<`function`>,1
+vcd,mosaic.default,4,0,2,class<`grapcon_generator`>,1
+vcd,mosaic.default,4,0,3,list<class<`unit`>>,1
+vcd,mosaic.default,5,0,0,any,1
+vcd,mosaic.default,6,0,0,null,1
+vcd,mosaic.default,6,0,1,class<`gpar`>,1
+vcd,mosaic.default,6,0,2,class<`grapcon_generator`>,1
+vcd,mosaic.default,6,0,3,character[],1
+vcd,mosaic.default,6,0,4,class<`function`>,1
+vcd,mosaic.default,7,0,0,null,1
+vcd,mosaic.default,7,0,1,class<`formula`>,1
+vcd,mosaic.default,7,0,2,class<`array`>,1
+vcd,mosaic.default,7,0,3,list<double[]>,1
+vcd,mosaic.formula,-1,0,0,"class<`ftable`, `structable`>",1
+vcd,mosaic.formula,0,0,0,class<`formula`>,1
+vcd,mosaic.formula,1,0,0,class<`data.frame`>,1
+vcd,mosaic.formula,1,0,1,"class<`ftable`, `structable`>",1
+vcd,mosaic.formula,1,0,2,class<`table`>,1
+vcd,mosaic.formula,1,0,3,"class<`table`, `xtabs`>",1
+vcd,mosaic.formula,2,0,0,null,1
+vcd,mosaic.formula,3,0,0,...,1
+vcd,mosaic.formula,4,0,0,null,1
+vcd,mosaic.formula,4,0,1,character,1
+vcd,mosaic.formula,5,0,0,null,1
+vcd,mosaic.formula,6,0,0,any,1
+vcd,mosaic.formula,7,0,0,null,1
+vcd,mplot,-1,0,0,null,1
+vcd,mplot,0,0,0,...,1
+vcd,mplot,1,0,0,list<any>,1
+vcd,mplot,2,0,0,null,1
+vcd,mplot,3,0,0,null,1
+vcd,mplot,4,0,0,character,1
+vcd,mplot,4,0,1,null,1
+vcd,mplot,5,0,0,any,1
+vcd,mplot,6,0,0,null,1
+vcd,mplot,7,0,0,any,1
+vcd,odds,-1,0,0,list<double[]>,1
+vcd,odds,0,0,0,class<`table`>,1
+vcd,odds,0,0,1,class<`array`>,1
+vcd,odds,0,0,2,class<`matrix`>,1
+vcd,Ord_estimate,-1,0,0,list<double | character>,1
+vcd,Ord_estimate,0,0,0,double[],1
+vcd,Ord_estimate,1,0,0,null,1
+vcd,Ord_estimate,2,0,0,double,1
+vcd,Ord_plot,-1,0,0,double[],1
+vcd,Ord_plot,0,0,0,class<`table`>,1
+vcd,Ord_plot,0,0,1,"class<`table`, `xtabs`>",1
+vcd,Ord_plot,0,0,2,integer[],1
+vcd,Ord_plot,1,0,0,logical,1
+vcd,Ord_plot,2,0,0,logical,1
+vcd,Ord_plot,3,0,0,double,1
+vcd,Ord_plot,4,0,0,null,1
+vcd,Ord_plot,5,0,0,null,1
+vcd,Ord_plot,6,0,0,null,1
+vcd,Ord_plot,7,0,0,character,1
+vcd,pairs_diagonal_text,-1,0,0,class<`function`>,1
+vcd,pairs_diagonal_text,0,0,0,logical,1
+vcd,pairs_diagonal_text,1,0,0,any,1
+vcd,pairs_diagonal_text,2,0,0,any,1
+vcd,pairs_diagonal_text,3,0,0,any,1
+vcd,pairs_diagonal_text,4,0,0,character[],1
+vcd,pairs_diagonal_text,5,0,0,character[],1
+vcd,pairs_diagonal_text,6,0,0,double,1
+vcd,pairs_diagonal_text,7,0,0,...,1
+vcd,pairs_mosaic,-1,0,0,class<`function`>,1
+vcd,pairs_mosaic,0,0,0,...,1
+vcd,pairs_strucplot,-1,0,0,class<`function`>,1
+vcd,pairs_strucplot,0,0,0,any,1
+vcd,pairs_strucplot,1,0,0,character[],1
+vcd,pairs_strucplot,2,0,0,logical,1
+vcd,pairs_strucplot,3,0,0,any,1
+vcd,pairs_strucplot,4,0,0,null,1
+vcd,pairs_strucplot,5,0,0,...,1
+vcd,pairs.structable,-1,0,0,class<`table`>,1
+vcd,pairs.structable,0,0,0,"class<`ftable`, `structable`>",1
+vcd,pairs.structable,1,0,0,...,1
+vcd,pairs.table,-1,0,0,class<`table`>,1
+vcd,pairs.table,-1,0,1,"class<`table`, `xtabs`>",1
+vcd,pairs.table,0,0,0,class<`table`>,1
+vcd,pairs.table,0,0,1,"class<`table`, `xtabs`>",1
+vcd,pairs.table,1,0,0,class<`grapcon_generator`>,1
+vcd,pairs.table,2,0,0,list<any>,1
+vcd,pairs.table,3,0,0,class<`function`>,1
+vcd,pairs.table,3,0,1,class<`grapcon_generator`>,1
+vcd,pairs.table,4,0,0,any,1
+vcd,pairs.table,5,0,0,class<`grapcon_generator`>,1
+vcd,pairs.table,5,0,1,class<`function`>,1
+vcd,pairs.table,6,0,0,any,1
+vcd,pairs.table,7,0,0,null,1
+vcd,pexpand,-1,0,0,character[],1
+vcd,pexpand,-1,0,1,double[],1
+vcd,pexpand,-1,0,2,list<class<`gpar`>>,1
+vcd,pexpand,-1,0,3,list<character[]>,1
+vcd,pexpand,0,0,0,character[],1
+vcd,pexpand,0,0,1,double[],1
+vcd,pexpand,0,0,2,null,1
+vcd,pexpand,0,0,3,list<class<`gpar`>>,1
+vcd,pexpand,0,0,4,list<character[]>,1
+vcd,pexpand,1,0,0,double,1
+vcd,pexpand,2,0,0,any,1
+vcd,pexpand,3,0,0,character[],1
+vcd,pexpand,4,0,0,null,1
+vcd,pexpand,4,0,1,character[],1
+vcd,plot.goodfit,-1,0,0,null,1
+vcd,plot.goodfit,0,0,0,class<`goodfit`>,1
+vcd,plot.goodfit,1,0,0,...,1
+vcd,plot.loddsratio,-1,0,0,null,1
+vcd,plot.loddsratio,0,0,0,class<`loddsratio`>,1
+vcd,plot.loddsratio,1,0,0,logical,1
+vcd,plot.loddsratio,2,0,0,class<`gpar`>,1
+vcd,plot.loddsratio,3,0,0,logical,1
+vcd,plot.loddsratio,4,0,0,double,1
+vcd,plot.loddsratio,5,0,0,logical,1
+vcd,plot.loddsratio,6,0,0,double,1
+vcd,plot.loddsratio,7,0,0,double,1
+vcd,plot.loglm,-1,0,0,"class<`ftable`, `structable`>",1
+vcd,plot.loglm,0,0,0,class<`loglm`>,1
+vcd,plot.loglm,1,0,0,class<`function`>,1
+vcd,plot.loglm,2,0,0,character[],1
+vcd,plot.loglm,3,0,0,character[],1
+vcd,plot.loglm,4,0,0,class<`grapcon_generator`>,1
+vcd,plot.loglm,5,0,0,list<any>,1
+vcd,plot.loglm,6,0,0,...,1
+vcd,predict.goodfit,-1,0,0,double[],1
+vcd,predict.goodfit,0,0,0,class<`goodfit`>,1
+vcd,predict.goodfit,1,0,0,integer[],1
+vcd,predict.goodfit,2,0,0,character[],1
+vcd,predict.goodfit,3,0,0,...,1
+vcd,print.Kappa,-1,0,0,class<`Kappa`>,1
+vcd,print.Kappa,0,0,0,class<`Kappa`>,1
+vcd,print.Kappa,1,0,0,double,1
+vcd,print.Kappa,2,0,0,logical,1
+vcd,print.Kappa,3,0,0,double,1
+vcd,print.Kappa,4,0,0,...,1
+vcd,remove_trailing_comma,-1,0,0,character,1
+vcd,remove_trailing_comma,0,0,0,character,1
+vcd,rootogram,-1,0,0,null,1
+vcd,rootogram,0,0,0,class<`goodfit`>,1
+vcd,rootogram,0,0,1,class<`table`>,1
+vcd,rootogram,1,0,0,...,1
+vcd,rootogram.default,-1,0,0,null,1
+vcd,rootogram.default,0,0,0,double[],1
+vcd,rootogram.default,0,0,1,class<`table`>,1
+vcd,rootogram.default,1,0,0,double[],1
+vcd,rootogram.default,2,0,0,integer[],1
+vcd,rootogram.default,2,0,1,null,1
+vcd,rootogram.default,3,0,0,character[],1
+vcd,rootogram.default,4,0,0,character[],1
+vcd,rootogram.default,5,0,0,logical,1
+vcd,rootogram.default,6,0,0,logical,1
+vcd,rootogram.default,7,0,0,any,1
+vcd,rootogram.goodfit,-1,0,0,null,1
+vcd,rootogram.goodfit,0,0,0,class<`goodfit`>,1
+vcd,rootogram.goodfit,1,0,0,...,1
+vcd,shading_binary,-1,0,0,class<`function`>,1
+vcd,shading_binary,0,0,0,null,1
+vcd,shading_binary,1,0,0,null,1
+vcd,shading_binary,2,0,0,null,1
+vcd,shading_binary,3,0,0,null,1
+vcd,shading_binary,4,0,0,double[],1
+vcd,shading_diagonal,-1,0,0,class<`gpar`>,1
+vcd,shading_diagonal,0,0,0,"class<`table`, `xtabs`>",1
+vcd,shading_diagonal,1,0,0,null,1
+vcd,shading_Friendly,-1,0,0,class<`function`>,1
+vcd,shading_Friendly,0,0,0,null,1
+vcd,shading_Friendly,1,0,0,null,1
+vcd,shading_Friendly,2,0,0,null,1
+vcd,shading_Friendly,3,0,0,null,1
+vcd,shading_Friendly,4,0,0,double[],1
+vcd,shading_Friendly,5,0,0,double,1
+vcd,shading_Friendly,6,0,0,double[],1
+vcd,shading_Friendly,7,0,0,null,1
+vcd,shading_hcl,-1,0,0,class<`function`>,1
+vcd,shading_hcl,0,0,0,class<`table`>,1
+vcd,shading_hcl,0,0,1,"class<`table`, `xtabs`>",1
+vcd,shading_hcl,0,0,2,null,1
+vcd,shading_hcl,1,0,0,class<`table`>,1
+vcd,shading_hcl,1,0,1,"class<`table`, `xtabs`>",1
+vcd,shading_hcl,1,0,2,null,1
+vcd,shading_hcl,2,0,0,class<`array`>,1
+vcd,shading_hcl,2,0,1,class<`table`>,1
+vcd,shading_hcl,2,0,2,"class<`table`, `xtabs`>",1
+vcd,shading_hcl,2,0,3,null,1
+vcd,shading_hcl,3,0,0,double,1
+vcd,shading_hcl,3,0,1,null,1
+vcd,shading_hcl,4,0,0,null,1
+vcd,shading_hcl,4,0,1,double[],1
+vcd,shading_hcl,5,0,0,null,1
+vcd,shading_hcl,5,0,1,double[],1
+vcd,shading_hcl,6,0,0,null,1
+vcd,shading_hcl,6,0,1,double[],1
+vcd,shading_hcl,7,0,0,double[],1
+vcd,shading_hcl,7,0,1,class<`function`>,1
+vcd,shading_hsv,-1,0,0,class<`function`>,1
+vcd,shading_hsv,0,0,0,class<`table`>,1
+vcd,shading_hsv,0,0,1,"class<`table`, `xtabs`>",1
+vcd,shading_hsv,0,0,2,null,1
+vcd,shading_hsv,1,0,0,class<`table`>,1
+vcd,shading_hsv,1,0,1,"class<`table`, `xtabs`>",1
+vcd,shading_hsv,1,0,2,null,1
+vcd,shading_hsv,2,0,0,class<`table`>,1
+vcd,shading_hsv,2,0,1,"class<`table`, `xtabs`>",1
+vcd,shading_hsv,2,0,2,null,1
+vcd,shading_hsv,3,0,0,double,1
+vcd,shading_hsv,3,0,1,null,1
+vcd,shading_hsv,4,0,0,double[],1
+vcd,shading_hsv,5,0,0,double[],1
+vcd,shading_hsv,6,0,0,double[],1
+vcd,shading_hsv,7,0,0,double[],1
+vcd,shading_Marimekko,-1,0,0,class<`gpar`>,1
+vcd,shading_Marimekko,0,0,0,class<`table`>,1
+vcd,shading_Marimekko,1,0,0,null,1
+vcd,shading_Marimekko,2,0,0,logical,1
+vcd,shading_sieve,-1,0,0,class<`function`>,1
+vcd,shading_sieve,0,0,0,null,1
+vcd,shading_sieve,1,0,0,null,1
+vcd,shading_sieve,2,0,0,null,1
+vcd,shading_sieve,3,0,0,null,1
+vcd,shading_sieve,4,0,0,double[],1
+vcd,shading_sieve,5,0,0,character[],1
+vcd,shading_sieve,6,0,0,double,1
+vcd,shading_sieve,7,0,0,double,1
+vcd,sieve,-1,0,0,"class<`ftable`, `structable`>",1
+vcd,sieve,0,0,0,class<`formula`>,1
+vcd,sieve,0,0,1,class<`table`>,1
+vcd,sieve,0,0,2,"class<`table`, `xtabs`>",1
+vcd,sieve,1,0,0,...,1
+vcd,sieve.default,-1,0,0,"class<`ftable`, `structable`>",1
+vcd,sieve.default,0,0,0,class<`table`>,1
+vcd,sieve.default,0,0,1,"class<`table`, `xtabs`>",1
+vcd,sieve.default,1,0,0,null,1
+vcd,sieve.default,2,0,0,null,1
+vcd,sieve.default,3,0,0,null,1
+vcd,sieve.default,3,0,1,logical,1
+vcd,sieve.default,4,0,0,logical,1
+vcd,sieve.default,5,0,0,null,1
+vcd,sieve.default,6,0,0,null,1
+vcd,sieve.default,7,0,0,class<`function`>,1
+vcd,sieve.default,7,0,1,null,1
+vcd,sieve.formula,-1,0,0,"class<`ftable`, `structable`>",1
+vcd,sieve.formula,0,0,0,class<`formula`>,1
+vcd,sieve.formula,1,0,0,class<`data.frame`>,1
+vcd,sieve.formula,1,0,1,"class<`ftable`, `structable`>",1
+vcd,sieve.formula,2,0,0,...,1
+vcd,sieve.formula,3,0,0,character,1
+vcd,sieve.formula,3,0,1,null,1
+vcd,sieve.formula,4,0,0,null,1
+vcd,sieve.formula,5,0,0,logical[],1
+vcd,sieve.formula,5,0,1,null,1
+vcd,spacing_conditional,-1,0,0,class<`function`>,1
+vcd,spacing_conditional,0,0,0,class<`unit`>,1
+vcd,spacing_conditional,0,0,1,double,1
+vcd,spacing_conditional,1,0,0,class<`unit`>,1
+vcd,spacing_conditional,2,0,0,double,1
+vcd,spacing_dimequal,-1,0,0,list<class<`unit`>>,1
+vcd,spacing_dimequal,-1,0,1,"list<class<`unit`, `unit.arithmetic`>>",1
+vcd,spacing_dimequal,0,0,0,integer[],1
+vcd,spacing_dimequal,1,0,0,any,1
+vcd,spacing_dimequal,-1,1,0,class<`function`>,1
+vcd,spacing_dimequal,0,1,0,class<`unit`>,1
+vcd,spacing_dimequal,0,1,1,"class<`unit`, `unit.arithmetic`>",1
+vcd,spacing_dimequal,0,1,2,double[],1
+vcd,spacing_equal,-1,0,0,list<class<`unit`>>,1
+vcd,spacing_equal,0,0,0,integer[],1
+vcd,spacing_equal,1,0,0,any,1
+vcd,spacing_equal,-1,1,0,class<`function`>,1
+vcd,spacing_equal,0,1,0,class<`unit`>,1
+vcd,spacing_equal,0,1,1,double,1
+vcd,spacing_increase,-1,0,0,class<`function`>,1
+vcd,spacing_increase,0,0,0,class<`unit`>,1
+vcd,spacing_increase,0,0,1,double,1
+vcd,spacing_increase,1,0,0,any,1
+vcd,spacing_increase,-1,1,0,"list<class<`unit`, `unit.arithmetic`>>",1
+vcd,spacing_increase,0,1,0,integer[],1
+vcd,spacing_increase,1,1,0,any,1
+vcd,spine,-1,0,0,class<`table`>,1
+vcd,spine,0,0,0,class<`factor`>,1
+vcd,spine,0,0,1,class<`formula`>,1
+vcd,spine,0,0,2,integer[],1
+vcd,spine,1,0,0,...,1
+vcd,spine.default,-1,0,0,class<`table`>,1
+vcd,spine.default,0,0,0,class<`factor`>,1
+vcd,spine.default,0,0,1,integer[],1
+vcd,spine.default,1,0,0,"class<`factor`, `ordered`>",1
+vcd,spine.default,1,0,1,class<`factor`>,1
+vcd,spine.default,2,0,0,any,1
+vcd,spine.default,3,0,0,double,1
+vcd,spine.default,4,0,0,any,1
+vcd,spine.default,5,0,0,character,1
+vcd,spine.default,6,0,0,character,1
+vcd,spine.default,7,0,0,character,1
+vcd,spine.formula,-1,0,0,class<`table`>,1
+vcd,spine.formula,0,0,0,class<`formula`>,1
+vcd,spine.formula,1,0,0,class<`data.frame`>,1
+vcd,spine.formula,2,0,0,character,1
+vcd,spine.formula,2,0,1,double[],1
+vcd,spine.formula,2,0,2,null,1
+vcd,spine.formula,3,0,0,double,1
+vcd,spine.formula,4,0,0,null,1
+vcd,spine.formula,5,0,0,character,1
+vcd,spine.formula,6,0,0,null,1
+vcd,spine.formula,7,0,0,null,1
+vcd,struc_assoc,-1,0,0,class<`function`>,1
+vcd,struc_assoc,0,0,0,any,1
+vcd,struc_assoc,1,0,0,any,1
+vcd,struc_assoc,2,0,0,any,1
+vcd,struc_assoc,3,0,0,any,1
+vcd,struc_assoc,4,0,0,any,1
+vcd,struc_assoc,5,0,0,any,1
+vcd,struc_mosaic,-1,0,0,null,1
+vcd,struc_mosaic,0,0,0,any,1
+vcd,struc_mosaic,1,0,0,class<`matrix`>,1
+vcd,struc_mosaic,1,0,1,"class<`table`, `xtabs`>",1
+vcd,struc_mosaic,1,0,2,class<`array`>,1
+vcd,struc_mosaic,2,0,0,any,1
+vcd,struc_mosaic,3,0,0,list<class<`unit`>>,1
+vcd,struc_mosaic,3,0,1,"list<class<`unit`, `unit.arithmetic`> | class<`unit`>>",1
+vcd,struc_mosaic,4,0,0,class<`gpar`>,1
+vcd,struc_mosaic,5,0,0,logical[],1
+vcd,struc_mosaic,6,0,0,character,1
+vcd,struc_mosaic,-1,1,0,class<`function`>,1
+vcd,struc_mosaic,0,1,0,any,1
+vcd,struc_mosaic,1,1,0,any,1
+vcd,struc_mosaic,2,1,0,any,1
+vcd,struc_mosaic,3,1,0,any,1
+vcd,struc_mosaic,4,1,0,any,1
+vcd,strucplot,-1,0,0,"class<`ftable`, `structable`>",1
+vcd,strucplot,0,0,0,class<`table`>,1
+vcd,strucplot,0,0,1,"class<`table`, `xtabs`>",1
+vcd,strucplot,0,0,2,class<`matrix`>,1
+vcd,strucplot,1,0,0,class<`table`>,1
+vcd,strucplot,1,0,1,null,1
+vcd,strucplot,1,0,2,class<`matrix`>,1
+vcd,strucplot,2,0,0,class<`array`>,1
+vcd,strucplot,2,0,1,null,1
+vcd,strucplot,2,0,2,class<`formula`>,1
+vcd,strucplot,2,0,3,list<double[]>,1
+vcd,strucplot,3,0,0,any,1
+vcd,strucplot,4,0,0,null,1
+vcd,strucplot,4,0,1,logical,1
+vcd,strucplot,5,0,0,character[],1
+vcd,strucplot,6,0,0,character,1
+vcd,strucplot,6,0,1,null,1
+vcd,strucplot,7,0,0,null,1
+vcd,struc_sieve,-1,0,0,class<`function`>,1
+vcd,struc_sieve,0,0,0,character,1
+vcd,struc_sieve,1,0,0,any,1
+vcd,struc_sieve,2,0,0,any,1
+vcd,structable,-1,0,0,"class<`ftable`, `structable`>",1
+vcd,structable,0,0,0,class<`formula`>,1
+vcd,structable,0,0,1,class<`table`>,1
+vcd,structable,0,0,2,"class<`table`, `xtabs`>",1
+vcd,structable,0,0,3,class<`array`>,1
+vcd,structable,0,0,4,class<`matrix`>,1
+vcd,structable,1,0,0,...,1
+vcd,[<-.structable,-1,0,0,"class<`ftable`, `structable`>",1
+vcd,[<-.structable,0,0,0,"class<`ftable`, `structable`>",1
+vcd,[<-.structable,1,0,0,...,1
+vcd,[<-.structable,2,0,0,"class<`ftable`, `structable`>",1
+vcd,[.structable,-1,0,0,"class<`ftable`, `structable`>",1
+vcd,[.structable,0,0,0,"class<`ftable`, `structable`>",1
+vcd,[.structable,1,0,0,...,1
+vcd,[[.structable,-1,0,0,"class<`ftable`, `structable`>",1
+vcd,[[.structable,-1,0,1,class<`structable`>,1
+vcd,[[.structable,0,0,0,"class<`ftable`, `structable`>",1
+vcd,[[.structable,0,0,1,class<`structable`>,1
+vcd,[[.structable,1,0,0,...,1
+vcd,structable.default,-1,0,0,"class<`ftable`, `structable`>",1
+vcd,structable.default,0,0,0,...,1
+vcd,structable.default,1,0,0,character[],1
+vcd,structable.default,1,0,1,null,1
+vcd,structable.default,2,0,0,logical[],1
+vcd,structable.formula,-1,0,0,"class<`ftable`, `structable`>",1
+vcd,structable.formula,0,0,0,class<`formula`>,1
+vcd,structable.formula,1,0,0,class<`data.frame`>,1
+vcd,structable.formula,1,0,1,"class<`ftable`, `structable`>",1
+vcd,structable.formula,1,0,2,class<`table`>,1
+vcd,structable.formula,1,0,3,"class<`table`, `xtabs`>",1
+vcd,structable.formula,2,0,0,null,1
+vcd,structable.formula,3,0,0,logical,1
+vcd,structable.formula,3,0,1,null,1
+vcd,structable.formula,4,0,0,...,1
+vcd,structable.formula,5,0,0,any,1
+vcd,structable.formula,6,0,0,any,1
+vcd,summary.assocstats,-1,0,0,class<`summary.assocstats`>,1
+vcd,summary.assocstats,0,0,0,class<`assocstats`>,1
+vcd,summary.assocstats,1,0,0,logical,1
+vcd,summary.assocstats,2,0,0,...,1
+vcd,summary.goodfit,-1,0,0,class<`matrix`>,1
+vcd,summary.goodfit,0,0,0,class<`goodfit`>,1
+vcd,summary.goodfit,1,0,0,...,1
+vcd,summary.Kappa,-1,0,0,class<`summary.Kappa`>,1
+vcd,summary.Kappa,0,0,0,class<`Kappa`>,1
+vcd,summary.Kappa,1,0,0,...,1
+vcd,summary.lodds,-1,0,0,class<`coeftest`>,1
+vcd,summary.lodds,0,0,0,class<`lodds`>,1
+vcd,summary.lodds,0,0,1,class<`loddsratio`>,1
+vcd,summary.lodds,1,0,0,...,1
+vcd,summary.loddsratio,-1,0,0,class<`coeftest`>,1
+vcd,summary.loddsratio,0,0,0,class<`lodds`>,1
+vcd,summary.loddsratio,0,0,1,class<`loddsratio`>,1
+vcd,summary.loddsratio,1,0,0,...,1
+vcd,table2d_summary,-1,0,0,class<`table2d_summary`>,1
+vcd,table2d_summary,0,0,0,class<`table`>,1
+vcd,table2d_summary,1,0,0,logical,1
+vcd,table2d_summary,2,0,0,logical,1
+vcd,table2d_summary,3,0,0,character[],1
+vcd,table2d_summary,4,0,0,logical,1
+vcd,table2d_summary,5,0,0,...,1
+vcd,ternaryplot,-1,0,0,null,1
+vcd,ternaryplot,0,0,0,class<`data.frame`>,1
+vcd,ternaryplot,0,0,1,class<`matrix`>,1
+vcd,ternaryplot,0,0,2,"class<`table`, `xtabs`>",1
+vcd,ternaryplot,1,0,0,double,1
+vcd,ternaryplot,2,0,0,character[],1
+vcd,ternaryplot,2,0,1,null,1
+vcd,ternaryplot,3,0,0,character[],1
+vcd,ternaryplot,4,0,0,character,1
+vcd,ternaryplot,5,0,0,any,1
+vcd,ternaryplot,6,0,0,^character[],1
+vcd,ternaryplot,6,0,1,null,1
+vcd,ternaryplot,7,0,0,character,1
+vcd,tile,-1,0,0,"class<`ftable`, `structable`>",1
+vcd,tile,0,0,0,class<`loddsratio`>,1
+vcd,tile,0,0,1,class<`matrix`>,1
+vcd,tile,0,0,2,class<`table`>,1
+vcd,tile,1,0,0,...,1
+vcd,tile.default,-1,0,0,"class<`ftable`, `structable`>",1
+vcd,tile.default,0,0,0,class<`matrix`>,1
+vcd,tile.default,0,0,1,class<`table`>,1
+vcd,tile.default,1,0,0,character[],1
+vcd,tile.default,2,0,0,character[],1
+vcd,tile.default,3,0,0,character[],1
+vcd,tile.default,4,0,0,null,1
+vcd,tile.default,5,0,0,logical,1
+vcd,tile.default,6,0,0,class<`function`>,1
+vcd,tile.default,7,0,0,null,1
+vcd,tile.loddsratio,-1,0,0,"class<`ftable`, `structable`>",1
+vcd,tile.loddsratio,0,0,0,class<`loddsratio`>,1
+vcd,tile.loddsratio,1,0,0,null,1
+vcd,tile.loddsratio,2,0,0,class<`grapcon_generator`>,1
+vcd,tile.loddsratio,3,0,0,any,1
+vcd,tile.loddsratio,4,0,0,null,1
+vcd,tile.loddsratio,5,0,0,class<`function`>,1
+vcd,tile.loddsratio,6,0,0,character,1
+vcd,tile.loddsratio,7,0,0,character,1
+vcd,t.structable,-1,0,0,"class<`ftable`, `structable`>",1
+vcd,t.structable,0,0,0,"class<`ftable`, `structable`>",1
+vcd,vcdViewport,-1,0,0,"class<`viewport`, `vpTree`>",1
+vcd,vcdViewport,0,0,0,class<`unit`>,1
+vcd,vcdViewport,0,0,1,"class<`unit`, `unit.arithmetic`>",1
+vcd,vcdViewport,0,0,2,double[],1
+vcd,vcdViewport,1,0,0,class<`unit`>,1
+vcd,vcdViewport,1,0,1,null,1
+vcd,vcdViewport,1,0,2,double,1
+vcd,vcdViewport,2,0,0,null,1
+vcd,vcdViewport,3,0,0,logical,1
+vcd,vcdViewport,4,0,0,logical,1
+vcd,vcdViewport,5,0,0,logical,1
+vcd,vcdViewport,6,0,0,logical,1
+vcd,vcdViewport,7,0,0,character,1
+vcd,vcov.lodds,-1,0,0,class<`matrix`>,1
+vcd,vcov.lodds,0,0,0,class<`lodds`>,1
+vcd,vcov.lodds,0,0,1,class<`loddsratio`>,1
+vcd,vcov.lodds,1,0,0,logical,1
+vcd,vcov.lodds,2,0,0,...,1
+vcd,vcov.loddsratio,-1,0,0,class<`matrix`>,1
+vcd,vcov.loddsratio,0,0,0,class<`lodds`>,1
+vcd,vcov.loddsratio,0,0,1,class<`loddsratio`>,1
+vcd,vcov.loddsratio,1,0,0,logical,1
+vcd,vcov.loddsratio,2,0,0,...,1
+vcd,woolf_test,-1,0,0,class<`htest`>,1
+vcd,woolf_test,0,0,0,class<`table`>,1
+vctrs,%0%,-1,0,0,double,1
+vctrs,%0%,-1,0,1,integer[],1
+vctrs,%0%,0,0,0,integer[],1
+vctrs,%0%,1,0,0,double,1
+vctrs,all_equal,-1,0,0,logical,1
+vctrs,all_equal,0,0,0,integer[],1
+vctrs,allow_lossy_cast,-1,0,0,any,1
+vctrs,allow_lossy_cast,0,0,0,any,1
+vctrs,allow_lossy_cast,1,0,0,null,1
+vctrs,allow_lossy_cast,2,0,0,null,1
+vctrs,allow_lossy_cast,2,0,1,integer[],1
+vctrs,append_pos,-1,0,0,character[],1
+vctrs,append_pos,0,0,0,character[],1
+vctrs,append_pos,1,0,0,logical[],1
+vctrs,as_double_date,-1,0,0,class<`Date`>,1
+vctrs,as_double_date,0,0,0,class<`Date`>,1
+vctrs,as_list_of,-1,0,0,"class<`vctrs_list_of`, `vctrs_vctr`>",1
+vctrs,as_list_of,0,0,0,"class<`vctrs_list_of`, `vctrs_vctr`>",1
+vctrs,as_list_of,1,0,0,...,1
+vctrs,as_list_of.vctrs_list_of,-1,0,0,"class<`vctrs_list_of`, `vctrs_vctr`>",1
+vctrs,as_list_of.vctrs_list_of,0,0,0,"class<`vctrs_list_of`, `vctrs_vctr`>",1
+vctrs,as_list_of.vctrs_list_of,1,0,0,double[],1
+vctrs,as_list_of.vctrs_list_of,2,0,0,...,1
+vctrs,as.list.vctrs_sclr,-1,0,0,list<class<`factor`>>,1
+vctrs,as.list.vctrs_sclr,0,0,0,"class<`vctrs_partial`, `vctrs_partial_factor`, `vctrs_sclr`>",1
+vctrs,as.list.vctrs_sclr,1,0,0,...,1
+vctrs,as_minimal_names,-1,0,0,character[],1
+vctrs,as_minimal_names,0,0,0,character[],1
+vctrs,as_universal_names,-1,0,0,character[],1
+vctrs,as_universal_names,0,0,0,character[],1
+vctrs,as_universal_names,1,0,0,logical,1
+vctrs,bullets,-1,0,0,character,1
+vctrs,bullets,0,0,0,character,1
+vctrs,bullets,1,0,0,...,1
+vctrs,bullets,2,0,0,any,1
+vctrs,cat_line,-1,0,0,null,1
+vctrs,cat_line,0,0,0,...,1
+vctrs,check_fields,-1,0,0,list<integer[] | character[]>,1
+vctrs,check_fields,0,0,0,list<integer[] | character[]>,1
+vctrs,cnd_body.vctrs_error_cast_lossy,-1,0,0,character,1
+vctrs,cnd_body.vctrs_error_cast_lossy,0,0,0,"class<`condition`, `error`, `rlang_error`, `vctrs_error`, `vctrs_error_cast_lossy`>",1
+vctrs,cnd_body.vctrs_error_cast_lossy,1,0,0,...,1
+vctrs,cnd_header.vctrs_error_cast_lossy,-1,0,0,"class<`character`, `glue`>",1
+vctrs,cnd_header.vctrs_error_cast_lossy,0,0,0,"class<`condition`, `error`, `rlang_error`, `vctrs_error`, `vctrs_error_cast_lossy`>",1
+vctrs,cnd_header.vctrs_error_cast_lossy,1,0,0,...,1
+vctrs,compact,-1,0,0,list<any>,1
+vctrs,compact,0,0,0,list<any>,1
+vctrs,conditionMessage.vctrs_error_cast_lossy,-1,0,0,character,1
+vctrs,conditionMessage.vctrs_error_cast_lossy,0,0,0,"class<`condition`, `error`, `rlang_error`, `vctrs_error`, `vctrs_error_cast_lossy`>",1
+vctrs,data_frame,-1,0,0,class<`data.frame`>,1
+vctrs,data_frame,0,0,0,...,1
+vctrs,describe_repair,-1,0,0,null,1
+vctrs,describe_repair,0,0,0,character[],1
+vctrs,describe_repair,0,0,1,null,1
+vctrs,describe_repair,1,0,0,character[],1
+vctrs,dim2,-1,0,0,integer[],1
+vctrs,dim2,0,0,0,class<`matrix`>,1
+vctrs,dim2,0,0,1,character[],1
+vctrs,dim2,0,0,2,double[],1
+vctrs,dim2,0,0,3,null,1
+vctrs,field,-1,0,0,double[],1
+vctrs,field,0,0,0,"class<`vctrs_rcrd`, `vctrs_vctr`>",1
+vctrs,field,0,0,1,"class<`vctrs_group_rle`, `vctrs_rcrd`, `vctrs_vctr`>",1
+vctrs,field,1,0,0,character,1
+vctrs,field<-,-1,0,0,"class<`vctrs_rcrd`, `vctrs_vctr`>",1
+vctrs,field<-,0,0,0,"class<`vctrs_rcrd`, `vctrs_vctr`>",1
+vctrs,field<-,1,0,0,character,1
+vctrs,field<-,2,0,0,double[],1
+vctrs,fields,-1,0,0,character[],1
+vctrs,fields,0,0,0,"class<`vctrs_rcrd`, `vctrs_vctr`>",1
+vctrs,format_arg_label,-1,0,0,character,1
+vctrs,format_arg_label,0,0,0,character,1
+vctrs,format_arg_label,1,0,0,character,1
+vctrs,glue_lines,-1,0,0,character,1
+vctrs,glue_lines,0,0,0,...,1
+vctrs,glue_lines,1,0,0,environment,1
+vctrs,has_dim,-1,0,0,logical,1
+vctrs,has_dim,0,0,0,character[],1
+vctrs,has_dim,0,0,1,class<`difftime`>,1
+vctrs,has_dim,0,0,2,"class<`POSIXct`, `POSIXt`>",1
+vctrs,has_dim,0,0,3,class<`vctrs_vctr`>,1
+vctrs,has_dim,0,0,4,^double[],1
+vctrs,hash_label,-1,0,0,character,1
+vctrs,hash_label,0,0,0,character[],1
+vctrs,hash_label,1,0,0,double,1
+vctrs,has_unique_names,-1,0,0,logical,1
+vctrs,has_unique_names,0,0,0,list<class<`data.frame`>>,1
+vctrs,has_unique_names,0,0,1,list<class<`factor`>>,1
+vctrs,has_unique_names,0,0,2,list<integer[] | character[]>,1
+vctrs,indent,-1,0,0,character,1
+vctrs,indent,0,0,0,character,1
+vctrs,indent,1,0,0,double,1
+vctrs,inline_list,-1,0,0,character,1
+vctrs,inline_list,0,0,0,character,1
+vctrs,inline_list,1,0,0,integer,1
+vctrs,inline_list,2,0,0,integer,1
+vctrs,inline_list,3,0,0,character,1
+vctrs,is_partial,-1,0,0,logical,1
+vctrs,is_partial,0,0,0,class<`factor`>,1
+vctrs,is_partial,0,0,1,"class<`vctrs_partial`, `vctrs_partial_factor`, `vctrs_sclr`>",1
+vctrs,is_partial,0,0,2,double[],1
+vctrs,is_same_type,-1,0,0,logical,1
+vctrs,is_same_type,0,0,0,character,1
+vctrs,is_same_type,0,0,1,class<`factor`>,1
+vctrs,is_same_type,0,0,2,integer[],1
+vctrs,is_same_type,1,0,0,double[],1
+vctrs,is_same_type,1,0,1,class<`factor`>,1
+vctrs,is_same_type,1,0,2,"class<`vctrs_partial`, `vctrs_partial_factor`, `vctrs_sclr`>",1
+vctrs,is_syntactic,-1,0,0,logical[],1
+vctrs,is_syntactic,0,0,0,character[],1
+vctrs,is_unspecified,-1,0,0,logical,1
+vctrs,is_unspecified,0,0,0,double[],1
+vctrs,layout_type,-1,0,0,character,1
+vctrs,layout_type,0,0,0,character,1
+vctrs,layout_type,1,0,0,character,1
+vctrs,list_of,-1,0,0,"class<`vctrs_list_of`, `vctrs_vctr`>",1
+vctrs,list_of,0,0,0,...,1
+vctrs,list_of,1,0,0,double[],1
+vctrs,list_of,1,0,1,null,1
+vctrs,make_syntactic,-1,0,0,character[],1
+vctrs,make_syntactic,0,0,0,character[],1
+vctrs,map,-1,0,0,list<any>,1
+vctrs,map,0,0,0,character[],1
+vctrs,map,0,0,1,list<character[]>,1
+vctrs,map,0,0,2,list<class<`data.frame`>>,1
+vctrs,map,0,0,3,list<double>,1
+vctrs,map,0,0,4,class<`data.frame`>,1
+vctrs,map,0,0,5,list<integer[]>,1
+vctrs,map,0,0,6,"class<`vctrs_partial`, `vctrs_partial_factor`, `vctrs_sclr`>",1
+vctrs,map,1,0,0,class<`function`>,1
+vctrs,map,2,0,0,...,1
+vctrs,map_chr,-1,0,0,character[],1
+vctrs,map_chr,0,0,0,list<character[]>,1
+vctrs,map_chr,0,0,1,list<class<`data.frame`>>,1
+vctrs,map_chr,0,0,2,character,1
+vctrs,map_chr,0,0,3,class<`data.frame`>,1
+vctrs,map_chr,1,0,0,class<`function`>,1
+vctrs,map_chr,2,0,0,...,1
+vctrs,map_int,-1,0,0,integer[],1
+vctrs,map_int,0,0,0,list<character[]>,1
+vctrs,map_int,0,0,1,list<integer[] | character[]>,1
+vctrs,map_int,1,0,0,class<`function`>,1
+vctrs,map_int,2,0,0,...,1
+vctrs,map_lgl,-1,0,0,logical[],1
+vctrs,map_lgl,0,0,0,list<any>,1
+vctrs,map_lgl,0,0,1,class<`data.frame`>,1
+vctrs,map_lgl,1,0,0,class<`function`>,1
+vctrs,map_lgl,2,0,0,...,1
+vctrs,map_mold,-1,0,0,character[],1
+vctrs,map_mold,-1,0,1,integer[],1
+vctrs,map_mold,0,0,0,character,1
+vctrs,map_mold,0,0,1,class<`data.frame`>,1
+vctrs,map_mold,0,0,2,list<any>,1
+vctrs,map_mold,1,0,0,class<`function`>,1
+vctrs,map_mold,2,0,0,character,1
+vctrs,map_mold,2,0,1,integer,1
+vctrs,map_mold,3,0,0,...,1
+vctrs,Math.vctrs_vctr,-1,0,0,class<`vctrs_vctr`>,1
+vctrs,Math.vctrs_vctr,0,0,0,class<`vctrs_vctr`>,1
+vctrs,Math.vctrs_vctr,1,0,0,...,1
+vctrs,maybe_lossy_cast,-1,0,0,any,1
+vctrs,maybe_lossy_cast,0,0,0,character[],1
+vctrs,maybe_lossy_cast,0,0,1,integer[],1
+vctrs,maybe_lossy_cast,1,0,0,any,1
+vctrs,maybe_lossy_cast,2,0,0,any,1
+vctrs,maybe_lossy_cast,3,0,0,logical[],1
+vctrs,maybe_lossy_cast,4,0,0,null,1
+vctrs,maybe_lossy_cast,5,0,0,null,1
+vctrs,maybe_lossy_cast,6,0,0,...,1
+vctrs,maybe_lossy_cast,7,0,0,any,1
+vctrs,maybe_lossy_cast,8,0,0,any,1
+vctrs,maybe_lossy_cast,9,0,0,null,1
+vctrs,maybe_lossy_cast,10,0,0,null,1
+vctrs,maybe_lossy_cast,11,0,0,logical,1
+vctrs,names_all_or_nothing,-1,0,0,logical,1
+vctrs,names_all_or_nothing,0,0,0,null,1
+vctrs,new_data_frame,-1,0,0,class<`data.frame`>,1
+vctrs,new_data_frame,0,0,0,list<^double[]>,1
+vctrs,new_data_frame,0,0,1,list<^logical[] | integer[]>,1
+vctrs,new_data_frame,0,0,2,list<double[] | character[]>,1
+vctrs,new_data_frame,0,0,3,list<integer[] | character[]>,1
+vctrs,new_data_frame,1,0,0,integer,1
+vctrs,new_data_frame,1,0,1,null,1
+vctrs,new_data_frame,2,0,0,...,1
+vctrs,new_data_frame,3,0,0,null,1
+vctrs,new_date,-1,0,0,class<`Date`>,1
+vctrs,new_date,0,0,0,double,1
+vctrs,new_datetime,-1,0,0,"class<`POSIXct`, `POSIXt`>",1
+vctrs,new_datetime,0,0,0,"class<`POSIXct`, `POSIXt`>",1
+vctrs,new_datetime,0,0,1,double,1
+vctrs,new_datetime,1,0,0,null,1
+vctrs,new_datetime,1,0,1,character,1
+vctrs,new_duration,-1,0,0,class<`difftime`>,1
+vctrs,new_duration,0,0,0,double[],1
+vctrs,new_duration,1,0,0,character,1
+vctrs,new_factor,-1,0,0,class<`factor`>,1
+vctrs,new_factor,0,0,0,integer[],1
+vctrs,new_factor,1,0,0,character[],1
+vctrs,new_factor,2,0,0,...,1
+vctrs,new_factor,3,0,0,character[],1
+vctrs,new_list_of,-1,0,0,"class<`vctrs_list_of`, `vctrs_vctr`>",1
+vctrs,new_list_of,0,0,0,list<any>,1
+vctrs,new_list_of,1,0,0,double[],1
+vctrs,new_list_of,2,0,0,...,1
+vctrs,new_list_of,3,0,0,character[],1
+vctrs,new_partial,-1,0,0,"class<`vctrs_partial`, `vctrs_partial_factor`, `vctrs_sclr`>",1
+vctrs,new_partial,-1,0,1,"class<`vctrs_partial`, `vctrs_partial_frame`, `vctrs_sclr`>",1
+vctrs,new_partial,0,0,0,...,1
+vctrs,new_partial,1,0,0,character,1
+vctrs,new_partial_factor,-1,0,0,"class<`vctrs_partial`, `vctrs_partial_factor`, `vctrs_sclr`>",1
+vctrs,new_partial_factor,0,0,0,class<`factor`>,1
+vctrs,new_partial_factor,1,0,0,class<`factor`>,1
+vctrs,new_partial_frame,-1,0,0,"class<`vctrs_partial`, `vctrs_partial_frame`, `vctrs_sclr`>",1
+vctrs,new_partial_frame,0,0,0,class<`data.frame`>,1
+vctrs,new_partial_frame,1,0,0,class<`data.frame`>,1
+vctrs,new_rcrd,-1,0,0,"class<`vctrs_rcrd`, `vctrs_vctr`>",1
+vctrs,new_rcrd,0,0,0,list<integer[] | character[]>,1
+vctrs,new_rcrd,1,0,0,...,1
+vctrs,new_rcrd,2,0,0,character[],1
+vctrs,new_sclr,-1,0,0,"class<`vctrs_partial`, `vctrs_partial_factor`, `vctrs_sclr`>",1
+vctrs,new_sclr,-1,0,1,"class<`vctrs_partial`, `vctrs_partial_frame`, `vctrs_sclr`>",1
+vctrs,new_sclr,0,0,0,...,1
+vctrs,new_sclr,1,0,0,character[],1
+vctrs,new_vctr,-1,0,0,"class<`vctrs_list_of`, `vctrs_vctr`>",1
+vctrs,new_vctr,-1,0,1,class<`vctrs_vctr`>,1
+vctrs,new_vctr,0,0,0,list<any>,1
+vctrs,new_vctr,0,0,1,double[],1
+vctrs,new_vctr,1,0,0,...,1
+vctrs,new_vctr,2,0,0,character[],1
+vctrs,new_vctr,3,0,0,logical,1
+vctrs,n_fields,-1,0,0,integer,1
+vctrs,n_fields,0,0,0,"class<`vctrs_rcrd`, `vctrs_vctr`>",1
+vctrs,on_package_load,-1,0,0,null,1
+vctrs,on_package_load,0,0,0,character,1
+vctrs,on_package_load,1,0,0,any,1
+vctrs,order_proxy,-1,0,0,integer[],1
+vctrs,order_proxy,0,0,0,character[],1
+vctrs,order_proxy,0,0,1,class<`data.frame`>,1
+vctrs,order_proxy,0,0,2,^double[],1
+vctrs,order_proxy,1,0,0,character,1
+vctrs,order_proxy,2,0,0,character,1
+vctrs,parens,-1,0,0,character[],1
+vctrs,parens,0,0,0,character[],1
+vctrs,parens,1,0,0,logical,1
+vctrs,partial_factor,-1,0,0,"class<`vctrs_partial`, `vctrs_partial_factor`, `vctrs_sclr`>",1
+vctrs,partial_factor,0,0,0,character[],1
+vctrs,partial_frame,-1,0,0,"class<`vctrs_partial`, `vctrs_partial_frame`, `vctrs_sclr`>",1
+vctrs,partial_frame,0,0,0,...,1
+vctrs,paste_line,-1,0,0,character,1
+vctrs,paste_line,0,0,0,...,1
+vctrs,re_match,-1,0,0,class<`data.frame`>,1
+vctrs,re_match,0,0,0,character[],1
+vctrs,re_match,1,0,0,character,1
+vctrs,re_match,2,0,0,logical,1
+vctrs,re_match,3,0,0,...,1
+vctrs,reset_rownames,-1,0,0,class<`data.frame`>,1
+vctrs,reset_rownames,0,0,0,class<`data.frame`>,1
+vctrs,result,-1,0,0,class<`rlang_result`>,1
+vctrs,result,0,0,0,character[],1
+vctrs,result,0,0,1,integer,1
+vctrs,result,1,0,0,null,1
+vctrs,result_get,-1,0,0,character[],1
+vctrs,result_get,-1,0,1,integer,1
+vctrs,result_get,0,0,0,class<`rlang_result`>,1
+vctrs,s3_register,-1,0,0,null,1
+vctrs,s3_register,0,0,0,character,1
+vctrs,s3_register,1,0,0,character,1
+vctrs,s3_register,2,0,0,null,1
+vctrs,set_names_fallback,-1,0,0,class<`factor`>,1
+vctrs,set_names_fallback,0,0,0,class<`factor`>,1
+vctrs,set_names_fallback,1,0,0,null,1
+vctrs,shape_broadcast,-1,0,0,integer[],1
+vctrs,shape_broadcast,-1,0,1,list<integer[]>,1
+vctrs,shape_broadcast,0,0,0,integer[],1
+vctrs,shape_broadcast,0,0,1,list<integer[]>,1
+vctrs,shape_broadcast,1,0,0,integer[],1
+vctrs,shape_broadcast,1,0,1,list<any>,1
+vctrs,stop_incompatible,-1,0,0,any,1
+vctrs,stop_incompatible,0,0,0,character,1
+vctrs,stop_incompatible,0,0,1,double,1
+vctrs,stop_incompatible,1,0,0,double[],1
+vctrs,stop_incompatible,1,0,1,class<`factor`>,1
+vctrs,stop_incompatible,2,0,0,null,1
+vctrs,stop_incompatible,3,0,0,...,1
+vctrs,stop_incompatible,4,0,0,character,1
+vctrs,stop_incompatible,5,0,0,character,1
+vctrs,stop_incompatible_cast,-1,0,0,any,1
+vctrs,stop_incompatible_cast,0,0,0,double,1
+vctrs,stop_incompatible_cast,1,0,0,class<`factor`>,1
+vctrs,stop_incompatible_cast,2,0,0,null,1
+vctrs,stop_incompatible_cast,3,0,0,...,1
+vctrs,stop_incompatible_cast,4,0,0,character,1
+vctrs,stop_incompatible_cast,5,0,0,character,1
+vctrs,stop_incompatible_cast,6,0,0,null,1
+vctrs,stop_incompatible_cast,7,0,0,null,1
+vctrs,stop_incompatible_type,-1,0,0,any,1
+vctrs,stop_incompatible_type,0,0,0,character,1
+vctrs,stop_incompatible_type,1,0,0,double[],1
+vctrs,stop_incompatible_type,2,0,0,character,1
+vctrs,stop_incompatible_type,3,0,0,character,1
+vctrs,stop_incompatible_type,4,0,0,null,1
+vctrs,stop_incompatible_type,5,0,0,...,1
+vctrs,stop_incompatible_type,6,0,0,null,1
+vctrs,stop_incompatible_type,7,0,0,null,1
+vctrs,stop_lossy_cast,-1,0,0,any,1
+vctrs,stop_lossy_cast,0,0,0,double[],1
+vctrs,stop_lossy_cast,0,0,1,null,1
+vctrs,stop_lossy_cast,1,0,0,integer[],1
+vctrs,stop_lossy_cast,1,0,1,character,1
+vctrs,stop_lossy_cast,2,0,0,integer[],1
+vctrs,stop_lossy_cast,2,0,1,character[],1
+vctrs,stop_lossy_cast,3,0,0,integer,1
+vctrs,stop_lossy_cast,4,0,0,null,1
+vctrs,stop_lossy_cast,5,0,0,...,1
+vctrs,stop_lossy_cast,6,0,0,character,1
+vctrs,stop_lossy_cast,7,0,0,character,1
+vctrs,stop_lossy_cast,8,0,0,null,1
+vctrs,stop_lossy_cast,9,0,0,null,1
+vctrs,stop_vctrs,-1,0,0,any,1
+vctrs,stop_vctrs,0,0,0,character,1
+vctrs,stop_vctrs,0,0,1,null,1
+vctrs,stop_vctrs,1,0,0,character[],1
+vctrs,stop_vctrs,2,0,0,...,1
+vctrs,str_backtick,-1,0,0,character,1
+vctrs,str_backtick,0,0,0,character,1
+vctrs,str_dup,-1,0,0,character,1
+vctrs,str_dup,0,0,0,character,1
+vctrs,str_dup,1,0,0,double,1
+vctrs,strip_pos,-1,0,0,character[],1
+vctrs,strip_pos,0,0,0,character[],1
+vctrs,str_is_multiline,-1,0,0,logical,1
+vctrs,str_is_multiline,0,0,0,character,1
+vctrs,Summary.vctrs_vctr,-1,0,0,class<`vctrs_vctr`>,1
+vctrs,Summary.vctrs_vctr,0,0,0,...,1
+vctrs,Summary.vctrs_vctr,1,0,0,logical,1
+vctrs,tick,-1,0,0,character[],1
+vctrs,tick,-1,0,1,logical[],1
+vctrs,tick,0,0,0,character[],1
+vctrs,tick_if_needed,-1,0,0,character[],1
+vctrs,tick_if_needed,0,0,0,character[],1
+vctrs,two_to_three_dots,-1,0,0,character[],1
+vctrs,two_to_three_dots,0,0,0,character[],1
+vctrs,tzone,-1,0,0,character,1
+vctrs,tzone,0,0,0,"class<`POSIXct`, `POSIXt`>",1
+vctrs,tzone_is_local,-1,0,0,logical,1
+vctrs,tzone_is_local,0,0,0,"class<`POSIXct`, `POSIXt`>",1
+vctrs,units_union,-1,0,0,character,1
+vctrs,units_union,0,0,0,class<`difftime`>,1
+vctrs,units_union,1,0,0,class<`difftime`>,1
+vctrs,validate_names,-1,0,0,null,1
+vctrs,validate_names,0,0,0,double[],1
+vctrs,validate_names,0,0,1,list<any>,1
+vctrs,[[.vctrs_list_of,-1,0,0,double,1
+vctrs,[[.vctrs_list_of,-1,0,1,class<`data.frame`>,1
+vctrs,[[.vctrs_list_of,-1,0,2,class<`factor`>,1
+vctrs,[[.vctrs_list_of,0,0,0,"class<`vctrs_list_of`, `vctrs_vctr`>",1
+vctrs,[[.vctrs_list_of,0,0,1,"class<`vctrs_partial`, `vctrs_partial_frame`, `vctrs_sclr`>",1
+vctrs,[[.vctrs_list_of,0,0,2,"class<`vctrs_partial`, `vctrs_partial_factor`, `vctrs_sclr`>",1
+vctrs,[[.vctrs_list_of,1,0,0,integer,1
+vctrs,[[.vctrs_list_of,1,0,1,character,1
+vctrs,[[.vctrs_list_of,2,0,0,...,1
+vctrs,$.vctrs_sclr,-1,0,0,double,1
+vctrs,$.vctrs_sclr,-1,0,1,class<`data.frame`>,1
+vctrs,$.vctrs_sclr,-1,0,2,class<`factor`>,1
+vctrs,$.vctrs_sclr,0,0,0,"class<`vctrs_list_of`, `vctrs_vctr`>",1
+vctrs,$.vctrs_sclr,0,0,1,"class<`vctrs_partial`, `vctrs_partial_frame`, `vctrs_sclr`>",1
+vctrs,$.vctrs_sclr,0,0,2,"class<`vctrs_partial`, `vctrs_partial_factor`, `vctrs_sclr`>",1
+vctrs,$.vctrs_sclr,1,0,0,integer,1
+vctrs,$.vctrs_sclr,1,0,1,character,1
+vctrs,$.vctrs_sclr,2,0,0,...,1
+vctrs,vec_arith,-1,0,0,class<`difftime`>,1
+vctrs,vec_arith,-1,0,1,"class<`POSIXct`, `POSIXt`>",1
+vctrs,vec_arith,-1,0,2,double,1
+vctrs,vec_arith,0,0,0,character,1
+vctrs,vec_arith,1,0,0,"class<`POSIXct`, `POSIXt`>",1
+vctrs,vec_arith,1,0,1,class<`difftime`>,1
+vctrs,vec_arith,2,0,0,class<`Date`>,1
+vctrs,vec_arith,2,0,1,class<`difftime`>,1
+vctrs,vec_arith,2,0,2,double,1
+vctrs,vec_arith,3,0,0,...,1
+vctrs,vec_arith_base,-1,0,0,double,1
+vctrs,vec_arith_base,0,0,0,character,1
+vctrs,vec_arith_base,1,0,0,class<`difftime`>,1
+vctrs,vec_arith_base,1,0,1,"class<`POSIXct`, `POSIXt`>",1
+vctrs,vec_arith_base,2,0,0,class<`difftime`>,1
+vctrs,vec_arith_base,2,0,1,double,1
+vctrs,vec_arith.difftime,-1,0,0,class<`difftime`>,1
+vctrs,vec_arith.difftime,-1,0,1,double,1
+vctrs,vec_arith.difftime,0,0,0,character,1
+vctrs,vec_arith.difftime,1,0,0,class<`difftime`>,1
+vctrs,vec_arith.difftime,2,0,0,class<`difftime`>,1
+vctrs,vec_arith.difftime,2,0,1,double,1
+vctrs,vec_arith.difftime,3,0,0,...,1
+vctrs,vec_arith.difftime.difftime,-1,0,0,class<`difftime`>,1
+vctrs,vec_arith.difftime.difftime,-1,0,1,double,1
+vctrs,vec_arith.difftime.difftime,0,0,0,character,1
+vctrs,vec_arith.difftime.difftime,1,0,0,class<`difftime`>,1
+vctrs,vec_arith.difftime.difftime,2,0,0,class<`difftime`>,1
+vctrs,vec_arith.difftime.difftime,3,0,0,...,1
+vctrs,vec_arith.difftime.numeric,-1,0,0,class<`difftime`>,1
+vctrs,vec_arith.difftime.numeric,0,0,0,character,1
+vctrs,vec_arith.difftime.numeric,1,0,0,class<`difftime`>,1
+vctrs,vec_arith.difftime.numeric,2,0,0,double,1
+vctrs,vec_arith.difftime.numeric,3,0,0,...,1
+vctrs,vec_arith.POSIXct,-1,0,0,class<`difftime`>,1
+vctrs,vec_arith.POSIXct,-1,0,1,"class<`POSIXct`, `POSIXt`>",1
+vctrs,vec_arith.POSIXct,0,0,0,character,1
+vctrs,vec_arith.POSIXct,1,0,0,"class<`POSIXct`, `POSIXt`>",1
+vctrs,vec_arith.POSIXct,2,0,0,class<`Date`>,1
+vctrs,vec_arith.POSIXct,2,0,1,class<`difftime`>,1
+vctrs,vec_arith.POSIXct,2,0,2,double,1
+vctrs,vec_arith.POSIXct,3,0,0,...,1
+vctrs,vec_arith.POSIXct.Date,-1,0,0,class<`difftime`>,1
+vctrs,vec_arith.POSIXct.Date,0,0,0,character,1
+vctrs,vec_arith.POSIXct.Date,1,0,0,"class<`POSIXct`, `POSIXt`>",1
+vctrs,vec_arith.POSIXct.Date,2,0,0,class<`Date`>,1
+vctrs,vec_arith.POSIXct.Date,3,0,0,...,1
+vctrs,vec_arith.POSIXct.difftime,-1,0,0,"class<`POSIXct`, `POSIXt`>",1
+vctrs,vec_arith.POSIXct.difftime,0,0,0,character,1
+vctrs,vec_arith.POSIXct.difftime,1,0,0,"class<`POSIXct`, `POSIXt`>",1
+vctrs,vec_arith.POSIXct.difftime,2,0,0,class<`difftime`>,1
+vctrs,vec_arith.POSIXct.difftime,3,0,0,...,1
+vctrs,vec_arith.POSIXct.numeric,-1,0,0,"class<`POSIXct`, `POSIXt`>",1
+vctrs,vec_arith.POSIXct.numeric,0,0,0,character,1
+vctrs,vec_arith.POSIXct.numeric,1,0,0,"class<`POSIXct`, `POSIXt`>",1
+vctrs,vec_arith.POSIXct.numeric,2,0,0,double,1
+vctrs,vec_arith.POSIXct.numeric,3,0,0,...,1
+vctrs,vec_as_location,-1,0,0,integer[],1
+vctrs,vec_as_location,0,0,0,character[],1
+vctrs,vec_as_location,0,0,1,double,1
+vctrs,vec_as_location,1,0,0,integer,1
+vctrs,vec_as_location,2,0,0,character[],1
+vctrs,vec_as_location,2,0,1,null,1
+vctrs,vec_as_location,3,0,0,...,1
+vctrs,vec_as_location,4,0,0,character[],1
+vctrs,vec_as_location,5,0,0,null,1
+vctrs,vec_as_names,-1,0,0,character[],1
+vctrs,vec_as_names,0,0,0,^character[],1
+vctrs,vec_as_names,1,0,0,...,1
+vctrs,vec_as_names,2,0,0,character[],1
+vctrs,vec_as_names,3,0,0,logical,1
+vctrs,vec_assert,-1,0,0,any,1
+vctrs,vec_assert,0,0,0,character[],1
+vctrs,vec_assert,0,0,1,class<`data.frame`>,1
+vctrs,vec_assert,0,0,2,class<`difftime`>,1
+vctrs,vec_assert,0,0,3,class<`factor`>,1
+vctrs,vec_assert,0,0,4,"class<`POSIXct`, `POSIXt`>",1
+vctrs,vec_assert,0,0,5,class<`vctrs_vctr`>,1
+vctrs,vec_assert,0,0,6,^double[],1
+vctrs,vec_assert,1,0,0,null,1
+vctrs,vec_assert,1,0,1,"class<`vctrs_partial`, `vctrs_partial_factor`, `vctrs_sclr`>",1
+vctrs,vec_assert,1,0,2,class<`factor`>,1
+vctrs,vec_assert,1,0,3,logical[],1
+vctrs,vec_assert,2,0,0,null,1
+vctrs,vec_assert,2,0,1,integer,1
+vctrs,vec_assert,3,0,0,any,1
+vctrs,vec_assert_type_explain,-1,0,0,character,1
+vctrs,vec_assert_type_explain,0,0,0,class<`factor`>,1
+vctrs,vec_assert_type_explain,1,0,0,class<`factor`>,1
+vctrs,vec_assert_type_explain,1,0,1,"class<`vctrs_partial`, `vctrs_partial_factor`, `vctrs_sclr`>",1
+vctrs,vec_assert_type_explain,2,0,0,character,1
+vctrs,vec_assign,-1,0,0,any,1
+vctrs,vec_assign,0,0,0,double[],1
+vctrs,vec_assign,1,0,0,double,1
+vctrs,vec_assign,2,0,0,double,1
+vctrs,vec_assign,2,0,1,character,1
+vctrs,vec_as_subscript,-1,0,0,character[],1
+vctrs,vec_as_subscript,-1,0,1,integer,1
+vctrs,vec_as_subscript,0,0,0,character[],1
+vctrs,vec_as_subscript,0,0,1,double,1
+vctrs,vec_as_subscript,1,0,0,...,1
+vctrs,vec_as_subscript,2,0,0,character[],1
+vctrs,vec_as_subscript,3,0,0,character[],1
+vctrs,vec_as_subscript,4,0,0,character[],1
+vctrs,vec_as_subscript,5,0,0,any,1
+vctrs,vec_as_subscript_result,-1,0,0,class<`rlang_result`>,1
+vctrs,vec_as_subscript_result,0,0,0,character[],1
+vctrs,vec_as_subscript_result,0,0,1,double,1
+vctrs,vec_as_subscript_result,1,0,0,any,1
+vctrs,vec_as_subscript_result,2,0,0,character[],1
+vctrs,vec_as_subscript_result,3,0,0,character[],1
+vctrs,vec_as_subscript_result,4,0,0,character[],1
+vctrs,vec_c,-1,0,0,any,1
+vctrs,vec_c,0,0,0,...,1
+vctrs,vec_c,1,0,0,character[],1
+vctrs,vec_c,1,0,1,null,1
+vctrs,vec_c,2,0,0,null,1
+vctrs,vec_c,2,0,1,character,1
+vctrs,vec_c,2,0,2,class<`function`>,1
+vctrs,vec_c,2,0,3,class<`formula`>,1
+vctrs,vec_c,3,0,0,character[],1
+vctrs,vec_cast,-1,0,0,any,1
+vctrs,vec_cast,0,0,0,class<`difftime`>,1
+vctrs,vec_cast,0,0,1,double[],1
+vctrs,vec_cast,0,0,2,character,1
+vctrs,vec_cast,1,0,0,class<`difftime`>,1
+vctrs,vec_cast,1,0,1,integer[],1
+vctrs,vec_cast,1,0,2,class<`factor`>,1
+vctrs,vec_cast,2,0,0,...,1
+vctrs,vec_cast,3,0,0,character,1
+vctrs,vec_cast,4,0,0,character,1
+vctrs,vec_cast_common,-1,0,0,list<character[]>,1
+vctrs,vec_cast_common,-1,0,1,list<class<`data.frame`>>,1
+vctrs,vec_cast_common,-1,0,2,list<class<`difftime`>>,1
+vctrs,vec_cast_common,-1,0,3,list<class<`factor`>>,1
+vctrs,vec_cast_common,-1,0,4,list<double[]>,1
+vctrs,vec_cast_common,-1,0,5,list<^logical[]>,1
+vctrs,vec_cast_common,0,0,0,...,1
+vctrs,vec_cast_common,1,0,0,null,1
+vctrs,vec_cast.Date,-1,0,0,class<`Date`>,1
+vctrs,vec_cast.Date,0,0,0,class<`Date`>,1
+vctrs,vec_cast.Date,1,0,0,class<`Date`>,1
+vctrs,vec_cast.Date,2,0,0,...,1
+vctrs,vec_cast.Date.Date,-1,0,0,class<`Date`>,1
+vctrs,vec_cast.Date.Date,0,0,0,class<`Date`>,1
+vctrs,vec_cast.Date.Date,1,0,0,class<`Date`>,1
+vctrs,vec_cast.Date.Date,2,0,0,...,1
+vctrs,vec_cast.difftime,-1,0,0,class<`difftime`>,1
+vctrs,vec_cast.difftime,0,0,0,class<`difftime`>,1
+vctrs,vec_cast.difftime,1,0,0,class<`difftime`>,1
+vctrs,vec_cast.difftime,2,0,0,...,1
+vctrs,vec_cast.difftime.difftime,-1,0,0,class<`difftime`>,1
+vctrs,vec_cast.difftime.difftime,0,0,0,class<`difftime`>,1
+vctrs,vec_cast.difftime.difftime,1,0,0,class<`difftime`>,1
+vctrs,vec_cast.difftime.difftime,2,0,0,...,1
+vctrs,vec_cast_dispatch,-1,0,0,any,1
+vctrs,vec_cast_dispatch,0,0,0,class<`Date`>,1
+vctrs,vec_cast_dispatch,0,0,1,class<`difftime`>,1
+vctrs,vec_cast_dispatch,0,0,2,"class<`POSIXct`, `POSIXt`>",1
+vctrs,vec_cast_dispatch,0,0,3,"class<`vctrs_list_of`, `vctrs_vctr`>",1
+vctrs,vec_cast_dispatch,0,0,4,class<`vctrs_vctr`>,1
+vctrs,vec_cast_dispatch,0,0,5,double[],1
+vctrs,vec_cast_dispatch,0,0,6,character,1
+vctrs,vec_cast_dispatch,0,0,7,list<integer[]>,1
+vctrs,vec_cast_dispatch,1,0,0,class<`Date`>,1
+vctrs,vec_cast_dispatch,1,0,1,class<`difftime`>,1
+vctrs,vec_cast_dispatch,1,0,2,"class<`POSIXct`, `POSIXt`>",1
+vctrs,vec_cast_dispatch,1,0,3,"class<`vctrs_list_of`, `vctrs_vctr`>",1
+vctrs,vec_cast_dispatch,1,0,4,class<`vctrs_vctr`>,1
+vctrs,vec_cast_dispatch,1,0,5,integer[],1
+vctrs,vec_cast_dispatch,1,0,6,class<`factor`>,1
+vctrs,vec_cast_dispatch,1,0,7,list<any>,1
+vctrs,vec_cast_dispatch,2,0,0,...,1
+vctrs,vec_cast_dispatch,3,0,0,any,1
+vctrs,vec_cast_dispatch,4,0,0,any,1
+vctrs,vec_cast.factor,-1,0,0,any,1
+vctrs,vec_cast.factor,0,0,0,double,1
+vctrs,vec_cast.factor,1,0,0,class<`factor`>,1
+vctrs,vec_cast.factor,2,0,0,...,1
+vctrs,vec_cast.factor.default,-1,0,0,any,1
+vctrs,vec_cast.factor.default,0,0,0,double,1
+vctrs,vec_cast.factor.default,1,0,0,class<`factor`>,1
+vctrs,vec_cast.factor.default,2,0,0,...,1
+vctrs,vec_cast.factor.default,3,0,0,character,1
+vctrs,vec_cast.factor.default,4,0,0,character,1
+vctrs,vec_cast.integer,-1,0,0,any,1
+vctrs,vec_cast.integer,0,0,0,double[],1
+vctrs,vec_cast.integer,0,0,1,character,1
+vctrs,vec_cast.integer,1,0,0,integer[],1
+vctrs,vec_cast.integer,2,0,0,...,1
+vctrs,vec_cast.integer.character,-1,0,0,any,1
+vctrs,vec_cast.integer.character,0,0,0,character,1
+vctrs,vec_cast.integer.character,0,0,1,double[],1
+vctrs,vec_cast.integer.character,1,0,0,integer[],1
+vctrs,vec_cast.integer.character,2,0,0,...,1
+vctrs,vec_cast.integer.character,3,0,0,any,1
+vctrs,vec_cast.integer.character,4,0,0,any,1
+vctrs,vec_cast.integer.double,-1,0,0,any,1
+vctrs,vec_cast.integer.double,0,0,0,character,1
+vctrs,vec_cast.integer.double,0,0,1,double[],1
+vctrs,vec_cast.integer.double,1,0,0,integer[],1
+vctrs,vec_cast.integer.double,2,0,0,...,1
+vctrs,vec_cast.integer.double,3,0,0,any,1
+vctrs,vec_cast.integer.double,4,0,0,any,1
+vctrs,vec_cast.list,-1,0,0,list<integer[]>,1
+vctrs,vec_cast.list,0,0,0,list<integer[]>,1
+vctrs,vec_cast.list,1,0,0,list<any>,1
+vctrs,vec_cast.list,2,0,0,...,1
+vctrs,vec_cast.list.list,-1,0,0,list<integer[]>,1
+vctrs,vec_cast.list.list,0,0,0,list<integer[]>,1
+vctrs,vec_cast.list.list,1,0,0,list<any>,1
+vctrs,vec_cast.list.list,2,0,0,...,1
+vctrs,vec_cast.list.list,3,0,0,any,1
+vctrs,vec_cast.list.list,4,0,0,any,1
+vctrs,vec_cast.logical,-1,0,0,any,1
+vctrs,vec_cast.logical,0,0,0,double[],1
+vctrs,vec_cast.logical,1,0,0,logical[],1
+vctrs,vec_cast.logical,2,0,0,...,1
+vctrs,vec_cast.logical.double,-1,0,0,any,1
+vctrs,vec_cast.logical.double,0,0,0,double[],1
+vctrs,vec_cast.logical.double,1,0,0,logical[],1
+vctrs,vec_cast.logical.double,2,0,0,...,1
+vctrs,vec_cast.logical.double,3,0,0,character,1
+vctrs,vec_cast.logical.double,4,0,0,character,1
+vctrs,vec_cast.POSIXct,-1,0,0,"class<`POSIXct`, `POSIXt`>",1
+vctrs,vec_cast.POSIXct,0,0,0,class<`Date`>,1
+vctrs,vec_cast.POSIXct,0,0,1,"class<`POSIXct`, `POSIXt`>",1
+vctrs,vec_cast.POSIXct,1,0,0,"class<`POSIXct`, `POSIXt`>",1
+vctrs,vec_cast.POSIXct,2,0,0,...,1
+vctrs,vec_cast.POSIXct.Date,-1,0,0,"class<`POSIXct`, `POSIXt`>",1
+vctrs,vec_cast.POSIXct.Date,0,0,0,class<`Date`>,1
+vctrs,vec_cast.POSIXct.Date,1,0,0,"class<`POSIXct`, `POSIXt`>",1
+vctrs,vec_cast.POSIXct.Date,2,0,0,...,1
+vctrs,vec_cast.POSIXct.POSIXct,-1,0,0,"class<`POSIXct`, `POSIXt`>",1
+vctrs,vec_cast.POSIXct.POSIXct,0,0,0,"class<`POSIXct`, `POSIXt`>",1
+vctrs,vec_cast.POSIXct.POSIXct,1,0,0,"class<`POSIXct`, `POSIXt`>",1
+vctrs,vec_cast.POSIXct.POSIXct,2,0,0,...,1
+vctrs,vec_cast.vctrs_list_of,-1,0,0,"class<`vctrs_list_of`, `vctrs_vctr`>",1
+vctrs,vec_cast.vctrs_list_of,0,0,0,"class<`vctrs_list_of`, `vctrs_vctr`>",1
+vctrs,vec_cast.vctrs_list_of,1,0,0,"class<`vctrs_list_of`, `vctrs_vctr`>",1
+vctrs,vec_cast.vctrs_list_of,2,0,0,...,1
+vctrs,vec_cast.vctrs_list_of.vctrs_list_of,-1,0,0,"class<`vctrs_list_of`, `vctrs_vctr`>",1
+vctrs,vec_cast.vctrs_list_of.vctrs_list_of,0,0,0,"class<`vctrs_list_of`, `vctrs_vctr`>",1
+vctrs,vec_cast.vctrs_list_of.vctrs_list_of,1,0,0,"class<`vctrs_list_of`, `vctrs_vctr`>",1
+vctrs,vec_cast.vctrs_list_of.vctrs_list_of,2,0,0,...,1
+vctrs,vec_cast.vctrs_vctr,-1,0,0,class<`vctrs_vctr`>,1
+vctrs,vec_cast.vctrs_vctr,0,0,0,class<`vctrs_vctr`>,1
+vctrs,vec_cast.vctrs_vctr,1,0,0,class<`vctrs_vctr`>,1
+vctrs,vec_cast.vctrs_vctr,2,0,0,...,1
+vctrs,vec_cast.vctrs_vctr.default,-1,0,0,class<`vctrs_vctr`>,1
+vctrs,vec_cast.vctrs_vctr.default,0,0,0,class<`vctrs_vctr`>,1
+vctrs,vec_cast.vctrs_vctr.default,1,0,0,class<`vctrs_vctr`>,1
+vctrs,vec_cast.vctrs_vctr.default,2,0,0,...,1
+vctrs,vec_cbind,-1,0,0,class<`data.frame`>,1
+vctrs,vec_cbind,-1,0,1,"class<`data.frame`, `tbl`, `tbl_df`>",1
+vctrs,vec_cbind,0,0,0,...,1
+vctrs,vec_cbind,1,0,0,null,1
+vctrs,vec_cbind,2,0,0,null,1
+vctrs,vec_cbind,3,0,0,character[],1
+vctrs,vec_chop,-1,0,0,list<class<`data.frame`>>,1
+vctrs,vec_chop,-1,0,1,list<integer[]>,1
+vctrs,vec_chop,0,0,0,class<`data.frame`>,1
+vctrs,vec_chop,0,0,1,integer[],1
+vctrs,vec_chop,1,0,0,list<integer[]>,1
+vctrs,vec_chop,1,0,1,null,1
+vctrs,vec_chop,1,0,2,list<double | integer[]>,1
+vctrs,vec_coerce_bare,-1,0,0,integer[],1
+vctrs,vec_coerce_bare,0,0,0,double[],1
+vctrs,vec_coerce_bare,0,0,1,character,1
+vctrs,vec_coerce_bare,1,0,0,character,1
+vctrs,vec_coercible_cast,-1,0,0,integer,1
+vctrs,vec_coercible_cast,0,0,0,double,1
+vctrs,vec_coercible_cast,1,0,0,integer[],1
+vctrs,vec_coercible_cast,2,0,0,...,1
+vctrs,vec_coercible_cast,3,0,0,null,1
+vctrs,vec_coercible_cast,4,0,0,character,1
+vctrs,vec_compare,-1,0,0,^integer[],1
+vctrs,vec_compare,0,0,0,^logical[],1
+vctrs,vec_compare,0,0,1,character[],1
+vctrs,vec_compare,0,0,2,class<`data.frame`>,1
+vctrs,vec_compare,0,0,3,double[],1
+vctrs,vec_compare,1,0,0,character,1
+vctrs,vec_compare,1,0,1,class<`data.frame`>,1
+vctrs,vec_compare,1,0,2,double,1
+vctrs,vec_compare,2,0,0,logical,1
+vctrs,vec_compare,3,0,0,null,1
+vctrs,vec_count,-1,0,0,class<`data.frame`>,1
+vctrs,vec_count,0,0,0,character[],1
+vctrs,vec_count,0,0,1,class<`data.frame`>,1
+vctrs,vec_count,0,0,2,class<`factor`>,1
+vctrs,vec_count,0,0,3,double[],1
+vctrs,vec_count,1,0,0,character[],1
+vctrs,vec_data,-1,0,0,character[],1
+vctrs,vec_data,-1,0,1,^double[],1
+vctrs,vec_data,0,0,0,character[],1
+vctrs,vec_data,0,0,1,^double[],1
+vctrs,vec_data,0,0,2,class<`vctrs_vctr`>,1
+vctrs,vec_data,0,0,3,class<`difftime`>,1
+vctrs,vec_data,0,0,4,"class<`POSIXct`, `POSIXt`>",1
+vctrs,vec_default_cast,-1,0,0,any,1
+vctrs,vec_default_cast,0,0,0,double,1
+vctrs,vec_default_cast,1,0,0,class<`factor`>,1
+vctrs,vec_default_cast,2,0,0,character,1
+vctrs,vec_default_cast,3,0,0,character,1
+vctrs,vec_default_ptype2,-1,0,0,any,1
+vctrs,vec_default_ptype2,0,0,0,character,1
+vctrs,vec_default_ptype2,1,0,0,double[],1
+vctrs,vec_default_ptype2,2,0,0,...,1
+vctrs,vec_default_ptype2,3,0,0,character,1
+vctrs,vec_default_ptype2,4,0,0,character,1
+vctrs,vec_dim,-1,0,0,integer,1
+vctrs,vec_dim,0,0,0,integer[],1
+vctrs,vec_dim,0,0,1,list<any>,1
+vctrs,vec_dim_n,-1,0,0,integer,1
+vctrs,vec_dim_n,0,0,0,character[],1
+vctrs,vec_dim_n,0,0,1,^double[],1
+vctrs,vec_duplicate_any,-1,0,0,logical,1
+vctrs,vec_duplicate_any,0,0,0,double[],1
+vctrs,vec_duplicate_detect,-1,0,0,logical[],1
+vctrs,vec_duplicate_detect,0,0,0,character[],1
+vctrs,vec_duplicate_detect,0,0,1,double[],1
+vctrs,vec_duplicate_id,-1,0,0,integer[],1
+vctrs,vec_duplicate_id,0,0,0,double[],1
+vctrs,vec_equal,-1,0,0,^logical[],1
+vctrs,vec_equal,0,0,0,class<`data.frame`>,1
+vctrs,vec_equal,0,0,1,^logical[],1
+vctrs,vec_equal,0,0,2,character,1
+vctrs,vec_equal,0,0,3,double,1
+vctrs,vec_equal,1,0,0,class<`data.frame`>,1
+vctrs,vec_equal,1,0,1,character[],1
+vctrs,vec_equal,1,0,2,integer[],1
+vctrs,vec_equal,2,0,0,logical,1
+vctrs,vec_equal,3,0,0,null,1
+vctrs,vec_equal_na,-1,0,0,logical[],1
+vctrs,vec_equal_na,0,0,0,class<`data.frame`>,1
+vctrs,vec_equal_na,0,0,1,^logical[],1
+vctrs,vec_group_id,-1,0,0,integer[],1
+vctrs,vec_group_id,0,0,0,character[],1
+vctrs,vec_group_id,0,0,1,class<`data.frame`>,1
+vctrs,vec_group_loc,-1,0,0,class<`data.frame`>,1
+vctrs,vec_group_loc,0,0,0,class<`data.frame`>,1
+vctrs,vec_group_loc,0,0,1,double[],1
+vctrs,vec_group_rle,-1,0,0,"class<`vctrs_group_rle`, `vctrs_rcrd`, `vctrs_vctr`>",1
+vctrs,vec_group_rle,0,0,0,character[],1
+vctrs,vec_group_rle,0,0,1,class<`data.frame`>,1
+vctrs,vec_in,-1,0,0,logical[],1
+vctrs,vec_in,0,0,0,character[],1
+vctrs,vec_in,1,0,0,character[],1
+vctrs,vec_init,-1,0,0,class<`data.frame`>,1
+vctrs,vec_init,-1,0,1,class<`Date`>,1
+vctrs,vec_init,-1,0,2,^integer[],1
+vctrs,vec_init,0,0,0,class<`data.frame`>,1
+vctrs,vec_init,0,0,1,class<`Date`>,1
+vctrs,vec_init,0,0,2,integer[],1
+vctrs,vec_init,1,0,0,double,1
+vctrs,vec_init_along,-1,0,0,class<`data.frame`>,1
+vctrs,vec_init_along,0,0,0,class<`data.frame`>,1
+vctrs,vec_init_along,1,0,0,class<`data.frame`>,1
+vctrs,vec_is,-1,0,0,logical,1
+vctrs,vec_is,0,0,0,character[],1
+vctrs,vec_is,0,0,1,double,1
+vctrs,vec_is,0,0,2,integer[],1
+vctrs,vec_is,1,0,0,null,1
+vctrs,vec_is,1,0,1,integer[],1
+vctrs,vec_is,2,0,0,null,1
+vctrs,vec_is_empty,-1,0,0,logical,1
+vctrs,vec_is_empty,0,0,0,integer[],1
+vctrs,vec_is_list,-1,0,0,logical,1
+vctrs,vec_is_list,0,0,0,class<`data.frame`>,1
+vctrs,vec_is_list,0,0,1,"class<`vctrs_list_of`, `vctrs_vctr`>",1
+vctrs,vec_is_list,0,0,2,list<any>,1
+vctrs,vec_is_vector,-1,0,0,logical,1
+vctrs,vec_is_vector,0,0,0,character[],1
+vctrs,vec_is_vector,0,0,1,class<`data.frame`>,1
+vctrs,vec_is_vector,0,0,2,class<`difftime`>,1
+vctrs,vec_is_vector,0,0,3,class<`factor`>,1
+vctrs,vec_is_vector,0,0,4,"class<`POSIXct`, `POSIXt`>",1
+vctrs,vec_is_vector,0,0,5,class<`vctrs_vctr`>,1
+vctrs,vec_is_vector,0,0,6,^double[],1
+vctrs,vec_match,-1,0,0,^integer[],1
+vctrs,vec_match,0,0,0,character[],1
+vctrs,vec_match,0,0,1,class<`data.frame`>,1
+vctrs,vec_match,1,0,0,character[],1
+vctrs,vec_match,1,0,1,class<`data.frame`>,1
+vctrs,vec_math,-1,0,0,class<`vctrs_vctr`>,1
+vctrs,vec_math,0,0,0,character,1
+vctrs,vec_math,1,0,0,class<`vctrs_vctr`>,1
+vctrs,vec_math,2,0,0,...,1
+vctrs,vec_math_base,-1,0,0,double[],1
+vctrs,vec_math_base,0,0,0,character,1
+vctrs,vec_math_base,1,0,0,class<`vctrs_vctr`>,1
+vctrs,vec_math_base,2,0,0,...,1
+vctrs,vec_math.default,-1,0,0,class<`vctrs_vctr`>,1
+vctrs,vec_math.default,0,0,0,character,1
+vctrs,vec_math.default,1,0,0,class<`vctrs_vctr`>,1
+vctrs,vec_math.default,2,0,0,...,1
+vctrs,vec_order,-1,0,0,integer[],1
+vctrs,vec_order,0,0,0,character[],1
+vctrs,vec_order,0,0,1,class<`data.frame`>,1
+vctrs,vec_order,0,0,2,^double[],1
+vctrs,vec_order,1,0,0,character[],1
+vctrs,vec_order,2,0,0,character[],1
+vctrs,vec_proxy,-1,0,0,character[],1
+vctrs,vec_proxy,-1,0,1,class<`data.frame`>,1
+vctrs,vec_proxy,-1,0,2,class<`difftime`>,1
+vctrs,vec_proxy,-1,0,3,class<`factor`>,1
+vctrs,vec_proxy,-1,0,4,"class<`POSIXct`, `POSIXt`>",1
+vctrs,vec_proxy,-1,0,5,class<`vctrs_vctr`>,1
+vctrs,vec_proxy,-1,0,6,^double[],1
+vctrs,vec_proxy,0,0,0,character[],1
+vctrs,vec_proxy,0,0,1,class<`data.frame`>,1
+vctrs,vec_proxy,0,0,2,class<`difftime`>,1
+vctrs,vec_proxy,0,0,3,class<`factor`>,1
+vctrs,vec_proxy,0,0,4,"class<`POSIXct`, `POSIXt`>",1
+vctrs,vec_proxy,0,0,5,class<`vctrs_vctr`>,1
+vctrs,vec_proxy,0,0,6,^double[],1
+vctrs,vec_proxy,1,0,0,...,1
+vctrs,vec_proxy,-1,1,0,class<`Date`>,1
+vctrs,vec_proxy,0,1,0,class<`Date`>,1
+vctrs,vec_proxy,1,1,0,...,1
+vctrs,vec_proxy,-1,2,0,class<`vctrs_vctr`>,1
+vctrs,vec_proxy,0,2,0,class<`vctrs_vctr`>,1
+vctrs,vec_proxy,1,2,0,...,1
+vctrs,vec_proxy,-1,3,0,class<`data.frame`>,1
+vctrs,vec_proxy,0,3,0,"class<`vctrs_rcrd`, `vctrs_vctr`>",1
+vctrs,vec_proxy,1,3,0,...,1
+vctrs,vec_proxy,-1,4,0,"class<`POSIXct`, `POSIXt`>",1
+vctrs,vec_proxy,0,4,0,"class<`POSIXct`, `POSIXt`>",1
+vctrs,vec_proxy,1,4,0,...,1
+vctrs,vec_proxy,-1,5,0,list<any>,1
+vctrs,vec_proxy,0,5,0,"class<`vctrs_list_of`, `vctrs_vctr`>",1
+vctrs,vec_proxy,1,5,0,...,1
+vctrs,vec_proxy_compare,-1,0,0,^double[],1
+vctrs,vec_proxy_compare,-1,0,1,character[],1
+vctrs,vec_proxy_compare,-1,0,2,class<`data.frame`>,1
+vctrs,vec_proxy_compare,0,0,0,^double[],1
+vctrs,vec_proxy_compare,0,0,1,character[],1
+vctrs,vec_proxy_compare,0,0,2,class<`data.frame`>,1
+vctrs,vec_proxy_compare,1,0,0,...,1
+vctrs,vec_proxy_compare,2,0,0,logical,1
+vctrs,vec_proxy_compare.data.frame,-1,0,0,class<`data.frame`>,1
+vctrs,vec_proxy_compare.data.frame,0,0,0,class<`data.frame`>,1
+vctrs,vec_proxy_compare.data.frame,1,0,0,...,1
+vctrs,vec_proxy_compare.data.frame,2,0,0,logical,1
+vctrs,vec_proxy_compare_default,-1,0,0,character[],1
+vctrs,vec_proxy_compare_default,-1,0,1,^double[],1
+vctrs,vec_proxy_compare_default,0,0,0,character[],1
+vctrs,vec_proxy_compare_default,0,0,1,^double[],1
+vctrs,vec_proxy_compare_default,1,0,0,any,1
+vctrs,vec_proxy_compare.default,-1,0,0,character[],1
+vctrs,vec_proxy_compare.default,-1,0,1,^double[],1
+vctrs,vec_proxy_compare.default,0,0,0,character[],1
+vctrs,vec_proxy_compare.default,0,0,1,^double[],1
+vctrs,vec_proxy_compare.default,1,0,0,...,1
+vctrs,vec_proxy_compare.default,2,0,0,logical,1
+vctrs,vec_proxy_equal.default,-1,0,0,class<`factor`>,1
+vctrs,vec_proxy_equal.default,0,0,0,class<`factor`>,1
+vctrs,vec_proxy_equal.default,1,0,0,...,1
+vctrs,vec_proxy_equal_dispatch,-1,0,0,class<`factor`>,1
+vctrs,vec_proxy_equal_dispatch,0,0,0,class<`factor`>,1
+vctrs,vec_proxy_equal_dispatch,1,0,0,...,1
+vctrs,vec_ptype,-1,0,0,class<`factor`>,1
+vctrs,vec_ptype,-1,0,1,"class<`vctrs_partial`, `vctrs_partial_factor`, `vctrs_sclr`>",1
+vctrs,vec_ptype,-1,0,2,double[],1
+vctrs,vec_ptype,0,0,0,class<`factor`>,1
+vctrs,vec_ptype,0,0,1,"class<`vctrs_partial`, `vctrs_partial_factor`, `vctrs_sclr`>",1
+vctrs,vec_ptype,0,0,2,double[],1
+vctrs,vec_ptype2,-1,0,0,any,1
+vctrs,vec_ptype2,0,0,0,class<`data.frame`>,1
+vctrs,vec_ptype2,0,0,1,class<`factor`>,1
+vctrs,vec_ptype2,0,0,2,double[],1
+vctrs,vec_ptype2,0,0,3,character,1
+vctrs,vec_ptype2,1,0,0,class<`data.frame`>,1
+vctrs,vec_ptype2,1,0,1,class<`factor`>,1
+vctrs,vec_ptype2,1,0,2,integer[],1
+vctrs,vec_ptype2,2,0,0,...,1
+vctrs,vec_ptype2,3,0,0,character,1
+vctrs,vec_ptype2,4,0,0,character,1
+vctrs,vec_ptype2.character,-1,0,0,any,1
+vctrs,vec_ptype2.character,0,0,0,character,1
+vctrs,vec_ptype2.character,1,0,0,double[],1
+vctrs,vec_ptype2.character,2,0,0,...,1
+vctrs,vec_ptype2.character,3,0,0,character,1
+vctrs,vec_ptype2.character,4,0,0,character,1
+vctrs,vec_ptype2.character.default,-1,0,0,any,1
+vctrs,vec_ptype2.character.default,0,0,0,character,1
+vctrs,vec_ptype2.character.default,1,0,0,double[],1
+vctrs,vec_ptype2.character.default,2,0,0,...,1
+vctrs,vec_ptype2.character.default,3,0,0,character,1
+vctrs,vec_ptype2.character.default,4,0,0,character,1
+vctrs,vec_ptype2.difftime,-1,0,0,class<`difftime`>,1
+vctrs,vec_ptype2.difftime,0,0,0,class<`difftime`>,1
+vctrs,vec_ptype2.difftime,1,0,0,class<`difftime`>,1
+vctrs,vec_ptype2.difftime,2,0,0,...,1
+vctrs,vec_ptype2.difftime.difftime,-1,0,0,class<`difftime`>,1
+vctrs,vec_ptype2.difftime.difftime,0,0,0,class<`difftime`>,1
+vctrs,vec_ptype2.difftime.difftime,1,0,0,class<`difftime`>,1
+vctrs,vec_ptype2.difftime.difftime,2,0,0,...,1
+vctrs,vec_ptype2_dispatch_s3,-1,0,0,any,1
+vctrs,vec_ptype2_dispatch_s3,0,0,0,class<`difftime`>,1
+vctrs,vec_ptype2_dispatch_s3,0,0,1,"class<`vctrs_list_of`, `vctrs_vctr`>",1
+vctrs,vec_ptype2_dispatch_s3,0,0,2,class<`factor`>,1
+vctrs,vec_ptype2_dispatch_s3,0,0,3,"class<`vctrs_partial`, `vctrs_partial_factor`, `vctrs_sclr`>",1
+vctrs,vec_ptype2_dispatch_s3,0,0,4,"class<`vctrs_partial`, `vctrs_partial_frame`, `vctrs_sclr`>",1
+vctrs,vec_ptype2_dispatch_s3,0,0,5,character,1
+vctrs,vec_ptype2_dispatch_s3,1,0,0,class<`difftime`>,1
+vctrs,vec_ptype2_dispatch_s3,1,0,1,"class<`vctrs_list_of`, `vctrs_vctr`>",1
+vctrs,vec_ptype2_dispatch_s3,1,0,2,"class<`vctrs_partial`, `vctrs_partial_factor`, `vctrs_sclr`>",1
+vctrs,vec_ptype2_dispatch_s3,1,0,3,class<`factor`>,1
+vctrs,vec_ptype2_dispatch_s3,1,0,4,class<`data.frame`>,1
+vctrs,vec_ptype2_dispatch_s3,1,0,5,double[],1
+vctrs,vec_ptype2_dispatch_s3,2,0,0,...,1
+vctrs,vec_ptype2_dispatch_s3,3,0,0,any,1
+vctrs,vec_ptype2_dispatch_s3,4,0,0,any,1
+vctrs,vec_ptype2.factor,-1,0,0,"class<`vctrs_partial`, `vctrs_partial_factor`, `vctrs_sclr`>",1
+vctrs,vec_ptype2.factor,0,0,0,class<`factor`>,1
+vctrs,vec_ptype2.factor,1,0,0,"class<`vctrs_partial`, `vctrs_partial_factor`, `vctrs_sclr`>",1
+vctrs,vec_ptype2.factor,2,0,0,...,1
+vctrs,vec_ptype2.factor.vctrs_partial_factor,-1,0,0,"class<`vctrs_partial`, `vctrs_partial_factor`, `vctrs_sclr`>",1
+vctrs,vec_ptype2.factor.vctrs_partial_factor,0,0,0,class<`factor`>,1
+vctrs,vec_ptype2.factor.vctrs_partial_factor,1,0,0,"class<`vctrs_partial`, `vctrs_partial_factor`, `vctrs_sclr`>",1
+vctrs,vec_ptype2.factor.vctrs_partial_factor,2,0,0,...,1
+vctrs,vec_ptype2.vctrs_list_of,-1,0,0,"class<`vctrs_list_of`, `vctrs_vctr`>",1
+vctrs,vec_ptype2.vctrs_list_of,0,0,0,"class<`vctrs_list_of`, `vctrs_vctr`>",1
+vctrs,vec_ptype2.vctrs_list_of,1,0,0,"class<`vctrs_list_of`, `vctrs_vctr`>",1
+vctrs,vec_ptype2.vctrs_list_of,2,0,0,...,1
+vctrs,vec_ptype2.vctrs_list_of,3,0,0,any,1
+vctrs,vec_ptype2.vctrs_list_of,4,0,0,any,1
+vctrs,vec_ptype2.vctrs_list_of.vctrs_list_of,-1,0,0,"class<`vctrs_list_of`, `vctrs_vctr`>",1
+vctrs,vec_ptype2.vctrs_list_of.vctrs_list_of,0,0,0,"class<`vctrs_list_of`, `vctrs_vctr`>",1
+vctrs,vec_ptype2.vctrs_list_of.vctrs_list_of,1,0,0,"class<`vctrs_list_of`, `vctrs_vctr`>",1
+vctrs,vec_ptype2.vctrs_list_of.vctrs_list_of,2,0,0,...,1
+vctrs,vec_ptype2.vctrs_partial_factor,-1,0,0,"class<`vctrs_partial`, `vctrs_partial_factor`, `vctrs_sclr`>",1
+vctrs,vec_ptype2.vctrs_partial_factor,0,0,0,"class<`vctrs_partial`, `vctrs_partial_factor`, `vctrs_sclr`>",1
+vctrs,vec_ptype2.vctrs_partial_factor,1,0,0,class<`factor`>,1
+vctrs,vec_ptype2.vctrs_partial_factor,2,0,0,...,1
+vctrs,vec_ptype2.vctrs_partial_factor.factor,-1,0,0,"class<`vctrs_partial`, `vctrs_partial_factor`, `vctrs_sclr`>",1
+vctrs,vec_ptype2.vctrs_partial_factor.factor,0,0,0,"class<`vctrs_partial`, `vctrs_partial_factor`, `vctrs_sclr`>",1
+vctrs,vec_ptype2.vctrs_partial_factor.factor,1,0,0,class<`factor`>,1
+vctrs,vec_ptype2.vctrs_partial_factor.factor,2,0,0,...,1
+vctrs,vec_ptype2.vctrs_partial_frame,-1,0,0,"class<`vctrs_partial`, `vctrs_partial_frame`, `vctrs_sclr`>",1
+vctrs,vec_ptype2.vctrs_partial_frame,0,0,0,"class<`vctrs_partial`, `vctrs_partial_frame`, `vctrs_sclr`>",1
+vctrs,vec_ptype2.vctrs_partial_frame,1,0,0,class<`data.frame`>,1
+vctrs,vec_ptype2.vctrs_partial_frame,2,0,0,...,1
+vctrs,vec_ptype2.vctrs_partial_frame.data.frame,-1,0,0,"class<`vctrs_partial`, `vctrs_partial_frame`, `vctrs_sclr`>",1
+vctrs,vec_ptype2.vctrs_partial_frame.data.frame,0,0,0,"class<`vctrs_partial`, `vctrs_partial_frame`, `vctrs_sclr`>",1
+vctrs,vec_ptype2.vctrs_partial_frame.data.frame,1,0,0,class<`data.frame`>,1
+vctrs,vec_ptype2.vctrs_partial_frame.data.frame,2,0,0,...,1
+vctrs,vec_ptype_abbr,-1,0,0,character,1
+vctrs,vec_ptype_abbr,0,0,0,integer[],1
+vctrs,vec_ptype_abbr,1,0,0,...,1
+vctrs,vec_ptype_abbr.default,-1,0,0,character,1
+vctrs,vec_ptype_abbr.default,0,0,0,integer[],1
+vctrs,vec_ptype_abbr.default,1,0,0,...,1
+vctrs,vec_ptype_common,-1,0,0,class<`factor`>,1
+vctrs,vec_ptype_common,-1,0,1,double[],1
+vctrs,vec_ptype_common,0,0,0,...,1
+vctrs,vec_ptype_common,1,0,0,"class<`vctrs_partial`, `vctrs_partial_factor`, `vctrs_sclr`>",1
+vctrs,vec_ptype_common,1,0,1,null,1
+vctrs,vec_ptype_common,1,0,2,double[],1
+vctrs,vec_ptype_finalise,-1,0,0,class<`factor`>,1
+vctrs,vec_ptype_finalise,-1,0,1,integer[],1
+vctrs,vec_ptype_finalise,0,0,0,class<`factor`>,1
+vctrs,vec_ptype_finalise,0,0,1,integer[],1
+vctrs,vec_ptype_finalise,1,0,0,...,1
+vctrs,vec_ptype_finalise.default,-1,0,0,class<`Date`>,1
+vctrs,vec_ptype_finalise.default,-1,0,1,class<`difftime`>,1
+vctrs,vec_ptype_finalise.default,-1,0,2,class<`factor`>,1
+vctrs,vec_ptype_finalise.default,-1,0,3,"class<`POSIXct`, `POSIXt`>",1
+vctrs,vec_ptype_finalise.default,-1,0,4,"class<`vctrs_list_of`, `vctrs_vctr`>",1
+vctrs,vec_ptype_finalise.default,-1,0,5,class<`vctrs_vctr`>,1
+vctrs,vec_ptype_finalise.default,0,0,0,class<`Date`>,1
+vctrs,vec_ptype_finalise.default,0,0,1,class<`difftime`>,1
+vctrs,vec_ptype_finalise.default,0,0,2,class<`factor`>,1
+vctrs,vec_ptype_finalise.default,0,0,3,"class<`POSIXct`, `POSIXt`>",1
+vctrs,vec_ptype_finalise.default,0,0,4,"class<`vctrs_list_of`, `vctrs_vctr`>",1
+vctrs,vec_ptype_finalise.default,0,0,5,class<`vctrs_vctr`>,1
+vctrs,vec_ptype_finalise.default,1,0,0,...,1
+vctrs,vec_ptype_finalise_dispatch,-1,0,0,class<`data.frame`>,1
+vctrs,vec_ptype_finalise_dispatch,-1,0,1,class<`Date`>,1
+vctrs,vec_ptype_finalise_dispatch,-1,0,2,class<`difftime`>,1
+vctrs,vec_ptype_finalise_dispatch,-1,0,3,class<`factor`>,1
+vctrs,vec_ptype_finalise_dispatch,-1,0,4,"class<`POSIXct`, `POSIXt`>",1
+vctrs,vec_ptype_finalise_dispatch,-1,0,5,"class<`vctrs_list_of`, `vctrs_vctr`>",1
+vctrs,vec_ptype_finalise_dispatch,-1,0,6,class<`vctrs_vctr`>,1
+vctrs,vec_ptype_finalise_dispatch,0,0,0,"class<`vctrs_partial`, `vctrs_partial_frame`, `vctrs_sclr`>",1
+vctrs,vec_ptype_finalise_dispatch,0,0,1,class<`Date`>,1
+vctrs,vec_ptype_finalise_dispatch,0,0,2,class<`difftime`>,1
+vctrs,vec_ptype_finalise_dispatch,0,0,3,class<`factor`>,1
+vctrs,vec_ptype_finalise_dispatch,0,0,4,"class<`vctrs_partial`, `vctrs_partial_factor`, `vctrs_sclr`>",1
+vctrs,vec_ptype_finalise_dispatch,0,0,5,"class<`POSIXct`, `POSIXt`>",1
+vctrs,vec_ptype_finalise_dispatch,0,0,6,"class<`vctrs_list_of`, `vctrs_vctr`>",1
+vctrs,vec_ptype_finalise_dispatch,0,0,7,class<`vctrs_vctr`>,1
+vctrs,vec_ptype_finalise_dispatch,1,0,0,...,1
+vctrs,vec_ptype_finalise.vctrs_partial_factor,-1,0,0,class<`factor`>,1
+vctrs,vec_ptype_finalise.vctrs_partial_factor,0,0,0,"class<`vctrs_partial`, `vctrs_partial_factor`, `vctrs_sclr`>",1
+vctrs,vec_ptype_finalise.vctrs_partial_factor,1,0,0,...,1
+vctrs,vec_ptype_finalise.vctrs_partial_frame,-1,0,0,class<`data.frame`>,1
+vctrs,vec_ptype_finalise.vctrs_partial_frame,0,0,0,"class<`vctrs_partial`, `vctrs_partial_frame`, `vctrs_sclr`>",1
+vctrs,vec_ptype_finalise.vctrs_partial_frame,1,0,0,...,1
+vctrs,vec_ptype_full,-1,0,0,character,1
+vctrs,vec_ptype_full,0,0,0,class<`data.frame`>,1
+vctrs,vec_ptype_full,0,0,1,class<`factor`>,1
+vctrs,vec_ptype_full,0,0,2,double[],1
+vctrs,vec_ptype_full,0,0,3,character[],1
+vctrs,vec_ptype_full,0,0,4,class<`Date`>,1
+vctrs,vec_ptype_full,0,0,5,"class<`factor`, `ordered`>",1
+vctrs,vec_ptype_full,0,0,6,class<`matrix`>,1
+vctrs,vec_ptype_full,0,0,7,"class<`POSIXct`, `POSIXt`>",1
+vctrs,vec_ptype_full,0,0,8,"class<`vctrs_partial`, `vctrs_partial_factor`, `vctrs_sclr`>",1
+vctrs,vec_ptype_full,0,0,9,null,1
+vctrs,vec_ptype_full,1,0,0,...,1
+vctrs,vec_ptype_full.data.frame,-1,0,0,character,1
+vctrs,vec_ptype_full.data.frame,0,0,0,class<`data.frame`>,1
+vctrs,vec_ptype_full.data.frame,1,0,0,...,1
+vctrs,vec_ptype_full.Date,-1,0,0,character,1
+vctrs,vec_ptype_full.Date,0,0,0,class<`Date`>,1
+vctrs,vec_ptype_full.Date,1,0,0,...,1
+vctrs,vec_ptype_full.default,-1,0,0,character,1
+vctrs,vec_ptype_full.default,0,0,0,character[],1
+vctrs,vec_ptype_full.default,0,0,1,class<`matrix`>,1
+vctrs,vec_ptype_full.default,0,0,2,double[],1
+vctrs,vec_ptype_full.default,0,0,3,null,1
+vctrs,vec_ptype_full.default,1,0,0,...,1
+vctrs,vec_ptype_full.factor,-1,0,0,character,1
+vctrs,vec_ptype_full.factor,0,0,0,class<`factor`>,1
+vctrs,vec_ptype_full.factor,1,0,0,...,1
+vctrs,vec_ptype_full.NULL,-1,0,0,character,1
+vctrs,vec_ptype_full.NULL,0,0,0,null,1
+vctrs,vec_ptype_full.NULL,1,0,0,...,1
+vctrs,vec_ptype_full.ordered,-1,0,0,character,1
+vctrs,vec_ptype_full.ordered,0,0,0,"class<`factor`, `ordered`>",1
+vctrs,vec_ptype_full.ordered,1,0,0,...,1
+vctrs,vec_ptype_full.POSIXct,-1,0,0,character,1
+vctrs,vec_ptype_full.POSIXct,0,0,0,"class<`POSIXct`, `POSIXt`>",1
+vctrs,vec_ptype_full.POSIXct,1,0,0,...,1
+vctrs,vec_ptype_full.vctrs_partial_factor,-1,0,0,character,1
+vctrs,vec_ptype_full.vctrs_partial_factor,0,0,0,"class<`vctrs_partial`, `vctrs_partial_factor`, `vctrs_sclr`>",1
+vctrs,vec_ptype_full.vctrs_partial_factor,1,0,0,...,1
+vctrs,vec_ptype_shape,-1,0,0,character,1
+vctrs,vec_ptype_shape,0,0,0,character[],1
+vctrs,vec_ptype_shape,0,0,1,class<`matrix`>,1
+vctrs,vec_ptype_shape,0,0,2,double[],1
+vctrs,vec_ptype_shape,0,0,3,null,1
+vctrs,vec_ptype_show,-1,0,0,null,1
+vctrs,vec_ptype_show,0,0,0,...,1
+vctrs,vec_rbind,-1,0,0,class<`data.frame`>,1
+vctrs,vec_rbind,0,0,0,...,1
+vctrs,vec_rbind,1,0,0,"class<`vctrs_partial`, `vctrs_partial_frame`, `vctrs_sclr`>",1
+vctrs,vec_rbind,1,0,1,null,1
+vctrs,vec_rbind,2,0,0,null,1
+vctrs,vec_rbind,3,0,0,character[],1
+vctrs,vec_recycle,-1,0,0,integer,1
+vctrs,vec_recycle,0,0,0,integer,1
+vctrs,vec_recycle,1,0,0,integer,1
+vctrs,vec_recycle,2,0,0,...,1
+vctrs,vec_recycle,3,0,0,character,1
+vctrs,vec_recycle_common,-1,0,0,list<character[]>,1
+vctrs,vec_recycle_common,-1,0,1,list<class<`array`> | integer[]>,1
+vctrs,vec_recycle_common,-1,0,2,list<class<`data.frame`>>,1
+vctrs,vec_recycle_common,-1,0,3,list<class<`data.frame`> | integer[]>,1
+vctrs,vec_recycle_common,-1,0,4,list<class<`difftime`>>,1
+vctrs,vec_recycle_common,-1,0,5,list<class<`difftime`> | double>,1
+vctrs,vec_recycle_common,-1,0,6,list<class<`matrix`> | integer[]>,1
+vctrs,vec_recycle_common,-1,0,7,"list<class<`POSIXct`, `POSIXt`> | class<`difftime`>>",1
+vctrs,vec_recycle_common,-1,0,8,"list<class<`POSIXct`, `POSIXt`> | double>",1
+vctrs,vec_recycle_common,-1,0,9,list<double[]>,1
+vctrs,vec_recycle_common,-1,0,10,list<^logical[]>,1
+vctrs,vec_recycle_common,0,0,0,...,1
+vctrs,vec_recycle_common,1,0,0,null,1
+vctrs,vec_repeat,-1,0,0,class<`data.frame`>,1
+vctrs,vec_repeat,-1,0,1,integer[],1
+vctrs,vec_repeat,0,0,0,class<`data.frame`>,1
+vctrs,vec_repeat,0,0,1,integer[],1
+vctrs,vec_repeat,1,0,0,double,1
+vctrs,vec_repeat,2,0,0,double,1
+vctrs,vec_restore,-1,0,0,class<`difftime`>,1
+vctrs,vec_restore,-1,0,1,"class<`POSIXct`, `POSIXt`>",1
+vctrs,vec_restore,-1,0,2,class<`vctrs_vctr`>,1
+vctrs,vec_restore,0,0,0,double[],1
+vctrs,vec_restore,1,0,0,class<`difftime`>,1
+vctrs,vec_restore,1,0,1,"class<`POSIXct`, `POSIXt`>",1
+vctrs,vec_restore,1,0,2,class<`vctrs_vctr`>,1
+vctrs,vec_restore,2,0,0,...,1
+vctrs,vec_restore,3,0,0,null,1
+vctrs,vec_restore.default,-1,0,0,class<`Date`>,1
+vctrs,vec_restore.default,-1,0,1,class<`difftime`>,1
+vctrs,vec_restore.default,-1,0,2,class<`factor`>,1
+vctrs,vec_restore.default,-1,0,3,"class<`POSIXct`, `POSIXt`>",1
+vctrs,vec_restore.default,-1,0,4,"class<`vctrs_list_of`, `vctrs_vctr`>",1
+vctrs,vec_restore.default,-1,0,5,class<`vctrs_vctr`>,1
+vctrs,vec_restore.default,0,0,0,class<`Date`>,1
+vctrs,vec_restore.default,0,0,1,^double[],1
+vctrs,vec_restore.default,0,0,2,null,1
+vctrs,vec_restore.default,0,0,3,class<`factor`>,1
+vctrs,vec_restore.default,0,0,4,"class<`POSIXct`, `POSIXt`>",1
+vctrs,vec_restore.default,0,0,5,list<any>,1
+vctrs,vec_restore.default,0,0,6,class<`vctrs_vctr`>,1
+vctrs,vec_restore.default,1,0,0,class<`Date`>,1
+vctrs,vec_restore.default,1,0,1,class<`difftime`>,1
+vctrs,vec_restore.default,1,0,2,class<`factor`>,1
+vctrs,vec_restore.default,1,0,3,"class<`POSIXct`, `POSIXt`>",1
+vctrs,vec_restore.default,1,0,4,"class<`vctrs_list_of`, `vctrs_vctr`>",1
+vctrs,vec_restore.default,1,0,5,class<`vctrs_vctr`>,1
+vctrs,vec_restore.default,2,0,0,...,1
+vctrs,vec_restore.default,3,0,0,any,1
+vctrs,vec_restore_dispatch,-1,0,0,class<`Date`>,1
+vctrs,vec_restore_dispatch,-1,0,1,class<`difftime`>,1
+vctrs,vec_restore_dispatch,-1,0,2,class<`factor`>,1
+vctrs,vec_restore_dispatch,-1,0,3,"class<`POSIXct`, `POSIXt`>",1
+vctrs,vec_restore_dispatch,-1,0,4,"class<`vctrs_list_of`, `vctrs_vctr`>",1
+vctrs,vec_restore_dispatch,-1,0,5,class<`vctrs_vctr`>,1
+vctrs,vec_restore_dispatch,0,0,0,class<`Date`>,1
+vctrs,vec_restore_dispatch,0,0,1,^double[],1
+vctrs,vec_restore_dispatch,0,0,2,null,1
+vctrs,vec_restore_dispatch,0,0,3,class<`factor`>,1
+vctrs,vec_restore_dispatch,0,0,4,"class<`POSIXct`, `POSIXt`>",1
+vctrs,vec_restore_dispatch,0,0,5,list<any>,1
+vctrs,vec_restore_dispatch,0,0,6,class<`vctrs_vctr`>,1
+vctrs,vec_restore_dispatch,1,0,0,class<`Date`>,1
+vctrs,vec_restore_dispatch,1,0,1,class<`difftime`>,1
+vctrs,vec_restore_dispatch,1,0,2,class<`factor`>,1
+vctrs,vec_restore_dispatch,1,0,3,"class<`POSIXct`, `POSIXt`>",1
+vctrs,vec_restore_dispatch,1,0,4,"class<`vctrs_list_of`, `vctrs_vctr`>",1
+vctrs,vec_restore_dispatch,1,0,5,class<`vctrs_vctr`>,1
+vctrs,vec_restore_dispatch,2,0,0,...,1
+vctrs,vec_restore_dispatch,3,0,0,any,1
+vctrs,vec_restore.vctrs_vctr,-1,0,0,"class<`vctrs_list_of`, `vctrs_vctr`>",1
+vctrs,vec_restore.vctrs_vctr,-1,0,1,class<`vctrs_vctr`>,1
+vctrs,vec_restore.vctrs_vctr,0,0,0,list<any>,1
+vctrs,vec_restore.vctrs_vctr,0,0,1,class<`vctrs_vctr`>,1
+vctrs,vec_restore.vctrs_vctr,0,0,2,^double[],1
+vctrs,vec_restore.vctrs_vctr,1,0,0,"class<`vctrs_list_of`, `vctrs_vctr`>",1
+vctrs,vec_restore.vctrs_vctr,1,0,1,class<`vctrs_vctr`>,1
+vctrs,vec_restore.vctrs_vctr,2,0,0,...,1
+vctrs,vec_restore.vctrs_vctr,3,0,0,null,1
+vctrs,vec_seq_along,-1,0,0,integer[],1
+vctrs,vec_seq_along,0,0,0,class<`data.frame`>,1
+vctrs,vec_seq_along,0,0,1,integer[],1
+vctrs,vec_set_attributes,-1,0,0,character[],1
+vctrs,vec_set_attributes,-1,0,1,"class<`vctrs_list_of`, `vctrs_vctr`>",1
+vctrs,vec_set_attributes,-1,0,2,class<`vctrs_vctr`>,1
+vctrs,vec_set_attributes,-1,0,3,^double[],1
+vctrs,vec_set_attributes,-1,0,4,list<class<`factor`>>,1
+vctrs,vec_set_attributes,0,0,0,character[],1
+vctrs,vec_set_attributes,0,0,1,list<any>,1
+vctrs,vec_set_attributes,0,0,2,^double[],1
+vctrs,vec_set_attributes,0,0,3,class<`vctrs_vctr`>,1
+vctrs,vec_set_attributes,0,0,4,class<`difftime`>,1
+vctrs,vec_set_attributes,0,0,5,"class<`POSIXct`, `POSIXt`>",1
+vctrs,vec_set_attributes,0,0,6,"class<`vctrs_partial`, `vctrs_partial_factor`, `vctrs_sclr`>",1
+vctrs,vec_set_attributes,1,0,0,list<null>,1
+vctrs,vec_set_attributes,1,0,1,list<null | double[] | character[]>,1
+vctrs,vec_set_attributes,1,0,2,list<null | integer[] | character[]>,1
+vctrs,vec_set_attributes,1,0,3,list<null | logical[] | character[]>,1
+vctrs,vec_set_attributes,1,0,4,list<null | character>,1
+vctrs,vec_set_attributes,1,0,5,list<character[]>,1
+vctrs,vec_set_names,-1,0,0,character[],1
+vctrs,vec_set_names,-1,0,1,class<`factor`>,1
+vctrs,vec_set_names,-1,0,2,double[],1
+vctrs,vec_set_names,0,0,0,character[],1
+vctrs,vec_set_names,0,0,1,class<`factor`>,1
+vctrs,vec_set_names,0,0,2,double[],1
+vctrs,vec_set_names,1,0,0,null,1
+vctrs,vec_size,-1,0,0,integer,1
+vctrs,vec_size,0,0,0,class<`array`>,1
+vctrs,vec_size,0,0,1,class<`data.frame`>,1
+vctrs,vec_size,0,0,2,class<`matrix`>,1
+vctrs,vec_size,0,0,3,double[],1
+vctrs,vec_size_common,-1,0,0,integer,1
+vctrs,vec_size_common,0,0,0,...,1
+vctrs,vec_size_common,1,0,0,null,1
+vctrs,vec_size_common,2,0,0,integer,1
+vctrs,vec_slice,-1,0,0,character[],1
+vctrs,vec_slice,-1,0,1,class<`data.frame`>,1
+vctrs,vec_slice,-1,0,2,class<`factor`>,1
+vctrs,vec_slice,-1,0,3,^double[],1
+vctrs,vec_slice,0,0,0,character[],1
+vctrs,vec_slice,0,0,1,class<`data.frame`>,1
+vctrs,vec_slice,0,0,2,class<`factor`>,1
+vctrs,vec_slice,0,0,3,^double[],1
+vctrs,vec_slice,1,0,0,^integer[],1
+vctrs,vec_slice<-,-1,0,0,any,1
+vctrs,vec_slice<-,0,0,0,double[],1
+vctrs,vec_slice<-,1,0,0,double,1
+vctrs,vec_slice<-,2,0,0,double,1
+vctrs,vec_slice<-,2,0,1,character,1
+vctrs,vec_sort,-1,0,0,class<`data.frame`>,1
+vctrs,vec_sort,-1,0,1,^double[],1
+vctrs,vec_sort,0,0,0,class<`data.frame`>,1
+vctrs,vec_sort,0,0,1,^double[],1
+vctrs,vec_sort,1,0,0,character[],1
+vctrs,vec_sort,2,0,0,character[],1
+vctrs,vec_split,-1,0,0,class<`data.frame`>,1
+vctrs,vec_split,0,0,0,class<`data.frame`>,1
+vctrs,vec_split,0,0,1,double[],1
+vctrs,vec_split,1,0,0,class<`data.frame`>,1
+vctrs,vec_split,1,0,1,double[],1
+vctrs,vec_unique,-1,0,0,class<`data.frame`>,1
+vctrs,vec_unique,-1,0,1,^double[],1
+vctrs,vec_unique,0,0,0,class<`data.frame`>,1
+vctrs,vec_unique,0,0,1,^double[],1
+vctrs,vec_unique_count,-1,0,0,integer,1
+vctrs,vec_unique_count,0,0,0,integer[],1
+vctrs,vec_unique_loc,-1,0,0,integer[],1
+vctrs,vec_unique_loc,0,0,0,class<`data.frame`>,1
+vctrs,vec_unique_loc,0,0,1,^double[],1
+viridisLite,viridis,-1,0,0,character[],1
+viridisLite,viridis,0,0,0,double,1
+viridisLite,viridis,1,0,0,double,1
+viridisLite,viridis,2,0,0,double,1
+viridisLite,viridis,3,0,0,double,1
+viridisLite,viridis,4,0,0,double,1
+viridisLite,viridis,5,0,0,character,1
+wesanderson,wes_palette,-1,0,0,class<`palette`>,1
+wesanderson,wes_palette,0,0,0,character,1
+wesanderson,wes_palette,1,0,0,any,1
+wesanderson,wes_palette,2,0,0,character[],1
+withr,add_handler,-1,0,0,list<class<`call`> | environment>,1
+withr,add_handler,0,0,0,environment,1
+withr,add_handler,1,0,0,list<class<`call`> | environment>,1
+withr,add_handler,2,0,0,logical,1
+withr,defer,-1,0,0,list<class<`call`> | environment>,1
+withr,defer,0,0,0,any,1
+withr,defer,1,0,0,environment,1
+withr,defer,2,0,0,character[],1
+withr,defer_parent,-1,0,0,list<class<`call`> | environment>,1
+withr,defer_parent,0,0,0,any,1
+withr,defer_parent,1,0,0,character[],1
+withr,get_handlers,-1,0,0,list<list<class<`call`> | environment>>,1
+withr,get_handlers,-1,0,1,null,1
+withr,get_handlers,0,0,0,environment,1
+withr,get_seed,-1,0,0,integer[],1
+withr,get_seed,-1,0,1,null,1
+withr,is.named,-1,0,0,logical,1
+withr,is.named,0,0,0,character,1
+withr,is.named,0,0,1,double,1
+withr,is.named,0,0,2,null,1
+withr,is.named,0,0,3,"list<class<`connection`, `file`>>",1
+withr,is.named,0,0,4,list<class<`SQLiteConnection`>>,1
+withr,local_connection,-1,0,0,"class<`connection`, `file`>",1
+withr,local_connection,0,0,0,"class<`connection`, `file`>",1
+withr,local_connection,1,0,0,environment,1
+withr,local_db_connection,-1,0,0,class<`SQLiteConnection`>,1
+withr,local_db_connection,0,0,0,class<`SQLiteConnection`>,1
+withr,local_db_connection,1,0,0,environment,1
+withr,make_call,-1,0,0,class<`call`>,1
+withr,make_call,0,0,0,...,1
+withr,names2,-1,0,0,character,1
+withr,names2,0,0,0,character,1
+withr,names2,0,0,1,list<null>,1
+withr,pdf_dev,-1,0,0,integer,1
+withr,pdf_dev,0,0,0,character,1
+withr,pdf_dev,1,0,0,double,1
+withr,pdf_dev,2,0,0,double,1
+withr,pdf_dev,3,0,0,any,1
+withr,pdf_dev,4,0,0,any,1
+withr,pdf_dev,5,0,0,any,1
+withr,pdf_dev,6,0,0,any,1
+withr,pdf_dev,7,0,0,any,1
+withr,png_dev,-1,0,0,integer,1
+withr,png_dev,0,0,0,character,1
+withr,png_dev,1,0,0,...,1
+withr,set_envvar,-1,0,0,character,1
+withr,set_envvar,-1,0,1,null,1
+withr,set_envvar,0,0,0,character,1
+withr,set_envvar,0,0,1,double,1
+withr,set_envvar,0,0,2,null,1
+withr,set_envvar,1,0,0,character,1
+withr,set_handlers,-1,0,0,null,1
+withr,set_handlers,0,0,0,environment,1
+withr,set_handlers,1,0,0,list<list<class<`call`> | environment>>,1
+withr,vlapply,-1,0,0,logical,1
+withr,vlapply,0,0,0,list<class<`SQLiteConnection`>>,1
+withr,vlapply,1,0,0,class<`function`>,1
+withr,vlapply,2,0,0,...,1
+withr,vlapply,3,0,0,logical,1
+withr,with_,-1,0,0,class<`function`>,1
+withr,with_,0,0,0,class<`function`>,1
+withr,with_,1,0,0,any,1
+withr,with_,2,0,0,environment,1
+withr,with_,3,0,0,logical,1
+withr,with_connection,-1,0,0,null,1
+withr,with_connection,0,0,0,"list<class<`connection`, `file`>>",1
+withr,with_connection,1,0,0,any,1
+withr,with_db_connection,-1,0,0,logical,1
+withr,with_db_connection,0,0,0,list<class<`SQLiteConnection`>>,1
+withr,with_db_connection,1,0,0,logical,1
+withr,with_dir,-1,0,0,character,1
+withr,with_dir,0,0,0,character,1
+withr,with_dir,1,0,0,character,1
+withr,with_envvar,-1,0,0,character,1
+withr,with_envvar,0,0,0,double,1
+withr,with_envvar,1,0,0,character,1
+withr,with_envvar,2,0,0,character,1
+withr,with_file,-1,0,0,character,1
+withr,with_file,-1,0,1,list<null>,1
+withr,with_file,0,0,0,character,1
+withr,with_file,0,0,1,list<null>,1
+withr,with_file,1,0,0,character,1
+withr,with_pdf,-1,0,0,null,1
+withr,with_pdf,0,0,0,character,1
+withr,with_pdf,1,0,0,null,1
+withr,with_pdf,2,0,0,double,1
+withr,with_pdf,3,0,0,double,1
+withr,with_pdf,4,0,0,any,1
+withr,with_pdf,5,0,0,any,1
+withr,with_pdf,6,0,0,any,1
+withr,with_pdf,7,0,0,any,1
+withr,with_png,-1,0,0,null,1
+withr,with_png,0,0,0,character,1
+withr,with_png,1,0,0,null,1
+withr,with_png,2,0,0,...,1
+withr,with_preserve_seed,-1,0,0,double[],1
+withr,with_preserve_seed,0,0,0,double[],1
+withr,with_seed,-1,0,0,double[],1
+withr,with_seed,0,0,0,integer,1
+withr,with_seed,1,0,0,double[],1
+wmtsa,as.matrix.wavCWT,-1,0,0,class<`matrix`>,1
+wmtsa,as.matrix.wavCWT,0,0,0,class<`wavCWT`>,1
+wmtsa,as.matrix.wavCWT,1,0,0,character,1
+wmtsa,as.matrix.wavCWT,2,0,0,logical,1
+wmtsa,as.matrix.wavCWT,3,0,0,...,1
+wmtsa,as.matrix.wavMRD,-1,0,0,class<`matrix`>,1
+wmtsa,as.matrix.wavMRD,0,0,0,class<`wavMRD`>,1
+wmtsa,as.matrix.wavMRD,1,0,0,character,1
+wmtsa,as.matrix.wavMRD,2,0,0,logical,1
+wmtsa,as.matrix.wavMRD,3,0,0,...,1
+wmtsa,boxplot.wavTransform,-1,0,0,null,1
+wmtsa,boxplot.wavTransform,0,0,0,class<`wavTransform`>,1
+wmtsa,boxplot.wavTransform,1,0,0,character,1
+wmtsa,boxplot.wavTransform,2,0,0,character,1
+wmtsa,boxplot.wavTransform,3,0,0,...,1
+wmtsa,create.signalSeries,-1,0,0,class<`signalSeries`>,1
+wmtsa,create.signalSeries,0,0,0,class<`signalSeries`>,1
+wmtsa,create.signalSeries,0,0,1,class<`ts`>,1
+wmtsa,create.signalSeries,0,0,2,double[],1
+wmtsa,create.signalSeries,0,0,3,null,1
+wmtsa,create.signalSeries,1,0,0,any,1
+wmtsa,create.signalSeries,2,0,0,null,1
+wmtsa,create.signalSeries,2,0,1,double,1
+wmtsa,create.signalSeries,3,0,0,null,1
+wmtsa,create.signalSeries,3,0,1,double,1
+wmtsa,create.signalSeries,4,0,0,null,1
+wmtsa,create.signalSeries,5,0,0,null,1
+wmtsa,create.signalSeries,5,0,1,double,1
+wmtsa,crystal.names,-1,0,0,character[],1
+wmtsa,crystal.names,0,0,0,class<`wavMRD`>,1
+wmtsa,crystal.names,1,0,0,...,1
+wmtsa,crystal.names.wavMRD,-1,0,0,character[],1
+wmtsa,crystal.names.wavMRD,0,0,0,class<`wavMRD`>,1
+wmtsa,crystal.names.wavMRD,1,0,0,...,1
+wmtsa,D.statistic,-1,0,0,double,1
+wmtsa,D.statistic,0,0,0,double[],1
+wmtsa,D.table,-1,0,0,class<`matrix`>,1
+wmtsa,D.table,0,0,0,integer[],1
+wmtsa,D.table,1,0,0,double[],1
+wmtsa,D.table,2,0,0,logical,1
+wmtsa,D.table,3,0,0,any,1
+wmtsa,D.table,4,0,0,any,1
+wmtsa,D.table,5,0,0,any,1
+wmtsa,eda.plot,-1,0,0,null,1
+wmtsa,eda.plot,0,0,0,class<`wavTransform`>,1
+wmtsa,eda.plot,1,0,0,...,1
+wmtsa,eda.plot.wavTransform,-1,0,0,null,1
+wmtsa,eda.plot.wavTransform,0,0,0,class<`wavTransform`>,1
+wmtsa,eda.plot.wavTransform,1,0,0,logical,1
+wmtsa,eda.plot.wavTransform,2,0,0,null,1
+wmtsa,eda.plot.wavTransform,3,0,0,double,1
+wmtsa,eda.plot.wavTransform,4,0,0,double,1
+wmtsa,eda.plot.wavTransform,5,0,0,null,1
+wmtsa,holderSpectrum,-1,0,0,list<double[]>,1
+wmtsa,holderSpectrum,0,0,0,class<`wavCWTTree`>,1
+wmtsa,holderSpectrum,1,0,0,double,1
+wmtsa,holderSpectrum,2,0,0,class<`function`>,1
+wmtsa,make.signal,-1,0,0,class<`signalSeries`>,1
+wmtsa,make.signal,0,0,0,character,1
+wmtsa,make.signal,1,0,0,double,1
+wmtsa,make.signal,2,0,0,double,1
+wmtsa,oceansdf,-1,0,0,double[],1
+wmtsa,oceansdf,0,0,0,double[],1
+wmtsa,plot.wavBoundary,-1,0,0,double[],1
+wmtsa,plot.wavBoundary,0,0,0,class<`wavBoundary`>,1
+wmtsa,plot.wavBoundary,1,0,0,logical,1
+wmtsa,plot.wavBoundary,2,0,0,logical,1
+wmtsa,plot.wavBoundary,3,0,0,character,1
+wmtsa,plot.wavBoundary,4,0,0,logical,1
+wmtsa,plot.wavBoundary,5,0,0,null,1
+wmtsa,plot.wavCWT,-1,0,0,null,1
+wmtsa,plot.wavCWT,0,0,0,class<`wavCWT`>,1
+wmtsa,plot.wavCWT,1,0,0,null,1
+wmtsa,plot.wavCWT,2,0,0,null,1
+wmtsa,plot.wavCWT,3,0,0,character,1
+wmtsa,plot.wavCWT,4,0,0,double,1
+wmtsa,plot.wavCWT,5,0,0,logical,1
+wmtsa,plot.wavCWTTree,-1,0,0,null,1
+wmtsa,plot.wavCWTTree,0,0,0,class<`wavCWTTree`>,1
+wmtsa,plot.wavCWTTree,1,0,0,logical,1
+wmtsa,plot.wavCWTTree,2,0,0,character,1
+wmtsa,plot.wavCWTTree,3,0,0,logical,1
+wmtsa,plot.wavCWTTree,4,0,0,character,1
+wmtsa,plot.wavCWTTree,5,0,0,character,1
+wmtsa,plot.wavCWTTree,5,0,1,null,1
+wmtsa,plot.wavDaubechies,-1,0,0,null,1
+wmtsa,plot.wavDaubechies,0,0,0,class<`wavDaubechies`>,1
+wmtsa,plot.wavDaubechies,1,0,0,character,1
+wmtsa,plot.wavDaubechies,2,0,0,...,1
+wmtsa,plot.wavFDP,-1,0,0,null,1
+wmtsa,plot.wavFDP,0,0,0,class<`wavFDP`>,1
+wmtsa,plot.wavFDP,1,0,0,double,1
+wmtsa,plot.wavFDP,1,0,1,null,1
+wmtsa,plot.wavFDP,2,0,0,character,1
+wmtsa,plot.wavFDP,3,0,0,character,1
+wmtsa,plot.wavFDP,4,0,0,null,1
+wmtsa,plot.wavFDP,5,0,0,character,1
+wmtsa,plot.wavGain,-1,0,0,null,1
+wmtsa,plot.wavGain,0,0,0,class<`wavGain`>,1
+wmtsa,plot.wavGain,1,0,0,double,1
+wmtsa,plot.wavGain,2,0,0,double,1
+wmtsa,plot.wavGain,3,0,0,...,1
+wmtsa,plot.wavMRD,-1,0,0,double[],1
+wmtsa,plot.wavMRD,0,0,0,class<`wavMRD`>,1
+wmtsa,plot.wavMRD,1,0,0,double,1
+wmtsa,plot.wavMRD,2,0,0,double,1
+wmtsa,plot.wavMRD,3,0,0,double,1
+wmtsa,plot.wavMRD,4,0,0,null,1
+wmtsa,plot.wavMRD,5,0,0,logical,1
+wmtsa,plot.wavTransform,-1,0,0,null,1
+wmtsa,plot.wavTransform,0,0,0,class<`wavTransform`>,1
+wmtsa,plot.wavTransform,1,0,0,character,1
+wmtsa,plot.wavTransform,2,0,0,logical,1
+wmtsa,plot.wavTransform,3,0,0,logical,1
+wmtsa,plot.wavTransform,4,0,0,logical,1
+wmtsa,plot.wavTransform,5,0,0,double,1
+wmtsa,plot.wavVar,-1,0,0,null,1
+wmtsa,plot.wavVar,0,0,0,class<`wavVar`>,1
+wmtsa,plot.wavVar,1,0,0,character,1
+wmtsa,plot.wavVar,2,0,0,logical,1
+wmtsa,plot.wavVar,3,0,0,null,1
+wmtsa,plot.wavVar,4,0,0,character,1
+wmtsa,plot.wavVar,5,0,0,null,1
+wmtsa,print.wavCWT,-1,0,0,class<`wavCWT`>,1
+wmtsa,print.wavCWT,0,0,0,class<`wavCWT`>,1
+wmtsa,print.wavCWT,1,0,0,character,1
+wmtsa,print.wavCWT,2,0,0,character,1
+wmtsa,print.wavCWT,3,0,0,...,1
+wmtsa,print.wavCWTTree,-1,0,0,class<`wavCWTTree`>,1
+wmtsa,print.wavCWTTree,0,0,0,class<`wavCWTTree`>,1
+wmtsa,print.wavCWTTree,1,0,0,character,1
+wmtsa,print.wavCWTTree,2,0,0,character,1
+wmtsa,print.wavCWTTree,3,0,0,...,1
+wmtsa,print.wavFDP,-1,0,0,null,1
+wmtsa,print.wavFDP,0,0,0,class<`wavFDP`>,1
+wmtsa,print.wavFDP,1,0,0,double,1
+wmtsa,print.wavFDP,2,0,0,character,1
+wmtsa,print.wavFDP,3,0,0,character,1
+wmtsa,print.wavFDP,4,0,0,...,1
+wmtsa,reconstruct,-1,0,0,double[],1
+wmtsa,reconstruct,0,0,0,class<`wavTransform`>,1
+wmtsa,reconstruct,1,0,0,...,1
+wmtsa,reconstruct.wavTransform,-1,0,0,double[],1
+wmtsa,reconstruct.wavTransform,0,0,0,class<`wavTransform`>,1
+wmtsa,reconstruct.wavTransform,1,0,0,double,1
+wmtsa,reconstruct.wavTransform,2,0,0,...,1
+wmtsa,summary.wavBoundary,-1,0,0,class<`summary.wavBoundary`>,1
+wmtsa,summary.wavBoundary,0,0,0,class<`wavBoundary`>,1
+wmtsa,summary.wavBoundary,1,0,0,...,1
+wmtsa,summary.wavCWTTree,-1,0,0,"class<`data.frame`, `summary.wavCWTTree`>",1
+wmtsa,summary.wavCWTTree,0,0,0,class<`wavCWTTree`>,1
+wmtsa,summary.wavCWTTree,1,0,0,...,1
+wmtsa,summary.wavTransform,-1,0,0,class<`summary.wavTransform`>,1
+wmtsa,summary.wavTransform,0,0,0,class<`wavTransform`>,1
+wmtsa,summary.wavTransform,1,0,0,...,1
+wmtsa,wavBestBasis,-1,0,0,list<double[] | list<double[]>>,1
+wmtsa,wavBestBasis,0,0,0,double[],1
+wmtsa,wavBootstrap,-1,0,0,double[],1
+wmtsa,wavBootstrap,0,0,0,double[],1
+wmtsa,wavBootstrap,1,0,0,class<`matrix`>,1
+wmtsa,wavBootstrap,2,0,0,double,1
+wmtsa,wavBootstrap,3,0,0,character,1
+wmtsa,wavBootstrap,4,0,0,null,1
+wmtsa,wavBoundary,-1,0,0,class<`wavBoundary`>,1
+wmtsa,wavBoundary,0,0,0,class<`wavTransform`>,1
+wmtsa,wavCWT,-1,0,0,class<`wavCWT`>,1
+wmtsa,wavCWT,0,0,0,class<`signalSeries`>,1
+wmtsa,wavCWT,0,0,1,class<`ts`>,1
+wmtsa,wavCWT,1,0,0,double[],1
+wmtsa,wavCWT,2,0,0,double,1
+wmtsa,wavCWT,3,0,0,character,1
+wmtsa,wavCWT,4,0,0,double,1
+wmtsa,wavCWT,5,0,0,double,1
+wmtsa,wavCWTFilters,-1,0,0,complex[],1
+wmtsa,wavCWTFilters,0,0,0,character,1
+wmtsa,wavCWTFilters,1,0,0,double[],1
+wmtsa,wavCWTFilters,2,0,0,double,1
+wmtsa,wavCWTFilters,3,0,0,double,1
+wmtsa,wavCWTFilters,4,0,0,null,1
+wmtsa,wavCWTPeaks,-1,0,0,list<double[]>,1
+wmtsa,wavCWTPeaks,0,0,0,class<`wavCWTTree`>,1
+wmtsa,wavCWTPeaks,1,0,0,double,1
+wmtsa,wavCWTPeaks,2,0,0,null,1
+wmtsa,wavCWTPeaks,3,0,0,double,1
+wmtsa,wavCWTPeaks,4,0,0,null,1
+wmtsa,wavCWTPeaks,5,0,0,character,1
+wmtsa,wavCWTTree,-1,0,0,class<`wavCWTTree`>,1
+wmtsa,wavCWTTree,0,0,0,class<`wavCWT`>,1
+wmtsa,wavCWTTree,1,0,0,double,1
+wmtsa,wavCWTTree,2,0,0,double,1
+wmtsa,wavCWTTree,3,0,0,character,1
+wmtsa,[.wavCWTTree,-1,0,0,class<`wavCWTTree`>,1
+wmtsa,[.wavCWTTree,0,0,0,class<`wavCWTTree`>,1
+wmtsa,[.wavCWTTree,1,0,0,any,1
+wmtsa,[.wavCWTTree,2,0,0,...,1
+wmtsa,[.wavCWTTree,3,0,0,null,1
+wmtsa,[.wavCWTTree,4,0,0,null,1
+wmtsa,[.wavCWTTree,4,0,1,double[],1
+wmtsa,wavDaubechies,-1,0,0,class<`wavDaubechies`>,1
+wmtsa,wavDaubechies,0,0,0,character,1
+wmtsa,wavDaubechies,1,0,0,logical,1
+wmtsa,wavDictionary,-1,0,0,class<`wavDictionary`>,1
+wmtsa,wavDictionary,0,0,0,character,1
+wmtsa,wavDictionary,1,0,0,logical,1
+wmtsa,wavDictionary,2,0,0,logical,1
+wmtsa,wavDictionary,3,0,0,double,1
+wmtsa,wavDictionary,4,0,0,null,1
+wmtsa,wavDictionary,5,0,0,double,1
+wmtsa,wavDWPT,-1,0,0,class<`wavTransform`>,1
+wmtsa,wavDWPT,0,0,0,class<`signalSeries`>,1
+wmtsa,wavDWPT,0,0,1,class<`ts`>,1
+wmtsa,wavDWPT,0,0,2,double[],1
+wmtsa,wavDWPT,1,0,0,character,1
+wmtsa,wavDWPT,2,0,0,double,1
+wmtsa,wavDWPT,3,0,0,any,1
+wmtsa,wavDWPT,4,0,0,any,1
+wmtsa,wavDWPT,5,0,0,character[],1
+wmtsa,wavDWPTWhitest,-1,0,0,class<`matrix`>,1
+wmtsa,wavDWPTWhitest,0,0,0,class<`wavTransform`>,1
+wmtsa,wavDWPTWhitest,1,0,0,double,1
+wmtsa,wavDWPTWhitest,2,0,0,character,1
+wmtsa,wavDWPTWhitest,3,0,0,character,1
+wmtsa,wavDWPTWhitest,4,0,0,null,1
+wmtsa,wavDWT,-1,0,0,class<`wavTransform`>,1
+wmtsa,wavDWT,0,0,0,class<`signalSeries`>,1
+wmtsa,wavDWT,0,0,1,double[],1
+wmtsa,wavDWT,1,0,0,double,1
+wmtsa,wavDWT,2,0,0,character,1
+wmtsa,wavDWT,3,0,0,any,1
+wmtsa,wavDWT,4,0,0,any,1
+wmtsa,wavDWT,5,0,0,character[],1
+wmtsa,wavDWTMatrix,-1,0,0,class<`matrix`>,1
+wmtsa,wavDWTMatrix,0,0,0,character,1
+wmtsa,wavDWTMatrix,1,0,0,double,1
+wmtsa,wavDWTMatrix,2,0,0,double,1
+wmtsa,wavEDOF,-1,0,0,list<double[]>,1
+wmtsa,wavEDOF,-1,0,1,list<double[] | ^logical[]>,1
+wmtsa,wavEDOF,0,0,0,class<`wavTransform`>,1
+wmtsa,wavEDOF,0,0,1,double[],1
+wmtsa,wavEDOF,0,0,2,class<`signalSeries`>,1
+wmtsa,wavEDOF,1,0,0,character,1
+wmtsa,wavEDOF,2,0,0,integer[],1
+wmtsa,wavEDOF,2,0,1,null,1
+wmtsa,wavEDOF,3,0,0,class<`function`>,1
+wmtsa,wavEDOF,3,0,1,null,1
+wmtsa,wavEDOF,4,0,0,any,1
+wmtsa,wavEDOF,5,0,0,any,1
+wmtsa,wavEquivFilter,-1,0,0,double[],1
+wmtsa,wavEquivFilter,0,0,0,character,1
+wmtsa,wavEquivFilter,1,0,0,double,1
+wmtsa,wavEquivFilter,2,0,0,logical,1
+wmtsa,wavEquivFilter,3,0,0,logical,1
+wmtsa,wavFDP,-1,0,0,class<`wavFDP`>,1
+wmtsa,wavFDP,0,0,0,character,1
+wmtsa,wavFDP,1,0,0,^double[],1
+wmtsa,wavFDP,2,0,0,^double[],1
+wmtsa,wavFDP,2,0,1,null,1
+wmtsa,wavFDP,3,0,0,^double[],1
+wmtsa,wavFDP,4,0,0,double[],1
+wmtsa,wavFDP,5,0,0,class<`wavDictionary`>,1
+wmtsa,wavFDPBand,-1,0,0,double[],1
+wmtsa,wavFDPBand,0,0,0,double,1
+wmtsa,wavFDPBand,1,0,0,character,1
+wmtsa,wavFDPBand,2,0,0,logical,1
+wmtsa,wavFDPBand,3,0,0,double[],1
+wmtsa,wavFDPBand,4,0,0,any,1
+wmtsa,wavFDPBlock,-1,0,0,class<`wavFDP`>,1
+wmtsa,wavFDPBlock,0,0,0,double[],1
+wmtsa,wavFDPBlock,1,0,0,character,1
+wmtsa,wavFDPBlock,2,0,0,integer[],1
+wmtsa,wavFDPBlock,3,0,0,null,1
+wmtsa,wavFDPBlock,4,0,0,character,1
+wmtsa,wavFDPBlock,5,0,0,double,1
+wmtsa,wavFDPSDF,-1,0,0,double[],1
+wmtsa,wavFDPSDF,0,0,0,double[],1
+wmtsa,wavFDPSDF,1,0,0,double,1
+wmtsa,wavFDPSDF,2,0,0,double,1
+wmtsa,wavFDPSDF,3,0,0,null,1
+wmtsa,wavFDPTime,-1,0,0,class<`wavFDP`>,1
+wmtsa,wavFDPTime,0,0,0,double[],1
+wmtsa,wavFDPTime,1,0,0,character,1
+wmtsa,wavFDPTime,2,0,0,integer[],1
+wmtsa,wavFDPTime,3,0,0,logical,1
+wmtsa,wavFDPTime,4,0,0,character,1
+wmtsa,wavFDPTime,5,0,0,double,1
+wmtsa,wavGain,-1,0,0,class<`wavGain`>,1
+wmtsa,wavGain,0,0,0,character,1
+wmtsa,wavGain,1,0,0,double,1
+wmtsa,wavGain,2,0,0,double,1
+wmtsa,wavGain,3,0,0,logical,1
+wmtsa,wavIndex,-1,0,0,list<list<integer[]>>,1
+wmtsa,wavIndex,0,0,0,class<`wavTransform`>,1
+wmtsa,wavMaxLevel,-1,0,0,integer,1
+wmtsa,wavMaxLevel,0,0,0,double,1
+wmtsa,wavMaxLevel,1,0,0,double,1
+wmtsa,wavMaxLevel,2,0,0,character,1
+wmtsa,wavMODWPT,-1,0,0,class<`wavTransform`>,1
+wmtsa,wavMODWPT,0,0,0,class<`ts`>,1
+wmtsa,wavMODWPT,1,0,0,character,1
+wmtsa,wavMODWPT,2,0,0,double,1
+wmtsa,wavMODWPT,3,0,0,any,1
+wmtsa,wavMODWPT,4,0,0,character[],1
+wmtsa,wavMODWPT,5,0,0,character[],1
+wmtsa,wavMODWT,-1,0,0,class<`wavTransform`>,1
+wmtsa,wavMODWT,0,0,0,class<`signalSeries`>,1
+wmtsa,wavMODWT,0,0,1,class<`ts`>,1
+wmtsa,wavMODWT,0,0,2,double[],1
+wmtsa,wavMODWT,1,0,0,character,1
+wmtsa,wavMODWT,2,0,0,double,1
+wmtsa,wavMODWT,3,0,0,any,1
+wmtsa,wavMODWT,4,0,0,any,1
+wmtsa,wavMODWT,5,0,0,character[],1
+wmtsa,wavMRD,-1,0,0,class<`wavMRD`>,1
+wmtsa,wavMRD,0,0,0,class<`wavTransform`>,1
+wmtsa,wavMRD,1,0,0,double[],1
+wmtsa,wavMRD,1,0,1,null,1
+wmtsa,wavMRD,2,0,0,null,1
+wmtsa,wavMRDSum,-1,0,0,double[],1
+wmtsa,wavMRDSum,0,0,0,double[],1
+wmtsa,wavMRDSum,1,0,0,character,1
+wmtsa,wavMRDSum,2,0,0,integer[],1
+wmtsa,wavMRDSum,3,0,0,character,1
+wmtsa,wavMRDSum,4,0,0,logical,1
+wmtsa,wavMRDSum,5,0,0,logical,1
+wmtsa,wavPacketBasis,-1,0,0,list<list<double[]>>,1
+wmtsa,wavPacketBasis,0,0,0,class<`wavTransform`>,1
+wmtsa,wavPacketBasis,1,0,0,double[],1
+wmtsa,wavPacketIndices,-1,0,0,list<double[]>,1
+wmtsa,wavPacketIndices,0,0,0,double[],1
+wmtsa,wavPacketIndices,1,0,0,logical,1
+wmtsa,wavShift,-1,0,0,class<`wavBoundary`>,1
+wmtsa,wavShift,-1,0,1,class<`wavTransform`>,1
+wmtsa,wavShift,0,0,0,class<`wavBoundary`>,1
+wmtsa,wavShift,0,0,1,class<`wavTransform`>,1
+wmtsa,wavShrink,-1,0,0,double[],1
+wmtsa,wavShrink,0,0,0,double[],1
+wmtsa,wavShrink,1,0,0,character,1
+wmtsa,wavShrink,2,0,0,integer,1
+wmtsa,wavShrink,3,0,0,character,1
+wmtsa,wavShrink,4,0,0,character,1
+wmtsa,wavShrink,5,0,0,null,1
+wmtsa,wavSortCrystals,-1,0,0,character[],1
+wmtsa,wavSortCrystals,0,0,0,character[],1
+wmtsa,wavSortCrystals,1,0,0,logical,1
+wmtsa,wavStackPlot,-1,0,0,null,1
+wmtsa,wavStackPlot,0,0,0,class<`wavTransform`>,1
+wmtsa,wavStackPlot,1,0,0,...,1
+wmtsa,wavStackPlot.default,-1,0,0,double[],1
+wmtsa,wavStackPlot.default,0,0,0,list<double[]>,1
+wmtsa,wavStackPlot.default,1,0,0,logical,1
+wmtsa,wavStackPlot.default,2,0,0,logical,1
+wmtsa,wavStackPlot.default,3,0,0,character,1
+wmtsa,wavStackPlot.default,4,0,0,logical,1
+wmtsa,wavStackPlot.default,5,0,0,logical,1
+wmtsa,wavStackPlot.wavTransform,-1,0,0,null,1
+wmtsa,wavStackPlot.wavTransform,0,0,0,class<`wavTransform`>,1
+wmtsa,wavStackPlot.wavTransform,1,0,0,logical,1
+wmtsa,wavStackPlot.wavTransform,2,0,0,logical,1
+wmtsa,wavStackPlot.wavTransform,3,0,0,null,1
+wmtsa,wavStackPlot.wavTransform,4,0,0,null,1
+wmtsa,wavStackPlot.wavTransform,5,0,0,double,1
+wmtsa,wavStemPlot,-1,0,0,null,1
+wmtsa,wavStemPlot,0,0,0,double[],1
+wmtsa,wavStemPlot,1,0,0,any,1
+wmtsa,wavStemPlot,2,0,0,double,1
+wmtsa,wavStemPlot,3,0,0,character,1
+wmtsa,wavStemPlot,4,0,0,character,1
+wmtsa,wavStemPlot,5,0,0,...,1
+wmtsa,wavTitle,-1,0,0,character,1
+wmtsa,wavTitle,0,0,0,class<`wavBoundary`>,1
+wmtsa,wavTitle,0,0,1,class<`wavFDP`>,1
+wmtsa,wavTitle,0,0,2,class<`wavTransform`>,1
+wmtsa,wavTitle,1,0,0,character,1
+wmtsa,wavTransform,-1,0,0,class<`wavTransform`>,1
+wmtsa,wavTransform,0,0,0,list<double[]>,1
+wmtsa,wavTransform,1,0,0,class<`signalSeries`>,1
+wmtsa,wavTransform,2,0,0,integer,1
+wmtsa,wavTransform,3,0,0,class<`wavDictionary`>,1
+wmtsa,wavTransform,4,0,0,logical,1
+wmtsa,wavTransform,5,0,0,character,1
+wmtsa,wavVar,-1,0,0,class<`wavVar`>,1
+wmtsa,wavVar,0,0,0,class<`signalSeries`>,1
+wmtsa,wavVar,1,0,0,character,1
+wmtsa,wavVar,2,0,0,character,1
+wmtsa,wavVar,3,0,0,null,1
+wmtsa,wavVar,4,0,0,any,1
+wmtsa,wavVar,5,0,0,any,1
+wmtsa,wavVarConfidence,-1,0,0,list<double[]>,1
+wmtsa,wavVarConfidence,0,0,0,double[],1
+wmtsa,wavVarConfidence,1,0,0,double[],1
+wmtsa,wavVarConfidence,2,0,0,double,1
+wmtsa,wavVarTest,-1,0,0,class<`wavVarTest`>,1
+wmtsa,wavVarTest,0,0,0,double[],1
+wmtsa,wavVarTest,1,0,0,character,1
+wmtsa,wavVarTest,2,0,0,null,1
+wmtsa,wavVarTest,3,0,0,double[],1
+wmtsa,wavVarTest,4,0,0,logical,1
+wmtsa,wavVarTest,5,0,0,double,1
+wmtsa,wavZeroPhase,-1,0,0,list<integer[]>,1
+wmtsa,wavZeroPhase,0,0,0,character,1
+wmtsa,wavZeroPhase,1,0,0,double[],1
+wrapr,:=,-1,0,0,character[],1
+wrapr,:=,-1,0,1,class<`function`>,1
+wrapr,:=,-1,0,2,double[],1
+wrapr,:=,0,0,0,any,1
+wrapr,:=,1,0,0,any,1
+wrapr,%?%,-1,0,0,^double[],1
+wrapr,%?%,-1,0,1,list<double | null>,1
+wrapr,%?%,-1,0,2,null,1
+wrapr,%?%,-1,0,3,list<double>,1
+wrapr,%?%,0,0,0,^double[],1
+wrapr,%?%,0,0,1,null,1
+wrapr,%?%,0,0,2,list<any>,1
+wrapr,%?%,1,0,0,^double[],1
+wrapr,%?%,1,0,1,list<any>,1
+wrapr,%.>%,-1,0,0,any,1
+wrapr,%.>%,0,0,0,any,1
+wrapr,%.>%,1,0,0,any,1
+wrapr,%.|%,-1,0,0,integer,1
+wrapr,%.|%,0,0,0,integer[],1
+wrapr,%.|%,1,0,0,any,1
+wrapr,add_name_column,-1,0,0,list<class<`data.frame`>>,1
+wrapr,add_name_column,0,0,0,list<class<`data.frame`>>,1
+wrapr,add_name_column,1,0,0,character,1
+wrapr,apply_left,-1,0,0,any,1
+wrapr,apply_left,0,0,0,character,1
+wrapr,apply_left,0,0,1,class<`Collector`>,1
+wrapr,apply_left,0,0,2,class<`data.frame`>,1
+wrapr,apply_left,0,0,3,list<class<`data.frame`>>,1
+wrapr,apply_left,0,0,4,class<`formula`>,1
+wrapr,apply_left,0,0,5,class<`function`>,1
+wrapr,apply_left,0,0,6,class<`locum`>,1
+wrapr,apply_left,0,0,7,class<`PartialNamedFn`>,1
+wrapr,apply_left,0,0,8,double[],1
+wrapr,apply_left,0,0,9,class<`track`>,1
+wrapr,apply_left,1,0,0,character,1
+wrapr,apply_left,1,0,1,class<`call`>,1
+wrapr,apply_left,1,0,2,double,1
+wrapr,apply_left,1,0,3,class<`{`>,1
+wrapr,apply_left,2,0,0,environment,1
+wrapr,apply_left,3,0,0,any,1
+wrapr,apply_left,4,0,0,any,1
+wrapr,apply_left,5,0,0,any,1
+wrapr,apply_left.Collector,-1,0,0,class<`Collector`>,1
+wrapr,apply_left.Collector,0,0,0,class<`Collector`>,1
+wrapr,apply_left.Collector,1,0,0,class<`call`>,1
+wrapr,apply_left.Collector,2,0,0,environment,1
+wrapr,apply_left.Collector,3,0,0,any,1
+wrapr,apply_left.Collector,4,0,0,any,1
+wrapr,apply_left.Collector,5,0,0,any,1
+wrapr,apply_left_default,-1,0,0,any,1
+wrapr,apply_left_default,0,0,0,any,1
+wrapr,apply_left_default,1,0,0,class<`call`>,1
+wrapr,apply_left_default,1,0,1,class<`{`>,1
+wrapr,apply_left_default,2,0,0,environment,1
+wrapr,apply_left_default,3,0,0,any,1
+wrapr,apply_left_default,4,0,0,any,1
+wrapr,apply_left_default,5,0,0,any,1
+wrapr,apply_left.default,-1,0,0,any,1
+wrapr,apply_left.default,0,0,0,class<`data.frame`>,1
+wrapr,apply_left.default,0,0,1,list<class<`data.frame`>>,1
+wrapr,apply_left.default,0,0,2,class<`function`>,1
+wrapr,apply_left.default,0,0,3,double[],1
+wrapr,apply_left.default,0,0,4,class<`track`>,1
+wrapr,apply_left.default,1,0,0,class<`call`>,1
+wrapr,apply_left.default,1,0,1,class<`{`>,1
+wrapr,apply_left.default,2,0,0,environment,1
+wrapr,apply_left.default,3,0,0,any,1
+wrapr,apply_left.default,4,0,0,any,1
+wrapr,apply_left.default,5,0,0,any,1
+wrapr,apply_left.locum,-1,0,0,class<`locum`>,1
+wrapr,apply_left.locum,0,0,0,class<`locum`>,1
+wrapr,apply_left.locum,1,0,0,class<`call`>,1
+wrapr,apply_left.locum,2,0,0,environment,1
+wrapr,apply_left.locum,3,0,0,null,1
+wrapr,apply_left.locum,4,0,0,character,1
+wrapr,apply_left.locum,5,0,0,null,1
+wrapr,apply_left.UnaryFn,-1,0,0,class<`UnaryFnList`>,1
+wrapr,apply_left.UnaryFn,0,0,0,class<`PartialNamedFn`>,1
+wrapr,apply_left.UnaryFn,1,0,0,class<`call`>,1
+wrapr,apply_left.UnaryFn,2,0,0,environment,1
+wrapr,apply_left.UnaryFn,3,0,0,any,1
+wrapr,apply_left.UnaryFn,4,0,0,any,1
+wrapr,apply_left.UnaryFn,5,0,0,any,1
+wrapr,apply_right,-1,0,0,double[],1
+wrapr,apply_right,-1,0,1,character,1
+wrapr,apply_right,-1,0,2,class<`data.frame`>,1
+wrapr,apply_right,-1,0,3,class<`UnaryFnList`>,1
+wrapr,apply_right,0,0,0,character,1
+wrapr,apply_right,0,0,1,class<`data.frame`>,1
+wrapr,apply_right,0,0,2,class<`PartialFunction`>,1
+wrapr,apply_right,0,0,3,class<`PartialNamedFn`>,1
+wrapr,apply_right,0,0,4,class<`UnaryFnList`>,1
+wrapr,apply_right,0,0,5,double[],1
+wrapr,apply_right,1,0,0,class<`PartialFunction`>,1
+wrapr,apply_right,1,0,1,character,1
+wrapr,apply_right,1,0,2,class<`data.frame`>,1
+wrapr,apply_right,1,0,3,class<`PartialNamedFn`>,1
+wrapr,apply_right,1,0,4,class<`UnaryFnList`>,1
+wrapr,apply_right,1,0,5,class<`SrcFunction`>,1
+wrapr,apply_right,1,0,6,class<`locum`>,1
+wrapr,apply_right,1,0,7,"class<`ourclass`, `wrapr_applicable`>",1
+wrapr,apply_right,1,0,8,list<class<`function`>>,1
+wrapr,apply_right,1,0,9,"class<`glm`, `lm`>",1
+wrapr,apply_right,2,0,0,environment,1
+wrapr,apply_right,3,0,0,any,1
+wrapr,apply_right,4,0,0,any,1
+wrapr,apply_right,5,0,0,any,1
+wrapr,apply_right.default,-1,0,0,character,1
+wrapr,apply_right.default,-1,0,1,class<`data.frame`>,1
+wrapr,apply_right.default,0,0,0,character,1
+wrapr,apply_right.default,0,0,1,class<`data.frame`>,1
+wrapr,apply_right.default,1,0,0,character,1
+wrapr,apply_right.default,1,0,1,class<`data.frame`>,1
+wrapr,apply_right.default,2,0,0,environment,1
+wrapr,apply_right.default,3,0,0,any,1
+wrapr,apply_right.default,4,0,0,any,1
+wrapr,apply_right.default,5,0,0,any,1
+wrapr,apply_right.locum,-1,0,0,double,1
+wrapr,apply_right.locum,0,0,0,double,1
+wrapr,apply_right.locum,1,0,0,class<`locum`>,1
+wrapr,apply_right.locum,2,0,0,environment,1
+wrapr,apply_right.locum,3,0,0,any,1
+wrapr,apply_right.locum,4,0,0,any,1
+wrapr,apply_right.locum,5,0,0,any,1
+wrapr,apply_right_S4,-1,0,0,character,1
+wrapr,apply_right_S4,-1,0,1,class<`data.frame`>,1
+wrapr,apply_right_S4,0,0,0,character,1
+wrapr,apply_right_S4,0,0,1,class<`data.frame`>,1
+wrapr,apply_right_S4,1,0,0,character,1
+wrapr,apply_right_S4,1,0,1,class<`data.frame`>,1
+wrapr,apply_right_S4,2,0,0,any,1
+wrapr,apply_right_S4,3,0,0,any,1
+wrapr,apply_right_S4,4,0,0,any,1
+wrapr,apply_right_S4,5,0,0,any,1
+wrapr,apply_right.UnaryFn,-1,0,0,class<`UnaryFnList`>,1
+wrapr,apply_right.UnaryFn,-1,0,1,double[],1
+wrapr,apply_right.UnaryFn,0,0,0,class<`PartialFunction`>,1
+wrapr,apply_right.UnaryFn,0,0,1,class<`PartialNamedFn`>,1
+wrapr,apply_right.UnaryFn,0,0,2,class<`UnaryFnList`>,1
+wrapr,apply_right.UnaryFn,0,0,3,double[],1
+wrapr,apply_right.UnaryFn,0,0,4,class<`data.frame`>,1
+wrapr,apply_right.UnaryFn,1,0,0,class<`PartialFunction`>,1
+wrapr,apply_right.UnaryFn,1,0,1,class<`PartialNamedFn`>,1
+wrapr,apply_right.UnaryFn,1,0,2,class<`UnaryFnList`>,1
+wrapr,apply_right.UnaryFn,1,0,3,class<`SrcFunction`>,1
+wrapr,apply_right.UnaryFn,2,0,0,environment,1
+wrapr,apply_right.UnaryFn,3,0,0,any,1
+wrapr,apply_right.UnaryFn,4,0,0,any,1
+wrapr,apply_right.UnaryFn,5,0,0,any,1
+wrapr,ApplyTo,-1,0,0,class<`UnaryFnList`>,1
+wrapr,ApplyTo,0,0,0,class<`PartialFunction`>,1
+wrapr,ApplyTo,1,0,0,class<`UnaryFnList`>,1
+wrapr,ApplyTo,2,0,0,any,1
+wrapr,ApplyTo,-1,1,0,class<`UnaryFnList`>,1
+wrapr,ApplyTo,0,1,0,class<`UnaryFnList`>,1
+wrapr,ApplyTo,1,1,0,class<`UnaryFnList`>,1
+wrapr,ApplyTo,2,1,0,any,1
+wrapr,ApplyTo,-1,2,0,class<`UnaryFnList`>,1
+wrapr,ApplyTo,0,2,0,class<`PartialNamedFn`>,1
+wrapr,ApplyTo,1,2,0,class<`PartialFunction`>,1
+wrapr,ApplyTo,2,2,0,any,1
+wrapr,ApplyTo,-1,3,0,double,1
+wrapr,ApplyTo,0,3,0,class<`SrcFunction`>,1
+wrapr,ApplyTo,1,3,0,double,1
+wrapr,ApplyTo,2,3,0,environment,1
+wrapr,ApplyTo,-1,4,0,class<`UnaryFnList`>,1
+wrapr,ApplyTo,0,4,0,class<`UnaryFnList`>,1
+wrapr,ApplyTo,1,4,0,class<`PartialNamedFn`>,1
+wrapr,ApplyTo,2,4,0,any,1
+wrapr,ApplyTo,-1,5,0,double[],1
+wrapr,ApplyTo,0,5,0,class<`SrcFunction`>,1
+wrapr,ApplyTo,1,5,0,integer[],1
+wrapr,ApplyTo,2,5,0,environment,1
+wrapr,ApplyTo,-1,6,0,class<`UnaryFnList`>,1
+wrapr,ApplyTo,-1,6,1,double[],1
+wrapr,ApplyTo,0,6,0,class<`PartialFunction`>,1
+wrapr,ApplyTo,0,6,1,class<`PartialNamedFn`>,1
+wrapr,ApplyTo,0,6,2,class<`UnaryFnList`>,1
+wrapr,ApplyTo,0,6,3,class<`SrcFunction`>,1
+wrapr,ApplyTo,1,6,0,class<`PartialFunction`>,1
+wrapr,ApplyTo,1,6,1,class<`PartialNamedFn`>,1
+wrapr,ApplyTo,1,6,2,class<`UnaryFnList`>,1
+wrapr,ApplyTo,1,6,3,double[],1
+wrapr,ApplyTo,1,6,4,class<`data.frame`>,1
+wrapr,ApplyTo,2,6,0,any,1
+wrapr,ApplyTo,-1,7,0,class<`UnaryFnList`>,1
+wrapr,ApplyTo,0,7,0,class<`PartialFunction`>,1
+wrapr,ApplyTo,1,7,0,class<`PartialFunction`>,1
+wrapr,ApplyTo,2,7,0,any,1
+wrapr,ApplyTo,-1,8,0,double[],1
+wrapr,ApplyTo,0,8,0,class<`PartialNamedFn`>,1
+wrapr,ApplyTo,1,8,0,integer[],1
+wrapr,ApplyTo,2,8,0,environment,1
+wrapr,ApplyTo,-1,9,0,double[],1
+wrapr,ApplyTo,0,9,0,class<`UnaryFnList`>,1
+wrapr,ApplyTo,1,9,0,class<`data.frame`>,1
+wrapr,ApplyTo,2,9,0,environment,1
+wrapr,ApplyTo,-1,10,0,double[],1
+wrapr,ApplyTo,0,10,0,class<`PartialNamedFn`>,1
+wrapr,ApplyTo,1,10,0,class<`data.frame`>,1
+wrapr,ApplyTo,2,10,0,environment,1
+wrapr,ApplyTo,-1,11,0,double[],1
+wrapr,ApplyTo,0,11,0,class<`PartialFunction`>,1
+wrapr,ApplyTo,1,11,0,integer[],1
+wrapr,ApplyTo,2,11,0,environment,1
+wrapr,ApplyTo,-1,12,0,class<`UnaryFnList`>,1
+wrapr,ApplyTo,0,12,0,class<`UnaryFnList`>,1
+wrapr,ApplyTo,1,12,0,class<`PartialFunction`>,1
+wrapr,ApplyTo,2,12,0,any,1
+wrapr,ApplyTo,-1,13,0,double[],1
+wrapr,ApplyTo,0,13,0,class<`PartialNamedFn`>,1
+wrapr,ApplyTo,1,13,0,double[],1
+wrapr,ApplyTo,2,13,0,environment,1
+wrapr,ApplyTo,-1,14,0,class<`UnaryFnList`>,1
+wrapr,ApplyTo,0,14,0,class<`PartialNamedFn`>,1
+wrapr,ApplyTo,1,14,0,class<`UnaryFnList`>,1
+wrapr,ApplyTo,2,14,0,any,1
+wrapr,ApplyTo,-1,15,0,double[],1
+wrapr,ApplyTo,0,15,0,class<`UnaryFnList`>,1
+wrapr,ApplyTo,1,15,0,integer[],1
+wrapr,ApplyTo,2,15,0,environment,1
+wrapr,ApplyTo,-1,16,0,class<`UnaryFnList`>,1
+wrapr,ApplyTo,0,16,0,class<`PartialNamedFn`>,1
+wrapr,ApplyTo,1,16,0,class<`PartialNamedFn`>,1
+wrapr,ApplyTo,2,16,0,any,1
+wrapr,ApplyTo,-1,17,0,class<`UnaryFnList`>,1
+wrapr,ApplyTo,0,17,0,class<`PartialFunction`>,1
+wrapr,ApplyTo,1,17,0,class<`PartialNamedFn`>,1
+wrapr,ApplyTo,2,17,0,any,1
+wrapr,ApplyTo,-1,18,0,double[],1
+wrapr,ApplyTo,0,18,0,class<`PartialFunction`>,1
+wrapr,ApplyTo,1,18,0,double[],1
+wrapr,ApplyTo,2,18,0,environment,1
+wrapr,as.character.locum,-1,0,0,character,1
+wrapr,as.character.locum,0,0,0,class<`locum`>,1
+wrapr,as.character.locum,1,0,0,...,1
+wrapr,as_dot_fn,-1,0,0,class<`wrapr_as_dot_fn`>,1
+wrapr,as_dot_fn,0,0,0,any,1
+wrapr,as_dot_fn,1,0,0,environment,1
+wrapr,as_fn,-1,0,0,class<`wrapr_as_fn`>,1
+wrapr,as_fn,0,0,0,class<`PartialFunction`>,1
+wrapr,as_fn,0,0,1,class<`PartialNamedFn`>,1
+wrapr,as_fn,1,0,0,environment,1
+wrapr,as_fnlist,-1,0,0,class<`UnaryFnList`>,1
+wrapr,as_fnlist,0,0,0,list<class<`PartialNamedFn`>>,1
+wrapr,as_fnlist,1,0,0,environment,1
+wrapr,as.list.UnaryFn,-1,0,0,list<class<`PartialNamedFn`>>,1
+wrapr,as.list.UnaryFn,0,0,0,class<`PartialNamedFn`>,1
+wrapr,as.list.UnaryFn,1,0,0,...,1
+wrapr,as.list.UnaryFnList,-1,0,0,list<class<`PartialNamedFn`>>,1
+wrapr,as.list.UnaryFnList,0,0,0,class<`UnaryFnList`>,1
+wrapr,as.list.UnaryFnList,1,0,0,...,1
+wrapr,as_named_list,-1,0,0,list<class<`data.frame`> | double>,1
+wrapr,as_named_list,0,0,0,...,1
+wrapr,as.UnaryFn,-1,0,0,class<`UnaryFnList`>,1
+wrapr,as.UnaryFn,0,0,0,list<class<`PartialNamedFn`>>,1
+wrapr,as.UnaryFn,1,0,0,environment,1
+wrapr,bquote_call_args,-1,0,0,list<double>,1
+wrapr,bquote_call_args,0,0,0,class<`call`>,1
+wrapr,bquote_call_args,1,0,0,environment,1
+wrapr,bquote_function,-1,0,0,class<`function`>,1
+wrapr,bquote_function,0,0,0,class<`function`>,1
+wrapr,build_frame,-1,0,0,class<`data.frame`>,1
+wrapr,build_frame,0,0,0,...,1
+wrapr,build_frame,1,0,0,environment,1
+wrapr,buildNameCallback,-1,0,0,class<`function`>,1
+wrapr,buildNameCallback,0,0,0,character,1
+wrapr,%c%,-1,0,0,character[],1
+wrapr,%c%,-1,0,1,integer[],1
+wrapr,%c%,0,0,0,character[],1
+wrapr,%c%,0,0,1,integer[],1
+wrapr,%c%,1,0,0,character,1
+wrapr,%c%,1,0,1,integer[],1
+wrapr,:=.character,-1,0,0,character[],1
+wrapr,:=.character,-1,0,1,double[],1
+wrapr,:=.character,0,0,0,character[],1
+wrapr,:=.character,0,0,1,class<`factor`>,1
+wrapr,:=.character,1,0,0,character[],1
+wrapr,:=.character,1,0,1,double[],1
+wrapr,checkColsFormUniqueKeys,-1,0,0,logical,1
+wrapr,checkColsFormUniqueKeys,0,0,0,class<`data.frame`>,1
+wrapr,checkColsFormUniqueKeys,1,0,0,character[],1
+wrapr,clean_fit_glm,-1,0,0,"list<class<`glm`, `lm`> | class<`summary.glm`>>",1
+wrapr,clean_fit_glm,0,0,0,character,1
+wrapr,clean_fit_glm,1,0,0,character[],1
+wrapr,clean_fit_glm,2,0,0,class<`data.frame`>,1
+wrapr,clean_fit_glm,3,0,0,...,1
+wrapr,clean_fit_glm,4,0,0,class<`function`>,1
+wrapr,clean_fit_glm,5,0,0,logical,1
+wrapr,clean_fit_glm,6,0,0,null,1
+wrapr,clean_fit_glm,7,0,0,character,1
+wrapr,clean_fit_lm,-1,0,0,list<class<`lm`> | class<`summary.lm`>>,1
+wrapr,clean_fit_lm,0,0,0,character,1
+wrapr,clean_fit_lm,1,0,0,character[],1
+wrapr,clean_fit_lm,2,0,0,class<`data.frame`>,1
+wrapr,clean_fit_lm,3,0,0,...,1
+wrapr,clean_fit_lm,4,0,0,logical,1
+wrapr,clean_fit_lm,5,0,0,null,1
+wrapr,clean_fit_lm,6,0,0,environment,1
+wrapr,coalesce,-1,0,0,^double[],1
+wrapr,coalesce,-1,0,1,list<double | null>,1
+wrapr,coalesce,-1,0,2,null,1
+wrapr,coalesce,-1,0,3,list<double>,1
+wrapr,coalesce,0,0,0,^double[],1
+wrapr,coalesce,0,0,1,null,1
+wrapr,coalesce,0,0,2,list<any>,1
+wrapr,coalesce,1,0,0,^double[],1
+wrapr,coalesce,1,0,1,list<any>,1
+wrapr,Collector,-1,0,0,class<`Collector`>,1
+wrapr,concat_items_rev,-1,0,0,list<class<`PartialFunction`>>,1
+wrapr,concat_items_rev,-1,0,1,list<class<`PartialFunction`> | class<`PartialNamedFn`>>,1
+wrapr,concat_items_rev,-1,0,2,list<class<`PartialNamedFn`> | class<`PartialFunction`>>,1
+wrapr,concat_items_rev,-1,0,3,list<class<`PartialNamedFn`>>,1
+wrapr,concat_items_rev,0,0,0,list<class<`PartialFunction`>>,1
+wrapr,concat_items_rev,0,0,1,list<class<`PartialNamedFn`> | class<`PartialFunction`>>,1
+wrapr,concat_items_rev,0,0,2,list<class<`PartialNamedFn`>>,1
+wrapr,concat_items_rev,1,0,0,list<any>,1
+wrapr,c.UnaryFn,-1,0,0,class<`UnaryFnList`>,1
+wrapr,c.UnaryFn,0,0,0,...,1
+wrapr,DebugFn,-1,0,0,any,1
+wrapr,DebugFn,0,0,0,character,1
+wrapr,DebugFn,1,0,0,class<`function`>,1
+wrapr,DebugFn,2,0,0,...,1
+wrapr,DebugFnE,-1,0,0,any,1
+wrapr,DebugFnE,0,0,0,character,1
+wrapr,DebugFnE,1,0,0,class<`function`>,1
+wrapr,DebugFnE,2,0,0,...,1
+wrapr,DebugFnW,-1,0,0,class<`function`>,1
+wrapr,DebugFnW,0,0,0,character,1
+wrapr,DebugFnW,0,0,1,class<`function`>,1
+wrapr,DebugFnW,0,0,2,class<`name`>,1
+wrapr,DebugFnW,1,0,0,class<`function`>,1
+wrapr,DebugFnWE,-1,0,0,class<`function`>,1
+wrapr,DebugFnWE,0,0,0,character,1
+wrapr,DebugFnWE,1,0,0,class<`function`>,1
+wrapr,DebugFnWE,2,0,0,...,1
+wrapr,DebugPrintFn,-1,0,0,any,1
+wrapr,DebugPrintFn,0,0,0,character,1
+wrapr,DebugPrintFn,1,0,0,class<`function`>,1
+wrapr,DebugPrintFn,2,0,0,...,1
+wrapr,DebugPrintFnE,-1,0,0,any,1
+wrapr,DebugPrintFnE,0,0,0,character,1
+wrapr,DebugPrintFnE,1,0,0,class<`function`>,1
+wrapr,DebugPrintFnE,2,0,0,...,1
+wrapr,defineLambda,-1,0,0,class<`function`>,1
+wrapr,defineLambda,0,0,0,environment,1
+wrapr,defineLambda,1,0,0,null,1
+wrapr,%dot%,-1,0,0,double,1
+wrapr,%dot%,0,0,0,double[],1
+wrapr,%dot%,1,0,0,double[],1
+wrapr,draw_frame,-1,0,0,character,1
+wrapr,draw_frame,0,0,0,class<`data.frame`>,1
+wrapr,draw_frame,1,0,0,...,1
+wrapr,draw_frame,2,0,0,character,1
+wrapr,draw_frame,3,0,0,list<any>,1
+wrapr,draw_frame,4,0,0,double,1
+wrapr,draw_framec,-1,0,0,character,1
+wrapr,draw_framec,0,0,0,class<`data.frame`>,1
+wrapr,draw_framec,1,0,0,...,1
+wrapr,draw_framec,2,0,0,character[],1
+wrapr,draw_framec,3,0,0,double,1
+wrapr,early_tries,-1,0,0,class<`function`>,1
+wrapr,early_tries,-1,0,1,null,1
+wrapr,early_tries,0,0,0,class<`call`>,1
+wrapr,early_tries,0,0,1,class<`name`>,1
+wrapr,early_tries,0,0,2,character,1
+wrapr,early_tries,1,0,0,class<`{`>,1
+wrapr,early_tries,1,0,1,class<`call`>,1
+wrapr,early_tries,1,0,2,character,1
+wrapr,early_tries,1,0,3,double,1
+wrapr,early_tries,1,0,4,class<`name`>,1
+wrapr,early_tries,2,0,0,any,1
+wrapr,evalb,-1,0,0,null,1
+wrapr,evalb,0,0,0,...,1
+wrapr,evalb,1,0,0,environment,1
+wrapr,eval_dot_sequence,-1,0,0,character,1
+wrapr,eval_dot_sequence,0,0,0,character,1
+wrapr,eval_dot_sequence,1,0,0,class<`Collector`>,1
+wrapr,eval_dot_sequence,2,0,0,environment,1
+wrapr,execute_parallel,-1,0,0,list<class<`data.frame`>>,1
+wrapr,execute_parallel,0,0,0,list<class<`data.frame`>>,1
+wrapr,execute_parallel,1,0,0,class<`function`>,1
+wrapr,execute_parallel,2,0,0,character,1
+wrapr,execute_parallel,3,0,0,...,1
+wrapr,execute_parallel,4,0,0,"class<`SOCKcluster`, `cluster`>",1
+wrapr,execute_parallel,5,0,0,logical,1
+wrapr,execute_parallel,6,0,0,environment,1
+wrapr,:=.factor,-1,0,0,character[],1
+wrapr,:=.factor,-1,0,1,double[],1
+wrapr,:=.factor,0,0,0,character[],1
+wrapr,:=.factor,0,0,1,class<`factor`>,1
+wrapr,:=.factor,1,0,0,character[],1
+wrapr,:=.factor,1,0,1,double[],1
+wrapr,fnlist,-1,0,0,class<`UnaryFnList`>,1
+wrapr,fnlist,0,0,0,...,1
+wrapr,format.locum,-1,0,0,character,1
+wrapr,format.locum,0,0,0,class<`locum`>,1
+wrapr,format.locum,1,0,0,...,1
+wrapr,format.PartialFunction,-1,0,0,character,1
+wrapr,format.PartialFunction,0,0,0,class<`PartialFunction`>,1
+wrapr,format.PartialFunction,1,0,0,...,1
+wrapr,format.PartialNamedFn,-1,0,0,character,1
+wrapr,format.PartialNamedFn,0,0,0,class<`PartialNamedFn`>,1
+wrapr,format.PartialNamedFn,1,0,0,...,1
+wrapr,format.SrcFunction,-1,0,0,character,1
+wrapr,format.SrcFunction,0,0,0,class<`SrcFunction`>,1
+wrapr,format.SrcFunction,1,0,0,...,1
+wrapr,format.UnaryFnList,-1,0,0,character,1
+wrapr,format.UnaryFnList,0,0,0,class<`UnaryFnList`>,1
+wrapr,format.UnaryFnList,1,0,0,...,1
+wrapr,grab_assignments_from_dots,-1,0,0,character[],1
+wrapr,grab_assignments_from_dots,0,0,0,list<class<`name`>>,1
+wrapr,grab_assignments_from_dots,0,0,1,list<class<`name`> | class<`call`> | class<`<-`>>,1
+wrapr,grab_assignments_from_dots,0,0,2,list<class<`<-`> | class<`name`>>,1
+wrapr,grab_assignments_from_dots,0,0,3,list<class<`<-`>>,1
+wrapr,grepdf,-1,0,0,character,1
+wrapr,grepdf,0,0,0,character,1
+wrapr,grepdf,1,0,0,class<`data.frame`>,1
+wrapr,grepdf,2,0,0,...,1
+wrapr,grepdf,3,0,0,logical,1
+wrapr,grepdf,4,0,0,logical,1
+wrapr,grepdf,5,0,0,logical,1
+wrapr,grepdf,6,0,0,logical,1
+wrapr,grepdf,7,0,0,logical,1
+wrapr,grepv,-1,0,0,character,1
+wrapr,grepv,0,0,0,character,1
+wrapr,grepv,1,0,0,character[],1
+wrapr,grepv,2,0,0,...,1
+wrapr,grepv,3,0,0,logical,1
+wrapr,grepv,4,0,0,logical,1
+wrapr,grepv,5,0,0,logical,1
+wrapr,grepv,6,0,0,logical,1
+wrapr,grepv,7,0,0,logical,1
+wrapr,has_no_dup_rows,-1,0,0,logical,1
+wrapr,has_no_dup_rows,0,0,0,class<`data.frame`>,1
+wrapr,%in_block%,-1,0,0,class<`data.frame`>,1
+wrapr,%in_block%,0,0,0,character[],1
+wrapr,%in_block%,1,0,0,any,1
+wrapr,invert_perm,-1,0,0,integer[],1
+wrapr,invert_perm,0,0,0,double[],1
+wrapr,is_infix,-1,0,0,logical,1
+wrapr,is_infix,0,0,0,class<`name`>,1
+wrapr,isValidAndUnreservedName,-1,0,0,logical,1
+wrapr,isValidAndUnreservedName,0,0,0,character,1
+wrapr,lambda,-1,0,0,class<`function`>,1
+wrapr,lambda,0,0,0,...,1
+wrapr,lambda,1,0,0,environment,1
+wrapr,lapplym,-1,0,0,list<double>,1
+wrapr,lapplym,0,0,0,double[],1
+wrapr,lapplym,1,0,0,class<`function`>,1
+wrapr,lapplym,2,0,0,...,1
+wrapr,let,-1,0,0,character,1
+wrapr,let,-1,0,1,class<`{`>,1
+wrapr,let,-1,0,2,class<`call`>,1
+wrapr,let,-1,0,3,class<`data.frame`>,1
+wrapr,let,-1,0,4,double[],1
+wrapr,let,-1,0,5,expression,1
+wrapr,let,-1,0,6,null,1
+wrapr,let,-1,0,7,list<character | double[]>,1
+wrapr,let,0,0,0,character[],1
+wrapr,let,0,0,1,list<any>,1
+wrapr,let,0,0,2,null,1
+wrapr,let,1,0,0,any,1
+wrapr,let,2,0,0,...,1
+wrapr,let,3,0,0,environment,1
+wrapr,let,4,0,0,character,1
+wrapr,let,5,0,0,logical,1
+wrapr,let,6,0,0,logical,1
+wrapr,let,7,0,0,logical,1
+wrapr,letprep_lang,-1,0,0,character,1
+wrapr,letprep_lang,-1,0,1,class<`<-`>,1
+wrapr,letprep_lang,-1,0,2,class<`=`>,1
+wrapr,letprep_lang,-1,0,3,class<`{`>,1
+wrapr,letprep_lang,-1,0,4,class<`call`>,1
+wrapr,letprep_lang,-1,0,5,class<`name`>,1
+wrapr,letprep_lang,-1,0,6,double,1
+wrapr,letprep_lang,-1,0,7,pairlist,1
+wrapr,letprep_lang,0,0,0,any,1
+wrapr,letprep_lang,1,0,0,character,1
+wrapr,letprep_lang,1,0,1,class<`<-`>,1
+wrapr,letprep_lang,1,0,2,class<`=`>,1
+wrapr,letprep_lang,1,0,3,class<`{`>,1
+wrapr,letprep_lang,1,0,4,class<`call`>,1
+wrapr,letprep_lang,1,0,5,class<`name`>,1
+wrapr,letprep_lang,1,0,6,double,1
+wrapr,letprep_lang,1,0,7,pairlist,1
+wrapr,letprep_str,-1,0,0,expression,1
+wrapr,letprep_str,0,0,0,list<character>,1
+wrapr,letprep_str,1,0,0,character,1
+wrapr,locum,-1,0,0,class<`locum`>,1
+wrapr,makeFunction_se,-1,0,0,class<`function`>,1
+wrapr,makeFunction_se,0,0,0,list<class<`name`>>,1
+wrapr,makeFunction_se,0,0,1,character[],1
+wrapr,makeFunction_se,0,0,2,class<`name`>,1
+wrapr,makeFunction_se,1,0,0,class<`call`>,1
+wrapr,makeFunction_se,1,0,1,class<`{`>,1
+wrapr,makeFunction_se,2,0,0,environment,1
+wrapr,mapsyms,-1,0,0,list<character>,1
+wrapr,mapsyms,0,0,0,...,1
+wrapr,map_to_char,-1,0,0,character,1
+wrapr,map_to_char,0,0,0,^character[],1
+wrapr,map_to_char,0,0,1,^double[],1
+wrapr,map_to_char,1,0,0,...,1
+wrapr,map_to_char,2,0,0,character,1
+wrapr,map_to_char,3,0,0,character,1
+wrapr,map_to_char,4,0,0,class<`function`>,1
+wrapr,map_upper,-1,0,0,list<character>,1
+wrapr,map_upper,0,0,0,...,1
+wrapr,match_order,-1,0,0,integer[],1
+wrapr,match_order,0,0,0,double[],1
+wrapr,match_order,1,0,0,double[],1
+wrapr,mk_formula,-1,0,0,class<`formula`>,1
+wrapr,mk_formula,0,0,0,character,1
+wrapr,mk_formula,1,0,0,character[],1
+wrapr,mk_formula,1,0,1,null,1
+wrapr,mk_formula,2,0,0,...,1
+wrapr,mk_formula,3,0,0,logical,1
+wrapr,mk_formula,4,0,0,double,1
+wrapr,mk_formula,4,0,1,null,1
+wrapr,mk_formula,5,0,0,character,1
+wrapr,mk_formula,6,0,0,environment,1
+wrapr,mk_formula,7,0,0,null,1
+wrapr,mk_tmp_name_source,-1,0,0,class<`function`>,1
+wrapr,mk_tmp_name_source,0,0,0,character,1
+wrapr,mk_tmp_name_source,1,0,0,...,1
+wrapr,mk_tmp_name_source,2,0,0,character[],1
+wrapr,mk_tmp_name_source,3,0,0,double,1
+wrapr,mk_tmp_name_source,4,0,0,character,1
+wrapr,mk_unpack_single_arg_fn,-1,0,0,class<`UnpackTarget`>,1
+wrapr,mk_unpack_single_arg_fn,0,0,0,character[],1
+wrapr,mk_unpack_single_arg_fn,1,0,0,character,1
+wrapr,mk_unpack_single_arg_fn,2,0,0,character,1
+wrapr,orderv,-1,0,0,integer[],1
+wrapr,orderv,0,0,0,class<`data.frame`>,1
+wrapr,orderv,0,0,1,list<double[]>,1
+wrapr,orderv,1,0,0,...,1
+wrapr,orderv,2,0,0,logical,1
+wrapr,orderv,3,0,0,logical,1
+wrapr,orderv,4,0,0,character[],1
+wrapr,%p%,-1,0,0,character[],1
+wrapr,%p%,0,0,0,character[],1
+wrapr,%p%,1,0,0,character,1
+wrapr,parLapplyLBm,-1,0,0,list<double>,1
+wrapr,parLapplyLBm,0,0,0,"class<`SOCKcluster`, `cluster`>",1
+wrapr,parLapplyLBm,1,0,0,double[],1
+wrapr,parLapplyLBm,2,0,0,class<`function`>,1
+wrapr,parLapplyLBm,3,0,0,...,1
+wrapr,parLapplyLBm,4,0,0,null,1
+wrapr,partition_tables,-1,0,0,list<list<class<`data.frame`>>>,1
+wrapr,partition_tables,0,0,0,character[],1
+wrapr,partition_tables,1,0,0,character,1
+wrapr,partition_tables,2,0,0,...,1
+wrapr,partition_tables,3,0,0,null,1
+wrapr,partition_tables,4,0,0,null,1
+wrapr,partition_tables,5,0,0,list<class<`data.frame`>>,1
+wrapr,partition_tables,6,0,0,any,1
+wrapr,pipe_impl,-1,0,0,any,1
+wrapr,pipe_impl,0,0,0,double,1
+wrapr,pipe_impl,0,0,1,character,1
+wrapr,pipe_impl,0,0,2,class<`call`>,1
+wrapr,pipe_impl,0,0,3,class<`name`>,1
+wrapr,pipe_impl,0,0,4,class<`(`>,1
+wrapr,pipe_impl,1,0,0,class<`name`>,1
+wrapr,pipe_impl,1,0,1,character,1
+wrapr,pipe_impl,1,0,2,class<`call`>,1
+wrapr,pipe_impl,1,0,3,double,1
+wrapr,pipe_impl,1,0,4,class<`{`>,1
+wrapr,pipe_impl,1,0,5,class<`(`>,1
+wrapr,pipe_impl,2,0,0,environment,1
+wrapr,pipe_impl,3,0,0,any,1
+wrapr,pkgfn,-1,0,0,class<`PartialNamedFn`>,1
+wrapr,pkgfn,0,0,0,character,1
+wrapr,pkgfn,1,0,0,character,1
+wrapr,pkgfn,2,0,0,list<any>,1
+wrapr,prepareAlias,-1,0,0,list<any>,1
+wrapr,prepareAlias,0,0,0,list<any>,1
+wrapr,prepareAlias,0,0,1,null,1
+wrapr,prepareAlias,0,0,2,character[],1
+wrapr,prepareAlias,1,0,0,logical,1
+wrapr,print.locum,-1,0,0,null,1
+wrapr,print.locum,0,0,0,class<`locum`>,1
+wrapr,print.locum,1,0,0,...,1
+wrapr,psagg,-1,0,0,character,1
+wrapr,psagg,0,0,0,character[],1
+wrapr,psagg,1,0,0,...,1
+wrapr,psagg,2,0,0,logical,1
+wrapr,qae,-1,0,0,character[],1
+wrapr,qae,0,0,0,...,1
+wrapr,qc,-1,0,0,character[],1
+wrapr,qc,0,0,0,...,1
+wrapr,qc,1,0,0,environment,1
+wrapr,%qc%,-1,0,0,character[],1
+wrapr,%qc%,0,0,0,any,1
+wrapr,%qc%,1,0,0,any,1
+wrapr,qchar_frame,-1,0,0,class<`data.frame`>,1
+wrapr,qchar_frame,0,0,0,...,1
+wrapr,qe,-1,0,0,character[],1
+wrapr,qe,0,0,0,...,1
+wrapr,qs,-1,0,0,class<`call`>,1
+wrapr,qs,0,0,0,any,1
+wrapr,reduceexpand,-1,0,0,integer,1
+wrapr,reduceexpand,0,0,0,class<`call`>,1
+wrapr,reduceexpand,0,0,1,class<`name`>,1
+wrapr,reduceexpand,1,0,0,integer[],1
+wrapr,reduceexpand,2,0,0,environment,1
+wrapr,restrictToNameAssignments,-1,0,0,list<character>,1
+wrapr,restrictToNameAssignments,0,0,0,list<character>,1
+wrapr,restrictToNameAssignments,1,0,0,logical,1
+wrapr,r_plus,-1,0,0,class<`call`>,1
+wrapr,r_plus,-1,0,1,class<`name`>,1
+wrapr,r_plus,-1,0,2,double,1
+wrapr,r_plus,0,0,0,character[],1
+wrapr,r_plus,0,0,1,null,1
+wrapr,r_plus,1,0,0,logical,1
+wrapr,seqi,-1,0,0,double[],1
+wrapr,seqi,0,0,0,double,1
+wrapr,seqi,1,0,0,double,1
+wrapr,sequence_as_function,-1,0,0,class<`function`>,1
+wrapr,sequence_as_function,0,0,0,class<`Collector`>,1
+wrapr,sequence_as_function,1,0,0,environment,1
+wrapr,sinterp,-1,0,0,character[],1
+wrapr,sinterp,0,0,0,character,1
+wrapr,sinterp,1,0,0,...,1
+wrapr,sinterp,2,0,0,class<`data.frame`>,1
+wrapr,sinterp,2,0,1,environment,1
+wrapr,sinterp,2,0,2,list<double>,1
+wrapr,sinterp,3,0,0,environment,1
+wrapr,sinterp,4,0,0,character,1
+wrapr,sinterp,5,0,0,character[],1
+wrapr,sortv,-1,0,0,class<`data.frame`>,1
+wrapr,sortv,0,0,0,class<`data.frame`>,1
+wrapr,sortv,1,0,0,character[],1
+wrapr,sortv,2,0,0,...,1
+wrapr,sortv,3,0,0,logical,1
+wrapr,sortv,4,0,0,logical,1
+wrapr,sortv,5,0,0,character[],1
+wrapr,split_at_brace_pairs,-1,0,0,list<character[]>,1
+wrapr,split_at_brace_pairs,-1,0,1,character[],1
+wrapr,split_at_brace_pairs,0,0,0,list<character>,1
+wrapr,split_at_brace_pairs,0,0,1,character[],1
+wrapr,split_at_brace_pairs,1,0,0,character,1
+wrapr,split_at_brace_pairs,2,0,0,character,1
+wrapr,srcfn,-1,0,0,class<`SrcFunction`>,1
+wrapr,srcfn,0,0,0,character,1
+wrapr,srcfn,1,0,0,character,1
+wrapr,srcfn,2,0,0,list<double>,1
+wrapr,stop_if_dot_args,-1,0,0,any,1
+wrapr,stop_if_dot_args,0,0,0,class<`call`>,1
+wrapr,stop_if_dot_args,1,0,0,character,1
+wrapr,strsplit_capture,-1,0,0,list<character>,1
+wrapr,strsplit_capture,0,0,0,character,1
+wrapr,strsplit_capture,1,0,0,character,1
+wrapr,strsplit_capture,2,0,0,...,1
+wrapr,strsplit_capture,3,0,0,logical,1
+wrapr,strsplit_capture,4,0,0,logical,1
+wrapr,strsplit_capture,5,0,0,logical,1
+wrapr,strsplit_capture,6,0,0,logical,1
+wrapr,to,-1,0,0,class<`UnpackTarget`>,1
+wrapr,to,0,0,0,...,1
+wrapr,to_vector,-1,0,0,^character[],1
+wrapr,to_vector,-1,0,1,class<`Date`>,1
+wrapr,to_vector,-1,0,2,^double[],1
+wrapr,to_vector,0,0,0,list<character | null>,1
+wrapr,to_vector,0,0,1,list<character>,1
+wrapr,to_vector,0,0,2,list<class<`Date`>>,1
+wrapr,to_vector,0,0,3,list<double | null>,1
+wrapr,to_vector,0,0,4,list<double>,1
+wrapr,uniques,-1,0,0,any,1
+wrapr,uniques,0,0,0,any,1
+wrapr,uniques,1,0,0,...,1
+wrapr,uniques,2,0,0,logical,1
+wrapr,uniques,3,0,0,double,1
+wrapr,uniques,4,0,0,logical,1
+wrapr,unpack,-1,0,0,any,1
+wrapr,unpack,0,0,0,list<class<`data.frame`>>,1
+wrapr,unpack,1,0,0,...,1
+wrapr,[<-.Unpacker,-1,0,0,class<`Unpacker`>,1
+wrapr,[<-.Unpacker,0,0,0,class<`Unpacker`>,1
+wrapr,[<-.Unpacker,1,0,0,...,1
+wrapr,[<-.Unpacker,2,0,0,list<double>,1
+wrapr,[<-.Unpacker,2,0,1,list<class<`data.frame`>>,1
+wrapr,[.Unpacker,-1,0,0,class<`UnpackTarget`>,1
+wrapr,[.Unpacker,0,0,0,class<`Unpacker`>,1
+wrapr,[.Unpacker,1,0,0,...,1
+wrapr,unpack_impl,-1,0,0,any,1
+wrapr,unpack_impl,0,0,0,...,1
+wrapr,unpack_impl,1,0,0,environment,1
+wrapr,unpack_impl,2,0,0,list<class<`data.frame`>>,1
+wrapr,unpack_impl,2,0,1,list<double>,1
+wrapr,unpack_impl,3,0,0,character[],1
+wrapr,unpack_impl,4,0,0,null,1
+wrapr,unpack_impl,4,0,1,character,1
+wrapr,unpack_impl,5,0,0,any,1
+wrapr,validate_assignment_named_map,-1,0,0,character[],1
+wrapr,validate_assignment_named_map,0,0,0,character[],1
+wrapr,validate_assignment_named_map,1,0,0,character,1
+wrapr,validate_assignment_named_map,1,0,1,null,1
+wrapr,validate_positional_targets,-1,0,0,character[],1
+wrapr,validate_positional_targets,0,0,0,character[],1
+wrapr,validate_positional_targets,1,0,0,character,1
+wrapr,validate_positional_targets,1,0,1,null,1
+wrapr,validate_source_names,-1,0,0,character[],1
+wrapr,validate_source_names,0,0,0,character[],1
+wrapr,vapplym,-1,0,0,double[],1
+wrapr,vapplym,0,0,0,double[],1
+wrapr,vapplym,1,0,0,class<`function`>,1
+wrapr,vapplym,2,0,0,double,1
+wrapr,vapplym,3,0,0,...,1
+wrapr,vapplym,4,0,0,logical,1
+wrapr,VectorizeM,-1,0,0,class<`function`>,1
+wrapr,VectorizeM,0,0,0,class<`function`>,1
+wrapr,VectorizeM,1,0,0,character,1
+wrapr,VectorizeM,2,0,0,logical,1
+wrapr,VectorizeM,3,0,0,logical,1
+wrapr,VectorizeM,4,0,0,logical,1
+wrapr,view,-1,0,0,class<`knitr_kable`>,1
+wrapr,view,0,0,0,class<`data.frame`>,1
+wrapr,view,1,0,0,...,1
+wrapr,view,2,0,0,any,1
+wrapr,view,3,0,0,double,1
+wrapr,view.data.frame,-1,0,0,class<`knitr_kable`>,1
+wrapr,view.data.frame,0,0,0,class<`data.frame`>,1
+wrapr,view.data.frame,1,0,0,...,1
+wrapr,view.data.frame,2,0,0,character,1
+wrapr,view.data.frame,3,0,0,double,1
+wrapr,wrapfn,-1,0,0,class<`PartialFunction`>,1
+wrapr,wrapfn,0,0,0,class<`function`>,1
+wrapr,wrapfn,1,0,0,character,1
+wrapr,wrapfn,2,0,0,list<any>,1
+wrapr,wrapr_deparse,-1,0,0,character,1
+wrapr,wrapr_deparse,0,0,0,class<`<-`>,1
+wrapr,wrapr_deparse,0,0,1,class<`{`>,1
+wrapr,wrapr_deparse,0,0,2,class<`call`>,1
+wrapr,wrapr_deparse,0,0,3,class<`name`>,1
+wrapr,wrapr_deparse,0,0,4,double,1
+wrapr,write_values_into_env,-1,0,0,any,1
+wrapr,write_values_into_env,0,0,0,environment,1
+wrapr,write_values_into_env,1,0,0,character[],1
+wrapr,write_values_into_env,2,0,0,list<class<`data.frame`>>,1
+wrapr,write_values_into_env,2,0,1,list<double>,1
+xlsx,addAutoFilter,-1,0,0,class<`jobjRef`>,1
+xlsx,addAutoFilter,0,0,0,class<`jobjRef`>,1
+xlsx,addAutoFilter,1,0,0,character,1
+xlsx,addDataFrame,-1,0,0,class<`CellBlock`>,1
+xlsx,addDataFrame,0,0,0,class<`data.frame`>,1
+xlsx,addDataFrame,1,0,0,class<`jobjRef`>,1
+xlsx,addDataFrame,2,0,0,logical,1
+xlsx,addDataFrame,3,0,0,logical,1
+xlsx,addDataFrame,4,0,0,double,1
+xlsx,addDataFrame,5,0,0,double,1
+xlsx,addDataFrame,6,0,0,list<class<`CellStyle`>>,1
+xlsx,addDataFrame,7,0,0,class<`CellStyle`>,1
+xlsx,addDataFrame,7,0,1,null,1
+xlsx,addDataFrame,8,0,0,null,1
+xlsx,addDataFrame,8,0,1,class<`CellStyle`>,1
+xlsx,addHyperlink,-1,0,0,null,1
+xlsx,addHyperlink,0,0,0,class<`jobjRef`>,1
+xlsx,addHyperlink,1,0,0,character,1
+xlsx,addHyperlink,2,0,0,character[],1
+xlsx,addHyperlink,3,0,0,null,1
+xlsx,addMergedRegion,-1,0,0,integer,1
+xlsx,addMergedRegion,0,0,0,class<`jobjRef`>,1
+xlsx,addMergedRegion,1,0,0,double,1
+xlsx,addMergedRegion,2,0,0,double,1
+xlsx,addMergedRegion,3,0,0,double,1
+xlsx,addMergedRegion,4,0,0,double,1
+xlsx,addPicture,-1,0,0,class<`jobjRef`>,1
+xlsx,addPicture,0,0,0,character,1
+xlsx,addPicture,1,0,0,class<`jobjRef`>,1
+xlsx,addPicture,2,0,0,double,1
+xlsx,addPicture,3,0,0,double,1
+xlsx,addPicture,4,0,0,double,1
+xlsx,Alignment,-1,0,0,class<`Alignment`>,1
+xlsx,Alignment,0,0,0,character,1
+xlsx,Alignment,1,0,0,character,1
+xlsx,Alignment,1,0,1,null,1
+xlsx,Alignment,2,0,0,logical,1
+xlsx,Alignment,3,0,0,double,1
+xlsx,Alignment,4,0,0,double,1
+xlsx,Border,-1,0,0,class<`Border`>,1
+xlsx,Border,0,0,0,character,1
+xlsx,Border,1,0,0,character[],1
+xlsx,Border,2,0,0,character[],1
+xlsx,CB.setBorder,-1,0,0,null,1
+xlsx,CB.setBorder,0,0,0,class<`CellBlock`>,1
+xlsx,CB.setBorder,1,0,0,class<`Border`>,1
+xlsx,CB.setBorder,2,0,0,double,1
+xlsx,CB.setBorder,3,0,0,integer[],1
+xlsx,CB.setColData,-1,0,0,null,1
+xlsx,CB.setColData,0,0,0,class<`CellBlock`>,1
+xlsx,CB.setColData,1,0,0,integer[],1
+xlsx,CB.setColData,2,0,0,double,1
+xlsx,CB.setColData,3,0,0,double,1
+xlsx,CB.setColData,4,0,0,logical,1
+xlsx,CB.setColData,5,0,0,null,1
+xlsx,CB.setFill,-1,0,0,null,1
+xlsx,CB.setFill,0,0,0,class<`CellBlock`>,1
+xlsx,CB.setFill,1,0,0,class<`Fill`>,1
+xlsx,CB.setFill,2,0,0,double[],1
+xlsx,CB.setFill,3,0,0,double[],1
+xlsx,CB.setMatrixData,-1,0,0,null,1
+xlsx,CB.setMatrixData,0,0,0,class<`CellBlock`>,1
+xlsx,CB.setMatrixData,1,0,0,class<`matrix`>,1
+xlsx,CB.setMatrixData,2,0,0,double,1
+xlsx,CB.setMatrixData,3,0,0,double,1
+xlsx,CB.setMatrixData,4,0,0,logical,1
+xlsx,CB.setMatrixData,5,0,0,class<`CellStyle`>,1
+xlsx,CB.setRowData,-1,0,0,null,1
+xlsx,CB.setRowData,0,0,0,class<`CellBlock`>,1
+xlsx,CB.setRowData,1,0,0,integer[],1
+xlsx,CB.setRowData,2,0,0,double,1
+xlsx,CB.setRowData,3,0,0,double,1
+xlsx,CB.setRowData,4,0,0,logical,1
+xlsx,CB.setRowData,5,0,0,null,1
+xlsx,CellBlock,-1,0,0,class<`CellBlock`>,1
+xlsx,CellBlock,0,0,0,class<`jobjRef`>,1
+xlsx,CellBlock,1,0,0,double,1
+xlsx,CellBlock,2,0,0,double,1
+xlsx,CellBlock,3,0,0,double,1
+xlsx,CellBlock,4,0,0,double,1
+xlsx,CellBlock,5,0,0,logical,1
+xlsx,CellBlock.default,-1,0,0,class<`CellBlock`>,1
+xlsx,CellBlock.default,0,0,0,class<`jobjRef`>,1
+xlsx,CellBlock.default,1,0,0,double,1
+xlsx,CellBlock.default,2,0,0,double,1
+xlsx,CellBlock.default,3,0,0,double,1
+xlsx,CellBlock.default,4,0,0,double,1
+xlsx,CellBlock.default,5,0,0,logical,1
+xlsx,CellProtection,-1,0,0,class<`CellProtection`>,1
+xlsx,CellProtection,0,0,0,logical,1
+xlsx,CellProtection,1,0,0,logical,1
+xlsx,CellStyle,-1,0,0,class<`CellStyle`>,1
+xlsx,CellStyle,0,0,0,class<`jobjRef`>,1
+xlsx,CellStyle,1,0,0,null,1
+xlsx,CellStyle,2,0,0,null,1
+xlsx,CellStyle,3,0,0,null,1
+xlsx,CellStyle,4,0,0,null,1
+xlsx,CellStyle,5,0,0,null,1
+xlsx,CellStyle,6,0,0,null,1
+xlsx,+.CellStyle,-1,0,0,class<`CellStyle`>,1
+xlsx,+.CellStyle,0,0,0,class<`CellStyle`>,1
+xlsx,+.CellStyle,1,0,0,class<`Alignment`>,1
+xlsx,+.CellStyle,1,0,1,class<`Border`>,1
+xlsx,+.CellStyle,1,0,2,class<`DataFormat`>,1
+xlsx,+.CellStyle,1,0,3,class<`Fill`>,1
+xlsx,+.CellStyle,1,0,4,class<`Font`>,1
+xlsx,CellStyle.default,-1,0,0,class<`CellStyle`>,1
+xlsx,CellStyle.default,0,0,0,class<`jobjRef`>,1
+xlsx,CellStyle.default,1,0,0,class<`DataFormat`>,1
+xlsx,CellStyle.default,1,0,1,null,1
+xlsx,CellStyle.default,2,0,0,class<`Alignment`>,1
+xlsx,CellStyle.default,2,0,1,null,1
+xlsx,CellStyle.default,3,0,0,null,1
+xlsx,CellStyle.default,3,0,1,class<`Border`>,1
+xlsx,CellStyle.default,4,0,0,class<`Fill`>,1
+xlsx,CellStyle.default,4,0,1,null,1
+xlsx,CellStyle.default,5,0,0,class<`Font`>,1
+xlsx,CellStyle.default,5,0,1,null,1
+xlsx,CellStyle.default,6,0,0,null,1
+xlsx,createCell,-1,0,0,class<`matrix`>,1
+xlsx,createCell,0,0,0,list<class<`jobjRef`>>,1
+xlsx,createCell,1,0,0,integer[],1
+xlsx,createCellComment,-1,0,0,class<`jobjRef`>,1
+xlsx,createCellComment,0,0,0,class<`jobjRef`>,1
+xlsx,createCellComment,1,0,0,character,1
+xlsx,createCellComment,2,0,0,character,1
+xlsx,createCellComment,3,0,0,logical,1
+xlsx,createFreezePane,-1,0,0,null,1
+xlsx,createFreezePane,0,0,0,class<`jobjRef`>,1
+xlsx,createFreezePane,1,0,0,double,1
+xlsx,createFreezePane,2,0,0,double,1
+xlsx,createFreezePane,3,0,0,double,1
+xlsx,createFreezePane,4,0,0,double,1
+xlsx,createRow,-1,0,0,list<class<`jobjRef`>>,1
+xlsx,createRow,0,0,0,class<`jobjRef`>,1
+xlsx,createRow,1,0,0,integer[],1
+xlsx,createSheet,-1,0,0,class<`jobjRef`>,1
+xlsx,createSheet,0,0,0,class<`jobjRef`>,1
+xlsx,createSheet,1,0,0,character,1
+xlsx,createSplitPane,-1,0,0,null,1
+xlsx,createSplitPane,0,0,0,class<`jobjRef`>,1
+xlsx,createSplitPane,1,0,0,double,1
+xlsx,createSplitPane,2,0,0,double,1
+xlsx,createSplitPane,3,0,0,double,1
+xlsx,createSplitPane,4,0,0,double,1
+xlsx,createSplitPane,5,0,0,character,1
+xlsx,createWorkbook,-1,0,0,class<`jobjRef`>,1
+xlsx,createWorkbook,0,0,0,character,1
+xlsx,DataFormat,-1,0,0,class<`DataFormat`>,1
+xlsx,DataFormat,0,0,0,character,1
+xlsx,Fill,-1,0,0,class<`Fill`>,1
+xlsx,Fill,0,0,0,character,1
+xlsx,Fill,1,0,0,character,1
+xlsx,Fill,2,0,0,character,1
+xlsx,Font,-1,0,0,class<`Font`>,1
+xlsx,Font,0,0,0,class<`jobjRef`>,1
+xlsx,Font,1,0,0,character,1
+xlsx,Font,1,0,1,null,1
+xlsx,Font,2,0,0,null,1
+xlsx,Font,2,0,1,double,1
+xlsx,Font,3,0,0,null,1
+xlsx,Font,3,0,1,character,1
+xlsx,Font,4,0,0,logical,1
+xlsx,Font,5,0,0,logical,1
+xlsx,Font,6,0,0,logical,1
+xlsx,Font,7,0,0,double,1
+xlsx,Font,7,0,1,null,1
+xlsx,Font,8,0,0,null,1
+xlsx,getCellComment,-1,0,0,class<`jobjRef`>,1
+xlsx,getCellComment,0,0,0,class<`jobjRef`>,1
+xlsx,getCells,-1,0,0,list<class<`jobjRef`>>,1
+xlsx,getCells,0,0,0,list<class<`jobjRef`>>,1
+xlsx,getCells,1,0,0,null,1
+xlsx,getCells,2,0,0,logical,1
+xlsx,getRanges,-1,0,0,list<class<`jobjRef`>>,1
+xlsx,getRanges,0,0,0,class<`jobjRef`>,1
+xlsx,getRows,-1,0,0,list<class<`jobjRef`>>,1
+xlsx,getRows,0,0,0,class<`jobjRef`>,1
+xlsx,getRows,1,0,0,null,1
+xlsx,getSheets,-1,0,0,list<class<`jobjRef`>>,1
+xlsx,getSheets,0,0,0,class<`jobjRef`>,1
+xlsx,is.Alignment,-1,0,0,logical,1
+xlsx,is.Alignment,0,0,0,class<`Alignment`>,1
+xlsx,is.Alignment,0,0,1,class<`Border`>,1
+xlsx,is.Alignment,0,0,2,class<`Fill`>,1
+xlsx,is.Alignment,0,0,3,class<`Font`>,1
+xlsx,is.Border,-1,0,0,logical,1
+xlsx,is.Border,0,0,0,class<`Border`>,1
+xlsx,is.Border,0,0,1,class<`Fill`>,1
+xlsx,is.Border,0,0,2,class<`Font`>,1
+xlsx,is.CellStyle,-1,0,0,logical,1
+xlsx,is.CellStyle,0,0,0,class<`Alignment`>,1
+xlsx,is.CellStyle,0,0,1,class<`Border`>,1
+xlsx,is.CellStyle,0,0,2,class<`DataFormat`>,1
+xlsx,is.CellStyle,0,0,3,class<`Fill`>,1
+xlsx,is.CellStyle,0,0,4,class<`Font`>,1
+xlsx,is.DataFormat,-1,0,0,logical,1
+xlsx,is.DataFormat,0,0,0,class<`Alignment`>,1
+xlsx,is.DataFormat,0,0,1,class<`Border`>,1
+xlsx,is.DataFormat,0,0,2,class<`DataFormat`>,1
+xlsx,is.DataFormat,0,0,3,class<`Fill`>,1
+xlsx,is.DataFormat,0,0,4,class<`Font`>,1
+xlsx,is.Fill,-1,0,0,logical,1
+xlsx,is.Fill,0,0,0,class<`Fill`>,1
+xlsx,is.Fill,0,0,1,class<`Font`>,1
+xlsx,is.Font,-1,0,0,logical,1
+xlsx,is.Font,0,0,0,class<`Font`>,1
+xlsx,loadWorkbook,-1,0,0,class<`jobjRef`>,1
+xlsx,loadWorkbook,0,0,0,character,1
+xlsx,loadWorkbook,1,0,0,null,1
+xlsx,printSetup,-1,0,0,class<`jobjRef`>,1
+xlsx,printSetup,0,0,0,class<`jobjRef`>,1
+xlsx,printSetup,1,0,0,null,1
+xlsx,printSetup,2,0,0,null,1
+xlsx,printSetup,3,0,0,double,1
+xlsx,printSetup,4,0,0,null,1
+xlsx,printSetup,5,0,0,null,1
+xlsx,printSetup,6,0,0,null,1
+xlsx,printSetup,7,0,0,logical,1
+xlsx,printSetup,8,0,0,null,1
+xlsx,.Rcolor2XLcolor,-1,0,0,list<class<`jobjRef`>>,1
+xlsx,.Rcolor2XLcolor,0,0,0,character[],1
+xlsx,.Rcolor2XLcolor,1,0,0,logical,1
+xlsx,removeRow,-1,0,0,null,1
+xlsx,removeRow,0,0,0,class<`jobjRef`>,1
+xlsx,removeRow,1,0,0,list<class<`jobjRef`>>,1
+xlsx,saveWorkbook,-1,0,0,null,1
+xlsx,saveWorkbook,0,0,0,class<`jobjRef`>,1
+xlsx,saveWorkbook,1,0,0,character,1
+xlsx,saveWorkbook,2,0,0,null,1
+xlsx,setCellStyle,-1,0,0,null,1
+xlsx,setCellStyle,0,0,0,class<`jobjRef`>,1
+xlsx,setCellStyle,1,0,0,class<`CellStyle`>,1
+xlsx,setCellValue,-1,0,0,null,1
+xlsx,setCellValue,0,0,0,class<`jobjRef`>,1
+xlsx,setCellValue,1,0,0,character,1
+xlsx,setCellValue,1,0,1,double,1
+xlsx,setCellValue,2,0,0,logical,1
+xlsx,setCellValue,3,0,0,logical,1
+xlsx,setColumnWidth,-1,0,0,null,1
+xlsx,setColumnWidth,0,0,0,class<`jobjRef`>,1
+xlsx,setColumnWidth,1,0,0,double,1
+xlsx,setColumnWidth,2,0,0,double,1
+xlsx,set_java_tmp_dir,-1,0,0,character,1
+xlsx,set_java_tmp_dir,0,0,0,character,1
+xlsx,setRowHeight,-1,0,0,null,1
+xlsx,setRowHeight,0,0,0,list<class<`jobjRef`>>,1
+xlsx,setRowHeight,1,0,0,any,1
+xlsx,setRowHeight,2,0,0,double,1
+xlsx,setZoom,-1,0,0,null,1
+xlsx,setZoom,0,0,0,class<`jobjRef`>,1
+xlsx,setZoom,1,0,0,double,1
+xlsx,setZoom,2,0,0,double,1
+xlsx,.xssfcolor,-1,0,0,class<`jobjRef`>,1
+xlsx,.xssfcolor,0,0,0,character,1
+xml2,as.character.xml_document,-1,0,0,character,1
+xml2,as.character.xml_document,0,0,0,class<`xml_document`>,1
+xml2,as.character.xml_document,0,0,1,"class<`xml_document`, `xml_node`>",1
+xml2,as.character.xml_document,1,0,0,...,1
+xml2,as.character.xml_document,2,0,0,character,1
+xml2,as.character.xml_document,3,0,0,character,1
+xml2,as_list,-1,0,0,character,1
+xml2,as_list,-1,0,1,list<any>,1
+xml2,as_list,0,0,0,class<`xml_node`>,1
+xml2,as_list,0,0,1,"class<`xml_document`, `xml_node`>",1
+xml2,as_list,1,0,0,any,1
+xml2,as_list,2,0,0,...,1
+xml2,as_list.xml_document,-1,0,0,list<list<any>>,1
+xml2,as_list.xml_document,0,0,0,"class<`xml_document`, `xml_node`>",1
+xml2,as_list.xml_document,1,0,0,any,1
+xml2,as_list.xml_document,2,0,0,...,1
+xml2,as_list.xml_node,-1,0,0,character,1
+xml2,as_list.xml_node,-1,0,1,list<any>,1
+xml2,as_list.xml_node,0,0,0,class<`xml_node`>,1
+xml2,as_list.xml_node,0,0,1,"class<`xml_document`, `xml_node`>",1
+xml2,as_list.xml_node,1,0,0,any,1
+xml2,as_list.xml_node,2,0,0,...,1
+xml2,as_xml_document,-1,0,0,"class<`xml_document`, `xml_node`>",1
+xml2,as_xml_document,0,0,0,class<`xml_nodeset`>,1
+xml2,as_xml_document,0,0,1,list<list<any>>,1
+xml2,as_xml_document,1,0,0,...,1
+xml2,as_xml_document.list,-1,0,0,"class<`xml_document`, `xml_node`>",1
+xml2,as_xml_document.list,0,0,0,list<list<any>>,1
+xml2,as_xml_document.list,1,0,0,...,1
+xml2,as_xml_document.xml_nodeset,-1,0,0,"class<`xml_document`, `xml_node`>",1
+xml2,as_xml_document.xml_nodeset,0,0,0,class<`xml_nodeset`>,1
+xml2,as_xml_document.xml_nodeset,1,0,0,character,1
+xml2,as_xml_document.xml_nodeset,2,0,0,...,1
+xml2,check_path,-1,0,0,character,1
+xml2,check_path,0,0,0,character,1
+xml2,create_node,-1,0,0,"class<`xml_document`, `xml_node`>",1
+xml2,create_node,-1,0,1,class<`xml_node`>,1
+xml2,create_node,-1,0,2,null,1
+xml2,create_node,0,0,0,"class<`xml_document`, `xml_node`>",1
+xml2,create_node,0,0,1,character,1
+xml2,create_node,0,0,2,class<`xml_cdata`>,1
+xml2,create_node,0,0,3,class<`xml_comment`>,1
+xml2,create_node,0,0,4,class<`xml_node`>,1
+xml2,create_node,0,0,5,class<`xml_dtd`>,1
+xml2,create_node,1,0,0,...,1
+xml2,create_node,2,0,0,any,1
+xml2,create_node,3,0,0,any,1
+xml2,has_names,-1,0,0,logical[],1
+xml2,has_names,0,0,0,character[],1
+xml2,has_names,0,0,1,list<any>,1
+xml2,has_names,0,0,2,null,1
+xml2,html_structure,-1,0,0,null,1
+xml2,html_structure,0,0,0,"class<`xml_document`, `xml_node`>",1
+xml2,html_structure,1,0,0,double,1
+xml2,html_structure,2,0,0,character,1
+xml2,is_named,-1,0,0,logical,1
+xml2,is_named,0,0,0,character[],1
+xml2,is_named,0,0,1,list<any>,1
+xml2,is_named,0,0,2,null,1
+xml2,is.na.xml_node,-1,0,0,logical,1
+xml2,is.na.xml_node,0,0,0,class<`xml_node`>,1
+xml2,is.na.xml_nodeset,-1,0,0,logical[],1
+xml2,is.na.xml_nodeset,0,0,0,class<`xml_nodeset`>,1
+xml2,is_url,-1,0,0,logical,1
+xml2,is_url,0,0,0,character,1
+xml2,make_nodeset,-1,0,0,class<`xml_nodeset`>,1
+xml2,make_nodeset,0,0,0,list<externalptr>,1
+xml2,make_nodeset,0,0,1,list<list<any>>,1
+xml2,make_nodeset,1,0,0,externalptr,1
+xml2,nodeset_apply,-1,0,0,class<`xml_nodeset`>,1
+xml2,nodeset_apply,0,0,0,"class<`xml_document`, `xml_node`>",1
+xml2,nodeset_apply,0,0,1,class<`xml_node`>,1
+xml2,nodeset_apply,0,0,2,class<`xml_nodeset`>,1
+xml2,nodeset_apply,1,0,0,class<`function`>,1
+xml2,nodeset_apply,2,0,0,...,1
+xml2,nodeset_apply.xml_document,-1,0,0,class<`xml_nodeset`>,1
+xml2,nodeset_apply.xml_document,0,0,0,"class<`xml_document`, `xml_node`>",1
+xml2,nodeset_apply.xml_document,1,0,0,class<`function`>,1
+xml2,nodeset_apply.xml_document,2,0,0,...,1
+xml2,nodeset_apply.xml_node,-1,0,0,class<`xml_nodeset`>,1
+xml2,nodeset_apply.xml_node,0,0,0,"class<`xml_document`, `xml_node`>",1
+xml2,nodeset_apply.xml_node,0,0,1,class<`xml_node`>,1
+xml2,nodeset_apply.xml_node,1,0,0,class<`function`>,1
+xml2,nodeset_apply.xml_node,2,0,0,...,1
+xml2,nodeset_apply.xml_nodeset,-1,0,0,class<`xml_nodeset`>,1
+xml2,nodeset_apply.xml_nodeset,0,0,0,class<`xml_nodeset`>,1
+xml2,nodeset_apply.xml_nodeset,1,0,0,class<`function`>,1
+xml2,nodeset_apply.xml_nodeset,2,0,0,...,1
+xml2,parse_options,-1,0,0,integer,1
+xml2,parse_options,0,0,0,character[],1
+xml2,parse_options,0,0,1,integer,1
+xml2,parse_options,1,0,0,any,1
+xml2,path_to_connection,-1,0,0,character,1
+xml2,path_to_connection,0,0,0,character,1
+xml2,path_to_connection,1,0,0,character[],1
+xml2,print_xml_structure,-1,0,0,list<any>,1
+xml2,print_xml_structure,-1,0,1,null,1
+xml2,print_xml_structure,0,0,0,class<`xml_node`>,1
+xml2,print_xml_structure,0,0,1,"class<`xml_document`, `xml_node`>",1
+xml2,print_xml_structure,1,0,0,double,1
+xml2,print_xml_structure,2,0,0,any,1
+xml2,print_xml_structure,3,0,0,any,1
+xml2,print_xml_structure,4,0,0,character,1
+xml2,r_attrs_to_xml,-1,0,0,list<any>,1
+xml2,r_attrs_to_xml,-1,0,1,null,1
+xml2,r_attrs_to_xml,0,0,0,list<character[]>,1
+xml2,r_attrs_to_xml,0,0,1,null,1
+xml2,read_html,-1,0,0,"class<`xml_document`, `xml_node`>",1
+xml2,read_html,0,0,0,character,1
+xml2,read_html,1,0,0,character,1
+xml2,read_html,2,0,0,...,1
+xml2,read_html,3,0,0,any,1
+xml2,read_html.default,-1,0,0,"class<`xml_document`, `xml_node`>",1
+xml2,read_html.default,0,0,0,character,1
+xml2,read_html.default,1,0,0,character,1
+xml2,read_html.default,2,0,0,...,1
+xml2,read_html.default,3,0,0,character[],1
+xml2,read_xml,-1,0,0,"class<`xml_document`, `xml_node`>",1
+xml2,read_xml,0,0,0,character,1
+xml2,read_xml,1,0,0,any,1
+xml2,read_xml,2,0,0,...,1
+xml2,read_xml,3,0,0,logical,1
+xml2,read_xml,4,0,0,integer,1
+xml2,read_xml,4,0,1,character,1
+xml2,read_xml.character,-1,0,0,"class<`xml_document`, `xml_node`>",1
+xml2,read_xml.character,0,0,0,character,1
+xml2,read_xml.character,1,0,0,any,1
+xml2,read_xml.character,2,0,0,...,1
+xml2,read_xml.character,3,0,0,logical,1
+xml2,read_xml.character,4,0,0,integer,1
+xml2,read_xml.character,4,0,1,character,1
+xml2,read_xml.raw,-1,0,0,"class<`xml_document`, `xml_node`>",1
+xml2,read_xml.raw,0,0,0,raw[],1
+xml2,read_xml.raw,1,0,0,character,1
+xml2,read_xml.raw,2,0,0,character,1
+xml2,read_xml.raw,3,0,0,...,1
+xml2,read_xml.raw,4,0,0,logical,1
+xml2,read_xml.raw,5,0,0,integer,1
+xml2,tree_structure,-1,0,0,null,1
+xml2,tree_structure,0,0,0,"class<`xml_document`, `xml_node`>",1
+xml2,tree_structure,0,0,1,class<`xml_nodeset`>,1
+xml2,tree_structure,1,0,0,double,1
+xml2,tree_structure,2,0,0,logical,1
+xml2,tree_structure,3,0,0,character,1
+xml2,tree_structure.xml_node,-1,0,0,null,1
+xml2,tree_structure.xml_node,0,0,0,"class<`xml_document`, `xml_node`>",1
+xml2,tree_structure.xml_node,1,0,0,double,1
+xml2,tree_structure.xml_node,2,0,0,logical,1
+xml2,tree_structure.xml_node,3,0,0,character,1
+xml2,tree_structure.xml_nodeset,-1,0,0,null,1
+xml2,tree_structure.xml_nodeset,0,0,0,class<`xml_nodeset`>,1
+xml2,tree_structure.xml_nodeset,1,0,0,double,1
+xml2,tree_structure.xml_nodeset,2,0,0,logical,1
+xml2,tree_structure.xml_nodeset,3,0,0,character,1
+xml2,url_absolute,-1,0,0,character[],1
+xml2,url_absolute,0,0,0,character[],1
+xml2,url_absolute,1,0,0,character,1
+xml2,url_escape,-1,0,0,character,1
+xml2,url_escape,0,0,0,character,1
+xml2,url_escape,1,0,0,character,1
+xml2,url_parse,-1,0,0,class<`data.frame`>,1
+xml2,url_parse,0,0,0,character,1
+xml2,url_relative,-1,0,0,character,1
+xml2,url_relative,0,0,0,character,1
+xml2,url_relative,1,0,0,character,1
+xml2,url_unescape,-1,0,0,character,1
+xml2,url_unescape,0,0,0,character,1
+xml2,write_html,-1,0,0,null,1
+xml2,write_html,0,0,0,"class<`xml_document`, `xml_node`>",1
+xml2,write_html,1,0,0,character,1
+xml2,write_html,2,0,0,...,1
+xml2,write_html.xml_document,-1,0,0,null,1
+xml2,write_html.xml_document,0,0,0,"class<`xml_document`, `xml_node`>",1
+xml2,write_html.xml_document,1,0,0,character,1
+xml2,write_html.xml_document,2,0,0,...,1
+xml2,write_html.xml_document,3,0,0,character,1
+xml2,write_html.xml_document,4,0,0,character,1
+xml2,write_xml,-1,0,0,null,1
+xml2,write_xml,0,0,0,"class<`xml_document`, `xml_node`>",1
+xml2,write_xml,1,0,0,character,1
+xml2,write_xml,2,0,0,...,1
+xml2,write_xml.xml_document,-1,0,0,null,1
+xml2,write_xml.xml_document,0,0,0,"class<`xml_document`, `xml_node`>",1
+xml2,write_xml.xml_document,1,0,0,character,1
+xml2,write_xml.xml_document,2,0,0,...,1
+xml2,write_xml.xml_document,3,0,0,character,1
+xml2,write_xml.xml_document,4,0,0,character,1
+xml2,xml2_example,-1,0,0,character,1
+xml2,xml2_example,0,0,0,character,1
+xml2,xml_add_child,-1,0,0,class<`xml_document`>,1
+xml2,xml_add_child,-1,0,1,"class<`xml_document`, `xml_node`>",1
+xml2,xml_add_child,-1,0,2,class<`xml_node`>,1
+xml2,xml_add_child,0,0,0,class<`xml_document`>,1
+xml2,xml_add_child,0,0,1,class<`xml_node`>,1
+xml2,xml_add_child,0,0,2,"class<`xml_document`, `xml_node`>",1
+xml2,xml_add_child,1,0,0,class<`xml_dtd`>,1
+xml2,xml_add_child,1,0,1,character,1
+xml2,xml_add_child,1,0,2,"class<`xml_document`, `xml_node`>",1
+xml2,xml_add_child,1,0,3,class<`xml_cdata`>,1
+xml2,xml_add_child,1,0,4,class<`xml_comment`>,1
+xml2,xml_add_child,1,0,5,class<`xml_node`>,1
+xml2,xml_add_child,2,0,0,...,1
+xml2,xml_add_child,3,0,0,any,1
+xml2,xml_add_child,4,0,0,any,1
+xml2,xml_add_child.xml_document,-1,0,0,class<`xml_document`>,1
+xml2,xml_add_child.xml_document,-1,0,1,"class<`xml_document`, `xml_node`>",1
+xml2,xml_add_child.xml_document,-1,0,2,class<`xml_node`>,1
+xml2,xml_add_child.xml_document,0,0,0,class<`xml_document`>,1
+xml2,xml_add_child.xml_document,0,0,1,"class<`xml_document`, `xml_node`>",1
+xml2,xml_add_child.xml_document,1,0,0,class<`xml_dtd`>,1
+xml2,xml_add_child.xml_document,1,0,1,character,1
+xml2,xml_add_child.xml_document,1,0,2,class<`xml_cdata`>,1
+xml2,xml_add_child.xml_document,1,0,3,class<`xml_comment`>,1
+xml2,xml_add_child.xml_document,1,0,4,class<`xml_node`>,1
+xml2,xml_add_child.xml_document,2,0,0,...,1
+xml2,xml_add_child.xml_document,3,0,0,any,1
+xml2,xml_add_child.xml_document,4,0,0,any,1
+xml2,xml_add_child.xml_node,-1,0,0,"class<`xml_document`, `xml_node`>",1
+xml2,xml_add_child.xml_node,-1,0,1,class<`xml_node`>,1
+xml2,xml_add_child.xml_node,0,0,0,class<`xml_node`>,1
+xml2,xml_add_child.xml_node,0,0,1,"class<`xml_document`, `xml_node`>",1
+xml2,xml_add_child.xml_node,1,0,0,"class<`xml_document`, `xml_node`>",1
+xml2,xml_add_child.xml_node,1,0,1,character,1
+xml2,xml_add_child.xml_node,1,0,2,class<`xml_cdata`>,1
+xml2,xml_add_child.xml_node,1,0,3,class<`xml_comment`>,1
+xml2,xml_add_child.xml_node,1,0,4,class<`xml_node`>,1
+xml2,xml_add_child.xml_node,2,0,0,...,1
+xml2,xml_add_child.xml_node,3,0,0,integer,1
+xml2,xml_add_child.xml_node,4,0,0,any,1
+xml2,xml_add_sibling,-1,0,0,class<`xml_node`>,1
+xml2,xml_add_sibling,0,0,0,class<`xml_node`>,1
+xml2,xml_add_sibling,1,0,0,class<`xml_node`>,1
+xml2,xml_add_sibling,2,0,0,...,1
+xml2,xml_add_sibling,3,0,0,any,1
+xml2,xml_add_sibling,4,0,0,logical,1
+xml2,xml_add_sibling.xml_node,-1,0,0,class<`xml_node`>,1
+xml2,xml_add_sibling.xml_node,0,0,0,class<`xml_node`>,1
+xml2,xml_add_sibling.xml_node,1,0,0,class<`xml_node`>,1
+xml2,xml_add_sibling.xml_node,2,0,0,...,1
+xml2,xml_add_sibling.xml_node,3,0,0,character[],1
+xml2,xml_add_sibling.xml_node,4,0,0,logical,1
+xml2,xml_attr,-1,0,0,null,1
+xml2,xml_attr,-1,0,1,^character[],1
+xml2,xml_attr,0,0,0,class<`xml_node`>,1
+xml2,xml_attr,0,0,1,class<`xml_nodeset`>,1
+xml2,xml_attr,0,0,2,"class<`xml_document`, `xml_node`>",1
+xml2,xml_attr,1,0,0,character,1
+xml2,xml_attr,2,0,0,any,1
+xml2,xml_attr,3,0,0,null,1
+xml2,xml_attr<-,-1,0,0,"class<`xml_document`, `xml_node`>",1
+xml2,xml_attr<-,-1,0,1,class<`xml_node`>,1
+xml2,xml_attr<-,-1,0,2,class<`xml_nodeset`>,1
+xml2,xml_attr<-,0,0,0,"class<`xml_document`, `xml_node`>",1
+xml2,xml_attr<-,0,0,1,class<`xml_node`>,1
+xml2,xml_attr<-,0,0,2,class<`xml_nodeset`>,1
+xml2,xml_attr<-,1,0,0,character,1
+xml2,xml_attr<-,2,0,0,any,1
+xml2,xml_attr<-,3,0,0,character,1
+xml2,xml_attr<-,3,0,1,null,1
+xml2,xml_attrs,-1,0,0,character[],1
+xml2,xml_attrs,-1,0,1,list<character[]>,1
+xml2,xml_attrs,0,0,0,class<`xml_node`>,1
+xml2,xml_attrs,0,0,1,"class<`xml_document`, `xml_node`>",1
+xml2,xml_attrs,0,0,2,class<`xml_nodeset`>,1
+xml2,xml_attrs,1,0,0,any,1
+xml2,xml_attrs<-,-1,0,0,"class<`xml_document`, `xml_node`>",1
+xml2,xml_attrs<-,-1,0,1,class<`xml_node`>,1
+xml2,xml_attrs<-,0,0,0,"class<`xml_document`, `xml_node`>",1
+xml2,xml_attrs<-,0,0,1,class<`xml_node`>,1
+xml2,xml_attrs<-,1,0,0,any,1
+xml2,xml_attrs<-,2,0,0,character[],1
+xml2,xml_attrs<-,2,0,1,null,1
+xml2,xml_attrs<-,2,0,2,list<any>,1
+xml2,xml_attrs<-.xml_node,-1,0,0,"class<`xml_document`, `xml_node`>",1
+xml2,xml_attrs<-.xml_node,-1,0,1,class<`xml_node`>,1
+xml2,xml_attrs<-.xml_node,0,0,0,"class<`xml_document`, `xml_node`>",1
+xml2,xml_attrs<-.xml_node,0,0,1,class<`xml_node`>,1
+xml2,xml_attrs<-.xml_node,1,0,0,character[],1
+xml2,xml_attrs<-.xml_node,2,0,0,character[],1
+xml2,xml_attrs<-.xml_node,2,0,1,null,1
+xml2,xml_attrs<-.xml_node,2,0,2,list<any>,1
+xml2,xml_attrs.xml_node,-1,0,0,character[],1
+xml2,xml_attrs.xml_node,0,0,0,class<`xml_node`>,1
+xml2,xml_attrs.xml_node,0,0,1,"class<`xml_document`, `xml_node`>",1
+xml2,xml_attrs.xml_node,1,0,0,class<`xml_namespace`>,1
+xml2,xml_attrs.xml_node,1,0,1,character[],1
+xml2,xml_attrs.xml_nodeset,-1,0,0,list<character[]>,1
+xml2,xml_attrs.xml_nodeset,0,0,0,class<`xml_nodeset`>,1
+xml2,xml_attrs.xml_nodeset,1,0,0,character[],1
+xml2,xml_attr<-.xml_node,-1,0,0,"class<`xml_document`, `xml_node`>",1
+xml2,xml_attr<-.xml_node,-1,0,1,class<`xml_node`>,1
+xml2,xml_attr<-.xml_node,0,0,0,"class<`xml_document`, `xml_node`>",1
+xml2,xml_attr<-.xml_node,0,0,1,class<`xml_node`>,1
+xml2,xml_attr<-.xml_node,1,0,0,character,1
+xml2,xml_attr<-.xml_node,2,0,0,character[],1
+xml2,xml_attr<-.xml_node,3,0,0,character,1
+xml2,xml_attr<-.xml_node,3,0,1,null,1
+xml2,xml_attr.xml_node,-1,0,0,character,1
+xml2,xml_attr.xml_node,-1,0,1,null,1
+xml2,xml_attr.xml_node,0,0,0,"class<`xml_document`, `xml_node`>",1
+xml2,xml_attr.xml_node,0,0,1,class<`xml_node`>,1
+xml2,xml_attr.xml_node,1,0,0,character,1
+xml2,xml_attr.xml_node,2,0,0,character[],1
+xml2,xml_attr.xml_node,2,0,1,class<`xml_namespace`>,1
+xml2,xml_attr.xml_node,3,0,0,null,1
+xml2,xml_attr<-.xml_nodeset,-1,0,0,class<`xml_nodeset`>,1
+xml2,xml_attr<-.xml_nodeset,0,0,0,class<`xml_nodeset`>,1
+xml2,xml_attr<-.xml_nodeset,1,0,0,character,1
+xml2,xml_attr<-.xml_nodeset,2,0,0,character[],1
+xml2,xml_attr<-.xml_nodeset,3,0,0,null,1
+xml2,xml_attr.xml_nodeset,-1,0,0,^character[],1
+xml2,xml_attr.xml_nodeset,0,0,0,class<`xml_nodeset`>,1
+xml2,xml_attr.xml_nodeset,1,0,0,character,1
+xml2,xml_attr.xml_nodeset,2,0,0,character[],1
+xml2,xml_attr.xml_nodeset,3,0,0,null,1
+xml2,xml_cdata,-1,0,0,class<`xml_cdata`>,1
+xml2,xml_cdata,0,0,0,character,1
+xml2,xml_child,-1,0,0,class<`xml_missing`>,1
+xml2,xml_child,-1,0,1,class<`xml_node`>,1
+xml2,xml_child,0,0,0,"class<`xml_document`, `xml_node`>",1
+xml2,xml_child,1,0,0,character,1
+xml2,xml_child,1,0,1,double,1
+xml2,xml_child,2,0,0,any,1
+xml2,xml_children,-1,0,0,class<`xml_nodeset`>,1
+xml2,xml_children,0,0,0,"class<`xml_document`, `xml_node`>",1
+xml2,xml_children,0,0,1,class<`xml_node`>,1
+xml2,xml_children,0,0,2,class<`xml_nodeset`>,1
+xml2,xml_comment,-1,0,0,class<`xml_comment`>,1
+xml2,xml_comment,0,0,0,character,1
+xml2,xml_contents,-1,0,0,class<`xml_nodeset`>,1
+xml2,xml_contents,0,0,0,"class<`xml_document`, `xml_node`>",1
+xml2,xml_contents,0,0,1,class<`xml_node`>,1
+xml2,xml_document,-1,0,0,class<`xml_document`>,1
+xml2,xml_document,-1,0,1,"class<`xml_document`, `xml_node`>",1
+xml2,xml_document,0,0,0,externalptr,1
+xml2,xml_dtd,-1,0,0,class<`xml_dtd`>,1
+xml2,xml_dtd,0,0,0,character,1
+xml2,xml_dtd,1,0,0,character,1
+xml2,xml_dtd,2,0,0,character,1
+xml2,xml_find_all,-1,0,0,class<`xml_nodeset`>,1
+xml2,xml_find_all,0,0,0,"class<`xml_document`, `xml_node`>",1
+xml2,xml_find_all,0,0,1,class<`xml_nodeset`>,1
+xml2,xml_find_all,1,0,0,character,1
+xml2,xml_find_all,2,0,0,any,1
+xml2,xml_find_all.xml_node,-1,0,0,class<`xml_nodeset`>,1
+xml2,xml_find_all.xml_node,0,0,0,"class<`xml_document`, `xml_node`>",1
+xml2,xml_find_all.xml_node,1,0,0,character,1
+xml2,xml_find_all.xml_node,2,0,0,class<`xml_namespace`>,1
+xml2,xml_find_all.xml_nodeset,-1,0,0,class<`xml_nodeset`>,1
+xml2,xml_find_all.xml_nodeset,0,0,0,class<`xml_nodeset`>,1
+xml2,xml_find_all.xml_nodeset,1,0,0,character,1
+xml2,xml_find_all.xml_nodeset,2,0,0,class<`xml_namespace`>,1
+xml2,xml_find_first,-1,0,0,class<`xml_missing`>,1
+xml2,xml_find_first,-1,0,1,class<`xml_node`>,1
+xml2,xml_find_first,-1,0,2,class<`xml_nodeset`>,1
+xml2,xml_find_first,0,0,0,"class<`xml_document`, `xml_node`>",1
+xml2,xml_find_first,0,0,1,class<`xml_node`>,1
+xml2,xml_find_first,0,0,2,class<`xml_nodeset`>,1
+xml2,xml_find_first,1,0,0,character,1
+xml2,xml_find_first,2,0,0,any,1
+xml2,xml_find_first.xml_node,-1,0,0,class<`xml_missing`>,1
+xml2,xml_find_first.xml_node,-1,0,1,class<`xml_node`>,1
+xml2,xml_find_first.xml_node,0,0,0,"class<`xml_document`, `xml_node`>",1
+xml2,xml_find_first.xml_node,0,0,1,class<`xml_node`>,1
+xml2,xml_find_first.xml_node,1,0,0,character,1
+xml2,xml_find_first.xml_node,2,0,0,class<`xml_namespace`>,1
+xml2,xml_find_first.xml_node,2,0,1,character[],1
+xml2,xml_find_first.xml_nodeset,-1,0,0,class<`xml_nodeset`>,1
+xml2,xml_find_first.xml_nodeset,0,0,0,class<`xml_nodeset`>,1
+xml2,xml_find_first.xml_nodeset,1,0,0,character,1
+xml2,xml_find_first.xml_nodeset,2,0,0,class<`xml_namespace`>,1
+xml2,xml_has_attr,-1,0,0,logical[],1
+xml2,xml_has_attr,0,0,0,class<`xml_nodeset`>,1
+xml2,xml_has_attr,1,0,0,character,1
+xml2,xml_has_attr,2,0,0,character[],1
+xml2,xml_integer,-1,0,0,integer[],1
+xml2,xml_integer,0,0,0,class<`xml_node`>,1
+xml2,xml_integer,0,0,1,class<`xml_nodeset`>,1
+xml2,xml_integer.xml_node,-1,0,0,integer,1
+xml2,xml_integer.xml_node,0,0,0,class<`xml_node`>,1
+xml2,xml_integer.xml_nodeset,-1,0,0,integer[],1
+xml2,xml_integer.xml_nodeset,0,0,0,class<`xml_nodeset`>,1
+xml2,xml_length,-1,0,0,integer,1
+xml2,xml_length,0,0,0,"class<`xml_document`, `xml_node`>",1
+xml2,xml_length,1,0,0,logical,1
+xml2,xml_length.xml_node,-1,0,0,integer,1
+xml2,xml_length.xml_node,0,0,0,"class<`xml_document`, `xml_node`>",1
+xml2,xml_length.xml_node,1,0,0,logical,1
+xml2,[.xml_missing,-1,0,0,class<`xml_missing`>,1
+xml2,[.xml_missing,0,0,0,class<`xml_missing`>,1
+xml2,[.xml_missing,1,0,0,any,1
+xml2,[.xml_missing,2,0,0,...,1
+xml2,xml_missing,-1,0,0,class<`xml_missing`>,1
+xml2,xml_name,-1,0,0,character[],1
+xml2,xml_name,0,0,0,class<`xml_node`>,1
+xml2,xml_name,0,0,1,class<`xml_nodeset`>,1
+xml2,xml_name,0,0,2,"class<`xml_document`, `xml_node`>",1
+xml2,xml_name,1,0,0,any,1
+xml2,xml_name<-,-1,0,0,"class<`xml_document`, `xml_node`>",1
+xml2,xml_name<-,0,0,0,"class<`xml_document`, `xml_node`>",1
+xml2,xml_name<-,1,0,0,any,1
+xml2,xml_name<-,2,0,0,character,1
+xml2,xml_name<-.xml_node,-1,0,0,"class<`xml_document`, `xml_node`>",1
+xml2,xml_name<-.xml_node,0,0,0,"class<`xml_document`, `xml_node`>",1
+xml2,xml_name<-.xml_node,1,0,0,any,1
+xml2,xml_name<-.xml_node,2,0,0,character,1
+xml2,xml_name.xml_node,-1,0,0,character,1
+xml2,xml_name.xml_node,0,0,0,"class<`xml_document`, `xml_node`>",1
+xml2,xml_name.xml_node,0,0,1,class<`xml_node`>,1
+xml2,xml_name.xml_node,1,0,0,character[],1
+xml2,xml_name.xml_node,1,0,1,class<`xml_namespace`>,1
+xml2,xml_name.xml_nodeset,-1,0,0,character[],1
+xml2,xml_name.xml_nodeset,0,0,0,class<`xml_nodeset`>,1
+xml2,xml_name.xml_nodeset,1,0,0,character[],1
+xml2,xml_name.xml_nodeset,1,0,1,class<`xml_namespace`>,1
+xml2,xml_new_document,-1,0,0,class<`xml_document`>,1
+xml2,xml_new_document,0,0,0,character,1
+xml2,xml_new_document,1,0,0,character,1
+xml2,xml_new_root,-1,0,0,class<`xml_document`>,1
+xml2,xml_new_root,-1,0,1,"class<`xml_document`, `xml_node`>",1
+xml2,xml_new_root,0,0,0,class<`xml_dtd`>,1
+xml2,xml_new_root,0,0,1,character,1
+xml2,xml_new_root,1,0,0,...,1
+xml2,xml_new_root,2,0,0,any,1
+xml2,xml_new_root,3,0,0,character,1
+xml2,xml_new_root,4,0,0,character,1
+xml2,xml_node,-1,0,0,class<`xml_node`>,1
+xml2,xml_node,0,0,0,externalptr,1
+xml2,xml_node,1,0,0,externalptr,1
+xml2,[.xml_nodeset,-1,0,0,class<`xml_nodeset`>,1
+xml2,[.xml_nodeset,0,0,0,class<`xml_nodeset`>,1
+xml2,[.xml_nodeset,1,0,0,integer[],1
+xml2,[.xml_nodeset,2,0,0,...,1
+xml2,xml_nodeset,-1,0,0,class<`xml_nodeset`>,1
+xml2,xml_nodeset,0,0,0,class<`xml_missing`>,1
+xml2,xml_nodeset,0,0,1,list<any>,1
+xml2,xml_nodeset,1,0,0,logical,1
+xml2,xml_ns,-1,0,0,class<`xml_namespace`>,1
+xml2,xml_ns,0,0,0,"class<`xml_document`, `xml_node`>",1
+xml2,xml_ns,0,0,1,class<`xml_node`>,1
+xml2,xml_ns,0,0,2,class<`xml_nodeset`>,1
+xml2,xml_ns_rename,-1,0,0,class<`xml_namespace`>,1
+xml2,xml_ns_rename,0,0,0,class<`xml_namespace`>,1
+xml2,xml_ns_rename,1,0,0,...,1
+xml2,xml_ns_strip,-1,0,0,"class<`xml_document`, `xml_node`>",1
+xml2,xml_ns_strip,0,0,0,"class<`xml_document`, `xml_node`>",1
+xml2,xml_ns.xml_document,-1,0,0,class<`xml_namespace`>,1
+xml2,xml_ns.xml_document,0,0,0,"class<`xml_document`, `xml_node`>",1
+xml2,xml_ns.xml_node,-1,0,0,class<`xml_namespace`>,1
+xml2,xml_ns.xml_node,0,0,0,class<`xml_node`>,1
+xml2,xml_ns.xml_nodeset,-1,0,0,class<`xml_namespace`>,1
+xml2,xml_ns.xml_nodeset,0,0,0,class<`xml_nodeset`>,1
+xml2,xml_parent,-1,0,0,class<`xml_nodeset`>,1
+xml2,xml_parent,0,0,0,class<`xml_nodeset`>,1
+xml2,xml_parent.xml_nodeset,-1,0,0,class<`xml_nodeset`>,1
+xml2,xml_parent.xml_nodeset,0,0,0,class<`xml_nodeset`>,1
+xml2,xml_parse_options,-1,0,0,integer[],1
+xml2,xml_path,-1,0,0,character[],1
+xml2,xml_path,0,0,0,class<`xml_node`>,1
+xml2,xml_path,0,0,1,class<`xml_nodeset`>,1
+xml2,xml_path.xml_node,-1,0,0,character,1
+xml2,xml_path.xml_node,0,0,0,class<`xml_node`>,1
+xml2,xml_path.xml_nodeset,-1,0,0,character[],1
+xml2,xml_path.xml_nodeset,0,0,0,class<`xml_nodeset`>,1
+xml2,xml_remove,-1,0,0,class<`xml_node`>,1
+xml2,xml_remove,0,0,0,class<`xml_node`>,1
+xml2,xml_remove,1,0,0,logical,1
+xml2,xml_remove.xml_node,-1,0,0,class<`xml_node`>,1
+xml2,xml_remove.xml_node,0,0,0,class<`xml_node`>,1
+xml2,xml_remove.xml_node,1,0,0,logical,1
+xml2,xml_replace,-1,0,0,class<`xml_node`>,1
+xml2,xml_replace,0,0,0,class<`xml_node`>,1
+xml2,xml_replace,1,0,0,class<`xml_node`>,1
+xml2,xml_replace,2,0,0,...,1
+xml2,xml_replace,3,0,0,logical,1
+xml2,xml_replace.xml_node,-1,0,0,class<`xml_node`>,1
+xml2,xml_replace.xml_node,0,0,0,class<`xml_node`>,1
+xml2,xml_replace.xml_node,1,0,0,class<`xml_node`>,1
+xml2,xml_replace.xml_node,2,0,0,...,1
+xml2,xml_replace.xml_node,3,0,0,logical,1
+xml2,xml_root,-1,0,0,"class<`xml_document`, `xml_node`>",1
+xml2,xml_root,0,0,0,class<`xml_document`>,1
+xml2,xml_root,0,0,1,class<`xml_node`>,1
+xml2,xml_save_options,-1,0,0,integer[],1
+xml2,xml_serialize,-1,0,0,raw[],1
+xml2,xml_serialize,0,0,0,class<`xml_nodeset`>,1
+xml2,xml_serialize,1,0,0,null,1
+xml2,xml_serialize,2,0,0,...,1
+xml2,xml_serialize.xml_nodeset,-1,0,0,raw[],1
+xml2,xml_serialize.xml_nodeset,0,0,0,class<`xml_nodeset`>,1
+xml2,xml_serialize.xml_nodeset,1,0,0,null,1
+xml2,xml_serialize.xml_nodeset,2,0,0,...,1
+xml2,xml_set_attr,-1,0,0,character,1
+xml2,xml_set_attr,0,0,0,"class<`xml_document`, `xml_node`>",1
+xml2,xml_set_attr,0,0,1,class<`xml_node`>,1
+xml2,xml_set_attr,1,0,0,character,1
+xml2,xml_set_attr,2,0,0,character,1
+xml2,xml_set_attr,3,0,0,any,1
+xml2,xml_set_attrs,-1,0,0,character[],1
+xml2,xml_set_attrs,0,0,0,class<`xml_node`>,1
+xml2,xml_set_attrs,1,0,0,character[],1
+xml2,xml_set_attrs,2,0,0,any,1
+xml2,xml_set_attrs.xml_node,-1,0,0,character[],1
+xml2,xml_set_attrs.xml_node,0,0,0,class<`xml_node`>,1
+xml2,xml_set_attrs.xml_node,1,0,0,character[],1
+xml2,xml_set_attrs.xml_node,2,0,0,character[],1
+xml2,xml_set_attr.xml_node,-1,0,0,character,1
+xml2,xml_set_attr.xml_node,0,0,0,"class<`xml_document`, `xml_node`>",1
+xml2,xml_set_attr.xml_node,0,0,1,class<`xml_node`>,1
+xml2,xml_set_attr.xml_node,1,0,0,character,1
+xml2,xml_set_attr.xml_node,2,0,0,character,1
+xml2,xml_set_attr.xml_node,3,0,0,character[],1
+xml2,xml_siblings,-1,0,0,class<`xml_nodeset`>,1
+xml2,xml_siblings,0,0,0,class<`xml_node`>,1
+xml2,xml_structure,-1,0,0,null,1
+xml2,xml_structure,0,0,0,"class<`xml_document`, `xml_node`>",1
+xml2,xml_structure,0,0,1,class<`xml_nodeset`>,1
+xml2,xml_structure,1,0,0,double,1
+xml2,xml_structure,2,0,0,character,1
+xml2,xml_text,-1,0,0,null,1
+xml2,xml_text,-1,0,1,^character[],1
+xml2,xml_text,0,0,0,class<`xml_node`>,1
+xml2,xml_text,0,0,1,class<`xml_missing`>,1
+xml2,xml_text,0,0,2,class<`xml_nodeset`>,1
+xml2,xml_text,0,0,3,"class<`xml_document`, `xml_node`>",1
+xml2,xml_text,1,0,0,logical,1
+xml2,xml_text<-,-1,0,0,"class<`xml_document`, `xml_node`>",1
+xml2,xml_text<-,-1,0,1,class<`xml_node`>,1
+xml2,xml_text<-,-1,0,2,class<`xml_nodeset`>,1
+xml2,xml_text<-,0,0,0,"class<`xml_document`, `xml_node`>",1
+xml2,xml_text<-,0,0,1,class<`xml_node`>,1
+xml2,xml_text<-,0,0,2,class<`xml_nodeset`>,1
+xml2,xml_text<-,1,0,0,character[],1
+xml2,xml_text.xml_missing,-1,0,0,null,1
+xml2,xml_text.xml_missing,0,0,0,class<`xml_missing`>,1
+xml2,xml_text.xml_missing,1,0,0,logical,1
+xml2,xml_text<-.xml_node,-1,0,0,"class<`xml_document`, `xml_node`>",1
+xml2,xml_text<-.xml_node,-1,0,1,class<`xml_node`>,1
+xml2,xml_text<-.xml_node,0,0,0,"class<`xml_document`, `xml_node`>",1
+xml2,xml_text<-.xml_node,0,0,1,class<`xml_node`>,1
+xml2,xml_text<-.xml_node,1,0,0,character,1
+xml2,xml_text.xml_node,-1,0,0,character,1
+xml2,xml_text.xml_node,0,0,0,"class<`xml_document`, `xml_node`>",1
+xml2,xml_text.xml_node,0,0,1,class<`xml_node`>,1
+xml2,xml_text.xml_node,1,0,0,logical,1
+xml2,xml_text<-.xml_nodeset,-1,0,0,class<`xml_nodeset`>,1
+xml2,xml_text<-.xml_nodeset,0,0,0,class<`xml_nodeset`>,1
+xml2,xml_text<-.xml_nodeset,1,0,0,character[],1
+xml2,xml_text.xml_nodeset,-1,0,0,^character[],1
+xml2,xml_text.xml_nodeset,0,0,0,class<`xml_nodeset`>,1
+xml2,xml_text.xml_nodeset,1,0,0,logical,1
+xml2,xml_to_r_attrs,-1,0,0,null,1
+xml2,xml_to_r_attrs,-1,0,1,list<character>,1
+xml2,xml_to_r_attrs,0,0,0,character[],1
+xml2,xml_type,-1,0,0,character[],1
+xml2,xml_type,0,0,0,class<`xml_nodeset`>,1
+xml2,xml_type,0,0,1,"class<`xml_document`, `xml_node`>",1
+xml2,xml_type,0,0,2,class<`xml_node`>,1
+xml2,xml_type.xml_node,-1,0,0,character,1
+xml2,xml_type.xml_node,0,0,0,"class<`xml_document`, `xml_node`>",1
+xml2,xml_type.xml_node,0,0,1,class<`xml_node`>,1
+xml2,xml_type.xml_nodeset,-1,0,0,character[],1
+xml2,xml_type.xml_nodeset,0,0,0,class<`xml_nodeset`>,1
+xml2,xml_unserialize,-1,0,0,class<`xml_nodeset`>,1
+xml2,xml_unserialize,0,0,0,raw[],1
+xml2,xml_unserialize,1,0,0,...,1
+xml2,xml_url,-1,0,0,character,1
+xml2,xml_url,-1,0,1,null,1
+xml2,xml_url,0,0,0,"class<`xml_document`, `xml_node`>",1
+xml2,xml_url.xml_node,-1,0,0,character,1
+xml2,xml_url.xml_node,-1,0,1,null,1
+xml2,xml_url.xml_node,0,0,0,"class<`xml_document`, `xml_node`>",1
+xml2,xml_validate,-1,0,0,logical,1
+xml2,xml_validate,0,0,0,"class<`xml_document`, `xml_node`>",1
+xml2,xml_validate,1,0,0,"class<`xml_document`, `xml_node`>",1
+xml2,xml_validate.xml_document,-1,0,0,logical,1
+xml2,xml_validate.xml_document,0,0,0,"class<`xml_document`, `xml_node`>",1
+xml2,xml_validate.xml_document,1,0,0,"class<`xml_document`, `xml_node`>",1
+xtable,align<-,-1,0,0,"class<`data.frame`, `xtable`>",1
+xtable,align<-,0,0,0,"class<`data.frame`, `xtable`>",1
+xtable,align<-,1,0,0,character[],1
+xtable,.alignStringToVector,-1,0,0,character[],1
+xtable,.alignStringToVector,0,0,0,character,1
+xtable,align<-.xtable,-1,0,0,"class<`data.frame`, `xtable`>",1
+xtable,align<-.xtable,0,0,0,"class<`data.frame`, `xtable`>",1
+xtable,align<-.xtable,1,0,0,character[],1
+xtable,as.is,-1,0,0,character[],1
+xtable,as.is,0,0,0,character[],1
+xtable,as.math,-1,0,0,character,1
+xtable,as.math,0,0,0,character,1
+xtable,as.math,1,0,0,...,1
+xtable,as.string,-1,0,0,class<`string`>,1
+xtable,as.string,0,0,0,character,1
+xtable,as.string,1,0,0,character,1
+xtable,as.string,2,0,0,logical,1
+xtable,autoformat,-1,0,0,"class<`data.frame`, `xtable`>",1
+xtable,autoformat,0,0,0,"class<`data.frame`, `xtable`>",1
+xtable,autoformat,1,0,0,integer,1
+xtable,caption<-,-1,0,0,"class<`data.frame`, `xtable`>",1
+xtable,caption<-,0,0,0,"class<`data.frame`, `xtable`>",1
+xtable,caption<-,1,0,0,null,1
+xtable,caption<-,1,0,1,character[],1
+xtable,caption<-.xtable,-1,0,0,"class<`data.frame`, `xtable`>",1
+xtable,caption<-.xtable,0,0,0,"class<`data.frame`, `xtable`>",1
+xtable,caption<-.xtable,1,0,0,null,1
+xtable,caption<-.xtable,1,0,1,character[],1
+xtable,digits<-,-1,0,0,"class<`data.frame`, `xtable`>",1
+xtable,digits<-,0,0,0,"class<`data.frame`, `xtable`>",1
+xtable,digits<-,1,0,0,double[],1
+xtable,digits<-,1,0,1,class<`matrix`>,1
+xtable,digits<-.xtable,-1,0,0,"class<`data.frame`, `xtable`>",1
+xtable,digits<-.xtable,0,0,0,"class<`data.frame`, `xtable`>",1
+xtable,digits<-.xtable,1,0,0,double[],1
+xtable,digits<-.xtable,1,0,1,class<`matrix`>,1
+xtable,display,-1,0,0,character[],1
+xtable,display,0,0,0,"class<`data.frame`, `xtable`>",1
+xtable,display,1,0,0,...,1
+xtable,display<-,-1,0,0,"class<`data.frame`, `xtable`>",1
+xtable,display<-,0,0,0,"class<`data.frame`, `xtable`>",1
+xtable,display<-,1,0,0,character[],1
+xtable,display<-.xtable,-1,0,0,"class<`data.frame`, `xtable`>",1
+xtable,display<-.xtable,0,0,0,"class<`data.frame`, `xtable`>",1
+xtable,display<-.xtable,1,0,0,character[],1
+xtable,display.xtable,-1,0,0,character[],1
+xtable,display.xtable,0,0,0,"class<`data.frame`, `xtable`>",1
+xtable,display.xtable,1,0,0,...,1
+xtable,label<-,-1,0,0,"class<`data.frame`, `xtable`>",1
+xtable,label<-,0,0,0,"class<`data.frame`, `xtable`>",1
+xtable,label<-,1,0,0,null,1
+xtable,label<-,1,0,1,character,1
+xtable,label<-.xtable,-1,0,0,"class<`data.frame`, `xtable`>",1
+xtable,label<-.xtable,0,0,0,"class<`data.frame`, `xtable`>",1
+xtable,label<-.xtable,1,0,0,null,1
+xtable,label<-.xtable,1,0,1,character,1
+xtable,print.string,-1,0,0,null,1
+xtable,print.string,0,0,0,class<`string`>,1
+xtable,print.string,1,0,0,...,1
+xtable,print.xtable,-1,0,0,character,1
+xtable,print.xtable,0,0,0,"class<`data.frame`, `xtable`>",1
+xtable,print.xtable,0,0,1,"class<`data.frame`, `xtableList`>",1
+xtable,print.xtable,0,0,2,"class<`data.frame`, `xtableMatharray`>",1
+xtable,print.xtable,0,0,3,class<`matrix`>,1
+xtable,print.xtable,1,0,0,character,1
+xtable,print.xtable,2,0,0,character,1
+xtable,print.xtable,3,0,0,logical,1
+xtable,print.xtable,4,0,0,logical,1
+xtable,print.xtable,5,0,0,character,1
+xtable,print.xtable,6,0,0,character,1
+xtable,print.xtable,6,0,1,null,1
+xtable,print.xtable,7,0,0,character,1
+xtable,print.xtableFtable,-1,0,0,character,1
+xtable,print.xtableFtable,0,0,0,"class<`ftable`, `xtableFtable`>",1
+xtable,print.xtableFtable,1,0,0,character,1
+xtable,print.xtableFtable,2,0,0,character,1
+xtable,print.xtableFtable,3,0,0,logical,1
+xtable,print.xtableFtable,4,0,0,logical,1
+xtable,print.xtableFtable,5,0,0,character,1
+xtable,print.xtableFtable,6,0,0,character,1
+xtable,print.xtableFtable,7,0,0,character,1
+xtable,print.xtableList,-1,0,0,character,1
+xtable,print.xtableList,0,0,0,class<`xtableList`>,1
+xtable,print.xtableList,1,0,0,character,1
+xtable,print.xtableList,2,0,0,any,1
+xtable,print.xtableList,3,0,0,any,1
+xtable,print.xtableList,4,0,0,logical,1
+xtable,print.xtableList,5,0,0,character,1
+xtable,print.xtableList,6,0,0,character,1
+xtable,print.xtableList,7,0,0,character,1
+xtable,print.xtableMatharray,-1,0,0,character,1
+xtable,print.xtableMatharray,0,0,0,"class<`data.frame`, `xtable`>",1
+xtable,print.xtableMatharray,0,0,1,"class<`data.frame`, `xtable`, `xtableMatharray`>",1
+xtable,print.xtableMatharray,1,0,0,logical,1
+xtable,print.xtableMatharray,2,0,0,null,1
+xtable,print.xtableMatharray,2,0,1,list<character>,1
+xtable,print.xtableMatharray,3,0,0,null,1
+xtable,print.xtableMatharray,3,0,1,double,1
+xtable,print.xtableMatharray,4,0,0,logical,1
+xtable,print.xtableMatharray,5,0,0,null,1
+xtable,print.xtableMatharray,5,0,1,character,1
+xtable,print.xtableMatharray,6,0,0,...,1
+xtable,sanitize,-1,0,0,character[],1
+xtable,sanitize,0,0,0,character[],1
+xtable,sanitize,1,0,0,character,1
+xtable,sanitize.final,-1,0,0,class<`string`>,1
+xtable,sanitize.final,0,0,0,class<`string`>,1
+xtable,sanitize.final,1,0,0,character,1
+xtable,sanitize.numbers,-1,0,0,character[],1
+xtable,sanitize.numbers,-1,0,1,double[],1
+xtable,sanitize.numbers,0,0,0,character[],1
+xtable,sanitize.numbers,0,0,1,double[],1
+xtable,sanitize.numbers,1,0,0,character,1
+xtable,sanitize.numbers,2,0,0,any,1
+xtable,sanitize.numbers,3,0,0,any,1
+xtable,string,-1,0,0,class<`string`>,1
+xtable,string,0,0,0,character,1
+xtable,string,1,0,0,character,1
+xtable,string,2,0,0,logical,1
+xtable,+.string,-1,0,0,class<`string`>,1
+xtable,+.string,0,0,0,class<`string`>,1
+xtable,+.string,1,0,0,character,1
+xtable,toLatex.xtable,-1,0,0,class<`Latex`>,1
+xtable,toLatex.xtable,0,0,0,"class<`data.frame`, `xtable`>",1
+xtable,toLatex.xtable,1,0,0,...,1
+xtable,xalign,-1,0,0,character[],1
+xtable,xalign,0,0,0,double[],1
+xtable,xalign,0,0,1,"class<`data.frame`, `xtable`>",1
+xtable,xalign,0,0,2,class<`data.frame`>,1
+xtable,xalign,1,0,0,logical,1
+xtable,xdigits,-1,0,0,integer[],1
+xtable,xdigits,0,0,0,double[],1
+xtable,xdigits,0,0,1,"class<`data.frame`, `xtable`>",1
+xtable,xdigits,0,0,2,class<`data.frame`>,1
+xtable,xdigits,1,0,0,logical,1
+xtable,xdigits,2,0,0,integer,1
+xtable,xdisplay,-1,0,0,character[],1
+xtable,xdisplay,0,0,0,double[],1
+xtable,xdisplay,0,0,1,"class<`data.frame`, `xtable`>",1
+xtable,xdisplay,0,0,2,class<`data.frame`>,1
+xtable,xdisplay,1,0,0,logical,1
+xtable,xtable,-1,0,0,"class<`data.frame`, `xtable`>",1
+xtable,xtable,0,0,0,"class<`glm`, `lm`>",1
+xtable,xtable,0,0,1,class<`lm`>,1
+xtable,xtable,0,0,2,class<`prcomp`>,1
+xtable,xtable,0,0,3,class<`summary.prcomp`>,1
+xtable,xtable,0,0,4,"class<`anova`, `data.frame`>",1
+xtable,xtable,0,0,5,"class<`aovlist`, `listof`>",1
+xtable,xtable,0,0,6,class<`summary.aovlist`>,1
+xtable,xtable,0,0,7,class<`coxph`>,1
+xtable,xtable,0,0,8,class<`data.frame`>,1
+xtable,xtable,0,0,9,"class<`listof`, `summary.aov`>",1
+xtable,xtable,0,0,10,class<`matrix`>,1
+xtable,xtable,0,0,11,class<`table`>,1
+xtable,xtable,0,0,12,class<`ts`>,1
+xtable,xtable,0,0,13,class<`zoo`>,1
+xtable,xtable,0,0,14,"class<`zoo`, `zooreg`>",1
+xtable,xtable,0,0,15,"class<`aov`, `lm`>",1
+xtable,xtable,1,0,0,null,1
+xtable,xtable,1,0,1,character[],1
+xtable,xtable,2,0,0,null,1
+xtable,xtable,2,0,1,character,1
+xtable,xtable,3,0,0,null,1
+xtable,xtable,3,0,1,character[],1
+xtable,xtable,4,0,0,null,1
+xtable,xtable,4,0,1,double[],1
+xtable,xtable,5,0,0,null,1
+xtable,xtable,5,0,1,character[],1
+xtable,xtable,6,0,0,logical,1
+xtable,xtable,7,0,0,...,1
+xtable,xtable.anova,-1,0,0,"class<`data.frame`, `xtable`>",1
+xtable,xtable.anova,0,0,0,"class<`anova`, `data.frame`>",1
+xtable,xtable.anova,1,0,0,null,1
+xtable,xtable.anova,1,0,1,character[],1
+xtable,xtable.anova,2,0,0,null,1
+xtable,xtable.anova,3,0,0,null,1
+xtable,xtable.anova,4,0,0,null,1
+xtable,xtable.anova,5,0,0,null,1
+xtable,xtable.anova,6,0,0,logical,1
+xtable,xtable.anova,7,0,0,...,1
+xtable,xtable.aov,-1,0,0,"class<`data.frame`, `xtable`>",1
+xtable,xtable.aov,0,0,0,"class<`aov`, `lm`>",1
+xtable,xtable.aov,1,0,0,null,1
+xtable,xtable.aov,1,0,1,character[],1
+xtable,xtable.aov,2,0,0,null,1
+xtable,xtable.aov,3,0,0,null,1
+xtable,xtable.aov,4,0,0,null,1
+xtable,xtable.aov,5,0,0,null,1
+xtable,xtable.aov,6,0,0,logical,1
+xtable,xtable.aov,7,0,0,...,1
+xtable,xtable.aovlist,-1,0,0,"class<`data.frame`, `xtable`>",1
+xtable,xtable.aovlist,0,0,0,"class<`aovlist`, `listof`>",1
+xtable,xtable.aovlist,1,0,0,null,1
+xtable,xtable.aovlist,2,0,0,null,1
+xtable,xtable.aovlist,3,0,0,null,1
+xtable,xtable.aovlist,4,0,0,null,1
+xtable,xtable.aovlist,5,0,0,null,1
+xtable,xtable.aovlist,6,0,0,logical,1
+xtable,xtable.aovlist,7,0,0,...,1
+xtable,xtable.coxph,-1,0,0,"class<`data.frame`, `xtable`>",1
+xtable,xtable.coxph,0,0,0,class<`coxph`>,1
+xtable,xtable.coxph,1,0,0,null,1
+xtable,xtable.coxph,2,0,0,null,1
+xtable,xtable.coxph,3,0,0,null,1
+xtable,xtable.coxph,4,0,0,null,1
+xtable,xtable.coxph,5,0,0,null,1
+xtable,xtable.coxph,6,0,0,logical,1
+xtable,xtable.coxph,7,0,0,...,1
+xtable,xtable.data.frame,-1,0,0,"class<`data.frame`, `xtable`>",1
+xtable,xtable.data.frame,0,0,0,class<`data.frame`>,1
+xtable,xtable.data.frame,1,0,0,null,1
+xtable,xtable.data.frame,1,0,1,character,1
+xtable,xtable.data.frame,2,0,0,null,1
+xtable,xtable.data.frame,2,0,1,character,1
+xtable,xtable.data.frame,3,0,0,null,1
+xtable,xtable.data.frame,3,0,1,character[],1
+xtable,xtable.data.frame,4,0,0,null,1
+xtable,xtable.data.frame,4,0,1,double[],1
+xtable,xtable.data.frame,5,0,0,null,1
+xtable,xtable.data.frame,5,0,1,character[],1
+xtable,xtable.data.frame,6,0,0,logical,1
+xtable,xtable.data.frame,7,0,0,...,1
+xtable,xtableFtable,-1,0,0,"class<`ftable`, `xtableFtable`>",1
+xtable,xtableFtable,0,0,0,class<`ftable`>,1
+xtable,xtableFtable,1,0,0,null,1
+xtable,xtableFtable,2,0,0,null,1
+xtable,xtableFtable,3,0,0,null,1
+xtable,xtableFtable,4,0,0,double,1
+xtable,xtableFtable,5,0,0,null,1
+xtable,xtableFtable,6,0,0,logical,1
+xtable,xtableFtable,7,0,0,character[],1
+xtable,xtable.glm,-1,0,0,"class<`data.frame`, `xtable`>",1
+xtable,xtable.glm,0,0,0,"class<`glm`, `lm`>",1
+xtable,xtable.glm,1,0,0,null,1
+xtable,xtable.glm,2,0,0,null,1
+xtable,xtable.glm,3,0,0,character,1
+xtable,xtable.glm,3,0,1,null,1
+xtable,xtable.glm,4,0,0,null,1
+xtable,xtable.glm,5,0,0,null,1
+xtable,xtable.glm,6,0,0,logical,1
+xtable,xtable.glm,7,0,0,...,1
+xtable,xtableList,-1,0,0,class<`xtableList`>,1
+xtable,xtableList,0,0,0,list<class<`data.frame`>>,1
+xtable,xtableList,1,0,0,null,1
+xtable,xtableList,1,0,1,character,1
+xtable,xtableList,2,0,0,null,1
+xtable,xtableList,2,0,1,character,1
+xtable,xtableList,3,0,0,null,1
+xtable,xtableList,4,0,0,null,1
+xtable,xtableList,4,0,1,double[],1
+xtable,xtableList,5,0,0,null,1
+xtable,xtableList,6,0,0,...,1
+xtable,xtable.lm,-1,0,0,"class<`data.frame`, `xtable`>",1
+xtable,xtable.lm,0,0,0,class<`lm`>,1
+xtable,xtable.lm,1,0,0,null,1
+xtable,xtable.lm,1,0,1,character,1
+xtable,xtable.lm,2,0,0,null,1
+xtable,xtable.lm,3,0,0,null,1
+xtable,xtable.lm,4,0,0,null,1
+xtable,xtable.lm,5,0,0,null,1
+xtable,xtable.lm,6,0,0,logical,1
+xtable,xtable.lm,7,0,0,...,1
+xtable,xtableMatharray,-1,0,0,"class<`data.frame`, `xtable`, `xtableMatharray`>",1
+xtable,xtableMatharray,0,0,0,class<`matrix`>,1
+xtable,xtableMatharray,0,0,1,class<`xtableMatharray`>,1
+xtable,xtableMatharray,1,0,0,null,1
+xtable,xtableMatharray,2,0,0,null,1
+xtable,xtableMatharray,3,0,0,null,1
+xtable,xtableMatharray,4,0,0,null,1
+xtable,xtableMatharray,4,0,1,double,1
+xtable,xtableMatharray,5,0,0,null,1
+xtable,xtableMatharray,5,0,1,character[],1
+xtable,xtableMatharray,6,0,0,logical,1
+xtable,xtableMatharray,7,0,0,...,1
+xtable,xtable.matrix,-1,0,0,"class<`data.frame`, `xtable`>",1
+xtable,xtable.matrix,0,0,0,class<`matrix`>,1
+xtable,xtable.matrix,0,0,1,"class<`matrix`, `xtableMatharray`>",1
+xtable,xtable.matrix,1,0,0,null,1
+xtable,xtable.matrix,1,0,1,character,1
+xtable,xtable.matrix,2,0,0,null,1
+xtable,xtable.matrix,2,0,1,character,1
+xtable,xtable.matrix,3,0,0,null,1
+xtable,xtable.matrix,4,0,0,null,1
+xtable,xtable.matrix,4,0,1,double,1
+xtable,xtable.matrix,5,0,0,null,1
+xtable,xtable.matrix,5,0,1,character[],1
+xtable,xtable.matrix,6,0,0,logical,1
+xtable,xtable.matrix,7,0,0,...,1
+xtable,xtable.prcomp,-1,0,0,"class<`data.frame`, `xtable`>",1
+xtable,xtable.prcomp,0,0,0,class<`prcomp`>,1
+xtable,xtable.prcomp,1,0,0,null,1
+xtable,xtable.prcomp,2,0,0,null,1
+xtable,xtable.prcomp,3,0,0,null,1
+xtable,xtable.prcomp,4,0,0,null,1
+xtable,xtable.prcomp,5,0,0,null,1
+xtable,xtable.prcomp,6,0,0,logical,1
+xtable,xtable.prcomp,7,0,0,...,1
+xtable,xtable.summary.aov,-1,0,0,"class<`data.frame`, `xtable`>",1
+xtable,xtable.summary.aov,0,0,0,"class<`listof`, `summary.aov`>",1
+xtable,xtable.summary.aov,1,0,0,null,1
+xtable,xtable.summary.aov,2,0,0,null,1
+xtable,xtable.summary.aov,3,0,0,null,1
+xtable,xtable.summary.aov,4,0,0,null,1
+xtable,xtable.summary.aov,5,0,0,null,1
+xtable,xtable.summary.aov,6,0,0,logical,1
+xtable,xtable.summary.aov,7,0,0,...,1
+xtable,xtable.summary.aovlist,-1,0,0,"class<`data.frame`, `xtable`>",1
+xtable,xtable.summary.aovlist,0,0,0,class<`summary.aovlist`>,1
+xtable,xtable.summary.aovlist,1,0,0,null,1
+xtable,xtable.summary.aovlist,2,0,0,null,1
+xtable,xtable.summary.aovlist,3,0,0,null,1
+xtable,xtable.summary.aovlist,4,0,0,null,1
+xtable,xtable.summary.aovlist,5,0,0,null,1
+xtable,xtable.summary.aovlist,6,0,0,logical,1
+xtable,xtable.summary.aovlist,7,0,0,...,1
+xtable,xtable.summary.glm,-1,0,0,"class<`data.frame`, `xtable`>",1
+xtable,xtable.summary.glm,0,0,0,class<`summary.glm`>,1
+xtable,xtable.summary.glm,1,0,0,null,1
+xtable,xtable.summary.glm,2,0,0,null,1
+xtable,xtable.summary.glm,3,0,0,character,1
+xtable,xtable.summary.glm,3,0,1,null,1
+xtable,xtable.summary.glm,4,0,0,null,1
+xtable,xtable.summary.glm,5,0,0,null,1
+xtable,xtable.summary.glm,6,0,0,logical,1
+xtable,xtable.summary.glm,7,0,0,...,1
+xtable,xtable.summary.lm,-1,0,0,"class<`data.frame`, `xtable`>",1
+xtable,xtable.summary.lm,0,0,0,class<`summary.glm`>,1
+xtable,xtable.summary.lm,0,0,1,class<`summary.lm`>,1
+xtable,xtable.summary.lm,1,0,0,null,1
+xtable,xtable.summary.lm,1,0,1,character,1
+xtable,xtable.summary.lm,2,0,0,null,1
+xtable,xtable.summary.lm,3,0,0,character,1
+xtable,xtable.summary.lm,3,0,1,null,1
+xtable,xtable.summary.lm,4,0,0,null,1
+xtable,xtable.summary.lm,5,0,0,null,1
+xtable,xtable.summary.lm,6,0,0,logical,1
+xtable,xtable.summary.lm,7,0,0,...,1
+xtable,xtable.summary.prcomp,-1,0,0,"class<`data.frame`, `xtable`>",1
+xtable,xtable.summary.prcomp,0,0,0,class<`summary.prcomp`>,1
+xtable,xtable.summary.prcomp,1,0,0,null,1
+xtable,xtable.summary.prcomp,2,0,0,null,1
+xtable,xtable.summary.prcomp,3,0,0,null,1
+xtable,xtable.summary.prcomp,4,0,0,null,1
+xtable,xtable.summary.prcomp,5,0,0,null,1
+xtable,xtable.summary.prcomp,6,0,0,logical,1
+xtable,xtable.summary.prcomp,7,0,0,...,1
+xtable,xtable.table,-1,0,0,"class<`data.frame`, `xtable`>",1
+xtable,xtable.table,0,0,0,class<`table`>,1
+xtable,xtable.table,1,0,0,null,1
+xtable,xtable.table,2,0,0,null,1
+xtable,xtable.table,3,0,0,null,1
+xtable,xtable.table,4,0,0,null,1
+xtable,xtable.table,5,0,0,null,1
+xtable,xtable.table,6,0,0,logical,1
+xtable,xtable.table,7,0,0,...,1
+xtable,xtable.ts,-1,0,0,"class<`data.frame`, `xtable`>",1
+xtable,xtable.ts,0,0,0,class<`ts`>,1
+xtable,xtable.ts,1,0,0,null,1
+xtable,xtable.ts,2,0,0,null,1
+xtable,xtable.ts,3,0,0,null,1
+xtable,xtable.ts,4,0,0,double,1
+xtable,xtable.ts,4,0,1,null,1
+xtable,xtable.ts,5,0,0,null,1
+xtable,xtable.ts,6,0,0,logical,1
+xtable,xtable.ts,7,0,0,...,1
+xtable,xtable.zoo,-1,0,0,"class<`data.frame`, `xtable`>",1
+xtable,xtable.zoo,0,0,0,class<`zoo`>,1
+xtable,xtable.zoo,0,0,1,"class<`zoo`, `zooreg`>",1
+xtable,xtable.zoo,1,0,0,null,1
+xtable,xtable.zoo,2,0,0,null,1
+xtable,xtable.zoo,3,0,0,null,1
+xtable,xtable.zoo,4,0,0,null,1
+xtable,xtable.zoo,4,0,1,double,1
+xtable,xtable.zoo,5,0,0,null,1
+xtable,xtable.zoo,6,0,0,logical,1
+xtable,xtable.zoo,7,0,0,...,1
+zeallot,%<-%,-1,0,0,any,1
+zeallot,%<-%,0,0,0,any,1
+zeallot,%<-%,1,0,0,character[],1
+zeallot,%<-%,1,0,1,class<`data.frame`>,1
+zeallot,%<-%,1,0,2,"class<`summaryDefault`, `table`>",1
+zeallot,%<-%,1,0,3,class<`summary.lm`>,1
+zeallot,%<-%,1,0,4,double[],1
+zeallot,%<-%,1,0,5,list<character[]>,1
+zeallot,%<-%,1,0,6,list<double | character>,1
+zeallot,%<-%,1,0,7,list<double>,1
+zeallot,%<-%,1,0,8,list<double | list<double | list<double | list<double>>>>,1
+zeallot,%<-%,1,0,9,list<list<double>>,1
+zeallot,%->%,-1,0,0,list<character>,1
+zeallot,%->%,-1,0,1,list<double | character>,1
+zeallot,%->%,0,0,0,list<character>,1
+zeallot,%->%,0,0,1,list<double | character>,1
+zeallot,%->%,1,0,0,any,1
+zeallot,add_defaults,-1,0,0,list<character | null>,1
+zeallot,add_defaults,0,0,0,list<character>,1
+zeallot,add_defaults,1,0,0,list<character>,1
+zeallot,add_defaults,2,0,0,environment,1
+zeallot,assert_destruction,-1,0,0,null,1
+zeallot,assert_destruction,0,0,0,character,1
+zeallot,assert_destruction,0,0,1,class<`Date`>,1
+zeallot,calls,-1,0,0,character[],1
+zeallot,calls,-1,0,1,null,1
+zeallot,calls,0,0,0,list<class<`name`> | list<class<`name`> | character | null>>,1
+zeallot,calls,0,0,1,list<class<`name`> | list<class<`name`> | list<class<`name`> | list<class<`name`>>>>>,1
+zeallot,calls,0,0,2,list<class<`name`> | list<class<`name`>>>,1
+zeallot,calls,0,0,3,list<class<`name`>>,1
+zeallot,calls,0,0,4,list<class<`name`> | list<class<`name`> | list<class<`name`>>>>,1
+zeallot,calls,0,0,5,list<class<`name`> | character | null>,1
+zeallot,calls,0,0,6,character,1
+zeallot,calls,0,0,7,class<`name`>,1
+zeallot,calls,0,0,8,null,1
+zeallot,car,-1,0,0,character[],1
+zeallot,car,-1,0,1,class<`call`>,1
+zeallot,car,-1,0,2,class<`name`>,1
+zeallot,car,-1,0,3,double[],1
+zeallot,car,-1,0,4,list<character>,1
+zeallot,car,-1,0,5,list<character | list<character | list<character>>>,1
+zeallot,car,-1,0,6,list<character | list<character>>,1
+zeallot,car,-1,0,7,list<double>,1
+zeallot,car,-1,0,8,list<double | list<double | list<double>>>,1
+zeallot,car,-1,0,9,list<double | list<double>>,1
+zeallot,car,-1,0,10,null,1
+zeallot,car,0,0,0,list<any>,1
+zeallot,cdr,-1,0,0,list<any>,1
+zeallot,cdr,0,0,0,list<any>,1
+zeallot,check_extract_calls,-1,0,0,null,1
+zeallot,check_extract_calls,0,0,0,list<character>,1
+zeallot,check_extract_calls,0,0,1,list<character | list<character | list<character | list<character>>>>,1
+zeallot,check_extract_calls,0,0,2,list<list<character>>,1
+zeallot,check_extract_calls,0,0,3,character,1
+zeallot,check_extract_calls,0,0,4,list<character | list<character | list<character>>>,1
+zeallot,check_extract_calls,0,0,5,list<character | list<character>>,1
+zeallot,check_extract_calls,1,0,0,any,1
+zeallot,collect,-1,0,0,list<list<character>>,1
+zeallot,collect,-1,0,1,list<character | list<character>>,1
+zeallot,collect,-1,0,2,list<list<double[]>>,1
+zeallot,collect,-1,0,3,"list<double[] | class<`matrix`> | list<class<`formula`, `terms`> | double[] | class<`matrix`>>>",1
+zeallot,collect,0,0,0,list<character>,1
+zeallot,collect,1,0,0,list<character>,1
+zeallot,collect,1,0,1,list<double[]>,1
+zeallot,collect,1,0,2,"list<class<`formula`, `terms`> | double[] | class<`matrix`>>",1
+zeallot,condition,-1,0,0,"class<`condition`, `error`, `invalid_rhs`>",1
+zeallot,condition,0,0,0,character[],1
+zeallot,condition,1,0,0,character,1
+zeallot,condition,2,0,0,class<`call`>,1
+zeallot,condition,3,0,0,...,1
+zeallot,destructure,-1,0,0,list<any>,1
+zeallot,destructure,0,0,0,character,1
+zeallot,destructure,0,0,1,class<`shape`>,1
+zeallot,destructure,0,0,2,class<`Date`>,1
+zeallot,destructure,0,0,3,class<`summary.lm`>,1
+zeallot,destructure,0,0,4,class<`data.frame`>,1
+zeallot,destructure.character,-1,0,0,list<character>,1
+zeallot,destructure.character,0,0,0,character,1
+zeallot,destructure.data.frame,-1,0,0,list<double[]>,1
+zeallot,destructure.data.frame,0,0,0,class<`data.frame`>,1
+zeallot,destructure.Date,-1,0,0,list<double>,1
+zeallot,destructure.Date,0,0,0,class<`Date`>,1
+zeallot,destructure.summary.lm,-1,0,0,list<any>,1
+zeallot,destructure.summary.lm,0,0,0,class<`summary.lm`>,1
+zeallot,get_default,-1,0,0,null,1
+zeallot,get_default,0,0,0,character,1
+zeallot,has_collector,-1,0,0,logical,1
+zeallot,has_collector,0,0,0,list<character>,1
+zeallot,has_default,-1,0,0,logical[],1
+zeallot,has_default,0,0,0,list<character>,1
+zeallot,incorrect_number_of_values,-1,0,0,character,1
+zeallot,is_collector,-1,0,0,logical,1
+zeallot,is_collector,0,0,0,character,1
+zeallot,is_collector,0,0,1,list<character>,1
+zeallot,is_collector,0,0,2,list<character | list<character | list<character>>>,1
+zeallot,is_collector,0,0,3,list<character | list<character>>,1
+zeallot,is_extract_op,-1,0,0,logical,1
+zeallot,is_extract_op,0,0,0,class<`name`>,1
+zeallot,is_list,-1,0,0,logical,1
+zeallot,is_list,0,0,0,character[],1
+zeallot,is_list,0,0,1,class<`data.frame`>,1
+zeallot,is_list,0,0,2,class<`name`>,1
+zeallot,is_list,0,0,3,"class<`summaryDefault`, `table`>",1
+zeallot,is_list,0,0,4,class<`summary.lm`>,1
+zeallot,is_list,0,0,5,double[],1
+zeallot,is_list,0,0,6,list<any>,1
+zeallot,is_list,0,0,7,null,1
+zeallot,is_valid_call,-1,0,0,logical,1
+zeallot,is_valid_call,0,0,0,class<`name`>,1
+zeallot,multi_assign,-1,0,0,any,1
+zeallot,multi_assign,0,0,0,class<`call`>,1
+zeallot,multi_assign,1,0,0,character[],1
+zeallot,multi_assign,1,0,1,class<`data.frame`>,1
+zeallot,multi_assign,1,0,2,"class<`summaryDefault`, `table`>",1
+zeallot,multi_assign,1,0,3,class<`summary.lm`>,1
+zeallot,multi_assign,1,0,4,double[],1
+zeallot,multi_assign,1,0,5,list<character[]>,1
+zeallot,multi_assign,1,0,6,list<double | character>,1
+zeallot,multi_assign,1,0,7,list<double>,1
+zeallot,multi_assign,1,0,8,list<double | list<double | list<double | list<double>>>>,1
+zeallot,multi_assign,1,0,9,list<list<double>>,1
+zeallot,multi_assign,2,0,0,any,1
+zeallot,names2,-1,0,0,character,1
+zeallot,names2,0,0,0,class<`call`>,1
+zeallot,pair_off,-1,0,0,any,1
+zeallot,pair_off,0,0,0,character,1
+zeallot,pair_off,0,0,1,list<any>,1
+zeallot,pair_off,1,0,0,any,1
+zeallot,pair_off,2,0,0,any,1
+zeallot,stop_invalid_rhs,-1,0,0,any,1
+zeallot,stop_invalid_rhs,0,0,0,character,1
+zeallot,stop_invalid_rhs,1,0,0,class<`call`>,1
+zeallot,stop_invalid_rhs,2,0,0,...,1
+zeallot,tree,-1,0,0,class<`name`>,1
+zeallot,tree,-1,0,1,list<class<`name`>>,1
+zeallot,tree,-1,0,2,list<class<`name`> | list<class<`name`> | character | null>>,1
+zeallot,tree,-1,0,3,list<class<`name`> | list<class<`name`> | list<class<`name`> | list<class<`name`>>>>>,1
+zeallot,tree,-1,0,4,list<class<`name`> | list<class<`name`> | list<class<`name`>>>>,1
+zeallot,tree,-1,0,5,list<class<`name`> | list<class<`name`>>>,1
+zeallot,tree,0,0,0,class<`name`>,1
+zeallot,tree,0,0,1,class<`call`>,1
+zeallot,variables,-1,0,0,character,1
+zeallot,variables,-1,0,1,list<character>,1
+zeallot,variables,-1,0,2,list<character | list<character | list<character>>>,1
+zeallot,variables,-1,0,3,list<character | list<character>>,1
+zeallot,variables,-1,0,4,list<character | list<character | list<character | list<character>>>>,1
+zeallot,variables,-1,0,5,list<list<character>>,1
+zeallot,variables,0,0,0,class<`name`>,1
+zeallot,variables,0,0,1,list<class<`name`> | character | null>,1
+zeallot,variables,0,0,2,list<class<`name`>>,1
+zeallot,variables,0,0,3,list<class<`name`> | list<class<`name`> | list<class<`name`>>>>,1
+zeallot,variables,0,0,4,list<class<`name`> | list<class<`name`>>>,1
+zeallot,variables,0,0,5,list<class<`name`> | list<class<`name`> | character | null>>,1
+zeallot,variables,0,0,6,list<class<`name`> | list<class<`name`> | list<class<`name`> | list<class<`name`>>>>>,1

From 25117d30c7ed169594c56f32ccee0ac68237a1f9 Mon Sep 17 00:00:00 2001
From: Lukas Rohde <86918771+loki259@users.noreply.github.com>
Date: Fri, 25 Jul 2025 21:47:09 +0000
Subject: [PATCH 103/153] feat: change parser and pretty-printer to
 #makerohdehappy

---
 .../repl/commands/repl-turcotte-type-parse.ts | 42 +++++++++----------
 src/typing/{subtyping => }/pretty-print.ts    | 13 +++---
 2 files changed, 26 insertions(+), 29 deletions(-)
 rename src/typing/{subtyping => }/pretty-print.ts (89%)

diff --git a/src/cli/repl/commands/repl-turcotte-type-parse.ts b/src/cli/repl/commands/repl-turcotte-type-parse.ts
index 1425ca82d4e..0f98dd3f303 100644
--- a/src/cli/repl/commands/repl-turcotte-type-parse.ts
+++ b/src/cli/repl/commands/repl-turcotte-type-parse.ts
@@ -17,7 +17,7 @@ import {
 	UnresolvedRTypeUnion,
 	UnresolvedRTypeVariable
 } from '../../../typing/subtyping/types';
-import { prettyPrint } from '../../../typing/subtyping/pretty-print';
+import { prettyPrint } from '../../../typing/pretty-print';
 import { ColorEffect, Colors } from '../../../util/text/ansi';
 
 interface FunctionTypeInformation {
@@ -131,9 +131,9 @@ function convertSingleTurcotteFunctionAlternative2RohdeType(fingerprint: string,
 			constrainLowerAndUpperBound(fn.returnType, type);
 		} else {
 			// we get the type to create a new one if not already there
-			getParameterTypeFromFunction(fn, Number(parameterPosition));
+			const parameterType = getParameterTypeFromFunction(fn, Number(parameterPosition));
 			// now we can set the type
-			constrainLowerAndUpperBound(fn.parameterTypes.get(Number(parameterPosition)) as UnresolvedDataType, type);
+			constrainLowerAndUpperBound(parameterType, type);
 		}
 	}
 
@@ -179,21 +179,21 @@ function turcotteType2RohdeType(type: string): UnresolvedDataType {
 		case 'raw':         r = new RRawType(); break;
 		case 'expression':  r = new RLanguageType(); break;
 		case 'externalptr': r = new UnresolvedRTypeVariable(); break;
-		case 'pairlist':    r = new UnresolvedRListType(); break;
+		case 'pairlist':    r = new UnresolvedRTypeVariable(); break;
 		default:
 			r = parseComplicatedTurcotteType(type);
 	}
 
 	guard(r !== undefined, `Unknown type ${JSON.stringify(type)} in Turcotte data!`);
 
-	if(r.tag !== DataTypeTag.Variable) {
-		if(isArray) {
-			const variable = new UnresolvedRTypeVariable();
-			constrainLowerAndUpperBound(variable, r);
-			r = new UnresolvedRAtomicVectorType(variable);
+	if(isArray) {
+		if(r.tag !== DataTypeTag.Variable) {
+			const vectorType = new UnresolvedRAtomicVectorType();
+			constrainLowerAndUpperBound(vectorType.elementType, r);
+			r = vectorType;
+		} else {
+			r = new UnresolvedRAtomicVectorType(r);
 		}
-	} else if(isArray) {
-		r = new UnresolvedRAtomicVectorType(r);
 	}
 
 	return r;
@@ -228,7 +228,7 @@ function turcotte2RohdeTypes(data: TurcotteCsvRow[]): RohdeTypes {
 
 
 
-function parseComplicatedTurcotteType(type: string): UnresolvedDataType | undefined{
+function parseComplicatedTurcotteType(type: string): UnresolvedDataType | undefined {
 	// everything up until the first parse <1, 2 | 3, 4 & 5> etc. recursively!
 	const [prefix, main] = type.split(/<(.*)/, 2);
 
@@ -251,9 +251,9 @@ function parseComplicatedTurcotteType(type: string): UnresolvedDataType | undefi
 	switch(prefix) {
 		case 'list': {
 			guard(params.length === 1, `List type ${JSON.stringify(type)} must have exactly one parameter!`);
-			const v = new UnresolvedRTypeVariable();
-			constrainLowerAndUpperBound(v, alternativeTurcotteType2RohdeType(params[0]));
-			return new UnresolvedRListType(v);
+			const listType = new UnresolvedRListType();
+			constrainLowerAndUpperBound(listType.elementType, alternativeTurcotteType2RohdeType(params[0]));
+			return listType;
 		}
 
 	}
@@ -265,7 +265,7 @@ function parseComplicatedTurcotteType(type: string): UnresolvedDataType | undefi
 function collectParams(argString: string): string[][] {
 	// split at comma but respect nestings with <>
 	const params: string[][] = [];
-	const currentParams: string[] = [];
+	const currentParamAlternatives: string[] = [];
 	let current = '';
 	let depth = 0;
 	let quoted = false;
@@ -280,13 +280,13 @@ function collectParams(argString: string): string[][] {
 		} else if(char === '>' && !quoted) {
 			depth--;
 		} else if(!quoted && char === ',' && depth === 0) {
-			params.push([...currentParams, current.trim()]);
+			params.push([...currentParamAlternatives, current.trim()]);
 			current = '';
 			continue;
 		} else if(char === '|' && !quoted && depth === 0) {
 			// split on alternatives
 			if(current.trim().length > 0) {
-				currentParams.push(current.trim());
+				currentParamAlternatives.push(current.trim());
 			}
 			current = '';
 			continue;
@@ -295,10 +295,10 @@ function collectParams(argString: string): string[][] {
 	}
 
 	if(current.trim().length > 0) {
-		currentParams.push(current.trim());
+		currentParamAlternatives.push(current.trim());
 	}
-	if(currentParams.length > 0) {
-		params.push(currentParams);
+	if(currentParamAlternatives.length > 0) {
+		params.push(currentParamAlternatives);
 	}
 	return params;
 }
\ No newline at end of file
diff --git a/src/typing/subtyping/pretty-print.ts b/src/typing/pretty-print.ts
similarity index 89%
rename from src/typing/subtyping/pretty-print.ts
rename to src/typing/pretty-print.ts
index ff5e149777c..71018f6b187 100644
--- a/src/typing/subtyping/pretty-print.ts
+++ b/src/typing/pretty-print.ts
@@ -1,6 +1,6 @@
-import type { DataType } from '../types';
-import { DataTypeTag } from '../types';
-import { assertUnreachable } from '../../util/assert';
+import type { DataType } from './types';
+import { DataTypeTag } from './types';
+import { assertUnreachable } from '../util/assert';
 
 function isAny(t: DataType): boolean {
 	return t.tag === DataTypeTag.Variable &&
@@ -8,10 +8,7 @@ function isAny(t: DataType): boolean {
         t.upperBound.tag === DataTypeTag.Intersection && t.upperBound.types.size === 0;
 }
 
-export function prettyPrint(t: DataType | undefined, shorten = true): string {
-	if(t === undefined) {
-		return '$$undefined';
-	}
+export function prettyPrint(t: DataType, shorten = true): string {
 	const tag = t.tag;
 	if(isAny(t)) {
 		return 'any';
@@ -26,7 +23,7 @@ export function prettyPrint(t: DataType | undefined, shorten = true): string {
 		case DataTypeTag.Raw:
 		case DataTypeTag.Environment:
 		case DataTypeTag.Language:
-			return shorten && tag.startsWith('R') && tag.endsWith('Type') ? tag.slice(1, -4): tag;
+			return shorten && tag.startsWith('R') && tag.endsWith('Type') ? tag.slice(1, -4) : tag;
 		case DataTypeTag.Function:
 			return `${shorten ? 'fn' : 'function'}(${[...t.parameterTypes.entries()].map(([k, v]) => 
 				k ? `${k}: ${prettyPrint(v, shorten)}` : prettyPrint(v, shorten)

From 5b947719d5f0f727d53f8d5bcd3fec0a73a57530 Mon Sep 17 00:00:00 2001
From: Florian Sihler <florian.sihler@uni-ulm.de>
Date: Sat, 26 Jul 2025 15:01:58 +0200
Subject: [PATCH 104/153] feat: rohde types are chonky

---
 .../repl/commands/repl-turcotte-type-parse.ts | 309 ++-------------
 src/typing/adapter/turcotte-types.ts          | 371 ++++++++++++++++++
 src/typing/pretty-print.ts                    |   4 +
 3 files changed, 413 insertions(+), 271 deletions(-)
 create mode 100644 src/typing/adapter/turcotte-types.ts

diff --git a/src/cli/repl/commands/repl-turcotte-type-parse.ts b/src/cli/repl/commands/repl-turcotte-type-parse.ts
index 0f98dd3f303..7086824e066 100644
--- a/src/cli/repl/commands/repl-turcotte-type-parse.ts
+++ b/src/cli/repl/commands/repl-turcotte-type-parse.ts
@@ -1,65 +1,52 @@
 import type { ReplCommand } from './repl-main';
 import { findSource } from '../../../dataflow/internal/process/functions/call/built-in/built-in-source';
-import type {
-	RFunctionType } from '../../../typing/types';
-import {
-	DataTypeTag, RComplexType, RDoubleType, REnvironmentType, RIntegerType, RLanguageType,
-	RLogicalType,
-	RNullType, RRawType, RStringType
-} from '../../../typing/types';
 import fs from 'fs';
 import csvParser from 'csv-parser';
-import { guard } from '../../../util/assert';
 import type {
-	UnresolvedDataType } from '../../../typing/subtyping/types';
+	RohdeTypes,
+	TurcotteCsvRow
+} from '../../../typing/adapter/turcotte-types';
 import {
-	constrainWithLowerBound, constrainWithUpperBound, getParameterTypeFromFunction, UnresolvedRAtomicVectorType, UnresolvedRFunctionType, UnresolvedRListType,
-	UnresolvedRTypeUnion,
-	UnresolvedRTypeVariable
-} from '../../../typing/subtyping/types';
-import { prettyPrint } from '../../../typing/pretty-print';
-import { ColorEffect, Colors } from '../../../util/text/ansi';
-
-interface FunctionTypeInformation {
-	readonly name:    string;
-	readonly package: string;
-	readonly type:    readonly RFunctionType[]
-}
-
-interface RohdeTypes {
-	readonly info: FunctionTypeInformation[];
-}
-
-interface TurcotteCsvRow {
-	readonly package_name:       string;
-	readonly function_name:      string;
-	readonly parameter_position: string;
-	readonly outer_alternative:  string;
-	readonly inner_alternative:  string;
-	readonly type:               string;
-	readonly count:              string;
-}
+	dumpRohdeTypesFromTurcotte,
+	recoverRohdeTypesFromTurcotteFromDump,
+	turcotte2RohdeTypes
+} from '../../../typing/adapter/turcotte-types';
+import { splitAtEscapeSensitive } from '../../../util/text/args';
+import { compressToUTF16, decompressFromUTF16 } from 'lz-string';
 
 
 export const replTurcotteTypeParseCommand: ReplCommand = {
 	description:  'Give me a file to read from and I will happily print you the types in the Rohde System!',
-	usageExample: ':turcotte-type-parse foo.csv',
+	usageExample: ':turcotte-type-parse foo.csv out.data',
 	aliases:      [ 'ttp',],
 	script:       false,
-	fn:           async(output, shell, remainingLine) => {
+	fn:           async(output, _shell, remainingLine) => {
+		const now = new Date();
 		if(!remainingLine.trim()) {
 			output.stderr('Please provide a file to read from. You do not need a prefix, just the file path.');
 			return;
 		}
-		const file = findSource(remainingLine.trim(), { referenceChain: [] });
-		if(file?.length !== 1) {
-			output.stderr(`Could not find a single file to read from. Got: ${JSON.stringify(file)}`);
+		const args = splitAtEscapeSensitive(remainingLine.trim());
+		if(args.length < 1 || args.length > 2) {
+			output.stderr(`Expected a single file to read from and and optional one to write to, got: ${JSON.stringify(args)}`);
+			return;
+		}
+		const [readFilePath, writeFilePath] = args as [string, string | undefined];
+		const readFile = findSource(readFilePath.trim(), { referenceChain: [] });
+		if(readFile?.length !== 1) {
+			output.stderr(`Could not find a single file to read from. Got: ${JSON.stringify(readFile)}`);
+			return;
+		}
+		const writeFile = writeFilePath ? findSource(writeFilePath.trim(), { referenceChain: [] }) : undefined;
+		if(writeFilePath && writeFile && writeFile.length > 0) {
+			output.stderr(`The output file already exists, will not overwrite: ${writeFilePath}`);
 			return;
 		}
 
+
 		const data: TurcotteCsvRow[] = [];
 		await new Promise(resolve => {
-			fs.createReadStream(file[0], { encoding: 'utf-8' })
+			fs.createReadStream(readFile[0], { encoding: 'utf-8' })
 				.pipe(csvParser({ separator: ',' }))
 				.on('data', (row: TurcotteCsvRow) => {
 					data.push(row);
@@ -67,238 +54,18 @@ export const replTurcotteTypeParseCommand: ReplCommand = {
 				.on('end', () => resolve(null));
 		});
 		const rohdeTypes: RohdeTypes = turcotte2RohdeTypes(data);
-		for(const info of rohdeTypes.info) {
-			if(info.type.length <= 1) {
-				output.stdout(output.formatter.format(`${info.package}::${info.name} :: `, { color: Colors.White, effect: ColorEffect.Foreground }) + prettyPrint(info.type[0]));
-				continue;
-			}
-			output.stdout(`${info.package}::${info.name} has ${info.type.length} alternatives`);
-			for(const type of info.type) {
-				output.stdout('  :: ' + prettyPrint(type));
-			}
-		}
-		output.stdout(`Parsed ${rohdeTypes.info.length} functions from ${file[0]}.`);
-	}
-};
-
-function groupTurcotteData<T>(data: readonly TurcotteCsvRow[], makeKey: (d: TurcotteCsvRow) => T): Map<T, TurcotteCsvRow[]> {
-	const grouped: Map<T, TurcotteCsvRow[]> = new Map();
-	for(const row of data) {
-		const key = makeKey(row);
-		if(!grouped.has(key)) {
-			grouped.set(key, []);
-		}
-		grouped.get(key)?.push(row);
-	}
-	return grouped;
-}
-
-function convertTurcotteFunction2RohdeType(fingerprint: string, rows: TurcotteCsvRow[]): FunctionTypeInformation {
-	guard(rows.length > 0, `No rows found for fingerprint ${fingerprint}`);
 
-	const anyRow = rows[0];
+		output.stdout(`Parsed ${rohdeTypes.info.length} functions from ${readFile[0]} in ${Date.now() - now.getTime()}ms.`);
 
-	// now we group them by their outer_alternative so that we can get the alternatives in order
-	const groupedByOuter = groupTurcotteData(rows, row => row.outer_alternative);
-
-	const type = [];
-	for(const [, innerRows] of groupedByOuter.entries()) {
-		type.push(convertSingleTurcotteFunctionAlternative2RohdeType(fingerprint, innerRows));
-	}
-
-	return {
-		package: anyRow.package_name,
-		name:    anyRow.function_name,
-		type
-	};
-}
-const globalCache: Map<UnresolvedDataType, { lowerBounds: Set<UnresolvedDataType>, upperBounds: Set<UnresolvedDataType> }> = new Map();
-
-function constrainLowerAndUpperBound(type: UnresolvedDataType, lowerBound: UnresolvedDataType, upperBound: UnresolvedDataType = lowerBound) {
-	constrainWithLowerBound(type, lowerBound, globalCache);
-	constrainWithUpperBound(type, upperBound, globalCache);
-	return type;
-}
-
-function convertSingleTurcotteFunctionAlternative2RohdeType(fingerprint: string, rows: TurcotteCsvRow[]): RFunctionType {
-	const groupedByParameterPos = groupTurcotteData(rows, row => row.parameter_position);
-	const fn = new UnresolvedRFunctionType();
-
-	for(const [parameterPosition, parameterRows] of groupedByParameterPos.entries()) {
-		// convert the rows to a single type
-		const type = convertSingleTurcotteParameter2RohdeType(fingerprint, parameterRows);
-		if(parameterPosition === '-1') {
-			constrainLowerAndUpperBound(fn.returnType, type);
-		} else {
-			// we get the type to create a new one if not already there
-			const parameterType = getParameterTypeFromFunction(fn, Number(parameterPosition));
-			// now we can set the type
-			constrainLowerAndUpperBound(parameterType, type);
+		if(writeFilePath) {
+			const startWrite = Date.now();
+			fs.writeFileSync(writeFilePath, compressToUTF16(dumpRohdeTypesFromTurcotte(rohdeTypes)), { encoding: 'utf-16le' });
+			output.stdout(`Wrote ${rohdeTypes.info.length} functions to ${writeFilePath} in ${Date.now() - startWrite}ms.`);
+			const startRead = Date.now();
+			const loadCheck = decompressFromUTF16(fs.readFileSync(writeFilePath, { encoding: 'utf-16le' }));
+			const recovered = recoverRohdeTypesFromTurcotteFromDump(loadCheck);
+			output.stdout(`[Test] Recovered ${recovered.info.length} functions from ${writeFilePath} in ${Date.now() - startRead}ms.`);
 		}
 	}
+};
 
-	return fn;
-}
-
-function convertSingleTurcotteParameter2RohdeType(fingerprint: string, rows: TurcotteCsvRow[]): UnresolvedDataType {
-	// every row here is an alternative for a single parameter position
-	guard(rows.length > 0, `No rows found for fingerprint ${fingerprint}`);
-	const anyRow = rows[0];
-	guard(rows.every(r =>
-		r.parameter_position === anyRow.parameter_position &&
-		r.package_name === anyRow.package_name &&
-		r.outer_alternative === anyRow.outer_alternative &&
-		r.function_name === anyRow.function_name), 'Just for my sanity, please!');
-
-	// now we convert all types in the list to the rohde System
-	return new UnresolvedRTypeUnion(
-		...rows.map(r => turcotteType2RohdeType(r.type))
-	);
-}
-
-
-function turcotteType2RohdeType(type: string): UnresolvedDataType {
-	const isArray = type.endsWith('[]');
-	if(isArray) {
-		type = type.slice(0, -2); // remove the []
-	}
-	// it may contain NAs, currently untracked by the Rohde System
-	if(type.startsWith('^')) {
-		type = type.slice(1); // remove the ^
-	}
-	let r: UnresolvedDataType | undefined = undefined;
-	switch(type) {
-		case 'any':         r = new UnresolvedRTypeVariable(); break;
-		case 'null':        r = new RNullType(); break;
-		case 'logical':     r = new RLogicalType(); break;
-		case 'integer':     r = new RIntegerType(); break;
-		case 'double':      r = new RDoubleType(); break;
-		case 'character':   r = new RStringType(); break;
-		case 'complex':     r = new RComplexType(); break;
-		case 'environment': r = new REnvironmentType(); break;
-		case 'raw':         r = new RRawType(); break;
-		case 'expression':  r = new RLanguageType(); break;
-		case 'externalptr': r = new UnresolvedRTypeVariable(); break;
-		case 'pairlist':    r = new UnresolvedRTypeVariable(); break;
-		default:
-			r = parseComplicatedTurcotteType(type);
-	}
-
-	guard(r !== undefined, `Unknown type ${JSON.stringify(type)} in Turcotte data!`);
-
-	if(isArray) {
-		if(r.tag !== DataTypeTag.Variable) {
-			const vectorType = new UnresolvedRAtomicVectorType();
-			constrainLowerAndUpperBound(vectorType.elementType, r);
-			r = vectorType;
-		} else {
-			r = new UnresolvedRAtomicVectorType(r);
-		}
-	}
-
-	return r;
-}
-
-function alternativeTurcotteType2RohdeType(type: string[]): UnresolvedDataType {
-	if(type.length === 0) {
-		return new UnresolvedRTypeVariable();
-	}
-	if(type.length === 1) {
-		return turcotteType2RohdeType(type[0]);
-	}
-	const types = type.map(t => turcotteType2RohdeType(t));
-	return new UnresolvedRTypeUnion(...types);
-}
-
-
-function turcotte2RohdeTypes(data: TurcotteCsvRow[]): RohdeTypes {
-	// why even?
-	guard(data.every(d => d.count === '1'), 'What the count?');
-
-	// first we group the data by package::function name to get the alternatives in order!
-	const groupedData = groupTurcotteData(data, row => `${row.package_name}::${row.function_name}`);
-
-	const info: FunctionTypeInformation[] = [];
-	for(const [fingerprint, rows] of groupedData.entries()) {
-		info.push(convertTurcotteFunction2RohdeType(fingerprint, rows));
-	}
-
-	return { info };
-}
-
-
-
-function parseComplicatedTurcotteType(type: string): UnresolvedDataType | undefined {
-	// everything up until the first parse <1, 2 | 3, 4 & 5> etc. recursively!
-	const [prefix, main] = type.split(/<(.*)/, 2);
-
-	// no can do's
-	switch(prefix) {
-		case 'class':
-			// Rohde currently does not support classes, so we just return a variable type
-			return new UnresolvedRTypeVariable();
-		case '...':
-			// there may be arbitrary more parameters - we do not know their type
-			return new UnresolvedRTypeVariable();
-	}
-
-	guard(main.endsWith('>'), `Invalid Turcotte type ${JSON.stringify(type)}!`);
-
-	const argString = main.slice(0, -1);
-
-	const params = collectParams(argString);
-
-	switch(prefix) {
-		case 'list': {
-			guard(params.length === 1, `List type ${JSON.stringify(type)} must have exactly one parameter!`);
-			const listType = new UnresolvedRListType();
-			constrainLowerAndUpperBound(listType.elementType, alternativeTurcotteType2RohdeType(params[0]));
-			return listType;
-		}
-
-	}
-
-	return undefined;
-}
-
-// collect params, splitting on alternatives '|'
-function collectParams(argString: string): string[][] {
-	// split at comma but respect nestings with <>
-	const params: string[][] = [];
-	const currentParamAlternatives: string[] = [];
-	let current = '';
-	let depth = 0;
-	let quoted = false;
-	for(const char of argString) {
-		if(char === '"' || char === "'" || char === '`') {
-			quoted = !quoted; // toggle quoted state
-			current += char;
-			continue;
-		}
-		if(char === '<' && !quoted) {
-			depth++;
-		} else if(char === '>' && !quoted) {
-			depth--;
-		} else if(!quoted && char === ',' && depth === 0) {
-			params.push([...currentParamAlternatives, current.trim()]);
-			current = '';
-			continue;
-		} else if(char === '|' && !quoted && depth === 0) {
-			// split on alternatives
-			if(current.trim().length > 0) {
-				currentParamAlternatives.push(current.trim());
-			}
-			current = '';
-			continue;
-		}
-		current += char;
-	}
-
-	if(current.trim().length > 0) {
-		currentParamAlternatives.push(current.trim());
-	}
-	if(currentParamAlternatives.length > 0) {
-		params.push(currentParamAlternatives);
-	}
-	return params;
-}
\ No newline at end of file
diff --git a/src/typing/adapter/turcotte-types.ts b/src/typing/adapter/turcotte-types.ts
new file mode 100644
index 00000000000..94734176954
--- /dev/null
+++ b/src/typing/adapter/turcotte-types.ts
@@ -0,0 +1,371 @@
+import { guard } from '../../util/assert';
+import type {
+	DataType,
+	RFunctionType } from '../types';
+import {
+	DataTypeTag,
+	RComplexType,
+	RDoubleType,
+	REnvironmentType,
+	RIntegerType,
+	RLanguageType,
+	RLogicalType,
+	RNullType,
+	RRawType,
+	RStringType
+} from '../types';
+import type {
+	UnresolvedDataType } from '../subtyping/types';
+import {
+	constrainWithLowerBound,
+	constrainWithUpperBound,
+	getParameterTypeFromFunction,
+	UnresolvedRAtomicVectorType,
+	UnresolvedRFunctionType,
+	UnresolvedRListType,
+	UnresolvedRTypeUnion,
+	UnresolvedRTypeVariable
+} from '../subtyping/types';
+import { jsonReplacer } from '../../util/json';
+
+export interface RohdeFunctionTypeInformation {
+    readonly name:    string;
+    readonly package: string;
+    readonly type:    readonly RFunctionType[]
+}
+
+export interface RohdeConstantTypeInformation {
+    readonly name:    string;
+    readonly package: string;
+    readonly type:    UnresolvedDataType;
+}
+
+export interface RohdeTypes {
+    readonly info: (RohdeFunctionTypeInformation | RohdeConstantTypeInformation)[];
+}
+
+export interface TurcotteCsvRow {
+    readonly package_name:       string;
+    readonly function_name:      string;
+    readonly parameter_position: string;
+    readonly outer_alternative:  string;
+    readonly inner_alternative:  string;
+    readonly type:               string;
+    readonly count:              string;
+}
+
+function groupTurcotteData<T>(data: readonly TurcotteCsvRow[], makeKey: (d: TurcotteCsvRow) => T): Map<T, TurcotteCsvRow[]> {
+	const grouped: Map<T, TurcotteCsvRow[]> = new Map();
+	for(const row of data) {
+		const key = makeKey(row);
+		if(!grouped.has(key)) {
+			grouped.set(key, []);
+		}
+		grouped.get(key)?.push(row);
+	}
+	return grouped;
+}
+
+function convertTurcotteFunction2RohdeType(fingerprint: string, rows: TurcotteCsvRow[]): RohdeFunctionTypeInformation {
+	guard(rows.length > 0, `No rows found for fingerprint ${fingerprint}`);
+
+	const anyRow = rows[0];
+
+	// now we group them by their outer_alternative so that we can get the alternatives in order
+	const groupedByOuter = groupTurcotteData(rows, row => row.outer_alternative);
+
+	const type = [];
+	for(const [, innerRows] of groupedByOuter.entries()) {
+		type.push(convertSingleTurcotteFunctionAlternative2RohdeType(fingerprint, innerRows));
+	}
+
+	return {
+		package: anyRow.package_name,
+		name:    anyRow.function_name,
+		type
+	};
+}
+
+const globalCache: Map<UnresolvedDataType, {
+    lowerBounds: Set<UnresolvedDataType>,
+    upperBounds: Set<UnresolvedDataType>
+}> = new Map();
+
+function constrainLowerAndUpperBound(type: UnresolvedDataType, lowerBound: UnresolvedDataType, upperBound: UnresolvedDataType = lowerBound) {
+	constrainWithLowerBound(type, lowerBound, globalCache);
+	constrainWithUpperBound(type, upperBound, globalCache);
+	return type;
+}
+
+function convertSingleTurcotteFunctionAlternative2RohdeType(fingerprint: string, rows: TurcotteCsvRow[]): RFunctionType {
+	const groupedByParameterPos = groupTurcotteData(rows, row => row.parameter_position);
+	const fn = new UnresolvedRFunctionType();
+
+	for(const [parameterPosition, parameterRows] of groupedByParameterPos.entries()) {
+		// convert the rows to a single type
+		const type = convertSingleTurcotteParameter2RohdeType(fingerprint, parameterRows);
+		if(parameterPosition === '-1') {
+			constrainLowerAndUpperBound(fn.returnType, type);
+		} else {
+			// we get the type to create a new one if not already there
+			const parameterType = getParameterTypeFromFunction(fn, Number(parameterPosition));
+			// now we can set the type
+			constrainLowerAndUpperBound(parameterType, type);
+		}
+	}
+
+	return fn;
+}
+
+function convertSingleTurcotteParameter2RohdeType(fingerprint: string, rows: TurcotteCsvRow[]): UnresolvedDataType {
+	// every row here is an alternative for a single parameter position
+	guard(rows.length > 0, `No rows found for fingerprint ${fingerprint}`);
+	const anyRow = rows[0];
+	guard(rows.every(r =>
+		r.parameter_position === anyRow.parameter_position &&
+        r.package_name === anyRow.package_name &&
+        r.outer_alternative === anyRow.outer_alternative &&
+        r.function_name === anyRow.function_name), 'Just for my sanity, please!');
+
+	// now we convert all types in the list to the rohde System
+	return new UnresolvedRTypeUnion(
+		...rows.map(r => turcotteType2RohdeType(r.type))
+	);
+}
+
+function turcotteType2RohdeType(type: string): UnresolvedDataType {
+	const isArray = type.endsWith('[]');
+	if(isArray) {
+		type = type.slice(0, -2); // remove the []
+	}
+	// it may contain NAs, currently untracked by the Rohde System
+	if(type.startsWith('^')) {
+		type = type.slice(1); // remove the ^
+	}
+	let r: UnresolvedDataType | undefined;
+	switch(type) {
+		case 'any':
+			r = new UnresolvedRTypeVariable();
+			break;
+		case 'null':
+			r = new RNullType();
+			break;
+		case 'logical':
+			r = new RLogicalType();
+			break;
+		case 'integer':
+			r = new RIntegerType();
+			break;
+		case 'double':
+			r = new RDoubleType();
+			break;
+		case 'character':
+			r = new RStringType();
+			break;
+		case 'complex':
+			r = new RComplexType();
+			break;
+		case 'environment':
+			r = new REnvironmentType();
+			break;
+		case 'raw':
+			r = new RRawType();
+			break;
+		case 'expression':
+			r = new RLanguageType();
+			break;
+		case 'externalptr':
+			r = new UnresolvedRTypeVariable();
+			break;
+		case 'pairlist':
+			r = new UnresolvedRTypeVariable();
+			break;
+		default:
+			r = parseComplicatedTurcotteType(type);
+	}
+
+	guard(r !== undefined, `Unknown type ${JSON.stringify(type)} in Turcotte data!`);
+
+	if(isArray) {
+		if(r.tag !== DataTypeTag.Variable) {
+			const vectorType = new UnresolvedRAtomicVectorType();
+			constrainLowerAndUpperBound(vectorType.elementType, r);
+			r = vectorType;
+		} else {
+			r = new UnresolvedRAtomicVectorType(r);
+		}
+	}
+
+	return r;
+}
+
+function alternativeTurcotteType2RohdeType(type: string[]): UnresolvedDataType {
+	if(type.length === 0) {
+		return new UnresolvedRTypeVariable();
+	}
+	if(type.length === 1) {
+		return turcotteType2RohdeType(type[0]);
+	}
+	const types = type.map(t => turcotteType2RohdeType(t));
+	return new UnresolvedRTypeUnion(...types);
+}
+
+/**
+ * Take in types mined by Turcotte et al. (e.g., https://github.com/PRL-PRG/OOPSLA20-typer-artifact)
+ * and convert them to the type system used in flowR.
+ */
+export function turcotte2RohdeTypes(data: readonly TurcotteCsvRow[]): RohdeTypes {
+	// why even?
+	guard(data.every(d => d.count === '1'), 'What the count?');
+
+	// first we group the data by package::function name to get the alternatives in order!
+	const groupedData = groupTurcotteData(data, row => `${row.package_name}::${row.function_name}`);
+
+	const info: RohdeFunctionTypeInformation[] = [];
+	for(const [fingerprint, rows] of groupedData.entries()) {
+		info.push(convertTurcotteFunction2RohdeType(fingerprint, rows));
+	}
+
+	return { info };
+}
+
+function parseComplicatedTurcotteType(type: string): UnresolvedDataType | undefined {
+	// everything up until the first parse <1, 2 | 3, 4 & 5> etc. recursively!
+	const [prefix, main] = type.split(/<(.*)/, 2);
+
+	// no can do's
+	switch(prefix) {
+		case 'class':
+			// Rohde currently does not support classes, so we just return a variable type
+			return new UnresolvedRTypeVariable();
+		case '...':
+			// there may be arbitrary more parameters - we do not know their type
+			return new UnresolvedRTypeVariable();
+	}
+
+	guard(main.endsWith('>'), `Invalid Turcotte type ${JSON.stringify(type)}!`);
+
+	const argString = main.slice(0, -1);
+
+	const params = collectParams(argString);
+
+	switch(prefix) {
+		case 'list': {
+			guard(params.length === 1, `List type ${JSON.stringify(type)} must have exactly one parameter!`);
+			const listType = new UnresolvedRListType();
+			constrainLowerAndUpperBound(listType.elementType, alternativeTurcotteType2RohdeType(params[0]));
+			return listType;
+		}
+
+	}
+
+	return undefined;
+}
+
+// collect params, splitting on alternatives '|'
+function collectParams(argString: string): string[][] {
+	// split at comma but respect nestings with <>
+	const params: string[][] = [];
+	const currentParamAlternatives: string[] = [];
+	let current = '';
+	let depth = 0;
+	let quoted = false;
+	for(const char of argString) {
+		if(char === '"' || char === "'" || char === '`') {
+			quoted = !quoted; // toggle quoted state
+			current += char;
+			continue;
+		}
+		if(char === '<' && !quoted) {
+			depth++;
+		} else if(char === '>' && !quoted) {
+			depth--;
+		} else if(!quoted && char === ',' && depth === 0) {
+			params.push([...currentParamAlternatives, current.trim()]);
+			current = '';
+			continue;
+		} else if(char === '|' && !quoted && depth === 0) {
+			// split on alternatives
+			if(current.trim().length > 0) {
+				currentParamAlternatives.push(current.trim());
+			}
+			current = '';
+			continue;
+		}
+		current += char;
+	}
+
+	if(current.trim().length > 0) {
+		currentParamAlternatives.push(current.trim());
+	}
+	if(currentParamAlternatives.length > 0) {
+		params.push(currentParamAlternatives);
+	}
+	return params;
+}
+
+
+function isDataType(value: unknown): value is DataType {
+	return typeof value === 'object' && value !== null && 'tag' in value && typeof value.tag === 'string' && value.tag in DataTypeTag;
+}
+
+function rohdeReplacer(key: string, value: unknown): unknown {
+	if(value instanceof Map) {
+		return { __class: 'Map', entries: Array.from(value.entries()) };
+	} else if(value instanceof Set) {
+		return { __class: 'Set', entries: Array.from(value.values()) };
+	} else if(isDataType(value)) {
+		return { ...value, __class: value.constructor.name };
+	}
+	return jsonReplacer(key, value);
+
+}
+
+/**
+ * serializer of rohde types in a recoverable format.
+ */
+export function dumpRohdeTypesFromTurcotte(types: RohdeTypes): string {
+	return JSON.stringify(types, rohdeReplacer, 0);
+}
+
+
+function rohdeReviver(key: string, value: unknown): unknown {
+	if(typeof value === 'object' && value !== null && '__class' in value) {
+		switch(value.__class) {
+			case DataTypeTag.Null:
+				return new RNullType();
+			case DataTypeTag.Logical:
+				return new RLogicalType();
+			case DataTypeTag.Integer:
+				return new RIntegerType();
+			case DataTypeTag.Double:
+				return new RDoubleType();
+			case DataTypeTag.String:
+				return new RStringType();
+			case DataTypeTag.Complex:
+				return new RComplexType();
+			case DataTypeTag.Environment:
+				return new REnvironmentType();
+			case DataTypeTag.Raw:
+				return new RRawType();
+			case DataTypeTag.Language:
+				return new RLanguageType();
+			case 'UnresolvedRAtomicVectorType':
+				return new UnresolvedRAtomicVectorType((value as unknown as UnresolvedRAtomicVectorType).elementType);
+			case 'UnresolvedRListType':
+				return new UnresolvedRListType((value as unknown as UnresolvedRListType).elementType);
+			case 'Map':
+				return new Map((value as unknown as { entries: [string, unknown][] }).entries);
+			case 'Set':
+				return new Set((value as unknown as { entries: unknown[] }).entries);
+			default:
+				throw new Error(`Unknown class ${JSON.stringify(value)} in Rohde types!`);
+		}
+	} else {
+		return value;
+	}
+}
+
+export function recoverRohdeTypesFromTurcotteFromDump(dump: string): RohdeTypes {
+	return JSON.parse(dump, rohdeReviver) as RohdeTypes;
+}
\ No newline at end of file
diff --git a/src/typing/pretty-print.ts b/src/typing/pretty-print.ts
index 71018f6b187..89d660bf505 100644
--- a/src/typing/pretty-print.ts
+++ b/src/typing/pretty-print.ts
@@ -8,6 +8,10 @@ function isAny(t: DataType): boolean {
         t.upperBound.tag === DataTypeTag.Intersection && t.upperBound.types.size === 0;
 }
 
+/**
+ * Visualize a {@link DataType} as a string.
+ * The `shorten` parameter will do sever simplification so should not be used for debugging but just for display purposes.
+ */
 export function prettyPrint(t: DataType, shorten = true): string {
 	const tag = t.tag;
 	if(isAny(t)) {

From 548c2bc4b567c12b12372e026c8279513f550b47 Mon Sep 17 00:00:00 2001
From: Lukas Rohde <lukas.rohde@silupe.de>
Date: Sat, 26 Jul 2025 16:41:35 +0200
Subject: [PATCH 105/153] refactor(typing): refactor constraint handling
 functions

---
 src/typing/subtyping/infer.ts                 |  24 +--
 src/typing/subtyping/types.ts                 | 193 ++++++------------
 src/typing/unification/infer.ts               |   7 +-
 src/typing/unification/types.ts               |  30 +--
 .../typing/subtyping/constrain.test.ts        |  94 ++++-----
 5 files changed, 134 insertions(+), 214 deletions(-)

diff --git a/src/typing/subtyping/infer.ts b/src/typing/subtyping/infer.ts
index 77e7ed326f5..d6a2d3b4a58 100644
--- a/src/typing/subtyping/infer.ts
+++ b/src/typing/subtyping/infer.ts
@@ -24,7 +24,7 @@ import { RType } from '../../r-bridge/lang-4.x/ast/model/type';
 import type { NoInfo, RNode } from '../../r-bridge/lang-4.x/ast/model/model';
 import { RFalse, RTrue } from '../../r-bridge/lang-4.x/convert-values';
 import type { UnresolvedDataType } from './types';
-import { constrainWithLowerBound, constrainWithUpperBound, getIndexedElementTypeFromList, getParameterTypeFromFunction, resolveType, UnresolvedRAtomicVectorType, UnresolvedRFunctionType, UnresolvedRListType, UnresolvedRTypeUnion, UnresolvedRTypeVariable } from './types';
+import { constrain, getIndexedElementTypeFromList, getParameterTypeFromFunction, resolve, UnresolvedRAtomicVectorType, UnresolvedRFunctionType, UnresolvedRListType, UnresolvedRTypeUnion, UnresolvedRTypeVariable } from './types';
 
 export function inferDataTypes<Info extends ParentInformation & { typeVariable?: undefined }>(ast: NormalizedAst<ParentInformation & Info>, dataflowInfo: DataflowInformation): NormalizedAst<Info & DataTypeInfo> {
 	const astWithTypeVars = decorateTypeVariables(ast);
@@ -54,7 +54,7 @@ function resolveTypeVariables<Info extends ParentInformation & UnresolvedTypeInf
 	const cache = new Map<UnresolvedDataType, DataType>();
 	return mapNormalizedAstInfo(ast, node => {
 		const { typeVariable, ...rest } = node.info;
-		return { ...rest, inferredType: resolveType(typeVariable, cache) };
+		return { ...rest, inferredType: resolve(typeVariable, cache) };
 	});
 }
 
@@ -78,7 +78,7 @@ class TypeInferringCfgGuidedVisitor<
 		super({ dataflow: config.dataflowInfo.graph, ...config });
 	}
 
-	protected constraintCache: Map<UnresolvedDataType, { lowerBounds: Set<UnresolvedDataType>, upperBounds: Set<UnresolvedDataType> }> = new Map();
+	protected constraintCache: Map<UnresolvedDataType, Set<UnresolvedDataType>> = new Map();
 
 
 	protected constrainNodeType(nodeOrId: RNode<UnresolvedTypeInfo> | NodeId, constraint: UnresolvedDataType | { lowerBound?: UnresolvedDataType, upperBound?: UnresolvedDataType }): void {
@@ -89,10 +89,10 @@ class TypeInferringCfgGuidedVisitor<
 		const upperBound = 'tag' in constraint ? constraint : constraint.upperBound;
 
 		if(lowerBound !== undefined) {
-			constrainWithLowerBound(node.info.typeVariable, lowerBound, this.constraintCache);
+			constrain(lowerBound, node.info.typeVariable, this.constraintCache);
 		}
 		if(upperBound !== undefined) {
-			constrainWithUpperBound(node.info.typeVariable, upperBound, this.constraintCache);
+			constrain(node.info.typeVariable, upperBound, this.constraintCache);
 		}
 	}
 
@@ -182,9 +182,9 @@ class TypeInferringCfgGuidedVisitor<
 					guard(argNode !== undefined, 'Expected argument node to be defined');
 
 					if(arg.name !== undefined) {
-						constrainWithLowerBound(getParameterTypeFromFunction(functionType, arg.name), argNode.info.typeVariable, this.constraintCache);
+						constrain(argNode.info.typeVariable, getParameterTypeFromFunction(functionType, arg.name), this.constraintCache);
 					} else {
-						constrainWithLowerBound(getParameterTypeFromFunction(functionType, index), argNode.info.typeVariable, this.constraintCache);
+						constrain(argNode.info.typeVariable, getParameterTypeFromFunction(functionType, index), this.constraintCache);
 					}
 				}
 
@@ -326,10 +326,10 @@ class TypeInferringCfgGuidedVisitor<
 			const argNode = this.getNormalizedAst(arg.nodeId);
 			guard(argNode !== undefined, 'Expected argument node to be defined');
 
-			constrainWithLowerBound(getIndexedElementTypeFromList(listType, index, this.constraintCache), argNode.info.typeVariable, this.constraintCache);
+			constrain(argNode.info.typeVariable, getIndexedElementTypeFromList(listType, index, this.constraintCache), this.constraintCache);
 
 			if(arg.name !== undefined) {
-				constrainWithLowerBound(getIndexedElementTypeFromList(listType, arg.name, this.constraintCache), argNode.info.typeVariable, this.constraintCache);
+				constrain(argNode.info.typeVariable, getIndexedElementTypeFromList(listType, arg.name, this.constraintCache), this.constraintCache);
 			}
 		}
 	}
@@ -349,7 +349,7 @@ class TypeInferringCfgGuidedVisitor<
 			const argNode = this.getNormalizedAst(arg.nodeId);
 			guard(argNode !== undefined, 'Expected argument node to be defined');
 			this.constrainNodeType(argNode, { upperBound: new UnresolvedRAtomicVectorType() });
-			constrainWithLowerBound(vectorType, argNode.info.typeVariable, this.constraintCache);
+			constrain(argNode.info.typeVariable, vectorType, this.constraintCache);
 		}
 	}
 
@@ -369,9 +369,9 @@ class TypeInferringCfgGuidedVisitor<
 
 			if(!dotsEncountered) {
 				// Only constrain the parameter type positionally if no `...` has been encountered yet
-				constrainWithUpperBound(getParameterTypeFromFunction(functionType, index), param.info.typeVariable, this.constraintCache);
+				constrain(getParameterTypeFromFunction(functionType, index), param.info.typeVariable, this.constraintCache);
 			}
-			constrainWithUpperBound(getParameterTypeFromFunction(functionType, param.name.lexeme), param.info.typeVariable, this.constraintCache);
+			constrain(getParameterTypeFromFunction(functionType, param.name.lexeme), param.info.typeVariable, this.constraintCache);
 
 			if(param.defaultValue !== undefined) {
 				this.constrainNodeType(param, { lowerBound: param.defaultValue.info.typeVariable });
diff --git a/src/typing/subtyping/types.ts b/src/typing/subtyping/types.ts
index 4b3314724e6..3d5a6505492 100644
--- a/src/typing/subtyping/types.ts
+++ b/src/typing/subtyping/types.ts
@@ -25,13 +25,13 @@ export class UnresolvedRListType {
 	}
 }
 
-export function getIndexedElementTypeFromList(list: UnresolvedRListType, indexOrName: number | string, constraintCache: Map<UnresolvedDataType, { lowerBounds: Set<UnresolvedDataType>, upperBounds: Set<UnresolvedDataType> }>): UnresolvedRTypeVariable {
+export function getIndexedElementTypeFromList(list: UnresolvedRListType, indexOrName: number | string, constraintCache: Map<UnresolvedDataType, Set<UnresolvedDataType>>): UnresolvedRTypeVariable {
 	let elementType = list.indexedElementTypes.get(indexOrName);
 	if(elementType === undefined) {
 		elementType = new UnresolvedRTypeVariable();
-		constrainWithUpperBound(elementType, list.elementType.upperBound, constraintCache);
+		constrain(elementType, list.elementType.upperBound, constraintCache);
 		list.indexedElementTypes.set(indexOrName, elementType);
-		constrainWithLowerBound(list.elementType, elementType, constraintCache);
+		constrain(elementType, list.elementType, constraintCache);
 	}
 	return elementType;
 }
@@ -87,147 +87,75 @@ export class UnresolvedRTypeVariable {
 	readonly upperBound = new UnresolvedRTypeIntersection();
 }
 
-
-export function constrainWithLowerBound(type: UnresolvedDataType, bound: UnresolvedDataType, cache: Map<UnresolvedDataType, { lowerBounds: Set<UnresolvedDataType>, upperBounds: Set<UnresolvedDataType> }>): void {
-	// console.debug('constraining', type, 'with lower bound', bound);
-
-	if(type === bound) {
-		return; // No need to constrain if both types are the same
-	}
-
-	const cachedConstraints = cache.get(type);
-	if(cachedConstraints?.lowerBounds.has(bound)) {
-		return; // Avoid infinite recursion
-	}
-	if(cachedConstraints !== undefined) {
-		cachedConstraints.lowerBounds.add(bound);
-	} else {
-		cache.set(type, { lowerBounds: new Set([bound]), upperBounds: new Set() });
-	}
-
-	if(type instanceof UnresolvedRTypeVariable) {
-		type.lowerBound.types.add(bound);
-		for(const upperBound of type.upperBound.types) {
-			constrainWithLowerBound(upperBound, bound, cache);
-		}
-	} else if(bound instanceof UnresolvedRTypeVariable) {
-		// constrainWithUpperBound(bound, type);
-		bound.upperBound.types.add(type);
-		for(const lowerBound of bound.lowerBound.types) {
-			constrainWithLowerBound(type, lowerBound, cache);
-		}
-	} else if(type instanceof UnresolvedRTypeUnion) {
-		for(const subtype of type.types.values()) {
-			if(!subsumes(bound, subtype)) {
-				// console.debug('Removing subtype', subtype, 'from union', type, 'because it does not subsume the bound', bound);
-				type.types.delete(subtype);
-			} else {
-				constrainWithLowerBound(subtype, bound, cache);
-			}
-		}
-	} else if(bound instanceof UnresolvedRTypeUnion) {
-		// constrainWithUpperBound(bound, type);
-		for(const subtype of bound.types) {
-			constrainWithLowerBound(type, subtype, cache);
-		}
-	} else if(type instanceof UnresolvedRTypeIntersection) {
-		for(const subtype of type.types) {
-			constrainWithLowerBound(subtype, bound, cache);
-		}
-	} else if(bound instanceof UnresolvedRTypeIntersection) {
-		// constrainWithUpperBound(bound, type);
-		for(const subtype of bound.types.values()) {
-			if(!subsumes(subtype, type)) {
-				// console.debug('Removing subtype', subtype, 'from intersection', bound, 'because it does not subsume the type', type);
-				bound.types.delete(subtype);
-			} else {
-				constrainWithLowerBound(type, subtype, cache);
-			}
-		}
-	} else if(type instanceof UnresolvedRFunctionType && bound instanceof UnresolvedRFunctionType) {
-		for(const [key, paramType] of bound.parameterTypes) {
-			constrainWithUpperBound(getParameterTypeFromFunction(type, key), paramType, cache);
-		}
-		constrainWithLowerBound(type.returnType, bound.returnType, cache);
-	} else if(type instanceof UnresolvedRAtomicVectorType && bound instanceof UnresolvedRAtomicVectorType) {
-		constrainWithLowerBound(type.elementType, bound.elementType, cache);
-	} else if(type instanceof UnresolvedRAtomicVectorType && isAtomicVectorBaseType(bound)) {
-		constrainWithLowerBound(type.elementType, bound, cache);
-	} else if(type instanceof UnresolvedRListType && bound instanceof UnresolvedRListType) {
-		constrainWithLowerBound(type.elementType, bound.elementType, cache);
-	}
-}
-
-export function constrainWithUpperBound(type: UnresolvedDataType, bound: UnresolvedDataType, cache: Map<UnresolvedDataType, { lowerBounds: Set<UnresolvedDataType>, upperBounds: Set<UnresolvedDataType> }>): void {
+export function constrain(subtype: UnresolvedDataType, supertype: UnresolvedDataType, cache: Map<UnresolvedDataType, Set<UnresolvedDataType>>): void {
 	// console.debug('constraining', type, 'with upper bound', bound);
 
-	if(type === bound) {
+	if(subtype === supertype) {
 		return; // No need to constrain if both types are the same
 	}
 
-	const cachedConstraints = cache.get(type);
-	if(cachedConstraints?.upperBounds.has(bound)) {
+	const cachedConstraints = cache.get(subtype);
+	if(cachedConstraints?.has(supertype)) {
 		return; // Avoid infinite recursion
 	}
 	if(cachedConstraints !== undefined) {
-		cachedConstraints.upperBounds.add(bound);
+		cachedConstraints.add(supertype);
 	} else {
-		cache.set(type, { lowerBounds: new Set(), upperBounds: new Set([bound]) });
+		cache.set(subtype, new Set([supertype]));
 	}
 
-	if(type instanceof UnresolvedRTypeVariable) {
-		type.upperBound.types.add(bound);
-		for(const lowerBound of type.lowerBound.types) {
-			constrainWithUpperBound(lowerBound, bound, cache);
+	if(subtype instanceof UnresolvedRTypeVariable) {
+		subtype.upperBound.types.add(supertype);
+		for(const lowerBound of subtype.lowerBound.types) {
+			constrain(lowerBound, supertype, cache);
 		}
-	} else if(bound instanceof UnresolvedRTypeVariable) {
-		// constrainWithLowerBound(bound, type);
-		bound.lowerBound.types.add(type);
-		for(const upperBound of bound.upperBound.types) {
-			constrainWithUpperBound(type, upperBound, cache);
+	} else if(supertype instanceof UnresolvedRTypeVariable) {
+		supertype.lowerBound.types.add(subtype);
+		for(const upperBound of supertype.upperBound.types) {
+			constrain(subtype, upperBound, cache);
 		}
-	} else if(type instanceof UnresolvedRTypeUnion) {
-		for(const subtype of type.types) {
-			constrainWithUpperBound(subtype, bound, cache);
+	} else if(subtype instanceof UnresolvedRTypeUnion) {
+		for(const type of subtype.types) {
+			constrain(type, supertype, cache);
 		}
-	} else if(bound instanceof UnresolvedRTypeUnion) {
-		// constrainWithLowerBound(bound, type);
-		for(const subtype of bound.types.values()) {
-			if(!subsumes(type, subtype)) {
-				// console.debug('Removing subtype', subtype, 'from union', bound, 'because it does not subsume the type', type);
-				bound.types.delete(subtype);
+	} else if(supertype instanceof UnresolvedRTypeUnion) {
+		for(const type of supertype.types.values()) {
+			if(!subsumes(subtype, type)) {
+				supertype.types.delete(type);
 			} else {
-				constrainWithUpperBound(type, subtype, cache);
+				constrain(subtype, type, cache);
 			}
 		}
-	} else if(type instanceof UnresolvedRTypeIntersection) {
-		for(const subtype of type.types.values()) {
-			if(!subsumes(subtype, bound)) {
-				// console.debug('Removing subtype', subtype, 'from intersection', type, 'because it does not subsume the bound', bound);
-				type.types.delete(subtype);
+	} else if(subtype instanceof UnresolvedRTypeIntersection) {
+		for(const type of subtype.types.values()) {
+			if(!subsumes(type, supertype)) {
+				subtype.types.delete(type);
 			} else {
-				constrainWithUpperBound(subtype, bound, cache);
+				constrain(type, supertype, cache);
 			}
 		}
-	} else if(bound instanceof UnresolvedRTypeIntersection) {
-		// constrainWithLowerBound(bound, type);
-		for(const subtype of bound.types) {
-			constrainWithUpperBound(type, subtype, cache);
+	} else if(supertype instanceof UnresolvedRTypeIntersection) {
+		for(const type of supertype.types) {
+			constrain(type, type, cache);
 		}
-	} else if(type instanceof UnresolvedRFunctionType && bound instanceof UnresolvedRFunctionType) {
-		for(const [key, paramType] of bound.parameterTypes) {
-			constrainWithLowerBound(getParameterTypeFromFunction(type, key), paramType, cache);
+	} else if(subtype instanceof UnresolvedRFunctionType && supertype instanceof UnresolvedRFunctionType) {
+		const subtypeParameterKeys = new Set(subtype.parameterTypes.keys());
+		const supertypeParameterKeys = new Set(supertype.parameterTypes.keys());
+		for(const key of subtypeParameterKeys.union(supertypeParameterKeys)) {
+			constrain(getParameterTypeFromFunction(supertype, key), getParameterTypeFromFunction(subtype, key), cache);
 		}
-		constrainWithUpperBound(type.returnType, bound.returnType, cache);
-	} else if(type instanceof UnresolvedRAtomicVectorType && bound instanceof UnresolvedRAtomicVectorType) {
-		constrainWithUpperBound(type.elementType, bound.elementType, cache);
-	} else if(type instanceof UnresolvedRListType && bound instanceof UnresolvedRListType) {
-		constrainWithUpperBound(type.elementType, bound.elementType, cache);
+		constrain(subtype.returnType, supertype.returnType, cache);
+	} else if(subtype instanceof UnresolvedRAtomicVectorType && supertype instanceof UnresolvedRAtomicVectorType) {
+		constrain(subtype.elementType, supertype.elementType, cache);
+	} else if(isAtomicVectorBaseType(subtype) && supertype instanceof UnresolvedRAtomicVectorType) {
+		constrain(subtype, supertype.elementType, cache);
+	} else if(subtype instanceof UnresolvedRListType && supertype instanceof UnresolvedRListType) {
+		constrain(subtype.elementType, supertype.elementType, cache);
 	}
 }
 
 
-export function resolveType(type: UnresolvedDataType, cache: Map<UnresolvedDataType, DataType> = new Map()): DataType {
+export function resolve(type: UnresolvedDataType, cache: Map<UnresolvedDataType, DataType> = new Map()): DataType {
 	const cachedType = cache.get(type);
 	if(cachedType !== undefined) {
 		return cachedType;
@@ -236,8 +164,8 @@ export function resolveType(type: UnresolvedDataType, cache: Map<UnresolvedDataT
 	if(type instanceof UnresolvedRTypeVariable) {
 		cache.set(type, new RTypeVariable()); // Prevent infinite recursion
 
-		const lowerBound = resolveType(type.lowerBound, cache);
-		const upperBound = resolveType(type.upperBound, cache);
+		const lowerBound = resolve(type.lowerBound, cache);
+		const upperBound = resolve(type.upperBound, cache);
 
 		if(!subsumes(lowerBound, upperBound)) {
 			const errorType = new RTypeError(lowerBound, upperBound);
@@ -261,7 +189,7 @@ export function resolveType(type: UnresolvedDataType, cache: Map<UnresolvedDataT
 
 		let resolvedType: DataType = new RTypeUnion();
 		for(const subtype of type.types) {
-			const resolvedSubtype = resolveType(subtype, cache);
+			const resolvedSubtype = resolve(subtype, cache);
 			resolvedType = join(resolvedType, resolvedSubtype);
 		}
 		cache.set(type, resolvedType);
@@ -271,25 +199,25 @@ export function resolveType(type: UnresolvedDataType, cache: Map<UnresolvedDataT
 
 		let resolvedType: DataType = new RTypeIntersection();
 		for(const subtype of type.types) {
-			const resolvedSubtype = resolveType(subtype, cache);
+			const resolvedSubtype = resolve(subtype, cache);
 			resolvedType = meet(resolvedType, resolvedSubtype);
 		}
 		cache.set(type, resolvedType);
 		return resolvedType;
 	} else if(type instanceof UnresolvedRFunctionType) {
-		const resolvedParameterTypes = new Map(type.parameterTypes.entries().toArray().map(([key, type]) => [key, resolveType(type, cache)]));
-		const resolvedReturnType = resolveType(type.returnType, cache);
+		const resolvedParameterTypes = new Map(type.parameterTypes.entries().toArray().map(([key, type]) => [key, resolve(type, cache)]));
+		const resolvedReturnType = resolve(type.returnType, cache);
 		const resolvedType = new RFunctionType(resolvedParameterTypes, resolvedReturnType);
 		cache.set(type, resolvedType);
 		return resolvedType;
 	} else if(type instanceof UnresolvedRAtomicVectorType) {
-		const resolvedElementType = resolveType(type.elementType, cache);
+		const resolvedElementType = resolve(type.elementType, cache);
 		const resolvedType = new RAtomicVectorType(resolvedElementType);
 		cache.set(type, resolvedType);
 		return resolvedType;
 	} else if(type instanceof UnresolvedRListType) {
-		const resolvedElementType = resolveType(type.elementType, cache);
-		const resolvedIndexedElementTypes = new Map(type.indexedElementTypes.entries().map(([indexOrName, elementType]) => [indexOrName, resolveType(elementType, cache)]));
+		const resolvedElementType = resolve(type.elementType, cache);
+		const resolvedIndexedElementTypes = new Map(type.indexedElementTypes.entries().map(([indexOrName, elementType]) => [indexOrName, resolve(elementType, cache)]));
 		const resolvedType = new RListType(resolvedElementType, resolvedIndexedElementTypes);
 		cache.set(type, resolvedType);
 		return resolvedType;
@@ -326,12 +254,11 @@ function subsumes(subtype: DataType | UnresolvedDataType, supertype: DataType |
 		// A scalar subsumes a vector type if it subsumes the element type of the vector
 		return subsumes(subtype, supertype.elementType);
 	} else if(subtype.tag === DataTypeTag.Function && supertype.tag === DataTypeTag.Function) {
-		return subsumes(subtype.returnType, supertype.returnType) && subtype.parameterTypes.entries().every(([key, type]) => {
-			const supertypeParameter = supertype.parameterTypes.get(key);
-			if(supertypeParameter === undefined) {
-				return false; // supertype does not have a parameter with this key
-			}
-			return subsumes(supertypeParameter, type);
+		const subtypeParameterKeys = new Set(subtype.parameterTypes.keys());
+		const supertypeParameterKeys = new Set(supertype.parameterTypes.keys());
+		return subsumes(subtype.returnType, supertype.returnType) && subtypeParameterKeys.intersection(supertypeParameterKeys).values().every(key => {
+			// eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+			return subsumes(supertype.parameterTypes.get(key)!, subtype.parameterTypes.get(key)!);
 		});
 	} else {
 		return subsumesByTag(subtype.tag, supertype.tag);
diff --git a/src/typing/unification/infer.ts b/src/typing/unification/infer.ts
index b12383b44b2..4989078aa31 100644
--- a/src/typing/unification/infer.ts
+++ b/src/typing/unification/infer.ts
@@ -23,7 +23,7 @@ import type { RSymbol } from '../../r-bridge/lang-4.x/ast/model/nodes/r-symbol';
 import { RType } from '../../r-bridge/lang-4.x/ast/model/type';
 import type { NoInfo } from '../../r-bridge/lang-4.x/ast/model/model';
 import { RFalse, RTrue } from '../../r-bridge/lang-4.x/convert-values';
-import { resolveType, UnresolvedRFunctionType, UnresolvedRListType, UnresolvedRTypeVariable } from './types';
+import { resolve, UnresolvedRFunctionType, UnresolvedRListType, UnresolvedRTypeVariable } from './types';
 
 export function inferDataTypes<Info extends ParentInformation & { typeVariable?: undefined }>(ast: NormalizedAst<ParentInformation & Info>, dataflowInfo: DataflowInformation): NormalizedAst<Info & DataTypeInfo> {
 	const astWithTypeVars = decorateTypeVariables(ast);
@@ -52,7 +52,7 @@ function decorateTypeVariables<Info extends ParentInformation>(ast: NormalizedAs
 function resolveTypeVariables<Info extends ParentInformation & UnresolvedTypeInfo>(ast: NormalizedAst<Info>): NormalizedAst<Omit<Info, keyof UnresolvedTypeInfo> & DataTypeInfo> {
 	return mapNormalizedAstInfo(ast, node => {
 		const { typeVariable, ...rest } = node.info;
-		return { ...rest, inferredType: resolveType(typeVariable) };
+		return { ...rest, inferredType: resolve(typeVariable) };
 	});
 }
 
@@ -215,7 +215,8 @@ class TypeInferringCfgGuidedVisitor<
 
 				node.info.typeVariable.unify(functionType.returnType);
 			} else {
-				// TODO: Handle builtin functions that are not represented in the AST
+				// The function is a builtin function that is not represented in the AST
+				// We do not handle builtin functions in the unification approach and provide type information only in the more advanced subtyping system
 			}
 		}
 	}
diff --git a/src/typing/unification/types.ts b/src/typing/unification/types.ts
index 8f6ad5a3ae1..019e3ea57c1 100644
--- a/src/typing/unification/types.ts
+++ b/src/typing/unification/types.ts
@@ -10,10 +10,6 @@ export class UnresolvedRListType {
 			this.elementType.unify(elementType);
 		}
 	}
-	
-	unify(other: UnresolvedRListType): void {
-		this.elementType.unify(other.elementType);
-	}
 }
 
 export class UnresolvedRFunctionType {
@@ -21,13 +17,6 @@ export class UnresolvedRFunctionType {
 	readonly parameterTypes = new Map<number | string, UnresolvedRTypeVariable>();
 	readonly returnType = new UnresolvedRTypeVariable();
 
-	unify(other: UnresolvedRFunctionType): void {
-		for(const [key, type] of other.parameterTypes) {
-			this.getParameterType(key).unify(type);
-		}
-		this.returnType.unify(other.returnType);
-	}
-
 	getParameterType(indexOrName: number | string): UnresolvedRTypeVariable {
 		let parameterType = this.parameterTypes.get(indexOrName);
 		if(parameterType === undefined) {
@@ -62,26 +51,29 @@ export class UnresolvedRTypeVariable {
 		} else if(otherRep instanceof UnresolvedRTypeVariable) {
 			otherRep.boundType = thisRep;
 		} else if(thisRep instanceof UnresolvedRFunctionType && otherRep instanceof UnresolvedRFunctionType) {
-			thisRep.unify(otherRep);
+			for(const [key, type] of otherRep.parameterTypes) {
+				thisRep.getParameterType(key).unify(type);
+			}
+			thisRep.returnType.unify(otherRep.returnType);
 		} else if(thisRep instanceof UnresolvedRListType && otherRep instanceof UnresolvedRListType) {
-			thisRep.unify(otherRep);
+			thisRep.elementType.unify(otherRep.elementType);
 		} else if(thisRep instanceof RTypeError || thisRep.tag !== otherRep.tag) {
-			this.boundType = new RTypeError(resolveType(thisRep), resolveType(otherRep));
+			this.boundType = new RTypeError(resolve(thisRep), resolve(otherRep));
 		}
 	}
 }
 
 
-export function resolveType(type: UnresolvedRDataType): DataType {
+export function resolve(type: UnresolvedRDataType): DataType {
 	if(type instanceof UnresolvedRTypeVariable) {
 		const typeRep = type.find();
-		return typeRep !== type ? resolveType(typeRep) : new RTypeVariable();
+		return typeRep !== type ? resolve(typeRep) : new RTypeVariable();
 	} else if(type instanceof UnresolvedRFunctionType) {
-		const resolvedParameterTypes = new Map(type.parameterTypes.entries().toArray().map(([key, type]) => [key, resolveType(type)]));
-		const resolvedReturnType = resolveType(type.returnType);
+		const resolvedParameterTypes = new Map(type.parameterTypes.entries().toArray().map(([key, type]) => [key, resolve(type)]));
+		const resolvedReturnType = resolve(type.returnType);
 		return new RFunctionType(resolvedParameterTypes, resolvedReturnType);
 	} else if(type instanceof UnresolvedRListType) {
-		const resolvedElementType = resolveType(type.elementType);
+		const resolvedElementType = resolve(type.elementType);
 		return new RListType(resolvedElementType);
 	} else {
 		return type;
diff --git a/test/functionality/typing/subtyping/constrain.test.ts b/test/functionality/typing/subtyping/constrain.test.ts
index 83228a231ef..e7a2664ca70 100644
--- a/test/functionality/typing/subtyping/constrain.test.ts
+++ b/test/functionality/typing/subtyping/constrain.test.ts
@@ -1,95 +1,95 @@
 import { describe, expect, test } from 'vitest';
 import type { UnresolvedDataType } from '../../../../src/typing/subtyping/types';
-import { constrainWithLowerBound, constrainWithUpperBound, resolveType, UnresolvedRAtomicVectorType, UnresolvedRFunctionType, UnresolvedRListType, UnresolvedRTypeIntersection, UnresolvedRTypeUnion, UnresolvedRTypeVariable } from '../../../../src/typing/subtyping/types';
+import { constrain, resolve, UnresolvedRAtomicVectorType, UnresolvedRFunctionType, UnresolvedRListType, UnresolvedRTypeIntersection, UnresolvedRTypeUnion, UnresolvedRTypeVariable } from '../../../../src/typing/subtyping/types';
 import { RIntegerType, RComplexType, RTypeVariable, RDoubleType, RStringType, RListType, RTypeIntersection } from '../../../../src/typing/types';
 
 describe('Constrain types with lower and upper bounds', () => {
 	test('Constrain with numeric bounds', () => {
-		const cache = new Map<UnresolvedDataType, { lowerBounds: Set<UnresolvedDataType>, upperBounds: Set<UnresolvedDataType> }>();
+		const cache = new Map<UnresolvedDataType, Set<UnresolvedDataType>>();
 
 		const typeVar = new UnresolvedRTypeVariable();
-		constrainWithLowerBound(typeVar, new RIntegerType(), cache);
-		constrainWithUpperBound(typeVar, new RComplexType(), cache);
+		constrain(new RIntegerType(), typeVar, cache);
+		constrain(typeVar, new RComplexType(), cache);
 		
-		expect(resolveType(typeVar)).toEqual(new RTypeVariable(new RIntegerType(), new RComplexType()));
+		expect(resolve(typeVar)).toEqual(new RTypeVariable(new RIntegerType(), new RComplexType()));
 	});
 
 	test('Constrain with multiple bounds', () => {
-		const cache = new Map<UnresolvedDataType, { lowerBounds: Set<UnresolvedDataType>, upperBounds: Set<UnresolvedDataType> }>();
+		const cache = new Map<UnresolvedDataType, Set<UnresolvedDataType>>();
 
 		const typeVar = new UnresolvedRTypeVariable();
-		constrainWithLowerBound(typeVar, new RIntegerType(), cache);
-		constrainWithLowerBound(typeVar, new RDoubleType(), cache);
-		constrainWithUpperBound(typeVar, new UnresolvedRTypeUnion(new RComplexType(), new RStringType()), cache);
+		constrain(new RIntegerType(), typeVar, cache);
+		constrain(new RDoubleType(), typeVar, cache);
+		constrain(typeVar, new UnresolvedRTypeUnion(new RComplexType(), new RStringType()), cache);
 
-		expect(resolveType(typeVar)).toEqual(new RTypeVariable(new RDoubleType(), new RComplexType()));
+		expect(resolve(typeVar)).toEqual(new RTypeVariable(new RDoubleType(), new RComplexType()));
 	});
 
 	test('Constrain with compound bounds', () => {
-		const cache = new Map<UnresolvedDataType, { lowerBounds: Set<UnresolvedDataType>, upperBounds: Set<UnresolvedDataType> }>();
+		const cache = new Map<UnresolvedDataType, Set<UnresolvedDataType>>();
 
 		const typeVar = new UnresolvedRTypeVariable();
 		const listType1 = new UnresolvedRListType();
-		constrainWithLowerBound(listType1.elementType, new RIntegerType(), cache);
-		constrainWithLowerBound(typeVar, listType1, cache);
+		constrain(new RIntegerType(), listType1.elementType, cache);
+		constrain(listType1, typeVar, cache);
 		const listType2 = new UnresolvedRListType();
-		constrainWithUpperBound(listType2.elementType, new RComplexType(), cache);
-		constrainWithUpperBound(typeVar, listType2, cache);
+		constrain(listType2.elementType, new RComplexType(), cache);
+		constrain(typeVar, listType2, cache);
 
-		expect(resolveType(typeVar)).toEqual(new RListType(new RTypeVariable(new RIntegerType(), new RComplexType())));
+		expect(resolve(typeVar)).toEqual(new RListType(new RTypeVariable(new RIntegerType(), new RComplexType())));
 	});
 
 	test('Constraint propagation', () => {
-		const cache = new Map<UnresolvedDataType, { lowerBounds: Set<UnresolvedDataType>, upperBounds: Set<UnresolvedDataType> }>();
+		const cache = new Map<UnresolvedDataType, Set<UnresolvedDataType>>();
 
 		const typeVar = new UnresolvedRTypeVariable();
 		const listType1 = new UnresolvedRListType();
-		constrainWithLowerBound(listType1.elementType, new RIntegerType(), cache);
-		constrainWithLowerBound(typeVar, listType1, cache);
+		constrain(new RIntegerType(), listType1.elementType, cache);
+		constrain(listType1, typeVar, cache);
 
 		const elementType = new UnresolvedRTypeVariable();
 		const listType2 = new UnresolvedRListType(elementType);
-		constrainWithUpperBound(typeVar, listType2, cache);
+		constrain(typeVar, listType2, cache);
 
-		expect(resolveType(typeVar)).toEqual(new RListType(new RTypeVariable(new RIntegerType(), new RTypeIntersection())));
-		expect(resolveType(elementType)).toEqual(new RTypeVariable(new RIntegerType(), new RTypeIntersection()));
+		expect(resolve(typeVar)).toEqual(new RListType(new RTypeVariable(new RIntegerType(), new RTypeIntersection())));
+		expect(resolve(elementType)).toEqual(new RTypeVariable(new RIntegerType(), new RTypeIntersection()));
 	});
 
 	test('Advanced constraint propagation', () => {
-		const cache = new Map<UnresolvedDataType, { lowerBounds: Set<UnresolvedDataType>, upperBounds: Set<UnresolvedDataType> }>();
+		const cache = new Map<UnresolvedDataType, Set<UnresolvedDataType>>();
 
 		const typeVar = new UnresolvedRTypeVariable();
 		const listType1 = new UnresolvedRListType();
-		constrainWithLowerBound(listType1.elementType, new RIntegerType(), cache);
-		constrainWithLowerBound(typeVar, listType1, cache);
+		constrain(new RIntegerType(), listType1.elementType, cache);
+		constrain(listType1, typeVar, cache);
 
 		const elementType = new UnresolvedRTypeVariable();
 		const vectorType = new UnresolvedRTypeUnion(new UnresolvedRAtomicVectorType(elementType), new UnresolvedRListType(elementType));
-		constrainWithUpperBound(typeVar, vectorType, cache);
+		constrain(typeVar, vectorType, cache);
 
-		expect(resolveType(typeVar)).toEqual(new RListType(new RTypeVariable(new RIntegerType(), new RTypeIntersection())));
-		expect(resolveType(elementType)).toEqual(new RTypeVariable(new RIntegerType(), new RTypeIntersection()));
+		expect(resolve(typeVar)).toEqual(new RListType(new RTypeVariable(new RIntegerType(), new RTypeIntersection())));
+		expect(resolve(elementType)).toEqual(new RTypeVariable(new RIntegerType(), new RTypeIntersection()));
 	});
 
 	test('Function overloading', () => {
-		const cache = new Map<UnresolvedDataType, { lowerBounds: Set<UnresolvedDataType>, upperBounds: Set<UnresolvedDataType> }>();
+		const cache = new Map<UnresolvedDataType, Set<UnresolvedDataType>>();
 
 		// Predetermined types in context
 		const funcType1 = new UnresolvedRFunctionType();
 		const paramType1 = new UnresolvedRTypeVariable();
 		funcType1.parameterTypes.set(0, paramType1);
-		constrainWithLowerBound(paramType1, new RIntegerType(), cache);
-		constrainWithUpperBound(paramType1, new RIntegerType(), cache);
-		constrainWithLowerBound(funcType1.returnType, new RIntegerType(), cache);
-		constrainWithUpperBound(funcType1.returnType, new RIntegerType(), cache);
+		constrain(new RIntegerType(), paramType1, cache);
+		constrain(paramType1, new RIntegerType(), cache);
+		constrain(new RIntegerType(), funcType1.returnType, cache);
+		constrain(funcType1.returnType, new RIntegerType(), cache);
 
 		const funcType2 = new UnresolvedRFunctionType();
 		const paramType2 = new UnresolvedRTypeVariable();
 		funcType2.parameterTypes.set(0, paramType2);
-		constrainWithLowerBound(paramType2, new RDoubleType(), cache);
-		constrainWithUpperBound(paramType2, new RDoubleType(), cache);
-		constrainWithLowerBound(funcType2.returnType, new RDoubleType(), cache);
-		constrainWithUpperBound(funcType2.returnType, new RDoubleType(), cache);
+		constrain(new RDoubleType(), paramType2, cache);
+		constrain(paramType2, new RDoubleType(), cache);
+		constrain(new RDoubleType(), funcType2.returnType, cache);
+		constrain(funcType2.returnType, new RDoubleType(), cache);
 
 		const overloadedFuncType1 = new UnresolvedRTypeIntersection(funcType1, funcType2);
 		const overloadedFuncType2 = new UnresolvedRTypeIntersection(funcType1, funcType2);
@@ -97,26 +97,26 @@ describe('Constrain types with lower and upper bounds', () => {
 		// Typing of called function
 		const calledFuncType1 = new UnresolvedRTypeVariable();
 		const calledFuncType2 = new UnresolvedRTypeVariable();
-		constrainWithLowerBound(calledFuncType1, overloadedFuncType1, cache);
-		constrainWithLowerBound(calledFuncType2, overloadedFuncType2, cache);
+		constrain(overloadedFuncType1, calledFuncType1, cache);
+		constrain(overloadedFuncType2, calledFuncType2, cache);
 
 		// Typing of function call
 		const argType1 = new UnresolvedRTypeVariable();
 		const argType2 = new UnresolvedRTypeVariable();
-		constrainWithLowerBound(argType1, new RIntegerType(), cache);
-		constrainWithUpperBound(argType1, new RIntegerType(), cache);
-		constrainWithLowerBound(argType2, new RDoubleType(), cache);
-		constrainWithUpperBound(argType2, new RDoubleType(), cache);
+		constrain(new RIntegerType(), argType1, cache);
+		constrain(argType1, new RIntegerType(), cache);
+		constrain(new RDoubleType(), argType2, cache);
+		constrain(argType2, new RDoubleType(), cache);
 		const templateFuncType1 = new UnresolvedRFunctionType();
 		templateFuncType1.parameterTypes.set(0, argType1);
 		const returnType1 = templateFuncType1.returnType;
 		const templateFuncType2 = new UnresolvedRFunctionType();
 		templateFuncType2.parameterTypes.set(0, argType2);
 		const returnType2 = templateFuncType2.returnType;
-		constrainWithUpperBound(calledFuncType1, templateFuncType1, cache);
-		constrainWithUpperBound(calledFuncType2, templateFuncType2, cache);
+		constrain(calledFuncType1, templateFuncType1, cache);
+		constrain(calledFuncType2, templateFuncType2, cache);
 
-		expect(resolveType(returnType1)).toEqual(new RTypeVariable(new RIntegerType(), new RTypeIntersection()));
-		expect(resolveType(returnType2)).toEqual(new RTypeVariable(new RDoubleType(), new RTypeIntersection()));
+		expect(resolve(returnType1)).toEqual(new RTypeVariable(new RIntegerType(), new RTypeIntersection()));
+		expect(resolve(returnType2)).toEqual(new RTypeVariable(new RDoubleType(), new RTypeIntersection()));
 	});
 });
\ No newline at end of file

From d8873e2d344b8891972fe1eb624e07069ba92f11 Mon Sep 17 00:00:00 2001
From: Lukas Rohde <lukas.rohde@silupe.de>
Date: Sat, 26 Jul 2025 16:50:44 +0200
Subject: [PATCH 106/153] feat-fix(typing): fix merge conflicts

---
 src/typing/adapter/turcotte-types.ts | 12 ++++--------
 1 file changed, 4 insertions(+), 8 deletions(-)

diff --git a/src/typing/adapter/turcotte-types.ts b/src/typing/adapter/turcotte-types.ts
index 94734176954..253dad97080 100644
--- a/src/typing/adapter/turcotte-types.ts
+++ b/src/typing/adapter/turcotte-types.ts
@@ -17,8 +17,7 @@ import {
 import type {
 	UnresolvedDataType } from '../subtyping/types';
 import {
-	constrainWithLowerBound,
-	constrainWithUpperBound,
+	constrain,
 	getParameterTypeFromFunction,
 	UnresolvedRAtomicVectorType,
 	UnresolvedRFunctionType,
@@ -86,14 +85,11 @@ function convertTurcotteFunction2RohdeType(fingerprint: string, rows: TurcotteCs
 	};
 }
 
-const globalCache: Map<UnresolvedDataType, {
-    lowerBounds: Set<UnresolvedDataType>,
-    upperBounds: Set<UnresolvedDataType>
-}> = new Map();
+const globalCache: Map<UnresolvedDataType, Set<UnresolvedDataType>> = new Map();
 
 function constrainLowerAndUpperBound(type: UnresolvedDataType, lowerBound: UnresolvedDataType, upperBound: UnresolvedDataType = lowerBound) {
-	constrainWithLowerBound(type, lowerBound, globalCache);
-	constrainWithUpperBound(type, upperBound, globalCache);
+	constrain(lowerBound, type, globalCache);
+	constrain(type, upperBound, globalCache);
 	return type;
 }
 

From 70bd7454922cac5e3e6cdb6bd5a0e634cec7b6c4 Mon Sep 17 00:00:00 2001
From: Lukas Rohde <lukas.rohde@silupe.de>
Date: Sat, 26 Jul 2025 19:43:25 +0200
Subject: [PATCH 107/153] refactor(typing): move turcotte-types.csv and
 refactor turcotte-types.ts

---
 .../typing/adapter/turcotte-types.csv           |  0
 src/typing/adapter/turcotte-types.ts            | 17 +++++++----------
 2 files changed, 7 insertions(+), 10 deletions(-)
 rename turcotte-types.csv => src/typing/adapter/turcotte-types.csv (100%)

diff --git a/turcotte-types.csv b/src/typing/adapter/turcotte-types.csv
similarity index 100%
rename from turcotte-types.csv
rename to src/typing/adapter/turcotte-types.csv
diff --git a/src/typing/adapter/turcotte-types.ts b/src/typing/adapter/turcotte-types.ts
index 253dad97080..2cf02bcae9e 100644
--- a/src/typing/adapter/turcotte-types.ts
+++ b/src/typing/adapter/turcotte-types.ts
@@ -1,7 +1,5 @@
 import { guard } from '../../util/assert';
-import type {
-	DataType,
-	RFunctionType } from '../types';
+import type { DataType } from '../types';
 import {
 	DataTypeTag,
 	RComplexType,
@@ -14,8 +12,7 @@ import {
 	RRawType,
 	RStringType
 } from '../types';
-import type {
-	UnresolvedDataType } from '../subtyping/types';
+import type { UnresolvedDataType } from '../subtyping/types';
 import {
 	constrain,
 	getParameterTypeFromFunction,
@@ -30,7 +27,7 @@ import { jsonReplacer } from '../../util/json';
 export interface RohdeFunctionTypeInformation {
     readonly name:    string;
     readonly package: string;
-    readonly type:    readonly RFunctionType[]
+    readonly types:   readonly UnresolvedRFunctionType[]
 }
 
 export interface RohdeConstantTypeInformation {
@@ -73,15 +70,15 @@ function convertTurcotteFunction2RohdeType(fingerprint: string, rows: TurcotteCs
 	// now we group them by their outer_alternative so that we can get the alternatives in order
 	const groupedByOuter = groupTurcotteData(rows, row => row.outer_alternative);
 
-	const type = [];
+	const functionTypes = [];
 	for(const [, innerRows] of groupedByOuter.entries()) {
-		type.push(convertSingleTurcotteFunctionAlternative2RohdeType(fingerprint, innerRows));
+		functionTypes.push(convertSingleTurcotteFunctionAlternative2RohdeType(fingerprint, innerRows));
 	}
 
 	return {
 		package: anyRow.package_name,
 		name:    anyRow.function_name,
-		type
+		types:   functionTypes
 	};
 }
 
@@ -93,7 +90,7 @@ function constrainLowerAndUpperBound(type: UnresolvedDataType, lowerBound: Unres
 	return type;
 }
 
-function convertSingleTurcotteFunctionAlternative2RohdeType(fingerprint: string, rows: TurcotteCsvRow[]): RFunctionType {
+function convertSingleTurcotteFunctionAlternative2RohdeType(fingerprint: string, rows: TurcotteCsvRow[]): UnresolvedRFunctionType {
 	const groupedByParameterPos = groupTurcotteData(rows, row => row.parameter_position);
 	const fn = new UnresolvedRFunctionType();
 

From 8a6c962577a55698ff720bf3cd57f4f0baa87989 Mon Sep 17 00:00:00 2001
From: Lukas Rohde <lukas.rohde@silupe.de>
Date: Sat, 26 Jul 2025 20:06:40 +0200
Subject: [PATCH 108/153] feat(typing): integrate turcotte types into the
 inference strategy

---
 src/typing/subtyping/infer.ts | 96 +++++++++++++++++++++++++----------
 1 file changed, 69 insertions(+), 27 deletions(-)

diff --git a/src/typing/subtyping/infer.ts b/src/typing/subtyping/infer.ts
index d6a2d3b4a58..c77ce5e7a0e 100644
--- a/src/typing/subtyping/infer.ts
+++ b/src/typing/subtyping/infer.ts
@@ -24,9 +24,13 @@ import { RType } from '../../r-bridge/lang-4.x/ast/model/type';
 import type { NoInfo, RNode } from '../../r-bridge/lang-4.x/ast/model/model';
 import { RFalse, RTrue } from '../../r-bridge/lang-4.x/convert-values';
 import type { UnresolvedDataType } from './types';
-import { constrain, getIndexedElementTypeFromList, getParameterTypeFromFunction, resolve, UnresolvedRAtomicVectorType, UnresolvedRFunctionType, UnresolvedRListType, UnresolvedRTypeUnion, UnresolvedRTypeVariable } from './types';
+import { constrain, getIndexedElementTypeFromList, getParameterTypeFromFunction, resolve, UnresolvedRAtomicVectorType, UnresolvedRFunctionType, UnresolvedRListType, UnresolvedRTypeIntersection, UnresolvedRTypeUnion, UnresolvedRTypeVariable } from './types';
+import type { RohdeTypes, TurcotteCsvRow } from '../adapter/turcotte-types';
+import { turcotte2RohdeTypes } from '../adapter/turcotte-types';
+import csvParser from 'csv-parser';
+import fs from 'fs';
 
-export function inferDataTypes<Info extends ParentInformation & { typeVariable?: undefined }>(ast: NormalizedAst<ParentInformation & Info>, dataflowInfo: DataflowInformation): NormalizedAst<Info & DataTypeInfo> {
+export function inferDataTypes<Info extends ParentInformation & { typeVariable?: undefined }>(ast: NormalizedAst<ParentInformation & Info>, dataflowInfo: DataflowInformation, useTurcotteTypes: boolean = true): NormalizedAst<Info & DataTypeInfo> {
 	const astWithTypeVars = decorateTypeVariables(ast);
 	const controlFlowInfo = extractCfg(astWithTypeVars, dataflowInfo.graph, ['unique-cf-sets', 'analyze-dead-code', 'remove-dead-code']);
 	const config = {
@@ -35,6 +39,7 @@ export function inferDataTypes<Info extends ParentInformation & { typeVariable?:
 		dataflowInfo:         dataflowInfo,
 		dfg:                  dataflowInfo.graph,
 		defaultVisitingOrder: 'forward' as const,
+		useTurcotteTypes,
 	};
 	const visitor = new TypeInferringCfgGuidedVisitor(config);
 	visitor.start();
@@ -64,7 +69,8 @@ export interface TypeInferringCfgGuidedVisitorConfiguration<
 	Ast extends NormalizedAst<UnresolvedTypeInfo & OtherInfo> = NormalizedAst<UnresolvedTypeInfo & OtherInfo>,
 	Dataflow extends DataflowInformation                      = DataflowInformation
 > extends Omit<SemanticCfgGuidedVisitorConfiguration<UnresolvedTypeInfo & OtherInfo, ControlFlow, Ast>, 'dataflow'> {
-	dataflowInfo: Dataflow;
+	dataflowInfo:     Dataflow;
+	useTurcotteTypes: boolean;
 }
 
 class TypeInferringCfgGuidedVisitor<
@@ -76,9 +82,31 @@ class TypeInferringCfgGuidedVisitor<
 > extends SemanticCfgGuidedVisitor<UnresolvedTypeInfo & OtherInfo, ControlFlow, Ast, Dataflow['graph'], Config & { dataflow: Dataflow['graph'] }> {
 	constructor(config: Config) {
 		super({ dataflow: config.dataflowInfo.graph, ...config });
+
+		if(config.useTurcotteTypes) {
+			const data: TurcotteCsvRow[] = [];
+			fs.createReadStream('src/typing/adapter/turcotte-types.csv', { encoding: 'utf-8' })
+				.pipe(csvParser({ separator: ',' }))
+				.on('data', (row: TurcotteCsvRow) => {
+					data.push(row);
+				});
+			const rohdeTypes: RohdeTypes = turcotte2RohdeTypes(data);
+			for(const info of rohdeTypes.info) {
+				const label = info.name; //`${info.package}::${info.name}`;
+				if('type' in info) {
+					this.constantContext.set(label, info.type);
+				}
+				if('types' in info) {
+					const type = info.types.length === 1 ? info.types[0] : new UnresolvedRTypeIntersection(...info.types);
+					this.functionContext.set(label, type);
+				}
+			}
+		}
 	}
 
 	protected constraintCache: Map<UnresolvedDataType, Set<UnresolvedDataType>> = new Map();
+	protected constantContext: Map<string, UnresolvedDataType> = new Map();
+	protected functionContext: Map<string, UnresolvedDataType> = new Map();
 
 
 	protected constrainNodeType(nodeOrId: RNode<UnresolvedTypeInfo> | NodeId, constraint: UnresolvedDataType | { lowerBound?: UnresolvedDataType, upperBound?: UnresolvedDataType }): void {
@@ -121,6 +149,26 @@ class TypeInferringCfgGuidedVisitor<
 		this.constrainNodeType(data.node, new RStringType());
 	}
 
+	protected inferNodeTypeFromReadOrigins(node: RNode<UnresolvedTypeInfo>, readOrigins: Array<{ id: NodeId, type: OriginType }>): void {
+		for(const readOrigin of readOrigins ?? []) {
+			const readNode = this.getNormalizedAst(readOrigin.id);
+			if(readNode !== undefined) {
+				this.constrainNodeType(node, { lowerBound: readNode.info.typeVariable });
+			} else if(node.type === RType.Symbol) {
+				// If the read variable has no associated AST node it might be a library constant or function
+				const constantType = this.constantContext.get(node.content);
+				if(constantType !== undefined) {
+					this.constrainNodeType(node, { lowerBound: constantType });
+				}
+
+				const functionType = this.functionContext.get(node.content);
+				if(functionType !== undefined) {
+					this.constrainNodeType(node, { lowerBound: functionType });
+				}
+			}
+		}
+	}
+
 	override onVariableUse(data: { vertex: DataflowGraphVertexUse }): void {
 		const isArgumentOfGetCall = this.config.dfg.ingoingEdges(data.vertex.id)?.entries().some(([source, edge]) => {
 			return edgeIncludesType(edge.types, EdgeType.Argument) &&
@@ -140,12 +188,8 @@ class TypeInferringCfgGuidedVisitor<
 			return;
 		}
 
-		const readOrigins = this.getOrigins(data.vertex.id)?.filter((origin) => origin.type === OriginType.ReadVariableOrigin);
-		for(const readOrigin of readOrigins ?? []) {
-			const readNode = this.getNormalizedAst(readOrigin.id);
-			guard(readNode !== undefined, 'Expected read node to be defined');
-			this.constrainNodeType(data.vertex.id, { lowerBound: readNode.info.typeVariable });
-		}
+		const readOrigins = this.getOrigins(data.vertex.id)?.filter((origin) => origin.type === OriginType.ReadVariableOrigin) ?? [];
+		this.inferNodeTypeFromReadOrigins(node, readOrigins);
 	}
 
 	override onAssignmentCall(data: { call: DataflowGraphVertexFunctionCall, target?: NodeId, source?: NodeId }): void {
@@ -161,17 +205,13 @@ class TypeInferringCfgGuidedVisitor<
 	}
 
 	override onDefaultFunctionCall(data: { call: DataflowGraphVertexFunctionCall }): void {
-		const outgoing = this.config.dataflowInfo.graph.outgoingEdges(data.call.id);
-		const callTargets = outgoing?.entries()
-			.filter(([_target, edge]) => edgeIncludesType(edge.types, EdgeType.Calls))
-			.map(([target, _edge]) => target)
-			.toArray();
+		const callTargets = this.getOrigins(data.call.id)?.filter((origin) => origin.type === OriginType.FunctionCallOrigin) ?? [];
 
-		for(const target of callTargets ?? []) {
-			const targetNode = this.getNormalizedAst(target);
+		const functionType = new UnresolvedRFunctionType();
+		for(const target of callTargets) {
+			const targetNode = this.getNormalizedAst(target.id);
 			if(targetNode !== undefined) {
-				const functionType = new UnresolvedRFunctionType();
-				this.constrainNodeType(targetNode, { lowerBound: functionType });
+				this.constrainNodeType(targetNode, { upperBound: functionType });
 
 				for(const [index, arg] of data.call.args.entries()) {
 					if(arg === EmptyArgument) {
@@ -187,12 +227,15 @@ class TypeInferringCfgGuidedVisitor<
 						constrain(argNode.info.typeVariable, getParameterTypeFromFunction(functionType, index), this.constraintCache);
 					}
 				}
-
-				this.constrainNodeType(data.call.id, functionType.returnType);
 			} else {
-				// TODO: Handle builtin functions that are not represented in the AST
+				// If the target function has no associated AST node it might be a library function
+				const contextFunctionType = this.functionContext.get(data.call.name);
+				if(contextFunctionType !== undefined) {
+					constrain(contextFunctionType, functionType, this.constraintCache);
+				}
 			}
 		}
+		this.constrainNodeType(data.call.id, functionType.returnType);
 	}
 
 	override onGetCall(data: { call: DataflowGraphVertexFunctionCall }) {
@@ -201,13 +244,12 @@ class TypeInferringCfgGuidedVisitor<
 		
 		guard(varName !== undefined && varName !== EmptyArgument, 'Expected argument of get call to be defined');
 		this.constrainNodeType(varName.nodeId, { upperBound: new RStringType() });
+		
+		const node = this.getNormalizedAst(data.call.id);
+		guard(node !== undefined, 'Expected AST node to be defined');
 
-		const varReadOrigins = this.getOrigins(varName.nodeId)?.filter((origin) => origin.type === OriginType.ReadVariableOrigin);
-		for(const readOrigin of varReadOrigins ?? []) {
-			const readNode = this.getNormalizedAst(readOrigin.id);
-			guard(readNode !== undefined, 'Expected read node to be defined');
-			this.constrainNodeType(data.call.id, { lowerBound: readNode.info.typeVariable });
-		}
+		const varReadOrigins = this.getOrigins(varName.nodeId)?.filter((origin) => origin.type === OriginType.ReadVariableOrigin) ?? [];
+		this.inferNodeTypeFromReadOrigins(node, varReadOrigins);
 	}
 
 	override onRmCall(data: { call: DataflowGraphVertexFunctionCall }) {

From 3dd31e2c64994e0fb810e36681d44af6b7c76f7f Mon Sep 17 00:00:00 2001
From: Lukas Rohde <lukas.rohde@silupe.de>
Date: Sat, 26 Jul 2025 20:15:52 +0200
Subject: [PATCH 109/153] feat(typing): add query configuration option for
 usage of turcotte types

---
 .../datatype-query/datatype-query-executor.ts | 28 +++++++++++++++----
 .../datatype-query/datatype-query-format.ts   | 14 ++++++----
 2 files changed, 30 insertions(+), 12 deletions(-)

diff --git a/src/queries/catalog/datatype-query/datatype-query-executor.ts b/src/queries/catalog/datatype-query/datatype-query-executor.ts
index 2984c6f526a..72eba089589 100644
--- a/src/queries/catalog/datatype-query/datatype-query-executor.ts
+++ b/src/queries/catalog/datatype-query/datatype-query-executor.ts
@@ -26,18 +26,34 @@ export function executeDatatypeQuery({ dataflow, ast }: BasicQueryData, queries:
 			result[criterion] = node.info.inferredType;
 		}
 	};
-	const [queriesWithoutSubtyping, queriesUsingSubtyping] = queries.reduce(([unificationGroup, subtypingGroup], query) => query.useSubtyping ? [unificationGroup, [...subtypingGroup, query]] : [[...unificationGroup, query], subtypingGroup], [[], []] as [DatatypeQuery[], DatatypeQuery[]]);
+	const [unificationQueries, subtypingQueries, turcotteQueries] = queries.reduce(([unificationGroup, subtypingGroup, turcotteGroup], query) => {
+		if(query.useSubtyping) {
+			if(query.useTurcotteTypes) {
+				turcotteGroup.push(query);
+			} else {
+				subtypingGroup.push(query);
+			}
+		} else {
+			unificationGroup.push(query);
+		}
+		return [unificationGroup, subtypingGroup, turcotteGroup];
+	}, [[], [], []] as [DatatypeQuery[], DatatypeQuery[], DatatypeQuery[]]);
 
 	const start = Date.now();
 
-	if(queriesWithoutSubtyping.length > 0) {
+	if(unificationQueries.length > 0) {
 		const typedAst = inferDataTypes(ast as NormalizedAst<ParentInformation & { typeVariable?: undefined }>, dataflow);
-		extractInferredTypeFromAst(typedAst, queriesWithoutSubtyping.map(query => query.criterion ?? '1:1'));
+		extractInferredTypeFromAst(typedAst, unificationQueries.map(query => query.criterion ?? '1:1'));
+	}
+
+	if(subtypingQueries.length > 0) {
+		const typedAst = inferDataTypesUsingSubtyping(ast as NormalizedAst<ParentInformation & { typeVariable?: undefined }>, dataflow, false);
+		extractInferredTypeFromAst(typedAst, subtypingQueries.map(query => query.criterion ?? '1:1'));
 	}
 
-	if(queriesUsingSubtyping.length > 0) {
-		const typedAst = inferDataTypesUsingSubtyping(ast as NormalizedAst<ParentInformation & { typeVariable?: undefined }>, dataflow);
-		extractInferredTypeFromAst(typedAst, queriesUsingSubtyping.map(query => query.criterion ?? '1:1'));
+	if(turcotteQueries.length > 0) {
+		const typedAst = inferDataTypesUsingSubtyping(ast as NormalizedAst<ParentInformation & { typeVariable?: undefined }>, dataflow, true);
+		extractInferredTypeFromAst(typedAst, turcotteQueries.map(query => query.criterion ?? '1:1'));
 	}
 
 	return {
diff --git a/src/queries/catalog/datatype-query/datatype-query-format.ts b/src/queries/catalog/datatype-query/datatype-query-format.ts
index 27ce823a246..abb87ce77a4 100644
--- a/src/queries/catalog/datatype-query/datatype-query-format.ts
+++ b/src/queries/catalog/datatype-query/datatype-query-format.ts
@@ -12,9 +12,10 @@ import type { DataType } from '../../../typing/types';
  * Calculates the inferred data type for the given criterion.
  */
 export interface DatatypeQuery extends BaseQueryFormat {
-	readonly type:          'datatype';
-	readonly criterion?:    SingleSlicingCriterion;
-	readonly useSubtyping?: boolean;
+	readonly type:              'datatype';
+	readonly criterion?:        SingleSlicingCriterion;
+	readonly useSubtyping?:     boolean;
+	readonly useTurcotteTypes?: boolean;
 }
 
 export interface DatatypeQueryResult extends BaseQueryResult {
@@ -36,8 +37,9 @@ export const DatatypeQueryDefinition = {
 		return [];
 	},
 	schema: Joi.object({
-		type:         Joi.string().valid('datatype').required().description('The type of the query.'),
-		criterion:    Joi.string().optional().description('The slicing criterion of the node to get the inferred data type for.'),
-		useSubtyping: Joi.boolean().optional().default(false).description('Whether to use subtyping to infer the data type.'),
+		type:             Joi.string().valid('datatype').required().description('The type of the query.'),
+		criterion:        Joi.string().optional().description('The slicing criterion of the node to get the inferred data type for.'),
+		useSubtyping:     Joi.boolean().optional().default(false).description('Whether to use subtyping to infer the data type.'),
+		useTurcotteTypes: Joi.boolean().optional().default(true).description('Whether to use Turcotte types for inference.'),
 	}).description('Datatype query used to extract the inferred data type for a node in the normalized AST')
 } as const satisfies SupportedQuery<'datatype'>;

From 9cf22c5d238a5bf9025aeaf56186f4210b9b3724 Mon Sep 17 00:00:00 2001
From: Lukas Rohde <lukas.rohde@silupe.de>
Date: Mon, 28 Jul 2025 14:22:10 +0200
Subject: [PATCH 110/153] feat-fix(typing): fix stack overflows due to large
 types and add tests

---
 src/typing/subtyping/infer.ts                 |   2 +
 src/typing/subtyping/types.ts                 | 102 +++++++++----
 .../typing/subtyping/constrain.test.ts        |  14 ++
 .../typing/subtyping/resolve.test.ts          | 136 ++++++++++++++++++
 4 files changed, 228 insertions(+), 26 deletions(-)
 create mode 100644 test/functionality/typing/subtyping/resolve.test.ts

diff --git a/src/typing/subtyping/infer.ts b/src/typing/subtyping/infer.ts
index c77ce5e7a0e..4bde1d5d9d8 100644
--- a/src/typing/subtyping/infer.ts
+++ b/src/typing/subtyping/infer.ts
@@ -102,6 +102,8 @@ class TypeInferringCfgGuidedVisitor<
 				}
 			}
 		}
+
+		Error.stackTraceLimit = 100; // Increase stack trace limit for better debugging
 	}
 
 	protected constraintCache: Map<UnresolvedDataType, Set<UnresolvedDataType>> = new Map();
diff --git a/src/typing/subtyping/types.ts b/src/typing/subtyping/types.ts
index 5a816223a1c..9d4e8893881 100644
--- a/src/typing/subtyping/types.ts
+++ b/src/typing/subtyping/types.ts
@@ -1,9 +1,13 @@
 import { guard } from '../../util/assert';
 import type { DataType , AtomicVectorBaseType, REnvironmentType, RLanguageType, RNullType } from '../types';
 import { DataTypeTag, isAtomicVectorBaseType, RAtomicVectorType, RFunctionType, RListType, RTypeError, RTypeIntersection, RTypeUnion, RTypeVariable } from '../types';
+// import { inspect } from 'util';
+
+// let idCounter = 0;
 
 export class UnresolvedRAtomicVectorType {
 	readonly tag = DataTypeTag.AtomicVector;
+	// readonly id = idCounter++;
 	readonly elementType = new UnresolvedRTypeVariable();
 
 	constructor(elementType?: UnresolvedRTypeVariable) {
@@ -15,6 +19,7 @@ export class UnresolvedRAtomicVectorType {
 
 export class UnresolvedRListType {
 	readonly tag = DataTypeTag.List;
+	// readonly id = idCounter++;
 	readonly elementType = new UnresolvedRTypeVariable();
 	readonly indexedElementTypes = new Map<number | string, UnresolvedRTypeVariable>();
 
@@ -38,6 +43,7 @@ export function getIndexedElementTypeFromList(list: UnresolvedRListType, indexOr
 
 export class UnresolvedRFunctionType {
 	readonly tag = DataTypeTag.Function;
+	// readonly id = idCounter++;
 	readonly parameterTypes = new Map<number | string, UnresolvedRTypeVariable>();
 	readonly returnType = new UnresolvedRTypeVariable();
 
@@ -59,6 +65,7 @@ export function getParameterTypeFromFunction(func: UnresolvedRFunctionType, inde
 
 export class UnresolvedRTypeUnion {
 	readonly tag = DataTypeTag.Union;
+	// readonly id = idCounter++;
 	readonly types: Set<UnresolvedDataType> = new Set();
 
 	constructor(...types: UnresolvedDataType[]) {
@@ -71,6 +78,7 @@ export class UnresolvedRTypeUnion {
 
 export class UnresolvedRTypeIntersection {
 	readonly tag = DataTypeTag.Intersection;
+	// readonly id = idCounter++;
 	readonly types: Set<UnresolvedDataType> = new Set();
 
 	constructor(...types: UnresolvedDataType[]) {
@@ -83,10 +91,12 @@ export class UnresolvedRTypeIntersection {
 
 export class UnresolvedRTypeVariable {
 	readonly tag = DataTypeTag.Variable;
+	// readonly id = idCounter++;
 	readonly lowerBound = new UnresolvedRTypeUnion();
 	readonly upperBound = new UnresolvedRTypeIntersection();
 }
 
+
 export function constrain(subtype: UnresolvedDataType, supertype: UnresolvedDataType, cache: Map<UnresolvedDataType, Set<UnresolvedDataType>>): void {
 	// console.debug('constraining', type, 'with upper bound', bound);
 
@@ -227,42 +237,58 @@ export function resolve(type: UnresolvedDataType, cache: Map<UnresolvedDataType,
 	}
 }
 
-export function subsumes(subtype: DataType | UnresolvedDataType, supertype: DataType | UnresolvedDataType): boolean {
+export function subsumes(subtype: DataType | UnresolvedDataType, supertype: DataType | UnresolvedDataType, inProcess: Map<DataType | UnresolvedDataType, Set<DataType | UnresolvedDataType>> = new Map()): boolean {
 	// console.debug('Checking if', subtype, 'subsumes', supertype);
 
 	if(subtype === supertype) {
-		return true;
-	} else if(subtype.tag === DataTypeTag.Error || supertype.tag === DataTypeTag.Error) {
-		return false; // Error types do not subsume and are not subsumed by any other type
+		return true; // If both types are the same, they subsume each other
+	}
+
+	let processedSupertypes = inProcess.get(subtype);
+	if(processedSupertypes?.has(supertype)) {
+		return true; // Avoid infinite recursion
+	}
+	processedSupertypes ??= new Set();
+	processedSupertypes.add(supertype);
+	inProcess.set(subtype, processedSupertypes);
+
+	let result: boolean;
+
+	if(subtype.tag === DataTypeTag.Error || supertype.tag === DataTypeTag.Error) {
+		result = false; // Error types do not subsume and are not subsumed by any other type
 	} else if(subtype.tag === DataTypeTag.Variable) {
-		return subsumes(subtype.lowerBound, supertype) && subsumes(subtype.upperBound, supertype);
+		result = subsumes(subtype.lowerBound, supertype, inProcess) && subsumes(subtype.upperBound, supertype, inProcess);
 	} else if(supertype.tag === DataTypeTag.Variable) {
-		return subsumes(supertype.lowerBound, subtype) && subsumes(subtype, supertype.upperBound);
+		result = subsumes(supertype.lowerBound, subtype, inProcess) && subsumes(subtype, supertype.upperBound, inProcess);
 	} else if(subtype.tag === DataTypeTag.Union) {
-		return subtype.types.values().every(subtype => subsumes(subtype, supertype));
+		result = subtype.types.values().every(subtype => subsumes(subtype, supertype, inProcess));
 	} else if(supertype.tag === DataTypeTag.Union) {
-		return supertype.types.values().some(supertype => subsumes(subtype, supertype));
+		result = supertype.types.values().some(supertype => subsumes(subtype, supertype, inProcess));
 	} else if(supertype.tag === DataTypeTag.Intersection) {
-		return supertype.types.values().every(supertype => subsumes(subtype, supertype));
+		result = supertype.types.values().every(supertype => subsumes(subtype, supertype, inProcess));
 	} else if(subtype.tag === DataTypeTag.Intersection) {
-		return subtype.types.values().some(subtype => subsumes(subtype, supertype));
+		result = subtype.types.values().some(subtype => subsumes(subtype, supertype, inProcess));
 	} else if(subtype.tag === DataTypeTag.List && supertype.tag === DataTypeTag.List) {
-		return subsumes(subtype.elementType, supertype.elementType);
+		result = subsumes(subtype.elementType, supertype.elementType, inProcess);
 	} else if(subtype.tag === DataTypeTag.AtomicVector && supertype.tag === DataTypeTag.AtomicVector) {
-		return subsumes(subtype.elementType, supertype.elementType);
+		result = subsumes(subtype.elementType, supertype.elementType, inProcess);
 	} else if(isAtomicVectorBaseType(subtype) && supertype.tag === DataTypeTag.AtomicVector) {
 		// A scalar subsumes a vector type if it subsumes the element type of the vector
-		return subsumes(subtype, supertype.elementType);
+		result = subsumes(subtype, supertype.elementType, inProcess);
 	} else if(subtype.tag === DataTypeTag.Function && supertype.tag === DataTypeTag.Function) {
 		const subtypeParameterKeys = new Set(subtype.parameterTypes.keys());
 		const supertypeParameterKeys = new Set(supertype.parameterTypes.keys());
-		return subsumes(subtype.returnType, supertype.returnType) && subtypeParameterKeys.intersection(supertypeParameterKeys).values().every(key => {
+		result = subsumes(subtype.returnType, supertype.returnType, inProcess) && subtypeParameterKeys.intersection(supertypeParameterKeys).values().every(key => {
 			// eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-			return subsumes(supertype.parameterTypes.get(key)!, subtype.parameterTypes.get(key)!);
+			return subsumes(supertype.parameterTypes.get(key)!, subtype.parameterTypes.get(key)!, inProcess);
 		});
 	} else {
-		return subsumesByTag(subtype.tag, supertype.tag);
+		result = subsumesByTag(subtype.tag, supertype.tag);
 	}
+
+	processedSupertypes?.delete(supertype); // Remove the supertype from the processed set
+
+	return result;
 }
 
 function subsumesByTag(subtype: DataTypeTag, supertype: DataTypeTag): boolean {
@@ -276,7 +302,9 @@ function subsumesByTag(subtype: DataTypeTag, supertype: DataTypeTag): boolean {
 		|| [DataTypeTag.Logical, DataTypeTag.Integer, DataTypeTag.Double, DataTypeTag.Complex, DataTypeTag.String, DataTypeTag.Raw].includes(subtype) && supertype === DataTypeTag.AtomicVector;
 }
 
-function join(type1: DataType, type2: DataType): DataType {
+export function join(type1: DataType, type2: DataType): DataType {
+	// console.debug('Joining', type1, 'and', type2);
+
 	if(type1 instanceof RTypeError) {
 		return type1;
 	} else if(type2 instanceof RTypeError) {
@@ -290,18 +318,28 @@ function join(type1: DataType, type2: DataType): DataType {
 			return type2; // If type1 is an empty union, return type2
 		}
 
-		// ? Use type1.types.values().flatMap(...); instead?
 		const types = new Set<DataType>();
 		for(const subtype of type1.types) {
 			const joinedType = join(subtype, type2);
 			if(joinedType instanceof RTypeError) {
 				return joinedType; // If any subtype resolves to an error, return the error
-			} else if(joinedType instanceof RTypeUnion) {
-				joinedType.types.forEach(type => types.add(type));
 			} else {
-				types.add(joinedType);
+				const typesToAdd = new Set(joinedType instanceof RTypeUnion ? joinedType.types : [joinedType]);
+				for(const type of types) {
+					for(const typeToAdd of typesToAdd) {
+						if(subsumes(typeToAdd, type)) {
+							// If the current type supersumes the new type, do not add the new type
+							typesToAdd.delete(typeToAdd);
+						} else if(subsumes(type, typeToAdd)) {
+							// If the new type supersumes the current type, remove the current type
+							types.delete(type);
+						}
+					}
+				}
+				typesToAdd.forEach(type => types.add(type));
 			}
 		}
+
 		return types.size === 1 ? [...types][0] : new RTypeUnion(...types);
 	} else if(type2 instanceof RTypeUnion) {
 		return join(type2, type1);
@@ -356,7 +394,9 @@ function join(type1: DataType, type2: DataType): DataType {
 	return new RTypeUnion(type1, type2);
 }
 
-function meet(type1: DataType, type2: DataType): DataType {
+export function meet(type1: DataType, type2: DataType): DataType {
+	// console.debug('Meeting', type1, 'and', type2);
+
 	if(type1 instanceof RTypeError) {
 		return type1;
 	} else if(type2 instanceof RTypeError) {
@@ -386,18 +426,28 @@ function meet(type1: DataType, type2: DataType): DataType {
 			return type2; // If type1 is an empty intersection, return type2
 		}
 
-		// ? Use type1.types.values().flatMap(...); instead?
 		const types = new Set<DataType>();
 		for(const subtype of type1.types) {
 			const metType = meet(subtype, type2);
 			if(metType instanceof RTypeError) {
 				return metType; // If any subtype resolves to an error, return the error
-			} else if(metType instanceof RTypeIntersection) {
-				metType.types.forEach(type => types.add(type));
 			} else {
-				types.add(metType);
+				const typesToAdd = new Set(metType instanceof RTypeIntersection ? metType.types : [metType]);
+				for(const type of types) {
+					for(const typeToAdd of typesToAdd) {
+						if(subsumes(type, typeToAdd)) {
+							// If the current type subsumes the new type, do not add the new type
+							typesToAdd.delete(typeToAdd);
+						} else if(subsumes(typeToAdd, type)) {
+							// If the new type subsumes the current type, remove the current type
+							types.delete(type);
+						}
+					}
+				}
+				typesToAdd.forEach(type => types.add(type));
 			}
 		}
+
 		return types.size === 1 ? [...types][0] : new RTypeIntersection(...types);
 	} else if(type2 instanceof RTypeIntersection) {
 		return meet(type2, type1);
diff --git a/test/functionality/typing/subtyping/constrain.test.ts b/test/functionality/typing/subtyping/constrain.test.ts
index e7a2664ca70..aea51fe45be 100644
--- a/test/functionality/typing/subtyping/constrain.test.ts
+++ b/test/functionality/typing/subtyping/constrain.test.ts
@@ -119,4 +119,18 @@ describe('Constrain types with lower and upper bounds', () => {
 		expect(resolve(returnType1)).toEqual(new RTypeVariable(new RIntegerType(), new RTypeIntersection()));
 		expect(resolve(returnType2)).toEqual(new RTypeVariable(new RDoubleType(), new RTypeIntersection()));
 	});
+
+	test('Constrain from both sides', () => {
+		const cache = new Map<UnresolvedDataType, Set<UnresolvedDataType>>();
+
+		const typeVar1 = new UnresolvedRTypeVariable();
+		const typeVar2 = new UnresolvedRTypeVariable();
+		constrain(typeVar1, typeVar2, cache);
+		constrain(typeVar2, typeVar1, cache);
+		constrain(new RIntegerType(), typeVar2, cache);
+		constrain(typeVar2, new RIntegerType(), cache);
+
+		expect(resolve(typeVar1)).toEqual(new RIntegerType());
+		expect(resolve(typeVar2)).toEqual(new RIntegerType());
+	});
 });
\ No newline at end of file
diff --git a/test/functionality/typing/subtyping/resolve.test.ts b/test/functionality/typing/subtyping/resolve.test.ts
new file mode 100644
index 00000000000..90a3f77f243
--- /dev/null
+++ b/test/functionality/typing/subtyping/resolve.test.ts
@@ -0,0 +1,136 @@
+import { describe, expect, test } from 'vitest';
+import type { UnresolvedDataType } from '../../../../src/typing/subtyping/types';
+import { constrain, meet, resolve, UnresolvedRListType, UnresolvedRTypeVariable } from '../../../../src/typing/subtyping/types';
+import { RIntegerType, RTypeVariable, RListType, RTypeIntersection, RNullType, RStringType, RLanguageType, RTypeUnion } from '../../../../src/typing/types';
+
+describe('Resolve constrained types', () => {
+	test('Resolve type with complex constraints 1', () => {
+		const cache = new Map<UnresolvedDataType, Set<UnresolvedDataType>>();
+
+		const typeVar1 = new UnresolvedRTypeVariable();
+		// const typeVar2 = new UnresolvedRTypeVariable();
+		// constrain(typeVar1, typeVar2, cache);
+		// const elementTypeVar = new UnresolvedRTypeVariable();
+		// const typeVar3 = new UnresolvedRTypeVariable();
+		// constrain(elementTypeVar, typeVar3, cache);
+		// const atomicVectorType = new UnresolvedRAtomicVectorType();
+		// const listType1 = new UnresolvedRListType();
+		// const union = new UnresolvedRTypeUnion(atomicVectorType, listType1);
+		// const listType2 = new UnresolvedRListType();
+		constrain(typeVar1, new RStringType(), cache);
+		constrain(typeVar1, new RIntegerType(), cache);
+		const typeVar4 = new UnresolvedRTypeVariable();
+		constrain(typeVar1, typeVar4, cache);
+		// const typeVar5 = new UnresolvedRTypeVariable();
+		constrain(typeVar4, new RNullType(), cache);
+		constrain(typeVar4, new RLanguageType(), cache);
+		// const typeVar6 = new UnresolvedRTypeVariable();
+		// constrain(typeVar5, typeVar6, cache);
+		// const typeVar7 = new UnresolvedRTypeVariable();
+		// constrain(typeVar4, typeVar7, cache);
+
+		expect(resolve(typeVar1)).toEqual(new RTypeVariable(new RTypeUnion(), new RTypeIntersection(new RStringType(), new RIntegerType(), new RNullType(), new RLanguageType())));
+	});
+
+	test('Resolve type with complex constraints 2', () => {
+		const cache = new Map<UnresolvedDataType, Set<UnresolvedDataType>>();
+
+		// 	const typeVar1 = new UnresolvedRTypeVariable(); // ? 5118
+
+		// 	// Subtypes:
+		// 	// const typeVar2 = new UnresolvedRTypeVariable(); // ? 5331
+
+		// 	// const typeVar3 = new UnresolvedRTypeVariable(); // ? 5334
+		// 	// constrain(typeVar2, typeVar3, cache);
+
+		// 	// constrain(typeVar2, typeVar1, cache);
+
+		// 	// Supertypes:
+		// 	const typeVar4 = new UnresolvedRTypeVariable(); // ? 5343
+			
+		// 	const elementTypeVar1 = new UnresolvedRTypeVariable(); // ? 8299
+		// 	// const typeVar5 = new UnresolvedRTypeVariable(); // ? 5352
+		// 	// constrain(elementTypeVar1, typeVar5, cache);
+		// 	const atomicVectorType1 = new UnresolvedRAtomicVectorType(); // ? 8302
+		// 	const listType1 = new UnresolvedRListType(); // ? 8306
+		// 	const union1 = new UnresolvedRTypeUnion(atomicVectorType1, listType1); // ? 8310
+		// 	constrain(typeVar4, union1, cache);
+		// 	const listType2 = new UnresolvedRListType(); // ? 8311
+		// 	constrain(typeVar4, listType2, cache);
+
+		// 	const typeVar6 = new UnresolvedRTypeVariable(); // ? 5358
+
+		// 	const elementTypeVar2 = new UnresolvedRTypeVariable(); // ? 8315
+		// 	// const typeVar7 = new UnresolvedRTypeVariable(); // ? 5367
+		// 	// constrain(elementTypeVar2, typeVar7, cache);
+		// 	const atomicVectorType2 = new UnresolvedRAtomicVectorType(); // ? 8318
+		// 	const listType3 = new UnresolvedRListType(); // ? 8322
+		// 	const union2 = new UnresolvedRTypeUnion(atomicVectorType2, listType3); // ? 8326
+		// 	constrain(typeVar6, union2, cache);
+		// 	const listType4 = new UnresolvedRListType(); // ? 8327
+		// 	constrain(typeVar6, listType4, cache);
+
+		// 	const typeVar8 = new UnresolvedRTypeVariable(); // ? 5451
+
+		// 	const elementTypeVar3 = new UnresolvedRTypeVariable(); // ? 8359
+		// 	// const typeVar9 = new UnresolvedRTypeVariable(); // ? 5460
+		// 	// constrain(elementTypeVar3, typeVar9, cache);
+		// 	const atomicVectorType3 = new UnresolvedRAtomicVectorType(); // ? 8362
+		// 	const listType5 = new UnresolvedRListType(); // ? 8366
+		// 	const union3 = new UnresolvedRTypeUnion(atomicVectorType3, listType5); // ? 8370
+		// 	constrain(typeVar8, union3, cache);
+		// 	const listType6 = new UnresolvedRListType(); // ? 8371
+		// 	constrain(typeVar8, listType6, cache);
+
+		// 	const typeVar10 = new UnresolvedRTypeVariable(); // ? 5466
+
+		// 	const elementTypeVar4 = new UnresolvedRTypeVariable(); // ? 8375
+		// 	// const typeVar11 = new UnresolvedRTypeVariable(); // ? 5475
+		// 	// constrain(elementTypeVar4, typeVar11, cache);
+		// 	const atomicVectorType4 = new UnresolvedRAtomicVectorType(); // ? 8378
+		// 	const listType7 = new UnresolvedRListType(); // ? 8382
+		// 	const union4 = new UnresolvedRTypeUnion(atomicVectorType4, listType7); // ? 8386
+		// 	constrain(typeVar10, union4, cache);
+		// 	const listType8 = new UnresolvedRListType(); // ? 8387
+		// 	constrain(typeVar10, listType8, cache);
+
+		// 	constrain(typeVar1, typeVar4, cache);
+		// 	constrain(typeVar1, typeVar6, cache);
+		// 	constrain(typeVar1, typeVar8, cache);
+		// 	constrain(typeVar1, typeVar10, cache);
+
+		const typeVar1 = new UnresolvedRTypeVariable();
+
+		const typeVar4 = new UnresolvedRTypeVariable();
+		constrain(typeVar4, new RIntegerType(), cache);
+		constrain(typeVar4, new UnresolvedRListType(), cache);
+
+		const typeVar6 = new UnresolvedRTypeVariable();
+		constrain(typeVar6, new RIntegerType(), cache);
+		constrain(typeVar6, new UnresolvedRListType(), cache);
+
+		const typeVar8 = new UnresolvedRTypeVariable();
+		constrain(typeVar8, new RIntegerType(), cache);
+		constrain(typeVar8, new UnresolvedRListType(), cache);
+
+		const typeVar10 = new UnresolvedRTypeVariable();
+		constrain(typeVar10, new RIntegerType(), cache);
+		constrain(typeVar10, new UnresolvedRListType(), cache);
+
+		const typeVar12 = new UnresolvedRTypeVariable();
+		constrain(typeVar12, new RIntegerType(), cache);
+		constrain(typeVar12, new UnresolvedRListType(), cache);
+
+		constrain(typeVar1, typeVar4, cache);
+		constrain(typeVar1, typeVar6, cache);
+		constrain(typeVar1, typeVar8, cache);
+		constrain(typeVar1, typeVar10, cache);
+		constrain(typeVar1, typeVar12, cache);
+
+		expect(resolve(typeVar1)).toEqual(new RTypeVariable(new RTypeUnion(), new RTypeIntersection(new RIntegerType(), new RListType(new RTypeVariable()))));
+	});
+
+	test('Calculate meet with intersections', () => {
+		expect(meet(new RTypeIntersection(new RIntegerType(), new RListType(new RNullType())), new RTypeIntersection(new RIntegerType(), new RListType(new RNullType())))).toEqual(new RTypeIntersection(new RIntegerType(), new RListType(new RNullType())));
+	});
+});
\ No newline at end of file

From 7585d548e17ef0acbc1d0e4c69931457caac4f50 Mon Sep 17 00:00:00 2001
From: Lukas Rohde <lukas.rohde@silupe.de>
Date: Thu, 31 Jul 2025 13:02:19 +0200
Subject: [PATCH 111/153] feat-fix(typing): fix `subsumes` function

---
 src/typing/subtyping/types.ts                 |  6 +--
 .../typing/subtyping/subsumes.test.ts         | 40 +++++++++++++++++++
 2 files changed, 43 insertions(+), 3 deletions(-)
 create mode 100644 test/functionality/typing/subtyping/subsumes.test.ts

diff --git a/src/typing/subtyping/types.ts b/src/typing/subtyping/types.ts
index 9d4e8893881..7a3dedc3737 100644
--- a/src/typing/subtyping/types.ts
+++ b/src/typing/subtyping/types.ts
@@ -238,7 +238,7 @@ export function resolve(type: UnresolvedDataType, cache: Map<UnresolvedDataType,
 }
 
 export function subsumes(subtype: DataType | UnresolvedDataType, supertype: DataType | UnresolvedDataType, inProcess: Map<DataType | UnresolvedDataType, Set<DataType | UnresolvedDataType>> = new Map()): boolean {
-	// console.debug('Checking if', subtype, 'subsumes', supertype);
+	// console.debug('Checking if', inspect(subtype, { depth: null, colors: true }), 'subsumes', inspect(supertype, { depth: null, colors: true }));
 
 	if(subtype === supertype) {
 		return true; // If both types are the same, they subsume each other
@@ -257,9 +257,9 @@ export function subsumes(subtype: DataType | UnresolvedDataType, supertype: Data
 	if(subtype.tag === DataTypeTag.Error || supertype.tag === DataTypeTag.Error) {
 		result = false; // Error types do not subsume and are not subsumed by any other type
 	} else if(subtype.tag === DataTypeTag.Variable) {
-		result = subsumes(subtype.lowerBound, supertype, inProcess) && subsumes(subtype.upperBound, supertype, inProcess);
+		result = subsumes(subtype.upperBound, supertype, inProcess);
 	} else if(supertype.tag === DataTypeTag.Variable) {
-		result = subsumes(supertype.lowerBound, subtype, inProcess) && subsumes(subtype, supertype.upperBound, inProcess);
+		result = subsumes(subtype, supertype.upperBound, inProcess);
 	} else if(subtype.tag === DataTypeTag.Union) {
 		result = subtype.types.values().every(subtype => subsumes(subtype, supertype, inProcess));
 	} else if(supertype.tag === DataTypeTag.Union) {
diff --git a/test/functionality/typing/subtyping/subsumes.test.ts b/test/functionality/typing/subtyping/subsumes.test.ts
new file mode 100644
index 00000000000..0d0c2b818fa
--- /dev/null
+++ b/test/functionality/typing/subtyping/subsumes.test.ts
@@ -0,0 +1,40 @@
+import { describe, expect, test } from 'vitest';
+import type { UnresolvedDataType } from '../../../../src/typing/subtyping/types';
+import { constrain, subsumes, UnresolvedRTypeVariable } from '../../../../src/typing/subtyping/types';
+import { RIntegerType, RNullType, RLogicalType } from '../../../../src/typing/types';
+
+describe('Test subsumption of types', () => {
+	test('Test subsumption of types with nested variables', () => {
+		const cache = new Map<UnresolvedDataType, Set<UnresolvedDataType>>();
+
+		const logicalType = new RLogicalType();
+		const integerType = new RIntegerType();
+		const nullType = new RNullType();
+
+		const typeVar1 = new UnresolvedRTypeVariable();
+		// eslint-disable-next-line @typescript-eslint/naming-convention
+		const typeVar1_1 = new UnresolvedRTypeVariable();
+		// eslint-disable-next-line @typescript-eslint/naming-convention
+		const typeVar1_2 = new UnresolvedRTypeVariable();
+		constrain(logicalType, typeVar1, cache);
+		constrain(logicalType, typeVar1_1, cache);
+		constrain(logicalType, typeVar1_2, cache);
+		constrain(integerType, typeVar1, cache);
+		constrain(integerType, typeVar1_1, cache);
+		constrain(integerType, typeVar1_2, cache);
+		constrain(nullType, typeVar1, cache);
+		constrain(nullType, typeVar1_1, cache);
+		constrain(nullType, typeVar1_2, cache);
+		constrain(typeVar1, typeVar1_1, cache);
+		constrain(typeVar1_1, typeVar1_2, cache);
+
+		const typeVar2 = new UnresolvedRTypeVariable();
+		constrain(logicalType, typeVar2, cache);
+		constrain(integerType, typeVar2, cache);
+		constrain(nullType, typeVar2, cache);
+		constrain(typeVar2, typeVar1, cache);
+
+		expect(subsumes(typeVar2, typeVar1)).toBe(true);
+		expect(subsumes(typeVar1, typeVar2)).toBe(true);
+	});
+});
\ No newline at end of file

From 4b2946ceaba3d060b8b36130b2f4a17fb5960d2e Mon Sep 17 00:00:00 2001
From: Lukas Rohde <lukas.rohde@silupe.de>
Date: Thu, 31 Jul 2025 13:04:19 +0200
Subject: [PATCH 112/153] feat-fix(typing): fix overloading and upper bound
 unions by pruning

---
 src/typing/subtyping/types.ts                 | 395 +++++++++++++++---
 .../typing/subtyping/constrain.test.ts        |  81 +++-
 2 files changed, 411 insertions(+), 65 deletions(-)

diff --git a/src/typing/subtyping/types.ts b/src/typing/subtyping/types.ts
index 7a3dedc3737..be522923505 100644
--- a/src/typing/subtyping/types.ts
+++ b/src/typing/subtyping/types.ts
@@ -1,7 +1,6 @@
 import { guard } from '../../util/assert';
 import type { DataType , AtomicVectorBaseType, REnvironmentType, RLanguageType, RNullType } from '../types';
 import { DataTypeTag, isAtomicVectorBaseType, RAtomicVectorType, RFunctionType, RListType, RTypeError, RTypeIntersection, RTypeUnion, RTypeVariable } from '../types';
-// import { inspect } from 'util';
 
 // let idCounter = 0;
 
@@ -23,10 +22,13 @@ export class UnresolvedRListType {
 	readonly elementType = new UnresolvedRTypeVariable();
 	readonly indexedElementTypes = new Map<number | string, UnresolvedRTypeVariable>();
 
-	constructor(elementType?: UnresolvedRTypeVariable) {
+	constructor(elementType?: UnresolvedRTypeVariable, indexedElementTypes?: Map<number | string, UnresolvedRTypeVariable>) {
 		if(elementType !== undefined) {
 			this.elementType = elementType;
 		}
+		if(indexedElementTypes !== undefined) {
+			this.indexedElementTypes = indexedElementTypes;
+		}
 	}
 }
 
@@ -47,7 +49,10 @@ export class UnresolvedRFunctionType {
 	readonly parameterTypes = new Map<number | string, UnresolvedRTypeVariable>();
 	readonly returnType = new UnresolvedRTypeVariable();
 
-	constructor(returnType?: UnresolvedRTypeVariable) {
+	constructor(parameterTypes?: Map<number | string, UnresolvedRTypeVariable>, returnType?: UnresolvedRTypeVariable) {
+		if(parameterTypes !== undefined) {
+			this.parameterTypes = parameterTypes;
+		}
 		if(returnType !== undefined) {
 			this.returnType = returnType;
 		}
@@ -66,7 +71,7 @@ export function getParameterTypeFromFunction(func: UnresolvedRFunctionType, inde
 export class UnresolvedRTypeUnion {
 	readonly tag = DataTypeTag.Union;
 	// readonly id = idCounter++;
-	readonly types: Set<UnresolvedDataType> = new Set();
+	types: Set<UnresolvedDataType> = new Set();
 
 	constructor(...types: UnresolvedDataType[]) {
 		for(const type of types) {
@@ -79,7 +84,7 @@ export class UnresolvedRTypeUnion {
 export class UnresolvedRTypeIntersection {
 	readonly tag = DataTypeTag.Intersection;
 	// readonly id = idCounter++;
-	readonly types: Set<UnresolvedDataType> = new Set();
+	types: Set<UnresolvedDataType> = new Set();
 
 	constructor(...types: UnresolvedDataType[]) {
 		for(const type of types) {
@@ -97,7 +102,7 @@ export class UnresolvedRTypeVariable {
 }
 
 
-export function constrain(subtype: UnresolvedDataType, supertype: UnresolvedDataType, cache: Map<UnresolvedDataType, Set<UnresolvedDataType>>): void {
+export function constrain(subtype: UnresolvedDataType, supertype: UnresolvedDataType, cache: Map<UnresolvedDataType, Set<UnresolvedDataType>> = new Map()): void {
 	// console.debug('constraining', type, 'with upper bound', bound);
 
 	if(subtype === supertype) {
@@ -114,7 +119,15 @@ export function constrain(subtype: UnresolvedDataType, supertype: UnresolvedData
 		cache.set(subtype, new Set([supertype]));
 	}
 
-	if(subtype instanceof UnresolvedRTypeVariable) {
+	if(subtype instanceof UnresolvedRTypeUnion) {
+		for(const type of subtype.types) {
+			constrain(type, supertype, cache);
+		}
+	} else if(supertype instanceof UnresolvedRTypeIntersection) {
+		for(const type of supertype.types) {
+			constrain(type, type, cache);
+		}
+	} else if(subtype instanceof UnresolvedRTypeVariable) {
 		subtype.upperBound.types.add(supertype);
 		for(const lowerBound of subtype.lowerBound.types) {
 			constrain(lowerBound, supertype, cache);
@@ -124,30 +137,6 @@ export function constrain(subtype: UnresolvedDataType, supertype: UnresolvedData
 		for(const upperBound of supertype.upperBound.types) {
 			constrain(subtype, upperBound, cache);
 		}
-	} else if(subtype instanceof UnresolvedRTypeUnion) {
-		for(const type of subtype.types) {
-			constrain(type, supertype, cache);
-		}
-	} else if(supertype instanceof UnresolvedRTypeUnion) {
-		for(const type of supertype.types.values()) {
-			if(!subsumes(subtype, type)) {
-				supertype.types.delete(type);
-			} else {
-				constrain(subtype, type, cache);
-			}
-		}
-	} else if(subtype instanceof UnresolvedRTypeIntersection) {
-		for(const type of subtype.types.values()) {
-			if(!subsumes(type, supertype)) {
-				subtype.types.delete(type);
-			} else {
-				constrain(type, supertype, cache);
-			}
-		}
-	} else if(supertype instanceof UnresolvedRTypeIntersection) {
-		for(const type of supertype.types) {
-			constrain(type, type, cache);
-		}
 	} else if(subtype instanceof UnresolvedRFunctionType && supertype instanceof UnresolvedRFunctionType) {
 		const subtypeParameterKeys = new Set(subtype.parameterTypes.keys());
 		const supertypeParameterKeys = new Set(supertype.parameterTypes.keys());
@@ -165,6 +154,107 @@ export function constrain(subtype: UnresolvedDataType, supertype: UnresolvedData
 }
 
 
+export function prune(variable: UnresolvedRTypeVariable, inProcess: Set<UnresolvedRTypeVariable | Set<UnresolvedDataType>> = new Set()): void {
+	inProcess.add(variable);
+
+	function pruneLowerBounds(lowerBounds: Set<UnresolvedDataType>): Set<UnresolvedDataType> {
+		inProcess.add(lowerBounds);
+
+		const prunedBounds = new Set(lowerBounds.values().flatMap(lowerBound => {
+			if(lowerBound instanceof UnresolvedRTypeVariable) {
+				// If the lower bound is a type variable, we only care about its lower bound
+				if(inProcess.has(lowerBound) || inProcess.has(lowerBound.lowerBound.types)) {
+					return []; // If the variable is already in process, we skip it to avoid infinite recursion
+				}
+				prune(lowerBound, inProcess); // Prune the variable recursively w.r.t. its own bounds
+				lowerBound.lowerBound.types = pruneLowerBounds(lowerBound.lowerBound.types);
+				return [lowerBound];
+			} else if(lowerBound instanceof UnresolvedRTypeUnion) {
+				// If the lower bound is a union, we prune and include its types directly
+				if(inProcess.has(lowerBound.types)) {
+					return []; // If the union is already in process, we skip it to avoid infinite recursion
+				}
+				return pruneLowerBounds(lowerBound.types);
+			} else if(lowerBound instanceof UnresolvedRTypeIntersection) {
+				// If the lower bound is an intersection, we need to consider its upper bounds
+				if(variable.upperBound.types.size === 0) {
+					return [lowerBound]; // If there are no upper bounds, we keep the lower bound
+				}
+				// Otherwise, we prune it to only include types that subsume some upper bound
+				let upperBound: UnresolvedDataType = new UnresolvedRTypeUnion();
+				for(const type of variable.upperBound.types) {
+					upperBound = unresolvedJoin(upperBound, type);
+				}
+				return [new UnresolvedRTypeIntersection(...lowerBound.types.values().filter(type => {
+					if(variable.upperBound.types.values().some(upperBound => subsumes(type, upperBound))) {
+						// console.debug('\x1b[36m', 'Constraining', inspect(type, { depth: null, colors: true }), 'with upper bound', inspect(upperBound, { depth: null, colors: true }), '\x1b[0m');
+						constrain(type, upperBound);
+						return true;
+					}
+					return false;
+				}))];
+			} else {
+				return [lowerBound]; // If the lower bound is a concrete type, we keep it as is
+			}
+		}));
+
+		inProcess.delete(lowerBounds);
+
+		return prunedBounds;
+	}
+	function pruneUpperBounds(upperBounds: Set<UnresolvedDataType>): Set<UnresolvedDataType> {
+		inProcess.add(upperBounds);
+
+		const prunedBounds = new Set(upperBounds.values().flatMap(upperBound => {
+			if(upperBound instanceof UnresolvedRTypeVariable) {
+				// If the upper bound is a type variable, we only care about its upper bound
+				if(inProcess.has(upperBound) || inProcess.has(upperBound.upperBound.types)) {
+					return []; // If the variable is already in process, we skip it to avoid infinite recursion
+				}
+				prune(upperBound, inProcess); // Prune the variable recursively w.r.t. its own bounds
+				upperBound.upperBound.types = pruneUpperBounds(upperBound.upperBound.types);
+				return [upperBound];
+			} else if(upperBound instanceof UnresolvedRTypeIntersection) {
+				// If the upper bound is an intersection, we prune and include its types directly
+				if(inProcess.has(upperBound.types)) {
+					return []; // If the intersection is already in process, we skip it to avoid infinite recursion
+				}
+				return pruneUpperBounds(upperBound.types);
+			} else if(upperBound instanceof UnresolvedRTypeUnion) {
+				// If the upper bound is a union, we need to consider its lower bounds
+				if(variable.lowerBound.types.size === 0) {
+					return [upperBound]; // If there are no lower bounds, we keep the upper bound
+				}
+				// Otherwise, we prune it to only include types that are subsumed by some lower bound
+				let lowerBound: UnresolvedDataType = new UnresolvedRTypeIntersection();
+				for(const type of variable.lowerBound.types) {
+					lowerBound = unresolvedMeet(lowerBound, type);
+				}
+				return [new UnresolvedRTypeUnion(...upperBound.types.values().filter(type => {
+					if(variable.lowerBound.types.values().some(lowerBound => subsumes(lowerBound, type))) {
+						// console.debug('\x1b[36m', 'Constraining', inspect(type, { depth: null, colors: true }), 'with lower bound', inspect(lowerBound, { depth: null, colors: true }), '\x1b[0m');
+						constrain(lowerBound, type);
+						return true;
+					}
+					return false;
+				}))];
+			} else {
+				return [upperBound]; // If the upper bound is a concrete type, we keep it
+			}
+		}));
+
+		inProcess.delete(upperBounds);
+
+		return prunedBounds;
+	}
+	
+	variable.lowerBound.types = pruneLowerBounds(variable.lowerBound.types);
+	variable.upperBound.types = pruneUpperBounds(variable.upperBound.types);
+
+	inProcess.delete(variable);
+}
+
+
 export function resolve(type: UnresolvedDataType, cache: Map<UnresolvedDataType, DataType> = new Map()): DataType {
 	const cachedType = cache.get(type);
 	if(cachedType !== undefined) {
@@ -174,6 +264,8 @@ export function resolve(type: UnresolvedDataType, cache: Map<UnresolvedDataType,
 	if(type instanceof UnresolvedRTypeVariable) {
 		cache.set(type, new RTypeVariable()); // Prevent infinite recursion
 
+		prune(type); // Prune the variable to remove unnecessary bounds
+
 		const lowerBound = resolve(type.lowerBound, cache);
 		const upperBound = resolve(type.upperBound, cache);
 
@@ -202,6 +294,7 @@ export function resolve(type: UnresolvedDataType, cache: Map<UnresolvedDataType,
 			const resolvedSubtype = resolve(subtype, cache);
 			resolvedType = join(resolvedType, resolvedSubtype);
 		}
+		
 		cache.set(type, resolvedType);
 		return resolvedType;
 	} else if(type instanceof UnresolvedRTypeIntersection) {
@@ -212,23 +305,35 @@ export function resolve(type: UnresolvedDataType, cache: Map<UnresolvedDataType,
 			const resolvedSubtype = resolve(subtype, cache);
 			resolvedType = meet(resolvedType, resolvedSubtype);
 		}
+		
 		cache.set(type, resolvedType);
 		return resolvedType;
 	} else if(type instanceof UnresolvedRFunctionType) {
+		type.parameterTypes.values().forEach(paramType => prune(paramType));
+		prune(type.returnType);
+
 		const resolvedParameterTypes = new Map(type.parameterTypes.entries().toArray().map(([key, type]) => [key, resolve(type, cache)]));
 		const resolvedReturnType = resolve(type.returnType, cache);
 		const resolvedType = new RFunctionType(resolvedParameterTypes, resolvedReturnType);
+		
 		cache.set(type, resolvedType);
 		return resolvedType;
 	} else if(type instanceof UnresolvedRAtomicVectorType) {
+		prune(type.elementType);
+
 		const resolvedElementType = resolve(type.elementType, cache);
 		const resolvedType = new RAtomicVectorType(resolvedElementType);
+		
 		cache.set(type, resolvedType);
 		return resolvedType;
 	} else if(type instanceof UnresolvedRListType) {
+		type.indexedElementTypes.values().forEach(elementType => prune(elementType));
+		prune(type.elementType);
+
 		const resolvedElementType = resolve(type.elementType, cache);
 		const resolvedIndexedElementTypes = new Map(type.indexedElementTypes.entries().map(([indexOrName, elementType]) => [indexOrName, resolve(elementType, cache)]));
 		const resolvedType = new RListType(resolvedElementType, resolvedIndexedElementTypes);
+		
 		cache.set(type, resolvedType);
 		return resolvedType;
 	} else {
@@ -302,6 +407,108 @@ function subsumesByTag(subtype: DataTypeTag, supertype: DataTypeTag): boolean {
 		|| [DataTypeTag.Logical, DataTypeTag.Integer, DataTypeTag.Double, DataTypeTag.Complex, DataTypeTag.String, DataTypeTag.Raw].includes(subtype) && supertype === DataTypeTag.AtomicVector;
 }
 
+export function unresolvedJoin(type1: UnresolvedDataType, type2: UnresolvedDataType): UnresolvedDataType {
+	// console.debug('Joining', type1, 'and', type2);
+
+	if(type1 instanceof RTypeError) {
+		return type1;
+	} else if(type2 instanceof RTypeError) {
+		return type2;
+	} else if(type1 instanceof UnresolvedRTypeVariable) {
+		return unresolvedJoin(type1.lowerBound, type2);
+	} else if(type2 instanceof UnresolvedRTypeVariable) {
+		return unresolvedJoin(type1, type2.lowerBound);
+	} else if(type1 instanceof UnresolvedRTypeUnion) {
+		if(type1.types.size === 0) {
+			return type2; // If type1 is an empty union, return type2
+		}
+
+		const types = new Set<UnresolvedDataType>();
+		for(const type of type1.types) {
+			const joinedType = unresolvedJoin(type, type2);
+			if(joinedType instanceof RTypeError) {
+				return joinedType; // If any subtype resolves to an error, return the error
+			} else {
+				const typesToAdd = new Set(joinedType instanceof UnresolvedRTypeUnion ? joinedType.types : [joinedType]);
+				for(const type of types) {
+					for(const typeToAdd of typesToAdd) {
+						if(subsumes(typeToAdd, type)) {
+							// If the current type supersumes the new type, do not add the new type
+							typesToAdd.delete(typeToAdd);
+						} else if(subsumes(type, typeToAdd)) {
+							// If the new type supersumes the current type, remove the current type
+							types.delete(type);
+						}
+					}
+				}
+				typesToAdd.forEach(type => types.add(type));
+			}
+		}
+
+		return types.size === 1 ? [...types][0] : new UnresolvedRTypeUnion(...types);
+	} else if(type2 instanceof UnresolvedRTypeUnion) {
+		return unresolvedJoin(type2, type1);
+	} else if(type1 instanceof UnresolvedRFunctionType && type2 instanceof UnresolvedRFunctionType) {
+		const parameterTypes = new Map<number | string, UnresolvedRTypeVariable>();
+		const keys1 = new Set(type1.parameterTypes.keys());
+		const keys2 = new Set(type2.parameterTypes.keys());
+		for(const key of keys1.union(keys2)) {
+			const parameterType1 = type1.parameterTypes.get(key) ?? new UnresolvedRTypeUnion();
+			const parameterType2 = type2.parameterTypes.get(key) ?? new UnresolvedRTypeUnion();
+			const metParameterType = unresolvedMeet(parameterType1, parameterType2);
+			const parameterType = new UnresolvedRTypeVariable();
+			constrain(metParameterType, parameterType);
+			// constrain(parameterType, metParameterType);
+			parameterTypes.set(key, parameterType);
+		}
+		const joinedReturnType = unresolvedJoin(type1.returnType, type2.returnType);
+		const returnType = new UnresolvedRTypeVariable();
+		constrain(returnType, joinedReturnType);
+		// constrain(joinedReturnType, returnType);
+		return new UnresolvedRFunctionType(parameterTypes, returnType);
+	} else if(type1 instanceof UnresolvedRListType && type2 instanceof UnresolvedRListType) {
+		const indexedElementTypes = new Map<number | string, UnresolvedRTypeVariable>();
+		const keys1 = new Set(type1.indexedElementTypes.keys());
+		const keys2 = new Set(type2.indexedElementTypes.keys());
+		for(const key of keys1.intersection(keys2)) {
+			const elementType1 = type1.indexedElementTypes.get(key) ?? new UnresolvedRTypeIntersection();
+			const elementType2 = type2.indexedElementTypes.get(key) ?? new UnresolvedRTypeIntersection();
+			const joinedElementType = unresolvedJoin(elementType1, elementType2);
+			const elementType = new UnresolvedRTypeVariable();
+			constrain(elementType, joinedElementType);
+			// constrain(joinedElementType, elementType);
+			indexedElementTypes.set(key, elementType);
+		}
+		const joinedElementType = unresolvedJoin(type1.elementType, type2.elementType);
+		const elementType = new UnresolvedRTypeVariable();
+		constrain(elementType, joinedElementType);
+		// constrain(joinedElementType, elementType);
+		return new UnresolvedRListType(elementType, indexedElementTypes);
+	} else if(type1 instanceof UnresolvedRAtomicVectorType && type2 instanceof UnresolvedRAtomicVectorType) {
+		const joinedElementType = unresolvedJoin(type1.elementType, type2.elementType);
+		const elementType = new UnresolvedRTypeVariable();
+		constrain(elementType, joinedElementType);
+		// constrain(joinedElementType, elementType);
+		return new UnresolvedRAtomicVectorType(elementType);
+	} else if(isAtomicVectorBaseType(type1) && type2.tag === DataTypeTag.AtomicVector) {
+		const joinedElementType = unresolvedJoin(type1, type2.elementType);
+		const elementType = new UnresolvedRTypeVariable();
+		constrain(elementType, joinedElementType);
+		// constrain(joinedElementType, elementType);
+		return new UnresolvedRAtomicVectorType(elementType);
+	} else if(isAtomicVectorBaseType(type2) && type1.tag === DataTypeTag.AtomicVector) {
+		const joinedElementType = unresolvedJoin(type2, type1.elementType);
+		const elementType = new UnresolvedRTypeVariable();
+		constrain(elementType, joinedElementType);
+		// constrain(joinedElementType, elementType);
+		return new UnresolvedRAtomicVectorType(elementType);
+	} else if(subsumesByTag(type1.tag, type2.tag)) {
+		return type2;
+	} else if(subsumesByTag(type2.tag, type1.tag)) {
+		return type1;
+	}
+	return new UnresolvedRTypeUnion(type1, type2);
+}
 export function join(type1: DataType, type2: DataType): DataType {
 	// console.debug('Joining', type1, 'and', type2);
 
@@ -343,22 +550,6 @@ export function join(type1: DataType, type2: DataType): DataType {
 		return types.size === 1 ? [...types][0] : new RTypeUnion(...types);
 	} else if(type2 instanceof RTypeUnion) {
 		return join(type2, type1);
-	// } else if(type1 instanceof RTypeIntersection) {
-	// 	// ? Use type1.types.values().flatMap(...); instead?
-	// 	const types = new Set<DataType>();
-	// 	for(const subtype of type1.types) {
-	// 		const joinedType = join(subtype, type2);
-	// 		if(joinedType instanceof RErrorType) {
-	// 			return joinedType; // If any subtype resolves to an error, return the error
-	// 		} else if(joinedType instanceof RTypeIntersection) {
-	// 			joinedType.types.forEach(type => types.add(type));
-	// 		} else {
-	// 			types.add(joinedType);
-	// 		}
-	// 	}
-	// 	return types.size === 1 ? [...types][0] : new RTypeIntersection(...types);
-	// } else if(type2 instanceof RTypeIntersection) {
-	// 	return join(type2, type1);
 	} else if(type1 instanceof RFunctionType && type2 instanceof RFunctionType) {
 		const parameterTypes = new Map<number | string, DataType>();
 		const keys1 = new Set(type1.parameterTypes.keys());
@@ -394,6 +585,100 @@ export function join(type1: DataType, type2: DataType): DataType {
 	return new RTypeUnion(type1, type2);
 }
 
+export function unresolvedMeet(type1: UnresolvedDataType, type2: UnresolvedDataType): UnresolvedDataType {
+	// console.debug('Meeting', type1, 'and', type2);
+
+	if(type1 instanceof RTypeError) {
+		return type1;
+	} else if(type2 instanceof RTypeError) {
+		return type2;
+	} else if(type1 instanceof UnresolvedRTypeVariable) {
+		return unresolvedMeet(type1.upperBound, type2);
+	} else if(type2 instanceof UnresolvedRTypeVariable) {
+		return unresolvedMeet(type1, type2.upperBound);
+	} else if(type1 instanceof UnresolvedRTypeIntersection) {
+		if(type1.types.size === 0) {
+			return type2; // If type1 is an empty intersection, return type2
+		}
+
+		const types = new Set<UnresolvedDataType>();
+		for(const subtype of type1.types) {
+			const metType = unresolvedMeet(subtype, type2);
+			if(metType instanceof RTypeError) {
+				return metType; // If any subtype resolves to an error, return the error
+			} else {
+				const typesToAdd = new Set(metType instanceof UnresolvedRTypeIntersection ? metType.types : [metType]);
+				for(const type of types) {
+					for(const typeToAdd of typesToAdd) {
+						if(subsumes(type, typeToAdd)) {
+							// If the current type subsumes the new type, do not add the new type
+							typesToAdd.delete(typeToAdd);
+						} else if(subsumes(typeToAdd, type)) {
+							// If the new type subsumes the current type, remove the current type
+							types.delete(type);
+						}
+					}
+				}
+				typesToAdd.forEach(type => types.add(type));
+			}
+		}
+
+		return types.size === 1 ? [...types][0] : new UnresolvedRTypeIntersection(...types);
+	} else if(type2 instanceof UnresolvedRTypeIntersection) {
+		return unresolvedMeet(type2, type1);
+	} else if(type1 instanceof UnresolvedRFunctionType && type2 instanceof UnresolvedRFunctionType) {
+		const parameterTypes = new Map<number | string, UnresolvedRTypeVariable>();
+		const keys1 = new Set(type1.parameterTypes.keys());
+		const keys2 = new Set(type2.parameterTypes.keys());
+		for(const key of keys1.intersection(keys2)) {
+			const parameterType1 = type1.parameterTypes.get(key) ?? new UnresolvedRTypeIntersection();
+			const parameterType2 = type2.parameterTypes.get(key) ?? new UnresolvedRTypeIntersection();
+			const joinedParameterType = unresolvedJoin(parameterType1, parameterType2);
+			const parameterType = new UnresolvedRTypeVariable();
+			constrain(parameterType, joinedParameterType);
+			// constrain(joinedParameterType, parameterType);
+			parameterTypes.set(key, parameterType);
+		}
+		const metReturnType = unresolvedMeet(type1.returnType, type2.returnType);
+		const returnType = new UnresolvedRTypeVariable();
+		constrain(metReturnType, returnType);
+		// constrain(returnType, metReturnType);
+		return new UnresolvedRFunctionType(parameterTypes, returnType);
+	} else if(type1 instanceof UnresolvedRListType && type2 instanceof UnresolvedRListType) {
+		const indexedElementTypes = new Map<number | string, UnresolvedRTypeVariable>();
+		const keys1 = new Set(type1.indexedElementTypes.keys());
+		const keys2 = new Set(type2.indexedElementTypes.keys());
+		for(const key of keys1.union(keys2)) {
+			const elementType1 = type1.indexedElementTypes.get(key) ?? new UnresolvedRTypeUnion();
+			const elementType2 = type2.indexedElementTypes.get(key) ?? new UnresolvedRTypeUnion();
+			const metElementType = unresolvedMeet(elementType1, elementType2);
+			const elementType = new UnresolvedRTypeVariable();
+			constrain(metElementType, elementType);
+			// constrain(elementType, metElementType);
+			indexedElementTypes.set(key, elementType);
+		}
+		const metElementType = unresolvedMeet(type1.elementType, type2.elementType);
+		const elementType = new UnresolvedRTypeVariable();
+		constrain(metElementType, elementType);
+		// constrain(elementType, metElementType);
+		return new UnresolvedRListType(elementType, indexedElementTypes);
+	} else if(type1 instanceof RAtomicVectorType && type2 instanceof UnresolvedRAtomicVectorType) {
+		const metElementType = unresolvedMeet(type1.elementType, type2.elementType);
+		const elementType = new UnresolvedRTypeVariable();
+		constrain(metElementType, elementType);
+		// constrain(elementType, metElementType);
+		return new UnresolvedRAtomicVectorType(elementType);
+	} else if(isAtomicVectorBaseType(type1) && type2.tag === DataTypeTag.AtomicVector) {
+		return unresolvedMeet(type1, type2.elementType);
+	} else if(isAtomicVectorBaseType(type2) && type1.tag === DataTypeTag.AtomicVector) {
+		return unresolvedMeet(type2, type1.elementType);
+	} else if(subsumesByTag(type1.tag, type2.tag)) {
+		return type1;
+	} else if(subsumesByTag(type2.tag, type1.tag)) {
+		return type2;
+	}
+	return new UnresolvedRTypeIntersection(type1, type2);
+}
 export function meet(type1: DataType, type2: DataType): DataType {
 	// console.debug('Meeting', type1, 'and', type2);
 
@@ -405,22 +690,6 @@ export function meet(type1: DataType, type2: DataType): DataType {
 		return meet(type1.upperBound, type2);
 	} else if(type2 instanceof RTypeVariable) {
 		return meet(type1, type2.upperBound);
-	// } else if(type1 instanceof RTypeUnion) {
-	// 	// ? Use type1.types.values().flatMap(...); instead?
-	// 	const types = new Set<DataType>();
-	// 	for(const subtype of type1.types) {
-	// 		const metType = meet(subtype, type2);
-	// 		if(metType instanceof RErrorType) {
-	// 			return metType; // If any subtype resolves to an error, return the error
-	// 		} else if(metType instanceof RTypeUnion) {
-	// 			metType.types.forEach(type => types.add(type));
-	// 		} else {
-	// 			types.add(metType);
-	// 		}
-	// 	}
-	// 	return types.size === 1 ? [...types][0] : new RTypeUnion(...types);
-	// } else if(type2 instanceof RTypeUnion) {
-	// 	return meet(type2, type1);
 	} else if(type1 instanceof RTypeIntersection) {
 		if(type1.types.size === 0) {
 			return type2; // If type1 is an empty intersection, return type2
diff --git a/test/functionality/typing/subtyping/constrain.test.ts b/test/functionality/typing/subtyping/constrain.test.ts
index aea51fe45be..95b3c603284 100644
--- a/test/functionality/typing/subtyping/constrain.test.ts
+++ b/test/functionality/typing/subtyping/constrain.test.ts
@@ -71,7 +71,70 @@ describe('Constrain types with lower and upper bounds', () => {
 		expect(resolve(elementType)).toEqual(new RTypeVariable(new RIntegerType(), new RTypeIntersection()));
 	});
 
-	test('Function overloading', () => {
+	test('Function overloading 1', () => {
+		const cache = new Map<UnresolvedDataType, Set<UnresolvedDataType>>();
+
+		// Predetermined types in context
+		const funcType1 = new UnresolvedRFunctionType();
+		const paramType1 = new UnresolvedRTypeVariable();
+		funcType1.parameterTypes.set(0, paramType1);
+		constrain(new RIntegerType(), paramType1, cache);
+		constrain(paramType1, new RIntegerType(), cache);
+		constrain(new RIntegerType(), funcType1.returnType, cache);
+		constrain(funcType1.returnType, new RIntegerType(), cache);
+
+		const funcType2 = new UnresolvedRFunctionType();
+		const paramType2 = new UnresolvedRTypeVariable();
+		funcType2.parameterTypes.set(0, paramType2);
+		constrain(new RStringType(), paramType2, cache);
+		constrain(paramType2, new RStringType(), cache);
+		constrain(new RStringType(), funcType2.returnType, cache);
+		constrain(funcType2.returnType, new RStringType(), cache);
+
+		const overloadedFuncType1 = new UnresolvedRTypeIntersection(funcType1, funcType2);
+		const overloadedFuncType2 = new UnresolvedRTypeIntersection(funcType1, funcType2);
+
+		// Typing of called function
+		const calledFuncType1 = new UnresolvedRTypeVariable();
+		const calledFuncType2 = new UnresolvedRTypeVariable();
+		constrain(overloadedFuncType1, calledFuncType1, cache);
+		constrain(overloadedFuncType2, calledFuncType2, cache);
+
+		// Typing of function call
+		const argType1 = new UnresolvedRTypeVariable();
+		const argType2 = new UnresolvedRTypeVariable();
+		constrain(new RIntegerType(), argType1, cache);
+		constrain(argType1, new RIntegerType(), cache);
+		constrain(new RStringType(), argType2, cache);
+		constrain(argType2, new RStringType(), cache);
+		const templateFuncType1 = new UnresolvedRFunctionType();
+		templateFuncType1.parameterTypes.set(0, argType1);
+		const returnType1 = templateFuncType1.returnType;
+		const templateFuncType2 = new UnresolvedRFunctionType();
+		templateFuncType2.parameterTypes.set(0, argType2);
+		const returnType2 = templateFuncType2.returnType;
+		constrain(calledFuncType1, templateFuncType1, cache);
+		constrain(calledFuncType2, templateFuncType2, cache);
+
+		resolve(calledFuncType1);
+		resolve(calledFuncType2);
+
+		// console.debug('funcType1', inspect(funcType1, { depth: null, colors: true }));
+		// console.debug('funcType2', inspect(funcType2, { depth: null, colors: true }));
+		// console.debug('overloadedFuncType1', inspect(overloadedFuncType1, { depth: null, colors: true }));
+		// console.debug('overloadedFuncType2', inspect(overloadedFuncType2, { depth: null, colors: true }));
+		// console.debug('calledFuncType1', inspect(calledFuncType1, { depth: null, colors: true }));
+		// console.debug('calledFuncType2', inspect(calledFuncType2, { depth: null, colors: true }));
+		// console.debug('templateFuncType1', inspect(templateFuncType1, { depth: null, colors: true }));
+		// console.debug('templateFuncType2', inspect(templateFuncType2, { depth: null, colors: true }));
+		// console.debug('returnType1', inspect(returnType1, { depth: null, colors: true }));
+		// console.debug('returnType2', inspect(returnType2, { depth: null, colors: true }));
+
+		expect(resolve(returnType1)).toEqual(new RTypeVariable(new RIntegerType(), new RTypeIntersection()));
+		expect(resolve(returnType2)).toEqual(new RTypeVariable(new RStringType(), new RTypeIntersection()));
+	});
+
+	test('Function overloading 2', () => {
 		const cache = new Map<UnresolvedDataType, Set<UnresolvedDataType>>();
 
 		// Predetermined types in context
@@ -116,7 +179,21 @@ describe('Constrain types with lower and upper bounds', () => {
 		constrain(calledFuncType1, templateFuncType1, cache);
 		constrain(calledFuncType2, templateFuncType2, cache);
 
-		expect(resolve(returnType1)).toEqual(new RTypeVariable(new RIntegerType(), new RTypeIntersection()));
+		resolve(calledFuncType1);
+		resolve(calledFuncType2);
+
+		// console.debug('funcType1', inspect(funcType1, { depth: null, colors: true }));
+		// console.debug('funcType2', inspect(funcType2, { depth: null, colors: true }));
+		// console.debug('overloadedFuncType1', inspect(overloadedFuncType1, { depth: null, colors: true }));
+		// console.debug('overloadedFuncType2', inspect(overloadedFuncType2, { depth: null, colors: true }));
+		// console.debug('calledFuncType1', inspect(calledFuncType1, { depth: null, colors: true }));
+		// console.debug('calledFuncType2', inspect(calledFuncType2, { depth: null, colors: true }));
+		// console.debug('templateFuncType1', inspect(templateFuncType1, { depth: null, colors: true }));
+		// console.debug('templateFuncType2', inspect(templateFuncType2, { depth: null, colors: true }));
+		// console.debug('returnType1', inspect(returnType1, { depth: null, colors: true }));
+		// console.debug('returnType2', inspect(returnType2, { depth: null, colors: true }));
+
+		expect(resolve(returnType1)).toEqual(new RTypeVariable(new RDoubleType(), new RTypeIntersection()));
 		expect(resolve(returnType2)).toEqual(new RTypeVariable(new RDoubleType(), new RTypeIntersection()));
 	});
 

From 0289612f8047fdbc87ae3103fd6f6f8a41e8a6b5 Mon Sep 17 00:00:00 2001
From: Lukas Rohde <lukas.rohde@silupe.de>
Date: Thu, 31 Jul 2025 23:26:18 +0200
Subject: [PATCH 113/153] refactor(typing): move tests

---
 .../typing/subtyping/constrain.test.ts        | 204 +++++++++++++++++-
 .../typing/subtyping/resolve.test.ts          | 136 ------------
 .../typing/subtyping/subsumes.test.ts         |  40 ----
 3 files changed, 200 insertions(+), 180 deletions(-)
 delete mode 100644 test/functionality/typing/subtyping/resolve.test.ts
 delete mode 100644 test/functionality/typing/subtyping/subsumes.test.ts

diff --git a/test/functionality/typing/subtyping/constrain.test.ts b/test/functionality/typing/subtyping/constrain.test.ts
index 95b3c603284..db4de901d06 100644
--- a/test/functionality/typing/subtyping/constrain.test.ts
+++ b/test/functionality/typing/subtyping/constrain.test.ts
@@ -1,9 +1,9 @@
 import { describe, expect, test } from 'vitest';
 import type { UnresolvedDataType } from '../../../../src/typing/subtyping/types';
-import { constrain, resolve, UnresolvedRAtomicVectorType, UnresolvedRFunctionType, UnresolvedRListType, UnresolvedRTypeIntersection, UnresolvedRTypeUnion, UnresolvedRTypeVariable } from '../../../../src/typing/subtyping/types';
-import { RIntegerType, RComplexType, RTypeVariable, RDoubleType, RStringType, RListType, RTypeIntersection } from '../../../../src/typing/types';
+import { constrain, meet, resolve, subsumes, UnresolvedRAtomicVectorType, UnresolvedRFunctionType, UnresolvedRListType, UnresolvedRTypeIntersection, UnresolvedRTypeUnion, UnresolvedRTypeVariable } from '../../../../src/typing/subtyping/types';
+import { RIntegerType, RComplexType, RTypeVariable, RDoubleType, RStringType, RListType, RTypeIntersection, RTypeUnion, RNullType, RLanguageType, RLogicalType } from '../../../../src/typing/types';
 
-describe('Constrain types with lower and upper bounds', () => {
+describe('Constrain and resolve types', () => {
 	test('Constrain with numeric bounds', () => {
 		const cache = new Map<UnresolvedDataType, Set<UnresolvedDataType>>();
 
@@ -197,7 +197,7 @@ describe('Constrain types with lower and upper bounds', () => {
 		expect(resolve(returnType2)).toEqual(new RTypeVariable(new RDoubleType(), new RTypeIntersection()));
 	});
 
-	test('Constrain from both sides', () => {
+	test('Constrain from both sides 1', () => {
 		const cache = new Map<UnresolvedDataType, Set<UnresolvedDataType>>();
 
 		const typeVar1 = new UnresolvedRTypeVariable();
@@ -210,4 +210,200 @@ describe('Constrain types with lower and upper bounds', () => {
 		expect(resolve(typeVar1)).toEqual(new RIntegerType());
 		expect(resolve(typeVar2)).toEqual(new RIntegerType());
 	});
+	
+	test.only('Constrain from both sides 2', () => {
+		const cache = new Map<UnresolvedDataType, Set<UnresolvedDataType>>();
+
+		const assignmentTypeVar = new UnresolvedRTypeVariable();
+		const assignedTypeVar = new UnresolvedRTypeVariable();
+		const valueTypeVar = new UnresolvedRTypeVariable();
+
+		// console.debug('Constraining assignedTypeVar <: valueTypeVar');
+		constrain(assignedTypeVar, valueTypeVar, cache);
+		// console.debug('Constraining valueTypeVar <: assignedTypeVar');
+		constrain(valueTypeVar, assignedTypeVar, cache);
+		// console.debug('Constraining assignmentTypeVar <: valueTypeVar');
+		constrain(assignmentTypeVar, valueTypeVar, cache);
+		// console.debug('Constraining valueTypeVar <: assignmentTypeVar');
+		constrain(valueTypeVar, assignmentTypeVar, cache);
+		// console.debug('Constraining assignmentTypeVar <: new RIntegerType()');
+		constrain(new RIntegerType(), valueTypeVar, cache);
+		// console.debug('Constraining valueTypeVar <: new RComplexType()');
+		constrain(valueTypeVar, new RComplexType(), cache);
+
+		// console.dir(assignmentTypeVar, { depth: null, colors: true });
+		// console.dir(assignedTypeVar, { depth: null, colors: true });
+		// console.dir(valueTypeVar, { depth: null, colors: true });
+
+		// console.debug('Resolving assignmentTypeVar');
+		expect(resolve(assignmentTypeVar)).toEqual(new RTypeVariable(new RIntegerType(), new RComplexType()));
+		// console.debug('Resolving assignedTypeVar');
+		expect(resolve(assignedTypeVar)).toEqual(new RTypeVariable(new RIntegerType(), new RComplexType()));
+		// console.debug('Resolving valueTypeVar');
+		expect(resolve(valueTypeVar)).toEqual(new RTypeVariable(new RIntegerType(), new RComplexType()));
+	});
+
+	test('Resolve type with complex constraints 1', () => {
+		const cache = new Map<UnresolvedDataType, Set<UnresolvedDataType>>();
+
+		const typeVar1 = new UnresolvedRTypeVariable();
+		// const typeVar2 = new UnresolvedRTypeVariable();
+		// constrain(typeVar1, typeVar2, cache);
+		// const elementTypeVar = new UnresolvedRTypeVariable();
+		// const typeVar3 = new UnresolvedRTypeVariable();
+		// constrain(elementTypeVar, typeVar3, cache);
+		// const atomicVectorType = new UnresolvedRAtomicVectorType();
+		// const listType1 = new UnresolvedRListType();
+		// const union = new UnresolvedRTypeUnion(atomicVectorType, listType1);
+		// const listType2 = new UnresolvedRListType();
+		constrain(typeVar1, new RStringType(), cache);
+		constrain(typeVar1, new RIntegerType(), cache);
+		const typeVar4 = new UnresolvedRTypeVariable();
+		constrain(typeVar1, typeVar4, cache);
+		// const typeVar5 = new UnresolvedRTypeVariable();
+		constrain(typeVar4, new RNullType(), cache);
+		constrain(typeVar4, new RLanguageType(), cache);
+		// const typeVar6 = new UnresolvedRTypeVariable();
+		// constrain(typeVar5, typeVar6, cache);
+		// const typeVar7 = new UnresolvedRTypeVariable();
+		// constrain(typeVar4, typeVar7, cache);
+
+		expect(resolve(typeVar1)).toEqual(new RTypeVariable(new RTypeUnion(), new RTypeIntersection(new RStringType(), new RIntegerType(), new RNullType(), new RLanguageType())));
+	});
+
+	test('Resolve type with complex constraints 2', () => {
+		const cache = new Map<UnresolvedDataType, Set<UnresolvedDataType>>();
+
+		// 	const typeVar1 = new UnresolvedRTypeVariable(); // ? 5118
+
+		// 	// Subtypes:
+		// 	// const typeVar2 = new UnresolvedRTypeVariable(); // ? 5331
+
+		// 	// const typeVar3 = new UnresolvedRTypeVariable(); // ? 5334
+		// 	// constrain(typeVar2, typeVar3, cache);
+
+		// 	// constrain(typeVar2, typeVar1, cache);
+
+		// 	// Supertypes:
+		// 	const typeVar4 = new UnresolvedRTypeVariable(); // ? 5343
+			
+		// 	const elementTypeVar1 = new UnresolvedRTypeVariable(); // ? 8299
+		// 	// const typeVar5 = new UnresolvedRTypeVariable(); // ? 5352
+		// 	// constrain(elementTypeVar1, typeVar5, cache);
+		// 	const atomicVectorType1 = new UnresolvedRAtomicVectorType(); // ? 8302
+		// 	const listType1 = new UnresolvedRListType(); // ? 8306
+		// 	const union1 = new UnresolvedRTypeUnion(atomicVectorType1, listType1); // ? 8310
+		// 	constrain(typeVar4, union1, cache);
+		// 	const listType2 = new UnresolvedRListType(); // ? 8311
+		// 	constrain(typeVar4, listType2, cache);
+
+		// 	const typeVar6 = new UnresolvedRTypeVariable(); // ? 5358
+
+		// 	const elementTypeVar2 = new UnresolvedRTypeVariable(); // ? 8315
+		// 	// const typeVar7 = new UnresolvedRTypeVariable(); // ? 5367
+		// 	// constrain(elementTypeVar2, typeVar7, cache);
+		// 	const atomicVectorType2 = new UnresolvedRAtomicVectorType(); // ? 8318
+		// 	const listType3 = new UnresolvedRListType(); // ? 8322
+		// 	const union2 = new UnresolvedRTypeUnion(atomicVectorType2, listType3); // ? 8326
+		// 	constrain(typeVar6, union2, cache);
+		// 	const listType4 = new UnresolvedRListType(); // ? 8327
+		// 	constrain(typeVar6, listType4, cache);
+
+		// 	const typeVar8 = new UnresolvedRTypeVariable(); // ? 5451
+
+		// 	const elementTypeVar3 = new UnresolvedRTypeVariable(); // ? 8359
+		// 	// const typeVar9 = new UnresolvedRTypeVariable(); // ? 5460
+		// 	// constrain(elementTypeVar3, typeVar9, cache);
+		// 	const atomicVectorType3 = new UnresolvedRAtomicVectorType(); // ? 8362
+		// 	const listType5 = new UnresolvedRListType(); // ? 8366
+		// 	const union3 = new UnresolvedRTypeUnion(atomicVectorType3, listType5); // ? 8370
+		// 	constrain(typeVar8, union3, cache);
+		// 	const listType6 = new UnresolvedRListType(); // ? 8371
+		// 	constrain(typeVar8, listType6, cache);
+
+		// 	const typeVar10 = new UnresolvedRTypeVariable(); // ? 5466
+
+		// 	const elementTypeVar4 = new UnresolvedRTypeVariable(); // ? 8375
+		// 	// const typeVar11 = new UnresolvedRTypeVariable(); // ? 5475
+		// 	// constrain(elementTypeVar4, typeVar11, cache);
+		// 	const atomicVectorType4 = new UnresolvedRAtomicVectorType(); // ? 8378
+		// 	const listType7 = new UnresolvedRListType(); // ? 8382
+		// 	const union4 = new UnresolvedRTypeUnion(atomicVectorType4, listType7); // ? 8386
+		// 	constrain(typeVar10, union4, cache);
+		// 	const listType8 = new UnresolvedRListType(); // ? 8387
+		// 	constrain(typeVar10, listType8, cache);
+
+		// 	constrain(typeVar1, typeVar4, cache);
+		// 	constrain(typeVar1, typeVar6, cache);
+		// 	constrain(typeVar1, typeVar8, cache);
+		// 	constrain(typeVar1, typeVar10, cache);
+
+		const typeVar1 = new UnresolvedRTypeVariable();
+
+		const typeVar4 = new UnresolvedRTypeVariable();
+		constrain(typeVar4, new RIntegerType(), cache);
+		constrain(typeVar4, new UnresolvedRListType(), cache);
+
+		const typeVar6 = new UnresolvedRTypeVariable();
+		constrain(typeVar6, new RIntegerType(), cache);
+		constrain(typeVar6, new UnresolvedRListType(), cache);
+
+		const typeVar8 = new UnresolvedRTypeVariable();
+		constrain(typeVar8, new RIntegerType(), cache);
+		constrain(typeVar8, new UnresolvedRListType(), cache);
+
+		const typeVar10 = new UnresolvedRTypeVariable();
+		constrain(typeVar10, new RIntegerType(), cache);
+		constrain(typeVar10, new UnresolvedRListType(), cache);
+
+		const typeVar12 = new UnresolvedRTypeVariable();
+		constrain(typeVar12, new RIntegerType(), cache);
+		constrain(typeVar12, new UnresolvedRListType(), cache);
+
+		constrain(typeVar1, typeVar4, cache);
+		constrain(typeVar1, typeVar6, cache);
+		constrain(typeVar1, typeVar8, cache);
+		constrain(typeVar1, typeVar10, cache);
+		constrain(typeVar1, typeVar12, cache);
+
+		expect(resolve(typeVar1)).toEqual(new RTypeVariable(new RTypeUnion(), new RTypeIntersection(new RIntegerType(), new RListType(new RTypeVariable()))));
+	});
+
+	test('Calculate meet with intersections', () => {
+		expect(meet(new RTypeIntersection(new RIntegerType(), new RListType(new RNullType())), new RTypeIntersection(new RIntegerType(), new RListType(new RNullType())))).toEqual(new RTypeIntersection(new RIntegerType(), new RListType(new RNullType())));
+	});
+
+	test('Test subsumption of types with nested variables', () => {
+		const cache = new Map<UnresolvedDataType, Set<UnresolvedDataType>>();
+
+		const logicalType = new RLogicalType();
+		const integerType = new RIntegerType();
+		const nullType = new RNullType();
+
+		const typeVar1 = new UnresolvedRTypeVariable();
+		// eslint-disable-next-line @typescript-eslint/naming-convention
+		const typeVar1_1 = new UnresolvedRTypeVariable();
+		// eslint-disable-next-line @typescript-eslint/naming-convention
+		const typeVar1_2 = new UnresolvedRTypeVariable();
+		constrain(logicalType, typeVar1, cache);
+		constrain(logicalType, typeVar1_1, cache);
+		constrain(logicalType, typeVar1_2, cache);
+		constrain(integerType, typeVar1, cache);
+		constrain(integerType, typeVar1_1, cache);
+		constrain(integerType, typeVar1_2, cache);
+		constrain(nullType, typeVar1, cache);
+		constrain(nullType, typeVar1_1, cache);
+		constrain(nullType, typeVar1_2, cache);
+		constrain(typeVar1, typeVar1_1, cache);
+		constrain(typeVar1_1, typeVar1_2, cache);
+
+		const typeVar2 = new UnresolvedRTypeVariable();
+		constrain(logicalType, typeVar2, cache);
+		constrain(integerType, typeVar2, cache);
+		constrain(nullType, typeVar2, cache);
+		constrain(typeVar2, typeVar1, cache);
+
+		expect(subsumes(typeVar2, typeVar1)).toBe(true);
+		expect(subsumes(typeVar1, typeVar2)).toBe(true);
+	});
 });
\ No newline at end of file
diff --git a/test/functionality/typing/subtyping/resolve.test.ts b/test/functionality/typing/subtyping/resolve.test.ts
deleted file mode 100644
index 90a3f77f243..00000000000
--- a/test/functionality/typing/subtyping/resolve.test.ts
+++ /dev/null
@@ -1,136 +0,0 @@
-import { describe, expect, test } from 'vitest';
-import type { UnresolvedDataType } from '../../../../src/typing/subtyping/types';
-import { constrain, meet, resolve, UnresolvedRListType, UnresolvedRTypeVariable } from '../../../../src/typing/subtyping/types';
-import { RIntegerType, RTypeVariable, RListType, RTypeIntersection, RNullType, RStringType, RLanguageType, RTypeUnion } from '../../../../src/typing/types';
-
-describe('Resolve constrained types', () => {
-	test('Resolve type with complex constraints 1', () => {
-		const cache = new Map<UnresolvedDataType, Set<UnresolvedDataType>>();
-
-		const typeVar1 = new UnresolvedRTypeVariable();
-		// const typeVar2 = new UnresolvedRTypeVariable();
-		// constrain(typeVar1, typeVar2, cache);
-		// const elementTypeVar = new UnresolvedRTypeVariable();
-		// const typeVar3 = new UnresolvedRTypeVariable();
-		// constrain(elementTypeVar, typeVar3, cache);
-		// const atomicVectorType = new UnresolvedRAtomicVectorType();
-		// const listType1 = new UnresolvedRListType();
-		// const union = new UnresolvedRTypeUnion(atomicVectorType, listType1);
-		// const listType2 = new UnresolvedRListType();
-		constrain(typeVar1, new RStringType(), cache);
-		constrain(typeVar1, new RIntegerType(), cache);
-		const typeVar4 = new UnresolvedRTypeVariable();
-		constrain(typeVar1, typeVar4, cache);
-		// const typeVar5 = new UnresolvedRTypeVariable();
-		constrain(typeVar4, new RNullType(), cache);
-		constrain(typeVar4, new RLanguageType(), cache);
-		// const typeVar6 = new UnresolvedRTypeVariable();
-		// constrain(typeVar5, typeVar6, cache);
-		// const typeVar7 = new UnresolvedRTypeVariable();
-		// constrain(typeVar4, typeVar7, cache);
-
-		expect(resolve(typeVar1)).toEqual(new RTypeVariable(new RTypeUnion(), new RTypeIntersection(new RStringType(), new RIntegerType(), new RNullType(), new RLanguageType())));
-	});
-
-	test('Resolve type with complex constraints 2', () => {
-		const cache = new Map<UnresolvedDataType, Set<UnresolvedDataType>>();
-
-		// 	const typeVar1 = new UnresolvedRTypeVariable(); // ? 5118
-
-		// 	// Subtypes:
-		// 	// const typeVar2 = new UnresolvedRTypeVariable(); // ? 5331
-
-		// 	// const typeVar3 = new UnresolvedRTypeVariable(); // ? 5334
-		// 	// constrain(typeVar2, typeVar3, cache);
-
-		// 	// constrain(typeVar2, typeVar1, cache);
-
-		// 	// Supertypes:
-		// 	const typeVar4 = new UnresolvedRTypeVariable(); // ? 5343
-			
-		// 	const elementTypeVar1 = new UnresolvedRTypeVariable(); // ? 8299
-		// 	// const typeVar5 = new UnresolvedRTypeVariable(); // ? 5352
-		// 	// constrain(elementTypeVar1, typeVar5, cache);
-		// 	const atomicVectorType1 = new UnresolvedRAtomicVectorType(); // ? 8302
-		// 	const listType1 = new UnresolvedRListType(); // ? 8306
-		// 	const union1 = new UnresolvedRTypeUnion(atomicVectorType1, listType1); // ? 8310
-		// 	constrain(typeVar4, union1, cache);
-		// 	const listType2 = new UnresolvedRListType(); // ? 8311
-		// 	constrain(typeVar4, listType2, cache);
-
-		// 	const typeVar6 = new UnresolvedRTypeVariable(); // ? 5358
-
-		// 	const elementTypeVar2 = new UnresolvedRTypeVariable(); // ? 8315
-		// 	// const typeVar7 = new UnresolvedRTypeVariable(); // ? 5367
-		// 	// constrain(elementTypeVar2, typeVar7, cache);
-		// 	const atomicVectorType2 = new UnresolvedRAtomicVectorType(); // ? 8318
-		// 	const listType3 = new UnresolvedRListType(); // ? 8322
-		// 	const union2 = new UnresolvedRTypeUnion(atomicVectorType2, listType3); // ? 8326
-		// 	constrain(typeVar6, union2, cache);
-		// 	const listType4 = new UnresolvedRListType(); // ? 8327
-		// 	constrain(typeVar6, listType4, cache);
-
-		// 	const typeVar8 = new UnresolvedRTypeVariable(); // ? 5451
-
-		// 	const elementTypeVar3 = new UnresolvedRTypeVariable(); // ? 8359
-		// 	// const typeVar9 = new UnresolvedRTypeVariable(); // ? 5460
-		// 	// constrain(elementTypeVar3, typeVar9, cache);
-		// 	const atomicVectorType3 = new UnresolvedRAtomicVectorType(); // ? 8362
-		// 	const listType5 = new UnresolvedRListType(); // ? 8366
-		// 	const union3 = new UnresolvedRTypeUnion(atomicVectorType3, listType5); // ? 8370
-		// 	constrain(typeVar8, union3, cache);
-		// 	const listType6 = new UnresolvedRListType(); // ? 8371
-		// 	constrain(typeVar8, listType6, cache);
-
-		// 	const typeVar10 = new UnresolvedRTypeVariable(); // ? 5466
-
-		// 	const elementTypeVar4 = new UnresolvedRTypeVariable(); // ? 8375
-		// 	// const typeVar11 = new UnresolvedRTypeVariable(); // ? 5475
-		// 	// constrain(elementTypeVar4, typeVar11, cache);
-		// 	const atomicVectorType4 = new UnresolvedRAtomicVectorType(); // ? 8378
-		// 	const listType7 = new UnresolvedRListType(); // ? 8382
-		// 	const union4 = new UnresolvedRTypeUnion(atomicVectorType4, listType7); // ? 8386
-		// 	constrain(typeVar10, union4, cache);
-		// 	const listType8 = new UnresolvedRListType(); // ? 8387
-		// 	constrain(typeVar10, listType8, cache);
-
-		// 	constrain(typeVar1, typeVar4, cache);
-		// 	constrain(typeVar1, typeVar6, cache);
-		// 	constrain(typeVar1, typeVar8, cache);
-		// 	constrain(typeVar1, typeVar10, cache);
-
-		const typeVar1 = new UnresolvedRTypeVariable();
-
-		const typeVar4 = new UnresolvedRTypeVariable();
-		constrain(typeVar4, new RIntegerType(), cache);
-		constrain(typeVar4, new UnresolvedRListType(), cache);
-
-		const typeVar6 = new UnresolvedRTypeVariable();
-		constrain(typeVar6, new RIntegerType(), cache);
-		constrain(typeVar6, new UnresolvedRListType(), cache);
-
-		const typeVar8 = new UnresolvedRTypeVariable();
-		constrain(typeVar8, new RIntegerType(), cache);
-		constrain(typeVar8, new UnresolvedRListType(), cache);
-
-		const typeVar10 = new UnresolvedRTypeVariable();
-		constrain(typeVar10, new RIntegerType(), cache);
-		constrain(typeVar10, new UnresolvedRListType(), cache);
-
-		const typeVar12 = new UnresolvedRTypeVariable();
-		constrain(typeVar12, new RIntegerType(), cache);
-		constrain(typeVar12, new UnresolvedRListType(), cache);
-
-		constrain(typeVar1, typeVar4, cache);
-		constrain(typeVar1, typeVar6, cache);
-		constrain(typeVar1, typeVar8, cache);
-		constrain(typeVar1, typeVar10, cache);
-		constrain(typeVar1, typeVar12, cache);
-
-		expect(resolve(typeVar1)).toEqual(new RTypeVariable(new RTypeUnion(), new RTypeIntersection(new RIntegerType(), new RListType(new RTypeVariable()))));
-	});
-
-	test('Calculate meet with intersections', () => {
-		expect(meet(new RTypeIntersection(new RIntegerType(), new RListType(new RNullType())), new RTypeIntersection(new RIntegerType(), new RListType(new RNullType())))).toEqual(new RTypeIntersection(new RIntegerType(), new RListType(new RNullType())));
-	});
-});
\ No newline at end of file
diff --git a/test/functionality/typing/subtyping/subsumes.test.ts b/test/functionality/typing/subtyping/subsumes.test.ts
deleted file mode 100644
index 0d0c2b818fa..00000000000
--- a/test/functionality/typing/subtyping/subsumes.test.ts
+++ /dev/null
@@ -1,40 +0,0 @@
-import { describe, expect, test } from 'vitest';
-import type { UnresolvedDataType } from '../../../../src/typing/subtyping/types';
-import { constrain, subsumes, UnresolvedRTypeVariable } from '../../../../src/typing/subtyping/types';
-import { RIntegerType, RNullType, RLogicalType } from '../../../../src/typing/types';
-
-describe('Test subsumption of types', () => {
-	test('Test subsumption of types with nested variables', () => {
-		const cache = new Map<UnresolvedDataType, Set<UnresolvedDataType>>();
-
-		const logicalType = new RLogicalType();
-		const integerType = new RIntegerType();
-		const nullType = new RNullType();
-
-		const typeVar1 = new UnresolvedRTypeVariable();
-		// eslint-disable-next-line @typescript-eslint/naming-convention
-		const typeVar1_1 = new UnresolvedRTypeVariable();
-		// eslint-disable-next-line @typescript-eslint/naming-convention
-		const typeVar1_2 = new UnresolvedRTypeVariable();
-		constrain(logicalType, typeVar1, cache);
-		constrain(logicalType, typeVar1_1, cache);
-		constrain(logicalType, typeVar1_2, cache);
-		constrain(integerType, typeVar1, cache);
-		constrain(integerType, typeVar1_1, cache);
-		constrain(integerType, typeVar1_2, cache);
-		constrain(nullType, typeVar1, cache);
-		constrain(nullType, typeVar1_1, cache);
-		constrain(nullType, typeVar1_2, cache);
-		constrain(typeVar1, typeVar1_1, cache);
-		constrain(typeVar1_1, typeVar1_2, cache);
-
-		const typeVar2 = new UnresolvedRTypeVariable();
-		constrain(logicalType, typeVar2, cache);
-		constrain(integerType, typeVar2, cache);
-		constrain(nullType, typeVar2, cache);
-		constrain(typeVar2, typeVar1, cache);
-
-		expect(subsumes(typeVar2, typeVar1)).toBe(true);
-		expect(subsumes(typeVar1, typeVar2)).toBe(true);
-	});
-});
\ No newline at end of file

From 2edd831f8c40f326170c2d33577a0e47b80fdf61 Mon Sep 17 00:00:00 2001
From: Lukas Rohde <lukas.rohde@silupe.de>
Date: Thu, 31 Jul 2025 23:31:48 +0200
Subject: [PATCH 114/153] feat-fix(typing): fix resolving of recursive types
 and meets/joins

---
 src/typing/subtyping/types.ts | 169 ++++++++++++++++++++--------------
 1 file changed, 101 insertions(+), 68 deletions(-)

diff --git a/src/typing/subtyping/types.ts b/src/typing/subtyping/types.ts
index be522923505..a060ce89d72 100644
--- a/src/typing/subtyping/types.ts
+++ b/src/typing/subtyping/types.ts
@@ -103,7 +103,7 @@ export class UnresolvedRTypeVariable {
 
 
 export function constrain(subtype: UnresolvedDataType, supertype: UnresolvedDataType, cache: Map<UnresolvedDataType, Set<UnresolvedDataType>> = new Map()): void {
-	// console.debug('constraining', type, 'with upper bound', bound);
+	// console.debug('Constraining', inspect(subtype, { depth: null, colors: true }), 'to subsume', inspect(supertype, { depth: null, colors: true }));
 
 	if(subtype === supertype) {
 		return; // No need to constrain if both types are the same
@@ -155,6 +155,8 @@ export function constrain(subtype: UnresolvedDataType, supertype: UnresolvedData
 
 
 export function prune(variable: UnresolvedRTypeVariable, inProcess: Set<UnresolvedRTypeVariable | Set<UnresolvedDataType>> = new Set()): void {
+	// console.debug('Pruning variable', inspect(variable, { depth: null, colors: true }));
+	
 	inProcess.add(variable);
 
 	function pruneLowerBounds(lowerBounds: Set<UnresolvedDataType>): Set<UnresolvedDataType> {
@@ -163,15 +165,15 @@ export function prune(variable: UnresolvedRTypeVariable, inProcess: Set<Unresolv
 		const prunedBounds = new Set(lowerBounds.values().flatMap(lowerBound => {
 			if(lowerBound instanceof UnresolvedRTypeVariable) {
 				// If the lower bound is a type variable, we only care about its lower bound
-				if(inProcess.has(lowerBound) || inProcess.has(lowerBound.lowerBound.types)) {
-					return []; // If the variable is already in process, we skip it to avoid infinite recursion
+				if(!inProcess.has(lowerBound) && !inProcess.has(lowerBound.lowerBound.types)) {
+					prune(lowerBound, inProcess); // Prune the variable recursively w.r.t. its own bounds
+					lowerBound.lowerBound.types = pruneLowerBounds(lowerBound.lowerBound.types);
 				}
-				prune(lowerBound, inProcess); // Prune the variable recursively w.r.t. its own bounds
-				lowerBound.lowerBound.types = pruneLowerBounds(lowerBound.lowerBound.types);
 				return [lowerBound];
 			} else if(lowerBound instanceof UnresolvedRTypeUnion) {
 				// If the lower bound is a union, we prune and include its types directly
 				if(inProcess.has(lowerBound.types)) {
+					// console.debug('Skipping already processed union', inspect(lowerBound, { depth: null, colors: true }));
 					return []; // If the union is already in process, we skip it to avoid infinite recursion
 				}
 				return pruneLowerBounds(lowerBound.types);
@@ -208,15 +210,15 @@ export function prune(variable: UnresolvedRTypeVariable, inProcess: Set<Unresolv
 		const prunedBounds = new Set(upperBounds.values().flatMap(upperBound => {
 			if(upperBound instanceof UnresolvedRTypeVariable) {
 				// If the upper bound is a type variable, we only care about its upper bound
-				if(inProcess.has(upperBound) || inProcess.has(upperBound.upperBound.types)) {
-					return []; // If the variable is already in process, we skip it to avoid infinite recursion
+				if(!inProcess.has(upperBound) && !inProcess.has(upperBound.upperBound.types)) {
+					prune(upperBound, inProcess); // Prune the variable recursively w.r.t. its own bounds
+					upperBound.upperBound.types = pruneUpperBounds(upperBound.upperBound.types);
 				}
-				prune(upperBound, inProcess); // Prune the variable recursively w.r.t. its own bounds
-				upperBound.upperBound.types = pruneUpperBounds(upperBound.upperBound.types);
 				return [upperBound];
 			} else if(upperBound instanceof UnresolvedRTypeIntersection) {
 				// If the upper bound is an intersection, we prune and include its types directly
 				if(inProcess.has(upperBound.types)) {
+					// console.debug('Skipping already processed intersection', inspect(upperBound, { depth: null, colors: true }));
 					return []; // If the intersection is already in process, we skip it to avoid infinite recursion
 				}
 				return pruneUpperBounds(upperBound.types);
@@ -255,93 +257,124 @@ export function prune(variable: UnresolvedRTypeVariable, inProcess: Set<Unresolv
 }
 
 
-export function resolve(type: UnresolvedDataType, cache: Map<UnresolvedDataType, DataType> = new Map()): DataType {
-	const cachedType = cache.get(type);
-	if(cachedType !== undefined) {
-		return cachedType;
-	}
+export function resolve(type: UnresolvedDataType, isUpperBound?: boolean, cache: Map<UnresolvedRTypeVariable, { lowerBound: DataType, upperBound: DataType, combined: DataType }> = new Map()): DataType {
+	// console.debug('Resolving type', inspect(type, { depth: null, colors: true }));
 
 	if(type instanceof UnresolvedRTypeVariable) {
-		cache.set(type, new RTypeVariable()); // Prevent infinite recursion
+		const cachedType = cache.get(type);
+		if(cachedType !== undefined) {
+			switch(isUpperBound) {
+				case true:
+					return cachedType.upperBound;
+				case false:
+					return cachedType.lowerBound;
+				default:
+					return cachedType.combined;
+			}
+		}
+		cache.set(type, { lowerBound: new RTypeUnion(), upperBound: new RTypeIntersection(), combined: new RTypeVariable() }); // Prevent infinite recursion
 
 		prune(type); // Prune the variable to remove unnecessary bounds
 
-		const lowerBound = resolve(type.lowerBound, cache);
-		const upperBound = resolve(type.upperBound, cache);
+		const lowerBound = resolve(type.lowerBound, false, cache);
+		const upperBound = resolve(type.upperBound, true, cache);
 
 		if(!subsumes(lowerBound, upperBound)) {
 			const errorType = new RTypeError(lowerBound, upperBound);
-			cache.set(type, errorType);
+			cache.set(type, { lowerBound: errorType, upperBound: errorType, combined: errorType });
 			return errorType;
 		}
-		
-		if(subsumes(lowerBound, upperBound) && subsumes(upperBound, lowerBound)) {
-			cache.set(type, lowerBound);
-			return lowerBound; // If both bounds are equal, return one of them
+
+		const combined = combine(lowerBound, upperBound);
+		cache.set(type, { lowerBound, upperBound, combined });
+
+		switch(isUpperBound) {
+			case true:
+				return upperBound;
+			case false:
+				return lowerBound;
+			default:
+				return combined;
 		}
-		
-		const resolvedType = new RTypeVariable(
-			lowerBound instanceof RTypeVariable ? lowerBound.lowerBound : lowerBound,
-			upperBound instanceof RTypeVariable ? upperBound.upperBound : upperBound
-		);
-		cache.set(type, resolvedType);
-		return resolvedType;
 	} else if(type instanceof UnresolvedRTypeUnion) {
-		cache.set(type, new RTypeUnion()); // Prevent infinite recursion
-
 		let resolvedType: DataType = new RTypeUnion();
 		for(const subtype of type.types) {
-			const resolvedSubtype = resolve(subtype, cache);
+			const resolvedSubtype = resolve(subtype, isUpperBound, cache);
 			resolvedType = join(resolvedType, resolvedSubtype);
 		}
-		
-		cache.set(type, resolvedType);
 		return resolvedType;
 	} else if(type instanceof UnresolvedRTypeIntersection) {
-		cache.set(type, new RTypeIntersection()); // Prevent infinite recursion
-
 		let resolvedType: DataType = new RTypeIntersection();
 		for(const subtype of type.types) {
-			const resolvedSubtype = resolve(subtype, cache);
+			const resolvedSubtype = resolve(subtype, isUpperBound, cache);
 			resolvedType = meet(resolvedType, resolvedSubtype);
 		}
-		
-		cache.set(type, resolvedType);
 		return resolvedType;
 	} else if(type instanceof UnresolvedRFunctionType) {
 		type.parameterTypes.values().forEach(paramType => prune(paramType));
 		prune(type.returnType);
 
-		const resolvedParameterTypes = new Map(type.parameterTypes.entries().toArray().map(([key, type]) => [key, resolve(type, cache)]));
-		const resolvedReturnType = resolve(type.returnType, cache);
+		const resolvedParameterTypes = new Map(type.parameterTypes.entries().toArray().map(([key, type]) => {
+			return [key, resolve(type, isUpperBound !== undefined ? !isUpperBound : undefined, cache)];
+		}));
+		const resolvedReturnType = resolve(type.returnType, isUpperBound, cache);
 		const resolvedType = new RFunctionType(resolvedParameterTypes, resolvedReturnType);
 		
-		cache.set(type, resolvedType);
 		return resolvedType;
 	} else if(type instanceof UnresolvedRAtomicVectorType) {
 		prune(type.elementType);
 
-		const resolvedElementType = resolve(type.elementType, cache);
+		const resolvedElementType = resolve(type.elementType, isUpperBound, cache);
 		const resolvedType = new RAtomicVectorType(resolvedElementType);
 		
-		cache.set(type, resolvedType);
 		return resolvedType;
 	} else if(type instanceof UnresolvedRListType) {
 		type.indexedElementTypes.values().forEach(elementType => prune(elementType));
 		prune(type.elementType);
 
-		const resolvedElementType = resolve(type.elementType, cache);
-		const resolvedIndexedElementTypes = new Map(type.indexedElementTypes.entries().map(([indexOrName, elementType]) => [indexOrName, resolve(elementType, cache)]));
+		const resolvedElementType = resolve(type.elementType, isUpperBound, cache);
+		const resolvedIndexedElementTypes = new Map(type.indexedElementTypes.entries().map(([indexOrName, elementType]) => [indexOrName, resolve(elementType, isUpperBound, cache)]));
 		const resolvedType = new RListType(resolvedElementType, resolvedIndexedElementTypes);
 		
-		cache.set(type, resolvedType);
 		return resolvedType;
 	} else {
-		cache.set(type, type);
 		return type;
 	}
 }
 
+export function combine(lowerBound: DataType, upperBound: DataType): DataType {
+	if(lowerBound instanceof RFunctionType && upperBound instanceof RFunctionType) {
+		const parameterTypes = new Map<number | string, DataType>();
+		const keys1 = new Set(lowerBound.parameterTypes.keys());
+		const keys2 = new Set(upperBound.parameterTypes.keys());
+		for(const key of keys1.union(keys2)) {
+			const lowerBoundParameterType = lowerBound.parameterTypes.get(key) ?? new RTypeIntersection();
+			const upperBoundParameterType = upperBound.parameterTypes.get(key) ?? new RTypeUnion();
+			parameterTypes.set(key, combine(upperBoundParameterType, lowerBoundParameterType));
+		}
+		const returnType = combine(lowerBound.returnType, upperBound.returnType);
+		return new RFunctionType(parameterTypes, returnType);
+	} else if(lowerBound instanceof RListType && upperBound instanceof RListType) {
+		const elementType = combine(lowerBound.elementType, upperBound.elementType);
+		const indexedElementTypes = new Map<number | string, DataType>();
+		const keys1 = new Set(lowerBound.indexedElementTypes.keys());
+		const keys2 = new Set(upperBound.indexedElementTypes.keys());
+		for(const key of keys1.union(keys2)) {
+			const lowerBoundElementType = lowerBound.indexedElementTypes.get(key) ?? new RTypeUnion();
+			const upperBoundElementType = upperBound.indexedElementTypes.get(key) ?? new RTypeIntersection();
+			indexedElementTypes.set(key, combine(lowerBoundElementType, upperBoundElementType));
+		}
+		return new RListType(elementType, indexedElementTypes);
+	} else if(lowerBound instanceof RAtomicVectorType && upperBound instanceof RAtomicVectorType) {
+		const elementType = combine(lowerBound.elementType, upperBound.elementType);
+		return new RAtomicVectorType(elementType);
+	} else if(subsumesByTag(lowerBound.tag, upperBound.tag) && subsumesByTag(upperBound.tag, lowerBound.tag)) {
+		return lowerBound; // If both types are the same, we return the upper bound
+	} else {
+		return new RTypeVariable(lowerBound, upperBound); // If the types are not compatible, we create a new variable type that combines both bounds 
+	}
+}
+
 export function subsumes(subtype: DataType | UnresolvedDataType, supertype: DataType | UnresolvedDataType, inProcess: Map<DataType | UnresolvedDataType, Set<DataType | UnresolvedDataType>> = new Map()): boolean {
 	// console.debug('Checking if', inspect(subtype, { depth: null, colors: true }), 'subsumes', inspect(supertype, { depth: null, colors: true }));
 
@@ -415,9 +448,9 @@ export function unresolvedJoin(type1: UnresolvedDataType, type2: UnresolvedDataT
 	} else if(type2 instanceof RTypeError) {
 		return type2;
 	} else if(type1 instanceof UnresolvedRTypeVariable) {
-		return unresolvedJoin(type1.lowerBound, type2);
+		return unresolvedJoin(type1.upperBound, type2);
 	} else if(type2 instanceof UnresolvedRTypeVariable) {
-		return unresolvedJoin(type1, type2.lowerBound);
+		return unresolvedJoin(type1, type2.upperBound);
 	} else if(type1 instanceof UnresolvedRTypeUnion) {
 		if(type1.types.size === 0) {
 			return type2; // If type1 is an empty union, return type2
@@ -453,8 +486,8 @@ export function unresolvedJoin(type1: UnresolvedDataType, type2: UnresolvedDataT
 		const keys1 = new Set(type1.parameterTypes.keys());
 		const keys2 = new Set(type2.parameterTypes.keys());
 		for(const key of keys1.union(keys2)) {
-			const parameterType1 = type1.parameterTypes.get(key) ?? new UnresolvedRTypeUnion();
-			const parameterType2 = type2.parameterTypes.get(key) ?? new UnresolvedRTypeUnion();
+			const parameterType1 = type1.parameterTypes.get(key) ?? new UnresolvedRTypeIntersection();
+			const parameterType2 = type2.parameterTypes.get(key) ?? new UnresolvedRTypeIntersection();
 			const metParameterType = unresolvedMeet(parameterType1, parameterType2);
 			const parameterType = new UnresolvedRTypeVariable();
 			constrain(metParameterType, parameterType);
@@ -517,9 +550,9 @@ export function join(type1: DataType, type2: DataType): DataType {
 	} else if(type2 instanceof RTypeError) {
 		return type2;
 	} else if(type1 instanceof RTypeVariable) {
-		return join(type1.lowerBound, type2);
+		return new RTypeVariable(join(type1.lowerBound, type2), join(type1.upperBound, type2));
 	} else if(type2 instanceof RTypeVariable) {
-		return join(type1, type2.lowerBound);
+		return new RTypeVariable(join(type1, type2.lowerBound), join(type1, type2.upperBound));
 	} else if(type1 instanceof RTypeUnion) {
 		if(type1.types.size === 0) {
 			return type2; // If type1 is an empty union, return type2
@@ -555,8 +588,8 @@ export function join(type1: DataType, type2: DataType): DataType {
 		const keys1 = new Set(type1.parameterTypes.keys());
 		const keys2 = new Set(type2.parameterTypes.keys());
 		for(const key of keys1.union(keys2)) {
-			const parameterType1 = type1.parameterTypes.get(key) ?? new RTypeUnion();
-			const parameterType2 = type2.parameterTypes.get(key) ?? new RTypeUnion();
+			const parameterType1 = type1.parameterTypes.get(key) ?? new RTypeIntersection();
+			const parameterType2 = type2.parameterTypes.get(key) ?? new RTypeIntersection();
 			parameterTypes.set(key, meet(parameterType1, parameterType2));
 		}
 		const returnType = join(type1.returnType, type2.returnType);
@@ -566,8 +599,8 @@ export function join(type1: DataType, type2: DataType): DataType {
 		const keys1 = new Set(type1.indexedElementTypes.keys());
 		const keys2 = new Set(type2.indexedElementTypes.keys());
 		for(const key of keys1.intersection(keys2)) {
-			const elementType1 = type1.indexedElementTypes.get(key) ?? new RTypeIntersection();
-			const elementType2 = type2.indexedElementTypes.get(key) ?? new RTypeIntersection();
+			const elementType1 = type1.indexedElementTypes.get(key) ?? new RTypeUnion();
+			const elementType2 = type2.indexedElementTypes.get(key) ?? new RTypeUnion();
 			indexedElementTypes.set(key, join(elementType1, elementType2));
 		}
 		return new RListType(join(type1.elementType, type2.elementType), indexedElementTypes);
@@ -593,9 +626,9 @@ export function unresolvedMeet(type1: UnresolvedDataType, type2: UnresolvedDataT
 	} else if(type2 instanceof RTypeError) {
 		return type2;
 	} else if(type1 instanceof UnresolvedRTypeVariable) {
-		return unresolvedMeet(type1.upperBound, type2);
+		return unresolvedMeet(type1.lowerBound, type2);
 	} else if(type2 instanceof UnresolvedRTypeVariable) {
-		return unresolvedMeet(type1, type2.upperBound);
+		return unresolvedMeet(type1, type2.lowerBound);
 	} else if(type1 instanceof UnresolvedRTypeIntersection) {
 		if(type1.types.size === 0) {
 			return type2; // If type1 is an empty intersection, return type2
@@ -631,8 +664,8 @@ export function unresolvedMeet(type1: UnresolvedDataType, type2: UnresolvedDataT
 		const keys1 = new Set(type1.parameterTypes.keys());
 		const keys2 = new Set(type2.parameterTypes.keys());
 		for(const key of keys1.intersection(keys2)) {
-			const parameterType1 = type1.parameterTypes.get(key) ?? new UnresolvedRTypeIntersection();
-			const parameterType2 = type2.parameterTypes.get(key) ?? new UnresolvedRTypeIntersection();
+			const parameterType1 = type1.parameterTypes.get(key) ?? new UnresolvedRTypeUnion();
+			const parameterType2 = type2.parameterTypes.get(key) ?? new UnresolvedRTypeUnion();
 			const joinedParameterType = unresolvedJoin(parameterType1, parameterType2);
 			const parameterType = new UnresolvedRTypeVariable();
 			constrain(parameterType, joinedParameterType);
@@ -687,9 +720,9 @@ export function meet(type1: DataType, type2: DataType): DataType {
 	} else if(type2 instanceof RTypeError) {
 		return type2;
 	} else if(type1 instanceof RTypeVariable) {
-		return meet(type1.upperBound, type2);
+		return new RTypeVariable(meet(type1.lowerBound, type2), meet(type1.upperBound, type2));
 	} else if(type2 instanceof RTypeVariable) {
-		return meet(type1, type2.upperBound);
+		return new RTypeVariable(meet(type1, type2.lowerBound), meet(type1, type2.upperBound));
 	} else if(type1 instanceof RTypeIntersection) {
 		if(type1.types.size === 0) {
 			return type2; // If type1 is an empty intersection, return type2
@@ -725,8 +758,8 @@ export function meet(type1: DataType, type2: DataType): DataType {
 		const keys1 = new Set(type1.parameterTypes.keys());
 		const keys2 = new Set(type2.parameterTypes.keys());
 		for(const key of keys1.intersection(keys2)) {
-			const parameterType1 = type1.parameterTypes.get(key) ?? new RTypeIntersection();
-			const parameterType2 = type2.parameterTypes.get(key) ?? new RTypeIntersection();
+			const parameterType1 = type1.parameterTypes.get(key) ?? new RTypeUnion();
+			const parameterType2 = type2.parameterTypes.get(key) ?? new RTypeUnion();
 			parameterTypes.set(key, join(parameterType1, parameterType2));
 		}
 		const returnType = meet(type1.returnType, type2.returnType);
@@ -736,8 +769,8 @@ export function meet(type1: DataType, type2: DataType): DataType {
 		const keys1 = new Set(type1.indexedElementTypes.keys());
 		const keys2 = new Set(type2.indexedElementTypes.keys());
 		for(const key of keys1.union(keys2)) {
-			const elementType1 = type1.indexedElementTypes.get(key) ?? new RTypeUnion();
-			const elementType2 = type2.indexedElementTypes.get(key) ?? new RTypeUnion();
+			const elementType1 = type1.indexedElementTypes.get(key) ?? new RTypeIntersection();
+			const elementType2 = type2.indexedElementTypes.get(key) ?? new RTypeIntersection();
 			indexedElementTypes.set(key, meet(elementType1, elementType2));
 		}
 		return new RListType(meet(type1.elementType, type2.elementType), indexedElementTypes);

From c99d30790775e158243bfeedf1e38f02bc2c6349 Mon Sep 17 00:00:00 2001
From: Lukas Rohde <lukas.rohde@silupe.de>
Date: Thu, 31 Jul 2025 23:32:18 +0200
Subject: [PATCH 115/153] test-fix(typing): update tests

---
 .../typing/subtyping/builtin-functions.test.ts         |  8 ++++----
 test/functionality/typing/subtyping/subsetting.test.ts |  8 ++++----
 test/functionality/typing/subtyping/variables.test.ts  | 10 +++++-----
 3 files changed, 13 insertions(+), 13 deletions(-)

diff --git a/test/functionality/typing/subtyping/builtin-functions.test.ts b/test/functionality/typing/subtyping/builtin-functions.test.ts
index b6521e7e2bf..554dfc1ed6e 100644
--- a/test/functionality/typing/subtyping/builtin-functions.test.ts
+++ b/test/functionality/typing/subtyping/builtin-functions.test.ts
@@ -1,5 +1,5 @@
 import { describe } from 'vitest';
-import { RTypeIntersection, RIntegerType, RLanguageType, RListType, RLogicalType, RTypeUnion, RNullType, RStringType, RTypeVariable, RAtomicVectorType } from '../../../../src/typing/types';
+import { RTypeIntersection, RIntegerType, RLanguageType, RListType, RLogicalType, RNullType, RStringType, RTypeVariable, RAtomicVectorType, RComplexType } from '../../../../src/typing/types';
 import { assertInferredType, assertInferredTypes } from '../../_helper/typing/subtyping/assert-inferred-type';
 import { Q } from '../../../../src/search/flowr-search-builder';
 
@@ -8,14 +8,14 @@ describe('Infer types for builtin functions', () => {
 
 	assertInferredTypes(
 		'x <- 42\nget("x")',
-		{ query: Q.criterion('1@x').build(),   lowerBound: new RIntegerType() },
-		{ query: Q.criterion('2@get').build(), lowerBound: new RIntegerType() },
+		{ query: Q.criterion('1@x').build(),   lowerBound: new RIntegerType(), upperBound: new RComplexType() },
+		{ query: Q.criterion('2@get').build(), lowerBound: new RIntegerType(), upperBound: new RComplexType() },
 		{ query: Q.criterion('2@"x"').build(), upperBound: new RStringType() }
 	);
 
 	assertInferredTypes(
 		'eval(quote(TRUE))',
-		{ query: Q.criterion('1@eval').build(),  lowerBound: new RTypeUnion(), upperBound: new RTypeIntersection() },
+		{ query: Q.criterion('1@eval').build(),  expectedType: new RTypeVariable() },
 		{ query: Q.criterion('1@quote').build(), expectedType: new RLanguageType() },
 		{ query: Q.criterion('1@TRUE').build(),  expectedType: new RLogicalType() }
 	);
diff --git a/test/functionality/typing/subtyping/subsetting.test.ts b/test/functionality/typing/subtyping/subsetting.test.ts
index 44fa1adfd6b..279fce55a9a 100644
--- a/test/functionality/typing/subtyping/subsetting.test.ts
+++ b/test/functionality/typing/subtyping/subsetting.test.ts
@@ -9,27 +9,27 @@ describe('Infer types for subsetting expressions', () => {
 	assertInferredTypes(
 		'v <- c(1, 2, 3); v[2]',
 		{ query: Q.var('v').last().build(),                    expectedType: new RAtomicVectorType(new RTypeVariable(new RIntegerType(), new RTypeIntersection())) },
-		{ query: Q.all().filter(RType.Access).first().build(), lowerBound: new RAtomicVectorType(new RTypeVariable(new RIntegerType(), new RTypeIntersection())) },
+		{ query: Q.all().filter(RType.Access).first().build(), lowerBound: new RAtomicVectorType(new RIntegerType()) },
 	);
 	
 	const elementType1 = new RTypeVariable(new RIntegerType(), new RTypeIntersection());
 	assertInferredTypes(
 		'l <- list(1, 2, 3); l[2]',
 		{ query: Q.var('l').last().build(),                    expectedType: new RListType(elementType1, new Map([[0, elementType1], [1, elementType1], [2, elementType1]])) },
-		{ query: Q.all().filter(RType.Access).first().build(), lowerBound: new RListType(elementType1, new Map([[0, elementType1], [1, elementType1], [2, elementType1]])) },
+		{ query: Q.all().filter(RType.Access).first().build(), lowerBound: new RListType(new RIntegerType(), new Map([[0, new RIntegerType()], [1, new RIntegerType()], [2, new RIntegerType()]])) },
 	);
 	
 	assertInferredTypes(
 		'v <- c(1, 2, 3); v[]',
 		{ query: Q.var('v').last().build(),                    expectedType: new RAtomicVectorType(new RTypeVariable(new RIntegerType(), new RTypeIntersection())) },
-		{ query: Q.all().filter(RType.Access).first().build(), lowerBound: new RAtomicVectorType(new RTypeVariable(new RIntegerType(), new RTypeIntersection())) },
+		{ query: Q.all().filter(RType.Access).first().build(), lowerBound: new RAtomicVectorType(new RIntegerType()) },
 	);
 	
 	const elementType2 = new RTypeVariable(new RIntegerType(), new RTypeIntersection());
 	assertInferredTypes(
 		'l <- list(1, 2, 3); l[]',
 		{ query: Q.var('l').last().build(),                    expectedType: new RListType(elementType2, new Map([[0, elementType2], [1, elementType2], [2, elementType2]])) },
-		{ query: Q.all().filter(RType.Access).first().build(), lowerBound: new RListType(elementType2, new Map([[0, elementType2], [1, elementType2], [2, elementType2]])) },
+		{ query: Q.all().filter(RType.Access).first().build(), lowerBound: new RListType(new RIntegerType(), new Map([[0, new RIntegerType()], [1, new RIntegerType()], [2, new RIntegerType()]])) },
 	);
 	
 	assertInferredTypes(
diff --git a/test/functionality/typing/subtyping/variables.test.ts b/test/functionality/typing/subtyping/variables.test.ts
index 1a603dc8cf0..ec61e7788e7 100644
--- a/test/functionality/typing/subtyping/variables.test.ts
+++ b/test/functionality/typing/subtyping/variables.test.ts
@@ -1,13 +1,13 @@
 import { describe } from 'vitest';
-import { RIntegerType } from '../../../../src/typing/types';
+import { RComplexType, RIntegerType } from '../../../../src/typing/types';
 import { assertInferredTypes } from '../../_helper/typing/subtyping/assert-inferred-type';
 import { Q } from '../../../../src/search/flowr-search-builder';
 
 describe('Infer types for variables', () => {
 	assertInferredTypes(
-		'x <- 42; x',
-		{ query: Q.var('x').first().build(),  lowerBound: new RIntegerType() },
-		{ query: Q.criterion('1@<-').build(), lowerBound: new RIntegerType() },
-		{ query: Q.var('x').last().build(),   lowerBound: new RIntegerType() }
+		'x <- 42',
+		{ query: Q.var('x').first().build(),  lowerBound: new RIntegerType(), upperBound: new RComplexType() },
+		{ query: Q.criterion('1@<-').build(), lowerBound: new RIntegerType(), upperBound: new RComplexType() },
+		// { query: Q.var('x').last().build(),   lowerBound: new RIntegerType(), upperBound: new RComplexType() },
 	);
 });
\ No newline at end of file

From 74945551ca63ab4f0484d674b1b1e1bdc8fb2060 Mon Sep 17 00:00:00 2001
From: Lukas Rohde <lukas.rohde@silupe.de>
Date: Fri, 1 Aug 2025 01:36:34 +0200
Subject: [PATCH 116/153] feat-fix(typing): fix subsumption checks in `meet`,
 `join` and `combine`

---
 src/typing/subtyping/types.ts | 55 ++++++++++++++++++++++-------------
 1 file changed, 34 insertions(+), 21 deletions(-)

diff --git a/src/typing/subtyping/types.ts b/src/typing/subtyping/types.ts
index a060ce89d72..4cae1a4ff04 100644
--- a/src/typing/subtyping/types.ts
+++ b/src/typing/subtyping/types.ts
@@ -265,10 +265,13 @@ export function resolve(type: UnresolvedDataType, isUpperBound?: boolean, cache:
 		if(cachedType !== undefined) {
 			switch(isUpperBound) {
 				case true:
+					// console.debug('Returning', inspect(cachedType.upperBound, { depth: null, colors: true }), 'for upper bound');
 					return cachedType.upperBound;
 				case false:
+					// console.debug('Returning', inspect(cachedType.lowerBound, { depth: null, colors: true }), 'for lower bound');
 					return cachedType.lowerBound;
 				default:
+					// console.debug('Returning', inspect(cachedType.combined, { depth: null, colors: true }), 'for combined');
 					return cachedType.combined;
 			}
 		}
@@ -285,15 +288,20 @@ export function resolve(type: UnresolvedDataType, isUpperBound?: boolean, cache:
 			return errorType;
 		}
 
+		// console.debug('Resolved lower bound', inspect(lowerBound, { depth: null, colors: true }), 'and upper bound', inspect(upperBound, { depth: null, colors: true }));
 		const combined = combine(lowerBound, upperBound);
+		// console.debug('Combined bounds into type', inspect(combined, { depth: null, colors: true }));
 		cache.set(type, { lowerBound, upperBound, combined });
 
 		switch(isUpperBound) {
 			case true:
+				// console.debug('Returning', inspect(upperBound, { depth: null, colors: true }), 'for upper bound');
 				return upperBound;
 			case false:
+				// console.debug('Returning', inspect(lowerBound, { depth: null, colors: true }), 'for lower bound');
 				return lowerBound;
 			default:
+				// console.debug('Returning', inspect(combined, { depth: null, colors: true }), 'for combined');
 				return combined;
 		}
 	} else if(type instanceof UnresolvedRTypeUnion) {
@@ -302,6 +310,8 @@ export function resolve(type: UnresolvedDataType, isUpperBound?: boolean, cache:
 			const resolvedSubtype = resolve(subtype, isUpperBound, cache);
 			resolvedType = join(resolvedType, resolvedSubtype);
 		}
+
+		// console.debug('Returning', inspect(resolvedType, { depth: null, colors: true }), 'for resolved union type');
 		return resolvedType;
 	} else if(type instanceof UnresolvedRTypeIntersection) {
 		let resolvedType: DataType = new RTypeIntersection();
@@ -309,6 +319,8 @@ export function resolve(type: UnresolvedDataType, isUpperBound?: boolean, cache:
 			const resolvedSubtype = resolve(subtype, isUpperBound, cache);
 			resolvedType = meet(resolvedType, resolvedSubtype);
 		}
+
+		// console.debug('Returning', inspect(resolvedType, { depth: null, colors: true }), 'for resolved intersection type');
 		return resolvedType;
 	} else if(type instanceof UnresolvedRFunctionType) {
 		type.parameterTypes.values().forEach(paramType => prune(paramType));
@@ -320,6 +332,7 @@ export function resolve(type: UnresolvedDataType, isUpperBound?: boolean, cache:
 		const resolvedReturnType = resolve(type.returnType, isUpperBound, cache);
 		const resolvedType = new RFunctionType(resolvedParameterTypes, resolvedReturnType);
 		
+		// console.debug('Returning', inspect(resolvedType, { depth: null, colors: true }), 'for resolved function type');
 		return resolvedType;
 	} else if(type instanceof UnresolvedRAtomicVectorType) {
 		prune(type.elementType);
@@ -327,6 +340,7 @@ export function resolve(type: UnresolvedDataType, isUpperBound?: boolean, cache:
 		const resolvedElementType = resolve(type.elementType, isUpperBound, cache);
 		const resolvedType = new RAtomicVectorType(resolvedElementType);
 		
+		// console.debug('Returning', inspect(resolvedType, { depth: null, colors: true }), 'for resolved atomic vector type');
 		return resolvedType;
 	} else if(type instanceof UnresolvedRListType) {
 		type.indexedElementTypes.values().forEach(elementType => prune(elementType));
@@ -336,13 +350,17 @@ export function resolve(type: UnresolvedDataType, isUpperBound?: boolean, cache:
 		const resolvedIndexedElementTypes = new Map(type.indexedElementTypes.entries().map(([indexOrName, elementType]) => [indexOrName, resolve(elementType, isUpperBound, cache)]));
 		const resolvedType = new RListType(resolvedElementType, resolvedIndexedElementTypes);
 		
+		// console.debug('Returning', inspect(resolvedType, { depth: null, colors: true }), 'for resolved list type');
 		return resolvedType;
 	} else {
+		// console.debug('Returning already resolved', inspect(type, { depth: null, colors: true }));
 		return type;
 	}
 }
 
 export function combine(lowerBound: DataType, upperBound: DataType): DataType {
+	// console.debug('Combining', inspect(lowerBound, { depth: null, colors: true }), 'and', inspect(upperBound, { depth: null, colors: true }));
+
 	if(lowerBound instanceof RFunctionType && upperBound instanceof RFunctionType) {
 		const parameterTypes = new Map<number | string, DataType>();
 		const keys1 = new Set(lowerBound.parameterTypes.keys());
@@ -368,7 +386,7 @@ export function combine(lowerBound: DataType, upperBound: DataType): DataType {
 	} else if(lowerBound instanceof RAtomicVectorType && upperBound instanceof RAtomicVectorType) {
 		const elementType = combine(lowerBound.elementType, upperBound.elementType);
 		return new RAtomicVectorType(elementType);
-	} else if(subsumesByTag(lowerBound.tag, upperBound.tag) && subsumesByTag(upperBound.tag, lowerBound.tag)) {
+	} else if(subsumes(lowerBound, upperBound) && subsumes(upperBound, lowerBound)) {
 		return lowerBound; // If both types are the same, we return the upper bound
 	} else {
 		return new RTypeVariable(lowerBound, upperBound); // If the types are not compatible, we create a new variable type that combines both bounds 
@@ -421,7 +439,13 @@ export function subsumes(subtype: DataType | UnresolvedDataType, supertype: Data
 			return subsumes(supertype.parameterTypes.get(key)!, subtype.parameterTypes.get(key)!, inProcess);
 		});
 	} else {
-		result = subsumesByTag(subtype.tag, supertype.tag);
+		result = subtype.tag === supertype.tag
+			|| subtype.tag === DataTypeTag.Logical && supertype.tag === DataTypeTag.Integer
+			|| subtype.tag === DataTypeTag.Logical && supertype.tag === DataTypeTag.Double
+			|| subtype.tag === DataTypeTag.Logical && supertype.tag === DataTypeTag.Complex
+			|| subtype.tag === DataTypeTag.Integer && supertype.tag === DataTypeTag.Double
+			|| subtype.tag === DataTypeTag.Integer && supertype.tag === DataTypeTag.Complex
+			|| subtype.tag === DataTypeTag.Double && supertype.tag === DataTypeTag.Complex;
 	}
 
 	processedSupertypes?.delete(supertype); // Remove the supertype from the processed set
@@ -429,17 +453,6 @@ export function subsumes(subtype: DataType | UnresolvedDataType, supertype: Data
 	return result;
 }
 
-function subsumesByTag(subtype: DataTypeTag, supertype: DataTypeTag): boolean {
-	return subtype === supertype && subtype !== DataTypeTag.Error
-		|| subtype === DataTypeTag.Logical && supertype === DataTypeTag.Integer
-		|| subtype === DataTypeTag.Logical && supertype === DataTypeTag.Double
-		|| subtype === DataTypeTag.Logical && supertype === DataTypeTag.Complex
-		|| subtype === DataTypeTag.Integer && supertype === DataTypeTag.Double
-		|| subtype === DataTypeTag.Integer && supertype === DataTypeTag.Complex
-		|| subtype === DataTypeTag.Double && supertype === DataTypeTag.Complex
-		|| [DataTypeTag.Logical, DataTypeTag.Integer, DataTypeTag.Double, DataTypeTag.Complex, DataTypeTag.String, DataTypeTag.Raw].includes(subtype) && supertype === DataTypeTag.AtomicVector;
-}
-
 export function unresolvedJoin(type1: UnresolvedDataType, type2: UnresolvedDataType): UnresolvedDataType {
 	// console.debug('Joining', type1, 'and', type2);
 
@@ -535,9 +548,9 @@ export function unresolvedJoin(type1: UnresolvedDataType, type2: UnresolvedDataT
 		constrain(elementType, joinedElementType);
 		// constrain(joinedElementType, elementType);
 		return new UnresolvedRAtomicVectorType(elementType);
-	} else if(subsumesByTag(type1.tag, type2.tag)) {
+	} else if(subsumes(type1, type2)) {
 		return type2;
-	} else if(subsumesByTag(type2.tag, type1.tag)) {
+	} else if(subsumes(type2, type1)) {
 		return type1;
 	}
 	return new UnresolvedRTypeUnion(type1, type2);
@@ -610,9 +623,9 @@ export function join(type1: DataType, type2: DataType): DataType {
 		return new RAtomicVectorType(join(type1, type2.elementType));
 	} else if(isAtomicVectorBaseType(type2) && type1.tag === DataTypeTag.AtomicVector) {
 		return new RAtomicVectorType(join(type2, type1.elementType));
-	} else if(subsumesByTag(type1.tag, type2.tag)) {
+	} else if(subsumes(type1, type2)) {
 		return type2;
-	} else if(subsumesByTag(type2.tag, type1.tag)) {
+	} else if(subsumes(type2, type1)) {
 		return type1;
 	}
 	return new RTypeUnion(type1, type2);
@@ -705,9 +718,9 @@ export function unresolvedMeet(type1: UnresolvedDataType, type2: UnresolvedDataT
 		return unresolvedMeet(type1, type2.elementType);
 	} else if(isAtomicVectorBaseType(type2) && type1.tag === DataTypeTag.AtomicVector) {
 		return unresolvedMeet(type2, type1.elementType);
-	} else if(subsumesByTag(type1.tag, type2.tag)) {
+	} else if(subsumes(type1, type2)) {
 		return type1;
-	} else if(subsumesByTag(type2.tag, type1.tag)) {
+	} else if(subsumes(type2, type1)) {
 		return type2;
 	}
 	return new UnresolvedRTypeIntersection(type1, type2);
@@ -780,9 +793,9 @@ export function meet(type1: DataType, type2: DataType): DataType {
 		return meet(type1, type2.elementType);
 	} else if(isAtomicVectorBaseType(type2) && type1.tag === DataTypeTag.AtomicVector) {
 		return meet(type2, type1.elementType);
-	} else if(subsumesByTag(type1.tag, type2.tag)) {
+	} else if(subsumes(type1, type2)) {
 		return type1;
-	} else if(subsumesByTag(type2.tag, type1.tag)) {
+	} else if(subsumes(type2, type1)) {
 		return type2;
 	}
 	return new RTypeIntersection(type1, type2);

From 8f6c770f00b54036c7237f65b74bcbd2a1029ced Mon Sep 17 00:00:00 2001
From: Lukas Rohde <lukas.rohde@silupe.de>
Date: Fri, 1 Aug 2025 01:37:26 +0200
Subject: [PATCH 117/153] test(typing): add test and rename suite

---
 .../{constrain.test.ts => resolve.test.ts}    | 73 ++++++++++++++++++-
 1 file changed, 70 insertions(+), 3 deletions(-)
 rename test/functionality/typing/subtyping/{constrain.test.ts => resolve.test.ts} (88%)

diff --git a/test/functionality/typing/subtyping/constrain.test.ts b/test/functionality/typing/subtyping/resolve.test.ts
similarity index 88%
rename from test/functionality/typing/subtyping/constrain.test.ts
rename to test/functionality/typing/subtyping/resolve.test.ts
index db4de901d06..b81bcfb325a 100644
--- a/test/functionality/typing/subtyping/constrain.test.ts
+++ b/test/functionality/typing/subtyping/resolve.test.ts
@@ -1,7 +1,7 @@
 import { describe, expect, test } from 'vitest';
 import type { UnresolvedDataType } from '../../../../src/typing/subtyping/types';
 import { constrain, meet, resolve, subsumes, UnresolvedRAtomicVectorType, UnresolvedRFunctionType, UnresolvedRListType, UnresolvedRTypeIntersection, UnresolvedRTypeUnion, UnresolvedRTypeVariable } from '../../../../src/typing/subtyping/types';
-import { RIntegerType, RComplexType, RTypeVariable, RDoubleType, RStringType, RListType, RTypeIntersection, RTypeUnion, RNullType, RLanguageType, RLogicalType } from '../../../../src/typing/types';
+import { RIntegerType, RComplexType, RTypeVariable, RDoubleType, RStringType, RListType, RTypeIntersection, RTypeUnion, RNullType, RLanguageType, RLogicalType, RAtomicVectorType } from '../../../../src/typing/types';
 
 describe('Constrain and resolve types', () => {
 	test('Constrain with numeric bounds', () => {
@@ -211,7 +211,7 @@ describe('Constrain and resolve types', () => {
 		expect(resolve(typeVar2)).toEqual(new RIntegerType());
 	});
 	
-	test.only('Constrain from both sides 2', () => {
+	test('Constrain from both sides 2', () => {
 		const cache = new Map<UnresolvedDataType, Set<UnresolvedDataType>>();
 
 		const assignmentTypeVar = new UnresolvedRTypeVariable();
@@ -366,7 +366,7 @@ describe('Constrain and resolve types', () => {
 		constrain(typeVar1, typeVar10, cache);
 		constrain(typeVar1, typeVar12, cache);
 
-		expect(resolve(typeVar1)).toEqual(new RTypeVariable(new RTypeUnion(), new RTypeIntersection(new RIntegerType(), new RListType(new RTypeVariable()))));
+		expect(resolve(typeVar1)).toEqual(new RTypeVariable(new RTypeUnion(), new RTypeIntersection(new RIntegerType(), new RListType(new RTypeIntersection()))));
 	});
 
 	test('Calculate meet with intersections', () => {
@@ -406,4 +406,71 @@ describe('Constrain and resolve types', () => {
 		expect(subsumes(typeVar2, typeVar1)).toBe(true);
 		expect(subsumes(typeVar1, typeVar2)).toBe(true);
 	});
+
+	// <ref *1> UnresolvedRTypeVariable {
+	// 	tag: 'RTypeVariable',
+	// 	lowerBound: UnresolvedRTypeUnion { tag: 'RTypeUnion', types: Set(0) {} },
+	// 	upperBound: UnresolvedRTypeIntersection {
+	// 		tag: 'RTypeIntersection',
+	// 		types: Set(2) {
+	// 		UnresolvedRTypeVariable {
+	// 			tag: 'RTypeVariable',
+	// 			lowerBound: UnresolvedRTypeUnion { tag: 'RTypeUnion', types: Set(0) {} },
+	// 			upperBound: UnresolvedRTypeIntersection {
+	// 			tag: 'RTypeIntersection',
+	// 			types: Set(1) { [Circular *1] }
+	// 			}
+	// 		},
+	// 		UnresolvedRTypeUnion {
+	// 			tag: 'RTypeUnion',
+	// 			types: Set(2) {
+	// 			UnresolvedRAtomicVectorType {
+	// 				tag: 'RAtomicVectorType',
+	// 				elementType: UnresolvedRTypeVariable {
+	// 				tag: 'RTypeVariable',
+	// 				lowerBound: UnresolvedRTypeUnion {
+	// 					tag: 'RTypeUnion',
+	// 					types: Set(0) {}
+	// 				},
+	// 				upperBound: UnresolvedRTypeIntersection {
+	// 					tag: 'RTypeIntersection',
+	// 					types: Set(0) {}
+	// 				}
+	// 				}
+	// 			},
+	// 			UnresolvedRListType {
+	// 				tag: 'RListType',
+	// 				elementType: UnresolvedRTypeVariable {
+	// 				tag: 'RTypeVariable',
+	// 				lowerBound: UnresolvedRTypeUnion {
+	// 					tag: 'RTypeUnion',
+	// 					types: Set(0) {}
+	// 				},
+	// 				upperBound: UnresolvedRTypeIntersection {
+	// 					tag: 'RTypeIntersection',
+	// 					types: Set(0) {}
+	// 				}
+	// 				},
+	// 				indexedElementTypes: Map(0) {}
+	// 			}
+	// 			}
+	// 		}
+	// 		}
+	// 	}
+	// 	}
+	test.only('Resolve cyclic type variable with upper union', () => {
+		const cache = new Map<UnresolvedDataType, Set<UnresolvedDataType>>();
+
+		const typeVar1 = new UnresolvedRTypeVariable();
+		// const typeVar2 = new UnresolvedRTypeVariable();
+		const elementType = new UnresolvedRTypeVariable();
+		const vectorType = new UnresolvedRTypeUnion(new UnresolvedRAtomicVectorType(elementType), new UnresolvedRListType(elementType));
+		// constrain(typeVar1, typeVar2, cache);
+		constrain(typeVar1, vectorType, cache);
+		// constrain(typeVar2, typeVar1, cache);
+
+		// console.debug('Resolving', inspect(typeVar1, { depth: null, colors: true }));
+
+		expect(resolve(typeVar1)).toEqual(new RTypeVariable(new RTypeUnion(), new RTypeUnion(new RAtomicVectorType(new RTypeIntersection()), new RListType(new RTypeIntersection()))));
+	});
 });
\ No newline at end of file

From e28a3bc778597e2d2a9c75a7e2aa13505160dd04 Mon Sep 17 00:00:00 2001
From: Lukas Rohde <lukas.rohde@silupe.de>
Date: Fri, 1 Aug 2025 02:01:04 +0200
Subject: [PATCH 118/153] feat(typing): support replacement and infer upper
 bounds for variables

---
 src/typing/subtyping/infer.ts                 | 68 ++++++++++++--
 .../typing/subtyping/replacement.test.ts      | 93 +++++++++++++++++++
 2 files changed, 151 insertions(+), 10 deletions(-)
 create mode 100644 test/functionality/typing/subtyping/replacement.test.ts

diff --git a/src/typing/subtyping/infer.ts b/src/typing/subtyping/infer.ts
index 4bde1d5d9d8..90ca6d33e4a 100644
--- a/src/typing/subtyping/infer.ts
+++ b/src/typing/subtyping/infer.ts
@@ -8,7 +8,7 @@ import type { RNumber } from '../../r-bridge/lang-4.x/ast/model/nodes/r-number';
 import type { RString } from '../../r-bridge/lang-4.x/ast/model/nodes/r-string';
 import type { NormalizedAst, ParentInformation } from '../../r-bridge/lang-4.x/ast/model/processing/decorate';
 import { mapNormalizedAstInfo } from '../../r-bridge/lang-4.x/ast/model/processing/decorate';
-import type { DataType, DataTypeInfo } from '../types';
+import type { DataTypeInfo } from '../types';
 import { RComplexType, RDoubleType, RIntegerType, RLogicalType, RStringType, RNullType, RLanguageType } from '../types';
 import type { RExpressionList } from '../../r-bridge/lang-4.x/ast/model/nodes/r-expression-list';
 import { guard } from '../../util/assert';
@@ -56,10 +56,13 @@ function decorateTypeVariables<Info extends ParentInformation>(ast: NormalizedAs
 }
 
 function resolveTypeVariables<Info extends ParentInformation & UnresolvedTypeInfo>(ast: NormalizedAst<Info>): NormalizedAst<Omit<Info, keyof UnresolvedTypeInfo> & DataTypeInfo> {
-	const cache = new Map<UnresolvedDataType, DataType>();
 	return mapNormalizedAstInfo(ast, node => {
 		const { typeVariable, ...rest } = node.info;
-		return { ...rest, inferredType: resolve(typeVariable, cache) };
+		const resolvedType = resolve(typeVariable);
+		// if(node.lexeme === 'y') {
+		// 	console.debug('Resolving type variable', inspect(typeVariable, { depth: null, colors: true }), 'to', inspect(resolvedType, { depth: null, colors: true }));
+		// }
+		return { ...rest, inferredType: resolvedType };
 	});
 }
 
@@ -152,11 +155,21 @@ class TypeInferringCfgGuidedVisitor<
 	}
 
 	protected inferNodeTypeFromReadOrigins(node: RNode<UnresolvedTypeInfo>, readOrigins: Array<{ id: NodeId, type: OriginType }>): void {
+		let hasUnresolvableOrigins = false;
+		const lowerBounds = new Set<UnresolvedDataType>();
+		
 		for(const readOrigin of readOrigins ?? []) {
 			const readNode = this.getNormalizedAst(readOrigin.id);
 			if(readNode !== undefined) {
 				this.constrainNodeType(node, { lowerBound: readNode.info.typeVariable });
-			} else if(node.type === RType.Symbol) {
+				lowerBounds.add(readNode.info.typeVariable);
+			} else {
+				hasUnresolvableOrigins = true;
+			}
+		}
+
+		if(hasUnresolvableOrigins) {
+			if(node.type === RType.Symbol) {
 				// If the read variable has no associated AST node it might be a library constant or function
 				const constantType = this.constantContext.get(node.content);
 				if(constantType !== undefined) {
@@ -168,6 +181,9 @@ class TypeInferringCfgGuidedVisitor<
 					this.constrainNodeType(node, { lowerBound: functionType });
 				}
 			}
+		} else if(lowerBounds.size > 0) {
+			const upperBound = lowerBounds.size === 1 ? lowerBounds.values().next().value : new UnresolvedRTypeUnion(...lowerBounds);
+			this.constrainNodeType(node, { upperBound });
 		}
 	}
 
@@ -202,8 +218,8 @@ class TypeInferringCfgGuidedVisitor<
 		const valueNode = this.getNormalizedAst(data.source);
 		guard(valueNode !== undefined, 'Expected AST node to be defined');
 
-		this.constrainNodeType(data.target, { lowerBound: valueNode.info.typeVariable });
-		this.constrainNodeType(data.call.id, { lowerBound: valueNode.info.typeVariable });
+		this.constrainNodeType(data.target, valueNode.info.typeVariable);
+		this.constrainNodeType(data.call.id, valueNode.info.typeVariable);
 	}
 
 	override onDefaultFunctionCall(data: { call: DataflowGraphVertexFunctionCall }): void {
@@ -392,8 +408,7 @@ class TypeInferringCfgGuidedVisitor<
 		for(const arg of args) {
 			const argNode = this.getNormalizedAst(arg.nodeId);
 			guard(argNode !== undefined, 'Expected argument node to be defined');
-			this.constrainNodeType(argNode, { upperBound: new UnresolvedRAtomicVectorType() });
-			constrain(argNode.info.typeVariable, vectorType, this.constraintCache);
+			this.constrainNodeType(argNode, { upperBound: vectorType });
 		}
 	}
 
@@ -478,11 +493,44 @@ class TypeInferringCfgGuidedVisitor<
 			case '[[':
 				this.constrainNodeType(data.call.id, { lowerBound: elementType });
 				break;
-			case '$': {
+			case '$':
 				this.constrainNodeType(firstArgNode, { upperBound: new UnresolvedRListType(elementType) });
 				this.constrainNodeType(data.call.id, { lowerBound: elementType });
 				break;
-			}
+		}
+	}
+
+	protected override onReplacementCall(data: { call: DataflowGraphVertexFunctionCall; source: NodeId | undefined; target: NodeId | undefined; }): void {
+		if(data.source === undefined || data.target === undefined) {
+			return; // Malformed replacement call
+		}
+
+		const targetNode = this.getNormalizedAst(data.target);
+		guard(targetNode !== undefined, 'Expected target node to be defined');
+		const sourceNode = this.getNormalizedAst(data.source);
+		guard(sourceNode !== undefined, 'Expected source node to be defined');
+
+		const targetElementType = new UnresolvedRTypeVariable();
+		const targetVectorType = new UnresolvedRTypeUnion(new UnresolvedRAtomicVectorType(targetElementType), new UnresolvedRListType(targetElementType));
+		this.constrainNodeType(targetNode, { upperBound: targetVectorType });
+
+		this.constrainNodeType(data.call.id, sourceNode.info.typeVariable);
+
+		const sourceElementType = new UnresolvedRTypeVariable();
+		const sourceVectorType = new UnresolvedRTypeUnion(new UnresolvedRAtomicVectorType(sourceElementType), new UnresolvedRListType(sourceElementType));
+
+		switch(data.call.name) {
+			case '[<-':
+				// If the replacement call uses a `[` operation, we assume that the source is as another instance of the same container type
+				this.constrainNodeType(sourceNode, { upperBound: sourceVectorType });
+				break;
+			case '[[<-':
+				this.constrainNodeType(sourceNode, { upperBound: sourceElementType });
+				break;
+			case '$<-':
+				this.constrainNodeType(targetNode, { upperBound: new UnresolvedRListType(targetElementType) });
+				this.constrainNodeType(sourceNode, { upperBound: sourceElementType });
+				break;
 		}
 	}
 }
\ No newline at end of file
diff --git a/test/functionality/typing/subtyping/replacement.test.ts b/test/functionality/typing/subtyping/replacement.test.ts
new file mode 100644
index 00000000000..3146b754190
--- /dev/null
+++ b/test/functionality/typing/subtyping/replacement.test.ts
@@ -0,0 +1,93 @@
+import { describe, expect, test } from 'vitest';
+import type { DataType } from '../../../../src/typing/types';
+import { RTypeIntersection, RAtomicVectorType, RIntegerType, RListType, RTypeVariable, RTypeUnion, RNullType, RLogicalType, RComplexType } from '../../../../src/typing/types';
+import { assertInferredTypes } from '../../_helper/typing/subtyping/assert-inferred-type';
+import { Q } from '../../../../src/search/flowr-search-builder';
+
+describe('Infer types for subsetting expressions', () => {
+	test('placeholder test', () => expect(true).toBe(true)); // Placeholder to ensure the test suite runs
+
+	assertInferredTypes(
+		'v <- c(1, 2, 3); v[2] <- y; v',
+		{ query: Q.var('v').first().build(),          expectedType: new RAtomicVectorType(new RTypeVariable(new RIntegerType(), new RTypeIntersection())) },
+		{ query: Q.var('v').last().build(),           expectedType: new RAtomicVectorType(new RTypeVariable(new RIntegerType(), new RTypeIntersection())) },
+		{ query: Q.var('y').last().build(),           upperBound: new RTypeUnion(new RAtomicVectorType(new RTypeIntersection()), new RListType(new RTypeIntersection())) },
+		{ query: Q.criterion('1@[').last().build(),   upperBound: new RTypeUnion(new RAtomicVectorType(new RTypeIntersection()), new RListType(new RTypeIntersection())) },
+		{ query: Q.criterion('1@<-').first().build(), expectedType: new RAtomicVectorType(new RTypeVariable(new RIntegerType(), new RTypeIntersection())) },
+	);
+	
+	assertInferredTypes(
+		'v <- c(1, 2, 3); y <- 1; v[2] <- y; v',
+		{ query: Q.var('v').last().build(),         expectedType: new RAtomicVectorType(new RTypeVariable(new RIntegerType(), new RTypeIntersection())) },
+		{ query: Q.var('y').last().build(),         lowerBound: new RIntegerType(), upperBound: new RComplexType() },
+		{ query: Q.criterion('1@[').last().build(), lowerBound: new RIntegerType(), upperBound: new RComplexType() },
+	);
+	
+	const elementType1 = new RTypeVariable(new RIntegerType(), new RTypeIntersection());
+	assertInferredTypes(
+		'l <- list(1, 2, 3); l[2] <- y; l',
+		{ query: Q.var('l').last().build(),         expectedType: new RListType(elementType1, new Map([[0, elementType1], [1, elementType1], [2, elementType1]])) },
+		{ query: Q.var('y').last().build(),         upperBound: new RTypeUnion(new RAtomicVectorType(new RTypeIntersection()), new RListType(new RTypeIntersection())) },
+		{ query: Q.criterion('1@[').last().build(), upperBound: new RTypeUnion(new RAtomicVectorType(new RTypeIntersection()), new RListType(new RTypeIntersection())) },
+	);
+	
+	assertInferredTypes(
+		'v <- c(1, 2, 3); v[] <- y; v',
+		{ query: Q.var('v').last().build(),         expectedType: new RAtomicVectorType(new RTypeVariable(new RIntegerType(), new RTypeIntersection())) },
+		{ query: Q.var('y').last().build(),         upperBound: new RTypeUnion(new RAtomicVectorType(new RTypeIntersection()), new RListType(new RTypeIntersection())) },
+		{ query: Q.criterion('1@[').last().build(), upperBound: new RTypeUnion(new RAtomicVectorType(new RTypeIntersection()), new RListType(new RTypeIntersection())) },
+	);
+	
+	const elementType2 = new RTypeVariable(new RIntegerType(), new RTypeIntersection());
+	assertInferredTypes(
+		'l <- list(1, 2, 3); l[] <- y; l',
+		{ query: Q.var('l').last().build(),         expectedType: new RListType(elementType2, new Map([[0, elementType2], [1, elementType2], [2, elementType2]])) },
+		{ query: Q.var('y').last().build(),         upperBound: new RTypeUnion(new RAtomicVectorType(new RTypeIntersection()), new RListType(new RTypeIntersection())) },
+		{ query: Q.criterion('1@[').last().build(), upperBound: new RTypeUnion(new RAtomicVectorType(new RTypeIntersection()), new RListType(new RTypeIntersection())) },
+	);
+	
+	assertInferredTypes(
+		'v <- c(1, 2, 3); v[[2]] <- y; v',
+		{ query: Q.var('v').last().build(),          expectedType: new RAtomicVectorType(new RTypeVariable(new RIntegerType(), new RTypeIntersection())) },
+		{ query: Q.var('y').last().build(),          upperBound: new RTypeIntersection() },
+		{ query: Q.criterion('1@[[').last().build(), expectedType: new RTypeVariable() },
+	);
+	
+	const elementType3 = new RTypeVariable(new RIntegerType(), new RTypeIntersection());
+	assertInferredTypes(
+		'l <- list(1, 2, 3); l[[2]] <- y; l',
+		{ query: Q.var('l').last().build(),          expectedType: new RListType(elementType1, new Map([[0, elementType3], [1, elementType3], [2, elementType3]])) },
+		{ query: Q.var('y').last().build(),          upperBound: new RTypeIntersection() },
+		{ query: Q.criterion('1@[[').last().build(), expectedType: new RTypeVariable() },
+	);
+	
+	const elementType4 = new RTypeVariable(new RIntegerType(), new RTypeIntersection());
+	assertInferredTypes(
+		'l <- list(1, x = 2, 3); l$x <- y; l',
+		{ query: Q.var('l').last().build(),         expectedType: new RListType(elementType4, new Map<number | string, DataType>([[0, elementType4], [1, elementType4], [2, elementType4], ['x', elementType4]])) },
+		{ query: Q.var('y').last().build(),         upperBound: new RTypeIntersection() },
+		{ query: Q.criterion('1@$').last().build(), expectedType: new RTypeVariable() },
+	);
+	
+	const elementType5 = new RTypeVariable(new RIntegerType(), new RTypeIntersection());
+	assertInferredTypes(
+		'l <- list(1, 2, 3); l$a <- y; l',
+		{ query: Q.var('l').last().build(),         expectedType: new RListType(elementType5, new Map([[0, elementType5], [1, elementType5], [2, elementType5]])) },
+		{ query: Q.var('y').last().build(),         upperBound: new RTypeIntersection() },
+		{ query: Q.criterion('1@$').last().build(), expectedType: new RTypeVariable() },
+	);
+	
+	const elementType6 = new RTypeVariable(new RTypeUnion(new RIntegerType(), new RNullType()), new RTypeIntersection());
+	// eslint-disable-next-line @typescript-eslint/naming-convention
+	const elementType6_0 = new RTypeVariable(new RLogicalType(), new RTypeIntersection());
+	// eslint-disable-next-line @typescript-eslint/naming-convention
+	const elementType6_1 = new RTypeVariable(new RIntegerType(), new RTypeIntersection());
+	// eslint-disable-next-line @typescript-eslint/naming-convention
+	const elementType6_2 = new RTypeVariable(new RNullType(), new RTypeIntersection());
+	assertInferredTypes(
+		'l <- list(TRUE, a = 42, NULL); l$a <- y; l',
+		{ query: Q.var('l').last().build(),         expectedType: new RListType(elementType6, new Map<number | string, DataType>([[0, elementType6_0], [1, elementType6_1], [2, elementType6_2], ['a', elementType6_1]])) },
+		{ query: Q.var('y').last().build(),         upperBound: new RTypeIntersection() },
+		{ query: Q.criterion('1@$').last().build(), expectedType: new RTypeVariable() },
+	);
+});
\ No newline at end of file

From 02e0ec472812fabc85b643aaca43fac67b1675df Mon Sep 17 00:00:00 2001
From: Lukas Rohde <lukas.rohde@silupe.de>
Date: Fri, 1 Aug 2025 11:54:37 +0200
Subject: [PATCH 119/153] feat(typing): add subtyping relation between NULL and
 atomic vectors

---
 src/typing/subtyping/infer.ts                 | 10 ++-----
 src/typing/subtyping/types.ts                 | 27 ++++++++++++++-----
 .../typing/subtyping/replacement.test.ts      | 24 +++++++++++++++--
 .../typing/subtyping/subsetting.test.ts       | 18 ++++++++++---
 4 files changed, 59 insertions(+), 20 deletions(-)

diff --git a/src/typing/subtyping/infer.ts b/src/typing/subtyping/infer.ts
index 90ca6d33e4a..1716dae3c0c 100644
--- a/src/typing/subtyping/infer.ts
+++ b/src/typing/subtyping/infer.ts
@@ -377,19 +377,15 @@ class TypeInferringCfgGuidedVisitor<
 		const listType = new UnresolvedRListType();
 		this.constrainNodeType(data.call.id, listType);
 
-		// TODO: Handle flattening behavior of `list` function (?)
 		for(const [index, arg] of data.call.args.entries()) {
 			if(arg === EmptyArgument) {
 				continue; // Skip empty arguments
 			}
-			
-			const argNode = this.getNormalizedAst(arg.nodeId);
-			guard(argNode !== undefined, 'Expected argument node to be defined');
 
-			constrain(argNode.info.typeVariable, getIndexedElementTypeFromList(listType, index, this.constraintCache), this.constraintCache);
+			this.constrainNodeType(arg.nodeId, { upperBound: getIndexedElementTypeFromList(listType, index, this.constraintCache) });
 
 			if(arg.name !== undefined) {
-				constrain(argNode.info.typeVariable, getIndexedElementTypeFromList(listType, arg.name, this.constraintCache), this.constraintCache);
+				this.constrainNodeType(arg.nodeId, { upperBound: getIndexedElementTypeFromList(listType, arg.name, this.constraintCache) });
 			}
 		}
 	}
@@ -401,7 +397,6 @@ class TypeInferringCfgGuidedVisitor<
 			return;
 		}
 		
-		// TODO: Handle behavior of `c` function for non-vector arguments
 		const vectorType = new UnresolvedRAtomicVectorType();
 		this.constrainNodeType(data.call.id, vectorType);
 
@@ -479,7 +474,6 @@ class TypeInferringCfgGuidedVisitor<
 		const firstArgNode = this.getNormalizedAst(firstArg.nodeId);
 		guard(firstArgNode !== undefined, 'Expected first argument node to be defined');
 
-		// TODO: Handle subsetting for other operand types, in particular for scalars and null
 		const elementType = new UnresolvedRTypeVariable();
 		const vectorType = new UnresolvedRTypeUnion(new UnresolvedRAtomicVectorType(elementType), new UnresolvedRListType(elementType));
 		this.constrainNodeType(firstArgNode, { upperBound: vectorType });
diff --git a/src/typing/subtyping/types.ts b/src/typing/subtyping/types.ts
index 4cae1a4ff04..9c70404d988 100644
--- a/src/typing/subtyping/types.ts
+++ b/src/typing/subtyping/types.ts
@@ -1,6 +1,6 @@
 import { guard } from '../../util/assert';
-import type { DataType , AtomicVectorBaseType, REnvironmentType, RLanguageType, RNullType } from '../types';
-import { DataTypeTag, isAtomicVectorBaseType, RAtomicVectorType, RFunctionType, RListType, RTypeError, RTypeIntersection, RTypeUnion, RTypeVariable } from '../types';
+import type { DataType , AtomicVectorBaseType, REnvironmentType, RLanguageType } from '../types';
+import { RNullType , DataTypeTag, isAtomicVectorBaseType, RAtomicVectorType, RFunctionType, RListType, RTypeError, RTypeIntersection, RTypeUnion, RTypeVariable } from '../types';
 
 // let idCounter = 0;
 
@@ -445,7 +445,8 @@ export function subsumes(subtype: DataType | UnresolvedDataType, supertype: Data
 			|| subtype.tag === DataTypeTag.Logical && supertype.tag === DataTypeTag.Complex
 			|| subtype.tag === DataTypeTag.Integer && supertype.tag === DataTypeTag.Double
 			|| subtype.tag === DataTypeTag.Integer && supertype.tag === DataTypeTag.Complex
-			|| subtype.tag === DataTypeTag.Double && supertype.tag === DataTypeTag.Complex;
+			|| subtype.tag === DataTypeTag.Double && supertype.tag === DataTypeTag.Complex
+			|| subtype.tag === DataTypeTag.Null && supertype.tag === DataTypeTag.AtomicVector;
 	}
 
 	processedSupertypes?.delete(supertype); // Remove the supertype from the processed set
@@ -548,6 +549,14 @@ export function unresolvedJoin(type1: UnresolvedDataType, type2: UnresolvedDataT
 		constrain(elementType, joinedElementType);
 		// constrain(joinedElementType, elementType);
 		return new UnresolvedRAtomicVectorType(elementType);
+	} else if(type1 instanceof RNullType && isAtomicVectorBaseType(type2)) {
+		const elementType = new UnresolvedRTypeVariable();
+		constrain(elementType, type2);
+		return new UnresolvedRAtomicVectorType(elementType);
+	} else if(isAtomicVectorBaseType(type1) && type2 instanceof RNullType) {
+		const elementType = new UnresolvedRTypeVariable();
+		constrain(elementType, type1);
+		return new UnresolvedRAtomicVectorType(elementType);
 	} else if(subsumes(type1, type2)) {
 		return type2;
 	} else if(subsumes(type2, type1)) {
@@ -563,9 +572,9 @@ export function join(type1: DataType, type2: DataType): DataType {
 	} else if(type2 instanceof RTypeError) {
 		return type2;
 	} else if(type1 instanceof RTypeVariable) {
-		return new RTypeVariable(join(type1.lowerBound, type2), join(type1.upperBound, type2));
+		return combine(join(type1.lowerBound, type2), join(type1.upperBound, type2));
 	} else if(type2 instanceof RTypeVariable) {
-		return new RTypeVariable(join(type1, type2.lowerBound), join(type1, type2.upperBound));
+		return combine(join(type1, type2.lowerBound), join(type1, type2.upperBound));
 	} else if(type1 instanceof RTypeUnion) {
 		if(type1.types.size === 0) {
 			return type2; // If type1 is an empty union, return type2
@@ -623,6 +632,10 @@ export function join(type1: DataType, type2: DataType): DataType {
 		return new RAtomicVectorType(join(type1, type2.elementType));
 	} else if(isAtomicVectorBaseType(type2) && type1.tag === DataTypeTag.AtomicVector) {
 		return new RAtomicVectorType(join(type2, type1.elementType));
+	} else if(type1 instanceof RNullType && isAtomicVectorBaseType(type2)) {
+		return new RAtomicVectorType(type2);
+	} else if(isAtomicVectorBaseType(type1) && type2 instanceof RNullType) {
+		return new RAtomicVectorType(type1);
 	} else if(subsumes(type1, type2)) {
 		return type2;
 	} else if(subsumes(type2, type1)) {
@@ -733,9 +746,9 @@ export function meet(type1: DataType, type2: DataType): DataType {
 	} else if(type2 instanceof RTypeError) {
 		return type2;
 	} else if(type1 instanceof RTypeVariable) {
-		return new RTypeVariable(meet(type1.lowerBound, type2), meet(type1.upperBound, type2));
+		return combine(meet(type1.lowerBound, type2), meet(type1.upperBound, type2));
 	} else if(type2 instanceof RTypeVariable) {
-		return new RTypeVariable(meet(type1, type2.lowerBound), meet(type1, type2.upperBound));
+		return combine(meet(type1, type2.lowerBound), meet(type1, type2.upperBound));
 	} else if(type1 instanceof RTypeIntersection) {
 		if(type1.types.size === 0) {
 			return type2; // If type1 is an empty intersection, return type2
diff --git a/test/functionality/typing/subtyping/replacement.test.ts b/test/functionality/typing/subtyping/replacement.test.ts
index 3146b754190..7eea284bcec 100644
--- a/test/functionality/typing/subtyping/replacement.test.ts
+++ b/test/functionality/typing/subtyping/replacement.test.ts
@@ -1,6 +1,6 @@
 import { describe, expect, test } from 'vitest';
 import type { DataType } from '../../../../src/typing/types';
-import { RTypeIntersection, RAtomicVectorType, RIntegerType, RListType, RTypeVariable, RTypeUnion, RNullType, RLogicalType, RComplexType } from '../../../../src/typing/types';
+import { RTypeIntersection, RAtomicVectorType, RIntegerType, RListType, RTypeVariable, RTypeUnion, RNullType, RLogicalType, RComplexType, RDoubleType } from '../../../../src/typing/types';
 import { assertInferredTypes } from '../../_helper/typing/subtyping/assert-inferred-type';
 import { Q } from '../../../../src/search/flowr-search-builder';
 
@@ -77,7 +77,7 @@ describe('Infer types for subsetting expressions', () => {
 		{ query: Q.criterion('1@$').last().build(), expectedType: new RTypeVariable() },
 	);
 	
-	const elementType6 = new RTypeVariable(new RTypeUnion(new RIntegerType(), new RNullType()), new RTypeIntersection());
+	const elementType6 = new RTypeVariable(new RAtomicVectorType(new RIntegerType()), new RTypeIntersection());
 	// eslint-disable-next-line @typescript-eslint/naming-convention
 	const elementType6_0 = new RTypeVariable(new RLogicalType(), new RTypeIntersection());
 	// eslint-disable-next-line @typescript-eslint/naming-convention
@@ -90,4 +90,24 @@ describe('Infer types for subsetting expressions', () => {
 		{ query: Q.var('y').last().build(),         upperBound: new RTypeIntersection() },
 		{ query: Q.criterion('1@$').last().build(), expectedType: new RTypeVariable() },
 	);
+
+	assertInferredTypes(
+		'v <- 1; v[[1]] <- y; v',
+		{ query: Q.var('v').last().build(),          expectedType: new RTypeVariable(new RIntegerType(), new RAtomicVectorType(new RTypeIntersection())) },
+		{ query: Q.var('y').last().build(),          expectedType: new RTypeVariable() },
+		{ query: Q.criterion('1@[[').last().build(), expectedType: new RTypeVariable() },
+	);
+	
+	assertInferredTypes(
+		'v <- 1; v[[1]] <- 1.2; v',
+		{ query: Q.var('v').last().build(),          expectedType: new RTypeVariable(new RIntegerType(), new RAtomicVectorType(new RTypeIntersection())) },
+		{ query: Q.criterion('1@[[').last().build(), lowerBound: new RDoubleType(), upperBound: new RComplexType() },
+	);
+	
+	assertInferredTypes(
+		'v <- NULL; v[1] <- y; v',
+		{ query: Q.var('v').last().build(),         expectedType: new RTypeVariable(new RNullType(), new RAtomicVectorType(new RTypeIntersection())) },
+		{ query: Q.var('y').last().build(),         upperBound: new RTypeUnion(new RAtomicVectorType(new RTypeIntersection()), new RListType(new RTypeIntersection())) },
+		{ query: Q.criterion('1@[').last().build(), upperBound: new RTypeUnion(new RAtomicVectorType(new RTypeIntersection()), new RListType(new RTypeIntersection())) },
+	);
 });
\ No newline at end of file
diff --git a/test/functionality/typing/subtyping/subsetting.test.ts b/test/functionality/typing/subtyping/subsetting.test.ts
index 279fce55a9a..f96903b0b66 100644
--- a/test/functionality/typing/subtyping/subsetting.test.ts
+++ b/test/functionality/typing/subtyping/subsetting.test.ts
@@ -1,6 +1,6 @@
 import { describe } from 'vitest';
 import type { DataType } from '../../../../src/typing/types';
-import { RTypeIntersection, RAtomicVectorType, RIntegerType, RListType, RTypeVariable, RTypeUnion, RNullType, RLogicalType } from '../../../../src/typing/types';
+import { RTypeIntersection, RAtomicVectorType, RIntegerType, RListType, RTypeVariable, RNullType, RLogicalType, RComplexType } from '../../../../src/typing/types';
 import { assertInferredTypes } from '../../_helper/typing/subtyping/assert-inferred-type';
 import { Q } from '../../../../src/search/flowr-search-builder';
 import { RType } from '../../../../src/r-bridge/lang-4.x/ast/model/type';
@@ -59,7 +59,7 @@ describe('Infer types for subsetting expressions', () => {
 		{ query: Q.all().filter(RType.Access).first().build(), lowerBound: new RIntegerType() },
 	);
 	
-	const elementType6 = new RTypeVariable(new RTypeUnion(new RIntegerType(), new RNullType()), new RTypeIntersection());
+	const elementType6 = new RTypeVariable(new RAtomicVectorType(new RIntegerType()), new RTypeIntersection());
 	// eslint-disable-next-line @typescript-eslint/naming-convention
 	const elementType6_0 = new RTypeVariable(new RLogicalType(), new RTypeIntersection());
 	// eslint-disable-next-line @typescript-eslint/naming-convention
@@ -69,6 +69,18 @@ describe('Infer types for subsetting expressions', () => {
 	assertInferredTypes(
 		'l <- list(TRUE, a = 42, NULL); l$a',
 		{ query: Q.var('l').last().build(),                    expectedType: new RListType(elementType6, new Map<number | string, DataType>([[0, elementType6_0], [1, elementType6_1], [2, elementType6_2], ['a', elementType6_1]])) },
-		{ query: Q.all().filter(RType.Access).first().build(), lowerBound: new RTypeUnion(new RIntegerType(), new RNullType()), upperBound: new RTypeIntersection() },
+		{ query: Q.all().filter(RType.Access).first().build(), lowerBound: new RAtomicVectorType(new RIntegerType()), upperBound: new RTypeIntersection() },
+	);
+
+	assertInferredTypes(
+		'v <- 1; v[[1]]',
+		{ query: Q.var('v').last().build(),                    lowerBound: new RIntegerType(), upperBound: new RComplexType() },
+		{ query: Q.all().filter(RType.Access).first().build(), lowerBound: new RIntegerType() },
+	);
+
+	assertInferredTypes(
+		'v <- NULL; v[1]',
+		{ query: Q.var('v').last().build(),                    expectedType: new RNullType() },
+		{ query: Q.all().filter(RType.Access).first().build(), lowerBound: new RNullType() },
 	);
 });
\ No newline at end of file

From 7135d5d70b38719d966235c44562c829b399edc7 Mon Sep 17 00:00:00 2001
From: Lukas Rohde <lukas.rohde@silupe.de>
Date: Sat, 2 Aug 2025 14:42:44 +0200
Subject: [PATCH 120/153] feat-fix(typing): fix explosion of recursive calls in
 `prune`

---
 src/typing/subtyping/types.ts | 39 +++++++++++++++++++++++------------
 1 file changed, 26 insertions(+), 13 deletions(-)

diff --git a/src/typing/subtyping/types.ts b/src/typing/subtyping/types.ts
index 9c70404d988..e23c0830842 100644
--- a/src/typing/subtyping/types.ts
+++ b/src/typing/subtyping/types.ts
@@ -155,20 +155,26 @@ export function constrain(subtype: UnresolvedDataType, supertype: UnresolvedData
 
 
 export function prune(variable: UnresolvedRTypeVariable, inProcess: Set<UnresolvedRTypeVariable | Set<UnresolvedDataType>> = new Set()): void {
-	// console.debug('Pruning variable', inspect(variable, { depth: null, colors: true }));
-	
+	// console.debug('Pruning variable', variable.id);
+
+	if(inProcess.has(variable)) {
+		// console.debug('Variable', variable.id, 'is already in process');
+		return;
+	}
+
 	inProcess.add(variable);
 
 	function pruneLowerBounds(lowerBounds: Set<UnresolvedDataType>): Set<UnresolvedDataType> {
+		if(inProcess.has(lowerBounds)) {
+			return lowerBounds;
+		}
+
 		inProcess.add(lowerBounds);
 
 		const prunedBounds = new Set(lowerBounds.values().flatMap(lowerBound => {
 			if(lowerBound instanceof UnresolvedRTypeVariable) {
 				// If the lower bound is a type variable, we only care about its lower bound
-				if(!inProcess.has(lowerBound) && !inProcess.has(lowerBound.lowerBound.types)) {
-					prune(lowerBound, inProcess); // Prune the variable recursively w.r.t. its own bounds
-					lowerBound.lowerBound.types = pruneLowerBounds(lowerBound.lowerBound.types);
-				}
+				lowerBound.lowerBound.types = pruneLowerBounds(lowerBound.lowerBound.types);
 				return [lowerBound];
 			} else if(lowerBound instanceof UnresolvedRTypeUnion) {
 				// If the lower bound is a union, we prune and include its types directly
@@ -205,15 +211,19 @@ export function prune(variable: UnresolvedRTypeVariable, inProcess: Set<Unresolv
 		return prunedBounds;
 	}
 	function pruneUpperBounds(upperBounds: Set<UnresolvedDataType>): Set<UnresolvedDataType> {
+		// console.debug('Pruning upper bounds');
+
+		if(inProcess.has(upperBounds)) {
+			// console.debug('Upper bounds are already in process');
+			return upperBounds;
+		}
+
 		inProcess.add(upperBounds);
 
 		const prunedBounds = new Set(upperBounds.values().flatMap(upperBound => {
 			if(upperBound instanceof UnresolvedRTypeVariable) {
 				// If the upper bound is a type variable, we only care about its upper bound
-				if(!inProcess.has(upperBound) && !inProcess.has(upperBound.upperBound.types)) {
-					prune(upperBound, inProcess); // Prune the variable recursively w.r.t. its own bounds
-					upperBound.upperBound.types = pruneUpperBounds(upperBound.upperBound.types);
-				}
+				upperBound.upperBound.types = pruneUpperBounds(upperBound.upperBound.types);
 				return [upperBound];
 			} else if(upperBound instanceof UnresolvedRTypeIntersection) {
 				// If the upper bound is an intersection, we prune and include its types directly
@@ -247,6 +257,7 @@ export function prune(variable: UnresolvedRTypeVariable, inProcess: Set<Unresolv
 
 		inProcess.delete(upperBounds);
 
+		// console.debug('Returning from pruning upper bounds');
 		return prunedBounds;
 	}
 	
@@ -254,11 +265,13 @@ export function prune(variable: UnresolvedRTypeVariable, inProcess: Set<Unresolv
 	variable.upperBound.types = pruneUpperBounds(variable.upperBound.types);
 
 	inProcess.delete(variable);
+	
+	// console.debug('Returning from pruning variable', variable.id);
 }
 
 
 export function resolve(type: UnresolvedDataType, isUpperBound?: boolean, cache: Map<UnresolvedRTypeVariable, { lowerBound: DataType, upperBound: DataType, combined: DataType }> = new Map()): DataType {
-	// console.debug('Resolving type', inspect(type, { depth: null, colors: true }));
+	// console.debug('Resolving', inspect(type, { depth: null, colors: true }));
 
 	if(type instanceof UnresolvedRTypeVariable) {
 		const cachedType = cache.get(type);
@@ -455,7 +468,7 @@ export function subsumes(subtype: DataType | UnresolvedDataType, supertype: Data
 }
 
 export function unresolvedJoin(type1: UnresolvedDataType, type2: UnresolvedDataType): UnresolvedDataType {
-	// console.debug('Joining', type1, 'and', type2);
+	// console.debug('Joining (unresolved)', type1, 'and', type2);
 
 	if(type1 instanceof RTypeError) {
 		return type1;
@@ -645,7 +658,7 @@ export function join(type1: DataType, type2: DataType): DataType {
 }
 
 export function unresolvedMeet(type1: UnresolvedDataType, type2: UnresolvedDataType): UnresolvedDataType {
-	// console.debug('Meeting', type1, 'and', type2);
+	// console.debug('Meeting (unresolved)', type1, 'and', type2);
 
 	if(type1 instanceof RTypeError) {
 		return type1;

From 4f4b21006b48ae58cb69f23b402cdf5320652393 Mon Sep 17 00:00:00 2001
From: Lukas Rohde <lukas.rohde@silupe.de>
Date: Sat, 2 Aug 2025 15:56:44 +0200
Subject: [PATCH 121/153] refactor(typing): aggressively simplify `prune` and
 avoid repeated work

---
 src/typing/subtyping/infer.ts                 |   3 +-
 src/typing/subtyping/types.ts                 | 169 ++++++------------
 .../typing/subtyping/resolve.test.ts          |   2 +-
 3 files changed, 56 insertions(+), 118 deletions(-)

diff --git a/src/typing/subtyping/infer.ts b/src/typing/subtyping/infer.ts
index 1716dae3c0c..c8ab18ada20 100644
--- a/src/typing/subtyping/infer.ts
+++ b/src/typing/subtyping/infer.ts
@@ -56,9 +56,10 @@ function decorateTypeVariables<Info extends ParentInformation>(ast: NormalizedAs
 }
 
 function resolveTypeVariables<Info extends ParentInformation & UnresolvedTypeInfo>(ast: NormalizedAst<Info>): NormalizedAst<Omit<Info, keyof UnresolvedTypeInfo> & DataTypeInfo> {
+	const prunedVariables = new Set<UnresolvedRTypeVariable>();
 	return mapNormalizedAstInfo(ast, node => {
 		const { typeVariable, ...rest } = node.info;
-		const resolvedType = resolve(typeVariable);
+		const resolvedType = resolve(typeVariable, undefined, prunedVariables);
 		// if(node.lexeme === 'y') {
 		// 	console.debug('Resolving type variable', inspect(typeVariable, { depth: null, colors: true }), 'to', inspect(resolvedType, { depth: null, colors: true }));
 		// }
diff --git a/src/typing/subtyping/types.ts b/src/typing/subtyping/types.ts
index e23c0830842..bfcea08ccb6 100644
--- a/src/typing/subtyping/types.ts
+++ b/src/typing/subtyping/types.ts
@@ -154,123 +154,56 @@ export function constrain(subtype: UnresolvedDataType, supertype: UnresolvedData
 }
 
 
-export function prune(variable: UnresolvedRTypeVariable, inProcess: Set<UnresolvedRTypeVariable | Set<UnresolvedDataType>> = new Set()): void {
+export function prune(variable: UnresolvedRTypeVariable): void {
 	// console.debug('Pruning variable', variable.id);
 
-	if(inProcess.has(variable)) {
-		// console.debug('Variable', variable.id, 'is already in process');
-		return;
-	}
-
-	inProcess.add(variable);
-
-	function pruneLowerBounds(lowerBounds: Set<UnresolvedDataType>): Set<UnresolvedDataType> {
-		if(inProcess.has(lowerBounds)) {
-			return lowerBounds;
-		}
-
-		inProcess.add(lowerBounds);
-
-		const prunedBounds = new Set(lowerBounds.values().flatMap(lowerBound => {
-			if(lowerBound instanceof UnresolvedRTypeVariable) {
-				// If the lower bound is a type variable, we only care about its lower bound
-				lowerBound.lowerBound.types = pruneLowerBounds(lowerBound.lowerBound.types);
-				return [lowerBound];
-			} else if(lowerBound instanceof UnresolvedRTypeUnion) {
-				// If the lower bound is a union, we prune and include its types directly
-				if(inProcess.has(lowerBound.types)) {
-					// console.debug('Skipping already processed union', inspect(lowerBound, { depth: null, colors: true }));
-					return []; // If the union is already in process, we skip it to avoid infinite recursion
-				}
-				return pruneLowerBounds(lowerBound.types);
-			} else if(lowerBound instanceof UnresolvedRTypeIntersection) {
-				// If the lower bound is an intersection, we need to consider its upper bounds
-				if(variable.upperBound.types.size === 0) {
-					return [lowerBound]; // If there are no upper bounds, we keep the lower bound
-				}
-				// Otherwise, we prune it to only include types that subsume some upper bound
-				let upperBound: UnresolvedDataType = new UnresolvedRTypeUnion();
-				for(const type of variable.upperBound.types) {
-					upperBound = unresolvedJoin(upperBound, type);
+	// Prune lower bounds
+	for(const lowerBound of variable.lowerBound.types) {
+		if(lowerBound instanceof UnresolvedRTypeIntersection) {
+			// If the lower bound is an intersection, we need to consider its upper bounds
+			if(variable.upperBound.types.size === 0) {
+				continue; // If there are no upper bounds, we keep the lower bound
+			}
+			// Otherwise, we prune it to only include types that subsume some upper bound
+			let upperBound: UnresolvedDataType = new UnresolvedRTypeUnion();
+			for(const type of variable.upperBound.types) {
+				upperBound = unresolvedJoin(upperBound, type);
+			}
+			for(const type of lowerBound.types) {
+				if(variable.upperBound.types.values().some(upperBound => subsumes(type, upperBound))) {
+					constrain(type, upperBound);
+				} else {
+					lowerBound.types.delete(type);
 				}
-				return [new UnresolvedRTypeIntersection(...lowerBound.types.values().filter(type => {
-					if(variable.upperBound.types.values().some(upperBound => subsumes(type, upperBound))) {
-						// console.debug('\x1b[36m', 'Constraining', inspect(type, { depth: null, colors: true }), 'with upper bound', inspect(upperBound, { depth: null, colors: true }), '\x1b[0m');
-						constrain(type, upperBound);
-						return true;
-					}
-					return false;
-				}))];
-			} else {
-				return [lowerBound]; // If the lower bound is a concrete type, we keep it as is
 			}
-		}));
-
-		inProcess.delete(lowerBounds);
-
-		return prunedBounds;
+		}
 	}
-	function pruneUpperBounds(upperBounds: Set<UnresolvedDataType>): Set<UnresolvedDataType> {
-		// console.debug('Pruning upper bounds');
-
-		if(inProcess.has(upperBounds)) {
-			// console.debug('Upper bounds are already in process');
-			return upperBounds;
-		}
-
-		inProcess.add(upperBounds);
-
-		const prunedBounds = new Set(upperBounds.values().flatMap(upperBound => {
-			if(upperBound instanceof UnresolvedRTypeVariable) {
-				// If the upper bound is a type variable, we only care about its upper bound
-				upperBound.upperBound.types = pruneUpperBounds(upperBound.upperBound.types);
-				return [upperBound];
-			} else if(upperBound instanceof UnresolvedRTypeIntersection) {
-				// If the upper bound is an intersection, we prune and include its types directly
-				if(inProcess.has(upperBound.types)) {
-					// console.debug('Skipping already processed intersection', inspect(upperBound, { depth: null, colors: true }));
-					return []; // If the intersection is already in process, we skip it to avoid infinite recursion
-				}
-				return pruneUpperBounds(upperBound.types);
-			} else if(upperBound instanceof UnresolvedRTypeUnion) {
-				// If the upper bound is a union, we need to consider its lower bounds
-				if(variable.lowerBound.types.size === 0) {
-					return [upperBound]; // If there are no lower bounds, we keep the upper bound
-				}
-				// Otherwise, we prune it to only include types that are subsumed by some lower bound
-				let lowerBound: UnresolvedDataType = new UnresolvedRTypeIntersection();
-				for(const type of variable.lowerBound.types) {
-					lowerBound = unresolvedMeet(lowerBound, type);
+
+	// Prune upper bounds
+	for(const upperBound of variable.upperBound.types) {
+		if(upperBound instanceof UnresolvedRTypeUnion) {
+			// If the upper bound is a union, we need to consider its lower bounds
+			if(variable.lowerBound.types.size === 0) {
+				continue; // If there are no lower bounds, we keep the upper bound
+			}
+			// Otherwise, we prune it to only include types that are subsumed by some lower bound
+			let lowerBound: UnresolvedDataType = new UnresolvedRTypeIntersection();
+			for(const type of variable.lowerBound.types) {
+				lowerBound = unresolvedMeet(lowerBound, type);
+			}
+			for(const type of upperBound.types) {
+				if(variable.lowerBound.types.values().some(lowerBound => subsumes(lowerBound, type))) {
+					constrain(lowerBound, type);
+				} else {
+					upperBound.types.delete(type);
 				}
-				return [new UnresolvedRTypeUnion(...upperBound.types.values().filter(type => {
-					if(variable.lowerBound.types.values().some(lowerBound => subsumes(lowerBound, type))) {
-						// console.debug('\x1b[36m', 'Constraining', inspect(type, { depth: null, colors: true }), 'with lower bound', inspect(lowerBound, { depth: null, colors: true }), '\x1b[0m');
-						constrain(lowerBound, type);
-						return true;
-					}
-					return false;
-				}))];
-			} else {
-				return [upperBound]; // If the upper bound is a concrete type, we keep it
 			}
-		}));
-
-		inProcess.delete(upperBounds);
-
-		// console.debug('Returning from pruning upper bounds');
-		return prunedBounds;
+		}
 	}
-	
-	variable.lowerBound.types = pruneLowerBounds(variable.lowerBound.types);
-	variable.upperBound.types = pruneUpperBounds(variable.upperBound.types);
-
-	inProcess.delete(variable);
-	
-	// console.debug('Returning from pruning variable', variable.id);
 }
 
 
-export function resolve(type: UnresolvedDataType, isUpperBound?: boolean, cache: Map<UnresolvedRTypeVariable, { lowerBound: DataType, upperBound: DataType, combined: DataType }> = new Map()): DataType {
+export function resolve(type: UnresolvedDataType, isUpperBound?: boolean, prunedVariables: Set<UnresolvedRTypeVariable> = new Set(), cache: Map<UnresolvedRTypeVariable, { lowerBound: DataType, upperBound: DataType, combined: DataType }> = new Map()): DataType {
 	// console.debug('Resolving', inspect(type, { depth: null, colors: true }));
 
 	if(type instanceof UnresolvedRTypeVariable) {
@@ -290,10 +223,14 @@ export function resolve(type: UnresolvedDataType, isUpperBound?: boolean, cache:
 		}
 		cache.set(type, { lowerBound: new RTypeUnion(), upperBound: new RTypeIntersection(), combined: new RTypeVariable() }); // Prevent infinite recursion
 
-		prune(type); // Prune the variable to remove unnecessary bounds
+		if(!prunedVariables.has(type)) {
+			prune(type); // Prune the variable to remove unnecessary bounds
+			prunedVariables.add(type);
+		}
+
 
-		const lowerBound = resolve(type.lowerBound, false, cache);
-		const upperBound = resolve(type.upperBound, true, cache);
+		const lowerBound = resolve(type.lowerBound, false, prunedVariables, cache);
+		const upperBound = resolve(type.upperBound, true, prunedVariables, cache);
 
 		if(!subsumes(lowerBound, upperBound)) {
 			const errorType = new RTypeError(lowerBound, upperBound);
@@ -320,7 +257,7 @@ export function resolve(type: UnresolvedDataType, isUpperBound?: boolean, cache:
 	} else if(type instanceof UnresolvedRTypeUnion) {
 		let resolvedType: DataType = new RTypeUnion();
 		for(const subtype of type.types) {
-			const resolvedSubtype = resolve(subtype, isUpperBound, cache);
+			const resolvedSubtype = resolve(subtype, isUpperBound, prunedVariables, cache);
 			resolvedType = join(resolvedType, resolvedSubtype);
 		}
 
@@ -329,7 +266,7 @@ export function resolve(type: UnresolvedDataType, isUpperBound?: boolean, cache:
 	} else if(type instanceof UnresolvedRTypeIntersection) {
 		let resolvedType: DataType = new RTypeIntersection();
 		for(const subtype of type.types) {
-			const resolvedSubtype = resolve(subtype, isUpperBound, cache);
+			const resolvedSubtype = resolve(subtype, isUpperBound, prunedVariables, cache);
 			resolvedType = meet(resolvedType, resolvedSubtype);
 		}
 
@@ -340,9 +277,9 @@ export function resolve(type: UnresolvedDataType, isUpperBound?: boolean, cache:
 		prune(type.returnType);
 
 		const resolvedParameterTypes = new Map(type.parameterTypes.entries().toArray().map(([key, type]) => {
-			return [key, resolve(type, isUpperBound !== undefined ? !isUpperBound : undefined, cache)];
+			return [key, resolve(type, isUpperBound !== undefined ? !isUpperBound : undefined, prunedVariables, cache)];
 		}));
-		const resolvedReturnType = resolve(type.returnType, isUpperBound, cache);
+		const resolvedReturnType = resolve(type.returnType, isUpperBound, prunedVariables, cache);
 		const resolvedType = new RFunctionType(resolvedParameterTypes, resolvedReturnType);
 		
 		// console.debug('Returning', inspect(resolvedType, { depth: null, colors: true }), 'for resolved function type');
@@ -350,7 +287,7 @@ export function resolve(type: UnresolvedDataType, isUpperBound?: boolean, cache:
 	} else if(type instanceof UnresolvedRAtomicVectorType) {
 		prune(type.elementType);
 
-		const resolvedElementType = resolve(type.elementType, isUpperBound, cache);
+		const resolvedElementType = resolve(type.elementType, isUpperBound, prunedVariables, cache);
 		const resolvedType = new RAtomicVectorType(resolvedElementType);
 		
 		// console.debug('Returning', inspect(resolvedType, { depth: null, colors: true }), 'for resolved atomic vector type');
@@ -359,8 +296,8 @@ export function resolve(type: UnresolvedDataType, isUpperBound?: boolean, cache:
 		type.indexedElementTypes.values().forEach(elementType => prune(elementType));
 		prune(type.elementType);
 
-		const resolvedElementType = resolve(type.elementType, isUpperBound, cache);
-		const resolvedIndexedElementTypes = new Map(type.indexedElementTypes.entries().map(([indexOrName, elementType]) => [indexOrName, resolve(elementType, isUpperBound, cache)]));
+		const resolvedElementType = resolve(type.elementType, isUpperBound, prunedVariables, cache);
+		const resolvedIndexedElementTypes = new Map(type.indexedElementTypes.entries().map(([indexOrName, elementType]) => [indexOrName, resolve(elementType, isUpperBound, prunedVariables, cache)]));
 		const resolvedType = new RListType(resolvedElementType, resolvedIndexedElementTypes);
 		
 		// console.debug('Returning', inspect(resolvedType, { depth: null, colors: true }), 'for resolved list type');
diff --git a/test/functionality/typing/subtyping/resolve.test.ts b/test/functionality/typing/subtyping/resolve.test.ts
index b81bcfb325a..f019440ce61 100644
--- a/test/functionality/typing/subtyping/resolve.test.ts
+++ b/test/functionality/typing/subtyping/resolve.test.ts
@@ -458,7 +458,7 @@ describe('Constrain and resolve types', () => {
 	// 		}
 	// 	}
 	// 	}
-	test.only('Resolve cyclic type variable with upper union', () => {
+	test('Resolve cyclic type variable with upper union', () => {
 		const cache = new Map<UnresolvedDataType, Set<UnresolvedDataType>>();
 
 		const typeVar1 = new UnresolvedRTypeVariable();

From 1c731807ff7209f193bca7c55e68a1fe47f9430d Mon Sep 17 00:00:00 2001
From: Lukas Rohde <lukas.rohde@silupe.de>
Date: Mon, 4 Aug 2025 12:52:52 +0200
Subject: [PATCH 122/153] refactor(typing): refactor the datatype query format
 and its execution

---
 src/documentation/print-query-wiki.ts         |  4 +-
 .../datatype-query/datatype-query-executor.ts | 41 ++++---------------
 .../datatype-query/datatype-query-format.ts   |  4 +-
 3 files changed, 12 insertions(+), 37 deletions(-)

diff --git a/src/documentation/print-query-wiki.ts b/src/documentation/print-query-wiki.ts
index 7d1011fb978..148643a5855 100644
--- a/src/documentation/print-query-wiki.ts
+++ b/src/documentation/print-query-wiki.ts
@@ -500,8 +500,8 @@ ${codeBlock('r', exampleCode)}
 To see the type of the variable \`x\`, you can use the following query:
 ${
 	await showQuery(shell, exampleCode, [{
-		type:      'datatype',
-		criterion: '3@x'
+		type:     'datatype',
+		criteria: ['3@x']
 	}], { showCode: false })
 }
 `;
diff --git a/src/queries/catalog/datatype-query/datatype-query-executor.ts b/src/queries/catalog/datatype-query/datatype-query-executor.ts
index 72eba089589..8ec59db985a 100644
--- a/src/queries/catalog/datatype-query/datatype-query-executor.ts
+++ b/src/queries/catalog/datatype-query/datatype-query-executor.ts
@@ -6,12 +6,16 @@ import type { SingleSlicingCriterion } from '../../../slicing/criterion/parse';
 import { slicingCriterionToId } from '../../../slicing/criterion/parse';
 import { inferDataTypes } from '../../../typing/unification/infer';
 import { inferDataTypes as inferDataTypesUsingSubtyping } from '../../../typing/subtyping/infer';
-import type { DataTypeInfo } from '../../../typing/types';
 
 export function executeDatatypeQuery({ dataflow, ast }: BasicQueryData, queries: readonly DatatypeQuery[]): DatatypeQueryResult {
+	const start = Date.now();
+
 	const result: DatatypeQueryResult['inferredTypes'] = {};
-	const extractInferredTypeFromAst = (typedAst: NormalizedAst<DataTypeInfo>, criteria: SingleSlicingCriterion[]): void => {
-		for(const criterion of criteria) {
+	for(const query of queries) {
+		const typedAst = query.useSubtyping
+			? inferDataTypesUsingSubtyping(ast as NormalizedAst<ParentInformation & { typeVariable?: undefined }>, dataflow, query.useTurcotteTypes)
+			: inferDataTypes(ast as NormalizedAst<ParentInformation & { typeVariable?: undefined }>, dataflow);
+		for(const criterion of query.criteria ?? ast.idMap.keys().map(id => `$${id}` as SingleSlicingCriterion)) {
 			if(result[criterion] !== undefined) {
 				log.warn('Duplicate criterion in datatype query:', criterion);
 				continue;
@@ -25,39 +29,10 @@ export function executeDatatypeQuery({ dataflow, ast }: BasicQueryData, queries:
 			
 			result[criterion] = node.info.inferredType;
 		}
-	};
-	const [unificationQueries, subtypingQueries, turcotteQueries] = queries.reduce(([unificationGroup, subtypingGroup, turcotteGroup], query) => {
-		if(query.useSubtyping) {
-			if(query.useTurcotteTypes) {
-				turcotteGroup.push(query);
-			} else {
-				subtypingGroup.push(query);
-			}
-		} else {
-			unificationGroup.push(query);
-		}
-		return [unificationGroup, subtypingGroup, turcotteGroup];
-	}, [[], [], []] as [DatatypeQuery[], DatatypeQuery[], DatatypeQuery[]]);
-
-	const start = Date.now();
-
-	if(unificationQueries.length > 0) {
-		const typedAst = inferDataTypes(ast as NormalizedAst<ParentInformation & { typeVariable?: undefined }>, dataflow);
-		extractInferredTypeFromAst(typedAst, unificationQueries.map(query => query.criterion ?? '1:1'));
-	}
-
-	if(subtypingQueries.length > 0) {
-		const typedAst = inferDataTypesUsingSubtyping(ast as NormalizedAst<ParentInformation & { typeVariable?: undefined }>, dataflow, false);
-		extractInferredTypeFromAst(typedAst, subtypingQueries.map(query => query.criterion ?? '1:1'));
-	}
-
-	if(turcotteQueries.length > 0) {
-		const typedAst = inferDataTypesUsingSubtyping(ast as NormalizedAst<ParentInformation & { typeVariable?: undefined }>, dataflow, true);
-		extractInferredTypeFromAst(typedAst, turcotteQueries.map(query => query.criterion ?? '1:1'));
 	}
 
 	return {
 		'.meta':       { timing: Date.now() - start },
 		inferredTypes: result
 	};
-}
+}
\ No newline at end of file
diff --git a/src/queries/catalog/datatype-query/datatype-query-format.ts b/src/queries/catalog/datatype-query/datatype-query-format.ts
index abb87ce77a4..b39c524a735 100644
--- a/src/queries/catalog/datatype-query/datatype-query-format.ts
+++ b/src/queries/catalog/datatype-query/datatype-query-format.ts
@@ -13,7 +13,7 @@ import type { DataType } from '../../../typing/types';
  */
 export interface DatatypeQuery extends BaseQueryFormat {
 	readonly type:              'datatype';
-	readonly criterion?:        SingleSlicingCriterion;
+	readonly criteria?:         SingleSlicingCriterion[];
 	readonly useSubtyping?:     boolean;
 	readonly useTurcotteTypes?: boolean;
 }
@@ -38,7 +38,7 @@ export const DatatypeQueryDefinition = {
 	},
 	schema: Joi.object({
 		type:             Joi.string().valid('datatype').required().description('The type of the query.'),
-		criterion:        Joi.string().optional().description('The slicing criterion of the node to get the inferred data type for.'),
+		criteria:         Joi.array().items(Joi.string()).optional().description('The slicing criteria of the node to get the inferred data type for.'),
 		useSubtyping:     Joi.boolean().optional().default(false).description('Whether to use subtyping to infer the data type.'),
 		useTurcotteTypes: Joi.boolean().optional().default(true).description('Whether to use Turcotte types for inference.'),
 	}).description('Datatype query used to extract the inferred data type for a node in the normalized AST')

From 446d3c5cc7759d90302c8defcb65962a2ac6d522 Mon Sep 17 00:00:00 2001
From: Lukas Rohde <lukas.rohde@silupe.de>
Date: Mon, 4 Aug 2025 21:26:20 +0200
Subject: [PATCH 123/153] feat(typing): add compression for json results of
 datatype queries

---
 src/cli/repl/commands/repl-query.ts | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/src/cli/repl/commands/repl-query.ts b/src/cli/repl/commands/repl-query.ts
index a13ca7f2db7..86a83ec459d 100644
--- a/src/cli/repl/commands/repl-query.ts
+++ b/src/cli/repl/commands/repl-query.ts
@@ -11,6 +11,7 @@ import type { PipelineOutput } from '../../../core/steps/pipeline/pipeline';
 import { jsonReplacer } from '../../../util/json';
 import { asciiSummaryOfQueryResult } from '../../../queries/query-print';
 import type { KnownParser } from '../../../r-bridge/parser';
+import { compressToUTF16 } from 'lz-string';
 
 
 async function getDataflow(parser: KnownParser, remainingLine: string) {
@@ -95,7 +96,7 @@ export const queryStarCommand: ReplCommand = {
 	fn:           async(output, shell, remainingLine) => {
 		const results = await processQueryArgs(remainingLine, shell, output);
 		if(results) {
-			output.stdout(JSON.stringify(results.query, jsonReplacer));
+			output.stdout(compressToUTF16(JSON.stringify(results.query, jsonReplacer)));
 		}
 	}
 };

From 997c74e45ca35a0dff60d49673109913b21861b1 Mon Sep 17 00:00:00 2001
From: Lukas Rohde <lukas.rohde@silupe.de>
Date: Tue, 5 Aug 2025 16:56:48 +0200
Subject: [PATCH 124/153] feat(typing): add improved support for loading
 contextual types

---
 .../repl/commands/repl-turcotte-type-parse.ts |    6 +-
 .../datatype-query/datatype-query-executor.ts |   13 +-
 .../datatype-query/datatype-query-format.ts   |    2 +
 src/typing/adapter/interface.ts               |   17 +
 src/typing/adapter/load-type-signatures.ts    |   56 +
 src/typing/adapter/traced-function-types.csv  | 1620 +++++++++++++++++
 src/typing/adapter/traced-function-types.ts   |   92 +
 src/typing/adapter/turcotte-types.ts          |   17 +-
 src/typing/subtyping/infer.ts                 |   57 +-
 9 files changed, 1814 insertions(+), 66 deletions(-)
 create mode 100644 src/typing/adapter/interface.ts
 create mode 100644 src/typing/adapter/load-type-signatures.ts
 create mode 100644 src/typing/adapter/traced-function-types.csv
 create mode 100644 src/typing/adapter/traced-function-types.ts

diff --git a/src/cli/repl/commands/repl-turcotte-type-parse.ts b/src/cli/repl/commands/repl-turcotte-type-parse.ts
index 7086824e066..428c4cd4fd7 100644
--- a/src/cli/repl/commands/repl-turcotte-type-parse.ts
+++ b/src/cli/repl/commands/repl-turcotte-type-parse.ts
@@ -2,10 +2,7 @@ import type { ReplCommand } from './repl-main';
 import { findSource } from '../../../dataflow/internal/process/functions/call/built-in/built-in-source';
 import fs from 'fs';
 import csvParser from 'csv-parser';
-import type {
-	RohdeTypes,
-	TurcotteCsvRow
-} from '../../../typing/adapter/turcotte-types';
+import type { TurcotteCsvRow } from '../../../typing/adapter/turcotte-types';
 import {
 	dumpRohdeTypesFromTurcotte,
 	recoverRohdeTypesFromTurcotteFromDump,
@@ -13,6 +10,7 @@ import {
 } from '../../../typing/adapter/turcotte-types';
 import { splitAtEscapeSensitive } from '../../../util/text/args';
 import { compressToUTF16, decompressFromUTF16 } from 'lz-string';
+import type { RohdeTypes } from '../../../typing/adapter/interface';
 
 
 export const replTurcotteTypeParseCommand: ReplCommand = {
diff --git a/src/queries/catalog/datatype-query/datatype-query-executor.ts b/src/queries/catalog/datatype-query/datatype-query-executor.ts
index 8ec59db985a..6656c61361f 100644
--- a/src/queries/catalog/datatype-query/datatype-query-executor.ts
+++ b/src/queries/catalog/datatype-query/datatype-query-executor.ts
@@ -6,14 +6,25 @@ import type { SingleSlicingCriterion } from '../../../slicing/criterion/parse';
 import { slicingCriterionToId } from '../../../slicing/criterion/parse';
 import { inferDataTypes } from '../../../typing/unification/infer';
 import { inferDataTypes as inferDataTypesUsingSubtyping } from '../../../typing/subtyping/infer';
+import type { UnresolvedDataType } from '../../../typing/subtyping/types';
+// import { loadTracedTypes, loadTurcotteTypes } from '../../../typing/adapter/load-type-signatures';
 
 export function executeDatatypeQuery({ dataflow, ast }: BasicQueryData, queries: readonly DatatypeQuery[]): DatatypeQueryResult {
 	const start = Date.now();
 
 	const result: DatatypeQueryResult['inferredTypes'] = {};
 	for(const query of queries) {
+		const knownTypes = new Map<string, UnresolvedDataType>();
+		// TODO: Make the query asynchronous to be able to load the types
+		// if(query.useTurcotteTypes) {
+		// 	await loadTurcotteTypes(knownTypes);
+		// }
+		// if(query.useTracedTypes) {
+		// 	await loadTracedTypes(knownTypes);
+		// }
+
 		const typedAst = query.useSubtyping
-			? inferDataTypesUsingSubtyping(ast as NormalizedAst<ParentInformation & { typeVariable?: undefined }>, dataflow, query.useTurcotteTypes)
+			? inferDataTypesUsingSubtyping(ast as NormalizedAst<ParentInformation & { typeVariable?: undefined }>, dataflow, knownTypes)
 			: inferDataTypes(ast as NormalizedAst<ParentInformation & { typeVariable?: undefined }>, dataflow);
 		for(const criterion of query.criteria ?? ast.idMap.keys().map(id => `$${id}` as SingleSlicingCriterion)) {
 			if(result[criterion] !== undefined) {
diff --git a/src/queries/catalog/datatype-query/datatype-query-format.ts b/src/queries/catalog/datatype-query/datatype-query-format.ts
index b39c524a735..3be93dbbd45 100644
--- a/src/queries/catalog/datatype-query/datatype-query-format.ts
+++ b/src/queries/catalog/datatype-query/datatype-query-format.ts
@@ -16,6 +16,7 @@ export interface DatatypeQuery extends BaseQueryFormat {
 	readonly criteria?:         SingleSlicingCriterion[];
 	readonly useSubtyping?:     boolean;
 	readonly useTurcotteTypes?: boolean;
+	readonly useTracedTypes?:   boolean;
 }
 
 export interface DatatypeQueryResult extends BaseQueryResult {
@@ -41,5 +42,6 @@ export const DatatypeQueryDefinition = {
 		criteria:         Joi.array().items(Joi.string()).optional().description('The slicing criteria of the node to get the inferred data type for.'),
 		useSubtyping:     Joi.boolean().optional().default(false).description('Whether to use subtyping to infer the data type.'),
 		useTurcotteTypes: Joi.boolean().optional().default(true).description('Whether to use Turcotte types for inference.'),
+		useTracedTypes:   Joi.boolean().optional().default(true).description('Whether to use our manually traced types for inference.')
 	}).description('Datatype query used to extract the inferred data type for a node in the normalized AST')
 } as const satisfies SupportedQuery<'datatype'>;
diff --git a/src/typing/adapter/interface.ts b/src/typing/adapter/interface.ts
new file mode 100644
index 00000000000..6345cf20d1e
--- /dev/null
+++ b/src/typing/adapter/interface.ts
@@ -0,0 +1,17 @@
+import type { UnresolvedDataType, UnresolvedRFunctionType } from '../subtyping/types';
+
+export interface RohdeFunctionTypeInformation {
+    readonly name:    string;
+    readonly package: string;
+    readonly types:   readonly UnresolvedRFunctionType[]
+}
+
+export interface RohdeConstantTypeInformation {
+    readonly name:    string;
+    readonly package: string;
+    readonly type:    UnresolvedDataType;
+}
+
+export interface RohdeTypes {
+    readonly info: (RohdeFunctionTypeInformation | RohdeConstantTypeInformation)[];
+}
\ No newline at end of file
diff --git a/src/typing/adapter/load-type-signatures.ts b/src/typing/adapter/load-type-signatures.ts
new file mode 100644
index 00000000000..1649ef7920e
--- /dev/null
+++ b/src/typing/adapter/load-type-signatures.ts
@@ -0,0 +1,56 @@
+import csvParser from 'csv-parser';
+import type { UnresolvedDataType } from '../subtyping/types';
+import { UnresolvedRTypeIntersection } from '../subtyping/types';
+import type { TraceCsvRow } from './traced-function-types';
+import { extractTypesFromTraceData } from './traced-function-types';
+import { turcotte2RohdeTypes, type TurcotteCsvRow } from './turcotte-types';
+import fs from 'fs';
+
+export async function loadTurcotteTypes(typeMap: Map<string, UnresolvedDataType> = new Map()): Promise<Map<string, UnresolvedDataType>> {
+	const data: TurcotteCsvRow[] = [];
+	await new Promise(resolve => {
+		fs.createReadStream('src/typing/adapter/turcotte-types.csv', { encoding: 'utf-8' })
+			.pipe(csvParser({ separator: ',' }))
+			.on('data', (row: TurcotteCsvRow) => {
+				data.push(row);
+			})
+			.on('end', () => resolve(null));
+	});
+	
+	const rohdeTypes = turcotte2RohdeTypes(data);
+	for(const info of rohdeTypes.info) {
+		const label = info.name; //`${info.package}::${info.name}`;
+		if('type' in info) {
+			typeMap.set(label, info.type);
+		}
+		if('types' in info) {
+			const type = info.types.length === 1 ? info.types[0] : new UnresolvedRTypeIntersection(...info.types);
+			typeMap.set(label, type);
+		}
+	}
+
+	return typeMap;
+}
+
+export async function loadTracedTypes(typeMap: Map<string, UnresolvedDataType> = new Map()): Promise<Map<string, UnresolvedDataType>> {
+	const data: TraceCsvRow[] = [];
+	await new Promise(resolve => {
+		fs.createReadStream('src/typing/adapter/traced-function-types.csv', { encoding: 'utf-8' })
+			.pipe(csvParser({ separator: ',' }))
+			.on('data', (row: TraceCsvRow) => {
+				data.push(row);
+			})
+			.on('end', () => resolve(null));
+	});
+	
+	console.log(data.length);
+	const [functionTypeInfos, contributions] = extractTypesFromTraceData(data);
+	console.log(contributions);
+	for(const info of functionTypeInfos) {
+		const label = info.name;
+		const type = info.types.length === 1 ? info.types[0] : new UnresolvedRTypeIntersection(...info.types);
+		typeMap.set(label, type);
+	}
+
+	return typeMap;
+}
\ No newline at end of file
diff --git a/src/typing/adapter/traced-function-types.csv b/src/typing/adapter/traced-function-types.csv
new file mode 100644
index 00000000000..d3f82fc3767
--- /dev/null
+++ b/src/typing/adapter/traced-function-types.csv
@@ -0,0 +1,1620 @@
+file,fname,arg_types,ret_type
+'stats::asOneSidedFormula','identical',"'formula','formula'",'logical',
+'stats::asOneSidedFormula','as.name',"'character'",'name',
+'stats::r2dtable','c',"'double','double','double','double'",'v<double>',
+'stats::r2dtable','c',"'character','character'",'v<character>',
+'stats::r2dtable','list',"'v<character>','v<character>'",'list',
+'stats::r2dtable','sum',"'v<double>'",'double',
+'stats::r2dtable','sapply',"'list','function'",'v<double>',
+'stats::r2dtable','>=',"'v<double>','double'",'v<logical>',
+'stats::r2dtable','sum',"'v<logical>'",'integer',
+'stats::r2dtable','/',"'integer','double'",'double',
+'stats::drop.terms',':',"'double','double'",'v<integer>',
+'stats::drop.terms','-',"'double'",'double',
+'stats::confint.lm','/',"'double','v<double>'",'v<double>',
+'stats::confint.lm','list',"'v<double>','v<double>','v<double>','v<double>','v<double>'",'list',
+'stats::confint.lm','list','','list',
+'stats::confint.lm','lm',"'formula','list'",'list',
+'stats::confint.lm','c',"'double','double','double','double','double','double','double','double','double'",'v<double>',
+'stats::confint.lm','list',"'v<double>','integer','integer'",'list',
+'stats::confint.lm','glm',"'formula','list'",'list',
+'stats::is.mts','c',"'double','double'",'v<double>',
+'stats::is.mts','print',"'integer','logical'",'integer',
+'stats::is.mts','+',"'double','v<double>'",'v<double>',
+'stats::is.mts','plot',"'double'",'NULL',
+'stats::is.mts','plot',"'double','double','double','character','character'",'NULL',
+'stats::nlminb','rep',"'double','double'",'v<double>',
+'stats::nlminb','length',"'v<double>'",'integer',
+'stats::nlminb','-',"'v<double>','v<double>'",'v<double>',
+'stats::nlminb','c',"'double','double','double','double','double'",'v<double>',
+'stats::nlminb','*',"'double','v<double>'",'v<double>',
+'stats::nlminb','*',"'double','double'",'double',
+'stats::nlminb','-',"'double','double'",'double',
+'stats::nlminb','+',"'double','double'",'double',
+'stats::nlminb','-',"'integer','double'",'double',
+'stats::nlminb','c',"'double','v<double>'",'v<double>',
+'stats::nlminb','-',"'integer'",'integer',
+'stats::nlminb','*',"'v<double>','v<double>'",'v<double>',
+'stats::nlminb','list',"'double'",'list',
+'stats::alias','list',"'v<double>','integer','integer','integer','integer'",'list',
+'stats::gaussian','str',"'list'",'NULL',
+'stats::gaussian','/',"'double','double'",'double',
+'stats::gaussian','seq',"'double','double','double'",'v<double>',
+'stats::gaussian','plot',"'v<double>','v<double>','character'",'NULL',
+'stats::gaussian','+',"'v<double>','v<double>'",'v<double>',
+'stats::gaussian','/',"'v<double>','double'",'v<double>',
+'stats::gaussian','/',"'v<double>','v<double>'",'v<double>',
+'stats::gaussian','data.frame',"'integer','integer','v<double>'",'list',
+'stats::gaussian','glm',"'formula','list','list'",'list',
+'stats::gaussian','anova',"'list','character'",'list',
+'stats::gaussian','summary',"'list'",'list',
+'stats::gaussian','anova',"'list','double','character'",'list',
+'stats::gaussian','summary',"'list','double'",'list',
+'stats::gaussian','paste0',"'character','double','character'",'character',
+'stats::gaussian','list',"'function','function','function','function','character'",'list',
+'stats::gaussian','==',"'integer','double'",'logical',
+'stats::gaussian','list',"'v<integer>','v<double>'",'list',
+'stats::gaussian','glm',"'formula','function'",'list',
+'stats::gaussian','glm',"'formula','list','v<double>'",'list',
+'stats::ls.diag','as.numeric',"'integer'",'v<double>',
+'stats::ls.diag','<',"'double','double'",'logical',
+'stats::ls.diag','plot',"'v<double>','v<double>','v<double>'",'NULL',
+'stats::mahalanobis','==',"'v<double>','v<double>'",'v<logical>',
+'stats::mahalanobis','plot',"'list','character'",'NULL',
+'stats::rmultinom','c',"'double','double','double'",'v<double>',
+'stats::rmultinom','<=',"'v<double>','double'",'v<logical>',
+'stats::rmultinom',':',"'double','double'",'integer',
+'stats::rmultinom','-',"'integer','v<double>'",'v<double>',
+'stats::rmultinom','list',"'v<character>','NULL'",'list',
+'stats::dpois','+',"'double','v<integer>'",'v<double>',
+'stats::dpois','-',"'v<double>'",'v<double>',
+'stats::dpois','max',"'v<integer>'",'integer',
+'stats::dpois',':',"'double','integer'",'v<integer>',
+'stats::dpois','factor',"'v<integer>','v<integer>'",'integer',
+'stats::dpois','table',"'integer'",'integer',
+'stats::dpois','*',"'double','v<integer>'",'v<double>',
+'stats::dpois','-',"'double','v<double>'",'v<double>',
+'stats::dpois','plot',"'v<double>','v<double>','character','character','character'",'NULL',
+'stats::dpois','identical',"'double','double'",'logical',
+'stats::numericDeriv','str',"'double'",'NULL',
+'stats::numericDeriv','c',"'double'",'v<double>',
+'stats::makepredictcall','plot',"'list','character','character'",'NULL',
+'stats::makepredictcall','data.frame',"'v<double>'",'list',
+'stats::makepredictcall','predict',"'list','list'",'v<double>',
+'stats::qlogis','var',"'v<double>'",'double',
+'stats::nlm','-',"'v<double>','v<integer>'",'v<double>',
+'stats::nlm','c',"'double'",'double',
+'stats::nlm','length',"'double'",'integer',
+'stats::nlm',':',"'double','integer'",'integer',
+'stats::nlm','-',"'double','integer'",'double',
+'stats::nlm','sum',"'double'",'double',
+'stats::nextn','table',"'v<integer>'",'integer',
+'stats::nextn','-',"'v<integer>','v<integer>'",'v<integer>',
+'stats::nextn','plot',"'v<integer>','v<integer>','character','double','double'",'NULL',
+'stats::nls','list',"'v<double>','v<double>'",'list',
+'stats::nls','list',"'double','double'",'list',
+'stats::nls','list',"'double','double','double'",'list',
+'stats::nls','==',"'integer','character'",'v<logical>',
+'stats::nls','list',"'double','v<double>','v<double>'",'list',
+'stats::nls','+',"'v<double>','double'",'v<double>',
+'stats::nls','list',"'v<double>','v<integer>'",'list',
+'stats::nls','list',"'double','logical'",'list',
+'stats::nls','-',"'v<integer>'",'v<integer>',
+'stats::nls','/',"'v<integer>','double'",'v<double>',
+'stats::nls','predict',"'list'",'v<double>',
+'stats::plot.stepfun','paste',"'character','v<double>'",'v<character>',
+'stats::dummy.coef','list',"'v<double>','integer'",'list',
+'stats::dummy.coef','list',"'v<double>','integer','integer','integer'",'list',
+'stats::ftable','dim',"'double'",'v<integer>',
+'stats::ftable','==',"'v<integer>','v<double>'",'v<logical>',
+'stats::ftable','c',"'character','character','character','character'",'v<character>',
+'stats::as.formula','class',"'formula'",'character',
+'stats::as.formula','typeof',"'formula'",'character',
+'stats::as.formula','paste0',"'character','v<integer>'",'v<character>',
+'stats::as.formula','paste',"'v<character>','character'",'character',
+'stats::as.formula','paste',"'character','character'",'character',
+'stats::pairwise.wilcox.test','factor',"'v<integer>','v<character>'",'integer',
+'stats::time','as.vector',"'double'",'v<double>',
+'stats::mantelhaen.test','c',"'double','double','double','double','double','double','double','double','double','double','double','double','double','double','double','double','double','double','double','double'",'v<double>',
+'stats::mantelhaen.test','c',"'character','character','character','character','character'",'v<character>',
+'stats::mantelhaen.test','list',"'v<character>','v<character>','v<character>'",'list',
+'stats::mantelhaen.test','array',"'v<double>','v<double>','list'",'double',
+'stats::mantelhaen.test','apply',"'double','double','function'",'v<double>',
+'stats::mantelhaen.test','-',"'v<double>','double'",'v<double>',
+'stats::mantelhaen.test','c',"'double','double','double','double','double','double','double','double','double','double','double','double','double','double','double','double','double','double','double','double','double','double','double','double','double','double','double','double','double','double','double','double'",'v<double>',
+'stats::mantelhaen.test','as.table',"'double'",'double',
+'stats::dwilcox','plot',"'v<integer>','v<double>','character','character','character'",'NULL',
+'stats::dwilcox','-',"'v<integer>','double'",'v<double>',
+'stats::dwilcox','paste',"'character','double'",'character',
+'stats::dwilcox','paste',"'character','character','character'",'character',
+'stats::dwilcox','print',"'integer'",'integer',
+'stats::dwilcox','names',"'integer'",'v<character>',
+'stats::dwilcox','as.numeric',"'v<character>'",'v<double>',
+'stats::ar','predict',"'list','double'",'list',
+'stats::oneway.test','anova',"'list'",'list',
+'stats::fligner.test','plot',"'formula','list'",'NULL',
+'stats::bw.bcv','plot',"'list'",'NULL',
+'stats::bw.bcv','c',"'character','character','character','character','character','character'",'v<character>',
+'stats::predict.glm','rep',"'v<integer>','double'",'v<integer>',
+'stats::predict.glm','c',"'double','double','double','double','double','double','double','double','double','double','double','double'",'v<double>',
+'stats::predict.glm','rep',"'v<character>','v<double>'",'v<character>',
+'stats::predict.glm','factor',"'v<character>'",'integer',
+'stats::predict.glm','plot',"'v<double>','v<double>','character','character','character','character'",'NULL',
+'stats::predict.glm','as.character',"'integer'",'v<character>',
+'stats::predict.glm','rep',"'character','integer'",'v<character>',
+'stats::predict.glm','factor',"'v<character>','v<character>'",'integer',
+'stats::predict.glm','data.frame',"'v<double>','integer'",'list',
+'stats::predict.glm','list',"'integer','v<double>'",'list',
+'stats::predict.glm','predict',"'list','list','character'",'v<double>',
+'stats::rWishart','mean',"'v<double>'",'double',
+'stats::logLik','list',"'v<integer>'",'list',
+'stats::logLik','lm',"'formula'",'list',
+'stats::logLik','list',"'v<double>','v<double>','v<double>','v<double>','v<double>','v<double>','v<double>'",'list',
+'stats::logLik','list',"'v<double>','integer','v<double>'",'list',
+'stats::AIC','list',"'v<double>','v<double>','v<integer>','v<integer>','v<double>','v<double>'",'list',
+'stats::arima','list',"'v<double>'",'list',
+'stats::arima','c',"'logical','logical','double','double','double'",'v<double>',
+'stats::plot.ts','plot',"'double','double','character'",'NULL',
+'stats::plot.ts','plot',"'double','double','character','character','character','logical'",'NULL',
+'stats::model.extract','identical',"'v<double>','v<double>'",'logical',
+'stats::model.extract','names',"'list'",'v<character>',
+'stats::stat.anova','print',"'list'",'list',
+'stats::qbeta','==',"'double','double'",'logical',
+'stats::factanal','c',"'double','double','double','double','double','double','double','double','double','double','double','double','double','double','double','double','double','double'",'v<double>',
+'stats::factanal','list',"'v<double>','v<double>','v<double>','v<double>','v<double>','v<double>'",'list',
+'stats::summary.aov','list',"'list','list'",'list',
+'stats::summary.aov','summary',"'list','list'",'list',
+'stats::summary.aov','list',"'double','v<integer>'",'list',
+'stats::summary.aov','list',"'list'",'list',
+'stats::summary.aov','summary',"'list','list','logical'",'list',
+'stats::optimHess','plot',"'function','double','double','double','character'",'list',
+'stats::optimHess','c',"'v<integer>','double'",'v<double>',
+'stats::optimHess','plot',"'v<double>','v<double>','character','double','character','character','character','logical'",'NULL',
+'stats::optimHess','+',"'v<integer>','double'",'v<double>',
+'stats::optimHess','list',"'double','double','logical','double'",'list',
+'stats::optimHess','seq',"'double','double'",'v<integer>',
+'stats::optimHess','sample',"'v<integer>','double','logical'",'v<integer>',
+'stats::optimHess','list',"'logical'",'list',
+'stats::cooks.distance','which',"'v<logical>'",'v<integer>',
+'stats::cooks.distance','plot',"'formula'",'NULL',
+'stats::cooks.distance','plot',"'list','double'",'NULL',
+'stats::cooks.distance','cat',"'character'",'NULL',
+'stats::cooks.distance','vapply',"'v<integer>','function','double'",'v<double>',
+'stats::cooks.distance','c',"'double','double','double','double','double','double'",'v<double>',
+'stats::dnorm','plot',"'function','double','double','character'",'list',
+'stats::C','attributes',"'integer'",'list',
+'stats::D','c',"'integer','integer'",'v<integer>',
+'stats::D','c',"'character'",'character',
+'stats::D','list',"'NULL','character'",'list',
+'stats::D','list',"'NULL','v<character>'",'list',
+'stats::D','*',"'v<double>','double'",'v<double>',
+'stats::D','c',"'character','character','character'",'v<character>',
+'stats::D','identical',"'call','call'",'logical',
+'stats::lowess','paste',"'character','v<character>'",'v<character>',
+'stats::lowess','c',"'v<character>'",'v<character>',
+'stats::optimize','print',"'double'",'double',
+'stats::optimize','>',"'v<double>','double'",'v<logical>',
+'stats::optimize','<',"'v<double>','double'",'v<logical>',
+'stats::optimize','ifelse',"'v<logical>','v<double>','double'",'v<double>',
+'stats::optimize','plot',"'function','double','double','v<integer>','double'",'list',
+'stats::optimize','>',"'double','double'",'logical',
+'stats::optimize','ifelse',"'logical','double','double'",'double',
+'stats::lag.plot','c',"'v<integer>','v<integer>'",'v<integer>',
+'stats::splinefunH','paste',"'character','double','character'",'character',
+'stats::splinefunH','plot',"'v<integer>','v<double>','character'",'NULL',
+'stats::splinefunH','findInterval',"'v<double>','v<double>'",'v<integer>',
+'stats::splinefunH','table',"'v<double>'",'integer',
+'stats::splinefunH','>',"'integer','double'",'logical',
+'stats::splinefunH','match',"'v<double>','v<double>'",'v<integer>',
+'stats::splinefunH','range',"'v<double>'",'v<double>',
+'stats::splinefunH','tapply',"'v<double>','v<integer>','function','logical'",'list',
+'stats::splinefunH','sort',"'v<double>'",'v<double>',
+'stats::splinefunH','==',"'v<double>','double'",'v<logical>',
+'stats::splinefunH','list',"'character','function'",'list',
+'stats::splinefunH','mean',"'double'",'double',
+'stats::splinefunH','plot',"'v<double>','v<double>'",'NULL',
+'stats::splinefunH','paste0',"'character','v<character>','character'",'v<character>',
+'stats::splinefunH','plot',"'v<double>','v<double>','character','double','double','character'",'NULL',
+'stats::df','c',"'v<double>','double','v<integer>'",'v<double>',
+'stats::glm.control','glm',"'formula','list','logical','double'",'list',
+'stats::pgamma','table',"'v<logical>'",'integer',
+'stats::addmargins','sample',"'v<character>','double','logical'",'v<character>',
+'stats::addmargins','table',"'v<character>','v<character>','v<character>'",'integer',
+'stats::addmargins','list',"'function','function'",'list',
+'stats::addmargins','list',"'list','function'",'list',
+'stats::addmargins','min',"'v<integer>'",'integer',
+'stats::addmargins','list',"'function','list'",'list',
+'stats::addmargins','sum',"'v<integer>'",'integer',
+'stats::addmargins','min',"'v<double>'",'double',
+'stats::addmargins','max',"'v<double>'",'double',
+'stats::addmargins','table',"'v<character>','v<character>'",'integer',
+'stats::addmargins','apply',"'integer','double','function'",'v<integer>',
+'stats::addmargins','list',"'function'",'list',
+'stats::addmargins','table',"'v<integer>','v<integer>'",'integer',
+'stats::dexp','plot',"'v<double>','v<integer>','character'",'NULL',
+'stats::ave','mean',"'v<double>','double'",'double',
+'stats::ave','plot',"'v<double>','character'",'NULL',
+'stats::ave','median',"'v<double>'",'double',
+'stats::loess.smooth','list',"'character','double','double'",'list',
+'stats::line','plot',"'formula','character'",'NULL',
+'stats::line','c',"'v<double>','double','double','double'",'v<double>',
+'stats::line','data.frame',"'v<double>','v<double>'",'list',
+'stats::qqline','c',"'double','double','double','double','double','double','double','double','double','double','double','double','double','double','double','double','double','double','double','double','double','double','double','double','double','double','double','double','double','double','double','double','double','double','double','double','double','double','double','double','double','double','double','double','double','double','double','double','double','double','double','double','double','double','double','double','double','double','double','double','double','double','double','double','double','double','double','double','double','double','double','double','double','double','double','double','double','double','double','double'",'v<double>',
+'stats::qqline','list',"'character','logical'",'list',
+'stats::qqline','list',"'logical','character'",'list',
+'stats::get_all_vars','is.data.frame',"'list'",'logical',
+'stats::get_all_vars','identical',"'list','list'",'logical',
+'stats::get_all_vars','ncol',"'list'",'integer',
+'stats::get_all_vars','+',"'integer','double'",'double',
+'stats::dt','c',"'v<integer>','double','double','double','double'",'v<double>',
+'stats::dt','plot',"'function','double','double','v<double>','character','character'",'list',
+'stats::dt','+',"'v<integer>','v<double>'",'v<double>',
+'stats::dt','/',"'v<integer>','v<double>'",'v<double>',
+'stats::ks.test','c',"'v<double>','v<double>'",'v<double>',
+'stats::ks.test','t.test',"'v<double>','v<double>','character'",'list',
+'stats::ks.test','wilcox.test',"'v<double>','v<double>','character'",'list',
+'stats::ks.test','c',"'double','double','double','double','double','double','double'",'v<double>',
+'stats::ks.test','list',"'v<integer>','v<integer>'",'list',
+'stats::ks.test','%in%',"'v<integer>','v<double>'",'v<logical>',
+'stats::cor','var',"'v<integer>'",'double',
+'stats::cor','var',"'v<integer>','v<integer>'",'double',
+'stats::cor','cor',"'v<integer>','v<integer>'",'double',
+'stats::cor','colnames',"'list'",'v<character>',
+'stats::ecdf','quantile',"'v<double>'",'v<double>',
+'stats::ecdf','unique',"'v<double>'",'v<double>',
+'stats::ecdf','plot',"'v<double>','v<double>','character','double'",'NULL',
+'stats::dendrapply','attributes',"'list'",'list',
+'stats::dendrapply','list',"'character','double'",'list',
+'stats::dendrapply','c',"'NULL','list'",'list',
+'stats::rsignrank','c',"'v<integer>','double','double'",'v<double>',
+'stats::rsignrank','plot',"'v<double>','v<double>','character','character'",'NULL',
+'stats::rsignrank','c',"'double','double','double','double','v<integer>','double','double','double','double','double','double','double','double','double','double','double','double','double','double','double','double','double','double','double'",'v<double>',
+'stats::rsignrank','rev',"'v<double>'",'v<double>',
+'stats::rsignrank','c',"'v<double>','v<double>','double'",'v<double>',
+'stats::rsignrank','c',"'v<integer>','v<integer>','v<integer>'",'v<integer>',
+'stats::rsignrank','==',"'v<double>','v<integer>'",'v<logical>',
+'stats::as.dist','==',"'double','double'",'v<logical>',
+'stats::SSweibull','plot',"'formula','list','v<double>','character'",'NULL',
+'stats::SSweibull','c',"'list','v<double>'",'list',
+'stats::mvfft','length',"'v<integer>'",'integer',
+'stats::mvfft','/',"'v<complex>','integer'",'v<complex>',
+'stats::mvfft','length',"'v<complex>'",'integer',
+'stats::mvfft','*',"'double','complex'",'complex',
+'stats::mvfft','*',"'complex','v<integer>'",'v<complex>',
+'stats::mvfft','*',"'v<complex>','double'",'v<complex>',
+'stats::mvfft','*',"'v<complex>','v<complex>'",'v<complex>',
+'stats::mvfft','sum',"'v<complex>'",'complex',
+'stats::mvfft','vapply',"'v<integer>','function','complex'",'v<complex>',
+'stats::mvfft','-',"'v<complex>','v<complex>'",'v<complex>',
+'stats::mvfft','+',"'v<complex>','v<complex>'",'v<complex>',
+'stats::.checkMFClasses','sapply',"'list','function'",'v<character>',
+'stats::.checkMFClasses','identical',"'v<character>','v<character>'",'logical',
+'stats::.checkMFClasses','is.null',"'NULL'",'logical',
+'stats::effects','list',"'v<double>','double'",'list',
+'stats::reorder','names',"'double'",'v<character>',
+'stats::reorder','order',"'double'",'v<integer>',
+'stats::reorder','rev',"'v<integer>'",'v<integer>',
+'stats::eff.aovlist','factor',"'v<double>'",'integer',
+'stats::eff.aovlist','data.frame',"'integer','integer','integer','integer','v<double>'",'list',
+'stats::glm.fit','*',"'double','integer'",'double',
+'stats::glm.fit','list',"'v<double>','v<double>','integer','v<double>'",'list',
+'stats::glm.fit','glm',"'formula','function','list'",'list',
+'stats::glm.fit','data.frame',"'v<double>','v<double>','v<double>'",'list',
+'stats::glm.fit','glm',"'formula','list','function'",'list',
+'stats::glm.fit','list',"'v<double>','v<double>','v<double>'",'list',
+'stats::setNames','setNames',"'v<integer>','v<character>'",'v<integer>',
+'stats::setNames','setNames',"'v<character>'",'v<character>',
+'stats::model.matrix','data.frame',"'integer','integer'",'list',
+'stats::model.matrix','list',"'integer','integer'",'list',
+'stats::model.matrix','list',"'character'",'list',
+'stats::.nknots.smspl','plot',"'formula','list','character'",'NULL',
+'stats::.nknots.smspl','==',"'v<double>','integer'",'logical',
+'stats::.nknots.smspl','c',"'v<integer>','v<double>'",'v<double>',
+'stats::.nknots.smspl','c',"'v<integer>','v<double>','v<double>'",'v<double>',
+'stats::.nknots.smspl','c',"'v<integer>','double','double','v<integer>','v<double>','v<double>'",'v<double>',
+'stats::.nknots.smspl','seq',"'double','integer','double'",'v<double>',
+'stats::.nknots.smspl','plot',"'v<double>','character','double'",'NULL',
+'stats::.nknots.smspl','predict',"'list','v<double>'",'list',
+'stats::.nknots.smspl','as.numeric',"'v<integer>'",'v<double>',
+'stats::.nknots.smspl','list',"'logical','double','double'",'list',
+'stats::SSasymp','plot',"'v<double>','v<double>','character','logical','v<double>','v<double>','character','character','double','call'",'NULL',
+'stats::predict','cat',"'character','character','v<character>','character'",'NULL',
+'stats::t.test','c',"'v<integer>'",'v<integer>',
+'stats::t.test','t.test',"'v<integer>','v<integer>'",'list',
+'stats::t.test','t.test',"'v<integer>','v<double>'",'list',
+'stats::t.test','t.test',"'v<double>','v<double>'",'list',
+'stats::t.test','t.test',"'formula','list'",'list',
+'stats::t.test','t.test',"'v<double>'",'list',
+'stats::t.test','reshape',"'list','character','character','character'",'list',
+'stats::t.test','t.test',"'v<double>','v<double>','logical'",'list',
+'stats::cophenetic','cor',"'double','double'",'double',
+'stats::cophenetic','c',"'double','double','double','double','double','double','double','double','double','double'",'v<double>',
+'stats::spec.pgram','plot',"'list','character'",'list',
+'stats::interaction.plot','tapply',"'v<double>','v<double>','function'",'double',
+'stats::interaction.plot','factor',"'v<double>','v<integer>'",'integer',
+'stats::estVar','c',"'double','double','double','double','double','double','double','double','double','double','double','double','double','double','double','double','double','double','double','double','double','double','double','double','double','double','double','double','double','double','double','double','double','double','double','double','double','double','double','double','double','double','double','double','double','double','double','double','double','double','double','double','double','double','double','double','double','double','double','double'",'v<double>',
+'stats::estVar','list',"'v<integer>','v<character>'",'list',
+'stats::quantile','c',"'double','double','double','double','double','double','double','logical'",'v<double>',
+'stats::quantile','quantile',"'v<double>','v<double>'",'v<double>',
+'stats::quantile','quantile',"'v<double>','v<double>','double'",'v<double>',
+'stats::quantile','quantile',"'v<double>','v<double>','integer'",'v<double>',
+'stats::quantile','quantile',"'v<double>','v<integer>','double'",'v<double>',
+'stats::quantile','quantile',"'v<double>','v<integer>','integer'",'v<double>',
+'stats::quantile','quantile',"'v<complex>','v<double>','double'",'v<complex>',
+'stats::quantile','quantile',"'v<complex>','v<double>','integer'",'v<complex>',
+'stats::wilcox.test','wilcox.test',"'v<double>','v<double>','logical','character'",'list',
+'stats::wilcox.test','wilcox.test',"'v<double>','character'",'list',
+'stats::wilcox.test','wilcox.test',"'v<double>','character','logical','logical'",'list',
+'stats::wilcox.test','wilcox.test',"'formula','list'",'list',
+'stats::wilcox.test','wilcox.test',"'v<double>','v<double>','character','logical','logical'",'list',
+'stats::wilcox.test','wilcox.test',"'v<double>','v<double>','logical'",'list',
+'stats::wilcox.test','%in%',"'integer','v<double>'",'v<logical>',
+'stats::complete.cases','is.na',"'v<integer>'",'v<logical>',
+'stats::approx','plot',"'function','double','double','character','logical','double','double'",'list',
+'stats::approx','c',"'double','logical','v<integer>'",'v<double>',
+'stats::approx','data.frame',"'list'",'list',
+'stats::approx','list',"'double','double','v<integer>','v<integer>'",'list',
+'stats::approx','c',"'logical','logical'",'v<logical>',
+'stats::approx','sapply',"'v<character>','function','character'",'double',
+'stats::approx','sapply',"'list','function','character'",'double',
+'stats::approx','dimnames',"'double'",'list',
+'stats::approx','is.na',"'double'",'logical',
+'stats::approx','c',"'logical','double','double','double','double','double','double','double','logical','logical','double','double','logical','logical','double','double','double','logical','logical','double','double','double','double','double','double','double','logical','logical','double','logical','logical','logical','double','double','double','logical','double','double','double','double','double','double','double','double','double','double','double','double','logical','logical','double','double','double','double','double','double','double','double','double','double','double','double','double','double','double','logical','logical','logical','double','double','double','double','logical','double','double','double','double','double','double','double','double','logical','double','double','logical','logical','double','double','double','double','logical','double','double','double','double','double','double','double','double','logical','double','logical','logical','logical','double','double','double','double','double','double','double','double','double','double','double','double','logical','double','double','double','logical','logical','double','double','double','logical','double','double','double','double','double','double','double','double','logical','double','double','logical','logical','logical','double','double','double','logical'",'v<double>',
+'stats::approx','c',"'integer','integer','integer','integer'",'v<integer>',
+'stats::approx','array',"'v<double>','v<integer>'",'double',
+'stats::approx','as.vector',"'v<double>'",'v<double>',
+'stats::approx','c',"'double','v<integer>','double','double','double','double','double','double','double'",'v<double>',
+'stats::approx','c',"'double','double','double','double','double','double','double','double','double','double','double'",'v<double>',
+'stats::approx','min',"'double'",'double',
+'stats::approx','max',"'double'",'double',
+'stats::SSfpl','print',"'v<double>','double'",'v<double>',
+'stats::SSfpl','plot',"'v<double>','v<double>','character','logical','v<double>','v<double>','character','character','double','character'",'NULL',
+'stats::proj','c',"'double','double','double','double','double','double','double','double','double','double','double','double','double','double','double','double','double','double','double','double','double','double','double','double'",'v<double>',
+'stats::princomp','list',"'v<double>','v<integer>','v<integer>','v<double>'",'list',
+'stats::princomp','list',"'v<double>','v<integer>','v<integer>'",'list',
+'stats::aggregate.data.frame','list',"'integer'",'list',
+'stats::aggregate.data.frame','list',"'integer','v<logical>'",'list',
+'stats::aggregate.data.frame','c',"'double','double','double','double','double','double','double','logical','double','double','double','double'",'v<double>',
+'stats::aggregate.data.frame','c',"'character','character','double','double','logical','character','double','double','character','double','logical','double'",'v<character>',
+'stats::aggregate.data.frame','c',"'character','character','double','double','logical','character','double','double','character','double','logical','logical'",'v<character>',
+'stats::aggregate.data.frame','aggregate',"'list','list','character'",'list',
+'stats::aggregate.data.frame','factor',"'v<character>','character'",'integer',
+'stats::aggregate.data.frame','aggregate',"'formula','list','function'",'list',
+'stats::aggregate.data.frame','mean',"'v<integer>'",'double',
+'stats::aggregate.data.frame','mean',"'v<integer>','logical'",'double',
+'stats::aggregate.data.frame','aggregate',"'formula','list','function','function','logical'",'list',
+'stats::aggregate.data.frame','aggregate',"'list','formula','function'",'list',
+'stats::aggregate.data.frame','aggregate',"'double','double','function'",'double',
+'stats::aggregate.data.frame','aggregate',"'double','double','function','v<double>'",'double',
+'stats::lm.influence','summary',"'list','logical'",'list',
+'stats::convolve','c',"'double','integer'",'v<double>',
+'stats::median.default','median',"'v<integer>'",'double',
+'stats::poly','c',"'double','v<integer>'",'v<double>',
+'stats::write.ftable','cat',"'character','character','character','character','character','character','character'",'NULL',
+'stats::write.ftable','cat',"'character','character','character','character','character'",'NULL',
+'stats::write.ftable','list',"'v<character>'",'list',
+'stats::write.ftable','print',"'double','character'",'double',
+'stats::write.ftable','==',"'v<integer>','v<integer>'",'v<logical>',
+'stats::friedman.test','c',"'double','double','double','double','double','double','double','double','double','double','double','double','double','double','double','double','double','double','double','double','double','double','double','double','double','double','double','double','double','double','double','double','double','double','double','double','double','double','double','double','double','double','double','double','double','double','double','double','double','double','double','double','double','double','double','double','double','double','double','double','double','double','double','double','double','double'",'v<double>',
+'stats::friedman.test','aggregate',"'v<double>','list','function'",'list',
+'stats::cmdscale','plot',"'v<double>','v<double>','character','character','character','double','logical','character'",'NULL',
+'stats::symnum','setNames',"'v<integer>','v<integer>'",'v<integer>',
+'stats::symnum','rep',"'character','double'",'v<character>',
+'stats::smooth','c',"'double','double','v<integer>'",'v<double>',
+'stats::smooth','c',"'v<integer>','double','double','double','double','double'",'v<double>',
+'stats::smooth','is.na',"'double'",'v<logical>',
+'stats::smooth','plot',"'double','character'",'NULL',
+'stats::ppr','list',"'v<double>','v<double>','v<double>','v<double>'",'list',
+'stats::lm','lm',"'formula','character'",'list',
+'stats::stl','plot',"'list','NULL','NULL','character'",'NULL',
+'stats::stl','plot',"'list','NULL'",'NULL',
+'stats::loess','predict',"'list','list','logical'",'list',
+'stats::na.pass','c',"'double','double','logical'",'v<double>',
+'stats::toeplitz','c',"'v<double>','v<double>','v<double>'",'v<double>',
+'stats::toeplitz','print',"'dgCMatrix'",'dgCMatrix',
+'stats::toeplitz','rep',"'double','integer'",'v<double>',
+'stats::toeplitz','plot',"'v<integer>','v<double>','character','v<double>'",'NULL',
+'stats::pairwise.t.test','factor',"'integer','v<character>'",'integer',
+'stats::density.default','c',"'double','v<double>','double'",'v<double>',
+'stats::density.default','plot',"'list','v<double>'",'NULL',
+'stats::density.default','sample',"'integer','double'",'v<integer>',
+'stats::density.default','/',"'integer','integer'",'double',
+'stats::density.default','sample',"'v<double>','double','logical'",'v<double>',
+'stats::density.default','c',"'character','character','character','character','character','character','character'",'v<character>',
+'stats::density.default','length',"'v<character>'",'integer',
+'stats::density.default','seq',"'v<character>'",'v<integer>',
+'stats::density.default','plot',"'list','character','v<double>','character','character'",'NULL',
+'stats::density.default','sapply',"'v<character>','function'",'v<double>',
+'stats::medpolish','paste',"'v<integer>'",'v<character>',
+'stats::SSlogis','c',"'v<double>','double','double','v<double>'",'v<double>',
+'stats::SSlogis','data.frame',"'v<double>','v<integer>'",'list',
+'stats::chisq.test','chisq.test',"'double'",'list',
+'stats::chisq.test','chisq.test',"'v<double>'",'list',
+'stats::chisq.test','as.table',"'v<double>'",'double',
+'stats::chisq.test','chisq.test',"'v<double>','v<double>','logical'",'list',
+'stats::chisq.test','chisq.test',"'v<double>','v<double>'",'list',
+'stats::chisq.test','chisq.test',"'integer'",'list',
+'stats::ppoints','plot',"'v<double>','v<double>','character','character','v<integer>','v<integer>','character','character'",'NULL',
+'stats::quade.test','c',"'double','double','double','double','double','double','double','double','double','double','double','double','double','double','double','double','double','double','double','double','double','double','double','double','double','double','double','double','double','double','double','double','double','double','double'",'v<double>',
+'stats::quade.test','as.character',"'v<integer>'",'v<character>',
+'stats::quade.test','as.data.frame',"'double'",'list',
+'stats::quade.test','order',"'v<double>'",'v<integer>',
+'stats::case.names','paste',"'character','v<integer>','character'",'v<character>',
+'stats::case.names','setNames',"'v<double>','v<character>'",'v<double>',
+'stats::case.names','list',"'v<double>','v<integer>','double','double','double'",'list',
+'stats::kmeans','cbind',"'list','v<double>'",'list',
+'stats::SSbiexp','plot',"'v<double>','v<double>','character','double','v<double>','v<double>','character'",'NULL',
+'stats::SSbiexp','predict',"'list','list'",'double',
+'stats::SSbiexp','list',"'double','v<double>'",'list',
+'stats::SSbiexp','list',"'double','logical','double','logical'",'list',
+'stats::xtabs','list',"'v<double>','integer','integer','v<integer>'",'list',
+'stats::xtabs','data.frame',"'v<character>','integer'",'list',
+'stats::xtabs','list',"'v<character>','integer'",'list',
+'stats::xtabs','sample',"'double','double'",'v<integer>',
+'stats::xtabs','xtabs',"'formula','list','logical'",'dgCMatrix',
+'stats::xtabs','as.integer',"'integer'",'v<integer>',
+'stats::kruskal.test','rep',"'v<integer>','v<double>'",'v<integer>',
+'stats::termplot','%in%',"'character','v<character>'",'logical',
+'stats::termplot','rep',"'v<character>','double'",'v<character>',
+'stats::termplot','glm',"'formula'",'list',
+'stats::termplot','paste',"'character','v<character>','character'",'v<character>',
+'stats::se.contrast','list',"'v<logical>','v<logical>'",'list',
+'stats::se.contrast','==',"'v<double>','character'",'v<logical>',
+'stats::se.contrast','c',"'double','double','double','double','double','double','double','double','double','double','double','double','double','double','double','double','double','double','double','double','double','double','double','double','double','double','double','double','double','double','double','double','double','double','double','double'",'v<double>',
+'stats::se.contrast','rep',"'integer','double'",'integer',
+'stats::summary.manova','summary',"'list','character'",'list',
+'stats::is.leaf','str',"'list','double','character'",'NULL',
+'stats::is.leaf','str',"'list','double'",'NULL',
+'stats::is.leaf','c',"'double','logical'",'v<double>',
+'stats::is.leaf','list',"'v<double>','double','double'",'list',
+'stats::is.leaf','plot',"'list','list','character','logical'",'NULL',
+'stats::is.leaf','plot',"'list','list','double','logical'",'NULL',
+'stats::is.leaf','list',"'v<integer>','v<double>','v<integer>'",'list',
+'stats::is.leaf','plot',"'list','list','logical'",'NULL',
+'stats::is.leaf','cut',"'list','double'",'list',
+'stats::is.leaf','plot',"'list','list'",'NULL',
+'stats::is.leaf','plot',"'list','list','logical','character'",'NULL',
+'stats::is.leaf','plot',"'list','list','list','logical'",'NULL',
+'stats::is.leaf','str',"'list','character'",'NULL',
+'stats::is.leaf','merge',"'list','list'",'list',
+'stats::is.leaf','merge',"'list','list','list','list'",'list',
+'stats::is.leaf','plot',"'list','v<double>','v<double>'",'NULL',
+'stats::is.leaf','list',"'v<integer>','v<double>','v<integer>','v<character>','double','character'",'list',
+'stats::is.leaf','paste',"'integer','character'",'character',
+'stats::is.leaf','plot',"'list','list','character'",'NULL',
+'stats::order.dendrogram','rownames',"'list'",'v<character>',
+'stats::ts.plot','list',"'character','character','v<integer>'",'list',
+'stats::reshape','summary',"'list'",'character',
+'stats::reshape','reshape',"'list','character','character','character','character','character'",'list',
+'stats::reshape','reshape',"'list','character'",'list',
+'stats::reshape','reshape',"'list','character','list','character','character'",'list',
+'stats::reshape','data.frame',"'v<integer>','character','v<double>','v<double>'",'list',
+'stats::reshape','reshape',"'list','character','character','character','character'",'list',
+'stats::reshape','data.frame',"'v<integer>','v<double>','v<double>','v<double>','v<double>'",'list',
+'stats::reshape','reshape',"'list','character','v<integer>','character'",'list',
+'stats::reshape','reshape',"'list','character','v<character>','v<character>','character','list','character'",'list',
+'stats::reshape','unique',"'v<character>'",'v<character>',
+'stats::reshape','reshape',"'list','character','v<character>'",'list',
+'stats::reshape','rep',"'v<double>','double'",'v<double>',
+'stats::reshape','data.frame',"'v<integer>','v<integer>','v<double>','v<double>'",'list',
+'stats::reshape','reshape',"'list','v<character>','character'",'list',
+'stats::reshape','reshape',"'list'",'list',
+'stats::selfStart','nrow',"'list'",'integer',
+'stats::selfStart','<',"'integer','double'",'logical',
+'stats::selfStart','setNames',"'v<double>','list'",'v<double>',
+'stats::selfStart','==',"'character','v<character>'",'v<logical>',
+'stats::selfStart','which',"'v<logical>'",'integer',
+'stats::selfStart','names',"'v<character>'",'v<character>',
+'stats::selfStart','==',"'v<character>','integer'",'v<logical>',
+'stats::selfStart','sapply',"'v<character>','function','integer','character'",'list',
+'stats::selfStart','sapply',"'list','function','character'",'v<logical>',
+'stats::selfStart','str',"'list','logical'",'NULL',
+'stats::sd','sd',"'v<integer>'",'double',
+'stats::SSmicmen','plot',"'v<double>','v<double>','character','double','v<double>','v<double>','logical','logical','character'",'NULL',
+'stats::simulate','factor',"'v<double>','v<character>'",'integer',
+'stats::smoothEnds','is.na',"'v<double>'",'v<logical>',
+'stats::smoothEnds','identical',"'v<integer>','v<integer>'",'logical',
+'stats::smoothEnds','c',"'v<integer>','integer'",'v<integer>',
+'stats::HoltWinters','+',"'double','v<double>'",'double',
+'stats::summary.lm','list',"'v<double>','integer','logical'",'list',
+'stats::hclust','==',"'v<integer>','integer'",'v<logical>',
+'stats::hclust','plot',"'list','logical','double','character'",'NULL',
+'stats::fisher.test','c',"'double','double','double','double','double','double','double','double','double','double','double','double','double','double','double','double'",'v<double>',
+'stats::isoreg','c',"'double','double','v<integer>','v<integer>','double','double'",'v<double>',
+'stats::isoreg','sample',"'v<double>'",'v<double>',
+'stats::uniroot','ifelse',"'v<logical>','double','v<double>'",'v<double>',
+'stats::uniroot','sapply',"'v<double>','function'",'v<double>',
+'stats::runmed','plot',"'v<double>','character','v<double>','character'",'NULL',
+'stats::runmed','plot',"'v<double>'",'NULL',
+'stats::runmed','seq',"'v<double>'",'v<integer>',
+'stats::runmed','c',"'double','logical','logical'",'v<double>',
+'stats::runmed','rep',"'logical','double'",'v<logical>',
+'stats::runmed','c',"'v<logical>','v<double>'",'v<double>',
+'stats::runmed','c',"'character','v<character>'",'v<character>',
+'stats::StructTS','c',"'double','double','logical','logical'",'v<double>',
+'base::$','c',"'logical','logical','logical'",'v<logical>',
+'base::$','list',"'double','double','double','double'",'list',
+'base::$','names',"'double'",'character',
+'base::$','identical',"'character','character'",'logical',
+'base::$','names',"'double'",'NULL',
+'base::$','list',"'double','character'",'list',
+'base::$','list',"'list','v<integer>'",'list',
+'base::(','identical',"'expression','expression'",'logical',
+'base::*','print',"'double','double'",'double',
+'base:::',':',"'double','double'",'v<double>',
+'base:::',':',"'integer','integer'",'integer',
+'base::<','sort',"'v<character>'",'v<character>',
+'base::as.matrix.data.frame','is.matrix',"'list'",'logical',
+'base::F','as.logical',"'v<double>'",'v<logical>',
+'base::F','c',"'character','character','character','character','character','character','character','character','character','character','character','character'",'v<character>',
+'base::F','as.logical',"'v<character>'",'v<logical>',
+'base::F','as.logical',"'integer'",'v<logical>',
+'base::registerS3methods','as.list',"'environment','logical'",'list',
+'base::c','c',"'v<integer>','double','character'",'v<character>',
+'base::c','as.vector',"'v<integer>'",'v<integer>',
+'base::c','c',"'list','v<integer>'",'list',
+'base::c','c',"'list','list'",'list',
+'base::c','c',"'list','logical'",'double',
+'base::c','c',"'list','logical'",'v<double>',
+'base::t','seq',"'integer'",'v<integer>',
+'base::array2DF','tapply',"'v<double>','list','function','logical'",'list',
+'base::array2DF','tapply',"'v<double>','list','function'",'list',
+'base::array2DF','data.frame',"'double','character'",'list',
+'base::array2DF','sample',"'v<double>','double'",'v<double>',
+'base::array2DF','tapply',"'v<double>','list','function','double'",'list',
+'base::array2DF','sample',"'v<double>','logical'",'v<double>',
+'base::qr.solve','+',"'v<double>','v<integer>'",'v<double>',
+'base::str2expression','cat',"'character','character'",'NULL',
+'base::str2expression','identical',"'<-','<-'",'logical',
+'base::str2expression','identical',"'name','name'",'logical',
+'base::dynGet','as.list',"'v<character>'",'list',
+'base::interaction','identical',"'integer','integer'",'logical',
+'base::gamma','print',"'v<double>'",'v<double>',
+'base::gamma','*',"'v<integer>','double'",'v<double>',
+'base::gamma','plot',"'v<double>','v<double>','v<double>','character','character','double','expression'",'NULL',
+'base::gamma','>=',"'integer','double'",'logical',
+'base::gamma','paste0',"'character','character'",'character',
+'base::gamma','>=',"'double','double'",'logical',
+'base::gamma','max',"'double','double'",'double',
+'base::gamma','cat',"'character','character','v<character>'",'NULL',
+'base::gamma','<=',"'v<integer>','double'",'v<logical>',
+'base::gamma','==',"'v<integer>','double'",'v<logical>',
+'base::gamma',':',"'double','double'",'double',
+'base::gamma','sapply',"'v<integer>','function'",'v<double>',
+'base::gamma','ifelse',"'v<logical>','v<logical>','v<double>'",'v<double>',
+'base::as.package_version','<',"'list','character'",'v<logical>',
+'base::as.package_version','min',"'list'",'list',
+'base::as.package_version','max',"'list'",'list',
+'base::as.package_version','<=',"'list','character'",'logical',
+'base::as.package_version','is.na',"'list'",'v<logical>',
+'base::as.package_version','c',"'v<logical>','logical'",'v<logical>',
+'base::as.package_version','identical',"'v<logical>','v<logical>'",'logical',
+'base::.GlobalEnv','is.environment',"'environment'",'logical',
+'base::.GlobalEnv','==',"'integer','integer'",'logical',
+'base::print.srcfile','summary',"'srcfile'",'srcfile',
+'base::is.na<-','paste',"'v<double>'",'v<character>',
+'base::is.na<-','is.na',"'v<character>'",'v<logical>',
+'base::is.na<-','c',"'logical','v<integer>'",'v<integer>',
+'base::is.na<-','list',"'v<integer>','v<integer>','v<character>','v<character>'",'list',
+'base::is.na<-','sapply',"'list','function'",'v<logical>',
+'base::.handleSimpleError','print',"'character'",'character',
+'base::summary.connection','print',"'v<character>'",'v<character>',
+'base::subset.default','>',"'v<integer>','double'",'v<logical>',
+'base::subset.default','subset',"'v<integer>','v<logical>'",'v<integer>',
+'base::subset.default','%in%',"'v<character>','v<character>'",'v<logical>',
+'base::Ops.POSIXt','is.list',"'list'",'logical',
+'base::Ops.POSIXt','+',"'double','integer'",'double',
+'base::Ops.POSIXt','length',"'list'",'integer',
+'base::Ops.POSIXt','seq_along',"'list'",'v<integer>',
+'base::quote','typeof',"'call'",'character',
+'base::quote','typeof',"'expression'",'character',
+'base::quote','typeof',"'name'",'character',
+'base::inverse.rle','rep',"'v<integer>','v<integer>'",'v<integer>',
+'base::inverse.rle','c',"'logical','logical','logical','logical','logical','logical','logical','logical','logical'",'v<logical>',
+'base::inverse.rle','as.character',"'v<logical>'",'v<character>',
+'base::inverse.rle','print',"'list','character'",'list',
+'base::inverse.rle','==',"'v<logical>','v<logical>'",'v<logical>',
+'base::getOption','as.logical',"'logical'",'logical',
+'base::Im','+',"'v<integer>','v<complex>'",'v<complex>',
+'base::Im','/',"'v<complex>','double'",'v<complex>',
+'base::Im','plot',"'v<complex>','v<double>','v<double>','character','double','expression'",'NULL',
+'base::Im','+',"'double','complex'",'complex',
+'base::Im','identical',"'complex','complex'",'logical',
+'base::Im','list',"'logical','integer','double','character','complex'",'list',
+'base::Im','vapply',"'list','function','complex'",'v<complex>',
+'base::Im','is.na',"'v<complex>'",'v<logical>',
+'base::Im','paste0',"'character','v<double>','character','v<double>','character'",'v<character>',
+'base::Im','str',"'complex'",'NULL',
+'base::Im','is.na',"'complex'",'logical',
+'base::Im','paste0',"'character','double','character','double','character'",'character',
+'base::rapply','list',"'double','list'",'list',
+'base::rapply','list',"'list','character'",'list',
+'base::rapply','list',"'v<expression>','character'",'list',
+'base::rapply','as.character',"'name'",'character',
+'base::rapply','as.character',"'call'",'v<character>',
+'base::rapply','as.character',"'character'",'character',
+'base::rapply','identical',"'v<expression>','v<expression>'",'logical',
+'base::library.dynam','tail',"'list','double'",'list',
+'base::evalq','*',"'integer','double'",'double',
+'base::units.difftime','as.numeric',"'double','character'",'v<double>',
+'base::unique.array','c',"'v<integer>','v<integer>','v<double>'",'v<double>',
+'base::unique.array','unique',"'v<double>','logical'",'v<double>',
+'base::unique.array','sample',"'double','double','logical'",'v<integer>',
+'base::unique.array','unique',"'v<integer>'",'v<integer>',
+'base::unique.array','unique',"'list'",'list',
+'base::.LC.categories','sapply',"'list','function'",'v<integer>',
+'base::.LC.categories','sapply',"'list','function','integer'",'v<character>',
+'base::.LC.categories','setNames',"'v<character>','v<character>'",'v<character>',
+'base::dimnames.data.frame','array',"'v<integer>','v<integer>'",'integer',
+'base::dimnames.data.frame','dimnames',"'integer'",'list',
+'base::dimnames.data.frame','list',"'NULL'",'list',
+'base::dimnames.data.frame','tail',"'v<character>'",'v<character>',
+'base::require','match',"'character','v<character>'",'integer',
+'base::if','print',"'v<integer>'",'v<integer>',
+'base::if','cat',"'double','character','double','character','character'",'NULL',
+'base::if','unique',"'integer'",'integer',
+'base::if','head',"'v<double>'",'v<double>',
+'base::unique.warnings','cat',"'character','integer','character'",'NULL',
+'base::unique.warnings','cat',"'integer','character'",'NULL',
+'base::lapply','c',"'logical','logical','logical','logical'",'v<logical>',
+'base::lapply','list',"'v<integer>','v<double>','v<logical>'",'list',
+'base::lapply','mean',"'v<logical>'",'double',
+'base::lapply','lapply',"'list','function'",'list',
+'base::lapply','quantile',"'v<integer>','v<double>'",'v<double>',
+'base::lapply','quantile',"'v<logical>','v<double>'",'v<double>',
+'base::lapply','lapply',"'list','function','v<double>'",'list',
+'base::lapply','quantile',"'v<integer>'",'v<double>',
+'base::lapply','quantile',"'v<logical>'",'v<double>',
+'base::lapply','sapply',"'v<integer>','function'",'list',
+'base::lapply','sapply',"'v<double>','function','v<double>','character'",'double',
+'base::lapply','list',"'NULL','NULL','v<character>'",'list',
+'base::paste','paste0',"'v<integer>'",'v<character>',
+'base::paste','c',"'character','character','character','v<character>'",'v<character>',
+'base::paste','paste0',"'v<integer>','v<character>'",'v<character>',
+'base::paste','paste',"'v<character>','character','v<character>','character'",'v<character>',
+'base::paste','paste',"'v<character>','v<character>'",'v<character>',
+'base::paste','paste',"'v<character>','character','v<character>','character','character'",'v<character>',
+'base::paste','paste0',"'v<character>','character'",'character',
+'base::paste','paste',"'character','character','character','character'",'character',
+'base::paste','paste',"'v<character>','v<character>','character','character'",'character',
+'base::paste','paste',"'NULL','v<integer>'",'v<character>',
+'base::paste','paste',"'character','double','character','logical'",'character',
+'base::paste','paste',"'character','NULL','character','character'",'character',
+'base::paste','paste',"'character','NULL','character','logical'",'character',
+'base::paste','paste',"'character'",'character',
+'base::paste','paste',"'character','logical'",'character',
+'base::paste','paste',"'NULL','character'",'character',
+'base::paste','paste',"'NULL','character','logical'",'character',
+'base::match','c',"'character','character','character','character','character','logical','character','character','character','character','character'",'v<character>',
+'base::match','c',"'v<character>','v<character>'",'v<character>',
+'base::match','c',"'double','logical','double'",'v<double>',
+'base::match','c',"'v<complex>','v<complex>','v<complex>','v<complex>'",'v<complex>',
+'base::match','match',"'v<complex>','v<complex>'",'v<integer>',
+'base::match','unique',"'v<complex>'",'v<complex>',
+'base::match','identical',"'v<complex>','v<complex>'",'logical',
+'base::order','c',"'double','double','v<integer>','v<integer>','double'",'v<double>',
+'base::order','order',"'v<double>','v<double>','v<double>'",'v<integer>',
+'base::order','as.character',"'v<double>'",'v<character>',
+'base::order','order',"'v<double>','v<integer>','v<double>'",'v<integer>',
+'base::order','order',"'v<double>','v<character>','v<double>','v<logical>','character'",'v<integer>',
+'base::order','transform',"'list','integer'",'list',
+'base::order','order',"'v<double>','v<double>','integer'",'v<integer>',
+'base::order','data.frame',"'v<double>','v<double>','v<double>','v<double>'",'list',
+'base::order','order',"'v<double>','v<double>','v<double>','v<double>'",'v<integer>',
+'base::order','order',"'v<integer>'",'v<integer>',
+'base::order','c',"'double','double','double','logical','double'",'v<double>',
+'base::order','c',"'double','logical','double','double','double'",'v<double>',
+'base::order','order',"'v<double>','v<double>'",'v<integer>',
+'base::order','order',"'v<double>','v<double>','logical'",'v<integer>',
+'base::rank','rank',"'v<double>'",'v<double>',
+'base::rank','rank',"'v<double>','character'",'v<integer>',
+'base::rank','+',"'v<integer>','v<integer>'",'v<integer>',
+'base::rank','sapply',"'NULL','function'",'list',
+'base::rank','cbind',"'v<double>','list'",'list',
+'base::rank','sample',"'double'",'v<integer>',
+'base::seq.default','seq',"'double'",'v<integer>',
+'base::startsWith','==',"'v<character>','character'",'v<logical>',
+'base::[<-.Date','seq',"'double','double','character'",'double',
+'base::[<-.Date','seq_along',"'double'",'v<integer>',
+'base::aperm.default','summary',"'double'",'list',
+'base::as.character.hexmode','class',"'integer'",'character',
+'base::as.character.hexmode','as.integer',"'integer'",'integer',
+'base::as.character.hexmode','c',"'logical','double'",'v<double>',
+'base::as.character.hexmode','c',"'v<integer>','v<character>'",'v<character>',
+'base::as.character.hexmode','==',"'v<character>','v<character>'",'v<logical>',
+'base::as.character.hexmode','as.integer',"'double'",'v<integer>',
+'base::kappa.qr','rep',"'v<double>','integer'",'v<double>',
+'base::colMeans','-',"'v<integer>','complex'",'v<complex>',
+'base::find.package','lapply',"'v<character>','function'",'list',
+'base::weekdays.POSIXt','as.data.frame',"'list'",'list',
+'base::weekdays.POSIXt','+',"'double','v<integer>'",'double',
+'base::weekdays.POSIXt','cbind',"'double','list','integer'",'list',
+'base::weekdays.POSIXt','seq',"'double','double','double'",'double',
+'base::weekdays.POSIXt','as.numeric',"'double'",'double',
+'base::autoloader','list',"'character','character'",'list',
+'base::Encoding','cat',"'character','character','character','character','character','character','character','character'",'NULL',
+'base::do.call','c',"'list','character'",'list',
+'base::do.call','paste',"'integer','v<integer>','integer','character'",'v<character>',
+'base::do.call','list',"'name','name'",'list',
+'base::do.call','paste',"'name','name'",'character',
+'base::do.call','list',"'name'",'list',
+'base::chooseOpsMethod.default','identical',"'double','character'",'logical',
+'base::levels.default','list',"'v<character>','character'",'list',
+'base::levels.default','list',"'character','character','character'",'list',
+'base::readBin','paste',"'character','v<integer>','character'",'character',
+'base::sys.call','cat',"'character','v<integer>','character'",'NULL',
+'base::sys.call','print',"'function'",'function',
+'base::sys.call','str',"'call'",'NULL',
+'base::sys.call','print',"'environment'",'environment',
+'base::data.matrix','seq',"'double','character','double'",'double',
+'base::data.matrix','data.frame',"'v<integer>','v<character>','double','logical'",'list',
+'base::all.equal.formula','as.environment',"'character'",'environment',
+'base::all.equal.formula','is.character',"'v<character>'",'logical',
+'base::all.equal.formula','as.numeric',"'character'",'double',
+'base::all.equal.formula','str',"'logical'",'NULL',
+'base::all.equal.formula','cat',"'character','character','double','character'",'NULL',
+'base::all.equal.formula','c',"'logical'",'logical',
+'base::all.equal.formula','==',"'character','character'",'logical',
+'base::print.noquote','as.logical',"'v<logical>'",'v<logical>',
+'base::print.noquote','length',"'v<logical>'",'integer',
+'base::print.noquote','+',"'double','v<logical>'",'v<double>',
+'base::Ops.ordered','factor',"'integer'",'integer',
+'base::Ops.ordered','factor',"'v<double>','NULL'",'integer',
+'base::Ops.ordered','is.na',"'integer'",'v<logical>',
+'base::Ops.ordered','c',"'v<integer>','logical'",'v<integer>',
+'base::Ops.ordered','factor',"'v<integer>','character'",'integer',
+'base::Ops.ordered','factor',"'v<integer>','NULL'",'integer',
+'base::Ops.ordered','factor',"'v<character>','v<character>','v<character>'",'integer',
+'base::as.character.octmode','c',"'integer','character','character'",'v<character>',
+'base::print.listof','table',"'v<double>','v<double>'",'integer',
+'base::print.listof','print',"'integer','character'",'integer',
+'base::print.listof','length',"'integer'",'integer',
+'base::print.listof','*',"'integer','v<double>'",'double',
+'base::print.listof','table',"'double','logical'",'integer',
+'base::transform.data.frame','transform',"'v<integer>','v<double>'",'list',
+'base::unname','cut',"'v<double>','v<double>'",'integer',
+'base::sample','sample',"'v<integer>'",'v<integer>',
+'base::sample','sample',"'v<integer>','logical'",'v<integer>',
+'base::sample','sample',"'integer'",'v<integer>',
+'base::sample','sample',"'integer'",'integer',
+'base::format.POSIXct','as.character',"'list'",'v<character>',
+'base::format.POSIXct','as.character',"'list'",'character',
+'base::format.POSIXct','c',"'double','double','double','logical'",'v<double>',
+'base::is.call','class',"'call'",'character',
+'base::row.names','data.frame',"'v<logical>','v<double>'",'list',
+'base::switch','cat',"'character','character','v<integer>','character'",'NULL',
+'base::switch','cat',"'character','character','NULL','character'",'NULL',
+'base::switch','cat',"'character','character','character','character'",'NULL',
+'base::switch','print',"'NULL'",'NULL',
+'base::lengths','lapply',"'list','function','logical'",'list',
+'base::lengths','rep',"'v<double>','v<integer>'",'v<double>',
+'base::lengths','vapply',"'list','function','integer'",'v<integer>',
+'base::save','list',"'double','logical','character'",'list',
+'base::save','list',"'logical','logical'",'list',
+'base::is.null','is.null',"'list'",'logical',
+'base::is.null','is.null',"'integer'",'logical',
+'base::is.null','is.null',"'logical'",'logical',
+'base::pretty','lapply',"'v<integer>','function'",'list',
+'base::pretty','lapply',"'v<integer>','function','double'",'list',
+'base::pretty','cat',"'character','character','character','v<character>','character'",'NULL',
+'base::range.POSIXct','c',"'logical','v<integer>','v<double>'",'v<double>',
+'base::range.POSIXct','range',"'v<double>','logical'",'v<double>',
+'base::arrayInd','c',"'logical','logical','logical','logical','logical','logical','logical'",'v<logical>',
+'base::arrayInd','seq',"'v<logical>'",'v<integer>',
+'base::arrayInd','which',"'v<logical>','logical'",'v<integer>',
+'base::arrayInd','c',"'integer'",'v<integer>',
+'base::arrayInd','*',"'integer','v<integer>'",'v<integer>',
+'base::arrayInd','c',"'v<integer>','v<integer>','v<integer>','v<integer>','v<integer>','integer'",'v<integer>',
+'base::casefold','names',"'character'",'NULL',
+'base::casefold','sapply',"'list','function','logical'",'character',
+'base::casefold','names',"'v<character>'",'NULL',
+'base::casefold','sapply',"'list','function','logical'",'v<character>',
+'base::casefold','c',"'v<character>','v<character>','character'",'v<character>',
+'base::is.language','list',"'expression','name','expression','call'",'list',
+'base::get0','identical',"'NULL','NULL'",'logical',
+'base::as.vector','data.frame',"'v<integer>','v<integer>'",'list',
+'base::split<-.default','sd',"'v<double>'",'double',
+'base::split<-.default','tapply',"'v<double>','integer','function'",'double',
+'base::split<-.default','head',"'list'",'list',
+'base::split<-.default','sd',"'v<double>','logical'",'double',
+'base::split<-.default','tapply',"'v<double>','v<integer>','function','logical'",'double',
+'base::is.pairlist','as.list',"'environment'",'list',
+'base::rep.Date','rep',"'v<integer>','double','double'",'v<integer>',
+'base::rep.Date','list',"'v<integer>','character'",'list',
+'base::rep.Date','rep',"'list','double'",'list',
+'base::rep.Date','rep',"'list','v<double>'",'list',
+'base::length','length',"'formula'",'integer',
+'base::length','length',"'v<expression>'",'integer',
+'base::length','length',"'call'",'integer',
+'base::formals','names',"'list'",'character',
+'base::formatC','*',"'v<integer>','v<double>'",'v<double>',
+'base::formatC','paste',"'v<integer>','character'",'character',
+'base::formatC','sapply',"'v<integer>','function'",'v<character>',
+'base::formatC','*',"'complex','v<double>'",'v<complex>',
+'base::formatC','+',"'v<double>','v<complex>'",'v<complex>',
+'base::formatC','head',"'v<character>','double'",'v<character>',
+'base::is.numeric.Date','factor',"'v<integer>'",'integer',
+'base::make.unique','c',"'v<character>','character'",'v<character>',
+'base::make.unique','c',"'v<character>','character','character'",'v<character>',
+'base::make.unique','data.frame',"'double','double','double'",'list',
+'base::make.unique','data.frame',"'double','double'",'list',
+'base::make.unique','data.frame',"'list','double'",'list',
+'base::class<-','class',"'double'",'character',
+'base::class<-','class',"'name'",'character',
+'base::class<-','class',"'<-'",'character',
+'base::class<-','class',"'('",'character',
+'base::class<-','class',"'if'",'character',
+'base::intersect','sample',"'v<integer>','double'",'v<integer>',
+'base::intersect','sort',"'v<integer>'",'v<integer>',
+'base::as.table.default','table',"'integer','integer'",'integer',
+'base::as.table.default','cut',"'v<integer>','v<double>'",'integer',
+'base::as.table.default','table',"'integer','v<integer>'",'integer',
+'base::as.table.default','sample',"'v<character>'",'v<character>',
+'base::as.table.default','table',"'v<character>','v<character>','NULL'",'integer',
+'base::as.table.default','table',"'v<character>','v<character>','double'",'integer',
+'base::as.table.default','/',"'double','v<integer>'",'v<double>',
+'base::as.table.default','c',"'logical','v<double>'",'v<double>',
+'base::as.table.default','table',"'v<double>','NULL'",'integer',
+'base::as.table.default','table',"'integer','character'",'integer',
+'base::as.table.default','c',"'double','logical','v<integer>','v<integer>'",'v<double>',
+'base::as.table.default','table',"'integer','NULL'",'integer',
+'base::as.table.default','table',"'integer','logical'",'integer',
+'base::as.table.default','table',"'v<logical>','v<integer>','character'",'integer',
+'base::as.table.default','table',"'v<logical>','integer'",'integer',
+'base::normalizePath','cat',"'v<character>','character'",'NULL',
+'base::sort','sort',"'v<integer>','v<double>'",'v<integer>',
+'base::sort','sort',"'v<integer>','character','logical'",'list',
+'base::sort','c',"'v<integer>','v<integer>','double'",'v<double>',
+'base::print.data.frame','data.frame',"'v<integer>','integer','character'",'list',
+'base::print.data.frame','print',"'list','logical','logical'",'list',
+'base::grep','cat',"'character','v<character>','character'",'NULL',
+'base::grep','c',"'character','character','character','character','character','character','character','character','character','character','character','character','character','character','character','character','character','character','character','character','character','character','character','character','character','character','character','character','character','character','character','character','character','character','character','character','character','character','character','character','character','character','character','character','character','character','character','character','character'",'v<character>',
+'base::grep','match',"'v<character>','v<character>'",'v<integer>',
+'base::grep','names',"'NULL'",'NULL',
+'base::grep','sapply',"'v<character>','function'",'list',
+'base::grep','seq_along',"'v<character>'",'v<integer>',
+'base::grep','lapply',"'list','function','v<integer>'",'list',
+'base::strsplit','rev',"'v<character>'",'v<character>',
+'base::strsplit','sapply',"'list','function','character'",'v<character>',
+'base::strsplit','-',"'v<integer>','integer'",'v<integer>',
+'base::strsplit','rev',"'character'",'character',
+'base::Summary.data.frame','data.frame',"'v<integer>','v<double>'",'list',
+'base::Summary.data.frame','+',"'double','list'",'list',
+'base::Summary.data.frame','class',"'list'",'character',
+'base::merge.data.frame','data.frame',"'character','v<character>','v<character>'",'list',
+'base::merge.data.frame','c',"'logical','character','logical','logical','logical','logical','character'",'v<character>',
+'base::merge.data.frame','merge',"'list','list','character','character'",'list',
+'base::unloadNamespace','identical',"'logical','logical'",'logical',
+'base::unloadNamespace','is.null',"'character'",'logical',
+'base::%o%','paste',"'v<integer>','character','character'",'v<character>',
+'base::%o%','paste',"'v<character>','v<integer>'",'v<character>',
+'base::apply','c',"'v<double>','double'",'v<double>',
+'base::apply','apply',"'double','v<integer>','function'",'double',
+'base::apply','list',"'NULL','NULL'",'list',
+'base::apply','c',"'v<integer>','double','v<integer>'",'v<double>',
+'base::apply','apply',"'integer','v<integer>','function'",'list',
+'base::apply','typeof',"'list'",'character',
+'base::apply','dim',"'list'",'v<integer>',
+'base::apply','apply',"'integer','double','function'",'list',
+'base::chkDots','seq',"'double','double','character'",'v<integer>',
+'base::OlsonNames','vapply',"'list','function','character','double'",'v<character>',
+'base::OlsonNames','table',"'v<character>'",'integer',
+'base::OlsonNames','>=',"'v<integer>','double'",'v<logical>',
+'base::topenv','identical',"'environment','environment'",'logical',
+'base::as.character.factor','as.character',"'formula'",'v<character>',
+'base::as.character.factor','as.character',"'double'",'character',
+'base::as.character.factor','list',"'character','v<character>'",'list',
+'base::format.default','data.frame',"'v<character>','logical'",'list',
+'base::format.default','sapply',"'v<double>','standardGeneric','integer'",'v<character>',
+'base::format.default','list',"'v<character>','v<complex>','v<double>','v<character>','call','expression'",'list',
+'base::as.expression.default','length',"'expression'",'integer',
+'base::as.expression.default','sapply',"'v<expression>','function'",'v<character>',
+'base::as.expression.default','typeof',"'double'",'character',
+'base::bitwAnd','c',"'raw','raw'",'v<raw>',
+'base::cut.POSIXt','cut',"'double','character'",'integer',
+'base::cut.POSIXt','mean',"'integer'",'double',
+'base::cut.POSIXt','aggregate',"'v<integer>','list','function'",'list',
+'base::file.size','>',"'double','double'",'v<logical>',
+'base::findInterval','findInterval',"'v<integer>','v<double>'",'v<integer>',
+'base::findInterval','+',"'double'",'double',
+'base::findInterval','<',"'v<integer>','double'",'v<logical>',
+'base::findInterval','findInterval',"'v<integer>','v<double>','logical'",'v<integer>',
+'base::findInterval',':',"'integer','double'",'v<integer>',
+'base::findInterval','-',"'integer','v<integer>'",'v<integer>',
+'base::sprintf','paste0',"'character','v<integer>','character'",'v<character>',
+'base::duplicated.matrix','c',"'v<integer>','v<integer>','v<integer>','v<integer>'",'v<integer>',
+'base::duplicated.matrix','unique',"'v<integer>','logical'",'v<integer>',
+'base::cbind.data.frame','seq_along',"'integer'",'v<integer>',
+'base::cbind.data.frame','setNames',"'integer','v<character>'",'integer',
+'base::cbind.data.frame','data.frame',"'double','integer','integer'",'list',
+'base::cbind.data.frame','data.frame',"'double','character','character'",'list',
+'base::cbind.data.frame','rbind',"'list','list'",'list',
+'base::cbind.data.frame','rbind',"'list','list','logical'",'list',
+'base::cbind.data.frame','as.list',"'list'",'list',
+'base::names','names',"'v<double>'",'v<character>',
+'base::names','list',"'double','character','v<integer>'",'list',
+'base::names','names',"'v<integer>'",'NULL',
+'base::names','c',"'environment','environment'",'list',
+'base::names','names',"'environment'",'v<character>',
+'base::tanpi','%in%',"'v<double>','v<double>'",'v<logical>',
+'base::prmatrix','paste',"'character','v<integer>'",'v<character>',
+'base::identical','identical',"'double','NULL'",'logical',
+'base::identical','as.integer',"'double'",'integer',
+'base::identical','identical',"'double','integer'",'logical',
+'base::identical','identical',"'double','double','logical'",'logical',
+'base::identical','identical',"'function','function'",'logical',
+'base::identical','identical',"'function','function','logical'",'logical',
+'base::identical','identical',"'list','list','logical'",'logical',
+'base::identical','attributes',"'double'",'list',
+'base::identical','rev',"'list'",'list',
+'base::mapply','rep',"'integer','integer'",'v<integer>',
+'base::mapply','rep',"'integer','integer'",'integer',
+'base::mapply','mapply',"'function','v<integer>','v<integer>'",'list',
+'base::mapply','rep',"'integer','double'",'double',
+'base::mapply','rep',"'integer','double'",'v<double>',
+'base::mapply','mapply',"'function','v<integer>','list'",'list',
+'base::mapply','mapply',"'function','v<double>','v<double>'",'list',
+'base::mapply','mapply',"'function','v<character>','v<integer>','logical'",'list',
+'base::mapply','mapply',"'function','character','integer'",'list',
+'base::list2env','list',"'double','v<integer>','double','integer'",'list',
+'base::list2env','list',"'v<character>','character','list'",'list',
+'base::set.seed','*',"'v<double>','v<integer>'",'v<double>',
+'base::returnValue','as.list',"'{'",'list',
+'base::returnValue','as.list',"'if'",'list',
+'base::summary.data.frame','summary',"'list','double'",'character',
+'base::summary.data.frame','summary',"'integer','double'",'v<integer>',
+'base::summary.data.frame','>',"'integer','double'",'v<logical>',
+'base::summary.data.frame','as.factor',"'v<logical>'",'integer',
+'base::summary.data.frame','summary',"'integer'",'v<integer>',
+'base::Exec','<=',"'double','double'",'logical',
+'base::Exec','list',"'call'",'list',
+'base::Exec','identical',"'call','name'",'logical',
+'base::storage.mode<-','c',"'character','character','character','character','character','character','character','character','character','character','character','character','character','character','character'",'v<character>',
+'base::storage.mode<-','data.frame',"'double'",'list',
+'base::ngettext','is.na',"'character'",'logical',
+'base::Find','+',"'integer','integer'",'integer',
+'base::Find','list',"'function','function','function','function'",'list',
+'base::Find','sapply',"'v<character>','function','environment'",'list',
+'base::Find','length',"'NULL'",'integer',
+'base::Find','%in%',"'NULL','character'",'logical',
+'base::Find','%in%',"'v<character>','character'",'v<logical>',
+'base::Find','%in%',"'character','character'",'logical',
+'base::body<-','c',"'name','v<expression>'",'v<expression>',
+'base::body<-','identical',"'{','{'",'logical',
+'base::rawToChar','c',"'v<raw>','raw','v<raw>'",'v<raw>',
+'base::rawToChar','as.logical',"'v<raw>'",'v<logical>',
+'base::rawToChar','identical',"'v<raw>','v<raw>'",'logical',
+'base::rawToChar','as.integer',"'v<integer>'",'v<integer>',
+'base::rawToChar','rev',"'v<raw>'",'v<raw>',
+'base::rawToChar','as.character',"'v<raw>'",'v<character>',
+'base::rawToChar','c',"'character','character','v<character>'",'v<character>',
+'base::rawToChar','vapply',"'v<integer>','function','character'",'v<character>',
+'base::rawToChar','print',"'v<character>','double','logical'",'v<character>',
+'base::rawToChar','c',"'character','character','v<character>','character','v<character>'",'v<character>',
+'base::rawToChar','vapply',"'double','function','character'",'character',
+'base::rawToChar','vapply',"'v<double>','function','character'",'v<character>',
+'base::[<-.data.frame','class',"'v<double>'",'character',
+'base::[<-.data.frame','class',"'v<character>'",'character',
+'base::[<-.data.frame','class',"'v<integer>'",'character',
+'base::[<-.data.frame','list',"'v<character>','NULL','v<integer>'",'list',
+'base::[<-.data.frame','data.frame',"'v<integer>','integer','integer'",'list',
+'base::[<-.data.frame','identical',"'v<integer>','integer'",'logical',
+'base::data.frame','data.frame',"'double','v<integer>','v<character>'",'list',
+'base::data.frame','data.frame',"'list','v<character>','logical'",'list',
+'base::data.frame','==',"'v<integer>','v<character>'",'v<logical>',
+'base::-.Date','<',"'double','v<character>'",'v<logical>',
+'base::array','as.array',"'v<character>'",'character',
+'base::array','dim',"'character'",'integer',
+'base::.deparseOpts','>',"'integer','integer'",'logical',
+'base::.deparseOpts','data.frame',"'v<character>','v<double>','v<double>'",'list',
+'base::bquote','plot',"'v<integer>','v<double>','call'",'NULL',
+'base::nchar','data.frame',"'integer','logical'",'list',
+'base::nchar','sapply',"'v<logical>','function'",'list',
+'base::nchar','length',"'character'",'integer',
+'base::nchar','vapply',"'v<character>','function','integer'",'v<integer>',
+'base::nchar','unique',"'v<integer>'",'integer',
+'base::seq.Date','<',"'double','double'",'v<logical>',
+'base::seq.Date','rev',"'double'",'double',
+'base::format.pval','c',"'v<double>','double','logical'",'v<double>',
+'base::besselI','plot',"'v<double>','v<double>','v<double>','character','character','character'",'NULL',
+'base::besselI','seq',"'v<integer>'",'v<integer>',
+'base::besselI','plot',"'v<double>','v<double>','character','character','character','character','character'",'NULL',
+'base::besselI','+',"'double','logical'",'double',
+'base::besselI','paste',"'v<double>','v<double>','character'",'v<character>',
+'base::besselI','plot',"'v<double>','v<double>','v<double>','character','character','character','character'",'NULL',
+'base::besselI','c',"'v<double>'",'v<double>',
+'base::mostattributes<-','list',"'character','v<integer>','list','v<character>'",'list',
+'base::substring<-','attributes',"'character'",'list',
+'base::memCompress','length',"'v<raw>'",'integer',
+'base::which.min','range',"'double','logical'",'v<double>',
+'base::which.min','c',"'integer'",'integer',
+'base::Sys.getpid','paste',"'character','integer'",'character',
+'base::cat','cat',"'character','double','character'",'NULL',
+'base::cat','paste',"'v<character>','v<double>'",'v<character>',
+'base::cat','cat',"'v<character>','logical','v<character>'",'NULL',
+'base::is.raw','as.integer',"'v<raw>'",'v<integer>',
+'base::is.raw','==',"'raw','raw'",'logical',
+'base::is.raw','<=',"'v<raw>','raw'",'v<logical>',
+'base::readLines','cat',"'character','character','character','character','character','character'",'NULL',
+'base::readLines','cat',"'character','character','logical'",'NULL',
+'base::cut','cut',"'v<double>','v<integer>'",'integer',
+'base::cut','cut',"'v<double>','v<integer>','logical'",'v<integer>',
+'base::cut','sum',"'integer'",'integer',
+'base::cut','cut',"'v<double>','double'",'integer',
+'base::cut','==',"'integer','v<double>'",'logical',
+'base::cut','cut',"'v<integer>','double'",'integer',
+'base::cut','cut',"'v<integer>','v<double>','logical'",'integer',
+'base::cut','cut',"'v<double>','v<double>','double'",'integer',
+'base::cut','cut',"'v<double>','v<double>','logical'",'integer',
+'base::pmax.int','min',"'v<integer>','double'",'double',
+'base::assign','paste',"'character','integer','character'",'character',
+'base::droplevels.factor','subset',"'list','v<logical>'",'list',
+'base::Sys.setenv','print',"'v<logical>'",'v<logical>',
+'base::format.info','c',"'double','double','v<integer>','double','double'",'v<double>',
+'base::format.info','sapply',"'v<double>','standardGeneric'",'v<character>',
+'base::rev','sort',"'v<integer>','logical'",'v<integer>',
+'base::sum','sum',"'double','double','double','double','double'",'double',
+'base::sum','sum',"'v<integer>','v<integer>'",'integer',
+'base::sum','sum',"'v<integer>','logical'",'integer',
+'base::sum','sum',"'v<integer>','logical','logical'",'integer',
+'base::isSymmetric.matrix','+',"'v<integer>','complex'",'v<complex>',
+'base::Sys.getenv','names',"'character'",'v<character>',
+'base::Sys.getenv','head',"'character','double'",'character',
+'base::as.environment','as.environment',"'double'",'environment',
+'base::as.environment','list',"'character','double','v<character>'",'list',
+'base::as.environment','as.environment',"'list'",'environment',
+'base::print.eigen','c',"'double','complex'",'v<complex>',
+'base::print.eigen','-',"'complex'",'complex',
+'base::print.eigen','c',"'complex','double'",'v<complex>',
+'base::validUTF8','c',"'character','character','character','character','character','character','character','character','character','character'",'v<character>',
+'base::delayedAssign','typeof',"'character'",'character',
+'base::delayedAssign','typeof',"'{'",'character',
+'base::tapply','as.factor',"'v<integer>'",'integer',
+'base::tapply','tapply',"'integer','integer','function'",'integer',
+'base::tapply','tapply',"'v<double>','list','function'",'double',
+'base::tapply','tapply',"'v<integer>','integer','function'",'integer',
+'base::tapply','tapply',"'v<integer>','integer','function','double'",'double',
+'base::tapply','tapply',"'v<integer>','integer','function','logical'",'list',
+'base::tapply','range',"'v<integer>'",'v<integer>',
+'base::tapply','tapply',"'v<integer>','integer','function'",'list',
+'base::tapply','mean',"'v<double>','logical'",'double',
+'base::tapply','tapply',"'double','double','function','logical'",'double',
+'base::tapply','list',"'v<double>','v<character>'",'list',
+'base::tapply','table',"'list'",'integer',
+'base::tapply','tapply',"'v<integer>','list'",'v<integer>',
+'base::tapply','c',"'integer','integer','integer'",'v<integer>',
+'base::tapply','c',"'integer','integer','logical','integer'",'v<integer>',
+'base::tapply','list',"'v<double>','v<double>','NULL','NULL'",'list',
+'base::tapply','array',"'list','double','list'",'list',
+'base::print.default','print',"'v<character>','logical'",'v<character>',
+'base::balancePOSIXlt','*',"'v<integer>','integer'",'v<integer>',
+'base::balancePOSIXlt','+',"'integer','v<integer>'",'v<integer>',
+'base::args','list',"'logical','NULL'",'list',
+'base::ncol','ncol',"'integer'",'integer',
+'base::diag<-','c',"'complex','complex'",'v<complex>',
+'base::diag<-','names',"'v<double>'",'NULL',
+'base::ifelse','ifelse',"'v<logical>','v<integer>','logical'",'v<integer>',
+'base::ifelse','ifelse',"'v<logical>','v<double>','logical'",'v<double>',
+'base::ifelse','ifelse',"'v<logical>','double','logical'",'v<double>',
+'base::ifelse','ifelse',"'logical','v<integer>','v<double>'",'logical',
+'base::ifelse','ifelse',"'logical','v<integer>','v<double>'",'integer',
+'base::ifelse','ifelse',"'logical','v<integer>','v<double>'",'double',
+'base::sweep','apply',"'list','double','function'",'v<double>',
+'base::sweep','-',"'integer','integer'",'integer',
+'base::sweep','as.array',"'v<integer>'",'integer',
+'base::sweep','list',"'v<integer>','v<integer>','v<integer>'",'list',
+'base::encodeString','cat',"'character','character','character'",'NULL',
+'base::encodeString','factor',"'character'",'integer',
+'base::...length','list',"'double','double','double','double','v<double>','character'",'list',
+'base::...length','names',"'list'",'NULL',
+'base::list2DF','list',"'character','character','v<character>'",'list',
+'base::stopifnot','<=',"'double','v<integer>'",'v<logical>',
+'base::stopifnot','length',"'{'",'integer',
+'base::stopifnot','list',"'{','list'",'list',
+'base::stopifnot','list',"'for','list'",'list',
+'base::polyroot','print',"'complex','double'",'complex',
+'base::polyroot','print',"'v<complex>','double'",'v<complex>',
+'base::slice.index','array',"'v<integer>','v<double>'",'integer',
+'base::plot','plot',"'function','double','double'",'list',
+'base::plot','plot',"'integer','character','character','double','character'",'v<double>',
+'base::plot','plot',"'v<double>','character','character'",'NULL',
+'base::match.arg','c',"'character','logical','character','character'",'v<character>',
+'base::.Platform','sapply',"'v<character>','function'",'v<logical>',
+'base::mode<-','typeof',"'NULL'",'character',
+'base::mode<-','typeof',"'integer'",'character',
+'base::mode<-','typeof',"'complex'",'character',
+'base::mode<-','typeof',"'function'",'character',
+'base::mode<-','typeof',"'v<integer>'",'character',
+'base::mode<-','typeof',"'('",'character',
+'base::format.AsIs','+',"'complex','complex'",'complex',
+'base::is.integer','as.integer',"'v<complex>'",'v<integer>',
+'base::is.integer','is.integer',"'double'",'logical',
+'base::drop','dim',"'integer'",'v<integer>',
+'base::month.name','-',"'complex','double'",'complex',
+'base::unlist','list',"'list','character','logical'",'list',
+'base::unlist','list',"'character','double','complex'",'list',
+'base::unlist','list',"'character','name','complex'",'list',
+'base::unlist','list',"'name','call','v<integer>','v<character>','expression'",'list',
+'base::all.equal','==',"'v<complex>','v<double>'",'v<logical>',
+'utils::changedFiles',':',"'integer','integer'",'v<integer>',
+'utils::packageDate','<',"'list','character'",'logical',
+'utils::as.roman','-',"'integer','v<double>'",'integer',
+'utils::as.roman','c',"'logical','v<integer>','character','v<character>'",'v<character>',
+'utils::as.roman','c',"'logical','v<integer>','v<character>'",'v<character>',
+'utils::as.roman','*',"'double','integer'",'integer',
+'utils::as.roman','*',"'integer','double'",'integer',
+'utils::as.roman','c',"'logical','v<integer>','logical','v<integer>'",'v<integer>',
+'utils::as.roman','as.list',"'integer'",'list',
+'utils::as.roman','as.list',"'v<integer>'",'list',
+'utils::as.roman','<',"'v<integer>','v<integer>'",'v<logical>',
+'utils::as.roman','<',"'integer','v<integer>'",'v<logical>',
+'utils::as.roman','<',"'integer','integer'",'v<logical>',
+'utils::as.roman','min',"'integer'",'integer',
+'utils::as.roman','min',"'integer','logical'",'integer',
+'utils::as.roman','min',"'v<integer>','logical'",'integer',
+'utils::as.roman','range',"'integer'",'integer',
+'utils::as.roman','sum',"'integer','logical'",'integer',
+'utils::strcapture','data.frame',"'character','integer','integer'",'list',
+'utils::remhash','list',"'environment'",'list',
+'utils::ls.str','print',"'character','double'",'character',
+'utils::ls.str','sapply',"'list','function','double'",'v<character>',
+'utils::read.delim2','c',"'v<integer>','character','character'",'v<character>',
+'utils::read.delim2','read.csv',"'character','logical'",'list',
+'utils::read.delim2','read.csv',"'character','logical','logical','v<character>'",'list',
+'utils::read.delim2','read.table',"'logical','character'",'list',
+'utils::hasName','is.null',"'double'",'logical',
+'utils::news','print',"'list','logical'",'list',
+'utils::news','==',"'list','character'",'v<logical>',
+'utils::hsearch_db_concepts','head',"'list','double'",'list',
+'utils::head.matrix','head',"'v<character>'",'v<character>',
+'utils::head.matrix','head',"'v<character>','integer'",'v<character>',
+'utils::head.matrix','head',"'double'",'v<double>',
+'utils::head.matrix','head',"'double'",'double',
+'utils::head.matrix','head',"'double','v<integer>'",'double',
+'utils::head.matrix','tail',"'v<character>','integer'",'v<character>',
+'utils::head.matrix','tail',"'double'",'v<double>',
+'utils::head.matrix','tail',"'double'",'double',
+'utils::head.matrix','tail',"'double','v<integer>'",'double',
+'utils::head.matrix','tail',"'double','v<double>'",'double',
+'utils::head.matrix','tail',"'double','v<double>','logical'",'double',
+'utils::head.matrix','nrow',"'double'",'NULL',
+'utils::methods','print',"'character','logical'",'character',
+'utils::object.size','print',"'double','character','character'",'double',
+'utils::object.size','sapply',"'v<character>','function'",'v<character>',
+'utils::object.size','as.vector',"'v<character>'",'v<character>',
+'utils::object.size','unique',"'v<character>'",'character',
+'utils::object.size','as.vector',"'double'",'double',
+'utils::charClass','c',"'character','character','character','character','character','character','character','character'",'v<character>',
+'utils::write.table','data.frame',"'character','complex'",'list',
+'utils::write.table','write.table',"'list','character','character','logical','character'",'NULL',
+'utils::write.table','read.table',"'character','logical','character','double'",'list',
+'utils::write.table','write.csv',"'list','character'",'NULL',
+'utils::write.table','read.csv',"'character','double'",'list',
+'utils::write.table','write.csv',"'list','character','logical'",'NULL',
+'utils::write.table','read.csv',"'character'",'list',
+'utils::apropos',':',"'double','complex'",'v<integer>',
+'utils::removeSource','attributes',"'function'",'list',
+'utils::removeSource','attributes',"'{'",'list',
+'utils::removeSource','attributes',"'function'",'NULL',
+'utils::removeSource','attributes',"'{'",'NULL',
+'utils::removeSource','attributes',"'expression'",'list',
+'utils::removeSource','attributes',"'expression'",'NULL',
+'utils::getParseText','as.character',"'integer'",'character',
+'utils::isS3method','paste',"'v<character>','character','character'",'v<character>',
+'utils::available.packages','table',"'character'",'integer',
+'utils::combn','==',"'double','integer'",'logical',
+'utils::combn','is.array',"'integer'",'logical',
+'utils::combn','c',"'integer','double'",'v<double>',
+'utils::example','sapply',"'v<character>','function','logical','logical'",'list',
+'utils::warnErrList','list',"'v<double>','v<double>','double','integer'",'list',
+'utils::warnErrList','list',"'v<double>','v<double>','double'",'list',
+'graphics::polypath','c',"'double','double','double','double','logical','double','double','double','double'",'v<double>',
+'graphics::polypath','is.na',"'logical'",'logical',
+'graphics::layout.show','plot',"'v<double>','v<double>','v<double>','v<double>','character','character'",'NULL',
+'graphics::matplot','*',"'v<double>','complex'",'v<complex>',
+'graphics::matplot','*',"'v<complex>','v<integer>'",'v<complex>',
+'graphics::matplot','*',"'v<integer>','complex'",'v<complex>',
+'graphics::matplot','*',"'v<complex>','v<double>'",'v<complex>',
+'graphics::matplot','list',"'NULL','v<character>','v<character>'",'list',
+'graphics::matplot','array',"'logical','v<double>','list'",'logical',
+'graphics::boxplot','list',"'v<double>','v<double>','integer'",'list',
+'graphics::box','plot',"'v<integer>','v<double>','character','logical'",'NULL',
+'graphics::axis.POSIXct','paste',"'double','v<double>','v<double>','v<double>'",'v<character>',
+'graphics::axis.POSIXct','plot',"'list','v<double>','character'",'NULL',
+'graphics::axis.POSIXct','plot',"'list','v<double>','character','character'",'NULL',
+'graphics::axis.POSIXct','range',"'list'",'list',
+'graphics::axis.POSIXct','plot',"'double','v<integer>','character','character','character','character','character'",'NULL',
+'graphics::axis.POSIXct','plot',"'double','v<integer>'",'NULL',
+'graphics::axis.POSIXct','plot',"'double','v<integer>','character'",'NULL',
+'graphics::curve','plot',"'function'",'list',
+'graphics::curve','plot',"'function','character'",'list',
+'graphics::curve','plot',"'function','complex','complex'",'list',
+'graphics::curve','paste0',"'character','character','character'",'character',
+'graphics::plot.default','plot',"'v<double>','v<double>','list','double','double','character'",'NULL',
+'graphics::plot.default','plot',"'v<double>','v<double>','NULL','double','double','character'",'NULL',
+'graphics::plot.default','/',"'complex','double'",'complex',
+'graphics::plot.default','c',"'character','character','character','character','character','character','character','character','character'",'v<character>',
+'graphics::plot.default','list',"'v<complex>','v<integer>'",'list',
+'graphics::plot.default','plot',"'formula','character','character'",'NULL',
+'graphics::plot.default','plot',"'v<double>','v<double>','character','character','character','character','expression','character'",'NULL',
+'graphics::plot.default','plot',"'v<double>','v<double>','character','character','character','character','character','expression','character','logical','logical'",'NULL',
+'graphics::pairs.default','list',"'v<double>','v<integer>','v<double>'",'list',
+'graphics::pairs.default','c',"'v<double>','double','double'",'v<double>',
+'graphics::pairs.default','/',"'v<integer>','integer'",'v<double>',
+'graphics::par','plot',"'v<integer>','character'",'NULL',
+'graphics::par','c',"'double','double','double','double','double','double','double','double','double','double','double','double','double'",'v<double>',
+'graphics::par','plot',"'v<integer>','character','character','character','character','character'",'NULL',
+'graphics::par','plot',"'v<integer>','v<integer>','character','logical','logical'",'NULL',
+'graphics::par','as.character',"'v<character>'",'v<character>',
+'graphics::par','paste',"'v<character>','character'",'v<character>',
+'graphics::hist.default','c',"'v<double>','v<double>','double','double','double'",'v<double>',
+'graphics::hist.default','sapply',"'list','integer'",'v<double>',
+'graphics::xyinch','plot',"'v<double>','v<double>','double','character'",'NULL',
+'graphics::mtext','plot',"'v<integer>','v<double>','character','character'",'NULL',
+'graphics::mtext','paste',"'character','integer','character','double','character'",'character',
+'graphics::image.default','seq',"'complex','complex','double'",'v<complex>',
+'graphics::polygon','c',"'double','v<double>','double','double','double','double','double','v<integer>'",'v<double>',
+'graphics::points','plot',"'v<integer>','v<integer>','character'",'NULL',
+'graphics::points','seq',"'double','complex','double'",'v<complex>',
+'graphics::points','plot',"'v<complex>','v<complex>','character','double','character','character','double','character'",'NULL',
+'graphics::points','plot',"'v<double>','v<integer>','character','logical'",'NULL',
+'graphics::points','plot',"'v<double>','v<double>','character','logical','character','character','character'",'NULL',
+'graphics::points','plot',"'v<double>','v<double>','character','logical','character','character','NULL'",'NULL',
+'graphics::points','plot',"'v<double>','v<double>','character','character','character','character','character','character'",'NULL',
+'graphics::grconvertX','plot',"'v<integer>'",'NULL',
+'graphics::spineplot','rep',"'v<double>','v<double>'",'v<double>',
+'graphics::spineplot','factor',"'v<double>','v<double>','v<character>'",'integer',
+'graphics::spineplot','c',"'double','double','double','double','double','double','double','double','double','double','double','double','double','double','double','double','double','double','double','double','double','double','double'",'v<double>',
+'graphics::title','list',"'character','double','character','double'",'list',
+'graphics::title','plot',"'double','character','character'",'NULL',
+'graphics::title','c',"'complex','complex','double','complex','complex'",'v<complex>',
+'graphics::persp','*',"'double','v<complex>'",'v<complex>',
+'graphics::persp','/',"'v<complex>','v<complex>'",'v<complex>',
+'graphics::mosaicplot','list',"'v<integer>','double'",'list',
+'graphics::axTicks','plot',"'v<integer>','v<double>'",'NULL',
+'graphics::axTicks','cat',"'v<character>','character','v<double>','character'",'NULL',
+'graphics::text.default','plot',"'v<integer>','v<integer>','character','character','character'",'NULL',
+'graphics::text.default','*',"'complex','double'",'complex',
+'graphics::text.default','*',"'complex','complex'",'complex',
+'graphics::text.default','plot',"'v<integer>','v<integer>','character','character'",'NULL',
+'graphics::strheight','unique',"'v<double>'",'double',
+'graphics::rect','c',"'logical','character'",'v<character>',
+'graphics::rect','c',"'logical','character','character','character'",'v<character>',
+'graphics::rect','c',"'logical','logical','double','double'",'v<double>',
+'graphics::grid','plot',"'v<double>','v<double>','v<integer>','v<double>','v<double>','list','character'",'NULL',
+'graphics::grid','plot',"'v<double>','v<double>','v<integer>','list','character'",'NULL',
+'graphics::grid','c',"'double','double','double','double','double','double','double','double'",'v<double>',
+'graphics::axis','plot',"'v<integer>','v<double>','logical'",'NULL',
+'graphics::axis','plot',"'v<integer>','v<double>','character','character','character','logical','character'",'NULL',
+'graphics::axis','plot',"'v<integer>','character','logical','logical'",'NULL',
+'graphics::axis','ifelse',"'v<logical>','character','character'",'v<character>',
+'graphics::axis','paste0',"'v<character>','character','v<character>'",'v<character>',
+'graphics::axis','seq_along',"'v<double>'",'v<integer>',
+'graphics::cdplot','factor',"'v<double>','v<integer>','v<character>'",'integer',
+'graphics::xspline','plot',"'v<double>','v<double>','character','logical','character','character'",'NULL',
+'graphics::xspline','plot',"'v<double>','v<double>','double'",'NULL',
+'graphics::bxp','list',"'double','double','double','character','double','character','double','double','logical'",'list',
+'graphics::abline','plot',"'v<double>','v<double>','character','character','character','double'",'NULL',
+'graphics::plot.window','plot',"'v<double>','v<double>','character','double','character','character'",'NULL',
+'graphics::clip','as.list',"'v<double>'",'list',
+'grDevices::rainbow','/',"'double','integer'",'double',
+'grDevices::rainbow','plot',"'v<integer>','v<double>','character','character','character','character'",'NULL',
+'grDevices::rainbow','min',"'integer','double'",'double',
+'grDevices::rainbow','min',"'double','double'",'double',
+'grDevices::rainbow','min',"'double','integer'",'double',
+'grDevices::check.options','list',"'v<integer>','complex','character'",'list',
+'grDevices::colorspaces','cbind',"'double','list'",'list',
+'grDevices::nclass.Sturges','c',"'double','integer','integer'",'v<double>',
+'grDevices::hsv','-',"'v<complex>'",'v<complex>',
+'grDevices::hsv','plot',"'v<complex>','logical','logical','character','character','double','double','v<character>','character'",'NULL',
+'grDevices::hcl','c',"'double','double','double','double','double','double','double','double','double','double','double','double','double','double','double','double','double','double','double','double','double','double','double','double','double','double','double','double','double','double','double','double','double','double','double','double','double','double','double','double','double','double','double','double','double','double','double','double','double','double','double','double','double','double','double','double'",'v<double>',
+'grDevices::is.raster','array',"'v<double>','v<double>'",'double',
+'grDevices::boxplot.stats','c',"'v<double>','logical'",'v<double>',
+'grDevices::boxplot.stats','seq',"'integer'",'integer',
+'grDevices::boxplot.stats','quantile',"'integer','v<double>','logical'",'v<double>',
+'grDevices::boxplot.stats','quantile',"'v<integer>','v<double>','logical'",'v<double>',
+'grDevices::xyz.coords','data.frame',"'v<double>','double'",'list',
+'grDevices::xyz.coords','data.frame',"'v<integer>','v<integer>','v<integer>'",'list',
+'grDevices::contourLines','vapply',"'list','function','double','character'",'v<double>',
+'grDevices::contourLines','vapply',"'list','function','double'",'v<double>',
+'methods::showExtends','typeof',"'S4'",'character',
+'methods::showExtends','class',"'mle'",'character',
+'methods::Complex','c',"'character','double'",'v<character>',
+'methods::callNextMethod','as.numeric',"'double'",'v<double>',
+'methods::callNextMethod','as.numeric',"'v<double>'",'v<double>',
+'methods::callNextMethod','+',"'double','double'",'v<double>',
+'methods::callNextMethod','*',"'double','double'",'v<double>',
+'methods::callNextMethod','<=',"'integer','integer'",'logical',
+'methods::callNextMethod','-',"'double','double'",'v<double>',
+'methods::slotNames','class',"'track'",'character',
+'methods::slotNames','lapply',"'v<character>','function','track'",'list',
+'methods::getValidity','paste',"'character','integer','character','integer','character'",'character',
+'methods::classesToAM','class',"'standardGeneric'",'character',
+'methods::classesToAM','class',"'derivedDefaultMethod'",'character',
+'methods::.S4methods','is.na',"'integer'",'logical',
+'methods::setClass','nrow',"'double'",'integer',
+'grid::grid.lines','c',"'v<double>','v<double>','v<double>','v<double>'",'v<double>',
+'grid::grid.text','c','','NULL',
+'grid::unit.rep','*',"'list','double'",'list',
+'grid::calcStringMetric','list',"'character','character','character','character','expression','expression','expression','expression','expression'",'list',
+'grid::calcStringMetric','is.character',"'character'",'logical',
+'grid::calcStringMetric','is.character',"'expression'",'logical',
+'tools::md5sum','as.vector',"'character'",'character',
+'tools::Adobe_glyphs','paste0',"'character','v<character>'",'v<character>',
+'tools::xgettext2pot','paste',"'character','character','character','character','character','character','character','character','character','character','character','character','character','character','character','character','character','character','character','character'",'character',
+'tools::standard_package_names','sapply',"'v<character>','function','character'",'v<character>',
+'tools::showNonASCII','cat',"'v<character>','character','character'",'NULL',
+'tools::Rd_db','lapply',"'list','function','character'",'list',
+'tools::Rd_db','sort',"'integer'",'integer',
+'tools::Rd_db','rev',"'integer'",'integer',
+'tools::bibstyle','seq_along',"'list'",'integer',
+'tools::package_dependencies','which',"'logical'",'integer',
+'tools::package_dependencies','head',"'integer'",'integer',
+'markdown::smartypants','cat',"'v<character>'",'NULL',
+'rjson::toJSON','list',"'v<integer>','NULL'",'list',
+'rjson::toJSON','list',"'v<integer>','character','list','v<logical>'",'list',
+'dplyr::group_by_drop_default','%>%',"'list','logical'",'logical',
+'dplyr::coalesce','c',"'v<integer>','logical','logical','logical'",'v<integer>',
+'dplyr::coalesce','list',"'double','double','NULL'",'list',
+'dplyr::coalesce','c',"'double','double','logical','logical','double'",'v<double>',
+'dplyr::join_by','c',"'integer','integer','integer','integer','integer'",'v<integer>',
+'dplyr::check_dbplyr','>=',"'list','character'",'logical',
+'dplyr::dense_rank','c',"'double','double','double','double','double','logical'",'v<double>',
+'dplyr::dense_rank','data.frame',"'v<double>','v<double>','v<double>','v<integer>'",'list',
+'dplyr::consecutive_id','c',"'logical','logical','logical','logical','logical','logical','logical','logical'",'v<logical>',
+'dplyr::distinct_at','is.numeric',"'v<double>'",'logical',
+'dplyr::do','head',"'integer','double'",'integer',
+'dplyr::cumany','/',"'v<double>','v<integer>'",'v<double>',
+'dplyr::cumany','data.frame',"'double','v<double>'",'list',
+'dplyr::cur_column','rep',"'v<character>','v<integer>'",'v<character>',
+'dplyr::case_match','c',"'character','character','character','character','character','logical','character','character'",'v<character>',
+'dplyr::case_match','c',"'double','double','double','double','double','logical','double','double'",'v<double>',
+'dplyr::n_distinct','c',"'double','double','logical','double','double'",'v<double>',
+'dplyr::rename','>',"'list','character'",'logical',
+'dplyr::rename','paste0',"'character','character','logical'",'character',
+'dplyr::funs','list',"'function','formula'",'list',
+'dplyr::funs','list',"'function','character','formula'",'list',
+'dplyr::if_else','%in%',"'integer','v<character>'",'v<logical>',
+'dplyr::if_else','ifelse',"'v<logical>','integer','logical'",'v<integer>',
+'dplyr::group_by_all','is.factor',"'v<double>'",'logical',
+'dplyr::group_by_all','is.factor',"'integer'",'logical',
+'dplyr::group_by_all','as.factor',"'v<double>'",'integer',
+'stringr::str_which','c',"'character','logical','character'",'v<character>',
+'stringr::str_width','c',"'character','character','character','logical'",'v<character>',
+'stringr::str_view','c',"'character','character','character','logical','character'",'v<character>',
+'stringr::str_replace_na','c',"'logical','character','character'",'v<character>',
+'stringr::str_match_all','c',"'character','character','character','character','logical'",'v<character>',
+'stringr::str_c','paste0',"'v<character>','character'",'v<character>',
+'stringr::str_c','paste0',"'v<integer>','v<integer>'",'v<character>',
+'rlang::int','list',"'double','integer'",'list',
+'rlang::int','list',"'double','double','integer'",'list',
+'rlang::inject','list',"'logical','double'",'list',
+'rlang::inject','mean',"'v<integer>','logical','double'",'double',
+'rlang::call_modify','list',"'NULL','double'",'list',
+'rlang::call_modify','list',"'NULL','name'",'list',
+'rlang::is_lgl_na','c',"'integer','logical','integer'",'v<integer>',
+'rlang::is_missing','list',"'double','name','double','name'",'list',
+'rlang::is_missing','is.null',"'name'",'logical',
+'rlang::dots_list','as.numeric',"'list'",'v<double>',
+'rlang::dots_list','as.numeric',"'list'",'double',
+'rlang::dots_list','list',"'double','name'",'list',
+'rlang::flatten_lgl','list',"'double','list','list'",'list',
+'rlang::na_lgl','typeof',"'logical'",'character',
+'rlang::names2<-','names',"'v<integer>'",'v<character>',
+'rlang::as_list','as.logical',"'list'",'logical',
+'rlang::as_list','as.integer',"'character'",'integer',
+'rlang::eval_bare','list',"'environment','environment'",'list',
+'rlang::%|%','c',"'character','character','logical','character'",'v<character>',
+'rlang::%|%','c',"'integer','logical','integer','logical','logical'",'v<integer>',
+'rlang::new_weakref','identical',"'environment','NULL'",'logical',
+'rlang::new_weakref','identical',"'list','NULL'",'logical',
+'rlang::exec','c',"'v<integer>','double','logical'",'v<double>',
+'rlang::exec','list',"'v<double>','logical'",'list',
+'rlang::exec','mean',"'v<double>','logical','double'",'double',
+'rlang::exec','list',"'call','call'",'list',
+'purrr::list_rbind','data.frame',"'v<integer>'",'list',
+'purrr::list_rbind','data.frame',"'character'",'list',
+'purrr::discard','list',"'character','NULL','integer','logical','list'",'list',
+'purrr::pmap','list',"'list','list','list'",'list',
+'purrr::pmap','data.frame',"'v<character>','v<character>','v<character>','logical'",'list',
+'purrr::pmap','data.frame',"'v<integer>','v<integer>','v<character>'",'list',
+'purrr::map_dbl','list',"'NULL','integer'",'list',
+'purrr::pluck_exists','list',"'character','list'",'list',
+'purrr::pluck_exists','list',"'double','function'",'list',
+'purrr::lift_lv','c',"'v<integer>','logical','double'",'v<double>',
+'purrr::lift_lv','list',"'v<double>','logical','double'",'list',
+'purrr::splice','list',"'list','v<character>'",'list',
+'purrr::splice','c',"'list','v<character>'",'list',
+'purrr::imodify','sample',"'v<logical>','double','logical'",'v<logical>',
+'purrr::imodify','list',"'v<logical>','v<integer>'",'list',
+'purrr::imodify','as.integer',"'v<double>'",'v<integer>',
+'purrr::imap_dbl','paste',"'integer','integer'",'character',
+'purrr::imap_dbl','paste0',"'integer','character','integer'",'character',
+'purrr::imap_dbl','cat',"'character','character','double','character','character'",'NULL',
+'purrr::list_assign','list',"'v<integer>','double','list'",'list',
+'purrr::list_assign','list',"'double','list','double'",'list',
+'purrr::lmap_at','list',"'v<integer>','v<character>','v<integer>','character'",'list',
+'purrr::lmap_at','paste0',"'character','integer'",'character',
+'purrr::lmap_at','is.character',"'v<integer>'",'logical',
+'purrr::as_mapper','list',"'double','character','double'",'list',
+'purrr::reduce','*',"'integer','integer'",'integer',
+'purrr::reduce','list',"'list','integer'",'list',
+'purrr::reduce','list',"'integer','list'",'list',
+'purrr::reduce','paste',"'v<double>','v<double>','v<double>'",'v<character>',
+'purrr::reduce','paste',"'v<character>','v<double>','v<double>'",'v<character>',
+'purrr::has_element','list',"'v<integer>','double','double'",'list',
+'purrr::map_depth','paste',"'integer','integer','character'",'character',
+'purrr::every','is.numeric',"'v<integer>'",'logical',
+'purrr::every','is.numeric',"'double'",'logical',
+'purrr::every','is.integer',"'v<integer>'",'logical',
+'purrr::every','is.character',"'double'",'logical',
+'purrr::map_if','is.numeric',"'integer'",'logical',
+'purrr::cross','>=',"'integer','integer'",'logical',
+'purrr::cross','setNames',"'list','v<character>'",'list',
+'purrr::list_along','seq_along',"'v<integer>'",'v<integer>',
+'purrr::list_simplify','list',"'double','double','v<integer>'",'list',
+'purrr::list_simplify','list',"'double','double','character'",'list',
+'purrr::negate','list',"'v<integer>','v<logical>','v<character>'",'list',
+'purrr::negate','is.numeric',"'v<logical>'",'logical',
+'purrr::negate','is.numeric',"'v<character>'",'logical',
+'purrr::modify_tree','list',"'v<integer>','list','list'",'list',
+'purrr::modify_tree','order',"'character'",'integer',
+'purrr::modify_tree','is.null',"'v<character>'",'logical',
+'purrr::modify_tree','order',"'v<character>'",'v<integer>',
+'purrr::list_flatten','list',"'double','double','double','double','double'",'list',
+'purrr::list_flatten','list',"'double','list','double','list'",'list',
+'tibble::deframe','list',"'double','v<integer>','v<integer>'",'list',
+'tibble::lst','list',"'double','call'",'list',
+'magrittr::%>%','%>%',"'list','function'",'list',
+'magrittr::%>%','%>%',"'list','double'",'list',
+'magrittr::%>%','%>%',"'character','character'",'character',
+'magrittr::%>%','paste0',"'character'",'character',
+'magrittr::%>%','%>%',"'v<integer>','character'",'v<character>',
+'magrittr::%>%','min',"'integer'",'double',
+'magrittr::%>%','max',"'integer'",'double',
+'magrittr::%>%','%>%',"'v<double>','v<double>'",'v<double>',
+'magrittr::%>%','%>%',"'v<double>','function'",'v<double>',
+'magrittr::%>%','sample',"'v<integer>','double'",'integer',
+'magrittr::%>%','head',"'integer','integer'",'integer',
+'magrittr::%>%','tail',"'integer','integer'",'integer',
+'readr::read_delim','vapply',"'v<character>','function','character'",'v<character>',
+'readr::read_lines','rownames',"'list'",'NULL',
+'readr::type_convert','data.frame',"'v<character>','v<character>','logical'",'list',
+'forcats::fct_relabel','paste0',"'character','v<double>'",'v<character>',
+'forcats::fct_relevel','lapply',"'list','function','character','double'",'list',
+'forcats::fct_anon','%>%',"'integer','integer'",'integer',
+'forcats::fct_c','c',"'integer','integer','integer'",'integer',
+'forcats::fct_c','list',"'integer','integer','integer'",'list',
+'forcats::fct_na_level_to_value','c',"'character','character','logical','character','character','logical'",'v<character>',
+'forcats::as_factor','as.factor',"'v<character>'",'integer',
+'forcats::fct_reorder','+',"'list','list'",'list',
+'forcats::fct_explicit_na','c',"'character','character','logical','logical','character','character','logical','character','character','character','character'",'v<character>',
+'/files/runnable/projects/figshare/35/Fulton_absentee.R','c',"'character','character','character','character','character','character','character','character','character','character','character','character','character','character','character','character','character','character','character','character','character','character','character','character','character','character','character','character','character','character','character','character','character','character','character','character','character','character','character','character','character','character','character','character','character','character','character','character','character','character','character','character','character','character','character','character','character','character','character','character','character','character','character','character','character','character','character','character','character','character','character','character','character','character','character','character','character','character','character','character','character','character','character','character','character','character','character','character','character','character','character','character','character','character','character','character','character','character','character','character','character','character','character','character','character','character','character','character','character','character','character','character','character','character','character','character','character','character','character','character','character','character','character','character','character','character','character','character','character','character','character','character','character','character','character','character','character','character','character','character','character','character','character','character','character','character','character','character','character','character','character','character','character','character','character','character','character','character','character','character','character','character','character','character','character','character','character','character','character','character','character','character','character','character','character'",'v<character>',
+'/files/runnable/projects/figshare/35/Fulton_absentee.R','c',"'double','integer','integer','integer'",'v<double>',
+'/files/runnable/projects/statistical/10/R replication code.R','==',"'v<integer>','character'",'v<logical>',
+'/files/runnable/projects/statistical/10/R replication code.R','list',"'v<integer>','v<integer>','double'",'list',
+'/files/runnable/projects/statistical/10/R replication code.R','print',"'jmcmMod'",'jmcmMod',
+'/files/runnable/projects/statistical/10/R replication code.R','typeof',"'jmcmMod'",'character',
+'/files/runnable/projects/statistical/10/R replication code.R','list',"'v<double>','v<double>','v<double>','v<double>','v<double>','v<double>','v<double>','v<double>','v<double>','v<double>','v<double>'",'list',
+'/files/runnable/projects/statistical/10/R replication code.R','list',"'jmcmMod','double'",'list',
+'/files/runnable/projects/statistical/10/R replication code.R','sapply',"'v<character>','function','logical'",'list',
+'/files/runnable/projects/statistical/10/R replication code.R','c',"'v<double>','double','v<double>'",'v<double>',
+'/files/runnable/projects/statistical/10/R replication code.R','list',"'double','v<integer>','v<double>'",'list',
+'/files/runnable/projects/statistical/10/R replication code.R','list',"'double','v<integer>','v<double>','v<double>','v<integer>'",'list',
+'/files/runnable/projects/statistical/12/R example code from the paper.R','typeof',"'v<double>'",'character',
+'/files/runnable/projects/statistical/2/R replication code.R','list',"'v<integer>','v<double>','v<double>','v<integer>'",'list',
+'/files/runnable/projects/statistical/2/R replication code.R','list',"'v<integer>','v<double>','v<double>'",'list',
+'/files/runnable/projects/statistical/2/R replication code.R','*',"'v<logical>','double'",'v<double>',
+'/files/runnable/projects/statistical/2/R replication code.R','tapply',"'v<integer>','v<integer>','integer'",'integer',
+'/files/runnable/projects/statistical/2/R replication code.R','names',"'integer'",'character',
+'/files/runnable/projects/statistical/2/R replication code.R','%in%',"'v<integer>','character'",'v<logical>',
+'/files/runnable/projects/statistical/2/R replication code.R','rbind',"'list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list'",'list',
+'/files/runnable/projects/statistical/2/R replication code.R','list',"'v<double>','NULL'",'list',
+'/files/runnable/projects/statistical/2/R replication code.R','list',"'double','NULL'",'list',
+'/files/runnable/projects/statistical/2/R replication code.R','is.matrix',"'v<double>'",'logical',
+'/files/runnable/projects/statistical/2/R replication code.R','tapply',"'v<double>','v<integer>','integer'",'double',
+'/files/runnable/projects/zenodo/103/correcting_MO2-2.R','read.table',"'character','double'",'list',
+'/files/runnable/projects/zenodo/103/correcting_MO2-2.R','tail',"'list'",'list',
+'/files/runnable/projects/zenodo/103/correcting_MO2-2.R','paste',"'v<character>','v<character>','character'",'v<character>',
+'/files/runnable/projects/zenodo/105/vabbshw_merge.R','read.csv',"'character','character','logical'",'list',
+'/files/runnable/projects/zenodo/105/vabbshw_merge.R','merge',"'list','list','character','logical'",'list',
+'/files/runnable/projects/zenodo/105/vabbshw_merge.R','merge',"'list','list','character'",'list',
+'/files/runnable/projects/zenodo/108/filedrawer.R','as.matrix',"'integer'",'integer',
+'/files/runnable/projects/zenodo/108/filedrawer.R','as.numeric',"'v<logical>'",'v<double>',
+'/files/runnable/projects/zenodo/117/reproducing_calculations.R','read.csv',"'character','logical','double','logical'",'list',
+'/files/runnable/projects/zenodo/117/reproducing_calculations.R','==',"'NULL','v<character>'",'logical',
+'/files/runnable/projects/zenodo/117/reproducing_calculations.R','typeof',"'v<character>'",'character',
+'/files/runnable/projects/zenodo/117/reproducing_calculations.R','c',"'v<character>','v<character>','v<character>','v<character>'",'v<character>',
+'/files/runnable/projects/zenodo/117/reproducing_calculations.R','*',"'list','list'",'list',
+'/files/runnable/projects/zenodo/117/reproducing_calculations.R','seq',"'double','integer'",'v<integer>',
+'/files/runnable/projects/zenodo/117/reproducing_calculations.R','c',"'NULL','integer'",'integer',
+'/files/runnable/projects/zenodo/118/RScript_Analysis_NoObsBias.R','cbind',"'list','v<double>','v<double>'",'list',
+'/files/runnable/projects/zenodo/13/FissionFusionRate.R','/',"'v<integer>','v<integer>'",'v<double>',
+'/files/runnable/projects/zenodo/15/Dmel Activity and Aggregation.R','c',"'integer','double','double'",'v<double>',
+'/files/runnable/projects/zenodo/151/pca-intervals_sam.R','read.csv',"'character','double','logical','character'",'list',
+'/files/runnable/projects/zenodo/160/10.survival_analysis_k100.R','data.frame',"'double','double','list'",'list',
+'/files/runnable/projects/zenodo/160/10.survival_analysis_k100.R','rbind',"'list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list'",'list',
+'/files/runnable/projects/zenodo/166/Vaziri_etal_2018_activity_fig.R','list',"'v<character>','v<double>'",'list',
+'/files/runnable/projects/zenodo/166/Vaziri_etal_2018_activity_fig.R','mean',"'v<double>','v<double>'",'double',
+'/files/runnable/projects/zenodo/166/Vaziri_etal_2018_activity_fig.R','rep',"'v<character>','integer'",'v<character>',
+'/files/runnable/projects/zenodo/166/Vaziri_etal_2018_activity_fig.R','data.frame',"'v<double>','v<double>','v<double>','v<character>'",'list',
+'/files/runnable/projects/zenodo/180/Fig_3-6_setup.R','==',"'NULL','character'",'logical',
+'/files/runnable/projects/zenodo/180/SoilPase_Fig_AGB_AGR.R','==',"'NULL','double'",'logical',
+'/files/runnable/projects/zenodo/180/SoilPase_Fig_Pase_x_TRT_Ndfa.R','cbind',"'list','list'",'list',
+'/files/runnable/projects/zenodo/180/SoilPase_Fig_Pase_x_TRT_Ndfa.R','min',"'v<double>','logical'",'double',
+'/files/runnable/projects/zenodo/180/SoilPase_Fig_Pase_x_TRT_Ndfa.R','max',"'v<double>','logical'",'double',
+'/files/runnable/projects/zenodo/184/06_ScholExplorer_harvest_Flemish_universities.R','read.table',"'character','logical','character','character','logical','character','character','NULL','logical','logical','character','logical'",'list',
+'/files/runnable/projects/zenodo/195/comparativegreetings-analysis(1).R','read.table',"'character','logical','character'",'list',
+'/files/runnable/projects/zenodo/195/comparativegreetings-analysis(1).R','list',"'character','logical','logical'",'list',
+'/files/runnable/projects/zenodo/195/comparativegreetings-analysis(1).R','list',"'v<integer>','v<character>','v<integer>','v<double>','v<double>','v<integer>','v<integer>','v<double>','v<character>','v<character>'",'list',
+'/files/runnable/projects/zenodo/195/comparativegreetings-analysis(1).R','list',"'v<integer>','v<character>','v<integer>','v<double>','v<double>','v<integer>','v<integer>','v<double>'",'list',
+'/files/runnable/projects/zenodo/195/comparativegreetings-analysis(1).R','list',"'v<integer>','v<character>','v<integer>','v<double>','v<double>','v<character>'",'list',
+'/files/runnable/projects/zenodo/195/comparativegreetings-analysis(1).R','list',"'v<integer>','v<character>','v<character>','v<integer>','v<double>','v<double>','v<character>'",'list',
+'/files/runnable/projects/zenodo/195/comparativegreetings-analysis(1).R','anova',"'glmerMod','glmerMod','character'",'list',
+'/files/runnable/projects/zenodo/195/comparativegreetings-analysis(1).R','list',"'v<integer>','v<character>','v<integer>','v<double>','v<double>','v<integer>','v<double>','v<character>','v<character>'",'list',
+'/files/runnable/projects/zenodo/195/comparativegreetings-analysis(1).R','list',"'v<integer>','v<character>','v<integer>','v<double>','v<double>','v<integer>','v<double>'",'list',
+'/files/runnable/projects/zenodo/195/comparativegreetings-analysis(1).R','list',"'v<integer>','v<character>','v<integer>','v<double>','v<integer>','v<integer>','v<double>','v<character>','v<double>','v<character>'",'list',
+'/files/runnable/projects/zenodo/195/comparativegreetings-analysis(1).R','list',"'v<integer>','v<character>','v<integer>','v<double>','v<integer>','v<integer>','v<double>'",'list',
+'/files/runnable/projects/zenodo/195/comparativegreetings-analysis(1).R','list',"'v<integer>','v<character>','v<integer>','v<double>','v<double>','v<integer>','v<integer>','v<character>','v<character>'",'list',
+'/files/runnable/projects/zenodo/195/comparativegreetings-analysis(1).R','list',"'v<integer>','v<character>','v<integer>','v<double>','v<double>','v<integer>','v<integer>'",'list',
+'/files/runnable/projects/zenodo/195/comparativegreetings-analysis(1).R','summary',"'glmerMod'",'list',
+'/files/runnable/projects/zenodo/195/comparativegreetings-analysis(1).R','anova',"'glmerMod','glmerMod'",'list',
+'/files/runnable/projects/zenodo/26/Box_3_Honeybee_Example_NBDA_Code.R','array',"'logical','v<double>'",'logical',
+'/files/runnable/projects/zenodo/26/Box_3_Honeybee_Example_NBDA_Code.R','data.frame',"'v<double>','v<character>','v<double>','v<double>','v<double>','v<double>','v<double>'",'list',
+'/files/runnable/projects/zenodo/26/NBDA_Tutorial_1_fitting_OADA_models.R','c',"'double','double','double','double','double','double','double','double','double','double','double','double','double','double','double','double','double','double','double','double','double','double','double','double','double','double','double','double','double','double'",'v<double>',
+'/files/runnable/projects/zenodo/26/NBDA_Tutorial_1_fitting_OADA_models.R','data.frame',"'character','double','double'",'list',
+'/files/runnable/projects/zenodo/3/main-analyses.R','is.factor',"'v<character>'",'logical',
+'/files/runnable/projects/zenodo/41/Statistical_analyses.R','list',"'v<double>','v<double>','v<double>','v<double>','v<double>','integer','v<double>'",'list',
+'/files/runnable/projects/zenodo/41/Statistical_analyses.R','glm',"'formula','list','character'",'list',
+'/files/runnable/projects/zenodo/52/scaleAnalysis.R','predict',"'glmerMod'",'v<double>',
+'/files/runnable/projects/zenodo/52/scaleAnalysis.R','rep',"'logical','integer'",'v<logical>',
+'/files/runnable/projects/zenodo/52/scaleAnalysis.R','cov',"'v<double>','v<double>'",'double',
+'/files/runnable/projects/zenodo/55/1DegreeMetrics.R','>=',"'double','double'",'v<logical>',
+'/files/runnable/projects/zenodo/55/1DegreeMetrics.R','<=',"'double','double'",'v<logical>',
+'/files/runnable/projects/zenodo/55/1DegreeMetrics.R','%in%',"'v<integer>','v<integer>'",'v<logical>',
+'/files/runnable/projects/zenodo/55/1DegreeMetrics.R','max',"'integer'",'integer',
+'/files/runnable/projects/zenodo/55/1DegreeMetrics.R','data.frame',"'character','double','integer','integer','integer'",'list',
+'/files/runnable/projects/zenodo/55/1DegreeMetrics.R','rbind',"'list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list','list'",'list',
+'/files/runnable/projects/zenodo/55/2RealDataModels.R','list',"'v<integer>','v<double>','v<character>'",'list',
+'/files/runnable/projects/zenodo/55/4RandomizationTest.R','merge',"'list','list','character','double','logical','logical'",'list',
+'/files/runnable/projects/zenodo/69/R_Code_all_weeks_all_phenotypes_for_object_effects.R','list',"'double','integer','integer'",'list',
+'/files/runnable/projects/zenodo/73/R_script_Fig_3c_neurite_length.R','list',"'integer','v<character>','character','v<double>'",'list',
+'/files/runnable/projects/zenodo/73/R_script_Fig_3c_neurite_length.R','is.null',"'v<double>'",'logical',
+'/files/runnable/projects/zenodo/73/R_script_Fig_3c_neurite_length.R','list',"'v<double>','v<double>','v<double>','double'",'list',
+'/files/runnable/projects/zenodo/73/R_script_Fig_3d_relative_to_TCP.R','list',"'v<double>','integer','v<character>'",'list',
+'/files/runnable/projects/zenodo/73/R_script_Fig_3d_relative_to_TCP.R','list',"'v<character>','character','character','v<double>'",'list',
+'/files/runnable/projects/zenodo/73/R_script_Fig_4d_4e_positive_cell_fraction.R','list',"'v<character>','character','v<double>'",'list',
+'/files/runnable/projects/zenodo/73/R_script_Fig_4f_relative_to_TCP.R','list',"'v<character>','character','character'",'list',
+'/files/runnable/projects/zenodo/73/R_script_Fig_5d_eccentricity.R','*',"'integer','v<double>'",'v<double>',
+'/files/runnable/projects/zenodo/73/R_script_Fig_5d_eccentricity.R','-',"'v<integer>','v<double>'",'v<double>',
+'/files/runnable/projects/zenodo/73/R_script_Fig_5e_cell_replication.R','aggregate',"'list','list','function'",'list',
+'/files/runnable/projects/zenodo/73/R_script_Fig_5f_absolute_levels.R','paste',"'integer','v<character>'",'v<character>',
+'/files/runnable/projects/zenodo/73/R_script_Fig_5f_absolute_levels.R','/',"'v<double>','double'",'double',
+'/files/runnable/projects/zenodo/73/R_script_Fig_5f_absolute_levels.R','list',"'v<double>','v<character>','v<character>','v<character>'",'list',
+'/files/runnable/projects/zenodo/73/R_script_Fig_5f_absolute_levels.R','list',"'logical','list'",'list',
+'/files/runnable/projects/zenodo/74/Adult_towards_potentialEPoffspring.R','read.csv',"'character','logical','character'",'list',
+'/files/runnable/projects/zenodo/74/Adult_towards_potentialEPoffspring.R','as.character',"'double'",'v<character>',
+'/files/runnable/projects/zenodo/74/Adult_towards_potentialEPoffspring.R','%in%',"'v<character>','v<double>'",'v<logical>',
+'/files/runnable/projects/zenodo/74/Adult_towards_potentialEPoffspring.R','min',"'v<double>','v<double>'",'double',
+'/files/runnable/projects/zenodo/74/Adult_towards_potentialEPoffspring.R','%in%',"'v<character>','double'",'v<logical>',
+'/files/runnable/projects/zenodo/74/Adult_towards_potentialEPoffspring.R','%in%',"'v<integer>','integer'",'v<logical>',
+'/files/runnable/projects/zenodo/74/Adult_towards_potentialEPoffspring.R','min',"'double','v<double>'",'double',
+'/files/runnable/projects/zenodo/74/Adult_towards_potentialEPoffspring.R','%in%',"'double','double'",'logical',
+'/files/runnable/projects/zenodo/74/Adult_towards_potentialEPoffspring.R','%in%',"'double','v<double>'",'logical',
+'/files/runnable/projects/zenodo/74/Figure3a_Adult_towards_OwnSocialOffspring.R','%in%',"'v<integer>','v<character>'",'v<logical>',
+'/files/runnable/projects/zenodo/74/Figure3a_Adult_towards_OwnSocialOffspring.R','list',"'v<double>','v<double>','v<integer>','v<integer>'",'list',
+'/files/runnable/projects/zenodo/74/Figure3a_Adult_towards_OwnSocialOffspring.R','predict',"'glmerMod','list','character','formula'",'v<double>',
+'/files/runnable/projects/zenodo/74/Figure3a_Adult_towards_OwnSocialOffspring.R','sapply',"'double','function'",'v<double>',
+'/files/runnable/projects/zenodo/74/Figure3a_Adult_towards_OwnSocialOffspring.R','sample',"'v<integer>','integer','logical'",'v<integer>',
+'/files/runnable/projects/zenodo/74/Figure3a_Adult_towards_OwnSocialOffspring.R','is.null',"'glmerMod'",'logical',
+'/files/runnable/projects/zenodo/74/Figure3a_Adult_towards_OwnSocialOffspring.R','data.frame',"'v<double>','v<double>','double'",'list',
+'/files/runnable/projects/zenodo/74/Figure3a_Adult_towards_OwnSocialOffspring.R','c',"'NULL','character'",'character',
+'/files/runnable/projects/zenodo/74/Figure3b_Adult_towards_GeneticOffspring.R','data.frame',"'v<integer>','v<character>'",'list',
+'/files/runnable/projects/zenodo/74/Figure3b_Adult_towards_GeneticOffspring.R','min',"'NULL'",'double',
+'/files/runnable/projects/zenodo/74/Figure3b_Adult_towards_GeneticOffspring.R','max',"'NULL'",'double',
+'/files/runnable/projects/zenodo/74/Figure3b_Adult_towards_GeneticOffspring.R','data.frame',"'v<integer>','v<integer>','v<integer>','v<double>','v<double>'",'list',
+'/files/runnable/projects/zenodo/74/Figure4b_Adult_towards_BeggingNonOffspring.R','>',"'v<integer>','v<integer>'",'v<logical>',
+'/files/runnable/projects/zenodo/83/Marie-Orleach.et.al_R.SCRIPT_MAIN.R','data.frame',"'double','double','double','double','double','double','double','double','double','double','double','double','double'",'list',
+'/files/runnable/projects/zenodo/83/Marie-Orleach.et.al_R.SCRIPT_MAIN.R','match',"'v<integer>','v<integer>'",'v<integer>',
+'/files/runnable/projects/zenodo/83/Marie-Orleach.et.al_R.SCRIPT_MAIN.R','data.frame',"'double','double','double','double','double'",'list',
+'/files/runnable/projects/zenodo/9/plutniak2021.R','list',"'v<character>','v<character>','v<character>','v<character>','v<character>','v<character>'",'list',
diff --git a/src/typing/adapter/traced-function-types.ts b/src/typing/adapter/traced-function-types.ts
new file mode 100644
index 00000000000..5fd667e0d40
--- /dev/null
+++ b/src/typing/adapter/traced-function-types.ts
@@ -0,0 +1,92 @@
+import type { UnresolvedDataType } from '../subtyping/types';
+import { constrain, getParameterTypeFromFunction, UnresolvedRAtomicVectorType, UnresolvedRFunctionType, UnresolvedRListType } from '../subtyping/types';
+import { RComplexType, RDoubleType, REnvironmentType, RIntegerType, RLanguageType, RLogicalType, RNullType, RRawType, RStringType } from '../types';
+import type { RohdeFunctionTypeInformation } from './interface';
+
+export interface TraceCsvRow {
+	readonly packageName:   string;
+	readonly functionName:  string;
+	readonly argumentTypes: string;
+	readonly returnType:    string;
+}
+
+export function extractTypesFromTraceData(data: readonly TraceCsvRow[]): [RohdeFunctionTypeInformation[], Map<string, number>] {
+	const extractedTypes: Map<string, Map<string, UnresolvedRFunctionType[]>> = new Map();
+	const unseenSignaturePackageContributions: Map<string, Set<string>> = new Map();
+
+	for(const row of data) {
+		const argumentTypes = row.argumentTypes.split(',').map(str => typeFromStr(str.trim(), true));
+		const returnType = typeFromStr(row.returnType.trim());
+
+		const signature = `${row.functionName} : (${row.argumentTypes}) -> ${row.returnType}`;
+		if(!unseenSignaturePackageContributions.values().some(set => set.has(signature))) {
+			if(!unseenSignaturePackageContributions.has(row.packageName)) {
+				unseenSignaturePackageContributions.set(row.packageName, new Set([signature]));
+			} else {
+				// eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+				unseenSignaturePackageContributions.get(row.packageName)!.add(signature);
+			}
+		}
+
+		const functionType = new UnresolvedRFunctionType();
+		for(const [index, type] of argumentTypes.entries()) {
+			constrain(getParameterTypeFromFunction(functionType, index), type);
+		}
+		constrain(returnType, functionType.returnType);
+
+		if(!extractedTypes.has(row.packageName)) {
+			extractedTypes.set(row.packageName, new Map());
+		}
+		// eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+		const packageMap = extractedTypes.get(row.packageName)!;
+		if(!packageMap.has(row.functionName)) {
+			packageMap.set(row.functionName, []);
+		}
+		// eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+		packageMap.get(row.functionName)!.push(functionType);
+	}
+
+	const functionTypeInfos = extractedTypes.entries().flatMap(([packageName, map]) => map.entries().map(([functionName, types]) => ({
+		name:    functionName,
+		package: packageName,
+		types:   types
+	}))).toArray();
+	const unseenSignaturePackageContributionCounts = new Map(unseenSignaturePackageContributions.entries().map(([packageName, signatures]) => [packageName, signatures.size] as const));
+	return [functionTypeInfos, unseenSignaturePackageContributionCounts];
+}
+
+function typeFromStr(str: string, hasNegativePolarity: boolean = false): UnresolvedDataType {
+	if(str.startsWith('v<') && str.endsWith('>')) {
+		const vectorType = new UnresolvedRAtomicVectorType();
+		if(hasNegativePolarity) {
+			constrain(vectorType.elementType, typeFromStr(str.slice(2, -1)));
+		} else {
+			constrain(typeFromStr(str.slice(2, -1)), vectorType.elementType);
+		}
+		return vectorType;
+	} else if(str === 'function') {
+		return new UnresolvedRFunctionType();
+	} else if(str === 'list') {
+		return new UnresolvedRListType();
+	} else if(str === 'logical') {
+		return new RLogicalType();
+	} else if(str === 'integer') {
+		return new RIntegerType();
+	} else if(str === 'double') {
+		return new RDoubleType();
+	} else if(str === 'complex') {
+		return new RComplexType();
+	} else if(str === 'character') {
+		return new RStringType();
+	} else if(str === 'raw') {
+		return new RRawType();
+	} else if(str === 'NULL') {
+		return new RNullType();
+	} else if(str === 'formula' || str === 'expression' || str === 'name' || str === 'symbol' || str === 'language' || str === 'call') {
+		return new RLanguageType();
+	} else if(str === 'environment') {
+		return new REnvironmentType();
+	} else {
+		throw new Error(`Unknown type: ${str}`);
+	}
+}
\ No newline at end of file
diff --git a/src/typing/adapter/turcotte-types.ts b/src/typing/adapter/turcotte-types.ts
index 2cf02bcae9e..671fa1250bd 100644
--- a/src/typing/adapter/turcotte-types.ts
+++ b/src/typing/adapter/turcotte-types.ts
@@ -23,22 +23,7 @@ import {
 	UnresolvedRTypeVariable
 } from '../subtyping/types';
 import { jsonReplacer } from '../../util/json';
-
-export interface RohdeFunctionTypeInformation {
-    readonly name:    string;
-    readonly package: string;
-    readonly types:   readonly UnresolvedRFunctionType[]
-}
-
-export interface RohdeConstantTypeInformation {
-    readonly name:    string;
-    readonly package: string;
-    readonly type:    UnresolvedDataType;
-}
-
-export interface RohdeTypes {
-    readonly info: (RohdeFunctionTypeInformation | RohdeConstantTypeInformation)[];
-}
+import type { RohdeFunctionTypeInformation, RohdeTypes } from './interface';
 
 export interface TurcotteCsvRow {
     readonly package_name:       string;
diff --git a/src/typing/subtyping/infer.ts b/src/typing/subtyping/infer.ts
index c8ab18ada20..f9f2ba18a50 100644
--- a/src/typing/subtyping/infer.ts
+++ b/src/typing/subtyping/infer.ts
@@ -24,13 +24,10 @@ import { RType } from '../../r-bridge/lang-4.x/ast/model/type';
 import type { NoInfo, RNode } from '../../r-bridge/lang-4.x/ast/model/model';
 import { RFalse, RTrue } from '../../r-bridge/lang-4.x/convert-values';
 import type { UnresolvedDataType } from './types';
-import { constrain, getIndexedElementTypeFromList, getParameterTypeFromFunction, resolve, UnresolvedRAtomicVectorType, UnresolvedRFunctionType, UnresolvedRListType, UnresolvedRTypeIntersection, UnresolvedRTypeUnion, UnresolvedRTypeVariable } from './types';
-import type { RohdeTypes, TurcotteCsvRow } from '../adapter/turcotte-types';
-import { turcotte2RohdeTypes } from '../adapter/turcotte-types';
-import csvParser from 'csv-parser';
-import fs from 'fs';
+import { constrain, getIndexedElementTypeFromList, getParameterTypeFromFunction, resolve, UnresolvedRAtomicVectorType, UnresolvedRFunctionType, UnresolvedRListType, UnresolvedRTypeUnion, UnresolvedRTypeVariable } from './types';
 
-export function inferDataTypes<Info extends ParentInformation & { typeVariable?: undefined }>(ast: NormalizedAst<ParentInformation & Info>, dataflowInfo: DataflowInformation, useTurcotteTypes: boolean = true): NormalizedAst<Info & DataTypeInfo> {
+
+export function inferDataTypes<Info extends ParentInformation & { typeVariable?: undefined }>(ast: NormalizedAst<ParentInformation & Info>, dataflowInfo: DataflowInformation, knownTypes: Map<string, UnresolvedDataType> = new Map()): NormalizedAst<Info & DataTypeInfo> {
 	const astWithTypeVars = decorateTypeVariables(ast);
 	const controlFlowInfo = extractCfg(astWithTypeVars, dataflowInfo.graph, ['unique-cf-sets', 'analyze-dead-code', 'remove-dead-code']);
 	const config = {
@@ -39,7 +36,7 @@ export function inferDataTypes<Info extends ParentInformation & { typeVariable?:
 		dataflowInfo:         dataflowInfo,
 		dfg:                  dataflowInfo.graph,
 		defaultVisitingOrder: 'forward' as const,
-		useTurcotteTypes,
+		knownTypes,
 	};
 	const visitor = new TypeInferringCfgGuidedVisitor(config);
 	visitor.start();
@@ -60,9 +57,6 @@ function resolveTypeVariables<Info extends ParentInformation & UnresolvedTypeInf
 	return mapNormalizedAstInfo(ast, node => {
 		const { typeVariable, ...rest } = node.info;
 		const resolvedType = resolve(typeVariable, undefined, prunedVariables);
-		// if(node.lexeme === 'y') {
-		// 	console.debug('Resolving type variable', inspect(typeVariable, { depth: null, colors: true }), 'to', inspect(resolvedType, { depth: null, colors: true }));
-		// }
 		return { ...rest, inferredType: resolvedType };
 	});
 }
@@ -73,8 +67,8 @@ export interface TypeInferringCfgGuidedVisitorConfiguration<
 	Ast extends NormalizedAst<UnresolvedTypeInfo & OtherInfo> = NormalizedAst<UnresolvedTypeInfo & OtherInfo>,
 	Dataflow extends DataflowInformation                      = DataflowInformation
 > extends Omit<SemanticCfgGuidedVisitorConfiguration<UnresolvedTypeInfo & OtherInfo, ControlFlow, Ast>, 'dataflow'> {
-	dataflowInfo:     Dataflow;
-	useTurcotteTypes: boolean;
+	dataflowInfo: Dataflow;
+	knownTypes:   Map<string, UnresolvedDataType>;
 }
 
 class TypeInferringCfgGuidedVisitor<
@@ -87,32 +81,10 @@ class TypeInferringCfgGuidedVisitor<
 	constructor(config: Config) {
 		super({ dataflow: config.dataflowInfo.graph, ...config });
 
-		if(config.useTurcotteTypes) {
-			const data: TurcotteCsvRow[] = [];
-			fs.createReadStream('src/typing/adapter/turcotte-types.csv', { encoding: 'utf-8' })
-				.pipe(csvParser({ separator: ',' }))
-				.on('data', (row: TurcotteCsvRow) => {
-					data.push(row);
-				});
-			const rohdeTypes: RohdeTypes = turcotte2RohdeTypes(data);
-			for(const info of rohdeTypes.info) {
-				const label = info.name; //`${info.package}::${info.name}`;
-				if('type' in info) {
-					this.constantContext.set(label, info.type);
-				}
-				if('types' in info) {
-					const type = info.types.length === 1 ? info.types[0] : new UnresolvedRTypeIntersection(...info.types);
-					this.functionContext.set(label, type);
-				}
-			}
-		}
-
 		Error.stackTraceLimit = 100; // Increase stack trace limit for better debugging
 	}
 
 	protected constraintCache: Map<UnresolvedDataType, Set<UnresolvedDataType>> = new Map();
-	protected constantContext: Map<string, UnresolvedDataType> = new Map();
-	protected functionContext: Map<string, UnresolvedDataType> = new Map();
 
 
 	protected constrainNodeType(nodeOrId: RNode<UnresolvedTypeInfo> | NodeId, constraint: UnresolvedDataType | { lowerBound?: UnresolvedDataType, upperBound?: UnresolvedDataType }): void {
@@ -172,14 +144,9 @@ class TypeInferringCfgGuidedVisitor<
 		if(hasUnresolvableOrigins) {
 			if(node.type === RType.Symbol) {
 				// If the read variable has no associated AST node it might be a library constant or function
-				const constantType = this.constantContext.get(node.content);
-				if(constantType !== undefined) {
-					this.constrainNodeType(node, { lowerBound: constantType });
-				}
-
-				const functionType = this.functionContext.get(node.content);
-				if(functionType !== undefined) {
-					this.constrainNodeType(node, { lowerBound: functionType });
+				const contextualType = this.config.knownTypes.get(node.content);
+				if(contextualType !== undefined) {
+					this.constrainNodeType(node, { lowerBound: contextualType });
 				}
 			}
 		} else if(lowerBounds.size > 0) {
@@ -248,9 +215,9 @@ class TypeInferringCfgGuidedVisitor<
 				}
 			} else {
 				// If the target function has no associated AST node it might be a library function
-				const contextFunctionType = this.functionContext.get(data.call.name);
-				if(contextFunctionType !== undefined) {
-					constrain(contextFunctionType, functionType, this.constraintCache);
+				const contextualType = this.config.knownTypes.get(data.call.name);
+				if(contextualType !== undefined) {
+					constrain(contextualType, functionType, this.constraintCache);
 				}
 			}
 		}

From d021183bc1a2bacd81d8fea30a6ec7e5dce12506 Mon Sep 17 00:00:00 2001
From: Lukas Rohde <lukas.rohde@silupe.de>
Date: Wed, 6 Aug 2025 00:17:18 +0200
Subject: [PATCH 125/153] refactor(typing): change compression format for json
 datatype queries

---
 src/cli/repl/commands/repl-query.ts | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/src/cli/repl/commands/repl-query.ts b/src/cli/repl/commands/repl-query.ts
index 86a83ec459d..25671f44ad1 100644
--- a/src/cli/repl/commands/repl-query.ts
+++ b/src/cli/repl/commands/repl-query.ts
@@ -11,7 +11,7 @@ import type { PipelineOutput } from '../../../core/steps/pipeline/pipeline';
 import { jsonReplacer } from '../../../util/json';
 import { asciiSummaryOfQueryResult } from '../../../queries/query-print';
 import type { KnownParser } from '../../../r-bridge/parser';
-import { compressToUTF16 } from 'lz-string';
+import { compressToBase64 } from 'lz-string';
 
 
 async function getDataflow(parser: KnownParser, remainingLine: string) {
@@ -96,7 +96,7 @@ export const queryStarCommand: ReplCommand = {
 	fn:           async(output, shell, remainingLine) => {
 		const results = await processQueryArgs(remainingLine, shell, output);
 		if(results) {
-			output.stdout(compressToUTF16(JSON.stringify(results.query, jsonReplacer)));
+			output.stdout(compressToBase64(JSON.stringify(results.query, jsonReplacer)));
 		}
 	}
 };

From 776cdb334e01d650b1d34efe59db9a003d7352dd Mon Sep 17 00:00:00 2001
From: Lukas Rohde <lukas.rohde@silupe.de>
Date: Wed, 6 Aug 2025 10:38:42 +0200
Subject: [PATCH 126/153] build-fix(merge): fix merge conflicts

---
 .../repl/commands/repl-turcotte-type-parse.ts | 24 +++++++++----------
 src/typing/subtyping/infer.ts                 |  4 +++-
 src/typing/unification/infer.ts               |  4 +++-
 .../typing/subtyping/assert-inferred-type.ts  | 10 ++++----
 .../unification/assert-inferred-type.ts       | 12 ++++++----
 5 files changed, 31 insertions(+), 23 deletions(-)

diff --git a/src/cli/repl/commands/repl-turcotte-type-parse.ts b/src/cli/repl/commands/repl-turcotte-type-parse.ts
index 428c4cd4fd7..6b77b5735f5 100644
--- a/src/cli/repl/commands/repl-turcotte-type-parse.ts
+++ b/src/cli/repl/commands/repl-turcotte-type-parse.ts
@@ -18,26 +18,26 @@ export const replTurcotteTypeParseCommand: ReplCommand = {
 	usageExample: ':turcotte-type-parse foo.csv out.data',
 	aliases:      [ 'ttp',],
 	script:       false,
-	fn:           async(output, _shell, remainingLine) => {
+	fn:           async(info) => {
 		const now = new Date();
-		if(!remainingLine.trim()) {
-			output.stderr('Please provide a file to read from. You do not need a prefix, just the file path.');
+		if(!info.remainingLine.trim()) {
+			info.output.stderr('Please provide a file to read from. You do not need a prefix, just the file path.');
 			return;
 		}
-		const args = splitAtEscapeSensitive(remainingLine.trim());
+		const args = splitAtEscapeSensitive(info.remainingLine.trim());
 		if(args.length < 1 || args.length > 2) {
-			output.stderr(`Expected a single file to read from and and optional one to write to, got: ${JSON.stringify(args)}`);
+			info.output.stderr(`Expected a single file to read from and and optional one to write to, got: ${JSON.stringify(args)}`);
 			return;
 		}
 		const [readFilePath, writeFilePath] = args as [string, string | undefined];
-		const readFile = findSource(readFilePath.trim(), { referenceChain: [] });
+		const readFile = findSource(undefined, readFilePath.trim(), { referenceChain: [] });
 		if(readFile?.length !== 1) {
-			output.stderr(`Could not find a single file to read from. Got: ${JSON.stringify(readFile)}`);
+			info.output.stderr(`Could not find a single file to read from. Got: ${JSON.stringify(readFile)}`);
 			return;
 		}
-		const writeFile = writeFilePath ? findSource(writeFilePath.trim(), { referenceChain: [] }) : undefined;
+		const writeFile = writeFilePath ? findSource(undefined, writeFilePath.trim(), { referenceChain: [] }) : undefined;
 		if(writeFilePath && writeFile && writeFile.length > 0) {
-			output.stderr(`The output file already exists, will not overwrite: ${writeFilePath}`);
+			info.output.stderr(`The output file already exists, will not overwrite: ${writeFilePath}`);
 			return;
 		}
 
@@ -53,16 +53,16 @@ export const replTurcotteTypeParseCommand: ReplCommand = {
 		});
 		const rohdeTypes: RohdeTypes = turcotte2RohdeTypes(data);
 
-		output.stdout(`Parsed ${rohdeTypes.info.length} functions from ${readFile[0]} in ${Date.now() - now.getTime()}ms.`);
+		info.output.stdout(`Parsed ${rohdeTypes.info.length} functions from ${readFile[0]} in ${Date.now() - now.getTime()}ms.`);
 
 		if(writeFilePath) {
 			const startWrite = Date.now();
 			fs.writeFileSync(writeFilePath, compressToUTF16(dumpRohdeTypesFromTurcotte(rohdeTypes)), { encoding: 'utf-16le' });
-			output.stdout(`Wrote ${rohdeTypes.info.length} functions to ${writeFilePath} in ${Date.now() - startWrite}ms.`);
+			info.output.stdout(`Wrote ${rohdeTypes.info.length} functions to ${writeFilePath} in ${Date.now() - startWrite}ms.`);
 			const startRead = Date.now();
 			const loadCheck = decompressFromUTF16(fs.readFileSync(writeFilePath, { encoding: 'utf-16le' }));
 			const recovered = recoverRohdeTypesFromTurcotteFromDump(loadCheck);
-			output.stdout(`[Test] Recovered ${recovered.info.length} functions from ${writeFilePath} in ${Date.now() - startRead}ms.`);
+			info.output.stdout(`[Test] Recovered ${recovered.info.length} functions from ${writeFilePath} in ${Date.now() - startRead}ms.`);
 		}
 	}
 };
diff --git a/src/typing/subtyping/infer.ts b/src/typing/subtyping/infer.ts
index f9f2ba18a50..59f41affca6 100644
--- a/src/typing/subtyping/infer.ts
+++ b/src/typing/subtyping/infer.ts
@@ -25,17 +25,19 @@ import type { NoInfo, RNode } from '../../r-bridge/lang-4.x/ast/model/model';
 import { RFalse, RTrue } from '../../r-bridge/lang-4.x/convert-values';
 import type { UnresolvedDataType } from './types';
 import { constrain, getIndexedElementTypeFromList, getParameterTypeFromFunction, resolve, UnresolvedRAtomicVectorType, UnresolvedRFunctionType, UnresolvedRListType, UnresolvedRTypeUnion, UnresolvedRTypeVariable } from './types';
+import { defaultConfigOptions } from '../../config';
 
 
 export function inferDataTypes<Info extends ParentInformation & { typeVariable?: undefined }>(ast: NormalizedAst<ParentInformation & Info>, dataflowInfo: DataflowInformation, knownTypes: Map<string, UnresolvedDataType> = new Map()): NormalizedAst<Info & DataTypeInfo> {
 	const astWithTypeVars = decorateTypeVariables(ast);
-	const controlFlowInfo = extractCfg(astWithTypeVars, dataflowInfo.graph, ['unique-cf-sets', 'analyze-dead-code', 'remove-dead-code']);
+	const controlFlowInfo = extractCfg(astWithTypeVars, defaultConfigOptions, dataflowInfo.graph, ['unique-cf-sets', 'analyze-dead-code', 'remove-dead-code']);
 	const config = {
 		normalizedAst:        astWithTypeVars,
 		controlFlow:          controlFlowInfo,
 		dataflowInfo:         dataflowInfo,
 		dfg:                  dataflowInfo.graph,
 		defaultVisitingOrder: 'forward' as const,
+		flowrConfig:          defaultConfigOptions,
 		knownTypes,
 	};
 	const visitor = new TypeInferringCfgGuidedVisitor(config);
diff --git a/src/typing/unification/infer.ts b/src/typing/unification/infer.ts
index 4989078aa31..006e2a15797 100644
--- a/src/typing/unification/infer.ts
+++ b/src/typing/unification/infer.ts
@@ -24,16 +24,18 @@ import { RType } from '../../r-bridge/lang-4.x/ast/model/type';
 import type { NoInfo } from '../../r-bridge/lang-4.x/ast/model/model';
 import { RFalse, RTrue } from '../../r-bridge/lang-4.x/convert-values';
 import { resolve, UnresolvedRFunctionType, UnresolvedRListType, UnresolvedRTypeVariable } from './types';
+import { defaultConfigOptions } from '../../config';
 
 export function inferDataTypes<Info extends ParentInformation & { typeVariable?: undefined }>(ast: NormalizedAst<ParentInformation & Info>, dataflowInfo: DataflowInformation): NormalizedAst<Info & DataTypeInfo> {
 	const astWithTypeVars = decorateTypeVariables(ast);
-	const controlFlowInfo = extractCfg(astWithTypeVars, dataflowInfo.graph, ['unique-cf-sets', 'analyze-dead-code', 'remove-dead-code']);
+	const controlFlowInfo = extractCfg(astWithTypeVars, defaultConfigOptions, dataflowInfo.graph, ['unique-cf-sets', 'analyze-dead-code', 'remove-dead-code']);
 	const config = {
 		normalizedAst:        astWithTypeVars,
 		controlFlow:          controlFlowInfo,
 		dataflowInfo:         dataflowInfo,
 		dfg:                  dataflowInfo.graph,
 		defaultVisitingOrder: 'forward' as const,
+		flowrConfig:          defaultConfigOptions
 	};
 	const visitor = new TypeInferringCfgGuidedVisitor(config);
 	visitor.start();
diff --git a/test/functionality/_helper/typing/subtyping/assert-inferred-type.ts b/test/functionality/_helper/typing/subtyping/assert-inferred-type.ts
index c2dbc738199..0677ef3094e 100644
--- a/test/functionality/_helper/typing/subtyping/assert-inferred-type.ts
+++ b/test/functionality/_helper/typing/subtyping/assert-inferred-type.ts
@@ -9,6 +9,7 @@ import { type FlowrSearch } from '../../../../../src/search/flowr-search-builder
 import { runSearch } from '../../../../../src/search/flowr-search-executor';
 import type { ParentInformation } from '../../../../../src/r-bridge/lang-4.x/ast/model/processing/decorate';
 import type { RNode } from '../../../../../src/r-bridge/lang-4.x/ast/model/model';
+import { defaultConfigOptions } from '../../../../../src/config';
 
 export function assertInferredType(input: string, expectedType: { expectedType: DataType } | { lowerBound?: DataType, upperBound?: DataType }): void {
 	assertInferredTypes(input, expectedType);
@@ -19,7 +20,7 @@ export function assertInferredTypes(
 ): void {
 	describe(`Infer types for ${input}`, async() => {
 		const executor = new TreeSitterExecutor();
-		const result = await createDataflowPipeline(executor, { request: requestFromInput(input) }).allRemainingSteps();
+		const result = await createDataflowPipeline(executor, { request: requestFromInput(input) }, defaultConfigOptions).allRemainingSteps();
 		inferDataTypes(result.normalize, result.dataflow);
 
 		const expectedTypes = expectations.map(({ query, ...rest }) => ({
@@ -32,9 +33,10 @@ export function assertInferredTypes(
 		describe.each(expectedTypes)('Infer $expectedType.tag for query $query', ({ query, expectedType }) => {
 			let node: RNode<ParentInformation & DataTypeInfo>;
 			if(query !== undefined) {
-				const searchResult = runSearch(query, result);
-				expect(searchResult).toHaveLength(1);
-				node = searchResult[0].node as RNode<ParentInformation & DataTypeInfo>;
+				const searchResult = runSearch(query, { config: defaultConfigOptions, ...result });
+				const searchElements = searchResult.getElements();
+				expect(searchElements).toHaveLength(1);
+				node = searchElements[0].node as RNode<ParentInformation & DataTypeInfo>;
 			} else {
 				node = result.normalize.idMap.get(result.dataflow.exitPoints[0].nodeId) as RNode<ParentInformation & DataTypeInfo>;
 			}
diff --git a/test/functionality/_helper/typing/unification/assert-inferred-type.ts b/test/functionality/_helper/typing/unification/assert-inferred-type.ts
index 7dfb698e4e8..0fcb98ed587 100644
--- a/test/functionality/_helper/typing/unification/assert-inferred-type.ts
+++ b/test/functionality/_helper/typing/unification/assert-inferred-type.ts
@@ -6,11 +6,12 @@ import type { DataType } from '../../../../../src/typing/types';
 import { inferDataTypes } from '../../../../../src/typing/unification/infer';
 import type { FlowrSearch } from '../../../../../src/search/flowr-search-builder';
 import { runSearch } from '../../../../../src/search/flowr-search-executor';
+import { defaultConfigOptions } from '../../../../../src/config';
 
 export function assertInferredType(input: string, expectedType: DataType): void {
 	test(`Infer ${expectedType.tag} for ${input}`, async() => {
 		const executor = new TreeSitterExecutor();
-		const result = await createDataflowPipeline(executor, { request: requestFromInput(input) }).allRemainingSteps();
+		const result = await createDataflowPipeline(executor, { request: requestFromInput(input) }, defaultConfigOptions).allRemainingSteps();
 		const typedAst = inferDataTypes(result.normalize, result.dataflow);
 		const rootNode = typedAst.ast;
 		expect(rootNode.info.inferredType).toEqual(expectedType);
@@ -22,13 +23,14 @@ export function assertInferredTypes(
 ): void {
 	describe(`Infer types for ${input}`, async() => {
 		const executor = new TreeSitterExecutor();
-		const result = await createDataflowPipeline(executor, { request: requestFromInput(input) }).allRemainingSteps();
+		const result = await createDataflowPipeline(executor, { request: requestFromInput(input) }, defaultConfigOptions).allRemainingSteps();
 		inferDataTypes(result.normalize, result.dataflow);
 
 		describe.each(expectations)('Infer $expectedType.tag for query $query', ({ query, expectedType }) => {
-			const searchResult = runSearch(query, result);
-			expect(searchResult).toHaveLength(1);
-			const node = searchResult[0].node;
+			const searchResult = runSearch(query, { config: defaultConfigOptions, ...result });
+			const searchElements = searchResult.getElements();
+			expect(searchElements).toHaveLength(1);
+			const node = searchElements[0].node;
 
 			test(`Infer ${expectedType.tag} for ${node.lexeme}`, () => {
 				expect(node.info.inferredType).toEqual(expectedType);

From df13f4a15c0622a52d09d93d960a66f4f32824bd Mon Sep 17 00:00:00 2001
From: Lukas Rohde <lukas.rohde@silupe.de>
Date: Wed, 6 Aug 2025 12:21:34 +0200
Subject: [PATCH 127/153] feat(typing): load dynamically traced types for
 datatype queries

---
 .../datatype-query/datatype-query-executor.ts   | 17 ++++++++---------
 1 file changed, 8 insertions(+), 9 deletions(-)

diff --git a/src/queries/catalog/datatype-query/datatype-query-executor.ts b/src/queries/catalog/datatype-query/datatype-query-executor.ts
index 6656c61361f..8a613a22cd9 100644
--- a/src/queries/catalog/datatype-query/datatype-query-executor.ts
+++ b/src/queries/catalog/datatype-query/datatype-query-executor.ts
@@ -7,21 +7,20 @@ import { slicingCriterionToId } from '../../../slicing/criterion/parse';
 import { inferDataTypes } from '../../../typing/unification/infer';
 import { inferDataTypes as inferDataTypesUsingSubtyping } from '../../../typing/subtyping/infer';
 import type { UnresolvedDataType } from '../../../typing/subtyping/types';
-// import { loadTracedTypes, loadTurcotteTypes } from '../../../typing/adapter/load-type-signatures';
+import { loadTracedTypes, loadTurcotteTypes } from '../../../typing/adapter/load-type-signatures';
 
-export function executeDatatypeQuery({ dataflow, ast }: BasicQueryData, queries: readonly DatatypeQuery[]): DatatypeQueryResult {
+export async function executeDatatypeQuery({ dataflow, ast }: BasicQueryData, queries: readonly DatatypeQuery[]): Promise<DatatypeQueryResult> {
 	const start = Date.now();
 
 	const result: DatatypeQueryResult['inferredTypes'] = {};
 	for(const query of queries) {
 		const knownTypes = new Map<string, UnresolvedDataType>();
-		// TODO: Make the query asynchronous to be able to load the types
-		// if(query.useTurcotteTypes) {
-		// 	await loadTurcotteTypes(knownTypes);
-		// }
-		// if(query.useTracedTypes) {
-		// 	await loadTracedTypes(knownTypes);
-		// }
+		if(query.useTurcotteTypes) {
+			await loadTurcotteTypes(knownTypes);
+		}
+		if(query.useTracedTypes) {
+			await loadTracedTypes(knownTypes);
+		}
 
 		const typedAst = query.useSubtyping
 			? inferDataTypesUsingSubtyping(ast as NormalizedAst<ParentInformation & { typeVariable?: undefined }>, dataflow, knownTypes)

From 61150f54fe8e1ad34fcc27361a2898c9d114406b Mon Sep 17 00:00:00 2001
From: Lukas Rohde <lukas.rohde@silupe.de>
Date: Wed, 6 Aug 2025 15:22:59 +0200
Subject: [PATCH 128/153] feat-fix(typing): fix loading of contextual types

---
 src/typing/adapter/load-type-signatures.ts    | 70 +++++++++++++++----
 src/typing/adapter/traced-function-types.ts   | 61 ++++++++++------
 src/typing/subtyping/infer.ts                 | 18 ++---
 .../typing/subtyping/assert-inferred-type.ts  |  9 ++-
 .../subtyping/builtin-functions.test.ts       |  3 +
 .../typing/subtyping/conditionals.test.ts     |  1 +
 .../subtyping/contextual-inference.test.ts    | 17 +++++
 .../typing/subtyping/loops.test.ts            |  1 +
 .../typing/subtyping/replacement.test.ts      | 13 ++++
 .../typing/subtyping/subsetting.test.ts       | 11 +++
 .../subtyping/unsupported-expressions.test.ts |  8 ---
 .../typing/subtyping/variables.test.ts        |  5 +-
 12 files changed, 159 insertions(+), 58 deletions(-)
 create mode 100644 test/functionality/typing/subtyping/contextual-inference.test.ts
 delete mode 100644 test/functionality/typing/subtyping/unsupported-expressions.test.ts

diff --git a/src/typing/adapter/load-type-signatures.ts b/src/typing/adapter/load-type-signatures.ts
index 1649ef7920e..89777986e33 100644
--- a/src/typing/adapter/load-type-signatures.ts
+++ b/src/typing/adapter/load-type-signatures.ts
@@ -1,12 +1,11 @@
 import csvParser from 'csv-parser';
 import type { UnresolvedDataType } from '../subtyping/types';
-import { UnresolvedRTypeIntersection } from '../subtyping/types';
 import type { TraceCsvRow } from './traced-function-types';
 import { extractTypesFromTraceData } from './traced-function-types';
 import { turcotte2RohdeTypes, type TurcotteCsvRow } from './turcotte-types';
 import fs from 'fs';
 
-export async function loadTurcotteTypes(typeMap: Map<string, UnresolvedDataType> = new Map()): Promise<Map<string, UnresolvedDataType>> {
+export async function loadTurcotteTypes(typeMap: Map<string, Set<UnresolvedDataType>> = new Map()): Promise<Map<string, Set<UnresolvedDataType>>> {
 	const data: TurcotteCsvRow[] = [];
 	await new Promise(resolve => {
 		fs.createReadStream('src/typing/adapter/turcotte-types.csv', { encoding: 'utf-8' })
@@ -19,38 +18,83 @@ export async function loadTurcotteTypes(typeMap: Map<string, UnresolvedDataType>
 	
 	const rohdeTypes = turcotte2RohdeTypes(data);
 	for(const info of rohdeTypes.info) {
-		const label = info.name; //`${info.package}::${info.name}`;
+		const label = info.name;
+
+		if(!typeMap.has(label)) {
+			typeMap.set(label, new Set());
+		}
+
 		if('type' in info) {
-			typeMap.set(label, info.type);
+			// eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+			typeMap.get(label)!.add(info.type);
 		}
 		if('types' in info) {
-			const type = info.types.length === 1 ? info.types[0] : new UnresolvedRTypeIntersection(...info.types);
-			typeMap.set(label, type);
+			for(const type of info.types) {
+				// eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+				typeMap.get(label)!.add(type);
+			}
 		}
 	}
 
 	return typeMap;
 }
 
-export async function loadTracedTypes(typeMap: Map<string, UnresolvedDataType> = new Map()): Promise<Map<string, UnresolvedDataType>> {
+function trimQuotes(str: string): string {
+	if(str.startsWith("'") && str.endsWith("'") || str.startsWith('"') && str.endsWith('"')) {
+		return str.slice(1, -1);
+	}
+	return str;
+}
+
+export async function loadTracedTypes(typeMap: Map<string, Set<UnresolvedDataType>> = new Map()): Promise<Map<string, Set<UnresolvedDataType>>> {
 	const data: TraceCsvRow[] = [];
 	await new Promise(resolve => {
 		fs.createReadStream('src/typing/adapter/traced-function-types.csv', { encoding: 'utf-8' })
-			.pipe(csvParser({ separator: ',' }))
+			.pipe(csvParser({
+				separator:  ',',
+				mapHeaders: ({ header }) => {
+					switch(header.trim()) {
+						case 'file':
+							return 'package_name';
+						case 'fname':
+							return 'function_name';
+						case 'arg_types':
+							return 'parameter_types';
+						case 'ret_type':
+							return 'return_type';
+						default:
+							throw new Error(`Unknown header in CSV: ${header}`);
+					}
+				},
+				mapValues: ({ header, value }) => {
+					if(header === 'parameter_types') {
+						return (value as string).split(',').map(str => trimQuotes(str)).filter(str => str !== '');
+					}
+					return trimQuotes(value as string);
+				}
+			}))
 			.on('data', (row: TraceCsvRow) => {
 				data.push(row);
 			})
 			.on('end', () => resolve(null));
 	});
 	
-	console.log(data.length);
-	const [functionTypeInfos, contributions] = extractTypesFromTraceData(data);
-	console.log(contributions);
+	const [functionTypeInfos, _contributions] = extractTypesFromTraceData(data);
+	// console.log(contributions);
+
 	for(const info of functionTypeInfos) {
 		const label = info.name;
-		const type = info.types.length === 1 ? info.types[0] : new UnresolvedRTypeIntersection(...info.types);
-		typeMap.set(label, type);
+		
+		if(!typeMap.has(label)) {
+			typeMap.set(label, new Set());
+		}
+		for(const type of info.types) {
+			// eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+			typeMap.get(label)!.add(type);
+		}
 	}
 
+	// console.dir(typeMap.get('+'), { depth: null, colors: true });
+	
 	return typeMap;
 }
\ No newline at end of file
diff --git a/src/typing/adapter/traced-function-types.ts b/src/typing/adapter/traced-function-types.ts
index 5fd667e0d40..496fd2dfd30 100644
--- a/src/typing/adapter/traced-function-types.ts
+++ b/src/typing/adapter/traced-function-types.ts
@@ -1,13 +1,13 @@
 import type { UnresolvedDataType } from '../subtyping/types';
-import { constrain, getParameterTypeFromFunction, UnresolvedRAtomicVectorType, UnresolvedRFunctionType, UnresolvedRListType } from '../subtyping/types';
+import { UnresolvedRTypeVariable , constrain, getParameterTypeFromFunction, UnresolvedRAtomicVectorType, UnresolvedRFunctionType, UnresolvedRListType } from '../subtyping/types';
 import { RComplexType, RDoubleType, REnvironmentType, RIntegerType, RLanguageType, RLogicalType, RNullType, RRawType, RStringType } from '../types';
 import type { RohdeFunctionTypeInformation } from './interface';
 
 export interface TraceCsvRow {
-	readonly packageName:   string;
-	readonly functionName:  string;
-	readonly argumentTypes: string;
-	readonly returnType:    string;
+	readonly package_name:    string;
+	readonly function_name:   string;
+	readonly parameter_types: string[];
+	readonly return_type:     string;
 }
 
 export function extractTypesFromTraceData(data: readonly TraceCsvRow[]): [RohdeFunctionTypeInformation[], Map<string, number>] {
@@ -15,17 +15,19 @@ export function extractTypesFromTraceData(data: readonly TraceCsvRow[]): [RohdeF
 	const unseenSignaturePackageContributions: Map<string, Set<string>> = new Map();
 
 	for(const row of data) {
-		const argumentTypes = row.argumentTypes.split(',').map(str => typeFromStr(str.trim(), true));
-		const returnType = typeFromStr(row.returnType.trim());
+		const argumentTypes = row.parameter_types.map(typeFromStr);
+		const returnType = typeFromStr(row.return_type);
 
-		const signature = `${row.functionName} : (${row.argumentTypes}) -> ${row.returnType}`;
+		const signature = `${row.function_name} : (${row.parameter_types.join(', ')}) -> ${row.return_type}`;
 		if(!unseenSignaturePackageContributions.values().some(set => set.has(signature))) {
-			if(!unseenSignaturePackageContributions.has(row.packageName)) {
-				unseenSignaturePackageContributions.set(row.packageName, new Set([signature]));
+			if(!unseenSignaturePackageContributions.has(row.package_name)) {
+				unseenSignaturePackageContributions.set(row.package_name, new Set([signature]));
 			} else {
 				// eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-				unseenSignaturePackageContributions.get(row.packageName)!.add(signature);
+				unseenSignaturePackageContributions.get(row.package_name)!.add(signature);
 			}
+		} else {
+			continue; // Skip if we have already seen this signature for this package
 		}
 
 		const functionType = new UnresolvedRFunctionType();
@@ -34,16 +36,16 @@ export function extractTypesFromTraceData(data: readonly TraceCsvRow[]): [RohdeF
 		}
 		constrain(returnType, functionType.returnType);
 
-		if(!extractedTypes.has(row.packageName)) {
-			extractedTypes.set(row.packageName, new Map());
+		if(!extractedTypes.has(row.package_name)) {
+			extractedTypes.set(row.package_name, new Map());
 		}
 		// eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-		const packageMap = extractedTypes.get(row.packageName)!;
-		if(!packageMap.has(row.functionName)) {
-			packageMap.set(row.functionName, []);
+		const packageMap = extractedTypes.get(row.package_name)!;
+		if(!packageMap.has(row.function_name)) {
+			packageMap.set(row.function_name, []);
 		}
 		// eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-		packageMap.get(row.functionName)!.push(functionType);
+		packageMap.get(row.function_name)!.push(functionType);
 	}
 
 	const functionTypeInfos = extractedTypes.entries().flatMap(([packageName, map]) => map.entries().map(([functionName, types]) => ({
@@ -55,14 +57,11 @@ export function extractTypesFromTraceData(data: readonly TraceCsvRow[]): [RohdeF
 	return [functionTypeInfos, unseenSignaturePackageContributionCounts];
 }
 
-function typeFromStr(str: string, hasNegativePolarity: boolean = false): UnresolvedDataType {
+function typeFromStr(str: string): UnresolvedDataType {
 	if(str.startsWith('v<') && str.endsWith('>')) {
 		const vectorType = new UnresolvedRAtomicVectorType();
-		if(hasNegativePolarity) {
-			constrain(vectorType.elementType, typeFromStr(str.slice(2, -1)));
-		} else {
-			constrain(typeFromStr(str.slice(2, -1)), vectorType.elementType);
-		}
+		constrain(vectorType.elementType, typeFromStr(str.slice(2, -1)));
+		constrain(typeFromStr(str.slice(2, -1)), vectorType.elementType);
 		return vectorType;
 	} else if(str === 'function') {
 		return new UnresolvedRFunctionType();
@@ -86,6 +85,22 @@ function typeFromStr(str: string, hasNegativePolarity: boolean = false): Unresol
 		return new RLanguageType();
 	} else if(str === 'environment') {
 		return new REnvironmentType();
+	} else if(str === 'S4') {
+		// S4 types are not supported yet, so we return a variable type
+		return new UnresolvedRTypeVariable();
+	} else if(str === 'dgCMatrix') {
+		// Time for crying
+		return new UnresolvedRListType();
+	} else if(str === '<-' || str === '(' || str === 'if' || str === '{' || str === 'for') {
+		// Arbitrary definitions
+		return new UnresolvedRTypeVariable();
+	} else if(str === 'srcfile') {
+		return new UnresolvedRTypeVariable();
+	} else if(str === 'standardGeneric') {
+		return new UnresolvedRFunctionType();
+	} else if(str === 'mle' || str === 'track' || str === 'derivedDefaultMethod' || str === 'jmcmMod' || str === 'glmerMod') {
+		// Huh?
+		return new UnresolvedRTypeVariable();
 	} else {
 		throw new Error(`Unknown type: ${str}`);
 	}
diff --git a/src/typing/subtyping/infer.ts b/src/typing/subtyping/infer.ts
index 59f41affca6..6689fd5c0ad 100644
--- a/src/typing/subtyping/infer.ts
+++ b/src/typing/subtyping/infer.ts
@@ -24,11 +24,11 @@ import { RType } from '../../r-bridge/lang-4.x/ast/model/type';
 import type { NoInfo, RNode } from '../../r-bridge/lang-4.x/ast/model/model';
 import { RFalse, RTrue } from '../../r-bridge/lang-4.x/convert-values';
 import type { UnresolvedDataType } from './types';
-import { constrain, getIndexedElementTypeFromList, getParameterTypeFromFunction, resolve, UnresolvedRAtomicVectorType, UnresolvedRFunctionType, UnresolvedRListType, UnresolvedRTypeUnion, UnresolvedRTypeVariable } from './types';
+import { constrain, getIndexedElementTypeFromList, getParameterTypeFromFunction, resolve, UnresolvedRAtomicVectorType, UnresolvedRFunctionType, UnresolvedRListType, UnresolvedRTypeIntersection, UnresolvedRTypeUnion, UnresolvedRTypeVariable } from './types';
 import { defaultConfigOptions } from '../../config';
 
 
-export function inferDataTypes<Info extends ParentInformation & { typeVariable?: undefined }>(ast: NormalizedAst<ParentInformation & Info>, dataflowInfo: DataflowInformation, knownTypes: Map<string, UnresolvedDataType> = new Map()): NormalizedAst<Info & DataTypeInfo> {
+export function inferDataTypes<Info extends ParentInformation & { typeVariable?: undefined }>(ast: NormalizedAst<ParentInformation & Info>, dataflowInfo: DataflowInformation, knownTypes: Map<string, Set<UnresolvedDataType>> = new Map()): NormalizedAst<Info & DataTypeInfo> {
 	const astWithTypeVars = decorateTypeVariables(ast);
 	const controlFlowInfo = extractCfg(astWithTypeVars, defaultConfigOptions, dataflowInfo.graph, ['unique-cf-sets', 'analyze-dead-code', 'remove-dead-code']);
 	const config = {
@@ -70,7 +70,7 @@ export interface TypeInferringCfgGuidedVisitorConfiguration<
 	Dataflow extends DataflowInformation                      = DataflowInformation
 > extends Omit<SemanticCfgGuidedVisitorConfiguration<UnresolvedTypeInfo & OtherInfo, ControlFlow, Ast>, 'dataflow'> {
 	dataflowInfo: Dataflow;
-	knownTypes:   Map<string, UnresolvedDataType>;
+	knownTypes:   Map<string, Set<UnresolvedDataType>>;
 }
 
 class TypeInferringCfgGuidedVisitor<
@@ -146,9 +146,9 @@ class TypeInferringCfgGuidedVisitor<
 		if(hasUnresolvableOrigins) {
 			if(node.type === RType.Symbol) {
 				// If the read variable has no associated AST node it might be a library constant or function
-				const contextualType = this.config.knownTypes.get(node.content);
-				if(contextualType !== undefined) {
-					this.constrainNodeType(node, { lowerBound: contextualType });
+				const contextualTypes = this.config.knownTypes.get(node.content);
+				if(contextualTypes !== undefined && contextualTypes.size > 0) {
+					this.constrainNodeType(node, { lowerBound: new UnresolvedRTypeIntersection(...contextualTypes.values()) });
 				}
 			}
 		} else if(lowerBounds.size > 0) {
@@ -217,9 +217,9 @@ class TypeInferringCfgGuidedVisitor<
 				}
 			} else {
 				// If the target function has no associated AST node it might be a library function
-				const contextualType = this.config.knownTypes.get(data.call.name);
-				if(contextualType !== undefined) {
-					constrain(contextualType, functionType, this.constraintCache);
+				const contextualTypes = this.config.knownTypes.get(data.call.name);
+				if(contextualTypes !== undefined && contextualTypes.size > 0) {
+					constrain(new UnresolvedRTypeUnion(...contextualTypes.values()), functionType, this.constraintCache);
 				}
 			}
 		}
diff --git a/test/functionality/_helper/typing/subtyping/assert-inferred-type.ts b/test/functionality/_helper/typing/subtyping/assert-inferred-type.ts
index 0677ef3094e..0eb42b3d740 100644
--- a/test/functionality/_helper/typing/subtyping/assert-inferred-type.ts
+++ b/test/functionality/_helper/typing/subtyping/assert-inferred-type.ts
@@ -10,18 +10,21 @@ import { runSearch } from '../../../../../src/search/flowr-search-executor';
 import type { ParentInformation } from '../../../../../src/r-bridge/lang-4.x/ast/model/processing/decorate';
 import type { RNode } from '../../../../../src/r-bridge/lang-4.x/ast/model/model';
 import { defaultConfigOptions } from '../../../../../src/config';
+import type { UnresolvedDataType } from '../../../../../src/typing/subtyping/types';
 
-export function assertInferredType(input: string, expectedType: { expectedType: DataType } | { lowerBound?: DataType, upperBound?: DataType }): void {
-	assertInferredTypes(input, expectedType);
+export function assertInferredType(input: string, expectedType: { expectedType: DataType } | { lowerBound?: DataType, upperBound?: DataType }, knownTypes?: Map<string, Set<UnresolvedDataType>>): void {
+	assertInferredTypes(input, knownTypes, expectedType);
 }
+
 export function assertInferredTypes(
 	input: string,
+	knownTypes?: Map<string, Set<UnresolvedDataType>>,
 	...expectations: ({ query?: FlowrSearch } & ({ expectedType: DataType } | { lowerBound?: DataType, upperBound?: DataType }))[]
 ): void {
 	describe(`Infer types for ${input}`, async() => {
 		const executor = new TreeSitterExecutor();
 		const result = await createDataflowPipeline(executor, { request: requestFromInput(input) }, defaultConfigOptions).allRemainingSteps();
-		inferDataTypes(result.normalize, result.dataflow);
+		inferDataTypes(result.normalize, result.dataflow, knownTypes);
 
 		const expectedTypes = expectations.map(({ query, ...rest }) => ({
 			query,
diff --git a/test/functionality/typing/subtyping/builtin-functions.test.ts b/test/functionality/typing/subtyping/builtin-functions.test.ts
index 554dfc1ed6e..6c72235ae91 100644
--- a/test/functionality/typing/subtyping/builtin-functions.test.ts
+++ b/test/functionality/typing/subtyping/builtin-functions.test.ts
@@ -8,6 +8,7 @@ describe('Infer types for builtin functions', () => {
 
 	assertInferredTypes(
 		'x <- 42\nget("x")',
+		undefined,
 		{ query: Q.criterion('1@x').build(),   lowerBound: new RIntegerType(), upperBound: new RComplexType() },
 		{ query: Q.criterion('2@get').build(), lowerBound: new RIntegerType(), upperBound: new RComplexType() },
 		{ query: Q.criterion('2@"x"').build(), upperBound: new RStringType() }
@@ -15,6 +16,7 @@ describe('Infer types for builtin functions', () => {
 
 	assertInferredTypes(
 		'eval(quote(TRUE))',
+		undefined,
 		{ query: Q.criterion('1@eval').build(),  expectedType: new RTypeVariable() },
 		{ query: Q.criterion('1@quote').build(), expectedType: new RLanguageType() },
 		{ query: Q.criterion('1@TRUE').build(),  expectedType: new RLogicalType() }
@@ -25,6 +27,7 @@ describe('Infer types for builtin functions', () => {
 
 	assertInferredTypes(
 		'c("Hello", "Flo", "!")',
+		undefined,
 		{ query: Q.criterion('1@c').build(),       expectedType: new RAtomicVectorType(new RTypeVariable(new RStringType(), new RTypeIntersection())) },
 		{ query: Q.criterion('1@"Hello"').build(), expectedType: new RStringType() },
 	);
diff --git a/test/functionality/typing/subtyping/conditionals.test.ts b/test/functionality/typing/subtyping/conditionals.test.ts
index 340cdce4fe2..60ce8511de7 100644
--- a/test/functionality/typing/subtyping/conditionals.test.ts
+++ b/test/functionality/typing/subtyping/conditionals.test.ts
@@ -13,6 +13,7 @@ describe('Infer types for if statements', () => {
 
 	assertInferredTypes(
 		'a <- if(1 > 2) { "Yes" } else { "Nope" }',
+		undefined,
 		{ query: Q.all().filter(RType.BinaryOp).first().build(), lowerBound: new RStringType() },
 		{ query: Q.all().filter(RType.BinaryOp).last().build(),  upperBound: new RLogicalType() },
 	);
diff --git a/test/functionality/typing/subtyping/contextual-inference.test.ts b/test/functionality/typing/subtyping/contextual-inference.test.ts
new file mode 100644
index 00000000000..b1735c9d652
--- /dev/null
+++ b/test/functionality/typing/subtyping/contextual-inference.test.ts
@@ -0,0 +1,17 @@
+import { beforeAll, describe } from 'vitest';
+import { RTypeIntersection, RTypeUnion, RTypeVariable } from '../../../../src/typing/types';
+import { assertInferredType } from '../../_helper/typing/subtyping/assert-inferred-type';
+import type { UnresolvedDataType } from '../../../../src/typing/subtyping/types';
+import { loadTracedTypes, loadTurcotteTypes } from '../../../../src/typing/adapter/load-type-signatures';
+
+describe('Infer no type information for currently unsupported R expressions', () => {
+	const knownTypes: Map<string, Set<UnresolvedDataType>> = new Map();
+	
+	beforeAll(async() => {
+		await loadTurcotteTypes(knownTypes);
+		await loadTracedTypes(knownTypes);
+	});
+
+	assertInferredType('1 + 2',                  new RTypeVariable(new RTypeUnion(), new RTypeIntersection()), knownTypes);
+	assertInferredType('print("Hello, world!")', new RTypeVariable(new RTypeUnion(), new RTypeIntersection()), knownTypes);
+});
\ No newline at end of file
diff --git a/test/functionality/typing/subtyping/loops.test.ts b/test/functionality/typing/subtyping/loops.test.ts
index e48fbc6545f..2818cf3e23e 100644
--- a/test/functionality/typing/subtyping/loops.test.ts
+++ b/test/functionality/typing/subtyping/loops.test.ts
@@ -18,6 +18,7 @@ describe('Infer types for loops', () => {
 
 	assertInferredTypes(
 		'while(1 > 2) { print("Testing is done!") }',
+		undefined,
 		{ query: Q.all().filter(RType.BinaryOp).build(), upperBound: new RLogicalType() },
 	);
 });
\ No newline at end of file
diff --git a/test/functionality/typing/subtyping/replacement.test.ts b/test/functionality/typing/subtyping/replacement.test.ts
index 7eea284bcec..1ebac259402 100644
--- a/test/functionality/typing/subtyping/replacement.test.ts
+++ b/test/functionality/typing/subtyping/replacement.test.ts
@@ -9,6 +9,7 @@ describe('Infer types for subsetting expressions', () => {
 
 	assertInferredTypes(
 		'v <- c(1, 2, 3); v[2] <- y; v',
+		undefined,
 		{ query: Q.var('v').first().build(),          expectedType: new RAtomicVectorType(new RTypeVariable(new RIntegerType(), new RTypeIntersection())) },
 		{ query: Q.var('v').last().build(),           expectedType: new RAtomicVectorType(new RTypeVariable(new RIntegerType(), new RTypeIntersection())) },
 		{ query: Q.var('y').last().build(),           upperBound: new RTypeUnion(new RAtomicVectorType(new RTypeIntersection()), new RListType(new RTypeIntersection())) },
@@ -18,6 +19,7 @@ describe('Infer types for subsetting expressions', () => {
 	
 	assertInferredTypes(
 		'v <- c(1, 2, 3); y <- 1; v[2] <- y; v',
+		undefined,
 		{ query: Q.var('v').last().build(),         expectedType: new RAtomicVectorType(new RTypeVariable(new RIntegerType(), new RTypeIntersection())) },
 		{ query: Q.var('y').last().build(),         lowerBound: new RIntegerType(), upperBound: new RComplexType() },
 		{ query: Q.criterion('1@[').last().build(), lowerBound: new RIntegerType(), upperBound: new RComplexType() },
@@ -26,6 +28,7 @@ describe('Infer types for subsetting expressions', () => {
 	const elementType1 = new RTypeVariable(new RIntegerType(), new RTypeIntersection());
 	assertInferredTypes(
 		'l <- list(1, 2, 3); l[2] <- y; l',
+		undefined,
 		{ query: Q.var('l').last().build(),         expectedType: new RListType(elementType1, new Map([[0, elementType1], [1, elementType1], [2, elementType1]])) },
 		{ query: Q.var('y').last().build(),         upperBound: new RTypeUnion(new RAtomicVectorType(new RTypeIntersection()), new RListType(new RTypeIntersection())) },
 		{ query: Q.criterion('1@[').last().build(), upperBound: new RTypeUnion(new RAtomicVectorType(new RTypeIntersection()), new RListType(new RTypeIntersection())) },
@@ -33,6 +36,7 @@ describe('Infer types for subsetting expressions', () => {
 	
 	assertInferredTypes(
 		'v <- c(1, 2, 3); v[] <- y; v',
+		undefined,
 		{ query: Q.var('v').last().build(),         expectedType: new RAtomicVectorType(new RTypeVariable(new RIntegerType(), new RTypeIntersection())) },
 		{ query: Q.var('y').last().build(),         upperBound: new RTypeUnion(new RAtomicVectorType(new RTypeIntersection()), new RListType(new RTypeIntersection())) },
 		{ query: Q.criterion('1@[').last().build(), upperBound: new RTypeUnion(new RAtomicVectorType(new RTypeIntersection()), new RListType(new RTypeIntersection())) },
@@ -41,6 +45,7 @@ describe('Infer types for subsetting expressions', () => {
 	const elementType2 = new RTypeVariable(new RIntegerType(), new RTypeIntersection());
 	assertInferredTypes(
 		'l <- list(1, 2, 3); l[] <- y; l',
+		undefined,
 		{ query: Q.var('l').last().build(),         expectedType: new RListType(elementType2, new Map([[0, elementType2], [1, elementType2], [2, elementType2]])) },
 		{ query: Q.var('y').last().build(),         upperBound: new RTypeUnion(new RAtomicVectorType(new RTypeIntersection()), new RListType(new RTypeIntersection())) },
 		{ query: Q.criterion('1@[').last().build(), upperBound: new RTypeUnion(new RAtomicVectorType(new RTypeIntersection()), new RListType(new RTypeIntersection())) },
@@ -48,6 +53,7 @@ describe('Infer types for subsetting expressions', () => {
 	
 	assertInferredTypes(
 		'v <- c(1, 2, 3); v[[2]] <- y; v',
+		undefined,
 		{ query: Q.var('v').last().build(),          expectedType: new RAtomicVectorType(new RTypeVariable(new RIntegerType(), new RTypeIntersection())) },
 		{ query: Q.var('y').last().build(),          upperBound: new RTypeIntersection() },
 		{ query: Q.criterion('1@[[').last().build(), expectedType: new RTypeVariable() },
@@ -56,6 +62,7 @@ describe('Infer types for subsetting expressions', () => {
 	const elementType3 = new RTypeVariable(new RIntegerType(), new RTypeIntersection());
 	assertInferredTypes(
 		'l <- list(1, 2, 3); l[[2]] <- y; l',
+		undefined,
 		{ query: Q.var('l').last().build(),          expectedType: new RListType(elementType1, new Map([[0, elementType3], [1, elementType3], [2, elementType3]])) },
 		{ query: Q.var('y').last().build(),          upperBound: new RTypeIntersection() },
 		{ query: Q.criterion('1@[[').last().build(), expectedType: new RTypeVariable() },
@@ -64,6 +71,7 @@ describe('Infer types for subsetting expressions', () => {
 	const elementType4 = new RTypeVariable(new RIntegerType(), new RTypeIntersection());
 	assertInferredTypes(
 		'l <- list(1, x = 2, 3); l$x <- y; l',
+		undefined,
 		{ query: Q.var('l').last().build(),         expectedType: new RListType(elementType4, new Map<number | string, DataType>([[0, elementType4], [1, elementType4], [2, elementType4], ['x', elementType4]])) },
 		{ query: Q.var('y').last().build(),         upperBound: new RTypeIntersection() },
 		{ query: Q.criterion('1@$').last().build(), expectedType: new RTypeVariable() },
@@ -72,6 +80,7 @@ describe('Infer types for subsetting expressions', () => {
 	const elementType5 = new RTypeVariable(new RIntegerType(), new RTypeIntersection());
 	assertInferredTypes(
 		'l <- list(1, 2, 3); l$a <- y; l',
+		undefined,
 		{ query: Q.var('l').last().build(),         expectedType: new RListType(elementType5, new Map([[0, elementType5], [1, elementType5], [2, elementType5]])) },
 		{ query: Q.var('y').last().build(),         upperBound: new RTypeIntersection() },
 		{ query: Q.criterion('1@$').last().build(), expectedType: new RTypeVariable() },
@@ -86,6 +95,7 @@ describe('Infer types for subsetting expressions', () => {
 	const elementType6_2 = new RTypeVariable(new RNullType(), new RTypeIntersection());
 	assertInferredTypes(
 		'l <- list(TRUE, a = 42, NULL); l$a <- y; l',
+		undefined,
 		{ query: Q.var('l').last().build(),         expectedType: new RListType(elementType6, new Map<number | string, DataType>([[0, elementType6_0], [1, elementType6_1], [2, elementType6_2], ['a', elementType6_1]])) },
 		{ query: Q.var('y').last().build(),         upperBound: new RTypeIntersection() },
 		{ query: Q.criterion('1@$').last().build(), expectedType: new RTypeVariable() },
@@ -93,6 +103,7 @@ describe('Infer types for subsetting expressions', () => {
 
 	assertInferredTypes(
 		'v <- 1; v[[1]] <- y; v',
+		undefined,
 		{ query: Q.var('v').last().build(),          expectedType: new RTypeVariable(new RIntegerType(), new RAtomicVectorType(new RTypeIntersection())) },
 		{ query: Q.var('y').last().build(),          expectedType: new RTypeVariable() },
 		{ query: Q.criterion('1@[[').last().build(), expectedType: new RTypeVariable() },
@@ -100,12 +111,14 @@ describe('Infer types for subsetting expressions', () => {
 	
 	assertInferredTypes(
 		'v <- 1; v[[1]] <- 1.2; v',
+		undefined,
 		{ query: Q.var('v').last().build(),          expectedType: new RTypeVariable(new RIntegerType(), new RAtomicVectorType(new RTypeIntersection())) },
 		{ query: Q.criterion('1@[[').last().build(), lowerBound: new RDoubleType(), upperBound: new RComplexType() },
 	);
 	
 	assertInferredTypes(
 		'v <- NULL; v[1] <- y; v',
+		undefined,
 		{ query: Q.var('v').last().build(),         expectedType: new RTypeVariable(new RNullType(), new RAtomicVectorType(new RTypeIntersection())) },
 		{ query: Q.var('y').last().build(),         upperBound: new RTypeUnion(new RAtomicVectorType(new RTypeIntersection()), new RListType(new RTypeIntersection())) },
 		{ query: Q.criterion('1@[').last().build(), upperBound: new RTypeUnion(new RAtomicVectorType(new RTypeIntersection()), new RListType(new RTypeIntersection())) },
diff --git a/test/functionality/typing/subtyping/subsetting.test.ts b/test/functionality/typing/subtyping/subsetting.test.ts
index f96903b0b66..d4a1673f79a 100644
--- a/test/functionality/typing/subtyping/subsetting.test.ts
+++ b/test/functionality/typing/subtyping/subsetting.test.ts
@@ -8,6 +8,7 @@ import { RType } from '../../../../src/r-bridge/lang-4.x/ast/model/type';
 describe('Infer types for subsetting expressions', () => {
 	assertInferredTypes(
 		'v <- c(1, 2, 3); v[2]',
+		undefined,
 		{ query: Q.var('v').last().build(),                    expectedType: new RAtomicVectorType(new RTypeVariable(new RIntegerType(), new RTypeIntersection())) },
 		{ query: Q.all().filter(RType.Access).first().build(), lowerBound: new RAtomicVectorType(new RIntegerType()) },
 	);
@@ -15,12 +16,14 @@ describe('Infer types for subsetting expressions', () => {
 	const elementType1 = new RTypeVariable(new RIntegerType(), new RTypeIntersection());
 	assertInferredTypes(
 		'l <- list(1, 2, 3); l[2]',
+		undefined,
 		{ query: Q.var('l').last().build(),                    expectedType: new RListType(elementType1, new Map([[0, elementType1], [1, elementType1], [2, elementType1]])) },
 		{ query: Q.all().filter(RType.Access).first().build(), lowerBound: new RListType(new RIntegerType(), new Map([[0, new RIntegerType()], [1, new RIntegerType()], [2, new RIntegerType()]])) },
 	);
 	
 	assertInferredTypes(
 		'v <- c(1, 2, 3); v[]',
+		undefined,
 		{ query: Q.var('v').last().build(),                    expectedType: new RAtomicVectorType(new RTypeVariable(new RIntegerType(), new RTypeIntersection())) },
 		{ query: Q.all().filter(RType.Access).first().build(), lowerBound: new RAtomicVectorType(new RIntegerType()) },
 	);
@@ -28,12 +31,14 @@ describe('Infer types for subsetting expressions', () => {
 	const elementType2 = new RTypeVariable(new RIntegerType(), new RTypeIntersection());
 	assertInferredTypes(
 		'l <- list(1, 2, 3); l[]',
+		undefined,
 		{ query: Q.var('l').last().build(),                    expectedType: new RListType(elementType2, new Map([[0, elementType2], [1, elementType2], [2, elementType2]])) },
 		{ query: Q.all().filter(RType.Access).first().build(), lowerBound: new RListType(new RIntegerType(), new Map([[0, new RIntegerType()], [1, new RIntegerType()], [2, new RIntegerType()]])) },
 	);
 	
 	assertInferredTypes(
 		'v <- c(1, 2, 3); v[[2]]',
+		undefined,
 		{ query: Q.var('v').last().build(),                    expectedType: new RAtomicVectorType(new RTypeVariable(new RIntegerType(), new RTypeIntersection())) },
 		{ query: Q.all().filter(RType.Access).first().build(), lowerBound: new RIntegerType() },
 	);
@@ -41,6 +46,7 @@ describe('Infer types for subsetting expressions', () => {
 	const elementType3 = new RTypeVariable(new RIntegerType(), new RTypeIntersection());
 	assertInferredTypes(
 		'l <- list(1, 2, 3); l[[2]]',
+		undefined,
 		{ query: Q.var('l').last().build(),                    expectedType: new RListType(elementType1, new Map([[0, elementType3], [1, elementType3], [2, elementType3]])) },
 		{ query: Q.all().filter(RType.Access).first().build(), lowerBound: new RIntegerType() },
 	);
@@ -48,6 +54,7 @@ describe('Infer types for subsetting expressions', () => {
 	const elementType4 = new RTypeVariable(new RIntegerType(), new RTypeIntersection());
 	assertInferredTypes(
 		'l <- list(1, x = 2, 3); l$x',
+		undefined,
 		{ query: Q.var('l').last().build(),                    expectedType: new RListType(elementType4, new Map<number | string, DataType>([[0, elementType4], [1, elementType4], [2, elementType4], ['x', elementType4]])) },
 		{ query: Q.all().filter(RType.Access).first().build(), lowerBound: new RIntegerType() },
 	);
@@ -55,6 +62,7 @@ describe('Infer types for subsetting expressions', () => {
 	const elementType5 = new RTypeVariable(new RIntegerType(), new RTypeIntersection());
 	assertInferredTypes(
 		'l <- list(1, 2, 3); l$a',
+		undefined,
 		{ query: Q.var('l').last().build(),                    expectedType: new RListType(elementType5, new Map([[0, elementType5], [1, elementType5], [2, elementType5]])) },
 		{ query: Q.all().filter(RType.Access).first().build(), lowerBound: new RIntegerType() },
 	);
@@ -68,18 +76,21 @@ describe('Infer types for subsetting expressions', () => {
 	const elementType6_2 = new RTypeVariable(new RNullType(), new RTypeIntersection());
 	assertInferredTypes(
 		'l <- list(TRUE, a = 42, NULL); l$a',
+		undefined,
 		{ query: Q.var('l').last().build(),                    expectedType: new RListType(elementType6, new Map<number | string, DataType>([[0, elementType6_0], [1, elementType6_1], [2, elementType6_2], ['a', elementType6_1]])) },
 		{ query: Q.all().filter(RType.Access).first().build(), lowerBound: new RAtomicVectorType(new RIntegerType()), upperBound: new RTypeIntersection() },
 	);
 
 	assertInferredTypes(
 		'v <- 1; v[[1]]',
+		undefined,
 		{ query: Q.var('v').last().build(),                    lowerBound: new RIntegerType(), upperBound: new RComplexType() },
 		{ query: Q.all().filter(RType.Access).first().build(), lowerBound: new RIntegerType() },
 	);
 
 	assertInferredTypes(
 		'v <- NULL; v[1]',
+		undefined,
 		{ query: Q.var('v').last().build(),                    expectedType: new RNullType() },
 		{ query: Q.all().filter(RType.Access).first().build(), lowerBound: new RNullType() },
 	);
diff --git a/test/functionality/typing/subtyping/unsupported-expressions.test.ts b/test/functionality/typing/subtyping/unsupported-expressions.test.ts
deleted file mode 100644
index 090b671232b..00000000000
--- a/test/functionality/typing/subtyping/unsupported-expressions.test.ts
+++ /dev/null
@@ -1,8 +0,0 @@
-import { describe } from 'vitest';
-import { RTypeIntersection, RTypeUnion, RTypeVariable } from '../../../../src/typing/types';
-import { assertInferredType } from '../../_helper/typing/subtyping/assert-inferred-type';
-
-describe('Infer no type information for currently unsupported R expressions', () => {
-	assertInferredType('1 + 2',                  new RTypeVariable(new RTypeUnion(), new RTypeIntersection()));
-	assertInferredType('print("Hello, world!")', new RTypeVariable(new RTypeUnion(), new RTypeIntersection()));
-});
\ No newline at end of file
diff --git a/test/functionality/typing/subtyping/variables.test.ts b/test/functionality/typing/subtyping/variables.test.ts
index ec61e7788e7..a3d2fdbbc55 100644
--- a/test/functionality/typing/subtyping/variables.test.ts
+++ b/test/functionality/typing/subtyping/variables.test.ts
@@ -5,9 +5,10 @@ import { Q } from '../../../../src/search/flowr-search-builder';
 
 describe('Infer types for variables', () => {
 	assertInferredTypes(
-		'x <- 42',
+		'x <- 42; x',
+		undefined,
 		{ query: Q.var('x').first().build(),  lowerBound: new RIntegerType(), upperBound: new RComplexType() },
 		{ query: Q.criterion('1@<-').build(), lowerBound: new RIntegerType(), upperBound: new RComplexType() },
-		// { query: Q.var('x').last().build(),   lowerBound: new RIntegerType(), upperBound: new RComplexType() },
+		{ query: Q.var('x').last().build(),   lowerBound: new RIntegerType(), upperBound: new RComplexType() },
 	);
 });
\ No newline at end of file

From 3279fa01c7a80d68a91aa33c0eaf3780eb0745df Mon Sep 17 00:00:00 2001
From: Lukas Rohde <lukas.rohde@silupe.de>
Date: Wed, 6 Aug 2025 18:25:39 +0200
Subject: [PATCH 129/153] feat-fix(typing): fix type error in datatype query
 executor

---
 src/queries/catalog/datatype-query/datatype-query-executor.ts | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/src/queries/catalog/datatype-query/datatype-query-executor.ts b/src/queries/catalog/datatype-query/datatype-query-executor.ts
index 8a613a22cd9..11da575ee80 100644
--- a/src/queries/catalog/datatype-query/datatype-query-executor.ts
+++ b/src/queries/catalog/datatype-query/datatype-query-executor.ts
@@ -14,7 +14,7 @@ export async function executeDatatypeQuery({ dataflow, ast }: BasicQueryData, qu
 
 	const result: DatatypeQueryResult['inferredTypes'] = {};
 	for(const query of queries) {
-		const knownTypes = new Map<string, UnresolvedDataType>();
+		const knownTypes = new Map<string, Set<UnresolvedDataType>>();
 		if(query.useTurcotteTypes) {
 			await loadTurcotteTypes(knownTypes);
 		}
@@ -25,7 +25,7 @@ export async function executeDatatypeQuery({ dataflow, ast }: BasicQueryData, qu
 		const typedAst = query.useSubtyping
 			? inferDataTypesUsingSubtyping(ast as NormalizedAst<ParentInformation & { typeVariable?: undefined }>, dataflow, knownTypes)
 			: inferDataTypes(ast as NormalizedAst<ParentInformation & { typeVariable?: undefined }>, dataflow);
-		for(const criterion of query.criteria ?? ast.idMap.keys().map(id => `$${id}` as SingleSlicingCriterion)) {
+		for(const criterion of query.criteria ?? typedAst.idMap.keys().map(id => `$${id}` as SingleSlicingCriterion)) {
 			if(result[criterion] !== undefined) {
 				log.warn('Duplicate criterion in datatype query:', criterion);
 				continue;

From 5f4e635f403d1ba772d292dafb388f10c6e1206e Mon Sep 17 00:00:00 2001
From: Lukas Rohde <lukas.rohde@silupe.de>
Date: Wed, 6 Aug 2025 18:27:12 +0200
Subject: [PATCH 130/153] feat(typing): improve pretty printing of datatypes

---
 .../datatype-query/datatype-query-format.ts   |  4 +-
 src/queries/query-print.ts                    | 11 ---
 src/typing/pretty-print.ts                    | 73 +++++++++----------
 3 files changed, 35 insertions(+), 53 deletions(-)

diff --git a/src/queries/catalog/datatype-query/datatype-query-format.ts b/src/queries/catalog/datatype-query/datatype-query-format.ts
index 3be93dbbd45..24f0179f363 100644
--- a/src/queries/catalog/datatype-query/datatype-query-format.ts
+++ b/src/queries/catalog/datatype-query/datatype-query-format.ts
@@ -5,8 +5,8 @@ import { bold } from '../../../util/text/ansi';
 import { printAsMs } from '../../../util/text/time';
 import Joi from 'joi';
 import { executeDatatypeQuery } from './datatype-query-executor';
-import { asciiDataType } from '../../query-print';
 import type { DataType } from '../../../typing/types';
+import { prettyPrintDataType } from '../../../typing/pretty-print';
 
 /**
  * Calculates the inferred data type for the given criterion.
@@ -30,7 +30,7 @@ export const DatatypeQueryDefinition = {
 		const out = queryResults as QueryResults<'datatype'>['datatype'];
 		result.push(`Query: ${bold('datatype', formatter)} (${printAsMs(out['.meta'].timing, 0)})`);
 		for(const [criterion, inferredType] of Object.entries(out.inferredTypes)) {
-			result.push(`   ╰ ${criterion}: {${asciiDataType(inferredType)}}`);
+			result.push(`   ╰ ${criterion}: {${prettyPrintDataType(inferredType)}}`);
 		}
 		return true;
 	},
diff --git a/src/queries/query-print.ts b/src/queries/query-print.ts
index 9cafb34ca53..7d1ebda8a30 100644
--- a/src/queries/query-print.ts
+++ b/src/queries/query-print.ts
@@ -10,7 +10,6 @@ import type { CallContextQuerySubKindResult } from './catalog/call-context-query
 import type { BaseQueryMeta, BaseQueryResult } from './base-query-format';
 import { printAsMs } from '../util/text/time';
 import { isBuiltIn } from '../dataflow/environments/built-in';
-import { DataTypeTag, type DataType } from '../typing/types';
 
 function nodeString(nodeId: NodeId | { id: NodeId, info?: object}, formatter: OutputFormatter, processed: PipelineOutput<typeof DEFAULT_DATAFLOW_PIPELINE>): string {
 	const isObj = typeof nodeId === 'object' && nodeId !== null && 'id' in nodeId;
@@ -77,16 +76,6 @@ export function summarizeIdsIfTooLong(formatter: OutputFormatter, ids: readonly
 	return formatter === markdownFormatter ? textWithTooltip(acc, JSON.stringify(ids)) : acc;
 }
 
-export function asciiDataType(type: DataType): string {
-	if(type.tag === DataTypeTag.Function) {
-		return `Function(${type.parameterTypes.entries().toArray().map(([key, type]) => `${key}: ${asciiDataType(type)}`).join(', ')}) -> ${asciiDataType(type.returnType)}`;
-	} else if(type.tag === DataTypeTag.List) {
-		return `List(${asciiDataType(type.elementType)})`;
-	} else {
-		return type.tag;
-	}
-}
-
 export function asciiSummaryOfQueryResult<S extends SupportedQueryTypes>(formatter: OutputFormatter, totalInMs: number, results: Awaited<QueryResults<S>>, processed: PipelineOutput<typeof DEFAULT_DATAFLOW_PIPELINE>): string {
 	const result: string[] = [];
 
diff --git a/src/typing/pretty-print.ts b/src/typing/pretty-print.ts
index 89d660bf505..97cfcb7ac6f 100644
--- a/src/typing/pretty-print.ts
+++ b/src/typing/pretty-print.ts
@@ -2,21 +2,12 @@ import type { DataType } from './types';
 import { DataTypeTag } from './types';
 import { assertUnreachable } from '../util/assert';
 
-function isAny(t: DataType): boolean {
-	return t.tag === DataTypeTag.Variable &&
-        t.lowerBound.tag === DataTypeTag.Union && t.lowerBound.types.size === 0 &&
-        t.upperBound.tag === DataTypeTag.Intersection && t.upperBound.types.size === 0;
-}
-
 /**
  * Visualize a {@link DataType} as a string.
  * The `shorten` parameter will do sever simplification so should not be used for debugging but just for display purposes.
  */
-export function prettyPrint(t: DataType, shorten = true): string {
-	const tag = t.tag;
-	if(isAny(t)) {
-		return 'any';
-	}
+export function prettyPrintDataType(type: DataType, shorten = true): string {
+	const tag = type.tag;
 	switch(tag) {
 		case DataTypeTag.String:
 		case DataTypeTag.Integer:
@@ -27,48 +18,50 @@ export function prettyPrint(t: DataType, shorten = true): string {
 		case DataTypeTag.Raw:
 		case DataTypeTag.Environment:
 		case DataTypeTag.Language:
-			return shorten && tag.startsWith('R') && tag.endsWith('Type') ? tag.slice(1, -4) : tag;
+			return shorten && tag.startsWith('R') && tag.endsWith('Type') ? tag.slice(1, -4).toLowerCase() : tag.toLowerCase();
 		case DataTypeTag.Function:
-			return `${shorten ? 'fn' : 'function'}(${[...t.parameterTypes.entries()].map(([k, v]) => 
-				k ? `${k}: ${prettyPrint(v, shorten)}` : prettyPrint(v, shorten)
-			).join(', ')}) ${shorten ? '→' : '->'} ${prettyPrint(t.returnType, shorten)}`;
+			return `(${[...type.parameterTypes.entries()].map(([k, v]) => 
+				`${k}: ${prettyPrintDataType(v, shorten)}`
+			).join(', ')}) ${shorten ? '→' : '->'} ${prettyPrintDataType(type.returnType, shorten)}`;
 		case DataTypeTag.List: {
-			const type = prettyPrint(t.elementType, shorten);
-			const indexed = t.indexedElementTypes.size > 0 ? `, idx: {${[...t.indexedElementTypes.entries()].map(([k, v]) => 
-				k ? `${k}: ${prettyPrint(v, shorten)}` : prettyPrint(v, shorten)).join(', ')}}` : '';
-			if(shorten && indexed === '' && type === 'any' || type === '$(any)') {
-				return 'list';
-			}
-			return `list<${type}${indexed}>`;
+			const elementType = prettyPrintDataType(type.elementType, shorten);
+			const indexedElementTypes = `${[...type.indexedElementTypes.entries()].map(([k, v]) => 
+				`${k}: ${prettyPrintDataType(v, shorten)}`
+			).join(', ')}`;
+			return `list[${shorten || indexedElementTypes === '' ? elementType : indexedElementTypes}]`;
 		} case DataTypeTag.Variable: {
-			const prefix = shorten ? '$' : 'var(';
-			// subsumes didn't work :/
-			const lower = prettyPrint(t.lowerBound, shorten);
-			const upper = prettyPrint(t.upperBound, shorten);
-			if(shorten && lower === upper) {
-				return `${prefix}(${prettyPrint(t.lowerBound, shorten)})`;
+			const prefix = shorten ? '?' : 'var';
+			const lower = prettyPrintDataType(type.lowerBound, shorten);
+			const upper = prettyPrintDataType(type.upperBound, shorten);
+			if(shorten && lower === '⊥' && upper === '⊤') {
+				return `${prefix}`;
 			}
 			return `${prefix}(${lower}, ${upper})`;
 		}
 		case DataTypeTag.Union: {
-			if(shorten && t.types.size === 1) {
-				return prettyPrint([...t.types][0], shorten);
+			if(type.types.size === 0) {
+				return shorten ? '⊥' : 'none';
 			}
-			const types = [...t.types].map(d => prettyPrint(d, shorten));
-			if(shorten && types.some(t => t === 'any' || t === '$(any)')) {
-				return '⋃(any*)';
+			if(shorten && type.types.size === 1) {
+				return prettyPrintDataType([...type.types][0], shorten);
 			}
-			return `${shorten ? '⋃' : 'union'}(${types.join(', ')}))`;
+			const types = [...type.types].map(d => prettyPrintDataType(d, shorten));
+			return shorten ? `${types.join(' ⋃ ')})` : `union(${types.join(', ')})`;
 		}
-		case DataTypeTag.Intersection:
-			if(shorten && t.types.size === 1) {
-				return prettyPrint([...t.types][0], shorten);
+		case DataTypeTag.Intersection: {
+			if(type.types.size === 0) {
+				return shorten ? '⊤' : 'any';
 			}
-			return `${shorten ? '⋂' : 'intersection'}(${[...t.types].map(d => prettyPrint(d, shorten)).join(', ')})`;
+			if(shorten && type.types.size === 1) {
+				return prettyPrintDataType([...type.types][0], shorten);
+			}
+			const types = [...type.types].map(d => prettyPrintDataType(d, shorten));
+			return shorten ? `${types.join(' ⋂ ')})` : `intersection(${types.join(', ')})`;
+		}
 		case DataTypeTag.AtomicVector:
-			return `${shorten ? 'c' : 'vector'}<${prettyPrint(t.elementType, shorten)}>`;
+			return `vector[${prettyPrintDataType(type.elementType, shorten)}]`;
 		case DataTypeTag.Error:
-			return `error(${JSON.stringify(t.conflictingBounds)})`;
+			return 'error';
 		default:
 			assertUnreachable(tag);
 	}

From d6999e1c2e51c65379f50ac3462f29d82ab71e18 Mon Sep 17 00:00:00 2001
From: Lukas Rohde <lukas.rohde@silupe.de>
Date: Wed, 6 Aug 2025 18:28:36 +0200
Subject: [PATCH 131/153] feat-fix(typing): fix bug with virtual node ids in
 mapNormalizedAstInfo

---
 src/r-bridge/lang-4.x/ast/model/processing/decorate.ts | 7 +++++--
 1 file changed, 5 insertions(+), 2 deletions(-)

diff --git a/src/r-bridge/lang-4.x/ast/model/processing/decorate.ts b/src/r-bridge/lang-4.x/ast/model/processing/decorate.ts
index 130259cf404..b037261c23f 100644
--- a/src/r-bridge/lang-4.x/ast/model/processing/decorate.ts
+++ b/src/r-bridge/lang-4.x/ast/model/processing/decorate.ts
@@ -519,9 +519,12 @@ export function mapAstInfo<OldInfo, Down, NewInfo>(ast: RNode<OldInfo>, down: Do
 }
 
 export function mapNormalizedAstInfo<OldInfo extends ParentInformation, NewInfo>(normalizedAst: NormalizedAst<OldInfo>, infoMapper: (node: RNode<OldInfo>) => NewInfo): NormalizedAst<NewInfo> {
-	for(const [id, node] of normalizedAst.idMap.entries()) {
-		if(id === node.info.id) { // we skip virtual nodes
+	const mappedNodes = new Set<RNode>(); // To avoid repeatedly mapping the same node in case of virtual node ids
+	
+	for(const node of normalizedAst.idMap.values()) {
+		if(!mappedNodes.has(node)) {
 			(node.info as unknown as NewInfo) = infoMapper(node);
+			mappedNodes.add(node);
 		}
 	}
 

From 2ea13cb16d2c88b4ac8974fc491020c9a0792d95 Mon Sep 17 00:00:00 2001
From: Lukas Rohde <lukas.rohde@silupe.de>
Date: Wed, 6 Aug 2025 20:53:45 +0200
Subject: [PATCH 132/153] feat-fix(typing): fix contextual type inference

---
 src/typing/adapter/load-type-signatures.ts    |  2 -
 src/typing/adapter/traced-function-types.ts   |  5 +
 src/typing/subtyping/infer.ts                 | 94 +++++++++++--------
 .../subtyping/contextual-inference.test.ts    | 18 ++--
 4 files changed, 70 insertions(+), 49 deletions(-)

diff --git a/src/typing/adapter/load-type-signatures.ts b/src/typing/adapter/load-type-signatures.ts
index 89777986e33..bc77852bbdb 100644
--- a/src/typing/adapter/load-type-signatures.ts
+++ b/src/typing/adapter/load-type-signatures.ts
@@ -94,7 +94,5 @@ export async function loadTracedTypes(typeMap: Map<string, Set<UnresolvedDataTyp
 		}
 	}
 
-	// console.dir(typeMap.get('+'), { depth: null, colors: true });
-	
 	return typeMap;
 }
\ No newline at end of file
diff --git a/src/typing/adapter/traced-function-types.ts b/src/typing/adapter/traced-function-types.ts
index 496fd2dfd30..1dd8e72d35c 100644
--- a/src/typing/adapter/traced-function-types.ts
+++ b/src/typing/adapter/traced-function-types.ts
@@ -26,6 +26,9 @@ export function extractTypesFromTraceData(data: readonly TraceCsvRow[]): [RohdeF
 				// eslint-disable-next-line @typescript-eslint/no-non-null-assertion
 				unseenSignaturePackageContributions.get(row.package_name)!.add(signature);
 			}
+			// if(row.function_name === 'print') {
+			// 	console.log('Found print signature:', signature);
+			// }
 		} else {
 			continue; // Skip if we have already seen this signature for this package
 		}
@@ -33,8 +36,10 @@ export function extractTypesFromTraceData(data: readonly TraceCsvRow[]): [RohdeF
 		const functionType = new UnresolvedRFunctionType();
 		for(const [index, type] of argumentTypes.entries()) {
 			constrain(getParameterTypeFromFunction(functionType, index), type);
+			constrain(type, getParameterTypeFromFunction(functionType, index));
 		}
 		constrain(returnType, functionType.returnType);
+		constrain(functionType.returnType, returnType);
 
 		if(!extractedTypes.has(row.package_name)) {
 			extractedTypes.set(row.package_name, new Map());
diff --git a/src/typing/subtyping/infer.ts b/src/typing/subtyping/infer.ts
index 6689fd5c0ad..0b5d5cfa7e9 100644
--- a/src/typing/subtyping/infer.ts
+++ b/src/typing/subtyping/infer.ts
@@ -87,6 +87,7 @@ class TypeInferringCfgGuidedVisitor<
 	}
 
 	protected constraintCache: Map<UnresolvedDataType, Set<UnresolvedDataType>> = new Map();
+	protected orphanTypes:     Set<UnresolvedDataType> = new Set();
 
 
 	protected constrainNodeType(nodeOrId: RNode<UnresolvedTypeInfo> | NodeId, constraint: UnresolvedDataType | { lowerBound?: UnresolvedDataType, upperBound?: UnresolvedDataType }): void {
@@ -104,6 +105,11 @@ class TypeInferringCfgGuidedVisitor<
 		}
 	}
 
+	
+	override start(): void {
+		super.start();
+		this.onVisitorEnd();
+	}
 
 	protected override onNullConstant(data: { vertex: DataflowGraphVertexValue, node: RSymbol<UnresolvedTypeInfo, 'NULL'>; }): void {
 		this.constrainNodeType(data.node, new RNullType());
@@ -130,25 +136,21 @@ class TypeInferringCfgGuidedVisitor<
 	}
 
 	protected inferNodeTypeFromReadOrigins(node: RNode<UnresolvedTypeInfo>, readOrigins: Array<{ id: NodeId, type: OriginType }>): void {
-		let hasUnresolvableOrigins = false;
+		const readOriginNodes = readOrigins.flatMap(origin => this.getNormalizedAst(origin.id) ?? []);
+
 		const lowerBounds = new Set<UnresolvedDataType>();
 		
-		for(const readOrigin of readOrigins ?? []) {
-			const readNode = this.getNormalizedAst(readOrigin.id);
-			if(readNode !== undefined) {
-				this.constrainNodeType(node, { lowerBound: readNode.info.typeVariable });
-				lowerBounds.add(readNode.info.typeVariable);
-			} else {
-				hasUnresolvableOrigins = true;
-			}
+		for(const readNode of readOriginNodes) {
+			this.constrainNodeType(node, { lowerBound: readNode.info.typeVariable });
+			lowerBounds.add(readNode.info.typeVariable);
 		}
 
-		if(hasUnresolvableOrigins) {
+		if(readOriginNodes.length === 0) {
 			if(node.type === RType.Symbol) {
 				// If the read variable has no associated AST node it might be a library constant or function
 				const contextualTypes = this.config.knownTypes.get(node.content);
 				if(contextualTypes !== undefined && contextualTypes.size > 0) {
-					this.constrainNodeType(node, { lowerBound: new UnresolvedRTypeIntersection(...contextualTypes.values()) });
+					this.constrainNodeType(node, { lowerBound: new UnresolvedRTypeUnion(...contextualTypes.values()) });
 				}
 			}
 		} else if(lowerBounds.size > 0) {
@@ -194,36 +196,45 @@ class TypeInferringCfgGuidedVisitor<
 
 	override onDefaultFunctionCall(data: { call: DataflowGraphVertexFunctionCall }): void {
 		const callTargets = this.getOrigins(data.call.id)?.filter((origin) => origin.type === OriginType.FunctionCallOrigin) ?? [];
+		const callTargetNodes = callTargets.flatMap(target => this.getNormalizedAst(target.id) ?? []);
+		
+		const calledFunctionType = new UnresolvedRTypeVariable();
+		
+		const templateFunctionType = new UnresolvedRFunctionType();
+		for(const [index, arg] of data.call.args.entries()) {
+			if(arg === EmptyArgument) {
+				continue; // Skip empty arguments
+			}
 
-		const functionType = new UnresolvedRFunctionType();
-		for(const target of callTargets) {
-			const targetNode = this.getNormalizedAst(target.id);
-			if(targetNode !== undefined) {
-				this.constrainNodeType(targetNode, { upperBound: functionType });
-
-				for(const [index, arg] of data.call.args.entries()) {
-					if(arg === EmptyArgument) {
-						continue; // Skip empty arguments
-					}
-
-					const argNode = this.getNormalizedAst(arg.nodeId);
-					guard(argNode !== undefined, 'Expected argument node to be defined');
-
-					if(arg.name !== undefined) {
-						constrain(argNode.info.typeVariable, getParameterTypeFromFunction(functionType, arg.name), this.constraintCache);
-					} else {
-						constrain(argNode.info.typeVariable, getParameterTypeFromFunction(functionType, index), this.constraintCache);
-					}
-				}
+			const argNode = this.getNormalizedAst(arg.nodeId);
+			guard(argNode !== undefined, 'Expected argument node to be defined');
+
+			if(arg.name !== undefined) {
+				// constrain(argNode.info.typeVariable, getParameterTypeFromFunction(templateFunctionType, arg.name), this.constraintCache);
+				constrain(getParameterTypeFromFunction(templateFunctionType, arg.name), argNode.info.typeVariable, this.constraintCache);
 			} else {
-				// If the target function has no associated AST node it might be a library function
-				const contextualTypes = this.config.knownTypes.get(data.call.name);
-				if(contextualTypes !== undefined && contextualTypes.size > 0) {
-					constrain(new UnresolvedRTypeUnion(...contextualTypes.values()), functionType, this.constraintCache);
-				}
+				// constrain(argNode.info.typeVariable, getParameterTypeFromFunction(templateFunctionType, index), this.constraintCache);
+				constrain(getParameterTypeFromFunction(templateFunctionType, index), argNode.info.typeVariable, this.constraintCache);
+			}
+		}
+		constrain(calledFunctionType, templateFunctionType, this.constraintCache);
+
+		for(const targetNode of callTargetNodes) {
+			this.constrainNodeType(targetNode, { upperBound: templateFunctionType });
+		}
+		
+		if(callTargetNodes.length === 0) {
+			// If the target function has no associated AST node it might be a library function
+			const contextualTypes = this.config.knownTypes.get(data.call.name);
+			if(contextualTypes !== undefined && contextualTypes.size > 0) {
+				// console.log('Constraining node', data.call.id, 'with contextual types for', data.call.name);
+				constrain(new UnresolvedRTypeIntersection(...contextualTypes.values()), calledFunctionType, this.constraintCache);
 			}
 		}
-		this.constrainNodeType(data.call.id, functionType.returnType);
+
+		this.constrainNodeType(data.call.id, templateFunctionType.returnType);
+		
+		this.orphanTypes.add(calledFunctionType);
 	}
 
 	override onGetCall(data: { call: DataflowGraphVertexFunctionCall }) {
@@ -497,4 +508,13 @@ class TypeInferringCfgGuidedVisitor<
 				break;
 		}
 	}
+
+	protected onVisitorEnd(): void {
+		// Resolve types that are not directly constrained by a node type
+		for(const type of this.orphanTypes) {
+			// console.debug('Resolved orphan type:');
+			// console.dir(resolve(type), { depth: null, colors: true });
+			resolve(type);
+		}
+	}
 }
\ No newline at end of file
diff --git a/test/functionality/typing/subtyping/contextual-inference.test.ts b/test/functionality/typing/subtyping/contextual-inference.test.ts
index b1735c9d652..c83bf8cddb8 100644
--- a/test/functionality/typing/subtyping/contextual-inference.test.ts
+++ b/test/functionality/typing/subtyping/contextual-inference.test.ts
@@ -1,17 +1,15 @@
-import { beforeAll, describe } from 'vitest';
-import { RTypeIntersection, RTypeUnion, RTypeVariable } from '../../../../src/typing/types';
+import { describe } from 'vitest';
+import { RAtomicVectorType, RComplexType, RStringType, RTypeIntersection, RTypeVariable } from '../../../../src/typing/types';
 import { assertInferredType } from '../../_helper/typing/subtyping/assert-inferred-type';
 import type { UnresolvedDataType } from '../../../../src/typing/subtyping/types';
-import { loadTracedTypes, loadTurcotteTypes } from '../../../../src/typing/adapter/load-type-signatures';
+import { loadTracedTypes, /*loadTurcotteTypes*/ } from '../../../../src/typing/adapter/load-type-signatures';
 
-describe('Infer no type information for currently unsupported R expressions', () => {
+describe('Infer no type information for currently unsupported R expressions', async() => {
 	const knownTypes: Map<string, Set<UnresolvedDataType>> = new Map();
 	
-	beforeAll(async() => {
-		await loadTurcotteTypes(knownTypes);
-		await loadTracedTypes(knownTypes);
-	});
+	// await loadTurcotteTypes(knownTypes);
+	await loadTracedTypes(knownTypes);
 
-	assertInferredType('1 + 2',                  new RTypeVariable(new RTypeUnion(), new RTypeIntersection()), knownTypes);
-	assertInferredType('print("Hello, world!")', new RTypeVariable(new RTypeUnion(), new RTypeIntersection()), knownTypes);
+	assertInferredType('1 + 2',                  new RTypeVariable(new RAtomicVectorType(new RComplexType()), new RTypeIntersection()), knownTypes);
+	assertInferredType('print("Hello, world!")', new RTypeVariable(new RAtomicVectorType(new RStringType()), new RTypeIntersection()), knownTypes);
 });
\ No newline at end of file

From dd3f6895cf91467e9dcbd3ac2bee70b4c906b075 Mon Sep 17 00:00:00 2001
From: Lukas Rohde <lukas.rohde@silupe.de>
Date: Wed, 6 Aug 2025 21:00:49 +0200
Subject: [PATCH 133/153] feat(typing): refine type extraction from traced data

---
 src/typing/adapter/traced-function-types.ts | 18 ++++--------------
 1 file changed, 4 insertions(+), 14 deletions(-)

diff --git a/src/typing/adapter/traced-function-types.ts b/src/typing/adapter/traced-function-types.ts
index 1dd8e72d35c..04b8f21fa94 100644
--- a/src/typing/adapter/traced-function-types.ts
+++ b/src/typing/adapter/traced-function-types.ts
@@ -70,7 +70,7 @@ function typeFromStr(str: string): UnresolvedDataType {
 		return vectorType;
 	} else if(str === 'function') {
 		return new UnresolvedRFunctionType();
-	} else if(str === 'list') {
+	} else if(str === 'list' || str === 'dgCMatrix') {
 		return new UnresolvedRListType();
 	} else if(str === 'logical') {
 		return new RLogicalType();
@@ -86,25 +86,15 @@ function typeFromStr(str: string): UnresolvedDataType {
 		return new RRawType();
 	} else if(str === 'NULL') {
 		return new RNullType();
-	} else if(str === 'formula' || str === 'expression' || str === 'name' || str === 'symbol' || str === 'language' || str === 'call') {
+	} else if(str === 'formula' || str === 'expression' || str === 'name' || str === 'symbol' || str === 'language' || str === 'call' || str === 'srcfile' || str === '<-' || str === '(' || str === 'if' || str === '{' || str === 'for') {
 		return new RLanguageType();
 	} else if(str === 'environment') {
 		return new REnvironmentType();
 	} else if(str === 'S4') {
 		// S4 types are not supported yet, so we return a variable type
 		return new UnresolvedRTypeVariable();
-	} else if(str === 'dgCMatrix') {
-		// Time for crying
-		return new UnresolvedRListType();
-	} else if(str === '<-' || str === '(' || str === 'if' || str === '{' || str === 'for') {
-		// Arbitrary definitions
-		return new UnresolvedRTypeVariable();
-	} else if(str === 'srcfile') {
-		return new UnresolvedRTypeVariable();
-	} else if(str === 'standardGeneric') {
-		return new UnresolvedRFunctionType();
-	} else if(str === 'mle' || str === 'track' || str === 'derivedDefaultMethod' || str === 'jmcmMod' || str === 'glmerMod') {
-		// Huh?
+	} else if(str === 'standardGeneric' || str === 'mle' || str === 'track' || str === 'derivedDefaultMethod' || str === 'jmcmMod' || str === 'glmerMod') {
+		// Give Up
 		return new UnresolvedRTypeVariable();
 	} else {
 		throw new Error(`Unknown type: ${str}`);

From 8c442f6bc2567e8de9ec9193ee9bb0719e3ad585 Mon Sep 17 00:00:00 2001
From: Lukas Rohde <lukas.rohde@silupe.de>
Date: Thu, 7 Aug 2025 15:36:33 +0200
Subject: [PATCH 134/153] build-fix(typing): fix inclusion and resolution of
 csv data files

---
 package.json                               | 3 ++-
 src/typing/adapter/load-type-signatures.ts | 5 +++--
 2 files changed, 5 insertions(+), 3 deletions(-)

diff --git a/package.json b/package.json
index 6b2cc4701c1..9162db1a3ac 100644
--- a/package.json
+++ b/package.json
@@ -42,8 +42,9 @@
     "gen:linter-issue": "ts-node src/documentation/print-linter-issue.ts",
     "build": "tsc --project .",
     "build-dev": "npm run build && npm run build:copy-wasm",
-    "build:bundle-flowr": "npm run build && esbuild --bundle dist/src/cli/flowr.js --platform=node --tree-shaking=true --bundle --minify --external:clipboardy --target=node22 --outfile=dist/src/cli/flowr.min.js && npm run build:copy-wasm",
+    "build:bundle-flowr": "npm run build && esbuild --bundle dist/src/cli/flowr.js --platform=node --tree-shaking=true --bundle --minify --external:clipboardy --target=node22 --outfile=dist/src/cli/flowr.min.js && npm run build:copy-wasm && npm run build:copy-csvs",
     "build:copy-wasm": "mkdir -p dist/node_modules/@eagleoutice/tree-sitter-r/ && mkdir -p dist/node_modules/web-tree-sitter && cp node_modules/@eagleoutice/tree-sitter-r/tree-sitter-r.wasm dist/node_modules/@eagleoutice/tree-sitter-r/  && cp node_modules/web-tree-sitter/tree-sitter.wasm dist/node_modules/web-tree-sitter/",
+    "build:copy-csvs": "cp src/typing/adapter/traced-function-types.csv dist/src/typing/adapter/traced-function-types.csv && cp src/typing/adapter/turcotte-types.csv dist/src/typing/adapter/turcotte-types.csv",
     "lint-local": "npx eslint --version && npx eslint src/ test/ --rule \"no-warning-comments: off\"",
     "lint": "npm run license-compat -- --summary && npx eslint --version && npx eslint src/ test/",
     "license-compat": "license-checker --onlyAllow 'MIT;MIT OR X11;GPLv2;LGPL;GNUGPL;ISC;Apache-2.0;FreeBSD;BSD-2-Clause;clearbsd;ModifiedBSD;BSD-3-Clause;Python-2.0;Unlicense;WTFPL;BlueOak-1.0.0;CC-BY-4.0;CC-BY-3.0;CC0-1.0;0BSD'",
diff --git a/src/typing/adapter/load-type-signatures.ts b/src/typing/adapter/load-type-signatures.ts
index bc77852bbdb..f9af91d2095 100644
--- a/src/typing/adapter/load-type-signatures.ts
+++ b/src/typing/adapter/load-type-signatures.ts
@@ -4,11 +4,12 @@ import type { TraceCsvRow } from './traced-function-types';
 import { extractTypesFromTraceData } from './traced-function-types';
 import { turcotte2RohdeTypes, type TurcotteCsvRow } from './turcotte-types';
 import fs from 'fs';
+import path from 'path';
 
 export async function loadTurcotteTypes(typeMap: Map<string, Set<UnresolvedDataType>> = new Map()): Promise<Map<string, Set<UnresolvedDataType>>> {
 	const data: TurcotteCsvRow[] = [];
 	await new Promise(resolve => {
-		fs.createReadStream('src/typing/adapter/turcotte-types.csv', { encoding: 'utf-8' })
+		fs.createReadStream(path.resolve('dist/src/typing/adapter/turcotte-types.csv'), { encoding: 'utf-8' })
 			.pipe(csvParser({ separator: ',' }))
 			.on('data', (row: TurcotteCsvRow) => {
 				data.push(row);
@@ -49,7 +50,7 @@ function trimQuotes(str: string): string {
 export async function loadTracedTypes(typeMap: Map<string, Set<UnresolvedDataType>> = new Map()): Promise<Map<string, Set<UnresolvedDataType>>> {
 	const data: TraceCsvRow[] = [];
 	await new Promise(resolve => {
-		fs.createReadStream('src/typing/adapter/traced-function-types.csv', { encoding: 'utf-8' })
+		fs.createReadStream(path.resolve('dist/src/typing/adapter/traced-function-types.csv'), { encoding: 'utf-8' })
 			.pipe(csvParser({
 				separator:  ',',
 				mapHeaders: ({ header }) => {

From 8c9a66917341c2c155c82f322fb182590679e1bd Mon Sep 17 00:00:00 2001
From: Lukas Rohde <lukas.rohde@silupe.de>
Date: Fri, 8 Aug 2025 00:45:09 +0200
Subject: [PATCH 135/153] feat-fix(typing): fix constraints of loaded function
 signatures

---
 src/typing/adapter/traced-function-types.ts   |  6 +-
 src/typing/adapter/turcotte-types.ts          | 14 ++--
 src/typing/subtyping/types.ts                 |  4 +-
 .../subtyping/contextual-inference.test.ts    | 15 ++--
 .../typing/subtyping/resolve.test.ts          | 74 +++++++++++++++++++
 5 files changed, 94 insertions(+), 19 deletions(-)

diff --git a/src/typing/adapter/traced-function-types.ts b/src/typing/adapter/traced-function-types.ts
index 04b8f21fa94..1dbe18bb7d4 100644
--- a/src/typing/adapter/traced-function-types.ts
+++ b/src/typing/adapter/traced-function-types.ts
@@ -15,7 +15,7 @@ export function extractTypesFromTraceData(data: readonly TraceCsvRow[]): [RohdeF
 	const unseenSignaturePackageContributions: Map<string, Set<string>> = new Map();
 
 	for(const row of data) {
-		const argumentTypes = row.parameter_types.map(typeFromStr);
+		const parameterTypes = row.parameter_types.map(typeFromStr);
 		const returnType = typeFromStr(row.return_type);
 
 		const signature = `${row.function_name} : (${row.parameter_types.join(', ')}) -> ${row.return_type}`;
@@ -34,12 +34,10 @@ export function extractTypesFromTraceData(data: readonly TraceCsvRow[]): [RohdeF
 		}
 
 		const functionType = new UnresolvedRFunctionType();
-		for(const [index, type] of argumentTypes.entries()) {
+		for(const [index, type] of parameterTypes.entries()) {
 			constrain(getParameterTypeFromFunction(functionType, index), type);
-			constrain(type, getParameterTypeFromFunction(functionType, index));
 		}
 		constrain(returnType, functionType.returnType);
-		constrain(functionType.returnType, returnType);
 
 		if(!extractedTypes.has(row.package_name)) {
 			extractedTypes.set(row.package_name, new Map());
diff --git a/src/typing/adapter/turcotte-types.ts b/src/typing/adapter/turcotte-types.ts
index 671fa1250bd..bf86e64bde9 100644
--- a/src/typing/adapter/turcotte-types.ts
+++ b/src/typing/adapter/turcotte-types.ts
@@ -77,22 +77,22 @@ function constrainLowerAndUpperBound(type: UnresolvedDataType, lowerBound: Unres
 
 function convertSingleTurcotteFunctionAlternative2RohdeType(fingerprint: string, rows: TurcotteCsvRow[]): UnresolvedRFunctionType {
 	const groupedByParameterPos = groupTurcotteData(rows, row => row.parameter_position);
-	const fn = new UnresolvedRFunctionType();
+	const functionType = new UnresolvedRFunctionType();
 
 	for(const [parameterPosition, parameterRows] of groupedByParameterPos.entries()) {
 		// convert the rows to a single type
 		const type = convertSingleTurcotteParameter2RohdeType(fingerprint, parameterRows);
 		if(parameterPosition === '-1') {
-			constrainLowerAndUpperBound(fn.returnType, type);
+			constrain(type, functionType.returnType, globalCache);
 		} else {
 			// we get the type to create a new one if not already there
-			const parameterType = getParameterTypeFromFunction(fn, Number(parameterPosition));
+			const parameterType = getParameterTypeFromFunction(functionType, Number(parameterPosition));
 			// now we can set the type
-			constrainLowerAndUpperBound(parameterType, type);
+			constrain(parameterType, type, globalCache);
 		}
 	}
 
-	return fn;
+	return functionType;
 }
 
 function convertSingleTurcotteParameter2RohdeType(fingerprint: string, rows: TurcotteCsvRow[]): UnresolvedDataType {
@@ -106,9 +106,7 @@ function convertSingleTurcotteParameter2RohdeType(fingerprint: string, rows: Tur
         r.function_name === anyRow.function_name), 'Just for my sanity, please!');
 
 	// now we convert all types in the list to the rohde System
-	return new UnresolvedRTypeUnion(
-		...rows.map(r => turcotteType2RohdeType(r.type))
-	);
+	return alternativeTurcotteType2RohdeType(rows.map(row => row.type));
 }
 
 function turcotteType2RohdeType(type: string): UnresolvedDataType {
diff --git a/src/typing/subtyping/types.ts b/src/typing/subtyping/types.ts
index bfcea08ccb6..db54d21322f 100644
--- a/src/typing/subtyping/types.ts
+++ b/src/typing/subtyping/types.ts
@@ -103,7 +103,7 @@ export class UnresolvedRTypeVariable {
 
 
 export function constrain(subtype: UnresolvedDataType, supertype: UnresolvedDataType, cache: Map<UnresolvedDataType, Set<UnresolvedDataType>> = new Map()): void {
-	// console.debug('Constraining', inspect(subtype, { depth: null, colors: true }), 'to subsume', inspect(supertype, { depth: null, colors: true }));
+	// console.debug('Constraining', subtype instanceof UnresolvedRTypeVariable ? subtype.id : inspect(subtype, { depth: null, colors: true }), 'to subsume', supertype instanceof UnresolvedRTypeVariable ? supertype.id : inspect(supertype, { depth: null, colors: true }));
 
 	if(subtype === supertype) {
 		return; // No need to constrain if both types are the same
@@ -352,7 +352,7 @@ export function subsumes(subtype: DataType | UnresolvedDataType, supertype: Data
 
 	let processedSupertypes = inProcess.get(subtype);
 	if(processedSupertypes?.has(supertype)) {
-		return true; // Avoid infinite recursion
+		return true; // If we have already processed this pair, we can assume it subsumes
 	}
 	processedSupertypes ??= new Set();
 	processedSupertypes.add(supertype);
diff --git a/test/functionality/typing/subtyping/contextual-inference.test.ts b/test/functionality/typing/subtyping/contextual-inference.test.ts
index c83bf8cddb8..2b019e0c36d 100644
--- a/test/functionality/typing/subtyping/contextual-inference.test.ts
+++ b/test/functionality/typing/subtyping/contextual-inference.test.ts
@@ -1,15 +1,20 @@
 import { describe } from 'vitest';
-import { RAtomicVectorType, RComplexType, RStringType, RTypeIntersection, RTypeVariable } from '../../../../src/typing/types';
+import { RAtomicVectorType, RComplexType, RDoubleType, RStringType, RTypeIntersection, RTypeUnion, RTypeVariable } from '../../../../src/typing/types';
 import { assertInferredType } from '../../_helper/typing/subtyping/assert-inferred-type';
 import type { UnresolvedDataType } from '../../../../src/typing/subtyping/types';
-import { loadTracedTypes, /*loadTurcotteTypes*/ } from '../../../../src/typing/adapter/load-type-signatures';
+import { loadTracedTypes, loadTurcotteTypes } from '../../../../src/typing/adapter/load-type-signatures';
 
 describe('Infer no type information for currently unsupported R expressions', async() => {
 	const knownTypes: Map<string, Set<UnresolvedDataType>> = new Map();
 	
-	// await loadTurcotteTypes(knownTypes);
-	await loadTracedTypes(knownTypes);
+	await loadTurcotteTypes(knownTypes);
 
+	// const printTypes = knownTypes.get('print')?.values().toArray() ?? [];
+	// console.dir(printTypes, { depth: null, colors: true });
+	// knownTypes.set('print', new Set([printTypes[1]]));
+	
+	await loadTracedTypes(knownTypes);
+	
 	assertInferredType('1 + 2',                  new RTypeVariable(new RAtomicVectorType(new RComplexType()), new RTypeIntersection()), knownTypes);
-	assertInferredType('print("Hello, world!")', new RTypeVariable(new RAtomicVectorType(new RStringType()), new RTypeIntersection()), knownTypes);
+	assertInferredType('print("Hello, world!")', new RTypeVariable(new RAtomicVectorType(new RTypeUnion(new RStringType(), new RDoubleType())), new RTypeIntersection()), knownTypes);
 });
\ No newline at end of file
diff --git a/test/functionality/typing/subtyping/resolve.test.ts b/test/functionality/typing/subtyping/resolve.test.ts
index f019440ce61..49fda5a5477 100644
--- a/test/functionality/typing/subtyping/resolve.test.ts
+++ b/test/functionality/typing/subtyping/resolve.test.ts
@@ -196,6 +196,80 @@ describe('Constrain and resolve types', () => {
 		expect(resolve(returnType1)).toEqual(new RTypeVariable(new RDoubleType(), new RTypeIntersection()));
 		expect(resolve(returnType2)).toEqual(new RTypeVariable(new RDoubleType(), new RTypeIntersection()));
 	});
+	
+	test('Function overloading 3', () => {
+		const cache = new Map<UnresolvedDataType, Set<UnresolvedDataType>>();
+
+		// Predetermined types in context
+		const funcType1 = new UnresolvedRFunctionType();
+		const paramType1 = new UnresolvedRTypeVariable();
+		funcType1.parameterTypes.set(0, paramType1);
+		// constrain(new RIntegerType(), paramType1, cache);
+		constrain(paramType1, new RIntegerType(), cache);
+		constrain(new RIntegerType(), funcType1.returnType, cache);
+		// constrain(funcType1.returnType, new RIntegerType(), cache);
+
+		const funcType2 = new UnresolvedRFunctionType();
+		const paramType2 = new UnresolvedRTypeVariable();
+		funcType2.parameterTypes.set(0, paramType2);
+		// constrain(new RStringType(), paramType2, cache);
+		constrain(paramType2, new RStringType(), cache);
+		constrain(new RStringType(), funcType2.returnType, cache);
+		// constrain(funcType2.returnType, new RStringType(), cache);
+
+		const funcType3 = new UnresolvedRFunctionType();
+		const paramType3 = new UnresolvedRTypeVariable();
+		funcType3.parameterTypes.set(0, paramType3);
+		const var1 = new UnresolvedRTypeVariable();
+		// const var2 = new UnresolvedRTypeVariable();
+		constrain(paramType3, var1, cache);
+		// constrain(var1, paramType3, cache); // AVOID THIS AT ALL COSTS!
+		// constrain(funcType3.returnType, var2, cache);
+		// constrain(var2, funcType3.returnType, cache);
+
+		const overloadedFuncType1 = new UnresolvedRTypeIntersection(funcType3, funcType1, funcType2);
+		const overloadedFuncType2 = new UnresolvedRTypeIntersection(funcType3, funcType2, funcType1);
+
+		// Typing of called function
+		const calledFuncType1 = new UnresolvedRTypeVariable();
+		const calledFuncType2 = new UnresolvedRTypeVariable();
+		constrain(overloadedFuncType1, calledFuncType1, cache);
+		constrain(overloadedFuncType2, calledFuncType2, cache);
+
+		// Typing of function call
+		const argType1 = new UnresolvedRTypeVariable();
+		// const argType2 = new UnresolvedRTypeVariable();
+		// constrain(new RIntegerType(), argType1, cache);
+		constrain(argType1, new RIntegerType(), cache);
+		// constrain(new RStringType(), argType2, cache);
+		// constrain(argType2, new RStringType(), cache);
+		const templateFuncType1 = new UnresolvedRFunctionType();
+		templateFuncType1.parameterTypes.set(0, argType1);
+		const returnType1 = templateFuncType1.returnType;
+		const templateFuncType2 = new UnresolvedRFunctionType();
+		// templateFuncType2.parameterTypes.set(0, argType2);
+		const returnType2 = templateFuncType2.returnType;
+		constrain(calledFuncType1, templateFuncType1, cache);
+		constrain(calledFuncType2, templateFuncType2, cache);
+
+		resolve(calledFuncType1);
+		// resolve(calledFuncType2);
+
+		// console.debug('funcType3', inspect(funcType3, { depth: null, colors: true }));
+		// console.debug('funcType1', inspect(funcType1, { depth: null, colors: true }));
+		// console.debug('funcType2', inspect(funcType2, { depth: null, colors: true }));
+		// console.debug('overloadedFuncType1', inspect(overloadedFuncType1, { depth: null, colors: true }));
+		// console.debug('overloadedFuncType2', inspect(overloadedFuncType2, { depth: null, colors: true }));
+		// console.debug('calledFuncType1', inspect(calledFuncType1, { depth: null, colors: true }));
+		// console.debug('calledFuncType2', inspect(calledFuncType2, { depth: null, colors: true }));
+		// console.debug('templateFuncType1', inspect(templateFuncType1, { depth: null, colors: true }));
+		// console.debug('templateFuncType2', inspect(templateFuncType2, { depth: null, colors: true }));
+		// console.debug('returnType1', inspect(returnType1, { depth: null, colors: true }));
+		// console.debug('returnType2', inspect(returnType2, { depth: null, colors: true }));
+
+		expect(resolve(returnType1)).toEqual(new RTypeVariable(new RIntegerType(), new RTypeIntersection()));
+		expect(resolve(returnType2)).toEqual(new RTypeVariable(new RTypeUnion(), new RTypeIntersection()));
+	});
 
 	test('Constrain from both sides 1', () => {
 		const cache = new Map<UnresolvedDataType, Set<UnresolvedDataType>>();

From bbbd51da6ba1202e154d4ae427e63e8d493392eb Mon Sep 17 00:00:00 2001
From: Lukas Rohde <lukas.rohde@silupe.de>
Date: Fri, 8 Aug 2025 16:10:49 +0200
Subject: [PATCH 136/153] feat(typing): add limited support for S4 and improve
 subsetting rules

---
 src/typing/adapter/traced-function-types.ts   |  5 +-
 src/typing/pretty-print.ts                    |  1 +
 src/typing/subtyping/infer.ts                 | 58 +++++++++++--------
 src/typing/subtyping/types.ts                 |  9 +--
 src/typing/types.ts                           | 20 +++++--
 .../typing/subtyping/replacement.test.ts      | 10 +++-
 .../typing/subtyping/subsetting.test.ts       |  9 ++-
 7 files changed, 71 insertions(+), 41 deletions(-)

diff --git a/src/typing/adapter/traced-function-types.ts b/src/typing/adapter/traced-function-types.ts
index 1dbe18bb7d4..fa474b7dfc1 100644
--- a/src/typing/adapter/traced-function-types.ts
+++ b/src/typing/adapter/traced-function-types.ts
@@ -1,6 +1,6 @@
 import type { UnresolvedDataType } from '../subtyping/types';
 import { UnresolvedRTypeVariable , constrain, getParameterTypeFromFunction, UnresolvedRAtomicVectorType, UnresolvedRFunctionType, UnresolvedRListType } from '../subtyping/types';
-import { RComplexType, RDoubleType, REnvironmentType, RIntegerType, RLanguageType, RLogicalType, RNullType, RRawType, RStringType } from '../types';
+import { RComplexType, RDoubleType, REnvironmentType, RIntegerType, RLanguageType, RLogicalType, RNullType, RRawType, RS4Type, RStringType } from '../types';
 import type { RohdeFunctionTypeInformation } from './interface';
 
 export interface TraceCsvRow {
@@ -89,8 +89,7 @@ function typeFromStr(str: string): UnresolvedDataType {
 	} else if(str === 'environment') {
 		return new REnvironmentType();
 	} else if(str === 'S4') {
-		// S4 types are not supported yet, so we return a variable type
-		return new UnresolvedRTypeVariable();
+		return new RS4Type();
 	} else if(str === 'standardGeneric' || str === 'mle' || str === 'track' || str === 'derivedDefaultMethod' || str === 'jmcmMod' || str === 'glmerMod') {
 		// Give Up
 		return new UnresolvedRTypeVariable();
diff --git a/src/typing/pretty-print.ts b/src/typing/pretty-print.ts
index 97cfcb7ac6f..a59864d59fb 100644
--- a/src/typing/pretty-print.ts
+++ b/src/typing/pretty-print.ts
@@ -18,6 +18,7 @@ export function prettyPrintDataType(type: DataType, shorten = true): string {
 		case DataTypeTag.Raw:
 		case DataTypeTag.Environment:
 		case DataTypeTag.Language:
+		case DataTypeTag.S4:
 			return shorten && tag.startsWith('R') && tag.endsWith('Type') ? tag.slice(1, -4).toLowerCase() : tag.toLowerCase();
 		case DataTypeTag.Function:
 			return `(${[...type.parameterTypes.entries()].map(([k, v]) => 
diff --git a/src/typing/subtyping/infer.ts b/src/typing/subtyping/infer.ts
index 0b5d5cfa7e9..5accd4c6b80 100644
--- a/src/typing/subtyping/infer.ts
+++ b/src/typing/subtyping/infer.ts
@@ -9,7 +9,7 @@ import type { RString } from '../../r-bridge/lang-4.x/ast/model/nodes/r-string';
 import type { NormalizedAst, ParentInformation } from '../../r-bridge/lang-4.x/ast/model/processing/decorate';
 import { mapNormalizedAstInfo } from '../../r-bridge/lang-4.x/ast/model/processing/decorate';
 import type { DataTypeInfo } from '../types';
-import { RComplexType, RDoubleType, RIntegerType, RLogicalType, RStringType, RNullType, RLanguageType } from '../types';
+import { RComplexType, RDoubleType, RIntegerType, RLogicalType, RStringType, RNullType, RLanguageType, RS4Type } from '../types';
 import type { RExpressionList } from '../../r-bridge/lang-4.x/ast/model/nodes/r-expression-list';
 import { guard } from '../../util/assert';
 import { OriginType } from '../../dataflow/origin/dfg-get-origin';
@@ -455,23 +455,32 @@ class TypeInferringCfgGuidedVisitor<
 		const firstArgNode = this.getNormalizedAst(firstArg.nodeId);
 		guard(firstArgNode !== undefined, 'Expected first argument node to be defined');
 
-		const elementType = new UnresolvedRTypeVariable();
-		const vectorType = new UnresolvedRTypeUnion(new UnresolvedRAtomicVectorType(elementType), new UnresolvedRListType(elementType));
-		this.constrainNodeType(firstArgNode, { upperBound: vectorType });
-
 		switch(data.call.name) {
-			case '[':
-				// If the access call is a `[` operation, we can assume that the it returns a subset
-				// of the first argument's elements as another instance of the same container type
+			case '[': { // If the access call is a `[` operation, we can assume that it returns a subset of the first argument's elements as another instance of the same vector type
+				const vectorType = new UnresolvedRTypeUnion(new UnresolvedRAtomicVectorType(), new UnresolvedRListType());
+				this.constrainNodeType(firstArgNode, { upperBound: vectorType });
 				this.constrainNodeType(data.call.id, { lowerBound: firstArgNode.info.typeVariable });
 				break;
-			case '[[':
+			}
+			
+			case '[[': { // If the access call is a `[[` operation, we can assume that the first argument is a container type and that it returns one of its elements
+				const elementType = new UnresolvedRTypeVariable();
+				const vectorType = new UnresolvedRTypeUnion(new UnresolvedRAtomicVectorType(elementType), new UnresolvedRListType(elementType));
+				this.constrainNodeType(firstArgNode, { upperBound: vectorType });
 				this.constrainNodeType(data.call.id, { lowerBound: elementType });
 				break;
-			case '$':
+			}
+			case '$': {
+				const elementType = new UnresolvedRTypeVariable();
 				this.constrainNodeType(firstArgNode, { upperBound: new UnresolvedRListType(elementType) });
 				this.constrainNodeType(data.call.id, { lowerBound: elementType });
 				break;
+			}
+			case '@': {
+				// The target of the access call must be an S4 object but we can not make any assumptions about its slots
+				this.constrainNodeType(firstArgNode, { upperBound: new RS4Type() });
+				break;
+			}
 		}
 	}
 
@@ -485,27 +494,26 @@ class TypeInferringCfgGuidedVisitor<
 		const sourceNode = this.getNormalizedAst(data.source);
 		guard(sourceNode !== undefined, 'Expected source node to be defined');
 
-		const targetElementType = new UnresolvedRTypeVariable();
-		const targetVectorType = new UnresolvedRTypeUnion(new UnresolvedRAtomicVectorType(targetElementType), new UnresolvedRListType(targetElementType));
-		this.constrainNodeType(targetNode, { upperBound: targetVectorType });
-
 		this.constrainNodeType(data.call.id, sourceNode.info.typeVariable);
 
-		const sourceElementType = new UnresolvedRTypeVariable();
-		const sourceVectorType = new UnresolvedRTypeUnion(new UnresolvedRAtomicVectorType(sourceElementType), new UnresolvedRListType(sourceElementType));
-
 		switch(data.call.name) {
-			case '[<-':
-				// If the replacement call uses a `[` operation, we assume that the source is as another instance of the same container type
-				this.constrainNodeType(sourceNode, { upperBound: sourceVectorType });
+			case '[<-': {
+				this.constrainNodeType(targetNode, { upperBound: new UnresolvedRTypeUnion(new UnresolvedRAtomicVectorType(), new UnresolvedRListType()) });
+				this.constrainNodeType(sourceNode, { upperBound: new UnresolvedRTypeUnion(new UnresolvedRAtomicVectorType(), new UnresolvedRListType()) });
 				break;
-			case '[[<-':
-				this.constrainNodeType(sourceNode, { upperBound: sourceElementType });
+			}
+			case '[[<-': {
+				this.constrainNodeType(targetNode, { upperBound: new UnresolvedRTypeUnion(new UnresolvedRAtomicVectorType(), new UnresolvedRListType()) });
 				break;
-			case '$<-':
-				this.constrainNodeType(targetNode, { upperBound: new UnresolvedRListType(targetElementType) });
-				this.constrainNodeType(sourceNode, { upperBound: sourceElementType });
+			}
+			case '$<-': {
+				this.constrainNodeType(targetNode, { upperBound: new UnresolvedRListType() });
 				break;
+			}
+			case '@<-': {
+				this.constrainNodeType(targetNode, { upperBound: new RS4Type() });
+				break;
+			}
 		}
 	}
 
diff --git a/src/typing/subtyping/types.ts b/src/typing/subtyping/types.ts
index db54d21322f..151c6ba87d4 100644
--- a/src/typing/subtyping/types.ts
+++ b/src/typing/subtyping/types.ts
@@ -1,5 +1,5 @@
 import { guard } from '../../util/assert';
-import type { DataType , AtomicVectorBaseType, REnvironmentType, RLanguageType } from '../types';
+import type { SimpleType, DataType } from '../types';
 import { RNullType , DataTypeTag, isAtomicVectorBaseType, RAtomicVectorType, RFunctionType, RListType, RTypeError, RTypeIntersection, RTypeUnion, RTypeVariable } from '../types';
 
 // let idCounter = 0;
@@ -766,13 +766,10 @@ export function meet(type1: DataType, type2: DataType): DataType {
 
 
 export type UnresolvedDataType
-	= UnresolvedRAtomicVectorType
-	| AtomicVectorBaseType
+	= SimpleType
+	| UnresolvedRAtomicVectorType
 	| UnresolvedRListType
-	| RNullType
 	| UnresolvedRFunctionType
-	| REnvironmentType
-	| RLanguageType
 	| UnresolvedRTypeUnion
 	| UnresolvedRTypeIntersection
 	| UnresolvedRTypeVariable
diff --git a/src/typing/types.ts b/src/typing/types.ts
index 4cadf6477f4..0b3af064374 100644
--- a/src/typing/types.ts
+++ b/src/typing/types.ts
@@ -29,6 +29,8 @@ export enum DataTypeTag {
 	Environment = 'REnvironmentType',
 	/** {@link RLanguageType} */
 	Language = 'RLanguageType',
+	/** {@link RS4Type} */
+	S4 = 'RS4Type',
 	/** {@link RTypeUnion} */
 	Union = 'RTypeUnion',
 	/** {@link RTypeIntersection} */
@@ -107,6 +109,10 @@ export class RLanguageType {
 	readonly tag = DataTypeTag.Language;
 }
 
+export class RS4Type {
+	readonly tag = DataTypeTag.S4;
+}
+
 export class RTypeUnion {
 	readonly tag = DataTypeTag.Union;
 	readonly types: Set<DataType> = new Set();
@@ -171,6 +177,13 @@ export function isAtomicVectorBaseType(type: DataType): type is AtomicVectorBase
 		|| type.tag === DataTypeTag.Raw;
 }
 
+export type SimpleType
+	= AtomicVectorBaseType
+	| RNullType
+	| REnvironmentType
+	| RLanguageType
+	| RS4Type;
+
 /**
  * The `RDataType` type is the union of all possible types that can be inferred
  * by the type inferencer for R objects.
@@ -178,13 +191,10 @@ export function isAtomicVectorBaseType(type: DataType): type is AtomicVectorBase
  * type you are dealing with or if you want to handle all possible types.
 */
 export type DataType
-	= RAtomicVectorType
-	| AtomicVectorBaseType
+	= SimpleType
+	| RAtomicVectorType
 	| RListType
-	| RNullType
 	| RFunctionType
-	| REnvironmentType
-	| RLanguageType
 	| RTypeUnion
 	| RTypeIntersection
 	| RTypeVariable
diff --git a/test/functionality/typing/subtyping/replacement.test.ts b/test/functionality/typing/subtyping/replacement.test.ts
index 1ebac259402..6b1561e44ff 100644
--- a/test/functionality/typing/subtyping/replacement.test.ts
+++ b/test/functionality/typing/subtyping/replacement.test.ts
@@ -1,6 +1,6 @@
 import { describe, expect, test } from 'vitest';
 import type { DataType } from '../../../../src/typing/types';
-import { RTypeIntersection, RAtomicVectorType, RIntegerType, RListType, RTypeVariable, RTypeUnion, RNullType, RLogicalType, RComplexType, RDoubleType } from '../../../../src/typing/types';
+import { RTypeIntersection, RAtomicVectorType, RIntegerType, RListType, RTypeVariable, RTypeUnion, RNullType, RLogicalType, RComplexType, RDoubleType, RS4Type } from '../../../../src/typing/types';
 import { assertInferredTypes } from '../../_helper/typing/subtyping/assert-inferred-type';
 import { Q } from '../../../../src/search/flowr-search-builder';
 
@@ -123,4 +123,12 @@ describe('Infer types for subsetting expressions', () => {
 		{ query: Q.var('y').last().build(),         upperBound: new RTypeUnion(new RAtomicVectorType(new RTypeIntersection()), new RListType(new RTypeIntersection())) },
 		{ query: Q.criterion('1@[').last().build(), upperBound: new RTypeUnion(new RAtomicVectorType(new RTypeIntersection()), new RListType(new RTypeIntersection())) },
 	);
+	
+	assertInferredTypes(
+		'o@"name" <- y; o',
+		undefined,
+		{ query: Q.var('o').last().build(),         upperBound: new RS4Type() },
+		{ query: Q.var('y').last().build(),         expectedType: new RTypeVariable() },
+		{ query: Q.criterion('1@@').last().build(), expectedType: new RTypeVariable() },
+	);
 });
\ No newline at end of file
diff --git a/test/functionality/typing/subtyping/subsetting.test.ts b/test/functionality/typing/subtyping/subsetting.test.ts
index d4a1673f79a..613b53ecd09 100644
--- a/test/functionality/typing/subtyping/subsetting.test.ts
+++ b/test/functionality/typing/subtyping/subsetting.test.ts
@@ -1,6 +1,6 @@
 import { describe } from 'vitest';
 import type { DataType } from '../../../../src/typing/types';
-import { RTypeIntersection, RAtomicVectorType, RIntegerType, RListType, RTypeVariable, RNullType, RLogicalType, RComplexType } from '../../../../src/typing/types';
+import { RTypeIntersection, RAtomicVectorType, RIntegerType, RListType, RTypeVariable, RNullType, RLogicalType, RComplexType, RS4Type } from '../../../../src/typing/types';
 import { assertInferredTypes } from '../../_helper/typing/subtyping/assert-inferred-type';
 import { Q } from '../../../../src/search/flowr-search-builder';
 import { RType } from '../../../../src/r-bridge/lang-4.x/ast/model/type';
@@ -94,4 +94,11 @@ describe('Infer types for subsetting expressions', () => {
 		{ query: Q.var('v').last().build(),                    expectedType: new RNullType() },
 		{ query: Q.all().filter(RType.Access).first().build(), lowerBound: new RNullType() },
 	);
+	
+	assertInferredTypes(
+		'o <- new("Object", name = "Flo"); o@name; o',
+		undefined,
+		{ query: Q.var('o').last().build(),                    upperBound: new RS4Type() },
+		{ query: Q.all().filter(RType.Access).first().build(), expectedType: new RTypeVariable() },
+	);
 });
\ No newline at end of file

From 308f85f445b4d35a573543c2980e326bbe4071f0 Mon Sep 17 00:00:00 2001
From: Lukas Rohde <lukas.rohde@silupe.de>
Date: Sun, 10 Aug 2025 12:29:03 +0200
Subject: [PATCH 137/153] feat(typing): make inference rules for number
 literals more precise

---
 src/typing/subtyping/infer.ts                 |  4 +-
 .../subtyping/builtin-functions.test.ts       | 10 ++---
 .../typing/subtyping/constants.test.ts        |  4 +-
 .../typing/subtyping/replacement.test.ts      | 40 ++++++++---------
 .../typing/subtyping/subsetting.test.ts       | 44 +++++++++----------
 .../typing/subtyping/variables.test.ts        |  8 ++--
 6 files changed, 54 insertions(+), 56 deletions(-)

diff --git a/src/typing/subtyping/infer.ts b/src/typing/subtyping/infer.ts
index 5accd4c6b80..1de17506b6d 100644
--- a/src/typing/subtyping/infer.ts
+++ b/src/typing/subtyping/infer.ts
@@ -124,10 +124,8 @@ class TypeInferringCfgGuidedVisitor<
 			this.constrainNodeType(data.node, new RComplexType());
 		} else if(data.node.content.markedAsInt) {
 			this.constrainNodeType(data.node, new RIntegerType());
-		} else if(data.node.content.num % 1 === 0) {
-			this.constrainNodeType(data.node, { lowerBound: new RIntegerType(), upperBound: new RComplexType() });
 		} else {
-			this.constrainNodeType(data.node, { lowerBound: new RDoubleType(), upperBound: new RComplexType() });
+			this.constrainNodeType(data.node, new RDoubleType());
 		}
 	}
 
diff --git a/test/functionality/typing/subtyping/builtin-functions.test.ts b/test/functionality/typing/subtyping/builtin-functions.test.ts
index 6c72235ae91..1d0dc723b40 100644
--- a/test/functionality/typing/subtyping/builtin-functions.test.ts
+++ b/test/functionality/typing/subtyping/builtin-functions.test.ts
@@ -1,5 +1,5 @@
 import { describe } from 'vitest';
-import { RTypeIntersection, RIntegerType, RLanguageType, RListType, RLogicalType, RNullType, RStringType, RTypeVariable, RAtomicVectorType, RComplexType } from '../../../../src/typing/types';
+import { RTypeIntersection, RLanguageType, RListType, RLogicalType, RNullType, RStringType, RTypeVariable, RAtomicVectorType, RDoubleType } from '../../../../src/typing/types';
 import { assertInferredType, assertInferredTypes } from '../../_helper/typing/subtyping/assert-inferred-type';
 import { Q } from '../../../../src/search/flowr-search-builder';
 
@@ -9,8 +9,8 @@ describe('Infer types for builtin functions', () => {
 	assertInferredTypes(
 		'x <- 42\nget("x")',
 		undefined,
-		{ query: Q.criterion('1@x').build(),   lowerBound: new RIntegerType(), upperBound: new RComplexType() },
-		{ query: Q.criterion('2@get').build(), lowerBound: new RIntegerType(), upperBound: new RComplexType() },
+		{ query: Q.criterion('1@x').build(),   expectedType: new RDoubleType() },
+		{ query: Q.criterion('2@get').build(), expectedType: new RDoubleType() },
 		{ query: Q.criterion('2@"x"').build(), upperBound: new RStringType() }
 	);
 
@@ -21,8 +21,8 @@ describe('Infer types for builtin functions', () => {
 		{ query: Q.criterion('1@quote').build(), expectedType: new RLanguageType() },
 		{ query: Q.criterion('1@TRUE').build(),  expectedType: new RLogicalType() }
 	);
-	
-	const elementType = new RTypeVariable(new RIntegerType(), new RTypeIntersection());
+
+	const elementType = new RTypeVariable(new RDoubleType(), new RTypeIntersection());
 	assertInferredType('list(1, 2, 3)', { expectedType: new RListType(elementType, new Map([[0, elementType], [1, elementType], [2, elementType]])) });
 
 	assertInferredTypes(
diff --git a/test/functionality/typing/subtyping/constants.test.ts b/test/functionality/typing/subtyping/constants.test.ts
index 83eb19f504f..4a113bf6a5b 100644
--- a/test/functionality/typing/subtyping/constants.test.ts
+++ b/test/functionality/typing/subtyping/constants.test.ts
@@ -7,9 +7,9 @@ describe('Infer types for constants', () => {
 		{ description: 'logical constant',        input: 'TRUE',            expectedType: new RLogicalType() },
 		{ description: 'logical constant',        input: 'FALSE',           expectedType: new RLogicalType() },
 		{ description: 'null constant',           input: 'NULL',            expectedType: new RNullType() },
-		{ description: 'integer constant',        input: '42',              lowerBound: new RIntegerType(), upperBound: new RComplexType() },
+		{ description: 'integer constant',        input: '42',              expectedType: new RDoubleType() },
 		{ description: 'integer constant',        input: '42L',             expectedType: new RIntegerType() },
-		{ description: 'double constant',         input: '42.5',            lowerBound: new RDoubleType(), upperBound: new RComplexType() },
+		{ description: 'double constant',         input: '42.5',            expectedType: new RDoubleType() },
 		{ description: 'complex number constant', input: '42i',             expectedType: new RComplexType() },
 		{ description: 'string constant',         input: '"Hello, world!"', expectedType: new RStringType() },
 		{ description: 'empty expression list',   input: '{}',              expectedType: new RNullType() }
diff --git a/test/functionality/typing/subtyping/replacement.test.ts b/test/functionality/typing/subtyping/replacement.test.ts
index 6b1561e44ff..80dc12506cc 100644
--- a/test/functionality/typing/subtyping/replacement.test.ts
+++ b/test/functionality/typing/subtyping/replacement.test.ts
@@ -1,6 +1,6 @@
 import { describe, expect, test } from 'vitest';
 import type { DataType } from '../../../../src/typing/types';
-import { RTypeIntersection, RAtomicVectorType, RIntegerType, RListType, RTypeVariable, RTypeUnion, RNullType, RLogicalType, RComplexType, RDoubleType, RS4Type } from '../../../../src/typing/types';
+import { RTypeIntersection, RAtomicVectorType, RListType, RTypeVariable, RTypeUnion, RNullType, RLogicalType, RComplexType, RDoubleType, RS4Type } from '../../../../src/typing/types';
 import { assertInferredTypes } from '../../_helper/typing/subtyping/assert-inferred-type';
 import { Q } from '../../../../src/search/flowr-search-builder';
 
@@ -10,22 +10,22 @@ describe('Infer types for subsetting expressions', () => {
 	assertInferredTypes(
 		'v <- c(1, 2, 3); v[2] <- y; v',
 		undefined,
-		{ query: Q.var('v').first().build(),          expectedType: new RAtomicVectorType(new RTypeVariable(new RIntegerType(), new RTypeIntersection())) },
-		{ query: Q.var('v').last().build(),           expectedType: new RAtomicVectorType(new RTypeVariable(new RIntegerType(), new RTypeIntersection())) },
+		{ query: Q.var('v').first().build(),          expectedType: new RAtomicVectorType(new RTypeVariable(new RDoubleType(), new RTypeIntersection())) },
+		{ query: Q.var('v').last().build(),           expectedType: new RAtomicVectorType(new RTypeVariable(new RDoubleType(), new RTypeIntersection())) },
 		{ query: Q.var('y').last().build(),           upperBound: new RTypeUnion(new RAtomicVectorType(new RTypeIntersection()), new RListType(new RTypeIntersection())) },
 		{ query: Q.criterion('1@[').last().build(),   upperBound: new RTypeUnion(new RAtomicVectorType(new RTypeIntersection()), new RListType(new RTypeIntersection())) },
-		{ query: Q.criterion('1@<-').first().build(), expectedType: new RAtomicVectorType(new RTypeVariable(new RIntegerType(), new RTypeIntersection())) },
+		{ query: Q.criterion('1@<-').first().build(), expectedType: new RAtomicVectorType(new RTypeVariable(new RDoubleType(), new RTypeIntersection())) },
 	);
 	
 	assertInferredTypes(
 		'v <- c(1, 2, 3); y <- 1; v[2] <- y; v',
 		undefined,
-		{ query: Q.var('v').last().build(),         expectedType: new RAtomicVectorType(new RTypeVariable(new RIntegerType(), new RTypeIntersection())) },
-		{ query: Q.var('y').last().build(),         lowerBound: new RIntegerType(), upperBound: new RComplexType() },
-		{ query: Q.criterion('1@[').last().build(), lowerBound: new RIntegerType(), upperBound: new RComplexType() },
+		{ query: Q.var('v').last().build(),         expectedType: new RAtomicVectorType(new RTypeVariable(new RDoubleType(), new RTypeIntersection())) },
+		{ query: Q.var('y').last().build(),         expectedType: new RDoubleType() },
+		{ query: Q.criterion('1@[').last().build(), expectedType: new RDoubleType() },
 	);
 	
-	const elementType1 = new RTypeVariable(new RIntegerType(), new RTypeIntersection());
+	const elementType1 = new RTypeVariable(new RDoubleType(), new RTypeIntersection());
 	assertInferredTypes(
 		'l <- list(1, 2, 3); l[2] <- y; l',
 		undefined,
@@ -37,12 +37,12 @@ describe('Infer types for subsetting expressions', () => {
 	assertInferredTypes(
 		'v <- c(1, 2, 3); v[] <- y; v',
 		undefined,
-		{ query: Q.var('v').last().build(),         expectedType: new RAtomicVectorType(new RTypeVariable(new RIntegerType(), new RTypeIntersection())) },
+		{ query: Q.var('v').last().build(),         expectedType: new RAtomicVectorType(new RTypeVariable(new RDoubleType(), new RTypeIntersection())) },
 		{ query: Q.var('y').last().build(),         upperBound: new RTypeUnion(new RAtomicVectorType(new RTypeIntersection()), new RListType(new RTypeIntersection())) },
 		{ query: Q.criterion('1@[').last().build(), upperBound: new RTypeUnion(new RAtomicVectorType(new RTypeIntersection()), new RListType(new RTypeIntersection())) },
 	);
 	
-	const elementType2 = new RTypeVariable(new RIntegerType(), new RTypeIntersection());
+	const elementType2 = new RTypeVariable(new RDoubleType(), new RTypeIntersection());
 	assertInferredTypes(
 		'l <- list(1, 2, 3); l[] <- y; l',
 		undefined,
@@ -54,12 +54,12 @@ describe('Infer types for subsetting expressions', () => {
 	assertInferredTypes(
 		'v <- c(1, 2, 3); v[[2]] <- y; v',
 		undefined,
-		{ query: Q.var('v').last().build(),          expectedType: new RAtomicVectorType(new RTypeVariable(new RIntegerType(), new RTypeIntersection())) },
+		{ query: Q.var('v').last().build(),          expectedType: new RAtomicVectorType(new RTypeVariable(new RDoubleType(), new RTypeIntersection())) },
 		{ query: Q.var('y').last().build(),          upperBound: new RTypeIntersection() },
 		{ query: Q.criterion('1@[[').last().build(), expectedType: new RTypeVariable() },
 	);
 	
-	const elementType3 = new RTypeVariable(new RIntegerType(), new RTypeIntersection());
+	const elementType3 = new RTypeVariable(new RDoubleType(), new RTypeIntersection());
 	assertInferredTypes(
 		'l <- list(1, 2, 3); l[[2]] <- y; l',
 		undefined,
@@ -68,7 +68,7 @@ describe('Infer types for subsetting expressions', () => {
 		{ query: Q.criterion('1@[[').last().build(), expectedType: new RTypeVariable() },
 	);
 	
-	const elementType4 = new RTypeVariable(new RIntegerType(), new RTypeIntersection());
+	const elementType4 = new RTypeVariable(new RDoubleType(), new RTypeIntersection());
 	assertInferredTypes(
 		'l <- list(1, x = 2, 3); l$x <- y; l',
 		undefined,
@@ -77,7 +77,7 @@ describe('Infer types for subsetting expressions', () => {
 		{ query: Q.criterion('1@$').last().build(), expectedType: new RTypeVariable() },
 	);
 	
-	const elementType5 = new RTypeVariable(new RIntegerType(), new RTypeIntersection());
+	const elementType5 = new RTypeVariable(new RDoubleType(), new RTypeIntersection());
 	assertInferredTypes(
 		'l <- list(1, 2, 3); l$a <- y; l',
 		undefined,
@@ -86,11 +86,11 @@ describe('Infer types for subsetting expressions', () => {
 		{ query: Q.criterion('1@$').last().build(), expectedType: new RTypeVariable() },
 	);
 	
-	const elementType6 = new RTypeVariable(new RAtomicVectorType(new RIntegerType()), new RTypeIntersection());
+	const elementType6 = new RTypeVariable(new RAtomicVectorType(new RDoubleType()), new RTypeIntersection());
 	// eslint-disable-next-line @typescript-eslint/naming-convention
 	const elementType6_0 = new RTypeVariable(new RLogicalType(), new RTypeIntersection());
 	// eslint-disable-next-line @typescript-eslint/naming-convention
-	const elementType6_1 = new RTypeVariable(new RIntegerType(), new RTypeIntersection());
+	const elementType6_1 = new RTypeVariable(new RDoubleType(), new RTypeIntersection());
 	// eslint-disable-next-line @typescript-eslint/naming-convention
 	const elementType6_2 = new RTypeVariable(new RNullType(), new RTypeIntersection());
 	assertInferredTypes(
@@ -104,16 +104,16 @@ describe('Infer types for subsetting expressions', () => {
 	assertInferredTypes(
 		'v <- 1; v[[1]] <- y; v',
 		undefined,
-		{ query: Q.var('v').last().build(),          expectedType: new RTypeVariable(new RIntegerType(), new RAtomicVectorType(new RTypeIntersection())) },
+		{ query: Q.var('v').last().build(),          expectedType: new RTypeVariable(new RDoubleType(), new RAtomicVectorType(new RTypeIntersection())) },
 		{ query: Q.var('y').last().build(),          expectedType: new RTypeVariable() },
 		{ query: Q.criterion('1@[[').last().build(), expectedType: new RTypeVariable() },
 	);
 	
 	assertInferredTypes(
-		'v <- 1; v[[1]] <- 1.2; v',
+		'v <- 1; v[[1]] <- 1i; v',
 		undefined,
-		{ query: Q.var('v').last().build(),          expectedType: new RTypeVariable(new RIntegerType(), new RAtomicVectorType(new RTypeIntersection())) },
-		{ query: Q.criterion('1@[[').last().build(), lowerBound: new RDoubleType(), upperBound: new RComplexType() },
+		{ query: Q.var('v').last().build(),          expectedType: new RTypeVariable(new RDoubleType(), new RAtomicVectorType(new RTypeIntersection())) },
+		{ query: Q.criterion('1@[[').last().build(), expectedType: new RComplexType() },
 	);
 	
 	assertInferredTypes(
diff --git a/test/functionality/typing/subtyping/subsetting.test.ts b/test/functionality/typing/subtyping/subsetting.test.ts
index 613b53ecd09..5a05f341f0e 100644
--- a/test/functionality/typing/subtyping/subsetting.test.ts
+++ b/test/functionality/typing/subtyping/subsetting.test.ts
@@ -1,6 +1,6 @@
 import { describe } from 'vitest';
 import type { DataType } from '../../../../src/typing/types';
-import { RTypeIntersection, RAtomicVectorType, RIntegerType, RListType, RTypeVariable, RNullType, RLogicalType, RComplexType, RS4Type } from '../../../../src/typing/types';
+import { RTypeIntersection, RAtomicVectorType, RListType, RTypeVariable, RNullType, RLogicalType, RS4Type, RDoubleType } from '../../../../src/typing/types';
 import { assertInferredTypes } from '../../_helper/typing/subtyping/assert-inferred-type';
 import { Q } from '../../../../src/search/flowr-search-builder';
 import { RType } from '../../../../src/r-bridge/lang-4.x/ast/model/type';
@@ -9,83 +9,83 @@ describe('Infer types for subsetting expressions', () => {
 	assertInferredTypes(
 		'v <- c(1, 2, 3); v[2]',
 		undefined,
-		{ query: Q.var('v').last().build(),                    expectedType: new RAtomicVectorType(new RTypeVariable(new RIntegerType(), new RTypeIntersection())) },
-		{ query: Q.all().filter(RType.Access).first().build(), lowerBound: new RAtomicVectorType(new RIntegerType()) },
+		{ query: Q.var('v').last().build(),                    expectedType: new RAtomicVectorType(new RTypeVariable(new RDoubleType(), new RTypeIntersection())) },
+		{ query: Q.all().filter(RType.Access).first().build(), lowerBound: new RAtomicVectorType(new RDoubleType()) },
 	);
 	
-	const elementType1 = new RTypeVariable(new RIntegerType(), new RTypeIntersection());
+	const elementType1 = new RTypeVariable(new RDoubleType(), new RTypeIntersection());
 	assertInferredTypes(
 		'l <- list(1, 2, 3); l[2]',
 		undefined,
 		{ query: Q.var('l').last().build(),                    expectedType: new RListType(elementType1, new Map([[0, elementType1], [1, elementType1], [2, elementType1]])) },
-		{ query: Q.all().filter(RType.Access).first().build(), lowerBound: new RListType(new RIntegerType(), new Map([[0, new RIntegerType()], [1, new RIntegerType()], [2, new RIntegerType()]])) },
+		{ query: Q.all().filter(RType.Access).first().build(), lowerBound: new RListType(new RDoubleType(), new Map([[0, new RDoubleType()], [1, new RDoubleType()], [2, new RDoubleType()]])) },
 	);
 	
 	assertInferredTypes(
 		'v <- c(1, 2, 3); v[]',
 		undefined,
-		{ query: Q.var('v').last().build(),                    expectedType: new RAtomicVectorType(new RTypeVariable(new RIntegerType(), new RTypeIntersection())) },
-		{ query: Q.all().filter(RType.Access).first().build(), lowerBound: new RAtomicVectorType(new RIntegerType()) },
+		{ query: Q.var('v').last().build(),                    expectedType: new RAtomicVectorType(new RTypeVariable(new RDoubleType(), new RTypeIntersection())) },
+		{ query: Q.all().filter(RType.Access).first().build(), lowerBound: new RAtomicVectorType(new RDoubleType()) },
 	);
 	
-	const elementType2 = new RTypeVariable(new RIntegerType(), new RTypeIntersection());
+	const elementType2 = new RTypeVariable(new RDoubleType(), new RTypeIntersection());
 	assertInferredTypes(
 		'l <- list(1, 2, 3); l[]',
 		undefined,
 		{ query: Q.var('l').last().build(),                    expectedType: new RListType(elementType2, new Map([[0, elementType2], [1, elementType2], [2, elementType2]])) },
-		{ query: Q.all().filter(RType.Access).first().build(), lowerBound: new RListType(new RIntegerType(), new Map([[0, new RIntegerType()], [1, new RIntegerType()], [2, new RIntegerType()]])) },
+		{ query: Q.all().filter(RType.Access).first().build(), lowerBound: new RListType(new RDoubleType(), new Map([[0, new RDoubleType()], [1, new RDoubleType()], [2, new RDoubleType()]])) },
 	);
 	
 	assertInferredTypes(
 		'v <- c(1, 2, 3); v[[2]]',
 		undefined,
-		{ query: Q.var('v').last().build(),                    expectedType: new RAtomicVectorType(new RTypeVariable(new RIntegerType(), new RTypeIntersection())) },
-		{ query: Q.all().filter(RType.Access).first().build(), lowerBound: new RIntegerType() },
+		{ query: Q.var('v').last().build(),                    expectedType: new RAtomicVectorType(new RTypeVariable(new RDoubleType(), new RTypeIntersection())) },
+		{ query: Q.all().filter(RType.Access).first().build(), lowerBound: new RDoubleType() },
 	);
 	
-	const elementType3 = new RTypeVariable(new RIntegerType(), new RTypeIntersection());
+	const elementType3 = new RTypeVariable(new RDoubleType(), new RTypeIntersection());
 	assertInferredTypes(
 		'l <- list(1, 2, 3); l[[2]]',
 		undefined,
 		{ query: Q.var('l').last().build(),                    expectedType: new RListType(elementType1, new Map([[0, elementType3], [1, elementType3], [2, elementType3]])) },
-		{ query: Q.all().filter(RType.Access).first().build(), lowerBound: new RIntegerType() },
+		{ query: Q.all().filter(RType.Access).first().build(), lowerBound: new RDoubleType() },
 	);
 	
-	const elementType4 = new RTypeVariable(new RIntegerType(), new RTypeIntersection());
+	const elementType4 = new RTypeVariable(new RDoubleType(), new RTypeIntersection());
 	assertInferredTypes(
 		'l <- list(1, x = 2, 3); l$x',
 		undefined,
 		{ query: Q.var('l').last().build(),                    expectedType: new RListType(elementType4, new Map<number | string, DataType>([[0, elementType4], [1, elementType4], [2, elementType4], ['x', elementType4]])) },
-		{ query: Q.all().filter(RType.Access).first().build(), lowerBound: new RIntegerType() },
+		{ query: Q.all().filter(RType.Access).first().build(), lowerBound: new RDoubleType() },
 	);
 	
-	const elementType5 = new RTypeVariable(new RIntegerType(), new RTypeIntersection());
+	const elementType5 = new RTypeVariable(new RDoubleType(), new RTypeIntersection());
 	assertInferredTypes(
 		'l <- list(1, 2, 3); l$a',
 		undefined,
 		{ query: Q.var('l').last().build(),                    expectedType: new RListType(elementType5, new Map([[0, elementType5], [1, elementType5], [2, elementType5]])) },
-		{ query: Q.all().filter(RType.Access).first().build(), lowerBound: new RIntegerType() },
+		{ query: Q.all().filter(RType.Access).first().build(), lowerBound: new RDoubleType() },
 	);
 	
-	const elementType6 = new RTypeVariable(new RAtomicVectorType(new RIntegerType()), new RTypeIntersection());
+	const elementType6 = new RTypeVariable(new RAtomicVectorType(new RDoubleType()), new RTypeIntersection());
 	// eslint-disable-next-line @typescript-eslint/naming-convention
 	const elementType6_0 = new RTypeVariable(new RLogicalType(), new RTypeIntersection());
 	// eslint-disable-next-line @typescript-eslint/naming-convention
-	const elementType6_1 = new RTypeVariable(new RIntegerType(), new RTypeIntersection());
+	const elementType6_1 = new RTypeVariable(new RDoubleType(), new RTypeIntersection());
 	// eslint-disable-next-line @typescript-eslint/naming-convention
 	const elementType6_2 = new RTypeVariable(new RNullType(), new RTypeIntersection());
 	assertInferredTypes(
 		'l <- list(TRUE, a = 42, NULL); l$a',
 		undefined,
 		{ query: Q.var('l').last().build(),                    expectedType: new RListType(elementType6, new Map<number | string, DataType>([[0, elementType6_0], [1, elementType6_1], [2, elementType6_2], ['a', elementType6_1]])) },
-		{ query: Q.all().filter(RType.Access).first().build(), lowerBound: new RAtomicVectorType(new RIntegerType()), upperBound: new RTypeIntersection() },
+		{ query: Q.all().filter(RType.Access).first().build(), lowerBound: new RAtomicVectorType(new RDoubleType()), upperBound: new RTypeIntersection() },
 	);
 
 	assertInferredTypes(
 		'v <- 1; v[[1]]',
 		undefined,
-		{ query: Q.var('v').last().build(),                    lowerBound: new RIntegerType(), upperBound: new RComplexType() },
-		{ query: Q.all().filter(RType.Access).first().build(), lowerBound: new RIntegerType() },
+		{ query: Q.var('v').last().build(),                    expectedType: new RDoubleType() },
+		{ query: Q.all().filter(RType.Access).first().build(), lowerBound: new RDoubleType() },
 	);
 
 	assertInferredTypes(
diff --git a/test/functionality/typing/subtyping/variables.test.ts b/test/functionality/typing/subtyping/variables.test.ts
index a3d2fdbbc55..e9bf3d91b64 100644
--- a/test/functionality/typing/subtyping/variables.test.ts
+++ b/test/functionality/typing/subtyping/variables.test.ts
@@ -1,5 +1,5 @@
 import { describe } from 'vitest';
-import { RComplexType, RIntegerType } from '../../../../src/typing/types';
+import { RDoubleType } from '../../../../src/typing/types';
 import { assertInferredTypes } from '../../_helper/typing/subtyping/assert-inferred-type';
 import { Q } from '../../../../src/search/flowr-search-builder';
 
@@ -7,8 +7,8 @@ describe('Infer types for variables', () => {
 	assertInferredTypes(
 		'x <- 42; x',
 		undefined,
-		{ query: Q.var('x').first().build(),  lowerBound: new RIntegerType(), upperBound: new RComplexType() },
-		{ query: Q.criterion('1@<-').build(), lowerBound: new RIntegerType(), upperBound: new RComplexType() },
-		{ query: Q.var('x').last().build(),   lowerBound: new RIntegerType(), upperBound: new RComplexType() },
+		{ query: Q.var('x').first().build(),  expectedType: new RDoubleType() },
+		{ query: Q.criterion('1@<-').build(), expectedType: new RDoubleType() },
+		{ query: Q.var('x').last().build(),   expectedType: new RDoubleType() },
 	);
 });
\ No newline at end of file

From 30bc9e8fd292f2b3da43f0433248c47aaf09d464 Mon Sep 17 00:00:00 2001
From: Lukas Rohde <lukas.rohde@silupe.de>
Date: Sun, 10 Aug 2025 18:13:18 +0200
Subject: [PATCH 138/153] feat(typing): rework rules for NULL, vectors, and
 subsetting/replacement

---
 src/typing/subtyping/infer.ts                 | 95 ++++++++++++-------
 src/typing/subtyping/types.ts                 | 51 ++++++----
 .../subtyping/contextual-inference.test.ts    |  4 +-
 .../typing/subtyping/replacement.test.ts      | 24 ++---
 .../typing/subtyping/resolve.test.ts          |  4 +-
 .../typing/subtyping/subsetting.test.ts       | 14 +--
 6 files changed, 113 insertions(+), 79 deletions(-)

diff --git a/src/typing/subtyping/infer.ts b/src/typing/subtyping/infer.ts
index 1de17506b6d..7faf778bbfa 100644
--- a/src/typing/subtyping/infer.ts
+++ b/src/typing/subtyping/infer.ts
@@ -9,7 +9,7 @@ import type { RString } from '../../r-bridge/lang-4.x/ast/model/nodes/r-string';
 import type { NormalizedAst, ParentInformation } from '../../r-bridge/lang-4.x/ast/model/processing/decorate';
 import { mapNormalizedAstInfo } from '../../r-bridge/lang-4.x/ast/model/processing/decorate';
 import type { DataTypeInfo } from '../types';
-import { RComplexType, RDoubleType, RIntegerType, RLogicalType, RStringType, RNullType, RLanguageType, RS4Type } from '../types';
+import { RComplexType, RDoubleType, RIntegerType, RLogicalType, RStringType, RNullType, RLanguageType, RS4Type, REnvironmentType } from '../types';
 import type { RExpressionList } from '../../r-bridge/lang-4.x/ast/model/nodes/r-expression-list';
 import { guard } from '../../util/assert';
 import { OriginType } from '../../dataflow/origin/dfg-get-origin';
@@ -208,11 +208,9 @@ class TypeInferringCfgGuidedVisitor<
 			guard(argNode !== undefined, 'Expected argument node to be defined');
 
 			if(arg.name !== undefined) {
-				// constrain(argNode.info.typeVariable, getParameterTypeFromFunction(templateFunctionType, arg.name), this.constraintCache);
-				constrain(getParameterTypeFromFunction(templateFunctionType, arg.name), argNode.info.typeVariable, this.constraintCache);
+				constrain(argNode.info.typeVariable, getParameterTypeFromFunction(templateFunctionType, arg.name), this.constraintCache);
 			} else {
-				// constrain(argNode.info.typeVariable, getParameterTypeFromFunction(templateFunctionType, index), this.constraintCache);
-				constrain(getParameterTypeFromFunction(templateFunctionType, index), argNode.info.typeVariable, this.constraintCache);
+				constrain(argNode.info.typeVariable, getParameterTypeFromFunction(templateFunctionType, index), this.constraintCache);
 			}
 		}
 		constrain(calledFunctionType, templateFunctionType, this.constraintCache);
@@ -356,34 +354,35 @@ class TypeInferringCfgGuidedVisitor<
 		const listType = new UnresolvedRListType();
 		this.constrainNodeType(data.call.id, listType);
 
-		for(const [index, arg] of data.call.args.entries()) {
-			if(arg === EmptyArgument) {
-				continue; // Skip empty arguments
-			}
-
-			this.constrainNodeType(arg.nodeId, { upperBound: getIndexedElementTypeFromList(listType, index, this.constraintCache) });
+		for(const [index, arg] of data.call.args.filter((arg) => arg !== EmptyArgument).entries()) {
+			const argNode = this.getNormalizedAst(arg.nodeId);
+			guard(argNode !== undefined, 'Expected argument node to be defined');
+			
+			this.constrainNodeType(argNode, { upperBound: getIndexedElementTypeFromList(listType, index, this.constraintCache) });
 
 			if(arg.name !== undefined) {
-				this.constrainNodeType(arg.nodeId, { upperBound: getIndexedElementTypeFromList(listType, arg.name, this.constraintCache) });
+				this.constrainNodeType(argNode, { upperBound: getIndexedElementTypeFromList(listType, arg.name, this.constraintCache) });
 			}
 		}
 	}
 
 	override onVectorCall(data: { call: DataflowGraphVertexFunctionCall }) {
-		const args = data.call.args.filter((arg) => arg !== EmptyArgument);
-		if(args.length === 0) {
-			this.constrainNodeType(data.call.id, new RNullType());
-			return;
-		}
+		const lowerBounds = new Set<UnresolvedDataType>();
 		
 		const vectorType = new UnresolvedRAtomicVectorType();
 		this.constrainNodeType(data.call.id, vectorType);
 
-		for(const arg of args) {
+		for(const arg of data.call.args.filter((arg) => arg !== EmptyArgument)) {
 			const argNode = this.getNormalizedAst(arg.nodeId);
 			guard(argNode !== undefined, 'Expected argument node to be defined');
+
 			this.constrainNodeType(argNode, { upperBound: vectorType });
+			lowerBounds.add(argNode.info.typeVariable);
 		}
+
+		// eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+		const upperBound = lowerBounds.size === 1 ? lowerBounds.values().next().value! : new UnresolvedRTypeUnion(...lowerBounds);
+		constrain(vectorType, upperBound, this.constraintCache);
 	}
 
 	override onFunctionDefinition(data: { vertex: DataflowGraphVertexFunctionDefinition }): void {
@@ -453,33 +452,59 @@ class TypeInferringCfgGuidedVisitor<
 		const firstArgNode = this.getNormalizedAst(firstArg.nodeId);
 		guard(firstArgNode !== undefined, 'Expected first argument node to be defined');
 
+		const accessFunction = new UnresolvedRTypeVariable();
+		const overloads = new UnresolvedRTypeIntersection();
+		const templateFunction = new UnresolvedRFunctionType();
+
 		switch(data.call.name) {
-			case '[': { // If the access call is a `[` operation, we can assume that it returns a subset of the first argument's elements as another instance of the same vector type
-				const vectorType = new UnresolvedRTypeUnion(new UnresolvedRAtomicVectorType(), new UnresolvedRListType());
-				this.constrainNodeType(firstArgNode, { upperBound: vectorType });
-				this.constrainNodeType(data.call.id, { lowerBound: firstArgNode.info.typeVariable });
+			case '[': {
+				if(data.call.args.at(1) === undefined || data.call.args.at(1) === EmptyArgument) {
+					overloads.types = new Set([new UnresolvedRFunctionType(new Map([[0, firstArgNode.info.typeVariable]]), firstArgNode.info.typeVariable)]);
+					break;
+				}
+				const vectorSignature = new UnresolvedRFunctionType(new Map([[0, new UnresolvedRTypeVariable(undefined, [new UnresolvedRAtomicVectorType()])]]), new UnresolvedRTypeVariable([new UnresolvedRAtomicVectorType()], undefined));
+				const listSignature = new UnresolvedRFunctionType(new Map([[0, new UnresolvedRTypeVariable(undefined, [new UnresolvedRListType()])]]), new UnresolvedRTypeVariable([new UnresolvedRListType()], undefined));
+				const nullSignature = new UnresolvedRFunctionType(new Map([[0, new UnresolvedRTypeVariable(undefined, [new RNullType()])]]), new UnresolvedRTypeVariable([new RNullType()], undefined));
+				overloads.types = new Set([vectorSignature, listSignature, nullSignature]);
 				break;
 			}
-			
-			case '[[': { // If the access call is a `[[` operation, we can assume that the first argument is a container type and that it returns one of its elements
+			case '[[': {
 				const elementType = new UnresolvedRTypeVariable();
-				const vectorType = new UnresolvedRTypeUnion(new UnresolvedRAtomicVectorType(elementType), new UnresolvedRListType(elementType));
-				this.constrainNodeType(firstArgNode, { upperBound: vectorType });
-				this.constrainNodeType(data.call.id, { lowerBound: elementType });
+				const vectorSignature = new UnresolvedRFunctionType(new Map([[0, new UnresolvedRTypeVariable(undefined, [new UnresolvedRAtomicVectorType(elementType)])]]), elementType);
+				const listSignature = new UnresolvedRFunctionType(new Map([[0, new UnresolvedRTypeVariable(undefined, [new UnresolvedRListType(elementType)])]]), elementType);
+				const nullSignature = new UnresolvedRFunctionType(new Map([[0, new UnresolvedRTypeVariable(undefined, [new RNullType()])]]), new UnresolvedRTypeVariable([new RNullType()], undefined));
+				const environmentSignature = new UnresolvedRFunctionType(new Map([[0, new UnresolvedRTypeVariable(undefined, [new REnvironmentType()])]]), new UnresolvedRTypeVariable());
+				overloads.types = new Set([vectorSignature, listSignature, nullSignature, environmentSignature]);
 				break;
 			}
 			case '$': {
+				const indexArg = data.call.args.at(1);
+				guard(indexArg !== undefined && indexArg !== EmptyArgument, 'Expected index argument to be defined');
+				const indexNode = this.getNormalizedAst(indexArg.nodeId);
+				guard(indexNode !== undefined && indexNode.type === RType.Symbol, 'Expected index node to be defined and of type Symbol');
+				const index = indexNode.content;
 				const elementType = new UnresolvedRTypeVariable();
-				this.constrainNodeType(firstArgNode, { upperBound: new UnresolvedRListType(elementType) });
-				this.constrainNodeType(data.call.id, { lowerBound: elementType });
+				const listSignature = new UnresolvedRFunctionType(new Map([[0, new UnresolvedRTypeVariable(undefined, [new UnresolvedRListType(undefined, new Map([[index, elementType]]))])]]), elementType);
+				const nullSignature = new UnresolvedRFunctionType(new Map([[0, new UnresolvedRTypeVariable(undefined, [new RNullType()])]]), new UnresolvedRTypeVariable([new RNullType()], undefined));
+				const environmentSignature = new UnresolvedRFunctionType(new Map([[0, new UnresolvedRTypeVariable(undefined, [new REnvironmentType()])]]), new UnresolvedRTypeVariable());
+				overloads.types = new Set([listSignature, nullSignature, environmentSignature]);
 				break;
 			}
 			case '@': {
 				// The target of the access call must be an S4 object but we can not make any assumptions about its slots
-				this.constrainNodeType(firstArgNode, { upperBound: new RS4Type() });
+				const signature = new UnresolvedRFunctionType(new Map([[0, new UnresolvedRTypeVariable(undefined, [new RS4Type()])]]), new UnresolvedRTypeVariable());
+				overloads.types = new Set([signature]);
 				break;
 			}
 		}
+
+		constrain(firstArgNode.info.typeVariable, getParameterTypeFromFunction(templateFunction, 0), this.constraintCache);
+		this.constrainNodeType(data.call.id, templateFunction.returnType);
+		
+		constrain(overloads, accessFunction, this.constraintCache);
+		constrain(accessFunction, templateFunction, this.constraintCache);
+
+		this.orphanTypes.add(accessFunction);
 	}
 
 	protected override onReplacementCall(data: { call: DataflowGraphVertexFunctionCall; source: NodeId | undefined; target: NodeId | undefined; }): void {
@@ -496,16 +521,16 @@ class TypeInferringCfgGuidedVisitor<
 
 		switch(data.call.name) {
 			case '[<-': {
-				this.constrainNodeType(targetNode, { upperBound: new UnresolvedRTypeUnion(new UnresolvedRAtomicVectorType(), new UnresolvedRListType()) });
-				this.constrainNodeType(sourceNode, { upperBound: new UnresolvedRTypeUnion(new UnresolvedRAtomicVectorType(), new UnresolvedRListType()) });
+				this.constrainNodeType(targetNode, { upperBound: new UnresolvedRTypeUnion(new RNullType(), new UnresolvedRAtomicVectorType(), new UnresolvedRListType()) });
+				this.constrainNodeType(sourceNode, { upperBound: new UnresolvedRTypeUnion(new RNullType(), new UnresolvedRAtomicVectorType(), new UnresolvedRListType()) });
 				break;
 			}
 			case '[[<-': {
-				this.constrainNodeType(targetNode, { upperBound: new UnresolvedRTypeUnion(new UnresolvedRAtomicVectorType(), new UnresolvedRListType()) });
+				this.constrainNodeType(targetNode, { upperBound: new UnresolvedRTypeUnion(new RNullType(), new UnresolvedRAtomicVectorType(), new UnresolvedRListType(), new REnvironmentType()) });
 				break;
 			}
 			case '$<-': {
-				this.constrainNodeType(targetNode, { upperBound: new UnresolvedRListType() });
+				this.constrainNodeType(targetNode, { upperBound: new UnresolvedRTypeUnion(new RNullType(), new UnresolvedRListType(), new REnvironmentType()) });
 				break;
 			}
 			case '@<-': {
@@ -518,8 +543,6 @@ class TypeInferringCfgGuidedVisitor<
 	protected onVisitorEnd(): void {
 		// Resolve types that are not directly constrained by a node type
 		for(const type of this.orphanTypes) {
-			// console.debug('Resolved orphan type:');
-			// console.dir(resolve(type), { depth: null, colors: true });
 			resolve(type);
 		}
 	}
diff --git a/src/typing/subtyping/types.ts b/src/typing/subtyping/types.ts
index 151c6ba87d4..0619c35ad6f 100644
--- a/src/typing/subtyping/types.ts
+++ b/src/typing/subtyping/types.ts
@@ -1,6 +1,6 @@
 import { guard } from '../../util/assert';
 import type { SimpleType, DataType } from '../types';
-import { RNullType , DataTypeTag, isAtomicVectorBaseType, RAtomicVectorType, RFunctionType, RListType, RTypeError, RTypeIntersection, RTypeUnion, RTypeVariable } from '../types';
+import { DataTypeTag, isAtomicVectorBaseType, RAtomicVectorType, RFunctionType, RListType, RTypeError, RTypeIntersection, RTypeUnion, RTypeVariable } from '../types';
 
 // let idCounter = 0;
 
@@ -97,8 +97,13 @@ export class UnresolvedRTypeIntersection {
 export class UnresolvedRTypeVariable {
 	readonly tag = DataTypeTag.Variable;
 	// readonly id = idCounter++;
-	readonly lowerBound = new UnresolvedRTypeUnion();
-	readonly upperBound = new UnresolvedRTypeIntersection();
+	readonly lowerBound: UnresolvedRTypeUnion;
+	readonly upperBound: UnresolvedRTypeIntersection;
+
+	constructor(lowerBounds: UnresolvedDataType[] = [], upperBounds: UnresolvedDataType[] = []) {
+		this.lowerBound = new UnresolvedRTypeUnion(...lowerBounds);
+		this.upperBound = new UnresolvedRTypeIntersection(...upperBounds);
+	}
 }
 
 
@@ -140,7 +145,7 @@ export function constrain(subtype: UnresolvedDataType, supertype: UnresolvedData
 	} else if(subtype instanceof UnresolvedRFunctionType && supertype instanceof UnresolvedRFunctionType) {
 		const subtypeParameterKeys = new Set(subtype.parameterTypes.keys());
 		const supertypeParameterKeys = new Set(supertype.parameterTypes.keys());
-		for(const key of subtypeParameterKeys.union(supertypeParameterKeys)) {
+		for(const key of subtypeParameterKeys.intersection(supertypeParameterKeys)) {
 			constrain(getParameterTypeFromFunction(supertype, key), getParameterTypeFromFunction(subtype, key), cache);
 		}
 		constrain(subtype.returnType, supertype.returnType, cache);
@@ -149,6 +154,11 @@ export function constrain(subtype: UnresolvedDataType, supertype: UnresolvedData
 	} else if(isAtomicVectorBaseType(subtype) && supertype instanceof UnresolvedRAtomicVectorType) {
 		constrain(subtype, supertype.elementType, cache);
 	} else if(subtype instanceof UnresolvedRListType && supertype instanceof UnresolvedRListType) {
+		const subtypeElementIndices = new Set(subtype.indexedElementTypes.keys());
+		const supertypeElementIndices = new Set(supertype.indexedElementTypes.keys());
+		for(const indexOrName of subtypeElementIndices.union(supertypeElementIndices).values()) {
+			constrain(getIndexedElementTypeFromList(subtype, indexOrName, cache), getIndexedElementTypeFromList(supertype, indexOrName, cache), cache);
+		}
 		constrain(subtype.elementType, supertype.elementType, cache);
 	}
 }
@@ -171,8 +181,10 @@ export function prune(variable: UnresolvedRTypeVariable): void {
 			}
 			for(const type of lowerBound.types) {
 				if(variable.upperBound.types.values().some(upperBound => subsumes(type, upperBound))) {
+					// console.debug('Constraining', inspect(type, { depth: null, colors: true }), 'to subsume', inspect(upperBound, { depth: null, colors: true }));
 					constrain(type, upperBound);
 				} else {
+					// console.debug('Pruning', inspect(type, { depth: null, colors: true }), 'from lower intersection', inspect(lowerBound, { depth: null, colors: true }));
 					lowerBound.types.delete(type);
 				}
 			}
@@ -363,7 +375,7 @@ export function subsumes(subtype: DataType | UnresolvedDataType, supertype: Data
 	if(subtype.tag === DataTypeTag.Error || supertype.tag === DataTypeTag.Error) {
 		result = false; // Error types do not subsume and are not subsumed by any other type
 	} else if(subtype.tag === DataTypeTag.Variable) {
-		result = subsumes(subtype.upperBound, supertype, inProcess);
+		result = subsumes(subtype.lowerBound, supertype, inProcess);
 	} else if(supertype.tag === DataTypeTag.Variable) {
 		result = subsumes(subtype, supertype.upperBound, inProcess);
 	} else if(subtype.tag === DataTypeTag.Union) {
@@ -375,12 +387,18 @@ export function subsumes(subtype: DataType | UnresolvedDataType, supertype: Data
 	} else if(subtype.tag === DataTypeTag.Intersection) {
 		result = subtype.types.values().some(subtype => subsumes(subtype, supertype, inProcess));
 	} else if(subtype.tag === DataTypeTag.List && supertype.tag === DataTypeTag.List) {
-		result = subsumes(subtype.elementType, supertype.elementType, inProcess);
+		const subtypeElementIndices = new Set(subtype.indexedElementTypes.keys());
+		const supertypeElementIndices = new Set(supertype.indexedElementTypes.keys());
+		result = subsumes(subtype.elementType, supertype.elementType, inProcess) && subtypeElementIndices.union(supertypeElementIndices).values().every(indexOrName => {
+			return subsumes(subtype.indexedElementTypes.get(indexOrName) ?? new RTypeVariable(), supertype.indexedElementTypes.get(indexOrName) ?? new RTypeVariable(), inProcess);
+		});
 	} else if(subtype.tag === DataTypeTag.AtomicVector && supertype.tag === DataTypeTag.AtomicVector) {
 		result = subsumes(subtype.elementType, supertype.elementType, inProcess);
 	} else if(isAtomicVectorBaseType(subtype) && supertype.tag === DataTypeTag.AtomicVector) {
 		// A scalar subsumes a vector type if it subsumes the element type of the vector
 		result = subsumes(subtype, supertype.elementType, inProcess);
+	} else if(subtype.tag === DataTypeTag.AtomicVector && supertype.tag === DataTypeTag.Null) {
+		result = subsumes(subtype.elementType, new RTypeUnion());
 	} else if(subtype.tag === DataTypeTag.Function && supertype.tag === DataTypeTag.Function) {
 		const subtypeParameterKeys = new Set(subtype.parameterTypes.keys());
 		const supertypeParameterKeys = new Set(supertype.parameterTypes.keys());
@@ -395,8 +413,7 @@ export function subsumes(subtype: DataType | UnresolvedDataType, supertype: Data
 			|| subtype.tag === DataTypeTag.Logical && supertype.tag === DataTypeTag.Complex
 			|| subtype.tag === DataTypeTag.Integer && supertype.tag === DataTypeTag.Double
 			|| subtype.tag === DataTypeTag.Integer && supertype.tag === DataTypeTag.Complex
-			|| subtype.tag === DataTypeTag.Double && supertype.tag === DataTypeTag.Complex
-			|| subtype.tag === DataTypeTag.Null && supertype.tag === DataTypeTag.AtomicVector;
+			|| subtype.tag === DataTypeTag.Double && supertype.tag === DataTypeTag.Complex;
 	}
 
 	processedSupertypes?.delete(supertype); // Remove the supertype from the processed set
@@ -499,14 +516,6 @@ export function unresolvedJoin(type1: UnresolvedDataType, type2: UnresolvedDataT
 		constrain(elementType, joinedElementType);
 		// constrain(joinedElementType, elementType);
 		return new UnresolvedRAtomicVectorType(elementType);
-	} else if(type1 instanceof RNullType && isAtomicVectorBaseType(type2)) {
-		const elementType = new UnresolvedRTypeVariable();
-		constrain(elementType, type2);
-		return new UnresolvedRAtomicVectorType(elementType);
-	} else if(isAtomicVectorBaseType(type1) && type2 instanceof RNullType) {
-		const elementType = new UnresolvedRTypeVariable();
-		constrain(elementType, type1);
-		return new UnresolvedRAtomicVectorType(elementType);
 	} else if(subsumes(type1, type2)) {
 		return type2;
 	} else if(subsumes(type2, type1)) {
@@ -582,10 +591,6 @@ export function join(type1: DataType, type2: DataType): DataType {
 		return new RAtomicVectorType(join(type1, type2.elementType));
 	} else if(isAtomicVectorBaseType(type2) && type1.tag === DataTypeTag.AtomicVector) {
 		return new RAtomicVectorType(join(type2, type1.elementType));
-	} else if(type1 instanceof RNullType && isAtomicVectorBaseType(type2)) {
-		return new RAtomicVectorType(type2);
-	} else if(isAtomicVectorBaseType(type1) && type2 instanceof RNullType) {
-		return new RAtomicVectorType(type1);
 	} else if(subsumes(type1, type2)) {
 		return type2;
 	} else if(subsumes(type2, type1)) {
@@ -681,6 +686,10 @@ export function unresolvedMeet(type1: UnresolvedDataType, type2: UnresolvedDataT
 		return unresolvedMeet(type1, type2.elementType);
 	} else if(isAtomicVectorBaseType(type2) && type1.tag === DataTypeTag.AtomicVector) {
 		return unresolvedMeet(type2, type1.elementType);
+	} else if(type1.tag === DataTypeTag.AtomicVector && type2.tag === DataTypeTag.Null || type2.tag === DataTypeTag.AtomicVector && type1.tag === DataTypeTag.Null) {
+		const elementType = new UnresolvedRTypeVariable();
+		constrain(new UnresolvedRTypeUnion(), elementType);
+		return new UnresolvedRAtomicVectorType(elementType);
 	} else if(subsumes(type1, type2)) {
 		return type1;
 	} else if(subsumes(type2, type1)) {
@@ -756,6 +765,8 @@ export function meet(type1: DataType, type2: DataType): DataType {
 		return meet(type1, type2.elementType);
 	} else if(isAtomicVectorBaseType(type2) && type1.tag === DataTypeTag.AtomicVector) {
 		return meet(type2, type1.elementType);
+	} else if(type1.tag === DataTypeTag.AtomicVector && type2.tag === DataTypeTag.Null || type2.tag === DataTypeTag.AtomicVector && type1.tag === DataTypeTag.Null) {
+		return new RAtomicVectorType(new RTypeUnion());
 	} else if(subsumes(type1, type2)) {
 		return type1;
 	} else if(subsumes(type2, type1)) {
diff --git a/test/functionality/typing/subtyping/contextual-inference.test.ts b/test/functionality/typing/subtyping/contextual-inference.test.ts
index 2b019e0c36d..d0b183dc35f 100644
--- a/test/functionality/typing/subtyping/contextual-inference.test.ts
+++ b/test/functionality/typing/subtyping/contextual-inference.test.ts
@@ -1,5 +1,5 @@
 import { describe } from 'vitest';
-import { RAtomicVectorType, RComplexType, RDoubleType, RStringType, RTypeIntersection, RTypeUnion, RTypeVariable } from '../../../../src/typing/types';
+import { RAtomicVectorType, RComplexType, RDoubleType, RNullType, RStringType, RTypeIntersection, RTypeUnion, RTypeVariable } from '../../../../src/typing/types';
 import { assertInferredType } from '../../_helper/typing/subtyping/assert-inferred-type';
 import type { UnresolvedDataType } from '../../../../src/typing/subtyping/types';
 import { loadTracedTypes, loadTurcotteTypes } from '../../../../src/typing/adapter/load-type-signatures';
@@ -16,5 +16,5 @@ describe('Infer no type information for currently unsupported R expressions', as
 	await loadTracedTypes(knownTypes);
 	
 	assertInferredType('1 + 2',                  new RTypeVariable(new RAtomicVectorType(new RComplexType()), new RTypeIntersection()), knownTypes);
-	assertInferredType('print("Hello, world!")', new RTypeVariable(new RAtomicVectorType(new RTypeUnion(new RStringType(), new RDoubleType())), new RTypeIntersection()), knownTypes);
+	assertInferredType('print("Hello, world!")', new RTypeVariable(new RTypeUnion(new RAtomicVectorType(new RTypeUnion(new RStringType(), new RDoubleType())), new RNullType()), new RTypeIntersection()), knownTypes);
 });
\ No newline at end of file
diff --git a/test/functionality/typing/subtyping/replacement.test.ts b/test/functionality/typing/subtyping/replacement.test.ts
index 80dc12506cc..f6ffb4b171c 100644
--- a/test/functionality/typing/subtyping/replacement.test.ts
+++ b/test/functionality/typing/subtyping/replacement.test.ts
@@ -12,8 +12,8 @@ describe('Infer types for subsetting expressions', () => {
 		undefined,
 		{ query: Q.var('v').first().build(),          expectedType: new RAtomicVectorType(new RTypeVariable(new RDoubleType(), new RTypeIntersection())) },
 		{ query: Q.var('v').last().build(),           expectedType: new RAtomicVectorType(new RTypeVariable(new RDoubleType(), new RTypeIntersection())) },
-		{ query: Q.var('y').last().build(),           upperBound: new RTypeUnion(new RAtomicVectorType(new RTypeIntersection()), new RListType(new RTypeIntersection())) },
-		{ query: Q.criterion('1@[').last().build(),   upperBound: new RTypeUnion(new RAtomicVectorType(new RTypeIntersection()), new RListType(new RTypeIntersection())) },
+		{ query: Q.var('y').last().build(),           upperBound: new RTypeUnion(new RNullType(), new RAtomicVectorType(new RTypeIntersection()), new RListType(new RTypeIntersection())) },
+		{ query: Q.criterion('1@[').last().build(),   upperBound: new RTypeUnion(new RNullType(), new RAtomicVectorType(new RTypeIntersection()), new RListType(new RTypeIntersection())) },
 		{ query: Q.criterion('1@<-').first().build(), expectedType: new RAtomicVectorType(new RTypeVariable(new RDoubleType(), new RTypeIntersection())) },
 	);
 	
@@ -30,16 +30,16 @@ describe('Infer types for subsetting expressions', () => {
 		'l <- list(1, 2, 3); l[2] <- y; l',
 		undefined,
 		{ query: Q.var('l').last().build(),         expectedType: new RListType(elementType1, new Map([[0, elementType1], [1, elementType1], [2, elementType1]])) },
-		{ query: Q.var('y').last().build(),         upperBound: new RTypeUnion(new RAtomicVectorType(new RTypeIntersection()), new RListType(new RTypeIntersection())) },
-		{ query: Q.criterion('1@[').last().build(), upperBound: new RTypeUnion(new RAtomicVectorType(new RTypeIntersection()), new RListType(new RTypeIntersection())) },
+		{ query: Q.var('y').last().build(),         upperBound: new RTypeUnion(new RNullType(), new RAtomicVectorType(new RTypeIntersection()), new RListType(new RTypeIntersection())) },
+		{ query: Q.criterion('1@[').last().build(), upperBound: new RTypeUnion(new RNullType(), new RAtomicVectorType(new RTypeIntersection()), new RListType(new RTypeIntersection())) },
 	);
 	
 	assertInferredTypes(
 		'v <- c(1, 2, 3); v[] <- y; v',
 		undefined,
 		{ query: Q.var('v').last().build(),         expectedType: new RAtomicVectorType(new RTypeVariable(new RDoubleType(), new RTypeIntersection())) },
-		{ query: Q.var('y').last().build(),         upperBound: new RTypeUnion(new RAtomicVectorType(new RTypeIntersection()), new RListType(new RTypeIntersection())) },
-		{ query: Q.criterion('1@[').last().build(), upperBound: new RTypeUnion(new RAtomicVectorType(new RTypeIntersection()), new RListType(new RTypeIntersection())) },
+		{ query: Q.var('y').last().build(),         upperBound: new RTypeUnion(new RNullType(), new RAtomicVectorType(new RTypeIntersection()), new RListType(new RTypeIntersection())) },
+		{ query: Q.criterion('1@[').last().build(), upperBound: new RTypeUnion(new RNullType(), new RAtomicVectorType(new RTypeIntersection()), new RListType(new RTypeIntersection())) },
 	);
 	
 	const elementType2 = new RTypeVariable(new RDoubleType(), new RTypeIntersection());
@@ -47,8 +47,8 @@ describe('Infer types for subsetting expressions', () => {
 		'l <- list(1, 2, 3); l[] <- y; l',
 		undefined,
 		{ query: Q.var('l').last().build(),         expectedType: new RListType(elementType2, new Map([[0, elementType2], [1, elementType2], [2, elementType2]])) },
-		{ query: Q.var('y').last().build(),         upperBound: new RTypeUnion(new RAtomicVectorType(new RTypeIntersection()), new RListType(new RTypeIntersection())) },
-		{ query: Q.criterion('1@[').last().build(), upperBound: new RTypeUnion(new RAtomicVectorType(new RTypeIntersection()), new RListType(new RTypeIntersection())) },
+		{ query: Q.var('y').last().build(),         upperBound: new RTypeUnion(new RNullType(), new RAtomicVectorType(new RTypeIntersection()), new RListType(new RTypeIntersection())) },
+		{ query: Q.criterion('1@[').last().build(), upperBound: new RTypeUnion(new RNullType(), new RAtomicVectorType(new RTypeIntersection()), new RListType(new RTypeIntersection())) },
 	);
 	
 	assertInferredTypes(
@@ -86,7 +86,7 @@ describe('Infer types for subsetting expressions', () => {
 		{ query: Q.criterion('1@$').last().build(), expectedType: new RTypeVariable() },
 	);
 	
-	const elementType6 = new RTypeVariable(new RAtomicVectorType(new RDoubleType()), new RTypeIntersection());
+	const elementType6 = new RTypeVariable(new RTypeUnion(new RDoubleType(), new RNullType()), new RTypeIntersection());
 	// eslint-disable-next-line @typescript-eslint/naming-convention
 	const elementType6_0 = new RTypeVariable(new RLogicalType(), new RTypeIntersection());
 	// eslint-disable-next-line @typescript-eslint/naming-convention
@@ -119,9 +119,9 @@ describe('Infer types for subsetting expressions', () => {
 	assertInferredTypes(
 		'v <- NULL; v[1] <- y; v',
 		undefined,
-		{ query: Q.var('v').last().build(),         expectedType: new RTypeVariable(new RNullType(), new RAtomicVectorType(new RTypeIntersection())) },
-		{ query: Q.var('y').last().build(),         upperBound: new RTypeUnion(new RAtomicVectorType(new RTypeIntersection()), new RListType(new RTypeIntersection())) },
-		{ query: Q.criterion('1@[').last().build(), upperBound: new RTypeUnion(new RAtomicVectorType(new RTypeIntersection()), new RListType(new RTypeIntersection())) },
+		{ query: Q.var('v').last().build(),         expectedType: new RNullType() },
+		{ query: Q.var('y').last().build(),         upperBound: new RTypeUnion(new RNullType(), new RAtomicVectorType(new RTypeIntersection()), new RListType(new RTypeIntersection())) },
+		{ query: Q.criterion('1@[').last().build(), upperBound: new RTypeUnion(new RNullType(), new RAtomicVectorType(new RTypeIntersection()), new RListType(new RTypeIntersection())) },
 	);
 	
 	assertInferredTypes(
diff --git a/test/functionality/typing/subtyping/resolve.test.ts b/test/functionality/typing/subtyping/resolve.test.ts
index 49fda5a5477..cf83c7a2014 100644
--- a/test/functionality/typing/subtyping/resolve.test.ts
+++ b/test/functionality/typing/subtyping/resolve.test.ts
@@ -239,8 +239,8 @@ describe('Constrain and resolve types', () => {
 		// Typing of function call
 		const argType1 = new UnresolvedRTypeVariable();
 		// const argType2 = new UnresolvedRTypeVariable();
-		// constrain(new RIntegerType(), argType1, cache);
-		constrain(argType1, new RIntegerType(), cache);
+		constrain(new RIntegerType(), argType1, cache);
+		// constrain(argType1, new RIntegerType(), cache);
 		// constrain(new RStringType(), argType2, cache);
 		// constrain(argType2, new RStringType(), cache);
 		const templateFuncType1 = new UnresolvedRFunctionType();
diff --git a/test/functionality/typing/subtyping/subsetting.test.ts b/test/functionality/typing/subtyping/subsetting.test.ts
index 5a05f341f0e..b17271d05bd 100644
--- a/test/functionality/typing/subtyping/subsetting.test.ts
+++ b/test/functionality/typing/subtyping/subsetting.test.ts
@@ -1,6 +1,6 @@
 import { describe } from 'vitest';
 import type { DataType } from '../../../../src/typing/types';
-import { RTypeIntersection, RAtomicVectorType, RListType, RTypeVariable, RNullType, RLogicalType, RS4Type, RDoubleType } from '../../../../src/typing/types';
+import { RTypeIntersection, RAtomicVectorType, RListType, RTypeVariable, RNullType, RLogicalType, RS4Type, RDoubleType, RTypeUnion } from '../../../../src/typing/types';
 import { assertInferredTypes } from '../../_helper/typing/subtyping/assert-inferred-type';
 import { Q } from '../../../../src/search/flowr-search-builder';
 import { RType } from '../../../../src/r-bridge/lang-4.x/ast/model/type';
@@ -10,7 +10,7 @@ describe('Infer types for subsetting expressions', () => {
 		'v <- c(1, 2, 3); v[2]',
 		undefined,
 		{ query: Q.var('v').last().build(),                    expectedType: new RAtomicVectorType(new RTypeVariable(new RDoubleType(), new RTypeIntersection())) },
-		{ query: Q.all().filter(RType.Access).first().build(), lowerBound: new RAtomicVectorType(new RDoubleType()) },
+		{ query: Q.all().filter(RType.Access).first().build(), lowerBound: new RAtomicVectorType(new RTypeUnion()) },
 	);
 	
 	const elementType1 = new RTypeVariable(new RDoubleType(), new RTypeIntersection());
@@ -18,7 +18,7 @@ describe('Infer types for subsetting expressions', () => {
 		'l <- list(1, 2, 3); l[2]',
 		undefined,
 		{ query: Q.var('l').last().build(),                    expectedType: new RListType(elementType1, new Map([[0, elementType1], [1, elementType1], [2, elementType1]])) },
-		{ query: Q.all().filter(RType.Access).first().build(), lowerBound: new RListType(new RDoubleType(), new Map([[0, new RDoubleType()], [1, new RDoubleType()], [2, new RDoubleType()]])) },
+		{ query: Q.all().filter(RType.Access).first().build(), lowerBound: new RListType(new RTypeUnion()) },
 	);
 	
 	assertInferredTypes(
@@ -63,11 +63,11 @@ describe('Infer types for subsetting expressions', () => {
 	assertInferredTypes(
 		'l <- list(1, 2, 3); l$a',
 		undefined,
-		{ query: Q.var('l').last().build(),                    expectedType: new RListType(elementType5, new Map([[0, elementType5], [1, elementType5], [2, elementType5]])) },
-		{ query: Q.all().filter(RType.Access).first().build(), lowerBound: new RDoubleType() },
+		{ query: Q.var('l').last().build(),                    expectedType: new RListType(elementType5, new Map<number | string, DataType>([[0, elementType5], [1, elementType5], [2, elementType5], ['a', new RTypeVariable()]])) },
+		{ query: Q.all().filter(RType.Access).first().build(), lowerBound: new RTypeUnion() },
 	);
 	
-	const elementType6 = new RTypeVariable(new RAtomicVectorType(new RDoubleType()), new RTypeIntersection());
+	const elementType6 = new RTypeVariable(new RTypeUnion(new RDoubleType(), new RNullType()), new RTypeIntersection());
 	// eslint-disable-next-line @typescript-eslint/naming-convention
 	const elementType6_0 = new RTypeVariable(new RLogicalType(), new RTypeIntersection());
 	// eslint-disable-next-line @typescript-eslint/naming-convention
@@ -78,7 +78,7 @@ describe('Infer types for subsetting expressions', () => {
 		'l <- list(TRUE, a = 42, NULL); l$a',
 		undefined,
 		{ query: Q.var('l').last().build(),                    expectedType: new RListType(elementType6, new Map<number | string, DataType>([[0, elementType6_0], [1, elementType6_1], [2, elementType6_2], ['a', elementType6_1]])) },
-		{ query: Q.all().filter(RType.Access).first().build(), lowerBound: new RAtomicVectorType(new RDoubleType()), upperBound: new RTypeIntersection() },
+		{ query: Q.all().filter(RType.Access).first().build(), lowerBound: new RDoubleType() },
 	);
 
 	assertInferredTypes(

From 128469a8cc0ed28ebdbb56e42e6fdfa2ec66874e Mon Sep 17 00:00:00 2001
From: Lukas Rohde <lukas.rohde@silupe.de>
Date: Mon, 11 Aug 2025 16:08:41 +0200
Subject: [PATCH 139/153] feat-fix(typing): fix default values for datatype
 query parameters

---
 src/queries/catalog/datatype-query/datatype-query-executor.ts | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/src/queries/catalog/datatype-query/datatype-query-executor.ts b/src/queries/catalog/datatype-query/datatype-query-executor.ts
index 11da575ee80..783d5456361 100644
--- a/src/queries/catalog/datatype-query/datatype-query-executor.ts
+++ b/src/queries/catalog/datatype-query/datatype-query-executor.ts
@@ -15,10 +15,10 @@ export async function executeDatatypeQuery({ dataflow, ast }: BasicQueryData, qu
 	const result: DatatypeQueryResult['inferredTypes'] = {};
 	for(const query of queries) {
 		const knownTypes = new Map<string, Set<UnresolvedDataType>>();
-		if(query.useTurcotteTypes) {
+		if(query.useTurcotteTypes ?? true) {
 			await loadTurcotteTypes(knownTypes);
 		}
-		if(query.useTracedTypes) {
+		if(query.useTracedTypes ?? true) {
 			await loadTracedTypes(knownTypes);
 		}
 

From 898859cc5150bb92c123d74bf3b5d7933031f5fd Mon Sep 17 00:00:00 2001
From: Lukas Rohde <lukas.rohde@silupe.de>
Date: Mon, 11 Aug 2025 16:10:59 +0200
Subject: [PATCH 140/153] feat-fix(typing): fix major oversight in handling
 overloading

---
 src/typing/subtyping/infer.ts                 |  59 ++---
 src/typing/subtyping/types.ts                 | 240 +++++++++---------
 .../subtyping/contextual-inference.test.ts    |   8 +-
 .../typing/subtyping/example-code.test.ts     |  34 +++
 .../typing/subtyping/resolve.test.ts          | 198 ++++++++++-----
 5 files changed, 322 insertions(+), 217 deletions(-)
 create mode 100644 test/functionality/typing/subtyping/example-code.test.ts

diff --git a/src/typing/subtyping/infer.ts b/src/typing/subtyping/infer.ts
index 7faf778bbfa..c626f9de748 100644
--- a/src/typing/subtyping/infer.ts
+++ b/src/typing/subtyping/infer.ts
@@ -24,7 +24,7 @@ import { RType } from '../../r-bridge/lang-4.x/ast/model/type';
 import type { NoInfo, RNode } from '../../r-bridge/lang-4.x/ast/model/model';
 import { RFalse, RTrue } from '../../r-bridge/lang-4.x/convert-values';
 import type { UnresolvedDataType } from './types';
-import { constrain, getIndexedElementTypeFromList, getParameterTypeFromFunction, resolve, UnresolvedRAtomicVectorType, UnresolvedRFunctionType, UnresolvedRListType, UnresolvedRTypeIntersection, UnresolvedRTypeUnion, UnresolvedRTypeVariable } from './types';
+import { constrain, getIndexedElementTypeFromList, getParameterTypeFromFunction, prune, resolve, UnresolvedRAtomicVectorType, UnresolvedRFunctionType, UnresolvedRListType, UnresolvedRTypeIntersection, UnresolvedRTypeUnion, UnresolvedRTypeVariable } from './types';
 import { defaultConfigOptions } from '../../config';
 
 
@@ -55,11 +55,9 @@ function decorateTypeVariables<Info extends ParentInformation>(ast: NormalizedAs
 }
 
 function resolveTypeVariables<Info extends ParentInformation & UnresolvedTypeInfo>(ast: NormalizedAst<Info>): NormalizedAst<Omit<Info, keyof UnresolvedTypeInfo> & DataTypeInfo> {
-	const prunedVariables = new Set<UnresolvedRTypeVariable>();
 	return mapNormalizedAstInfo(ast, node => {
 		const { typeVariable, ...rest } = node.info;
-		const resolvedType = resolve(typeVariable, undefined, prunedVariables);
-		return { ...rest, inferredType: resolvedType };
+		return { ...rest, inferredType: resolve(typeVariable, undefined) };
 	});
 }
 
@@ -86,8 +84,8 @@ class TypeInferringCfgGuidedVisitor<
 		Error.stackTraceLimit = 100; // Increase stack trace limit for better debugging
 	}
 
-	protected constraintCache: Map<UnresolvedDataType, Set<UnresolvedDataType>> = new Map();
-	protected orphanTypes:     Set<UnresolvedDataType> = new Set();
+	protected constraintCache:   Map<UnresolvedDataType, Set<UnresolvedDataType>> = new Map();
+	protected prunableVariables: Set<UnresolvedRTypeVariable> = new Set();
 
 
 	protected constrainNodeType(nodeOrId: RNode<UnresolvedTypeInfo> | NodeId, constraint: UnresolvedDataType | { lowerBound?: UnresolvedDataType, upperBound?: UnresolvedDataType }): void {
@@ -98,10 +96,10 @@ class TypeInferringCfgGuidedVisitor<
 		const upperBound = 'tag' in constraint ? constraint : constraint.upperBound;
 
 		if(lowerBound !== undefined) {
-			constrain(lowerBound, node.info.typeVariable, this.constraintCache);
+			constrain(lowerBound, node.info.typeVariable, this.constraintCache, this.prunableVariables);
 		}
 		if(upperBound !== undefined) {
-			constrain(node.info.typeVariable, upperBound, this.constraintCache);
+			constrain(node.info.typeVariable, upperBound, this.constraintCache, this.prunableVariables);
 		}
 	}
 
@@ -148,10 +146,13 @@ class TypeInferringCfgGuidedVisitor<
 				// If the read variable has no associated AST node it might be a library constant or function
 				const contextualTypes = this.config.knownTypes.get(node.content);
 				if(contextualTypes !== undefined && contextualTypes.size > 0) {
-					this.constrainNodeType(node, { lowerBound: new UnresolvedRTypeUnion(...contextualTypes.values()) });
+					for(const type of contextualTypes) {
+						this.constrainNodeType(node, { lowerBound: type });
+						lowerBounds.add(type);
+					}
 				}
 			}
-		} else if(lowerBounds.size > 0) {
+		} else {
 			const upperBound = lowerBounds.size === 1 ? lowerBounds.values().next().value : new UnresolvedRTypeUnion(...lowerBounds);
 			this.constrainNodeType(node, { upperBound });
 		}
@@ -208,12 +209,12 @@ class TypeInferringCfgGuidedVisitor<
 			guard(argNode !== undefined, 'Expected argument node to be defined');
 
 			if(arg.name !== undefined) {
-				constrain(argNode.info.typeVariable, getParameterTypeFromFunction(templateFunctionType, arg.name), this.constraintCache);
+				constrain(argNode.info.typeVariable, getParameterTypeFromFunction(templateFunctionType, arg.name), this.constraintCache, this.prunableVariables);
 			} else {
-				constrain(argNode.info.typeVariable, getParameterTypeFromFunction(templateFunctionType, index), this.constraintCache);
+				constrain(argNode.info.typeVariable, getParameterTypeFromFunction(templateFunctionType, index), this.constraintCache, this.prunableVariables);
 			}
 		}
-		constrain(calledFunctionType, templateFunctionType, this.constraintCache);
+		constrain(calledFunctionType, templateFunctionType, this.constraintCache, this.prunableVariables);
 
 		for(const targetNode of callTargetNodes) {
 			this.constrainNodeType(targetNode, { upperBound: templateFunctionType });
@@ -224,13 +225,11 @@ class TypeInferringCfgGuidedVisitor<
 			const contextualTypes = this.config.knownTypes.get(data.call.name);
 			if(contextualTypes !== undefined && contextualTypes.size > 0) {
 				// console.log('Constraining node', data.call.id, 'with contextual types for', data.call.name);
-				constrain(new UnresolvedRTypeIntersection(...contextualTypes.values()), calledFunctionType, this.constraintCache);
+				constrain(new UnresolvedRTypeIntersection(...contextualTypes.values()), calledFunctionType, this.constraintCache, this.prunableVariables);
 			}
 		}
 
 		this.constrainNodeType(data.call.id, templateFunctionType.returnType);
-		
-		this.orphanTypes.add(calledFunctionType);
 	}
 
 	override onGetCall(data: { call: DataflowGraphVertexFunctionCall }) {
@@ -358,17 +357,15 @@ class TypeInferringCfgGuidedVisitor<
 			const argNode = this.getNormalizedAst(arg.nodeId);
 			guard(argNode !== undefined, 'Expected argument node to be defined');
 			
-			this.constrainNodeType(argNode, { upperBound: getIndexedElementTypeFromList(listType, index, this.constraintCache) });
+			this.constrainNodeType(argNode, { upperBound: getIndexedElementTypeFromList(listType, index, this.constraintCache, this.prunableVariables) });
 
 			if(arg.name !== undefined) {
-				this.constrainNodeType(argNode, { upperBound: getIndexedElementTypeFromList(listType, arg.name, this.constraintCache) });
+				this.constrainNodeType(argNode, { upperBound: getIndexedElementTypeFromList(listType, arg.name, this.constraintCache, this.prunableVariables) });
 			}
 		}
 	}
 
 	override onVectorCall(data: { call: DataflowGraphVertexFunctionCall }) {
-		const lowerBounds = new Set<UnresolvedDataType>();
-		
 		const vectorType = new UnresolvedRAtomicVectorType();
 		this.constrainNodeType(data.call.id, vectorType);
 
@@ -377,12 +374,7 @@ class TypeInferringCfgGuidedVisitor<
 			guard(argNode !== undefined, 'Expected argument node to be defined');
 
 			this.constrainNodeType(argNode, { upperBound: vectorType });
-			lowerBounds.add(argNode.info.typeVariable);
 		}
-
-		// eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-		const upperBound = lowerBounds.size === 1 ? lowerBounds.values().next().value! : new UnresolvedRTypeUnion(...lowerBounds);
-		constrain(vectorType, upperBound, this.constraintCache);
 	}
 
 	override onFunctionDefinition(data: { vertex: DataflowGraphVertexFunctionDefinition }): void {
@@ -498,13 +490,11 @@ class TypeInferringCfgGuidedVisitor<
 			}
 		}
 
-		constrain(firstArgNode.info.typeVariable, getParameterTypeFromFunction(templateFunction, 0), this.constraintCache);
+		constrain(firstArgNode.info.typeVariable, getParameterTypeFromFunction(templateFunction, 0), this.constraintCache, this.prunableVariables);
 		this.constrainNodeType(data.call.id, templateFunction.returnType);
-		
-		constrain(overloads, accessFunction, this.constraintCache);
-		constrain(accessFunction, templateFunction, this.constraintCache);
 
-		this.orphanTypes.add(accessFunction);
+		constrain(overloads, accessFunction, this.constraintCache, this.prunableVariables);
+		constrain(accessFunction, templateFunction, this.constraintCache, this.prunableVariables);
 	}
 
 	protected override onReplacementCall(data: { call: DataflowGraphVertexFunctionCall; source: NodeId | undefined; target: NodeId | undefined; }): void {
@@ -541,9 +531,12 @@ class TypeInferringCfgGuidedVisitor<
 	}
 
 	protected onVisitorEnd(): void {
-		// Resolve types that are not directly constrained by a node type
-		for(const type of this.orphanTypes) {
-			resolve(type);
+		let newConstraintsFound = true;
+		while(newConstraintsFound) {
+			newConstraintsFound = false;
+			for(const type of this.prunableVariables) {
+				newConstraintsFound ||= prune(type, this.constraintCache, this.prunableVariables);
+			}
 		}
 	}
 }
\ No newline at end of file
diff --git a/src/typing/subtyping/types.ts b/src/typing/subtyping/types.ts
index 0619c35ad6f..c5d4da8e04d 100644
--- a/src/typing/subtyping/types.ts
+++ b/src/typing/subtyping/types.ts
@@ -32,13 +32,13 @@ export class UnresolvedRListType {
 	}
 }
 
-export function getIndexedElementTypeFromList(list: UnresolvedRListType, indexOrName: number | string, constraintCache: Map<UnresolvedDataType, Set<UnresolvedDataType>>): UnresolvedRTypeVariable {
+export function getIndexedElementTypeFromList(list: UnresolvedRListType, indexOrName: number | string, constraintCache: Map<UnresolvedDataType, Set<UnresolvedDataType>>, prunableVariables: Set<UnresolvedRTypeVariable> = new Set()): UnresolvedRTypeVariable {
 	let elementType = list.indexedElementTypes.get(indexOrName);
 	if(elementType === undefined) {
 		elementType = new UnresolvedRTypeVariable();
-		constrain(elementType, list.elementType.upperBound, constraintCache);
+		constrain(elementType, list.elementType.upperBound, constraintCache, prunableVariables);
 		list.indexedElementTypes.set(indexOrName, elementType);
-		constrain(elementType, list.elementType, constraintCache);
+		constrain(elementType, list.elementType, constraintCache, prunableVariables);
 	}
 	return elementType;
 }
@@ -107,16 +107,16 @@ export class UnresolvedRTypeVariable {
 }
 
 
-export function constrain(subtype: UnresolvedDataType, supertype: UnresolvedDataType, cache: Map<UnresolvedDataType, Set<UnresolvedDataType>> = new Map()): void {
-	// console.debug('Constraining', subtype instanceof UnresolvedRTypeVariable ? subtype.id : inspect(subtype, { depth: null, colors: true }), 'to subsume', supertype instanceof UnresolvedRTypeVariable ? supertype.id : inspect(supertype, { depth: null, colors: true }));
+export function constrain(subtype: UnresolvedDataType, supertype: UnresolvedDataType, cache: Map<UnresolvedDataType, Set<UnresolvedDataType>> = new Map(), prunableVariables: Set<UnresolvedRTypeVariable> = new Set()): boolean {
+	// console.debug('Constraining', inspect(subtype, { depth: null, colors: true }), 'to subsume', supertype instanceof UnresolvedRTypeVariable ? supertype.id : inspect(supertype, { depth: null, colors: true }));
 
 	if(subtype === supertype) {
-		return; // No need to constrain if both types are the same
+		return false; // No need to constrain if both types are the same
 	}
 
 	const cachedConstraints = cache.get(subtype);
 	if(cachedConstraints?.has(supertype)) {
-		return; // Avoid infinite recursion
+		return false; // Avoid infinite recursion
 	}
 	if(cachedConstraints !== undefined) {
 		cachedConstraints.add(supertype);
@@ -126,96 +126,126 @@ export function constrain(subtype: UnresolvedDataType, supertype: UnresolvedData
 
 	if(subtype instanceof UnresolvedRTypeUnion) {
 		for(const type of subtype.types) {
-			constrain(type, supertype, cache);
+			constrain(type, supertype, cache, prunableVariables);
 		}
 	} else if(supertype instanceof UnresolvedRTypeIntersection) {
 		for(const type of supertype.types) {
-			constrain(type, type, cache);
+			constrain(subtype, type, cache, prunableVariables);
 		}
 	} else if(subtype instanceof UnresolvedRTypeVariable) {
 		subtype.upperBound.types.add(supertype);
+		if(supertype instanceof UnresolvedRTypeUnion && supertype.types.size > 0) {
+			prunableVariables.add(subtype);
+		}
 		for(const lowerBound of subtype.lowerBound.types) {
-			constrain(lowerBound, supertype, cache);
+			constrain(lowerBound, supertype, cache, prunableVariables);
 		}
 	} else if(supertype instanceof UnresolvedRTypeVariable) {
 		supertype.lowerBound.types.add(subtype);
+		if(subtype instanceof UnresolvedRTypeIntersection && subtype.types.size > 0) {
+			prunableVariables.add(supertype);
+		}
 		for(const upperBound of supertype.upperBound.types) {
-			constrain(subtype, upperBound, cache);
+			constrain(subtype, upperBound, cache, prunableVariables);
 		}
 	} else if(subtype instanceof UnresolvedRFunctionType && supertype instanceof UnresolvedRFunctionType) {
 		const subtypeParameterKeys = new Set(subtype.parameterTypes.keys());
 		const supertypeParameterKeys = new Set(supertype.parameterTypes.keys());
 		for(const key of subtypeParameterKeys.intersection(supertypeParameterKeys)) {
-			constrain(getParameterTypeFromFunction(supertype, key), getParameterTypeFromFunction(subtype, key), cache);
+			constrain(getParameterTypeFromFunction(supertype, key), getParameterTypeFromFunction(subtype, key), cache, prunableVariables);
 		}
-		constrain(subtype.returnType, supertype.returnType, cache);
+		constrain(subtype.returnType, supertype.returnType, cache, prunableVariables);
 	} else if(subtype instanceof UnresolvedRAtomicVectorType && supertype instanceof UnresolvedRAtomicVectorType) {
-		constrain(subtype.elementType, supertype.elementType, cache);
+		constrain(subtype.elementType, supertype.elementType, cache, prunableVariables);
 	} else if(isAtomicVectorBaseType(subtype) && supertype instanceof UnresolvedRAtomicVectorType) {
-		constrain(subtype, supertype.elementType, cache);
+		constrain(subtype, supertype.elementType, cache, prunableVariables);
 	} else if(subtype instanceof UnresolvedRListType && supertype instanceof UnresolvedRListType) {
 		const subtypeElementIndices = new Set(subtype.indexedElementTypes.keys());
 		const supertypeElementIndices = new Set(supertype.indexedElementTypes.keys());
 		for(const indexOrName of subtypeElementIndices.union(supertypeElementIndices).values()) {
-			constrain(getIndexedElementTypeFromList(subtype, indexOrName, cache), getIndexedElementTypeFromList(supertype, indexOrName, cache), cache);
+			constrain(getIndexedElementTypeFromList(subtype, indexOrName, cache, prunableVariables), getIndexedElementTypeFromList(supertype, indexOrName, cache, prunableVariables), cache, prunableVariables);
 		}
-		constrain(subtype.elementType, supertype.elementType, cache);
+		constrain(subtype.elementType, supertype.elementType, cache, prunableVariables);
 	}
+
+	return true; // Successfully constrained types
 }
 
 
-export function prune(variable: UnresolvedRTypeVariable): void {
+export function prune(variable: UnresolvedRTypeVariable, constraintCache: Map<UnresolvedDataType, Set<UnresolvedDataType>> = new Map(), prunableVariables: Set<UnresolvedRTypeVariable>): boolean {
 	// console.debug('Pruning variable', variable.id);
 
+	let newConstraintsFound = false;
+
 	// Prune lower bounds
-	for(const lowerBound of variable.lowerBound.types) {
+	for(const lowerBound of variable.lowerBound.types.values()) {
 		if(lowerBound instanceof UnresolvedRTypeIntersection) {
-			// If the lower bound is an intersection, we need to consider its upper bounds
+			// console.debug('Analyzing lower bound intersection:', inspect(lowerBound, { depth: null, colors: true }));
+
 			if(variable.upperBound.types.size === 0) {
 				continue; // If there are no upper bounds, we keep the lower bound
 			}
-			// Otherwise, we prune it to only include types that subsume some upper bound
-			let upperBound: UnresolvedDataType = new UnresolvedRTypeUnion();
-			for(const type of variable.upperBound.types) {
-				upperBound = unresolvedJoin(upperBound, type);
-			}
+
 			for(const type of lowerBound.types) {
-				if(variable.upperBound.types.values().some(upperBound => subsumes(type, upperBound))) {
-					// console.debug('Constraining', inspect(type, { depth: null, colors: true }), 'to subsume', inspect(upperBound, { depth: null, colors: true }));
-					constrain(type, upperBound);
-				} else {
-					// console.debug('Pruning', inspect(type, { depth: null, colors: true }), 'from lower intersection', inspect(lowerBound, { depth: null, colors: true }));
+				if(!variable.upperBound.types.values().some(upperBound => subsumes(type, upperBound))) {
 					lowerBound.types.delete(type);
 				}
 			}
+
+			let newLowerBound: UnresolvedDataType = new UnresolvedRTypeIntersection();
+			for(const type of lowerBound.types) {
+				newLowerBound = unresolvedMeet(newLowerBound, type, constraintCache, prunableVariables);
+			}
+			// console.debug('New lower bound:', inspect(newLowerBound, { depth: null, colors: true }));
+
+			lowerBound.types = newLowerBound instanceof UnresolvedRTypeIntersection ? newLowerBound.types : new Set([newLowerBound]);
+			
+			if(lowerBound.types.size === 1) {
+				const [type] = lowerBound.types;
+				// console.debug('Constraining', inspect(type, { depth: null, colors: true }), 'to subsume', inspect(variable, { depth: null, colors: true }));
+				newConstraintsFound ||= constrain(type, variable, constraintCache, prunableVariables);
+			}
 		}
 	}
 
 	// Prune upper bounds
-	for(const upperBound of variable.upperBound.types) {
+	for(const upperBound of variable.upperBound.types.values()) {
 		if(upperBound instanceof UnresolvedRTypeUnion) {
-			// If the upper bound is a union, we need to consider its lower bounds
+			// console.debug('Analyzing upper bound union:', inspect(upperBound, { depth: null, colors: true }));
+
 			if(variable.lowerBound.types.size === 0) {
 				continue; // If there are no lower bounds, we keep the upper bound
 			}
-			// Otherwise, we prune it to only include types that are subsumed by some lower bound
-			let lowerBound: UnresolvedDataType = new UnresolvedRTypeIntersection();
-			for(const type of variable.lowerBound.types) {
-				lowerBound = unresolvedMeet(lowerBound, type);
-			}
+
 			for(const type of upperBound.types) {
-				if(variable.lowerBound.types.values().some(lowerBound => subsumes(lowerBound, type))) {
-					constrain(lowerBound, type);
-				} else {
+				if(!variable.lowerBound.types.values().some(lowerBound => subsumes(lowerBound, type))) {
 					upperBound.types.delete(type);
 				}
 			}
+
+			let newUpperBound: UnresolvedDataType = new UnresolvedRTypeUnion();
+			for(const type of upperBound.types) {
+				newUpperBound = unresolvedJoin(newUpperBound, type, constraintCache, prunableVariables);
+			}
+			// console.debug('New upper bound:', inspect(newUpperBound, { depth: null, colors: true }));
+
+			upperBound.types = newUpperBound instanceof UnresolvedRTypeUnion ? newUpperBound.types : new Set([newUpperBound]);
+
+			if(upperBound.types.size === 1) {
+				const [type] = upperBound.types;
+				// console.debug('Constraining', inspect(variable, { depth: null, colors: true }), 'to subsume', inspect(type, { depth: null, colors: true }));
+				newConstraintsFound ||= constrain(variable, type, constraintCache, prunableVariables);
+			}
+			
 		}
 	}
+	
+	// console.debug('New constraints found:', newConstraintsFound);
+	return newConstraintsFound;
 }
 
 
-export function resolve(type: UnresolvedDataType, isUpperBound?: boolean, prunedVariables: Set<UnresolvedRTypeVariable> = new Set(), cache: Map<UnresolvedRTypeVariable, { lowerBound: DataType, upperBound: DataType, combined: DataType }> = new Map()): DataType {
+export function resolve(type: UnresolvedDataType, isUpperBound?: boolean, cache: Map<UnresolvedRTypeVariable, { lowerBound: DataType, upperBound: DataType, combined: DataType }> = new Map()): DataType {
 	// console.debug('Resolving', inspect(type, { depth: null, colors: true }));
 
 	if(type instanceof UnresolvedRTypeVariable) {
@@ -223,26 +253,17 @@ export function resolve(type: UnresolvedDataType, isUpperBound?: boolean, pruned
 		if(cachedType !== undefined) {
 			switch(isUpperBound) {
 				case true:
-					// console.debug('Returning', inspect(cachedType.upperBound, { depth: null, colors: true }), 'for upper bound');
 					return cachedType.upperBound;
 				case false:
-					// console.debug('Returning', inspect(cachedType.lowerBound, { depth: null, colors: true }), 'for lower bound');
 					return cachedType.lowerBound;
 				default:
-					// console.debug('Returning', inspect(cachedType.combined, { depth: null, colors: true }), 'for combined');
 					return cachedType.combined;
 			}
 		}
 		cache.set(type, { lowerBound: new RTypeUnion(), upperBound: new RTypeIntersection(), combined: new RTypeVariable() }); // Prevent infinite recursion
 
-		if(!prunedVariables.has(type)) {
-			prune(type); // Prune the variable to remove unnecessary bounds
-			prunedVariables.add(type);
-		}
-
-
-		const lowerBound = resolve(type.lowerBound, false, prunedVariables, cache);
-		const upperBound = resolve(type.upperBound, true, prunedVariables, cache);
+		const lowerBound = resolve(type.lowerBound, false, cache);
+		const upperBound = resolve(type.upperBound, true, cache);
 
 		if(!subsumes(lowerBound, upperBound)) {
 			const errorType = new RTypeError(lowerBound, upperBound);
@@ -250,72 +271,49 @@ export function resolve(type: UnresolvedDataType, isUpperBound?: boolean, pruned
 			return errorType;
 		}
 
-		// console.debug('Resolved lower bound', inspect(lowerBound, { depth: null, colors: true }), 'and upper bound', inspect(upperBound, { depth: null, colors: true }));
 		const combined = combine(lowerBound, upperBound);
-		// console.debug('Combined bounds into type', inspect(combined, { depth: null, colors: true }));
+		
 		cache.set(type, { lowerBound, upperBound, combined });
 
 		switch(isUpperBound) {
 			case true:
-				// console.debug('Returning', inspect(upperBound, { depth: null, colors: true }), 'for upper bound');
 				return upperBound;
 			case false:
-				// console.debug('Returning', inspect(lowerBound, { depth: null, colors: true }), 'for lower bound');
 				return lowerBound;
 			default:
-				// console.debug('Returning', inspect(combined, { depth: null, colors: true }), 'for combined');
 				return combined;
 		}
 	} else if(type instanceof UnresolvedRTypeUnion) {
 		let resolvedType: DataType = new RTypeUnion();
 		for(const subtype of type.types) {
-			const resolvedSubtype = resolve(subtype, isUpperBound, prunedVariables, cache);
+			const resolvedSubtype = resolve(subtype, isUpperBound, cache);
 			resolvedType = join(resolvedType, resolvedSubtype);
 		}
-
-		// console.debug('Returning', inspect(resolvedType, { depth: null, colors: true }), 'for resolved union type');
 		return resolvedType;
 	} else if(type instanceof UnresolvedRTypeIntersection) {
 		let resolvedType: DataType = new RTypeIntersection();
 		for(const subtype of type.types) {
-			const resolvedSubtype = resolve(subtype, isUpperBound, prunedVariables, cache);
+			const resolvedSubtype = resolve(subtype, isUpperBound, cache);
 			resolvedType = meet(resolvedType, resolvedSubtype);
 		}
-
-		// console.debug('Returning', inspect(resolvedType, { depth: null, colors: true }), 'for resolved intersection type');
 		return resolvedType;
 	} else if(type instanceof UnresolvedRFunctionType) {
-		type.parameterTypes.values().forEach(paramType => prune(paramType));
-		prune(type.returnType);
-
 		const resolvedParameterTypes = new Map(type.parameterTypes.entries().toArray().map(([key, type]) => {
-			return [key, resolve(type, isUpperBound !== undefined ? !isUpperBound : undefined, prunedVariables, cache)];
+			return [key, resolve(type, isUpperBound !== undefined ? !isUpperBound : undefined, cache)];
 		}));
-		const resolvedReturnType = resolve(type.returnType, isUpperBound, prunedVariables, cache);
+		const resolvedReturnType = resolve(type.returnType, isUpperBound, cache);
 		const resolvedType = new RFunctionType(resolvedParameterTypes, resolvedReturnType);
-		
-		// console.debug('Returning', inspect(resolvedType, { depth: null, colors: true }), 'for resolved function type');
 		return resolvedType;
 	} else if(type instanceof UnresolvedRAtomicVectorType) {
-		prune(type.elementType);
-
-		const resolvedElementType = resolve(type.elementType, isUpperBound, prunedVariables, cache);
+		const resolvedElementType = resolve(type.elementType, isUpperBound, cache);
 		const resolvedType = new RAtomicVectorType(resolvedElementType);
-		
-		// console.debug('Returning', inspect(resolvedType, { depth: null, colors: true }), 'for resolved atomic vector type');
 		return resolvedType;
 	} else if(type instanceof UnresolvedRListType) {
-		type.indexedElementTypes.values().forEach(elementType => prune(elementType));
-		prune(type.elementType);
-
-		const resolvedElementType = resolve(type.elementType, isUpperBound, prunedVariables, cache);
-		const resolvedIndexedElementTypes = new Map(type.indexedElementTypes.entries().map(([indexOrName, elementType]) => [indexOrName, resolve(elementType, isUpperBound, prunedVariables, cache)]));
+		const resolvedElementType = resolve(type.elementType, isUpperBound, cache);
+		const resolvedIndexedElementTypes = new Map(type.indexedElementTypes.entries().map(([indexOrName, elementType]) => [indexOrName, resolve(elementType, isUpperBound, cache)]));
 		const resolvedType = new RListType(resolvedElementType, resolvedIndexedElementTypes);
-		
-		// console.debug('Returning', inspect(resolvedType, { depth: null, colors: true }), 'for resolved list type');
 		return resolvedType;
 	} else {
-		// console.debug('Returning already resolved', inspect(type, { depth: null, colors: true }));
 		return type;
 	}
 }
@@ -421,7 +419,7 @@ export function subsumes(subtype: DataType | UnresolvedDataType, supertype: Data
 	return result;
 }
 
-export function unresolvedJoin(type1: UnresolvedDataType, type2: UnresolvedDataType): UnresolvedDataType {
+export function unresolvedJoin(type1: UnresolvedDataType, type2: UnresolvedDataType, constraintCache: Map<UnresolvedDataType, Set<UnresolvedDataType>>, prunableVariables: Set<UnresolvedRTypeVariable>): UnresolvedDataType {
 	// console.debug('Joining (unresolved)', type1, 'and', type2);
 
 	if(type1 instanceof RTypeError) {
@@ -429,9 +427,9 @@ export function unresolvedJoin(type1: UnresolvedDataType, type2: UnresolvedDataT
 	} else if(type2 instanceof RTypeError) {
 		return type2;
 	} else if(type1 instanceof UnresolvedRTypeVariable) {
-		return unresolvedJoin(type1.upperBound, type2);
+		return unresolvedJoin(type1.upperBound, type2, constraintCache, prunableVariables);
 	} else if(type2 instanceof UnresolvedRTypeVariable) {
-		return unresolvedJoin(type1, type2.upperBound);
+		return unresolvedJoin(type1, type2.upperBound, constraintCache, prunableVariables);
 	} else if(type1 instanceof UnresolvedRTypeUnion) {
 		if(type1.types.size === 0) {
 			return type2; // If type1 is an empty union, return type2
@@ -439,7 +437,7 @@ export function unresolvedJoin(type1: UnresolvedDataType, type2: UnresolvedDataT
 
 		const types = new Set<UnresolvedDataType>();
 		for(const type of type1.types) {
-			const joinedType = unresolvedJoin(type, type2);
+			const joinedType = unresolvedJoin(type, type2, constraintCache, prunableVariables);
 			if(joinedType instanceof RTypeError) {
 				return joinedType; // If any subtype resolves to an error, return the error
 			} else {
@@ -461,7 +459,7 @@ export function unresolvedJoin(type1: UnresolvedDataType, type2: UnresolvedDataT
 
 		return types.size === 1 ? [...types][0] : new UnresolvedRTypeUnion(...types);
 	} else if(type2 instanceof UnresolvedRTypeUnion) {
-		return unresolvedJoin(type2, type1);
+		return unresolvedJoin(type2, type1, constraintCache, prunableVariables);
 	} else if(type1 instanceof UnresolvedRFunctionType && type2 instanceof UnresolvedRFunctionType) {
 		const parameterTypes = new Map<number | string, UnresolvedRTypeVariable>();
 		const keys1 = new Set(type1.parameterTypes.keys());
@@ -469,15 +467,15 @@ export function unresolvedJoin(type1: UnresolvedDataType, type2: UnresolvedDataT
 		for(const key of keys1.union(keys2)) {
 			const parameterType1 = type1.parameterTypes.get(key) ?? new UnresolvedRTypeIntersection();
 			const parameterType2 = type2.parameterTypes.get(key) ?? new UnresolvedRTypeIntersection();
-			const metParameterType = unresolvedMeet(parameterType1, parameterType2);
+			const metParameterType = unresolvedMeet(parameterType1, parameterType2, constraintCache, prunableVariables);
 			const parameterType = new UnresolvedRTypeVariable();
-			constrain(metParameterType, parameterType);
+			constrain(metParameterType, parameterType, constraintCache, prunableVariables);
 			// constrain(parameterType, metParameterType);
 			parameterTypes.set(key, parameterType);
 		}
-		const joinedReturnType = unresolvedJoin(type1.returnType, type2.returnType);
+		const joinedReturnType = unresolvedJoin(type1.returnType, type2.returnType, constraintCache, prunableVariables);
 		const returnType = new UnresolvedRTypeVariable();
-		constrain(returnType, joinedReturnType);
+		constrain(returnType, joinedReturnType, constraintCache, prunableVariables);
 		// constrain(joinedReturnType, returnType);
 		return new UnresolvedRFunctionType(parameterTypes, returnType);
 	} else if(type1 instanceof UnresolvedRListType && type2 instanceof UnresolvedRListType) {
@@ -487,33 +485,33 @@ export function unresolvedJoin(type1: UnresolvedDataType, type2: UnresolvedDataT
 		for(const key of keys1.intersection(keys2)) {
 			const elementType1 = type1.indexedElementTypes.get(key) ?? new UnresolvedRTypeIntersection();
 			const elementType2 = type2.indexedElementTypes.get(key) ?? new UnresolvedRTypeIntersection();
-			const joinedElementType = unresolvedJoin(elementType1, elementType2);
+			const joinedElementType = unresolvedJoin(elementType1, elementType2, constraintCache, prunableVariables);
 			const elementType = new UnresolvedRTypeVariable();
-			constrain(elementType, joinedElementType);
+			constrain(elementType, joinedElementType, constraintCache, prunableVariables);
 			// constrain(joinedElementType, elementType);
 			indexedElementTypes.set(key, elementType);
 		}
-		const joinedElementType = unresolvedJoin(type1.elementType, type2.elementType);
+		const joinedElementType = unresolvedJoin(type1.elementType, type2.elementType, constraintCache, prunableVariables);
 		const elementType = new UnresolvedRTypeVariable();
-		constrain(elementType, joinedElementType);
+		constrain(elementType, joinedElementType, constraintCache, prunableVariables);
 		// constrain(joinedElementType, elementType);
 		return new UnresolvedRListType(elementType, indexedElementTypes);
 	} else if(type1 instanceof UnresolvedRAtomicVectorType && type2 instanceof UnresolvedRAtomicVectorType) {
-		const joinedElementType = unresolvedJoin(type1.elementType, type2.elementType);
+		const joinedElementType = unresolvedJoin(type1.elementType, type2.elementType, constraintCache, prunableVariables);
 		const elementType = new UnresolvedRTypeVariable();
-		constrain(elementType, joinedElementType);
+		constrain(elementType, joinedElementType, constraintCache, prunableVariables);
 		// constrain(joinedElementType, elementType);
 		return new UnresolvedRAtomicVectorType(elementType);
 	} else if(isAtomicVectorBaseType(type1) && type2.tag === DataTypeTag.AtomicVector) {
-		const joinedElementType = unresolvedJoin(type1, type2.elementType);
+		const joinedElementType = unresolvedJoin(type1, type2.elementType, constraintCache, prunableVariables);
 		const elementType = new UnresolvedRTypeVariable();
-		constrain(elementType, joinedElementType);
+		constrain(elementType, joinedElementType, constraintCache, prunableVariables);
 		// constrain(joinedElementType, elementType);
 		return new UnresolvedRAtomicVectorType(elementType);
 	} else if(isAtomicVectorBaseType(type2) && type1.tag === DataTypeTag.AtomicVector) {
-		const joinedElementType = unresolvedJoin(type2, type1.elementType);
+		const joinedElementType = unresolvedJoin(type2, type1.elementType, constraintCache, prunableVariables);
 		const elementType = new UnresolvedRTypeVariable();
-		constrain(elementType, joinedElementType);
+		constrain(elementType, joinedElementType, constraintCache, prunableVariables);
 		// constrain(joinedElementType, elementType);
 		return new UnresolvedRAtomicVectorType(elementType);
 	} else if(subsumes(type1, type2)) {
@@ -599,17 +597,17 @@ export function join(type1: DataType, type2: DataType): DataType {
 	return new RTypeUnion(type1, type2);
 }
 
-export function unresolvedMeet(type1: UnresolvedDataType, type2: UnresolvedDataType): UnresolvedDataType {
-	// console.debug('Meeting (unresolved)', type1, 'and', type2);
+export function unresolvedMeet(type1: UnresolvedDataType, type2: UnresolvedDataType, constraintCache: Map<UnresolvedDataType, Set<UnresolvedDataType>>, prunableVariables: Set<UnresolvedRTypeVariable>): UnresolvedDataType {
+	// console.debug('Meeting (unresolved)', inspect(type1, { depth: null, colors: true }), 'and', inspect(type2, { depth: null, colors: true }));
 
 	if(type1 instanceof RTypeError) {
 		return type1;
 	} else if(type2 instanceof RTypeError) {
 		return type2;
 	} else if(type1 instanceof UnresolvedRTypeVariable) {
-		return unresolvedMeet(type1.lowerBound, type2);
+		return unresolvedMeet(type1.lowerBound, type2, constraintCache, prunableVariables);
 	} else if(type2 instanceof UnresolvedRTypeVariable) {
-		return unresolvedMeet(type1, type2.lowerBound);
+		return unresolvedMeet(type1, type2.lowerBound, constraintCache, prunableVariables);
 	} else if(type1 instanceof UnresolvedRTypeIntersection) {
 		if(type1.types.size === 0) {
 			return type2; // If type1 is an empty intersection, return type2
@@ -617,7 +615,7 @@ export function unresolvedMeet(type1: UnresolvedDataType, type2: UnresolvedDataT
 
 		const types = new Set<UnresolvedDataType>();
 		for(const subtype of type1.types) {
-			const metType = unresolvedMeet(subtype, type2);
+			const metType = unresolvedMeet(subtype, type2, constraintCache, prunableVariables);
 			if(metType instanceof RTypeError) {
 				return metType; // If any subtype resolves to an error, return the error
 			} else {
@@ -639,7 +637,7 @@ export function unresolvedMeet(type1: UnresolvedDataType, type2: UnresolvedDataT
 
 		return types.size === 1 ? [...types][0] : new UnresolvedRTypeIntersection(...types);
 	} else if(type2 instanceof UnresolvedRTypeIntersection) {
-		return unresolvedMeet(type2, type1);
+		return unresolvedMeet(type2, type1, constraintCache, prunableVariables);
 	} else if(type1 instanceof UnresolvedRFunctionType && type2 instanceof UnresolvedRFunctionType) {
 		const parameterTypes = new Map<number | string, UnresolvedRTypeVariable>();
 		const keys1 = new Set(type1.parameterTypes.keys());
@@ -647,15 +645,15 @@ export function unresolvedMeet(type1: UnresolvedDataType, type2: UnresolvedDataT
 		for(const key of keys1.intersection(keys2)) {
 			const parameterType1 = type1.parameterTypes.get(key) ?? new UnresolvedRTypeUnion();
 			const parameterType2 = type2.parameterTypes.get(key) ?? new UnresolvedRTypeUnion();
-			const joinedParameterType = unresolvedJoin(parameterType1, parameterType2);
+			const joinedParameterType = unresolvedJoin(parameterType1, parameterType2, constraintCache, prunableVariables);
 			const parameterType = new UnresolvedRTypeVariable();
-			constrain(parameterType, joinedParameterType);
+			constrain(parameterType, joinedParameterType, constraintCache, prunableVariables);
 			// constrain(joinedParameterType, parameterType);
 			parameterTypes.set(key, parameterType);
 		}
-		const metReturnType = unresolvedMeet(type1.returnType, type2.returnType);
+		const metReturnType = unresolvedMeet(type1.returnType, type2.returnType, constraintCache, prunableVariables);
 		const returnType = new UnresolvedRTypeVariable();
-		constrain(metReturnType, returnType);
+		constrain(metReturnType, returnType, constraintCache, prunableVariables);
 		// constrain(returnType, metReturnType);
 		return new UnresolvedRFunctionType(parameterTypes, returnType);
 	} else if(type1 instanceof UnresolvedRListType && type2 instanceof UnresolvedRListType) {
@@ -665,30 +663,30 @@ export function unresolvedMeet(type1: UnresolvedDataType, type2: UnresolvedDataT
 		for(const key of keys1.union(keys2)) {
 			const elementType1 = type1.indexedElementTypes.get(key) ?? new UnresolvedRTypeUnion();
 			const elementType2 = type2.indexedElementTypes.get(key) ?? new UnresolvedRTypeUnion();
-			const metElementType = unresolvedMeet(elementType1, elementType2);
+			const metElementType = unresolvedMeet(elementType1, elementType2, constraintCache, prunableVariables);
 			const elementType = new UnresolvedRTypeVariable();
-			constrain(metElementType, elementType);
+			constrain(metElementType, elementType, constraintCache, prunableVariables);
 			// constrain(elementType, metElementType);
 			indexedElementTypes.set(key, elementType);
 		}
-		const metElementType = unresolvedMeet(type1.elementType, type2.elementType);
+		const metElementType = unresolvedMeet(type1.elementType, type2.elementType, constraintCache, prunableVariables);
 		const elementType = new UnresolvedRTypeVariable();
-		constrain(metElementType, elementType);
+		constrain(metElementType, elementType, constraintCache, prunableVariables);
 		// constrain(elementType, metElementType);
 		return new UnresolvedRListType(elementType, indexedElementTypes);
 	} else if(type1 instanceof RAtomicVectorType && type2 instanceof UnresolvedRAtomicVectorType) {
-		const metElementType = unresolvedMeet(type1.elementType, type2.elementType);
+		const metElementType = unresolvedMeet(type1.elementType, type2.elementType, constraintCache, prunableVariables);
 		const elementType = new UnresolvedRTypeVariable();
-		constrain(metElementType, elementType);
+		constrain(metElementType, elementType, constraintCache, prunableVariables);
 		// constrain(elementType, metElementType);
 		return new UnresolvedRAtomicVectorType(elementType);
 	} else if(isAtomicVectorBaseType(type1) && type2.tag === DataTypeTag.AtomicVector) {
-		return unresolvedMeet(type1, type2.elementType);
+		return unresolvedMeet(type1, type2.elementType, constraintCache, prunableVariables);
 	} else if(isAtomicVectorBaseType(type2) && type1.tag === DataTypeTag.AtomicVector) {
-		return unresolvedMeet(type2, type1.elementType);
+		return unresolvedMeet(type2, type1.elementType, constraintCache, prunableVariables);
 	} else if(type1.tag === DataTypeTag.AtomicVector && type2.tag === DataTypeTag.Null || type2.tag === DataTypeTag.AtomicVector && type1.tag === DataTypeTag.Null) {
 		const elementType = new UnresolvedRTypeVariable();
-		constrain(new UnresolvedRTypeUnion(), elementType);
+		constrain(new UnresolvedRTypeUnion(), elementType, constraintCache, prunableVariables);
 		return new UnresolvedRAtomicVectorType(elementType);
 	} else if(subsumes(type1, type2)) {
 		return type1;
diff --git a/test/functionality/typing/subtyping/contextual-inference.test.ts b/test/functionality/typing/subtyping/contextual-inference.test.ts
index d0b183dc35f..a528e74a3eb 100644
--- a/test/functionality/typing/subtyping/contextual-inference.test.ts
+++ b/test/functionality/typing/subtyping/contextual-inference.test.ts
@@ -1,10 +1,10 @@
 import { describe } from 'vitest';
-import { RAtomicVectorType, RComplexType, RDoubleType, RNullType, RStringType, RTypeIntersection, RTypeUnion, RTypeVariable } from '../../../../src/typing/types';
+import { RDoubleType, RTypeIntersection, RTypeVariable } from '../../../../src/typing/types';
 import { assertInferredType } from '../../_helper/typing/subtyping/assert-inferred-type';
 import type { UnresolvedDataType } from '../../../../src/typing/subtyping/types';
 import { loadTracedTypes, loadTurcotteTypes } from '../../../../src/typing/adapter/load-type-signatures';
 
-describe('Infer no type information for currently unsupported R expressions', async() => {
+describe('Infer types based on contextual type signatures', async() => {
 	const knownTypes: Map<string, Set<UnresolvedDataType>> = new Map();
 	
 	await loadTurcotteTypes(knownTypes);
@@ -15,6 +15,6 @@ describe('Infer no type information for currently unsupported R expressions', as
 	
 	await loadTracedTypes(knownTypes);
 	
-	assertInferredType('1 + 2',                  new RTypeVariable(new RAtomicVectorType(new RComplexType()), new RTypeIntersection()), knownTypes);
-	assertInferredType('print("Hello, world!")', new RTypeVariable(new RTypeUnion(new RAtomicVectorType(new RTypeUnion(new RStringType(), new RDoubleType())), new RNullType()), new RTypeIntersection()), knownTypes);
+	assertInferredType('1 + 2',                  new RTypeVariable(new RDoubleType(), new RTypeIntersection()), knownTypes);
+	assertInferredType('print("Hello, world!")', new RTypeVariable(), knownTypes);
 });
\ No newline at end of file
diff --git a/test/functionality/typing/subtyping/example-code.test.ts b/test/functionality/typing/subtyping/example-code.test.ts
new file mode 100644
index 00000000000..c25cb70f015
--- /dev/null
+++ b/test/functionality/typing/subtyping/example-code.test.ts
@@ -0,0 +1,34 @@
+import { describe } from 'vitest';
+import type { DataType } from '../../../../src/typing/types';
+import { RComplexType, RDoubleType, RFunctionType, RIntegerType, RAtomicVectorType, RStringType, RTypeIntersection, RTypeVariable } from '../../../../src/typing/types';
+import { assertInferredTypes } from '../../_helper/typing/subtyping/assert-inferred-type';
+import type { UnresolvedDataType } from '../../../../src/typing/subtyping/types';
+import { loadTracedTypes, loadTurcotteTypes } from '../../../../src/typing/adapter/load-type-signatures';
+import { Q } from '../../../../src/search/flowr-search-builder';
+
+describe('Infer types for longer code snippets', async() => {
+	const knownTypes: Map<string, Set<UnresolvedDataType>> = new Map();
+	
+	await loadTurcotteTypes(knownTypes);
+
+	// const signatures = knownTypes.get('sum')?.values().toArray() ?? [];
+	// console.dir(signatures, { depth: null, colors: true });
+	// knownTypes.set('print', new Set([printTypes[1]]));
+	
+	await loadTracedTypes(knownTypes);
+	
+	const functionType = new RFunctionType(new Map<number | string, DataType>([[0, new RTypeVariable(new RStringType(), new RTypeIntersection())], [1, new RTypeVariable(new RDoubleType(), new RTypeIntersection())], ['price', new RTypeVariable()], ['quantity', new RTypeVariable()]]), new RTypeVariable());
+	
+	assertInferredTypes(
+		'cost <- function(price, quantity) sum(price * quantity); cost("5.50€", 2)',
+		knownTypes,
+		{ query: Q.var('cost').first().build(),     expectedType: functionType },
+		// { query: Q.var('price').first().build(),    lowerBound: new RStringType() },
+		// { query: Q.var('price').last().build(),     lowerBound: new RStringType() },
+		// { query: Q.var('quantity').first().build(), lowerBound: new RDoubleType() },
+		// { query: Q.var('quantity').last().build(),  lowerBound: new RDoubleType() },
+		{ query: Q.criterion('1@*').build(),        lowerBound: new RIntegerType(), upperBound: new RAtomicVectorType(new RComplexType()) },
+		{ query: Q.criterion('1@*').build(),        lowerBound: new RIntegerType(), upperBound: new RAtomicVectorType(new RComplexType()) },
+		{ query: Q.criterion('1@sum').build(),      lowerBound: new RIntegerType() }
+	);
+});
\ No newline at end of file
diff --git a/test/functionality/typing/subtyping/resolve.test.ts b/test/functionality/typing/subtyping/resolve.test.ts
index cf83c7a2014..fb31d4f3657 100644
--- a/test/functionality/typing/subtyping/resolve.test.ts
+++ b/test/functionality/typing/subtyping/resolve.test.ts
@@ -1,6 +1,6 @@
 import { describe, expect, test } from 'vitest';
 import type { UnresolvedDataType } from '../../../../src/typing/subtyping/types';
-import { constrain, meet, resolve, subsumes, UnresolvedRAtomicVectorType, UnresolvedRFunctionType, UnresolvedRListType, UnresolvedRTypeIntersection, UnresolvedRTypeUnion, UnresolvedRTypeVariable } from '../../../../src/typing/subtyping/types';
+import { constrain, meet, prune, resolve, subsumes, UnresolvedRAtomicVectorType, UnresolvedRFunctionType, UnresolvedRListType, UnresolvedRTypeIntersection, UnresolvedRTypeUnion, UnresolvedRTypeVariable } from '../../../../src/typing/subtyping/types';
 import { RIntegerType, RComplexType, RTypeVariable, RDoubleType, RStringType, RListType, RTypeIntersection, RTypeUnion, RNullType, RLanguageType, RLogicalType, RAtomicVectorType } from '../../../../src/typing/types';
 
 describe('Constrain and resolve types', () => {
@@ -10,17 +10,26 @@ describe('Constrain and resolve types', () => {
 		const typeVar = new UnresolvedRTypeVariable();
 		constrain(new RIntegerType(), typeVar, cache);
 		constrain(typeVar, new RComplexType(), cache);
-		
+
 		expect(resolve(typeVar)).toEqual(new RTypeVariable(new RIntegerType(), new RComplexType()));
 	});
 
 	test('Constrain with multiple bounds', () => {
 		const cache = new Map<UnresolvedDataType, Set<UnresolvedDataType>>();
+		const prunableVariables = new Set<UnresolvedRTypeVariable>();
 
 		const typeVar = new UnresolvedRTypeVariable();
-		constrain(new RIntegerType(), typeVar, cache);
-		constrain(new RDoubleType(), typeVar, cache);
-		constrain(typeVar, new UnresolvedRTypeUnion(new RComplexType(), new RStringType()), cache);
+		constrain(new RIntegerType(), typeVar, cache, prunableVariables);
+		constrain(new RDoubleType(), typeVar, cache, prunableVariables);
+		constrain(typeVar, new UnresolvedRTypeUnion(new RComplexType(), new RStringType()), cache, prunableVariables);
+
+		let newConstraintsFound = true;
+		while(newConstraintsFound) {
+			newConstraintsFound = false;
+			for(const variable of prunableVariables) {
+				newConstraintsFound ||= prune(variable, cache, prunableVariables);
+			}
+		}
 
 		expect(resolve(typeVar)).toEqual(new RTypeVariable(new RDoubleType(), new RComplexType()));
 	});
@@ -57,15 +66,24 @@ describe('Constrain and resolve types', () => {
 
 	test('Advanced constraint propagation', () => {
 		const cache = new Map<UnresolvedDataType, Set<UnresolvedDataType>>();
+		const prunableVariables = new Set<UnresolvedRTypeVariable>();
 
 		const typeVar = new UnresolvedRTypeVariable();
 		const listType1 = new UnresolvedRListType();
-		constrain(new RIntegerType(), listType1.elementType, cache);
-		constrain(listType1, typeVar, cache);
+		constrain(new RIntegerType(), listType1.elementType, cache, prunableVariables);
+		constrain(listType1, typeVar, cache, prunableVariables);
 
 		const elementType = new UnresolvedRTypeVariable();
 		const vectorType = new UnresolvedRTypeUnion(new UnresolvedRAtomicVectorType(elementType), new UnresolvedRListType(elementType));
-		constrain(typeVar, vectorType, cache);
+		constrain(typeVar, vectorType, cache, prunableVariables);
+
+		let newConstraintsFound = true;
+		while(newConstraintsFound) {
+			newConstraintsFound = false;
+			for(const variable of prunableVariables) {
+				newConstraintsFound ||= prune(variable, cache, prunableVariables);
+			}
+		}
 
 		expect(resolve(typeVar)).toEqual(new RListType(new RTypeVariable(new RIntegerType(), new RTypeIntersection())));
 		expect(resolve(elementType)).toEqual(new RTypeVariable(new RIntegerType(), new RTypeIntersection()));
@@ -73,23 +91,24 @@ describe('Constrain and resolve types', () => {
 
 	test('Function overloading 1', () => {
 		const cache = new Map<UnresolvedDataType, Set<UnresolvedDataType>>();
+		const prunableVariables = new Set<UnresolvedRTypeVariable>();
 
 		// Predetermined types in context
 		const funcType1 = new UnresolvedRFunctionType();
 		const paramType1 = new UnresolvedRTypeVariable();
 		funcType1.parameterTypes.set(0, paramType1);
-		constrain(new RIntegerType(), paramType1, cache);
-		constrain(paramType1, new RIntegerType(), cache);
-		constrain(new RIntegerType(), funcType1.returnType, cache);
-		constrain(funcType1.returnType, new RIntegerType(), cache);
+		constrain(new RIntegerType(), paramType1, cache, prunableVariables);
+		constrain(paramType1, new RIntegerType(), cache, prunableVariables);
+		constrain(new RIntegerType(), funcType1.returnType, cache, prunableVariables);
+		constrain(funcType1.returnType, new RIntegerType(), cache, prunableVariables);
 
 		const funcType2 = new UnresolvedRFunctionType();
 		const paramType2 = new UnresolvedRTypeVariable();
 		funcType2.parameterTypes.set(0, paramType2);
-		constrain(new RStringType(), paramType2, cache);
-		constrain(paramType2, new RStringType(), cache);
-		constrain(new RStringType(), funcType2.returnType, cache);
-		constrain(funcType2.returnType, new RStringType(), cache);
+		constrain(new RStringType(), paramType2, cache, prunableVariables);
+		constrain(paramType2, new RStringType(), cache, prunableVariables);
+		constrain(new RStringType(), funcType2.returnType, cache, prunableVariables);
+		constrain(funcType2.returnType, new RStringType(), cache, prunableVariables);
 
 		const overloadedFuncType1 = new UnresolvedRTypeIntersection(funcType1, funcType2);
 		const overloadedFuncType2 = new UnresolvedRTypeIntersection(funcType1, funcType2);
@@ -97,27 +116,32 @@ describe('Constrain and resolve types', () => {
 		// Typing of called function
 		const calledFuncType1 = new UnresolvedRTypeVariable();
 		const calledFuncType2 = new UnresolvedRTypeVariable();
-		constrain(overloadedFuncType1, calledFuncType1, cache);
-		constrain(overloadedFuncType2, calledFuncType2, cache);
+		constrain(overloadedFuncType1, calledFuncType1, cache, prunableVariables);
+		constrain(overloadedFuncType2, calledFuncType2, cache, prunableVariables);
 
 		// Typing of function call
 		const argType1 = new UnresolvedRTypeVariable();
 		const argType2 = new UnresolvedRTypeVariable();
-		constrain(new RIntegerType(), argType1, cache);
-		constrain(argType1, new RIntegerType(), cache);
-		constrain(new RStringType(), argType2, cache);
-		constrain(argType2, new RStringType(), cache);
+		constrain(new RIntegerType(), argType1, cache, prunableVariables);
+		constrain(argType1, new RIntegerType(), cache, prunableVariables);
+		constrain(new RStringType(), argType2, cache, prunableVariables);
+		constrain(argType2, new RStringType(), cache, prunableVariables);
 		const templateFuncType1 = new UnresolvedRFunctionType();
 		templateFuncType1.parameterTypes.set(0, argType1);
 		const returnType1 = templateFuncType1.returnType;
 		const templateFuncType2 = new UnresolvedRFunctionType();
 		templateFuncType2.parameterTypes.set(0, argType2);
 		const returnType2 = templateFuncType2.returnType;
-		constrain(calledFuncType1, templateFuncType1, cache);
-		constrain(calledFuncType2, templateFuncType2, cache);
+		constrain(calledFuncType1, templateFuncType1, cache, prunableVariables);
+		constrain(calledFuncType2, templateFuncType2, cache, prunableVariables);
 
-		resolve(calledFuncType1);
-		resolve(calledFuncType2);
+		let newConstraintsFound = true;
+		while(newConstraintsFound) {
+			newConstraintsFound = false;
+			for(const variable of prunableVariables) {
+				newConstraintsFound ||= prune(variable, cache, prunableVariables);
+			}
+		}
 
 		// console.debug('funcType1', inspect(funcType1, { depth: null, colors: true }));
 		// console.debug('funcType2', inspect(funcType2, { depth: null, colors: true }));
@@ -136,23 +160,20 @@ describe('Constrain and resolve types', () => {
 
 	test('Function overloading 2', () => {
 		const cache = new Map<UnresolvedDataType, Set<UnresolvedDataType>>();
+		const prunableVariables = new Set<UnresolvedRTypeVariable>();
 
 		// Predetermined types in context
 		const funcType1 = new UnresolvedRFunctionType();
 		const paramType1 = new UnresolvedRTypeVariable();
 		funcType1.parameterTypes.set(0, paramType1);
-		constrain(new RIntegerType(), paramType1, cache);
-		constrain(paramType1, new RIntegerType(), cache);
-		constrain(new RIntegerType(), funcType1.returnType, cache);
-		constrain(funcType1.returnType, new RIntegerType(), cache);
+		constrain(paramType1, new RIntegerType(), cache, prunableVariables);
+		constrain(new RIntegerType(), funcType1.returnType, cache, prunableVariables);
 
 		const funcType2 = new UnresolvedRFunctionType();
 		const paramType2 = new UnresolvedRTypeVariable();
 		funcType2.parameterTypes.set(0, paramType2);
-		constrain(new RDoubleType(), paramType2, cache);
-		constrain(paramType2, new RDoubleType(), cache);
-		constrain(new RDoubleType(), funcType2.returnType, cache);
-		constrain(funcType2.returnType, new RDoubleType(), cache);
+		constrain(paramType2, new RDoubleType(), cache, prunableVariables);
+		constrain(new RDoubleType(), funcType2.returnType, cache, prunableVariables);
 
 		const overloadedFuncType1 = new UnresolvedRTypeIntersection(funcType1, funcType2);
 		const overloadedFuncType2 = new UnresolvedRTypeIntersection(funcType1, funcType2);
@@ -160,27 +181,30 @@ describe('Constrain and resolve types', () => {
 		// Typing of called function
 		const calledFuncType1 = new UnresolvedRTypeVariable();
 		const calledFuncType2 = new UnresolvedRTypeVariable();
-		constrain(overloadedFuncType1, calledFuncType1, cache);
-		constrain(overloadedFuncType2, calledFuncType2, cache);
+		constrain(overloadedFuncType1, calledFuncType1, cache, prunableVariables);
+		constrain(overloadedFuncType2, calledFuncType2, cache, prunableVariables);
 
 		// Typing of function call
 		const argType1 = new UnresolvedRTypeVariable();
 		const argType2 = new UnresolvedRTypeVariable();
-		constrain(new RIntegerType(), argType1, cache);
-		constrain(argType1, new RIntegerType(), cache);
-		constrain(new RDoubleType(), argType2, cache);
-		constrain(argType2, new RDoubleType(), cache);
+		constrain(new RIntegerType(), argType1, cache, prunableVariables);
+		constrain(new RDoubleType(), argType2, cache, prunableVariables);
 		const templateFuncType1 = new UnresolvedRFunctionType();
 		templateFuncType1.parameterTypes.set(0, argType1);
 		const returnType1 = templateFuncType1.returnType;
 		const templateFuncType2 = new UnresolvedRFunctionType();
 		templateFuncType2.parameterTypes.set(0, argType2);
 		const returnType2 = templateFuncType2.returnType;
-		constrain(calledFuncType1, templateFuncType1, cache);
-		constrain(calledFuncType2, templateFuncType2, cache);
+		constrain(calledFuncType1, templateFuncType1, cache, prunableVariables);
+		constrain(calledFuncType2, templateFuncType2, cache, prunableVariables);
 
-		resolve(calledFuncType1);
-		resolve(calledFuncType2);
+		let newConstraintsFound = true;
+		while(newConstraintsFound) {
+			newConstraintsFound = false;
+			for(const variable of prunableVariables) {
+				newConstraintsFound ||= prune(variable, cache, prunableVariables);
+			}
+		}
 
 		// console.debug('funcType1', inspect(funcType1, { depth: null, colors: true }));
 		// console.debug('funcType2', inspect(funcType2, { depth: null, colors: true }));
@@ -193,28 +217,29 @@ describe('Constrain and resolve types', () => {
 		// console.debug('returnType1', inspect(returnType1, { depth: null, colors: true }));
 		// console.debug('returnType2', inspect(returnType2, { depth: null, colors: true }));
 
-		expect(resolve(returnType1)).toEqual(new RTypeVariable(new RDoubleType(), new RTypeIntersection()));
+		expect(resolve(returnType1)).toEqual(new RTypeVariable(new RIntegerType(), new RTypeIntersection()));
 		expect(resolve(returnType2)).toEqual(new RTypeVariable(new RDoubleType(), new RTypeIntersection()));
 	});
 	
 	test('Function overloading 3', () => {
 		const cache = new Map<UnresolvedDataType, Set<UnresolvedDataType>>();
+		const prunableVariables = new Set<UnresolvedRTypeVariable>();
 
 		// Predetermined types in context
 		const funcType1 = new UnresolvedRFunctionType();
 		const paramType1 = new UnresolvedRTypeVariable();
 		funcType1.parameterTypes.set(0, paramType1);
 		// constrain(new RIntegerType(), paramType1, cache);
-		constrain(paramType1, new RIntegerType(), cache);
-		constrain(new RIntegerType(), funcType1.returnType, cache);
+		constrain(paramType1, new RIntegerType(), cache, prunableVariables);
+		constrain(new RIntegerType(), funcType1.returnType, cache, prunableVariables);
 		// constrain(funcType1.returnType, new RIntegerType(), cache);
 
 		const funcType2 = new UnresolvedRFunctionType();
 		const paramType2 = new UnresolvedRTypeVariable();
 		funcType2.parameterTypes.set(0, paramType2);
 		// constrain(new RStringType(), paramType2, cache);
-		constrain(paramType2, new RStringType(), cache);
-		constrain(new RStringType(), funcType2.returnType, cache);
+		constrain(paramType2, new RStringType(), cache, prunableVariables);
+		constrain(new RStringType(), funcType2.returnType, cache, prunableVariables);
 		// constrain(funcType2.returnType, new RStringType(), cache);
 
 		const funcType3 = new UnresolvedRFunctionType();
@@ -222,7 +247,7 @@ describe('Constrain and resolve types', () => {
 		funcType3.parameterTypes.set(0, paramType3);
 		const var1 = new UnresolvedRTypeVariable();
 		// const var2 = new UnresolvedRTypeVariable();
-		constrain(paramType3, var1, cache);
+		constrain(paramType3, var1, cache, prunableVariables);
 		// constrain(var1, paramType3, cache); // AVOID THIS AT ALL COSTS!
 		// constrain(funcType3.returnType, var2, cache);
 		// constrain(var2, funcType3.returnType, cache);
@@ -233,13 +258,13 @@ describe('Constrain and resolve types', () => {
 		// Typing of called function
 		const calledFuncType1 = new UnresolvedRTypeVariable();
 		const calledFuncType2 = new UnresolvedRTypeVariable();
-		constrain(overloadedFuncType1, calledFuncType1, cache);
-		constrain(overloadedFuncType2, calledFuncType2, cache);
+		constrain(overloadedFuncType1, calledFuncType1, cache, prunableVariables);
+		constrain(overloadedFuncType2, calledFuncType2, cache, prunableVariables);
 
 		// Typing of function call
 		const argType1 = new UnresolvedRTypeVariable();
 		// const argType2 = new UnresolvedRTypeVariable();
-		constrain(new RIntegerType(), argType1, cache);
+		constrain(new RIntegerType(), argType1, cache, prunableVariables);
 		// constrain(argType1, new RIntegerType(), cache);
 		// constrain(new RStringType(), argType2, cache);
 		// constrain(argType2, new RStringType(), cache);
@@ -249,11 +274,16 @@ describe('Constrain and resolve types', () => {
 		const templateFuncType2 = new UnresolvedRFunctionType();
 		// templateFuncType2.parameterTypes.set(0, argType2);
 		const returnType2 = templateFuncType2.returnType;
-		constrain(calledFuncType1, templateFuncType1, cache);
-		constrain(calledFuncType2, templateFuncType2, cache);
+		constrain(calledFuncType1, templateFuncType1, cache, prunableVariables);
+		constrain(calledFuncType2, templateFuncType2, cache, prunableVariables);
 
-		resolve(calledFuncType1);
-		// resolve(calledFuncType2);
+		let newConstraintsFound = true;
+		while(newConstraintsFound) {
+			newConstraintsFound = false;
+			for(const variable of prunableVariables) {
+				newConstraintsFound ||= prune(variable, cache, prunableVariables);
+			}
+		}
 
 		// console.debug('funcType3', inspect(funcType3, { depth: null, colors: true }));
 		// console.debug('funcType1', inspect(funcType1, { depth: null, colors: true }));
@@ -267,8 +297,58 @@ describe('Constrain and resolve types', () => {
 		// console.debug('returnType1', inspect(returnType1, { depth: null, colors: true }));
 		// console.debug('returnType2', inspect(returnType2, { depth: null, colors: true }));
 
-		expect(resolve(returnType1)).toEqual(new RTypeVariable(new RIntegerType(), new RTypeIntersection()));
-		expect(resolve(returnType2)).toEqual(new RTypeVariable(new RTypeUnion(), new RTypeIntersection()));
+		expect(resolve(returnType1)).toEqual(new RTypeVariable());
+		expect(resolve(returnType2)).toEqual(new RTypeVariable());
+	});
+	
+	test('Function overloading 4', () => {
+		const cache = new Map<UnresolvedDataType, Set<UnresolvedDataType>>();
+		const prunableVariables = new Set<UnresolvedRTypeVariable>();
+
+		// Predetermined types in context
+		const funcType1 = new UnresolvedRFunctionType();
+		const paramType1 = new UnresolvedRTypeVariable();
+		funcType1.parameterTypes.set(0, paramType1);
+		constrain(paramType1, new RLogicalType(), cache, prunableVariables);
+		constrain(new RDoubleType(), funcType1.returnType, cache, prunableVariables);
+
+		const funcType2 = new UnresolvedRFunctionType();
+		const paramType2 = new UnresolvedRTypeVariable();
+		funcType2.parameterTypes.set(0, paramType2);
+		constrain(paramType2, new RIntegerType(), cache, prunableVariables);
+		constrain(new RComplexType(), funcType2.returnType, cache, prunableVariables);
+
+		const overloadedFuncType = new UnresolvedRTypeIntersection(funcType1, funcType2);
+
+		// Typing of called function
+		const calledFuncType = new UnresolvedRTypeVariable();
+		constrain(overloadedFuncType, calledFuncType, cache, prunableVariables);
+
+		// Typing of function call
+		const argType = new UnresolvedRTypeVariable();
+		constrain(new UnresolvedRTypeVariable(), argType, cache, prunableVariables);
+		const templateFuncType = new UnresolvedRFunctionType();
+		templateFuncType.parameterTypes.set(0, argType);
+		const returnType = templateFuncType.returnType;
+		constrain(calledFuncType, templateFuncType, cache, prunableVariables);
+
+		let newConstraintsFound = true;
+		while(newConstraintsFound) {
+			newConstraintsFound = false;
+			for(const variable of prunableVariables) {
+				newConstraintsFound ||= prune(variable, cache, prunableVariables);
+			}
+		}
+
+		// console.debug('funcType1', inspect(funcType1, { depth: null, colors: true }));
+		// console.debug('funcType2', inspect(funcType2, { depth: null, colors: true }));
+		// console.debug('overloadedFuncType', inspect(overloadedFuncType, { depth: null, colors: true }));
+		// console.debug('calledFuncType', inspect(calledFuncType, { depth: null, colors: true }));
+		// console.debug('templateFuncType', inspect(templateFuncType, { depth: null, colors: true }));
+		// console.debug('returnType', inspect(returnType, { depth: null, colors: true }));
+
+		expect(resolve(returnType)).toEqual(new RTypeVariable(new RDoubleType(), new RTypeIntersection()));
+		expect(resolve(argType)).toEqual(new RTypeVariable(new RTypeUnion(), new RIntegerType()));
 	});
 
 	test('Constrain from both sides 1', () => {

From ddfaa64aee004f286021332b7bb36f875005c650 Mon Sep 17 00:00:00 2001
From: Lukas Rohde <lukas.rohde@silupe.de>
Date: Mon, 11 Aug 2025 17:07:55 +0200
Subject: [PATCH 141/153] feat(typing): improve typing of function definitions

---
 src/typing/subtyping/infer.ts                     | 12 ++++++++----
 .../typing/subtyping/example-code.test.ts         | 15 ++++++++-------
 2 files changed, 16 insertions(+), 11 deletions(-)

diff --git a/src/typing/subtyping/infer.ts b/src/typing/subtyping/infer.ts
index c626f9de748..dcc24cc3ac1 100644
--- a/src/typing/subtyping/infer.ts
+++ b/src/typing/subtyping/infer.ts
@@ -172,7 +172,7 @@ class TypeInferringCfgGuidedVisitor<
 		guard(node !== undefined, 'Expected AST node to be defined');
 		if(node.type === RType.Argument) {
 			if(node.value !== undefined) {
-				this.constrainNodeType(data.vertex.id, node.value.info.typeVariable);
+				this.constrainNodeType(node, node.value.info.typeVariable);
 			}
 			return;
 		}
@@ -382,7 +382,7 @@ class TypeInferringCfgGuidedVisitor<
 		guard(node !== undefined && node.type === RType.FunctionDefinition, 'Expected AST node to be a function definition');
 
 		const functionType = new UnresolvedRFunctionType();
-		this.constrainNodeType(node, { lowerBound: functionType });
+		this.constrainNodeType(node, functionType);
 
 		let dotsEncountered = false;
 		for(const [index, param] of node.parameters.entries()) {
@@ -391,16 +391,20 @@ class TypeInferringCfgGuidedVisitor<
 				continue; // Skip `...` parameters
 			}
 
+			this.constrainNodeType(param, param.name.info.typeVariable); // Ignore laziness of parameters for now
+
 			if(!dotsEncountered) {
 				// Only constrain the parameter type positionally if no `...` has been encountered yet
-				constrain(getParameterTypeFromFunction(functionType, index), param.info.typeVariable, this.constraintCache);
+				this.constrainNodeType(param, getParameterTypeFromFunction(functionType, index));
 			}
-			constrain(getParameterTypeFromFunction(functionType, param.name.lexeme), param.info.typeVariable, this.constraintCache);
+			this.constrainNodeType(param, getParameterTypeFromFunction(functionType, param.name.content));
 
 			if(param.defaultValue !== undefined) {
 				this.constrainNodeType(param, { lowerBound: param.defaultValue.info.typeVariable });
 			}
 		}
+
+		this.constrainNodeType(node.body, functionType.returnType);
 	}
 
 	override onProgram(node: RExpressionList<UnresolvedTypeInfo>) {
diff --git a/test/functionality/typing/subtyping/example-code.test.ts b/test/functionality/typing/subtyping/example-code.test.ts
index c25cb70f015..f6700c5eab0 100644
--- a/test/functionality/typing/subtyping/example-code.test.ts
+++ b/test/functionality/typing/subtyping/example-code.test.ts
@@ -1,6 +1,6 @@
 import { describe } from 'vitest';
 import type { DataType } from '../../../../src/typing/types';
-import { RComplexType, RDoubleType, RFunctionType, RIntegerType, RAtomicVectorType, RStringType, RTypeIntersection, RTypeVariable } from '../../../../src/typing/types';
+import { RComplexType, RDoubleType, RFunctionType, RIntegerType, RAtomicVectorType, RStringType, RTypeIntersection, RTypeVariable, RTypeUnion } from '../../../../src/typing/types';
 import { assertInferredTypes } from '../../_helper/typing/subtyping/assert-inferred-type';
 import type { UnresolvedDataType } from '../../../../src/typing/subtyping/types';
 import { loadTracedTypes, loadTurcotteTypes } from '../../../../src/typing/adapter/load-type-signatures';
@@ -23,12 +23,13 @@ describe('Infer types for longer code snippets', async() => {
 		'cost <- function(price, quantity) sum(price * quantity); cost("5.50€", 2)',
 		knownTypes,
 		{ query: Q.var('cost').first().build(),     expectedType: functionType },
-		// { query: Q.var('price').first().build(),    lowerBound: new RStringType() },
-		// { query: Q.var('price').last().build(),     lowerBound: new RStringType() },
-		// { query: Q.var('quantity').first().build(), lowerBound: new RDoubleType() },
-		// { query: Q.var('quantity').last().build(),  lowerBound: new RDoubleType() },
-		{ query: Q.criterion('1@*').build(),        lowerBound: new RIntegerType(), upperBound: new RAtomicVectorType(new RComplexType()) },
-		{ query: Q.criterion('1@*').build(),        lowerBound: new RIntegerType(), upperBound: new RAtomicVectorType(new RComplexType()) },
+		{ query: Q.var('price').first().build(),    lowerBound: new RStringType() },
+		{ query: Q.var('quantity').first().build(), lowerBound: new RDoubleType() },
+		{ query: Q.criterion('$1').build(),         lowerBound: new RStringType() },
+		{ query: Q.criterion('$3').build(),         lowerBound: new RDoubleType() },
+		{ query: Q.var('price').last().build(),     lowerBound: new RStringType() },
+		{ query: Q.var('quantity').last().build(),  lowerBound: new RDoubleType() },
+		{ query: Q.criterion('1@*').build(),        lowerBound: new RTypeUnion(), upperBound: new RAtomicVectorType(new RComplexType()) },
 		{ query: Q.criterion('1@sum').build(),      lowerBound: new RIntegerType() }
 	);
 });
\ No newline at end of file

From 8cbd2fbc5072d7380fbc86436e4b791ffe479cc3 Mon Sep 17 00:00:00 2001
From: Lukas Rohde <lukas.rohde@silupe.de>
Date: Mon, 11 Aug 2025 17:09:26 +0200
Subject: [PATCH 142/153] feat(typing): add override for apply functions

---
 src/typing/subtyping/infer.ts | 4 ++++
 1 file changed, 4 insertions(+)

diff --git a/src/typing/subtyping/infer.ts b/src/typing/subtyping/infer.ts
index dcc24cc3ac1..16599e5abb3 100644
--- a/src/typing/subtyping/infer.ts
+++ b/src/typing/subtyping/infer.ts
@@ -534,6 +534,10 @@ class TypeInferringCfgGuidedVisitor<
 		}
 	}
 
+	protected override onApplyFunctionCall(data: { call: DataflowGraphVertexFunctionCall; }): void {
+		this.onDefaultFunctionCall(data);
+	}
+
 	protected onVisitorEnd(): void {
 		let newConstraintsFound = true;
 		while(newConstraintsFound) {

From 352e6fbb4f296135e0a53d59348043a3c0336a5e Mon Sep 17 00:00:00 2001
From: Lukas Rohde <lukas.rohde@silupe.de>
Date: Mon, 11 Aug 2025 17:13:47 +0200
Subject: [PATCH 143/153] refactor(typing): remove builtin support for `quote`,
 `eval`, and `rm`

---
 src/typing/subtyping/infer.ts                     | 15 ++-------------
 .../typing/subtyping/builtin-functions.test.ts    | 12 +-----------
 2 files changed, 3 insertions(+), 24 deletions(-)

diff --git a/src/typing/subtyping/infer.ts b/src/typing/subtyping/infer.ts
index 16599e5abb3..8e7bec4fbca 100644
--- a/src/typing/subtyping/infer.ts
+++ b/src/typing/subtyping/infer.ts
@@ -9,7 +9,7 @@ import type { RString } from '../../r-bridge/lang-4.x/ast/model/nodes/r-string';
 import type { NormalizedAst, ParentInformation } from '../../r-bridge/lang-4.x/ast/model/processing/decorate';
 import { mapNormalizedAstInfo } from '../../r-bridge/lang-4.x/ast/model/processing/decorate';
 import type { DataTypeInfo } from '../types';
-import { RComplexType, RDoubleType, RIntegerType, RLogicalType, RStringType, RNullType, RLanguageType, RS4Type, REnvironmentType } from '../types';
+import { RComplexType, RDoubleType, RIntegerType, RLogicalType, RStringType, RNullType, RS4Type, REnvironmentType } from '../types';
 import type { RExpressionList } from '../../r-bridge/lang-4.x/ast/model/nodes/r-expression-list';
 import { guard } from '../../util/assert';
 import { OriginType } from '../../dataflow/origin/dfg-get-origin';
@@ -246,10 +246,6 @@ class TypeInferringCfgGuidedVisitor<
 		this.inferNodeTypeFromReadOrigins(node, varReadOrigins);
 	}
 
-	override onRmCall(data: { call: DataflowGraphVertexFunctionCall }) {
-		this.constrainNodeType(data.call.id, new RNullType());
-	}
-
 	override onForLoopCall(data: { call: DataflowGraphVertexFunctionCall, variable: FunctionArgument, vector: FunctionArgument, body: FunctionArgument }) {
 		guard(data.variable !== EmptyArgument && data.vector !== EmptyArgument, 'Expected variable and vector arguments to be defined');
 		const elementType = new UnresolvedRTypeVariable();
@@ -339,14 +335,7 @@ class TypeInferringCfgGuidedVisitor<
 	}
 	
 	override onQuoteCall(data: { call: DataflowGraphVertexFunctionCall }) {
-		this.constrainNodeType(data.call.id, new RLanguageType());
-	}
-
-	override onEvalFunctionCall(data: { call: DataflowGraphVertexFunctionCall }) {
-		guard(data.call.args.length === 1, 'Expected exactly one argument for eval call');
-		const arg = data.call.args.at(0);
-		guard(arg !== undefined && arg !== EmptyArgument, 'Expected argument of eval call to be defined');
-		this.constrainNodeType(arg.nodeId, { upperBound: new RLanguageType() });
+		this.onDefaultFunctionCall(data);
 	}
 
 	override onListCall(data: { call: DataflowGraphVertexFunctionCall }) {
diff --git a/test/functionality/typing/subtyping/builtin-functions.test.ts b/test/functionality/typing/subtyping/builtin-functions.test.ts
index 1d0dc723b40..d366d2ac110 100644
--- a/test/functionality/typing/subtyping/builtin-functions.test.ts
+++ b/test/functionality/typing/subtyping/builtin-functions.test.ts
@@ -1,11 +1,9 @@
 import { describe } from 'vitest';
-import { RTypeIntersection, RLanguageType, RListType, RLogicalType, RNullType, RStringType, RTypeVariable, RAtomicVectorType, RDoubleType } from '../../../../src/typing/types';
+import { RTypeIntersection, RListType, RStringType, RTypeVariable, RAtomicVectorType, RDoubleType } from '../../../../src/typing/types';
 import { assertInferredType, assertInferredTypes } from '../../_helper/typing/subtyping/assert-inferred-type';
 import { Q } from '../../../../src/search/flowr-search-builder';
 
 describe('Infer types for builtin functions', () => {
-	assertInferredType('rm(x)', { expectedType: new RNullType() });
-
 	assertInferredTypes(
 		'x <- 42\nget("x")',
 		undefined,
@@ -14,14 +12,6 @@ describe('Infer types for builtin functions', () => {
 		{ query: Q.criterion('2@"x"').build(), upperBound: new RStringType() }
 	);
 
-	assertInferredTypes(
-		'eval(quote(TRUE))',
-		undefined,
-		{ query: Q.criterion('1@eval').build(),  expectedType: new RTypeVariable() },
-		{ query: Q.criterion('1@quote').build(), expectedType: new RLanguageType() },
-		{ query: Q.criterion('1@TRUE').build(),  expectedType: new RLogicalType() }
-	);
-
 	const elementType = new RTypeVariable(new RDoubleType(), new RTypeIntersection());
 	assertInferredType('list(1, 2, 3)', { expectedType: new RListType(elementType, new Map([[0, elementType], [1, elementType], [2, elementType]])) });
 

From bfc85a1f42144f92696948349a1e874d9e0dc399 Mon Sep 17 00:00:00 2001
From: Lukas Rohde <lukas.rohde@silupe.de>
Date: Mon, 11 Aug 2025 18:17:00 +0200
Subject: [PATCH 144/153] refactor(typing): simplify typing of function calls

---
 src/typing/subtyping/infer.ts | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/src/typing/subtyping/infer.ts b/src/typing/subtyping/infer.ts
index 8e7bec4fbca..38a26d677db 100644
--- a/src/typing/subtyping/infer.ts
+++ b/src/typing/subtyping/infer.ts
@@ -209,9 +209,9 @@ class TypeInferringCfgGuidedVisitor<
 			guard(argNode !== undefined, 'Expected argument node to be defined');
 
 			if(arg.name !== undefined) {
-				constrain(argNode.info.typeVariable, getParameterTypeFromFunction(templateFunctionType, arg.name), this.constraintCache, this.prunableVariables);
+				this.constrainNodeType(argNode, getParameterTypeFromFunction(templateFunctionType, arg.name));
 			} else {
-				constrain(argNode.info.typeVariable, getParameterTypeFromFunction(templateFunctionType, index), this.constraintCache, this.prunableVariables);
+				this.constrainNodeType(argNode, getParameterTypeFromFunction(templateFunctionType, index));
 			}
 		}
 		constrain(calledFunctionType, templateFunctionType, this.constraintCache, this.prunableVariables);

From 08b3771f0a20958dd752d1ff8b911e392c46bda9 Mon Sep 17 00:00:00 2001
From: Lukas Rohde <lukas.rohde@silupe.de>
Date: Tue, 12 Aug 2025 09:05:15 +0200
Subject: [PATCH 145/153] refactor(typing): remove compression for datatype
 query results

---
 src/cli/repl/commands/repl-query.ts | 3 +--
 1 file changed, 1 insertion(+), 2 deletions(-)

diff --git a/src/cli/repl/commands/repl-query.ts b/src/cli/repl/commands/repl-query.ts
index 740f0d5009c..45c38a6ae26 100644
--- a/src/cli/repl/commands/repl-query.ts
+++ b/src/cli/repl/commands/repl-query.ts
@@ -11,7 +11,6 @@ import type { PipelineOutput } from '../../../core/steps/pipeline/pipeline';
 import { jsonReplacer } from '../../../util/json';
 import { asciiSummaryOfQueryResult } from '../../../queries/query-print';
 import type { KnownParser } from '../../../r-bridge/parser';
-import { compressToBase64 } from 'lz-string';
 import type { FlowrConfigOptions } from '../../../config';
 
 
@@ -97,7 +96,7 @@ export const queryStarCommand: ReplCommand = {
 	fn:           async({ output, parser, remainingLine, config }) => {
 		const results = await processQueryArgs(remainingLine, parser, output, config);
 		if(results) {
-			output.stdout(compressToBase64(JSON.stringify(results.query, jsonReplacer)));
+			output.stdout(JSON.stringify(results.query, jsonReplacer));
 		}
 	}
 };

From 695c00e185705abbf1e9344c7ff7cb4dbd9e5288 Mon Sep 17 00:00:00 2001
From: Lukas Rohde <lukas.rohde@silupe.de>
Date: Tue, 12 Aug 2025 09:06:10 +0200
Subject: [PATCH 146/153] wip(typing): add test code file and log statements
 for debugging

---
 test.R                                                          | 1 +
 .../_helper/typing/subtyping/assert-inferred-type.ts            | 2 ++
 2 files changed, 3 insertions(+)
 create mode 100644 test.R

diff --git a/test.R b/test.R
new file mode 100644
index 00000000000..b98972e9d62
--- /dev/null
+++ b/test.R
@@ -0,0 +1 @@
+cost <- function(price, quantity) sum(price * quantity); cost("5.50€", 2)
\ No newline at end of file
diff --git a/test/functionality/_helper/typing/subtyping/assert-inferred-type.ts b/test/functionality/_helper/typing/subtyping/assert-inferred-type.ts
index 0eb42b3d740..0edeb47bbab 100644
--- a/test/functionality/_helper/typing/subtyping/assert-inferred-type.ts
+++ b/test/functionality/_helper/typing/subtyping/assert-inferred-type.ts
@@ -11,6 +11,7 @@ import type { ParentInformation } from '../../../../../src/r-bridge/lang-4.x/ast
 import type { RNode } from '../../../../../src/r-bridge/lang-4.x/ast/model/model';
 import { defaultConfigOptions } from '../../../../../src/config';
 import type { UnresolvedDataType } from '../../../../../src/typing/subtyping/types';
+import { prettyPrintDataType } from '../../../../../src/typing/pretty-print';
 
 export function assertInferredType(input: string, expectedType: { expectedType: DataType } | { lowerBound?: DataType, upperBound?: DataType }, knownTypes?: Map<string, Set<UnresolvedDataType>>): void {
 	assertInferredTypes(input, knownTypes, expectedType);
@@ -43,6 +44,7 @@ export function assertInferredTypes(
 			} else {
 				node = result.normalize.idMap.get(result.dataflow.exitPoints[0].nodeId) as RNode<ParentInformation & DataTypeInfo>;
 			}
+			console.debug(`$${node.info.id} [${node.lexeme}]: {${prettyPrintDataType(node.info.inferredType)}}`);
 
 			test(`Infer ${expectedType.tag} for ${node.lexeme}`, () => {
 				expect(node.info.inferredType).toEqual(expectedType);

From e708d2263920951463131c49b037be2763e95976 Mon Sep 17 00:00:00 2001
From: Lukas Rohde <lukas.rohde@silupe.de>
Date: Tue, 12 Aug 2025 10:06:44 +0200
Subject: [PATCH 147/153] refactor(typing): disambiguate `inferDataTypes` for
 unification

---
 .../catalog/datatype-query/datatype-query-executor.ts     | 8 ++++----
 src/typing/unification/infer.ts                           | 2 +-
 .../_helper/typing/unification/assert-inferred-type.ts    | 6 +++---
 3 files changed, 8 insertions(+), 8 deletions(-)

diff --git a/src/queries/catalog/datatype-query/datatype-query-executor.ts b/src/queries/catalog/datatype-query/datatype-query-executor.ts
index 783d5456361..44f11318136 100644
--- a/src/queries/catalog/datatype-query/datatype-query-executor.ts
+++ b/src/queries/catalog/datatype-query/datatype-query-executor.ts
@@ -4,8 +4,8 @@ import type { BasicQueryData } from '../../base-query-format';
 import type { NormalizedAst, ParentInformation } from '../../../r-bridge/lang-4.x/ast/model/processing/decorate';
 import type { SingleSlicingCriterion } from '../../../slicing/criterion/parse';
 import { slicingCriterionToId } from '../../../slicing/criterion/parse';
-import { inferDataTypes } from '../../../typing/unification/infer';
-import { inferDataTypes as inferDataTypesUsingSubtyping } from '../../../typing/subtyping/infer';
+import { inferDataTypesWithUnification } from '../../../typing/unification/infer';
+import { inferDataTypes } from '../../../typing/subtyping/infer';
 import type { UnresolvedDataType } from '../../../typing/subtyping/types';
 import { loadTracedTypes, loadTurcotteTypes } from '../../../typing/adapter/load-type-signatures';
 
@@ -23,8 +23,8 @@ export async function executeDatatypeQuery({ dataflow, ast }: BasicQueryData, qu
 		}
 
 		const typedAst = query.useSubtyping
-			? inferDataTypesUsingSubtyping(ast as NormalizedAst<ParentInformation & { typeVariable?: undefined }>, dataflow, knownTypes)
-			: inferDataTypes(ast as NormalizedAst<ParentInformation & { typeVariable?: undefined }>, dataflow);
+			? inferDataTypes(ast as NormalizedAst<ParentInformation & { typeVariable?: undefined }>, dataflow, knownTypes)
+			: inferDataTypesWithUnification(ast as NormalizedAst<ParentInformation & { typeVariable?: undefined }>, dataflow);
 		for(const criterion of query.criteria ?? typedAst.idMap.keys().map(id => `$${id}` as SingleSlicingCriterion)) {
 			if(result[criterion] !== undefined) {
 				log.warn('Duplicate criterion in datatype query:', criterion);
diff --git a/src/typing/unification/infer.ts b/src/typing/unification/infer.ts
index 006e2a15797..030d169bce0 100644
--- a/src/typing/unification/infer.ts
+++ b/src/typing/unification/infer.ts
@@ -26,7 +26,7 @@ import { RFalse, RTrue } from '../../r-bridge/lang-4.x/convert-values';
 import { resolve, UnresolvedRFunctionType, UnresolvedRListType, UnresolvedRTypeVariable } from './types';
 import { defaultConfigOptions } from '../../config';
 
-export function inferDataTypes<Info extends ParentInformation & { typeVariable?: undefined }>(ast: NormalizedAst<ParentInformation & Info>, dataflowInfo: DataflowInformation): NormalizedAst<Info & DataTypeInfo> {
+export function inferDataTypesWithUnification<Info extends ParentInformation & { typeVariable?: undefined }>(ast: NormalizedAst<ParentInformation & Info>, dataflowInfo: DataflowInformation): NormalizedAst<Info & DataTypeInfo> {
 	const astWithTypeVars = decorateTypeVariables(ast);
 	const controlFlowInfo = extractCfg(astWithTypeVars, defaultConfigOptions, dataflowInfo.graph, ['unique-cf-sets', 'analyze-dead-code', 'remove-dead-code']);
 	const config = {
diff --git a/test/functionality/_helper/typing/unification/assert-inferred-type.ts b/test/functionality/_helper/typing/unification/assert-inferred-type.ts
index 0fcb98ed587..474b152f1de 100644
--- a/test/functionality/_helper/typing/unification/assert-inferred-type.ts
+++ b/test/functionality/_helper/typing/unification/assert-inferred-type.ts
@@ -3,7 +3,7 @@ import { TreeSitterExecutor } from '../../../../../src/r-bridge/lang-4.x/tree-si
 import { createDataflowPipeline } from '../../../../../src/core/steps/pipeline/default-pipelines';
 import { requestFromInput } from '../../../../../src/r-bridge/retriever';
 import type { DataType } from '../../../../../src/typing/types';
-import { inferDataTypes } from '../../../../../src/typing/unification/infer';
+import { inferDataTypesWithUnification } from '../../../../../src/typing/unification/infer';
 import type { FlowrSearch } from '../../../../../src/search/flowr-search-builder';
 import { runSearch } from '../../../../../src/search/flowr-search-executor';
 import { defaultConfigOptions } from '../../../../../src/config';
@@ -12,7 +12,7 @@ export function assertInferredType(input: string, expectedType: DataType): void
 	test(`Infer ${expectedType.tag} for ${input}`, async() => {
 		const executor = new TreeSitterExecutor();
 		const result = await createDataflowPipeline(executor, { request: requestFromInput(input) }, defaultConfigOptions).allRemainingSteps();
-		const typedAst = inferDataTypes(result.normalize, result.dataflow);
+		const typedAst = inferDataTypesWithUnification(result.normalize, result.dataflow);
 		const rootNode = typedAst.ast;
 		expect(rootNode.info.inferredType).toEqual(expectedType);
 	});
@@ -24,7 +24,7 @@ export function assertInferredTypes(
 	describe(`Infer types for ${input}`, async() => {
 		const executor = new TreeSitterExecutor();
 		const result = await createDataflowPipeline(executor, { request: requestFromInput(input) }, defaultConfigOptions).allRemainingSteps();
-		inferDataTypes(result.normalize, result.dataflow);
+		inferDataTypesWithUnification(result.normalize, result.dataflow);
 
 		describe.each(expectations)('Infer $expectedType.tag for query $query', ({ query, expectedType }) => {
 			const searchResult = runSearch(query, { config: defaultConfigOptions, ...result });

From 372417667126771eb279b46a986e6027672008aa Mon Sep 17 00:00:00 2001
From: Lukas Rohde <lukas.rohde@silupe.de>
Date: Tue, 12 Aug 2025 10:07:23 +0200
Subject: [PATCH 148/153] refactor(typing): make subtyping the default in
 queries

---
 src/queries/catalog/datatype-query/datatype-query-executor.ts | 2 +-
 src/queries/catalog/datatype-query/datatype-query-format.ts   | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/src/queries/catalog/datatype-query/datatype-query-executor.ts b/src/queries/catalog/datatype-query/datatype-query-executor.ts
index 44f11318136..4099c4c79a2 100644
--- a/src/queries/catalog/datatype-query/datatype-query-executor.ts
+++ b/src/queries/catalog/datatype-query/datatype-query-executor.ts
@@ -22,7 +22,7 @@ export async function executeDatatypeQuery({ dataflow, ast }: BasicQueryData, qu
 			await loadTracedTypes(knownTypes);
 		}
 
-		const typedAst = query.useSubtyping
+		const typedAst = query.useSubtyping ?? true
 			? inferDataTypes(ast as NormalizedAst<ParentInformation & { typeVariable?: undefined }>, dataflow, knownTypes)
 			: inferDataTypesWithUnification(ast as NormalizedAst<ParentInformation & { typeVariable?: undefined }>, dataflow);
 		for(const criterion of query.criteria ?? typedAst.idMap.keys().map(id => `$${id}` as SingleSlicingCriterion)) {
diff --git a/src/queries/catalog/datatype-query/datatype-query-format.ts b/src/queries/catalog/datatype-query/datatype-query-format.ts
index 24f0179f363..32fa3636600 100644
--- a/src/queries/catalog/datatype-query/datatype-query-format.ts
+++ b/src/queries/catalog/datatype-query/datatype-query-format.ts
@@ -40,7 +40,7 @@ export const DatatypeQueryDefinition = {
 	schema: Joi.object({
 		type:             Joi.string().valid('datatype').required().description('The type of the query.'),
 		criteria:         Joi.array().items(Joi.string()).optional().description('The slicing criteria of the node to get the inferred data type for.'),
-		useSubtyping:     Joi.boolean().optional().default(false).description('Whether to use subtyping to infer the data type.'),
+		useSubtyping:     Joi.boolean().optional().default(true).description('Whether to use subtyping to infer the data type.'),
 		useTurcotteTypes: Joi.boolean().optional().default(true).description('Whether to use Turcotte types for inference.'),
 		useTracedTypes:   Joi.boolean().optional().default(true).description('Whether to use our manually traced types for inference.')
 	}).description('Datatype query used to extract the inferred data type for a node in the normalized AST')

From 11ac68cd79c976ac52d72875b2a3f2ee6b9c1e42 Mon Sep 17 00:00:00 2001
From: Lukas Rohde <lukas.rohde@silupe.de>
Date: Tue, 12 Aug 2025 12:00:42 +0200
Subject: [PATCH 149/153] feat(typing): add option for writing datatype query
 output to a file

---
 .../datatype-query/datatype-query-executor.ts    | 16 +++++++++++++++-
 .../datatype-query/datatype-query-format.ts      |  4 +++-
 2 files changed, 18 insertions(+), 2 deletions(-)

diff --git a/src/queries/catalog/datatype-query/datatype-query-executor.ts b/src/queries/catalog/datatype-query/datatype-query-executor.ts
index 4099c4c79a2..650afffc68e 100644
--- a/src/queries/catalog/datatype-query/datatype-query-executor.ts
+++ b/src/queries/catalog/datatype-query/datatype-query-executor.ts
@@ -8,6 +8,8 @@ import { inferDataTypesWithUnification } from '../../../typing/unification/infer
 import { inferDataTypes } from '../../../typing/subtyping/infer';
 import type { UnresolvedDataType } from '../../../typing/subtyping/types';
 import { loadTracedTypes, loadTurcotteTypes } from '../../../typing/adapter/load-type-signatures';
+import fs from 'fs';
+import { superBigJsonStringify } from '../../../util/json';
 
 export async function executeDatatypeQuery({ dataflow, ast }: BasicQueryData, queries: readonly DatatypeQuery[]): Promise<DatatypeQueryResult> {
 	const start = Date.now();
@@ -41,8 +43,20 @@ export async function executeDatatypeQuery({ dataflow, ast }: BasicQueryData, qu
 		}
 	}
 
-	return {
+	const output = {
 		'.meta':       { timing: Date.now() - start },
 		inferredTypes: result
 	};
+
+	for(const filePath of queries.map(query => query.outputFile).filter(filePath => filePath !== undefined)) {
+		if(fs.existsSync(filePath)) {
+			const stream = fs.createWriteStream(filePath, { flags: 'w' });
+			superBigJsonStringify(output, '', str => stream.write(str));
+			stream.end();
+		} else {
+			log.warn('Output file does not exist:', filePath);
+		}
+	}
+
+	return output;
 }
\ No newline at end of file
diff --git a/src/queries/catalog/datatype-query/datatype-query-format.ts b/src/queries/catalog/datatype-query/datatype-query-format.ts
index 32fa3636600..9ba422f5c9c 100644
--- a/src/queries/catalog/datatype-query/datatype-query-format.ts
+++ b/src/queries/catalog/datatype-query/datatype-query-format.ts
@@ -17,6 +17,7 @@ export interface DatatypeQuery extends BaseQueryFormat {
 	readonly useSubtyping?:     boolean;
 	readonly useTurcotteTypes?: boolean;
 	readonly useTracedTypes?:   boolean;
+	readonly outputFile?:       string;
 }
 
 export interface DatatypeQueryResult extends BaseQueryResult {
@@ -42,6 +43,7 @@ export const DatatypeQueryDefinition = {
 		criteria:         Joi.array().items(Joi.string()).optional().description('The slicing criteria of the node to get the inferred data type for.'),
 		useSubtyping:     Joi.boolean().optional().default(true).description('Whether to use subtyping to infer the data type.'),
 		useTurcotteTypes: Joi.boolean().optional().default(true).description('Whether to use Turcotte types for inference.'),
-		useTracedTypes:   Joi.boolean().optional().default(true).description('Whether to use our manually traced types for inference.')
+		useTracedTypes:   Joi.boolean().optional().default(true).description('Whether to use our manually traced types for inference.'),
+		outputFile:       Joi.string().optional().description('The output file to write the inferred types to.')
 	}).description('Datatype query used to extract the inferred data type for a node in the normalized AST')
 } as const satisfies SupportedQuery<'datatype'>;

From 113822ea2782318ae5233a43bf25007dd3eced91 Mon Sep 17 00:00:00 2001
From: Lukas Rohde <lukas.rohde@silupe.de>
Date: Tue, 12 Aug 2025 13:33:23 +0200
Subject: [PATCH 150/153] feat-fix(typing): fix writing of output files in
 datatype queries

---
 .../catalog/datatype-query/datatype-query-executor.ts       | 6 +++++-
 1 file changed, 5 insertions(+), 1 deletion(-)

diff --git a/src/queries/catalog/datatype-query/datatype-query-executor.ts b/src/queries/catalog/datatype-query/datatype-query-executor.ts
index 650afffc68e..40c5771f975 100644
--- a/src/queries/catalog/datatype-query/datatype-query-executor.ts
+++ b/src/queries/catalog/datatype-query/datatype-query-executor.ts
@@ -52,7 +52,11 @@ export async function executeDatatypeQuery({ dataflow, ast }: BasicQueryData, qu
 		if(fs.existsSync(filePath)) {
 			const stream = fs.createWriteStream(filePath, { flags: 'w' });
 			superBigJsonStringify(output, '', str => stream.write(str));
-			stream.end();
+			await new Promise<void>((resolve, reject) => {
+				stream.end();
+				stream.on('error', reject);
+				stream.on('finish', resolve);
+			});
 		} else {
 			log.warn('Output file does not exist:', filePath);
 		}

From bf67bc5cb31b3cbd9beadf5d3caa017b23b7655f Mon Sep 17 00:00:00 2001
From: Lukas Rohde <lukas.rohde@silupe.de>
Date: Tue, 12 Aug 2025 15:06:41 +0200
Subject: [PATCH 151/153] feat(typing): improve caching for `subsumes` check

---
 src/typing/subtyping/types.ts | 52 +++++++++++++++++++++--------------
 1 file changed, 31 insertions(+), 21 deletions(-)

diff --git a/src/typing/subtyping/types.ts b/src/typing/subtyping/types.ts
index c5d4da8e04d..29b87e7befc 100644
--- a/src/typing/subtyping/types.ts
+++ b/src/typing/subtyping/types.ts
@@ -108,6 +108,7 @@ export class UnresolvedRTypeVariable {
 
 
 export function constrain(subtype: UnresolvedDataType, supertype: UnresolvedDataType, cache: Map<UnresolvedDataType, Set<UnresolvedDataType>> = new Map(), prunableVariables: Set<UnresolvedRTypeVariable> = new Set()): boolean {
+	// console.debug('Constraining');
 	// console.debug('Constraining', inspect(subtype, { depth: null, colors: true }), 'to subsume', supertype instanceof UnresolvedRTypeVariable ? supertype.id : inspect(supertype, { depth: null, colors: true }));
 
 	if(subtype === supertype) {
@@ -173,6 +174,7 @@ export function constrain(subtype: UnresolvedDataType, supertype: UnresolvedData
 
 
 export function prune(variable: UnresolvedRTypeVariable, constraintCache: Map<UnresolvedDataType, Set<UnresolvedDataType>> = new Map(), prunableVariables: Set<UnresolvedRTypeVariable>): boolean {
+	// console.debug('Pruning');
 	// console.debug('Pruning variable', variable.id);
 
 	let newConstraintsFound = false;
@@ -246,6 +248,7 @@ export function prune(variable: UnresolvedRTypeVariable, constraintCache: Map<Un
 
 
 export function resolve(type: UnresolvedDataType, isUpperBound?: boolean, cache: Map<UnresolvedRTypeVariable, { lowerBound: DataType, upperBound: DataType, combined: DataType }> = new Map()): DataType {
+	// console.debug('Resolving');
 	// console.debug('Resolving', inspect(type, { depth: null, colors: true }));
 
 	if(type instanceof UnresolvedRTypeVariable) {
@@ -319,6 +322,7 @@ export function resolve(type: UnresolvedDataType, isUpperBound?: boolean, cache:
 }
 
 export function combine(lowerBound: DataType, upperBound: DataType): DataType {
+	// console.debug('Combining');
 	// console.debug('Combining', inspect(lowerBound, { depth: null, colors: true }), 'and', inspect(upperBound, { depth: null, colors: true }));
 
 	if(lowerBound instanceof RFunctionType && upperBound instanceof RFunctionType) {
@@ -353,56 +357,58 @@ export function combine(lowerBound: DataType, upperBound: DataType): DataType {
 	}
 }
 
-export function subsumes(subtype: DataType | UnresolvedDataType, supertype: DataType | UnresolvedDataType, inProcess: Map<DataType | UnresolvedDataType, Set<DataType | UnresolvedDataType>> = new Map()): boolean {
+export function subsumes(subtype: DataType | UnresolvedDataType, supertype: DataType | UnresolvedDataType, cache: Map<DataType | UnresolvedDataType, Map<DataType | UnresolvedDataType, boolean>> = new Map()): boolean {
+	// console.debug('Checking subsumption' + (subtype instanceof UnresolvedRTypeVariable ? ` (variable ${subtype.id})` : ''));
 	// console.debug('Checking if', inspect(subtype, { depth: null, colors: true }), 'subsumes', inspect(supertype, { depth: null, colors: true }));
 
 	if(subtype === supertype) {
 		return true; // If both types are the same, they subsume each other
 	}
 
-	let processedSupertypes = inProcess.get(subtype);
-	if(processedSupertypes?.has(supertype)) {
-		return true; // If we have already processed this pair, we can assume it subsumes
+	let processedSupertypes = cache.get(subtype);
+	const cachedResult = processedSupertypes?.get(supertype);
+	if(cachedResult !== undefined) {
+		return cachedResult; // If we have already processed this pair, we can assume it subsumes
 	}
-	processedSupertypes ??= new Set();
-	processedSupertypes.add(supertype);
-	inProcess.set(subtype, processedSupertypes);
+	processedSupertypes ??= new Map();
+	processedSupertypes.set(supertype, true); // Avoid infinite recursion
+	cache.set(subtype, processedSupertypes);
 
 	let result: boolean;
 
 	if(subtype.tag === DataTypeTag.Error || supertype.tag === DataTypeTag.Error) {
 		result = false; // Error types do not subsume and are not subsumed by any other type
 	} else if(subtype.tag === DataTypeTag.Variable) {
-		result = subsumes(subtype.lowerBound, supertype, inProcess);
+		result = subsumes(subtype.lowerBound, supertype, cache);
 	} else if(supertype.tag === DataTypeTag.Variable) {
-		result = subsumes(subtype, supertype.upperBound, inProcess);
+		result = subsumes(subtype, supertype.upperBound, cache);
 	} else if(subtype.tag === DataTypeTag.Union) {
-		result = subtype.types.values().every(subtype => subsumes(subtype, supertype, inProcess));
+		result = subtype.types.values().every(subtype => subsumes(subtype, supertype, cache));
 	} else if(supertype.tag === DataTypeTag.Union) {
-		result = supertype.types.values().some(supertype => subsumes(subtype, supertype, inProcess));
+		result = supertype.types.values().some(supertype => subsumes(subtype, supertype, cache));
 	} else if(supertype.tag === DataTypeTag.Intersection) {
-		result = supertype.types.values().every(supertype => subsumes(subtype, supertype, inProcess));
+		result = supertype.types.values().every(supertype => subsumes(subtype, supertype, cache));
 	} else if(subtype.tag === DataTypeTag.Intersection) {
-		result = subtype.types.values().some(subtype => subsumes(subtype, supertype, inProcess));
+		result = subtype.types.values().some(subtype => subsumes(subtype, supertype, cache));
 	} else if(subtype.tag === DataTypeTag.List && supertype.tag === DataTypeTag.List) {
 		const subtypeElementIndices = new Set(subtype.indexedElementTypes.keys());
 		const supertypeElementIndices = new Set(supertype.indexedElementTypes.keys());
-		result = subsumes(subtype.elementType, supertype.elementType, inProcess) && subtypeElementIndices.union(supertypeElementIndices).values().every(indexOrName => {
-			return subsumes(subtype.indexedElementTypes.get(indexOrName) ?? new RTypeVariable(), supertype.indexedElementTypes.get(indexOrName) ?? new RTypeVariable(), inProcess);
+		result = subsumes(subtype.elementType, supertype.elementType, cache) && subtypeElementIndices.union(supertypeElementIndices).values().every(indexOrName => {
+			return subsumes(subtype.indexedElementTypes.get(indexOrName) ?? new RTypeVariable(), supertype.indexedElementTypes.get(indexOrName) ?? new RTypeVariable(), cache);
 		});
 	} else if(subtype.tag === DataTypeTag.AtomicVector && supertype.tag === DataTypeTag.AtomicVector) {
-		result = subsumes(subtype.elementType, supertype.elementType, inProcess);
+		result = subsumes(subtype.elementType, supertype.elementType, cache);
 	} else if(isAtomicVectorBaseType(subtype) && supertype.tag === DataTypeTag.AtomicVector) {
 		// A scalar subsumes a vector type if it subsumes the element type of the vector
-		result = subsumes(subtype, supertype.elementType, inProcess);
+		result = subsumes(subtype, supertype.elementType, cache);
 	} else if(subtype.tag === DataTypeTag.AtomicVector && supertype.tag === DataTypeTag.Null) {
-		result = subsumes(subtype.elementType, new RTypeUnion());
+		result = subsumes(subtype.elementType, new RTypeUnion(), cache);
 	} else if(subtype.tag === DataTypeTag.Function && supertype.tag === DataTypeTag.Function) {
 		const subtypeParameterKeys = new Set(subtype.parameterTypes.keys());
 		const supertypeParameterKeys = new Set(supertype.parameterTypes.keys());
-		result = subsumes(subtype.returnType, supertype.returnType, inProcess) && subtypeParameterKeys.intersection(supertypeParameterKeys).values().every(key => {
+		result = subsumes(subtype.returnType, supertype.returnType, cache) && subtypeParameterKeys.intersection(supertypeParameterKeys).values().every(key => {
 			// eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-			return subsumes(supertype.parameterTypes.get(key)!, subtype.parameterTypes.get(key)!, inProcess);
+			return subsumes(supertype.parameterTypes.get(key)!, subtype.parameterTypes.get(key)!, cache);
 		});
 	} else {
 		result = subtype.tag === supertype.tag
@@ -414,12 +420,13 @@ export function subsumes(subtype: DataType | UnresolvedDataType, supertype: Data
 			|| subtype.tag === DataTypeTag.Double && supertype.tag === DataTypeTag.Complex;
 	}
 
-	processedSupertypes?.delete(supertype); // Remove the supertype from the processed set
+	processedSupertypes.set(supertype, result); // Cache the result for this pair
 
 	return result;
 }
 
 export function unresolvedJoin(type1: UnresolvedDataType, type2: UnresolvedDataType, constraintCache: Map<UnresolvedDataType, Set<UnresolvedDataType>>, prunableVariables: Set<UnresolvedRTypeVariable>): UnresolvedDataType {
+	// console.debug('Joining (unresolved)');
 	// console.debug('Joining (unresolved)', type1, 'and', type2);
 
 	if(type1 instanceof RTypeError) {
@@ -522,6 +529,7 @@ export function unresolvedJoin(type1: UnresolvedDataType, type2: UnresolvedDataT
 	return new UnresolvedRTypeUnion(type1, type2);
 }
 export function join(type1: DataType, type2: DataType): DataType {
+	// console.debug('Joining');
 	// console.debug('Joining', type1, 'and', type2);
 
 	if(type1 instanceof RTypeError) {
@@ -598,6 +606,7 @@ export function join(type1: DataType, type2: DataType): DataType {
 }
 
 export function unresolvedMeet(type1: UnresolvedDataType, type2: UnresolvedDataType, constraintCache: Map<UnresolvedDataType, Set<UnresolvedDataType>>, prunableVariables: Set<UnresolvedRTypeVariable>): UnresolvedDataType {
+	// console.debug('Meeting (unresolved)');
 	// console.debug('Meeting (unresolved)', inspect(type1, { depth: null, colors: true }), 'and', inspect(type2, { depth: null, colors: true }));
 
 	if(type1 instanceof RTypeError) {
@@ -696,6 +705,7 @@ export function unresolvedMeet(type1: UnresolvedDataType, type2: UnresolvedDataT
 	return new UnresolvedRTypeIntersection(type1, type2);
 }
 export function meet(type1: DataType, type2: DataType): DataType {
+	// console.debug('Meeting');
 	// console.debug('Meeting', type1, 'and', type2);
 
 	if(type1 instanceof RTypeError) {

From d3eeba343dbe0d8a1ad09e9c466e70a98cd6aa16 Mon Sep 17 00:00:00 2001
From: Lukas Rohde <lukas.rohde@silupe.de>
Date: Tue, 12 Aug 2025 15:11:38 +0200
Subject: [PATCH 152/153] refactor(typing): remove r code file previously used
 for testing

---
 test.R | 1 -
 1 file changed, 1 deletion(-)
 delete mode 100644 test.R

diff --git a/test.R b/test.R
deleted file mode 100644
index b98972e9d62..00000000000
--- a/test.R
+++ /dev/null
@@ -1 +0,0 @@
-cost <- function(price, quantity) sum(price * quantity); cost("5.50€", 2)
\ No newline at end of file

From 44cdaeb4bcc847b6204813acc4136f9c00bc784e Mon Sep 17 00:00:00 2001
From: Lukas Rohde <lukas.rohde@silupe.de>
Date: Wed, 3 Sep 2025 22:20:02 +0200
Subject: [PATCH 153/153] test(typing): add test for null subtyping anomaly

---
 test/functionality/typing/subtyping/subsetting.test.ts | 7 +++++++
 1 file changed, 7 insertions(+)

diff --git a/test/functionality/typing/subtyping/subsetting.test.ts b/test/functionality/typing/subtyping/subsetting.test.ts
index b17271d05bd..b3f3623987f 100644
--- a/test/functionality/typing/subtyping/subsetting.test.ts
+++ b/test/functionality/typing/subtyping/subsetting.test.ts
@@ -101,4 +101,11 @@ describe('Infer types for subsetting expressions', () => {
 		{ query: Q.var('o').last().build(),                    upperBound: new RS4Type() },
 		{ query: Q.all().filter(RType.Access).first().build(), expectedType: new RTypeVariable() },
 	);
+
+	assertInferredTypes(
+		'v <- c(); v[1]; v',
+		undefined,
+		// This test result is expected but suboptimal :(
+		{ query: Q.var('v').last().build(), expectedType: new RAtomicVectorType(new RTypeUnion()) },
+	);
 });
\ No newline at end of file