{
    categories = {
	NSBundle = {
	    STAdditions = STBundleInfo;
	};
	NSInvocation = {
	    STAdditions = "NSInvocation+additions";
	};
	NSObject = {
	    STAdditions = "NSObject+additions";
	    STScripting = STScripting;
	};
    };
    category = {
	"NSBundle(STAdditions)" = STBundleInfo;
	"NSInvocation(STAdditions)" = "NSInvocation+additions";
	"NSObject(STAdditions)" = "NSObject+additions";
	"NSObject(STScripting)" = STScripting;
    };
    class = {
	STActor = STActor;
	STBundleInfo = STBundleInfo;
	STContext = STContext;
	STConversation = STConversation;
	STEngine = STEngine;
	STEnvironment = STEnvironment;
	STEnvironmentDescription = STEnvironmentDescription;
	STFileScript = STFileScript;
	STLanguage = STLanguage;
	STLanguageManager = STLanguageManager;
	STMethod = STMethod;
	STObjectReference = STObjectReference;
	STRemoteConversation = STRemoteConversation;
	STScript = STScript;
	STScriptObject = STScriptObject;
	STScriptsManager = STScriptsManager;
	STSelector = STSelector;
	STUndefinedObject = STUndefinedObject;
    };
    classvars = {
	STActor = {
	    environment = STActor;
	    ivars = STActor;
	    methodDictionary = STActor;
	};
	STBundleInfo = {
	    allClasses = STBundleInfo;
	    bundle = STBundleInfo;
	    objectReferenceDictionary = STBundleInfo;
	    publicClasses = STBundleInfo;
	    scriptingInfoClass = STBundleInfo;
	    scriptingInfoClassName = STBundleInfo;
	    useAllClasses = STBundleInfo;
	};
	STContext = {
	    createsUnknownObjects = STContext;
	    fullScripting = STContext;
	    objectDictionary = STContext;
	    parentContext = STContext;
	};
	STEnvironment = {
	    classes = STEnvironment;
	    description = STEnvironment;
	    infoCache = STEnvironment;
	    loadedBundles = STEnvironment;
	    objectFinders = STEnvironment;
	};
	STEnvironmentDescription = {
	    aliases = STEnvironmentDescription;
	    behaviours = STEnvironmentDescription;
	    classes = STEnvironmentDescription;
	    finders = STEnvironmentDescription;
	    frameworks = STEnvironmentDescription;
	    modules = STEnvironmentDescription;
	    restriction = STEnvironmentDescription;
	    usedDefs = STEnvironmentDescription;
	};
	STFileScript = {
	    description = STFileScript;
	    fileName = STFileScript;
	    localizedName = STFileScript;
	    menuKey = STFileScript;
	};
	STLanguageManager = {
	    engineClasses = STLanguageManager;
	    fileTypes = STLanguageManager;
	    languageBundles = STLanguageManager;
	    languageInfos = STLanguageManager;
	    languages = STLanguageManager;
	};
	STObjectReference = {
	    identifier = STObjectReference;
	    target = STObjectReference;
	};
	STRemoteConversation = {
	    connection = STRemoteConversation;
	    environmentName = STRemoteConversation;
	    environmentProcess = STRemoteConversation;
	    hostName = STRemoteConversation;
	    proxy = STRemoteConversation;
	};
	STScript = {
	    language = STScript;
	    source = STScript;
	};
	STScriptObject = {
	    environment = STScriptObject;
	    ivars = STScriptObject;
	    methodDictionary = STScriptObject;
	};
	STScriptsManager = {
	    scriptSearchPaths = STScriptsManager;
	    scriptsDomainName = STScriptsManager;
	};
	STSelector = {
	    sel = STSelector;
	    selectorName = STSelector;
	};
    };
    function = {
	STAllObjectiveCClasses = STObjCRuntime;
	STAllObjectiveCSelectors = STObjCRuntime;
	STClassDictionaryWithNames = STObjCRuntime;
	STConstructMethodSignatureForSelector = STObjCRuntime;
	STFindAllResources = STFunctions;
	STFindResource = STFunctions;
	STGetFoundationConstants = STObjCRuntime;
	STGetValueOfTypeFromObject = "NSInvocation+additions";
	STMethodSignatureForSelector = STObjCRuntime;
	STObjectFromValueOfType = "NSInvocation+additions";
	STSelectorFromString = STObjCRuntime;
	STSelectorFromValue = STObjCRuntime;
	STUserConfigPath = STFunctions;
	STValueFromSelector = STObjCRuntime;
    };
    ivariable = {
	aliases = {
	    STEnvironmentDescription = STEnvironmentDescription;
	};
	allClasses = {
	    STBundleInfo = STBundleInfo;
	};
	behaviours = {
	    STEnvironmentDescription = STEnvironmentDescription;
	};
	bundle = {
	    STBundleInfo = STBundleInfo;
	};
	classes = {
	    STEnvironment = STEnvironment;
	    STEnvironmentDescription = STEnvironmentDescription;
	};
	connection = {
	    STRemoteConversation = STRemoteConversation;
	};
	createsUnknownObjects = {
	    STContext = STContext;
	};
	description = {
	    STEnvironment = STEnvironment;
	    STFileScript = STFileScript;
	};
	engineClasses = {
	    STLanguageManager = STLanguageManager;
	};
	environment = {
	    STActor = STActor;
	    STScriptObject = STScriptObject;
	};
	environmentName = {
	    STRemoteConversation = STRemoteConversation;
	};
	environmentProcess = {
	    STRemoteConversation = STRemoteConversation;
	};
	fileName = {
	    STFileScript = STFileScript;
	};
	fileTypes = {
	    STLanguageManager = STLanguageManager;
	};
	finders = {
	    STEnvironmentDescription = STEnvironmentDescription;
	};
	frameworks = {
	    STEnvironmentDescription = STEnvironmentDescription;
	};
	fullScripting = {
	    STContext = STContext;
	};
	hostName = {
	    STRemoteConversation = STRemoteConversation;
	};
	identifier = {
	    STObjectReference = STObjectReference;
	};
	infoCache = {
	    STEnvironment = STEnvironment;
	};
	ivars = {
	    STActor = STActor;
	    STScriptObject = STScriptObject;
	};
	language = {
	    STScript = STScript;
	};
	languageBundles = {
	    STLanguageManager = STLanguageManager;
	};
	languageInfos = {
	    STLanguageManager = STLanguageManager;
	};
	languages = {
	    STLanguageManager = STLanguageManager;
	};
	loadedBundles = {
	    STEnvironment = STEnvironment;
	};
	localizedName = {
	    STFileScript = STFileScript;
	};
	menuKey = {
	    STFileScript = STFileScript;
	};
	methodDictionary = {
	    STActor = STActor;
	    STScriptObject = STScriptObject;
	};
	modules = {
	    STEnvironmentDescription = STEnvironmentDescription;
	};
	objectDictionary = {
	    STContext = STContext;
	};
	objectFinders = {
	    STEnvironment = STEnvironment;
	};
	objectReferenceDictionary = {
	    STBundleInfo = STBundleInfo;
	};
	parentContext = {
	    STContext = STContext;
	};
	proxy = {
	    STRemoteConversation = STRemoteConversation;
	};
	publicClasses = {
	    STBundleInfo = STBundleInfo;
	};
	restriction = {
	    STEnvironmentDescription = STEnvironmentDescription;
	};
	scriptSearchPaths = {
	    STScriptsManager = STScriptsManager;
	};
	scriptingInfoClass = {
	    STBundleInfo = STBundleInfo;
	};
	scriptingInfoClassName = {
	    STBundleInfo = STBundleInfo;
	};
	scriptsDomainName = {
	    STScriptsManager = STScriptsManager;
	};
	sel = {
	    STSelector = STSelector;
	};
	selectorName = {
	    STSelector = STSelector;
	};
	source = {
	    STScript = STScript;
	};
	target = {
	    STObjectReference = STObjectReference;
	};
	useAllClasses = {
	    STBundleInfo = STBundleInfo;
	};
	usedDefs = {
	    STEnvironmentDescription = STEnvironmentDescription;
	};
    };
    method = {
	"+actorInEnvironment:" = {
	    STActor = STActor;
	};
	"+allFrameworkNames" = {
	    NSBundle = STBundleInfo;
	};
	"+allKnownFileTypes" = {
	    STLanguage = STLanguage;
	};
	"+allLanguageNames" = {
	    STLanguage = STLanguage;
	};
	"+bundleForFrameworkWithName:" = {
	    NSBundle = STBundleInfo;
	};
	"+classForScripting" = {
	    "(STScripting)" = STScripting;
	};
	"+className" = {
	    "(STScripting)" = STScripting;
	};
	"+conversationWithEnvironment:language:" = {
	    STConversation = STConversation;
	};
	"+defaultDescriptionName" = {
	    STEnvironmentDescription = STEnvironmentDescription;
	};
	"+defaultLanguageName" = {
	    STLanguage = STLanguage;
	};
	"+defaultManager" = {
	    STLanguageManager = STLanguageManager;
	    STScriptsManager = STScriptsManager;
	};
	"+defaultScriptingEnvironment" = {
	    STEnvironment = STEnvironment;
	};
	"+descriptionFromDictionary:" = {
	    STEnvironmentDescription = STEnvironmentDescription;
	};
	"+descriptionWithName:" = {
	    STEnvironmentDescription = STEnvironmentDescription;
	};
	"+engineForFileType:" = {
	    STEngine = STEngine;
	};
	"+engineForLanguage:" = {
	    STEngine = STEngine;
	};
	"+engineForLanguageWithName:" = {
	    STEngine = STEngine;
	};
	"+environmentWithDefaultDescription" = {
	    STEnvironment = STEnvironment;
	};
	"+environmentWithDescription:" = {
	    STEnvironment = STEnvironment;
	};
	"+environmentWithDescriptionName:" = {
	    STEnvironment = STEnvironment;
	};
	"+infoForBundle:" = {
	    STBundleInfo = STBundleInfo;
	};
	"+invocationWithTarget:selector:" = {
	    NSInvocation = "NSInvocation+additions";
	};
	"+invocationWithTarget:selectorName:" = {
	    NSInvocation = "NSInvocation+additions";
	};
	"+isClass" = {
	    "(STScripting)" = STScripting;
	};
	"+languageForFileType:" = {
	    STLanguage = STLanguage;
	};
	"+languageNameForFileType:" = {
	    STLanguage = STLanguage;
	};
	"+languageWithName:" = {
	    STLanguage = STLanguage;
	};
	"+languageWithPath:" = {
	    STLanguage = STLanguage;
	};
	"+pathForFrameworkWithName:" = {
	    NSBundle = STBundleInfo;
	};
	"+scriptObject" = {
	    STScriptObject = STScriptObject;
	};
	"+scriptWithFile:" = {
	    STFileScript = STFileScript;
	    STScript = STScript;
	};
	"+scriptWithSource:language:" = {
	    STScript = STScript;
	};
	"+sharedEnvironment" = {
	    STEnvironment = STEnvironment;
	};
	"+stepTalkBundleNames" = {
	    NSBundle = STBundleInfo;
	};
	"+stepTalkBundleWithName:" = {
	    NSBundle = STBundleInfo;
	};
	"-addClassesWithNames:" = {
	    STEnvironment = STEnvironment;
	};
	"-addMethod:" = {
	    STActor = STActor;
	    STScriptObject = STScriptObject;
	};
	"-addNamedObjectsFromDictionary:" = {
	    STContext = STContext;
	    STEnvironment = STEnvironment;
	};
	"-allClassNames" = {
	    STBundleInfo = STBundleInfo;
	};
	"-allScripts" = {
	    STScriptsManager = STScriptsManager;
	};
	"-availableLanguages" = {
	    STLanguageManager = STLanguageManager;
	};
	"-bundleForLanguage:" = {
	    STLanguageManager = STLanguageManager;
	};
	"-canInterpret:" = {
	    STEngine = STEngine;
	};
	"-classForScripting" = {
	    "(STScripting)" = STScripting;
	};
	"-className" = {
	    "(STScripting)" = STScripting;
	};
	"-classes" = {
	    STEnvironmentDescription = STEnvironmentDescription;
	};
	"-compareByLocalizedName:" = {
	    STFileScript = STFileScript;
	    STScript = STScript;
	};
	"-context" = {
	    STConversation = STConversation;
	};
	"-createEngineForLanguage:" = {
	    STLanguageManager = STLanguageManager;
	};
	"-createsUnknownObjects" = {
	    STContext = STContext;
	    STEnvironment = STEnvironment;
	};
	"-defaultEnvironment" = {
	    STEngine = STEngine;
	};
	"-defaultLanguage" = {
	    STLanguageManager = STLanguageManager;
	};
	"-engine" = {
	    STLanguage = STLanguage;
	};
	"-engineClassForLanguage:" = {
	    STLanguageManager = STLanguageManager;
	};
	"-environment" = {
	    STActor = STActor;
	    STConversation = STConversation;
	    STScriptObject = STScriptObject;
	};
	"-executeCode:" = {
	    STEngine = STEngine;
	};
	"-executeCode:inEnvironment:" = {
	    STEngine = STEngine;
	};
	"-executeMethod:forReceiver:withArguments:inEnvironment:" = {
	    STEngine = STEngine;
	};
	"-executeMethod:forScriptObject:" = {
	    STEngine = STEngine;
	};
	"-fileName" = {
	    STFileScript = STFileScript;
	    STScript = STScript;
	};
	"-frameworks" = {
	    STEnvironmentDescription = STEnvironmentDescription;
	};
	"-fullScriptingEnabled" = {
	    STContext = STContext;
	    STEnvironment = STEnvironment;
	};
	"-getArgumentAsObjectAtIndex:" = {
	    NSInvocation = "NSInvocation+additions";
	};
	"-identifier" = {
	    STObjectReference = STObjectReference;
	};
	"-includeBundle:" = {
	    STEnvironment = STEnvironment;
	};
	"-includeFramework:" = {
	    STEnvironment = STEnvironment;
	};
	"-initDefault" = {
	    STEnvironment = STEnvironment;
	};
	"-initFromDictionary:" = {
	    STEnvironmentDescription = STEnvironmentDescription;
	};
	"-initWithBundle:" = {
	    STBundleInfo = STBundleInfo;
	};
	"-initWithContext:language:" = {
	    STConversation = STConversation;
	};
	"-initWithDefaultDescription" = {
	    STEnvironment = STEnvironment;
	};
	"-initWithDescription:" = {
	    STEnvironment = STEnvironment;
	};
	"-initWithDescriptionName:" = {
	    STEnvironment = STEnvironment;
	};
	"-initWithDomainName:" = {
	    STScriptsManager = STScriptsManager;
	};
	"-initWithEnvironment:" = {
	    STActor = STActor;
	};
	"-initWithEnvironment:language:" = {
	    STConversation = STConversation;
	};
	"-initWithEnvironmentName:host:language:" = {
	    STRemoteConversation = STRemoteConversation;
	};
	"-initWithFile:" = {
	    STFileScript = STFileScript;
	    STScript = STScript;
	};
	"-initWithIdentifier:target:" = {
	    STObjectReference = STObjectReference;
	};
	"-initWithInstanceVariableNames:" = {
	    STScriptObject = STScriptObject;
	};
	"-initWithName:" = {
	    STEnvironmentDescription = STEnvironmentDescription;
	    STSelector = STSelector;
	};
	"-initWithObjectName:pool:" = {
	    STObjectReference = STObjectReference;
	};
	"-initWithSelector:" = {
	    STSelector = STSelector;
	};
	"-initWithSource:language:" = {
	    STScript = STScript;
	};
	"-instanceVariableNames" = {
	    "(STScriptObject)" = STScriptObject;
	    STScriptObject = STScriptObject;
	};
	"-interpretMethod:forReceiver:withArguments:inContext:" = {
	    STEngine = STEngine;
	};
	"-interpretScript:" = {
	    "(STConversation)" = STConversation;
	};
	"-interpretScript:inContext:" = {
	    STEngine = STEngine;
	};
	"-isClass" = {
	    "(STScripting)" = STScripting;
	};
	"-isNil" = {
	    NSObject = "NSObject+additions";
	};
	"-isSame:" = {
	    NSObject = "NSObject+additions";
	};
	"-knownLanguages" = {
	    "(STConversation)" = STConversation;
	};
	"-knownObjectNames" = {
	    STContext = STContext;
	    STEnvironment = STEnvironment;
	};
	"-language" = {
	    "(STConversation)" = STConversation;
	    STConversation = STConversation;
	    STScript = STScript;
	};
	"-languageName" = {
	    "(STMethod)" = STMethod;
	    STLanguage = STLanguage;
	    STMethod = STMethod;
	};
	"-loadModule:" = {
	    STEnvironment = STEnvironment;
	};
	"-localizedName" = {
	    STFileScript = STFileScript;
	    STScript = STScript;
	};
	"-methodDictionary" = {
	    STActor = STActor;
	    STScriptObject = STScriptObject;
	};
	"-methodFromSource:forReceiver:inContext:" = {
	    STEngine = STEngine;
	};
	"-methodFromSource:forReceiver:inEnvironment:" = {
	    STEngine = STEngine;
	};
	"-methodFromSource:forScriptObject:" = {
	    STEngine = STEngine;
	};
	"-methodName" = {
	    "(STMethod)" = STMethod;
	    STMethod = STMethod;
	};
	"-methodNames" = {
	    STActor = STActor;
	    STScriptObject = STScriptObject;
	};
	"-methodWithName:" = {
	    STActor = STActor;
	    STScriptObject = STScriptObject;
	};
	"-modules" = {
	    STEnvironmentDescription = STEnvironmentDescription;
	};
	"-namedObjects" = {
	    STBundleInfo = STBundleInfo;
	};
	"-notNil" = {
	    NSObject = "NSObject+additions";
	};
	"-object" = {
	    STObjectReference = STObjectReference;
	};
	"-objectDictionary" = {
	    STContext = STContext;
	    STEnvironment = STEnvironment;
	};
	"-objectFinders" = {
	    STEnvironmentDescription = STEnvironmentDescription;
	};
	"-objectForVariable:" = {
	    STScriptObject = STScriptObject;
	};
	"-objectName" = {
	    STObjectReference = STObjectReference;
	};
	"-objectReferenceDictionary" = {
	    STBundleInfo = STBundleInfo;
	};
	"-objectReferenceForObjectWithName:" = {
	    STContext = STContext;
	    STEnvironment = STEnvironment;
	};
	"-objectWithName:" = {
	    STContext = STContext;
	    STEnvironment = STEnvironment;
	};
	"-parentContext" = {
	    STContext = STContext;
	};
	"-pool" = {
	    STObjectReference = STObjectReference;
	};
	"-publicClassNames" = {
	    STBundleInfo = STBundleInfo;
	};
	"-registerObjectFinder:name:" = {
	    STEnvironment = STEnvironment;
	};
	"-registerObjectFinderNamed:" = {
	    STEnvironment = STEnvironment;
	};
	"-removeMethod:" = {
	    STActor = STActor;
	    STScriptObject = STScriptObject;
	};
	"-removeMethodWithName:" = {
	    STActor = STActor;
	    STScriptObject = STScriptObject;
	};
	"-removeObjectFinderWithName:" = {
	    STEnvironment = STEnvironment;
	};
	"-removeObjectWithName:" = {
	    STContext = STContext;
	    STEnvironment = STEnvironment;
	};
	"-result" = {
	    "(STConversation)" = STConversation;
	};
	"-resultByCopy" = {
	    "(STConversation)" = STConversation;
	};
	"-returnValueAsObject" = {
	    NSInvocation = "NSInvocation+additions";
	};
	"-runScriptFromString:" = {
	    STConversation = STConversation;
	};
	"-scriptDescription" = {
	    STFileScript = STFileScript;
	    STScript = STScript;
	};
	"-scriptName" = {
	    STFileScript = STFileScript;
	    STScript = STScript;
	};
	"-scriptSearchPaths" = {
	    STScriptsManager = STScriptsManager;
	};
	"-scriptWithName:" = {
	    STScriptsManager = STScriptsManager;
	};
	"-scriptingInfoDictionary" = {
	    NSBundle = STBundleInfo;
	};
	"-scriptsDomainName" = {
	    STScriptsManager = STScriptsManager;
	};
	"-selectorName" = {
	    STSelector = STSelector;
	};
	"-selectorValue" = {
	    STSelector = STSelector;
	};
	"-setArgumentAsObject:atIndex:" = {
	    NSInvocation = "NSInvocation+additions";
	};
	"-setCreatesUnknownObjects:" = {
	    STContext = STContext;
	    STEnvironment = STEnvironment;
	};
	"-setDefaultEnvironment:" = {
	    STEngine = STEngine;
	};
	"-setEnvironment:" = {
	    STActor = STActor;
	    STScriptObject = STScriptObject;
	};
	"-setFullScriptingEnabled:" = {
	    STContext = STContext;
	    STEnvironment = STEnvironment;
	};
	"-setLanguage:" = {
	    "(STConversation)" = STConversation;
	    STConversation = STConversation;
	    STScript = STScript;
	};
	"-setObject:" = {
	    STObjectReference = STObjectReference;
	};
	"-setObject:forName:" = {
	    STContext = STContext;
	    STEnvironment = STEnvironment;
	};
	"-setObject:forVariable:" = {
	    STScriptObject = STScriptObject;
	};
	"-setObjectName:" = {
	    STObjectReference = STObjectReference;
	};
	"-setParentContext:" = {
	    STContext = STContext;
	};
	"-setPool:" = {
	    STObjectReference = STObjectReference;
	};
	"-setScriptSearchPaths:" = {
	    STScriptsManager = STScriptsManager;
	};
	"-setScriptSearchPathsToDefaults" = {
	    STScriptsManager = STScriptsManager;
	};
	"-setSource:" = {
	    STScript = STScript;
	};
	"-setValue:forOption:" = {
	    STEngine = STEngine;
	};
	"-source" = {
	    "(STMethod)" = STMethod;
	    STMethod = STMethod;
	    STScript = STScript;
	};
	"-stringValue" = {
	    STSelector = STSelector;
	};
	"-target" = {
	    STObjectReference = STObjectReference;
	};
	"-translateSelector:forReceiver:" = {
	    STEnvironment = STEnvironment;
	};
	"-understandsCode:" = {
	    STEngine = STEngine;
	};
	"-updateClassWithName:description:" = {
	    STEnvironmentDescription = STEnvironmentDescription;
	};
	"-updateFromDictionary:" = {
	    STEnvironmentDescription = STEnvironmentDescription;
	};
	"-validScriptSearchPaths" = {
	    STScriptsManager = STScriptsManager;
	};
	"-valueForOption:" = {
	    STEngine = STEngine;
	};
    };
    output = {
	"Headers/StepTalk/NSInvocation+additions.h" = (
	    "../Documentation/Reference/NSInvocation+additions.gsdoc"
	);
	"Headers/StepTalk/NSObject+additions.h" = (
	    "../Documentation/Reference/NSObject+additions.gsdoc"
	);
	Headers/StepTalk/STBundleInfo.h = (
	    ../Documentation/Reference/STBundleInfo.gsdoc
	);
	Headers/StepTalk/STEngine.h = (
	    ../Documentation/Reference/STEngine.gsdoc
	);
	Headers/StepTalk/STEnvironment.h = (
	    ../Documentation/Reference/STEnvironment.gsdoc
	);
	Headers/StepTalk/STExterns.h = (
	    ../Documentation/Reference/STExterns.gsdoc
	);
	Headers/StepTalk/STFunctions.h = (
	    ../Documentation/Reference/STFunctions.gsdoc
	);
	Headers/StepTalk/STLanguage.h = (
	    ../Documentation/Reference/STLanguage.gsdoc
	);
	Headers/StepTalk/STMethod.h = (
	    ../Documentation/Reference/STMethod.gsdoc
	);
	Headers/StepTalk/STObjCRuntime.h = (
	    ../Documentation/Reference/STObjCRuntime.gsdoc
	);
	Headers/StepTalk/STObjectReference.h = (
	    ../Documentation/Reference/STObjectReference.gsdoc
	);
	Headers/StepTalk/STScript.h = (
	    ../Documentation/Reference/STScript.gsdoc
	);
	Headers/StepTalk/STScriptObject.h = (
	    ../Documentation/Reference/STScriptObject.gsdoc
	);
	Headers/StepTalk/STScripting.h = (
	    ../Documentation/Reference/STScripting.gsdoc
	);
	Headers/StepTalk/STScriptsManager.h = (
	    ../Documentation/Reference/STScriptsManager.gsdoc
	);
	Headers/StepTalk/STSelector.h = (
	    ../Documentation/Reference/STSelector.gsdoc
	);
	Headers/StepTalk/STUndefinedObject.h = (
	    ../Documentation/Reference/STUndefinedObject.gsdoc
	);
	"NSInvocation+additions.h" = (
	    "../../Documentation/Reference/NSInvocation+additions.gsdoc"
	);
	"NSObject+additions.h" = (
	    "../../Documentation/Reference/NSObject+additions.gsdoc"
	);
	STActor.h = (
	    ../../Documentation/Reference/STActor.gsdoc
	);
	STBundleInfo.h = (
	    ../../Documentation/Reference/STBundleInfo.gsdoc
	);
	STContext.h = (
	    ../../Documentation/Reference/STContext.gsdoc
	);
	STConversation.h = (
	    ../../Documentation/Reference/STConversation.gsdoc
	);
	STEngine.h = (
	    ../../Documentation/Reference/STEngine.gsdoc
	);
	STEnvironment.h = (
	    ../../Documentation/Reference/STEnvironment.gsdoc
	);
	STEnvironmentDescription.h = (
	    ../../Documentation/Reference/STEnvironmentDescription.gsdoc
	);
	STExterns.h = (
	    ../../Documentation/Reference/STExterns.gsdoc
	);
	STFileScript.h = (
	    ../../Documentation/Reference/STFileScript.gsdoc
	);
	STFunctions.h = (
	    ../../Documentation/Reference/STFunctions.gsdoc
	);
	STLanguage.h = (
	    ../../Documentation/Reference/STLanguage.gsdoc
	);
	STLanguageManager.h = (
	    ../../Documentation/Reference/STLanguageManager.gsdoc
	);
	STMethod.h = (
	    ../../Documentation/Reference/STMethod.gsdoc
	);
	STObjCRuntime.h = (
	    ../../Documentation/Reference/STObjCRuntime.gsdoc
	);
	STObjectReference.h = (
	    ../../Documentation/Reference/STObjectReference.gsdoc
	);
	STRemoteConversation.h = (
	    ../../Documentation/Reference/STRemoteConversation.gsdoc
	);
	STScript.h = (
	    ../../Documentation/Reference/STScript.gsdoc
	);
	STScriptObject.h = (
	    ../../Documentation/Reference/STScriptObject.gsdoc
	);
	STScripting.h = (
	    ../../Documentation/Reference/STScripting.gsdoc
	);
	STScriptsManager.h = (
	    ../../Documentation/Reference/STScriptsManager.gsdoc
	);
	STSelector.h = (
	    ../../Documentation/Reference/STSelector.gsdoc
	);
	STUndefinedObject.h = (
	    ../../Documentation/Reference/STUndefinedObject.gsdoc
	);
    };
    protocol = {
	"(STConversation)" = STConversation;
	"(STMethod)" = STMethod;
	"(STScriptObject)" = STScriptObject;
	"(STScripting)" = STScripting;
    };
    source = {
	"Headers/StepTalk/NSInvocation+additions.h" = (
	    "NSInvocation+additions.m"
	);
	"Headers/StepTalk/NSObject+additions.h" = (
	    "NSObject+additions.m"
	);
	Headers/StepTalk/STBundleInfo.h = (
	    STBundleInfo.m
	);
	Headers/StepTalk/STEngine.h = (
	    STEngine.m
	);
	Headers/StepTalk/STEnvironment.h = (
	    STEnvironment.m
	);
	Headers/StepTalk/STExterns.h = (
	    STExterns.m
	);
	Headers/StepTalk/STFunctions.h = (
	    STFunctions.m
	);
	Headers/StepTalk/STLanguage.h = (
	    STLanguage.m
	);
	Headers/StepTalk/STMethod.h = (
	    STMethod.m
	);
	Headers/StepTalk/STObjCRuntime.h = (
	    STObjCRuntime.m
	);
	Headers/StepTalk/STObjectReference.h = (
	    STObjectReference.m
	);
	Headers/StepTalk/STScript.h = (
	    STScript.m
	);
	Headers/StepTalk/STScriptObject.h = (
	    STScriptObject.m
	);
	Headers/StepTalk/STScripting.h = (
	    STScripting.m
	);
	Headers/StepTalk/STScriptsManager.h = (
	    STScriptsManager.m
	);
	Headers/StepTalk/STSelector.h = (
	    STSelector.m
	);
	Headers/StepTalk/STUndefinedObject.h = (
	    STUndefinedObject.m
	);
	"NSInvocation+additions.h" = (
	    "NSInvocation+additions.m"
	);
	"NSObject+additions.h" = (
	    "NSObject+additions.m"
	);
	STActor.h = (
	    STActor.m
	);
	STBundleInfo.h = (
	    STBundleInfo.m
	);
	STContext.h = (
	    STContext.m
	);
	STConversation.h = (
	    STConversation.m
	);
	STEngine.h = (
	    STEngine.m
	);
	STEnvironment.h = (
	    STEnvironment.m
	);
	STEnvironmentDescription.h = (
	    STEnvironmentDescription.m
	);
	STExterns.h = (
	    STExterns.m
	);
	STFileScript.h = (
	    STFileScript.m
	);
	STFunctions.h = (
	    STFunctions.m
	);
	STLanguage.h = (
	    STLanguage.m
	);
	STLanguageManager.h = (
	    STLanguageManager.m
	);
	STMethod.h = (
	    STMethod.m
	);
	STObjCRuntime.h = (
	    STObjCRuntime.m
	);
	STObjectReference.h = (
	    STObjectReference.m
	);
	STRemoteConversation.h = (
	    STRemoteConversation.m
	);
	STScript.h = (
	    STScript.m
	);
	STScriptObject.h = (
	    STScriptObject.m
	);
	STScripting.h = (
	    STScripting.m
	);
	STScriptsManager.h = (
	    STScriptsManager.m
	);
	STSelector.h = (
	    STSelector.m
	);
	STUndefinedObject.h = (
	    STUndefinedObject.m
	);
    };
    super = {
	STActor = NSObject;
	STBundleInfo = NSObject;
	STContext = NSObject;
	STConversation = NSObject;
	STEngine = NSObject;
	STEnvironment = STContext;
	STEnvironmentDescription = NSObject;
	STFileScript = STScript;
	STLanguage = NSBundle;
	STLanguageManager = NSObject;
	STMethod = NSObject;
	STObjectReference = NSObject;
	STRemoteConversation = STConversation;
	STScript = NSObject;
	STScriptObject = NSObject;
	STScriptsManager = NSObject;
	STSelector = NSObject;
	STUndefinedObject = NSObject;
    };
    title = {
	"NSInvocation+additions" = "NSInvocation class additions";
	"NSObject+additions" = "NSObject+additions documentation";
	STActor = "STActor class documentation";
	STBundleInfo = "STBundleInfo class documentation";
	STContext = "STEnvironment class reference";
	STConversation = "STConversation class documentation";
	STEngine = "STEngine class documentation";
	STEnvironment = "STEnvironment class reference";
	STEnvironmentDescription = "STEnvironmentDescription class documentation";
	STExterns = "STExterns documentation";
	STFileScript = "STFileScript class documentation";
	STFunctions = "STFunctions documentation";
	STLanguage = "STLanguage class documentation";
	STLanguageManager = "STLanguageManager class documentation";
	STMethod = "STMethod documentation";
	STObjCRuntime = "STObjCRuntime documentation";
	STObjectReference = "STObjectReference class documentation";
	STRemoteConversation = "STRemoteConversation class documentation";
	STScript = "STScript class documentation";
	STScriptObject = "STScriptObject class documentation";
	STScripting = "STScripting protocol documentation";
	STScriptsManager = "STScriptsManager class documentation";
	STSelector = "STSelector class documentation";
	STUndefinedObject = "STUndefinedObject class documentation";
	StepTalk = "StepTalk Documentation";
    };
    unitmethods = {
	"(STConversation)" = {
	    "-interpretScript:" = STConversation;
	    "-knownLanguages" = STConversation;
	    "-language" = STConversation;
	    "-result" = STConversation;
	    "-resultByCopy" = STConversation;
	    "-setLanguage:" = STConversation;
	};
	"(STMethod)" = {
	    "-languageName" = STMethod;
	    "-methodName" = STMethod;
	    "-source" = STMethod;
	};
	"(STScriptObject)" = {
	    "-instanceVariableNames" = STScriptObject;
	};
	"(STScripting)" = {
	    "+classForScripting" = STScripting;
	    "+className" = STScripting;
	    "+isClass" = STScripting;
	    "-classForScripting" = STScripting;
	    "-className" = STScripting;
	    "-isClass" = STScripting;
	};
	"NSBundle(STAdditions)" = {
	    "+allFrameworkNames" = STBundleInfo;
	    "+bundleForFrameworkWithName:" = STBundleInfo;
	    "+pathForFrameworkWithName:" = STBundleInfo;
	    "+stepTalkBundleNames" = STBundleInfo;
	    "+stepTalkBundleWithName:" = STBundleInfo;
	    "-scriptingInfoDictionary" = STBundleInfo;
	};
	"NSInvocation(STAdditions)" = {
	    "+invocationWithTarget:selector:" = "NSInvocation+additions";
	    "+invocationWithTarget:selectorName:" = "NSInvocation+additions";
	    "-getArgumentAsObjectAtIndex:" = "NSInvocation+additions";
	    "-returnValueAsObject" = "NSInvocation+additions";
	    "-setArgumentAsObject:atIndex:" = "NSInvocation+additions";
	};
	"NSObject(STAdditions)" = {
	    "-isNil" = "NSObject+additions";
	    "-isSame:" = "NSObject+additions";
	    "-notNil" = "NSObject+additions";
	};
	STActor = {
	    "+actorInEnvironment:" = STActor;
	    "-addMethod:" = STActor;
	    "-environment" = STActor;
	    "-initWithEnvironment:" = STActor;
	    "-methodDictionary" = STActor;
	    "-methodNames" = STActor;
	    "-methodWithName:" = STActor;
	    "-removeMethod:" = STActor;
	    "-removeMethodWithName:" = STActor;
	    "-setEnvironment:" = STActor;
	};
	STBundleInfo = {
	    "+infoForBundle:" = STBundleInfo;
	    "-allClassNames" = STBundleInfo;
	    "-initWithBundle:" = STBundleInfo;
	    "-namedObjects" = STBundleInfo;
	    "-objectReferenceDictionary" = STBundleInfo;
	    "-publicClassNames" = STBundleInfo;
	};
	STContext = {
	    "-addNamedObjectsFromDictionary:" = STContext;
	    "-createsUnknownObjects" = STContext;
	    "-fullScriptingEnabled" = STContext;
	    "-knownObjectNames" = STContext;
	    "-objectDictionary" = STContext;
	    "-objectReferenceForObjectWithName:" = STContext;
	    "-objectWithName:" = STContext;
	    "-parentContext" = STContext;
	    "-removeObjectWithName:" = STContext;
	    "-setCreatesUnknownObjects:" = STContext;
	    "-setFullScriptingEnabled:" = STContext;
	    "-setObject:forName:" = STContext;
	    "-setParentContext:" = STContext;
	};
	STConversation = {
	    "+conversationWithEnvironment:language:" = STConversation;
	    "-context" = STConversation;
	    "-environment" = STConversation;
	    "-initWithContext:language:" = STConversation;
	    "-initWithEnvironment:language:" = STConversation;
	    "-language" = STConversation;
	    "-runScriptFromString:" = STConversation;
	    "-setLanguage:" = STConversation;
	};
	STEngine = {
	    "+engineForFileType:" = STEngine;
	    "+engineForLanguage:" = STEngine;
	    "+engineForLanguageWithName:" = STEngine;
	    "-canInterpret:" = STEngine;
	    "-defaultEnvironment" = STEngine;
	    "-executeCode:" = STEngine;
	    "-executeCode:inEnvironment:" = STEngine;
	    "-executeMethod:forReceiver:withArguments:inEnvironment:" = STEngine;
	    "-executeMethod:forScriptObject:" = STEngine;
	    "-interpretMethod:forReceiver:withArguments:inContext:" = STEngine;
	    "-interpretScript:inContext:" = STEngine;
	    "-methodFromSource:forReceiver:inContext:" = STEngine;
	    "-methodFromSource:forReceiver:inEnvironment:" = STEngine;
	    "-methodFromSource:forScriptObject:" = STEngine;
	    "-setDefaultEnvironment:" = STEngine;
	    "-setValue:forOption:" = STEngine;
	    "-understandsCode:" = STEngine;
	    "-valueForOption:" = STEngine;
	};
	STEnvironment = {
	    "+defaultScriptingEnvironment" = STEnvironment;
	    "+environmentWithDefaultDescription" = STEnvironment;
	    "+environmentWithDescription:" = STEnvironment;
	    "+environmentWithDescriptionName:" = STEnvironment;
	    "+sharedEnvironment" = STEnvironment;
	    "-addClassesWithNames:" = STEnvironment;
	    "-addNamedObjectsFromDictionary:" = STEnvironment;
	    "-createsUnknownObjects" = STEnvironment;
	    "-fullScriptingEnabled" = STEnvironment;
	    "-includeBundle:" = STEnvironment;
	    "-includeFramework:" = STEnvironment;
	    "-initDefault" = STEnvironment;
	    "-initWithDefaultDescription" = STEnvironment;
	    "-initWithDescription:" = STEnvironment;
	    "-initWithDescriptionName:" = STEnvironment;
	    "-knownObjectNames" = STEnvironment;
	    "-loadModule:" = STEnvironment;
	    "-objectDictionary" = STEnvironment;
	    "-objectReferenceForObjectWithName:" = STEnvironment;
	    "-objectWithName:" = STEnvironment;
	    "-registerObjectFinder:name:" = STEnvironment;
	    "-registerObjectFinderNamed:" = STEnvironment;
	    "-removeObjectFinderWithName:" = STEnvironment;
	    "-removeObjectWithName:" = STEnvironment;
	    "-setCreatesUnknownObjects:" = STEnvironment;
	    "-setFullScriptingEnabled:" = STEnvironment;
	    "-setObject:forName:" = STEnvironment;
	    "-translateSelector:forReceiver:" = STEnvironment;
	};
	STEnvironmentDescription = {
	    "+defaultDescriptionName" = STEnvironmentDescription;
	    "+descriptionFromDictionary:" = STEnvironmentDescription;
	    "+descriptionWithName:" = STEnvironmentDescription;
	    "-classes" = STEnvironmentDescription;
	    "-frameworks" = STEnvironmentDescription;
	    "-initFromDictionary:" = STEnvironmentDescription;
	    "-initWithName:" = STEnvironmentDescription;
	    "-modules" = STEnvironmentDescription;
	    "-objectFinders" = STEnvironmentDescription;
	    "-updateClassWithName:description:" = STEnvironmentDescription;
	    "-updateFromDictionary:" = STEnvironmentDescription;
	};
	STFileScript = {
	    "+scriptWithFile:" = STFileScript;
	    "-compareByLocalizedName:" = STFileScript;
	    "-fileName" = STFileScript;
	    "-initWithFile:" = STFileScript;
	    "-localizedName" = STFileScript;
	    "-scriptDescription" = STFileScript;
	    "-scriptName" = STFileScript;
	};
	STLanguage = {
	    "+allKnownFileTypes" = STLanguage;
	    "+allLanguageNames" = STLanguage;
	    "+defaultLanguageName" = STLanguage;
	    "+languageForFileType:" = STLanguage;
	    "+languageNameForFileType:" = STLanguage;
	    "+languageWithName:" = STLanguage;
	    "+languageWithPath:" = STLanguage;
	    "-engine" = STLanguage;
	    "-languageName" = STLanguage;
	};
	STLanguageManager = {
	    "+defaultManager" = STLanguageManager;
	    "-availableLanguages" = STLanguageManager;
	    "-bundleForLanguage:" = STLanguageManager;
	    "-createEngineForLanguage:" = STLanguageManager;
	    "-defaultLanguage" = STLanguageManager;
	    "-engineClassForLanguage:" = STLanguageManager;
	};
	STMethod = {
	    "-languageName" = STMethod;
	    "-methodName" = STMethod;
	    "-source" = STMethod;
	};
	STObjectReference = {
	    "-identifier" = STObjectReference;
	    "-initWithIdentifier:target:" = STObjectReference;
	    "-initWithObjectName:pool:" = STObjectReference;
	    "-object" = STObjectReference;
	    "-objectName" = STObjectReference;
	    "-pool" = STObjectReference;
	    "-setObject:" = STObjectReference;
	    "-setObjectName:" = STObjectReference;
	    "-setPool:" = STObjectReference;
	    "-target" = STObjectReference;
	};
	STRemoteConversation = {
	    "-initWithEnvironmentName:host:language:" = STRemoteConversation;
	};
	STScript = {
	    "+scriptWithFile:" = STScript;
	    "+scriptWithSource:language:" = STScript;
	    "-compareByLocalizedName:" = STScript;
	    "-fileName" = STScript;
	    "-initWithFile:" = STScript;
	    "-initWithSource:language:" = STScript;
	    "-language" = STScript;
	    "-localizedName" = STScript;
	    "-scriptDescription" = STScript;
	    "-scriptName" = STScript;
	    "-setLanguage:" = STScript;
	    "-setSource:" = STScript;
	    "-source" = STScript;
	};
	STScriptObject = {
	    "+scriptObject" = STScriptObject;
	    "-addMethod:" = STScriptObject;
	    "-environment" = STScriptObject;
	    "-initWithInstanceVariableNames:" = STScriptObject;
	    "-instanceVariableNames" = STScriptObject;
	    "-methodDictionary" = STScriptObject;
	    "-methodNames" = STScriptObject;
	    "-methodWithName:" = STScriptObject;
	    "-objectForVariable:" = STScriptObject;
	    "-removeMethod:" = STScriptObject;
	    "-removeMethodWithName:" = STScriptObject;
	    "-setEnvironment:" = STScriptObject;
	    "-setObject:forVariable:" = STScriptObject;
	};
	STScriptsManager = {
	    "+defaultManager" = STScriptsManager;
	    "-allScripts" = STScriptsManager;
	    "-initWithDomainName:" = STScriptsManager;
	    "-scriptSearchPaths" = STScriptsManager;
	    "-scriptWithName:" = STScriptsManager;
	    "-scriptsDomainName" = STScriptsManager;
	    "-setScriptSearchPaths:" = STScriptsManager;
	    "-setScriptSearchPathsToDefaults" = STScriptsManager;
	    "-validScriptSearchPaths" = STScriptsManager;
	};
	STSelector = {
	    "-initWithName:" = STSelector;
	    "-initWithSelector:" = STSelector;
	    "-selectorName" = STSelector;
	    "-selectorValue" = STSelector;
	    "-stringValue" = STSelector;
	};
    };
    variable = {
	STGenericException = STExterns;
	STInternalInconsistencyException = STExterns;
	STInvalidArgumentException = STExterns;
	STLanguageBundleExtension = STExterns;
	STLanguageBundlesDirectory = STExterns;
	STLanguagesConfigFile = STExterns;
	STLibraryDirectory = STExterns;
	STMallocZone = STExterns;
	STModuleExtension = STExterns;
	STModulesDirectory = STExterns;
	STNil = STExterns;
	STScriptExtension = STExterns;
	STScriptingEnvironmentExtension = STExterns;
	STScriptingEnvironmentsDirectory = STExterns;
	STScriptingException = STExterns;
	STScriptsDirectory = STExterns;
    };
}