ble/ns/main.go

package ns


/*
#cgo CFLAGS: -x objective-c -fno-objc-arc
#cgo LDFLAGS: -framework Foundation -framework CoreBluetooth
#pragma clang diagnostic ignored "-Wformat-security"

#import <Foundation/Foundation.h>
#import <CoreBluetooth/CoreBluetooth.h>

BOOL
NSUUID_IsSubclassOfClass(void* aClass) {
	BOOL ret;
	@autoreleasepool {
		ret = [NSUUID isSubclassOfClass:aClass];
	}
	return ret;

}
void*
NSUUID_Alloc() {
	return [NSUUID alloc];
}
void*
NSUUID_CopyWithZone(void* zone) {
	NSObject* ret;
	@autoreleasepool {
		ret = [NSUUID copyWithZone:zone];
	}
	return ret;

}
void*
NSUUID_MutableCopyWithZone(void* zone) {
	NSObject* ret;
	@autoreleasepool {
		ret = [NSUUID mutableCopyWithZone:zone];
	}
	return ret;

}
void*
NSUUID_New() {
	NSUUID* ret;
	@autoreleasepool {
		ret = [NSUUID new];
	}
	return ret;

}
void* _Nonnull
NSUUID_KeyPathsForValuesAffectingValueForKey(void* key) {
	NSSet* _Nonnull ret;
	@autoreleasepool {
		ret = [NSUUID keyPathsForValuesAffectingValueForKey:key];
	}
	return ret;

}
void* _Nonnull
NSUUID_UUID() {
	NSUUID* _Nonnull ret;
	@autoreleasepool {
		ret = [NSUUID UUID];
		if(ret != nil) { [ret retain]; }
	}
	return ret;

}
void*
selectorFromString(char *s) {
	return NSSelectorFromString([NSString stringWithUTF8String:s]);
}

void*
NSUUID_InstanceMethodSignatureForSelector(void* aSelector) {
	NSMethodSignature* ret;
	@autoreleasepool {
		ret = [NSUUID instanceMethodSignatureForSelector:aSelector];
	}
	return ret;

}
void*
NSUUID_Class() {
	Class ret;
	@autoreleasepool {
		ret = [NSUUID class];
	}
	return ret;

}
void
NSUUID_Load() {
	@autoreleasepool {
		[NSUUID load];
	}
}
void*
NSUUID_DebugDescription() {
	NSString* ret;
	@autoreleasepool {
		ret = [NSUUID debugDescription];
		if(ret != nil) { [ret retain]; }
	}
	return ret;

}
NSInteger
NSUUID_Version() {
	NSInteger ret;
	@autoreleasepool {
		ret = [NSUUID version];
	}
	return ret;

}
void
NSUUID_SetVersion(NSInteger aVersion) {
	@autoreleasepool {
		[NSUUID setVersion:aVersion];
	}
}
BOOL
NSUUID_InstancesRespondToSelector(void* aSelector) {
	BOOL ret;
	@autoreleasepool {
		ret = [NSUUID instancesRespondToSelector:aSelector];
	}
	return ret;

}
void* _Nonnull
NSUUID_ClassForKeyedUnarchiver() {
	Class _Nonnull ret;
	@autoreleasepool {
		ret = [NSUUID classForKeyedUnarchiver];
	}
	return ret;

}
BOOL
NSUUID_ConformsToProtocol(void* protocol) {
	BOOL ret;
	@autoreleasepool {
		ret = [NSUUID conformsToProtocol:protocol];
	}
	return ret;

}
BOOL
NSUUID_ResolveInstanceMethod(void* sel) {
	BOOL ret;
	@autoreleasepool {
		ret = [NSUUID resolveInstanceMethod:sel];
	}
	return ret;

}
void*
NSUUID_Description() {
	NSString* ret;
	@autoreleasepool {
		ret = [NSUUID description];
		if(ret != nil) { [ret retain]; }
	}
	return ret;

}
BOOL
NSUUID_AccessInstanceVariablesDirectly() {
	BOOL ret;
	@autoreleasepool {
		ret = [NSUUID accessInstanceVariablesDirectly];
	}
	return ret;

}
NSUInteger
NSUUID_Hash() {
	NSUInteger ret;
	@autoreleasepool {
		ret = [NSUUID hash];
	}
	return ret;

}
BOOL
NSUUID_AutomaticallyNotifiesObserversForKey(void* key) {
	BOOL ret;
	@autoreleasepool {
		ret = [NSUUID automaticallyNotifiesObserversForKey:key];
	}
	return ret;

}
void
NSUUID_CancelPreviousPerformRequestsWithTarget(void* aTarget) {
	@autoreleasepool {
		[NSUUID cancelPreviousPerformRequestsWithTarget:aTarget];
	}
}
void
NSUUID_CancelPreviousPerformRequestsWithTargetSelector(void* aTarget, void* aSelector, void* anArgument) {
	@autoreleasepool {
		[NSUUID cancelPreviousPerformRequestsWithTarget:aTarget selector:aSelector object:anArgument];
	}
}
void
NSUUID_CancelPreviousPerformRequestsWithTargetSelectorObject(void* aTarget, void* aSelector, void* anArgument) {
	@autoreleasepool {
		[NSUUID cancelPreviousPerformRequestsWithTarget:aTarget selector:aSelector object:anArgument];
	}
}
BOOL
NSUUID_ResolveClassMethod(void* sel) {
	BOOL ret;
	@autoreleasepool {
		ret = [NSUUID resolveClassMethod:sel];
	}
	return ret;

}
void*
NSUUID_AllocWithZone(void* zone) {
	return [NSUUID allocWithZone:zone];
}
void* _Nonnull
NSUUID_ClassFallbacksForKeyedArchiver() {
	NSArray* _Nonnull ret;
	@autoreleasepool {
		ret = [NSUUID classFallbacksForKeyedArchiver];
	}
	return ret;

}
void*
NSUUID_Superclass() {
	Class ret;
	@autoreleasepool {
		ret = [NSUUID superclass];
	}
	return ret;

}
BOOL
NSUUID_SupportsSecureCoding() {
	BOOL ret;
	@autoreleasepool {
		ret = [NSUUID supportsSecureCoding];
	}
	return ret;

}
void* _Nonnull
NSUUID_inst_MutableArrayValueForKey(void* o, void* key) {
	NSMutableArray* _Nonnull ret;
	@autoreleasepool {
		ret = [(NSUUID*)o mutableArrayValueForKey:key];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
void*
NSUUID_inst_ForwardingTargetForSelector(void* o, void* aSelector) {
	NSObject* ret;
	@autoreleasepool {
		ret = [(NSUUID*)o forwardingTargetForSelector:aSelector];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
void
NSUUID_inst_SetValuesForKeysWithDictionary(void* o, void* keyedValues) {
	@autoreleasepool {
		[(NSUUID*)o setValuesForKeysWithDictionary:keyedValues];
	}
}
void
NSUUID_inst_GetUUIDBytes(void* o, void* uuid) {
	@autoreleasepool {
		[(NSUUID*)o getUUIDBytes:uuid];
	}
}
void* _Nonnull
NSUUID_inst_MutableOrderedSetValueForKey(void* o, void* key) {
	NSMutableOrderedSet* _Nonnull ret;
	@autoreleasepool {
		ret = [(NSUUID*)o mutableOrderedSetValueForKey:key];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
void
NSUUID_inst_SetValueForKey(void* o, void* value, void* key) {
	@autoreleasepool {
		[(NSUUID*)o setValue:value forKey:key];
	}
}
void
NSUUID_inst_SetValueForKeyPath(void* o, void* value, void* keyPath) {
	@autoreleasepool {
		[(NSUUID*)o setValue:value forKeyPath:keyPath];
	}
}
void
NSUUID_inst_SetValueForUndefinedKey(void* o, void* value, void* key) {
	@autoreleasepool {
		[(NSUUID*)o setValue:value forUndefinedKey:key];
	}
}
void* _Nullable
NSUUID_inst_ValueForKey(void* o, void* key) {
	NSObject* _Nullable ret;
	@autoreleasepool {
		ret = [(NSUUID*)o valueForKey:key];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
void* _Nullable
NSUUID_inst_ValueAtIndexInPropertyWithKey(void* o, NSUInteger index, void* key) {
	NSObject* _Nullable ret;
	@autoreleasepool {
		ret = [(NSUUID*)o valueAtIndex:index inPropertyWithKey:key];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
void
NSUUID_inst_WillChangeValuesAtIndexes(void* o, NSKeyValueChange changeKind, void* indexes, void* key) {
	@autoreleasepool {
		[(NSUUID*)o willChange:changeKind valuesAtIndexes:indexes forKey:key];
	}
}
void
NSUUID_inst_WillChangeValuesAtIndexesForKey(void* o, NSKeyValueChange changeKind, void* indexes, void* key) {
	@autoreleasepool {
		[(NSUUID*)o willChange:changeKind valuesAtIndexes:indexes forKey:key];
	}
}
void* _Nullable
NSUUID_inst_ClassForArchiver(void* o) {
	Class _Nullable ret;
	@autoreleasepool {
		ret = [(NSUUID*)o classForArchiver];
	}
	return ret;

}
void
NSUUID_inst_SetObservationInfo(void* o, void* observationInfo) {
	@autoreleasepool {
		[(NSUUID*)o setObservationInfo:observationInfo];
	}
}
void* _Nonnull
NSUUID_inst_AttributeKeys(void* o) {
	NSArray* _Nonnull ret;
	@autoreleasepool {
		ret = [(NSUUID*)o attributeKeys];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
void
NSUUID_inst_ObserveValueForKeyPathOfObject(void* o, void* keyPath, void* object, void* change, void* context) {
	@autoreleasepool {
		[(NSUUID*)o observeValueForKeyPath:keyPath ofObject:object change:change context:context];
	}
}
void
NSUUID_inst_ObserveValueForKeyPathOfObjectChange(void* o, void* keyPath, void* object, void* change, void* context) {
	@autoreleasepool {
		[(NSUUID*)o observeValueForKeyPath:keyPath ofObject:object change:change context:context];
	}
}
void*
NSUUID_inst_ObservationInfo(void* o) {
	void* ret;
	@autoreleasepool {
		ret = [(NSUUID*)o observationInfo];
	}
	return ret;

}
BOOL
NSUUID_inst_IsGreaterThanOrEqualTo(void* o, void* object) {
	BOOL ret;
	@autoreleasepool {
		ret = [(NSUUID*)o isGreaterThanOrEqualTo:object];
	}
	return ret;

}
void* _Nonnull
NSUUID_inst_UUIDString(void* o) {
	NSString* _Nonnull ret;
	@autoreleasepool {
		ret = [(NSUUID*)o UUIDString];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
FourCharCode
NSUUID_inst_ClassCode(void* o) {
	FourCharCode ret;
	@autoreleasepool {
		ret = [(NSUUID*)o classCode];
	}
	return ret;

}
void* _Nonnull
NSUUID_inst_DictionaryWithValuesForKeys(void* o, void* keys) {
	NSDictionary* _Nonnull ret;
	@autoreleasepool {
		ret = [(NSUUID*)o dictionaryWithValuesForKeys:keys];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
void* _Nonnull
NSUUID_inst_ClassForCoder(void* o) {
	Class _Nonnull ret;
	@autoreleasepool {
		ret = [(NSUUID*)o classForCoder];
	}
	return ret;

}
void* _Nonnull
NSUUID_inst_ClassDescription(void* o) {
	NSClassDescription* _Nonnull ret;
	@autoreleasepool {
		ret = [(NSUUID*)o classDescription];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
void* _Nullable
NSUUID_inst_ReplacementObjectForKeyedArchiver(void* o, void* archiver) {
	NSObject* _Nullable ret;
	@autoreleasepool {
		ret = [(NSUUID*)o replacementObjectForKeyedArchiver:archiver];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
void* _Nullable
NSUUID_inst_ObjectSpecifier(void* o) {
	NSScriptObjectSpecifier* _Nullable ret;
	@autoreleasepool {
		ret = [(NSUUID*)o objectSpecifier];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
void* _Nonnull
NSUUID_inst_InitWithUUIDBytes(void* o, void* bytes) {
	NSUUID* _Nonnull ret;
	@autoreleasepool {
		ret = [(NSUUID*)o initWithUUIDBytes:bytes];
	}
	return ret;

}
void* _Nullable
NSUUID_inst_ScriptingValueForSpecifier(void* o, void* objectSpecifier) {
	NSObject* _Nullable ret;
	@autoreleasepool {
		ret = [(NSUUID*)o scriptingValueForSpecifier:objectSpecifier];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
void
NSUUID_inst_PerformSelectorInBackgroundWithObject(void* o, void* aSelector, void* arg) {
	@autoreleasepool {
		[(NSUUID*)o performSelectorInBackground:aSelector withObject:arg];
	}
}
BOOL
NSUUID_inst_ScriptingBeginsWith(void* o, void* object) {
	BOOL ret;
	@autoreleasepool {
		ret = [(NSUUID*)o scriptingBeginsWith:object];
	}
	return ret;

}
void* _Nonnull
NSUUID_inst_ClassName(void* o) {
	NSString* _Nonnull ret;
	@autoreleasepool {
		ret = [(NSUUID*)o className];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
BOOL
NSUUID_inst_ScriptingEndsWith(void* o, void* object) {
	BOOL ret;
	@autoreleasepool {
		ret = [(NSUUID*)o scriptingEndsWith:object];
	}
	return ret;

}
void* _Nullable
NSUUID_inst_AwakeAfterUsingCoder(void* o, void* coder) {
	NSObject* _Nullable ret;
	@autoreleasepool {
		ret = [(NSUUID*)o awakeAfterUsingCoder:coder];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
void
NSUUID_inst_RemoveValueAtIndexFromPropertyWithKey(void* o, NSUInteger index, void* key) {
	@autoreleasepool {
		[(NSUUID*)o removeValueAtIndex:index fromPropertyWithKey:key];
	}
}
void* _Nullable
NSUUID_inst_CoerceValueForKey(void* o, void* value, void* key) {
	NSObject* _Nullable ret;
	@autoreleasepool {
		ret = [(NSUUID*)o coerceValue:value forKey:key];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
BOOL
NSUUID_inst_ScriptingIsGreaterThan(void* o, void* object) {
	BOOL ret;
	@autoreleasepool {
		ret = [(NSUUID*)o scriptingIsGreaterThan:object];
	}
	return ret;

}
void* _Nullable
NSUUID_inst_ValueWithUniqueIDInPropertyWithKey(void* o, void* uniqueID, void* key) {
	NSObject* _Nullable ret;
	@autoreleasepool {
		ret = [(NSUUID*)o valueWithUniqueID:uniqueID inPropertyWithKey:key];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
void
NSUUID_inst_Dealloc(void* o) {
	@autoreleasepool {
		[(NSUUID*)o dealloc];
	}
}
BOOL
NSUUID_inst_IsLessThanOrEqualTo(void* o, void* object) {
	BOOL ret;
	@autoreleasepool {
		ret = [(NSUUID*)o isLessThanOrEqualTo:object];
	}
	return ret;

}
BOOL
NSUUID_inst_DoesContain(void* o, void* object) {
	BOOL ret;
	@autoreleasepool {
		ret = [(NSUUID*)o doesContain:object];
	}
	return ret;

}
void* _Nonnull
NSUUID_inst_ToOneRelationshipKeys(void* o) {
	NSArray* _Nonnull ret;
	@autoreleasepool {
		ret = [(NSUUID*)o toOneRelationshipKeys];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
void
NSUUID_inst_WillChangeValueForKey(void* o, void* key) {
	@autoreleasepool {
		[(NSUUID*)o willChangeValueForKey:key];
	}
}
void
NSUUID_inst_WillChangeValueForKeyWithSetMutation(void* o, void* key, NSKeyValueSetMutationKind mutationKind, void* objects) {
	@autoreleasepool {
		[(NSUUID*)o willChangeValueForKey:key withSetMutation:mutationKind usingObjects:objects];
	}
}
void
NSUUID_inst_WillChangeValueForKeyWithSetMutationUsingObjects(void* o, void* key, NSKeyValueSetMutationKind mutationKind, void* objects) {
	@autoreleasepool {
		[(NSUUID*)o willChangeValueForKey:key withSetMutation:mutationKind usingObjects:objects];
	}
}
void*
NSUUID_inst_Copy(void* o) {
	NSObject* ret;
	@autoreleasepool {
		ret = [(NSUUID*)o copy];
	}
	return ret;

}
BOOL
NSUUID_inst_ScriptingIsEqualTo(void* o, void* object) {
	BOOL ret;
	@autoreleasepool {
		ret = [(NSUUID*)o scriptingIsEqualTo:object];
	}
	return ret;

}
void
NSUUID_inst_RemoveObserverForKeyPath(void* o, void* observer, void* keyPath) {
	@autoreleasepool {
		[(NSUUID*)o removeObserver:observer forKeyPath:keyPath];
	}
}
void
NSUUID_inst_RemoveObserverForKeyPathContext(void* o, void* observer, void* keyPath, void* context) {
	@autoreleasepool {
		[(NSUUID*)o removeObserver:observer forKeyPath:keyPath context:context];
	}
}
void* _Nullable
NSUUID_inst_InverseForRelationshipKey(void* o, void* relationshipKey) {
	NSString* _Nullable ret;
	@autoreleasepool {
		ret = [(NSUUID*)o inverseForRelationshipKey:relationshipKey];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
void* _Nonnull
NSUUID_inst_AutoContentAccessingProxy(void* o) {
	NSObject* _Nonnull ret;
	@autoreleasepool {
		ret = [(NSUUID*)o autoContentAccessingProxy];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
void* _Nullable
NSUUID_inst_ValueWithNameInPropertyWithKey(void* o, void* name, void* key) {
	NSObject* _Nullable ret;
	@autoreleasepool {
		ret = [(NSUUID*)o valueWithName:name inPropertyWithKey:key];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
void* _Nullable
NSUUID_inst_ReplacementObjectForCoder(void* o, void* coder) {
	NSObject* _Nullable ret;
	@autoreleasepool {
		ret = [(NSUUID*)o replacementObjectForCoder:coder];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
BOOL
NSUUID_inst_IsGreaterThan(void* o, void* object) {
	BOOL ret;
	@autoreleasepool {
		ret = [(NSUUID*)o isGreaterThan:object];
	}
	return ret;

}
void* _Nullable
NSUUID_inst_NewScriptingObjectOfClassForValueForKey(void* o, void* objectClass, void* key, void* contentsValue, void* properties) {
	NSObject* _Nullable ret;
	@autoreleasepool {
		ret = [(NSUUID*)o newScriptingObjectOfClass:objectClass forValueForKey:key withContentsValue:contentsValue properties:properties];
	}
	return ret;

}
void* _Nullable
NSUUID_inst_NewScriptingObjectOfClassForValueForKeyWithContentsValue(void* o, void* objectClass, void* key, void* contentsValue, void* properties) {
	NSObject* _Nullable ret;
	@autoreleasepool {
		ret = [(NSUUID*)o newScriptingObjectOfClass:objectClass forValueForKey:key withContentsValue:contentsValue properties:properties];
	}
	return ret;

}
BOOL
NSUUID_inst_ScriptingIsLessThanOrEqualTo(void* o, void* object) {
	BOOL ret;
	@autoreleasepool {
		ret = [(NSUUID*)o scriptingIsLessThanOrEqualTo:object];
	}
	return ret;

}
void
NSUUID_inst_DidChangeValueForKey(void* o, void* key) {
	@autoreleasepool {
		[(NSUUID*)o didChangeValueForKey:key];
	}
}
void
NSUUID_inst_DidChangeValueForKeyWithSetMutation(void* o, void* key, NSKeyValueSetMutationKind mutationKind, void* objects) {
	@autoreleasepool {
		[(NSUUID*)o didChangeValueForKey:key withSetMutation:mutationKind usingObjects:objects];
	}
}
void
NSUUID_inst_DidChangeValueForKeyWithSetMutationUsingObjects(void* o, void* key, NSKeyValueSetMutationKind mutationKind, void* objects) {
	@autoreleasepool {
		[(NSUUID*)o didChangeValueForKey:key withSetMutation:mutationKind usingObjects:objects];
	}
}
void
NSUUID_inst_SetNilValueForKey(void* o, void* key) {
	@autoreleasepool {
		[(NSUUID*)o setNilValueForKey:key];
	}
}
void* _Nonnull
NSUUID_inst_CopyWithZone(void* o, void* zone) {
	NSObject* _Nonnull ret;
	@autoreleasepool {
		ret = [(NSUUID*)o copyWithZone:zone];
	}
	return ret;

}
void
NSUUID_inst_SetScriptingProperties(void* o, void* scriptingProperties) {
	@autoreleasepool {
		[(NSUUID*)o setScriptingProperties:scriptingProperties];
	}
}
void* _Nonnull
NSUUID_inst_MutableOrderedSetValueForKeyPath(void* o, void* keyPath) {
	NSMutableOrderedSet* _Nonnull ret;
	@autoreleasepool {
		ret = [(NSUUID*)o mutableOrderedSetValueForKeyPath:keyPath];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
void* _Nonnull
NSUUID_inst_MutableSetValueForKeyPath(void* o, void* keyPath) {
	NSMutableSet* _Nonnull ret;
	@autoreleasepool {
		ret = [(NSUUID*)o mutableSetValueForKeyPath:keyPath];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
void* _Nullable
NSUUID_inst_ScriptingProperties(void* o) {
	NSDictionary* _Nullable ret;
	@autoreleasepool {
		ret = [(NSUUID*)o scriptingProperties];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
void
NSUUID_inst_ForwardInvocation(void* o, void* anInvocation) {
	@autoreleasepool {
		[(NSUUID*)o forwardInvocation:anInvocation];
	}
}
void* _Nonnull
NSUUID_inst_MutableSetValueForKey(void* o, void* key) {
	NSMutableSet* _Nonnull ret;
	@autoreleasepool {
		ret = [(NSUUID*)o mutableSetValueForKey:key];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
void* _Nullable
NSUUID_inst_InitWithUUIDString(void* o, void* string) {
	NSUUID* _Nullable ret;
	@autoreleasepool {
		ret = [(NSUUID*)o initWithUUIDString:string];
	}
	return ret;

}
void*
NSUUID_inst_MutableCopy(void* o) {
	NSObject* ret;
	@autoreleasepool {
		ret = [(NSUUID*)o mutableCopy];
	}
	return ret;

}
void
NSUUID_inst_PerformSelectorWithObject(void* o, void* aSelector, void* anArgument, NSTimeInterval delay) {
	@autoreleasepool {
		[(NSUUID*)o performSelector:aSelector withObject:anArgument afterDelay:delay];
	}
}
void
NSUUID_inst_PerformSelectorWithObjectAfterDelay(void* o, void* aSelector, void* anArgument, NSTimeInterval delay) {
	@autoreleasepool {
		[(NSUUID*)o performSelector:aSelector withObject:anArgument afterDelay:delay];
	}
}
void
NSUUID_inst_PerformSelectorWithObjectAfterDelayInModes(void* o, void* aSelector, void* anArgument, NSTimeInterval delay, void* modes) {
	@autoreleasepool {
		[(NSUUID*)o performSelector:aSelector withObject:anArgument afterDelay:delay inModes:modes];
	}
}
void
NSUUID_inst_PerformSelectorOnThread(void* o, void* aSelector, void* thr, void* arg, BOOL wait) {
	@autoreleasepool {
		[(NSUUID*)o performSelector:aSelector onThread:thr withObject:arg waitUntilDone:wait];
	}
}
void
NSUUID_inst_PerformSelectorOnThreadWithObject(void* o, void* aSelector, void* thr, void* arg, BOOL wait) {
	@autoreleasepool {
		[(NSUUID*)o performSelector:aSelector onThread:thr withObject:arg waitUntilDone:wait];
	}
}
void
NSUUID_inst_PerformSelectorOnThreadWithObjectWaitUntilDone(void* o, void* aSelector, void* thr, void* arg, BOOL wait, void* array) {
	@autoreleasepool {
		[(NSUUID*)o performSelector:aSelector onThread:thr withObject:arg waitUntilDone:wait modes:array];
	}
}
void
NSUUID_inst_PerformSelectorOnThreadWithObjectWaitUntilDoneModes(void* o, void* aSelector, void* thr, void* arg, BOOL wait, void* array) {
	@autoreleasepool {
		[(NSUUID*)o performSelector:aSelector onThread:thr withObject:arg waitUntilDone:wait modes:array];
	}
}
void* _Nullable
NSUUID_inst_IndicesOfObjectsByEvaluatingObjectSpecifier(void* o, void* specifier) {
	NSArray* _Nullable ret;
	@autoreleasepool {
		ret = [(NSUUID*)o indicesOfObjectsByEvaluatingObjectSpecifier:specifier];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
void
NSUUID_inst_InsertValueInPropertyWithKey(void* o, void* value, void* key) {
	@autoreleasepool {
		[(NSUUID*)o insertValue:value inPropertyWithKey:key];
	}
}
void
NSUUID_inst_InsertValueAtIndex(void* o, void* value, NSUInteger index, void* key) {
	@autoreleasepool {
		[(NSUUID*)o insertValue:value atIndex:index inPropertyWithKey:key];
	}
}
void
NSUUID_inst_InsertValueAtIndexInPropertyWithKey(void* o, void* value, NSUInteger index, void* key) {
	@autoreleasepool {
		[(NSUUID*)o insertValue:value atIndex:index inPropertyWithKey:key];
	}
}
void* _Nullable
NSUUID_inst_CopyScriptingValueForKey(void* o, void* value, void* key, void* properties) {
	NSObject* _Nullable ret;
	@autoreleasepool {
		ret = [(NSUUID*)o copyScriptingValue:value forKey:key withProperties:properties];
	}
	return ret;

}
void* _Nullable
NSUUID_inst_CopyScriptingValueForKeyWithProperties(void* o, void* value, void* key, void* properties) {
	NSObject* _Nullable ret;
	@autoreleasepool {
		ret = [(NSUUID*)o copyScriptingValue:value forKey:key withProperties:properties];
	}
	return ret;

}
void* _Nullable
NSUUID_inst_ClassForKeyedArchiver(void* o) {
	Class _Nullable ret;
	@autoreleasepool {
		ret = [(NSUUID*)o classForKeyedArchiver];
	}
	return ret;

}
BOOL
NSUUID_inst_IsLessThan(void* o, void* object) {
	BOOL ret;
	@autoreleasepool {
		ret = [(NSUUID*)o isLessThan:object];
	}
	return ret;

}
BOOL
NSUUID_inst_IsCaseInsensitiveLike(void* o, void* object) {
	BOOL ret;
	@autoreleasepool {
		ret = [(NSUUID*)o isCaseInsensitiveLike:object];
	}
	return ret;

}
void
NSUUID_inst_PerformSelectorOnMainThreadWithObject(void* o, void* aSelector, void* arg, BOOL wait) {
	@autoreleasepool {
		[(NSUUID*)o performSelectorOnMainThread:aSelector withObject:arg waitUntilDone:wait];
	}
}
void
NSUUID_inst_PerformSelectorOnMainThreadWithObjectWaitUntilDone(void* o, void* aSelector, void* arg, BOOL wait) {
	@autoreleasepool {
		[(NSUUID*)o performSelectorOnMainThread:aSelector withObject:arg waitUntilDone:wait];
	}
}
void
NSUUID_inst_PerformSelectorOnMainThreadWithObjectWaitUntilDoneModes(void* o, void* aSelector, void* arg, BOOL wait, void* array) {
	@autoreleasepool {
		[(NSUUID*)o performSelectorOnMainThread:aSelector withObject:arg waitUntilDone:wait modes:array];
	}
}
BOOL
NSUUID_inst_ScriptingIsLessThan(void* o, void* object) {
	BOOL ret;
	@autoreleasepool {
		ret = [(NSUUID*)o scriptingIsLessThan:object];
	}
	return ret;

}
void
NSUUID_inst_ReplaceValueAtIndexInPropertyWithKey(void* o, NSUInteger index, void* key, void* value) {
	@autoreleasepool {
		[(NSUUID*)o replaceValueAtIndex:index inPropertyWithKey:key withValue:value];
	}
}
void
NSUUID_inst_ReplaceValueAtIndexInPropertyWithKeyWithValue(void* o, NSUInteger index, void* key, void* value) {
	@autoreleasepool {
		[(NSUUID*)o replaceValueAtIndex:index inPropertyWithKey:key withValue:value];
	}
}
void* _Nullable
NSUUID_inst_ValueForKeyPath(void* o, void* keyPath) {
	NSObject* _Nullable ret;
	@autoreleasepool {
		ret = [(NSUUID*)o valueForKeyPath:keyPath];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
void* _Nonnull
NSUUID_inst_Init(void* o) {
	NSUUID* _Nonnull ret;
	@autoreleasepool {
		ret = [(NSUUID*)o init];
	}
	return ret;

}
BOOL
NSUUID_inst_ScriptingIsGreaterThanOrEqualTo(void* o, void* object) {
	BOOL ret;
	@autoreleasepool {
		ret = [(NSUUID*)o scriptingIsGreaterThanOrEqualTo:object];
	}
	return ret;

}
BOOL
NSUUID_inst_IsNotEqualTo(void* o, void* object) {
	BOOL ret;
	@autoreleasepool {
		ret = [(NSUUID*)o isNotEqualTo:object];
	}
	return ret;

}
void* _Nonnull
NSUUID_inst_ToManyRelationshipKeys(void* o) {
	NSArray* _Nonnull ret;
	@autoreleasepool {
		ret = [(NSUUID*)o toManyRelationshipKeys];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
void
NSUUID_inst_DidChangeValuesAtIndexes(void* o, NSKeyValueChange changeKind, void* indexes, void* key) {
	@autoreleasepool {
		[(NSUUID*)o didChange:changeKind valuesAtIndexes:indexes forKey:key];
	}
}
void
NSUUID_inst_DidChangeValuesAtIndexesForKey(void* o, NSKeyValueChange changeKind, void* indexes, void* key) {
	@autoreleasepool {
		[(NSUUID*)o didChange:changeKind valuesAtIndexes:indexes forKey:key];
	}
}
void
NSUUID_inst_AddObserverForKeyPath(void* o, void* observer, void* keyPath, NSKeyValueObservingOptions options, void* context) {
	@autoreleasepool {
		[(NSUUID*)o addObserver:observer forKeyPath:keyPath options:options context:context];
	}
}
void
NSUUID_inst_AddObserverForKeyPathOptions(void* o, void* observer, void* keyPath, NSKeyValueObservingOptions options, void* context) {
	@autoreleasepool {
		[(NSUUID*)o addObserver:observer forKeyPath:keyPath options:options context:context];
	}
}
BOOL
NSUUID_inst_ValidateValueForKey(void* o, void** ioValue, void* inKey, void** outError) {
	BOOL ret;
	@autoreleasepool {
		ret = [(NSUUID*)o validateValue:(id _Nullable* _Nonnull)ioValue forKey:inKey error:(NSError* _Nullable* _Nullable)outError];
		for(int i=0;i<1;i++) {
			if(ioValue[i] == 0) { break; }
			[(id)ioValue[i] retain];
		}
	
	
		for(int i=0;i<1;i++) {
			if(outError[i] == 0) { break; }
			[(id)outError[i] retain];
		}
	
	}
	return ret;

}
BOOL
NSUUID_inst_ValidateValueForKeyPath(void* o, void** ioValue, void* inKeyPath, void** outError) {
	BOOL ret;
	@autoreleasepool {
		ret = [(NSUUID*)o validateValue:(id _Nullable* _Nonnull)ioValue forKeyPath:inKeyPath error:(NSError* _Nullable* _Nullable)outError];
		for(int i=0;i<1;i++) {
			if(ioValue[i] == 0) { break; }
			[(id)ioValue[i] retain];
		}
	
	
		for(int i=0;i<1;i++) {
			if(outError[i] == 0) { break; }
			[(id)outError[i] retain];
		}
	
	}
	return ret;

}
BOOL
NSUUID_inst_ValidateValueForKeyError(void* o, void** ioValue, void* inKey, void** outError) {
	BOOL ret;
	@autoreleasepool {
		ret = [(NSUUID*)o validateValue:(id _Nullable* _Nonnull)ioValue forKey:inKey error:(NSError* _Nullable* _Nullable)outError];
		for(int i=0;i<1;i++) {
			if(ioValue[i] == 0) { break; }
			[(id)ioValue[i] retain];
		}
	
	
		for(int i=0;i<1;i++) {
			if(outError[i] == 0) { break; }
			[(id)outError[i] retain];
		}
	
	}
	return ret;

}
BOOL
NSUUID_inst_ValidateValueForKeyPathError(void* o, void** ioValue, void* inKeyPath, void** outError) {
	BOOL ret;
	@autoreleasepool {
		ret = [(NSUUID*)o validateValue:(id _Nullable* _Nonnull)ioValue forKeyPath:inKeyPath error:(NSError* _Nullable* _Nullable)outError];
		for(int i=0;i<1;i++) {
			if(ioValue[i] == 0) { break; }
			[(id)ioValue[i] retain];
		}
	
	
		for(int i=0;i<1;i++) {
			if(outError[i] == 0) { break; }
			[(id)outError[i] retain];
		}
	
	}
	return ret;

}
BOOL
NSUUID_inst_IsLike(void* o, void* object) {
	BOOL ret;
	@autoreleasepool {
		ret = [(NSUUID*)o isLike:object];
	}
	return ret;

}
void*
NSUUID_inst_MethodSignatureForSelector(void* o, void* aSelector) {
	NSMethodSignature* ret;
	@autoreleasepool {
		ret = [(NSUUID*)o methodSignatureForSelector:aSelector];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
BOOL
NSUUID_inst_ScriptingContains(void* o, void* object) {
	BOOL ret;
	@autoreleasepool {
		ret = [(NSUUID*)o scriptingContains:object];
	}
	return ret;

}
BOOL
NSUUID_inst_AttemptRecoveryFromErrorOptionIndex(void* o, void* error, NSUInteger recoveryOptionIndex) {
	BOOL ret;
	@autoreleasepool {
		ret = [(NSUUID*)o attemptRecoveryFromError:error optionIndex:recoveryOptionIndex];
	}
	return ret;

}
void
NSUUID_inst_AttemptRecoveryFromErrorOptionIndexDelegate(void* o, void* error, NSUInteger recoveryOptionIndex, void* delegate, void* didRecoverSelector, void* contextInfo) {
	@autoreleasepool {
		[(NSUUID*)o attemptRecoveryFromError:error optionIndex:recoveryOptionIndex delegate:delegate didRecoverSelector:didRecoverSelector contextInfo:contextInfo];
	}
}
void
NSUUID_inst_AttemptRecoveryFromErrorOptionIndexDelegateDidRecoverSelector(void* o, void* error, NSUInteger recoveryOptionIndex, void* delegate, void* didRecoverSelector, void* contextInfo) {
	@autoreleasepool {
		[(NSUUID*)o attemptRecoveryFromError:error optionIndex:recoveryOptionIndex delegate:delegate didRecoverSelector:didRecoverSelector contextInfo:contextInfo];
	}
}
void* _Nullable
NSUUID_inst_ValueForUndefinedKey(void* o, void* key) {
	NSObject* _Nullable ret;
	@autoreleasepool {
		ret = [(NSUUID*)o valueForUndefinedKey:key];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
BOOL
NSUUID_inst_IsEqualTo(void* o, void* object) {
	BOOL ret;
	@autoreleasepool {
		ret = [(NSUUID*)o isEqualTo:object];
	}
	return ret;

}
void* _Nonnull
NSUUID_inst_MutableArrayValueForKeyPath(void* o, void* keyPath) {
	NSMutableArray* _Nonnull ret;
	@autoreleasepool {
		ret = [(NSUUID*)o mutableArrayValueForKeyPath:keyPath];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
void
NSUUID_inst_DoesNotRecognizeSelector(void* o, void* aSelector) {
	@autoreleasepool {
		[(NSUUID*)o doesNotRecognizeSelector:aSelector];
	}
}
void*
CBCentralManager_DebugDescription() {
	NSString* ret;
	@autoreleasepool {
		ret = [CBCentralManager debugDescription];
	}
	return ret;

}
void* _Nonnull
CBCentralManager_KeyPathsForValuesAffectingValueForKey(void* key) {
	NSSet* _Nonnull ret;
	@autoreleasepool {
		ret = [CBCentralManager keyPathsForValuesAffectingValueForKey:key];
	}
	return ret;

}
void* _Nonnull
CBCentralManager_ClassForKeyedUnarchiver() {
	Class _Nonnull ret;
	@autoreleasepool {
		ret = [CBCentralManager classForKeyedUnarchiver];
	}
	return ret;

}
void
CBCentralManager_SetVersion(NSInteger aVersion) {
	@autoreleasepool {
		[CBCentralManager setVersion:aVersion];
	}
}
void*
CBCentralManager_New() {
	CBCentralManager* ret;
	@autoreleasepool {
		ret = [CBCentralManager new];
	}
	return ret;

}
void*
CBCentralManager_Class() {
	Class ret;
	@autoreleasepool {
		ret = [CBCentralManager class];
	}
	return ret;

}
BOOL
CBCentralManager_ConformsToProtocol(void* protocol) {
	BOOL ret;
	@autoreleasepool {
		ret = [CBCentralManager conformsToProtocol:protocol];
	}
	return ret;

}
BOOL
CBCentralManager_ResolveInstanceMethod(void* sel) {
	BOOL ret;
	@autoreleasepool {
		ret = [CBCentralManager resolveInstanceMethod:sel];
	}
	return ret;

}
void*
CBCentralManager_Alloc() {
	return [CBCentralManager alloc];
}
NSInteger
CBCentralManager_Version() {
	NSInteger ret;
	@autoreleasepool {
		ret = [CBCentralManager version];
	}
	return ret;

}
void*
CBCentralManager_Superclass() {
	Class ret;
	@autoreleasepool {
		ret = [CBCentralManager superclass];
	}
	return ret;

}
CBManagerAuthorization
CBCentralManager_Authorization() {
	CBManagerAuthorization ret;
	@autoreleasepool {
		ret = [CBCentralManager authorization];
	}
	return ret;

}
BOOL
CBCentralManager_ResolveClassMethod(void* sel) {
	BOOL ret;
	@autoreleasepool {
		ret = [CBCentralManager resolveClassMethod:sel];
	}
	return ret;

}
void*
CBCentralManager_AllocWithZone(void* zone) {
	return [CBCentralManager allocWithZone:zone];
}
BOOL
CBCentralManager_AccessInstanceVariablesDirectly() {
	BOOL ret;
	@autoreleasepool {
		ret = [CBCentralManager accessInstanceVariablesDirectly];
	}
	return ret;

}
void* _Nonnull
CBCentralManager_ClassFallbacksForKeyedArchiver() {
	NSArray* _Nonnull ret;
	@autoreleasepool {
		ret = [CBCentralManager classFallbacksForKeyedArchiver];
	}
	return ret;

}
void
CBCentralManager_CancelPreviousPerformRequestsWithTarget(void* aTarget) {
	@autoreleasepool {
		[CBCentralManager cancelPreviousPerformRequestsWithTarget:aTarget];
	}
}
void
CBCentralManager_CancelPreviousPerformRequestsWithTargetSelector(void* aTarget, void* aSelector, void* anArgument) {
	@autoreleasepool {
		[CBCentralManager cancelPreviousPerformRequestsWithTarget:aTarget selector:aSelector object:anArgument];
	}
}
void
CBCentralManager_CancelPreviousPerformRequestsWithTargetSelectorObject(void* aTarget, void* aSelector, void* anArgument) {
	@autoreleasepool {
		[CBCentralManager cancelPreviousPerformRequestsWithTarget:aTarget selector:aSelector object:anArgument];
	}
}
void*
CBCentralManager_Description() {
	NSString* ret;
	@autoreleasepool {
		ret = [CBCentralManager description];
	}
	return ret;

}
BOOL
CBCentralManager_AutomaticallyNotifiesObserversForKey(void* key) {
	BOOL ret;
	@autoreleasepool {
		ret = [CBCentralManager automaticallyNotifiesObserversForKey:key];
	}
	return ret;

}
void*
CBCentralManager_MutableCopyWithZone(void* zone) {
	NSObject* ret;
	@autoreleasepool {
		ret = [CBCentralManager mutableCopyWithZone:zone];
	}
	return ret;

}
void*
CBCentralManager_InstanceMethodSignatureForSelector(void* aSelector) {
	NSMethodSignature* ret;
	@autoreleasepool {
		ret = [CBCentralManager instanceMethodSignatureForSelector:aSelector];
	}
	return ret;

}
BOOL
CBCentralManager_InstancesRespondToSelector(void* aSelector) {
	BOOL ret;
	@autoreleasepool {
		ret = [CBCentralManager instancesRespondToSelector:aSelector];
	}
	return ret;

}
NSUInteger
CBCentralManager_Hash() {
	NSUInteger ret;
	@autoreleasepool {
		ret = [CBCentralManager hash];
	}
	return ret;

}
void
CBCentralManager_Load() {
	@autoreleasepool {
		[CBCentralManager load];
	}
}
BOOL
CBCentralManager_IsSubclassOfClass(void* aClass) {
	BOOL ret;
	@autoreleasepool {
		ret = [CBCentralManager isSubclassOfClass:aClass];
	}
	return ret;

}
void*
CBCentralManager_CopyWithZone(void* zone) {
	NSObject* ret;
	@autoreleasepool {
		ret = [CBCentralManager copyWithZone:zone];
	}
	return ret;

}
BOOL
CBCentralManager_inst_IsGreaterThan(void* o, void* object) {
	BOOL ret;
	@autoreleasepool {
		ret = [(CBCentralManager*)o isGreaterThan:object];
	}
	return ret;

}
BOOL
CBCentralManager_inst_ScriptingBeginsWith(void* o, void* object) {
	BOOL ret;
	@autoreleasepool {
		ret = [(CBCentralManager*)o scriptingBeginsWith:object];
	}
	return ret;

}
void* _Nullable
CBCentralManager_inst_NewScriptingObjectOfClassForValueForKey(void* o, void* objectClass, void* key, void* contentsValue, void* properties) {
	NSObject* _Nullable ret;
	@autoreleasepool {
		ret = [(CBCentralManager*)o newScriptingObjectOfClass:objectClass forValueForKey:key withContentsValue:contentsValue properties:properties];
	}
	return ret;

}
void* _Nullable
CBCentralManager_inst_NewScriptingObjectOfClassForValueForKeyWithContentsValue(void* o, void* objectClass, void* key, void* contentsValue, void* properties) {
	NSObject* _Nullable ret;
	@autoreleasepool {
		ret = [(CBCentralManager*)o newScriptingObjectOfClass:objectClass forValueForKey:key withContentsValue:contentsValue properties:properties];
	}
	return ret;

}
BOOL
CBCentralManager_inst_ScriptingIsLessThanOrEqualTo(void* o, void* object) {
	BOOL ret;
	@autoreleasepool {
		ret = [(CBCentralManager*)o scriptingIsLessThanOrEqualTo:object];
	}
	return ret;

}
BOOL
CBCentralManager_inst_IsLike(void* o, void* object) {
	BOOL ret;
	@autoreleasepool {
		ret = [(CBCentralManager*)o isLike:object];
	}
	return ret;

}
void* _Nonnull
CBCentralManager_inst_AttributeKeys(void* o) {
	NSArray* _Nonnull ret;
	@autoreleasepool {
		ret = [(CBCentralManager*)o attributeKeys];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
void* _Nonnull
CBCentralManager_inst_RetrieveConnectedPeripheralsWithServices(void* o, void* serviceUUIDs) {
	NSArray* _Nonnull ret;
	@autoreleasepool {
		ret = [(CBCentralManager*)o retrieveConnectedPeripheralsWithServices:serviceUUIDs];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
void
CBCentralManager_inst_InsertValueInPropertyWithKey(void* o, void* value, void* key) {
	@autoreleasepool {
		[(CBCentralManager*)o insertValue:value inPropertyWithKey:key];
	}
}
void
CBCentralManager_inst_InsertValueAtIndex(void* o, void* value, NSUInteger index, void* key) {
	@autoreleasepool {
		[(CBCentralManager*)o insertValue:value atIndex:index inPropertyWithKey:key];
	}
}
void
CBCentralManager_inst_InsertValueAtIndexInPropertyWithKey(void* o, void* value, NSUInteger index, void* key) {
	@autoreleasepool {
		[(CBCentralManager*)o insertValue:value atIndex:index inPropertyWithKey:key];
	}
}
void* _Nullable
CBCentralManager_inst_ReplacementObjectForKeyedArchiver(void* o, void* archiver) {
	NSObject* _Nullable ret;
	@autoreleasepool {
		ret = [(CBCentralManager*)o replacementObjectForKeyedArchiver:archiver];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
void
CBCentralManager_inst_DidChangeValuesAtIndexes(void* o, NSKeyValueChange changeKind, void* indexes, void* key) {
	@autoreleasepool {
		[(CBCentralManager*)o didChange:changeKind valuesAtIndexes:indexes forKey:key];
	}
}
void
CBCentralManager_inst_DidChangeValuesAtIndexesForKey(void* o, NSKeyValueChange changeKind, void* indexes, void* key) {
	@autoreleasepool {
		[(CBCentralManager*)o didChange:changeKind valuesAtIndexes:indexes forKey:key];
	}
}
CBManagerState
CBCentralManager_inst_State(void* o) {
	CBManagerState ret;
	@autoreleasepool {
		ret = [(CBCentralManager*)o state];
	}
	return ret;

}
void* _Nullable
CBCentralManager_inst_InverseForRelationshipKey(void* o, void* relationshipKey) {
	NSString* _Nullable ret;
	@autoreleasepool {
		ret = [(CBCentralManager*)o inverseForRelationshipKey:relationshipKey];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
BOOL
CBCentralManager_inst_ScriptingEndsWith(void* o, void* object) {
	BOOL ret;
	@autoreleasepool {
		ret = [(CBCentralManager*)o scriptingEndsWith:object];
	}
	return ret;

}
void* _Nullable
CBCentralManager_inst_ValueWithNameInPropertyWithKey(void* o, void* name, void* key) {
	NSObject* _Nullable ret;
	@autoreleasepool {
		ret = [(CBCentralManager*)o valueWithName:name inPropertyWithKey:key];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
BOOL
CBCentralManager_inst_IsCaseInsensitiveLike(void* o, void* object) {
	BOOL ret;
	@autoreleasepool {
		ret = [(CBCentralManager*)o isCaseInsensitiveLike:object];
	}
	return ret;

}
void
CBCentralManager_inst_PerformSelectorWithObject(void* o, void* aSelector, void* anArgument, NSTimeInterval delay) {
	@autoreleasepool {
		[(CBCentralManager*)o performSelector:aSelector withObject:anArgument afterDelay:delay];
	}
}
void
CBCentralManager_inst_PerformSelectorWithObjectAfterDelay(void* o, void* aSelector, void* anArgument, NSTimeInterval delay) {
	@autoreleasepool {
		[(CBCentralManager*)o performSelector:aSelector withObject:anArgument afterDelay:delay];
	}
}
void
CBCentralManager_inst_PerformSelectorWithObjectAfterDelayInModes(void* o, void* aSelector, void* anArgument, NSTimeInterval delay, void* modes) {
	@autoreleasepool {
		[(CBCentralManager*)o performSelector:aSelector withObject:anArgument afterDelay:delay inModes:modes];
	}
}
void
CBCentralManager_inst_PerformSelectorOnThread(void* o, void* aSelector, void* thr, void* arg, BOOL wait) {
	@autoreleasepool {
		[(CBCentralManager*)o performSelector:aSelector onThread:thr withObject:arg waitUntilDone:wait];
	}
}
void
CBCentralManager_inst_PerformSelectorOnThreadWithObject(void* o, void* aSelector, void* thr, void* arg, BOOL wait) {
	@autoreleasepool {
		[(CBCentralManager*)o performSelector:aSelector onThread:thr withObject:arg waitUntilDone:wait];
	}
}
void
CBCentralManager_inst_PerformSelectorOnThreadWithObjectWaitUntilDone(void* o, void* aSelector, void* thr, void* arg, BOOL wait, void* array) {
	@autoreleasepool {
		[(CBCentralManager*)o performSelector:aSelector onThread:thr withObject:arg waitUntilDone:wait modes:array];
	}
}
void
CBCentralManager_inst_PerformSelectorOnThreadWithObjectWaitUntilDoneModes(void* o, void* aSelector, void* thr, void* arg, BOOL wait, void* array) {
	@autoreleasepool {
		[(CBCentralManager*)o performSelector:aSelector onThread:thr withObject:arg waitUntilDone:wait modes:array];
	}
}
void* _Nonnull
CBCentralManager_inst_MutableArrayValueForKeyPath(void* o, void* keyPath) {
	NSMutableArray* _Nonnull ret;
	@autoreleasepool {
		ret = [(CBCentralManager*)o mutableArrayValueForKeyPath:keyPath];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
void* _Nullable
CBCentralManager_inst_ScriptingValueForSpecifier(void* o, void* objectSpecifier) {
	NSObject* _Nullable ret;
	@autoreleasepool {
		ret = [(CBCentralManager*)o scriptingValueForSpecifier:objectSpecifier];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
void
CBCentralManager_inst_ObserveValueForKeyPathOfObject(void* o, void* keyPath, void* object, void* change, void* context) {
	@autoreleasepool {
		[(CBCentralManager*)o observeValueForKeyPath:keyPath ofObject:object change:change context:context];
	}
}
void
CBCentralManager_inst_ObserveValueForKeyPathOfObjectChange(void* o, void* keyPath, void* object, void* change, void* context) {
	@autoreleasepool {
		[(CBCentralManager*)o observeValueForKeyPath:keyPath ofObject:object change:change context:context];
	}
}
void* _Nullable
CBCentralManager_inst_CopyScriptingValueForKey(void* o, void* value, void* key, void* properties) {
	NSObject* _Nullable ret;
	@autoreleasepool {
		ret = [(CBCentralManager*)o copyScriptingValue:value forKey:key withProperties:properties];
	}
	return ret;

}
void* _Nullable
CBCentralManager_inst_CopyScriptingValueForKeyWithProperties(void* o, void* value, void* key, void* properties) {
	NSObject* _Nullable ret;
	@autoreleasepool {
		ret = [(CBCentralManager*)o copyScriptingValue:value forKey:key withProperties:properties];
	}
	return ret;

}
void* _Nonnull
CBCentralManager_inst_AutoContentAccessingProxy(void* o) {
	NSObject* _Nonnull ret;
	@autoreleasepool {
		ret = [(CBCentralManager*)o autoContentAccessingProxy];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
void
CBCentralManager_inst_AddObserverForKeyPath(void* o, void* observer, void* keyPath, NSKeyValueObservingOptions options, void* context) {
	@autoreleasepool {
		[(CBCentralManager*)o addObserver:observer forKeyPath:keyPath options:options context:context];
	}
}
void
CBCentralManager_inst_AddObserverForKeyPathOptions(void* o, void* observer, void* keyPath, NSKeyValueObservingOptions options, void* context) {
	@autoreleasepool {
		[(CBCentralManager*)o addObserver:observer forKeyPath:keyPath options:options context:context];
	}
}
void* _Nonnull
CBCentralManager_inst_ToOneRelationshipKeys(void* o) {
	NSArray* _Nonnull ret;
	@autoreleasepool {
		ret = [(CBCentralManager*)o toOneRelationshipKeys];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
void* _Nullable
CBCentralManager_inst_ValueForUndefinedKey(void* o, void* key) {
	NSObject* _Nullable ret;
	@autoreleasepool {
		ret = [(CBCentralManager*)o valueForUndefinedKey:key];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
CBManagerAuthorization
CBCentralManager_inst_Authorization(void* o) {
	CBManagerAuthorization ret;
	@autoreleasepool {
		ret = [(CBCentralManager*)o authorization];
	}
	return ret;

}
FourCharCode
CBCentralManager_inst_ClassCode(void* o) {
	FourCharCode ret;
	@autoreleasepool {
		ret = [(CBCentralManager*)o classCode];
	}
	return ret;

}
void* _Nullable
CBCentralManager_inst_ValueWithUniqueIDInPropertyWithKey(void* o, void* uniqueID, void* key) {
	NSObject* _Nullable ret;
	@autoreleasepool {
		ret = [(CBCentralManager*)o valueWithUniqueID:uniqueID inPropertyWithKey:key];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
void
CBCentralManager_inst_SetDelegate(void* o, void* delegate) {
	@autoreleasepool {
		[(CBCentralManager*)o setDelegate:delegate];
	}
}
BOOL
CBCentralManager_inst_ScriptingIsGreaterThanOrEqualTo(void* o, void* object) {
	BOOL ret;
	@autoreleasepool {
		ret = [(CBCentralManager*)o scriptingIsGreaterThanOrEqualTo:object];
	}
	return ret;

}
void
CBCentralManager_inst_StopScan(void* o) {
	@autoreleasepool {
		[(CBCentralManager*)o stopScan];
	}
}
BOOL
CBCentralManager_inst_IsLessThanOrEqualTo(void* o, void* object) {
	BOOL ret;
	@autoreleasepool {
		ret = [(CBCentralManager*)o isLessThanOrEqualTo:object];
	}
	return ret;

}
void
CBCentralManager_inst_SetValueForKey(void* o, void* value, void* key) {
	@autoreleasepool {
		[(CBCentralManager*)o setValue:value forKey:key];
	}
}
void
CBCentralManager_inst_SetValueForKeyPath(void* o, void* value, void* keyPath) {
	@autoreleasepool {
		[(CBCentralManager*)o setValue:value forKeyPath:keyPath];
	}
}
void
CBCentralManager_inst_SetValueForUndefinedKey(void* o, void* value, void* key) {
	@autoreleasepool {
		[(CBCentralManager*)o setValue:value forUndefinedKey:key];
	}
}
BOOL
CBCentralManager_inst_IsScanning(void* o) {
	BOOL ret;
	@autoreleasepool {
		ret = [(CBCentralManager*)o isScanning];
	}
	return ret;

}
void* _Nonnull
CBCentralManager_inst_InitWithDelegateQueue(void* o, void* delegate, void* queue) {
	CBCentralManager* _Nonnull ret;
	@autoreleasepool {
		ret = [(CBCentralManager*)o initWithDelegate:delegate queue:queue];
	}
	return ret;

}
void* _Nonnull
CBCentralManager_inst_InitWithDelegateQueueOptions(void* o, void* delegate, void* queue, void* options) {
	CBCentralManager* _Nonnull ret;
	@autoreleasepool {
		ret = [(CBCentralManager*)o initWithDelegate:delegate queue:queue options:options];
	}
	return ret;

}
BOOL
CBCentralManager_inst_IsGreaterThanOrEqualTo(void* o, void* object) {
	BOOL ret;
	@autoreleasepool {
		ret = [(CBCentralManager*)o isGreaterThanOrEqualTo:object];
	}
	return ret;

}
BOOL
CBCentralManager_inst_IsEqualTo(void* o, void* object) {
	BOOL ret;
	@autoreleasepool {
		ret = [(CBCentralManager*)o isEqualTo:object];
	}
	return ret;

}
void
CBCentralManager_inst_ReplaceValueAtIndexInPropertyWithKey(void* o, NSUInteger index, void* key, void* value) {
	@autoreleasepool {
		[(CBCentralManager*)o replaceValueAtIndex:index inPropertyWithKey:key withValue:value];
	}
}
void
CBCentralManager_inst_ReplaceValueAtIndexInPropertyWithKeyWithValue(void* o, NSUInteger index, void* key, void* value) {
	@autoreleasepool {
		[(CBCentralManager*)o replaceValueAtIndex:index inPropertyWithKey:key withValue:value];
	}
}
void
CBCentralManager_inst_DidChangeValueForKey(void* o, void* key) {
	@autoreleasepool {
		[(CBCentralManager*)o didChangeValueForKey:key];
	}
}
void
CBCentralManager_inst_DidChangeValueForKeyWithSetMutation(void* o, void* key, NSKeyValueSetMutationKind mutationKind, void* objects) {
	@autoreleasepool {
		[(CBCentralManager*)o didChangeValueForKey:key withSetMutation:mutationKind usingObjects:objects];
	}
}
void
CBCentralManager_inst_DidChangeValueForKeyWithSetMutationUsingObjects(void* o, void* key, NSKeyValueSetMutationKind mutationKind, void* objects) {
	@autoreleasepool {
		[(CBCentralManager*)o didChangeValueForKey:key withSetMutation:mutationKind usingObjects:objects];
	}
}
void* _Nullable
CBCentralManager_inst_Delegate(void* o) {
	NSObject* _Nullable ret;
	@autoreleasepool {
		ret = [(CBCentralManager*)o delegate];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
void* _Nullable
CBCentralManager_inst_AwakeAfterUsingCoder(void* o, void* coder) {
	NSObject* _Nullable ret;
	@autoreleasepool {
		ret = [(CBCentralManager*)o awakeAfterUsingCoder:coder];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
void* _Nonnull
CBCentralManager_inst_ToManyRelationshipKeys(void* o) {
	NSArray* _Nonnull ret;
	@autoreleasepool {
		ret = [(CBCentralManager*)o toManyRelationshipKeys];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
void*
CBCentralManager_inst_ObservationInfo(void* o) {
	void* ret;
	@autoreleasepool {
		ret = [(CBCentralManager*)o observationInfo];
	}
	return ret;

}
void
CBCentralManager_inst_WillChangeValueForKey(void* o, void* key) {
	@autoreleasepool {
		[(CBCentralManager*)o willChangeValueForKey:key];
	}
}
void
CBCentralManager_inst_WillChangeValueForKeyWithSetMutation(void* o, void* key, NSKeyValueSetMutationKind mutationKind, void* objects) {
	@autoreleasepool {
		[(CBCentralManager*)o willChangeValueForKey:key withSetMutation:mutationKind usingObjects:objects];
	}
}
void
CBCentralManager_inst_WillChangeValueForKeyWithSetMutationUsingObjects(void* o, void* key, NSKeyValueSetMutationKind mutationKind, void* objects) {
	@autoreleasepool {
		[(CBCentralManager*)o willChangeValueForKey:key withSetMutation:mutationKind usingObjects:objects];
	}
}
void* _Nullable
CBCentralManager_inst_ValueForKeyPath(void* o, void* keyPath) {
	NSObject* _Nullable ret;
	@autoreleasepool {
		ret = [(CBCentralManager*)o valueForKeyPath:keyPath];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
void*
CBCentralManager_inst_MethodSignatureForSelector(void* o, void* aSelector) {
	NSMethodSignature* ret;
	@autoreleasepool {
		ret = [(CBCentralManager*)o methodSignatureForSelector:aSelector];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
void* _Nonnull
CBCentralManager_inst_ClassForCoder(void* o) {
	Class _Nonnull ret;
	@autoreleasepool {
		ret = [(CBCentralManager*)o classForCoder];
	}
	return ret;

}
void*
CBCentralManager_inst_ForwardingTargetForSelector(void* o, void* aSelector) {
	NSObject* ret;
	@autoreleasepool {
		ret = [(CBCentralManager*)o forwardingTargetForSelector:aSelector];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
void* _Nullable
CBCentralManager_inst_ValueAtIndexInPropertyWithKey(void* o, NSUInteger index, void* key) {
	NSObject* _Nullable ret;
	@autoreleasepool {
		ret = [(CBCentralManager*)o valueAtIndex:index inPropertyWithKey:key];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
void
CBCentralManager_inst_SetObservationInfo(void* o, void* observationInfo) {
	@autoreleasepool {
		[(CBCentralManager*)o setObservationInfo:observationInfo];
	}
}
BOOL
CBCentralManager_inst_IsLessThan(void* o, void* object) {
	BOOL ret;
	@autoreleasepool {
		ret = [(CBCentralManager*)o isLessThan:object];
	}
	return ret;

}
void* _Nonnull
CBCentralManager_inst_MutableSetValueForKey(void* o, void* key) {
	NSMutableSet* _Nonnull ret;
	@autoreleasepool {
		ret = [(CBCentralManager*)o mutableSetValueForKey:key];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
void
CBCentralManager_inst_SetScriptingProperties(void* o, void* scriptingProperties) {
	@autoreleasepool {
		[(CBCentralManager*)o setScriptingProperties:scriptingProperties];
	}
}
void* _Nonnull
CBCentralManager_inst_ClassDescription(void* o) {
	NSClassDescription* _Nonnull ret;
	@autoreleasepool {
		ret = [(CBCentralManager*)o classDescription];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
void
CBCentralManager_inst_PerformSelectorOnMainThreadWithObject(void* o, void* aSelector, void* arg, BOOL wait) {
	@autoreleasepool {
		[(CBCentralManager*)o performSelectorOnMainThread:aSelector withObject:arg waitUntilDone:wait];
	}
}
void
CBCentralManager_inst_PerformSelectorOnMainThreadWithObjectWaitUntilDone(void* o, void* aSelector, void* arg, BOOL wait) {
	@autoreleasepool {
		[(CBCentralManager*)o performSelectorOnMainThread:aSelector withObject:arg waitUntilDone:wait];
	}
}
void
CBCentralManager_inst_PerformSelectorOnMainThreadWithObjectWaitUntilDoneModes(void* o, void* aSelector, void* arg, BOOL wait, void* array) {
	@autoreleasepool {
		[(CBCentralManager*)o performSelectorOnMainThread:aSelector withObject:arg waitUntilDone:wait modes:array];
	}
}
void* _Nullable
CBCentralManager_inst_ClassForArchiver(void* o) {
	Class _Nullable ret;
	@autoreleasepool {
		ret = [(CBCentralManager*)o classForArchiver];
	}
	return ret;

}
void* _Nullable
CBCentralManager_inst_ClassForKeyedArchiver(void* o) {
	Class _Nullable ret;
	@autoreleasepool {
		ret = [(CBCentralManager*)o classForKeyedArchiver];
	}
	return ret;

}
void* _Nullable
CBCentralManager_inst_ReplacementObjectForCoder(void* o, void* coder) {
	NSObject* _Nullable ret;
	@autoreleasepool {
		ret = [(CBCentralManager*)o replacementObjectForCoder:coder];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
void
CBCentralManager_inst_DoesNotRecognizeSelector(void* o, void* aSelector) {
	@autoreleasepool {
		[(CBCentralManager*)o doesNotRecognizeSelector:aSelector];
	}
}
BOOL
CBCentralManager_inst_DoesContain(void* o, void* object) {
	BOOL ret;
	@autoreleasepool {
		ret = [(CBCentralManager*)o doesContain:object];
	}
	return ret;

}
void* _Nonnull
CBCentralManager_inst_MutableOrderedSetValueForKeyPath(void* o, void* keyPath) {
	NSMutableOrderedSet* _Nonnull ret;
	@autoreleasepool {
		ret = [(CBCentralManager*)o mutableOrderedSetValueForKeyPath:keyPath];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
void* _Nonnull
CBCentralManager_inst_MutableArrayValueForKey(void* o, void* key) {
	NSMutableArray* _Nonnull ret;
	@autoreleasepool {
		ret = [(CBCentralManager*)o mutableArrayValueForKey:key];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
void* _Nullable
CBCentralManager_inst_IndicesOfObjectsByEvaluatingObjectSpecifier(void* o, void* specifier) {
	NSArray* _Nullable ret;
	@autoreleasepool {
		ret = [(CBCentralManager*)o indicesOfObjectsByEvaluatingObjectSpecifier:specifier];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
BOOL
CBCentralManager_inst_ScriptingContains(void* o, void* object) {
	BOOL ret;
	@autoreleasepool {
		ret = [(CBCentralManager*)o scriptingContains:object];
	}
	return ret;

}
void* _Nonnull
CBCentralManager_inst_RetrievePeripheralsWithIdentifiers(void* o, void* identifiers) {
	NSArray* _Nonnull ret;
	@autoreleasepool {
		ret = [(CBCentralManager*)o retrievePeripheralsWithIdentifiers:identifiers];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
void
CBCentralManager_inst_CancelPeripheralConnection(void* o, void* peripheral) {
	@autoreleasepool {
		[(CBCentralManager*)o cancelPeripheralConnection:peripheral];
	}
}
BOOL
CBCentralManager_inst_AttemptRecoveryFromErrorOptionIndex(void* o, void* error, NSUInteger recoveryOptionIndex) {
	BOOL ret;
	@autoreleasepool {
		ret = [(CBCentralManager*)o attemptRecoveryFromError:error optionIndex:recoveryOptionIndex];
	}
	return ret;

}
void
CBCentralManager_inst_AttemptRecoveryFromErrorOptionIndexDelegate(void* o, void* error, NSUInteger recoveryOptionIndex, void* delegate, void* didRecoverSelector, void* contextInfo) {
	@autoreleasepool {
		[(CBCentralManager*)o attemptRecoveryFromError:error optionIndex:recoveryOptionIndex delegate:delegate didRecoverSelector:didRecoverSelector contextInfo:contextInfo];
	}
}
void
CBCentralManager_inst_AttemptRecoveryFromErrorOptionIndexDelegateDidRecoverSelector(void* o, void* error, NSUInteger recoveryOptionIndex, void* delegate, void* didRecoverSelector, void* contextInfo) {
	@autoreleasepool {
		[(CBCentralManager*)o attemptRecoveryFromError:error optionIndex:recoveryOptionIndex delegate:delegate didRecoverSelector:didRecoverSelector contextInfo:contextInfo];
	}
}
void
CBCentralManager_inst_SetValuesForKeysWithDictionary(void* o, void* keyedValues) {
	@autoreleasepool {
		[(CBCentralManager*)o setValuesForKeysWithDictionary:keyedValues];
	}
}
void*
CBCentralManager_inst_MutableCopy(void* o) {
	NSObject* ret;
	@autoreleasepool {
		ret = [(CBCentralManager*)o mutableCopy];
	}
	return ret;

}
BOOL
CBCentralManager_inst_ScriptingIsLessThan(void* o, void* object) {
	BOOL ret;
	@autoreleasepool {
		ret = [(CBCentralManager*)o scriptingIsLessThan:object];
	}
	return ret;

}
BOOL
CBCentralManager_inst_ScriptingIsGreaterThan(void* o, void* object) {
	BOOL ret;
	@autoreleasepool {
		ret = [(CBCentralManager*)o scriptingIsGreaterThan:object];
	}
	return ret;

}
void* _Nonnull
CBCentralManager_inst_Init(void* o) {
	CBCentralManager* _Nonnull ret;
	@autoreleasepool {
		ret = [(CBCentralManager*)o init];
	}
	return ret;

}
void* _Nullable
CBCentralManager_inst_ObjectSpecifier(void* o) {
	NSScriptObjectSpecifier* _Nullable ret;
	@autoreleasepool {
		ret = [(CBCentralManager*)o objectSpecifier];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
void*
CBCentralManager_inst_Copy(void* o) {
	NSObject* ret;
	@autoreleasepool {
		ret = [(CBCentralManager*)o copy];
	}
	return ret;

}
BOOL
CBCentralManager_inst_ValidateValueForKey(void* o, void** ioValue, void* inKey, void** outError) {
	BOOL ret;
	@autoreleasepool {
		ret = [(CBCentralManager*)o validateValue:(id _Nullable* _Nonnull)ioValue forKey:inKey error:(NSError* _Nullable* _Nullable)outError];
		for(int i=0;i<1;i++) {
			if(ioValue[i] == 0) { break; }
			[(id)ioValue[i] retain];
		}
	
	
		for(int i=0;i<1;i++) {
			if(outError[i] == 0) { break; }
			[(id)outError[i] retain];
		}
	
	}
	return ret;

}
BOOL
CBCentralManager_inst_ValidateValueForKeyPath(void* o, void** ioValue, void* inKeyPath, void** outError) {
	BOOL ret;
	@autoreleasepool {
		ret = [(CBCentralManager*)o validateValue:(id _Nullable* _Nonnull)ioValue forKeyPath:inKeyPath error:(NSError* _Nullable* _Nullable)outError];
		for(int i=0;i<1;i++) {
			if(ioValue[i] == 0) { break; }
			[(id)ioValue[i] retain];
		}
	
	
		for(int i=0;i<1;i++) {
			if(outError[i] == 0) { break; }
			[(id)outError[i] retain];
		}
	
	}
	return ret;

}
BOOL
CBCentralManager_inst_ValidateValueForKeyError(void* o, void** ioValue, void* inKey, void** outError) {
	BOOL ret;
	@autoreleasepool {
		ret = [(CBCentralManager*)o validateValue:(id _Nullable* _Nonnull)ioValue forKey:inKey error:(NSError* _Nullable* _Nullable)outError];
		for(int i=0;i<1;i++) {
			if(ioValue[i] == 0) { break; }
			[(id)ioValue[i] retain];
		}
	
	
		for(int i=0;i<1;i++) {
			if(outError[i] == 0) { break; }
			[(id)outError[i] retain];
		}
	
	}
	return ret;

}
BOOL
CBCentralManager_inst_ValidateValueForKeyPathError(void* o, void** ioValue, void* inKeyPath, void** outError) {
	BOOL ret;
	@autoreleasepool {
		ret = [(CBCentralManager*)o validateValue:(id _Nullable* _Nonnull)ioValue forKeyPath:inKeyPath error:(NSError* _Nullable* _Nullable)outError];
		for(int i=0;i<1;i++) {
			if(ioValue[i] == 0) { break; }
			[(id)ioValue[i] retain];
		}
	
	
		for(int i=0;i<1;i++) {
			if(outError[i] == 0) { break; }
			[(id)outError[i] retain];
		}
	
	}
	return ret;

}
void* _Nullable
CBCentralManager_inst_CoerceValueForKey(void* o, void* value, void* key) {
	NSObject* _Nullable ret;
	@autoreleasepool {
		ret = [(CBCentralManager*)o coerceValue:value forKey:key];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
void
CBCentralManager_inst_ForwardInvocation(void* o, void* anInvocation) {
	@autoreleasepool {
		[(CBCentralManager*)o forwardInvocation:anInvocation];
	}
}
void
CBCentralManager_inst_ConnectPeripheral(void* o, void* peripheral, void* options) {
	@autoreleasepool {
		[(CBCentralManager*)o connectPeripheral:peripheral options:options];
	}
}
void* _Nonnull
CBCentralManager_inst_DictionaryWithValuesForKeys(void* o, void* keys) {
	NSDictionary* _Nonnull ret;
	@autoreleasepool {
		ret = [(CBCentralManager*)o dictionaryWithValuesForKeys:keys];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
BOOL
CBCentralManager_inst_ScriptingIsEqualTo(void* o, void* object) {
	BOOL ret;
	@autoreleasepool {
		ret = [(CBCentralManager*)o scriptingIsEqualTo:object];
	}
	return ret;

}
void* _Nonnull
CBCentralManager_inst_ClassName(void* o) {
	NSString* _Nonnull ret;
	@autoreleasepool {
		ret = [(CBCentralManager*)o className];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
void
CBCentralManager_inst_RemoveObserverForKeyPath(void* o, void* observer, void* keyPath) {
	@autoreleasepool {
		[(CBCentralManager*)o removeObserver:observer forKeyPath:keyPath];
	}
}
void
CBCentralManager_inst_RemoveObserverForKeyPathContext(void* o, void* observer, void* keyPath, void* context) {
	@autoreleasepool {
		[(CBCentralManager*)o removeObserver:observer forKeyPath:keyPath context:context];
	}
}
void
CBCentralManager_inst_RemoveValueAtIndexFromPropertyWithKey(void* o, NSUInteger index, void* key) {
	@autoreleasepool {
		[(CBCentralManager*)o removeValueAtIndex:index fromPropertyWithKey:key];
	}
}
void* _Nonnull
CBCentralManager_inst_MutableSetValueForKeyPath(void* o, void* keyPath) {
	NSMutableSet* _Nonnull ret;
	@autoreleasepool {
		ret = [(CBCentralManager*)o mutableSetValueForKeyPath:keyPath];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
void* _Nonnull
CBCentralManager_inst_MutableOrderedSetValueForKey(void* o, void* key) {
	NSMutableOrderedSet* _Nonnull ret;
	@autoreleasepool {
		ret = [(CBCentralManager*)o mutableOrderedSetValueForKey:key];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
BOOL
CBCentralManager_inst_IsNotEqualTo(void* o, void* object) {
	BOOL ret;
	@autoreleasepool {
		ret = [(CBCentralManager*)o isNotEqualTo:object];
	}
	return ret;

}
void
CBCentralManager_inst_Dealloc(void* o) {
	@autoreleasepool {
		[(CBCentralManager*)o dealloc];
	}
}
void* _Nullable
CBCentralManager_inst_ValueForKey(void* o, void* key) {
	NSObject* _Nullable ret;
	@autoreleasepool {
		ret = [(CBCentralManager*)o valueForKey:key];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
void
CBCentralManager_inst_PerformSelectorInBackgroundWithObject(void* o, void* aSelector, void* arg) {
	@autoreleasepool {
		[(CBCentralManager*)o performSelectorInBackground:aSelector withObject:arg];
	}
}
void* _Nullable
CBCentralManager_inst_ScriptingProperties(void* o) {
	NSDictionary* _Nullable ret;
	@autoreleasepool {
		ret = [(CBCentralManager*)o scriptingProperties];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
void
CBCentralManager_inst_SetNilValueForKey(void* o, void* key) {
	@autoreleasepool {
		[(CBCentralManager*)o setNilValueForKey:key];
	}
}
void
CBCentralManager_inst_ScanForPeripheralsWithServices(void* o, void* serviceUUIDs, void* options) {
	@autoreleasepool {
		[(CBCentralManager*)o scanForPeripheralsWithServices:serviceUUIDs options:options];
	}
}
void
CBCentralManager_inst_WillChangeValuesAtIndexes(void* o, NSKeyValueChange changeKind, void* indexes, void* key) {
	@autoreleasepool {
		[(CBCentralManager*)o willChange:changeKind valuesAtIndexes:indexes forKey:key];
	}
}
void
CBCentralManager_inst_WillChangeValuesAtIndexesForKey(void* o, NSKeyValueChange changeKind, void* indexes, void* key) {
	@autoreleasepool {
		[(CBCentralManager*)o willChange:changeKind valuesAtIndexes:indexes forKey:key];
	}
}
void*
CBCharacteristic_CopyWithZone(void* zone) {
	NSObject* ret;
	@autoreleasepool {
		ret = [CBCharacteristic copyWithZone:zone];
	}
	return ret;

}
void*
CBCharacteristic_MutableCopyWithZone(void* zone) {
	NSObject* ret;
	@autoreleasepool {
		ret = [CBCharacteristic mutableCopyWithZone:zone];
	}
	return ret;

}
BOOL
CBCharacteristic_AccessInstanceVariablesDirectly() {
	BOOL ret;
	@autoreleasepool {
		ret = [CBCharacteristic accessInstanceVariablesDirectly];
	}
	return ret;

}
void*
CBCharacteristic_New() {
	CBCharacteristic* ret;
	@autoreleasepool {
		NSLog(@"CBCharacteristic new");
		//ret = [CBCharacteristic new];
	}
	return ret;

}
void* _Nonnull
CBCharacteristic_KeyPathsForValuesAffectingValueForKey(void* key) {
	NSSet* _Nonnull ret;
	@autoreleasepool {
		ret = [CBCharacteristic keyPathsForValuesAffectingValueForKey:key];
	}
	return ret;

}
void
CBCharacteristic_Load() {
	@autoreleasepool {
		[CBCharacteristic load];
	}
}
BOOL
CBCharacteristic_IsSubclassOfClass(void* aClass) {
	BOOL ret;
	@autoreleasepool {
		ret = [CBCharacteristic isSubclassOfClass:aClass];
	}
	return ret;

}
void
CBCharacteristic_CancelPreviousPerformRequestsWithTarget(void* aTarget) {
	@autoreleasepool {
		[CBCharacteristic cancelPreviousPerformRequestsWithTarget:aTarget];
	}
}
void
CBCharacteristic_CancelPreviousPerformRequestsWithTargetSelector(void* aTarget, void* aSelector, void* anArgument) {
	@autoreleasepool {
		[CBCharacteristic cancelPreviousPerformRequestsWithTarget:aTarget selector:aSelector object:anArgument];
	}
}
void
CBCharacteristic_CancelPreviousPerformRequestsWithTargetSelectorObject(void* aTarget, void* aSelector, void* anArgument) {
	@autoreleasepool {
		[CBCharacteristic cancelPreviousPerformRequestsWithTarget:aTarget selector:aSelector object:anArgument];
	}
}
void*
CBCharacteristic_Alloc() {
	return [CBCharacteristic alloc];
}
BOOL
CBCharacteristic_ResolveClassMethod(void* sel) {
	BOOL ret;
	@autoreleasepool {
		ret = [CBCharacteristic resolveClassMethod:sel];
	}
	return ret;

}
void*
CBCharacteristic_DebugDescription() {
	NSString* ret;
	@autoreleasepool {
		ret = [CBCharacteristic debugDescription];
	}
	return ret;

}
void*
CBCharacteristic_Description() {
	NSString* ret;
	@autoreleasepool {
		ret = [CBCharacteristic description];
	}
	return ret;

}
void*
CBCharacteristic_InstanceMethodSignatureForSelector(void* aSelector) {
	NSMethodSignature* ret;
	@autoreleasepool {
		ret = [CBCharacteristic instanceMethodSignatureForSelector:aSelector];
	}
	return ret;

}
BOOL
CBCharacteristic_AutomaticallyNotifiesObserversForKey(void* key) {
	BOOL ret;
	@autoreleasepool {
		ret = [CBCharacteristic automaticallyNotifiesObserversForKey:key];
	}
	return ret;

}
BOOL
CBCharacteristic_ConformsToProtocol(void* protocol) {
	BOOL ret;
	@autoreleasepool {
		ret = [CBCharacteristic conformsToProtocol:protocol];
	}
	return ret;

}
void
CBCharacteristic_SetVersion(NSInteger aVersion) {
	@autoreleasepool {
		[CBCharacteristic setVersion:aVersion];
	}
}
void*
CBCharacteristic_Superclass() {
	Class ret;
	@autoreleasepool {
		ret = [CBCharacteristic superclass];
	}
	return ret;

}
BOOL
CBCharacteristic_InstancesRespondToSelector(void* aSelector) {
	BOOL ret;
	@autoreleasepool {
		ret = [CBCharacteristic instancesRespondToSelector:aSelector];
	}
	return ret;

}
void* _Nonnull
CBCharacteristic_ClassForKeyedUnarchiver() {
	Class _Nonnull ret;
	@autoreleasepool {
		ret = [CBCharacteristic classForKeyedUnarchiver];
	}
	return ret;

}
BOOL
CBCharacteristic_ResolveInstanceMethod(void* sel) {
	BOOL ret;
	@autoreleasepool {
		ret = [CBCharacteristic resolveInstanceMethod:sel];
	}
	return ret;

}
void*
CBCharacteristic_AllocWithZone(void* zone) {
	return [CBCharacteristic allocWithZone:zone];
}
NSInteger
CBCharacteristic_Version() {
	NSInteger ret;
	@autoreleasepool {
		ret = [CBCharacteristic version];
	}
	return ret;

}
void* _Nonnull
CBCharacteristic_ClassFallbacksForKeyedArchiver() {
	NSArray* _Nonnull ret;
	@autoreleasepool {
		ret = [CBCharacteristic classFallbacksForKeyedArchiver];
	}
	return ret;

}
void*
CBCharacteristic_Class() {
	Class ret;
	@autoreleasepool {
		ret = [CBCharacteristic class];
	}
	return ret;

}
NSUInteger
CBCharacteristic_Hash() {
	NSUInteger ret;
	@autoreleasepool {
		ret = [CBCharacteristic hash];
	}
	return ret;

}
void* _Nonnull
CBCharacteristic_inst_ClassForCoder(void* o) {
	Class _Nonnull ret;
	@autoreleasepool {
		ret = [(CBCharacteristic*)o classForCoder];
	}
	return ret;

}
void
CBCharacteristic_inst_WillChangeValuesAtIndexes(void* o, NSKeyValueChange changeKind, void* indexes, void* key) {
	@autoreleasepool {
		[(CBCharacteristic*)o willChange:changeKind valuesAtIndexes:indexes forKey:key];
	}
}
void
CBCharacteristic_inst_WillChangeValuesAtIndexesForKey(void* o, NSKeyValueChange changeKind, void* indexes, void* key) {
	@autoreleasepool {
		[(CBCharacteristic*)o willChange:changeKind valuesAtIndexes:indexes forKey:key];
	}
}
void* _Nullable
CBCharacteristic_inst_ValueForKeyPath(void* o, void* keyPath) {
	NSObject* _Nullable ret;
	@autoreleasepool {
		ret = [(CBCharacteristic*)o valueForKeyPath:keyPath];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
void* _Nullable
CBCharacteristic_inst_Value(void* o) {
	NSData* _Nullable ret;
	@autoreleasepool {
		ret = [(CBCharacteristic*)o value];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
void* _Nullable
CBCharacteristic_inst_ValueWithUniqueIDInPropertyWithKey(void* o, void* uniqueID, void* key) {
	NSObject* _Nullable ret;
	@autoreleasepool {
		ret = [(CBCharacteristic*)o valueWithUniqueID:uniqueID inPropertyWithKey:key];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
void* _Nonnull
CBCharacteristic_inst_MutableArrayValueForKey(void* o, void* key) {
	NSMutableArray* _Nonnull ret;
	@autoreleasepool {
		ret = [(CBCharacteristic*)o mutableArrayValueForKey:key];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
void* _Nonnull
CBCharacteristic_inst_ClassName(void* o) {
	NSString* _Nonnull ret;
	@autoreleasepool {
		ret = [(CBCharacteristic*)o className];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
void* _Nullable
CBCharacteristic_inst_ClassForArchiver(void* o) {
	Class _Nullable ret;
	@autoreleasepool {
		ret = [(CBCharacteristic*)o classForArchiver];
	}
	return ret;

}
void* _Nullable
CBCharacteristic_inst_CopyScriptingValueForKey(void* o, void* value, void* key, void* properties) {
	NSObject* _Nullable ret;
	@autoreleasepool {
		ret = [(CBCharacteristic*)o copyScriptingValue:value forKey:key withProperties:properties];
	}
	return ret;

}
void* _Nullable
CBCharacteristic_inst_CopyScriptingValueForKeyWithProperties(void* o, void* value, void* key, void* properties) {
	NSObject* _Nullable ret;
	@autoreleasepool {
		ret = [(CBCharacteristic*)o copyScriptingValue:value forKey:key withProperties:properties];
	}
	return ret;

}
BOOL
CBCharacteristic_inst_IsNotifying(void* o) {
	BOOL ret;
	@autoreleasepool {
		ret = [(CBCharacteristic*)o isNotifying];
	}
	return ret;

}
void* _Nullable
CBCharacteristic_inst_ScriptingValueForSpecifier(void* o, void* objectSpecifier) {
	NSObject* _Nullable ret;
	@autoreleasepool {
		ret = [(CBCharacteristic*)o scriptingValueForSpecifier:objectSpecifier];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
void
CBCharacteristic_inst_PerformSelectorWithObject(void* o, void* aSelector, void* anArgument, NSTimeInterval delay) {
	@autoreleasepool {
		[(CBCharacteristic*)o performSelector:aSelector withObject:anArgument afterDelay:delay];
	}
}
void
CBCharacteristic_inst_PerformSelectorWithObjectAfterDelay(void* o, void* aSelector, void* anArgument, NSTimeInterval delay) {
	@autoreleasepool {
		[(CBCharacteristic*)o performSelector:aSelector withObject:anArgument afterDelay:delay];
	}
}
void
CBCharacteristic_inst_PerformSelectorWithObjectAfterDelayInModes(void* o, void* aSelector, void* anArgument, NSTimeInterval delay, void* modes) {
	@autoreleasepool {
		[(CBCharacteristic*)o performSelector:aSelector withObject:anArgument afterDelay:delay inModes:modes];
	}
}
void
CBCharacteristic_inst_PerformSelectorOnThread(void* o, void* aSelector, void* thr, void* arg, BOOL wait) {
	@autoreleasepool {
		[(CBCharacteristic*)o performSelector:aSelector onThread:thr withObject:arg waitUntilDone:wait];
	}
}
void
CBCharacteristic_inst_PerformSelectorOnThreadWithObject(void* o, void* aSelector, void* thr, void* arg, BOOL wait) {
	@autoreleasepool {
		[(CBCharacteristic*)o performSelector:aSelector onThread:thr withObject:arg waitUntilDone:wait];
	}
}
void
CBCharacteristic_inst_PerformSelectorOnThreadWithObjectWaitUntilDone(void* o, void* aSelector, void* thr, void* arg, BOOL wait, void* array) {
	@autoreleasepool {
		[(CBCharacteristic*)o performSelector:aSelector onThread:thr withObject:arg waitUntilDone:wait modes:array];
	}
}
void
CBCharacteristic_inst_PerformSelectorOnThreadWithObjectWaitUntilDoneModes(void* o, void* aSelector, void* thr, void* arg, BOOL wait, void* array) {
	@autoreleasepool {
		[(CBCharacteristic*)o performSelector:aSelector onThread:thr withObject:arg waitUntilDone:wait modes:array];
	}
}
void
CBCharacteristic_inst_PerformSelectorInBackgroundWithObject(void* o, void* aSelector, void* arg) {
	@autoreleasepool {
		[(CBCharacteristic*)o performSelectorInBackground:aSelector withObject:arg];
	}
}
BOOL
CBCharacteristic_inst_ScriptingIsGreaterThan(void* o, void* object) {
	BOOL ret;
	@autoreleasepool {
		ret = [(CBCharacteristic*)o scriptingIsGreaterThan:object];
	}
	return ret;

}
void*
CBCharacteristic_inst_Copy(void* o) {
	NSObject* ret;
	@autoreleasepool {
		ret = [(CBCharacteristic*)o copy];
	}
	return ret;

}
void
CBCharacteristic_inst_ObserveValueForKeyPathOfObject(void* o, void* keyPath, void* object, void* change, void* context) {
	@autoreleasepool {
		[(CBCharacteristic*)o observeValueForKeyPath:keyPath ofObject:object change:change context:context];
	}
}
void
CBCharacteristic_inst_ObserveValueForKeyPathOfObjectChange(void* o, void* keyPath, void* object, void* change, void* context) {
	@autoreleasepool {
		[(CBCharacteristic*)o observeValueForKeyPath:keyPath ofObject:object change:change context:context];
	}
}
BOOL
CBCharacteristic_inst_IsLessThanOrEqualTo(void* o, void* object) {
	BOOL ret;
	@autoreleasepool {
		ret = [(CBCharacteristic*)o isLessThanOrEqualTo:object];
	}
	return ret;

}
void* _Nullable
CBCharacteristic_inst_ValueForUndefinedKey(void* o, void* key) {
	NSObject* _Nullable ret;
	@autoreleasepool {
		ret = [(CBCharacteristic*)o valueForUndefinedKey:key];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
void
CBCharacteristic_inst_PerformSelectorOnMainThreadWithObject(void* o, void* aSelector, void* arg, BOOL wait) {
	@autoreleasepool {
		[(CBCharacteristic*)o performSelectorOnMainThread:aSelector withObject:arg waitUntilDone:wait];
	}
}
void
CBCharacteristic_inst_PerformSelectorOnMainThreadWithObjectWaitUntilDone(void* o, void* aSelector, void* arg, BOOL wait) {
	@autoreleasepool {
		[(CBCharacteristic*)o performSelectorOnMainThread:aSelector withObject:arg waitUntilDone:wait];
	}
}
void
CBCharacteristic_inst_PerformSelectorOnMainThreadWithObjectWaitUntilDoneModes(void* o, void* aSelector, void* arg, BOOL wait, void* array) {
	@autoreleasepool {
		[(CBCharacteristic*)o performSelectorOnMainThread:aSelector withObject:arg waitUntilDone:wait modes:array];
	}
}
BOOL
CBCharacteristic_inst_ScriptingBeginsWith(void* o, void* object) {
	BOOL ret;
	@autoreleasepool {
		ret = [(CBCharacteristic*)o scriptingBeginsWith:object];
	}
	return ret;

}
void*
CBCharacteristic_inst_ForwardingTargetForSelector(void* o, void* aSelector) {
	NSObject* ret;
	@autoreleasepool {
		ret = [(CBCharacteristic*)o forwardingTargetForSelector:aSelector];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
void
CBCharacteristic_inst_RemoveValueAtIndexFromPropertyWithKey(void* o, NSUInteger index, void* key) {
	@autoreleasepool {
		[(CBCharacteristic*)o removeValueAtIndex:index fromPropertyWithKey:key];
	}
}
void*
CBCharacteristic_inst_ObservationInfo(void* o) {
	void* ret;
	@autoreleasepool {
		ret = [(CBCharacteristic*)o observationInfo];
	}
	return ret;

}
void* _Nullable
CBCharacteristic_inst_NewScriptingObjectOfClassForValueForKey(void* o, void* objectClass, void* key, void* contentsValue, void* properties) {
	NSObject* _Nullable ret;
	@autoreleasepool {
		ret = [(CBCharacteristic*)o newScriptingObjectOfClass:objectClass forValueForKey:key withContentsValue:contentsValue properties:properties];
	}
	return ret;

}
void* _Nullable
CBCharacteristic_inst_NewScriptingObjectOfClassForValueForKeyWithContentsValue(void* o, void* objectClass, void* key, void* contentsValue, void* properties) {
	NSObject* _Nullable ret;
	@autoreleasepool {
		ret = [(CBCharacteristic*)o newScriptingObjectOfClass:objectClass forValueForKey:key withContentsValue:contentsValue properties:properties];
	}
	return ret;

}
void
CBCharacteristic_inst_ForwardInvocation(void* o, void* anInvocation) {
	@autoreleasepool {
		[(CBCharacteristic*)o forwardInvocation:anInvocation];
	}
}
BOOL
CBCharacteristic_inst_IsLessThan(void* o, void* object) {
	BOOL ret;
	@autoreleasepool {
		ret = [(CBCharacteristic*)o isLessThan:object];
	}
	return ret;

}
void
CBCharacteristic_inst_DidChangeValueForKey(void* o, void* key) {
	@autoreleasepool {
		[(CBCharacteristic*)o didChangeValueForKey:key];
	}
}
void
CBCharacteristic_inst_DidChangeValueForKeyWithSetMutation(void* o, void* key, NSKeyValueSetMutationKind mutationKind, void* objects) {
	@autoreleasepool {
		[(CBCharacteristic*)o didChangeValueForKey:key withSetMutation:mutationKind usingObjects:objects];
	}
}
void
CBCharacteristic_inst_DidChangeValueForKeyWithSetMutationUsingObjects(void* o, void* key, NSKeyValueSetMutationKind mutationKind, void* objects) {
	@autoreleasepool {
		[(CBCharacteristic*)o didChangeValueForKey:key withSetMutation:mutationKind usingObjects:objects];
	}
}
void*
CBCharacteristic_inst_MethodSignatureForSelector(void* o, void* aSelector) {
	NSMethodSignature* ret;
	@autoreleasepool {
		ret = [(CBCharacteristic*)o methodSignatureForSelector:aSelector];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
void* _Nullable
CBCharacteristic_inst_IndicesOfObjectsByEvaluatingObjectSpecifier(void* o, void* specifier) {
	NSArray* _Nullable ret;
	@autoreleasepool {
		ret = [(CBCharacteristic*)o indicesOfObjectsByEvaluatingObjectSpecifier:specifier];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
void* _Nullable
CBCharacteristic_inst_InverseForRelationshipKey(void* o, void* relationshipKey) {
	NSString* _Nullable ret;
	@autoreleasepool {
		ret = [(CBCharacteristic*)o inverseForRelationshipKey:relationshipKey];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
BOOL
CBCharacteristic_inst_ValidateValueForKey(void* o, void** ioValue, void* inKey, void** outError) {
	BOOL ret;
	@autoreleasepool {
		ret = [(CBCharacteristic*)o validateValue:(id _Nullable* _Nonnull)ioValue forKey:inKey error:(NSError* _Nullable* _Nullable)outError];
		for(int i=0;i<1;i++) {
			if(ioValue[i] == 0) { break; }
			[(id)ioValue[i] retain];
		}
	
	
		for(int i=0;i<1;i++) {
			if(outError[i] == 0) { break; }
			[(id)outError[i] retain];
		}
	
	}
	return ret;

}
BOOL
CBCharacteristic_inst_ValidateValueForKeyPath(void* o, void** ioValue, void* inKeyPath, void** outError) {
	BOOL ret;
	@autoreleasepool {
		ret = [(CBCharacteristic*)o validateValue:(id _Nullable* _Nonnull)ioValue forKeyPath:inKeyPath error:(NSError* _Nullable* _Nullable)outError];
		for(int i=0;i<1;i++) {
			if(ioValue[i] == 0) { break; }
			[(id)ioValue[i] retain];
		}
	
	
		for(int i=0;i<1;i++) {
			if(outError[i] == 0) { break; }
			[(id)outError[i] retain];
		}
	
	}
	return ret;

}
BOOL
CBCharacteristic_inst_ValidateValueForKeyError(void* o, void** ioValue, void* inKey, void** outError) {
	BOOL ret;
	@autoreleasepool {
		ret = [(CBCharacteristic*)o validateValue:(id _Nullable* _Nonnull)ioValue forKey:inKey error:(NSError* _Nullable* _Nullable)outError];
		for(int i=0;i<1;i++) {
			if(ioValue[i] == 0) { break; }
			[(id)ioValue[i] retain];
		}
	
	
		for(int i=0;i<1;i++) {
			if(outError[i] == 0) { break; }
			[(id)outError[i] retain];
		}
	
	}
	return ret;

}
BOOL
CBCharacteristic_inst_ValidateValueForKeyPathError(void* o, void** ioValue, void* inKeyPath, void** outError) {
	BOOL ret;
	@autoreleasepool {
		ret = [(CBCharacteristic*)o validateValue:(id _Nullable* _Nonnull)ioValue forKeyPath:inKeyPath error:(NSError* _Nullable* _Nullable)outError];
		for(int i=0;i<1;i++) {
			if(ioValue[i] == 0) { break; }
			[(id)ioValue[i] retain];
		}
	
	
		for(int i=0;i<1;i++) {
			if(outError[i] == 0) { break; }
			[(id)outError[i] retain];
		}
	
	}
	return ret;

}
BOOL
CBCharacteristic_inst_ScriptingIsLessThanOrEqualTo(void* o, void* object) {
	BOOL ret;
	@autoreleasepool {
		ret = [(CBCharacteristic*)o scriptingIsLessThanOrEqualTo:object];
	}
	return ret;

}
void* _Nonnull
CBCharacteristic_inst_ClassDescription(void* o) {
	NSClassDescription* _Nonnull ret;
	@autoreleasepool {
		ret = [(CBCharacteristic*)o classDescription];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
BOOL
CBCharacteristic_inst_IsEqualTo(void* o, void* object) {
	BOOL ret;
	@autoreleasepool {
		ret = [(CBCharacteristic*)o isEqualTo:object];
	}
	return ret;

}
CBCharacteristicProperties
CBCharacteristic_inst_Properties(void* o) {
	CBCharacteristicProperties ret;
	@autoreleasepool {
		ret = [(CBCharacteristic*)o properties];
	}
	return ret;

}
void* _Nullable
CBCharacteristic_inst_ValueForKey(void* o, void* key) {
	NSObject* _Nullable ret;
	@autoreleasepool {
		ret = [(CBCharacteristic*)o valueForKey:key];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
void
CBCharacteristic_inst_ReplaceValueAtIndexInPropertyWithKey(void* o, NSUInteger index, void* key, void* value) {
	@autoreleasepool {
		[(CBCharacteristic*)o replaceValueAtIndex:index inPropertyWithKey:key withValue:value];
	}
}
void
CBCharacteristic_inst_ReplaceValueAtIndexInPropertyWithKeyWithValue(void* o, NSUInteger index, void* key, void* value) {
	@autoreleasepool {
		[(CBCharacteristic*)o replaceValueAtIndex:index inPropertyWithKey:key withValue:value];
	}
}
void* _Nonnull
CBCharacteristic_inst_MutableSetValueForKey(void* o, void* key) {
	NSMutableSet* _Nonnull ret;
	@autoreleasepool {
		ret = [(CBCharacteristic*)o mutableSetValueForKey:key];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
void* _Nonnull
CBCharacteristic_inst_UUID(void* o) {
	CBUUID* _Nonnull ret;
	@autoreleasepool {
		ret = [(CBCharacteristic*)o UUID];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
FourCharCode
CBCharacteristic_inst_ClassCode(void* o) {
	FourCharCode ret;
	@autoreleasepool {
		ret = [(CBCharacteristic*)o classCode];
	}
	return ret;

}
BOOL
CBCharacteristic_inst_IsNotEqualTo(void* o, void* object) {
	BOOL ret;
	@autoreleasepool {
		ret = [(CBCharacteristic*)o isNotEqualTo:object];
	}
	return ret;

}
void
CBCharacteristic_inst_RemoveObserverForKeyPath(void* o, void* observer, void* keyPath) {
	@autoreleasepool {
		[(CBCharacteristic*)o removeObserver:observer forKeyPath:keyPath];
	}
}
void
CBCharacteristic_inst_RemoveObserverForKeyPathContext(void* o, void* observer, void* keyPath, void* context) {
	@autoreleasepool {
		[(CBCharacteristic*)o removeObserver:observer forKeyPath:keyPath context:context];
	}
}
void* _Nonnull
CBCharacteristic_inst_ToOneRelationshipKeys(void* o) {
	NSArray* _Nonnull ret;
	@autoreleasepool {
		ret = [(CBCharacteristic*)o toOneRelationshipKeys];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
BOOL
CBCharacteristic_inst_ScriptingIsLessThan(void* o, void* object) {
	BOOL ret;
	@autoreleasepool {
		ret = [(CBCharacteristic*)o scriptingIsLessThan:object];
	}
	return ret;

}
void* _Nullable
CBCharacteristic_inst_ValueAtIndexInPropertyWithKey(void* o, NSUInteger index, void* key) {
	NSObject* _Nullable ret;
	@autoreleasepool {
		ret = [(CBCharacteristic*)o valueAtIndex:index inPropertyWithKey:key];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
void
CBCharacteristic_inst_Dealloc(void* o) {
	@autoreleasepool {
		[(CBCharacteristic*)o dealloc];
	}
}
void
CBCharacteristic_inst_SetValuesForKeysWithDictionary(void* o, void* keyedValues) {
	@autoreleasepool {
		[(CBCharacteristic*)o setValuesForKeysWithDictionary:keyedValues];
	}
}
void* _Nullable
CBCharacteristic_inst_ScriptingProperties(void* o) {
	NSDictionary* _Nullable ret;
	@autoreleasepool {
		ret = [(CBCharacteristic*)o scriptingProperties];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
void* _Nullable
CBCharacteristic_inst_Descriptors(void* o) {
	NSArray* _Nullable ret;
	@autoreleasepool {
		ret = [(CBCharacteristic*)o descriptors];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
void* _Nonnull
CBCharacteristic_inst_DictionaryWithValuesForKeys(void* o, void* keys) {
	NSDictionary* _Nonnull ret;
	@autoreleasepool {
		ret = [(CBCharacteristic*)o dictionaryWithValuesForKeys:keys];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
void
CBCharacteristic_inst_SetValueForKey(void* o, void* value, void* key) {
	@autoreleasepool {
		[(CBCharacteristic*)o setValue:value forKey:key];
	}
}
void
CBCharacteristic_inst_SetValueForKeyPath(void* o, void* value, void* keyPath) {
	@autoreleasepool {
		[(CBCharacteristic*)o setValue:value forKeyPath:keyPath];
	}
}
void
CBCharacteristic_inst_SetValueForUndefinedKey(void* o, void* value, void* key) {
	@autoreleasepool {
		[(CBCharacteristic*)o setValue:value forUndefinedKey:key];
	}
}
BOOL
CBCharacteristic_inst_IsGreaterThanOrEqualTo(void* o, void* object) {
	BOOL ret;
	@autoreleasepool {
		ret = [(CBCharacteristic*)o isGreaterThanOrEqualTo:object];
	}
	return ret;

}
void* _Nullable
CBCharacteristic_inst_ObjectSpecifier(void* o) {
	NSScriptObjectSpecifier* _Nullable ret;
	@autoreleasepool {
		ret = [(CBCharacteristic*)o objectSpecifier];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
void* _Nullable
CBCharacteristic_inst_AwakeAfterUsingCoder(void* o, void* coder) {
	NSObject* _Nullable ret;
	@autoreleasepool {
		ret = [(CBCharacteristic*)o awakeAfterUsingCoder:coder];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
void
CBCharacteristic_inst_DidChangeValuesAtIndexes(void* o, NSKeyValueChange changeKind, void* indexes, void* key) {
	@autoreleasepool {
		[(CBCharacteristic*)o didChange:changeKind valuesAtIndexes:indexes forKey:key];
	}
}
void
CBCharacteristic_inst_DidChangeValuesAtIndexesForKey(void* o, NSKeyValueChange changeKind, void* indexes, void* key) {
	@autoreleasepool {
		[(CBCharacteristic*)o didChange:changeKind valuesAtIndexes:indexes forKey:key];
	}
}
void
CBCharacteristic_inst_AddObserverForKeyPath(void* o, void* observer, void* keyPath, NSKeyValueObservingOptions options, void* context) {
	@autoreleasepool {
		[(CBCharacteristic*)o addObserver:observer forKeyPath:keyPath options:options context:context];
	}
}
void
CBCharacteristic_inst_AddObserverForKeyPathOptions(void* o, void* observer, void* keyPath, NSKeyValueObservingOptions options, void* context) {
	@autoreleasepool {
		[(CBCharacteristic*)o addObserver:observer forKeyPath:keyPath options:options context:context];
	}
}
void*
CBCharacteristic_inst_MutableCopy(void* o) {
	NSObject* ret;
	@autoreleasepool {
		ret = [(CBCharacteristic*)o mutableCopy];
	}
	return ret;

}
void* _Nullable
CBCharacteristic_inst_CoerceValueForKey(void* o, void* value, void* key) {
	NSObject* _Nullable ret;
	@autoreleasepool {
		ret = [(CBCharacteristic*)o coerceValue:value forKey:key];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
void
CBCharacteristic_inst_SetObservationInfo(void* o, void* observationInfo) {
	@autoreleasepool {
		[(CBCharacteristic*)o setObservationInfo:observationInfo];
	}
}
BOOL
CBCharacteristic_inst_IsLike(void* o, void* object) {
	BOOL ret;
	@autoreleasepool {
		ret = [(CBCharacteristic*)o isLike:object];
	}
	return ret;

}
BOOL
CBCharacteristic_inst_ScriptingContains(void* o, void* object) {
	BOOL ret;
	@autoreleasepool {
		ret = [(CBCharacteristic*)o scriptingContains:object];
	}
	return ret;

}
BOOL
CBCharacteristic_inst_ScriptingEndsWith(void* o, void* object) {
	BOOL ret;
	@autoreleasepool {
		ret = [(CBCharacteristic*)o scriptingEndsWith:object];
	}
	return ret;

}
BOOL
CBCharacteristic_inst_IsCaseInsensitiveLike(void* o, void* object) {
	BOOL ret;
	@autoreleasepool {
		ret = [(CBCharacteristic*)o isCaseInsensitiveLike:object];
	}
	return ret;

}
void* _Nullable
CBCharacteristic_inst_ReplacementObjectForCoder(void* o, void* coder) {
	NSObject* _Nullable ret;
	@autoreleasepool {
		ret = [(CBCharacteristic*)o replacementObjectForCoder:coder];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
void
CBCharacteristic_inst_DoesNotRecognizeSelector(void* o, void* aSelector) {
	@autoreleasepool {
		[(CBCharacteristic*)o doesNotRecognizeSelector:aSelector];
	}
}
BOOL
CBCharacteristic_inst_IsGreaterThan(void* o, void* object) {
	BOOL ret;
	@autoreleasepool {
		ret = [(CBCharacteristic*)o isGreaterThan:object];
	}
	return ret;

}
void
CBCharacteristic_inst_SetScriptingProperties(void* o, void* scriptingProperties) {
	@autoreleasepool {
		[(CBCharacteristic*)o setScriptingProperties:scriptingProperties];
	}
}
void* _Nonnull
CBCharacteristic_inst_MutableOrderedSetValueForKeyPath(void* o, void* keyPath) {
	NSMutableOrderedSet* _Nonnull ret;
	@autoreleasepool {
		ret = [(CBCharacteristic*)o mutableOrderedSetValueForKeyPath:keyPath];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
void* _Nonnull
CBCharacteristic_inst_ToManyRelationshipKeys(void* o) {
	NSArray* _Nonnull ret;
	@autoreleasepool {
		ret = [(CBCharacteristic*)o toManyRelationshipKeys];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
void* _Nullable
CBCharacteristic_inst_ReplacementObjectForKeyedArchiver(void* o, void* archiver) {
	NSObject* _Nullable ret;
	@autoreleasepool {
		ret = [(CBCharacteristic*)o replacementObjectForKeyedArchiver:archiver];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
void* _Nonnull
CBCharacteristic_inst_MutableSetValueForKeyPath(void* o, void* keyPath) {
	NSMutableSet* _Nonnull ret;
	@autoreleasepool {
		ret = [(CBCharacteristic*)o mutableSetValueForKeyPath:keyPath];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
BOOL
CBCharacteristic_inst_AttemptRecoveryFromErrorOptionIndex(void* o, void* error, NSUInteger recoveryOptionIndex) {
	BOOL ret;
	@autoreleasepool {
		ret = [(CBCharacteristic*)o attemptRecoveryFromError:error optionIndex:recoveryOptionIndex];
	}
	return ret;

}
void
CBCharacteristic_inst_AttemptRecoveryFromErrorOptionIndexDelegate(void* o, void* error, NSUInteger recoveryOptionIndex, void* delegate, void* didRecoverSelector, void* contextInfo) {
	@autoreleasepool {
		[(CBCharacteristic*)o attemptRecoveryFromError:error optionIndex:recoveryOptionIndex delegate:delegate didRecoverSelector:didRecoverSelector contextInfo:contextInfo];
	}
}
void
CBCharacteristic_inst_AttemptRecoveryFromErrorOptionIndexDelegateDidRecoverSelector(void* o, void* error, NSUInteger recoveryOptionIndex, void* delegate, void* didRecoverSelector, void* contextInfo) {
	@autoreleasepool {
		[(CBCharacteristic*)o attemptRecoveryFromError:error optionIndex:recoveryOptionIndex delegate:delegate didRecoverSelector:didRecoverSelector contextInfo:contextInfo];
	}
}
void* _Nonnull
CBCharacteristic_inst_MutableArrayValueForKeyPath(void* o, void* keyPath) {
	NSMutableArray* _Nonnull ret;
	@autoreleasepool {
		ret = [(CBCharacteristic*)o mutableArrayValueForKeyPath:keyPath];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
void
CBCharacteristic_inst_WillChangeValueForKey(void* o, void* key) {
	@autoreleasepool {
		[(CBCharacteristic*)o willChangeValueForKey:key];
	}
}
void
CBCharacteristic_inst_WillChangeValueForKeyWithSetMutation(void* o, void* key, NSKeyValueSetMutationKind mutationKind, void* objects) {
	@autoreleasepool {
		[(CBCharacteristic*)o willChangeValueForKey:key withSetMutation:mutationKind usingObjects:objects];
	}
}
void
CBCharacteristic_inst_WillChangeValueForKeyWithSetMutationUsingObjects(void* o, void* key, NSKeyValueSetMutationKind mutationKind, void* objects) {
	@autoreleasepool {
		[(CBCharacteristic*)o willChangeValueForKey:key withSetMutation:mutationKind usingObjects:objects];
	}
}
void* _Nonnull
CBCharacteristic_inst_Service(void* o) {
	CBService* _Nonnull ret;
	@autoreleasepool {
		ret = [(CBCharacteristic*)o service];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
BOOL
CBCharacteristic_inst_ScriptingIsGreaterThanOrEqualTo(void* o, void* object) {
	BOOL ret;
	@autoreleasepool {
		ret = [(CBCharacteristic*)o scriptingIsGreaterThanOrEqualTo:object];
	}
	return ret;

}
void* _Nonnull
CBCharacteristic_inst_MutableOrderedSetValueForKey(void* o, void* key) {
	NSMutableOrderedSet* _Nonnull ret;
	@autoreleasepool {
		ret = [(CBCharacteristic*)o mutableOrderedSetValueForKey:key];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
BOOL
CBCharacteristic_inst_ScriptingIsEqualTo(void* o, void* object) {
	BOOL ret;
	@autoreleasepool {
		ret = [(CBCharacteristic*)o scriptingIsEqualTo:object];
	}
	return ret;

}
void* _Nonnull
CBCharacteristic_inst_AutoContentAccessingProxy(void* o) {
	NSObject* _Nonnull ret;
	@autoreleasepool {
		ret = [(CBCharacteristic*)o autoContentAccessingProxy];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
BOOL
CBCharacteristic_inst_DoesContain(void* o, void* object) {
	BOOL ret;
	@autoreleasepool {
		ret = [(CBCharacteristic*)o doesContain:object];
	}
	return ret;

}
void* _Nonnull
CBCharacteristic_inst_AttributeKeys(void* o) {
	NSArray* _Nonnull ret;
	@autoreleasepool {
		ret = [(CBCharacteristic*)o attributeKeys];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
void
CBCharacteristic_inst_InsertValueInPropertyWithKey(void* o, void* value, void* key) {
	@autoreleasepool {
		[(CBCharacteristic*)o insertValue:value inPropertyWithKey:key];
	}
}
void
CBCharacteristic_inst_InsertValueAtIndex(void* o, void* value, NSUInteger index, void* key) {
	@autoreleasepool {
		[(CBCharacteristic*)o insertValue:value atIndex:index inPropertyWithKey:key];
	}
}
void
CBCharacteristic_inst_InsertValueAtIndexInPropertyWithKey(void* o, void* value, NSUInteger index, void* key) {
	@autoreleasepool {
		[(CBCharacteristic*)o insertValue:value atIndex:index inPropertyWithKey:key];
	}
}
void* _Nullable
CBCharacteristic_inst_ValueWithNameInPropertyWithKey(void* o, void* name, void* key) {
	NSObject* _Nullable ret;
	@autoreleasepool {
		ret = [(CBCharacteristic*)o valueWithName:name inPropertyWithKey:key];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
void* _Nullable
CBCharacteristic_inst_ClassForKeyedArchiver(void* o) {
	Class _Nullable ret;
	@autoreleasepool {
		ret = [(CBCharacteristic*)o classForKeyedArchiver];
	}
	return ret;

}
void
CBCharacteristic_inst_SetNilValueForKey(void* o, void* key) {
	@autoreleasepool {
		[(CBCharacteristic*)o setNilValueForKey:key];
	}
}
void* _Nonnull
NSArray_ArrayWithObjects(void* firstObj) {
	NSArray* _Nonnull ret;
	@autoreleasepool {
		ret = [NSArray arrayWithObjects:firstObj,nil];
		if(ret != nil) { [ret retain]; }
	}
	return ret;

}
void* _Nonnull
NSArray_ArrayWithObjectsCount(void** objects, NSUInteger cnt) {
	NSArray* _Nonnull ret;
	@autoreleasepool {
		ret = [NSArray arrayWithObjects:(id _Nonnull const* _Nonnull)objects count:cnt];
		if(ret != nil) { [ret retain]; }
		for(int i=0;i<cnt;i++) {
			if(objects[i] == 0) { break; }
			[(id)objects[i] retain];
		}
	
	}
	return ret;

}
void
NSArray_CancelPreviousPerformRequestsWithTarget(void* aTarget) {
	@autoreleasepool {
		[NSArray cancelPreviousPerformRequestsWithTarget:aTarget];
	}
}
void
NSArray_CancelPreviousPerformRequestsWithTargetSelector(void* aTarget, void* aSelector, void* anArgument) {
	@autoreleasepool {
		[NSArray cancelPreviousPerformRequestsWithTarget:aTarget selector:aSelector object:anArgument];
	}
}
void
NSArray_CancelPreviousPerformRequestsWithTargetSelectorObject(void* aTarget, void* aSelector, void* anArgument) {
	@autoreleasepool {
		[NSArray cancelPreviousPerformRequestsWithTarget:aTarget selector:aSelector object:anArgument];
	}
}
void
NSArray_SetVersion(NSInteger aVersion) {
	@autoreleasepool {
		[NSArray setVersion:aVersion];
	}
}
void*
NSArray_Alloc() {
	return [NSArray alloc];
}
void*
NSArray_AllocWithZone(void* zone) {
	return [NSArray allocWithZone:zone];
}
BOOL
NSArray_InstancesRespondToSelector(void* aSelector) {
	BOOL ret;
	@autoreleasepool {
		ret = [NSArray instancesRespondToSelector:aSelector];
	}
	return ret;

}
void
NSArray_Load() {
	@autoreleasepool {
		[NSArray load];
	}
}
BOOL
NSArray_ResolveClassMethod(void* sel) {
	BOOL ret;
	@autoreleasepool {
		ret = [NSArray resolveClassMethod:sel];
	}
	return ret;

}
void*
NSArray_MutableCopyWithZone(void* zone) {
	NSObject* ret;
	@autoreleasepool {
		ret = [NSArray mutableCopyWithZone:zone];
	}
	return ret;

}
BOOL
NSArray_AccessInstanceVariablesDirectly() {
	BOOL ret;
	@autoreleasepool {
		ret = [NSArray accessInstanceVariablesDirectly];
	}
	return ret;

}
void*
NSArray_Description() {
	NSString* ret;
	@autoreleasepool {
		ret = [NSArray description];
	}
	return ret;

}
void*
NSArray_InstanceMethodSignatureForSelector(void* aSelector) {
	NSMethodSignature* ret;
	@autoreleasepool {
		ret = [NSArray instanceMethodSignatureForSelector:aSelector];
	}
	return ret;

}
void*
NSArray_Class() {
	Class ret;
	@autoreleasepool {
		ret = [NSArray class];
	}
	return ret;

}
void* _Nonnull
NSArray_ClassForKeyedUnarchiver() {
	Class _Nonnull ret;
	@autoreleasepool {
		ret = [NSArray classForKeyedUnarchiver];
	}
	return ret;

}
void* _Nonnull
NSArray_ArrayWithArray(void* array) {
	NSArray* _Nonnull ret;
	@autoreleasepool {
		ret = [NSArray arrayWithArray:array];
		if(ret != nil) { [ret retain]; }
	}
	return ret;

}
BOOL
NSArray_ResolveInstanceMethod(void* sel) {
	BOOL ret;
	@autoreleasepool {
		ret = [NSArray resolveInstanceMethod:sel];
	}
	return ret;

}
void*
NSArray_CopyWithZone(void* zone) {
	NSObject* ret;
	@autoreleasepool {
		ret = [NSArray copyWithZone:zone];
	}
	return ret;

}
void* _Nonnull
NSArray_KeyPathsForValuesAffectingValueForKey(void* key) {
	NSSet* _Nonnull ret;
	@autoreleasepool {
		ret = [NSArray keyPathsForValuesAffectingValueForKey:key];
	}
	return ret;

}
void* _Nonnull
NSArray_Array() {
	NSArray* _Nonnull ret;
	@autoreleasepool {
		ret = [NSArray array];
		if(ret != nil) { [ret retain]; }
	}
	return ret;

}
void*
NSArray_DebugDescription() {
	NSString* ret;
	@autoreleasepool {
		ret = [NSArray debugDescription];
	}
	return ret;

}
void* _Nonnull
NSArray_ClassFallbacksForKeyedArchiver() {
	NSArray* _Nonnull ret;
	@autoreleasepool {
		ret = [NSArray classFallbacksForKeyedArchiver];
	}
	return ret;

}
void* _Nullable
NSArray_ArrayWithContentsOfURLError(void* url, void** error) {
	NSArray* _Nullable ret;
	@autoreleasepool {
		ret = [NSArray arrayWithContentsOfURL:url error:(NSError* _Nullable* _Nullable)error];
		if(ret != nil) { [ret retain]; }
		for(int i=0;i<1;i++) {
			if(error[i] == 0) { break; }
			[(id)error[i] retain];
		}
	
	}
	return ret;

}
NSUInteger
NSArray_Hash() {
	NSUInteger ret;
	@autoreleasepool {
		ret = [NSArray hash];
	}
	return ret;

}
BOOL
NSArray_SupportsSecureCoding() {
	BOOL ret;
	@autoreleasepool {
		ret = [NSArray supportsSecureCoding];
	}
	return ret;

}
void* _Nonnull
NSArray_ArrayWithObject(void* anObject) {
	NSArray* _Nonnull ret;
	@autoreleasepool {
		ret = [NSArray arrayWithObject:anObject];
		if(ret != nil) { [ret retain]; }
	}
	return ret;

}
BOOL
NSArray_IsSubclassOfClass(void* aClass) {
	BOOL ret;
	@autoreleasepool {
		ret = [NSArray isSubclassOfClass:aClass];
	}
	return ret;

}
void*
NSArray_Superclass() {
	Class ret;
	@autoreleasepool {
		ret = [NSArray superclass];
	}
	return ret;

}
BOOL
NSArray_ConformsToProtocol(void* protocol) {
	BOOL ret;
	@autoreleasepool {
		ret = [NSArray conformsToProtocol:protocol];
	}
	return ret;

}
NSInteger
NSArray_Version() {
	NSInteger ret;
	@autoreleasepool {
		ret = [NSArray version];
	}
	return ret;

}
void*
NSArray_New() {
	NSArray* ret;
	@autoreleasepool {
		ret = [NSArray new];
	}
	return ret;

}
BOOL
NSArray_AutomaticallyNotifiesObserversForKey(void* key) {
	BOOL ret;
	@autoreleasepool {
		ret = [NSArray automaticallyNotifiesObserversForKey:key];
	}
	return ret;

}
BOOL
NSArray_inst_IsLessThanOrEqualTo(void* o, void* object) {
	BOOL ret;
	@autoreleasepool {
		ret = [(NSArray*)o isLessThanOrEqualTo:object];
	}
	return ret;

}
void
NSArray_inst_WillChangeValueForKey(void* o, void* key) {
	@autoreleasepool {
		[(NSArray*)o willChangeValueForKey:key];
	}
}
void
NSArray_inst_WillChangeValueForKeyWithSetMutation(void* o, void* key, NSKeyValueSetMutationKind mutationKind, void* objects) {
	@autoreleasepool {
		[(NSArray*)o willChangeValueForKey:key withSetMutation:mutationKind usingObjects:objects];
	}
}
void
NSArray_inst_WillChangeValueForKeyWithSetMutationUsingObjects(void* o, void* key, NSKeyValueSetMutationKind mutationKind, void* objects) {
	@autoreleasepool {
		[(NSArray*)o willChangeValueForKey:key withSetMutation:mutationKind usingObjects:objects];
	}
}
BOOL
NSArray_inst_IsLike(void* o, void* object) {
	BOOL ret;
	@autoreleasepool {
		ret = [(NSArray*)o isLike:object];
	}
	return ret;

}
void* _Nonnull
NSArray_inst_AttributeKeys(void* o) {
	NSArray* _Nonnull ret;
	@autoreleasepool {
		ret = [(NSArray*)o attributeKeys];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
NSUInteger
NSArray_inst_IndexOfObject(void* o, void* anObject) {
	NSUInteger ret;
	@autoreleasepool {
		ret = [(NSArray*)o indexOfObject:anObject];
	}
	return ret;

}
NSUInteger
NSArray_inst_IndexOfObjectInRange(void* o, void* anObject, NSRange range) {
	NSUInteger ret;
	@autoreleasepool {
		ret = [(NSArray*)o indexOfObject:anObject inRange:range];
	}
	return ret;

}
void* _Nullable
NSArray_inst_CopyScriptingValueForKey(void* o, void* value, void* key, void* properties) {
	NSObject* _Nullable ret;
	@autoreleasepool {
		ret = [(NSArray*)o copyScriptingValue:value forKey:key withProperties:properties];
	}
	return ret;

}
void* _Nullable
NSArray_inst_CopyScriptingValueForKeyWithProperties(void* o, void* value, void* key, void* properties) {
	NSObject* _Nullable ret;
	@autoreleasepool {
		ret = [(NSArray*)o copyScriptingValue:value forKey:key withProperties:properties];
	}
	return ret;

}
void
NSArray_inst_DoesNotRecognizeSelector(void* o, void* aSelector) {
	@autoreleasepool {
		[(NSArray*)o doesNotRecognizeSelector:aSelector];
	}
}
void* _Nonnull
NSArray_inst_DescriptionWithLocale(void* o, void* locale) {
	NSString* _Nonnull ret;
	@autoreleasepool {
		ret = [(NSArray*)o descriptionWithLocale:locale];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
void* _Nonnull
NSArray_inst_DescriptionWithLocaleIndent(void* o, void* locale, NSUInteger level) {
	NSString* _Nonnull ret;
	@autoreleasepool {
		ret = [(NSArray*)o descriptionWithLocale:locale indent:level];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
BOOL
NSArray_inst_IsEqualToArray(void* o, void* otherArray) {
	BOOL ret;
	@autoreleasepool {
		ret = [(NSArray*)o isEqualToArray:otherArray];
	}
	return ret;

}
void* _Nonnull
NSArray_inst_DictionaryWithValuesForKeys(void* o, void* keys) {
	NSDictionary* _Nonnull ret;
	@autoreleasepool {
		ret = [(NSArray*)o dictionaryWithValuesForKeys:keys];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
BOOL
NSArray_inst_ScriptingBeginsWith(void* o, void* object) {
	BOOL ret;
	@autoreleasepool {
		ret = [(NSArray*)o scriptingBeginsWith:object];
	}
	return ret;

}
void* _Nonnull
NSArray_inst_MutableCopyWithZone(void* o, void* zone) {
	NSObject* _Nonnull ret;
	@autoreleasepool {
		ret = [(NSArray*)o mutableCopyWithZone:zone];
	}
	return ret;

}
BOOL
NSArray_inst_WriteToURLError(void* o, void* url, void** error) {
	BOOL ret;
	@autoreleasepool {
		ret = [(NSArray*)o writeToURL:url error:(NSError* _Nullable* _Nullable)error];
		for(int i=0;i<1;i++) {
			if(error[i] == 0) { break; }
			[(id)error[i] retain];
		}
	
	}
	return ret;

}
void
NSArray_inst_GetObjectsRange(void* o, void** objects, NSRange range) {
	@autoreleasepool {
		[(NSArray*)o getObjects:(id _Nonnull* _Nonnull)objects range:range];
		for(int i=0;i<range.length;i++) {
			if(objects[i] == 0) { break; }
			[(id)objects[i] retain];
		}
	
	}
}
void* _Nonnull
NSArray_inst_MutableOrderedSetValueForKeyPath(void* o, void* keyPath) {
	NSMutableOrderedSet* _Nonnull ret;
	@autoreleasepool {
		ret = [(NSArray*)o mutableOrderedSetValueForKeyPath:keyPath];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
BOOL
NSArray_inst_IsCaseInsensitiveLike(void* o, void* object) {
	BOOL ret;
	@autoreleasepool {
		ret = [(NSArray*)o isCaseInsensitiveLike:object];
	}
	return ret;

}
void* _Nonnull
NSArray_inst_DifferenceFromArray(void* o, void* other) {
	NSOrderedCollectionDifference* _Nonnull ret;
	@autoreleasepool {
		ret = [(NSArray*)o differenceFromArray:other];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
void* _Nonnull
NSArray_inst_DifferenceFromArrayWithOptions(void* o, void* other, NSOrderedCollectionDifferenceCalculationOptions options) {
	NSOrderedCollectionDifference* _Nonnull ret;
	@autoreleasepool {
		ret = [(NSArray*)o differenceFromArray:other withOptions:options];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
void* _Nullable
NSArray_inst_InverseForRelationshipKey(void* o, void* relationshipKey) {
	NSString* _Nullable ret;
	@autoreleasepool {
		ret = [(NSArray*)o inverseForRelationshipKey:relationshipKey];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
BOOL
NSArray_inst_ScriptingContains(void* o, void* object) {
	BOOL ret;
	@autoreleasepool {
		ret = [(NSArray*)o scriptingContains:object];
	}
	return ret;

}
BOOL
NSArray_inst_ScriptingIsLessThanOrEqualTo(void* o, void* object) {
	BOOL ret;
	@autoreleasepool {
		ret = [(NSArray*)o scriptingIsLessThanOrEqualTo:object];
	}
	return ret;

}
void
NSArray_inst_RemoveObserverForKeyPath(void* o, void* observer, void* keyPath) {
	@autoreleasepool {
		[(NSArray*)o removeObserver:observer forKeyPath:keyPath];
	}
}
void
NSArray_inst_RemoveObserverForKeyPathContext(void* o, void* observer, void* keyPath, void* context) {
	@autoreleasepool {
		[(NSArray*)o removeObserver:observer forKeyPath:keyPath context:context];
	}
}
void
NSArray_inst_RemoveObserverFromObjectsAtIndexes(void* o, void* observer, void* indexes, void* keyPath) {
	@autoreleasepool {
		[(NSArray*)o removeObserver:observer fromObjectsAtIndexes:indexes forKeyPath:keyPath];
	}
}
void
NSArray_inst_RemoveObserverFromObjectsAtIndexesForKeyPath(void* o, void* observer, void* indexes, void* keyPath) {
	@autoreleasepool {
		[(NSArray*)o removeObserver:observer fromObjectsAtIndexes:indexes forKeyPath:keyPath];
	}
}
void
NSArray_inst_RemoveObserverFromObjectsAtIndexesForKeyPathContext(void* o, void* observer, void* indexes, void* keyPath, void* context) {
	@autoreleasepool {
		[(NSArray*)o removeObserver:observer fromObjectsAtIndexes:indexes forKeyPath:keyPath context:context];
	}
}
BOOL
NSArray_inst_ValidateValueForKey(void* o, void** ioValue, void* inKey, void** outError) {
	BOOL ret;
	@autoreleasepool {
		ret = [(NSArray*)o validateValue:(id _Nullable* _Nonnull)ioValue forKey:inKey error:(NSError* _Nullable* _Nullable)outError];
		for(int i=0;i<1;i++) {
			if(ioValue[i] == 0) { break; }
			[(id)ioValue[i] retain];
		}
	
	
		for(int i=0;i<1;i++) {
			if(outError[i] == 0) { break; }
			[(id)outError[i] retain];
		}
	
	}
	return ret;

}
BOOL
NSArray_inst_ValidateValueForKeyPath(void* o, void** ioValue, void* inKeyPath, void** outError) {
	BOOL ret;
	@autoreleasepool {
		ret = [(NSArray*)o validateValue:(id _Nullable* _Nonnull)ioValue forKeyPath:inKeyPath error:(NSError* _Nullable* _Nullable)outError];
		for(int i=0;i<1;i++) {
			if(ioValue[i] == 0) { break; }
			[(id)ioValue[i] retain];
		}
	
	
		for(int i=0;i<1;i++) {
			if(outError[i] == 0) { break; }
			[(id)outError[i] retain];
		}
	
	}
	return ret;

}
BOOL
NSArray_inst_ValidateValueForKeyError(void* o, void** ioValue, void* inKey, void** outError) {
	BOOL ret;
	@autoreleasepool {
		ret = [(NSArray*)o validateValue:(id _Nullable* _Nonnull)ioValue forKey:inKey error:(NSError* _Nullable* _Nullable)outError];
		for(int i=0;i<1;i++) {
			if(ioValue[i] == 0) { break; }
			[(id)ioValue[i] retain];
		}
	
	
		for(int i=0;i<1;i++) {
			if(outError[i] == 0) { break; }
			[(id)outError[i] retain];
		}
	
	}
	return ret;

}
BOOL
NSArray_inst_ValidateValueForKeyPathError(void* o, void** ioValue, void* inKeyPath, void** outError) {
	BOOL ret;
	@autoreleasepool {
		ret = [(NSArray*)o validateValue:(id _Nullable* _Nonnull)ioValue forKeyPath:inKeyPath error:(NSError* _Nullable* _Nullable)outError];
		for(int i=0;i<1;i++) {
			if(ioValue[i] == 0) { break; }
			[(id)ioValue[i] retain];
		}
	
	
		for(int i=0;i<1;i++) {
			if(outError[i] == 0) { break; }
			[(id)outError[i] retain];
		}
	
	}
	return ret;

}
BOOL
NSArray_inst_IsEqualTo(void* o, void* object) {
	BOOL ret;
	@autoreleasepool {
		ret = [(NSArray*)o isEqualTo:object];
	}
	return ret;

}
void* _Nullable
NSArray_inst_LastObject(void* o) {
	NSObject* _Nullable ret;
	@autoreleasepool {
		ret = [(NSArray*)o lastObject];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
void* _Nonnull
NSArray_inst_ClassForCoder(void* o) {
	Class _Nonnull ret;
	@autoreleasepool {
		ret = [(NSArray*)o classForCoder];
	}
	return ret;

}
void
NSArray_inst_ObserveValueForKeyPathOfObject(void* o, void* keyPath, void* object, void* change, void* context) {
	@autoreleasepool {
		[(NSArray*)o observeValueForKeyPath:keyPath ofObject:object change:change context:context];
	}
}
void
NSArray_inst_ObserveValueForKeyPathOfObjectChange(void* o, void* keyPath, void* object, void* change, void* context) {
	@autoreleasepool {
		[(NSArray*)o observeValueForKeyPath:keyPath ofObject:object change:change context:context];
	}
}
void* _Nullable
NSArray_inst_ArrayByApplyingDifference(void* o, void* difference) {
	NSArray* _Nullable ret;
	@autoreleasepool {
		ret = [(NSArray*)o arrayByApplyingDifference:difference];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
void
NSArray_inst_SetScriptingProperties(void* o, void* scriptingProperties) {
	@autoreleasepool {
		[(NSArray*)o setScriptingProperties:scriptingProperties];
	}
}
void
NSArray_inst_ForwardInvocation(void* o, void* anInvocation) {
	@autoreleasepool {
		[(NSArray*)o forwardInvocation:anInvocation];
	}
}
void* _Nonnull
NSArray_inst_InitWithObjects(void* o, void* firstObj) {
	NSArray* _Nonnull ret;
	@autoreleasepool {
		ret = [(NSArray*)o initWithObjects:firstObj,nil];
	}
	return ret;

}
void* _Nonnull
NSArray_inst_InitWithObjectsCount(void* o, void** objects, NSUInteger cnt) {
	NSArray* _Nonnull ret;
	@autoreleasepool {
		ret = [(NSArray*)o initWithObjects:(id _Nonnull const* _Nullable)objects count:cnt];
		for(int i=0;i<cnt;i++) {
			if(objects[i] == 0) { break; }
			[(id)objects[i] retain];
		}
	
	}
	return ret;

}
void
NSArray_inst_DidChangeValuesAtIndexes(void* o, NSKeyValueChange changeKind, void* indexes, void* key) {
	@autoreleasepool {
		[(NSArray*)o didChange:changeKind valuesAtIndexes:indexes forKey:key];
	}
}
void
NSArray_inst_DidChangeValuesAtIndexesForKey(void* o, NSKeyValueChange changeKind, void* indexes, void* key) {
	@autoreleasepool {
		[(NSArray*)o didChange:changeKind valuesAtIndexes:indexes forKey:key];
	}
}
BOOL
NSArray_inst_AttemptRecoveryFromErrorOptionIndex(void* o, void* error, NSUInteger recoveryOptionIndex) {
	BOOL ret;
	@autoreleasepool {
		ret = [(NSArray*)o attemptRecoveryFromError:error optionIndex:recoveryOptionIndex];
	}
	return ret;

}
void
NSArray_inst_AttemptRecoveryFromErrorOptionIndexDelegate(void* o, void* error, NSUInteger recoveryOptionIndex, void* delegate, void* didRecoverSelector, void* contextInfo) {
	@autoreleasepool {
		[(NSArray*)o attemptRecoveryFromError:error optionIndex:recoveryOptionIndex delegate:delegate didRecoverSelector:didRecoverSelector contextInfo:contextInfo];
	}
}
void
NSArray_inst_AttemptRecoveryFromErrorOptionIndexDelegateDidRecoverSelector(void* o, void* error, NSUInteger recoveryOptionIndex, void* delegate, void* didRecoverSelector, void* contextInfo) {
	@autoreleasepool {
		[(NSArray*)o attemptRecoveryFromError:error optionIndex:recoveryOptionIndex delegate:delegate didRecoverSelector:didRecoverSelector contextInfo:contextInfo];
	}
}
void
NSArray_inst_PerformSelectorInBackgroundWithObject(void* o, void* aSelector, void* arg) {
	@autoreleasepool {
		[(NSArray*)o performSelectorInBackground:aSelector withObject:arg];
	}
}
void* _Nonnull
NSArray_inst_InitWithArray(void* o, void* array) {
	NSArray* _Nonnull ret;
	@autoreleasepool {
		ret = [(NSArray*)o initWithArray:array];
	}
	return ret;

}
void* _Nonnull
NSArray_inst_InitWithArrayCopyItems(void* o, void* array, BOOL flag) {
	NSArray* _Nonnull ret;
	@autoreleasepool {
		ret = [(NSArray*)o initWithArray:array copyItems:flag];
	}
	return ret;

}
void*
NSArray_inst_ForwardingTargetForSelector(void* o, void* aSelector) {
	NSObject* ret;
	@autoreleasepool {
		ret = [(NSArray*)o forwardingTargetForSelector:aSelector];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
void* _Nonnull
NSArray_inst_AutoContentAccessingProxy(void* o) {
	NSObject* _Nonnull ret;
	@autoreleasepool {
		ret = [(NSArray*)o autoContentAccessingProxy];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
void* _Nonnull
NSArray_inst_SortedArrayUsingDescriptors(void* o, void* sortDescriptors) {
	NSArray* _Nonnull ret;
	@autoreleasepool {
		ret = [(NSArray*)o sortedArrayUsingDescriptors:sortDescriptors];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
void*
NSArray_inst_ObservationInfo(void* o) {
	void* ret;
	@autoreleasepool {
		ret = [(NSArray*)o observationInfo];
	}
	return ret;

}
void* _Nullable
NSArray_inst_NewScriptingObjectOfClassForValueForKey(void* o, void* objectClass, void* key, void* contentsValue, void* properties) {
	NSObject* _Nullable ret;
	@autoreleasepool {
		ret = [(NSArray*)o newScriptingObjectOfClass:objectClass forValueForKey:key withContentsValue:contentsValue properties:properties];
	}
	return ret;

}
void* _Nullable
NSArray_inst_NewScriptingObjectOfClassForValueForKeyWithContentsValue(void* o, void* objectClass, void* key, void* contentsValue, void* properties) {
	NSObject* _Nullable ret;
	@autoreleasepool {
		ret = [(NSArray*)o newScriptingObjectOfClass:objectClass forValueForKey:key withContentsValue:contentsValue properties:properties];
	}
	return ret;

}
void* _Nullable
NSArray_inst_ValueAtIndexInPropertyWithKey(void* o, NSUInteger index, void* key) {
	NSObject* _Nullable ret;
	@autoreleasepool {
		ret = [(NSArray*)o valueAtIndex:index inPropertyWithKey:key];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
void* _Nonnull
NSArray_inst_SortedArrayHint(void* o) {
	NSData* _Nonnull ret;
	@autoreleasepool {
		ret = [(NSArray*)o sortedArrayHint];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
BOOL
NSArray_inst_IsNotEqualTo(void* o, void* object) {
	BOOL ret;
	@autoreleasepool {
		ret = [(NSArray*)o isNotEqualTo:object];
	}
	return ret;

}
void* _Nonnull
NSArray_inst_ToManyRelationshipKeys(void* o) {
	NSArray* _Nonnull ret;
	@autoreleasepool {
		ret = [(NSArray*)o toManyRelationshipKeys];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
void
NSArray_inst_PerformSelectorOnMainThreadWithObject(void* o, void* aSelector, void* arg, BOOL wait) {
	@autoreleasepool {
		[(NSArray*)o performSelectorOnMainThread:aSelector withObject:arg waitUntilDone:wait];
	}
}
void
NSArray_inst_PerformSelectorOnMainThreadWithObjectWaitUntilDone(void* o, void* aSelector, void* arg, BOOL wait) {
	@autoreleasepool {
		[(NSArray*)o performSelectorOnMainThread:aSelector withObject:arg waitUntilDone:wait];
	}
}
void
NSArray_inst_PerformSelectorOnMainThreadWithObjectWaitUntilDoneModes(void* o, void* aSelector, void* arg, BOOL wait, void* array) {
	@autoreleasepool {
		[(NSArray*)o performSelectorOnMainThread:aSelector withObject:arg waitUntilDone:wait modes:array];
	}
}
void
NSArray_inst_MakeObjectsPerformSelector(void* o, void* aSelector) {
	@autoreleasepool {
		[(NSArray*)o makeObjectsPerformSelector:aSelector];
	}
}
void
NSArray_inst_MakeObjectsPerformSelectorWithObject(void* o, void* aSelector, void* argument) {
	@autoreleasepool {
		[(NSArray*)o makeObjectsPerformSelector:aSelector withObject:argument];
	}
}
void* _Nonnull
NSArray_inst_ReverseObjectEnumerator(void* o) {
	NSEnumerator* _Nonnull ret;
	@autoreleasepool {
		ret = [(NSArray*)o reverseObjectEnumerator];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
void* _Nullable
NSArray_inst_ReplacementObjectForCoder(void* o, void* coder) {
	NSObject* _Nullable ret;
	@autoreleasepool {
		ret = [(NSArray*)o replacementObjectForCoder:coder];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
void* _Nonnull
NSArray_inst_MutableSetValueForKeyPath(void* o, void* keyPath) {
	NSMutableSet* _Nonnull ret;
	@autoreleasepool {
		ret = [(NSArray*)o mutableSetValueForKeyPath:keyPath];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
void
NSArray_inst_SetValuesForKeysWithDictionary(void* o, void* keyedValues) {
	@autoreleasepool {
		[(NSArray*)o setValuesForKeysWithDictionary:keyedValues];
	}
}
void
NSArray_inst_ReplaceValueAtIndexInPropertyWithKey(void* o, NSUInteger index, void* key, void* value) {
	@autoreleasepool {
		[(NSArray*)o replaceValueAtIndex:index inPropertyWithKey:key withValue:value];
	}
}
void
NSArray_inst_ReplaceValueAtIndexInPropertyWithKeyWithValue(void* o, NSUInteger index, void* key, void* value) {
	@autoreleasepool {
		[(NSArray*)o replaceValueAtIndex:index inPropertyWithKey:key withValue:value];
	}
}
void* _Nonnull
NSArray_inst_ComponentsJoinedByString(void* o, void* separator) {
	NSString* _Nonnull ret;
	@autoreleasepool {
		ret = [(NSArray*)o componentsJoinedByString:separator];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
void* _Nonnull
NSArray_inst_Description(void* o) {
	NSString* _Nonnull ret;
	@autoreleasepool {
		ret = [(NSArray*)o description];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
void* _Nullable
NSArray_inst_FirstObject(void* o) {
	NSObject* _Nullable ret;
	@autoreleasepool {
		ret = [(NSArray*)o firstObject];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
BOOL
NSArray_inst_ScriptingIsLessThan(void* o, void* object) {
	BOOL ret;
	@autoreleasepool {
		ret = [(NSArray*)o scriptingIsLessThan:object];
	}
	return ret;

}
FourCharCode
NSArray_inst_ClassCode(void* o) {
	FourCharCode ret;
	@autoreleasepool {
		ret = [(NSArray*)o classCode];
	}
	return ret;

}
void
NSArray_inst_RemoveValueAtIndexFromPropertyWithKey(void* o, NSUInteger index, void* key) {
	@autoreleasepool {
		[(NSArray*)o removeValueAtIndex:index fromPropertyWithKey:key];
	}
}
void
NSArray_inst_InsertValueInPropertyWithKey(void* o, void* value, void* key) {
	@autoreleasepool {
		[(NSArray*)o insertValue:value inPropertyWithKey:key];
	}
}
void
NSArray_inst_InsertValueAtIndex(void* o, void* value, NSUInteger index, void* key) {
	@autoreleasepool {
		[(NSArray*)o insertValue:value atIndex:index inPropertyWithKey:key];
	}
}
void
NSArray_inst_InsertValueAtIndexInPropertyWithKey(void* o, void* value, NSUInteger index, void* key) {
	@autoreleasepool {
		[(NSArray*)o insertValue:value atIndex:index inPropertyWithKey:key];
	}
}
void* _Nonnull
NSArray_inst_CopyWithZone(void* o, void* zone) {
	NSObject* _Nonnull ret;
	@autoreleasepool {
		ret = [(NSArray*)o copyWithZone:zone];
	}
	return ret;

}
void* _Nonnull
NSArray_inst_MutableOrderedSetValueForKey(void* o, void* key) {
	NSMutableOrderedSet* _Nonnull ret;
	@autoreleasepool {
		ret = [(NSArray*)o mutableOrderedSetValueForKey:key];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
void* _Nullable
NSArray_inst_ObjectSpecifier(void* o) {
	NSScriptObjectSpecifier* _Nullable ret;
	@autoreleasepool {
		ret = [(NSArray*)o objectSpecifier];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
void
NSArray_inst_SetObservationInfo(void* o, void* observationInfo) {
	@autoreleasepool {
		[(NSArray*)o setObservationInfo:observationInfo];
	}
}
void* _Nonnull
NSArray_inst_ObjectsAtIndexes(void* o, void* indexes) {
	NSArray* _Nonnull ret;
	@autoreleasepool {
		ret = [(NSArray*)o objectsAtIndexes:indexes];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
NSUInteger
NSArray_inst_IndexOfObjectIdenticalTo(void* o, void* anObject) {
	NSUInteger ret;
	@autoreleasepool {
		ret = [(NSArray*)o indexOfObjectIdenticalTo:anObject];
	}
	return ret;

}
NSUInteger
NSArray_inst_IndexOfObjectIdenticalToInRange(void* o, void* anObject, NSRange range) {
	NSUInteger ret;
	@autoreleasepool {
		ret = [(NSArray*)o indexOfObjectIdenticalTo:anObject inRange:range];
	}
	return ret;

}
BOOL
NSArray_inst_ScriptingEndsWith(void* o, void* object) {
	BOOL ret;
	@autoreleasepool {
		ret = [(NSArray*)o scriptingEndsWith:object];
	}
	return ret;

}
void* _Nullable
NSArray_inst_ClassForKeyedArchiver(void* o) {
	Class _Nullable ret;
	@autoreleasepool {
		ret = [(NSArray*)o classForKeyedArchiver];
	}
	return ret;

}
NSUInteger
NSArray_inst_CountByEnumeratingWithStateObjects(void* o, void* state, void** buffer, NSUInteger len) {
	NSUInteger ret;
	@autoreleasepool {
		ret = [(NSArray*)o countByEnumeratingWithState:state objects:(id _Nullable* _Nonnull)buffer count:len];
		for(int i=0;i<len;i++) {
			if(buffer[i] == 0) { break; }
			[(id)buffer[i] retain];
		}
	
	}
	return ret;

}
NSUInteger
NSArray_inst_CountByEnumeratingWithStateObjectsCount(void* o, void* state, void** buffer, NSUInteger len) {
	NSUInteger ret;
	@autoreleasepool {
		ret = [(NSArray*)o countByEnumeratingWithState:state objects:(id _Nullable* _Nonnull)buffer count:len];
		for(int i=0;i<len;i++) {
			if(buffer[i] == 0) { break; }
			[(id)buffer[i] retain];
		}
	
	}
	return ret;

}
void
NSArray_inst_SetNilValueForKey(void* o, void* key) {
	@autoreleasepool {
		[(NSArray*)o setNilValueForKey:key];
	}
}
void*
NSArray_inst_Copy(void* o) {
	NSObject* ret;
	@autoreleasepool {
		ret = [(NSArray*)o copy];
	}
	return ret;

}
void
NSArray_inst_Dealloc(void* o) {
	@autoreleasepool {
		[(NSArray*)o dealloc];
	}
}
BOOL
NSArray_inst_DoesContain(void* o, void* object) {
	BOOL ret;
	@autoreleasepool {
		ret = [(NSArray*)o doesContain:object];
	}
	return ret;

}
void
NSArray_inst_DidChangeValueForKey(void* o, void* key) {
	@autoreleasepool {
		[(NSArray*)o didChangeValueForKey:key];
	}
}
void
NSArray_inst_DidChangeValueForKeyWithSetMutation(void* o, void* key, NSKeyValueSetMutationKind mutationKind, void* objects) {
	@autoreleasepool {
		[(NSArray*)o didChangeValueForKey:key withSetMutation:mutationKind usingObjects:objects];
	}
}
void
NSArray_inst_DidChangeValueForKeyWithSetMutationUsingObjects(void* o, void* key, NSKeyValueSetMutationKind mutationKind, void* objects) {
	@autoreleasepool {
		[(NSArray*)o didChangeValueForKey:key withSetMutation:mutationKind usingObjects:objects];
	}
}
void* _Nullable
NSArray_inst_ValueForKeyPath(void* o, void* keyPath) {
	NSObject* _Nullable ret;
	@autoreleasepool {
		ret = [(NSArray*)o valueForKeyPath:keyPath];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
BOOL
NSArray_inst_ScriptingIsEqualTo(void* o, void* object) {
	BOOL ret;
	@autoreleasepool {
		ret = [(NSArray*)o scriptingIsEqualTo:object];
	}
	return ret;

}
BOOL
NSArray_inst_ScriptingIsGreaterThan(void* o, void* object) {
	BOOL ret;
	@autoreleasepool {
		ret = [(NSArray*)o scriptingIsGreaterThan:object];
	}
	return ret;

}
void* _Nonnull
NSArray_inst_ObjectAtIndexedSubscript(void* o, NSUInteger idx) {
	NSObject* _Nonnull ret;
	@autoreleasepool {
		ret = [(NSArray*)o objectAtIndexedSubscript:idx];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
void* _Nonnull
NSArray_inst_SortedArrayUsingSelector(void* o, void* comparator) {
	NSArray* _Nonnull ret;
	@autoreleasepool {
		ret = [(NSArray*)o sortedArrayUsingSelector:comparator];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
void* _Nonnull
NSArray_inst_ArrayByAddingObject(void* o, void* anObject) {
	NSArray* _Nonnull ret;
	@autoreleasepool {
		ret = [(NSArray*)o arrayByAddingObject:anObject];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
void* _Nonnull
NSArray_inst_SubarrayWithRange(void* o, NSRange range) {
	NSArray* _Nonnull ret;
	@autoreleasepool {
		ret = [(NSArray*)o subarrayWithRange:range];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
void* _Nonnull
NSArray_inst_ToOneRelationshipKeys(void* o) {
	NSArray* _Nonnull ret;
	@autoreleasepool {
		ret = [(NSArray*)o toOneRelationshipKeys];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
void* _Nullable
NSArray_inst_ValueWithUniqueIDInPropertyWithKey(void* o, void* uniqueID, void* key) {
	NSObject* _Nullable ret;
	@autoreleasepool {
		ret = [(NSArray*)o valueWithUniqueID:uniqueID inPropertyWithKey:key];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
void* _Nonnull
NSArray_inst_ClassName(void* o) {
	NSString* _Nonnull ret;
	@autoreleasepool {
		ret = [(NSArray*)o className];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
void* _Nullable
NSArray_inst_ValueWithNameInPropertyWithKey(void* o, void* name, void* key) {
	NSObject* _Nullable ret;
	@autoreleasepool {
		ret = [(NSArray*)o valueWithName:name inPropertyWithKey:key];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
void*
NSArray_inst_MutableCopy(void* o) {
	NSObject* ret;
	@autoreleasepool {
		ret = [(NSArray*)o mutableCopy];
	}
	return ret;

}
BOOL
NSArray_inst_IsGreaterThanOrEqualTo(void* o, void* object) {
	BOOL ret;
	@autoreleasepool {
		ret = [(NSArray*)o isGreaterThanOrEqualTo:object];
	}
	return ret;

}
void* _Nullable
NSArray_inst_CoerceValueForKey(void* o, void* value, void* key) {
	NSObject* _Nullable ret;
	@autoreleasepool {
		ret = [(NSArray*)o coerceValue:value forKey:key];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
void* _Nonnull
NSArray_inst_ValueForKey(void* o, void* key) {
	NSObject* _Nonnull ret;
	@autoreleasepool {
		ret = [(NSArray*)o valueForKey:key];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
void* _Nonnull
NSArray_inst_PathsMatchingExtensions(void* o, void* filterTypes) {
	NSArray* _Nonnull ret;
	@autoreleasepool {
		ret = [(NSArray*)o pathsMatchingExtensions:filterTypes];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
void* _Nonnull
NSArray_inst_ClassDescription(void* o) {
	NSClassDescription* _Nonnull ret;
	@autoreleasepool {
		ret = [(NSArray*)o classDescription];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
void* _Nullable
NSArray_inst_AwakeAfterUsingCoder(void* o, void* coder) {
	NSObject* _Nullable ret;
	@autoreleasepool {
		ret = [(NSArray*)o awakeAfterUsingCoder:coder];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
void
NSArray_inst_SetValueForKey(void* o, void* value, void* key) {
	@autoreleasepool {
		[(NSArray*)o setValue:value forKey:key];
	}
}
void
NSArray_inst_SetValueForKeyPath(void* o, void* value, void* keyPath) {
	@autoreleasepool {
		[(NSArray*)o setValue:value forKeyPath:keyPath];
	}
}
void
NSArray_inst_SetValueForUndefinedKey(void* o, void* value, void* key) {
	@autoreleasepool {
		[(NSArray*)o setValue:value forUndefinedKey:key];
	}
}
void* _Nonnull
NSArray_inst_MutableSetValueForKey(void* o, void* key) {
	NSMutableSet* _Nonnull ret;
	@autoreleasepool {
		ret = [(NSArray*)o mutableSetValueForKey:key];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
BOOL
NSArray_inst_IsGreaterThan(void* o, void* object) {
	BOOL ret;
	@autoreleasepool {
		ret = [(NSArray*)o isGreaterThan:object];
	}
	return ret;

}
void* _Nullable
NSArray_inst_ClassForArchiver(void* o) {
	Class _Nullable ret;
	@autoreleasepool {
		ret = [(NSArray*)o classForArchiver];
	}
	return ret;

}
void
NSArray_inst_AddObserverForKeyPath(void* o, void* observer, void* keyPath, NSKeyValueObservingOptions options, void* context) {
	@autoreleasepool {
		[(NSArray*)o addObserver:observer forKeyPath:keyPath options:options context:context];
	}
}
void
NSArray_inst_AddObserverForKeyPathOptions(void* o, void* observer, void* keyPath, NSKeyValueObservingOptions options, void* context) {
	@autoreleasepool {
		[(NSArray*)o addObserver:observer forKeyPath:keyPath options:options context:context];
	}
}
void
NSArray_inst_AddObserverForKeyPathOptionsContext(void* o, void* observer, void* keyPath, NSKeyValueObservingOptions options, void* context) {
	@autoreleasepool {
		[(NSArray*)o addObserver:observer forKeyPath:keyPath options:options context:context];
	}
}
void
NSArray_inst_AddObserverToObjectsAtIndexes(void* o, void* observer, void* indexes, void* keyPath, NSKeyValueObservingOptions options, void* context) {
	@autoreleasepool {
		[(NSArray*)o addObserver:observer toObjectsAtIndexes:indexes forKeyPath:keyPath options:options context:context];
	}
}
void
NSArray_inst_AddObserverToObjectsAtIndexesForKeyPath(void* o, void* observer, void* indexes, void* keyPath, NSKeyValueObservingOptions options, void* context) {
	@autoreleasepool {
		[(NSArray*)o addObserver:observer toObjectsAtIndexes:indexes forKeyPath:keyPath options:options context:context];
	}
}
void* _Nonnull
NSArray_inst_Init(void* o) {
	NSArray* _Nonnull ret;
	@autoreleasepool {
		ret = [(NSArray*)o init];
	}
	return ret;

}
void* _Nullable
NSArray_inst_FirstObjectCommonWithArray(void* o, void* otherArray) {
	NSObject* _Nullable ret;
	@autoreleasepool {
		ret = [(NSArray*)o firstObjectCommonWithArray:otherArray];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
void* _Nonnull
NSArray_inst_MutableArrayValueForKeyPath(void* o, void* keyPath) {
	NSMutableArray* _Nonnull ret;
	@autoreleasepool {
		ret = [(NSArray*)o mutableArrayValueForKeyPath:keyPath];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
void* _Nonnull
NSArray_inst_ArrayByAddingObjectsFromArray(void* o, void* otherArray) {
	NSArray* _Nonnull ret;
	@autoreleasepool {
		ret = [(NSArray*)o arrayByAddingObjectsFromArray:otherArray];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
BOOL
NSArray_inst_ScriptingIsGreaterThanOrEqualTo(void* o, void* object) {
	BOOL ret;
	@autoreleasepool {
		ret = [(NSArray*)o scriptingIsGreaterThanOrEqualTo:object];
	}
	return ret;

}
void* _Nullable
NSArray_inst_ReplacementObjectForKeyedArchiver(void* o, void* archiver) {
	NSObject* _Nullable ret;
	@autoreleasepool {
		ret = [(NSArray*)o replacementObjectForKeyedArchiver:archiver];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
void* _Nonnull
NSArray_inst_ObjectEnumerator(void* o) {
	NSEnumerator* _Nonnull ret;
	@autoreleasepool {
		ret = [(NSArray*)o objectEnumerator];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
NSUInteger
NSArray_inst_Count(void* o) {
	NSUInteger ret;
	@autoreleasepool {
		ret = [(NSArray*)o count];
	}
	return ret;

}
void* _Nullable
NSArray_inst_InitWithCoder(void* o, void* coder) {
	NSArray* _Nullable ret;
	@autoreleasepool {
		ret = [(NSArray*)o initWithCoder:coder];
	}
	return ret;

}
BOOL
NSArray_inst_ContainsObject(void* o, void* anObject) {
	BOOL ret;
	@autoreleasepool {
		ret = [(NSArray*)o containsObject:anObject];
	}
	return ret;

}
void* _Nonnull
NSArray_inst_MutableArrayValueForKey(void* o, void* key) {
	NSMutableArray* _Nonnull ret;
	@autoreleasepool {
		ret = [(NSArray*)o mutableArrayValueForKey:key];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
void* _Nullable
NSArray_inst_ScriptingProperties(void* o) {
	NSDictionary* _Nullable ret;
	@autoreleasepool {
		ret = [(NSArray*)o scriptingProperties];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
void* _Nonnull
NSArray_inst_ObjectAtIndex(void* o, NSUInteger index) {
	NSObject* _Nonnull ret;
	@autoreleasepool {
		ret = [(NSArray*)o objectAtIndex:index];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
void* _Nullable
NSArray_inst_InitWithContentsOfURLError(void* o, void* url, void** error) {
	NSArray* _Nullable ret;
	@autoreleasepool {
		ret = [(NSArray*)o initWithContentsOfURL:url error:(NSError* _Nullable* _Nullable)error];
		for(int i=0;i<1;i++) {
			if(error[i] == 0) { break; }
			[(id)error[i] retain];
		}
	
	}
	return ret;

}
void* _Nullable
NSArray_inst_ScriptingValueForSpecifier(void* o, void* objectSpecifier) {
	NSObject* _Nullable ret;
	@autoreleasepool {
		ret = [(NSArray*)o scriptingValueForSpecifier:objectSpecifier];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
void* _Nonnull
NSArray_inst_FilteredArrayUsingPredicate(void* o, void* predicate) {
	NSArray* _Nonnull ret;
	@autoreleasepool {
		ret = [(NSArray*)o filteredArrayUsingPredicate:predicate];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
void
NSArray_inst_WillChangeValuesAtIndexes(void* o, NSKeyValueChange changeKind, void* indexes, void* key) {
	@autoreleasepool {
		[(NSArray*)o willChange:changeKind valuesAtIndexes:indexes forKey:key];
	}
}
void
NSArray_inst_WillChangeValuesAtIndexesForKey(void* o, NSKeyValueChange changeKind, void* indexes, void* key) {
	@autoreleasepool {
		[(NSArray*)o willChange:changeKind valuesAtIndexes:indexes forKey:key];
	}
}
void* _Nullable
NSArray_inst_IndicesOfObjectsByEvaluatingObjectSpecifier(void* o, void* specifier) {
	NSArray* _Nullable ret;
	@autoreleasepool {
		ret = [(NSArray*)o indicesOfObjectsByEvaluatingObjectSpecifier:specifier];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
void* _Nullable
NSArray_inst_ValueForUndefinedKey(void* o, void* key) {
	NSObject* _Nullable ret;
	@autoreleasepool {
		ret = [(NSArray*)o valueForUndefinedKey:key];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
BOOL
NSArray_inst_IsLessThan(void* o, void* object) {
	BOOL ret;
	@autoreleasepool {
		ret = [(NSArray*)o isLessThan:object];
	}
	return ret;

}
void*
NSArray_inst_MethodSignatureForSelector(void* o, void* aSelector) {
	NSMethodSignature* ret;
	@autoreleasepool {
		ret = [(NSArray*)o methodSignatureForSelector:aSelector];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
void
NSArray_inst_PerformSelectorWithObject(void* o, void* aSelector, void* anArgument, NSTimeInterval delay) {
	@autoreleasepool {
		[(NSArray*)o performSelector:aSelector withObject:anArgument afterDelay:delay];
	}
}
void
NSArray_inst_PerformSelectorWithObjectAfterDelay(void* o, void* aSelector, void* anArgument, NSTimeInterval delay) {
	@autoreleasepool {
		[(NSArray*)o performSelector:aSelector withObject:anArgument afterDelay:delay];
	}
}
void
NSArray_inst_PerformSelectorWithObjectAfterDelayInModes(void* o, void* aSelector, void* anArgument, NSTimeInterval delay, void* modes) {
	@autoreleasepool {
		[(NSArray*)o performSelector:aSelector withObject:anArgument afterDelay:delay inModes:modes];
	}
}
void
NSArray_inst_PerformSelectorOnThread(void* o, void* aSelector, void* thr, void* arg, BOOL wait) {
	@autoreleasepool {
		[(NSArray*)o performSelector:aSelector onThread:thr withObject:arg waitUntilDone:wait];
	}
}
void
NSArray_inst_PerformSelectorOnThreadWithObject(void* o, void* aSelector, void* thr, void* arg, BOOL wait) {
	@autoreleasepool {
		[(NSArray*)o performSelector:aSelector onThread:thr withObject:arg waitUntilDone:wait];
	}
}
void
NSArray_inst_PerformSelectorOnThreadWithObjectWaitUntilDone(void* o, void* aSelector, void* thr, void* arg, BOOL wait, void* array) {
	@autoreleasepool {
		[(NSArray*)o performSelector:aSelector onThread:thr withObject:arg waitUntilDone:wait modes:array];
	}
}
void
NSArray_inst_PerformSelectorOnThreadWithObjectWaitUntilDoneModes(void* o, void* aSelector, void* thr, void* arg, BOOL wait, void* array) {
	@autoreleasepool {
		[(NSArray*)o performSelector:aSelector onThread:thr withObject:arg waitUntilDone:wait modes:array];
	}
}
void
NSMutableArray_CancelPreviousPerformRequestsWithTarget(void* aTarget) {
	@autoreleasepool {
		[NSMutableArray cancelPreviousPerformRequestsWithTarget:aTarget];
	}
}
void
NSMutableArray_CancelPreviousPerformRequestsWithTargetSelector(void* aTarget, void* aSelector, void* anArgument) {
	@autoreleasepool {
		[NSMutableArray cancelPreviousPerformRequestsWithTarget:aTarget selector:aSelector object:anArgument];
	}
}
void
NSMutableArray_CancelPreviousPerformRequestsWithTargetSelectorObject(void* aTarget, void* aSelector, void* anArgument) {
	@autoreleasepool {
		[NSMutableArray cancelPreviousPerformRequestsWithTarget:aTarget selector:aSelector object:anArgument];
	}
}
void*
NSMutableArray_CopyWithZone(void* zone) {
	NSObject* ret;
	@autoreleasepool {
		ret = [NSMutableArray copyWithZone:zone];
	}
	return ret;

}
BOOL
NSMutableArray_SupportsSecureCoding() {
	BOOL ret;
	@autoreleasepool {
		ret = [NSMutableArray supportsSecureCoding];
	}
	return ret;

}
void* _Nullable
NSMutableArray_ArrayWithContentsOfFile(void* path) {
	NSMutableArray* _Nullable ret;
	@autoreleasepool {
		ret = [NSMutableArray arrayWithContentsOfFile:path];
		if(ret != nil) { [ret retain]; }
	}
	return ret;

}
void* _Nonnull
NSMutableArray_ArrayWithArray(void* array) {
	NSMutableArray* _Nonnull ret;
	@autoreleasepool {
		ret = [NSMutableArray arrayWithArray:array];
		if(ret != nil) { [ret retain]; }
	}
	return ret;

}
NSUInteger
NSMutableArray_Hash() {
	NSUInteger ret;
	@autoreleasepool {
		ret = [NSMutableArray hash];
	}
	return ret;

}
void*
NSMutableArray_Class() {
	Class ret;
	@autoreleasepool {
		ret = [NSMutableArray class];
	}
	return ret;

}
void* _Nonnull
NSMutableArray_ClassForKeyedUnarchiver() {
	Class _Nonnull ret;
	@autoreleasepool {
		ret = [NSMutableArray classForKeyedUnarchiver];
	}
	return ret;

}
BOOL
NSMutableArray_ResolveInstanceMethod(void* sel) {
	BOOL ret;
	@autoreleasepool {
		ret = [NSMutableArray resolveInstanceMethod:sel];
	}
	return ret;

}
BOOL
NSMutableArray_AutomaticallyNotifiesObserversForKey(void* key) {
	BOOL ret;
	@autoreleasepool {
		ret = [NSMutableArray automaticallyNotifiesObserversForKey:key];
	}
	return ret;

}
void
NSMutableArray_Load() {
	@autoreleasepool {
		[NSMutableArray load];
	}
}
BOOL
NSMutableArray_ResolveClassMethod(void* sel) {
	BOOL ret;
	@autoreleasepool {
		ret = [NSMutableArray resolveClassMethod:sel];
	}
	return ret;

}
BOOL
NSMutableArray_InstancesRespondToSelector(void* aSelector) {
	BOOL ret;
	@autoreleasepool {
		ret = [NSMutableArray instancesRespondToSelector:aSelector];
	}
	return ret;

}
void*
NSMutableArray_MutableCopyWithZone(void* zone) {
	NSObject* ret;
	@autoreleasepool {
		ret = [NSMutableArray mutableCopyWithZone:zone];
	}
	return ret;

}
void*
NSMutableArray_InstanceMethodSignatureForSelector(void* aSelector) {
	NSMethodSignature* ret;
	@autoreleasepool {
		ret = [NSMutableArray instanceMethodSignatureForSelector:aSelector];
	}
	return ret;

}
void*
NSMutableArray_DebugDescription() {
	NSString* ret;
	@autoreleasepool {
		ret = [NSMutableArray debugDescription];
	}
	return ret;

}
BOOL
NSMutableArray_IsSubclassOfClass(void* aClass) {
	BOOL ret;
	@autoreleasepool {
		ret = [NSMutableArray isSubclassOfClass:aClass];
	}
	return ret;

}
void* _Nonnull
NSMutableArray_ArrayWithCapacity(NSUInteger numItems) {
	NSMutableArray* _Nonnull ret;
	@autoreleasepool {
		ret = [NSMutableArray arrayWithCapacity:numItems];
		if(ret != nil) { [ret retain]; }
	}
	return ret;

}
void*
NSMutableArray_Alloc() {
	return [NSMutableArray alloc];
}
void*
NSMutableArray_Description() {
	NSString* ret;
	@autoreleasepool {
		ret = [NSMutableArray description];
	}
	return ret;

}
void* _Nonnull
NSMutableArray_KeyPathsForValuesAffectingValueForKey(void* key) {
	NSSet* _Nonnull ret;
	@autoreleasepool {
		ret = [NSMutableArray keyPathsForValuesAffectingValueForKey:key];
	}
	return ret;

}
void* _Nonnull
NSMutableArray_ClassFallbacksForKeyedArchiver() {
	NSArray* _Nonnull ret;
	@autoreleasepool {
		ret = [NSMutableArray classFallbacksForKeyedArchiver];
	}
	return ret;

}
void* _Nonnull
NSMutableArray_ArrayWithObject(void* anObject) {
	NSMutableArray* _Nonnull ret;
	@autoreleasepool {
		ret = [NSMutableArray arrayWithObject:anObject];
		if(ret != nil) { [ret retain]; }
	}
	return ret;

}
void*
NSMutableArray_Superclass() {
	Class ret;
	@autoreleasepool {
		ret = [NSMutableArray superclass];
	}
	return ret;

}
BOOL
NSMutableArray_ConformsToProtocol(void* protocol) {
	BOOL ret;
	@autoreleasepool {
		ret = [NSMutableArray conformsToProtocol:protocol];
	}
	return ret;

}
void* _Nonnull
NSMutableArray_ArrayWithObjects(void* firstObj) {
	NSMutableArray* _Nonnull ret;
	@autoreleasepool {
		ret = [NSMutableArray arrayWithObjects:firstObj,nil];
		if(ret != nil) { [ret retain]; }
	}
	return ret;

}
void* _Nonnull
NSMutableArray_ArrayWithObjectsCount(void** objects, NSUInteger cnt) {
	NSMutableArray* _Nonnull ret;
	@autoreleasepool {
		ret = [NSMutableArray arrayWithObjects:(id _Nonnull const* _Nonnull)objects count:cnt];
		if(ret != nil) { [ret retain]; }
		for(int i=0;i<cnt;i++) {
			if(objects[i] == 0) { break; }
			[(id)objects[i] retain];
		}
	
	}
	return ret;

}
void*
NSMutableArray_AllocWithZone(void* zone) {
	return [NSMutableArray allocWithZone:zone];
}
void*
NSMutableArray_New() {
	NSMutableArray* ret;
	@autoreleasepool {
		ret = [NSMutableArray new];
	}
	return ret;

}
BOOL
NSMutableArray_AccessInstanceVariablesDirectly() {
	BOOL ret;
	@autoreleasepool {
		ret = [NSMutableArray accessInstanceVariablesDirectly];
	}
	return ret;

}
void* _Nonnull
NSMutableArray_Array() {
	NSMutableArray* _Nonnull ret;
	@autoreleasepool {
		ret = [NSMutableArray array];
		if(ret != nil) { [ret retain]; }
	}
	return ret;

}
NSInteger
NSMutableArray_Version() {
	NSInteger ret;
	@autoreleasepool {
		ret = [NSMutableArray version];
	}
	return ret;

}
void* _Nullable
NSMutableArray_ArrayWithContentsOfURL(void* url) {
	NSMutableArray* _Nullable ret;
	@autoreleasepool {
		ret = [NSMutableArray arrayWithContentsOfURL:url];
		if(ret != nil) { [ret retain]; }
	}
	return ret;

}
void* _Nullable
NSMutableArray_ArrayWithContentsOfURLError(void* url, void** error) {
	NSArray* _Nullable ret;
	@autoreleasepool {
		ret = [NSMutableArray arrayWithContentsOfURL:url error:(NSError* _Nullable* _Nullable)error];
		if(ret != nil) { [ret retain]; }
		for(int i=0;i<1;i++) {
			if(error[i] == 0) { break; }
			[(id)error[i] retain];
		}
	
	}
	return ret;

}
void
NSMutableArray_SetVersion(NSInteger aVersion) {
	@autoreleasepool {
		[NSMutableArray setVersion:aVersion];
	}
}
NSUInteger
NSMutableArray_inst_IndexOfObjectIdenticalTo(void* o, void* anObject) {
	NSUInteger ret;
	@autoreleasepool {
		ret = [(NSMutableArray*)o indexOfObjectIdenticalTo:anObject];
	}
	return ret;

}
NSUInteger
NSMutableArray_inst_IndexOfObjectIdenticalToInRange(void* o, void* anObject, NSRange range) {
	NSUInteger ret;
	@autoreleasepool {
		ret = [(NSMutableArray*)o indexOfObjectIdenticalTo:anObject inRange:range];
	}
	return ret;

}
void*
NSMutableArray_inst_MutableCopy(void* o) {
	NSObject* ret;
	@autoreleasepool {
		ret = [(NSMutableArray*)o mutableCopy];
	}
	return ret;

}
void* _Nonnull
NSMutableArray_inst_ValueForKey(void* o, void* key) {
	NSObject* _Nonnull ret;
	@autoreleasepool {
		ret = [(NSMutableArray*)o valueForKey:key];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
void
NSMutableArray_inst_RemoveObjectAtIndex(void* o, NSUInteger index) {
	@autoreleasepool {
		[(NSMutableArray*)o removeObjectAtIndex:index];
	}
}
void
NSMutableArray_inst_FilterUsingPredicate(void* o, void* predicate) {
	@autoreleasepool {
		[(NSMutableArray*)o filterUsingPredicate:predicate];
	}
}
BOOL
NSMutableArray_inst_IsLessThanOrEqualTo(void* o, void* object) {
	BOOL ret;
	@autoreleasepool {
		ret = [(NSMutableArray*)o isLessThanOrEqualTo:object];
	}
	return ret;

}
void* _Nullable
NSMutableArray_inst_InverseForRelationshipKey(void* o, void* relationshipKey) {
	NSString* _Nullable ret;
	@autoreleasepool {
		ret = [(NSMutableArray*)o inverseForRelationshipKey:relationshipKey];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
void* _Nonnull
NSMutableArray_inst_MutableOrderedSetValueForKey(void* o, void* key) {
	NSMutableOrderedSet* _Nonnull ret;
	@autoreleasepool {
		ret = [(NSMutableArray*)o mutableOrderedSetValueForKey:key];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
NSUInteger
NSMutableArray_inst_Count(void* o) {
	NSUInteger ret;
	@autoreleasepool {
		ret = [(NSMutableArray*)o count];
	}
	return ret;

}
void*
NSMutableArray_inst_MethodSignatureForSelector(void* o, void* aSelector) {
	NSMethodSignature* ret;
	@autoreleasepool {
		ret = [(NSMutableArray*)o methodSignatureForSelector:aSelector];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
void
NSMutableArray_inst_SetScriptingProperties(void* o, void* scriptingProperties) {
	@autoreleasepool {
		[(NSMutableArray*)o setScriptingProperties:scriptingProperties];
	}
}
void* _Nullable
NSMutableArray_inst_ClassForKeyedArchiver(void* o) {
	Class _Nullable ret;
	@autoreleasepool {
		ret = [(NSMutableArray*)o classForKeyedArchiver];
	}
	return ret;

}
void* _Nullable
NSMutableArray_inst_FirstObjectCommonWithArray(void* o, void* otherArray) {
	NSObject* _Nullable ret;
	@autoreleasepool {
		ret = [(NSMutableArray*)o firstObjectCommonWithArray:otherArray];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
void
NSMutableArray_inst_DidChangeValuesAtIndexes(void* o, NSKeyValueChange changeKind, void* indexes, void* key) {
	@autoreleasepool {
		[(NSMutableArray*)o didChange:changeKind valuesAtIndexes:indexes forKey:key];
	}
}
void
NSMutableArray_inst_DidChangeValuesAtIndexesForKey(void* o, NSKeyValueChange changeKind, void* indexes, void* key) {
	@autoreleasepool {
		[(NSMutableArray*)o didChange:changeKind valuesAtIndexes:indexes forKey:key];
	}
}
void* _Nonnull
NSMutableArray_inst_ObjectEnumerator(void* o) {
	NSEnumerator* _Nonnull ret;
	@autoreleasepool {
		ret = [(NSMutableArray*)o objectEnumerator];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
void* _Nonnull
NSMutableArray_inst_MutableArrayValueForKey(void* o, void* key) {
	NSMutableArray* _Nonnull ret;
	@autoreleasepool {
		ret = [(NSMutableArray*)o mutableArrayValueForKey:key];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
void
NSMutableArray_inst_SetNilValueForKey(void* o, void* key) {
	@autoreleasepool {
		[(NSMutableArray*)o setNilValueForKey:key];
	}
}
NSUInteger
NSMutableArray_inst_CountByEnumeratingWithStateObjects(void* o, void* state, void** buffer, NSUInteger len) {
	NSUInteger ret;
	@autoreleasepool {
		ret = [(NSMutableArray*)o countByEnumeratingWithState:state objects:(id _Nullable* _Nonnull)buffer count:len];
		for(int i=0;i<len;i++) {
			if(buffer[i] == 0) { break; }
			[(id)buffer[i] retain];
		}
	
	}
	return ret;

}
NSUInteger
NSMutableArray_inst_CountByEnumeratingWithStateObjectsCount(void* o, void* state, void** buffer, NSUInteger len) {
	NSUInteger ret;
	@autoreleasepool {
		ret = [(NSMutableArray*)o countByEnumeratingWithState:state objects:(id _Nullable* _Nonnull)buffer count:len];
		for(int i=0;i<len;i++) {
			if(buffer[i] == 0) { break; }
			[(id)buffer[i] retain];
		}
	
	}
	return ret;

}
void* _Nonnull
NSMutableArray_inst_ArrayByAddingObjectsFromArray(void* o, void* otherArray) {
	NSArray* _Nonnull ret;
	@autoreleasepool {
		ret = [(NSMutableArray*)o arrayByAddingObjectsFromArray:otherArray];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
void* _Nonnull
NSMutableArray_inst_Init(void* o) {
	NSMutableArray* _Nonnull ret;
	@autoreleasepool {
		ret = [(NSMutableArray*)o init];
	}
	return ret;

}
void* _Nullable
NSMutableArray_inst_CopyScriptingValueForKey(void* o, void* value, void* key, void* properties) {
	NSObject* _Nullable ret;
	@autoreleasepool {
		ret = [(NSMutableArray*)o copyScriptingValue:value forKey:key withProperties:properties];
	}
	return ret;

}
void* _Nullable
NSMutableArray_inst_CopyScriptingValueForKeyWithProperties(void* o, void* value, void* key, void* properties) {
	NSObject* _Nullable ret;
	@autoreleasepool {
		ret = [(NSMutableArray*)o copyScriptingValue:value forKey:key withProperties:properties];
	}
	return ret;

}
void* _Nullable
NSMutableArray_inst_ValueAtIndexInPropertyWithKey(void* o, NSUInteger index, void* key) {
	NSObject* _Nullable ret;
	@autoreleasepool {
		ret = [(NSMutableArray*)o valueAtIndex:index inPropertyWithKey:key];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
void* _Nullable
NSMutableArray_inst_ReplacementObjectForCoder(void* o, void* coder) {
	NSObject* _Nullable ret;
	@autoreleasepool {
		ret = [(NSMutableArray*)o replacementObjectForCoder:coder];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
void* _Nonnull
NSMutableArray_inst_MutableSetValueForKeyPath(void* o, void* keyPath) {
	NSMutableSet* _Nonnull ret;
	@autoreleasepool {
		ret = [(NSMutableArray*)o mutableSetValueForKeyPath:keyPath];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
BOOL
NSMutableArray_inst_ContainsObject(void* o, void* anObject) {
	BOOL ret;
	@autoreleasepool {
		ret = [(NSMutableArray*)o containsObject:anObject];
	}
	return ret;

}
void* _Nonnull
NSMutableArray_inst_SortedArrayUsingSelector(void* o, void* comparator) {
	NSArray* _Nonnull ret;
	@autoreleasepool {
		ret = [(NSMutableArray*)o sortedArrayUsingSelector:comparator];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
void
NSMutableArray_inst_ReplaceObjectsInRangeWithObjectsFromArray(void* o, NSRange range, void* otherArray) {
	@autoreleasepool {
		[(NSMutableArray*)o replaceObjectsInRange:range withObjectsFromArray:otherArray];
	}
}
void
NSMutableArray_inst_ReplaceObjectsInRangeWithObjectsFromArrayRange(void* o, NSRange range, void* otherArray, NSRange otherRange) {
	@autoreleasepool {
		[(NSMutableArray*)o replaceObjectsInRange:range withObjectsFromArray:otherArray range:otherRange];
	}
}
void* _Nonnull
NSMutableArray_inst_DictionaryWithValuesForKeys(void* o, void* keys) {
	NSDictionary* _Nonnull ret;
	@autoreleasepool {
		ret = [(NSMutableArray*)o dictionaryWithValuesForKeys:keys];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
void* _Nonnull
NSMutableArray_inst_SortedArrayHint(void* o) {
	NSData* _Nonnull ret;
	@autoreleasepool {
		ret = [(NSMutableArray*)o sortedArrayHint];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
void* _Nonnull
NSMutableArray_inst_CopyWithZone(void* o, void* zone) {
	NSObject* _Nonnull ret;
	@autoreleasepool {
		ret = [(NSMutableArray*)o copyWithZone:zone];
	}
	return ret;

}
void
NSMutableArray_inst_Dealloc(void* o) {
	@autoreleasepool {
		[(NSMutableArray*)o dealloc];
	}
}
void
NSMutableArray_inst_SortUsingDescriptors(void* o, void* sortDescriptors) {
	@autoreleasepool {
		[(NSMutableArray*)o sortUsingDescriptors:sortDescriptors];
	}
}
void
NSMutableArray_inst_PerformSelectorWithObject(void* o, void* aSelector, void* anArgument, NSTimeInterval delay) {
	@autoreleasepool {
		[(NSMutableArray*)o performSelector:aSelector withObject:anArgument afterDelay:delay];
	}
}
void
NSMutableArray_inst_PerformSelectorWithObjectAfterDelay(void* o, void* aSelector, void* anArgument, NSTimeInterval delay) {
	@autoreleasepool {
		[(NSMutableArray*)o performSelector:aSelector withObject:anArgument afterDelay:delay];
	}
}
void
NSMutableArray_inst_PerformSelectorWithObjectAfterDelayInModes(void* o, void* aSelector, void* anArgument, NSTimeInterval delay, void* modes) {
	@autoreleasepool {
		[(NSMutableArray*)o performSelector:aSelector withObject:anArgument afterDelay:delay inModes:modes];
	}
}
void
NSMutableArray_inst_PerformSelectorOnThread(void* o, void* aSelector, void* thr, void* arg, BOOL wait) {
	@autoreleasepool {
		[(NSMutableArray*)o performSelector:aSelector onThread:thr withObject:arg waitUntilDone:wait];
	}
}
void
NSMutableArray_inst_PerformSelectorOnThreadWithObject(void* o, void* aSelector, void* thr, void* arg, BOOL wait) {
	@autoreleasepool {
		[(NSMutableArray*)o performSelector:aSelector onThread:thr withObject:arg waitUntilDone:wait];
	}
}
void
NSMutableArray_inst_PerformSelectorOnThreadWithObjectWaitUntilDone(void* o, void* aSelector, void* thr, void* arg, BOOL wait) {
	@autoreleasepool {
		[(NSMutableArray*)o performSelector:aSelector onThread:thr withObject:arg waitUntilDone:wait];
	}
}
void
NSMutableArray_inst_PerformSelectorOnThreadWithObjectWaitUntilDoneModes(void* o, void* aSelector, void* thr, void* arg, BOOL wait, void* array) {
	@autoreleasepool {
		[(NSMutableArray*)o performSelector:aSelector onThread:thr withObject:arg waitUntilDone:wait modes:array];
	}
}
void* _Nonnull
NSMutableArray_inst_AttributeKeys(void* o) {
	NSArray* _Nonnull ret;
	@autoreleasepool {
		ret = [(NSMutableArray*)o attributeKeys];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
void* _Nonnull
NSMutableArray_inst_DescriptionWithLocale(void* o, void* locale) {
	NSString* _Nonnull ret;
	@autoreleasepool {
		ret = [(NSMutableArray*)o descriptionWithLocale:locale];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
void* _Nonnull
NSMutableArray_inst_DescriptionWithLocaleIndent(void* o, void* locale, NSUInteger level) {
	NSString* _Nonnull ret;
	@autoreleasepool {
		ret = [(NSMutableArray*)o descriptionWithLocale:locale indent:level];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
BOOL
NSMutableArray_inst_IsEqualTo(void* o, void* object) {
	BOOL ret;
	@autoreleasepool {
		ret = [(NSMutableArray*)o isEqualTo:object];
	}
	return ret;

}
void
NSMutableArray_inst_SetObservationInfo(void* o, void* observationInfo) {
	@autoreleasepool {
		[(NSMutableArray*)o setObservationInfo:observationInfo];
	}
}
void* _Nonnull
NSMutableArray_inst_ObjectAtIndex(void* o, NSUInteger index) {
	NSObject* _Nonnull ret;
	@autoreleasepool {
		ret = [(NSMutableArray*)o objectAtIndex:index];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
void* _Nullable
NSMutableArray_inst_AwakeAfterUsingCoder(void* o, void* coder) {
	NSObject* _Nullable ret;
	@autoreleasepool {
		ret = [(NSMutableArray*)o awakeAfterUsingCoder:coder];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
void
NSMutableArray_inst_RemoveObjectsInArray(void* o, void* otherArray) {
	@autoreleasepool {
		[(NSMutableArray*)o removeObjectsInArray:otherArray];
	}
}
void
NSMutableArray_inst_InsertObjectAtIndex(void* o, void* anObject, NSUInteger index) {
	@autoreleasepool {
		[(NSMutableArray*)o insertObject:anObject atIndex:index];
	}
}
void
NSMutableArray_inst_AddObject(void* o, void* anObject) {
	@autoreleasepool {
		[(NSMutableArray*)o addObject:anObject];
	}
}
BOOL
NSMutableArray_inst_ScriptingContains(void* o, void* object) {
	BOOL ret;
	@autoreleasepool {
		ret = [(NSMutableArray*)o scriptingContains:object];
	}
	return ret;

}
void* _Nonnull
NSMutableArray_inst_AutoContentAccessingProxy(void* o) {
	NSObject* _Nonnull ret;
	@autoreleasepool {
		ret = [(NSMutableArray*)o autoContentAccessingProxy];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
void* _Nullable
NSMutableArray_inst_CoerceValueForKey(void* o, void* value, void* key) {
	NSObject* _Nullable ret;
	@autoreleasepool {
		ret = [(NSMutableArray*)o coerceValue:value forKey:key];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
void* _Nonnull
NSMutableArray_inst_ObjectAtIndexedSubscript(void* o, NSUInteger idx) {
	NSObject* _Nonnull ret;
	@autoreleasepool {
		ret = [(NSMutableArray*)o objectAtIndexedSubscript:idx];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
void* _Nullable
NSMutableArray_inst_ScriptingValueForSpecifier(void* o, void* objectSpecifier) {
	NSObject* _Nullable ret;
	@autoreleasepool {
		ret = [(NSMutableArray*)o scriptingValueForSpecifier:objectSpecifier];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
BOOL
NSMutableArray_inst_IsGreaterThan(void* o, void* object) {
	BOOL ret;
	@autoreleasepool {
		ret = [(NSMutableArray*)o isGreaterThan:object];
	}
	return ret;

}
BOOL
NSMutableArray_inst_ScriptingIsGreaterThanOrEqualTo(void* o, void* object) {
	BOOL ret;
	@autoreleasepool {
		ret = [(NSMutableArray*)o scriptingIsGreaterThanOrEqualTo:object];
	}
	return ret;

}
void
NSMutableArray_inst_ForwardInvocation(void* o, void* anInvocation) {
	@autoreleasepool {
		[(NSMutableArray*)o forwardInvocation:anInvocation];
	}
}
void* _Nonnull
NSMutableArray_inst_InitWithObjects(void* o, void* firstObj) {
	NSMutableArray* _Nonnull ret;
	@autoreleasepool {
		ret = [(NSMutableArray*)o initWithObjects:firstObj,nil];
	}
	return ret;

}
void* _Nonnull
NSMutableArray_inst_InitWithObjectsCount(void* o, void** objects, NSUInteger cnt) {
	NSMutableArray* _Nonnull ret;
	@autoreleasepool {
		ret = [(NSMutableArray*)o initWithObjects:(id _Nonnull const* _Nullable)objects count:cnt];
		for(int i=0;i<cnt;i++) {
			if(objects[i] == 0) { break; }
			[(id)objects[i] retain];
		}
	
	}
	return ret;

}
void
NSMutableArray_inst_PerformSelectorInBackgroundWithObject(void* o, void* aSelector, void* arg) {
	@autoreleasepool {
		[(NSMutableArray*)o performSelectorInBackground:aSelector withObject:arg];
	}
}
void
NSMutableArray_inst_PerformSelectorOnMainThreadWithObject(void* o, void* aSelector, void* arg, BOOL wait) {
	@autoreleasepool {
		[(NSMutableArray*)o performSelectorOnMainThread:aSelector withObject:arg waitUntilDone:wait];
	}
}
void
NSMutableArray_inst_PerformSelectorOnMainThreadWithObjectWaitUntilDone(void* o, void* aSelector, void* arg, BOOL wait) {
	@autoreleasepool {
		[(NSMutableArray*)o performSelectorOnMainThread:aSelector withObject:arg waitUntilDone:wait];
	}
}
void
NSMutableArray_inst_PerformSelectorOnMainThreadWithObjectWaitUntilDoneModes(void* o, void* aSelector, void* arg, BOOL wait, void* array) {
	@autoreleasepool {
		[(NSMutableArray*)o performSelectorOnMainThread:aSelector withObject:arg waitUntilDone:wait modes:array];
	}
}
void* _Nonnull
NSMutableArray_inst_MutableArrayValueForKeyPath(void* o, void* keyPath) {
	NSMutableArray* _Nonnull ret;
	@autoreleasepool {
		ret = [(NSMutableArray*)o mutableArrayValueForKeyPath:keyPath];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
void* _Nonnull
NSMutableArray_inst_ObjectsAtIndexes(void* o, void* indexes) {
	NSArray* _Nonnull ret;
	@autoreleasepool {
		ret = [(NSMutableArray*)o objectsAtIndexes:indexes];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
BOOL
NSMutableArray_inst_IsLessThan(void* o, void* object) {
	BOOL ret;
	@autoreleasepool {
		ret = [(NSMutableArray*)o isLessThan:object];
	}
	return ret;

}
void* _Nullable
NSMutableArray_inst_InitWithContentsOfFile(void* o, void* path) {
	NSMutableArray* _Nullable ret;
	@autoreleasepool {
		ret = [(NSMutableArray*)o initWithContentsOfFile:path];
	}
	return ret;

}
void
NSMutableArray_inst_RemoveObjectsAtIndexes(void* o, void* indexes) {
	@autoreleasepool {
		[(NSMutableArray*)o removeObjectsAtIndexes:indexes];
	}
}
void
NSMutableArray_inst_SetValueForKey(void* o, void* value, void* key) {
	@autoreleasepool {
		[(NSMutableArray*)o setValue:value forKey:key];
	}
}
void
NSMutableArray_inst_SetValueForKeyPath(void* o, void* value, void* keyPath) {
	@autoreleasepool {
		[(NSMutableArray*)o setValue:value forKeyPath:keyPath];
	}
}
void
NSMutableArray_inst_SetValueForUndefinedKey(void* o, void* value, void* key) {
	@autoreleasepool {
		[(NSMutableArray*)o setValue:value forUndefinedKey:key];
	}
}
void* _Nullable
NSMutableArray_inst_ReplacementObjectForKeyedArchiver(void* o, void* archiver) {
	NSObject* _Nullable ret;
	@autoreleasepool {
		ret = [(NSMutableArray*)o replacementObjectForKeyedArchiver:archiver];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
void
NSMutableArray_inst_AddObserverForKeyPath(void* o, void* observer, void* keyPath, NSKeyValueObservingOptions options, void* context) {
	@autoreleasepool {
		[(NSMutableArray*)o addObserver:observer forKeyPath:keyPath options:options context:context];
	}
}
void
NSMutableArray_inst_AddObserverForKeyPathOptions(void* o, void* observer, void* keyPath, NSKeyValueObservingOptions options, void* context) {
	@autoreleasepool {
		[(NSMutableArray*)o addObserver:observer forKeyPath:keyPath options:options context:context];
	}
}
void
NSMutableArray_inst_AddObserverForKeyPathOptionsContext(void* o, void* observer, void* keyPath, NSKeyValueObservingOptions options, void* context) {
	@autoreleasepool {
		[(NSMutableArray*)o addObserver:observer forKeyPath:keyPath options:options context:context];
	}
}
void
NSMutableArray_inst_AddObserverToObjectsAtIndexes(void* o, void* observer, void* indexes, void* keyPath, NSKeyValueObservingOptions options, void* context) {
	@autoreleasepool {
		[(NSMutableArray*)o addObserver:observer toObjectsAtIndexes:indexes forKeyPath:keyPath options:options context:context];
	}
}
void
NSMutableArray_inst_AddObserverToObjectsAtIndexesForKeyPath(void* o, void* observer, void* indexes, void* keyPath, NSKeyValueObservingOptions options, void* context) {
	@autoreleasepool {
		[(NSMutableArray*)o addObserver:observer toObjectsAtIndexes:indexes forKeyPath:keyPath options:options context:context];
	}
}
void
NSMutableArray_inst_SortUsingSelector(void* o, void* comparator) {
	@autoreleasepool {
		[(NSMutableArray*)o sortUsingSelector:comparator];
	}
}
void
NSMutableArray_inst_RemoveLastObject(void* o) {
	@autoreleasepool {
		[(NSMutableArray*)o removeLastObject];
	}
}
void* _Nonnull
NSMutableArray_inst_SortedArrayUsingDescriptors(void* o, void* sortDescriptors) {
	NSArray* _Nonnull ret;
	@autoreleasepool {
		ret = [(NSMutableArray*)o sortedArrayUsingDescriptors:sortDescriptors];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
BOOL
NSMutableArray_inst_ScriptingIsGreaterThan(void* o, void* object) {
	BOOL ret;
	@autoreleasepool {
		ret = [(NSMutableArray*)o scriptingIsGreaterThan:object];
	}
	return ret;

}
void* _Nonnull
NSMutableArray_inst_PathsMatchingExtensions(void* o, void* filterTypes) {
	NSArray* _Nonnull ret;
	@autoreleasepool {
		ret = [(NSMutableArray*)o pathsMatchingExtensions:filterTypes];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
void
NSMutableArray_inst_WillChangeValueForKey(void* o, void* key) {
	@autoreleasepool {
		[(NSMutableArray*)o willChangeValueForKey:key];
	}
}
void
NSMutableArray_inst_WillChangeValueForKeyWithSetMutation(void* o, void* key, NSKeyValueSetMutationKind mutationKind, void* objects) {
	@autoreleasepool {
		[(NSMutableArray*)o willChangeValueForKey:key withSetMutation:mutationKind usingObjects:objects];
	}
}
void
NSMutableArray_inst_WillChangeValueForKeyWithSetMutationUsingObjects(void* o, void* key, NSKeyValueSetMutationKind mutationKind, void* objects) {
	@autoreleasepool {
		[(NSMutableArray*)o willChangeValueForKey:key withSetMutation:mutationKind usingObjects:objects];
	}
}
void
NSMutableArray_inst_RemoveValueAtIndexFromPropertyWithKey(void* o, NSUInteger index, void* key) {
	@autoreleasepool {
		[(NSMutableArray*)o removeValueAtIndex:index fromPropertyWithKey:key];
	}
}
void
NSMutableArray_inst_WillChangeValuesAtIndexes(void* o, NSKeyValueChange changeKind, void* indexes, void* key) {
	@autoreleasepool {
		[(NSMutableArray*)o willChange:changeKind valuesAtIndexes:indexes forKey:key];
	}
}
void
NSMutableArray_inst_WillChangeValuesAtIndexesForKey(void* o, NSKeyValueChange changeKind, void* indexes, void* key) {
	@autoreleasepool {
		[(NSMutableArray*)o willChange:changeKind valuesAtIndexes:indexes forKey:key];
	}
}
BOOL
NSMutableArray_inst_ScriptingEndsWith(void* o, void* object) {
	BOOL ret;
	@autoreleasepool {
		ret = [(NSMutableArray*)o scriptingEndsWith:object];
	}
	return ret;

}
void* _Nullable
NSMutableArray_inst_InitWithContentsOfURL(void* o, void* url) {
	NSMutableArray* _Nullable ret;
	@autoreleasepool {
		ret = [(NSMutableArray*)o initWithContentsOfURL:url];
	}
	return ret;

}
void* _Nullable
NSMutableArray_inst_InitWithContentsOfURLError(void* o, void* url, void** error) {
	NSArray* _Nullable ret;
	@autoreleasepool {
		ret = [(NSMutableArray*)o initWithContentsOfURL:url error:(NSError* _Nullable* _Nullable)error];
		for(int i=0;i<1;i++) {
			if(error[i] == 0) { break; }
			[(id)error[i] retain];
		}
	
	}
	return ret;

}
NSUInteger
NSMutableArray_inst_IndexOfObject(void* o, void* anObject) {
	NSUInteger ret;
	@autoreleasepool {
		ret = [(NSMutableArray*)o indexOfObject:anObject];
	}
	return ret;

}
NSUInteger
NSMutableArray_inst_IndexOfObjectInRange(void* o, void* anObject, NSRange range) {
	NSUInteger ret;
	@autoreleasepool {
		ret = [(NSMutableArray*)o indexOfObject:anObject inRange:range];
	}
	return ret;

}
void* _Nonnull
NSMutableArray_inst_MutableCopyWithZone(void* o, void* zone) {
	NSObject* _Nonnull ret;
	@autoreleasepool {
		ret = [(NSMutableArray*)o mutableCopyWithZone:zone];
	}
	return ret;

}
BOOL
NSMutableArray_inst_IsNotEqualTo(void* o, void* object) {
	BOOL ret;
	@autoreleasepool {
		ret = [(NSMutableArray*)o isNotEqualTo:object];
	}
	return ret;

}
void
NSMutableArray_inst_ReplaceValueAtIndexInPropertyWithKey(void* o, NSUInteger index, void* key, void* value) {
	@autoreleasepool {
		[(NSMutableArray*)o replaceValueAtIndex:index inPropertyWithKey:key withValue:value];
	}
}
void
NSMutableArray_inst_ReplaceValueAtIndexInPropertyWithKeyWithValue(void* o, NSUInteger index, void* key, void* value) {
	@autoreleasepool {
		[(NSMutableArray*)o replaceValueAtIndex:index inPropertyWithKey:key withValue:value];
	}
}
void
NSMutableArray_inst_SetValuesForKeysWithDictionary(void* o, void* keyedValues) {
	@autoreleasepool {
		[(NSMutableArray*)o setValuesForKeysWithDictionary:keyedValues];
	}
}
void* _Nonnull
NSMutableArray_inst_MutableSetValueForKey(void* o, void* key) {
	NSMutableSet* _Nonnull ret;
	@autoreleasepool {
		ret = [(NSMutableArray*)o mutableSetValueForKey:key];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
BOOL
NSMutableArray_inst_ScriptingIsLessThan(void* o, void* object) {
	BOOL ret;
	@autoreleasepool {
		ret = [(NSMutableArray*)o scriptingIsLessThan:object];
	}
	return ret;

}
void* _Nullable
NSMutableArray_inst_ValueWithUniqueIDInPropertyWithKey(void* o, void* uniqueID, void* key) {
	NSObject* _Nullable ret;
	@autoreleasepool {
		ret = [(NSMutableArray*)o valueWithUniqueID:uniqueID inPropertyWithKey:key];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
BOOL
NSMutableArray_inst_IsGreaterThanOrEqualTo(void* o, void* object) {
	BOOL ret;
	@autoreleasepool {
		ret = [(NSMutableArray*)o isGreaterThanOrEqualTo:object];
	}
	return ret;

}
void* _Nonnull
NSMutableArray_inst_InitWithCapacity(void* o, NSUInteger numItems) {
	NSMutableArray* _Nonnull ret;
	@autoreleasepool {
		ret = [(NSMutableArray*)o initWithCapacity:numItems];
	}
	return ret;

}
void* _Nonnull
NSMutableArray_inst_MutableOrderedSetValueForKeyPath(void* o, void* keyPath) {
	NSMutableOrderedSet* _Nonnull ret;
	@autoreleasepool {
		ret = [(NSMutableArray*)o mutableOrderedSetValueForKeyPath:keyPath];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
void* _Nonnull
NSMutableArray_inst_ClassForCoder(void* o) {
	Class _Nonnull ret;
	@autoreleasepool {
		ret = [(NSMutableArray*)o classForCoder];
	}
	return ret;

}
void* _Nullable
NSMutableArray_inst_ArrayByApplyingDifference(void* o, void* difference) {
	NSArray* _Nullable ret;
	@autoreleasepool {
		ret = [(NSMutableArray*)o arrayByApplyingDifference:difference];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
void* _Nonnull
NSMutableArray_inst_FilteredArrayUsingPredicate(void* o, void* predicate) {
	NSArray* _Nonnull ret;
	@autoreleasepool {
		ret = [(NSMutableArray*)o filteredArrayUsingPredicate:predicate];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
void* _Nullable
NSMutableArray_inst_ValueForUndefinedKey(void* o, void* key) {
	NSObject* _Nullable ret;
	@autoreleasepool {
		ret = [(NSMutableArray*)o valueForUndefinedKey:key];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
void* _Nonnull
NSMutableArray_inst_ClassDescription(void* o) {
	NSClassDescription* _Nonnull ret;
	@autoreleasepool {
		ret = [(NSMutableArray*)o classDescription];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
void
NSMutableArray_inst_ReplaceObjectAtIndexWithObject(void* o, NSUInteger index, void* anObject) {
	@autoreleasepool {
		[(NSMutableArray*)o replaceObjectAtIndex:index withObject:anObject];
	}
}
void
NSMutableArray_inst_RemoveObjectIdenticalTo(void* o, void* anObject) {
	@autoreleasepool {
		[(NSMutableArray*)o removeObjectIdenticalTo:anObject];
	}
}
void
NSMutableArray_inst_RemoveObjectIdenticalToInRange(void* o, void* anObject, NSRange range) {
	@autoreleasepool {
		[(NSMutableArray*)o removeObjectIdenticalTo:anObject inRange:range];
	}
}
BOOL
NSMutableArray_inst_DoesContain(void* o, void* object) {
	BOOL ret;
	@autoreleasepool {
		ret = [(NSMutableArray*)o doesContain:object];
	}
	return ret;

}
void* _Nonnull
NSMutableArray_inst_ClassName(void* o) {
	NSString* _Nonnull ret;
	@autoreleasepool {
		ret = [(NSMutableArray*)o className];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
void*
NSMutableArray_inst_Copy(void* o) {
	NSObject* ret;
	@autoreleasepool {
		ret = [(NSMutableArray*)o copy];
	}
	return ret;

}
void
NSMutableArray_inst_RemoveAllObjects(void* o) {
	@autoreleasepool {
		[(NSMutableArray*)o removeAllObjects];
	}
}
void
NSMutableArray_inst_SetObjectAtIndexedSubscript(void* o, void* obj, NSUInteger idx) {
	@autoreleasepool {
		[(NSMutableArray*)o setObject:obj atIndexedSubscript:idx];
	}
}
void* _Nonnull
NSMutableArray_inst_ToManyRelationshipKeys(void* o) {
	NSArray* _Nonnull ret;
	@autoreleasepool {
		ret = [(NSMutableArray*)o toManyRelationshipKeys];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
FourCharCode
NSMutableArray_inst_ClassCode(void* o) {
	FourCharCode ret;
	@autoreleasepool {
		ret = [(NSMutableArray*)o classCode];
	}
	return ret;

}
void
NSMutableArray_inst_GetObjectsRange(void* o, void** objects, NSRange range) {
	@autoreleasepool {
		[(NSMutableArray*)o getObjects:(id _Nonnull* _Nonnull)objects range:range];
		for(int i=0;i<range.length;i++) {
			if(objects[i] == 0) { break; }
			[(id)objects[i] retain];
		}
	
	}
}
void
NSMutableArray_inst_RemoveObserverForKeyPath(void* o, void* observer, void* keyPath) {
	@autoreleasepool {
		[(NSMutableArray*)o removeObserver:observer forKeyPath:keyPath];
	}
}
void
NSMutableArray_inst_RemoveObserverForKeyPathContext(void* o, void* observer, void* keyPath, void* context) {
	@autoreleasepool {
		[(NSMutableArray*)o removeObserver:observer forKeyPath:keyPath context:context];
	}
}
void
NSMutableArray_inst_RemoveObserverFromObjectsAtIndexes(void* o, void* observer, void* indexes, void* keyPath) {
	@autoreleasepool {
		[(NSMutableArray*)o removeObserver:observer fromObjectsAtIndexes:indexes forKeyPath:keyPath];
	}
}
void
NSMutableArray_inst_RemoveObserverFromObjectsAtIndexesForKeyPath(void* o, void* observer, void* indexes, void* keyPath) {
	@autoreleasepool {
		[(NSMutableArray*)o removeObserver:observer fromObjectsAtIndexes:indexes forKeyPath:keyPath];
	}
}
void
NSMutableArray_inst_RemoveObserverFromObjectsAtIndexesForKeyPathContext(void* o, void* observer, void* indexes, void* keyPath, void* context) {
	@autoreleasepool {
		[(NSMutableArray*)o removeObserver:observer fromObjectsAtIndexes:indexes forKeyPath:keyPath context:context];
	}
}
void* _Nullable
NSMutableArray_inst_LastObject(void* o) {
	NSObject* _Nullable ret;
	@autoreleasepool {
		ret = [(NSMutableArray*)o lastObject];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
void* _Nullable
NSMutableArray_inst_NewScriptingObjectOfClassForValueForKey(void* o, void* objectClass, void* key, void* contentsValue, void* properties) {
	NSObject* _Nullable ret;
	@autoreleasepool {
		ret = [(NSMutableArray*)o newScriptingObjectOfClass:objectClass forValueForKey:key withContentsValue:contentsValue properties:properties];
	}
	return ret;

}
void* _Nullable
NSMutableArray_inst_NewScriptingObjectOfClassForValueForKeyWithContentsValue(void* o, void* objectClass, void* key, void* contentsValue, void* properties) {
	NSObject* _Nullable ret;
	@autoreleasepool {
		ret = [(NSMutableArray*)o newScriptingObjectOfClass:objectClass forValueForKey:key withContentsValue:contentsValue properties:properties];
	}
	return ret;

}
void* _Nullable
NSMutableArray_inst_NewScriptingObjectOfClassForValueForKeyWithContentsValueProperties(void* o, void* objectClass, void* key, void* contentsValue, void* properties) {
	NSObject* _Nullable ret;
	@autoreleasepool {
		ret = [(NSMutableArray*)o newScriptingObjectOfClass:objectClass forValueForKey:key withContentsValue:contentsValue properties:properties];
	}
	return ret;

}
void
NSMutableArray_inst_RemoveObjectsInRange(void* o, NSRange range) {
	@autoreleasepool {
		[(NSMutableArray*)o removeObjectsInRange:range];
	}
}
BOOL
NSMutableArray_inst_IsLike(void* o, void* object) {
	BOOL ret;
	@autoreleasepool {
		ret = [(NSMutableArray*)o isLike:object];
	}
	return ret;

}
BOOL
NSMutableArray_inst_IsEqualToArray(void* o, void* otherArray) {
	BOOL ret;
	@autoreleasepool {
		ret = [(NSMutableArray*)o isEqualToArray:otherArray];
	}
	return ret;

}
void
NSMutableArray_inst_MakeObjectsPerformSelector(void* o, void* aSelector) {
	@autoreleasepool {
		[(NSMutableArray*)o makeObjectsPerformSelector:aSelector];
	}
}
void
NSMutableArray_inst_MakeObjectsPerformSelectorWithObject(void* o, void* aSelector, void* argument) {
	@autoreleasepool {
		[(NSMutableArray*)o makeObjectsPerformSelector:aSelector withObject:argument];
	}
}
void* _Nonnull
NSMutableArray_inst_ToOneRelationshipKeys(void* o) {
	NSArray* _Nonnull ret;
	@autoreleasepool {
		ret = [(NSMutableArray*)o toOneRelationshipKeys];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
void* _Nullable
NSMutableArray_inst_ClassForArchiver(void* o) {
	Class _Nullable ret;
	@autoreleasepool {
		ret = [(NSMutableArray*)o classForArchiver];
	}
	return ret;

}
void
NSMutableArray_inst_ReplaceObjectsAtIndexesWithObjects(void* o, void* indexes, void* objects) {
	@autoreleasepool {
		[(NSMutableArray*)o replaceObjectsAtIndexes:indexes withObjects:objects];
	}
}
void
NSMutableArray_inst_RemoveObject(void* o, void* anObject) {
	@autoreleasepool {
		[(NSMutableArray*)o removeObject:anObject];
	}
}
void
NSMutableArray_inst_RemoveObjectInRange(void* o, void* anObject, NSRange range) {
	@autoreleasepool {
		[(NSMutableArray*)o removeObject:anObject inRange:range];
	}
}
BOOL
NSMutableArray_inst_ValidateValueForKey(void* o, void** ioValue, void* inKey, void** outError) {
	BOOL ret;
	@autoreleasepool {
		ret = [(NSMutableArray*)o validateValue:(id _Nullable* _Nonnull)ioValue forKey:inKey error:(NSError* _Nullable* _Nullable)outError];
		for(int i=0;i<1;i++) {
			if(ioValue[i] == 0) { break; }
			[(id)ioValue[i] retain];
		}
	
	
		for(int i=0;i<1;i++) {
			if(outError[i] == 0) { break; }
			[(id)outError[i] retain];
		}
	
	}
	return ret;

}
BOOL
NSMutableArray_inst_ValidateValueForKeyPath(void* o, void** ioValue, void* inKeyPath, void** outError) {
	BOOL ret;
	@autoreleasepool {
		ret = [(NSMutableArray*)o validateValue:(id _Nullable* _Nonnull)ioValue forKeyPath:inKeyPath error:(NSError* _Nullable* _Nullable)outError];
		for(int i=0;i<1;i++) {
			if(ioValue[i] == 0) { break; }
			[(id)ioValue[i] retain];
		}
	
	
		for(int i=0;i<1;i++) {
			if(outError[i] == 0) { break; }
			[(id)outError[i] retain];
		}
	
	}
	return ret;

}
BOOL
NSMutableArray_inst_ValidateValueForKeyError(void* o, void** ioValue, void* inKey, void** outError) {
	BOOL ret;
	@autoreleasepool {
		ret = [(NSMutableArray*)o validateValue:(id _Nullable* _Nonnull)ioValue forKey:inKey error:(NSError* _Nullable* _Nullable)outError];
		for(int i=0;i<1;i++) {
			if(ioValue[i] == 0) { break; }
			[(id)ioValue[i] retain];
		}
	
	
		for(int i=0;i<1;i++) {
			if(outError[i] == 0) { break; }
			[(id)outError[i] retain];
		}
	
	}
	return ret;

}
BOOL
NSMutableArray_inst_ValidateValueForKeyPathError(void* o, void** ioValue, void* inKeyPath, void** outError) {
	BOOL ret;
	@autoreleasepool {
		ret = [(NSMutableArray*)o validateValue:(id _Nullable* _Nonnull)ioValue forKeyPath:inKeyPath error:(NSError* _Nullable* _Nullable)outError];
		for(int i=0;i<1;i++) {
			if(ioValue[i] == 0) { break; }
			[(id)ioValue[i] retain];
		}
	
	
		for(int i=0;i<1;i++) {
			if(outError[i] == 0) { break; }
			[(id)outError[i] retain];
		}
	
	}
	return ret;

}
void
NSMutableArray_inst_ObserveValueForKeyPathOfObject(void* o, void* keyPath, void* object, void* change, void* context) {
	@autoreleasepool {
		[(NSMutableArray*)o observeValueForKeyPath:keyPath ofObject:object change:change context:context];
	}
}
void
NSMutableArray_inst_ObserveValueForKeyPathOfObjectChange(void* o, void* keyPath, void* object, void* change, void* context) {
	@autoreleasepool {
		[(NSMutableArray*)o observeValueForKeyPath:keyPath ofObject:object change:change context:context];
	}
}
void
NSMutableArray_inst_ObserveValueForKeyPathOfObjectChangeContext(void* o, void* keyPath, void* object, void* change, void* context) {
	@autoreleasepool {
		[(NSMutableArray*)o observeValueForKeyPath:keyPath ofObject:object change:change context:context];
	}
}
void*
NSMutableArray_inst_ObservationInfo(void* o) {
	void* ret;
	@autoreleasepool {
		ret = [(NSMutableArray*)o observationInfo];
	}
	return ret;

}
void
NSMutableArray_inst_InsertValueInPropertyWithKey(void* o, void* value, void* key) {
	@autoreleasepool {
		[(NSMutableArray*)o insertValue:value inPropertyWithKey:key];
	}
}
void
NSMutableArray_inst_InsertValueAtIndex(void* o, void* value, NSUInteger index, void* key) {
	@autoreleasepool {
		[(NSMutableArray*)o insertValue:value atIndex:index inPropertyWithKey:key];
	}
}
void
NSMutableArray_inst_InsertValueAtIndexInPropertyWithKey(void* o, void* value, NSUInteger index, void* key) {
	@autoreleasepool {
		[(NSMutableArray*)o insertValue:value atIndex:index inPropertyWithKey:key];
	}
}
void
NSMutableArray_inst_DoesNotRecognizeSelector(void* o, void* aSelector) {
	@autoreleasepool {
		[(NSMutableArray*)o doesNotRecognizeSelector:aSelector];
	}
}
BOOL
NSMutableArray_inst_IsCaseInsensitiveLike(void* o, void* object) {
	BOOL ret;
	@autoreleasepool {
		ret = [(NSMutableArray*)o isCaseInsensitiveLike:object];
	}
	return ret;

}
BOOL
NSMutableArray_inst_AttemptRecoveryFromErrorOptionIndex(void* o, void* error, NSUInteger recoveryOptionIndex) {
	BOOL ret;
	@autoreleasepool {
		ret = [(NSMutableArray*)o attemptRecoveryFromError:error optionIndex:recoveryOptionIndex];
	}
	return ret;

}
void
NSMutableArray_inst_AttemptRecoveryFromErrorOptionIndexDelegate(void* o, void* error, NSUInteger recoveryOptionIndex, void* delegate, void* didRecoverSelector, void* contextInfo) {
	@autoreleasepool {
		[(NSMutableArray*)o attemptRecoveryFromError:error optionIndex:recoveryOptionIndex delegate:delegate didRecoverSelector:didRecoverSelector contextInfo:contextInfo];
	}
}
void
NSMutableArray_inst_AttemptRecoveryFromErrorOptionIndexDelegateDidRecoverSelector(void* o, void* error, NSUInteger recoveryOptionIndex, void* delegate, void* didRecoverSelector, void* contextInfo) {
	@autoreleasepool {
		[(NSMutableArray*)o attemptRecoveryFromError:error optionIndex:recoveryOptionIndex delegate:delegate didRecoverSelector:didRecoverSelector contextInfo:contextInfo];
	}
}
void
NSMutableArray_inst_AttemptRecoveryFromErrorOptionIndexDelegateDidRecoverSelectorContextInfo(void* o, void* error, NSUInteger recoveryOptionIndex, void* delegate, void* didRecoverSelector, void* contextInfo) {
	@autoreleasepool {
		[(NSMutableArray*)o attemptRecoveryFromError:error optionIndex:recoveryOptionIndex delegate:delegate didRecoverSelector:didRecoverSelector contextInfo:contextInfo];
	}
}
void* _Nullable
NSMutableArray_inst_ObjectSpecifier(void* o) {
	NSScriptObjectSpecifier* _Nullable ret;
	@autoreleasepool {
		ret = [(NSMutableArray*)o objectSpecifier];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
BOOL
NSMutableArray_inst_ScriptingIsEqualTo(void* o, void* object) {
	BOOL ret;
	@autoreleasepool {
		ret = [(NSMutableArray*)o scriptingIsEqualTo:object];
	}
	return ret;

}
BOOL
NSMutableArray_inst_WriteToURLError(void* o, void* url, void** error) {
	BOOL ret;
	@autoreleasepool {
		ret = [(NSMutableArray*)o writeToURL:url error:(NSError* _Nullable* _Nullable)error];
		for(int i=0;i<1;i++) {
			if(error[i] == 0) { break; }
			[(id)error[i] retain];
		}
	
	}
	return ret;

}
BOOL
NSMutableArray_inst_ScriptingIsLessThanOrEqualTo(void* o, void* object) {
	BOOL ret;
	@autoreleasepool {
		ret = [(NSMutableArray*)o scriptingIsLessThanOrEqualTo:object];
	}
	return ret;

}
void
NSMutableArray_inst_DidChangeValueForKey(void* o, void* key) {
	@autoreleasepool {
		[(NSMutableArray*)o didChangeValueForKey:key];
	}
}
void
NSMutableArray_inst_DidChangeValueForKeyWithSetMutation(void* o, void* key, NSKeyValueSetMutationKind mutationKind, void* objects) {
	@autoreleasepool {
		[(NSMutableArray*)o didChangeValueForKey:key withSetMutation:mutationKind usingObjects:objects];
	}
}
void
NSMutableArray_inst_DidChangeValueForKeyWithSetMutationUsingObjects(void* o, void* key, NSKeyValueSetMutationKind mutationKind, void* objects) {
	@autoreleasepool {
		[(NSMutableArray*)o didChangeValueForKey:key withSetMutation:mutationKind usingObjects:objects];
	}
}
void* _Nonnull
NSMutableArray_inst_SubarrayWithRange(void* o, NSRange range) {
	NSArray* _Nonnull ret;
	@autoreleasepool {
		ret = [(NSMutableArray*)o subarrayWithRange:range];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
void* _Nullable
NSMutableArray_inst_ValueWithNameInPropertyWithKey(void* o, void* name, void* key) {
	NSObject* _Nullable ret;
	@autoreleasepool {
		ret = [(NSMutableArray*)o valueWithName:name inPropertyWithKey:key];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
void
NSMutableArray_inst_SetArray(void* o, void* otherArray) {
	@autoreleasepool {
		[(NSMutableArray*)o setArray:otherArray];
	}
}
void* _Nullable
NSMutableArray_inst_FirstObject(void* o) {
	NSObject* _Nullable ret;
	@autoreleasepool {
		ret = [(NSMutableArray*)o firstObject];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
void* _Nullable
NSMutableArray_inst_InitWithCoder(void* o, void* coder) {
	NSMutableArray* _Nullable ret;
	@autoreleasepool {
		ret = [(NSMutableArray*)o initWithCoder:coder];
	}
	return ret;

}
void
NSMutableArray_inst_ExchangeObjectAtIndexWithObjectAtIndex(void* o, NSUInteger idx1, NSUInteger idx2) {
	@autoreleasepool {
		[(NSMutableArray*)o exchangeObjectAtIndex:idx1 withObjectAtIndex:idx2];
	}
}
void* _Nonnull
NSMutableArray_inst_ReverseObjectEnumerator(void* o) {
	NSEnumerator* _Nonnull ret;
	@autoreleasepool {
		ret = [(NSMutableArray*)o reverseObjectEnumerator];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
void* _Nonnull
NSMutableArray_inst_Description(void* o) {
	NSString* _Nonnull ret;
	@autoreleasepool {
		ret = [(NSMutableArray*)o description];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
void* _Nullable
NSMutableArray_inst_IndicesOfObjectsByEvaluatingObjectSpecifier(void* o, void* specifier) {
	NSArray* _Nullable ret;
	@autoreleasepool {
		ret = [(NSMutableArray*)o indicesOfObjectsByEvaluatingObjectSpecifier:specifier];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
BOOL
NSMutableArray_inst_ScriptingBeginsWith(void* o, void* object) {
	BOOL ret;
	@autoreleasepool {
		ret = [(NSMutableArray*)o scriptingBeginsWith:object];
	}
	return ret;

}
void* _Nonnull
NSMutableArray_inst_InitWithArray(void* o, void* array) {
	NSMutableArray* _Nonnull ret;
	@autoreleasepool {
		ret = [(NSMutableArray*)o initWithArray:array];
	}
	return ret;

}
void* _Nonnull
NSMutableArray_inst_InitWithArrayCopyItems(void* o, void* array, BOOL flag) {
	NSMutableArray* _Nonnull ret;
	@autoreleasepool {
		ret = [(NSMutableArray*)o initWithArray:array copyItems:flag];
	}
	return ret;

}
void* _Nonnull
NSMutableArray_inst_ComponentsJoinedByString(void* o, void* separator) {
	NSString* _Nonnull ret;
	@autoreleasepool {
		ret = [(NSMutableArray*)o componentsJoinedByString:separator];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
void* _Nullable
NSMutableArray_inst_ValueForKeyPath(void* o, void* keyPath) {
	NSObject* _Nullable ret;
	@autoreleasepool {
		ret = [(NSMutableArray*)o valueForKeyPath:keyPath];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
void* _Nonnull
NSMutableArray_inst_ArrayByAddingObject(void* o, void* anObject) {
	NSArray* _Nonnull ret;
	@autoreleasepool {
		ret = [(NSMutableArray*)o arrayByAddingObject:anObject];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
void* _Nullable
NSMutableArray_inst_ScriptingProperties(void* o) {
	NSDictionary* _Nullable ret;
	@autoreleasepool {
		ret = [(NSMutableArray*)o scriptingProperties];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
void
NSMutableArray_inst_AddObjectsFromArray(void* o, void* otherArray) {
	@autoreleasepool {
		[(NSMutableArray*)o addObjectsFromArray:otherArray];
	}
}
void
NSMutableArray_inst_InsertObjectsAtIndexes(void* o, void* objects, void* indexes) {
	@autoreleasepool {
		[(NSMutableArray*)o insertObjects:objects atIndexes:indexes];
	}
}
void
NSMutableArray_inst_ApplyDifference(void* o, void* difference) {
	@autoreleasepool {
		[(NSMutableArray*)o applyDifference:difference];
	}
}
void* _Nonnull
NSMutableArray_inst_DifferenceFromArray(void* o, void* other) {
	NSOrderedCollectionDifference* _Nonnull ret;
	@autoreleasepool {
		ret = [(NSMutableArray*)o differenceFromArray:other];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
void* _Nonnull
NSMutableArray_inst_DifferenceFromArrayWithOptions(void* o, void* other, NSOrderedCollectionDifferenceCalculationOptions options) {
	NSOrderedCollectionDifference* _Nonnull ret;
	@autoreleasepool {
		ret = [(NSMutableArray*)o differenceFromArray:other withOptions:options];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
void*
NSMutableArray_inst_ForwardingTargetForSelector(void* o, void* aSelector) {
	NSObject* ret;
	@autoreleasepool {
		ret = [(NSMutableArray*)o forwardingTargetForSelector:aSelector];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
void*
NSEnumerator_CopyWithZone(void* zone) {
	NSObject* ret;
	@autoreleasepool {
		ret = [NSEnumerator copyWithZone:zone];
	}
	return ret;

}
void*
NSEnumerator_DebugDescription() {
	NSString* ret;
	@autoreleasepool {
		ret = [NSEnumerator debugDescription];
	}
	return ret;

}
void* _Nonnull
NSEnumerator_ClassFallbacksForKeyedArchiver() {
	NSArray* _Nonnull ret;
	@autoreleasepool {
		ret = [NSEnumerator classFallbacksForKeyedArchiver];
	}
	return ret;

}
NSUInteger
NSEnumerator_Hash() {
	NSUInteger ret;
	@autoreleasepool {
		ret = [NSEnumerator hash];
	}
	return ret;

}
BOOL
NSEnumerator_AutomaticallyNotifiesObserversForKey(void* key) {
	BOOL ret;
	@autoreleasepool {
		ret = [NSEnumerator automaticallyNotifiesObserversForKey:key];
	}
	return ret;

}
BOOL
NSEnumerator_ResolveInstanceMethod(void* sel) {
	BOOL ret;
	@autoreleasepool {
		ret = [NSEnumerator resolveInstanceMethod:sel];
	}
	return ret;

}
BOOL
NSEnumerator_IsSubclassOfClass(void* aClass) {
	BOOL ret;
	@autoreleasepool {
		ret = [NSEnumerator isSubclassOfClass:aClass];
	}
	return ret;

}
void*
NSEnumerator_Alloc() {
	return [NSEnumerator alloc];
}
void
NSEnumerator_SetVersion(NSInteger aVersion) {
	@autoreleasepool {
		[NSEnumerator setVersion:aVersion];
	}
}
void*
NSEnumerator_Class() {
	Class ret;
	@autoreleasepool {
		ret = [NSEnumerator class];
	}
	return ret;

}
void*
NSEnumerator_Superclass() {
	Class ret;
	@autoreleasepool {
		ret = [NSEnumerator superclass];
	}
	return ret;

}
BOOL
NSEnumerator_ConformsToProtocol(void* protocol) {
	BOOL ret;
	@autoreleasepool {
		ret = [NSEnumerator conformsToProtocol:protocol];
	}
	return ret;

}
void
NSEnumerator_CancelPreviousPerformRequestsWithTarget(void* aTarget) {
	@autoreleasepool {
		[NSEnumerator cancelPreviousPerformRequestsWithTarget:aTarget];
	}
}
void
NSEnumerator_CancelPreviousPerformRequestsWithTargetSelector(void* aTarget, void* aSelector, void* anArgument) {
	@autoreleasepool {
		[NSEnumerator cancelPreviousPerformRequestsWithTarget:aTarget selector:aSelector object:anArgument];
	}
}
void
NSEnumerator_CancelPreviousPerformRequestsWithTargetSelectorObject(void* aTarget, void* aSelector, void* anArgument) {
	@autoreleasepool {
		[NSEnumerator cancelPreviousPerformRequestsWithTarget:aTarget selector:aSelector object:anArgument];
	}
}
BOOL
NSEnumerator_ResolveClassMethod(void* sel) {
	BOOL ret;
	@autoreleasepool {
		ret = [NSEnumerator resolveClassMethod:sel];
	}
	return ret;

}
void*
NSEnumerator_Description() {
	NSString* ret;
	@autoreleasepool {
		ret = [NSEnumerator description];
	}
	return ret;

}
void* _Nonnull
NSEnumerator_ClassForKeyedUnarchiver() {
	Class _Nonnull ret;
	@autoreleasepool {
		ret = [NSEnumerator classForKeyedUnarchiver];
	}
	return ret;

}
void*
NSEnumerator_InstanceMethodSignatureForSelector(void* aSelector) {
	NSMethodSignature* ret;
	@autoreleasepool {
		ret = [NSEnumerator instanceMethodSignatureForSelector:aSelector];
	}
	return ret;

}
void* _Nonnull
NSEnumerator_KeyPathsForValuesAffectingValueForKey(void* key) {
	NSSet* _Nonnull ret;
	@autoreleasepool {
		ret = [NSEnumerator keyPathsForValuesAffectingValueForKey:key];
	}
	return ret;

}
void*
NSEnumerator_AllocWithZone(void* zone) {
	return [NSEnumerator allocWithZone:zone];
}
void*
NSEnumerator_MutableCopyWithZone(void* zone) {
	NSObject* ret;
	@autoreleasepool {
		ret = [NSEnumerator mutableCopyWithZone:zone];
	}
	return ret;

}
BOOL
NSEnumerator_AccessInstanceVariablesDirectly() {
	BOOL ret;
	@autoreleasepool {
		ret = [NSEnumerator accessInstanceVariablesDirectly];
	}
	return ret;

}
void
NSEnumerator_Load() {
	@autoreleasepool {
		[NSEnumerator load];
	}
}
NSInteger
NSEnumerator_Version() {
	NSInteger ret;
	@autoreleasepool {
		ret = [NSEnumerator version];
	}
	return ret;

}
BOOL
NSEnumerator_InstancesRespondToSelector(void* aSelector) {
	BOOL ret;
	@autoreleasepool {
		ret = [NSEnumerator instancesRespondToSelector:aSelector];
	}
	return ret;

}
void*
NSEnumerator_New() {
	NSEnumerator* ret;
	@autoreleasepool {
		ret = [NSEnumerator new];
	}
	return ret;

}
BOOL
NSEnumerator_inst_IsLike(void* o, void* object) {
	BOOL ret;
	@autoreleasepool {
		ret = [(NSEnumerator*)o isLike:object];
	}
	return ret;

}
void*
NSEnumerator_inst_Copy(void* o) {
	NSObject* ret;
	@autoreleasepool {
		ret = [(NSEnumerator*)o copy];
	}
	return ret;

}
void
NSEnumerator_inst_RemoveObserverForKeyPath(void* o, void* observer, void* keyPath) {
	@autoreleasepool {
		[(NSEnumerator*)o removeObserver:observer forKeyPath:keyPath];
	}
}
void
NSEnumerator_inst_RemoveObserverForKeyPathContext(void* o, void* observer, void* keyPath, void* context) {
	@autoreleasepool {
		[(NSEnumerator*)o removeObserver:observer forKeyPath:keyPath context:context];
	}
}
void* _Nullable
NSEnumerator_inst_InverseForRelationshipKey(void* o, void* relationshipKey) {
	NSString* _Nullable ret;
	@autoreleasepool {
		ret = [(NSEnumerator*)o inverseForRelationshipKey:relationshipKey];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
BOOL
NSEnumerator_inst_ScriptingContains(void* o, void* object) {
	BOOL ret;
	@autoreleasepool {
		ret = [(NSEnumerator*)o scriptingContains:object];
	}
	return ret;

}
void* _Nullable
NSEnumerator_inst_ScriptingProperties(void* o) {
	NSDictionary* _Nullable ret;
	@autoreleasepool {
		ret = [(NSEnumerator*)o scriptingProperties];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
BOOL
NSEnumerator_inst_AttemptRecoveryFromErrorOptionIndex(void* o, void* error, NSUInteger recoveryOptionIndex) {
	BOOL ret;
	@autoreleasepool {
		ret = [(NSEnumerator*)o attemptRecoveryFromError:error optionIndex:recoveryOptionIndex];
	}
	return ret;

}
void
NSEnumerator_inst_AttemptRecoveryFromErrorOptionIndexDelegate(void* o, void* error, NSUInteger recoveryOptionIndex, void* delegate, void* didRecoverSelector, void* contextInfo) {
	@autoreleasepool {
		[(NSEnumerator*)o attemptRecoveryFromError:error optionIndex:recoveryOptionIndex delegate:delegate didRecoverSelector:didRecoverSelector contextInfo:contextInfo];
	}
}
void
NSEnumerator_inst_AttemptRecoveryFromErrorOptionIndexDelegateDidRecoverSelector(void* o, void* error, NSUInteger recoveryOptionIndex, void* delegate, void* didRecoverSelector, void* contextInfo) {
	@autoreleasepool {
		[(NSEnumerator*)o attemptRecoveryFromError:error optionIndex:recoveryOptionIndex delegate:delegate didRecoverSelector:didRecoverSelector contextInfo:contextInfo];
	}
}
BOOL
NSEnumerator_inst_DoesContain(void* o, void* object) {
	BOOL ret;
	@autoreleasepool {
		ret = [(NSEnumerator*)o doesContain:object];
	}
	return ret;

}
void* _Nullable
NSEnumerator_inst_CoerceValueForKey(void* o, void* value, void* key) {
	NSObject* _Nullable ret;
	@autoreleasepool {
		ret = [(NSEnumerator*)o coerceValue:value forKey:key];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
void* _Nullable
NSEnumerator_inst_ScriptingValueForSpecifier(void* o, void* objectSpecifier) {
	NSObject* _Nullable ret;
	@autoreleasepool {
		ret = [(NSEnumerator*)o scriptingValueForSpecifier:objectSpecifier];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
void* _Nonnull
NSEnumerator_inst_DictionaryWithValuesForKeys(void* o, void* keys) {
	NSDictionary* _Nonnull ret;
	@autoreleasepool {
		ret = [(NSEnumerator*)o dictionaryWithValuesForKeys:keys];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
void
NSEnumerator_inst_ObserveValueForKeyPathOfObject(void* o, void* keyPath, void* object, void* change, void* context) {
	@autoreleasepool {
		[(NSEnumerator*)o observeValueForKeyPath:keyPath ofObject:object change:change context:context];
	}
}
void
NSEnumerator_inst_ObserveValueForKeyPathOfObjectChange(void* o, void* keyPath, void* object, void* change, void* context) {
	@autoreleasepool {
		[(NSEnumerator*)o observeValueForKeyPath:keyPath ofObject:object change:change context:context];
	}
}
void* _Nonnull
NSEnumerator_inst_ToManyRelationshipKeys(void* o) {
	NSArray* _Nonnull ret;
	@autoreleasepool {
		ret = [(NSEnumerator*)o toManyRelationshipKeys];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
void
NSEnumerator_inst_SetValueForKey(void* o, void* value, void* key) {
	@autoreleasepool {
		[(NSEnumerator*)o setValue:value forKey:key];
	}
}
void
NSEnumerator_inst_SetValueForKeyPath(void* o, void* value, void* keyPath) {
	@autoreleasepool {
		[(NSEnumerator*)o setValue:value forKeyPath:keyPath];
	}
}
void
NSEnumerator_inst_SetValueForUndefinedKey(void* o, void* value, void* key) {
	@autoreleasepool {
		[(NSEnumerator*)o setValue:value forUndefinedKey:key];
	}
}
BOOL
NSEnumerator_inst_ScriptingBeginsWith(void* o, void* object) {
	BOOL ret;
	@autoreleasepool {
		ret = [(NSEnumerator*)o scriptingBeginsWith:object];
	}
	return ret;

}
void*
NSEnumerator_inst_MethodSignatureForSelector(void* o, void* aSelector) {
	NSMethodSignature* ret;
	@autoreleasepool {
		ret = [(NSEnumerator*)o methodSignatureForSelector:aSelector];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
BOOL
NSEnumerator_inst_IsLessThanOrEqualTo(void* o, void* object) {
	BOOL ret;
	@autoreleasepool {
		ret = [(NSEnumerator*)o isLessThanOrEqualTo:object];
	}
	return ret;

}
BOOL
NSEnumerator_inst_ScriptingEndsWith(void* o, void* object) {
	BOOL ret;
	@autoreleasepool {
		ret = [(NSEnumerator*)o scriptingEndsWith:object];
	}
	return ret;

}
void* _Nonnull
NSEnumerator_inst_AutoContentAccessingProxy(void* o) {
	NSObject* _Nonnull ret;
	@autoreleasepool {
		ret = [(NSEnumerator*)o autoContentAccessingProxy];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
void
NSEnumerator_inst_PerformSelectorWithObject(void* o, void* aSelector, void* anArgument, NSTimeInterval delay) {
	@autoreleasepool {
		[(NSEnumerator*)o performSelector:aSelector withObject:anArgument afterDelay:delay];
	}
}
void
NSEnumerator_inst_PerformSelectorWithObjectAfterDelay(void* o, void* aSelector, void* anArgument, NSTimeInterval delay) {
	@autoreleasepool {
		[(NSEnumerator*)o performSelector:aSelector withObject:anArgument afterDelay:delay];
	}
}
void
NSEnumerator_inst_PerformSelectorWithObjectAfterDelayInModes(void* o, void* aSelector, void* anArgument, NSTimeInterval delay, void* modes) {
	@autoreleasepool {
		[(NSEnumerator*)o performSelector:aSelector withObject:anArgument afterDelay:delay inModes:modes];
	}
}
void
NSEnumerator_inst_PerformSelectorOnThread(void* o, void* aSelector, void* thr, void* arg, BOOL wait) {
	@autoreleasepool {
		[(NSEnumerator*)o performSelector:aSelector onThread:thr withObject:arg waitUntilDone:wait];
	}
}
void
NSEnumerator_inst_PerformSelectorOnThreadWithObject(void* o, void* aSelector, void* thr, void* arg, BOOL wait) {
	@autoreleasepool {
		[(NSEnumerator*)o performSelector:aSelector onThread:thr withObject:arg waitUntilDone:wait];
	}
}
void
NSEnumerator_inst_PerformSelectorOnThreadWithObjectWaitUntilDone(void* o, void* aSelector, void* thr, void* arg, BOOL wait, void* array) {
	@autoreleasepool {
		[(NSEnumerator*)o performSelector:aSelector onThread:thr withObject:arg waitUntilDone:wait modes:array];
	}
}
void
NSEnumerator_inst_PerformSelectorOnThreadWithObjectWaitUntilDoneModes(void* o, void* aSelector, void* thr, void* arg, BOOL wait, void* array) {
	@autoreleasepool {
		[(NSEnumerator*)o performSelector:aSelector onThread:thr withObject:arg waitUntilDone:wait modes:array];
	}
}
BOOL
NSEnumerator_inst_IsLessThan(void* o, void* object) {
	BOOL ret;
	@autoreleasepool {
		ret = [(NSEnumerator*)o isLessThan:object];
	}
	return ret;

}
FourCharCode
NSEnumerator_inst_ClassCode(void* o) {
	FourCharCode ret;
	@autoreleasepool {
		ret = [(NSEnumerator*)o classCode];
	}
	return ret;

}
BOOL
NSEnumerator_inst_ScriptingIsGreaterThanOrEqualTo(void* o, void* object) {
	BOOL ret;
	@autoreleasepool {
		ret = [(NSEnumerator*)o scriptingIsGreaterThanOrEqualTo:object];
	}
	return ret;

}
void* _Nonnull
NSEnumerator_inst_ClassForCoder(void* o) {
	Class _Nonnull ret;
	@autoreleasepool {
		ret = [(NSEnumerator*)o classForCoder];
	}
	return ret;

}
void*
NSEnumerator_inst_ForwardingTargetForSelector(void* o, void* aSelector) {
	NSObject* ret;
	@autoreleasepool {
		ret = [(NSEnumerator*)o forwardingTargetForSelector:aSelector];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
void
NSEnumerator_inst_DidChangeValuesAtIndexes(void* o, NSKeyValueChange changeKind, void* indexes, void* key) {
	@autoreleasepool {
		[(NSEnumerator*)o didChange:changeKind valuesAtIndexes:indexes forKey:key];
	}
}
void
NSEnumerator_inst_DidChangeValuesAtIndexesForKey(void* o, NSKeyValueChange changeKind, void* indexes, void* key) {
	@autoreleasepool {
		[(NSEnumerator*)o didChange:changeKind valuesAtIndexes:indexes forKey:key];
	}
}
void* _Nullable
NSEnumerator_inst_ClassForKeyedArchiver(void* o) {
	Class _Nullable ret;
	@autoreleasepool {
		ret = [(NSEnumerator*)o classForKeyedArchiver];
	}
	return ret;

}
void* _Nullable
NSEnumerator_inst_ValueWithUniqueIDInPropertyWithKey(void* o, void* uniqueID, void* key) {
	NSObject* _Nullable ret;
	@autoreleasepool {
		ret = [(NSEnumerator*)o valueWithUniqueID:uniqueID inPropertyWithKey:key];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
void
NSEnumerator_inst_Dealloc(void* o) {
	@autoreleasepool {
		[(NSEnumerator*)o dealloc];
	}
}
void*
NSEnumerator_inst_Init(void* o) {
	NSEnumerator* ret;
	@autoreleasepool {
		ret = [(NSEnumerator*)o init];
	}
	return ret;

}
void* _Nullable
NSEnumerator_inst_ClassForArchiver(void* o) {
	Class _Nullable ret;
	@autoreleasepool {
		ret = [(NSEnumerator*)o classForArchiver];
	}
	return ret;

}
void* _Nullable
NSEnumerator_inst_CopyScriptingValueForKey(void* o, void* value, void* key, void* properties) {
	NSObject* _Nullable ret;
	@autoreleasepool {
		ret = [(NSEnumerator*)o copyScriptingValue:value forKey:key withProperties:properties];
	}
	return ret;

}
void* _Nullable
NSEnumerator_inst_CopyScriptingValueForKeyWithProperties(void* o, void* value, void* key, void* properties) {
	NSObject* _Nullable ret;
	@autoreleasepool {
		ret = [(NSEnumerator*)o copyScriptingValue:value forKey:key withProperties:properties];
	}
	return ret;

}
void* _Nonnull
NSEnumerator_inst_ClassName(void* o) {
	NSString* _Nonnull ret;
	@autoreleasepool {
		ret = [(NSEnumerator*)o className];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
void
NSEnumerator_inst_PerformSelectorOnMainThreadWithObject(void* o, void* aSelector, void* arg, BOOL wait) {
	@autoreleasepool {
		[(NSEnumerator*)o performSelectorOnMainThread:aSelector withObject:arg waitUntilDone:wait];
	}
}
void
NSEnumerator_inst_PerformSelectorOnMainThreadWithObjectWaitUntilDone(void* o, void* aSelector, void* arg, BOOL wait) {
	@autoreleasepool {
		[(NSEnumerator*)o performSelectorOnMainThread:aSelector withObject:arg waitUntilDone:wait];
	}
}
void
NSEnumerator_inst_PerformSelectorOnMainThreadWithObjectWaitUntilDoneModes(void* o, void* aSelector, void* arg, BOOL wait, void* array) {
	@autoreleasepool {
		[(NSEnumerator*)o performSelectorOnMainThread:aSelector withObject:arg waitUntilDone:wait modes:array];
	}
}
void
NSEnumerator_inst_PerformSelectorInBackgroundWithObject(void* o, void* aSelector, void* arg) {
	@autoreleasepool {
		[(NSEnumerator*)o performSelectorInBackground:aSelector withObject:arg];
	}
}
void
NSEnumerator_inst_SetObservationInfo(void* o, void* observationInfo) {
	@autoreleasepool {
		[(NSEnumerator*)o setObservationInfo:observationInfo];
	}
}
BOOL
NSEnumerator_inst_IsGreaterThan(void* o, void* object) {
	BOOL ret;
	@autoreleasepool {
		ret = [(NSEnumerator*)o isGreaterThan:object];
	}
	return ret;

}
BOOL
NSEnumerator_inst_ScriptingIsGreaterThan(void* o, void* object) {
	BOOL ret;
	@autoreleasepool {
		ret = [(NSEnumerator*)o scriptingIsGreaterThan:object];
	}
	return ret;

}
void* _Nonnull
NSEnumerator_inst_ClassDescription(void* o) {
	NSClassDescription* _Nonnull ret;
	@autoreleasepool {
		ret = [(NSEnumerator*)o classDescription];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
void* _Nullable
NSEnumerator_inst_ReplacementObjectForKeyedArchiver(void* o, void* archiver) {
	NSObject* _Nullable ret;
	@autoreleasepool {
		ret = [(NSEnumerator*)o replacementObjectForKeyedArchiver:archiver];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
void
NSEnumerator_inst_RemoveValueAtIndexFromPropertyWithKey(void* o, NSUInteger index, void* key) {
	@autoreleasepool {
		[(NSEnumerator*)o removeValueAtIndex:index fromPropertyWithKey:key];
	}
}
void*
NSEnumerator_inst_ObservationInfo(void* o) {
	void* ret;
	@autoreleasepool {
		ret = [(NSEnumerator*)o observationInfo];
	}
	return ret;

}
BOOL
NSEnumerator_inst_ScriptingIsLessThan(void* o, void* object) {
	BOOL ret;
	@autoreleasepool {
		ret = [(NSEnumerator*)o scriptingIsLessThan:object];
	}
	return ret;

}
void
NSEnumerator_inst_DoesNotRecognizeSelector(void* o, void* aSelector) {
	@autoreleasepool {
		[(NSEnumerator*)o doesNotRecognizeSelector:aSelector];
	}
}
void* _Nonnull
NSEnumerator_inst_ToOneRelationshipKeys(void* o) {
	NSArray* _Nonnull ret;
	@autoreleasepool {
		ret = [(NSEnumerator*)o toOneRelationshipKeys];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
void* _Nonnull
NSEnumerator_inst_AttributeKeys(void* o) {
	NSArray* _Nonnull ret;
	@autoreleasepool {
		ret = [(NSEnumerator*)o attributeKeys];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
BOOL
NSEnumerator_inst_IsNotEqualTo(void* o, void* object) {
	BOOL ret;
	@autoreleasepool {
		ret = [(NSEnumerator*)o isNotEqualTo:object];
	}
	return ret;

}
void* _Nullable
NSEnumerator_inst_IndicesOfObjectsByEvaluatingObjectSpecifier(void* o, void* specifier) {
	NSArray* _Nullable ret;
	@autoreleasepool {
		ret = [(NSEnumerator*)o indicesOfObjectsByEvaluatingObjectSpecifier:specifier];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
void* _Nullable
NSEnumerator_inst_ObjectSpecifier(void* o) {
	NSScriptObjectSpecifier* _Nullable ret;
	@autoreleasepool {
		ret = [(NSEnumerator*)o objectSpecifier];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
void* _Nullable
NSEnumerator_inst_AwakeAfterUsingCoder(void* o, void* coder) {
	NSObject* _Nullable ret;
	@autoreleasepool {
		ret = [(NSEnumerator*)o awakeAfterUsingCoder:coder];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
void
NSEnumerator_inst_SetValuesForKeysWithDictionary(void* o, void* keyedValues) {
	@autoreleasepool {
		[(NSEnumerator*)o setValuesForKeysWithDictionary:keyedValues];
	}
}
BOOL
NSEnumerator_inst_IsGreaterThanOrEqualTo(void* o, void* object) {
	BOOL ret;
	@autoreleasepool {
		ret = [(NSEnumerator*)o isGreaterThanOrEqualTo:object];
	}
	return ret;

}
void* _Nullable
NSEnumerator_inst_ValueAtIndexInPropertyWithKey(void* o, NSUInteger index, void* key) {
	NSObject* _Nullable ret;
	@autoreleasepool {
		ret = [(NSEnumerator*)o valueAtIndex:index inPropertyWithKey:key];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
BOOL
NSEnumerator_inst_ScriptingIsLessThanOrEqualTo(void* o, void* object) {
	BOOL ret;
	@autoreleasepool {
		ret = [(NSEnumerator*)o scriptingIsLessThanOrEqualTo:object];
	}
	return ret;

}
void* _Nullable
NSEnumerator_inst_NextObject(void* o) {
	NSObject* _Nullable ret;
	@autoreleasepool {
		ret = [(NSEnumerator*)o nextObject];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
void* _Nonnull
NSEnumerator_inst_MutableOrderedSetValueForKey(void* o, void* key) {
	NSMutableOrderedSet* _Nonnull ret;
	@autoreleasepool {
		ret = [(NSEnumerator*)o mutableOrderedSetValueForKey:key];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
void* _Nullable
NSEnumerator_inst_ValueForKey(void* o, void* key) {
	NSObject* _Nullable ret;
	@autoreleasepool {
		ret = [(NSEnumerator*)o valueForKey:key];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
void
NSEnumerator_inst_InsertValueInPropertyWithKey(void* o, void* value, void* key) {
	@autoreleasepool {
		[(NSEnumerator*)o insertValue:value inPropertyWithKey:key];
	}
}
void
NSEnumerator_inst_InsertValueAtIndex(void* o, void* value, NSUInteger index, void* key) {
	@autoreleasepool {
		[(NSEnumerator*)o insertValue:value atIndex:index inPropertyWithKey:key];
	}
}
void
NSEnumerator_inst_InsertValueAtIndexInPropertyWithKey(void* o, void* value, NSUInteger index, void* key) {
	@autoreleasepool {
		[(NSEnumerator*)o insertValue:value atIndex:index inPropertyWithKey:key];
	}
}
void
NSEnumerator_inst_AddObserverForKeyPath(void* o, void* observer, void* keyPath, NSKeyValueObservingOptions options, void* context) {
	@autoreleasepool {
		[(NSEnumerator*)o addObserver:observer forKeyPath:keyPath options:options context:context];
	}
}
void
NSEnumerator_inst_AddObserverForKeyPathOptions(void* o, void* observer, void* keyPath, NSKeyValueObservingOptions options, void* context) {
	@autoreleasepool {
		[(NSEnumerator*)o addObserver:observer forKeyPath:keyPath options:options context:context];
	}
}
void
NSEnumerator_inst_ForwardInvocation(void* o, void* anInvocation) {
	@autoreleasepool {
		[(NSEnumerator*)o forwardInvocation:anInvocation];
	}
}
void
NSEnumerator_inst_DidChangeValueForKey(void* o, void* key) {
	@autoreleasepool {
		[(NSEnumerator*)o didChangeValueForKey:key];
	}
}
void
NSEnumerator_inst_DidChangeValueForKeyWithSetMutation(void* o, void* key, NSKeyValueSetMutationKind mutationKind, void* objects) {
	@autoreleasepool {
		[(NSEnumerator*)o didChangeValueForKey:key withSetMutation:mutationKind usingObjects:objects];
	}
}
void
NSEnumerator_inst_DidChangeValueForKeyWithSetMutationUsingObjects(void* o, void* key, NSKeyValueSetMutationKind mutationKind, void* objects) {
	@autoreleasepool {
		[(NSEnumerator*)o didChangeValueForKey:key withSetMutation:mutationKind usingObjects:objects];
	}
}
void* _Nullable
NSEnumerator_inst_ValueForKeyPath(void* o, void* keyPath) {
	NSObject* _Nullable ret;
	@autoreleasepool {
		ret = [(NSEnumerator*)o valueForKeyPath:keyPath];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
void
NSEnumerator_inst_WillChangeValuesAtIndexes(void* o, NSKeyValueChange changeKind, void* indexes, void* key) {
	@autoreleasepool {
		[(NSEnumerator*)o willChange:changeKind valuesAtIndexes:indexes forKey:key];
	}
}
void
NSEnumerator_inst_WillChangeValuesAtIndexesForKey(void* o, NSKeyValueChange changeKind, void* indexes, void* key) {
	@autoreleasepool {
		[(NSEnumerator*)o willChange:changeKind valuesAtIndexes:indexes forKey:key];
	}
}
BOOL
NSEnumerator_inst_IsCaseInsensitiveLike(void* o, void* object) {
	BOOL ret;
	@autoreleasepool {
		ret = [(NSEnumerator*)o isCaseInsensitiveLike:object];
	}
	return ret;

}
void* _Nonnull
NSEnumerator_inst_MutableArrayValueForKeyPath(void* o, void* keyPath) {
	NSMutableArray* _Nonnull ret;
	@autoreleasepool {
		ret = [(NSEnumerator*)o mutableArrayValueForKeyPath:keyPath];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
void* _Nonnull
NSEnumerator_inst_MutableArrayValueForKey(void* o, void* key) {
	NSMutableArray* _Nonnull ret;
	@autoreleasepool {
		ret = [(NSEnumerator*)o mutableArrayValueForKey:key];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
void* _Nullable
NSEnumerator_inst_ValueForUndefinedKey(void* o, void* key) {
	NSObject* _Nullable ret;
	@autoreleasepool {
		ret = [(NSEnumerator*)o valueForUndefinedKey:key];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
BOOL
NSEnumerator_inst_IsEqualTo(void* o, void* object) {
	BOOL ret;
	@autoreleasepool {
		ret = [(NSEnumerator*)o isEqualTo:object];
	}
	return ret;

}
void*
NSEnumerator_inst_MutableCopy(void* o) {
	NSObject* ret;
	@autoreleasepool {
		ret = [(NSEnumerator*)o mutableCopy];
	}
	return ret;

}
void* _Nonnull
NSEnumerator_inst_AllObjects(void* o) {
	NSArray* _Nonnull ret;
	@autoreleasepool {
		ret = [(NSEnumerator*)o allObjects];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
void
NSEnumerator_inst_SetScriptingProperties(void* o, void* scriptingProperties) {
	@autoreleasepool {
		[(NSEnumerator*)o setScriptingProperties:scriptingProperties];
	}
}
BOOL
NSEnumerator_inst_ScriptingIsEqualTo(void* o, void* object) {
	BOOL ret;
	@autoreleasepool {
		ret = [(NSEnumerator*)o scriptingIsEqualTo:object];
	}
	return ret;

}
void* _Nonnull
NSEnumerator_inst_MutableSetValueForKeyPath(void* o, void* keyPath) {
	NSMutableSet* _Nonnull ret;
	@autoreleasepool {
		ret = [(NSEnumerator*)o mutableSetValueForKeyPath:keyPath];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
void* _Nullable
NSEnumerator_inst_ValueWithNameInPropertyWithKey(void* o, void* name, void* key) {
	NSObject* _Nullable ret;
	@autoreleasepool {
		ret = [(NSEnumerator*)o valueWithName:name inPropertyWithKey:key];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
void* _Nullable
NSEnumerator_inst_NewScriptingObjectOfClassForValueForKey(void* o, void* objectClass, void* key, void* contentsValue, void* properties) {
	NSObject* _Nullable ret;
	@autoreleasepool {
		ret = [(NSEnumerator*)o newScriptingObjectOfClass:objectClass forValueForKey:key withContentsValue:contentsValue properties:properties];
	}
	return ret;

}
void* _Nullable
NSEnumerator_inst_NewScriptingObjectOfClassForValueForKeyWithContentsValue(void* o, void* objectClass, void* key, void* contentsValue, void* properties) {
	NSObject* _Nullable ret;
	@autoreleasepool {
		ret = [(NSEnumerator*)o newScriptingObjectOfClass:objectClass forValueForKey:key withContentsValue:contentsValue properties:properties];
	}
	return ret;

}
void
NSEnumerator_inst_WillChangeValueForKey(void* o, void* key) {
	@autoreleasepool {
		[(NSEnumerator*)o willChangeValueForKey:key];
	}
}
void
NSEnumerator_inst_WillChangeValueForKeyWithSetMutation(void* o, void* key, NSKeyValueSetMutationKind mutationKind, void* objects) {
	@autoreleasepool {
		[(NSEnumerator*)o willChangeValueForKey:key withSetMutation:mutationKind usingObjects:objects];
	}
}
void
NSEnumerator_inst_WillChangeValueForKeyWithSetMutationUsingObjects(void* o, void* key, NSKeyValueSetMutationKind mutationKind, void* objects) {
	@autoreleasepool {
		[(NSEnumerator*)o willChangeValueForKey:key withSetMutation:mutationKind usingObjects:objects];
	}
}
void
NSEnumerator_inst_SetNilValueForKey(void* o, void* key) {
	@autoreleasepool {
		[(NSEnumerator*)o setNilValueForKey:key];
	}
}
NSUInteger
NSEnumerator_inst_CountByEnumeratingWithStateObjects(void* o, void* state, void** buffer, NSUInteger len) {
	NSUInteger ret;
	@autoreleasepool {
		ret = [(NSEnumerator*)o countByEnumeratingWithState:state objects:(id _Nullable* _Nonnull)buffer count:len];
		for(int i=0;i<len;i++) {
			if(buffer[i] == 0) { break; }
			[(id)buffer[i] retain];
		}
	
	}
	return ret;

}
NSUInteger
NSEnumerator_inst_CountByEnumeratingWithStateObjectsCount(void* o, void* state, void** buffer, NSUInteger len) {
	NSUInteger ret;
	@autoreleasepool {
		ret = [(NSEnumerator*)o countByEnumeratingWithState:state objects:(id _Nullable* _Nonnull)buffer count:len];
		for(int i=0;i<len;i++) {
			if(buffer[i] == 0) { break; }
			[(id)buffer[i] retain];
		}
	
	}
	return ret;

}
void* _Nonnull
NSEnumerator_inst_MutableSetValueForKey(void* o, void* key) {
	NSMutableSet* _Nonnull ret;
	@autoreleasepool {
		ret = [(NSEnumerator*)o mutableSetValueForKey:key];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
void* _Nonnull
NSEnumerator_inst_MutableOrderedSetValueForKeyPath(void* o, void* keyPath) {
	NSMutableOrderedSet* _Nonnull ret;
	@autoreleasepool {
		ret = [(NSEnumerator*)o mutableOrderedSetValueForKeyPath:keyPath];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
BOOL
NSEnumerator_inst_ValidateValueForKey(void* o, void** ioValue, void* inKey, void** outError) {
	BOOL ret;
	@autoreleasepool {
		ret = [(NSEnumerator*)o validateValue:(id _Nullable* _Nonnull)ioValue forKey:inKey error:(NSError* _Nullable* _Nullable)outError];
		for(int i=0;i<1;i++) {
			if(ioValue[i] == 0) { break; }
			[(id)ioValue[i] retain];
		}
	
	
		for(int i=0;i<1;i++) {
			if(outError[i] == 0) { break; }
			[(id)outError[i] retain];
		}
	
	}
	return ret;

}
BOOL
NSEnumerator_inst_ValidateValueForKeyPath(void* o, void** ioValue, void* inKeyPath, void** outError) {
	BOOL ret;
	@autoreleasepool {
		ret = [(NSEnumerator*)o validateValue:(id _Nullable* _Nonnull)ioValue forKeyPath:inKeyPath error:(NSError* _Nullable* _Nullable)outError];
		for(int i=0;i<1;i++) {
			if(ioValue[i] == 0) { break; }
			[(id)ioValue[i] retain];
		}
	
	
		for(int i=0;i<1;i++) {
			if(outError[i] == 0) { break; }
			[(id)outError[i] retain];
		}
	
	}
	return ret;

}
BOOL
NSEnumerator_inst_ValidateValueForKeyError(void* o, void** ioValue, void* inKey, void** outError) {
	BOOL ret;
	@autoreleasepool {
		ret = [(NSEnumerator*)o validateValue:(id _Nullable* _Nonnull)ioValue forKey:inKey error:(NSError* _Nullable* _Nullable)outError];
		for(int i=0;i<1;i++) {
			if(ioValue[i] == 0) { break; }
			[(id)ioValue[i] retain];
		}
	
	
		for(int i=0;i<1;i++) {
			if(outError[i] == 0) { break; }
			[(id)outError[i] retain];
		}
	
	}
	return ret;

}
BOOL
NSEnumerator_inst_ValidateValueForKeyPathError(void* o, void** ioValue, void* inKeyPath, void** outError) {
	BOOL ret;
	@autoreleasepool {
		ret = [(NSEnumerator*)o validateValue:(id _Nullable* _Nonnull)ioValue forKeyPath:inKeyPath error:(NSError* _Nullable* _Nullable)outError];
		for(int i=0;i<1;i++) {
			if(ioValue[i] == 0) { break; }
			[(id)ioValue[i] retain];
		}
	
	
		for(int i=0;i<1;i++) {
			if(outError[i] == 0) { break; }
			[(id)outError[i] retain];
		}
	
	}
	return ret;

}
void* _Nullable
NSEnumerator_inst_ReplacementObjectForCoder(void* o, void* coder) {
	NSObject* _Nullable ret;
	@autoreleasepool {
		ret = [(NSEnumerator*)o replacementObjectForCoder:coder];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
void
NSEnumerator_inst_ReplaceValueAtIndexInPropertyWithKey(void* o, NSUInteger index, void* key, void* value) {
	@autoreleasepool {
		[(NSEnumerator*)o replaceValueAtIndex:index inPropertyWithKey:key withValue:value];
	}
}
void
NSEnumerator_inst_ReplaceValueAtIndexInPropertyWithKeyWithValue(void* o, NSUInteger index, void* key, void* value) {
	@autoreleasepool {
		[(NSEnumerator*)o replaceValueAtIndex:index inPropertyWithKey:key withValue:value];
	}
}
void
NSAutoreleasePool_CancelPreviousPerformRequestsWithTarget(void* aTarget) {
	@autoreleasepool {
		[NSAutoreleasePool cancelPreviousPerformRequestsWithTarget:aTarget];
	}
}
void
NSAutoreleasePool_CancelPreviousPerformRequestsWithTargetSelector(void* aTarget, void* aSelector, void* anArgument) {
	@autoreleasepool {
		[NSAutoreleasePool cancelPreviousPerformRequestsWithTarget:aTarget selector:aSelector object:anArgument];
	}
}
void
NSAutoreleasePool_CancelPreviousPerformRequestsWithTargetSelectorObject(void* aTarget, void* aSelector, void* anArgument) {
	@autoreleasepool {
		[NSAutoreleasePool cancelPreviousPerformRequestsWithTarget:aTarget selector:aSelector object:anArgument];
	}
}
void* _Nonnull
NSAutoreleasePool_KeyPathsForValuesAffectingValueForKey(void* key) {
	NSSet* _Nonnull ret;
	@autoreleasepool {
		ret = [NSAutoreleasePool keyPathsForValuesAffectingValueForKey:key];
	}
	return ret;

}
BOOL
NSAutoreleasePool_ResolveInstanceMethod(void* sel) {
	BOOL ret;
	@autoreleasepool {
		ret = [NSAutoreleasePool resolveInstanceMethod:sel];
	}
	return ret;

}
void*
NSAutoreleasePool_Alloc() {
	NSAutoreleasePool* ret;
	@autoreleasepool {
		ret = [NSAutoreleasePool alloc];
	}
	return ret;

}
void*
NSAutoreleasePool_Superclass() {
	Class ret;
	@autoreleasepool {
		ret = [NSAutoreleasePool superclass];
	}
	return ret;

}
void*
NSAutoreleasePool_AllocWithZone(void* zone) {
	NSAutoreleasePool* ret;
	@autoreleasepool {
		ret = [NSAutoreleasePool allocWithZone:zone];
	}
	return ret;

}
void*
NSAutoreleasePool_MutableCopyWithZone(void* zone) {
	NSObject* ret;
	@autoreleasepool {
		ret = [NSAutoreleasePool mutableCopyWithZone:zone];
	}
	return ret;

}
BOOL
NSAutoreleasePool_AccessInstanceVariablesDirectly() {
	BOOL ret;
	@autoreleasepool {
		ret = [NSAutoreleasePool accessInstanceVariablesDirectly];
	}
	return ret;

}
BOOL
NSAutoreleasePool_ConformsToProtocol(void* protocol) {
	BOOL ret;
	@autoreleasepool {
		ret = [NSAutoreleasePool conformsToProtocol:protocol];
	}
	return ret;

}
BOOL
NSAutoreleasePool_ResolveClassMethod(void* sel) {
	BOOL ret;
	@autoreleasepool {
		ret = [NSAutoreleasePool resolveClassMethod:sel];
	}
	return ret;

}
void*
NSAutoreleasePool_DebugDescription() {
	NSString* ret;
	@autoreleasepool {
		ret = [NSAutoreleasePool debugDescription];
	}
	return ret;

}
NSInteger
NSAutoreleasePool_Version() {
	NSInteger ret;
	@autoreleasepool {
		ret = [NSAutoreleasePool version];
	}
	return ret;

}
void
NSAutoreleasePool_SetVersion(NSInteger aVersion) {
	@autoreleasepool {
		[NSAutoreleasePool setVersion:aVersion];
	}
}
void*
NSAutoreleasePool_Class() {
	Class ret;
	@autoreleasepool {
		ret = [NSAutoreleasePool class];
	}
	return ret;

}
void*
NSAutoreleasePool_CopyWithZone(void* zone) {
	NSObject* ret;
	@autoreleasepool {
		ret = [NSAutoreleasePool copyWithZone:zone];
	}
	return ret;

}
void*
NSAutoreleasePool_Description() {
	NSString* ret;
	@autoreleasepool {
		ret = [NSAutoreleasePool description];
	}
	return ret;

}
void
NSAutoreleasePool_AddObject(void* anObject) {
	@autoreleasepool {
		[NSAutoreleasePool addObject:anObject];
	}
}
void* _Nonnull
NSAutoreleasePool_ClassFallbacksForKeyedArchiver() {
	NSArray* _Nonnull ret;
	@autoreleasepool {
		ret = [NSAutoreleasePool classFallbacksForKeyedArchiver];
	}
	return ret;

}
void* _Nonnull
NSAutoreleasePool_ClassForKeyedUnarchiver() {
	Class _Nonnull ret;
	@autoreleasepool {
		ret = [NSAutoreleasePool classForKeyedUnarchiver];
	}
	return ret;

}
NSUInteger
NSAutoreleasePool_Hash() {
	NSUInteger ret;
	@autoreleasepool {
		ret = [NSAutoreleasePool hash];
	}
	return ret;

}
BOOL
NSAutoreleasePool_IsSubclassOfClass(void* aClass) {
	BOOL ret;
	@autoreleasepool {
		ret = [NSAutoreleasePool isSubclassOfClass:aClass];
	}
	return ret;

}
BOOL
NSAutoreleasePool_AutomaticallyNotifiesObserversForKey(void* key) {
	BOOL ret;
	@autoreleasepool {
		ret = [NSAutoreleasePool automaticallyNotifiesObserversForKey:key];
	}
	return ret;

}
void
NSAutoreleasePool_Load() {
	@autoreleasepool {
		[NSAutoreleasePool load];
	}
}
void*
NSAutoreleasePool_InstanceMethodSignatureForSelector(void* aSelector) {
	NSMethodSignature* ret;
	@autoreleasepool {
		ret = [NSAutoreleasePool instanceMethodSignatureForSelector:aSelector];
	}
	return ret;

}
BOOL
NSAutoreleasePool_InstancesRespondToSelector(void* aSelector) {
	BOOL ret;
	@autoreleasepool {
		ret = [NSAutoreleasePool instancesRespondToSelector:aSelector];
	}
	return ret;

}
void*
NSAutoreleasePool_New() {
	NSAutoreleasePool* ret;
	@autoreleasepool {
		ret = [NSAutoreleasePool new];
	}
	return ret;

}
BOOL
NSAutoreleasePool_inst_IsEqualTo(void* o, void* object) {
	BOOL ret;
	@autoreleasepool {
		ret = [(NSAutoreleasePool*)o isEqualTo:object];
	}
	return ret;

}
BOOL
NSAutoreleasePool_inst_IsGreaterThan(void* o, void* object) {
	BOOL ret;
	@autoreleasepool {
		ret = [(NSAutoreleasePool*)o isGreaterThan:object];
	}
	return ret;

}
void* _Nonnull
NSAutoreleasePool_inst_AttributeKeys(void* o) {
	NSArray* _Nonnull ret;
	@autoreleasepool {
		ret = [(NSAutoreleasePool*)o attributeKeys];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
void* _Nonnull
NSAutoreleasePool_inst_ClassDescription(void* o) {
	NSClassDescription* _Nonnull ret;
	@autoreleasepool {
		ret = [(NSAutoreleasePool*)o classDescription];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
void* _Nullable
NSAutoreleasePool_inst_AwakeAfterUsingCoder(void* o, void* coder) {
	NSObject* _Nullable ret;
	@autoreleasepool {
		ret = [(NSAutoreleasePool*)o awakeAfterUsingCoder:coder];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
void* _Nonnull
NSAutoreleasePool_inst_MutableSetValueForKeyPath(void* o, void* keyPath) {
	NSMutableSet* _Nonnull ret;
	@autoreleasepool {
		ret = [(NSAutoreleasePool*)o mutableSetValueForKeyPath:keyPath];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
BOOL
NSAutoreleasePool_inst_IsGreaterThanOrEqualTo(void* o, void* object) {
	BOOL ret;
	@autoreleasepool {
		ret = [(NSAutoreleasePool*)o isGreaterThanOrEqualTo:object];
	}
	return ret;

}
void
NSAutoreleasePool_inst_PerformSelectorOnMainThreadWithObject(void* o, void* aSelector, void* arg, BOOL wait) {
	@autoreleasepool {
		[(NSAutoreleasePool*)o performSelectorOnMainThread:aSelector withObject:arg waitUntilDone:wait];
	}
}
void
NSAutoreleasePool_inst_PerformSelectorOnMainThreadWithObjectWaitUntilDone(void* o, void* aSelector, void* arg, BOOL wait) {
	@autoreleasepool {
		[(NSAutoreleasePool*)o performSelectorOnMainThread:aSelector withObject:arg waitUntilDone:wait];
	}
}
void
NSAutoreleasePool_inst_PerformSelectorOnMainThreadWithObjectWaitUntilDoneModes(void* o, void* aSelector, void* arg, BOOL wait, void* array) {
	@autoreleasepool {
		[(NSAutoreleasePool*)o performSelectorOnMainThread:aSelector withObject:arg waitUntilDone:wait modes:array];
	}
}
BOOL
NSAutoreleasePool_inst_IsLike(void* o, void* object) {
	BOOL ret;
	@autoreleasepool {
		ret = [(NSAutoreleasePool*)o isLike:object];
	}
	return ret;

}
void
NSAutoreleasePool_inst_SetScriptingProperties(void* o, void* scriptingProperties) {
	@autoreleasepool {
		[(NSAutoreleasePool*)o setScriptingProperties:scriptingProperties];
	}
}
void
NSAutoreleasePool_inst_InsertValueInPropertyWithKey(void* o, void* value, void* key) {
	@autoreleasepool {
		[(NSAutoreleasePool*)o insertValue:value inPropertyWithKey:key];
	}
}
void
NSAutoreleasePool_inst_InsertValueAtIndex(void* o, void* value, NSUInteger index, void* key) {
	@autoreleasepool {
		[(NSAutoreleasePool*)o insertValue:value atIndex:index inPropertyWithKey:key];
	}
}
void
NSAutoreleasePool_inst_InsertValueAtIndexInPropertyWithKey(void* o, void* value, NSUInteger index, void* key) {
	@autoreleasepool {
		[(NSAutoreleasePool*)o insertValue:value atIndex:index inPropertyWithKey:key];
	}
}
BOOL
NSAutoreleasePool_inst_DoesContain(void* o, void* object) {
	BOOL ret;
	@autoreleasepool {
		ret = [(NSAutoreleasePool*)o doesContain:object];
	}
	return ret;

}
BOOL
NSAutoreleasePool_inst_ValidateValueForKey(void* o, void** ioValue, void* inKey, void** outError) {
	BOOL ret;
	@autoreleasepool {
		ret = [(NSAutoreleasePool*)o validateValue:(id _Nullable* _Nonnull)ioValue forKey:inKey error:(NSError* _Nullable* _Nullable)outError];
		for(int i=0;i<1;i++) {
			if(ioValue[i] == 0) { break; }
			[(id)ioValue[i] retain];
		}
	
	
		for(int i=0;i<1;i++) {
			if(outError[i] == 0) { break; }
			[(id)outError[i] retain];
		}
	
	}
	return ret;

}
BOOL
NSAutoreleasePool_inst_ValidateValueForKeyPath(void* o, void** ioValue, void* inKeyPath, void** outError) {
	BOOL ret;
	@autoreleasepool {
		ret = [(NSAutoreleasePool*)o validateValue:(id _Nullable* _Nonnull)ioValue forKeyPath:inKeyPath error:(NSError* _Nullable* _Nullable)outError];
		for(int i=0;i<1;i++) {
			if(ioValue[i] == 0) { break; }
			[(id)ioValue[i] retain];
		}
	
	
		for(int i=0;i<1;i++) {
			if(outError[i] == 0) { break; }
			[(id)outError[i] retain];
		}
	
	}
	return ret;

}
BOOL
NSAutoreleasePool_inst_ValidateValueForKeyError(void* o, void** ioValue, void* inKey, void** outError) {
	BOOL ret;
	@autoreleasepool {
		ret = [(NSAutoreleasePool*)o validateValue:(id _Nullable* _Nonnull)ioValue forKey:inKey error:(NSError* _Nullable* _Nullable)outError];
		for(int i=0;i<1;i++) {
			if(ioValue[i] == 0) { break; }
			[(id)ioValue[i] retain];
		}
	
	
		for(int i=0;i<1;i++) {
			if(outError[i] == 0) { break; }
			[(id)outError[i] retain];
		}
	
	}
	return ret;

}
BOOL
NSAutoreleasePool_inst_ValidateValueForKeyPathError(void* o, void** ioValue, void* inKeyPath, void** outError) {
	BOOL ret;
	@autoreleasepool {
		ret = [(NSAutoreleasePool*)o validateValue:(id _Nullable* _Nonnull)ioValue forKeyPath:inKeyPath error:(NSError* _Nullable* _Nullable)outError];
		for(int i=0;i<1;i++) {
			if(ioValue[i] == 0) { break; }
			[(id)ioValue[i] retain];
		}
	
	
		for(int i=0;i<1;i++) {
			if(outError[i] == 0) { break; }
			[(id)outError[i] retain];
		}
	
	}
	return ret;

}
void* _Nullable
NSAutoreleasePool_inst_CopyScriptingValueForKey(void* o, void* value, void* key, void* properties) {
	NSObject* _Nullable ret;
	@autoreleasepool {
		ret = [(NSAutoreleasePool*)o copyScriptingValue:value forKey:key withProperties:properties];
	}
	return ret;

}
void* _Nullable
NSAutoreleasePool_inst_CopyScriptingValueForKeyWithProperties(void* o, void* value, void* key, void* properties) {
	NSObject* _Nullable ret;
	@autoreleasepool {
		ret = [(NSAutoreleasePool*)o copyScriptingValue:value forKey:key withProperties:properties];
	}
	return ret;

}
void
NSAutoreleasePool_inst_DoesNotRecognizeSelector(void* o, void* aSelector) {
	@autoreleasepool {
		[(NSAutoreleasePool*)o doesNotRecognizeSelector:aSelector];
	}
}
FourCharCode
NSAutoreleasePool_inst_ClassCode(void* o) {
	FourCharCode ret;
	@autoreleasepool {
		ret = [(NSAutoreleasePool*)o classCode];
	}
	return ret;

}
void*
NSAutoreleasePool_inst_Init(void* o) {
	NSAutoreleasePool* ret;
	@autoreleasepool {
		ret = [(NSAutoreleasePool*)o init];
	}
	return ret;

}
void
NSAutoreleasePool_inst_AddObserverForKeyPath(void* o, void* observer, void* keyPath, NSKeyValueObservingOptions options, void* context) {
	@autoreleasepool {
		[(NSAutoreleasePool*)o addObserver:observer forKeyPath:keyPath options:options context:context];
	}
}
void
NSAutoreleasePool_inst_AddObserverForKeyPathOptions(void* o, void* observer, void* keyPath, NSKeyValueObservingOptions options, void* context) {
	@autoreleasepool {
		[(NSAutoreleasePool*)o addObserver:observer forKeyPath:keyPath options:options context:context];
	}
}
void* _Nonnull
NSAutoreleasePool_inst_ToOneRelationshipKeys(void* o) {
	NSArray* _Nonnull ret;
	@autoreleasepool {
		ret = [(NSAutoreleasePool*)o toOneRelationshipKeys];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
void
NSAutoreleasePool_inst_ReplaceValueAtIndexInPropertyWithKey(void* o, NSUInteger index, void* key, void* value) {
	@autoreleasepool {
		[(NSAutoreleasePool*)o replaceValueAtIndex:index inPropertyWithKey:key withValue:value];
	}
}
void
NSAutoreleasePool_inst_ReplaceValueAtIndexInPropertyWithKeyWithValue(void* o, NSUInteger index, void* key, void* value) {
	@autoreleasepool {
		[(NSAutoreleasePool*)o replaceValueAtIndex:index inPropertyWithKey:key withValue:value];
	}
}
void
NSAutoreleasePool_inst_DidChangeValuesAtIndexes(void* o, NSKeyValueChange changeKind, void* indexes, void* key) {
	@autoreleasepool {
		[(NSAutoreleasePool*)o didChange:changeKind valuesAtIndexes:indexes forKey:key];
	}
}
void
NSAutoreleasePool_inst_DidChangeValuesAtIndexesForKey(void* o, NSKeyValueChange changeKind, void* indexes, void* key) {
	@autoreleasepool {
		[(NSAutoreleasePool*)o didChange:changeKind valuesAtIndexes:indexes forKey:key];
	}
}
BOOL
NSAutoreleasePool_inst_AttemptRecoveryFromErrorOptionIndex(void* o, void* error, NSUInteger recoveryOptionIndex) {
	BOOL ret;
	@autoreleasepool {
		ret = [(NSAutoreleasePool*)o attemptRecoveryFromError:error optionIndex:recoveryOptionIndex];
	}
	return ret;

}
void
NSAutoreleasePool_inst_AttemptRecoveryFromErrorOptionIndexDelegate(void* o, void* error, NSUInteger recoveryOptionIndex, void* delegate, void* didRecoverSelector, void* contextInfo) {
	@autoreleasepool {
		[(NSAutoreleasePool*)o attemptRecoveryFromError:error optionIndex:recoveryOptionIndex delegate:delegate didRecoverSelector:didRecoverSelector contextInfo:contextInfo];
	}
}
void
NSAutoreleasePool_inst_AttemptRecoveryFromErrorOptionIndexDelegateDidRecoverSelector(void* o, void* error, NSUInteger recoveryOptionIndex, void* delegate, void* didRecoverSelector, void* contextInfo) {
	@autoreleasepool {
		[(NSAutoreleasePool*)o attemptRecoveryFromError:error optionIndex:recoveryOptionIndex delegate:delegate didRecoverSelector:didRecoverSelector contextInfo:contextInfo];
	}
}
void
NSAutoreleasePool_inst_SetValuesForKeysWithDictionary(void* o, void* keyedValues) {
	@autoreleasepool {
		[(NSAutoreleasePool*)o setValuesForKeysWithDictionary:keyedValues];
	}
}
void* _Nonnull
NSAutoreleasePool_inst_DictionaryWithValuesForKeys(void* o, void* keys) {
	NSDictionary* _Nonnull ret;
	@autoreleasepool {
		ret = [(NSAutoreleasePool*)o dictionaryWithValuesForKeys:keys];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
void*
NSAutoreleasePool_inst_Copy(void* o) {
	NSObject* ret;
	@autoreleasepool {
		ret = [(NSAutoreleasePool*)o copy];
	}
	return ret;

}
void* _Nonnull
NSAutoreleasePool_inst_MutableOrderedSetValueForKey(void* o, void* key) {
	NSMutableOrderedSet* _Nonnull ret;
	@autoreleasepool {
		ret = [(NSAutoreleasePool*)o mutableOrderedSetValueForKey:key];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
void
NSAutoreleasePool_inst_RemoveObserverForKeyPath(void* o, void* observer, void* keyPath) {
	@autoreleasepool {
		[(NSAutoreleasePool*)o removeObserver:observer forKeyPath:keyPath];
	}
}
void
NSAutoreleasePool_inst_RemoveObserverForKeyPathContext(void* o, void* observer, void* keyPath, void* context) {
	@autoreleasepool {
		[(NSAutoreleasePool*)o removeObserver:observer forKeyPath:keyPath context:context];
	}
}
void* _Nullable
NSAutoreleasePool_inst_ObjectSpecifier(void* o) {
	NSScriptObjectSpecifier* _Nullable ret;
	@autoreleasepool {
		ret = [(NSAutoreleasePool*)o objectSpecifier];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
BOOL
NSAutoreleasePool_inst_ScriptingIsLessThan(void* o, void* object) {
	BOOL ret;
	@autoreleasepool {
		ret = [(NSAutoreleasePool*)o scriptingIsLessThan:object];
	}
	return ret;

}
void
NSAutoreleasePool_inst_Drain(void* o) {
	@autoreleasepool {
		[(NSAutoreleasePool*)o drain];
	}
}
void
NSAutoreleasePool_inst_ObserveValueForKeyPathOfObject(void* o, void* keyPath, void* object, void* change, void* context) {
	@autoreleasepool {
		[(NSAutoreleasePool*)o observeValueForKeyPath:keyPath ofObject:object change:change context:context];
	}
}
void
NSAutoreleasePool_inst_ObserveValueForKeyPathOfObjectChange(void* o, void* keyPath, void* object, void* change, void* context) {
	@autoreleasepool {
		[(NSAutoreleasePool*)o observeValueForKeyPath:keyPath ofObject:object change:change context:context];
	}
}
void
NSAutoreleasePool_inst_SetValueForKey(void* o, void* value, void* key) {
	@autoreleasepool {
		[(NSAutoreleasePool*)o setValue:value forKey:key];
	}
}
void
NSAutoreleasePool_inst_SetValueForKeyPath(void* o, void* value, void* keyPath) {
	@autoreleasepool {
		[(NSAutoreleasePool*)o setValue:value forKeyPath:keyPath];
	}
}
void
NSAutoreleasePool_inst_SetValueForUndefinedKey(void* o, void* value, void* key) {
	@autoreleasepool {
		[(NSAutoreleasePool*)o setValue:value forUndefinedKey:key];
	}
}
void
NSAutoreleasePool_inst_SetObservationInfo(void* o, void* observationInfo) {
	@autoreleasepool {
		[(NSAutoreleasePool*)o setObservationInfo:observationInfo];
	}
}
void
NSAutoreleasePool_inst_SetNilValueForKey(void* o, void* key) {
	@autoreleasepool {
		[(NSAutoreleasePool*)o setNilValueForKey:key];
	}
}
void* _Nonnull
NSAutoreleasePool_inst_ClassForCoder(void* o) {
	Class _Nonnull ret;
	@autoreleasepool {
		ret = [(NSAutoreleasePool*)o classForCoder];
	}
	return ret;

}
void* _Nullable
NSAutoreleasePool_inst_ValueForKey(void* o, void* key) {
	NSObject* _Nullable ret;
	@autoreleasepool {
		ret = [(NSAutoreleasePool*)o valueForKey:key];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
void
NSAutoreleasePool_inst_RemoveValueAtIndexFromPropertyWithKey(void* o, NSUInteger index, void* key) {
	@autoreleasepool {
		[(NSAutoreleasePool*)o removeValueAtIndex:index fromPropertyWithKey:key];
	}
}
void* _Nullable
NSAutoreleasePool_inst_ClassForKeyedArchiver(void* o) {
	Class _Nullable ret;
	@autoreleasepool {
		ret = [(NSAutoreleasePool*)o classForKeyedArchiver];
	}
	return ret;

}
void* _Nullable
NSAutoreleasePool_inst_ValueWithNameInPropertyWithKey(void* o, void* name, void* key) {
	NSObject* _Nullable ret;
	@autoreleasepool {
		ret = [(NSAutoreleasePool*)o valueWithName:name inPropertyWithKey:key];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
void* _Nullable
NSAutoreleasePool_inst_NewScriptingObjectOfClassForValueForKey(void* o, void* objectClass, void* key, void* contentsValue, void* properties) {
	NSObject* _Nullable ret;
	@autoreleasepool {
		ret = [(NSAutoreleasePool*)o newScriptingObjectOfClass:objectClass forValueForKey:key withContentsValue:contentsValue properties:properties];
	}
	return ret;

}
void* _Nullable
NSAutoreleasePool_inst_NewScriptingObjectOfClassForValueForKeyWithContentsValue(void* o, void* objectClass, void* key, void* contentsValue, void* properties) {
	NSObject* _Nullable ret;
	@autoreleasepool {
		ret = [(NSAutoreleasePool*)o newScriptingObjectOfClass:objectClass forValueForKey:key withContentsValue:contentsValue properties:properties];
	}
	return ret;

}
void* _Nonnull
NSAutoreleasePool_inst_ClassName(void* o) {
	NSString* _Nonnull ret;
	@autoreleasepool {
		ret = [(NSAutoreleasePool*)o className];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
BOOL
NSAutoreleasePool_inst_IsLessThanOrEqualTo(void* o, void* object) {
	BOOL ret;
	@autoreleasepool {
		ret = [(NSAutoreleasePool*)o isLessThanOrEqualTo:object];
	}
	return ret;

}
BOOL
NSAutoreleasePool_inst_ScriptingEndsWith(void* o, void* object) {
	BOOL ret;
	@autoreleasepool {
		ret = [(NSAutoreleasePool*)o scriptingEndsWith:object];
	}
	return ret;

}
void
NSAutoreleasePool_inst_PerformSelectorWithObject(void* o, void* aSelector, void* anArgument, NSTimeInterval delay) {
	@autoreleasepool {
		[(NSAutoreleasePool*)o performSelector:aSelector withObject:anArgument afterDelay:delay];
	}
}
void
NSAutoreleasePool_inst_PerformSelectorWithObjectAfterDelay(void* o, void* aSelector, void* anArgument, NSTimeInterval delay) {
	@autoreleasepool {
		[(NSAutoreleasePool*)o performSelector:aSelector withObject:anArgument afterDelay:delay];
	}
}
void
NSAutoreleasePool_inst_PerformSelectorWithObjectAfterDelayInModes(void* o, void* aSelector, void* anArgument, NSTimeInterval delay, void* modes) {
	@autoreleasepool {
		[(NSAutoreleasePool*)o performSelector:aSelector withObject:anArgument afterDelay:delay inModes:modes];
	}
}
void
NSAutoreleasePool_inst_PerformSelectorOnThread(void* o, void* aSelector, void* thr, void* arg, BOOL wait) {
	@autoreleasepool {
		[(NSAutoreleasePool*)o performSelector:aSelector onThread:thr withObject:arg waitUntilDone:wait];
	}
}
void
NSAutoreleasePool_inst_PerformSelectorOnThreadWithObject(void* o, void* aSelector, void* thr, void* arg, BOOL wait) {
	@autoreleasepool {
		[(NSAutoreleasePool*)o performSelector:aSelector onThread:thr withObject:arg waitUntilDone:wait];
	}
}
void
NSAutoreleasePool_inst_PerformSelectorOnThreadWithObjectWaitUntilDone(void* o, void* aSelector, void* thr, void* arg, BOOL wait, void* array) {
	@autoreleasepool {
		[(NSAutoreleasePool*)o performSelector:aSelector onThread:thr withObject:arg waitUntilDone:wait modes:array];
	}
}
void
NSAutoreleasePool_inst_PerformSelectorOnThreadWithObjectWaitUntilDoneModes(void* o, void* aSelector, void* thr, void* arg, BOOL wait, void* array) {
	@autoreleasepool {
		[(NSAutoreleasePool*)o performSelector:aSelector onThread:thr withObject:arg waitUntilDone:wait modes:array];
	}
}
BOOL
NSAutoreleasePool_inst_ScriptingIsLessThanOrEqualTo(void* o, void* object) {
	BOOL ret;
	@autoreleasepool {
		ret = [(NSAutoreleasePool*)o scriptingIsLessThanOrEqualTo:object];
	}
	return ret;

}
void* _Nullable
NSAutoreleasePool_inst_ValueWithUniqueIDInPropertyWithKey(void* o, void* uniqueID, void* key) {
	NSObject* _Nullable ret;
	@autoreleasepool {
		ret = [(NSAutoreleasePool*)o valueWithUniqueID:uniqueID inPropertyWithKey:key];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
void*
NSAutoreleasePool_inst_ForwardingTargetForSelector(void* o, void* aSelector) {
	NSObject* ret;
	@autoreleasepool {
		ret = [(NSAutoreleasePool*)o forwardingTargetForSelector:aSelector];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
void* _Nonnull
NSAutoreleasePool_inst_AutoContentAccessingProxy(void* o) {
	NSObject* _Nonnull ret;
	@autoreleasepool {
		ret = [(NSAutoreleasePool*)o autoContentAccessingProxy];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
void* _Nullable
NSAutoreleasePool_inst_ValueAtIndexInPropertyWithKey(void* o, NSUInteger index, void* key) {
	NSObject* _Nullable ret;
	@autoreleasepool {
		ret = [(NSAutoreleasePool*)o valueAtIndex:index inPropertyWithKey:key];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
void
NSAutoreleasePool_inst_AddObject(void* o, void* anObject) {
	@autoreleasepool {
		[(NSAutoreleasePool*)o addObject:anObject];
	}
}
void
NSAutoreleasePool_inst_PerformSelectorInBackgroundWithObject(void* o, void* aSelector, void* arg) {
	@autoreleasepool {
		[(NSAutoreleasePool*)o performSelectorInBackground:aSelector withObject:arg];
	}
}
void* _Nullable
NSAutoreleasePool_inst_ReplacementObjectForCoder(void* o, void* coder) {
	NSObject* _Nullable ret;
	@autoreleasepool {
		ret = [(NSAutoreleasePool*)o replacementObjectForCoder:coder];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
void
NSAutoreleasePool_inst_WillChangeValuesAtIndexes(void* o, NSKeyValueChange changeKind, void* indexes, void* key) {
	@autoreleasepool {
		[(NSAutoreleasePool*)o willChange:changeKind valuesAtIndexes:indexes forKey:key];
	}
}
void
NSAutoreleasePool_inst_WillChangeValuesAtIndexesForKey(void* o, NSKeyValueChange changeKind, void* indexes, void* key) {
	@autoreleasepool {
		[(NSAutoreleasePool*)o willChange:changeKind valuesAtIndexes:indexes forKey:key];
	}
}
void*
NSAutoreleasePool_inst_ObservationInfo(void* o) {
	void* ret;
	@autoreleasepool {
		ret = [(NSAutoreleasePool*)o observationInfo];
	}
	return ret;

}
void* _Nullable
NSAutoreleasePool_inst_ValueForUndefinedKey(void* o, void* key) {
	NSObject* _Nullable ret;
	@autoreleasepool {
		ret = [(NSAutoreleasePool*)o valueForUndefinedKey:key];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
void* _Nullable
NSAutoreleasePool_inst_ValueForKeyPath(void* o, void* keyPath) {
	NSObject* _Nullable ret;
	@autoreleasepool {
		ret = [(NSAutoreleasePool*)o valueForKeyPath:keyPath];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
void
NSAutoreleasePool_inst_DidChangeValueForKey(void* o, void* key) {
	@autoreleasepool {
		[(NSAutoreleasePool*)o didChangeValueForKey:key];
	}
}
void
NSAutoreleasePool_inst_DidChangeValueForKeyWithSetMutation(void* o, void* key, NSKeyValueSetMutationKind mutationKind, void* objects) {
	@autoreleasepool {
		[(NSAutoreleasePool*)o didChangeValueForKey:key withSetMutation:mutationKind usingObjects:objects];
	}
}
void
NSAutoreleasePool_inst_DidChangeValueForKeyWithSetMutationUsingObjects(void* o, void* key, NSKeyValueSetMutationKind mutationKind, void* objects) {
	@autoreleasepool {
		[(NSAutoreleasePool*)o didChangeValueForKey:key withSetMutation:mutationKind usingObjects:objects];
	}
}
void* _Nullable
NSAutoreleasePool_inst_ScriptingValueForSpecifier(void* o, void* objectSpecifier) {
	NSObject* _Nullable ret;
	@autoreleasepool {
		ret = [(NSAutoreleasePool*)o scriptingValueForSpecifier:objectSpecifier];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
void*
NSAutoreleasePool_inst_MethodSignatureForSelector(void* o, void* aSelector) {
	NSMethodSignature* ret;
	@autoreleasepool {
		ret = [(NSAutoreleasePool*)o methodSignatureForSelector:aSelector];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
void*
NSAutoreleasePool_inst_MutableCopy(void* o) {
	NSObject* ret;
	@autoreleasepool {
		ret = [(NSAutoreleasePool*)o mutableCopy];
	}
	return ret;

}
void
NSAutoreleasePool_inst_ForwardInvocation(void* o, void* anInvocation) {
	@autoreleasepool {
		[(NSAutoreleasePool*)o forwardInvocation:anInvocation];
	}
}
void* _Nonnull
NSAutoreleasePool_inst_MutableSetValueForKey(void* o, void* key) {
	NSMutableSet* _Nonnull ret;
	@autoreleasepool {
		ret = [(NSAutoreleasePool*)o mutableSetValueForKey:key];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
BOOL
NSAutoreleasePool_inst_ScriptingContains(void* o, void* object) {
	BOOL ret;
	@autoreleasepool {
		ret = [(NSAutoreleasePool*)o scriptingContains:object];
	}
	return ret;

}
void* _Nonnull
NSAutoreleasePool_inst_MutableArrayValueForKeyPath(void* o, void* keyPath) {
	NSMutableArray* _Nonnull ret;
	@autoreleasepool {
		ret = [(NSAutoreleasePool*)o mutableArrayValueForKeyPath:keyPath];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
BOOL
NSAutoreleasePool_inst_IsLessThan(void* o, void* object) {
	BOOL ret;
	@autoreleasepool {
		ret = [(NSAutoreleasePool*)o isLessThan:object];
	}
	return ret;

}
BOOL
NSAutoreleasePool_inst_ScriptingIsEqualTo(void* o, void* object) {
	BOOL ret;
	@autoreleasepool {
		ret = [(NSAutoreleasePool*)o scriptingIsEqualTo:object];
	}
	return ret;

}
void* _Nullable
NSAutoreleasePool_inst_IndicesOfObjectsByEvaluatingObjectSpecifier(void* o, void* specifier) {
	NSArray* _Nullable ret;
	@autoreleasepool {
		ret = [(NSAutoreleasePool*)o indicesOfObjectsByEvaluatingObjectSpecifier:specifier];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
BOOL
NSAutoreleasePool_inst_IsCaseInsensitiveLike(void* o, void* object) {
	BOOL ret;
	@autoreleasepool {
		ret = [(NSAutoreleasePool*)o isCaseInsensitiveLike:object];
	}
	return ret;

}
BOOL
NSAutoreleasePool_inst_ScriptingIsGreaterThanOrEqualTo(void* o, void* object) {
	BOOL ret;
	@autoreleasepool {
		ret = [(NSAutoreleasePool*)o scriptingIsGreaterThanOrEqualTo:object];
	}
	return ret;

}
void* _Nonnull
NSAutoreleasePool_inst_MutableOrderedSetValueForKeyPath(void* o, void* keyPath) {
	NSMutableOrderedSet* _Nonnull ret;
	@autoreleasepool {
		ret = [(NSAutoreleasePool*)o mutableOrderedSetValueForKeyPath:keyPath];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
void* _Nonnull
NSAutoreleasePool_inst_MutableArrayValueForKey(void* o, void* key) {
	NSMutableArray* _Nonnull ret;
	@autoreleasepool {
		ret = [(NSAutoreleasePool*)o mutableArrayValueForKey:key];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
void* _Nonnull
NSAutoreleasePool_inst_ToManyRelationshipKeys(void* o) {
	NSArray* _Nonnull ret;
	@autoreleasepool {
		ret = [(NSAutoreleasePool*)o toManyRelationshipKeys];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
void
NSAutoreleasePool_inst_Dealloc(void* o) {
	@autoreleasepool {
		[(NSAutoreleasePool*)o dealloc];
	}
}
void* _Nullable
NSAutoreleasePool_inst_ScriptingProperties(void* o) {
	NSDictionary* _Nullable ret;
	@autoreleasepool {
		ret = [(NSAutoreleasePool*)o scriptingProperties];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
void
NSAutoreleasePool_inst_WillChangeValueForKey(void* o, void* key) {
	@autoreleasepool {
		[(NSAutoreleasePool*)o willChangeValueForKey:key];
	}
}
void
NSAutoreleasePool_inst_WillChangeValueForKeyWithSetMutation(void* o, void* key, NSKeyValueSetMutationKind mutationKind, void* objects) {
	@autoreleasepool {
		[(NSAutoreleasePool*)o willChangeValueForKey:key withSetMutation:mutationKind usingObjects:objects];
	}
}
void
NSAutoreleasePool_inst_WillChangeValueForKeyWithSetMutationUsingObjects(void* o, void* key, NSKeyValueSetMutationKind mutationKind, void* objects) {
	@autoreleasepool {
		[(NSAutoreleasePool*)o willChangeValueForKey:key withSetMutation:mutationKind usingObjects:objects];
	}
}
BOOL
NSAutoreleasePool_inst_IsNotEqualTo(void* o, void* object) {
	BOOL ret;
	@autoreleasepool {
		ret = [(NSAutoreleasePool*)o isNotEqualTo:object];
	}
	return ret;

}
void* _Nullable
NSAutoreleasePool_inst_InverseForRelationshipKey(void* o, void* relationshipKey) {
	NSString* _Nullable ret;
	@autoreleasepool {
		ret = [(NSAutoreleasePool*)o inverseForRelationshipKey:relationshipKey];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
void* _Nullable
NSAutoreleasePool_inst_ClassForArchiver(void* o) {
	Class _Nullable ret;
	@autoreleasepool {
		ret = [(NSAutoreleasePool*)o classForArchiver];
	}
	return ret;

}
BOOL
NSAutoreleasePool_inst_ScriptingIsGreaterThan(void* o, void* object) {
	BOOL ret;
	@autoreleasepool {
		ret = [(NSAutoreleasePool*)o scriptingIsGreaterThan:object];
	}
	return ret;

}
void* _Nullable
NSAutoreleasePool_inst_ReplacementObjectForKeyedArchiver(void* o, void* archiver) {
	NSObject* _Nullable ret;
	@autoreleasepool {
		ret = [(NSAutoreleasePool*)o replacementObjectForKeyedArchiver:archiver];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
void* _Nullable
NSAutoreleasePool_inst_CoerceValueForKey(void* o, void* value, void* key) {
	NSObject* _Nullable ret;
	@autoreleasepool {
		ret = [(NSAutoreleasePool*)o coerceValue:value forKey:key];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
BOOL
NSAutoreleasePool_inst_ScriptingBeginsWith(void* o, void* object) {
	BOOL ret;
	@autoreleasepool {
		ret = [(NSAutoreleasePool*)o scriptingBeginsWith:object];
	}
	return ret;

}
void* _Nonnull
CBManager_ClassFallbacksForKeyedArchiver() {
	NSArray* _Nonnull ret;
	@autoreleasepool {
		ret = [CBManager classFallbacksForKeyedArchiver];
	}
	return ret;

}
void
CBManager_SetVersion(NSInteger aVersion) {
	@autoreleasepool {
		[CBManager setVersion:aVersion];
	}
}
void* _Nonnull
CBManager_KeyPathsForValuesAffectingValueForKey(void* key) {
	NSSet* _Nonnull ret;
	@autoreleasepool {
		ret = [CBManager keyPathsForValuesAffectingValueForKey:key];
	}
	return ret;

}
void*
CBManager_Description() {
	NSString* ret;
	@autoreleasepool {
		ret = [CBManager description];
	}
	return ret;

}
NSInteger
CBManager_Version() {
	NSInteger ret;
	@autoreleasepool {
		ret = [CBManager version];
	}
	return ret;

}
BOOL
CBManager_AccessInstanceVariablesDirectly() {
	BOOL ret;
	@autoreleasepool {
		ret = [CBManager accessInstanceVariablesDirectly];
	}
	return ret;

}
CBManagerAuthorization
CBManager_Authorization() {
	CBManagerAuthorization ret;
	@autoreleasepool {
		ret = [CBManager authorization];
	}
	return ret;

}
BOOL
CBManager_ConformsToProtocol(void* protocol) {
	BOOL ret;
	@autoreleasepool {
		ret = [CBManager conformsToProtocol:protocol];
	}
	return ret;

}
void*
CBManager_CopyWithZone(void* zone) {
	NSObject* ret;
	@autoreleasepool {
		ret = [CBManager copyWithZone:zone];
	}
	return ret;

}
void*
CBManager_Superclass() {
	Class ret;
	@autoreleasepool {
		ret = [CBManager superclass];
	}
	return ret;

}
void* _Nonnull
CBManager_ClassForKeyedUnarchiver() {
	Class _Nonnull ret;
	@autoreleasepool {
		ret = [CBManager classForKeyedUnarchiver];
	}
	return ret;

}
void
CBManager_Load() {
	@autoreleasepool {
		[CBManager load];
	}
}
BOOL
CBManager_IsSubclassOfClass(void* aClass) {
	BOOL ret;
	@autoreleasepool {
		ret = [CBManager isSubclassOfClass:aClass];
	}
	return ret;

}
BOOL
CBManager_ResolveClassMethod(void* sel) {
	BOOL ret;
	@autoreleasepool {
		ret = [CBManager resolveClassMethod:sel];
	}
	return ret;

}
BOOL
CBManager_AutomaticallyNotifiesObserversForKey(void* key) {
	BOOL ret;
	@autoreleasepool {
		ret = [CBManager automaticallyNotifiesObserversForKey:key];
	}
	return ret;

}
void*
CBManager_New() {
	CBManager* ret;
	@autoreleasepool {
		NSLog(@"CBCharacteristic new");
		//ret = [CBManager new];
	}
	return ret;

}
void*
CBManager_MutableCopyWithZone(void* zone) {
	NSObject* ret;
	@autoreleasepool {
		ret = [CBManager mutableCopyWithZone:zone];
	}
	return ret;

}
void*
CBManager_Alloc() {
	return [CBManager alloc];
}
void*
CBManager_DebugDescription() {
	NSString* ret;
	@autoreleasepool {
		ret = [CBManager debugDescription];
	}
	return ret;

}
void
CBManager_CancelPreviousPerformRequestsWithTarget(void* aTarget) {
	@autoreleasepool {
		[CBManager cancelPreviousPerformRequestsWithTarget:aTarget];
	}
}
void
CBManager_CancelPreviousPerformRequestsWithTargetSelector(void* aTarget, void* aSelector, void* anArgument) {
	@autoreleasepool {
		[CBManager cancelPreviousPerformRequestsWithTarget:aTarget selector:aSelector object:anArgument];
	}
}
void
CBManager_CancelPreviousPerformRequestsWithTargetSelectorObject(void* aTarget, void* aSelector, void* anArgument) {
	@autoreleasepool {
		[CBManager cancelPreviousPerformRequestsWithTarget:aTarget selector:aSelector object:anArgument];
	}
}
void*
CBManager_AllocWithZone(void* zone) {
	return [CBManager allocWithZone:zone];
}
NSUInteger
CBManager_Hash() {
	NSUInteger ret;
	@autoreleasepool {
		ret = [CBManager hash];
	}
	return ret;

}
BOOL
CBManager_ResolveInstanceMethod(void* sel) {
	BOOL ret;
	@autoreleasepool {
		ret = [CBManager resolveInstanceMethod:sel];
	}
	return ret;

}
void*
CBManager_InstanceMethodSignatureForSelector(void* aSelector) {
	NSMethodSignature* ret;
	@autoreleasepool {
		ret = [CBManager instanceMethodSignatureForSelector:aSelector];
	}
	return ret;

}
void*
CBManager_Class() {
	Class ret;
	@autoreleasepool {
		ret = [CBManager class];
	}
	return ret;

}
BOOL
CBManager_InstancesRespondToSelector(void* aSelector) {
	BOOL ret;
	@autoreleasepool {
		ret = [CBManager instancesRespondToSelector:aSelector];
	}
	return ret;

}
void
CBManager_inst_RemoveObserverForKeyPath(void* o, void* observer, void* keyPath) {
	@autoreleasepool {
		[(CBManager*)o removeObserver:observer forKeyPath:keyPath];
	}
}
void
CBManager_inst_RemoveObserverForKeyPathContext(void* o, void* observer, void* keyPath, void* context) {
	@autoreleasepool {
		[(CBManager*)o removeObserver:observer forKeyPath:keyPath context:context];
	}
}
void* _Nullable
CBManager_inst_ValueForKey(void* o, void* key) {
	NSObject* _Nullable ret;
	@autoreleasepool {
		ret = [(CBManager*)o valueForKey:key];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
BOOL
CBManager_inst_ScriptingEndsWith(void* o, void* object) {
	BOOL ret;
	@autoreleasepool {
		ret = [(CBManager*)o scriptingEndsWith:object];
	}
	return ret;

}
void
CBManager_inst_RemoveValueAtIndexFromPropertyWithKey(void* o, NSUInteger index, void* key) {
	@autoreleasepool {
		[(CBManager*)o removeValueAtIndex:index fromPropertyWithKey:key];
	}
}
BOOL
CBManager_inst_ScriptingIsLessThanOrEqualTo(void* o, void* object) {
	BOOL ret;
	@autoreleasepool {
		ret = [(CBManager*)o scriptingIsLessThanOrEqualTo:object];
	}
	return ret;

}
void* _Nonnull
CBManager_inst_MutableArrayValueForKey(void* o, void* key) {
	NSMutableArray* _Nonnull ret;
	@autoreleasepool {
		ret = [(CBManager*)o mutableArrayValueForKey:key];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
void
CBManager_inst_SetValueForKey(void* o, void* value, void* key) {
	@autoreleasepool {
		[(CBManager*)o setValue:value forKey:key];
	}
}
void
CBManager_inst_SetValueForKeyPath(void* o, void* value, void* keyPath) {
	@autoreleasepool {
		[(CBManager*)o setValue:value forKeyPath:keyPath];
	}
}
void
CBManager_inst_SetValueForUndefinedKey(void* o, void* value, void* key) {
	@autoreleasepool {
		[(CBManager*)o setValue:value forUndefinedKey:key];
	}
}
BOOL
CBManager_inst_ValidateValueForKey(void* o, void** ioValue, void* inKey, void** outError) {
	BOOL ret;
	@autoreleasepool {
		ret = [(CBManager*)o validateValue:(id _Nullable* _Nonnull)ioValue forKey:inKey error:(NSError* _Nullable* _Nullable)outError];
		for(int i=0;i<1;i++) {
			if(ioValue[i] == 0) { break; }
			[(id)ioValue[i] retain];
		}
	
	
		for(int i=0;i<1;i++) {
			if(outError[i] == 0) { break; }
			[(id)outError[i] retain];
		}
	
	}
	return ret;

}
BOOL
CBManager_inst_ValidateValueForKeyPath(void* o, void** ioValue, void* inKeyPath, void** outError) {
	BOOL ret;
	@autoreleasepool {
		ret = [(CBManager*)o validateValue:(id _Nullable* _Nonnull)ioValue forKeyPath:inKeyPath error:(NSError* _Nullable* _Nullable)outError];
		for(int i=0;i<1;i++) {
			if(ioValue[i] == 0) { break; }
			[(id)ioValue[i] retain];
		}
	
	
		for(int i=0;i<1;i++) {
			if(outError[i] == 0) { break; }
			[(id)outError[i] retain];
		}
	
	}
	return ret;

}
BOOL
CBManager_inst_ValidateValueForKeyError(void* o, void** ioValue, void* inKey, void** outError) {
	BOOL ret;
	@autoreleasepool {
		ret = [(CBManager*)o validateValue:(id _Nullable* _Nonnull)ioValue forKey:inKey error:(NSError* _Nullable* _Nullable)outError];
		for(int i=0;i<1;i++) {
			if(ioValue[i] == 0) { break; }
			[(id)ioValue[i] retain];
		}
	
	
		for(int i=0;i<1;i++) {
			if(outError[i] == 0) { break; }
			[(id)outError[i] retain];
		}
	
	}
	return ret;

}
BOOL
CBManager_inst_ValidateValueForKeyPathError(void* o, void** ioValue, void* inKeyPath, void** outError) {
	BOOL ret;
	@autoreleasepool {
		ret = [(CBManager*)o validateValue:(id _Nullable* _Nonnull)ioValue forKeyPath:inKeyPath error:(NSError* _Nullable* _Nullable)outError];
		for(int i=0;i<1;i++) {
			if(ioValue[i] == 0) { break; }
			[(id)ioValue[i] retain];
		}
	
	
		for(int i=0;i<1;i++) {
			if(outError[i] == 0) { break; }
			[(id)outError[i] retain];
		}
	
	}
	return ret;

}
FourCharCode
CBManager_inst_ClassCode(void* o) {
	FourCharCode ret;
	@autoreleasepool {
		ret = [(CBManager*)o classCode];
	}
	return ret;

}
void*
CBManager_inst_MutableCopy(void* o) {
	NSObject* ret;
	@autoreleasepool {
		ret = [(CBManager*)o mutableCopy];
	}
	return ret;

}
void
CBManager_inst_ForwardInvocation(void* o, void* anInvocation) {
	@autoreleasepool {
		[(CBManager*)o forwardInvocation:anInvocation];
	}
}
void* _Nonnull
CBManager_inst_AttributeKeys(void* o) {
	NSArray* _Nonnull ret;
	@autoreleasepool {
		ret = [(CBManager*)o attributeKeys];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
void*
CBManager_inst_Copy(void* o) {
	NSObject* ret;
	@autoreleasepool {
		ret = [(CBManager*)o copy];
	}
	return ret;

}
void* _Nullable
CBManager_inst_ValueWithNameInPropertyWithKey(void* o, void* name, void* key) {
	NSObject* _Nullable ret;
	@autoreleasepool {
		ret = [(CBManager*)o valueWithName:name inPropertyWithKey:key];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
void*
CBManager_inst_ObservationInfo(void* o) {
	void* ret;
	@autoreleasepool {
		ret = [(CBManager*)o observationInfo];
	}
	return ret;

}
void
CBManager_inst_AddObserverForKeyPath(void* o, void* observer, void* keyPath, NSKeyValueObservingOptions options, void* context) {
	@autoreleasepool {
		[(CBManager*)o addObserver:observer forKeyPath:keyPath options:options context:context];
	}
}
void
CBManager_inst_AddObserverForKeyPathOptions(void* o, void* observer, void* keyPath, NSKeyValueObservingOptions options, void* context) {
	@autoreleasepool {
		[(CBManager*)o addObserver:observer forKeyPath:keyPath options:options context:context];
	}
}
void* _Nonnull
CBManager_inst_ClassForCoder(void* o) {
	Class _Nonnull ret;
	@autoreleasepool {
		ret = [(CBManager*)o classForCoder];
	}
	return ret;

}
void* _Nullable
CBManager_inst_AwakeAfterUsingCoder(void* o, void* coder) {
	NSObject* _Nullable ret;
	@autoreleasepool {
		ret = [(CBManager*)o awakeAfterUsingCoder:coder];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
void* _Nonnull
CBManager_inst_ToOneRelationshipKeys(void* o) {
	NSArray* _Nonnull ret;
	@autoreleasepool {
		ret = [(CBManager*)o toOneRelationshipKeys];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
void
CBManager_inst_PerformSelectorWithObject(void* o, void* aSelector, void* anArgument, NSTimeInterval delay) {
	@autoreleasepool {
		[(CBManager*)o performSelector:aSelector withObject:anArgument afterDelay:delay];
	}
}
void
CBManager_inst_PerformSelectorWithObjectAfterDelay(void* o, void* aSelector, void* anArgument, NSTimeInterval delay) {
	@autoreleasepool {
		[(CBManager*)o performSelector:aSelector withObject:anArgument afterDelay:delay];
	}
}
void
CBManager_inst_PerformSelectorWithObjectAfterDelayInModes(void* o, void* aSelector, void* anArgument, NSTimeInterval delay, void* modes) {
	@autoreleasepool {
		[(CBManager*)o performSelector:aSelector withObject:anArgument afterDelay:delay inModes:modes];
	}
}
void
CBManager_inst_PerformSelectorOnThread(void* o, void* aSelector, void* thr, void* arg, BOOL wait) {
	@autoreleasepool {
		[(CBManager*)o performSelector:aSelector onThread:thr withObject:arg waitUntilDone:wait];
	}
}
void
CBManager_inst_PerformSelectorOnThreadWithObject(void* o, void* aSelector, void* thr, void* arg, BOOL wait) {
	@autoreleasepool {
		[(CBManager*)o performSelector:aSelector onThread:thr withObject:arg waitUntilDone:wait];
	}
}
void
CBManager_inst_PerformSelectorOnThreadWithObjectWaitUntilDone(void* o, void* aSelector, void* thr, void* arg, BOOL wait, void* array) {
	@autoreleasepool {
		[(CBManager*)o performSelector:aSelector onThread:thr withObject:arg waitUntilDone:wait modes:array];
	}
}
void
CBManager_inst_PerformSelectorOnThreadWithObjectWaitUntilDoneModes(void* o, void* aSelector, void* thr, void* arg, BOOL wait, void* array) {
	@autoreleasepool {
		[(CBManager*)o performSelector:aSelector onThread:thr withObject:arg waitUntilDone:wait modes:array];
	}
}
BOOL
CBManager_inst_ScriptingIsGreaterThanOrEqualTo(void* o, void* object) {
	BOOL ret;
	@autoreleasepool {
		ret = [(CBManager*)o scriptingIsGreaterThanOrEqualTo:object];
	}
	return ret;

}
CBManagerAuthorization
CBManager_inst_Authorization(void* o) {
	CBManagerAuthorization ret;
	@autoreleasepool {
		ret = [(CBManager*)o authorization];
	}
	return ret;

}
void* _Nullable
CBManager_inst_ValueWithUniqueIDInPropertyWithKey(void* o, void* uniqueID, void* key) {
	NSObject* _Nullable ret;
	@autoreleasepool {
		ret = [(CBManager*)o valueWithUniqueID:uniqueID inPropertyWithKey:key];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
void* _Nonnull
CBManager_inst_MutableArrayValueForKeyPath(void* o, void* keyPath) {
	NSMutableArray* _Nonnull ret;
	@autoreleasepool {
		ret = [(CBManager*)o mutableArrayValueForKeyPath:keyPath];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
void
CBManager_inst_ReplaceValueAtIndexInPropertyWithKey(void* o, NSUInteger index, void* key, void* value) {
	@autoreleasepool {
		[(CBManager*)o replaceValueAtIndex:index inPropertyWithKey:key withValue:value];
	}
}
void
CBManager_inst_ReplaceValueAtIndexInPropertyWithKeyWithValue(void* o, NSUInteger index, void* key, void* value) {
	@autoreleasepool {
		[(CBManager*)o replaceValueAtIndex:index inPropertyWithKey:key withValue:value];
	}
}
void* _Nonnull
CBManager_inst_MutableSetValueForKey(void* o, void* key) {
	NSMutableSet* _Nonnull ret;
	@autoreleasepool {
		ret = [(CBManager*)o mutableSetValueForKey:key];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
CBManagerState
CBManager_inst_State(void* o) {
	CBManagerState ret;
	@autoreleasepool {
		ret = [(CBManager*)o state];
	}
	return ret;

}
void*
CBManager_inst_MethodSignatureForSelector(void* o, void* aSelector) {
	NSMethodSignature* ret;
	@autoreleasepool {
		ret = [(CBManager*)o methodSignatureForSelector:aSelector];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
BOOL
CBManager_inst_IsNotEqualTo(void* o, void* object) {
	BOOL ret;
	@autoreleasepool {
		ret = [(CBManager*)o isNotEqualTo:object];
	}
	return ret;

}
void* _Nonnull
CBManager_inst_ClassName(void* o) {
	NSString* _Nonnull ret;
	@autoreleasepool {
		ret = [(CBManager*)o className];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
BOOL
CBManager_inst_DoesContain(void* o, void* object) {
	BOOL ret;
	@autoreleasepool {
		ret = [(CBManager*)o doesContain:object];
	}
	return ret;

}
void* _Nullable
CBManager_inst_ValueForKeyPath(void* o, void* keyPath) {
	NSObject* _Nullable ret;
	@autoreleasepool {
		ret = [(CBManager*)o valueForKeyPath:keyPath];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
void
CBManager_inst_SetScriptingProperties(void* o, void* scriptingProperties) {
	@autoreleasepool {
		[(CBManager*)o setScriptingProperties:scriptingProperties];
	}
}
void*
CBManager_inst_ForwardingTargetForSelector(void* o, void* aSelector) {
	NSObject* ret;
	@autoreleasepool {
		ret = [(CBManager*)o forwardingTargetForSelector:aSelector];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
void* _Nullable
CBManager_inst_NewScriptingObjectOfClassForValueForKey(void* o, void* objectClass, void* key, void* contentsValue, void* properties) {
	NSObject* _Nullable ret;
	@autoreleasepool {
		ret = [(CBManager*)o newScriptingObjectOfClass:objectClass forValueForKey:key withContentsValue:contentsValue properties:properties];
	}
	return ret;

}
void* _Nullable
CBManager_inst_NewScriptingObjectOfClassForValueForKeyWithContentsValue(void* o, void* objectClass, void* key, void* contentsValue, void* properties) {
	NSObject* _Nullable ret;
	@autoreleasepool {
		ret = [(CBManager*)o newScriptingObjectOfClass:objectClass forValueForKey:key withContentsValue:contentsValue properties:properties];
	}
	return ret;

}
void
CBManager_inst_PerformSelectorOnMainThreadWithObject(void* o, void* aSelector, void* arg, BOOL wait) {
	@autoreleasepool {
		[(CBManager*)o performSelectorOnMainThread:aSelector withObject:arg waitUntilDone:wait];
	}
}
void
CBManager_inst_PerformSelectorOnMainThreadWithObjectWaitUntilDone(void* o, void* aSelector, void* arg, BOOL wait) {
	@autoreleasepool {
		[(CBManager*)o performSelectorOnMainThread:aSelector withObject:arg waitUntilDone:wait];
	}
}
void
CBManager_inst_PerformSelectorOnMainThreadWithObjectWaitUntilDoneModes(void* o, void* aSelector, void* arg, BOOL wait, void* array) {
	@autoreleasepool {
		[(CBManager*)o performSelectorOnMainThread:aSelector withObject:arg waitUntilDone:wait modes:array];
	}
}
BOOL
CBManager_inst_IsLessThan(void* o, void* object) {
	BOOL ret;
	@autoreleasepool {
		ret = [(CBManager*)o isLessThan:object];
	}
	return ret;

}
BOOL
CBManager_inst_IsLike(void* o, void* object) {
	BOOL ret;
	@autoreleasepool {
		ret = [(CBManager*)o isLike:object];
	}
	return ret;

}
void* _Nonnull
CBManager_inst_ToManyRelationshipKeys(void* o) {
	NSArray* _Nonnull ret;
	@autoreleasepool {
		ret = [(CBManager*)o toManyRelationshipKeys];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
void* _Nullable
CBManager_inst_ReplacementObjectForKeyedArchiver(void* o, void* archiver) {
	NSObject* _Nullable ret;
	@autoreleasepool {
		ret = [(CBManager*)o replacementObjectForKeyedArchiver:archiver];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
void
CBManager_inst_InsertValueInPropertyWithKey(void* o, void* value, void* key) {
	@autoreleasepool {
		[(CBManager*)o insertValue:value inPropertyWithKey:key];
	}
}
void
CBManager_inst_InsertValueAtIndex(void* o, void* value, NSUInteger index, void* key) {
	@autoreleasepool {
		[(CBManager*)o insertValue:value atIndex:index inPropertyWithKey:key];
	}
}
void
CBManager_inst_InsertValueAtIndexInPropertyWithKey(void* o, void* value, NSUInteger index, void* key) {
	@autoreleasepool {
		[(CBManager*)o insertValue:value atIndex:index inPropertyWithKey:key];
	}
}
BOOL
CBManager_inst_IsCaseInsensitiveLike(void* o, void* object) {
	BOOL ret;
	@autoreleasepool {
		ret = [(CBManager*)o isCaseInsensitiveLike:object];
	}
	return ret;

}
void* _Nullable
CBManager_inst_ValueAtIndexInPropertyWithKey(void* o, NSUInteger index, void* key) {
	NSObject* _Nullable ret;
	@autoreleasepool {
		ret = [(CBManager*)o valueAtIndex:index inPropertyWithKey:key];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
void
CBManager_inst_WillChangeValueForKey(void* o, void* key) {
	@autoreleasepool {
		[(CBManager*)o willChangeValueForKey:key];
	}
}
void
CBManager_inst_WillChangeValueForKeyWithSetMutation(void* o, void* key, NSKeyValueSetMutationKind mutationKind, void* objects) {
	@autoreleasepool {
		[(CBManager*)o willChangeValueForKey:key withSetMutation:mutationKind usingObjects:objects];
	}
}
void
CBManager_inst_WillChangeValueForKeyWithSetMutationUsingObjects(void* o, void* key, NSKeyValueSetMutationKind mutationKind, void* objects) {
	@autoreleasepool {
		[(CBManager*)o willChangeValueForKey:key withSetMutation:mutationKind usingObjects:objects];
	}
}
BOOL
CBManager_inst_ScriptingContains(void* o, void* object) {
	BOOL ret;
	@autoreleasepool {
		ret = [(CBManager*)o scriptingContains:object];
	}
	return ret;

}
void* _Nonnull
CBManager_inst_MutableSetValueForKeyPath(void* o, void* keyPath) {
	NSMutableSet* _Nonnull ret;
	@autoreleasepool {
		ret = [(CBManager*)o mutableSetValueForKeyPath:keyPath];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
BOOL
CBManager_inst_AttemptRecoveryFromErrorOptionIndex(void* o, void* error, NSUInteger recoveryOptionIndex) {
	BOOL ret;
	@autoreleasepool {
		ret = [(CBManager*)o attemptRecoveryFromError:error optionIndex:recoveryOptionIndex];
	}
	return ret;

}
void
CBManager_inst_AttemptRecoveryFromErrorOptionIndexDelegate(void* o, void* error, NSUInteger recoveryOptionIndex, void* delegate, void* didRecoverSelector, void* contextInfo) {
	@autoreleasepool {
		[(CBManager*)o attemptRecoveryFromError:error optionIndex:recoveryOptionIndex delegate:delegate didRecoverSelector:didRecoverSelector contextInfo:contextInfo];
	}
}
void
CBManager_inst_AttemptRecoveryFromErrorOptionIndexDelegateDidRecoverSelector(void* o, void* error, NSUInteger recoveryOptionIndex, void* delegate, void* didRecoverSelector, void* contextInfo) {
	@autoreleasepool {
		[(CBManager*)o attemptRecoveryFromError:error optionIndex:recoveryOptionIndex delegate:delegate didRecoverSelector:didRecoverSelector contextInfo:contextInfo];
	}
}
BOOL
CBManager_inst_IsGreaterThanOrEqualTo(void* o, void* object) {
	BOOL ret;
	@autoreleasepool {
		ret = [(CBManager*)o isGreaterThanOrEqualTo:object];
	}
	return ret;

}
void
CBManager_inst_PerformSelectorInBackgroundWithObject(void* o, void* aSelector, void* arg) {
	@autoreleasepool {
		[(CBManager*)o performSelectorInBackground:aSelector withObject:arg];
	}
}
BOOL
CBManager_inst_ScriptingIsLessThan(void* o, void* object) {
	BOOL ret;
	@autoreleasepool {
		ret = [(CBManager*)o scriptingIsLessThan:object];
	}
	return ret;

}
void* _Nullable
CBManager_inst_ClassForArchiver(void* o) {
	Class _Nullable ret;
	@autoreleasepool {
		ret = [(CBManager*)o classForArchiver];
	}
	return ret;

}
void* _Nonnull
CBManager_inst_DictionaryWithValuesForKeys(void* o, void* keys) {
	NSDictionary* _Nonnull ret;
	@autoreleasepool {
		ret = [(CBManager*)o dictionaryWithValuesForKeys:keys];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
void* _Nullable
CBManager_inst_CoerceValueForKey(void* o, void* value, void* key) {
	NSObject* _Nullable ret;
	@autoreleasepool {
		ret = [(CBManager*)o coerceValue:value forKey:key];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
void
CBManager_inst_DidChangeValueForKey(void* o, void* key) {
	@autoreleasepool {
		[(CBManager*)o didChangeValueForKey:key];
	}
}
void
CBManager_inst_DidChangeValueForKeyWithSetMutation(void* o, void* key, NSKeyValueSetMutationKind mutationKind, void* objects) {
	@autoreleasepool {
		[(CBManager*)o didChangeValueForKey:key withSetMutation:mutationKind usingObjects:objects];
	}
}
void
CBManager_inst_DidChangeValueForKeyWithSetMutationUsingObjects(void* o, void* key, NSKeyValueSetMutationKind mutationKind, void* objects) {
	@autoreleasepool {
		[(CBManager*)o didChangeValueForKey:key withSetMutation:mutationKind usingObjects:objects];
	}
}
void* _Nullable
CBManager_inst_ClassForKeyedArchiver(void* o) {
	Class _Nullable ret;
	@autoreleasepool {
		ret = [(CBManager*)o classForKeyedArchiver];
	}
	return ret;

}
void* _Nonnull
CBManager_inst_AutoContentAccessingProxy(void* o) {
	NSObject* _Nonnull ret;
	@autoreleasepool {
		ret = [(CBManager*)o autoContentAccessingProxy];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
void* _Nullable
CBManager_inst_ObjectSpecifier(void* o) {
	NSScriptObjectSpecifier* _Nullable ret;
	@autoreleasepool {
		ret = [(CBManager*)o objectSpecifier];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
void
CBManager_inst_SetValuesForKeysWithDictionary(void* o, void* keyedValues) {
	@autoreleasepool {
		[(CBManager*)o setValuesForKeysWithDictionary:keyedValues];
	}
}
void* _Nullable
CBManager_inst_ReplacementObjectForCoder(void* o, void* coder) {
	NSObject* _Nullable ret;
	@autoreleasepool {
		ret = [(CBManager*)o replacementObjectForCoder:coder];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
void
CBManager_inst_Dealloc(void* o) {
	@autoreleasepool {
		[(CBManager*)o dealloc];
	}
}
void* _Nullable
CBManager_inst_ValueForUndefinedKey(void* o, void* key) {
	NSObject* _Nullable ret;
	@autoreleasepool {
		ret = [(CBManager*)o valueForUndefinedKey:key];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
void
CBManager_inst_SetObservationInfo(void* o, void* observationInfo) {
	@autoreleasepool {
		[(CBManager*)o setObservationInfo:observationInfo];
	}
}
BOOL
CBManager_inst_IsGreaterThan(void* o, void* object) {
	BOOL ret;
	@autoreleasepool {
		ret = [(CBManager*)o isGreaterThan:object];
	}
	return ret;

}
void* _Nonnull
CBManager_inst_MutableOrderedSetValueForKeyPath(void* o, void* keyPath) {
	NSMutableOrderedSet* _Nonnull ret;
	@autoreleasepool {
		ret = [(CBManager*)o mutableOrderedSetValueForKeyPath:keyPath];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
void* _Nullable
CBManager_inst_InverseForRelationshipKey(void* o, void* relationshipKey) {
	NSString* _Nullable ret;
	@autoreleasepool {
		ret = [(CBManager*)o inverseForRelationshipKey:relationshipKey];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
void
CBManager_inst_DidChangeValuesAtIndexes(void* o, NSKeyValueChange changeKind, void* indexes, void* key) {
	@autoreleasepool {
		[(CBManager*)o didChange:changeKind valuesAtIndexes:indexes forKey:key];
	}
}
void
CBManager_inst_DidChangeValuesAtIndexesForKey(void* o, NSKeyValueChange changeKind, void* indexes, void* key) {
	@autoreleasepool {
		[(CBManager*)o didChange:changeKind valuesAtIndexes:indexes forKey:key];
	}
}
void* _Nullable
CBManager_inst_ScriptingProperties(void* o) {
	NSDictionary* _Nullable ret;
	@autoreleasepool {
		ret = [(CBManager*)o scriptingProperties];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
void
CBManager_inst_DoesNotRecognizeSelector(void* o, void* aSelector) {
	@autoreleasepool {
		[(CBManager*)o doesNotRecognizeSelector:aSelector];
	}
}
void* _Nonnull
CBManager_inst_ClassDescription(void* o) {
	NSClassDescription* _Nonnull ret;
	@autoreleasepool {
		ret = [(CBManager*)o classDescription];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
void* _Nonnull
CBManager_inst_MutableOrderedSetValueForKey(void* o, void* key) {
	NSMutableOrderedSet* _Nonnull ret;
	@autoreleasepool {
		ret = [(CBManager*)o mutableOrderedSetValueForKey:key];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
void
CBManager_inst_ObserveValueForKeyPathOfObject(void* o, void* keyPath, void* object, void* change, void* context) {
	@autoreleasepool {
		[(CBManager*)o observeValueForKeyPath:keyPath ofObject:object change:change context:context];
	}
}
void
CBManager_inst_ObserveValueForKeyPathOfObjectChange(void* o, void* keyPath, void* object, void* change, void* context) {
	@autoreleasepool {
		[(CBManager*)o observeValueForKeyPath:keyPath ofObject:object change:change context:context];
	}
}
BOOL
CBManager_inst_ScriptingIsGreaterThan(void* o, void* object) {
	BOOL ret;
	@autoreleasepool {
		ret = [(CBManager*)o scriptingIsGreaterThan:object];
	}
	return ret;

}
void
CBManager_inst_WillChangeValuesAtIndexes(void* o, NSKeyValueChange changeKind, void* indexes, void* key) {
	@autoreleasepool {
		[(CBManager*)o willChange:changeKind valuesAtIndexes:indexes forKey:key];
	}
}
void
CBManager_inst_WillChangeValuesAtIndexesForKey(void* o, NSKeyValueChange changeKind, void* indexes, void* key) {
	@autoreleasepool {
		[(CBManager*)o willChange:changeKind valuesAtIndexes:indexes forKey:key];
	}
}
void* _Nullable
CBManager_inst_IndicesOfObjectsByEvaluatingObjectSpecifier(void* o, void* specifier) {
	NSArray* _Nullable ret;
	@autoreleasepool {
		ret = [(CBManager*)o indicesOfObjectsByEvaluatingObjectSpecifier:specifier];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
BOOL
CBManager_inst_ScriptingIsEqualTo(void* o, void* object) {
	BOOL ret;
	@autoreleasepool {
		ret = [(CBManager*)o scriptingIsEqualTo:object];
	}
	return ret;

}
BOOL
CBManager_inst_IsLessThanOrEqualTo(void* o, void* object) {
	BOOL ret;
	@autoreleasepool {
		ret = [(CBManager*)o isLessThanOrEqualTo:object];
	}
	return ret;

}
BOOL
CBManager_inst_IsEqualTo(void* o, void* object) {
	BOOL ret;
	@autoreleasepool {
		ret = [(CBManager*)o isEqualTo:object];
	}
	return ret;

}
void* _Nullable
CBManager_inst_CopyScriptingValueForKey(void* o, void* value, void* key, void* properties) {
	NSObject* _Nullable ret;
	@autoreleasepool {
		ret = [(CBManager*)o copyScriptingValue:value forKey:key withProperties:properties];
	}
	return ret;

}
void* _Nullable
CBManager_inst_CopyScriptingValueForKeyWithProperties(void* o, void* value, void* key, void* properties) {
	NSObject* _Nullable ret;
	@autoreleasepool {
		ret = [(CBManager*)o copyScriptingValue:value forKey:key withProperties:properties];
	}
	return ret;

}
void
CBManager_inst_SetNilValueForKey(void* o, void* key) {
	@autoreleasepool {
		[(CBManager*)o setNilValueForKey:key];
	}
}
BOOL
CBManager_inst_ScriptingBeginsWith(void* o, void* object) {
	BOOL ret;
	@autoreleasepool {
		ret = [(CBManager*)o scriptingBeginsWith:object];
	}
	return ret;

}
void* _Nullable
CBManager_inst_ScriptingValueForSpecifier(void* o, void* objectSpecifier) {
	NSObject* _Nullable ret;
	@autoreleasepool {
		ret = [(CBManager*)o scriptingValueForSpecifier:objectSpecifier];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
BOOL
CBService_ConformsToProtocol(void* protocol) {
	BOOL ret;
	@autoreleasepool {
		ret = [CBService conformsToProtocol:protocol];
	}
	return ret;

}
BOOL
CBService_ResolveInstanceMethod(void* sel) {
	BOOL ret;
	@autoreleasepool {
		ret = [CBService resolveInstanceMethod:sel];
	}
	return ret;

}
void
CBService_CancelPreviousPerformRequestsWithTarget(void* aTarget) {
	@autoreleasepool {
		[CBService cancelPreviousPerformRequestsWithTarget:aTarget];
	}
}
void
CBService_CancelPreviousPerformRequestsWithTargetSelector(void* aTarget, void* aSelector, void* anArgument) {
	@autoreleasepool {
		[CBService cancelPreviousPerformRequestsWithTarget:aTarget selector:aSelector object:anArgument];
	}
}
void
CBService_CancelPreviousPerformRequestsWithTargetSelectorObject(void* aTarget, void* aSelector, void* anArgument) {
	@autoreleasepool {
		[CBService cancelPreviousPerformRequestsWithTarget:aTarget selector:aSelector object:anArgument];
	}
}
void*
CBService_CopyWithZone(void* zone) {
	NSObject* ret;
	@autoreleasepool {
		ret = [CBService copyWithZone:zone];
	}
	return ret;

}
NSInteger
CBService_Version() {
	NSInteger ret;
	@autoreleasepool {
		ret = [CBService version];
	}
	return ret;

}
void* _Nonnull
CBService_ClassFallbacksForKeyedArchiver() {
	NSArray* _Nonnull ret;
	@autoreleasepool {
		ret = [CBService classFallbacksForKeyedArchiver];
	}
	return ret;

}
void
CBService_SetVersion(NSInteger aVersion) {
	@autoreleasepool {
		[CBService setVersion:aVersion];
	}
}
void*
CBService_New() {
	CBService* ret;
	@autoreleasepool {
		NSLog(@"CBService new");
		//ret = [CBService new];
	}
	return ret;

}
BOOL
CBService_ResolveClassMethod(void* sel) {
	BOOL ret;
	@autoreleasepool {
		ret = [CBService resolveClassMethod:sel];
	}
	return ret;

}
void*
CBService_Superclass() {
	Class ret;
	@autoreleasepool {
		ret = [CBService superclass];
	}
	return ret;

}
BOOL
CBService_InstancesRespondToSelector(void* aSelector) {
	BOOL ret;
	@autoreleasepool {
		ret = [CBService instancesRespondToSelector:aSelector];
	}
	return ret;

}
NSUInteger
CBService_Hash() {
	NSUInteger ret;
	@autoreleasepool {
		ret = [CBService hash];
	}
	return ret;

}
void* _Nonnull
CBService_KeyPathsForValuesAffectingValueForKey(void* key) {
	NSSet* _Nonnull ret;
	@autoreleasepool {
		ret = [CBService keyPathsForValuesAffectingValueForKey:key];
	}
	return ret;

}
void* _Nonnull
CBService_ClassForKeyedUnarchiver() {
	Class _Nonnull ret;
	@autoreleasepool {
		ret = [CBService classForKeyedUnarchiver];
	}
	return ret;

}
void*
CBService_Alloc() {
	return [CBService alloc];
}
void*
CBService_DebugDescription() {
	NSString* ret;
	@autoreleasepool {
		ret = [CBService debugDescription];
	}
	return ret;

}
void*
CBService_MutableCopyWithZone(void* zone) {
	NSObject* ret;
	@autoreleasepool {
		ret = [CBService mutableCopyWithZone:zone];
	}
	return ret;

}
void*
CBService_InstanceMethodSignatureForSelector(void* aSelector) {
	NSMethodSignature* ret;
	@autoreleasepool {
		ret = [CBService instanceMethodSignatureForSelector:aSelector];
	}
	return ret;

}
void*
CBService_Class() {
	Class ret;
	@autoreleasepool {
		ret = [CBService class];
	}
	return ret;

}
BOOL
CBService_AutomaticallyNotifiesObserversForKey(void* key) {
	BOOL ret;
	@autoreleasepool {
		ret = [CBService automaticallyNotifiesObserversForKey:key];
	}
	return ret;

}
BOOL
CBService_IsSubclassOfClass(void* aClass) {
	BOOL ret;
	@autoreleasepool {
		ret = [CBService isSubclassOfClass:aClass];
	}
	return ret;

}
void*
CBService_Description() {
	NSString* ret;
	@autoreleasepool {
		ret = [CBService description];
	}
	return ret;

}
void*
CBService_AllocWithZone(void* zone) {
	return [CBService allocWithZone:zone];
}
BOOL
CBService_AccessInstanceVariablesDirectly() {
	BOOL ret;
	@autoreleasepool {
		ret = [CBService accessInstanceVariablesDirectly];
	}
	return ret;

}
void
CBService_Load() {
	@autoreleasepool {
		[CBService load];
	}
}
void
CBService_inst_RemoveObserverForKeyPath(void* o, void* observer, void* keyPath) {
	@autoreleasepool {
		[(CBService*)o removeObserver:observer forKeyPath:keyPath];
	}
}
void
CBService_inst_RemoveObserverForKeyPathContext(void* o, void* observer, void* keyPath, void* context) {
	@autoreleasepool {
		[(CBService*)o removeObserver:observer forKeyPath:keyPath context:context];
	}
}
void
CBService_inst_InsertValueInPropertyWithKey(void* o, void* value, void* key) {
	@autoreleasepool {
		[(CBService*)o insertValue:value inPropertyWithKey:key];
	}
}
void
CBService_inst_InsertValueAtIndex(void* o, void* value, NSUInteger index, void* key) {
	@autoreleasepool {
		[(CBService*)o insertValue:value atIndex:index inPropertyWithKey:key];
	}
}
void
CBService_inst_InsertValueAtIndexInPropertyWithKey(void* o, void* value, NSUInteger index, void* key) {
	@autoreleasepool {
		[(CBService*)o insertValue:value atIndex:index inPropertyWithKey:key];
	}
}
void* _Nullable
CBService_inst_ValueForUndefinedKey(void* o, void* key) {
	NSObject* _Nullable ret;
	@autoreleasepool {
		ret = [(CBService*)o valueForUndefinedKey:key];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
BOOL
CBService_inst_IsLessThan(void* o, void* object) {
	BOOL ret;
	@autoreleasepool {
		ret = [(CBService*)o isLessThan:object];
	}
	return ret;

}
void* _Nonnull
CBService_inst_MutableSetValueForKey(void* o, void* key) {
	NSMutableSet* _Nonnull ret;
	@autoreleasepool {
		ret = [(CBService*)o mutableSetValueForKey:key];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
void* _Nullable
CBService_inst_IndicesOfObjectsByEvaluatingObjectSpecifier(void* o, void* specifier) {
	NSArray* _Nullable ret;
	@autoreleasepool {
		ret = [(CBService*)o indicesOfObjectsByEvaluatingObjectSpecifier:specifier];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
void* _Nullable
CBService_inst_AwakeAfterUsingCoder(void* o, void* coder) {
	NSObject* _Nullable ret;
	@autoreleasepool {
		ret = [(CBService*)o awakeAfterUsingCoder:coder];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
void*
CBService_inst_ObservationInfo(void* o) {
	void* ret;
	@autoreleasepool {
		ret = [(CBService*)o observationInfo];
	}
	return ret;

}
BOOL
CBService_inst_ValidateValueForKey(void* o, void** ioValue, void* inKey, void** outError) {
	BOOL ret;
	@autoreleasepool {
		ret = [(CBService*)o validateValue:(id _Nullable* _Nonnull)ioValue forKey:inKey error:(NSError* _Nullable* _Nullable)outError];
		for(int i=0;i<1;i++) {
			if(ioValue[i] == 0) { break; }
			[(id)ioValue[i] retain];
		}
	
	
		for(int i=0;i<1;i++) {
			if(outError[i] == 0) { break; }
			[(id)outError[i] retain];
		}
	
	}
	return ret;

}
BOOL
CBService_inst_ValidateValueForKeyPath(void* o, void** ioValue, void* inKeyPath, void** outError) {
	BOOL ret;
	@autoreleasepool {
		ret = [(CBService*)o validateValue:(id _Nullable* _Nonnull)ioValue forKeyPath:inKeyPath error:(NSError* _Nullable* _Nullable)outError];
		for(int i=0;i<1;i++) {
			if(ioValue[i] == 0) { break; }
			[(id)ioValue[i] retain];
		}
	
	
		for(int i=0;i<1;i++) {
			if(outError[i] == 0) { break; }
			[(id)outError[i] retain];
		}
	
	}
	return ret;

}
BOOL
CBService_inst_ValidateValueForKeyError(void* o, void** ioValue, void* inKey, void** outError) {
	BOOL ret;
	@autoreleasepool {
		ret = [(CBService*)o validateValue:(id _Nullable* _Nonnull)ioValue forKey:inKey error:(NSError* _Nullable* _Nullable)outError];
		for(int i=0;i<1;i++) {
			if(ioValue[i] == 0) { break; }
			[(id)ioValue[i] retain];
		}
	
	
		for(int i=0;i<1;i++) {
			if(outError[i] == 0) { break; }
			[(id)outError[i] retain];
		}
	
	}
	return ret;

}
BOOL
CBService_inst_ValidateValueForKeyPathError(void* o, void** ioValue, void* inKeyPath, void** outError) {
	BOOL ret;
	@autoreleasepool {
		ret = [(CBService*)o validateValue:(id _Nullable* _Nonnull)ioValue forKeyPath:inKeyPath error:(NSError* _Nullable* _Nullable)outError];
		for(int i=0;i<1;i++) {
			if(ioValue[i] == 0) { break; }
			[(id)ioValue[i] retain];
		}
	
	
		for(int i=0;i<1;i++) {
			if(outError[i] == 0) { break; }
			[(id)outError[i] retain];
		}
	
	}
	return ret;

}
void
CBService_inst_PerformSelectorWithObject(void* o, void* aSelector, void* anArgument, NSTimeInterval delay) {
	@autoreleasepool {
		[(CBService*)o performSelector:aSelector withObject:anArgument afterDelay:delay];
	}
}
void
CBService_inst_PerformSelectorWithObjectAfterDelay(void* o, void* aSelector, void* anArgument, NSTimeInterval delay) {
	@autoreleasepool {
		[(CBService*)o performSelector:aSelector withObject:anArgument afterDelay:delay];
	}
}
void
CBService_inst_PerformSelectorWithObjectAfterDelayInModes(void* o, void* aSelector, void* anArgument, NSTimeInterval delay, void* modes) {
	@autoreleasepool {
		[(CBService*)o performSelector:aSelector withObject:anArgument afterDelay:delay inModes:modes];
	}
}
void
CBService_inst_PerformSelectorOnThread(void* o, void* aSelector, void* thr, void* arg, BOOL wait) {
	@autoreleasepool {
		[(CBService*)o performSelector:aSelector onThread:thr withObject:arg waitUntilDone:wait];
	}
}
void
CBService_inst_PerformSelectorOnThreadWithObject(void* o, void* aSelector, void* thr, void* arg, BOOL wait) {
	@autoreleasepool {
		[(CBService*)o performSelector:aSelector onThread:thr withObject:arg waitUntilDone:wait];
	}
}
void
CBService_inst_PerformSelectorOnThreadWithObjectWaitUntilDone(void* o, void* aSelector, void* thr, void* arg, BOOL wait, void* array) {
	@autoreleasepool {
		[(CBService*)o performSelector:aSelector onThread:thr withObject:arg waitUntilDone:wait modes:array];
	}
}
void
CBService_inst_PerformSelectorOnThreadWithObjectWaitUntilDoneModes(void* o, void* aSelector, void* thr, void* arg, BOOL wait, void* array) {
	@autoreleasepool {
		[(CBService*)o performSelector:aSelector onThread:thr withObject:arg waitUntilDone:wait modes:array];
	}
}
void
CBService_inst_PerformSelectorOnMainThreadWithObject(void* o, void* aSelector, void* arg, BOOL wait) {
	@autoreleasepool {
		[(CBService*)o performSelectorOnMainThread:aSelector withObject:arg waitUntilDone:wait];
	}
}
void
CBService_inst_PerformSelectorOnMainThreadWithObjectWaitUntilDone(void* o, void* aSelector, void* arg, BOOL wait) {
	@autoreleasepool {
		[(CBService*)o performSelectorOnMainThread:aSelector withObject:arg waitUntilDone:wait];
	}
}
void
CBService_inst_PerformSelectorOnMainThreadWithObjectWaitUntilDoneModes(void* o, void* aSelector, void* arg, BOOL wait, void* array) {
	@autoreleasepool {
		[(CBService*)o performSelectorOnMainThread:aSelector withObject:arg waitUntilDone:wait modes:array];
	}
}
void
CBService_inst_ReplaceValueAtIndexInPropertyWithKey(void* o, NSUInteger index, void* key, void* value) {
	@autoreleasepool {
		[(CBService*)o replaceValueAtIndex:index inPropertyWithKey:key withValue:value];
	}
}
void
CBService_inst_ReplaceValueAtIndexInPropertyWithKeyWithValue(void* o, NSUInteger index, void* key, void* value) {
	@autoreleasepool {
		[(CBService*)o replaceValueAtIndex:index inPropertyWithKey:key withValue:value];
	}
}
void
CBService_inst_SetNilValueForKey(void* o, void* key) {
	@autoreleasepool {
		[(CBService*)o setNilValueForKey:key];
	}
}
void* _Nullable
CBService_inst_Characteristics(void* o) {
	NSArray* _Nullable ret;
	@autoreleasepool {
		ret = [(CBService*)o characteristics];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
void* _Nonnull
CBService_inst_UUID(void* o) {
	CBUUID* _Nonnull ret;
	@autoreleasepool {
		ret = [(CBService*)o UUID];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
void* _Nullable
CBService_inst_ScriptingValueForSpecifier(void* o, void* objectSpecifier) {
	NSObject* _Nullable ret;
	@autoreleasepool {
		ret = [(CBService*)o scriptingValueForSpecifier:objectSpecifier];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
BOOL
CBService_inst_ScriptingContains(void* o, void* object) {
	BOOL ret;
	@autoreleasepool {
		ret = [(CBService*)o scriptingContains:object];
	}
	return ret;

}
void* _Nonnull
CBService_inst_MutableSetValueForKeyPath(void* o, void* keyPath) {
	NSMutableSet* _Nonnull ret;
	@autoreleasepool {
		ret = [(CBService*)o mutableSetValueForKeyPath:keyPath];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
void* _Nonnull
CBService_inst_MutableOrderedSetValueForKey(void* o, void* key) {
	NSMutableOrderedSet* _Nonnull ret;
	@autoreleasepool {
		ret = [(CBService*)o mutableOrderedSetValueForKey:key];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
void* _Nullable
CBService_inst_NewScriptingObjectOfClassForValueForKey(void* o, void* objectClass, void* key, void* contentsValue, void* properties) {
	NSObject* _Nullable ret;
	@autoreleasepool {
		ret = [(CBService*)o newScriptingObjectOfClass:objectClass forValueForKey:key withContentsValue:contentsValue properties:properties];
	}
	return ret;

}
void* _Nullable
CBService_inst_NewScriptingObjectOfClassForValueForKeyWithContentsValue(void* o, void* objectClass, void* key, void* contentsValue, void* properties) {
	NSObject* _Nullable ret;
	@autoreleasepool {
		ret = [(CBService*)o newScriptingObjectOfClass:objectClass forValueForKey:key withContentsValue:contentsValue properties:properties];
	}
	return ret;

}
BOOL
CBService_inst_DoesContain(void* o, void* object) {
	BOOL ret;
	@autoreleasepool {
		ret = [(CBService*)o doesContain:object];
	}
	return ret;

}
void* _Nullable
CBService_inst_IncludedServices(void* o) {
	NSArray* _Nullable ret;
	@autoreleasepool {
		ret = [(CBService*)o includedServices];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
void*
CBService_inst_Copy(void* o) {
	NSObject* ret;
	@autoreleasepool {
		ret = [(CBService*)o copy];
	}
	return ret;

}
void* _Nullable
CBService_inst_ValueWithUniqueIDInPropertyWithKey(void* o, void* uniqueID, void* key) {
	NSObject* _Nullable ret;
	@autoreleasepool {
		ret = [(CBService*)o valueWithUniqueID:uniqueID inPropertyWithKey:key];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
void* _Nonnull
CBService_inst_MutableOrderedSetValueForKeyPath(void* o, void* keyPath) {
	NSMutableOrderedSet* _Nonnull ret;
	@autoreleasepool {
		ret = [(CBService*)o mutableOrderedSetValueForKeyPath:keyPath];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
void
CBService_inst_SetValueForKey(void* o, void* value, void* key) {
	@autoreleasepool {
		[(CBService*)o setValue:value forKey:key];
	}
}
void
CBService_inst_SetValueForKeyPath(void* o, void* value, void* keyPath) {
	@autoreleasepool {
		[(CBService*)o setValue:value forKeyPath:keyPath];
	}
}
void
CBService_inst_SetValueForUndefinedKey(void* o, void* value, void* key) {
	@autoreleasepool {
		[(CBService*)o setValue:value forUndefinedKey:key];
	}
}
void
CBService_inst_RemoveValueAtIndexFromPropertyWithKey(void* o, NSUInteger index, void* key) {
	@autoreleasepool {
		[(CBService*)o removeValueAtIndex:index fromPropertyWithKey:key];
	}
}
BOOL
CBService_inst_IsGreaterThan(void* o, void* object) {
	BOOL ret;
	@autoreleasepool {
		ret = [(CBService*)o isGreaterThan:object];
	}
	return ret;

}
BOOL
CBService_inst_IsLike(void* o, void* object) {
	BOOL ret;
	@autoreleasepool {
		ret = [(CBService*)o isLike:object];
	}
	return ret;

}
BOOL
CBService_inst_IsPrimary(void* o) {
	BOOL ret;
	@autoreleasepool {
		ret = [(CBService*)o isPrimary];
	}
	return ret;

}
void* _Nonnull
CBService_inst_AutoContentAccessingProxy(void* o) {
	NSObject* _Nonnull ret;
	@autoreleasepool {
		ret = [(CBService*)o autoContentAccessingProxy];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
void* _Nullable
CBService_inst_ObjectSpecifier(void* o) {
	NSScriptObjectSpecifier* _Nullable ret;
	@autoreleasepool {
		ret = [(CBService*)o objectSpecifier];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
void* _Nonnull
CBService_inst_ToOneRelationshipKeys(void* o) {
	NSArray* _Nonnull ret;
	@autoreleasepool {
		ret = [(CBService*)o toOneRelationshipKeys];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
void* _Nullable
CBService_inst_ScriptingProperties(void* o) {
	NSDictionary* _Nullable ret;
	@autoreleasepool {
		ret = [(CBService*)o scriptingProperties];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
void* _Nullable
CBService_inst_ClassForArchiver(void* o) {
	Class _Nullable ret;
	@autoreleasepool {
		ret = [(CBService*)o classForArchiver];
	}
	return ret;

}
void* _Nonnull
CBService_inst_AttributeKeys(void* o) {
	NSArray* _Nonnull ret;
	@autoreleasepool {
		ret = [(CBService*)o attributeKeys];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
BOOL
CBService_inst_ScriptingIsEqualTo(void* o, void* object) {
	BOOL ret;
	@autoreleasepool {
		ret = [(CBService*)o scriptingIsEqualTo:object];
	}
	return ret;

}
void
CBService_inst_DoesNotRecognizeSelector(void* o, void* aSelector) {
	@autoreleasepool {
		[(CBService*)o doesNotRecognizeSelector:aSelector];
	}
}
BOOL
CBService_inst_ScriptingIsGreaterThan(void* o, void* object) {
	BOOL ret;
	@autoreleasepool {
		ret = [(CBService*)o scriptingIsGreaterThan:object];
	}
	return ret;

}
void
CBService_inst_SetScriptingProperties(void* o, void* scriptingProperties) {
	@autoreleasepool {
		[(CBService*)o setScriptingProperties:scriptingProperties];
	}
}
void
CBService_inst_ForwardInvocation(void* o, void* anInvocation) {
	@autoreleasepool {
		[(CBService*)o forwardInvocation:anInvocation];
	}
}
void
CBService_inst_DidChangeValuesAtIndexes(void* o, NSKeyValueChange changeKind, void* indexes, void* key) {
	@autoreleasepool {
		[(CBService*)o didChange:changeKind valuesAtIndexes:indexes forKey:key];
	}
}
void
CBService_inst_DidChangeValuesAtIndexesForKey(void* o, NSKeyValueChange changeKind, void* indexes, void* key) {
	@autoreleasepool {
		[(CBService*)o didChange:changeKind valuesAtIndexes:indexes forKey:key];
	}
}
void* _Nonnull
CBService_inst_MutableArrayValueForKeyPath(void* o, void* keyPath) {
	NSMutableArray* _Nonnull ret;
	@autoreleasepool {
		ret = [(CBService*)o mutableArrayValueForKeyPath:keyPath];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
void* _Nullable
CBService_inst_ReplacementObjectForCoder(void* o, void* coder) {
	NSObject* _Nullable ret;
	@autoreleasepool {
		ret = [(CBService*)o replacementObjectForCoder:coder];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
void
CBService_inst_DidChangeValueForKey(void* o, void* key) {
	@autoreleasepool {
		[(CBService*)o didChangeValueForKey:key];
	}
}
void
CBService_inst_DidChangeValueForKeyWithSetMutation(void* o, void* key, NSKeyValueSetMutationKind mutationKind, void* objects) {
	@autoreleasepool {
		[(CBService*)o didChangeValueForKey:key withSetMutation:mutationKind usingObjects:objects];
	}
}
void
CBService_inst_DidChangeValueForKeyWithSetMutationUsingObjects(void* o, void* key, NSKeyValueSetMutationKind mutationKind, void* objects) {
	@autoreleasepool {
		[(CBService*)o didChangeValueForKey:key withSetMutation:mutationKind usingObjects:objects];
	}
}
void* _Nullable
CBService_inst_ValueForKeyPath(void* o, void* keyPath) {
	NSObject* _Nullable ret;
	@autoreleasepool {
		ret = [(CBService*)o valueForKeyPath:keyPath];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
BOOL
CBService_inst_ScriptingBeginsWith(void* o, void* object) {
	BOOL ret;
	@autoreleasepool {
		ret = [(CBService*)o scriptingBeginsWith:object];
	}
	return ret;

}
void* _Nonnull
CBService_inst_ClassDescription(void* o) {
	NSClassDescription* _Nonnull ret;
	@autoreleasepool {
		ret = [(CBService*)o classDescription];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
void
CBService_inst_WillChangeValuesAtIndexes(void* o, NSKeyValueChange changeKind, void* indexes, void* key) {
	@autoreleasepool {
		[(CBService*)o willChange:changeKind valuesAtIndexes:indexes forKey:key];
	}
}
void
CBService_inst_WillChangeValuesAtIndexesForKey(void* o, NSKeyValueChange changeKind, void* indexes, void* key) {
	@autoreleasepool {
		[(CBService*)o willChange:changeKind valuesAtIndexes:indexes forKey:key];
	}
}
void
CBService_inst_ObserveValueForKeyPathOfObject(void* o, void* keyPath, void* object, void* change, void* context) {
	@autoreleasepool {
		[(CBService*)o observeValueForKeyPath:keyPath ofObject:object change:change context:context];
	}
}
void
CBService_inst_ObserveValueForKeyPathOfObjectChange(void* o, void* keyPath, void* object, void* change, void* context) {
	@autoreleasepool {
		[(CBService*)o observeValueForKeyPath:keyPath ofObject:object change:change context:context];
	}
}
void
CBService_inst_WillChangeValueForKey(void* o, void* key) {
	@autoreleasepool {
		[(CBService*)o willChangeValueForKey:key];
	}
}
void
CBService_inst_WillChangeValueForKeyWithSetMutation(void* o, void* key, NSKeyValueSetMutationKind mutationKind, void* objects) {
	@autoreleasepool {
		[(CBService*)o willChangeValueForKey:key withSetMutation:mutationKind usingObjects:objects];
	}
}
void
CBService_inst_WillChangeValueForKeyWithSetMutationUsingObjects(void* o, void* key, NSKeyValueSetMutationKind mutationKind, void* objects) {
	@autoreleasepool {
		[(CBService*)o willChangeValueForKey:key withSetMutation:mutationKind usingObjects:objects];
	}
}
void
CBService_inst_AddObserverForKeyPath(void* o, void* observer, void* keyPath, NSKeyValueObservingOptions options, void* context) {
	@autoreleasepool {
		[(CBService*)o addObserver:observer forKeyPath:keyPath options:options context:context];
	}
}
void
CBService_inst_AddObserverForKeyPathOptions(void* o, void* observer, void* keyPath, NSKeyValueObservingOptions options, void* context) {
	@autoreleasepool {
		[(CBService*)o addObserver:observer forKeyPath:keyPath options:options context:context];
	}
}
void* _Nullable
CBService_inst_ValueWithNameInPropertyWithKey(void* o, void* name, void* key) {
	NSObject* _Nullable ret;
	@autoreleasepool {
		ret = [(CBService*)o valueWithName:name inPropertyWithKey:key];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
void
CBService_inst_SetValuesForKeysWithDictionary(void* o, void* keyedValues) {
	@autoreleasepool {
		[(CBService*)o setValuesForKeysWithDictionary:keyedValues];
	}
}
void* _Nullable
CBService_inst_ValueAtIndexInPropertyWithKey(void* o, NSUInteger index, void* key) {
	NSObject* _Nullable ret;
	@autoreleasepool {
		ret = [(CBService*)o valueAtIndex:index inPropertyWithKey:key];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
BOOL
CBService_inst_ScriptingIsLessThanOrEqualTo(void* o, void* object) {
	BOOL ret;
	@autoreleasepool {
		ret = [(CBService*)o scriptingIsLessThanOrEqualTo:object];
	}
	return ret;

}
FourCharCode
CBService_inst_ClassCode(void* o) {
	FourCharCode ret;
	@autoreleasepool {
		ret = [(CBService*)o classCode];
	}
	return ret;

}
void* _Nonnull
CBService_inst_DictionaryWithValuesForKeys(void* o, void* keys) {
	NSDictionary* _Nonnull ret;
	@autoreleasepool {
		ret = [(CBService*)o dictionaryWithValuesForKeys:keys];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
void*
CBService_inst_MethodSignatureForSelector(void* o, void* aSelector) {
	NSMethodSignature* ret;
	@autoreleasepool {
		ret = [(CBService*)o methodSignatureForSelector:aSelector];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
void* _Nonnull
CBService_inst_MutableArrayValueForKey(void* o, void* key) {
	NSMutableArray* _Nonnull ret;
	@autoreleasepool {
		ret = [(CBService*)o mutableArrayValueForKey:key];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
void* _Nonnull
CBService_inst_ToManyRelationshipKeys(void* o) {
	NSArray* _Nonnull ret;
	@autoreleasepool {
		ret = [(CBService*)o toManyRelationshipKeys];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
void* _Nonnull
CBService_inst_ClassName(void* o) {
	NSString* _Nonnull ret;
	@autoreleasepool {
		ret = [(CBService*)o className];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
void*
CBService_inst_ForwardingTargetForSelector(void* o, void* aSelector) {
	NSObject* ret;
	@autoreleasepool {
		ret = [(CBService*)o forwardingTargetForSelector:aSelector];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
void* _Nullable
CBService_inst_ReplacementObjectForKeyedArchiver(void* o, void* archiver) {
	NSObject* _Nullable ret;
	@autoreleasepool {
		ret = [(CBService*)o replacementObjectForKeyedArchiver:archiver];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
BOOL
CBService_inst_AttemptRecoveryFromErrorOptionIndex(void* o, void* error, NSUInteger recoveryOptionIndex) {
	BOOL ret;
	@autoreleasepool {
		ret = [(CBService*)o attemptRecoveryFromError:error optionIndex:recoveryOptionIndex];
	}
	return ret;

}
void
CBService_inst_AttemptRecoveryFromErrorOptionIndexDelegate(void* o, void* error, NSUInteger recoveryOptionIndex, void* delegate, void* didRecoverSelector, void* contextInfo) {
	@autoreleasepool {
		[(CBService*)o attemptRecoveryFromError:error optionIndex:recoveryOptionIndex delegate:delegate didRecoverSelector:didRecoverSelector contextInfo:contextInfo];
	}
}
void
CBService_inst_AttemptRecoveryFromErrorOptionIndexDelegateDidRecoverSelector(void* o, void* error, NSUInteger recoveryOptionIndex, void* delegate, void* didRecoverSelector, void* contextInfo) {
	@autoreleasepool {
		[(CBService*)o attemptRecoveryFromError:error optionIndex:recoveryOptionIndex delegate:delegate didRecoverSelector:didRecoverSelector contextInfo:contextInfo];
	}
}
BOOL
CBService_inst_IsGreaterThanOrEqualTo(void* o, void* object) {
	BOOL ret;
	@autoreleasepool {
		ret = [(CBService*)o isGreaterThanOrEqualTo:object];
	}
	return ret;

}
void
CBService_inst_PerformSelectorInBackgroundWithObject(void* o, void* aSelector, void* arg) {
	@autoreleasepool {
		[(CBService*)o performSelectorInBackground:aSelector withObject:arg];
	}
}
void* _Nonnull
CBService_inst_Peripheral(void* o) {
	CBPeripheral* _Nonnull ret;
	@autoreleasepool {
		ret = [(CBService*)o peripheral];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
BOOL
CBService_inst_ScriptingIsGreaterThanOrEqualTo(void* o, void* object) {
	BOOL ret;
	@autoreleasepool {
		ret = [(CBService*)o scriptingIsGreaterThanOrEqualTo:object];
	}
	return ret;

}
BOOL
CBService_inst_IsLessThanOrEqualTo(void* o, void* object) {
	BOOL ret;
	@autoreleasepool {
		ret = [(CBService*)o isLessThanOrEqualTo:object];
	}
	return ret;

}
void* _Nullable
CBService_inst_CopyScriptingValueForKey(void* o, void* value, void* key, void* properties) {
	NSObject* _Nullable ret;
	@autoreleasepool {
		ret = [(CBService*)o copyScriptingValue:value forKey:key withProperties:properties];
	}
	return ret;

}
void* _Nullable
CBService_inst_CopyScriptingValueForKeyWithProperties(void* o, void* value, void* key, void* properties) {
	NSObject* _Nullable ret;
	@autoreleasepool {
		ret = [(CBService*)o copyScriptingValue:value forKey:key withProperties:properties];
	}
	return ret;

}
void* _Nullable
CBService_inst_ClassForKeyedArchiver(void* o) {
	Class _Nullable ret;
	@autoreleasepool {
		ret = [(CBService*)o classForKeyedArchiver];
	}
	return ret;

}
void
CBService_inst_SetObservationInfo(void* o, void* observationInfo) {
	@autoreleasepool {
		[(CBService*)o setObservationInfo:observationInfo];
	}
}
BOOL
CBService_inst_IsNotEqualTo(void* o, void* object) {
	BOOL ret;
	@autoreleasepool {
		ret = [(CBService*)o isNotEqualTo:object];
	}
	return ret;

}
void
CBService_inst_Dealloc(void* o) {
	@autoreleasepool {
		[(CBService*)o dealloc];
	}
}
BOOL
CBService_inst_ScriptingEndsWith(void* o, void* object) {
	BOOL ret;
	@autoreleasepool {
		ret = [(CBService*)o scriptingEndsWith:object];
	}
	return ret;

}
BOOL
CBService_inst_IsEqualTo(void* o, void* object) {
	BOOL ret;
	@autoreleasepool {
		ret = [(CBService*)o isEqualTo:object];
	}
	return ret;

}
void* _Nonnull
CBService_inst_ClassForCoder(void* o) {
	Class _Nonnull ret;
	@autoreleasepool {
		ret = [(CBService*)o classForCoder];
	}
	return ret;

}
void* _Nullable
CBService_inst_InverseForRelationshipKey(void* o, void* relationshipKey) {
	NSString* _Nullable ret;
	@autoreleasepool {
		ret = [(CBService*)o inverseForRelationshipKey:relationshipKey];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
void* _Nullable
CBService_inst_ValueForKey(void* o, void* key) {
	NSObject* _Nullable ret;
	@autoreleasepool {
		ret = [(CBService*)o valueForKey:key];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
BOOL
CBService_inst_IsCaseInsensitiveLike(void* o, void* object) {
	BOOL ret;
	@autoreleasepool {
		ret = [(CBService*)o isCaseInsensitiveLike:object];
	}
	return ret;

}
void*
CBService_inst_MutableCopy(void* o) {
	NSObject* ret;
	@autoreleasepool {
		ret = [(CBService*)o mutableCopy];
	}
	return ret;

}
BOOL
CBService_inst_ScriptingIsLessThan(void* o, void* object) {
	BOOL ret;
	@autoreleasepool {
		ret = [(CBService*)o scriptingIsLessThan:object];
	}
	return ret;

}
void* _Nullable
CBService_inst_CoerceValueForKey(void* o, void* value, void* key) {
	NSObject* _Nullable ret;
	@autoreleasepool {
		ret = [(CBService*)o coerceValue:value forKey:key];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
BOOL
CBAttribute_AutomaticallyNotifiesObserversForKey(void* key) {
	BOOL ret;
	@autoreleasepool {
		ret = [CBAttribute automaticallyNotifiesObserversForKey:key];
	}
	return ret;

}
BOOL
CBAttribute_ResolveClassMethod(void* sel) {
	BOOL ret;
	@autoreleasepool {
		ret = [CBAttribute resolveClassMethod:sel];
	}
	return ret;

}
void*
CBAttribute_DebugDescription() {
	NSString* ret;
	@autoreleasepool {
		ret = [CBAttribute debugDescription];
	}
	return ret;

}
void*
CBAttribute_AllocWithZone(void* zone) {
	return [CBAttribute allocWithZone:zone];
}
BOOL
CBAttribute_AccessInstanceVariablesDirectly() {
	BOOL ret;
	@autoreleasepool {
		ret = [CBAttribute accessInstanceVariablesDirectly];
	}
	return ret;

}
void
CBAttribute_SetVersion(NSInteger aVersion) {
	@autoreleasepool {
		[CBAttribute setVersion:aVersion];
	}
}
NSUInteger
CBAttribute_Hash() {
	NSUInteger ret;
	@autoreleasepool {
		ret = [CBAttribute hash];
	}
	return ret;

}
void*
CBAttribute_Alloc() {
	return [CBAttribute alloc];
}
void*
CBAttribute_CopyWithZone(void* zone) {
	NSObject* ret;
	@autoreleasepool {
		ret = [CBAttribute copyWithZone:zone];
	}
	return ret;

}
void*
CBAttribute_Description() {
	NSString* ret;
	@autoreleasepool {
		ret = [CBAttribute description];
	}
	return ret;

}
BOOL
CBAttribute_InstancesRespondToSelector(void* aSelector) {
	BOOL ret;
	@autoreleasepool {
		ret = [CBAttribute instancesRespondToSelector:aSelector];
	}
	return ret;

}
void* _Nonnull
CBAttribute_KeyPathsForValuesAffectingValueForKey(void* key) {
	NSSet* _Nonnull ret;
	@autoreleasepool {
		ret = [CBAttribute keyPathsForValuesAffectingValueForKey:key];
	}
	return ret;

}
void*
CBAttribute_New() {
	CBAttribute* ret;
	@autoreleasepool {
		NSLog(@"CBAttribute new");
		//ret = [CBAttribute new];
	}
	return ret;

}
BOOL
CBAttribute_ConformsToProtocol(void* protocol) {
	BOOL ret;
	@autoreleasepool {
		ret = [CBAttribute conformsToProtocol:protocol];
	}
	return ret;

}
BOOL
CBAttribute_ResolveInstanceMethod(void* sel) {
	BOOL ret;
	@autoreleasepool {
		ret = [CBAttribute resolveInstanceMethod:sel];
	}
	return ret;

}
BOOL
CBAttribute_IsSubclassOfClass(void* aClass) {
	BOOL ret;
	@autoreleasepool {
		ret = [CBAttribute isSubclassOfClass:aClass];
	}
	return ret;

}
void
CBAttribute_CancelPreviousPerformRequestsWithTarget(void* aTarget) {
	@autoreleasepool {
		[CBAttribute cancelPreviousPerformRequestsWithTarget:aTarget];
	}
}
void
CBAttribute_CancelPreviousPerformRequestsWithTargetSelector(void* aTarget, void* aSelector, void* anArgument) {
	@autoreleasepool {
		[CBAttribute cancelPreviousPerformRequestsWithTarget:aTarget selector:aSelector object:anArgument];
	}
}
void
CBAttribute_CancelPreviousPerformRequestsWithTargetSelectorObject(void* aTarget, void* aSelector, void* anArgument) {
	@autoreleasepool {
		[CBAttribute cancelPreviousPerformRequestsWithTarget:aTarget selector:aSelector object:anArgument];
	}
}
void*
CBAttribute_Class() {
	Class ret;
	@autoreleasepool {
		ret = [CBAttribute class];
	}
	return ret;

}
void*
CBAttribute_Superclass() {
	Class ret;
	@autoreleasepool {
		ret = [CBAttribute superclass];
	}
	return ret;

}
void
CBAttribute_Load() {
	@autoreleasepool {
		[CBAttribute load];
	}
}
NSInteger
CBAttribute_Version() {
	NSInteger ret;
	@autoreleasepool {
		ret = [CBAttribute version];
	}
	return ret;

}
void*
CBAttribute_MutableCopyWithZone(void* zone) {
	NSObject* ret;
	@autoreleasepool {
		ret = [CBAttribute mutableCopyWithZone:zone];
	}
	return ret;

}
void* _Nonnull
CBAttribute_ClassFallbacksForKeyedArchiver() {
	NSArray* _Nonnull ret;
	@autoreleasepool {
		ret = [CBAttribute classFallbacksForKeyedArchiver];
	}
	return ret;

}
void*
CBAttribute_InstanceMethodSignatureForSelector(void* aSelector) {
	NSMethodSignature* ret;
	@autoreleasepool {
		ret = [CBAttribute instanceMethodSignatureForSelector:aSelector];
	}
	return ret;

}
void* _Nonnull
CBAttribute_ClassForKeyedUnarchiver() {
	Class _Nonnull ret;
	@autoreleasepool {
		ret = [CBAttribute classForKeyedUnarchiver];
	}
	return ret;

}
void* _Nullable
CBAttribute_inst_ScriptingValueForSpecifier(void* o, void* objectSpecifier) {
	NSObject* _Nullable ret;
	@autoreleasepool {
		ret = [(CBAttribute*)o scriptingValueForSpecifier:objectSpecifier];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
void
CBAttribute_inst_Dealloc(void* o) {
	@autoreleasepool {
		[(CBAttribute*)o dealloc];
	}
}
void* _Nonnull
CBAttribute_inst_ClassName(void* o) {
	NSString* _Nonnull ret;
	@autoreleasepool {
		ret = [(CBAttribute*)o className];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
BOOL
CBAttribute_inst_ScriptingContains(void* o, void* object) {
	BOOL ret;
	@autoreleasepool {
		ret = [(CBAttribute*)o scriptingContains:object];
	}
	return ret;

}
void
CBAttribute_inst_ReplaceValueAtIndexInPropertyWithKey(void* o, NSUInteger index, void* key, void* value) {
	@autoreleasepool {
		[(CBAttribute*)o replaceValueAtIndex:index inPropertyWithKey:key withValue:value];
	}
}
void
CBAttribute_inst_ReplaceValueAtIndexInPropertyWithKeyWithValue(void* o, NSUInteger index, void* key, void* value) {
	@autoreleasepool {
		[(CBAttribute*)o replaceValueAtIndex:index inPropertyWithKey:key withValue:value];
	}
}
void
CBAttribute_inst_DidChangeValueForKey(void* o, void* key) {
	@autoreleasepool {
		[(CBAttribute*)o didChangeValueForKey:key];
	}
}
void
CBAttribute_inst_DidChangeValueForKeyWithSetMutation(void* o, void* key, NSKeyValueSetMutationKind mutationKind, void* objects) {
	@autoreleasepool {
		[(CBAttribute*)o didChangeValueForKey:key withSetMutation:mutationKind usingObjects:objects];
	}
}
void
CBAttribute_inst_DidChangeValueForKeyWithSetMutationUsingObjects(void* o, void* key, NSKeyValueSetMutationKind mutationKind, void* objects) {
	@autoreleasepool {
		[(CBAttribute*)o didChangeValueForKey:key withSetMutation:mutationKind usingObjects:objects];
	}
}
void* _Nullable
CBAttribute_inst_ValueForKeyPath(void* o, void* keyPath) {
	NSObject* _Nullable ret;
	@autoreleasepool {
		ret = [(CBAttribute*)o valueForKeyPath:keyPath];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
BOOL
CBAttribute_inst_ScriptingEndsWith(void* o, void* object) {
	BOOL ret;
	@autoreleasepool {
		ret = [(CBAttribute*)o scriptingEndsWith:object];
	}
	return ret;

}
BOOL
CBAttribute_inst_IsCaseInsensitiveLike(void* o, void* object) {
	BOOL ret;
	@autoreleasepool {
		ret = [(CBAttribute*)o isCaseInsensitiveLike:object];
	}
	return ret;

}
void
CBAttribute_inst_PerformSelectorWithObject(void* o, void* aSelector, void* anArgument, NSTimeInterval delay) {
	@autoreleasepool {
		[(CBAttribute*)o performSelector:aSelector withObject:anArgument afterDelay:delay];
	}
}
void
CBAttribute_inst_PerformSelectorWithObjectAfterDelay(void* o, void* aSelector, void* anArgument, NSTimeInterval delay) {
	@autoreleasepool {
		[(CBAttribute*)o performSelector:aSelector withObject:anArgument afterDelay:delay];
	}
}
void
CBAttribute_inst_PerformSelectorWithObjectAfterDelayInModes(void* o, void* aSelector, void* anArgument, NSTimeInterval delay, void* modes) {
	@autoreleasepool {
		[(CBAttribute*)o performSelector:aSelector withObject:anArgument afterDelay:delay inModes:modes];
	}
}
void
CBAttribute_inst_PerformSelectorOnThread(void* o, void* aSelector, void* thr, void* arg, BOOL wait) {
	@autoreleasepool {
		[(CBAttribute*)o performSelector:aSelector onThread:thr withObject:arg waitUntilDone:wait];
	}
}
void
CBAttribute_inst_PerformSelectorOnThreadWithObject(void* o, void* aSelector, void* thr, void* arg, BOOL wait) {
	@autoreleasepool {
		[(CBAttribute*)o performSelector:aSelector onThread:thr withObject:arg waitUntilDone:wait];
	}
}
void
CBAttribute_inst_PerformSelectorOnThreadWithObjectWaitUntilDone(void* o, void* aSelector, void* thr, void* arg, BOOL wait, void* array) {
	@autoreleasepool {
		[(CBAttribute*)o performSelector:aSelector onThread:thr withObject:arg waitUntilDone:wait modes:array];
	}
}
void
CBAttribute_inst_PerformSelectorOnThreadWithObjectWaitUntilDoneModes(void* o, void* aSelector, void* thr, void* arg, BOOL wait, void* array) {
	@autoreleasepool {
		[(CBAttribute*)o performSelector:aSelector onThread:thr withObject:arg waitUntilDone:wait modes:array];
	}
}
void* _Nonnull
CBAttribute_inst_MutableSetValueForKey(void* o, void* key) {
	NSMutableSet* _Nonnull ret;
	@autoreleasepool {
		ret = [(CBAttribute*)o mutableSetValueForKey:key];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
void* _Nonnull
CBAttribute_inst_DictionaryWithValuesForKeys(void* o, void* keys) {
	NSDictionary* _Nonnull ret;
	@autoreleasepool {
		ret = [(CBAttribute*)o dictionaryWithValuesForKeys:keys];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
BOOL
CBAttribute_inst_AttemptRecoveryFromErrorOptionIndex(void* o, void* error, NSUInteger recoveryOptionIndex) {
	BOOL ret;
	@autoreleasepool {
		ret = [(CBAttribute*)o attemptRecoveryFromError:error optionIndex:recoveryOptionIndex];
	}
	return ret;

}
void
CBAttribute_inst_AttemptRecoveryFromErrorOptionIndexDelegate(void* o, void* error, NSUInteger recoveryOptionIndex, void* delegate, void* didRecoverSelector, void* contextInfo) {
	@autoreleasepool {
		[(CBAttribute*)o attemptRecoveryFromError:error optionIndex:recoveryOptionIndex delegate:delegate didRecoverSelector:didRecoverSelector contextInfo:contextInfo];
	}
}
void
CBAttribute_inst_AttemptRecoveryFromErrorOptionIndexDelegateDidRecoverSelector(void* o, void* error, NSUInteger recoveryOptionIndex, void* delegate, void* didRecoverSelector, void* contextInfo) {
	@autoreleasepool {
		[(CBAttribute*)o attemptRecoveryFromError:error optionIndex:recoveryOptionIndex delegate:delegate didRecoverSelector:didRecoverSelector contextInfo:contextInfo];
	}
}
BOOL
CBAttribute_inst_ValidateValueForKey(void* o, void** ioValue, void* inKey, void** outError) {
	BOOL ret;
	@autoreleasepool {
		ret = [(CBAttribute*)o validateValue:(id _Nullable* _Nonnull)ioValue forKey:inKey error:(NSError* _Nullable* _Nullable)outError];
		for(int i=0;i<1;i++) {
			if(ioValue[i] == 0) { break; }
			[(id)ioValue[i] retain];
		}
	
	
		for(int i=0;i<1;i++) {
			if(outError[i] == 0) { break; }
			[(id)outError[i] retain];
		}
	
	}
	return ret;

}
BOOL
CBAttribute_inst_ValidateValueForKeyPath(void* o, void** ioValue, void* inKeyPath, void** outError) {
	BOOL ret;
	@autoreleasepool {
		ret = [(CBAttribute*)o validateValue:(id _Nullable* _Nonnull)ioValue forKeyPath:inKeyPath error:(NSError* _Nullable* _Nullable)outError];
		for(int i=0;i<1;i++) {
			if(ioValue[i] == 0) { break; }
			[(id)ioValue[i] retain];
		}
	
	
		for(int i=0;i<1;i++) {
			if(outError[i] == 0) { break; }
			[(id)outError[i] retain];
		}
	
	}
	return ret;

}
BOOL
CBAttribute_inst_ValidateValueForKeyError(void* o, void** ioValue, void* inKey, void** outError) {
	BOOL ret;
	@autoreleasepool {
		ret = [(CBAttribute*)o validateValue:(id _Nullable* _Nonnull)ioValue forKey:inKey error:(NSError* _Nullable* _Nullable)outError];
		for(int i=0;i<1;i++) {
			if(ioValue[i] == 0) { break; }
			[(id)ioValue[i] retain];
		}
	
	
		for(int i=0;i<1;i++) {
			if(outError[i] == 0) { break; }
			[(id)outError[i] retain];
		}
	
	}
	return ret;

}
BOOL
CBAttribute_inst_ValidateValueForKeyPathError(void* o, void** ioValue, void* inKeyPath, void** outError) {
	BOOL ret;
	@autoreleasepool {
		ret = [(CBAttribute*)o validateValue:(id _Nullable* _Nonnull)ioValue forKeyPath:inKeyPath error:(NSError* _Nullable* _Nullable)outError];
		for(int i=0;i<1;i++) {
			if(ioValue[i] == 0) { break; }
			[(id)ioValue[i] retain];
		}
	
	
		for(int i=0;i<1;i++) {
			if(outError[i] == 0) { break; }
			[(id)outError[i] retain];
		}
	
	}
	return ret;

}
void* _Nullable
CBAttribute_inst_CoerceValueForKey(void* o, void* value, void* key) {
	NSObject* _Nullable ret;
	@autoreleasepool {
		ret = [(CBAttribute*)o coerceValue:value forKey:key];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
void
CBAttribute_inst_SetObservationInfo(void* o, void* observationInfo) {
	@autoreleasepool {
		[(CBAttribute*)o setObservationInfo:observationInfo];
	}
}
BOOL
CBAttribute_inst_IsGreaterThan(void* o, void* object) {
	BOOL ret;
	@autoreleasepool {
		ret = [(CBAttribute*)o isGreaterThan:object];
	}
	return ret;

}
void* _Nullable
CBAttribute_inst_ObjectSpecifier(void* o) {
	NSScriptObjectSpecifier* _Nullable ret;
	@autoreleasepool {
		ret = [(CBAttribute*)o objectSpecifier];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
void* _Nullable
CBAttribute_inst_ValueWithNameInPropertyWithKey(void* o, void* name, void* key) {
	NSObject* _Nullable ret;
	@autoreleasepool {
		ret = [(CBAttribute*)o valueWithName:name inPropertyWithKey:key];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
void* _Nullable
CBAttribute_inst_NewScriptingObjectOfClassForValueForKey(void* o, void* objectClass, void* key, void* contentsValue, void* properties) {
	NSObject* _Nullable ret;
	@autoreleasepool {
		ret = [(CBAttribute*)o newScriptingObjectOfClass:objectClass forValueForKey:key withContentsValue:contentsValue properties:properties];
	}
	return ret;

}
void* _Nullable
CBAttribute_inst_NewScriptingObjectOfClassForValueForKeyWithContentsValue(void* o, void* objectClass, void* key, void* contentsValue, void* properties) {
	NSObject* _Nullable ret;
	@autoreleasepool {
		ret = [(CBAttribute*)o newScriptingObjectOfClass:objectClass forValueForKey:key withContentsValue:contentsValue properties:properties];
	}
	return ret;

}
void
CBAttribute_inst_SetScriptingProperties(void* o, void* scriptingProperties) {
	@autoreleasepool {
		[(CBAttribute*)o setScriptingProperties:scriptingProperties];
	}
}
void
CBAttribute_inst_RemoveValueAtIndexFromPropertyWithKey(void* o, NSUInteger index, void* key) {
	@autoreleasepool {
		[(CBAttribute*)o removeValueAtIndex:index fromPropertyWithKey:key];
	}
}
void
CBAttribute_inst_AddObserverForKeyPath(void* o, void* observer, void* keyPath, NSKeyValueObservingOptions options, void* context) {
	@autoreleasepool {
		[(CBAttribute*)o addObserver:observer forKeyPath:keyPath options:options context:context];
	}
}
void
CBAttribute_inst_AddObserverForKeyPathOptions(void* o, void* observer, void* keyPath, NSKeyValueObservingOptions options, void* context) {
	@autoreleasepool {
		[(CBAttribute*)o addObserver:observer forKeyPath:keyPath options:options context:context];
	}
}
void* _Nullable
CBAttribute_inst_ReplacementObjectForCoder(void* o, void* coder) {
	NSObject* _Nullable ret;
	@autoreleasepool {
		ret = [(CBAttribute*)o replacementObjectForCoder:coder];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
BOOL
CBAttribute_inst_ScriptingIsGreaterThanOrEqualTo(void* o, void* object) {
	BOOL ret;
	@autoreleasepool {
		ret = [(CBAttribute*)o scriptingIsGreaterThanOrEqualTo:object];
	}
	return ret;

}
BOOL
CBAttribute_inst_IsLessThanOrEqualTo(void* o, void* object) {
	BOOL ret;
	@autoreleasepool {
		ret = [(CBAttribute*)o isLessThanOrEqualTo:object];
	}
	return ret;

}
BOOL
CBAttribute_inst_DoesContain(void* o, void* object) {
	BOOL ret;
	@autoreleasepool {
		ret = [(CBAttribute*)o doesContain:object];
	}
	return ret;

}
void
CBAttribute_inst_WillChangeValueForKey(void* o, void* key) {
	@autoreleasepool {
		[(CBAttribute*)o willChangeValueForKey:key];
	}
}
void
CBAttribute_inst_WillChangeValueForKeyWithSetMutation(void* o, void* key, NSKeyValueSetMutationKind mutationKind, void* objects) {
	@autoreleasepool {
		[(CBAttribute*)o willChangeValueForKey:key withSetMutation:mutationKind usingObjects:objects];
	}
}
void
CBAttribute_inst_WillChangeValueForKeyWithSetMutationUsingObjects(void* o, void* key, NSKeyValueSetMutationKind mutationKind, void* objects) {
	@autoreleasepool {
		[(CBAttribute*)o willChangeValueForKey:key withSetMutation:mutationKind usingObjects:objects];
	}
}
void* _Nonnull
CBAttribute_inst_UUID(void* o) {
	CBUUID* _Nonnull ret;
	@autoreleasepool {
		ret = [(CBAttribute*)o UUID];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
FourCharCode
CBAttribute_inst_ClassCode(void* o) {
	FourCharCode ret;
	@autoreleasepool {
		ret = [(CBAttribute*)o classCode];
	}
	return ret;

}
BOOL
CBAttribute_inst_IsNotEqualTo(void* o, void* object) {
	BOOL ret;
	@autoreleasepool {
		ret = [(CBAttribute*)o isNotEqualTo:object];
	}
	return ret;

}
void*
CBAttribute_inst_ForwardingTargetForSelector(void* o, void* aSelector) {
	NSObject* ret;
	@autoreleasepool {
		ret = [(CBAttribute*)o forwardingTargetForSelector:aSelector];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
void* _Nullable
CBAttribute_inst_InverseForRelationshipKey(void* o, void* relationshipKey) {
	NSString* _Nullable ret;
	@autoreleasepool {
		ret = [(CBAttribute*)o inverseForRelationshipKey:relationshipKey];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
void
CBAttribute_inst_SetValueForKey(void* o, void* value, void* key) {
	@autoreleasepool {
		[(CBAttribute*)o setValue:value forKey:key];
	}
}
void
CBAttribute_inst_SetValueForKeyPath(void* o, void* value, void* keyPath) {
	@autoreleasepool {
		[(CBAttribute*)o setValue:value forKeyPath:keyPath];
	}
}
void
CBAttribute_inst_SetValueForUndefinedKey(void* o, void* value, void* key) {
	@autoreleasepool {
		[(CBAttribute*)o setValue:value forUndefinedKey:key];
	}
}
void* _Nullable
CBAttribute_inst_ValueForKey(void* o, void* key) {
	NSObject* _Nullable ret;
	@autoreleasepool {
		ret = [(CBAttribute*)o valueForKey:key];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
void
CBAttribute_inst_PerformSelectorOnMainThreadWithObject(void* o, void* aSelector, void* arg, BOOL wait) {
	@autoreleasepool {
		[(CBAttribute*)o performSelectorOnMainThread:aSelector withObject:arg waitUntilDone:wait];
	}
}
void
CBAttribute_inst_PerformSelectorOnMainThreadWithObjectWaitUntilDone(void* o, void* aSelector, void* arg, BOOL wait) {
	@autoreleasepool {
		[(CBAttribute*)o performSelectorOnMainThread:aSelector withObject:arg waitUntilDone:wait];
	}
}
void
CBAttribute_inst_PerformSelectorOnMainThreadWithObjectWaitUntilDoneModes(void* o, void* aSelector, void* arg, BOOL wait, void* array) {
	@autoreleasepool {
		[(CBAttribute*)o performSelectorOnMainThread:aSelector withObject:arg waitUntilDone:wait modes:array];
	}
}
void* _Nullable
CBAttribute_inst_CopyScriptingValueForKey(void* o, void* value, void* key, void* properties) {
	NSObject* _Nullable ret;
	@autoreleasepool {
		ret = [(CBAttribute*)o copyScriptingValue:value forKey:key withProperties:properties];
	}
	return ret;

}
void* _Nullable
CBAttribute_inst_CopyScriptingValueForKeyWithProperties(void* o, void* value, void* key, void* properties) {
	NSObject* _Nullable ret;
	@autoreleasepool {
		ret = [(CBAttribute*)o copyScriptingValue:value forKey:key withProperties:properties];
	}
	return ret;

}
BOOL
CBAttribute_inst_IsLessThan(void* o, void* object) {
	BOOL ret;
	@autoreleasepool {
		ret = [(CBAttribute*)o isLessThan:object];
	}
	return ret;

}
void*
CBAttribute_inst_MutableCopy(void* o) {
	NSObject* ret;
	@autoreleasepool {
		ret = [(CBAttribute*)o mutableCopy];
	}
	return ret;

}
BOOL
CBAttribute_inst_ScriptingIsLessThan(void* o, void* object) {
	BOOL ret;
	@autoreleasepool {
		ret = [(CBAttribute*)o scriptingIsLessThan:object];
	}
	return ret;

}
void* _Nullable
CBAttribute_inst_ValueWithUniqueIDInPropertyWithKey(void* o, void* uniqueID, void* key) {
	NSObject* _Nullable ret;
	@autoreleasepool {
		ret = [(CBAttribute*)o valueWithUniqueID:uniqueID inPropertyWithKey:key];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
void
CBAttribute_inst_ObserveValueForKeyPathOfObject(void* o, void* keyPath, void* object, void* change, void* context) {
	@autoreleasepool {
		[(CBAttribute*)o observeValueForKeyPath:keyPath ofObject:object change:change context:context];
	}
}
void
CBAttribute_inst_ObserveValueForKeyPathOfObjectChange(void* o, void* keyPath, void* object, void* change, void* context) {
	@autoreleasepool {
		[(CBAttribute*)o observeValueForKeyPath:keyPath ofObject:object change:change context:context];
	}
}
void* _Nonnull
CBAttribute_inst_ToOneRelationshipKeys(void* o) {
	NSArray* _Nonnull ret;
	@autoreleasepool {
		ret = [(CBAttribute*)o toOneRelationshipKeys];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
void
CBAttribute_inst_PerformSelectorInBackgroundWithObject(void* o, void* aSelector, void* arg) {
	@autoreleasepool {
		[(CBAttribute*)o performSelectorInBackground:aSelector withObject:arg];
	}
}
void* _Nonnull
CBAttribute_inst_ClassForCoder(void* o) {
	Class _Nonnull ret;
	@autoreleasepool {
		ret = [(CBAttribute*)o classForCoder];
	}
	return ret;

}
void* _Nonnull
CBAttribute_inst_ClassDescription(void* o) {
	NSClassDescription* _Nonnull ret;
	@autoreleasepool {
		ret = [(CBAttribute*)o classDescription];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
BOOL
CBAttribute_inst_ScriptingIsEqualTo(void* o, void* object) {
	BOOL ret;
	@autoreleasepool {
		ret = [(CBAttribute*)o scriptingIsEqualTo:object];
	}
	return ret;

}
void* _Nullable
CBAttribute_inst_IndicesOfObjectsByEvaluatingObjectSpecifier(void* o, void* specifier) {
	NSArray* _Nullable ret;
	@autoreleasepool {
		ret = [(CBAttribute*)o indicesOfObjectsByEvaluatingObjectSpecifier:specifier];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
void* _Nullable
CBAttribute_inst_ValueAtIndexInPropertyWithKey(void* o, NSUInteger index, void* key) {
	NSObject* _Nullable ret;
	@autoreleasepool {
		ret = [(CBAttribute*)o valueAtIndex:index inPropertyWithKey:key];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
void* _Nonnull
CBAttribute_inst_MutableArrayValueForKeyPath(void* o, void* keyPath) {
	NSMutableArray* _Nonnull ret;
	@autoreleasepool {
		ret = [(CBAttribute*)o mutableArrayValueForKeyPath:keyPath];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
void* _Nonnull
CBAttribute_inst_MutableOrderedSetValueForKeyPath(void* o, void* keyPath) {
	NSMutableOrderedSet* _Nonnull ret;
	@autoreleasepool {
		ret = [(CBAttribute*)o mutableOrderedSetValueForKeyPath:keyPath];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
BOOL
CBAttribute_inst_IsEqualTo(void* o, void* object) {
	BOOL ret;
	@autoreleasepool {
		ret = [(CBAttribute*)o isEqualTo:object];
	}
	return ret;

}
void
CBAttribute_inst_SetNilValueForKey(void* o, void* key) {
	@autoreleasepool {
		[(CBAttribute*)o setNilValueForKey:key];
	}
}
void*
CBAttribute_inst_MethodSignatureForSelector(void* o, void* aSelector) {
	NSMethodSignature* ret;
	@autoreleasepool {
		ret = [(CBAttribute*)o methodSignatureForSelector:aSelector];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
void
CBAttribute_inst_WillChangeValuesAtIndexes(void* o, NSKeyValueChange changeKind, void* indexes, void* key) {
	@autoreleasepool {
		[(CBAttribute*)o willChange:changeKind valuesAtIndexes:indexes forKey:key];
	}
}
void
CBAttribute_inst_WillChangeValuesAtIndexesForKey(void* o, NSKeyValueChange changeKind, void* indexes, void* key) {
	@autoreleasepool {
		[(CBAttribute*)o willChange:changeKind valuesAtIndexes:indexes forKey:key];
	}
}
void* _Nonnull
CBAttribute_inst_MutableOrderedSetValueForKey(void* o, void* key) {
	NSMutableOrderedSet* _Nonnull ret;
	@autoreleasepool {
		ret = [(CBAttribute*)o mutableOrderedSetValueForKey:key];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
void* _Nullable
CBAttribute_inst_ReplacementObjectForKeyedArchiver(void* o, void* archiver) {
	NSObject* _Nullable ret;
	@autoreleasepool {
		ret = [(CBAttribute*)o replacementObjectForKeyedArchiver:archiver];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
void* _Nullable
CBAttribute_inst_AwakeAfterUsingCoder(void* o, void* coder) {
	NSObject* _Nullable ret;
	@autoreleasepool {
		ret = [(CBAttribute*)o awakeAfterUsingCoder:coder];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
void
CBAttribute_inst_SetValuesForKeysWithDictionary(void* o, void* keyedValues) {
	@autoreleasepool {
		[(CBAttribute*)o setValuesForKeysWithDictionary:keyedValues];
	}
}
BOOL
CBAttribute_inst_ScriptingBeginsWith(void* o, void* object) {
	BOOL ret;
	@autoreleasepool {
		ret = [(CBAttribute*)o scriptingBeginsWith:object];
	}
	return ret;

}
void* _Nonnull
CBAttribute_inst_AutoContentAccessingProxy(void* o) {
	NSObject* _Nonnull ret;
	@autoreleasepool {
		ret = [(CBAttribute*)o autoContentAccessingProxy];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
void
CBAttribute_inst_InsertValueInPropertyWithKey(void* o, void* value, void* key) {
	@autoreleasepool {
		[(CBAttribute*)o insertValue:value inPropertyWithKey:key];
	}
}
void
CBAttribute_inst_InsertValueAtIndex(void* o, void* value, NSUInteger index, void* key) {
	@autoreleasepool {
		[(CBAttribute*)o insertValue:value atIndex:index inPropertyWithKey:key];
	}
}
void
CBAttribute_inst_InsertValueAtIndexInPropertyWithKey(void* o, void* value, NSUInteger index, void* key) {
	@autoreleasepool {
		[(CBAttribute*)o insertValue:value atIndex:index inPropertyWithKey:key];
	}
}
void* _Nonnull
CBAttribute_inst_MutableSetValueForKeyPath(void* o, void* keyPath) {
	NSMutableSet* _Nonnull ret;
	@autoreleasepool {
		ret = [(CBAttribute*)o mutableSetValueForKeyPath:keyPath];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
void
CBAttribute_inst_ForwardInvocation(void* o, void* anInvocation) {
	@autoreleasepool {
		[(CBAttribute*)o forwardInvocation:anInvocation];
	}
}
void* _Nonnull
CBAttribute_inst_AttributeKeys(void* o) {
	NSArray* _Nonnull ret;
	@autoreleasepool {
		ret = [(CBAttribute*)o attributeKeys];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
void*
CBAttribute_inst_Copy(void* o) {
	NSObject* ret;
	@autoreleasepool {
		ret = [(CBAttribute*)o copy];
	}
	return ret;

}
void* _Nonnull
CBAttribute_inst_MutableArrayValueForKey(void* o, void* key) {
	NSMutableArray* _Nonnull ret;
	@autoreleasepool {
		ret = [(CBAttribute*)o mutableArrayValueForKey:key];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
void
CBAttribute_inst_RemoveObserverForKeyPath(void* o, void* observer, void* keyPath) {
	@autoreleasepool {
		[(CBAttribute*)o removeObserver:observer forKeyPath:keyPath];
	}
}
void
CBAttribute_inst_RemoveObserverForKeyPathContext(void* o, void* observer, void* keyPath, void* context) {
	@autoreleasepool {
		[(CBAttribute*)o removeObserver:observer forKeyPath:keyPath context:context];
	}
}
void
CBAttribute_inst_DidChangeValuesAtIndexes(void* o, NSKeyValueChange changeKind, void* indexes, void* key) {
	@autoreleasepool {
		[(CBAttribute*)o didChange:changeKind valuesAtIndexes:indexes forKey:key];
	}
}
void
CBAttribute_inst_DidChangeValuesAtIndexesForKey(void* o, NSKeyValueChange changeKind, void* indexes, void* key) {
	@autoreleasepool {
		[(CBAttribute*)o didChange:changeKind valuesAtIndexes:indexes forKey:key];
	}
}
void* _Nullable
CBAttribute_inst_ValueForUndefinedKey(void* o, void* key) {
	NSObject* _Nullable ret;
	@autoreleasepool {
		ret = [(CBAttribute*)o valueForUndefinedKey:key];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
BOOL
CBAttribute_inst_IsLike(void* o, void* object) {
	BOOL ret;
	@autoreleasepool {
		ret = [(CBAttribute*)o isLike:object];
	}
	return ret;

}
void*
CBAttribute_inst_ObservationInfo(void* o) {
	void* ret;
	@autoreleasepool {
		ret = [(CBAttribute*)o observationInfo];
	}
	return ret;

}
BOOL
CBAttribute_inst_IsGreaterThanOrEqualTo(void* o, void* object) {
	BOOL ret;
	@autoreleasepool {
		ret = [(CBAttribute*)o isGreaterThanOrEqualTo:object];
	}
	return ret;

}
void* _Nullable
CBAttribute_inst_ClassForArchiver(void* o) {
	Class _Nullable ret;
	@autoreleasepool {
		ret = [(CBAttribute*)o classForArchiver];
	}
	return ret;

}
void* _Nullable
CBAttribute_inst_ClassForKeyedArchiver(void* o) {
	Class _Nullable ret;
	@autoreleasepool {
		ret = [(CBAttribute*)o classForKeyedArchiver];
	}
	return ret;

}
BOOL
CBAttribute_inst_ScriptingIsLessThanOrEqualTo(void* o, void* object) {
	BOOL ret;
	@autoreleasepool {
		ret = [(CBAttribute*)o scriptingIsLessThanOrEqualTo:object];
	}
	return ret;

}
void
CBAttribute_inst_DoesNotRecognizeSelector(void* o, void* aSelector) {
	@autoreleasepool {
		[(CBAttribute*)o doesNotRecognizeSelector:aSelector];
	}
}
void* _Nonnull
CBAttribute_inst_ToManyRelationshipKeys(void* o) {
	NSArray* _Nonnull ret;
	@autoreleasepool {
		ret = [(CBAttribute*)o toManyRelationshipKeys];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
void* _Nullable
CBAttribute_inst_ScriptingProperties(void* o) {
	NSDictionary* _Nullable ret;
	@autoreleasepool {
		ret = [(CBAttribute*)o scriptingProperties];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
BOOL
CBAttribute_inst_ScriptingIsGreaterThan(void* o, void* object) {
	BOOL ret;
	@autoreleasepool {
		ret = [(CBAttribute*)o scriptingIsGreaterThan:object];
	}
	return ret;

}
BOOL
CBDescriptor_AutomaticallyNotifiesObserversForKey(void* key) {
	BOOL ret;
	@autoreleasepool {
		ret = [CBDescriptor automaticallyNotifiesObserversForKey:key];
	}
	return ret;

}
void*
CBDescriptor_AllocWithZone(void* zone) {
	return [CBDescriptor allocWithZone:zone];
}
void* _Nonnull
CBDescriptor_KeyPathsForValuesAffectingValueForKey(void* key) {
	NSSet* _Nonnull ret;
	@autoreleasepool {
		ret = [CBDescriptor keyPathsForValuesAffectingValueForKey:key];
	}
	return ret;

}
BOOL
CBDescriptor_ConformsToProtocol(void* protocol) {
	BOOL ret;
	@autoreleasepool {
		ret = [CBDescriptor conformsToProtocol:protocol];
	}
	return ret;

}
void
CBDescriptor_Load() {
	@autoreleasepool {
		[CBDescriptor load];
	}
}
NSInteger
CBDescriptor_Version() {
	NSInteger ret;
	@autoreleasepool {
		ret = [CBDescriptor version];
	}
	return ret;

}
BOOL
CBDescriptor_ResolveClassMethod(void* sel) {
	BOOL ret;
	@autoreleasepool {
		ret = [CBDescriptor resolveClassMethod:sel];
	}
	return ret;

}
void*
CBDescriptor_DebugDescription() {
	NSString* ret;
	@autoreleasepool {
		ret = [CBDescriptor debugDescription];
	}
	return ret;

}
NSUInteger
CBDescriptor_Hash() {
	NSUInteger ret;
	@autoreleasepool {
		ret = [CBDescriptor hash];
	}
	return ret;

}
void*
CBDescriptor_CopyWithZone(void* zone) {
	NSObject* ret;
	@autoreleasepool {
		ret = [CBDescriptor copyWithZone:zone];
	}
	return ret;

}
void*
CBDescriptor_Description() {
	NSString* ret;
	@autoreleasepool {
		ret = [CBDescriptor description];
	}
	return ret;

}
BOOL
CBDescriptor_InstancesRespondToSelector(void* aSelector) {
	BOOL ret;
	@autoreleasepool {
		ret = [CBDescriptor instancesRespondToSelector:aSelector];
	}
	return ret;

}
void*
CBDescriptor_MutableCopyWithZone(void* zone) {
	NSObject* ret;
	@autoreleasepool {
		ret = [CBDescriptor mutableCopyWithZone:zone];
	}
	return ret;

}
void* _Nonnull
CBDescriptor_ClassFallbacksForKeyedArchiver() {
	NSArray* _Nonnull ret;
	@autoreleasepool {
		ret = [CBDescriptor classFallbacksForKeyedArchiver];
	}
	return ret;

}
void*
CBDescriptor_InstanceMethodSignatureForSelector(void* aSelector) {
	NSMethodSignature* ret;
	@autoreleasepool {
		ret = [CBDescriptor instanceMethodSignatureForSelector:aSelector];
	}
	return ret;

}
void
CBDescriptor_SetVersion(NSInteger aVersion) {
	@autoreleasepool {
		[CBDescriptor setVersion:aVersion];
	}
}
void*
CBDescriptor_New() {
	CBDescriptor* ret;
	@autoreleasepool {
		NSLog(@"CBDescriptor new");
		//ret = [CBDescriptor new];
	}
	return ret;

}
BOOL
CBDescriptor_ResolveInstanceMethod(void* sel) {
	BOOL ret;
	@autoreleasepool {
		ret = [CBDescriptor resolveInstanceMethod:sel];
	}
	return ret;

}
BOOL
CBDescriptor_IsSubclassOfClass(void* aClass) {
	BOOL ret;
	@autoreleasepool {
		ret = [CBDescriptor isSubclassOfClass:aClass];
	}
	return ret;

}
void
CBDescriptor_CancelPreviousPerformRequestsWithTarget(void* aTarget) {
	@autoreleasepool {
		[CBDescriptor cancelPreviousPerformRequestsWithTarget:aTarget];
	}
}
void
CBDescriptor_CancelPreviousPerformRequestsWithTargetSelector(void* aTarget, void* aSelector, void* anArgument) {
	@autoreleasepool {
		[CBDescriptor cancelPreviousPerformRequestsWithTarget:aTarget selector:aSelector object:anArgument];
	}
}
void
CBDescriptor_CancelPreviousPerformRequestsWithTargetSelectorObject(void* aTarget, void* aSelector, void* anArgument) {
	@autoreleasepool {
		[CBDescriptor cancelPreviousPerformRequestsWithTarget:aTarget selector:aSelector object:anArgument];
	}
}
BOOL
CBDescriptor_AccessInstanceVariablesDirectly() {
	BOOL ret;
	@autoreleasepool {
		ret = [CBDescriptor accessInstanceVariablesDirectly];
	}
	return ret;

}
void*
CBDescriptor_Alloc() {
	return [CBDescriptor alloc];
}
void*
CBDescriptor_Class() {
	Class ret;
	@autoreleasepool {
		ret = [CBDescriptor class];
	}
	return ret;

}
void*
CBDescriptor_Superclass() {
	Class ret;
	@autoreleasepool {
		ret = [CBDescriptor superclass];
	}
	return ret;

}
void* _Nonnull
CBDescriptor_ClassForKeyedUnarchiver() {
	Class _Nonnull ret;
	@autoreleasepool {
		ret = [CBDescriptor classForKeyedUnarchiver];
	}
	return ret;

}
void*
CBDescriptor_inst_ForwardingTargetForSelector(void* o, void* aSelector) {
	NSObject* ret;
	@autoreleasepool {
		ret = [(CBDescriptor*)o forwardingTargetForSelector:aSelector];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
void*
CBDescriptor_inst_Copy(void* o) {
	NSObject* ret;
	@autoreleasepool {
		ret = [(CBDescriptor*)o copy];
	}
	return ret;

}
void* _Nullable
CBDescriptor_inst_ClassForArchiver(void* o) {
	Class _Nullable ret;
	@autoreleasepool {
		ret = [(CBDescriptor*)o classForArchiver];
	}
	return ret;

}
BOOL
CBDescriptor_inst_ScriptingIsLessThanOrEqualTo(void* o, void* object) {
	BOOL ret;
	@autoreleasepool {
		ret = [(CBDescriptor*)o scriptingIsLessThanOrEqualTo:object];
	}
	return ret;

}
void* _Nonnull
CBDescriptor_inst_Characteristic(void* o) {
	CBCharacteristic* _Nonnull ret;
	@autoreleasepool {
		ret = [(CBDescriptor*)o characteristic];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
void* _Nullable
CBDescriptor_inst_Value(void* o) {
	NSObject* _Nullable ret;
	@autoreleasepool {
		ret = [(CBDescriptor*)o value];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
BOOL
CBDescriptor_inst_ScriptingEndsWith(void* o, void* object) {
	BOOL ret;
	@autoreleasepool {
		ret = [(CBDescriptor*)o scriptingEndsWith:object];
	}
	return ret;

}
void
CBDescriptor_inst_PerformSelectorWithObject(void* o, void* aSelector, void* anArgument, NSTimeInterval delay) {
	@autoreleasepool {
		[(CBDescriptor*)o performSelector:aSelector withObject:anArgument afterDelay:delay];
	}
}
void
CBDescriptor_inst_PerformSelectorWithObjectAfterDelay(void* o, void* aSelector, void* anArgument, NSTimeInterval delay) {
	@autoreleasepool {
		[(CBDescriptor*)o performSelector:aSelector withObject:anArgument afterDelay:delay];
	}
}
void
CBDescriptor_inst_PerformSelectorWithObjectAfterDelayInModes(void* o, void* aSelector, void* anArgument, NSTimeInterval delay, void* modes) {
	@autoreleasepool {
		[(CBDescriptor*)o performSelector:aSelector withObject:anArgument afterDelay:delay inModes:modes];
	}
}
void
CBDescriptor_inst_PerformSelectorOnThread(void* o, void* aSelector, void* thr, void* arg, BOOL wait) {
	@autoreleasepool {
		[(CBDescriptor*)o performSelector:aSelector onThread:thr withObject:arg waitUntilDone:wait];
	}
}
void
CBDescriptor_inst_PerformSelectorOnThreadWithObject(void* o, void* aSelector, void* thr, void* arg, BOOL wait) {
	@autoreleasepool {
		[(CBDescriptor*)o performSelector:aSelector onThread:thr withObject:arg waitUntilDone:wait];
	}
}
void
CBDescriptor_inst_PerformSelectorOnThreadWithObjectWaitUntilDone(void* o, void* aSelector, void* thr, void* arg, BOOL wait) {
	@autoreleasepool {
		[(CBDescriptor*)o performSelector:aSelector onThread:thr withObject:arg waitUntilDone:wait];
	}
}
void
CBDescriptor_inst_PerformSelectorOnThreadWithObjectWaitUntilDoneModes(void* o, void* aSelector, void* thr, void* arg, BOOL wait, void* array) {
	@autoreleasepool {
		[(CBDescriptor*)o performSelector:aSelector onThread:thr withObject:arg waitUntilDone:wait modes:array];
	}
}
BOOL
CBDescriptor_inst_AttemptRecoveryFromErrorOptionIndex(void* o, void* error, NSUInteger recoveryOptionIndex) {
	BOOL ret;
	@autoreleasepool {
		ret = [(CBDescriptor*)o attemptRecoveryFromError:error optionIndex:recoveryOptionIndex];
	}
	return ret;

}
void
CBDescriptor_inst_AttemptRecoveryFromErrorOptionIndexDelegate(void* o, void* error, NSUInteger recoveryOptionIndex, void* delegate, void* didRecoverSelector, void* contextInfo) {
	@autoreleasepool {
		[(CBDescriptor*)o attemptRecoveryFromError:error optionIndex:recoveryOptionIndex delegate:delegate didRecoverSelector:didRecoverSelector contextInfo:contextInfo];
	}
}
void
CBDescriptor_inst_AttemptRecoveryFromErrorOptionIndexDelegateDidRecoverSelector(void* o, void* error, NSUInteger recoveryOptionIndex, void* delegate, void* didRecoverSelector, void* contextInfo) {
	@autoreleasepool {
		[(CBDescriptor*)o attemptRecoveryFromError:error optionIndex:recoveryOptionIndex delegate:delegate didRecoverSelector:didRecoverSelector contextInfo:contextInfo];
	}
}
void
CBDescriptor_inst_AttemptRecoveryFromErrorOptionIndexDelegateDidRecoverSelectorContextInfo(void* o, void* error, NSUInteger recoveryOptionIndex, void* delegate, void* didRecoverSelector, void* contextInfo) {
	@autoreleasepool {
		[(CBDescriptor*)o attemptRecoveryFromError:error optionIndex:recoveryOptionIndex delegate:delegate didRecoverSelector:didRecoverSelector contextInfo:contextInfo];
	}
}
FourCharCode
CBDescriptor_inst_ClassCode(void* o) {
	FourCharCode ret;
	@autoreleasepool {
		ret = [(CBDescriptor*)o classCode];
	}
	return ret;

}
void* _Nullable
CBDescriptor_inst_ValueWithUniqueIDInPropertyWithKey(void* o, void* uniqueID, void* key) {
	NSObject* _Nullable ret;
	@autoreleasepool {
		ret = [(CBDescriptor*)o valueWithUniqueID:uniqueID inPropertyWithKey:key];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
void* _Nullable
CBDescriptor_inst_ValueForUndefinedKey(void* o, void* key) {
	NSObject* _Nullable ret;
	@autoreleasepool {
		ret = [(CBDescriptor*)o valueForUndefinedKey:key];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
void
CBDescriptor_inst_RemoveValueAtIndexFromPropertyWithKey(void* o, NSUInteger index, void* key) {
	@autoreleasepool {
		[(CBDescriptor*)o removeValueAtIndex:index fromPropertyWithKey:key];
	}
}
BOOL
CBDescriptor_inst_IsEqualTo(void* o, void* object) {
	BOOL ret;
	@autoreleasepool {
		ret = [(CBDescriptor*)o isEqualTo:object];
	}
	return ret;

}
void* _Nullable
CBDescriptor_inst_AwakeAfterUsingCoder(void* o, void* coder) {
	NSObject* _Nullable ret;
	@autoreleasepool {
		ret = [(CBDescriptor*)o awakeAfterUsingCoder:coder];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
BOOL
CBDescriptor_inst_ScriptingBeginsWith(void* o, void* object) {
	BOOL ret;
	@autoreleasepool {
		ret = [(CBDescriptor*)o scriptingBeginsWith:object];
	}
	return ret;

}
void
CBDescriptor_inst_SetNilValueForKey(void* o, void* key) {
	@autoreleasepool {
		[(CBDescriptor*)o setNilValueForKey:key];
	}
}
BOOL
CBDescriptor_inst_IsLike(void* o, void* object) {
	BOOL ret;
	@autoreleasepool {
		ret = [(CBDescriptor*)o isLike:object];
	}
	return ret;

}
void* _Nullable
CBDescriptor_inst_ReplacementObjectForCoder(void* o, void* coder) {
	NSObject* _Nullable ret;
	@autoreleasepool {
		ret = [(CBDescriptor*)o replacementObjectForCoder:coder];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
BOOL
CBDescriptor_inst_IsLessThanOrEqualTo(void* o, void* object) {
	BOOL ret;
	@autoreleasepool {
		ret = [(CBDescriptor*)o isLessThanOrEqualTo:object];
	}
	return ret;

}
BOOL
CBDescriptor_inst_DoesContain(void* o, void* object) {
	BOOL ret;
	@autoreleasepool {
		ret = [(CBDescriptor*)o doesContain:object];
	}
	return ret;

}
void* _Nullable
CBDescriptor_inst_ValueForKey(void* o, void* key) {
	NSObject* _Nullable ret;
	@autoreleasepool {
		ret = [(CBDescriptor*)o valueForKey:key];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
void* _Nullable
CBDescriptor_inst_IndicesOfObjectsByEvaluatingObjectSpecifier(void* o, void* specifier) {
	NSArray* _Nullable ret;
	@autoreleasepool {
		ret = [(CBDescriptor*)o indicesOfObjectsByEvaluatingObjectSpecifier:specifier];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
void* _Nullable
CBDescriptor_inst_ValueAtIndexInPropertyWithKey(void* o, NSUInteger index, void* key) {
	NSObject* _Nullable ret;
	@autoreleasepool {
		ret = [(CBDescriptor*)o valueAtIndex:index inPropertyWithKey:key];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
void* _Nullable
CBDescriptor_inst_ClassForKeyedArchiver(void* o) {
	Class _Nullable ret;
	@autoreleasepool {
		ret = [(CBDescriptor*)o classForKeyedArchiver];
	}
	return ret;

}
void* _Nullable
CBDescriptor_inst_ScriptingValueForSpecifier(void* o, void* objectSpecifier) {
	NSObject* _Nullable ret;
	@autoreleasepool {
		ret = [(CBDescriptor*)o scriptingValueForSpecifier:objectSpecifier];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
void* _Nullable
CBDescriptor_inst_ObjectSpecifier(void* o) {
	NSScriptObjectSpecifier* _Nullable ret;
	@autoreleasepool {
		ret = [(CBDescriptor*)o objectSpecifier];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
void* _Nonnull
CBDescriptor_inst_UUID(void* o) {
	CBUUID* _Nonnull ret;
	@autoreleasepool {
		ret = [(CBDescriptor*)o UUID];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
BOOL
CBDescriptor_inst_ScriptingIsLessThan(void* o, void* object) {
	BOOL ret;
	@autoreleasepool {
		ret = [(CBDescriptor*)o scriptingIsLessThan:object];
	}
	return ret;

}
void
CBDescriptor_inst_PerformSelectorInBackgroundWithObject(void* o, void* aSelector, void* arg) {
	@autoreleasepool {
		[(CBDescriptor*)o performSelectorInBackground:aSelector withObject:arg];
	}
}
BOOL
CBDescriptor_inst_IsNotEqualTo(void* o, void* object) {
	BOOL ret;
	@autoreleasepool {
		ret = [(CBDescriptor*)o isNotEqualTo:object];
	}
	return ret;

}
BOOL
CBDescriptor_inst_IsLessThan(void* o, void* object) {
	BOOL ret;
	@autoreleasepool {
		ret = [(CBDescriptor*)o isLessThan:object];
	}
	return ret;

}
void* _Nonnull
CBDescriptor_inst_ToOneRelationshipKeys(void* o) {
	NSArray* _Nonnull ret;
	@autoreleasepool {
		ret = [(CBDescriptor*)o toOneRelationshipKeys];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
BOOL
CBDescriptor_inst_ScriptingIsEqualTo(void* o, void* object) {
	BOOL ret;
	@autoreleasepool {
		ret = [(CBDescriptor*)o scriptingIsEqualTo:object];
	}
	return ret;

}
void
CBDescriptor_inst_WillChangeValuesAtIndexes(void* o, NSKeyValueChange changeKind, void* indexes, void* key) {
	@autoreleasepool {
		[(CBDescriptor*)o willChange:changeKind valuesAtIndexes:indexes forKey:key];
	}
}
void
CBDescriptor_inst_WillChangeValuesAtIndexesForKey(void* o, NSKeyValueChange changeKind, void* indexes, void* key) {
	@autoreleasepool {
		[(CBDescriptor*)o willChange:changeKind valuesAtIndexes:indexes forKey:key];
	}
}
void* _Nonnull
CBDescriptor_inst_MutableOrderedSetValueForKey(void* o, void* key) {
	NSMutableOrderedSet* _Nonnull ret;
	@autoreleasepool {
		ret = [(CBDescriptor*)o mutableOrderedSetValueForKey:key];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
void* _Nonnull
CBDescriptor_inst_ClassName(void* o) {
	NSString* _Nonnull ret;
	@autoreleasepool {
		ret = [(CBDescriptor*)o className];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
void* _Nullable
CBDescriptor_inst_ValueForKeyPath(void* o, void* keyPath) {
	NSObject* _Nullable ret;
	@autoreleasepool {
		ret = [(CBDescriptor*)o valueForKeyPath:keyPath];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
void* _Nullable
CBDescriptor_inst_CoerceValueForKey(void* o, void* value, void* key) {
	NSObject* _Nullable ret;
	@autoreleasepool {
		ret = [(CBDescriptor*)o coerceValue:value forKey:key];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
void
CBDescriptor_inst_SetObservationInfo(void* o, void* observationInfo) {
	@autoreleasepool {
		[(CBDescriptor*)o setObservationInfo:observationInfo];
	}
}
void* _Nullable
CBDescriptor_inst_ValueWithNameInPropertyWithKey(void* o, void* name, void* key) {
	NSObject* _Nullable ret;
	@autoreleasepool {
		ret = [(CBDescriptor*)o valueWithName:name inPropertyWithKey:key];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
void* _Nonnull
CBDescriptor_inst_ClassDescription(void* o) {
	NSClassDescription* _Nonnull ret;
	@autoreleasepool {
		ret = [(CBDescriptor*)o classDescription];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
void
CBDescriptor_inst_InsertValueInPropertyWithKey(void* o, void* value, void* key) {
	@autoreleasepool {
		[(CBDescriptor*)o insertValue:value inPropertyWithKey:key];
	}
}
void
CBDescriptor_inst_InsertValueAtIndex(void* o, void* value, NSUInteger index, void* key) {
	@autoreleasepool {
		[(CBDescriptor*)o insertValue:value atIndex:index inPropertyWithKey:key];
	}
}
void
CBDescriptor_inst_InsertValueAtIndexInPropertyWithKey(void* o, void* value, NSUInteger index, void* key) {
	@autoreleasepool {
		[(CBDescriptor*)o insertValue:value atIndex:index inPropertyWithKey:key];
	}
}
void
CBDescriptor_inst_ForwardInvocation(void* o, void* anInvocation) {
	@autoreleasepool {
		[(CBDescriptor*)o forwardInvocation:anInvocation];
	}
}
void* _Nonnull
CBDescriptor_inst_AttributeKeys(void* o) {
	NSArray* _Nonnull ret;
	@autoreleasepool {
		ret = [(CBDescriptor*)o attributeKeys];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
BOOL
CBDescriptor_inst_IsCaseInsensitiveLike(void* o, void* object) {
	BOOL ret;
	@autoreleasepool {
		ret = [(CBDescriptor*)o isCaseInsensitiveLike:object];
	}
	return ret;

}
void
CBDescriptor_inst_SetValueForKey(void* o, void* value, void* key) {
	@autoreleasepool {
		[(CBDescriptor*)o setValue:value forKey:key];
	}
}
void
CBDescriptor_inst_SetValueForKeyPath(void* o, void* value, void* keyPath) {
	@autoreleasepool {
		[(CBDescriptor*)o setValue:value forKeyPath:keyPath];
	}
}
void
CBDescriptor_inst_SetValueForUndefinedKey(void* o, void* value, void* key) {
	@autoreleasepool {
		[(CBDescriptor*)o setValue:value forUndefinedKey:key];
	}
}
void* _Nonnull
CBDescriptor_inst_ClassForCoder(void* o) {
	Class _Nonnull ret;
	@autoreleasepool {
		ret = [(CBDescriptor*)o classForCoder];
	}
	return ret;

}
void
CBDescriptor_inst_DidChangeValuesAtIndexes(void* o, NSKeyValueChange changeKind, void* indexes, void* key) {
	@autoreleasepool {
		[(CBDescriptor*)o didChange:changeKind valuesAtIndexes:indexes forKey:key];
	}
}
void
CBDescriptor_inst_DidChangeValuesAtIndexesForKey(void* o, NSKeyValueChange changeKind, void* indexes, void* key) {
	@autoreleasepool {
		[(CBDescriptor*)o didChange:changeKind valuesAtIndexes:indexes forKey:key];
	}
}
void
CBDescriptor_inst_AddObserverForKeyPath(void* o, void* observer, void* keyPath, NSKeyValueObservingOptions options, void* context) {
	@autoreleasepool {
		[(CBDescriptor*)o addObserver:observer forKeyPath:keyPath options:options context:context];
	}
}
void
CBDescriptor_inst_AddObserverForKeyPathOptions(void* o, void* observer, void* keyPath, NSKeyValueObservingOptions options, void* context) {
	@autoreleasepool {
		[(CBDescriptor*)o addObserver:observer forKeyPath:keyPath options:options context:context];
	}
}
void
CBDescriptor_inst_AddObserverForKeyPathOptionsContext(void* o, void* observer, void* keyPath, NSKeyValueObservingOptions options, void* context) {
	@autoreleasepool {
		[(CBDescriptor*)o addObserver:observer forKeyPath:keyPath options:options context:context];
	}
}
BOOL
CBDescriptor_inst_IsGreaterThanOrEqualTo(void* o, void* object) {
	BOOL ret;
	@autoreleasepool {
		ret = [(CBDescriptor*)o isGreaterThanOrEqualTo:object];
	}
	return ret;

}
void
CBDescriptor_inst_Dealloc(void* o) {
	@autoreleasepool {
		[(CBDescriptor*)o dealloc];
	}
}
void*
CBDescriptor_inst_MethodSignatureForSelector(void* o, void* aSelector) {
	NSMethodSignature* ret;
	@autoreleasepool {
		ret = [(CBDescriptor*)o methodSignatureForSelector:aSelector];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
void* _Nonnull
CBDescriptor_inst_AutoContentAccessingProxy(void* o) {
	NSObject* _Nonnull ret;
	@autoreleasepool {
		ret = [(CBDescriptor*)o autoContentAccessingProxy];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
void* _Nonnull
CBDescriptor_inst_MutableSetValueForKeyPath(void* o, void* keyPath) {
	NSMutableSet* _Nonnull ret;
	@autoreleasepool {
		ret = [(CBDescriptor*)o mutableSetValueForKeyPath:keyPath];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
void* _Nonnull
CBDescriptor_inst_MutableArrayValueForKey(void* o, void* key) {
	NSMutableArray* _Nonnull ret;
	@autoreleasepool {
		ret = [(CBDescriptor*)o mutableArrayValueForKey:key];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
BOOL
CBDescriptor_inst_ScriptingContains(void* o, void* object) {
	BOOL ret;
	@autoreleasepool {
		ret = [(CBDescriptor*)o scriptingContains:object];
	}
	return ret;

}
void* _Nonnull
CBDescriptor_inst_MutableSetValueForKey(void* o, void* key) {
	NSMutableSet* _Nonnull ret;
	@autoreleasepool {
		ret = [(CBDescriptor*)o mutableSetValueForKey:key];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
void* _Nonnull
CBDescriptor_inst_DictionaryWithValuesForKeys(void* o, void* keys) {
	NSDictionary* _Nonnull ret;
	@autoreleasepool {
		ret = [(CBDescriptor*)o dictionaryWithValuesForKeys:keys];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
void
CBDescriptor_inst_SetScriptingProperties(void* o, void* scriptingProperties) {
	@autoreleasepool {
		[(CBDescriptor*)o setScriptingProperties:scriptingProperties];
	}
}
void*
CBDescriptor_inst_ObservationInfo(void* o) {
	void* ret;
	@autoreleasepool {
		ret = [(CBDescriptor*)o observationInfo];
	}
	return ret;

}
void* _Nonnull
CBDescriptor_inst_ToManyRelationshipKeys(void* o) {
	NSArray* _Nonnull ret;
	@autoreleasepool {
		ret = [(CBDescriptor*)o toManyRelationshipKeys];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
void
CBDescriptor_inst_ReplaceValueAtIndexInPropertyWithKey(void* o, NSUInteger index, void* key, void* value) {
	@autoreleasepool {
		[(CBDescriptor*)o replaceValueAtIndex:index inPropertyWithKey:key withValue:value];
	}
}
void
CBDescriptor_inst_ReplaceValueAtIndexInPropertyWithKeyWithValue(void* o, NSUInteger index, void* key, void* value) {
	@autoreleasepool {
		[(CBDescriptor*)o replaceValueAtIndex:index inPropertyWithKey:key withValue:value];
	}
}
void
CBDescriptor_inst_DidChangeValueForKey(void* o, void* key) {
	@autoreleasepool {
		[(CBDescriptor*)o didChangeValueForKey:key];
	}
}
void
CBDescriptor_inst_DidChangeValueForKeyWithSetMutation(void* o, void* key, NSKeyValueSetMutationKind mutationKind, void* objects) {
	@autoreleasepool {
		[(CBDescriptor*)o didChangeValueForKey:key withSetMutation:mutationKind usingObjects:objects];
	}
}
void
CBDescriptor_inst_DidChangeValueForKeyWithSetMutationUsingObjects(void* o, void* key, NSKeyValueSetMutationKind mutationKind, void* objects) {
	@autoreleasepool {
		[(CBDescriptor*)o didChangeValueForKey:key withSetMutation:mutationKind usingObjects:objects];
	}
}
BOOL
CBDescriptor_inst_ValidateValueForKey(void* o, void** ioValue, void* inKey, void** outError) {
	BOOL ret;
	@autoreleasepool {
		ret = [(CBDescriptor*)o validateValue:(id _Nullable* _Nonnull)ioValue forKey:inKey error:(NSError* _Nullable* _Nullable)outError];
		for(int i=0;i<1;i++) {
			if(ioValue[i] == 0) { break; }
			[(id)ioValue[i] retain];
		}
	
	
		for(int i=0;i<1;i++) {
			if(outError[i] == 0) { break; }
			[(id)outError[i] retain];
		}
	
	}
	return ret;

}
BOOL
CBDescriptor_inst_ValidateValueForKeyPath(void* o, void** ioValue, void* inKeyPath, void** outError) {
	BOOL ret;
	@autoreleasepool {
		ret = [(CBDescriptor*)o validateValue:(id _Nullable* _Nonnull)ioValue forKeyPath:inKeyPath error:(NSError* _Nullable* _Nullable)outError];
		for(int i=0;i<1;i++) {
			if(ioValue[i] == 0) { break; }
			[(id)ioValue[i] retain];
		}
	
	
		for(int i=0;i<1;i++) {
			if(outError[i] == 0) { break; }
			[(id)outError[i] retain];
		}
	
	}
	return ret;

}
BOOL
CBDescriptor_inst_ValidateValueForKeyError(void* o, void** ioValue, void* inKey, void** outError) {
	BOOL ret;
	@autoreleasepool {
		ret = [(CBDescriptor*)o validateValue:(id _Nullable* _Nonnull)ioValue forKey:inKey error:(NSError* _Nullable* _Nullable)outError];
		for(int i=0;i<1;i++) {
			if(ioValue[i] == 0) { break; }
			[(id)ioValue[i] retain];
		}
	
	
		for(int i=0;i<1;i++) {
			if(outError[i] == 0) { break; }
			[(id)outError[i] retain];
		}
	
	}
	return ret;

}
BOOL
CBDescriptor_inst_ValidateValueForKeyPathError(void* o, void** ioValue, void* inKeyPath, void** outError) {
	BOOL ret;
	@autoreleasepool {
		ret = [(CBDescriptor*)o validateValue:(id _Nullable* _Nonnull)ioValue forKeyPath:inKeyPath error:(NSError* _Nullable* _Nullable)outError];
		for(int i=0;i<1;i++) {
			if(ioValue[i] == 0) { break; }
			[(id)ioValue[i] retain];
		}
	
	
		for(int i=0;i<1;i++) {
			if(outError[i] == 0) { break; }
			[(id)outError[i] retain];
		}
	
	}
	return ret;

}
BOOL
CBDescriptor_inst_IsGreaterThan(void* o, void* object) {
	BOOL ret;
	@autoreleasepool {
		ret = [(CBDescriptor*)o isGreaterThan:object];
	}
	return ret;

}
void*
CBDescriptor_inst_MutableCopy(void* o) {
	NSObject* ret;
	@autoreleasepool {
		ret = [(CBDescriptor*)o mutableCopy];
	}
	return ret;

}
void
CBDescriptor_inst_ObserveValueForKeyPathOfObject(void* o, void* keyPath, void* object, void* change, void* context) {
	@autoreleasepool {
		[(CBDescriptor*)o observeValueForKeyPath:keyPath ofObject:object change:change context:context];
	}
}
void
CBDescriptor_inst_ObserveValueForKeyPathOfObjectChange(void* o, void* keyPath, void* object, void* change, void* context) {
	@autoreleasepool {
		[(CBDescriptor*)o observeValueForKeyPath:keyPath ofObject:object change:change context:context];
	}
}
void
CBDescriptor_inst_ObserveValueForKeyPathOfObjectChangeContext(void* o, void* keyPath, void* object, void* change, void* context) {
	@autoreleasepool {
		[(CBDescriptor*)o observeValueForKeyPath:keyPath ofObject:object change:change context:context];
	}
}
void
CBDescriptor_inst_PerformSelectorOnMainThreadWithObject(void* o, void* aSelector, void* arg, BOOL wait) {
	@autoreleasepool {
		[(CBDescriptor*)o performSelectorOnMainThread:aSelector withObject:arg waitUntilDone:wait];
	}
}
void
CBDescriptor_inst_PerformSelectorOnMainThreadWithObjectWaitUntilDone(void* o, void* aSelector, void* arg, BOOL wait) {
	@autoreleasepool {
		[(CBDescriptor*)o performSelectorOnMainThread:aSelector withObject:arg waitUntilDone:wait];
	}
}
void
CBDescriptor_inst_PerformSelectorOnMainThreadWithObjectWaitUntilDoneModes(void* o, void* aSelector, void* arg, BOOL wait, void* array) {
	@autoreleasepool {
		[(CBDescriptor*)o performSelectorOnMainThread:aSelector withObject:arg waitUntilDone:wait modes:array];
	}
}
void* _Nonnull
CBDescriptor_inst_MutableOrderedSetValueForKeyPath(void* o, void* keyPath) {
	NSMutableOrderedSet* _Nonnull ret;
	@autoreleasepool {
		ret = [(CBDescriptor*)o mutableOrderedSetValueForKeyPath:keyPath];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
void* _Nullable
CBDescriptor_inst_ReplacementObjectForKeyedArchiver(void* o, void* archiver) {
	NSObject* _Nullable ret;
	@autoreleasepool {
		ret = [(CBDescriptor*)o replacementObjectForKeyedArchiver:archiver];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
BOOL
CBDescriptor_inst_ScriptingIsGreaterThan(void* o, void* object) {
	BOOL ret;
	@autoreleasepool {
		ret = [(CBDescriptor*)o scriptingIsGreaterThan:object];
	}
	return ret;

}
void
CBDescriptor_inst_DoesNotRecognizeSelector(void* o, void* aSelector) {
	@autoreleasepool {
		[(CBDescriptor*)o doesNotRecognizeSelector:aSelector];
	}
}
void* _Nullable
CBDescriptor_inst_NewScriptingObjectOfClassForValueForKey(void* o, void* objectClass, void* key, void* contentsValue, void* properties) {
	NSObject* _Nullable ret;
	@autoreleasepool {
		ret = [(CBDescriptor*)o newScriptingObjectOfClass:objectClass forValueForKey:key withContentsValue:contentsValue properties:properties];
	}
	return ret;

}
void* _Nullable
CBDescriptor_inst_NewScriptingObjectOfClassForValueForKeyWithContentsValue(void* o, void* objectClass, void* key, void* contentsValue, void* properties) {
	NSObject* _Nullable ret;
	@autoreleasepool {
		ret = [(CBDescriptor*)o newScriptingObjectOfClass:objectClass forValueForKey:key withContentsValue:contentsValue properties:properties];
	}
	return ret;

}
void* _Nullable
CBDescriptor_inst_NewScriptingObjectOfClassForValueForKeyWithContentsValueProperties(void* o, void* objectClass, void* key, void* contentsValue, void* properties) {
	NSObject* _Nullable ret;
	@autoreleasepool {
		ret = [(CBDescriptor*)o newScriptingObjectOfClass:objectClass forValueForKey:key withContentsValue:contentsValue properties:properties];
	}
	return ret;

}
BOOL
CBDescriptor_inst_ScriptingIsGreaterThanOrEqualTo(void* o, void* object) {
	BOOL ret;
	@autoreleasepool {
		ret = [(CBDescriptor*)o scriptingIsGreaterThanOrEqualTo:object];
	}
	return ret;

}
void
CBDescriptor_inst_WillChangeValueForKey(void* o, void* key) {
	@autoreleasepool {
		[(CBDescriptor*)o willChangeValueForKey:key];
	}
}
void
CBDescriptor_inst_WillChangeValueForKeyWithSetMutation(void* o, void* key, NSKeyValueSetMutationKind mutationKind, void* objects) {
	@autoreleasepool {
		[(CBDescriptor*)o willChangeValueForKey:key withSetMutation:mutationKind usingObjects:objects];
	}
}
void
CBDescriptor_inst_WillChangeValueForKeyWithSetMutationUsingObjects(void* o, void* key, NSKeyValueSetMutationKind mutationKind, void* objects) {
	@autoreleasepool {
		[(CBDescriptor*)o willChangeValueForKey:key withSetMutation:mutationKind usingObjects:objects];
	}
}
void* _Nullable
CBDescriptor_inst_CopyScriptingValueForKey(void* o, void* value, void* key, void* properties) {
	NSObject* _Nullable ret;
	@autoreleasepool {
		ret = [(CBDescriptor*)o copyScriptingValue:value forKey:key withProperties:properties];
	}
	return ret;

}
void* _Nullable
CBDescriptor_inst_CopyScriptingValueForKeyWithProperties(void* o, void* value, void* key, void* properties) {
	NSObject* _Nullable ret;
	@autoreleasepool {
		ret = [(CBDescriptor*)o copyScriptingValue:value forKey:key withProperties:properties];
	}
	return ret;

}
void* _Nonnull
CBDescriptor_inst_MutableArrayValueForKeyPath(void* o, void* keyPath) {
	NSMutableArray* _Nonnull ret;
	@autoreleasepool {
		ret = [(CBDescriptor*)o mutableArrayValueForKeyPath:keyPath];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
void* _Nullable
CBDescriptor_inst_InverseForRelationshipKey(void* o, void* relationshipKey) {
	NSString* _Nullable ret;
	@autoreleasepool {
		ret = [(CBDescriptor*)o inverseForRelationshipKey:relationshipKey];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
void
CBDescriptor_inst_SetValuesForKeysWithDictionary(void* o, void* keyedValues) {
	@autoreleasepool {
		[(CBDescriptor*)o setValuesForKeysWithDictionary:keyedValues];
	}
}
void
CBDescriptor_inst_RemoveObserverForKeyPath(void* o, void* observer, void* keyPath) {
	@autoreleasepool {
		[(CBDescriptor*)o removeObserver:observer forKeyPath:keyPath];
	}
}
void
CBDescriptor_inst_RemoveObserverForKeyPathContext(void* o, void* observer, void* keyPath, void* context) {
	@autoreleasepool {
		[(CBDescriptor*)o removeObserver:observer forKeyPath:keyPath context:context];
	}
}
void* _Nullable
CBDescriptor_inst_ScriptingProperties(void* o) {
	NSDictionary* _Nullable ret;
	@autoreleasepool {
		ret = [(CBDescriptor*)o scriptingProperties];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
void* _Nonnull
CBUUID_UUIDWithNSUUID(void* theUUID) {
	CBUUID* _Nonnull ret;
	@autoreleasepool {
		ret = [CBUUID UUIDWithNSUUID:theUUID];
		if(ret != nil) { [ret retain]; }
	}
	return ret;

}
void*
CBUUID_Description() {
	NSString* ret;
	@autoreleasepool {
		ret = [CBUUID description];
		if(ret != nil) { [ret retain]; }
	}
	return ret;

}
BOOL
CBUUID_AccessInstanceVariablesDirectly() {
	BOOL ret;
	@autoreleasepool {
		ret = [CBUUID accessInstanceVariablesDirectly];
	}
	return ret;

}
void*
CBUUID_New() {
	CBUUID* ret;
	@autoreleasepool {
		ret = [CBUUID new];
	}
	return ret;

}
void* _Nonnull
CBUUID_KeyPathsForValuesAffectingValueForKey(void* key) {
	NSSet* _Nonnull ret;
	@autoreleasepool {
		ret = [CBUUID keyPathsForValuesAffectingValueForKey:key];
	}
	return ret;

}
BOOL
CBUUID_AutomaticallyNotifiesObserversForKey(void* key) {
	BOOL ret;
	@autoreleasepool {
		ret = [CBUUID automaticallyNotifiesObserversForKey:key];
	}
	return ret;

}
void*
CBUUID_CopyWithZone(void* zone) {
	NSObject* ret;
	@autoreleasepool {
		ret = [CBUUID copyWithZone:zone];
	}
	return ret;

}
BOOL
CBUUID_ConformsToProtocol(void* protocol) {
	BOOL ret;
	@autoreleasepool {
		ret = [CBUUID conformsToProtocol:protocol];
	}
	return ret;

}
void* _Nonnull
CBUUID_UUIDWithString(void* theString) {
	CBUUID* _Nonnull ret;
	@autoreleasepool {
		ret = [CBUUID UUIDWithString:theString];
		if(ret != nil) { [ret retain]; }
	}
	return ret;

}
BOOL
CBUUID_ResolveInstanceMethod(void* sel) {
	BOOL ret;
	@autoreleasepool {
		ret = [CBUUID resolveInstanceMethod:sel];
	}
	return ret;

}
void
CBUUID_CancelPreviousPerformRequestsWithTarget(void* aTarget) {
	@autoreleasepool {
		[CBUUID cancelPreviousPerformRequestsWithTarget:aTarget];
	}
}
void
CBUUID_CancelPreviousPerformRequestsWithTargetSelector(void* aTarget, void* aSelector, void* anArgument) {
	@autoreleasepool {
		[CBUUID cancelPreviousPerformRequestsWithTarget:aTarget selector:aSelector object:anArgument];
	}
}
void
CBUUID_CancelPreviousPerformRequestsWithTargetSelectorObject(void* aTarget, void* aSelector, void* anArgument) {
	@autoreleasepool {
		[CBUUID cancelPreviousPerformRequestsWithTarget:aTarget selector:aSelector object:anArgument];
	}
}
void*
CBUUID_Class() {
	Class ret;
	@autoreleasepool {
		ret = [CBUUID class];
	}
	return ret;

}
void*
CBUUID_Superclass() {
	Class ret;
	@autoreleasepool {
		ret = [CBUUID superclass];
	}
	return ret;

}
NSInteger
CBUUID_Version() {
	NSInteger ret;
	@autoreleasepool {
		ret = [CBUUID version];
	}
	return ret;

}
BOOL
CBUUID_InstancesRespondToSelector(void* aSelector) {
	BOOL ret;
	@autoreleasepool {
		ret = [CBUUID instancesRespondToSelector:aSelector];
	}
	return ret;

}
BOOL
CBUUID_ResolveClassMethod(void* sel) {
	BOOL ret;
	@autoreleasepool {
		ret = [CBUUID resolveClassMethod:sel];
	}
	return ret;

}
void*
CBUUID_MutableCopyWithZone(void* zone) {
	NSObject* ret;
	@autoreleasepool {
		ret = [CBUUID mutableCopyWithZone:zone];
	}
	return ret;

}
void* _Nonnull
CBUUID_ClassFallbacksForKeyedArchiver() {
	NSArray* _Nonnull ret;
	@autoreleasepool {
		ret = [CBUUID classFallbacksForKeyedArchiver];
	}
	return ret;

}
void*
CBUUID_InstanceMethodSignatureForSelector(void* aSelector) {
	NSMethodSignature* ret;
	@autoreleasepool {
		ret = [CBUUID instanceMethodSignatureForSelector:aSelector];
	}
	return ret;

}
void*
CBUUID_DebugDescription() {
	NSString* ret;
	@autoreleasepool {
		ret = [CBUUID debugDescription];
		if(ret != nil) { [ret retain]; }
	}
	return ret;

}
void
CBUUID_SetVersion(NSInteger aVersion) {
	@autoreleasepool {
		[CBUUID setVersion:aVersion];
	}
}
void
CBUUID_Load() {
	@autoreleasepool {
		[CBUUID load];
	}
}
void* _Nonnull
CBUUID_UUIDWithData(void* theData) {
	CBUUID* _Nonnull ret;
	@autoreleasepool {
		ret = [CBUUID UUIDWithData:theData];
		if(ret != nil) { [ret retain]; }
	}
	return ret;

}
BOOL
CBUUID_IsSubclassOfClass(void* aClass) {
	BOOL ret;
	@autoreleasepool {
		ret = [CBUUID isSubclassOfClass:aClass];
	}
	return ret;

}
void*
CBUUID_Alloc() {
	return [CBUUID alloc];
}
NSUInteger
CBUUID_Hash() {
	NSUInteger ret;
	@autoreleasepool {
		ret = [CBUUID hash];
	}
	return ret;

}
void* _Nonnull
CBUUID_ClassForKeyedUnarchiver() {
	Class _Nonnull ret;
	@autoreleasepool {
		ret = [CBUUID classForKeyedUnarchiver];
	}
	return ret;

}
void*
CBUUID_AllocWithZone(void* zone) {
	return [CBUUID allocWithZone:zone];
}
void* _Nullable
CBUUID_inst_ValueForKey(void* o, void* key) {
	NSObject* _Nullable ret;
	@autoreleasepool {
		ret = [(CBUUID*)o valueForKey:key];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
BOOL
CBUUID_inst_IsCaseInsensitiveLike(void* o, void* object) {
	BOOL ret;
	@autoreleasepool {
		ret = [(CBUUID*)o isCaseInsensitiveLike:object];
	}
	return ret;

}
void*
CBUUID_inst_MutableCopy(void* o) {
	NSObject* ret;
	@autoreleasepool {
		ret = [(CBUUID*)o mutableCopy];
	}
	return ret;

}
void* _Nullable
CBUUID_inst_ClassForKeyedArchiver(void* o) {
	Class _Nullable ret;
	@autoreleasepool {
		ret = [(CBUUID*)o classForKeyedArchiver];
	}
	return ret;

}
void
CBUUID_inst_SetScriptingProperties(void* o, void* scriptingProperties) {
	@autoreleasepool {
		[(CBUUID*)o setScriptingProperties:scriptingProperties];
	}
}
void
CBUUID_inst_WillChangeValuesAtIndexes(void* o, NSKeyValueChange changeKind, void* indexes, void* key) {
	@autoreleasepool {
		[(CBUUID*)o willChange:changeKind valuesAtIndexes:indexes forKey:key];
	}
}
void
CBUUID_inst_WillChangeValuesAtIndexesForKey(void* o, NSKeyValueChange changeKind, void* indexes, void* key) {
	@autoreleasepool {
		[(CBUUID*)o willChange:changeKind valuesAtIndexes:indexes forKey:key];
	}
}
void* _Nonnull
CBUUID_inst_AutoContentAccessingProxy(void* o) {
	NSObject* _Nonnull ret;
	@autoreleasepool {
		ret = [(CBUUID*)o autoContentAccessingProxy];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
BOOL
CBUUID_inst_ScriptingBeginsWith(void* o, void* object) {
	BOOL ret;
	@autoreleasepool {
		ret = [(CBUUID*)o scriptingBeginsWith:object];
	}
	return ret;

}
BOOL
CBUUID_inst_IsGreaterThanOrEqualTo(void* o, void* object) {
	BOOL ret;
	@autoreleasepool {
		ret = [(CBUUID*)o isGreaterThanOrEqualTo:object];
	}
	return ret;

}
void
CBUUID_inst_SetValuesForKeysWithDictionary(void* o, void* keyedValues) {
	@autoreleasepool {
		[(CBUUID*)o setValuesForKeysWithDictionary:keyedValues];
	}
}
BOOL
CBUUID_inst_ValidateValueForKey(void* o, void** ioValue, void* inKey, void** outError) {
	BOOL ret;
	@autoreleasepool {
		ret = [(CBUUID*)o validateValue:(id _Nullable* _Nonnull)ioValue forKey:inKey error:(NSError* _Nullable* _Nullable)outError];
		for(int i=0;i<1;i++) {
			if(ioValue[i] == 0) { break; }
			[(id)ioValue[i] retain];
		}
	
	
		for(int i=0;i<1;i++) {
			if(outError[i] == 0) { break; }
			[(id)outError[i] retain];
		}
	
	}
	return ret;

}
BOOL
CBUUID_inst_ValidateValueForKeyPath(void* o, void** ioValue, void* inKeyPath, void** outError) {
	BOOL ret;
	@autoreleasepool {
		ret = [(CBUUID*)o validateValue:(id _Nullable* _Nonnull)ioValue forKeyPath:inKeyPath error:(NSError* _Nullable* _Nullable)outError];
		for(int i=0;i<1;i++) {
			if(ioValue[i] == 0) { break; }
			[(id)ioValue[i] retain];
		}
	
	
		for(int i=0;i<1;i++) {
			if(outError[i] == 0) { break; }
			[(id)outError[i] retain];
		}
	
	}
	return ret;

}
BOOL
CBUUID_inst_ValidateValueForKeyError(void* o, void** ioValue, void* inKey, void** outError) {
	BOOL ret;
	@autoreleasepool {
		ret = [(CBUUID*)o validateValue:(id _Nullable* _Nonnull)ioValue forKey:inKey error:(NSError* _Nullable* _Nullable)outError];
		for(int i=0;i<1;i++) {
			if(ioValue[i] == 0) { break; }
			[(id)ioValue[i] retain];
		}
	
	
		for(int i=0;i<1;i++) {
			if(outError[i] == 0) { break; }
			[(id)outError[i] retain];
		}
	
	}
	return ret;

}
BOOL
CBUUID_inst_ValidateValueForKeyPathError(void* o, void** ioValue, void* inKeyPath, void** outError) {
	BOOL ret;
	@autoreleasepool {
		ret = [(CBUUID*)o validateValue:(id _Nullable* _Nonnull)ioValue forKeyPath:inKeyPath error:(NSError* _Nullable* _Nullable)outError];
		for(int i=0;i<1;i++) {
			if(ioValue[i] == 0) { break; }
			[(id)ioValue[i] retain];
		}
	
	
		for(int i=0;i<1;i++) {
			if(outError[i] == 0) { break; }
			[(id)outError[i] retain];
		}
	
	}
	return ret;

}
BOOL
CBUUID_inst_IsLessThanOrEqualTo(void* o, void* object) {
	BOOL ret;
	@autoreleasepool {
		ret = [(CBUUID*)o isLessThanOrEqualTo:object];
	}
	return ret;

}
void* _Nullable
CBUUID_inst_ReplacementObjectForKeyedArchiver(void* o, void* archiver) {
	NSObject* _Nullable ret;
	@autoreleasepool {
		ret = [(CBUUID*)o replacementObjectForKeyedArchiver:archiver];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
BOOL
CBUUID_inst_ScriptingEndsWith(void* o, void* object) {
	BOOL ret;
	@autoreleasepool {
		ret = [(CBUUID*)o scriptingEndsWith:object];
	}
	return ret;

}
void* _Nullable
CBUUID_inst_ValueWithUniqueIDInPropertyWithKey(void* o, void* uniqueID, void* key) {
	NSObject* _Nullable ret;
	@autoreleasepool {
		ret = [(CBUUID*)o valueWithUniqueID:uniqueID inPropertyWithKey:key];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
void
CBUUID_inst_PerformSelectorOnMainThreadWithObject(void* o, void* aSelector, void* arg, BOOL wait) {
	@autoreleasepool {
		[(CBUUID*)o performSelectorOnMainThread:aSelector withObject:arg waitUntilDone:wait];
	}
}
void
CBUUID_inst_PerformSelectorOnMainThreadWithObjectWaitUntilDone(void* o, void* aSelector, void* arg, BOOL wait) {
	@autoreleasepool {
		[(CBUUID*)o performSelectorOnMainThread:aSelector withObject:arg waitUntilDone:wait];
	}
}
void
CBUUID_inst_PerformSelectorOnMainThreadWithObjectWaitUntilDoneModes(void* o, void* aSelector, void* arg, BOOL wait, void* array) {
	@autoreleasepool {
		[(CBUUID*)o performSelectorOnMainThread:aSelector withObject:arg waitUntilDone:wait modes:array];
	}
}
BOOL
CBUUID_inst_IsLike(void* o, void* object) {
	BOOL ret;
	@autoreleasepool {
		ret = [(CBUUID*)o isLike:object];
	}
	return ret;

}
void* _Nonnull
CBUUID_inst_ClassDescription(void* o) {
	NSClassDescription* _Nonnull ret;
	@autoreleasepool {
		ret = [(CBUUID*)o classDescription];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
BOOL
CBUUID_inst_DoesContain(void* o, void* object) {
	BOOL ret;
	@autoreleasepool {
		ret = [(CBUUID*)o doesContain:object];
	}
	return ret;

}
void* _Nullable
CBUUID_inst_ReplacementObjectForCoder(void* o, void* coder) {
	NSObject* _Nullable ret;
	@autoreleasepool {
		ret = [(CBUUID*)o replacementObjectForCoder:coder];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
void
CBUUID_inst_WillChangeValueForKey(void* o, void* key) {
	@autoreleasepool {
		[(CBUUID*)o willChangeValueForKey:key];
	}
}
void
CBUUID_inst_WillChangeValueForKeyWithSetMutation(void* o, void* key, NSKeyValueSetMutationKind mutationKind, void* objects) {
	@autoreleasepool {
		[(CBUUID*)o willChangeValueForKey:key withSetMutation:mutationKind usingObjects:objects];
	}
}
void
CBUUID_inst_WillChangeValueForKeyWithSetMutationUsingObjects(void* o, void* key, NSKeyValueSetMutationKind mutationKind, void* objects) {
	@autoreleasepool {
		[(CBUUID*)o willChangeValueForKey:key withSetMutation:mutationKind usingObjects:objects];
	}
}
void* _Nonnull
CBUUID_inst_MutableOrderedSetValueForKey(void* o, void* key) {
	NSMutableOrderedSet* _Nonnull ret;
	@autoreleasepool {
		ret = [(CBUUID*)o mutableOrderedSetValueForKey:key];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
BOOL
CBUUID_inst_ScriptingIsEqualTo(void* o, void* object) {
	BOOL ret;
	@autoreleasepool {
		ret = [(CBUUID*)o scriptingIsEqualTo:object];
	}
	return ret;

}
BOOL
CBUUID_inst_IsEqualTo(void* o, void* object) {
	BOOL ret;
	@autoreleasepool {
		ret = [(CBUUID*)o isEqualTo:object];
	}
	return ret;

}
void* _Nonnull
CBUUID_inst_DictionaryWithValuesForKeys(void* o, void* keys) {
	NSDictionary* _Nonnull ret;
	@autoreleasepool {
		ret = [(CBUUID*)o dictionaryWithValuesForKeys:keys];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
void* _Nonnull
CBUUID_inst_ToManyRelationshipKeys(void* o) {
	NSArray* _Nonnull ret;
	@autoreleasepool {
		ret = [(CBUUID*)o toManyRelationshipKeys];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
void* _Nullable
CBUUID_inst_AwakeAfterUsingCoder(void* o, void* coder) {
	NSObject* _Nullable ret;
	@autoreleasepool {
		ret = [(CBUUID*)o awakeAfterUsingCoder:coder];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
void* _Nullable
CBUUID_inst_ValueAtIndexInPropertyWithKey(void* o, NSUInteger index, void* key) {
	NSObject* _Nullable ret;
	@autoreleasepool {
		ret = [(CBUUID*)o valueAtIndex:index inPropertyWithKey:key];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
void* _Nullable
CBUUID_inst_ClassForArchiver(void* o) {
	Class _Nullable ret;
	@autoreleasepool {
		ret = [(CBUUID*)o classForArchiver];
	}
	return ret;

}
void
CBUUID_inst_ReplaceValueAtIndexInPropertyWithKey(void* o, NSUInteger index, void* key, void* value) {
	@autoreleasepool {
		[(CBUUID*)o replaceValueAtIndex:index inPropertyWithKey:key withValue:value];
	}
}
void
CBUUID_inst_ReplaceValueAtIndexInPropertyWithKeyWithValue(void* o, NSUInteger index, void* key, void* value) {
	@autoreleasepool {
		[(CBUUID*)o replaceValueAtIndex:index inPropertyWithKey:key withValue:value];
	}
}
void
CBUUID_inst_SetNilValueForKey(void* o, void* key) {
	@autoreleasepool {
		[(CBUUID*)o setNilValueForKey:key];
	}
}
FourCharCode
CBUUID_inst_ClassCode(void* o) {
	FourCharCode ret;
	@autoreleasepool {
		ret = [(CBUUID*)o classCode];
	}
	return ret;

}
void
CBUUID_inst_DidChangeValuesAtIndexes(void* o, NSKeyValueChange changeKind, void* indexes, void* key) {
	@autoreleasepool {
		[(CBUUID*)o didChange:changeKind valuesAtIndexes:indexes forKey:key];
	}
}
void
CBUUID_inst_DidChangeValuesAtIndexesForKey(void* o, NSKeyValueChange changeKind, void* indexes, void* key) {
	@autoreleasepool {
		[(CBUUID*)o didChange:changeKind valuesAtIndexes:indexes forKey:key];
	}
}
void* _Nullable
CBUUID_inst_NewScriptingObjectOfClassForValueForKey(void* o, void* objectClass, void* key, void* contentsValue, void* properties) {
	NSObject* _Nullable ret;
	@autoreleasepool {
		ret = [(CBUUID*)o newScriptingObjectOfClass:objectClass forValueForKey:key withContentsValue:contentsValue properties:properties];
	}
	return ret;

}
void* _Nullable
CBUUID_inst_NewScriptingObjectOfClassForValueForKeyWithContentsValue(void* o, void* objectClass, void* key, void* contentsValue, void* properties) {
	NSObject* _Nullable ret;
	@autoreleasepool {
		ret = [(CBUUID*)o newScriptingObjectOfClass:objectClass forValueForKey:key withContentsValue:contentsValue properties:properties];
	}
	return ret;

}
void* _Nonnull
CBUUID_inst_ToOneRelationshipKeys(void* o) {
	NSArray* _Nonnull ret;
	@autoreleasepool {
		ret = [(CBUUID*)o toOneRelationshipKeys];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
void* _Nonnull
CBUUID_inst_MutableArrayValueForKeyPath(void* o, void* keyPath) {
	NSMutableArray* _Nonnull ret;
	@autoreleasepool {
		ret = [(CBUUID*)o mutableArrayValueForKeyPath:keyPath];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
void
CBUUID_inst_ForwardInvocation(void* o, void* anInvocation) {
	@autoreleasepool {
		[(CBUUID*)o forwardInvocation:anInvocation];
	}
}
BOOL
CBUUID_inst_IsLessThan(void* o, void* object) {
	BOOL ret;
	@autoreleasepool {
		ret = [(CBUUID*)o isLessThan:object];
	}
	return ret;

}
void
CBUUID_inst_DidChangeValueForKey(void* o, void* key) {
	@autoreleasepool {
		[(CBUUID*)o didChangeValueForKey:key];
	}
}
void
CBUUID_inst_DidChangeValueForKeyWithSetMutation(void* o, void* key, NSKeyValueSetMutationKind mutationKind, void* objects) {
	@autoreleasepool {
		[(CBUUID*)o didChangeValueForKey:key withSetMutation:mutationKind usingObjects:objects];
	}
}
void
CBUUID_inst_DidChangeValueForKeyWithSetMutationUsingObjects(void* o, void* key, NSKeyValueSetMutationKind mutationKind, void* objects) {
	@autoreleasepool {
		[(CBUUID*)o didChangeValueForKey:key withSetMutation:mutationKind usingObjects:objects];
	}
}
void* _Nullable
CBUUID_inst_InverseForRelationshipKey(void* o, void* relationshipKey) {
	NSString* _Nullable ret;
	@autoreleasepool {
		ret = [(CBUUID*)o inverseForRelationshipKey:relationshipKey];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
void*
CBUUID_inst_Init(void* o) {
	CBUUID* ret;
	@autoreleasepool {
		ret = [(CBUUID*)o init];
	}
	return ret;

}
void* _Nonnull
CBUUID_inst_MutableSetValueForKeyPath(void* o, void* keyPath) {
	NSMutableSet* _Nonnull ret;
	@autoreleasepool {
		ret = [(CBUUID*)o mutableSetValueForKeyPath:keyPath];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
void* _Nullable
CBUUID_inst_ObjectSpecifier(void* o) {
	NSScriptObjectSpecifier* _Nullable ret;
	@autoreleasepool {
		ret = [(CBUUID*)o objectSpecifier];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
void* _Nullable
CBUUID_inst_CopyScriptingValueForKey(void* o, void* value, void* key, void* properties) {
	NSObject* _Nullable ret;
	@autoreleasepool {
		ret = [(CBUUID*)o copyScriptingValue:value forKey:key withProperties:properties];
	}
	return ret;

}
void* _Nullable
CBUUID_inst_CopyScriptingValueForKeyWithProperties(void* o, void* value, void* key, void* properties) {
	NSObject* _Nullable ret;
	@autoreleasepool {
		ret = [(CBUUID*)o copyScriptingValue:value forKey:key withProperties:properties];
	}
	return ret;

}
void* _Nullable
CBUUID_inst_CoerceValueForKey(void* o, void* value, void* key) {
	NSObject* _Nullable ret;
	@autoreleasepool {
		ret = [(CBUUID*)o coerceValue:value forKey:key];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
BOOL
CBUUID_inst_IsGreaterThan(void* o, void* object) {
	BOOL ret;
	@autoreleasepool {
		ret = [(CBUUID*)o isGreaterThan:object];
	}
	return ret;

}
void* _Nonnull
CBUUID_inst_ClassName(void* o) {
	NSString* _Nonnull ret;
	@autoreleasepool {
		ret = [(CBUUID*)o className];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
void
CBUUID_inst_RemoveValueAtIndexFromPropertyWithKey(void* o, NSUInteger index, void* key) {
	@autoreleasepool {
		[(CBUUID*)o removeValueAtIndex:index fromPropertyWithKey:key];
	}
}
BOOL
CBUUID_inst_ScriptingIsLessThan(void* o, void* object) {
	BOOL ret;
	@autoreleasepool {
		ret = [(CBUUID*)o scriptingIsLessThan:object];
	}
	return ret;

}
void
CBUUID_inst_Dealloc(void* o) {
	@autoreleasepool {
		[(CBUUID*)o dealloc];
	}
}
void
CBUUID_inst_RemoveObserverForKeyPath(void* o, void* observer, void* keyPath) {
	@autoreleasepool {
		[(CBUUID*)o removeObserver:observer forKeyPath:keyPath];
	}
}
void
CBUUID_inst_RemoveObserverForKeyPathContext(void* o, void* observer, void* keyPath, void* context) {
	@autoreleasepool {
		[(CBUUID*)o removeObserver:observer forKeyPath:keyPath context:context];
	}
}
void
CBUUID_inst_AddObserverForKeyPath(void* o, void* observer, void* keyPath, NSKeyValueObservingOptions options, void* context) {
	@autoreleasepool {
		[(CBUUID*)o addObserver:observer forKeyPath:keyPath options:options context:context];
	}
}
void
CBUUID_inst_AddObserverForKeyPathOptions(void* o, void* observer, void* keyPath, NSKeyValueObservingOptions options, void* context) {
	@autoreleasepool {
		[(CBUUID*)o addObserver:observer forKeyPath:keyPath options:options context:context];
	}
}
void
CBUUID_inst_PerformSelectorWithObject(void* o, void* aSelector, void* anArgument, NSTimeInterval delay) {
	@autoreleasepool {
		[(CBUUID*)o performSelector:aSelector withObject:anArgument afterDelay:delay];
	}
}
void
CBUUID_inst_PerformSelectorWithObjectAfterDelay(void* o, void* aSelector, void* anArgument, NSTimeInterval delay) {
	@autoreleasepool {
		[(CBUUID*)o performSelector:aSelector withObject:anArgument afterDelay:delay];
	}
}
void
CBUUID_inst_PerformSelectorWithObjectAfterDelayInModes(void* o, void* aSelector, void* anArgument, NSTimeInterval delay, void* modes) {
	@autoreleasepool {
		[(CBUUID*)o performSelector:aSelector withObject:anArgument afterDelay:delay inModes:modes];
	}
}
void
CBUUID_inst_PerformSelectorOnThread(void* o, void* aSelector, void* thr, void* arg, BOOL wait) {
	@autoreleasepool {
		[(CBUUID*)o performSelector:aSelector onThread:thr withObject:arg waitUntilDone:wait];
	}
}
void
CBUUID_inst_PerformSelectorOnThreadWithObject(void* o, void* aSelector, void* thr, void* arg, BOOL wait) {
	@autoreleasepool {
		[(CBUUID*)o performSelector:aSelector onThread:thr withObject:arg waitUntilDone:wait];
	}
}
void
CBUUID_inst_PerformSelectorOnThreadWithObjectWaitUntilDone(void* o, void* aSelector, void* thr, void* arg, BOOL wait, void* array) {
	@autoreleasepool {
		[(CBUUID*)o performSelector:aSelector onThread:thr withObject:arg waitUntilDone:wait modes:array];
	}
}
void
CBUUID_inst_PerformSelectorOnThreadWithObjectWaitUntilDoneModes(void* o, void* aSelector, void* thr, void* arg, BOOL wait, void* array) {
	@autoreleasepool {
		[(CBUUID*)o performSelector:aSelector onThread:thr withObject:arg waitUntilDone:wait modes:array];
	}
}
BOOL
CBUUID_inst_ScriptingIsLessThanOrEqualTo(void* o, void* object) {
	BOOL ret;
	@autoreleasepool {
		ret = [(CBUUID*)o scriptingIsLessThanOrEqualTo:object];
	}
	return ret;

}
void* _Nonnull
CBUUID_inst_ClassForCoder(void* o) {
	Class _Nonnull ret;
	@autoreleasepool {
		ret = [(CBUUID*)o classForCoder];
	}
	return ret;

}
void* _Nonnull
CBUUID_inst_MutableArrayValueForKey(void* o, void* key) {
	NSMutableArray* _Nonnull ret;
	@autoreleasepool {
		ret = [(CBUUID*)o mutableArrayValueForKey:key];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
void
CBUUID_inst_ObserveValueForKeyPathOfObject(void* o, void* keyPath, void* object, void* change, void* context) {
	@autoreleasepool {
		[(CBUUID*)o observeValueForKeyPath:keyPath ofObject:object change:change context:context];
	}
}
void
CBUUID_inst_ObserveValueForKeyPathOfObjectChange(void* o, void* keyPath, void* object, void* change, void* context) {
	@autoreleasepool {
		[(CBUUID*)o observeValueForKeyPath:keyPath ofObject:object change:change context:context];
	}
}
void* _Nonnull
CBUUID_inst_MutableSetValueForKey(void* o, void* key) {
	NSMutableSet* _Nonnull ret;
	@autoreleasepool {
		ret = [(CBUUID*)o mutableSetValueForKey:key];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
void* _Nonnull
CBUUID_inst_AttributeKeys(void* o) {
	NSArray* _Nonnull ret;
	@autoreleasepool {
		ret = [(CBUUID*)o attributeKeys];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
void* _Nonnull
CBUUID_inst_CopyWithZone(void* o, void* zone) {
	NSObject* _Nonnull ret;
	@autoreleasepool {
		ret = [(CBUUID*)o copyWithZone:zone];
	}
	return ret;

}
void* _Nullable
CBUUID_inst_ScriptingValueForSpecifier(void* o, void* objectSpecifier) {
	NSObject* _Nullable ret;
	@autoreleasepool {
		ret = [(CBUUID*)o scriptingValueForSpecifier:objectSpecifier];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
void
CBUUID_inst_InsertValueInPropertyWithKey(void* o, void* value, void* key) {
	@autoreleasepool {
		[(CBUUID*)o insertValue:value inPropertyWithKey:key];
	}
}
void
CBUUID_inst_InsertValueAtIndex(void* o, void* value, NSUInteger index, void* key) {
	@autoreleasepool {
		[(CBUUID*)o insertValue:value atIndex:index inPropertyWithKey:key];
	}
}
void
CBUUID_inst_InsertValueAtIndexInPropertyWithKey(void* o, void* value, NSUInteger index, void* key) {
	@autoreleasepool {
		[(CBUUID*)o insertValue:value atIndex:index inPropertyWithKey:key];
	}
}
void* _Nullable
CBUUID_inst_ValueForUndefinedKey(void* o, void* key) {
	NSObject* _Nullable ret;
	@autoreleasepool {
		ret = [(CBUUID*)o valueForUndefinedKey:key];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
void
CBUUID_inst_PerformSelectorInBackgroundWithObject(void* o, void* aSelector, void* arg) {
	@autoreleasepool {
		[(CBUUID*)o performSelectorInBackground:aSelector withObject:arg];
	}
}
void* _Nullable
CBUUID_inst_ScriptingProperties(void* o) {
	NSDictionary* _Nullable ret;
	@autoreleasepool {
		ret = [(CBUUID*)o scriptingProperties];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
BOOL
CBUUID_inst_ScriptingIsGreaterThan(void* o, void* object) {
	BOOL ret;
	@autoreleasepool {
		ret = [(CBUUID*)o scriptingIsGreaterThan:object];
	}
	return ret;

}
void* _Nonnull
CBUUID_inst_MutableOrderedSetValueForKeyPath(void* o, void* keyPath) {
	NSMutableOrderedSet* _Nonnull ret;
	@autoreleasepool {
		ret = [(CBUUID*)o mutableOrderedSetValueForKeyPath:keyPath];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
BOOL
CBUUID_inst_IsNotEqualTo(void* o, void* object) {
	BOOL ret;
	@autoreleasepool {
		ret = [(CBUUID*)o isNotEqualTo:object];
	}
	return ret;

}
BOOL
CBUUID_inst_AttemptRecoveryFromErrorOptionIndex(void* o, void* error, NSUInteger recoveryOptionIndex) {
	BOOL ret;
	@autoreleasepool {
		ret = [(CBUUID*)o attemptRecoveryFromError:error optionIndex:recoveryOptionIndex];
	}
	return ret;

}
void
CBUUID_inst_AttemptRecoveryFromErrorOptionIndexDelegate(void* o, void* error, NSUInteger recoveryOptionIndex, void* delegate, void* didRecoverSelector, void* contextInfo) {
	@autoreleasepool {
		[(CBUUID*)o attemptRecoveryFromError:error optionIndex:recoveryOptionIndex delegate:delegate didRecoverSelector:didRecoverSelector contextInfo:contextInfo];
	}
}
void
CBUUID_inst_AttemptRecoveryFromErrorOptionIndexDelegateDidRecoverSelector(void* o, void* error, NSUInteger recoveryOptionIndex, void* delegate, void* didRecoverSelector, void* contextInfo) {
	@autoreleasepool {
		[(CBUUID*)o attemptRecoveryFromError:error optionIndex:recoveryOptionIndex delegate:delegate didRecoverSelector:didRecoverSelector contextInfo:contextInfo];
	}
}
void*
CBUUID_inst_MethodSignatureForSelector(void* o, void* aSelector) {
	NSMethodSignature* ret;
	@autoreleasepool {
		ret = [(CBUUID*)o methodSignatureForSelector:aSelector];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
void* _Nullable
CBUUID_inst_IndicesOfObjectsByEvaluatingObjectSpecifier(void* o, void* specifier) {
	NSArray* _Nullable ret;
	@autoreleasepool {
		ret = [(CBUUID*)o indicesOfObjectsByEvaluatingObjectSpecifier:specifier];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
void
CBUUID_inst_SetValueForKey(void* o, void* value, void* key) {
	@autoreleasepool {
		[(CBUUID*)o setValue:value forKey:key];
	}
}
void
CBUUID_inst_SetValueForKeyPath(void* o, void* value, void* keyPath) {
	@autoreleasepool {
		[(CBUUID*)o setValue:value forKeyPath:keyPath];
	}
}
void
CBUUID_inst_SetValueForUndefinedKey(void* o, void* value, void* key) {
	@autoreleasepool {
		[(CBUUID*)o setValue:value forUndefinedKey:key];
	}
}
void* _Nullable
CBUUID_inst_ValueWithNameInPropertyWithKey(void* o, void* name, void* key) {
	NSObject* _Nullable ret;
	@autoreleasepool {
		ret = [(CBUUID*)o valueWithName:name inPropertyWithKey:key];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
void* _Nonnull
CBUUID_inst_Data(void* o) {
	NSData* _Nonnull ret;
	@autoreleasepool {
		ret = [(CBUUID*)o data];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
void*
CBUUID_inst_UUIDString(void* o) {
	NSString* ret;
	@autoreleasepool {
		ret = [(CBUUID*)o UUIDString];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
BOOL
CBUUID_inst_ScriptingIsGreaterThanOrEqualTo(void* o, void* object) {
	BOOL ret;
	@autoreleasepool {
		ret = [(CBUUID*)o scriptingIsGreaterThanOrEqualTo:object];
	}
	return ret;

}
void
CBUUID_inst_DoesNotRecognizeSelector(void* o, void* aSelector) {
	@autoreleasepool {
		[(CBUUID*)o doesNotRecognizeSelector:aSelector];
	}
}
void
CBUUID_inst_SetObservationInfo(void* o, void* observationInfo) {
	@autoreleasepool {
		[(CBUUID*)o setObservationInfo:observationInfo];
	}
}
void* _Nullable
CBUUID_inst_ValueForKeyPath(void* o, void* keyPath) {
	NSObject* _Nullable ret;
	@autoreleasepool {
		ret = [(CBUUID*)o valueForKeyPath:keyPath];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
void*
CBUUID_inst_Copy(void* o) {
	NSObject* ret;
	@autoreleasepool {
		ret = [(CBUUID*)o copy];
	}
	return ret;

}
void*
CBUUID_inst_ForwardingTargetForSelector(void* o, void* aSelector) {
	NSObject* ret;
	@autoreleasepool {
		ret = [(CBUUID*)o forwardingTargetForSelector:aSelector];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
void*
CBUUID_inst_ObservationInfo(void* o) {
	void* ret;
	@autoreleasepool {
		ret = [(CBUUID*)o observationInfo];
	}
	return ret;

}
BOOL
CBUUID_inst_ScriptingContains(void* o, void* object) {
	BOOL ret;
	@autoreleasepool {
		ret = [(CBUUID*)o scriptingContains:object];
	}
	return ret;

}
void* _Nonnull
NSNumber_NumberWithUnsignedShort(unsigned short value) {
	NSNumber* _Nonnull ret;
	@autoreleasepool {
		ret = [NSNumber numberWithUnsignedShort:value];
		if(ret != nil) { [ret retain]; }
	}
	return ret;

}
void*
NSNumber_New() {
	NSNumber* ret;
	@autoreleasepool {
		ret = [NSNumber new];
	}
	return ret;

}
void* _Nonnull
NSNumber_ValueWithObjCType(void* value, void* type) {
	NSValue* _Nonnull ret;
	@autoreleasepool {
		ret = [NSNumber value:value withObjCType:type];
	}
	return ret;

}
void*
NSNumber_DebugDescription() {
	NSString* ret;
	@autoreleasepool {
		ret = [NSNumber debugDescription];
	}
	return ret;

}
NSInteger
NSNumber_Version() {
	NSInteger ret;
	@autoreleasepool {
		ret = [NSNumber version];
	}
	return ret;

}
void* _Nonnull
NSNumber_KeyPathsForValuesAffectingValueForKey(void* key) {
	NSSet* _Nonnull ret;
	@autoreleasepool {
		ret = [NSNumber keyPathsForValuesAffectingValueForKey:key];
	}
	return ret;

}
void* _Nonnull
NSNumber_NumberWithInteger(NSInteger value) {
	NSNumber* _Nonnull ret;
	@autoreleasepool {
		ret = [NSNumber numberWithInteger:value];
		if(ret != nil) { [ret retain]; }
	}
	return ret;

}
void* _Nonnull
NSNumber_NumberWithDouble(double value) {
	NSNumber* _Nonnull ret;
	@autoreleasepool {
		ret = [NSNumber numberWithDouble:value];
		if(ret != nil) { [ret retain]; }
	}
	return ret;

}
void* _Nonnull
NSNumber_ValueWithNonretainedObject(void* anObject) {
	NSValue* _Nonnull ret;
	@autoreleasepool {
		ret = [NSNumber valueWithNonretainedObject:anObject];
	}
	return ret;

}
void* _Nonnull
NSNumber_ValueWithSize(NSSize size) {
	NSValue* _Nonnull ret;
	@autoreleasepool {
		ret = [NSNumber valueWithSize:size];
	}
	return ret;

}
void* _Nonnull
NSNumber_ClassForKeyedUnarchiver() {
	Class _Nonnull ret;
	@autoreleasepool {
		ret = [NSNumber classForKeyedUnarchiver];
	}
	return ret;

}
void* _Nonnull
NSNumber_NumberWithUnsignedChar(unsigned char value) {
	NSNumber* _Nonnull ret;
	@autoreleasepool {
		ret = [NSNumber numberWithUnsignedChar:value];
		if(ret != nil) { [ret retain]; }
	}
	return ret;

}
void* _Nonnull
NSNumber_NumberWithUnsignedLong(unsigned long value) {
	NSNumber* _Nonnull ret;
	@autoreleasepool {
		ret = [NSNumber numberWithUnsignedLong:value];
		if(ret != nil) { [ret retain]; }
	}
	return ret;

}
BOOL
NSNumber_ResolveClassMethod(void* sel) {
	BOOL ret;
	@autoreleasepool {
		ret = [NSNumber resolveClassMethod:sel];
	}
	return ret;

}
BOOL
NSNumber_AutomaticallyNotifiesObserversForKey(void* key) {
	BOOL ret;
	@autoreleasepool {
		ret = [NSNumber automaticallyNotifiesObserversForKey:key];
	}
	return ret;

}
void*
NSNumber_CopyWithZone(void* zone) {
	NSObject* ret;
	@autoreleasepool {
		ret = [NSNumber copyWithZone:zone];
	}
	return ret;

}
void*
NSNumber_Description() {
	NSString* ret;
	@autoreleasepool {
		ret = [NSNumber description];
	}
	return ret;

}
void*
NSNumber_MutableCopyWithZone(void* zone) {
	NSObject* ret;
	@autoreleasepool {
		ret = [NSNumber mutableCopyWithZone:zone];
	}
	return ret;

}
void*
NSNumber_Superclass() {
	Class ret;
	@autoreleasepool {
		ret = [NSNumber superclass];
	}
	return ret;

}
void* _Nonnull
NSNumber_NumberWithUnsignedInteger(NSUInteger value) {
	NSNumber* _Nonnull ret;
	@autoreleasepool {
		ret = [NSNumber numberWithUnsignedInteger:value];
		if(ret != nil) { [ret retain]; }
	}
	return ret;

}
void* _Nonnull
NSNumber_NumberWithChar(char value) {
	NSNumber* _Nonnull ret;
	@autoreleasepool {
		ret = [NSNumber numberWithChar:value];
		if(ret != nil) { [ret retain]; }
	}
	return ret;

}
void* _Nonnull
NSNumber_NumberWithBool(BOOL value) {
	NSNumber* _Nonnull ret;
	@autoreleasepool {
		ret = [NSNumber numberWithBool:value];
		if(ret != nil) { [ret retain]; }
	}
	return ret;

}
void
NSNumber_CancelPreviousPerformRequestsWithTarget(void* aTarget) {
	@autoreleasepool {
		[NSNumber cancelPreviousPerformRequestsWithTarget:aTarget];
	}
}
void
NSNumber_CancelPreviousPerformRequestsWithTargetSelector(void* aTarget, void* aSelector, void* anArgument) {
	@autoreleasepool {
		[NSNumber cancelPreviousPerformRequestsWithTarget:aTarget selector:aSelector object:anArgument];
	}
}
void
NSNumber_CancelPreviousPerformRequestsWithTargetSelectorObject(void* aTarget, void* aSelector, void* anArgument) {
	@autoreleasepool {
		[NSNumber cancelPreviousPerformRequestsWithTarget:aTarget selector:aSelector object:anArgument];
	}
}
BOOL
NSNumber_AccessInstanceVariablesDirectly() {
	BOOL ret;
	@autoreleasepool {
		ret = [NSNumber accessInstanceVariablesDirectly];
	}
	return ret;

}
void* _Nonnull
NSNumber_ClassFallbacksForKeyedArchiver() {
	NSArray* _Nonnull ret;
	@autoreleasepool {
		ret = [NSNumber classFallbacksForKeyedArchiver];
	}
	return ret;

}
void
NSNumber_SetVersion(NSInteger aVersion) {
	@autoreleasepool {
		[NSNumber setVersion:aVersion];
	}
}
void*
NSNumber_InstanceMethodSignatureForSelector(void* aSelector) {
	NSMethodSignature* ret;
	@autoreleasepool {
		ret = [NSNumber instanceMethodSignatureForSelector:aSelector];
	}
	return ret;

}
void* _Nonnull
NSNumber_NumberWithLong(long value) {
	NSNumber* _Nonnull ret;
	@autoreleasepool {
		ret = [NSNumber numberWithLong:value];
		if(ret != nil) { [ret retain]; }
	}
	return ret;

}
void* _Nonnull
NSNumber_NumberWithLongLong(long long value) {
	NSNumber* _Nonnull ret;
	@autoreleasepool {
		ret = [NSNumber numberWithLongLong:value];
		if(ret != nil) { [ret retain]; }
	}
	return ret;

}
void* _Nonnull
NSNumber_NumberWithFloat(float value) {
	NSNumber* _Nonnull ret;
	@autoreleasepool {
		ret = [NSNumber numberWithFloat:value];
		if(ret != nil) { [ret retain]; }
	}
	return ret;

}
void* _Nonnull
NSNumber_ValueWithRange(NSRange range) {
	NSValue* _Nonnull ret;
	@autoreleasepool {
		ret = [NSNumber valueWithRange:range];
	}
	return ret;

}
NSUInteger
NSNumber_Hash() {
	NSUInteger ret;
	@autoreleasepool {
		ret = [NSNumber hash];
	}
	return ret;

}
void*
NSNumber_Class() {
	Class ret;
	@autoreleasepool {
		ret = [NSNumber class];
	}
	return ret;

}
void* _Nonnull
NSNumber_NumberWithUnsignedLongLong(unsigned long long value) {
	NSNumber* _Nonnull ret;
	@autoreleasepool {
		ret = [NSNumber numberWithUnsignedLongLong:value];
		if(ret != nil) { [ret retain]; }
	}
	return ret;

}
void* _Nonnull
NSNumber_ValueWithEdgeInsets(NSEdgeInsets insets) {
	NSValue* _Nonnull ret;
	@autoreleasepool {
		ret = [NSNumber valueWithEdgeInsets:insets];
	}
	return ret;

}
void* _Nonnull
NSNumber_ValueWithPoint(NSPoint point) {
	NSValue* _Nonnull ret;
	@autoreleasepool {
		ret = [NSNumber valueWithPoint:point];
	}
	return ret;

}
void*
NSNumber_Alloc() {
	return [NSNumber alloc];
}
void*
NSNumber_AllocWithZone(void* zone) {
	return [NSNumber allocWithZone:zone];
}
BOOL
NSNumber_InstancesRespondToSelector(void* aSelector) {
	BOOL ret;
	@autoreleasepool {
		ret = [NSNumber instancesRespondToSelector:aSelector];
	}
	return ret;

}
BOOL
NSNumber_ConformsToProtocol(void* protocol) {
	BOOL ret;
	@autoreleasepool {
		ret = [NSNumber conformsToProtocol:protocol];
	}
	return ret;

}
void
NSNumber_Load() {
	@autoreleasepool {
		[NSNumber load];
	}
}
void* _Nonnull
NSNumber_NumberWithUnsignedInt(unsigned int value) {
	NSNumber* _Nonnull ret;
	@autoreleasepool {
		ret = [NSNumber numberWithUnsignedInt:value];
		if(ret != nil) { [ret retain]; }
	}
	return ret;

}
void* _Nonnull
NSNumber_NumberWithShort(short value) {
	NSNumber* _Nonnull ret;
	@autoreleasepool {
		ret = [NSNumber numberWithShort:value];
		if(ret != nil) { [ret retain]; }
	}
	return ret;

}
void* _Nonnull
NSNumber_ValueWithPointer(void* pointer) {
	NSValue* _Nonnull ret;
	@autoreleasepool {
		ret = [NSNumber valueWithPointer:pointer];
	}
	return ret;

}
BOOL
NSNumber_ResolveInstanceMethod(void* sel) {
	BOOL ret;
	@autoreleasepool {
		ret = [NSNumber resolveInstanceMethod:sel];
	}
	return ret;

}
void* _Nonnull
NSNumber_NumberWithInt(int value) {
	NSNumber* _Nonnull ret;
	@autoreleasepool {
		ret = [NSNumber numberWithInt:value];
		if(ret != nil) { [ret retain]; }
	}
	return ret;

}
void* _Nonnull
NSNumber_ValueWithRect(NSRect rect) {
	NSValue* _Nonnull ret;
	@autoreleasepool {
		ret = [NSNumber valueWithRect:rect];
	}
	return ret;

}
void* _Nonnull
NSNumber_ValueWithBytesObjCType(void* value, void* type) {
	NSValue* _Nonnull ret;
	@autoreleasepool {
		ret = [NSNumber valueWithBytes:value objCType:type];
	}
	return ret;

}
BOOL
NSNumber_IsSubclassOfClass(void* aClass) {
	BOOL ret;
	@autoreleasepool {
		ret = [NSNumber isSubclassOfClass:aClass];
	}
	return ret;

}
void* _Nonnull
NSNumber_inst_MutableOrderedSetValueForKey(void* o, void* key) {
	NSMutableOrderedSet* _Nonnull ret;
	@autoreleasepool {
		ret = [(NSNumber*)o mutableOrderedSetValueForKey:key];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
void* _Nullable
NSNumber_inst_CopyScriptingValueForKey(void* o, void* value, void* key, void* properties) {
	NSObject* _Nullable ret;
	@autoreleasepool {
		ret = [(NSNumber*)o copyScriptingValue:value forKey:key withProperties:properties];
	}
	return ret;

}
void* _Nullable
NSNumber_inst_CopyScriptingValueForKeyWithProperties(void* o, void* value, void* key, void* properties) {
	NSObject* _Nullable ret;
	@autoreleasepool {
		ret = [(NSNumber*)o copyScriptingValue:value forKey:key withProperties:properties];
	}
	return ret;

}
void
NSNumber_inst_SetNilValueForKey(void* o, void* key) {
	@autoreleasepool {
		[(NSNumber*)o setNilValueForKey:key];
	}
}
void
NSNumber_inst_SetValuesForKeysWithDictionary(void* o, void* keyedValues) {
	@autoreleasepool {
		[(NSNumber*)o setValuesForKeysWithDictionary:keyedValues];
	}
}
double
NSNumber_inst_DoubleValue(void* o) {
	double ret;
	@autoreleasepool {
		ret = [(NSNumber*)o doubleValue];
	}
	return ret;

}
void* _Nonnull
NSNumber_inst_InitWithBool(void* o, BOOL value) {
	NSNumber* _Nonnull ret;
	@autoreleasepool {
		ret = [(NSNumber*)o initWithBool:value];
	}
	return ret;

}
void* _Nonnull
NSNumber_inst_InitWithShort(void* o, short value) {
	NSNumber* _Nonnull ret;
	@autoreleasepool {
		ret = [(NSNumber*)o initWithShort:value];
	}
	return ret;

}
void* _Nonnull
NSNumber_inst_InitWithLong(void* o, long value) {
	NSNumber* _Nonnull ret;
	@autoreleasepool {
		ret = [(NSNumber*)o initWithLong:value];
	}
	return ret;

}
void* _Nullable
NSNumber_inst_ScriptingValueForSpecifier(void* o, void* objectSpecifier) {
	NSObject* _Nullable ret;
	@autoreleasepool {
		ret = [(NSNumber*)o scriptingValueForSpecifier:objectSpecifier];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
void* _Nonnull
NSNumber_inst_AutoContentAccessingProxy(void* o) {
	NSObject* _Nonnull ret;
	@autoreleasepool {
		ret = [(NSNumber*)o autoContentAccessingProxy];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
void
NSNumber_inst_ForwardInvocation(void* o, void* anInvocation) {
	@autoreleasepool {
		[(NSNumber*)o forwardInvocation:anInvocation];
	}
}
unsigned short
NSNumber_inst_UnsignedShortValue(void* o) {
	unsigned short ret;
	@autoreleasepool {
		ret = [(NSNumber*)o unsignedShortValue];
	}
	return ret;

}
void* _Nonnull
NSNumber_inst_InitWithDouble(void* o, double value) {
	NSNumber* _Nonnull ret;
	@autoreleasepool {
		ret = [(NSNumber*)o initWithDouble:value];
	}
	return ret;

}
void* _Nonnull
NSNumber_inst_ClassDescription(void* o) {
	NSClassDescription* _Nonnull ret;
	@autoreleasepool {
		ret = [(NSNumber*)o classDescription];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
void* _Nonnull
NSNumber_inst_MutableSetValueForKeyPath(void* o, void* keyPath) {
	NSMutableSet* _Nonnull ret;
	@autoreleasepool {
		ret = [(NSNumber*)o mutableSetValueForKeyPath:keyPath];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
BOOL
NSNumber_inst_IsGreaterThan(void* o, void* object) {
	BOOL ret;
	@autoreleasepool {
		ret = [(NSNumber*)o isGreaterThan:object];
	}
	return ret;

}
BOOL
NSNumber_inst_ScriptingBeginsWith(void* o, void* object) {
	BOOL ret;
	@autoreleasepool {
		ret = [(NSNumber*)o scriptingBeginsWith:object];
	}
	return ret;

}
BOOL
NSNumber_inst_IsEqualToValue(void* o, void* value) {
	BOOL ret;
	@autoreleasepool {
		ret = [(NSNumber*)o isEqualToValue:value];
	}
	return ret;

}
void* _Nonnull
NSNumber_inst_DictionaryWithValuesForKeys(void* o, void* keys) {
	NSDictionary* _Nonnull ret;
	@autoreleasepool {
		ret = [(NSNumber*)o dictionaryWithValuesForKeys:keys];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
void
NSNumber_inst_DidChangeValuesAtIndexes(void* o, NSKeyValueChange changeKind, void* indexes, void* key) {
	@autoreleasepool {
		[(NSNumber*)o didChange:changeKind valuesAtIndexes:indexes forKey:key];
	}
}
void
NSNumber_inst_DidChangeValuesAtIndexesForKey(void* o, NSKeyValueChange changeKind, void* indexes, void* key) {
	@autoreleasepool {
		[(NSNumber*)o didChange:changeKind valuesAtIndexes:indexes forKey:key];
	}
}
BOOL
NSNumber_inst_IsGreaterThanOrEqualTo(void* o, void* object) {
	BOOL ret;
	@autoreleasepool {
		ret = [(NSNumber*)o isGreaterThanOrEqualTo:object];
	}
	return ret;

}
BOOL
NSNumber_inst_IsLessThan(void* o, void* object) {
	BOOL ret;
	@autoreleasepool {
		ret = [(NSNumber*)o isLessThan:object];
	}
	return ret;

}
void* _Nonnull
NSNumber_inst_AttributeKeys(void* o) {
	NSArray* _Nonnull ret;
	@autoreleasepool {
		ret = [(NSNumber*)o attributeKeys];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
NSSize
NSNumber_inst_SizeValue(void* o) {
	NSSize ret;
	@autoreleasepool {
		ret = [(NSNumber*)o sizeValue];
	}
	return ret;

}
void* _Nullable
NSNumber_inst_AwakeAfterUsingCoder(void* o, void* coder) {
	NSObject* _Nullable ret;
	@autoreleasepool {
		ret = [(NSNumber*)o awakeAfterUsingCoder:coder];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
void*
NSNumber_inst_Init(void* o) {
	NSNumber* ret;
	@autoreleasepool {
		ret = [(NSNumber*)o init];
	}
	return ret;

}
void* _Nullable
NSNumber_inst_NewScriptingObjectOfClassForValueForKey(void* o, void* objectClass, void* key, void* contentsValue, void* properties) {
	NSObject* _Nullable ret;
	@autoreleasepool {
		ret = [(NSNumber*)o newScriptingObjectOfClass:objectClass forValueForKey:key withContentsValue:contentsValue properties:properties];
	}
	return ret;

}
void* _Nullable
NSNumber_inst_NewScriptingObjectOfClassForValueForKeyWithContentsValue(void* o, void* objectClass, void* key, void* contentsValue, void* properties) {
	NSObject* _Nullable ret;
	@autoreleasepool {
		ret = [(NSNumber*)o newScriptingObjectOfClass:objectClass forValueForKey:key withContentsValue:contentsValue properties:properties];
	}
	return ret;

}
unsigned int
NSNumber_inst_UnsignedIntValue(void* o) {
	unsigned int ret;
	@autoreleasepool {
		ret = [(NSNumber*)o unsignedIntValue];
	}
	return ret;

}
BOOL
NSNumber_inst_IsCaseInsensitiveLike(void* o, void* object) {
	BOOL ret;
	@autoreleasepool {
		ret = [(NSNumber*)o isCaseInsensitiveLike:object];
	}
	return ret;

}
BOOL
NSNumber_inst_ValidateValueForKey(void* o, void** ioValue, void* inKey, void** outError) {
	BOOL ret;
	@autoreleasepool {
		ret = [(NSNumber*)o validateValue:(id _Nullable* _Nonnull)ioValue forKey:inKey error:(NSError* _Nullable* _Nullable)outError];
		for(int i=0;i<1;i++) {
			if(ioValue[i] == 0) { break; }
			[(id)ioValue[i] retain];
		}
	
	
		for(int i=0;i<1;i++) {
			if(outError[i] == 0) { break; }
			[(id)outError[i] retain];
		}
	
	}
	return ret;

}
BOOL
NSNumber_inst_ValidateValueForKeyPath(void* o, void** ioValue, void* inKeyPath, void** outError) {
	BOOL ret;
	@autoreleasepool {
		ret = [(NSNumber*)o validateValue:(id _Nullable* _Nonnull)ioValue forKeyPath:inKeyPath error:(NSError* _Nullable* _Nullable)outError];
		for(int i=0;i<1;i++) {
			if(ioValue[i] == 0) { break; }
			[(id)ioValue[i] retain];
		}
	
	
		for(int i=0;i<1;i++) {
			if(outError[i] == 0) { break; }
			[(id)outError[i] retain];
		}
	
	}
	return ret;

}
BOOL
NSNumber_inst_ValidateValueForKeyError(void* o, void** ioValue, void* inKey, void** outError) {
	BOOL ret;
	@autoreleasepool {
		ret = [(NSNumber*)o validateValue:(id _Nullable* _Nonnull)ioValue forKey:inKey error:(NSError* _Nullable* _Nullable)outError];
		for(int i=0;i<1;i++) {
			if(ioValue[i] == 0) { break; }
			[(id)ioValue[i] retain];
		}
	
	
		for(int i=0;i<1;i++) {
			if(outError[i] == 0) { break; }
			[(id)outError[i] retain];
		}
	
	}
	return ret;

}
BOOL
NSNumber_inst_ValidateValueForKeyPathError(void* o, void** ioValue, void* inKeyPath, void** outError) {
	BOOL ret;
	@autoreleasepool {
		ret = [(NSNumber*)o validateValue:(id _Nullable* _Nonnull)ioValue forKeyPath:inKeyPath error:(NSError* _Nullable* _Nullable)outError];
		for(int i=0;i<1;i++) {
			if(ioValue[i] == 0) { break; }
			[(id)ioValue[i] retain];
		}
	
	
		for(int i=0;i<1;i++) {
			if(outError[i] == 0) { break; }
			[(id)outError[i] retain];
		}
	
	}
	return ret;

}
BOOL
NSNumber_inst_IsLike(void* o, void* object) {
	BOOL ret;
	@autoreleasepool {
		ret = [(NSNumber*)o isLike:object];
	}
	return ret;

}
void* _Nonnull
NSNumber_inst_DescriptionWithLocale(void* o, void* locale) {
	NSString* _Nonnull ret;
	@autoreleasepool {
		ret = [(NSNumber*)o descriptionWithLocale:locale];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
void* _Nonnull
NSNumber_inst_InitWithUnsignedLong(void* o, unsigned long value) {
	NSNumber* _Nonnull ret;
	@autoreleasepool {
		ret = [(NSNumber*)o initWithUnsignedLong:value];
	}
	return ret;

}
void* _Nullable
NSNumber_inst_PointerValue(void* o) {
	void* _Nullable ret;
	@autoreleasepool {
		ret = [(NSNumber*)o pointerValue];
	}
	return ret;

}
BOOL
NSNumber_inst_ScriptingEndsWith(void* o, void* object) {
	BOOL ret;
	@autoreleasepool {
		ret = [(NSNumber*)o scriptingEndsWith:object];
	}
	return ret;

}
void* _Nullable
NSNumber_inst_ValueForUndefinedKey(void* o, void* key) {
	NSObject* _Nullable ret;
	@autoreleasepool {
		ret = [(NSNumber*)o valueForUndefinedKey:key];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
void* _Nonnull
NSNumber_inst_InitWithBytesObjCType(void* o, void* value, void* type) {
	NSNumber* _Nonnull ret;
	@autoreleasepool {
		ret = [(NSNumber*)o initWithBytes:value objCType:type];
	}
	return ret;

}
NSComparisonResult
NSNumber_inst_Compare(void* o, void* otherNumber) {
	NSComparisonResult ret;
	@autoreleasepool {
		ret = [(NSNumber*)o compare:otherNumber];
	}
	return ret;

}
void* _Nullable
NSNumber_inst_IndicesOfObjectsByEvaluatingObjectSpecifier(void* o, void* specifier) {
	NSArray* _Nullable ret;
	@autoreleasepool {
		ret = [(NSNumber*)o indicesOfObjectsByEvaluatingObjectSpecifier:specifier];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
BOOL
NSNumber_inst_BoolValue(void* o) {
	BOOL ret;
	@autoreleasepool {
		ret = [(NSNumber*)o boolValue];
	}
	return ret;

}
void* _Nullable
NSNumber_inst_ValueForKey(void* o, void* key) {
	NSObject* _Nullable ret;
	@autoreleasepool {
		ret = [(NSNumber*)o valueForKey:key];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
void
NSNumber_inst_RemoveValueAtIndexFromPropertyWithKey(void* o, NSUInteger index, void* key) {
	@autoreleasepool {
		[(NSNumber*)o removeValueAtIndex:index fromPropertyWithKey:key];
	}
}
void* _Nonnull
NSNumber_inst_MutableSetValueForKey(void* o, void* key) {
	NSMutableSet* _Nonnull ret;
	@autoreleasepool {
		ret = [(NSNumber*)o mutableSetValueForKey:key];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
void* _Nonnull
NSNumber_inst_MutableArrayValueForKey(void* o, void* key) {
	NSMutableArray* _Nonnull ret;
	@autoreleasepool {
		ret = [(NSNumber*)o mutableArrayValueForKey:key];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
void* _Nullable
NSNumber_inst_ValueWithNameInPropertyWithKey(void* o, void* name, void* key) {
	NSObject* _Nullable ret;
	@autoreleasepool {
		ret = [(NSNumber*)o valueWithName:name inPropertyWithKey:key];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
void* _Nullable
NSNumber_inst_ValueForKeyPath(void* o, void* keyPath) {
	NSObject* _Nullable ret;
	@autoreleasepool {
		ret = [(NSNumber*)o valueForKeyPath:keyPath];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
void* _Nonnull
NSNumber_inst_InitWithFloat(void* o, float value) {
	NSNumber* _Nonnull ret;
	@autoreleasepool {
		ret = [(NSNumber*)o initWithFloat:value];
	}
	return ret;

}
void* _Nonnull
NSNumber_inst_InitWithUnsignedShort(void* o, unsigned short value) {
	NSNumber* _Nonnull ret;
	@autoreleasepool {
		ret = [(NSNumber*)o initWithUnsignedShort:value];
	}
	return ret;

}
void
NSNumber_inst_SetScriptingProperties(void* o, void* scriptingProperties) {
	@autoreleasepool {
		[(NSNumber*)o setScriptingProperties:scriptingProperties];
	}
}
void* _Nonnull
NSNumber_inst_MutableOrderedSetValueForKeyPath(void* o, void* keyPath) {
	NSMutableOrderedSet* _Nonnull ret;
	@autoreleasepool {
		ret = [(NSNumber*)o mutableOrderedSetValueForKeyPath:keyPath];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
void* _Nullable
NSNumber_inst_ObjectSpecifier(void* o) {
	NSScriptObjectSpecifier* _Nullable ret;
	@autoreleasepool {
		ret = [(NSNumber*)o objectSpecifier];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
void* _Nullable
NSNumber_inst_ClassForKeyedArchiver(void* o) {
	Class _Nullable ret;
	@autoreleasepool {
		ret = [(NSNumber*)o classForKeyedArchiver];
	}
	return ret;

}
BOOL
NSNumber_inst_ScriptingContains(void* o, void* object) {
	BOOL ret;
	@autoreleasepool {
		ret = [(NSNumber*)o scriptingContains:object];
	}
	return ret;

}
void
NSNumber_inst_PerformSelectorOnMainThreadWithObject(void* o, void* aSelector, void* arg, BOOL wait) {
	@autoreleasepool {
		[(NSNumber*)o performSelectorOnMainThread:aSelector withObject:arg waitUntilDone:wait];
	}
}
void
NSNumber_inst_PerformSelectorOnMainThreadWithObjectWaitUntilDone(void* o, void* aSelector, void* arg, BOOL wait) {
	@autoreleasepool {
		[(NSNumber*)o performSelectorOnMainThread:aSelector withObject:arg waitUntilDone:wait];
	}
}
void
NSNumber_inst_PerformSelectorOnMainThreadWithObjectWaitUntilDoneModes(void* o, void* aSelector, void* arg, BOOL wait, void* array) {
	@autoreleasepool {
		[(NSNumber*)o performSelectorOnMainThread:aSelector withObject:arg waitUntilDone:wait modes:array];
	}
}
int
NSNumber_inst_IntValue(void* o) {
	int ret;
	@autoreleasepool {
		ret = [(NSNumber*)o intValue];
	}
	return ret;

}
void*
NSNumber_inst_MethodSignatureForSelector(void* o, void* aSelector) {
	NSMethodSignature* ret;
	@autoreleasepool {
		ret = [(NSNumber*)o methodSignatureForSelector:aSelector];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
void* _Nonnull
NSNumber_inst_ClassForCoder(void* o) {
	Class _Nonnull ret;
	@autoreleasepool {
		ret = [(NSNumber*)o classForCoder];
	}
	return ret;

}
void*
NSNumber_inst_ObservationInfo(void* o) {
	void* ret;
	@autoreleasepool {
		ret = [(NSNumber*)o observationInfo];
	}
	return ret;

}
void* _Nonnull
NSNumber_inst_StringValue(void* o) {
	NSString* _Nonnull ret;
	@autoreleasepool {
		ret = [(NSNumber*)o stringValue];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
NSDecimal
NSNumber_inst_DecimalValue(void* o) {
	NSDecimal ret;
	@autoreleasepool {
		ret = [(NSNumber*)o decimalValue];
	}
	return ret;

}
const void*
NSNumber_inst_ObjCType(void* o) {
	const char* ret;
	@autoreleasepool {
		ret = strdup([(NSNumber*)o objCType]);
	}
	return ret;

}
void
NSNumber_inst_RemoveObserverForKeyPath(void* o, void* observer, void* keyPath) {
	@autoreleasepool {
		[(NSNumber*)o removeObserver:observer forKeyPath:keyPath];
	}
}
void
NSNumber_inst_RemoveObserverForKeyPathContext(void* o, void* observer, void* keyPath, void* context) {
	@autoreleasepool {
		[(NSNumber*)o removeObserver:observer forKeyPath:keyPath context:context];
	}
}
void* _Nullable
NSNumber_inst_ReplacementObjectForKeyedArchiver(void* o, void* archiver) {
	NSObject* _Nullable ret;
	@autoreleasepool {
		ret = [(NSNumber*)o replacementObjectForKeyedArchiver:archiver];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
void* _Nullable
NSNumber_inst_CoerceValueForKey(void* o, void* value, void* key) {
	NSObject* _Nullable ret;
	@autoreleasepool {
		ret = [(NSNumber*)o coerceValue:value forKey:key];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
void* _Nonnull
NSNumber_inst_InitWithUnsignedInt(void* o, unsigned int value) {
	NSNumber* _Nonnull ret;
	@autoreleasepool {
		ret = [(NSNumber*)o initWithUnsignedInt:value];
	}
	return ret;

}
NSRange
NSNumber_inst_RangeValue(void* o) {
	NSRange ret;
	@autoreleasepool {
		ret = [(NSNumber*)o rangeValue];
	}
	return ret;

}
void* _Nonnull
NSNumber_inst_InitWithUnsignedLongLong(void* o, unsigned long long value) {
	NSNumber* _Nonnull ret;
	@autoreleasepool {
		ret = [(NSNumber*)o initWithUnsignedLongLong:value];
	}
	return ret;

}
void*
NSNumber_inst_MutableCopy(void* o) {
	NSObject* ret;
	@autoreleasepool {
		ret = [(NSNumber*)o mutableCopy];
	}
	return ret;

}
void* _Nonnull
NSNumber_inst_InitWithUnsignedChar(void* o, unsigned char value) {
	NSNumber* _Nonnull ret;
	@autoreleasepool {
		ret = [(NSNumber*)o initWithUnsignedChar:value];
	}
	return ret;

}
void
NSNumber_inst_PerformSelectorWithObject(void* o, void* aSelector, void* anArgument, NSTimeInterval delay) {
	@autoreleasepool {
		[(NSNumber*)o performSelector:aSelector withObject:anArgument afterDelay:delay];
	}
}
void
NSNumber_inst_PerformSelectorWithObjectAfterDelay(void* o, void* aSelector, void* anArgument, NSTimeInterval delay) {
	@autoreleasepool {
		[(NSNumber*)o performSelector:aSelector withObject:anArgument afterDelay:delay];
	}
}
void
NSNumber_inst_PerformSelectorWithObjectAfterDelayInModes(void* o, void* aSelector, void* anArgument, NSTimeInterval delay, void* modes) {
	@autoreleasepool {
		[(NSNumber*)o performSelector:aSelector withObject:anArgument afterDelay:delay inModes:modes];
	}
}
void
NSNumber_inst_PerformSelectorOnThread(void* o, void* aSelector, void* thr, void* arg, BOOL wait) {
	@autoreleasepool {
		[(NSNumber*)o performSelector:aSelector onThread:thr withObject:arg waitUntilDone:wait];
	}
}
void
NSNumber_inst_PerformSelectorOnThreadWithObject(void* o, void* aSelector, void* thr, void* arg, BOOL wait) {
	@autoreleasepool {
		[(NSNumber*)o performSelector:aSelector onThread:thr withObject:arg waitUntilDone:wait];
	}
}
void
NSNumber_inst_PerformSelectorOnThreadWithObjectWaitUntilDone(void* o, void* aSelector, void* thr, void* arg, BOOL wait, void* array) {
	@autoreleasepool {
		[(NSNumber*)o performSelector:aSelector onThread:thr withObject:arg waitUntilDone:wait modes:array];
	}
}
void
NSNumber_inst_PerformSelectorOnThreadWithObjectWaitUntilDoneModes(void* o, void* aSelector, void* thr, void* arg, BOOL wait, void* array) {
	@autoreleasepool {
		[(NSNumber*)o performSelector:aSelector onThread:thr withObject:arg waitUntilDone:wait modes:array];
	}
}
BOOL
NSNumber_inst_ScriptingIsLessThan(void* o, void* object) {
	BOOL ret;
	@autoreleasepool {
		ret = [(NSNumber*)o scriptingIsLessThan:object];
	}
	return ret;

}
void
NSNumber_inst_SetObservationInfo(void* o, void* observationInfo) {
	@autoreleasepool {
		[(NSNumber*)o setObservationInfo:observationInfo];
	}
}
BOOL
NSNumber_inst_DoesContain(void* o, void* object) {
	BOOL ret;
	@autoreleasepool {
		ret = [(NSNumber*)o doesContain:object];
	}
	return ret;

}
unsigned long
NSNumber_inst_UnsignedLongValue(void* o) {
	unsigned long ret;
	@autoreleasepool {
		ret = [(NSNumber*)o unsignedLongValue];
	}
	return ret;

}
short
NSNumber_inst_ShortValue(void* o) {
	short ret;
	@autoreleasepool {
		ret = [(NSNumber*)o shortValue];
	}
	return ret;

}
NSRect
NSNumber_inst_RectValue(void* o) {
	NSRect ret;
	@autoreleasepool {
		ret = [(NSNumber*)o rectValue];
	}
	return ret;

}
BOOL
NSNumber_inst_IsNotEqualTo(void* o, void* object) {
	BOOL ret;
	@autoreleasepool {
		ret = [(NSNumber*)o isNotEqualTo:object];
	}
	return ret;

}
void* _Nullable
NSNumber_inst_InverseForRelationshipKey(void* o, void* relationshipKey) {
	NSString* _Nullable ret;
	@autoreleasepool {
		ret = [(NSNumber*)o inverseForRelationshipKey:relationshipKey];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
void
NSNumber_inst_InsertValueInPropertyWithKey(void* o, void* value, void* key) {
	@autoreleasepool {
		[(NSNumber*)o insertValue:value inPropertyWithKey:key];
	}
}
void
NSNumber_inst_InsertValueAtIndex(void* o, void* value, NSUInteger index, void* key) {
	@autoreleasepool {
		[(NSNumber*)o insertValue:value atIndex:index inPropertyWithKey:key];
	}
}
void
NSNumber_inst_InsertValueAtIndexInPropertyWithKey(void* o, void* value, NSUInteger index, void* key) {
	@autoreleasepool {
		[(NSNumber*)o insertValue:value atIndex:index inPropertyWithKey:key];
	}
}
void* _Nonnull
NSNumber_inst_InitWithInteger(void* o, NSInteger value) {
	NSNumber* _Nonnull ret;
	@autoreleasepool {
		ret = [(NSNumber*)o initWithInteger:value];
	}
	return ret;

}
void
NSNumber_inst_GetValueSize(void* o, void* value, NSUInteger size) {
	@autoreleasepool {
		[(NSNumber*)o getValue:value size:size];
	}
}
void* _Nullable
NSNumber_inst_ScriptingProperties(void* o) {
	NSDictionary* _Nullable ret;
	@autoreleasepool {
		ret = [(NSNumber*)o scriptingProperties];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
void* _Nullable
NSNumber_inst_ClassForArchiver(void* o) {
	Class _Nullable ret;
	@autoreleasepool {
		ret = [(NSNumber*)o classForArchiver];
	}
	return ret;

}
long long
NSNumber_inst_LongLongValue(void* o) {
	long long ret;
	@autoreleasepool {
		ret = [(NSNumber*)o longLongValue];
	}
	return ret;

}
BOOL
NSNumber_inst_ScriptingIsGreaterThanOrEqualTo(void* o, void* object) {
	BOOL ret;
	@autoreleasepool {
		ret = [(NSNumber*)o scriptingIsGreaterThanOrEqualTo:object];
	}
	return ret;

}
void*
NSNumber_inst_ForwardingTargetForSelector(void* o, void* aSelector) {
	NSObject* ret;
	@autoreleasepool {
		ret = [(NSNumber*)o forwardingTargetForSelector:aSelector];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
void* _Nullable
NSNumber_inst_ValueAtIndexInPropertyWithKey(void* o, NSUInteger index, void* key) {
	NSObject* _Nullable ret;
	@autoreleasepool {
		ret = [(NSNumber*)o valueAtIndex:index inPropertyWithKey:key];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
void
NSNumber_inst_DoesNotRecognizeSelector(void* o, void* aSelector) {
	@autoreleasepool {
		[(NSNumber*)o doesNotRecognizeSelector:aSelector];
	}
}
unsigned char
NSNumber_inst_UnsignedCharValue(void* o) {
	unsigned char ret;
	@autoreleasepool {
		ret = [(NSNumber*)o unsignedCharValue];
	}
	return ret;

}
void* _Nullable
NSNumber_inst_ValueWithUniqueIDInPropertyWithKey(void* o, void* uniqueID, void* key) {
	NSObject* _Nullable ret;
	@autoreleasepool {
		ret = [(NSNumber*)o valueWithUniqueID:uniqueID inPropertyWithKey:key];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
void
NSNumber_inst_AddObserverForKeyPath(void* o, void* observer, void* keyPath, NSKeyValueObservingOptions options, void* context) {
	@autoreleasepool {
		[(NSNumber*)o addObserver:observer forKeyPath:keyPath options:options context:context];
	}
}
void
NSNumber_inst_AddObserverForKeyPathOptions(void* o, void* observer, void* keyPath, NSKeyValueObservingOptions options, void* context) {
	@autoreleasepool {
		[(NSNumber*)o addObserver:observer forKeyPath:keyPath options:options context:context];
	}
}
void* _Nullable
NSNumber_inst_ReplacementObjectForCoder(void* o, void* coder) {
	NSObject* _Nullable ret;
	@autoreleasepool {
		ret = [(NSNumber*)o replacementObjectForCoder:coder];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
void
NSNumber_inst_ReplaceValueAtIndexInPropertyWithKey(void* o, NSUInteger index, void* key, void* value) {
	@autoreleasepool {
		[(NSNumber*)o replaceValueAtIndex:index inPropertyWithKey:key withValue:value];
	}
}
void
NSNumber_inst_ReplaceValueAtIndexInPropertyWithKeyWithValue(void* o, NSUInteger index, void* key, void* value) {
	@autoreleasepool {
		[(NSNumber*)o replaceValueAtIndex:index inPropertyWithKey:key withValue:value];
	}
}
void
NSNumber_inst_WillChangeValueForKey(void* o, void* key) {
	@autoreleasepool {
		[(NSNumber*)o willChangeValueForKey:key];
	}
}
void
NSNumber_inst_WillChangeValueForKeyWithSetMutation(void* o, void* key, NSKeyValueSetMutationKind mutationKind, void* objects) {
	@autoreleasepool {
		[(NSNumber*)o willChangeValueForKey:key withSetMutation:mutationKind usingObjects:objects];
	}
}
void
NSNumber_inst_WillChangeValueForKeyWithSetMutationUsingObjects(void* o, void* key, NSKeyValueSetMutationKind mutationKind, void* objects) {
	@autoreleasepool {
		[(NSNumber*)o willChangeValueForKey:key withSetMutation:mutationKind usingObjects:objects];
	}
}
void* _Nullable
NSNumber_inst_InitWithCoder(void* o, void* coder) {
	NSNumber* _Nullable ret;
	@autoreleasepool {
		ret = [(NSNumber*)o initWithCoder:coder];
	}
	return ret;

}
float
NSNumber_inst_FloatValue(void* o) {
	float ret;
	@autoreleasepool {
		ret = [(NSNumber*)o floatValue];
	}
	return ret;

}
NSInteger
NSNumber_inst_IntegerValue(void* o) {
	NSInteger ret;
	@autoreleasepool {
		ret = [(NSNumber*)o integerValue];
	}
	return ret;

}
void*
NSNumber_inst_Copy(void* o) {
	NSObject* ret;
	@autoreleasepool {
		ret = [(NSNumber*)o copy];
	}
	return ret;

}
BOOL
NSNumber_inst_IsLessThanOrEqualTo(void* o, void* object) {
	BOOL ret;
	@autoreleasepool {
		ret = [(NSNumber*)o isLessThanOrEqualTo:object];
	}
	return ret;

}
void
NSNumber_inst_PerformSelectorInBackgroundWithObject(void* o, void* aSelector, void* arg) {
	@autoreleasepool {
		[(NSNumber*)o performSelectorInBackground:aSelector withObject:arg];
	}
}
void
NSNumber_inst_DidChangeValueForKey(void* o, void* key) {
	@autoreleasepool {
		[(NSNumber*)o didChangeValueForKey:key];
	}
}
void
NSNumber_inst_DidChangeValueForKeyWithSetMutation(void* o, void* key, NSKeyValueSetMutationKind mutationKind, void* objects) {
	@autoreleasepool {
		[(NSNumber*)o didChangeValueForKey:key withSetMutation:mutationKind usingObjects:objects];
	}
}
void
NSNumber_inst_DidChangeValueForKeyWithSetMutationUsingObjects(void* o, void* key, NSKeyValueSetMutationKind mutationKind, void* objects) {
	@autoreleasepool {
		[(NSNumber*)o didChangeValueForKey:key withSetMutation:mutationKind usingObjects:objects];
	}
}
unsigned long long
NSNumber_inst_UnsignedLongLongValue(void* o) {
	unsigned long long ret;
	@autoreleasepool {
		ret = [(NSNumber*)o unsignedLongLongValue];
	}
	return ret;

}
BOOL
NSNumber_inst_IsEqualTo(void* o, void* object) {
	BOOL ret;
	@autoreleasepool {
		ret = [(NSNumber*)o isEqualTo:object];
	}
	return ret;

}
BOOL
NSNumber_inst_IsEqualToNumber(void* o, void* number) {
	BOOL ret;
	@autoreleasepool {
		ret = [(NSNumber*)o isEqualToNumber:number];
	}
	return ret;

}
FourCharCode
NSNumber_inst_ClassCode(void* o) {
	FourCharCode ret;
	@autoreleasepool {
		ret = [(NSNumber*)o classCode];
	}
	return ret;

}
void
NSNumber_inst_SetValueForKey(void* o, void* value, void* key) {
	@autoreleasepool {
		[(NSNumber*)o setValue:value forKey:key];
	}
}
void
NSNumber_inst_SetValueForKeyPath(void* o, void* value, void* keyPath) {
	@autoreleasepool {
		[(NSNumber*)o setValue:value forKeyPath:keyPath];
	}
}
void
NSNumber_inst_SetValueForUndefinedKey(void* o, void* value, void* key) {
	@autoreleasepool {
		[(NSNumber*)o setValue:value forUndefinedKey:key];
	}
}
NSUInteger
NSNumber_inst_UnsignedIntegerValue(void* o) {
	NSUInteger ret;
	@autoreleasepool {
		ret = [(NSNumber*)o unsignedIntegerValue];
	}
	return ret;

}
void
NSNumber_inst_ObserveValueForKeyPathOfObject(void* o, void* keyPath, void* object, void* change, void* context) {
	@autoreleasepool {
		[(NSNumber*)o observeValueForKeyPath:keyPath ofObject:object change:change context:context];
	}
}
void
NSNumber_inst_ObserveValueForKeyPathOfObjectChange(void* o, void* keyPath, void* object, void* change, void* context) {
	@autoreleasepool {
		[(NSNumber*)o observeValueForKeyPath:keyPath ofObject:object change:change context:context];
	}
}
void
NSNumber_inst_Dealloc(void* o) {
	@autoreleasepool {
		[(NSNumber*)o dealloc];
	}
}
void* _Nonnull
NSNumber_inst_ClassName(void* o) {
	NSString* _Nonnull ret;
	@autoreleasepool {
		ret = [(NSNumber*)o className];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
void
NSNumber_inst_WillChangeValuesAtIndexes(void* o, NSKeyValueChange changeKind, void* indexes, void* key) {
	@autoreleasepool {
		[(NSNumber*)o willChange:changeKind valuesAtIndexes:indexes forKey:key];
	}
}
void
NSNumber_inst_WillChangeValuesAtIndexesForKey(void* o, NSKeyValueChange changeKind, void* indexes, void* key) {
	@autoreleasepool {
		[(NSNumber*)o willChange:changeKind valuesAtIndexes:indexes forKey:key];
	}
}
BOOL
NSNumber_inst_ScriptingIsEqualTo(void* o, void* object) {
	BOOL ret;
	@autoreleasepool {
		ret = [(NSNumber*)o scriptingIsEqualTo:object];
	}
	return ret;

}
void* _Nonnull
NSNumber_inst_InitWithChar(void* o, char value) {
	NSNumber* _Nonnull ret;
	@autoreleasepool {
		ret = [(NSNumber*)o initWithChar:value];
	}
	return ret;

}
void* _Nonnull
NSNumber_inst_InitWithLongLong(void* o, long long value) {
	NSNumber* _Nonnull ret;
	@autoreleasepool {
		ret = [(NSNumber*)o initWithLongLong:value];
	}
	return ret;

}
long
NSNumber_inst_LongValue(void* o) {
	long ret;
	@autoreleasepool {
		ret = [(NSNumber*)o longValue];
	}
	return ret;

}
void* _Nonnull
NSNumber_inst_InitWithUnsignedInteger(void* o, NSUInteger value) {
	NSNumber* _Nonnull ret;
	@autoreleasepool {
		ret = [(NSNumber*)o initWithUnsignedInteger:value];
	}
	return ret;

}
char
NSNumber_inst_CharValue(void* o) {
	char ret;
	@autoreleasepool {
		ret = [(NSNumber*)o charValue];
	}
	return ret;

}
void* _Nullable
NSNumber_inst_NonretainedObjectValue(void* o) {
	NSObject* _Nullable ret;
	@autoreleasepool {
		ret = [(NSNumber*)o nonretainedObjectValue];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
BOOL
NSNumber_inst_AttemptRecoveryFromErrorOptionIndex(void* o, void* error, NSUInteger recoveryOptionIndex) {
	BOOL ret;
	@autoreleasepool {
		ret = [(NSNumber*)o attemptRecoveryFromError:error optionIndex:recoveryOptionIndex];
	}
	return ret;

}
void
NSNumber_inst_AttemptRecoveryFromErrorOptionIndexDelegate(void* o, void* error, NSUInteger recoveryOptionIndex, void* delegate, void* didRecoverSelector, void* contextInfo) {
	@autoreleasepool {
		[(NSNumber*)o attemptRecoveryFromError:error optionIndex:recoveryOptionIndex delegate:delegate didRecoverSelector:didRecoverSelector contextInfo:contextInfo];
	}
}
void
NSNumber_inst_AttemptRecoveryFromErrorOptionIndexDelegateDidRecoverSelector(void* o, void* error, NSUInteger recoveryOptionIndex, void* delegate, void* didRecoverSelector, void* contextInfo) {
	@autoreleasepool {
		[(NSNumber*)o attemptRecoveryFromError:error optionIndex:recoveryOptionIndex delegate:delegate didRecoverSelector:didRecoverSelector contextInfo:contextInfo];
	}
}
void* _Nonnull
NSNumber_inst_ToOneRelationshipKeys(void* o) {
	NSArray* _Nonnull ret;
	@autoreleasepool {
		ret = [(NSNumber*)o toOneRelationshipKeys];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
void* _Nonnull
NSNumber_inst_MutableArrayValueForKeyPath(void* o, void* keyPath) {
	NSMutableArray* _Nonnull ret;
	@autoreleasepool {
		ret = [(NSNumber*)o mutableArrayValueForKeyPath:keyPath];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
void* _Nonnull
NSNumber_inst_InitWithInt(void* o, int value) {
	NSNumber* _Nonnull ret;
	@autoreleasepool {
		ret = [(NSNumber*)o initWithInt:value];
	}
	return ret;

}
NSPoint
NSNumber_inst_PointValue(void* o) {
	NSPoint ret;
	@autoreleasepool {
		ret = [(NSNumber*)o pointValue];
	}
	return ret;

}
NSEdgeInsets
NSNumber_inst_EdgeInsetsValue(void* o) {
	NSEdgeInsets ret;
	@autoreleasepool {
		ret = [(NSNumber*)o edgeInsetsValue];
	}
	return ret;

}
void* _Nonnull
NSNumber_inst_ToManyRelationshipKeys(void* o) {
	NSArray* _Nonnull ret;
	@autoreleasepool {
		ret = [(NSNumber*)o toManyRelationshipKeys];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
BOOL
NSNumber_inst_ScriptingIsLessThanOrEqualTo(void* o, void* object) {
	BOOL ret;
	@autoreleasepool {
		ret = [(NSNumber*)o scriptingIsLessThanOrEqualTo:object];
	}
	return ret;

}
BOOL
NSNumber_inst_ScriptingIsGreaterThan(void* o, void* object) {
	BOOL ret;
	@autoreleasepool {
		ret = [(NSNumber*)o scriptingIsGreaterThan:object];
	}
	return ret;

}
BOOL
CBPeripheralManager_AutomaticallyNotifiesObserversForKey(void* key) {
	BOOL ret;
	@autoreleasepool {
		ret = [CBPeripheralManager automaticallyNotifiesObserversForKey:key];
	}
	return ret;

}
void*
CBPeripheralManager_New() {
	CBPeripheralManager* ret;
	@autoreleasepool {
		ret = [CBPeripheralManager new];
	}
	return ret;

}
void*
CBPeripheralManager_Alloc() {
	return [CBPeripheralManager alloc];
}
void*
CBPeripheralManager_InstanceMethodSignatureForSelector(void* aSelector) {
	NSMethodSignature* ret;
	@autoreleasepool {
		ret = [CBPeripheralManager instanceMethodSignatureForSelector:aSelector];
	}
	return ret;

}
void* _Nonnull
CBPeripheralManager_KeyPathsForValuesAffectingValueForKey(void* key) {
	NSSet* _Nonnull ret;
	@autoreleasepool {
		ret = [CBPeripheralManager keyPathsForValuesAffectingValueForKey:key];
	}
	return ret;

}
BOOL
CBPeripheralManager_ResolveClassMethod(void* sel) {
	BOOL ret;
	@autoreleasepool {
		ret = [CBPeripheralManager resolveClassMethod:sel];
	}
	return ret;

}
BOOL
CBPeripheralManager_IsSubclassOfClass(void* aClass) {
	BOOL ret;
	@autoreleasepool {
		ret = [CBPeripheralManager isSubclassOfClass:aClass];
	}
	return ret;

}
NSUInteger
CBPeripheralManager_Hash() {
	NSUInteger ret;
	@autoreleasepool {
		ret = [CBPeripheralManager hash];
	}
	return ret;

}
BOOL
CBPeripheralManager_InstancesRespondToSelector(void* aSelector) {
	BOOL ret;
	@autoreleasepool {
		ret = [CBPeripheralManager instancesRespondToSelector:aSelector];
	}
	return ret;

}
void
CBPeripheralManager_SetVersion(NSInteger aVersion) {
	@autoreleasepool {
		[CBPeripheralManager setVersion:aVersion];
	}
}
void*
CBPeripheralManager_CopyWithZone(void* zone) {
	NSObject* ret;
	@autoreleasepool {
		ret = [CBPeripheralManager copyWithZone:zone];
	}
	return ret;

}
BOOL
CBPeripheralManager_AccessInstanceVariablesDirectly() {
	BOOL ret;
	@autoreleasepool {
		ret = [CBPeripheralManager accessInstanceVariablesDirectly];
	}
	return ret;

}
void*
CBPeripheralManager_AllocWithZone(void* zone) {
	return [CBPeripheralManager allocWithZone:zone];
}
void
CBPeripheralManager_CancelPreviousPerformRequestsWithTarget(void* aTarget) {
	@autoreleasepool {
		[CBPeripheralManager cancelPreviousPerformRequestsWithTarget:aTarget];
	}
}
void
CBPeripheralManager_CancelPreviousPerformRequestsWithTargetSelector(void* aTarget, void* aSelector, void* anArgument) {
	@autoreleasepool {
		[CBPeripheralManager cancelPreviousPerformRequestsWithTarget:aTarget selector:aSelector object:anArgument];
	}
}
void
CBPeripheralManager_CancelPreviousPerformRequestsWithTargetSelectorObject(void* aTarget, void* aSelector, void* anArgument) {
	@autoreleasepool {
		[CBPeripheralManager cancelPreviousPerformRequestsWithTarget:aTarget selector:aSelector object:anArgument];
	}
}
BOOL
CBPeripheralManager_ResolveInstanceMethod(void* sel) {
	BOOL ret;
	@autoreleasepool {
		ret = [CBPeripheralManager resolveInstanceMethod:sel];
	}
	return ret;

}
BOOL
CBPeripheralManager_ConformsToProtocol(void* protocol) {
	BOOL ret;
	@autoreleasepool {
		ret = [CBPeripheralManager conformsToProtocol:protocol];
	}
	return ret;

}
void*
CBPeripheralManager_Superclass() {
	Class ret;
	@autoreleasepool {
		ret = [CBPeripheralManager superclass];
	}
	return ret;

}
CBManagerAuthorization
CBPeripheralManager_Authorization() {
	CBManagerAuthorization ret;
	@autoreleasepool {
		ret = [CBPeripheralManager authorization];
	}
	return ret;

}
void
CBPeripheralManager_Load() {
	@autoreleasepool {
		[CBPeripheralManager load];
	}
}
void*
CBPeripheralManager_DebugDescription() {
	NSString* ret;
	@autoreleasepool {
		ret = [CBPeripheralManager debugDescription];
	}
	return ret;

}
void*
CBPeripheralManager_Class() {
	Class ret;
	@autoreleasepool {
		ret = [CBPeripheralManager class];
	}
	return ret;

}
void* _Nonnull
CBPeripheralManager_ClassFallbacksForKeyedArchiver() {
	NSArray* _Nonnull ret;
	@autoreleasepool {
		ret = [CBPeripheralManager classFallbacksForKeyedArchiver];
	}
	return ret;

}
NSInteger
CBPeripheralManager_Version() {
	NSInteger ret;
	@autoreleasepool {
		ret = [CBPeripheralManager version];
	}
	return ret;

}
void*
CBPeripheralManager_MutableCopyWithZone(void* zone) {
	NSObject* ret;
	@autoreleasepool {
		ret = [CBPeripheralManager mutableCopyWithZone:zone];
	}
	return ret;

}
void*
CBPeripheralManager_Description() {
	NSString* ret;
	@autoreleasepool {
		ret = [CBPeripheralManager description];
	}
	return ret;

}
void* _Nonnull
CBPeripheralManager_ClassForKeyedUnarchiver() {
	Class _Nonnull ret;
	@autoreleasepool {
		ret = [CBPeripheralManager classForKeyedUnarchiver];
	}
	return ret;

}
void* _Nullable
CBPeripheralManager_inst_ClassForKeyedArchiver(void* o) {
	Class _Nullable ret;
	@autoreleasepool {
		ret = [(CBPeripheralManager*)o classForKeyedArchiver];
	}
	return ret;

}
void* _Nonnull
CBPeripheralManager_inst_Init(void* o) {
	CBPeripheralManager* _Nonnull ret;
	@autoreleasepool {
		ret = [(CBPeripheralManager*)o init];
	}
	return ret;

}
void* _Nullable
CBPeripheralManager_inst_ReplacementObjectForKeyedArchiver(void* o, void* archiver) {
	NSObject* _Nullable ret;
	@autoreleasepool {
		ret = [(CBPeripheralManager*)o replacementObjectForKeyedArchiver:archiver];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
void* _Nullable
CBPeripheralManager_inst_CoerceValueForKey(void* o, void* value, void* key) {
	NSObject* _Nullable ret;
	@autoreleasepool {
		ret = [(CBPeripheralManager*)o coerceValue:value forKey:key];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
void* _Nonnull
CBPeripheralManager_inst_AutoContentAccessingProxy(void* o) {
	NSObject* _Nonnull ret;
	@autoreleasepool {
		ret = [(CBPeripheralManager*)o autoContentAccessingProxy];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
void* _Nullable
CBPeripheralManager_inst_ScriptingProperties(void* o) {
	NSDictionary* _Nullable ret;
	@autoreleasepool {
		ret = [(CBPeripheralManager*)o scriptingProperties];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
void*
CBPeripheralManager_inst_MutableCopy(void* o) {
	NSObject* ret;
	@autoreleasepool {
		ret = [(CBPeripheralManager*)o mutableCopy];
	}
	return ret;

}
void
CBPeripheralManager_inst_WillChangeValueForKey(void* o, void* key) {
	@autoreleasepool {
		[(CBPeripheralManager*)o willChangeValueForKey:key];
	}
}
void
CBPeripheralManager_inst_WillChangeValueForKeyWithSetMutation(void* o, void* key, NSKeyValueSetMutationKind mutationKind, void* objects) {
	@autoreleasepool {
		[(CBPeripheralManager*)o willChangeValueForKey:key withSetMutation:mutationKind usingObjects:objects];
	}
}
void
CBPeripheralManager_inst_WillChangeValueForKeyWithSetMutationUsingObjects(void* o, void* key, NSKeyValueSetMutationKind mutationKind, void* objects) {
	@autoreleasepool {
		[(CBPeripheralManager*)o willChangeValueForKey:key withSetMutation:mutationKind usingObjects:objects];
	}
}
void
CBPeripheralManager_inst_ObserveValueForKeyPathOfObject(void* o, void* keyPath, void* object, void* change, void* context) {
	@autoreleasepool {
		[(CBPeripheralManager*)o observeValueForKeyPath:keyPath ofObject:object change:change context:context];
	}
}
void
CBPeripheralManager_inst_ObserveValueForKeyPathOfObjectChange(void* o, void* keyPath, void* object, void* change, void* context) {
	@autoreleasepool {
		[(CBPeripheralManager*)o observeValueForKeyPath:keyPath ofObject:object change:change context:context];
	}
}
void
CBPeripheralManager_inst_ObserveValueForKeyPathOfObjectChangeContext(void* o, void* keyPath, void* object, void* change, void* context) {
	@autoreleasepool {
		[(CBPeripheralManager*)o observeValueForKeyPath:keyPath ofObject:object change:change context:context];
	}
}
BOOL
CBPeripheralManager_inst_ScriptingIsLessThanOrEqualTo(void* o, void* object) {
	BOOL ret;
	@autoreleasepool {
		ret = [(CBPeripheralManager*)o scriptingIsLessThanOrEqualTo:object];
	}
	return ret;

}
void
CBPeripheralManager_inst_SetValueForKey(void* o, void* value, void* key) {
	@autoreleasepool {
		[(CBPeripheralManager*)o setValue:value forKey:key];
	}
}
void
CBPeripheralManager_inst_SetValueForKeyPath(void* o, void* value, void* keyPath) {
	@autoreleasepool {
		[(CBPeripheralManager*)o setValue:value forKeyPath:keyPath];
	}
}
void
CBPeripheralManager_inst_SetValueForUndefinedKey(void* o, void* value, void* key) {
	@autoreleasepool {
		[(CBPeripheralManager*)o setValue:value forUndefinedKey:key];
	}
}
void* _Nullable
CBPeripheralManager_inst_NewScriptingObjectOfClassForValueForKey(void* o, void* objectClass, void* key, void* contentsValue, void* properties) {
	NSObject* _Nullable ret;
	@autoreleasepool {
		ret = [(CBPeripheralManager*)o newScriptingObjectOfClass:objectClass forValueForKey:key withContentsValue:contentsValue properties:properties];
	}
	return ret;

}
void* _Nullable
CBPeripheralManager_inst_NewScriptingObjectOfClassForValueForKeyWithContentsValue(void* o, void* objectClass, void* key, void* contentsValue, void* properties) {
	NSObject* _Nullable ret;
	@autoreleasepool {
		ret = [(CBPeripheralManager*)o newScriptingObjectOfClass:objectClass forValueForKey:key withContentsValue:contentsValue properties:properties];
	}
	return ret;

}
void* _Nullable
CBPeripheralManager_inst_NewScriptingObjectOfClassForValueForKeyWithContentsValueProperties(void* o, void* objectClass, void* key, void* contentsValue, void* properties) {
	NSObject* _Nullable ret;
	@autoreleasepool {
		ret = [(CBPeripheralManager*)o newScriptingObjectOfClass:objectClass forValueForKey:key withContentsValue:contentsValue properties:properties];
	}
	return ret;

}
BOOL
CBPeripheralManager_inst_IsEqualTo(void* o, void* object) {
	BOOL ret;
	@autoreleasepool {
		ret = [(CBPeripheralManager*)o isEqualTo:object];
	}
	return ret;

}
void
CBPeripheralManager_inst_PublishL2CAPChannelWithEncryption(void* o, BOOL encryptionRequired) {
	@autoreleasepool {
		[(CBPeripheralManager*)o publishL2CAPChannelWithEncryption:encryptionRequired];
	}
}
void* _Nullable
CBPeripheralManager_inst_Delegate(void* o) {
	NSObject* _Nullable ret;
	@autoreleasepool {
		ret = [(CBPeripheralManager*)o delegate];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
void
CBPeripheralManager_inst_PerformSelectorOnMainThreadWithObject(void* o, void* aSelector, void* arg, BOOL wait) {
	@autoreleasepool {
		[(CBPeripheralManager*)o performSelectorOnMainThread:aSelector withObject:arg waitUntilDone:wait];
	}
}
void
CBPeripheralManager_inst_PerformSelectorOnMainThreadWithObjectWaitUntilDone(void* o, void* aSelector, void* arg, BOOL wait) {
	@autoreleasepool {
		[(CBPeripheralManager*)o performSelectorOnMainThread:aSelector withObject:arg waitUntilDone:wait];
	}
}
void
CBPeripheralManager_inst_PerformSelectorOnMainThreadWithObjectWaitUntilDoneModes(void* o, void* aSelector, void* arg, BOOL wait, void* array) {
	@autoreleasepool {
		[(CBPeripheralManager*)o performSelectorOnMainThread:aSelector withObject:arg waitUntilDone:wait modes:array];
	}
}
BOOL
CBPeripheralManager_inst_ScriptingIsLessThan(void* o, void* object) {
	BOOL ret;
	@autoreleasepool {
		ret = [(CBPeripheralManager*)o scriptingIsLessThan:object];
	}
	return ret;

}
void* _Nonnull
CBPeripheralManager_inst_DictionaryWithValuesForKeys(void* o, void* keys) {
	NSDictionary* _Nonnull ret;
	@autoreleasepool {
		ret = [(CBPeripheralManager*)o dictionaryWithValuesForKeys:keys];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
void
CBPeripheralManager_inst_SetObservationInfo(void* o, void* observationInfo) {
	@autoreleasepool {
		[(CBPeripheralManager*)o setObservationInfo:observationInfo];
	}
}
void
CBPeripheralManager_inst_WillChangeValuesAtIndexes(void* o, NSKeyValueChange changeKind, void* indexes, void* key) {
	@autoreleasepool {
		[(CBPeripheralManager*)o willChange:changeKind valuesAtIndexes:indexes forKey:key];
	}
}
void
CBPeripheralManager_inst_WillChangeValuesAtIndexesForKey(void* o, NSKeyValueChange changeKind, void* indexes, void* key) {
	@autoreleasepool {
		[(CBPeripheralManager*)o willChange:changeKind valuesAtIndexes:indexes forKey:key];
	}
}
BOOL
CBPeripheralManager_inst_ScriptingIsEqualTo(void* o, void* object) {
	BOOL ret;
	@autoreleasepool {
		ret = [(CBPeripheralManager*)o scriptingIsEqualTo:object];
	}
	return ret;

}
void
CBPeripheralManager_inst_RemoveObserverForKeyPath(void* o, void* observer, void* keyPath) {
	@autoreleasepool {
		[(CBPeripheralManager*)o removeObserver:observer forKeyPath:keyPath];
	}
}
void
CBPeripheralManager_inst_RemoveObserverForKeyPathContext(void* o, void* observer, void* keyPath, void* context) {
	@autoreleasepool {
		[(CBPeripheralManager*)o removeObserver:observer forKeyPath:keyPath context:context];
	}
}
void
CBPeripheralManager_inst_SetScriptingProperties(void* o, void* scriptingProperties) {
	@autoreleasepool {
		[(CBPeripheralManager*)o setScriptingProperties:scriptingProperties];
	}
}
BOOL
CBPeripheralManager_inst_ScriptingBeginsWith(void* o, void* object) {
	BOOL ret;
	@autoreleasepool {
		ret = [(CBPeripheralManager*)o scriptingBeginsWith:object];
	}
	return ret;

}
void* _Nullable
CBPeripheralManager_inst_CopyScriptingValueForKey(void* o, void* value, void* key, void* properties) {
	NSObject* _Nullable ret;
	@autoreleasepool {
		ret = [(CBPeripheralManager*)o copyScriptingValue:value forKey:key withProperties:properties];
	}
	return ret;

}
void* _Nullable
CBPeripheralManager_inst_CopyScriptingValueForKeyWithProperties(void* o, void* value, void* key, void* properties) {
	NSObject* _Nullable ret;
	@autoreleasepool {
		ret = [(CBPeripheralManager*)o copyScriptingValue:value forKey:key withProperties:properties];
	}
	return ret;

}
void
CBPeripheralManager_inst_SetNilValueForKey(void* o, void* key) {
	@autoreleasepool {
		[(CBPeripheralManager*)o setNilValueForKey:key];
	}
}
void
CBPeripheralManager_inst_AddObserverForKeyPath(void* o, void* observer, void* keyPath, NSKeyValueObservingOptions options, void* context) {
	@autoreleasepool {
		[(CBPeripheralManager*)o addObserver:observer forKeyPath:keyPath options:options context:context];
	}
}
void
CBPeripheralManager_inst_AddObserverForKeyPathOptions(void* o, void* observer, void* keyPath, NSKeyValueObservingOptions options, void* context) {
	@autoreleasepool {
		[(CBPeripheralManager*)o addObserver:observer forKeyPath:keyPath options:options context:context];
	}
}
void
CBPeripheralManager_inst_AddObserverForKeyPathOptionsContext(void* o, void* observer, void* keyPath, NSKeyValueObservingOptions options, void* context) {
	@autoreleasepool {
		[(CBPeripheralManager*)o addObserver:observer forKeyPath:keyPath options:options context:context];
	}
}
BOOL
CBPeripheralManager_inst_DoesContain(void* o, void* object) {
	BOOL ret;
	@autoreleasepool {
		ret = [(CBPeripheralManager*)o doesContain:object];
	}
	return ret;

}
void* _Nullable
CBPeripheralManager_inst_ValueForKeyPath(void* o, void* keyPath) {
	NSObject* _Nullable ret;
	@autoreleasepool {
		ret = [(CBPeripheralManager*)o valueForKeyPath:keyPath];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
BOOL
CBPeripheralManager_inst_IsLessThan(void* o, void* object) {
	BOOL ret;
	@autoreleasepool {
		ret = [(CBPeripheralManager*)o isLessThan:object];
	}
	return ret;

}
void
CBPeripheralManager_inst_SetValuesForKeysWithDictionary(void* o, void* keyedValues) {
	@autoreleasepool {
		[(CBPeripheralManager*)o setValuesForKeysWithDictionary:keyedValues];
	}
}
void* _Nullable
CBPeripheralManager_inst_ReplacementObjectForCoder(void* o, void* coder) {
	NSObject* _Nullable ret;
	@autoreleasepool {
		ret = [(CBPeripheralManager*)o replacementObjectForCoder:coder];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
void
CBPeripheralManager_inst_StopAdvertising(void* o) {
	@autoreleasepool {
		[(CBPeripheralManager*)o stopAdvertising];
	}
}
void
CBPeripheralManager_inst_StartAdvertising(void* o, void* advertisementData) {
	@autoreleasepool {
		[(CBPeripheralManager*)o startAdvertising:advertisementData];
	}
}
void* _Nonnull
CBPeripheralManager_inst_MutableOrderedSetValueForKey(void* o, void* key) {
	NSMutableOrderedSet* _Nonnull ret;
	@autoreleasepool {
		ret = [(CBPeripheralManager*)o mutableOrderedSetValueForKey:key];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
void* _Nonnull
CBPeripheralManager_inst_ClassForCoder(void* o) {
	Class _Nonnull ret;
	@autoreleasepool {
		ret = [(CBPeripheralManager*)o classForCoder];
	}
	return ret;

}
void* _Nonnull
CBPeripheralManager_inst_MutableArrayValueForKeyPath(void* o, void* keyPath) {
	NSMutableArray* _Nonnull ret;
	@autoreleasepool {
		ret = [(CBPeripheralManager*)o mutableArrayValueForKeyPath:keyPath];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
CBManagerState
CBPeripheralManager_inst_State(void* o) {
	CBManagerState ret;
	@autoreleasepool {
		ret = [(CBPeripheralManager*)o state];
	}
	return ret;

}
void* _Nonnull
CBPeripheralManager_inst_MutableSetValueForKeyPath(void* o, void* keyPath) {
	NSMutableSet* _Nonnull ret;
	@autoreleasepool {
		ret = [(CBPeripheralManager*)o mutableSetValueForKeyPath:keyPath];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
void* _Nullable
CBPeripheralManager_inst_ValueForUndefinedKey(void* o, void* key) {
	NSObject* _Nullable ret;
	@autoreleasepool {
		ret = [(CBPeripheralManager*)o valueForUndefinedKey:key];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
BOOL
CBPeripheralManager_inst_IsLessThanOrEqualTo(void* o, void* object) {
	BOOL ret;
	@autoreleasepool {
		ret = [(CBPeripheralManager*)o isLessThanOrEqualTo:object];
	}
	return ret;

}
BOOL
CBPeripheralManager_inst_ScriptingEndsWith(void* o, void* object) {
	BOOL ret;
	@autoreleasepool {
		ret = [(CBPeripheralManager*)o scriptingEndsWith:object];
	}
	return ret;

}
void* _Nullable
CBPeripheralManager_inst_ValueWithNameInPropertyWithKey(void* o, void* name, void* key) {
	NSObject* _Nullable ret;
	@autoreleasepool {
		ret = [(CBPeripheralManager*)o valueWithName:name inPropertyWithKey:key];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
BOOL
CBPeripheralManager_inst_ScriptingIsGreaterThanOrEqualTo(void* o, void* object) {
	BOOL ret;
	@autoreleasepool {
		ret = [(CBPeripheralManager*)o scriptingIsGreaterThanOrEqualTo:object];
	}
	return ret;

}
void
CBPeripheralManager_inst_AddService(void* o, void* service) {
	@autoreleasepool {
		[(CBPeripheralManager*)o addService:service];
	}
}
FourCharCode
CBPeripheralManager_inst_ClassCode(void* o) {
	FourCharCode ret;
	@autoreleasepool {
		ret = [(CBPeripheralManager*)o classCode];
	}
	return ret;

}
void*
CBPeripheralManager_inst_MethodSignatureForSelector(void* o, void* aSelector) {
	NSMethodSignature* ret;
	@autoreleasepool {
		ret = [(CBPeripheralManager*)o methodSignatureForSelector:aSelector];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
void* _Nullable
CBPeripheralManager_inst_ClassForArchiver(void* o) {
	Class _Nullable ret;
	@autoreleasepool {
		ret = [(CBPeripheralManager*)o classForArchiver];
	}
	return ret;

}
void
CBPeripheralManager_inst_SetDesiredConnectionLatency(void* o, CBPeripheralManagerConnectionLatency latency, void* central) {
	@autoreleasepool {
		[(CBPeripheralManager*)o setDesiredConnectionLatency:latency forCentral:central];
	}
}
void
CBPeripheralManager_inst_RemoveValueAtIndexFromPropertyWithKey(void* o, NSUInteger index, void* key) {
	@autoreleasepool {
		[(CBPeripheralManager*)o removeValueAtIndex:index fromPropertyWithKey:key];
	}
}
void
CBPeripheralManager_inst_RemoveAllServices(void* o) {
	@autoreleasepool {
		[(CBPeripheralManager*)o removeAllServices];
	}
}
void* _Nullable
CBPeripheralManager_inst_ValueForKey(void* o, void* key) {
	NSObject* _Nullable ret;
	@autoreleasepool {
		ret = [(CBPeripheralManager*)o valueForKey:key];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
void* _Nullable
CBPeripheralManager_inst_AwakeAfterUsingCoder(void* o, void* coder) {
	NSObject* _Nullable ret;
	@autoreleasepool {
		ret = [(CBPeripheralManager*)o awakeAfterUsingCoder:coder];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
BOOL
CBPeripheralManager_inst_IsLike(void* o, void* object) {
	BOOL ret;
	@autoreleasepool {
		ret = [(CBPeripheralManager*)o isLike:object];
	}
	return ret;

}
BOOL
CBPeripheralManager_inst_AttemptRecoveryFromErrorOptionIndex(void* o, void* error, NSUInteger recoveryOptionIndex) {
	BOOL ret;
	@autoreleasepool {
		ret = [(CBPeripheralManager*)o attemptRecoveryFromError:error optionIndex:recoveryOptionIndex];
	}
	return ret;

}
void
CBPeripheralManager_inst_AttemptRecoveryFromErrorOptionIndexDelegate(void* o, void* error, NSUInteger recoveryOptionIndex, void* delegate, void* didRecoverSelector, void* contextInfo) {
	@autoreleasepool {
		[(CBPeripheralManager*)o attemptRecoveryFromError:error optionIndex:recoveryOptionIndex delegate:delegate didRecoverSelector:didRecoverSelector contextInfo:contextInfo];
	}
}
void
CBPeripheralManager_inst_AttemptRecoveryFromErrorOptionIndexDelegateDidRecoverSelector(void* o, void* error, NSUInteger recoveryOptionIndex, void* delegate, void* didRecoverSelector, void* contextInfo) {
	@autoreleasepool {
		[(CBPeripheralManager*)o attemptRecoveryFromError:error optionIndex:recoveryOptionIndex delegate:delegate didRecoverSelector:didRecoverSelector contextInfo:contextInfo];
	}
}
void
CBPeripheralManager_inst_AttemptRecoveryFromErrorOptionIndexDelegateDidRecoverSelectorContextInfo(void* o, void* error, NSUInteger recoveryOptionIndex, void* delegate, void* didRecoverSelector, void* contextInfo) {
	@autoreleasepool {
		[(CBPeripheralManager*)o attemptRecoveryFromError:error optionIndex:recoveryOptionIndex delegate:delegate didRecoverSelector:didRecoverSelector contextInfo:contextInfo];
	}
}
void
CBPeripheralManager_inst_Dealloc(void* o) {
	@autoreleasepool {
		[(CBPeripheralManager*)o dealloc];
	}
}
void
CBPeripheralManager_inst_RemoveService(void* o, void* service) {
	@autoreleasepool {
		[(CBPeripheralManager*)o removeService:service];
	}
}
void
CBPeripheralManager_inst_UnpublishL2CAPChannel(void* o, CBL2CAPPSM PSM) {
	@autoreleasepool {
		[(CBPeripheralManager*)o unpublishL2CAPChannel:PSM];
	}
}
void* _Nullable
CBPeripheralManager_inst_ValueAtIndexInPropertyWithKey(void* o, NSUInteger index, void* key) {
	NSObject* _Nullable ret;
	@autoreleasepool {
		ret = [(CBPeripheralManager*)o valueAtIndex:index inPropertyWithKey:key];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
void* _Nullable
CBPeripheralManager_inst_InverseForRelationshipKey(void* o, void* relationshipKey) {
	NSString* _Nullable ret;
	@autoreleasepool {
		ret = [(CBPeripheralManager*)o inverseForRelationshipKey:relationshipKey];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
void* _Nullable
CBPeripheralManager_inst_IndicesOfObjectsByEvaluatingObjectSpecifier(void* o, void* specifier) {
	NSArray* _Nullable ret;
	@autoreleasepool {
		ret = [(CBPeripheralManager*)o indicesOfObjectsByEvaluatingObjectSpecifier:specifier];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
BOOL
CBPeripheralManager_inst_UpdateValue(void* o, void* value, void* characteristic, void* centrals) {
	BOOL ret;
	@autoreleasepool {
		ret = [(CBPeripheralManager*)o updateValue:value forCharacteristic:characteristic onSubscribedCentrals:centrals];
	}
	return ret;

}
void
CBPeripheralManager_inst_PerformSelectorWithObject(void* o, void* aSelector, void* anArgument, NSTimeInterval delay) {
	@autoreleasepool {
		[(CBPeripheralManager*)o performSelector:aSelector withObject:anArgument afterDelay:delay];
	}
}
void
CBPeripheralManager_inst_PerformSelectorWithObjectAfterDelay(void* o, void* aSelector, void* anArgument, NSTimeInterval delay) {
	@autoreleasepool {
		[(CBPeripheralManager*)o performSelector:aSelector withObject:anArgument afterDelay:delay];
	}
}
void
CBPeripheralManager_inst_PerformSelectorWithObjectAfterDelayInModes(void* o, void* aSelector, void* anArgument, NSTimeInterval delay, void* modes) {
	@autoreleasepool {
		[(CBPeripheralManager*)o performSelector:aSelector withObject:anArgument afterDelay:delay inModes:modes];
	}
}
void
CBPeripheralManager_inst_PerformSelectorOnThread(void* o, void* aSelector, void* thr, void* arg, BOOL wait) {
	@autoreleasepool {
		[(CBPeripheralManager*)o performSelector:aSelector onThread:thr withObject:arg waitUntilDone:wait];
	}
}
void
CBPeripheralManager_inst_PerformSelectorOnThreadWithObject(void* o, void* aSelector, void* thr, void* arg, BOOL wait) {
	@autoreleasepool {
		[(CBPeripheralManager*)o performSelector:aSelector onThread:thr withObject:arg waitUntilDone:wait];
	}
}
void
CBPeripheralManager_inst_PerformSelectorOnThreadWithObjectWaitUntilDone(void* o, void* aSelector, void* thr, void* arg, BOOL wait) {
	@autoreleasepool {
		[(CBPeripheralManager*)o performSelector:aSelector onThread:thr withObject:arg waitUntilDone:wait];
	}
}
void
CBPeripheralManager_inst_PerformSelectorOnThreadWithObjectWaitUntilDoneModes(void* o, void* aSelector, void* thr, void* arg, BOOL wait, void* array) {
	@autoreleasepool {
		[(CBPeripheralManager*)o performSelector:aSelector onThread:thr withObject:arg waitUntilDone:wait modes:array];
	}
}
void
CBPeripheralManager_inst_ForwardInvocation(void* o, void* anInvocation) {
	@autoreleasepool {
		[(CBPeripheralManager*)o forwardInvocation:anInvocation];
	}
}
void* _Nonnull
CBPeripheralManager_inst_AttributeKeys(void* o) {
	NSArray* _Nonnull ret;
	@autoreleasepool {
		ret = [(CBPeripheralManager*)o attributeKeys];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
void* _Nullable
CBPeripheralManager_inst_ValueWithUniqueIDInPropertyWithKey(void* o, void* uniqueID, void* key) {
	NSObject* _Nullable ret;
	@autoreleasepool {
		ret = [(CBPeripheralManager*)o valueWithUniqueID:uniqueID inPropertyWithKey:key];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
void* _Nonnull
CBPeripheralManager_inst_ToManyRelationshipKeys(void* o) {
	NSArray* _Nonnull ret;
	@autoreleasepool {
		ret = [(CBPeripheralManager*)o toManyRelationshipKeys];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
BOOL
CBPeripheralManager_inst_IsCaseInsensitiveLike(void* o, void* object) {
	BOOL ret;
	@autoreleasepool {
		ret = [(CBPeripheralManager*)o isCaseInsensitiveLike:object];
	}
	return ret;

}
BOOL
CBPeripheralManager_inst_IsGreaterThanOrEqualTo(void* o, void* object) {
	BOOL ret;
	@autoreleasepool {
		ret = [(CBPeripheralManager*)o isGreaterThanOrEqualTo:object];
	}
	return ret;

}
BOOL
CBPeripheralManager_inst_IsAdvertising(void* o) {
	BOOL ret;
	@autoreleasepool {
		ret = [(CBPeripheralManager*)o isAdvertising];
	}
	return ret;

}
void
CBPeripheralManager_inst_SetDelegate(void* o, void* delegate) {
	@autoreleasepool {
		[(CBPeripheralManager*)o setDelegate:delegate];
	}
}
void
CBPeripheralManager_inst_DidChangeValuesAtIndexes(void* o, NSKeyValueChange changeKind, void* indexes, void* key) {
	@autoreleasepool {
		[(CBPeripheralManager*)o didChange:changeKind valuesAtIndexes:indexes forKey:key];
	}
}
void
CBPeripheralManager_inst_DidChangeValuesAtIndexesForKey(void* o, NSKeyValueChange changeKind, void* indexes, void* key) {
	@autoreleasepool {
		[(CBPeripheralManager*)o didChange:changeKind valuesAtIndexes:indexes forKey:key];
	}
}
void
CBPeripheralManager_inst_DoesNotRecognizeSelector(void* o, void* aSelector) {
	@autoreleasepool {
		[(CBPeripheralManager*)o doesNotRecognizeSelector:aSelector];
	}
}
BOOL
CBPeripheralManager_inst_IsGreaterThan(void* o, void* object) {
	BOOL ret;
	@autoreleasepool {
		ret = [(CBPeripheralManager*)o isGreaterThan:object];
	}
	return ret;

}
void
CBPeripheralManager_inst_InsertValueInPropertyWithKey(void* o, void* value, void* key) {
	@autoreleasepool {
		[(CBPeripheralManager*)o insertValue:value inPropertyWithKey:key];
	}
}
void
CBPeripheralManager_inst_InsertValueAtIndex(void* o, void* value, NSUInteger index, void* key) {
	@autoreleasepool {
		[(CBPeripheralManager*)o insertValue:value atIndex:index inPropertyWithKey:key];
	}
}
void
CBPeripheralManager_inst_InsertValueAtIndexInPropertyWithKey(void* o, void* value, NSUInteger index, void* key) {
	@autoreleasepool {
		[(CBPeripheralManager*)o insertValue:value atIndex:index inPropertyWithKey:key];
	}
}
BOOL
CBPeripheralManager_inst_ScriptingIsGreaterThan(void* o, void* object) {
	BOOL ret;
	@autoreleasepool {
		ret = [(CBPeripheralManager*)o scriptingIsGreaterThan:object];
	}
	return ret;

}
void
CBPeripheralManager_inst_RespondToRequest(void* o, void* request, CBATTError result) {
	@autoreleasepool {
		[(CBPeripheralManager*)o respondToRequest:request withResult:result];
	}
}
void* _Nonnull
CBPeripheralManager_inst_ToOneRelationshipKeys(void* o) {
	NSArray* _Nonnull ret;
	@autoreleasepool {
		ret = [(CBPeripheralManager*)o toOneRelationshipKeys];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
void
CBPeripheralManager_inst_ReplaceValueAtIndexInPropertyWithKey(void* o, NSUInteger index, void* key, void* value) {
	@autoreleasepool {
		[(CBPeripheralManager*)o replaceValueAtIndex:index inPropertyWithKey:key withValue:value];
	}
}
void
CBPeripheralManager_inst_ReplaceValueAtIndexInPropertyWithKeyWithValue(void* o, NSUInteger index, void* key, void* value) {
	@autoreleasepool {
		[(CBPeripheralManager*)o replaceValueAtIndex:index inPropertyWithKey:key withValue:value];
	}
}
BOOL
CBPeripheralManager_inst_IsNotEqualTo(void* o, void* object) {
	BOOL ret;
	@autoreleasepool {
		ret = [(CBPeripheralManager*)o isNotEqualTo:object];
	}
	return ret;

}
void
CBPeripheralManager_inst_DidChangeValueForKey(void* o, void* key) {
	@autoreleasepool {
		[(CBPeripheralManager*)o didChangeValueForKey:key];
	}
}
void
CBPeripheralManager_inst_DidChangeValueForKeyWithSetMutation(void* o, void* key, NSKeyValueSetMutationKind mutationKind, void* objects) {
	@autoreleasepool {
		[(CBPeripheralManager*)o didChangeValueForKey:key withSetMutation:mutationKind usingObjects:objects];
	}
}
void
CBPeripheralManager_inst_DidChangeValueForKeyWithSetMutationUsingObjects(void* o, void* key, NSKeyValueSetMutationKind mutationKind, void* objects) {
	@autoreleasepool {
		[(CBPeripheralManager*)o didChangeValueForKey:key withSetMutation:mutationKind usingObjects:objects];
	}
}
void* _Nullable
CBPeripheralManager_inst_ObjectSpecifier(void* o) {
	NSScriptObjectSpecifier* _Nullable ret;
	@autoreleasepool {
		ret = [(CBPeripheralManager*)o objectSpecifier];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
void* _Nullable
CBPeripheralManager_inst_ScriptingValueForSpecifier(void* o, void* objectSpecifier) {
	NSObject* _Nullable ret;
	@autoreleasepool {
		ret = [(CBPeripheralManager*)o scriptingValueForSpecifier:objectSpecifier];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
void* _Nonnull
CBPeripheralManager_inst_MutableArrayValueForKey(void* o, void* key) {
	NSMutableArray* _Nonnull ret;
	@autoreleasepool {
		ret = [(CBPeripheralManager*)o mutableArrayValueForKey:key];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
void*
CBPeripheralManager_inst_ObservationInfo(void* o) {
	void* ret;
	@autoreleasepool {
		ret = [(CBPeripheralManager*)o observationInfo];
	}
	return ret;

}
void*
CBPeripheralManager_inst_ForwardingTargetForSelector(void* o, void* aSelector) {
	NSObject* ret;
	@autoreleasepool {
		ret = [(CBPeripheralManager*)o forwardingTargetForSelector:aSelector];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
BOOL
CBPeripheralManager_inst_ScriptingContains(void* o, void* object) {
	BOOL ret;
	@autoreleasepool {
		ret = [(CBPeripheralManager*)o scriptingContains:object];
	}
	return ret;

}
void
CBPeripheralManager_inst_PerformSelectorInBackgroundWithObject(void* o, void* aSelector, void* arg) {
	@autoreleasepool {
		[(CBPeripheralManager*)o performSelectorInBackground:aSelector withObject:arg];
	}
}
void* _Nonnull
CBPeripheralManager_inst_MutableOrderedSetValueForKeyPath(void* o, void* keyPath) {
	NSMutableOrderedSet* _Nonnull ret;
	@autoreleasepool {
		ret = [(CBPeripheralManager*)o mutableOrderedSetValueForKeyPath:keyPath];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
BOOL
CBPeripheralManager_inst_ValidateValueForKey(void* o, void** ioValue, void* inKey, void** outError) {
	BOOL ret;
	@autoreleasepool {
		ret = [(CBPeripheralManager*)o validateValue:(id _Nullable* _Nonnull)ioValue forKey:inKey error:(NSError* _Nullable* _Nullable)outError];
		for(int i=0;i<1;i++) {
			if(ioValue[i] == 0) { break; }
			[(id)ioValue[i] retain];
		}
	
	
		for(int i=0;i<1;i++) {
			if(outError[i] == 0) { break; }
			[(id)outError[i] retain];
		}
	
	}
	return ret;

}
BOOL
CBPeripheralManager_inst_ValidateValueForKeyPath(void* o, void** ioValue, void* inKeyPath, void** outError) {
	BOOL ret;
	@autoreleasepool {
		ret = [(CBPeripheralManager*)o validateValue:(id _Nullable* _Nonnull)ioValue forKeyPath:inKeyPath error:(NSError* _Nullable* _Nullable)outError];
		for(int i=0;i<1;i++) {
			if(ioValue[i] == 0) { break; }
			[(id)ioValue[i] retain];
		}
	
	
		for(int i=0;i<1;i++) {
			if(outError[i] == 0) { break; }
			[(id)outError[i] retain];
		}
	
	}
	return ret;

}
BOOL
CBPeripheralManager_inst_ValidateValueForKeyError(void* o, void** ioValue, void* inKey, void** outError) {
	BOOL ret;
	@autoreleasepool {
		ret = [(CBPeripheralManager*)o validateValue:(id _Nullable* _Nonnull)ioValue forKey:inKey error:(NSError* _Nullable* _Nullable)outError];
		for(int i=0;i<1;i++) {
			if(ioValue[i] == 0) { break; }
			[(id)ioValue[i] retain];
		}
	
	
		for(int i=0;i<1;i++) {
			if(outError[i] == 0) { break; }
			[(id)outError[i] retain];
		}
	
	}
	return ret;

}
BOOL
CBPeripheralManager_inst_ValidateValueForKeyPathError(void* o, void** ioValue, void* inKeyPath, void** outError) {
	BOOL ret;
	@autoreleasepool {
		ret = [(CBPeripheralManager*)o validateValue:(id _Nullable* _Nonnull)ioValue forKeyPath:inKeyPath error:(NSError* _Nullable* _Nullable)outError];
		for(int i=0;i<1;i++) {
			if(ioValue[i] == 0) { break; }
			[(id)ioValue[i] retain];
		}
	
	
		for(int i=0;i<1;i++) {
			if(outError[i] == 0) { break; }
			[(id)outError[i] retain];
		}
	
	}
	return ret;

}
CBManagerAuthorization
CBPeripheralManager_inst_Authorization(void* o) {
	CBManagerAuthorization ret;
	@autoreleasepool {
		ret = [(CBPeripheralManager*)o authorization];
	}
	return ret;

}
void* _Nonnull
CBPeripheralManager_inst_MutableSetValueForKey(void* o, void* key) {
	NSMutableSet* _Nonnull ret;
	@autoreleasepool {
		ret = [(CBPeripheralManager*)o mutableSetValueForKey:key];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
void* _Nonnull
CBPeripheralManager_inst_ClassName(void* o) {
	NSString* _Nonnull ret;
	@autoreleasepool {
		ret = [(CBPeripheralManager*)o className];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
void* _Nonnull
CBPeripheralManager_inst_ClassDescription(void* o) {
	NSClassDescription* _Nonnull ret;
	@autoreleasepool {
		ret = [(CBPeripheralManager*)o classDescription];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
void* _Nonnull
CBPeripheralManager_inst_InitWithDelegateQueue(void* o, void* delegate, void* queue) {
	CBPeripheralManager* _Nonnull ret;
	@autoreleasepool {
		ret = [(CBPeripheralManager*)o initWithDelegate:delegate queue:queue];
	}
	return ret;

}
void* _Nonnull
CBPeripheralManager_inst_InitWithDelegateQueueOptions(void* o, void* delegate, void* queue, void* options) {
	CBPeripheralManager* _Nonnull ret;
	@autoreleasepool {
		ret = [(CBPeripheralManager*)o initWithDelegate:delegate queue:queue options:options];
	}
	return ret;

}
void*
CBPeripheralManager_inst_Copy(void* o) {
	NSObject* ret;
	@autoreleasepool {
		ret = [(CBPeripheralManager*)o copy];
	}
	return ret;

}
void*
CBPeripheral_Superclass() {
	Class ret;
	@autoreleasepool {
		ret = [CBPeripheral superclass];
	}
	return ret;

}
BOOL
CBPeripheral_ConformsToProtocol(void* protocol) {
	BOOL ret;
	@autoreleasepool {
		ret = [CBPeripheral conformsToProtocol:protocol];
	}
	return ret;

}
void
CBPeripheral_CancelPreviousPerformRequestsWithTarget(void* aTarget) {
	@autoreleasepool {
		[CBPeripheral cancelPreviousPerformRequestsWithTarget:aTarget];
	}
}
void
CBPeripheral_CancelPreviousPerformRequestsWithTargetSelector(void* aTarget, void* aSelector, void* anArgument) {
	@autoreleasepool {
		[CBPeripheral cancelPreviousPerformRequestsWithTarget:aTarget selector:aSelector object:anArgument];
	}
}
void
CBPeripheral_CancelPreviousPerformRequestsWithTargetSelectorObject(void* aTarget, void* aSelector, void* anArgument) {
	@autoreleasepool {
		[CBPeripheral cancelPreviousPerformRequestsWithTarget:aTarget selector:aSelector object:anArgument];
	}
}
NSInteger
CBPeripheral_Version() {
	NSInteger ret;
	@autoreleasepool {
		ret = [CBPeripheral version];
	}
	return ret;

}
void*
CBPeripheral_DebugDescription() {
	NSString* ret;
	@autoreleasepool {
		ret = [CBPeripheral debugDescription];
	}
	return ret;

}
void*
CBPeripheral_Description() {
	NSString* ret;
	@autoreleasepool {
		ret = [CBPeripheral description];
	}
	return ret;

}
void*
CBPeripheral_Class() {
	Class ret;
	@autoreleasepool {
		ret = [CBPeripheral class];
	}
	return ret;

}
NSUInteger
CBPeripheral_Hash() {
	NSUInteger ret;
	@autoreleasepool {
		ret = [CBPeripheral hash];
	}
	return ret;

}
BOOL
CBPeripheral_AutomaticallyNotifiesObserversForKey(void* key) {
	BOOL ret;
	@autoreleasepool {
		ret = [CBPeripheral automaticallyNotifiesObserversForKey:key];
	}
	return ret;

}
void
CBPeripheral_Load() {
	@autoreleasepool {
		[CBPeripheral load];
	}
}
void*
CBPeripheral_Alloc() {
	return [CBPeripheral alloc];
}
void*
CBPeripheral_CopyWithZone(void* zone) {
	NSObject* ret;
	@autoreleasepool {
		ret = [CBPeripheral copyWithZone:zone];
	}
	return ret;

}
BOOL
CBPeripheral_AccessInstanceVariablesDirectly() {
	BOOL ret;
	@autoreleasepool {
		ret = [CBPeripheral accessInstanceVariablesDirectly];
	}
	return ret;

}
void* _Nonnull
CBPeripheral_ClassFallbacksForKeyedArchiver() {
	NSArray* _Nonnull ret;
	@autoreleasepool {
		ret = [CBPeripheral classFallbacksForKeyedArchiver];
	}
	return ret;

}
void
CBPeripheral_SetVersion(NSInteger aVersion) {
	@autoreleasepool {
		[CBPeripheral setVersion:aVersion];
	}
}
void* _Nonnull
CBPeripheral_KeyPathsForValuesAffectingValueForKey(void* key) {
	NSSet* _Nonnull ret;
	@autoreleasepool {
		ret = [CBPeripheral keyPathsForValuesAffectingValueForKey:key];
	}
	return ret;

}
void* _Nonnull
CBPeripheral_ClassForKeyedUnarchiver() {
	Class _Nonnull ret;
	@autoreleasepool {
		ret = [CBPeripheral classForKeyedUnarchiver];
	}
	return ret;

}
BOOL
CBPeripheral_ResolveInstanceMethod(void* sel) {
	BOOL ret;
	@autoreleasepool {
		ret = [CBPeripheral resolveInstanceMethod:sel];
	}
	return ret;

}
BOOL
CBPeripheral_IsSubclassOfClass(void* aClass) {
	BOOL ret;
	@autoreleasepool {
		ret = [CBPeripheral isSubclassOfClass:aClass];
	}
	return ret;

}
void*
CBPeripheral_MutableCopyWithZone(void* zone) {
	NSObject* ret;
	@autoreleasepool {
		ret = [CBPeripheral mutableCopyWithZone:zone];
	}
	return ret;

}
void*
CBPeripheral_InstanceMethodSignatureForSelector(void* aSelector) {
	NSMethodSignature* ret;
	@autoreleasepool {
		ret = [CBPeripheral instanceMethodSignatureForSelector:aSelector];
	}
	return ret;

}
BOOL
CBPeripheral_InstancesRespondToSelector(void* aSelector) {
	BOOL ret;
	@autoreleasepool {
		ret = [CBPeripheral instancesRespondToSelector:aSelector];
	}
	return ret;

}
void*
CBPeripheral_New() {
	CBPeripheral* ret;
	@autoreleasepool {
		NSLog(@"CBPeripheral new");
		//ret = [CBPeripheral new];
	}
	return ret;

}
BOOL
CBPeripheral_ResolveClassMethod(void* sel) {
	BOOL ret;
	@autoreleasepool {
		ret = [CBPeripheral resolveClassMethod:sel];
	}
	return ret;

}
void*
CBPeripheral_AllocWithZone(void* zone) {
	return [CBPeripheral allocWithZone:zone];
}
void* _Nonnull
CBPeripheral_inst_MutableArrayValueForKeyPath(void* o, void* keyPath) {
	NSMutableArray* _Nonnull ret;
	@autoreleasepool {
		ret = [(CBPeripheral*)o mutableArrayValueForKeyPath:keyPath];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
void
CBPeripheral_inst_SetNotifyValue(void* o, BOOL enabled, void* characteristic) {
	@autoreleasepool {
		[(CBPeripheral*)o setNotifyValue:enabled forCharacteristic:characteristic];
	}
}
FourCharCode
CBPeripheral_inst_ClassCode(void* o) {
	FourCharCode ret;
	@autoreleasepool {
		ret = [(CBPeripheral*)o classCode];
	}
	return ret;

}
void*
CBPeripheral_inst_Copy(void* o) {
	NSObject* ret;
	@autoreleasepool {
		ret = [(CBPeripheral*)o copy];
	}
	return ret;

}
void
CBPeripheral_inst_ObserveValueForKeyPathOfObject(void* o, void* keyPath, void* object, void* change, void* context) {
	@autoreleasepool {
		[(CBPeripheral*)o observeValueForKeyPath:keyPath ofObject:object change:change context:context];
	}
}
void
CBPeripheral_inst_ObserveValueForKeyPathOfObjectChange(void* o, void* keyPath, void* object, void* change, void* context) {
	@autoreleasepool {
		[(CBPeripheral*)o observeValueForKeyPath:keyPath ofObject:object change:change context:context];
	}
}
void*
CBPeripheral_inst_ForwardingTargetForSelector(void* o, void* aSelector) {
	NSObject* ret;
	@autoreleasepool {
		ret = [(CBPeripheral*)o forwardingTargetForSelector:aSelector];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
void* _Nullable
CBPeripheral_inst_ValueForUndefinedKey(void* o, void* key) {
	NSObject* _Nullable ret;
	@autoreleasepool {
		ret = [(CBPeripheral*)o valueForUndefinedKey:key];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
BOOL
CBPeripheral_inst_IsLessThanOrEqualTo(void* o, void* object) {
	BOOL ret;
	@autoreleasepool {
		ret = [(CBPeripheral*)o isLessThanOrEqualTo:object];
	}
	return ret;

}
void* _Nonnull
CBPeripheral_inst_AutoContentAccessingProxy(void* o) {
	NSObject* _Nonnull ret;
	@autoreleasepool {
		ret = [(CBPeripheral*)o autoContentAccessingProxy];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
void
CBPeripheral_inst_SetValueForKey(void* o, void* value, void* key) {
	@autoreleasepool {
		[(CBPeripheral*)o setValue:value forKey:key];
	}
}
void
CBPeripheral_inst_SetValueForKeyPath(void* o, void* value, void* keyPath) {
	@autoreleasepool {
		[(CBPeripheral*)o setValue:value forKeyPath:keyPath];
	}
}
void
CBPeripheral_inst_SetValueForUndefinedKey(void* o, void* value, void* key) {
	@autoreleasepool {
		[(CBPeripheral*)o setValue:value forUndefinedKey:key];
	}
}
BOOL
CBPeripheral_inst_ScriptingEndsWith(void* o, void* object) {
	BOOL ret;
	@autoreleasepool {
		ret = [(CBPeripheral*)o scriptingEndsWith:object];
	}
	return ret;

}
void* _Nonnull
CBPeripheral_inst_MutableOrderedSetValueForKeyPath(void* o, void* keyPath) {
	NSMutableOrderedSet* _Nonnull ret;
	@autoreleasepool {
		ret = [(CBPeripheral*)o mutableOrderedSetValueForKeyPath:keyPath];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
void* _Nullable
CBPeripheral_inst_IndicesOfObjectsByEvaluatingObjectSpecifier(void* o, void* specifier) {
	NSArray* _Nullable ret;
	@autoreleasepool {
		ret = [(CBPeripheral*)o indicesOfObjectsByEvaluatingObjectSpecifier:specifier];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
void* _Nullable
CBPeripheral_inst_ValueWithNameInPropertyWithKey(void* o, void* name, void* key) {
	NSObject* _Nullable ret;
	@autoreleasepool {
		ret = [(CBPeripheral*)o valueWithName:name inPropertyWithKey:key];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
void
CBPeripheral_inst_SetObservationInfo(void* o, void* observationInfo) {
	@autoreleasepool {
		[(CBPeripheral*)o setObservationInfo:observationInfo];
	}
}
BOOL
CBPeripheral_inst_ScriptingIsGreaterThan(void* o, void* object) {
	BOOL ret;
	@autoreleasepool {
		ret = [(CBPeripheral*)o scriptingIsGreaterThan:object];
	}
	return ret;

}
void
CBPeripheral_inst_DidChangeValueForKey(void* o, void* key) {
	@autoreleasepool {
		[(CBPeripheral*)o didChangeValueForKey:key];
	}
}
void
CBPeripheral_inst_DidChangeValueForKeyWithSetMutation(void* o, void* key, NSKeyValueSetMutationKind mutationKind, void* objects) {
	@autoreleasepool {
		[(CBPeripheral*)o didChangeValueForKey:key withSetMutation:mutationKind usingObjects:objects];
	}
}
void
CBPeripheral_inst_DidChangeValueForKeyWithSetMutationUsingObjects(void* o, void* key, NSKeyValueSetMutationKind mutationKind, void* objects) {
	@autoreleasepool {
		[(CBPeripheral*)o didChangeValueForKey:key withSetMutation:mutationKind usingObjects:objects];
	}
}
void
CBPeripheral_inst_ReadRSSI(void* o) {
	@autoreleasepool {
		[(CBPeripheral*)o readRSSI];
	}
}
void* _Nonnull
CBPeripheral_inst_ToOneRelationshipKeys(void* o) {
	NSArray* _Nonnull ret;
	@autoreleasepool {
		ret = [(CBPeripheral*)o toOneRelationshipKeys];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
void* _Nullable
CBPeripheral_inst_ValueAtIndexInPropertyWithKey(void* o, NSUInteger index, void* key) {
	NSObject* _Nullable ret;
	@autoreleasepool {
		ret = [(CBPeripheral*)o valueAtIndex:index inPropertyWithKey:key];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
BOOL
CBPeripheral_inst_IsLike(void* o, void* object) {
	BOOL ret;
	@autoreleasepool {
		ret = [(CBPeripheral*)o isLike:object];
	}
	return ret;

}
NSUInteger
CBPeripheral_inst_MaximumWriteValueLengthForType(void* o, CBCharacteristicWriteType type) {
	NSUInteger ret;
	@autoreleasepool {
		ret = [(CBPeripheral*)o maximumWriteValueLengthForType:type];
	}
	return ret;

}
BOOL
CBPeripheral_inst_CanSendWriteWithoutResponse(void* o) {
	BOOL ret;
	@autoreleasepool {
		ret = [(CBPeripheral*)o canSendWriteWithoutResponse];
	}
	return ret;

}
BOOL
CBPeripheral_inst_ScriptingIsEqualTo(void* o, void* object) {
	BOOL ret;
	@autoreleasepool {
		ret = [(CBPeripheral*)o scriptingIsEqualTo:object];
	}
	return ret;

}
void* _Nullable
CBPeripheral_inst_InverseForRelationshipKey(void* o, void* relationshipKey) {
	NSString* _Nullable ret;
	@autoreleasepool {
		ret = [(CBPeripheral*)o inverseForRelationshipKey:relationshipKey];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
void* _Nullable
CBPeripheral_inst_ClassForKeyedArchiver(void* o) {
	Class _Nullable ret;
	@autoreleasepool {
		ret = [(CBPeripheral*)o classForKeyedArchiver];
	}
	return ret;

}
BOOL
CBPeripheral_inst_IsLessThan(void* o, void* object) {
	BOOL ret;
	@autoreleasepool {
		ret = [(CBPeripheral*)o isLessThan:object];
	}
	return ret;

}
void* _Nullable
CBPeripheral_inst_ScriptingValueForSpecifier(void* o, void* objectSpecifier) {
	NSObject* _Nullable ret;
	@autoreleasepool {
		ret = [(CBPeripheral*)o scriptingValueForSpecifier:objectSpecifier];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
void
CBPeripheral_inst_SetScriptingProperties(void* o, void* scriptingProperties) {
	@autoreleasepool {
		[(CBPeripheral*)o setScriptingProperties:scriptingProperties];
	}
}
void*
CBPeripheral_inst_MethodSignatureForSelector(void* o, void* aSelector) {
	NSMethodSignature* ret;
	@autoreleasepool {
		ret = [(CBPeripheral*)o methodSignatureForSelector:aSelector];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
BOOL
CBPeripheral_inst_ValidateValueForKey(void* o, void** ioValue, void* inKey, void** outError) {
	BOOL ret;
	@autoreleasepool {
		ret = [(CBPeripheral*)o validateValue:(id _Nullable* _Nonnull)ioValue forKey:inKey error:(NSError* _Nullable* _Nullable)outError];
		for(int i=0;i<1;i++) {
			if(ioValue[i] == 0) { break; }
			[(id)ioValue[i] retain];
		}
	
	
		for(int i=0;i<1;i++) {
			if(outError[i] == 0) { break; }
			[(id)outError[i] retain];
		}
	
	}
	return ret;

}
BOOL
CBPeripheral_inst_ValidateValueForKeyPath(void* o, void** ioValue, void* inKeyPath, void** outError) {
	BOOL ret;
	@autoreleasepool {
		ret = [(CBPeripheral*)o validateValue:(id _Nullable* _Nonnull)ioValue forKeyPath:inKeyPath error:(NSError* _Nullable* _Nullable)outError];
		for(int i=0;i<1;i++) {
			if(ioValue[i] == 0) { break; }
			[(id)ioValue[i] retain];
		}
	
	
		for(int i=0;i<1;i++) {
			if(outError[i] == 0) { break; }
			[(id)outError[i] retain];
		}
	
	}
	return ret;

}
BOOL
CBPeripheral_inst_ValidateValueForKeyError(void* o, void** ioValue, void* inKey, void** outError) {
	BOOL ret;
	@autoreleasepool {
		ret = [(CBPeripheral*)o validateValue:(id _Nullable* _Nonnull)ioValue forKey:inKey error:(NSError* _Nullable* _Nullable)outError];
		for(int i=0;i<1;i++) {
			if(ioValue[i] == 0) { break; }
			[(id)ioValue[i] retain];
		}
	
	
		for(int i=0;i<1;i++) {
			if(outError[i] == 0) { break; }
			[(id)outError[i] retain];
		}
	
	}
	return ret;

}
BOOL
CBPeripheral_inst_ValidateValueForKeyPathError(void* o, void** ioValue, void* inKeyPath, void** outError) {
	BOOL ret;
	@autoreleasepool {
		ret = [(CBPeripheral*)o validateValue:(id _Nullable* _Nonnull)ioValue forKeyPath:inKeyPath error:(NSError* _Nullable* _Nullable)outError];
		for(int i=0;i<1;i++) {
			if(ioValue[i] == 0) { break; }
			[(id)ioValue[i] retain];
		}
	
	
		for(int i=0;i<1;i++) {
			if(outError[i] == 0) { break; }
			[(id)outError[i] retain];
		}
	
	}
	return ret;

}
BOOL
CBPeripheral_inst_IsEqualTo(void* o, void* object) {
	BOOL ret;
	@autoreleasepool {
		ret = [(CBPeripheral*)o isEqualTo:object];
	}
	return ret;

}
void
CBPeripheral_inst_WillChangeValueForKey(void* o, void* key) {
	@autoreleasepool {
		[(CBPeripheral*)o willChangeValueForKey:key];
	}
}
void
CBPeripheral_inst_WillChangeValueForKeyWithSetMutation(void* o, void* key, NSKeyValueSetMutationKind mutationKind, void* objects) {
	@autoreleasepool {
		[(CBPeripheral*)o willChangeValueForKey:key withSetMutation:mutationKind usingObjects:objects];
	}
}
void
CBPeripheral_inst_WillChangeValueForKeyWithSetMutationUsingObjects(void* o, void* key, NSKeyValueSetMutationKind mutationKind, void* objects) {
	@autoreleasepool {
		[(CBPeripheral*)o willChangeValueForKey:key withSetMutation:mutationKind usingObjects:objects];
	}
}
void* _Nonnull
CBPeripheral_inst_AttributeKeys(void* o) {
	NSArray* _Nonnull ret;
	@autoreleasepool {
		ret = [(CBPeripheral*)o attributeKeys];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
BOOL
CBPeripheral_inst_IsGreaterThanOrEqualTo(void* o, void* object) {
	BOOL ret;
	@autoreleasepool {
		ret = [(CBPeripheral*)o isGreaterThanOrEqualTo:object];
	}
	return ret;

}
void
CBPeripheral_inst_WriteValueForDescriptor(void* o, void* data, void* descriptor) {
	@autoreleasepool {
		[(CBPeripheral*)o writeValue:data forDescriptor:descriptor];
	}
}
void
CBPeripheral_inst_WriteValueForCharacteristic(void* o, void* data, void* characteristic, CBCharacteristicWriteType type) {
	@autoreleasepool {
		[(CBPeripheral*)o writeValue:data forCharacteristic:characteristic type:type];
	}
}
void
CBPeripheral_inst_OpenL2CAPChannel(void* o, CBL2CAPPSM PSM) {
	@autoreleasepool {
		[(CBPeripheral*)o openL2CAPChannel:PSM];
	}
}
BOOL
CBPeripheral_inst_ScriptingIsGreaterThanOrEqualTo(void* o, void* object) {
	BOOL ret;
	@autoreleasepool {
		ret = [(CBPeripheral*)o scriptingIsGreaterThanOrEqualTo:object];
	}
	return ret;

}
void
CBPeripheral_inst_WillChangeValuesAtIndexes(void* o, NSKeyValueChange changeKind, void* indexes, void* key) {
	@autoreleasepool {
		[(CBPeripheral*)o willChange:changeKind valuesAtIndexes:indexes forKey:key];
	}
}
void
CBPeripheral_inst_WillChangeValuesAtIndexesForKey(void* o, NSKeyValueChange changeKind, void* indexes, void* key) {
	@autoreleasepool {
		[(CBPeripheral*)o willChange:changeKind valuesAtIndexes:indexes forKey:key];
	}
}
void
CBPeripheral_inst_RemoveObserverForKeyPath(void* o, void* observer, void* keyPath) {
	@autoreleasepool {
		[(CBPeripheral*)o removeObserver:observer forKeyPath:keyPath];
	}
}
void
CBPeripheral_inst_RemoveObserverForKeyPathContext(void* o, void* observer, void* keyPath, void* context) {
	@autoreleasepool {
		[(CBPeripheral*)o removeObserver:observer forKeyPath:keyPath context:context];
	}
}
void* _Nullable
CBPeripheral_inst_ValueForKey(void* o, void* key) {
	NSObject* _Nullable ret;
	@autoreleasepool {
		ret = [(CBPeripheral*)o valueForKey:key];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
void* _Nullable
CBPeripheral_inst_CoerceValueForKey(void* o, void* value, void* key) {
	NSObject* _Nullable ret;
	@autoreleasepool {
		ret = [(CBPeripheral*)o coerceValue:value forKey:key];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
void
CBPeripheral_inst_ForwardInvocation(void* o, void* anInvocation) {
	@autoreleasepool {
		[(CBPeripheral*)o forwardInvocation:anInvocation];
	}
}
void
CBPeripheral_inst_ReadValueForCharacteristic(void* o, void* characteristic) {
	@autoreleasepool {
		[(CBPeripheral*)o readValueForCharacteristic:characteristic];
	}
}
void*
CBPeripheral_inst_Identifier(void* o) {
	NSUUID* ret;
	@autoreleasepool {
		ret = [(CBPeripheral*)o identifier];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
void
CBPeripheral_inst_Dealloc(void* o) {
	@autoreleasepool {
		[(CBPeripheral*)o dealloc];
	}
}
BOOL
CBPeripheral_inst_AttemptRecoveryFromErrorOptionIndex(void* o, void* error, NSUInteger recoveryOptionIndex) {
	BOOL ret;
	@autoreleasepool {
		ret = [(CBPeripheral*)o attemptRecoveryFromError:error optionIndex:recoveryOptionIndex];
	}
	return ret;

}
void
CBPeripheral_inst_AttemptRecoveryFromErrorOptionIndexDelegate(void* o, void* error, NSUInteger recoveryOptionIndex, void* delegate, void* didRecoverSelector, void* contextInfo) {
	@autoreleasepool {
		[(CBPeripheral*)o attemptRecoveryFromError:error optionIndex:recoveryOptionIndex delegate:delegate didRecoverSelector:didRecoverSelector contextInfo:contextInfo];
	}
}
void
CBPeripheral_inst_AttemptRecoveryFromErrorOptionIndexDelegateDidRecoverSelector(void* o, void* error, NSUInteger recoveryOptionIndex, void* delegate, void* didRecoverSelector, void* contextInfo) {
	@autoreleasepool {
		[(CBPeripheral*)o attemptRecoveryFromError:error optionIndex:recoveryOptionIndex delegate:delegate didRecoverSelector:didRecoverSelector contextInfo:contextInfo];
	}
}
void* _Nonnull
CBPeripheral_inst_MutableArrayValueForKey(void* o, void* key) {
	NSMutableArray* _Nonnull ret;
	@autoreleasepool {
		ret = [(CBPeripheral*)o mutableArrayValueForKey:key];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
void* _Nullable
CBPeripheral_inst_NewScriptingObjectOfClassForValueForKey(void* o, void* objectClass, void* key, void* contentsValue, void* properties) {
	NSObject* _Nullable ret;
	@autoreleasepool {
		ret = [(CBPeripheral*)o newScriptingObjectOfClass:objectClass forValueForKey:key withContentsValue:contentsValue properties:properties];
	}
	return ret;

}
void* _Nullable
CBPeripheral_inst_NewScriptingObjectOfClassForValueForKeyWithContentsValue(void* o, void* objectClass, void* key, void* contentsValue, void* properties) {
	NSObject* _Nullable ret;
	@autoreleasepool {
		ret = [(CBPeripheral*)o newScriptingObjectOfClass:objectClass forValueForKey:key withContentsValue:contentsValue properties:properties];
	}
	return ret;

}
void
CBPeripheral_inst_PerformSelectorInBackgroundWithObject(void* o, void* aSelector, void* arg) {
	@autoreleasepool {
		[(CBPeripheral*)o performSelectorInBackground:aSelector withObject:arg];
	}
}
void* _Nullable
CBPeripheral_inst_ReplacementObjectForCoder(void* o, void* coder) {
	NSObject* _Nullable ret;
	@autoreleasepool {
		ret = [(CBPeripheral*)o replacementObjectForCoder:coder];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
void
CBPeripheral_inst_SetNilValueForKey(void* o, void* key) {
	@autoreleasepool {
		[(CBPeripheral*)o setNilValueForKey:key];
	}
}
void* _Nullable
CBPeripheral_inst_ScriptingProperties(void* o) {
	NSDictionary* _Nullable ret;
	@autoreleasepool {
		ret = [(CBPeripheral*)o scriptingProperties];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
void* _Nullable
CBPeripheral_inst_ClassForArchiver(void* o) {
	Class _Nullable ret;
	@autoreleasepool {
		ret = [(CBPeripheral*)o classForArchiver];
	}
	return ret;

}
BOOL
CBPeripheral_inst_ScriptingIsLessThanOrEqualTo(void* o, void* object) {
	BOOL ret;
	@autoreleasepool {
		ret = [(CBPeripheral*)o scriptingIsLessThanOrEqualTo:object];
	}
	return ret;

}
void* _Nonnull
CBPeripheral_inst_MutableSetValueForKeyPath(void* o, void* keyPath) {
	NSMutableSet* _Nonnull ret;
	@autoreleasepool {
		ret = [(CBPeripheral*)o mutableSetValueForKeyPath:keyPath];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
void
CBPeripheral_inst_DiscoverCharacteristics(void* o, void* characteristicUUIDs, void* service) {
	@autoreleasepool {
		[(CBPeripheral*)o discoverCharacteristics:characteristicUUIDs forService:service];
	}
}
void
CBPeripheral_inst_SetDelegate(void* o, void* delegate) {
	@autoreleasepool {
		[(CBPeripheral*)o setDelegate:delegate];
	}
}
CBPeripheralState
CBPeripheral_inst_State(void* o) {
	CBPeripheralState ret;
	@autoreleasepool {
		ret = [(CBPeripheral*)o state];
	}
	return ret;

}
void* _Nullable
CBPeripheral_inst_ValueWithUniqueIDInPropertyWithKey(void* o, void* uniqueID, void* key) {
	NSObject* _Nullable ret;
	@autoreleasepool {
		ret = [(CBPeripheral*)o valueWithUniqueID:uniqueID inPropertyWithKey:key];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
void* _Nonnull
CBPeripheral_inst_ClassName(void* o) {
	NSString* _Nonnull ret;
	@autoreleasepool {
		ret = [(CBPeripheral*)o className];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
void* _Nullable
CBPeripheral_inst_ObjectSpecifier(void* o) {
	NSScriptObjectSpecifier* _Nullable ret;
	@autoreleasepool {
		ret = [(CBPeripheral*)o objectSpecifier];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
void
CBPeripheral_inst_RemoveValueAtIndexFromPropertyWithKey(void* o, NSUInteger index, void* key) {
	@autoreleasepool {
		[(CBPeripheral*)o removeValueAtIndex:index fromPropertyWithKey:key];
	}
}
void
CBPeripheral_inst_AddObserverForKeyPath(void* o, void* observer, void* keyPath, NSKeyValueObservingOptions options, void* context) {
	@autoreleasepool {
		[(CBPeripheral*)o addObserver:observer forKeyPath:keyPath options:options context:context];
	}
}
void
CBPeripheral_inst_AddObserverForKeyPathOptions(void* o, void* observer, void* keyPath, NSKeyValueObservingOptions options, void* context) {
	@autoreleasepool {
		[(CBPeripheral*)o addObserver:observer forKeyPath:keyPath options:options context:context];
	}
}
void* _Nullable
CBPeripheral_inst_Name(void* o) {
	NSString* _Nullable ret;
	@autoreleasepool {
		ret = [(CBPeripheral*)o name];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
void* _Nonnull
CBPeripheral_inst_ClassForCoder(void* o) {
	Class _Nonnull ret;
	@autoreleasepool {
		ret = [(CBPeripheral*)o classForCoder];
	}
	return ret;

}
void* _Nonnull
CBPeripheral_inst_ClassDescription(void* o) {
	NSClassDescription* _Nonnull ret;
	@autoreleasepool {
		ret = [(CBPeripheral*)o classDescription];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
void
CBPeripheral_inst_DidChangeValuesAtIndexes(void* o, NSKeyValueChange changeKind, void* indexes, void* key) {
	@autoreleasepool {
		[(CBPeripheral*)o didChange:changeKind valuesAtIndexes:indexes forKey:key];
	}
}
void
CBPeripheral_inst_DidChangeValuesAtIndexesForKey(void* o, NSKeyValueChange changeKind, void* indexes, void* key) {
	@autoreleasepool {
		[(CBPeripheral*)o didChange:changeKind valuesAtIndexes:indexes forKey:key];
	}
}
BOOL
CBPeripheral_inst_DoesContain(void* o, void* object) {
	BOOL ret;
	@autoreleasepool {
		ret = [(CBPeripheral*)o doesContain:object];
	}
	return ret;

}
void
CBPeripheral_inst_PerformSelectorOnMainThreadWithObject(void* o, void* aSelector, void* arg, BOOL wait) {
	@autoreleasepool {
		[(CBPeripheral*)o performSelectorOnMainThread:aSelector withObject:arg waitUntilDone:wait];
	}
}
void
CBPeripheral_inst_PerformSelectorOnMainThreadWithObjectWaitUntilDone(void* o, void* aSelector, void* arg, BOOL wait) {
	@autoreleasepool {
		[(CBPeripheral*)o performSelectorOnMainThread:aSelector withObject:arg waitUntilDone:wait];
	}
}
void
CBPeripheral_inst_PerformSelectorOnMainThreadWithObjectWaitUntilDoneModes(void* o, void* aSelector, void* arg, BOOL wait, void* array) {
	@autoreleasepool {
		[(CBPeripheral*)o performSelectorOnMainThread:aSelector withObject:arg waitUntilDone:wait modes:array];
	}
}
void
CBPeripheral_inst_ReadValueForDescriptor(void* o, void* descriptor) {
	@autoreleasepool {
		[(CBPeripheral*)o readValueForDescriptor:descriptor];
	}
}
void* _Nonnull
CBPeripheral_inst_ToManyRelationshipKeys(void* o) {
	NSArray* _Nonnull ret;
	@autoreleasepool {
		ret = [(CBPeripheral*)o toManyRelationshipKeys];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
void
CBPeripheral_inst_PerformSelectorWithObject(void* o, void* aSelector, void* anArgument, NSTimeInterval delay) {
	@autoreleasepool {
		[(CBPeripheral*)o performSelector:aSelector withObject:anArgument afterDelay:delay];
	}
}
void
CBPeripheral_inst_PerformSelectorWithObjectAfterDelay(void* o, void* aSelector, void* anArgument, NSTimeInterval delay) {
	@autoreleasepool {
		[(CBPeripheral*)o performSelector:aSelector withObject:anArgument afterDelay:delay];
	}
}
void
CBPeripheral_inst_PerformSelectorWithObjectAfterDelayInModes(void* o, void* aSelector, void* anArgument, NSTimeInterval delay, void* modes) {
	@autoreleasepool {
		[(CBPeripheral*)o performSelector:aSelector withObject:anArgument afterDelay:delay inModes:modes];
	}
}
void
CBPeripheral_inst_PerformSelectorOnThread(void* o, void* aSelector, void* thr, void* arg, BOOL wait) {
	@autoreleasepool {
		[(CBPeripheral*)o performSelector:aSelector onThread:thr withObject:arg waitUntilDone:wait];
	}
}
void
CBPeripheral_inst_PerformSelectorOnThreadWithObject(void* o, void* aSelector, void* thr, void* arg, BOOL wait) {
	@autoreleasepool {
		[(CBPeripheral*)o performSelector:aSelector onThread:thr withObject:arg waitUntilDone:wait];
	}
}
void
CBPeripheral_inst_PerformSelectorOnThreadWithObjectWaitUntilDone(void* o, void* aSelector, void* thr, void* arg, BOOL wait, void* array) {
	@autoreleasepool {
		[(CBPeripheral*)o performSelector:aSelector onThread:thr withObject:arg waitUntilDone:wait modes:array];
	}
}
void
CBPeripheral_inst_PerformSelectorOnThreadWithObjectWaitUntilDoneModes(void* o, void* aSelector, void* thr, void* arg, BOOL wait, void* array) {
	@autoreleasepool {
		[(CBPeripheral*)o performSelector:aSelector onThread:thr withObject:arg waitUntilDone:wait modes:array];
	}
}
void* _Nullable
CBPeripheral_inst_ValueForKeyPath(void* o, void* keyPath) {
	NSObject* _Nullable ret;
	@autoreleasepool {
		ret = [(CBPeripheral*)o valueForKeyPath:keyPath];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
void
CBPeripheral_inst_ReplaceValueAtIndexInPropertyWithKey(void* o, NSUInteger index, void* key, void* value) {
	@autoreleasepool {
		[(CBPeripheral*)o replaceValueAtIndex:index inPropertyWithKey:key withValue:value];
	}
}
void
CBPeripheral_inst_ReplaceValueAtIndexInPropertyWithKeyWithValue(void* o, NSUInteger index, void* key, void* value) {
	@autoreleasepool {
		[(CBPeripheral*)o replaceValueAtIndex:index inPropertyWithKey:key withValue:value];
	}
}
void* _Nullable
CBPeripheral_inst_Services(void* o) {
	NSArray* _Nullable ret;
	@autoreleasepool {
		ret = [(CBPeripheral*)o services];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
void* _Nonnull
CBPeripheral_inst_MutableOrderedSetValueForKey(void* o, void* key) {
	NSMutableOrderedSet* _Nonnull ret;
	@autoreleasepool {
		ret = [(CBPeripheral*)o mutableOrderedSetValueForKey:key];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
void
CBPeripheral_inst_InsertValueInPropertyWithKey(void* o, void* value, void* key) {
	@autoreleasepool {
		[(CBPeripheral*)o insertValue:value inPropertyWithKey:key];
	}
}
void
CBPeripheral_inst_InsertValueAtIndex(void* o, void* value, NSUInteger index, void* key) {
	@autoreleasepool {
		[(CBPeripheral*)o insertValue:value atIndex:index inPropertyWithKey:key];
	}
}
void
CBPeripheral_inst_InsertValueAtIndexInPropertyWithKey(void* o, void* value, NSUInteger index, void* key) {
	@autoreleasepool {
		[(CBPeripheral*)o insertValue:value atIndex:index inPropertyWithKey:key];
	}
}
void*
CBPeripheral_inst_ObservationInfo(void* o) {
	void* ret;
	@autoreleasepool {
		ret = [(CBPeripheral*)o observationInfo];
	}
	return ret;

}
BOOL
CBPeripheral_inst_ScriptingIsLessThan(void* o, void* object) {
	BOOL ret;
	@autoreleasepool {
		ret = [(CBPeripheral*)o scriptingIsLessThan:object];
	}
	return ret;

}
void* _Nullable
CBPeripheral_inst_CopyScriptingValueForKey(void* o, void* value, void* key, void* properties) {
	NSObject* _Nullable ret;
	@autoreleasepool {
		ret = [(CBPeripheral*)o copyScriptingValue:value forKey:key withProperties:properties];
	}
	return ret;

}
void* _Nullable
CBPeripheral_inst_CopyScriptingValueForKeyWithProperties(void* o, void* value, void* key, void* properties) {
	NSObject* _Nullable ret;
	@autoreleasepool {
		ret = [(CBPeripheral*)o copyScriptingValue:value forKey:key withProperties:properties];
	}
	return ret;

}
BOOL
CBPeripheral_inst_IsGreaterThan(void* o, void* object) {
	BOOL ret;
	@autoreleasepool {
		ret = [(CBPeripheral*)o isGreaterThan:object];
	}
	return ret;

}
BOOL
CBPeripheral_inst_ScriptingBeginsWith(void* o, void* object) {
	BOOL ret;
	@autoreleasepool {
		ret = [(CBPeripheral*)o scriptingBeginsWith:object];
	}
	return ret;

}
void*
CBPeripheral_inst_MutableCopy(void* o) {
	NSObject* ret;
	@autoreleasepool {
		ret = [(CBPeripheral*)o mutableCopy];
	}
	return ret;

}
void
CBPeripheral_inst_DiscoverServices(void* o, void* serviceUUIDs) {
	@autoreleasepool {
		[(CBPeripheral*)o discoverServices:serviceUUIDs];
	}
}
void* _Nullable
CBPeripheral_inst_Delegate(void* o) {
	NSObject* _Nullable ret;
	@autoreleasepool {
		ret = [(CBPeripheral*)o delegate];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
void
CBPeripheral_inst_DiscoverIncludedServices(void* o, void* includedServiceUUIDs, void* service) {
	@autoreleasepool {
		[(CBPeripheral*)o discoverIncludedServices:includedServiceUUIDs forService:service];
	}
}
void* _Nonnull
CBPeripheral_inst_DictionaryWithValuesForKeys(void* o, void* keys) {
	NSDictionary* _Nonnull ret;
	@autoreleasepool {
		ret = [(CBPeripheral*)o dictionaryWithValuesForKeys:keys];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
BOOL
CBPeripheral_inst_IsNotEqualTo(void* o, void* object) {
	BOOL ret;
	@autoreleasepool {
		ret = [(CBPeripheral*)o isNotEqualTo:object];
	}
	return ret;

}
BOOL
CBPeripheral_inst_ScriptingContains(void* o, void* object) {
	BOOL ret;
	@autoreleasepool {
		ret = [(CBPeripheral*)o scriptingContains:object];
	}
	return ret;

}
void
CBPeripheral_inst_SetValuesForKeysWithDictionary(void* o, void* keyedValues) {
	@autoreleasepool {
		[(CBPeripheral*)o setValuesForKeysWithDictionary:keyedValues];
	}
}
void* _Nonnull
CBPeripheral_inst_MutableSetValueForKey(void* o, void* key) {
	NSMutableSet* _Nonnull ret;
	@autoreleasepool {
		ret = [(CBPeripheral*)o mutableSetValueForKey:key];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
void
CBPeripheral_inst_DiscoverDescriptorsForCharacteristic(void* o, void* characteristic) {
	@autoreleasepool {
		[(CBPeripheral*)o discoverDescriptorsForCharacteristic:characteristic];
	}
}
void* _Nullable
CBPeripheral_inst_ReplacementObjectForKeyedArchiver(void* o, void* archiver) {
	NSObject* _Nullable ret;
	@autoreleasepool {
		ret = [(CBPeripheral*)o replacementObjectForKeyedArchiver:archiver];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
void* _Nullable
CBPeripheral_inst_AwakeAfterUsingCoder(void* o, void* coder) {
	NSObject* _Nullable ret;
	@autoreleasepool {
		ret = [(CBPeripheral*)o awakeAfterUsingCoder:coder];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
BOOL
CBPeripheral_inst_IsCaseInsensitiveLike(void* o, void* object) {
	BOOL ret;
	@autoreleasepool {
		ret = [(CBPeripheral*)o isCaseInsensitiveLike:object];
	}
	return ret;

}
void
CBPeripheral_inst_DoesNotRecognizeSelector(void* o, void* aSelector) {
	@autoreleasepool {
		[(CBPeripheral*)o doesNotRecognizeSelector:aSelector];
	}
}
void*
NSString_Description() {
	NSString* ret;
	@autoreleasepool {
		ret = [NSString description];
	}
	return ret;

}
void* _Nonnull
NSString_StringWithString(void* string) {
	NSString* _Nonnull ret;
	@autoreleasepool {
		ret = [NSString stringWithString:string];
		if(ret != nil) { [ret retain]; }
	}
	return ret;

}
void* _Nonnull
NSString_StringWithFormat(void* format) {
	NSString* _Nonnull ret;
	@autoreleasepool {
		ret = [NSString stringWithFormat:format];
		if(ret != nil) { [ret retain]; }
	}
	return ret;

}
void* _Nullable
NSString_StringWithUTF8String(void* nullTerminatedCString) {
	NSString* _Nullable ret;
	@autoreleasepool {
		ret = [NSString stringWithUTF8String:nullTerminatedCString];
		if(ret != nil) { [ret retain]; }
	}
	return ret;

}
void* _Nonnull
NSString_LocalizedStringWithFormat(void* format) {
	NSString* _Nonnull ret;
	@autoreleasepool {
		ret = [NSString localizedStringWithFormat:format];
	}
	return ret;

}
void* _Nullable
NSString_StringWithContentsOfURLEncoding(void* url, NSStringEncoding enc, void** error) {
	NSString* _Nullable ret;
	@autoreleasepool {
		ret = [NSString stringWithContentsOfURL:url encoding:enc error:(NSError* _Nullable* _Nullable)error];
		if(ret != nil) { [ret retain]; }
		for(int i=0;i<1;i++) {
			if(error[i] == 0) { break; }
			[(id)error[i] retain];
		}
	
	}
	return ret;

}
void* _Nullable
NSString_StringWithContentsOfURLUsedEncoding(void* url, void* enc, void** error) {
	NSString* _Nullable ret;
	@autoreleasepool {
		ret = [NSString stringWithContentsOfURL:url usedEncoding:enc error:(NSError* _Nullable* _Nullable)error];
		if(ret != nil) { [ret retain]; }
		for(int i=0;i<1;i++) {
			if(error[i] == 0) { break; }
			[(id)error[i] retain];
		}
	
	}
	return ret;

}
void* _Nullable
NSString_StringWithContentsOfURLEncodingError(void* url, NSStringEncoding enc, void** error) {
	NSString* _Nullable ret;
	@autoreleasepool {
		ret = [NSString stringWithContentsOfURL:url encoding:enc error:(NSError* _Nullable* _Nullable)error];
		if(ret != nil) { [ret retain]; }
		for(int i=0;i<1;i++) {
			if(error[i] == 0) { break; }
			[(id)error[i] retain];
		}
	
	}
	return ret;

}
void* _Nullable
NSString_StringWithContentsOfURLUsedEncodingError(void* url, void* enc, void** error) {
	NSString* _Nullable ret;
	@autoreleasepool {
		ret = [NSString stringWithContentsOfURL:url usedEncoding:enc error:(NSError* _Nullable* _Nullable)error];
		if(ret != nil) { [ret retain]; }
		for(int i=0;i<1;i++) {
			if(error[i] == 0) { break; }
			[(id)error[i] retain];
		}
	
	}
	return ret;

}
void* _Nullable
NSString_StringWithCStringEncoding(void* cString, NSStringEncoding enc) {
	NSString* _Nullable ret;
	@autoreleasepool {
		ret = [NSString stringWithCString:cString encoding:enc];
		if(ret != nil) { [ret retain]; }
	}
	return ret;

}
BOOL
NSString_ResolveInstanceMethod(void* sel) {
	BOOL ret;
	@autoreleasepool {
		ret = [NSString resolveInstanceMethod:sel];
	}
	return ret;

}
void*
NSString_AllocWithZone(void* zone) {
	return [NSString allocWithZone:zone];
}
const void* _Nonnull
NSString_AvailableStringEncodings() {
	const NSStringEncoding* _Nonnull ret;
	@autoreleasepool {
		ret = [NSString availableStringEncodings];
	}
	return ret;

}
void* _Nonnull
NSString_LocalizedNameOfStringEncoding(NSStringEncoding encoding) {
	NSString* _Nonnull ret;
	@autoreleasepool {
		ret = [NSString localizedNameOfStringEncoding:encoding];
	}
	return ret;

}
void* _Nonnull
NSString_StringWithCharactersLength(void* characters, NSUInteger length) {
	NSString* _Nonnull ret;
	@autoreleasepool {
		ret = [NSString stringWithCharacters:characters length:length];
		if(ret != nil) { [ret retain]; }
	}
	return ret;

}
void* _Nullable
NSString_StringWithContentsOfFileEncoding(void* path, NSStringEncoding enc, void** error) {
	NSString* _Nullable ret;
	@autoreleasepool {
		ret = [NSString stringWithContentsOfFile:path encoding:enc error:(NSError* _Nullable* _Nullable)error];
		if(ret != nil) { [ret retain]; }
		for(int i=0;i<1;i++) {
			if(error[i] == 0) { break; }
			[(id)error[i] retain];
		}
	
	}
	return ret;

}
void* _Nullable
NSString_StringWithContentsOfFileUsedEncoding(void* path, void* enc, void** error) {
	NSString* _Nullable ret;
	@autoreleasepool {
		ret = [NSString stringWithContentsOfFile:path usedEncoding:enc error:(NSError* _Nullable* _Nullable)error];
		if(ret != nil) { [ret retain]; }
		for(int i=0;i<1;i++) {
			if(error[i] == 0) { break; }
			[(id)error[i] retain];
		}
	
	}
	return ret;

}
void* _Nullable
NSString_StringWithContentsOfFileEncodingError(void* path, NSStringEncoding enc, void** error) {
	NSString* _Nullable ret;
	@autoreleasepool {
		ret = [NSString stringWithContentsOfFile:path encoding:enc error:(NSError* _Nullable* _Nullable)error];
		if(ret != nil) { [ret retain]; }
		for(int i=0;i<1;i++) {
			if(error[i] == 0) { break; }
			[(id)error[i] retain];
		}
	
	}
	return ret;

}
void* _Nullable
NSString_StringWithContentsOfFileUsedEncodingError(void* path, void* enc, void** error) {
	NSString* _Nullable ret;
	@autoreleasepool {
		ret = [NSString stringWithContentsOfFile:path usedEncoding:enc error:(NSError* _Nullable* _Nullable)error];
		if(ret != nil) { [ret retain]; }
		for(int i=0;i<1;i++) {
			if(error[i] == 0) { break; }
			[(id)error[i] retain];
		}
	
	}
	return ret;

}
void* _Nonnull
NSString_ClassFallbacksForKeyedArchiver() {
	NSArray* _Nonnull ret;
	@autoreleasepool {
		ret = [NSString classFallbacksForKeyedArchiver];
	}
	return ret;

}
NSUInteger
NSString_Hash() {
	NSUInteger ret;
	@autoreleasepool {
		ret = [NSString hash];
	}
	return ret;

}
void* _Nonnull
NSString_WritableTypeIdentifiersForItemProvider() {
	NSArray* _Nonnull ret;
	@autoreleasepool {
		ret = [NSString writableTypeIdentifiersForItemProvider];
	}
	return ret;

}
void* _Nonnull
NSString_KeyPathsForValuesAffectingValueForKey(void* key) {
	NSSet* _Nonnull ret;
	@autoreleasepool {
		ret = [NSString keyPathsForValuesAffectingValueForKey:key];
	}
	return ret;

}
BOOL
NSString_SupportsSecureCoding() {
	BOOL ret;
	@autoreleasepool {
		ret = [NSString supportsSecureCoding];
	}
	return ret;

}
void* _Nonnull
NSString_String() {
	NSString* _Nonnull ret;
	@autoreleasepool {
		ret = [NSString string];
		if(ret != nil) { [ret retain]; }
	}
	return ret;

}
BOOL
NSString_AccessInstanceVariablesDirectly() {
	BOOL ret;
	@autoreleasepool {
		ret = [NSString accessInstanceVariablesDirectly];
	}
	return ret;

}
void
NSString_SetVersion(NSInteger aVersion) {
	@autoreleasepool {
		[NSString setVersion:aVersion];
	}
}
void*
NSString_InstanceMethodSignatureForSelector(void* aSelector) {
	NSMethodSignature* ret;
	@autoreleasepool {
		ret = [NSString instanceMethodSignatureForSelector:aSelector];
	}
	return ret;

}
void
NSString_CancelPreviousPerformRequestsWithTarget(void* aTarget) {
	@autoreleasepool {
		[NSString cancelPreviousPerformRequestsWithTarget:aTarget];
	}
}
void
NSString_CancelPreviousPerformRequestsWithTargetSelector(void* aTarget, void* aSelector, void* anArgument) {
	@autoreleasepool {
		[NSString cancelPreviousPerformRequestsWithTarget:aTarget selector:aSelector object:anArgument];
	}
}
void
NSString_CancelPreviousPerformRequestsWithTargetSelectorObject(void* aTarget, void* aSelector, void* anArgument) {
	@autoreleasepool {
		[NSString cancelPreviousPerformRequestsWithTarget:aTarget selector:aSelector object:anArgument];
	}
}
void*
NSString_DebugDescription() {
	NSString* ret;
	@autoreleasepool {
		ret = [NSString debugDescription];
	}
	return ret;

}
void* _Nonnull
NSString_ReadableTypeIdentifiersForItemProvider() {
	NSArray* _Nonnull ret;
	@autoreleasepool {
		ret = [NSString readableTypeIdentifiersForItemProvider];
	}
	return ret;

}
NSItemProviderRepresentationVisibility
NSString_ItemProviderVisibilityForRepresentationWithTypeIdentifier(void* typeIdentifier) {
	NSItemProviderRepresentationVisibility ret;
	@autoreleasepool {
		ret = [NSString itemProviderVisibilityForRepresentationWithTypeIdentifier:typeIdentifier];
	}
	return ret;

}
BOOL
NSString_IsSubclassOfClass(void* aClass) {
	BOOL ret;
	@autoreleasepool {
		ret = [NSString isSubclassOfClass:aClass];
	}
	return ret;

}
void
NSString_Load() {
	@autoreleasepool {
		[NSString load];
	}
}
BOOL
NSString_InstancesRespondToSelector(void* aSelector) {
	BOOL ret;
	@autoreleasepool {
		ret = [NSString instancesRespondToSelector:aSelector];
	}
	return ret;

}
void* _Nullable
NSString_ObjectWithItemProviderDataTypeIdentifier(void* data, void* typeIdentifier, void** outError) {
	NSString* _Nullable ret;
	@autoreleasepool {
		ret = [NSString objectWithItemProviderData:data typeIdentifier:typeIdentifier error:(NSError* _Nullable* _Nullable)outError];
		for(int i=0;i<1;i++) {
			if(outError[i] == 0) { break; }
			[(id)outError[i] retain];
		}
	
	}
	return ret;

}
void* _Nullable
NSString_ObjectWithItemProviderDataTypeIdentifierError(void* data, void* typeIdentifier, void** outError) {
	NSString* _Nullable ret;
	@autoreleasepool {
		ret = [NSString objectWithItemProviderData:data typeIdentifier:typeIdentifier error:(NSError* _Nullable* _Nullable)outError];
		for(int i=0;i<1;i++) {
			if(outError[i] == 0) { break; }
			[(id)outError[i] retain];
		}
	
	}
	return ret;

}
NSStringEncoding
NSString_DefaultCStringEncoding() {
	NSStringEncoding ret;
	@autoreleasepool {
		ret = [NSString defaultCStringEncoding];
	}
	return ret;

}
void*
NSString_Alloc() {
	return [NSString alloc];
}
void*
NSString_Class() {
	Class ret;
	@autoreleasepool {
		ret = [NSString class];
	}
	return ret;

}
void*
NSString_Superclass() {
	Class ret;
	@autoreleasepool {
		ret = [NSString superclass];
	}
	return ret;

}
void*
NSString_New() {
	NSString* ret;
	@autoreleasepool {
		ret = [NSString new];
	}
	return ret;

}
BOOL
NSString_AutomaticallyNotifiesObserversForKey(void* key) {
	BOOL ret;
	@autoreleasepool {
		ret = [NSString automaticallyNotifiesObserversForKey:key];
	}
	return ret;

}
BOOL
NSString_ConformsToProtocol(void* protocol) {
	BOOL ret;
	@autoreleasepool {
		ret = [NSString conformsToProtocol:protocol];
	}
	return ret;

}
NSStringEncoding
NSString_StringEncodingForDataEncodingOptions(void* data, void* opts, void** string, void* usedLossyConversion) {
	NSStringEncoding ret;
	@autoreleasepool {
		ret = [NSString stringEncodingForData:data encodingOptions:opts convertedString:(NSString* _Nullable* _Nullable)string usedLossyConversion:usedLossyConversion];
		for(int i=0;i<1;i++) {
			if(string[i] == 0) { break; }
			[(id)string[i] retain];
		}
	
	}
	return ret;

}
NSStringEncoding
NSString_StringEncodingForDataEncodingOptionsConvertedString(void* data, void* opts, void** string, void* usedLossyConversion) {
	NSStringEncoding ret;
	@autoreleasepool {
		ret = [NSString stringEncodingForData:data encodingOptions:opts convertedString:(NSString* _Nullable* _Nullable)string usedLossyConversion:usedLossyConversion];
		for(int i=0;i<1;i++) {
			if(string[i] == 0) { break; }
			[(id)string[i] retain];
		}
	
	}
	return ret;

}
void*
NSString_CopyWithZone(void* zone) {
	NSObject* ret;
	@autoreleasepool {
		ret = [NSString copyWithZone:zone];
	}
	return ret;

}
NSInteger
NSString_Version() {
	NSInteger ret;
	@autoreleasepool {
		ret = [NSString version];
	}
	return ret;

}
void*
NSString_MutableCopyWithZone(void* zone) {
	NSObject* ret;
	@autoreleasepool {
		ret = [NSString mutableCopyWithZone:zone];
	}
	return ret;

}
void* _Nonnull
NSString_PathWithComponents(void* components) {
	NSString* _Nonnull ret;
	@autoreleasepool {
		ret = [NSString pathWithComponents:components];
	}
	return ret;

}
BOOL
NSString_ResolveClassMethod(void* sel) {
	BOOL ret;
	@autoreleasepool {
		ret = [NSString resolveClassMethod:sel];
	}
	return ret;

}
void* _Nonnull
NSString_ClassForKeyedUnarchiver() {
	Class _Nonnull ret;
	@autoreleasepool {
		ret = [NSString classForKeyedUnarchiver];
	}
	return ret;

}
BOOL
NSString_inst_WriteToFileAtomically(void* o, void* path, BOOL useAuxiliaryFile, NSStringEncoding enc, void** error) {
	BOOL ret;
	@autoreleasepool {
		ret = [(NSString*)o writeToFile:path atomically:useAuxiliaryFile encoding:enc error:(NSError* _Nullable* _Nullable)error];
		for(int i=0;i<1;i++) {
			if(error[i] == 0) { break; }
			[(id)error[i] retain];
		}
	
	}
	return ret;

}
BOOL
NSString_inst_WriteToFileAtomicallyEncoding(void* o, void* path, BOOL useAuxiliaryFile, NSStringEncoding enc, void** error) {
	BOOL ret;
	@autoreleasepool {
		ret = [(NSString*)o writeToFile:path atomically:useAuxiliaryFile encoding:enc error:(NSError* _Nullable* _Nullable)error];
		for(int i=0;i<1;i++) {
			if(error[i] == 0) { break; }
			[(id)error[i] retain];
		}
	
	}
	return ret;

}
NSRange
NSString_inst_LocalizedStandardRangeOfString(void* o, void* str) {
	NSRange ret;
	@autoreleasepool {
		ret = [(NSString*)o localizedStandardRangeOfString:str];
	}
	return ret;

}
NSRange
NSString_inst_ParagraphRangeForRange(void* o, NSRange range) {
	NSRange ret;
	@autoreleasepool {
		ret = [(NSString*)o paragraphRangeForRange:range];
	}
	return ret;

}
BOOL
NSString_inst_IsNotEqualTo(void* o, void* object) {
	BOOL ret;
	@autoreleasepool {
		ret = [(NSString*)o isNotEqualTo:object];
	}
	return ret;

}
NSInteger
NSString_inst_IntegerValue(void* o) {
	NSInteger ret;
	@autoreleasepool {
		ret = [(NSString*)o integerValue];
	}
	return ret;

}
void* _Nonnull
NSString_inst_Description(void* o) {
	NSString* _Nonnull ret;
	@autoreleasepool {
		ret = [(NSString*)o description];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
NSRange
NSString_inst_RangeOfCharacterFromSet(void* o, void* searchSet) {
	NSRange ret;
	@autoreleasepool {
		ret = [(NSString*)o rangeOfCharacterFromSet:searchSet];
	}
	return ret;

}
NSRange
NSString_inst_RangeOfCharacterFromSetOptions(void* o, void* searchSet, NSStringCompareOptions mask) {
	NSRange ret;
	@autoreleasepool {
		ret = [(NSString*)o rangeOfCharacterFromSet:searchSet options:mask];
	}
	return ret;

}
NSRange
NSString_inst_RangeOfCharacterFromSetOptionsRange(void* o, void* searchSet, NSStringCompareOptions mask, NSRange rangeOfReceiverToSearch) {
	NSRange ret;
	@autoreleasepool {
		ret = [(NSString*)o rangeOfCharacterFromSet:searchSet options:mask range:rangeOfReceiverToSearch];
	}
	return ret;

}
void* _Nonnull
NSString_inst_VariantFittingPresentationWidth(void* o, NSInteger width) {
	NSString* _Nonnull ret;
	@autoreleasepool {
		ret = [(NSString*)o variantFittingPresentationWidth:width];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
void* _Nullable
NSString_inst_CopyScriptingValueForKey(void* o, void* value, void* key, void* properties) {
	NSObject* _Nullable ret;
	@autoreleasepool {
		ret = [(NSString*)o copyScriptingValue:value forKey:key withProperties:properties];
	}
	return ret;

}
void* _Nullable
NSString_inst_CopyScriptingValueForKeyWithProperties(void* o, void* value, void* key, void* properties) {
	NSObject* _Nullable ret;
	@autoreleasepool {
		ret = [(NSString*)o copyScriptingValue:value forKey:key withProperties:properties];
	}
	return ret;

}
NSStringEncoding
NSString_inst_SmallestEncoding(void* o) {
	NSStringEncoding ret;
	@autoreleasepool {
		ret = [(NSString*)o smallestEncoding];
	}
	return ret;

}
void* _Nullable
NSString_inst_InitWithContentsOfFileEncoding(void* o, void* path, NSStringEncoding enc, void** error) {
	NSString* _Nullable ret;
	@autoreleasepool {
		ret = [(NSString*)o initWithContentsOfFile:path encoding:enc error:(NSError* _Nullable* _Nullable)error];
		for(int i=0;i<1;i++) {
			if(error[i] == 0) { break; }
			[(id)error[i] retain];
		}
	
	}
	return ret;

}
void* _Nullable
NSString_inst_InitWithContentsOfFileUsedEncoding(void* o, void* path, void* enc, void** error) {
	NSString* _Nullable ret;
	@autoreleasepool {
		ret = [(NSString*)o initWithContentsOfFile:path usedEncoding:enc error:(NSError* _Nullable* _Nullable)error];
		for(int i=0;i<1;i++) {
			if(error[i] == 0) { break; }
			[(id)error[i] retain];
		}
	
	}
	return ret;

}
void* _Nullable
NSString_inst_InitWithContentsOfFileEncodingError(void* o, void* path, NSStringEncoding enc, void** error) {
	NSString* _Nullable ret;
	@autoreleasepool {
		ret = [(NSString*)o initWithContentsOfFile:path encoding:enc error:(NSError* _Nullable* _Nullable)error];
		for(int i=0;i<1;i++) {
			if(error[i] == 0) { break; }
			[(id)error[i] retain];
		}
	
	}
	return ret;

}
void* _Nullable
NSString_inst_InitWithContentsOfFileUsedEncodingError(void* o, void* path, void* enc, void** error) {
	NSString* _Nullable ret;
	@autoreleasepool {
		ret = [(NSString*)o initWithContentsOfFile:path usedEncoding:enc error:(NSError* _Nullable* _Nullable)error];
		for(int i=0;i<1;i++) {
			if(error[i] == 0) { break; }
			[(id)error[i] retain];
		}
	
	}
	return ret;

}
void* _Nonnull
NSString_inst_LocalizedCapitalizedString(void* o) {
	NSString* _Nonnull ret;
	@autoreleasepool {
		ret = [(NSString*)o localizedCapitalizedString];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
void* _Nullable
NSString_inst_ClassForArchiver(void* o) {
	Class _Nullable ret;
	@autoreleasepool {
		ret = [(NSString*)o classForArchiver];
	}
	return ret;

}
void* _Nullable
NSString_inst_CoerceValueForKey(void* o, void* value, void* key) {
	NSObject* _Nullable ret;
	@autoreleasepool {
		ret = [(NSString*)o coerceValue:value forKey:key];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
void
NSString_inst_WillChangeValueForKey(void* o, void* key) {
	@autoreleasepool {
		[(NSString*)o willChangeValueForKey:key];
	}
}
void
NSString_inst_WillChangeValueForKeyWithSetMutation(void* o, void* key, NSKeyValueSetMutationKind mutationKind, void* objects) {
	@autoreleasepool {
		[(NSString*)o willChangeValueForKey:key withSetMutation:mutationKind usingObjects:objects];
	}
}
void
NSString_inst_WillChangeValueForKeyWithSetMutationUsingObjects(void* o, void* key, NSKeyValueSetMutationKind mutationKind, void* objects) {
	@autoreleasepool {
		[(NSString*)o willChangeValueForKey:key withSetMutation:mutationKind usingObjects:objects];
	}
}
BOOL
NSString_inst_GetBytesMaxLength(void* o, void* buffer, NSUInteger maxBufferCount, void* usedBufferCount, NSStringEncoding encoding, NSStringEncodingConversionOptions options, NSRange range, void* leftover) {
	BOOL ret;
	@autoreleasepool {
		ret = [(NSString*)o getBytes:buffer maxLength:maxBufferCount usedLength:usedBufferCount encoding:encoding options:options range:range remainingRange:leftover];
	}
	return ret;

}
BOOL
NSString_inst_GetBytesMaxLengthUsedLength(void* o, void* buffer, NSUInteger maxBufferCount, void* usedBufferCount, NSStringEncoding encoding, NSStringEncodingConversionOptions options, NSRange range, void* leftover) {
	BOOL ret;
	@autoreleasepool {
		ret = [(NSString*)o getBytes:buffer maxLength:maxBufferCount usedLength:usedBufferCount encoding:encoding options:options range:range remainingRange:leftover];
	}
	return ret;

}
NSComparisonResult
NSString_inst_LocalizedStandardCompare(void* o, void* string) {
	NSComparisonResult ret;
	@autoreleasepool {
		ret = [(NSString*)o localizedStandardCompare:string];
	}
	return ret;

}
void* _Nonnull
NSString_inst_StringByStandardizingPath(void* o) {
	NSString* _Nonnull ret;
	@autoreleasepool {
		ret = [(NSString*)o stringByStandardizingPath];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
void* _Nullable
NSString_inst_ScriptingValueForSpecifier(void* o, void* objectSpecifier) {
	NSObject* _Nullable ret;
	@autoreleasepool {
		ret = [(NSString*)o scriptingValueForSpecifier:objectSpecifier];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
void* _Nullable
NSString_inst_InverseForRelationshipKey(void* o, void* relationshipKey) {
	NSString* _Nullable ret;
	@autoreleasepool {
		ret = [(NSString*)o inverseForRelationshipKey:relationshipKey];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
void*
NSString_inst_MutableCopy(void* o) {
	NSObject* ret;
	@autoreleasepool {
		ret = [(NSString*)o mutableCopy];
	}
	return ret;

}
void
NSString_inst_SetObservationInfo(void* o, void* observationInfo) {
	@autoreleasepool {
		[(NSString*)o setObservationInfo:observationInfo];
	}
}
void* _Nonnull
NSString_inst_StringByExpandingTildeInPath(void* o) {
	NSString* _Nonnull ret;
	@autoreleasepool {
		ret = [(NSString*)o stringByExpandingTildeInPath];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
BOOL
NSString_inst_IsEqualToString(void* o, void* aString) {
	BOOL ret;
	@autoreleasepool {
		ret = [(NSString*)o isEqualToString:aString];
	}
	return ret;

}
BOOL
NSString_inst_ScriptingContains(void* o, void* object) {
	BOOL ret;
	@autoreleasepool {
		ret = [(NSString*)o scriptingContains:object];
	}
	return ret;

}
void* _Nonnull
NSString_inst_StringByDeletingPathExtension(void* o) {
	NSString* _Nonnull ret;
	@autoreleasepool {
		ret = [(NSString*)o stringByDeletingPathExtension];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
void* _Nonnull
NSString_inst_StringsByAppendingPaths(void* o, void* paths) {
	NSArray* _Nonnull ret;
	@autoreleasepool {
		ret = [(NSString*)o stringsByAppendingPaths:paths];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
void* _Nonnull
NSString_inst_InitWithCharactersLength(void* o, void* characters, NSUInteger length) {
	NSString* _Nonnull ret;
	@autoreleasepool {
		ret = [(NSString*)o initWithCharacters:characters length:length];
	}
	return ret;

}
void* _Nullable
NSString_inst_InitWithCStringEncoding(void* o, void* nullTerminatedCString, NSStringEncoding encoding) {
	NSString* _Nullable ret;
	@autoreleasepool {
		ret = [(NSString*)o initWithCString:nullTerminatedCString encoding:encoding];
	}
	return ret;

}
void*
NSString_inst_ForwardingTargetForSelector(void* o, void* aSelector) {
	NSObject* ret;
	@autoreleasepool {
		ret = [(NSString*)o forwardingTargetForSelector:aSelector];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
BOOL
NSString_inst_AttemptRecoveryFromErrorOptionIndex(void* o, void* error, NSUInteger recoveryOptionIndex) {
	BOOL ret;
	@autoreleasepool {
		ret = [(NSString*)o attemptRecoveryFromError:error optionIndex:recoveryOptionIndex];
	}
	return ret;

}
void
NSString_inst_AttemptRecoveryFromErrorOptionIndexDelegate(void* o, void* error, NSUInteger recoveryOptionIndex, void* delegate, void* didRecoverSelector, void* contextInfo) {
	@autoreleasepool {
		[(NSString*)o attemptRecoveryFromError:error optionIndex:recoveryOptionIndex delegate:delegate didRecoverSelector:didRecoverSelector contextInfo:contextInfo];
	}
}
void
NSString_inst_AttemptRecoveryFromErrorOptionIndexDelegateDidRecoverSelector(void* o, void* error, NSUInteger recoveryOptionIndex, void* delegate, void* didRecoverSelector, void* contextInfo) {
	@autoreleasepool {
		[(NSString*)o attemptRecoveryFromError:error optionIndex:recoveryOptionIndex delegate:delegate didRecoverSelector:didRecoverSelector contextInfo:contextInfo];
	}
}
void* _Nonnull
NSString_inst_LocalizedUppercaseString(void* o) {
	NSString* _Nonnull ret;
	@autoreleasepool {
		ret = [(NSString*)o localizedUppercaseString];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
unichar
NSString_inst_CharacterAtIndex(void* o, NSUInteger index) {
	unichar ret;
	@autoreleasepool {
		ret = [(NSString*)o characterAtIndex:index];
	}
	return ret;

}
void* _Nonnull
NSString_inst_InitWithString(void* o, void* aString) {
	NSString* _Nonnull ret;
	@autoreleasepool {
		ret = [(NSString*)o initWithString:aString];
	}
	return ret;

}
void* _Nullable
NSString_inst_ValueWithUniqueIDInPropertyWithKey(void* o, void* uniqueID, void* key) {
	NSObject* _Nullable ret;
	@autoreleasepool {
		ret = [(NSString*)o valueWithUniqueID:uniqueID inPropertyWithKey:key];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
BOOL
NSString_inst_ScriptingIsEqualTo(void* o, void* object) {
	BOOL ret;
	@autoreleasepool {
		ret = [(NSString*)o scriptingIsEqualTo:object];
	}
	return ret;

}
void
NSString_inst_RemoveObserverForKeyPath(void* o, void* observer, void* keyPath) {
	@autoreleasepool {
		[(NSString*)o removeObserver:observer forKeyPath:keyPath];
	}
}
void
NSString_inst_RemoveObserverForKeyPathContext(void* o, void* observer, void* keyPath, void* context) {
	@autoreleasepool {
		[(NSString*)o removeObserver:observer forKeyPath:keyPath context:context];
	}
}
BOOL
NSString_inst_CanBeConvertedToEncoding(void* o, NSStringEncoding encoding) {
	BOOL ret;
	@autoreleasepool {
		ret = [(NSString*)o canBeConvertedToEncoding:encoding];
	}
	return ret;

}
void* _Nonnull
NSString_inst_PathComponents(void* o) {
	NSArray* _Nonnull ret;
	@autoreleasepool {
		ret = [(NSString*)o pathComponents];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
void* _Nonnull
NSString_inst_LowercaseStringWithLocale(void* o, void* locale) {
	NSString* _Nonnull ret;
	@autoreleasepool {
		ret = [(NSString*)o lowercaseStringWithLocale:locale];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
void* _Nullable
NSString_inst_InitWithBytesLength(void* o, void* bytes, NSUInteger len, NSStringEncoding encoding) {
	NSString* _Nullable ret;
	@autoreleasepool {
		ret = [(NSString*)o initWithBytes:bytes length:len encoding:encoding];
	}
	return ret;

}
void* _Nullable
NSString_inst_InitWithBytesLengthEncoding(void* o, void* bytes, NSUInteger len, NSStringEncoding encoding) {
	NSString* _Nullable ret;
	@autoreleasepool {
		ret = [(NSString*)o initWithBytes:bytes length:len encoding:encoding];
	}
	return ret;

}
void* _Nonnull
NSString_inst_LastPathComponent(void* o) {
	NSString* _Nonnull ret;
	@autoreleasepool {
		ret = [(NSString*)o lastPathComponent];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
void
NSString_inst_SetScriptingProperties(void* o, void* scriptingProperties) {
	@autoreleasepool {
		[(NSString*)o setScriptingProperties:scriptingProperties];
	}
}
BOOL
NSString_inst_IsLessThanOrEqualTo(void* o, void* object) {
	BOOL ret;
	@autoreleasepool {
		ret = [(NSString*)o isLessThanOrEqualTo:object];
	}
	return ret;

}
void* _Nullable
NSString_inst_ReplacementObjectForKeyedArchiver(void* o, void* archiver) {
	NSObject* _Nullable ret;
	@autoreleasepool {
		ret = [(NSString*)o replacementObjectForKeyedArchiver:archiver];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
void* _Nullable
NSString_inst_ObjectSpecifier(void* o) {
	NSScriptObjectSpecifier* _Nullable ret;
	@autoreleasepool {
		ret = [(NSString*)o objectSpecifier];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
void
NSString_inst_InsertValueInPropertyWithKey(void* o, void* value, void* key) {
	@autoreleasepool {
		[(NSString*)o insertValue:value inPropertyWithKey:key];
	}
}
void
NSString_inst_InsertValueAtIndex(void* o, void* value, NSUInteger index, void* key) {
	@autoreleasepool {
		[(NSString*)o insertValue:value atIndex:index inPropertyWithKey:key];
	}
}
void
NSString_inst_InsertValueAtIndexInPropertyWithKey(void* o, void* value, NSUInteger index, void* key) {
	@autoreleasepool {
		[(NSString*)o insertValue:value atIndex:index inPropertyWithKey:key];
	}
}
const void* _Nullable
NSString_inst_CStringUsingEncoding(void* o, NSStringEncoding encoding) {
	const char* _Nullable ret;
	@autoreleasepool {
		ret = strdup([(NSString*)o cStringUsingEncoding:encoding]);
	}
	return ret;

}
void* _Nonnull
NSString_inst_LowercaseString(void* o) {
	NSString* _Nonnull ret;
	@autoreleasepool {
		ret = [(NSString*)o lowercaseString];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
BOOL
NSString_inst_LocalizedStandardContainsString(void* o, void* str) {
	BOOL ret;
	@autoreleasepool {
		ret = [(NSString*)o localizedStandardContainsString:str];
	}
	return ret;

}
void* _Nonnull
NSString_inst_StringByTrimmingCharactersInSet(void* o, void* set) {
	NSString* _Nonnull ret;
	@autoreleasepool {
		ret = [(NSString*)o stringByTrimmingCharactersInSet:set];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
void* _Nonnull
NSString_inst_MutableOrderedSetValueForKey(void* o, void* key) {
	NSMutableOrderedSet* _Nonnull ret;
	@autoreleasepool {
		ret = [(NSString*)o mutableOrderedSetValueForKey:key];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
void* _Nullable
NSString_inst_ValueForKey(void* o, void* key) {
	NSObject* _Nullable ret;
	@autoreleasepool {
		ret = [(NSString*)o valueForKey:key];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
void* _Nullable
NSString_inst_ClassForKeyedArchiver(void* o) {
	Class _Nullable ret;
	@autoreleasepool {
		ret = [(NSString*)o classForKeyedArchiver];
	}
	return ret;

}
void
NSString_inst_ReplaceValueAtIndexInPropertyWithKey(void* o, NSUInteger index, void* key, void* value) {
	@autoreleasepool {
		[(NSString*)o replaceValueAtIndex:index inPropertyWithKey:key withValue:value];
	}
}
void
NSString_inst_ReplaceValueAtIndexInPropertyWithKeyWithValue(void* o, NSUInteger index, void* key, void* value) {
	@autoreleasepool {
		[(NSString*)o replaceValueAtIndex:index inPropertyWithKey:key withValue:value];
	}
}
void*
NSString_inst_ObservationInfo(void* o) {
	void* ret;
	@autoreleasepool {
		ret = [(NSString*)o observationInfo];
	}
	return ret;

}
BOOL
NSString_inst_ValidateValueForKey(void* o, void** ioValue, void* inKey, void** outError) {
	BOOL ret;
	@autoreleasepool {
		ret = [(NSString*)o validateValue:(id _Nullable* _Nonnull)ioValue forKey:inKey error:(NSError* _Nullable* _Nullable)outError];
		for(int i=0;i<1;i++) {
			if(ioValue[i] == 0) { break; }
			[(id)ioValue[i] retain];
		}
	
	
		for(int i=0;i<1;i++) {
			if(outError[i] == 0) { break; }
			[(id)outError[i] retain];
		}
	
	}
	return ret;

}
BOOL
NSString_inst_ValidateValueForKeyPath(void* o, void** ioValue, void* inKeyPath, void** outError) {
	BOOL ret;
	@autoreleasepool {
		ret = [(NSString*)o validateValue:(id _Nullable* _Nonnull)ioValue forKeyPath:inKeyPath error:(NSError* _Nullable* _Nullable)outError];
		for(int i=0;i<1;i++) {
			if(ioValue[i] == 0) { break; }
			[(id)ioValue[i] retain];
		}
	
	
		for(int i=0;i<1;i++) {
			if(outError[i] == 0) { break; }
			[(id)outError[i] retain];
		}
	
	}
	return ret;

}
BOOL
NSString_inst_ValidateValueForKeyError(void* o, void** ioValue, void* inKey, void** outError) {
	BOOL ret;
	@autoreleasepool {
		ret = [(NSString*)o validateValue:(id _Nullable* _Nonnull)ioValue forKey:inKey error:(NSError* _Nullable* _Nullable)outError];
		for(int i=0;i<1;i++) {
			if(ioValue[i] == 0) { break; }
			[(id)ioValue[i] retain];
		}
	
	
		for(int i=0;i<1;i++) {
			if(outError[i] == 0) { break; }
			[(id)outError[i] retain];
		}
	
	}
	return ret;

}
BOOL
NSString_inst_ValidateValueForKeyPathError(void* o, void** ioValue, void* inKeyPath, void** outError) {
	BOOL ret;
	@autoreleasepool {
		ret = [(NSString*)o validateValue:(id _Nullable* _Nonnull)ioValue forKeyPath:inKeyPath error:(NSError* _Nullable* _Nullable)outError];
		for(int i=0;i<1;i++) {
			if(ioValue[i] == 0) { break; }
			[(id)ioValue[i] retain];
		}
	
	
		for(int i=0;i<1;i++) {
			if(outError[i] == 0) { break; }
			[(id)outError[i] retain];
		}
	
	}
	return ret;

}
BOOL
NSString_inst_IsLike(void* o, void* object) {
	BOOL ret;
	@autoreleasepool {
		ret = [(NSString*)o isLike:object];
	}
	return ret;

}
void* _Nonnull
NSString_inst_MutableCopyWithZone(void* o, void* zone) {
	NSObject* _Nonnull ret;
	@autoreleasepool {
		ret = [(NSString*)o mutableCopyWithZone:zone];
	}
	return ret;

}
void* _Nullable
NSString_inst_StringByAddingPercentEncodingWithAllowedCharacters(void* o, void* allowedCharacters) {
	NSString* _Nullable ret;
	@autoreleasepool {
		ret = [(NSString*)o stringByAddingPercentEncodingWithAllowedCharacters:allowedCharacters];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
void*
NSString_inst_MethodSignatureForSelector(void* o, void* aSelector) {
	NSMethodSignature* ret;
	@autoreleasepool {
		ret = [(NSString*)o methodSignatureForSelector:aSelector];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
BOOL
NSString_inst_IsLessThan(void* o, void* object) {
	BOOL ret;
	@autoreleasepool {
		ret = [(NSString*)o isLessThan:object];
	}
	return ret;

}
BOOL
NSString_inst_HasSuffix(void* o, void* str) {
	BOOL ret;
	@autoreleasepool {
		ret = [(NSString*)o hasSuffix:str];
	}
	return ret;

}
const void*
NSString_inst_UTF8String(void* o) {
	const char* ret;
	@autoreleasepool {
		ret = strdup([(NSString*)o UTF8String]);
	}
	return ret;

}
void* _Nonnull
NSString_inst_StringByPaddingToLengthWithString(void* o, NSUInteger newLength, void* padString, NSUInteger padIndex) {
	NSString* _Nonnull ret;
	@autoreleasepool {
		ret = [(NSString*)o stringByPaddingToLength:newLength withString:padString startingAtIndex:padIndex];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
void* _Nonnull
NSString_inst_StringByPaddingToLengthWithStringStartingAtIndex(void* o, NSUInteger newLength, void* padString, NSUInteger padIndex) {
	NSString* _Nonnull ret;
	@autoreleasepool {
		ret = [(NSString*)o stringByPaddingToLength:newLength withString:padString startingAtIndex:padIndex];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
void* _Nonnull
NSString_inst_AutoContentAccessingProxy(void* o) {
	NSObject* _Nonnull ret;
	@autoreleasepool {
		ret = [(NSString*)o autoContentAccessingProxy];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
BOOL
NSString_inst_IsEqualTo(void* o, void* object) {
	BOOL ret;
	@autoreleasepool {
		ret = [(NSString*)o isEqualTo:object];
	}
	return ret;

}
BOOL
NSString_inst_IsGreaterThan(void* o, void* object) {
	BOOL ret;
	@autoreleasepool {
		ret = [(NSString*)o isGreaterThan:object];
	}
	return ret;

}
void
NSString_inst_GetCharacters(void* o, void* buffer) {
	@autoreleasepool {
		[(NSString*)o getCharacters:buffer];
	}
}
void
NSString_inst_GetCharactersRange(void* o, void* buffer, NSRange range) {
	@autoreleasepool {
		[(NSString*)o getCharacters:buffer range:range];
	}
}
void* _Nonnull
NSString_inst_UppercaseStringWithLocale(void* o, void* locale) {
	NSString* _Nonnull ret;
	@autoreleasepool {
		ret = [(NSString*)o uppercaseStringWithLocale:locale];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
void* _Nonnull
NSString_inst_CapitalizedStringWithLocale(void* o, void* locale) {
	NSString* _Nonnull ret;
	@autoreleasepool {
		ret = [(NSString*)o capitalizedStringWithLocale:locale];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
NSUInteger
NSString_inst_Hash(void* o) {
	NSUInteger ret;
	@autoreleasepool {
		ret = [(NSString*)o hash];
	}
	return ret;

}
NSUInteger
NSString_inst_LengthOfBytesUsingEncoding(void* o, NSStringEncoding enc) {
	NSUInteger ret;
	@autoreleasepool {
		ret = [(NSString*)o lengthOfBytesUsingEncoding:enc];
	}
	return ret;

}
void* _Nonnull
NSString_inst_ClassDescription(void* o) {
	NSClassDescription* _Nonnull ret;
	@autoreleasepool {
		ret = [(NSString*)o classDescription];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
void* _Nullable
NSString_inst_AwakeAfterUsingCoder(void* o, void* coder) {
	NSObject* _Nullable ret;
	@autoreleasepool {
		ret = [(NSString*)o awakeAfterUsingCoder:coder];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
void* _Nonnull
NSString_inst_CopyWithZone(void* o, void* zone) {
	NSObject* _Nonnull ret;
	@autoreleasepool {
		ret = [(NSString*)o copyWithZone:zone];
	}
	return ret;

}
long long
NSString_inst_LongLongValue(void* o) {
	long long ret;
	@autoreleasepool {
		ret = [(NSString*)o longLongValue];
	}
	return ret;

}
void* _Nonnull
NSString_inst_PathExtension(void* o) {
	NSString* _Nonnull ret;
	@autoreleasepool {
		ret = [(NSString*)o pathExtension];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
void* _Nonnull
NSString_inst_InitWithCharactersNoCopyLength(void* o, void* characters, NSUInteger length, BOOL freeBuffer) {
	NSString* _Nonnull ret;
	@autoreleasepool {
		ret = [(NSString*)o initWithCharactersNoCopy:characters length:length freeWhenDone:freeBuffer];
	}
	return ret;

}
void* _Nonnull
NSString_inst_InitWithCharactersNoCopyLengthFreeWhenDone(void* o, void* characters, NSUInteger length, BOOL freeBuffer) {
	NSString* _Nonnull ret;
	@autoreleasepool {
		ret = [(NSString*)o initWithCharactersNoCopy:characters length:length freeWhenDone:freeBuffer];
	}
	return ret;

}
void
NSString_inst_PerformSelectorWithObject(void* o, void* aSelector, void* anArgument, NSTimeInterval delay) {
	@autoreleasepool {
		[(NSString*)o performSelector:aSelector withObject:anArgument afterDelay:delay];
	}
}
void
NSString_inst_PerformSelectorWithObjectAfterDelay(void* o, void* aSelector, void* anArgument, NSTimeInterval delay) {
	@autoreleasepool {
		[(NSString*)o performSelector:aSelector withObject:anArgument afterDelay:delay];
	}
}
void
NSString_inst_PerformSelectorWithObjectAfterDelayInModes(void* o, void* aSelector, void* anArgument, NSTimeInterval delay, void* modes) {
	@autoreleasepool {
		[(NSString*)o performSelector:aSelector withObject:anArgument afterDelay:delay inModes:modes];
	}
}
void
NSString_inst_PerformSelectorOnThread(void* o, void* aSelector, void* thr, void* arg, BOOL wait) {
	@autoreleasepool {
		[(NSString*)o performSelector:aSelector onThread:thr withObject:arg waitUntilDone:wait];
	}
}
void
NSString_inst_PerformSelectorOnThreadWithObject(void* o, void* aSelector, void* thr, void* arg, BOOL wait) {
	@autoreleasepool {
		[(NSString*)o performSelector:aSelector onThread:thr withObject:arg waitUntilDone:wait];
	}
}
void
NSString_inst_PerformSelectorOnThreadWithObjectWaitUntilDone(void* o, void* aSelector, void* thr, void* arg, BOOL wait, void* array) {
	@autoreleasepool {
		[(NSString*)o performSelector:aSelector onThread:thr withObject:arg waitUntilDone:wait modes:array];
	}
}
void
NSString_inst_PerformSelectorOnThreadWithObjectWaitUntilDoneModes(void* o, void* aSelector, void* thr, void* arg, BOOL wait, void* array) {
	@autoreleasepool {
		[(NSString*)o performSelector:aSelector onThread:thr withObject:arg waitUntilDone:wait modes:array];
	}
}
void* _Nullable
NSString_inst_StringByAppendingPathExtension(void* o, void* str) {
	NSString* _Nullable ret;
	@autoreleasepool {
		ret = [(NSString*)o stringByAppendingPathExtension:str];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
BOOL
NSString_inst_LocalizedCaseInsensitiveContainsString(void* o, void* str) {
	BOOL ret;
	@autoreleasepool {
		ret = [(NSString*)o localizedCaseInsensitiveContainsString:str];
	}
	return ret;

}
void* _Nonnull
NSString_inst_StringByAbbreviatingWithTildeInPath(void* o) {
	NSString* _Nonnull ret;
	@autoreleasepool {
		ret = [(NSString*)o stringByAbbreviatingWithTildeInPath];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
void* _Nonnull
NSString_inst_DictionaryWithValuesForKeys(void* o, void* keys) {
	NSDictionary* _Nonnull ret;
	@autoreleasepool {
		ret = [(NSString*)o dictionaryWithValuesForKeys:keys];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
void* _Nonnull
NSString_inst_CapitalizedString(void* o) {
	NSString* _Nonnull ret;
	@autoreleasepool {
		ret = [(NSString*)o capitalizedString];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
int
NSString_inst_IntValue(void* o) {
	int ret;
	@autoreleasepool {
		ret = [(NSString*)o intValue];
	}
	return ret;

}
BOOL
NSString_inst_GetCStringMaxLength(void* o, void* buffer, NSUInteger maxBufferCount, NSStringEncoding encoding) {
	BOOL ret;
	@autoreleasepool {
		ret = [(NSString*)o getCString:buffer maxLength:maxBufferCount encoding:encoding];
	}
	return ret;

}
BOOL
NSString_inst_GetCStringMaxLengthEncoding(void* o, void* buffer, NSUInteger maxBufferCount, NSStringEncoding encoding) {
	BOOL ret;
	@autoreleasepool {
		ret = [(NSString*)o getCString:buffer maxLength:maxBufferCount encoding:encoding];
	}
	return ret;

}
NSUInteger
NSString_inst_MaximumLengthOfBytesUsingEncoding(void* o, NSStringEncoding enc) {
	NSUInteger ret;
	@autoreleasepool {
		ret = [(NSString*)o maximumLengthOfBytesUsingEncoding:enc];
	}
	return ret;

}
BOOL
NSString_inst_HasPrefix(void* o, void* str) {
	BOOL ret;
	@autoreleasepool {
		ret = [(NSString*)o hasPrefix:str];
	}
	return ret;

}
BOOL
NSString_inst_IsCaseInsensitiveLike(void* o, void* object) {
	BOOL ret;
	@autoreleasepool {
		ret = [(NSString*)o isCaseInsensitiveLike:object];
	}
	return ret;

}
BOOL
NSString_inst_ScriptingBeginsWith(void* o, void* object) {
	BOOL ret;
	@autoreleasepool {
		ret = [(NSString*)o scriptingBeginsWith:object];
	}
	return ret;

}
void* _Nonnull
NSString_inst_PropertyList(void* o) {
	NSObject* _Nonnull ret;
	@autoreleasepool {
		ret = [(NSString*)o propertyList];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
NSComparisonResult
NSString_inst_Compare(void* o, void* string) {
	NSComparisonResult ret;
	@autoreleasepool {
		ret = [(NSString*)o compare:string];
	}
	return ret;

}
NSComparisonResult
NSString_inst_CompareOptions(void* o, void* string, NSStringCompareOptions mask) {
	NSComparisonResult ret;
	@autoreleasepool {
		ret = [(NSString*)o compare:string options:mask];
	}
	return ret;

}
NSComparisonResult
NSString_inst_CompareOptionsRange(void* o, void* string, NSStringCompareOptions mask, NSRange rangeOfReceiverToCompare) {
	NSComparisonResult ret;
	@autoreleasepool {
		ret = [(NSString*)o compare:string options:mask range:rangeOfReceiverToCompare];
	}
	return ret;

}
NSComparisonResult
NSString_inst_CompareOptionsRangeLocale(void* o, void* string, NSStringCompareOptions mask, NSRange rangeOfReceiverToCompare, void* locale) {
	NSComparisonResult ret;
	@autoreleasepool {
		ret = [(NSString*)o compare:string options:mask range:rangeOfReceiverToCompare locale:locale];
	}
	return ret;

}
BOOL
NSString_inst_IsGreaterThanOrEqualTo(void* o, void* object) {
	BOOL ret;
	@autoreleasepool {
		ret = [(NSString*)o isGreaterThanOrEqualTo:object];
	}
	return ret;

}
void* _Nullable
NSString_inst_NewScriptingObjectOfClassForValueForKey(void* o, void* objectClass, void* key, void* contentsValue, void* properties) {
	NSObject* _Nullable ret;
	@autoreleasepool {
		ret = [(NSString*)o newScriptingObjectOfClass:objectClass forValueForKey:key withContentsValue:contentsValue properties:properties];
	}
	return ret;

}
void* _Nullable
NSString_inst_NewScriptingObjectOfClassForValueForKeyWithContentsValue(void* o, void* objectClass, void* key, void* contentsValue, void* properties) {
	NSObject* _Nullable ret;
	@autoreleasepool {
		ret = [(NSString*)o newScriptingObjectOfClass:objectClass forValueForKey:key withContentsValue:contentsValue properties:properties];
	}
	return ret;

}
BOOL
NSString_inst_ScriptingIsLessThanOrEqualTo(void* o, void* object) {
	BOOL ret;
	@autoreleasepool {
		ret = [(NSString*)o scriptingIsLessThanOrEqualTo:object];
	}
	return ret;

}
BOOL
NSString_inst_ScriptingIsGreaterThan(void* o, void* object) {
	BOOL ret;
	@autoreleasepool {
		ret = [(NSString*)o scriptingIsGreaterThan:object];
	}
	return ret;

}
void
NSString_inst_GetLineStartEnd(void* o, void* startPtr, void* lineEndPtr, void* contentsEndPtr, NSRange range) {
	@autoreleasepool {
		[(NSString*)o getLineStart:startPtr end:lineEndPtr contentsEnd:contentsEndPtr forRange:range];
	}
}
void
NSString_inst_GetLineStartEndContentsEnd(void* o, void* startPtr, void* lineEndPtr, void* contentsEndPtr, NSRange range) {
	@autoreleasepool {
		[(NSString*)o getLineStart:startPtr end:lineEndPtr contentsEnd:contentsEndPtr forRange:range];
	}
}
void* _Nonnull
NSString_inst_MutableArrayValueForKey(void* o, void* key) {
	NSMutableArray* _Nonnull ret;
	@autoreleasepool {
		ret = [(NSString*)o mutableArrayValueForKey:key];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
void* _Nonnull
NSString_inst_MutableSetValueForKeyPath(void* o, void* keyPath) {
	NSMutableSet* _Nonnull ret;
	@autoreleasepool {
		ret = [(NSString*)o mutableSetValueForKeyPath:keyPath];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
void
NSString_inst_AddObserverForKeyPath(void* o, void* observer, void* keyPath, NSKeyValueObservingOptions options, void* context) {
	@autoreleasepool {
		[(NSString*)o addObserver:observer forKeyPath:keyPath options:options context:context];
	}
}
void
NSString_inst_AddObserverForKeyPathOptions(void* o, void* observer, void* keyPath, NSKeyValueObservingOptions options, void* context) {
	@autoreleasepool {
		[(NSString*)o addObserver:observer forKeyPath:keyPath options:options context:context];
	}
}
void* _Nonnull
NSString_inst_Init(void* o) {
	NSString* _Nonnull ret;
	@autoreleasepool {
		ret = [(NSString*)o init];
	}
	return ret;

}
void* _Nonnull
NSString_inst_DecomposedStringWithCompatibilityMapping(void* o) {
	NSString* _Nonnull ret;
	@autoreleasepool {
		ret = [(NSString*)o decomposedStringWithCompatibilityMapping];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
void* _Nullable
NSString_inst_StringByApplyingTransformReverse(void* o, void* transform, BOOL reverse) {
	NSString* _Nullable ret;
	@autoreleasepool {
		ret = [(NSString*)o stringByApplyingTransform:transform reverse:reverse];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
void* _Nonnull
NSString_inst_StringByReplacingCharactersInRangeWithString(void* o, NSRange range, void* replacement) {
	NSString* _Nonnull ret;
	@autoreleasepool {
		ret = [(NSString*)o stringByReplacingCharactersInRange:range withString:replacement];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
void* _Nullable
NSString_inst_StringByRemovingPercentEncoding(void* o) {
	NSString* _Nullable ret;
	@autoreleasepool {
		ret = [(NSString*)o stringByRemovingPercentEncoding];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
void*
NSString_inst_Copy(void* o) {
	NSObject* ret;
	@autoreleasepool {
		ret = [(NSString*)o copy];
	}
	return ret;

}
void* _Nonnull
NSString_inst_MutableOrderedSetValueForKeyPath(void* o, void* keyPath) {
	NSMutableOrderedSet* _Nonnull ret;
	@autoreleasepool {
		ret = [(NSString*)o mutableOrderedSetValueForKeyPath:keyPath];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
void* _Nonnull
NSString_inst_ClassName(void* o) {
	NSString* _Nonnull ret;
	@autoreleasepool {
		ret = [(NSString*)o className];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
void
NSString_inst_PerformSelectorOnMainThreadWithObject(void* o, void* aSelector, void* arg, BOOL wait) {
	@autoreleasepool {
		[(NSString*)o performSelectorOnMainThread:aSelector withObject:arg waitUntilDone:wait];
	}
}
void
NSString_inst_PerformSelectorOnMainThreadWithObjectWaitUntilDone(void* o, void* aSelector, void* arg, BOOL wait) {
	@autoreleasepool {
		[(NSString*)o performSelectorOnMainThread:aSelector withObject:arg waitUntilDone:wait];
	}
}
void
NSString_inst_PerformSelectorOnMainThreadWithObjectWaitUntilDoneModes(void* o, void* aSelector, void* arg, BOOL wait, void* array) {
	@autoreleasepool {
		[(NSString*)o performSelectorOnMainThread:aSelector withObject:arg waitUntilDone:wait modes:array];
	}
}
void* _Nonnull
NSString_inst_WritableTypeIdentifiersForItemProvider(void* o) {
	NSArray* _Nonnull ret;
	@autoreleasepool {
		ret = [(NSString*)o writableTypeIdentifiersForItemProvider];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
void* _Nonnull
NSString_inst_InitWithFormat(void* o, void* format) {
	NSString* _Nonnull ret;
	@autoreleasepool {
		ret = [(NSString*)o initWithFormat:format];
	}
	return ret;

}
void* _Nonnull
NSString_inst_InitWithFormatArguments(void* o, void* format, va_list argList) {
	NSString* _Nonnull ret;
	@autoreleasepool {
		ret = [(NSString*)o initWithFormat:format arguments:argList];
	}
	return ret;

}
void* _Nonnull
NSString_inst_InitWithFormatLocale(void* o, void* format, void* locale) {
	NSString* _Nonnull ret;
	@autoreleasepool {
		ret = [(NSString*)o initWithFormat:format locale:locale];
	}
	return ret;

}
void* _Nonnull
NSString_inst_InitWithFormatLocaleArguments(void* o, void* format, void* locale, va_list argList) {
	NSString* _Nonnull ret;
	@autoreleasepool {
		ret = [(NSString*)o initWithFormat:format locale:locale arguments:argList];
	}
	return ret;

}
void* _Nonnull
NSString_inst_StringByAppendingFormat(void* o, void* format) {
	NSString* _Nonnull ret;
	@autoreleasepool {
		ret = [(NSString*)o stringByAppendingFormat:format];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
void* _Nonnull
NSString_inst_StringByResolvingSymlinksInPath(void* o) {
	NSString* _Nonnull ret;
	@autoreleasepool {
		ret = [(NSString*)o stringByResolvingSymlinksInPath];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
BOOL
NSString_inst_ScriptingIsGreaterThanOrEqualTo(void* o, void* object) {
	BOOL ret;
	@autoreleasepool {
		ret = [(NSString*)o scriptingIsGreaterThanOrEqualTo:object];
	}
	return ret;

}
void
NSString_inst_SetValueForKey(void* o, void* value, void* key) {
	@autoreleasepool {
		[(NSString*)o setValue:value forKey:key];
	}
}
void
NSString_inst_SetValueForKeyPath(void* o, void* value, void* keyPath) {
	@autoreleasepool {
		[(NSString*)o setValue:value forKeyPath:keyPath];
	}
}
void
NSString_inst_SetValueForUndefinedKey(void* o, void* value, void* key) {
	@autoreleasepool {
		[(NSString*)o setValue:value forUndefinedKey:key];
	}
}
void* _Nullable
NSString_inst_ValueWithNameInPropertyWithKey(void* o, void* name, void* key) {
	NSObject* _Nullable ret;
	@autoreleasepool {
		ret = [(NSString*)o valueWithName:name inPropertyWithKey:key];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
void* _Nonnull
NSString_inst_ToOneRelationshipKeys(void* o) {
	NSArray* _Nonnull ret;
	@autoreleasepool {
		ret = [(NSString*)o toOneRelationshipKeys];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
void* _Nullable
NSString_inst_ValueForUndefinedKey(void* o, void* key) {
	NSObject* _Nullable ret;
	@autoreleasepool {
		ret = [(NSString*)o valueForUndefinedKey:key];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
void* _Nullable
NSString_inst_ReplacementObjectForCoder(void* o, void* coder) {
	NSObject* _Nullable ret;
	@autoreleasepool {
		ret = [(NSString*)o replacementObjectForCoder:coder];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
void
NSString_inst_SetNilValueForKey(void* o, void* key) {
	@autoreleasepool {
		[(NSString*)o setNilValueForKey:key];
	}
}
NSItemProviderRepresentationVisibility
NSString_inst_ItemProviderVisibilityForRepresentationWithTypeIdentifier(void* o, void* typeIdentifier) {
	NSItemProviderRepresentationVisibility ret;
	@autoreleasepool {
		ret = [(NSString*)o itemProviderVisibilityForRepresentationWithTypeIdentifier:typeIdentifier];
	}
	return ret;

}
void* _Nullable
NSString_inst_PropertyListFromStringsFileFormat(void* o) {
	NSDictionary* _Nullable ret;
	@autoreleasepool {
		ret = [(NSString*)o propertyListFromStringsFileFormat];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
void* _Nonnull
NSString_inst_PrecomposedStringWithCompatibilityMapping(void* o) {
	NSString* _Nonnull ret;
	@autoreleasepool {
		ret = [(NSString*)o precomposedStringWithCompatibilityMapping];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
void* _Nonnull
NSString_inst_SubstringWithRange(void* o, NSRange range) {
	NSString* _Nonnull ret;
	@autoreleasepool {
		ret = [(NSString*)o substringWithRange:range];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
void* _Nullable
NSString_inst_InitWithUTF8String(void* o, void* nullTerminatedCString) {
	NSString* _Nullable ret;
	@autoreleasepool {
		ret = [(NSString*)o initWithUTF8String:nullTerminatedCString];
	}
	return ret;

}
BOOL
NSString_inst_WriteToURLAtomically(void* o, void* url, BOOL useAuxiliaryFile, NSStringEncoding enc, void** error) {
	BOOL ret;
	@autoreleasepool {
		ret = [(NSString*)o writeToURL:url atomically:useAuxiliaryFile encoding:enc error:(NSError* _Nullable* _Nullable)error];
		for(int i=0;i<1;i++) {
			if(error[i] == 0) { break; }
			[(id)error[i] retain];
		}
	
	}
	return ret;

}
BOOL
NSString_inst_WriteToURLAtomicallyEncoding(void* o, void* url, BOOL useAuxiliaryFile, NSStringEncoding enc, void** error) {
	BOOL ret;
	@autoreleasepool {
		ret = [(NSString*)o writeToURL:url atomically:useAuxiliaryFile encoding:enc error:(NSError* _Nullable* _Nullable)error];
		for(int i=0;i<1;i++) {
			if(error[i] == 0) { break; }
			[(id)error[i] retain];
		}
	
	}
	return ret;

}
void* _Nonnull
NSString_inst_ClassForCoder(void* o) {
	Class _Nonnull ret;
	@autoreleasepool {
		ret = [(NSString*)o classForCoder];
	}
	return ret;

}
void* _Nullable
NSString_inst_InitWithBytesNoCopyLength(void* o, void* bytes, NSUInteger len, NSStringEncoding encoding, BOOL freeBuffer) {
	NSString* _Nullable ret;
	@autoreleasepool {
		ret = [(NSString*)o initWithBytesNoCopy:bytes length:len encoding:encoding freeWhenDone:freeBuffer];
	}
	return ret;

}
void* _Nullable
NSString_inst_InitWithBytesNoCopyLengthEncodingFreeWhenDone(void* o, void* bytes, NSUInteger len, NSStringEncoding encoding, BOOL freeBuffer) {
	NSString* _Nullable ret;
	@autoreleasepool {
		ret = [(NSString*)o initWithBytesNoCopy:bytes length:len encoding:encoding freeWhenDone:freeBuffer];
	}
	return ret;

}
void* _Nonnull
NSString_inst_SubstringFromIndex(void* o, NSUInteger from) {
	NSString* _Nonnull ret;
	@autoreleasepool {
		ret = [(NSString*)o substringFromIndex:from];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
BOOL
NSString_inst_ContainsString(void* o, void* str) {
	BOOL ret;
	@autoreleasepool {
		ret = [(NSString*)o containsString:str];
	}
	return ret;

}
FourCharCode
NSString_inst_ClassCode(void* o) {
	FourCharCode ret;
	@autoreleasepool {
		ret = [(NSString*)o classCode];
	}
	return ret;

}
void
NSString_inst_WillChangeValuesAtIndexes(void* o, NSKeyValueChange changeKind, void* indexes, void* key) {
	@autoreleasepool {
		[(NSString*)o willChange:changeKind valuesAtIndexes:indexes forKey:key];
	}
}
void
NSString_inst_WillChangeValuesAtIndexesForKey(void* o, NSKeyValueChange changeKind, void* indexes, void* key) {
	@autoreleasepool {
		[(NSString*)o willChange:changeKind valuesAtIndexes:indexes forKey:key];
	}
}
NSRange
NSString_inst_RangeOfComposedCharacterSequencesForRange(void* o, NSRange range) {
	NSRange ret;
	@autoreleasepool {
		ret = [(NSString*)o rangeOfComposedCharacterSequencesForRange:range];
	}
	return ret;

}
void* _Nonnull
NSString_inst_ComponentsSeparatedByString(void* o, void* separator) {
	NSArray* _Nonnull ret;
	@autoreleasepool {
		ret = [(NSString*)o componentsSeparatedByString:separator];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
void* _Nullable
NSString_inst_DataUsingEncoding(void* o, NSStringEncoding encoding) {
	NSData* _Nullable ret;
	@autoreleasepool {
		ret = [(NSString*)o dataUsingEncoding:encoding];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
void* _Nullable
NSString_inst_DataUsingEncodingAllowLossyConversion(void* o, NSStringEncoding encoding, BOOL lossy) {
	NSData* _Nullable ret;
	@autoreleasepool {
		ret = [(NSString*)o dataUsingEncoding:encoding allowLossyConversion:lossy];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
void* _Nonnull
NSString_inst_CommonPrefixWithStringOptions(void* o, void* str, NSStringCompareOptions mask) {
	NSString* _Nonnull ret;
	@autoreleasepool {
		ret = [(NSString*)o commonPrefixWithString:str options:mask];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
NSStringEncoding
NSString_inst_FastestEncoding(void* o) {
	NSStringEncoding ret;
	@autoreleasepool {
		ret = [(NSString*)o fastestEncoding];
	}
	return ret;

}
NSRange
NSString_inst_LineRangeForRange(void* o, NSRange range) {
	NSRange ret;
	@autoreleasepool {
		ret = [(NSString*)o lineRangeForRange:range];
	}
	return ret;

}
NSComparisonResult
NSString_inst_CaseInsensitiveCompare(void* o, void* string) {
	NSComparisonResult ret;
	@autoreleasepool {
		ret = [(NSString*)o caseInsensitiveCompare:string];
	}
	return ret;

}
BOOL
NSString_inst_ScriptingEndsWith(void* o, void* object) {
	BOOL ret;
	@autoreleasepool {
		ret = [(NSString*)o scriptingEndsWith:object];
	}
	return ret;

}
void* _Nonnull
NSString_inst_MutableArrayValueForKeyPath(void* o, void* keyPath) {
	NSMutableArray* _Nonnull ret;
	@autoreleasepool {
		ret = [(NSString*)o mutableArrayValueForKeyPath:keyPath];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
void
NSString_inst_DoesNotRecognizeSelector(void* o, void* aSelector) {
	@autoreleasepool {
		[(NSString*)o doesNotRecognizeSelector:aSelector];
	}
}
void* _Nonnull
NSString_inst_SubstringToIndex(void* o, NSUInteger to) {
	NSString* _Nonnull ret;
	@autoreleasepool {
		ret = [(NSString*)o substringToIndex:to];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
void* _Nullable
NSString_inst_InitWithDataEncoding(void* o, void* data, NSStringEncoding encoding) {
	NSString* _Nullable ret;
	@autoreleasepool {
		ret = [(NSString*)o initWithData:data encoding:encoding];
	}
	return ret;

}
void
NSString_inst_Dealloc(void* o) {
	@autoreleasepool {
		[(NSString*)o dealloc];
	}
}
BOOL
NSString_inst_ScriptingIsLessThan(void* o, void* object) {
	BOOL ret;
	@autoreleasepool {
		ret = [(NSString*)o scriptingIsLessThan:object];
	}
	return ret;

}
void* _Nullable
NSString_inst_ValueAtIndexInPropertyWithKey(void* o, NSUInteger index, void* key) {
	NSObject* _Nullable ret;
	@autoreleasepool {
		ret = [(NSString*)o valueAtIndex:index inPropertyWithKey:key];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
void* _Nullable
NSString_inst_ValueForKeyPath(void* o, void* keyPath) {
	NSObject* _Nullable ret;
	@autoreleasepool {
		ret = [(NSString*)o valueForKeyPath:keyPath];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
BOOL
NSString_inst_BoolValue(void* o) {
	BOOL ret;
	@autoreleasepool {
		ret = [(NSString*)o boolValue];
	}
	return ret;

}
const void*
NSString_inst_FileSystemRepresentation(void* o) {
	const char* ret;
	@autoreleasepool {
		ret = strdup([(NSString*)o fileSystemRepresentation]);
	}
	return ret;

}
void* _Nonnull
NSString_inst_DecomposedStringWithCanonicalMapping(void* o) {
	NSString* _Nonnull ret;
	@autoreleasepool {
		ret = [(NSString*)o decomposedStringWithCanonicalMapping];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
double
NSString_inst_DoubleValue(void* o) {
	double ret;
	@autoreleasepool {
		ret = [(NSString*)o doubleValue];
	}
	return ret;

}
void* _Nullable
NSString_inst_IndicesOfObjectsByEvaluatingObjectSpecifier(void* o, void* specifier) {
	NSArray* _Nullable ret;
	@autoreleasepool {
		ret = [(NSString*)o indicesOfObjectsByEvaluatingObjectSpecifier:specifier];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
void* _Nonnull
NSString_inst_MutableSetValueForKey(void* o, void* key) {
	NSMutableSet* _Nonnull ret;
	@autoreleasepool {
		ret = [(NSString*)o mutableSetValueForKey:key];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
NSRange
NSString_inst_RangeOfComposedCharacterSequenceAtIndex(void* o, NSUInteger index) {
	NSRange ret;
	@autoreleasepool {
		ret = [(NSString*)o rangeOfComposedCharacterSequenceAtIndex:index];
	}
	return ret;

}
void* _Nonnull
NSString_inst_LocalizedLowercaseString(void* o) {
	NSString* _Nonnull ret;
	@autoreleasepool {
		ret = [(NSString*)o localizedLowercaseString];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
NSComparisonResult
NSString_inst_LocalizedCaseInsensitiveCompare(void* o, void* string) {
	NSComparisonResult ret;
	@autoreleasepool {
		ret = [(NSString*)o localizedCaseInsensitiveCompare:string];
	}
	return ret;

}
void* _Nonnull
NSString_inst_UppercaseString(void* o) {
	NSString* _Nonnull ret;
	@autoreleasepool {
		ret = [(NSString*)o uppercaseString];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
BOOL
NSString_inst_IsAbsolutePath(void* o) {
	BOOL ret;
	@autoreleasepool {
		ret = [(NSString*)o isAbsolutePath];
	}
	return ret;

}
float
NSString_inst_FloatValue(void* o) {
	float ret;
	@autoreleasepool {
		ret = [(NSString*)o floatValue];
	}
	return ret;

}
void* _Nonnull
NSString_inst_StringByAppendingString(void* o, void* aString) {
	NSString* _Nonnull ret;
	@autoreleasepool {
		ret = [(NSString*)o stringByAppendingString:aString];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
void* _Nonnull
NSString_inst_StringByAppendingPathComponent(void* o, void* str) {
	NSString* _Nonnull ret;
	@autoreleasepool {
		ret = [(NSString*)o stringByAppendingPathComponent:str];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
NSComparisonResult
NSString_inst_LocalizedCompare(void* o, void* string) {
	NSComparisonResult ret;
	@autoreleasepool {
		ret = [(NSString*)o localizedCompare:string];
	}
	return ret;

}
void
NSString_inst_RemoveValueAtIndexFromPropertyWithKey(void* o, NSUInteger index, void* key) {
	@autoreleasepool {
		[(NSString*)o removeValueAtIndex:index fromPropertyWithKey:key];
	}
}
void
NSString_inst_PerformSelectorInBackgroundWithObject(void* o, void* aSelector, void* arg) {
	@autoreleasepool {
		[(NSString*)o performSelectorInBackground:aSelector withObject:arg];
	}
}
void* _Nonnull
NSString_inst_StringByReplacingOccurrencesOfStringWithString(void* o, void* target, void* replacement) {
	NSString* _Nonnull ret;
	@autoreleasepool {
		ret = [(NSString*)o stringByReplacingOccurrencesOfString:target withString:replacement];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
void* _Nonnull
NSString_inst_StringByReplacingOccurrencesOfStringWithStringOptions(void* o, void* target, void* replacement, NSStringCompareOptions options, NSRange searchRange) {
	NSString* _Nonnull ret;
	@autoreleasepool {
		ret = [(NSString*)o stringByReplacingOccurrencesOfString:target withString:replacement options:options range:searchRange];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
void* _Nonnull
NSString_inst_StringByReplacingOccurrencesOfStringWithStringOptionsRange(void* o, void* target, void* replacement, NSStringCompareOptions options, NSRange searchRange) {
	NSString* _Nonnull ret;
	@autoreleasepool {
		ret = [(NSString*)o stringByReplacingOccurrencesOfString:target withString:replacement options:options range:searchRange];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
NSUInteger
NSString_inst_CompletePathIntoStringCaseSensitive(void* o, void** outputName, BOOL flag, void** outputArray, void* filterTypes) {
	NSUInteger ret;
	@autoreleasepool {
		ret = [(NSString*)o completePathIntoString:(NSString* _Nullable* _Nullable)outputName caseSensitive:flag matchesIntoArray:(NSArray <NSString*>* _Nullable* _Nullable)outputArray filterTypes:filterTypes];
		for(int i=0;i<1;i++) {
			if(outputName[i] == 0) { break; }
			[(id)outputName[i] retain];
		}
	
	
		for(int i=0;i<1;i++) {
			if(outputArray[i] == 0) { break; }
			[(id)outputArray[i] retain];
		}
	
	}
	return ret;

}
NSUInteger
NSString_inst_CompletePathIntoStringCaseSensitiveMatchesIntoArray(void* o, void** outputName, BOOL flag, void** outputArray, void* filterTypes) {
	NSUInteger ret;
	@autoreleasepool {
		ret = [(NSString*)o completePathIntoString:(NSString* _Nullable* _Nullable)outputName caseSensitive:flag matchesIntoArray:(NSArray <NSString*>* _Nullable* _Nullable)outputArray filterTypes:filterTypes];
		for(int i=0;i<1;i++) {
			if(outputName[i] == 0) { break; }
			[(id)outputName[i] retain];
		}
	
	
		for(int i=0;i<1;i++) {
			if(outputArray[i] == 0) { break; }
			[(id)outputArray[i] retain];
		}
	
	}
	return ret;

}
void* _Nonnull
NSString_inst_StringByFoldingWithOptionsLocale(void* o, NSStringCompareOptions options, void* locale) {
	NSString* _Nonnull ret;
	@autoreleasepool {
		ret = [(NSString*)o stringByFoldingWithOptions:options locale:locale];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
void* _Nullable
NSString_inst_InitWithCoder(void* o, void* coder) {
	NSString* _Nullable ret;
	@autoreleasepool {
		ret = [(NSString*)o initWithCoder:coder];
	}
	return ret;

}
NSRange
NSString_inst_RangeOfString(void* o, void* searchString) {
	NSRange ret;
	@autoreleasepool {
		ret = [(NSString*)o rangeOfString:searchString];
	}
	return ret;

}
NSRange
NSString_inst_RangeOfStringOptions(void* o, void* searchString, NSStringCompareOptions mask) {
	NSRange ret;
	@autoreleasepool {
		ret = [(NSString*)o rangeOfString:searchString options:mask];
	}
	return ret;

}
NSRange
NSString_inst_RangeOfStringOptionsRange(void* o, void* searchString, NSStringCompareOptions mask, NSRange rangeOfReceiverToSearch) {
	NSRange ret;
	@autoreleasepool {
		ret = [(NSString*)o rangeOfString:searchString options:mask range:rangeOfReceiverToSearch];
	}
	return ret;

}
NSRange
NSString_inst_RangeOfStringOptionsRangeLocale(void* o, void* searchString, NSStringCompareOptions mask, NSRange rangeOfReceiverToSearch, void* locale) {
	NSRange ret;
	@autoreleasepool {
		ret = [(NSString*)o rangeOfString:searchString options:mask range:rangeOfReceiverToSearch locale:locale];
	}
	return ret;

}
BOOL
NSString_inst_DoesContain(void* o, void* object) {
	BOOL ret;
	@autoreleasepool {
		ret = [(NSString*)o doesContain:object];
	}
	return ret;

}
void
NSString_inst_SetValuesForKeysWithDictionary(void* o, void* keyedValues) {
	@autoreleasepool {
		[(NSString*)o setValuesForKeysWithDictionary:keyedValues];
	}
}
NSUInteger
NSString_inst_Length(void* o) {
	NSUInteger ret;
	@autoreleasepool {
		ret = [(NSString*)o length];
	}
	return ret;

}
void
NSString_inst_GetParagraphStartEnd(void* o, void* startPtr, void* parEndPtr, void* contentsEndPtr, NSRange range) {
	@autoreleasepool {
		[(NSString*)o getParagraphStart:startPtr end:parEndPtr contentsEnd:contentsEndPtr forRange:range];
	}
}
void
NSString_inst_GetParagraphStartEndContentsEnd(void* o, void* startPtr, void* parEndPtr, void* contentsEndPtr, NSRange range) {
	@autoreleasepool {
		[(NSString*)o getParagraphStart:startPtr end:parEndPtr contentsEnd:contentsEndPtr forRange:range];
	}
}
void* _Nonnull
NSString_inst_PrecomposedStringWithCanonicalMapping(void* o) {
	NSString* _Nonnull ret;
	@autoreleasepool {
		ret = [(NSString*)o precomposedStringWithCanonicalMapping];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
void* _Nullable
NSString_inst_InitWithContentsOfURLEncoding(void* o, void* url, NSStringEncoding enc, void** error) {
	NSString* _Nullable ret;
	@autoreleasepool {
		ret = [(NSString*)o initWithContentsOfURL:url encoding:enc error:(NSError* _Nullable* _Nullable)error];
		for(int i=0;i<1;i++) {
			if(error[i] == 0) { break; }
			[(id)error[i] retain];
		}
	
	}
	return ret;

}
void* _Nullable
NSString_inst_InitWithContentsOfURLUsedEncoding(void* o, void* url, void* enc, void** error) {
	NSString* _Nullable ret;
	@autoreleasepool {
		ret = [(NSString*)o initWithContentsOfURL:url usedEncoding:enc error:(NSError* _Nullable* _Nullable)error];
		for(int i=0;i<1;i++) {
			if(error[i] == 0) { break; }
			[(id)error[i] retain];
		}
	
	}
	return ret;

}
void* _Nullable
NSString_inst_InitWithContentsOfURLEncodingError(void* o, void* url, NSStringEncoding enc, void** error) {
	NSString* _Nullable ret;
	@autoreleasepool {
		ret = [(NSString*)o initWithContentsOfURL:url encoding:enc error:(NSError* _Nullable* _Nullable)error];
		for(int i=0;i<1;i++) {
			if(error[i] == 0) { break; }
			[(id)error[i] retain];
		}
	
	}
	return ret;

}
void* _Nullable
NSString_inst_InitWithContentsOfURLUsedEncodingError(void* o, void* url, void* enc, void** error) {
	NSString* _Nullable ret;
	@autoreleasepool {
		ret = [(NSString*)o initWithContentsOfURL:url usedEncoding:enc error:(NSError* _Nullable* _Nullable)error];
		for(int i=0;i<1;i++) {
			if(error[i] == 0) { break; }
			[(id)error[i] retain];
		}
	
	}
	return ret;

}
void
NSString_inst_ObserveValueForKeyPathOfObject(void* o, void* keyPath, void* object, void* change, void* context) {
	@autoreleasepool {
		[(NSString*)o observeValueForKeyPath:keyPath ofObject:object change:change context:context];
	}
}
void
NSString_inst_ObserveValueForKeyPathOfObjectChange(void* o, void* keyPath, void* object, void* change, void* context) {
	@autoreleasepool {
		[(NSString*)o observeValueForKeyPath:keyPath ofObject:object change:change context:context];
	}
}
void* _Nullable
NSString_inst_ScriptingProperties(void* o) {
	NSDictionary* _Nullable ret;
	@autoreleasepool {
		ret = [(NSString*)o scriptingProperties];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
void
NSString_inst_DidChangeValueForKey(void* o, void* key) {
	@autoreleasepool {
		[(NSString*)o didChangeValueForKey:key];
	}
}
void
NSString_inst_DidChangeValueForKeyWithSetMutation(void* o, void* key, NSKeyValueSetMutationKind mutationKind, void* objects) {
	@autoreleasepool {
		[(NSString*)o didChangeValueForKey:key withSetMutation:mutationKind usingObjects:objects];
	}
}
void
NSString_inst_DidChangeValueForKeyWithSetMutationUsingObjects(void* o, void* key, NSKeyValueSetMutationKind mutationKind, void* objects) {
	@autoreleasepool {
		[(NSString*)o didChangeValueForKey:key withSetMutation:mutationKind usingObjects:objects];
	}
}
void* _Nonnull
NSString_inst_ComponentsSeparatedByCharactersInSet(void* o, void* separator) {
	NSArray* _Nonnull ret;
	@autoreleasepool {
		ret = [(NSString*)o componentsSeparatedByCharactersInSet:separator];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
BOOL
NSString_inst_GetFileSystemRepresentationMaxLength(void* o, void* cname, NSUInteger max) {
	BOOL ret;
	@autoreleasepool {
		ret = [(NSString*)o getFileSystemRepresentation:cname maxLength:max];
	}
	return ret;

}
void* _Nonnull
NSString_inst_StringByDeletingLastPathComponent(void* o) {
	NSString* _Nonnull ret;
	@autoreleasepool {
		ret = [(NSString*)o stringByDeletingLastPathComponent];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
void* _Nonnull
NSString_inst_ToManyRelationshipKeys(void* o) {
	NSArray* _Nonnull ret;
	@autoreleasepool {
		ret = [(NSString*)o toManyRelationshipKeys];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
void
NSString_inst_DidChangeValuesAtIndexes(void* o, NSKeyValueChange changeKind, void* indexes, void* key) {
	@autoreleasepool {
		[(NSString*)o didChange:changeKind valuesAtIndexes:indexes forKey:key];
	}
}
void
NSString_inst_DidChangeValuesAtIndexesForKey(void* o, NSKeyValueChange changeKind, void* indexes, void* key) {
	@autoreleasepool {
		[(NSString*)o didChange:changeKind valuesAtIndexes:indexes forKey:key];
	}
}
void
NSString_inst_ForwardInvocation(void* o, void* anInvocation) {
	@autoreleasepool {
		[(NSString*)o forwardInvocation:anInvocation];
	}
}
void* _Nonnull
NSString_inst_AttributeKeys(void* o) {
	NSArray* _Nonnull ret;
	@autoreleasepool {
		ret = [(NSString*)o attributeKeys];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
void*
NSObject_Class() {
	Class ret;
	@autoreleasepool {
		ret = [NSObject class];
	}
	return ret;

}
BOOL
NSObject_AutomaticallyNotifiesObserversForKey(void* key) {
	BOOL ret;
	@autoreleasepool {
		ret = [NSObject automaticallyNotifiesObserversForKey:key];
	}
	return ret;

}
void
NSObject_Load() {
	@autoreleasepool {
		[NSObject load];
	}
}
BOOL
NSObject_ResolveInstanceMethod(void* sel) {
	BOOL ret;
	@autoreleasepool {
		ret = [NSObject resolveInstanceMethod:sel];
	}
	return ret;

}
BOOL
NSObject_ResolveClassMethod(void* sel) {
	BOOL ret;
	@autoreleasepool {
		ret = [NSObject resolveClassMethod:sel];
	}
	return ret;

}
void*
NSObject_Description() {
	NSString* ret;
	@autoreleasepool {
		ret = [NSObject description];
	}
	return ret;

}
void* _Nonnull
NSObject_ClassFallbacksForKeyedArchiver() {
	NSArray* _Nonnull ret;
	@autoreleasepool {
		ret = [NSObject classFallbacksForKeyedArchiver];
	}
	return ret;

}
BOOL
NSObject_IsSubclassOfClass(void* aClass) {
	BOOL ret;
	@autoreleasepool {
		ret = [NSObject isSubclassOfClass:aClass];
	}
	return ret;

}
void*
NSObject_CopyWithZone(void* zone) {
	NSObject* ret;
	@autoreleasepool {
		ret = [NSObject copyWithZone:zone];
	}
	return ret;

}
NSUInteger
NSObject_Hash() {
	NSUInteger ret;
	@autoreleasepool {
		ret = [NSObject hash];
	}
	return ret;

}
void
NSObject_CancelPreviousPerformRequestsWithTarget(void* aTarget) {
	@autoreleasepool {
		[NSObject cancelPreviousPerformRequestsWithTarget:aTarget];
	}
}
void
NSObject_CancelPreviousPerformRequestsWithTargetSelector(void* aTarget, void* aSelector, void* anArgument) {
	@autoreleasepool {
		[NSObject cancelPreviousPerformRequestsWithTarget:aTarget selector:aSelector object:anArgument];
	}
}
void
NSObject_CancelPreviousPerformRequestsWithTargetSelectorObject(void* aTarget, void* aSelector, void* anArgument) {
	@autoreleasepool {
		[NSObject cancelPreviousPerformRequestsWithTarget:aTarget selector:aSelector object:anArgument];
	}
}
void*
NSObject_AllocWithZone(void* zone) {
	return [NSObject allocWithZone:zone];
}
void*
NSObject_New() {
	NSObject* ret;
	@autoreleasepool {
		ret = [NSObject new];
	}
	return ret;

}
void* _Nonnull
NSObject_KeyPathsForValuesAffectingValueForKey(void* key) {
	NSSet* _Nonnull ret;
	@autoreleasepool {
		ret = [NSObject keyPathsForValuesAffectingValueForKey:key];
	}
	return ret;

}
BOOL
NSObject_AccessInstanceVariablesDirectly() {
	BOOL ret;
	@autoreleasepool {
		ret = [NSObject accessInstanceVariablesDirectly];
	}
	return ret;

}
void
NSObject_SetVersion(NSInteger aVersion) {
	@autoreleasepool {
		[NSObject setVersion:aVersion];
	}
}
void*
NSObject_InstanceMethodSignatureForSelector(void* aSelector) {
	NSMethodSignature* ret;
	@autoreleasepool {
		ret = [NSObject instanceMethodSignatureForSelector:aSelector];
	}
	return ret;

}
void*
NSObject_Superclass() {
	Class ret;
	@autoreleasepool {
		ret = [NSObject superclass];
	}
	return ret;

}
void*
NSObject_Alloc() {
	return [NSObject alloc];
}
void*
NSObject_DebugDescription() {
	NSString* ret;
	@autoreleasepool {
		ret = [NSObject debugDescription];
	}
	return ret;

}
NSInteger
NSObject_Version() {
	NSInteger ret;
	@autoreleasepool {
		ret = [NSObject version];
	}
	return ret;

}
void*
NSObject_MutableCopyWithZone(void* zone) {
	NSObject* ret;
	@autoreleasepool {
		ret = [NSObject mutableCopyWithZone:zone];
	}
	return ret;

}
BOOL
NSObject_InstancesRespondToSelector(void* aSelector) {
	BOOL ret;
	@autoreleasepool {
		ret = [NSObject instancesRespondToSelector:aSelector];
	}
	return ret;

}
BOOL
NSObject_ConformsToProtocol(void* protocol) {
	BOOL ret;
	@autoreleasepool {
		ret = [NSObject conformsToProtocol:protocol];
	}
	return ret;

}
void* _Nonnull
NSObject_ClassForKeyedUnarchiver() {
	Class _Nonnull ret;
	@autoreleasepool {
		ret = [NSObject classForKeyedUnarchiver];
	}
	return ret;

}
BOOL
NSObject_inst_ScriptingIsLessThanOrEqualTo(void* o, void* object) {
	BOOL ret;
	@autoreleasepool {
		ret = [(NSObject*)o scriptingIsLessThanOrEqualTo:object];
	}
	return ret;

}
BOOL
NSObject_inst_IsProxy(void* o) {
	BOOL ret;
	@autoreleasepool {
		ret = [(NSObject*)o isProxy];
	}
	return ret;

}
BOOL
NSObject_inst_IsMemberOfClass(void* o, void* aClass) {
	BOOL ret;
	@autoreleasepool {
		ret = [(NSObject*)o isMemberOfClass:aClass];
	}
	return ret;

}
void
NSObject_inst_RemoveValueAtIndexFromPropertyWithKey(void* o, NSUInteger index, void* key) {
	@autoreleasepool {
		[(NSObject*)o removeValueAtIndex:index fromPropertyWithKey:key];
	}
}
BOOL
NSObject_inst_AttemptRecoveryFromErrorOptionIndex(void* o, void* error, NSUInteger recoveryOptionIndex) {
	BOOL ret;
	@autoreleasepool {
		ret = [(NSObject*)o attemptRecoveryFromError:error optionIndex:recoveryOptionIndex];
	}
	return ret;

}
void
NSObject_inst_AttemptRecoveryFromErrorOptionIndexDelegate(void* o, void* error, NSUInteger recoveryOptionIndex, void* delegate, void* didRecoverSelector, void* contextInfo) {
	@autoreleasepool {
		[(NSObject*)o attemptRecoveryFromError:error optionIndex:recoveryOptionIndex delegate:delegate didRecoverSelector:didRecoverSelector contextInfo:contextInfo];
	}
}
void
NSObject_inst_AttemptRecoveryFromErrorOptionIndexDelegateDidRecoverSelector(void* o, void* error, NSUInteger recoveryOptionIndex, void* delegate, void* didRecoverSelector, void* contextInfo) {
	@autoreleasepool {
		[(NSObject*)o attemptRecoveryFromError:error optionIndex:recoveryOptionIndex delegate:delegate didRecoverSelector:didRecoverSelector contextInfo:contextInfo];
	}
}
void* _Nonnull
NSObject_inst_MutableArrayValueForKeyPath(void* o, void* keyPath) {
	NSMutableArray* _Nonnull ret;
	@autoreleasepool {
		ret = [(NSObject*)o mutableArrayValueForKeyPath:keyPath];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
BOOL
NSObject_inst_ScriptingIsLessThan(void* o, void* object) {
	BOOL ret;
	@autoreleasepool {
		ret = [(NSObject*)o scriptingIsLessThan:object];
	}
	return ret;

}
void* _Nullable
NSObject_inst_ReplacementObjectForCoder(void* o, void* coder) {
	NSObject* _Nullable ret;
	@autoreleasepool {
		ret = [(NSObject*)o replacementObjectForCoder:coder];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
BOOL
NSObject_inst_IsGreaterThan(void* o, void* object) {
	BOOL ret;
	@autoreleasepool {
		ret = [(NSObject*)o isGreaterThan:object];
	}
	return ret;

}
BOOL
NSObject_inst_IsEqual(void* o, void* object) {
	BOOL ret;
	@autoreleasepool {
		ret = [(NSObject*)o isEqual:object];
	}
	return ret;

}
void*
NSObject_inst_Class(void* o) {
	Class ret;
	@autoreleasepool {
		ret = [(NSObject*)o class];
	}
	return ret;

}
void
NSObject_inst_SetValueForKey(void* o, void* value, void* key) {
	@autoreleasepool {
		[(NSObject*)o setValue:value forKey:key];
	}
}
void
NSObject_inst_SetValueForKeyPath(void* o, void* value, void* keyPath) {
	@autoreleasepool {
		[(NSObject*)o setValue:value forKeyPath:keyPath];
	}
}
void
NSObject_inst_SetValueForUndefinedKey(void* o, void* value, void* key) {
	@autoreleasepool {
		[(NSObject*)o setValue:value forUndefinedKey:key];
	}
}
void* _Nonnull
NSObject_inst_MutableSetValueForKeyPath(void* o, void* keyPath) {
	NSMutableSet* _Nonnull ret;
	@autoreleasepool {
		ret = [(NSObject*)o mutableSetValueForKeyPath:keyPath];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
void
NSObject_inst_AddObserverForKeyPath(void* o, void* observer, void* keyPath, NSKeyValueObservingOptions options, void* context) {
	@autoreleasepool {
		[(NSObject*)o addObserver:observer forKeyPath:keyPath options:options context:context];
	}
}
void
NSObject_inst_AddObserverForKeyPathOptions(void* o, void* observer, void* keyPath, NSKeyValueObservingOptions options, void* context) {
	@autoreleasepool {
		[(NSObject*)o addObserver:observer forKeyPath:keyPath options:options context:context];
	}
}
void*
NSObject_inst_Retain(void* o) {
	NSObject* ret;
	@autoreleasepool {
		ret = [(NSObject*)o retain];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
void* _Nullable
NSObject_inst_ValueForKey(void* o, void* key) {
	NSObject* _Nullable ret;
	@autoreleasepool {
		ret = [(NSObject*)o valueForKey:key];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
void* _Nullable
NSObject_inst_NewScriptingObjectOfClassForValueForKey(void* o, void* objectClass, void* key, void* contentsValue, void* properties) {
	NSObject* _Nullable ret;
	@autoreleasepool {
		ret = [(NSObject*)o newScriptingObjectOfClass:objectClass forValueForKey:key withContentsValue:contentsValue properties:properties];
	}
	return ret;

}
void* _Nullable
NSObject_inst_NewScriptingObjectOfClassForValueForKeyWithContentsValue(void* o, void* objectClass, void* key, void* contentsValue, void* properties) {
	NSObject* _Nullable ret;
	@autoreleasepool {
		ret = [(NSObject*)o newScriptingObjectOfClass:objectClass forValueForKey:key withContentsValue:contentsValue properties:properties];
	}
	return ret;

}
BOOL
NSObject_inst_IsCaseInsensitiveLike(void* o, void* object) {
	BOOL ret;
	@autoreleasepool {
		ret = [(NSObject*)o isCaseInsensitiveLike:object];
	}
	return ret;

}
void* _Nullable
NSObject_inst_ClassForArchiver(void* o) {
	Class _Nullable ret;
	@autoreleasepool {
		ret = [(NSObject*)o classForArchiver];
	}
	return ret;

}
FourCharCode
NSObject_inst_ClassCode(void* o) {
	FourCharCode ret;
	@autoreleasepool {
		ret = [(NSObject*)o classCode];
	}
	return ret;

}
void
NSObject_inst_SetScriptingProperties(void* o, void* scriptingProperties) {
	@autoreleasepool {
		[(NSObject*)o setScriptingProperties:scriptingProperties];
	}
}
void* _Nonnull
NSObject_inst_MutableOrderedSetValueForKeyPath(void* o, void* keyPath) {
	NSMutableOrderedSet* _Nonnull ret;
	@autoreleasepool {
		ret = [(NSObject*)o mutableOrderedSetValueForKeyPath:keyPath];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
void
NSObject_inst_ReplaceValueAtIndexInPropertyWithKey(void* o, NSUInteger index, void* key, void* value) {
	@autoreleasepool {
		[(NSObject*)o replaceValueAtIndex:index inPropertyWithKey:key withValue:value];
	}
}
void
NSObject_inst_ReplaceValueAtIndexInPropertyWithKeyWithValue(void* o, NSUInteger index, void* key, void* value) {
	@autoreleasepool {
		[(NSObject*)o replaceValueAtIndex:index inPropertyWithKey:key withValue:value];
	}
}
BOOL
NSObject_inst_ScriptingIsGreaterThanOrEqualTo(void* o, void* object) {
	BOOL ret;
	@autoreleasepool {
		ret = [(NSObject*)o scriptingIsGreaterThanOrEqualTo:object];
	}
	return ret;

}
void* _Nullable
NSObject_inst_AwakeAfterUsingCoder(void* o, void* coder) {
	NSObject* _Nullable ret;
	@autoreleasepool {
		ret = [(NSObject*)o awakeAfterUsingCoder:coder];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
void* _Nonnull
NSObject_inst_ToOneRelationshipKeys(void* o) {
	NSArray* _Nonnull ret;
	@autoreleasepool {
		ret = [(NSObject*)o toOneRelationshipKeys];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
void* _Nullable
NSObject_inst_ValueWithNameInPropertyWithKey(void* o, void* name, void* key) {
	NSObject* _Nullable ret;
	@autoreleasepool {
		ret = [(NSObject*)o valueWithName:name inPropertyWithKey:key];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
void
NSObject_inst_WillChangeValueForKey(void* o, void* key) {
	@autoreleasepool {
		[(NSObject*)o willChangeValueForKey:key];
	}
}
void
NSObject_inst_WillChangeValueForKeyWithSetMutation(void* o, void* key, NSKeyValueSetMutationKind mutationKind, void* objects) {
	@autoreleasepool {
		[(NSObject*)o willChangeValueForKey:key withSetMutation:mutationKind usingObjects:objects];
	}
}
void
NSObject_inst_WillChangeValueForKeyWithSetMutationUsingObjects(void* o, void* key, NSKeyValueSetMutationKind mutationKind, void* objects) {
	@autoreleasepool {
		[(NSObject*)o willChangeValueForKey:key withSetMutation:mutationKind usingObjects:objects];
	}
}
BOOL
NSObject_inst_ConformsToProtocol(void* o, void* aProtocol) {
	BOOL ret;
	@autoreleasepool {
		ret = [(NSObject*)o conformsToProtocol:aProtocol];
	}
	return ret;

}
void*
NSObject_inst_Copy(void* o) {
	NSObject* ret;
	@autoreleasepool {
		ret = [(NSObject*)o copy];
	}
	return ret;

}
void* _Nonnull
NSObject_inst_MutableOrderedSetValueForKey(void* o, void* key) {
	NSMutableOrderedSet* _Nonnull ret;
	@autoreleasepool {
		ret = [(NSObject*)o mutableOrderedSetValueForKey:key];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
void
NSObject_inst_Dealloc(void* o) {
	@autoreleasepool {
		[(NSObject*)o dealloc];
	}
}
void
NSObject_inst_SetNilValueForKey(void* o, void* key) {
	@autoreleasepool {
		[(NSObject*)o setNilValueForKey:key];
	}
}
void* _Nonnull
NSObject_inst_AttributeKeys(void* o) {
	NSArray* _Nonnull ret;
	@autoreleasepool {
		ret = [(NSObject*)o attributeKeys];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
BOOL
NSObject_inst_RespondsToSelector(void* o, void* aSelector) {
	BOOL ret;
	@autoreleasepool {
		ret = [(NSObject*)o respondsToSelector:aSelector];
	}
	return ret;

}
NSUInteger
NSObject_inst_RetainCount(void* o) {
	NSUInteger ret;
	@autoreleasepool {
		ret = [(NSObject*)o retainCount];
	}
	return ret;

}
void* _Nullable
NSObject_inst_ObjectSpecifier(void* o) {
	NSScriptObjectSpecifier* _Nullable ret;
	@autoreleasepool {
		ret = [(NSObject*)o objectSpecifier];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
void* _Nullable
NSObject_inst_ValueAtIndexInPropertyWithKey(void* o, NSUInteger index, void* key) {
	NSObject* _Nullable ret;
	@autoreleasepool {
		ret = [(NSObject*)o valueAtIndex:index inPropertyWithKey:key];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
void
NSObject_inst_ForwardInvocation(void* o, void* anInvocation) {
	@autoreleasepool {
		[(NSObject*)o forwardInvocation:anInvocation];
	}
}
void* _Nullable
NSObject_inst_ScriptingProperties(void* o) {
	NSDictionary* _Nullable ret;
	@autoreleasepool {
		ret = [(NSObject*)o scriptingProperties];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
void
NSObject_inst_SetObservationInfo(void* o, void* observationInfo) {
	@autoreleasepool {
		[(NSObject*)o setObservationInfo:observationInfo];
	}
}
void
NSObject_inst_DoesNotRecognizeSelector(void* o, void* aSelector) {
	@autoreleasepool {
		[(NSObject*)o doesNotRecognizeSelector:aSelector];
	}
}
void
NSObject_inst_WillChangeValuesAtIndexes(void* o, NSKeyValueChange changeKind, void* indexes, void* key) {
	@autoreleasepool {
		[(NSObject*)o willChange:changeKind valuesAtIndexes:indexes forKey:key];
	}
}
void
NSObject_inst_WillChangeValuesAtIndexesForKey(void* o, NSKeyValueChange changeKind, void* indexes, void* key) {
	@autoreleasepool {
		[(NSObject*)o willChange:changeKind valuesAtIndexes:indexes forKey:key];
	}
}
void* _Nonnull
NSObject_inst_MutableArrayValueForKey(void* o, void* key) {
	NSMutableArray* _Nonnull ret;
	@autoreleasepool {
		ret = [(NSObject*)o mutableArrayValueForKey:key];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
void* _Nullable
NSObject_inst_InverseForRelationshipKey(void* o, void* relationshipKey) {
	NSString* _Nullable ret;
	@autoreleasepool {
		ret = [(NSObject*)o inverseForRelationshipKey:relationshipKey];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
void*
NSObject_inst_ForwardingTargetForSelector(void* o, void* aSelector) {
	NSObject* ret;
	@autoreleasepool {
		ret = [(NSObject*)o forwardingTargetForSelector:aSelector];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
void
NSObject_inst_RemoveObserverForKeyPath(void* o, void* observer, void* keyPath) {
	@autoreleasepool {
		[(NSObject*)o removeObserver:observer forKeyPath:keyPath];
	}
}
void
NSObject_inst_RemoveObserverForKeyPathContext(void* o, void* observer, void* keyPath, void* context) {
	@autoreleasepool {
		[(NSObject*)o removeObserver:observer forKeyPath:keyPath context:context];
	}
}
void
NSObject_inst_DidChangeValuesAtIndexes(void* o, NSKeyValueChange changeKind, void* indexes, void* key) {
	@autoreleasepool {
		[(NSObject*)o didChange:changeKind valuesAtIndexes:indexes forKey:key];
	}
}
void
NSObject_inst_DidChangeValuesAtIndexesForKey(void* o, NSKeyValueChange changeKind, void* indexes, void* key) {
	@autoreleasepool {
		[(NSObject*)o didChange:changeKind valuesAtIndexes:indexes forKey:key];
	}
}
void
NSObject_inst_InsertValueInPropertyWithKey(void* o, void* value, void* key) {
	@autoreleasepool {
		[(NSObject*)o insertValue:value inPropertyWithKey:key];
	}
}
void
NSObject_inst_InsertValueAtIndex(void* o, void* value, NSUInteger index, void* key) {
	@autoreleasepool {
		[(NSObject*)o insertValue:value atIndex:index inPropertyWithKey:key];
	}
}
void
NSObject_inst_InsertValueAtIndexInPropertyWithKey(void* o, void* value, NSUInteger index, void* key) {
	@autoreleasepool {
		[(NSObject*)o insertValue:value atIndex:index inPropertyWithKey:key];
	}
}
void*
NSObject_inst_MutableCopy(void* o) {
	NSObject* ret;
	@autoreleasepool {
		ret = [(NSObject*)o mutableCopy];
	}
	return ret;

}
void* _Nullable
NSObject_inst_ScriptingValueForSpecifier(void* o, void* objectSpecifier) {
	NSObject* _Nullable ret;
	@autoreleasepool {
		ret = [(NSObject*)o scriptingValueForSpecifier:objectSpecifier];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
BOOL
NSObject_inst_ScriptingIsEqualTo(void* o, void* object) {
	BOOL ret;
	@autoreleasepool {
		ret = [(NSObject*)o scriptingIsEqualTo:object];
	}
	return ret;

}
void* _Nonnull
NSObject_inst_ClassName(void* o) {
	NSString* _Nonnull ret;
	@autoreleasepool {
		ret = [(NSObject*)o className];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
BOOL
NSObject_inst_ValidateValueForKey(void* o, void** ioValue, void* inKey, void** outError) {
	BOOL ret;
	@autoreleasepool {
		ret = [(NSObject*)o validateValue:(id _Nullable* _Nonnull)ioValue forKey:inKey error:(NSError* _Nullable* _Nullable)outError];
		for(int i=0;i<1;i++) {
			if(ioValue[i] == 0) { break; }
			[(id)ioValue[i] retain];
		}
	
	
		for(int i=0;i<1;i++) {
			if(outError[i] == 0) { break; }
			[(id)outError[i] retain];
		}
	
	}
	return ret;

}
BOOL
NSObject_inst_ValidateValueForKeyPath(void* o, void** ioValue, void* inKeyPath, void** outError) {
	BOOL ret;
	@autoreleasepool {
		ret = [(NSObject*)o validateValue:(id _Nullable* _Nonnull)ioValue forKeyPath:inKeyPath error:(NSError* _Nullable* _Nullable)outError];
		for(int i=0;i<1;i++) {
			if(ioValue[i] == 0) { break; }
			[(id)ioValue[i] retain];
		}
	
	
		for(int i=0;i<1;i++) {
			if(outError[i] == 0) { break; }
			[(id)outError[i] retain];
		}
	
	}
	return ret;

}
BOOL
NSObject_inst_ValidateValueForKeyError(void* o, void** ioValue, void* inKey, void** outError) {
	BOOL ret;
	@autoreleasepool {
		ret = [(NSObject*)o validateValue:(id _Nullable* _Nonnull)ioValue forKey:inKey error:(NSError* _Nullable* _Nullable)outError];
		for(int i=0;i<1;i++) {
			if(ioValue[i] == 0) { break; }
			[(id)ioValue[i] retain];
		}
	
	
		for(int i=0;i<1;i++) {
			if(outError[i] == 0) { break; }
			[(id)outError[i] retain];
		}
	
	}
	return ret;

}
BOOL
NSObject_inst_ValidateValueForKeyPathError(void* o, void** ioValue, void* inKeyPath, void** outError) {
	BOOL ret;
	@autoreleasepool {
		ret = [(NSObject*)o validateValue:(id _Nullable* _Nonnull)ioValue forKeyPath:inKeyPath error:(NSError* _Nullable* _Nullable)outError];
		for(int i=0;i<1;i++) {
			if(ioValue[i] == 0) { break; }
			[(id)ioValue[i] retain];
		}
	
	
		for(int i=0;i<1;i++) {
			if(outError[i] == 0) { break; }
			[(id)outError[i] retain];
		}
	
	}
	return ret;

}
BOOL
NSObject_inst_IsEqualTo(void* o, void* object) {
	BOOL ret;
	@autoreleasepool {
		ret = [(NSObject*)o isEqualTo:object];
	}
	return ret;

}
void
NSObject_inst_DidChangeValueForKey(void* o, void* key) {
	@autoreleasepool {
		[(NSObject*)o didChangeValueForKey:key];
	}
}
void
NSObject_inst_DidChangeValueForKeyWithSetMutation(void* o, void* key, NSKeyValueSetMutationKind mutationKind, void* objects) {
	@autoreleasepool {
		[(NSObject*)o didChangeValueForKey:key withSetMutation:mutationKind usingObjects:objects];
	}
}
void
NSObject_inst_DidChangeValueForKeyWithSetMutationUsingObjects(void* o, void* key, NSKeyValueSetMutationKind mutationKind, void* objects) {
	@autoreleasepool {
		[(NSObject*)o didChangeValueForKey:key withSetMutation:mutationKind usingObjects:objects];
	}
}
void* _Nonnull
NSObject_inst_ClassDescription(void* o) {
	NSClassDescription* _Nonnull ret;
	@autoreleasepool {
		ret = [(NSObject*)o classDescription];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
void* _Nullable
NSObject_inst_ValueForUndefinedKey(void* o, void* key) {
	NSObject* _Nullable ret;
	@autoreleasepool {
		ret = [(NSObject*)o valueForUndefinedKey:key];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
void* _Nonnull
NSObject_inst_ToManyRelationshipKeys(void* o) {
	NSArray* _Nonnull ret;
	@autoreleasepool {
		ret = [(NSObject*)o toManyRelationshipKeys];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
void* _Nullable
NSObject_inst_IndicesOfObjectsByEvaluatingObjectSpecifier(void* o, void* specifier) {
	NSArray* _Nullable ret;
	@autoreleasepool {
		ret = [(NSObject*)o indicesOfObjectsByEvaluatingObjectSpecifier:specifier];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
BOOL
NSObject_inst_IsGreaterThanOrEqualTo(void* o, void* object) {
	BOOL ret;
	@autoreleasepool {
		ret = [(NSObject*)o isGreaterThanOrEqualTo:object];
	}
	return ret;

}
BOOL
NSObject_inst_DoesContain(void* o, void* object) {
	BOOL ret;
	@autoreleasepool {
		ret = [(NSObject*)o doesContain:object];
	}
	return ret;

}
void*
NSObject_inst_Autorelease(void* o) {
	NSObject* ret;
	@autoreleasepool {
		ret = [(NSObject*)o autorelease];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
void* _Nonnull
NSObject_inst_DictionaryWithValuesForKeys(void* o, void* keys) {
	NSDictionary* _Nonnull ret;
	@autoreleasepool {
		ret = [(NSObject*)o dictionaryWithValuesForKeys:keys];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
BOOL
NSObject_inst_IsNotEqualTo(void* o, void* object) {
	BOOL ret;
	@autoreleasepool {
		ret = [(NSObject*)o isNotEqualTo:object];
	}
	return ret;

}
void
NSObject_inst_ObserveValueForKeyPathOfObject(void* o, void* keyPath, void* object, void* change, void* context) {
	@autoreleasepool {
		[(NSObject*)o observeValueForKeyPath:keyPath ofObject:object change:change context:context];
	}
}
void
NSObject_inst_ObserveValueForKeyPathOfObjectChange(void* o, void* keyPath, void* object, void* change, void* context) {
	@autoreleasepool {
		[(NSObject*)o observeValueForKeyPath:keyPath ofObject:object change:change context:context];
	}
}
void*
NSObject_inst_Superclass(void* o) {
	Class ret;
	@autoreleasepool {
		ret = [(NSObject*)o superclass];
	}
	return ret;

}
BOOL
NSObject_inst_ScriptingIsGreaterThan(void* o, void* object) {
	BOOL ret;
	@autoreleasepool {
		ret = [(NSObject*)o scriptingIsGreaterThan:object];
	}
	return ret;

}
BOOL
NSObject_inst_IsLike(void* o, void* object) {
	BOOL ret;
	@autoreleasepool {
		ret = [(NSObject*)o isLike:object];
	}
	return ret;

}
BOOL
NSObject_inst_IsKindOfClass(void* o, void* aClass) {
	BOOL ret;
	@autoreleasepool {
		ret = [(NSObject*)o isKindOfClass:aClass];
	}
	return ret;

}
void*
NSObject_inst_Init(void* o) {
	NSObject* ret;
	@autoreleasepool {
		ret = [(NSObject*)o init];
	}
	return ret;

}
void
NSObject_inst_SetValuesForKeysWithDictionary(void* o, void* keyedValues) {
	@autoreleasepool {
		[(NSObject*)o setValuesForKeysWithDictionary:keyedValues];
	}
}
void* _Nullable
NSObject_inst_ClassForKeyedArchiver(void* o) {
	Class _Nullable ret;
	@autoreleasepool {
		ret = [(NSObject*)o classForKeyedArchiver];
	}
	return ret;

}
BOOL
NSObject_inst_ScriptingContains(void* o, void* object) {
	BOOL ret;
	@autoreleasepool {
		ret = [(NSObject*)o scriptingContains:object];
	}
	return ret;

}
void* _Nonnull
NSObject_inst_MutableSetValueForKey(void* o, void* key) {
	NSMutableSet* _Nonnull ret;
	@autoreleasepool {
		ret = [(NSObject*)o mutableSetValueForKey:key];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
void* _Nullable
NSObject_inst_ReplacementObjectForKeyedArchiver(void* o, void* archiver) {
	NSObject* _Nullable ret;
	@autoreleasepool {
		ret = [(NSObject*)o replacementObjectForKeyedArchiver:archiver];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
BOOL
NSObject_inst_ScriptingEndsWith(void* o, void* object) {
	BOOL ret;
	@autoreleasepool {
		ret = [(NSObject*)o scriptingEndsWith:object];
	}
	return ret;

}
void*
NSObject_inst_ObservationInfo(void* o) {
	void* ret;
	@autoreleasepool {
		ret = [(NSObject*)o observationInfo];
	}
	return ret;

}
void*
NSObject_inst_PerformSelector(void* o, void* aSelector) {
	NSObject* ret;
	@autoreleasepool {
		ret = [(NSObject*)o performSelector:aSelector];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
void*
NSObject_inst_PerformSelectorWithObject(void* o, void* aSelector, void* object) {
	NSObject* ret;
	@autoreleasepool {
		ret = [(NSObject*)o performSelector:aSelector withObject:object];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
void
NSObject_inst_PerformSelectorWithObjectAfterDelay(void* o, void* aSelector, void* anArgument, NSTimeInterval delay) {
	@autoreleasepool {
		[(NSObject*)o performSelector:aSelector withObject:anArgument afterDelay:delay];
	}
}
void*
NSObject_inst_PerformSelectorWithObjectWithObject(void* o, void* aSelector, void* object1, void* object2) {
	NSObject* ret;
	@autoreleasepool {
		ret = [(NSObject*)o performSelector:aSelector withObject:object1 withObject:object2];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
void
NSObject_inst_PerformSelectorOnThread(void* o, void* aSelector, void* thr, void* arg, BOOL wait) {
	@autoreleasepool {
		[(NSObject*)o performSelector:aSelector onThread:thr withObject:arg waitUntilDone:wait];
	}
}
void
NSObject_inst_PerformSelectorWithObjectAfterDelayInModes(void* o, void* aSelector, void* anArgument, NSTimeInterval delay, void* modes) {
	@autoreleasepool {
		[(NSObject*)o performSelector:aSelector withObject:anArgument afterDelay:delay inModes:modes];
	}
}
void
NSObject_inst_PerformSelectorOnThreadWithObject(void* o, void* aSelector, void* thr, void* arg, BOOL wait) {
	@autoreleasepool {
		[(NSObject*)o performSelector:aSelector onThread:thr withObject:arg waitUntilDone:wait];
	}
}
void
NSObject_inst_PerformSelectorOnThreadWithObjectWaitUntilDone(void* o, void* aSelector, void* thr, void* arg, BOOL wait, void* array) {
	@autoreleasepool {
		[(NSObject*)o performSelector:aSelector onThread:thr withObject:arg waitUntilDone:wait modes:array];
	}
}
void
NSObject_inst_PerformSelectorOnThreadWithObjectWaitUntilDoneModes(void* o, void* aSelector, void* thr, void* arg, BOOL wait, void* array) {
	@autoreleasepool {
		[(NSObject*)o performSelector:aSelector onThread:thr withObject:arg waitUntilDone:wait modes:array];
	}
}
void* _Nullable
NSObject_inst_CopyScriptingValueForKey(void* o, void* value, void* key, void* properties) {
	NSObject* _Nullable ret;
	@autoreleasepool {
		ret = [(NSObject*)o copyScriptingValue:value forKey:key withProperties:properties];
	}
	return ret;

}
void* _Nullable
NSObject_inst_CopyScriptingValueForKeyWithProperties(void* o, void* value, void* key, void* properties) {
	NSObject* _Nullable ret;
	@autoreleasepool {
		ret = [(NSObject*)o copyScriptingValue:value forKey:key withProperties:properties];
	}
	return ret;

}
void* _Nullable
NSObject_inst_ValueWithUniqueIDInPropertyWithKey(void* o, void* uniqueID, void* key) {
	NSObject* _Nullable ret;
	@autoreleasepool {
		ret = [(NSObject*)o valueWithUniqueID:uniqueID inPropertyWithKey:key];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
BOOL
NSObject_inst_IsLessThanOrEqualTo(void* o, void* object) {
	BOOL ret;
	@autoreleasepool {
		ret = [(NSObject*)o isLessThanOrEqualTo:object];
	}
	return ret;

}
void* _Nonnull
NSObject_inst_AutoContentAccessingProxy(void* o) {
	NSObject* _Nonnull ret;
	@autoreleasepool {
		ret = [(NSObject*)o autoContentAccessingProxy];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
void*
NSObject_inst_Zone(void* o) {
	struct _NSZone* ret;
	@autoreleasepool {
		ret = [(NSObject*)o zone];
	}
	return ret;

}
void*
NSObject_inst_DebugDescription(void* o) {
	NSString* ret;
	@autoreleasepool {
		ret = [(NSObject*)o debugDescription];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
void
NSObject_inst_Release(void* o) {
	@autoreleasepool {
		[(NSObject*)o release];
	}
}
BOOL
NSObject_inst_IsLessThan(void* o, void* object) {
	BOOL ret;
	@autoreleasepool {
		ret = [(NSObject*)o isLessThan:object];
	}
	return ret;

}
void* _Nullable
NSObject_inst_ValueForKeyPath(void* o, void* keyPath) {
	NSObject* _Nullable ret;
	@autoreleasepool {
		ret = [(NSObject*)o valueForKeyPath:keyPath];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
BOOL
NSObject_inst_ScriptingBeginsWith(void* o, void* object) {
	BOOL ret;
	@autoreleasepool {
		ret = [(NSObject*)o scriptingBeginsWith:object];
	}
	return ret;

}
void*
NSObject_inst_Self(void* o) {
	NSObject* ret;
	@autoreleasepool {
		ret = [(NSObject*)o self];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
void* _Nullable
NSObject_inst_CoerceValueForKey(void* o, void* value, void* key) {
	NSObject* _Nullable ret;
	@autoreleasepool {
		ret = [(NSObject*)o coerceValue:value forKey:key];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
void
NSObject_inst_PerformSelectorInBackgroundWithObject(void* o, void* aSelector, void* arg) {
	@autoreleasepool {
		[(NSObject*)o performSelectorInBackground:aSelector withObject:arg];
	}
}
NSUInteger
NSObject_inst_Hash(void* o) {
	NSUInteger ret;
	@autoreleasepool {
		ret = [(NSObject*)o hash];
	}
	return ret;

}
void*
NSObject_inst_Description(void* o) {
	NSString* ret;
	@autoreleasepool {
		ret = [(NSObject*)o description];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
void*
NSObject_inst_MethodSignatureForSelector(void* o, void* aSelector) {
	NSMethodSignature* ret;
	@autoreleasepool {
		ret = [(NSObject*)o methodSignatureForSelector:aSelector];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
void* _Nonnull
NSObject_inst_ClassForCoder(void* o) {
	Class _Nonnull ret;
	@autoreleasepool {
		ret = [(NSObject*)o classForCoder];
	}
	return ret;

}
void
NSObject_inst_PerformSelectorOnMainThreadWithObject(void* o, void* aSelector, void* arg, BOOL wait) {
	@autoreleasepool {
		[(NSObject*)o performSelectorOnMainThread:aSelector withObject:arg waitUntilDone:wait];
	}
}
void
NSObject_inst_PerformSelectorOnMainThreadWithObjectWaitUntilDone(void* o, void* aSelector, void* arg, BOOL wait) {
	@autoreleasepool {
		[(NSObject*)o performSelectorOnMainThread:aSelector withObject:arg waitUntilDone:wait];
	}
}
void
NSObject_inst_PerformSelectorOnMainThreadWithObjectWaitUntilDoneModes(void* o, void* aSelector, void* arg, BOOL wait, void* array) {
	@autoreleasepool {
		[(NSObject*)o performSelectorOnMainThread:aSelector withObject:arg waitUntilDone:wait modes:array];
	}
}
BOOL
NSData_AutomaticallyNotifiesObserversForKey(void* key) {
	BOOL ret;
	@autoreleasepool {
		ret = [NSData automaticallyNotifiesObserversForKey:key];
	}
	return ret;

}
void*
NSData_Description() {
	NSString* ret;
	@autoreleasepool {
		ret = [NSData description];
	}
	return ret;

}
BOOL
NSData_IsSubclassOfClass(void* aClass) {
	BOOL ret;
	@autoreleasepool {
		ret = [NSData isSubclassOfClass:aClass];
	}
	return ret;

}
void*
NSData_CopyWithZone(void* zone) {
	NSObject* ret;
	@autoreleasepool {
		ret = [NSData copyWithZone:zone];
	}
	return ret;

}
BOOL
NSData_ConformsToProtocol(void* protocol) {
	BOOL ret;
	@autoreleasepool {
		ret = [NSData conformsToProtocol:protocol];
	}
	return ret;

}
BOOL
NSData_SupportsSecureCoding() {
	BOOL ret;
	@autoreleasepool {
		ret = [NSData supportsSecureCoding];
	}
	return ret;

}
BOOL
NSData_ResolveClassMethod(void* sel) {
	BOOL ret;
	@autoreleasepool {
		ret = [NSData resolveClassMethod:sel];
	}
	return ret;

}
void*
NSData_MutableCopyWithZone(void* zone) {
	NSObject* ret;
	@autoreleasepool {
		ret = [NSData mutableCopyWithZone:zone];
	}
	return ret;

}
BOOL
NSData_InstancesRespondToSelector(void* aSelector) {
	BOOL ret;
	@autoreleasepool {
		ret = [NSData instancesRespondToSelector:aSelector];
	}
	return ret;

}
void*
NSData_Alloc() {
	return [NSData alloc];
}
void*
NSData_DebugDescription() {
	NSString* ret;
	@autoreleasepool {
		ret = [NSData debugDescription];
	}
	return ret;

}
void* _Nullable
NSData_DataWithContentsOfFile(void* path) {
	NSData* _Nullable ret;
	@autoreleasepool {
		ret = [NSData dataWithContentsOfFile:path];
		if(ret != nil) { [ret retain]; }
	}
	return ret;

}
void* _Nullable
NSData_DataWithContentsOfFileOptions(void* path, NSDataReadingOptions readOptionsMask, void** errorPtr) {
	NSData* _Nullable ret;
	@autoreleasepool {
		ret = [NSData dataWithContentsOfFile:path options:readOptionsMask error:(NSError* _Nullable* _Nullable)errorPtr];
		if(ret != nil) { [ret retain]; }
		for(int i=0;i<1;i++) {
			if(errorPtr[i] == 0) { break; }
			[(id)errorPtr[i] retain];
		}
	
	}
	return ret;

}
void* _Nullable
NSData_DataWithContentsOfFileOptionsError(void* path, NSDataReadingOptions readOptionsMask, void** errorPtr) {
	NSData* _Nullable ret;
	@autoreleasepool {
		ret = [NSData dataWithContentsOfFile:path options:readOptionsMask error:(NSError* _Nullable* _Nullable)errorPtr];
		if(ret != nil) { [ret retain]; }
		for(int i=0;i<1;i++) {
			if(errorPtr[i] == 0) { break; }
			[(id)errorPtr[i] retain];
		}
	
	}
	return ret;

}
void* _Nonnull
NSData_DataWithData(void* data) {
	NSData* _Nonnull ret;
	@autoreleasepool {
		ret = [NSData dataWithData:data];
		if(ret != nil) { [ret retain]; }
	}
	return ret;

}
NSUInteger
NSData_Hash() {
	NSUInteger ret;
	@autoreleasepool {
		ret = [NSData hash];
	}
	return ret;

}
void*
NSData_AllocWithZone(void* zone) {
	return [NSData allocWithZone:zone];
}
void* _Nonnull
NSData_KeyPathsForValuesAffectingValueForKey(void* key) {
	NSSet* _Nonnull ret;
	@autoreleasepool {
		ret = [NSData keyPathsForValuesAffectingValueForKey:key];
	}
	return ret;

}
void* _Nonnull
NSData_DataWithBytesNoCopyLength(void* bytes, NSUInteger length) {
	NSData* _Nonnull ret;
	@autoreleasepool {
		ret = [NSData dataWithBytesNoCopy:bytes length:length];
		if(ret != nil) { [ret retain]; }
	}
	return ret;

}
void* _Nonnull
NSData_DataWithBytesNoCopyLengthFreeWhenDone(void* bytes, NSUInteger length, BOOL b) {
	NSData* _Nonnull ret;
	@autoreleasepool {
		ret = [NSData dataWithBytesNoCopy:bytes length:length freeWhenDone:b];
		if(ret != nil) { [ret retain]; }
	}
	return ret;

}
void* _Nullable
NSData_DataWithContentsOfURL(void* url) {
	NSData* _Nullable ret;
	@autoreleasepool {
		ret = [NSData dataWithContentsOfURL:url];
		if(ret != nil) { [ret retain]; }
	}
	return ret;

}
void* _Nullable
NSData_DataWithContentsOfURLOptions(void* url, NSDataReadingOptions readOptionsMask, void** errorPtr) {
	NSData* _Nullable ret;
	@autoreleasepool {
		ret = [NSData dataWithContentsOfURL:url options:readOptionsMask error:(NSError* _Nullable* _Nullable)errorPtr];
		if(ret != nil) { [ret retain]; }
		for(int i=0;i<1;i++) {
			if(errorPtr[i] == 0) { break; }
			[(id)errorPtr[i] retain];
		}
	
	}
	return ret;

}
void* _Nullable
NSData_DataWithContentsOfURLOptionsError(void* url, NSDataReadingOptions readOptionsMask, void** errorPtr) {
	NSData* _Nullable ret;
	@autoreleasepool {
		ret = [NSData dataWithContentsOfURL:url options:readOptionsMask error:(NSError* _Nullable* _Nullable)errorPtr];
		if(ret != nil) { [ret retain]; }
		for(int i=0;i<1;i++) {
			if(errorPtr[i] == 0) { break; }
			[(id)errorPtr[i] retain];
		}
	
	}
	return ret;

}
void* _Nonnull
NSData_DataWithBytesLength(void* bytes, NSUInteger length) {
	NSData* _Nonnull ret;
	@autoreleasepool {
		ret = [NSData dataWithBytes:bytes length:length];
		if(ret != nil) { [ret retain]; }
	}
	return ret;

}
void* _Nonnull
NSData_ClassFallbacksForKeyedArchiver() {
	NSArray* _Nonnull ret;
	@autoreleasepool {
		ret = [NSData classFallbacksForKeyedArchiver];
	}
	return ret;

}
void*
NSData_New() {
	NSData* ret;
	@autoreleasepool {
		ret = [NSData new];
	}
	return ret;

}
void
NSData_SetVersion(NSInteger aVersion) {
	@autoreleasepool {
		[NSData setVersion:aVersion];
	}
}
void
NSData_Load() {
	@autoreleasepool {
		[NSData load];
	}
}
void
NSData_CancelPreviousPerformRequestsWithTarget(void* aTarget) {
	@autoreleasepool {
		[NSData cancelPreviousPerformRequestsWithTarget:aTarget];
	}
}
void
NSData_CancelPreviousPerformRequestsWithTargetSelector(void* aTarget, void* aSelector, void* anArgument) {
	@autoreleasepool {
		[NSData cancelPreviousPerformRequestsWithTarget:aTarget selector:aSelector object:anArgument];
	}
}
void
NSData_CancelPreviousPerformRequestsWithTargetSelectorObject(void* aTarget, void* aSelector, void* anArgument) {
	@autoreleasepool {
		[NSData cancelPreviousPerformRequestsWithTarget:aTarget selector:aSelector object:anArgument];
	}
}
void*
NSData_InstanceMethodSignatureForSelector(void* aSelector) {
	NSMethodSignature* ret;
	@autoreleasepool {
		ret = [NSData instanceMethodSignatureForSelector:aSelector];
	}
	return ret;

}
NSInteger
NSData_Version() {
	NSInteger ret;
	@autoreleasepool {
		ret = [NSData version];
	}
	return ret;

}
void*
NSData_Class() {
	Class ret;
	@autoreleasepool {
		ret = [NSData class];
	}
	return ret;

}
void* _Nonnull
NSData_Data() {
	NSData* _Nonnull ret;
	@autoreleasepool {
		ret = [NSData data];
		if(ret != nil) { [ret retain]; }
	}
	return ret;

}
BOOL
NSData_ResolveInstanceMethod(void* sel) {
	BOOL ret;
	@autoreleasepool {
		ret = [NSData resolveInstanceMethod:sel];
	}
	return ret;

}
BOOL
NSData_AccessInstanceVariablesDirectly() {
	BOOL ret;
	@autoreleasepool {
		ret = [NSData accessInstanceVariablesDirectly];
	}
	return ret;

}
void*
NSData_Superclass() {
	Class ret;
	@autoreleasepool {
		ret = [NSData superclass];
	}
	return ret;

}
void* _Nonnull
NSData_ClassForKeyedUnarchiver() {
	Class _Nonnull ret;
	@autoreleasepool {
		ret = [NSData classForKeyedUnarchiver];
	}
	return ret;

}
void* _Nonnull
NSData_inst_Base64EncodedDataWithOptions(void* o, NSDataBase64EncodingOptions options) {
	NSData* _Nonnull ret;
	@autoreleasepool {
		ret = [(NSData*)o base64EncodedDataWithOptions:options];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
void* _Nullable
NSData_inst_AwakeAfterUsingCoder(void* o, void* coder) {
	NSObject* _Nullable ret;
	@autoreleasepool {
		ret = [(NSData*)o awakeAfterUsingCoder:coder];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
void
NSData_inst_ObserveValueForKeyPathOfObject(void* o, void* keyPath, void* object, void* change, void* context) {
	@autoreleasepool {
		[(NSData*)o observeValueForKeyPath:keyPath ofObject:object change:change context:context];
	}
}
void
NSData_inst_ObserveValueForKeyPathOfObjectChange(void* o, void* keyPath, void* object, void* change, void* context) {
	@autoreleasepool {
		[(NSData*)o observeValueForKeyPath:keyPath ofObject:object change:change context:context];
	}
}
void* _Nullable
NSData_inst_ObjectSpecifier(void* o) {
	NSScriptObjectSpecifier* _Nullable ret;
	@autoreleasepool {
		ret = [(NSData*)o objectSpecifier];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
void* _Nonnull
NSData_inst_MutableArrayValueForKey(void* o, void* key) {
	NSMutableArray* _Nonnull ret;
	@autoreleasepool {
		ret = [(NSData*)o mutableArrayValueForKey:key];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
void*
NSData_inst_Superclass(void* o) {
	Class ret;
	@autoreleasepool {
		ret = [(NSData*)o superclass];
	}
	return ret;

}
BOOL
NSData_inst_ScriptingIsGreaterThanOrEqualTo(void* o, void* object) {
	BOOL ret;
	@autoreleasepool {
		ret = [(NSData*)o scriptingIsGreaterThanOrEqualTo:object];
	}
	return ret;

}
BOOL
NSData_inst_IsKindOfClass(void* o, void* aClass) {
	BOOL ret;
	@autoreleasepool {
		ret = [(NSData*)o isKindOfClass:aClass];
	}
	return ret;

}
void* _Nonnull
NSData_inst_InitWithData(void* o, void* data) {
	NSData* _Nonnull ret;
	@autoreleasepool {
		ret = [(NSData*)o initWithData:data];
	}
	return ret;

}
void* _Nullable
NSData_inst_InitWithContentsOfURL(void* o, void* url) {
	NSData* _Nullable ret;
	@autoreleasepool {
		ret = [(NSData*)o initWithContentsOfURL:url];
	}
	return ret;

}
void* _Nullable
NSData_inst_InitWithContentsOfURLOptions(void* o, void* url, NSDataReadingOptions readOptionsMask, void** errorPtr) {
	NSData* _Nullable ret;
	@autoreleasepool {
		ret = [(NSData*)o initWithContentsOfURL:url options:readOptionsMask error:(NSError* _Nullable* _Nullable)errorPtr];
		for(int i=0;i<1;i++) {
			if(errorPtr[i] == 0) { break; }
			[(id)errorPtr[i] retain];
		}
	
	}
	return ret;

}
void* _Nullable
NSData_inst_InitWithContentsOfURLOptionsError(void* o, void* url, NSDataReadingOptions readOptionsMask, void** errorPtr) {
	NSData* _Nullable ret;
	@autoreleasepool {
		ret = [(NSData*)o initWithContentsOfURL:url options:readOptionsMask error:(NSError* _Nullable* _Nullable)errorPtr];
		for(int i=0;i<1;i++) {
			if(errorPtr[i] == 0) { break; }
			[(id)errorPtr[i] retain];
		}
	
	}
	return ret;

}
void* _Nonnull
NSData_inst_DictionaryWithValuesForKeys(void* o, void* keys) {
	NSDictionary* _Nonnull ret;
	@autoreleasepool {
		ret = [(NSData*)o dictionaryWithValuesForKeys:keys];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
NSUInteger
NSData_inst_RetainCount(void* o) {
	NSUInteger ret;
	@autoreleasepool {
		ret = [(NSData*)o retainCount];
	}
	return ret;

}
void* _Nonnull
NSData_inst_MutableCopyWithZone(void* o, void* zone) {
	NSObject* _Nonnull ret;
	@autoreleasepool {
		ret = [(NSData*)o mutableCopyWithZone:zone];
	}
	return ret;

}
void* _Nonnull
NSData_inst_InitWithBytesNoCopyLength(void* o, void* bytes, NSUInteger length) {
	NSData* _Nonnull ret;
	@autoreleasepool {
		ret = [(NSData*)o initWithBytesNoCopy:bytes length:length];
	}
	return ret;

}
void* _Nonnull
NSData_inst_InitWithBytesNoCopyLengthFreeWhenDone(void* o, void* bytes, NSUInteger length, BOOL b) {
	NSData* _Nonnull ret;
	@autoreleasepool {
		ret = [(NSData*)o initWithBytesNoCopy:bytes length:length freeWhenDone:b];
	}
	return ret;

}
void* _Nullable
NSData_inst_InitWithBase64EncodedDataOptions(void* o, void* base64Data, NSDataBase64DecodingOptions options) {
	NSData* _Nullable ret;
	@autoreleasepool {
		ret = [(NSData*)o initWithBase64EncodedData:base64Data options:options];
	}
	return ret;

}
void* _Nonnull
NSData_inst_SubdataWithRange(void* o, NSRange range) {
	NSData* _Nonnull ret;
	@autoreleasepool {
		ret = [(NSData*)o subdataWithRange:range];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
BOOL
NSData_inst_IsMemberOfClass(void* o, void* aClass) {
	BOOL ret;
	@autoreleasepool {
		ret = [(NSData*)o isMemberOfClass:aClass];
	}
	return ret;

}
void* _Nullable
NSData_inst_IndicesOfObjectsByEvaluatingObjectSpecifier(void* o, void* specifier) {
	NSArray* _Nullable ret;
	@autoreleasepool {
		ret = [(NSData*)o indicesOfObjectsByEvaluatingObjectSpecifier:specifier];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
void
NSData_inst_SetValuesForKeysWithDictionary(void* o, void* keyedValues) {
	@autoreleasepool {
		[(NSData*)o setValuesForKeysWithDictionary:keyedValues];
	}
}
void*
NSData_inst_PerformSelector(void* o, void* aSelector) {
	NSObject* ret;
	@autoreleasepool {
		ret = [(NSData*)o performSelector:aSelector];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
void*
NSData_inst_PerformSelectorWithObject(void* o, void* aSelector, void* object) {
	NSObject* ret;
	@autoreleasepool {
		ret = [(NSData*)o performSelector:aSelector withObject:object];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
void*
NSData_inst_PerformSelectorWithObjectWithObject(void* o, void* aSelector, void* object1, void* object2) {
	NSObject* ret;
	@autoreleasepool {
		ret = [(NSData*)o performSelector:aSelector withObject:object1 withObject:object2];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
void
NSData_inst_PerformSelectorWithObjectAfterDelay(void* o, void* aSelector, void* anArgument, NSTimeInterval delay) {
	@autoreleasepool {
		[(NSData*)o performSelector:aSelector withObject:anArgument afterDelay:delay];
	}
}
void
NSData_inst_PerformSelectorOnThread(void* o, void* aSelector, void* thr, void* arg, BOOL wait) {
	@autoreleasepool {
		[(NSData*)o performSelector:aSelector onThread:thr withObject:arg waitUntilDone:wait];
	}
}
void
NSData_inst_PerformSelectorWithObjectAfterDelayInModes(void* o, void* aSelector, void* anArgument, NSTimeInterval delay, void* modes) {
	@autoreleasepool {
		[(NSData*)o performSelector:aSelector withObject:anArgument afterDelay:delay inModes:modes];
	}
}
void
NSData_inst_PerformSelectorOnThreadWithObject(void* o, void* aSelector, void* thr, void* arg, BOOL wait) {
	@autoreleasepool {
		[(NSData*)o performSelector:aSelector onThread:thr withObject:arg waitUntilDone:wait];
	}
}
void
NSData_inst_PerformSelectorOnThreadWithObjectWaitUntilDone(void* o, void* aSelector, void* thr, void* arg, BOOL wait, void* array) {
	@autoreleasepool {
		[(NSData*)o performSelector:aSelector onThread:thr withObject:arg waitUntilDone:wait modes:array];
	}
}
void
NSData_inst_PerformSelectorOnThreadWithObjectWaitUntilDoneModes(void* o, void* aSelector, void* thr, void* arg, BOOL wait, void* array) {
	@autoreleasepool {
		[(NSData*)o performSelector:aSelector onThread:thr withObject:arg waitUntilDone:wait modes:array];
	}
}
void*
NSData_inst_MethodSignatureForSelector(void* o, void* aSelector) {
	NSMethodSignature* ret;
	@autoreleasepool {
		ret = [(NSData*)o methodSignatureForSelector:aSelector];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
void* _Nullable
NSData_inst_InverseForRelationshipKey(void* o, void* relationshipKey) {
	NSString* _Nullable ret;
	@autoreleasepool {
		ret = [(NSData*)o inverseForRelationshipKey:relationshipKey];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
void*
NSData_inst_ForwardingTargetForSelector(void* o, void* aSelector) {
	NSObject* ret;
	@autoreleasepool {
		ret = [(NSData*)o forwardingTargetForSelector:aSelector];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
BOOL
NSData_inst_ScriptingIsEqualTo(void* o, void* object) {
	BOOL ret;
	@autoreleasepool {
		ret = [(NSData*)o scriptingIsEqualTo:object];
	}
	return ret;

}
BOOL
NSData_inst_ValidateValueForKey(void* o, void** ioValue, void* inKey, void** outError) {
	BOOL ret;
	@autoreleasepool {
		ret = [(NSData*)o validateValue:(id _Nullable* _Nonnull)ioValue forKey:inKey error:(NSError* _Nullable* _Nullable)outError];
		for(int i=0;i<1;i++) {
			if(ioValue[i] == 0) { break; }
			[(id)ioValue[i] retain];
		}
	
	
		for(int i=0;i<1;i++) {
			if(outError[i] == 0) { break; }
			[(id)outError[i] retain];
		}
	
	}
	return ret;

}
BOOL
NSData_inst_ValidateValueForKeyPath(void* o, void** ioValue, void* inKeyPath, void** outError) {
	BOOL ret;
	@autoreleasepool {
		ret = [(NSData*)o validateValue:(id _Nullable* _Nonnull)ioValue forKeyPath:inKeyPath error:(NSError* _Nullable* _Nullable)outError];
		for(int i=0;i<1;i++) {
			if(ioValue[i] == 0) { break; }
			[(id)ioValue[i] retain];
		}
	
	
		for(int i=0;i<1;i++) {
			if(outError[i] == 0) { break; }
			[(id)outError[i] retain];
		}
	
	}
	return ret;

}
BOOL
NSData_inst_ValidateValueForKeyError(void* o, void** ioValue, void* inKey, void** outError) {
	BOOL ret;
	@autoreleasepool {
		ret = [(NSData*)o validateValue:(id _Nullable* _Nonnull)ioValue forKey:inKey error:(NSError* _Nullable* _Nullable)outError];
		for(int i=0;i<1;i++) {
			if(ioValue[i] == 0) { break; }
			[(id)ioValue[i] retain];
		}
	
	
		for(int i=0;i<1;i++) {
			if(outError[i] == 0) { break; }
			[(id)outError[i] retain];
		}
	
	}
	return ret;

}
BOOL
NSData_inst_ValidateValueForKeyPathError(void* o, void** ioValue, void* inKeyPath, void** outError) {
	BOOL ret;
	@autoreleasepool {
		ret = [(NSData*)o validateValue:(id _Nullable* _Nonnull)ioValue forKeyPath:inKeyPath error:(NSError* _Nullable* _Nullable)outError];
		for(int i=0;i<1;i++) {
			if(ioValue[i] == 0) { break; }
			[(id)ioValue[i] retain];
		}
	
	
		for(int i=0;i<1;i++) {
			if(outError[i] == 0) { break; }
			[(id)outError[i] retain];
		}
	
	}
	return ret;

}
void* _Nonnull
NSData_inst_Description(void* o) {
	NSString* _Nonnull ret;
	@autoreleasepool {
		ret = [(NSData*)o description];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
BOOL
NSData_inst_ConformsToProtocol(void* o, void* aProtocol) {
	BOOL ret;
	@autoreleasepool {
		ret = [(NSData*)o conformsToProtocol:aProtocol];
	}
	return ret;

}
BOOL
NSData_inst_ScriptingIsGreaterThan(void* o, void* object) {
	BOOL ret;
	@autoreleasepool {
		ret = [(NSData*)o scriptingIsGreaterThan:object];
	}
	return ret;

}
void*
NSData_inst_MutableCopy(void* o) {
	NSObject* ret;
	@autoreleasepool {
		ret = [(NSData*)o mutableCopy];
	}
	return ret;

}
BOOL
NSData_inst_IsGreaterThan(void* o, void* object) {
	BOOL ret;
	@autoreleasepool {
		ret = [(NSData*)o isGreaterThan:object];
	}
	return ret;

}
BOOL
NSData_inst_IsCaseInsensitiveLike(void* o, void* object) {
	BOOL ret;
	@autoreleasepool {
		ret = [(NSData*)o isCaseInsensitiveLike:object];
	}
	return ret;

}
void* _Nullable
NSData_inst_ValueWithNameInPropertyWithKey(void* o, void* name, void* key) {
	NSObject* _Nullable ret;
	@autoreleasepool {
		ret = [(NSData*)o valueWithName:name inPropertyWithKey:key];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
void
NSData_inst_WillChangeValuesAtIndexes(void* o, NSKeyValueChange changeKind, void* indexes, void* key) {
	@autoreleasepool {
		[(NSData*)o willChange:changeKind valuesAtIndexes:indexes forKey:key];
	}
}
void
NSData_inst_WillChangeValuesAtIndexesForKey(void* o, NSKeyValueChange changeKind, void* indexes, void* key) {
	@autoreleasepool {
		[(NSData*)o willChange:changeKind valuesAtIndexes:indexes forKey:key];
	}
}
void* _Nullable
NSData_inst_CoerceValueForKey(void* o, void* value, void* key) {
	NSObject* _Nullable ret;
	@autoreleasepool {
		ret = [(NSData*)o coerceValue:value forKey:key];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
NSUInteger
NSData_inst_Hash(void* o) {
	NSUInteger ret;
	@autoreleasepool {
		ret = [(NSData*)o hash];
	}
	return ret;

}
void
NSData_inst_SetNilValueForKey(void* o, void* key) {
	@autoreleasepool {
		[(NSData*)o setNilValueForKey:key];
	}
}
void* _Nullable
NSData_inst_ScriptingValueForSpecifier(void* o, void* objectSpecifier) {
	NSObject* _Nullable ret;
	@autoreleasepool {
		ret = [(NSData*)o scriptingValueForSpecifier:objectSpecifier];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
BOOL
NSData_inst_ScriptingBeginsWith(void* o, void* object) {
	BOOL ret;
	@autoreleasepool {
		ret = [(NSData*)o scriptingBeginsWith:object];
	}
	return ret;

}
BOOL
NSData_inst_WriteToFileAtomically(void* o, void* path, BOOL useAuxiliaryFile) {
	BOOL ret;
	@autoreleasepool {
		ret = [(NSData*)o writeToFile:path atomically:useAuxiliaryFile];
	}
	return ret;

}
BOOL
NSData_inst_WriteToFileOptions(void* o, void* path, NSDataWritingOptions writeOptionsMask, void** errorPtr) {
	BOOL ret;
	@autoreleasepool {
		ret = [(NSData*)o writeToFile:path options:writeOptionsMask error:(NSError* _Nullable* _Nullable)errorPtr];
		for(int i=0;i<1;i++) {
			if(errorPtr[i] == 0) { break; }
			[(id)errorPtr[i] retain];
		}
	
	}
	return ret;

}
BOOL
NSData_inst_WriteToFileOptionsError(void* o, void* path, NSDataWritingOptions writeOptionsMask, void** errorPtr) {
	BOOL ret;
	@autoreleasepool {
		ret = [(NSData*)o writeToFile:path options:writeOptionsMask error:(NSError* _Nullable* _Nullable)errorPtr];
		for(int i=0;i<1;i++) {
			if(errorPtr[i] == 0) { break; }
			[(id)errorPtr[i] retain];
		}
	
	}
	return ret;

}
void* _Nonnull
NSData_inst_InitWithBytesLength(void* o, void* bytes, NSUInteger length) {
	NSData* _Nonnull ret;
	@autoreleasepool {
		ret = [(NSData*)o initWithBytes:bytes length:length];
	}
	return ret;

}
BOOL
NSData_inst_ScriptingIsLessThan(void* o, void* object) {
	BOOL ret;
	@autoreleasepool {
		ret = [(NSData*)o scriptingIsLessThan:object];
	}
	return ret;

}
void*
NSData_inst_Init(void* o) {
	NSData* ret;
	@autoreleasepool {
		ret = [(NSData*)o init];
	}
	return ret;

}
void* _Nonnull
NSData_inst_MutableArrayValueForKeyPath(void* o, void* keyPath) {
	NSMutableArray* _Nonnull ret;
	@autoreleasepool {
		ret = [(NSData*)o mutableArrayValueForKeyPath:keyPath];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
void
NSData_inst_InsertValueInPropertyWithKey(void* o, void* value, void* key) {
	@autoreleasepool {
		[(NSData*)o insertValue:value inPropertyWithKey:key];
	}
}
void
NSData_inst_InsertValueAtIndex(void* o, void* value, NSUInteger index, void* key) {
	@autoreleasepool {
		[(NSData*)o insertValue:value atIndex:index inPropertyWithKey:key];
	}
}
void
NSData_inst_InsertValueAtIndexInPropertyWithKey(void* o, void* value, NSUInteger index, void* key) {
	@autoreleasepool {
		[(NSData*)o insertValue:value atIndex:index inPropertyWithKey:key];
	}
}
void* _Nonnull
NSData_inst_ClassDescription(void* o) {
	NSClassDescription* _Nonnull ret;
	@autoreleasepool {
		ret = [(NSData*)o classDescription];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
BOOL
NSData_inst_DoesContain(void* o, void* object) {
	BOOL ret;
	@autoreleasepool {
		ret = [(NSData*)o doesContain:object];
	}
	return ret;

}
void
NSData_inst_GetBytesLength(void* o, void* buffer, NSUInteger length) {
	@autoreleasepool {
		[(NSData*)o getBytes:buffer length:length];
	}
}
void
NSData_inst_GetBytesRange(void* o, void* buffer, NSRange range) {
	@autoreleasepool {
		[(NSData*)o getBytes:buffer range:range];
	}
}
void* _Nonnull
NSData_inst_MutableOrderedSetValueForKey(void* o, void* key) {
	NSMutableOrderedSet* _Nonnull ret;
	@autoreleasepool {
		ret = [(NSData*)o mutableOrderedSetValueForKey:key];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
BOOL
NSData_inst_ScriptingEndsWith(void* o, void* object) {
	BOOL ret;
	@autoreleasepool {
		ret = [(NSData*)o scriptingEndsWith:object];
	}
	return ret;

}
void* _Nonnull
NSData_inst_ClassForCoder(void* o) {
	Class _Nonnull ret;
	@autoreleasepool {
		ret = [(NSData*)o classForCoder];
	}
	return ret;

}
BOOL
NSData_inst_IsProxy(void* o) {
	BOOL ret;
	@autoreleasepool {
		ret = [(NSData*)o isProxy];
	}
	return ret;

}
void
NSData_inst_SetScriptingProperties(void* o, void* scriptingProperties) {
	@autoreleasepool {
		[(NSData*)o setScriptingProperties:scriptingProperties];
	}
}
void*
NSData_inst_Zone(void* o) {
	struct _NSZone* ret;
	@autoreleasepool {
		ret = [(NSData*)o zone];
	}
	return ret;

}
void
NSData_inst_Release(void* o) {
	@autoreleasepool {
		[(NSData*)o release];
	}
}
void* _Nullable
NSData_inst_InitWithContentsOfFile(void* o, void* path) {
	NSData* _Nullable ret;
	@autoreleasepool {
		ret = [(NSData*)o initWithContentsOfFile:path];
	}
	return ret;

}
void* _Nullable
NSData_inst_InitWithContentsOfFileOptions(void* o, void* path, NSDataReadingOptions readOptionsMask, void** errorPtr) {
	NSData* _Nullable ret;
	@autoreleasepool {
		ret = [(NSData*)o initWithContentsOfFile:path options:readOptionsMask error:(NSError* _Nullable* _Nullable)errorPtr];
		for(int i=0;i<1;i++) {
			if(errorPtr[i] == 0) { break; }
			[(id)errorPtr[i] retain];
		}
	
	}
	return ret;

}
void* _Nullable
NSData_inst_InitWithContentsOfFileOptionsError(void* o, void* path, NSDataReadingOptions readOptionsMask, void** errorPtr) {
	NSData* _Nullable ret;
	@autoreleasepool {
		ret = [(NSData*)o initWithContentsOfFile:path options:readOptionsMask error:(NSError* _Nullable* _Nullable)errorPtr];
		for(int i=0;i<1;i++) {
			if(errorPtr[i] == 0) { break; }
			[(id)errorPtr[i] retain];
		}
	
	}
	return ret;

}
void* _Nonnull
NSData_inst_AttributeKeys(void* o) {
	NSArray* _Nonnull ret;
	@autoreleasepool {
		ret = [(NSData*)o attributeKeys];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
BOOL
NSData_inst_RespondsToSelector(void* o, void* aSelector) {
	BOOL ret;
	@autoreleasepool {
		ret = [(NSData*)o respondsToSelector:aSelector];
	}
	return ret;

}
void* _Nonnull
NSData_inst_MutableSetValueForKey(void* o, void* key) {
	NSMutableSet* _Nonnull ret;
	@autoreleasepool {
		ret = [(NSData*)o mutableSetValueForKey:key];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
void* _Nullable
NSData_inst_DecompressedDataUsingAlgorithmError(void* o, NSDataCompressionAlgorithm algorithm, void** error) {
	NSData* _Nullable ret;
	@autoreleasepool {
		ret = [(NSData*)o decompressedDataUsingAlgorithm:algorithm error:(NSError* _Nullable* _Nullable)error];
		if (ret != nil && ret != o) { [ret retain]; }
		for(int i=0;i<1;i++) {
			if(error[i] == 0) { break; }
			[(id)error[i] retain];
		}
	
	}
	return ret;

}
void* _Nullable
NSData_inst_InitWithBase64EncodedStringOptions(void* o, void* base64String, NSDataBase64DecodingOptions options) {
	NSData* _Nullable ret;
	@autoreleasepool {
		ret = [(NSData*)o initWithBase64EncodedString:base64String options:options];
	}
	return ret;

}
void* _Nonnull
NSData_inst_MutableSetValueForKeyPath(void* o, void* keyPath) {
	NSMutableSet* _Nonnull ret;
	@autoreleasepool {
		ret = [(NSData*)o mutableSetValueForKeyPath:keyPath];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
void
NSData_inst_DoesNotRecognizeSelector(void* o, void* aSelector) {
	@autoreleasepool {
		[(NSData*)o doesNotRecognizeSelector:aSelector];
	}
}
void* _Nonnull
NSData_inst_ClassName(void* o) {
	NSString* _Nonnull ret;
	@autoreleasepool {
		ret = [(NSData*)o className];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
void* _Nullable
NSData_inst_ReplacementObjectForKeyedArchiver(void* o, void* archiver) {
	NSObject* _Nullable ret;
	@autoreleasepool {
		ret = [(NSData*)o replacementObjectForKeyedArchiver:archiver];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
void* _Nullable
NSData_inst_ValueWithUniqueIDInPropertyWithKey(void* o, void* uniqueID, void* key) {
	NSObject* _Nullable ret;
	@autoreleasepool {
		ret = [(NSData*)o valueWithUniqueID:uniqueID inPropertyWithKey:key];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
void* _Nullable
NSData_inst_CompressedDataUsingAlgorithmError(void* o, NSDataCompressionAlgorithm algorithm, void** error) {
	NSData* _Nullable ret;
	@autoreleasepool {
		ret = [(NSData*)o compressedDataUsingAlgorithm:algorithm error:(NSError* _Nullable* _Nullable)error];
		if (ret != nil && ret != o) { [ret retain]; }
		for(int i=0;i<1;i++) {
			if(error[i] == 0) { break; }
			[(id)error[i] retain];
		}
	
	}
	return ret;

}
void
NSData_inst_AddObserverForKeyPath(void* o, void* observer, void* keyPath, NSKeyValueObservingOptions options, void* context) {
	@autoreleasepool {
		[(NSData*)o addObserver:observer forKeyPath:keyPath options:options context:context];
	}
}
void
NSData_inst_AddObserverForKeyPathOptions(void* o, void* observer, void* keyPath, NSKeyValueObservingOptions options, void* context) {
	@autoreleasepool {
		[(NSData*)o addObserver:observer forKeyPath:keyPath options:options context:context];
	}
}
void* _Nonnull
NSData_inst_MutableOrderedSetValueForKeyPath(void* o, void* keyPath) {
	NSMutableOrderedSet* _Nonnull ret;
	@autoreleasepool {
		ret = [(NSData*)o mutableOrderedSetValueForKeyPath:keyPath];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
void
NSData_inst_ForwardInvocation(void* o, void* anInvocation) {
	@autoreleasepool {
		[(NSData*)o forwardInvocation:anInvocation];
	}
}
BOOL
NSData_inst_IsLessThan(void* o, void* object) {
	BOOL ret;
	@autoreleasepool {
		ret = [(NSData*)o isLessThan:object];
	}
	return ret;

}
BOOL
NSData_inst_IsGreaterThanOrEqualTo(void* o, void* object) {
	BOOL ret;
	@autoreleasepool {
		ret = [(NSData*)o isGreaterThanOrEqualTo:object];
	}
	return ret;

}
BOOL
NSData_inst_IsNotEqualTo(void* o, void* object) {
	BOOL ret;
	@autoreleasepool {
		ret = [(NSData*)o isNotEqualTo:object];
	}
	return ret;

}
BOOL
NSData_inst_ScriptingContains(void* o, void* object) {
	BOOL ret;
	@autoreleasepool {
		ret = [(NSData*)o scriptingContains:object];
	}
	return ret;

}
void*
NSData_inst_DebugDescription(void* o) {
	NSString* ret;
	@autoreleasepool {
		ret = [(NSData*)o debugDescription];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
void* _Nullable
NSData_inst_ValueForKeyPath(void* o, void* keyPath) {
	NSObject* _Nullable ret;
	@autoreleasepool {
		ret = [(NSData*)o valueForKeyPath:keyPath];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
void*
NSData_inst_Self(void* o) {
	NSData* ret;
	@autoreleasepool {
		ret = [(NSData*)o self];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
void
NSData_inst_RemoveValueAtIndexFromPropertyWithKey(void* o, NSUInteger index, void* key) {
	@autoreleasepool {
		[(NSData*)o removeValueAtIndex:index fromPropertyWithKey:key];
	}
}
void
NSData_inst_Dealloc(void* o) {
	@autoreleasepool {
		[(NSData*)o dealloc];
	}
}
void
NSData_inst_SetObservationInfo(void* o, void* observationInfo) {
	@autoreleasepool {
		[(NSData*)o setObservationInfo:observationInfo];
	}
}
BOOL
NSData_inst_IsEqualTo(void* o, void* object) {
	BOOL ret;
	@autoreleasepool {
		ret = [(NSData*)o isEqualTo:object];
	}
	return ret;

}
void
NSData_inst_PerformSelectorInBackgroundWithObject(void* o, void* aSelector, void* arg) {
	@autoreleasepool {
		[(NSData*)o performSelectorInBackground:aSelector withObject:arg];
	}
}
const void*
NSData_inst_Bytes(void* o) {
	const void* ret;
	@autoreleasepool {
		ret = [(NSData*)o bytes];
	}
	return ret;

}
void*
NSData_inst_Retain(void* o) {
	NSData* ret;
	@autoreleasepool {
		ret = [(NSData*)o retain];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
void* _Nullable
NSData_inst_NewScriptingObjectOfClassForValueForKey(void* o, void* objectClass, void* key, void* contentsValue, void* properties) {
	NSObject* _Nullable ret;
	@autoreleasepool {
		ret = [(NSData*)o newScriptingObjectOfClass:objectClass forValueForKey:key withContentsValue:contentsValue properties:properties];
	}
	return ret;

}
void* _Nullable
NSData_inst_NewScriptingObjectOfClassForValueForKeyWithContentsValue(void* o, void* objectClass, void* key, void* contentsValue, void* properties) {
	NSObject* _Nullable ret;
	@autoreleasepool {
		ret = [(NSData*)o newScriptingObjectOfClass:objectClass forValueForKey:key withContentsValue:contentsValue properties:properties];
	}
	return ret;

}
FourCharCode
NSData_inst_ClassCode(void* o) {
	FourCharCode ret;
	@autoreleasepool {
		ret = [(NSData*)o classCode];
	}
	return ret;

}
BOOL
NSData_inst_IsEqual(void* o, void* object) {
	BOOL ret;
	@autoreleasepool {
		ret = [(NSData*)o isEqual:object];
	}
	return ret;

}
void* _Nullable
NSData_inst_ValueForUndefinedKey(void* o, void* key) {
	NSObject* _Nullable ret;
	@autoreleasepool {
		ret = [(NSData*)o valueForUndefinedKey:key];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
void* _Nullable
NSData_inst_ClassForKeyedArchiver(void* o) {
	Class _Nullable ret;
	@autoreleasepool {
		ret = [(NSData*)o classForKeyedArchiver];
	}
	return ret;

}
void* _Nullable
NSData_inst_CopyScriptingValueForKey(void* o, void* value, void* key, void* properties) {
	NSObject* _Nullable ret;
	@autoreleasepool {
		ret = [(NSData*)o copyScriptingValue:value forKey:key withProperties:properties];
	}
	return ret;

}
void* _Nullable
NSData_inst_CopyScriptingValueForKeyWithProperties(void* o, void* value, void* key, void* properties) {
	NSObject* _Nullable ret;
	@autoreleasepool {
		ret = [(NSData*)o copyScriptingValue:value forKey:key withProperties:properties];
	}
	return ret;

}
void* _Nullable
NSData_inst_ValueAtIndexInPropertyWithKey(void* o, NSUInteger index, void* key) {
	NSObject* _Nullable ret;
	@autoreleasepool {
		ret = [(NSData*)o valueAtIndex:index inPropertyWithKey:key];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
void
NSData_inst_DidChangeValuesAtIndexes(void* o, NSKeyValueChange changeKind, void* indexes, void* key) {
	@autoreleasepool {
		[(NSData*)o didChange:changeKind valuesAtIndexes:indexes forKey:key];
	}
}
void
NSData_inst_DidChangeValuesAtIndexesForKey(void* o, NSKeyValueChange changeKind, void* indexes, void* key) {
	@autoreleasepool {
		[(NSData*)o didChange:changeKind valuesAtIndexes:indexes forKey:key];
	}
}
void
NSData_inst_DidChangeValueForKey(void* o, void* key) {
	@autoreleasepool {
		[(NSData*)o didChangeValueForKey:key];
	}
}
void
NSData_inst_DidChangeValueForKeyWithSetMutation(void* o, void* key, NSKeyValueSetMutationKind mutationKind, void* objects) {
	@autoreleasepool {
		[(NSData*)o didChangeValueForKey:key withSetMutation:mutationKind usingObjects:objects];
	}
}
void
NSData_inst_DidChangeValueForKeyWithSetMutationUsingObjects(void* o, void* key, NSKeyValueSetMutationKind mutationKind, void* objects) {
	@autoreleasepool {
		[(NSData*)o didChangeValueForKey:key withSetMutation:mutationKind usingObjects:objects];
	}
}
void* _Nullable
NSData_inst_ReplacementObjectForCoder(void* o, void* coder) {
	NSObject* _Nullable ret;
	@autoreleasepool {
		ret = [(NSData*)o replacementObjectForCoder:coder];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
BOOL
NSData_inst_AttemptRecoveryFromErrorOptionIndex(void* o, void* error, NSUInteger recoveryOptionIndex) {
	BOOL ret;
	@autoreleasepool {
		ret = [(NSData*)o attemptRecoveryFromError:error optionIndex:recoveryOptionIndex];
	}
	return ret;

}
void
NSData_inst_AttemptRecoveryFromErrorOptionIndexDelegate(void* o, void* error, NSUInteger recoveryOptionIndex, void* delegate, void* didRecoverSelector, void* contextInfo) {
	@autoreleasepool {
		[(NSData*)o attemptRecoveryFromError:error optionIndex:recoveryOptionIndex delegate:delegate didRecoverSelector:didRecoverSelector contextInfo:contextInfo];
	}
}
void
NSData_inst_AttemptRecoveryFromErrorOptionIndexDelegateDidRecoverSelector(void* o, void* error, NSUInteger recoveryOptionIndex, void* delegate, void* didRecoverSelector, void* contextInfo) {
	@autoreleasepool {
		[(NSData*)o attemptRecoveryFromError:error optionIndex:recoveryOptionIndex delegate:delegate didRecoverSelector:didRecoverSelector contextInfo:contextInfo];
	}
}
void* _Nonnull
NSData_inst_ToOneRelationshipKeys(void* o) {
	NSArray* _Nonnull ret;
	@autoreleasepool {
		ret = [(NSData*)o toOneRelationshipKeys];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
void* _Nonnull
NSData_inst_CopyWithZone(void* o, void* zone) {
	NSObject* _Nonnull ret;
	@autoreleasepool {
		ret = [(NSData*)o copyWithZone:zone];
	}
	return ret;

}
BOOL
NSData_inst_IsEqualToData(void* o, void* other) {
	BOOL ret;
	@autoreleasepool {
		ret = [(NSData*)o isEqualToData:other];
	}
	return ret;

}
void* _Nullable
NSData_inst_ValueForKey(void* o, void* key) {
	NSObject* _Nullable ret;
	@autoreleasepool {
		ret = [(NSData*)o valueForKey:key];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
void*
NSData_inst_Copy(void* o) {
	NSObject* ret;
	@autoreleasepool {
		ret = [(NSData*)o copy];
	}
	return ret;

}
void* _Nonnull
NSData_inst_ToManyRelationshipKeys(void* o) {
	NSArray* _Nonnull ret;
	@autoreleasepool {
		ret = [(NSData*)o toManyRelationshipKeys];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
BOOL
NSData_inst_IsLike(void* o, void* object) {
	BOOL ret;
	@autoreleasepool {
		ret = [(NSData*)o isLike:object];
	}
	return ret;

}
void* _Nonnull
NSData_inst_AutoContentAccessingProxy(void* o) {
	NSObject* _Nonnull ret;
	@autoreleasepool {
		ret = [(NSData*)o autoContentAccessingProxy];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
void
NSData_inst_SetValueForKey(void* o, void* value, void* key) {
	@autoreleasepool {
		[(NSData*)o setValue:value forKey:key];
	}
}
void
NSData_inst_SetValueForKeyPath(void* o, void* value, void* keyPath) {
	@autoreleasepool {
		[(NSData*)o setValue:value forKeyPath:keyPath];
	}
}
void
NSData_inst_SetValueForUndefinedKey(void* o, void* value, void* key) {
	@autoreleasepool {
		[(NSData*)o setValue:value forUndefinedKey:key];
	}
}
void
NSData_inst_ReplaceValueAtIndexInPropertyWithKey(void* o, NSUInteger index, void* key, void* value) {
	@autoreleasepool {
		[(NSData*)o replaceValueAtIndex:index inPropertyWithKey:key withValue:value];
	}
}
void
NSData_inst_ReplaceValueAtIndexInPropertyWithKeyWithValue(void* o, NSUInteger index, void* key, void* value) {
	@autoreleasepool {
		[(NSData*)o replaceValueAtIndex:index inPropertyWithKey:key withValue:value];
	}
}
void
NSData_inst_WillChangeValueForKey(void* o, void* key) {
	@autoreleasepool {
		[(NSData*)o willChangeValueForKey:key];
	}
}
void
NSData_inst_WillChangeValueForKeyWithSetMutation(void* o, void* key, NSKeyValueSetMutationKind mutationKind, void* objects) {
	@autoreleasepool {
		[(NSData*)o willChangeValueForKey:key withSetMutation:mutationKind usingObjects:objects];
	}
}
void
NSData_inst_WillChangeValueForKeyWithSetMutationUsingObjects(void* o, void* key, NSKeyValueSetMutationKind mutationKind, void* objects) {
	@autoreleasepool {
		[(NSData*)o willChangeValueForKey:key withSetMutation:mutationKind usingObjects:objects];
	}
}
void* _Nullable
NSData_inst_ScriptingProperties(void* o) {
	NSDictionary* _Nullable ret;
	@autoreleasepool {
		ret = [(NSData*)o scriptingProperties];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
BOOL
NSData_inst_WriteToURLAtomically(void* o, void* url, BOOL atomically) {
	BOOL ret;
	@autoreleasepool {
		ret = [(NSData*)o writeToURL:url atomically:atomically];
	}
	return ret;

}
BOOL
NSData_inst_WriteToURLOptions(void* o, void* url, NSDataWritingOptions writeOptionsMask, void** errorPtr) {
	BOOL ret;
	@autoreleasepool {
		ret = [(NSData*)o writeToURL:url options:writeOptionsMask error:(NSError* _Nullable* _Nullable)errorPtr];
		for(int i=0;i<1;i++) {
			if(errorPtr[i] == 0) { break; }
			[(id)errorPtr[i] retain];
		}
	
	}
	return ret;

}
BOOL
NSData_inst_WriteToURLOptionsError(void* o, void* url, NSDataWritingOptions writeOptionsMask, void** errorPtr) {
	BOOL ret;
	@autoreleasepool {
		ret = [(NSData*)o writeToURL:url options:writeOptionsMask error:(NSError* _Nullable* _Nullable)errorPtr];
		for(int i=0;i<1;i++) {
			if(errorPtr[i] == 0) { break; }
			[(id)errorPtr[i] retain];
		}
	
	}
	return ret;

}
void*
NSData_inst_ObservationInfo(void* o) {
	void* ret;
	@autoreleasepool {
		ret = [(NSData*)o observationInfo];
	}
	return ret;

}
void*
NSData_inst_Autorelease(void* o) {
	NSData* ret;
	@autoreleasepool {
		ret = [(NSData*)o autorelease];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
BOOL
NSData_inst_IsLessThanOrEqualTo(void* o, void* object) {
	BOOL ret;
	@autoreleasepool {
		ret = [(NSData*)o isLessThanOrEqualTo:object];
	}
	return ret;

}
void
NSData_inst_PerformSelectorOnMainThreadWithObject(void* o, void* aSelector, void* arg, BOOL wait) {
	@autoreleasepool {
		[(NSData*)o performSelectorOnMainThread:aSelector withObject:arg waitUntilDone:wait];
	}
}
void
NSData_inst_PerformSelectorOnMainThreadWithObjectWaitUntilDone(void* o, void* aSelector, void* arg, BOOL wait) {
	@autoreleasepool {
		[(NSData*)o performSelectorOnMainThread:aSelector withObject:arg waitUntilDone:wait];
	}
}
void
NSData_inst_PerformSelectorOnMainThreadWithObjectWaitUntilDoneModes(void* o, void* aSelector, void* arg, BOOL wait, void* array) {
	@autoreleasepool {
		[(NSData*)o performSelectorOnMainThread:aSelector withObject:arg waitUntilDone:wait modes:array];
	}
}
void* _Nonnull
NSData_inst_Base64EncodedStringWithOptions(void* o, NSDataBase64EncodingOptions options) {
	NSString* _Nonnull ret;
	@autoreleasepool {
		ret = [(NSData*)o base64EncodedStringWithOptions:options];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
BOOL
NSData_inst_ScriptingIsLessThanOrEqualTo(void* o, void* object) {
	BOOL ret;
	@autoreleasepool {
		ret = [(NSData*)o scriptingIsLessThanOrEqualTo:object];
	}
	return ret;

}
void*
NSData_inst_Class(void* o) {
	Class ret;
	@autoreleasepool {
		ret = [(NSData*)o class];
	}
	return ret;

}
void
NSData_inst_RemoveObserverForKeyPath(void* o, void* observer, void* keyPath) {
	@autoreleasepool {
		[(NSData*)o removeObserver:observer forKeyPath:keyPath];
	}
}
void
NSData_inst_RemoveObserverForKeyPathContext(void* o, void* observer, void* keyPath, void* context) {
	@autoreleasepool {
		[(NSData*)o removeObserver:observer forKeyPath:keyPath context:context];
	}
}
NSRange
NSData_inst_RangeOfDataOptions(void* o, void* dataToFind, NSDataSearchOptions mask, NSRange searchRange) {
	NSRange ret;
	@autoreleasepool {
		ret = [(NSData*)o rangeOfData:dataToFind options:mask range:searchRange];
	}
	return ret;

}
NSRange
NSData_inst_RangeOfDataOptionsRange(void* o, void* dataToFind, NSDataSearchOptions mask, NSRange searchRange) {
	NSRange ret;
	@autoreleasepool {
		ret = [(NSData*)o rangeOfData:dataToFind options:mask range:searchRange];
	}
	return ret;

}
NSUInteger
NSData_inst_Length(void* o) {
	NSUInteger ret;
	@autoreleasepool {
		ret = [(NSData*)o length];
	}
	return ret;

}
void* _Nullable
NSData_inst_ClassForArchiver(void* o) {
	Class _Nullable ret;
	@autoreleasepool {
		ret = [(NSData*)o classForArchiver];
	}
	return ret;

}
BOOL
CBCentral_InstancesRespondToSelector(void* aSelector) {
	BOOL ret;
	@autoreleasepool {
		ret = [CBCentral instancesRespondToSelector:aSelector];
	}
	return ret;

}
BOOL
CBCentral_ResolveClassMethod(void* sel) {
	BOOL ret;
	@autoreleasepool {
		ret = [CBCentral resolveClassMethod:sel];
	}
	return ret;

}
void*
CBCentral_CopyWithZone(void* zone) {
	NSObject* ret;
	@autoreleasepool {
		ret = [CBCentral copyWithZone:zone];
	}
	return ret;

}
void*
CBCentral_MutableCopyWithZone(void* zone) {
	NSObject* ret;
	@autoreleasepool {
		ret = [CBCentral mutableCopyWithZone:zone];
	}
	return ret;

}
void* _Nonnull
CBCentral_ClassForKeyedUnarchiver() {
	Class _Nonnull ret;
	@autoreleasepool {
		ret = [CBCentral classForKeyedUnarchiver];
	}
	return ret;

}
BOOL
CBCentral_AutomaticallyNotifiesObserversForKey(void* key) {
	BOOL ret;
	@autoreleasepool {
		ret = [CBCentral automaticallyNotifiesObserversForKey:key];
	}
	return ret;

}
NSUInteger
CBCentral_Hash() {
	NSUInteger ret;
	@autoreleasepool {
		ret = [CBCentral hash];
	}
	return ret;

}
void
CBCentral_CancelPreviousPerformRequestsWithTarget(void* aTarget) {
	@autoreleasepool {
		[CBCentral cancelPreviousPerformRequestsWithTarget:aTarget];
	}
}
void
CBCentral_CancelPreviousPerformRequestsWithTargetSelector(void* aTarget, void* aSelector, void* anArgument) {
	@autoreleasepool {
		[CBCentral cancelPreviousPerformRequestsWithTarget:aTarget selector:aSelector object:anArgument];
	}
}
void
CBCentral_CancelPreviousPerformRequestsWithTargetSelectorObject(void* aTarget, void* aSelector, void* anArgument) {
	@autoreleasepool {
		[CBCentral cancelPreviousPerformRequestsWithTarget:aTarget selector:aSelector object:anArgument];
	}
}
BOOL
CBCentral_ConformsToProtocol(void* protocol) {
	BOOL ret;
	@autoreleasepool {
		ret = [CBCentral conformsToProtocol:protocol];
	}
	return ret;

}
void*
CBCentral_DebugDescription() {
	NSString* ret;
	@autoreleasepool {
		ret = [CBCentral debugDescription];
	}
	return ret;

}
NSInteger
CBCentral_Version() {
	NSInteger ret;
	@autoreleasepool {
		ret = [CBCentral version];
	}
	return ret;

}
void*
CBCentral_Description() {
	NSString* ret;
	@autoreleasepool {
		ret = [CBCentral description];
	}
	return ret;

}
void* _Nonnull
CBCentral_ClassFallbacksForKeyedArchiver() {
	NSArray* _Nonnull ret;
	@autoreleasepool {
		ret = [CBCentral classFallbacksForKeyedArchiver];
	}
	return ret;

}
void*
CBCentral_AllocWithZone(void* zone) {
	return [CBCentral allocWithZone:zone];
}
void* _Nonnull
CBCentral_KeyPathsForValuesAffectingValueForKey(void* key) {
	NSSet* _Nonnull ret;
	@autoreleasepool {
		ret = [CBCentral keyPathsForValuesAffectingValueForKey:key];
	}
	return ret;

}
void*
CBCentral_New() {
	CBCentral* ret;
	@autoreleasepool {
		NSLog(@"CBCentral new");
		//ret = [CBCentral new];
	}
	return ret;

}
BOOL
CBCentral_AccessInstanceVariablesDirectly() {
	BOOL ret;
	@autoreleasepool {
		ret = [CBCentral accessInstanceVariablesDirectly];
	}
	return ret;

}
void
CBCentral_SetVersion(NSInteger aVersion) {
	@autoreleasepool {
		[CBCentral setVersion:aVersion];
	}
}
void*
CBCentral_InstanceMethodSignatureForSelector(void* aSelector) {
	NSMethodSignature* ret;
	@autoreleasepool {
		ret = [CBCentral instanceMethodSignatureForSelector:aSelector];
	}
	return ret;

}
void*
CBCentral_Class() {
	Class ret;
	@autoreleasepool {
		ret = [CBCentral class];
	}
	return ret;

}
void
CBCentral_Load() {
	@autoreleasepool {
		[CBCentral load];
	}
}
BOOL
CBCentral_ResolveInstanceMethod(void* sel) {
	BOOL ret;
	@autoreleasepool {
		ret = [CBCentral resolveInstanceMethod:sel];
	}
	return ret;

}
BOOL
CBCentral_IsSubclassOfClass(void* aClass) {
	BOOL ret;
	@autoreleasepool {
		ret = [CBCentral isSubclassOfClass:aClass];
	}
	return ret;

}
void*
CBCentral_Superclass() {
	Class ret;
	@autoreleasepool {
		ret = [CBCentral superclass];
	}
	return ret;

}
void*
CBCentral_Alloc() {
	return [CBCentral alloc];
}
void
CBCentral_inst_WillChangeValueForKey(void* o, void* key) {
	@autoreleasepool {
		[(CBCentral*)o willChangeValueForKey:key];
	}
}
void
CBCentral_inst_WillChangeValueForKeyWithSetMutation(void* o, void* key, NSKeyValueSetMutationKind mutationKind, void* objects) {
	@autoreleasepool {
		[(CBCentral*)o willChangeValueForKey:key withSetMutation:mutationKind usingObjects:objects];
	}
}
void
CBCentral_inst_WillChangeValueForKeyWithSetMutationUsingObjects(void* o, void* key, NSKeyValueSetMutationKind mutationKind, void* objects) {
	@autoreleasepool {
		[(CBCentral*)o willChangeValueForKey:key withSetMutation:mutationKind usingObjects:objects];
	}
}
void* _Nonnull
CBCentral_inst_AttributeKeys(void* o) {
	NSArray* _Nonnull ret;
	@autoreleasepool {
		ret = [(CBCentral*)o attributeKeys];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
BOOL
CBCentral_inst_RespondsToSelector(void* o, void* aSelector) {
	BOOL ret;
	@autoreleasepool {
		ret = [(CBCentral*)o respondsToSelector:aSelector];
	}
	return ret;

}
NSUInteger
CBCentral_inst_RetainCount(void* o) {
	NSUInteger ret;
	@autoreleasepool {
		ret = [(CBCentral*)o retainCount];
	}
	return ret;

}
void* _Nullable
CBCentral_inst_ScriptingProperties(void* o) {
	NSDictionary* _Nullable ret;
	@autoreleasepool {
		ret = [(CBCentral*)o scriptingProperties];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
void* _Nonnull
CBCentral_inst_ClassName(void* o) {
	NSString* _Nonnull ret;
	@autoreleasepool {
		ret = [(CBCentral*)o className];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
BOOL
CBCentral_inst_IsProxy(void* o) {
	BOOL ret;
	@autoreleasepool {
		ret = [(CBCentral*)o isProxy];
	}
	return ret;

}
void* _Nonnull
CBCentral_inst_MutableSetValueForKeyPath(void* o, void* keyPath) {
	NSMutableSet* _Nonnull ret;
	@autoreleasepool {
		ret = [(CBCentral*)o mutableSetValueForKeyPath:keyPath];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
BOOL
CBCentral_inst_IsNotEqualTo(void* o, void* object) {
	BOOL ret;
	@autoreleasepool {
		ret = [(CBCentral*)o isNotEqualTo:object];
	}
	return ret;

}
void* _Nonnull
CBCentral_inst_ClassForCoder(void* o) {
	Class _Nonnull ret;
	@autoreleasepool {
		ret = [(CBCentral*)o classForCoder];
	}
	return ret;

}
void*
CBCentral_inst_ForwardingTargetForSelector(void* o, void* aSelector) {
	NSObject* ret;
	@autoreleasepool {
		ret = [(CBCentral*)o forwardingTargetForSelector:aSelector];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
BOOL
CBCentral_inst_ScriptingEndsWith(void* o, void* object) {
	BOOL ret;
	@autoreleasepool {
		ret = [(CBCentral*)o scriptingEndsWith:object];
	}
	return ret;

}
void* _Nullable
CBCentral_inst_ValueForKeyPath(void* o, void* keyPath) {
	NSObject* _Nullable ret;
	@autoreleasepool {
		ret = [(CBCentral*)o valueForKeyPath:keyPath];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
BOOL
CBCentral_inst_AttemptRecoveryFromErrorOptionIndex(void* o, void* error, NSUInteger recoveryOptionIndex) {
	BOOL ret;
	@autoreleasepool {
		ret = [(CBCentral*)o attemptRecoveryFromError:error optionIndex:recoveryOptionIndex];
	}
	return ret;

}
void
CBCentral_inst_AttemptRecoveryFromErrorOptionIndexDelegate(void* o, void* error, NSUInteger recoveryOptionIndex, void* delegate, void* didRecoverSelector, void* contextInfo) {
	@autoreleasepool {
		[(CBCentral*)o attemptRecoveryFromError:error optionIndex:recoveryOptionIndex delegate:delegate didRecoverSelector:didRecoverSelector contextInfo:contextInfo];
	}
}
void
CBCentral_inst_AttemptRecoveryFromErrorOptionIndexDelegateDidRecoverSelector(void* o, void* error, NSUInteger recoveryOptionIndex, void* delegate, void* didRecoverSelector, void* contextInfo) {
	@autoreleasepool {
		[(CBCentral*)o attemptRecoveryFromError:error optionIndex:recoveryOptionIndex delegate:delegate didRecoverSelector:didRecoverSelector contextInfo:contextInfo];
	}
}
void* _Nonnull
CBCentral_inst_ToOneRelationshipKeys(void* o) {
	NSArray* _Nonnull ret;
	@autoreleasepool {
		ret = [(CBCentral*)o toOneRelationshipKeys];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
void*
CBCentral_inst_PerformSelector(void* o, void* aSelector) {
	NSObject* ret;
	@autoreleasepool {
		ret = [(CBCentral*)o performSelector:aSelector];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
void*
CBCentral_inst_PerformSelectorWithObject(void* o, void* aSelector, void* object) {
	NSObject* ret;
	@autoreleasepool {
		ret = [(CBCentral*)o performSelector:aSelector withObject:object];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
void*
CBCentral_inst_PerformSelectorWithObjectWithObject(void* o, void* aSelector, void* object1, void* object2) {
	NSObject* ret;
	@autoreleasepool {
		ret = [(CBCentral*)o performSelector:aSelector withObject:object1 withObject:object2];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
void
CBCentral_inst_PerformSelectorWithObjectAfterDelay(void* o, void* aSelector, void* anArgument, NSTimeInterval delay) {
	@autoreleasepool {
		[(CBCentral*)o performSelector:aSelector withObject:anArgument afterDelay:delay];
	}
}
void
CBCentral_inst_PerformSelectorOnThread(void* o, void* aSelector, void* thr, void* arg, BOOL wait) {
	@autoreleasepool {
		[(CBCentral*)o performSelector:aSelector onThread:thr withObject:arg waitUntilDone:wait];
	}
}
void
CBCentral_inst_PerformSelectorWithObjectAfterDelayInModes(void* o, void* aSelector, void* anArgument, NSTimeInterval delay, void* modes) {
	@autoreleasepool {
		[(CBCentral*)o performSelector:aSelector withObject:anArgument afterDelay:delay inModes:modes];
	}
}
void
CBCentral_inst_PerformSelectorOnThreadWithObject(void* o, void* aSelector, void* thr, void* arg, BOOL wait) {
	@autoreleasepool {
		[(CBCentral*)o performSelector:aSelector onThread:thr withObject:arg waitUntilDone:wait];
	}
}
void
CBCentral_inst_PerformSelectorOnThreadWithObjectWaitUntilDone(void* o, void* aSelector, void* thr, void* arg, BOOL wait, void* array) {
	@autoreleasepool {
		[(CBCentral*)o performSelector:aSelector onThread:thr withObject:arg waitUntilDone:wait modes:array];
	}
}
void
CBCentral_inst_PerformSelectorOnThreadWithObjectWaitUntilDoneModes(void* o, void* aSelector, void* thr, void* arg, BOOL wait, void* array) {
	@autoreleasepool {
		[(CBCentral*)o performSelector:aSelector onThread:thr withObject:arg waitUntilDone:wait modes:array];
	}
}
BOOL
CBCentral_inst_IsGreaterThan(void* o, void* object) {
	BOOL ret;
	@autoreleasepool {
		ret = [(CBCentral*)o isGreaterThan:object];
	}
	return ret;

}
void* _Nullable
CBCentral_inst_IndicesOfObjectsByEvaluatingObjectSpecifier(void* o, void* specifier) {
	NSArray* _Nullable ret;
	@autoreleasepool {
		ret = [(CBCentral*)o indicesOfObjectsByEvaluatingObjectSpecifier:specifier];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
void
CBCentral_inst_Dealloc(void* o) {
	@autoreleasepool {
		[(CBCentral*)o dealloc];
	}
}
void
CBCentral_inst_WillChangeValuesAtIndexes(void* o, NSKeyValueChange changeKind, void* indexes, void* key) {
	@autoreleasepool {
		[(CBCentral*)o willChange:changeKind valuesAtIndexes:indexes forKey:key];
	}
}
void
CBCentral_inst_WillChangeValuesAtIndexesForKey(void* o, NSKeyValueChange changeKind, void* indexes, void* key) {
	@autoreleasepool {
		[(CBCentral*)o willChange:changeKind valuesAtIndexes:indexes forKey:key];
	}
}
void* _Nonnull
CBCentral_inst_ToManyRelationshipKeys(void* o) {
	NSArray* _Nonnull ret;
	@autoreleasepool {
		ret = [(CBCentral*)o toManyRelationshipKeys];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
void*
CBCentral_inst_Autorelease(void* o) {
	CBCentral* ret;
	@autoreleasepool {
		ret = [(CBCentral*)o autorelease];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
void*
CBCentral_inst_ObservationInfo(void* o) {
	void* ret;
	@autoreleasepool {
		ret = [(CBCentral*)o observationInfo];
	}
	return ret;

}
BOOL
CBCentral_inst_IsLessThan(void* o, void* object) {
	BOOL ret;
	@autoreleasepool {
		ret = [(CBCentral*)o isLessThan:object];
	}
	return ret;

}
void*
CBCentral_inst_Retain(void* o) {
	CBCentral* ret;
	@autoreleasepool {
		ret = [(CBCentral*)o retain];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
void*
CBCentral_inst_Copy(void* o) {
	NSObject* ret;
	@autoreleasepool {
		ret = [(CBCentral*)o copy];
	}
	return ret;

}
void*
CBCentral_inst_Self(void* o) {
	CBCentral* ret;
	@autoreleasepool {
		ret = [(CBCentral*)o self];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
void*
CBCentral_inst_MethodSignatureForSelector(void* o, void* aSelector) {
	NSMethodSignature* ret;
	@autoreleasepool {
		ret = [(CBCentral*)o methodSignatureForSelector:aSelector];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
void
CBCentral_inst_RemoveValueAtIndexFromPropertyWithKey(void* o, NSUInteger index, void* key) {
	@autoreleasepool {
		[(CBCentral*)o removeValueAtIndex:index fromPropertyWithKey:key];
	}
}
void* _Nonnull
CBCentral_inst_MutableArrayValueForKeyPath(void* o, void* keyPath) {
	NSMutableArray* _Nonnull ret;
	@autoreleasepool {
		ret = [(CBCentral*)o mutableArrayValueForKeyPath:keyPath];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
void*
CBCentral_inst_Class(void* o) {
	Class ret;
	@autoreleasepool {
		ret = [(CBCentral*)o class];
	}
	return ret;

}
void* _Nullable
CBCentral_inst_ClassForArchiver(void* o) {
	Class _Nullable ret;
	@autoreleasepool {
		ret = [(CBCentral*)o classForArchiver];
	}
	return ret;

}
void* _Nonnull
CBCentral_inst_MutableOrderedSetValueForKeyPath(void* o, void* keyPath) {
	NSMutableOrderedSet* _Nonnull ret;
	@autoreleasepool {
		ret = [(CBCentral*)o mutableOrderedSetValueForKeyPath:keyPath];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
BOOL
CBCentral_inst_ScriptingIsEqualTo(void* o, void* object) {
	BOOL ret;
	@autoreleasepool {
		ret = [(CBCentral*)o scriptingIsEqualTo:object];
	}
	return ret;

}
void*
CBCentral_inst_Identifier(void* o) {
	NSUUID* ret;
	@autoreleasepool {
		ret = [(CBCentral*)o identifier];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
void* _Nullable
CBCentral_inst_ObjectSpecifier(void* o) {
	NSScriptObjectSpecifier* _Nullable ret;
	@autoreleasepool {
		ret = [(CBCentral*)o objectSpecifier];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
void* _Nullable
CBCentral_inst_ValueAtIndexInPropertyWithKey(void* o, NSUInteger index, void* key) {
	NSObject* _Nullable ret;
	@autoreleasepool {
		ret = [(CBCentral*)o valueAtIndex:index inPropertyWithKey:key];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
BOOL
CBCentral_inst_IsEqualTo(void* o, void* object) {
	BOOL ret;
	@autoreleasepool {
		ret = [(CBCentral*)o isEqualTo:object];
	}
	return ret;

}
void* _Nullable
CBCentral_inst_ValueForUndefinedKey(void* o, void* key) {
	NSObject* _Nullable ret;
	@autoreleasepool {
		ret = [(CBCentral*)o valueForUndefinedKey:key];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
BOOL
CBCentral_inst_ScriptingContains(void* o, void* object) {
	BOOL ret;
	@autoreleasepool {
		ret = [(CBCentral*)o scriptingContains:object];
	}
	return ret;

}
BOOL
CBCentral_inst_IsMemberOfClass(void* o, void* aClass) {
	BOOL ret;
	@autoreleasepool {
		ret = [(CBCentral*)o isMemberOfClass:aClass];
	}
	return ret;

}
void* _Nullable
CBCentral_inst_ValueWithNameInPropertyWithKey(void* o, void* name, void* key) {
	NSObject* _Nullable ret;
	@autoreleasepool {
		ret = [(CBCentral*)o valueWithName:name inPropertyWithKey:key];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
void
CBCentral_inst_ReplaceValueAtIndexInPropertyWithKey(void* o, NSUInteger index, void* key, void* value) {
	@autoreleasepool {
		[(CBCentral*)o replaceValueAtIndex:index inPropertyWithKey:key withValue:value];
	}
}
void
CBCentral_inst_ReplaceValueAtIndexInPropertyWithKeyWithValue(void* o, NSUInteger index, void* key, void* value) {
	@autoreleasepool {
		[(CBCentral*)o replaceValueAtIndex:index inPropertyWithKey:key withValue:value];
	}
}
void* _Nullable
CBCentral_inst_AwakeAfterUsingCoder(void* o, void* coder) {
	NSObject* _Nullable ret;
	@autoreleasepool {
		ret = [(CBCentral*)o awakeAfterUsingCoder:coder];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
BOOL
CBCentral_inst_IsKindOfClass(void* o, void* aClass) {
	BOOL ret;
	@autoreleasepool {
		ret = [(CBCentral*)o isKindOfClass:aClass];
	}
	return ret;

}
void* _Nullable
CBCentral_inst_CopyScriptingValueForKey(void* o, void* value, void* key, void* properties) {
	NSObject* _Nullable ret;
	@autoreleasepool {
		ret = [(CBCentral*)o copyScriptingValue:value forKey:key withProperties:properties];
	}
	return ret;

}
void* _Nullable
CBCentral_inst_CopyScriptingValueForKeyWithProperties(void* o, void* value, void* key, void* properties) {
	NSObject* _Nullable ret;
	@autoreleasepool {
		ret = [(CBCentral*)o copyScriptingValue:value forKey:key withProperties:properties];
	}
	return ret;

}
void*
CBCentral_inst_DebugDescription(void* o) {
	NSString* ret;
	@autoreleasepool {
		ret = [(CBCentral*)o debugDescription];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
void*
CBCentral_inst_Description(void* o) {
	NSString* ret;
	@autoreleasepool {
		ret = [(CBCentral*)o description];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
void
CBCentral_inst_SetValueForKey(void* o, void* value, void* key) {
	@autoreleasepool {
		[(CBCentral*)o setValue:value forKey:key];
	}
}
void
CBCentral_inst_SetValueForKeyPath(void* o, void* value, void* keyPath) {
	@autoreleasepool {
		[(CBCentral*)o setValue:value forKeyPath:keyPath];
	}
}
void
CBCentral_inst_SetValueForUndefinedKey(void* o, void* value, void* key) {
	@autoreleasepool {
		[(CBCentral*)o setValue:value forUndefinedKey:key];
	}
}
void
CBCentral_inst_AddObserverForKeyPath(void* o, void* observer, void* keyPath, NSKeyValueObservingOptions options, void* context) {
	@autoreleasepool {
		[(CBCentral*)o addObserver:observer forKeyPath:keyPath options:options context:context];
	}
}
void
CBCentral_inst_AddObserverForKeyPathOptions(void* o, void* observer, void* keyPath, NSKeyValueObservingOptions options, void* context) {
	@autoreleasepool {
		[(CBCentral*)o addObserver:observer forKeyPath:keyPath options:options context:context];
	}
}
BOOL
CBCentral_inst_IsGreaterThanOrEqualTo(void* o, void* object) {
	BOOL ret;
	@autoreleasepool {
		ret = [(CBCentral*)o isGreaterThanOrEqualTo:object];
	}
	return ret;

}
BOOL
CBCentral_inst_DoesContain(void* o, void* object) {
	BOOL ret;
	@autoreleasepool {
		ret = [(CBCentral*)o doesContain:object];
	}
	return ret;

}
void
CBCentral_inst_ObserveValueForKeyPathOfObject(void* o, void* keyPath, void* object, void* change, void* context) {
	@autoreleasepool {
		[(CBCentral*)o observeValueForKeyPath:keyPath ofObject:object change:change context:context];
	}
}
void
CBCentral_inst_ObserveValueForKeyPathOfObjectChange(void* o, void* keyPath, void* object, void* change, void* context) {
	@autoreleasepool {
		[(CBCentral*)o observeValueForKeyPath:keyPath ofObject:object change:change context:context];
	}
}
void* _Nullable
CBCentral_inst_ValueWithUniqueIDInPropertyWithKey(void* o, void* uniqueID, void* key) {
	NSObject* _Nullable ret;
	@autoreleasepool {
		ret = [(CBCentral*)o valueWithUniqueID:uniqueID inPropertyWithKey:key];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
BOOL
CBCentral_inst_ConformsToProtocol(void* o, void* aProtocol) {
	BOOL ret;
	@autoreleasepool {
		ret = [(CBCentral*)o conformsToProtocol:aProtocol];
	}
	return ret;

}
BOOL
CBCentral_inst_ScriptingIsLessThanOrEqualTo(void* o, void* object) {
	BOOL ret;
	@autoreleasepool {
		ret = [(CBCentral*)o scriptingIsLessThanOrEqualTo:object];
	}
	return ret;

}
void
CBCentral_inst_SetScriptingProperties(void* o, void* scriptingProperties) {
	@autoreleasepool {
		[(CBCentral*)o setScriptingProperties:scriptingProperties];
	}
}
void
CBCentral_inst_SetNilValueForKey(void* o, void* key) {
	@autoreleasepool {
		[(CBCentral*)o setNilValueForKey:key];
	}
}
void* _Nullable
CBCentral_inst_ScriptingValueForSpecifier(void* o, void* objectSpecifier) {
	NSObject* _Nullable ret;
	@autoreleasepool {
		ret = [(CBCentral*)o scriptingValueForSpecifier:objectSpecifier];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
BOOL
CBCentral_inst_ValidateValueForKey(void* o, void** ioValue, void* inKey, void** outError) {
	BOOL ret;
	@autoreleasepool {
		ret = [(CBCentral*)o validateValue:(id _Nullable* _Nonnull)ioValue forKey:inKey error:(NSError* _Nullable* _Nullable)outError];
		for(int i=0;i<1;i++) {
			if(ioValue[i] == 0) { break; }
			[(id)ioValue[i] retain];
		}
	
	
		for(int i=0;i<1;i++) {
			if(outError[i] == 0) { break; }
			[(id)outError[i] retain];
		}
	
	}
	return ret;

}
BOOL
CBCentral_inst_ValidateValueForKeyPath(void* o, void** ioValue, void* inKeyPath, void** outError) {
	BOOL ret;
	@autoreleasepool {
		ret = [(CBCentral*)o validateValue:(id _Nullable* _Nonnull)ioValue forKeyPath:inKeyPath error:(NSError* _Nullable* _Nullable)outError];
		for(int i=0;i<1;i++) {
			if(ioValue[i] == 0) { break; }
			[(id)ioValue[i] retain];
		}
	
	
		for(int i=0;i<1;i++) {
			if(outError[i] == 0) { break; }
			[(id)outError[i] retain];
		}
	
	}
	return ret;

}
BOOL
CBCentral_inst_ValidateValueForKeyError(void* o, void** ioValue, void* inKey, void** outError) {
	BOOL ret;
	@autoreleasepool {
		ret = [(CBCentral*)o validateValue:(id _Nullable* _Nonnull)ioValue forKey:inKey error:(NSError* _Nullable* _Nullable)outError];
		for(int i=0;i<1;i++) {
			if(ioValue[i] == 0) { break; }
			[(id)ioValue[i] retain];
		}
	
	
		for(int i=0;i<1;i++) {
			if(outError[i] == 0) { break; }
			[(id)outError[i] retain];
		}
	
	}
	return ret;

}
BOOL
CBCentral_inst_ValidateValueForKeyPathError(void* o, void** ioValue, void* inKeyPath, void** outError) {
	BOOL ret;
	@autoreleasepool {
		ret = [(CBCentral*)o validateValue:(id _Nullable* _Nonnull)ioValue forKeyPath:inKeyPath error:(NSError* _Nullable* _Nullable)outError];
		for(int i=0;i<1;i++) {
			if(ioValue[i] == 0) { break; }
			[(id)ioValue[i] retain];
		}
	
	
		for(int i=0;i<1;i++) {
			if(outError[i] == 0) { break; }
			[(id)outError[i] retain];
		}
	
	}
	return ret;

}
void* _Nonnull
CBCentral_inst_ClassDescription(void* o) {
	NSClassDescription* _Nonnull ret;
	@autoreleasepool {
		ret = [(CBCentral*)o classDescription];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
void* _Nullable
CBCentral_inst_ClassForKeyedArchiver(void* o) {
	Class _Nullable ret;
	@autoreleasepool {
		ret = [(CBCentral*)o classForKeyedArchiver];
	}
	return ret;

}
void* _Nonnull
CBCentral_inst_MutableSetValueForKey(void* o, void* key) {
	NSMutableSet* _Nonnull ret;
	@autoreleasepool {
		ret = [(CBCentral*)o mutableSetValueForKey:key];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
void* _Nullable
CBCentral_inst_NewScriptingObjectOfClassForValueForKey(void* o, void* objectClass, void* key, void* contentsValue, void* properties) {
	NSObject* _Nullable ret;
	@autoreleasepool {
		ret = [(CBCentral*)o newScriptingObjectOfClass:objectClass forValueForKey:key withContentsValue:contentsValue properties:properties];
	}
	return ret;

}
void* _Nullable
CBCentral_inst_NewScriptingObjectOfClassForValueForKeyWithContentsValue(void* o, void* objectClass, void* key, void* contentsValue, void* properties) {
	NSObject* _Nullable ret;
	@autoreleasepool {
		ret = [(CBCentral*)o newScriptingObjectOfClass:objectClass forValueForKey:key withContentsValue:contentsValue properties:properties];
	}
	return ret;

}
void* _Nonnull
CBCentral_inst_MutableOrderedSetValueForKey(void* o, void* key) {
	NSMutableOrderedSet* _Nonnull ret;
	@autoreleasepool {
		ret = [(CBCentral*)o mutableOrderedSetValueForKey:key];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
BOOL
CBCentral_inst_IsLessThanOrEqualTo(void* o, void* object) {
	BOOL ret;
	@autoreleasepool {
		ret = [(CBCentral*)o isLessThanOrEqualTo:object];
	}
	return ret;

}
void
CBCentral_inst_PerformSelectorOnMainThreadWithObject(void* o, void* aSelector, void* arg, BOOL wait) {
	@autoreleasepool {
		[(CBCentral*)o performSelectorOnMainThread:aSelector withObject:arg waitUntilDone:wait];
	}
}
void
CBCentral_inst_PerformSelectorOnMainThreadWithObjectWaitUntilDone(void* o, void* aSelector, void* arg, BOOL wait) {
	@autoreleasepool {
		[(CBCentral*)o performSelectorOnMainThread:aSelector withObject:arg waitUntilDone:wait];
	}
}
void
CBCentral_inst_PerformSelectorOnMainThreadWithObjectWaitUntilDoneModes(void* o, void* aSelector, void* arg, BOOL wait, void* array) {
	@autoreleasepool {
		[(CBCentral*)o performSelectorOnMainThread:aSelector withObject:arg waitUntilDone:wait modes:array];
	}
}
NSUInteger
CBCentral_inst_Hash(void* o) {
	NSUInteger ret;
	@autoreleasepool {
		ret = [(CBCentral*)o hash];
	}
	return ret;

}
BOOL
CBCentral_inst_IsCaseInsensitiveLike(void* o, void* object) {
	BOOL ret;
	@autoreleasepool {
		ret = [(CBCentral*)o isCaseInsensitiveLike:object];
	}
	return ret;

}
BOOL
CBCentral_inst_ScriptingIsGreaterThanOrEqualTo(void* o, void* object) {
	BOOL ret;
	@autoreleasepool {
		ret = [(CBCentral*)o scriptingIsGreaterThanOrEqualTo:object];
	}
	return ret;

}
BOOL
CBCentral_inst_ScriptingIsGreaterThan(void* o, void* object) {
	BOOL ret;
	@autoreleasepool {
		ret = [(CBCentral*)o scriptingIsGreaterThan:object];
	}
	return ret;

}
void* _Nullable
CBCentral_inst_ReplacementObjectForKeyedArchiver(void* o, void* archiver) {
	NSObject* _Nullable ret;
	@autoreleasepool {
		ret = [(CBCentral*)o replacementObjectForKeyedArchiver:archiver];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
void
CBCentral_inst_SetObservationInfo(void* o, void* observationInfo) {
	@autoreleasepool {
		[(CBCentral*)o setObservationInfo:observationInfo];
	}
}
void
CBCentral_inst_DidChangeValuesAtIndexes(void* o, NSKeyValueChange changeKind, void* indexes, void* key) {
	@autoreleasepool {
		[(CBCentral*)o didChange:changeKind valuesAtIndexes:indexes forKey:key];
	}
}
void
CBCentral_inst_DidChangeValuesAtIndexesForKey(void* o, NSKeyValueChange changeKind, void* indexes, void* key) {
	@autoreleasepool {
		[(CBCentral*)o didChange:changeKind valuesAtIndexes:indexes forKey:key];
	}
}
void* _Nonnull
CBCentral_inst_MutableArrayValueForKey(void* o, void* key) {
	NSMutableArray* _Nonnull ret;
	@autoreleasepool {
		ret = [(CBCentral*)o mutableArrayValueForKey:key];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
void
CBCentral_inst_RemoveObserverForKeyPath(void* o, void* observer, void* keyPath) {
	@autoreleasepool {
		[(CBCentral*)o removeObserver:observer forKeyPath:keyPath];
	}
}
void
CBCentral_inst_RemoveObserverForKeyPathContext(void* o, void* observer, void* keyPath, void* context) {
	@autoreleasepool {
		[(CBCentral*)o removeObserver:observer forKeyPath:keyPath context:context];
	}
}
void
CBCentral_inst_InsertValueInPropertyWithKey(void* o, void* value, void* key) {
	@autoreleasepool {
		[(CBCentral*)o insertValue:value inPropertyWithKey:key];
	}
}
void
CBCentral_inst_InsertValueAtIndex(void* o, void* value, NSUInteger index, void* key) {
	@autoreleasepool {
		[(CBCentral*)o insertValue:value atIndex:index inPropertyWithKey:key];
	}
}
void
CBCentral_inst_InsertValueAtIndexInPropertyWithKey(void* o, void* value, NSUInteger index, void* key) {
	@autoreleasepool {
		[(CBCentral*)o insertValue:value atIndex:index inPropertyWithKey:key];
	}
}
void
CBCentral_inst_DidChangeValueForKey(void* o, void* key) {
	@autoreleasepool {
		[(CBCentral*)o didChangeValueForKey:key];
	}
}
void
CBCentral_inst_DidChangeValueForKeyWithSetMutation(void* o, void* key, NSKeyValueSetMutationKind mutationKind, void* objects) {
	@autoreleasepool {
		[(CBCentral*)o didChangeValueForKey:key withSetMutation:mutationKind usingObjects:objects];
	}
}
void
CBCentral_inst_DidChangeValueForKeyWithSetMutationUsingObjects(void* o, void* key, NSKeyValueSetMutationKind mutationKind, void* objects) {
	@autoreleasepool {
		[(CBCentral*)o didChangeValueForKey:key withSetMutation:mutationKind usingObjects:objects];
	}
}
void*
CBCentral_inst_Zone(void* o) {
	struct _NSZone* ret;
	@autoreleasepool {
		ret = [(CBCentral*)o zone];
	}
	return ret;

}
BOOL
CBCentral_inst_ScriptingBeginsWith(void* o, void* object) {
	BOOL ret;
	@autoreleasepool {
		ret = [(CBCentral*)o scriptingBeginsWith:object];
	}
	return ret;

}
void* _Nullable
CBCentral_inst_ValueForKey(void* o, void* key) {
	NSObject* _Nullable ret;
	@autoreleasepool {
		ret = [(CBCentral*)o valueForKey:key];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
void
CBCentral_inst_ForwardInvocation(void* o, void* anInvocation) {
	@autoreleasepool {
		[(CBCentral*)o forwardInvocation:anInvocation];
	}
}
void
CBCentral_inst_PerformSelectorInBackgroundWithObject(void* o, void* aSelector, void* arg) {
	@autoreleasepool {
		[(CBCentral*)o performSelectorInBackground:aSelector withObject:arg];
	}
}
void* _Nullable
CBCentral_inst_CoerceValueForKey(void* o, void* value, void* key) {
	NSObject* _Nullable ret;
	@autoreleasepool {
		ret = [(CBCentral*)o coerceValue:value forKey:key];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
void* _Nonnull
CBCentral_inst_DictionaryWithValuesForKeys(void* o, void* keys) {
	NSDictionary* _Nonnull ret;
	@autoreleasepool {
		ret = [(CBCentral*)o dictionaryWithValuesForKeys:keys];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
void*
CBCentral_inst_Superclass(void* o) {
	Class ret;
	@autoreleasepool {
		ret = [(CBCentral*)o superclass];
	}
	return ret;

}
BOOL
CBCentral_inst_ScriptingIsLessThan(void* o, void* object) {
	BOOL ret;
	@autoreleasepool {
		ret = [(CBCentral*)o scriptingIsLessThan:object];
	}
	return ret;

}
FourCharCode
CBCentral_inst_ClassCode(void* o) {
	FourCharCode ret;
	@autoreleasepool {
		ret = [(CBCentral*)o classCode];
	}
	return ret;

}
void* _Nonnull
CBCentral_inst_AutoContentAccessingProxy(void* o) {
	NSObject* _Nonnull ret;
	@autoreleasepool {
		ret = [(CBCentral*)o autoContentAccessingProxy];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
void* _Nullable
CBCentral_inst_InverseForRelationshipKey(void* o, void* relationshipKey) {
	NSString* _Nullable ret;
	@autoreleasepool {
		ret = [(CBCentral*)o inverseForRelationshipKey:relationshipKey];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
BOOL
CBCentral_inst_IsLike(void* o, void* object) {
	BOOL ret;
	@autoreleasepool {
		ret = [(CBCentral*)o isLike:object];
	}
	return ret;

}
BOOL
CBCentral_inst_IsEqual(void* o, void* object) {
	BOOL ret;
	@autoreleasepool {
		ret = [(CBCentral*)o isEqual:object];
	}
	return ret;

}
void
CBCentral_inst_DoesNotRecognizeSelector(void* o, void* aSelector) {
	@autoreleasepool {
		[(CBCentral*)o doesNotRecognizeSelector:aSelector];
	}
}
void*
CBCentral_inst_MutableCopy(void* o) {
	NSObject* ret;
	@autoreleasepool {
		ret = [(CBCentral*)o mutableCopy];
	}
	return ret;

}
void
CBCentral_inst_SetValuesForKeysWithDictionary(void* o, void* keyedValues) {
	@autoreleasepool {
		[(CBCentral*)o setValuesForKeysWithDictionary:keyedValues];
	}
}
void
CBCentral_inst_Release(void* o) {
	@autoreleasepool {
		[(CBCentral*)o release];
	}
}
NSUInteger
CBCentral_inst_MaximumUpdateValueLength(void* o) {
	NSUInteger ret;
	@autoreleasepool {
		ret = [(CBCentral*)o maximumUpdateValueLength];
	}
	return ret;

}
void* _Nullable
CBCentral_inst_ReplacementObjectForCoder(void* o, void* coder) {
	NSObject* _Nullable ret;
	@autoreleasepool {
		ret = [(CBCentral*)o replacementObjectForCoder:coder];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
BOOL
NSDictionary_ResolveClassMethod(void* sel) {
	BOOL ret;
	@autoreleasepool {
		ret = [NSDictionary resolveClassMethod:sel];
	}
	return ret;

}
void* _Nonnull
NSDictionary_KeyPathsForValuesAffectingValueForKey(void* key) {
	NSSet* _Nonnull ret;
	@autoreleasepool {
		ret = [NSDictionary keyPathsForValuesAffectingValueForKey:key];
	}
	return ret;

}
void*
NSDictionary_MutableCopyWithZone(void* zone) {
	NSObject* ret;
	@autoreleasepool {
		ret = [NSDictionary mutableCopyWithZone:zone];
	}
	return ret;

}
BOOL
NSDictionary_ResolveInstanceMethod(void* sel) {
	BOOL ret;
	@autoreleasepool {
		ret = [NSDictionary resolveInstanceMethod:sel];
	}
	return ret;

}
void*
NSDictionary_Superclass() {
	Class ret;
	@autoreleasepool {
		ret = [NSDictionary superclass];
	}
	return ret;

}
NSUInteger
NSDictionary_Hash() {
	NSUInteger ret;
	@autoreleasepool {
		ret = [NSDictionary hash];
	}
	return ret;

}
void*
NSDictionary_New() {
	NSDictionary* ret;
	@autoreleasepool {
		ret = [NSDictionary new];
	}
	return ret;

}
BOOL
NSDictionary_AccessInstanceVariablesDirectly() {
	BOOL ret;
	@autoreleasepool {
		ret = [NSDictionary accessInstanceVariablesDirectly];
	}
	return ret;

}
void*
NSDictionary_Alloc() {
	return [NSDictionary alloc];
}
void*
NSDictionary_DebugDescription() {
	NSString* ret;
	@autoreleasepool {
		ret = [NSDictionary debugDescription];
	}
	return ret;

}
BOOL
NSDictionary_InstancesRespondToSelector(void* aSelector) {
	BOOL ret;
	@autoreleasepool {
		ret = [NSDictionary instancesRespondToSelector:aSelector];
	}
	return ret;

}
void* _Nonnull
NSDictionary_DictionaryWithDictionary(void* dict) {
	NSDictionary* _Nonnull ret;
	@autoreleasepool {
		ret = [NSDictionary dictionaryWithDictionary:dict];
		if(ret != nil) { [ret retain]; }
	}
	return ret;

}
BOOL
NSDictionary_IsSubclassOfClass(void* aClass) {
	BOOL ret;
	@autoreleasepool {
		ret = [NSDictionary isSubclassOfClass:aClass];
	}
	return ret;

}
BOOL
NSDictionary_ConformsToProtocol(void* protocol) {
	BOOL ret;
	@autoreleasepool {
		ret = [NSDictionary conformsToProtocol:protocol];
	}
	return ret;

}
void* _Nonnull
NSDictionary_ClassForKeyedUnarchiver() {
	Class _Nonnull ret;
	@autoreleasepool {
		ret = [NSDictionary classForKeyedUnarchiver];
	}
	return ret;

}
BOOL
NSDictionary_SupportsSecureCoding() {
	BOOL ret;
	@autoreleasepool {
		ret = [NSDictionary supportsSecureCoding];
	}
	return ret;

}
void
NSDictionary_SetVersion(NSInteger aVersion) {
	@autoreleasepool {
		[NSDictionary setVersion:aVersion];
	}
}
void*
NSDictionary_InstanceMethodSignatureForSelector(void* aSelector) {
	NSMethodSignature* ret;
	@autoreleasepool {
		ret = [NSDictionary instanceMethodSignatureForSelector:aSelector];
	}
	return ret;

}
void* _Nullable
NSDictionary_DictionaryWithContentsOfURLError(void* url, void** error) {
	NSDictionary* _Nullable ret;
	@autoreleasepool {
		ret = [NSDictionary dictionaryWithContentsOfURL:url error:(NSError* _Nullable* _Nullable)error];
		if(ret != nil) { [ret retain]; }
		for(int i=0;i<1;i++) {
			if(error[i] == 0) { break; }
			[(id)error[i] retain];
		}
	
	}
	return ret;

}
void*
NSDictionary_AllocWithZone(void* zone) {
	return [NSDictionary allocWithZone:zone];
}
void* _Nonnull
NSDictionary_ClassFallbacksForKeyedArchiver() {
	NSArray* _Nonnull ret;
	@autoreleasepool {
		ret = [NSDictionary classFallbacksForKeyedArchiver];
	}
	return ret;

}
NSInteger
NSDictionary_Version() {
	NSInteger ret;
	@autoreleasepool {
		ret = [NSDictionary version];
	}
	return ret;

}
void* _Nonnull
NSDictionary_DictionaryWithObjectForKey(void* object, void* key) {
	NSDictionary* _Nonnull ret;
	@autoreleasepool {
		ret = [NSDictionary dictionaryWithObject:object forKey:key];
		if(ret != nil) { [ret retain]; }
	}
	return ret;

}
void*
NSDictionary_Description() {
	NSString* ret;
	@autoreleasepool {
		ret = [NSDictionary description];
	}
	return ret;

}
void*
NSDictionary_Class() {
	Class ret;
	@autoreleasepool {
		ret = [NSDictionary class];
	}
	return ret;

}
BOOL
NSDictionary_AutomaticallyNotifiesObserversForKey(void* key) {
	BOOL ret;
	@autoreleasepool {
		ret = [NSDictionary automaticallyNotifiesObserversForKey:key];
	}
	return ret;

}
void
NSDictionary_CancelPreviousPerformRequestsWithTarget(void* aTarget) {
	@autoreleasepool {
		[NSDictionary cancelPreviousPerformRequestsWithTarget:aTarget];
	}
}
void
NSDictionary_CancelPreviousPerformRequestsWithTargetSelector(void* aTarget, void* aSelector, void* anArgument) {
	@autoreleasepool {
		[NSDictionary cancelPreviousPerformRequestsWithTarget:aTarget selector:aSelector object:anArgument];
	}
}
void
NSDictionary_CancelPreviousPerformRequestsWithTargetSelectorObject(void* aTarget, void* aSelector, void* anArgument) {
	@autoreleasepool {
		[NSDictionary cancelPreviousPerformRequestsWithTarget:aTarget selector:aSelector object:anArgument];
	}
}
void* _Nonnull
NSDictionary_DictionaryWithObjectsAndKeys(void* firstObject) {
	NSDictionary* _Nonnull ret;
	@autoreleasepool {
		ret = [NSDictionary dictionaryWithObjectsAndKeys:firstObject,nil];
		if(ret != nil) { [ret retain]; }
	}
	return ret;

}
void* _Nonnull
NSDictionary_SharedKeySetForKeys(void* keys) {
	NSObject* _Nonnull ret;
	@autoreleasepool {
		ret = [NSDictionary sharedKeySetForKeys:keys];
	}
	return ret;

}
void
NSDictionary_Load() {
	@autoreleasepool {
		[NSDictionary load];
	}
}
void*
NSDictionary_CopyWithZone(void* zone) {
	NSObject* ret;
	@autoreleasepool {
		ret = [NSDictionary copyWithZone:zone];
	}
	return ret;

}
void* _Nonnull
NSDictionary_Dictionary() {
	NSDictionary* _Nonnull ret;
	@autoreleasepool {
		ret = [NSDictionary dictionary];
		if(ret != nil) { [ret retain]; }
	}
	return ret;

}
void* _Nonnull
NSDictionary_DictionaryWithObjectsForKeys(void* objects, void* keys) {
	NSDictionary* _Nonnull ret;
	@autoreleasepool {
		ret = [NSDictionary dictionaryWithObjects:objects forKeys:keys];
		if(ret != nil) { [ret retain]; }
	}
	return ret;

}
void* _Nonnull
NSDictionary_DictionaryWithObjectsForKeysCount(void** objects, void** keys, NSUInteger cnt) {
	NSDictionary* _Nonnull ret;
	@autoreleasepool {
		ret = [NSDictionary dictionaryWithObjects:(id _Nonnull const* _Nullable)objects forKeys:(id <NSCopying> _Nonnull const* _Nullable)keys count:cnt];
		if(ret != nil) { [ret retain]; }
		for(int i=0;i<cnt;i++) {
			if(objects[i] == 0) { break; }
			[(id)objects[i] retain];
		}
	
	
		for(int i=0;i<cnt;i++) {
			if(keys[i] == 0) { break; }
			[(id)keys[i] retain];
		}
	
	}
	return ret;

}
BOOL
NSDictionary_inst_ConformsToProtocol(void* o, void* aProtocol) {
	BOOL ret;
	@autoreleasepool {
		ret = [(NSDictionary*)o conformsToProtocol:aProtocol];
	}
	return ret;

}
void
NSDictionary_inst_RemoveObserverForKeyPath(void* o, void* observer, void* keyPath) {
	@autoreleasepool {
		[(NSDictionary*)o removeObserver:observer forKeyPath:keyPath];
	}
}
void
NSDictionary_inst_RemoveObserverForKeyPathContext(void* o, void* observer, void* keyPath, void* context) {
	@autoreleasepool {
		[(NSDictionary*)o removeObserver:observer forKeyPath:keyPath context:context];
	}
}
void
NSDictionary_inst_PerformSelectorInBackgroundWithObject(void* o, void* aSelector, void* arg) {
	@autoreleasepool {
		[(NSDictionary*)o performSelectorInBackground:aSelector withObject:arg];
	}
}
void* _Nullable
NSDictionary_inst_IndicesOfObjectsByEvaluatingObjectSpecifier(void* o, void* specifier) {
	NSArray* _Nullable ret;
	@autoreleasepool {
		ret = [(NSDictionary*)o indicesOfObjectsByEvaluatingObjectSpecifier:specifier];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
void* _Nonnull
NSDictionary_inst_MutableSetValueForKey(void* o, void* key) {
	NSMutableSet* _Nonnull ret;
	@autoreleasepool {
		ret = [(NSDictionary*)o mutableSetValueForKey:key];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
void* _Nonnull
NSDictionary_inst_CopyWithZone(void* o, void* zone) {
	NSObject* _Nonnull ret;
	@autoreleasepool {
		ret = [(NSDictionary*)o copyWithZone:zone];
	}
	return ret;

}
void* _Nullable
NSDictionary_inst_ObjectForKeyedSubscript(void* o, void* key) {
	NSObject* _Nullable ret;
	@autoreleasepool {
		ret = [(NSDictionary*)o objectForKeyedSubscript:key];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
void* _Nullable
NSDictionary_inst_ValueForUndefinedKey(void* o, void* key) {
	NSObject* _Nullable ret;
	@autoreleasepool {
		ret = [(NSDictionary*)o valueForUndefinedKey:key];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
void* _Nullable
NSDictionary_inst_ValueWithUniqueIDInPropertyWithKey(void* o, void* uniqueID, void* key) {
	NSObject* _Nullable ret;
	@autoreleasepool {
		ret = [(NSDictionary*)o valueWithUniqueID:uniqueID inPropertyWithKey:key];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
void* _Nonnull
NSDictionary_inst_ClassForCoder(void* o) {
	Class _Nonnull ret;
	@autoreleasepool {
		ret = [(NSDictionary*)o classForCoder];
	}
	return ret;

}
BOOL
NSDictionary_inst_FileIsAppendOnly(void* o) {
	BOOL ret;
	@autoreleasepool {
		ret = [(NSDictionary*)o fileIsAppendOnly];
	}
	return ret;

}
void* _Nonnull
NSDictionary_inst_ToManyRelationshipKeys(void* o) {
	NSArray* _Nonnull ret;
	@autoreleasepool {
		ret = [(NSDictionary*)o toManyRelationshipKeys];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
void* _Nonnull
NSDictionary_inst_AllKeysForObject(void* o, void* anObject) {
	NSArray* _Nonnull ret;
	@autoreleasepool {
		ret = [(NSDictionary*)o allKeysForObject:anObject];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
void*
NSDictionary_inst_Superclass(void* o) {
	Class ret;
	@autoreleasepool {
		ret = [(NSDictionary*)o superclass];
	}
	return ret;

}
BOOL
NSDictionary_inst_IsLessThanOrEqualTo(void* o, void* object) {
	BOOL ret;
	@autoreleasepool {
		ret = [(NSDictionary*)o isLessThanOrEqualTo:object];
	}
	return ret;

}
unsigned long long
NSDictionary_inst_FileSize(void* o) {
	unsigned long long ret;
	@autoreleasepool {
		ret = [(NSDictionary*)o fileSize];
	}
	return ret;

}
void
NSDictionary_inst_Dealloc(void* o) {
	@autoreleasepool {
		[(NSDictionary*)o dealloc];
	}
}
void*
NSDictionary_inst_PerformSelector(void* o, void* aSelector) {
	NSObject* ret;
	@autoreleasepool {
		ret = [(NSDictionary*)o performSelector:aSelector];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
void*
NSDictionary_inst_PerformSelectorWithObject(void* o, void* aSelector, void* object) {
	NSObject* ret;
	@autoreleasepool {
		ret = [(NSDictionary*)o performSelector:aSelector withObject:object];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
void*
NSDictionary_inst_PerformSelectorWithObjectWithObject(void* o, void* aSelector, void* object1, void* object2) {
	NSObject* ret;
	@autoreleasepool {
		ret = [(NSDictionary*)o performSelector:aSelector withObject:object1 withObject:object2];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
void
NSDictionary_inst_PerformSelectorWithObjectAfterDelay(void* o, void* aSelector, void* anArgument, NSTimeInterval delay) {
	@autoreleasepool {
		[(NSDictionary*)o performSelector:aSelector withObject:anArgument afterDelay:delay];
	}
}
void
NSDictionary_inst_PerformSelectorOnThread(void* o, void* aSelector, void* thr, void* arg, BOOL wait) {
	@autoreleasepool {
		[(NSDictionary*)o performSelector:aSelector onThread:thr withObject:arg waitUntilDone:wait];
	}
}
void
NSDictionary_inst_PerformSelectorWithObjectAfterDelayInModes(void* o, void* aSelector, void* anArgument, NSTimeInterval delay, void* modes) {
	@autoreleasepool {
		[(NSDictionary*)o performSelector:aSelector withObject:anArgument afterDelay:delay inModes:modes];
	}
}
void
NSDictionary_inst_PerformSelectorOnThreadWithObject(void* o, void* aSelector, void* thr, void* arg, BOOL wait) {
	@autoreleasepool {
		[(NSDictionary*)o performSelector:aSelector onThread:thr withObject:arg waitUntilDone:wait];
	}
}
void
NSDictionary_inst_PerformSelectorOnThreadWithObjectWaitUntilDone(void* o, void* aSelector, void* thr, void* arg, BOOL wait, void* array) {
	@autoreleasepool {
		[(NSDictionary*)o performSelector:aSelector onThread:thr withObject:arg waitUntilDone:wait modes:array];
	}
}
void
NSDictionary_inst_PerformSelectorOnThreadWithObjectWaitUntilDoneModes(void* o, void* aSelector, void* thr, void* arg, BOOL wait, void* array) {
	@autoreleasepool {
		[(NSDictionary*)o performSelector:aSelector onThread:thr withObject:arg waitUntilDone:wait modes:array];
	}
}
void* _Nonnull
NSDictionary_inst_AutoContentAccessingProxy(void* o) {
	NSObject* _Nonnull ret;
	@autoreleasepool {
		ret = [(NSDictionary*)o autoContentAccessingProxy];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
OSType
NSDictionary_inst_FileHFSCreatorCode(void* o) {
	OSType ret;
	@autoreleasepool {
		ret = [(NSDictionary*)o fileHFSCreatorCode];
	}
	return ret;

}
void* _Nonnull
NSDictionary_inst_Init(void* o) {
	NSDictionary* _Nonnull ret;
	@autoreleasepool {
		ret = [(NSDictionary*)o init];
	}
	return ret;

}
void*
NSDictionary_inst_Retain(void* o) {
	NSDictionary* ret;
	@autoreleasepool {
		ret = [(NSDictionary*)o retain];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
BOOL
NSDictionary_inst_IsEqualTo(void* o, void* object) {
	BOOL ret;
	@autoreleasepool {
		ret = [(NSDictionary*)o isEqualTo:object];
	}
	return ret;

}
BOOL
NSDictionary_inst_DoesContain(void* o, void* object) {
	BOOL ret;
	@autoreleasepool {
		ret = [(NSDictionary*)o doesContain:object];
	}
	return ret;

}
void* _Nonnull
NSDictionary_inst_MutableCopyWithZone(void* o, void* zone) {
	NSObject* _Nonnull ret;
	@autoreleasepool {
		ret = [(NSDictionary*)o mutableCopyWithZone:zone];
	}
	return ret;

}
void* _Nonnull
NSDictionary_inst_InitWithObjectsAndKeys(void* o, void* firstObject) {
	NSDictionary* _Nonnull ret;
	@autoreleasepool {
		ret = [(NSDictionary*)o initWithObjectsAndKeys:firstObject,nil];
	}
	return ret;

}
void* _Nullable
NSDictionary_inst_NewScriptingObjectOfClassForValueForKey(void* o, void* objectClass, void* key, void* contentsValue, void* properties) {
	NSObject* _Nullable ret;
	@autoreleasepool {
		ret = [(NSDictionary*)o newScriptingObjectOfClass:objectClass forValueForKey:key withContentsValue:contentsValue properties:properties];
	}
	return ret;

}
void* _Nullable
NSDictionary_inst_NewScriptingObjectOfClassForValueForKeyWithContentsValue(void* o, void* objectClass, void* key, void* contentsValue, void* properties) {
	NSObject* _Nullable ret;
	@autoreleasepool {
		ret = [(NSDictionary*)o newScriptingObjectOfClass:objectClass forValueForKey:key withContentsValue:contentsValue properties:properties];
	}
	return ret;

}
void
NSDictionary_inst_DoesNotRecognizeSelector(void* o, void* aSelector) {
	@autoreleasepool {
		[(NSDictionary*)o doesNotRecognizeSelector:aSelector];
	}
}
void*
NSDictionary_inst_Zone(void* o) {
	struct _NSZone* ret;
	@autoreleasepool {
		ret = [(NSDictionary*)o zone];
	}
	return ret;

}
BOOL
NSDictionary_inst_ScriptingBeginsWith(void* o, void* object) {
	BOOL ret;
	@autoreleasepool {
		ret = [(NSDictionary*)o scriptingBeginsWith:object];
	}
	return ret;

}
void*
NSDictionary_inst_MethodSignatureForSelector(void* o, void* aSelector) {
	NSMethodSignature* ret;
	@autoreleasepool {
		ret = [(NSDictionary*)o methodSignatureForSelector:aSelector];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
void* _Nullable
NSDictionary_inst_ScriptingProperties(void* o) {
	NSDictionary* _Nullable ret;
	@autoreleasepool {
		ret = [(NSDictionary*)o scriptingProperties];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
void* _Nonnull
NSDictionary_inst_KeysSortedByValueUsingSelector(void* o, void* comparator) {
	NSArray* _Nonnull ret;
	@autoreleasepool {
		ret = [(NSDictionary*)o keysSortedByValueUsingSelector:comparator];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
void* _Nullable
NSDictionary_inst_FileGroupOwnerAccountID(void* o) {
	NSNumber* _Nullable ret;
	@autoreleasepool {
		ret = [(NSDictionary*)o fileGroupOwnerAccountID];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
void* _Nullable
NSDictionary_inst_FileOwnerAccountID(void* o) {
	NSNumber* _Nullable ret;
	@autoreleasepool {
		ret = [(NSDictionary*)o fileOwnerAccountID];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
NSUInteger
NSDictionary_inst_FileSystemFileNumber(void* o) {
	NSUInteger ret;
	@autoreleasepool {
		ret = [(NSDictionary*)o fileSystemFileNumber];
	}
	return ret;

}
BOOL
NSDictionary_inst_IsMemberOfClass(void* o, void* aClass) {
	BOOL ret;
	@autoreleasepool {
		ret = [(NSDictionary*)o isMemberOfClass:aClass];
	}
	return ret;

}
void
NSDictionary_inst_AddObserverForKeyPath(void* o, void* observer, void* keyPath, NSKeyValueObservingOptions options, void* context) {
	@autoreleasepool {
		[(NSDictionary*)o addObserver:observer forKeyPath:keyPath options:options context:context];
	}
}
void
NSDictionary_inst_AddObserverForKeyPathOptions(void* o, void* observer, void* keyPath, NSKeyValueObservingOptions options, void* context) {
	@autoreleasepool {
		[(NSDictionary*)o addObserver:observer forKeyPath:keyPath options:options context:context];
	}
}
FourCharCode
NSDictionary_inst_ClassCode(void* o) {
	FourCharCode ret;
	@autoreleasepool {
		ret = [(NSDictionary*)o classCode];
	}
	return ret;

}
void
NSDictionary_inst_WillChangeValuesAtIndexes(void* o, NSKeyValueChange changeKind, void* indexes, void* key) {
	@autoreleasepool {
		[(NSDictionary*)o willChange:changeKind valuesAtIndexes:indexes forKey:key];
	}
}
void
NSDictionary_inst_WillChangeValuesAtIndexesForKey(void* o, NSKeyValueChange changeKind, void* indexes, void* key) {
	@autoreleasepool {
		[(NSDictionary*)o willChange:changeKind valuesAtIndexes:indexes forKey:key];
	}
}
void
NSDictionary_inst_SetValuesForKeysWithDictionary(void* o, void* keyedValues) {
	@autoreleasepool {
		[(NSDictionary*)o setValuesForKeysWithDictionary:keyedValues];
	}
}
BOOL
NSDictionary_inst_ScriptingEndsWith(void* o, void* object) {
	BOOL ret;
	@autoreleasepool {
		ret = [(NSDictionary*)o scriptingEndsWith:object];
	}
	return ret;

}
void* _Nullable
NSDictionary_inst_FileType(void* o) {
	NSString* _Nullable ret;
	@autoreleasepool {
		ret = [(NSDictionary*)o fileType];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
BOOL
NSDictionary_inst_FileIsImmutable(void* o) {
	BOOL ret;
	@autoreleasepool {
		ret = [(NSDictionary*)o fileIsImmutable];
	}
	return ret;

}
void* _Nullable
NSDictionary_inst_ObjectSpecifier(void* o) {
	NSScriptObjectSpecifier* _Nullable ret;
	@autoreleasepool {
		ret = [(NSDictionary*)o objectSpecifier];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
void* _Nullable
NSDictionary_inst_ScriptingValueForSpecifier(void* o, void* objectSpecifier) {
	NSObject* _Nullable ret;
	@autoreleasepool {
		ret = [(NSDictionary*)o scriptingValueForSpecifier:objectSpecifier];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
void*
NSDictionary_inst_DebugDescription(void* o) {
	NSString* ret;
	@autoreleasepool {
		ret = [(NSDictionary*)o debugDescription];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
NSUInteger
NSDictionary_inst_Hash(void* o) {
	NSUInteger ret;
	@autoreleasepool {
		ret = [(NSDictionary*)o hash];
	}
	return ret;

}
BOOL
NSDictionary_inst_WriteToURLError(void* o, void* url, void** error) {
	BOOL ret;
	@autoreleasepool {
		ret = [(NSDictionary*)o writeToURL:url error:(NSError* _Nullable* _Nullable)error];
		for(int i=0;i<1;i++) {
			if(error[i] == 0) { break; }
			[(id)error[i] retain];
		}
	
	}
	return ret;

}
void* _Nonnull
NSDictionary_inst_DescriptionInStringsFileFormat(void* o) {
	NSString* _Nonnull ret;
	@autoreleasepool {
		ret = [(NSDictionary*)o descriptionInStringsFileFormat];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
void* _Nullable
NSDictionary_inst_InitWithContentsOfURLError(void* o, void* url, void** error) {
	NSDictionary* _Nullable ret;
	@autoreleasepool {
		ret = [(NSDictionary*)o initWithContentsOfURL:url error:(NSError* _Nullable* _Nullable)error];
		for(int i=0;i<1;i++) {
			if(error[i] == 0) { break; }
			[(id)error[i] retain];
		}
	
	}
	return ret;

}
void* _Nonnull
NSDictionary_inst_AttributeKeys(void* o) {
	NSArray* _Nonnull ret;
	@autoreleasepool {
		ret = [(NSDictionary*)o attributeKeys];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
void*
NSDictionary_inst_Autorelease(void* o) {
	NSDictionary* ret;
	@autoreleasepool {
		ret = [(NSDictionary*)o autorelease];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
BOOL
NSDictionary_inst_AttemptRecoveryFromErrorOptionIndex(void* o, void* error, NSUInteger recoveryOptionIndex) {
	BOOL ret;
	@autoreleasepool {
		ret = [(NSDictionary*)o attemptRecoveryFromError:error optionIndex:recoveryOptionIndex];
	}
	return ret;

}
void
NSDictionary_inst_AttemptRecoveryFromErrorOptionIndexDelegate(void* o, void* error, NSUInteger recoveryOptionIndex, void* delegate, void* didRecoverSelector, void* contextInfo) {
	@autoreleasepool {
		[(NSDictionary*)o attemptRecoveryFromError:error optionIndex:recoveryOptionIndex delegate:delegate didRecoverSelector:didRecoverSelector contextInfo:contextInfo];
	}
}
void
NSDictionary_inst_AttemptRecoveryFromErrorOptionIndexDelegateDidRecoverSelector(void* o, void* error, NSUInteger recoveryOptionIndex, void* delegate, void* didRecoverSelector, void* contextInfo) {
	@autoreleasepool {
		[(NSDictionary*)o attemptRecoveryFromError:error optionIndex:recoveryOptionIndex delegate:delegate didRecoverSelector:didRecoverSelector contextInfo:contextInfo];
	}
}
void* _Nullable
NSDictionary_inst_ValueAtIndexInPropertyWithKey(void* o, NSUInteger index, void* key) {
	NSObject* _Nullable ret;
	@autoreleasepool {
		ret = [(NSDictionary*)o valueAtIndex:index inPropertyWithKey:key];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
BOOL
NSDictionary_inst_ScriptingContains(void* o, void* object) {
	BOOL ret;
	@autoreleasepool {
		ret = [(NSDictionary*)o scriptingContains:object];
	}
	return ret;

}
BOOL
NSDictionary_inst_IsCaseInsensitiveLike(void* o, void* object) {
	BOOL ret;
	@autoreleasepool {
		ret = [(NSDictionary*)o isCaseInsensitiveLike:object];
	}
	return ret;

}
void*
NSDictionary_inst_ObservationInfo(void* o) {
	void* ret;
	@autoreleasepool {
		ret = [(NSDictionary*)o observationInfo];
	}
	return ret;

}
void* _Nullable
NSDictionary_inst_CoerceValueForKey(void* o, void* value, void* key) {
	NSObject* _Nullable ret;
	@autoreleasepool {
		ret = [(NSDictionary*)o coerceValue:value forKey:key];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
BOOL
NSDictionary_inst_IsKindOfClass(void* o, void* aClass) {
	BOOL ret;
	@autoreleasepool {
		ret = [(NSDictionary*)o isKindOfClass:aClass];
	}
	return ret;

}
void
NSDictionary_inst_GetObjectsAndKeys(void* o, void** objects, void** keys, NSUInteger count) {
	@autoreleasepool {
		[(NSDictionary*)o getObjects:(id _Nonnull* _Nullable)objects andKeys:(id _Nonnull* _Nullable)keys count:count];
		for(int i=0;i<count;i++) {
			if(objects[i] == 0) { break; }
			[(id)objects[i] retain];
		}
	
	
		for(int i=0;i<count;i++) {
			if(keys[i] == 0) { break; }
			[(id)keys[i] retain];
		}
	
	}
}
void
NSDictionary_inst_GetObjectsAndKeysCount(void* o, void** objects, void** keys, NSUInteger count) {
	@autoreleasepool {
		[(NSDictionary*)o getObjects:(id _Nonnull* _Nullable)objects andKeys:(id _Nonnull* _Nullable)keys count:count];
		for(int i=0;i<count;i++) {
			if(objects[i] == 0) { break; }
			[(id)objects[i] retain];
		}
	
	
		for(int i=0;i<count;i++) {
			if(keys[i] == 0) { break; }
			[(id)keys[i] retain];
		}
	
	}
}
void* _Nonnull
NSDictionary_inst_KeyEnumerator(void* o) {
	NSEnumerator* _Nonnull ret;
	@autoreleasepool {
		ret = [(NSDictionary*)o keyEnumerator];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
void* _Nullable
NSDictionary_inst_ObjectForKey(void* o, void* aKey) {
	NSObject* _Nullable ret;
	@autoreleasepool {
		ret = [(NSDictionary*)o objectForKey:aKey];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
void* _Nonnull
NSDictionary_inst_MutableArrayValueForKeyPath(void* o, void* keyPath) {
	NSMutableArray* _Nonnull ret;
	@autoreleasepool {
		ret = [(NSDictionary*)o mutableArrayValueForKeyPath:keyPath];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
void* _Nonnull
NSDictionary_inst_MutableSetValueForKeyPath(void* o, void* keyPath) {
	NSMutableSet* _Nonnull ret;
	@autoreleasepool {
		ret = [(NSDictionary*)o mutableSetValueForKeyPath:keyPath];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
void* _Nonnull
NSDictionary_inst_MutableOrderedSetValueForKeyPath(void* o, void* keyPath) {
	NSMutableOrderedSet* _Nonnull ret;
	@autoreleasepool {
		ret = [(NSDictionary*)o mutableOrderedSetValueForKeyPath:keyPath];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
BOOL
NSDictionary_inst_IsLike(void* o, void* object) {
	BOOL ret;
	@autoreleasepool {
		ret = [(NSDictionary*)o isLike:object];
	}
	return ret;

}
void* _Nullable
NSDictionary_inst_ValueForKeyPath(void* o, void* keyPath) {
	NSObject* _Nullable ret;
	@autoreleasepool {
		ret = [(NSDictionary*)o valueForKeyPath:keyPath];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
BOOL
NSDictionary_inst_IsEqual(void* o, void* object) {
	BOOL ret;
	@autoreleasepool {
		ret = [(NSDictionary*)o isEqual:object];
	}
	return ret;

}
void
NSDictionary_inst_DidChangeValueForKey(void* o, void* key) {
	@autoreleasepool {
		[(NSDictionary*)o didChangeValueForKey:key];
	}
}
void
NSDictionary_inst_DidChangeValueForKeyWithSetMutation(void* o, void* key, NSKeyValueSetMutationKind mutationKind, void* objects) {
	@autoreleasepool {
		[(NSDictionary*)o didChangeValueForKey:key withSetMutation:mutationKind usingObjects:objects];
	}
}
void
NSDictionary_inst_DidChangeValueForKeyWithSetMutationUsingObjects(void* o, void* key, NSKeyValueSetMutationKind mutationKind, void* objects) {
	@autoreleasepool {
		[(NSDictionary*)o didChangeValueForKey:key withSetMutation:mutationKind usingObjects:objects];
	}
}
void* _Nullable
NSDictionary_inst_CopyScriptingValueForKey(void* o, void* value, void* key, void* properties) {
	NSObject* _Nullable ret;
	@autoreleasepool {
		ret = [(NSDictionary*)o copyScriptingValue:value forKey:key withProperties:properties];
	}
	return ret;

}
void* _Nullable
NSDictionary_inst_CopyScriptingValueForKeyWithProperties(void* o, void* value, void* key, void* properties) {
	NSObject* _Nullable ret;
	@autoreleasepool {
		ret = [(NSDictionary*)o copyScriptingValue:value forKey:key withProperties:properties];
	}
	return ret;

}
OSType
NSDictionary_inst_FileHFSTypeCode(void* o) {
	OSType ret;
	@autoreleasepool {
		ret = [(NSDictionary*)o fileHFSTypeCode];
	}
	return ret;

}
void* _Nonnull
NSDictionary_inst_ObjectsForKeysNotFoundMarker(void* o, void* keys, void* marker) {
	NSArray* _Nonnull ret;
	@autoreleasepool {
		ret = [(NSDictionary*)o objectsForKeys:keys notFoundMarker:marker];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
void* _Nonnull
NSDictionary_inst_InitWithObjectsForKeys(void* o, void* objects, void* keys) {
	NSDictionary* _Nonnull ret;
	@autoreleasepool {
		ret = [(NSDictionary*)o initWithObjects:objects forKeys:keys];
	}
	return ret;

}
void* _Nonnull
NSDictionary_inst_InitWithObjectsForKeysCount(void* o, void** objects, void** keys, NSUInteger cnt) {
	NSDictionary* _Nonnull ret;
	@autoreleasepool {
		ret = [(NSDictionary*)o initWithObjects:(id _Nonnull const* _Nullable)objects forKeys:(id <NSCopying> _Nonnull const* _Nullable)keys count:cnt];
		for(int i=0;i<cnt;i++) {
			if(objects[i] == 0) { break; }
			[(id)objects[i] retain];
		}
	
	
		for(int i=0;i<cnt;i++) {
			if(keys[i] == 0) { break; }
			[(id)keys[i] retain];
		}
	
	}
	return ret;

}
void* _Nullable
NSDictionary_inst_ReplacementObjectForCoder(void* o, void* coder) {
	NSObject* _Nullable ret;
	@autoreleasepool {
		ret = [(NSDictionary*)o replacementObjectForCoder:coder];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
void* _Nullable
NSDictionary_inst_ValueForKey(void* o, void* key) {
	NSObject* _Nullable ret;
	@autoreleasepool {
		ret = [(NSDictionary*)o valueForKey:key];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
NSUInteger
NSDictionary_inst_Count(void* o) {
	NSUInteger ret;
	@autoreleasepool {
		ret = [(NSDictionary*)o count];
	}
	return ret;

}
BOOL
NSDictionary_inst_ScriptingIsLessThan(void* o, void* object) {
	BOOL ret;
	@autoreleasepool {
		ret = [(NSDictionary*)o scriptingIsLessThan:object];
	}
	return ret;

}
void*
NSDictionary_inst_Copy(void* o) {
	NSObject* ret;
	@autoreleasepool {
		ret = [(NSDictionary*)o copy];
	}
	return ret;

}
BOOL
NSDictionary_inst_RespondsToSelector(void* o, void* aSelector) {
	BOOL ret;
	@autoreleasepool {
		ret = [(NSDictionary*)o respondsToSelector:aSelector];
	}
	return ret;

}
void* _Nonnull
NSDictionary_inst_ClassName(void* o) {
	NSString* _Nonnull ret;
	@autoreleasepool {
		ret = [(NSDictionary*)o className];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
void* _Nonnull
NSDictionary_inst_AllKeys(void* o) {
	NSArray* _Nonnull ret;
	@autoreleasepool {
		ret = [(NSDictionary*)o allKeys];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
void* _Nullable
NSDictionary_inst_FileOwnerAccountName(void* o) {
	NSString* _Nullable ret;
	@autoreleasepool {
		ret = [(NSDictionary*)o fileOwnerAccountName];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
void
NSDictionary_inst_ReplaceValueAtIndexInPropertyWithKey(void* o, NSUInteger index, void* key, void* value) {
	@autoreleasepool {
		[(NSDictionary*)o replaceValueAtIndex:index inPropertyWithKey:key withValue:value];
	}
}
void
NSDictionary_inst_ReplaceValueAtIndexInPropertyWithKeyWithValue(void* o, NSUInteger index, void* key, void* value) {
	@autoreleasepool {
		[(NSDictionary*)o replaceValueAtIndex:index inPropertyWithKey:key withValue:value];
	}
}
void
NSDictionary_inst_ForwardInvocation(void* o, void* anInvocation) {
	@autoreleasepool {
		[(NSDictionary*)o forwardInvocation:anInvocation];
	}
}
BOOL
NSDictionary_inst_IsNotEqualTo(void* o, void* object) {
	BOOL ret;
	@autoreleasepool {
		ret = [(NSDictionary*)o isNotEqualTo:object];
	}
	return ret;

}
void* _Nonnull
NSDictionary_inst_ObjectEnumerator(void* o) {
	NSEnumerator* _Nonnull ret;
	@autoreleasepool {
		ret = [(NSDictionary*)o objectEnumerator];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
BOOL
NSDictionary_inst_IsProxy(void* o) {
	BOOL ret;
	@autoreleasepool {
		ret = [(NSDictionary*)o isProxy];
	}
	return ret;

}
void
NSDictionary_inst_RemoveValueAtIndexFromPropertyWithKey(void* o, NSUInteger index, void* key) {
	@autoreleasepool {
		[(NSDictionary*)o removeValueAtIndex:index fromPropertyWithKey:key];
	}
}
void* _Nonnull
NSDictionary_inst_ClassDescription(void* o) {
	NSClassDescription* _Nonnull ret;
	@autoreleasepool {
		ret = [(NSDictionary*)o classDescription];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
void
NSDictionary_inst_Release(void* o) {
	@autoreleasepool {
		[(NSDictionary*)o release];
	}
}
void* _Nonnull
NSDictionary_inst_MutableOrderedSetValueForKey(void* o, void* key) {
	NSMutableOrderedSet* _Nonnull ret;
	@autoreleasepool {
		ret = [(NSDictionary*)o mutableOrderedSetValueForKey:key];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
NSUInteger
NSDictionary_inst_RetainCount(void* o) {
	NSUInteger ret;
	@autoreleasepool {
		ret = [(NSDictionary*)o retainCount];
	}
	return ret;

}
void
NSDictionary_inst_SetObservationInfo(void* o, void* observationInfo) {
	@autoreleasepool {
		[(NSDictionary*)o setObservationInfo:observationInfo];
	}
}
void* _Nullable
NSDictionary_inst_ReplacementObjectForKeyedArchiver(void* o, void* archiver) {
	NSObject* _Nullable ret;
	@autoreleasepool {
		ret = [(NSDictionary*)o replacementObjectForKeyedArchiver:archiver];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
void* _Nonnull
NSDictionary_inst_DescriptionWithLocale(void* o, void* locale) {
	NSString* _Nonnull ret;
	@autoreleasepool {
		ret = [(NSDictionary*)o descriptionWithLocale:locale];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
void* _Nonnull
NSDictionary_inst_DescriptionWithLocaleIndent(void* o, void* locale, NSUInteger level) {
	NSString* _Nonnull ret;
	@autoreleasepool {
		ret = [(NSDictionary*)o descriptionWithLocale:locale indent:level];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
NSInteger
NSDictionary_inst_FileSystemNumber(void* o) {
	NSInteger ret;
	@autoreleasepool {
		ret = [(NSDictionary*)o fileSystemNumber];
	}
	return ret;

}
void* _Nullable
NSDictionary_inst_AwakeAfterUsingCoder(void* o, void* coder) {
	NSObject* _Nullable ret;
	@autoreleasepool {
		ret = [(NSDictionary*)o awakeAfterUsingCoder:coder];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
void*
NSDictionary_inst_ForwardingTargetForSelector(void* o, void* aSelector) {
	NSObject* ret;
	@autoreleasepool {
		ret = [(NSDictionary*)o forwardingTargetForSelector:aSelector];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
void
NSDictionary_inst_DidChangeValuesAtIndexes(void* o, NSKeyValueChange changeKind, void* indexes, void* key) {
	@autoreleasepool {
		[(NSDictionary*)o didChange:changeKind valuesAtIndexes:indexes forKey:key];
	}
}
void
NSDictionary_inst_DidChangeValuesAtIndexesForKey(void* o, NSKeyValueChange changeKind, void* indexes, void* key) {
	@autoreleasepool {
		[(NSDictionary*)o didChange:changeKind valuesAtIndexes:indexes forKey:key];
	}
}
BOOL
NSDictionary_inst_IsEqualToDictionary(void* o, void* otherDictionary) {
	BOOL ret;
	@autoreleasepool {
		ret = [(NSDictionary*)o isEqualToDictionary:otherDictionary];
	}
	return ret;

}
BOOL
NSDictionary_inst_FileExtensionHidden(void* o) {
	BOOL ret;
	@autoreleasepool {
		ret = [(NSDictionary*)o fileExtensionHidden];
	}
	return ret;

}
void
NSDictionary_inst_SetNilValueForKey(void* o, void* key) {
	@autoreleasepool {
		[(NSDictionary*)o setNilValueForKey:key];
	}
}
void* _Nonnull
NSDictionary_inst_MutableArrayValueForKey(void* o, void* key) {
	NSMutableArray* _Nonnull ret;
	@autoreleasepool {
		ret = [(NSDictionary*)o mutableArrayValueForKey:key];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
void* _Nullable
NSDictionary_inst_InverseForRelationshipKey(void* o, void* relationshipKey) {
	NSString* _Nullable ret;
	@autoreleasepool {
		ret = [(NSDictionary*)o inverseForRelationshipKey:relationshipKey];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
void*
NSDictionary_inst_MutableCopy(void* o) {
	NSObject* ret;
	@autoreleasepool {
		ret = [(NSDictionary*)o mutableCopy];
	}
	return ret;

}
void* _Nonnull
NSDictionary_inst_AllValues(void* o) {
	NSArray* _Nonnull ret;
	@autoreleasepool {
		ret = [(NSDictionary*)o allValues];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
void* _Nonnull
NSDictionary_inst_Description(void* o) {
	NSString* _Nonnull ret;
	@autoreleasepool {
		ret = [(NSDictionary*)o description];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
BOOL
NSDictionary_inst_ScriptingIsLessThanOrEqualTo(void* o, void* object) {
	BOOL ret;
	@autoreleasepool {
		ret = [(NSDictionary*)o scriptingIsLessThanOrEqualTo:object];
	}
	return ret;

}
void
NSDictionary_inst_SetValueForKey(void* o, void* value, void* key) {
	@autoreleasepool {
		[(NSDictionary*)o setValue:value forKey:key];
	}
}
void
NSDictionary_inst_SetValueForKeyPath(void* o, void* value, void* keyPath) {
	@autoreleasepool {
		[(NSDictionary*)o setValue:value forKeyPath:keyPath];
	}
}
void
NSDictionary_inst_SetValueForUndefinedKey(void* o, void* value, void* key) {
	@autoreleasepool {
		[(NSDictionary*)o setValue:value forUndefinedKey:key];
	}
}
void* _Nullable
NSDictionary_inst_ClassForArchiver(void* o) {
	Class _Nullable ret;
	@autoreleasepool {
		ret = [(NSDictionary*)o classForArchiver];
	}
	return ret;

}
void* _Nonnull
NSDictionary_inst_ToOneRelationshipKeys(void* o) {
	NSArray* _Nonnull ret;
	@autoreleasepool {
		ret = [(NSDictionary*)o toOneRelationshipKeys];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
BOOL
NSDictionary_inst_ValidateValueForKey(void* o, void** ioValue, void* inKey, void** outError) {
	BOOL ret;
	@autoreleasepool {
		ret = [(NSDictionary*)o validateValue:(id _Nullable* _Nonnull)ioValue forKey:inKey error:(NSError* _Nullable* _Nullable)outError];
		for(int i=0;i<1;i++) {
			if(ioValue[i] == 0) { break; }
			[(id)ioValue[i] retain];
		}
	
	
		for(int i=0;i<1;i++) {
			if(outError[i] == 0) { break; }
			[(id)outError[i] retain];
		}
	
	}
	return ret;

}
BOOL
NSDictionary_inst_ValidateValueForKeyPath(void* o, void** ioValue, void* inKeyPath, void** outError) {
	BOOL ret;
	@autoreleasepool {
		ret = [(NSDictionary*)o validateValue:(id _Nullable* _Nonnull)ioValue forKeyPath:inKeyPath error:(NSError* _Nullable* _Nullable)outError];
		for(int i=0;i<1;i++) {
			if(ioValue[i] == 0) { break; }
			[(id)ioValue[i] retain];
		}
	
	
		for(int i=0;i<1;i++) {
			if(outError[i] == 0) { break; }
			[(id)outError[i] retain];
		}
	
	}
	return ret;

}
BOOL
NSDictionary_inst_ValidateValueForKeyError(void* o, void** ioValue, void* inKey, void** outError) {
	BOOL ret;
	@autoreleasepool {
		ret = [(NSDictionary*)o validateValue:(id _Nullable* _Nonnull)ioValue forKey:inKey error:(NSError* _Nullable* _Nullable)outError];
		for(int i=0;i<1;i++) {
			if(ioValue[i] == 0) { break; }
			[(id)ioValue[i] retain];
		}
	
	
		for(int i=0;i<1;i++) {
			if(outError[i] == 0) { break; }
			[(id)outError[i] retain];
		}
	
	}
	return ret;

}
BOOL
NSDictionary_inst_ValidateValueForKeyPathError(void* o, void** ioValue, void* inKeyPath, void** outError) {
	BOOL ret;
	@autoreleasepool {
		ret = [(NSDictionary*)o validateValue:(id _Nullable* _Nonnull)ioValue forKeyPath:inKeyPath error:(NSError* _Nullable* _Nullable)outError];
		for(int i=0;i<1;i++) {
			if(ioValue[i] == 0) { break; }
			[(id)ioValue[i] retain];
		}
	
	
		for(int i=0;i<1;i++) {
			if(outError[i] == 0) { break; }
			[(id)outError[i] retain];
		}
	
	}
	return ret;

}
void*
NSDictionary_inst_Self(void* o) {
	NSDictionary* ret;
	@autoreleasepool {
		ret = [(NSDictionary*)o self];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
void* _Nullable
NSDictionary_inst_ValueWithNameInPropertyWithKey(void* o, void* name, void* key) {
	NSObject* _Nullable ret;
	@autoreleasepool {
		ret = [(NSDictionary*)o valueWithName:name inPropertyWithKey:key];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
void* _Nonnull
NSDictionary_inst_InitWithDictionary(void* o, void* otherDictionary) {
	NSDictionary* _Nonnull ret;
	@autoreleasepool {
		ret = [(NSDictionary*)o initWithDictionary:otherDictionary];
	}
	return ret;

}
void* _Nonnull
NSDictionary_inst_InitWithDictionaryCopyItems(void* o, void* otherDictionary, BOOL flag) {
	NSDictionary* _Nonnull ret;
	@autoreleasepool {
		ret = [(NSDictionary*)o initWithDictionary:otherDictionary copyItems:flag];
	}
	return ret;

}
void* _Nullable
NSDictionary_inst_InitWithCoder(void* o, void* coder) {
	NSDictionary* _Nullable ret;
	@autoreleasepool {
		ret = [(NSDictionary*)o initWithCoder:coder];
	}
	return ret;

}
BOOL
NSDictionary_inst_ScriptingIsGreaterThanOrEqualTo(void* o, void* object) {
	BOOL ret;
	@autoreleasepool {
		ret = [(NSDictionary*)o scriptingIsGreaterThanOrEqualTo:object];
	}
	return ret;

}
void
NSDictionary_inst_WillChangeValueForKey(void* o, void* key) {
	@autoreleasepool {
		[(NSDictionary*)o willChangeValueForKey:key];
	}
}
void
NSDictionary_inst_WillChangeValueForKeyWithSetMutation(void* o, void* key, NSKeyValueSetMutationKind mutationKind, void* objects) {
	@autoreleasepool {
		[(NSDictionary*)o willChangeValueForKey:key withSetMutation:mutationKind usingObjects:objects];
	}
}
void
NSDictionary_inst_WillChangeValueForKeyWithSetMutationUsingObjects(void* o, void* key, NSKeyValueSetMutationKind mutationKind, void* objects) {
	@autoreleasepool {
		[(NSDictionary*)o willChangeValueForKey:key withSetMutation:mutationKind usingObjects:objects];
	}
}
void
NSDictionary_inst_InsertValueInPropertyWithKey(void* o, void* value, void* key) {
	@autoreleasepool {
		[(NSDictionary*)o insertValue:value inPropertyWithKey:key];
	}
}
void
NSDictionary_inst_InsertValueAtIndex(void* o, void* value, NSUInteger index, void* key) {
	@autoreleasepool {
		[(NSDictionary*)o insertValue:value atIndex:index inPropertyWithKey:key];
	}
}
void
NSDictionary_inst_InsertValueAtIndexInPropertyWithKey(void* o, void* value, NSUInteger index, void* key) {
	@autoreleasepool {
		[(NSDictionary*)o insertValue:value atIndex:index inPropertyWithKey:key];
	}
}
void
NSDictionary_inst_ObserveValueForKeyPathOfObject(void* o, void* keyPath, void* object, void* change, void* context) {
	@autoreleasepool {
		[(NSDictionary*)o observeValueForKeyPath:keyPath ofObject:object change:change context:context];
	}
}
void
NSDictionary_inst_ObserveValueForKeyPathOfObjectChange(void* o, void* keyPath, void* object, void* change, void* context) {
	@autoreleasepool {
		[(NSDictionary*)o observeValueForKeyPath:keyPath ofObject:object change:change context:context];
	}
}
void* _Nullable
NSDictionary_inst_FileCreationDate(void* o) {
	NSDate* _Nullable ret;
	@autoreleasepool {
		ret = [(NSDictionary*)o fileCreationDate];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
NSUInteger
NSDictionary_inst_CountByEnumeratingWithStateObjects(void* o, void* state, void** buffer, NSUInteger len) {
	NSUInteger ret;
	@autoreleasepool {
		ret = [(NSDictionary*)o countByEnumeratingWithState:state objects:(id _Nullable* _Nonnull)buffer count:len];
		for(int i=0;i<len;i++) {
			if(buffer[i] == 0) { break; }
			[(id)buffer[i] retain];
		}
	
	}
	return ret;

}
NSUInteger
NSDictionary_inst_CountByEnumeratingWithStateObjectsCount(void* o, void* state, void** buffer, NSUInteger len) {
	NSUInteger ret;
	@autoreleasepool {
		ret = [(NSDictionary*)o countByEnumeratingWithState:state objects:(id _Nullable* _Nonnull)buffer count:len];
		for(int i=0;i<len;i++) {
			if(buffer[i] == 0) { break; }
			[(id)buffer[i] retain];
		}
	
	}
	return ret;

}
void* _Nullable
NSDictionary_inst_FileModificationDate(void* o) {
	NSDate* _Nullable ret;
	@autoreleasepool {
		ret = [(NSDictionary*)o fileModificationDate];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
void
NSDictionary_inst_SetScriptingProperties(void* o, void* scriptingProperties) {
	@autoreleasepool {
		[(NSDictionary*)o setScriptingProperties:scriptingProperties];
	}
}
BOOL
NSDictionary_inst_ScriptingIsGreaterThan(void* o, void* object) {
	BOOL ret;
	@autoreleasepool {
		ret = [(NSDictionary*)o scriptingIsGreaterThan:object];
	}
	return ret;

}
void
NSDictionary_inst_PerformSelectorOnMainThreadWithObject(void* o, void* aSelector, void* arg, BOOL wait) {
	@autoreleasepool {
		[(NSDictionary*)o performSelectorOnMainThread:aSelector withObject:arg waitUntilDone:wait];
	}
}
void
NSDictionary_inst_PerformSelectorOnMainThreadWithObjectWaitUntilDone(void* o, void* aSelector, void* arg, BOOL wait) {
	@autoreleasepool {
		[(NSDictionary*)o performSelectorOnMainThread:aSelector withObject:arg waitUntilDone:wait];
	}
}
void
NSDictionary_inst_PerformSelectorOnMainThreadWithObjectWaitUntilDoneModes(void* o, void* aSelector, void* arg, BOOL wait, void* array) {
	@autoreleasepool {
		[(NSDictionary*)o performSelectorOnMainThread:aSelector withObject:arg waitUntilDone:wait modes:array];
	}
}
void* _Nullable
NSDictionary_inst_ClassForKeyedArchiver(void* o) {
	Class _Nullable ret;
	@autoreleasepool {
		ret = [(NSDictionary*)o classForKeyedArchiver];
	}
	return ret;

}
NSUInteger
NSDictionary_inst_FilePosixPermissions(void* o) {
	NSUInteger ret;
	@autoreleasepool {
		ret = [(NSDictionary*)o filePosixPermissions];
	}
	return ret;

}
BOOL
NSDictionary_inst_IsGreaterThanOrEqualTo(void* o, void* object) {
	BOOL ret;
	@autoreleasepool {
		ret = [(NSDictionary*)o isGreaterThanOrEqualTo:object];
	}
	return ret;

}
BOOL
NSDictionary_inst_IsLessThan(void* o, void* object) {
	BOOL ret;
	@autoreleasepool {
		ret = [(NSDictionary*)o isLessThan:object];
	}
	return ret;

}
void* _Nullable
NSDictionary_inst_FileGroupOwnerAccountName(void* o) {
	NSString* _Nullable ret;
	@autoreleasepool {
		ret = [(NSDictionary*)o fileGroupOwnerAccountName];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}
BOOL
NSDictionary_inst_IsGreaterThan(void* o, void* object) {
	BOOL ret;
	@autoreleasepool {
		ret = [(NSDictionary*)o isGreaterThan:object];
	}
	return ret;

}
void*
NSDictionary_inst_Class(void* o) {
	Class ret;
	@autoreleasepool {
		ret = [(NSDictionary*)o class];
	}
	return ret;

}
BOOL
NSDictionary_inst_ScriptingIsEqualTo(void* o, void* object) {
	BOOL ret;
	@autoreleasepool {
		ret = [(NSDictionary*)o scriptingIsEqualTo:object];
	}
	return ret;

}
void* _Nonnull
NSDictionary_inst_DictionaryWithValuesForKeys(void* o, void* keys) {
	NSDictionary* _Nonnull ret;
	@autoreleasepool {
		ret = [(NSDictionary*)o dictionaryWithValuesForKeys:keys];
		if (ret != nil && ret != o) { [ret retain]; }
	}
	return ret;

}

void CBDelegateCentralManagerDidConnectPeripheral(void*, void*, void*);
void CBDelegateCentralManagerDidDisconnectPeripheral(void*, void*, void*, void*);
void CBDelegateCentralManagerDidDiscoverPeripheral(void*, void*, void*, void*, void*);
void CBDelegateCentralManagerDidUpdateState(void*, void*);
void CBDelegatePeripheralDidDiscoverServices(void*, void*, void*);
void CBDelegatePeripheralDidDiscoverCharacteristicsForService(void*, void*, void*, void*);
void CBDelegatePeripheralDidUpdateValueForCharacteristic(void*, void*, void*, void*);

@interface CBDelegate : NSObject <CBCentralManagerDelegate, CBPeripheralDelegate>
{ }
- (void)centralManager:(CBCentralManager* _Nonnull)central didConnectPeripheral:(CBPeripheral* _Nonnull)peripheral;
- (void)centralManager:(CBCentralManager* _Nonnull)central didDisconnectPeripheral:(CBPeripheral* _Nonnull)peripheral error:(NSError* _Nullable)error;
- (void)centralManager:(CBCentralManager* _Nonnull)central didDiscoverPeripheral:(CBPeripheral* _Nonnull)peripheral advertisementData:(NSDictionary <NSString*, id>* _Nonnull)advertisementData RSSI:(NSNumber* _Nonnull)RSSI;
- (void)centralManagerDidUpdateState:(CBCentralManager* _Nonnull)central;
- (void)peripheral:(CBPeripheral* _Nonnull)peripheral didDiscoverServices:(NSError* _Nullable)error;
- (void)peripheral:(CBPeripheral* _Nonnull)peripheral didDiscoverCharacteristicsForService:(CBService* _Nonnull)service error:(NSError* _Nullable)error;
- (void)peripheral:(CBPeripheral* _Nonnull)peripheral didUpdateValueForCharacteristic:(CBCharacteristic* _Nonnull)characteristic error:(NSError* _Nullable)error;

@end

@implementation CBDelegate

- (void)centralManager:(CBCentralManager* _Nonnull)central didConnectPeripheral:(CBPeripheral* _Nonnull)peripheral
{
	CBDelegateCentralManagerDidConnectPeripheral(self, central, peripheral);
}


- (void)centralManager:(CBCentralManager* _Nonnull)central didDisconnectPeripheral:(CBPeripheral* _Nonnull)peripheral error:(NSError* _Nullable)error
{
	CBDelegateCentralManagerDidDisconnectPeripheral(self, central, peripheral, error);
}


- (void)centralManager:(CBCentralManager* _Nonnull)central didDiscoverPeripheral:(CBPeripheral* _Nonnull)peripheral advertisementData:(NSDictionary <NSString*, id>* _Nonnull)advertisementData RSSI:(NSNumber* _Nonnull)RSSI
{
	CBDelegateCentralManagerDidDiscoverPeripheral(self, central, peripheral, advertisementData, RSSI);
}


- (void)centralManagerDidUpdateState:(CBCentralManager* _Nonnull)central
{
	NSLog(@"centralManagerDidUpdateState");
	CBDelegateCentralManagerDidUpdateState(self, central);
}


- (void)peripheral:(CBPeripheral* _Nonnull)peripheral didDiscoverServices:(NSError* _Nullable)error
{
	CBDelegatePeripheralDidDiscoverServices(self, peripheral, error);
}


- (void)peripheral:(CBPeripheral* _Nonnull)peripheral didDiscoverCharacteristicsForService:(CBService* _Nonnull)service error:(NSError* _Nullable)error
{
	CBDelegatePeripheralDidDiscoverCharacteristicsForService(self, peripheral, service, error);
}


- (void)peripheral:(CBPeripheral* _Nonnull)peripheral didUpdateValueForCharacteristic:(CBCharacteristic* _Nonnull)characteristic error:(NSError* _Nullable)error
{
	CBDelegatePeripheralDidUpdateValueForCharacteristic(self, peripheral, characteristic, error);
}


@end

void*
CBDelegateAlloc() {
	return [CBDelegate alloc];
}

void
CBDelegate_inst_CentralManagerWillRestoreState(void* o, void* central, void* dict) {
	@autoreleasepool {
		[(CBDelegate*)o centralManager:central willRestoreState:dict];
	}
}
void
CBDelegate_inst_CentralManagerDidFailToConnectPeripheral(void* o, void* central, void* peripheral, void* error) {
	@autoreleasepool {
		[(CBDelegate*)o centralManager:central didFailToConnectPeripheral:peripheral error:error];
	}
}
void
CBDelegate_inst_PeripheralDidUpdateName(void* o, void* peripheral) {
	@autoreleasepool {
		[(CBDelegate*)o peripheralDidUpdateName:peripheral];
	}
}
void
CBDelegate_inst_PeripheralDidModifyServices(void* o, void* peripheral, void* invalidatedServices) {
	@autoreleasepool {
		[(CBDelegate*)o peripheral:peripheral didModifyServices:invalidatedServices];
	}
}
void
CBDelegate_inst_PeripheralDidReadRSSI(void* o, void* peripheral, void* RSSI, void* error) {
	@autoreleasepool {
		[(CBDelegate*)o peripheral:peripheral didReadRSSI:RSSI error:error];
	}
}
void
CBDelegate_inst_PeripheralDidDiscoverIncludedServicesForService(void* o, void* peripheral, void* service, void* error) {
	@autoreleasepool {
		[(CBDelegate*)o peripheral:peripheral didDiscoverIncludedServicesForService:service error:error];
	}
}
void
CBDelegate_inst_PeripheralDidWriteValueForCharacteristic(void* o, void* peripheral, void* characteristic, void* error) {
	@autoreleasepool {
		[(CBDelegate*)o peripheral:peripheral didWriteValueForCharacteristic:characteristic error:error];
	}
}
void
CBDelegate_inst_PeripheralDidUpdateNotificationStateForCharacteristic(void* o, void* peripheral, void* characteristic, void* error) {
	@autoreleasepool {
		[(CBDelegate*)o peripheral:peripheral didUpdateNotificationStateForCharacteristic:characteristic error:error];
	}
}
void
CBDelegate_inst_PeripheralDidDiscoverDescriptorsForCharacteristic(void* o, void* peripheral, void* characteristic, void* error) {
	@autoreleasepool {
		[(CBDelegate*)o peripheral:peripheral didDiscoverDescriptorsForCharacteristic:characteristic error:error];
	}
}
void
CBDelegate_inst_PeripheralDidUpdateValueForDescriptor(void* o, void* peripheral, void* descriptor, void* error) {
	@autoreleasepool {
		[(CBDelegate*)o peripheral:peripheral didUpdateValueForDescriptor:descriptor error:error];
	}
}
void
CBDelegate_inst_PeripheralDidWriteValueForDescriptor(void* o, void* peripheral, void* descriptor, void* error) {
	@autoreleasepool {
		[(CBDelegate*)o peripheral:peripheral didWriteValueForDescriptor:descriptor error:error];
	}
}
void
CBDelegate_inst_PeripheralDidOpenL2CAPChannel(void* o, void* peripheral, void* channel, void* error) {
	@autoreleasepool {
		[(CBDelegate*)o peripheral:peripheral didOpenL2CAPChannel:channel error:error];
	}
}
void
CBDelegate_inst_PeripheralIsReadyToSendWriteWithoutResponse(void* o, void* peripheral) {
	@autoreleasepool {
		[(CBDelegate*)o peripheralIsReadyToSendWriteWithoutResponse:peripheral];
	}
}
void
NSWrap_init() {
	NSLog(@"Thread start");
	[[NSThread new] start]; // put the runtime into multi-threaded mode
	NSLog(@"Thread started");
}

*/
import "C"

import (
	"runtime"
	"sync"
	"unsafe"
	"log"
)

func init() {
	C.NSWrap_init()
}

type Id struct {
	ptr unsafe.Pointer
}
func (o *Id) Ptr() unsafe.Pointer { if o == nil { return nil }; return o.ptr }

type NSObject interface {
	Ptr() unsafe.Pointer
}

type NSUUID struct { Id }
func (o *NSUUID) Ptr() unsafe.Pointer { if o == nil { return nil }; return o.ptr }
func (o *Id) NSUUID() *NSUUID {
	return (*NSUUID)(unsafe.Pointer(o))
}

type BOOL C.bool

type Class *C.struct_objc_class

type _NSZone = C.struct__NSZone

type NSSet struct { Id }
func (o *NSSet) Ptr() unsafe.Pointer { if o == nil { return nil }; return o.ptr }
func (o *Id) NSSet() *NSSet {
	return (*NSSet)(unsafe.Pointer(o))
}

type NSString struct { Id }
func (o *NSString) Ptr() unsafe.Pointer { if o == nil { return nil }; return o.ptr }
func (o *Id) NSString() *NSString {
	return (*NSString)(unsafe.Pointer(o))
}

type NSMethodSignature struct { Id }
func (o *NSMethodSignature) Ptr() unsafe.Pointer { if o == nil { return nil }; return o.ptr }
func (o *Id) NSMethodSignature() *NSMethodSignature {
	return (*NSMethodSignature)(unsafe.Pointer(o))
}

type SEL *C.struct_objc_selector

type NSInteger C.long

type Protocol interface {
	Ptr() unsafe.Pointer
}

type NSUInteger C.ulong

type NSArray struct { Id }
func (o *NSArray) Ptr() unsafe.Pointer { if o == nil { return nil }; return o.ptr }
func (o *Id) NSArray() *NSArray {
	return (*NSArray)(unsafe.Pointer(o))
}

type NSMutableArray struct { NSArray }
func (o *NSMutableArray) Ptr() unsafe.Pointer { if o == nil { return nil }; return o.ptr }
func (o *Id) NSMutableArray() *NSMutableArray {
	return (*NSMutableArray)(unsafe.Pointer(o))
}

type NSDictionary struct { Id }
func (o *NSDictionary) Ptr() unsafe.Pointer { if o == nil { return nil }; return o.ptr }
func (o *Id) NSDictionary() *NSDictionary {
	return (*NSDictionary)(unsafe.Pointer(o))
}

type UnsignedChar C.uchar

type NSOrderedSet struct { Id }
func (o *NSOrderedSet) Ptr() unsafe.Pointer { if o == nil { return nil }; return o.ptr }
func (o *Id) NSOrderedSet() *NSOrderedSet {
	return (*NSOrderedSet)(unsafe.Pointer(o))
}

type NSMutableOrderedSet struct { NSOrderedSet }
func (o *NSMutableOrderedSet) Ptr() unsafe.Pointer { if o == nil { return nil }; return o.ptr }
func (o *Id) NSMutableOrderedSet() *NSMutableOrderedSet {
	return (*NSMutableOrderedSet)(unsafe.Pointer(o))
}

type NSKeyValueChange C.enum_NSKeyValueChange

type NSIndexSet struct { Id }
func (o *NSIndexSet) Ptr() unsafe.Pointer { if o == nil { return nil }; return o.ptr }
func (o *Id) NSIndexSet() *NSIndexSet {
	return (*NSIndexSet)(unsafe.Pointer(o))
}

type FourCharCode C.UInt32

type NSClassDescription struct { Id }
func (o *NSClassDescription) Ptr() unsafe.Pointer { if o == nil { return nil }; return o.ptr }
func (o *Id) NSClassDescription() *NSClassDescription {
	return (*NSClassDescription)(unsafe.Pointer(o))
}

type NSCoder struct { Id }
func (o *NSCoder) Ptr() unsafe.Pointer { if o == nil { return nil }; return o.ptr }
func (o *Id) NSCoder() *NSCoder {
	return (*NSCoder)(unsafe.Pointer(o))
}

type NSKeyedArchiver struct { NSCoder }
func (o *NSKeyedArchiver) Ptr() unsafe.Pointer { if o == nil { return nil }; return o.ptr }
func (o *Id) NSKeyedArchiver() *NSKeyedArchiver {
	return (*NSKeyedArchiver)(unsafe.Pointer(o))
}

type NSScriptObjectSpecifier struct { Id }
func (o *NSScriptObjectSpecifier) Ptr() unsafe.Pointer { if o == nil { return nil }; return o.ptr }
func (o *Id) NSScriptObjectSpecifier() *NSScriptObjectSpecifier {
	return (*NSScriptObjectSpecifier)(unsafe.Pointer(o))
}

type NSKeyValueSetMutationKind C.enum_NSKeyValueSetMutationKind

type NSZone = C.struct__NSZone

type NSMutableSet struct { NSSet }
func (o *NSMutableSet) Ptr() unsafe.Pointer { if o == nil { return nil }; return o.ptr }
func (o *Id) NSMutableSet() *NSMutableSet {
	return (*NSMutableSet)(unsafe.Pointer(o))
}

type NSInvocation struct { Id }
func (o *NSInvocation) Ptr() unsafe.Pointer { if o == nil { return nil }; return o.ptr }
func (o *Id) NSInvocation() *NSInvocation {
	return (*NSInvocation)(unsafe.Pointer(o))
}

type NSTimeInterval C.double

type NSThread struct { Id }
func (o *NSThread) Ptr() unsafe.Pointer { if o == nil { return nil }; return o.ptr }
func (o *Id) NSThread() *NSThread {
	return (*NSThread)(unsafe.Pointer(o))
}

type NSKeyValueObservingOptions C.enum_NSKeyValueObservingOptions

type NSError struct { Id }
func (o *NSError) Ptr() unsafe.Pointer { if o == nil { return nil }; return o.ptr }
func (o *Id) NSError() *NSError {
	return (*NSError)(unsafe.Pointer(o))
}

type CBManager struct { Id }
func (o *CBManager) Ptr() unsafe.Pointer { if o == nil { return nil }; return o.ptr }
func (o *Id) CBManager() *CBManager {
	return (*CBManager)(unsafe.Pointer(o))
}

type CBCentralManager struct { CBManager }
func (o *CBCentralManager) Ptr() unsafe.Pointer { if o == nil { return nil }; return o.ptr }
func (o *Id) CBCentralManager() *CBCentralManager {
	return (*CBCentralManager)(unsafe.Pointer(o))
}

type CBManagerAuthorization C.enum_CBManagerAuthorization

type CBManagerState C.enum_CBManagerState

type Dispatch_queue_t = *Id

type CBPeer struct { Id }
func (o *CBPeer) Ptr() unsafe.Pointer { if o == nil { return nil }; return o.ptr }
func (o *Id) CBPeer() *CBPeer {
	return (*CBPeer)(unsafe.Pointer(o))
}

type CBPeripheral struct { CBPeer }
func (o *CBPeripheral) Ptr() unsafe.Pointer { if o == nil { return nil }; return o.ptr }
func (o *Id) CBPeripheral() *CBPeripheral {
	return (*CBPeripheral)(unsafe.Pointer(o))
}

type CBAttribute struct { Id }
func (o *CBAttribute) Ptr() unsafe.Pointer { if o == nil { return nil }; return o.ptr }
func (o *Id) CBAttribute() *CBAttribute {
	return (*CBAttribute)(unsafe.Pointer(o))
}

type CBCharacteristic struct { CBAttribute }
func (o *CBCharacteristic) Ptr() unsafe.Pointer { if o == nil { return nil }; return o.ptr }
func (o *Id) CBCharacteristic() *CBCharacteristic {
	return (*CBCharacteristic)(unsafe.Pointer(o))
}

type NSData struct { Id }
func (o *NSData) Ptr() unsafe.Pointer { if o == nil { return nil }; return o.ptr }
func (o *Id) NSData() *NSData {
	return (*NSData)(unsafe.Pointer(o))
}

type CBCharacteristicProperties C.enum_CBCharacteristicProperties

type CBUUID struct { Id }
func (o *CBUUID) Ptr() unsafe.Pointer { if o == nil { return nil }; return o.ptr }
func (o *Id) CBUUID() *CBUUID {
	return (*CBUUID)(unsafe.Pointer(o))
}

type CBService struct { CBAttribute }
func (o *CBService) Ptr() unsafe.Pointer { if o == nil { return nil }; return o.ptr }
func (o *Id) CBService() *CBService {
	return (*CBService)(unsafe.Pointer(o))
}

type NSURL struct { Id }
func (o *NSURL) Ptr() unsafe.Pointer { if o == nil { return nil }; return o.ptr }
func (o *Id) NSURL() *NSURL {
	return (*NSURL)(unsafe.Pointer(o))
}

type NSRange = C.struct__NSRange

type NSOrderedCollectionDifference struct { Id }
func (o *NSOrderedCollectionDifference) Ptr() unsafe.Pointer { if o == nil { return nil }; return o.ptr }
func (o *Id) NSOrderedCollectionDifference() *NSOrderedCollectionDifference {
	return (*NSOrderedCollectionDifference)(unsafe.Pointer(o))
}

type NSOrderedCollectionDifferenceCalculationOptions C.enum_NSOrderedCollectionDifferenceCalculationOptions

type NSEnumerator struct { Id }
func (o *NSEnumerator) Ptr() unsafe.Pointer { if o == nil { return nil }; return o.ptr }
func (o *Id) NSEnumerator() *NSEnumerator {
	return (*NSEnumerator)(unsafe.Pointer(o))
}

type NSFastEnumerationState = C.struct_NSFastEnumerationState

type NSPredicate struct { Id }
func (o *NSPredicate) Ptr() unsafe.Pointer { if o == nil { return nil }; return o.ptr }
func (o *Id) NSPredicate() *NSPredicate {
	return (*NSPredicate)(unsafe.Pointer(o))
}

type NSAutoreleasePool struct { Id }
func (o *NSAutoreleasePool) Ptr() unsafe.Pointer { if o == nil { return nil }; return o.ptr }
func (o *Id) NSAutoreleasePool() *NSAutoreleasePool {
	return (*NSAutoreleasePool)(unsafe.Pointer(o))
}

type CBDescriptor struct { CBAttribute }
func (o *CBDescriptor) Ptr() unsafe.Pointer { if o == nil { return nil }; return o.ptr }
func (o *Id) CBDescriptor() *CBDescriptor {
	return (*CBDescriptor)(unsafe.Pointer(o))
}

type NSValue struct { Id }
func (o *NSValue) Ptr() unsafe.Pointer { if o == nil { return nil }; return o.ptr }
func (o *Id) NSValue() *NSValue {
	return (*NSValue)(unsafe.Pointer(o))
}

type NSNumber struct { NSValue }
func (o *NSNumber) Ptr() unsafe.Pointer { if o == nil { return nil }; return o.ptr }
func (o *Id) NSNumber() *NSNumber {
	return (*NSNumber)(unsafe.Pointer(o))
}

type UnsignedShort C.ushort

type Char C.char

type Double C.double

type NSSize C.CGSize

type UnsignedLong C.ulong

type Long C.long

type LongLong C.longlong

type Float C.float

type UnsignedLongLong C.ulonglong

type NSEdgeInsets = C.struct_NSEdgeInsets

type NSPoint C.CGPoint

type UnsignedInt C.uint

type Short C.short

type Int C.int

type NSRect C.CGRect

type NSComparisonResult C.enum_NSComparisonResult

type NSDecimal = C.struct_NSDecimal

type CBPeripheralManager struct { CBManager }
func (o *CBPeripheralManager) Ptr() unsafe.Pointer { if o == nil { return nil }; return o.ptr }
func (o *Id) CBPeripheralManager() *CBPeripheralManager {
	return (*CBPeripheralManager)(unsafe.Pointer(o))
}

type CBMutableService struct { CBService }
func (o *CBMutableService) Ptr() unsafe.Pointer { if o == nil { return nil }; return o.ptr }
func (o *Id) CBMutableService() *CBMutableService {
	return (*CBMutableService)(unsafe.Pointer(o))
}

type CBPeripheralManagerConnectionLatency C.enum_CBPeripheralManagerConnectionLatency

type CBCentral struct { CBPeer }
func (o *CBCentral) Ptr() unsafe.Pointer { if o == nil { return nil }; return o.ptr }
func (o *Id) CBCentral() *CBCentral {
	return (*CBCentral)(unsafe.Pointer(o))
}

type CBL2CAPPSM C.uint16_t

type CBMutableCharacteristic struct { CBCharacteristic }
func (o *CBMutableCharacteristic) Ptr() unsafe.Pointer { if o == nil { return nil }; return o.ptr }
func (o *Id) CBMutableCharacteristic() *CBMutableCharacteristic {
	return (*CBMutableCharacteristic)(unsafe.Pointer(o))
}

type CBATTRequest struct { Id }
func (o *CBATTRequest) Ptr() unsafe.Pointer { if o == nil { return nil }; return o.ptr }
func (o *Id) CBATTRequest() *CBATTRequest {
	return (*CBATTRequest)(unsafe.Pointer(o))
}

type CBATTError C.enum_CBATTError

type CBCharacteristicWriteType C.enum_CBCharacteristicWriteType

type CBPeripheralState C.enum_CBPeripheralState

type NSStringEncoding C.NSUInteger

type Unichar C.ushort

type NSItemProviderRepresentationVisibility C.enum_NSItemProviderRepresentationVisibility

type NSCharacterSet struct { Id }
func (o *NSCharacterSet) Ptr() unsafe.Pointer { if o == nil { return nil }; return o.ptr }
func (o *Id) NSCharacterSet() *NSCharacterSet {
	return (*NSCharacterSet)(unsafe.Pointer(o))
}

type NSStringCompareOptions C.enum_NSStringCompareOptions

type NSStringEncodingConversionOptions C.enum_NSStringEncodingConversionOptions

type NSRangePointer *C.NSRange

type NSLocale struct { Id }
func (o *NSLocale) Ptr() unsafe.Pointer { if o == nil { return nil }; return o.ptr }
func (o *Id) NSLocale() *NSLocale {
	return (*NSLocale)(unsafe.Pointer(o))
}

type NSStringTransform = *NSString

type Va_list C.__darwin_va_list

type NSDataReadingOptions C.enum_NSDataReadingOptions

type NSDataBase64EncodingOptions C.enum_NSDataBase64EncodingOptions

type NSDataBase64DecodingOptions C.enum_NSDataBase64DecodingOptions

type NSDataWritingOptions C.enum_NSDataWritingOptions

type NSDataCompressionAlgorithm C.enum_NSDataCompressionAlgorithm

type NSDataSearchOptions C.enum_NSDataSearchOptions

type OSType C.FourCharCode

type NSDate struct { Id }
func (o *NSDate) Ptr() unsafe.Pointer { if o == nil { return nil }; return o.ptr }
func (o *Id) NSDate() *NSDate {
	return (*NSDate)(unsafe.Pointer(o))
}

type Dispatch_queue_attr_t = *Id

type CBDelegate struct { Id }
func (o *CBDelegate) Ptr() unsafe.Pointer { if o == nil { return nil }; return o.ptr }
func (o *Id) CBDelegate() *CBDelegate {
	return (*CBDelegate)(unsafe.Pointer(o))
}

type CBL2CAPChannel struct { Id }
func (o *CBL2CAPChannel) Ptr() unsafe.Pointer { if o == nil { return nil }; return o.ptr }
func (o *Id) CBL2CAPChannel() *CBL2CAPChannel {
	return (*CBL2CAPChannel)(unsafe.Pointer(o))
}
const CBConnectionEventPeerDisconnected NSInteger = C.CBConnectionEventPeerDisconnected
const CBConnectionEventPeerConnected NSInteger = C.CBConnectionEventPeerConnected

const CBErrorUnknown NSInteger = C.CBErrorUnknown
const CBErrorInvalidParameters NSInteger = C.CBErrorInvalidParameters
const CBErrorInvalidHandle NSInteger = C.CBErrorInvalidHandle
const CBErrorNotConnected NSInteger = C.CBErrorNotConnected
const CBErrorOutOfSpace NSInteger = C.CBErrorOutOfSpace
const CBErrorOperationCancelled NSInteger = C.CBErrorOperationCancelled
const CBErrorConnectionTimeout NSInteger = C.CBErrorConnectionTimeout
const CBErrorPeripheralDisconnected NSInteger = C.CBErrorPeripheralDisconnected
const CBErrorUUIDNotAllowed NSInteger = C.CBErrorUUIDNotAllowed
const CBErrorAlreadyAdvertising NSInteger = C.CBErrorAlreadyAdvertising
const CBErrorConnectionFailed NSInteger = C.CBErrorConnectionFailed
const CBErrorConnectionLimitReached NSInteger = C.CBErrorConnectionLimitReached
const CBErrorUnkownDevice NSInteger = C.CBErrorUnkownDevice
const CBErrorUnknownDevice NSInteger = C.CBErrorUnknownDevice
const CBErrorOperationNotSupported NSInteger = C.CBErrorOperationNotSupported
const CBErrorPeerRemovedPairingInformation NSInteger = C.CBErrorPeerRemovedPairingInformation
const CBErrorEncryptionTimedOut NSInteger = C.CBErrorEncryptionTimedOut
const CBErrorTooManyLEPairedDevices NSInteger = C.CBErrorTooManyLEPairedDevices

const CBATTErrorSuccess NSInteger = C.CBATTErrorSuccess
const CBATTErrorInvalidHandle NSInteger = C.CBATTErrorInvalidHandle
const CBATTErrorReadNotPermitted NSInteger = C.CBATTErrorReadNotPermitted
const CBATTErrorWriteNotPermitted NSInteger = C.CBATTErrorWriteNotPermitted
const CBATTErrorInvalidPdu NSInteger = C.CBATTErrorInvalidPdu
const CBATTErrorInsufficientAuthentication NSInteger = C.CBATTErrorInsufficientAuthentication
const CBATTErrorRequestNotSupported NSInteger = C.CBATTErrorRequestNotSupported
const CBATTErrorInvalidOffset NSInteger = C.CBATTErrorInvalidOffset
const CBATTErrorInsufficientAuthorization NSInteger = C.CBATTErrorInsufficientAuthorization
const CBATTErrorPrepareQueueFull NSInteger = C.CBATTErrorPrepareQueueFull
const CBATTErrorAttributeNotFound NSInteger = C.CBATTErrorAttributeNotFound
const CBATTErrorAttributeNotLong NSInteger = C.CBATTErrorAttributeNotLong
const CBATTErrorInsufficientEncryptionKeySize NSInteger = C.CBATTErrorInsufficientEncryptionKeySize
const CBATTErrorInvalidAttributeValueLength NSInteger = C.CBATTErrorInvalidAttributeValueLength
const CBATTErrorUnlikelyError NSInteger = C.CBATTErrorUnlikelyError
const CBATTErrorInsufficientEncryption NSInteger = C.CBATTErrorInsufficientEncryption
const CBATTErrorUnsupportedGroupType NSInteger = C.CBATTErrorUnsupportedGroupType
const CBATTErrorInsufficientResources NSInteger = C.CBATTErrorInsufficientResources

const CBPeripheralManagerConnectionLatencyLow NSInteger = C.CBPeripheralManagerConnectionLatencyLow
const CBPeripheralManagerConnectionLatencyMedium NSInteger = C.CBPeripheralManagerConnectionLatencyMedium
const CBPeripheralManagerConnectionLatencyHigh NSInteger = C.CBPeripheralManagerConnectionLatencyHigh

const CBPeripheralStateDisconnected NSInteger = C.CBPeripheralStateDisconnected
const CBPeripheralStateConnecting NSInteger = C.CBPeripheralStateConnecting
const CBPeripheralStateConnected NSInteger = C.CBPeripheralStateConnected
const CBPeripheralStateDisconnecting NSInteger = C.CBPeripheralStateDisconnecting

const CBManagerStateUnknown NSInteger = C.CBManagerStateUnknown
const CBManagerStateResetting NSInteger = C.CBManagerStateResetting
const CBManagerStateUnsupported NSInteger = C.CBManagerStateUnsupported
const CBManagerStateUnauthorized NSInteger = C.CBManagerStateUnauthorized
const CBManagerStatePoweredOff NSInteger = C.CBManagerStatePoweredOff
const CBManagerStatePoweredOn NSInteger = C.CBManagerStatePoweredOn

const CBManagerAuthorizationNotDetermined NSInteger = C.CBManagerAuthorizationNotDetermined
const CBManagerAuthorizationRestricted NSInteger = C.CBManagerAuthorizationRestricted
const CBManagerAuthorizationDenied NSInteger = C.CBManagerAuthorizationDenied
const CBManagerAuthorizationAllowedAlways NSInteger = C.CBManagerAuthorizationAllowedAlways

const CBCharacteristicWriteWithResponse NSInteger = C.CBCharacteristicWriteWithResponse
const CBCharacteristicWriteWithoutResponse NSInteger = C.CBCharacteristicWriteWithoutResponse

const CBCharacteristicPropertyBroadcast NSUInteger = C.CBCharacteristicPropertyBroadcast
const CBCharacteristicPropertyRead NSUInteger = C.CBCharacteristicPropertyRead
const CBCharacteristicPropertyWriteWithoutResponse NSUInteger = C.CBCharacteristicPropertyWriteWithoutResponse
const CBCharacteristicPropertyWrite NSUInteger = C.CBCharacteristicPropertyWrite
const CBCharacteristicPropertyNotify NSUInteger = C.CBCharacteristicPropertyNotify
const CBCharacteristicPropertyIndicate NSUInteger = C.CBCharacteristicPropertyIndicate
const CBCharacteristicPropertyAuthenticatedSignedWrites NSUInteger = C.CBCharacteristicPropertyAuthenticatedSignedWrites
const CBCharacteristicPropertyExtendedProperties NSUInteger = C.CBCharacteristicPropertyExtendedProperties
const CBCharacteristicPropertyNotifyEncryptionRequired NSUInteger = C.CBCharacteristicPropertyNotifyEncryptionRequired
const CBCharacteristicPropertyIndicateEncryptionRequired NSUInteger = C.CBCharacteristicPropertyIndicateEncryptionRequired

const CBAttributePermissionsReadable NSUInteger = C.CBAttributePermissionsReadable
const CBAttributePermissionsWriteable NSUInteger = C.CBAttributePermissionsWriteable
const CBAttributePermissionsReadEncryptionRequired NSUInteger = C.CBAttributePermissionsReadEncryptionRequired
const CBAttributePermissionsWriteEncryptionRequired NSUInteger = C.CBAttributePermissionsWriteEncryptionRequired


func Selector(s string) SEL {
	return (SEL)(unsafe.Pointer(C.selectorFromString(C.CString(s))))
}

func (e *NSEnumerator) ForIn(f func(*Id) bool) {
	for o := e.NextObject(); o.Ptr() != nil; o = e.NextObject() {
		if !f(o) { break }
	}
}

func Autoreleasepool(f func()) {
	pool := NSAutoreleasePoolAlloc().Init()
	f()
	pool.Drain()
}

func CharWithGoString(s string) *Char {
	return (*Char)(unsafe.Pointer(C.CString(s)))
}

func CharWithBytes(b []byte) *Char {
	return (*Char)(unsafe.Pointer(C.CString(string(b))))
}

func (c *Char) String() string {
	return C.GoString((*C.char)(c))
}

func (c *Char) Free() {
	C.free(unsafe.Pointer(c))
}

func (o *NSString) String() string {
	utf8 := o.UTF8String()
	ret := utf8.String()
	utf8.Free()
	runtime.KeepAlive(o)
	return ret
}

func NSUUIDIsSubclassOfClass(aClass Class) bool {
	ret := (bool)(C.NSUUID_IsSubclassOfClass(unsafe.Pointer(aClass)))
	return ret
}

func NSUUIDAlloc() *NSUUID {
	ret := &NSUUID{}
	ret.ptr = unsafe.Pointer(C.NSUUID_Alloc())
	if ret.ptr == nil { return ret }
	runtime.SetFinalizer(ret, func(o *NSUUID) {
		o.Release()
	})
	return ret
}

func (o *NSUUID) GC() {
	if o.ptr == nil { return }
	runtime.SetFinalizer(o, func(o *NSUUID) {
		o.Release()
	})
	runtime.KeepAlive(o)
}

func NSUUIDCopyWithZone(zone *_NSZone) *Id {
	ret := &Id{}
	ret.ptr = unsafe.Pointer(C.NSUUID_CopyWithZone(unsafe.Pointer(zone)))
	if ret.ptr == nil { return ret }
	runtime.SetFinalizer(ret, func(o *Id) {
		o.Release()
	})
	return ret
}

func NSUUIDMutableCopyWithZone(zone *_NSZone) *Id {
	ret := &Id{}
	ret.ptr = unsafe.Pointer(C.NSUUID_MutableCopyWithZone(unsafe.Pointer(zone)))
	if ret.ptr == nil { return ret }
	runtime.SetFinalizer(ret, func(o *Id) {
		o.Release()
	})
	return ret
}

func NSUUIDNew() *NSUUID {
	ret := &NSUUID{}
	ret.ptr = unsafe.Pointer(C.NSUUID_New())
	if ret.ptr == nil { return ret }
	runtime.SetFinalizer(ret, func(o *NSUUID) {
		o.Release()
	})
	return ret
}

func NSUUIDKeyPathsForValuesAffectingValueForKey(key *NSString) *NSSet {
	ret := &NSSet{}
	ret.ptr = unsafe.Pointer(C.NSUUID_KeyPathsForValuesAffectingValueForKey(key.Ptr()))
	if ret.ptr == nil { return ret }
	return ret
}

func NSUUIDUUID() *NSUUID {
	ret := &NSUUID{}
	ret.ptr = unsafe.Pointer(C.NSUUID_UUID())
	if ret.ptr == nil { return ret }
	runtime.SetFinalizer(ret, func(o *NSUUID) {
		o.Release()
	})
	return ret
}

func NSUUIDInstanceMethodSignatureForSelector(aSelector SEL) *NSMethodSignature {
	ret := &NSMethodSignature{}
	ret.ptr = unsafe.Pointer(C.NSUUID_InstanceMethodSignatureForSelector(unsafe.Pointer(aSelector)))
	if ret.ptr == nil { return ret }
	return ret
}

func NSUUIDClass() Class {
	ret := (Class)(unsafe.Pointer(C.NSUUID_Class()))
	return ret
}

func NSUUIDLoad()  {
	C.NSUUID_Load()
}

func NSUUIDebugDescription() *NSString {
	ret := &NSString{}
	ret.ptr = unsafe.Pointer(C.NSUUID_DebugDescription())
	if ret.ptr == nil { return ret }
	runtime.SetFinalizer(ret, func(o *NSString) {
		o.Release()
	})
	return ret
}

func NSUUIDVersion() NSInteger {
	ret := (NSInteger)(C.NSUUID_Version())
	return ret
}

func NSUUIDSetVersion(aVersion NSInteger)  {
	C.NSUUID_SetVersion((C.NSInteger)(aVersion))
}

func NSUUIDInstancesRespondToSelector(aSelector SEL) bool {
	ret := (bool)(C.NSUUID_InstancesRespondToSelector(unsafe.Pointer(aSelector)))
	return ret
}

func NSUUIDClassForKeyedUnarchiver() Class {
	ret := (Class)(unsafe.Pointer(C.NSUUID_ClassForKeyedUnarchiver()))
	return ret
}

func NSUUIDConformsToProtocol(protocol Protocol) bool {
	ret := (bool)(C.NSUUID_ConformsToProtocol(protocol.Ptr()))
	return ret
}

func NSUUIDResolveInstanceMethod(sel SEL) bool {
	ret := (bool)(C.NSUUID_ResolveInstanceMethod(unsafe.Pointer(sel)))
	return ret
}

func NSUUIDescription() *NSString {
	ret := &NSString{}
	ret.ptr = unsafe.Pointer(C.NSUUID_Description())
	if ret.ptr == nil { return ret }
	runtime.SetFinalizer(ret, func(o *NSString) {
		o.Release()
	})
	return ret
}

func NSUUIDAccessInstanceVariablesDirectly() bool {
	ret := (bool)(C.NSUUID_AccessInstanceVariablesDirectly())
	return ret
}

func NSUUIDHash() NSUInteger {
	ret := (NSUInteger)(C.NSUUID_Hash())
	return ret
}

func NSUUIDAutomaticallyNotifiesObserversForKey(key *NSString) bool {
	ret := (bool)(C.NSUUID_AutomaticallyNotifiesObserversForKey(key.Ptr()))
	return ret
}

func NSUUIDCancelPreviousPerformRequestsWithTarget(aTarget NSObject)  {
	C.NSUUID_CancelPreviousPerformRequestsWithTarget(aTarget.Ptr())
}

func NSUUIDCancelPreviousPerformRequestsWithTargetSelector(aTarget NSObject, aSelector SEL, anArgument NSObject)  {
	C.NSUUID_CancelPreviousPerformRequestsWithTargetSelector(aTarget.Ptr(), unsafe.Pointer(aSelector), anArgument.Ptr())
}

func NSUUIDCancelPreviousPerformRequestsWithTargetSelectorObject(aTarget NSObject, aSelector SEL, anArgument NSObject)  {
	C.NSUUID_CancelPreviousPerformRequestsWithTargetSelectorObject(aTarget.Ptr(), unsafe.Pointer(aSelector), anArgument.Ptr())
}

func NSUUIDResolveClassMethod(sel SEL) bool {
	ret := (bool)(C.NSUUID_ResolveClassMethod(unsafe.Pointer(sel)))
	return ret
}

func NSUUIDAllocWithZone(zone *_NSZone) *NSUUID {
	ret := &NSUUID{}
	ret.ptr = unsafe.Pointer(C.NSUUID_AllocWithZone(unsafe.Pointer(zone)))
	if ret.ptr == nil { return ret }
	runtime.SetFinalizer(ret, func(o *NSUUID) {
		o.Release()
	})
	return ret
}

func NSUUIDClassFallbacksForKeyedArchiver() *NSArray {
	ret := &NSArray{}
	ret.ptr = unsafe.Pointer(C.NSUUID_ClassFallbacksForKeyedArchiver())
	if ret.ptr == nil { return ret }
	return ret
}

func NSUUIDSuperclass() Class {
	ret := (Class)(unsafe.Pointer(C.NSUUID_Superclass()))
	return ret
}

func NSUUIDSupportsSecureCoding() bool {
	ret := (bool)(C.NSUUID_SupportsSecureCoding())
	return ret
}

func (o *NSUUID) MutableArrayValueForKey(key *NSString) *NSMutableArray {
	ret := &NSMutableArray{}
	ret.ptr = unsafe.Pointer(C.NSUUID_inst_MutableArrayValueForKey(o.Ptr(), key.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSMutableArray)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *NSMutableArray) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *NSUUID) ForwardingTargetForSelector(aSelector SEL) *Id {
	ret := &Id{}
	ret.ptr = unsafe.Pointer(C.NSUUID_inst_ForwardingTargetForSelector(o.Ptr(), unsafe.Pointer(aSelector)))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *Id) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *NSUUID) SetValuesForKeysWithDictionary(keyedValues *NSDictionary)  {
	C.NSUUID_inst_SetValuesForKeysWithDictionary(o.Ptr(), keyedValues.Ptr())
	runtime.KeepAlive(o)
}

func (o *NSUUID) GetUUIDBytes(uuid *UnsignedChar)  {
	C.NSUUID_inst_GetUUIDBytes(o.Ptr(), unsafe.Pointer(uuid))
	runtime.KeepAlive(o)
}

func (o *NSUUID) MutableOrderedSetValueForKey(key *NSString) *NSMutableOrderedSet {
	ret := &NSMutableOrderedSet{}
	ret.ptr = unsafe.Pointer(C.NSUUID_inst_MutableOrderedSetValueForKey(o.Ptr(), key.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSMutableOrderedSet)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *NSMutableOrderedSet) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *NSUUID) SetValueForKey(value NSObject, key *NSString)  {
	C.NSUUID_inst_SetValueForKey(o.Ptr(), value.Ptr(), key.Ptr())
	runtime.KeepAlive(o)
}

func (o *NSUUID) SetValueForKeyPath(value NSObject, keyPath *NSString)  {
	C.NSUUID_inst_SetValueForKeyPath(o.Ptr(), value.Ptr(), keyPath.Ptr())
	runtime.KeepAlive(o)
}

func (o *NSUUID) SetValueForUndefinedKey(value NSObject, key *NSString)  {
	C.NSUUID_inst_SetValueForUndefinedKey(o.Ptr(), value.Ptr(), key.Ptr())
	runtime.KeepAlive(o)
}

func (o *NSUUID) ValueForKey(key *NSString) *Id {
	ret := &Id{}
	ret.ptr = unsafe.Pointer(C.NSUUID_inst_ValueForKey(o.Ptr(), key.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *Id) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *NSUUID) ValueAtIndexInPropertyWithKey(index NSUInteger, key *NSString) *Id {
	ret := &Id{}
	ret.ptr = unsafe.Pointer(C.NSUUID_inst_ValueAtIndexInPropertyWithKey(o.Ptr(), (C.NSUInteger)(index), key.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *Id) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *NSUUID) WillChangeValuesAtIndexes(changeKind NSKeyValueChange, indexes *NSIndexSet, key *NSString)  {
	C.NSUUID_inst_WillChangeValuesAtIndexes(o.Ptr(), (C.NSKeyValueChange)(changeKind), indexes.Ptr(), key.Ptr())
	runtime.KeepAlive(o)
}

func (o *NSUUID) WillChangeValuesAtIndexesForKey(changeKind NSKeyValueChange, indexes *NSIndexSet, key *NSString)  {
	C.NSUUID_inst_WillChangeValuesAtIndexesForKey(o.Ptr(), (C.NSKeyValueChange)(changeKind), indexes.Ptr(), key.Ptr())
	runtime.KeepAlive(o)
}

func (o *NSUUID) ClassForArchiver() Class {
	ret := (Class)(unsafe.Pointer(C.NSUUID_inst_ClassForArchiver(o.Ptr())))
	runtime.KeepAlive(o)
	return ret
}

func (o *NSUUID) SetObservationInfo(observationInfo unsafe.Pointer)  {
	C.NSUUID_inst_SetObservationInfo(o.Ptr(), unsafe.Pointer(observationInfo))
	runtime.KeepAlive(o)
}

func (o *NSUUID) AttributeKeys() *NSArray {
	ret := &NSArray{}
	ret.ptr = unsafe.Pointer(C.NSUUID_inst_AttributeKeys(o.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSArray)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *NSArray) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *NSUUID) ObserveValueForKeyPathOfObject(keyPath *NSString, object NSObject, change *NSDictionary, context unsafe.Pointer)  {
	C.NSUUID_inst_ObserveValueForKeyPathOfObject(o.Ptr(), keyPath.Ptr(), object.Ptr(), change.Ptr(), unsafe.Pointer(context))
	runtime.KeepAlive(o)
}

func (o *NSUUID) ObserveValueForKeyPathOfObjectChange(keyPath *NSString, object NSObject, change *NSDictionary, context unsafe.Pointer)  {
	C.NSUUID_inst_ObserveValueForKeyPathOfObjectChange(o.Ptr(), keyPath.Ptr(), object.Ptr(), change.Ptr(), unsafe.Pointer(context))
	runtime.KeepAlive(o)
}

func (o *NSUUID) ObservationInfo() unsafe.Pointer {
	ret := (unsafe.Pointer)(unsafe.Pointer(C.NSUUID_inst_ObservationInfo(o.Ptr())))
	runtime.KeepAlive(o)
	return ret
}

func (o *NSUUID) IsGreaterThanOrEqualTo(object NSObject) bool {
	ret := (bool)(C.NSUUID_inst_IsGreaterThanOrEqualTo(o.Ptr(), object.Ptr()))
	runtime.KeepAlive(o)
	return ret
}

func (o *NSUUID) UUIDString() *NSString {
	ret := &NSString{}
	ret.ptr = unsafe.Pointer(C.NSUUID_inst_UUIDString(o.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSString)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *NSString) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *NSUUID) ClassCode() FourCharCode {
	ret := (FourCharCode)(C.NSUUID_inst_ClassCode(o.Ptr()))
	runtime.KeepAlive(o)
	return ret
}

func (o *NSUUID) DictionaryWithValuesForKeys(keys *NSArray) *NSDictionary {
	ret := &NSDictionary{}
	ret.ptr = unsafe.Pointer(C.NSUUID_inst_DictionaryWithValuesForKeys(o.Ptr(), keys.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSDictionary)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *NSDictionary) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *NSUUID) ClassForCoder() Class {
	ret := (Class)(unsafe.Pointer(C.NSUUID_inst_ClassForCoder(o.Ptr())))
	runtime.KeepAlive(o)
	return ret
}

func (o *NSUUID) ClassDescription() *NSClassDescription {
	ret := &NSClassDescription{}
	ret.ptr = unsafe.Pointer(C.NSUUID_inst_ClassDescription(o.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSClassDescription)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *NSClassDescription) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *NSUUID) ReplacementObjectForKeyedArchiver(archiver *NSKeyedArchiver) *Id {
	ret := &Id{}
	ret.ptr = unsafe.Pointer(C.NSUUID_inst_ReplacementObjectForKeyedArchiver(o.Ptr(), archiver.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *Id) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *NSUUID) ObjectSpecifier() *NSScriptObjectSpecifier {
	ret := &NSScriptObjectSpecifier{}
	ret.ptr = unsafe.Pointer(C.NSUUID_inst_ObjectSpecifier(o.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSScriptObjectSpecifier)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *NSScriptObjectSpecifier) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *NSUUID) InitWithUUIDBytes(bytes *UnsignedChar) *NSUUID {
	ret := &NSUUID{}
	ret.ptr = unsafe.Pointer(C.NSUUID_inst_InitWithUUIDBytes(o.Ptr(), unsafe.Pointer(bytes)))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSUUID)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *NSUUID) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *NSUUID) ScriptingValueForSpecifier(objectSpecifier *NSScriptObjectSpecifier) *Id {
	ret := &Id{}
	ret.ptr = unsafe.Pointer(C.NSUUID_inst_ScriptingValueForSpecifier(o.Ptr(), objectSpecifier.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *Id) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *NSUUID) PerformSelectorInBackgroundWithObject(aSelector SEL, arg NSObject)  {
	C.NSUUID_inst_PerformSelectorInBackgroundWithObject(o.Ptr(), unsafe.Pointer(aSelector), arg.Ptr())
	runtime.KeepAlive(o)
}

func (o *NSUUID) ScriptingBeginsWith(object NSObject) bool {
	ret := (bool)(C.NSUUID_inst_ScriptingBeginsWith(o.Ptr(), object.Ptr()))
	runtime.KeepAlive(o)
	return ret
}

func (o *NSUUID) ClassName() *NSString {
	ret := &NSString{}
	ret.ptr = unsafe.Pointer(C.NSUUID_inst_ClassName(o.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSString)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *NSString) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *NSUUID) ScriptingEndsWith(object NSObject) bool {
	ret := (bool)(C.NSUUID_inst_ScriptingEndsWith(o.Ptr(), object.Ptr()))
	runtime.KeepAlive(o)
	return ret
}

func (o *NSUUID) AwakeAfterUsingCoder(coder *NSCoder) *Id {
	ret := &Id{}
	ret.ptr = unsafe.Pointer(C.NSUUID_inst_AwakeAfterUsingCoder(o.Ptr(), coder.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *Id) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *NSUUID) RemoveValueAtIndexFromPropertyWithKey(index NSUInteger, key *NSString)  {
	C.NSUUID_inst_RemoveValueAtIndexFromPropertyWithKey(o.Ptr(), (C.NSUInteger)(index), key.Ptr())
	runtime.KeepAlive(o)
}

func (o *NSUUID) CoerceValueForKey(value NSObject, key *NSString) *Id {
	ret := &Id{}
	ret.ptr = unsafe.Pointer(C.NSUUID_inst_CoerceValueForKey(o.Ptr(), value.Ptr(), key.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *Id) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *NSUUID) ScriptingIsGreaterThan(object NSObject) bool {
	ret := (bool)(C.NSUUID_inst_ScriptingIsGreaterThan(o.Ptr(), object.Ptr()))
	runtime.KeepAlive(o)
	return ret
}

func (o *NSUUID) ValueWithUniqueIDInPropertyWithKey(uniqueID NSObject, key *NSString) *Id {
	ret := &Id{}
	ret.ptr = unsafe.Pointer(C.NSUUID_inst_ValueWithUniqueIDInPropertyWithKey(o.Ptr(), uniqueID.Ptr(), key.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *Id) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *NSUUID) Dealloc()  {
	C.NSUUID_inst_Dealloc(o.Ptr())
	runtime.KeepAlive(o)
}

func (o *NSUUID) IsLessThanOrEqualTo(object NSObject) bool {
	ret := (bool)(C.NSUUID_inst_IsLessThanOrEqualTo(o.Ptr(), object.Ptr()))
	runtime.KeepAlive(o)
	return ret
}

func (o *NSUUID) DoesContain(object NSObject) bool {
	ret := (bool)(C.NSUUID_inst_DoesContain(o.Ptr(), object.Ptr()))
	runtime.KeepAlive(o)
	return ret
}

func (o *NSUUID) ToOneRelationshipKeys() *NSArray {
	ret := &NSArray{}
	ret.ptr = unsafe.Pointer(C.NSUUID_inst_ToOneRelationshipKeys(o.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSArray)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *NSArray) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *NSUUID) WillChangeValueForKey(key *NSString)  {
	C.NSUUID_inst_WillChangeValueForKey(o.Ptr(), key.Ptr())
	runtime.KeepAlive(o)
}

func (o *NSUUID) WillChangeValueForKeyWithSetMutation(key *NSString, mutationKind NSKeyValueSetMutationKind, objects *NSSet)  {
	C.NSUUID_inst_WillChangeValueForKeyWithSetMutation(o.Ptr(), key.Ptr(), (C.NSKeyValueSetMutationKind)(mutationKind), objects.Ptr())
	runtime.KeepAlive(o)
}

func (o *NSUUID) WillChangeValueForKeyWithSetMutationUsingObjects(key *NSString, mutationKind NSKeyValueSetMutationKind, objects *NSSet)  {
	C.NSUUID_inst_WillChangeValueForKeyWithSetMutationUsingObjects(o.Ptr(), key.Ptr(), (C.NSKeyValueSetMutationKind)(mutationKind), objects.Ptr())
	runtime.KeepAlive(o)
}

func (o *NSUUID) Copy() *Id {
	ret := &Id{}
	ret.ptr = unsafe.Pointer(C.NSUUID_inst_Copy(o.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	runtime.SetFinalizer(ret, func(o *Id) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *NSUUID) ScriptingIsEqualTo(object NSObject) bool {
	ret := (bool)(C.NSUUID_inst_ScriptingIsEqualTo(o.Ptr(), object.Ptr()))
	runtime.KeepAlive(o)
	return ret
}

func (o *NSUUID) RemoveObserverForKeyPath(observer NSObject, keyPath *NSString)  {
	C.NSUUID_inst_RemoveObserverForKeyPath(o.Ptr(), observer.Ptr(), keyPath.Ptr())
	runtime.KeepAlive(o)
}

func (o *NSUUID) RemoveObserverForKeyPathContext(observer NSObject, keyPath *NSString, context unsafe.Pointer)  {
	C.NSUUID_inst_RemoveObserverForKeyPathContext(o.Ptr(), observer.Ptr(), keyPath.Ptr(), unsafe.Pointer(context))
	runtime.KeepAlive(o)
}

func (o *NSUUID) InverseForRelationshipKey(relationshipKey *NSString) *NSString {
	ret := &NSString{}
	ret.ptr = unsafe.Pointer(C.NSUUID_inst_InverseForRelationshipKey(o.Ptr(), relationshipKey.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSString)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *NSString) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *NSUUID) AutoContentAccessingProxy() *Id {
	ret := &Id{}
	ret.ptr = unsafe.Pointer(C.NSUUID_inst_AutoContentAccessingProxy(o.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *Id) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *NSUUID) ValueWithNameInPropertyWithKey(name *NSString, key *NSString) *Id {
	ret := &Id{}
	ret.ptr = unsafe.Pointer(C.NSUUID_inst_ValueWithNameInPropertyWithKey(o.Ptr(), name.Ptr(), key.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *Id) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *NSUUID) ReplacementObjectForCoder(coder *NSCoder) *Id {
	ret := &Id{}
	ret.ptr = unsafe.Pointer(C.NSUUID_inst_ReplacementObjectForCoder(o.Ptr(), coder.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *Id) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *NSUUID) IsGreaterThan(object NSObject) bool {
	ret := (bool)(C.NSUUID_inst_IsGreaterThan(o.Ptr(), object.Ptr()))
	runtime.KeepAlive(o)
	return ret
}

func (o *NSUUID) NewScriptingObjectOfClassForValueForKey(objectClass Class, key *NSString, contentsValue NSObject, properties *NSDictionary) *Id {
	ret := &Id{}
	ret.ptr = unsafe.Pointer(C.NSUUID_inst_NewScriptingObjectOfClassForValueForKey(o.Ptr(), unsafe.Pointer(objectClass), key.Ptr(), contentsValue.Ptr(), properties.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *Id) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *NSUUID) NewScriptingObjectOfClassForValueForKeyWithContentsValue(objectClass Class, key *NSString, contentsValue NSObject, properties *NSDictionary) *Id {
	ret := &Id{}
	ret.ptr = unsafe.Pointer(C.NSUUID_inst_NewScriptingObjectOfClassForValueForKeyWithContentsValue(o.Ptr(), unsafe.Pointer(objectClass), key.Ptr(), contentsValue.Ptr(), properties.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *Id) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *NSUUID) ScriptingIsLessThanOrEqualTo(object NSObject) bool {
	ret := (bool)(C.NSUUID_inst_ScriptingIsLessThanOrEqualTo(o.Ptr(), object.Ptr()))
	runtime.KeepAlive(o)
	return ret
}

func (o *NSUUID) DidChangeValueForKey(key *NSString)  {
	C.NSUUID_inst_DidChangeValueForKey(o.Ptr(), key.Ptr())
	runtime.KeepAlive(o)
}

func (o *NSUUID) DidChangeValueForKeyWithSetMutation(key *NSString, mutationKind NSKeyValueSetMutationKind, objects *NSSet)  {
	C.NSUUID_inst_DidChangeValueForKeyWithSetMutation(o.Ptr(), key.Ptr(), (C.NSKeyValueSetMutationKind)(mutationKind), objects.Ptr())
	runtime.KeepAlive(o)
}

func (o *NSUUID) DidChangeValueForKeyWithSetMutationUsingObjects(key *NSString, mutationKind NSKeyValueSetMutationKind, objects *NSSet)  {
	C.NSUUID_inst_DidChangeValueForKeyWithSetMutationUsingObjects(o.Ptr(), key.Ptr(), (C.NSKeyValueSetMutationKind)(mutationKind), objects.Ptr())
	runtime.KeepAlive(o)
}

func (o *NSUUID) SetNilValueForKey(key *NSString)  {
	C.NSUUID_inst_SetNilValueForKey(o.Ptr(), key.Ptr())
	runtime.KeepAlive(o)
}

func (o *NSUUID) CopyWithZone(zone *NSZone) *Id {
	ret := &Id{}
	ret.ptr = unsafe.Pointer(C.NSUUID_inst_CopyWithZone(o.Ptr(), unsafe.Pointer(zone)))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *Id) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *NSUUID) SetScriptingProperties(scriptingProperties *NSDictionary)  {
	C.NSUUID_inst_SetScriptingProperties(o.Ptr(), scriptingProperties.Ptr())
	runtime.KeepAlive(o)
}

func (o *NSUUID) MutableOrderedSetValueForKeyPath(keyPath *NSString) *NSMutableOrderedSet {
	ret := &NSMutableOrderedSet{}
	ret.ptr = unsafe.Pointer(C.NSUUID_inst_MutableOrderedSetValueForKeyPath(o.Ptr(), keyPath.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSMutableOrderedSet)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *NSMutableOrderedSet) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *NSUUID) MutableSetValueForKeyPath(keyPath *NSString) *NSMutableSet {
	ret := &NSMutableSet{}
	ret.ptr = unsafe.Pointer(C.NSUUID_inst_MutableSetValueForKeyPath(o.Ptr(), keyPath.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSMutableSet)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *NSMutableSet) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *NSUUID) ScriptingProperties() *NSDictionary {
	ret := &NSDictionary{}
	ret.ptr = unsafe.Pointer(C.NSUUID_inst_ScriptingProperties(o.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSDictionary)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *NSDictionary) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *NSUUID) ForwardInvocation(anInvocation *NSInvocation)  {
	C.NSUUID_inst_ForwardInvocation(o.Ptr(), anInvocation.Ptr())
	runtime.KeepAlive(o)
}

func (o *NSUUID) MutableSetValueForKey(key *NSString) *NSMutableSet {
	ret := &NSMutableSet{}
	ret.ptr = unsafe.Pointer(C.NSUUID_inst_MutableSetValueForKey(o.Ptr(), key.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSMutableSet)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *NSMutableSet) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *NSUUID) InitWithUUIDString(string *NSString) *NSUUID {
	ret := &NSUUID{}
	ret.ptr = unsafe.Pointer(C.NSUUID_inst_InitWithUUIDString(o.Ptr(), string.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSUUID)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *NSUUID) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *NSUUID) MutableCopy() *Id {
	ret := &Id{}
	ret.ptr = unsafe.Pointer(C.NSUUID_inst_MutableCopy(o.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	runtime.SetFinalizer(ret, func(o *Id) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *NSUUID) PerformSelectorWithObject(aSelector SEL, anArgument NSObject, delay NSTimeInterval)  {
	C.NSUUID_inst_PerformSelectorWithObject(o.Ptr(), unsafe.Pointer(aSelector), anArgument.Ptr(), (C.NSTimeInterval)(delay))
	runtime.KeepAlive(o)
}

func (o *NSUUID) PerformSelectorWithObjectAfterDelay(aSelector SEL, anArgument NSObject, delay NSTimeInterval)  {
	C.NSUUID_inst_PerformSelectorWithObjectAfterDelay(o.Ptr(), unsafe.Pointer(aSelector), anArgument.Ptr(), (C.NSTimeInterval)(delay))
	runtime.KeepAlive(o)
}

func (o *NSUUID) PerformSelectorWithObjectAfterDelayInModes(aSelector SEL, anArgument NSObject, delay NSTimeInterval, modes *NSArray)  {
	C.NSUUID_inst_PerformSelectorWithObjectAfterDelayInModes(o.Ptr(), unsafe.Pointer(aSelector), anArgument.Ptr(), (C.NSTimeInterval)(delay), modes.Ptr())
	runtime.KeepAlive(o)
}

func (o *NSUUID) PerformSelectorOnThread(aSelector SEL, thr *NSThread, arg NSObject, wait BOOL)  {
	C.NSUUID_inst_PerformSelectorOnThread(o.Ptr(), unsafe.Pointer(aSelector), thr.Ptr(), arg.Ptr(), (C.BOOL)(wait))
	runtime.KeepAlive(o)
}

func (o *NSUUID) PerformSelectorOnThreadWithObject(aSelector SEL, thr *NSThread, arg NSObject, wait BOOL)  {
	C.NSUUID_inst_PerformSelectorOnThreadWithObject(o.Ptr(), unsafe.Pointer(aSelector), thr.Ptr(), arg.Ptr(), (C.BOOL)(wait))
	runtime.KeepAlive(o)
}

func (o *NSUUID) PerformSelectorOnThreadWithObjectWaitUntilDone(aSelector SEL, thr *NSThread, arg NSObject, wait BOOL, array *NSArray)  {
	C.NSUUID_inst_PerformSelectorOnThreadWithObjectWaitUntilDone(o.Ptr(), unsafe.Pointer(aSelector), thr.Ptr(), arg.Ptr(), (C.BOOL)(wait), array.Ptr())
	runtime.KeepAlive(o)
}

func (o *NSUUID) PerformSelectorOnThreadWithObjectWaitUntilDoneModes(aSelector SEL, thr *NSThread, arg NSObject, wait BOOL, array *NSArray)  {
	C.NSUUID_inst_PerformSelectorOnThreadWithObjectWaitUntilDoneModes(o.Ptr(), unsafe.Pointer(aSelector), thr.Ptr(), arg.Ptr(), (C.BOOL)(wait), array.Ptr())
	runtime.KeepAlive(o)
}

func (o *NSUUID) IndicesOfObjectsByEvaluatingObjectSpecifier(specifier *NSScriptObjectSpecifier) *NSArray {
	ret := &NSArray{}
	ret.ptr = unsafe.Pointer(C.NSUUID_inst_IndicesOfObjectsByEvaluatingObjectSpecifier(o.Ptr(), specifier.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSArray)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *NSArray) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *NSUUID) InsertValueInPropertyWithKey(value NSObject, key *NSString)  {
	C.NSUUID_inst_InsertValueInPropertyWithKey(o.Ptr(), value.Ptr(), key.Ptr())
	runtime.KeepAlive(o)
}

func (o *NSUUID) InsertValueAtIndex(value NSObject, index NSUInteger, key *NSString)  {
	C.NSUUID_inst_InsertValueAtIndex(o.Ptr(), value.Ptr(), (C.NSUInteger)(index), key.Ptr())
	runtime.KeepAlive(o)
}

func (o *NSUUID) InsertValueAtIndexInPropertyWithKey(value NSObject, index NSUInteger, key *NSString)  {
	C.NSUUID_inst_InsertValueAtIndexInPropertyWithKey(o.Ptr(), value.Ptr(), (C.NSUInteger)(index), key.Ptr())
	runtime.KeepAlive(o)
}

func (o *NSUUID) CopyScriptingValueForKey(value NSObject, key *NSString, properties *NSDictionary) *Id {
	ret := &Id{}
	ret.ptr = unsafe.Pointer(C.NSUUID_inst_CopyScriptingValueForKey(o.Ptr(), value.Ptr(), key.Ptr(), properties.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *Id) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *NSUUID) CopyScriptingValueForKeyWithProperties(value NSObject, key *NSString, properties *NSDictionary) *Id {
	ret := &Id{}
	ret.ptr = unsafe.Pointer(C.NSUUID_inst_CopyScriptingValueForKeyWithProperties(o.Ptr(), value.Ptr(), key.Ptr(), properties.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *Id) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *NSUUID) ClassForKeyedArchiver() Class {
	ret := (Class)(unsafe.Pointer(C.NSUUID_inst_ClassForKeyedArchiver(o.Ptr())))
	runtime.KeepAlive(o)
	return ret
}

func (o *NSUUID) IsLessThan(object NSObject) bool {
	ret := (bool)(C.NSUUID_inst_IsLessThan(o.Ptr(), object.Ptr()))
	runtime.KeepAlive(o)
	return ret
}

func (o *NSUUID) IsCaseInsensitiveLike(object *NSString) bool {
	ret := (bool)(C.NSUUID_inst_IsCaseInsensitiveLike(o.Ptr(), object.Ptr()))
	runtime.KeepAlive(o)
	return ret
}

func (o *NSUUID) PerformSelectorOnMainThreadWithObject(aSelector SEL, arg NSObject, wait BOOL)  {
	C.NSUUID_inst_PerformSelectorOnMainThreadWithObject(o.Ptr(), unsafe.Pointer(aSelector), arg.Ptr(), (C.BOOL)(wait))
	runtime.KeepAlive(o)
}

func (o *NSUUID) PerformSelectorOnMainThreadWithObjectWaitUntilDone(aSelector SEL, arg NSObject, wait BOOL)  {
	C.NSUUID_inst_PerformSelectorOnMainThreadWithObjectWaitUntilDone(o.Ptr(), unsafe.Pointer(aSelector), arg.Ptr(), (C.BOOL)(wait))
	runtime.KeepAlive(o)
}

func (o *NSUUID) PerformSelectorOnMainThreadWithObjectWaitUntilDoneModes(aSelector SEL, arg NSObject, wait BOOL, array *NSArray)  {
	C.NSUUID_inst_PerformSelectorOnMainThreadWithObjectWaitUntilDoneModes(o.Ptr(), unsafe.Pointer(aSelector), arg.Ptr(), (C.BOOL)(wait), array.Ptr())
	runtime.KeepAlive(o)
}

func (o *NSUUID) ScriptingIsLessThan(object NSObject) bool {
	ret := (bool)(C.NSUUID_inst_ScriptingIsLessThan(o.Ptr(), object.Ptr()))
	runtime.KeepAlive(o)
	return ret
}

func (o *NSUUID) ReplaceValueAtIndexInPropertyWithKey(index NSUInteger, key *NSString, value NSObject)  {
	C.NSUUID_inst_ReplaceValueAtIndexInPropertyWithKey(o.Ptr(), (C.NSUInteger)(index), key.Ptr(), value.Ptr())
	runtime.KeepAlive(o)
}

func (o *NSUUID) ReplaceValueAtIndexInPropertyWithKeyWithValue(index NSUInteger, key *NSString, value NSObject)  {
	C.NSUUID_inst_ReplaceValueAtIndexInPropertyWithKeyWithValue(o.Ptr(), (C.NSUInteger)(index), key.Ptr(), value.Ptr())
	runtime.KeepAlive(o)
}

func (o *NSUUID) ValueForKeyPath(keyPath *NSString) *Id {
	ret := &Id{}
	ret.ptr = unsafe.Pointer(C.NSUUID_inst_ValueForKeyPath(o.Ptr(), keyPath.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *Id) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *NSUUID) Init() *NSUUID {
	ret := &NSUUID{}
	ret.ptr = unsafe.Pointer(C.NSUUID_inst_Init(o.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSUUID)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *NSUUID) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *NSUUID) ScriptingIsGreaterThanOrEqualTo(object NSObject) bool {
	ret := (bool)(C.NSUUID_inst_ScriptingIsGreaterThanOrEqualTo(o.Ptr(), object.Ptr()))
	runtime.KeepAlive(o)
	return ret
}

func (o *NSUUID) IsNotEqualTo(object NSObject) bool {
	ret := (bool)(C.NSUUID_inst_IsNotEqualTo(o.Ptr(), object.Ptr()))
	runtime.KeepAlive(o)
	return ret
}

func (o *NSUUID) ToManyRelationshipKeys() *NSArray {
	ret := &NSArray{}
	ret.ptr = unsafe.Pointer(C.NSUUID_inst_ToManyRelationshipKeys(o.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSArray)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *NSArray) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *NSUUID) DidChangeValuesAtIndexes(changeKind NSKeyValueChange, indexes *NSIndexSet, key *NSString)  {
	C.NSUUID_inst_DidChangeValuesAtIndexes(o.Ptr(), (C.NSKeyValueChange)(changeKind), indexes.Ptr(), key.Ptr())
	runtime.KeepAlive(o)
}

func (o *NSUUID) DidChangeValuesAtIndexesForKey(changeKind NSKeyValueChange, indexes *NSIndexSet, key *NSString)  {
	C.NSUUID_inst_DidChangeValuesAtIndexesForKey(o.Ptr(), (C.NSKeyValueChange)(changeKind), indexes.Ptr(), key.Ptr())
	runtime.KeepAlive(o)
}

func (o *NSUUID) AddObserverForKeyPath(observer NSObject, keyPath *NSString, options NSKeyValueObservingOptions, context unsafe.Pointer)  {
	C.NSUUID_inst_AddObserverForKeyPath(o.Ptr(), observer.Ptr(), keyPath.Ptr(), (C.NSKeyValueObservingOptions)(options), unsafe.Pointer(context))
	runtime.KeepAlive(o)
}

func (o *NSUUID) AddObserverForKeyPathOptions(observer NSObject, keyPath *NSString, options NSKeyValueObservingOptions, context unsafe.Pointer)  {
	C.NSUUID_inst_AddObserverForKeyPathOptions(o.Ptr(), observer.Ptr(), keyPath.Ptr(), (C.NSKeyValueObservingOptions)(options), unsafe.Pointer(context))
	runtime.KeepAlive(o)
}

func (o *NSUUID) ValidateValueForKey(ioValue *[]*Id, inKey *NSString, outError *[]*NSError) bool {

	goSlice1 := make([]unsafe.Pointer,cap(*ioValue))
	for i := 0; i < len(*ioValue); i++ {
		goSlice1[i] = (*ioValue)[i].Ptr()
	}

	goSlice3 := make([]unsafe.Pointer,cap(*outError))
	for i := 0; i < len(*outError); i++ {
		goSlice3[i] = (*outError)[i].Ptr()
	}
	ret := (bool)(C.NSUUID_inst_ValidateValueForKey(o.Ptr(), (*unsafe.Pointer)(unsafe.Pointer(&goSlice1[0])), inKey.Ptr(), (*unsafe.Pointer)(unsafe.Pointer(&goSlice3[0]))))
	(*ioValue) = (*ioValue)[:cap(*ioValue)]
	for i := 0; i < len(*ioValue); i++ {
		if goSlice1[i] == nil {
			(*ioValue) = (*ioValue)[:i]
			break
		}
		if (*ioValue)[i] == nil {
			(*ioValue)[i] = &Id{}
			runtime.SetFinalizer((*ioValue)[i], func(o *Id) {
				o.Release()
			})
		}
		(*ioValue)[i].ptr = goSlice1[i]
	}
	(*outError) = (*outError)[:cap(*outError)]
	for i := 0; i < len(*outError); i++ {
		if goSlice3[i] == nil {
			(*outError) = (*outError)[:i]
			break
		}
		if (*outError)[i] == nil {
			(*outError)[i] = &NSError{}
			runtime.SetFinalizer((*outError)[i], func(o *NSError) {
				o.Release()
			})
		}
		(*outError)[i].ptr = goSlice3[i]
	}
	runtime.KeepAlive(o)
	return ret
}

func (o *NSUUID) ValidateValueForKeyPath(ioValue *[]*Id, inKeyPath *NSString, outError *[]*NSError) bool {

	goSlice1 := make([]unsafe.Pointer,cap(*ioValue))
	for i := 0; i < len(*ioValue); i++ {
		goSlice1[i] = (*ioValue)[i].Ptr()
	}

	goSlice3 := make([]unsafe.Pointer,cap(*outError))
	for i := 0; i < len(*outError); i++ {
		goSlice3[i] = (*outError)[i].Ptr()
	}
	ret := (bool)(C.NSUUID_inst_ValidateValueForKeyPath(o.Ptr(), (*unsafe.Pointer)(unsafe.Pointer(&goSlice1[0])), inKeyPath.Ptr(), (*unsafe.Pointer)(unsafe.Pointer(&goSlice3[0]))))
	(*ioValue) = (*ioValue)[:cap(*ioValue)]
	for i := 0; i < len(*ioValue); i++ {
		if goSlice1[i] == nil {
			(*ioValue) = (*ioValue)[:i]
			break
		}
		if (*ioValue)[i] == nil {
			(*ioValue)[i] = &Id{}
			runtime.SetFinalizer((*ioValue)[i], func(o *Id) {
				o.Release()
			})
		}
		(*ioValue)[i].ptr = goSlice1[i]
	}
	(*outError) = (*outError)[:cap(*outError)]
	for i := 0; i < len(*outError); i++ {
		if goSlice3[i] == nil {
			(*outError) = (*outError)[:i]
			break
		}
		if (*outError)[i] == nil {
			(*outError)[i] = &NSError{}
			runtime.SetFinalizer((*outError)[i], func(o *NSError) {
				o.Release()
			})
		}
		(*outError)[i].ptr = goSlice3[i]
	}
	runtime.KeepAlive(o)
	return ret
}

func (o *NSUUID) ValidateValueForKeyError(ioValue *[]*Id, inKey *NSString, outError *[]*NSError) bool {

	goSlice1 := make([]unsafe.Pointer,cap(*ioValue))
	for i := 0; i < len(*ioValue); i++ {
		goSlice1[i] = (*ioValue)[i].Ptr()
	}

	goSlice3 := make([]unsafe.Pointer,cap(*outError))
	for i := 0; i < len(*outError); i++ {
		goSlice3[i] = (*outError)[i].Ptr()
	}
	ret := (bool)(C.NSUUID_inst_ValidateValueForKeyError(o.Ptr(), (*unsafe.Pointer)(unsafe.Pointer(&goSlice1[0])), inKey.Ptr(), (*unsafe.Pointer)(unsafe.Pointer(&goSlice3[0]))))
	(*ioValue) = (*ioValue)[:cap(*ioValue)]
	for i := 0; i < len(*ioValue); i++ {
		if goSlice1[i] == nil {
			(*ioValue) = (*ioValue)[:i]
			break
		}
		if (*ioValue)[i] == nil {
			(*ioValue)[i] = &Id{}
			runtime.SetFinalizer((*ioValue)[i], func(o *Id) {
				o.Release()
			})
		}
		(*ioValue)[i].ptr = goSlice1[i]
	}
	(*outError) = (*outError)[:cap(*outError)]
	for i := 0; i < len(*outError); i++ {
		if goSlice3[i] == nil {
			(*outError) = (*outError)[:i]
			break
		}
		if (*outError)[i] == nil {
			(*outError)[i] = &NSError{}
			runtime.SetFinalizer((*outError)[i], func(o *NSError) {
				o.Release()
			})
		}
		(*outError)[i].ptr = goSlice3[i]
	}
	runtime.KeepAlive(o)
	return ret
}

func (o *NSUUID) ValidateValueForKeyPathError(ioValue *[]*Id, inKeyPath *NSString, outError *[]*NSError) bool {

	goSlice1 := make([]unsafe.Pointer,cap(*ioValue))
	for i := 0; i < len(*ioValue); i++ {
		goSlice1[i] = (*ioValue)[i].Ptr()
	}

	goSlice3 := make([]unsafe.Pointer,cap(*outError))
	for i := 0; i < len(*outError); i++ {
		goSlice3[i] = (*outError)[i].Ptr()
	}
	ret := (bool)(C.NSUUID_inst_ValidateValueForKeyPathError(o.Ptr(), (*unsafe.Pointer)(unsafe.Pointer(&goSlice1[0])), inKeyPath.Ptr(), (*unsafe.Pointer)(unsafe.Pointer(&goSlice3[0]))))
	(*ioValue) = (*ioValue)[:cap(*ioValue)]
	for i := 0; i < len(*ioValue); i++ {
		if goSlice1[i] == nil {
			(*ioValue) = (*ioValue)[:i]
			break
		}
		if (*ioValue)[i] == nil {
			(*ioValue)[i] = &Id{}
			runtime.SetFinalizer((*ioValue)[i], func(o *Id) {
				o.Release()
			})
		}
		(*ioValue)[i].ptr = goSlice1[i]
	}
	(*outError) = (*outError)[:cap(*outError)]
	for i := 0; i < len(*outError); i++ {
		if goSlice3[i] == nil {
			(*outError) = (*outError)[:i]
			break
		}
		if (*outError)[i] == nil {
			(*outError)[i] = &NSError{}
			runtime.SetFinalizer((*outError)[i], func(o *NSError) {
				o.Release()
			})
		}
		(*outError)[i].ptr = goSlice3[i]
	}
	runtime.KeepAlive(o)
	return ret
}

func (o *NSUUID) IsLike(object *NSString) bool {
	ret := (bool)(C.NSUUID_inst_IsLike(o.Ptr(), object.Ptr()))
	runtime.KeepAlive(o)
	return ret
}

func (o *NSUUID) MethodSignatureForSelector(aSelector SEL) *NSMethodSignature {
	ret := &NSMethodSignature{}
	ret.ptr = unsafe.Pointer(C.NSUUID_inst_MethodSignatureForSelector(o.Ptr(), unsafe.Pointer(aSelector)))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSMethodSignature)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *NSMethodSignature) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *NSUUID) ScriptingContains(object NSObject) bool {
	ret := (bool)(C.NSUUID_inst_ScriptingContains(o.Ptr(), object.Ptr()))
	runtime.KeepAlive(o)
	return ret
}

func (o *NSUUID) AttemptRecoveryFromErrorOptionIndex(error *NSError, recoveryOptionIndex NSUInteger) bool {
	ret := (bool)(C.NSUUID_inst_AttemptRecoveryFromErrorOptionIndex(o.Ptr(), error.Ptr(), (C.NSUInteger)(recoveryOptionIndex)))
	runtime.KeepAlive(o)
	return ret
}

func (o *NSUUID) AttemptRecoveryFromErrorOptionIndexDelegate(error *NSError, recoveryOptionIndex NSUInteger, delegate NSObject, didRecoverSelector SEL, contextInfo unsafe.Pointer)  {
	C.NSUUID_inst_AttemptRecoveryFromErrorOptionIndexDelegate(o.Ptr(), error.Ptr(), (C.NSUInteger)(recoveryOptionIndex), delegate.Ptr(), unsafe.Pointer(didRecoverSelector), unsafe.Pointer(contextInfo))
	runtime.KeepAlive(o)
}

func (o *NSUUID) AttemptRecoveryFromErrorOptionIndexDelegateDidRecoverSelector(error *NSError, recoveryOptionIndex NSUInteger, delegate NSObject, didRecoverSelector SEL, contextInfo unsafe.Pointer)  {
	C.NSUUID_inst_AttemptRecoveryFromErrorOptionIndexDelegateDidRecoverSelector(o.Ptr(), error.Ptr(), (C.NSUInteger)(recoveryOptionIndex), delegate.Ptr(), unsafe.Pointer(didRecoverSelector), unsafe.Pointer(contextInfo))
	runtime.KeepAlive(o)
}

func (o *NSUUID) ValueForUndefinedKey(key *NSString) *Id {
	ret := &Id{}
	ret.ptr = unsafe.Pointer(C.NSUUID_inst_ValueForUndefinedKey(o.Ptr(), key.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *Id) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *NSUUID) IsEqualTo(object NSObject) bool {
	ret := (bool)(C.NSUUID_inst_IsEqualTo(o.Ptr(), object.Ptr()))
	runtime.KeepAlive(o)
	return ret
}

func (o *NSUUID) MutableArrayValueForKeyPath(keyPath *NSString) *NSMutableArray {
	ret := &NSMutableArray{}
	ret.ptr = unsafe.Pointer(C.NSUUID_inst_MutableArrayValueForKeyPath(o.Ptr(), keyPath.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSMutableArray)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *NSMutableArray) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *NSUUID) DoesNotRecognizeSelector(aSelector SEL)  {
	C.NSUUID_inst_DoesNotRecognizeSelector(o.Ptr(), unsafe.Pointer(aSelector))
	runtime.KeepAlive(o)
}

func CBCentralManagerDebugDescription() *NSString {
	ret := &NSString{}
	ret.ptr = unsafe.Pointer(C.CBCentralManager_DebugDescription())
	if ret.ptr == nil { return ret }
	return ret
}

func CBCentralManagerKeyPathsForValuesAffectingValueForKey(key *NSString) *NSSet {
	ret := &NSSet{}
	ret.ptr = unsafe.Pointer(C.CBCentralManager_KeyPathsForValuesAffectingValueForKey(key.Ptr()))
	if ret.ptr == nil { return ret }
	return ret
}

func CBCentralManagerClassForKeyedUnarchiver() Class {
	ret := (Class)(unsafe.Pointer(C.CBCentralManager_ClassForKeyedUnarchiver()))
	return ret
}

func CBCentralManagerSetVersion(aVersion NSInteger)  {
	C.CBCentralManager_SetVersion((C.NSInteger)(aVersion))
}

func CBCentralManagerNew() *CBCentralManager {
	ret := &CBCentralManager{}
	ret.ptr = unsafe.Pointer(C.CBCentralManager_New())
	if ret.ptr == nil { return ret }
	runtime.SetFinalizer(ret, func(o *CBCentralManager) {
		o.Release()
	})
	return ret
}

func CBCentralManagerClass() Class {
	ret := (Class)(unsafe.Pointer(C.CBCentralManager_Class()))
	return ret
}

func CBCentralManagerConformsToProtocol(protocol Protocol) bool {
	ret := (bool)(C.CBCentralManager_ConformsToProtocol(protocol.Ptr()))
	return ret
}

func CBCentralManagerResolveInstanceMethod(sel SEL) bool {
	ret := (bool)(C.CBCentralManager_ResolveInstanceMethod(unsafe.Pointer(sel)))
	return ret
}

func CBCentralManagerAlloc() *CBCentralManager {
	ret := &CBCentralManager{}
	ret.ptr = unsafe.Pointer(C.CBCentralManager_Alloc())
	if ret.ptr == nil { return ret }
	runtime.SetFinalizer(ret, func(o *CBCentralManager) {
		o.Release()
	})
	return ret
}

func (o *CBCentralManager) GC() {
	if o.ptr == nil { return }
	runtime.SetFinalizer(o, func(o *CBCentralManager) {
		o.Release()
	})
	runtime.KeepAlive(o)
}

func CBCentralManagerVersion() NSInteger {
	ret := (NSInteger)(C.CBCentralManager_Version())
	return ret
}

func CBCentralManagerSuperclass() Class {
	ret := (Class)(unsafe.Pointer(C.CBCentralManager_Superclass()))
	return ret
}

func CBCentralManagerAuthorization() CBManagerAuthorization {
	ret := (CBManagerAuthorization)(C.CBCentralManager_Authorization())
	return ret
}

func CBCentralManagerResolveClassMethod(sel SEL) bool {
	ret := (bool)(C.CBCentralManager_ResolveClassMethod(unsafe.Pointer(sel)))
	return ret
}

func CBCentralManagerAllocWithZone(zone *_NSZone) *CBCentralManager {
	ret := &CBCentralManager{}
	ret.ptr = unsafe.Pointer(C.CBCentralManager_AllocWithZone(unsafe.Pointer(zone)))
	if ret.ptr == nil { return ret }
	runtime.SetFinalizer(ret, func(o *CBCentralManager) {
		o.Release()
	})
	return ret
}

func CBCentralManagerAccessInstanceVariablesDirectly() bool {
	ret := (bool)(C.CBCentralManager_AccessInstanceVariablesDirectly())
	return ret
}

func CBCentralManagerClassFallbacksForKeyedArchiver() *NSArray {
	ret := &NSArray{}
	ret.ptr = unsafe.Pointer(C.CBCentralManager_ClassFallbacksForKeyedArchiver())
	if ret.ptr == nil { return ret }
	return ret
}

func CBCentralManagerCancelPreviousPerformRequestsWithTarget(aTarget NSObject)  {
	C.CBCentralManager_CancelPreviousPerformRequestsWithTarget(aTarget.Ptr())
}

func CBCentralManagerCancelPreviousPerformRequestsWithTargetSelector(aTarget NSObject, aSelector SEL, anArgument NSObject)  {
	C.CBCentralManager_CancelPreviousPerformRequestsWithTargetSelector(aTarget.Ptr(), unsafe.Pointer(aSelector), anArgument.Ptr())
}

func CBCentralManagerCancelPreviousPerformRequestsWithTargetSelectorObject(aTarget NSObject, aSelector SEL, anArgument NSObject)  {
	C.CBCentralManager_CancelPreviousPerformRequestsWithTargetSelectorObject(aTarget.Ptr(), unsafe.Pointer(aSelector), anArgument.Ptr())
}

func CBCentralManagerDescription() *NSString {
	ret := &NSString{}
	ret.ptr = unsafe.Pointer(C.CBCentralManager_Description())
	if ret.ptr == nil { return ret }
	return ret
}

func CBCentralManagerAutomaticallyNotifiesObserversForKey(key *NSString) bool {
	ret := (bool)(C.CBCentralManager_AutomaticallyNotifiesObserversForKey(key.Ptr()))
	return ret
}

func CBCentralManagerMutableCopyWithZone(zone *_NSZone) *Id {
	ret := &Id{}
	ret.ptr = unsafe.Pointer(C.CBCentralManager_MutableCopyWithZone(unsafe.Pointer(zone)))
	if ret.ptr == nil { return ret }
	runtime.SetFinalizer(ret, func(o *Id) {
		o.Release()
	})
	return ret
}

func CBCentralManagerInstanceMethodSignatureForSelector(aSelector SEL) *NSMethodSignature {
	ret := &NSMethodSignature{}
	ret.ptr = unsafe.Pointer(C.CBCentralManager_InstanceMethodSignatureForSelector(unsafe.Pointer(aSelector)))
	if ret.ptr == nil { return ret }
	return ret
}

func CBCentralManagerInstancesRespondToSelector(aSelector SEL) bool {
	ret := (bool)(C.CBCentralManager_InstancesRespondToSelector(unsafe.Pointer(aSelector)))
	return ret
}

func CBCentralManagerHash() NSUInteger {
	ret := (NSUInteger)(C.CBCentralManager_Hash())
	return ret
}

func CBCentralManagerLoad()  {
	C.CBCentralManager_Load()
}

func CBCentralManagerIsSubclassOfClass(aClass Class) bool {
	ret := (bool)(C.CBCentralManager_IsSubclassOfClass(unsafe.Pointer(aClass)))
	return ret
}

func CBCentralManagerCopyWithZone(zone *_NSZone) *Id {
	ret := &Id{}
	ret.ptr = unsafe.Pointer(C.CBCentralManager_CopyWithZone(unsafe.Pointer(zone)))
	if ret.ptr == nil { return ret }
	runtime.SetFinalizer(ret, func(o *Id) {
		o.Release()
	})
	return ret
}

func (o *CBCentralManager) IsGreaterThan(object NSObject) bool {
	ret := (bool)(C.CBCentralManager_inst_IsGreaterThan(o.Ptr(), object.Ptr()))
	runtime.KeepAlive(o)
	return ret
}

func (o *CBCentralManager) ScriptingBeginsWith(object NSObject) bool {
	ret := (bool)(C.CBCentralManager_inst_ScriptingBeginsWith(o.Ptr(), object.Ptr()))
	runtime.KeepAlive(o)
	return ret
}

func (o *CBCentralManager) NewScriptingObjectOfClassForValueForKey(objectClass Class, key *NSString, contentsValue NSObject, properties *NSDictionary) *Id {
	ret := &Id{}
	ret.ptr = unsafe.Pointer(C.CBCentralManager_inst_NewScriptingObjectOfClassForValueForKey(o.Ptr(), unsafe.Pointer(objectClass), key.Ptr(), contentsValue.Ptr(), properties.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *Id) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *CBCentralManager) NewScriptingObjectOfClassForValueForKeyWithContentsValue(objectClass Class, key *NSString, contentsValue NSObject, properties *NSDictionary) *Id {
	ret := &Id{}
	ret.ptr = unsafe.Pointer(C.CBCentralManager_inst_NewScriptingObjectOfClassForValueForKeyWithContentsValue(o.Ptr(), unsafe.Pointer(objectClass), key.Ptr(), contentsValue.Ptr(), properties.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *Id) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *CBCentralManager) ScriptingIsLessThanOrEqualTo(object NSObject) bool {
	ret := (bool)(C.CBCentralManager_inst_ScriptingIsLessThanOrEqualTo(o.Ptr(), object.Ptr()))
	runtime.KeepAlive(o)
	return ret
}

func (o *CBCentralManager) IsLike(object *NSString) bool {
	ret := (bool)(C.CBCentralManager_inst_IsLike(o.Ptr(), object.Ptr()))
	runtime.KeepAlive(o)
	return ret
}

func (o *CBCentralManager) AttributeKeys() *NSArray {
	ret := &NSArray{}
	ret.ptr = unsafe.Pointer(C.CBCentralManager_inst_AttributeKeys(o.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSArray)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *NSArray) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *CBCentralManager) RetrieveConnectedPeripheralsWithServices(serviceUUIDs *NSArray) *NSArray {
	ret := &NSArray{}
	ret.ptr = unsafe.Pointer(C.CBCentralManager_inst_RetrieveConnectedPeripheralsWithServices(o.Ptr(), serviceUUIDs.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSArray)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *NSArray) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *CBCentralManager) InsertValueInPropertyWithKey(value NSObject, key *NSString)  {
	C.CBCentralManager_inst_InsertValueInPropertyWithKey(o.Ptr(), value.Ptr(), key.Ptr())
	runtime.KeepAlive(o)
}

func (o *CBCentralManager) InsertValueAtIndex(value NSObject, index NSUInteger, key *NSString)  {
	C.CBCentralManager_inst_InsertValueAtIndex(o.Ptr(), value.Ptr(), (C.NSUInteger)(index), key.Ptr())
	runtime.KeepAlive(o)
}

func (o *CBCentralManager) InsertValueAtIndexInPropertyWithKey(value NSObject, index NSUInteger, key *NSString)  {
	C.CBCentralManager_inst_InsertValueAtIndexInPropertyWithKey(o.Ptr(), value.Ptr(), (C.NSUInteger)(index), key.Ptr())
	runtime.KeepAlive(o)
}

func (o *CBCentralManager) ReplacementObjectForKeyedArchiver(archiver *NSKeyedArchiver) *Id {
	ret := &Id{}
	ret.ptr = unsafe.Pointer(C.CBCentralManager_inst_ReplacementObjectForKeyedArchiver(o.Ptr(), archiver.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *Id) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *CBCentralManager) DidChangeValuesAtIndexes(changeKind NSKeyValueChange, indexes *NSIndexSet, key *NSString)  {
	C.CBCentralManager_inst_DidChangeValuesAtIndexes(o.Ptr(), (C.NSKeyValueChange)(changeKind), indexes.Ptr(), key.Ptr())
	runtime.KeepAlive(o)
}

func (o *CBCentralManager) DidChangeValuesAtIndexesForKey(changeKind NSKeyValueChange, indexes *NSIndexSet, key *NSString)  {
	C.CBCentralManager_inst_DidChangeValuesAtIndexesForKey(o.Ptr(), (C.NSKeyValueChange)(changeKind), indexes.Ptr(), key.Ptr())
	runtime.KeepAlive(o)
}

func (o *CBCentralManager) State() CBManagerState {
	ret := (CBManagerState)(C.CBCentralManager_inst_State(o.Ptr()))
	runtime.KeepAlive(o)
	return ret
}

func (o *CBCentralManager) InverseForRelationshipKey(relationshipKey *NSString) *NSString {
	ret := &NSString{}
	ret.ptr = unsafe.Pointer(C.CBCentralManager_inst_InverseForRelationshipKey(o.Ptr(), relationshipKey.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSString)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *NSString) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *CBCentralManager) ScriptingEndsWith(object NSObject) bool {
	ret := (bool)(C.CBCentralManager_inst_ScriptingEndsWith(o.Ptr(), object.Ptr()))
	runtime.KeepAlive(o)
	return ret
}

func (o *CBCentralManager) ValueWithNameInPropertyWithKey(name *NSString, key *NSString) *Id {
	ret := &Id{}
	ret.ptr = unsafe.Pointer(C.CBCentralManager_inst_ValueWithNameInPropertyWithKey(o.Ptr(), name.Ptr(), key.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *Id) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *CBCentralManager) IsCaseInsensitiveLike(object *NSString) bool {
	ret := (bool)(C.CBCentralManager_inst_IsCaseInsensitiveLike(o.Ptr(), object.Ptr()))
	runtime.KeepAlive(o)
	return ret
}

func (o *CBCentralManager) PerformSelectorWithObject(aSelector SEL, anArgument NSObject, delay NSTimeInterval)  {
	C.CBCentralManager_inst_PerformSelectorWithObject(o.Ptr(), unsafe.Pointer(aSelector), anArgument.Ptr(), (C.NSTimeInterval)(delay))
	runtime.KeepAlive(o)
}

func (o *CBCentralManager) PerformSelectorWithObjectAfterDelay(aSelector SEL, anArgument NSObject, delay NSTimeInterval)  {
	C.CBCentralManager_inst_PerformSelectorWithObjectAfterDelay(o.Ptr(), unsafe.Pointer(aSelector), anArgument.Ptr(), (C.NSTimeInterval)(delay))
	runtime.KeepAlive(o)
}

func (o *CBCentralManager) PerformSelectorWithObjectAfterDelayInModes(aSelector SEL, anArgument NSObject, delay NSTimeInterval, modes *NSArray)  {
	C.CBCentralManager_inst_PerformSelectorWithObjectAfterDelayInModes(o.Ptr(), unsafe.Pointer(aSelector), anArgument.Ptr(), (C.NSTimeInterval)(delay), modes.Ptr())
	runtime.KeepAlive(o)
}

func (o *CBCentralManager) PerformSelectorOnThread(aSelector SEL, thr *NSThread, arg NSObject, wait BOOL)  {
	C.CBCentralManager_inst_PerformSelectorOnThread(o.Ptr(), unsafe.Pointer(aSelector), thr.Ptr(), arg.Ptr(), (C.BOOL)(wait))
	runtime.KeepAlive(o)
}

func (o *CBCentralManager) PerformSelectorOnThreadWithObject(aSelector SEL, thr *NSThread, arg NSObject, wait BOOL)  {
	C.CBCentralManager_inst_PerformSelectorOnThreadWithObject(o.Ptr(), unsafe.Pointer(aSelector), thr.Ptr(), arg.Ptr(), (C.BOOL)(wait))
	runtime.KeepAlive(o)
}

func (o *CBCentralManager) PerformSelectorOnThreadWithObjectWaitUntilDone(aSelector SEL, thr *NSThread, arg NSObject, wait BOOL, array *NSArray)  {
	C.CBCentralManager_inst_PerformSelectorOnThreadWithObjectWaitUntilDone(o.Ptr(), unsafe.Pointer(aSelector), thr.Ptr(), arg.Ptr(), (C.BOOL)(wait), array.Ptr())
	runtime.KeepAlive(o)
}

func (o *CBCentralManager) PerformSelectorOnThreadWithObjectWaitUntilDoneModes(aSelector SEL, thr *NSThread, arg NSObject, wait BOOL, array *NSArray)  {
	C.CBCentralManager_inst_PerformSelectorOnThreadWithObjectWaitUntilDoneModes(o.Ptr(), unsafe.Pointer(aSelector), thr.Ptr(), arg.Ptr(), (C.BOOL)(wait), array.Ptr())
	runtime.KeepAlive(o)
}

func (o *CBCentralManager) MutableArrayValueForKeyPath(keyPath *NSString) *NSMutableArray {
	ret := &NSMutableArray{}
	ret.ptr = unsafe.Pointer(C.CBCentralManager_inst_MutableArrayValueForKeyPath(o.Ptr(), keyPath.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSMutableArray)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *NSMutableArray) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *CBCentralManager) ScriptingValueForSpecifier(objectSpecifier *NSScriptObjectSpecifier) *Id {
	ret := &Id{}
	ret.ptr = unsafe.Pointer(C.CBCentralManager_inst_ScriptingValueForSpecifier(o.Ptr(), objectSpecifier.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *Id) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *CBCentralManager) ObserveValueForKeyPathOfObject(keyPath *NSString, object NSObject, change *NSDictionary, context unsafe.Pointer)  {
	C.CBCentralManager_inst_ObserveValueForKeyPathOfObject(o.Ptr(), keyPath.Ptr(), object.Ptr(), change.Ptr(), unsafe.Pointer(context))
	runtime.KeepAlive(o)
}

func (o *CBCentralManager) ObserveValueForKeyPathOfObjectChange(keyPath *NSString, object NSObject, change *NSDictionary, context unsafe.Pointer)  {
	C.CBCentralManager_inst_ObserveValueForKeyPathOfObjectChange(o.Ptr(), keyPath.Ptr(), object.Ptr(), change.Ptr(), unsafe.Pointer(context))
	runtime.KeepAlive(o)
}

func (o *CBCentralManager) CopyScriptingValueForKey(value NSObject, key *NSString, properties *NSDictionary) *Id {
	ret := &Id{}
	ret.ptr = unsafe.Pointer(C.CBCentralManager_inst_CopyScriptingValueForKey(o.Ptr(), value.Ptr(), key.Ptr(), properties.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *Id) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *CBCentralManager) CopyScriptingValueForKeyWithProperties(value NSObject, key *NSString, properties *NSDictionary) *Id {
	ret := &Id{}
	ret.ptr = unsafe.Pointer(C.CBCentralManager_inst_CopyScriptingValueForKeyWithProperties(o.Ptr(), value.Ptr(), key.Ptr(), properties.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *Id) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *CBCentralManager) AutoContentAccessingProxy() *Id {
	ret := &Id{}
	ret.ptr = unsafe.Pointer(C.CBCentralManager_inst_AutoContentAccessingProxy(o.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *Id) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *CBCentralManager) AddObserverForKeyPath(observer NSObject, keyPath *NSString, options NSKeyValueObservingOptions, context unsafe.Pointer)  {
	C.CBCentralManager_inst_AddObserverForKeyPath(o.Ptr(), observer.Ptr(), keyPath.Ptr(), (C.NSKeyValueObservingOptions)(options), unsafe.Pointer(context))
	runtime.KeepAlive(o)
}

func (o *CBCentralManager) AddObserverForKeyPathOptions(observer NSObject, keyPath *NSString, options NSKeyValueObservingOptions, context unsafe.Pointer)  {
	C.CBCentralManager_inst_AddObserverForKeyPathOptions(o.Ptr(), observer.Ptr(), keyPath.Ptr(), (C.NSKeyValueObservingOptions)(options), unsafe.Pointer(context))
	runtime.KeepAlive(o)
}

func (o *CBCentralManager) ToOneRelationshipKeys() *NSArray {
	ret := &NSArray{}
	ret.ptr = unsafe.Pointer(C.CBCentralManager_inst_ToOneRelationshipKeys(o.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSArray)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *NSArray) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *CBCentralManager) ValueForUndefinedKey(key *NSString) *Id {
	ret := &Id{}
	ret.ptr = unsafe.Pointer(C.CBCentralManager_inst_ValueForUndefinedKey(o.Ptr(), key.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *Id) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *CBCentralManager) Authorization() CBManagerAuthorization {
	ret := (CBManagerAuthorization)(C.CBCentralManager_inst_Authorization(o.Ptr()))
	runtime.KeepAlive(o)
	return ret
}

func (o *CBCentralManager) ClassCode() FourCharCode {
	ret := (FourCharCode)(C.CBCentralManager_inst_ClassCode(o.Ptr()))
	runtime.KeepAlive(o)
	return ret
}

func (o *CBCentralManager) ValueWithUniqueIDInPropertyWithKey(uniqueID NSObject, key *NSString) *Id {
	ret := &Id{}
	ret.ptr = unsafe.Pointer(C.CBCentralManager_inst_ValueWithUniqueIDInPropertyWithKey(o.Ptr(), uniqueID.Ptr(), key.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *Id) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *CBCentralManager) SetDelegate(delegate NSObject)  {
	C.CBCentralManager_inst_SetDelegate(o.Ptr(), delegate.Ptr())
	runtime.KeepAlive(o)
}

func (o *CBCentralManager) ScriptingIsGreaterThanOrEqualTo(object NSObject) bool {
	ret := (bool)(C.CBCentralManager_inst_ScriptingIsGreaterThanOrEqualTo(o.Ptr(), object.Ptr()))
	runtime.KeepAlive(o)
	return ret
}

func (o *CBCentralManager) StopScan()  {
	C.CBCentralManager_inst_StopScan(o.Ptr())
	runtime.KeepAlive(o)
}

func (o *CBCentralManager) IsLessThanOrEqualTo(object NSObject) bool {
	ret := (bool)(C.CBCentralManager_inst_IsLessThanOrEqualTo(o.Ptr(), object.Ptr()))
	runtime.KeepAlive(o)
	return ret
}

func (o *CBCentralManager) SetValueForKey(value NSObject, key *NSString)  {
	C.CBCentralManager_inst_SetValueForKey(o.Ptr(), value.Ptr(), key.Ptr())
	runtime.KeepAlive(o)
}

func (o *CBCentralManager) SetValueForKeyPath(value NSObject, keyPath *NSString)  {
	C.CBCentralManager_inst_SetValueForKeyPath(o.Ptr(), value.Ptr(), keyPath.Ptr())
	runtime.KeepAlive(o)
}

func (o *CBCentralManager) SetValueForUndefinedKey(value NSObject, key *NSString)  {
	C.CBCentralManager_inst_SetValueForUndefinedKey(o.Ptr(), value.Ptr(), key.Ptr())
	runtime.KeepAlive(o)
}

func (o *CBCentralManager) IsScanning() bool {
	ret := (bool)(C.CBCentralManager_inst_IsScanning(o.Ptr()))
	runtime.KeepAlive(o)
	return ret
}

func (o *CBCentralManager) InitWithDelegateQueue(delegate NSObject, queue Dispatch_queue_t) *CBCentralManager {
	ret := &CBCentralManager{}
	ret.ptr = unsafe.Pointer(C.CBCentralManager_inst_InitWithDelegateQueue(o.Ptr(), delegate.Ptr(), queue.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*CBCentralManager)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *CBCentralManager) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *CBCentralManager) InitWithDelegateQueueOptions(delegate NSObject, queue Dispatch_queue_t, options *NSDictionary) *CBCentralManager {
	ret := &CBCentralManager{}
	ret.ptr = unsafe.Pointer(C.CBCentralManager_inst_InitWithDelegateQueueOptions(o.Ptr(), delegate.Ptr(), queue.Ptr(), options.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*CBCentralManager)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *CBCentralManager) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *CBCentralManager) IsGreaterThanOrEqualTo(object NSObject) bool {
	ret := (bool)(C.CBCentralManager_inst_IsGreaterThanOrEqualTo(o.Ptr(), object.Ptr()))
	runtime.KeepAlive(o)
	return ret
}

func (o *CBCentralManager) IsEqualTo(object NSObject) bool {
	ret := (bool)(C.CBCentralManager_inst_IsEqualTo(o.Ptr(), object.Ptr()))
	runtime.KeepAlive(o)
	return ret
}

func (o *CBCentralManager) ReplaceValueAtIndexInPropertyWithKey(index NSUInteger, key *NSString, value NSObject)  {
	C.CBCentralManager_inst_ReplaceValueAtIndexInPropertyWithKey(o.Ptr(), (C.NSUInteger)(index), key.Ptr(), value.Ptr())
	runtime.KeepAlive(o)
}

func (o *CBCentralManager) ReplaceValueAtIndexInPropertyWithKeyWithValue(index NSUInteger, key *NSString, value NSObject)  {
	C.CBCentralManager_inst_ReplaceValueAtIndexInPropertyWithKeyWithValue(o.Ptr(), (C.NSUInteger)(index), key.Ptr(), value.Ptr())
	runtime.KeepAlive(o)
}

func (o *CBCentralManager) DidChangeValueForKey(key *NSString)  {
	C.CBCentralManager_inst_DidChangeValueForKey(o.Ptr(), key.Ptr())
	runtime.KeepAlive(o)
}

func (o *CBCentralManager) DidChangeValueForKeyWithSetMutation(key *NSString, mutationKind NSKeyValueSetMutationKind, objects *NSSet)  {
	C.CBCentralManager_inst_DidChangeValueForKeyWithSetMutation(o.Ptr(), key.Ptr(), (C.NSKeyValueSetMutationKind)(mutationKind), objects.Ptr())
	runtime.KeepAlive(o)
}

func (o *CBCentralManager) DidChangeValueForKeyWithSetMutationUsingObjects(key *NSString, mutationKind NSKeyValueSetMutationKind, objects *NSSet)  {
	C.CBCentralManager_inst_DidChangeValueForKeyWithSetMutationUsingObjects(o.Ptr(), key.Ptr(), (C.NSKeyValueSetMutationKind)(mutationKind), objects.Ptr())
	runtime.KeepAlive(o)
}

func (o *CBCentralManager) Delegate() *Id {
	ret := &Id{}
	ret.ptr = unsafe.Pointer(C.CBCentralManager_inst_Delegate(o.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *Id) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *CBCentralManager) AwakeAfterUsingCoder(coder *NSCoder) *Id {
	ret := &Id{}
	ret.ptr = unsafe.Pointer(C.CBCentralManager_inst_AwakeAfterUsingCoder(o.Ptr(), coder.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *Id) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *CBCentralManager) ToManyRelationshipKeys() *NSArray {
	ret := &NSArray{}
	ret.ptr = unsafe.Pointer(C.CBCentralManager_inst_ToManyRelationshipKeys(o.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSArray)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *NSArray) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *CBCentralManager) ObservationInfo() unsafe.Pointer {
	ret := (unsafe.Pointer)(unsafe.Pointer(C.CBCentralManager_inst_ObservationInfo(o.Ptr())))
	runtime.KeepAlive(o)
	return ret
}

func (o *CBCentralManager) WillChangeValueForKey(key *NSString)  {
	C.CBCentralManager_inst_WillChangeValueForKey(o.Ptr(), key.Ptr())
	runtime.KeepAlive(o)
}

func (o *CBCentralManager) WillChangeValueForKeyWithSetMutation(key *NSString, mutationKind NSKeyValueSetMutationKind, objects *NSSet)  {
	C.CBCentralManager_inst_WillChangeValueForKeyWithSetMutation(o.Ptr(), key.Ptr(), (C.NSKeyValueSetMutationKind)(mutationKind), objects.Ptr())
	runtime.KeepAlive(o)
}

func (o *CBCentralManager) WillChangeValueForKeyWithSetMutationUsingObjects(key *NSString, mutationKind NSKeyValueSetMutationKind, objects *NSSet)  {
	C.CBCentralManager_inst_WillChangeValueForKeyWithSetMutationUsingObjects(o.Ptr(), key.Ptr(), (C.NSKeyValueSetMutationKind)(mutationKind), objects.Ptr())
	runtime.KeepAlive(o)
}

func (o *CBCentralManager) ValueForKeyPath(keyPath *NSString) *Id {
	ret := &Id{}
	ret.ptr = unsafe.Pointer(C.CBCentralManager_inst_ValueForKeyPath(o.Ptr(), keyPath.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *Id) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *CBCentralManager) MethodSignatureForSelector(aSelector SEL) *NSMethodSignature {
	ret := &NSMethodSignature{}
	ret.ptr = unsafe.Pointer(C.CBCentralManager_inst_MethodSignatureForSelector(o.Ptr(), unsafe.Pointer(aSelector)))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSMethodSignature)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *NSMethodSignature) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *CBCentralManager) ClassForCoder() Class {
	ret := (Class)(unsafe.Pointer(C.CBCentralManager_inst_ClassForCoder(o.Ptr())))
	runtime.KeepAlive(o)
	return ret
}

func (o *CBCentralManager) ForwardingTargetForSelector(aSelector SEL) *Id {
	ret := &Id{}
	ret.ptr = unsafe.Pointer(C.CBCentralManager_inst_ForwardingTargetForSelector(o.Ptr(), unsafe.Pointer(aSelector)))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *Id) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *CBCentralManager) ValueAtIndexInPropertyWithKey(index NSUInteger, key *NSString) *Id {
	ret := &Id{}
	ret.ptr = unsafe.Pointer(C.CBCentralManager_inst_ValueAtIndexInPropertyWithKey(o.Ptr(), (C.NSUInteger)(index), key.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *Id) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *CBCentralManager) SetObservationInfo(observationInfo unsafe.Pointer)  {
	C.CBCentralManager_inst_SetObservationInfo(o.Ptr(), unsafe.Pointer(observationInfo))
	runtime.KeepAlive(o)
}

func (o *CBCentralManager) IsLessThan(object NSObject) bool {
	ret := (bool)(C.CBCentralManager_inst_IsLessThan(o.Ptr(), object.Ptr()))
	runtime.KeepAlive(o)
	return ret
}

func (o *CBCentralManager) MutableSetValueForKey(key *NSString) *NSMutableSet {
	ret := &NSMutableSet{}
	ret.ptr = unsafe.Pointer(C.CBCentralManager_inst_MutableSetValueForKey(o.Ptr(), key.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSMutableSet)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *NSMutableSet) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *CBCentralManager) SetScriptingProperties(scriptingProperties *NSDictionary)  {
	C.CBCentralManager_inst_SetScriptingProperties(o.Ptr(), scriptingProperties.Ptr())
	runtime.KeepAlive(o)
}

func (o *CBCentralManager) ClassDescription() *NSClassDescription {
	ret := &NSClassDescription{}
	ret.ptr = unsafe.Pointer(C.CBCentralManager_inst_ClassDescription(o.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSClassDescription)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *NSClassDescription) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *CBCentralManager) PerformSelectorOnMainThreadWithObject(aSelector SEL, arg NSObject, wait BOOL)  {
	C.CBCentralManager_inst_PerformSelectorOnMainThreadWithObject(o.Ptr(), unsafe.Pointer(aSelector), arg.Ptr(), (C.BOOL)(wait))
	runtime.KeepAlive(o)
}

func (o *CBCentralManager) PerformSelectorOnMainThreadWithObjectWaitUntilDone(aSelector SEL, arg NSObject, wait BOOL)  {
	C.CBCentralManager_inst_PerformSelectorOnMainThreadWithObjectWaitUntilDone(o.Ptr(), unsafe.Pointer(aSelector), arg.Ptr(), (C.BOOL)(wait))
	runtime.KeepAlive(o)
}

func (o *CBCentralManager) PerformSelectorOnMainThreadWithObjectWaitUntilDoneModes(aSelector SEL, arg NSObject, wait BOOL, array *NSArray)  {
	C.CBCentralManager_inst_PerformSelectorOnMainThreadWithObjectWaitUntilDoneModes(o.Ptr(), unsafe.Pointer(aSelector), arg.Ptr(), (C.BOOL)(wait), array.Ptr())
	runtime.KeepAlive(o)
}

func (o *CBCentralManager) ClassForArchiver() Class {
	ret := (Class)(unsafe.Pointer(C.CBCentralManager_inst_ClassForArchiver(o.Ptr())))
	runtime.KeepAlive(o)
	return ret
}

func (o *CBCentralManager) ClassForKeyedArchiver() Class {
	ret := (Class)(unsafe.Pointer(C.CBCentralManager_inst_ClassForKeyedArchiver(o.Ptr())))
	runtime.KeepAlive(o)
	return ret
}

func (o *CBCentralManager) ReplacementObjectForCoder(coder *NSCoder) *Id {
	ret := &Id{}
	ret.ptr = unsafe.Pointer(C.CBCentralManager_inst_ReplacementObjectForCoder(o.Ptr(), coder.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *Id) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *CBCentralManager) DoesNotRecognizeSelector(aSelector SEL)  {
	C.CBCentralManager_inst_DoesNotRecognizeSelector(o.Ptr(), unsafe.Pointer(aSelector))
	runtime.KeepAlive(o)
}

func (o *CBCentralManager) DoesContain(object NSObject) bool {
	ret := (bool)(C.CBCentralManager_inst_DoesContain(o.Ptr(), object.Ptr()))
	runtime.KeepAlive(o)
	return ret
}

func (o *CBCentralManager) MutableOrderedSetValueForKeyPath(keyPath *NSString) *NSMutableOrderedSet {
	ret := &NSMutableOrderedSet{}
	ret.ptr = unsafe.Pointer(C.CBCentralManager_inst_MutableOrderedSetValueForKeyPath(o.Ptr(), keyPath.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSMutableOrderedSet)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *NSMutableOrderedSet) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *CBCentralManager) MutableArrayValueForKey(key *NSString) *NSMutableArray {
	ret := &NSMutableArray{}
	ret.ptr = unsafe.Pointer(C.CBCentralManager_inst_MutableArrayValueForKey(o.Ptr(), key.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSMutableArray)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *NSMutableArray) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *CBCentralManager) IndicesOfObjectsByEvaluatingObjectSpecifier(specifier *NSScriptObjectSpecifier) *NSArray {
	ret := &NSArray{}
	ret.ptr = unsafe.Pointer(C.CBCentralManager_inst_IndicesOfObjectsByEvaluatingObjectSpecifier(o.Ptr(), specifier.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSArray)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *NSArray) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *CBCentralManager) ScriptingContains(object NSObject) bool {
	ret := (bool)(C.CBCentralManager_inst_ScriptingContains(o.Ptr(), object.Ptr()))
	runtime.KeepAlive(o)
	return ret
}

func (o *CBCentralManager) RetrievePeripheralsWithIdentifiers(identifiers *NSArray) *NSArray {
	ret := &NSArray{}
	ret.ptr = unsafe.Pointer(C.CBCentralManager_inst_RetrievePeripheralsWithIdentifiers(o.Ptr(), identifiers.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSArray)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *NSArray) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *CBCentralManager) CancelPeripheralConnection(peripheral *CBPeripheral)  {
	C.CBCentralManager_inst_CancelPeripheralConnection(o.Ptr(), peripheral.Ptr())
	runtime.KeepAlive(o)
}

func (o *CBCentralManager) AttemptRecoveryFromErrorOptionIndex(error *NSError, recoveryOptionIndex NSUInteger) bool {
	ret := (bool)(C.CBCentralManager_inst_AttemptRecoveryFromErrorOptionIndex(o.Ptr(), error.Ptr(), (C.NSUInteger)(recoveryOptionIndex)))
	runtime.KeepAlive(o)
	return ret
}

func (o *CBCentralManager) AttemptRecoveryFromErrorOptionIndexDelegate(error *NSError, recoveryOptionIndex NSUInteger, delegate NSObject, didRecoverSelector SEL, contextInfo unsafe.Pointer)  {
	C.CBCentralManager_inst_AttemptRecoveryFromErrorOptionIndexDelegate(o.Ptr(), error.Ptr(), (C.NSUInteger)(recoveryOptionIndex), delegate.Ptr(), unsafe.Pointer(didRecoverSelector), unsafe.Pointer(contextInfo))
	runtime.KeepAlive(o)
}

func (o *CBCentralManager) AttemptRecoveryFromErrorOptionIndexDelegateDidRecoverSelector(error *NSError, recoveryOptionIndex NSUInteger, delegate NSObject, didRecoverSelector SEL, contextInfo unsafe.Pointer)  {
	C.CBCentralManager_inst_AttemptRecoveryFromErrorOptionIndexDelegateDidRecoverSelector(o.Ptr(), error.Ptr(), (C.NSUInteger)(recoveryOptionIndex), delegate.Ptr(), unsafe.Pointer(didRecoverSelector), unsafe.Pointer(contextInfo))
	runtime.KeepAlive(o)
}

func (o *CBCentralManager) SetValuesForKeysWithDictionary(keyedValues *NSDictionary)  {
	C.CBCentralManager_inst_SetValuesForKeysWithDictionary(o.Ptr(), keyedValues.Ptr())
	runtime.KeepAlive(o)
}

func (o *CBCentralManager) MutableCopy() *Id {
	ret := &Id{}
	ret.ptr = unsafe.Pointer(C.CBCentralManager_inst_MutableCopy(o.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	runtime.SetFinalizer(ret, func(o *Id) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *CBCentralManager) ScriptingIsLessThan(object NSObject) bool {
	ret := (bool)(C.CBCentralManager_inst_ScriptingIsLessThan(o.Ptr(), object.Ptr()))
	runtime.KeepAlive(o)
	return ret
}

func (o *CBCentralManager) ScriptingIsGreaterThan(object NSObject) bool {
	ret := (bool)(C.CBCentralManager_inst_ScriptingIsGreaterThan(o.Ptr(), object.Ptr()))
	runtime.KeepAlive(o)
	return ret
}

func (o *CBCentralManager) Init() *CBCentralManager {
	ret := &CBCentralManager{}
	ret.ptr = unsafe.Pointer(C.CBCentralManager_inst_Init(o.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*CBCentralManager)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *CBCentralManager) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *CBCentralManager) ObjectSpecifier() *NSScriptObjectSpecifier {
	ret := &NSScriptObjectSpecifier{}
	ret.ptr = unsafe.Pointer(C.CBCentralManager_inst_ObjectSpecifier(o.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSScriptObjectSpecifier)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *NSScriptObjectSpecifier) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *CBCentralManager) Copy() *Id {
	ret := &Id{}
	ret.ptr = unsafe.Pointer(C.CBCentralManager_inst_Copy(o.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	runtime.SetFinalizer(ret, func(o *Id) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *CBCentralManager) ValidateValueForKey(ioValue *[]*Id, inKey *NSString, outError *[]*NSError) bool {

	goSlice1 := make([]unsafe.Pointer,cap(*ioValue))
	for i := 0; i < len(*ioValue); i++ {
		goSlice1[i] = (*ioValue)[i].Ptr()
	}

	goSlice3 := make([]unsafe.Pointer,cap(*outError))
	for i := 0; i < len(*outError); i++ {
		goSlice3[i] = (*outError)[i].Ptr()
	}
	ret := (bool)(C.CBCentralManager_inst_ValidateValueForKey(o.Ptr(), (*unsafe.Pointer)(unsafe.Pointer(&goSlice1[0])), inKey.Ptr(), (*unsafe.Pointer)(unsafe.Pointer(&goSlice3[0]))))
	(*ioValue) = (*ioValue)[:cap(*ioValue)]
	for i := 0; i < len(*ioValue); i++ {
		if goSlice1[i] == nil {
			(*ioValue) = (*ioValue)[:i]
			break
		}
		if (*ioValue)[i] == nil {
			(*ioValue)[i] = &Id{}
			runtime.SetFinalizer((*ioValue)[i], func(o *Id) {
				o.Release()
			})
		}
		(*ioValue)[i].ptr = goSlice1[i]
	}
	(*outError) = (*outError)[:cap(*outError)]
	for i := 0; i < len(*outError); i++ {
		if goSlice3[i] == nil {
			(*outError) = (*outError)[:i]
			break
		}
		if (*outError)[i] == nil {
			(*outError)[i] = &NSError{}
			runtime.SetFinalizer((*outError)[i], func(o *NSError) {
				o.Release()
			})
		}
		(*outError)[i].ptr = goSlice3[i]
	}
	runtime.KeepAlive(o)
	return ret
}

func (o *CBCentralManager) ValidateValueForKeyPath(ioValue *[]*Id, inKeyPath *NSString, outError *[]*NSError) bool {

	goSlice1 := make([]unsafe.Pointer,cap(*ioValue))
	for i := 0; i < len(*ioValue); i++ {
		goSlice1[i] = (*ioValue)[i].Ptr()
	}

	goSlice3 := make([]unsafe.Pointer,cap(*outError))
	for i := 0; i < len(*outError); i++ {
		goSlice3[i] = (*outError)[i].Ptr()
	}
	ret := (bool)(C.CBCentralManager_inst_ValidateValueForKeyPath(o.Ptr(), (*unsafe.Pointer)(unsafe.Pointer(&goSlice1[0])), inKeyPath.Ptr(), (*unsafe.Pointer)(unsafe.Pointer(&goSlice3[0]))))
	(*ioValue) = (*ioValue)[:cap(*ioValue)]
	for i := 0; i < len(*ioValue); i++ {
		if goSlice1[i] == nil {
			(*ioValue) = (*ioValue)[:i]
			break
		}
		if (*ioValue)[i] == nil {
			(*ioValue)[i] = &Id{}
			runtime.SetFinalizer((*ioValue)[i], func(o *Id) {
				o.Release()
			})
		}
		(*ioValue)[i].ptr = goSlice1[i]
	}
	(*outError) = (*outError)[:cap(*outError)]
	for i := 0; i < len(*outError); i++ {
		if goSlice3[i] == nil {
			(*outError) = (*outError)[:i]
			break
		}
		if (*outError)[i] == nil {
			(*outError)[i] = &NSError{}
			runtime.SetFinalizer((*outError)[i], func(o *NSError) {
				o.Release()
			})
		}
		(*outError)[i].ptr = goSlice3[i]
	}
	runtime.KeepAlive(o)
	return ret
}

func (o *CBCentralManager) ValidateValueForKeyError(ioValue *[]*Id, inKey *NSString, outError *[]*NSError) bool {

	goSlice1 := make([]unsafe.Pointer,cap(*ioValue))
	for i := 0; i < len(*ioValue); i++ {
		goSlice1[i] = (*ioValue)[i].Ptr()
	}

	goSlice3 := make([]unsafe.Pointer,cap(*outError))
	for i := 0; i < len(*outError); i++ {
		goSlice3[i] = (*outError)[i].Ptr()
	}
	ret := (bool)(C.CBCentralManager_inst_ValidateValueForKeyError(o.Ptr(), (*unsafe.Pointer)(unsafe.Pointer(&goSlice1[0])), inKey.Ptr(), (*unsafe.Pointer)(unsafe.Pointer(&goSlice3[0]))))
	(*ioValue) = (*ioValue)[:cap(*ioValue)]
	for i := 0; i < len(*ioValue); i++ {
		if goSlice1[i] == nil {
			(*ioValue) = (*ioValue)[:i]
			break
		}
		if (*ioValue)[i] == nil {
			(*ioValue)[i] = &Id{}
			runtime.SetFinalizer((*ioValue)[i], func(o *Id) {
				o.Release()
			})
		}
		(*ioValue)[i].ptr = goSlice1[i]
	}
	(*outError) = (*outError)[:cap(*outError)]
	for i := 0; i < len(*outError); i++ {
		if goSlice3[i] == nil {
			(*outError) = (*outError)[:i]
			break
		}
		if (*outError)[i] == nil {
			(*outError)[i] = &NSError{}
			runtime.SetFinalizer((*outError)[i], func(o *NSError) {
				o.Release()
			})
		}
		(*outError)[i].ptr = goSlice3[i]
	}
	runtime.KeepAlive(o)
	return ret
}

func (o *CBCentralManager) ValidateValueForKeyPathError(ioValue *[]*Id, inKeyPath *NSString, outError *[]*NSError) bool {

	goSlice1 := make([]unsafe.Pointer,cap(*ioValue))
	for i := 0; i < len(*ioValue); i++ {
		goSlice1[i] = (*ioValue)[i].Ptr()
	}

	goSlice3 := make([]unsafe.Pointer,cap(*outError))
	for i := 0; i < len(*outError); i++ {
		goSlice3[i] = (*outError)[i].Ptr()
	}
	ret := (bool)(C.CBCentralManager_inst_ValidateValueForKeyPathError(o.Ptr(), (*unsafe.Pointer)(unsafe.Pointer(&goSlice1[0])), inKeyPath.Ptr(), (*unsafe.Pointer)(unsafe.Pointer(&goSlice3[0]))))
	(*ioValue) = (*ioValue)[:cap(*ioValue)]
	for i := 0; i < len(*ioValue); i++ {
		if goSlice1[i] == nil {
			(*ioValue) = (*ioValue)[:i]
			break
		}
		if (*ioValue)[i] == nil {
			(*ioValue)[i] = &Id{}
			runtime.SetFinalizer((*ioValue)[i], func(o *Id) {
				o.Release()
			})
		}
		(*ioValue)[i].ptr = goSlice1[i]
	}
	(*outError) = (*outError)[:cap(*outError)]
	for i := 0; i < len(*outError); i++ {
		if goSlice3[i] == nil {
			(*outError) = (*outError)[:i]
			break
		}
		if (*outError)[i] == nil {
			(*outError)[i] = &NSError{}
			runtime.SetFinalizer((*outError)[i], func(o *NSError) {
				o.Release()
			})
		}
		(*outError)[i].ptr = goSlice3[i]
	}
	runtime.KeepAlive(o)
	return ret
}

func (o *CBCentralManager) CoerceValueForKey(value NSObject, key *NSString) *Id {
	ret := &Id{}
	ret.ptr = unsafe.Pointer(C.CBCentralManager_inst_CoerceValueForKey(o.Ptr(), value.Ptr(), key.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *Id) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *CBCentralManager) ForwardInvocation(anInvocation *NSInvocation)  {
	C.CBCentralManager_inst_ForwardInvocation(o.Ptr(), anInvocation.Ptr())
	runtime.KeepAlive(o)
}

func (o *CBCentralManager) ConnectPeripheral(peripheral *CBPeripheral, options *NSDictionary)  {
	C.CBCentralManager_inst_ConnectPeripheral(o.Ptr(), peripheral.Ptr(), options.Ptr())
	runtime.KeepAlive(o)
}

func (o *CBCentralManager) DictionaryWithValuesForKeys(keys *NSArray) *NSDictionary {
	ret := &NSDictionary{}
	ret.ptr = unsafe.Pointer(C.CBCentralManager_inst_DictionaryWithValuesForKeys(o.Ptr(), keys.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSDictionary)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *NSDictionary) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *CBCentralManager) ScriptingIsEqualTo(object NSObject) bool {
	ret := (bool)(C.CBCentralManager_inst_ScriptingIsEqualTo(o.Ptr(), object.Ptr()))
	runtime.KeepAlive(o)
	return ret
}

func (o *CBCentralManager) ClassName() *NSString {
	ret := &NSString{}
	ret.ptr = unsafe.Pointer(C.CBCentralManager_inst_ClassName(o.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSString)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *NSString) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *CBCentralManager) RemoveObserverForKeyPath(observer NSObject, keyPath *NSString)  {
	C.CBCentralManager_inst_RemoveObserverForKeyPath(o.Ptr(), observer.Ptr(), keyPath.Ptr())
	runtime.KeepAlive(o)
}

func (o *CBCentralManager) RemoveObserverForKeyPathContext(observer NSObject, keyPath *NSString, context unsafe.Pointer)  {
	C.CBCentralManager_inst_RemoveObserverForKeyPathContext(o.Ptr(), observer.Ptr(), keyPath.Ptr(), unsafe.Pointer(context))
	runtime.KeepAlive(o)
}

func (o *CBCentralManager) RemoveValueAtIndexFromPropertyWithKey(index NSUInteger, key *NSString)  {
	C.CBCentralManager_inst_RemoveValueAtIndexFromPropertyWithKey(o.Ptr(), (C.NSUInteger)(index), key.Ptr())
	runtime.KeepAlive(o)
}

func (o *CBCentralManager) MutableSetValueForKeyPath(keyPath *NSString) *NSMutableSet {
	ret := &NSMutableSet{}
	ret.ptr = unsafe.Pointer(C.CBCentralManager_inst_MutableSetValueForKeyPath(o.Ptr(), keyPath.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSMutableSet)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *NSMutableSet) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *CBCentralManager) MutableOrderedSetValueForKey(key *NSString) *NSMutableOrderedSet {
	ret := &NSMutableOrderedSet{}
	ret.ptr = unsafe.Pointer(C.CBCentralManager_inst_MutableOrderedSetValueForKey(o.Ptr(), key.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSMutableOrderedSet)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *NSMutableOrderedSet) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *CBCentralManager) IsNotEqualTo(object NSObject) bool {
	ret := (bool)(C.CBCentralManager_inst_IsNotEqualTo(o.Ptr(), object.Ptr()))
	runtime.KeepAlive(o)
	return ret
}

func (o *CBCentralManager) Dealloc()  {
	C.CBCentralManager_inst_Dealloc(o.Ptr())
	runtime.KeepAlive(o)
}

func (o *CBCentralManager) ValueForKey(key *NSString) *Id {
	ret := &Id{}
	ret.ptr = unsafe.Pointer(C.CBCentralManager_inst_ValueForKey(o.Ptr(), key.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *Id) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *CBCentralManager) PerformSelectorInBackgroundWithObject(aSelector SEL, arg NSObject)  {
	C.CBCentralManager_inst_PerformSelectorInBackgroundWithObject(o.Ptr(), unsafe.Pointer(aSelector), arg.Ptr())
	runtime.KeepAlive(o)
}

func (o *CBCentralManager) ScriptingProperties() *NSDictionary {
	ret := &NSDictionary{}
	ret.ptr = unsafe.Pointer(C.CBCentralManager_inst_ScriptingProperties(o.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSDictionary)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *NSDictionary) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *CBCentralManager) SetNilValueForKey(key *NSString)  {
	C.CBCentralManager_inst_SetNilValueForKey(o.Ptr(), key.Ptr())
	runtime.KeepAlive(o)
}

func (o *CBCentralManager) ScanForPeripheralsWithServices(serviceUUIDs *NSArray, options *NSDictionary)  {
	C.CBCentralManager_inst_ScanForPeripheralsWithServices(o.Ptr(), serviceUUIDs.Ptr(), options.Ptr())
	runtime.KeepAlive(o)
}

func (o *CBCentralManager) WillChangeValuesAtIndexes(changeKind NSKeyValueChange, indexes *NSIndexSet, key *NSString)  {
	C.CBCentralManager_inst_WillChangeValuesAtIndexes(o.Ptr(), (C.NSKeyValueChange)(changeKind), indexes.Ptr(), key.Ptr())
	runtime.KeepAlive(o)
}

func (o *CBCentralManager) WillChangeValuesAtIndexesForKey(changeKind NSKeyValueChange, indexes *NSIndexSet, key *NSString)  {
	C.CBCentralManager_inst_WillChangeValuesAtIndexesForKey(o.Ptr(), (C.NSKeyValueChange)(changeKind), indexes.Ptr(), key.Ptr())
	runtime.KeepAlive(o)
}

func CBCharacteristicCopyWithZone(zone *_NSZone) *Id {
	ret := &Id{}
	ret.ptr = unsafe.Pointer(C.CBCharacteristic_CopyWithZone(unsafe.Pointer(zone)))
	if ret.ptr == nil { return ret }
	runtime.SetFinalizer(ret, func(o *Id) {
		o.Release()
	})
	return ret
}

func CBCharacteristicMutableCopyWithZone(zone *_NSZone) *Id {
	ret := &Id{}
	ret.ptr = unsafe.Pointer(C.CBCharacteristic_MutableCopyWithZone(unsafe.Pointer(zone)))
	if ret.ptr == nil { return ret }
	runtime.SetFinalizer(ret, func(o *Id) {
		o.Release()
	})
	return ret
}

func CBCharacteristicAccessInstanceVariablesDirectly() bool {
	ret := (bool)(C.CBCharacteristic_AccessInstanceVariablesDirectly())
	return ret
}

func CBCharacteristicNew() *CBCharacteristic {
	ret := &CBCharacteristic{}
	ret.ptr = unsafe.Pointer(C.CBCharacteristic_New())
	if ret.ptr == nil { return ret }
	runtime.SetFinalizer(ret, func(o *CBCharacteristic) {
		o.Release()
	})
	return ret
}

func CBCharacteristicKeyPathsForValuesAffectingValueForKey(key *NSString) *NSSet {
	ret := &NSSet{}
	ret.ptr = unsafe.Pointer(C.CBCharacteristic_KeyPathsForValuesAffectingValueForKey(key.Ptr()))
	if ret.ptr == nil { return ret }
	return ret
}

func CBCharacteristicLoad()  {
	C.CBCharacteristic_Load()
}

func CBCharacteristicIsSubclassOfClass(aClass Class) bool {
	ret := (bool)(C.CBCharacteristic_IsSubclassOfClass(unsafe.Pointer(aClass)))
	return ret
}

func CBCharacteristicCancelPreviousPerformRequestsWithTarget(aTarget NSObject)  {
	C.CBCharacteristic_CancelPreviousPerformRequestsWithTarget(aTarget.Ptr())
}

func CBCharacteristicCancelPreviousPerformRequestsWithTargetSelector(aTarget NSObject, aSelector SEL, anArgument NSObject)  {
	C.CBCharacteristic_CancelPreviousPerformRequestsWithTargetSelector(aTarget.Ptr(), unsafe.Pointer(aSelector), anArgument.Ptr())
}

func CBCharacteristicCancelPreviousPerformRequestsWithTargetSelectorObject(aTarget NSObject, aSelector SEL, anArgument NSObject)  {
	C.CBCharacteristic_CancelPreviousPerformRequestsWithTargetSelectorObject(aTarget.Ptr(), unsafe.Pointer(aSelector), anArgument.Ptr())
}

func CBCharacteristicAlloc() *CBCharacteristic {
	ret := &CBCharacteristic{}
	ret.ptr = unsafe.Pointer(C.CBCharacteristic_Alloc())
	if ret.ptr == nil { return ret }
	runtime.SetFinalizer(ret, func(o *CBCharacteristic) {
		o.Release()
	})
	return ret
}

func (o *CBCharacteristic) GC() {
	if o.ptr == nil { return }
	runtime.SetFinalizer(o, func(o *CBCharacteristic) {
		o.Release()
	})
	runtime.KeepAlive(o)
}

func CBCharacteristicResolveClassMethod(sel SEL) bool {
	ret := (bool)(C.CBCharacteristic_ResolveClassMethod(unsafe.Pointer(sel)))
	return ret
}

func CBCharacteristicDebugDescription() *NSString {
	ret := &NSString{}
	ret.ptr = unsafe.Pointer(C.CBCharacteristic_DebugDescription())
	if ret.ptr == nil { return ret }
	return ret
}

func CBCharacteristicDescription() *NSString {
	ret := &NSString{}
	ret.ptr = unsafe.Pointer(C.CBCharacteristic_Description())
	if ret.ptr == nil { return ret }
	return ret
}

func CBCharacteristicInstanceMethodSignatureForSelector(aSelector SEL) *NSMethodSignature {
	ret := &NSMethodSignature{}
	ret.ptr = unsafe.Pointer(C.CBCharacteristic_InstanceMethodSignatureForSelector(unsafe.Pointer(aSelector)))
	if ret.ptr == nil { return ret }
	return ret
}

func CBCharacteristicAutomaticallyNotifiesObserversForKey(key *NSString) bool {
	ret := (bool)(C.CBCharacteristic_AutomaticallyNotifiesObserversForKey(key.Ptr()))
	return ret
}

func CBCharacteristicConformsToProtocol(protocol Protocol) bool {
	ret := (bool)(C.CBCharacteristic_ConformsToProtocol(protocol.Ptr()))
	return ret
}

func CBCharacteristicSetVersion(aVersion NSInteger)  {
	C.CBCharacteristic_SetVersion((C.NSInteger)(aVersion))
}

func CBCharacteristicSuperclass() Class {
	ret := (Class)(unsafe.Pointer(C.CBCharacteristic_Superclass()))
	return ret
}

func CBCharacteristicInstancesRespondToSelector(aSelector SEL) bool {
	ret := (bool)(C.CBCharacteristic_InstancesRespondToSelector(unsafe.Pointer(aSelector)))
	return ret
}

func CBCharacteristicClassForKeyedUnarchiver() Class {
	ret := (Class)(unsafe.Pointer(C.CBCharacteristic_ClassForKeyedUnarchiver()))
	return ret
}

func CBCharacteristicResolveInstanceMethod(sel SEL) bool {
	ret := (bool)(C.CBCharacteristic_ResolveInstanceMethod(unsafe.Pointer(sel)))
	return ret
}

func CBCharacteristicAllocWithZone(zone *_NSZone) *CBCharacteristic {
	ret := &CBCharacteristic{}
	ret.ptr = unsafe.Pointer(C.CBCharacteristic_AllocWithZone(unsafe.Pointer(zone)))
	if ret.ptr == nil { return ret }
	runtime.SetFinalizer(ret, func(o *CBCharacteristic) {
		o.Release()
	})
	return ret
}

func CBCharacteristicVersion() NSInteger {
	ret := (NSInteger)(C.CBCharacteristic_Version())
	return ret
}

func CBCharacteristicClassFallbacksForKeyedArchiver() *NSArray {
	ret := &NSArray{}
	ret.ptr = unsafe.Pointer(C.CBCharacteristic_ClassFallbacksForKeyedArchiver())
	if ret.ptr == nil { return ret }
	return ret
}

func CBCharacteristicClass() Class {
	ret := (Class)(unsafe.Pointer(C.CBCharacteristic_Class()))
	return ret
}

func CBCharacteristicHash() NSUInteger {
	ret := (NSUInteger)(C.CBCharacteristic_Hash())
	return ret
}

func (o *CBCharacteristic) ClassForCoder() Class {
	ret := (Class)(unsafe.Pointer(C.CBCharacteristic_inst_ClassForCoder(o.Ptr())))
	runtime.KeepAlive(o)
	return ret
}

func (o *CBCharacteristic) WillChangeValuesAtIndexes(changeKind NSKeyValueChange, indexes *NSIndexSet, key *NSString)  {
	C.CBCharacteristic_inst_WillChangeValuesAtIndexes(o.Ptr(), (C.NSKeyValueChange)(changeKind), indexes.Ptr(), key.Ptr())
	runtime.KeepAlive(o)
}

func (o *CBCharacteristic) WillChangeValuesAtIndexesForKey(changeKind NSKeyValueChange, indexes *NSIndexSet, key *NSString)  {
	C.CBCharacteristic_inst_WillChangeValuesAtIndexesForKey(o.Ptr(), (C.NSKeyValueChange)(changeKind), indexes.Ptr(), key.Ptr())
	runtime.KeepAlive(o)
}

func (o *CBCharacteristic) ValueForKeyPath(keyPath *NSString) *Id {
	ret := &Id{}
	ret.ptr = unsafe.Pointer(C.CBCharacteristic_inst_ValueForKeyPath(o.Ptr(), keyPath.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *Id) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *CBCharacteristic) Value() *NSData {
	ret := &NSData{}
	ret.ptr = unsafe.Pointer(C.CBCharacteristic_inst_Value(o.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSData)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *NSData) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *CBCharacteristic) ValueWithUniqueIDInPropertyWithKey(uniqueID NSObject, key *NSString) *Id {
	ret := &Id{}
	ret.ptr = unsafe.Pointer(C.CBCharacteristic_inst_ValueWithUniqueIDInPropertyWithKey(o.Ptr(), uniqueID.Ptr(), key.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *Id) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *CBCharacteristic) MutableArrayValueForKey(key *NSString) *NSMutableArray {
	ret := &NSMutableArray{}
	ret.ptr = unsafe.Pointer(C.CBCharacteristic_inst_MutableArrayValueForKey(o.Ptr(), key.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSMutableArray)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *NSMutableArray) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *CBCharacteristic) ClassName() *NSString {
	ret := &NSString{}
	ret.ptr = unsafe.Pointer(C.CBCharacteristic_inst_ClassName(o.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSString)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *NSString) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *CBCharacteristic) ClassForArchiver() Class {
	ret := (Class)(unsafe.Pointer(C.CBCharacteristic_inst_ClassForArchiver(o.Ptr())))
	runtime.KeepAlive(o)
	return ret
}

func (o *CBCharacteristic) CopyScriptingValueForKey(value NSObject, key *NSString, properties *NSDictionary) *Id {
	ret := &Id{}
	ret.ptr = unsafe.Pointer(C.CBCharacteristic_inst_CopyScriptingValueForKey(o.Ptr(), value.Ptr(), key.Ptr(), properties.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *Id) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *CBCharacteristic) CopyScriptingValueForKeyWithProperties(value NSObject, key *NSString, properties *NSDictionary) *Id {
	ret := &Id{}
	ret.ptr = unsafe.Pointer(C.CBCharacteristic_inst_CopyScriptingValueForKeyWithProperties(o.Ptr(), value.Ptr(), key.Ptr(), properties.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *Id) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *CBCharacteristic) IsNotifying() bool {
	ret := (bool)(C.CBCharacteristic_inst_IsNotifying(o.Ptr()))
	runtime.KeepAlive(o)
	return ret
}

func (o *CBCharacteristic) ScriptingValueForSpecifier(objectSpecifier *NSScriptObjectSpecifier) *Id {
	ret := &Id{}
	ret.ptr = unsafe.Pointer(C.CBCharacteristic_inst_ScriptingValueForSpecifier(o.Ptr(), objectSpecifier.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *Id) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *CBCharacteristic) PerformSelectorWithObject(aSelector SEL, anArgument NSObject, delay NSTimeInterval)  {
	C.CBCharacteristic_inst_PerformSelectorWithObject(o.Ptr(), unsafe.Pointer(aSelector), anArgument.Ptr(), (C.NSTimeInterval)(delay))
	runtime.KeepAlive(o)
}

func (o *CBCharacteristic) PerformSelectorWithObjectAfterDelay(aSelector SEL, anArgument NSObject, delay NSTimeInterval)  {
	C.CBCharacteristic_inst_PerformSelectorWithObjectAfterDelay(o.Ptr(), unsafe.Pointer(aSelector), anArgument.Ptr(), (C.NSTimeInterval)(delay))
	runtime.KeepAlive(o)
}

func (o *CBCharacteristic) PerformSelectorWithObjectAfterDelayInModes(aSelector SEL, anArgument NSObject, delay NSTimeInterval, modes *NSArray)  {
	C.CBCharacteristic_inst_PerformSelectorWithObjectAfterDelayInModes(o.Ptr(), unsafe.Pointer(aSelector), anArgument.Ptr(), (C.NSTimeInterval)(delay), modes.Ptr())
	runtime.KeepAlive(o)
}

func (o *CBCharacteristic) PerformSelectorOnThread(aSelector SEL, thr *NSThread, arg NSObject, wait BOOL)  {
	C.CBCharacteristic_inst_PerformSelectorOnThread(o.Ptr(), unsafe.Pointer(aSelector), thr.Ptr(), arg.Ptr(), (C.BOOL)(wait))
	runtime.KeepAlive(o)
}

func (o *CBCharacteristic) PerformSelectorOnThreadWithObject(aSelector SEL, thr *NSThread, arg NSObject, wait BOOL)  {
	C.CBCharacteristic_inst_PerformSelectorOnThreadWithObject(o.Ptr(), unsafe.Pointer(aSelector), thr.Ptr(), arg.Ptr(), (C.BOOL)(wait))
	runtime.KeepAlive(o)
}

func (o *CBCharacteristic) PerformSelectorOnThreadWithObjectWaitUntilDone(aSelector SEL, thr *NSThread, arg NSObject, wait BOOL, array *NSArray)  {
	C.CBCharacteristic_inst_PerformSelectorOnThreadWithObjectWaitUntilDone(o.Ptr(), unsafe.Pointer(aSelector), thr.Ptr(), arg.Ptr(), (C.BOOL)(wait), array.Ptr())
	runtime.KeepAlive(o)
}

func (o *CBCharacteristic) PerformSelectorOnThreadWithObjectWaitUntilDoneModes(aSelector SEL, thr *NSThread, arg NSObject, wait BOOL, array *NSArray)  {
	C.CBCharacteristic_inst_PerformSelectorOnThreadWithObjectWaitUntilDoneModes(o.Ptr(), unsafe.Pointer(aSelector), thr.Ptr(), arg.Ptr(), (C.BOOL)(wait), array.Ptr())
	runtime.KeepAlive(o)
}

func (o *CBCharacteristic) PerformSelectorInBackgroundWithObject(aSelector SEL, arg NSObject)  {
	C.CBCharacteristic_inst_PerformSelectorInBackgroundWithObject(o.Ptr(), unsafe.Pointer(aSelector), arg.Ptr())
	runtime.KeepAlive(o)
}

func (o *CBCharacteristic) ScriptingIsGreaterThan(object NSObject) bool {
	ret := (bool)(C.CBCharacteristic_inst_ScriptingIsGreaterThan(o.Ptr(), object.Ptr()))
	runtime.KeepAlive(o)
	return ret
}

func (o *CBCharacteristic) Copy() *Id {
	ret := &Id{}
	ret.ptr = unsafe.Pointer(C.CBCharacteristic_inst_Copy(o.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	runtime.SetFinalizer(ret, func(o *Id) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *CBCharacteristic) ObserveValueForKeyPathOfObject(keyPath *NSString, object NSObject, change *NSDictionary, context unsafe.Pointer)  {
	C.CBCharacteristic_inst_ObserveValueForKeyPathOfObject(o.Ptr(), keyPath.Ptr(), object.Ptr(), change.Ptr(), unsafe.Pointer(context))
	runtime.KeepAlive(o)
}

func (o *CBCharacteristic) ObserveValueForKeyPathOfObjectChange(keyPath *NSString, object NSObject, change *NSDictionary, context unsafe.Pointer)  {
	C.CBCharacteristic_inst_ObserveValueForKeyPathOfObjectChange(o.Ptr(), keyPath.Ptr(), object.Ptr(), change.Ptr(), unsafe.Pointer(context))
	runtime.KeepAlive(o)
}

func (o *CBCharacteristic) IsLessThanOrEqualTo(object NSObject) bool {
	ret := (bool)(C.CBCharacteristic_inst_IsLessThanOrEqualTo(o.Ptr(), object.Ptr()))
	runtime.KeepAlive(o)
	return ret
}

func (o *CBCharacteristic) ValueForUndefinedKey(key *NSString) *Id {
	ret := &Id{}
	ret.ptr = unsafe.Pointer(C.CBCharacteristic_inst_ValueForUndefinedKey(o.Ptr(), key.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *Id) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *CBCharacteristic) PerformSelectorOnMainThreadWithObject(aSelector SEL, arg NSObject, wait BOOL)  {
	C.CBCharacteristic_inst_PerformSelectorOnMainThreadWithObject(o.Ptr(), unsafe.Pointer(aSelector), arg.Ptr(), (C.BOOL)(wait))
	runtime.KeepAlive(o)
}

func (o *CBCharacteristic) PerformSelectorOnMainThreadWithObjectWaitUntilDone(aSelector SEL, arg NSObject, wait BOOL)  {
	C.CBCharacteristic_inst_PerformSelectorOnMainThreadWithObjectWaitUntilDone(o.Ptr(), unsafe.Pointer(aSelector), arg.Ptr(), (C.BOOL)(wait))
	runtime.KeepAlive(o)
}

func (o *CBCharacteristic) PerformSelectorOnMainThreadWithObjectWaitUntilDoneModes(aSelector SEL, arg NSObject, wait BOOL, array *NSArray)  {
	C.CBCharacteristic_inst_PerformSelectorOnMainThreadWithObjectWaitUntilDoneModes(o.Ptr(), unsafe.Pointer(aSelector), arg.Ptr(), (C.BOOL)(wait), array.Ptr())
	runtime.KeepAlive(o)
}

func (o *CBCharacteristic) ScriptingBeginsWith(object NSObject) bool {
	ret := (bool)(C.CBCharacteristic_inst_ScriptingBeginsWith(o.Ptr(), object.Ptr()))
	runtime.KeepAlive(o)
	return ret
}

func (o *CBCharacteristic) ForwardingTargetForSelector(aSelector SEL) *Id {
	ret := &Id{}
	ret.ptr = unsafe.Pointer(C.CBCharacteristic_inst_ForwardingTargetForSelector(o.Ptr(), unsafe.Pointer(aSelector)))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *Id) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *CBCharacteristic) RemoveValueAtIndexFromPropertyWithKey(index NSUInteger, key *NSString)  {
	C.CBCharacteristic_inst_RemoveValueAtIndexFromPropertyWithKey(o.Ptr(), (C.NSUInteger)(index), key.Ptr())
	runtime.KeepAlive(o)
}

func (o *CBCharacteristic) ObservationInfo() unsafe.Pointer {
	ret := (unsafe.Pointer)(unsafe.Pointer(C.CBCharacteristic_inst_ObservationInfo(o.Ptr())))
	runtime.KeepAlive(o)
	return ret
}

func (o *CBCharacteristic) NewScriptingObjectOfClassForValueForKey(objectClass Class, key *NSString, contentsValue NSObject, properties *NSDictionary) *Id {
	ret := &Id{}
	ret.ptr = unsafe.Pointer(C.CBCharacteristic_inst_NewScriptingObjectOfClassForValueForKey(o.Ptr(), unsafe.Pointer(objectClass), key.Ptr(), contentsValue.Ptr(), properties.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *Id) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *CBCharacteristic) NewScriptingObjectOfClassForValueForKeyWithContentsValue(objectClass Class, key *NSString, contentsValue NSObject, properties *NSDictionary) *Id {
	ret := &Id{}
	ret.ptr = unsafe.Pointer(C.CBCharacteristic_inst_NewScriptingObjectOfClassForValueForKeyWithContentsValue(o.Ptr(), unsafe.Pointer(objectClass), key.Ptr(), contentsValue.Ptr(), properties.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *Id) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *CBCharacteristic) ForwardInvocation(anInvocation *NSInvocation)  {
	C.CBCharacteristic_inst_ForwardInvocation(o.Ptr(), anInvocation.Ptr())
	runtime.KeepAlive(o)
}

func (o *CBCharacteristic) IsLessThan(object NSObject) bool {
	ret := (bool)(C.CBCharacteristic_inst_IsLessThan(o.Ptr(), object.Ptr()))
	runtime.KeepAlive(o)
	return ret
}

func (o *CBCharacteristic) DidChangeValueForKey(key *NSString)  {
	C.CBCharacteristic_inst_DidChangeValueForKey(o.Ptr(), key.Ptr())
	runtime.KeepAlive(o)
}

func (o *CBCharacteristic) DidChangeValueForKeyWithSetMutation(key *NSString, mutationKind NSKeyValueSetMutationKind, objects *NSSet)  {
	C.CBCharacteristic_inst_DidChangeValueForKeyWithSetMutation(o.Ptr(), key.Ptr(), (C.NSKeyValueSetMutationKind)(mutationKind), objects.Ptr())
	runtime.KeepAlive(o)
}

func (o *CBCharacteristic) DidChangeValueForKeyWithSetMutationUsingObjects(key *NSString, mutationKind NSKeyValueSetMutationKind, objects *NSSet)  {
	C.CBCharacteristic_inst_DidChangeValueForKeyWithSetMutationUsingObjects(o.Ptr(), key.Ptr(), (C.NSKeyValueSetMutationKind)(mutationKind), objects.Ptr())
	runtime.KeepAlive(o)
}

func (o *CBCharacteristic) MethodSignatureForSelector(aSelector SEL) *NSMethodSignature {
	ret := &NSMethodSignature{}
	ret.ptr = unsafe.Pointer(C.CBCharacteristic_inst_MethodSignatureForSelector(o.Ptr(), unsafe.Pointer(aSelector)))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSMethodSignature)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *NSMethodSignature) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *CBCharacteristic) IndicesOfObjectsByEvaluatingObjectSpecifier(specifier *NSScriptObjectSpecifier) *NSArray {
	ret := &NSArray{}
	ret.ptr = unsafe.Pointer(C.CBCharacteristic_inst_IndicesOfObjectsByEvaluatingObjectSpecifier(o.Ptr(), specifier.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSArray)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *NSArray) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *CBCharacteristic) InverseForRelationshipKey(relationshipKey *NSString) *NSString {
	ret := &NSString{}
	ret.ptr = unsafe.Pointer(C.CBCharacteristic_inst_InverseForRelationshipKey(o.Ptr(), relationshipKey.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSString)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *NSString) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *CBCharacteristic) ValidateValueForKey(ioValue *[]*Id, inKey *NSString, outError *[]*NSError) bool {

	goSlice1 := make([]unsafe.Pointer,cap(*ioValue))
	for i := 0; i < len(*ioValue); i++ {
		goSlice1[i] = (*ioValue)[i].Ptr()
	}

	goSlice3 := make([]unsafe.Pointer,cap(*outError))
	for i := 0; i < len(*outError); i++ {
		goSlice3[i] = (*outError)[i].Ptr()
	}
	ret := (bool)(C.CBCharacteristic_inst_ValidateValueForKey(o.Ptr(), (*unsafe.Pointer)(unsafe.Pointer(&goSlice1[0])), inKey.Ptr(), (*unsafe.Pointer)(unsafe.Pointer(&goSlice3[0]))))
	(*ioValue) = (*ioValue)[:cap(*ioValue)]
	for i := 0; i < len(*ioValue); i++ {
		if goSlice1[i] == nil {
			(*ioValue) = (*ioValue)[:i]
			break
		}
		if (*ioValue)[i] == nil {
			(*ioValue)[i] = &Id{}
			runtime.SetFinalizer((*ioValue)[i], func(o *Id) {
				o.Release()
			})
		}
		(*ioValue)[i].ptr = goSlice1[i]
	}
	(*outError) = (*outError)[:cap(*outError)]
	for i := 0; i < len(*outError); i++ {
		if goSlice3[i] == nil {
			(*outError) = (*outError)[:i]
			break
		}
		if (*outError)[i] == nil {
			(*outError)[i] = &NSError{}
			runtime.SetFinalizer((*outError)[i], func(o *NSError) {
				o.Release()
			})
		}
		(*outError)[i].ptr = goSlice3[i]
	}
	runtime.KeepAlive(o)
	return ret
}

func (o *CBCharacteristic) ValidateValueForKeyPath(ioValue *[]*Id, inKeyPath *NSString, outError *[]*NSError) bool {

	goSlice1 := make([]unsafe.Pointer,cap(*ioValue))
	for i := 0; i < len(*ioValue); i++ {
		goSlice1[i] = (*ioValue)[i].Ptr()
	}

	goSlice3 := make([]unsafe.Pointer,cap(*outError))
	for i := 0; i < len(*outError); i++ {
		goSlice3[i] = (*outError)[i].Ptr()
	}
	ret := (bool)(C.CBCharacteristic_inst_ValidateValueForKeyPath(o.Ptr(), (*unsafe.Pointer)(unsafe.Pointer(&goSlice1[0])), inKeyPath.Ptr(), (*unsafe.Pointer)(unsafe.Pointer(&goSlice3[0]))))
	(*ioValue) = (*ioValue)[:cap(*ioValue)]
	for i := 0; i < len(*ioValue); i++ {
		if goSlice1[i] == nil {
			(*ioValue) = (*ioValue)[:i]
			break
		}
		if (*ioValue)[i] == nil {
			(*ioValue)[i] = &Id{}
			runtime.SetFinalizer((*ioValue)[i], func(o *Id) {
				o.Release()
			})
		}
		(*ioValue)[i].ptr = goSlice1[i]
	}
	(*outError) = (*outError)[:cap(*outError)]
	for i := 0; i < len(*outError); i++ {
		if goSlice3[i] == nil {
			(*outError) = (*outError)[:i]
			break
		}
		if (*outError)[i] == nil {
			(*outError)[i] = &NSError{}
			runtime.SetFinalizer((*outError)[i], func(o *NSError) {
				o.Release()
			})
		}
		(*outError)[i].ptr = goSlice3[i]
	}
	runtime.KeepAlive(o)
	return ret
}

func (o *CBCharacteristic) ValidateValueForKeyError(ioValue *[]*Id, inKey *NSString, outError *[]*NSError) bool {

	goSlice1 := make([]unsafe.Pointer,cap(*ioValue))
	for i := 0; i < len(*ioValue); i++ {
		goSlice1[i] = (*ioValue)[i].Ptr()
	}

	goSlice3 := make([]unsafe.Pointer,cap(*outError))
	for i := 0; i < len(*outError); i++ {
		goSlice3[i] = (*outError)[i].Ptr()
	}
	ret := (bool)(C.CBCharacteristic_inst_ValidateValueForKeyError(o.Ptr(), (*unsafe.Pointer)(unsafe.Pointer(&goSlice1[0])), inKey.Ptr(), (*unsafe.Pointer)(unsafe.Pointer(&goSlice3[0]))))
	(*ioValue) = (*ioValue)[:cap(*ioValue)]
	for i := 0; i < len(*ioValue); i++ {
		if goSlice1[i] == nil {
			(*ioValue) = (*ioValue)[:i]
			break
		}
		if (*ioValue)[i] == nil {
			(*ioValue)[i] = &Id{}
			runtime.SetFinalizer((*ioValue)[i], func(o *Id) {
				o.Release()
			})
		}
		(*ioValue)[i].ptr = goSlice1[i]
	}
	(*outError) = (*outError)[:cap(*outError)]
	for i := 0; i < len(*outError); i++ {
		if goSlice3[i] == nil {
			(*outError) = (*outError)[:i]
			break
		}
		if (*outError)[i] == nil {
			(*outError)[i] = &NSError{}
			runtime.SetFinalizer((*outError)[i], func(o *NSError) {
				o.Release()
			})
		}
		(*outError)[i].ptr = goSlice3[i]
	}
	runtime.KeepAlive(o)
	return ret
}

func (o *CBCharacteristic) ValidateValueForKeyPathError(ioValue *[]*Id, inKeyPath *NSString, outError *[]*NSError) bool {

	goSlice1 := make([]unsafe.Pointer,cap(*ioValue))
	for i := 0; i < len(*ioValue); i++ {
		goSlice1[i] = (*ioValue)[i].Ptr()
	}

	goSlice3 := make([]unsafe.Pointer,cap(*outError))
	for i := 0; i < len(*outError); i++ {
		goSlice3[i] = (*outError)[i].Ptr()
	}
	ret := (bool)(C.CBCharacteristic_inst_ValidateValueForKeyPathError(o.Ptr(), (*unsafe.Pointer)(unsafe.Pointer(&goSlice1[0])), inKeyPath.Ptr(), (*unsafe.Pointer)(unsafe.Pointer(&goSlice3[0]))))
	(*ioValue) = (*ioValue)[:cap(*ioValue)]
	for i := 0; i < len(*ioValue); i++ {
		if goSlice1[i] == nil {
			(*ioValue) = (*ioValue)[:i]
			break
		}
		if (*ioValue)[i] == nil {
			(*ioValue)[i] = &Id{}
			runtime.SetFinalizer((*ioValue)[i], func(o *Id) {
				o.Release()
			})
		}
		(*ioValue)[i].ptr = goSlice1[i]
	}
	(*outError) = (*outError)[:cap(*outError)]
	for i := 0; i < len(*outError); i++ {
		if goSlice3[i] == nil {
			(*outError) = (*outError)[:i]
			break
		}
		if (*outError)[i] == nil {
			(*outError)[i] = &NSError{}
			runtime.SetFinalizer((*outError)[i], func(o *NSError) {
				o.Release()
			})
		}
		(*outError)[i].ptr = goSlice3[i]
	}
	runtime.KeepAlive(o)
	return ret
}

func (o *CBCharacteristic) ScriptingIsLessThanOrEqualTo(object NSObject) bool {
	ret := (bool)(C.CBCharacteristic_inst_ScriptingIsLessThanOrEqualTo(o.Ptr(), object.Ptr()))
	runtime.KeepAlive(o)
	return ret
}

func (o *CBCharacteristic) ClassDescription() *NSClassDescription {
	ret := &NSClassDescription{}
	ret.ptr = unsafe.Pointer(C.CBCharacteristic_inst_ClassDescription(o.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSClassDescription)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *NSClassDescription) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *CBCharacteristic) IsEqualTo(object NSObject) bool {
	ret := (bool)(C.CBCharacteristic_inst_IsEqualTo(o.Ptr(), object.Ptr()))
	runtime.KeepAlive(o)
	return ret
}

func (o *CBCharacteristic) Properties() CBCharacteristicProperties {
	ret := (CBCharacteristicProperties)(C.CBCharacteristic_inst_Properties(o.Ptr()))
	runtime.KeepAlive(o)
	return ret
}

func (o *CBCharacteristic) ValueForKey(key *NSString) *Id {
	ret := &Id{}
	ret.ptr = unsafe.Pointer(C.CBCharacteristic_inst_ValueForKey(o.Ptr(), key.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *Id) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *CBCharacteristic) ReplaceValueAtIndexInPropertyWithKey(index NSUInteger, key *NSString, value NSObject)  {
	C.CBCharacteristic_inst_ReplaceValueAtIndexInPropertyWithKey(o.Ptr(), (C.NSUInteger)(index), key.Ptr(), value.Ptr())
	runtime.KeepAlive(o)
}

func (o *CBCharacteristic) ReplaceValueAtIndexInPropertyWithKeyWithValue(index NSUInteger, key *NSString, value NSObject)  {
	C.CBCharacteristic_inst_ReplaceValueAtIndexInPropertyWithKeyWithValue(o.Ptr(), (C.NSUInteger)(index), key.Ptr(), value.Ptr())
	runtime.KeepAlive(o)
}

func (o *CBCharacteristic) MutableSetValueForKey(key *NSString) *NSMutableSet {
	ret := &NSMutableSet{}
	ret.ptr = unsafe.Pointer(C.CBCharacteristic_inst_MutableSetValueForKey(o.Ptr(), key.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSMutableSet)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *NSMutableSet) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *CBCharacteristic) UUID() *CBUUID {
	ret := &CBUUID{}
	ret.ptr = unsafe.Pointer(C.CBCharacteristic_inst_UUID(o.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*CBUUID)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *CBUUID) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *CBCharacteristic) ClassCode() FourCharCode {
	ret := (FourCharCode)(C.CBCharacteristic_inst_ClassCode(o.Ptr()))
	runtime.KeepAlive(o)
	return ret
}

func (o *CBCharacteristic) IsNotEqualTo(object NSObject) bool {
	ret := (bool)(C.CBCharacteristic_inst_IsNotEqualTo(o.Ptr(), object.Ptr()))
	runtime.KeepAlive(o)
	return ret
}

func (o *CBCharacteristic) RemoveObserverForKeyPath(observer NSObject, keyPath *NSString)  {
	C.CBCharacteristic_inst_RemoveObserverForKeyPath(o.Ptr(), observer.Ptr(), keyPath.Ptr())
	runtime.KeepAlive(o)
}

func (o *CBCharacteristic) RemoveObserverForKeyPathContext(observer NSObject, keyPath *NSString, context unsafe.Pointer)  {
	C.CBCharacteristic_inst_RemoveObserverForKeyPathContext(o.Ptr(), observer.Ptr(), keyPath.Ptr(), unsafe.Pointer(context))
	runtime.KeepAlive(o)
}

func (o *CBCharacteristic) ToOneRelationshipKeys() *NSArray {
	ret := &NSArray{}
	ret.ptr = unsafe.Pointer(C.CBCharacteristic_inst_ToOneRelationshipKeys(o.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSArray)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *NSArray) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *CBCharacteristic) ScriptingIsLessThan(object NSObject) bool {
	ret := (bool)(C.CBCharacteristic_inst_ScriptingIsLessThan(o.Ptr(), object.Ptr()))
	runtime.KeepAlive(o)
	return ret
}

func (o *CBCharacteristic) ValueAtIndexInPropertyWithKey(index NSUInteger, key *NSString) *Id {
	ret := &Id{}
	ret.ptr = unsafe.Pointer(C.CBCharacteristic_inst_ValueAtIndexInPropertyWithKey(o.Ptr(), (C.NSUInteger)(index), key.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *Id) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *CBCharacteristic) Dealloc()  {
	C.CBCharacteristic_inst_Dealloc(o.Ptr())
	runtime.KeepAlive(o)
}

func (o *CBCharacteristic) SetValuesForKeysWithDictionary(keyedValues *NSDictionary)  {
	C.CBCharacteristic_inst_SetValuesForKeysWithDictionary(o.Ptr(), keyedValues.Ptr())
	runtime.KeepAlive(o)
}

func (o *CBCharacteristic) ScriptingProperties() *NSDictionary {
	ret := &NSDictionary{}
	ret.ptr = unsafe.Pointer(C.CBCharacteristic_inst_ScriptingProperties(o.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSDictionary)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *NSDictionary) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *CBCharacteristic) Descriptors() *NSArray {
	ret := &NSArray{}
	ret.ptr = unsafe.Pointer(C.CBCharacteristic_inst_Descriptors(o.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSArray)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *NSArray) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *CBCharacteristic) DictionaryWithValuesForKeys(keys *NSArray) *NSDictionary {
	ret := &NSDictionary{}
	ret.ptr = unsafe.Pointer(C.CBCharacteristic_inst_DictionaryWithValuesForKeys(o.Ptr(), keys.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSDictionary)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *NSDictionary) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *CBCharacteristic) SetValueForKey(value NSObject, key *NSString)  {
	C.CBCharacteristic_inst_SetValueForKey(o.Ptr(), value.Ptr(), key.Ptr())
	runtime.KeepAlive(o)
}

func (o *CBCharacteristic) SetValueForKeyPath(value NSObject, keyPath *NSString)  {
	C.CBCharacteristic_inst_SetValueForKeyPath(o.Ptr(), value.Ptr(), keyPath.Ptr())
	runtime.KeepAlive(o)
}

func (o *CBCharacteristic) SetValueForUndefinedKey(value NSObject, key *NSString)  {
	C.CBCharacteristic_inst_SetValueForUndefinedKey(o.Ptr(), value.Ptr(), key.Ptr())
	runtime.KeepAlive(o)
}

func (o *CBCharacteristic) IsGreaterThanOrEqualTo(object NSObject) bool {
	ret := (bool)(C.CBCharacteristic_inst_IsGreaterThanOrEqualTo(o.Ptr(), object.Ptr()))
	runtime.KeepAlive(o)
	return ret
}

func (o *CBCharacteristic) ObjectSpecifier() *NSScriptObjectSpecifier {
	ret := &NSScriptObjectSpecifier{}
	ret.ptr = unsafe.Pointer(C.CBCharacteristic_inst_ObjectSpecifier(o.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSScriptObjectSpecifier)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *NSScriptObjectSpecifier) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *CBCharacteristic) AwakeAfterUsingCoder(coder *NSCoder) *Id {
	ret := &Id{}
	ret.ptr = unsafe.Pointer(C.CBCharacteristic_inst_AwakeAfterUsingCoder(o.Ptr(), coder.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *Id) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *CBCharacteristic) DidChangeValuesAtIndexes(changeKind NSKeyValueChange, indexes *NSIndexSet, key *NSString)  {
	C.CBCharacteristic_inst_DidChangeValuesAtIndexes(o.Ptr(), (C.NSKeyValueChange)(changeKind), indexes.Ptr(), key.Ptr())
	runtime.KeepAlive(o)
}

func (o *CBCharacteristic) DidChangeValuesAtIndexesForKey(changeKind NSKeyValueChange, indexes *NSIndexSet, key *NSString)  {
	C.CBCharacteristic_inst_DidChangeValuesAtIndexesForKey(o.Ptr(), (C.NSKeyValueChange)(changeKind), indexes.Ptr(), key.Ptr())
	runtime.KeepAlive(o)
}

func (o *CBCharacteristic) AddObserverForKeyPath(observer NSObject, keyPath *NSString, options NSKeyValueObservingOptions, context unsafe.Pointer)  {
	C.CBCharacteristic_inst_AddObserverForKeyPath(o.Ptr(), observer.Ptr(), keyPath.Ptr(), (C.NSKeyValueObservingOptions)(options), unsafe.Pointer(context))
	runtime.KeepAlive(o)
}

func (o *CBCharacteristic) AddObserverForKeyPathOptions(observer NSObject, keyPath *NSString, options NSKeyValueObservingOptions, context unsafe.Pointer)  {
	C.CBCharacteristic_inst_AddObserverForKeyPathOptions(o.Ptr(), observer.Ptr(), keyPath.Ptr(), (C.NSKeyValueObservingOptions)(options), unsafe.Pointer(context))
	runtime.KeepAlive(o)
}

func (o *CBCharacteristic) MutableCopy() *Id {
	ret := &Id{}
	ret.ptr = unsafe.Pointer(C.CBCharacteristic_inst_MutableCopy(o.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	runtime.SetFinalizer(ret, func(o *Id) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *CBCharacteristic) CoerceValueForKey(value NSObject, key *NSString) *Id {
	ret := &Id{}
	ret.ptr = unsafe.Pointer(C.CBCharacteristic_inst_CoerceValueForKey(o.Ptr(), value.Ptr(), key.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *Id) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *CBCharacteristic) SetObservationInfo(observationInfo unsafe.Pointer)  {
	C.CBCharacteristic_inst_SetObservationInfo(o.Ptr(), unsafe.Pointer(observationInfo))
	runtime.KeepAlive(o)
}

func (o *CBCharacteristic) IsLike(object *NSString) bool {
	ret := (bool)(C.CBCharacteristic_inst_IsLike(o.Ptr(), object.Ptr()))
	runtime.KeepAlive(o)
	return ret
}

func (o *CBCharacteristic) ScriptingContains(object NSObject) bool {
	ret := (bool)(C.CBCharacteristic_inst_ScriptingContains(o.Ptr(), object.Ptr()))
	runtime.KeepAlive(o)
	return ret
}

func (o *CBCharacteristic) ScriptingEndsWith(object NSObject) bool {
	ret := (bool)(C.CBCharacteristic_inst_ScriptingEndsWith(o.Ptr(), object.Ptr()))
	runtime.KeepAlive(o)
	return ret
}

func (o *CBCharacteristic) IsCaseInsensitiveLike(object *NSString) bool {
	ret := (bool)(C.CBCharacteristic_inst_IsCaseInsensitiveLike(o.Ptr(), object.Ptr()))
	runtime.KeepAlive(o)
	return ret
}

func (o *CBCharacteristic) ReplacementObjectForCoder(coder *NSCoder) *Id {
	ret := &Id{}
	ret.ptr = unsafe.Pointer(C.CBCharacteristic_inst_ReplacementObjectForCoder(o.Ptr(), coder.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *Id) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *CBCharacteristic) DoesNotRecognizeSelector(aSelector SEL)  {
	C.CBCharacteristic_inst_DoesNotRecognizeSelector(o.Ptr(), unsafe.Pointer(aSelector))
	runtime.KeepAlive(o)
}

func (o *CBCharacteristic) IsGreaterThan(object NSObject) bool {
	ret := (bool)(C.CBCharacteristic_inst_IsGreaterThan(o.Ptr(), object.Ptr()))
	runtime.KeepAlive(o)
	return ret
}

func (o *CBCharacteristic) SetScriptingProperties(scriptingProperties *NSDictionary)  {
	C.CBCharacteristic_inst_SetScriptingProperties(o.Ptr(), scriptingProperties.Ptr())
	runtime.KeepAlive(o)
}

func (o *CBCharacteristic) MutableOrderedSetValueForKeyPath(keyPath *NSString) *NSMutableOrderedSet {
	ret := &NSMutableOrderedSet{}
	ret.ptr = unsafe.Pointer(C.CBCharacteristic_inst_MutableOrderedSetValueForKeyPath(o.Ptr(), keyPath.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSMutableOrderedSet)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *NSMutableOrderedSet) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *CBCharacteristic) ToManyRelationshipKeys() *NSArray {
	ret := &NSArray{}
	ret.ptr = unsafe.Pointer(C.CBCharacteristic_inst_ToManyRelationshipKeys(o.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSArray)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *NSArray) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *CBCharacteristic) ReplacementObjectForKeyedArchiver(archiver *NSKeyedArchiver) *Id {
	ret := &Id{}
	ret.ptr = unsafe.Pointer(C.CBCharacteristic_inst_ReplacementObjectForKeyedArchiver(o.Ptr(), archiver.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *Id) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *CBCharacteristic) MutableSetValueForKeyPath(keyPath *NSString) *NSMutableSet {
	ret := &NSMutableSet{}
	ret.ptr = unsafe.Pointer(C.CBCharacteristic_inst_MutableSetValueForKeyPath(o.Ptr(), keyPath.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSMutableSet)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *NSMutableSet) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *CBCharacteristic) AttemptRecoveryFromErrorOptionIndex(error *NSError, recoveryOptionIndex NSUInteger) bool {
	ret := (bool)(C.CBCharacteristic_inst_AttemptRecoveryFromErrorOptionIndex(o.Ptr(), error.Ptr(), (C.NSUInteger)(recoveryOptionIndex)))
	runtime.KeepAlive(o)
	return ret
}

func (o *CBCharacteristic) AttemptRecoveryFromErrorOptionIndexDelegate(error *NSError, recoveryOptionIndex NSUInteger, delegate NSObject, didRecoverSelector SEL, contextInfo unsafe.Pointer)  {
	C.CBCharacteristic_inst_AttemptRecoveryFromErrorOptionIndexDelegate(o.Ptr(), error.Ptr(), (C.NSUInteger)(recoveryOptionIndex), delegate.Ptr(), unsafe.Pointer(didRecoverSelector), unsafe.Pointer(contextInfo))
	runtime.KeepAlive(o)
}

func (o *CBCharacteristic) AttemptRecoveryFromErrorOptionIndexDelegateDidRecoverSelector(error *NSError, recoveryOptionIndex NSUInteger, delegate NSObject, didRecoverSelector SEL, contextInfo unsafe.Pointer)  {
	C.CBCharacteristic_inst_AttemptRecoveryFromErrorOptionIndexDelegateDidRecoverSelector(o.Ptr(), error.Ptr(), (C.NSUInteger)(recoveryOptionIndex), delegate.Ptr(), unsafe.Pointer(didRecoverSelector), unsafe.Pointer(contextInfo))
	runtime.KeepAlive(o)
}

func (o *CBCharacteristic) MutableArrayValueForKeyPath(keyPath *NSString) *NSMutableArray {
	ret := &NSMutableArray{}
	ret.ptr = unsafe.Pointer(C.CBCharacteristic_inst_MutableArrayValueForKeyPath(o.Ptr(), keyPath.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSMutableArray)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *NSMutableArray) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *CBCharacteristic) WillChangeValueForKey(key *NSString)  {
	C.CBCharacteristic_inst_WillChangeValueForKey(o.Ptr(), key.Ptr())
	runtime.KeepAlive(o)
}

func (o *CBCharacteristic) WillChangeValueForKeyWithSetMutation(key *NSString, mutationKind NSKeyValueSetMutationKind, objects *NSSet)  {
	C.CBCharacteristic_inst_WillChangeValueForKeyWithSetMutation(o.Ptr(), key.Ptr(), (C.NSKeyValueSetMutationKind)(mutationKind), objects.Ptr())
	runtime.KeepAlive(o)
}

func (o *CBCharacteristic) WillChangeValueForKeyWithSetMutationUsingObjects(key *NSString, mutationKind NSKeyValueSetMutationKind, objects *NSSet)  {
	C.CBCharacteristic_inst_WillChangeValueForKeyWithSetMutationUsingObjects(o.Ptr(), key.Ptr(), (C.NSKeyValueSetMutationKind)(mutationKind), objects.Ptr())
	runtime.KeepAlive(o)
}

func (o *CBCharacteristic) Service() *CBService {
	ret := &CBService{}
	ret.ptr = unsafe.Pointer(C.CBCharacteristic_inst_Service(o.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*CBService)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *CBService) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *CBCharacteristic) ScriptingIsGreaterThanOrEqualTo(object NSObject) bool {
	ret := (bool)(C.CBCharacteristic_inst_ScriptingIsGreaterThanOrEqualTo(o.Ptr(), object.Ptr()))
	runtime.KeepAlive(o)
	return ret
}

func (o *CBCharacteristic) MutableOrderedSetValueForKey(key *NSString) *NSMutableOrderedSet {
	ret := &NSMutableOrderedSet{}
	ret.ptr = unsafe.Pointer(C.CBCharacteristic_inst_MutableOrderedSetValueForKey(o.Ptr(), key.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSMutableOrderedSet)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *NSMutableOrderedSet) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *CBCharacteristic) ScriptingIsEqualTo(object NSObject) bool {
	ret := (bool)(C.CBCharacteristic_inst_ScriptingIsEqualTo(o.Ptr(), object.Ptr()))
	runtime.KeepAlive(o)
	return ret
}

func (o *CBCharacteristic) AutoContentAccessingProxy() *Id {
	ret := &Id{}
	ret.ptr = unsafe.Pointer(C.CBCharacteristic_inst_AutoContentAccessingProxy(o.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *Id) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *CBCharacteristic) DoesContain(object NSObject) bool {
	ret := (bool)(C.CBCharacteristic_inst_DoesContain(o.Ptr(), object.Ptr()))
	runtime.KeepAlive(o)
	return ret
}

func (o *CBCharacteristic) AttributeKeys() *NSArray {
	ret := &NSArray{}
	ret.ptr = unsafe.Pointer(C.CBCharacteristic_inst_AttributeKeys(o.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSArray)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *NSArray) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *CBCharacteristic) InsertValueInPropertyWithKey(value NSObject, key *NSString)  {
	C.CBCharacteristic_inst_InsertValueInPropertyWithKey(o.Ptr(), value.Ptr(), key.Ptr())
	runtime.KeepAlive(o)
}

func (o *CBCharacteristic) InsertValueAtIndex(value NSObject, index NSUInteger, key *NSString)  {
	C.CBCharacteristic_inst_InsertValueAtIndex(o.Ptr(), value.Ptr(), (C.NSUInteger)(index), key.Ptr())
	runtime.KeepAlive(o)
}

func (o *CBCharacteristic) InsertValueAtIndexInPropertyWithKey(value NSObject, index NSUInteger, key *NSString)  {
	C.CBCharacteristic_inst_InsertValueAtIndexInPropertyWithKey(o.Ptr(), value.Ptr(), (C.NSUInteger)(index), key.Ptr())
	runtime.KeepAlive(o)
}

func (o *CBCharacteristic) ValueWithNameInPropertyWithKey(name *NSString, key *NSString) *Id {
	ret := &Id{}
	ret.ptr = unsafe.Pointer(C.CBCharacteristic_inst_ValueWithNameInPropertyWithKey(o.Ptr(), name.Ptr(), key.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *Id) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *CBCharacteristic) ClassForKeyedArchiver() Class {
	ret := (Class)(unsafe.Pointer(C.CBCharacteristic_inst_ClassForKeyedArchiver(o.Ptr())))
	runtime.KeepAlive(o)
	return ret
}

func (o *CBCharacteristic) SetNilValueForKey(key *NSString)  {
	C.CBCharacteristic_inst_SetNilValueForKey(o.Ptr(), key.Ptr())
	runtime.KeepAlive(o)
}

func NSArrayWithObjects(firstObj NSObject) *NSArray {
	ret := &NSArray{}
	ret.ptr = unsafe.Pointer(C.NSArray_ArrayWithObjects(firstObj.Ptr()))
	if ret.ptr == nil { return ret }
	runtime.SetFinalizer(ret, func(o *NSArray) {
		o.Release()
	})
	return ret
}

func NSArrayWithObjectsCount(objects *[]*Id, cnt NSUInteger) *NSArray {

	goSlice0 := make([]unsafe.Pointer,cap(*objects))
	for i := 0; i < len(*objects); i++ {
		goSlice0[i] = (*objects)[i].Ptr()
	}
	ret := &NSArray{}
	ret.ptr = unsafe.Pointer(C.NSArray_ArrayWithObjectsCount((*unsafe.Pointer)(unsafe.Pointer(&goSlice0[0])), (C.NSUInteger)(cnt)))
	(*objects) = (*objects)[:cap(*objects)]
	for i := 0; i < len(*objects); i++ {
		if goSlice0[i] == nil {
			(*objects) = (*objects)[:i]
			break
		}
		if (*objects)[i] == nil {
			(*objects)[i] = &Id{}
			runtime.SetFinalizer((*objects)[i], func(o *Id) {
				o.Release()
			})
		}
		(*objects)[i].ptr = goSlice0[i]
	}
	if ret.ptr == nil { return ret }
	runtime.SetFinalizer(ret, func(o *NSArray) {
		o.Release()
	})
	return ret
}

func NSArrayCancelPreviousPerformRequestsWithTarget(aTarget NSObject)  {
	C.NSArray_CancelPreviousPerformRequestsWithTarget(aTarget.Ptr())
}

func NSArrayCancelPreviousPerformRequestsWithTargetSelector(aTarget NSObject, aSelector SEL, anArgument NSObject)  {
	C.NSArray_CancelPreviousPerformRequestsWithTargetSelector(aTarget.Ptr(), unsafe.Pointer(aSelector), anArgument.Ptr())
}

func NSArrayCancelPreviousPerformRequestsWithTargetSelectorObject(aTarget NSObject, aSelector SEL, anArgument NSObject)  {
	C.NSArray_CancelPreviousPerformRequestsWithTargetSelectorObject(aTarget.Ptr(), unsafe.Pointer(aSelector), anArgument.Ptr())
}

func NSArraySetVersion(aVersion NSInteger)  {
	C.NSArray_SetVersion((C.NSInteger)(aVersion))
}

func NSArrayAlloc() *NSArray {
	ret := &NSArray{}
	ret.ptr = unsafe.Pointer(C.NSArray_Alloc())
	if ret.ptr == nil { return ret }
	runtime.SetFinalizer(ret, func(o *NSArray) {
		o.Release()
	})
	return ret
}

func (o *NSArray) GC() {
	if o.ptr == nil { return }
	runtime.SetFinalizer(o, func(o *NSArray) {
		o.Release()
	})
	runtime.KeepAlive(o)
}

func NSArrayAllocWithZone(zone *_NSZone) *NSArray {
	ret := &NSArray{}
	ret.ptr = unsafe.Pointer(C.NSArray_AllocWithZone(unsafe.Pointer(zone)))
	if ret.ptr == nil { return ret }
	runtime.SetFinalizer(ret, func(o *NSArray) {
		o.Release()
	})
	return ret
}

func NSArrayInstancesRespondToSelector(aSelector SEL) bool {
	ret := (bool)(C.NSArray_InstancesRespondToSelector(unsafe.Pointer(aSelector)))
	return ret
}

func NSArrayLoad()  {
	C.NSArray_Load()
}

func NSArrayResolveClassMethod(sel SEL) bool {
	ret := (bool)(C.NSArray_ResolveClassMethod(unsafe.Pointer(sel)))
	return ret
}

func NSArrayMutableCopyWithZone(zone *_NSZone) *Id {
	ret := &Id{}
	ret.ptr = unsafe.Pointer(C.NSArray_MutableCopyWithZone(unsafe.Pointer(zone)))
	if ret.ptr == nil { return ret }
	runtime.SetFinalizer(ret, func(o *Id) {
		o.Release()
	})
	return ret
}

func NSArrayAccessInstanceVariablesDirectly() bool {
	ret := (bool)(C.NSArray_AccessInstanceVariablesDirectly())
	return ret
}

func NSArrayDescription() *NSString {
	ret := &NSString{}
	ret.ptr = unsafe.Pointer(C.NSArray_Description())
	if ret.ptr == nil { return ret }
	return ret
}

func NSArrayInstanceMethodSignatureForSelector(aSelector SEL) *NSMethodSignature {
	ret := &NSMethodSignature{}
	ret.ptr = unsafe.Pointer(C.NSArray_InstanceMethodSignatureForSelector(unsafe.Pointer(aSelector)))
	if ret.ptr == nil { return ret }
	return ret
}

func NSArrayClass() Class {
	ret := (Class)(unsafe.Pointer(C.NSArray_Class()))
	return ret
}

func NSArrayClassForKeyedUnarchiver() Class {
	ret := (Class)(unsafe.Pointer(C.NSArray_ClassForKeyedUnarchiver()))
	return ret
}

func NSArrayWithArray(array *NSArray) *NSArray {
	ret := &NSArray{}
	ret.ptr = unsafe.Pointer(C.NSArray_ArrayWithArray(array.Ptr()))
	if ret.ptr == nil { return ret }
	runtime.SetFinalizer(ret, func(o *NSArray) {
		o.Release()
	})
	return ret
}

func NSArrayResolveInstanceMethod(sel SEL) bool {
	ret := (bool)(C.NSArray_ResolveInstanceMethod(unsafe.Pointer(sel)))
	return ret
}

func NSArrayCopyWithZone(zone *_NSZone) *Id {
	ret := &Id{}
	ret.ptr = unsafe.Pointer(C.NSArray_CopyWithZone(unsafe.Pointer(zone)))
	if ret.ptr == nil { return ret }
	runtime.SetFinalizer(ret, func(o *Id) {
		o.Release()
	})
	return ret
}

func NSArrayKeyPathsForValuesAffectingValueForKey(key *NSString) *NSSet {
	ret := &NSSet{}
	ret.ptr = unsafe.Pointer(C.NSArray_KeyPathsForValuesAffectingValueForKey(key.Ptr()))
	if ret.ptr == nil { return ret }
	return ret
}

func NSArrayArray() *NSArray {
	ret := &NSArray{}
	ret.ptr = unsafe.Pointer(C.NSArray_Array())
	if ret.ptr == nil { return ret }
	runtime.SetFinalizer(ret, func(o *NSArray) {
		o.Release()
	})
	return ret
}

func NSArrayDebugDescription() *NSString {
	ret := &NSString{}
	ret.ptr = unsafe.Pointer(C.NSArray_DebugDescription())
	if ret.ptr == nil { return ret }
	return ret
}

func NSArrayClassFallbacksForKeyedArchiver() *NSArray {
	ret := &NSArray{}
	ret.ptr = unsafe.Pointer(C.NSArray_ClassFallbacksForKeyedArchiver())
	if ret.ptr == nil { return ret }
	return ret
}

func NSArrayWithContentsOfURLError(url *NSURL, error *[]*NSError) *NSArray {

	goSlice1 := make([]unsafe.Pointer,cap(*error))
	for i := 0; i < len(*error); i++ {
		goSlice1[i] = (*error)[i].Ptr()
	}
	ret := &NSArray{}
	ret.ptr = unsafe.Pointer(C.NSArray_ArrayWithContentsOfURLError(url.Ptr(), (*unsafe.Pointer)(unsafe.Pointer(&goSlice1[0]))))
	(*error) = (*error)[:cap(*error)]
	for i := 0; i < len(*error); i++ {
		if goSlice1[i] == nil {
			(*error) = (*error)[:i]
			break
		}
		if (*error)[i] == nil {
			(*error)[i] = &NSError{}
			runtime.SetFinalizer((*error)[i], func(o *NSError) {
				o.Release()
			})
		}
		(*error)[i].ptr = goSlice1[i]
	}
	if ret.ptr == nil { return ret }
	runtime.SetFinalizer(ret, func(o *NSArray) {
		o.Release()
	})
	return ret
}

func NSArrayHash() NSUInteger {
	ret := (NSUInteger)(C.NSArray_Hash())
	return ret
}

func NSArraySupportsSecureCoding() bool {
	ret := (bool)(C.NSArray_SupportsSecureCoding())
	return ret
}

func NSArrayWithObject(anObject NSObject) *NSArray {
	ret := &NSArray{}
	ret.ptr = unsafe.Pointer(C.NSArray_ArrayWithObject(anObject.Ptr()))
	if ret.ptr == nil { return ret }
	runtime.SetFinalizer(ret, func(o *NSArray) {
		o.Release()
	})
	return ret
}

func NSArrayIsSubclassOfClass(aClass Class) bool {
	ret := (bool)(C.NSArray_IsSubclassOfClass(unsafe.Pointer(aClass)))
	return ret
}

func NSArraySuperclass() Class {
	ret := (Class)(unsafe.Pointer(C.NSArray_Superclass()))
	return ret
}

func NSArrayConformsToProtocol(protocol Protocol) bool {
	ret := (bool)(C.NSArray_ConformsToProtocol(protocol.Ptr()))
	return ret
}

func NSArrayVersion() NSInteger {
	ret := (NSInteger)(C.NSArray_Version())
	return ret
}

func NSArrayNew() *NSArray {
	ret := &NSArray{}
	ret.ptr = unsafe.Pointer(C.NSArray_New())
	if ret.ptr == nil { return ret }
	runtime.SetFinalizer(ret, func(o *NSArray) {
		o.Release()
	})
	return ret
}

func NSArrayAutomaticallyNotifiesObserversForKey(key *NSString) bool {
	ret := (bool)(C.NSArray_AutomaticallyNotifiesObserversForKey(key.Ptr()))
	return ret
}

func (o *NSArray) IsLessThanOrEqualTo(object NSObject) bool {
	ret := (bool)(C.NSArray_inst_IsLessThanOrEqualTo(o.Ptr(), object.Ptr()))
	runtime.KeepAlive(o)
	return ret
}

func (o *NSArray) WillChangeValueForKey(key *NSString)  {
	C.NSArray_inst_WillChangeValueForKey(o.Ptr(), key.Ptr())
	runtime.KeepAlive(o)
}

func (o *NSArray) WillChangeValueForKeyWithSetMutation(key *NSString, mutationKind NSKeyValueSetMutationKind, objects *NSSet)  {
	C.NSArray_inst_WillChangeValueForKeyWithSetMutation(o.Ptr(), key.Ptr(), (C.NSKeyValueSetMutationKind)(mutationKind), objects.Ptr())
	runtime.KeepAlive(o)
}

func (o *NSArray) WillChangeValueForKeyWithSetMutationUsingObjects(key *NSString, mutationKind NSKeyValueSetMutationKind, objects *NSSet)  {
	C.NSArray_inst_WillChangeValueForKeyWithSetMutationUsingObjects(o.Ptr(), key.Ptr(), (C.NSKeyValueSetMutationKind)(mutationKind), objects.Ptr())
	runtime.KeepAlive(o)
}

func (o *NSArray) IsLike(object *NSString) bool {
	ret := (bool)(C.NSArray_inst_IsLike(o.Ptr(), object.Ptr()))
	runtime.KeepAlive(o)
	return ret
}

func (o *NSArray) AttributeKeys() *NSArray {
	ret := &NSArray{}
	ret.ptr = unsafe.Pointer(C.NSArray_inst_AttributeKeys(o.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSArray)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *NSArray) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *NSArray) IndexOfObject(anObject NSObject) NSUInteger {
	ret := (NSUInteger)(C.NSArray_inst_IndexOfObject(o.Ptr(), anObject.Ptr()))
	runtime.KeepAlive(o)
	return ret
}

func (o *NSArray) IndexOfObjectInRange(anObject NSObject, range_ NSRange) NSUInteger {
	ret := (NSUInteger)(C.NSArray_inst_IndexOfObjectInRange(o.Ptr(), anObject.Ptr(), (C.NSRange)(range_)))
	runtime.KeepAlive(o)
	return ret
}

func (o *NSArray) CopyScriptingValueForKey(value NSObject, key *NSString, properties *NSDictionary) *Id {
	ret := &Id{}
	ret.ptr = unsafe.Pointer(C.NSArray_inst_CopyScriptingValueForKey(o.Ptr(), value.Ptr(), key.Ptr(), properties.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *Id) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *NSArray) CopyScriptingValueForKeyWithProperties(value NSObject, key *NSString, properties *NSDictionary) *Id {
	ret := &Id{}
	ret.ptr = unsafe.Pointer(C.NSArray_inst_CopyScriptingValueForKeyWithProperties(o.Ptr(), value.Ptr(), key.Ptr(), properties.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *Id) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *NSArray) DoesNotRecognizeSelector(aSelector SEL)  {
	C.NSArray_inst_DoesNotRecognizeSelector(o.Ptr(), unsafe.Pointer(aSelector))
	runtime.KeepAlive(o)
}

func (o *NSArray) DescriptionWithLocale(locale NSObject) *NSString {
	ret := &NSString{}
	ret.ptr = unsafe.Pointer(C.NSArray_inst_DescriptionWithLocale(o.Ptr(), locale.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSString)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *NSString) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *NSArray) DescriptionWithLocaleIndent(locale NSObject, level NSUInteger) *NSString {
	ret := &NSString{}
	ret.ptr = unsafe.Pointer(C.NSArray_inst_DescriptionWithLocaleIndent(o.Ptr(), locale.Ptr(), (C.NSUInteger)(level)))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSString)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *NSString) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *NSArray) IsEqualToArray(otherArray *NSArray) bool {
	ret := (bool)(C.NSArray_inst_IsEqualToArray(o.Ptr(), otherArray.Ptr()))
	runtime.KeepAlive(o)
	return ret
}

func (o *NSArray) DictionaryWithValuesForKeys(keys *NSArray) *NSDictionary {
	ret := &NSDictionary{}
	ret.ptr = unsafe.Pointer(C.NSArray_inst_DictionaryWithValuesForKeys(o.Ptr(), keys.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSDictionary)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *NSDictionary) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *NSArray) ScriptingBeginsWith(object NSObject) bool {
	ret := (bool)(C.NSArray_inst_ScriptingBeginsWith(o.Ptr(), object.Ptr()))
	runtime.KeepAlive(o)
	return ret
}

func (o *NSArray) MutableCopyWithZone(zone *NSZone) *Id {
	ret := &Id{}
	ret.ptr = unsafe.Pointer(C.NSArray_inst_MutableCopyWithZone(o.Ptr(), unsafe.Pointer(zone)))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *Id) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *NSArray) WriteToURLError(url *NSURL, error *[]*NSError) bool {

	goSlice2 := make([]unsafe.Pointer,cap(*error))
	for i := 0; i < len(*error); i++ {
		goSlice2[i] = (*error)[i].Ptr()
	}
	ret := (bool)(C.NSArray_inst_WriteToURLError(o.Ptr(), url.Ptr(), (*unsafe.Pointer)(unsafe.Pointer(&goSlice2[0]))))
	(*error) = (*error)[:cap(*error)]
	for i := 0; i < len(*error); i++ {
		if goSlice2[i] == nil {
			(*error) = (*error)[:i]
			break
		}
		if (*error)[i] == nil {
			(*error)[i] = &NSError{}
			runtime.SetFinalizer((*error)[i], func(o *NSError) {
				o.Release()
			})
		}
		(*error)[i].ptr = goSlice2[i]
	}
	runtime.KeepAlive(o)
	return ret
}

func (o *NSArray) GetObjectsRange(objects *[]*Id, range_ NSRange)  {

	goSlice1 := make([]unsafe.Pointer,cap(*objects))
	for i := 0; i < len(*objects); i++ {
		goSlice1[i] = (*objects)[i].Ptr()
	}
	C.NSArray_inst_GetObjectsRange(o.Ptr(), (*unsafe.Pointer)(unsafe.Pointer(&goSlice1[0])), (C.NSRange)(range_))
	(*objects) = (*objects)[:cap(*objects)]
	for i := 0; i < len(*objects); i++ {
		if goSlice1[i] == nil {
			(*objects) = (*objects)[:i]
			break
		}
		if (*objects)[i] == nil {
			(*objects)[i] = &Id{}
			runtime.SetFinalizer((*objects)[i], func(o *Id) {
				o.Release()
			})
		}
		(*objects)[i].ptr = goSlice1[i]
	}
	runtime.KeepAlive(o)
}

func (o *NSArray) MutableOrderedSetValueForKeyPath(keyPath *NSString) *NSMutableOrderedSet {
	ret := &NSMutableOrderedSet{}
	ret.ptr = unsafe.Pointer(C.NSArray_inst_MutableOrderedSetValueForKeyPath(o.Ptr(), keyPath.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSMutableOrderedSet)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *NSMutableOrderedSet) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *NSArray) IsCaseInsensitiveLike(object *NSString) bool {
	ret := (bool)(C.NSArray_inst_IsCaseInsensitiveLike(o.Ptr(), object.Ptr()))
	runtime.KeepAlive(o)
	return ret
}

func (o *NSArray) DifferenceFromArray(other *NSArray) *NSOrderedCollectionDifference {
	ret := &NSOrderedCollectionDifference{}
	ret.ptr = unsafe.Pointer(C.NSArray_inst_DifferenceFromArray(o.Ptr(), other.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSOrderedCollectionDifference)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *NSOrderedCollectionDifference) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *NSArray) DifferenceFromArrayWithOptions(other *NSArray, options NSOrderedCollectionDifferenceCalculationOptions) *NSOrderedCollectionDifference {
	ret := &NSOrderedCollectionDifference{}
	ret.ptr = unsafe.Pointer(C.NSArray_inst_DifferenceFromArrayWithOptions(o.Ptr(), other.Ptr(), (C.NSOrderedCollectionDifferenceCalculationOptions)(options)))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSOrderedCollectionDifference)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *NSOrderedCollectionDifference) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *NSArray) InverseForRelationshipKey(relationshipKey *NSString) *NSString {
	ret := &NSString{}
	ret.ptr = unsafe.Pointer(C.NSArray_inst_InverseForRelationshipKey(o.Ptr(), relationshipKey.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSString)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *NSString) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *NSArray) ScriptingContains(object NSObject) bool {
	ret := (bool)(C.NSArray_inst_ScriptingContains(o.Ptr(), object.Ptr()))
	runtime.KeepAlive(o)
	return ret
}

func (o *NSArray) ScriptingIsLessThanOrEqualTo(object NSObject) bool {
	ret := (bool)(C.NSArray_inst_ScriptingIsLessThanOrEqualTo(o.Ptr(), object.Ptr()))
	runtime.KeepAlive(o)
	return ret
}

func (o *NSArray) RemoveObserverForKeyPath(observer NSObject, keyPath *NSString)  {
	C.NSArray_inst_RemoveObserverForKeyPath(o.Ptr(), observer.Ptr(), keyPath.Ptr())
	runtime.KeepAlive(o)
}

func (o *NSArray) RemoveObserverForKeyPathContext(observer NSObject, keyPath *NSString, context unsafe.Pointer)  {
	C.NSArray_inst_RemoveObserverForKeyPathContext(o.Ptr(), observer.Ptr(), keyPath.Ptr(), unsafe.Pointer(context))
	runtime.KeepAlive(o)
}

func (o *NSArray) RemoveObserverFromObjectsAtIndexes(observer NSObject, indexes *NSIndexSet, keyPath *NSString)  {
	C.NSArray_inst_RemoveObserverFromObjectsAtIndexes(o.Ptr(), observer.Ptr(), indexes.Ptr(), keyPath.Ptr())
	runtime.KeepAlive(o)
}

func (o *NSArray) RemoveObserverFromObjectsAtIndexesForKeyPath(observer NSObject, indexes *NSIndexSet, keyPath *NSString)  {
	C.NSArray_inst_RemoveObserverFromObjectsAtIndexesForKeyPath(o.Ptr(), observer.Ptr(), indexes.Ptr(), keyPath.Ptr())
	runtime.KeepAlive(o)
}

func (o *NSArray) RemoveObserverFromObjectsAtIndexesForKeyPathContext(observer NSObject, indexes *NSIndexSet, keyPath *NSString, context unsafe.Pointer)  {
	C.NSArray_inst_RemoveObserverFromObjectsAtIndexesForKeyPathContext(o.Ptr(), observer.Ptr(), indexes.Ptr(), keyPath.Ptr(), unsafe.Pointer(context))
	runtime.KeepAlive(o)
}

func (o *NSArray) ValidateValueForKey(ioValue *[]*Id, inKey *NSString, outError *[]*NSError) bool {

	goSlice1 := make([]unsafe.Pointer,cap(*ioValue))
	for i := 0; i < len(*ioValue); i++ {
		goSlice1[i] = (*ioValue)[i].Ptr()
	}

	goSlice3 := make([]unsafe.Pointer,cap(*outError))
	for i := 0; i < len(*outError); i++ {
		goSlice3[i] = (*outError)[i].Ptr()
	}
	ret := (bool)(C.NSArray_inst_ValidateValueForKey(o.Ptr(), (*unsafe.Pointer)(unsafe.Pointer(&goSlice1[0])), inKey.Ptr(), (*unsafe.Pointer)(unsafe.Pointer(&goSlice3[0]))))
	(*ioValue) = (*ioValue)[:cap(*ioValue)]
	for i := 0; i < len(*ioValue); i++ {
		if goSlice1[i] == nil {
			(*ioValue) = (*ioValue)[:i]
			break
		}
		if (*ioValue)[i] == nil {
			(*ioValue)[i] = &Id{}
			runtime.SetFinalizer((*ioValue)[i], func(o *Id) {
				o.Release()
			})
		}
		(*ioValue)[i].ptr = goSlice1[i]
	}
	(*outError) = (*outError)[:cap(*outError)]
	for i := 0; i < len(*outError); i++ {
		if goSlice3[i] == nil {
			(*outError) = (*outError)[:i]
			break
		}
		if (*outError)[i] == nil {
			(*outError)[i] = &NSError{}
			runtime.SetFinalizer((*outError)[i], func(o *NSError) {
				o.Release()
			})
		}
		(*outError)[i].ptr = goSlice3[i]
	}
	runtime.KeepAlive(o)
	return ret
}

func (o *NSArray) ValidateValueForKeyPath(ioValue *[]*Id, inKeyPath *NSString, outError *[]*NSError) bool {

	goSlice1 := make([]unsafe.Pointer,cap(*ioValue))
	for i := 0; i < len(*ioValue); i++ {
		goSlice1[i] = (*ioValue)[i].Ptr()
	}

	goSlice3 := make([]unsafe.Pointer,cap(*outError))
	for i := 0; i < len(*outError); i++ {
		goSlice3[i] = (*outError)[i].Ptr()
	}
	ret := (bool)(C.NSArray_inst_ValidateValueForKeyPath(o.Ptr(), (*unsafe.Pointer)(unsafe.Pointer(&goSlice1[0])), inKeyPath.Ptr(), (*unsafe.Pointer)(unsafe.Pointer(&goSlice3[0]))))
	(*ioValue) = (*ioValue)[:cap(*ioValue)]
	for i := 0; i < len(*ioValue); i++ {
		if goSlice1[i] == nil {
			(*ioValue) = (*ioValue)[:i]
			break
		}
		if (*ioValue)[i] == nil {
			(*ioValue)[i] = &Id{}
			runtime.SetFinalizer((*ioValue)[i], func(o *Id) {
				o.Release()
			})
		}
		(*ioValue)[i].ptr = goSlice1[i]
	}
	(*outError) = (*outError)[:cap(*outError)]
	for i := 0; i < len(*outError); i++ {
		if goSlice3[i] == nil {
			(*outError) = (*outError)[:i]
			break
		}
		if (*outError)[i] == nil {
			(*outError)[i] = &NSError{}
			runtime.SetFinalizer((*outError)[i], func(o *NSError) {
				o.Release()
			})
		}
		(*outError)[i].ptr = goSlice3[i]
	}
	runtime.KeepAlive(o)
	return ret
}

func (o *NSArray) ValidateValueForKeyError(ioValue *[]*Id, inKey *NSString, outError *[]*NSError) bool {

	goSlice1 := make([]unsafe.Pointer,cap(*ioValue))
	for i := 0; i < len(*ioValue); i++ {
		goSlice1[i] = (*ioValue)[i].Ptr()
	}

	goSlice3 := make([]unsafe.Pointer,cap(*outError))
	for i := 0; i < len(*outError); i++ {
		goSlice3[i] = (*outError)[i].Ptr()
	}
	ret := (bool)(C.NSArray_inst_ValidateValueForKeyError(o.Ptr(), (*unsafe.Pointer)(unsafe.Pointer(&goSlice1[0])), inKey.Ptr(), (*unsafe.Pointer)(unsafe.Pointer(&goSlice3[0]))))
	(*ioValue) = (*ioValue)[:cap(*ioValue)]
	for i := 0; i < len(*ioValue); i++ {
		if goSlice1[i] == nil {
			(*ioValue) = (*ioValue)[:i]
			break
		}
		if (*ioValue)[i] == nil {
			(*ioValue)[i] = &Id{}
			runtime.SetFinalizer((*ioValue)[i], func(o *Id) {
				o.Release()
			})
		}
		(*ioValue)[i].ptr = goSlice1[i]
	}
	(*outError) = (*outError)[:cap(*outError)]
	for i := 0; i < len(*outError); i++ {
		if goSlice3[i] == nil {
			(*outError) = (*outError)[:i]
			break
		}
		if (*outError)[i] == nil {
			(*outError)[i] = &NSError{}
			runtime.SetFinalizer((*outError)[i], func(o *NSError) {
				o.Release()
			})
		}
		(*outError)[i].ptr = goSlice3[i]
	}
	runtime.KeepAlive(o)
	return ret
}

func (o *NSArray) ValidateValueForKeyPathError(ioValue *[]*Id, inKeyPath *NSString, outError *[]*NSError) bool {

	goSlice1 := make([]unsafe.Pointer,cap(*ioValue))
	for i := 0; i < len(*ioValue); i++ {
		goSlice1[i] = (*ioValue)[i].Ptr()
	}

	goSlice3 := make([]unsafe.Pointer,cap(*outError))
	for i := 0; i < len(*outError); i++ {
		goSlice3[i] = (*outError)[i].Ptr()
	}
	ret := (bool)(C.NSArray_inst_ValidateValueForKeyPathError(o.Ptr(), (*unsafe.Pointer)(unsafe.Pointer(&goSlice1[0])), inKeyPath.Ptr(), (*unsafe.Pointer)(unsafe.Pointer(&goSlice3[0]))))
	(*ioValue) = (*ioValue)[:cap(*ioValue)]
	for i := 0; i < len(*ioValue); i++ {
		if goSlice1[i] == nil {
			(*ioValue) = (*ioValue)[:i]
			break
		}
		if (*ioValue)[i] == nil {
			(*ioValue)[i] = &Id{}
			runtime.SetFinalizer((*ioValue)[i], func(o *Id) {
				o.Release()
			})
		}
		(*ioValue)[i].ptr = goSlice1[i]
	}
	(*outError) = (*outError)[:cap(*outError)]
	for i := 0; i < len(*outError); i++ {
		if goSlice3[i] == nil {
			(*outError) = (*outError)[:i]
			break
		}
		if (*outError)[i] == nil {
			(*outError)[i] = &NSError{}
			runtime.SetFinalizer((*outError)[i], func(o *NSError) {
				o.Release()
			})
		}
		(*outError)[i].ptr = goSlice3[i]
	}
	runtime.KeepAlive(o)
	return ret
}

func (o *NSArray) IsEqualTo(object NSObject) bool {
	ret := (bool)(C.NSArray_inst_IsEqualTo(o.Ptr(), object.Ptr()))
	runtime.KeepAlive(o)
	return ret
}

func (o *NSArray) LastObject() *Id {
	ret := &Id{}
	ret.ptr = unsafe.Pointer(C.NSArray_inst_LastObject(o.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *Id) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *NSArray) ClassForCoder() Class {
	ret := (Class)(unsafe.Pointer(C.NSArray_inst_ClassForCoder(o.Ptr())))
	runtime.KeepAlive(o)
	return ret
}

func (o *NSArray) ObserveValueForKeyPathOfObject(keyPath *NSString, object NSObject, change *NSDictionary, context unsafe.Pointer)  {
	C.NSArray_inst_ObserveValueForKeyPathOfObject(o.Ptr(), keyPath.Ptr(), object.Ptr(), change.Ptr(), unsafe.Pointer(context))
	runtime.KeepAlive(o)
}

func (o *NSArray) ObserveValueForKeyPathOfObjectChange(keyPath *NSString, object NSObject, change *NSDictionary, context unsafe.Pointer)  {
	C.NSArray_inst_ObserveValueForKeyPathOfObjectChange(o.Ptr(), keyPath.Ptr(), object.Ptr(), change.Ptr(), unsafe.Pointer(context))
	runtime.KeepAlive(o)
}

func (o *NSArray) ArrayByApplyingDifference(difference *NSOrderedCollectionDifference) *NSArray {
	ret := &NSArray{}
	ret.ptr = unsafe.Pointer(C.NSArray_inst_ArrayByApplyingDifference(o.Ptr(), difference.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSArray)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *NSArray) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *NSArray) SetScriptingProperties(scriptingProperties *NSDictionary)  {
	C.NSArray_inst_SetScriptingProperties(o.Ptr(), scriptingProperties.Ptr())
	runtime.KeepAlive(o)
}

func (o *NSArray) ForwardInvocation(anInvocation *NSInvocation)  {
	C.NSArray_inst_ForwardInvocation(o.Ptr(), anInvocation.Ptr())
	runtime.KeepAlive(o)
}

func (o *NSArray) InitWithObjects(firstObj NSObject) *NSArray {
	ret := &NSArray{}
	ret.ptr = unsafe.Pointer(C.NSArray_inst_InitWithObjects(o.Ptr(), firstObj.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSArray)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *NSArray) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *NSArray) InitWithObjectsCount(objects *[]*Id, cnt NSUInteger) *NSArray {

	goSlice1 := make([]unsafe.Pointer,cap(*objects))
	for i := 0; i < len(*objects); i++ {
		goSlice1[i] = (*objects)[i].Ptr()
	}
	ret := &NSArray{}
	ret.ptr = unsafe.Pointer(C.NSArray_inst_InitWithObjectsCount(o.Ptr(), (*unsafe.Pointer)(unsafe.Pointer(&goSlice1[0])), (C.NSUInteger)(cnt)))
	(*objects) = (*objects)[:cap(*objects)]
	for i := 0; i < len(*objects); i++ {
		if goSlice1[i] == nil {
			(*objects) = (*objects)[:i]
			break
		}
		if (*objects)[i] == nil {
			(*objects)[i] = &Id{}
			runtime.SetFinalizer((*objects)[i], func(o *Id) {
				o.Release()
			})
		}
		(*objects)[i].ptr = goSlice1[i]
	}
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSArray)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *NSArray) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *NSArray) DidChangeValuesAtIndexes(changeKind NSKeyValueChange, indexes *NSIndexSet, key *NSString)  {
	C.NSArray_inst_DidChangeValuesAtIndexes(o.Ptr(), (C.NSKeyValueChange)(changeKind), indexes.Ptr(), key.Ptr())
	runtime.KeepAlive(o)
}

func (o *NSArray) DidChangeValuesAtIndexesForKey(changeKind NSKeyValueChange, indexes *NSIndexSet, key *NSString)  {
	C.NSArray_inst_DidChangeValuesAtIndexesForKey(o.Ptr(), (C.NSKeyValueChange)(changeKind), indexes.Ptr(), key.Ptr())
	runtime.KeepAlive(o)
}

func (o *NSArray) AttemptRecoveryFromErrorOptionIndex(error *NSError, recoveryOptionIndex NSUInteger) bool {
	ret := (bool)(C.NSArray_inst_AttemptRecoveryFromErrorOptionIndex(o.Ptr(), error.Ptr(), (C.NSUInteger)(recoveryOptionIndex)))
	runtime.KeepAlive(o)
	return ret
}

func (o *NSArray) AttemptRecoveryFromErrorOptionIndexDelegate(error *NSError, recoveryOptionIndex NSUInteger, delegate NSObject, didRecoverSelector SEL, contextInfo unsafe.Pointer)  {
	C.NSArray_inst_AttemptRecoveryFromErrorOptionIndexDelegate(o.Ptr(), error.Ptr(), (C.NSUInteger)(recoveryOptionIndex), delegate.Ptr(), unsafe.Pointer(didRecoverSelector), unsafe.Pointer(contextInfo))
	runtime.KeepAlive(o)
}

func (o *NSArray) AttemptRecoveryFromErrorOptionIndexDelegateDidRecoverSelector(error *NSError, recoveryOptionIndex NSUInteger, delegate NSObject, didRecoverSelector SEL, contextInfo unsafe.Pointer)  {
	C.NSArray_inst_AttemptRecoveryFromErrorOptionIndexDelegateDidRecoverSelector(o.Ptr(), error.Ptr(), (C.NSUInteger)(recoveryOptionIndex), delegate.Ptr(), unsafe.Pointer(didRecoverSelector), unsafe.Pointer(contextInfo))
	runtime.KeepAlive(o)
}

func (o *NSArray) PerformSelectorInBackgroundWithObject(aSelector SEL, arg NSObject)  {
	C.NSArray_inst_PerformSelectorInBackgroundWithObject(o.Ptr(), unsafe.Pointer(aSelector), arg.Ptr())
	runtime.KeepAlive(o)
}

func (o *NSArray) InitWithArray(array *NSArray) *NSArray {
	ret := &NSArray{}
	ret.ptr = unsafe.Pointer(C.NSArray_inst_InitWithArray(o.Ptr(), array.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSArray)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *NSArray) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *NSArray) InitWithArrayCopyItems(array *NSArray, flag BOOL) *NSArray {
	ret := &NSArray{}
	ret.ptr = unsafe.Pointer(C.NSArray_inst_InitWithArrayCopyItems(o.Ptr(), array.Ptr(), (C.BOOL)(flag)))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSArray)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *NSArray) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *NSArray) ForwardingTargetForSelector(aSelector SEL) *Id {
	ret := &Id{}
	ret.ptr = unsafe.Pointer(C.NSArray_inst_ForwardingTargetForSelector(o.Ptr(), unsafe.Pointer(aSelector)))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *Id) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *NSArray) AutoContentAccessingProxy() *Id {
	ret := &Id{}
	ret.ptr = unsafe.Pointer(C.NSArray_inst_AutoContentAccessingProxy(o.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *Id) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *NSArray) SortedArrayUsingDescriptors(sortDescriptors *NSArray) *NSArray {
	ret := &NSArray{}
	ret.ptr = unsafe.Pointer(C.NSArray_inst_SortedArrayUsingDescriptors(o.Ptr(), sortDescriptors.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSArray)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *NSArray) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *NSArray) ObservationInfo() unsafe.Pointer {
	ret := (unsafe.Pointer)(unsafe.Pointer(C.NSArray_inst_ObservationInfo(o.Ptr())))
	runtime.KeepAlive(o)
	return ret
}

func (o *NSArray) NewScriptingObjectOfClassForValueForKey(objectClass Class, key *NSString, contentsValue NSObject, properties *NSDictionary) *Id {
	ret := &Id{}
	ret.ptr = unsafe.Pointer(C.NSArray_inst_NewScriptingObjectOfClassForValueForKey(o.Ptr(), unsafe.Pointer(objectClass), key.Ptr(), contentsValue.Ptr(), properties.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *Id) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *NSArray) NewScriptingObjectOfClassForValueForKeyWithContentsValue(objectClass Class, key *NSString, contentsValue NSObject, properties *NSDictionary) *Id {
	ret := &Id{}
	ret.ptr = unsafe.Pointer(C.NSArray_inst_NewScriptingObjectOfClassForValueForKeyWithContentsValue(o.Ptr(), unsafe.Pointer(objectClass), key.Ptr(), contentsValue.Ptr(), properties.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *Id) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *NSArray) ValueAtIndexInPropertyWithKey(index NSUInteger, key *NSString) *Id {
	ret := &Id{}
	ret.ptr = unsafe.Pointer(C.NSArray_inst_ValueAtIndexInPropertyWithKey(o.Ptr(), (C.NSUInteger)(index), key.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *Id) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *NSArray) SortedArrayHint() *NSData {
	ret := &NSData{}
	ret.ptr = unsafe.Pointer(C.NSArray_inst_SortedArrayHint(o.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSData)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *NSData) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *NSArray) IsNotEqualTo(object NSObject) bool {
	ret := (bool)(C.NSArray_inst_IsNotEqualTo(o.Ptr(), object.Ptr()))
	runtime.KeepAlive(o)
	return ret
}

func (o *NSArray) ToManyRelationshipKeys() *NSArray {
	ret := &NSArray{}
	ret.ptr = unsafe.Pointer(C.NSArray_inst_ToManyRelationshipKeys(o.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSArray)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *NSArray) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *NSArray) PerformSelectorOnMainThreadWithObject(aSelector SEL, arg NSObject, wait BOOL)  {
	C.NSArray_inst_PerformSelectorOnMainThreadWithObject(o.Ptr(), unsafe.Pointer(aSelector), arg.Ptr(), (C.BOOL)(wait))
	runtime.KeepAlive(o)
}

func (o *NSArray) PerformSelectorOnMainThreadWithObjectWaitUntilDone(aSelector SEL, arg NSObject, wait BOOL)  {
	C.NSArray_inst_PerformSelectorOnMainThreadWithObjectWaitUntilDone(o.Ptr(), unsafe.Pointer(aSelector), arg.Ptr(), (C.BOOL)(wait))
	runtime.KeepAlive(o)
}

func (o *NSArray) PerformSelectorOnMainThreadWithObjectWaitUntilDoneModes(aSelector SEL, arg NSObject, wait BOOL, array *NSArray)  {
	C.NSArray_inst_PerformSelectorOnMainThreadWithObjectWaitUntilDoneModes(o.Ptr(), unsafe.Pointer(aSelector), arg.Ptr(), (C.BOOL)(wait), array.Ptr())
	runtime.KeepAlive(o)
}

func (o *NSArray) MakeObjectsPerformSelector(aSelector SEL)  {
	C.NSArray_inst_MakeObjectsPerformSelector(o.Ptr(), unsafe.Pointer(aSelector))
	runtime.KeepAlive(o)
}

func (o *NSArray) MakeObjectsPerformSelectorWithObject(aSelector SEL, argument NSObject)  {
	C.NSArray_inst_MakeObjectsPerformSelectorWithObject(o.Ptr(), unsafe.Pointer(aSelector), argument.Ptr())
	runtime.KeepAlive(o)
}

func (o *NSArray) ReverseObjectEnumerator() *NSEnumerator {
	ret := &NSEnumerator{}
	ret.ptr = unsafe.Pointer(C.NSArray_inst_ReverseObjectEnumerator(o.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSEnumerator)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *NSEnumerator) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *NSArray) ReplacementObjectForCoder(coder *NSCoder) *Id {
	ret := &Id{}
	ret.ptr = unsafe.Pointer(C.NSArray_inst_ReplacementObjectForCoder(o.Ptr(), coder.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *Id) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *NSArray) MutableSetValueForKeyPath(keyPath *NSString) *NSMutableSet {
	ret := &NSMutableSet{}
	ret.ptr = unsafe.Pointer(C.NSArray_inst_MutableSetValueForKeyPath(o.Ptr(), keyPath.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSMutableSet)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *NSMutableSet) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *NSArray) SetValuesForKeysWithDictionary(keyedValues *NSDictionary)  {
	C.NSArray_inst_SetValuesForKeysWithDictionary(o.Ptr(), keyedValues.Ptr())
	runtime.KeepAlive(o)
}

func (o *NSArray) ReplaceValueAtIndexInPropertyWithKey(index NSUInteger, key *NSString, value NSObject)  {
	C.NSArray_inst_ReplaceValueAtIndexInPropertyWithKey(o.Ptr(), (C.NSUInteger)(index), key.Ptr(), value.Ptr())
	runtime.KeepAlive(o)
}

func (o *NSArray) ReplaceValueAtIndexInPropertyWithKeyWithValue(index NSUInteger, key *NSString, value NSObject)  {
	C.NSArray_inst_ReplaceValueAtIndexInPropertyWithKeyWithValue(o.Ptr(), (C.NSUInteger)(index), key.Ptr(), value.Ptr())
	runtime.KeepAlive(o)
}

func (o *NSArray) ComponentsJoinedByString(separator *NSString) *NSString {
	ret := &NSString{}
	ret.ptr = unsafe.Pointer(C.NSArray_inst_ComponentsJoinedByString(o.Ptr(), separator.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSString)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *NSString) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *NSArray) Description() *NSString {
	ret := &NSString{}
	ret.ptr = unsafe.Pointer(C.NSArray_inst_Description(o.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSString)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *NSString) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *NSArray) FirstObject() *Id {
	ret := &Id{}
	ret.ptr = unsafe.Pointer(C.NSArray_inst_FirstObject(o.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *Id) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *NSArray) ScriptingIsLessThan(object NSObject) bool {
	ret := (bool)(C.NSArray_inst_ScriptingIsLessThan(o.Ptr(), object.Ptr()))
	runtime.KeepAlive(o)
	return ret
}

func (o *NSArray) ClassCode() FourCharCode {
	ret := (FourCharCode)(C.NSArray_inst_ClassCode(o.Ptr()))
	runtime.KeepAlive(o)
	return ret
}

func (o *NSArray) RemoveValueAtIndexFromPropertyWithKey(index NSUInteger, key *NSString)  {
	C.NSArray_inst_RemoveValueAtIndexFromPropertyWithKey(o.Ptr(), (C.NSUInteger)(index), key.Ptr())
	runtime.KeepAlive(o)
}

func (o *NSArray) InsertValueInPropertyWithKey(value NSObject, key *NSString)  {
	C.NSArray_inst_InsertValueInPropertyWithKey(o.Ptr(), value.Ptr(), key.Ptr())
	runtime.KeepAlive(o)
}

func (o *NSArray) InsertValueAtIndex(value NSObject, index NSUInteger, key *NSString)  {
	C.NSArray_inst_InsertValueAtIndex(o.Ptr(), value.Ptr(), (C.NSUInteger)(index), key.Ptr())
	runtime.KeepAlive(o)
}

func (o *NSArray) InsertValueAtIndexInPropertyWithKey(value NSObject, index NSUInteger, key *NSString)  {
	C.NSArray_inst_InsertValueAtIndexInPropertyWithKey(o.Ptr(), value.Ptr(), (C.NSUInteger)(index), key.Ptr())
	runtime.KeepAlive(o)
}

func (o *NSArray) CopyWithZone(zone *NSZone) *Id {
	ret := &Id{}
	ret.ptr = unsafe.Pointer(C.NSArray_inst_CopyWithZone(o.Ptr(), unsafe.Pointer(zone)))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *Id) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *NSArray) MutableOrderedSetValueForKey(key *NSString) *NSMutableOrderedSet {
	ret := &NSMutableOrderedSet{}
	ret.ptr = unsafe.Pointer(C.NSArray_inst_MutableOrderedSetValueForKey(o.Ptr(), key.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSMutableOrderedSet)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *NSMutableOrderedSet) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *NSArray) ObjectSpecifier() *NSScriptObjectSpecifier {
	ret := &NSScriptObjectSpecifier{}
	ret.ptr = unsafe.Pointer(C.NSArray_inst_ObjectSpecifier(o.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSScriptObjectSpecifier)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *NSScriptObjectSpecifier) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *NSArray) SetObservationInfo(observationInfo unsafe.Pointer)  {
	C.NSArray_inst_SetObservationInfo(o.Ptr(), unsafe.Pointer(observationInfo))
	runtime.KeepAlive(o)
}

func (o *NSArray) ObjectsAtIndexes(indexes *NSIndexSet) *NSArray {
	ret := &NSArray{}
	ret.ptr = unsafe.Pointer(C.NSArray_inst_ObjectsAtIndexes(o.Ptr(), indexes.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSArray)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *NSArray) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *NSArray) IndexOfObjectIdenticalTo(anObject NSObject) NSUInteger {
	ret := (NSUInteger)(C.NSArray_inst_IndexOfObjectIdenticalTo(o.Ptr(), anObject.Ptr()))
	runtime.KeepAlive(o)
	return ret
}

func (o *NSArray) IndexOfObjectIdenticalToInRange(anObject NSObject, range_ NSRange) NSUInteger {
	ret := (NSUInteger)(C.NSArray_inst_IndexOfObjectIdenticalToInRange(o.Ptr(), anObject.Ptr(), (C.NSRange)(range_)))
	runtime.KeepAlive(o)
	return ret
}

func (o *NSArray) ScriptingEndsWith(object NSObject) bool {
	ret := (bool)(C.NSArray_inst_ScriptingEndsWith(o.Ptr(), object.Ptr()))
	runtime.KeepAlive(o)
	return ret
}

func (o *NSArray) ClassForKeyedArchiver() Class {
	ret := (Class)(unsafe.Pointer(C.NSArray_inst_ClassForKeyedArchiver(o.Ptr())))
	runtime.KeepAlive(o)
	return ret
}

func (o *NSArray) CountByEnumeratingWithStateObjects(state *NSFastEnumerationState, buffer *[]*Id, len_ NSUInteger) NSUInteger {

	goSlice2 := make([]unsafe.Pointer,cap(*buffer))
	for i := 0; i < len(*buffer); i++ {
		goSlice2[i] = (*buffer)[i].Ptr()
	}
	ret := (NSUInteger)(C.NSArray_inst_CountByEnumeratingWithStateObjects(o.Ptr(), unsafe.Pointer(state), (*unsafe.Pointer)(unsafe.Pointer(&goSlice2[0])), (C.NSUInteger)(len_)))
	(*buffer) = (*buffer)[:cap(*buffer)]
	for i := 0; i < len(*buffer); i++ {
		if goSlice2[i] == nil {
			(*buffer) = (*buffer)[:i]
			break
		}
		if (*buffer)[i] == nil {
			(*buffer)[i] = &Id{}
			runtime.SetFinalizer((*buffer)[i], func(o *Id) {
				o.Release()
			})
		}
		(*buffer)[i].ptr = goSlice2[i]
	}
	runtime.KeepAlive(o)
	return ret
}

func (o *NSArray) CountByEnumeratingWithStateObjectsCount(state *NSFastEnumerationState, buffer *[]*Id, len_ NSUInteger) NSUInteger {

	goSlice2 := make([]unsafe.Pointer,cap(*buffer))
	for i := 0; i < len(*buffer); i++ {
		goSlice2[i] = (*buffer)[i].Ptr()
	}
	ret := (NSUInteger)(C.NSArray_inst_CountByEnumeratingWithStateObjectsCount(o.Ptr(), unsafe.Pointer(state), (*unsafe.Pointer)(unsafe.Pointer(&goSlice2[0])), (C.NSUInteger)(len_)))
	(*buffer) = (*buffer)[:cap(*buffer)]
	for i := 0; i < len(*buffer); i++ {
		if goSlice2[i] == nil {
			(*buffer) = (*buffer)[:i]
			break
		}
		if (*buffer)[i] == nil {
			(*buffer)[i] = &Id{}
			runtime.SetFinalizer((*buffer)[i], func(o *Id) {
				o.Release()
			})
		}
		(*buffer)[i].ptr = goSlice2[i]
	}
	runtime.KeepAlive(o)
	return ret
}

func (o *NSArray) SetNilValueForKey(key *NSString)  {
	C.NSArray_inst_SetNilValueForKey(o.Ptr(), key.Ptr())
	runtime.KeepAlive(o)
}

func (o *NSArray) Copy() *Id {
	ret := &Id{}
	ret.ptr = unsafe.Pointer(C.NSArray_inst_Copy(o.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	runtime.SetFinalizer(ret, func(o *Id) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *NSArray) Dealloc()  {
	C.NSArray_inst_Dealloc(o.Ptr())
	runtime.KeepAlive(o)
}

func (o *NSArray) DoesContain(object NSObject) bool {
	ret := (bool)(C.NSArray_inst_DoesContain(o.Ptr(), object.Ptr()))
	runtime.KeepAlive(o)
	return ret
}

func (o *NSArray) DidChangeValueForKey(key *NSString)  {
	C.NSArray_inst_DidChangeValueForKey(o.Ptr(), key.Ptr())
	runtime.KeepAlive(o)
}

func (o *NSArray) DidChangeValueForKeyWithSetMutation(key *NSString, mutationKind NSKeyValueSetMutationKind, objects *NSSet)  {
	C.NSArray_inst_DidChangeValueForKeyWithSetMutation(o.Ptr(), key.Ptr(), (C.NSKeyValueSetMutationKind)(mutationKind), objects.Ptr())
	runtime.KeepAlive(o)
}

func (o *NSArray) DidChangeValueForKeyWithSetMutationUsingObjects(key *NSString, mutationKind NSKeyValueSetMutationKind, objects *NSSet)  {
	C.NSArray_inst_DidChangeValueForKeyWithSetMutationUsingObjects(o.Ptr(), key.Ptr(), (C.NSKeyValueSetMutationKind)(mutationKind), objects.Ptr())
	runtime.KeepAlive(o)
}

func (o *NSArray) ValueForKeyPath(keyPath *NSString) *Id {
	ret := &Id{}
	ret.ptr = unsafe.Pointer(C.NSArray_inst_ValueForKeyPath(o.Ptr(), keyPath.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *Id) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *NSArray) ScriptingIsEqualTo(object NSObject) bool {
	ret := (bool)(C.NSArray_inst_ScriptingIsEqualTo(o.Ptr(), object.Ptr()))
	runtime.KeepAlive(o)
	return ret
}

func (o *NSArray) ScriptingIsGreaterThan(object NSObject) bool {
	ret := (bool)(C.NSArray_inst_ScriptingIsGreaterThan(o.Ptr(), object.Ptr()))
	runtime.KeepAlive(o)
	return ret
}

func (o *NSArray) ObjectAtIndexedSubscript(idx NSUInteger) *Id {
	ret := &Id{}
	ret.ptr = unsafe.Pointer(C.NSArray_inst_ObjectAtIndexedSubscript(o.Ptr(), (C.NSUInteger)(idx)))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *Id) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *NSArray) SortedArrayUsingSelector(comparator SEL) *NSArray {
	ret := &NSArray{}
	ret.ptr = unsafe.Pointer(C.NSArray_inst_SortedArrayUsingSelector(o.Ptr(), unsafe.Pointer(comparator)))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSArray)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *NSArray) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *NSArray) ArrayByAddingObject(anObject NSObject) *NSArray {
	ret := &NSArray{}
	ret.ptr = unsafe.Pointer(C.NSArray_inst_ArrayByAddingObject(o.Ptr(), anObject.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSArray)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *NSArray) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *NSArray) SubarrayWithRange(range_ NSRange) *NSArray {
	ret := &NSArray{}
	ret.ptr = unsafe.Pointer(C.NSArray_inst_SubarrayWithRange(o.Ptr(), (C.NSRange)(range_)))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSArray)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *NSArray) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *NSArray) ToOneRelationshipKeys() *NSArray {
	ret := &NSArray{}
	ret.ptr = unsafe.Pointer(C.NSArray_inst_ToOneRelationshipKeys(o.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSArray)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *NSArray) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *NSArray) ValueWithUniqueIDInPropertyWithKey(uniqueID NSObject, key *NSString) *Id {
	ret := &Id{}
	ret.ptr = unsafe.Pointer(C.NSArray_inst_ValueWithUniqueIDInPropertyWithKey(o.Ptr(), uniqueID.Ptr(), key.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *Id) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *NSArray) ClassName() *NSString {
	ret := &NSString{}
	ret.ptr = unsafe.Pointer(C.NSArray_inst_ClassName(o.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSString)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *NSString) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *NSArray) ValueWithNameInPropertyWithKey(name *NSString, key *NSString) *Id {
	ret := &Id{}
	ret.ptr = unsafe.Pointer(C.NSArray_inst_ValueWithNameInPropertyWithKey(o.Ptr(), name.Ptr(), key.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *Id) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *NSArray) MutableCopy() *Id {
	ret := &Id{}
	ret.ptr = unsafe.Pointer(C.NSArray_inst_MutableCopy(o.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	runtime.SetFinalizer(ret, func(o *Id) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *NSArray) IsGreaterThanOrEqualTo(object NSObject) bool {
	ret := (bool)(C.NSArray_inst_IsGreaterThanOrEqualTo(o.Ptr(), object.Ptr()))
	runtime.KeepAlive(o)
	return ret
}

func (o *NSArray) CoerceValueForKey(value NSObject, key *NSString) *Id {
	ret := &Id{}
	ret.ptr = unsafe.Pointer(C.NSArray_inst_CoerceValueForKey(o.Ptr(), value.Ptr(), key.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *Id) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *NSArray) ValueForKey(key *NSString) *Id {
	ret := &Id{}
	ret.ptr = unsafe.Pointer(C.NSArray_inst_ValueForKey(o.Ptr(), key.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *Id) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *NSArray) PathsMatchingExtensions(filterTypes *NSArray) *NSArray {
	ret := &NSArray{}
	ret.ptr = unsafe.Pointer(C.NSArray_inst_PathsMatchingExtensions(o.Ptr(), filterTypes.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSArray)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *NSArray) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *NSArray) ClassDescription() *NSClassDescription {
	ret := &NSClassDescription{}
	ret.ptr = unsafe.Pointer(C.NSArray_inst_ClassDescription(o.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSClassDescription)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *NSClassDescription) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *NSArray) AwakeAfterUsingCoder(coder *NSCoder) *Id {
	ret := &Id{}
	ret.ptr = unsafe.Pointer(C.NSArray_inst_AwakeAfterUsingCoder(o.Ptr(), coder.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *Id) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *NSArray) SetValueForKey(value NSObject, key *NSString)  {
	C.NSArray_inst_SetValueForKey(o.Ptr(), value.Ptr(), key.Ptr())
	runtime.KeepAlive(o)
}

func (o *NSArray) SetValueForKeyPath(value NSObject, keyPath *NSString)  {
	C.NSArray_inst_SetValueForKeyPath(o.Ptr(), value.Ptr(), keyPath.Ptr())
	runtime.KeepAlive(o)
}

func (o *NSArray) SetValueForUndefinedKey(value NSObject, key *NSString)  {
	C.NSArray_inst_SetValueForUndefinedKey(o.Ptr(), value.Ptr(), key.Ptr())
	runtime.KeepAlive(o)
}

func (o *NSArray) MutableSetValueForKey(key *NSString) *NSMutableSet {
	ret := &NSMutableSet{}
	ret.ptr = unsafe.Pointer(C.NSArray_inst_MutableSetValueForKey(o.Ptr(), key.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSMutableSet)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *NSMutableSet) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *NSArray) IsGreaterThan(object NSObject) bool {
	ret := (bool)(C.NSArray_inst_IsGreaterThan(o.Ptr(), object.Ptr()))
	runtime.KeepAlive(o)
	return ret
}

func (o *NSArray) ClassForArchiver() Class {
	ret := (Class)(unsafe.Pointer(C.NSArray_inst_ClassForArchiver(o.Ptr())))
	runtime.KeepAlive(o)
	return ret
}

func (o *NSArray) AddObserverForKeyPath(observer NSObject, keyPath *NSString, options NSKeyValueObservingOptions, context unsafe.Pointer)  {
	C.NSArray_inst_AddObserverForKeyPath(o.Ptr(), observer.Ptr(), keyPath.Ptr(), (C.NSKeyValueObservingOptions)(options), unsafe.Pointer(context))
	runtime.KeepAlive(o)
}

func (o *NSArray) AddObserverForKeyPathOptions(observer NSObject, keyPath *NSString, options NSKeyValueObservingOptions, context unsafe.Pointer)  {
	C.NSArray_inst_AddObserverForKeyPathOptions(o.Ptr(), observer.Ptr(), keyPath.Ptr(), (C.NSKeyValueObservingOptions)(options), unsafe.Pointer(context))
	runtime.KeepAlive(o)
}

func (o *NSArray) AddObserverForKeyPathOptionsContext(observer NSObject, keyPath *NSString, options NSKeyValueObservingOptions, context unsafe.Pointer)  {
	C.NSArray_inst_AddObserverForKeyPathOptionsContext(o.Ptr(), observer.Ptr(), keyPath.Ptr(), (C.NSKeyValueObservingOptions)(options), unsafe.Pointer(context))
	runtime.KeepAlive(o)
}

func (o *NSArray) AddObserverToObjectsAtIndexes(observer NSObject, indexes *NSIndexSet, keyPath *NSString, options NSKeyValueObservingOptions, context unsafe.Pointer)  {
	C.NSArray_inst_AddObserverToObjectsAtIndexes(o.Ptr(), observer.Ptr(), indexes.Ptr(), keyPath.Ptr(), (C.NSKeyValueObservingOptions)(options), unsafe.Pointer(context))
	runtime.KeepAlive(o)
}

func (o *NSArray) AddObserverToObjectsAtIndexesForKeyPath(observer NSObject, indexes *NSIndexSet, keyPath *NSString, options NSKeyValueObservingOptions, context unsafe.Pointer)  {
	C.NSArray_inst_AddObserverToObjectsAtIndexesForKeyPath(o.Ptr(), observer.Ptr(), indexes.Ptr(), keyPath.Ptr(), (C.NSKeyValueObservingOptions)(options), unsafe.Pointer(context))
	runtime.KeepAlive(o)
}

func (o *NSArray) Init() *NSArray {
	ret := &NSArray{}
	ret.ptr = unsafe.Pointer(C.NSArray_inst_Init(o.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSArray)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *NSArray) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *NSArray) FirstObjectCommonWithArray(otherArray *NSArray) *Id {
	ret := &Id{}
	ret.ptr = unsafe.Pointer(C.NSArray_inst_FirstObjectCommonWithArray(o.Ptr(), otherArray.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *Id) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *NSArray) MutableArrayValueForKeyPath(keyPath *NSString) *NSMutableArray {
	ret := &NSMutableArray{}
	ret.ptr = unsafe.Pointer(C.NSArray_inst_MutableArrayValueForKeyPath(o.Ptr(), keyPath.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSMutableArray)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *NSMutableArray) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *NSArray) ArrayByAddingObjectsFromArray(otherArray *NSArray) *NSArray {
	ret := &NSArray{}
	ret.ptr = unsafe.Pointer(C.NSArray_inst_ArrayByAddingObjectsFromArray(o.Ptr(), otherArray.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSArray)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *NSArray) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *NSArray) ScriptingIsGreaterThanOrEqualTo(object NSObject) bool {
	ret := (bool)(C.NSArray_inst_ScriptingIsGreaterThanOrEqualTo(o.Ptr(), object.Ptr()))
	runtime.KeepAlive(o)
	return ret
}

func (o *NSArray) ReplacementObjectForKeyedArchiver(archiver *NSKeyedArchiver) *Id {
	ret := &Id{}
	ret.ptr = unsafe.Pointer(C.NSArray_inst_ReplacementObjectForKeyedArchiver(o.Ptr(), archiver.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *Id) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *NSArray) ObjectEnumerator() *NSEnumerator {
	ret := &NSEnumerator{}
	ret.ptr = unsafe.Pointer(C.NSArray_inst_ObjectEnumerator(o.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSEnumerator)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *NSEnumerator) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *NSArray) Count() NSUInteger {
	ret := (NSUInteger)(C.NSArray_inst_Count(o.Ptr()))
	runtime.KeepAlive(o)
	return ret
}

func (o *NSArray) InitWithCoder(coder *NSCoder) *NSArray {
	ret := &NSArray{}
	ret.ptr = unsafe.Pointer(C.NSArray_inst_InitWithCoder(o.Ptr(), coder.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSArray)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *NSArray) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *NSArray) ContainsObject(anObject NSObject) bool {
	ret := (bool)(C.NSArray_inst_ContainsObject(o.Ptr(), anObject.Ptr()))
	runtime.KeepAlive(o)
	return ret
}

func (o *NSArray) MutableArrayValueForKey(key *NSString) *NSMutableArray {
	ret := &NSMutableArray{}
	ret.ptr = unsafe.Pointer(C.NSArray_inst_MutableArrayValueForKey(o.Ptr(), key.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSMutableArray)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *NSMutableArray) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *NSArray) ScriptingProperties() *NSDictionary {
	ret := &NSDictionary{}
	ret.ptr = unsafe.Pointer(C.NSArray_inst_ScriptingProperties(o.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSDictionary)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *NSDictionary) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *NSArray) ObjectAtIndex(index NSUInteger) *Id {
	ret := &Id{}
	ret.ptr = unsafe.Pointer(C.NSArray_inst_ObjectAtIndex(o.Ptr(), (C.NSUInteger)(index)))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *Id) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *NSArray) InitWithContentsOfURLError(url *NSURL, error *[]*NSError) *NSArray {

	goSlice2 := make([]unsafe.Pointer,cap(*error))
	for i := 0; i < len(*error); i++ {
		goSlice2[i] = (*error)[i].Ptr()
	}
	ret := &NSArray{}
	ret.ptr = unsafe.Pointer(C.NSArray_inst_InitWithContentsOfURLError(o.Ptr(), url.Ptr(), (*unsafe.Pointer)(unsafe.Pointer(&goSlice2[0]))))
	(*error) = (*error)[:cap(*error)]
	for i := 0; i < len(*error); i++ {
		if goSlice2[i] == nil {
			(*error) = (*error)[:i]
			break
		}
		if (*error)[i] == nil {
			(*error)[i] = &NSError{}
			runtime.SetFinalizer((*error)[i], func(o *NSError) {
				o.Release()
			})
		}
		(*error)[i].ptr = goSlice2[i]
	}
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSArray)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *NSArray) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *NSArray) ScriptingValueForSpecifier(objectSpecifier *NSScriptObjectSpecifier) *Id {
	ret := &Id{}
	ret.ptr = unsafe.Pointer(C.NSArray_inst_ScriptingValueForSpecifier(o.Ptr(), objectSpecifier.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *Id) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *NSArray) FilteredArrayUsingPredicate(predicate *NSPredicate) *NSArray {
	ret := &NSArray{}
	ret.ptr = unsafe.Pointer(C.NSArray_inst_FilteredArrayUsingPredicate(o.Ptr(), predicate.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSArray)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *NSArray) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *NSArray) WillChangeValuesAtIndexes(changeKind NSKeyValueChange, indexes *NSIndexSet, key *NSString)  {
	C.NSArray_inst_WillChangeValuesAtIndexes(o.Ptr(), (C.NSKeyValueChange)(changeKind), indexes.Ptr(), key.Ptr())
	runtime.KeepAlive(o)
}

func (o *NSArray) WillChangeValuesAtIndexesForKey(changeKind NSKeyValueChange, indexes *NSIndexSet, key *NSString)  {
	C.NSArray_inst_WillChangeValuesAtIndexesForKey(o.Ptr(), (C.NSKeyValueChange)(changeKind), indexes.Ptr(), key.Ptr())
	runtime.KeepAlive(o)
}

func (o *NSArray) IndicesOfObjectsByEvaluatingObjectSpecifier(specifier *NSScriptObjectSpecifier) *NSArray {
	ret := &NSArray{}
	ret.ptr = unsafe.Pointer(C.NSArray_inst_IndicesOfObjectsByEvaluatingObjectSpecifier(o.Ptr(), specifier.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSArray)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *NSArray) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *NSArray) ValueForUndefinedKey(key *NSString) *Id {
	ret := &Id{}
	ret.ptr = unsafe.Pointer(C.NSArray_inst_ValueForUndefinedKey(o.Ptr(), key.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *Id) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *NSArray) IsLessThan(object NSObject) bool {
	ret := (bool)(C.NSArray_inst_IsLessThan(o.Ptr(), object.Ptr()))
	runtime.KeepAlive(o)
	return ret
}

func (o *NSArray) MethodSignatureForSelector(aSelector SEL) *NSMethodSignature {
	ret := &NSMethodSignature{}
	ret.ptr = unsafe.Pointer(C.NSArray_inst_MethodSignatureForSelector(o.Ptr(), unsafe.Pointer(aSelector)))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSMethodSignature)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *NSMethodSignature) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *NSArray) PerformSelectorWithObject(aSelector SEL, anArgument NSObject, delay NSTimeInterval)  {
	C.NSArray_inst_PerformSelectorWithObject(o.Ptr(), unsafe.Pointer(aSelector), anArgument.Ptr(), (C.NSTimeInterval)(delay))
	runtime.KeepAlive(o)
}

func (o *NSArray) PerformSelectorWithObjectAfterDelay(aSelector SEL, anArgument NSObject, delay NSTimeInterval)  {
	C.NSArray_inst_PerformSelectorWithObjectAfterDelay(o.Ptr(), unsafe.Pointer(aSelector), anArgument.Ptr(), (C.NSTimeInterval)(delay))
	runtime.KeepAlive(o)
}

func (o *NSArray) PerformSelectorWithObjectAfterDelayInModes(aSelector SEL, anArgument NSObject, delay NSTimeInterval, modes *NSArray)  {
	C.NSArray_inst_PerformSelectorWithObjectAfterDelayInModes(o.Ptr(), unsafe.Pointer(aSelector), anArgument.Ptr(), (C.NSTimeInterval)(delay), modes.Ptr())
	runtime.KeepAlive(o)
}

func (o *NSArray) PerformSelectorOnThread(aSelector SEL, thr *NSThread, arg NSObject, wait BOOL)  {
	C.NSArray_inst_PerformSelectorOnThread(o.Ptr(), unsafe.Pointer(aSelector), thr.Ptr(), arg.Ptr(), (C.BOOL)(wait))
	runtime.KeepAlive(o)
}

func (o *NSArray) PerformSelectorOnThreadWithObject(aSelector SEL, thr *NSThread, arg NSObject, wait BOOL)  {
	C.NSArray_inst_PerformSelectorOnThreadWithObject(o.Ptr(), unsafe.Pointer(aSelector), thr.Ptr(), arg.Ptr(), (C.BOOL)(wait))
	runtime.KeepAlive(o)
}

func (o *NSArray) PerformSelectorOnThreadWithObjectWaitUntilDone(aSelector SEL, thr *NSThread, arg NSObject, wait BOOL, array *NSArray)  {
	C.NSArray_inst_PerformSelectorOnThreadWithObjectWaitUntilDone(o.Ptr(), unsafe.Pointer(aSelector), thr.Ptr(), arg.Ptr(), (C.BOOL)(wait), array.Ptr())
	runtime.KeepAlive(o)
}

func (o *NSArray) PerformSelectorOnThreadWithObjectWaitUntilDoneModes(aSelector SEL, thr *NSThread, arg NSObject, wait BOOL, array *NSArray)  {
	C.NSArray_inst_PerformSelectorOnThreadWithObjectWaitUntilDoneModes(o.Ptr(), unsafe.Pointer(aSelector), thr.Ptr(), arg.Ptr(), (C.BOOL)(wait), array.Ptr())
	runtime.KeepAlive(o)
}

func NSMutableArrayCancelPreviousPerformRequestsWithTarget(aTarget NSObject)  {
	C.NSMutableArray_CancelPreviousPerformRequestsWithTarget(aTarget.Ptr())
}

func NSMutableArrayCancelPreviousPerformRequestsWithTargetSelector(aTarget NSObject, aSelector SEL, anArgument NSObject)  {
	C.NSMutableArray_CancelPreviousPerformRequestsWithTargetSelector(aTarget.Ptr(), unsafe.Pointer(aSelector), anArgument.Ptr())
}

func NSMutableArrayCancelPreviousPerformRequestsWithTargetSelectorObject(aTarget NSObject, aSelector SEL, anArgument NSObject)  {
	C.NSMutableArray_CancelPreviousPerformRequestsWithTargetSelectorObject(aTarget.Ptr(), unsafe.Pointer(aSelector), anArgument.Ptr())
}

func NSMutableArrayCopyWithZone(zone *_NSZone) *Id {
	ret := &Id{}
	ret.ptr = unsafe.Pointer(C.NSMutableArray_CopyWithZone(unsafe.Pointer(zone)))
	if ret.ptr == nil { return ret }
	runtime.SetFinalizer(ret, func(o *Id) {
		o.Release()
	})
	return ret
}

func NSMutableArraySupportsSecureCoding() bool {
	ret := (bool)(C.NSMutableArray_SupportsSecureCoding())
	return ret
}

func NSMutableArrayWithContentsOfFile(path *NSString) *NSMutableArray {
	ret := &NSMutableArray{}
	ret.ptr = unsafe.Pointer(C.NSMutableArray_ArrayWithContentsOfFile(path.Ptr()))
	if ret.ptr == nil { return ret }
	runtime.SetFinalizer(ret, func(o *NSMutableArray) {
		o.Release()
	})
	return ret
}

func NSMutableArrayWithArray(array *NSArray) *NSMutableArray {
	ret := &NSMutableArray{}
	ret.ptr = unsafe.Pointer(C.NSMutableArray_ArrayWithArray(array.Ptr()))
	if ret.ptr == nil { return ret }
	runtime.SetFinalizer(ret, func(o *NSMutableArray) {
		o.Release()
	})
	return ret
}

func NSMutableArrayHash() NSUInteger {
	ret := (NSUInteger)(C.NSMutableArray_Hash())
	return ret
}

func NSMutableArrayClass() Class {
	ret := (Class)(unsafe.Pointer(C.NSMutableArray_Class()))
	return ret
}

func NSMutableArrayClassForKeyedUnarchiver() Class {
	ret := (Class)(unsafe.Pointer(C.NSMutableArray_ClassForKeyedUnarchiver()))
	return ret
}

func NSMutableArrayResolveInstanceMethod(sel SEL) bool {
	ret := (bool)(C.NSMutableArray_ResolveInstanceMethod(unsafe.Pointer(sel)))
	return ret
}

func NSMutableArrayAutomaticallyNotifiesObserversForKey(key *NSString) bool {
	ret := (bool)(C.NSMutableArray_AutomaticallyNotifiesObserversForKey(key.Ptr()))
	return ret
}

func NSMutableArrayLoad()  {
	C.NSMutableArray_Load()
}

func NSMutableArrayResolveClassMethod(sel SEL) bool {
	ret := (bool)(C.NSMutableArray_ResolveClassMethod(unsafe.Pointer(sel)))
	return ret
}

func NSMutableArrayInstancesRespondToSelector(aSelector SEL) bool {
	ret := (bool)(C.NSMutableArray_InstancesRespondToSelector(unsafe.Pointer(aSelector)))
	return ret
}

func NSMutableArrayMutableCopyWithZone(zone *_NSZone) *Id {
	ret := &Id{}
	ret.ptr = unsafe.Pointer(C.NSMutableArray_MutableCopyWithZone(unsafe.Pointer(zone)))
	if ret.ptr == nil { return ret }
	runtime.SetFinalizer(ret, func(o *Id) {
		o.Release()
	})
	return ret
}

func NSMutableArrayInstanceMethodSignatureForSelector(aSelector SEL) *NSMethodSignature {
	ret := &NSMethodSignature{}
	ret.ptr = unsafe.Pointer(C.NSMutableArray_InstanceMethodSignatureForSelector(unsafe.Pointer(aSelector)))
	if ret.ptr == nil { return ret }
	return ret
}

func NSMutableArrayDebugDescription() *NSString {
	ret := &NSString{}
	ret.ptr = unsafe.Pointer(C.NSMutableArray_DebugDescription())
	if ret.ptr == nil { return ret }
	return ret
}

func NSMutableArrayIsSubclassOfClass(aClass Class) bool {
	ret := (bool)(C.NSMutableArray_IsSubclassOfClass(unsafe.Pointer(aClass)))
	return ret
}

func NSMutableArrayWithCapacity(numItems NSUInteger) *NSMutableArray {
	ret := &NSMutableArray{}
	ret.ptr = unsafe.Pointer(C.NSMutableArray_ArrayWithCapacity((C.NSUInteger)(numItems)))
	if ret.ptr == nil { return ret }
	runtime.SetFinalizer(ret, func(o *NSMutableArray) {
		o.Release()
	})
	return ret
}

func NSMutableArrayAlloc() *NSMutableArray {
	ret := &NSMutableArray{}
	ret.ptr = unsafe.Pointer(C.NSMutableArray_Alloc())
	if ret.ptr == nil { return ret }
	runtime.SetFinalizer(ret, func(o *NSMutableArray) {
		o.Release()
	})
	return ret
}

func (o *NSMutableArray) GC() {
	if o.ptr == nil { return }
	runtime.SetFinalizer(o, func(o *NSMutableArray) {
		o.Release()
	})
	runtime.KeepAlive(o)
}

func NSMutableArrayDescription() *NSString {
	ret := &NSString{}
	ret.ptr = unsafe.Pointer(C.NSMutableArray_Description())
	if ret.ptr == nil { return ret }
	return ret
}

func NSMutableArrayKeyPathsForValuesAffectingValueForKey(key *NSString) *NSSet {
	ret := &NSSet{}
	ret.ptr = unsafe.Pointer(C.NSMutableArray_KeyPathsForValuesAffectingValueForKey(key.Ptr()))
	if ret.ptr == nil { return ret }
	return ret
}

func NSMutableArrayClassFallbacksForKeyedArchiver() *NSArray {
	ret := &NSArray{}
	ret.ptr = unsafe.Pointer(C.NSMutableArray_ClassFallbacksForKeyedArchiver())
	if ret.ptr == nil { return ret }
	return ret
}

func NSMutableArrayWithObject(anObject NSObject) *NSMutableArray {
	ret := &NSMutableArray{}
	ret.ptr = unsafe.Pointer(C.NSMutableArray_ArrayWithObject(anObject.Ptr()))
	if ret.ptr == nil { return ret }
	runtime.SetFinalizer(ret, func(o *NSMutableArray) {
		o.Release()
	})
	return ret
}

func NSMutableArraySuperclass() Class {
	ret := (Class)(unsafe.Pointer(C.NSMutableArray_Superclass()))
	return ret
}

func NSMutableArrayConformsToProtocol(protocol Protocol) bool {
	ret := (bool)(C.NSMutableArray_ConformsToProtocol(protocol.Ptr()))
	return ret
}

func NSMutableArrayWithObjects(firstObj NSObject) *NSMutableArray {
	ret := &NSMutableArray{}
	ret.ptr = unsafe.Pointer(C.NSMutableArray_ArrayWithObjects(firstObj.Ptr()))
	if ret.ptr == nil { return ret }
	runtime.SetFinalizer(ret, func(o *NSMutableArray) {
		o.Release()
	})
	return ret
}

func NSMutableArrayWithObjectsCount(objects *[]*Id, cnt NSUInteger) *NSMutableArray {

	goSlice0 := make([]unsafe.Pointer,cap(*objects))
	for i := 0; i < len(*objects); i++ {
		goSlice0[i] = (*objects)[i].Ptr()
	}
	ret := &NSMutableArray{}
	ret.ptr = unsafe.Pointer(C.NSMutableArray_ArrayWithObjectsCount((*unsafe.Pointer)(unsafe.Pointer(&goSlice0[0])), (C.NSUInteger)(cnt)))
	(*objects) = (*objects)[:cap(*objects)]
	for i := 0; i < len(*objects); i++ {
		if goSlice0[i] == nil {
			(*objects) = (*objects)[:i]
			break
		}
		if (*objects)[i] == nil {
			(*objects)[i] = &Id{}
			runtime.SetFinalizer((*objects)[i], func(o *Id) {
				o.Release()
			})
		}
		(*objects)[i].ptr = goSlice0[i]
	}
	if ret.ptr == nil { return ret }
	runtime.SetFinalizer(ret, func(o *NSMutableArray) {
		o.Release()
	})
	return ret
}

func NSMutableArrayAllocWithZone(zone *_NSZone) *NSMutableArray {
	ret := &NSMutableArray{}
	ret.ptr = unsafe.Pointer(C.NSMutableArray_AllocWithZone(unsafe.Pointer(zone)))
	if ret.ptr == nil { return ret }
	runtime.SetFinalizer(ret, func(o *NSMutableArray) {
		o.Release()
	})
	return ret
}

func NSMutableArrayNew() *NSMutableArray {
	ret := &NSMutableArray{}
	ret.ptr = unsafe.Pointer(C.NSMutableArray_New())
	if ret.ptr == nil { return ret }
	runtime.SetFinalizer(ret, func(o *NSMutableArray) {
		o.Release()
	})
	return ret
}

func NSMutableArrayAccessInstanceVariablesDirectly() bool {
	ret := (bool)(C.NSMutableArray_AccessInstanceVariablesDirectly())
	return ret
}

func NSMutableArrayArray() *NSMutableArray {
	ret := &NSMutableArray{}
	ret.ptr = unsafe.Pointer(C.NSMutableArray_Array())
	if ret.ptr == nil { return ret }
	runtime.SetFinalizer(ret, func(o *NSMutableArray) {
		o.Release()
	})
	return ret
}

func NSMutableArrayVersion() NSInteger {
	ret := (NSInteger)(C.NSMutableArray_Version())
	return ret
}

func NSMutableArrayWithContentsOfURL(url *NSURL) *NSMutableArray {
	ret := &NSMutableArray{}
	ret.ptr = unsafe.Pointer(C.NSMutableArray_ArrayWithContentsOfURL(url.Ptr()))
	if ret.ptr == nil { return ret }
	runtime.SetFinalizer(ret, func(o *NSMutableArray) {
		o.Release()
	})
	return ret
}

func NSMutableArrayWithContentsOfURLError(url *NSURL, error *[]*NSError) *NSArray {

	goSlice1 := make([]unsafe.Pointer,cap(*error))
	for i := 0; i < len(*error); i++ {
		goSlice1[i] = (*error)[i].Ptr()
	}
	ret := &NSArray{}
	ret.ptr = unsafe.Pointer(C.NSMutableArray_ArrayWithContentsOfURLError(url.Ptr(), (*unsafe.Pointer)(unsafe.Pointer(&goSlice1[0]))))
	(*error) = (*error)[:cap(*error)]
	for i := 0; i < len(*error); i++ {
		if goSlice1[i] == nil {
			(*error) = (*error)[:i]
			break
		}
		if (*error)[i] == nil {
			(*error)[i] = &NSError{}
			runtime.SetFinalizer((*error)[i], func(o *NSError) {
				o.Release()
			})
		}
		(*error)[i].ptr = goSlice1[i]
	}
	if ret.ptr == nil { return ret }
	runtime.SetFinalizer(ret, func(o *NSArray) {
		o.Release()
	})
	return ret
}

func NSMutableArraySetVersion(aVersion NSInteger)  {
	C.NSMutableArray_SetVersion((C.NSInteger)(aVersion))
}

func (o *NSMutableArray) IndexOfObjectIdenticalTo(anObject NSObject) NSUInteger {
	ret := (NSUInteger)(C.NSMutableArray_inst_IndexOfObjectIdenticalTo(o.Ptr(), anObject.Ptr()))
	runtime.KeepAlive(o)
	return ret
}

func (o *NSMutableArray) IndexOfObjectIdenticalToInRange(anObject NSObject, range_ NSRange) NSUInteger {
	ret := (NSUInteger)(C.NSMutableArray_inst_IndexOfObjectIdenticalToInRange(o.Ptr(), anObject.Ptr(), (C.NSRange)(range_)))
	runtime.KeepAlive(o)
	return ret
}

func (o *NSMutableArray) MutableCopy() *Id {
	ret := &Id{}
	ret.ptr = unsafe.Pointer(C.NSMutableArray_inst_MutableCopy(o.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	runtime.SetFinalizer(ret, func(o *Id) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *NSMutableArray) ValueForKey(key *NSString) *Id {
	ret := &Id{}
	ret.ptr = unsafe.Pointer(C.NSMutableArray_inst_ValueForKey(o.Ptr(), key.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *Id) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *NSMutableArray) RemoveObjectAtIndex(index NSUInteger)  {
	C.NSMutableArray_inst_RemoveObjectAtIndex(o.Ptr(), (C.NSUInteger)(index))
	runtime.KeepAlive(o)
}

func (o *NSMutableArray) FilterUsingPredicate(predicate *NSPredicate)  {
	C.NSMutableArray_inst_FilterUsingPredicate(o.Ptr(), predicate.Ptr())
	runtime.KeepAlive(o)
}

func (o *NSMutableArray) IsLessThanOrEqualTo(object NSObject) bool {
	ret := (bool)(C.NSMutableArray_inst_IsLessThanOrEqualTo(o.Ptr(), object.Ptr()))
	runtime.KeepAlive(o)
	return ret
}

func (o *NSMutableArray) InverseForRelationshipKey(relationshipKey *NSString) *NSString {
	ret := &NSString{}
	ret.ptr = unsafe.Pointer(C.NSMutableArray_inst_InverseForRelationshipKey(o.Ptr(), relationshipKey.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSString)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *NSString) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *NSMutableArray) MutableOrderedSetValueForKey(key *NSString) *NSMutableOrderedSet {
	ret := &NSMutableOrderedSet{}
	ret.ptr = unsafe.Pointer(C.NSMutableArray_inst_MutableOrderedSetValueForKey(o.Ptr(), key.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSMutableOrderedSet)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *NSMutableOrderedSet) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *NSMutableArray) Count() NSUInteger {
	ret := (NSUInteger)(C.NSMutableArray_inst_Count(o.Ptr()))
	runtime.KeepAlive(o)
	return ret
}

func (o *NSMutableArray) MethodSignatureForSelector(aSelector SEL) *NSMethodSignature {
	ret := &NSMethodSignature{}
	ret.ptr = unsafe.Pointer(C.NSMutableArray_inst_MethodSignatureForSelector(o.Ptr(), unsafe.Pointer(aSelector)))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSMethodSignature)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *NSMethodSignature) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *NSMutableArray) SetScriptingProperties(scriptingProperties *NSDictionary)  {
	C.NSMutableArray_inst_SetScriptingProperties(o.Ptr(), scriptingProperties.Ptr())
	runtime.KeepAlive(o)
}

func (o *NSMutableArray) ClassForKeyedArchiver() Class {
	ret := (Class)(unsafe.Pointer(C.NSMutableArray_inst_ClassForKeyedArchiver(o.Ptr())))
	runtime.KeepAlive(o)
	return ret
}

func (o *NSMutableArray) FirstObjectCommonWithArray(otherArray *NSArray) *Id {
	ret := &Id{}
	ret.ptr = unsafe.Pointer(C.NSMutableArray_inst_FirstObjectCommonWithArray(o.Ptr(), otherArray.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *Id) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *NSMutableArray) DidChangeValuesAtIndexes(changeKind NSKeyValueChange, indexes *NSIndexSet, key *NSString)  {
	C.NSMutableArray_inst_DidChangeValuesAtIndexes(o.Ptr(), (C.NSKeyValueChange)(changeKind), indexes.Ptr(), key.Ptr())
	runtime.KeepAlive(o)
}

func (o *NSMutableArray) DidChangeValuesAtIndexesForKey(changeKind NSKeyValueChange, indexes *NSIndexSet, key *NSString)  {
	C.NSMutableArray_inst_DidChangeValuesAtIndexesForKey(o.Ptr(), (C.NSKeyValueChange)(changeKind), indexes.Ptr(), key.Ptr())
	runtime.KeepAlive(o)
}

func (o *NSMutableArray) ObjectEnumerator() *NSEnumerator {
	ret := &NSEnumerator{}
	ret.ptr = unsafe.Pointer(C.NSMutableArray_inst_ObjectEnumerator(o.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSEnumerator)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *NSEnumerator) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *NSMutableArray) MutableArrayValueForKey(key *NSString) *NSMutableArray {
	ret := &NSMutableArray{}
	ret.ptr = unsafe.Pointer(C.NSMutableArray_inst_MutableArrayValueForKey(o.Ptr(), key.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSMutableArray)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *NSMutableArray) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *NSMutableArray) SetNilValueForKey(key *NSString)  {
	C.NSMutableArray_inst_SetNilValueForKey(o.Ptr(), key.Ptr())
	runtime.KeepAlive(o)
}

func (o *NSMutableArray) CountByEnumeratingWithStateObjects(state *NSFastEnumerationState, buffer *[]*Id, len_ NSUInteger) NSUInteger {

	goSlice2 := make([]unsafe.Pointer,cap(*buffer))
	for i := 0; i < len(*buffer); i++ {
		goSlice2[i] = (*buffer)[i].Ptr()
	}
	ret := (NSUInteger)(C.NSMutableArray_inst_CountByEnumeratingWithStateObjects(o.Ptr(), unsafe.Pointer(state), (*unsafe.Pointer)(unsafe.Pointer(&goSlice2[0])), (C.NSUInteger)(len_)))
	(*buffer) = (*buffer)[:cap(*buffer)]
	for i := 0; i < len(*buffer); i++ {
		if goSlice2[i] == nil {
			(*buffer) = (*buffer)[:i]
			break
		}
		if (*buffer)[i] == nil {
			(*buffer)[i] = &Id{}
			runtime.SetFinalizer((*buffer)[i], func(o *Id) {
				o.Release()
			})
		}
		(*buffer)[i].ptr = goSlice2[i]
	}
	runtime.KeepAlive(o)
	return ret
}

func (o *NSMutableArray) CountByEnumeratingWithStateObjectsCount(state *NSFastEnumerationState, buffer *[]*Id, len_ NSUInteger) NSUInteger {

	goSlice2 := make([]unsafe.Pointer,cap(*buffer))
	for i := 0; i < len(*buffer); i++ {
		goSlice2[i] = (*buffer)[i].Ptr()
	}
	ret := (NSUInteger)(C.NSMutableArray_inst_CountByEnumeratingWithStateObjectsCount(o.Ptr(), unsafe.Pointer(state), (*unsafe.Pointer)(unsafe.Pointer(&goSlice2[0])), (C.NSUInteger)(len_)))
	(*buffer) = (*buffer)[:cap(*buffer)]
	for i := 0; i < len(*buffer); i++ {
		if goSlice2[i] == nil {
			(*buffer) = (*buffer)[:i]
			break
		}
		if (*buffer)[i] == nil {
			(*buffer)[i] = &Id{}
			runtime.SetFinalizer((*buffer)[i], func(o *Id) {
				o.Release()
			})
		}
		(*buffer)[i].ptr = goSlice2[i]
	}
	runtime.KeepAlive(o)
	return ret
}

func (o *NSMutableArray) ArrayByAddingObjectsFromArray(otherArray *NSArray) *NSArray {
	ret := &NSArray{}
	ret.ptr = unsafe.Pointer(C.NSMutableArray_inst_ArrayByAddingObjectsFromArray(o.Ptr(), otherArray.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSArray)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *NSArray) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *NSMutableArray) Init() *NSMutableArray {
	ret := &NSMutableArray{}
	ret.ptr = unsafe.Pointer(C.NSMutableArray_inst_Init(o.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSMutableArray)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *NSMutableArray) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *NSMutableArray) CopyScriptingValueForKey(value NSObject, key *NSString, properties *NSDictionary) *Id {
	ret := &Id{}
	ret.ptr = unsafe.Pointer(C.NSMutableArray_inst_CopyScriptingValueForKey(o.Ptr(), value.Ptr(), key.Ptr(), properties.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *Id) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *NSMutableArray) CopyScriptingValueForKeyWithProperties(value NSObject, key *NSString, properties *NSDictionary) *Id {
	ret := &Id{}
	ret.ptr = unsafe.Pointer(C.NSMutableArray_inst_CopyScriptingValueForKeyWithProperties(o.Ptr(), value.Ptr(), key.Ptr(), properties.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *Id) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *NSMutableArray) ValueAtIndexInPropertyWithKey(index NSUInteger, key *NSString) *Id {
	ret := &Id{}
	ret.ptr = unsafe.Pointer(C.NSMutableArray_inst_ValueAtIndexInPropertyWithKey(o.Ptr(), (C.NSUInteger)(index), key.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *Id) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *NSMutableArray) ReplacementObjectForCoder(coder *NSCoder) *Id {
	ret := &Id{}
	ret.ptr = unsafe.Pointer(C.NSMutableArray_inst_ReplacementObjectForCoder(o.Ptr(), coder.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *Id) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *NSMutableArray) MutableSetValueForKeyPath(keyPath *NSString) *NSMutableSet {
	ret := &NSMutableSet{}
	ret.ptr = unsafe.Pointer(C.NSMutableArray_inst_MutableSetValueForKeyPath(o.Ptr(), keyPath.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSMutableSet)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *NSMutableSet) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *NSMutableArray) ContainsObject(anObject NSObject) bool {
	ret := (bool)(C.NSMutableArray_inst_ContainsObject(o.Ptr(), anObject.Ptr()))
	runtime.KeepAlive(o)
	return ret
}

func (o *NSMutableArray) SortedArrayUsingSelector(comparator SEL) *NSArray {
	ret := &NSArray{}
	ret.ptr = unsafe.Pointer(C.NSMutableArray_inst_SortedArrayUsingSelector(o.Ptr(), unsafe.Pointer(comparator)))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSArray)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *NSArray) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *NSMutableArray) ReplaceObjectsInRangeWithObjectsFromArray(range_ NSRange, otherArray *NSArray)  {
	C.NSMutableArray_inst_ReplaceObjectsInRangeWithObjectsFromArray(o.Ptr(), (C.NSRange)(range_), otherArray.Ptr())
	runtime.KeepAlive(o)
}

func (o *NSMutableArray) ReplaceObjectsInRangeWithObjectsFromArrayRange(range_ NSRange, otherArray *NSArray, otherRange NSRange)  {
	C.NSMutableArray_inst_ReplaceObjectsInRangeWithObjectsFromArrayRange(o.Ptr(), (C.NSRange)(range_), otherArray.Ptr(), (C.NSRange)(otherRange))
	runtime.KeepAlive(o)
}

func (o *NSMutableArray) DictionaryWithValuesForKeys(keys *NSArray) *NSDictionary {
	ret := &NSDictionary{}
	ret.ptr = unsafe.Pointer(C.NSMutableArray_inst_DictionaryWithValuesForKeys(o.Ptr(), keys.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSDictionary)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *NSDictionary) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *NSMutableArray) SortedArrayHint() *NSData {
	ret := &NSData{}
	ret.ptr = unsafe.Pointer(C.NSMutableArray_inst_SortedArrayHint(o.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSData)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *NSData) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *NSMutableArray) CopyWithZone(zone *NSZone) *Id {
	ret := &Id{}
	ret.ptr = unsafe.Pointer(C.NSMutableArray_inst_CopyWithZone(o.Ptr(), unsafe.Pointer(zone)))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *Id) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *NSMutableArray) Dealloc()  {
	C.NSMutableArray_inst_Dealloc(o.Ptr())
	runtime.KeepAlive(o)
}

func (o *NSMutableArray) SortUsingDescriptors(sortDescriptors *NSArray)  {
	C.NSMutableArray_inst_SortUsingDescriptors(o.Ptr(), sortDescriptors.Ptr())
	runtime.KeepAlive(o)
}

func (o *NSMutableArray) PerformSelectorWithObject(aSelector SEL, anArgument NSObject, delay NSTimeInterval)  {
	C.NSMutableArray_inst_PerformSelectorWithObject(o.Ptr(), unsafe.Pointer(aSelector), anArgument.Ptr(), (C.NSTimeInterval)(delay))
	runtime.KeepAlive(o)
}

func (o *NSMutableArray) PerformSelectorWithObjectAfterDelay(aSelector SEL, anArgument NSObject, delay NSTimeInterval)  {
	C.NSMutableArray_inst_PerformSelectorWithObjectAfterDelay(o.Ptr(), unsafe.Pointer(aSelector), anArgument.Ptr(), (C.NSTimeInterval)(delay))
	runtime.KeepAlive(o)
}

func (o *NSMutableArray) PerformSelectorWithObjectAfterDelayInModes(aSelector SEL, anArgument NSObject, delay NSTimeInterval, modes *NSArray)  {
	C.NSMutableArray_inst_PerformSelectorWithObjectAfterDelayInModes(o.Ptr(), unsafe.Pointer(aSelector), anArgument.Ptr(), (C.NSTimeInterval)(delay), modes.Ptr())
	runtime.KeepAlive(o)
}

func (o *NSMutableArray) PerformSelectorOnThread(aSelector SEL, thr *NSThread, arg NSObject, wait BOOL)  {
	C.NSMutableArray_inst_PerformSelectorOnThread(o.Ptr(), unsafe.Pointer(aSelector), thr.Ptr(), arg.Ptr(), (C.BOOL)(wait))
	runtime.KeepAlive(o)
}

func (o *NSMutableArray) PerformSelectorOnThreadWithObject(aSelector SEL, thr *NSThread, arg NSObject, wait BOOL)  {
	C.NSMutableArray_inst_PerformSelectorOnThreadWithObject(o.Ptr(), unsafe.Pointer(aSelector), thr.Ptr(), arg.Ptr(), (C.BOOL)(wait))
	runtime.KeepAlive(o)
}

func (o *NSMutableArray) PerformSelectorOnThreadWithObjectWaitUntilDone(aSelector SEL, thr *NSThread, arg NSObject, wait BOOL)  {
	C.NSMutableArray_inst_PerformSelectorOnThreadWithObjectWaitUntilDone(o.Ptr(), unsafe.Pointer(aSelector), thr.Ptr(), arg.Ptr(), (C.BOOL)(wait))
	runtime.KeepAlive(o)
}

func (o *NSMutableArray) PerformSelectorOnThreadWithObjectWaitUntilDoneModes(aSelector SEL, thr *NSThread, arg NSObject, wait BOOL, array *NSArray)  {
	C.NSMutableArray_inst_PerformSelectorOnThreadWithObjectWaitUntilDoneModes(o.Ptr(), unsafe.Pointer(aSelector), thr.Ptr(), arg.Ptr(), (C.BOOL)(wait), array.Ptr())
	runtime.KeepAlive(o)
}

func (o *NSMutableArray) AttributeKeys() *NSArray {
	ret := &NSArray{}
	ret.ptr = unsafe.Pointer(C.NSMutableArray_inst_AttributeKeys(o.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSArray)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *NSArray) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *NSMutableArray) DescriptionWithLocale(locale NSObject) *NSString {
	ret := &NSString{}
	ret.ptr = unsafe.Pointer(C.NSMutableArray_inst_DescriptionWithLocale(o.Ptr(), locale.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSString)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *NSString) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *NSMutableArray) DescriptionWithLocaleIndent(locale NSObject, level NSUInteger) *NSString {
	ret := &NSString{}
	ret.ptr = unsafe.Pointer(C.NSMutableArray_inst_DescriptionWithLocaleIndent(o.Ptr(), locale.Ptr(), (C.NSUInteger)(level)))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSString)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *NSString) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *NSMutableArray) IsEqualTo(object NSObject) bool {
	ret := (bool)(C.NSMutableArray_inst_IsEqualTo(o.Ptr(), object.Ptr()))
	runtime.KeepAlive(o)
	return ret
}

func (o *NSMutableArray) SetObservationInfo(observationInfo unsafe.Pointer)  {
	C.NSMutableArray_inst_SetObservationInfo(o.Ptr(), unsafe.Pointer(observationInfo))
	runtime.KeepAlive(o)
}

func (o *NSMutableArray) ObjectAtIndex(index NSUInteger) *Id {
	ret := &Id{}
	ret.ptr = unsafe.Pointer(C.NSMutableArray_inst_ObjectAtIndex(o.Ptr(), (C.NSUInteger)(index)))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *Id) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *NSMutableArray) AwakeAfterUsingCoder(coder *NSCoder) *Id {
	ret := &Id{}
	ret.ptr = unsafe.Pointer(C.NSMutableArray_inst_AwakeAfterUsingCoder(o.Ptr(), coder.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *Id) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *NSMutableArray) RemoveObjectsInArray(otherArray *NSArray)  {
	C.NSMutableArray_inst_RemoveObjectsInArray(o.Ptr(), otherArray.Ptr())
	runtime.KeepAlive(o)
}

func (o *NSMutableArray) InsertObjectAtIndex(anObject NSObject, index NSUInteger)  {
	C.NSMutableArray_inst_InsertObjectAtIndex(o.Ptr(), anObject.Ptr(), (C.NSUInteger)(index))
	runtime.KeepAlive(o)
}

func (o *NSMutableArray) AddObject(anObject NSObject)  {
	C.NSMutableArray_inst_AddObject(o.Ptr(), anObject.Ptr())
	runtime.KeepAlive(o)
}

func (o *NSMutableArray) ScriptingContains(object NSObject) bool {
	ret := (bool)(C.NSMutableArray_inst_ScriptingContains(o.Ptr(), object.Ptr()))
	runtime.KeepAlive(o)
	return ret
}

func (o *NSMutableArray) AutoContentAccessingProxy() *Id {
	ret := &Id{}
	ret.ptr = unsafe.Pointer(C.NSMutableArray_inst_AutoContentAccessingProxy(o.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *Id) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *NSMutableArray) CoerceValueForKey(value NSObject, key *NSString) *Id {
	ret := &Id{}
	ret.ptr = unsafe.Pointer(C.NSMutableArray_inst_CoerceValueForKey(o.Ptr(), value.Ptr(), key.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *Id) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *NSMutableArray) ObjectAtIndexedSubscript(idx NSUInteger) *Id {
	ret := &Id{}
	ret.ptr = unsafe.Pointer(C.NSMutableArray_inst_ObjectAtIndexedSubscript(o.Ptr(), (C.NSUInteger)(idx)))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *Id) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *NSMutableArray) ScriptingValueForSpecifier(objectSpecifier *NSScriptObjectSpecifier) *Id {
	ret := &Id{}
	ret.ptr = unsafe.Pointer(C.NSMutableArray_inst_ScriptingValueForSpecifier(o.Ptr(), objectSpecifier.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *Id) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *NSMutableArray) IsGreaterThan(object NSObject) bool {
	ret := (bool)(C.NSMutableArray_inst_IsGreaterThan(o.Ptr(), object.Ptr()))
	runtime.KeepAlive(o)
	return ret
}

func (o *NSMutableArray) ScriptingIsGreaterThanOrEqualTo(object NSObject) bool {
	ret := (bool)(C.NSMutableArray_inst_ScriptingIsGreaterThanOrEqualTo(o.Ptr(), object.Ptr()))
	runtime.KeepAlive(o)
	return ret
}

func (o *NSMutableArray) ForwardInvocation(anInvocation *NSInvocation)  {
	C.NSMutableArray_inst_ForwardInvocation(o.Ptr(), anInvocation.Ptr())
	runtime.KeepAlive(o)
}

func (o *NSMutableArray) InitWithObjects(firstObj NSObject) *NSMutableArray {
	ret := &NSMutableArray{}
	ret.ptr = unsafe.Pointer(C.NSMutableArray_inst_InitWithObjects(o.Ptr(), firstObj.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSMutableArray)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *NSMutableArray) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *NSMutableArray) InitWithObjectsCount(objects *[]*Id, cnt NSUInteger) *NSMutableArray {

	goSlice1 := make([]unsafe.Pointer,cap(*objects))
	for i := 0; i < len(*objects); i++ {
		goSlice1[i] = (*objects)[i].Ptr()
	}
	ret := &NSMutableArray{}
	ret.ptr = unsafe.Pointer(C.NSMutableArray_inst_InitWithObjectsCount(o.Ptr(), (*unsafe.Pointer)(unsafe.Pointer(&goSlice1[0])), (C.NSUInteger)(cnt)))
	(*objects) = (*objects)[:cap(*objects)]
	for i := 0; i < len(*objects); i++ {
		if goSlice1[i] == nil {
			(*objects) = (*objects)[:i]
			break
		}
		if (*objects)[i] == nil {
			(*objects)[i] = &Id{}
			runtime.SetFinalizer((*objects)[i], func(o *Id) {
				o.Release()
			})
		}
		(*objects)[i].ptr = goSlice1[i]
	}
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSMutableArray)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *NSMutableArray) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *NSMutableArray) PerformSelectorInBackgroundWithObject(aSelector SEL, arg NSObject)  {
	C.NSMutableArray_inst_PerformSelectorInBackgroundWithObject(o.Ptr(), unsafe.Pointer(aSelector), arg.Ptr())
	runtime.KeepAlive(o)
}

func (o *NSMutableArray) PerformSelectorOnMainThreadWithObject(aSelector SEL, arg NSObject, wait BOOL)  {
	C.NSMutableArray_inst_PerformSelectorOnMainThreadWithObject(o.Ptr(), unsafe.Pointer(aSelector), arg.Ptr(), (C.BOOL)(wait))
	runtime.KeepAlive(o)
}

func (o *NSMutableArray) PerformSelectorOnMainThreadWithObjectWaitUntilDone(aSelector SEL, arg NSObject, wait BOOL)  {
	C.NSMutableArray_inst_PerformSelectorOnMainThreadWithObjectWaitUntilDone(o.Ptr(), unsafe.Pointer(aSelector), arg.Ptr(), (C.BOOL)(wait))
	runtime.KeepAlive(o)
}

func (o *NSMutableArray) PerformSelectorOnMainThreadWithObjectWaitUntilDoneModes(aSelector SEL, arg NSObject, wait BOOL, array *NSArray)  {
	C.NSMutableArray_inst_PerformSelectorOnMainThreadWithObjectWaitUntilDoneModes(o.Ptr(), unsafe.Pointer(aSelector), arg.Ptr(), (C.BOOL)(wait), array.Ptr())
	runtime.KeepAlive(o)
}

func (o *NSMutableArray) MutableArrayValueForKeyPath(keyPath *NSString) *NSMutableArray {
	ret := &NSMutableArray{}
	ret.ptr = unsafe.Pointer(C.NSMutableArray_inst_MutableArrayValueForKeyPath(o.Ptr(), keyPath.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSMutableArray)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *NSMutableArray) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *NSMutableArray) ObjectsAtIndexes(indexes *NSIndexSet) *NSArray {
	ret := &NSArray{}
	ret.ptr = unsafe.Pointer(C.NSMutableArray_inst_ObjectsAtIndexes(o.Ptr(), indexes.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSArray)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *NSArray) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *NSMutableArray) IsLessThan(object NSObject) bool {
	ret := (bool)(C.NSMutableArray_inst_IsLessThan(o.Ptr(), object.Ptr()))
	runtime.KeepAlive(o)
	return ret
}

func (o *NSMutableArray) InitWithContentsOfFile(path *NSString) *NSMutableArray {
	ret := &NSMutableArray{}
	ret.ptr = unsafe.Pointer(C.NSMutableArray_inst_InitWithContentsOfFile(o.Ptr(), path.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSMutableArray)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *NSMutableArray) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *NSMutableArray) RemoveObjectsAtIndexes(indexes *NSIndexSet)  {
	C.NSMutableArray_inst_RemoveObjectsAtIndexes(o.Ptr(), indexes.Ptr())
	runtime.KeepAlive(o)
}

func (o *NSMutableArray) SetValueForKey(value NSObject, key *NSString)  {
	C.NSMutableArray_inst_SetValueForKey(o.Ptr(), value.Ptr(), key.Ptr())
	runtime.KeepAlive(o)
}

func (o *NSMutableArray) SetValueForKeyPath(value NSObject, keyPath *NSString)  {
	C.NSMutableArray_inst_SetValueForKeyPath(o.Ptr(), value.Ptr(), keyPath.Ptr())
	runtime.KeepAlive(o)
}

func (o *NSMutableArray) SetValueForUndefinedKey(value NSObject, key *NSString)  {
	C.NSMutableArray_inst_SetValueForUndefinedKey(o.Ptr(), value.Ptr(), key.Ptr())
	runtime.KeepAlive(o)
}

func (o *NSMutableArray) ReplacementObjectForKeyedArchiver(archiver *NSKeyedArchiver) *Id {
	ret := &Id{}
	ret.ptr = unsafe.Pointer(C.NSMutableArray_inst_ReplacementObjectForKeyedArchiver(o.Ptr(), archiver.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *Id) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *NSMutableArray) AddObserverForKeyPath(observer NSObject, keyPath *NSString, options NSKeyValueObservingOptions, context unsafe.Pointer)  {
	C.NSMutableArray_inst_AddObserverForKeyPath(o.Ptr(), observer.Ptr(), keyPath.Ptr(), (C.NSKeyValueObservingOptions)(options), unsafe.Pointer(context))
	runtime.KeepAlive(o)
}

func (o *NSMutableArray) AddObserverForKeyPathOptions(observer NSObject, keyPath *NSString, options NSKeyValueObservingOptions, context unsafe.Pointer)  {
	C.NSMutableArray_inst_AddObserverForKeyPathOptions(o.Ptr(), observer.Ptr(), keyPath.Ptr(), (C.NSKeyValueObservingOptions)(options), unsafe.Pointer(context))
	runtime.KeepAlive(o)
}

func (o *NSMutableArray) AddObserverForKeyPathOptionsContext(observer NSObject, keyPath *NSString, options NSKeyValueObservingOptions, context unsafe.Pointer)  {
	C.NSMutableArray_inst_AddObserverForKeyPathOptionsContext(o.Ptr(), observer.Ptr(), keyPath.Ptr(), (C.NSKeyValueObservingOptions)(options), unsafe.Pointer(context))
	runtime.KeepAlive(o)
}

func (o *NSMutableArray) AddObserverToObjectsAtIndexes(observer NSObject, indexes *NSIndexSet, keyPath *NSString, options NSKeyValueObservingOptions, context unsafe.Pointer)  {
	C.NSMutableArray_inst_AddObserverToObjectsAtIndexes(o.Ptr(), observer.Ptr(), indexes.Ptr(), keyPath.Ptr(), (C.NSKeyValueObservingOptions)(options), unsafe.Pointer(context))
	runtime.KeepAlive(o)
}

func (o *NSMutableArray) AddObserverToObjectsAtIndexesForKeyPath(observer NSObject, indexes *NSIndexSet, keyPath *NSString, options NSKeyValueObservingOptions, context unsafe.Pointer)  {
	C.NSMutableArray_inst_AddObserverToObjectsAtIndexesForKeyPath(o.Ptr(), observer.Ptr(), indexes.Ptr(), keyPath.Ptr(), (C.NSKeyValueObservingOptions)(options), unsafe.Pointer(context))
	runtime.KeepAlive(o)
}

func (o *NSMutableArray) SortUsingSelector(comparator SEL)  {
	C.NSMutableArray_inst_SortUsingSelector(o.Ptr(), unsafe.Pointer(comparator))
	runtime.KeepAlive(o)
}

func (o *NSMutableArray) RemoveLastObject()  {
	C.NSMutableArray_inst_RemoveLastObject(o.Ptr())
	runtime.KeepAlive(o)
}

func (o *NSMutableArray) SortedArrayUsingDescriptors(sortDescriptors *NSArray) *NSArray {
	ret := &NSArray{}
	ret.ptr = unsafe.Pointer(C.NSMutableArray_inst_SortedArrayUsingDescriptors(o.Ptr(), sortDescriptors.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSArray)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *NSArray) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *NSMutableArray) ScriptingIsGreaterThan(object NSObject) bool {
	ret := (bool)(C.NSMutableArray_inst_ScriptingIsGreaterThan(o.Ptr(), object.Ptr()))
	runtime.KeepAlive(o)
	return ret
}

func (o *NSMutableArray) PathsMatchingExtensions(filterTypes *NSArray) *NSArray {
	ret := &NSArray{}
	ret.ptr = unsafe.Pointer(C.NSMutableArray_inst_PathsMatchingExtensions(o.Ptr(), filterTypes.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSArray)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *NSArray) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *NSMutableArray) WillChangeValueForKey(key *NSString)  {
	C.NSMutableArray_inst_WillChangeValueForKey(o.Ptr(), key.Ptr())
	runtime.KeepAlive(o)
}

func (o *NSMutableArray) WillChangeValueForKeyWithSetMutation(key *NSString, mutationKind NSKeyValueSetMutationKind, objects *NSSet)  {
	C.NSMutableArray_inst_WillChangeValueForKeyWithSetMutation(o.Ptr(), key.Ptr(), (C.NSKeyValueSetMutationKind)(mutationKind), objects.Ptr())
	runtime.KeepAlive(o)
}

func (o *NSMutableArray) WillChangeValueForKeyWithSetMutationUsingObjects(key *NSString, mutationKind NSKeyValueSetMutationKind, objects *NSSet)  {
	C.NSMutableArray_inst_WillChangeValueForKeyWithSetMutationUsingObjects(o.Ptr(), key.Ptr(), (C.NSKeyValueSetMutationKind)(mutationKind), objects.Ptr())
	runtime.KeepAlive(o)
}

func (o *NSMutableArray) RemoveValueAtIndexFromPropertyWithKey(index NSUInteger, key *NSString)  {
	C.NSMutableArray_inst_RemoveValueAtIndexFromPropertyWithKey(o.Ptr(), (C.NSUInteger)(index), key.Ptr())
	runtime.KeepAlive(o)
}

func (o *NSMutableArray) WillChangeValuesAtIndexes(changeKind NSKeyValueChange, indexes *NSIndexSet, key *NSString)  {
	C.NSMutableArray_inst_WillChangeValuesAtIndexes(o.Ptr(), (C.NSKeyValueChange)(changeKind), indexes.Ptr(), key.Ptr())
	runtime.KeepAlive(o)
}

func (o *NSMutableArray) WillChangeValuesAtIndexesForKey(changeKind NSKeyValueChange, indexes *NSIndexSet, key *NSString)  {
	C.NSMutableArray_inst_WillChangeValuesAtIndexesForKey(o.Ptr(), (C.NSKeyValueChange)(changeKind), indexes.Ptr(), key.Ptr())
	runtime.KeepAlive(o)
}

func (o *NSMutableArray) ScriptingEndsWith(object NSObject) bool {
	ret := (bool)(C.NSMutableArray_inst_ScriptingEndsWith(o.Ptr(), object.Ptr()))
	runtime.KeepAlive(o)
	return ret
}

func (o *NSMutableArray) InitWithContentsOfURL(url *NSURL) *NSMutableArray {
	ret := &NSMutableArray{}
	ret.ptr = unsafe.Pointer(C.NSMutableArray_inst_InitWithContentsOfURL(o.Ptr(), url.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSMutableArray)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *NSMutableArray) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *NSMutableArray) InitWithContentsOfURLError(url *NSURL, error *[]*NSError) *NSArray {

	goSlice2 := make([]unsafe.Pointer,cap(*error))
	for i := 0; i < len(*error); i++ {
		goSlice2[i] = (*error)[i].Ptr()
	}
	ret := &NSArray{}
	ret.ptr = unsafe.Pointer(C.NSMutableArray_inst_InitWithContentsOfURLError(o.Ptr(), url.Ptr(), (*unsafe.Pointer)(unsafe.Pointer(&goSlice2[0]))))
	(*error) = (*error)[:cap(*error)]
	for i := 0; i < len(*error); i++ {
		if goSlice2[i] == nil {
			(*error) = (*error)[:i]
			break
		}
		if (*error)[i] == nil {
			(*error)[i] = &NSError{}
			runtime.SetFinalizer((*error)[i], func(o *NSError) {
				o.Release()
			})
		}
		(*error)[i].ptr = goSlice2[i]
	}
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSArray)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *NSArray) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *NSMutableArray) IndexOfObject(anObject NSObject) NSUInteger {
	ret := (NSUInteger)(C.NSMutableArray_inst_IndexOfObject(o.Ptr(), anObject.Ptr()))
	runtime.KeepAlive(o)
	return ret
}

func (o *NSMutableArray) IndexOfObjectInRange(anObject NSObject, range_ NSRange) NSUInteger {
	ret := (NSUInteger)(C.NSMutableArray_inst_IndexOfObjectInRange(o.Ptr(), anObject.Ptr(), (C.NSRange)(range_)))
	runtime.KeepAlive(o)
	return ret
}

func (o *NSMutableArray) MutableCopyWithZone(zone *NSZone) *Id {
	ret := &Id{}
	ret.ptr = unsafe.Pointer(C.NSMutableArray_inst_MutableCopyWithZone(o.Ptr(), unsafe.Pointer(zone)))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *Id) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *NSMutableArray) IsNotEqualTo(object NSObject) bool {
	ret := (bool)(C.NSMutableArray_inst_IsNotEqualTo(o.Ptr(), object.Ptr()))
	runtime.KeepAlive(o)
	return ret
}

func (o *NSMutableArray) ReplaceValueAtIndexInPropertyWithKey(index NSUInteger, key *NSString, value NSObject)  {
	C.NSMutableArray_inst_ReplaceValueAtIndexInPropertyWithKey(o.Ptr(), (C.NSUInteger)(index), key.Ptr(), value.Ptr())
	runtime.KeepAlive(o)
}

func (o *NSMutableArray) ReplaceValueAtIndexInPropertyWithKeyWithValue(index NSUInteger, key *NSString, value NSObject)  {
	C.NSMutableArray_inst_ReplaceValueAtIndexInPropertyWithKeyWithValue(o.Ptr(), (C.NSUInteger)(index), key.Ptr(), value.Ptr())
	runtime.KeepAlive(o)
}

func (o *NSMutableArray) SetValuesForKeysWithDictionary(keyedValues *NSDictionary)  {
	C.NSMutableArray_inst_SetValuesForKeysWithDictionary(o.Ptr(), keyedValues.Ptr())
	runtime.KeepAlive(o)
}

func (o *NSMutableArray) MutableSetValueForKey(key *NSString) *NSMutableSet {
	ret := &NSMutableSet{}
	ret.ptr = unsafe.Pointer(C.NSMutableArray_inst_MutableSetValueForKey(o.Ptr(), key.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSMutableSet)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *NSMutableSet) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *NSMutableArray) ScriptingIsLessThan(object NSObject) bool {
	ret := (bool)(C.NSMutableArray_inst_ScriptingIsLessThan(o.Ptr(), object.Ptr()))
	runtime.KeepAlive(o)
	return ret
}

func (o *NSMutableArray) ValueWithUniqueIDInPropertyWithKey(uniqueID NSObject, key *NSString) *Id {
	ret := &Id{}
	ret.ptr = unsafe.Pointer(C.NSMutableArray_inst_ValueWithUniqueIDInPropertyWithKey(o.Ptr(), uniqueID.Ptr(), key.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *Id) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *NSMutableArray) IsGreaterThanOrEqualTo(object NSObject) bool {
	ret := (bool)(C.NSMutableArray_inst_IsGreaterThanOrEqualTo(o.Ptr(), object.Ptr()))
	runtime.KeepAlive(o)
	return ret
}

func (o *NSMutableArray) InitWithCapacity(numItems NSUInteger) *NSMutableArray {
	ret := &NSMutableArray{}
	ret.ptr = unsafe.Pointer(C.NSMutableArray_inst_InitWithCapacity(o.Ptr(), (C.NSUInteger)(numItems)))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSMutableArray)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *NSMutableArray) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *NSMutableArray) MutableOrderedSetValueForKeyPath(keyPath *NSString) *NSMutableOrderedSet {
	ret := &NSMutableOrderedSet{}
	ret.ptr = unsafe.Pointer(C.NSMutableArray_inst_MutableOrderedSetValueForKeyPath(o.Ptr(), keyPath.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSMutableOrderedSet)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *NSMutableOrderedSet) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *NSMutableArray) ClassForCoder() Class {
	ret := (Class)(unsafe.Pointer(C.NSMutableArray_inst_ClassForCoder(o.Ptr())))
	runtime.KeepAlive(o)
	return ret
}

func (o *NSMutableArray) ArrayByApplyingDifference(difference *NSOrderedCollectionDifference) *NSArray {
	ret := &NSArray{}
	ret.ptr = unsafe.Pointer(C.NSMutableArray_inst_ArrayByApplyingDifference(o.Ptr(), difference.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSArray)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *NSArray) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *NSMutableArray) FilteredArrayUsingPredicate(predicate *NSPredicate) *NSArray {
	ret := &NSArray{}
	ret.ptr = unsafe.Pointer(C.NSMutableArray_inst_FilteredArrayUsingPredicate(o.Ptr(), predicate.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSArray)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *NSArray) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *NSMutableArray) ValueForUndefinedKey(key *NSString) *Id {
	ret := &Id{}
	ret.ptr = unsafe.Pointer(C.NSMutableArray_inst_ValueForUndefinedKey(o.Ptr(), key.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *Id) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *NSMutableArray) ClassDescription() *NSClassDescription {
	ret := &NSClassDescription{}
	ret.ptr = unsafe.Pointer(C.NSMutableArray_inst_ClassDescription(o.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSClassDescription)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *NSClassDescription) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *NSMutableArray) ReplaceObjectAtIndexWithObject(index NSUInteger, anObject NSObject)  {
	C.NSMutableArray_inst_ReplaceObjectAtIndexWithObject(o.Ptr(), (C.NSUInteger)(index), anObject.Ptr())
	runtime.KeepAlive(o)
}

func (o *NSMutableArray) RemoveObjectIdenticalTo(anObject NSObject)  {
	C.NSMutableArray_inst_RemoveObjectIdenticalTo(o.Ptr(), anObject.Ptr())
	runtime.KeepAlive(o)
}

func (o *NSMutableArray) RemoveObjectIdenticalToInRange(anObject NSObject, range_ NSRange)  {
	C.NSMutableArray_inst_RemoveObjectIdenticalToInRange(o.Ptr(), anObject.Ptr(), (C.NSRange)(range_))
	runtime.KeepAlive(o)
}

func (o *NSMutableArray) DoesContain(object NSObject) bool {
	ret := (bool)(C.NSMutableArray_inst_DoesContain(o.Ptr(), object.Ptr()))
	runtime.KeepAlive(o)
	return ret
}

func (o *NSMutableArray) ClassName() *NSString {
	ret := &NSString{}
	ret.ptr = unsafe.Pointer(C.NSMutableArray_inst_ClassName(o.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSString)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *NSString) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *NSMutableArray) Copy() *Id {
	ret := &Id{}
	ret.ptr = unsafe.Pointer(C.NSMutableArray_inst_Copy(o.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	runtime.SetFinalizer(ret, func(o *Id) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *NSMutableArray) RemoveAllObjects()  {
	C.NSMutableArray_inst_RemoveAllObjects(o.Ptr())
	runtime.KeepAlive(o)
}

func (o *NSMutableArray) SetObjectAtIndexedSubscript(obj NSObject, idx NSUInteger)  {
	C.NSMutableArray_inst_SetObjectAtIndexedSubscript(o.Ptr(), obj.Ptr(), (C.NSUInteger)(idx))
	runtime.KeepAlive(o)
}

func (o *NSMutableArray) ToManyRelationshipKeys() *NSArray {
	ret := &NSArray{}
	ret.ptr = unsafe.Pointer(C.NSMutableArray_inst_ToManyRelationshipKeys(o.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSArray)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *NSArray) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *NSMutableArray) ClassCode() FourCharCode {
	ret := (FourCharCode)(C.NSMutableArray_inst_ClassCode(o.Ptr()))
	runtime.KeepAlive(o)
	return ret
}

func (o *NSMutableArray) GetObjectsRange(objects *[]*Id, range_ NSRange)  {

	goSlice1 := make([]unsafe.Pointer,cap(*objects))
	for i := 0; i < len(*objects); i++ {
		goSlice1[i] = (*objects)[i].Ptr()
	}
	C.NSMutableArray_inst_GetObjectsRange(o.Ptr(), (*unsafe.Pointer)(unsafe.Pointer(&goSlice1[0])), (C.NSRange)(range_))
	(*objects) = (*objects)[:cap(*objects)]
	for i := 0; i < len(*objects); i++ {
		if goSlice1[i] == nil {
			(*objects) = (*objects)[:i]
			break
		}
		if (*objects)[i] == nil {
			(*objects)[i] = &Id{}
			runtime.SetFinalizer((*objects)[i], func(o *Id) {
				o.Release()
			})
		}
		(*objects)[i].ptr = goSlice1[i]
	}
	runtime.KeepAlive(o)
}

func (o *NSMutableArray) RemoveObserverForKeyPath(observer NSObject, keyPath *NSString)  {
	C.NSMutableArray_inst_RemoveObserverForKeyPath(o.Ptr(), observer.Ptr(), keyPath.Ptr())
	runtime.KeepAlive(o)
}

func (o *NSMutableArray) RemoveObserverForKeyPathContext(observer NSObject, keyPath *NSString, context unsafe.Pointer)  {
	C.NSMutableArray_inst_RemoveObserverForKeyPathContext(o.Ptr(), observer.Ptr(), keyPath.Ptr(), unsafe.Pointer(context))
	runtime.KeepAlive(o)
}

func (o *NSMutableArray) RemoveObserverFromObjectsAtIndexes(observer NSObject, indexes *NSIndexSet, keyPath *NSString)  {
	C.NSMutableArray_inst_RemoveObserverFromObjectsAtIndexes(o.Ptr(), observer.Ptr(), indexes.Ptr(), keyPath.Ptr())
	runtime.KeepAlive(o)
}

func (o *NSMutableArray) RemoveObserverFromObjectsAtIndexesForKeyPath(observer NSObject, indexes *NSIndexSet, keyPath *NSString)  {
	C.NSMutableArray_inst_RemoveObserverFromObjectsAtIndexesForKeyPath(o.Ptr(), observer.Ptr(), indexes.Ptr(), keyPath.Ptr())
	runtime.KeepAlive(o)
}

func (o *NSMutableArray) RemoveObserverFromObjectsAtIndexesForKeyPathContext(observer NSObject, indexes *NSIndexSet, keyPath *NSString, context unsafe.Pointer)  {
	C.NSMutableArray_inst_RemoveObserverFromObjectsAtIndexesForKeyPathContext(o.Ptr(), observer.Ptr(), indexes.Ptr(), keyPath.Ptr(), unsafe.Pointer(context))
	runtime.KeepAlive(o)
}

func (o *NSMutableArray) LastObject() *Id {
	ret := &Id{}
	ret.ptr = unsafe.Pointer(C.NSMutableArray_inst_LastObject(o.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *Id) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *NSMutableArray) NewScriptingObjectOfClassForValueForKey(objectClass Class, key *NSString, contentsValue NSObject, properties *NSDictionary) *Id {
	ret := &Id{}
	ret.ptr = unsafe.Pointer(C.NSMutableArray_inst_NewScriptingObjectOfClassForValueForKey(o.Ptr(), unsafe.Pointer(objectClass), key.Ptr(), contentsValue.Ptr(), properties.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *Id) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *NSMutableArray) NewScriptingObjectOfClassForValueForKeyWithContentsValue(objectClass Class, key *NSString, contentsValue NSObject, properties *NSDictionary) *Id {
	ret := &Id{}
	ret.ptr = unsafe.Pointer(C.NSMutableArray_inst_NewScriptingObjectOfClassForValueForKeyWithContentsValue(o.Ptr(), unsafe.Pointer(objectClass), key.Ptr(), contentsValue.Ptr(), properties.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *Id) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *NSMutableArray) NewScriptingObjectOfClassForValueForKeyWithContentsValueProperties(objectClass Class, key *NSString, contentsValue NSObject, properties *NSDictionary) *Id {
	ret := &Id{}
	ret.ptr = unsafe.Pointer(C.NSMutableArray_inst_NewScriptingObjectOfClassForValueForKeyWithContentsValueProperties(o.Ptr(), unsafe.Pointer(objectClass), key.Ptr(), contentsValue.Ptr(), properties.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *Id) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *NSMutableArray) RemoveObjectsInRange(range_ NSRange)  {
	C.NSMutableArray_inst_RemoveObjectsInRange(o.Ptr(), (C.NSRange)(range_))
	runtime.KeepAlive(o)
}

func (o *NSMutableArray) IsLike(object *NSString) bool {
	ret := (bool)(C.NSMutableArray_inst_IsLike(o.Ptr(), object.Ptr()))
	runtime.KeepAlive(o)
	return ret
}

func (o *NSMutableArray) IsEqualToArray(otherArray *NSArray) bool {
	ret := (bool)(C.NSMutableArray_inst_IsEqualToArray(o.Ptr(), otherArray.Ptr()))
	runtime.KeepAlive(o)
	return ret
}

func (o *NSMutableArray) MakeObjectsPerformSelector(aSelector SEL)  {
	C.NSMutableArray_inst_MakeObjectsPerformSelector(o.Ptr(), unsafe.Pointer(aSelector))
	runtime.KeepAlive(o)
}

func (o *NSMutableArray) MakeObjectsPerformSelectorWithObject(aSelector SEL, argument NSObject)  {
	C.NSMutableArray_inst_MakeObjectsPerformSelectorWithObject(o.Ptr(), unsafe.Pointer(aSelector), argument.Ptr())
	runtime.KeepAlive(o)
}

func (o *NSMutableArray) ToOneRelationshipKeys() *NSArray {
	ret := &NSArray{}
	ret.ptr = unsafe.Pointer(C.NSMutableArray_inst_ToOneRelationshipKeys(o.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSArray)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *NSArray) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *NSMutableArray) ClassForArchiver() Class {
	ret := (Class)(unsafe.Pointer(C.NSMutableArray_inst_ClassForArchiver(o.Ptr())))
	runtime.KeepAlive(o)
	return ret
}

func (o *NSMutableArray) ReplaceObjectsAtIndexesWithObjects(indexes *NSIndexSet, objects *NSArray)  {
	C.NSMutableArray_inst_ReplaceObjectsAtIndexesWithObjects(o.Ptr(), indexes.Ptr(), objects.Ptr())
	runtime.KeepAlive(o)
}

func (o *NSMutableArray) RemoveObject(anObject NSObject)  {
	C.NSMutableArray_inst_RemoveObject(o.Ptr(), anObject.Ptr())
	runtime.KeepAlive(o)
}

func (o *NSMutableArray) RemoveObjectInRange(anObject NSObject, range_ NSRange)  {
	C.NSMutableArray_inst_RemoveObjectInRange(o.Ptr(), anObject.Ptr(), (C.NSRange)(range_))
	runtime.KeepAlive(o)
}

func (o *NSMutableArray) ValidateValueForKey(ioValue *[]*Id, inKey *NSString, outError *[]*NSError) bool {

	goSlice1 := make([]unsafe.Pointer,cap(*ioValue))
	for i := 0; i < len(*ioValue); i++ {
		goSlice1[i] = (*ioValue)[i].Ptr()
	}

	goSlice3 := make([]unsafe.Pointer,cap(*outError))
	for i := 0; i < len(*outError); i++ {
		goSlice3[i] = (*outError)[i].Ptr()
	}
	ret := (bool)(C.NSMutableArray_inst_ValidateValueForKey(o.Ptr(), (*unsafe.Pointer)(unsafe.Pointer(&goSlice1[0])), inKey.Ptr(), (*unsafe.Pointer)(unsafe.Pointer(&goSlice3[0]))))
	(*ioValue) = (*ioValue)[:cap(*ioValue)]
	for i := 0; i < len(*ioValue); i++ {
		if goSlice1[i] == nil {
			(*ioValue) = (*ioValue)[:i]
			break
		}
		if (*ioValue)[i] == nil {
			(*ioValue)[i] = &Id{}
			runtime.SetFinalizer((*ioValue)[i], func(o *Id) {
				o.Release()
			})
		}
		(*ioValue)[i].ptr = goSlice1[i]
	}
	(*outError) = (*outError)[:cap(*outError)]
	for i := 0; i < len(*outError); i++ {
		if goSlice3[i] == nil {
			(*outError) = (*outError)[:i]
			break
		}
		if (*outError)[i] == nil {
			(*outError)[i] = &NSError{}
			runtime.SetFinalizer((*outError)[i], func(o *NSError) {
				o.Release()
			})
		}
		(*outError)[i].ptr = goSlice3[i]
	}
	runtime.KeepAlive(o)
	return ret
}

func (o *NSMutableArray) ValidateValueForKeyPath(ioValue *[]*Id, inKeyPath *NSString, outError *[]*NSError) bool {

	goSlice1 := make([]unsafe.Pointer,cap(*ioValue))
	for i := 0; i < len(*ioValue); i++ {
		goSlice1[i] = (*ioValue)[i].Ptr()
	}

	goSlice3 := make([]unsafe.Pointer,cap(*outError))
	for i := 0; i < len(*outError); i++ {
		goSlice3[i] = (*outError)[i].Ptr()
	}
	ret := (bool)(C.NSMutableArray_inst_ValidateValueForKeyPath(o.Ptr(), (*unsafe.Pointer)(unsafe.Pointer(&goSlice1[0])), inKeyPath.Ptr(), (*unsafe.Pointer)(unsafe.Pointer(&goSlice3[0]))))
	(*ioValue) = (*ioValue)[:cap(*ioValue)]
	for i := 0; i < len(*ioValue); i++ {
		if goSlice1[i] == nil {
			(*ioValue) = (*ioValue)[:i]
			break
		}
		if (*ioValue)[i] == nil {
			(*ioValue)[i] = &Id{}
			runtime.SetFinalizer((*ioValue)[i], func(o *Id) {
				o.Release()
			})
		}
		(*ioValue)[i].ptr = goSlice1[i]
	}
	(*outError) = (*outError)[:cap(*outError)]
	for i := 0; i < len(*outError); i++ {
		if goSlice3[i] == nil {
			(*outError) = (*outError)[:i]
			break
		}
		if (*outError)[i] == nil {
			(*outError)[i] = &NSError{}
			runtime.SetFinalizer((*outError)[i], func(o *NSError) {
				o.Release()
			})
		}
		(*outError)[i].ptr = goSlice3[i]
	}
	runtime.KeepAlive(o)
	return ret
}

func (o *NSMutableArray) ValidateValueForKeyError(ioValue *[]*Id, inKey *NSString, outError *[]*NSError) bool {

	goSlice1 := make([]unsafe.Pointer,cap(*ioValue))
	for i := 0; i < len(*ioValue); i++ {
		goSlice1[i] = (*ioValue)[i].Ptr()
	}

	goSlice3 := make([]unsafe.Pointer,cap(*outError))
	for i := 0; i < len(*outError); i++ {
		goSlice3[i] = (*outError)[i].Ptr()
	}
	ret := (bool)(C.NSMutableArray_inst_ValidateValueForKeyError(o.Ptr(), (*unsafe.Pointer)(unsafe.Pointer(&goSlice1[0])), inKey.Ptr(), (*unsafe.Pointer)(unsafe.Pointer(&goSlice3[0]))))
	(*ioValue) = (*ioValue)[:cap(*ioValue)]
	for i := 0; i < len(*ioValue); i++ {
		if goSlice1[i] == nil {
			(*ioValue) = (*ioValue)[:i]
			break
		}
		if (*ioValue)[i] == nil {
			(*ioValue)[i] = &Id{}
			runtime.SetFinalizer((*ioValue)[i], func(o *Id) {
				o.Release()
			})
		}
		(*ioValue)[i].ptr = goSlice1[i]
	}
	(*outError) = (*outError)[:cap(*outError)]
	for i := 0; i < len(*outError); i++ {
		if goSlice3[i] == nil {
			(*outError) = (*outError)[:i]
			break
		}
		if (*outError)[i] == nil {
			(*outError)[i] = &NSError{}
			runtime.SetFinalizer((*outError)[i], func(o *NSError) {
				o.Release()
			})
		}
		(*outError)[i].ptr = goSlice3[i]
	}
	runtime.KeepAlive(o)
	return ret
}

func (o *NSMutableArray) ValidateValueForKeyPathError(ioValue *[]*Id, inKeyPath *NSString, outError *[]*NSError) bool {

	goSlice1 := make([]unsafe.Pointer,cap(*ioValue))
	for i := 0; i < len(*ioValue); i++ {
		goSlice1[i] = (*ioValue)[i].Ptr()
	}

	goSlice3 := make([]unsafe.Pointer,cap(*outError))
	for i := 0; i < len(*outError); i++ {
		goSlice3[i] = (*outError)[i].Ptr()
	}
	ret := (bool)(C.NSMutableArray_inst_ValidateValueForKeyPathError(o.Ptr(), (*unsafe.Pointer)(unsafe.Pointer(&goSlice1[0])), inKeyPath.Ptr(), (*unsafe.Pointer)(unsafe.Pointer(&goSlice3[0]))))
	(*ioValue) = (*ioValue)[:cap(*ioValue)]
	for i := 0; i < len(*ioValue); i++ {
		if goSlice1[i] == nil {
			(*ioValue) = (*ioValue)[:i]
			break
		}
		if (*ioValue)[i] == nil {
			(*ioValue)[i] = &Id{}
			runtime.SetFinalizer((*ioValue)[i], func(o *Id) {
				o.Release()
			})
		}
		(*ioValue)[i].ptr = goSlice1[i]
	}
	(*outError) = (*outError)[:cap(*outError)]
	for i := 0; i < len(*outError); i++ {
		if goSlice3[i] == nil {
			(*outError) = (*outError)[:i]
			break
		}
		if (*outError)[i] == nil {
			(*outError)[i] = &NSError{}
			runtime.SetFinalizer((*outError)[i], func(o *NSError) {
				o.Release()
			})
		}
		(*outError)[i].ptr = goSlice3[i]
	}
	runtime.KeepAlive(o)
	return ret
}

func (o *NSMutableArray) ObserveValueForKeyPathOfObject(keyPath *NSString, object NSObject, change *NSDictionary, context unsafe.Pointer)  {
	C.NSMutableArray_inst_ObserveValueForKeyPathOfObject(o.Ptr(), keyPath.Ptr(), object.Ptr(), change.Ptr(), unsafe.Pointer(context))
	runtime.KeepAlive(o)
}

func (o *NSMutableArray) ObserveValueForKeyPathOfObjectChange(keyPath *NSString, object NSObject, change *NSDictionary, context unsafe.Pointer)  {
	C.NSMutableArray_inst_ObserveValueForKeyPathOfObjectChange(o.Ptr(), keyPath.Ptr(), object.Ptr(), change.Ptr(), unsafe.Pointer(context))
	runtime.KeepAlive(o)
}

func (o *NSMutableArray) ObserveValueForKeyPathOfObjectChangeContext(keyPath *NSString, object NSObject, change *NSDictionary, context unsafe.Pointer)  {
	C.NSMutableArray_inst_ObserveValueForKeyPathOfObjectChangeContext(o.Ptr(), keyPath.Ptr(), object.Ptr(), change.Ptr(), unsafe.Pointer(context))
	runtime.KeepAlive(o)
}

func (o *NSMutableArray) ObservationInfo() unsafe.Pointer {
	ret := (unsafe.Pointer)(unsafe.Pointer(C.NSMutableArray_inst_ObservationInfo(o.Ptr())))
	runtime.KeepAlive(o)
	return ret
}

func (o *NSMutableArray) InsertValueInPropertyWithKey(value NSObject, key *NSString)  {
	C.NSMutableArray_inst_InsertValueInPropertyWithKey(o.Ptr(), value.Ptr(), key.Ptr())
	runtime.KeepAlive(o)
}

func (o *NSMutableArray) InsertValueAtIndex(value NSObject, index NSUInteger, key *NSString)  {
	C.NSMutableArray_inst_InsertValueAtIndex(o.Ptr(), value.Ptr(), (C.NSUInteger)(index), key.Ptr())
	runtime.KeepAlive(o)
}

func (o *NSMutableArray) InsertValueAtIndexInPropertyWithKey(value NSObject, index NSUInteger, key *NSString)  {
	C.NSMutableArray_inst_InsertValueAtIndexInPropertyWithKey(o.Ptr(), value.Ptr(), (C.NSUInteger)(index), key.Ptr())
	runtime.KeepAlive(o)
}

func (o *NSMutableArray) DoesNotRecognizeSelector(aSelector SEL)  {
	C.NSMutableArray_inst_DoesNotRecognizeSelector(o.Ptr(), unsafe.Pointer(aSelector))
	runtime.KeepAlive(o)
}

func (o *NSMutableArray) IsCaseInsensitiveLike(object *NSString) bool {
	ret := (bool)(C.NSMutableArray_inst_IsCaseInsensitiveLike(o.Ptr(), object.Ptr()))
	runtime.KeepAlive(o)
	return ret
}

func (o *NSMutableArray) AttemptRecoveryFromErrorOptionIndex(error *NSError, recoveryOptionIndex NSUInteger) bool {
	ret := (bool)(C.NSMutableArray_inst_AttemptRecoveryFromErrorOptionIndex(o.Ptr(), error.Ptr(), (C.NSUInteger)(recoveryOptionIndex)))
	runtime.KeepAlive(o)
	return ret
}

func (o *NSMutableArray) AttemptRecoveryFromErrorOptionIndexDelegate(error *NSError, recoveryOptionIndex NSUInteger, delegate NSObject, didRecoverSelector SEL, contextInfo unsafe.Pointer)  {
	C.NSMutableArray_inst_AttemptRecoveryFromErrorOptionIndexDelegate(o.Ptr(), error.Ptr(), (C.NSUInteger)(recoveryOptionIndex), delegate.Ptr(), unsafe.Pointer(didRecoverSelector), unsafe.Pointer(contextInfo))
	runtime.KeepAlive(o)
}

func (o *NSMutableArray) AttemptRecoveryFromErrorOptionIndexDelegateDidRecoverSelector(error *NSError, recoveryOptionIndex NSUInteger, delegate NSObject, didRecoverSelector SEL, contextInfo unsafe.Pointer)  {
	C.NSMutableArray_inst_AttemptRecoveryFromErrorOptionIndexDelegateDidRecoverSelector(o.Ptr(), error.Ptr(), (C.NSUInteger)(recoveryOptionIndex), delegate.Ptr(), unsafe.Pointer(didRecoverSelector), unsafe.Pointer(contextInfo))
	runtime.KeepAlive(o)
}

func (o *NSMutableArray) AttemptRecoveryFromErrorOptionIndexDelegateDidRecoverSelectorContextInfo(error *NSError, recoveryOptionIndex NSUInteger, delegate NSObject, didRecoverSelector SEL, contextInfo unsafe.Pointer)  {
	C.NSMutableArray_inst_AttemptRecoveryFromErrorOptionIndexDelegateDidRecoverSelectorContextInfo(o.Ptr(), error.Ptr(), (C.NSUInteger)(recoveryOptionIndex), delegate.Ptr(), unsafe.Pointer(didRecoverSelector), unsafe.Pointer(contextInfo))
	runtime.KeepAlive(o)
}

func (o *NSMutableArray) ObjectSpecifier() *NSScriptObjectSpecifier {
	ret := &NSScriptObjectSpecifier{}
	ret.ptr = unsafe.Pointer(C.NSMutableArray_inst_ObjectSpecifier(o.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSScriptObjectSpecifier)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *NSScriptObjectSpecifier) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *NSMutableArray) ScriptingIsEqualTo(object NSObject) bool {
	ret := (bool)(C.NSMutableArray_inst_ScriptingIsEqualTo(o.Ptr(), object.Ptr()))
	runtime.KeepAlive(o)
	return ret
}

func (o *NSMutableArray) WriteToURLError(url *NSURL, error *[]*NSError) bool {

	goSlice2 := make([]unsafe.Pointer,cap(*error))
	for i := 0; i < len(*error); i++ {
		goSlice2[i] = (*error)[i].Ptr()
	}
	ret := (bool)(C.NSMutableArray_inst_WriteToURLError(o.Ptr(), url.Ptr(), (*unsafe.Pointer)(unsafe.Pointer(&goSlice2[0]))))
	(*error) = (*error)[:cap(*error)]
	for i := 0; i < len(*error); i++ {
		if goSlice2[i] == nil {
			(*error) = (*error)[:i]
			break
		}
		if (*error)[i] == nil {
			(*error)[i] = &NSError{}
			runtime.SetFinalizer((*error)[i], func(o *NSError) {
				o.Release()
			})
		}
		(*error)[i].ptr = goSlice2[i]
	}
	runtime.KeepAlive(o)
	return ret
}

func (o *NSMutableArray) ScriptingIsLessThanOrEqualTo(object NSObject) bool {
	ret := (bool)(C.NSMutableArray_inst_ScriptingIsLessThanOrEqualTo(o.Ptr(), object.Ptr()))
	runtime.KeepAlive(o)
	return ret
}

func (o *NSMutableArray) DidChangeValueForKey(key *NSString)  {
	C.NSMutableArray_inst_DidChangeValueForKey(o.Ptr(), key.Ptr())
	runtime.KeepAlive(o)
}

func (o *NSMutableArray) DidChangeValueForKeyWithSetMutation(key *NSString, mutationKind NSKeyValueSetMutationKind, objects *NSSet)  {
	C.NSMutableArray_inst_DidChangeValueForKeyWithSetMutation(o.Ptr(), key.Ptr(), (C.NSKeyValueSetMutationKind)(mutationKind), objects.Ptr())
	runtime.KeepAlive(o)
}

func (o *NSMutableArray) DidChangeValueForKeyWithSetMutationUsingObjects(key *NSString, mutationKind NSKeyValueSetMutationKind, objects *NSSet)  {
	C.NSMutableArray_inst_DidChangeValueForKeyWithSetMutationUsingObjects(o.Ptr(), key.Ptr(), (C.NSKeyValueSetMutationKind)(mutationKind), objects.Ptr())
	runtime.KeepAlive(o)
}

func (o *NSMutableArray) SubarrayWithRange(range_ NSRange) *NSArray {
	ret := &NSArray{}
	ret.ptr = unsafe.Pointer(C.NSMutableArray_inst_SubarrayWithRange(o.Ptr(), (C.NSRange)(range_)))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSArray)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *NSArray) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *NSMutableArray) ValueWithNameInPropertyWithKey(name *NSString, key *NSString) *Id {
	ret := &Id{}
	ret.ptr = unsafe.Pointer(C.NSMutableArray_inst_ValueWithNameInPropertyWithKey(o.Ptr(), name.Ptr(), key.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *Id) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *NSMutableArray) SetArray(otherArray *NSArray)  {
	C.NSMutableArray_inst_SetArray(o.Ptr(), otherArray.Ptr())
	runtime.KeepAlive(o)
}

func (o *NSMutableArray) FirstObject() *Id {
	ret := &Id{}
	ret.ptr = unsafe.Pointer(C.NSMutableArray_inst_FirstObject(o.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *Id) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *NSMutableArray) InitWithCoder(coder *NSCoder) *NSMutableArray {
	ret := &NSMutableArray{}
	ret.ptr = unsafe.Pointer(C.NSMutableArray_inst_InitWithCoder(o.Ptr(), coder.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSMutableArray)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *NSMutableArray) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *NSMutableArray) ExchangeObjectAtIndexWithObjectAtIndex(idx1 NSUInteger, idx2 NSUInteger)  {
	C.NSMutableArray_inst_ExchangeObjectAtIndexWithObjectAtIndex(o.Ptr(), (C.NSUInteger)(idx1), (C.NSUInteger)(idx2))
	runtime.KeepAlive(o)
}

func (o *NSMutableArray) ReverseObjectEnumerator() *NSEnumerator {
	ret := &NSEnumerator{}
	ret.ptr = unsafe.Pointer(C.NSMutableArray_inst_ReverseObjectEnumerator(o.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSEnumerator)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *NSEnumerator) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *NSMutableArray) Description() *NSString {
	ret := &NSString{}
	ret.ptr = unsafe.Pointer(C.NSMutableArray_inst_Description(o.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSString)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *NSString) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *NSMutableArray) IndicesOfObjectsByEvaluatingObjectSpecifier(specifier *NSScriptObjectSpecifier) *NSArray {
	ret := &NSArray{}
	ret.ptr = unsafe.Pointer(C.NSMutableArray_inst_IndicesOfObjectsByEvaluatingObjectSpecifier(o.Ptr(), specifier.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSArray)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *NSArray) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *NSMutableArray) ScriptingBeginsWith(object NSObject) bool {
	ret := (bool)(C.NSMutableArray_inst_ScriptingBeginsWith(o.Ptr(), object.Ptr()))
	runtime.KeepAlive(o)
	return ret
}

func (o *NSMutableArray) InitWithArray(array *NSArray) *NSMutableArray {
	ret := &NSMutableArray{}
	ret.ptr = unsafe.Pointer(C.NSMutableArray_inst_InitWithArray(o.Ptr(), array.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSMutableArray)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *NSMutableArray) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *NSMutableArray) InitWithArrayCopyItems(array *NSArray, flag BOOL) *NSMutableArray {
	ret := &NSMutableArray{}
	ret.ptr = unsafe.Pointer(C.NSMutableArray_inst_InitWithArrayCopyItems(o.Ptr(), array.Ptr(), (C.BOOL)(flag)))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSMutableArray)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *NSMutableArray) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *NSMutableArray) ComponentsJoinedByString(separator *NSString) *NSString {
	ret := &NSString{}
	ret.ptr = unsafe.Pointer(C.NSMutableArray_inst_ComponentsJoinedByString(o.Ptr(), separator.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSString)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *NSString) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *NSMutableArray) ValueForKeyPath(keyPath *NSString) *Id {
	ret := &Id{}
	ret.ptr = unsafe.Pointer(C.NSMutableArray_inst_ValueForKeyPath(o.Ptr(), keyPath.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *Id) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *NSMutableArray) ArrayByAddingObject(anObject NSObject) *NSArray {
	ret := &NSArray{}
	ret.ptr = unsafe.Pointer(C.NSMutableArray_inst_ArrayByAddingObject(o.Ptr(), anObject.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSArray)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *NSArray) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *NSMutableArray) ScriptingProperties() *NSDictionary {
	ret := &NSDictionary{}
	ret.ptr = unsafe.Pointer(C.NSMutableArray_inst_ScriptingProperties(o.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSDictionary)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *NSDictionary) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *NSMutableArray) AddObjectsFromArray(otherArray *NSArray)  {
	C.NSMutableArray_inst_AddObjectsFromArray(o.Ptr(), otherArray.Ptr())
	runtime.KeepAlive(o)
}

func (o *NSMutableArray) InsertObjectsAtIndexes(objects *NSArray, indexes *NSIndexSet)  {
	C.NSMutableArray_inst_InsertObjectsAtIndexes(o.Ptr(), objects.Ptr(), indexes.Ptr())
	runtime.KeepAlive(o)
}

func (o *NSMutableArray) ApplyDifference(difference *NSOrderedCollectionDifference)  {
	C.NSMutableArray_inst_ApplyDifference(o.Ptr(), difference.Ptr())
	runtime.KeepAlive(o)
}

func (o *NSMutableArray) DifferenceFromArray(other *NSArray) *NSOrderedCollectionDifference {
	ret := &NSOrderedCollectionDifference{}
	ret.ptr = unsafe.Pointer(C.NSMutableArray_inst_DifferenceFromArray(o.Ptr(), other.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSOrderedCollectionDifference)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *NSOrderedCollectionDifference) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *NSMutableArray) DifferenceFromArrayWithOptions(other *NSArray, options NSOrderedCollectionDifferenceCalculationOptions) *NSOrderedCollectionDifference {
	ret := &NSOrderedCollectionDifference{}
	ret.ptr = unsafe.Pointer(C.NSMutableArray_inst_DifferenceFromArrayWithOptions(o.Ptr(), other.Ptr(), (C.NSOrderedCollectionDifferenceCalculationOptions)(options)))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSOrderedCollectionDifference)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *NSOrderedCollectionDifference) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *NSMutableArray) ForwardingTargetForSelector(aSelector SEL) *Id {
	ret := &Id{}
	ret.ptr = unsafe.Pointer(C.NSMutableArray_inst_ForwardingTargetForSelector(o.Ptr(), unsafe.Pointer(aSelector)))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *Id) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func NSEnumeratorCopyWithZone(zone *_NSZone) *Id {
	ret := &Id{}
	ret.ptr = unsafe.Pointer(C.NSEnumerator_CopyWithZone(unsafe.Pointer(zone)))
	if ret.ptr == nil { return ret }
	runtime.SetFinalizer(ret, func(o *Id) {
		o.Release()
	})
	return ret
}

func NSEnumeratorDebugDescription() *NSString {
	ret := &NSString{}
	ret.ptr = unsafe.Pointer(C.NSEnumerator_DebugDescription())
	if ret.ptr == nil { return ret }
	return ret
}

func NSEnumeratorClassFallbacksForKeyedArchiver() *NSArray {
	ret := &NSArray{}
	ret.ptr = unsafe.Pointer(C.NSEnumerator_ClassFallbacksForKeyedArchiver())
	if ret.ptr == nil { return ret }
	return ret
}

func NSEnumeratorHash() NSUInteger {
	ret := (NSUInteger)(C.NSEnumerator_Hash())
	return ret
}

func NSEnumeratorAutomaticallyNotifiesObserversForKey(key *NSString) bool {
	ret := (bool)(C.NSEnumerator_AutomaticallyNotifiesObserversForKey(key.Ptr()))
	return ret
}

func NSEnumeratorResolveInstanceMethod(sel SEL) bool {
	ret := (bool)(C.NSEnumerator_ResolveInstanceMethod(unsafe.Pointer(sel)))
	return ret
}

func NSEnumeratorIsSubclassOfClass(aClass Class) bool {
	ret := (bool)(C.NSEnumerator_IsSubclassOfClass(unsafe.Pointer(aClass)))
	return ret
}

func NSEnumeratorAlloc() *NSEnumerator {
	ret := &NSEnumerator{}
	ret.ptr = unsafe.Pointer(C.NSEnumerator_Alloc())
	if ret.ptr == nil { return ret }
	runtime.SetFinalizer(ret, func(o *NSEnumerator) {
		o.Release()
	})
	return ret
}

func (o *NSEnumerator) GC() {
	if o.ptr == nil { return }
	runtime.SetFinalizer(o, func(o *NSEnumerator) {
		o.Release()
	})
	runtime.KeepAlive(o)
}

func NSEnumeratorSetVersion(aVersion NSInteger)  {
	C.NSEnumerator_SetVersion((C.NSInteger)(aVersion))
}

func NSEnumeratorClass() Class {
	ret := (Class)(unsafe.Pointer(C.NSEnumerator_Class()))
	return ret
}

func NSEnumeratorSuperclass() Class {
	ret := (Class)(unsafe.Pointer(C.NSEnumerator_Superclass()))
	return ret
}

func NSEnumeratorConformsToProtocol(protocol Protocol) bool {
	ret := (bool)(C.NSEnumerator_ConformsToProtocol(protocol.Ptr()))
	return ret
}

func NSEnumeratorCancelPreviousPerformRequestsWithTarget(aTarget NSObject)  {
	C.NSEnumerator_CancelPreviousPerformRequestsWithTarget(aTarget.Ptr())
}

func NSEnumeratorCancelPreviousPerformRequestsWithTargetSelector(aTarget NSObject, aSelector SEL, anArgument NSObject)  {
	C.NSEnumerator_CancelPreviousPerformRequestsWithTargetSelector(aTarget.Ptr(), unsafe.Pointer(aSelector), anArgument.Ptr())
}

func NSEnumeratorCancelPreviousPerformRequestsWithTargetSelectorObject(aTarget NSObject, aSelector SEL, anArgument NSObject)  {
	C.NSEnumerator_CancelPreviousPerformRequestsWithTargetSelectorObject(aTarget.Ptr(), unsafe.Pointer(aSelector), anArgument.Ptr())
}

func NSEnumeratorResolveClassMethod(sel SEL) bool {
	ret := (bool)(C.NSEnumerator_ResolveClassMethod(unsafe.Pointer(sel)))
	return ret
}

func NSEnumeratorDescription() *NSString {
	ret := &NSString{}
	ret.ptr = unsafe.Pointer(C.NSEnumerator_Description())
	if ret.ptr == nil { return ret }
	return ret
}

func NSEnumeratorClassForKeyedUnarchiver() Class {
	ret := (Class)(unsafe.Pointer(C.NSEnumerator_ClassForKeyedUnarchiver()))
	return ret
}

func NSEnumeratorInstanceMethodSignatureForSelector(aSelector SEL) *NSMethodSignature {
	ret := &NSMethodSignature{}
	ret.ptr = unsafe.Pointer(C.NSEnumerator_InstanceMethodSignatureForSelector(unsafe.Pointer(aSelector)))
	if ret.ptr == nil { return ret }
	return ret
}

func NSEnumeratorKeyPathsForValuesAffectingValueForKey(key *NSString) *NSSet {
	ret := &NSSet{}
	ret.ptr = unsafe.Pointer(C.NSEnumerator_KeyPathsForValuesAffectingValueForKey(key.Ptr()))
	if ret.ptr == nil { return ret }
	return ret
}

func NSEnumeratorAllocWithZone(zone *_NSZone) *NSEnumerator {
	ret := &NSEnumerator{}
	ret.ptr = unsafe.Pointer(C.NSEnumerator_AllocWithZone(unsafe.Pointer(zone)))
	if ret.ptr == nil { return ret }
	runtime.SetFinalizer(ret, func(o *NSEnumerator) {
		o.Release()
	})
	return ret
}

func NSEnumeratorMutableCopyWithZone(zone *_NSZone) *Id {
	ret := &Id{}
	ret.ptr = unsafe.Pointer(C.NSEnumerator_MutableCopyWithZone(unsafe.Pointer(zone)))
	if ret.ptr == nil { return ret }
	runtime.SetFinalizer(ret, func(o *Id) {
		o.Release()
	})
	return ret
}

func NSEnumeratorAccessInstanceVariablesDirectly() bool {
	ret := (bool)(C.NSEnumerator_AccessInstanceVariablesDirectly())
	return ret
}

func NSEnumeratorLoad()  {
	C.NSEnumerator_Load()
}

func NSEnumeratorVersion() NSInteger {
	ret := (NSInteger)(C.NSEnumerator_Version())
	return ret
}

func NSEnumeratorInstancesRespondToSelector(aSelector SEL) bool {
	ret := (bool)(C.NSEnumerator_InstancesRespondToSelector(unsafe.Pointer(aSelector)))
	return ret
}

func NSEnumeratorNew() *NSEnumerator {
	ret := &NSEnumerator{}
	ret.ptr = unsafe.Pointer(C.NSEnumerator_New())
	if ret.ptr == nil { return ret }
	runtime.SetFinalizer(ret, func(o *NSEnumerator) {
		o.Release()
	})
	return ret
}

func (o *NSEnumerator) IsLike(object *NSString) bool {
	ret := (bool)(C.NSEnumerator_inst_IsLike(o.Ptr(), object.Ptr()))
	runtime.KeepAlive(o)
	return ret
}

func (o *NSEnumerator) Copy() *Id {
	ret := &Id{}
	ret.ptr = unsafe.Pointer(C.NSEnumerator_inst_Copy(o.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	runtime.SetFinalizer(ret, func(o *Id) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *NSEnumerator) RemoveObserverForKeyPath(observer NSObject, keyPath *NSString)  {
	C.NSEnumerator_inst_RemoveObserverForKeyPath(o.Ptr(), observer.Ptr(), keyPath.Ptr())
	runtime.KeepAlive(o)
}

func (o *NSEnumerator) RemoveObserverForKeyPathContext(observer NSObject, keyPath *NSString, context unsafe.Pointer)  {
	C.NSEnumerator_inst_RemoveObserverForKeyPathContext(o.Ptr(), observer.Ptr(), keyPath.Ptr(), unsafe.Pointer(context))
	runtime.KeepAlive(o)
}

func (o *NSEnumerator) InverseForRelationshipKey(relationshipKey *NSString) *NSString {
	ret := &NSString{}
	ret.ptr = unsafe.Pointer(C.NSEnumerator_inst_InverseForRelationshipKey(o.Ptr(), relationshipKey.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSString)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *NSString) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *NSEnumerator) ScriptingContains(object NSObject) bool {
	ret := (bool)(C.NSEnumerator_inst_ScriptingContains(o.Ptr(), object.Ptr()))
	runtime.KeepAlive(o)
	return ret
}

func (o *NSEnumerator) ScriptingProperties() *NSDictionary {
	ret := &NSDictionary{}
	ret.ptr = unsafe.Pointer(C.NSEnumerator_inst_ScriptingProperties(o.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSDictionary)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *NSDictionary) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *NSEnumerator) AttemptRecoveryFromErrorOptionIndex(error *NSError, recoveryOptionIndex NSUInteger) bool {
	ret := (bool)(C.NSEnumerator_inst_AttemptRecoveryFromErrorOptionIndex(o.Ptr(), error.Ptr(), (C.NSUInteger)(recoveryOptionIndex)))
	runtime.KeepAlive(o)
	return ret
}

func (o *NSEnumerator) AttemptRecoveryFromErrorOptionIndexDelegate(error *NSError, recoveryOptionIndex NSUInteger, delegate NSObject, didRecoverSelector SEL, contextInfo unsafe.Pointer)  {
	C.NSEnumerator_inst_AttemptRecoveryFromErrorOptionIndexDelegate(o.Ptr(), error.Ptr(), (C.NSUInteger)(recoveryOptionIndex), delegate.Ptr(), unsafe.Pointer(didRecoverSelector), unsafe.Pointer(contextInfo))
	runtime.KeepAlive(o)
}

func (o *NSEnumerator) AttemptRecoveryFromErrorOptionIndexDelegateDidRecoverSelector(error *NSError, recoveryOptionIndex NSUInteger, delegate NSObject, didRecoverSelector SEL, contextInfo unsafe.Pointer)  {
	C.NSEnumerator_inst_AttemptRecoveryFromErrorOptionIndexDelegateDidRecoverSelector(o.Ptr(), error.Ptr(), (C.NSUInteger)(recoveryOptionIndex), delegate.Ptr(), unsafe.Pointer(didRecoverSelector), unsafe.Pointer(contextInfo))
	runtime.KeepAlive(o)
}

func (o *NSEnumerator) DoesContain(object NSObject) bool {
	ret := (bool)(C.NSEnumerator_inst_DoesContain(o.Ptr(), object.Ptr()))
	runtime.KeepAlive(o)
	return ret
}

func (o *NSEnumerator) CoerceValueForKey(value NSObject, key *NSString) *Id {
	ret := &Id{}
	ret.ptr = unsafe.Pointer(C.NSEnumerator_inst_CoerceValueForKey(o.Ptr(), value.Ptr(), key.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *Id) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *NSEnumerator) ScriptingValueForSpecifier(objectSpecifier *NSScriptObjectSpecifier) *Id {
	ret := &Id{}
	ret.ptr = unsafe.Pointer(C.NSEnumerator_inst_ScriptingValueForSpecifier(o.Ptr(), objectSpecifier.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *Id) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *NSEnumerator) DictionaryWithValuesForKeys(keys *NSArray) *NSDictionary {
	ret := &NSDictionary{}
	ret.ptr = unsafe.Pointer(C.NSEnumerator_inst_DictionaryWithValuesForKeys(o.Ptr(), keys.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSDictionary)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *NSDictionary) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *NSEnumerator) ObserveValueForKeyPathOfObject(keyPath *NSString, object NSObject, change *NSDictionary, context unsafe.Pointer)  {
	C.NSEnumerator_inst_ObserveValueForKeyPathOfObject(o.Ptr(), keyPath.Ptr(), object.Ptr(), change.Ptr(), unsafe.Pointer(context))
	runtime.KeepAlive(o)
}

func (o *NSEnumerator) ObserveValueForKeyPathOfObjectChange(keyPath *NSString, object NSObject, change *NSDictionary, context unsafe.Pointer)  {
	C.NSEnumerator_inst_ObserveValueForKeyPathOfObjectChange(o.Ptr(), keyPath.Ptr(), object.Ptr(), change.Ptr(), unsafe.Pointer(context))
	runtime.KeepAlive(o)
}

func (o *NSEnumerator) ToManyRelationshipKeys() *NSArray {
	ret := &NSArray{}
	ret.ptr = unsafe.Pointer(C.NSEnumerator_inst_ToManyRelationshipKeys(o.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSArray)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *NSArray) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *NSEnumerator) SetValueForKey(value NSObject, key *NSString)  {
	C.NSEnumerator_inst_SetValueForKey(o.Ptr(), value.Ptr(), key.Ptr())
	runtime.KeepAlive(o)
}

func (o *NSEnumerator) SetValueForKeyPath(value NSObject, keyPath *NSString)  {
	C.NSEnumerator_inst_SetValueForKeyPath(o.Ptr(), value.Ptr(), keyPath.Ptr())
	runtime.KeepAlive(o)
}

func (o *NSEnumerator) SetValueForUndefinedKey(value NSObject, key *NSString)  {
	C.NSEnumerator_inst_SetValueForUndefinedKey(o.Ptr(), value.Ptr(), key.Ptr())
	runtime.KeepAlive(o)
}

func (o *NSEnumerator) ScriptingBeginsWith(object NSObject) bool {
	ret := (bool)(C.NSEnumerator_inst_ScriptingBeginsWith(o.Ptr(), object.Ptr()))
	runtime.KeepAlive(o)
	return ret
}

func (o *NSEnumerator) MethodSignatureForSelector(aSelector SEL) *NSMethodSignature {
	ret := &NSMethodSignature{}
	ret.ptr = unsafe.Pointer(C.NSEnumerator_inst_MethodSignatureForSelector(o.Ptr(), unsafe.Pointer(aSelector)))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSMethodSignature)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *NSMethodSignature) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *NSEnumerator) IsLessThanOrEqualTo(object NSObject) bool {
	ret := (bool)(C.NSEnumerator_inst_IsLessThanOrEqualTo(o.Ptr(), object.Ptr()))
	runtime.KeepAlive(o)
	return ret
}

func (o *NSEnumerator) ScriptingEndsWith(object NSObject) bool {
	ret := (bool)(C.NSEnumerator_inst_ScriptingEndsWith(o.Ptr(), object.Ptr()))
	runtime.KeepAlive(o)
	return ret
}

func (o *NSEnumerator) AutoContentAccessingProxy() *Id {
	ret := &Id{}
	ret.ptr = unsafe.Pointer(C.NSEnumerator_inst_AutoContentAccessingProxy(o.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *Id) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *NSEnumerator) PerformSelectorWithObject(aSelector SEL, anArgument NSObject, delay NSTimeInterval)  {
	C.NSEnumerator_inst_PerformSelectorWithObject(o.Ptr(), unsafe.Pointer(aSelector), anArgument.Ptr(), (C.NSTimeInterval)(delay))
	runtime.KeepAlive(o)
}

func (o *NSEnumerator) PerformSelectorWithObjectAfterDelay(aSelector SEL, anArgument NSObject, delay NSTimeInterval)  {
	C.NSEnumerator_inst_PerformSelectorWithObjectAfterDelay(o.Ptr(), unsafe.Pointer(aSelector), anArgument.Ptr(), (C.NSTimeInterval)(delay))
	runtime.KeepAlive(o)
}

func (o *NSEnumerator) PerformSelectorWithObjectAfterDelayInModes(aSelector SEL, anArgument NSObject, delay NSTimeInterval, modes *NSArray)  {
	C.NSEnumerator_inst_PerformSelectorWithObjectAfterDelayInModes(o.Ptr(), unsafe.Pointer(aSelector), anArgument.Ptr(), (C.NSTimeInterval)(delay), modes.Ptr())
	runtime.KeepAlive(o)
}

func (o *NSEnumerator) PerformSelectorOnThread(aSelector SEL, thr *NSThread, arg NSObject, wait BOOL)  {
	C.NSEnumerator_inst_PerformSelectorOnThread(o.Ptr(), unsafe.Pointer(aSelector), thr.Ptr(), arg.Ptr(), (C.BOOL)(wait))
	runtime.KeepAlive(o)
}

func (o *NSEnumerator) PerformSelectorOnThreadWithObject(aSelector SEL, thr *NSThread, arg NSObject, wait BOOL)  {
	C.NSEnumerator_inst_PerformSelectorOnThreadWithObject(o.Ptr(), unsafe.Pointer(aSelector), thr.Ptr(), arg.Ptr(), (C.BOOL)(wait))
	runtime.KeepAlive(o)
}

func (o *NSEnumerator) PerformSelectorOnThreadWithObjectWaitUntilDone(aSelector SEL, thr *NSThread, arg NSObject, wait BOOL, array *NSArray)  {
	C.NSEnumerator_inst_PerformSelectorOnThreadWithObjectWaitUntilDone(o.Ptr(), unsafe.Pointer(aSelector), thr.Ptr(), arg.Ptr(), (C.BOOL)(wait), array.Ptr())
	runtime.KeepAlive(o)
}

func (o *NSEnumerator) PerformSelectorOnThreadWithObjectWaitUntilDoneModes(aSelector SEL, thr *NSThread, arg NSObject, wait BOOL, array *NSArray)  {
	C.NSEnumerator_inst_PerformSelectorOnThreadWithObjectWaitUntilDoneModes(o.Ptr(), unsafe.Pointer(aSelector), thr.Ptr(), arg.Ptr(), (C.BOOL)(wait), array.Ptr())
	runtime.KeepAlive(o)
}

func (o *NSEnumerator) IsLessThan(object NSObject) bool {
	ret := (bool)(C.NSEnumerator_inst_IsLessThan(o.Ptr(), object.Ptr()))
	runtime.KeepAlive(o)
	return ret
}

func (o *NSEnumerator) ClassCode() FourCharCode {
	ret := (FourCharCode)(C.NSEnumerator_inst_ClassCode(o.Ptr()))
	runtime.KeepAlive(o)
	return ret
}

func (o *NSEnumerator) ScriptingIsGreaterThanOrEqualTo(object NSObject) bool {
	ret := (bool)(C.NSEnumerator_inst_ScriptingIsGreaterThanOrEqualTo(o.Ptr(), object.Ptr()))
	runtime.KeepAlive(o)
	return ret
}

func (o *NSEnumerator) ClassForCoder() Class {
	ret := (Class)(unsafe.Pointer(C.NSEnumerator_inst_ClassForCoder(o.Ptr())))
	runtime.KeepAlive(o)
	return ret
}

func (o *NSEnumerator) ForwardingTargetForSelector(aSelector SEL) *Id {
	ret := &Id{}
	ret.ptr = unsafe.Pointer(C.NSEnumerator_inst_ForwardingTargetForSelector(o.Ptr(), unsafe.Pointer(aSelector)))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *Id) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *NSEnumerator) DidChangeValuesAtIndexes(changeKind NSKeyValueChange, indexes *NSIndexSet, key *NSString)  {
	C.NSEnumerator_inst_DidChangeValuesAtIndexes(o.Ptr(), (C.NSKeyValueChange)(changeKind), indexes.Ptr(), key.Ptr())
	runtime.KeepAlive(o)
}

func (o *NSEnumerator) DidChangeValuesAtIndexesForKey(changeKind NSKeyValueChange, indexes *NSIndexSet, key *NSString)  {
	C.NSEnumerator_inst_DidChangeValuesAtIndexesForKey(o.Ptr(), (C.NSKeyValueChange)(changeKind), indexes.Ptr(), key.Ptr())
	runtime.KeepAlive(o)
}

func (o *NSEnumerator) ClassForKeyedArchiver() Class {
	ret := (Class)(unsafe.Pointer(C.NSEnumerator_inst_ClassForKeyedArchiver(o.Ptr())))
	runtime.KeepAlive(o)
	return ret
}

func (o *NSEnumerator) ValueWithUniqueIDInPropertyWithKey(uniqueID NSObject, key *NSString) *Id {
	ret := &Id{}
	ret.ptr = unsafe.Pointer(C.NSEnumerator_inst_ValueWithUniqueIDInPropertyWithKey(o.Ptr(), uniqueID.Ptr(), key.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *Id) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *NSEnumerator) Dealloc()  {
	C.NSEnumerator_inst_Dealloc(o.Ptr())
	runtime.KeepAlive(o)
}

func (o *NSEnumerator) Init() *NSEnumerator {
	ret := &NSEnumerator{}
	ret.ptr = unsafe.Pointer(C.NSEnumerator_inst_Init(o.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSEnumerator)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *NSEnumerator) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *NSEnumerator) ClassForArchiver() Class {
	ret := (Class)(unsafe.Pointer(C.NSEnumerator_inst_ClassForArchiver(o.Ptr())))
	runtime.KeepAlive(o)
	return ret
}

func (o *NSEnumerator) CopyScriptingValueForKey(value NSObject, key *NSString, properties *NSDictionary) *Id {
	ret := &Id{}
	ret.ptr = unsafe.Pointer(C.NSEnumerator_inst_CopyScriptingValueForKey(o.Ptr(), value.Ptr(), key.Ptr(), properties.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *Id) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *NSEnumerator) CopyScriptingValueForKeyWithProperties(value NSObject, key *NSString, properties *NSDictionary) *Id {
	ret := &Id{}
	ret.ptr = unsafe.Pointer(C.NSEnumerator_inst_CopyScriptingValueForKeyWithProperties(o.Ptr(), value.Ptr(), key.Ptr(), properties.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *Id) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *NSEnumerator) ClassName() *NSString {
	ret := &NSString{}
	ret.ptr = unsafe.Pointer(C.NSEnumerator_inst_ClassName(o.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSString)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *NSString) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *NSEnumerator) PerformSelectorOnMainThreadWithObject(aSelector SEL, arg NSObject, wait BOOL)  {
	C.NSEnumerator_inst_PerformSelectorOnMainThreadWithObject(o.Ptr(), unsafe.Pointer(aSelector), arg.Ptr(), (C.BOOL)(wait))
	runtime.KeepAlive(o)
}

func (o *NSEnumerator) PerformSelectorOnMainThreadWithObjectWaitUntilDone(aSelector SEL, arg NSObject, wait BOOL)  {
	C.NSEnumerator_inst_PerformSelectorOnMainThreadWithObjectWaitUntilDone(o.Ptr(), unsafe.Pointer(aSelector), arg.Ptr(), (C.BOOL)(wait))
	runtime.KeepAlive(o)
}

func (o *NSEnumerator) PerformSelectorOnMainThreadWithObjectWaitUntilDoneModes(aSelector SEL, arg NSObject, wait BOOL, array *NSArray)  {
	C.NSEnumerator_inst_PerformSelectorOnMainThreadWithObjectWaitUntilDoneModes(o.Ptr(), unsafe.Pointer(aSelector), arg.Ptr(), (C.BOOL)(wait), array.Ptr())
	runtime.KeepAlive(o)
}

func (o *NSEnumerator) PerformSelectorInBackgroundWithObject(aSelector SEL, arg NSObject)  {
	C.NSEnumerator_inst_PerformSelectorInBackgroundWithObject(o.Ptr(), unsafe.Pointer(aSelector), arg.Ptr())
	runtime.KeepAlive(o)
}

func (o *NSEnumerator) SetObservationInfo(observationInfo unsafe.Pointer)  {
	C.NSEnumerator_inst_SetObservationInfo(o.Ptr(), unsafe.Pointer(observationInfo))
	runtime.KeepAlive(o)
}

func (o *NSEnumerator) IsGreaterThan(object NSObject) bool {
	ret := (bool)(C.NSEnumerator_inst_IsGreaterThan(o.Ptr(), object.Ptr()))
	runtime.KeepAlive(o)
	return ret
}

func (o *NSEnumerator) ScriptingIsGreaterThan(object NSObject) bool {
	ret := (bool)(C.NSEnumerator_inst_ScriptingIsGreaterThan(o.Ptr(), object.Ptr()))
	runtime.KeepAlive(o)
	return ret
}

func (o *NSEnumerator) ClassDescription() *NSClassDescription {
	ret := &NSClassDescription{}
	ret.ptr = unsafe.Pointer(C.NSEnumerator_inst_ClassDescription(o.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSClassDescription)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *NSClassDescription) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *NSEnumerator) ReplacementObjectForKeyedArchiver(archiver *NSKeyedArchiver) *Id {
	ret := &Id{}
	ret.ptr = unsafe.Pointer(C.NSEnumerator_inst_ReplacementObjectForKeyedArchiver(o.Ptr(), archiver.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *Id) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *NSEnumerator) RemoveValueAtIndexFromPropertyWithKey(index NSUInteger, key *NSString)  {
	C.NSEnumerator_inst_RemoveValueAtIndexFromPropertyWithKey(o.Ptr(), (C.NSUInteger)(index), key.Ptr())
	runtime.KeepAlive(o)
}

func (o *NSEnumerator) ObservationInfo() unsafe.Pointer {
	ret := (unsafe.Pointer)(unsafe.Pointer(C.NSEnumerator_inst_ObservationInfo(o.Ptr())))
	runtime.KeepAlive(o)
	return ret
}

func (o *NSEnumerator) ScriptingIsLessThan(object NSObject) bool {
	ret := (bool)(C.NSEnumerator_inst_ScriptingIsLessThan(o.Ptr(), object.Ptr()))
	runtime.KeepAlive(o)
	return ret
}

func (o *NSEnumerator) DoesNotRecognizeSelector(aSelector SEL)  {
	C.NSEnumerator_inst_DoesNotRecognizeSelector(o.Ptr(), unsafe.Pointer(aSelector))
	runtime.KeepAlive(o)
}

func (o *NSEnumerator) ToOneRelationshipKeys() *NSArray {
	ret := &NSArray{}
	ret.ptr = unsafe.Pointer(C.NSEnumerator_inst_ToOneRelationshipKeys(o.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSArray)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *NSArray) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *NSEnumerator) AttributeKeys() *NSArray {
	ret := &NSArray{}
	ret.ptr = unsafe.Pointer(C.NSEnumerator_inst_AttributeKeys(o.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSArray)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *NSArray) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *NSEnumerator) IsNotEqualTo(object NSObject) bool {
	ret := (bool)(C.NSEnumerator_inst_IsNotEqualTo(o.Ptr(), object.Ptr()))
	runtime.KeepAlive(o)
	return ret
}

func (o *NSEnumerator) IndicesOfObjectsByEvaluatingObjectSpecifier(specifier *NSScriptObjectSpecifier) *NSArray {
	ret := &NSArray{}
	ret.ptr = unsafe.Pointer(C.NSEnumerator_inst_IndicesOfObjectsByEvaluatingObjectSpecifier(o.Ptr(), specifier.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSArray)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *NSArray) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *NSEnumerator) ObjectSpecifier() *NSScriptObjectSpecifier {
	ret := &NSScriptObjectSpecifier{}
	ret.ptr = unsafe.Pointer(C.NSEnumerator_inst_ObjectSpecifier(o.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSScriptObjectSpecifier)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *NSScriptObjectSpecifier) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *NSEnumerator) AwakeAfterUsingCoder(coder *NSCoder) *Id {
	ret := &Id{}
	ret.ptr = unsafe.Pointer(C.NSEnumerator_inst_AwakeAfterUsingCoder(o.Ptr(), coder.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *Id) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *NSEnumerator) SetValuesForKeysWithDictionary(keyedValues *NSDictionary)  {
	C.NSEnumerator_inst_SetValuesForKeysWithDictionary(o.Ptr(), keyedValues.Ptr())
	runtime.KeepAlive(o)
}

func (o *NSEnumerator) IsGreaterThanOrEqualTo(object NSObject) bool {
	ret := (bool)(C.NSEnumerator_inst_IsGreaterThanOrEqualTo(o.Ptr(), object.Ptr()))
	runtime.KeepAlive(o)
	return ret
}

func (o *NSEnumerator) ValueAtIndexInPropertyWithKey(index NSUInteger, key *NSString) *Id {
	ret := &Id{}
	ret.ptr = unsafe.Pointer(C.NSEnumerator_inst_ValueAtIndexInPropertyWithKey(o.Ptr(), (C.NSUInteger)(index), key.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *Id) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *NSEnumerator) ScriptingIsLessThanOrEqualTo(object NSObject) bool {
	ret := (bool)(C.NSEnumerator_inst_ScriptingIsLessThanOrEqualTo(o.Ptr(), object.Ptr()))
	runtime.KeepAlive(o)
	return ret
}

func (o *NSEnumerator) NextObject() *Id {
	ret := &Id{}
	ret.ptr = unsafe.Pointer(C.NSEnumerator_inst_NextObject(o.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *Id) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *NSEnumerator) MutableOrderedSetValueForKey(key *NSString) *NSMutableOrderedSet {
	ret := &NSMutableOrderedSet{}
	ret.ptr = unsafe.Pointer(C.NSEnumerator_inst_MutableOrderedSetValueForKey(o.Ptr(), key.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSMutableOrderedSet)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *NSMutableOrderedSet) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *NSEnumerator) ValueForKey(key *NSString) *Id {
	ret := &Id{}
	ret.ptr = unsafe.Pointer(C.NSEnumerator_inst_ValueForKey(o.Ptr(), key.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *Id) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *NSEnumerator) InsertValueInPropertyWithKey(value NSObject, key *NSString)  {
	C.NSEnumerator_inst_InsertValueInPropertyWithKey(o.Ptr(), value.Ptr(), key.Ptr())
	runtime.KeepAlive(o)
}

func (o *NSEnumerator) InsertValueAtIndex(value NSObject, index NSUInteger, key *NSString)  {
	C.NSEnumerator_inst_InsertValueAtIndex(o.Ptr(), value.Ptr(), (C.NSUInteger)(index), key.Ptr())
	runtime.KeepAlive(o)
}

func (o *NSEnumerator) InsertValueAtIndexInPropertyWithKey(value NSObject, index NSUInteger, key *NSString)  {
	C.NSEnumerator_inst_InsertValueAtIndexInPropertyWithKey(o.Ptr(), value.Ptr(), (C.NSUInteger)(index), key.Ptr())
	runtime.KeepAlive(o)
}

func (o *NSEnumerator) AddObserverForKeyPath(observer NSObject, keyPath *NSString, options NSKeyValueObservingOptions, context unsafe.Pointer)  {
	C.NSEnumerator_inst_AddObserverForKeyPath(o.Ptr(), observer.Ptr(), keyPath.Ptr(), (C.NSKeyValueObservingOptions)(options), unsafe.Pointer(context))
	runtime.KeepAlive(o)
}

func (o *NSEnumerator) AddObserverForKeyPathOptions(observer NSObject, keyPath *NSString, options NSKeyValueObservingOptions, context unsafe.Pointer)  {
	C.NSEnumerator_inst_AddObserverForKeyPathOptions(o.Ptr(), observer.Ptr(), keyPath.Ptr(), (C.NSKeyValueObservingOptions)(options), unsafe.Pointer(context))
	runtime.KeepAlive(o)
}

func (o *NSEnumerator) ForwardInvocation(anInvocation *NSInvocation)  {
	C.NSEnumerator_inst_ForwardInvocation(o.Ptr(), anInvocation.Ptr())
	runtime.KeepAlive(o)
}

func (o *NSEnumerator) DidChangeValueForKey(key *NSString)  {
	C.NSEnumerator_inst_DidChangeValueForKey(o.Ptr(), key.Ptr())
	runtime.KeepAlive(o)
}

func (o *NSEnumerator) DidChangeValueForKeyWithSetMutation(key *NSString, mutationKind NSKeyValueSetMutationKind, objects *NSSet)  {
	C.NSEnumerator_inst_DidChangeValueForKeyWithSetMutation(o.Ptr(), key.Ptr(), (C.NSKeyValueSetMutationKind)(mutationKind), objects.Ptr())
	runtime.KeepAlive(o)
}

func (o *NSEnumerator) DidChangeValueForKeyWithSetMutationUsingObjects(key *NSString, mutationKind NSKeyValueSetMutationKind, objects *NSSet)  {
	C.NSEnumerator_inst_DidChangeValueForKeyWithSetMutationUsingObjects(o.Ptr(), key.Ptr(), (C.NSKeyValueSetMutationKind)(mutationKind), objects.Ptr())
	runtime.KeepAlive(o)
}

func (o *NSEnumerator) ValueForKeyPath(keyPath *NSString) *Id {
	ret := &Id{}
	ret.ptr = unsafe.Pointer(C.NSEnumerator_inst_ValueForKeyPath(o.Ptr(), keyPath.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *Id) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *NSEnumerator) WillChangeValuesAtIndexes(changeKind NSKeyValueChange, indexes *NSIndexSet, key *NSString)  {
	C.NSEnumerator_inst_WillChangeValuesAtIndexes(o.Ptr(), (C.NSKeyValueChange)(changeKind), indexes.Ptr(), key.Ptr())
	runtime.KeepAlive(o)
}

func (o *NSEnumerator) WillChangeValuesAtIndexesForKey(changeKind NSKeyValueChange, indexes *NSIndexSet, key *NSString)  {
	C.NSEnumerator_inst_WillChangeValuesAtIndexesForKey(o.Ptr(), (C.NSKeyValueChange)(changeKind), indexes.Ptr(), key.Ptr())
	runtime.KeepAlive(o)
}

func (o *NSEnumerator) IsCaseInsensitiveLike(object *NSString) bool {
	ret := (bool)(C.NSEnumerator_inst_IsCaseInsensitiveLike(o.Ptr(), object.Ptr()))
	runtime.KeepAlive(o)
	return ret
}

func (o *NSEnumerator) MutableArrayValueForKeyPath(keyPath *NSString) *NSMutableArray {
	ret := &NSMutableArray{}
	ret.ptr = unsafe.Pointer(C.NSEnumerator_inst_MutableArrayValueForKeyPath(o.Ptr(), keyPath.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSMutableArray)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *NSMutableArray) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *NSEnumerator) MutableArrayValueForKey(key *NSString) *NSMutableArray {
	ret := &NSMutableArray{}
	ret.ptr = unsafe.Pointer(C.NSEnumerator_inst_MutableArrayValueForKey(o.Ptr(), key.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSMutableArray)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *NSMutableArray) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *NSEnumerator) ValueForUndefinedKey(key *NSString) *Id {
	ret := &Id{}
	ret.ptr = unsafe.Pointer(C.NSEnumerator_inst_ValueForUndefinedKey(o.Ptr(), key.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *Id) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *NSEnumerator) IsEqualTo(object NSObject) bool {
	ret := (bool)(C.NSEnumerator_inst_IsEqualTo(o.Ptr(), object.Ptr()))
	runtime.KeepAlive(o)
	return ret
}

func (o *NSEnumerator) MutableCopy() *Id {
	ret := &Id{}
	ret.ptr = unsafe.Pointer(C.NSEnumerator_inst_MutableCopy(o.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	runtime.SetFinalizer(ret, func(o *Id) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *NSEnumerator) AllObjects() *NSArray {
	ret := &NSArray{}
	ret.ptr = unsafe.Pointer(C.NSEnumerator_inst_AllObjects(o.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSArray)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *NSArray) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *NSEnumerator) SetScriptingProperties(scriptingProperties *NSDictionary)  {
	C.NSEnumerator_inst_SetScriptingProperties(o.Ptr(), scriptingProperties.Ptr())
	runtime.KeepAlive(o)
}

func (o *NSEnumerator) ScriptingIsEqualTo(object NSObject) bool {
	ret := (bool)(C.NSEnumerator_inst_ScriptingIsEqualTo(o.Ptr(), object.Ptr()))
	runtime.KeepAlive(o)
	return ret
}

func (o *NSEnumerator) MutableSetValueForKeyPath(keyPath *NSString) *NSMutableSet {
	ret := &NSMutableSet{}
	ret.ptr = unsafe.Pointer(C.NSEnumerator_inst_MutableSetValueForKeyPath(o.Ptr(), keyPath.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSMutableSet)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *NSMutableSet) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *NSEnumerator) ValueWithNameInPropertyWithKey(name *NSString, key *NSString) *Id {
	ret := &Id{}
	ret.ptr = unsafe.Pointer(C.NSEnumerator_inst_ValueWithNameInPropertyWithKey(o.Ptr(), name.Ptr(), key.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *Id) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *NSEnumerator) NewScriptingObjectOfClassForValueForKey(objectClass Class, key *NSString, contentsValue NSObject, properties *NSDictionary) *Id {
	ret := &Id{}
	ret.ptr = unsafe.Pointer(C.NSEnumerator_inst_NewScriptingObjectOfClassForValueForKey(o.Ptr(), unsafe.Pointer(objectClass), key.Ptr(), contentsValue.Ptr(), properties.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *Id) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *NSEnumerator) NewScriptingObjectOfClassForValueForKeyWithContentsValue(objectClass Class, key *NSString, contentsValue NSObject, properties *NSDictionary) *Id {
	ret := &Id{}
	ret.ptr = unsafe.Pointer(C.NSEnumerator_inst_NewScriptingObjectOfClassForValueForKeyWithContentsValue(o.Ptr(), unsafe.Pointer(objectClass), key.Ptr(), contentsValue.Ptr(), properties.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *Id) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *NSEnumerator) WillChangeValueForKey(key *NSString)  {
	C.NSEnumerator_inst_WillChangeValueForKey(o.Ptr(), key.Ptr())
	runtime.KeepAlive(o)
}

func (o *NSEnumerator) WillChangeValueForKeyWithSetMutation(key *NSString, mutationKind NSKeyValueSetMutationKind, objects *NSSet)  {
	C.NSEnumerator_inst_WillChangeValueForKeyWithSetMutation(o.Ptr(), key.Ptr(), (C.NSKeyValueSetMutationKind)(mutationKind), objects.Ptr())
	runtime.KeepAlive(o)
}

func (o *NSEnumerator) WillChangeValueForKeyWithSetMutationUsingObjects(key *NSString, mutationKind NSKeyValueSetMutationKind, objects *NSSet)  {
	C.NSEnumerator_inst_WillChangeValueForKeyWithSetMutationUsingObjects(o.Ptr(), key.Ptr(), (C.NSKeyValueSetMutationKind)(mutationKind), objects.Ptr())
	runtime.KeepAlive(o)
}

func (o *NSEnumerator) SetNilValueForKey(key *NSString)  {
	C.NSEnumerator_inst_SetNilValueForKey(o.Ptr(), key.Ptr())
	runtime.KeepAlive(o)
}

func (o *NSEnumerator) CountByEnumeratingWithStateObjects(state *NSFastEnumerationState, buffer *[]*Id, len_ NSUInteger) NSUInteger {

	goSlice2 := make([]unsafe.Pointer,cap(*buffer))
	for i := 0; i < len(*buffer); i++ {
		goSlice2[i] = (*buffer)[i].Ptr()
	}
	ret := (NSUInteger)(C.NSEnumerator_inst_CountByEnumeratingWithStateObjects(o.Ptr(), unsafe.Pointer(state), (*unsafe.Pointer)(unsafe.Pointer(&goSlice2[0])), (C.NSUInteger)(len_)))
	(*buffer) = (*buffer)[:cap(*buffer)]
	for i := 0; i < len(*buffer); i++ {
		if goSlice2[i] == nil {
			(*buffer) = (*buffer)[:i]
			break
		}
		if (*buffer)[i] == nil {
			(*buffer)[i] = &Id{}
			runtime.SetFinalizer((*buffer)[i], func(o *Id) {
				o.Release()
			})
		}
		(*buffer)[i].ptr = goSlice2[i]
	}
	runtime.KeepAlive(o)
	return ret
}

func (o *NSEnumerator) CountByEnumeratingWithStateObjectsCount(state *NSFastEnumerationState, buffer *[]*Id, len_ NSUInteger) NSUInteger {

	goSlice2 := make([]unsafe.Pointer,cap(*buffer))
	for i := 0; i < len(*buffer); i++ {
		goSlice2[i] = (*buffer)[i].Ptr()
	}
	ret := (NSUInteger)(C.NSEnumerator_inst_CountByEnumeratingWithStateObjectsCount(o.Ptr(), unsafe.Pointer(state), (*unsafe.Pointer)(unsafe.Pointer(&goSlice2[0])), (C.NSUInteger)(len_)))
	(*buffer) = (*buffer)[:cap(*buffer)]
	for i := 0; i < len(*buffer); i++ {
		if goSlice2[i] == nil {
			(*buffer) = (*buffer)[:i]
			break
		}
		if (*buffer)[i] == nil {
			(*buffer)[i] = &Id{}
			runtime.SetFinalizer((*buffer)[i], func(o *Id) {
				o.Release()
			})
		}
		(*buffer)[i].ptr = goSlice2[i]
	}
	runtime.KeepAlive(o)
	return ret
}

func (o *NSEnumerator) MutableSetValueForKey(key *NSString) *NSMutableSet {
	ret := &NSMutableSet{}
	ret.ptr = unsafe.Pointer(C.NSEnumerator_inst_MutableSetValueForKey(o.Ptr(), key.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSMutableSet)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *NSMutableSet) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *NSEnumerator) MutableOrderedSetValueForKeyPath(keyPath *NSString) *NSMutableOrderedSet {
	ret := &NSMutableOrderedSet{}
	ret.ptr = unsafe.Pointer(C.NSEnumerator_inst_MutableOrderedSetValueForKeyPath(o.Ptr(), keyPath.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSMutableOrderedSet)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *NSMutableOrderedSet) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *NSEnumerator) ValidateValueForKey(ioValue *[]*Id, inKey *NSString, outError *[]*NSError) bool {

	goSlice1 := make([]unsafe.Pointer,cap(*ioValue))
	for i := 0; i < len(*ioValue); i++ {
		goSlice1[i] = (*ioValue)[i].Ptr()
	}

	goSlice3 := make([]unsafe.Pointer,cap(*outError))
	for i := 0; i < len(*outError); i++ {
		goSlice3[i] = (*outError)[i].Ptr()
	}
	ret := (bool)(C.NSEnumerator_inst_ValidateValueForKey(o.Ptr(), (*unsafe.Pointer)(unsafe.Pointer(&goSlice1[0])), inKey.Ptr(), (*unsafe.Pointer)(unsafe.Pointer(&goSlice3[0]))))
	(*ioValue) = (*ioValue)[:cap(*ioValue)]
	for i := 0; i < len(*ioValue); i++ {
		if goSlice1[i] == nil {
			(*ioValue) = (*ioValue)[:i]
			break
		}
		if (*ioValue)[i] == nil {
			(*ioValue)[i] = &Id{}
			runtime.SetFinalizer((*ioValue)[i], func(o *Id) {
				o.Release()
			})
		}
		(*ioValue)[i].ptr = goSlice1[i]
	}
	(*outError) = (*outError)[:cap(*outError)]
	for i := 0; i < len(*outError); i++ {
		if goSlice3[i] == nil {
			(*outError) = (*outError)[:i]
			break
		}
		if (*outError)[i] == nil {
			(*outError)[i] = &NSError{}
			runtime.SetFinalizer((*outError)[i], func(o *NSError) {
				o.Release()
			})
		}
		(*outError)[i].ptr = goSlice3[i]
	}
	runtime.KeepAlive(o)
	return ret
}

func (o *NSEnumerator) ValidateValueForKeyPath(ioValue *[]*Id, inKeyPath *NSString, outError *[]*NSError) bool {

	goSlice1 := make([]unsafe.Pointer,cap(*ioValue))
	for i := 0; i < len(*ioValue); i++ {
		goSlice1[i] = (*ioValue)[i].Ptr()
	}

	goSlice3 := make([]unsafe.Pointer,cap(*outError))
	for i := 0; i < len(*outError); i++ {
		goSlice3[i] = (*outError)[i].Ptr()
	}
	ret := (bool)(C.NSEnumerator_inst_ValidateValueForKeyPath(o.Ptr(), (*unsafe.Pointer)(unsafe.Pointer(&goSlice1[0])), inKeyPath.Ptr(), (*unsafe.Pointer)(unsafe.Pointer(&goSlice3[0]))))
	(*ioValue) = (*ioValue)[:cap(*ioValue)]
	for i := 0; i < len(*ioValue); i++ {
		if goSlice1[i] == nil {
			(*ioValue) = (*ioValue)[:i]
			break
		}
		if (*ioValue)[i] == nil {
			(*ioValue)[i] = &Id{}
			runtime.SetFinalizer((*ioValue)[i], func(o *Id) {
				o.Release()
			})
		}
		(*ioValue)[i].ptr = goSlice1[i]
	}
	(*outError) = (*outError)[:cap(*outError)]
	for i := 0; i < len(*outError); i++ {
		if goSlice3[i] == nil {
			(*outError) = (*outError)[:i]
			break
		}
		if (*outError)[i] == nil {
			(*outError)[i] = &NSError{}
			runtime.SetFinalizer((*outError)[i], func(o *NSError) {
				o.Release()
			})
		}
		(*outError)[i].ptr = goSlice3[i]
	}
	runtime.KeepAlive(o)
	return ret
}

func (o *NSEnumerator) ValidateValueForKeyError(ioValue *[]*Id, inKey *NSString, outError *[]*NSError) bool {

	goSlice1 := make([]unsafe.Pointer,cap(*ioValue))
	for i := 0; i < len(*ioValue); i++ {
		goSlice1[i] = (*ioValue)[i].Ptr()
	}

	goSlice3 := make([]unsafe.Pointer,cap(*outError))
	for i := 0; i < len(*outError); i++ {
		goSlice3[i] = (*outError)[i].Ptr()
	}
	ret := (bool)(C.NSEnumerator_inst_ValidateValueForKeyError(o.Ptr(), (*unsafe.Pointer)(unsafe.Pointer(&goSlice1[0])), inKey.Ptr(), (*unsafe.Pointer)(unsafe.Pointer(&goSlice3[0]))))
	(*ioValue) = (*ioValue)[:cap(*ioValue)]
	for i := 0; i < len(*ioValue); i++ {
		if goSlice1[i] == nil {
			(*ioValue) = (*ioValue)[:i]
			break
		}
		if (*ioValue)[i] == nil {
			(*ioValue)[i] = &Id{}
			runtime.SetFinalizer((*ioValue)[i], func(o *Id) {
				o.Release()
			})
		}
		(*ioValue)[i].ptr = goSlice1[i]
	}
	(*outError) = (*outError)[:cap(*outError)]
	for i := 0; i < len(*outError); i++ {
		if goSlice3[i] == nil {
			(*outError) = (*outError)[:i]
			break
		}
		if (*outError)[i] == nil {
			(*outError)[i] = &NSError{}
			runtime.SetFinalizer((*outError)[i], func(o *NSError) {
				o.Release()
			})
		}
		(*outError)[i].ptr = goSlice3[i]
	}
	runtime.KeepAlive(o)
	return ret
}

func (o *NSEnumerator) ValidateValueForKeyPathError(ioValue *[]*Id, inKeyPath *NSString, outError *[]*NSError) bool {

	goSlice1 := make([]unsafe.Pointer,cap(*ioValue))
	for i := 0; i < len(*ioValue); i++ {
		goSlice1[i] = (*ioValue)[i].Ptr()
	}

	goSlice3 := make([]unsafe.Pointer,cap(*outError))
	for i := 0; i < len(*outError); i++ {
		goSlice3[i] = (*outError)[i].Ptr()
	}
	ret := (bool)(C.NSEnumerator_inst_ValidateValueForKeyPathError(o.Ptr(), (*unsafe.Pointer)(unsafe.Pointer(&goSlice1[0])), inKeyPath.Ptr(), (*unsafe.Pointer)(unsafe.Pointer(&goSlice3[0]))))
	(*ioValue) = (*ioValue)[:cap(*ioValue)]
	for i := 0; i < len(*ioValue); i++ {
		if goSlice1[i] == nil {
			(*ioValue) = (*ioValue)[:i]
			break
		}
		if (*ioValue)[i] == nil {
			(*ioValue)[i] = &Id{}
			runtime.SetFinalizer((*ioValue)[i], func(o *Id) {
				o.Release()
			})
		}
		(*ioValue)[i].ptr = goSlice1[i]
	}
	(*outError) = (*outError)[:cap(*outError)]
	for i := 0; i < len(*outError); i++ {
		if goSlice3[i] == nil {
			(*outError) = (*outError)[:i]
			break
		}
		if (*outError)[i] == nil {
			(*outError)[i] = &NSError{}
			runtime.SetFinalizer((*outError)[i], func(o *NSError) {
				o.Release()
			})
		}
		(*outError)[i].ptr = goSlice3[i]
	}
	runtime.KeepAlive(o)
	return ret
}

func (o *NSEnumerator) ReplacementObjectForCoder(coder *NSCoder) *Id {
	ret := &Id{}
	ret.ptr = unsafe.Pointer(C.NSEnumerator_inst_ReplacementObjectForCoder(o.Ptr(), coder.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *Id) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *NSEnumerator) ReplaceValueAtIndexInPropertyWithKey(index NSUInteger, key *NSString, value NSObject)  {
	C.NSEnumerator_inst_ReplaceValueAtIndexInPropertyWithKey(o.Ptr(), (C.NSUInteger)(index), key.Ptr(), value.Ptr())
	runtime.KeepAlive(o)
}

func (o *NSEnumerator) ReplaceValueAtIndexInPropertyWithKeyWithValue(index NSUInteger, key *NSString, value NSObject)  {
	C.NSEnumerator_inst_ReplaceValueAtIndexInPropertyWithKeyWithValue(o.Ptr(), (C.NSUInteger)(index), key.Ptr(), value.Ptr())
	runtime.KeepAlive(o)
}

func NSAutoreleasePoolCancelPreviousPerformRequestsWithTarget(aTarget NSObject)  {
	C.NSAutoreleasePool_CancelPreviousPerformRequestsWithTarget(aTarget.Ptr())
}

func NSAutoreleasePoolCancelPreviousPerformRequestsWithTargetSelector(aTarget NSObject, aSelector SEL, anArgument NSObject)  {
	C.NSAutoreleasePool_CancelPreviousPerformRequestsWithTargetSelector(aTarget.Ptr(), unsafe.Pointer(aSelector), anArgument.Ptr())
}

func NSAutoreleasePoolCancelPreviousPerformRequestsWithTargetSelectorObject(aTarget NSObject, aSelector SEL, anArgument NSObject)  {
	C.NSAutoreleasePool_CancelPreviousPerformRequestsWithTargetSelectorObject(aTarget.Ptr(), unsafe.Pointer(aSelector), anArgument.Ptr())
}

func NSAutoreleasePoolKeyPathsForValuesAffectingValueForKey(key *NSString) *NSSet {
	ret := &NSSet{}
	ret.ptr = unsafe.Pointer(C.NSAutoreleasePool_KeyPathsForValuesAffectingValueForKey(key.Ptr()))
	if ret.ptr == nil { return ret }
	return ret
}

func NSAutoreleasePoolResolveInstanceMethod(sel SEL) bool {
	ret := (bool)(C.NSAutoreleasePool_ResolveInstanceMethod(unsafe.Pointer(sel)))
	return ret
}

func NSAutoreleasePoolAlloc() *NSAutoreleasePool {
	ret := &NSAutoreleasePool{}
	ret.ptr = unsafe.Pointer(C.NSAutoreleasePool_Alloc())
	if ret.ptr == nil { return ret }
	runtime.SetFinalizer(ret, func(o *NSAutoreleasePool) {
		o.Release()
	})
	return ret
}

func (o *NSAutoreleasePool) GC() {
	if o.ptr == nil { return }
	runtime.SetFinalizer(o, func(o *NSAutoreleasePool) {
		o.Release()
	})
	runtime.KeepAlive(o)
}

func NSAutoreleasePoolSuperclass() Class {
	ret := (Class)(unsafe.Pointer(C.NSAutoreleasePool_Superclass()))
	return ret
}

func NSAutoreleasePoolAllocWithZone(zone *_NSZone) *NSAutoreleasePool {
	ret := &NSAutoreleasePool{}
	ret.ptr = unsafe.Pointer(C.NSAutoreleasePool_AllocWithZone(unsafe.Pointer(zone)))
	if ret.ptr == nil { return ret }
	runtime.SetFinalizer(ret, func(o *NSAutoreleasePool) {
		o.Release()
	})
	return ret
}

func NSAutoreleasePoolMutableCopyWithZone(zone *_NSZone) *Id {
	ret := &Id{}
	ret.ptr = unsafe.Pointer(C.NSAutoreleasePool_MutableCopyWithZone(unsafe.Pointer(zone)))
	if ret.ptr == nil { return ret }
	runtime.SetFinalizer(ret, func(o *Id) {
		o.Release()
	})
	return ret
}

func NSAutoreleasePoolAccessInstanceVariablesDirectly() bool {
	ret := (bool)(C.NSAutoreleasePool_AccessInstanceVariablesDirectly())
	return ret
}

func NSAutoreleasePoolConformsToProtocol(protocol Protocol) bool {
	ret := (bool)(C.NSAutoreleasePool_ConformsToProtocol(protocol.Ptr()))
	return ret
}

func NSAutoreleasePoolResolveClassMethod(sel SEL) bool {
	ret := (bool)(C.NSAutoreleasePool_ResolveClassMethod(unsafe.Pointer(sel)))
	return ret
}

func NSAutoreleasePoolDebugDescription() *NSString {
	ret := &NSString{}
	ret.ptr = unsafe.Pointer(C.NSAutoreleasePool_DebugDescription())
	if ret.ptr == nil { return ret }
	return ret
}

func NSAutoreleasePoolVersion() NSInteger {
	ret := (NSInteger)(C.NSAutoreleasePool_Version())
	return ret
}

func NSAutoreleasePoolSetVersion(aVersion NSInteger)  {
	C.NSAutoreleasePool_SetVersion((C.NSInteger)(aVersion))
}

func NSAutoreleasePoolClass() Class {
	ret := (Class)(unsafe.Pointer(C.NSAutoreleasePool_Class()))
	return ret
}

func NSAutoreleasePoolCopyWithZone(zone *_NSZone) *Id {
	ret := &Id{}
	ret.ptr = unsafe.Pointer(C.NSAutoreleasePool_CopyWithZone(unsafe.Pointer(zone)))
	if ret.ptr == nil { return ret }
	runtime.SetFinalizer(ret, func(o *Id) {
		o.Release()
	})
	return ret
}

func NSAutoreleasePoolDescription() *NSString {
	ret := &NSString{}
	ret.ptr = unsafe.Pointer(C.NSAutoreleasePool_Description())
	if ret.ptr == nil { return ret }
	return ret
}

func NSAutoreleasePoolAddObject(anObject NSObject)  {
	C.NSAutoreleasePool_AddObject(anObject.Ptr())
}

func NSAutoreleasePoolClassFallbacksForKeyedArchiver() *NSArray {
	ret := &NSArray{}
	ret.ptr = unsafe.Pointer(C.NSAutoreleasePool_ClassFallbacksForKeyedArchiver())
	if ret.ptr == nil { return ret }
	return ret
}

func NSAutoreleasePoolClassForKeyedUnarchiver() Class {
	ret := (Class)(unsafe.Pointer(C.NSAutoreleasePool_ClassForKeyedUnarchiver()))
	return ret
}

func NSAutoreleasePoolHash() NSUInteger {
	ret := (NSUInteger)(C.NSAutoreleasePool_Hash())
	return ret
}

func NSAutoreleasePoolIsSubclassOfClass(aClass Class) bool {
	ret := (bool)(C.NSAutoreleasePool_IsSubclassOfClass(unsafe.Pointer(aClass)))
	return ret
}

func NSAutoreleasePoolAutomaticallyNotifiesObserversForKey(key *NSString) bool {
	ret := (bool)(C.NSAutoreleasePool_AutomaticallyNotifiesObserversForKey(key.Ptr()))
	return ret
}

func NSAutoreleasePoolLoad()  {
	C.NSAutoreleasePool_Load()
}

func NSAutoreleasePoolInstanceMethodSignatureForSelector(aSelector SEL) *NSMethodSignature {
	ret := &NSMethodSignature{}
	ret.ptr = unsafe.Pointer(C.NSAutoreleasePool_InstanceMethodSignatureForSelector(unsafe.Pointer(aSelector)))
	if ret.ptr == nil { return ret }
	return ret
}

func NSAutoreleasePoolInstancesRespondToSelector(aSelector SEL) bool {
	ret := (bool)(C.NSAutoreleasePool_InstancesRespondToSelector(unsafe.Pointer(aSelector)))
	return ret
}

func NSAutoreleasePoolNew() *NSAutoreleasePool {
	ret := &NSAutoreleasePool{}
	ret.ptr = unsafe.Pointer(C.NSAutoreleasePool_New())
	if ret.ptr == nil { return ret }
	runtime.SetFinalizer(ret, func(o *NSAutoreleasePool) {
		o.Release()
	})
	return ret
}

func (o *NSAutoreleasePool) IsEqualTo(object NSObject) bool {
	ret := (bool)(C.NSAutoreleasePool_inst_IsEqualTo(o.Ptr(), object.Ptr()))
	runtime.KeepAlive(o)
	return ret
}

func (o *NSAutoreleasePool) IsGreaterThan(object NSObject) bool {
	ret := (bool)(C.NSAutoreleasePool_inst_IsGreaterThan(o.Ptr(), object.Ptr()))
	runtime.KeepAlive(o)
	return ret
}

func (o *NSAutoreleasePool) AttributeKeys() *NSArray {
	ret := &NSArray{}
	ret.ptr = unsafe.Pointer(C.NSAutoreleasePool_inst_AttributeKeys(o.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSArray)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *NSArray) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *NSAutoreleasePool) ClassDescription() *NSClassDescription {
	ret := &NSClassDescription{}
	ret.ptr = unsafe.Pointer(C.NSAutoreleasePool_inst_ClassDescription(o.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSClassDescription)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *NSClassDescription) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *NSAutoreleasePool) AwakeAfterUsingCoder(coder *NSCoder) *Id {
	ret := &Id{}
	ret.ptr = unsafe.Pointer(C.NSAutoreleasePool_inst_AwakeAfterUsingCoder(o.Ptr(), coder.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *Id) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *NSAutoreleasePool) MutableSetValueForKeyPath(keyPath *NSString) *NSMutableSet {
	ret := &NSMutableSet{}
	ret.ptr = unsafe.Pointer(C.NSAutoreleasePool_inst_MutableSetValueForKeyPath(o.Ptr(), keyPath.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSMutableSet)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *NSMutableSet) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *NSAutoreleasePool) IsGreaterThanOrEqualTo(object NSObject) bool {
	ret := (bool)(C.NSAutoreleasePool_inst_IsGreaterThanOrEqualTo(o.Ptr(), object.Ptr()))
	runtime.KeepAlive(o)
	return ret
}

func (o *NSAutoreleasePool) PerformSelectorOnMainThreadWithObject(aSelector SEL, arg NSObject, wait BOOL)  {
	C.NSAutoreleasePool_inst_PerformSelectorOnMainThreadWithObject(o.Ptr(), unsafe.Pointer(aSelector), arg.Ptr(), (C.BOOL)(wait))
	runtime.KeepAlive(o)
}

func (o *NSAutoreleasePool) PerformSelectorOnMainThreadWithObjectWaitUntilDone(aSelector SEL, arg NSObject, wait BOOL)  {
	C.NSAutoreleasePool_inst_PerformSelectorOnMainThreadWithObjectWaitUntilDone(o.Ptr(), unsafe.Pointer(aSelector), arg.Ptr(), (C.BOOL)(wait))
	runtime.KeepAlive(o)
}

func (o *NSAutoreleasePool) PerformSelectorOnMainThreadWithObjectWaitUntilDoneModes(aSelector SEL, arg NSObject, wait BOOL, array *NSArray)  {
	C.NSAutoreleasePool_inst_PerformSelectorOnMainThreadWithObjectWaitUntilDoneModes(o.Ptr(), unsafe.Pointer(aSelector), arg.Ptr(), (C.BOOL)(wait), array.Ptr())
	runtime.KeepAlive(o)
}

func (o *NSAutoreleasePool) IsLike(object *NSString) bool {
	ret := (bool)(C.NSAutoreleasePool_inst_IsLike(o.Ptr(), object.Ptr()))
	runtime.KeepAlive(o)
	return ret
}

func (o *NSAutoreleasePool) SetScriptingProperties(scriptingProperties *NSDictionary)  {
	C.NSAutoreleasePool_inst_SetScriptingProperties(o.Ptr(), scriptingProperties.Ptr())
	runtime.KeepAlive(o)
}

func (o *NSAutoreleasePool) InsertValueInPropertyWithKey(value NSObject, key *NSString)  {
	C.NSAutoreleasePool_inst_InsertValueInPropertyWithKey(o.Ptr(), value.Ptr(), key.Ptr())
	runtime.KeepAlive(o)
}

func (o *NSAutoreleasePool) InsertValueAtIndex(value NSObject, index NSUInteger, key *NSString)  {
	C.NSAutoreleasePool_inst_InsertValueAtIndex(o.Ptr(), value.Ptr(), (C.NSUInteger)(index), key.Ptr())
	runtime.KeepAlive(o)
}

func (o *NSAutoreleasePool) InsertValueAtIndexInPropertyWithKey(value NSObject, index NSUInteger, key *NSString)  {
	C.NSAutoreleasePool_inst_InsertValueAtIndexInPropertyWithKey(o.Ptr(), value.Ptr(), (C.NSUInteger)(index), key.Ptr())
	runtime.KeepAlive(o)
}

func (o *NSAutoreleasePool) DoesContain(object NSObject) bool {
	ret := (bool)(C.NSAutoreleasePool_inst_DoesContain(o.Ptr(), object.Ptr()))
	runtime.KeepAlive(o)
	return ret
}

func (o *NSAutoreleasePool) ValidateValueForKey(ioValue *[]*Id, inKey *NSString, outError *[]*NSError) bool {

	goSlice1 := make([]unsafe.Pointer,cap(*ioValue))
	for i := 0; i < len(*ioValue); i++ {
		goSlice1[i] = (*ioValue)[i].Ptr()
	}

	goSlice3 := make([]unsafe.Pointer,cap(*outError))
	for i := 0; i < len(*outError); i++ {
		goSlice3[i] = (*outError)[i].Ptr()
	}
	ret := (bool)(C.NSAutoreleasePool_inst_ValidateValueForKey(o.Ptr(), (*unsafe.Pointer)(unsafe.Pointer(&goSlice1[0])), inKey.Ptr(), (*unsafe.Pointer)(unsafe.Pointer(&goSlice3[0]))))
	(*ioValue) = (*ioValue)[:cap(*ioValue)]
	for i := 0; i < len(*ioValue); i++ {
		if goSlice1[i] == nil {
			(*ioValue) = (*ioValue)[:i]
			break
		}
		if (*ioValue)[i] == nil {
			(*ioValue)[i] = &Id{}
			runtime.SetFinalizer((*ioValue)[i], func(o *Id) {
				o.Release()
			})
		}
		(*ioValue)[i].ptr = goSlice1[i]
	}
	(*outError) = (*outError)[:cap(*outError)]
	for i := 0; i < len(*outError); i++ {
		if goSlice3[i] == nil {
			(*outError) = (*outError)[:i]
			break
		}
		if (*outError)[i] == nil {
			(*outError)[i] = &NSError{}
			runtime.SetFinalizer((*outError)[i], func(o *NSError) {
				o.Release()
			})
		}
		(*outError)[i].ptr = goSlice3[i]
	}
	runtime.KeepAlive(o)
	return ret
}

func (o *NSAutoreleasePool) ValidateValueForKeyPath(ioValue *[]*Id, inKeyPath *NSString, outError *[]*NSError) bool {

	goSlice1 := make([]unsafe.Pointer,cap(*ioValue))
	for i := 0; i < len(*ioValue); i++ {
		goSlice1[i] = (*ioValue)[i].Ptr()
	}

	goSlice3 := make([]unsafe.Pointer,cap(*outError))
	for i := 0; i < len(*outError); i++ {
		goSlice3[i] = (*outError)[i].Ptr()
	}
	ret := (bool)(C.NSAutoreleasePool_inst_ValidateValueForKeyPath(o.Ptr(), (*unsafe.Pointer)(unsafe.Pointer(&goSlice1[0])), inKeyPath.Ptr(), (*unsafe.Pointer)(unsafe.Pointer(&goSlice3[0]))))
	(*ioValue) = (*ioValue)[:cap(*ioValue)]
	for i := 0; i < len(*ioValue); i++ {
		if goSlice1[i] == nil {
			(*ioValue) = (*ioValue)[:i]
			break
		}
		if (*ioValue)[i] == nil {
			(*ioValue)[i] = &Id{}
			runtime.SetFinalizer((*ioValue)[i], func(o *Id) {
				o.Release()
			})
		}
		(*ioValue)[i].ptr = goSlice1[i]
	}
	(*outError) = (*outError)[:cap(*outError)]
	for i := 0; i < len(*outError); i++ {
		if goSlice3[i] == nil {
			(*outError) = (*outError)[:i]
			break
		}
		if (*outError)[i] == nil {
			(*outError)[i] = &NSError{}
			runtime.SetFinalizer((*outError)[i], func(o *NSError) {
				o.Release()
			})
		}
		(*outError)[i].ptr = goSlice3[i]
	}
	runtime.KeepAlive(o)
	return ret
}

func (o *NSAutoreleasePool) ValidateValueForKeyError(ioValue *[]*Id, inKey *NSString, outError *[]*NSError) bool {

	goSlice1 := make([]unsafe.Pointer,cap(*ioValue))
	for i := 0; i < len(*ioValue); i++ {
		goSlice1[i] = (*ioValue)[i].Ptr()
	}

	goSlice3 := make([]unsafe.Pointer,cap(*outError))
	for i := 0; i < len(*outError); i++ {
		goSlice3[i] = (*outError)[i].Ptr()
	}
	ret := (bool)(C.NSAutoreleasePool_inst_ValidateValueForKeyError(o.Ptr(), (*unsafe.Pointer)(unsafe.Pointer(&goSlice1[0])), inKey.Ptr(), (*unsafe.Pointer)(unsafe.Pointer(&goSlice3[0]))))
	(*ioValue) = (*ioValue)[:cap(*ioValue)]
	for i := 0; i < len(*ioValue); i++ {
		if goSlice1[i] == nil {
			(*ioValue) = (*ioValue)[:i]
			break
		}
		if (*ioValue)[i] == nil {
			(*ioValue)[i] = &Id{}
			runtime.SetFinalizer((*ioValue)[i], func(o *Id) {
				o.Release()
			})
		}
		(*ioValue)[i].ptr = goSlice1[i]
	}
	(*outError) = (*outError)[:cap(*outError)]
	for i := 0; i < len(*outError); i++ {
		if goSlice3[i] == nil {
			(*outError) = (*outError)[:i]
			break
		}
		if (*outError)[i] == nil {
			(*outError)[i] = &NSError{}
			runtime.SetFinalizer((*outError)[i], func(o *NSError) {
				o.Release()
			})
		}
		(*outError)[i].ptr = goSlice3[i]
	}
	runtime.KeepAlive(o)
	return ret
}

func (o *NSAutoreleasePool) ValidateValueForKeyPathError(ioValue *[]*Id, inKeyPath *NSString, outError *[]*NSError) bool {

	goSlice1 := make([]unsafe.Pointer,cap(*ioValue))
	for i := 0; i < len(*ioValue); i++ {
		goSlice1[i] = (*ioValue)[i].Ptr()
	}

	goSlice3 := make([]unsafe.Pointer,cap(*outError))
	for i := 0; i < len(*outError); i++ {
		goSlice3[i] = (*outError)[i].Ptr()
	}
	ret := (bool)(C.NSAutoreleasePool_inst_ValidateValueForKeyPathError(o.Ptr(), (*unsafe.Pointer)(unsafe.Pointer(&goSlice1[0])), inKeyPath.Ptr(), (*unsafe.Pointer)(unsafe.Pointer(&goSlice3[0]))))
	(*ioValue) = (*ioValue)[:cap(*ioValue)]
	for i := 0; i < len(*ioValue); i++ {
		if goSlice1[i] == nil {
			(*ioValue) = (*ioValue)[:i]
			break
		}
		if (*ioValue)[i] == nil {
			(*ioValue)[i] = &Id{}
			runtime.SetFinalizer((*ioValue)[i], func(o *Id) {
				o.Release()
			})
		}
		(*ioValue)[i].ptr = goSlice1[i]
	}
	(*outError) = (*outError)[:cap(*outError)]
	for i := 0; i < len(*outError); i++ {
		if goSlice3[i] == nil {
			(*outError) = (*outError)[:i]
			break
		}
		if (*outError)[i] == nil {
			(*outError)[i] = &NSError{}
			runtime.SetFinalizer((*outError)[i], func(o *NSError) {
				o.Release()
			})
		}
		(*outError)[i].ptr = goSlice3[i]
	}
	runtime.KeepAlive(o)
	return ret
}

func (o *NSAutoreleasePool) CopyScriptingValueForKey(value NSObject, key *NSString, properties *NSDictionary) *Id {
	ret := &Id{}
	ret.ptr = unsafe.Pointer(C.NSAutoreleasePool_inst_CopyScriptingValueForKey(o.Ptr(), value.Ptr(), key.Ptr(), properties.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *Id) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *NSAutoreleasePool) CopyScriptingValueForKeyWithProperties(value NSObject, key *NSString, properties *NSDictionary) *Id {
	ret := &Id{}
	ret.ptr = unsafe.Pointer(C.NSAutoreleasePool_inst_CopyScriptingValueForKeyWithProperties(o.Ptr(), value.Ptr(), key.Ptr(), properties.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *Id) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *NSAutoreleasePool) DoesNotRecognizeSelector(aSelector SEL)  {
	C.NSAutoreleasePool_inst_DoesNotRecognizeSelector(o.Ptr(), unsafe.Pointer(aSelector))
	runtime.KeepAlive(o)
}

func (o *NSAutoreleasePool) ClassCode() FourCharCode {
	ret := (FourCharCode)(C.NSAutoreleasePool_inst_ClassCode(o.Ptr()))
	runtime.KeepAlive(o)
	return ret
}

func (o *NSAutoreleasePool) Init() *NSAutoreleasePool {
	ret := &NSAutoreleasePool{}
	ret.ptr = unsafe.Pointer(C.NSAutoreleasePool_inst_Init(o.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSAutoreleasePool)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *NSAutoreleasePool) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *NSAutoreleasePool) AddObserverForKeyPath(observer NSObject, keyPath *NSString, options NSKeyValueObservingOptions, context unsafe.Pointer)  {
	C.NSAutoreleasePool_inst_AddObserverForKeyPath(o.Ptr(), observer.Ptr(), keyPath.Ptr(), (C.NSKeyValueObservingOptions)(options), unsafe.Pointer(context))
	runtime.KeepAlive(o)
}

func (o *NSAutoreleasePool) AddObserverForKeyPathOptions(observer NSObject, keyPath *NSString, options NSKeyValueObservingOptions, context unsafe.Pointer)  {
	C.NSAutoreleasePool_inst_AddObserverForKeyPathOptions(o.Ptr(), observer.Ptr(), keyPath.Ptr(), (C.NSKeyValueObservingOptions)(options), unsafe.Pointer(context))
	runtime.KeepAlive(o)
}

func (o *NSAutoreleasePool) ToOneRelationshipKeys() *NSArray {
	ret := &NSArray{}
	ret.ptr = unsafe.Pointer(C.NSAutoreleasePool_inst_ToOneRelationshipKeys(o.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSArray)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *NSArray) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *NSAutoreleasePool) ReplaceValueAtIndexInPropertyWithKey(index NSUInteger, key *NSString, value NSObject)  {
	C.NSAutoreleasePool_inst_ReplaceValueAtIndexInPropertyWithKey(o.Ptr(), (C.NSUInteger)(index), key.Ptr(), value.Ptr())
	runtime.KeepAlive(o)
}

func (o *NSAutoreleasePool) ReplaceValueAtIndexInPropertyWithKeyWithValue(index NSUInteger, key *NSString, value NSObject)  {
	C.NSAutoreleasePool_inst_ReplaceValueAtIndexInPropertyWithKeyWithValue(o.Ptr(), (C.NSUInteger)(index), key.Ptr(), value.Ptr())
	runtime.KeepAlive(o)
}

func (o *NSAutoreleasePool) DidChangeValuesAtIndexes(changeKind NSKeyValueChange, indexes *NSIndexSet, key *NSString)  {
	C.NSAutoreleasePool_inst_DidChangeValuesAtIndexes(o.Ptr(), (C.NSKeyValueChange)(changeKind), indexes.Ptr(), key.Ptr())
	runtime.KeepAlive(o)
}

func (o *NSAutoreleasePool) DidChangeValuesAtIndexesForKey(changeKind NSKeyValueChange, indexes *NSIndexSet, key *NSString)  {
	C.NSAutoreleasePool_inst_DidChangeValuesAtIndexesForKey(o.Ptr(), (C.NSKeyValueChange)(changeKind), indexes.Ptr(), key.Ptr())
	runtime.KeepAlive(o)
}

func (o *NSAutoreleasePool) AttemptRecoveryFromErrorOptionIndex(error *NSError, recoveryOptionIndex NSUInteger) bool {
	ret := (bool)(C.NSAutoreleasePool_inst_AttemptRecoveryFromErrorOptionIndex(o.Ptr(), error.Ptr(), (C.NSUInteger)(recoveryOptionIndex)))
	runtime.KeepAlive(o)
	return ret
}

func (o *NSAutoreleasePool) AttemptRecoveryFromErrorOptionIndexDelegate(error *NSError, recoveryOptionIndex NSUInteger, delegate NSObject, didRecoverSelector SEL, contextInfo unsafe.Pointer)  {
	C.NSAutoreleasePool_inst_AttemptRecoveryFromErrorOptionIndexDelegate(o.Ptr(), error.Ptr(), (C.NSUInteger)(recoveryOptionIndex), delegate.Ptr(), unsafe.Pointer(didRecoverSelector), unsafe.Pointer(contextInfo))
	runtime.KeepAlive(o)
}

func (o *NSAutoreleasePool) AttemptRecoveryFromErrorOptionIndexDelegateDidRecoverSelector(error *NSError, recoveryOptionIndex NSUInteger, delegate NSObject, didRecoverSelector SEL, contextInfo unsafe.Pointer)  {
	C.NSAutoreleasePool_inst_AttemptRecoveryFromErrorOptionIndexDelegateDidRecoverSelector(o.Ptr(), error.Ptr(), (C.NSUInteger)(recoveryOptionIndex), delegate.Ptr(), unsafe.Pointer(didRecoverSelector), unsafe.Pointer(contextInfo))
	runtime.KeepAlive(o)
}

func (o *NSAutoreleasePool) SetValuesForKeysWithDictionary(keyedValues *NSDictionary)  {
	C.NSAutoreleasePool_inst_SetValuesForKeysWithDictionary(o.Ptr(), keyedValues.Ptr())
	runtime.KeepAlive(o)
}

func (o *NSAutoreleasePool) DictionaryWithValuesForKeys(keys *NSArray) *NSDictionary {
	ret := &NSDictionary{}
	ret.ptr = unsafe.Pointer(C.NSAutoreleasePool_inst_DictionaryWithValuesForKeys(o.Ptr(), keys.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSDictionary)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *NSDictionary) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *NSAutoreleasePool) Copy() *Id {
	ret := &Id{}
	ret.ptr = unsafe.Pointer(C.NSAutoreleasePool_inst_Copy(o.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	runtime.SetFinalizer(ret, func(o *Id) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *NSAutoreleasePool) MutableOrderedSetValueForKey(key *NSString) *NSMutableOrderedSet {
	ret := &NSMutableOrderedSet{}
	ret.ptr = unsafe.Pointer(C.NSAutoreleasePool_inst_MutableOrderedSetValueForKey(o.Ptr(), key.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSMutableOrderedSet)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *NSMutableOrderedSet) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *NSAutoreleasePool) RemoveObserverForKeyPath(observer NSObject, keyPath *NSString)  {
	C.NSAutoreleasePool_inst_RemoveObserverForKeyPath(o.Ptr(), observer.Ptr(), keyPath.Ptr())
	runtime.KeepAlive(o)
}

func (o *NSAutoreleasePool) RemoveObserverForKeyPathContext(observer NSObject, keyPath *NSString, context unsafe.Pointer)  {
	C.NSAutoreleasePool_inst_RemoveObserverForKeyPathContext(o.Ptr(), observer.Ptr(), keyPath.Ptr(), unsafe.Pointer(context))
	runtime.KeepAlive(o)
}

func (o *NSAutoreleasePool) ObjectSpecifier() *NSScriptObjectSpecifier {
	ret := &NSScriptObjectSpecifier{}
	ret.ptr = unsafe.Pointer(C.NSAutoreleasePool_inst_ObjectSpecifier(o.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSScriptObjectSpecifier)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *NSScriptObjectSpecifier) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *NSAutoreleasePool) ScriptingIsLessThan(object NSObject) bool {
	ret := (bool)(C.NSAutoreleasePool_inst_ScriptingIsLessThan(o.Ptr(), object.Ptr()))
	runtime.KeepAlive(o)
	return ret
}

func (o *NSAutoreleasePool) Drain()  {
	C.NSAutoreleasePool_inst_Drain(o.Ptr())
	runtime.KeepAlive(o)
}

func (o *NSAutoreleasePool) ObserveValueForKeyPathOfObject(keyPath *NSString, object NSObject, change *NSDictionary, context unsafe.Pointer)  {
	C.NSAutoreleasePool_inst_ObserveValueForKeyPathOfObject(o.Ptr(), keyPath.Ptr(), object.Ptr(), change.Ptr(), unsafe.Pointer(context))
	runtime.KeepAlive(o)
}

func (o *NSAutoreleasePool) ObserveValueForKeyPathOfObjectChange(keyPath *NSString, object NSObject, change *NSDictionary, context unsafe.Pointer)  {
	C.NSAutoreleasePool_inst_ObserveValueForKeyPathOfObjectChange(o.Ptr(), keyPath.Ptr(), object.Ptr(), change.Ptr(), unsafe.Pointer(context))
	runtime.KeepAlive(o)
}

func (o *NSAutoreleasePool) SetValueForKey(value NSObject, key *NSString)  {
	C.NSAutoreleasePool_inst_SetValueForKey(o.Ptr(), value.Ptr(), key.Ptr())
	runtime.KeepAlive(o)
}

func (o *NSAutoreleasePool) SetValueForKeyPath(value NSObject, keyPath *NSString)  {
	C.NSAutoreleasePool_inst_SetValueForKeyPath(o.Ptr(), value.Ptr(), keyPath.Ptr())
	runtime.KeepAlive(o)
}

func (o *NSAutoreleasePool) SetValueForUndefinedKey(value NSObject, key *NSString)  {
	C.NSAutoreleasePool_inst_SetValueForUndefinedKey(o.Ptr(), value.Ptr(), key.Ptr())
	runtime.KeepAlive(o)
}

func (o *NSAutoreleasePool) SetObservationInfo(observationInfo unsafe.Pointer)  {
	C.NSAutoreleasePool_inst_SetObservationInfo(o.Ptr(), unsafe.Pointer(observationInfo))
	runtime.KeepAlive(o)
}

func (o *NSAutoreleasePool) SetNilValueForKey(key *NSString)  {
	C.NSAutoreleasePool_inst_SetNilValueForKey(o.Ptr(), key.Ptr())
	runtime.KeepAlive(o)
}

func (o *NSAutoreleasePool) ClassForCoder() Class {
	ret := (Class)(unsafe.Pointer(C.NSAutoreleasePool_inst_ClassForCoder(o.Ptr())))
	runtime.KeepAlive(o)
	return ret
}

func (o *NSAutoreleasePool) ValueForKey(key *NSString) *Id {
	ret := &Id{}
	ret.ptr = unsafe.Pointer(C.NSAutoreleasePool_inst_ValueForKey(o.Ptr(), key.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *Id) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *NSAutoreleasePool) RemoveValueAtIndexFromPropertyWithKey(index NSUInteger, key *NSString)  {
	C.NSAutoreleasePool_inst_RemoveValueAtIndexFromPropertyWithKey(o.Ptr(), (C.NSUInteger)(index), key.Ptr())
	runtime.KeepAlive(o)
}

func (o *NSAutoreleasePool) ClassForKeyedArchiver() Class {
	ret := (Class)(unsafe.Pointer(C.NSAutoreleasePool_inst_ClassForKeyedArchiver(o.Ptr())))
	runtime.KeepAlive(o)
	return ret
}

func (o *NSAutoreleasePool) ValueWithNameInPropertyWithKey(name *NSString, key *NSString) *Id {
	ret := &Id{}
	ret.ptr = unsafe.Pointer(C.NSAutoreleasePool_inst_ValueWithNameInPropertyWithKey(o.Ptr(), name.Ptr(), key.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *Id) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *NSAutoreleasePool) NewScriptingObjectOfClassForValueForKey(objectClass Class, key *NSString, contentsValue NSObject, properties *NSDictionary) *Id {
	ret := &Id{}
	ret.ptr = unsafe.Pointer(C.NSAutoreleasePool_inst_NewScriptingObjectOfClassForValueForKey(o.Ptr(), unsafe.Pointer(objectClass), key.Ptr(), contentsValue.Ptr(), properties.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *Id) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *NSAutoreleasePool) NewScriptingObjectOfClassForValueForKeyWithContentsValue(objectClass Class, key *NSString, contentsValue NSObject, properties *NSDictionary) *Id {
	ret := &Id{}
	ret.ptr = unsafe.Pointer(C.NSAutoreleasePool_inst_NewScriptingObjectOfClassForValueForKeyWithContentsValue(o.Ptr(), unsafe.Pointer(objectClass), key.Ptr(), contentsValue.Ptr(), properties.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *Id) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *NSAutoreleasePool) ClassName() *NSString {
	ret := &NSString{}
	ret.ptr = unsafe.Pointer(C.NSAutoreleasePool_inst_ClassName(o.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSString)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *NSString) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *NSAutoreleasePool) IsLessThanOrEqualTo(object NSObject) bool {
	ret := (bool)(C.NSAutoreleasePool_inst_IsLessThanOrEqualTo(o.Ptr(), object.Ptr()))
	runtime.KeepAlive(o)
	return ret
}

func (o *NSAutoreleasePool) ScriptingEndsWith(object NSObject) bool {
	ret := (bool)(C.NSAutoreleasePool_inst_ScriptingEndsWith(o.Ptr(), object.Ptr()))
	runtime.KeepAlive(o)
	return ret
}

func (o *NSAutoreleasePool) PerformSelectorWithObject(aSelector SEL, anArgument NSObject, delay NSTimeInterval)  {
	C.NSAutoreleasePool_inst_PerformSelectorWithObject(o.Ptr(), unsafe.Pointer(aSelector), anArgument.Ptr(), (C.NSTimeInterval)(delay))
	runtime.KeepAlive(o)
}

func (o *NSAutoreleasePool) PerformSelectorWithObjectAfterDelay(aSelector SEL, anArgument NSObject, delay NSTimeInterval)  {
	C.NSAutoreleasePool_inst_PerformSelectorWithObjectAfterDelay(o.Ptr(), unsafe.Pointer(aSelector), anArgument.Ptr(), (C.NSTimeInterval)(delay))
	runtime.KeepAlive(o)
}

func (o *NSAutoreleasePool) PerformSelectorWithObjectAfterDelayInModes(aSelector SEL, anArgument NSObject, delay NSTimeInterval, modes *NSArray)  {
	C.NSAutoreleasePool_inst_PerformSelectorWithObjectAfterDelayInModes(o.Ptr(), unsafe.Pointer(aSelector), anArgument.Ptr(), (C.NSTimeInterval)(delay), modes.Ptr())
	runtime.KeepAlive(o)
}

func (o *NSAutoreleasePool) PerformSelectorOnThread(aSelector SEL, thr *NSThread, arg NSObject, wait BOOL)  {
	C.NSAutoreleasePool_inst_PerformSelectorOnThread(o.Ptr(), unsafe.Pointer(aSelector), thr.Ptr(), arg.Ptr(), (C.BOOL)(wait))
	runtime.KeepAlive(o)
}

func (o *NSAutoreleasePool) PerformSelectorOnThreadWithObject(aSelector SEL, thr *NSThread, arg NSObject, wait BOOL)  {
	C.NSAutoreleasePool_inst_PerformSelectorOnThreadWithObject(o.Ptr(), unsafe.Pointer(aSelector), thr.Ptr(), arg.Ptr(), (C.BOOL)(wait))
	runtime.KeepAlive(o)
}

func (o *NSAutoreleasePool) PerformSelectorOnThreadWithObjectWaitUntilDone(aSelector SEL, thr *NSThread, arg NSObject, wait BOOL, array *NSArray)  {
	C.NSAutoreleasePool_inst_PerformSelectorOnThreadWithObjectWaitUntilDone(o.Ptr(), unsafe.Pointer(aSelector), thr.Ptr(), arg.Ptr(), (C.BOOL)(wait), array.Ptr())
	runtime.KeepAlive(o)
}

func (o *NSAutoreleasePool) PerformSelectorOnThreadWithObjectWaitUntilDoneModes(aSelector SEL, thr *NSThread, arg NSObject, wait BOOL, array *NSArray)  {
	C.NSAutoreleasePool_inst_PerformSelectorOnThreadWithObjectWaitUntilDoneModes(o.Ptr(), unsafe.Pointer(aSelector), thr.Ptr(), arg.Ptr(), (C.BOOL)(wait), array.Ptr())
	runtime.KeepAlive(o)
}

func (o *NSAutoreleasePool) ScriptingIsLessThanOrEqualTo(object NSObject) bool {
	ret := (bool)(C.NSAutoreleasePool_inst_ScriptingIsLessThanOrEqualTo(o.Ptr(), object.Ptr()))
	runtime.KeepAlive(o)
	return ret
}

func (o *NSAutoreleasePool) ValueWithUniqueIDInPropertyWithKey(uniqueID NSObject, key *NSString) *Id {
	ret := &Id{}
	ret.ptr = unsafe.Pointer(C.NSAutoreleasePool_inst_ValueWithUniqueIDInPropertyWithKey(o.Ptr(), uniqueID.Ptr(), key.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *Id) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *NSAutoreleasePool) ForwardingTargetForSelector(aSelector SEL) *Id {
	ret := &Id{}
	ret.ptr = unsafe.Pointer(C.NSAutoreleasePool_inst_ForwardingTargetForSelector(o.Ptr(), unsafe.Pointer(aSelector)))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *Id) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *NSAutoreleasePool) AutoContentAccessingProxy() *Id {
	ret := &Id{}
	ret.ptr = unsafe.Pointer(C.NSAutoreleasePool_inst_AutoContentAccessingProxy(o.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *Id) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *NSAutoreleasePool) ValueAtIndexInPropertyWithKey(index NSUInteger, key *NSString) *Id {
	ret := &Id{}
	ret.ptr = unsafe.Pointer(C.NSAutoreleasePool_inst_ValueAtIndexInPropertyWithKey(o.Ptr(), (C.NSUInteger)(index), key.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *Id) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *NSAutoreleasePool) AddObject(anObject NSObject)  {
	C.NSAutoreleasePool_inst_AddObject(o.Ptr(), anObject.Ptr())
	runtime.KeepAlive(o)
}

func (o *NSAutoreleasePool) PerformSelectorInBackgroundWithObject(aSelector SEL, arg NSObject)  {
	C.NSAutoreleasePool_inst_PerformSelectorInBackgroundWithObject(o.Ptr(), unsafe.Pointer(aSelector), arg.Ptr())
	runtime.KeepAlive(o)
}

func (o *NSAutoreleasePool) ReplacementObjectForCoder(coder *NSCoder) *Id {
	ret := &Id{}
	ret.ptr = unsafe.Pointer(C.NSAutoreleasePool_inst_ReplacementObjectForCoder(o.Ptr(), coder.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *Id) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *NSAutoreleasePool) WillChangeValuesAtIndexes(changeKind NSKeyValueChange, indexes *NSIndexSet, key *NSString)  {
	C.NSAutoreleasePool_inst_WillChangeValuesAtIndexes(o.Ptr(), (C.NSKeyValueChange)(changeKind), indexes.Ptr(), key.Ptr())
	runtime.KeepAlive(o)
}

func (o *NSAutoreleasePool) WillChangeValuesAtIndexesForKey(changeKind NSKeyValueChange, indexes *NSIndexSet, key *NSString)  {
	C.NSAutoreleasePool_inst_WillChangeValuesAtIndexesForKey(o.Ptr(), (C.NSKeyValueChange)(changeKind), indexes.Ptr(), key.Ptr())
	runtime.KeepAlive(o)
}

func (o *NSAutoreleasePool) ObservationInfo() unsafe.Pointer {
	ret := (unsafe.Pointer)(unsafe.Pointer(C.NSAutoreleasePool_inst_ObservationInfo(o.Ptr())))
	runtime.KeepAlive(o)
	return ret
}

func (o *NSAutoreleasePool) ValueForUndefinedKey(key *NSString) *Id {
	ret := &Id{}
	ret.ptr = unsafe.Pointer(C.NSAutoreleasePool_inst_ValueForUndefinedKey(o.Ptr(), key.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *Id) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *NSAutoreleasePool) ValueForKeyPath(keyPath *NSString) *Id {
	ret := &Id{}
	ret.ptr = unsafe.Pointer(C.NSAutoreleasePool_inst_ValueForKeyPath(o.Ptr(), keyPath.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *Id) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *NSAutoreleasePool) DidChangeValueForKey(key *NSString)  {
	C.NSAutoreleasePool_inst_DidChangeValueForKey(o.Ptr(), key.Ptr())
	runtime.KeepAlive(o)
}

func (o *NSAutoreleasePool) DidChangeValueForKeyWithSetMutation(key *NSString, mutationKind NSKeyValueSetMutationKind, objects *NSSet)  {
	C.NSAutoreleasePool_inst_DidChangeValueForKeyWithSetMutation(o.Ptr(), key.Ptr(), (C.NSKeyValueSetMutationKind)(mutationKind), objects.Ptr())
	runtime.KeepAlive(o)
}

func (o *NSAutoreleasePool) DidChangeValueForKeyWithSetMutationUsingObjects(key *NSString, mutationKind NSKeyValueSetMutationKind, objects *NSSet)  {
	C.NSAutoreleasePool_inst_DidChangeValueForKeyWithSetMutationUsingObjects(o.Ptr(), key.Ptr(), (C.NSKeyValueSetMutationKind)(mutationKind), objects.Ptr())
	runtime.KeepAlive(o)
}

func (o *NSAutoreleasePool) ScriptingValueForSpecifier(objectSpecifier *NSScriptObjectSpecifier) *Id {
	ret := &Id{}
	ret.ptr = unsafe.Pointer(C.NSAutoreleasePool_inst_ScriptingValueForSpecifier(o.Ptr(), objectSpecifier.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *Id) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *NSAutoreleasePool) MethodSignatureForSelector(aSelector SEL) *NSMethodSignature {
	ret := &NSMethodSignature{}
	ret.ptr = unsafe.Pointer(C.NSAutoreleasePool_inst_MethodSignatureForSelector(o.Ptr(), unsafe.Pointer(aSelector)))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSMethodSignature)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *NSMethodSignature) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *NSAutoreleasePool) MutableCopy() *Id {
	ret := &Id{}
	ret.ptr = unsafe.Pointer(C.NSAutoreleasePool_inst_MutableCopy(o.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	runtime.SetFinalizer(ret, func(o *Id) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *NSAutoreleasePool) ForwardInvocation(anInvocation *NSInvocation)  {
	C.NSAutoreleasePool_inst_ForwardInvocation(o.Ptr(), anInvocation.Ptr())
	runtime.KeepAlive(o)
}

func (o *NSAutoreleasePool) MutableSetValueForKey(key *NSString) *NSMutableSet {
	ret := &NSMutableSet{}
	ret.ptr = unsafe.Pointer(C.NSAutoreleasePool_inst_MutableSetValueForKey(o.Ptr(), key.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSMutableSet)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *NSMutableSet) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *NSAutoreleasePool) ScriptingContains(object NSObject) bool {
	ret := (bool)(C.NSAutoreleasePool_inst_ScriptingContains(o.Ptr(), object.Ptr()))
	runtime.KeepAlive(o)
	return ret
}

func (o *NSAutoreleasePool) MutableArrayValueForKeyPath(keyPath *NSString) *NSMutableArray {
	ret := &NSMutableArray{}
	ret.ptr = unsafe.Pointer(C.NSAutoreleasePool_inst_MutableArrayValueForKeyPath(o.Ptr(), keyPath.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSMutableArray)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *NSMutableArray) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *NSAutoreleasePool) IsLessThan(object NSObject) bool {
	ret := (bool)(C.NSAutoreleasePool_inst_IsLessThan(o.Ptr(), object.Ptr()))
	runtime.KeepAlive(o)
	return ret
}

func (o *NSAutoreleasePool) ScriptingIsEqualTo(object NSObject) bool {
	ret := (bool)(C.NSAutoreleasePool_inst_ScriptingIsEqualTo(o.Ptr(), object.Ptr()))
	runtime.KeepAlive(o)
	return ret
}

func (o *NSAutoreleasePool) IndicesOfObjectsByEvaluatingObjectSpecifier(specifier *NSScriptObjectSpecifier) *NSArray {
	ret := &NSArray{}
	ret.ptr = unsafe.Pointer(C.NSAutoreleasePool_inst_IndicesOfObjectsByEvaluatingObjectSpecifier(o.Ptr(), specifier.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSArray)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *NSArray) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *NSAutoreleasePool) IsCaseInsensitiveLike(object *NSString) bool {
	ret := (bool)(C.NSAutoreleasePool_inst_IsCaseInsensitiveLike(o.Ptr(), object.Ptr()))
	runtime.KeepAlive(o)
	return ret
}

func (o *NSAutoreleasePool) ScriptingIsGreaterThanOrEqualTo(object NSObject) bool {
	ret := (bool)(C.NSAutoreleasePool_inst_ScriptingIsGreaterThanOrEqualTo(o.Ptr(), object.Ptr()))
	runtime.KeepAlive(o)
	return ret
}

func (o *NSAutoreleasePool) MutableOrderedSetValueForKeyPath(keyPath *NSString) *NSMutableOrderedSet {
	ret := &NSMutableOrderedSet{}
	ret.ptr = unsafe.Pointer(C.NSAutoreleasePool_inst_MutableOrderedSetValueForKeyPath(o.Ptr(), keyPath.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSMutableOrderedSet)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *NSMutableOrderedSet) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *NSAutoreleasePool) MutableArrayValueForKey(key *NSString) *NSMutableArray {
	ret := &NSMutableArray{}
	ret.ptr = unsafe.Pointer(C.NSAutoreleasePool_inst_MutableArrayValueForKey(o.Ptr(), key.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSMutableArray)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *NSMutableArray) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *NSAutoreleasePool) ToManyRelationshipKeys() *NSArray {
	ret := &NSArray{}
	ret.ptr = unsafe.Pointer(C.NSAutoreleasePool_inst_ToManyRelationshipKeys(o.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSArray)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *NSArray) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *NSAutoreleasePool) Dealloc()  {
	C.NSAutoreleasePool_inst_Dealloc(o.Ptr())
	runtime.KeepAlive(o)
}

func (o *NSAutoreleasePool) ScriptingProperties() *NSDictionary {
	ret := &NSDictionary{}
	ret.ptr = unsafe.Pointer(C.NSAutoreleasePool_inst_ScriptingProperties(o.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSDictionary)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *NSDictionary) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *NSAutoreleasePool) WillChangeValueForKey(key *NSString)  {
	C.NSAutoreleasePool_inst_WillChangeValueForKey(o.Ptr(), key.Ptr())
	runtime.KeepAlive(o)
}

func (o *NSAutoreleasePool) WillChangeValueForKeyWithSetMutation(key *NSString, mutationKind NSKeyValueSetMutationKind, objects *NSSet)  {
	C.NSAutoreleasePool_inst_WillChangeValueForKeyWithSetMutation(o.Ptr(), key.Ptr(), (C.NSKeyValueSetMutationKind)(mutationKind), objects.Ptr())
	runtime.KeepAlive(o)
}

func (o *NSAutoreleasePool) WillChangeValueForKeyWithSetMutationUsingObjects(key *NSString, mutationKind NSKeyValueSetMutationKind, objects *NSSet)  {
	C.NSAutoreleasePool_inst_WillChangeValueForKeyWithSetMutationUsingObjects(o.Ptr(), key.Ptr(), (C.NSKeyValueSetMutationKind)(mutationKind), objects.Ptr())
	runtime.KeepAlive(o)
}

func (o *NSAutoreleasePool) IsNotEqualTo(object NSObject) bool {
	ret := (bool)(C.NSAutoreleasePool_inst_IsNotEqualTo(o.Ptr(), object.Ptr()))
	runtime.KeepAlive(o)
	return ret
}

func (o *NSAutoreleasePool) InverseForRelationshipKey(relationshipKey *NSString) *NSString {
	ret := &NSString{}
	ret.ptr = unsafe.Pointer(C.NSAutoreleasePool_inst_InverseForRelationshipKey(o.Ptr(), relationshipKey.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSString)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *NSString) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *NSAutoreleasePool) ClassForArchiver() Class {
	ret := (Class)(unsafe.Pointer(C.NSAutoreleasePool_inst_ClassForArchiver(o.Ptr())))
	runtime.KeepAlive(o)
	return ret
}

func (o *NSAutoreleasePool) ScriptingIsGreaterThan(object NSObject) bool {
	ret := (bool)(C.NSAutoreleasePool_inst_ScriptingIsGreaterThan(o.Ptr(), object.Ptr()))
	runtime.KeepAlive(o)
	return ret
}

func (o *NSAutoreleasePool) ReplacementObjectForKeyedArchiver(archiver *NSKeyedArchiver) *Id {
	ret := &Id{}
	ret.ptr = unsafe.Pointer(C.NSAutoreleasePool_inst_ReplacementObjectForKeyedArchiver(o.Ptr(), archiver.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *Id) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *NSAutoreleasePool) CoerceValueForKey(value NSObject, key *NSString) *Id {
	ret := &Id{}
	ret.ptr = unsafe.Pointer(C.NSAutoreleasePool_inst_CoerceValueForKey(o.Ptr(), value.Ptr(), key.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *Id) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *NSAutoreleasePool) ScriptingBeginsWith(object NSObject) bool {
	ret := (bool)(C.NSAutoreleasePool_inst_ScriptingBeginsWith(o.Ptr(), object.Ptr()))
	runtime.KeepAlive(o)
	return ret
}

func CBManagerClassFallbacksForKeyedArchiver() *NSArray {
	ret := &NSArray{}
	ret.ptr = unsafe.Pointer(C.CBManager_ClassFallbacksForKeyedArchiver())
	if ret.ptr == nil { return ret }
	return ret
}

func CBManagerSetVersion(aVersion NSInteger)  {
	C.CBManager_SetVersion((C.NSInteger)(aVersion))
}

func CBManagerKeyPathsForValuesAffectingValueForKey(key *NSString) *NSSet {
	ret := &NSSet{}
	ret.ptr = unsafe.Pointer(C.CBManager_KeyPathsForValuesAffectingValueForKey(key.Ptr()))
	if ret.ptr == nil { return ret }
	return ret
}

func CBManagerDescription() *NSString {
	ret := &NSString{}
	ret.ptr = unsafe.Pointer(C.CBManager_Description())
	if ret.ptr == nil { return ret }
	return ret
}

func CBManagerVersion() NSInteger {
	ret := (NSInteger)(C.CBManager_Version())
	return ret
}

func CBManagerAccessInstanceVariablesDirectly() bool {
	ret := (bool)(C.CBManager_AccessInstanceVariablesDirectly())
	return ret
}

func GetCBManagerAuthorization() CBManagerAuthorization {
	ret := (CBManagerAuthorization)(C.CBManager_Authorization())
	return ret
}

func CBManagerConformsToProtocol(protocol Protocol) bool {
	ret := (bool)(C.CBManager_ConformsToProtocol(protocol.Ptr()))
	return ret
}

func CBManagerCopyWithZone(zone *_NSZone) *Id {
	ret := &Id{}
	ret.ptr = unsafe.Pointer(C.CBManager_CopyWithZone(unsafe.Pointer(zone)))
	if ret.ptr == nil { return ret }
	runtime.SetFinalizer(ret, func(o *Id) {
		o.Release()
	})
	return ret
}

func CBManagerSuperclass() Class {
	ret := (Class)(unsafe.Pointer(C.CBManager_Superclass()))
	return ret
}

func CBManagerClassForKeyedUnarchiver() Class {
	ret := (Class)(unsafe.Pointer(C.CBManager_ClassForKeyedUnarchiver()))
	return ret
}

func CBManagerLoad()  {
	C.CBManager_Load()
}

func CBManagerIsSubclassOfClass(aClass Class) bool {
	ret := (bool)(C.CBManager_IsSubclassOfClass(unsafe.Pointer(aClass)))
	return ret
}

func CBManagerResolveClassMethod(sel SEL) bool {
	ret := (bool)(C.CBManager_ResolveClassMethod(unsafe.Pointer(sel)))
	return ret
}

func CBManagerAutomaticallyNotifiesObserversForKey(key *NSString) bool {
	ret := (bool)(C.CBManager_AutomaticallyNotifiesObserversForKey(key.Ptr()))
	return ret
}

func CBManagerNew() *CBManager {
	ret := &CBManager{}
	ret.ptr = unsafe.Pointer(C.CBManager_New())
	if ret.ptr == nil { return ret }
	runtime.SetFinalizer(ret, func(o *CBManager) {
		o.Release()
	})
	return ret
}

func CBManagerMutableCopyWithZone(zone *_NSZone) *Id {
	ret := &Id{}
	ret.ptr = unsafe.Pointer(C.CBManager_MutableCopyWithZone(unsafe.Pointer(zone)))
	if ret.ptr == nil { return ret }
	runtime.SetFinalizer(ret, func(o *Id) {
		o.Release()
	})
	return ret
}

func CBManagerAlloc() *CBManager {
	ret := &CBManager{}
	ret.ptr = unsafe.Pointer(C.CBManager_Alloc())
	if ret.ptr == nil { return ret }
	runtime.SetFinalizer(ret, func(o *CBManager) {
		o.Release()
	})
	return ret
}

func (o *CBManager) GC() {
	if o.ptr == nil { return }
	runtime.SetFinalizer(o, func(o *CBManager) {
		o.Release()
	})
	runtime.KeepAlive(o)
}

func CBManagerDebugDescription() *NSString {
	ret := &NSString{}
	ret.ptr = unsafe.Pointer(C.CBManager_DebugDescription())
	if ret.ptr == nil { return ret }
	return ret
}

func CBManagerCancelPreviousPerformRequestsWithTarget(aTarget NSObject)  {
	C.CBManager_CancelPreviousPerformRequestsWithTarget(aTarget.Ptr())
}

func CBManagerCancelPreviousPerformRequestsWithTargetSelector(aTarget NSObject, aSelector SEL, anArgument NSObject)  {
	C.CBManager_CancelPreviousPerformRequestsWithTargetSelector(aTarget.Ptr(), unsafe.Pointer(aSelector), anArgument.Ptr())
}

func CBManagerCancelPreviousPerformRequestsWithTargetSelectorObject(aTarget NSObject, aSelector SEL, anArgument NSObject)  {
	C.CBManager_CancelPreviousPerformRequestsWithTargetSelectorObject(aTarget.Ptr(), unsafe.Pointer(aSelector), anArgument.Ptr())
}

func CBManagerAllocWithZone(zone *_NSZone) *CBManager {
	ret := &CBManager{}
	ret.ptr = unsafe.Pointer(C.CBManager_AllocWithZone(unsafe.Pointer(zone)))
	if ret.ptr == nil { return ret }
	runtime.SetFinalizer(ret, func(o *CBManager) {
		o.Release()
	})
	return ret
}

func CBManagerHash() NSUInteger {
	ret := (NSUInteger)(C.CBManager_Hash())
	return ret
}

func CBManagerResolveInstanceMethod(sel SEL) bool {
	ret := (bool)(C.CBManager_ResolveInstanceMethod(unsafe.Pointer(sel)))
	return ret
}

func CBManagerInstanceMethodSignatureForSelector(aSelector SEL) *NSMethodSignature {
	ret := &NSMethodSignature{}
	ret.ptr = unsafe.Pointer(C.CBManager_InstanceMethodSignatureForSelector(unsafe.Pointer(aSelector)))
	if ret.ptr == nil { return ret }
	return ret
}

func CBManagerClass() Class {
	ret := (Class)(unsafe.Pointer(C.CBManager_Class()))
	return ret
}

func CBManagerInstancesRespondToSelector(aSelector SEL) bool {
	ret := (bool)(C.CBManager_InstancesRespondToSelector(unsafe.Pointer(aSelector)))
	return ret
}

func (o *CBManager) RemoveObserverForKeyPath(observer NSObject, keyPath *NSString)  {
	C.CBManager_inst_RemoveObserverForKeyPath(o.Ptr(), observer.Ptr(), keyPath.Ptr())
	runtime.KeepAlive(o)
}

func (o *CBManager) RemoveObserverForKeyPathContext(observer NSObject, keyPath *NSString, context unsafe.Pointer)  {
	C.CBManager_inst_RemoveObserverForKeyPathContext(o.Ptr(), observer.Ptr(), keyPath.Ptr(), unsafe.Pointer(context))
	runtime.KeepAlive(o)
}

func (o *CBManager) ValueForKey(key *NSString) *Id {
	ret := &Id{}
	ret.ptr = unsafe.Pointer(C.CBManager_inst_ValueForKey(o.Ptr(), key.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *Id) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *CBManager) ScriptingEndsWith(object NSObject) bool {
	ret := (bool)(C.CBManager_inst_ScriptingEndsWith(o.Ptr(), object.Ptr()))
	runtime.KeepAlive(o)
	return ret
}

func (o *CBManager) RemoveValueAtIndexFromPropertyWithKey(index NSUInteger, key *NSString)  {
	C.CBManager_inst_RemoveValueAtIndexFromPropertyWithKey(o.Ptr(), (C.NSUInteger)(index), key.Ptr())
	runtime.KeepAlive(o)
}

func (o *CBManager) ScriptingIsLessThanOrEqualTo(object NSObject) bool {
	ret := (bool)(C.CBManager_inst_ScriptingIsLessThanOrEqualTo(o.Ptr(), object.Ptr()))
	runtime.KeepAlive(o)
	return ret
}

func (o *CBManager) MutableArrayValueForKey(key *NSString) *NSMutableArray {
	ret := &NSMutableArray{}
	ret.ptr = unsafe.Pointer(C.CBManager_inst_MutableArrayValueForKey(o.Ptr(), key.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSMutableArray)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *NSMutableArray) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *CBManager) SetValueForKey(value NSObject, key *NSString)  {
	C.CBManager_inst_SetValueForKey(o.Ptr(), value.Ptr(), key.Ptr())
	runtime.KeepAlive(o)
}

func (o *CBManager) SetValueForKeyPath(value NSObject, keyPath *NSString)  {
	C.CBManager_inst_SetValueForKeyPath(o.Ptr(), value.Ptr(), keyPath.Ptr())
	runtime.KeepAlive(o)
}

func (o *CBManager) SetValueForUndefinedKey(value NSObject, key *NSString)  {
	C.CBManager_inst_SetValueForUndefinedKey(o.Ptr(), value.Ptr(), key.Ptr())
	runtime.KeepAlive(o)
}

func (o *CBManager) ValidateValueForKey(ioValue *[]*Id, inKey *NSString, outError *[]*NSError) bool {

	goSlice1 := make([]unsafe.Pointer,cap(*ioValue))
	for i := 0; i < len(*ioValue); i++ {
		goSlice1[i] = (*ioValue)[i].Ptr()
	}

	goSlice3 := make([]unsafe.Pointer,cap(*outError))
	for i := 0; i < len(*outError); i++ {
		goSlice3[i] = (*outError)[i].Ptr()
	}
	ret := (bool)(C.CBManager_inst_ValidateValueForKey(o.Ptr(), (*unsafe.Pointer)(unsafe.Pointer(&goSlice1[0])), inKey.Ptr(), (*unsafe.Pointer)(unsafe.Pointer(&goSlice3[0]))))
	(*ioValue) = (*ioValue)[:cap(*ioValue)]
	for i := 0; i < len(*ioValue); i++ {
		if goSlice1[i] == nil {
			(*ioValue) = (*ioValue)[:i]
			break
		}
		if (*ioValue)[i] == nil {
			(*ioValue)[i] = &Id{}
			runtime.SetFinalizer((*ioValue)[i], func(o *Id) {
				o.Release()
			})
		}
		(*ioValue)[i].ptr = goSlice1[i]
	}
	(*outError) = (*outError)[:cap(*outError)]
	for i := 0; i < len(*outError); i++ {
		if goSlice3[i] == nil {
			(*outError) = (*outError)[:i]
			break
		}
		if (*outError)[i] == nil {
			(*outError)[i] = &NSError{}
			runtime.SetFinalizer((*outError)[i], func(o *NSError) {
				o.Release()
			})
		}
		(*outError)[i].ptr = goSlice3[i]
	}
	runtime.KeepAlive(o)
	return ret
}

func (o *CBManager) ValidateValueForKeyPath(ioValue *[]*Id, inKeyPath *NSString, outError *[]*NSError) bool {

	goSlice1 := make([]unsafe.Pointer,cap(*ioValue))
	for i := 0; i < len(*ioValue); i++ {
		goSlice1[i] = (*ioValue)[i].Ptr()
	}

	goSlice3 := make([]unsafe.Pointer,cap(*outError))
	for i := 0; i < len(*outError); i++ {
		goSlice3[i] = (*outError)[i].Ptr()
	}
	ret := (bool)(C.CBManager_inst_ValidateValueForKeyPath(o.Ptr(), (*unsafe.Pointer)(unsafe.Pointer(&goSlice1[0])), inKeyPath.Ptr(), (*unsafe.Pointer)(unsafe.Pointer(&goSlice3[0]))))
	(*ioValue) = (*ioValue)[:cap(*ioValue)]
	for i := 0; i < len(*ioValue); i++ {
		if goSlice1[i] == nil {
			(*ioValue) = (*ioValue)[:i]
			break
		}
		if (*ioValue)[i] == nil {
			(*ioValue)[i] = &Id{}
			runtime.SetFinalizer((*ioValue)[i], func(o *Id) {
				o.Release()
			})
		}
		(*ioValue)[i].ptr = goSlice1[i]
	}
	(*outError) = (*outError)[:cap(*outError)]
	for i := 0; i < len(*outError); i++ {
		if goSlice3[i] == nil {
			(*outError) = (*outError)[:i]
			break
		}
		if (*outError)[i] == nil {
			(*outError)[i] = &NSError{}
			runtime.SetFinalizer((*outError)[i], func(o *NSError) {
				o.Release()
			})
		}
		(*outError)[i].ptr = goSlice3[i]
	}
	runtime.KeepAlive(o)
	return ret
}

func (o *CBManager) ValidateValueForKeyError(ioValue *[]*Id, inKey *NSString, outError *[]*NSError) bool {

	goSlice1 := make([]unsafe.Pointer,cap(*ioValue))
	for i := 0; i < len(*ioValue); i++ {
		goSlice1[i] = (*ioValue)[i].Ptr()
	}

	goSlice3 := make([]unsafe.Pointer,cap(*outError))
	for i := 0; i < len(*outError); i++ {
		goSlice3[i] = (*outError)[i].Ptr()
	}
	ret := (bool)(C.CBManager_inst_ValidateValueForKeyError(o.Ptr(), (*unsafe.Pointer)(unsafe.Pointer(&goSlice1[0])), inKey.Ptr(), (*unsafe.Pointer)(unsafe.Pointer(&goSlice3[0]))))
	(*ioValue) = (*ioValue)[:cap(*ioValue)]
	for i := 0; i < len(*ioValue); i++ {
		if goSlice1[i] == nil {
			(*ioValue) = (*ioValue)[:i]
			break
		}
		if (*ioValue)[i] == nil {
			(*ioValue)[i] = &Id{}
			runtime.SetFinalizer((*ioValue)[i], func(o *Id) {
				o.Release()
			})
		}
		(*ioValue)[i].ptr = goSlice1[i]
	}
	(*outError) = (*outError)[:cap(*outError)]
	for i := 0; i < len(*outError); i++ {
		if goSlice3[i] == nil {
			(*outError) = (*outError)[:i]
			break
		}
		if (*outError)[i] == nil {
			(*outError)[i] = &NSError{}
			runtime.SetFinalizer((*outError)[i], func(o *NSError) {
				o.Release()
			})
		}
		(*outError)[i].ptr = goSlice3[i]
	}
	runtime.KeepAlive(o)
	return ret
}

func (o *CBManager) ValidateValueForKeyPathError(ioValue *[]*Id, inKeyPath *NSString, outError *[]*NSError) bool {

	goSlice1 := make([]unsafe.Pointer,cap(*ioValue))
	for i := 0; i < len(*ioValue); i++ {
		goSlice1[i] = (*ioValue)[i].Ptr()
	}

	goSlice3 := make([]unsafe.Pointer,cap(*outError))
	for i := 0; i < len(*outError); i++ {
		goSlice3[i] = (*outError)[i].Ptr()
	}
	ret := (bool)(C.CBManager_inst_ValidateValueForKeyPathError(o.Ptr(), (*unsafe.Pointer)(unsafe.Pointer(&goSlice1[0])), inKeyPath.Ptr(), (*unsafe.Pointer)(unsafe.Pointer(&goSlice3[0]))))
	(*ioValue) = (*ioValue)[:cap(*ioValue)]
	for i := 0; i < len(*ioValue); i++ {
		if goSlice1[i] == nil {
			(*ioValue) = (*ioValue)[:i]
			break
		}
		if (*ioValue)[i] == nil {
			(*ioValue)[i] = &Id{}
			runtime.SetFinalizer((*ioValue)[i], func(o *Id) {
				o.Release()
			})
		}
		(*ioValue)[i].ptr = goSlice1[i]
	}
	(*outError) = (*outError)[:cap(*outError)]
	for i := 0; i < len(*outError); i++ {
		if goSlice3[i] == nil {
			(*outError) = (*outError)[:i]
			break
		}
		if (*outError)[i] == nil {
			(*outError)[i] = &NSError{}
			runtime.SetFinalizer((*outError)[i], func(o *NSError) {
				o.Release()
			})
		}
		(*outError)[i].ptr = goSlice3[i]
	}
	runtime.KeepAlive(o)
	return ret
}

func (o *CBManager) ClassCode() FourCharCode {
	ret := (FourCharCode)(C.CBManager_inst_ClassCode(o.Ptr()))
	runtime.KeepAlive(o)
	return ret
}

func (o *CBManager) MutableCopy() *Id {
	ret := &Id{}
	ret.ptr = unsafe.Pointer(C.CBManager_inst_MutableCopy(o.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	runtime.SetFinalizer(ret, func(o *Id) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *CBManager) ForwardInvocation(anInvocation *NSInvocation)  {
	C.CBManager_inst_ForwardInvocation(o.Ptr(), anInvocation.Ptr())
	runtime.KeepAlive(o)
}

func (o *CBManager) AttributeKeys() *NSArray {
	ret := &NSArray{}
	ret.ptr = unsafe.Pointer(C.CBManager_inst_AttributeKeys(o.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSArray)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *NSArray) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *CBManager) Copy() *Id {
	ret := &Id{}
	ret.ptr = unsafe.Pointer(C.CBManager_inst_Copy(o.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	runtime.SetFinalizer(ret, func(o *Id) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *CBManager) ValueWithNameInPropertyWithKey(name *NSString, key *NSString) *Id {
	ret := &Id{}
	ret.ptr = unsafe.Pointer(C.CBManager_inst_ValueWithNameInPropertyWithKey(o.Ptr(), name.Ptr(), key.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *Id) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *CBManager) ObservationInfo() unsafe.Pointer {
	ret := (unsafe.Pointer)(unsafe.Pointer(C.CBManager_inst_ObservationInfo(o.Ptr())))
	runtime.KeepAlive(o)
	return ret
}

func (o *CBManager) AddObserverForKeyPath(observer NSObject, keyPath *NSString, options NSKeyValueObservingOptions, context unsafe.Pointer)  {
	C.CBManager_inst_AddObserverForKeyPath(o.Ptr(), observer.Ptr(), keyPath.Ptr(), (C.NSKeyValueObservingOptions)(options), unsafe.Pointer(context))
	runtime.KeepAlive(o)
}

func (o *CBManager) AddObserverForKeyPathOptions(observer NSObject, keyPath *NSString, options NSKeyValueObservingOptions, context unsafe.Pointer)  {
	C.CBManager_inst_AddObserverForKeyPathOptions(o.Ptr(), observer.Ptr(), keyPath.Ptr(), (C.NSKeyValueObservingOptions)(options), unsafe.Pointer(context))
	runtime.KeepAlive(o)
}

func (o *CBManager) ClassForCoder() Class {
	ret := (Class)(unsafe.Pointer(C.CBManager_inst_ClassForCoder(o.Ptr())))
	runtime.KeepAlive(o)
	return ret
}

func (o *CBManager) AwakeAfterUsingCoder(coder *NSCoder) *Id {
	ret := &Id{}
	ret.ptr = unsafe.Pointer(C.CBManager_inst_AwakeAfterUsingCoder(o.Ptr(), coder.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *Id) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *CBManager) ToOneRelationshipKeys() *NSArray {
	ret := &NSArray{}
	ret.ptr = unsafe.Pointer(C.CBManager_inst_ToOneRelationshipKeys(o.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSArray)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *NSArray) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *CBManager) PerformSelectorWithObject(aSelector SEL, anArgument NSObject, delay NSTimeInterval)  {
	C.CBManager_inst_PerformSelectorWithObject(o.Ptr(), unsafe.Pointer(aSelector), anArgument.Ptr(), (C.NSTimeInterval)(delay))
	runtime.KeepAlive(o)
}

func (o *CBManager) PerformSelectorWithObjectAfterDelay(aSelector SEL, anArgument NSObject, delay NSTimeInterval)  {
	C.CBManager_inst_PerformSelectorWithObjectAfterDelay(o.Ptr(), unsafe.Pointer(aSelector), anArgument.Ptr(), (C.NSTimeInterval)(delay))
	runtime.KeepAlive(o)
}

func (o *CBManager) PerformSelectorWithObjectAfterDelayInModes(aSelector SEL, anArgument NSObject, delay NSTimeInterval, modes *NSArray)  {
	C.CBManager_inst_PerformSelectorWithObjectAfterDelayInModes(o.Ptr(), unsafe.Pointer(aSelector), anArgument.Ptr(), (C.NSTimeInterval)(delay), modes.Ptr())
	runtime.KeepAlive(o)
}

func (o *CBManager) PerformSelectorOnThread(aSelector SEL, thr *NSThread, arg NSObject, wait BOOL)  {
	C.CBManager_inst_PerformSelectorOnThread(o.Ptr(), unsafe.Pointer(aSelector), thr.Ptr(), arg.Ptr(), (C.BOOL)(wait))
	runtime.KeepAlive(o)
}

func (o *CBManager) PerformSelectorOnThreadWithObject(aSelector SEL, thr *NSThread, arg NSObject, wait BOOL)  {
	C.CBManager_inst_PerformSelectorOnThreadWithObject(o.Ptr(), unsafe.Pointer(aSelector), thr.Ptr(), arg.Ptr(), (C.BOOL)(wait))
	runtime.KeepAlive(o)
}

func (o *CBManager) PerformSelectorOnThreadWithObjectWaitUntilDone(aSelector SEL, thr *NSThread, arg NSObject, wait BOOL, array *NSArray)  {
	C.CBManager_inst_PerformSelectorOnThreadWithObjectWaitUntilDone(o.Ptr(), unsafe.Pointer(aSelector), thr.Ptr(), arg.Ptr(), (C.BOOL)(wait), array.Ptr())
	runtime.KeepAlive(o)
}

func (o *CBManager) PerformSelectorOnThreadWithObjectWaitUntilDoneModes(aSelector SEL, thr *NSThread, arg NSObject, wait BOOL, array *NSArray)  {
	C.CBManager_inst_PerformSelectorOnThreadWithObjectWaitUntilDoneModes(o.Ptr(), unsafe.Pointer(aSelector), thr.Ptr(), arg.Ptr(), (C.BOOL)(wait), array.Ptr())
	runtime.KeepAlive(o)
}

func (o *CBManager) ScriptingIsGreaterThanOrEqualTo(object NSObject) bool {
	ret := (bool)(C.CBManager_inst_ScriptingIsGreaterThanOrEqualTo(o.Ptr(), object.Ptr()))
	runtime.KeepAlive(o)
	return ret
}

func (o *CBManager) Authorization() CBManagerAuthorization {
	ret := (CBManagerAuthorization)(C.CBManager_inst_Authorization(o.Ptr()))
	runtime.KeepAlive(o)
	return ret
}

func (o *CBManager) ValueWithUniqueIDInPropertyWithKey(uniqueID NSObject, key *NSString) *Id {
	ret := &Id{}
	ret.ptr = unsafe.Pointer(C.CBManager_inst_ValueWithUniqueIDInPropertyWithKey(o.Ptr(), uniqueID.Ptr(), key.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *Id) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *CBManager) MutableArrayValueForKeyPath(keyPath *NSString) *NSMutableArray {
	ret := &NSMutableArray{}
	ret.ptr = unsafe.Pointer(C.CBManager_inst_MutableArrayValueForKeyPath(o.Ptr(), keyPath.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSMutableArray)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *NSMutableArray) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *CBManager) ReplaceValueAtIndexInPropertyWithKey(index NSUInteger, key *NSString, value NSObject)  {
	C.CBManager_inst_ReplaceValueAtIndexInPropertyWithKey(o.Ptr(), (C.NSUInteger)(index), key.Ptr(), value.Ptr())
	runtime.KeepAlive(o)
}

func (o *CBManager) ReplaceValueAtIndexInPropertyWithKeyWithValue(index NSUInteger, key *NSString, value NSObject)  {
	C.CBManager_inst_ReplaceValueAtIndexInPropertyWithKeyWithValue(o.Ptr(), (C.NSUInteger)(index), key.Ptr(), value.Ptr())
	runtime.KeepAlive(o)
}

func (o *CBManager) MutableSetValueForKey(key *NSString) *NSMutableSet {
	ret := &NSMutableSet{}
	ret.ptr = unsafe.Pointer(C.CBManager_inst_MutableSetValueForKey(o.Ptr(), key.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSMutableSet)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *NSMutableSet) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *CBManager) State() CBManagerState {
	ret := (CBManagerState)(C.CBManager_inst_State(o.Ptr()))
	runtime.KeepAlive(o)
	return ret
}

func (o *CBManager) MethodSignatureForSelector(aSelector SEL) *NSMethodSignature {
	ret := &NSMethodSignature{}
	ret.ptr = unsafe.Pointer(C.CBManager_inst_MethodSignatureForSelector(o.Ptr(), unsafe.Pointer(aSelector)))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSMethodSignature)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *NSMethodSignature) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *CBManager) IsNotEqualTo(object NSObject) bool {
	ret := (bool)(C.CBManager_inst_IsNotEqualTo(o.Ptr(), object.Ptr()))
	runtime.KeepAlive(o)
	return ret
}

func (o *CBManager) ClassName() *NSString {
	ret := &NSString{}
	ret.ptr = unsafe.Pointer(C.CBManager_inst_ClassName(o.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSString)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *NSString) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *CBManager) DoesContain(object NSObject) bool {
	ret := (bool)(C.CBManager_inst_DoesContain(o.Ptr(), object.Ptr()))
	runtime.KeepAlive(o)
	return ret
}

func (o *CBManager) ValueForKeyPath(keyPath *NSString) *Id {
	ret := &Id{}
	ret.ptr = unsafe.Pointer(C.CBManager_inst_ValueForKeyPath(o.Ptr(), keyPath.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *Id) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *CBManager) SetScriptingProperties(scriptingProperties *NSDictionary)  {
	C.CBManager_inst_SetScriptingProperties(o.Ptr(), scriptingProperties.Ptr())
	runtime.KeepAlive(o)
}

func (o *CBManager) ForwardingTargetForSelector(aSelector SEL) *Id {
	ret := &Id{}
	ret.ptr = unsafe.Pointer(C.CBManager_inst_ForwardingTargetForSelector(o.Ptr(), unsafe.Pointer(aSelector)))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *Id) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *CBManager) NewScriptingObjectOfClassForValueForKey(objectClass Class, key *NSString, contentsValue NSObject, properties *NSDictionary) *Id {
	ret := &Id{}
	ret.ptr = unsafe.Pointer(C.CBManager_inst_NewScriptingObjectOfClassForValueForKey(o.Ptr(), unsafe.Pointer(objectClass), key.Ptr(), contentsValue.Ptr(), properties.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *Id) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *CBManager) NewScriptingObjectOfClassForValueForKeyWithContentsValue(objectClass Class, key *NSString, contentsValue NSObject, properties *NSDictionary) *Id {
	ret := &Id{}
	ret.ptr = unsafe.Pointer(C.CBManager_inst_NewScriptingObjectOfClassForValueForKeyWithContentsValue(o.Ptr(), unsafe.Pointer(objectClass), key.Ptr(), contentsValue.Ptr(), properties.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *Id) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *CBManager) PerformSelectorOnMainThreadWithObject(aSelector SEL, arg NSObject, wait BOOL)  {
	C.CBManager_inst_PerformSelectorOnMainThreadWithObject(o.Ptr(), unsafe.Pointer(aSelector), arg.Ptr(), (C.BOOL)(wait))
	runtime.KeepAlive(o)
}

func (o *CBManager) PerformSelectorOnMainThreadWithObjectWaitUntilDone(aSelector SEL, arg NSObject, wait BOOL)  {
	C.CBManager_inst_PerformSelectorOnMainThreadWithObjectWaitUntilDone(o.Ptr(), unsafe.Pointer(aSelector), arg.Ptr(), (C.BOOL)(wait))
	runtime.KeepAlive(o)
}

func (o *CBManager) PerformSelectorOnMainThreadWithObjectWaitUntilDoneModes(aSelector SEL, arg NSObject, wait BOOL, array *NSArray)  {
	C.CBManager_inst_PerformSelectorOnMainThreadWithObjectWaitUntilDoneModes(o.Ptr(), unsafe.Pointer(aSelector), arg.Ptr(), (C.BOOL)(wait), array.Ptr())
	runtime.KeepAlive(o)
}

func (o *CBManager) IsLessThan(object NSObject) bool {
	ret := (bool)(C.CBManager_inst_IsLessThan(o.Ptr(), object.Ptr()))
	runtime.KeepAlive(o)
	return ret
}

func (o *CBManager) IsLike(object *NSString) bool {
	ret := (bool)(C.CBManager_inst_IsLike(o.Ptr(), object.Ptr()))
	runtime.KeepAlive(o)
	return ret
}

func (o *CBManager) ToManyRelationshipKeys() *NSArray {
	ret := &NSArray{}
	ret.ptr = unsafe.Pointer(C.CBManager_inst_ToManyRelationshipKeys(o.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSArray)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *NSArray) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *CBManager) ReplacementObjectForKeyedArchiver(archiver *NSKeyedArchiver) *Id {
	ret := &Id{}
	ret.ptr = unsafe.Pointer(C.CBManager_inst_ReplacementObjectForKeyedArchiver(o.Ptr(), archiver.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *Id) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *CBManager) InsertValueInPropertyWithKey(value NSObject, key *NSString)  {
	C.CBManager_inst_InsertValueInPropertyWithKey(o.Ptr(), value.Ptr(), key.Ptr())
	runtime.KeepAlive(o)
}

func (o *CBManager) InsertValueAtIndex(value NSObject, index NSUInteger, key *NSString)  {
	C.CBManager_inst_InsertValueAtIndex(o.Ptr(), value.Ptr(), (C.NSUInteger)(index), key.Ptr())
	runtime.KeepAlive(o)
}

func (o *CBManager) InsertValueAtIndexInPropertyWithKey(value NSObject, index NSUInteger, key *NSString)  {
	C.CBManager_inst_InsertValueAtIndexInPropertyWithKey(o.Ptr(), value.Ptr(), (C.NSUInteger)(index), key.Ptr())
	runtime.KeepAlive(o)
}

func (o *CBManager) IsCaseInsensitiveLike(object *NSString) bool {
	ret := (bool)(C.CBManager_inst_IsCaseInsensitiveLike(o.Ptr(), object.Ptr()))
	runtime.KeepAlive(o)
	return ret
}

func (o *CBManager) ValueAtIndexInPropertyWithKey(index NSUInteger, key *NSString) *Id {
	ret := &Id{}
	ret.ptr = unsafe.Pointer(C.CBManager_inst_ValueAtIndexInPropertyWithKey(o.Ptr(), (C.NSUInteger)(index), key.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *Id) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *CBManager) WillChangeValueForKey(key *NSString)  {
	C.CBManager_inst_WillChangeValueForKey(o.Ptr(), key.Ptr())
	runtime.KeepAlive(o)
}

func (o *CBManager) WillChangeValueForKeyWithSetMutation(key *NSString, mutationKind NSKeyValueSetMutationKind, objects *NSSet)  {
	C.CBManager_inst_WillChangeValueForKeyWithSetMutation(o.Ptr(), key.Ptr(), (C.NSKeyValueSetMutationKind)(mutationKind), objects.Ptr())
	runtime.KeepAlive(o)
}

func (o *CBManager) WillChangeValueForKeyWithSetMutationUsingObjects(key *NSString, mutationKind NSKeyValueSetMutationKind, objects *NSSet)  {
	C.CBManager_inst_WillChangeValueForKeyWithSetMutationUsingObjects(o.Ptr(), key.Ptr(), (C.NSKeyValueSetMutationKind)(mutationKind), objects.Ptr())
	runtime.KeepAlive(o)
}

func (o *CBManager) ScriptingContains(object NSObject) bool {
	ret := (bool)(C.CBManager_inst_ScriptingContains(o.Ptr(), object.Ptr()))
	runtime.KeepAlive(o)
	return ret
}

func (o *CBManager) MutableSetValueForKeyPath(keyPath *NSString) *NSMutableSet {
	ret := &NSMutableSet{}
	ret.ptr = unsafe.Pointer(C.CBManager_inst_MutableSetValueForKeyPath(o.Ptr(), keyPath.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSMutableSet)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *NSMutableSet) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *CBManager) AttemptRecoveryFromErrorOptionIndex(error *NSError, recoveryOptionIndex NSUInteger) bool {
	ret := (bool)(C.CBManager_inst_AttemptRecoveryFromErrorOptionIndex(o.Ptr(), error.Ptr(), (C.NSUInteger)(recoveryOptionIndex)))
	runtime.KeepAlive(o)
	return ret
}

func (o *CBManager) AttemptRecoveryFromErrorOptionIndexDelegate(error *NSError, recoveryOptionIndex NSUInteger, delegate NSObject, didRecoverSelector SEL, contextInfo unsafe.Pointer)  {
	C.CBManager_inst_AttemptRecoveryFromErrorOptionIndexDelegate(o.Ptr(), error.Ptr(), (C.NSUInteger)(recoveryOptionIndex), delegate.Ptr(), unsafe.Pointer(didRecoverSelector), unsafe.Pointer(contextInfo))
	runtime.KeepAlive(o)
}

func (o *CBManager) AttemptRecoveryFromErrorOptionIndexDelegateDidRecoverSelector(error *NSError, recoveryOptionIndex NSUInteger, delegate NSObject, didRecoverSelector SEL, contextInfo unsafe.Pointer)  {
	C.CBManager_inst_AttemptRecoveryFromErrorOptionIndexDelegateDidRecoverSelector(o.Ptr(), error.Ptr(), (C.NSUInteger)(recoveryOptionIndex), delegate.Ptr(), unsafe.Pointer(didRecoverSelector), unsafe.Pointer(contextInfo))
	runtime.KeepAlive(o)
}

func (o *CBManager) IsGreaterThanOrEqualTo(object NSObject) bool {
	ret := (bool)(C.CBManager_inst_IsGreaterThanOrEqualTo(o.Ptr(), object.Ptr()))
	runtime.KeepAlive(o)
	return ret
}

func (o *CBManager) PerformSelectorInBackgroundWithObject(aSelector SEL, arg NSObject)  {
	C.CBManager_inst_PerformSelectorInBackgroundWithObject(o.Ptr(), unsafe.Pointer(aSelector), arg.Ptr())
	runtime.KeepAlive(o)
}

func (o *CBManager) ScriptingIsLessThan(object NSObject) bool {
	ret := (bool)(C.CBManager_inst_ScriptingIsLessThan(o.Ptr(), object.Ptr()))
	runtime.KeepAlive(o)
	return ret
}

func (o *CBManager) ClassForArchiver() Class {
	ret := (Class)(unsafe.Pointer(C.CBManager_inst_ClassForArchiver(o.Ptr())))
	runtime.KeepAlive(o)
	return ret
}

func (o *CBManager) DictionaryWithValuesForKeys(keys *NSArray) *NSDictionary {
	ret := &NSDictionary{}
	ret.ptr = unsafe.Pointer(C.CBManager_inst_DictionaryWithValuesForKeys(o.Ptr(), keys.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSDictionary)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *NSDictionary) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *CBManager) CoerceValueForKey(value NSObject, key *NSString) *Id {
	ret := &Id{}
	ret.ptr = unsafe.Pointer(C.CBManager_inst_CoerceValueForKey(o.Ptr(), value.Ptr(), key.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *Id) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *CBManager) DidChangeValueForKey(key *NSString)  {
	C.CBManager_inst_DidChangeValueForKey(o.Ptr(), key.Ptr())
	runtime.KeepAlive(o)
}

func (o *CBManager) DidChangeValueForKeyWithSetMutation(key *NSString, mutationKind NSKeyValueSetMutationKind, objects *NSSet)  {
	C.CBManager_inst_DidChangeValueForKeyWithSetMutation(o.Ptr(), key.Ptr(), (C.NSKeyValueSetMutationKind)(mutationKind), objects.Ptr())
	runtime.KeepAlive(o)
}

func (o *CBManager) DidChangeValueForKeyWithSetMutationUsingObjects(key *NSString, mutationKind NSKeyValueSetMutationKind, objects *NSSet)  {
	C.CBManager_inst_DidChangeValueForKeyWithSetMutationUsingObjects(o.Ptr(), key.Ptr(), (C.NSKeyValueSetMutationKind)(mutationKind), objects.Ptr())
	runtime.KeepAlive(o)
}

func (o *CBManager) ClassForKeyedArchiver() Class {
	ret := (Class)(unsafe.Pointer(C.CBManager_inst_ClassForKeyedArchiver(o.Ptr())))
	runtime.KeepAlive(o)
	return ret
}

func (o *CBManager) AutoContentAccessingProxy() *Id {
	ret := &Id{}
	ret.ptr = unsafe.Pointer(C.CBManager_inst_AutoContentAccessingProxy(o.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *Id) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *CBManager) ObjectSpecifier() *NSScriptObjectSpecifier {
	ret := &NSScriptObjectSpecifier{}
	ret.ptr = unsafe.Pointer(C.CBManager_inst_ObjectSpecifier(o.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSScriptObjectSpecifier)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *NSScriptObjectSpecifier) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *CBManager) SetValuesForKeysWithDictionary(keyedValues *NSDictionary)  {
	C.CBManager_inst_SetValuesForKeysWithDictionary(o.Ptr(), keyedValues.Ptr())
	runtime.KeepAlive(o)
}

func (o *CBManager) ReplacementObjectForCoder(coder *NSCoder) *Id {
	ret := &Id{}
	ret.ptr = unsafe.Pointer(C.CBManager_inst_ReplacementObjectForCoder(o.Ptr(), coder.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *Id) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *CBManager) Dealloc()  {
	C.CBManager_inst_Dealloc(o.Ptr())
	runtime.KeepAlive(o)
}

func (o *CBManager) ValueForUndefinedKey(key *NSString) *Id {
	ret := &Id{}
	ret.ptr = unsafe.Pointer(C.CBManager_inst_ValueForUndefinedKey(o.Ptr(), key.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *Id) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *CBManager) SetObservationInfo(observationInfo unsafe.Pointer)  {
	C.CBManager_inst_SetObservationInfo(o.Ptr(), unsafe.Pointer(observationInfo))
	runtime.KeepAlive(o)
}

func (o *CBManager) IsGreaterThan(object NSObject) bool {
	ret := (bool)(C.CBManager_inst_IsGreaterThan(o.Ptr(), object.Ptr()))
	runtime.KeepAlive(o)
	return ret
}

func (o *CBManager) MutableOrderedSetValueForKeyPath(keyPath *NSString) *NSMutableOrderedSet {
	ret := &NSMutableOrderedSet{}
	ret.ptr = unsafe.Pointer(C.CBManager_inst_MutableOrderedSetValueForKeyPath(o.Ptr(), keyPath.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSMutableOrderedSet)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *NSMutableOrderedSet) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *CBManager) InverseForRelationshipKey(relationshipKey *NSString) *NSString {
	ret := &NSString{}
	ret.ptr = unsafe.Pointer(C.CBManager_inst_InverseForRelationshipKey(o.Ptr(), relationshipKey.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSString)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *NSString) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *CBManager) DidChangeValuesAtIndexes(changeKind NSKeyValueChange, indexes *NSIndexSet, key *NSString)  {
	C.CBManager_inst_DidChangeValuesAtIndexes(o.Ptr(), (C.NSKeyValueChange)(changeKind), indexes.Ptr(), key.Ptr())
	runtime.KeepAlive(o)
}

func (o *CBManager) DidChangeValuesAtIndexesForKey(changeKind NSKeyValueChange, indexes *NSIndexSet, key *NSString)  {
	C.CBManager_inst_DidChangeValuesAtIndexesForKey(o.Ptr(), (C.NSKeyValueChange)(changeKind), indexes.Ptr(), key.Ptr())
	runtime.KeepAlive(o)
}

func (o *CBManager) ScriptingProperties() *NSDictionary {
	ret := &NSDictionary{}
	ret.ptr = unsafe.Pointer(C.CBManager_inst_ScriptingProperties(o.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSDictionary)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *NSDictionary) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *CBManager) DoesNotRecognizeSelector(aSelector SEL)  {
	C.CBManager_inst_DoesNotRecognizeSelector(o.Ptr(), unsafe.Pointer(aSelector))
	runtime.KeepAlive(o)
}

func (o *CBManager) ClassDescription() *NSClassDescription {
	ret := &NSClassDescription{}
	ret.ptr = unsafe.Pointer(C.CBManager_inst_ClassDescription(o.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSClassDescription)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *NSClassDescription) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *CBManager) MutableOrderedSetValueForKey(key *NSString) *NSMutableOrderedSet {
	ret := &NSMutableOrderedSet{}
	ret.ptr = unsafe.Pointer(C.CBManager_inst_MutableOrderedSetValueForKey(o.Ptr(), key.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSMutableOrderedSet)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *NSMutableOrderedSet) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *CBManager) ObserveValueForKeyPathOfObject(keyPath *NSString, object NSObject, change *NSDictionary, context unsafe.Pointer)  {
	C.CBManager_inst_ObserveValueForKeyPathOfObject(o.Ptr(), keyPath.Ptr(), object.Ptr(), change.Ptr(), unsafe.Pointer(context))
	runtime.KeepAlive(o)
}

func (o *CBManager) ObserveValueForKeyPathOfObjectChange(keyPath *NSString, object NSObject, change *NSDictionary, context unsafe.Pointer)  {
	C.CBManager_inst_ObserveValueForKeyPathOfObjectChange(o.Ptr(), keyPath.Ptr(), object.Ptr(), change.Ptr(), unsafe.Pointer(context))
	runtime.KeepAlive(o)
}

func (o *CBManager) ScriptingIsGreaterThan(object NSObject) bool {
	ret := (bool)(C.CBManager_inst_ScriptingIsGreaterThan(o.Ptr(), object.Ptr()))
	runtime.KeepAlive(o)
	return ret
}

func (o *CBManager) WillChangeValuesAtIndexes(changeKind NSKeyValueChange, indexes *NSIndexSet, key *NSString)  {
	C.CBManager_inst_WillChangeValuesAtIndexes(o.Ptr(), (C.NSKeyValueChange)(changeKind), indexes.Ptr(), key.Ptr())
	runtime.KeepAlive(o)
}

func (o *CBManager) WillChangeValuesAtIndexesForKey(changeKind NSKeyValueChange, indexes *NSIndexSet, key *NSString)  {
	C.CBManager_inst_WillChangeValuesAtIndexesForKey(o.Ptr(), (C.NSKeyValueChange)(changeKind), indexes.Ptr(), key.Ptr())
	runtime.KeepAlive(o)
}

func (o *CBManager) IndicesOfObjectsByEvaluatingObjectSpecifier(specifier *NSScriptObjectSpecifier) *NSArray {
	ret := &NSArray{}
	ret.ptr = unsafe.Pointer(C.CBManager_inst_IndicesOfObjectsByEvaluatingObjectSpecifier(o.Ptr(), specifier.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSArray)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *NSArray) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *CBManager) ScriptingIsEqualTo(object NSObject) bool {
	ret := (bool)(C.CBManager_inst_ScriptingIsEqualTo(o.Ptr(), object.Ptr()))
	runtime.KeepAlive(o)
	return ret
}

func (o *CBManager) IsLessThanOrEqualTo(object NSObject) bool {
	ret := (bool)(C.CBManager_inst_IsLessThanOrEqualTo(o.Ptr(), object.Ptr()))
	runtime.KeepAlive(o)
	return ret
}

func (o *CBManager) IsEqualTo(object NSObject) bool {
	ret := (bool)(C.CBManager_inst_IsEqualTo(o.Ptr(), object.Ptr()))
	runtime.KeepAlive(o)
	return ret
}

func (o *CBManager) CopyScriptingValueForKey(value NSObject, key *NSString, properties *NSDictionary) *Id {
	ret := &Id{}
	ret.ptr = unsafe.Pointer(C.CBManager_inst_CopyScriptingValueForKey(o.Ptr(), value.Ptr(), key.Ptr(), properties.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *Id) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *CBManager) CopyScriptingValueForKeyWithProperties(value NSObject, key *NSString, properties *NSDictionary) *Id {
	ret := &Id{}
	ret.ptr = unsafe.Pointer(C.CBManager_inst_CopyScriptingValueForKeyWithProperties(o.Ptr(), value.Ptr(), key.Ptr(), properties.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *Id) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *CBManager) SetNilValueForKey(key *NSString)  {
	C.CBManager_inst_SetNilValueForKey(o.Ptr(), key.Ptr())
	runtime.KeepAlive(o)
}

func (o *CBManager) ScriptingBeginsWith(object NSObject) bool {
	ret := (bool)(C.CBManager_inst_ScriptingBeginsWith(o.Ptr(), object.Ptr()))
	runtime.KeepAlive(o)
	return ret
}

func (o *CBManager) ScriptingValueForSpecifier(objectSpecifier *NSScriptObjectSpecifier) *Id {
	ret := &Id{}
	ret.ptr = unsafe.Pointer(C.CBManager_inst_ScriptingValueForSpecifier(o.Ptr(), objectSpecifier.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *Id) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func CBServiceConformsToProtocol(protocol Protocol) bool {
	ret := (bool)(C.CBService_ConformsToProtocol(protocol.Ptr()))
	return ret
}

func CBServiceResolveInstanceMethod(sel SEL) bool {
	ret := (bool)(C.CBService_ResolveInstanceMethod(unsafe.Pointer(sel)))
	return ret
}

func CBServiceCancelPreviousPerformRequestsWithTarget(aTarget NSObject)  {
	C.CBService_CancelPreviousPerformRequestsWithTarget(aTarget.Ptr())
}

func CBServiceCancelPreviousPerformRequestsWithTargetSelector(aTarget NSObject, aSelector SEL, anArgument NSObject)  {
	C.CBService_CancelPreviousPerformRequestsWithTargetSelector(aTarget.Ptr(), unsafe.Pointer(aSelector), anArgument.Ptr())
}

func CBServiceCancelPreviousPerformRequestsWithTargetSelectorObject(aTarget NSObject, aSelector SEL, anArgument NSObject)  {
	C.CBService_CancelPreviousPerformRequestsWithTargetSelectorObject(aTarget.Ptr(), unsafe.Pointer(aSelector), anArgument.Ptr())
}

func CBServiceCopyWithZone(zone *_NSZone) *Id {
	ret := &Id{}
	ret.ptr = unsafe.Pointer(C.CBService_CopyWithZone(unsafe.Pointer(zone)))
	if ret.ptr == nil { return ret }
	runtime.SetFinalizer(ret, func(o *Id) {
		o.Release()
	})
	return ret
}

func CBServiceVersion() NSInteger {
	ret := (NSInteger)(C.CBService_Version())
	return ret
}

func CBServiceClassFallbacksForKeyedArchiver() *NSArray {
	ret := &NSArray{}
	ret.ptr = unsafe.Pointer(C.CBService_ClassFallbacksForKeyedArchiver())
	if ret.ptr == nil { return ret }
	return ret
}

func CBServiceSetVersion(aVersion NSInteger)  {
	C.CBService_SetVersion((C.NSInteger)(aVersion))
}

func CBServiceNew() *CBService {
	ret := &CBService{}
	ret.ptr = unsafe.Pointer(C.CBService_New())
	if ret.ptr == nil { return ret }
	runtime.SetFinalizer(ret, func(o *CBService) {
		o.Release()
	})
	return ret
}

func CBServiceResolveClassMethod(sel SEL) bool {
	ret := (bool)(C.CBService_ResolveClassMethod(unsafe.Pointer(sel)))
	return ret
}

func CBServiceSuperclass() Class {
	ret := (Class)(unsafe.Pointer(C.CBService_Superclass()))
	return ret
}

func CBServiceInstancesRespondToSelector(aSelector SEL) bool {
	ret := (bool)(C.CBService_InstancesRespondToSelector(unsafe.Pointer(aSelector)))
	return ret
}

func CBServiceHash() NSUInteger {
	ret := (NSUInteger)(C.CBService_Hash())
	return ret
}

func CBServiceKeyPathsForValuesAffectingValueForKey(key *NSString) *NSSet {
	ret := &NSSet{}
	ret.ptr = unsafe.Pointer(C.CBService_KeyPathsForValuesAffectingValueForKey(key.Ptr()))
	if ret.ptr == nil { return ret }
	return ret
}

func CBServiceClassForKeyedUnarchiver() Class {
	ret := (Class)(unsafe.Pointer(C.CBService_ClassForKeyedUnarchiver()))
	return ret
}

func CBServiceAlloc() *CBService {
	ret := &CBService{}
	ret.ptr = unsafe.Pointer(C.CBService_Alloc())
	if ret.ptr == nil { return ret }
	runtime.SetFinalizer(ret, func(o *CBService) {
		o.Release()
	})
	return ret
}

func (o *CBService) GC() {
	if o.ptr == nil { return }
	runtime.SetFinalizer(o, func(o *CBService) {
		o.Release()
	})
	runtime.KeepAlive(o)
}

func CBServiceDebugDescription() *NSString {
	ret := &NSString{}
	ret.ptr = unsafe.Pointer(C.CBService_DebugDescription())
	if ret.ptr == nil { return ret }
	return ret
}

func CBServiceMutableCopyWithZone(zone *_NSZone) *Id {
	ret := &Id{}
	ret.ptr = unsafe.Pointer(C.CBService_MutableCopyWithZone(unsafe.Pointer(zone)))
	if ret.ptr == nil { return ret }
	runtime.SetFinalizer(ret, func(o *Id) {
		o.Release()
	})
	return ret
}

func CBServiceInstanceMethodSignatureForSelector(aSelector SEL) *NSMethodSignature {
	ret := &NSMethodSignature{}
	ret.ptr = unsafe.Pointer(C.CBService_InstanceMethodSignatureForSelector(unsafe.Pointer(aSelector)))
	if ret.ptr == nil { return ret }
	return ret
}

func CBServiceClass() Class {
	ret := (Class)(unsafe.Pointer(C.CBService_Class()))
	return ret
}

func CBServiceAutomaticallyNotifiesObserversForKey(key *NSString) bool {
	ret := (bool)(C.CBService_AutomaticallyNotifiesObserversForKey(key.Ptr()))
	return ret
}

func CBServiceIsSubclassOfClass(aClass Class) bool {
	ret := (bool)(C.CBService_IsSubclassOfClass(unsafe.Pointer(aClass)))
	return ret
}

func CBServiceDescription() *NSString {
	ret := &NSString{}
	ret.ptr = unsafe.Pointer(C.CBService_Description())
	if ret.ptr == nil { return ret }
	return ret
}

func CBServiceAllocWithZone(zone *_NSZone) *CBService {
	ret := &CBService{}
	ret.ptr = unsafe.Pointer(C.CBService_AllocWithZone(unsafe.Pointer(zone)))
	if ret.ptr == nil { return ret }
	runtime.SetFinalizer(ret, func(o *CBService) {
		o.Release()
	})
	return ret
}

func CBServiceAccessInstanceVariablesDirectly() bool {
	ret := (bool)(C.CBService_AccessInstanceVariablesDirectly())
	return ret
}

func CBServiceLoad()  {
	C.CBService_Load()
}

func (o *CBService) RemoveObserverForKeyPath(observer NSObject, keyPath *NSString)  {
	C.CBService_inst_RemoveObserverForKeyPath(o.Ptr(), observer.Ptr(), keyPath.Ptr())
	runtime.KeepAlive(o)
}

func (o *CBService) RemoveObserverForKeyPathContext(observer NSObject, keyPath *NSString, context unsafe.Pointer)  {
	C.CBService_inst_RemoveObserverForKeyPathContext(o.Ptr(), observer.Ptr(), keyPath.Ptr(), unsafe.Pointer(context))
	runtime.KeepAlive(o)
}

func (o *CBService) InsertValueInPropertyWithKey(value NSObject, key *NSString)  {
	C.CBService_inst_InsertValueInPropertyWithKey(o.Ptr(), value.Ptr(), key.Ptr())
	runtime.KeepAlive(o)
}

func (o *CBService) InsertValueAtIndex(value NSObject, index NSUInteger, key *NSString)  {
	C.CBService_inst_InsertValueAtIndex(o.Ptr(), value.Ptr(), (C.NSUInteger)(index), key.Ptr())
	runtime.KeepAlive(o)
}

func (o *CBService) InsertValueAtIndexInPropertyWithKey(value NSObject, index NSUInteger, key *NSString)  {
	C.CBService_inst_InsertValueAtIndexInPropertyWithKey(o.Ptr(), value.Ptr(), (C.NSUInteger)(index), key.Ptr())
	runtime.KeepAlive(o)
}

func (o *CBService) ValueForUndefinedKey(key *NSString) *Id {
	ret := &Id{}
	ret.ptr = unsafe.Pointer(C.CBService_inst_ValueForUndefinedKey(o.Ptr(), key.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *Id) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *CBService) IsLessThan(object NSObject) bool {
	ret := (bool)(C.CBService_inst_IsLessThan(o.Ptr(), object.Ptr()))
	runtime.KeepAlive(o)
	return ret
}

func (o *CBService) MutableSetValueForKey(key *NSString) *NSMutableSet {
	ret := &NSMutableSet{}
	ret.ptr = unsafe.Pointer(C.CBService_inst_MutableSetValueForKey(o.Ptr(), key.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSMutableSet)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *NSMutableSet) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *CBService) IndicesOfObjectsByEvaluatingObjectSpecifier(specifier *NSScriptObjectSpecifier) *NSArray {
	ret := &NSArray{}
	ret.ptr = unsafe.Pointer(C.CBService_inst_IndicesOfObjectsByEvaluatingObjectSpecifier(o.Ptr(), specifier.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSArray)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *NSArray) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *CBService) AwakeAfterUsingCoder(coder *NSCoder) *Id {
	ret := &Id{}
	ret.ptr = unsafe.Pointer(C.CBService_inst_AwakeAfterUsingCoder(o.Ptr(), coder.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *Id) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *CBService) ObservationInfo() unsafe.Pointer {
	ret := (unsafe.Pointer)(unsafe.Pointer(C.CBService_inst_ObservationInfo(o.Ptr())))
	runtime.KeepAlive(o)
	return ret
}

func (o *CBService) ValidateValueForKey(ioValue *[]*Id, inKey *NSString, outError *[]*NSError) bool {

	goSlice1 := make([]unsafe.Pointer,cap(*ioValue))
	for i := 0; i < len(*ioValue); i++ {
		goSlice1[i] = (*ioValue)[i].Ptr()
	}

	goSlice3 := make([]unsafe.Pointer,cap(*outError))
	for i := 0; i < len(*outError); i++ {
		goSlice3[i] = (*outError)[i].Ptr()
	}
	ret := (bool)(C.CBService_inst_ValidateValueForKey(o.Ptr(), (*unsafe.Pointer)(unsafe.Pointer(&goSlice1[0])), inKey.Ptr(), (*unsafe.Pointer)(unsafe.Pointer(&goSlice3[0]))))
	(*ioValue) = (*ioValue)[:cap(*ioValue)]
	for i := 0; i < len(*ioValue); i++ {
		if goSlice1[i] == nil {
			(*ioValue) = (*ioValue)[:i]
			break
		}
		if (*ioValue)[i] == nil {
			(*ioValue)[i] = &Id{}
			runtime.SetFinalizer((*ioValue)[i], func(o *Id) {
				o.Release()
			})
		}
		(*ioValue)[i].ptr = goSlice1[i]
	}
	(*outError) = (*outError)[:cap(*outError)]
	for i := 0; i < len(*outError); i++ {
		if goSlice3[i] == nil {
			(*outError) = (*outError)[:i]
			break
		}
		if (*outError)[i] == nil {
			(*outError)[i] = &NSError{}
			runtime.SetFinalizer((*outError)[i], func(o *NSError) {
				o.Release()
			})
		}
		(*outError)[i].ptr = goSlice3[i]
	}
	runtime.KeepAlive(o)
	return ret
}

func (o *CBService) ValidateValueForKeyPath(ioValue *[]*Id, inKeyPath *NSString, outError *[]*NSError) bool {

	goSlice1 := make([]unsafe.Pointer,cap(*ioValue))
	for i := 0; i < len(*ioValue); i++ {
		goSlice1[i] = (*ioValue)[i].Ptr()
	}

	goSlice3 := make([]unsafe.Pointer,cap(*outError))
	for i := 0; i < len(*outError); i++ {
		goSlice3[i] = (*outError)[i].Ptr()
	}
	ret := (bool)(C.CBService_inst_ValidateValueForKeyPath(o.Ptr(), (*unsafe.Pointer)(unsafe.Pointer(&goSlice1[0])), inKeyPath.Ptr(), (*unsafe.Pointer)(unsafe.Pointer(&goSlice3[0]))))
	(*ioValue) = (*ioValue)[:cap(*ioValue)]
	for i := 0; i < len(*ioValue); i++ {
		if goSlice1[i] == nil {
			(*ioValue) = (*ioValue)[:i]
			break
		}
		if (*ioValue)[i] == nil {
			(*ioValue)[i] = &Id{}
			runtime.SetFinalizer((*ioValue)[i], func(o *Id) {
				o.Release()
			})
		}
		(*ioValue)[i].ptr = goSlice1[i]
	}
	(*outError) = (*outError)[:cap(*outError)]
	for i := 0; i < len(*outError); i++ {
		if goSlice3[i] == nil {
			(*outError) = (*outError)[:i]
			break
		}
		if (*outError)[i] == nil {
			(*outError)[i] = &NSError{}
			runtime.SetFinalizer((*outError)[i], func(o *NSError) {
				o.Release()
			})
		}
		(*outError)[i].ptr = goSlice3[i]
	}
	runtime.KeepAlive(o)
	return ret
}

func (o *CBService) ValidateValueForKeyError(ioValue *[]*Id, inKey *NSString, outError *[]*NSError) bool {

	goSlice1 := make([]unsafe.Pointer,cap(*ioValue))
	for i := 0; i < len(*ioValue); i++ {
		goSlice1[i] = (*ioValue)[i].Ptr()
	}

	goSlice3 := make([]unsafe.Pointer,cap(*outError))
	for i := 0; i < len(*outError); i++ {
		goSlice3[i] = (*outError)[i].Ptr()
	}
	ret := (bool)(C.CBService_inst_ValidateValueForKeyError(o.Ptr(), (*unsafe.Pointer)(unsafe.Pointer(&goSlice1[0])), inKey.Ptr(), (*unsafe.Pointer)(unsafe.Pointer(&goSlice3[0]))))
	(*ioValue) = (*ioValue)[:cap(*ioValue)]
	for i := 0; i < len(*ioValue); i++ {
		if goSlice1[i] == nil {
			(*ioValue) = (*ioValue)[:i]
			break
		}
		if (*ioValue)[i] == nil {
			(*ioValue)[i] = &Id{}
			runtime.SetFinalizer((*ioValue)[i], func(o *Id) {
				o.Release()
			})
		}
		(*ioValue)[i].ptr = goSlice1[i]
	}
	(*outError) = (*outError)[:cap(*outError)]
	for i := 0; i < len(*outError); i++ {
		if goSlice3[i] == nil {
			(*outError) = (*outError)[:i]
			break
		}
		if (*outError)[i] == nil {
			(*outError)[i] = &NSError{}
			runtime.SetFinalizer((*outError)[i], func(o *NSError) {
				o.Release()
			})
		}
		(*outError)[i].ptr = goSlice3[i]
	}
	runtime.KeepAlive(o)
	return ret
}

func (o *CBService) ValidateValueForKeyPathError(ioValue *[]*Id, inKeyPath *NSString, outError *[]*NSError) bool {

	goSlice1 := make([]unsafe.Pointer,cap(*ioValue))
	for i := 0; i < len(*ioValue); i++ {
		goSlice1[i] = (*ioValue)[i].Ptr()
	}

	goSlice3 := make([]unsafe.Pointer,cap(*outError))
	for i := 0; i < len(*outError); i++ {
		goSlice3[i] = (*outError)[i].Ptr()
	}
	ret := (bool)(C.CBService_inst_ValidateValueForKeyPathError(o.Ptr(), (*unsafe.Pointer)(unsafe.Pointer(&goSlice1[0])), inKeyPath.Ptr(), (*unsafe.Pointer)(unsafe.Pointer(&goSlice3[0]))))
	(*ioValue) = (*ioValue)[:cap(*ioValue)]
	for i := 0; i < len(*ioValue); i++ {
		if goSlice1[i] == nil {
			(*ioValue) = (*ioValue)[:i]
			break
		}
		if (*ioValue)[i] == nil {
			(*ioValue)[i] = &Id{}
			runtime.SetFinalizer((*ioValue)[i], func(o *Id) {
				o.Release()
			})
		}
		(*ioValue)[i].ptr = goSlice1[i]
	}
	(*outError) = (*outError)[:cap(*outError)]
	for i := 0; i < len(*outError); i++ {
		if goSlice3[i] == nil {
			(*outError) = (*outError)[:i]
			break
		}
		if (*outError)[i] == nil {
			(*outError)[i] = &NSError{}
			runtime.SetFinalizer((*outError)[i], func(o *NSError) {
				o.Release()
			})
		}
		(*outError)[i].ptr = goSlice3[i]
	}
	runtime.KeepAlive(o)
	return ret
}

func (o *CBService) PerformSelectorWithObject(aSelector SEL, anArgument NSObject, delay NSTimeInterval)  {
	C.CBService_inst_PerformSelectorWithObject(o.Ptr(), unsafe.Pointer(aSelector), anArgument.Ptr(), (C.NSTimeInterval)(delay))
	runtime.KeepAlive(o)
}

func (o *CBService) PerformSelectorWithObjectAfterDelay(aSelector SEL, anArgument NSObject, delay NSTimeInterval)  {
	C.CBService_inst_PerformSelectorWithObjectAfterDelay(o.Ptr(), unsafe.Pointer(aSelector), anArgument.Ptr(), (C.NSTimeInterval)(delay))
	runtime.KeepAlive(o)
}

func (o *CBService) PerformSelectorWithObjectAfterDelayInModes(aSelector SEL, anArgument NSObject, delay NSTimeInterval, modes *NSArray)  {
	C.CBService_inst_PerformSelectorWithObjectAfterDelayInModes(o.Ptr(), unsafe.Pointer(aSelector), anArgument.Ptr(), (C.NSTimeInterval)(delay), modes.Ptr())
	runtime.KeepAlive(o)
}

func (o *CBService) PerformSelectorOnThread(aSelector SEL, thr *NSThread, arg NSObject, wait BOOL)  {
	C.CBService_inst_PerformSelectorOnThread(o.Ptr(), unsafe.Pointer(aSelector), thr.Ptr(), arg.Ptr(), (C.BOOL)(wait))
	runtime.KeepAlive(o)
}

func (o *CBService) PerformSelectorOnThreadWithObject(aSelector SEL, thr *NSThread, arg NSObject, wait BOOL)  {
	C.CBService_inst_PerformSelectorOnThreadWithObject(o.Ptr(), unsafe.Pointer(aSelector), thr.Ptr(), arg.Ptr(), (C.BOOL)(wait))
	runtime.KeepAlive(o)
}

func (o *CBService) PerformSelectorOnThreadWithObjectWaitUntilDone(aSelector SEL, thr *NSThread, arg NSObject, wait BOOL, array *NSArray)  {
	C.CBService_inst_PerformSelectorOnThreadWithObjectWaitUntilDone(o.Ptr(), unsafe.Pointer(aSelector), thr.Ptr(), arg.Ptr(), (C.BOOL)(wait), array.Ptr())
	runtime.KeepAlive(o)
}

func (o *CBService) PerformSelectorOnThreadWithObjectWaitUntilDoneModes(aSelector SEL, thr *NSThread, arg NSObject, wait BOOL, array *NSArray)  {
	C.CBService_inst_PerformSelectorOnThreadWithObjectWaitUntilDoneModes(o.Ptr(), unsafe.Pointer(aSelector), thr.Ptr(), arg.Ptr(), (C.BOOL)(wait), array.Ptr())
	runtime.KeepAlive(o)
}

func (o *CBService) PerformSelectorOnMainThreadWithObject(aSelector SEL, arg NSObject, wait BOOL)  {
	C.CBService_inst_PerformSelectorOnMainThreadWithObject(o.Ptr(), unsafe.Pointer(aSelector), arg.Ptr(), (C.BOOL)(wait))
	runtime.KeepAlive(o)
}

func (o *CBService) PerformSelectorOnMainThreadWithObjectWaitUntilDone(aSelector SEL, arg NSObject, wait BOOL)  {
	C.CBService_inst_PerformSelectorOnMainThreadWithObjectWaitUntilDone(o.Ptr(), unsafe.Pointer(aSelector), arg.Ptr(), (C.BOOL)(wait))
	runtime.KeepAlive(o)
}

func (o *CBService) PerformSelectorOnMainThreadWithObjectWaitUntilDoneModes(aSelector SEL, arg NSObject, wait BOOL, array *NSArray)  {
	C.CBService_inst_PerformSelectorOnMainThreadWithObjectWaitUntilDoneModes(o.Ptr(), unsafe.Pointer(aSelector), arg.Ptr(), (C.BOOL)(wait), array.Ptr())
	runtime.KeepAlive(o)
}

func (o *CBService) ReplaceValueAtIndexInPropertyWithKey(index NSUInteger, key *NSString, value NSObject)  {
	C.CBService_inst_ReplaceValueAtIndexInPropertyWithKey(o.Ptr(), (C.NSUInteger)(index), key.Ptr(), value.Ptr())
	runtime.KeepAlive(o)
}

func (o *CBService) ReplaceValueAtIndexInPropertyWithKeyWithValue(index NSUInteger, key *NSString, value NSObject)  {
	C.CBService_inst_ReplaceValueAtIndexInPropertyWithKeyWithValue(o.Ptr(), (C.NSUInteger)(index), key.Ptr(), value.Ptr())
	runtime.KeepAlive(o)
}

func (o *CBService) SetNilValueForKey(key *NSString)  {
	C.CBService_inst_SetNilValueForKey(o.Ptr(), key.Ptr())
	runtime.KeepAlive(o)
}

func (o *CBService) Characteristics() *NSArray {
	ret := &NSArray{}
	ret.ptr = unsafe.Pointer(C.CBService_inst_Characteristics(o.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSArray)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *NSArray) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *CBService) UUID() *CBUUID {
	ret := &CBUUID{}
	ret.ptr = unsafe.Pointer(C.CBService_inst_UUID(o.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*CBUUID)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *CBUUID) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *CBService) ScriptingValueForSpecifier(objectSpecifier *NSScriptObjectSpecifier) *Id {
	ret := &Id{}
	ret.ptr = unsafe.Pointer(C.CBService_inst_ScriptingValueForSpecifier(o.Ptr(), objectSpecifier.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *Id) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *CBService) ScriptingContains(object NSObject) bool {
	ret := (bool)(C.CBService_inst_ScriptingContains(o.Ptr(), object.Ptr()))
	runtime.KeepAlive(o)
	return ret
}

func (o *CBService) MutableSetValueForKeyPath(keyPath *NSString) *NSMutableSet {
	ret := &NSMutableSet{}
	ret.ptr = unsafe.Pointer(C.CBService_inst_MutableSetValueForKeyPath(o.Ptr(), keyPath.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSMutableSet)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *NSMutableSet) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *CBService) MutableOrderedSetValueForKey(key *NSString) *NSMutableOrderedSet {
	ret := &NSMutableOrderedSet{}
	ret.ptr = unsafe.Pointer(C.CBService_inst_MutableOrderedSetValueForKey(o.Ptr(), key.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSMutableOrderedSet)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *NSMutableOrderedSet) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *CBService) NewScriptingObjectOfClassForValueForKey(objectClass Class, key *NSString, contentsValue NSObject, properties *NSDictionary) *Id {
	ret := &Id{}
	ret.ptr = unsafe.Pointer(C.CBService_inst_NewScriptingObjectOfClassForValueForKey(o.Ptr(), unsafe.Pointer(objectClass), key.Ptr(), contentsValue.Ptr(), properties.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *Id) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *CBService) NewScriptingObjectOfClassForValueForKeyWithContentsValue(objectClass Class, key *NSString, contentsValue NSObject, properties *NSDictionary) *Id {
	ret := &Id{}
	ret.ptr = unsafe.Pointer(C.CBService_inst_NewScriptingObjectOfClassForValueForKeyWithContentsValue(o.Ptr(), unsafe.Pointer(objectClass), key.Ptr(), contentsValue.Ptr(), properties.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *Id) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *CBService) DoesContain(object NSObject) bool {
	ret := (bool)(C.CBService_inst_DoesContain(o.Ptr(), object.Ptr()))
	runtime.KeepAlive(o)
	return ret
}

func (o *CBService) IncludedServices() *NSArray {
	ret := &NSArray{}
	ret.ptr = unsafe.Pointer(C.CBService_inst_IncludedServices(o.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSArray)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *NSArray) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *CBService) Copy() *Id {
	ret := &Id{}
	ret.ptr = unsafe.Pointer(C.CBService_inst_Copy(o.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	runtime.SetFinalizer(ret, func(o *Id) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *CBService) ValueWithUniqueIDInPropertyWithKey(uniqueID NSObject, key *NSString) *Id {
	ret := &Id{}
	ret.ptr = unsafe.Pointer(C.CBService_inst_ValueWithUniqueIDInPropertyWithKey(o.Ptr(), uniqueID.Ptr(), key.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *Id) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *CBService) MutableOrderedSetValueForKeyPath(keyPath *NSString) *NSMutableOrderedSet {
	ret := &NSMutableOrderedSet{}
	ret.ptr = unsafe.Pointer(C.CBService_inst_MutableOrderedSetValueForKeyPath(o.Ptr(), keyPath.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSMutableOrderedSet)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *NSMutableOrderedSet) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *CBService) SetValueForKey(value NSObject, key *NSString)  {
	C.CBService_inst_SetValueForKey(o.Ptr(), value.Ptr(), key.Ptr())
	runtime.KeepAlive(o)
}

func (o *CBService) SetValueForKeyPath(value NSObject, keyPath *NSString)  {
	C.CBService_inst_SetValueForKeyPath(o.Ptr(), value.Ptr(), keyPath.Ptr())
	runtime.KeepAlive(o)
}

func (o *CBService) SetValueForUndefinedKey(value NSObject, key *NSString)  {
	C.CBService_inst_SetValueForUndefinedKey(o.Ptr(), value.Ptr(), key.Ptr())
	runtime.KeepAlive(o)
}

func (o *CBService) RemoveValueAtIndexFromPropertyWithKey(index NSUInteger, key *NSString)  {
	C.CBService_inst_RemoveValueAtIndexFromPropertyWithKey(o.Ptr(), (C.NSUInteger)(index), key.Ptr())
	runtime.KeepAlive(o)
}

func (o *CBService) IsGreaterThan(object NSObject) bool {
	ret := (bool)(C.CBService_inst_IsGreaterThan(o.Ptr(), object.Ptr()))
	runtime.KeepAlive(o)
	return ret
}

func (o *CBService) IsLike(object *NSString) bool {
	ret := (bool)(C.CBService_inst_IsLike(o.Ptr(), object.Ptr()))
	runtime.KeepAlive(o)
	return ret
}

func (o *CBService) IsPrimary() bool {
	ret := (bool)(C.CBService_inst_IsPrimary(o.Ptr()))
	runtime.KeepAlive(o)
	return ret
}

func (o *CBService) AutoContentAccessingProxy() *Id {
	ret := &Id{}
	ret.ptr = unsafe.Pointer(C.CBService_inst_AutoContentAccessingProxy(o.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *Id) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *CBService) ObjectSpecifier() *NSScriptObjectSpecifier {
	ret := &NSScriptObjectSpecifier{}
	ret.ptr = unsafe.Pointer(C.CBService_inst_ObjectSpecifier(o.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSScriptObjectSpecifier)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *NSScriptObjectSpecifier) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *CBService) ToOneRelationshipKeys() *NSArray {
	ret := &NSArray{}
	ret.ptr = unsafe.Pointer(C.CBService_inst_ToOneRelationshipKeys(o.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSArray)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *NSArray) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *CBService) ScriptingProperties() *NSDictionary {
	ret := &NSDictionary{}
	ret.ptr = unsafe.Pointer(C.CBService_inst_ScriptingProperties(o.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSDictionary)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *NSDictionary) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *CBService) ClassForArchiver() Class {
	ret := (Class)(unsafe.Pointer(C.CBService_inst_ClassForArchiver(o.Ptr())))
	runtime.KeepAlive(o)
	return ret
}

func (o *CBService) AttributeKeys() *NSArray {
	ret := &NSArray{}
	ret.ptr = unsafe.Pointer(C.CBService_inst_AttributeKeys(o.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSArray)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *NSArray) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *CBService) ScriptingIsEqualTo(object NSObject) bool {
	ret := (bool)(C.CBService_inst_ScriptingIsEqualTo(o.Ptr(), object.Ptr()))
	runtime.KeepAlive(o)
	return ret
}

func (o *CBService) DoesNotRecognizeSelector(aSelector SEL)  {
	C.CBService_inst_DoesNotRecognizeSelector(o.Ptr(), unsafe.Pointer(aSelector))
	runtime.KeepAlive(o)
}

func (o *CBService) ScriptingIsGreaterThan(object NSObject) bool {
	ret := (bool)(C.CBService_inst_ScriptingIsGreaterThan(o.Ptr(), object.Ptr()))
	runtime.KeepAlive(o)
	return ret
}

func (o *CBService) SetScriptingProperties(scriptingProperties *NSDictionary)  {
	C.CBService_inst_SetScriptingProperties(o.Ptr(), scriptingProperties.Ptr())
	runtime.KeepAlive(o)
}

func (o *CBService) ForwardInvocation(anInvocation *NSInvocation)  {
	C.CBService_inst_ForwardInvocation(o.Ptr(), anInvocation.Ptr())
	runtime.KeepAlive(o)
}

func (o *CBService) DidChangeValuesAtIndexes(changeKind NSKeyValueChange, indexes *NSIndexSet, key *NSString)  {
	C.CBService_inst_DidChangeValuesAtIndexes(o.Ptr(), (C.NSKeyValueChange)(changeKind), indexes.Ptr(), key.Ptr())
	runtime.KeepAlive(o)
}

func (o *CBService) DidChangeValuesAtIndexesForKey(changeKind NSKeyValueChange, indexes *NSIndexSet, key *NSString)  {
	C.CBService_inst_DidChangeValuesAtIndexesForKey(o.Ptr(), (C.NSKeyValueChange)(changeKind), indexes.Ptr(), key.Ptr())
	runtime.KeepAlive(o)
}

func (o *CBService) MutableArrayValueForKeyPath(keyPath *NSString) *NSMutableArray {
	ret := &NSMutableArray{}
	ret.ptr = unsafe.Pointer(C.CBService_inst_MutableArrayValueForKeyPath(o.Ptr(), keyPath.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSMutableArray)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *NSMutableArray) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *CBService) ReplacementObjectForCoder(coder *NSCoder) *Id {
	ret := &Id{}
	ret.ptr = unsafe.Pointer(C.CBService_inst_ReplacementObjectForCoder(o.Ptr(), coder.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *Id) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *CBService) DidChangeValueForKey(key *NSString)  {
	C.CBService_inst_DidChangeValueForKey(o.Ptr(), key.Ptr())
	runtime.KeepAlive(o)
}

func (o *CBService) DidChangeValueForKeyWithSetMutation(key *NSString, mutationKind NSKeyValueSetMutationKind, objects *NSSet)  {
	C.CBService_inst_DidChangeValueForKeyWithSetMutation(o.Ptr(), key.Ptr(), (C.NSKeyValueSetMutationKind)(mutationKind), objects.Ptr())
	runtime.KeepAlive(o)
}

func (o *CBService) DidChangeValueForKeyWithSetMutationUsingObjects(key *NSString, mutationKind NSKeyValueSetMutationKind, objects *NSSet)  {
	C.CBService_inst_DidChangeValueForKeyWithSetMutationUsingObjects(o.Ptr(), key.Ptr(), (C.NSKeyValueSetMutationKind)(mutationKind), objects.Ptr())
	runtime.KeepAlive(o)
}

func (o *CBService) ValueForKeyPath(keyPath *NSString) *Id {
	ret := &Id{}
	ret.ptr = unsafe.Pointer(C.CBService_inst_ValueForKeyPath(o.Ptr(), keyPath.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *Id) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *CBService) ScriptingBeginsWith(object NSObject) bool {
	ret := (bool)(C.CBService_inst_ScriptingBeginsWith(o.Ptr(), object.Ptr()))
	runtime.KeepAlive(o)
	return ret
}

func (o *CBService) ClassDescription() *NSClassDescription {
	ret := &NSClassDescription{}
	ret.ptr = unsafe.Pointer(C.CBService_inst_ClassDescription(o.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSClassDescription)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *NSClassDescription) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *CBService) WillChangeValuesAtIndexes(changeKind NSKeyValueChange, indexes *NSIndexSet, key *NSString)  {
	C.CBService_inst_WillChangeValuesAtIndexes(o.Ptr(), (C.NSKeyValueChange)(changeKind), indexes.Ptr(), key.Ptr())
	runtime.KeepAlive(o)
}

func (o *CBService) WillChangeValuesAtIndexesForKey(changeKind NSKeyValueChange, indexes *NSIndexSet, key *NSString)  {
	C.CBService_inst_WillChangeValuesAtIndexesForKey(o.Ptr(), (C.NSKeyValueChange)(changeKind), indexes.Ptr(), key.Ptr())
	runtime.KeepAlive(o)
}

func (o *CBService) ObserveValueForKeyPathOfObject(keyPath *NSString, object NSObject, change *NSDictionary, context unsafe.Pointer)  {
	C.CBService_inst_ObserveValueForKeyPathOfObject(o.Ptr(), keyPath.Ptr(), object.Ptr(), change.Ptr(), unsafe.Pointer(context))
	runtime.KeepAlive(o)
}

func (o *CBService) ObserveValueForKeyPathOfObjectChange(keyPath *NSString, object NSObject, change *NSDictionary, context unsafe.Pointer)  {
	C.CBService_inst_ObserveValueForKeyPathOfObjectChange(o.Ptr(), keyPath.Ptr(), object.Ptr(), change.Ptr(), unsafe.Pointer(context))
	runtime.KeepAlive(o)
}

func (o *CBService) WillChangeValueForKey(key *NSString)  {
	C.CBService_inst_WillChangeValueForKey(o.Ptr(), key.Ptr())
	runtime.KeepAlive(o)
}

func (o *CBService) WillChangeValueForKeyWithSetMutation(key *NSString, mutationKind NSKeyValueSetMutationKind, objects *NSSet)  {
	C.CBService_inst_WillChangeValueForKeyWithSetMutation(o.Ptr(), key.Ptr(), (C.NSKeyValueSetMutationKind)(mutationKind), objects.Ptr())
	runtime.KeepAlive(o)
}

func (o *CBService) WillChangeValueForKeyWithSetMutationUsingObjects(key *NSString, mutationKind NSKeyValueSetMutationKind, objects *NSSet)  {
	C.CBService_inst_WillChangeValueForKeyWithSetMutationUsingObjects(o.Ptr(), key.Ptr(), (C.NSKeyValueSetMutationKind)(mutationKind), objects.Ptr())
	runtime.KeepAlive(o)
}

func (o *CBService) AddObserverForKeyPath(observer NSObject, keyPath *NSString, options NSKeyValueObservingOptions, context unsafe.Pointer)  {
	C.CBService_inst_AddObserverForKeyPath(o.Ptr(), observer.Ptr(), keyPath.Ptr(), (C.NSKeyValueObservingOptions)(options), unsafe.Pointer(context))
	runtime.KeepAlive(o)
}

func (o *CBService) AddObserverForKeyPathOptions(observer NSObject, keyPath *NSString, options NSKeyValueObservingOptions, context unsafe.Pointer)  {
	C.CBService_inst_AddObserverForKeyPathOptions(o.Ptr(), observer.Ptr(), keyPath.Ptr(), (C.NSKeyValueObservingOptions)(options), unsafe.Pointer(context))
	runtime.KeepAlive(o)
}

func (o *CBService) ValueWithNameInPropertyWithKey(name *NSString, key *NSString) *Id {
	ret := &Id{}
	ret.ptr = unsafe.Pointer(C.CBService_inst_ValueWithNameInPropertyWithKey(o.Ptr(), name.Ptr(), key.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *Id) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *CBService) SetValuesForKeysWithDictionary(keyedValues *NSDictionary)  {
	C.CBService_inst_SetValuesForKeysWithDictionary(o.Ptr(), keyedValues.Ptr())
	runtime.KeepAlive(o)
}

func (o *CBService) ValueAtIndexInPropertyWithKey(index NSUInteger, key *NSString) *Id {
	ret := &Id{}
	ret.ptr = unsafe.Pointer(C.CBService_inst_ValueAtIndexInPropertyWithKey(o.Ptr(), (C.NSUInteger)(index), key.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *Id) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *CBService) ScriptingIsLessThanOrEqualTo(object NSObject) bool {
	ret := (bool)(C.CBService_inst_ScriptingIsLessThanOrEqualTo(o.Ptr(), object.Ptr()))
	runtime.KeepAlive(o)
	return ret
}

func (o *CBService) ClassCode() FourCharCode {
	ret := (FourCharCode)(C.CBService_inst_ClassCode(o.Ptr()))
	runtime.KeepAlive(o)
	return ret
}

func (o *CBService) DictionaryWithValuesForKeys(keys *NSArray) *NSDictionary {
	ret := &NSDictionary{}
	ret.ptr = unsafe.Pointer(C.CBService_inst_DictionaryWithValuesForKeys(o.Ptr(), keys.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSDictionary)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *NSDictionary) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *CBService) MethodSignatureForSelector(aSelector SEL) *NSMethodSignature {
	ret := &NSMethodSignature{}
	ret.ptr = unsafe.Pointer(C.CBService_inst_MethodSignatureForSelector(o.Ptr(), unsafe.Pointer(aSelector)))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSMethodSignature)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *NSMethodSignature) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *CBService) MutableArrayValueForKey(key *NSString) *NSMutableArray {
	ret := &NSMutableArray{}
	ret.ptr = unsafe.Pointer(C.CBService_inst_MutableArrayValueForKey(o.Ptr(), key.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSMutableArray)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *NSMutableArray) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *CBService) ToManyRelationshipKeys() *NSArray {
	ret := &NSArray{}
	ret.ptr = unsafe.Pointer(C.CBService_inst_ToManyRelationshipKeys(o.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSArray)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *NSArray) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *CBService) ClassName() *NSString {
	ret := &NSString{}
	ret.ptr = unsafe.Pointer(C.CBService_inst_ClassName(o.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSString)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *NSString) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *CBService) ForwardingTargetForSelector(aSelector SEL) *Id {
	ret := &Id{}
	ret.ptr = unsafe.Pointer(C.CBService_inst_ForwardingTargetForSelector(o.Ptr(), unsafe.Pointer(aSelector)))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *Id) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *CBService) ReplacementObjectForKeyedArchiver(archiver *NSKeyedArchiver) *Id {
	ret := &Id{}
	ret.ptr = unsafe.Pointer(C.CBService_inst_ReplacementObjectForKeyedArchiver(o.Ptr(), archiver.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *Id) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *CBService) AttemptRecoveryFromErrorOptionIndex(error *NSError, recoveryOptionIndex NSUInteger) bool {
	ret := (bool)(C.CBService_inst_AttemptRecoveryFromErrorOptionIndex(o.Ptr(), error.Ptr(), (C.NSUInteger)(recoveryOptionIndex)))
	runtime.KeepAlive(o)
	return ret
}

func (o *CBService) AttemptRecoveryFromErrorOptionIndexDelegate(error *NSError, recoveryOptionIndex NSUInteger, delegate NSObject, didRecoverSelector SEL, contextInfo unsafe.Pointer)  {
	C.CBService_inst_AttemptRecoveryFromErrorOptionIndexDelegate(o.Ptr(), error.Ptr(), (C.NSUInteger)(recoveryOptionIndex), delegate.Ptr(), unsafe.Pointer(didRecoverSelector), unsafe.Pointer(contextInfo))
	runtime.KeepAlive(o)
}

func (o *CBService) AttemptRecoveryFromErrorOptionIndexDelegateDidRecoverSelector(error *NSError, recoveryOptionIndex NSUInteger, delegate NSObject, didRecoverSelector SEL, contextInfo unsafe.Pointer)  {
	C.CBService_inst_AttemptRecoveryFromErrorOptionIndexDelegateDidRecoverSelector(o.Ptr(), error.Ptr(), (C.NSUInteger)(recoveryOptionIndex), delegate.Ptr(), unsafe.Pointer(didRecoverSelector), unsafe.Pointer(contextInfo))
	runtime.KeepAlive(o)
}

func (o *CBService) IsGreaterThanOrEqualTo(object NSObject) bool {
	ret := (bool)(C.CBService_inst_IsGreaterThanOrEqualTo(o.Ptr(), object.Ptr()))
	runtime.KeepAlive(o)
	return ret
}

func (o *CBService) PerformSelectorInBackgroundWithObject(aSelector SEL, arg NSObject)  {
	C.CBService_inst_PerformSelectorInBackgroundWithObject(o.Ptr(), unsafe.Pointer(aSelector), arg.Ptr())
	runtime.KeepAlive(o)
}

func (o *CBService) Peripheral() *CBPeripheral {
	ret := &CBPeripheral{}
	ret.ptr = unsafe.Pointer(C.CBService_inst_Peripheral(o.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*CBPeripheral)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *CBPeripheral) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *CBService) ScriptingIsGreaterThanOrEqualTo(object NSObject) bool {
	ret := (bool)(C.CBService_inst_ScriptingIsGreaterThanOrEqualTo(o.Ptr(), object.Ptr()))
	runtime.KeepAlive(o)
	return ret
}

func (o *CBService) IsLessThanOrEqualTo(object NSObject) bool {
	ret := (bool)(C.CBService_inst_IsLessThanOrEqualTo(o.Ptr(), object.Ptr()))
	runtime.KeepAlive(o)
	return ret
}

func (o *CBService) CopyScriptingValueForKey(value NSObject, key *NSString, properties *NSDictionary) *Id {
	ret := &Id{}
	ret.ptr = unsafe.Pointer(C.CBService_inst_CopyScriptingValueForKey(o.Ptr(), value.Ptr(), key.Ptr(), properties.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *Id) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *CBService) CopyScriptingValueForKeyWithProperties(value NSObject, key *NSString, properties *NSDictionary) *Id {
	ret := &Id{}
	ret.ptr = unsafe.Pointer(C.CBService_inst_CopyScriptingValueForKeyWithProperties(o.Ptr(), value.Ptr(), key.Ptr(), properties.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *Id) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *CBService) ClassForKeyedArchiver() Class {
	ret := (Class)(unsafe.Pointer(C.CBService_inst_ClassForKeyedArchiver(o.Ptr())))
	runtime.KeepAlive(o)
	return ret
}

func (o *CBService) SetObservationInfo(observationInfo unsafe.Pointer)  {
	C.CBService_inst_SetObservationInfo(o.Ptr(), unsafe.Pointer(observationInfo))
	runtime.KeepAlive(o)
}

func (o *CBService) IsNotEqualTo(object NSObject) bool {
	ret := (bool)(C.CBService_inst_IsNotEqualTo(o.Ptr(), object.Ptr()))
	runtime.KeepAlive(o)
	return ret
}

func (o *CBService) Dealloc()  {
	C.CBService_inst_Dealloc(o.Ptr())
	runtime.KeepAlive(o)
}

func (o *CBService) ScriptingEndsWith(object NSObject) bool {
	ret := (bool)(C.CBService_inst_ScriptingEndsWith(o.Ptr(), object.Ptr()))
	runtime.KeepAlive(o)
	return ret
}

func (o *CBService) IsEqualTo(object NSObject) bool {
	ret := (bool)(C.CBService_inst_IsEqualTo(o.Ptr(), object.Ptr()))
	runtime.KeepAlive(o)
	return ret
}

func (o *CBService) ClassForCoder() Class {
	ret := (Class)(unsafe.Pointer(C.CBService_inst_ClassForCoder(o.Ptr())))
	runtime.KeepAlive(o)
	return ret
}

func (o *CBService) InverseForRelationshipKey(relationshipKey *NSString) *NSString {
	ret := &NSString{}
	ret.ptr = unsafe.Pointer(C.CBService_inst_InverseForRelationshipKey(o.Ptr(), relationshipKey.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSString)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *NSString) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *CBService) ValueForKey(key *NSString) *Id {
	ret := &Id{}
	ret.ptr = unsafe.Pointer(C.CBService_inst_ValueForKey(o.Ptr(), key.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *Id) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *CBService) IsCaseInsensitiveLike(object *NSString) bool {
	ret := (bool)(C.CBService_inst_IsCaseInsensitiveLike(o.Ptr(), object.Ptr()))
	runtime.KeepAlive(o)
	return ret
}

func (o *CBService) MutableCopy() *Id {
	ret := &Id{}
	ret.ptr = unsafe.Pointer(C.CBService_inst_MutableCopy(o.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	runtime.SetFinalizer(ret, func(o *Id) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *CBService) ScriptingIsLessThan(object NSObject) bool {
	ret := (bool)(C.CBService_inst_ScriptingIsLessThan(o.Ptr(), object.Ptr()))
	runtime.KeepAlive(o)
	return ret
}

func (o *CBService) CoerceValueForKey(value NSObject, key *NSString) *Id {
	ret := &Id{}
	ret.ptr = unsafe.Pointer(C.CBService_inst_CoerceValueForKey(o.Ptr(), value.Ptr(), key.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *Id) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func CBAttributeAutomaticallyNotifiesObserversForKey(key *NSString) bool {
	ret := (bool)(C.CBAttribute_AutomaticallyNotifiesObserversForKey(key.Ptr()))
	return ret
}

func CBAttributeResolveClassMethod(sel SEL) bool {
	ret := (bool)(C.CBAttribute_ResolveClassMethod(unsafe.Pointer(sel)))
	return ret
}

func CBAttributeDebugDescription() *NSString {
	ret := &NSString{}
	ret.ptr = unsafe.Pointer(C.CBAttribute_DebugDescription())
	if ret.ptr == nil { return ret }
	return ret
}

func CBAttributeAllocWithZone(zone *_NSZone) *CBAttribute {
	ret := &CBAttribute{}
	ret.ptr = unsafe.Pointer(C.CBAttribute_AllocWithZone(unsafe.Pointer(zone)))
	if ret.ptr == nil { return ret }
	runtime.SetFinalizer(ret, func(o *CBAttribute) {
		o.Release()
	})
	return ret
}

func CBAttributeAccessInstanceVariablesDirectly() bool {
	ret := (bool)(C.CBAttribute_AccessInstanceVariablesDirectly())
	return ret
}

func CBAttributeSetVersion(aVersion NSInteger)  {
	C.CBAttribute_SetVersion((C.NSInteger)(aVersion))
}

func CBAttributeHash() NSUInteger {
	ret := (NSUInteger)(C.CBAttribute_Hash())
	return ret
}

func CBAttributeAlloc() *CBAttribute {
	ret := &CBAttribute{}
	ret.ptr = unsafe.Pointer(C.CBAttribute_Alloc())
	if ret.ptr == nil { return ret }
	runtime.SetFinalizer(ret, func(o *CBAttribute) {
		o.Release()
	})
	return ret
}

func (o *CBAttribute) GC() {
	if o.ptr == nil { return }
	runtime.SetFinalizer(o, func(o *CBAttribute) {
		o.Release()
	})
	runtime.KeepAlive(o)
}

func CBAttributeCopyWithZone(zone *_NSZone) *Id {
	ret := &Id{}
	ret.ptr = unsafe.Pointer(C.CBAttribute_CopyWithZone(unsafe.Pointer(zone)))
	if ret.ptr == nil { return ret }
	runtime.SetFinalizer(ret, func(o *Id) {
		o.Release()
	})
	return ret
}

func CBAttributeDescription() *NSString {
	ret := &NSString{}
	ret.ptr = unsafe.Pointer(C.CBAttribute_Description())
	if ret.ptr == nil { return ret }
	return ret
}

func CBAttributeInstancesRespondToSelector(aSelector SEL) bool {
	ret := (bool)(C.CBAttribute_InstancesRespondToSelector(unsafe.Pointer(aSelector)))
	return ret
}

func CBAttributeKeyPathsForValuesAffectingValueForKey(key *NSString) *NSSet {
	ret := &NSSet{}
	ret.ptr = unsafe.Pointer(C.CBAttribute_KeyPathsForValuesAffectingValueForKey(key.Ptr()))
	if ret.ptr == nil { return ret }
	return ret
}

func CBAttributeNew() *CBAttribute {
	ret := &CBAttribute{}
	ret.ptr = unsafe.Pointer(C.CBAttribute_New())
	if ret.ptr == nil { return ret }
	runtime.SetFinalizer(ret, func(o *CBAttribute) {
		o.Release()
	})
	return ret
}

func CBAttributeConformsToProtocol(protocol Protocol) bool {
	ret := (bool)(C.CBAttribute_ConformsToProtocol(protocol.Ptr()))
	return ret
}

func CBAttributeResolveInstanceMethod(sel SEL) bool {
	ret := (bool)(C.CBAttribute_ResolveInstanceMethod(unsafe.Pointer(sel)))
	return ret
}

func CBAttributeIsSubclassOfClass(aClass Class) bool {
	ret := (bool)(C.CBAttribute_IsSubclassOfClass(unsafe.Pointer(aClass)))
	return ret
}

func CBAttributeCancelPreviousPerformRequestsWithTarget(aTarget NSObject)  {
	C.CBAttribute_CancelPreviousPerformRequestsWithTarget(aTarget.Ptr())
}

func CBAttributeCancelPreviousPerformRequestsWithTargetSelector(aTarget NSObject, aSelector SEL, anArgument NSObject)  {
	C.CBAttribute_CancelPreviousPerformRequestsWithTargetSelector(aTarget.Ptr(), unsafe.Pointer(aSelector), anArgument.Ptr())
}

func CBAttributeCancelPreviousPerformRequestsWithTargetSelectorObject(aTarget NSObject, aSelector SEL, anArgument NSObject)  {
	C.CBAttribute_CancelPreviousPerformRequestsWithTargetSelectorObject(aTarget.Ptr(), unsafe.Pointer(aSelector), anArgument.Ptr())
}

func CBAttributeClass() Class {
	ret := (Class)(unsafe.Pointer(C.CBAttribute_Class()))
	return ret
}

func CBAttributeSuperclass() Class {
	ret := (Class)(unsafe.Pointer(C.CBAttribute_Superclass()))
	return ret
}

func CBAttributeLoad()  {
	C.CBAttribute_Load()
}

func CBAttributeVersion() NSInteger {
	ret := (NSInteger)(C.CBAttribute_Version())
	return ret
}

func CBAttributeMutableCopyWithZone(zone *_NSZone) *Id {
	ret := &Id{}
	ret.ptr = unsafe.Pointer(C.CBAttribute_MutableCopyWithZone(unsafe.Pointer(zone)))
	if ret.ptr == nil { return ret }
	runtime.SetFinalizer(ret, func(o *Id) {
		o.Release()
	})
	return ret
}

func CBAttributeClassFallbacksForKeyedArchiver() *NSArray {
	ret := &NSArray{}
	ret.ptr = unsafe.Pointer(C.CBAttribute_ClassFallbacksForKeyedArchiver())
	if ret.ptr == nil { return ret }
	return ret
}

func CBAttributeInstanceMethodSignatureForSelector(aSelector SEL) *NSMethodSignature {
	ret := &NSMethodSignature{}
	ret.ptr = unsafe.Pointer(C.CBAttribute_InstanceMethodSignatureForSelector(unsafe.Pointer(aSelector)))
	if ret.ptr == nil { return ret }
	return ret
}

func CBAttributeClassForKeyedUnarchiver() Class {
	ret := (Class)(unsafe.Pointer(C.CBAttribute_ClassForKeyedUnarchiver()))
	return ret
}

func (o *CBAttribute) ScriptingValueForSpecifier(objectSpecifier *NSScriptObjectSpecifier) *Id {
	ret := &Id{}
	ret.ptr = unsafe.Pointer(C.CBAttribute_inst_ScriptingValueForSpecifier(o.Ptr(), objectSpecifier.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *Id) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *CBAttribute) Dealloc()  {
	C.CBAttribute_inst_Dealloc(o.Ptr())
	runtime.KeepAlive(o)
}

func (o *CBAttribute) ClassName() *NSString {
	ret := &NSString{}
	ret.ptr = unsafe.Pointer(C.CBAttribute_inst_ClassName(o.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSString)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *NSString) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *CBAttribute) ScriptingContains(object NSObject) bool {
	ret := (bool)(C.CBAttribute_inst_ScriptingContains(o.Ptr(), object.Ptr()))
	runtime.KeepAlive(o)
	return ret
}

func (o *CBAttribute) ReplaceValueAtIndexInPropertyWithKey(index NSUInteger, key *NSString, value NSObject)  {
	C.CBAttribute_inst_ReplaceValueAtIndexInPropertyWithKey(o.Ptr(), (C.NSUInteger)(index), key.Ptr(), value.Ptr())
	runtime.KeepAlive(o)
}

func (o *CBAttribute) ReplaceValueAtIndexInPropertyWithKeyWithValue(index NSUInteger, key *NSString, value NSObject)  {
	C.CBAttribute_inst_ReplaceValueAtIndexInPropertyWithKeyWithValue(o.Ptr(), (C.NSUInteger)(index), key.Ptr(), value.Ptr())
	runtime.KeepAlive(o)
}

func (o *CBAttribute) DidChangeValueForKey(key *NSString)  {
	C.CBAttribute_inst_DidChangeValueForKey(o.Ptr(), key.Ptr())
	runtime.KeepAlive(o)
}

func (o *CBAttribute) DidChangeValueForKeyWithSetMutation(key *NSString, mutationKind NSKeyValueSetMutationKind, objects *NSSet)  {
	C.CBAttribute_inst_DidChangeValueForKeyWithSetMutation(o.Ptr(), key.Ptr(), (C.NSKeyValueSetMutationKind)(mutationKind), objects.Ptr())
	runtime.KeepAlive(o)
}

func (o *CBAttribute) DidChangeValueForKeyWithSetMutationUsingObjects(key *NSString, mutationKind NSKeyValueSetMutationKind, objects *NSSet)  {
	C.CBAttribute_inst_DidChangeValueForKeyWithSetMutationUsingObjects(o.Ptr(), key.Ptr(), (C.NSKeyValueSetMutationKind)(mutationKind), objects.Ptr())
	runtime.KeepAlive(o)
}

func (o *CBAttribute) ValueForKeyPath(keyPath *NSString) *Id {
	ret := &Id{}
	ret.ptr = unsafe.Pointer(C.CBAttribute_inst_ValueForKeyPath(o.Ptr(), keyPath.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *Id) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *CBAttribute) ScriptingEndsWith(object NSObject) bool {
	ret := (bool)(C.CBAttribute_inst_ScriptingEndsWith(o.Ptr(), object.Ptr()))
	runtime.KeepAlive(o)
	return ret
}

func (o *CBAttribute) IsCaseInsensitiveLike(object *NSString) bool {
	ret := (bool)(C.CBAttribute_inst_IsCaseInsensitiveLike(o.Ptr(), object.Ptr()))
	runtime.KeepAlive(o)
	return ret
}

func (o *CBAttribute) PerformSelectorWithObject(aSelector SEL, anArgument NSObject, delay NSTimeInterval)  {
	C.CBAttribute_inst_PerformSelectorWithObject(o.Ptr(), unsafe.Pointer(aSelector), anArgument.Ptr(), (C.NSTimeInterval)(delay))
	runtime.KeepAlive(o)
}

func (o *CBAttribute) PerformSelectorWithObjectAfterDelay(aSelector SEL, anArgument NSObject, delay NSTimeInterval)  {
	C.CBAttribute_inst_PerformSelectorWithObjectAfterDelay(o.Ptr(), unsafe.Pointer(aSelector), anArgument.Ptr(), (C.NSTimeInterval)(delay))
	runtime.KeepAlive(o)
}

func (o *CBAttribute) PerformSelectorWithObjectAfterDelayInModes(aSelector SEL, anArgument NSObject, delay NSTimeInterval, modes *NSArray)  {
	C.CBAttribute_inst_PerformSelectorWithObjectAfterDelayInModes(o.Ptr(), unsafe.Pointer(aSelector), anArgument.Ptr(), (C.NSTimeInterval)(delay), modes.Ptr())
	runtime.KeepAlive(o)
}

func (o *CBAttribute) PerformSelectorOnThread(aSelector SEL, thr *NSThread, arg NSObject, wait BOOL)  {
	C.CBAttribute_inst_PerformSelectorOnThread(o.Ptr(), unsafe.Pointer(aSelector), thr.Ptr(), arg.Ptr(), (C.BOOL)(wait))
	runtime.KeepAlive(o)
}

func (o *CBAttribute) PerformSelectorOnThreadWithObject(aSelector SEL, thr *NSThread, arg NSObject, wait BOOL)  {
	C.CBAttribute_inst_PerformSelectorOnThreadWithObject(o.Ptr(), unsafe.Pointer(aSelector), thr.Ptr(), arg.Ptr(), (C.BOOL)(wait))
	runtime.KeepAlive(o)
}

func (o *CBAttribute) PerformSelectorOnThreadWithObjectWaitUntilDone(aSelector SEL, thr *NSThread, arg NSObject, wait BOOL, array *NSArray)  {
	C.CBAttribute_inst_PerformSelectorOnThreadWithObjectWaitUntilDone(o.Ptr(), unsafe.Pointer(aSelector), thr.Ptr(), arg.Ptr(), (C.BOOL)(wait), array.Ptr())
	runtime.KeepAlive(o)
}

func (o *CBAttribute) PerformSelectorOnThreadWithObjectWaitUntilDoneModes(aSelector SEL, thr *NSThread, arg NSObject, wait BOOL, array *NSArray)  {
	C.CBAttribute_inst_PerformSelectorOnThreadWithObjectWaitUntilDoneModes(o.Ptr(), unsafe.Pointer(aSelector), thr.Ptr(), arg.Ptr(), (C.BOOL)(wait), array.Ptr())
	runtime.KeepAlive(o)
}

func (o *CBAttribute) MutableSetValueForKey(key *NSString) *NSMutableSet {
	ret := &NSMutableSet{}
	ret.ptr = unsafe.Pointer(C.CBAttribute_inst_MutableSetValueForKey(o.Ptr(), key.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSMutableSet)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *NSMutableSet) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *CBAttribute) DictionaryWithValuesForKeys(keys *NSArray) *NSDictionary {
	ret := &NSDictionary{}
	ret.ptr = unsafe.Pointer(C.CBAttribute_inst_DictionaryWithValuesForKeys(o.Ptr(), keys.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSDictionary)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *NSDictionary) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *CBAttribute) AttemptRecoveryFromErrorOptionIndex(error *NSError, recoveryOptionIndex NSUInteger) bool {
	ret := (bool)(C.CBAttribute_inst_AttemptRecoveryFromErrorOptionIndex(o.Ptr(), error.Ptr(), (C.NSUInteger)(recoveryOptionIndex)))
	runtime.KeepAlive(o)
	return ret
}

func (o *CBAttribute) AttemptRecoveryFromErrorOptionIndexDelegate(error *NSError, recoveryOptionIndex NSUInteger, delegate NSObject, didRecoverSelector SEL, contextInfo unsafe.Pointer)  {
	C.CBAttribute_inst_AttemptRecoveryFromErrorOptionIndexDelegate(o.Ptr(), error.Ptr(), (C.NSUInteger)(recoveryOptionIndex), delegate.Ptr(), unsafe.Pointer(didRecoverSelector), unsafe.Pointer(contextInfo))
	runtime.KeepAlive(o)
}

func (o *CBAttribute) AttemptRecoveryFromErrorOptionIndexDelegateDidRecoverSelector(error *NSError, recoveryOptionIndex NSUInteger, delegate NSObject, didRecoverSelector SEL, contextInfo unsafe.Pointer)  {
	C.CBAttribute_inst_AttemptRecoveryFromErrorOptionIndexDelegateDidRecoverSelector(o.Ptr(), error.Ptr(), (C.NSUInteger)(recoveryOptionIndex), delegate.Ptr(), unsafe.Pointer(didRecoverSelector), unsafe.Pointer(contextInfo))
	runtime.KeepAlive(o)
}

func (o *CBAttribute) ValidateValueForKey(ioValue *[]*Id, inKey *NSString, outError *[]*NSError) bool {

	goSlice1 := make([]unsafe.Pointer,cap(*ioValue))
	for i := 0; i < len(*ioValue); i++ {
		goSlice1[i] = (*ioValue)[i].Ptr()
	}

	goSlice3 := make([]unsafe.Pointer,cap(*outError))
	for i := 0; i < len(*outError); i++ {
		goSlice3[i] = (*outError)[i].Ptr()
	}
	ret := (bool)(C.CBAttribute_inst_ValidateValueForKey(o.Ptr(), (*unsafe.Pointer)(unsafe.Pointer(&goSlice1[0])), inKey.Ptr(), (*unsafe.Pointer)(unsafe.Pointer(&goSlice3[0]))))
	(*ioValue) = (*ioValue)[:cap(*ioValue)]
	for i := 0; i < len(*ioValue); i++ {
		if goSlice1[i] == nil {
			(*ioValue) = (*ioValue)[:i]
			break
		}
		if (*ioValue)[i] == nil {
			(*ioValue)[i] = &Id{}
			runtime.SetFinalizer((*ioValue)[i], func(o *Id) {
				o.Release()
			})
		}
		(*ioValue)[i].ptr = goSlice1[i]
	}
	(*outError) = (*outError)[:cap(*outError)]
	for i := 0; i < len(*outError); i++ {
		if goSlice3[i] == nil {
			(*outError) = (*outError)[:i]
			break
		}
		if (*outError)[i] == nil {
			(*outError)[i] = &NSError{}
			runtime.SetFinalizer((*outError)[i], func(o *NSError) {
				o.Release()
			})
		}
		(*outError)[i].ptr = goSlice3[i]
	}
	runtime.KeepAlive(o)
	return ret
}

func (o *CBAttribute) ValidateValueForKeyPath(ioValue *[]*Id, inKeyPath *NSString, outError *[]*NSError) bool {

	goSlice1 := make([]unsafe.Pointer,cap(*ioValue))
	for i := 0; i < len(*ioValue); i++ {
		goSlice1[i] = (*ioValue)[i].Ptr()
	}

	goSlice3 := make([]unsafe.Pointer,cap(*outError))
	for i := 0; i < len(*outError); i++ {
		goSlice3[i] = (*outError)[i].Ptr()
	}
	ret := (bool)(C.CBAttribute_inst_ValidateValueForKeyPath(o.Ptr(), (*unsafe.Pointer)(unsafe.Pointer(&goSlice1[0])), inKeyPath.Ptr(), (*unsafe.Pointer)(unsafe.Pointer(&goSlice3[0]))))
	(*ioValue) = (*ioValue)[:cap(*ioValue)]
	for i := 0; i < len(*ioValue); i++ {
		if goSlice1[i] == nil {
			(*ioValue) = (*ioValue)[:i]
			break
		}
		if (*ioValue)[i] == nil {
			(*ioValue)[i] = &Id{}
			runtime.SetFinalizer((*ioValue)[i], func(o *Id) {
				o.Release()
			})
		}
		(*ioValue)[i].ptr = goSlice1[i]
	}
	(*outError) = (*outError)[:cap(*outError)]
	for i := 0; i < len(*outError); i++ {
		if goSlice3[i] == nil {
			(*outError) = (*outError)[:i]
			break
		}
		if (*outError)[i] == nil {
			(*outError)[i] = &NSError{}
			runtime.SetFinalizer((*outError)[i], func(o *NSError) {
				o.Release()
			})
		}
		(*outError)[i].ptr = goSlice3[i]
	}
	runtime.KeepAlive(o)
	return ret
}

func (o *CBAttribute) ValidateValueForKeyError(ioValue *[]*Id, inKey *NSString, outError *[]*NSError) bool {

	goSlice1 := make([]unsafe.Pointer,cap(*ioValue))
	for i := 0; i < len(*ioValue); i++ {
		goSlice1[i] = (*ioValue)[i].Ptr()
	}

	goSlice3 := make([]unsafe.Pointer,cap(*outError))
	for i := 0; i < len(*outError); i++ {
		goSlice3[i] = (*outError)[i].Ptr()
	}
	ret := (bool)(C.CBAttribute_inst_ValidateValueForKeyError(o.Ptr(), (*unsafe.Pointer)(unsafe.Pointer(&goSlice1[0])), inKey.Ptr(), (*unsafe.Pointer)(unsafe.Pointer(&goSlice3[0]))))
	(*ioValue) = (*ioValue)[:cap(*ioValue)]
	for i := 0; i < len(*ioValue); i++ {
		if goSlice1[i] == nil {
			(*ioValue) = (*ioValue)[:i]
			break
		}
		if (*ioValue)[i] == nil {
			(*ioValue)[i] = &Id{}
			runtime.SetFinalizer((*ioValue)[i], func(o *Id) {
				o.Release()
			})
		}
		(*ioValue)[i].ptr = goSlice1[i]
	}
	(*outError) = (*outError)[:cap(*outError)]
	for i := 0; i < len(*outError); i++ {
		if goSlice3[i] == nil {
			(*outError) = (*outError)[:i]
			break
		}
		if (*outError)[i] == nil {
			(*outError)[i] = &NSError{}
			runtime.SetFinalizer((*outError)[i], func(o *NSError) {
				o.Release()
			})
		}
		(*outError)[i].ptr = goSlice3[i]
	}
	runtime.KeepAlive(o)
	return ret
}

func (o *CBAttribute) ValidateValueForKeyPathError(ioValue *[]*Id, inKeyPath *NSString, outError *[]*NSError) bool {

	goSlice1 := make([]unsafe.Pointer,cap(*ioValue))
	for i := 0; i < len(*ioValue); i++ {
		goSlice1[i] = (*ioValue)[i].Ptr()
	}

	goSlice3 := make([]unsafe.Pointer,cap(*outError))
	for i := 0; i < len(*outError); i++ {
		goSlice3[i] = (*outError)[i].Ptr()
	}
	ret := (bool)(C.CBAttribute_inst_ValidateValueForKeyPathError(o.Ptr(), (*unsafe.Pointer)(unsafe.Pointer(&goSlice1[0])), inKeyPath.Ptr(), (*unsafe.Pointer)(unsafe.Pointer(&goSlice3[0]))))
	(*ioValue) = (*ioValue)[:cap(*ioValue)]
	for i := 0; i < len(*ioValue); i++ {
		if goSlice1[i] == nil {
			(*ioValue) = (*ioValue)[:i]
			break
		}
		if (*ioValue)[i] == nil {
			(*ioValue)[i] = &Id{}
			runtime.SetFinalizer((*ioValue)[i], func(o *Id) {
				o.Release()
			})
		}
		(*ioValue)[i].ptr = goSlice1[i]
	}
	(*outError) = (*outError)[:cap(*outError)]
	for i := 0; i < len(*outError); i++ {
		if goSlice3[i] == nil {
			(*outError) = (*outError)[:i]
			break
		}
		if (*outError)[i] == nil {
			(*outError)[i] = &NSError{}
			runtime.SetFinalizer((*outError)[i], func(o *NSError) {
				o.Release()
			})
		}
		(*outError)[i].ptr = goSlice3[i]
	}
	runtime.KeepAlive(o)
	return ret
}

func (o *CBAttribute) CoerceValueForKey(value NSObject, key *NSString) *Id {
	ret := &Id{}
	ret.ptr = unsafe.Pointer(C.CBAttribute_inst_CoerceValueForKey(o.Ptr(), value.Ptr(), key.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *Id) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *CBAttribute) SetObservationInfo(observationInfo unsafe.Pointer)  {
	C.CBAttribute_inst_SetObservationInfo(o.Ptr(), unsafe.Pointer(observationInfo))
	runtime.KeepAlive(o)
}

func (o *CBAttribute) IsGreaterThan(object NSObject) bool {
	ret := (bool)(C.CBAttribute_inst_IsGreaterThan(o.Ptr(), object.Ptr()))
	runtime.KeepAlive(o)
	return ret
}

func (o *CBAttribute) ObjectSpecifier() *NSScriptObjectSpecifier {
	ret := &NSScriptObjectSpecifier{}
	ret.ptr = unsafe.Pointer(C.CBAttribute_inst_ObjectSpecifier(o.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSScriptObjectSpecifier)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *NSScriptObjectSpecifier) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *CBAttribute) ValueWithNameInPropertyWithKey(name *NSString, key *NSString) *Id {
	ret := &Id{}
	ret.ptr = unsafe.Pointer(C.CBAttribute_inst_ValueWithNameInPropertyWithKey(o.Ptr(), name.Ptr(), key.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *Id) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *CBAttribute) NewScriptingObjectOfClassForValueForKey(objectClass Class, key *NSString, contentsValue NSObject, properties *NSDictionary) *Id {
	ret := &Id{}
	ret.ptr = unsafe.Pointer(C.CBAttribute_inst_NewScriptingObjectOfClassForValueForKey(o.Ptr(), unsafe.Pointer(objectClass), key.Ptr(), contentsValue.Ptr(), properties.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *Id) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *CBAttribute) NewScriptingObjectOfClassForValueForKeyWithContentsValue(objectClass Class, key *NSString, contentsValue NSObject, properties *NSDictionary) *Id {
	ret := &Id{}
	ret.ptr = unsafe.Pointer(C.CBAttribute_inst_NewScriptingObjectOfClassForValueForKeyWithContentsValue(o.Ptr(), unsafe.Pointer(objectClass), key.Ptr(), contentsValue.Ptr(), properties.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *Id) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *CBAttribute) SetScriptingProperties(scriptingProperties *NSDictionary)  {
	C.CBAttribute_inst_SetScriptingProperties(o.Ptr(), scriptingProperties.Ptr())
	runtime.KeepAlive(o)
}

func (o *CBAttribute) RemoveValueAtIndexFromPropertyWithKey(index NSUInteger, key *NSString)  {
	C.CBAttribute_inst_RemoveValueAtIndexFromPropertyWithKey(o.Ptr(), (C.NSUInteger)(index), key.Ptr())
	runtime.KeepAlive(o)
}

func (o *CBAttribute) AddObserverForKeyPath(observer NSObject, keyPath *NSString, options NSKeyValueObservingOptions, context unsafe.Pointer)  {
	C.CBAttribute_inst_AddObserverForKeyPath(o.Ptr(), observer.Ptr(), keyPath.Ptr(), (C.NSKeyValueObservingOptions)(options), unsafe.Pointer(context))
	runtime.KeepAlive(o)
}

func (o *CBAttribute) AddObserverForKeyPathOptions(observer NSObject, keyPath *NSString, options NSKeyValueObservingOptions, context unsafe.Pointer)  {
	C.CBAttribute_inst_AddObserverForKeyPathOptions(o.Ptr(), observer.Ptr(), keyPath.Ptr(), (C.NSKeyValueObservingOptions)(options), unsafe.Pointer(context))
	runtime.KeepAlive(o)
}

func (o *CBAttribute) ReplacementObjectForCoder(coder *NSCoder) *Id {
	ret := &Id{}
	ret.ptr = unsafe.Pointer(C.CBAttribute_inst_ReplacementObjectForCoder(o.Ptr(), coder.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *Id) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *CBAttribute) ScriptingIsGreaterThanOrEqualTo(object NSObject) bool {
	ret := (bool)(C.CBAttribute_inst_ScriptingIsGreaterThanOrEqualTo(o.Ptr(), object.Ptr()))
	runtime.KeepAlive(o)
	return ret
}

func (o *CBAttribute) IsLessThanOrEqualTo(object NSObject) bool {
	ret := (bool)(C.CBAttribute_inst_IsLessThanOrEqualTo(o.Ptr(), object.Ptr()))
	runtime.KeepAlive(o)
	return ret
}

func (o *CBAttribute) DoesContain(object NSObject) bool {
	ret := (bool)(C.CBAttribute_inst_DoesContain(o.Ptr(), object.Ptr()))
	runtime.KeepAlive(o)
	return ret
}

func (o *CBAttribute) WillChangeValueForKey(key *NSString)  {
	C.CBAttribute_inst_WillChangeValueForKey(o.Ptr(), key.Ptr())
	runtime.KeepAlive(o)
}

func (o *CBAttribute) WillChangeValueForKeyWithSetMutation(key *NSString, mutationKind NSKeyValueSetMutationKind, objects *NSSet)  {
	C.CBAttribute_inst_WillChangeValueForKeyWithSetMutation(o.Ptr(), key.Ptr(), (C.NSKeyValueSetMutationKind)(mutationKind), objects.Ptr())
	runtime.KeepAlive(o)
}

func (o *CBAttribute) WillChangeValueForKeyWithSetMutationUsingObjects(key *NSString, mutationKind NSKeyValueSetMutationKind, objects *NSSet)  {
	C.CBAttribute_inst_WillChangeValueForKeyWithSetMutationUsingObjects(o.Ptr(), key.Ptr(), (C.NSKeyValueSetMutationKind)(mutationKind), objects.Ptr())
	runtime.KeepAlive(o)
}

func (o *CBAttribute) UUID() *CBUUID {
	ret := &CBUUID{}
	ret.ptr = unsafe.Pointer(C.CBAttribute_inst_UUID(o.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*CBUUID)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *CBUUID) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *CBAttribute) ClassCode() FourCharCode {
	ret := (FourCharCode)(C.CBAttribute_inst_ClassCode(o.Ptr()))
	runtime.KeepAlive(o)
	return ret
}

func (o *CBAttribute) IsNotEqualTo(object NSObject) bool {
	ret := (bool)(C.CBAttribute_inst_IsNotEqualTo(o.Ptr(), object.Ptr()))
	runtime.KeepAlive(o)
	return ret
}

func (o *CBAttribute) ForwardingTargetForSelector(aSelector SEL) *Id {
	ret := &Id{}
	ret.ptr = unsafe.Pointer(C.CBAttribute_inst_ForwardingTargetForSelector(o.Ptr(), unsafe.Pointer(aSelector)))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *Id) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *CBAttribute) InverseForRelationshipKey(relationshipKey *NSString) *NSString {
	ret := &NSString{}
	ret.ptr = unsafe.Pointer(C.CBAttribute_inst_InverseForRelationshipKey(o.Ptr(), relationshipKey.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSString)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *NSString) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *CBAttribute) SetValueForKey(value NSObject, key *NSString)  {
	C.CBAttribute_inst_SetValueForKey(o.Ptr(), value.Ptr(), key.Ptr())
	runtime.KeepAlive(o)
}

func (o *CBAttribute) SetValueForKeyPath(value NSObject, keyPath *NSString)  {
	C.CBAttribute_inst_SetValueForKeyPath(o.Ptr(), value.Ptr(), keyPath.Ptr())
	runtime.KeepAlive(o)
}

func (o *CBAttribute) SetValueForUndefinedKey(value NSObject, key *NSString)  {
	C.CBAttribute_inst_SetValueForUndefinedKey(o.Ptr(), value.Ptr(), key.Ptr())
	runtime.KeepAlive(o)
}

func (o *CBAttribute) ValueForKey(key *NSString) *Id {
	ret := &Id{}
	ret.ptr = unsafe.Pointer(C.CBAttribute_inst_ValueForKey(o.Ptr(), key.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *Id) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *CBAttribute) PerformSelectorOnMainThreadWithObject(aSelector SEL, arg NSObject, wait BOOL)  {
	C.CBAttribute_inst_PerformSelectorOnMainThreadWithObject(o.Ptr(), unsafe.Pointer(aSelector), arg.Ptr(), (C.BOOL)(wait))
	runtime.KeepAlive(o)
}

func (o *CBAttribute) PerformSelectorOnMainThreadWithObjectWaitUntilDone(aSelector SEL, arg NSObject, wait BOOL)  {
	C.CBAttribute_inst_PerformSelectorOnMainThreadWithObjectWaitUntilDone(o.Ptr(), unsafe.Pointer(aSelector), arg.Ptr(), (C.BOOL)(wait))
	runtime.KeepAlive(o)
}

func (o *CBAttribute) PerformSelectorOnMainThreadWithObjectWaitUntilDoneModes(aSelector SEL, arg NSObject, wait BOOL, array *NSArray)  {
	C.CBAttribute_inst_PerformSelectorOnMainThreadWithObjectWaitUntilDoneModes(o.Ptr(), unsafe.Pointer(aSelector), arg.Ptr(), (C.BOOL)(wait), array.Ptr())
	runtime.KeepAlive(o)
}

func (o *CBAttribute) CopyScriptingValueForKey(value NSObject, key *NSString, properties *NSDictionary) *Id {
	ret := &Id{}
	ret.ptr = unsafe.Pointer(C.CBAttribute_inst_CopyScriptingValueForKey(o.Ptr(), value.Ptr(), key.Ptr(), properties.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *Id) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *CBAttribute) CopyScriptingValueForKeyWithProperties(value NSObject, key *NSString, properties *NSDictionary) *Id {
	ret := &Id{}
	ret.ptr = unsafe.Pointer(C.CBAttribute_inst_CopyScriptingValueForKeyWithProperties(o.Ptr(), value.Ptr(), key.Ptr(), properties.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *Id) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *CBAttribute) IsLessThan(object NSObject) bool {
	ret := (bool)(C.CBAttribute_inst_IsLessThan(o.Ptr(), object.Ptr()))
	runtime.KeepAlive(o)
	return ret
}

func (o *CBAttribute) MutableCopy() *Id {
	ret := &Id{}
	ret.ptr = unsafe.Pointer(C.CBAttribute_inst_MutableCopy(o.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	runtime.SetFinalizer(ret, func(o *Id) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *CBAttribute) ScriptingIsLessThan(object NSObject) bool {
	ret := (bool)(C.CBAttribute_inst_ScriptingIsLessThan(o.Ptr(), object.Ptr()))
	runtime.KeepAlive(o)
	return ret
}

func (o *CBAttribute) ValueWithUniqueIDInPropertyWithKey(uniqueID NSObject, key *NSString) *Id {
	ret := &Id{}
	ret.ptr = unsafe.Pointer(C.CBAttribute_inst_ValueWithUniqueIDInPropertyWithKey(o.Ptr(), uniqueID.Ptr(), key.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *Id) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *CBAttribute) ObserveValueForKeyPathOfObject(keyPath *NSString, object NSObject, change *NSDictionary, context unsafe.Pointer)  {
	C.CBAttribute_inst_ObserveValueForKeyPathOfObject(o.Ptr(), keyPath.Ptr(), object.Ptr(), change.Ptr(), unsafe.Pointer(context))
	runtime.KeepAlive(o)
}

func (o *CBAttribute) ObserveValueForKeyPathOfObjectChange(keyPath *NSString, object NSObject, change *NSDictionary, context unsafe.Pointer)  {
	C.CBAttribute_inst_ObserveValueForKeyPathOfObjectChange(o.Ptr(), keyPath.Ptr(), object.Ptr(), change.Ptr(), unsafe.Pointer(context))
	runtime.KeepAlive(o)
}

func (o *CBAttribute) ToOneRelationshipKeys() *NSArray {
	ret := &NSArray{}
	ret.ptr = unsafe.Pointer(C.CBAttribute_inst_ToOneRelationshipKeys(o.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSArray)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *NSArray) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *CBAttribute) PerformSelectorInBackgroundWithObject(aSelector SEL, arg NSObject)  {
	C.CBAttribute_inst_PerformSelectorInBackgroundWithObject(o.Ptr(), unsafe.Pointer(aSelector), arg.Ptr())
	runtime.KeepAlive(o)
}

func (o *CBAttribute) ClassForCoder() Class {
	ret := (Class)(unsafe.Pointer(C.CBAttribute_inst_ClassForCoder(o.Ptr())))
	runtime.KeepAlive(o)
	return ret
}

func (o *CBAttribute) ClassDescription() *NSClassDescription {
	ret := &NSClassDescription{}
	ret.ptr = unsafe.Pointer(C.CBAttribute_inst_ClassDescription(o.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSClassDescription)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *NSClassDescription) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *CBAttribute) ScriptingIsEqualTo(object NSObject) bool {
	ret := (bool)(C.CBAttribute_inst_ScriptingIsEqualTo(o.Ptr(), object.Ptr()))
	runtime.KeepAlive(o)
	return ret
}

func (o *CBAttribute) IndicesOfObjectsByEvaluatingObjectSpecifier(specifier *NSScriptObjectSpecifier) *NSArray {
	ret := &NSArray{}
	ret.ptr = unsafe.Pointer(C.CBAttribute_inst_IndicesOfObjectsByEvaluatingObjectSpecifier(o.Ptr(), specifier.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSArray)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *NSArray) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *CBAttribute) ValueAtIndexInPropertyWithKey(index NSUInteger, key *NSString) *Id {
	ret := &Id{}
	ret.ptr = unsafe.Pointer(C.CBAttribute_inst_ValueAtIndexInPropertyWithKey(o.Ptr(), (C.NSUInteger)(index), key.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *Id) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *CBAttribute) MutableArrayValueForKeyPath(keyPath *NSString) *NSMutableArray {
	ret := &NSMutableArray{}
	ret.ptr = unsafe.Pointer(C.CBAttribute_inst_MutableArrayValueForKeyPath(o.Ptr(), keyPath.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSMutableArray)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *NSMutableArray) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *CBAttribute) MutableOrderedSetValueForKeyPath(keyPath *NSString) *NSMutableOrderedSet {
	ret := &NSMutableOrderedSet{}
	ret.ptr = unsafe.Pointer(C.CBAttribute_inst_MutableOrderedSetValueForKeyPath(o.Ptr(), keyPath.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSMutableOrderedSet)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *NSMutableOrderedSet) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *CBAttribute) IsEqualTo(object NSObject) bool {
	ret := (bool)(C.CBAttribute_inst_IsEqualTo(o.Ptr(), object.Ptr()))
	runtime.KeepAlive(o)
	return ret
}

func (o *CBAttribute) SetNilValueForKey(key *NSString)  {
	C.CBAttribute_inst_SetNilValueForKey(o.Ptr(), key.Ptr())
	runtime.KeepAlive(o)
}

func (o *CBAttribute) MethodSignatureForSelector(aSelector SEL) *NSMethodSignature {
	ret := &NSMethodSignature{}
	ret.ptr = unsafe.Pointer(C.CBAttribute_inst_MethodSignatureForSelector(o.Ptr(), unsafe.Pointer(aSelector)))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSMethodSignature)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *NSMethodSignature) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *CBAttribute) WillChangeValuesAtIndexes(changeKind NSKeyValueChange, indexes *NSIndexSet, key *NSString)  {
	C.CBAttribute_inst_WillChangeValuesAtIndexes(o.Ptr(), (C.NSKeyValueChange)(changeKind), indexes.Ptr(), key.Ptr())
	runtime.KeepAlive(o)
}

func (o *CBAttribute) WillChangeValuesAtIndexesForKey(changeKind NSKeyValueChange, indexes *NSIndexSet, key *NSString)  {
	C.CBAttribute_inst_WillChangeValuesAtIndexesForKey(o.Ptr(), (C.NSKeyValueChange)(changeKind), indexes.Ptr(), key.Ptr())
	runtime.KeepAlive(o)
}

func (o *CBAttribute) MutableOrderedSetValueForKey(key *NSString) *NSMutableOrderedSet {
	ret := &NSMutableOrderedSet{}
	ret.ptr = unsafe.Pointer(C.CBAttribute_inst_MutableOrderedSetValueForKey(o.Ptr(), key.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSMutableOrderedSet)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *NSMutableOrderedSet) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *CBAttribute) ReplacementObjectForKeyedArchiver(archiver *NSKeyedArchiver) *Id {
	ret := &Id{}
	ret.ptr = unsafe.Pointer(C.CBAttribute_inst_ReplacementObjectForKeyedArchiver(o.Ptr(), archiver.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *Id) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *CBAttribute) AwakeAfterUsingCoder(coder *NSCoder) *Id {
	ret := &Id{}
	ret.ptr = unsafe.Pointer(C.CBAttribute_inst_AwakeAfterUsingCoder(o.Ptr(), coder.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *Id) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *CBAttribute) SetValuesForKeysWithDictionary(keyedValues *NSDictionary)  {
	C.CBAttribute_inst_SetValuesForKeysWithDictionary(o.Ptr(), keyedValues.Ptr())
	runtime.KeepAlive(o)
}

func (o *CBAttribute) ScriptingBeginsWith(object NSObject) bool {
	ret := (bool)(C.CBAttribute_inst_ScriptingBeginsWith(o.Ptr(), object.Ptr()))
	runtime.KeepAlive(o)
	return ret
}

func (o *CBAttribute) AutoContentAccessingProxy() *Id {
	ret := &Id{}
	ret.ptr = unsafe.Pointer(C.CBAttribute_inst_AutoContentAccessingProxy(o.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *Id) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *CBAttribute) InsertValueInPropertyWithKey(value NSObject, key *NSString)  {
	C.CBAttribute_inst_InsertValueInPropertyWithKey(o.Ptr(), value.Ptr(), key.Ptr())
	runtime.KeepAlive(o)
}

func (o *CBAttribute) InsertValueAtIndex(value NSObject, index NSUInteger, key *NSString)  {
	C.CBAttribute_inst_InsertValueAtIndex(o.Ptr(), value.Ptr(), (C.NSUInteger)(index), key.Ptr())
	runtime.KeepAlive(o)
}

func (o *CBAttribute) InsertValueAtIndexInPropertyWithKey(value NSObject, index NSUInteger, key *NSString)  {
	C.CBAttribute_inst_InsertValueAtIndexInPropertyWithKey(o.Ptr(), value.Ptr(), (C.NSUInteger)(index), key.Ptr())
	runtime.KeepAlive(o)
}

func (o *CBAttribute) MutableSetValueForKeyPath(keyPath *NSString) *NSMutableSet {
	ret := &NSMutableSet{}
	ret.ptr = unsafe.Pointer(C.CBAttribute_inst_MutableSetValueForKeyPath(o.Ptr(), keyPath.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSMutableSet)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *NSMutableSet) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *CBAttribute) ForwardInvocation(anInvocation *NSInvocation)  {
	C.CBAttribute_inst_ForwardInvocation(o.Ptr(), anInvocation.Ptr())
	runtime.KeepAlive(o)
}

func (o *CBAttribute) AttributeKeys() *NSArray {
	ret := &NSArray{}
	ret.ptr = unsafe.Pointer(C.CBAttribute_inst_AttributeKeys(o.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSArray)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *NSArray) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *CBAttribute) Copy() *Id {
	ret := &Id{}
	ret.ptr = unsafe.Pointer(C.CBAttribute_inst_Copy(o.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	runtime.SetFinalizer(ret, func(o *Id) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *CBAttribute) MutableArrayValueForKey(key *NSString) *NSMutableArray {
	ret := &NSMutableArray{}
	ret.ptr = unsafe.Pointer(C.CBAttribute_inst_MutableArrayValueForKey(o.Ptr(), key.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSMutableArray)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *NSMutableArray) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *CBAttribute) RemoveObserverForKeyPath(observer NSObject, keyPath *NSString)  {
	C.CBAttribute_inst_RemoveObserverForKeyPath(o.Ptr(), observer.Ptr(), keyPath.Ptr())
	runtime.KeepAlive(o)
}

func (o *CBAttribute) RemoveObserverForKeyPathContext(observer NSObject, keyPath *NSString, context unsafe.Pointer)  {
	C.CBAttribute_inst_RemoveObserverForKeyPathContext(o.Ptr(), observer.Ptr(), keyPath.Ptr(), unsafe.Pointer(context))
	runtime.KeepAlive(o)
}

func (o *CBAttribute) DidChangeValuesAtIndexes(changeKind NSKeyValueChange, indexes *NSIndexSet, key *NSString)  {
	C.CBAttribute_inst_DidChangeValuesAtIndexes(o.Ptr(), (C.NSKeyValueChange)(changeKind), indexes.Ptr(), key.Ptr())
	runtime.KeepAlive(o)
}

func (o *CBAttribute) DidChangeValuesAtIndexesForKey(changeKind NSKeyValueChange, indexes *NSIndexSet, key *NSString)  {
	C.CBAttribute_inst_DidChangeValuesAtIndexesForKey(o.Ptr(), (C.NSKeyValueChange)(changeKind), indexes.Ptr(), key.Ptr())
	runtime.KeepAlive(o)
}

func (o *CBAttribute) ValueForUndefinedKey(key *NSString) *Id {
	ret := &Id{}
	ret.ptr = unsafe.Pointer(C.CBAttribute_inst_ValueForUndefinedKey(o.Ptr(), key.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *Id) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *CBAttribute) IsLike(object *NSString) bool {
	ret := (bool)(C.CBAttribute_inst_IsLike(o.Ptr(), object.Ptr()))
	runtime.KeepAlive(o)
	return ret
}

func (o *CBAttribute) ObservationInfo() unsafe.Pointer {
	ret := (unsafe.Pointer)(unsafe.Pointer(C.CBAttribute_inst_ObservationInfo(o.Ptr())))
	runtime.KeepAlive(o)
	return ret
}

func (o *CBAttribute) IsGreaterThanOrEqualTo(object NSObject) bool {
	ret := (bool)(C.CBAttribute_inst_IsGreaterThanOrEqualTo(o.Ptr(), object.Ptr()))
	runtime.KeepAlive(o)
	return ret
}

func (o *CBAttribute) ClassForArchiver() Class {
	ret := (Class)(unsafe.Pointer(C.CBAttribute_inst_ClassForArchiver(o.Ptr())))
	runtime.KeepAlive(o)
	return ret
}

func (o *CBAttribute) ClassForKeyedArchiver() Class {
	ret := (Class)(unsafe.Pointer(C.CBAttribute_inst_ClassForKeyedArchiver(o.Ptr())))
	runtime.KeepAlive(o)
	return ret
}

func (o *CBAttribute) ScriptingIsLessThanOrEqualTo(object NSObject) bool {
	ret := (bool)(C.CBAttribute_inst_ScriptingIsLessThanOrEqualTo(o.Ptr(), object.Ptr()))
	runtime.KeepAlive(o)
	return ret
}

func (o *CBAttribute) DoesNotRecognizeSelector(aSelector SEL)  {
	C.CBAttribute_inst_DoesNotRecognizeSelector(o.Ptr(), unsafe.Pointer(aSelector))
	runtime.KeepAlive(o)
}

func (o *CBAttribute) ToManyRelationshipKeys() *NSArray {
	ret := &NSArray{}
	ret.ptr = unsafe.Pointer(C.CBAttribute_inst_ToManyRelationshipKeys(o.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSArray)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *NSArray) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *CBAttribute) ScriptingProperties() *NSDictionary {
	ret := &NSDictionary{}
	ret.ptr = unsafe.Pointer(C.CBAttribute_inst_ScriptingProperties(o.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSDictionary)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *NSDictionary) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *CBAttribute) ScriptingIsGreaterThan(object NSObject) bool {
	ret := (bool)(C.CBAttribute_inst_ScriptingIsGreaterThan(o.Ptr(), object.Ptr()))
	runtime.KeepAlive(o)
	return ret
}

func CBDescriptorAutomaticallyNotifiesObserversForKey(key *NSString) bool {
	ret := (bool)(C.CBDescriptor_AutomaticallyNotifiesObserversForKey(key.Ptr()))
	return ret
}

func CBDescriptorAllocWithZone(zone *_NSZone) *CBDescriptor {
	ret := &CBDescriptor{}
	ret.ptr = unsafe.Pointer(C.CBDescriptor_AllocWithZone(unsafe.Pointer(zone)))
	if ret.ptr == nil { return ret }
	runtime.SetFinalizer(ret, func(o *CBDescriptor) {
		o.Release()
	})
	return ret
}

func CBDescriptorKeyPathsForValuesAffectingValueForKey(key *NSString) *NSSet {
	ret := &NSSet{}
	ret.ptr = unsafe.Pointer(C.CBDescriptor_KeyPathsForValuesAffectingValueForKey(key.Ptr()))
	if ret.ptr == nil { return ret }
	return ret
}

func CBDescriptorConformsToProtocol(protocol Protocol) bool {
	ret := (bool)(C.CBDescriptor_ConformsToProtocol(protocol.Ptr()))
	return ret
}

func CBDescriptorLoad()  {
	C.CBDescriptor_Load()
}

func CBDescriptorVersion() NSInteger {
	ret := (NSInteger)(C.CBDescriptor_Version())
	return ret
}

func CBDescriptorResolveClassMethod(sel SEL) bool {
	ret := (bool)(C.CBDescriptor_ResolveClassMethod(unsafe.Pointer(sel)))
	return ret
}

func CBDescriptorDebugDescription() *NSString {
	ret := &NSString{}
	ret.ptr = unsafe.Pointer(C.CBDescriptor_DebugDescription())
	if ret.ptr == nil { return ret }
	return ret
}

func CBDescriptorHash() NSUInteger {
	ret := (NSUInteger)(C.CBDescriptor_Hash())
	return ret
}

func CBDescriptorCopyWithZone(zone *_NSZone) *Id {
	ret := &Id{}
	ret.ptr = unsafe.Pointer(C.CBDescriptor_CopyWithZone(unsafe.Pointer(zone)))
	if ret.ptr == nil { return ret }
	runtime.SetFinalizer(ret, func(o *Id) {
		o.Release()
	})
	return ret
}

func CBDescriptorDescription() *NSString {
	ret := &NSString{}
	ret.ptr = unsafe.Pointer(C.CBDescriptor_Description())
	if ret.ptr == nil { return ret }
	return ret
}

func CBDescriptorInstancesRespondToSelector(aSelector SEL) bool {
	ret := (bool)(C.CBDescriptor_InstancesRespondToSelector(unsafe.Pointer(aSelector)))
	return ret
}

func CBDescriptorMutableCopyWithZone(zone *_NSZone) *Id {
	ret := &Id{}
	ret.ptr = unsafe.Pointer(C.CBDescriptor_MutableCopyWithZone(unsafe.Pointer(zone)))
	if ret.ptr == nil { return ret }
	runtime.SetFinalizer(ret, func(o *Id) {
		o.Release()
	})
	return ret
}

func CBDescriptorClassFallbacksForKeyedArchiver() *NSArray {
	ret := &NSArray{}
	ret.ptr = unsafe.Pointer(C.CBDescriptor_ClassFallbacksForKeyedArchiver())
	if ret.ptr == nil { return ret }
	return ret
}

func CBDescriptorInstanceMethodSignatureForSelector(aSelector SEL) *NSMethodSignature {
	ret := &NSMethodSignature{}
	ret.ptr = unsafe.Pointer(C.CBDescriptor_InstanceMethodSignatureForSelector(unsafe.Pointer(aSelector)))
	if ret.ptr == nil { return ret }
	return ret
}

func CBDescriptorSetVersion(aVersion NSInteger)  {
	C.CBDescriptor_SetVersion((C.NSInteger)(aVersion))
}

func CBDescriptorNew() *CBDescriptor {
	ret := &CBDescriptor{}
	ret.ptr = unsafe.Pointer(C.CBDescriptor_New())
	if ret.ptr == nil { return ret }
	runtime.SetFinalizer(ret, func(o *CBDescriptor) {
		o.Release()
	})
	return ret
}

func CBDescriptorResolveInstanceMethod(sel SEL) bool {
	ret := (bool)(C.CBDescriptor_ResolveInstanceMethod(unsafe.Pointer(sel)))
	return ret
}

func CBDescriptorIsSubclassOfClass(aClass Class) bool {
	ret := (bool)(C.CBDescriptor_IsSubclassOfClass(unsafe.Pointer(aClass)))
	return ret
}

func CBDescriptorCancelPreviousPerformRequestsWithTarget(aTarget NSObject)  {
	C.CBDescriptor_CancelPreviousPerformRequestsWithTarget(aTarget.Ptr())
}

func CBDescriptorCancelPreviousPerformRequestsWithTargetSelector(aTarget NSObject, aSelector SEL, anArgument NSObject)  {
	C.CBDescriptor_CancelPreviousPerformRequestsWithTargetSelector(aTarget.Ptr(), unsafe.Pointer(aSelector), anArgument.Ptr())
}

func CBDescriptorCancelPreviousPerformRequestsWithTargetSelectorObject(aTarget NSObject, aSelector SEL, anArgument NSObject)  {
	C.CBDescriptor_CancelPreviousPerformRequestsWithTargetSelectorObject(aTarget.Ptr(), unsafe.Pointer(aSelector), anArgument.Ptr())
}

func CBDescriptorAccessInstanceVariablesDirectly() bool {
	ret := (bool)(C.CBDescriptor_AccessInstanceVariablesDirectly())
	return ret
}

func CBDescriptorAlloc() *CBDescriptor {
	ret := &CBDescriptor{}
	ret.ptr = unsafe.Pointer(C.CBDescriptor_Alloc())
	if ret.ptr == nil { return ret }
	runtime.SetFinalizer(ret, func(o *CBDescriptor) {
		o.Release()
	})
	return ret
}

func (o *CBDescriptor) GC() {
	if o.ptr == nil { return }
	runtime.SetFinalizer(o, func(o *CBDescriptor) {
		o.Release()
	})
	runtime.KeepAlive(o)
}

func CBDescriptorClass() Class {
	ret := (Class)(unsafe.Pointer(C.CBDescriptor_Class()))
	return ret
}

func CBDescriptorSuperclass() Class {
	ret := (Class)(unsafe.Pointer(C.CBDescriptor_Superclass()))
	return ret
}

func CBDescriptorClassForKeyedUnarchiver() Class {
	ret := (Class)(unsafe.Pointer(C.CBDescriptor_ClassForKeyedUnarchiver()))
	return ret
}

func (o *CBDescriptor) ForwardingTargetForSelector(aSelector SEL) *Id {
	ret := &Id{}
	ret.ptr = unsafe.Pointer(C.CBDescriptor_inst_ForwardingTargetForSelector(o.Ptr(), unsafe.Pointer(aSelector)))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *Id) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *CBDescriptor) Copy() *Id {
	ret := &Id{}
	ret.ptr = unsafe.Pointer(C.CBDescriptor_inst_Copy(o.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	runtime.SetFinalizer(ret, func(o *Id) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *CBDescriptor) ClassForArchiver() Class {
	ret := (Class)(unsafe.Pointer(C.CBDescriptor_inst_ClassForArchiver(o.Ptr())))
	runtime.KeepAlive(o)
	return ret
}

func (o *CBDescriptor) ScriptingIsLessThanOrEqualTo(object NSObject) bool {
	ret := (bool)(C.CBDescriptor_inst_ScriptingIsLessThanOrEqualTo(o.Ptr(), object.Ptr()))
	runtime.KeepAlive(o)
	return ret
}

func (o *CBDescriptor) Characteristic() *CBCharacteristic {
	ret := &CBCharacteristic{}
	ret.ptr = unsafe.Pointer(C.CBDescriptor_inst_Characteristic(o.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*CBCharacteristic)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *CBCharacteristic) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *CBDescriptor) Value() *Id {
	ret := &Id{}
	ret.ptr = unsafe.Pointer(C.CBDescriptor_inst_Value(o.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *Id) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *CBDescriptor) ScriptingEndsWith(object NSObject) bool {
	ret := (bool)(C.CBDescriptor_inst_ScriptingEndsWith(o.Ptr(), object.Ptr()))
	runtime.KeepAlive(o)
	return ret
}

func (o *CBDescriptor) PerformSelectorWithObject(aSelector SEL, anArgument NSObject, delay NSTimeInterval)  {
	C.CBDescriptor_inst_PerformSelectorWithObject(o.Ptr(), unsafe.Pointer(aSelector), anArgument.Ptr(), (C.NSTimeInterval)(delay))
	runtime.KeepAlive(o)
}

func (o *CBDescriptor) PerformSelectorWithObjectAfterDelay(aSelector SEL, anArgument NSObject, delay NSTimeInterval)  {
	C.CBDescriptor_inst_PerformSelectorWithObjectAfterDelay(o.Ptr(), unsafe.Pointer(aSelector), anArgument.Ptr(), (C.NSTimeInterval)(delay))
	runtime.KeepAlive(o)
}

func (o *CBDescriptor) PerformSelectorWithObjectAfterDelayInModes(aSelector SEL, anArgument NSObject, delay NSTimeInterval, modes *NSArray)  {
	C.CBDescriptor_inst_PerformSelectorWithObjectAfterDelayInModes(o.Ptr(), unsafe.Pointer(aSelector), anArgument.Ptr(), (C.NSTimeInterval)(delay), modes.Ptr())
	runtime.KeepAlive(o)
}

func (o *CBDescriptor) PerformSelectorOnThread(aSelector SEL, thr *NSThread, arg NSObject, wait BOOL)  {
	C.CBDescriptor_inst_PerformSelectorOnThread(o.Ptr(), unsafe.Pointer(aSelector), thr.Ptr(), arg.Ptr(), (C.BOOL)(wait))
	runtime.KeepAlive(o)
}

func (o *CBDescriptor) PerformSelectorOnThreadWithObject(aSelector SEL, thr *NSThread, arg NSObject, wait BOOL)  {
	C.CBDescriptor_inst_PerformSelectorOnThreadWithObject(o.Ptr(), unsafe.Pointer(aSelector), thr.Ptr(), arg.Ptr(), (C.BOOL)(wait))
	runtime.KeepAlive(o)
}

func (o *CBDescriptor) PerformSelectorOnThreadWithObjectWaitUntilDone(aSelector SEL, thr *NSThread, arg NSObject, wait BOOL)  {
	C.CBDescriptor_inst_PerformSelectorOnThreadWithObjectWaitUntilDone(o.Ptr(), unsafe.Pointer(aSelector), thr.Ptr(), arg.Ptr(), (C.BOOL)(wait))
	runtime.KeepAlive(o)
}

func (o *CBDescriptor) PerformSelectorOnThreadWithObjectWaitUntilDoneModes(aSelector SEL, thr *NSThread, arg NSObject, wait BOOL, array *NSArray)  {
	C.CBDescriptor_inst_PerformSelectorOnThreadWithObjectWaitUntilDoneModes(o.Ptr(), unsafe.Pointer(aSelector), thr.Ptr(), arg.Ptr(), (C.BOOL)(wait), array.Ptr())
	runtime.KeepAlive(o)
}

func (o *CBDescriptor) AttemptRecoveryFromErrorOptionIndex(error *NSError, recoveryOptionIndex NSUInteger) bool {
	ret := (bool)(C.CBDescriptor_inst_AttemptRecoveryFromErrorOptionIndex(o.Ptr(), error.Ptr(), (C.NSUInteger)(recoveryOptionIndex)))
	runtime.KeepAlive(o)
	return ret
}

func (o *CBDescriptor) AttemptRecoveryFromErrorOptionIndexDelegate(error *NSError, recoveryOptionIndex NSUInteger, delegate NSObject, didRecoverSelector SEL, contextInfo unsafe.Pointer)  {
	C.CBDescriptor_inst_AttemptRecoveryFromErrorOptionIndexDelegate(o.Ptr(), error.Ptr(), (C.NSUInteger)(recoveryOptionIndex), delegate.Ptr(), unsafe.Pointer(didRecoverSelector), unsafe.Pointer(contextInfo))
	runtime.KeepAlive(o)
}

func (o *CBDescriptor) AttemptRecoveryFromErrorOptionIndexDelegateDidRecoverSelector(error *NSError, recoveryOptionIndex NSUInteger, delegate NSObject, didRecoverSelector SEL, contextInfo unsafe.Pointer)  {
	C.CBDescriptor_inst_AttemptRecoveryFromErrorOptionIndexDelegateDidRecoverSelector(o.Ptr(), error.Ptr(), (C.NSUInteger)(recoveryOptionIndex), delegate.Ptr(), unsafe.Pointer(didRecoverSelector), unsafe.Pointer(contextInfo))
	runtime.KeepAlive(o)
}

func (o *CBDescriptor) AttemptRecoveryFromErrorOptionIndexDelegateDidRecoverSelectorContextInfo(error *NSError, recoveryOptionIndex NSUInteger, delegate NSObject, didRecoverSelector SEL, contextInfo unsafe.Pointer)  {
	C.CBDescriptor_inst_AttemptRecoveryFromErrorOptionIndexDelegateDidRecoverSelectorContextInfo(o.Ptr(), error.Ptr(), (C.NSUInteger)(recoveryOptionIndex), delegate.Ptr(), unsafe.Pointer(didRecoverSelector), unsafe.Pointer(contextInfo))
	runtime.KeepAlive(o)
}

func (o *CBDescriptor) ClassCode() FourCharCode {
	ret := (FourCharCode)(C.CBDescriptor_inst_ClassCode(o.Ptr()))
	runtime.KeepAlive(o)
	return ret
}

func (o *CBDescriptor) ValueWithUniqueIDInPropertyWithKey(uniqueID NSObject, key *NSString) *Id {
	ret := &Id{}
	ret.ptr = unsafe.Pointer(C.CBDescriptor_inst_ValueWithUniqueIDInPropertyWithKey(o.Ptr(), uniqueID.Ptr(), key.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *Id) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *CBDescriptor) ValueForUndefinedKey(key *NSString) *Id {
	ret := &Id{}
	ret.ptr = unsafe.Pointer(C.CBDescriptor_inst_ValueForUndefinedKey(o.Ptr(), key.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *Id) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *CBDescriptor) RemoveValueAtIndexFromPropertyWithKey(index NSUInteger, key *NSString)  {
	C.CBDescriptor_inst_RemoveValueAtIndexFromPropertyWithKey(o.Ptr(), (C.NSUInteger)(index), key.Ptr())
	runtime.KeepAlive(o)
}

func (o *CBDescriptor) IsEqualTo(object NSObject) bool {
	ret := (bool)(C.CBDescriptor_inst_IsEqualTo(o.Ptr(), object.Ptr()))
	runtime.KeepAlive(o)
	return ret
}

func (o *CBDescriptor) AwakeAfterUsingCoder(coder *NSCoder) *Id {
	ret := &Id{}
	ret.ptr = unsafe.Pointer(C.CBDescriptor_inst_AwakeAfterUsingCoder(o.Ptr(), coder.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *Id) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *CBDescriptor) ScriptingBeginsWith(object NSObject) bool {
	ret := (bool)(C.CBDescriptor_inst_ScriptingBeginsWith(o.Ptr(), object.Ptr()))
	runtime.KeepAlive(o)
	return ret
}

func (o *CBDescriptor) SetNilValueForKey(key *NSString)  {
	C.CBDescriptor_inst_SetNilValueForKey(o.Ptr(), key.Ptr())
	runtime.KeepAlive(o)
}

func (o *CBDescriptor) IsLike(object *NSString) bool {
	ret := (bool)(C.CBDescriptor_inst_IsLike(o.Ptr(), object.Ptr()))
	runtime.KeepAlive(o)
	return ret
}

func (o *CBDescriptor) ReplacementObjectForCoder(coder *NSCoder) *Id {
	ret := &Id{}
	ret.ptr = unsafe.Pointer(C.CBDescriptor_inst_ReplacementObjectForCoder(o.Ptr(), coder.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *Id) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *CBDescriptor) IsLessThanOrEqualTo(object NSObject) bool {
	ret := (bool)(C.CBDescriptor_inst_IsLessThanOrEqualTo(o.Ptr(), object.Ptr()))
	runtime.KeepAlive(o)
	return ret
}

func (o *CBDescriptor) DoesContain(object NSObject) bool {
	ret := (bool)(C.CBDescriptor_inst_DoesContain(o.Ptr(), object.Ptr()))
	runtime.KeepAlive(o)
	return ret
}

func (o *CBDescriptor) ValueForKey(key *NSString) *Id {
	ret := &Id{}
	ret.ptr = unsafe.Pointer(C.CBDescriptor_inst_ValueForKey(o.Ptr(), key.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *Id) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *CBDescriptor) IndicesOfObjectsByEvaluatingObjectSpecifier(specifier *NSScriptObjectSpecifier) *NSArray {
	ret := &NSArray{}
	ret.ptr = unsafe.Pointer(C.CBDescriptor_inst_IndicesOfObjectsByEvaluatingObjectSpecifier(o.Ptr(), specifier.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSArray)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *NSArray) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *CBDescriptor) ValueAtIndexInPropertyWithKey(index NSUInteger, key *NSString) *Id {
	ret := &Id{}
	ret.ptr = unsafe.Pointer(C.CBDescriptor_inst_ValueAtIndexInPropertyWithKey(o.Ptr(), (C.NSUInteger)(index), key.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *Id) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *CBDescriptor) ClassForKeyedArchiver() Class {
	ret := (Class)(unsafe.Pointer(C.CBDescriptor_inst_ClassForKeyedArchiver(o.Ptr())))
	runtime.KeepAlive(o)
	return ret
}

func (o *CBDescriptor) ScriptingValueForSpecifier(objectSpecifier *NSScriptObjectSpecifier) *Id {
	ret := &Id{}
	ret.ptr = unsafe.Pointer(C.CBDescriptor_inst_ScriptingValueForSpecifier(o.Ptr(), objectSpecifier.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *Id) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *CBDescriptor) ObjectSpecifier() *NSScriptObjectSpecifier {
	ret := &NSScriptObjectSpecifier{}
	ret.ptr = unsafe.Pointer(C.CBDescriptor_inst_ObjectSpecifier(o.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSScriptObjectSpecifier)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *NSScriptObjectSpecifier) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *CBDescriptor) UUID() *CBUUID {
	ret := &CBUUID{}
	ret.ptr = unsafe.Pointer(C.CBDescriptor_inst_UUID(o.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*CBUUID)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *CBUUID) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *CBDescriptor) ScriptingIsLessThan(object NSObject) bool {
	ret := (bool)(C.CBDescriptor_inst_ScriptingIsLessThan(o.Ptr(), object.Ptr()))
	runtime.KeepAlive(o)
	return ret
}

func (o *CBDescriptor) PerformSelectorInBackgroundWithObject(aSelector SEL, arg NSObject)  {
	C.CBDescriptor_inst_PerformSelectorInBackgroundWithObject(o.Ptr(), unsafe.Pointer(aSelector), arg.Ptr())
	runtime.KeepAlive(o)
}

func (o *CBDescriptor) IsNotEqualTo(object NSObject) bool {
	ret := (bool)(C.CBDescriptor_inst_IsNotEqualTo(o.Ptr(), object.Ptr()))
	runtime.KeepAlive(o)
	return ret
}

func (o *CBDescriptor) IsLessThan(object NSObject) bool {
	ret := (bool)(C.CBDescriptor_inst_IsLessThan(o.Ptr(), object.Ptr()))
	runtime.KeepAlive(o)
	return ret
}

func (o *CBDescriptor) ToOneRelationshipKeys() *NSArray {
	ret := &NSArray{}
	ret.ptr = unsafe.Pointer(C.CBDescriptor_inst_ToOneRelationshipKeys(o.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSArray)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *NSArray) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *CBDescriptor) ScriptingIsEqualTo(object NSObject) bool {
	ret := (bool)(C.CBDescriptor_inst_ScriptingIsEqualTo(o.Ptr(), object.Ptr()))
	runtime.KeepAlive(o)
	return ret
}

func (o *CBDescriptor) WillChangeValuesAtIndexes(changeKind NSKeyValueChange, indexes *NSIndexSet, key *NSString)  {
	C.CBDescriptor_inst_WillChangeValuesAtIndexes(o.Ptr(), (C.NSKeyValueChange)(changeKind), indexes.Ptr(), key.Ptr())
	runtime.KeepAlive(o)
}

func (o *CBDescriptor) WillChangeValuesAtIndexesForKey(changeKind NSKeyValueChange, indexes *NSIndexSet, key *NSString)  {
	C.CBDescriptor_inst_WillChangeValuesAtIndexesForKey(o.Ptr(), (C.NSKeyValueChange)(changeKind), indexes.Ptr(), key.Ptr())
	runtime.KeepAlive(o)
}

func (o *CBDescriptor) MutableOrderedSetValueForKey(key *NSString) *NSMutableOrderedSet {
	ret := &NSMutableOrderedSet{}
	ret.ptr = unsafe.Pointer(C.CBDescriptor_inst_MutableOrderedSetValueForKey(o.Ptr(), key.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSMutableOrderedSet)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *NSMutableOrderedSet) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *CBDescriptor) ClassName() *NSString {
	ret := &NSString{}
	ret.ptr = unsafe.Pointer(C.CBDescriptor_inst_ClassName(o.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSString)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *NSString) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *CBDescriptor) ValueForKeyPath(keyPath *NSString) *Id {
	ret := &Id{}
	ret.ptr = unsafe.Pointer(C.CBDescriptor_inst_ValueForKeyPath(o.Ptr(), keyPath.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *Id) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *CBDescriptor) CoerceValueForKey(value NSObject, key *NSString) *Id {
	ret := &Id{}
	ret.ptr = unsafe.Pointer(C.CBDescriptor_inst_CoerceValueForKey(o.Ptr(), value.Ptr(), key.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *Id) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *CBDescriptor) SetObservationInfo(observationInfo unsafe.Pointer)  {
	C.CBDescriptor_inst_SetObservationInfo(o.Ptr(), unsafe.Pointer(observationInfo))
	runtime.KeepAlive(o)
}

func (o *CBDescriptor) ValueWithNameInPropertyWithKey(name *NSString, key *NSString) *Id {
	ret := &Id{}
	ret.ptr = unsafe.Pointer(C.CBDescriptor_inst_ValueWithNameInPropertyWithKey(o.Ptr(), name.Ptr(), key.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *Id) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *CBDescriptor) ClassDescription() *NSClassDescription {
	ret := &NSClassDescription{}
	ret.ptr = unsafe.Pointer(C.CBDescriptor_inst_ClassDescription(o.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSClassDescription)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *NSClassDescription) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *CBDescriptor) InsertValueInPropertyWithKey(value NSObject, key *NSString)  {
	C.CBDescriptor_inst_InsertValueInPropertyWithKey(o.Ptr(), value.Ptr(), key.Ptr())
	runtime.KeepAlive(o)
}

func (o *CBDescriptor) InsertValueAtIndex(value NSObject, index NSUInteger, key *NSString)  {
	C.CBDescriptor_inst_InsertValueAtIndex(o.Ptr(), value.Ptr(), (C.NSUInteger)(index), key.Ptr())
	runtime.KeepAlive(o)
}

func (o *CBDescriptor) InsertValueAtIndexInPropertyWithKey(value NSObject, index NSUInteger, key *NSString)  {
	C.CBDescriptor_inst_InsertValueAtIndexInPropertyWithKey(o.Ptr(), value.Ptr(), (C.NSUInteger)(index), key.Ptr())
	runtime.KeepAlive(o)
}

func (o *CBDescriptor) ForwardInvocation(anInvocation *NSInvocation)  {
	C.CBDescriptor_inst_ForwardInvocation(o.Ptr(), anInvocation.Ptr())
	runtime.KeepAlive(o)
}

func (o *CBDescriptor) AttributeKeys() *NSArray {
	ret := &NSArray{}
	ret.ptr = unsafe.Pointer(C.CBDescriptor_inst_AttributeKeys(o.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSArray)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *NSArray) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *CBDescriptor) IsCaseInsensitiveLike(object *NSString) bool {
	ret := (bool)(C.CBDescriptor_inst_IsCaseInsensitiveLike(o.Ptr(), object.Ptr()))
	runtime.KeepAlive(o)
	return ret
}

func (o *CBDescriptor) SetValueForKey(value NSObject, key *NSString)  {
	C.CBDescriptor_inst_SetValueForKey(o.Ptr(), value.Ptr(), key.Ptr())
	runtime.KeepAlive(o)
}

func (o *CBDescriptor) SetValueForKeyPath(value NSObject, keyPath *NSString)  {
	C.CBDescriptor_inst_SetValueForKeyPath(o.Ptr(), value.Ptr(), keyPath.Ptr())
	runtime.KeepAlive(o)
}

func (o *CBDescriptor) SetValueForUndefinedKey(value NSObject, key *NSString)  {
	C.CBDescriptor_inst_SetValueForUndefinedKey(o.Ptr(), value.Ptr(), key.Ptr())
	runtime.KeepAlive(o)
}

func (o *CBDescriptor) ClassForCoder() Class {
	ret := (Class)(unsafe.Pointer(C.CBDescriptor_inst_ClassForCoder(o.Ptr())))
	runtime.KeepAlive(o)
	return ret
}

func (o *CBDescriptor) DidChangeValuesAtIndexes(changeKind NSKeyValueChange, indexes *NSIndexSet, key *NSString)  {
	C.CBDescriptor_inst_DidChangeValuesAtIndexes(o.Ptr(), (C.NSKeyValueChange)(changeKind), indexes.Ptr(), key.Ptr())
	runtime.KeepAlive(o)
}

func (o *CBDescriptor) DidChangeValuesAtIndexesForKey(changeKind NSKeyValueChange, indexes *NSIndexSet, key *NSString)  {
	C.CBDescriptor_inst_DidChangeValuesAtIndexesForKey(o.Ptr(), (C.NSKeyValueChange)(changeKind), indexes.Ptr(), key.Ptr())
	runtime.KeepAlive(o)
}

func (o *CBDescriptor) AddObserverForKeyPath(observer NSObject, keyPath *NSString, options NSKeyValueObservingOptions, context unsafe.Pointer)  {
	C.CBDescriptor_inst_AddObserverForKeyPath(o.Ptr(), observer.Ptr(), keyPath.Ptr(), (C.NSKeyValueObservingOptions)(options), unsafe.Pointer(context))
	runtime.KeepAlive(o)
}

func (o *CBDescriptor) AddObserverForKeyPathOptions(observer NSObject, keyPath *NSString, options NSKeyValueObservingOptions, context unsafe.Pointer)  {
	C.CBDescriptor_inst_AddObserverForKeyPathOptions(o.Ptr(), observer.Ptr(), keyPath.Ptr(), (C.NSKeyValueObservingOptions)(options), unsafe.Pointer(context))
	runtime.KeepAlive(o)
}

func (o *CBDescriptor) AddObserverForKeyPathOptionsContext(observer NSObject, keyPath *NSString, options NSKeyValueObservingOptions, context unsafe.Pointer)  {
	C.CBDescriptor_inst_AddObserverForKeyPathOptionsContext(o.Ptr(), observer.Ptr(), keyPath.Ptr(), (C.NSKeyValueObservingOptions)(options), unsafe.Pointer(context))
	runtime.KeepAlive(o)
}

func (o *CBDescriptor) IsGreaterThanOrEqualTo(object NSObject) bool {
	ret := (bool)(C.CBDescriptor_inst_IsGreaterThanOrEqualTo(o.Ptr(), object.Ptr()))
	runtime.KeepAlive(o)
	return ret
}

func (o *CBDescriptor) Dealloc()  {
	C.CBDescriptor_inst_Dealloc(o.Ptr())
	runtime.KeepAlive(o)
}

func (o *CBDescriptor) MethodSignatureForSelector(aSelector SEL) *NSMethodSignature {
	ret := &NSMethodSignature{}
	ret.ptr = unsafe.Pointer(C.CBDescriptor_inst_MethodSignatureForSelector(o.Ptr(), unsafe.Pointer(aSelector)))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSMethodSignature)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *NSMethodSignature) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *CBDescriptor) AutoContentAccessingProxy() *Id {
	ret := &Id{}
	ret.ptr = unsafe.Pointer(C.CBDescriptor_inst_AutoContentAccessingProxy(o.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *Id) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *CBDescriptor) MutableSetValueForKeyPath(keyPath *NSString) *NSMutableSet {
	ret := &NSMutableSet{}
	ret.ptr = unsafe.Pointer(C.CBDescriptor_inst_MutableSetValueForKeyPath(o.Ptr(), keyPath.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSMutableSet)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *NSMutableSet) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *CBDescriptor) MutableArrayValueForKey(key *NSString) *NSMutableArray {
	ret := &NSMutableArray{}
	ret.ptr = unsafe.Pointer(C.CBDescriptor_inst_MutableArrayValueForKey(o.Ptr(), key.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSMutableArray)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *NSMutableArray) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *CBDescriptor) ScriptingContains(object NSObject) bool {
	ret := (bool)(C.CBDescriptor_inst_ScriptingContains(o.Ptr(), object.Ptr()))
	runtime.KeepAlive(o)
	return ret
}

func (o *CBDescriptor) MutableSetValueForKey(key *NSString) *NSMutableSet {
	ret := &NSMutableSet{}
	ret.ptr = unsafe.Pointer(C.CBDescriptor_inst_MutableSetValueForKey(o.Ptr(), key.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSMutableSet)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *NSMutableSet) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *CBDescriptor) DictionaryWithValuesForKeys(keys *NSArray) *NSDictionary {
	ret := &NSDictionary{}
	ret.ptr = unsafe.Pointer(C.CBDescriptor_inst_DictionaryWithValuesForKeys(o.Ptr(), keys.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSDictionary)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *NSDictionary) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *CBDescriptor) SetScriptingProperties(scriptingProperties *NSDictionary)  {
	C.CBDescriptor_inst_SetScriptingProperties(o.Ptr(), scriptingProperties.Ptr())
	runtime.KeepAlive(o)
}

func (o *CBDescriptor) ObservationInfo() unsafe.Pointer {
	ret := (unsafe.Pointer)(unsafe.Pointer(C.CBDescriptor_inst_ObservationInfo(o.Ptr())))
	runtime.KeepAlive(o)
	return ret
}

func (o *CBDescriptor) ToManyRelationshipKeys() *NSArray {
	ret := &NSArray{}
	ret.ptr = unsafe.Pointer(C.CBDescriptor_inst_ToManyRelationshipKeys(o.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSArray)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *NSArray) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *CBDescriptor) ReplaceValueAtIndexInPropertyWithKey(index NSUInteger, key *NSString, value NSObject)  {
	C.CBDescriptor_inst_ReplaceValueAtIndexInPropertyWithKey(o.Ptr(), (C.NSUInteger)(index), key.Ptr(), value.Ptr())
	runtime.KeepAlive(o)
}

func (o *CBDescriptor) ReplaceValueAtIndexInPropertyWithKeyWithValue(index NSUInteger, key *NSString, value NSObject)  {
	C.CBDescriptor_inst_ReplaceValueAtIndexInPropertyWithKeyWithValue(o.Ptr(), (C.NSUInteger)(index), key.Ptr(), value.Ptr())
	runtime.KeepAlive(o)
}

func (o *CBDescriptor) DidChangeValueForKey(key *NSString)  {
	C.CBDescriptor_inst_DidChangeValueForKey(o.Ptr(), key.Ptr())
	runtime.KeepAlive(o)
}

func (o *CBDescriptor) DidChangeValueForKeyWithSetMutation(key *NSString, mutationKind NSKeyValueSetMutationKind, objects *NSSet)  {
	C.CBDescriptor_inst_DidChangeValueForKeyWithSetMutation(o.Ptr(), key.Ptr(), (C.NSKeyValueSetMutationKind)(mutationKind), objects.Ptr())
	runtime.KeepAlive(o)
}

func (o *CBDescriptor) DidChangeValueForKeyWithSetMutationUsingObjects(key *NSString, mutationKind NSKeyValueSetMutationKind, objects *NSSet)  {
	C.CBDescriptor_inst_DidChangeValueForKeyWithSetMutationUsingObjects(o.Ptr(), key.Ptr(), (C.NSKeyValueSetMutationKind)(mutationKind), objects.Ptr())
	runtime.KeepAlive(o)
}

func (o *CBDescriptor) ValidateValueForKey(ioValue *[]*Id, inKey *NSString, outError *[]*NSError) bool {

	goSlice1 := make([]unsafe.Pointer,cap(*ioValue))
	for i := 0; i < len(*ioValue); i++ {
		goSlice1[i] = (*ioValue)[i].Ptr()
	}

	goSlice3 := make([]unsafe.Pointer,cap(*outError))
	for i := 0; i < len(*outError); i++ {
		goSlice3[i] = (*outError)[i].Ptr()
	}
	ret := (bool)(C.CBDescriptor_inst_ValidateValueForKey(o.Ptr(), (*unsafe.Pointer)(unsafe.Pointer(&goSlice1[0])), inKey.Ptr(), (*unsafe.Pointer)(unsafe.Pointer(&goSlice3[0]))))
	(*ioValue) = (*ioValue)[:cap(*ioValue)]
	for i := 0; i < len(*ioValue); i++ {
		if goSlice1[i] == nil {
			(*ioValue) = (*ioValue)[:i]
			break
		}
		if (*ioValue)[i] == nil {
			(*ioValue)[i] = &Id{}
			runtime.SetFinalizer((*ioValue)[i], func(o *Id) {
				o.Release()
			})
		}
		(*ioValue)[i].ptr = goSlice1[i]
	}
	(*outError) = (*outError)[:cap(*outError)]
	for i := 0; i < len(*outError); i++ {
		if goSlice3[i] == nil {
			(*outError) = (*outError)[:i]
			break
		}
		if (*outError)[i] == nil {
			(*outError)[i] = &NSError{}
			runtime.SetFinalizer((*outError)[i], func(o *NSError) {
				o.Release()
			})
		}
		(*outError)[i].ptr = goSlice3[i]
	}
	runtime.KeepAlive(o)
	return ret
}

func (o *CBDescriptor) ValidateValueForKeyPath(ioValue *[]*Id, inKeyPath *NSString, outError *[]*NSError) bool {

	goSlice1 := make([]unsafe.Pointer,cap(*ioValue))
	for i := 0; i < len(*ioValue); i++ {
		goSlice1[i] = (*ioValue)[i].Ptr()
	}

	goSlice3 := make([]unsafe.Pointer,cap(*outError))
	for i := 0; i < len(*outError); i++ {
		goSlice3[i] = (*outError)[i].Ptr()
	}
	ret := (bool)(C.CBDescriptor_inst_ValidateValueForKeyPath(o.Ptr(), (*unsafe.Pointer)(unsafe.Pointer(&goSlice1[0])), inKeyPath.Ptr(), (*unsafe.Pointer)(unsafe.Pointer(&goSlice3[0]))))
	(*ioValue) = (*ioValue)[:cap(*ioValue)]
	for i := 0; i < len(*ioValue); i++ {
		if goSlice1[i] == nil {
			(*ioValue) = (*ioValue)[:i]
			break
		}
		if (*ioValue)[i] == nil {
			(*ioValue)[i] = &Id{}
			runtime.SetFinalizer((*ioValue)[i], func(o *Id) {
				o.Release()
			})
		}
		(*ioValue)[i].ptr = goSlice1[i]
	}
	(*outError) = (*outError)[:cap(*outError)]
	for i := 0; i < len(*outError); i++ {
		if goSlice3[i] == nil {
			(*outError) = (*outError)[:i]
			break
		}
		if (*outError)[i] == nil {
			(*outError)[i] = &NSError{}
			runtime.SetFinalizer((*outError)[i], func(o *NSError) {
				o.Release()
			})
		}
		(*outError)[i].ptr = goSlice3[i]
	}
	runtime.KeepAlive(o)
	return ret
}

func (o *CBDescriptor) ValidateValueForKeyError(ioValue *[]*Id, inKey *NSString, outError *[]*NSError) bool {

	goSlice1 := make([]unsafe.Pointer,cap(*ioValue))
	for i := 0; i < len(*ioValue); i++ {
		goSlice1[i] = (*ioValue)[i].Ptr()
	}

	goSlice3 := make([]unsafe.Pointer,cap(*outError))
	for i := 0; i < len(*outError); i++ {
		goSlice3[i] = (*outError)[i].Ptr()
	}
	ret := (bool)(C.CBDescriptor_inst_ValidateValueForKeyError(o.Ptr(), (*unsafe.Pointer)(unsafe.Pointer(&goSlice1[0])), inKey.Ptr(), (*unsafe.Pointer)(unsafe.Pointer(&goSlice3[0]))))
	(*ioValue) = (*ioValue)[:cap(*ioValue)]
	for i := 0; i < len(*ioValue); i++ {
		if goSlice1[i] == nil {
			(*ioValue) = (*ioValue)[:i]
			break
		}
		if (*ioValue)[i] == nil {
			(*ioValue)[i] = &Id{}
			runtime.SetFinalizer((*ioValue)[i], func(o *Id) {
				o.Release()
			})
		}
		(*ioValue)[i].ptr = goSlice1[i]
	}
	(*outError) = (*outError)[:cap(*outError)]
	for i := 0; i < len(*outError); i++ {
		if goSlice3[i] == nil {
			(*outError) = (*outError)[:i]
			break
		}
		if (*outError)[i] == nil {
			(*outError)[i] = &NSError{}
			runtime.SetFinalizer((*outError)[i], func(o *NSError) {
				o.Release()
			})
		}
		(*outError)[i].ptr = goSlice3[i]
	}
	runtime.KeepAlive(o)
	return ret
}

func (o *CBDescriptor) ValidateValueForKeyPathError(ioValue *[]*Id, inKeyPath *NSString, outError *[]*NSError) bool {

	goSlice1 := make([]unsafe.Pointer,cap(*ioValue))
	for i := 0; i < len(*ioValue); i++ {
		goSlice1[i] = (*ioValue)[i].Ptr()
	}

	goSlice3 := make([]unsafe.Pointer,cap(*outError))
	for i := 0; i < len(*outError); i++ {
		goSlice3[i] = (*outError)[i].Ptr()
	}
	ret := (bool)(C.CBDescriptor_inst_ValidateValueForKeyPathError(o.Ptr(), (*unsafe.Pointer)(unsafe.Pointer(&goSlice1[0])), inKeyPath.Ptr(), (*unsafe.Pointer)(unsafe.Pointer(&goSlice3[0]))))
	(*ioValue) = (*ioValue)[:cap(*ioValue)]
	for i := 0; i < len(*ioValue); i++ {
		if goSlice1[i] == nil {
			(*ioValue) = (*ioValue)[:i]
			break
		}
		if (*ioValue)[i] == nil {
			(*ioValue)[i] = &Id{}
			runtime.SetFinalizer((*ioValue)[i], func(o *Id) {
				o.Release()
			})
		}
		(*ioValue)[i].ptr = goSlice1[i]
	}
	(*outError) = (*outError)[:cap(*outError)]
	for i := 0; i < len(*outError); i++ {
		if goSlice3[i] == nil {
			(*outError) = (*outError)[:i]
			break
		}
		if (*outError)[i] == nil {
			(*outError)[i] = &NSError{}
			runtime.SetFinalizer((*outError)[i], func(o *NSError) {
				o.Release()
			})
		}
		(*outError)[i].ptr = goSlice3[i]
	}
	runtime.KeepAlive(o)
	return ret
}

func (o *CBDescriptor) IsGreaterThan(object NSObject) bool {
	ret := (bool)(C.CBDescriptor_inst_IsGreaterThan(o.Ptr(), object.Ptr()))
	runtime.KeepAlive(o)
	return ret
}

func (o *CBDescriptor) MutableCopy() *Id {
	ret := &Id{}
	ret.ptr = unsafe.Pointer(C.CBDescriptor_inst_MutableCopy(o.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	runtime.SetFinalizer(ret, func(o *Id) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *CBDescriptor) ObserveValueForKeyPathOfObject(keyPath *NSString, object NSObject, change *NSDictionary, context unsafe.Pointer)  {
	C.CBDescriptor_inst_ObserveValueForKeyPathOfObject(o.Ptr(), keyPath.Ptr(), object.Ptr(), change.Ptr(), unsafe.Pointer(context))
	runtime.KeepAlive(o)
}

func (o *CBDescriptor) ObserveValueForKeyPathOfObjectChange(keyPath *NSString, object NSObject, change *NSDictionary, context unsafe.Pointer)  {
	C.CBDescriptor_inst_ObserveValueForKeyPathOfObjectChange(o.Ptr(), keyPath.Ptr(), object.Ptr(), change.Ptr(), unsafe.Pointer(context))
	runtime.KeepAlive(o)
}

func (o *CBDescriptor) ObserveValueForKeyPathOfObjectChangeContext(keyPath *NSString, object NSObject, change *NSDictionary, context unsafe.Pointer)  {
	C.CBDescriptor_inst_ObserveValueForKeyPathOfObjectChangeContext(o.Ptr(), keyPath.Ptr(), object.Ptr(), change.Ptr(), unsafe.Pointer(context))
	runtime.KeepAlive(o)
}

func (o *CBDescriptor) PerformSelectorOnMainThreadWithObject(aSelector SEL, arg NSObject, wait BOOL)  {
	C.CBDescriptor_inst_PerformSelectorOnMainThreadWithObject(o.Ptr(), unsafe.Pointer(aSelector), arg.Ptr(), (C.BOOL)(wait))
	runtime.KeepAlive(o)
}

func (o *CBDescriptor) PerformSelectorOnMainThreadWithObjectWaitUntilDone(aSelector SEL, arg NSObject, wait BOOL)  {
	C.CBDescriptor_inst_PerformSelectorOnMainThreadWithObjectWaitUntilDone(o.Ptr(), unsafe.Pointer(aSelector), arg.Ptr(), (C.BOOL)(wait))
	runtime.KeepAlive(o)
}

func (o *CBDescriptor) PerformSelectorOnMainThreadWithObjectWaitUntilDoneModes(aSelector SEL, arg NSObject, wait BOOL, array *NSArray)  {
	C.CBDescriptor_inst_PerformSelectorOnMainThreadWithObjectWaitUntilDoneModes(o.Ptr(), unsafe.Pointer(aSelector), arg.Ptr(), (C.BOOL)(wait), array.Ptr())
	runtime.KeepAlive(o)
}

func (o *CBDescriptor) MutableOrderedSetValueForKeyPath(keyPath *NSString) *NSMutableOrderedSet {
	ret := &NSMutableOrderedSet{}
	ret.ptr = unsafe.Pointer(C.CBDescriptor_inst_MutableOrderedSetValueForKeyPath(o.Ptr(), keyPath.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSMutableOrderedSet)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *NSMutableOrderedSet) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *CBDescriptor) ReplacementObjectForKeyedArchiver(archiver *NSKeyedArchiver) *Id {
	ret := &Id{}
	ret.ptr = unsafe.Pointer(C.CBDescriptor_inst_ReplacementObjectForKeyedArchiver(o.Ptr(), archiver.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *Id) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *CBDescriptor) ScriptingIsGreaterThan(object NSObject) bool {
	ret := (bool)(C.CBDescriptor_inst_ScriptingIsGreaterThan(o.Ptr(), object.Ptr()))
	runtime.KeepAlive(o)
	return ret
}

func (o *CBDescriptor) DoesNotRecognizeSelector(aSelector SEL)  {
	C.CBDescriptor_inst_DoesNotRecognizeSelector(o.Ptr(), unsafe.Pointer(aSelector))
	runtime.KeepAlive(o)
}

func (o *CBDescriptor) NewScriptingObjectOfClassForValueForKey(objectClass Class, key *NSString, contentsValue NSObject, properties *NSDictionary) *Id {
	ret := &Id{}
	ret.ptr = unsafe.Pointer(C.CBDescriptor_inst_NewScriptingObjectOfClassForValueForKey(o.Ptr(), unsafe.Pointer(objectClass), key.Ptr(), contentsValue.Ptr(), properties.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *Id) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *CBDescriptor) NewScriptingObjectOfClassForValueForKeyWithContentsValue(objectClass Class, key *NSString, contentsValue NSObject, properties *NSDictionary) *Id {
	ret := &Id{}
	ret.ptr = unsafe.Pointer(C.CBDescriptor_inst_NewScriptingObjectOfClassForValueForKeyWithContentsValue(o.Ptr(), unsafe.Pointer(objectClass), key.Ptr(), contentsValue.Ptr(), properties.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *Id) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *CBDescriptor) NewScriptingObjectOfClassForValueForKeyWithContentsValueProperties(objectClass Class, key *NSString, contentsValue NSObject, properties *NSDictionary) *Id {
	ret := &Id{}
	ret.ptr = unsafe.Pointer(C.CBDescriptor_inst_NewScriptingObjectOfClassForValueForKeyWithContentsValueProperties(o.Ptr(), unsafe.Pointer(objectClass), key.Ptr(), contentsValue.Ptr(), properties.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *Id) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *CBDescriptor) ScriptingIsGreaterThanOrEqualTo(object NSObject) bool {
	ret := (bool)(C.CBDescriptor_inst_ScriptingIsGreaterThanOrEqualTo(o.Ptr(), object.Ptr()))
	runtime.KeepAlive(o)
	return ret
}

func (o *CBDescriptor) WillChangeValueForKey(key *NSString)  {
	C.CBDescriptor_inst_WillChangeValueForKey(o.Ptr(), key.Ptr())
	runtime.KeepAlive(o)
}

func (o *CBDescriptor) WillChangeValueForKeyWithSetMutation(key *NSString, mutationKind NSKeyValueSetMutationKind, objects *NSSet)  {
	C.CBDescriptor_inst_WillChangeValueForKeyWithSetMutation(o.Ptr(), key.Ptr(), (C.NSKeyValueSetMutationKind)(mutationKind), objects.Ptr())
	runtime.KeepAlive(o)
}

func (o *CBDescriptor) WillChangeValueForKeyWithSetMutationUsingObjects(key *NSString, mutationKind NSKeyValueSetMutationKind, objects *NSSet)  {
	C.CBDescriptor_inst_WillChangeValueForKeyWithSetMutationUsingObjects(o.Ptr(), key.Ptr(), (C.NSKeyValueSetMutationKind)(mutationKind), objects.Ptr())
	runtime.KeepAlive(o)
}

func (o *CBDescriptor) CopyScriptingValueForKey(value NSObject, key *NSString, properties *NSDictionary) *Id {
	ret := &Id{}
	ret.ptr = unsafe.Pointer(C.CBDescriptor_inst_CopyScriptingValueForKey(o.Ptr(), value.Ptr(), key.Ptr(), properties.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *Id) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *CBDescriptor) CopyScriptingValueForKeyWithProperties(value NSObject, key *NSString, properties *NSDictionary) *Id {
	ret := &Id{}
	ret.ptr = unsafe.Pointer(C.CBDescriptor_inst_CopyScriptingValueForKeyWithProperties(o.Ptr(), value.Ptr(), key.Ptr(), properties.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *Id) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *CBDescriptor) MutableArrayValueForKeyPath(keyPath *NSString) *NSMutableArray {
	ret := &NSMutableArray{}
	ret.ptr = unsafe.Pointer(C.CBDescriptor_inst_MutableArrayValueForKeyPath(o.Ptr(), keyPath.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSMutableArray)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *NSMutableArray) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *CBDescriptor) InverseForRelationshipKey(relationshipKey *NSString) *NSString {
	ret := &NSString{}
	ret.ptr = unsafe.Pointer(C.CBDescriptor_inst_InverseForRelationshipKey(o.Ptr(), relationshipKey.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSString)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *NSString) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *CBDescriptor) SetValuesForKeysWithDictionary(keyedValues *NSDictionary)  {
	C.CBDescriptor_inst_SetValuesForKeysWithDictionary(o.Ptr(), keyedValues.Ptr())
	runtime.KeepAlive(o)
}

func (o *CBDescriptor) RemoveObserverForKeyPath(observer NSObject, keyPath *NSString)  {
	C.CBDescriptor_inst_RemoveObserverForKeyPath(o.Ptr(), observer.Ptr(), keyPath.Ptr())
	runtime.KeepAlive(o)
}

func (o *CBDescriptor) RemoveObserverForKeyPathContext(observer NSObject, keyPath *NSString, context unsafe.Pointer)  {
	C.CBDescriptor_inst_RemoveObserverForKeyPathContext(o.Ptr(), observer.Ptr(), keyPath.Ptr(), unsafe.Pointer(context))
	runtime.KeepAlive(o)
}

func (o *CBDescriptor) ScriptingProperties() *NSDictionary {
	ret := &NSDictionary{}
	ret.ptr = unsafe.Pointer(C.CBDescriptor_inst_ScriptingProperties(o.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSDictionary)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *NSDictionary) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func CBUUIDWithNSUUID(theUUID *NSUUID) *CBUUID {
	ret := &CBUUID{}
	ret.ptr = unsafe.Pointer(C.CBUUID_UUIDWithNSUUID(theUUID.Ptr()))
	if ret.ptr == nil { return ret }
	runtime.SetFinalizer(ret, func(o *CBUUID) {
		o.Release()
	})
	return ret
}

func CBUUIDescription() *NSString {
	ret := &NSString{}
	ret.ptr = unsafe.Pointer(C.CBUUID_Description())
	if ret.ptr == nil { return ret }
	runtime.SetFinalizer(ret, func(o *NSString) {
		o.Release()
	})
	return ret
}

func CBUUIDAccessInstanceVariablesDirectly() bool {
	ret := (bool)(C.CBUUID_AccessInstanceVariablesDirectly())
	return ret
}

func CBUUIDNew() *CBUUID {
	ret := &CBUUID{}
	ret.ptr = unsafe.Pointer(C.CBUUID_New())
	if ret.ptr == nil { return ret }
	runtime.SetFinalizer(ret, func(o *CBUUID) {
		o.Release()
	})
	return ret
}

func CBUUIDKeyPathsForValuesAffectingValueForKey(key *NSString) *NSSet {
	ret := &NSSet{}
	ret.ptr = unsafe.Pointer(C.CBUUID_KeyPathsForValuesAffectingValueForKey(key.Ptr()))
	if ret.ptr == nil { return ret }
	return ret
}

func CBUUIDAutomaticallyNotifiesObserversForKey(key *NSString) bool {
	ret := (bool)(C.CBUUID_AutomaticallyNotifiesObserversForKey(key.Ptr()))
	return ret
}

func CBUUIDCopyWithZone(zone *_NSZone) *Id {
	ret := &Id{}
	ret.ptr = unsafe.Pointer(C.CBUUID_CopyWithZone(unsafe.Pointer(zone)))
	if ret.ptr == nil { return ret }
	runtime.SetFinalizer(ret, func(o *Id) {
		o.Release()
	})
	return ret
}

func CBUUIDConformsToProtocol(protocol Protocol) bool {
	ret := (bool)(C.CBUUID_ConformsToProtocol(protocol.Ptr()))
	return ret
}

func CBUUIDWithString(theString *NSString) *CBUUID {
	ret := &CBUUID{}
	ret.ptr = unsafe.Pointer(C.CBUUID_UUIDWithString(theString.Ptr()))
	if ret.ptr == nil { return ret }
	runtime.SetFinalizer(ret, func(o *CBUUID) {
		o.Release()
	})
	return ret
}

func CBUUIDWithGoString(theString string) *CBUUID {
	theString_chr := CharWithGoString(theString)
	defer theString_chr.Free()
	ret := CBUUIDWithString(NSStringWithUTF8String(theString_chr))
	return ret
}

func CBUUIDResolveInstanceMethod(sel SEL) bool {
	ret := (bool)(C.CBUUID_ResolveInstanceMethod(unsafe.Pointer(sel)))
	return ret
}

func CBUUIDCancelPreviousPerformRequestsWithTarget(aTarget NSObject)  {
	C.CBUUID_CancelPreviousPerformRequestsWithTarget(aTarget.Ptr())
}

func CBUUIDCancelPreviousPerformRequestsWithTargetSelector(aTarget NSObject, aSelector SEL, anArgument NSObject)  {
	C.CBUUID_CancelPreviousPerformRequestsWithTargetSelector(aTarget.Ptr(), unsafe.Pointer(aSelector), anArgument.Ptr())
}

func CBUUIDCancelPreviousPerformRequestsWithTargetSelectorObject(aTarget NSObject, aSelector SEL, anArgument NSObject)  {
	C.CBUUID_CancelPreviousPerformRequestsWithTargetSelectorObject(aTarget.Ptr(), unsafe.Pointer(aSelector), anArgument.Ptr())
}

func CBUUIDClass() Class {
	ret := (Class)(unsafe.Pointer(C.CBUUID_Class()))
	return ret
}

func CBUUIDSuperclass() Class {
	ret := (Class)(unsafe.Pointer(C.CBUUID_Superclass()))
	return ret
}

func CBUUIDVersion() NSInteger {
	ret := (NSInteger)(C.CBUUID_Version())
	return ret
}

func CBUUIDInstancesRespondToSelector(aSelector SEL) bool {
	ret := (bool)(C.CBUUID_InstancesRespondToSelector(unsafe.Pointer(aSelector)))
	return ret
}

func CBUUIDResolveClassMethod(sel SEL) bool {
	ret := (bool)(C.CBUUID_ResolveClassMethod(unsafe.Pointer(sel)))
	return ret
}

func CBUUIDMutableCopyWithZone(zone *_NSZone) *Id {
	ret := &Id{}
	ret.ptr = unsafe.Pointer(C.CBUUID_MutableCopyWithZone(unsafe.Pointer(zone)))
	if ret.ptr == nil { return ret }
	runtime.SetFinalizer(ret, func(o *Id) {
		o.Release()
	})
	return ret
}

func CBUUIDClassFallbacksForKeyedArchiver() *NSArray {
	ret := &NSArray{}
	ret.ptr = unsafe.Pointer(C.CBUUID_ClassFallbacksForKeyedArchiver())
	if ret.ptr == nil { return ret }
	return ret
}

func CBUUIDInstanceMethodSignatureForSelector(aSelector SEL) *NSMethodSignature {
	ret := &NSMethodSignature{}
	ret.ptr = unsafe.Pointer(C.CBUUID_InstanceMethodSignatureForSelector(unsafe.Pointer(aSelector)))
	if ret.ptr == nil { return ret }
	return ret
}

func CBUUIDebugDescription() *NSString {
	ret := &NSString{}
	ret.ptr = unsafe.Pointer(C.CBUUID_DebugDescription())
	if ret.ptr == nil { return ret }
	runtime.SetFinalizer(ret, func(o *NSString) {
		o.Release()
	})
	return ret
}

func CBUUIDSetVersion(aVersion NSInteger)  {
	C.CBUUID_SetVersion((C.NSInteger)(aVersion))
}

func CBUUIDLoad()  {
	C.CBUUID_Load()
}

func CBUUIDWithData(theData *NSData) *CBUUID {
	ret := &CBUUID{}
	ret.ptr = unsafe.Pointer(C.CBUUID_UUIDWithData(theData.Ptr()))
	if ret.ptr == nil { return ret }
	runtime.SetFinalizer(ret, func(o *CBUUID) {
		o.Release()
	})
	return ret
}

func CBUUIDIsSubclassOfClass(aClass Class) bool {
	ret := (bool)(C.CBUUID_IsSubclassOfClass(unsafe.Pointer(aClass)))
	return ret
}

func CBUUIDAlloc() *CBUUID {
	ret := &CBUUID{}
	ret.ptr = unsafe.Pointer(C.CBUUID_Alloc())
	if ret.ptr == nil { return ret }
	runtime.SetFinalizer(ret, func(o *CBUUID) {
		o.Release()
	})
	return ret
}

func (o *CBUUID) GC() {
	if o.ptr == nil { return }
	runtime.SetFinalizer(o, func(o *CBUUID) {
		o.Release()
	})
	runtime.KeepAlive(o)
}

func CBUUIDHash() NSUInteger {
	ret := (NSUInteger)(C.CBUUID_Hash())
	return ret
}

func CBUUIDClassForKeyedUnarchiver() Class {
	ret := (Class)(unsafe.Pointer(C.CBUUID_ClassForKeyedUnarchiver()))
	return ret
}

func CBUUIDAllocWithZone(zone *_NSZone) *CBUUID {
	ret := &CBUUID{}
	ret.ptr = unsafe.Pointer(C.CBUUID_AllocWithZone(unsafe.Pointer(zone)))
	if ret.ptr == nil { return ret }
	runtime.SetFinalizer(ret, func(o *CBUUID) {
		o.Release()
	})
	return ret
}

func (o *CBUUID) ValueForKey(key *NSString) *Id {
	ret := &Id{}
	ret.ptr = unsafe.Pointer(C.CBUUID_inst_ValueForKey(o.Ptr(), key.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *Id) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *CBUUID) IsCaseInsensitiveLike(object *NSString) bool {
	ret := (bool)(C.CBUUID_inst_IsCaseInsensitiveLike(o.Ptr(), object.Ptr()))
	runtime.KeepAlive(o)
	return ret
}

func (o *CBUUID) MutableCopy() *Id {
	ret := &Id{}
	ret.ptr = unsafe.Pointer(C.CBUUID_inst_MutableCopy(o.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	runtime.SetFinalizer(ret, func(o *Id) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *CBUUID) ClassForKeyedArchiver() Class {
	ret := (Class)(unsafe.Pointer(C.CBUUID_inst_ClassForKeyedArchiver(o.Ptr())))
	runtime.KeepAlive(o)
	return ret
}

func (o *CBUUID) SetScriptingProperties(scriptingProperties *NSDictionary)  {
	C.CBUUID_inst_SetScriptingProperties(o.Ptr(), scriptingProperties.Ptr())
	runtime.KeepAlive(o)
}

func (o *CBUUID) WillChangeValuesAtIndexes(changeKind NSKeyValueChange, indexes *NSIndexSet, key *NSString)  {
	C.CBUUID_inst_WillChangeValuesAtIndexes(o.Ptr(), (C.NSKeyValueChange)(changeKind), indexes.Ptr(), key.Ptr())
	runtime.KeepAlive(o)
}

func (o *CBUUID) WillChangeValuesAtIndexesForKey(changeKind NSKeyValueChange, indexes *NSIndexSet, key *NSString)  {
	C.CBUUID_inst_WillChangeValuesAtIndexesForKey(o.Ptr(), (C.NSKeyValueChange)(changeKind), indexes.Ptr(), key.Ptr())
	runtime.KeepAlive(o)
}

func (o *CBUUID) AutoContentAccessingProxy() *Id {
	ret := &Id{}
	ret.ptr = unsafe.Pointer(C.CBUUID_inst_AutoContentAccessingProxy(o.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *Id) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *CBUUID) ScriptingBeginsWith(object NSObject) bool {
	ret := (bool)(C.CBUUID_inst_ScriptingBeginsWith(o.Ptr(), object.Ptr()))
	runtime.KeepAlive(o)
	return ret
}

func (o *CBUUID) IsGreaterThanOrEqualTo(object NSObject) bool {
	ret := (bool)(C.CBUUID_inst_IsGreaterThanOrEqualTo(o.Ptr(), object.Ptr()))
	runtime.KeepAlive(o)
	return ret
}

func (o *CBUUID) SetValuesForKeysWithDictionary(keyedValues *NSDictionary)  {
	C.CBUUID_inst_SetValuesForKeysWithDictionary(o.Ptr(), keyedValues.Ptr())
	runtime.KeepAlive(o)
}

func (o *CBUUID) ValidateValueForKey(ioValue *[]*Id, inKey *NSString, outError *[]*NSError) bool {

	goSlice1 := make([]unsafe.Pointer,cap(*ioValue))
	for i := 0; i < len(*ioValue); i++ {
		goSlice1[i] = (*ioValue)[i].Ptr()
	}

	goSlice3 := make([]unsafe.Pointer,cap(*outError))
	for i := 0; i < len(*outError); i++ {
		goSlice3[i] = (*outError)[i].Ptr()
	}
	ret := (bool)(C.CBUUID_inst_ValidateValueForKey(o.Ptr(), (*unsafe.Pointer)(unsafe.Pointer(&goSlice1[0])), inKey.Ptr(), (*unsafe.Pointer)(unsafe.Pointer(&goSlice3[0]))))
	(*ioValue) = (*ioValue)[:cap(*ioValue)]
	for i := 0; i < len(*ioValue); i++ {
		if goSlice1[i] == nil {
			(*ioValue) = (*ioValue)[:i]
			break
		}
		if (*ioValue)[i] == nil {
			(*ioValue)[i] = &Id{}
			runtime.SetFinalizer((*ioValue)[i], func(o *Id) {
				o.Release()
			})
		}
		(*ioValue)[i].ptr = goSlice1[i]
	}
	(*outError) = (*outError)[:cap(*outError)]
	for i := 0; i < len(*outError); i++ {
		if goSlice3[i] == nil {
			(*outError) = (*outError)[:i]
			break
		}
		if (*outError)[i] == nil {
			(*outError)[i] = &NSError{}
			runtime.SetFinalizer((*outError)[i], func(o *NSError) {
				o.Release()
			})
		}
		(*outError)[i].ptr = goSlice3[i]
	}
	runtime.KeepAlive(o)
	return ret
}

func (o *CBUUID) ValidateValueForKeyPath(ioValue *[]*Id, inKeyPath *NSString, outError *[]*NSError) bool {

	goSlice1 := make([]unsafe.Pointer,cap(*ioValue))
	for i := 0; i < len(*ioValue); i++ {
		goSlice1[i] = (*ioValue)[i].Ptr()
	}

	goSlice3 := make([]unsafe.Pointer,cap(*outError))
	for i := 0; i < len(*outError); i++ {
		goSlice3[i] = (*outError)[i].Ptr()
	}
	ret := (bool)(C.CBUUID_inst_ValidateValueForKeyPath(o.Ptr(), (*unsafe.Pointer)(unsafe.Pointer(&goSlice1[0])), inKeyPath.Ptr(), (*unsafe.Pointer)(unsafe.Pointer(&goSlice3[0]))))
	(*ioValue) = (*ioValue)[:cap(*ioValue)]
	for i := 0; i < len(*ioValue); i++ {
		if goSlice1[i] == nil {
			(*ioValue) = (*ioValue)[:i]
			break
		}
		if (*ioValue)[i] == nil {
			(*ioValue)[i] = &Id{}
			runtime.SetFinalizer((*ioValue)[i], func(o *Id) {
				o.Release()
			})
		}
		(*ioValue)[i].ptr = goSlice1[i]
	}
	(*outError) = (*outError)[:cap(*outError)]
	for i := 0; i < len(*outError); i++ {
		if goSlice3[i] == nil {
			(*outError) = (*outError)[:i]
			break
		}
		if (*outError)[i] == nil {
			(*outError)[i] = &NSError{}
			runtime.SetFinalizer((*outError)[i], func(o *NSError) {
				o.Release()
			})
		}
		(*outError)[i].ptr = goSlice3[i]
	}
	runtime.KeepAlive(o)
	return ret
}

func (o *CBUUID) ValidateValueForKeyError(ioValue *[]*Id, inKey *NSString, outError *[]*NSError) bool {

	goSlice1 := make([]unsafe.Pointer,cap(*ioValue))
	for i := 0; i < len(*ioValue); i++ {
		goSlice1[i] = (*ioValue)[i].Ptr()
	}

	goSlice3 := make([]unsafe.Pointer,cap(*outError))
	for i := 0; i < len(*outError); i++ {
		goSlice3[i] = (*outError)[i].Ptr()
	}
	ret := (bool)(C.CBUUID_inst_ValidateValueForKeyError(o.Ptr(), (*unsafe.Pointer)(unsafe.Pointer(&goSlice1[0])), inKey.Ptr(), (*unsafe.Pointer)(unsafe.Pointer(&goSlice3[0]))))
	(*ioValue) = (*ioValue)[:cap(*ioValue)]
	for i := 0; i < len(*ioValue); i++ {
		if goSlice1[i] == nil {
			(*ioValue) = (*ioValue)[:i]
			break
		}
		if (*ioValue)[i] == nil {
			(*ioValue)[i] = &Id{}
			runtime.SetFinalizer((*ioValue)[i], func(o *Id) {
				o.Release()
			})
		}
		(*ioValue)[i].ptr = goSlice1[i]
	}
	(*outError) = (*outError)[:cap(*outError)]
	for i := 0; i < len(*outError); i++ {
		if goSlice3[i] == nil {
			(*outError) = (*outError)[:i]
			break
		}
		if (*outError)[i] == nil {
			(*outError)[i] = &NSError{}
			runtime.SetFinalizer((*outError)[i], func(o *NSError) {
				o.Release()
			})
		}
		(*outError)[i].ptr = goSlice3[i]
	}
	runtime.KeepAlive(o)
	return ret
}

func (o *CBUUID) ValidateValueForKeyPathError(ioValue *[]*Id, inKeyPath *NSString, outError *[]*NSError) bool {

	goSlice1 := make([]unsafe.Pointer,cap(*ioValue))
	for i := 0; i < len(*ioValue); i++ {
		goSlice1[i] = (*ioValue)[i].Ptr()
	}

	goSlice3 := make([]unsafe.Pointer,cap(*outError))
	for i := 0; i < len(*outError); i++ {
		goSlice3[i] = (*outError)[i].Ptr()
	}
	ret := (bool)(C.CBUUID_inst_ValidateValueForKeyPathError(o.Ptr(), (*unsafe.Pointer)(unsafe.Pointer(&goSlice1[0])), inKeyPath.Ptr(), (*unsafe.Pointer)(unsafe.Pointer(&goSlice3[0]))))
	(*ioValue) = (*ioValue)[:cap(*ioValue)]
	for i := 0; i < len(*ioValue); i++ {
		if goSlice1[i] == nil {
			(*ioValue) = (*ioValue)[:i]
			break
		}
		if (*ioValue)[i] == nil {
			(*ioValue)[i] = &Id{}
			runtime.SetFinalizer((*ioValue)[i], func(o *Id) {
				o.Release()
			})
		}
		(*ioValue)[i].ptr = goSlice1[i]
	}
	(*outError) = (*outError)[:cap(*outError)]
	for i := 0; i < len(*outError); i++ {
		if goSlice3[i] == nil {
			(*outError) = (*outError)[:i]
			break
		}
		if (*outError)[i] == nil {
			(*outError)[i] = &NSError{}
			runtime.SetFinalizer((*outError)[i], func(o *NSError) {
				o.Release()
			})
		}
		(*outError)[i].ptr = goSlice3[i]
	}
	runtime.KeepAlive(o)
	return ret
}

func (o *CBUUID) IsLessThanOrEqualTo(object NSObject) bool {
	ret := (bool)(C.CBUUID_inst_IsLessThanOrEqualTo(o.Ptr(), object.Ptr()))
	runtime.KeepAlive(o)
	return ret
}

func (o *CBUUID) ReplacementObjectForKeyedArchiver(archiver *NSKeyedArchiver) *Id {
	ret := &Id{}
	ret.ptr = unsafe.Pointer(C.CBUUID_inst_ReplacementObjectForKeyedArchiver(o.Ptr(), archiver.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *Id) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *CBUUID) ScriptingEndsWith(object NSObject) bool {
	ret := (bool)(C.CBUUID_inst_ScriptingEndsWith(o.Ptr(), object.Ptr()))
	runtime.KeepAlive(o)
	return ret
}

func (o *CBUUID) ValueWithUniqueIDInPropertyWithKey(uniqueID NSObject, key *NSString) *Id {
	ret := &Id{}
	ret.ptr = unsafe.Pointer(C.CBUUID_inst_ValueWithUniqueIDInPropertyWithKey(o.Ptr(), uniqueID.Ptr(), key.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *Id) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *CBUUID) PerformSelectorOnMainThreadWithObject(aSelector SEL, arg NSObject, wait BOOL)  {
	C.CBUUID_inst_PerformSelectorOnMainThreadWithObject(o.Ptr(), unsafe.Pointer(aSelector), arg.Ptr(), (C.BOOL)(wait))
	runtime.KeepAlive(o)
}

func (o *CBUUID) PerformSelectorOnMainThreadWithObjectWaitUntilDone(aSelector SEL, arg NSObject, wait BOOL)  {
	C.CBUUID_inst_PerformSelectorOnMainThreadWithObjectWaitUntilDone(o.Ptr(), unsafe.Pointer(aSelector), arg.Ptr(), (C.BOOL)(wait))
	runtime.KeepAlive(o)
}

func (o *CBUUID) PerformSelectorOnMainThreadWithObjectWaitUntilDoneModes(aSelector SEL, arg NSObject, wait BOOL, array *NSArray)  {
	C.CBUUID_inst_PerformSelectorOnMainThreadWithObjectWaitUntilDoneModes(o.Ptr(), unsafe.Pointer(aSelector), arg.Ptr(), (C.BOOL)(wait), array.Ptr())
	runtime.KeepAlive(o)
}

func (o *CBUUID) IsLike(object *NSString) bool {
	ret := (bool)(C.CBUUID_inst_IsLike(o.Ptr(), object.Ptr()))
	runtime.KeepAlive(o)
	return ret
}

func (o *CBUUID) ClassDescription() *NSClassDescription {
	ret := &NSClassDescription{}
	ret.ptr = unsafe.Pointer(C.CBUUID_inst_ClassDescription(o.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSClassDescription)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *NSClassDescription) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *CBUUID) DoesContain(object NSObject) bool {
	ret := (bool)(C.CBUUID_inst_DoesContain(o.Ptr(), object.Ptr()))
	runtime.KeepAlive(o)
	return ret
}

func (o *CBUUID) ReplacementObjectForCoder(coder *NSCoder) *Id {
	ret := &Id{}
	ret.ptr = unsafe.Pointer(C.CBUUID_inst_ReplacementObjectForCoder(o.Ptr(), coder.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *Id) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *CBUUID) WillChangeValueForKey(key *NSString)  {
	C.CBUUID_inst_WillChangeValueForKey(o.Ptr(), key.Ptr())
	runtime.KeepAlive(o)
}

func (o *CBUUID) WillChangeValueForKeyWithSetMutation(key *NSString, mutationKind NSKeyValueSetMutationKind, objects *NSSet)  {
	C.CBUUID_inst_WillChangeValueForKeyWithSetMutation(o.Ptr(), key.Ptr(), (C.NSKeyValueSetMutationKind)(mutationKind), objects.Ptr())
	runtime.KeepAlive(o)
}

func (o *CBUUID) WillChangeValueForKeyWithSetMutationUsingObjects(key *NSString, mutationKind NSKeyValueSetMutationKind, objects *NSSet)  {
	C.CBUUID_inst_WillChangeValueForKeyWithSetMutationUsingObjects(o.Ptr(), key.Ptr(), (C.NSKeyValueSetMutationKind)(mutationKind), objects.Ptr())
	runtime.KeepAlive(o)
}

func (o *CBUUID) MutableOrderedSetValueForKey(key *NSString) *NSMutableOrderedSet {
	ret := &NSMutableOrderedSet{}
	ret.ptr = unsafe.Pointer(C.CBUUID_inst_MutableOrderedSetValueForKey(o.Ptr(), key.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSMutableOrderedSet)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *NSMutableOrderedSet) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *CBUUID) ScriptingIsEqualTo(object NSObject) bool {
	ret := (bool)(C.CBUUID_inst_ScriptingIsEqualTo(o.Ptr(), object.Ptr()))
	runtime.KeepAlive(o)
	return ret
}

func (o *CBUUID) IsEqualTo(object NSObject) bool {
	ret := (bool)(C.CBUUID_inst_IsEqualTo(o.Ptr(), object.Ptr()))
	runtime.KeepAlive(o)
	return ret
}

func (o *CBUUID) DictionaryWithValuesForKeys(keys *NSArray) *NSDictionary {
	ret := &NSDictionary{}
	ret.ptr = unsafe.Pointer(C.CBUUID_inst_DictionaryWithValuesForKeys(o.Ptr(), keys.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSDictionary)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *NSDictionary) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *CBUUID) ToManyRelationshipKeys() *NSArray {
	ret := &NSArray{}
	ret.ptr = unsafe.Pointer(C.CBUUID_inst_ToManyRelationshipKeys(o.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSArray)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *NSArray) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *CBUUID) AwakeAfterUsingCoder(coder *NSCoder) *Id {
	ret := &Id{}
	ret.ptr = unsafe.Pointer(C.CBUUID_inst_AwakeAfterUsingCoder(o.Ptr(), coder.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *Id) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *CBUUID) ValueAtIndexInPropertyWithKey(index NSUInteger, key *NSString) *Id {
	ret := &Id{}
	ret.ptr = unsafe.Pointer(C.CBUUID_inst_ValueAtIndexInPropertyWithKey(o.Ptr(), (C.NSUInteger)(index), key.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *Id) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *CBUUID) ClassForArchiver() Class {
	ret := (Class)(unsafe.Pointer(C.CBUUID_inst_ClassForArchiver(o.Ptr())))
	runtime.KeepAlive(o)
	return ret
}

func (o *CBUUID) ReplaceValueAtIndexInPropertyWithKey(index NSUInteger, key *NSString, value NSObject)  {
	C.CBUUID_inst_ReplaceValueAtIndexInPropertyWithKey(o.Ptr(), (C.NSUInteger)(index), key.Ptr(), value.Ptr())
	runtime.KeepAlive(o)
}

func (o *CBUUID) ReplaceValueAtIndexInPropertyWithKeyWithValue(index NSUInteger, key *NSString, value NSObject)  {
	C.CBUUID_inst_ReplaceValueAtIndexInPropertyWithKeyWithValue(o.Ptr(), (C.NSUInteger)(index), key.Ptr(), value.Ptr())
	runtime.KeepAlive(o)
}

func (o *CBUUID) SetNilValueForKey(key *NSString)  {
	C.CBUUID_inst_SetNilValueForKey(o.Ptr(), key.Ptr())
	runtime.KeepAlive(o)
}

func (o *CBUUID) ClassCode() FourCharCode {
	ret := (FourCharCode)(C.CBUUID_inst_ClassCode(o.Ptr()))
	runtime.KeepAlive(o)
	return ret
}

func (o *CBUUID) DidChangeValuesAtIndexes(changeKind NSKeyValueChange, indexes *NSIndexSet, key *NSString)  {
	C.CBUUID_inst_DidChangeValuesAtIndexes(o.Ptr(), (C.NSKeyValueChange)(changeKind), indexes.Ptr(), key.Ptr())
	runtime.KeepAlive(o)
}

func (o *CBUUID) DidChangeValuesAtIndexesForKey(changeKind NSKeyValueChange, indexes *NSIndexSet, key *NSString)  {
	C.CBUUID_inst_DidChangeValuesAtIndexesForKey(o.Ptr(), (C.NSKeyValueChange)(changeKind), indexes.Ptr(), key.Ptr())
	runtime.KeepAlive(o)
}

func (o *CBUUID) NewScriptingObjectOfClassForValueForKey(objectClass Class, key *NSString, contentsValue NSObject, properties *NSDictionary) *Id {
	ret := &Id{}
	ret.ptr = unsafe.Pointer(C.CBUUID_inst_NewScriptingObjectOfClassForValueForKey(o.Ptr(), unsafe.Pointer(objectClass), key.Ptr(), contentsValue.Ptr(), properties.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *Id) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *CBUUID) NewScriptingObjectOfClassForValueForKeyWithContentsValue(objectClass Class, key *NSString, contentsValue NSObject, properties *NSDictionary) *Id {
	ret := &Id{}
	ret.ptr = unsafe.Pointer(C.CBUUID_inst_NewScriptingObjectOfClassForValueForKeyWithContentsValue(o.Ptr(), unsafe.Pointer(objectClass), key.Ptr(), contentsValue.Ptr(), properties.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *Id) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *CBUUID) ToOneRelationshipKeys() *NSArray {
	ret := &NSArray{}
	ret.ptr = unsafe.Pointer(C.CBUUID_inst_ToOneRelationshipKeys(o.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSArray)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *NSArray) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *CBUUID) MutableArrayValueForKeyPath(keyPath *NSString) *NSMutableArray {
	ret := &NSMutableArray{}
	ret.ptr = unsafe.Pointer(C.CBUUID_inst_MutableArrayValueForKeyPath(o.Ptr(), keyPath.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSMutableArray)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *NSMutableArray) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *CBUUID) ForwardInvocation(anInvocation *NSInvocation)  {
	C.CBUUID_inst_ForwardInvocation(o.Ptr(), anInvocation.Ptr())
	runtime.KeepAlive(o)
}

func (o *CBUUID) IsLessThan(object NSObject) bool {
	ret := (bool)(C.CBUUID_inst_IsLessThan(o.Ptr(), object.Ptr()))
	runtime.KeepAlive(o)
	return ret
}

func (o *CBUUID) DidChangeValueForKey(key *NSString)  {
	C.CBUUID_inst_DidChangeValueForKey(o.Ptr(), key.Ptr())
	runtime.KeepAlive(o)
}

func (o *CBUUID) DidChangeValueForKeyWithSetMutation(key *NSString, mutationKind NSKeyValueSetMutationKind, objects *NSSet)  {
	C.CBUUID_inst_DidChangeValueForKeyWithSetMutation(o.Ptr(), key.Ptr(), (C.NSKeyValueSetMutationKind)(mutationKind), objects.Ptr())
	runtime.KeepAlive(o)
}

func (o *CBUUID) DidChangeValueForKeyWithSetMutationUsingObjects(key *NSString, mutationKind NSKeyValueSetMutationKind, objects *NSSet)  {
	C.CBUUID_inst_DidChangeValueForKeyWithSetMutationUsingObjects(o.Ptr(), key.Ptr(), (C.NSKeyValueSetMutationKind)(mutationKind), objects.Ptr())
	runtime.KeepAlive(o)
}

func (o *CBUUID) InverseForRelationshipKey(relationshipKey *NSString) *NSString {
	ret := &NSString{}
	ret.ptr = unsafe.Pointer(C.CBUUID_inst_InverseForRelationshipKey(o.Ptr(), relationshipKey.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSString)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *NSString) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *CBUUID) Init() *CBUUID {
	ret := &CBUUID{}
	ret.ptr = unsafe.Pointer(C.CBUUID_inst_Init(o.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*CBUUID)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *CBUUID) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *CBUUID) MutableSetValueForKeyPath(keyPath *NSString) *NSMutableSet {
	ret := &NSMutableSet{}
	ret.ptr = unsafe.Pointer(C.CBUUID_inst_MutableSetValueForKeyPath(o.Ptr(), keyPath.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSMutableSet)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *NSMutableSet) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *CBUUID) ObjectSpecifier() *NSScriptObjectSpecifier {
	ret := &NSScriptObjectSpecifier{}
	ret.ptr = unsafe.Pointer(C.CBUUID_inst_ObjectSpecifier(o.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSScriptObjectSpecifier)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *NSScriptObjectSpecifier) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *CBUUID) CopyScriptingValueForKey(value NSObject, key *NSString, properties *NSDictionary) *Id {
	ret := &Id{}
	ret.ptr = unsafe.Pointer(C.CBUUID_inst_CopyScriptingValueForKey(o.Ptr(), value.Ptr(), key.Ptr(), properties.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *Id) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *CBUUID) CopyScriptingValueForKeyWithProperties(value NSObject, key *NSString, properties *NSDictionary) *Id {
	ret := &Id{}
	ret.ptr = unsafe.Pointer(C.CBUUID_inst_CopyScriptingValueForKeyWithProperties(o.Ptr(), value.Ptr(), key.Ptr(), properties.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *Id) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *CBUUID) CoerceValueForKey(value NSObject, key *NSString) *Id {
	ret := &Id{}
	ret.ptr = unsafe.Pointer(C.CBUUID_inst_CoerceValueForKey(o.Ptr(), value.Ptr(), key.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *Id) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *CBUUID) IsGreaterThan(object NSObject) bool {
	ret := (bool)(C.CBUUID_inst_IsGreaterThan(o.Ptr(), object.Ptr()))
	runtime.KeepAlive(o)
	return ret
}

func (o *CBUUID) ClassName() *NSString {
	ret := &NSString{}
	ret.ptr = unsafe.Pointer(C.CBUUID_inst_ClassName(o.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSString)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *NSString) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *CBUUID) RemoveValueAtIndexFromPropertyWithKey(index NSUInteger, key *NSString)  {
	C.CBUUID_inst_RemoveValueAtIndexFromPropertyWithKey(o.Ptr(), (C.NSUInteger)(index), key.Ptr())
	runtime.KeepAlive(o)
}

func (o *CBUUID) ScriptingIsLessThan(object NSObject) bool {
	ret := (bool)(C.CBUUID_inst_ScriptingIsLessThan(o.Ptr(), object.Ptr()))
	runtime.KeepAlive(o)
	return ret
}

func (o *CBUUID) Dealloc()  {
	C.CBUUID_inst_Dealloc(o.Ptr())
	runtime.KeepAlive(o)
}

func (o *CBUUID) RemoveObserverForKeyPath(observer NSObject, keyPath *NSString)  {
	C.CBUUID_inst_RemoveObserverForKeyPath(o.Ptr(), observer.Ptr(), keyPath.Ptr())
	runtime.KeepAlive(o)
}

func (o *CBUUID) RemoveObserverForKeyPathContext(observer NSObject, keyPath *NSString, context unsafe.Pointer)  {
	C.CBUUID_inst_RemoveObserverForKeyPathContext(o.Ptr(), observer.Ptr(), keyPath.Ptr(), unsafe.Pointer(context))
	runtime.KeepAlive(o)
}

func (o *CBUUID) AddObserverForKeyPath(observer NSObject, keyPath *NSString, options NSKeyValueObservingOptions, context unsafe.Pointer)  {
	C.CBUUID_inst_AddObserverForKeyPath(o.Ptr(), observer.Ptr(), keyPath.Ptr(), (C.NSKeyValueObservingOptions)(options), unsafe.Pointer(context))
	runtime.KeepAlive(o)
}

func (o *CBUUID) AddObserverForKeyPathOptions(observer NSObject, keyPath *NSString, options NSKeyValueObservingOptions, context unsafe.Pointer)  {
	C.CBUUID_inst_AddObserverForKeyPathOptions(o.Ptr(), observer.Ptr(), keyPath.Ptr(), (C.NSKeyValueObservingOptions)(options), unsafe.Pointer(context))
	runtime.KeepAlive(o)
}

func (o *CBUUID) PerformSelectorWithObject(aSelector SEL, anArgument NSObject, delay NSTimeInterval)  {
	C.CBUUID_inst_PerformSelectorWithObject(o.Ptr(), unsafe.Pointer(aSelector), anArgument.Ptr(), (C.NSTimeInterval)(delay))
	runtime.KeepAlive(o)
}

func (o *CBUUID) PerformSelectorWithObjectAfterDelay(aSelector SEL, anArgument NSObject, delay NSTimeInterval)  {
	C.CBUUID_inst_PerformSelectorWithObjectAfterDelay(o.Ptr(), unsafe.Pointer(aSelector), anArgument.Ptr(), (C.NSTimeInterval)(delay))
	runtime.KeepAlive(o)
}

func (o *CBUUID) PerformSelectorWithObjectAfterDelayInModes(aSelector SEL, anArgument NSObject, delay NSTimeInterval, modes *NSArray)  {
	C.CBUUID_inst_PerformSelectorWithObjectAfterDelayInModes(o.Ptr(), unsafe.Pointer(aSelector), anArgument.Ptr(), (C.NSTimeInterval)(delay), modes.Ptr())
	runtime.KeepAlive(o)
}

func (o *CBUUID) PerformSelectorOnThread(aSelector SEL, thr *NSThread, arg NSObject, wait BOOL)  {
	C.CBUUID_inst_PerformSelectorOnThread(o.Ptr(), unsafe.Pointer(aSelector), thr.Ptr(), arg.Ptr(), (C.BOOL)(wait))
	runtime.KeepAlive(o)
}

func (o *CBUUID) PerformSelectorOnThreadWithObject(aSelector SEL, thr *NSThread, arg NSObject, wait BOOL)  {
	C.CBUUID_inst_PerformSelectorOnThreadWithObject(o.Ptr(), unsafe.Pointer(aSelector), thr.Ptr(), arg.Ptr(), (C.BOOL)(wait))
	runtime.KeepAlive(o)
}

func (o *CBUUID) PerformSelectorOnThreadWithObjectWaitUntilDone(aSelector SEL, thr *NSThread, arg NSObject, wait BOOL, array *NSArray)  {
	C.CBUUID_inst_PerformSelectorOnThreadWithObjectWaitUntilDone(o.Ptr(), unsafe.Pointer(aSelector), thr.Ptr(), arg.Ptr(), (C.BOOL)(wait), array.Ptr())
	runtime.KeepAlive(o)
}

func (o *CBUUID) PerformSelectorOnThreadWithObjectWaitUntilDoneModes(aSelector SEL, thr *NSThread, arg NSObject, wait BOOL, array *NSArray)  {
	C.CBUUID_inst_PerformSelectorOnThreadWithObjectWaitUntilDoneModes(o.Ptr(), unsafe.Pointer(aSelector), thr.Ptr(), arg.Ptr(), (C.BOOL)(wait), array.Ptr())
	runtime.KeepAlive(o)
}

func (o *CBUUID) ScriptingIsLessThanOrEqualTo(object NSObject) bool {
	ret := (bool)(C.CBUUID_inst_ScriptingIsLessThanOrEqualTo(o.Ptr(), object.Ptr()))
	runtime.KeepAlive(o)
	return ret
}

func (o *CBUUID) ClassForCoder() Class {
	ret := (Class)(unsafe.Pointer(C.CBUUID_inst_ClassForCoder(o.Ptr())))
	runtime.KeepAlive(o)
	return ret
}

func (o *CBUUID) MutableArrayValueForKey(key *NSString) *NSMutableArray {
	ret := &NSMutableArray{}
	ret.ptr = unsafe.Pointer(C.CBUUID_inst_MutableArrayValueForKey(o.Ptr(), key.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSMutableArray)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *NSMutableArray) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *CBUUID) ObserveValueForKeyPathOfObject(keyPath *NSString, object NSObject, change *NSDictionary, context unsafe.Pointer)  {
	C.CBUUID_inst_ObserveValueForKeyPathOfObject(o.Ptr(), keyPath.Ptr(), object.Ptr(), change.Ptr(), unsafe.Pointer(context))
	runtime.KeepAlive(o)
}

func (o *CBUUID) ObserveValueForKeyPathOfObjectChange(keyPath *NSString, object NSObject, change *NSDictionary, context unsafe.Pointer)  {
	C.CBUUID_inst_ObserveValueForKeyPathOfObjectChange(o.Ptr(), keyPath.Ptr(), object.Ptr(), change.Ptr(), unsafe.Pointer(context))
	runtime.KeepAlive(o)
}

func (o *CBUUID) MutableSetValueForKey(key *NSString) *NSMutableSet {
	ret := &NSMutableSet{}
	ret.ptr = unsafe.Pointer(C.CBUUID_inst_MutableSetValueForKey(o.Ptr(), key.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSMutableSet)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *NSMutableSet) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *CBUUID) AttributeKeys() *NSArray {
	ret := &NSArray{}
	ret.ptr = unsafe.Pointer(C.CBUUID_inst_AttributeKeys(o.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSArray)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *NSArray) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *CBUUID) CopyWithZone(zone *NSZone) *Id {
	ret := &Id{}
	ret.ptr = unsafe.Pointer(C.CBUUID_inst_CopyWithZone(o.Ptr(), unsafe.Pointer(zone)))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *Id) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *CBUUID) ScriptingValueForSpecifier(objectSpecifier *NSScriptObjectSpecifier) *Id {
	ret := &Id{}
	ret.ptr = unsafe.Pointer(C.CBUUID_inst_ScriptingValueForSpecifier(o.Ptr(), objectSpecifier.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *Id) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *CBUUID) InsertValueInPropertyWithKey(value NSObject, key *NSString)  {
	C.CBUUID_inst_InsertValueInPropertyWithKey(o.Ptr(), value.Ptr(), key.Ptr())
	runtime.KeepAlive(o)
}

func (o *CBUUID) InsertValueAtIndex(value NSObject, index NSUInteger, key *NSString)  {
	C.CBUUID_inst_InsertValueAtIndex(o.Ptr(), value.Ptr(), (C.NSUInteger)(index), key.Ptr())
	runtime.KeepAlive(o)
}

func (o *CBUUID) InsertValueAtIndexInPropertyWithKey(value NSObject, index NSUInteger, key *NSString)  {
	C.CBUUID_inst_InsertValueAtIndexInPropertyWithKey(o.Ptr(), value.Ptr(), (C.NSUInteger)(index), key.Ptr())
	runtime.KeepAlive(o)
}

func (o *CBUUID) ValueForUndefinedKey(key *NSString) *Id {
	ret := &Id{}
	ret.ptr = unsafe.Pointer(C.CBUUID_inst_ValueForUndefinedKey(o.Ptr(), key.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *Id) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *CBUUID) PerformSelectorInBackgroundWithObject(aSelector SEL, arg NSObject)  {
	C.CBUUID_inst_PerformSelectorInBackgroundWithObject(o.Ptr(), unsafe.Pointer(aSelector), arg.Ptr())
	runtime.KeepAlive(o)
}

func (o *CBUUID) ScriptingProperties() *NSDictionary {
	ret := &NSDictionary{}
	ret.ptr = unsafe.Pointer(C.CBUUID_inst_ScriptingProperties(o.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSDictionary)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *NSDictionary) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *CBUUID) ScriptingIsGreaterThan(object NSObject) bool {
	ret := (bool)(C.CBUUID_inst_ScriptingIsGreaterThan(o.Ptr(), object.Ptr()))
	runtime.KeepAlive(o)
	return ret
}

func (o *CBUUID) MutableOrderedSetValueForKeyPath(keyPath *NSString) *NSMutableOrderedSet {
	ret := &NSMutableOrderedSet{}
	ret.ptr = unsafe.Pointer(C.CBUUID_inst_MutableOrderedSetValueForKeyPath(o.Ptr(), keyPath.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSMutableOrderedSet)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *NSMutableOrderedSet) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *CBUUID) IsNotEqualTo(object NSObject) bool {
	ret := (bool)(C.CBUUID_inst_IsNotEqualTo(o.Ptr(), object.Ptr()))
	runtime.KeepAlive(o)
	return ret
}

func (o *CBUUID) AttemptRecoveryFromErrorOptionIndex(error *NSError, recoveryOptionIndex NSUInteger) bool {
	ret := (bool)(C.CBUUID_inst_AttemptRecoveryFromErrorOptionIndex(o.Ptr(), error.Ptr(), (C.NSUInteger)(recoveryOptionIndex)))
	runtime.KeepAlive(o)
	return ret
}

func (o *CBUUID) AttemptRecoveryFromErrorOptionIndexDelegate(error *NSError, recoveryOptionIndex NSUInteger, delegate NSObject, didRecoverSelector SEL, contextInfo unsafe.Pointer)  {
	C.CBUUID_inst_AttemptRecoveryFromErrorOptionIndexDelegate(o.Ptr(), error.Ptr(), (C.NSUInteger)(recoveryOptionIndex), delegate.Ptr(), unsafe.Pointer(didRecoverSelector), unsafe.Pointer(contextInfo))
	runtime.KeepAlive(o)
}

func (o *CBUUID) AttemptRecoveryFromErrorOptionIndexDelegateDidRecoverSelector(error *NSError, recoveryOptionIndex NSUInteger, delegate NSObject, didRecoverSelector SEL, contextInfo unsafe.Pointer)  {
	C.CBUUID_inst_AttemptRecoveryFromErrorOptionIndexDelegateDidRecoverSelector(o.Ptr(), error.Ptr(), (C.NSUInteger)(recoveryOptionIndex), delegate.Ptr(), unsafe.Pointer(didRecoverSelector), unsafe.Pointer(contextInfo))
	runtime.KeepAlive(o)
}

func (o *CBUUID) MethodSignatureForSelector(aSelector SEL) *NSMethodSignature {
	ret := &NSMethodSignature{}
	ret.ptr = unsafe.Pointer(C.CBUUID_inst_MethodSignatureForSelector(o.Ptr(), unsafe.Pointer(aSelector)))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSMethodSignature)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *NSMethodSignature) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *CBUUID) IndicesOfObjectsByEvaluatingObjectSpecifier(specifier *NSScriptObjectSpecifier) *NSArray {
	ret := &NSArray{}
	ret.ptr = unsafe.Pointer(C.CBUUID_inst_IndicesOfObjectsByEvaluatingObjectSpecifier(o.Ptr(), specifier.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSArray)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *NSArray) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *CBUUID) SetValueForKey(value NSObject, key *NSString)  {
	C.CBUUID_inst_SetValueForKey(o.Ptr(), value.Ptr(), key.Ptr())
	runtime.KeepAlive(o)
}

func (o *CBUUID) SetValueForKeyPath(value NSObject, keyPath *NSString)  {
	C.CBUUID_inst_SetValueForKeyPath(o.Ptr(), value.Ptr(), keyPath.Ptr())
	runtime.KeepAlive(o)
}

func (o *CBUUID) SetValueForUndefinedKey(value NSObject, key *NSString)  {
	C.CBUUID_inst_SetValueForUndefinedKey(o.Ptr(), value.Ptr(), key.Ptr())
	runtime.KeepAlive(o)
}

func (o *CBUUID) ValueWithNameInPropertyWithKey(name *NSString, key *NSString) *Id {
	ret := &Id{}
	ret.ptr = unsafe.Pointer(C.CBUUID_inst_ValueWithNameInPropertyWithKey(o.Ptr(), name.Ptr(), key.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *Id) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *CBUUID) Data() *NSData {
	ret := &NSData{}
	ret.ptr = unsafe.Pointer(C.CBUUID_inst_Data(o.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSData)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *NSData) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *CBUUID) UUIDString() *NSString {
	ret := &NSString{}
	ret.ptr = unsafe.Pointer(C.CBUUID_inst_UUIDString(o.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSString)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *NSString) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *CBUUID) ScriptingIsGreaterThanOrEqualTo(object NSObject) bool {
	ret := (bool)(C.CBUUID_inst_ScriptingIsGreaterThanOrEqualTo(o.Ptr(), object.Ptr()))
	runtime.KeepAlive(o)
	return ret
}

func (o *CBUUID) DoesNotRecognizeSelector(aSelector SEL)  {
	C.CBUUID_inst_DoesNotRecognizeSelector(o.Ptr(), unsafe.Pointer(aSelector))
	runtime.KeepAlive(o)
}

func (o *CBUUID) SetObservationInfo(observationInfo unsafe.Pointer)  {
	C.CBUUID_inst_SetObservationInfo(o.Ptr(), unsafe.Pointer(observationInfo))
	runtime.KeepAlive(o)
}

func (o *CBUUID) ValueForKeyPath(keyPath *NSString) *Id {
	ret := &Id{}
	ret.ptr = unsafe.Pointer(C.CBUUID_inst_ValueForKeyPath(o.Ptr(), keyPath.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *Id) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *CBUUID) Copy() *Id {
	ret := &Id{}
	ret.ptr = unsafe.Pointer(C.CBUUID_inst_Copy(o.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	runtime.SetFinalizer(ret, func(o *Id) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *CBUUID) ForwardingTargetForSelector(aSelector SEL) *Id {
	ret := &Id{}
	ret.ptr = unsafe.Pointer(C.CBUUID_inst_ForwardingTargetForSelector(o.Ptr(), unsafe.Pointer(aSelector)))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *Id) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *CBUUID) ObservationInfo() unsafe.Pointer {
	ret := (unsafe.Pointer)(unsafe.Pointer(C.CBUUID_inst_ObservationInfo(o.Ptr())))
	runtime.KeepAlive(o)
	return ret
}

func (o *CBUUID) ScriptingContains(object NSObject) bool {
	ret := (bool)(C.CBUUID_inst_ScriptingContains(o.Ptr(), object.Ptr()))
	runtime.KeepAlive(o)
	return ret
}

func NSNumberWithUnsignedShort(value UnsignedShort) *NSNumber {
	ret := &NSNumber{}
	ret.ptr = unsafe.Pointer(C.NSNumber_NumberWithUnsignedShort((C.ushort)(value)))
	if ret.ptr == nil { return ret }
	runtime.SetFinalizer(ret, func(o *NSNumber) {
		o.Release()
	})
	return ret
}

func NSNumberNew() *NSNumber {
	ret := &NSNumber{}
	ret.ptr = unsafe.Pointer(C.NSNumber_New())
	if ret.ptr == nil { return ret }
	runtime.SetFinalizer(ret, func(o *NSNumber) {
		o.Release()
	})
	return ret
}

func NSNumberValueWithObjCType(value unsafe.Pointer, type_ *Char) *NSValue {
	ret := &NSValue{}
	ret.ptr = unsafe.Pointer(C.NSNumber_ValueWithObjCType(unsafe.Pointer(value), unsafe.Pointer(type_)))
	if ret.ptr == nil { return ret }
	return ret
}

func NSNumberDebugDescription() *NSString {
	ret := &NSString{}
	ret.ptr = unsafe.Pointer(C.NSNumber_DebugDescription())
	if ret.ptr == nil { return ret }
	return ret
}

func NSNumberVersion() NSInteger {
	ret := (NSInteger)(C.NSNumber_Version())
	return ret
}

func NSNumberKeyPathsForValuesAffectingValueForKey(key *NSString) *NSSet {
	ret := &NSSet{}
	ret.ptr = unsafe.Pointer(C.NSNumber_KeyPathsForValuesAffectingValueForKey(key.Ptr()))
	if ret.ptr == nil { return ret }
	return ret
}

func NSNumberWithInteger(value NSInteger) *NSNumber {
	ret := &NSNumber{}
	ret.ptr = unsafe.Pointer(C.NSNumber_NumberWithInteger((C.NSInteger)(value)))
	if ret.ptr == nil { return ret }
	runtime.SetFinalizer(ret, func(o *NSNumber) {
		o.Release()
	})
	return ret
}

func NSNumberWithDouble(value Double) *NSNumber {
	ret := &NSNumber{}
	ret.ptr = unsafe.Pointer(C.NSNumber_NumberWithDouble((C.double)(value)))
	if ret.ptr == nil { return ret }
	runtime.SetFinalizer(ret, func(o *NSNumber) {
		o.Release()
	})
	return ret
}

func NSNumberValueWithNonretainedObject(anObject NSObject) *NSValue {
	ret := &NSValue{}
	ret.ptr = unsafe.Pointer(C.NSNumber_ValueWithNonretainedObject(anObject.Ptr()))
	if ret.ptr == nil { return ret }
	return ret
}

func NSNumberValueWithSize(size NSSize) *NSValue {
	ret := &NSValue{}
	ret.ptr = unsafe.Pointer(C.NSNumber_ValueWithSize((C.NSSize)(size)))
	if ret.ptr == nil { return ret }
	return ret
}

func NSNumberClassForKeyedUnarchiver() Class {
	ret := (Class)(unsafe.Pointer(C.NSNumber_ClassForKeyedUnarchiver()))
	return ret
}

func NSNumberWithUnsignedChar(value UnsignedChar) *NSNumber {
	ret := &NSNumber{}
	ret.ptr = unsafe.Pointer(C.NSNumber_NumberWithUnsignedChar((C.uchar)(value)))
	if ret.ptr == nil { return ret }
	runtime.SetFinalizer(ret, func(o *NSNumber) {
		o.Release()
	})
	return ret
}

func NSNumberWithUnsignedLong(value UnsignedLong) *NSNumber {
	ret := &NSNumber{}
	ret.ptr = unsafe.Pointer(C.NSNumber_NumberWithUnsignedLong((C.ulong)(value)))
	if ret.ptr == nil { return ret }
	runtime.SetFinalizer(ret, func(o *NSNumber) {
		o.Release()
	})
	return ret
}

func NSNumberResolveClassMethod(sel SEL) bool {
	ret := (bool)(C.NSNumber_ResolveClassMethod(unsafe.Pointer(sel)))
	return ret
}

func NSNumberAutomaticallyNotifiesObserversForKey(key *NSString) bool {
	ret := (bool)(C.NSNumber_AutomaticallyNotifiesObserversForKey(key.Ptr()))
	return ret
}

func NSNumberCopyWithZone(zone *_NSZone) *Id {
	ret := &Id{}
	ret.ptr = unsafe.Pointer(C.NSNumber_CopyWithZone(unsafe.Pointer(zone)))
	if ret.ptr == nil { return ret }
	runtime.SetFinalizer(ret, func(o *Id) {
		o.Release()
	})
	return ret
}

func NSNumberDescription() *NSString {
	ret := &NSString{}
	ret.ptr = unsafe.Pointer(C.NSNumber_Description())
	if ret.ptr == nil { return ret }
	return ret
}

func NSNumberMutableCopyWithZone(zone *_NSZone) *Id {
	ret := &Id{}
	ret.ptr = unsafe.Pointer(C.NSNumber_MutableCopyWithZone(unsafe.Pointer(zone)))
	if ret.ptr == nil { return ret }
	runtime.SetFinalizer(ret, func(o *Id) {
		o.Release()
	})
	return ret
}

func NSNumberSuperclass() Class {
	ret := (Class)(unsafe.Pointer(C.NSNumber_Superclass()))
	return ret
}

func NSNumberWithUnsignedInteger(value NSUInteger) *NSNumber {
	ret := &NSNumber{}
	ret.ptr = unsafe.Pointer(C.NSNumber_NumberWithUnsignedInteger((C.NSUInteger)(value)))
	if ret.ptr == nil { return ret }
	runtime.SetFinalizer(ret, func(o *NSNumber) {
		o.Release()
	})
	return ret
}

func NSNumberWithChar(value Char) *NSNumber {
	ret := &NSNumber{}
	ret.ptr = unsafe.Pointer(C.NSNumber_NumberWithChar((C.char)(value)))
	if ret.ptr == nil { return ret }
	runtime.SetFinalizer(ret, func(o *NSNumber) {
		o.Release()
	})
	return ret
}

func NSNumberWithBool(value BOOL) *NSNumber {
	ret := &NSNumber{}
	ret.ptr = unsafe.Pointer(C.NSNumber_NumberWithBool((C.BOOL)(value)))
	if ret.ptr == nil { return ret }
	runtime.SetFinalizer(ret, func(o *NSNumber) {
		o.Release()
	})
	return ret
}

func NSNumberCancelPreviousPerformRequestsWithTarget(aTarget NSObject)  {
	C.NSNumber_CancelPreviousPerformRequestsWithTarget(aTarget.Ptr())
}

func NSNumberCancelPreviousPerformRequestsWithTargetSelector(aTarget NSObject, aSelector SEL, anArgument NSObject)  {
	C.NSNumber_CancelPreviousPerformRequestsWithTargetSelector(aTarget.Ptr(), unsafe.Pointer(aSelector), anArgument.Ptr())
}

func NSNumberCancelPreviousPerformRequestsWithTargetSelectorObject(aTarget NSObject, aSelector SEL, anArgument NSObject)  {
	C.NSNumber_CancelPreviousPerformRequestsWithTargetSelectorObject(aTarget.Ptr(), unsafe.Pointer(aSelector), anArgument.Ptr())
}

func NSNumberAccessInstanceVariablesDirectly() bool {
	ret := (bool)(C.NSNumber_AccessInstanceVariablesDirectly())
	return ret
}

func NSNumberClassFallbacksForKeyedArchiver() *NSArray {
	ret := &NSArray{}
	ret.ptr = unsafe.Pointer(C.NSNumber_ClassFallbacksForKeyedArchiver())
	if ret.ptr == nil { return ret }
	return ret
}

func NSNumberSetVersion(aVersion NSInteger)  {
	C.NSNumber_SetVersion((C.NSInteger)(aVersion))
}

func NSNumberInstanceMethodSignatureForSelector(aSelector SEL) *NSMethodSignature {
	ret := &NSMethodSignature{}
	ret.ptr = unsafe.Pointer(C.NSNumber_InstanceMethodSignatureForSelector(unsafe.Pointer(aSelector)))
	if ret.ptr == nil { return ret }
	return ret
}

func NSNumberWithLong(value Long) *NSNumber {
	ret := &NSNumber{}
	ret.ptr = unsafe.Pointer(C.NSNumber_NumberWithLong((C.long)(value)))
	if ret.ptr == nil { return ret }
	runtime.SetFinalizer(ret, func(o *NSNumber) {
		o.Release()
	})
	return ret
}

func NSNumberWithLongLong(value LongLong) *NSNumber {
	ret := &NSNumber{}
	ret.ptr = unsafe.Pointer(C.NSNumber_NumberWithLongLong((C.longlong)(value)))
	if ret.ptr == nil { return ret }
	runtime.SetFinalizer(ret, func(o *NSNumber) {
		o.Release()
	})
	return ret
}

func NSNumberWithFloat(value Float) *NSNumber {
	ret := &NSNumber{}
	ret.ptr = unsafe.Pointer(C.NSNumber_NumberWithFloat((C.float)(value)))
	if ret.ptr == nil { return ret }
	runtime.SetFinalizer(ret, func(o *NSNumber) {
		o.Release()
	})
	return ret
}

func NSNumberValueWithRange(range_ NSRange) *NSValue {
	ret := &NSValue{}
	ret.ptr = unsafe.Pointer(C.NSNumber_ValueWithRange((C.NSRange)(range_)))
	if ret.ptr == nil { return ret }
	return ret
}

func NSNumberHash() NSUInteger {
	ret := (NSUInteger)(C.NSNumber_Hash())
	return ret
}

func NSNumberClass() Class {
	ret := (Class)(unsafe.Pointer(C.NSNumber_Class()))
	return ret
}

func NSNumberWithUnsignedLongLong(value UnsignedLongLong) *NSNumber {
	ret := &NSNumber{}
	ret.ptr = unsafe.Pointer(C.NSNumber_NumberWithUnsignedLongLong((C.ulonglong)(value)))
	if ret.ptr == nil { return ret }
	runtime.SetFinalizer(ret, func(o *NSNumber) {
		o.Release()
	})
	return ret
}

func NSNumberValueWithEdgeInsets(insets NSEdgeInsets) *NSValue {
	ret := &NSValue{}
	ret.ptr = unsafe.Pointer(C.NSNumber_ValueWithEdgeInsets((C.NSEdgeInsets)(insets)))
	if ret.ptr == nil { return ret }
	return ret
}

func NSNumberValueWithPoint(point NSPoint) *NSValue {
	ret := &NSValue{}
	ret.ptr = unsafe.Pointer(C.NSNumber_ValueWithPoint((C.NSPoint)(point)))
	if ret.ptr == nil { return ret }
	return ret
}

func NSNumberAlloc() *NSNumber {
	ret := &NSNumber{}
	ret.ptr = unsafe.Pointer(C.NSNumber_Alloc())
	if ret.ptr == nil { return ret }
	runtime.SetFinalizer(ret, func(o *NSNumber) {
		o.Release()
	})
	return ret
}

func (o *NSNumber) GC() {
	if o.ptr == nil { return }
	runtime.SetFinalizer(o, func(o *NSNumber) {
		o.Release()
	})
	runtime.KeepAlive(o)
}

func NSNumberAllocWithZone(zone *_NSZone) *NSNumber {
	ret := &NSNumber{}
	ret.ptr = unsafe.Pointer(C.NSNumber_AllocWithZone(unsafe.Pointer(zone)))
	if ret.ptr == nil { return ret }
	runtime.SetFinalizer(ret, func(o *NSNumber) {
		o.Release()
	})
	return ret
}

func NSNumberInstancesRespondToSelector(aSelector SEL) bool {
	ret := (bool)(C.NSNumber_InstancesRespondToSelector(unsafe.Pointer(aSelector)))
	return ret
}

func NSNumberConformsToProtocol(protocol Protocol) bool {
	ret := (bool)(C.NSNumber_ConformsToProtocol(protocol.Ptr()))
	return ret
}

func NSNumberLoad()  {
	C.NSNumber_Load()
}

func NSNumberWithUnsignedInt(value UnsignedInt) *NSNumber {
	ret := &NSNumber{}
	ret.ptr = unsafe.Pointer(C.NSNumber_NumberWithUnsignedInt((C.uint)(value)))
	if ret.ptr == nil { return ret }
	runtime.SetFinalizer(ret, func(o *NSNumber) {
		o.Release()
	})
	return ret
}

func NSNumberWithShort(value Short) *NSNumber {
	ret := &NSNumber{}
	ret.ptr = unsafe.Pointer(C.NSNumber_NumberWithShort((C.short)(value)))
	if ret.ptr == nil { return ret }
	runtime.SetFinalizer(ret, func(o *NSNumber) {
		o.Release()
	})
	return ret
}

func NSNumberValueWithPointer(pointer unsafe.Pointer) *NSValue {
	ret := &NSValue{}
	ret.ptr = unsafe.Pointer(C.NSNumber_ValueWithPointer(unsafe.Pointer(pointer)))
	if ret.ptr == nil { return ret }
	return ret
}

func NSNumberResolveInstanceMethod(sel SEL) bool {
	ret := (bool)(C.NSNumber_ResolveInstanceMethod(unsafe.Pointer(sel)))
	return ret
}

func NSNumberWithInt(value Int) *NSNumber {
	ret := &NSNumber{}
	ret.ptr = unsafe.Pointer(C.NSNumber_NumberWithInt((C.int)(value)))
	if ret.ptr == nil { return ret }
	runtime.SetFinalizer(ret, func(o *NSNumber) {
		o.Release()
	})
	return ret
}

func NSNumberValueWithRect(rect NSRect) *NSValue {
	ret := &NSValue{}
	ret.ptr = unsafe.Pointer(C.NSNumber_ValueWithRect((C.NSRect)(rect)))
	if ret.ptr == nil { return ret }
	return ret
}

func NSNumberValueWithBytesObjCType(value unsafe.Pointer, type_ *Char) *NSValue {
	ret := &NSValue{}
	ret.ptr = unsafe.Pointer(C.NSNumber_ValueWithBytesObjCType(unsafe.Pointer(value), unsafe.Pointer(type_)))
	if ret.ptr == nil { return ret }
	return ret
}

func NSNumberIsSubclassOfClass(aClass Class) bool {
	ret := (bool)(C.NSNumber_IsSubclassOfClass(unsafe.Pointer(aClass)))
	return ret
}

func (o *NSNumber) MutableOrderedSetValueForKey(key *NSString) *NSMutableOrderedSet {
	ret := &NSMutableOrderedSet{}
	ret.ptr = unsafe.Pointer(C.NSNumber_inst_MutableOrderedSetValueForKey(o.Ptr(), key.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSMutableOrderedSet)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *NSMutableOrderedSet) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *NSNumber) CopyScriptingValueForKey(value NSObject, key *NSString, properties *NSDictionary) *Id {
	ret := &Id{}
	ret.ptr = unsafe.Pointer(C.NSNumber_inst_CopyScriptingValueForKey(o.Ptr(), value.Ptr(), key.Ptr(), properties.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *Id) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *NSNumber) CopyScriptingValueForKeyWithProperties(value NSObject, key *NSString, properties *NSDictionary) *Id {
	ret := &Id{}
	ret.ptr = unsafe.Pointer(C.NSNumber_inst_CopyScriptingValueForKeyWithProperties(o.Ptr(), value.Ptr(), key.Ptr(), properties.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *Id) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *NSNumber) SetNilValueForKey(key *NSString)  {
	C.NSNumber_inst_SetNilValueForKey(o.Ptr(), key.Ptr())
	runtime.KeepAlive(o)
}

func (o *NSNumber) SetValuesForKeysWithDictionary(keyedValues *NSDictionary)  {
	C.NSNumber_inst_SetValuesForKeysWithDictionary(o.Ptr(), keyedValues.Ptr())
	runtime.KeepAlive(o)
}

func (o *NSNumber) DoubleValue() Double {
	ret := (Double)(C.NSNumber_inst_DoubleValue(o.Ptr()))
	runtime.KeepAlive(o)
	return ret
}

func (o *NSNumber) InitWithBool(value BOOL) *NSNumber {
	ret := &NSNumber{}
	ret.ptr = unsafe.Pointer(C.NSNumber_inst_InitWithBool(o.Ptr(), (C.BOOL)(value)))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSNumber)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *NSNumber) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *NSNumber) InitWithShort(value Short) *NSNumber {
	ret := &NSNumber{}
	ret.ptr = unsafe.Pointer(C.NSNumber_inst_InitWithShort(o.Ptr(), (C.short)(value)))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSNumber)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *NSNumber) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *NSNumber) InitWithLong(value Long) *NSNumber {
	ret := &NSNumber{}
	ret.ptr = unsafe.Pointer(C.NSNumber_inst_InitWithLong(o.Ptr(), (C.long)(value)))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSNumber)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *NSNumber) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *NSNumber) ScriptingValueForSpecifier(objectSpecifier *NSScriptObjectSpecifier) *Id {
	ret := &Id{}
	ret.ptr = unsafe.Pointer(C.NSNumber_inst_ScriptingValueForSpecifier(o.Ptr(), objectSpecifier.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *Id) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *NSNumber) AutoContentAccessingProxy() *Id {
	ret := &Id{}
	ret.ptr = unsafe.Pointer(C.NSNumber_inst_AutoContentAccessingProxy(o.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *Id) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *NSNumber) ForwardInvocation(anInvocation *NSInvocation)  {
	C.NSNumber_inst_ForwardInvocation(o.Ptr(), anInvocation.Ptr())
	runtime.KeepAlive(o)
}

func (o *NSNumber) UnsignedShortValue() UnsignedShort {
	ret := (UnsignedShort)(C.NSNumber_inst_UnsignedShortValue(o.Ptr()))
	runtime.KeepAlive(o)
	return ret
}

func (o *NSNumber) InitWithDouble(value Double) *NSNumber {
	ret := &NSNumber{}
	ret.ptr = unsafe.Pointer(C.NSNumber_inst_InitWithDouble(o.Ptr(), (C.double)(value)))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSNumber)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *NSNumber) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *NSNumber) ClassDescription() *NSClassDescription {
	ret := &NSClassDescription{}
	ret.ptr = unsafe.Pointer(C.NSNumber_inst_ClassDescription(o.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSClassDescription)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *NSClassDescription) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *NSNumber) MutableSetValueForKeyPath(keyPath *NSString) *NSMutableSet {
	ret := &NSMutableSet{}
	ret.ptr = unsafe.Pointer(C.NSNumber_inst_MutableSetValueForKeyPath(o.Ptr(), keyPath.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSMutableSet)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *NSMutableSet) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *NSNumber) IsGreaterThan(object NSObject) bool {
	ret := (bool)(C.NSNumber_inst_IsGreaterThan(o.Ptr(), object.Ptr()))
	runtime.KeepAlive(o)
	return ret
}

func (o *NSNumber) ScriptingBeginsWith(object NSObject) bool {
	ret := (bool)(C.NSNumber_inst_ScriptingBeginsWith(o.Ptr(), object.Ptr()))
	runtime.KeepAlive(o)
	return ret
}

func (o *NSNumber) IsEqualToValue(value *NSValue) bool {
	ret := (bool)(C.NSNumber_inst_IsEqualToValue(o.Ptr(), value.Ptr()))
	runtime.KeepAlive(o)
	return ret
}

func (o *NSNumber) DictionaryWithValuesForKeys(keys *NSArray) *NSDictionary {
	ret := &NSDictionary{}
	ret.ptr = unsafe.Pointer(C.NSNumber_inst_DictionaryWithValuesForKeys(o.Ptr(), keys.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSDictionary)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *NSDictionary) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *NSNumber) DidChangeValuesAtIndexes(changeKind NSKeyValueChange, indexes *NSIndexSet, key *NSString)  {
	C.NSNumber_inst_DidChangeValuesAtIndexes(o.Ptr(), (C.NSKeyValueChange)(changeKind), indexes.Ptr(), key.Ptr())
	runtime.KeepAlive(o)
}

func (o *NSNumber) DidChangeValuesAtIndexesForKey(changeKind NSKeyValueChange, indexes *NSIndexSet, key *NSString)  {
	C.NSNumber_inst_DidChangeValuesAtIndexesForKey(o.Ptr(), (C.NSKeyValueChange)(changeKind), indexes.Ptr(), key.Ptr())
	runtime.KeepAlive(o)
}

func (o *NSNumber) IsGreaterThanOrEqualTo(object NSObject) bool {
	ret := (bool)(C.NSNumber_inst_IsGreaterThanOrEqualTo(o.Ptr(), object.Ptr()))
	runtime.KeepAlive(o)
	return ret
}

func (o *NSNumber) IsLessThan(object NSObject) bool {
	ret := (bool)(C.NSNumber_inst_IsLessThan(o.Ptr(), object.Ptr()))
	runtime.KeepAlive(o)
	return ret
}

func (o *NSNumber) AttributeKeys() *NSArray {
	ret := &NSArray{}
	ret.ptr = unsafe.Pointer(C.NSNumber_inst_AttributeKeys(o.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSArray)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *NSArray) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *NSNumber) SizeValue() NSSize {
	ret := (NSSize)(C.NSNumber_inst_SizeValue(o.Ptr()))
	runtime.KeepAlive(o)
	return ret
}

func (o *NSNumber) AwakeAfterUsingCoder(coder *NSCoder) *Id {
	ret := &Id{}
	ret.ptr = unsafe.Pointer(C.NSNumber_inst_AwakeAfterUsingCoder(o.Ptr(), coder.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *Id) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *NSNumber) Init() *NSNumber {
	ret := &NSNumber{}
	ret.ptr = unsafe.Pointer(C.NSNumber_inst_Init(o.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSNumber)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *NSNumber) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *NSNumber) NewScriptingObjectOfClassForValueForKey(objectClass Class, key *NSString, contentsValue NSObject, properties *NSDictionary) *Id {
	ret := &Id{}
	ret.ptr = unsafe.Pointer(C.NSNumber_inst_NewScriptingObjectOfClassForValueForKey(o.Ptr(), unsafe.Pointer(objectClass), key.Ptr(), contentsValue.Ptr(), properties.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *Id) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *NSNumber) NewScriptingObjectOfClassForValueForKeyWithContentsValue(objectClass Class, key *NSString, contentsValue NSObject, properties *NSDictionary) *Id {
	ret := &Id{}
	ret.ptr = unsafe.Pointer(C.NSNumber_inst_NewScriptingObjectOfClassForValueForKeyWithContentsValue(o.Ptr(), unsafe.Pointer(objectClass), key.Ptr(), contentsValue.Ptr(), properties.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *Id) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *NSNumber) UnsignedIntValue() UnsignedInt {
	ret := (UnsignedInt)(C.NSNumber_inst_UnsignedIntValue(o.Ptr()))
	runtime.KeepAlive(o)
	return ret
}

func (o *NSNumber) IsCaseInsensitiveLike(object *NSString) bool {
	ret := (bool)(C.NSNumber_inst_IsCaseInsensitiveLike(o.Ptr(), object.Ptr()))
	runtime.KeepAlive(o)
	return ret
}

func (o *NSNumber) ValidateValueForKey(ioValue *[]*Id, inKey *NSString, outError *[]*NSError) bool {

	goSlice1 := make([]unsafe.Pointer,cap(*ioValue))
	for i := 0; i < len(*ioValue); i++ {
		goSlice1[i] = (*ioValue)[i].Ptr()
	}

	goSlice3 := make([]unsafe.Pointer,cap(*outError))
	for i := 0; i < len(*outError); i++ {
		goSlice3[i] = (*outError)[i].Ptr()
	}
	ret := (bool)(C.NSNumber_inst_ValidateValueForKey(o.Ptr(), (*unsafe.Pointer)(unsafe.Pointer(&goSlice1[0])), inKey.Ptr(), (*unsafe.Pointer)(unsafe.Pointer(&goSlice3[0]))))
	(*ioValue) = (*ioValue)[:cap(*ioValue)]
	for i := 0; i < len(*ioValue); i++ {
		if goSlice1[i] == nil {
			(*ioValue) = (*ioValue)[:i]
			break
		}
		if (*ioValue)[i] == nil {
			(*ioValue)[i] = &Id{}
			runtime.SetFinalizer((*ioValue)[i], func(o *Id) {
				o.Release()
			})
		}
		(*ioValue)[i].ptr = goSlice1[i]
	}
	(*outError) = (*outError)[:cap(*outError)]
	for i := 0; i < len(*outError); i++ {
		if goSlice3[i] == nil {
			(*outError) = (*outError)[:i]
			break
		}
		if (*outError)[i] == nil {
			(*outError)[i] = &NSError{}
			runtime.SetFinalizer((*outError)[i], func(o *NSError) {
				o.Release()
			})
		}
		(*outError)[i].ptr = goSlice3[i]
	}
	runtime.KeepAlive(o)
	return ret
}

func (o *NSNumber) ValidateValueForKeyPath(ioValue *[]*Id, inKeyPath *NSString, outError *[]*NSError) bool {

	goSlice1 := make([]unsafe.Pointer,cap(*ioValue))
	for i := 0; i < len(*ioValue); i++ {
		goSlice1[i] = (*ioValue)[i].Ptr()
	}

	goSlice3 := make([]unsafe.Pointer,cap(*outError))
	for i := 0; i < len(*outError); i++ {
		goSlice3[i] = (*outError)[i].Ptr()
	}
	ret := (bool)(C.NSNumber_inst_ValidateValueForKeyPath(o.Ptr(), (*unsafe.Pointer)(unsafe.Pointer(&goSlice1[0])), inKeyPath.Ptr(), (*unsafe.Pointer)(unsafe.Pointer(&goSlice3[0]))))
	(*ioValue) = (*ioValue)[:cap(*ioValue)]
	for i := 0; i < len(*ioValue); i++ {
		if goSlice1[i] == nil {
			(*ioValue) = (*ioValue)[:i]
			break
		}
		if (*ioValue)[i] == nil {
			(*ioValue)[i] = &Id{}
			runtime.SetFinalizer((*ioValue)[i], func(o *Id) {
				o.Release()
			})
		}
		(*ioValue)[i].ptr = goSlice1[i]
	}
	(*outError) = (*outError)[:cap(*outError)]
	for i := 0; i < len(*outError); i++ {
		if goSlice3[i] == nil {
			(*outError) = (*outError)[:i]
			break
		}
		if (*outError)[i] == nil {
			(*outError)[i] = &NSError{}
			runtime.SetFinalizer((*outError)[i], func(o *NSError) {
				o.Release()
			})
		}
		(*outError)[i].ptr = goSlice3[i]
	}
	runtime.KeepAlive(o)
	return ret
}

func (o *NSNumber) ValidateValueForKeyError(ioValue *[]*Id, inKey *NSString, outError *[]*NSError) bool {

	goSlice1 := make([]unsafe.Pointer,cap(*ioValue))
	for i := 0; i < len(*ioValue); i++ {
		goSlice1[i] = (*ioValue)[i].Ptr()
	}

	goSlice3 := make([]unsafe.Pointer,cap(*outError))
	for i := 0; i < len(*outError); i++ {
		goSlice3[i] = (*outError)[i].Ptr()
	}
	ret := (bool)(C.NSNumber_inst_ValidateValueForKeyError(o.Ptr(), (*unsafe.Pointer)(unsafe.Pointer(&goSlice1[0])), inKey.Ptr(), (*unsafe.Pointer)(unsafe.Pointer(&goSlice3[0]))))
	(*ioValue) = (*ioValue)[:cap(*ioValue)]
	for i := 0; i < len(*ioValue); i++ {
		if goSlice1[i] == nil {
			(*ioValue) = (*ioValue)[:i]
			break
		}
		if (*ioValue)[i] == nil {
			(*ioValue)[i] = &Id{}
			runtime.SetFinalizer((*ioValue)[i], func(o *Id) {
				o.Release()
			})
		}
		(*ioValue)[i].ptr = goSlice1[i]
	}
	(*outError) = (*outError)[:cap(*outError)]
	for i := 0; i < len(*outError); i++ {
		if goSlice3[i] == nil {
			(*outError) = (*outError)[:i]
			break
		}
		if (*outError)[i] == nil {
			(*outError)[i] = &NSError{}
			runtime.SetFinalizer((*outError)[i], func(o *NSError) {
				o.Release()
			})
		}
		(*outError)[i].ptr = goSlice3[i]
	}
	runtime.KeepAlive(o)
	return ret
}

func (o *NSNumber) ValidateValueForKeyPathError(ioValue *[]*Id, inKeyPath *NSString, outError *[]*NSError) bool {

	goSlice1 := make([]unsafe.Pointer,cap(*ioValue))
	for i := 0; i < len(*ioValue); i++ {
		goSlice1[i] = (*ioValue)[i].Ptr()
	}

	goSlice3 := make([]unsafe.Pointer,cap(*outError))
	for i := 0; i < len(*outError); i++ {
		goSlice3[i] = (*outError)[i].Ptr()
	}
	ret := (bool)(C.NSNumber_inst_ValidateValueForKeyPathError(o.Ptr(), (*unsafe.Pointer)(unsafe.Pointer(&goSlice1[0])), inKeyPath.Ptr(), (*unsafe.Pointer)(unsafe.Pointer(&goSlice3[0]))))
	(*ioValue) = (*ioValue)[:cap(*ioValue)]
	for i := 0; i < len(*ioValue); i++ {
		if goSlice1[i] == nil {
			(*ioValue) = (*ioValue)[:i]
			break
		}
		if (*ioValue)[i] == nil {
			(*ioValue)[i] = &Id{}
			runtime.SetFinalizer((*ioValue)[i], func(o *Id) {
				o.Release()
			})
		}
		(*ioValue)[i].ptr = goSlice1[i]
	}
	(*outError) = (*outError)[:cap(*outError)]
	for i := 0; i < len(*outError); i++ {
		if goSlice3[i] == nil {
			(*outError) = (*outError)[:i]
			break
		}
		if (*outError)[i] == nil {
			(*outError)[i] = &NSError{}
			runtime.SetFinalizer((*outError)[i], func(o *NSError) {
				o.Release()
			})
		}
		(*outError)[i].ptr = goSlice3[i]
	}
	runtime.KeepAlive(o)
	return ret
}

func (o *NSNumber) IsLike(object *NSString) bool {
	ret := (bool)(C.NSNumber_inst_IsLike(o.Ptr(), object.Ptr()))
	runtime.KeepAlive(o)
	return ret
}

func (o *NSNumber) DescriptionWithLocale(locale NSObject) *NSString {
	ret := &NSString{}
	ret.ptr = unsafe.Pointer(C.NSNumber_inst_DescriptionWithLocale(o.Ptr(), locale.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSString)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *NSString) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *NSNumber) InitWithUnsignedLong(value UnsignedLong) *NSNumber {
	ret := &NSNumber{}
	ret.ptr = unsafe.Pointer(C.NSNumber_inst_InitWithUnsignedLong(o.Ptr(), (C.ulong)(value)))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSNumber)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *NSNumber) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *NSNumber) PointerValue() unsafe.Pointer {
	ret := (unsafe.Pointer)(unsafe.Pointer(C.NSNumber_inst_PointerValue(o.Ptr())))
	runtime.KeepAlive(o)
	return ret
}

func (o *NSNumber) ScriptingEndsWith(object NSObject) bool {
	ret := (bool)(C.NSNumber_inst_ScriptingEndsWith(o.Ptr(), object.Ptr()))
	runtime.KeepAlive(o)
	return ret
}

func (o *NSNumber) ValueForUndefinedKey(key *NSString) *Id {
	ret := &Id{}
	ret.ptr = unsafe.Pointer(C.NSNumber_inst_ValueForUndefinedKey(o.Ptr(), key.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *Id) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *NSNumber) InitWithBytesObjCType(value unsafe.Pointer, type_ *Char) *NSNumber {
	ret := &NSNumber{}
	ret.ptr = unsafe.Pointer(C.NSNumber_inst_InitWithBytesObjCType(o.Ptr(), unsafe.Pointer(value), unsafe.Pointer(type_)))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSNumber)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *NSNumber) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *NSNumber) Compare(otherNumber *NSNumber) NSComparisonResult {
	ret := (NSComparisonResult)(C.NSNumber_inst_Compare(o.Ptr(), otherNumber.Ptr()))
	runtime.KeepAlive(o)
	return ret
}

func (o *NSNumber) IndicesOfObjectsByEvaluatingObjectSpecifier(specifier *NSScriptObjectSpecifier) *NSArray {
	ret := &NSArray{}
	ret.ptr = unsafe.Pointer(C.NSNumber_inst_IndicesOfObjectsByEvaluatingObjectSpecifier(o.Ptr(), specifier.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSArray)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *NSArray) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *NSNumber) BoolValue() bool {
	ret := (bool)(C.NSNumber_inst_BoolValue(o.Ptr()))
	runtime.KeepAlive(o)
	return ret
}

func (o *NSNumber) ValueForKey(key *NSString) *Id {
	ret := &Id{}
	ret.ptr = unsafe.Pointer(C.NSNumber_inst_ValueForKey(o.Ptr(), key.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *Id) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *NSNumber) RemoveValueAtIndexFromPropertyWithKey(index NSUInteger, key *NSString)  {
	C.NSNumber_inst_RemoveValueAtIndexFromPropertyWithKey(o.Ptr(), (C.NSUInteger)(index), key.Ptr())
	runtime.KeepAlive(o)
}

func (o *NSNumber) MutableSetValueForKey(key *NSString) *NSMutableSet {
	ret := &NSMutableSet{}
	ret.ptr = unsafe.Pointer(C.NSNumber_inst_MutableSetValueForKey(o.Ptr(), key.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSMutableSet)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *NSMutableSet) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *NSNumber) MutableArrayValueForKey(key *NSString) *NSMutableArray {
	ret := &NSMutableArray{}
	ret.ptr = unsafe.Pointer(C.NSNumber_inst_MutableArrayValueForKey(o.Ptr(), key.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSMutableArray)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *NSMutableArray) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *NSNumber) ValueWithNameInPropertyWithKey(name *NSString, key *NSString) *Id {
	ret := &Id{}
	ret.ptr = unsafe.Pointer(C.NSNumber_inst_ValueWithNameInPropertyWithKey(o.Ptr(), name.Ptr(), key.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *Id) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *NSNumber) ValueForKeyPath(keyPath *NSString) *Id {
	ret := &Id{}
	ret.ptr = unsafe.Pointer(C.NSNumber_inst_ValueForKeyPath(o.Ptr(), keyPath.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *Id) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *NSNumber) InitWithFloat(value Float) *NSNumber {
	ret := &NSNumber{}
	ret.ptr = unsafe.Pointer(C.NSNumber_inst_InitWithFloat(o.Ptr(), (C.float)(value)))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSNumber)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *NSNumber) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *NSNumber) InitWithUnsignedShort(value UnsignedShort) *NSNumber {
	ret := &NSNumber{}
	ret.ptr = unsafe.Pointer(C.NSNumber_inst_InitWithUnsignedShort(o.Ptr(), (C.ushort)(value)))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSNumber)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *NSNumber) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *NSNumber) SetScriptingProperties(scriptingProperties *NSDictionary)  {
	C.NSNumber_inst_SetScriptingProperties(o.Ptr(), scriptingProperties.Ptr())
	runtime.KeepAlive(o)
}

func (o *NSNumber) MutableOrderedSetValueForKeyPath(keyPath *NSString) *NSMutableOrderedSet {
	ret := &NSMutableOrderedSet{}
	ret.ptr = unsafe.Pointer(C.NSNumber_inst_MutableOrderedSetValueForKeyPath(o.Ptr(), keyPath.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSMutableOrderedSet)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *NSMutableOrderedSet) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *NSNumber) ObjectSpecifier() *NSScriptObjectSpecifier {
	ret := &NSScriptObjectSpecifier{}
	ret.ptr = unsafe.Pointer(C.NSNumber_inst_ObjectSpecifier(o.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSScriptObjectSpecifier)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *NSScriptObjectSpecifier) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *NSNumber) ClassForKeyedArchiver() Class {
	ret := (Class)(unsafe.Pointer(C.NSNumber_inst_ClassForKeyedArchiver(o.Ptr())))
	runtime.KeepAlive(o)
	return ret
}

func (o *NSNumber) ScriptingContains(object NSObject) bool {
	ret := (bool)(C.NSNumber_inst_ScriptingContains(o.Ptr(), object.Ptr()))
	runtime.KeepAlive(o)
	return ret
}

func (o *NSNumber) PerformSelectorOnMainThreadWithObject(aSelector SEL, arg NSObject, wait BOOL)  {
	C.NSNumber_inst_PerformSelectorOnMainThreadWithObject(o.Ptr(), unsafe.Pointer(aSelector), arg.Ptr(), (C.BOOL)(wait))
	runtime.KeepAlive(o)
}

func (o *NSNumber) PerformSelectorOnMainThreadWithObjectWaitUntilDone(aSelector SEL, arg NSObject, wait BOOL)  {
	C.NSNumber_inst_PerformSelectorOnMainThreadWithObjectWaitUntilDone(o.Ptr(), unsafe.Pointer(aSelector), arg.Ptr(), (C.BOOL)(wait))
	runtime.KeepAlive(o)
}

func (o *NSNumber) PerformSelectorOnMainThreadWithObjectWaitUntilDoneModes(aSelector SEL, arg NSObject, wait BOOL, array *NSArray)  {
	C.NSNumber_inst_PerformSelectorOnMainThreadWithObjectWaitUntilDoneModes(o.Ptr(), unsafe.Pointer(aSelector), arg.Ptr(), (C.BOOL)(wait), array.Ptr())
	runtime.KeepAlive(o)
}

func (o *NSNumber) IntValue() Int {
	ret := (Int)(C.NSNumber_inst_IntValue(o.Ptr()))
	runtime.KeepAlive(o)
	return ret
}

func (o *NSNumber) MethodSignatureForSelector(aSelector SEL) *NSMethodSignature {
	ret := &NSMethodSignature{}
	ret.ptr = unsafe.Pointer(C.NSNumber_inst_MethodSignatureForSelector(o.Ptr(), unsafe.Pointer(aSelector)))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSMethodSignature)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *NSMethodSignature) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *NSNumber) ClassForCoder() Class {
	ret := (Class)(unsafe.Pointer(C.NSNumber_inst_ClassForCoder(o.Ptr())))
	runtime.KeepAlive(o)
	return ret
}

func (o *NSNumber) ObservationInfo() unsafe.Pointer {
	ret := (unsafe.Pointer)(unsafe.Pointer(C.NSNumber_inst_ObservationInfo(o.Ptr())))
	runtime.KeepAlive(o)
	return ret
}

func (o *NSNumber) StringValue() *NSString {
	ret := &NSString{}
	ret.ptr = unsafe.Pointer(C.NSNumber_inst_StringValue(o.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSString)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *NSString) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

/*func (o *NSNumber) DecimalValue() NSDecimal {
	ret := (NSDecimal)(C.NSNumber_inst_DecimalValue(o.Ptr()))
	runtime.KeepAlive(o)
	return ret
}*/

func (o *NSNumber) ObjCType() *Char {
	ret := (*Char)(unsafe.Pointer(C.NSNumber_inst_ObjCType(o.Ptr())))
	runtime.KeepAlive(o)
	return ret
}

func (o *NSNumber) RemoveObserverForKeyPath(observer NSObject, keyPath *NSString)  {
	C.NSNumber_inst_RemoveObserverForKeyPath(o.Ptr(), observer.Ptr(), keyPath.Ptr())
	runtime.KeepAlive(o)
}

func (o *NSNumber) RemoveObserverForKeyPathContext(observer NSObject, keyPath *NSString, context unsafe.Pointer)  {
	C.NSNumber_inst_RemoveObserverForKeyPathContext(o.Ptr(), observer.Ptr(), keyPath.Ptr(), unsafe.Pointer(context))
	runtime.KeepAlive(o)
}

func (o *NSNumber) ReplacementObjectForKeyedArchiver(archiver *NSKeyedArchiver) *Id {
	ret := &Id{}
	ret.ptr = unsafe.Pointer(C.NSNumber_inst_ReplacementObjectForKeyedArchiver(o.Ptr(), archiver.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *Id) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *NSNumber) CoerceValueForKey(value NSObject, key *NSString) *Id {
	ret := &Id{}
	ret.ptr = unsafe.Pointer(C.NSNumber_inst_CoerceValueForKey(o.Ptr(), value.Ptr(), key.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *Id) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *NSNumber) InitWithUnsignedInt(value UnsignedInt) *NSNumber {
	ret := &NSNumber{}
	ret.ptr = unsafe.Pointer(C.NSNumber_inst_InitWithUnsignedInt(o.Ptr(), (C.uint)(value)))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSNumber)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *NSNumber) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *NSNumber) RangeValue() NSRange {
	ret := (NSRange)(C.NSNumber_inst_RangeValue(o.Ptr()))
	runtime.KeepAlive(o)
	return ret
}

func (o *NSNumber) InitWithUnsignedLongLong(value UnsignedLongLong) *NSNumber {
	ret := &NSNumber{}
	ret.ptr = unsafe.Pointer(C.NSNumber_inst_InitWithUnsignedLongLong(o.Ptr(), (C.ulonglong)(value)))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSNumber)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *NSNumber) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *NSNumber) MutableCopy() *Id {
	ret := &Id{}
	ret.ptr = unsafe.Pointer(C.NSNumber_inst_MutableCopy(o.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	runtime.SetFinalizer(ret, func(o *Id) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *NSNumber) InitWithUnsignedChar(value UnsignedChar) *NSNumber {
	ret := &NSNumber{}
	ret.ptr = unsafe.Pointer(C.NSNumber_inst_InitWithUnsignedChar(o.Ptr(), (C.uchar)(value)))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSNumber)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *NSNumber) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *NSNumber) PerformSelectorWithObject(aSelector SEL, anArgument NSObject, delay NSTimeInterval)  {
	C.NSNumber_inst_PerformSelectorWithObject(o.Ptr(), unsafe.Pointer(aSelector), anArgument.Ptr(), (C.NSTimeInterval)(delay))
	runtime.KeepAlive(o)
}

func (o *NSNumber) PerformSelectorWithObjectAfterDelay(aSelector SEL, anArgument NSObject, delay NSTimeInterval)  {
	C.NSNumber_inst_PerformSelectorWithObjectAfterDelay(o.Ptr(), unsafe.Pointer(aSelector), anArgument.Ptr(), (C.NSTimeInterval)(delay))
	runtime.KeepAlive(o)
}

func (o *NSNumber) PerformSelectorWithObjectAfterDelayInModes(aSelector SEL, anArgument NSObject, delay NSTimeInterval, modes *NSArray)  {
	C.NSNumber_inst_PerformSelectorWithObjectAfterDelayInModes(o.Ptr(), unsafe.Pointer(aSelector), anArgument.Ptr(), (C.NSTimeInterval)(delay), modes.Ptr())
	runtime.KeepAlive(o)
}

func (o *NSNumber) PerformSelectorOnThread(aSelector SEL, thr *NSThread, arg NSObject, wait BOOL)  {
	C.NSNumber_inst_PerformSelectorOnThread(o.Ptr(), unsafe.Pointer(aSelector), thr.Ptr(), arg.Ptr(), (C.BOOL)(wait))
	runtime.KeepAlive(o)
}

func (o *NSNumber) PerformSelectorOnThreadWithObject(aSelector SEL, thr *NSThread, arg NSObject, wait BOOL)  {
	C.NSNumber_inst_PerformSelectorOnThreadWithObject(o.Ptr(), unsafe.Pointer(aSelector), thr.Ptr(), arg.Ptr(), (C.BOOL)(wait))
	runtime.KeepAlive(o)
}

func (o *NSNumber) PerformSelectorOnThreadWithObjectWaitUntilDone(aSelector SEL, thr *NSThread, arg NSObject, wait BOOL, array *NSArray)  {
	C.NSNumber_inst_PerformSelectorOnThreadWithObjectWaitUntilDone(o.Ptr(), unsafe.Pointer(aSelector), thr.Ptr(), arg.Ptr(), (C.BOOL)(wait), array.Ptr())
	runtime.KeepAlive(o)
}

func (o *NSNumber) PerformSelectorOnThreadWithObjectWaitUntilDoneModes(aSelector SEL, thr *NSThread, arg NSObject, wait BOOL, array *NSArray)  {
	C.NSNumber_inst_PerformSelectorOnThreadWithObjectWaitUntilDoneModes(o.Ptr(), unsafe.Pointer(aSelector), thr.Ptr(), arg.Ptr(), (C.BOOL)(wait), array.Ptr())
	runtime.KeepAlive(o)
}

func (o *NSNumber) ScriptingIsLessThan(object NSObject) bool {
	ret := (bool)(C.NSNumber_inst_ScriptingIsLessThan(o.Ptr(), object.Ptr()))
	runtime.KeepAlive(o)
	return ret
}

func (o *NSNumber) SetObservationInfo(observationInfo unsafe.Pointer)  {
	C.NSNumber_inst_SetObservationInfo(o.Ptr(), unsafe.Pointer(observationInfo))
	runtime.KeepAlive(o)
}

func (o *NSNumber) DoesContain(object NSObject) bool {
	ret := (bool)(C.NSNumber_inst_DoesContain(o.Ptr(), object.Ptr()))
	runtime.KeepAlive(o)
	return ret
}

func (o *NSNumber) UnsignedLongValue() UnsignedLong {
	ret := (UnsignedLong)(C.NSNumber_inst_UnsignedLongValue(o.Ptr()))
	runtime.KeepAlive(o)
	return ret
}

func (o *NSNumber) ShortValue() Short {
	ret := (Short)(C.NSNumber_inst_ShortValue(o.Ptr()))
	runtime.KeepAlive(o)
	return ret
}

func (o *NSNumber) RectValue() NSRect {
	ret := (NSRect)(C.NSNumber_inst_RectValue(o.Ptr()))
	runtime.KeepAlive(o)
	return ret
}

func (o *NSNumber) IsNotEqualTo(object NSObject) bool {
	ret := (bool)(C.NSNumber_inst_IsNotEqualTo(o.Ptr(), object.Ptr()))
	runtime.KeepAlive(o)
	return ret
}

func (o *NSNumber) InverseForRelationshipKey(relationshipKey *NSString) *NSString {
	ret := &NSString{}
	ret.ptr = unsafe.Pointer(C.NSNumber_inst_InverseForRelationshipKey(o.Ptr(), relationshipKey.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSString)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *NSString) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *NSNumber) InsertValueInPropertyWithKey(value NSObject, key *NSString)  {
	C.NSNumber_inst_InsertValueInPropertyWithKey(o.Ptr(), value.Ptr(), key.Ptr())
	runtime.KeepAlive(o)
}

func (o *NSNumber) InsertValueAtIndex(value NSObject, index NSUInteger, key *NSString)  {
	C.NSNumber_inst_InsertValueAtIndex(o.Ptr(), value.Ptr(), (C.NSUInteger)(index), key.Ptr())
	runtime.KeepAlive(o)
}

func (o *NSNumber) InsertValueAtIndexInPropertyWithKey(value NSObject, index NSUInteger, key *NSString)  {
	C.NSNumber_inst_InsertValueAtIndexInPropertyWithKey(o.Ptr(), value.Ptr(), (C.NSUInteger)(index), key.Ptr())
	runtime.KeepAlive(o)
}

func (o *NSNumber) InitWithInteger(value NSInteger) *NSNumber {
	ret := &NSNumber{}
	ret.ptr = unsafe.Pointer(C.NSNumber_inst_InitWithInteger(o.Ptr(), (C.NSInteger)(value)))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSNumber)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *NSNumber) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *NSNumber) GetValueSize(value unsafe.Pointer, size NSUInteger)  {
	C.NSNumber_inst_GetValueSize(o.Ptr(), unsafe.Pointer(value), (C.NSUInteger)(size))
	runtime.KeepAlive(o)
}

func (o *NSNumber) ScriptingProperties() *NSDictionary {
	ret := &NSDictionary{}
	ret.ptr = unsafe.Pointer(C.NSNumber_inst_ScriptingProperties(o.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSDictionary)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *NSDictionary) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *NSNumber) ClassForArchiver() Class {
	ret := (Class)(unsafe.Pointer(C.NSNumber_inst_ClassForArchiver(o.Ptr())))
	runtime.KeepAlive(o)
	return ret
}

func (o *NSNumber) LongLongValue() LongLong {
	ret := (LongLong)(C.NSNumber_inst_LongLongValue(o.Ptr()))
	runtime.KeepAlive(o)
	return ret
}

func (o *NSNumber) ScriptingIsGreaterThanOrEqualTo(object NSObject) bool {
	ret := (bool)(C.NSNumber_inst_ScriptingIsGreaterThanOrEqualTo(o.Ptr(), object.Ptr()))
	runtime.KeepAlive(o)
	return ret
}

func (o *NSNumber) ForwardingTargetForSelector(aSelector SEL) *Id {
	ret := &Id{}
	ret.ptr = unsafe.Pointer(C.NSNumber_inst_ForwardingTargetForSelector(o.Ptr(), unsafe.Pointer(aSelector)))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *Id) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *NSNumber) ValueAtIndexInPropertyWithKey(index NSUInteger, key *NSString) *Id {
	ret := &Id{}
	ret.ptr = unsafe.Pointer(C.NSNumber_inst_ValueAtIndexInPropertyWithKey(o.Ptr(), (C.NSUInteger)(index), key.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *Id) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *NSNumber) DoesNotRecognizeSelector(aSelector SEL)  {
	C.NSNumber_inst_DoesNotRecognizeSelector(o.Ptr(), unsafe.Pointer(aSelector))
	runtime.KeepAlive(o)
}

func (o *NSNumber) UnsignedCharValue() UnsignedChar {
	ret := (UnsignedChar)(C.NSNumber_inst_UnsignedCharValue(o.Ptr()))
	runtime.KeepAlive(o)
	return ret
}

func (o *NSNumber) ValueWithUniqueIDInPropertyWithKey(uniqueID NSObject, key *NSString) *Id {
	ret := &Id{}
	ret.ptr = unsafe.Pointer(C.NSNumber_inst_ValueWithUniqueIDInPropertyWithKey(o.Ptr(), uniqueID.Ptr(), key.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *Id) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *NSNumber) AddObserverForKeyPath(observer NSObject, keyPath *NSString, options NSKeyValueObservingOptions, context unsafe.Pointer)  {
	C.NSNumber_inst_AddObserverForKeyPath(o.Ptr(), observer.Ptr(), keyPath.Ptr(), (C.NSKeyValueObservingOptions)(options), unsafe.Pointer(context))
	runtime.KeepAlive(o)
}

func (o *NSNumber) AddObserverForKeyPathOptions(observer NSObject, keyPath *NSString, options NSKeyValueObservingOptions, context unsafe.Pointer)  {
	C.NSNumber_inst_AddObserverForKeyPathOptions(o.Ptr(), observer.Ptr(), keyPath.Ptr(), (C.NSKeyValueObservingOptions)(options), unsafe.Pointer(context))
	runtime.KeepAlive(o)
}

func (o *NSNumber) ReplacementObjectForCoder(coder *NSCoder) *Id {
	ret := &Id{}
	ret.ptr = unsafe.Pointer(C.NSNumber_inst_ReplacementObjectForCoder(o.Ptr(), coder.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *Id) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *NSNumber) ReplaceValueAtIndexInPropertyWithKey(index NSUInteger, key *NSString, value NSObject)  {
	C.NSNumber_inst_ReplaceValueAtIndexInPropertyWithKey(o.Ptr(), (C.NSUInteger)(index), key.Ptr(), value.Ptr())
	runtime.KeepAlive(o)
}

func (o *NSNumber) ReplaceValueAtIndexInPropertyWithKeyWithValue(index NSUInteger, key *NSString, value NSObject)  {
	C.NSNumber_inst_ReplaceValueAtIndexInPropertyWithKeyWithValue(o.Ptr(), (C.NSUInteger)(index), key.Ptr(), value.Ptr())
	runtime.KeepAlive(o)
}

func (o *NSNumber) WillChangeValueForKey(key *NSString)  {
	C.NSNumber_inst_WillChangeValueForKey(o.Ptr(), key.Ptr())
	runtime.KeepAlive(o)
}

func (o *NSNumber) WillChangeValueForKeyWithSetMutation(key *NSString, mutationKind NSKeyValueSetMutationKind, objects *NSSet)  {
	C.NSNumber_inst_WillChangeValueForKeyWithSetMutation(o.Ptr(), key.Ptr(), (C.NSKeyValueSetMutationKind)(mutationKind), objects.Ptr())
	runtime.KeepAlive(o)
}

func (o *NSNumber) WillChangeValueForKeyWithSetMutationUsingObjects(key *NSString, mutationKind NSKeyValueSetMutationKind, objects *NSSet)  {
	C.NSNumber_inst_WillChangeValueForKeyWithSetMutationUsingObjects(o.Ptr(), key.Ptr(), (C.NSKeyValueSetMutationKind)(mutationKind), objects.Ptr())
	runtime.KeepAlive(o)
}

func (o *NSNumber) InitWithCoder(coder *NSCoder) *NSNumber {
	ret := &NSNumber{}
	ret.ptr = unsafe.Pointer(C.NSNumber_inst_InitWithCoder(o.Ptr(), coder.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSNumber)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *NSNumber) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *NSNumber) FloatValue() Float {
	ret := (Float)(C.NSNumber_inst_FloatValue(o.Ptr()))
	runtime.KeepAlive(o)
	return ret
}

func (o *NSNumber) IntegerValue() NSInteger {
	ret := (NSInteger)(C.NSNumber_inst_IntegerValue(o.Ptr()))
	runtime.KeepAlive(o)
	return ret
}

func (o *NSNumber) Copy() *Id {
	ret := &Id{}
	ret.ptr = unsafe.Pointer(C.NSNumber_inst_Copy(o.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	runtime.SetFinalizer(ret, func(o *Id) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *NSNumber) IsLessThanOrEqualTo(object NSObject) bool {
	ret := (bool)(C.NSNumber_inst_IsLessThanOrEqualTo(o.Ptr(), object.Ptr()))
	runtime.KeepAlive(o)
	return ret
}

func (o *NSNumber) PerformSelectorInBackgroundWithObject(aSelector SEL, arg NSObject)  {
	C.NSNumber_inst_PerformSelectorInBackgroundWithObject(o.Ptr(), unsafe.Pointer(aSelector), arg.Ptr())
	runtime.KeepAlive(o)
}

func (o *NSNumber) DidChangeValueForKey(key *NSString)  {
	C.NSNumber_inst_DidChangeValueForKey(o.Ptr(), key.Ptr())
	runtime.KeepAlive(o)
}

func (o *NSNumber) DidChangeValueForKeyWithSetMutation(key *NSString, mutationKind NSKeyValueSetMutationKind, objects *NSSet)  {
	C.NSNumber_inst_DidChangeValueForKeyWithSetMutation(o.Ptr(), key.Ptr(), (C.NSKeyValueSetMutationKind)(mutationKind), objects.Ptr())
	runtime.KeepAlive(o)
}

func (o *NSNumber) DidChangeValueForKeyWithSetMutationUsingObjects(key *NSString, mutationKind NSKeyValueSetMutationKind, objects *NSSet)  {
	C.NSNumber_inst_DidChangeValueForKeyWithSetMutationUsingObjects(o.Ptr(), key.Ptr(), (C.NSKeyValueSetMutationKind)(mutationKind), objects.Ptr())
	runtime.KeepAlive(o)
}

func (o *NSNumber) UnsignedLongLongValue() UnsignedLongLong {
	ret := (UnsignedLongLong)(C.NSNumber_inst_UnsignedLongLongValue(o.Ptr()))
	runtime.KeepAlive(o)
	return ret
}

func (o *NSNumber) IsEqualTo(object NSObject) bool {
	ret := (bool)(C.NSNumber_inst_IsEqualTo(o.Ptr(), object.Ptr()))
	runtime.KeepAlive(o)
	return ret
}

func (o *NSNumber) IsEqualToNumber(number *NSNumber) bool {
	ret := (bool)(C.NSNumber_inst_IsEqualToNumber(o.Ptr(), number.Ptr()))
	runtime.KeepAlive(o)
	return ret
}

func (o *NSNumber) ClassCode() FourCharCode {
	ret := (FourCharCode)(C.NSNumber_inst_ClassCode(o.Ptr()))
	runtime.KeepAlive(o)
	return ret
}

func (o *NSNumber) SetValueForKey(value NSObject, key *NSString)  {
	C.NSNumber_inst_SetValueForKey(o.Ptr(), value.Ptr(), key.Ptr())
	runtime.KeepAlive(o)
}

func (o *NSNumber) SetValueForKeyPath(value NSObject, keyPath *NSString)  {
	C.NSNumber_inst_SetValueForKeyPath(o.Ptr(), value.Ptr(), keyPath.Ptr())
	runtime.KeepAlive(o)
}

func (o *NSNumber) SetValueForUndefinedKey(value NSObject, key *NSString)  {
	C.NSNumber_inst_SetValueForUndefinedKey(o.Ptr(), value.Ptr(), key.Ptr())
	runtime.KeepAlive(o)
}

func (o *NSNumber) UnsignedIntegerValue() NSUInteger {
	ret := (NSUInteger)(C.NSNumber_inst_UnsignedIntegerValue(o.Ptr()))
	runtime.KeepAlive(o)
	return ret
}

func (o *NSNumber) ObserveValueForKeyPathOfObject(keyPath *NSString, object NSObject, change *NSDictionary, context unsafe.Pointer)  {
	C.NSNumber_inst_ObserveValueForKeyPathOfObject(o.Ptr(), keyPath.Ptr(), object.Ptr(), change.Ptr(), unsafe.Pointer(context))
	runtime.KeepAlive(o)
}

func (o *NSNumber) ObserveValueForKeyPathOfObjectChange(keyPath *NSString, object NSObject, change *NSDictionary, context unsafe.Pointer)  {
	C.NSNumber_inst_ObserveValueForKeyPathOfObjectChange(o.Ptr(), keyPath.Ptr(), object.Ptr(), change.Ptr(), unsafe.Pointer(context))
	runtime.KeepAlive(o)
}

func (o *NSNumber) Dealloc()  {
	C.NSNumber_inst_Dealloc(o.Ptr())
	runtime.KeepAlive(o)
}

func (o *NSNumber) ClassName() *NSString {
	ret := &NSString{}
	ret.ptr = unsafe.Pointer(C.NSNumber_inst_ClassName(o.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSString)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *NSString) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *NSNumber) WillChangeValuesAtIndexes(changeKind NSKeyValueChange, indexes *NSIndexSet, key *NSString)  {
	C.NSNumber_inst_WillChangeValuesAtIndexes(o.Ptr(), (C.NSKeyValueChange)(changeKind), indexes.Ptr(), key.Ptr())
	runtime.KeepAlive(o)
}

func (o *NSNumber) WillChangeValuesAtIndexesForKey(changeKind NSKeyValueChange, indexes *NSIndexSet, key *NSString)  {
	C.NSNumber_inst_WillChangeValuesAtIndexesForKey(o.Ptr(), (C.NSKeyValueChange)(changeKind), indexes.Ptr(), key.Ptr())
	runtime.KeepAlive(o)
}

func (o *NSNumber) ScriptingIsEqualTo(object NSObject) bool {
	ret := (bool)(C.NSNumber_inst_ScriptingIsEqualTo(o.Ptr(), object.Ptr()))
	runtime.KeepAlive(o)
	return ret
}

func (o *NSNumber) InitWithChar(value Char) *NSNumber {
	ret := &NSNumber{}
	ret.ptr = unsafe.Pointer(C.NSNumber_inst_InitWithChar(o.Ptr(), (C.char)(value)))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSNumber)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *NSNumber) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *NSNumber) InitWithLongLong(value LongLong) *NSNumber {
	ret := &NSNumber{}
	ret.ptr = unsafe.Pointer(C.NSNumber_inst_InitWithLongLong(o.Ptr(), (C.longlong)(value)))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSNumber)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *NSNumber) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *NSNumber) LongValue() Long {
	ret := (Long)(C.NSNumber_inst_LongValue(o.Ptr()))
	runtime.KeepAlive(o)
	return ret
}

func (o *NSNumber) InitWithUnsignedInteger(value NSUInteger) *NSNumber {
	ret := &NSNumber{}
	ret.ptr = unsafe.Pointer(C.NSNumber_inst_InitWithUnsignedInteger(o.Ptr(), (C.NSUInteger)(value)))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSNumber)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *NSNumber) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *NSNumber) CharValue() Char {
	ret := (Char)(C.NSNumber_inst_CharValue(o.Ptr()))
	runtime.KeepAlive(o)
	return ret
}

func (o *NSNumber) NonretainedObjectValue() *Id {
	ret := &Id{}
	ret.ptr = unsafe.Pointer(C.NSNumber_inst_NonretainedObjectValue(o.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *Id) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *NSNumber) AttemptRecoveryFromErrorOptionIndex(error *NSError, recoveryOptionIndex NSUInteger) bool {
	ret := (bool)(C.NSNumber_inst_AttemptRecoveryFromErrorOptionIndex(o.Ptr(), error.Ptr(), (C.NSUInteger)(recoveryOptionIndex)))
	runtime.KeepAlive(o)
	return ret
}

func (o *NSNumber) AttemptRecoveryFromErrorOptionIndexDelegate(error *NSError, recoveryOptionIndex NSUInteger, delegate NSObject, didRecoverSelector SEL, contextInfo unsafe.Pointer)  {
	C.NSNumber_inst_AttemptRecoveryFromErrorOptionIndexDelegate(o.Ptr(), error.Ptr(), (C.NSUInteger)(recoveryOptionIndex), delegate.Ptr(), unsafe.Pointer(didRecoverSelector), unsafe.Pointer(contextInfo))
	runtime.KeepAlive(o)
}

func (o *NSNumber) AttemptRecoveryFromErrorOptionIndexDelegateDidRecoverSelector(error *NSError, recoveryOptionIndex NSUInteger, delegate NSObject, didRecoverSelector SEL, contextInfo unsafe.Pointer)  {
	C.NSNumber_inst_AttemptRecoveryFromErrorOptionIndexDelegateDidRecoverSelector(o.Ptr(), error.Ptr(), (C.NSUInteger)(recoveryOptionIndex), delegate.Ptr(), unsafe.Pointer(didRecoverSelector), unsafe.Pointer(contextInfo))
	runtime.KeepAlive(o)
}

func (o *NSNumber) ToOneRelationshipKeys() *NSArray {
	ret := &NSArray{}
	ret.ptr = unsafe.Pointer(C.NSNumber_inst_ToOneRelationshipKeys(o.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSArray)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *NSArray) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *NSNumber) MutableArrayValueForKeyPath(keyPath *NSString) *NSMutableArray {
	ret := &NSMutableArray{}
	ret.ptr = unsafe.Pointer(C.NSNumber_inst_MutableArrayValueForKeyPath(o.Ptr(), keyPath.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSMutableArray)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *NSMutableArray) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *NSNumber) InitWithInt(value Int) *NSNumber {
	ret := &NSNumber{}
	ret.ptr = unsafe.Pointer(C.NSNumber_inst_InitWithInt(o.Ptr(), (C.int)(value)))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSNumber)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *NSNumber) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *NSNumber) PointValue() NSPoint {
	ret := (NSPoint)(C.NSNumber_inst_PointValue(o.Ptr()))
	runtime.KeepAlive(o)
	return ret
}

func (o *NSNumber) EdgeInsetsValue() NSEdgeInsets {
	ret := (NSEdgeInsets)(C.NSNumber_inst_EdgeInsetsValue(o.Ptr()))
	runtime.KeepAlive(o)
	return ret
}

func (o *NSNumber) ToManyRelationshipKeys() *NSArray {
	ret := &NSArray{}
	ret.ptr = unsafe.Pointer(C.NSNumber_inst_ToManyRelationshipKeys(o.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSArray)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *NSArray) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *NSNumber) ScriptingIsLessThanOrEqualTo(object NSObject) bool {
	ret := (bool)(C.NSNumber_inst_ScriptingIsLessThanOrEqualTo(o.Ptr(), object.Ptr()))
	runtime.KeepAlive(o)
	return ret
}

func (o *NSNumber) ScriptingIsGreaterThan(object NSObject) bool {
	ret := (bool)(C.NSNumber_inst_ScriptingIsGreaterThan(o.Ptr(), object.Ptr()))
	runtime.KeepAlive(o)
	return ret
}

func CBPeripheralManagerAutomaticallyNotifiesObserversForKey(key *NSString) bool {
	ret := (bool)(C.CBPeripheralManager_AutomaticallyNotifiesObserversForKey(key.Ptr()))
	return ret
}

func CBPeripheralManagerNew() *CBPeripheralManager {
	ret := &CBPeripheralManager{}
	ret.ptr = unsafe.Pointer(C.CBPeripheralManager_New())
	if ret.ptr == nil { return ret }
	runtime.SetFinalizer(ret, func(o *CBPeripheralManager) {
		o.Release()
	})
	return ret
}

func CBPeripheralManagerAlloc() *CBPeripheralManager {
	ret := &CBPeripheralManager{}
	ret.ptr = unsafe.Pointer(C.CBPeripheralManager_Alloc())
	if ret.ptr == nil { return ret }
	runtime.SetFinalizer(ret, func(o *CBPeripheralManager) {
		o.Release()
	})
	return ret
}

func (o *CBPeripheralManager) GC() {
	if o.ptr == nil { return }
	runtime.SetFinalizer(o, func(o *CBPeripheralManager) {
		o.Release()
	})
	runtime.KeepAlive(o)
}

func CBPeripheralManagerInstanceMethodSignatureForSelector(aSelector SEL) *NSMethodSignature {
	ret := &NSMethodSignature{}
	ret.ptr = unsafe.Pointer(C.CBPeripheralManager_InstanceMethodSignatureForSelector(unsafe.Pointer(aSelector)))
	if ret.ptr == nil { return ret }
	return ret
}

func CBPeripheralManagerKeyPathsForValuesAffectingValueForKey(key *NSString) *NSSet {
	ret := &NSSet{}
	ret.ptr = unsafe.Pointer(C.CBPeripheralManager_KeyPathsForValuesAffectingValueForKey(key.Ptr()))
	if ret.ptr == nil { return ret }
	return ret
}

func CBPeripheralManagerResolveClassMethod(sel SEL) bool {
	ret := (bool)(C.CBPeripheralManager_ResolveClassMethod(unsafe.Pointer(sel)))
	return ret
}

func CBPeripheralManagerIsSubclassOfClass(aClass Class) bool {
	ret := (bool)(C.CBPeripheralManager_IsSubclassOfClass(unsafe.Pointer(aClass)))
	return ret
}

func CBPeripheralManagerHash() NSUInteger {
	ret := (NSUInteger)(C.CBPeripheralManager_Hash())
	return ret
}

func CBPeripheralManagerInstancesRespondToSelector(aSelector SEL) bool {
	ret := (bool)(C.CBPeripheralManager_InstancesRespondToSelector(unsafe.Pointer(aSelector)))
	return ret
}

func CBPeripheralManagerSetVersion(aVersion NSInteger)  {
	C.CBPeripheralManager_SetVersion((C.NSInteger)(aVersion))
}

func CBPeripheralManagerCopyWithZone(zone *_NSZone) *Id {
	ret := &Id{}
	ret.ptr = unsafe.Pointer(C.CBPeripheralManager_CopyWithZone(unsafe.Pointer(zone)))
	if ret.ptr == nil { return ret }
	runtime.SetFinalizer(ret, func(o *Id) {
		o.Release()
	})
	return ret
}

func CBPeripheralManagerAccessInstanceVariablesDirectly() bool {
	ret := (bool)(C.CBPeripheralManager_AccessInstanceVariablesDirectly())
	return ret
}

func CBPeripheralManagerAllocWithZone(zone *_NSZone) *CBPeripheralManager {
	ret := &CBPeripheralManager{}
	ret.ptr = unsafe.Pointer(C.CBPeripheralManager_AllocWithZone(unsafe.Pointer(zone)))
	if ret.ptr == nil { return ret }
	runtime.SetFinalizer(ret, func(o *CBPeripheralManager) {
		o.Release()
	})
	return ret
}

func CBPeripheralManagerCancelPreviousPerformRequestsWithTarget(aTarget NSObject)  {
	C.CBPeripheralManager_CancelPreviousPerformRequestsWithTarget(aTarget.Ptr())
}

func CBPeripheralManagerCancelPreviousPerformRequestsWithTargetSelector(aTarget NSObject, aSelector SEL, anArgument NSObject)  {
	C.CBPeripheralManager_CancelPreviousPerformRequestsWithTargetSelector(aTarget.Ptr(), unsafe.Pointer(aSelector), anArgument.Ptr())
}

func CBPeripheralManagerCancelPreviousPerformRequestsWithTargetSelectorObject(aTarget NSObject, aSelector SEL, anArgument NSObject)  {
	C.CBPeripheralManager_CancelPreviousPerformRequestsWithTargetSelectorObject(aTarget.Ptr(), unsafe.Pointer(aSelector), anArgument.Ptr())
}

func CBPeripheralManagerResolveInstanceMethod(sel SEL) bool {
	ret := (bool)(C.CBPeripheralManager_ResolveInstanceMethod(unsafe.Pointer(sel)))
	return ret
}

func CBPeripheralManagerConformsToProtocol(protocol Protocol) bool {
	ret := (bool)(C.CBPeripheralManager_ConformsToProtocol(protocol.Ptr()))
	return ret
}

func CBPeripheralManagerSuperclass() Class {
	ret := (Class)(unsafe.Pointer(C.CBPeripheralManager_Superclass()))
	return ret
}

func CBPeripheralManagerAuthorization() CBManagerAuthorization {
	ret := (CBManagerAuthorization)(C.CBPeripheralManager_Authorization())
	return ret
}

func CBPeripheralManagerLoad()  {
	C.CBPeripheralManager_Load()
}

func CBPeripheralManagerDebugDescription() *NSString {
	ret := &NSString{}
	ret.ptr = unsafe.Pointer(C.CBPeripheralManager_DebugDescription())
	if ret.ptr == nil { return ret }
	return ret
}

func CBPeripheralManagerClass() Class {
	ret := (Class)(unsafe.Pointer(C.CBPeripheralManager_Class()))
	return ret
}

func CBPeripheralManagerClassFallbacksForKeyedArchiver() *NSArray {
	ret := &NSArray{}
	ret.ptr = unsafe.Pointer(C.CBPeripheralManager_ClassFallbacksForKeyedArchiver())
	if ret.ptr == nil { return ret }
	return ret
}

func CBPeripheralManagerVersion() NSInteger {
	ret := (NSInteger)(C.CBPeripheralManager_Version())
	return ret
}

func CBPeripheralManagerMutableCopyWithZone(zone *_NSZone) *Id {
	ret := &Id{}
	ret.ptr = unsafe.Pointer(C.CBPeripheralManager_MutableCopyWithZone(unsafe.Pointer(zone)))
	if ret.ptr == nil { return ret }
	runtime.SetFinalizer(ret, func(o *Id) {
		o.Release()
	})
	return ret
}

func CBPeripheralManagerDescription() *NSString {
	ret := &NSString{}
	ret.ptr = unsafe.Pointer(C.CBPeripheralManager_Description())
	if ret.ptr == nil { return ret }
	return ret
}

func CBPeripheralManagerClassForKeyedUnarchiver() Class {
	ret := (Class)(unsafe.Pointer(C.CBPeripheralManager_ClassForKeyedUnarchiver()))
	return ret
}

func (o *CBPeripheralManager) ClassForKeyedArchiver() Class {
	ret := (Class)(unsafe.Pointer(C.CBPeripheralManager_inst_ClassForKeyedArchiver(o.Ptr())))
	runtime.KeepAlive(o)
	return ret
}

func (o *CBPeripheralManager) Init() *CBPeripheralManager {
	ret := &CBPeripheralManager{}
	ret.ptr = unsafe.Pointer(C.CBPeripheralManager_inst_Init(o.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*CBPeripheralManager)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *CBPeripheralManager) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *CBPeripheralManager) ReplacementObjectForKeyedArchiver(archiver *NSKeyedArchiver) *Id {
	ret := &Id{}
	ret.ptr = unsafe.Pointer(C.CBPeripheralManager_inst_ReplacementObjectForKeyedArchiver(o.Ptr(), archiver.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *Id) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *CBPeripheralManager) CoerceValueForKey(value NSObject, key *NSString) *Id {
	ret := &Id{}
	ret.ptr = unsafe.Pointer(C.CBPeripheralManager_inst_CoerceValueForKey(o.Ptr(), value.Ptr(), key.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *Id) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *CBPeripheralManager) AutoContentAccessingProxy() *Id {
	ret := &Id{}
	ret.ptr = unsafe.Pointer(C.CBPeripheralManager_inst_AutoContentAccessingProxy(o.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *Id) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *CBPeripheralManager) ScriptingProperties() *NSDictionary {
	ret := &NSDictionary{}
	ret.ptr = unsafe.Pointer(C.CBPeripheralManager_inst_ScriptingProperties(o.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSDictionary)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *NSDictionary) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *CBPeripheralManager) MutableCopy() *Id {
	ret := &Id{}
	ret.ptr = unsafe.Pointer(C.CBPeripheralManager_inst_MutableCopy(o.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	runtime.SetFinalizer(ret, func(o *Id) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *CBPeripheralManager) WillChangeValueForKey(key *NSString)  {
	C.CBPeripheralManager_inst_WillChangeValueForKey(o.Ptr(), key.Ptr())
	runtime.KeepAlive(o)
}

func (o *CBPeripheralManager) WillChangeValueForKeyWithSetMutation(key *NSString, mutationKind NSKeyValueSetMutationKind, objects *NSSet)  {
	C.CBPeripheralManager_inst_WillChangeValueForKeyWithSetMutation(o.Ptr(), key.Ptr(), (C.NSKeyValueSetMutationKind)(mutationKind), objects.Ptr())
	runtime.KeepAlive(o)
}

func (o *CBPeripheralManager) WillChangeValueForKeyWithSetMutationUsingObjects(key *NSString, mutationKind NSKeyValueSetMutationKind, objects *NSSet)  {
	C.CBPeripheralManager_inst_WillChangeValueForKeyWithSetMutationUsingObjects(o.Ptr(), key.Ptr(), (C.NSKeyValueSetMutationKind)(mutationKind), objects.Ptr())
	runtime.KeepAlive(o)
}

func (o *CBPeripheralManager) ObserveValueForKeyPathOfObject(keyPath *NSString, object NSObject, change *NSDictionary, context unsafe.Pointer)  {
	C.CBPeripheralManager_inst_ObserveValueForKeyPathOfObject(o.Ptr(), keyPath.Ptr(), object.Ptr(), change.Ptr(), unsafe.Pointer(context))
	runtime.KeepAlive(o)
}

func (o *CBPeripheralManager) ObserveValueForKeyPathOfObjectChange(keyPath *NSString, object NSObject, change *NSDictionary, context unsafe.Pointer)  {
	C.CBPeripheralManager_inst_ObserveValueForKeyPathOfObjectChange(o.Ptr(), keyPath.Ptr(), object.Ptr(), change.Ptr(), unsafe.Pointer(context))
	runtime.KeepAlive(o)
}

func (o *CBPeripheralManager) ObserveValueForKeyPathOfObjectChangeContext(keyPath *NSString, object NSObject, change *NSDictionary, context unsafe.Pointer)  {
	C.CBPeripheralManager_inst_ObserveValueForKeyPathOfObjectChangeContext(o.Ptr(), keyPath.Ptr(), object.Ptr(), change.Ptr(), unsafe.Pointer(context))
	runtime.KeepAlive(o)
}

func (o *CBPeripheralManager) ScriptingIsLessThanOrEqualTo(object NSObject) bool {
	ret := (bool)(C.CBPeripheralManager_inst_ScriptingIsLessThanOrEqualTo(o.Ptr(), object.Ptr()))
	runtime.KeepAlive(o)
	return ret
}

func (o *CBPeripheralManager) SetValueForKey(value NSObject, key *NSString)  {
	C.CBPeripheralManager_inst_SetValueForKey(o.Ptr(), value.Ptr(), key.Ptr())
	runtime.KeepAlive(o)
}

func (o *CBPeripheralManager) SetValueForKeyPath(value NSObject, keyPath *NSString)  {
	C.CBPeripheralManager_inst_SetValueForKeyPath(o.Ptr(), value.Ptr(), keyPath.Ptr())
	runtime.KeepAlive(o)
}

func (o *CBPeripheralManager) SetValueForUndefinedKey(value NSObject, key *NSString)  {
	C.CBPeripheralManager_inst_SetValueForUndefinedKey(o.Ptr(), value.Ptr(), key.Ptr())
	runtime.KeepAlive(o)
}

func (o *CBPeripheralManager) NewScriptingObjectOfClassForValueForKey(objectClass Class, key *NSString, contentsValue NSObject, properties *NSDictionary) *Id {
	ret := &Id{}
	ret.ptr = unsafe.Pointer(C.CBPeripheralManager_inst_NewScriptingObjectOfClassForValueForKey(o.Ptr(), unsafe.Pointer(objectClass), key.Ptr(), contentsValue.Ptr(), properties.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *Id) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *CBPeripheralManager) NewScriptingObjectOfClassForValueForKeyWithContentsValue(objectClass Class, key *NSString, contentsValue NSObject, properties *NSDictionary) *Id {
	ret := &Id{}
	ret.ptr = unsafe.Pointer(C.CBPeripheralManager_inst_NewScriptingObjectOfClassForValueForKeyWithContentsValue(o.Ptr(), unsafe.Pointer(objectClass), key.Ptr(), contentsValue.Ptr(), properties.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *Id) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *CBPeripheralManager) NewScriptingObjectOfClassForValueForKeyWithContentsValueProperties(objectClass Class, key *NSString, contentsValue NSObject, properties *NSDictionary) *Id {
	ret := &Id{}
	ret.ptr = unsafe.Pointer(C.CBPeripheralManager_inst_NewScriptingObjectOfClassForValueForKeyWithContentsValueProperties(o.Ptr(), unsafe.Pointer(objectClass), key.Ptr(), contentsValue.Ptr(), properties.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *Id) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *CBPeripheralManager) IsEqualTo(object NSObject) bool {
	ret := (bool)(C.CBPeripheralManager_inst_IsEqualTo(o.Ptr(), object.Ptr()))
	runtime.KeepAlive(o)
	return ret
}

func (o *CBPeripheralManager) PublishL2CAPChannelWithEncryption(encryptionRequired BOOL)  {
	C.CBPeripheralManager_inst_PublishL2CAPChannelWithEncryption(o.Ptr(), (C.BOOL)(encryptionRequired))
	runtime.KeepAlive(o)
}

func (o *CBPeripheralManager) Delegate() *Id {
	ret := &Id{}
	ret.ptr = unsafe.Pointer(C.CBPeripheralManager_inst_Delegate(o.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *Id) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *CBPeripheralManager) PerformSelectorOnMainThreadWithObject(aSelector SEL, arg NSObject, wait BOOL)  {
	C.CBPeripheralManager_inst_PerformSelectorOnMainThreadWithObject(o.Ptr(), unsafe.Pointer(aSelector), arg.Ptr(), (C.BOOL)(wait))
	runtime.KeepAlive(o)
}

func (o *CBPeripheralManager) PerformSelectorOnMainThreadWithObjectWaitUntilDone(aSelector SEL, arg NSObject, wait BOOL)  {
	C.CBPeripheralManager_inst_PerformSelectorOnMainThreadWithObjectWaitUntilDone(o.Ptr(), unsafe.Pointer(aSelector), arg.Ptr(), (C.BOOL)(wait))
	runtime.KeepAlive(o)
}

func (o *CBPeripheralManager) PerformSelectorOnMainThreadWithObjectWaitUntilDoneModes(aSelector SEL, arg NSObject, wait BOOL, array *NSArray)  {
	C.CBPeripheralManager_inst_PerformSelectorOnMainThreadWithObjectWaitUntilDoneModes(o.Ptr(), unsafe.Pointer(aSelector), arg.Ptr(), (C.BOOL)(wait), array.Ptr())
	runtime.KeepAlive(o)
}

func (o *CBPeripheralManager) ScriptingIsLessThan(object NSObject) bool {
	ret := (bool)(C.CBPeripheralManager_inst_ScriptingIsLessThan(o.Ptr(), object.Ptr()))
	runtime.KeepAlive(o)
	return ret
}

func (o *CBPeripheralManager) DictionaryWithValuesForKeys(keys *NSArray) *NSDictionary {
	ret := &NSDictionary{}
	ret.ptr = unsafe.Pointer(C.CBPeripheralManager_inst_DictionaryWithValuesForKeys(o.Ptr(), keys.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSDictionary)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *NSDictionary) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *CBPeripheralManager) SetObservationInfo(observationInfo unsafe.Pointer)  {
	C.CBPeripheralManager_inst_SetObservationInfo(o.Ptr(), unsafe.Pointer(observationInfo))
	runtime.KeepAlive(o)
}

func (o *CBPeripheralManager) WillChangeValuesAtIndexes(changeKind NSKeyValueChange, indexes *NSIndexSet, key *NSString)  {
	C.CBPeripheralManager_inst_WillChangeValuesAtIndexes(o.Ptr(), (C.NSKeyValueChange)(changeKind), indexes.Ptr(), key.Ptr())
	runtime.KeepAlive(o)
}

func (o *CBPeripheralManager) WillChangeValuesAtIndexesForKey(changeKind NSKeyValueChange, indexes *NSIndexSet, key *NSString)  {
	C.CBPeripheralManager_inst_WillChangeValuesAtIndexesForKey(o.Ptr(), (C.NSKeyValueChange)(changeKind), indexes.Ptr(), key.Ptr())
	runtime.KeepAlive(o)
}

func (o *CBPeripheralManager) ScriptingIsEqualTo(object NSObject) bool {
	ret := (bool)(C.CBPeripheralManager_inst_ScriptingIsEqualTo(o.Ptr(), object.Ptr()))
	runtime.KeepAlive(o)
	return ret
}

func (o *CBPeripheralManager) RemoveObserverForKeyPath(observer NSObject, keyPath *NSString)  {
	C.CBPeripheralManager_inst_RemoveObserverForKeyPath(o.Ptr(), observer.Ptr(), keyPath.Ptr())
	runtime.KeepAlive(o)
}

func (o *CBPeripheralManager) RemoveObserverForKeyPathContext(observer NSObject, keyPath *NSString, context unsafe.Pointer)  {
	C.CBPeripheralManager_inst_RemoveObserverForKeyPathContext(o.Ptr(), observer.Ptr(), keyPath.Ptr(), unsafe.Pointer(context))
	runtime.KeepAlive(o)
}

func (o *CBPeripheralManager) SetScriptingProperties(scriptingProperties *NSDictionary)  {
	C.CBPeripheralManager_inst_SetScriptingProperties(o.Ptr(), scriptingProperties.Ptr())
	runtime.KeepAlive(o)
}

func (o *CBPeripheralManager) ScriptingBeginsWith(object NSObject) bool {
	ret := (bool)(C.CBPeripheralManager_inst_ScriptingBeginsWith(o.Ptr(), object.Ptr()))
	runtime.KeepAlive(o)
	return ret
}

func (o *CBPeripheralManager) CopyScriptingValueForKey(value NSObject, key *NSString, properties *NSDictionary) *Id {
	ret := &Id{}
	ret.ptr = unsafe.Pointer(C.CBPeripheralManager_inst_CopyScriptingValueForKey(o.Ptr(), value.Ptr(), key.Ptr(), properties.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *Id) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *CBPeripheralManager) CopyScriptingValueForKeyWithProperties(value NSObject, key *NSString, properties *NSDictionary) *Id {
	ret := &Id{}
	ret.ptr = unsafe.Pointer(C.CBPeripheralManager_inst_CopyScriptingValueForKeyWithProperties(o.Ptr(), value.Ptr(), key.Ptr(), properties.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *Id) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *CBPeripheralManager) SetNilValueForKey(key *NSString)  {
	C.CBPeripheralManager_inst_SetNilValueForKey(o.Ptr(), key.Ptr())
	runtime.KeepAlive(o)
}

func (o *CBPeripheralManager) AddObserverForKeyPath(observer NSObject, keyPath *NSString, options NSKeyValueObservingOptions, context unsafe.Pointer)  {
	C.CBPeripheralManager_inst_AddObserverForKeyPath(o.Ptr(), observer.Ptr(), keyPath.Ptr(), (C.NSKeyValueObservingOptions)(options), unsafe.Pointer(context))
	runtime.KeepAlive(o)
}

func (o *CBPeripheralManager) AddObserverForKeyPathOptions(observer NSObject, keyPath *NSString, options NSKeyValueObservingOptions, context unsafe.Pointer)  {
	C.CBPeripheralManager_inst_AddObserverForKeyPathOptions(o.Ptr(), observer.Ptr(), keyPath.Ptr(), (C.NSKeyValueObservingOptions)(options), unsafe.Pointer(context))
	runtime.KeepAlive(o)
}

func (o *CBPeripheralManager) AddObserverForKeyPathOptionsContext(observer NSObject, keyPath *NSString, options NSKeyValueObservingOptions, context unsafe.Pointer)  {
	C.CBPeripheralManager_inst_AddObserverForKeyPathOptionsContext(o.Ptr(), observer.Ptr(), keyPath.Ptr(), (C.NSKeyValueObservingOptions)(options), unsafe.Pointer(context))
	runtime.KeepAlive(o)
}

func (o *CBPeripheralManager) DoesContain(object NSObject) bool {
	ret := (bool)(C.CBPeripheralManager_inst_DoesContain(o.Ptr(), object.Ptr()))
	runtime.KeepAlive(o)
	return ret
}

func (o *CBPeripheralManager) ValueForKeyPath(keyPath *NSString) *Id {
	ret := &Id{}
	ret.ptr = unsafe.Pointer(C.CBPeripheralManager_inst_ValueForKeyPath(o.Ptr(), keyPath.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *Id) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *CBPeripheralManager) IsLessThan(object NSObject) bool {
	ret := (bool)(C.CBPeripheralManager_inst_IsLessThan(o.Ptr(), object.Ptr()))
	runtime.KeepAlive(o)
	return ret
}

func (o *CBPeripheralManager) SetValuesForKeysWithDictionary(keyedValues *NSDictionary)  {
	C.CBPeripheralManager_inst_SetValuesForKeysWithDictionary(o.Ptr(), keyedValues.Ptr())
	runtime.KeepAlive(o)
}

func (o *CBPeripheralManager) ReplacementObjectForCoder(coder *NSCoder) *Id {
	ret := &Id{}
	ret.ptr = unsafe.Pointer(C.CBPeripheralManager_inst_ReplacementObjectForCoder(o.Ptr(), coder.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *Id) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *CBPeripheralManager) StopAdvertising()  {
	C.CBPeripheralManager_inst_StopAdvertising(o.Ptr())
	runtime.KeepAlive(o)
}

func (o *CBPeripheralManager) StartAdvertising(advertisementData *NSDictionary)  {
	C.CBPeripheralManager_inst_StartAdvertising(o.Ptr(), advertisementData.Ptr())
	runtime.KeepAlive(o)
}

func (o *CBPeripheralManager) MutableOrderedSetValueForKey(key *NSString) *NSMutableOrderedSet {
	ret := &NSMutableOrderedSet{}
	ret.ptr = unsafe.Pointer(C.CBPeripheralManager_inst_MutableOrderedSetValueForKey(o.Ptr(), key.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSMutableOrderedSet)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *NSMutableOrderedSet) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *CBPeripheralManager) ClassForCoder() Class {
	ret := (Class)(unsafe.Pointer(C.CBPeripheralManager_inst_ClassForCoder(o.Ptr())))
	runtime.KeepAlive(o)
	return ret
}

func (o *CBPeripheralManager) MutableArrayValueForKeyPath(keyPath *NSString) *NSMutableArray {
	ret := &NSMutableArray{}
	ret.ptr = unsafe.Pointer(C.CBPeripheralManager_inst_MutableArrayValueForKeyPath(o.Ptr(), keyPath.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSMutableArray)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *NSMutableArray) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *CBPeripheralManager) State() CBManagerState {
	ret := (CBManagerState)(C.CBPeripheralManager_inst_State(o.Ptr()))
	runtime.KeepAlive(o)
	return ret
}

func (o *CBPeripheralManager) MutableSetValueForKeyPath(keyPath *NSString) *NSMutableSet {
	ret := &NSMutableSet{}
	ret.ptr = unsafe.Pointer(C.CBPeripheralManager_inst_MutableSetValueForKeyPath(o.Ptr(), keyPath.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSMutableSet)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *NSMutableSet) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *CBPeripheralManager) ValueForUndefinedKey(key *NSString) *Id {
	ret := &Id{}
	ret.ptr = unsafe.Pointer(C.CBPeripheralManager_inst_ValueForUndefinedKey(o.Ptr(), key.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *Id) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *CBPeripheralManager) IsLessThanOrEqualTo(object NSObject) bool {
	ret := (bool)(C.CBPeripheralManager_inst_IsLessThanOrEqualTo(o.Ptr(), object.Ptr()))
	runtime.KeepAlive(o)
	return ret
}

func (o *CBPeripheralManager) ScriptingEndsWith(object NSObject) bool {
	ret := (bool)(C.CBPeripheralManager_inst_ScriptingEndsWith(o.Ptr(), object.Ptr()))
	runtime.KeepAlive(o)
	return ret
}

func (o *CBPeripheralManager) ValueWithNameInPropertyWithKey(name *NSString, key *NSString) *Id {
	ret := &Id{}
	ret.ptr = unsafe.Pointer(C.CBPeripheralManager_inst_ValueWithNameInPropertyWithKey(o.Ptr(), name.Ptr(), key.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *Id) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *CBPeripheralManager) ScriptingIsGreaterThanOrEqualTo(object NSObject) bool {
	ret := (bool)(C.CBPeripheralManager_inst_ScriptingIsGreaterThanOrEqualTo(o.Ptr(), object.Ptr()))
	runtime.KeepAlive(o)
	return ret
}

func (o *CBPeripheralManager) AddService(service *CBMutableService)  {
	C.CBPeripheralManager_inst_AddService(o.Ptr(), service.Ptr())
	runtime.KeepAlive(o)
}

func (o *CBPeripheralManager) ClassCode() FourCharCode {
	ret := (FourCharCode)(C.CBPeripheralManager_inst_ClassCode(o.Ptr()))
	runtime.KeepAlive(o)
	return ret
}

func (o *CBPeripheralManager) MethodSignatureForSelector(aSelector SEL) *NSMethodSignature {
	ret := &NSMethodSignature{}
	ret.ptr = unsafe.Pointer(C.CBPeripheralManager_inst_MethodSignatureForSelector(o.Ptr(), unsafe.Pointer(aSelector)))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSMethodSignature)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *NSMethodSignature) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *CBPeripheralManager) ClassForArchiver() Class {
	ret := (Class)(unsafe.Pointer(C.CBPeripheralManager_inst_ClassForArchiver(o.Ptr())))
	runtime.KeepAlive(o)
	return ret
}

func (o *CBPeripheralManager) SetDesiredConnectionLatency(latency CBPeripheralManagerConnectionLatency, central *CBCentral)  {
	C.CBPeripheralManager_inst_SetDesiredConnectionLatency(o.Ptr(), (C.CBPeripheralManagerConnectionLatency)(latency), central.Ptr())
	runtime.KeepAlive(o)
}

func (o *CBPeripheralManager) RemoveValueAtIndexFromPropertyWithKey(index NSUInteger, key *NSString)  {
	C.CBPeripheralManager_inst_RemoveValueAtIndexFromPropertyWithKey(o.Ptr(), (C.NSUInteger)(index), key.Ptr())
	runtime.KeepAlive(o)
}

func (o *CBPeripheralManager) RemoveAllServices()  {
	C.CBPeripheralManager_inst_RemoveAllServices(o.Ptr())
	runtime.KeepAlive(o)
}

func (o *CBPeripheralManager) ValueForKey(key *NSString) *Id {
	ret := &Id{}
	ret.ptr = unsafe.Pointer(C.CBPeripheralManager_inst_ValueForKey(o.Ptr(), key.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *Id) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *CBPeripheralManager) AwakeAfterUsingCoder(coder *NSCoder) *Id {
	ret := &Id{}
	ret.ptr = unsafe.Pointer(C.CBPeripheralManager_inst_AwakeAfterUsingCoder(o.Ptr(), coder.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *Id) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *CBPeripheralManager) IsLike(object *NSString) bool {
	ret := (bool)(C.CBPeripheralManager_inst_IsLike(o.Ptr(), object.Ptr()))
	runtime.KeepAlive(o)
	return ret
}

func (o *CBPeripheralManager) AttemptRecoveryFromErrorOptionIndex(error *NSError, recoveryOptionIndex NSUInteger) bool {
	ret := (bool)(C.CBPeripheralManager_inst_AttemptRecoveryFromErrorOptionIndex(o.Ptr(), error.Ptr(), (C.NSUInteger)(recoveryOptionIndex)))
	runtime.KeepAlive(o)
	return ret
}

func (o *CBPeripheralManager) AttemptRecoveryFromErrorOptionIndexDelegate(error *NSError, recoveryOptionIndex NSUInteger, delegate NSObject, didRecoverSelector SEL, contextInfo unsafe.Pointer)  {
	C.CBPeripheralManager_inst_AttemptRecoveryFromErrorOptionIndexDelegate(o.Ptr(), error.Ptr(), (C.NSUInteger)(recoveryOptionIndex), delegate.Ptr(), unsafe.Pointer(didRecoverSelector), unsafe.Pointer(contextInfo))
	runtime.KeepAlive(o)
}

func (o *CBPeripheralManager) AttemptRecoveryFromErrorOptionIndexDelegateDidRecoverSelector(error *NSError, recoveryOptionIndex NSUInteger, delegate NSObject, didRecoverSelector SEL, contextInfo unsafe.Pointer)  {
	C.CBPeripheralManager_inst_AttemptRecoveryFromErrorOptionIndexDelegateDidRecoverSelector(o.Ptr(), error.Ptr(), (C.NSUInteger)(recoveryOptionIndex), delegate.Ptr(), unsafe.Pointer(didRecoverSelector), unsafe.Pointer(contextInfo))
	runtime.KeepAlive(o)
}

func (o *CBPeripheralManager) AttemptRecoveryFromErrorOptionIndexDelegateDidRecoverSelectorContextInfo(error *NSError, recoveryOptionIndex NSUInteger, delegate NSObject, didRecoverSelector SEL, contextInfo unsafe.Pointer)  {
	C.CBPeripheralManager_inst_AttemptRecoveryFromErrorOptionIndexDelegateDidRecoverSelectorContextInfo(o.Ptr(), error.Ptr(), (C.NSUInteger)(recoveryOptionIndex), delegate.Ptr(), unsafe.Pointer(didRecoverSelector), unsafe.Pointer(contextInfo))
	runtime.KeepAlive(o)
}

func (o *CBPeripheralManager) Dealloc()  {
	C.CBPeripheralManager_inst_Dealloc(o.Ptr())
	runtime.KeepAlive(o)
}

func (o *CBPeripheralManager) RemoveService(service *CBMutableService)  {
	C.CBPeripheralManager_inst_RemoveService(o.Ptr(), service.Ptr())
	runtime.KeepAlive(o)
}

func (o *CBPeripheralManager) UnpublishL2CAPChannel(PSM CBL2CAPPSM)  {
	C.CBPeripheralManager_inst_UnpublishL2CAPChannel(o.Ptr(), (C.CBL2CAPPSM)(PSM))
	runtime.KeepAlive(o)
}

func (o *CBPeripheralManager) ValueAtIndexInPropertyWithKey(index NSUInteger, key *NSString) *Id {
	ret := &Id{}
	ret.ptr = unsafe.Pointer(C.CBPeripheralManager_inst_ValueAtIndexInPropertyWithKey(o.Ptr(), (C.NSUInteger)(index), key.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *Id) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *CBPeripheralManager) InverseForRelationshipKey(relationshipKey *NSString) *NSString {
	ret := &NSString{}
	ret.ptr = unsafe.Pointer(C.CBPeripheralManager_inst_InverseForRelationshipKey(o.Ptr(), relationshipKey.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSString)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *NSString) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *CBPeripheralManager) IndicesOfObjectsByEvaluatingObjectSpecifier(specifier *NSScriptObjectSpecifier) *NSArray {
	ret := &NSArray{}
	ret.ptr = unsafe.Pointer(C.CBPeripheralManager_inst_IndicesOfObjectsByEvaluatingObjectSpecifier(o.Ptr(), specifier.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSArray)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *NSArray) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *CBPeripheralManager) UpdateValue(value *NSData, characteristic *CBMutableCharacteristic, centrals *NSArray) bool {
	ret := (bool)(C.CBPeripheralManager_inst_UpdateValue(o.Ptr(), value.Ptr(), characteristic.Ptr(), centrals.Ptr()))
	runtime.KeepAlive(o)
	return ret
}

func (o *CBPeripheralManager) PerformSelectorWithObject(aSelector SEL, anArgument NSObject, delay NSTimeInterval)  {
	C.CBPeripheralManager_inst_PerformSelectorWithObject(o.Ptr(), unsafe.Pointer(aSelector), anArgument.Ptr(), (C.NSTimeInterval)(delay))
	runtime.KeepAlive(o)
}

func (o *CBPeripheralManager) PerformSelectorWithObjectAfterDelay(aSelector SEL, anArgument NSObject, delay NSTimeInterval)  {
	C.CBPeripheralManager_inst_PerformSelectorWithObjectAfterDelay(o.Ptr(), unsafe.Pointer(aSelector), anArgument.Ptr(), (C.NSTimeInterval)(delay))
	runtime.KeepAlive(o)
}

func (o *CBPeripheralManager) PerformSelectorWithObjectAfterDelayInModes(aSelector SEL, anArgument NSObject, delay NSTimeInterval, modes *NSArray)  {
	C.CBPeripheralManager_inst_PerformSelectorWithObjectAfterDelayInModes(o.Ptr(), unsafe.Pointer(aSelector), anArgument.Ptr(), (C.NSTimeInterval)(delay), modes.Ptr())
	runtime.KeepAlive(o)
}

func (o *CBPeripheralManager) PerformSelectorOnThread(aSelector SEL, thr *NSThread, arg NSObject, wait BOOL)  {
	C.CBPeripheralManager_inst_PerformSelectorOnThread(o.Ptr(), unsafe.Pointer(aSelector), thr.Ptr(), arg.Ptr(), (C.BOOL)(wait))
	runtime.KeepAlive(o)
}

func (o *CBPeripheralManager) PerformSelectorOnThreadWithObject(aSelector SEL, thr *NSThread, arg NSObject, wait BOOL)  {
	C.CBPeripheralManager_inst_PerformSelectorOnThreadWithObject(o.Ptr(), unsafe.Pointer(aSelector), thr.Ptr(), arg.Ptr(), (C.BOOL)(wait))
	runtime.KeepAlive(o)
}

func (o *CBPeripheralManager) PerformSelectorOnThreadWithObjectWaitUntilDone(aSelector SEL, thr *NSThread, arg NSObject, wait BOOL)  {
	C.CBPeripheralManager_inst_PerformSelectorOnThreadWithObjectWaitUntilDone(o.Ptr(), unsafe.Pointer(aSelector), thr.Ptr(), arg.Ptr(), (C.BOOL)(wait))
	runtime.KeepAlive(o)
}

func (o *CBPeripheralManager) PerformSelectorOnThreadWithObjectWaitUntilDoneModes(aSelector SEL, thr *NSThread, arg NSObject, wait BOOL, array *NSArray)  {
	C.CBPeripheralManager_inst_PerformSelectorOnThreadWithObjectWaitUntilDoneModes(o.Ptr(), unsafe.Pointer(aSelector), thr.Ptr(), arg.Ptr(), (C.BOOL)(wait), array.Ptr())
	runtime.KeepAlive(o)
}

func (o *CBPeripheralManager) ForwardInvocation(anInvocation *NSInvocation)  {
	C.CBPeripheralManager_inst_ForwardInvocation(o.Ptr(), anInvocation.Ptr())
	runtime.KeepAlive(o)
}

func (o *CBPeripheralManager) AttributeKeys() *NSArray {
	ret := &NSArray{}
	ret.ptr = unsafe.Pointer(C.CBPeripheralManager_inst_AttributeKeys(o.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSArray)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *NSArray) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *CBPeripheralManager) ValueWithUniqueIDInPropertyWithKey(uniqueID NSObject, key *NSString) *Id {
	ret := &Id{}
	ret.ptr = unsafe.Pointer(C.CBPeripheralManager_inst_ValueWithUniqueIDInPropertyWithKey(o.Ptr(), uniqueID.Ptr(), key.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *Id) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *CBPeripheralManager) ToManyRelationshipKeys() *NSArray {
	ret := &NSArray{}
	ret.ptr = unsafe.Pointer(C.CBPeripheralManager_inst_ToManyRelationshipKeys(o.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSArray)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *NSArray) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *CBPeripheralManager) IsCaseInsensitiveLike(object *NSString) bool {
	ret := (bool)(C.CBPeripheralManager_inst_IsCaseInsensitiveLike(o.Ptr(), object.Ptr()))
	runtime.KeepAlive(o)
	return ret
}

func (o *CBPeripheralManager) IsGreaterThanOrEqualTo(object NSObject) bool {
	ret := (bool)(C.CBPeripheralManager_inst_IsGreaterThanOrEqualTo(o.Ptr(), object.Ptr()))
	runtime.KeepAlive(o)
	return ret
}

func (o *CBPeripheralManager) IsAdvertising() bool {
	ret := (bool)(C.CBPeripheralManager_inst_IsAdvertising(o.Ptr()))
	runtime.KeepAlive(o)
	return ret
}

func (o *CBPeripheralManager) SetDelegate(delegate NSObject)  {
	C.CBPeripheralManager_inst_SetDelegate(o.Ptr(), delegate.Ptr())
	runtime.KeepAlive(o)
}

func (o *CBPeripheralManager) DidChangeValuesAtIndexes(changeKind NSKeyValueChange, indexes *NSIndexSet, key *NSString)  {
	C.CBPeripheralManager_inst_DidChangeValuesAtIndexes(o.Ptr(), (C.NSKeyValueChange)(changeKind), indexes.Ptr(), key.Ptr())
	runtime.KeepAlive(o)
}

func (o *CBPeripheralManager) DidChangeValuesAtIndexesForKey(changeKind NSKeyValueChange, indexes *NSIndexSet, key *NSString)  {
	C.CBPeripheralManager_inst_DidChangeValuesAtIndexesForKey(o.Ptr(), (C.NSKeyValueChange)(changeKind), indexes.Ptr(), key.Ptr())
	runtime.KeepAlive(o)
}

func (o *CBPeripheralManager) DoesNotRecognizeSelector(aSelector SEL)  {
	C.CBPeripheralManager_inst_DoesNotRecognizeSelector(o.Ptr(), unsafe.Pointer(aSelector))
	runtime.KeepAlive(o)
}

func (o *CBPeripheralManager) IsGreaterThan(object NSObject) bool {
	ret := (bool)(C.CBPeripheralManager_inst_IsGreaterThan(o.Ptr(), object.Ptr()))
	runtime.KeepAlive(o)
	return ret
}

func (o *CBPeripheralManager) InsertValueInPropertyWithKey(value NSObject, key *NSString)  {
	C.CBPeripheralManager_inst_InsertValueInPropertyWithKey(o.Ptr(), value.Ptr(), key.Ptr())
	runtime.KeepAlive(o)
}

func (o *CBPeripheralManager) InsertValueAtIndex(value NSObject, index NSUInteger, key *NSString)  {
	C.CBPeripheralManager_inst_InsertValueAtIndex(o.Ptr(), value.Ptr(), (C.NSUInteger)(index), key.Ptr())
	runtime.KeepAlive(o)
}

func (o *CBPeripheralManager) InsertValueAtIndexInPropertyWithKey(value NSObject, index NSUInteger, key *NSString)  {
	C.CBPeripheralManager_inst_InsertValueAtIndexInPropertyWithKey(o.Ptr(), value.Ptr(), (C.NSUInteger)(index), key.Ptr())
	runtime.KeepAlive(o)
}

func (o *CBPeripheralManager) ScriptingIsGreaterThan(object NSObject) bool {
	ret := (bool)(C.CBPeripheralManager_inst_ScriptingIsGreaterThan(o.Ptr(), object.Ptr()))
	runtime.KeepAlive(o)
	return ret
}

func (o *CBPeripheralManager) RespondToRequest(request *CBATTRequest, result CBATTError)  {
	C.CBPeripheralManager_inst_RespondToRequest(o.Ptr(), request.Ptr(), (C.CBATTError)(result))
	runtime.KeepAlive(o)
}

func (o *CBPeripheralManager) ToOneRelationshipKeys() *NSArray {
	ret := &NSArray{}
	ret.ptr = unsafe.Pointer(C.CBPeripheralManager_inst_ToOneRelationshipKeys(o.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSArray)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *NSArray) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *CBPeripheralManager) ReplaceValueAtIndexInPropertyWithKey(index NSUInteger, key *NSString, value NSObject)  {
	C.CBPeripheralManager_inst_ReplaceValueAtIndexInPropertyWithKey(o.Ptr(), (C.NSUInteger)(index), key.Ptr(), value.Ptr())
	runtime.KeepAlive(o)
}

func (o *CBPeripheralManager) ReplaceValueAtIndexInPropertyWithKeyWithValue(index NSUInteger, key *NSString, value NSObject)  {
	C.CBPeripheralManager_inst_ReplaceValueAtIndexInPropertyWithKeyWithValue(o.Ptr(), (C.NSUInteger)(index), key.Ptr(), value.Ptr())
	runtime.KeepAlive(o)
}

func (o *CBPeripheralManager) IsNotEqualTo(object NSObject) bool {
	ret := (bool)(C.CBPeripheralManager_inst_IsNotEqualTo(o.Ptr(), object.Ptr()))
	runtime.KeepAlive(o)
	return ret
}

func (o *CBPeripheralManager) DidChangeValueForKey(key *NSString)  {
	C.CBPeripheralManager_inst_DidChangeValueForKey(o.Ptr(), key.Ptr())
	runtime.KeepAlive(o)
}

func (o *CBPeripheralManager) DidChangeValueForKeyWithSetMutation(key *NSString, mutationKind NSKeyValueSetMutationKind, objects *NSSet)  {
	C.CBPeripheralManager_inst_DidChangeValueForKeyWithSetMutation(o.Ptr(), key.Ptr(), (C.NSKeyValueSetMutationKind)(mutationKind), objects.Ptr())
	runtime.KeepAlive(o)
}

func (o *CBPeripheralManager) DidChangeValueForKeyWithSetMutationUsingObjects(key *NSString, mutationKind NSKeyValueSetMutationKind, objects *NSSet)  {
	C.CBPeripheralManager_inst_DidChangeValueForKeyWithSetMutationUsingObjects(o.Ptr(), key.Ptr(), (C.NSKeyValueSetMutationKind)(mutationKind), objects.Ptr())
	runtime.KeepAlive(o)
}

func (o *CBPeripheralManager) ObjectSpecifier() *NSScriptObjectSpecifier {
	ret := &NSScriptObjectSpecifier{}
	ret.ptr = unsafe.Pointer(C.CBPeripheralManager_inst_ObjectSpecifier(o.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSScriptObjectSpecifier)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *NSScriptObjectSpecifier) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *CBPeripheralManager) ScriptingValueForSpecifier(objectSpecifier *NSScriptObjectSpecifier) *Id {
	ret := &Id{}
	ret.ptr = unsafe.Pointer(C.CBPeripheralManager_inst_ScriptingValueForSpecifier(o.Ptr(), objectSpecifier.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *Id) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *CBPeripheralManager) MutableArrayValueForKey(key *NSString) *NSMutableArray {
	ret := &NSMutableArray{}
	ret.ptr = unsafe.Pointer(C.CBPeripheralManager_inst_MutableArrayValueForKey(o.Ptr(), key.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSMutableArray)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *NSMutableArray) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *CBPeripheralManager) ObservationInfo() unsafe.Pointer {
	ret := (unsafe.Pointer)(unsafe.Pointer(C.CBPeripheralManager_inst_ObservationInfo(o.Ptr())))
	runtime.KeepAlive(o)
	return ret
}

func (o *CBPeripheralManager) ForwardingTargetForSelector(aSelector SEL) *Id {
	ret := &Id{}
	ret.ptr = unsafe.Pointer(C.CBPeripheralManager_inst_ForwardingTargetForSelector(o.Ptr(), unsafe.Pointer(aSelector)))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *Id) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *CBPeripheralManager) ScriptingContains(object NSObject) bool {
	ret := (bool)(C.CBPeripheralManager_inst_ScriptingContains(o.Ptr(), object.Ptr()))
	runtime.KeepAlive(o)
	return ret
}

func (o *CBPeripheralManager) PerformSelectorInBackgroundWithObject(aSelector SEL, arg NSObject)  {
	C.CBPeripheralManager_inst_PerformSelectorInBackgroundWithObject(o.Ptr(), unsafe.Pointer(aSelector), arg.Ptr())
	runtime.KeepAlive(o)
}

func (o *CBPeripheralManager) MutableOrderedSetValueForKeyPath(keyPath *NSString) *NSMutableOrderedSet {
	ret := &NSMutableOrderedSet{}
	ret.ptr = unsafe.Pointer(C.CBPeripheralManager_inst_MutableOrderedSetValueForKeyPath(o.Ptr(), keyPath.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSMutableOrderedSet)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *NSMutableOrderedSet) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *CBPeripheralManager) ValidateValueForKey(ioValue *[]*Id, inKey *NSString, outError *[]*NSError) bool {

	goSlice1 := make([]unsafe.Pointer,cap(*ioValue))
	for i := 0; i < len(*ioValue); i++ {
		goSlice1[i] = (*ioValue)[i].Ptr()
	}

	goSlice3 := make([]unsafe.Pointer,cap(*outError))
	for i := 0; i < len(*outError); i++ {
		goSlice3[i] = (*outError)[i].Ptr()
	}
	ret := (bool)(C.CBPeripheralManager_inst_ValidateValueForKey(o.Ptr(), (*unsafe.Pointer)(unsafe.Pointer(&goSlice1[0])), inKey.Ptr(), (*unsafe.Pointer)(unsafe.Pointer(&goSlice3[0]))))
	(*ioValue) = (*ioValue)[:cap(*ioValue)]
	for i := 0; i < len(*ioValue); i++ {
		if goSlice1[i] == nil {
			(*ioValue) = (*ioValue)[:i]
			break
		}
		if (*ioValue)[i] == nil {
			(*ioValue)[i] = &Id{}
			runtime.SetFinalizer((*ioValue)[i], func(o *Id) {
				o.Release()
			})
		}
		(*ioValue)[i].ptr = goSlice1[i]
	}
	(*outError) = (*outError)[:cap(*outError)]
	for i := 0; i < len(*outError); i++ {
		if goSlice3[i] == nil {
			(*outError) = (*outError)[:i]
			break
		}
		if (*outError)[i] == nil {
			(*outError)[i] = &NSError{}
			runtime.SetFinalizer((*outError)[i], func(o *NSError) {
				o.Release()
			})
		}
		(*outError)[i].ptr = goSlice3[i]
	}
	runtime.KeepAlive(o)
	return ret
}

func (o *CBPeripheralManager) ValidateValueForKeyPath(ioValue *[]*Id, inKeyPath *NSString, outError *[]*NSError) bool {

	goSlice1 := make([]unsafe.Pointer,cap(*ioValue))
	for i := 0; i < len(*ioValue); i++ {
		goSlice1[i] = (*ioValue)[i].Ptr()
	}

	goSlice3 := make([]unsafe.Pointer,cap(*outError))
	for i := 0; i < len(*outError); i++ {
		goSlice3[i] = (*outError)[i].Ptr()
	}
	ret := (bool)(C.CBPeripheralManager_inst_ValidateValueForKeyPath(o.Ptr(), (*unsafe.Pointer)(unsafe.Pointer(&goSlice1[0])), inKeyPath.Ptr(), (*unsafe.Pointer)(unsafe.Pointer(&goSlice3[0]))))
	(*ioValue) = (*ioValue)[:cap(*ioValue)]
	for i := 0; i < len(*ioValue); i++ {
		if goSlice1[i] == nil {
			(*ioValue) = (*ioValue)[:i]
			break
		}
		if (*ioValue)[i] == nil {
			(*ioValue)[i] = &Id{}
			runtime.SetFinalizer((*ioValue)[i], func(o *Id) {
				o.Release()
			})
		}
		(*ioValue)[i].ptr = goSlice1[i]
	}
	(*outError) = (*outError)[:cap(*outError)]
	for i := 0; i < len(*outError); i++ {
		if goSlice3[i] == nil {
			(*outError) = (*outError)[:i]
			break
		}
		if (*outError)[i] == nil {
			(*outError)[i] = &NSError{}
			runtime.SetFinalizer((*outError)[i], func(o *NSError) {
				o.Release()
			})
		}
		(*outError)[i].ptr = goSlice3[i]
	}
	runtime.KeepAlive(o)
	return ret
}

func (o *CBPeripheralManager) ValidateValueForKeyError(ioValue *[]*Id, inKey *NSString, outError *[]*NSError) bool {

	goSlice1 := make([]unsafe.Pointer,cap(*ioValue))
	for i := 0; i < len(*ioValue); i++ {
		goSlice1[i] = (*ioValue)[i].Ptr()
	}

	goSlice3 := make([]unsafe.Pointer,cap(*outError))
	for i := 0; i < len(*outError); i++ {
		goSlice3[i] = (*outError)[i].Ptr()
	}
	ret := (bool)(C.CBPeripheralManager_inst_ValidateValueForKeyError(o.Ptr(), (*unsafe.Pointer)(unsafe.Pointer(&goSlice1[0])), inKey.Ptr(), (*unsafe.Pointer)(unsafe.Pointer(&goSlice3[0]))))
	(*ioValue) = (*ioValue)[:cap(*ioValue)]
	for i := 0; i < len(*ioValue); i++ {
		if goSlice1[i] == nil {
			(*ioValue) = (*ioValue)[:i]
			break
		}
		if (*ioValue)[i] == nil {
			(*ioValue)[i] = &Id{}
			runtime.SetFinalizer((*ioValue)[i], func(o *Id) {
				o.Release()
			})
		}
		(*ioValue)[i].ptr = goSlice1[i]
	}
	(*outError) = (*outError)[:cap(*outError)]
	for i := 0; i < len(*outError); i++ {
		if goSlice3[i] == nil {
			(*outError) = (*outError)[:i]
			break
		}
		if (*outError)[i] == nil {
			(*outError)[i] = &NSError{}
			runtime.SetFinalizer((*outError)[i], func(o *NSError) {
				o.Release()
			})
		}
		(*outError)[i].ptr = goSlice3[i]
	}
	runtime.KeepAlive(o)
	return ret
}

func (o *CBPeripheralManager) ValidateValueForKeyPathError(ioValue *[]*Id, inKeyPath *NSString, outError *[]*NSError) bool {

	goSlice1 := make([]unsafe.Pointer,cap(*ioValue))
	for i := 0; i < len(*ioValue); i++ {
		goSlice1[i] = (*ioValue)[i].Ptr()
	}

	goSlice3 := make([]unsafe.Pointer,cap(*outError))
	for i := 0; i < len(*outError); i++ {
		goSlice3[i] = (*outError)[i].Ptr()
	}
	ret := (bool)(C.CBPeripheralManager_inst_ValidateValueForKeyPathError(o.Ptr(), (*unsafe.Pointer)(unsafe.Pointer(&goSlice1[0])), inKeyPath.Ptr(), (*unsafe.Pointer)(unsafe.Pointer(&goSlice3[0]))))
	(*ioValue) = (*ioValue)[:cap(*ioValue)]
	for i := 0; i < len(*ioValue); i++ {
		if goSlice1[i] == nil {
			(*ioValue) = (*ioValue)[:i]
			break
		}
		if (*ioValue)[i] == nil {
			(*ioValue)[i] = &Id{}
			runtime.SetFinalizer((*ioValue)[i], func(o *Id) {
				o.Release()
			})
		}
		(*ioValue)[i].ptr = goSlice1[i]
	}
	(*outError) = (*outError)[:cap(*outError)]
	for i := 0; i < len(*outError); i++ {
		if goSlice3[i] == nil {
			(*outError) = (*outError)[:i]
			break
		}
		if (*outError)[i] == nil {
			(*outError)[i] = &NSError{}
			runtime.SetFinalizer((*outError)[i], func(o *NSError) {
				o.Release()
			})
		}
		(*outError)[i].ptr = goSlice3[i]
	}
	runtime.KeepAlive(o)
	return ret
}

func (o *CBPeripheralManager) Authorization() CBManagerAuthorization {
	ret := (CBManagerAuthorization)(C.CBPeripheralManager_inst_Authorization(o.Ptr()))
	runtime.KeepAlive(o)
	return ret
}

func (o *CBPeripheralManager) MutableSetValueForKey(key *NSString) *NSMutableSet {
	ret := &NSMutableSet{}
	ret.ptr = unsafe.Pointer(C.CBPeripheralManager_inst_MutableSetValueForKey(o.Ptr(), key.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSMutableSet)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *NSMutableSet) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *CBPeripheralManager) ClassName() *NSString {
	ret := &NSString{}
	ret.ptr = unsafe.Pointer(C.CBPeripheralManager_inst_ClassName(o.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSString)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *NSString) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *CBPeripheralManager) ClassDescription() *NSClassDescription {
	ret := &NSClassDescription{}
	ret.ptr = unsafe.Pointer(C.CBPeripheralManager_inst_ClassDescription(o.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSClassDescription)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *NSClassDescription) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *CBPeripheralManager) InitWithDelegateQueue(delegate NSObject, queue Dispatch_queue_t) *CBPeripheralManager {
	ret := &CBPeripheralManager{}
	ret.ptr = unsafe.Pointer(C.CBPeripheralManager_inst_InitWithDelegateQueue(o.Ptr(), delegate.Ptr(), queue.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*CBPeripheralManager)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *CBPeripheralManager) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *CBPeripheralManager) InitWithDelegateQueueOptions(delegate NSObject, queue Dispatch_queue_t, options *NSDictionary) *CBPeripheralManager {
	ret := &CBPeripheralManager{}
	ret.ptr = unsafe.Pointer(C.CBPeripheralManager_inst_InitWithDelegateQueueOptions(o.Ptr(), delegate.Ptr(), queue.Ptr(), options.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*CBPeripheralManager)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *CBPeripheralManager) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *CBPeripheralManager) Copy() *Id {
	ret := &Id{}
	ret.ptr = unsafe.Pointer(C.CBPeripheralManager_inst_Copy(o.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	runtime.SetFinalizer(ret, func(o *Id) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func CBPeripheralSuperclass() Class {
	ret := (Class)(unsafe.Pointer(C.CBPeripheral_Superclass()))
	return ret
}

func CBPeripheralConformsToProtocol(protocol Protocol) bool {
	ret := (bool)(C.CBPeripheral_ConformsToProtocol(protocol.Ptr()))
	return ret
}

func CBPeripheralCancelPreviousPerformRequestsWithTarget(aTarget NSObject)  {
	C.CBPeripheral_CancelPreviousPerformRequestsWithTarget(aTarget.Ptr())
}

func CBPeripheralCancelPreviousPerformRequestsWithTargetSelector(aTarget NSObject, aSelector SEL, anArgument NSObject)  {
	C.CBPeripheral_CancelPreviousPerformRequestsWithTargetSelector(aTarget.Ptr(), unsafe.Pointer(aSelector), anArgument.Ptr())
}

func CBPeripheralCancelPreviousPerformRequestsWithTargetSelectorObject(aTarget NSObject, aSelector SEL, anArgument NSObject)  {
	C.CBPeripheral_CancelPreviousPerformRequestsWithTargetSelectorObject(aTarget.Ptr(), unsafe.Pointer(aSelector), anArgument.Ptr())
}

func CBPeripheralVersion() NSInteger {
	ret := (NSInteger)(C.CBPeripheral_Version())
	return ret
}

func CBPeripheralDebugDescription() *NSString {
	ret := &NSString{}
	ret.ptr = unsafe.Pointer(C.CBPeripheral_DebugDescription())
	if ret.ptr == nil { return ret }
	return ret
}

func CBPeripheralDescription() *NSString {
	ret := &NSString{}
	ret.ptr = unsafe.Pointer(C.CBPeripheral_Description())
	if ret.ptr == nil { return ret }
	return ret
}

func CBPeripheralClass() Class {
	ret := (Class)(unsafe.Pointer(C.CBPeripheral_Class()))
	return ret
}

func CBPeripheralHash() NSUInteger {
	ret := (NSUInteger)(C.CBPeripheral_Hash())
	return ret
}

func CBPeripheralAutomaticallyNotifiesObserversForKey(key *NSString) bool {
	ret := (bool)(C.CBPeripheral_AutomaticallyNotifiesObserversForKey(key.Ptr()))
	return ret
}

func CBPeripheralLoad()  {
	C.CBPeripheral_Load()
}

func CBPeripheralAlloc() *CBPeripheral {
	ret := &CBPeripheral{}
	ret.ptr = unsafe.Pointer(C.CBPeripheral_Alloc())
	if ret.ptr == nil { return ret }
	runtime.SetFinalizer(ret, func(o *CBPeripheral) {
		o.Release()
	})
	return ret
}

func (o *CBPeripheral) GC() {
	if o.ptr == nil { return }
	runtime.SetFinalizer(o, func(o *CBPeripheral) {
		o.Release()
	})
	runtime.KeepAlive(o)
}

func CBPeripheralCopyWithZone(zone *_NSZone) *Id {
	ret := &Id{}
	ret.ptr = unsafe.Pointer(C.CBPeripheral_CopyWithZone(unsafe.Pointer(zone)))
	if ret.ptr == nil { return ret }
	runtime.SetFinalizer(ret, func(o *Id) {
		o.Release()
	})
	return ret
}

func CBPeripheralAccessInstanceVariablesDirectly() bool {
	ret := (bool)(C.CBPeripheral_AccessInstanceVariablesDirectly())
	return ret
}

func CBPeripheralClassFallbacksForKeyedArchiver() *NSArray {
	ret := &NSArray{}
	ret.ptr = unsafe.Pointer(C.CBPeripheral_ClassFallbacksForKeyedArchiver())
	if ret.ptr == nil { return ret }
	return ret
}

func CBPeripheralSetVersion(aVersion NSInteger)  {
	C.CBPeripheral_SetVersion((C.NSInteger)(aVersion))
}

func CBPeripheralKeyPathsForValuesAffectingValueForKey(key *NSString) *NSSet {
	ret := &NSSet{}
	ret.ptr = unsafe.Pointer(C.CBPeripheral_KeyPathsForValuesAffectingValueForKey(key.Ptr()))
	if ret.ptr == nil { return ret }
	return ret
}

func CBPeripheralClassForKeyedUnarchiver() Class {
	ret := (Class)(unsafe.Pointer(C.CBPeripheral_ClassForKeyedUnarchiver()))
	return ret
}

func CBPeripheralResolveInstanceMethod(sel SEL) bool {
	ret := (bool)(C.CBPeripheral_ResolveInstanceMethod(unsafe.Pointer(sel)))
	return ret
}

func CBPeripheralIsSubclassOfClass(aClass Class) bool {
	ret := (bool)(C.CBPeripheral_IsSubclassOfClass(unsafe.Pointer(aClass)))
	return ret
}

func CBPeripheralMutableCopyWithZone(zone *_NSZone) *Id {
	ret := &Id{}
	ret.ptr = unsafe.Pointer(C.CBPeripheral_MutableCopyWithZone(unsafe.Pointer(zone)))
	if ret.ptr == nil { return ret }
	runtime.SetFinalizer(ret, func(o *Id) {
		o.Release()
	})
	return ret
}

func CBPeripheralInstanceMethodSignatureForSelector(aSelector SEL) *NSMethodSignature {
	ret := &NSMethodSignature{}
	ret.ptr = unsafe.Pointer(C.CBPeripheral_InstanceMethodSignatureForSelector(unsafe.Pointer(aSelector)))
	if ret.ptr == nil { return ret }
	return ret
}

func CBPeripheralInstancesRespondToSelector(aSelector SEL) bool {
	ret := (bool)(C.CBPeripheral_InstancesRespondToSelector(unsafe.Pointer(aSelector)))
	return ret
}

func CBPeripheralNew() *CBPeripheral {
	ret := &CBPeripheral{}
	ret.ptr = unsafe.Pointer(C.CBPeripheral_New())
	if ret.ptr == nil { return ret }
	runtime.SetFinalizer(ret, func(o *CBPeripheral) {
		o.Release()
	})
	return ret
}

func CBPeripheralResolveClassMethod(sel SEL) bool {
	ret := (bool)(C.CBPeripheral_ResolveClassMethod(unsafe.Pointer(sel)))
	return ret
}

func CBPeripheralAllocWithZone(zone *_NSZone) *CBPeripheral {
	ret := &CBPeripheral{}
	ret.ptr = unsafe.Pointer(C.CBPeripheral_AllocWithZone(unsafe.Pointer(zone)))
	if ret.ptr == nil { return ret }
	runtime.SetFinalizer(ret, func(o *CBPeripheral) {
		o.Release()
	})
	return ret
}

func (o *CBPeripheral) MutableArrayValueForKeyPath(keyPath *NSString) *NSMutableArray {
	ret := &NSMutableArray{}
	ret.ptr = unsafe.Pointer(C.CBPeripheral_inst_MutableArrayValueForKeyPath(o.Ptr(), keyPath.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSMutableArray)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *NSMutableArray) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *CBPeripheral) SetNotifyValue(enabled BOOL, characteristic *CBCharacteristic)  {
	C.CBPeripheral_inst_SetNotifyValue(o.Ptr(), (C.BOOL)(enabled), characteristic.Ptr())
	runtime.KeepAlive(o)
}

func (o *CBPeripheral) ClassCode() FourCharCode {
	ret := (FourCharCode)(C.CBPeripheral_inst_ClassCode(o.Ptr()))
	runtime.KeepAlive(o)
	return ret
}

func (o *CBPeripheral) Copy() *Id {
	ret := &Id{}
	ret.ptr = unsafe.Pointer(C.CBPeripheral_inst_Copy(o.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	runtime.SetFinalizer(ret, func(o *Id) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *CBPeripheral) ObserveValueForKeyPathOfObject(keyPath *NSString, object NSObject, change *NSDictionary, context unsafe.Pointer)  {
	C.CBPeripheral_inst_ObserveValueForKeyPathOfObject(o.Ptr(), keyPath.Ptr(), object.Ptr(), change.Ptr(), unsafe.Pointer(context))
	runtime.KeepAlive(o)
}

func (o *CBPeripheral) ObserveValueForKeyPathOfObjectChange(keyPath *NSString, object NSObject, change *NSDictionary, context unsafe.Pointer)  {
	C.CBPeripheral_inst_ObserveValueForKeyPathOfObjectChange(o.Ptr(), keyPath.Ptr(), object.Ptr(), change.Ptr(), unsafe.Pointer(context))
	runtime.KeepAlive(o)
}

func (o *CBPeripheral) ForwardingTargetForSelector(aSelector SEL) *Id {
	ret := &Id{}
	ret.ptr = unsafe.Pointer(C.CBPeripheral_inst_ForwardingTargetForSelector(o.Ptr(), unsafe.Pointer(aSelector)))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *Id) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *CBPeripheral) ValueForUndefinedKey(key *NSString) *Id {
	ret := &Id{}
	ret.ptr = unsafe.Pointer(C.CBPeripheral_inst_ValueForUndefinedKey(o.Ptr(), key.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *Id) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *CBPeripheral) IsLessThanOrEqualTo(object NSObject) bool {
	ret := (bool)(C.CBPeripheral_inst_IsLessThanOrEqualTo(o.Ptr(), object.Ptr()))
	runtime.KeepAlive(o)
	return ret
}

func (o *CBPeripheral) AutoContentAccessingProxy() *Id {
	ret := &Id{}
	ret.ptr = unsafe.Pointer(C.CBPeripheral_inst_AutoContentAccessingProxy(o.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *Id) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *CBPeripheral) SetValueForKey(value NSObject, key *NSString)  {
	C.CBPeripheral_inst_SetValueForKey(o.Ptr(), value.Ptr(), key.Ptr())
	runtime.KeepAlive(o)
}

func (o *CBPeripheral) SetValueForKeyPath(value NSObject, keyPath *NSString)  {
	C.CBPeripheral_inst_SetValueForKeyPath(o.Ptr(), value.Ptr(), keyPath.Ptr())
	runtime.KeepAlive(o)
}

func (o *CBPeripheral) SetValueForUndefinedKey(value NSObject, key *NSString)  {
	C.CBPeripheral_inst_SetValueForUndefinedKey(o.Ptr(), value.Ptr(), key.Ptr())
	runtime.KeepAlive(o)
}

func (o *CBPeripheral) ScriptingEndsWith(object NSObject) bool {
	ret := (bool)(C.CBPeripheral_inst_ScriptingEndsWith(o.Ptr(), object.Ptr()))
	runtime.KeepAlive(o)
	return ret
}

func (o *CBPeripheral) MutableOrderedSetValueForKeyPath(keyPath *NSString) *NSMutableOrderedSet {
	ret := &NSMutableOrderedSet{}
	ret.ptr = unsafe.Pointer(C.CBPeripheral_inst_MutableOrderedSetValueForKeyPath(o.Ptr(), keyPath.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSMutableOrderedSet)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *NSMutableOrderedSet) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *CBPeripheral) IndicesOfObjectsByEvaluatingObjectSpecifier(specifier *NSScriptObjectSpecifier) *NSArray {
	ret := &NSArray{}
	ret.ptr = unsafe.Pointer(C.CBPeripheral_inst_IndicesOfObjectsByEvaluatingObjectSpecifier(o.Ptr(), specifier.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSArray)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *NSArray) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *CBPeripheral) ValueWithNameInPropertyWithKey(name *NSString, key *NSString) *Id {
	ret := &Id{}
	ret.ptr = unsafe.Pointer(C.CBPeripheral_inst_ValueWithNameInPropertyWithKey(o.Ptr(), name.Ptr(), key.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *Id) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *CBPeripheral) SetObservationInfo(observationInfo unsafe.Pointer)  {
	C.CBPeripheral_inst_SetObservationInfo(o.Ptr(), unsafe.Pointer(observationInfo))
	runtime.KeepAlive(o)
}

func (o *CBPeripheral) ScriptingIsGreaterThan(object NSObject) bool {
	ret := (bool)(C.CBPeripheral_inst_ScriptingIsGreaterThan(o.Ptr(), object.Ptr()))
	runtime.KeepAlive(o)
	return ret
}

func (o *CBPeripheral) DidChangeValueForKey(key *NSString)  {
	C.CBPeripheral_inst_DidChangeValueForKey(o.Ptr(), key.Ptr())
	runtime.KeepAlive(o)
}

func (o *CBPeripheral) DidChangeValueForKeyWithSetMutation(key *NSString, mutationKind NSKeyValueSetMutationKind, objects *NSSet)  {
	C.CBPeripheral_inst_DidChangeValueForKeyWithSetMutation(o.Ptr(), key.Ptr(), (C.NSKeyValueSetMutationKind)(mutationKind), objects.Ptr())
	runtime.KeepAlive(o)
}

func (o *CBPeripheral) DidChangeValueForKeyWithSetMutationUsingObjects(key *NSString, mutationKind NSKeyValueSetMutationKind, objects *NSSet)  {
	C.CBPeripheral_inst_DidChangeValueForKeyWithSetMutationUsingObjects(o.Ptr(), key.Ptr(), (C.NSKeyValueSetMutationKind)(mutationKind), objects.Ptr())
	runtime.KeepAlive(o)
}

func (o *CBPeripheral) ReadRSSI()  {
	C.CBPeripheral_inst_ReadRSSI(o.Ptr())
	runtime.KeepAlive(o)
}

func (o *CBPeripheral) ToOneRelationshipKeys() *NSArray {
	ret := &NSArray{}
	ret.ptr = unsafe.Pointer(C.CBPeripheral_inst_ToOneRelationshipKeys(o.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSArray)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *NSArray) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *CBPeripheral) ValueAtIndexInPropertyWithKey(index NSUInteger, key *NSString) *Id {
	ret := &Id{}
	ret.ptr = unsafe.Pointer(C.CBPeripheral_inst_ValueAtIndexInPropertyWithKey(o.Ptr(), (C.NSUInteger)(index), key.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *Id) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *CBPeripheral) IsLike(object *NSString) bool {
	ret := (bool)(C.CBPeripheral_inst_IsLike(o.Ptr(), object.Ptr()))
	runtime.KeepAlive(o)
	return ret
}

func (o *CBPeripheral) MaximumWriteValueLengthForType(type_ CBCharacteristicWriteType) NSUInteger {
	ret := (NSUInteger)(C.CBPeripheral_inst_MaximumWriteValueLengthForType(o.Ptr(), (C.CBCharacteristicWriteType)(type_)))
	runtime.KeepAlive(o)
	return ret
}

func (o *CBPeripheral) CanSendWriteWithoutResponse() bool {
	ret := (bool)(C.CBPeripheral_inst_CanSendWriteWithoutResponse(o.Ptr()))
	runtime.KeepAlive(o)
	return ret
}

func (o *CBPeripheral) ScriptingIsEqualTo(object NSObject) bool {
	ret := (bool)(C.CBPeripheral_inst_ScriptingIsEqualTo(o.Ptr(), object.Ptr()))
	runtime.KeepAlive(o)
	return ret
}

func (o *CBPeripheral) InverseForRelationshipKey(relationshipKey *NSString) *NSString {
	ret := &NSString{}
	ret.ptr = unsafe.Pointer(C.CBPeripheral_inst_InverseForRelationshipKey(o.Ptr(), relationshipKey.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSString)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *NSString) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *CBPeripheral) ClassForKeyedArchiver() Class {
	ret := (Class)(unsafe.Pointer(C.CBPeripheral_inst_ClassForKeyedArchiver(o.Ptr())))
	runtime.KeepAlive(o)
	return ret
}

func (o *CBPeripheral) IsLessThan(object NSObject) bool {
	ret := (bool)(C.CBPeripheral_inst_IsLessThan(o.Ptr(), object.Ptr()))
	runtime.KeepAlive(o)
	return ret
}

func (o *CBPeripheral) ScriptingValueForSpecifier(objectSpecifier *NSScriptObjectSpecifier) *Id {
	ret := &Id{}
	ret.ptr = unsafe.Pointer(C.CBPeripheral_inst_ScriptingValueForSpecifier(o.Ptr(), objectSpecifier.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *Id) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *CBPeripheral) SetScriptingProperties(scriptingProperties *NSDictionary)  {
	C.CBPeripheral_inst_SetScriptingProperties(o.Ptr(), scriptingProperties.Ptr())
	runtime.KeepAlive(o)
}

func (o *CBPeripheral) MethodSignatureForSelector(aSelector SEL) *NSMethodSignature {
	ret := &NSMethodSignature{}
	ret.ptr = unsafe.Pointer(C.CBPeripheral_inst_MethodSignatureForSelector(o.Ptr(), unsafe.Pointer(aSelector)))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSMethodSignature)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *NSMethodSignature) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *CBPeripheral) ValidateValueForKey(ioValue *[]*Id, inKey *NSString, outError *[]*NSError) bool {

	goSlice1 := make([]unsafe.Pointer,cap(*ioValue))
	for i := 0; i < len(*ioValue); i++ {
		goSlice1[i] = (*ioValue)[i].Ptr()
	}

	goSlice3 := make([]unsafe.Pointer,cap(*outError))
	for i := 0; i < len(*outError); i++ {
		goSlice3[i] = (*outError)[i].Ptr()
	}
	ret := (bool)(C.CBPeripheral_inst_ValidateValueForKey(o.Ptr(), (*unsafe.Pointer)(unsafe.Pointer(&goSlice1[0])), inKey.Ptr(), (*unsafe.Pointer)(unsafe.Pointer(&goSlice3[0]))))
	(*ioValue) = (*ioValue)[:cap(*ioValue)]
	for i := 0; i < len(*ioValue); i++ {
		if goSlice1[i] == nil {
			(*ioValue) = (*ioValue)[:i]
			break
		}
		if (*ioValue)[i] == nil {
			(*ioValue)[i] = &Id{}
			runtime.SetFinalizer((*ioValue)[i], func(o *Id) {
				o.Release()
			})
		}
		(*ioValue)[i].ptr = goSlice1[i]
	}
	(*outError) = (*outError)[:cap(*outError)]
	for i := 0; i < len(*outError); i++ {
		if goSlice3[i] == nil {
			(*outError) = (*outError)[:i]
			break
		}
		if (*outError)[i] == nil {
			(*outError)[i] = &NSError{}
			runtime.SetFinalizer((*outError)[i], func(o *NSError) {
				o.Release()
			})
		}
		(*outError)[i].ptr = goSlice3[i]
	}
	runtime.KeepAlive(o)
	return ret
}

func (o *CBPeripheral) ValidateValueForKeyPath(ioValue *[]*Id, inKeyPath *NSString, outError *[]*NSError) bool {

	goSlice1 := make([]unsafe.Pointer,cap(*ioValue))
	for i := 0; i < len(*ioValue); i++ {
		goSlice1[i] = (*ioValue)[i].Ptr()
	}

	goSlice3 := make([]unsafe.Pointer,cap(*outError))
	for i := 0; i < len(*outError); i++ {
		goSlice3[i] = (*outError)[i].Ptr()
	}
	ret := (bool)(C.CBPeripheral_inst_ValidateValueForKeyPath(o.Ptr(), (*unsafe.Pointer)(unsafe.Pointer(&goSlice1[0])), inKeyPath.Ptr(), (*unsafe.Pointer)(unsafe.Pointer(&goSlice3[0]))))
	(*ioValue) = (*ioValue)[:cap(*ioValue)]
	for i := 0; i < len(*ioValue); i++ {
		if goSlice1[i] == nil {
			(*ioValue) = (*ioValue)[:i]
			break
		}
		if (*ioValue)[i] == nil {
			(*ioValue)[i] = &Id{}
			runtime.SetFinalizer((*ioValue)[i], func(o *Id) {
				o.Release()
			})
		}
		(*ioValue)[i].ptr = goSlice1[i]
	}
	(*outError) = (*outError)[:cap(*outError)]
	for i := 0; i < len(*outError); i++ {
		if goSlice3[i] == nil {
			(*outError) = (*outError)[:i]
			break
		}
		if (*outError)[i] == nil {
			(*outError)[i] = &NSError{}
			runtime.SetFinalizer((*outError)[i], func(o *NSError) {
				o.Release()
			})
		}
		(*outError)[i].ptr = goSlice3[i]
	}
	runtime.KeepAlive(o)
	return ret
}

func (o *CBPeripheral) ValidateValueForKeyError(ioValue *[]*Id, inKey *NSString, outError *[]*NSError) bool {

	goSlice1 := make([]unsafe.Pointer,cap(*ioValue))
	for i := 0; i < len(*ioValue); i++ {
		goSlice1[i] = (*ioValue)[i].Ptr()
	}

	goSlice3 := make([]unsafe.Pointer,cap(*outError))
	for i := 0; i < len(*outError); i++ {
		goSlice3[i] = (*outError)[i].Ptr()
	}
	ret := (bool)(C.CBPeripheral_inst_ValidateValueForKeyError(o.Ptr(), (*unsafe.Pointer)(unsafe.Pointer(&goSlice1[0])), inKey.Ptr(), (*unsafe.Pointer)(unsafe.Pointer(&goSlice3[0]))))
	(*ioValue) = (*ioValue)[:cap(*ioValue)]
	for i := 0; i < len(*ioValue); i++ {
		if goSlice1[i] == nil {
			(*ioValue) = (*ioValue)[:i]
			break
		}
		if (*ioValue)[i] == nil {
			(*ioValue)[i] = &Id{}
			runtime.SetFinalizer((*ioValue)[i], func(o *Id) {
				o.Release()
			})
		}
		(*ioValue)[i].ptr = goSlice1[i]
	}
	(*outError) = (*outError)[:cap(*outError)]
	for i := 0; i < len(*outError); i++ {
		if goSlice3[i] == nil {
			(*outError) = (*outError)[:i]
			break
		}
		if (*outError)[i] == nil {
			(*outError)[i] = &NSError{}
			runtime.SetFinalizer((*outError)[i], func(o *NSError) {
				o.Release()
			})
		}
		(*outError)[i].ptr = goSlice3[i]
	}
	runtime.KeepAlive(o)
	return ret
}

func (o *CBPeripheral) ValidateValueForKeyPathError(ioValue *[]*Id, inKeyPath *NSString, outError *[]*NSError) bool {

	goSlice1 := make([]unsafe.Pointer,cap(*ioValue))
	for i := 0; i < len(*ioValue); i++ {
		goSlice1[i] = (*ioValue)[i].Ptr()
	}

	goSlice3 := make([]unsafe.Pointer,cap(*outError))
	for i := 0; i < len(*outError); i++ {
		goSlice3[i] = (*outError)[i].Ptr()
	}
	ret := (bool)(C.CBPeripheral_inst_ValidateValueForKeyPathError(o.Ptr(), (*unsafe.Pointer)(unsafe.Pointer(&goSlice1[0])), inKeyPath.Ptr(), (*unsafe.Pointer)(unsafe.Pointer(&goSlice3[0]))))
	(*ioValue) = (*ioValue)[:cap(*ioValue)]
	for i := 0; i < len(*ioValue); i++ {
		if goSlice1[i] == nil {
			(*ioValue) = (*ioValue)[:i]
			break
		}
		if (*ioValue)[i] == nil {
			(*ioValue)[i] = &Id{}
			runtime.SetFinalizer((*ioValue)[i], func(o *Id) {
				o.Release()
			})
		}
		(*ioValue)[i].ptr = goSlice1[i]
	}
	(*outError) = (*outError)[:cap(*outError)]
	for i := 0; i < len(*outError); i++ {
		if goSlice3[i] == nil {
			(*outError) = (*outError)[:i]
			break
		}
		if (*outError)[i] == nil {
			(*outError)[i] = &NSError{}
			runtime.SetFinalizer((*outError)[i], func(o *NSError) {
				o.Release()
			})
		}
		(*outError)[i].ptr = goSlice3[i]
	}
	runtime.KeepAlive(o)
	return ret
}

func (o *CBPeripheral) IsEqualTo(object NSObject) bool {
	ret := (bool)(C.CBPeripheral_inst_IsEqualTo(o.Ptr(), object.Ptr()))
	runtime.KeepAlive(o)
	return ret
}

func (o *CBPeripheral) WillChangeValueForKey(key *NSString)  {
	C.CBPeripheral_inst_WillChangeValueForKey(o.Ptr(), key.Ptr())
	runtime.KeepAlive(o)
}

func (o *CBPeripheral) WillChangeValueForKeyWithSetMutation(key *NSString, mutationKind NSKeyValueSetMutationKind, objects *NSSet)  {
	C.CBPeripheral_inst_WillChangeValueForKeyWithSetMutation(o.Ptr(), key.Ptr(), (C.NSKeyValueSetMutationKind)(mutationKind), objects.Ptr())
	runtime.KeepAlive(o)
}

func (o *CBPeripheral) WillChangeValueForKeyWithSetMutationUsingObjects(key *NSString, mutationKind NSKeyValueSetMutationKind, objects *NSSet)  {
	C.CBPeripheral_inst_WillChangeValueForKeyWithSetMutationUsingObjects(o.Ptr(), key.Ptr(), (C.NSKeyValueSetMutationKind)(mutationKind), objects.Ptr())
	runtime.KeepAlive(o)
}

func (o *CBPeripheral) AttributeKeys() *NSArray {
	ret := &NSArray{}
	ret.ptr = unsafe.Pointer(C.CBPeripheral_inst_AttributeKeys(o.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSArray)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *NSArray) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *CBPeripheral) IsGreaterThanOrEqualTo(object NSObject) bool {
	ret := (bool)(C.CBPeripheral_inst_IsGreaterThanOrEqualTo(o.Ptr(), object.Ptr()))
	runtime.KeepAlive(o)
	return ret
}

func (o *CBPeripheral) WriteValueForDescriptor(data *NSData, descriptor *CBDescriptor)  {
	C.CBPeripheral_inst_WriteValueForDescriptor(o.Ptr(), data.Ptr(), descriptor.Ptr())
	runtime.KeepAlive(o)
}

func (o *CBPeripheral) WriteValueForCharacteristic(data *NSData, characteristic *CBCharacteristic, type_ CBCharacteristicWriteType)  {
	C.CBPeripheral_inst_WriteValueForCharacteristic(o.Ptr(), data.Ptr(), characteristic.Ptr(), (C.CBCharacteristicWriteType)(type_))
	runtime.KeepAlive(o)
}

func (o *CBPeripheral) OpenL2CAPChannel(PSM CBL2CAPPSM)  {
	C.CBPeripheral_inst_OpenL2CAPChannel(o.Ptr(), (C.CBL2CAPPSM)(PSM))
	runtime.KeepAlive(o)
}

func (o *CBPeripheral) ScriptingIsGreaterThanOrEqualTo(object NSObject) bool {
	ret := (bool)(C.CBPeripheral_inst_ScriptingIsGreaterThanOrEqualTo(o.Ptr(), object.Ptr()))
	runtime.KeepAlive(o)
	return ret
}

func (o *CBPeripheral) WillChangeValuesAtIndexes(changeKind NSKeyValueChange, indexes *NSIndexSet, key *NSString)  {
	C.CBPeripheral_inst_WillChangeValuesAtIndexes(o.Ptr(), (C.NSKeyValueChange)(changeKind), indexes.Ptr(), key.Ptr())
	runtime.KeepAlive(o)
}

func (o *CBPeripheral) WillChangeValuesAtIndexesForKey(changeKind NSKeyValueChange, indexes *NSIndexSet, key *NSString)  {
	C.CBPeripheral_inst_WillChangeValuesAtIndexesForKey(o.Ptr(), (C.NSKeyValueChange)(changeKind), indexes.Ptr(), key.Ptr())
	runtime.KeepAlive(o)
}

func (o *CBPeripheral) RemoveObserverForKeyPath(observer NSObject, keyPath *NSString)  {
	C.CBPeripheral_inst_RemoveObserverForKeyPath(o.Ptr(), observer.Ptr(), keyPath.Ptr())
	runtime.KeepAlive(o)
}

func (o *CBPeripheral) RemoveObserverForKeyPathContext(observer NSObject, keyPath *NSString, context unsafe.Pointer)  {
	C.CBPeripheral_inst_RemoveObserverForKeyPathContext(o.Ptr(), observer.Ptr(), keyPath.Ptr(), unsafe.Pointer(context))
	runtime.KeepAlive(o)
}

func (o *CBPeripheral) ValueForKey(key *NSString) *Id {
	ret := &Id{}
	ret.ptr = unsafe.Pointer(C.CBPeripheral_inst_ValueForKey(o.Ptr(), key.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *Id) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *CBPeripheral) CoerceValueForKey(value NSObject, key *NSString) *Id {
	ret := &Id{}
	ret.ptr = unsafe.Pointer(C.CBPeripheral_inst_CoerceValueForKey(o.Ptr(), value.Ptr(), key.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *Id) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *CBPeripheral) ForwardInvocation(anInvocation *NSInvocation)  {
	C.CBPeripheral_inst_ForwardInvocation(o.Ptr(), anInvocation.Ptr())
	runtime.KeepAlive(o)
}

func (o *CBPeripheral) ReadValueForCharacteristic(characteristic *CBCharacteristic)  {
	C.CBPeripheral_inst_ReadValueForCharacteristic(o.Ptr(), characteristic.Ptr())
	runtime.KeepAlive(o)
}

func (o *CBPeripheral) Identifier() *NSUUID {
	ret := &NSUUID{}
	ret.ptr = unsafe.Pointer(C.CBPeripheral_inst_Identifier(o.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSUUID)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *NSUUID) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *CBPeripheral) Dealloc()  {
	C.CBPeripheral_inst_Dealloc(o.Ptr())
	runtime.KeepAlive(o)
}

func (o *CBPeripheral) AttemptRecoveryFromErrorOptionIndex(error *NSError, recoveryOptionIndex NSUInteger) bool {
	ret := (bool)(C.CBPeripheral_inst_AttemptRecoveryFromErrorOptionIndex(o.Ptr(), error.Ptr(), (C.NSUInteger)(recoveryOptionIndex)))
	runtime.KeepAlive(o)
	return ret
}

func (o *CBPeripheral) AttemptRecoveryFromErrorOptionIndexDelegate(error *NSError, recoveryOptionIndex NSUInteger, delegate NSObject, didRecoverSelector SEL, contextInfo unsafe.Pointer)  {
	C.CBPeripheral_inst_AttemptRecoveryFromErrorOptionIndexDelegate(o.Ptr(), error.Ptr(), (C.NSUInteger)(recoveryOptionIndex), delegate.Ptr(), unsafe.Pointer(didRecoverSelector), unsafe.Pointer(contextInfo))
	runtime.KeepAlive(o)
}

func (o *CBPeripheral) AttemptRecoveryFromErrorOptionIndexDelegateDidRecoverSelector(error *NSError, recoveryOptionIndex NSUInteger, delegate NSObject, didRecoverSelector SEL, contextInfo unsafe.Pointer)  {
	C.CBPeripheral_inst_AttemptRecoveryFromErrorOptionIndexDelegateDidRecoverSelector(o.Ptr(), error.Ptr(), (C.NSUInteger)(recoveryOptionIndex), delegate.Ptr(), unsafe.Pointer(didRecoverSelector), unsafe.Pointer(contextInfo))
	runtime.KeepAlive(o)
}

func (o *CBPeripheral) MutableArrayValueForKey(key *NSString) *NSMutableArray {
	ret := &NSMutableArray{}
	ret.ptr = unsafe.Pointer(C.CBPeripheral_inst_MutableArrayValueForKey(o.Ptr(), key.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSMutableArray)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *NSMutableArray) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *CBPeripheral) NewScriptingObjectOfClassForValueForKey(objectClass Class, key *NSString, contentsValue NSObject, properties *NSDictionary) *Id {
	ret := &Id{}
	ret.ptr = unsafe.Pointer(C.CBPeripheral_inst_NewScriptingObjectOfClassForValueForKey(o.Ptr(), unsafe.Pointer(objectClass), key.Ptr(), contentsValue.Ptr(), properties.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *Id) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *CBPeripheral) NewScriptingObjectOfClassForValueForKeyWithContentsValue(objectClass Class, key *NSString, contentsValue NSObject, properties *NSDictionary) *Id {
	ret := &Id{}
	ret.ptr = unsafe.Pointer(C.CBPeripheral_inst_NewScriptingObjectOfClassForValueForKeyWithContentsValue(o.Ptr(), unsafe.Pointer(objectClass), key.Ptr(), contentsValue.Ptr(), properties.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *Id) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *CBPeripheral) PerformSelectorInBackgroundWithObject(aSelector SEL, arg NSObject)  {
	C.CBPeripheral_inst_PerformSelectorInBackgroundWithObject(o.Ptr(), unsafe.Pointer(aSelector), arg.Ptr())
	runtime.KeepAlive(o)
}

func (o *CBPeripheral) ReplacementObjectForCoder(coder *NSCoder) *Id {
	ret := &Id{}
	ret.ptr = unsafe.Pointer(C.CBPeripheral_inst_ReplacementObjectForCoder(o.Ptr(), coder.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *Id) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *CBPeripheral) SetNilValueForKey(key *NSString)  {
	C.CBPeripheral_inst_SetNilValueForKey(o.Ptr(), key.Ptr())
	runtime.KeepAlive(o)
}

func (o *CBPeripheral) ScriptingProperties() *NSDictionary {
	ret := &NSDictionary{}
	ret.ptr = unsafe.Pointer(C.CBPeripheral_inst_ScriptingProperties(o.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSDictionary)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *NSDictionary) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *CBPeripheral) ClassForArchiver() Class {
	ret := (Class)(unsafe.Pointer(C.CBPeripheral_inst_ClassForArchiver(o.Ptr())))
	runtime.KeepAlive(o)
	return ret
}

func (o *CBPeripheral) ScriptingIsLessThanOrEqualTo(object NSObject) bool {
	ret := (bool)(C.CBPeripheral_inst_ScriptingIsLessThanOrEqualTo(o.Ptr(), object.Ptr()))
	runtime.KeepAlive(o)
	return ret
}

func (o *CBPeripheral) MutableSetValueForKeyPath(keyPath *NSString) *NSMutableSet {
	ret := &NSMutableSet{}
	ret.ptr = unsafe.Pointer(C.CBPeripheral_inst_MutableSetValueForKeyPath(o.Ptr(), keyPath.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSMutableSet)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *NSMutableSet) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *CBPeripheral) DiscoverCharacteristics(characteristicUUIDs *NSArray, service *CBService)  {
	C.CBPeripheral_inst_DiscoverCharacteristics(o.Ptr(), characteristicUUIDs.Ptr(), service.Ptr())
	runtime.KeepAlive(o)
}

func (o *CBPeripheral) SetDelegate(delegate NSObject)  {
	C.CBPeripheral_inst_SetDelegate(o.Ptr(), delegate.Ptr())
	runtime.KeepAlive(o)
}

func (o *CBPeripheral) State() CBPeripheralState {
	ret := (CBPeripheralState)(C.CBPeripheral_inst_State(o.Ptr()))
	runtime.KeepAlive(o)
	return ret
}

func (o *CBPeripheral) ValueWithUniqueIDInPropertyWithKey(uniqueID NSObject, key *NSString) *Id {
	ret := &Id{}
	ret.ptr = unsafe.Pointer(C.CBPeripheral_inst_ValueWithUniqueIDInPropertyWithKey(o.Ptr(), uniqueID.Ptr(), key.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *Id) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *CBPeripheral) ClassName() *NSString {
	ret := &NSString{}
	ret.ptr = unsafe.Pointer(C.CBPeripheral_inst_ClassName(o.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSString)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *NSString) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *CBPeripheral) ObjectSpecifier() *NSScriptObjectSpecifier {
	ret := &NSScriptObjectSpecifier{}
	ret.ptr = unsafe.Pointer(C.CBPeripheral_inst_ObjectSpecifier(o.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSScriptObjectSpecifier)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *NSScriptObjectSpecifier) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *CBPeripheral) RemoveValueAtIndexFromPropertyWithKey(index NSUInteger, key *NSString)  {
	C.CBPeripheral_inst_RemoveValueAtIndexFromPropertyWithKey(o.Ptr(), (C.NSUInteger)(index), key.Ptr())
	runtime.KeepAlive(o)
}

func (o *CBPeripheral) AddObserverForKeyPath(observer NSObject, keyPath *NSString, options NSKeyValueObservingOptions, context unsafe.Pointer)  {
	C.CBPeripheral_inst_AddObserverForKeyPath(o.Ptr(), observer.Ptr(), keyPath.Ptr(), (C.NSKeyValueObservingOptions)(options), unsafe.Pointer(context))
	runtime.KeepAlive(o)
}

func (o *CBPeripheral) AddObserverForKeyPathOptions(observer NSObject, keyPath *NSString, options NSKeyValueObservingOptions, context unsafe.Pointer)  {
	C.CBPeripheral_inst_AddObserverForKeyPathOptions(o.Ptr(), observer.Ptr(), keyPath.Ptr(), (C.NSKeyValueObservingOptions)(options), unsafe.Pointer(context))
	runtime.KeepAlive(o)
}

func (o *CBPeripheral) Name() *NSString {
	ret := &NSString{}
	ret.ptr = unsafe.Pointer(C.CBPeripheral_inst_Name(o.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSString)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *NSString) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *CBPeripheral) ClassForCoder() Class {
	ret := (Class)(unsafe.Pointer(C.CBPeripheral_inst_ClassForCoder(o.Ptr())))
	runtime.KeepAlive(o)
	return ret
}

func (o *CBPeripheral) ClassDescription() *NSClassDescription {
	ret := &NSClassDescription{}
	ret.ptr = unsafe.Pointer(C.CBPeripheral_inst_ClassDescription(o.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSClassDescription)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *NSClassDescription) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *CBPeripheral) DidChangeValuesAtIndexes(changeKind NSKeyValueChange, indexes *NSIndexSet, key *NSString)  {
	C.CBPeripheral_inst_DidChangeValuesAtIndexes(o.Ptr(), (C.NSKeyValueChange)(changeKind), indexes.Ptr(), key.Ptr())
	runtime.KeepAlive(o)
}

func (o *CBPeripheral) DidChangeValuesAtIndexesForKey(changeKind NSKeyValueChange, indexes *NSIndexSet, key *NSString)  {
	C.CBPeripheral_inst_DidChangeValuesAtIndexesForKey(o.Ptr(), (C.NSKeyValueChange)(changeKind), indexes.Ptr(), key.Ptr())
	runtime.KeepAlive(o)
}

func (o *CBPeripheral) DoesContain(object NSObject) bool {
	ret := (bool)(C.CBPeripheral_inst_DoesContain(o.Ptr(), object.Ptr()))
	runtime.KeepAlive(o)
	return ret
}

func (o *CBPeripheral) PerformSelectorOnMainThreadWithObject(aSelector SEL, arg NSObject, wait BOOL)  {
	C.CBPeripheral_inst_PerformSelectorOnMainThreadWithObject(o.Ptr(), unsafe.Pointer(aSelector), arg.Ptr(), (C.BOOL)(wait))
	runtime.KeepAlive(o)
}

func (o *CBPeripheral) PerformSelectorOnMainThreadWithObjectWaitUntilDone(aSelector SEL, arg NSObject, wait BOOL)  {
	C.CBPeripheral_inst_PerformSelectorOnMainThreadWithObjectWaitUntilDone(o.Ptr(), unsafe.Pointer(aSelector), arg.Ptr(), (C.BOOL)(wait))
	runtime.KeepAlive(o)
}

func (o *CBPeripheral) PerformSelectorOnMainThreadWithObjectWaitUntilDoneModes(aSelector SEL, arg NSObject, wait BOOL, array *NSArray)  {
	C.CBPeripheral_inst_PerformSelectorOnMainThreadWithObjectWaitUntilDoneModes(o.Ptr(), unsafe.Pointer(aSelector), arg.Ptr(), (C.BOOL)(wait), array.Ptr())
	runtime.KeepAlive(o)
}

func (o *CBPeripheral) ReadValueForDescriptor(descriptor *CBDescriptor)  {
	C.CBPeripheral_inst_ReadValueForDescriptor(o.Ptr(), descriptor.Ptr())
	runtime.KeepAlive(o)
}

func (o *CBPeripheral) ToManyRelationshipKeys() *NSArray {
	ret := &NSArray{}
	ret.ptr = unsafe.Pointer(C.CBPeripheral_inst_ToManyRelationshipKeys(o.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSArray)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *NSArray) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *CBPeripheral) PerformSelectorWithObject(aSelector SEL, anArgument NSObject, delay NSTimeInterval)  {
	C.CBPeripheral_inst_PerformSelectorWithObject(o.Ptr(), unsafe.Pointer(aSelector), anArgument.Ptr(), (C.NSTimeInterval)(delay))
	runtime.KeepAlive(o)
}

func (o *CBPeripheral) PerformSelectorWithObjectAfterDelay(aSelector SEL, anArgument NSObject, delay NSTimeInterval)  {
	C.CBPeripheral_inst_PerformSelectorWithObjectAfterDelay(o.Ptr(), unsafe.Pointer(aSelector), anArgument.Ptr(), (C.NSTimeInterval)(delay))
	runtime.KeepAlive(o)
}

func (o *CBPeripheral) PerformSelectorWithObjectAfterDelayInModes(aSelector SEL, anArgument NSObject, delay NSTimeInterval, modes *NSArray)  {
	C.CBPeripheral_inst_PerformSelectorWithObjectAfterDelayInModes(o.Ptr(), unsafe.Pointer(aSelector), anArgument.Ptr(), (C.NSTimeInterval)(delay), modes.Ptr())
	runtime.KeepAlive(o)
}

func (o *CBPeripheral) PerformSelectorOnThread(aSelector SEL, thr *NSThread, arg NSObject, wait BOOL)  {
	C.CBPeripheral_inst_PerformSelectorOnThread(o.Ptr(), unsafe.Pointer(aSelector), thr.Ptr(), arg.Ptr(), (C.BOOL)(wait))
	runtime.KeepAlive(o)
}

func (o *CBPeripheral) PerformSelectorOnThreadWithObject(aSelector SEL, thr *NSThread, arg NSObject, wait BOOL)  {
	C.CBPeripheral_inst_PerformSelectorOnThreadWithObject(o.Ptr(), unsafe.Pointer(aSelector), thr.Ptr(), arg.Ptr(), (C.BOOL)(wait))
	runtime.KeepAlive(o)
}

func (o *CBPeripheral) PerformSelectorOnThreadWithObjectWaitUntilDone(aSelector SEL, thr *NSThread, arg NSObject, wait BOOL, array *NSArray)  {
	C.CBPeripheral_inst_PerformSelectorOnThreadWithObjectWaitUntilDone(o.Ptr(), unsafe.Pointer(aSelector), thr.Ptr(), arg.Ptr(), (C.BOOL)(wait), array.Ptr())
	runtime.KeepAlive(o)
}

func (o *CBPeripheral) PerformSelectorOnThreadWithObjectWaitUntilDoneModes(aSelector SEL, thr *NSThread, arg NSObject, wait BOOL, array *NSArray)  {
	C.CBPeripheral_inst_PerformSelectorOnThreadWithObjectWaitUntilDoneModes(o.Ptr(), unsafe.Pointer(aSelector), thr.Ptr(), arg.Ptr(), (C.BOOL)(wait), array.Ptr())
	runtime.KeepAlive(o)
}

func (o *CBPeripheral) ValueForKeyPath(keyPath *NSString) *Id {
	ret := &Id{}
	ret.ptr = unsafe.Pointer(C.CBPeripheral_inst_ValueForKeyPath(o.Ptr(), keyPath.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *Id) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *CBPeripheral) ReplaceValueAtIndexInPropertyWithKey(index NSUInteger, key *NSString, value NSObject)  {
	C.CBPeripheral_inst_ReplaceValueAtIndexInPropertyWithKey(o.Ptr(), (C.NSUInteger)(index), key.Ptr(), value.Ptr())
	runtime.KeepAlive(o)
}

func (o *CBPeripheral) ReplaceValueAtIndexInPropertyWithKeyWithValue(index NSUInteger, key *NSString, value NSObject)  {
	C.CBPeripheral_inst_ReplaceValueAtIndexInPropertyWithKeyWithValue(o.Ptr(), (C.NSUInteger)(index), key.Ptr(), value.Ptr())
	runtime.KeepAlive(o)
}

func (o *CBPeripheral) Services() *NSArray {
	ret := &NSArray{}
	ret.ptr = unsafe.Pointer(C.CBPeripheral_inst_Services(o.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSArray)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *NSArray) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *CBPeripheral) MutableOrderedSetValueForKey(key *NSString) *NSMutableOrderedSet {
	ret := &NSMutableOrderedSet{}
	ret.ptr = unsafe.Pointer(C.CBPeripheral_inst_MutableOrderedSetValueForKey(o.Ptr(), key.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSMutableOrderedSet)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *NSMutableOrderedSet) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *CBPeripheral) InsertValueInPropertyWithKey(value NSObject, key *NSString)  {
	C.CBPeripheral_inst_InsertValueInPropertyWithKey(o.Ptr(), value.Ptr(), key.Ptr())
	runtime.KeepAlive(o)
}

func (o *CBPeripheral) InsertValueAtIndex(value NSObject, index NSUInteger, key *NSString)  {
	C.CBPeripheral_inst_InsertValueAtIndex(o.Ptr(), value.Ptr(), (C.NSUInteger)(index), key.Ptr())
	runtime.KeepAlive(o)
}

func (o *CBPeripheral) InsertValueAtIndexInPropertyWithKey(value NSObject, index NSUInteger, key *NSString)  {
	C.CBPeripheral_inst_InsertValueAtIndexInPropertyWithKey(o.Ptr(), value.Ptr(), (C.NSUInteger)(index), key.Ptr())
	runtime.KeepAlive(o)
}

func (o *CBPeripheral) ObservationInfo() unsafe.Pointer {
	ret := (unsafe.Pointer)(unsafe.Pointer(C.CBPeripheral_inst_ObservationInfo(o.Ptr())))
	runtime.KeepAlive(o)
	return ret
}

func (o *CBPeripheral) ScriptingIsLessThan(object NSObject) bool {
	ret := (bool)(C.CBPeripheral_inst_ScriptingIsLessThan(o.Ptr(), object.Ptr()))
	runtime.KeepAlive(o)
	return ret
}

func (o *CBPeripheral) CopyScriptingValueForKey(value NSObject, key *NSString, properties *NSDictionary) *Id {
	ret := &Id{}
	ret.ptr = unsafe.Pointer(C.CBPeripheral_inst_CopyScriptingValueForKey(o.Ptr(), value.Ptr(), key.Ptr(), properties.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *Id) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *CBPeripheral) CopyScriptingValueForKeyWithProperties(value NSObject, key *NSString, properties *NSDictionary) *Id {
	ret := &Id{}
	ret.ptr = unsafe.Pointer(C.CBPeripheral_inst_CopyScriptingValueForKeyWithProperties(o.Ptr(), value.Ptr(), key.Ptr(), properties.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *Id) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *CBPeripheral) IsGreaterThan(object NSObject) bool {
	ret := (bool)(C.CBPeripheral_inst_IsGreaterThan(o.Ptr(), object.Ptr()))
	runtime.KeepAlive(o)
	return ret
}

func (o *CBPeripheral) ScriptingBeginsWith(object NSObject) bool {
	ret := (bool)(C.CBPeripheral_inst_ScriptingBeginsWith(o.Ptr(), object.Ptr()))
	runtime.KeepAlive(o)
	return ret
}

func (o *CBPeripheral) MutableCopy() *Id {
	ret := &Id{}
	ret.ptr = unsafe.Pointer(C.CBPeripheral_inst_MutableCopy(o.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	runtime.SetFinalizer(ret, func(o *Id) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *CBPeripheral) DiscoverServices(serviceUUIDs *NSArray)  {
	C.CBPeripheral_inst_DiscoverServices(o.Ptr(), serviceUUIDs.Ptr())
	runtime.KeepAlive(o)
}

func (o *CBPeripheral) Delegate() *Id {
	ret := &Id{}
	ret.ptr = unsafe.Pointer(C.CBPeripheral_inst_Delegate(o.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *Id) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *CBPeripheral) DiscoverIncludedServices(includedServiceUUIDs *NSArray, service *CBService)  {
	C.CBPeripheral_inst_DiscoverIncludedServices(o.Ptr(), includedServiceUUIDs.Ptr(), service.Ptr())
	runtime.KeepAlive(o)
}

func (o *CBPeripheral) DictionaryWithValuesForKeys(keys *NSArray) *NSDictionary {
	ret := &NSDictionary{}
	ret.ptr = unsafe.Pointer(C.CBPeripheral_inst_DictionaryWithValuesForKeys(o.Ptr(), keys.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSDictionary)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *NSDictionary) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *CBPeripheral) IsNotEqualTo(object NSObject) bool {
	ret := (bool)(C.CBPeripheral_inst_IsNotEqualTo(o.Ptr(), object.Ptr()))
	runtime.KeepAlive(o)
	return ret
}

func (o *CBPeripheral) ScriptingContains(object NSObject) bool {
	ret := (bool)(C.CBPeripheral_inst_ScriptingContains(o.Ptr(), object.Ptr()))
	runtime.KeepAlive(o)
	return ret
}

func (o *CBPeripheral) SetValuesForKeysWithDictionary(keyedValues *NSDictionary)  {
	C.CBPeripheral_inst_SetValuesForKeysWithDictionary(o.Ptr(), keyedValues.Ptr())
	runtime.KeepAlive(o)
}

func (o *CBPeripheral) MutableSetValueForKey(key *NSString) *NSMutableSet {
	ret := &NSMutableSet{}
	ret.ptr = unsafe.Pointer(C.CBPeripheral_inst_MutableSetValueForKey(o.Ptr(), key.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSMutableSet)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *NSMutableSet) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *CBPeripheral) DiscoverDescriptorsForCharacteristic(characteristic *CBCharacteristic)  {
	C.CBPeripheral_inst_DiscoverDescriptorsForCharacteristic(o.Ptr(), characteristic.Ptr())
	runtime.KeepAlive(o)
}

func (o *CBPeripheral) ReplacementObjectForKeyedArchiver(archiver *NSKeyedArchiver) *Id {
	ret := &Id{}
	ret.ptr = unsafe.Pointer(C.CBPeripheral_inst_ReplacementObjectForKeyedArchiver(o.Ptr(), archiver.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *Id) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *CBPeripheral) AwakeAfterUsingCoder(coder *NSCoder) *Id {
	ret := &Id{}
	ret.ptr = unsafe.Pointer(C.CBPeripheral_inst_AwakeAfterUsingCoder(o.Ptr(), coder.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *Id) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *CBPeripheral) IsCaseInsensitiveLike(object *NSString) bool {
	ret := (bool)(C.CBPeripheral_inst_IsCaseInsensitiveLike(o.Ptr(), object.Ptr()))
	runtime.KeepAlive(o)
	return ret
}

func (o *CBPeripheral) DoesNotRecognizeSelector(aSelector SEL)  {
	C.CBPeripheral_inst_DoesNotRecognizeSelector(o.Ptr(), unsafe.Pointer(aSelector))
	runtime.KeepAlive(o)
}

func NSStringDescription() *NSString {
	ret := &NSString{}
	ret.ptr = unsafe.Pointer(C.NSString_Description())
	if ret.ptr == nil { return ret }
	return ret
}

func NSStringWithString(string *NSString) *NSString {
	ret := &NSString{}
	ret.ptr = unsafe.Pointer(C.NSString_StringWithString(string.Ptr()))
	if ret.ptr == nil { return ret }
	runtime.SetFinalizer(ret, func(o *NSString) {
		o.Release()
	})
	return ret
}

func NSStringWithGoString(string string) *NSString {
	string_chr := CharWithGoString(string)
	defer string_chr.Free()
	ret := NSStringWithString(NSStringWithUTF8String(string_chr))
	return ret
}

func NSStringWithFormat(format *NSString) *NSString {
	ret := &NSString{}
	ret.ptr = unsafe.Pointer(C.NSString_StringWithFormat(format.Ptr()))
	if ret.ptr == nil { return ret }
	runtime.SetFinalizer(ret, func(o *NSString) {
		o.Release()
	})
	return ret
}

func NSStringWithUTF8String(nullTerminatedCString *Char) *NSString {
	ret := &NSString{}
	ret.ptr = unsafe.Pointer(C.NSString_StringWithUTF8String(unsafe.Pointer(nullTerminatedCString)))
	if ret.ptr == nil { return ret }
	runtime.SetFinalizer(ret, func(o *NSString) {
		o.Release()
	})
	return ret
}

func NSStringLocalizedStringWithFormat(format *NSString) *NSString {
	ret := &NSString{}
	ret.ptr = unsafe.Pointer(C.NSString_LocalizedStringWithFormat(format.Ptr()))
	if ret.ptr == nil { return ret }
	return ret
}

func NSStringWithContentsOfURLEncoding(url *NSURL, enc NSStringEncoding, error *[]*NSError) *NSString {

	goSlice2 := make([]unsafe.Pointer,cap(*error))
	for i := 0; i < len(*error); i++ {
		goSlice2[i] = (*error)[i].Ptr()
	}
	ret := &NSString{}
	ret.ptr = unsafe.Pointer(C.NSString_StringWithContentsOfURLEncoding(url.Ptr(), (C.NSStringEncoding)(enc), (*unsafe.Pointer)(unsafe.Pointer(&goSlice2[0]))))
	(*error) = (*error)[:cap(*error)]
	for i := 0; i < len(*error); i++ {
		if goSlice2[i] == nil {
			(*error) = (*error)[:i]
			break
		}
		if (*error)[i] == nil {
			(*error)[i] = &NSError{}
			runtime.SetFinalizer((*error)[i], func(o *NSError) {
				o.Release()
			})
		}
		(*error)[i].ptr = goSlice2[i]
	}
	if ret.ptr == nil { return ret }
	runtime.SetFinalizer(ret, func(o *NSString) {
		o.Release()
	})
	return ret
}

func NSStringWithContentsOfURLUsedEncoding(url *NSURL, enc *NSStringEncoding, error *[]*NSError) *NSString {

	goSlice2 := make([]unsafe.Pointer,cap(*error))
	for i := 0; i < len(*error); i++ {
		goSlice2[i] = (*error)[i].Ptr()
	}
	ret := &NSString{}
	ret.ptr = unsafe.Pointer(C.NSString_StringWithContentsOfURLUsedEncoding(url.Ptr(), unsafe.Pointer(enc), (*unsafe.Pointer)(unsafe.Pointer(&goSlice2[0]))))
	(*error) = (*error)[:cap(*error)]
	for i := 0; i < len(*error); i++ {
		if goSlice2[i] == nil {
			(*error) = (*error)[:i]
			break
		}
		if (*error)[i] == nil {
			(*error)[i] = &NSError{}
			runtime.SetFinalizer((*error)[i], func(o *NSError) {
				o.Release()
			})
		}
		(*error)[i].ptr = goSlice2[i]
	}
	if ret.ptr == nil { return ret }
	runtime.SetFinalizer(ret, func(o *NSString) {
		o.Release()
	})
	return ret
}

func NSStringWithContentsOfURLEncodingError(url *NSURL, enc NSStringEncoding, error *[]*NSError) *NSString {

	goSlice2 := make([]unsafe.Pointer,cap(*error))
	for i := 0; i < len(*error); i++ {
		goSlice2[i] = (*error)[i].Ptr()
	}
	ret := &NSString{}
	ret.ptr = unsafe.Pointer(C.NSString_StringWithContentsOfURLEncodingError(url.Ptr(), (C.NSStringEncoding)(enc), (*unsafe.Pointer)(unsafe.Pointer(&goSlice2[0]))))
	(*error) = (*error)[:cap(*error)]
	for i := 0; i < len(*error); i++ {
		if goSlice2[i] == nil {
			(*error) = (*error)[:i]
			break
		}
		if (*error)[i] == nil {
			(*error)[i] = &NSError{}
			runtime.SetFinalizer((*error)[i], func(o *NSError) {
				o.Release()
			})
		}
		(*error)[i].ptr = goSlice2[i]
	}
	if ret.ptr == nil { return ret }
	runtime.SetFinalizer(ret, func(o *NSString) {
		o.Release()
	})
	return ret
}

func NSStringWithContentsOfURLUsedEncodingError(url *NSURL, enc *NSStringEncoding, error *[]*NSError) *NSString {

	goSlice2 := make([]unsafe.Pointer,cap(*error))
	for i := 0; i < len(*error); i++ {
		goSlice2[i] = (*error)[i].Ptr()
	}
	ret := &NSString{}
	ret.ptr = unsafe.Pointer(C.NSString_StringWithContentsOfURLUsedEncodingError(url.Ptr(), unsafe.Pointer(enc), (*unsafe.Pointer)(unsafe.Pointer(&goSlice2[0]))))
	(*error) = (*error)[:cap(*error)]
	for i := 0; i < len(*error); i++ {
		if goSlice2[i] == nil {
			(*error) = (*error)[:i]
			break
		}
		if (*error)[i] == nil {
			(*error)[i] = &NSError{}
			runtime.SetFinalizer((*error)[i], func(o *NSError) {
				o.Release()
			})
		}
		(*error)[i].ptr = goSlice2[i]
	}
	if ret.ptr == nil { return ret }
	runtime.SetFinalizer(ret, func(o *NSString) {
		o.Release()
	})
	return ret
}

func NSStringWithCStringEncoding(cString *Char, enc NSStringEncoding) *NSString {
	ret := &NSString{}
	ret.ptr = unsafe.Pointer(C.NSString_StringWithCStringEncoding(unsafe.Pointer(cString), (C.NSStringEncoding)(enc)))
	if ret.ptr == nil { return ret }
	runtime.SetFinalizer(ret, func(o *NSString) {
		o.Release()
	})
	return ret
}

func NSStringResolveInstanceMethod(sel SEL) bool {
	ret := (bool)(C.NSString_ResolveInstanceMethod(unsafe.Pointer(sel)))
	return ret
}

func NSStringAllocWithZone(zone *_NSZone) *NSString {
	ret := &NSString{}
	ret.ptr = unsafe.Pointer(C.NSString_AllocWithZone(unsafe.Pointer(zone)))
	if ret.ptr == nil { return ret }
	runtime.SetFinalizer(ret, func(o *NSString) {
		o.Release()
	})
	return ret
}

func NSStringAvailableStringEncodings() *NSStringEncoding {
	ret := (*NSStringEncoding)(unsafe.Pointer(C.NSString_AvailableStringEncodings()))
	return ret
}

func NSStringLocalizedNameOfStringEncoding(encoding NSStringEncoding) *NSString {
	ret := &NSString{}
	ret.ptr = unsafe.Pointer(C.NSString_LocalizedNameOfStringEncoding((C.NSStringEncoding)(encoding)))
	if ret.ptr == nil { return ret }
	return ret
}

func NSStringWithCharactersLength(characters *Unichar, length NSUInteger) *NSString {
	ret := &NSString{}
	ret.ptr = unsafe.Pointer(C.NSString_StringWithCharactersLength(unsafe.Pointer(characters), (C.NSUInteger)(length)))
	if ret.ptr == nil { return ret }
	runtime.SetFinalizer(ret, func(o *NSString) {
		o.Release()
	})
	return ret
}

func NSStringWithContentsOfFileEncoding(path *NSString, enc NSStringEncoding, error *[]*NSError) *NSString {

	goSlice2 := make([]unsafe.Pointer,cap(*error))
	for i := 0; i < len(*error); i++ {
		goSlice2[i] = (*error)[i].Ptr()
	}
	ret := &NSString{}
	ret.ptr = unsafe.Pointer(C.NSString_StringWithContentsOfFileEncoding(path.Ptr(), (C.NSStringEncoding)(enc), (*unsafe.Pointer)(unsafe.Pointer(&goSlice2[0]))))
	(*error) = (*error)[:cap(*error)]
	for i := 0; i < len(*error); i++ {
		if goSlice2[i] == nil {
			(*error) = (*error)[:i]
			break
		}
		if (*error)[i] == nil {
			(*error)[i] = &NSError{}
			runtime.SetFinalizer((*error)[i], func(o *NSError) {
				o.Release()
			})
		}
		(*error)[i].ptr = goSlice2[i]
	}
	if ret.ptr == nil { return ret }
	runtime.SetFinalizer(ret, func(o *NSString) {
		o.Release()
	})
	return ret
}

func NSStringWithContentsOfFileUsedEncoding(path *NSString, enc *NSStringEncoding, error *[]*NSError) *NSString {

	goSlice2 := make([]unsafe.Pointer,cap(*error))
	for i := 0; i < len(*error); i++ {
		goSlice2[i] = (*error)[i].Ptr()
	}
	ret := &NSString{}
	ret.ptr = unsafe.Pointer(C.NSString_StringWithContentsOfFileUsedEncoding(path.Ptr(), unsafe.Pointer(enc), (*unsafe.Pointer)(unsafe.Pointer(&goSlice2[0]))))
	(*error) = (*error)[:cap(*error)]
	for i := 0; i < len(*error); i++ {
		if goSlice2[i] == nil {
			(*error) = (*error)[:i]
			break
		}
		if (*error)[i] == nil {
			(*error)[i] = &NSError{}
			runtime.SetFinalizer((*error)[i], func(o *NSError) {
				o.Release()
			})
		}
		(*error)[i].ptr = goSlice2[i]
	}
	if ret.ptr == nil { return ret }
	runtime.SetFinalizer(ret, func(o *NSString) {
		o.Release()
	})
	return ret
}

func NSStringWithContentsOfFileEncodingError(path *NSString, enc NSStringEncoding, error *[]*NSError) *NSString {

	goSlice2 := make([]unsafe.Pointer,cap(*error))
	for i := 0; i < len(*error); i++ {
		goSlice2[i] = (*error)[i].Ptr()
	}
	ret := &NSString{}
	ret.ptr = unsafe.Pointer(C.NSString_StringWithContentsOfFileEncodingError(path.Ptr(), (C.NSStringEncoding)(enc), (*unsafe.Pointer)(unsafe.Pointer(&goSlice2[0]))))
	(*error) = (*error)[:cap(*error)]
	for i := 0; i < len(*error); i++ {
		if goSlice2[i] == nil {
			(*error) = (*error)[:i]
			break
		}
		if (*error)[i] == nil {
			(*error)[i] = &NSError{}
			runtime.SetFinalizer((*error)[i], func(o *NSError) {
				o.Release()
			})
		}
		(*error)[i].ptr = goSlice2[i]
	}
	if ret.ptr == nil { return ret }
	runtime.SetFinalizer(ret, func(o *NSString) {
		o.Release()
	})
	return ret
}

func NSStringWithContentsOfFileUsedEncodingError(path *NSString, enc *NSStringEncoding, error *[]*NSError) *NSString {

	goSlice2 := make([]unsafe.Pointer,cap(*error))
	for i := 0; i < len(*error); i++ {
		goSlice2[i] = (*error)[i].Ptr()
	}
	ret := &NSString{}
	ret.ptr = unsafe.Pointer(C.NSString_StringWithContentsOfFileUsedEncodingError(path.Ptr(), unsafe.Pointer(enc), (*unsafe.Pointer)(unsafe.Pointer(&goSlice2[0]))))
	(*error) = (*error)[:cap(*error)]
	for i := 0; i < len(*error); i++ {
		if goSlice2[i] == nil {
			(*error) = (*error)[:i]
			break
		}
		if (*error)[i] == nil {
			(*error)[i] = &NSError{}
			runtime.SetFinalizer((*error)[i], func(o *NSError) {
				o.Release()
			})
		}
		(*error)[i].ptr = goSlice2[i]
	}
	if ret.ptr == nil { return ret }
	runtime.SetFinalizer(ret, func(o *NSString) {
		o.Release()
	})
	return ret
}

func NSStringClassFallbacksForKeyedArchiver() *NSArray {
	ret := &NSArray{}
	ret.ptr = unsafe.Pointer(C.NSString_ClassFallbacksForKeyedArchiver())
	if ret.ptr == nil { return ret }
	return ret
}

func NSStringHash() NSUInteger {
	ret := (NSUInteger)(C.NSString_Hash())
	return ret
}

func NSStringWritableTypeIdentifiersForItemProvider() *NSArray {
	ret := &NSArray{}
	ret.ptr = unsafe.Pointer(C.NSString_WritableTypeIdentifiersForItemProvider())
	if ret.ptr == nil { return ret }
	return ret
}

func NSStringKeyPathsForValuesAffectingValueForKey(key *NSString) *NSSet {
	ret := &NSSet{}
	ret.ptr = unsafe.Pointer(C.NSString_KeyPathsForValuesAffectingValueForKey(key.Ptr()))
	if ret.ptr == nil { return ret }
	return ret
}

func NSStringSupportsSecureCoding() bool {
	ret := (bool)(C.NSString_SupportsSecureCoding())
	return ret
}

func NSStringString() *NSString {
	ret := &NSString{}
	ret.ptr = unsafe.Pointer(C.NSString_String())
	if ret.ptr == nil { return ret }
	runtime.SetFinalizer(ret, func(o *NSString) {
		o.Release()
	})
	return ret
}

func NSStringAccessInstanceVariablesDirectly() bool {
	ret := (bool)(C.NSString_AccessInstanceVariablesDirectly())
	return ret
}

func NSStringSetVersion(aVersion NSInteger)  {
	C.NSString_SetVersion((C.NSInteger)(aVersion))
}

func NSStringInstanceMethodSignatureForSelector(aSelector SEL) *NSMethodSignature {
	ret := &NSMethodSignature{}
	ret.ptr = unsafe.Pointer(C.NSString_InstanceMethodSignatureForSelector(unsafe.Pointer(aSelector)))
	if ret.ptr == nil { return ret }
	return ret
}

func NSStringCancelPreviousPerformRequestsWithTarget(aTarget NSObject)  {
	C.NSString_CancelPreviousPerformRequestsWithTarget(aTarget.Ptr())
}

func NSStringCancelPreviousPerformRequestsWithTargetSelector(aTarget NSObject, aSelector SEL, anArgument NSObject)  {
	C.NSString_CancelPreviousPerformRequestsWithTargetSelector(aTarget.Ptr(), unsafe.Pointer(aSelector), anArgument.Ptr())
}

func NSStringCancelPreviousPerformRequestsWithTargetSelectorObject(aTarget NSObject, aSelector SEL, anArgument NSObject)  {
	C.NSString_CancelPreviousPerformRequestsWithTargetSelectorObject(aTarget.Ptr(), unsafe.Pointer(aSelector), anArgument.Ptr())
}

func NSStringDebugDescription() *NSString {
	ret := &NSString{}
	ret.ptr = unsafe.Pointer(C.NSString_DebugDescription())
	if ret.ptr == nil { return ret }
	return ret
}

func NSStringReadableTypeIdentifiersForItemProvider() *NSArray {
	ret := &NSArray{}
	ret.ptr = unsafe.Pointer(C.NSString_ReadableTypeIdentifiersForItemProvider())
	if ret.ptr == nil { return ret }
	return ret
}

func NSStringItemProviderVisibilityForRepresentationWithTypeIdentifier(typeIdentifier *NSString) NSItemProviderRepresentationVisibility {
	ret := (NSItemProviderRepresentationVisibility)(C.NSString_ItemProviderVisibilityForRepresentationWithTypeIdentifier(typeIdentifier.Ptr()))
	return ret
}

func NSStringIsSubclassOfClass(aClass Class) bool {
	ret := (bool)(C.NSString_IsSubclassOfClass(unsafe.Pointer(aClass)))
	return ret
}

func NSStringLoad()  {
	C.NSString_Load()
}

func NSStringInstancesRespondToSelector(aSelector SEL) bool {
	ret := (bool)(C.NSString_InstancesRespondToSelector(unsafe.Pointer(aSelector)))
	return ret
}

func NSStringObjectWithItemProviderDataTypeIdentifier(data *NSData, typeIdentifier *NSString, outError *[]*NSError) *NSString {

	goSlice2 := make([]unsafe.Pointer,cap(*outError))
	for i := 0; i < len(*outError); i++ {
		goSlice2[i] = (*outError)[i].Ptr()
	}
	ret := &NSString{}
	ret.ptr = unsafe.Pointer(C.NSString_ObjectWithItemProviderDataTypeIdentifier(data.Ptr(), typeIdentifier.Ptr(), (*unsafe.Pointer)(unsafe.Pointer(&goSlice2[0]))))
	(*outError) = (*outError)[:cap(*outError)]
	for i := 0; i < len(*outError); i++ {
		if goSlice2[i] == nil {
			(*outError) = (*outError)[:i]
			break
		}
		if (*outError)[i] == nil {
			(*outError)[i] = &NSError{}
			runtime.SetFinalizer((*outError)[i], func(o *NSError) {
				o.Release()
			})
		}
		(*outError)[i].ptr = goSlice2[i]
	}
	if ret.ptr == nil { return ret }
	return ret
}

func NSStringObjectWithItemProviderDataTypeIdentifierError(data *NSData, typeIdentifier *NSString, outError *[]*NSError) *NSString {

	goSlice2 := make([]unsafe.Pointer,cap(*outError))
	for i := 0; i < len(*outError); i++ {
		goSlice2[i] = (*outError)[i].Ptr()
	}
	ret := &NSString{}
	ret.ptr = unsafe.Pointer(C.NSString_ObjectWithItemProviderDataTypeIdentifierError(data.Ptr(), typeIdentifier.Ptr(), (*unsafe.Pointer)(unsafe.Pointer(&goSlice2[0]))))
	(*outError) = (*outError)[:cap(*outError)]
	for i := 0; i < len(*outError); i++ {
		if goSlice2[i] == nil {
			(*outError) = (*outError)[:i]
			break
		}
		if (*outError)[i] == nil {
			(*outError)[i] = &NSError{}
			runtime.SetFinalizer((*outError)[i], func(o *NSError) {
				o.Release()
			})
		}
		(*outError)[i].ptr = goSlice2[i]
	}
	if ret.ptr == nil { return ret }
	return ret
}

func NSStringDefaultCStringEncoding() NSStringEncoding {
	ret := (NSStringEncoding)(C.NSString_DefaultCStringEncoding())
	return ret
}

func NSStringAlloc() *NSString {
	ret := &NSString{}
	ret.ptr = unsafe.Pointer(C.NSString_Alloc())
	if ret.ptr == nil { return ret }
	runtime.SetFinalizer(ret, func(o *NSString) {
		o.Release()
	})
	return ret
}

func (o *NSString) GC() {
	if o.ptr == nil { return }
	runtime.SetFinalizer(o, func(o *NSString) {
		o.Release()
	})
	runtime.KeepAlive(o)
}

func NSStringClass() Class {
	ret := (Class)(unsafe.Pointer(C.NSString_Class()))
	return ret
}

func NSStringSuperclass() Class {
	ret := (Class)(unsafe.Pointer(C.NSString_Superclass()))
	return ret
}

func NSStringNew() *NSString {
	ret := &NSString{}
	ret.ptr = unsafe.Pointer(C.NSString_New())
	if ret.ptr == nil { return ret }
	runtime.SetFinalizer(ret, func(o *NSString) {
		o.Release()
	})
	return ret
}

func NSStringAutomaticallyNotifiesObserversForKey(key *NSString) bool {
	ret := (bool)(C.NSString_AutomaticallyNotifiesObserversForKey(key.Ptr()))
	return ret
}

func NSStringConformsToProtocol(protocol Protocol) bool {
	ret := (bool)(C.NSString_ConformsToProtocol(protocol.Ptr()))
	return ret
}

func NSStringEncodingForDataEncodingOptions(data *NSData, opts *NSDictionary, string *[]*NSString, usedLossyConversion *BOOL) NSStringEncoding {

	goSlice2 := make([]unsafe.Pointer,cap(*string))
	for i := 0; i < len(*string); i++ {
		goSlice2[i] = (*string)[i].Ptr()
	}
	ret := (NSStringEncoding)(C.NSString_StringEncodingForDataEncodingOptions(data.Ptr(), opts.Ptr(), (*unsafe.Pointer)(unsafe.Pointer(&goSlice2[0])), unsafe.Pointer(usedLossyConversion)))
	(*string) = (*string)[:cap(*string)]
	for i := 0; i < len(*string); i++ {
		if goSlice2[i] == nil {
			(*string) = (*string)[:i]
			break
		}
		if (*string)[i] == nil {
			(*string)[i] = &NSString{}
			runtime.SetFinalizer((*string)[i], func(o *NSString) {
				o.Release()
			})
		}
		(*string)[i].ptr = goSlice2[i]
	}
	return ret
}

func NSStringEncodingForDataEncodingOptionsConvertedString(data *NSData, opts *NSDictionary, string *[]*NSString, usedLossyConversion *BOOL) NSStringEncoding {

	goSlice2 := make([]unsafe.Pointer,cap(*string))
	for i := 0; i < len(*string); i++ {
		goSlice2[i] = (*string)[i].Ptr()
	}
	ret := (NSStringEncoding)(C.NSString_StringEncodingForDataEncodingOptionsConvertedString(data.Ptr(), opts.Ptr(), (*unsafe.Pointer)(unsafe.Pointer(&goSlice2[0])), unsafe.Pointer(usedLossyConversion)))
	(*string) = (*string)[:cap(*string)]
	for i := 0; i < len(*string); i++ {
		if goSlice2[i] == nil {
			(*string) = (*string)[:i]
			break
		}
		if (*string)[i] == nil {
			(*string)[i] = &NSString{}
			runtime.SetFinalizer((*string)[i], func(o *NSString) {
				o.Release()
			})
		}
		(*string)[i].ptr = goSlice2[i]
	}
	return ret
}

func NSStringCopyWithZone(zone *_NSZone) *Id {
	ret := &Id{}
	ret.ptr = unsafe.Pointer(C.NSString_CopyWithZone(unsafe.Pointer(zone)))
	if ret.ptr == nil { return ret }
	runtime.SetFinalizer(ret, func(o *Id) {
		o.Release()
	})
	return ret
}

func NSStringVersion() NSInteger {
	ret := (NSInteger)(C.NSString_Version())
	return ret
}

func NSStringMutableCopyWithZone(zone *_NSZone) *Id {
	ret := &Id{}
	ret.ptr = unsafe.Pointer(C.NSString_MutableCopyWithZone(unsafe.Pointer(zone)))
	if ret.ptr == nil { return ret }
	runtime.SetFinalizer(ret, func(o *Id) {
		o.Release()
	})
	return ret
}

func NSStringPathWithComponents(components *NSArray) *NSString {
	ret := &NSString{}
	ret.ptr = unsafe.Pointer(C.NSString_PathWithComponents(components.Ptr()))
	if ret.ptr == nil { return ret }
	return ret
}

func NSStringResolveClassMethod(sel SEL) bool {
	ret := (bool)(C.NSString_ResolveClassMethod(unsafe.Pointer(sel)))
	return ret
}

func NSStringClassForKeyedUnarchiver() Class {
	ret := (Class)(unsafe.Pointer(C.NSString_ClassForKeyedUnarchiver()))
	return ret
}

func (o *NSString) WriteToFileAtomically(path *NSString, useAuxiliaryFile BOOL, enc NSStringEncoding, error *[]*NSError) bool {

	goSlice4 := make([]unsafe.Pointer,cap(*error))
	for i := 0; i < len(*error); i++ {
		goSlice4[i] = (*error)[i].Ptr()
	}
	ret := (bool)(C.NSString_inst_WriteToFileAtomically(o.Ptr(), path.Ptr(), (C.BOOL)(useAuxiliaryFile), (C.NSStringEncoding)(enc), (*unsafe.Pointer)(unsafe.Pointer(&goSlice4[0]))))
	(*error) = (*error)[:cap(*error)]
	for i := 0; i < len(*error); i++ {
		if goSlice4[i] == nil {
			(*error) = (*error)[:i]
			break
		}
		if (*error)[i] == nil {
			(*error)[i] = &NSError{}
			runtime.SetFinalizer((*error)[i], func(o *NSError) {
				o.Release()
			})
		}
		(*error)[i].ptr = goSlice4[i]
	}
	runtime.KeepAlive(o)
	return ret
}

func (o *NSString) WriteToFileAtomicallyEncoding(path *NSString, useAuxiliaryFile BOOL, enc NSStringEncoding, error *[]*NSError) bool {

	goSlice4 := make([]unsafe.Pointer,cap(*error))
	for i := 0; i < len(*error); i++ {
		goSlice4[i] = (*error)[i].Ptr()
	}
	ret := (bool)(C.NSString_inst_WriteToFileAtomicallyEncoding(o.Ptr(), path.Ptr(), (C.BOOL)(useAuxiliaryFile), (C.NSStringEncoding)(enc), (*unsafe.Pointer)(unsafe.Pointer(&goSlice4[0]))))
	(*error) = (*error)[:cap(*error)]
	for i := 0; i < len(*error); i++ {
		if goSlice4[i] == nil {
			(*error) = (*error)[:i]
			break
		}
		if (*error)[i] == nil {
			(*error)[i] = &NSError{}
			runtime.SetFinalizer((*error)[i], func(o *NSError) {
				o.Release()
			})
		}
		(*error)[i].ptr = goSlice4[i]
	}
	runtime.KeepAlive(o)
	return ret
}

func (o *NSString) LocalizedStandardRangeOfString(str *NSString) NSRange {
	ret := (NSRange)(C.NSString_inst_LocalizedStandardRangeOfString(o.Ptr(), str.Ptr()))
	runtime.KeepAlive(o)
	return ret
}

func (o *NSString) ParagraphRangeForRange(range_ NSRange) NSRange {
	ret := (NSRange)(C.NSString_inst_ParagraphRangeForRange(o.Ptr(), (C.NSRange)(range_)))
	runtime.KeepAlive(o)
	return ret
}

func (o *NSString) IsNotEqualTo(object NSObject) bool {
	ret := (bool)(C.NSString_inst_IsNotEqualTo(o.Ptr(), object.Ptr()))
	runtime.KeepAlive(o)
	return ret
}

func (o *NSString) IntegerValue() NSInteger {
	ret := (NSInteger)(C.NSString_inst_IntegerValue(o.Ptr()))
	runtime.KeepAlive(o)
	return ret
}

func (o *NSString) Description() *NSString {
	ret := &NSString{}
	ret.ptr = unsafe.Pointer(C.NSString_inst_Description(o.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSString)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *NSString) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *NSString) RangeOfCharacterFromSet(searchSet *NSCharacterSet) NSRange {
	ret := (NSRange)(C.NSString_inst_RangeOfCharacterFromSet(o.Ptr(), searchSet.Ptr()))
	runtime.KeepAlive(o)
	return ret
}

func (o *NSString) RangeOfCharacterFromSetOptions(searchSet *NSCharacterSet, mask NSStringCompareOptions) NSRange {
	ret := (NSRange)(C.NSString_inst_RangeOfCharacterFromSetOptions(o.Ptr(), searchSet.Ptr(), (C.NSStringCompareOptions)(mask)))
	runtime.KeepAlive(o)
	return ret
}

func (o *NSString) RangeOfCharacterFromSetOptionsRange(searchSet *NSCharacterSet, mask NSStringCompareOptions, rangeOfReceiverToSearch NSRange) NSRange {
	ret := (NSRange)(C.NSString_inst_RangeOfCharacterFromSetOptionsRange(o.Ptr(), searchSet.Ptr(), (C.NSStringCompareOptions)(mask), (C.NSRange)(rangeOfReceiverToSearch)))
	runtime.KeepAlive(o)
	return ret
}

func (o *NSString) VariantFittingPresentationWidth(width NSInteger) *NSString {
	ret := &NSString{}
	ret.ptr = unsafe.Pointer(C.NSString_inst_VariantFittingPresentationWidth(o.Ptr(), (C.NSInteger)(width)))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSString)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *NSString) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *NSString) CopyScriptingValueForKey(value NSObject, key *NSString, properties *NSDictionary) *Id {
	ret := &Id{}
	ret.ptr = unsafe.Pointer(C.NSString_inst_CopyScriptingValueForKey(o.Ptr(), value.Ptr(), key.Ptr(), properties.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *Id) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *NSString) CopyScriptingValueForKeyWithProperties(value NSObject, key *NSString, properties *NSDictionary) *Id {
	ret := &Id{}
	ret.ptr = unsafe.Pointer(C.NSString_inst_CopyScriptingValueForKeyWithProperties(o.Ptr(), value.Ptr(), key.Ptr(), properties.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *Id) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *NSString) SmallestEncoding() NSStringEncoding {
	ret := (NSStringEncoding)(C.NSString_inst_SmallestEncoding(o.Ptr()))
	runtime.KeepAlive(o)
	return ret
}

func (o *NSString) InitWithContentsOfFileEncoding(path *NSString, enc NSStringEncoding, error *[]*NSError) *NSString {

	goSlice3 := make([]unsafe.Pointer,cap(*error))
	for i := 0; i < len(*error); i++ {
		goSlice3[i] = (*error)[i].Ptr()
	}
	ret := &NSString{}
	ret.ptr = unsafe.Pointer(C.NSString_inst_InitWithContentsOfFileEncoding(o.Ptr(), path.Ptr(), (C.NSStringEncoding)(enc), (*unsafe.Pointer)(unsafe.Pointer(&goSlice3[0]))))
	(*error) = (*error)[:cap(*error)]
	for i := 0; i < len(*error); i++ {
		if goSlice3[i] == nil {
			(*error) = (*error)[:i]
			break
		}
		if (*error)[i] == nil {
			(*error)[i] = &NSError{}
			runtime.SetFinalizer((*error)[i], func(o *NSError) {
				o.Release()
			})
		}
		(*error)[i].ptr = goSlice3[i]
	}
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSString)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *NSString) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *NSString) InitWithContentsOfFileUsedEncoding(path *NSString, enc *NSStringEncoding, error *[]*NSError) *NSString {

	goSlice3 := make([]unsafe.Pointer,cap(*error))
	for i := 0; i < len(*error); i++ {
		goSlice3[i] = (*error)[i].Ptr()
	}
	ret := &NSString{}
	ret.ptr = unsafe.Pointer(C.NSString_inst_InitWithContentsOfFileUsedEncoding(o.Ptr(), path.Ptr(), unsafe.Pointer(enc), (*unsafe.Pointer)(unsafe.Pointer(&goSlice3[0]))))
	(*error) = (*error)[:cap(*error)]
	for i := 0; i < len(*error); i++ {
		if goSlice3[i] == nil {
			(*error) = (*error)[:i]
			break
		}
		if (*error)[i] == nil {
			(*error)[i] = &NSError{}
			runtime.SetFinalizer((*error)[i], func(o *NSError) {
				o.Release()
			})
		}
		(*error)[i].ptr = goSlice3[i]
	}
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSString)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *NSString) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *NSString) InitWithContentsOfFileEncodingError(path *NSString, enc NSStringEncoding, error *[]*NSError) *NSString {

	goSlice3 := make([]unsafe.Pointer,cap(*error))
	for i := 0; i < len(*error); i++ {
		goSlice3[i] = (*error)[i].Ptr()
	}
	ret := &NSString{}
	ret.ptr = unsafe.Pointer(C.NSString_inst_InitWithContentsOfFileEncodingError(o.Ptr(), path.Ptr(), (C.NSStringEncoding)(enc), (*unsafe.Pointer)(unsafe.Pointer(&goSlice3[0]))))
	(*error) = (*error)[:cap(*error)]
	for i := 0; i < len(*error); i++ {
		if goSlice3[i] == nil {
			(*error) = (*error)[:i]
			break
		}
		if (*error)[i] == nil {
			(*error)[i] = &NSError{}
			runtime.SetFinalizer((*error)[i], func(o *NSError) {
				o.Release()
			})
		}
		(*error)[i].ptr = goSlice3[i]
	}
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSString)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *NSString) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *NSString) InitWithContentsOfFileUsedEncodingError(path *NSString, enc *NSStringEncoding, error *[]*NSError) *NSString {

	goSlice3 := make([]unsafe.Pointer,cap(*error))
	for i := 0; i < len(*error); i++ {
		goSlice3[i] = (*error)[i].Ptr()
	}
	ret := &NSString{}
	ret.ptr = unsafe.Pointer(C.NSString_inst_InitWithContentsOfFileUsedEncodingError(o.Ptr(), path.Ptr(), unsafe.Pointer(enc), (*unsafe.Pointer)(unsafe.Pointer(&goSlice3[0]))))
	(*error) = (*error)[:cap(*error)]
	for i := 0; i < len(*error); i++ {
		if goSlice3[i] == nil {
			(*error) = (*error)[:i]
			break
		}
		if (*error)[i] == nil {
			(*error)[i] = &NSError{}
			runtime.SetFinalizer((*error)[i], func(o *NSError) {
				o.Release()
			})
		}
		(*error)[i].ptr = goSlice3[i]
	}
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSString)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *NSString) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *NSString) LocalizedCapitalizedString() *NSString {
	ret := &NSString{}
	ret.ptr = unsafe.Pointer(C.NSString_inst_LocalizedCapitalizedString(o.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSString)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *NSString) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *NSString) ClassForArchiver() Class {
	ret := (Class)(unsafe.Pointer(C.NSString_inst_ClassForArchiver(o.Ptr())))
	runtime.KeepAlive(o)
	return ret
}

func (o *NSString) CoerceValueForKey(value NSObject, key *NSString) *Id {
	ret := &Id{}
	ret.ptr = unsafe.Pointer(C.NSString_inst_CoerceValueForKey(o.Ptr(), value.Ptr(), key.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *Id) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *NSString) WillChangeValueForKey(key *NSString)  {
	C.NSString_inst_WillChangeValueForKey(o.Ptr(), key.Ptr())
	runtime.KeepAlive(o)
}

func (o *NSString) WillChangeValueForKeyWithSetMutation(key *NSString, mutationKind NSKeyValueSetMutationKind, objects *NSSet)  {
	C.NSString_inst_WillChangeValueForKeyWithSetMutation(o.Ptr(), key.Ptr(), (C.NSKeyValueSetMutationKind)(mutationKind), objects.Ptr())
	runtime.KeepAlive(o)
}

func (o *NSString) WillChangeValueForKeyWithSetMutationUsingObjects(key *NSString, mutationKind NSKeyValueSetMutationKind, objects *NSSet)  {
	C.NSString_inst_WillChangeValueForKeyWithSetMutationUsingObjects(o.Ptr(), key.Ptr(), (C.NSKeyValueSetMutationKind)(mutationKind), objects.Ptr())
	runtime.KeepAlive(o)
}

func (o *NSString) GetBytesMaxLength(buffer unsafe.Pointer, maxBufferCount NSUInteger, usedBufferCount *NSUInteger, encoding NSStringEncoding, options NSStringEncodingConversionOptions, range_ NSRange, leftover NSRangePointer) bool {
	ret := (bool)(C.NSString_inst_GetBytesMaxLength(o.Ptr(), unsafe.Pointer(buffer), (C.NSUInteger)(maxBufferCount), unsafe.Pointer(usedBufferCount), (C.NSStringEncoding)(encoding), (C.NSStringEncodingConversionOptions)(options), (C.NSRange)(range_), unsafe.Pointer(leftover)))
	runtime.KeepAlive(o)
	return ret
}

func (o *NSString) GetBytesMaxLengthUsedLength(buffer unsafe.Pointer, maxBufferCount NSUInteger, usedBufferCount *NSUInteger, encoding NSStringEncoding, options NSStringEncodingConversionOptions, range_ NSRange, leftover NSRangePointer) bool {
	ret := (bool)(C.NSString_inst_GetBytesMaxLengthUsedLength(o.Ptr(), unsafe.Pointer(buffer), (C.NSUInteger)(maxBufferCount), unsafe.Pointer(usedBufferCount), (C.NSStringEncoding)(encoding), (C.NSStringEncodingConversionOptions)(options), (C.NSRange)(range_), unsafe.Pointer(leftover)))
	runtime.KeepAlive(o)
	return ret
}

func (o *NSString) LocalizedStandardCompare(string *NSString) NSComparisonResult {
	ret := (NSComparisonResult)(C.NSString_inst_LocalizedStandardCompare(o.Ptr(), string.Ptr()))
	runtime.KeepAlive(o)
	return ret
}

func (o *NSString) StringByStandardizingPath() *NSString {
	ret := &NSString{}
	ret.ptr = unsafe.Pointer(C.NSString_inst_StringByStandardizingPath(o.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSString)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *NSString) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *NSString) ScriptingValueForSpecifier(objectSpecifier *NSScriptObjectSpecifier) *Id {
	ret := &Id{}
	ret.ptr = unsafe.Pointer(C.NSString_inst_ScriptingValueForSpecifier(o.Ptr(), objectSpecifier.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *Id) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *NSString) InverseForRelationshipKey(relationshipKey *NSString) *NSString {
	ret := &NSString{}
	ret.ptr = unsafe.Pointer(C.NSString_inst_InverseForRelationshipKey(o.Ptr(), relationshipKey.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSString)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *NSString) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *NSString) MutableCopy() *Id {
	ret := &Id{}
	ret.ptr = unsafe.Pointer(C.NSString_inst_MutableCopy(o.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	runtime.SetFinalizer(ret, func(o *Id) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *NSString) SetObservationInfo(observationInfo unsafe.Pointer)  {
	C.NSString_inst_SetObservationInfo(o.Ptr(), unsafe.Pointer(observationInfo))
	runtime.KeepAlive(o)
}

func (o *NSString) StringByExpandingTildeInPath() *NSString {
	ret := &NSString{}
	ret.ptr = unsafe.Pointer(C.NSString_inst_StringByExpandingTildeInPath(o.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSString)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *NSString) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *NSString) IsEqualToString(aString *NSString) bool {
	ret := (bool)(C.NSString_inst_IsEqualToString(o.Ptr(), aString.Ptr()))
	runtime.KeepAlive(o)
	return ret
}

func (o *NSString) ScriptingContains(object NSObject) bool {
	ret := (bool)(C.NSString_inst_ScriptingContains(o.Ptr(), object.Ptr()))
	runtime.KeepAlive(o)
	return ret
}

func (o *NSString) StringByDeletingPathExtension() *NSString {
	ret := &NSString{}
	ret.ptr = unsafe.Pointer(C.NSString_inst_StringByDeletingPathExtension(o.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSString)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *NSString) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *NSString) StringsByAppendingPaths(paths *NSArray) *NSArray {
	ret := &NSArray{}
	ret.ptr = unsafe.Pointer(C.NSString_inst_StringsByAppendingPaths(o.Ptr(), paths.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSArray)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *NSArray) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *NSString) InitWithCharactersLength(characters *Unichar, length NSUInteger) *NSString {
	ret := &NSString{}
	ret.ptr = unsafe.Pointer(C.NSString_inst_InitWithCharactersLength(o.Ptr(), unsafe.Pointer(characters), (C.NSUInteger)(length)))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSString)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *NSString) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *NSString) InitWithCStringEncoding(nullTerminatedCString *Char, encoding NSStringEncoding) *NSString {
	ret := &NSString{}
	ret.ptr = unsafe.Pointer(C.NSString_inst_InitWithCStringEncoding(o.Ptr(), unsafe.Pointer(nullTerminatedCString), (C.NSStringEncoding)(encoding)))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSString)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *NSString) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *NSString) ForwardingTargetForSelector(aSelector SEL) *Id {
	ret := &Id{}
	ret.ptr = unsafe.Pointer(C.NSString_inst_ForwardingTargetForSelector(o.Ptr(), unsafe.Pointer(aSelector)))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *Id) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *NSString) AttemptRecoveryFromErrorOptionIndex(error *NSError, recoveryOptionIndex NSUInteger) bool {
	ret := (bool)(C.NSString_inst_AttemptRecoveryFromErrorOptionIndex(o.Ptr(), error.Ptr(), (C.NSUInteger)(recoveryOptionIndex)))
	runtime.KeepAlive(o)
	return ret
}

func (o *NSString) AttemptRecoveryFromErrorOptionIndexDelegate(error *NSError, recoveryOptionIndex NSUInteger, delegate NSObject, didRecoverSelector SEL, contextInfo unsafe.Pointer)  {
	C.NSString_inst_AttemptRecoveryFromErrorOptionIndexDelegate(o.Ptr(), error.Ptr(), (C.NSUInteger)(recoveryOptionIndex), delegate.Ptr(), unsafe.Pointer(didRecoverSelector), unsafe.Pointer(contextInfo))
	runtime.KeepAlive(o)
}

func (o *NSString) AttemptRecoveryFromErrorOptionIndexDelegateDidRecoverSelector(error *NSError, recoveryOptionIndex NSUInteger, delegate NSObject, didRecoverSelector SEL, contextInfo unsafe.Pointer)  {
	C.NSString_inst_AttemptRecoveryFromErrorOptionIndexDelegateDidRecoverSelector(o.Ptr(), error.Ptr(), (C.NSUInteger)(recoveryOptionIndex), delegate.Ptr(), unsafe.Pointer(didRecoverSelector), unsafe.Pointer(contextInfo))
	runtime.KeepAlive(o)
}

func (o *NSString) LocalizedUppercaseString() *NSString {
	ret := &NSString{}
	ret.ptr = unsafe.Pointer(C.NSString_inst_LocalizedUppercaseString(o.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSString)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *NSString) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *NSString) CharacterAtIndex(index NSUInteger) Unichar {
	ret := (Unichar)(C.NSString_inst_CharacterAtIndex(o.Ptr(), (C.NSUInteger)(index)))
	runtime.KeepAlive(o)
	return ret
}

func (o *NSString) InitWithString(aString *NSString) *NSString {
	ret := &NSString{}
	ret.ptr = unsafe.Pointer(C.NSString_inst_InitWithString(o.Ptr(), aString.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSString)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *NSString) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *NSString) InitWithGoString(aString string) *NSString {
	aString_chr := CharWithGoString(aString)
	defer aString_chr.Free()
	ret := o.InitWithString(NSStringWithUTF8String(aString_chr))
	return ret
}

func (o *NSString) ValueWithUniqueIDInPropertyWithKey(uniqueID NSObject, key *NSString) *Id {
	ret := &Id{}
	ret.ptr = unsafe.Pointer(C.NSString_inst_ValueWithUniqueIDInPropertyWithKey(o.Ptr(), uniqueID.Ptr(), key.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *Id) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *NSString) ScriptingIsEqualTo(object NSObject) bool {
	ret := (bool)(C.NSString_inst_ScriptingIsEqualTo(o.Ptr(), object.Ptr()))
	runtime.KeepAlive(o)
	return ret
}

func (o *NSString) RemoveObserverForKeyPath(observer NSObject, keyPath *NSString)  {
	C.NSString_inst_RemoveObserverForKeyPath(o.Ptr(), observer.Ptr(), keyPath.Ptr())
	runtime.KeepAlive(o)
}

func (o *NSString) RemoveObserverForKeyPathContext(observer NSObject, keyPath *NSString, context unsafe.Pointer)  {
	C.NSString_inst_RemoveObserverForKeyPathContext(o.Ptr(), observer.Ptr(), keyPath.Ptr(), unsafe.Pointer(context))
	runtime.KeepAlive(o)
}

func (o *NSString) CanBeConvertedToEncoding(encoding NSStringEncoding) bool {
	ret := (bool)(C.NSString_inst_CanBeConvertedToEncoding(o.Ptr(), (C.NSStringEncoding)(encoding)))
	runtime.KeepAlive(o)
	return ret
}

func (o *NSString) PathComponents() *NSArray {
	ret := &NSArray{}
	ret.ptr = unsafe.Pointer(C.NSString_inst_PathComponents(o.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSArray)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *NSArray) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *NSString) LowercaseStringWithLocale(locale *NSLocale) *NSString {
	ret := &NSString{}
	ret.ptr = unsafe.Pointer(C.NSString_inst_LowercaseStringWithLocale(o.Ptr(), locale.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSString)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *NSString) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *NSString) InitWithBytesLength(bytes unsafe.Pointer, len_ NSUInteger, encoding NSStringEncoding) *NSString {
	ret := &NSString{}
	ret.ptr = unsafe.Pointer(C.NSString_inst_InitWithBytesLength(o.Ptr(), unsafe.Pointer(bytes), (C.NSUInteger)(len_), (C.NSStringEncoding)(encoding)))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSString)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *NSString) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *NSString) InitWithBytesLengthEncoding(bytes unsafe.Pointer, len_ NSUInteger, encoding NSStringEncoding) *NSString {
	ret := &NSString{}
	ret.ptr = unsafe.Pointer(C.NSString_inst_InitWithBytesLengthEncoding(o.Ptr(), unsafe.Pointer(bytes), (C.NSUInteger)(len_), (C.NSStringEncoding)(encoding)))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSString)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *NSString) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *NSString) LastPathComponent() *NSString {
	ret := &NSString{}
	ret.ptr = unsafe.Pointer(C.NSString_inst_LastPathComponent(o.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSString)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *NSString) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *NSString) SetScriptingProperties(scriptingProperties *NSDictionary)  {
	C.NSString_inst_SetScriptingProperties(o.Ptr(), scriptingProperties.Ptr())
	runtime.KeepAlive(o)
}

func (o *NSString) IsLessThanOrEqualTo(object NSObject) bool {
	ret := (bool)(C.NSString_inst_IsLessThanOrEqualTo(o.Ptr(), object.Ptr()))
	runtime.KeepAlive(o)
	return ret
}

func (o *NSString) ReplacementObjectForKeyedArchiver(archiver *NSKeyedArchiver) *Id {
	ret := &Id{}
	ret.ptr = unsafe.Pointer(C.NSString_inst_ReplacementObjectForKeyedArchiver(o.Ptr(), archiver.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *Id) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *NSString) ObjectSpecifier() *NSScriptObjectSpecifier {
	ret := &NSScriptObjectSpecifier{}
	ret.ptr = unsafe.Pointer(C.NSString_inst_ObjectSpecifier(o.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSScriptObjectSpecifier)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *NSScriptObjectSpecifier) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *NSString) InsertValueInPropertyWithKey(value NSObject, key *NSString)  {
	C.NSString_inst_InsertValueInPropertyWithKey(o.Ptr(), value.Ptr(), key.Ptr())
	runtime.KeepAlive(o)
}

func (o *NSString) InsertValueAtIndex(value NSObject, index NSUInteger, key *NSString)  {
	C.NSString_inst_InsertValueAtIndex(o.Ptr(), value.Ptr(), (C.NSUInteger)(index), key.Ptr())
	runtime.KeepAlive(o)
}

func (o *NSString) InsertValueAtIndexInPropertyWithKey(value NSObject, index NSUInteger, key *NSString)  {
	C.NSString_inst_InsertValueAtIndexInPropertyWithKey(o.Ptr(), value.Ptr(), (C.NSUInteger)(index), key.Ptr())
	runtime.KeepAlive(o)
}

func (o *NSString) CStringUsingEncoding(encoding NSStringEncoding) *Char {
	ret := (*Char)(unsafe.Pointer(C.NSString_inst_CStringUsingEncoding(o.Ptr(), (C.NSStringEncoding)(encoding))))
	runtime.KeepAlive(o)
	return ret
}

func (o *NSString) LowercaseString() *NSString {
	ret := &NSString{}
	ret.ptr = unsafe.Pointer(C.NSString_inst_LowercaseString(o.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSString)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *NSString) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *NSString) LocalizedStandardContainsString(str *NSString) bool {
	ret := (bool)(C.NSString_inst_LocalizedStandardContainsString(o.Ptr(), str.Ptr()))
	runtime.KeepAlive(o)
	return ret
}

func (o *NSString) StringByTrimmingCharactersInSet(set *NSCharacterSet) *NSString {
	ret := &NSString{}
	ret.ptr = unsafe.Pointer(C.NSString_inst_StringByTrimmingCharactersInSet(o.Ptr(), set.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSString)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *NSString) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *NSString) MutableOrderedSetValueForKey(key *NSString) *NSMutableOrderedSet {
	ret := &NSMutableOrderedSet{}
	ret.ptr = unsafe.Pointer(C.NSString_inst_MutableOrderedSetValueForKey(o.Ptr(), key.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSMutableOrderedSet)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *NSMutableOrderedSet) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *NSString) ValueForKey(key *NSString) *Id {
	ret := &Id{}
	ret.ptr = unsafe.Pointer(C.NSString_inst_ValueForKey(o.Ptr(), key.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *Id) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *NSString) ClassForKeyedArchiver() Class {
	ret := (Class)(unsafe.Pointer(C.NSString_inst_ClassForKeyedArchiver(o.Ptr())))
	runtime.KeepAlive(o)
	return ret
}

func (o *NSString) ReplaceValueAtIndexInPropertyWithKey(index NSUInteger, key *NSString, value NSObject)  {
	C.NSString_inst_ReplaceValueAtIndexInPropertyWithKey(o.Ptr(), (C.NSUInteger)(index), key.Ptr(), value.Ptr())
	runtime.KeepAlive(o)
}

func (o *NSString) ReplaceValueAtIndexInPropertyWithKeyWithValue(index NSUInteger, key *NSString, value NSObject)  {
	C.NSString_inst_ReplaceValueAtIndexInPropertyWithKeyWithValue(o.Ptr(), (C.NSUInteger)(index), key.Ptr(), value.Ptr())
	runtime.KeepAlive(o)
}

func (o *NSString) ObservationInfo() unsafe.Pointer {
	ret := (unsafe.Pointer)(unsafe.Pointer(C.NSString_inst_ObservationInfo(o.Ptr())))
	runtime.KeepAlive(o)
	return ret
}

func (o *NSString) ValidateValueForKey(ioValue *[]*Id, inKey *NSString, outError *[]*NSError) bool {

	goSlice1 := make([]unsafe.Pointer,cap(*ioValue))
	for i := 0; i < len(*ioValue); i++ {
		goSlice1[i] = (*ioValue)[i].Ptr()
	}

	goSlice3 := make([]unsafe.Pointer,cap(*outError))
	for i := 0; i < len(*outError); i++ {
		goSlice3[i] = (*outError)[i].Ptr()
	}
	ret := (bool)(C.NSString_inst_ValidateValueForKey(o.Ptr(), (*unsafe.Pointer)(unsafe.Pointer(&goSlice1[0])), inKey.Ptr(), (*unsafe.Pointer)(unsafe.Pointer(&goSlice3[0]))))
	(*ioValue) = (*ioValue)[:cap(*ioValue)]
	for i := 0; i < len(*ioValue); i++ {
		if goSlice1[i] == nil {
			(*ioValue) = (*ioValue)[:i]
			break
		}
		if (*ioValue)[i] == nil {
			(*ioValue)[i] = &Id{}
			runtime.SetFinalizer((*ioValue)[i], func(o *Id) {
				o.Release()
			})
		}
		(*ioValue)[i].ptr = goSlice1[i]
	}
	(*outError) = (*outError)[:cap(*outError)]
	for i := 0; i < len(*outError); i++ {
		if goSlice3[i] == nil {
			(*outError) = (*outError)[:i]
			break
		}
		if (*outError)[i] == nil {
			(*outError)[i] = &NSError{}
			runtime.SetFinalizer((*outError)[i], func(o *NSError) {
				o.Release()
			})
		}
		(*outError)[i].ptr = goSlice3[i]
	}
	runtime.KeepAlive(o)
	return ret
}

func (o *NSString) ValidateValueForKeyPath(ioValue *[]*Id, inKeyPath *NSString, outError *[]*NSError) bool {

	goSlice1 := make([]unsafe.Pointer,cap(*ioValue))
	for i := 0; i < len(*ioValue); i++ {
		goSlice1[i] = (*ioValue)[i].Ptr()
	}

	goSlice3 := make([]unsafe.Pointer,cap(*outError))
	for i := 0; i < len(*outError); i++ {
		goSlice3[i] = (*outError)[i].Ptr()
	}
	ret := (bool)(C.NSString_inst_ValidateValueForKeyPath(o.Ptr(), (*unsafe.Pointer)(unsafe.Pointer(&goSlice1[0])), inKeyPath.Ptr(), (*unsafe.Pointer)(unsafe.Pointer(&goSlice3[0]))))
	(*ioValue) = (*ioValue)[:cap(*ioValue)]
	for i := 0; i < len(*ioValue); i++ {
		if goSlice1[i] == nil {
			(*ioValue) = (*ioValue)[:i]
			break
		}
		if (*ioValue)[i] == nil {
			(*ioValue)[i] = &Id{}
			runtime.SetFinalizer((*ioValue)[i], func(o *Id) {
				o.Release()
			})
		}
		(*ioValue)[i].ptr = goSlice1[i]
	}
	(*outError) = (*outError)[:cap(*outError)]
	for i := 0; i < len(*outError); i++ {
		if goSlice3[i] == nil {
			(*outError) = (*outError)[:i]
			break
		}
		if (*outError)[i] == nil {
			(*outError)[i] = &NSError{}
			runtime.SetFinalizer((*outError)[i], func(o *NSError) {
				o.Release()
			})
		}
		(*outError)[i].ptr = goSlice3[i]
	}
	runtime.KeepAlive(o)
	return ret
}

func (o *NSString) ValidateValueForKeyError(ioValue *[]*Id, inKey *NSString, outError *[]*NSError) bool {

	goSlice1 := make([]unsafe.Pointer,cap(*ioValue))
	for i := 0; i < len(*ioValue); i++ {
		goSlice1[i] = (*ioValue)[i].Ptr()
	}

	goSlice3 := make([]unsafe.Pointer,cap(*outError))
	for i := 0; i < len(*outError); i++ {
		goSlice3[i] = (*outError)[i].Ptr()
	}
	ret := (bool)(C.NSString_inst_ValidateValueForKeyError(o.Ptr(), (*unsafe.Pointer)(unsafe.Pointer(&goSlice1[0])), inKey.Ptr(), (*unsafe.Pointer)(unsafe.Pointer(&goSlice3[0]))))
	(*ioValue) = (*ioValue)[:cap(*ioValue)]
	for i := 0; i < len(*ioValue); i++ {
		if goSlice1[i] == nil {
			(*ioValue) = (*ioValue)[:i]
			break
		}
		if (*ioValue)[i] == nil {
			(*ioValue)[i] = &Id{}
			runtime.SetFinalizer((*ioValue)[i], func(o *Id) {
				o.Release()
			})
		}
		(*ioValue)[i].ptr = goSlice1[i]
	}
	(*outError) = (*outError)[:cap(*outError)]
	for i := 0; i < len(*outError); i++ {
		if goSlice3[i] == nil {
			(*outError) = (*outError)[:i]
			break
		}
		if (*outError)[i] == nil {
			(*outError)[i] = &NSError{}
			runtime.SetFinalizer((*outError)[i], func(o *NSError) {
				o.Release()
			})
		}
		(*outError)[i].ptr = goSlice3[i]
	}
	runtime.KeepAlive(o)
	return ret
}

func (o *NSString) ValidateValueForKeyPathError(ioValue *[]*Id, inKeyPath *NSString, outError *[]*NSError) bool {

	goSlice1 := make([]unsafe.Pointer,cap(*ioValue))
	for i := 0; i < len(*ioValue); i++ {
		goSlice1[i] = (*ioValue)[i].Ptr()
	}

	goSlice3 := make([]unsafe.Pointer,cap(*outError))
	for i := 0; i < len(*outError); i++ {
		goSlice3[i] = (*outError)[i].Ptr()
	}
	ret := (bool)(C.NSString_inst_ValidateValueForKeyPathError(o.Ptr(), (*unsafe.Pointer)(unsafe.Pointer(&goSlice1[0])), inKeyPath.Ptr(), (*unsafe.Pointer)(unsafe.Pointer(&goSlice3[0]))))
	(*ioValue) = (*ioValue)[:cap(*ioValue)]
	for i := 0; i < len(*ioValue); i++ {
		if goSlice1[i] == nil {
			(*ioValue) = (*ioValue)[:i]
			break
		}
		if (*ioValue)[i] == nil {
			(*ioValue)[i] = &Id{}
			runtime.SetFinalizer((*ioValue)[i], func(o *Id) {
				o.Release()
			})
		}
		(*ioValue)[i].ptr = goSlice1[i]
	}
	(*outError) = (*outError)[:cap(*outError)]
	for i := 0; i < len(*outError); i++ {
		if goSlice3[i] == nil {
			(*outError) = (*outError)[:i]
			break
		}
		if (*outError)[i] == nil {
			(*outError)[i] = &NSError{}
			runtime.SetFinalizer((*outError)[i], func(o *NSError) {
				o.Release()
			})
		}
		(*outError)[i].ptr = goSlice3[i]
	}
	runtime.KeepAlive(o)
	return ret
}

func (o *NSString) IsLike(object *NSString) bool {
	ret := (bool)(C.NSString_inst_IsLike(o.Ptr(), object.Ptr()))
	runtime.KeepAlive(o)
	return ret
}

func (o *NSString) MutableCopyWithZone(zone *NSZone) *Id {
	ret := &Id{}
	ret.ptr = unsafe.Pointer(C.NSString_inst_MutableCopyWithZone(o.Ptr(), unsafe.Pointer(zone)))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *Id) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *NSString) StringByAddingPercentEncodingWithAllowedCharacters(allowedCharacters *NSCharacterSet) *NSString {
	ret := &NSString{}
	ret.ptr = unsafe.Pointer(C.NSString_inst_StringByAddingPercentEncodingWithAllowedCharacters(o.Ptr(), allowedCharacters.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSString)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *NSString) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *NSString) MethodSignatureForSelector(aSelector SEL) *NSMethodSignature {
	ret := &NSMethodSignature{}
	ret.ptr = unsafe.Pointer(C.NSString_inst_MethodSignatureForSelector(o.Ptr(), unsafe.Pointer(aSelector)))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSMethodSignature)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *NSMethodSignature) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *NSString) IsLessThan(object NSObject) bool {
	ret := (bool)(C.NSString_inst_IsLessThan(o.Ptr(), object.Ptr()))
	runtime.KeepAlive(o)
	return ret
}

func (o *NSString) HasSuffix(str *NSString) bool {
	ret := (bool)(C.NSString_inst_HasSuffix(o.Ptr(), str.Ptr()))
	runtime.KeepAlive(o)
	return ret
}

func (o *NSString) UTF8String() *Char {
	ret := (*Char)(unsafe.Pointer(C.NSString_inst_UTF8String(o.Ptr())))
	runtime.KeepAlive(o)
	return ret
}

func (o *NSString) StringByPaddingToLengthWithString(newLength NSUInteger, padString *NSString, padIndex NSUInteger) *NSString {
	ret := &NSString{}
	ret.ptr = unsafe.Pointer(C.NSString_inst_StringByPaddingToLengthWithString(o.Ptr(), (C.NSUInteger)(newLength), padString.Ptr(), (C.NSUInteger)(padIndex)))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSString)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *NSString) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *NSString) StringByPaddingToLengthWithStringStartingAtIndex(newLength NSUInteger, padString *NSString, padIndex NSUInteger) *NSString {
	ret := &NSString{}
	ret.ptr = unsafe.Pointer(C.NSString_inst_StringByPaddingToLengthWithStringStartingAtIndex(o.Ptr(), (C.NSUInteger)(newLength), padString.Ptr(), (C.NSUInteger)(padIndex)))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSString)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *NSString) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *NSString) AutoContentAccessingProxy() *Id {
	ret := &Id{}
	ret.ptr = unsafe.Pointer(C.NSString_inst_AutoContentAccessingProxy(o.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *Id) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *NSString) IsEqualTo(object NSObject) bool {
	ret := (bool)(C.NSString_inst_IsEqualTo(o.Ptr(), object.Ptr()))
	runtime.KeepAlive(o)
	return ret
}

func (o *NSString) IsGreaterThan(object NSObject) bool {
	ret := (bool)(C.NSString_inst_IsGreaterThan(o.Ptr(), object.Ptr()))
	runtime.KeepAlive(o)
	return ret
}

func (o *NSString) GetCharacters(buffer *Unichar)  {
	C.NSString_inst_GetCharacters(o.Ptr(), unsafe.Pointer(buffer))
	runtime.KeepAlive(o)
}

func (o *NSString) GetCharactersRange(buffer *Unichar, range_ NSRange)  {
	C.NSString_inst_GetCharactersRange(o.Ptr(), unsafe.Pointer(buffer), (C.NSRange)(range_))
	runtime.KeepAlive(o)
}

func (o *NSString) UppercaseStringWithLocale(locale *NSLocale) *NSString {
	ret := &NSString{}
	ret.ptr = unsafe.Pointer(C.NSString_inst_UppercaseStringWithLocale(o.Ptr(), locale.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSString)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *NSString) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *NSString) CapitalizedStringWithLocale(locale *NSLocale) *NSString {
	ret := &NSString{}
	ret.ptr = unsafe.Pointer(C.NSString_inst_CapitalizedStringWithLocale(o.Ptr(), locale.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSString)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *NSString) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *NSString) Hash() NSUInteger {
	ret := (NSUInteger)(C.NSString_inst_Hash(o.Ptr()))
	runtime.KeepAlive(o)
	return ret
}

func (o *NSString) LengthOfBytesUsingEncoding(enc NSStringEncoding) NSUInteger {
	ret := (NSUInteger)(C.NSString_inst_LengthOfBytesUsingEncoding(o.Ptr(), (C.NSStringEncoding)(enc)))
	runtime.KeepAlive(o)
	return ret
}

func (o *NSString) ClassDescription() *NSClassDescription {
	ret := &NSClassDescription{}
	ret.ptr = unsafe.Pointer(C.NSString_inst_ClassDescription(o.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSClassDescription)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *NSClassDescription) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *NSString) AwakeAfterUsingCoder(coder *NSCoder) *Id {
	ret := &Id{}
	ret.ptr = unsafe.Pointer(C.NSString_inst_AwakeAfterUsingCoder(o.Ptr(), coder.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *Id) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *NSString) CopyWithZone(zone *NSZone) *Id {
	ret := &Id{}
	ret.ptr = unsafe.Pointer(C.NSString_inst_CopyWithZone(o.Ptr(), unsafe.Pointer(zone)))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *Id) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *NSString) LongLongValue() LongLong {
	ret := (LongLong)(C.NSString_inst_LongLongValue(o.Ptr()))
	runtime.KeepAlive(o)
	return ret
}

func (o *NSString) PathExtension() *NSString {
	ret := &NSString{}
	ret.ptr = unsafe.Pointer(C.NSString_inst_PathExtension(o.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSString)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *NSString) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *NSString) InitWithCharactersNoCopyLength(characters *Unichar, length NSUInteger, freeBuffer BOOL) *NSString {
	ret := &NSString{}
	ret.ptr = unsafe.Pointer(C.NSString_inst_InitWithCharactersNoCopyLength(o.Ptr(), unsafe.Pointer(characters), (C.NSUInteger)(length), (C.BOOL)(freeBuffer)))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSString)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *NSString) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *NSString) InitWithCharactersNoCopyLengthFreeWhenDone(characters *Unichar, length NSUInteger, freeBuffer BOOL) *NSString {
	ret := &NSString{}
	ret.ptr = unsafe.Pointer(C.NSString_inst_InitWithCharactersNoCopyLengthFreeWhenDone(o.Ptr(), unsafe.Pointer(characters), (C.NSUInteger)(length), (C.BOOL)(freeBuffer)))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSString)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *NSString) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *NSString) PerformSelectorWithObject(aSelector SEL, anArgument NSObject, delay NSTimeInterval)  {
	C.NSString_inst_PerformSelectorWithObject(o.Ptr(), unsafe.Pointer(aSelector), anArgument.Ptr(), (C.NSTimeInterval)(delay))
	runtime.KeepAlive(o)
}

func (o *NSString) PerformSelectorWithObjectAfterDelay(aSelector SEL, anArgument NSObject, delay NSTimeInterval)  {
	C.NSString_inst_PerformSelectorWithObjectAfterDelay(o.Ptr(), unsafe.Pointer(aSelector), anArgument.Ptr(), (C.NSTimeInterval)(delay))
	runtime.KeepAlive(o)
}

func (o *NSString) PerformSelectorWithObjectAfterDelayInModes(aSelector SEL, anArgument NSObject, delay NSTimeInterval, modes *NSArray)  {
	C.NSString_inst_PerformSelectorWithObjectAfterDelayInModes(o.Ptr(), unsafe.Pointer(aSelector), anArgument.Ptr(), (C.NSTimeInterval)(delay), modes.Ptr())
	runtime.KeepAlive(o)
}

func (o *NSString) PerformSelectorOnThread(aSelector SEL, thr *NSThread, arg NSObject, wait BOOL)  {
	C.NSString_inst_PerformSelectorOnThread(o.Ptr(), unsafe.Pointer(aSelector), thr.Ptr(), arg.Ptr(), (C.BOOL)(wait))
	runtime.KeepAlive(o)
}

func (o *NSString) PerformSelectorOnThreadWithObject(aSelector SEL, thr *NSThread, arg NSObject, wait BOOL)  {
	C.NSString_inst_PerformSelectorOnThreadWithObject(o.Ptr(), unsafe.Pointer(aSelector), thr.Ptr(), arg.Ptr(), (C.BOOL)(wait))
	runtime.KeepAlive(o)
}

func (o *NSString) PerformSelectorOnThreadWithObjectWaitUntilDone(aSelector SEL, thr *NSThread, arg NSObject, wait BOOL, array *NSArray)  {
	C.NSString_inst_PerformSelectorOnThreadWithObjectWaitUntilDone(o.Ptr(), unsafe.Pointer(aSelector), thr.Ptr(), arg.Ptr(), (C.BOOL)(wait), array.Ptr())
	runtime.KeepAlive(o)
}

func (o *NSString) PerformSelectorOnThreadWithObjectWaitUntilDoneModes(aSelector SEL, thr *NSThread, arg NSObject, wait BOOL, array *NSArray)  {
	C.NSString_inst_PerformSelectorOnThreadWithObjectWaitUntilDoneModes(o.Ptr(), unsafe.Pointer(aSelector), thr.Ptr(), arg.Ptr(), (C.BOOL)(wait), array.Ptr())
	runtime.KeepAlive(o)
}

func (o *NSString) StringByAppendingPathExtension(str *NSString) *NSString {
	ret := &NSString{}
	ret.ptr = unsafe.Pointer(C.NSString_inst_StringByAppendingPathExtension(o.Ptr(), str.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSString)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *NSString) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *NSString) LocalizedCaseInsensitiveContainsString(str *NSString) bool {
	ret := (bool)(C.NSString_inst_LocalizedCaseInsensitiveContainsString(o.Ptr(), str.Ptr()))
	runtime.KeepAlive(o)
	return ret
}

func (o *NSString) StringByAbbreviatingWithTildeInPath() *NSString {
	ret := &NSString{}
	ret.ptr = unsafe.Pointer(C.NSString_inst_StringByAbbreviatingWithTildeInPath(o.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSString)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *NSString) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *NSString) DictionaryWithValuesForKeys(keys *NSArray) *NSDictionary {
	ret := &NSDictionary{}
	ret.ptr = unsafe.Pointer(C.NSString_inst_DictionaryWithValuesForKeys(o.Ptr(), keys.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSDictionary)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *NSDictionary) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *NSString) CapitalizedString() *NSString {
	ret := &NSString{}
	ret.ptr = unsafe.Pointer(C.NSString_inst_CapitalizedString(o.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSString)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *NSString) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *NSString) IntValue() Int {
	ret := (Int)(C.NSString_inst_IntValue(o.Ptr()))
	runtime.KeepAlive(o)
	return ret
}

func (o *NSString) GetCStringMaxLength(buffer *Char, maxBufferCount NSUInteger, encoding NSStringEncoding) bool {
	ret := (bool)(C.NSString_inst_GetCStringMaxLength(o.Ptr(), unsafe.Pointer(buffer), (C.NSUInteger)(maxBufferCount), (C.NSStringEncoding)(encoding)))
	runtime.KeepAlive(o)
	return ret
}

func (o *NSString) GetCStringMaxLengthEncoding(buffer *Char, maxBufferCount NSUInteger, encoding NSStringEncoding) bool {
	ret := (bool)(C.NSString_inst_GetCStringMaxLengthEncoding(o.Ptr(), unsafe.Pointer(buffer), (C.NSUInteger)(maxBufferCount), (C.NSStringEncoding)(encoding)))
	runtime.KeepAlive(o)
	return ret
}

func (o *NSString) MaximumLengthOfBytesUsingEncoding(enc NSStringEncoding) NSUInteger {
	ret := (NSUInteger)(C.NSString_inst_MaximumLengthOfBytesUsingEncoding(o.Ptr(), (C.NSStringEncoding)(enc)))
	runtime.KeepAlive(o)
	return ret
}

func (o *NSString) HasPrefix(str *NSString) bool {
	ret := (bool)(C.NSString_inst_HasPrefix(o.Ptr(), str.Ptr()))
	runtime.KeepAlive(o)
	return ret
}

func (o *NSString) IsCaseInsensitiveLike(object *NSString) bool {
	ret := (bool)(C.NSString_inst_IsCaseInsensitiveLike(o.Ptr(), object.Ptr()))
	runtime.KeepAlive(o)
	return ret
}

func (o *NSString) ScriptingBeginsWith(object NSObject) bool {
	ret := (bool)(C.NSString_inst_ScriptingBeginsWith(o.Ptr(), object.Ptr()))
	runtime.KeepAlive(o)
	return ret
}

func (o *NSString) PropertyList() *Id {
	ret := &Id{}
	ret.ptr = unsafe.Pointer(C.NSString_inst_PropertyList(o.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *Id) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *NSString) Compare(string *NSString) NSComparisonResult {
	ret := (NSComparisonResult)(C.NSString_inst_Compare(o.Ptr(), string.Ptr()))
	runtime.KeepAlive(o)
	return ret
}

func (o *NSString) CompareOptions(string *NSString, mask NSStringCompareOptions) NSComparisonResult {
	ret := (NSComparisonResult)(C.NSString_inst_CompareOptions(o.Ptr(), string.Ptr(), (C.NSStringCompareOptions)(mask)))
	runtime.KeepAlive(o)
	return ret
}

func (o *NSString) CompareOptionsRange(string *NSString, mask NSStringCompareOptions, rangeOfReceiverToCompare NSRange) NSComparisonResult {
	ret := (NSComparisonResult)(C.NSString_inst_CompareOptionsRange(o.Ptr(), string.Ptr(), (C.NSStringCompareOptions)(mask), (C.NSRange)(rangeOfReceiverToCompare)))
	runtime.KeepAlive(o)
	return ret
}

func (o *NSString) CompareOptionsRangeLocale(string *NSString, mask NSStringCompareOptions, rangeOfReceiverToCompare NSRange, locale NSObject) NSComparisonResult {
	ret := (NSComparisonResult)(C.NSString_inst_CompareOptionsRangeLocale(o.Ptr(), string.Ptr(), (C.NSStringCompareOptions)(mask), (C.NSRange)(rangeOfReceiverToCompare), locale.Ptr()))
	runtime.KeepAlive(o)
	return ret
}

func (o *NSString) IsGreaterThanOrEqualTo(object NSObject) bool {
	ret := (bool)(C.NSString_inst_IsGreaterThanOrEqualTo(o.Ptr(), object.Ptr()))
	runtime.KeepAlive(o)
	return ret
}

func (o *NSString) NewScriptingObjectOfClassForValueForKey(objectClass Class, key *NSString, contentsValue NSObject, properties *NSDictionary) *Id {
	ret := &Id{}
	ret.ptr = unsafe.Pointer(C.NSString_inst_NewScriptingObjectOfClassForValueForKey(o.Ptr(), unsafe.Pointer(objectClass), key.Ptr(), contentsValue.Ptr(), properties.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *Id) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *NSString) NewScriptingObjectOfClassForValueForKeyWithContentsValue(objectClass Class, key *NSString, contentsValue NSObject, properties *NSDictionary) *Id {
	ret := &Id{}
	ret.ptr = unsafe.Pointer(C.NSString_inst_NewScriptingObjectOfClassForValueForKeyWithContentsValue(o.Ptr(), unsafe.Pointer(objectClass), key.Ptr(), contentsValue.Ptr(), properties.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *Id) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *NSString) ScriptingIsLessThanOrEqualTo(object NSObject) bool {
	ret := (bool)(C.NSString_inst_ScriptingIsLessThanOrEqualTo(o.Ptr(), object.Ptr()))
	runtime.KeepAlive(o)
	return ret
}

func (o *NSString) ScriptingIsGreaterThan(object NSObject) bool {
	ret := (bool)(C.NSString_inst_ScriptingIsGreaterThan(o.Ptr(), object.Ptr()))
	runtime.KeepAlive(o)
	return ret
}

func (o *NSString) GetLineStartEnd(startPtr *NSUInteger, lineEndPtr *NSUInteger, contentsEndPtr *NSUInteger, range_ NSRange)  {
	C.NSString_inst_GetLineStartEnd(o.Ptr(), unsafe.Pointer(startPtr), unsafe.Pointer(lineEndPtr), unsafe.Pointer(contentsEndPtr), (C.NSRange)(range_))
	runtime.KeepAlive(o)
}

func (o *NSString) GetLineStartEndContentsEnd(startPtr *NSUInteger, lineEndPtr *NSUInteger, contentsEndPtr *NSUInteger, range_ NSRange)  {
	C.NSString_inst_GetLineStartEndContentsEnd(o.Ptr(), unsafe.Pointer(startPtr), unsafe.Pointer(lineEndPtr), unsafe.Pointer(contentsEndPtr), (C.NSRange)(range_))
	runtime.KeepAlive(o)
}

func (o *NSString) MutableArrayValueForKey(key *NSString) *NSMutableArray {
	ret := &NSMutableArray{}
	ret.ptr = unsafe.Pointer(C.NSString_inst_MutableArrayValueForKey(o.Ptr(), key.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSMutableArray)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *NSMutableArray) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *NSString) MutableSetValueForKeyPath(keyPath *NSString) *NSMutableSet {
	ret := &NSMutableSet{}
	ret.ptr = unsafe.Pointer(C.NSString_inst_MutableSetValueForKeyPath(o.Ptr(), keyPath.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSMutableSet)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *NSMutableSet) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *NSString) AddObserverForKeyPath(observer NSObject, keyPath *NSString, options NSKeyValueObservingOptions, context unsafe.Pointer)  {
	C.NSString_inst_AddObserverForKeyPath(o.Ptr(), observer.Ptr(), keyPath.Ptr(), (C.NSKeyValueObservingOptions)(options), unsafe.Pointer(context))
	runtime.KeepAlive(o)
}

func (o *NSString) AddObserverForKeyPathOptions(observer NSObject, keyPath *NSString, options NSKeyValueObservingOptions, context unsafe.Pointer)  {
	C.NSString_inst_AddObserverForKeyPathOptions(o.Ptr(), observer.Ptr(), keyPath.Ptr(), (C.NSKeyValueObservingOptions)(options), unsafe.Pointer(context))
	runtime.KeepAlive(o)
}

func (o *NSString) Init() *NSString {
	ret := &NSString{}
	ret.ptr = unsafe.Pointer(C.NSString_inst_Init(o.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSString)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *NSString) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *NSString) DecomposedStringWithCompatibilityMapping() *NSString {
	ret := &NSString{}
	ret.ptr = unsafe.Pointer(C.NSString_inst_DecomposedStringWithCompatibilityMapping(o.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSString)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *NSString) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *NSString) StringByApplyingTransformReverse(transform NSStringTransform, reverse BOOL) *NSString {
	ret := &NSString{}
	ret.ptr = unsafe.Pointer(C.NSString_inst_StringByApplyingTransformReverse(o.Ptr(), transform.Ptr(), (C.BOOL)(reverse)))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSString)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *NSString) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *NSString) StringByReplacingCharactersInRangeWithString(range_ NSRange, replacement *NSString) *NSString {
	ret := &NSString{}
	ret.ptr = unsafe.Pointer(C.NSString_inst_StringByReplacingCharactersInRangeWithString(o.Ptr(), (C.NSRange)(range_), replacement.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSString)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *NSString) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *NSString) StringByRemovingPercentEncoding() *NSString {
	ret := &NSString{}
	ret.ptr = unsafe.Pointer(C.NSString_inst_StringByRemovingPercentEncoding(o.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSString)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *NSString) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *NSString) Copy() *Id {
	ret := &Id{}
	ret.ptr = unsafe.Pointer(C.NSString_inst_Copy(o.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	runtime.SetFinalizer(ret, func(o *Id) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *NSString) MutableOrderedSetValueForKeyPath(keyPath *NSString) *NSMutableOrderedSet {
	ret := &NSMutableOrderedSet{}
	ret.ptr = unsafe.Pointer(C.NSString_inst_MutableOrderedSetValueForKeyPath(o.Ptr(), keyPath.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSMutableOrderedSet)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *NSMutableOrderedSet) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *NSString) ClassName() *NSString {
	ret := &NSString{}
	ret.ptr = unsafe.Pointer(C.NSString_inst_ClassName(o.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSString)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *NSString) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *NSString) PerformSelectorOnMainThreadWithObject(aSelector SEL, arg NSObject, wait BOOL)  {
	C.NSString_inst_PerformSelectorOnMainThreadWithObject(o.Ptr(), unsafe.Pointer(aSelector), arg.Ptr(), (C.BOOL)(wait))
	runtime.KeepAlive(o)
}

func (o *NSString) PerformSelectorOnMainThreadWithObjectWaitUntilDone(aSelector SEL, arg NSObject, wait BOOL)  {
	C.NSString_inst_PerformSelectorOnMainThreadWithObjectWaitUntilDone(o.Ptr(), unsafe.Pointer(aSelector), arg.Ptr(), (C.BOOL)(wait))
	runtime.KeepAlive(o)
}

func (o *NSString) PerformSelectorOnMainThreadWithObjectWaitUntilDoneModes(aSelector SEL, arg NSObject, wait BOOL, array *NSArray)  {
	C.NSString_inst_PerformSelectorOnMainThreadWithObjectWaitUntilDoneModes(o.Ptr(), unsafe.Pointer(aSelector), arg.Ptr(), (C.BOOL)(wait), array.Ptr())
	runtime.KeepAlive(o)
}

func (o *NSString) WritableTypeIdentifiersForItemProvider() *NSArray {
	ret := &NSArray{}
	ret.ptr = unsafe.Pointer(C.NSString_inst_WritableTypeIdentifiersForItemProvider(o.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSArray)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *NSArray) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *NSString) InitWithFormat(format *NSString) *NSString {
	ret := &NSString{}
	ret.ptr = unsafe.Pointer(C.NSString_inst_InitWithFormat(o.Ptr(), format.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSString)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *NSString) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *NSString) InitWithFormatArguments(format *NSString, argList Va_list) *NSString {
	ret := &NSString{}
	ret.ptr = unsafe.Pointer(C.NSString_inst_InitWithFormatArguments(o.Ptr(), format.Ptr(), (C.va_list)(argList)))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSString)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *NSString) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *NSString) InitWithFormatLocale(format *NSString, locale NSObject) *NSString {
	ret := &NSString{}
	ret.ptr = unsafe.Pointer(C.NSString_inst_InitWithFormatLocale(o.Ptr(), format.Ptr(), locale.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSString)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *NSString) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *NSString) InitWithFormatLocaleArguments(format *NSString, locale NSObject, argList Va_list) *NSString {
	ret := &NSString{}
	ret.ptr = unsafe.Pointer(C.NSString_inst_InitWithFormatLocaleArguments(o.Ptr(), format.Ptr(), locale.Ptr(), (C.va_list)(argList)))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSString)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *NSString) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *NSString) StringByAppendingFormat(format *NSString) *NSString {
	ret := &NSString{}
	ret.ptr = unsafe.Pointer(C.NSString_inst_StringByAppendingFormat(o.Ptr(), format.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSString)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *NSString) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *NSString) StringByResolvingSymlinksInPath() *NSString {
	ret := &NSString{}
	ret.ptr = unsafe.Pointer(C.NSString_inst_StringByResolvingSymlinksInPath(o.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSString)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *NSString) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *NSString) ScriptingIsGreaterThanOrEqualTo(object NSObject) bool {
	ret := (bool)(C.NSString_inst_ScriptingIsGreaterThanOrEqualTo(o.Ptr(), object.Ptr()))
	runtime.KeepAlive(o)
	return ret
}

func (o *NSString) SetValueForKey(value NSObject, key *NSString)  {
	C.NSString_inst_SetValueForKey(o.Ptr(), value.Ptr(), key.Ptr())
	runtime.KeepAlive(o)
}

func (o *NSString) SetValueForKeyPath(value NSObject, keyPath *NSString)  {
	C.NSString_inst_SetValueForKeyPath(o.Ptr(), value.Ptr(), keyPath.Ptr())
	runtime.KeepAlive(o)
}

func (o *NSString) SetValueForUndefinedKey(value NSObject, key *NSString)  {
	C.NSString_inst_SetValueForUndefinedKey(o.Ptr(), value.Ptr(), key.Ptr())
	runtime.KeepAlive(o)
}

func (o *NSString) ValueWithNameInPropertyWithKey(name *NSString, key *NSString) *Id {
	ret := &Id{}
	ret.ptr = unsafe.Pointer(C.NSString_inst_ValueWithNameInPropertyWithKey(o.Ptr(), name.Ptr(), key.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *Id) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *NSString) ToOneRelationshipKeys() *NSArray {
	ret := &NSArray{}
	ret.ptr = unsafe.Pointer(C.NSString_inst_ToOneRelationshipKeys(o.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSArray)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *NSArray) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *NSString) ValueForUndefinedKey(key *NSString) *Id {
	ret := &Id{}
	ret.ptr = unsafe.Pointer(C.NSString_inst_ValueForUndefinedKey(o.Ptr(), key.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *Id) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *NSString) ReplacementObjectForCoder(coder *NSCoder) *Id {
	ret := &Id{}
	ret.ptr = unsafe.Pointer(C.NSString_inst_ReplacementObjectForCoder(o.Ptr(), coder.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *Id) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *NSString) SetNilValueForKey(key *NSString)  {
	C.NSString_inst_SetNilValueForKey(o.Ptr(), key.Ptr())
	runtime.KeepAlive(o)
}

func (o *NSString) ItemProviderVisibilityForRepresentationWithTypeIdentifier(typeIdentifier *NSString) NSItemProviderRepresentationVisibility {
	ret := (NSItemProviderRepresentationVisibility)(C.NSString_inst_ItemProviderVisibilityForRepresentationWithTypeIdentifier(o.Ptr(), typeIdentifier.Ptr()))
	runtime.KeepAlive(o)
	return ret
}

func (o *NSString) PropertyListFromStringsFileFormat() *NSDictionary {
	ret := &NSDictionary{}
	ret.ptr = unsafe.Pointer(C.NSString_inst_PropertyListFromStringsFileFormat(o.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSDictionary)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *NSDictionary) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *NSString) PrecomposedStringWithCompatibilityMapping() *NSString {
	ret := &NSString{}
	ret.ptr = unsafe.Pointer(C.NSString_inst_PrecomposedStringWithCompatibilityMapping(o.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSString)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *NSString) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *NSString) SubstringWithRange(range_ NSRange) *NSString {
	ret := &NSString{}
	ret.ptr = unsafe.Pointer(C.NSString_inst_SubstringWithRange(o.Ptr(), (C.NSRange)(range_)))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSString)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *NSString) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *NSString) InitWithUTF8String(nullTerminatedCString *Char) *NSString {
	ret := &NSString{}
	ret.ptr = unsafe.Pointer(C.NSString_inst_InitWithUTF8String(o.Ptr(), unsafe.Pointer(nullTerminatedCString)))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSString)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *NSString) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *NSString) WriteToURLAtomically(url *NSURL, useAuxiliaryFile BOOL, enc NSStringEncoding, error *[]*NSError) bool {

	goSlice4 := make([]unsafe.Pointer,cap(*error))
	for i := 0; i < len(*error); i++ {
		goSlice4[i] = (*error)[i].Ptr()
	}
	ret := (bool)(C.NSString_inst_WriteToURLAtomically(o.Ptr(), url.Ptr(), (C.BOOL)(useAuxiliaryFile), (C.NSStringEncoding)(enc), (*unsafe.Pointer)(unsafe.Pointer(&goSlice4[0]))))
	(*error) = (*error)[:cap(*error)]
	for i := 0; i < len(*error); i++ {
		if goSlice4[i] == nil {
			(*error) = (*error)[:i]
			break
		}
		if (*error)[i] == nil {
			(*error)[i] = &NSError{}
			runtime.SetFinalizer((*error)[i], func(o *NSError) {
				o.Release()
			})
		}
		(*error)[i].ptr = goSlice4[i]
	}
	runtime.KeepAlive(o)
	return ret
}

func (o *NSString) WriteToURLAtomicallyEncoding(url *NSURL, useAuxiliaryFile BOOL, enc NSStringEncoding, error *[]*NSError) bool {

	goSlice4 := make([]unsafe.Pointer,cap(*error))
	for i := 0; i < len(*error); i++ {
		goSlice4[i] = (*error)[i].Ptr()
	}
	ret := (bool)(C.NSString_inst_WriteToURLAtomicallyEncoding(o.Ptr(), url.Ptr(), (C.BOOL)(useAuxiliaryFile), (C.NSStringEncoding)(enc), (*unsafe.Pointer)(unsafe.Pointer(&goSlice4[0]))))
	(*error) = (*error)[:cap(*error)]
	for i := 0; i < len(*error); i++ {
		if goSlice4[i] == nil {
			(*error) = (*error)[:i]
			break
		}
		if (*error)[i] == nil {
			(*error)[i] = &NSError{}
			runtime.SetFinalizer((*error)[i], func(o *NSError) {
				o.Release()
			})
		}
		(*error)[i].ptr = goSlice4[i]
	}
	runtime.KeepAlive(o)
	return ret
}

func (o *NSString) ClassForCoder() Class {
	ret := (Class)(unsafe.Pointer(C.NSString_inst_ClassForCoder(o.Ptr())))
	runtime.KeepAlive(o)
	return ret
}

func (o *NSString) InitWithBytesNoCopyLength(bytes unsafe.Pointer, len_ NSUInteger, encoding NSStringEncoding, freeBuffer BOOL) *NSString {
	ret := &NSString{}
	ret.ptr = unsafe.Pointer(C.NSString_inst_InitWithBytesNoCopyLength(o.Ptr(), unsafe.Pointer(bytes), (C.NSUInteger)(len_), (C.NSStringEncoding)(encoding), (C.BOOL)(freeBuffer)))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSString)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *NSString) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *NSString) InitWithBytesNoCopyLengthEncodingFreeWhenDone(bytes unsafe.Pointer, len_ NSUInteger, encoding NSStringEncoding, freeBuffer BOOL) *NSString {
	ret := &NSString{}
	ret.ptr = unsafe.Pointer(C.NSString_inst_InitWithBytesNoCopyLengthEncodingFreeWhenDone(o.Ptr(), unsafe.Pointer(bytes), (C.NSUInteger)(len_), (C.NSStringEncoding)(encoding), (C.BOOL)(freeBuffer)))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSString)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *NSString) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *NSString) SubstringFromIndex(from NSUInteger) *NSString {
	ret := &NSString{}
	ret.ptr = unsafe.Pointer(C.NSString_inst_SubstringFromIndex(o.Ptr(), (C.NSUInteger)(from)))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSString)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *NSString) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *NSString) ContainsString(str *NSString) bool {
	ret := (bool)(C.NSString_inst_ContainsString(o.Ptr(), str.Ptr()))
	runtime.KeepAlive(o)
	return ret
}

func (o *NSString) ClassCode() FourCharCode {
	ret := (FourCharCode)(C.NSString_inst_ClassCode(o.Ptr()))
	runtime.KeepAlive(o)
	return ret
}

func (o *NSString) WillChangeValuesAtIndexes(changeKind NSKeyValueChange, indexes *NSIndexSet, key *NSString)  {
	C.NSString_inst_WillChangeValuesAtIndexes(o.Ptr(), (C.NSKeyValueChange)(changeKind), indexes.Ptr(), key.Ptr())
	runtime.KeepAlive(o)
}

func (o *NSString) WillChangeValuesAtIndexesForKey(changeKind NSKeyValueChange, indexes *NSIndexSet, key *NSString)  {
	C.NSString_inst_WillChangeValuesAtIndexesForKey(o.Ptr(), (C.NSKeyValueChange)(changeKind), indexes.Ptr(), key.Ptr())
	runtime.KeepAlive(o)
}

func (o *NSString) RangeOfComposedCharacterSequencesForRange(range_ NSRange) NSRange {
	ret := (NSRange)(C.NSString_inst_RangeOfComposedCharacterSequencesForRange(o.Ptr(), (C.NSRange)(range_)))
	runtime.KeepAlive(o)
	return ret
}

func (o *NSString) ComponentsSeparatedByString(separator *NSString) *NSArray {
	ret := &NSArray{}
	ret.ptr = unsafe.Pointer(C.NSString_inst_ComponentsSeparatedByString(o.Ptr(), separator.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSArray)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *NSArray) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *NSString) DataUsingEncoding(encoding NSStringEncoding) *NSData {
	ret := &NSData{}
	ret.ptr = unsafe.Pointer(C.NSString_inst_DataUsingEncoding(o.Ptr(), (C.NSStringEncoding)(encoding)))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSData)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *NSData) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *NSString) DataUsingEncodingAllowLossyConversion(encoding NSStringEncoding, lossy BOOL) *NSData {
	ret := &NSData{}
	ret.ptr = unsafe.Pointer(C.NSString_inst_DataUsingEncodingAllowLossyConversion(o.Ptr(), (C.NSStringEncoding)(encoding), (C.BOOL)(lossy)))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSData)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *NSData) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *NSString) CommonPrefixWithStringOptions(str *NSString, mask NSStringCompareOptions) *NSString {
	ret := &NSString{}
	ret.ptr = unsafe.Pointer(C.NSString_inst_CommonPrefixWithStringOptions(o.Ptr(), str.Ptr(), (C.NSStringCompareOptions)(mask)))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSString)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *NSString) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *NSString) CommonPrefixWithStringOGoString(str string, mask NSStringCompareOptions) *NSString {
	str_chr := CharWithGoString(str)
	defer str_chr.Free()
	ret := o.CommonPrefixWithStringOptions(NSStringWithUTF8String(str_chr), mask)
	return ret
}

func (o *NSString) FastestEncoding() NSStringEncoding {
	ret := (NSStringEncoding)(C.NSString_inst_FastestEncoding(o.Ptr()))
	runtime.KeepAlive(o)
	return ret
}

func (o *NSString) LineRangeForRange(range_ NSRange) NSRange {
	ret := (NSRange)(C.NSString_inst_LineRangeForRange(o.Ptr(), (C.NSRange)(range_)))
	runtime.KeepAlive(o)
	return ret
}

func (o *NSString) CaseInsensitiveCompare(string *NSString) NSComparisonResult {
	ret := (NSComparisonResult)(C.NSString_inst_CaseInsensitiveCompare(o.Ptr(), string.Ptr()))
	runtime.KeepAlive(o)
	return ret
}

func (o *NSString) ScriptingEndsWith(object NSObject) bool {
	ret := (bool)(C.NSString_inst_ScriptingEndsWith(o.Ptr(), object.Ptr()))
	runtime.KeepAlive(o)
	return ret
}

func (o *NSString) MutableArrayValueForKeyPath(keyPath *NSString) *NSMutableArray {
	ret := &NSMutableArray{}
	ret.ptr = unsafe.Pointer(C.NSString_inst_MutableArrayValueForKeyPath(o.Ptr(), keyPath.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSMutableArray)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *NSMutableArray) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *NSString) DoesNotRecognizeSelector(aSelector SEL)  {
	C.NSString_inst_DoesNotRecognizeSelector(o.Ptr(), unsafe.Pointer(aSelector))
	runtime.KeepAlive(o)
}

func (o *NSString) SubstringToIndex(to NSUInteger) *NSString {
	ret := &NSString{}
	ret.ptr = unsafe.Pointer(C.NSString_inst_SubstringToIndex(o.Ptr(), (C.NSUInteger)(to)))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSString)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *NSString) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *NSString) InitWithDataEncoding(data *NSData, encoding NSStringEncoding) *NSString {
	ret := &NSString{}
	ret.ptr = unsafe.Pointer(C.NSString_inst_InitWithDataEncoding(o.Ptr(), data.Ptr(), (C.NSStringEncoding)(encoding)))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSString)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *NSString) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *NSString) Dealloc()  {
	C.NSString_inst_Dealloc(o.Ptr())
	runtime.KeepAlive(o)
}

func (o *NSString) ScriptingIsLessThan(object NSObject) bool {
	ret := (bool)(C.NSString_inst_ScriptingIsLessThan(o.Ptr(), object.Ptr()))
	runtime.KeepAlive(o)
	return ret
}

func (o *NSString) ValueAtIndexInPropertyWithKey(index NSUInteger, key *NSString) *Id {
	ret := &Id{}
	ret.ptr = unsafe.Pointer(C.NSString_inst_ValueAtIndexInPropertyWithKey(o.Ptr(), (C.NSUInteger)(index), key.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *Id) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *NSString) ValueForKeyPath(keyPath *NSString) *Id {
	ret := &Id{}
	ret.ptr = unsafe.Pointer(C.NSString_inst_ValueForKeyPath(o.Ptr(), keyPath.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *Id) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *NSString) BoolValue() bool {
	ret := (bool)(C.NSString_inst_BoolValue(o.Ptr()))
	runtime.KeepAlive(o)
	return ret
}

func (o *NSString) FileSystemRepresentation() *Char {
	ret := (*Char)(unsafe.Pointer(C.NSString_inst_FileSystemRepresentation(o.Ptr())))
	runtime.KeepAlive(o)
	return ret
}

func (o *NSString) DecomposedStringWithCanonicalMapping() *NSString {
	ret := &NSString{}
	ret.ptr = unsafe.Pointer(C.NSString_inst_DecomposedStringWithCanonicalMapping(o.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSString)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *NSString) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *NSString) DoubleValue() Double {
	ret := (Double)(C.NSString_inst_DoubleValue(o.Ptr()))
	runtime.KeepAlive(o)
	return ret
}

func (o *NSString) IndicesOfObjectsByEvaluatingObjectSpecifier(specifier *NSScriptObjectSpecifier) *NSArray {
	ret := &NSArray{}
	ret.ptr = unsafe.Pointer(C.NSString_inst_IndicesOfObjectsByEvaluatingObjectSpecifier(o.Ptr(), specifier.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSArray)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *NSArray) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *NSString) MutableSetValueForKey(key *NSString) *NSMutableSet {
	ret := &NSMutableSet{}
	ret.ptr = unsafe.Pointer(C.NSString_inst_MutableSetValueForKey(o.Ptr(), key.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSMutableSet)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *NSMutableSet) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *NSString) RangeOfComposedCharacterSequenceAtIndex(index NSUInteger) NSRange {
	ret := (NSRange)(C.NSString_inst_RangeOfComposedCharacterSequenceAtIndex(o.Ptr(), (C.NSUInteger)(index)))
	runtime.KeepAlive(o)
	return ret
}

func (o *NSString) LocalizedLowercaseString() *NSString {
	ret := &NSString{}
	ret.ptr = unsafe.Pointer(C.NSString_inst_LocalizedLowercaseString(o.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSString)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *NSString) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *NSString) LocalizedCaseInsensitiveCompare(string *NSString) NSComparisonResult {
	ret := (NSComparisonResult)(C.NSString_inst_LocalizedCaseInsensitiveCompare(o.Ptr(), string.Ptr()))
	runtime.KeepAlive(o)
	return ret
}

func (o *NSString) UppercaseString() *NSString {
	ret := &NSString{}
	ret.ptr = unsafe.Pointer(C.NSString_inst_UppercaseString(o.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSString)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *NSString) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *NSString) IsAbsolutePath() bool {
	ret := (bool)(C.NSString_inst_IsAbsolutePath(o.Ptr()))
	runtime.KeepAlive(o)
	return ret
}

func (o *NSString) FloatValue() Float {
	ret := (Float)(C.NSString_inst_FloatValue(o.Ptr()))
	runtime.KeepAlive(o)
	return ret
}

func (o *NSString) StringByAppendingString(aString *NSString) *NSString {
	ret := &NSString{}
	ret.ptr = unsafe.Pointer(C.NSString_inst_StringByAppendingString(o.Ptr(), aString.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSString)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *NSString) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *NSString) StringByAppendingPathComponent(str *NSString) *NSString {
	ret := &NSString{}
	ret.ptr = unsafe.Pointer(C.NSString_inst_StringByAppendingPathComponent(o.Ptr(), str.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSString)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *NSString) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *NSString) LocalizedCompare(string *NSString) NSComparisonResult {
	ret := (NSComparisonResult)(C.NSString_inst_LocalizedCompare(o.Ptr(), string.Ptr()))
	runtime.KeepAlive(o)
	return ret
}

func (o *NSString) RemoveValueAtIndexFromPropertyWithKey(index NSUInteger, key *NSString)  {
	C.NSString_inst_RemoveValueAtIndexFromPropertyWithKey(o.Ptr(), (C.NSUInteger)(index), key.Ptr())
	runtime.KeepAlive(o)
}

func (o *NSString) PerformSelectorInBackgroundWithObject(aSelector SEL, arg NSObject)  {
	C.NSString_inst_PerformSelectorInBackgroundWithObject(o.Ptr(), unsafe.Pointer(aSelector), arg.Ptr())
	runtime.KeepAlive(o)
}

func (o *NSString) StringByReplacingOccurrencesOfStringWithString(target *NSString, replacement *NSString) *NSString {
	ret := &NSString{}
	ret.ptr = unsafe.Pointer(C.NSString_inst_StringByReplacingOccurrencesOfStringWithString(o.Ptr(), target.Ptr(), replacement.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSString)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *NSString) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *NSString) StringByReplacingOccurrencesOfStringWithStringOptions(target *NSString, replacement *NSString, options NSStringCompareOptions, searchRange NSRange) *NSString {
	ret := &NSString{}
	ret.ptr = unsafe.Pointer(C.NSString_inst_StringByReplacingOccurrencesOfStringWithStringOptions(o.Ptr(), target.Ptr(), replacement.Ptr(), (C.NSStringCompareOptions)(options), (C.NSRange)(searchRange)))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSString)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *NSString) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *NSString) StringByReplacingOccurrencesOfStringWithStringOptionsRange(target *NSString, replacement *NSString, options NSStringCompareOptions, searchRange NSRange) *NSString {
	ret := &NSString{}
	ret.ptr = unsafe.Pointer(C.NSString_inst_StringByReplacingOccurrencesOfStringWithStringOptionsRange(o.Ptr(), target.Ptr(), replacement.Ptr(), (C.NSStringCompareOptions)(options), (C.NSRange)(searchRange)))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSString)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *NSString) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *NSString) CompletePathIntoStringCaseSensitive(outputName *[]*NSString, flag BOOL, outputArray *[]*NSArray, filterTypes *NSArray) NSUInteger {

	goSlice1 := make([]unsafe.Pointer,cap(*outputName))
	for i := 0; i < len(*outputName); i++ {
		goSlice1[i] = (*outputName)[i].Ptr()
	}

	goSlice3 := make([]unsafe.Pointer,cap(*outputArray))
	for i := 0; i < len(*outputArray); i++ {
		goSlice3[i] = (*outputArray)[i].Ptr()
	}
	ret := (NSUInteger)(C.NSString_inst_CompletePathIntoStringCaseSensitive(o.Ptr(), (*unsafe.Pointer)(unsafe.Pointer(&goSlice1[0])), (C.BOOL)(flag), (*unsafe.Pointer)(unsafe.Pointer(&goSlice3[0])), filterTypes.Ptr()))
	(*outputName) = (*outputName)[:cap(*outputName)]
	for i := 0; i < len(*outputName); i++ {
		if goSlice1[i] == nil {
			(*outputName) = (*outputName)[:i]
			break
		}
		if (*outputName)[i] == nil {
			(*outputName)[i] = &NSString{}
			runtime.SetFinalizer((*outputName)[i], func(o *NSString) {
				o.Release()
			})
		}
		(*outputName)[i].ptr = goSlice1[i]
	}
	(*outputArray) = (*outputArray)[:cap(*outputArray)]
	for i := 0; i < len(*outputArray); i++ {
		if goSlice3[i] == nil {
			(*outputArray) = (*outputArray)[:i]
			break
		}
		if (*outputArray)[i] == nil {
			(*outputArray)[i] = &NSArray{}
			runtime.SetFinalizer((*outputArray)[i], func(o *NSArray) {
				o.Release()
			})
		}
		(*outputArray)[i].ptr = goSlice3[i]
	}
	runtime.KeepAlive(o)
	return ret
}

func (o *NSString) CompletePathIntoStringCaseSensitiveMatchesIntoArray(outputName *[]*NSString, flag BOOL, outputArray *[]*NSArray, filterTypes *NSArray) NSUInteger {

	goSlice1 := make([]unsafe.Pointer,cap(*outputName))
	for i := 0; i < len(*outputName); i++ {
		goSlice1[i] = (*outputName)[i].Ptr()
	}

	goSlice3 := make([]unsafe.Pointer,cap(*outputArray))
	for i := 0; i < len(*outputArray); i++ {
		goSlice3[i] = (*outputArray)[i].Ptr()
	}
	ret := (NSUInteger)(C.NSString_inst_CompletePathIntoStringCaseSensitiveMatchesIntoArray(o.Ptr(), (*unsafe.Pointer)(unsafe.Pointer(&goSlice1[0])), (C.BOOL)(flag), (*unsafe.Pointer)(unsafe.Pointer(&goSlice3[0])), filterTypes.Ptr()))
	(*outputName) = (*outputName)[:cap(*outputName)]
	for i := 0; i < len(*outputName); i++ {
		if goSlice1[i] == nil {
			(*outputName) = (*outputName)[:i]
			break
		}
		if (*outputName)[i] == nil {
			(*outputName)[i] = &NSString{}
			runtime.SetFinalizer((*outputName)[i], func(o *NSString) {
				o.Release()
			})
		}
		(*outputName)[i].ptr = goSlice1[i]
	}
	(*outputArray) = (*outputArray)[:cap(*outputArray)]
	for i := 0; i < len(*outputArray); i++ {
		if goSlice3[i] == nil {
			(*outputArray) = (*outputArray)[:i]
			break
		}
		if (*outputArray)[i] == nil {
			(*outputArray)[i] = &NSArray{}
			runtime.SetFinalizer((*outputArray)[i], func(o *NSArray) {
				o.Release()
			})
		}
		(*outputArray)[i].ptr = goSlice3[i]
	}
	runtime.KeepAlive(o)
	return ret
}

func (o *NSString) StringByFoldingWithOptionsLocale(options NSStringCompareOptions, locale *NSLocale) *NSString {
	ret := &NSString{}
	ret.ptr = unsafe.Pointer(C.NSString_inst_StringByFoldingWithOptionsLocale(o.Ptr(), (C.NSStringCompareOptions)(options), locale.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSString)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *NSString) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *NSString) InitWithCoder(coder *NSCoder) *NSString {
	ret := &NSString{}
	ret.ptr = unsafe.Pointer(C.NSString_inst_InitWithCoder(o.Ptr(), coder.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSString)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *NSString) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *NSString) RangeOfString(searchString *NSString) NSRange {
	ret := (NSRange)(C.NSString_inst_RangeOfString(o.Ptr(), searchString.Ptr()))
	runtime.KeepAlive(o)
	return ret
}

func (o *NSString) RangeOfStringOptions(searchString *NSString, mask NSStringCompareOptions) NSRange {
	ret := (NSRange)(C.NSString_inst_RangeOfStringOptions(o.Ptr(), searchString.Ptr(), (C.NSStringCompareOptions)(mask)))
	runtime.KeepAlive(o)
	return ret
}

func (o *NSString) RangeOfStringOptionsRange(searchString *NSString, mask NSStringCompareOptions, rangeOfReceiverToSearch NSRange) NSRange {
	ret := (NSRange)(C.NSString_inst_RangeOfStringOptionsRange(o.Ptr(), searchString.Ptr(), (C.NSStringCompareOptions)(mask), (C.NSRange)(rangeOfReceiverToSearch)))
	runtime.KeepAlive(o)
	return ret
}

func (o *NSString) RangeOfStringOptionsRangeLocale(searchString *NSString, mask NSStringCompareOptions, rangeOfReceiverToSearch NSRange, locale *NSLocale) NSRange {
	ret := (NSRange)(C.NSString_inst_RangeOfStringOptionsRangeLocale(o.Ptr(), searchString.Ptr(), (C.NSStringCompareOptions)(mask), (C.NSRange)(rangeOfReceiverToSearch), locale.Ptr()))
	runtime.KeepAlive(o)
	return ret
}

func (o *NSString) DoesContain(object NSObject) bool {
	ret := (bool)(C.NSString_inst_DoesContain(o.Ptr(), object.Ptr()))
	runtime.KeepAlive(o)
	return ret
}

func (o *NSString) SetValuesForKeysWithDictionary(keyedValues *NSDictionary)  {
	C.NSString_inst_SetValuesForKeysWithDictionary(o.Ptr(), keyedValues.Ptr())
	runtime.KeepAlive(o)
}

func (o *NSString) Length() NSUInteger {
	ret := (NSUInteger)(C.NSString_inst_Length(o.Ptr()))
	runtime.KeepAlive(o)
	return ret
}

func (o *NSString) GetParagraphStartEnd(startPtr *NSUInteger, parEndPtr *NSUInteger, contentsEndPtr *NSUInteger, range_ NSRange)  {
	C.NSString_inst_GetParagraphStartEnd(o.Ptr(), unsafe.Pointer(startPtr), unsafe.Pointer(parEndPtr), unsafe.Pointer(contentsEndPtr), (C.NSRange)(range_))
	runtime.KeepAlive(o)
}

func (o *NSString) GetParagraphStartEndContentsEnd(startPtr *NSUInteger, parEndPtr *NSUInteger, contentsEndPtr *NSUInteger, range_ NSRange)  {
	C.NSString_inst_GetParagraphStartEndContentsEnd(o.Ptr(), unsafe.Pointer(startPtr), unsafe.Pointer(parEndPtr), unsafe.Pointer(contentsEndPtr), (C.NSRange)(range_))
	runtime.KeepAlive(o)
}

func (o *NSString) PrecomposedStringWithCanonicalMapping() *NSString {
	ret := &NSString{}
	ret.ptr = unsafe.Pointer(C.NSString_inst_PrecomposedStringWithCanonicalMapping(o.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSString)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *NSString) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *NSString) InitWithContentsOfURLEncoding(url *NSURL, enc NSStringEncoding, error *[]*NSError) *NSString {

	goSlice3 := make([]unsafe.Pointer,cap(*error))
	for i := 0; i < len(*error); i++ {
		goSlice3[i] = (*error)[i].Ptr()
	}
	ret := &NSString{}
	ret.ptr = unsafe.Pointer(C.NSString_inst_InitWithContentsOfURLEncoding(o.Ptr(), url.Ptr(), (C.NSStringEncoding)(enc), (*unsafe.Pointer)(unsafe.Pointer(&goSlice3[0]))))
	(*error) = (*error)[:cap(*error)]
	for i := 0; i < len(*error); i++ {
		if goSlice3[i] == nil {
			(*error) = (*error)[:i]
			break
		}
		if (*error)[i] == nil {
			(*error)[i] = &NSError{}
			runtime.SetFinalizer((*error)[i], func(o *NSError) {
				o.Release()
			})
		}
		(*error)[i].ptr = goSlice3[i]
	}
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSString)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *NSString) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *NSString) InitWithContentsOfURLUsedEncoding(url *NSURL, enc *NSStringEncoding, error *[]*NSError) *NSString {

	goSlice3 := make([]unsafe.Pointer,cap(*error))
	for i := 0; i < len(*error); i++ {
		goSlice3[i] = (*error)[i].Ptr()
	}
	ret := &NSString{}
	ret.ptr = unsafe.Pointer(C.NSString_inst_InitWithContentsOfURLUsedEncoding(o.Ptr(), url.Ptr(), unsafe.Pointer(enc), (*unsafe.Pointer)(unsafe.Pointer(&goSlice3[0]))))
	(*error) = (*error)[:cap(*error)]
	for i := 0; i < len(*error); i++ {
		if goSlice3[i] == nil {
			(*error) = (*error)[:i]
			break
		}
		if (*error)[i] == nil {
			(*error)[i] = &NSError{}
			runtime.SetFinalizer((*error)[i], func(o *NSError) {
				o.Release()
			})
		}
		(*error)[i].ptr = goSlice3[i]
	}
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSString)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *NSString) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *NSString) InitWithContentsOfURLEncodingError(url *NSURL, enc NSStringEncoding, error *[]*NSError) *NSString {

	goSlice3 := make([]unsafe.Pointer,cap(*error))
	for i := 0; i < len(*error); i++ {
		goSlice3[i] = (*error)[i].Ptr()
	}
	ret := &NSString{}
	ret.ptr = unsafe.Pointer(C.NSString_inst_InitWithContentsOfURLEncodingError(o.Ptr(), url.Ptr(), (C.NSStringEncoding)(enc), (*unsafe.Pointer)(unsafe.Pointer(&goSlice3[0]))))
	(*error) = (*error)[:cap(*error)]
	for i := 0; i < len(*error); i++ {
		if goSlice3[i] == nil {
			(*error) = (*error)[:i]
			break
		}
		if (*error)[i] == nil {
			(*error)[i] = &NSError{}
			runtime.SetFinalizer((*error)[i], func(o *NSError) {
				o.Release()
			})
		}
		(*error)[i].ptr = goSlice3[i]
	}
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSString)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *NSString) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *NSString) InitWithContentsOfURLUsedEncodingError(url *NSURL, enc *NSStringEncoding, error *[]*NSError) *NSString {

	goSlice3 := make([]unsafe.Pointer,cap(*error))
	for i := 0; i < len(*error); i++ {
		goSlice3[i] = (*error)[i].Ptr()
	}
	ret := &NSString{}
	ret.ptr = unsafe.Pointer(C.NSString_inst_InitWithContentsOfURLUsedEncodingError(o.Ptr(), url.Ptr(), unsafe.Pointer(enc), (*unsafe.Pointer)(unsafe.Pointer(&goSlice3[0]))))
	(*error) = (*error)[:cap(*error)]
	for i := 0; i < len(*error); i++ {
		if goSlice3[i] == nil {
			(*error) = (*error)[:i]
			break
		}
		if (*error)[i] == nil {
			(*error)[i] = &NSError{}
			runtime.SetFinalizer((*error)[i], func(o *NSError) {
				o.Release()
			})
		}
		(*error)[i].ptr = goSlice3[i]
	}
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSString)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *NSString) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *NSString) ObserveValueForKeyPathOfObject(keyPath *NSString, object NSObject, change *NSDictionary, context unsafe.Pointer)  {
	C.NSString_inst_ObserveValueForKeyPathOfObject(o.Ptr(), keyPath.Ptr(), object.Ptr(), change.Ptr(), unsafe.Pointer(context))
	runtime.KeepAlive(o)
}

func (o *NSString) ObserveValueForKeyPathOfObjectChange(keyPath *NSString, object NSObject, change *NSDictionary, context unsafe.Pointer)  {
	C.NSString_inst_ObserveValueForKeyPathOfObjectChange(o.Ptr(), keyPath.Ptr(), object.Ptr(), change.Ptr(), unsafe.Pointer(context))
	runtime.KeepAlive(o)
}

func (o *NSString) ScriptingProperties() *NSDictionary {
	ret := &NSDictionary{}
	ret.ptr = unsafe.Pointer(C.NSString_inst_ScriptingProperties(o.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSDictionary)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *NSDictionary) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *NSString) DidChangeValueForKey(key *NSString)  {
	C.NSString_inst_DidChangeValueForKey(o.Ptr(), key.Ptr())
	runtime.KeepAlive(o)
}

func (o *NSString) DidChangeValueForKeyWithSetMutation(key *NSString, mutationKind NSKeyValueSetMutationKind, objects *NSSet)  {
	C.NSString_inst_DidChangeValueForKeyWithSetMutation(o.Ptr(), key.Ptr(), (C.NSKeyValueSetMutationKind)(mutationKind), objects.Ptr())
	runtime.KeepAlive(o)
}

func (o *NSString) DidChangeValueForKeyWithSetMutationUsingObjects(key *NSString, mutationKind NSKeyValueSetMutationKind, objects *NSSet)  {
	C.NSString_inst_DidChangeValueForKeyWithSetMutationUsingObjects(o.Ptr(), key.Ptr(), (C.NSKeyValueSetMutationKind)(mutationKind), objects.Ptr())
	runtime.KeepAlive(o)
}

func (o *NSString) ComponentsSeparatedByCharactersInSet(separator *NSCharacterSet) *NSArray {
	ret := &NSArray{}
	ret.ptr = unsafe.Pointer(C.NSString_inst_ComponentsSeparatedByCharactersInSet(o.Ptr(), separator.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSArray)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *NSArray) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *NSString) GetFileSystemRepresentationMaxLength(cname *Char, max NSUInteger) bool {
	ret := (bool)(C.NSString_inst_GetFileSystemRepresentationMaxLength(o.Ptr(), unsafe.Pointer(cname), (C.NSUInteger)(max)))
	runtime.KeepAlive(o)
	return ret
}

func (o *NSString) StringByDeletingLastPathComponent() *NSString {
	ret := &NSString{}
	ret.ptr = unsafe.Pointer(C.NSString_inst_StringByDeletingLastPathComponent(o.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSString)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *NSString) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *NSString) ToManyRelationshipKeys() *NSArray {
	ret := &NSArray{}
	ret.ptr = unsafe.Pointer(C.NSString_inst_ToManyRelationshipKeys(o.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSArray)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *NSArray) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *NSString) DidChangeValuesAtIndexes(changeKind NSKeyValueChange, indexes *NSIndexSet, key *NSString)  {
	C.NSString_inst_DidChangeValuesAtIndexes(o.Ptr(), (C.NSKeyValueChange)(changeKind), indexes.Ptr(), key.Ptr())
	runtime.KeepAlive(o)
}

func (o *NSString) DidChangeValuesAtIndexesForKey(changeKind NSKeyValueChange, indexes *NSIndexSet, key *NSString)  {
	C.NSString_inst_DidChangeValuesAtIndexesForKey(o.Ptr(), (C.NSKeyValueChange)(changeKind), indexes.Ptr(), key.Ptr())
	runtime.KeepAlive(o)
}

func (o *NSString) ForwardInvocation(anInvocation *NSInvocation)  {
	C.NSString_inst_ForwardInvocation(o.Ptr(), anInvocation.Ptr())
	runtime.KeepAlive(o)
}

func (o *NSString) AttributeKeys() *NSArray {
	ret := &NSArray{}
	ret.ptr = unsafe.Pointer(C.NSString_inst_AttributeKeys(o.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSArray)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *NSArray) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func NSObjectClass() Class {
	ret := (Class)(unsafe.Pointer(C.NSObject_Class()))
	return ret
}

func NSObjectAutomaticallyNotifiesObserversForKey(key *NSString) bool {
	ret := (bool)(C.NSObject_AutomaticallyNotifiesObserversForKey(key.Ptr()))
	return ret
}

func NSObjectLoad()  {
	C.NSObject_Load()
}

func NSObjectResolveInstanceMethod(sel SEL) bool {
	ret := (bool)(C.NSObject_ResolveInstanceMethod(unsafe.Pointer(sel)))
	return ret
}

func NSObjectResolveClassMethod(sel SEL) bool {
	ret := (bool)(C.NSObject_ResolveClassMethod(unsafe.Pointer(sel)))
	return ret
}

func NSObjectDescription() *NSString {
	ret := &NSString{}
	ret.ptr = unsafe.Pointer(C.NSObject_Description())
	if ret.ptr == nil { return ret }
	return ret
}

func NSObjectClassFallbacksForKeyedArchiver() *NSArray {
	ret := &NSArray{}
	ret.ptr = unsafe.Pointer(C.NSObject_ClassFallbacksForKeyedArchiver())
	if ret.ptr == nil { return ret }
	return ret
}

func NSObjectIsSubclassOfClass(aClass Class) bool {
	ret := (bool)(C.NSObject_IsSubclassOfClass(unsafe.Pointer(aClass)))
	return ret
}

func NSObjectCopyWithZone(zone *_NSZone) *Id {
	ret := &Id{}
	ret.ptr = unsafe.Pointer(C.NSObject_CopyWithZone(unsafe.Pointer(zone)))
	if ret.ptr == nil { return ret }
	runtime.SetFinalizer(ret, func(o *Id) {
		o.Release()
	})
	return ret
}

func NSObjectHash() NSUInteger {
	ret := (NSUInteger)(C.NSObject_Hash())
	return ret
}

func NSObjectCancelPreviousPerformRequestsWithTarget(aTarget NSObject)  {
	C.NSObject_CancelPreviousPerformRequestsWithTarget(aTarget.Ptr())
}

func NSObjectCancelPreviousPerformRequestsWithTargetSelector(aTarget NSObject, aSelector SEL, anArgument NSObject)  {
	C.NSObject_CancelPreviousPerformRequestsWithTargetSelector(aTarget.Ptr(), unsafe.Pointer(aSelector), anArgument.Ptr())
}

func NSObjectCancelPreviousPerformRequestsWithTargetSelectorObject(aTarget NSObject, aSelector SEL, anArgument NSObject)  {
	C.NSObject_CancelPreviousPerformRequestsWithTargetSelectorObject(aTarget.Ptr(), unsafe.Pointer(aSelector), anArgument.Ptr())
}

func NSObjectAllocWithZone(zone *_NSZone) *Id {
	ret := &Id{}
	ret.ptr = unsafe.Pointer(C.NSObject_AllocWithZone(unsafe.Pointer(zone)))
	if ret.ptr == nil { return ret }
	runtime.SetFinalizer(ret, func(o *Id) {
		o.Release()
	})
	return ret
}

func NSObjectNew() *Id {
	ret := &Id{}
	ret.ptr = unsafe.Pointer(C.NSObject_New())
	if ret.ptr == nil { return ret }
	runtime.SetFinalizer(ret, func(o *Id) {
		o.Release()
	})
	return ret
}

func NSObjectKeyPathsForValuesAffectingValueForKey(key *NSString) *NSSet {
	ret := &NSSet{}
	ret.ptr = unsafe.Pointer(C.NSObject_KeyPathsForValuesAffectingValueForKey(key.Ptr()))
	if ret.ptr == nil { return ret }
	return ret
}

func NSObjectAccessInstanceVariablesDirectly() bool {
	ret := (bool)(C.NSObject_AccessInstanceVariablesDirectly())
	return ret
}

func NSObjectSetVersion(aVersion NSInteger)  {
	C.NSObject_SetVersion((C.NSInteger)(aVersion))
}

func NSObjectInstanceMethodSignatureForSelector(aSelector SEL) *NSMethodSignature {
	ret := &NSMethodSignature{}
	ret.ptr = unsafe.Pointer(C.NSObject_InstanceMethodSignatureForSelector(unsafe.Pointer(aSelector)))
	if ret.ptr == nil { return ret }
	return ret
}

func NSObjectSuperclass() Class {
	ret := (Class)(unsafe.Pointer(C.NSObject_Superclass()))
	return ret
}

func NSObjectAlloc() *Id {
	ret := &Id{}
	ret.ptr = unsafe.Pointer(C.NSObject_Alloc())
	if ret.ptr == nil { return ret }
	runtime.SetFinalizer(ret, func(o *Id) {
		o.Release()
	})
	return ret
}

func (o *Id) GC() {
	if o.ptr == nil { return }
	runtime.SetFinalizer(o, func(o *Id) {
		o.Release()
	})
	runtime.KeepAlive(o)
}

func NSObjectDebugDescription() *NSString {
	ret := &NSString{}
	ret.ptr = unsafe.Pointer(C.NSObject_DebugDescription())
	if ret.ptr == nil { return ret }
	return ret
}

func NSObjectVersion() NSInteger {
	ret := (NSInteger)(C.NSObject_Version())
	return ret
}

func NSObjectMutableCopyWithZone(zone *_NSZone) *Id {
	ret := &Id{}
	ret.ptr = unsafe.Pointer(C.NSObject_MutableCopyWithZone(unsafe.Pointer(zone)))
	if ret.ptr == nil { return ret }
	runtime.SetFinalizer(ret, func(o *Id) {
		o.Release()
	})
	return ret
}

func NSObjectInstancesRespondToSelector(aSelector SEL) bool {
	ret := (bool)(C.NSObject_InstancesRespondToSelector(unsafe.Pointer(aSelector)))
	return ret
}

func NSObjectConformsToProtocol(protocol Protocol) bool {
	ret := (bool)(C.NSObject_ConformsToProtocol(protocol.Ptr()))
	return ret
}

func NSObjectClassForKeyedUnarchiver() Class {
	ret := (Class)(unsafe.Pointer(C.NSObject_ClassForKeyedUnarchiver()))
	return ret
}

func (o *Id) ScriptingIsLessThanOrEqualTo(object NSObject) bool {
	ret := (bool)(C.NSObject_inst_ScriptingIsLessThanOrEqualTo(o.Ptr(), object.Ptr()))
	runtime.KeepAlive(o)
	return ret
}

func (o *Id) IsProxy() bool {
	ret := (bool)(C.NSObject_inst_IsProxy(o.Ptr()))
	runtime.KeepAlive(o)
	return ret
}

func (o *Id) IsMemberOfClass(aClass Class) bool {
	ret := (bool)(C.NSObject_inst_IsMemberOfClass(o.Ptr(), unsafe.Pointer(aClass)))
	runtime.KeepAlive(o)
	return ret
}

func (o *Id) RemoveValueAtIndexFromPropertyWithKey(index NSUInteger, key *NSString)  {
	C.NSObject_inst_RemoveValueAtIndexFromPropertyWithKey(o.Ptr(), (C.NSUInteger)(index), key.Ptr())
	runtime.KeepAlive(o)
}

func (o *Id) AttemptRecoveryFromErrorOptionIndex(error *NSError, recoveryOptionIndex NSUInteger) bool {
	ret := (bool)(C.NSObject_inst_AttemptRecoveryFromErrorOptionIndex(o.Ptr(), error.Ptr(), (C.NSUInteger)(recoveryOptionIndex)))
	runtime.KeepAlive(o)
	return ret
}

func (o *Id) AttemptRecoveryFromErrorOptionIndexDelegate(error *NSError, recoveryOptionIndex NSUInteger, delegate NSObject, didRecoverSelector SEL, contextInfo unsafe.Pointer)  {
	C.NSObject_inst_AttemptRecoveryFromErrorOptionIndexDelegate(o.Ptr(), error.Ptr(), (C.NSUInteger)(recoveryOptionIndex), delegate.Ptr(), unsafe.Pointer(didRecoverSelector), unsafe.Pointer(contextInfo))
	runtime.KeepAlive(o)
}

func (o *Id) AttemptRecoveryFromErrorOptionIndexDelegateDidRecoverSelector(error *NSError, recoveryOptionIndex NSUInteger, delegate NSObject, didRecoverSelector SEL, contextInfo unsafe.Pointer)  {
	C.NSObject_inst_AttemptRecoveryFromErrorOptionIndexDelegateDidRecoverSelector(o.Ptr(), error.Ptr(), (C.NSUInteger)(recoveryOptionIndex), delegate.Ptr(), unsafe.Pointer(didRecoverSelector), unsafe.Pointer(contextInfo))
	runtime.KeepAlive(o)
}

func (o *Id) MutableArrayValueForKeyPath(keyPath *NSString) *NSMutableArray {
	ret := &NSMutableArray{}
	ret.ptr = unsafe.Pointer(C.NSObject_inst_MutableArrayValueForKeyPath(o.Ptr(), keyPath.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSMutableArray)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *NSMutableArray) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *Id) ScriptingIsLessThan(object NSObject) bool {
	ret := (bool)(C.NSObject_inst_ScriptingIsLessThan(o.Ptr(), object.Ptr()))
	runtime.KeepAlive(o)
	return ret
}

func (o *Id) ReplacementObjectForCoder(coder *NSCoder) *Id {
	ret := &Id{}
	ret.ptr = unsafe.Pointer(C.NSObject_inst_ReplacementObjectForCoder(o.Ptr(), coder.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *Id) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *Id) IsGreaterThan(object NSObject) bool {
	ret := (bool)(C.NSObject_inst_IsGreaterThan(o.Ptr(), object.Ptr()))
	runtime.KeepAlive(o)
	return ret
}

func (o *Id) IsEqual(object NSObject) bool {
	ret := (bool)(C.NSObject_inst_IsEqual(o.Ptr(), object.Ptr()))
	runtime.KeepAlive(o)
	return ret
}

func (o *Id) GetClass() Class {
	ret := (Class)(unsafe.Pointer(C.NSObject_inst_Class(o.Ptr())))
	runtime.KeepAlive(o)
	return ret
}

func (o *Id) SetValueForKey(value NSObject, key *NSString)  {
	C.NSObject_inst_SetValueForKey(o.Ptr(), value.Ptr(), key.Ptr())
	runtime.KeepAlive(o)
}

func (o *Id) SetValueForKeyPath(value NSObject, keyPath *NSString)  {
	C.NSObject_inst_SetValueForKeyPath(o.Ptr(), value.Ptr(), keyPath.Ptr())
	runtime.KeepAlive(o)
}

func (o *Id) SetValueForUndefinedKey(value NSObject, key *NSString)  {
	C.NSObject_inst_SetValueForUndefinedKey(o.Ptr(), value.Ptr(), key.Ptr())
	runtime.KeepAlive(o)
}

func (o *Id) MutableSetValueForKeyPath(keyPath *NSString) *NSMutableSet {
	ret := &NSMutableSet{}
	ret.ptr = unsafe.Pointer(C.NSObject_inst_MutableSetValueForKeyPath(o.Ptr(), keyPath.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSMutableSet)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *NSMutableSet) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *Id) AddObserverForKeyPath(observer NSObject, keyPath *NSString, options NSKeyValueObservingOptions, context unsafe.Pointer)  {
	C.NSObject_inst_AddObserverForKeyPath(o.Ptr(), observer.Ptr(), keyPath.Ptr(), (C.NSKeyValueObservingOptions)(options), unsafe.Pointer(context))
	runtime.KeepAlive(o)
}

func (o *Id) AddObserverForKeyPathOptions(observer NSObject, keyPath *NSString, options NSKeyValueObservingOptions, context unsafe.Pointer)  {
	C.NSObject_inst_AddObserverForKeyPathOptions(o.Ptr(), observer.Ptr(), keyPath.Ptr(), (C.NSKeyValueObservingOptions)(options), unsafe.Pointer(context))
	runtime.KeepAlive(o)
}

func (o *Id) Retain() *Id {
	ret := &Id{}
	ret.ptr = unsafe.Pointer(C.NSObject_inst_Retain(o.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *Id) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *Id) ValueForKey(key *NSString) *Id {
	ret := &Id{}
	ret.ptr = unsafe.Pointer(C.NSObject_inst_ValueForKey(o.Ptr(), key.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *Id) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *Id) NewScriptingObjectOfClassForValueForKey(objectClass Class, key *NSString, contentsValue NSObject, properties *NSDictionary) *Id {
	ret := &Id{}
	ret.ptr = unsafe.Pointer(C.NSObject_inst_NewScriptingObjectOfClassForValueForKey(o.Ptr(), unsafe.Pointer(objectClass), key.Ptr(), contentsValue.Ptr(), properties.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *Id) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *Id) NewScriptingObjectOfClassForValueForKeyWithContentsValue(objectClass Class, key *NSString, contentsValue NSObject, properties *NSDictionary) *Id {
	ret := &Id{}
	ret.ptr = unsafe.Pointer(C.NSObject_inst_NewScriptingObjectOfClassForValueForKeyWithContentsValue(o.Ptr(), unsafe.Pointer(objectClass), key.Ptr(), contentsValue.Ptr(), properties.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *Id) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *Id) IsCaseInsensitiveLike(object *NSString) bool {
	ret := (bool)(C.NSObject_inst_IsCaseInsensitiveLike(o.Ptr(), object.Ptr()))
	runtime.KeepAlive(o)
	return ret
}

func (o *Id) ClassForArchiver() Class {
	ret := (Class)(unsafe.Pointer(C.NSObject_inst_ClassForArchiver(o.Ptr())))
	runtime.KeepAlive(o)
	return ret
}

func (o *Id) ClassCode() FourCharCode {
	ret := (FourCharCode)(C.NSObject_inst_ClassCode(o.Ptr()))
	runtime.KeepAlive(o)
	return ret
}

func (o *Id) SetScriptingProperties(scriptingProperties *NSDictionary)  {
	C.NSObject_inst_SetScriptingProperties(o.Ptr(), scriptingProperties.Ptr())
	runtime.KeepAlive(o)
}

func (o *Id) MutableOrderedSetValueForKeyPath(keyPath *NSString) *NSMutableOrderedSet {
	ret := &NSMutableOrderedSet{}
	ret.ptr = unsafe.Pointer(C.NSObject_inst_MutableOrderedSetValueForKeyPath(o.Ptr(), keyPath.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSMutableOrderedSet)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *NSMutableOrderedSet) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *Id) ReplaceValueAtIndexInPropertyWithKey(index NSUInteger, key *NSString, value NSObject)  {
	C.NSObject_inst_ReplaceValueAtIndexInPropertyWithKey(o.Ptr(), (C.NSUInteger)(index), key.Ptr(), value.Ptr())
	runtime.KeepAlive(o)
}

func (o *Id) ReplaceValueAtIndexInPropertyWithKeyWithValue(index NSUInteger, key *NSString, value NSObject)  {
	C.NSObject_inst_ReplaceValueAtIndexInPropertyWithKeyWithValue(o.Ptr(), (C.NSUInteger)(index), key.Ptr(), value.Ptr())
	runtime.KeepAlive(o)
}

func (o *Id) ScriptingIsGreaterThanOrEqualTo(object NSObject) bool {
	ret := (bool)(C.NSObject_inst_ScriptingIsGreaterThanOrEqualTo(o.Ptr(), object.Ptr()))
	runtime.KeepAlive(o)
	return ret
}

func (o *Id) AwakeAfterUsingCoder(coder *NSCoder) *Id {
	ret := &Id{}
	ret.ptr = unsafe.Pointer(C.NSObject_inst_AwakeAfterUsingCoder(o.Ptr(), coder.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *Id) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *Id) ToOneRelationshipKeys() *NSArray {
	ret := &NSArray{}
	ret.ptr = unsafe.Pointer(C.NSObject_inst_ToOneRelationshipKeys(o.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSArray)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *NSArray) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *Id) ValueWithNameInPropertyWithKey(name *NSString, key *NSString) *Id {
	ret := &Id{}
	ret.ptr = unsafe.Pointer(C.NSObject_inst_ValueWithNameInPropertyWithKey(o.Ptr(), name.Ptr(), key.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *Id) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *Id) WillChangeValueForKey(key *NSString)  {
	C.NSObject_inst_WillChangeValueForKey(o.Ptr(), key.Ptr())
	runtime.KeepAlive(o)
}

func (o *Id) WillChangeValueForKeyWithSetMutation(key *NSString, mutationKind NSKeyValueSetMutationKind, objects *NSSet)  {
	C.NSObject_inst_WillChangeValueForKeyWithSetMutation(o.Ptr(), key.Ptr(), (C.NSKeyValueSetMutationKind)(mutationKind), objects.Ptr())
	runtime.KeepAlive(o)
}

func (o *Id) WillChangeValueForKeyWithSetMutationUsingObjects(key *NSString, mutationKind NSKeyValueSetMutationKind, objects *NSSet)  {
	C.NSObject_inst_WillChangeValueForKeyWithSetMutationUsingObjects(o.Ptr(), key.Ptr(), (C.NSKeyValueSetMutationKind)(mutationKind), objects.Ptr())
	runtime.KeepAlive(o)
}

func (o *Id) ConformsToProtocol(aProtocol Protocol) bool {
	ret := (bool)(C.NSObject_inst_ConformsToProtocol(o.Ptr(), aProtocol.Ptr()))
	runtime.KeepAlive(o)
	return ret
}

func (o *Id) Copy() *Id {
	ret := &Id{}
	ret.ptr = unsafe.Pointer(C.NSObject_inst_Copy(o.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	runtime.SetFinalizer(ret, func(o *Id) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *Id) MutableOrderedSetValueForKey(key *NSString) *NSMutableOrderedSet {
	ret := &NSMutableOrderedSet{}
	ret.ptr = unsafe.Pointer(C.NSObject_inst_MutableOrderedSetValueForKey(o.Ptr(), key.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSMutableOrderedSet)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *NSMutableOrderedSet) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *Id) Dealloc()  {
	C.NSObject_inst_Dealloc(o.Ptr())
	runtime.KeepAlive(o)
}

func (o *Id) SetNilValueForKey(key *NSString)  {
	C.NSObject_inst_SetNilValueForKey(o.Ptr(), key.Ptr())
	runtime.KeepAlive(o)
}

func (o *Id) AttributeKeys() *NSArray {
	ret := &NSArray{}
	ret.ptr = unsafe.Pointer(C.NSObject_inst_AttributeKeys(o.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSArray)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *NSArray) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *Id) RespondsToSelector(aSelector SEL) bool {
	ret := (bool)(C.NSObject_inst_RespondsToSelector(o.Ptr(), unsafe.Pointer(aSelector)))
	runtime.KeepAlive(o)
	return ret
}

func (o *Id) RetainCount() NSUInteger {
	ret := (NSUInteger)(C.NSObject_inst_RetainCount(o.Ptr()))
	runtime.KeepAlive(o)
	return ret
}

func (o *Id) ObjectSpecifier() *NSScriptObjectSpecifier {
	ret := &NSScriptObjectSpecifier{}
	ret.ptr = unsafe.Pointer(C.NSObject_inst_ObjectSpecifier(o.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSScriptObjectSpecifier)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *NSScriptObjectSpecifier) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *Id) ValueAtIndexInPropertyWithKey(index NSUInteger, key *NSString) *Id {
	ret := &Id{}
	ret.ptr = unsafe.Pointer(C.NSObject_inst_ValueAtIndexInPropertyWithKey(o.Ptr(), (C.NSUInteger)(index), key.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *Id) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *Id) ForwardInvocation(anInvocation *NSInvocation)  {
	C.NSObject_inst_ForwardInvocation(o.Ptr(), anInvocation.Ptr())
	runtime.KeepAlive(o)
}

func (o *Id) ScriptingProperties() *NSDictionary {
	ret := &NSDictionary{}
	ret.ptr = unsafe.Pointer(C.NSObject_inst_ScriptingProperties(o.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSDictionary)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *NSDictionary) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *Id) SetObservationInfo(observationInfo unsafe.Pointer)  {
	C.NSObject_inst_SetObservationInfo(o.Ptr(), unsafe.Pointer(observationInfo))
	runtime.KeepAlive(o)
}

func (o *Id) DoesNotRecognizeSelector(aSelector SEL)  {
	C.NSObject_inst_DoesNotRecognizeSelector(o.Ptr(), unsafe.Pointer(aSelector))
	runtime.KeepAlive(o)
}

func (o *Id) WillChangeValuesAtIndexes(changeKind NSKeyValueChange, indexes *NSIndexSet, key *NSString)  {
	C.NSObject_inst_WillChangeValuesAtIndexes(o.Ptr(), (C.NSKeyValueChange)(changeKind), indexes.Ptr(), key.Ptr())
	runtime.KeepAlive(o)
}

func (o *Id) WillChangeValuesAtIndexesForKey(changeKind NSKeyValueChange, indexes *NSIndexSet, key *NSString)  {
	C.NSObject_inst_WillChangeValuesAtIndexesForKey(o.Ptr(), (C.NSKeyValueChange)(changeKind), indexes.Ptr(), key.Ptr())
	runtime.KeepAlive(o)
}

func (o *Id) MutableArrayValueForKey(key *NSString) *NSMutableArray {
	ret := &NSMutableArray{}
	ret.ptr = unsafe.Pointer(C.NSObject_inst_MutableArrayValueForKey(o.Ptr(), key.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSMutableArray)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *NSMutableArray) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *Id) InverseForRelationshipKey(relationshipKey *NSString) *NSString {
	ret := &NSString{}
	ret.ptr = unsafe.Pointer(C.NSObject_inst_InverseForRelationshipKey(o.Ptr(), relationshipKey.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSString)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *NSString) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *Id) ForwardingTargetForSelector(aSelector SEL) *Id {
	ret := &Id{}
	ret.ptr = unsafe.Pointer(C.NSObject_inst_ForwardingTargetForSelector(o.Ptr(), unsafe.Pointer(aSelector)))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *Id) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *Id) RemoveObserverForKeyPath(observer NSObject, keyPath *NSString)  {
	C.NSObject_inst_RemoveObserverForKeyPath(o.Ptr(), observer.Ptr(), keyPath.Ptr())
	runtime.KeepAlive(o)
}

func (o *Id) RemoveObserverForKeyPathContext(observer NSObject, keyPath *NSString, context unsafe.Pointer)  {
	C.NSObject_inst_RemoveObserverForKeyPathContext(o.Ptr(), observer.Ptr(), keyPath.Ptr(), unsafe.Pointer(context))
	runtime.KeepAlive(o)
}

func (o *Id) DidChangeValuesAtIndexes(changeKind NSKeyValueChange, indexes *NSIndexSet, key *NSString)  {
	C.NSObject_inst_DidChangeValuesAtIndexes(o.Ptr(), (C.NSKeyValueChange)(changeKind), indexes.Ptr(), key.Ptr())
	runtime.KeepAlive(o)
}

func (o *Id) DidChangeValuesAtIndexesForKey(changeKind NSKeyValueChange, indexes *NSIndexSet, key *NSString)  {
	C.NSObject_inst_DidChangeValuesAtIndexesForKey(o.Ptr(), (C.NSKeyValueChange)(changeKind), indexes.Ptr(), key.Ptr())
	runtime.KeepAlive(o)
}

func (o *Id) InsertValueInPropertyWithKey(value NSObject, key *NSString)  {
	C.NSObject_inst_InsertValueInPropertyWithKey(o.Ptr(), value.Ptr(), key.Ptr())
	runtime.KeepAlive(o)
}

func (o *Id) InsertValueAtIndex(value NSObject, index NSUInteger, key *NSString)  {
	C.NSObject_inst_InsertValueAtIndex(o.Ptr(), value.Ptr(), (C.NSUInteger)(index), key.Ptr())
	runtime.KeepAlive(o)
}

func (o *Id) InsertValueAtIndexInPropertyWithKey(value NSObject, index NSUInteger, key *NSString)  {
	C.NSObject_inst_InsertValueAtIndexInPropertyWithKey(o.Ptr(), value.Ptr(), (C.NSUInteger)(index), key.Ptr())
	runtime.KeepAlive(o)
}

func (o *Id) MutableCopy() *Id {
	ret := &Id{}
	ret.ptr = unsafe.Pointer(C.NSObject_inst_MutableCopy(o.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	runtime.SetFinalizer(ret, func(o *Id) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *Id) ScriptingValueForSpecifier(objectSpecifier *NSScriptObjectSpecifier) *Id {
	ret := &Id{}
	ret.ptr = unsafe.Pointer(C.NSObject_inst_ScriptingValueForSpecifier(o.Ptr(), objectSpecifier.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *Id) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *Id) ScriptingIsEqualTo(object NSObject) bool {
	ret := (bool)(C.NSObject_inst_ScriptingIsEqualTo(o.Ptr(), object.Ptr()))
	runtime.KeepAlive(o)
	return ret
}

func (o *Id) ClassName() *NSString {
	ret := &NSString{}
	ret.ptr = unsafe.Pointer(C.NSObject_inst_ClassName(o.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSString)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *NSString) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *Id) ValidateValueForKey(ioValue *[]*Id, inKey *NSString, outError *[]*NSError) bool {

	goSlice1 := make([]unsafe.Pointer,cap(*ioValue))
	for i := 0; i < len(*ioValue); i++ {
		goSlice1[i] = (*ioValue)[i].Ptr()
	}

	goSlice3 := make([]unsafe.Pointer,cap(*outError))
	for i := 0; i < len(*outError); i++ {
		goSlice3[i] = (*outError)[i].Ptr()
	}
	ret := (bool)(C.NSObject_inst_ValidateValueForKey(o.Ptr(), (*unsafe.Pointer)(unsafe.Pointer(&goSlice1[0])), inKey.Ptr(), (*unsafe.Pointer)(unsafe.Pointer(&goSlice3[0]))))
	(*ioValue) = (*ioValue)[:cap(*ioValue)]
	for i := 0; i < len(*ioValue); i++ {
		if goSlice1[i] == nil {
			(*ioValue) = (*ioValue)[:i]
			break
		}
		if (*ioValue)[i] == nil {
			(*ioValue)[i] = &Id{}
			runtime.SetFinalizer((*ioValue)[i], func(o *Id) {
				o.Release()
			})
		}
		(*ioValue)[i].ptr = goSlice1[i]
	}
	(*outError) = (*outError)[:cap(*outError)]
	for i := 0; i < len(*outError); i++ {
		if goSlice3[i] == nil {
			(*outError) = (*outError)[:i]
			break
		}
		if (*outError)[i] == nil {
			(*outError)[i] = &NSError{}
			runtime.SetFinalizer((*outError)[i], func(o *NSError) {
				o.Release()
			})
		}
		(*outError)[i].ptr = goSlice3[i]
	}
	runtime.KeepAlive(o)
	return ret
}

func (o *Id) ValidateValueForKeyPath(ioValue *[]*Id, inKeyPath *NSString, outError *[]*NSError) bool {

	goSlice1 := make([]unsafe.Pointer,cap(*ioValue))
	for i := 0; i < len(*ioValue); i++ {
		goSlice1[i] = (*ioValue)[i].Ptr()
	}

	goSlice3 := make([]unsafe.Pointer,cap(*outError))
	for i := 0; i < len(*outError); i++ {
		goSlice3[i] = (*outError)[i].Ptr()
	}
	ret := (bool)(C.NSObject_inst_ValidateValueForKeyPath(o.Ptr(), (*unsafe.Pointer)(unsafe.Pointer(&goSlice1[0])), inKeyPath.Ptr(), (*unsafe.Pointer)(unsafe.Pointer(&goSlice3[0]))))
	(*ioValue) = (*ioValue)[:cap(*ioValue)]
	for i := 0; i < len(*ioValue); i++ {
		if goSlice1[i] == nil {
			(*ioValue) = (*ioValue)[:i]
			break
		}
		if (*ioValue)[i] == nil {
			(*ioValue)[i] = &Id{}
			runtime.SetFinalizer((*ioValue)[i], func(o *Id) {
				o.Release()
			})
		}
		(*ioValue)[i].ptr = goSlice1[i]
	}
	(*outError) = (*outError)[:cap(*outError)]
	for i := 0; i < len(*outError); i++ {
		if goSlice3[i] == nil {
			(*outError) = (*outError)[:i]
			break
		}
		if (*outError)[i] == nil {
			(*outError)[i] = &NSError{}
			runtime.SetFinalizer((*outError)[i], func(o *NSError) {
				o.Release()
			})
		}
		(*outError)[i].ptr = goSlice3[i]
	}
	runtime.KeepAlive(o)
	return ret
}

func (o *Id) ValidateValueForKeyError(ioValue *[]*Id, inKey *NSString, outError *[]*NSError) bool {

	goSlice1 := make([]unsafe.Pointer,cap(*ioValue))
	for i := 0; i < len(*ioValue); i++ {
		goSlice1[i] = (*ioValue)[i].Ptr()
	}

	goSlice3 := make([]unsafe.Pointer,cap(*outError))
	for i := 0; i < len(*outError); i++ {
		goSlice3[i] = (*outError)[i].Ptr()
	}
	ret := (bool)(C.NSObject_inst_ValidateValueForKeyError(o.Ptr(), (*unsafe.Pointer)(unsafe.Pointer(&goSlice1[0])), inKey.Ptr(), (*unsafe.Pointer)(unsafe.Pointer(&goSlice3[0]))))
	(*ioValue) = (*ioValue)[:cap(*ioValue)]
	for i := 0; i < len(*ioValue); i++ {
		if goSlice1[i] == nil {
			(*ioValue) = (*ioValue)[:i]
			break
		}
		if (*ioValue)[i] == nil {
			(*ioValue)[i] = &Id{}
			runtime.SetFinalizer((*ioValue)[i], func(o *Id) {
				o.Release()
			})
		}
		(*ioValue)[i].ptr = goSlice1[i]
	}
	(*outError) = (*outError)[:cap(*outError)]
	for i := 0; i < len(*outError); i++ {
		if goSlice3[i] == nil {
			(*outError) = (*outError)[:i]
			break
		}
		if (*outError)[i] == nil {
			(*outError)[i] = &NSError{}
			runtime.SetFinalizer((*outError)[i], func(o *NSError) {
				o.Release()
			})
		}
		(*outError)[i].ptr = goSlice3[i]
	}
	runtime.KeepAlive(o)
	return ret
}

func (o *Id) ValidateValueForKeyPathError(ioValue *[]*Id, inKeyPath *NSString, outError *[]*NSError) bool {

	goSlice1 := make([]unsafe.Pointer,cap(*ioValue))
	for i := 0; i < len(*ioValue); i++ {
		goSlice1[i] = (*ioValue)[i].Ptr()
	}

	goSlice3 := make([]unsafe.Pointer,cap(*outError))
	for i := 0; i < len(*outError); i++ {
		goSlice3[i] = (*outError)[i].Ptr()
	}
	ret := (bool)(C.NSObject_inst_ValidateValueForKeyPathError(o.Ptr(), (*unsafe.Pointer)(unsafe.Pointer(&goSlice1[0])), inKeyPath.Ptr(), (*unsafe.Pointer)(unsafe.Pointer(&goSlice3[0]))))
	(*ioValue) = (*ioValue)[:cap(*ioValue)]
	for i := 0; i < len(*ioValue); i++ {
		if goSlice1[i] == nil {
			(*ioValue) = (*ioValue)[:i]
			break
		}
		if (*ioValue)[i] == nil {
			(*ioValue)[i] = &Id{}
			runtime.SetFinalizer((*ioValue)[i], func(o *Id) {
				o.Release()
			})
		}
		(*ioValue)[i].ptr = goSlice1[i]
	}
	(*outError) = (*outError)[:cap(*outError)]
	for i := 0; i < len(*outError); i++ {
		if goSlice3[i] == nil {
			(*outError) = (*outError)[:i]
			break
		}
		if (*outError)[i] == nil {
			(*outError)[i] = &NSError{}
			runtime.SetFinalizer((*outError)[i], func(o *NSError) {
				o.Release()
			})
		}
		(*outError)[i].ptr = goSlice3[i]
	}
	runtime.KeepAlive(o)
	return ret
}

func (o *Id) IsEqualTo(object NSObject) bool {
	ret := (bool)(C.NSObject_inst_IsEqualTo(o.Ptr(), object.Ptr()))
	runtime.KeepAlive(o)
	return ret
}

func (o *Id) DidChangeValueForKey(key *NSString)  {
	C.NSObject_inst_DidChangeValueForKey(o.Ptr(), key.Ptr())
	runtime.KeepAlive(o)
}

func (o *Id) DidChangeValueForKeyWithSetMutation(key *NSString, mutationKind NSKeyValueSetMutationKind, objects *NSSet)  {
	C.NSObject_inst_DidChangeValueForKeyWithSetMutation(o.Ptr(), key.Ptr(), (C.NSKeyValueSetMutationKind)(mutationKind), objects.Ptr())
	runtime.KeepAlive(o)
}

func (o *Id) DidChangeValueForKeyWithSetMutationUsingObjects(key *NSString, mutationKind NSKeyValueSetMutationKind, objects *NSSet)  {
	C.NSObject_inst_DidChangeValueForKeyWithSetMutationUsingObjects(o.Ptr(), key.Ptr(), (C.NSKeyValueSetMutationKind)(mutationKind), objects.Ptr())
	runtime.KeepAlive(o)
}

func (o *Id) ClassDescription() *NSClassDescription {
	ret := &NSClassDescription{}
	ret.ptr = unsafe.Pointer(C.NSObject_inst_ClassDescription(o.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSClassDescription)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *NSClassDescription) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *Id) ValueForUndefinedKey(key *NSString) *Id {
	ret := &Id{}
	ret.ptr = unsafe.Pointer(C.NSObject_inst_ValueForUndefinedKey(o.Ptr(), key.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *Id) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *Id) ToManyRelationshipKeys() *NSArray {
	ret := &NSArray{}
	ret.ptr = unsafe.Pointer(C.NSObject_inst_ToManyRelationshipKeys(o.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSArray)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *NSArray) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *Id) IndicesOfObjectsByEvaluatingObjectSpecifier(specifier *NSScriptObjectSpecifier) *NSArray {
	ret := &NSArray{}
	ret.ptr = unsafe.Pointer(C.NSObject_inst_IndicesOfObjectsByEvaluatingObjectSpecifier(o.Ptr(), specifier.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSArray)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *NSArray) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *Id) IsGreaterThanOrEqualTo(object NSObject) bool {
	ret := (bool)(C.NSObject_inst_IsGreaterThanOrEqualTo(o.Ptr(), object.Ptr()))
	runtime.KeepAlive(o)
	return ret
}

func (o *Id) DoesContain(object NSObject) bool {
	ret := (bool)(C.NSObject_inst_DoesContain(o.Ptr(), object.Ptr()))
	runtime.KeepAlive(o)
	return ret
}

func (o *Id) Autorelease() *Id {
	ret := &Id{}
	ret.ptr = unsafe.Pointer(C.NSObject_inst_Autorelease(o.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *Id) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *Id) DictionaryWithValuesForKeys(keys *NSArray) *NSDictionary {
	ret := &NSDictionary{}
	ret.ptr = unsafe.Pointer(C.NSObject_inst_DictionaryWithValuesForKeys(o.Ptr(), keys.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSDictionary)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *NSDictionary) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *Id) IsNotEqualTo(object NSObject) bool {
	ret := (bool)(C.NSObject_inst_IsNotEqualTo(o.Ptr(), object.Ptr()))
	runtime.KeepAlive(o)
	return ret
}

func (o *Id) ObserveValueForKeyPathOfObject(keyPath *NSString, object NSObject, change *NSDictionary, context unsafe.Pointer)  {
	C.NSObject_inst_ObserveValueForKeyPathOfObject(o.Ptr(), keyPath.Ptr(), object.Ptr(), change.Ptr(), unsafe.Pointer(context))
	runtime.KeepAlive(o)
}

func (o *Id) ObserveValueForKeyPathOfObjectChange(keyPath *NSString, object NSObject, change *NSDictionary, context unsafe.Pointer)  {
	C.NSObject_inst_ObserveValueForKeyPathOfObjectChange(o.Ptr(), keyPath.Ptr(), object.Ptr(), change.Ptr(), unsafe.Pointer(context))
	runtime.KeepAlive(o)
}

func (o *Id) Superclass() Class {
	ret := (Class)(unsafe.Pointer(C.NSObject_inst_Superclass(o.Ptr())))
	runtime.KeepAlive(o)
	return ret
}

func (o *Id) ScriptingIsGreaterThan(object NSObject) bool {
	ret := (bool)(C.NSObject_inst_ScriptingIsGreaterThan(o.Ptr(), object.Ptr()))
	runtime.KeepAlive(o)
	return ret
}

func (o *Id) IsLike(object *NSString) bool {
	ret := (bool)(C.NSObject_inst_IsLike(o.Ptr(), object.Ptr()))
	runtime.KeepAlive(o)
	return ret
}

func (o *Id) IsKindOfClass(aClass Class) bool {
	ret := (bool)(C.NSObject_inst_IsKindOfClass(o.Ptr(), unsafe.Pointer(aClass)))
	runtime.KeepAlive(o)
	return ret
}

func (o *Id) Init() *Id {
	ret := &Id{}
	ret.ptr = unsafe.Pointer(C.NSObject_inst_Init(o.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *Id) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *Id) SetValuesForKeysWithDictionary(keyedValues *NSDictionary)  {
	C.NSObject_inst_SetValuesForKeysWithDictionary(o.Ptr(), keyedValues.Ptr())
	runtime.KeepAlive(o)
}

func (o *Id) ClassForKeyedArchiver() Class {
	ret := (Class)(unsafe.Pointer(C.NSObject_inst_ClassForKeyedArchiver(o.Ptr())))
	runtime.KeepAlive(o)
	return ret
}

func (o *Id) ScriptingContains(object NSObject) bool {
	ret := (bool)(C.NSObject_inst_ScriptingContains(o.Ptr(), object.Ptr()))
	runtime.KeepAlive(o)
	return ret
}

func (o *Id) MutableSetValueForKey(key *NSString) *NSMutableSet {
	ret := &NSMutableSet{}
	ret.ptr = unsafe.Pointer(C.NSObject_inst_MutableSetValueForKey(o.Ptr(), key.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSMutableSet)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *NSMutableSet) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *Id) ReplacementObjectForKeyedArchiver(archiver *NSKeyedArchiver) *Id {
	ret := &Id{}
	ret.ptr = unsafe.Pointer(C.NSObject_inst_ReplacementObjectForKeyedArchiver(o.Ptr(), archiver.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *Id) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *Id) ScriptingEndsWith(object NSObject) bool {
	ret := (bool)(C.NSObject_inst_ScriptingEndsWith(o.Ptr(), object.Ptr()))
	runtime.KeepAlive(o)
	return ret
}

func (o *Id) ObservationInfo() unsafe.Pointer {
	ret := (unsafe.Pointer)(unsafe.Pointer(C.NSObject_inst_ObservationInfo(o.Ptr())))
	runtime.KeepAlive(o)
	return ret
}

func (o *Id) PerformSelector(aSelector SEL) *Id {
	ret := &Id{}
	ret.ptr = unsafe.Pointer(C.NSObject_inst_PerformSelector(o.Ptr(), unsafe.Pointer(aSelector)))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *Id) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *Id) PerformSelectorWithObject(aSelector SEL, object NSObject) *Id {
	ret := &Id{}
	ret.ptr = unsafe.Pointer(C.NSObject_inst_PerformSelectorWithObject(o.Ptr(), unsafe.Pointer(aSelector), object.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *Id) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *Id) PerformSelectorWithObjectAfterDelay(aSelector SEL, anArgument NSObject, delay NSTimeInterval)  {
	C.NSObject_inst_PerformSelectorWithObjectAfterDelay(o.Ptr(), unsafe.Pointer(aSelector), anArgument.Ptr(), (C.NSTimeInterval)(delay))
	runtime.KeepAlive(o)
}

func (o *Id) PerformSelectorWithObjectWithObject(aSelector SEL, object1 NSObject, object2 NSObject) *Id {
	ret := &Id{}
	ret.ptr = unsafe.Pointer(C.NSObject_inst_PerformSelectorWithObjectWithObject(o.Ptr(), unsafe.Pointer(aSelector), object1.Ptr(), object2.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *Id) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *Id) PerformSelectorOnThread(aSelector SEL, thr *NSThread, arg NSObject, wait BOOL)  {
	C.NSObject_inst_PerformSelectorOnThread(o.Ptr(), unsafe.Pointer(aSelector), thr.Ptr(), arg.Ptr(), (C.BOOL)(wait))
	runtime.KeepAlive(o)
}

func (o *Id) PerformSelectorWithObjectAfterDelayInModes(aSelector SEL, anArgument NSObject, delay NSTimeInterval, modes *NSArray)  {
	C.NSObject_inst_PerformSelectorWithObjectAfterDelayInModes(o.Ptr(), unsafe.Pointer(aSelector), anArgument.Ptr(), (C.NSTimeInterval)(delay), modes.Ptr())
	runtime.KeepAlive(o)
}

func (o *Id) PerformSelectorOnThreadWithObject(aSelector SEL, thr *NSThread, arg NSObject, wait BOOL)  {
	C.NSObject_inst_PerformSelectorOnThreadWithObject(o.Ptr(), unsafe.Pointer(aSelector), thr.Ptr(), arg.Ptr(), (C.BOOL)(wait))
	runtime.KeepAlive(o)
}

func (o *Id) PerformSelectorOnThreadWithObjectWaitUntilDone(aSelector SEL, thr *NSThread, arg NSObject, wait BOOL, array *NSArray)  {
	C.NSObject_inst_PerformSelectorOnThreadWithObjectWaitUntilDone(o.Ptr(), unsafe.Pointer(aSelector), thr.Ptr(), arg.Ptr(), (C.BOOL)(wait), array.Ptr())
	runtime.KeepAlive(o)
}

func (o *Id) PerformSelectorOnThreadWithObjectWaitUntilDoneModes(aSelector SEL, thr *NSThread, arg NSObject, wait BOOL, array *NSArray)  {
	C.NSObject_inst_PerformSelectorOnThreadWithObjectWaitUntilDoneModes(o.Ptr(), unsafe.Pointer(aSelector), thr.Ptr(), arg.Ptr(), (C.BOOL)(wait), array.Ptr())
	runtime.KeepAlive(o)
}

func (o *Id) CopyScriptingValueForKey(value NSObject, key *NSString, properties *NSDictionary) *Id {
	ret := &Id{}
	ret.ptr = unsafe.Pointer(C.NSObject_inst_CopyScriptingValueForKey(o.Ptr(), value.Ptr(), key.Ptr(), properties.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *Id) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *Id) CopyScriptingValueForKeyWithProperties(value NSObject, key *NSString, properties *NSDictionary) *Id {
	ret := &Id{}
	ret.ptr = unsafe.Pointer(C.NSObject_inst_CopyScriptingValueForKeyWithProperties(o.Ptr(), value.Ptr(), key.Ptr(), properties.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *Id) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *Id) ValueWithUniqueIDInPropertyWithKey(uniqueID NSObject, key *NSString) *Id {
	ret := &Id{}
	ret.ptr = unsafe.Pointer(C.NSObject_inst_ValueWithUniqueIDInPropertyWithKey(o.Ptr(), uniqueID.Ptr(), key.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *Id) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *Id) IsLessThanOrEqualTo(object NSObject) bool {
	ret := (bool)(C.NSObject_inst_IsLessThanOrEqualTo(o.Ptr(), object.Ptr()))
	runtime.KeepAlive(o)
	return ret
}

func (o *Id) AutoContentAccessingProxy() *Id {
	ret := &Id{}
	ret.ptr = unsafe.Pointer(C.NSObject_inst_AutoContentAccessingProxy(o.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *Id) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *Id) Zone() *_NSZone {
	ret := (*_NSZone)(unsafe.Pointer(C.NSObject_inst_Zone(o.Ptr())))
	runtime.KeepAlive(o)
	return ret
}

func (o *Id) DebugDescription() *NSString {
	ret := &NSString{}
	ret.ptr = unsafe.Pointer(C.NSObject_inst_DebugDescription(o.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSString)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *NSString) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *Id) Release()  {
	C.NSObject_inst_Release(o.Ptr())
	runtime.KeepAlive(o)
}

func (o *Id) IsLessThan(object NSObject) bool {
	ret := (bool)(C.NSObject_inst_IsLessThan(o.Ptr(), object.Ptr()))
	runtime.KeepAlive(o)
	return ret
}

func (o *Id) ValueForKeyPath(keyPath *NSString) *Id {
	ret := &Id{}
	ret.ptr = unsafe.Pointer(C.NSObject_inst_ValueForKeyPath(o.Ptr(), keyPath.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *Id) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *Id) ScriptingBeginsWith(object NSObject) bool {
	ret := (bool)(C.NSObject_inst_ScriptingBeginsWith(o.Ptr(), object.Ptr()))
	runtime.KeepAlive(o)
	return ret
}

func (o *Id) Self() *Id {
	ret := &Id{}
	ret.ptr = unsafe.Pointer(C.NSObject_inst_Self(o.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *Id) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *Id) CoerceValueForKey(value NSObject, key *NSString) *Id {
	ret := &Id{}
	ret.ptr = unsafe.Pointer(C.NSObject_inst_CoerceValueForKey(o.Ptr(), value.Ptr(), key.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *Id) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *Id) PerformSelectorInBackgroundWithObject(aSelector SEL, arg NSObject)  {
	C.NSObject_inst_PerformSelectorInBackgroundWithObject(o.Ptr(), unsafe.Pointer(aSelector), arg.Ptr())
	runtime.KeepAlive(o)
}

func (o *Id) Hash() NSUInteger {
	ret := (NSUInteger)(C.NSObject_inst_Hash(o.Ptr()))
	runtime.KeepAlive(o)
	return ret
}

func (o *Id) Description() *NSString {
	ret := &NSString{}
	ret.ptr = unsafe.Pointer(C.NSObject_inst_Description(o.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSString)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *NSString) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *Id) MethodSignatureForSelector(aSelector SEL) *NSMethodSignature {
	ret := &NSMethodSignature{}
	ret.ptr = unsafe.Pointer(C.NSObject_inst_MethodSignatureForSelector(o.Ptr(), unsafe.Pointer(aSelector)))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSMethodSignature)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *NSMethodSignature) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *Id) ClassForCoder() Class {
	ret := (Class)(unsafe.Pointer(C.NSObject_inst_ClassForCoder(o.Ptr())))
	runtime.KeepAlive(o)
	return ret
}

func (o *Id) PerformSelectorOnMainThreadWithObject(aSelector SEL, arg NSObject, wait BOOL)  {
	C.NSObject_inst_PerformSelectorOnMainThreadWithObject(o.Ptr(), unsafe.Pointer(aSelector), arg.Ptr(), (C.BOOL)(wait))
	runtime.KeepAlive(o)
}

func (o *Id) PerformSelectorOnMainThreadWithObjectWaitUntilDone(aSelector SEL, arg NSObject, wait BOOL)  {
	C.NSObject_inst_PerformSelectorOnMainThreadWithObjectWaitUntilDone(o.Ptr(), unsafe.Pointer(aSelector), arg.Ptr(), (C.BOOL)(wait))
	runtime.KeepAlive(o)
}

func (o *Id) PerformSelectorOnMainThreadWithObjectWaitUntilDoneModes(aSelector SEL, arg NSObject, wait BOOL, array *NSArray)  {
	C.NSObject_inst_PerformSelectorOnMainThreadWithObjectWaitUntilDoneModes(o.Ptr(), unsafe.Pointer(aSelector), arg.Ptr(), (C.BOOL)(wait), array.Ptr())
	runtime.KeepAlive(o)
}

func NSDataAutomaticallyNotifiesObserversForKey(key *NSString) bool {
	ret := (bool)(C.NSData_AutomaticallyNotifiesObserversForKey(key.Ptr()))
	return ret
}

func NSDataDescription() *NSString {
	ret := &NSString{}
	ret.ptr = unsafe.Pointer(C.NSData_Description())
	if ret.ptr == nil { return ret }
	return ret
}

func NSDataIsSubclassOfClass(aClass Class) bool {
	ret := (bool)(C.NSData_IsSubclassOfClass(unsafe.Pointer(aClass)))
	return ret
}

func NSDataCopyWithZone(zone *_NSZone) *Id {
	ret := &Id{}
	ret.ptr = unsafe.Pointer(C.NSData_CopyWithZone(unsafe.Pointer(zone)))
	if ret.ptr == nil { return ret }
	runtime.SetFinalizer(ret, func(o *Id) {
		o.Release()
	})
	return ret
}

func NSDataConformsToProtocol(protocol Protocol) bool {
	ret := (bool)(C.NSData_ConformsToProtocol(protocol.Ptr()))
	return ret
}

func NSDataSupportsSecureCoding() bool {
	ret := (bool)(C.NSData_SupportsSecureCoding())
	return ret
}

func NSDataResolveClassMethod(sel SEL) bool {
	ret := (bool)(C.NSData_ResolveClassMethod(unsafe.Pointer(sel)))
	return ret
}

func NSDataMutableCopyWithZone(zone *_NSZone) *Id {
	ret := &Id{}
	ret.ptr = unsafe.Pointer(C.NSData_MutableCopyWithZone(unsafe.Pointer(zone)))
	if ret.ptr == nil { return ret }
	runtime.SetFinalizer(ret, func(o *Id) {
		o.Release()
	})
	return ret
}

func NSDataInstancesRespondToSelector(aSelector SEL) bool {
	ret := (bool)(C.NSData_InstancesRespondToSelector(unsafe.Pointer(aSelector)))
	return ret
}

func NSDataAlloc() *NSData {
	ret := &NSData{}
	ret.ptr = unsafe.Pointer(C.NSData_Alloc())
	if ret.ptr == nil { return ret }
	runtime.SetFinalizer(ret, func(o *NSData) {
		o.Release()
	})
	return ret
}

func (o *NSData) GC() {
	if o.ptr == nil { return }
	runtime.SetFinalizer(o, func(o *NSData) {
		o.Release()
	})
	runtime.KeepAlive(o)
}

func NSDataDebugDescription() *NSString {
	ret := &NSString{}
	ret.ptr = unsafe.Pointer(C.NSData_DebugDescription())
	if ret.ptr == nil { return ret }
	return ret
}

func NSDataWithContentsOfFile(path *NSString) *NSData {
	ret := &NSData{}
	ret.ptr = unsafe.Pointer(C.NSData_DataWithContentsOfFile(path.Ptr()))
	if ret.ptr == nil { return ret }
	runtime.SetFinalizer(ret, func(o *NSData) {
		o.Release()
	})
	return ret
}

func NSDataWithContentsOfFileOptions(path *NSString, readOptionsMask NSDataReadingOptions, errorPtr *[]*NSError) *NSData {

	goSlice2 := make([]unsafe.Pointer,cap(*errorPtr))
	for i := 0; i < len(*errorPtr); i++ {
		goSlice2[i] = (*errorPtr)[i].Ptr()
	}
	ret := &NSData{}
	ret.ptr = unsafe.Pointer(C.NSData_DataWithContentsOfFileOptions(path.Ptr(), (C.NSDataReadingOptions)(readOptionsMask), (*unsafe.Pointer)(unsafe.Pointer(&goSlice2[0]))))
	(*errorPtr) = (*errorPtr)[:cap(*errorPtr)]
	for i := 0; i < len(*errorPtr); i++ {
		if goSlice2[i] == nil {
			(*errorPtr) = (*errorPtr)[:i]
			break
		}
		if (*errorPtr)[i] == nil {
			(*errorPtr)[i] = &NSError{}
			runtime.SetFinalizer((*errorPtr)[i], func(o *NSError) {
				o.Release()
			})
		}
		(*errorPtr)[i].ptr = goSlice2[i]
	}
	if ret.ptr == nil { return ret }
	runtime.SetFinalizer(ret, func(o *NSData) {
		o.Release()
	})
	return ret
}

func NSDataWithContentsOfFileOptionsError(path *NSString, readOptionsMask NSDataReadingOptions, errorPtr *[]*NSError) *NSData {

	goSlice2 := make([]unsafe.Pointer,cap(*errorPtr))
	for i := 0; i < len(*errorPtr); i++ {
		goSlice2[i] = (*errorPtr)[i].Ptr()
	}
	ret := &NSData{}
	ret.ptr = unsafe.Pointer(C.NSData_DataWithContentsOfFileOptionsError(path.Ptr(), (C.NSDataReadingOptions)(readOptionsMask), (*unsafe.Pointer)(unsafe.Pointer(&goSlice2[0]))))
	(*errorPtr) = (*errorPtr)[:cap(*errorPtr)]
	for i := 0; i < len(*errorPtr); i++ {
		if goSlice2[i] == nil {
			(*errorPtr) = (*errorPtr)[:i]
			break
		}
		if (*errorPtr)[i] == nil {
			(*errorPtr)[i] = &NSError{}
			runtime.SetFinalizer((*errorPtr)[i], func(o *NSError) {
				o.Release()
			})
		}
		(*errorPtr)[i].ptr = goSlice2[i]
	}
	if ret.ptr == nil { return ret }
	runtime.SetFinalizer(ret, func(o *NSData) {
		o.Release()
	})
	return ret
}

func NSDataWithData(data *NSData) *NSData {
	ret := &NSData{}
	ret.ptr = unsafe.Pointer(C.NSData_DataWithData(data.Ptr()))
	if ret.ptr == nil { return ret }
	runtime.SetFinalizer(ret, func(o *NSData) {
		o.Release()
	})
	return ret
}

func NSDataHash() NSUInteger {
	ret := (NSUInteger)(C.NSData_Hash())
	return ret
}

func NSDataAllocWithZone(zone *_NSZone) *NSData {
	ret := &NSData{}
	ret.ptr = unsafe.Pointer(C.NSData_AllocWithZone(unsafe.Pointer(zone)))
	if ret.ptr == nil { return ret }
	runtime.SetFinalizer(ret, func(o *NSData) {
		o.Release()
	})
	return ret
}

func NSDataKeyPathsForValuesAffectingValueForKey(key *NSString) *NSSet {
	ret := &NSSet{}
	ret.ptr = unsafe.Pointer(C.NSData_KeyPathsForValuesAffectingValueForKey(key.Ptr()))
	if ret.ptr == nil { return ret }
	return ret
}

func NSDataWithBytesNoCopyLength(bytes unsafe.Pointer, length NSUInteger) *NSData {
	ret := &NSData{}
	ret.ptr = unsafe.Pointer(C.NSData_DataWithBytesNoCopyLength(unsafe.Pointer(bytes), (C.NSUInteger)(length)))
	if ret.ptr == nil { return ret }
	runtime.SetFinalizer(ret, func(o *NSData) {
		o.Release()
	})
	return ret
}

func NSDataWithBytesNoCopyLengthFreeWhenDone(bytes unsafe.Pointer, length NSUInteger, b BOOL) *NSData {
	ret := &NSData{}
	ret.ptr = unsafe.Pointer(C.NSData_DataWithBytesNoCopyLengthFreeWhenDone(unsafe.Pointer(bytes), (C.NSUInteger)(length), (C.BOOL)(b)))
	if ret.ptr == nil { return ret }
	runtime.SetFinalizer(ret, func(o *NSData) {
		o.Release()
	})
	return ret
}

func NSDataWithContentsOfURL(url *NSURL) *NSData {
	ret := &NSData{}
	ret.ptr = unsafe.Pointer(C.NSData_DataWithContentsOfURL(url.Ptr()))
	if ret.ptr == nil { return ret }
	runtime.SetFinalizer(ret, func(o *NSData) {
		o.Release()
	})
	return ret
}

func NSDataWithContentsOfURLOptions(url *NSURL, readOptionsMask NSDataReadingOptions, errorPtr *[]*NSError) *NSData {

	goSlice2 := make([]unsafe.Pointer,cap(*errorPtr))
	for i := 0; i < len(*errorPtr); i++ {
		goSlice2[i] = (*errorPtr)[i].Ptr()
	}
	ret := &NSData{}
	ret.ptr = unsafe.Pointer(C.NSData_DataWithContentsOfURLOptions(url.Ptr(), (C.NSDataReadingOptions)(readOptionsMask), (*unsafe.Pointer)(unsafe.Pointer(&goSlice2[0]))))
	(*errorPtr) = (*errorPtr)[:cap(*errorPtr)]
	for i := 0; i < len(*errorPtr); i++ {
		if goSlice2[i] == nil {
			(*errorPtr) = (*errorPtr)[:i]
			break
		}
		if (*errorPtr)[i] == nil {
			(*errorPtr)[i] = &NSError{}
			runtime.SetFinalizer((*errorPtr)[i], func(o *NSError) {
				o.Release()
			})
		}
		(*errorPtr)[i].ptr = goSlice2[i]
	}
	if ret.ptr == nil { return ret }
	runtime.SetFinalizer(ret, func(o *NSData) {
		o.Release()
	})
	return ret
}

func NSDataWithContentsOfURLOptionsError(url *NSURL, readOptionsMask NSDataReadingOptions, errorPtr *[]*NSError) *NSData {

	goSlice2 := make([]unsafe.Pointer,cap(*errorPtr))
	for i := 0; i < len(*errorPtr); i++ {
		goSlice2[i] = (*errorPtr)[i].Ptr()
	}
	ret := &NSData{}
	ret.ptr = unsafe.Pointer(C.NSData_DataWithContentsOfURLOptionsError(url.Ptr(), (C.NSDataReadingOptions)(readOptionsMask), (*unsafe.Pointer)(unsafe.Pointer(&goSlice2[0]))))
	(*errorPtr) = (*errorPtr)[:cap(*errorPtr)]
	for i := 0; i < len(*errorPtr); i++ {
		if goSlice2[i] == nil {
			(*errorPtr) = (*errorPtr)[:i]
			break
		}
		if (*errorPtr)[i] == nil {
			(*errorPtr)[i] = &NSError{}
			runtime.SetFinalizer((*errorPtr)[i], func(o *NSError) {
				o.Release()
			})
		}
		(*errorPtr)[i].ptr = goSlice2[i]
	}
	if ret.ptr == nil { return ret }
	runtime.SetFinalizer(ret, func(o *NSData) {
		o.Release()
	})
	return ret
}

func NSDataWithBytesLength(bytes unsafe.Pointer, length NSUInteger) *NSData {
	ret := &NSData{}
	ret.ptr = unsafe.Pointer(C.NSData_DataWithBytesLength(unsafe.Pointer(bytes), (C.NSUInteger)(length)))
	if ret.ptr == nil { return ret }
	runtime.SetFinalizer(ret, func(o *NSData) {
		o.Release()
	})
	return ret
}

func NSDataClassFallbacksForKeyedArchiver() *NSArray {
	ret := &NSArray{}
	ret.ptr = unsafe.Pointer(C.NSData_ClassFallbacksForKeyedArchiver())
	if ret.ptr == nil { return ret }
	return ret
}

func NSDataNew() *NSData {
	ret := &NSData{}
	ret.ptr = unsafe.Pointer(C.NSData_New())
	if ret.ptr == nil { return ret }
	runtime.SetFinalizer(ret, func(o *NSData) {
		o.Release()
	})
	return ret
}

func NSDataSetVersion(aVersion NSInteger)  {
	C.NSData_SetVersion((C.NSInteger)(aVersion))
}

func NSDataLoad()  {
	C.NSData_Load()
}

func NSDataCancelPreviousPerformRequestsWithTarget(aTarget NSObject)  {
	C.NSData_CancelPreviousPerformRequestsWithTarget(aTarget.Ptr())
}

func NSDataCancelPreviousPerformRequestsWithTargetSelector(aTarget NSObject, aSelector SEL, anArgument NSObject)  {
	C.NSData_CancelPreviousPerformRequestsWithTargetSelector(aTarget.Ptr(), unsafe.Pointer(aSelector), anArgument.Ptr())
}

func NSDataCancelPreviousPerformRequestsWithTargetSelectorObject(aTarget NSObject, aSelector SEL, anArgument NSObject)  {
	C.NSData_CancelPreviousPerformRequestsWithTargetSelectorObject(aTarget.Ptr(), unsafe.Pointer(aSelector), anArgument.Ptr())
}

func NSDataInstanceMethodSignatureForSelector(aSelector SEL) *NSMethodSignature {
	ret := &NSMethodSignature{}
	ret.ptr = unsafe.Pointer(C.NSData_InstanceMethodSignatureForSelector(unsafe.Pointer(aSelector)))
	if ret.ptr == nil { return ret }
	return ret
}

func NSDataVersion() NSInteger {
	ret := (NSInteger)(C.NSData_Version())
	return ret
}

func NSDataClass() Class {
	ret := (Class)(unsafe.Pointer(C.NSData_Class()))
	return ret
}

func NSDataData() *NSData {
	ret := &NSData{}
	ret.ptr = unsafe.Pointer(C.NSData_Data())
	if ret.ptr == nil { return ret }
	runtime.SetFinalizer(ret, func(o *NSData) {
		o.Release()
	})
	return ret
}

func NSDataResolveInstanceMethod(sel SEL) bool {
	ret := (bool)(C.NSData_ResolveInstanceMethod(unsafe.Pointer(sel)))
	return ret
}

func NSDataAccessInstanceVariablesDirectly() bool {
	ret := (bool)(C.NSData_AccessInstanceVariablesDirectly())
	return ret
}

func NSDataSuperclass() Class {
	ret := (Class)(unsafe.Pointer(C.NSData_Superclass()))
	return ret
}

func NSDataClassForKeyedUnarchiver() Class {
	ret := (Class)(unsafe.Pointer(C.NSData_ClassForKeyedUnarchiver()))
	return ret
}

func (o *NSData) Base64EncodedDataWithOptions(options NSDataBase64EncodingOptions) *NSData {
	ret := &NSData{}
	ret.ptr = unsafe.Pointer(C.NSData_inst_Base64EncodedDataWithOptions(o.Ptr(), (C.NSDataBase64EncodingOptions)(options)))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSData)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *NSData) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *NSData) AwakeAfterUsingCoder(coder *NSCoder) *Id {
	ret := &Id{}
	ret.ptr = unsafe.Pointer(C.NSData_inst_AwakeAfterUsingCoder(o.Ptr(), coder.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *Id) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *NSData) ObserveValueForKeyPathOfObject(keyPath *NSString, object NSObject, change *NSDictionary, context unsafe.Pointer)  {
	C.NSData_inst_ObserveValueForKeyPathOfObject(o.Ptr(), keyPath.Ptr(), object.Ptr(), change.Ptr(), unsafe.Pointer(context))
	runtime.KeepAlive(o)
}

func (o *NSData) ObserveValueForKeyPathOfObjectChange(keyPath *NSString, object NSObject, change *NSDictionary, context unsafe.Pointer)  {
	C.NSData_inst_ObserveValueForKeyPathOfObjectChange(o.Ptr(), keyPath.Ptr(), object.Ptr(), change.Ptr(), unsafe.Pointer(context))
	runtime.KeepAlive(o)
}

func (o *NSData) ObjectSpecifier() *NSScriptObjectSpecifier {
	ret := &NSScriptObjectSpecifier{}
	ret.ptr = unsafe.Pointer(C.NSData_inst_ObjectSpecifier(o.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSScriptObjectSpecifier)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *NSScriptObjectSpecifier) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *NSData) MutableArrayValueForKey(key *NSString) *NSMutableArray {
	ret := &NSMutableArray{}
	ret.ptr = unsafe.Pointer(C.NSData_inst_MutableArrayValueForKey(o.Ptr(), key.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSMutableArray)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *NSMutableArray) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *NSData) Superclass() Class {
	ret := (Class)(unsafe.Pointer(C.NSData_inst_Superclass(o.Ptr())))
	runtime.KeepAlive(o)
	return ret
}

func (o *NSData) ScriptingIsGreaterThanOrEqualTo(object NSObject) bool {
	ret := (bool)(C.NSData_inst_ScriptingIsGreaterThanOrEqualTo(o.Ptr(), object.Ptr()))
	runtime.KeepAlive(o)
	return ret
}

func (o *NSData) IsKindOfClass(aClass Class) bool {
	ret := (bool)(C.NSData_inst_IsKindOfClass(o.Ptr(), unsafe.Pointer(aClass)))
	runtime.KeepAlive(o)
	return ret
}

func (o *NSData) InitWithData(data *NSData) *NSData {
	ret := &NSData{}
	ret.ptr = unsafe.Pointer(C.NSData_inst_InitWithData(o.Ptr(), data.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSData)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *NSData) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *NSData) InitWithContentsOfURL(url *NSURL) *NSData {
	ret := &NSData{}
	ret.ptr = unsafe.Pointer(C.NSData_inst_InitWithContentsOfURL(o.Ptr(), url.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSData)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *NSData) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *NSData) InitWithContentsOfURLOptions(url *NSURL, readOptionsMask NSDataReadingOptions, errorPtr *[]*NSError) *NSData {

	goSlice3 := make([]unsafe.Pointer,cap(*errorPtr))
	for i := 0; i < len(*errorPtr); i++ {
		goSlice3[i] = (*errorPtr)[i].Ptr()
	}
	ret := &NSData{}
	ret.ptr = unsafe.Pointer(C.NSData_inst_InitWithContentsOfURLOptions(o.Ptr(), url.Ptr(), (C.NSDataReadingOptions)(readOptionsMask), (*unsafe.Pointer)(unsafe.Pointer(&goSlice3[0]))))
	(*errorPtr) = (*errorPtr)[:cap(*errorPtr)]
	for i := 0; i < len(*errorPtr); i++ {
		if goSlice3[i] == nil {
			(*errorPtr) = (*errorPtr)[:i]
			break
		}
		if (*errorPtr)[i] == nil {
			(*errorPtr)[i] = &NSError{}
			runtime.SetFinalizer((*errorPtr)[i], func(o *NSError) {
				o.Release()
			})
		}
		(*errorPtr)[i].ptr = goSlice3[i]
	}
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSData)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *NSData) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *NSData) InitWithContentsOfURLOptionsError(url *NSURL, readOptionsMask NSDataReadingOptions, errorPtr *[]*NSError) *NSData {

	goSlice3 := make([]unsafe.Pointer,cap(*errorPtr))
	for i := 0; i < len(*errorPtr); i++ {
		goSlice3[i] = (*errorPtr)[i].Ptr()
	}
	ret := &NSData{}
	ret.ptr = unsafe.Pointer(C.NSData_inst_InitWithContentsOfURLOptionsError(o.Ptr(), url.Ptr(), (C.NSDataReadingOptions)(readOptionsMask), (*unsafe.Pointer)(unsafe.Pointer(&goSlice3[0]))))
	(*errorPtr) = (*errorPtr)[:cap(*errorPtr)]
	for i := 0; i < len(*errorPtr); i++ {
		if goSlice3[i] == nil {
			(*errorPtr) = (*errorPtr)[:i]
			break
		}
		if (*errorPtr)[i] == nil {
			(*errorPtr)[i] = &NSError{}
			runtime.SetFinalizer((*errorPtr)[i], func(o *NSError) {
				o.Release()
			})
		}
		(*errorPtr)[i].ptr = goSlice3[i]
	}
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSData)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *NSData) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *NSData) DictionaryWithValuesForKeys(keys *NSArray) *NSDictionary {
	ret := &NSDictionary{}
	ret.ptr = unsafe.Pointer(C.NSData_inst_DictionaryWithValuesForKeys(o.Ptr(), keys.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSDictionary)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *NSDictionary) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *NSData) RetainCount() NSUInteger {
	ret := (NSUInteger)(C.NSData_inst_RetainCount(o.Ptr()))
	runtime.KeepAlive(o)
	return ret
}

func (o *NSData) MutableCopyWithZone(zone *NSZone) *Id {
	ret := &Id{}
	ret.ptr = unsafe.Pointer(C.NSData_inst_MutableCopyWithZone(o.Ptr(), unsafe.Pointer(zone)))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *Id) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *NSData) InitWithBytesNoCopyLength(bytes unsafe.Pointer, length NSUInteger) *NSData {
	ret := &NSData{}
	ret.ptr = unsafe.Pointer(C.NSData_inst_InitWithBytesNoCopyLength(o.Ptr(), unsafe.Pointer(bytes), (C.NSUInteger)(length)))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSData)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *NSData) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *NSData) InitWithBytesNoCopyLengthFreeWhenDone(bytes unsafe.Pointer, length NSUInteger, b BOOL) *NSData {
	ret := &NSData{}
	ret.ptr = unsafe.Pointer(C.NSData_inst_InitWithBytesNoCopyLengthFreeWhenDone(o.Ptr(), unsafe.Pointer(bytes), (C.NSUInteger)(length), (C.BOOL)(b)))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSData)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *NSData) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *NSData) InitWithBase64EncodedDataOptions(base64Data *NSData, options NSDataBase64DecodingOptions) *NSData {
	ret := &NSData{}
	ret.ptr = unsafe.Pointer(C.NSData_inst_InitWithBase64EncodedDataOptions(o.Ptr(), base64Data.Ptr(), (C.NSDataBase64DecodingOptions)(options)))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSData)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *NSData) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *NSData) SubdataWithRange(range_ NSRange) *NSData {
	ret := &NSData{}
	ret.ptr = unsafe.Pointer(C.NSData_inst_SubdataWithRange(o.Ptr(), (C.NSRange)(range_)))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSData)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *NSData) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *NSData) IsMemberOfClass(aClass Class) bool {
	ret := (bool)(C.NSData_inst_IsMemberOfClass(o.Ptr(), unsafe.Pointer(aClass)))
	runtime.KeepAlive(o)
	return ret
}

func (o *NSData) IndicesOfObjectsByEvaluatingObjectSpecifier(specifier *NSScriptObjectSpecifier) *NSArray {
	ret := &NSArray{}
	ret.ptr = unsafe.Pointer(C.NSData_inst_IndicesOfObjectsByEvaluatingObjectSpecifier(o.Ptr(), specifier.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSArray)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *NSArray) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *NSData) SetValuesForKeysWithDictionary(keyedValues *NSDictionary)  {
	C.NSData_inst_SetValuesForKeysWithDictionary(o.Ptr(), keyedValues.Ptr())
	runtime.KeepAlive(o)
}

func (o *NSData) PerformSelector(aSelector SEL) *Id {
	ret := &Id{}
	ret.ptr = unsafe.Pointer(C.NSData_inst_PerformSelector(o.Ptr(), unsafe.Pointer(aSelector)))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *Id) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *NSData) PerformSelectorWithObject(aSelector SEL, object NSObject) *Id {
	ret := &Id{}
	ret.ptr = unsafe.Pointer(C.NSData_inst_PerformSelectorWithObject(o.Ptr(), unsafe.Pointer(aSelector), object.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *Id) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *NSData) PerformSelectorWithObjectWithObject(aSelector SEL, object1 NSObject, object2 NSObject) *Id {
	ret := &Id{}
	ret.ptr = unsafe.Pointer(C.NSData_inst_PerformSelectorWithObjectWithObject(o.Ptr(), unsafe.Pointer(aSelector), object1.Ptr(), object2.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *Id) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *NSData) PerformSelectorWithObjectAfterDelay(aSelector SEL, anArgument NSObject, delay NSTimeInterval)  {
	C.NSData_inst_PerformSelectorWithObjectAfterDelay(o.Ptr(), unsafe.Pointer(aSelector), anArgument.Ptr(), (C.NSTimeInterval)(delay))
	runtime.KeepAlive(o)
}

func (o *NSData) PerformSelectorOnThread(aSelector SEL, thr *NSThread, arg NSObject, wait BOOL)  {
	C.NSData_inst_PerformSelectorOnThread(o.Ptr(), unsafe.Pointer(aSelector), thr.Ptr(), arg.Ptr(), (C.BOOL)(wait))
	runtime.KeepAlive(o)
}

func (o *NSData) PerformSelectorWithObjectAfterDelayInModes(aSelector SEL, anArgument NSObject, delay NSTimeInterval, modes *NSArray)  {
	C.NSData_inst_PerformSelectorWithObjectAfterDelayInModes(o.Ptr(), unsafe.Pointer(aSelector), anArgument.Ptr(), (C.NSTimeInterval)(delay), modes.Ptr())
	runtime.KeepAlive(o)
}

func (o *NSData) PerformSelectorOnThreadWithObject(aSelector SEL, thr *NSThread, arg NSObject, wait BOOL)  {
	C.NSData_inst_PerformSelectorOnThreadWithObject(o.Ptr(), unsafe.Pointer(aSelector), thr.Ptr(), arg.Ptr(), (C.BOOL)(wait))
	runtime.KeepAlive(o)
}

func (o *NSData) PerformSelectorOnThreadWithObjectWaitUntilDone(aSelector SEL, thr *NSThread, arg NSObject, wait BOOL, array *NSArray)  {
	C.NSData_inst_PerformSelectorOnThreadWithObjectWaitUntilDone(o.Ptr(), unsafe.Pointer(aSelector), thr.Ptr(), arg.Ptr(), (C.BOOL)(wait), array.Ptr())
	runtime.KeepAlive(o)
}

func (o *NSData) PerformSelectorOnThreadWithObjectWaitUntilDoneModes(aSelector SEL, thr *NSThread, arg NSObject, wait BOOL, array *NSArray)  {
	C.NSData_inst_PerformSelectorOnThreadWithObjectWaitUntilDoneModes(o.Ptr(), unsafe.Pointer(aSelector), thr.Ptr(), arg.Ptr(), (C.BOOL)(wait), array.Ptr())
	runtime.KeepAlive(o)
}

func (o *NSData) MethodSignatureForSelector(aSelector SEL) *NSMethodSignature {
	ret := &NSMethodSignature{}
	ret.ptr = unsafe.Pointer(C.NSData_inst_MethodSignatureForSelector(o.Ptr(), unsafe.Pointer(aSelector)))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSMethodSignature)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *NSMethodSignature) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *NSData) InverseForRelationshipKey(relationshipKey *NSString) *NSString {
	ret := &NSString{}
	ret.ptr = unsafe.Pointer(C.NSData_inst_InverseForRelationshipKey(o.Ptr(), relationshipKey.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSString)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *NSString) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *NSData) ForwardingTargetForSelector(aSelector SEL) *Id {
	ret := &Id{}
	ret.ptr = unsafe.Pointer(C.NSData_inst_ForwardingTargetForSelector(o.Ptr(), unsafe.Pointer(aSelector)))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *Id) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *NSData) ScriptingIsEqualTo(object NSObject) bool {
	ret := (bool)(C.NSData_inst_ScriptingIsEqualTo(o.Ptr(), object.Ptr()))
	runtime.KeepAlive(o)
	return ret
}

func (o *NSData) ValidateValueForKey(ioValue *[]*Id, inKey *NSString, outError *[]*NSError) bool {

	goSlice1 := make([]unsafe.Pointer,cap(*ioValue))
	for i := 0; i < len(*ioValue); i++ {
		goSlice1[i] = (*ioValue)[i].Ptr()
	}

	goSlice3 := make([]unsafe.Pointer,cap(*outError))
	for i := 0; i < len(*outError); i++ {
		goSlice3[i] = (*outError)[i].Ptr()
	}
	ret := (bool)(C.NSData_inst_ValidateValueForKey(o.Ptr(), (*unsafe.Pointer)(unsafe.Pointer(&goSlice1[0])), inKey.Ptr(), (*unsafe.Pointer)(unsafe.Pointer(&goSlice3[0]))))
	(*ioValue) = (*ioValue)[:cap(*ioValue)]
	for i := 0; i < len(*ioValue); i++ {
		if goSlice1[i] == nil {
			(*ioValue) = (*ioValue)[:i]
			break
		}
		if (*ioValue)[i] == nil {
			(*ioValue)[i] = &Id{}
			runtime.SetFinalizer((*ioValue)[i], func(o *Id) {
				o.Release()
			})
		}
		(*ioValue)[i].ptr = goSlice1[i]
	}
	(*outError) = (*outError)[:cap(*outError)]
	for i := 0; i < len(*outError); i++ {
		if goSlice3[i] == nil {
			(*outError) = (*outError)[:i]
			break
		}
		if (*outError)[i] == nil {
			(*outError)[i] = &NSError{}
			runtime.SetFinalizer((*outError)[i], func(o *NSError) {
				o.Release()
			})
		}
		(*outError)[i].ptr = goSlice3[i]
	}
	runtime.KeepAlive(o)
	return ret
}

func (o *NSData) ValidateValueForKeyPath(ioValue *[]*Id, inKeyPath *NSString, outError *[]*NSError) bool {

	goSlice1 := make([]unsafe.Pointer,cap(*ioValue))
	for i := 0; i < len(*ioValue); i++ {
		goSlice1[i] = (*ioValue)[i].Ptr()
	}

	goSlice3 := make([]unsafe.Pointer,cap(*outError))
	for i := 0; i < len(*outError); i++ {
		goSlice3[i] = (*outError)[i].Ptr()
	}
	ret := (bool)(C.NSData_inst_ValidateValueForKeyPath(o.Ptr(), (*unsafe.Pointer)(unsafe.Pointer(&goSlice1[0])), inKeyPath.Ptr(), (*unsafe.Pointer)(unsafe.Pointer(&goSlice3[0]))))
	(*ioValue) = (*ioValue)[:cap(*ioValue)]
	for i := 0; i < len(*ioValue); i++ {
		if goSlice1[i] == nil {
			(*ioValue) = (*ioValue)[:i]
			break
		}
		if (*ioValue)[i] == nil {
			(*ioValue)[i] = &Id{}
			runtime.SetFinalizer((*ioValue)[i], func(o *Id) {
				o.Release()
			})
		}
		(*ioValue)[i].ptr = goSlice1[i]
	}
	(*outError) = (*outError)[:cap(*outError)]
	for i := 0; i < len(*outError); i++ {
		if goSlice3[i] == nil {
			(*outError) = (*outError)[:i]
			break
		}
		if (*outError)[i] == nil {
			(*outError)[i] = &NSError{}
			runtime.SetFinalizer((*outError)[i], func(o *NSError) {
				o.Release()
			})
		}
		(*outError)[i].ptr = goSlice3[i]
	}
	runtime.KeepAlive(o)
	return ret
}

func (o *NSData) ValidateValueForKeyError(ioValue *[]*Id, inKey *NSString, outError *[]*NSError) bool {

	goSlice1 := make([]unsafe.Pointer,cap(*ioValue))
	for i := 0; i < len(*ioValue); i++ {
		goSlice1[i] = (*ioValue)[i].Ptr()
	}

	goSlice3 := make([]unsafe.Pointer,cap(*outError))
	for i := 0; i < len(*outError); i++ {
		goSlice3[i] = (*outError)[i].Ptr()
	}
	ret := (bool)(C.NSData_inst_ValidateValueForKeyError(o.Ptr(), (*unsafe.Pointer)(unsafe.Pointer(&goSlice1[0])), inKey.Ptr(), (*unsafe.Pointer)(unsafe.Pointer(&goSlice3[0]))))
	(*ioValue) = (*ioValue)[:cap(*ioValue)]
	for i := 0; i < len(*ioValue); i++ {
		if goSlice1[i] == nil {
			(*ioValue) = (*ioValue)[:i]
			break
		}
		if (*ioValue)[i] == nil {
			(*ioValue)[i] = &Id{}
			runtime.SetFinalizer((*ioValue)[i], func(o *Id) {
				o.Release()
			})
		}
		(*ioValue)[i].ptr = goSlice1[i]
	}
	(*outError) = (*outError)[:cap(*outError)]
	for i := 0; i < len(*outError); i++ {
		if goSlice3[i] == nil {
			(*outError) = (*outError)[:i]
			break
		}
		if (*outError)[i] == nil {
			(*outError)[i] = &NSError{}
			runtime.SetFinalizer((*outError)[i], func(o *NSError) {
				o.Release()
			})
		}
		(*outError)[i].ptr = goSlice3[i]
	}
	runtime.KeepAlive(o)
	return ret
}

func (o *NSData) ValidateValueForKeyPathError(ioValue *[]*Id, inKeyPath *NSString, outError *[]*NSError) bool {

	goSlice1 := make([]unsafe.Pointer,cap(*ioValue))
	for i := 0; i < len(*ioValue); i++ {
		goSlice1[i] = (*ioValue)[i].Ptr()
	}

	goSlice3 := make([]unsafe.Pointer,cap(*outError))
	for i := 0; i < len(*outError); i++ {
		goSlice3[i] = (*outError)[i].Ptr()
	}
	ret := (bool)(C.NSData_inst_ValidateValueForKeyPathError(o.Ptr(), (*unsafe.Pointer)(unsafe.Pointer(&goSlice1[0])), inKeyPath.Ptr(), (*unsafe.Pointer)(unsafe.Pointer(&goSlice3[0]))))
	(*ioValue) = (*ioValue)[:cap(*ioValue)]
	for i := 0; i < len(*ioValue); i++ {
		if goSlice1[i] == nil {
			(*ioValue) = (*ioValue)[:i]
			break
		}
		if (*ioValue)[i] == nil {
			(*ioValue)[i] = &Id{}
			runtime.SetFinalizer((*ioValue)[i], func(o *Id) {
				o.Release()
			})
		}
		(*ioValue)[i].ptr = goSlice1[i]
	}
	(*outError) = (*outError)[:cap(*outError)]
	for i := 0; i < len(*outError); i++ {
		if goSlice3[i] == nil {
			(*outError) = (*outError)[:i]
			break
		}
		if (*outError)[i] == nil {
			(*outError)[i] = &NSError{}
			runtime.SetFinalizer((*outError)[i], func(o *NSError) {
				o.Release()
			})
		}
		(*outError)[i].ptr = goSlice3[i]
	}
	runtime.KeepAlive(o)
	return ret
}

func (o *NSData) Description() *NSString {
	ret := &NSString{}
	ret.ptr = unsafe.Pointer(C.NSData_inst_Description(o.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSString)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *NSString) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *NSData) ConformsToProtocol(aProtocol Protocol) bool {
	ret := (bool)(C.NSData_inst_ConformsToProtocol(o.Ptr(), aProtocol.Ptr()))
	runtime.KeepAlive(o)
	return ret
}

func (o *NSData) ScriptingIsGreaterThan(object NSObject) bool {
	ret := (bool)(C.NSData_inst_ScriptingIsGreaterThan(o.Ptr(), object.Ptr()))
	runtime.KeepAlive(o)
	return ret
}

func (o *NSData) MutableCopy() *Id {
	ret := &Id{}
	ret.ptr = unsafe.Pointer(C.NSData_inst_MutableCopy(o.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	runtime.SetFinalizer(ret, func(o *Id) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *NSData) IsGreaterThan(object NSObject) bool {
	ret := (bool)(C.NSData_inst_IsGreaterThan(o.Ptr(), object.Ptr()))
	runtime.KeepAlive(o)
	return ret
}

func (o *NSData) IsCaseInsensitiveLike(object *NSString) bool {
	ret := (bool)(C.NSData_inst_IsCaseInsensitiveLike(o.Ptr(), object.Ptr()))
	runtime.KeepAlive(o)
	return ret
}

func (o *NSData) ValueWithNameInPropertyWithKey(name *NSString, key *NSString) *Id {
	ret := &Id{}
	ret.ptr = unsafe.Pointer(C.NSData_inst_ValueWithNameInPropertyWithKey(o.Ptr(), name.Ptr(), key.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *Id) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *NSData) WillChangeValuesAtIndexes(changeKind NSKeyValueChange, indexes *NSIndexSet, key *NSString)  {
	C.NSData_inst_WillChangeValuesAtIndexes(o.Ptr(), (C.NSKeyValueChange)(changeKind), indexes.Ptr(), key.Ptr())
	runtime.KeepAlive(o)
}

func (o *NSData) WillChangeValuesAtIndexesForKey(changeKind NSKeyValueChange, indexes *NSIndexSet, key *NSString)  {
	C.NSData_inst_WillChangeValuesAtIndexesForKey(o.Ptr(), (C.NSKeyValueChange)(changeKind), indexes.Ptr(), key.Ptr())
	runtime.KeepAlive(o)
}

func (o *NSData) CoerceValueForKey(value NSObject, key *NSString) *Id {
	ret := &Id{}
	ret.ptr = unsafe.Pointer(C.NSData_inst_CoerceValueForKey(o.Ptr(), value.Ptr(), key.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *Id) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *NSData) Hash() NSUInteger {
	ret := (NSUInteger)(C.NSData_inst_Hash(o.Ptr()))
	runtime.KeepAlive(o)
	return ret
}

func (o *NSData) SetNilValueForKey(key *NSString)  {
	C.NSData_inst_SetNilValueForKey(o.Ptr(), key.Ptr())
	runtime.KeepAlive(o)
}

func (o *NSData) ScriptingValueForSpecifier(objectSpecifier *NSScriptObjectSpecifier) *Id {
	ret := &Id{}
	ret.ptr = unsafe.Pointer(C.NSData_inst_ScriptingValueForSpecifier(o.Ptr(), objectSpecifier.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *Id) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *NSData) ScriptingBeginsWith(object NSObject) bool {
	ret := (bool)(C.NSData_inst_ScriptingBeginsWith(o.Ptr(), object.Ptr()))
	runtime.KeepAlive(o)
	return ret
}

func (o *NSData) WriteToFileAtomically(path *NSString, useAuxiliaryFile BOOL) bool {
	ret := (bool)(C.NSData_inst_WriteToFileAtomically(o.Ptr(), path.Ptr(), (C.BOOL)(useAuxiliaryFile)))
	runtime.KeepAlive(o)
	return ret
}

func (o *NSData) WriteToFileOptions(path *NSString, writeOptionsMask NSDataWritingOptions, errorPtr *[]*NSError) bool {

	goSlice3 := make([]unsafe.Pointer,cap(*errorPtr))
	for i := 0; i < len(*errorPtr); i++ {
		goSlice3[i] = (*errorPtr)[i].Ptr()
	}
	ret := (bool)(C.NSData_inst_WriteToFileOptions(o.Ptr(), path.Ptr(), (C.NSDataWritingOptions)(writeOptionsMask), (*unsafe.Pointer)(unsafe.Pointer(&goSlice3[0]))))
	(*errorPtr) = (*errorPtr)[:cap(*errorPtr)]
	for i := 0; i < len(*errorPtr); i++ {
		if goSlice3[i] == nil {
			(*errorPtr) = (*errorPtr)[:i]
			break
		}
		if (*errorPtr)[i] == nil {
			(*errorPtr)[i] = &NSError{}
			runtime.SetFinalizer((*errorPtr)[i], func(o *NSError) {
				o.Release()
			})
		}
		(*errorPtr)[i].ptr = goSlice3[i]
	}
	runtime.KeepAlive(o)
	return ret
}

func (o *NSData) WriteToFileOptionsError(path *NSString, writeOptionsMask NSDataWritingOptions, errorPtr *[]*NSError) bool {

	goSlice3 := make([]unsafe.Pointer,cap(*errorPtr))
	for i := 0; i < len(*errorPtr); i++ {
		goSlice3[i] = (*errorPtr)[i].Ptr()
	}
	ret := (bool)(C.NSData_inst_WriteToFileOptionsError(o.Ptr(), path.Ptr(), (C.NSDataWritingOptions)(writeOptionsMask), (*unsafe.Pointer)(unsafe.Pointer(&goSlice3[0]))))
	(*errorPtr) = (*errorPtr)[:cap(*errorPtr)]
	for i := 0; i < len(*errorPtr); i++ {
		if goSlice3[i] == nil {
			(*errorPtr) = (*errorPtr)[:i]
			break
		}
		if (*errorPtr)[i] == nil {
			(*errorPtr)[i] = &NSError{}
			runtime.SetFinalizer((*errorPtr)[i], func(o *NSError) {
				o.Release()
			})
		}
		(*errorPtr)[i].ptr = goSlice3[i]
	}
	runtime.KeepAlive(o)
	return ret
}

func (o *NSData) InitWithBytesLength(bytes unsafe.Pointer, length NSUInteger) *NSData {
	ret := &NSData{}
	ret.ptr = unsafe.Pointer(C.NSData_inst_InitWithBytesLength(o.Ptr(), unsafe.Pointer(bytes), (C.NSUInteger)(length)))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSData)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *NSData) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *NSData) ScriptingIsLessThan(object NSObject) bool {
	ret := (bool)(C.NSData_inst_ScriptingIsLessThan(o.Ptr(), object.Ptr()))
	runtime.KeepAlive(o)
	return ret
}

func (o *NSData) Init() *NSData {
	ret := &NSData{}
	ret.ptr = unsafe.Pointer(C.NSData_inst_Init(o.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSData)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *NSData) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *NSData) MutableArrayValueForKeyPath(keyPath *NSString) *NSMutableArray {
	ret := &NSMutableArray{}
	ret.ptr = unsafe.Pointer(C.NSData_inst_MutableArrayValueForKeyPath(o.Ptr(), keyPath.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSMutableArray)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *NSMutableArray) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *NSData) InsertValueInPropertyWithKey(value NSObject, key *NSString)  {
	C.NSData_inst_InsertValueInPropertyWithKey(o.Ptr(), value.Ptr(), key.Ptr())
	runtime.KeepAlive(o)
}

func (o *NSData) InsertValueAtIndex(value NSObject, index NSUInteger, key *NSString)  {
	C.NSData_inst_InsertValueAtIndex(o.Ptr(), value.Ptr(), (C.NSUInteger)(index), key.Ptr())
	runtime.KeepAlive(o)
}

func (o *NSData) InsertValueAtIndexInPropertyWithKey(value NSObject, index NSUInteger, key *NSString)  {
	C.NSData_inst_InsertValueAtIndexInPropertyWithKey(o.Ptr(), value.Ptr(), (C.NSUInteger)(index), key.Ptr())
	runtime.KeepAlive(o)
}

func (o *NSData) ClassDescription() *NSClassDescription {
	ret := &NSClassDescription{}
	ret.ptr = unsafe.Pointer(C.NSData_inst_ClassDescription(o.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSClassDescription)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *NSClassDescription) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *NSData) DoesContain(object NSObject) bool {
	ret := (bool)(C.NSData_inst_DoesContain(o.Ptr(), object.Ptr()))
	runtime.KeepAlive(o)
	return ret
}

func (o *NSData) GetBytesLength(buffer unsafe.Pointer, length NSUInteger)  {
	C.NSData_inst_GetBytesLength(o.Ptr(), unsafe.Pointer(buffer), (C.NSUInteger)(length))
	runtime.KeepAlive(o)
}

func (o *NSData) GetBytesRange(buffer unsafe.Pointer, range_ NSRange)  {
	C.NSData_inst_GetBytesRange(o.Ptr(), unsafe.Pointer(buffer), (C.NSRange)(range_))
	runtime.KeepAlive(o)
}

func (o *NSData) MutableOrderedSetValueForKey(key *NSString) *NSMutableOrderedSet {
	ret := &NSMutableOrderedSet{}
	ret.ptr = unsafe.Pointer(C.NSData_inst_MutableOrderedSetValueForKey(o.Ptr(), key.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSMutableOrderedSet)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *NSMutableOrderedSet) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *NSData) ScriptingEndsWith(object NSObject) bool {
	ret := (bool)(C.NSData_inst_ScriptingEndsWith(o.Ptr(), object.Ptr()))
	runtime.KeepAlive(o)
	return ret
}

func (o *NSData) ClassForCoder() Class {
	ret := (Class)(unsafe.Pointer(C.NSData_inst_ClassForCoder(o.Ptr())))
	runtime.KeepAlive(o)
	return ret
}

func (o *NSData) IsProxy() bool {
	ret := (bool)(C.NSData_inst_IsProxy(o.Ptr()))
	runtime.KeepAlive(o)
	return ret
}

func (o *NSData) SetScriptingProperties(scriptingProperties *NSDictionary)  {
	C.NSData_inst_SetScriptingProperties(o.Ptr(), scriptingProperties.Ptr())
	runtime.KeepAlive(o)
}

func (o *NSData) Zone() *_NSZone {
	ret := (*_NSZone)(unsafe.Pointer(C.NSData_inst_Zone(o.Ptr())))
	runtime.KeepAlive(o)
	return ret
}

func (o *NSData) Release()  {
	C.NSData_inst_Release(o.Ptr())
	runtime.KeepAlive(o)
}

func (o *NSData) InitWithContentsOfFile(path *NSString) *NSData {
	ret := &NSData{}
	ret.ptr = unsafe.Pointer(C.NSData_inst_InitWithContentsOfFile(o.Ptr(), path.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSData)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *NSData) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *NSData) InitWithContentsOfFileOptions(path *NSString, readOptionsMask NSDataReadingOptions, errorPtr *[]*NSError) *NSData {

	goSlice3 := make([]unsafe.Pointer,cap(*errorPtr))
	for i := 0; i < len(*errorPtr); i++ {
		goSlice3[i] = (*errorPtr)[i].Ptr()
	}
	ret := &NSData{}
	ret.ptr = unsafe.Pointer(C.NSData_inst_InitWithContentsOfFileOptions(o.Ptr(), path.Ptr(), (C.NSDataReadingOptions)(readOptionsMask), (*unsafe.Pointer)(unsafe.Pointer(&goSlice3[0]))))
	(*errorPtr) = (*errorPtr)[:cap(*errorPtr)]
	for i := 0; i < len(*errorPtr); i++ {
		if goSlice3[i] == nil {
			(*errorPtr) = (*errorPtr)[:i]
			break
		}
		if (*errorPtr)[i] == nil {
			(*errorPtr)[i] = &NSError{}
			runtime.SetFinalizer((*errorPtr)[i], func(o *NSError) {
				o.Release()
			})
		}
		(*errorPtr)[i].ptr = goSlice3[i]
	}
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSData)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *NSData) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *NSData) InitWithContentsOfFileOptionsError(path *NSString, readOptionsMask NSDataReadingOptions, errorPtr *[]*NSError) *NSData {

	goSlice3 := make([]unsafe.Pointer,cap(*errorPtr))
	for i := 0; i < len(*errorPtr); i++ {
		goSlice3[i] = (*errorPtr)[i].Ptr()
	}
	ret := &NSData{}
	ret.ptr = unsafe.Pointer(C.NSData_inst_InitWithContentsOfFileOptionsError(o.Ptr(), path.Ptr(), (C.NSDataReadingOptions)(readOptionsMask), (*unsafe.Pointer)(unsafe.Pointer(&goSlice3[0]))))
	(*errorPtr) = (*errorPtr)[:cap(*errorPtr)]
	for i := 0; i < len(*errorPtr); i++ {
		if goSlice3[i] == nil {
			(*errorPtr) = (*errorPtr)[:i]
			break
		}
		if (*errorPtr)[i] == nil {
			(*errorPtr)[i] = &NSError{}
			runtime.SetFinalizer((*errorPtr)[i], func(o *NSError) {
				o.Release()
			})
		}
		(*errorPtr)[i].ptr = goSlice3[i]
	}
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSData)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *NSData) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *NSData) AttributeKeys() *NSArray {
	ret := &NSArray{}
	ret.ptr = unsafe.Pointer(C.NSData_inst_AttributeKeys(o.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSArray)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *NSArray) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *NSData) RespondsToSelector(aSelector SEL) bool {
	ret := (bool)(C.NSData_inst_RespondsToSelector(o.Ptr(), unsafe.Pointer(aSelector)))
	runtime.KeepAlive(o)
	return ret
}

func (o *NSData) MutableSetValueForKey(key *NSString) *NSMutableSet {
	ret := &NSMutableSet{}
	ret.ptr = unsafe.Pointer(C.NSData_inst_MutableSetValueForKey(o.Ptr(), key.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSMutableSet)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *NSMutableSet) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *NSData) DecompressedDataUsingAlgorithmError(algorithm NSDataCompressionAlgorithm, error *[]*NSError) *NSData {

	goSlice2 := make([]unsafe.Pointer,cap(*error))
	for i := 0; i < len(*error); i++ {
		goSlice2[i] = (*error)[i].Ptr()
	}
	ret := &NSData{}
	ret.ptr = unsafe.Pointer(C.NSData_inst_DecompressedDataUsingAlgorithmError(o.Ptr(), (C.NSDataCompressionAlgorithm)(algorithm), (*unsafe.Pointer)(unsafe.Pointer(&goSlice2[0]))))
	(*error) = (*error)[:cap(*error)]
	for i := 0; i < len(*error); i++ {
		if goSlice2[i] == nil {
			(*error) = (*error)[:i]
			break
		}
		if (*error)[i] == nil {
			(*error)[i] = &NSError{}
			runtime.SetFinalizer((*error)[i], func(o *NSError) {
				o.Release()
			})
		}
		(*error)[i].ptr = goSlice2[i]
	}
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSData)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *NSData) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *NSData) InitWithBase64EncodedStringOptions(base64String *NSString, options NSDataBase64DecodingOptions) *NSData {
	ret := &NSData{}
	ret.ptr = unsafe.Pointer(C.NSData_inst_InitWithBase64EncodedStringOptions(o.Ptr(), base64String.Ptr(), (C.NSDataBase64DecodingOptions)(options)))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSData)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *NSData) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *NSData) MutableSetValueForKeyPath(keyPath *NSString) *NSMutableSet {
	ret := &NSMutableSet{}
	ret.ptr = unsafe.Pointer(C.NSData_inst_MutableSetValueForKeyPath(o.Ptr(), keyPath.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSMutableSet)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *NSMutableSet) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *NSData) DoesNotRecognizeSelector(aSelector SEL)  {
	C.NSData_inst_DoesNotRecognizeSelector(o.Ptr(), unsafe.Pointer(aSelector))
	runtime.KeepAlive(o)
}

func (o *NSData) ClassName() *NSString {
	ret := &NSString{}
	ret.ptr = unsafe.Pointer(C.NSData_inst_ClassName(o.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSString)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *NSString) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *NSData) ReplacementObjectForKeyedArchiver(archiver *NSKeyedArchiver) *Id {
	ret := &Id{}
	ret.ptr = unsafe.Pointer(C.NSData_inst_ReplacementObjectForKeyedArchiver(o.Ptr(), archiver.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *Id) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *NSData) ValueWithUniqueIDInPropertyWithKey(uniqueID NSObject, key *NSString) *Id {
	ret := &Id{}
	ret.ptr = unsafe.Pointer(C.NSData_inst_ValueWithUniqueIDInPropertyWithKey(o.Ptr(), uniqueID.Ptr(), key.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *Id) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *NSData) CompressedDataUsingAlgorithmError(algorithm NSDataCompressionAlgorithm, error *[]*NSError) *NSData {

	goSlice2 := make([]unsafe.Pointer,cap(*error))
	for i := 0; i < len(*error); i++ {
		goSlice2[i] = (*error)[i].Ptr()
	}
	ret := &NSData{}
	ret.ptr = unsafe.Pointer(C.NSData_inst_CompressedDataUsingAlgorithmError(o.Ptr(), (C.NSDataCompressionAlgorithm)(algorithm), (*unsafe.Pointer)(unsafe.Pointer(&goSlice2[0]))))
	(*error) = (*error)[:cap(*error)]
	for i := 0; i < len(*error); i++ {
		if goSlice2[i] == nil {
			(*error) = (*error)[:i]
			break
		}
		if (*error)[i] == nil {
			(*error)[i] = &NSError{}
			runtime.SetFinalizer((*error)[i], func(o *NSError) {
				o.Release()
			})
		}
		(*error)[i].ptr = goSlice2[i]
	}
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSData)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *NSData) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *NSData) AddObserverForKeyPath(observer NSObject, keyPath *NSString, options NSKeyValueObservingOptions, context unsafe.Pointer)  {
	C.NSData_inst_AddObserverForKeyPath(o.Ptr(), observer.Ptr(), keyPath.Ptr(), (C.NSKeyValueObservingOptions)(options), unsafe.Pointer(context))
	runtime.KeepAlive(o)
}

func (o *NSData) AddObserverForKeyPathOptions(observer NSObject, keyPath *NSString, options NSKeyValueObservingOptions, context unsafe.Pointer)  {
	C.NSData_inst_AddObserverForKeyPathOptions(o.Ptr(), observer.Ptr(), keyPath.Ptr(), (C.NSKeyValueObservingOptions)(options), unsafe.Pointer(context))
	runtime.KeepAlive(o)
}

func (o *NSData) MutableOrderedSetValueForKeyPath(keyPath *NSString) *NSMutableOrderedSet {
	ret := &NSMutableOrderedSet{}
	ret.ptr = unsafe.Pointer(C.NSData_inst_MutableOrderedSetValueForKeyPath(o.Ptr(), keyPath.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSMutableOrderedSet)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *NSMutableOrderedSet) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *NSData) ForwardInvocation(anInvocation *NSInvocation)  {
	C.NSData_inst_ForwardInvocation(o.Ptr(), anInvocation.Ptr())
	runtime.KeepAlive(o)
}

func (o *NSData) IsLessThan(object NSObject) bool {
	ret := (bool)(C.NSData_inst_IsLessThan(o.Ptr(), object.Ptr()))
	runtime.KeepAlive(o)
	return ret
}

func (o *NSData) IsGreaterThanOrEqualTo(object NSObject) bool {
	ret := (bool)(C.NSData_inst_IsGreaterThanOrEqualTo(o.Ptr(), object.Ptr()))
	runtime.KeepAlive(o)
	return ret
}

func (o *NSData) IsNotEqualTo(object NSObject) bool {
	ret := (bool)(C.NSData_inst_IsNotEqualTo(o.Ptr(), object.Ptr()))
	runtime.KeepAlive(o)
	return ret
}

func (o *NSData) ScriptingContains(object NSObject) bool {
	ret := (bool)(C.NSData_inst_ScriptingContains(o.Ptr(), object.Ptr()))
	runtime.KeepAlive(o)
	return ret
}

func (o *NSData) DebugDescription() *NSString {
	ret := &NSString{}
	ret.ptr = unsafe.Pointer(C.NSData_inst_DebugDescription(o.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSString)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *NSString) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *NSData) ValueForKeyPath(keyPath *NSString) *Id {
	ret := &Id{}
	ret.ptr = unsafe.Pointer(C.NSData_inst_ValueForKeyPath(o.Ptr(), keyPath.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *Id) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *NSData) Self() *NSData {
	ret := &NSData{}
	ret.ptr = unsafe.Pointer(C.NSData_inst_Self(o.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSData)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *NSData) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *NSData) RemoveValueAtIndexFromPropertyWithKey(index NSUInteger, key *NSString)  {
	C.NSData_inst_RemoveValueAtIndexFromPropertyWithKey(o.Ptr(), (C.NSUInteger)(index), key.Ptr())
	runtime.KeepAlive(o)
}

func (o *NSData) Dealloc()  {
	C.NSData_inst_Dealloc(o.Ptr())
	runtime.KeepAlive(o)
}

func (o *NSData) SetObservationInfo(observationInfo unsafe.Pointer)  {
	C.NSData_inst_SetObservationInfo(o.Ptr(), unsafe.Pointer(observationInfo))
	runtime.KeepAlive(o)
}

func (o *NSData) IsEqualTo(object NSObject) bool {
	ret := (bool)(C.NSData_inst_IsEqualTo(o.Ptr(), object.Ptr()))
	runtime.KeepAlive(o)
	return ret
}

func (o *NSData) PerformSelectorInBackgroundWithObject(aSelector SEL, arg NSObject)  {
	C.NSData_inst_PerformSelectorInBackgroundWithObject(o.Ptr(), unsafe.Pointer(aSelector), arg.Ptr())
	runtime.KeepAlive(o)
}

func (o *NSData) Bytes() unsafe.Pointer {
	ret := (unsafe.Pointer)(unsafe.Pointer(C.NSData_inst_Bytes(o.Ptr())))
	runtime.KeepAlive(o)
	return ret
}

func (o *NSData) Retain() *NSData {
	ret := &NSData{}
	ret.ptr = unsafe.Pointer(C.NSData_inst_Retain(o.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSData)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *NSData) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *NSData) NewScriptingObjectOfClassForValueForKey(objectClass Class, key *NSString, contentsValue NSObject, properties *NSDictionary) *Id {
	ret := &Id{}
	ret.ptr = unsafe.Pointer(C.NSData_inst_NewScriptingObjectOfClassForValueForKey(o.Ptr(), unsafe.Pointer(objectClass), key.Ptr(), contentsValue.Ptr(), properties.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *Id) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *NSData) NewScriptingObjectOfClassForValueForKeyWithContentsValue(objectClass Class, key *NSString, contentsValue NSObject, properties *NSDictionary) *Id {
	ret := &Id{}
	ret.ptr = unsafe.Pointer(C.NSData_inst_NewScriptingObjectOfClassForValueForKeyWithContentsValue(o.Ptr(), unsafe.Pointer(objectClass), key.Ptr(), contentsValue.Ptr(), properties.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *Id) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *NSData) ClassCode() FourCharCode {
	ret := (FourCharCode)(C.NSData_inst_ClassCode(o.Ptr()))
	runtime.KeepAlive(o)
	return ret
}

func (o *NSData) IsEqual(object NSObject) bool {
	ret := (bool)(C.NSData_inst_IsEqual(o.Ptr(), object.Ptr()))
	runtime.KeepAlive(o)
	return ret
}

func (o *NSData) ValueForUndefinedKey(key *NSString) *Id {
	ret := &Id{}
	ret.ptr = unsafe.Pointer(C.NSData_inst_ValueForUndefinedKey(o.Ptr(), key.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *Id) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *NSData) ClassForKeyedArchiver() Class {
	ret := (Class)(unsafe.Pointer(C.NSData_inst_ClassForKeyedArchiver(o.Ptr())))
	runtime.KeepAlive(o)
	return ret
}

func (o *NSData) CopyScriptingValueForKey(value NSObject, key *NSString, properties *NSDictionary) *Id {
	ret := &Id{}
	ret.ptr = unsafe.Pointer(C.NSData_inst_CopyScriptingValueForKey(o.Ptr(), value.Ptr(), key.Ptr(), properties.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *Id) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *NSData) CopyScriptingValueForKeyWithProperties(value NSObject, key *NSString, properties *NSDictionary) *Id {
	ret := &Id{}
	ret.ptr = unsafe.Pointer(C.NSData_inst_CopyScriptingValueForKeyWithProperties(o.Ptr(), value.Ptr(), key.Ptr(), properties.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *Id) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *NSData) ValueAtIndexInPropertyWithKey(index NSUInteger, key *NSString) *Id {
	ret := &Id{}
	ret.ptr = unsafe.Pointer(C.NSData_inst_ValueAtIndexInPropertyWithKey(o.Ptr(), (C.NSUInteger)(index), key.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *Id) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *NSData) DidChangeValuesAtIndexes(changeKind NSKeyValueChange, indexes *NSIndexSet, key *NSString)  {
	C.NSData_inst_DidChangeValuesAtIndexes(o.Ptr(), (C.NSKeyValueChange)(changeKind), indexes.Ptr(), key.Ptr())
	runtime.KeepAlive(o)
}

func (o *NSData) DidChangeValuesAtIndexesForKey(changeKind NSKeyValueChange, indexes *NSIndexSet, key *NSString)  {
	C.NSData_inst_DidChangeValuesAtIndexesForKey(o.Ptr(), (C.NSKeyValueChange)(changeKind), indexes.Ptr(), key.Ptr())
	runtime.KeepAlive(o)
}

func (o *NSData) DidChangeValueForKey(key *NSString)  {
	C.NSData_inst_DidChangeValueForKey(o.Ptr(), key.Ptr())
	runtime.KeepAlive(o)
}

func (o *NSData) DidChangeValueForKeyWithSetMutation(key *NSString, mutationKind NSKeyValueSetMutationKind, objects *NSSet)  {
	C.NSData_inst_DidChangeValueForKeyWithSetMutation(o.Ptr(), key.Ptr(), (C.NSKeyValueSetMutationKind)(mutationKind), objects.Ptr())
	runtime.KeepAlive(o)
}

func (o *NSData) DidChangeValueForKeyWithSetMutationUsingObjects(key *NSString, mutationKind NSKeyValueSetMutationKind, objects *NSSet)  {
	C.NSData_inst_DidChangeValueForKeyWithSetMutationUsingObjects(o.Ptr(), key.Ptr(), (C.NSKeyValueSetMutationKind)(mutationKind), objects.Ptr())
	runtime.KeepAlive(o)
}

func (o *NSData) ReplacementObjectForCoder(coder *NSCoder) *Id {
	ret := &Id{}
	ret.ptr = unsafe.Pointer(C.NSData_inst_ReplacementObjectForCoder(o.Ptr(), coder.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *Id) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *NSData) AttemptRecoveryFromErrorOptionIndex(error *NSError, recoveryOptionIndex NSUInteger) bool {
	ret := (bool)(C.NSData_inst_AttemptRecoveryFromErrorOptionIndex(o.Ptr(), error.Ptr(), (C.NSUInteger)(recoveryOptionIndex)))
	runtime.KeepAlive(o)
	return ret
}

func (o *NSData) AttemptRecoveryFromErrorOptionIndexDelegate(error *NSError, recoveryOptionIndex NSUInteger, delegate NSObject, didRecoverSelector SEL, contextInfo unsafe.Pointer)  {
	C.NSData_inst_AttemptRecoveryFromErrorOptionIndexDelegate(o.Ptr(), error.Ptr(), (C.NSUInteger)(recoveryOptionIndex), delegate.Ptr(), unsafe.Pointer(didRecoverSelector), unsafe.Pointer(contextInfo))
	runtime.KeepAlive(o)
}

func (o *NSData) AttemptRecoveryFromErrorOptionIndexDelegateDidRecoverSelector(error *NSError, recoveryOptionIndex NSUInteger, delegate NSObject, didRecoverSelector SEL, contextInfo unsafe.Pointer)  {
	C.NSData_inst_AttemptRecoveryFromErrorOptionIndexDelegateDidRecoverSelector(o.Ptr(), error.Ptr(), (C.NSUInteger)(recoveryOptionIndex), delegate.Ptr(), unsafe.Pointer(didRecoverSelector), unsafe.Pointer(contextInfo))
	runtime.KeepAlive(o)
}

func (o *NSData) ToOneRelationshipKeys() *NSArray {
	ret := &NSArray{}
	ret.ptr = unsafe.Pointer(C.NSData_inst_ToOneRelationshipKeys(o.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSArray)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *NSArray) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *NSData) CopyWithZone(zone *NSZone) *Id {
	ret := &Id{}
	ret.ptr = unsafe.Pointer(C.NSData_inst_CopyWithZone(o.Ptr(), unsafe.Pointer(zone)))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *Id) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *NSData) IsEqualToData(other *NSData) bool {
	ret := (bool)(C.NSData_inst_IsEqualToData(o.Ptr(), other.Ptr()))
	runtime.KeepAlive(o)
	return ret
}

func (o *NSData) ValueForKey(key *NSString) *Id {
	ret := &Id{}
	ret.ptr = unsafe.Pointer(C.NSData_inst_ValueForKey(o.Ptr(), key.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *Id) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *NSData) Copy() *Id {
	ret := &Id{}
	ret.ptr = unsafe.Pointer(C.NSData_inst_Copy(o.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	runtime.SetFinalizer(ret, func(o *Id) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *NSData) ToManyRelationshipKeys() *NSArray {
	ret := &NSArray{}
	ret.ptr = unsafe.Pointer(C.NSData_inst_ToManyRelationshipKeys(o.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSArray)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *NSArray) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *NSData) IsLike(object *NSString) bool {
	ret := (bool)(C.NSData_inst_IsLike(o.Ptr(), object.Ptr()))
	runtime.KeepAlive(o)
	return ret
}

func (o *NSData) AutoContentAccessingProxy() *Id {
	ret := &Id{}
	ret.ptr = unsafe.Pointer(C.NSData_inst_AutoContentAccessingProxy(o.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *Id) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *NSData) SetValueForKey(value NSObject, key *NSString)  {
	C.NSData_inst_SetValueForKey(o.Ptr(), value.Ptr(), key.Ptr())
	runtime.KeepAlive(o)
}

func (o *NSData) SetValueForKeyPath(value NSObject, keyPath *NSString)  {
	C.NSData_inst_SetValueForKeyPath(o.Ptr(), value.Ptr(), keyPath.Ptr())
	runtime.KeepAlive(o)
}

func (o *NSData) SetValueForUndefinedKey(value NSObject, key *NSString)  {
	C.NSData_inst_SetValueForUndefinedKey(o.Ptr(), value.Ptr(), key.Ptr())
	runtime.KeepAlive(o)
}

func (o *NSData) ReplaceValueAtIndexInPropertyWithKey(index NSUInteger, key *NSString, value NSObject)  {
	C.NSData_inst_ReplaceValueAtIndexInPropertyWithKey(o.Ptr(), (C.NSUInteger)(index), key.Ptr(), value.Ptr())
	runtime.KeepAlive(o)
}

func (o *NSData) ReplaceValueAtIndexInPropertyWithKeyWithValue(index NSUInteger, key *NSString, value NSObject)  {
	C.NSData_inst_ReplaceValueAtIndexInPropertyWithKeyWithValue(o.Ptr(), (C.NSUInteger)(index), key.Ptr(), value.Ptr())
	runtime.KeepAlive(o)
}

func (o *NSData) WillChangeValueForKey(key *NSString)  {
	C.NSData_inst_WillChangeValueForKey(o.Ptr(), key.Ptr())
	runtime.KeepAlive(o)
}

func (o *NSData) WillChangeValueForKeyWithSetMutation(key *NSString, mutationKind NSKeyValueSetMutationKind, objects *NSSet)  {
	C.NSData_inst_WillChangeValueForKeyWithSetMutation(o.Ptr(), key.Ptr(), (C.NSKeyValueSetMutationKind)(mutationKind), objects.Ptr())
	runtime.KeepAlive(o)
}

func (o *NSData) WillChangeValueForKeyWithSetMutationUsingObjects(key *NSString, mutationKind NSKeyValueSetMutationKind, objects *NSSet)  {
	C.NSData_inst_WillChangeValueForKeyWithSetMutationUsingObjects(o.Ptr(), key.Ptr(), (C.NSKeyValueSetMutationKind)(mutationKind), objects.Ptr())
	runtime.KeepAlive(o)
}

func (o *NSData) ScriptingProperties() *NSDictionary {
	ret := &NSDictionary{}
	ret.ptr = unsafe.Pointer(C.NSData_inst_ScriptingProperties(o.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSDictionary)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *NSDictionary) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *NSData) WriteToURLAtomically(url *NSURL, atomically BOOL) bool {
	ret := (bool)(C.NSData_inst_WriteToURLAtomically(o.Ptr(), url.Ptr(), (C.BOOL)(atomically)))
	runtime.KeepAlive(o)
	return ret
}

func (o *NSData) WriteToURLOptions(url *NSURL, writeOptionsMask NSDataWritingOptions, errorPtr *[]*NSError) bool {

	goSlice3 := make([]unsafe.Pointer,cap(*errorPtr))
	for i := 0; i < len(*errorPtr); i++ {
		goSlice3[i] = (*errorPtr)[i].Ptr()
	}
	ret := (bool)(C.NSData_inst_WriteToURLOptions(o.Ptr(), url.Ptr(), (C.NSDataWritingOptions)(writeOptionsMask), (*unsafe.Pointer)(unsafe.Pointer(&goSlice3[0]))))
	(*errorPtr) = (*errorPtr)[:cap(*errorPtr)]
	for i := 0; i < len(*errorPtr); i++ {
		if goSlice3[i] == nil {
			(*errorPtr) = (*errorPtr)[:i]
			break
		}
		if (*errorPtr)[i] == nil {
			(*errorPtr)[i] = &NSError{}
			runtime.SetFinalizer((*errorPtr)[i], func(o *NSError) {
				o.Release()
			})
		}
		(*errorPtr)[i].ptr = goSlice3[i]
	}
	runtime.KeepAlive(o)
	return ret
}

func (o *NSData) WriteToURLOptionsError(url *NSURL, writeOptionsMask NSDataWritingOptions, errorPtr *[]*NSError) bool {

	goSlice3 := make([]unsafe.Pointer,cap(*errorPtr))
	for i := 0; i < len(*errorPtr); i++ {
		goSlice3[i] = (*errorPtr)[i].Ptr()
	}
	ret := (bool)(C.NSData_inst_WriteToURLOptionsError(o.Ptr(), url.Ptr(), (C.NSDataWritingOptions)(writeOptionsMask), (*unsafe.Pointer)(unsafe.Pointer(&goSlice3[0]))))
	(*errorPtr) = (*errorPtr)[:cap(*errorPtr)]
	for i := 0; i < len(*errorPtr); i++ {
		if goSlice3[i] == nil {
			(*errorPtr) = (*errorPtr)[:i]
			break
		}
		if (*errorPtr)[i] == nil {
			(*errorPtr)[i] = &NSError{}
			runtime.SetFinalizer((*errorPtr)[i], func(o *NSError) {
				o.Release()
			})
		}
		(*errorPtr)[i].ptr = goSlice3[i]
	}
	runtime.KeepAlive(o)
	return ret
}

func (o *NSData) ObservationInfo() unsafe.Pointer {
	ret := (unsafe.Pointer)(unsafe.Pointer(C.NSData_inst_ObservationInfo(o.Ptr())))
	runtime.KeepAlive(o)
	return ret
}

func (o *NSData) Autorelease() *NSData {
	ret := &NSData{}
	ret.ptr = unsafe.Pointer(C.NSData_inst_Autorelease(o.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSData)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *NSData) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *NSData) IsLessThanOrEqualTo(object NSObject) bool {
	ret := (bool)(C.NSData_inst_IsLessThanOrEqualTo(o.Ptr(), object.Ptr()))
	runtime.KeepAlive(o)
	return ret
}

func (o *NSData) PerformSelectorOnMainThreadWithObject(aSelector SEL, arg NSObject, wait BOOL)  {
	C.NSData_inst_PerformSelectorOnMainThreadWithObject(o.Ptr(), unsafe.Pointer(aSelector), arg.Ptr(), (C.BOOL)(wait))
	runtime.KeepAlive(o)
}

func (o *NSData) PerformSelectorOnMainThreadWithObjectWaitUntilDone(aSelector SEL, arg NSObject, wait BOOL)  {
	C.NSData_inst_PerformSelectorOnMainThreadWithObjectWaitUntilDone(o.Ptr(), unsafe.Pointer(aSelector), arg.Ptr(), (C.BOOL)(wait))
	runtime.KeepAlive(o)
}

func (o *NSData) PerformSelectorOnMainThreadWithObjectWaitUntilDoneModes(aSelector SEL, arg NSObject, wait BOOL, array *NSArray)  {
	C.NSData_inst_PerformSelectorOnMainThreadWithObjectWaitUntilDoneModes(o.Ptr(), unsafe.Pointer(aSelector), arg.Ptr(), (C.BOOL)(wait), array.Ptr())
	runtime.KeepAlive(o)
}

func (o *NSData) Base64EncodedStringWithOptions(options NSDataBase64EncodingOptions) *NSString {
	ret := &NSString{}
	ret.ptr = unsafe.Pointer(C.NSData_inst_Base64EncodedStringWithOptions(o.Ptr(), (C.NSDataBase64EncodingOptions)(options)))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSString)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *NSString) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *NSData) ScriptingIsLessThanOrEqualTo(object NSObject) bool {
	ret := (bool)(C.NSData_inst_ScriptingIsLessThanOrEqualTo(o.Ptr(), object.Ptr()))
	runtime.KeepAlive(o)
	return ret
}

func (o *NSData) GetClass() Class {
	ret := (Class)(unsafe.Pointer(C.NSData_inst_Class(o.Ptr())))
	runtime.KeepAlive(o)
	return ret
}

func (o *NSData) RemoveObserverForKeyPath(observer NSObject, keyPath *NSString)  {
	C.NSData_inst_RemoveObserverForKeyPath(o.Ptr(), observer.Ptr(), keyPath.Ptr())
	runtime.KeepAlive(o)
}

func (o *NSData) RemoveObserverForKeyPathContext(observer NSObject, keyPath *NSString, context unsafe.Pointer)  {
	C.NSData_inst_RemoveObserverForKeyPathContext(o.Ptr(), observer.Ptr(), keyPath.Ptr(), unsafe.Pointer(context))
	runtime.KeepAlive(o)
}

func (o *NSData) RangeOfDataOptions(dataToFind *NSData, mask NSDataSearchOptions, searchRange NSRange) NSRange {
	ret := (NSRange)(C.NSData_inst_RangeOfDataOptions(o.Ptr(), dataToFind.Ptr(), (C.NSDataSearchOptions)(mask), (C.NSRange)(searchRange)))
	runtime.KeepAlive(o)
	return ret
}

func (o *NSData) RangeOfDataOptionsRange(dataToFind *NSData, mask NSDataSearchOptions, searchRange NSRange) NSRange {
	ret := (NSRange)(C.NSData_inst_RangeOfDataOptionsRange(o.Ptr(), dataToFind.Ptr(), (C.NSDataSearchOptions)(mask), (C.NSRange)(searchRange)))
	runtime.KeepAlive(o)
	return ret
}

func (o *NSData) Length() NSUInteger {
	ret := (NSUInteger)(C.NSData_inst_Length(o.Ptr()))
	runtime.KeepAlive(o)
	return ret
}

func (o *NSData) ClassForArchiver() Class {
	ret := (Class)(unsafe.Pointer(C.NSData_inst_ClassForArchiver(o.Ptr())))
	runtime.KeepAlive(o)
	return ret
}

func CBCentralInstancesRespondToSelector(aSelector SEL) bool {
	ret := (bool)(C.CBCentral_InstancesRespondToSelector(unsafe.Pointer(aSelector)))
	return ret
}

func CBCentralResolveClassMethod(sel SEL) bool {
	ret := (bool)(C.CBCentral_ResolveClassMethod(unsafe.Pointer(sel)))
	return ret
}

func CBCentralCopyWithZone(zone *_NSZone) *Id {
	ret := &Id{}
	ret.ptr = unsafe.Pointer(C.CBCentral_CopyWithZone(unsafe.Pointer(zone)))
	if ret.ptr == nil { return ret }
	runtime.SetFinalizer(ret, func(o *Id) {
		o.Release()
	})
	return ret
}

func CBCentralMutableCopyWithZone(zone *_NSZone) *Id {
	ret := &Id{}
	ret.ptr = unsafe.Pointer(C.CBCentral_MutableCopyWithZone(unsafe.Pointer(zone)))
	if ret.ptr == nil { return ret }
	runtime.SetFinalizer(ret, func(o *Id) {
		o.Release()
	})
	return ret
}

func CBCentralClassForKeyedUnarchiver() Class {
	ret := (Class)(unsafe.Pointer(C.CBCentral_ClassForKeyedUnarchiver()))
	return ret
}

func CBCentralAutomaticallyNotifiesObserversForKey(key *NSString) bool {
	ret := (bool)(C.CBCentral_AutomaticallyNotifiesObserversForKey(key.Ptr()))
	return ret
}

func CBCentralHash() NSUInteger {
	ret := (NSUInteger)(C.CBCentral_Hash())
	return ret
}

func CBCentralCancelPreviousPerformRequestsWithTarget(aTarget NSObject)  {
	C.CBCentral_CancelPreviousPerformRequestsWithTarget(aTarget.Ptr())
}

func CBCentralCancelPreviousPerformRequestsWithTargetSelector(aTarget NSObject, aSelector SEL, anArgument NSObject)  {
	C.CBCentral_CancelPreviousPerformRequestsWithTargetSelector(aTarget.Ptr(), unsafe.Pointer(aSelector), anArgument.Ptr())
}

func CBCentralCancelPreviousPerformRequestsWithTargetSelectorObject(aTarget NSObject, aSelector SEL, anArgument NSObject)  {
	C.CBCentral_CancelPreviousPerformRequestsWithTargetSelectorObject(aTarget.Ptr(), unsafe.Pointer(aSelector), anArgument.Ptr())
}

func CBCentralConformsToProtocol(protocol Protocol) bool {
	ret := (bool)(C.CBCentral_ConformsToProtocol(protocol.Ptr()))
	return ret
}

func CBCentralDebugDescription() *NSString {
	ret := &NSString{}
	ret.ptr = unsafe.Pointer(C.CBCentral_DebugDescription())
	if ret.ptr == nil { return ret }
	return ret
}

func CBCentralVersion() NSInteger {
	ret := (NSInteger)(C.CBCentral_Version())
	return ret
}

func CBCentralDescription() *NSString {
	ret := &NSString{}
	ret.ptr = unsafe.Pointer(C.CBCentral_Description())
	if ret.ptr == nil { return ret }
	return ret
}

func CBCentralClassFallbacksForKeyedArchiver() *NSArray {
	ret := &NSArray{}
	ret.ptr = unsafe.Pointer(C.CBCentral_ClassFallbacksForKeyedArchiver())
	if ret.ptr == nil { return ret }
	return ret
}

func CBCentralAllocWithZone(zone *_NSZone) *CBCentral {
	ret := &CBCentral{}
	ret.ptr = unsafe.Pointer(C.CBCentral_AllocWithZone(unsafe.Pointer(zone)))
	if ret.ptr == nil { return ret }
	runtime.SetFinalizer(ret, func(o *CBCentral) {
		o.Release()
	})
	return ret
}

func CBCentralKeyPathsForValuesAffectingValueForKey(key *NSString) *NSSet {
	ret := &NSSet{}
	ret.ptr = unsafe.Pointer(C.CBCentral_KeyPathsForValuesAffectingValueForKey(key.Ptr()))
	if ret.ptr == nil { return ret }
	return ret
}

func CBCentralNew() *CBCentral {
	ret := &CBCentral{}
	ret.ptr = unsafe.Pointer(C.CBCentral_New())
	if ret.ptr == nil { return ret }
	runtime.SetFinalizer(ret, func(o *CBCentral) {
		o.Release()
	})
	return ret
}

func CBCentralAccessInstanceVariablesDirectly() bool {
	ret := (bool)(C.CBCentral_AccessInstanceVariablesDirectly())
	return ret
}

func CBCentralSetVersion(aVersion NSInteger)  {
	C.CBCentral_SetVersion((C.NSInteger)(aVersion))
}

func CBCentralInstanceMethodSignatureForSelector(aSelector SEL) *NSMethodSignature {
	ret := &NSMethodSignature{}
	ret.ptr = unsafe.Pointer(C.CBCentral_InstanceMethodSignatureForSelector(unsafe.Pointer(aSelector)))
	if ret.ptr == nil { return ret }
	return ret
}

func CBCentralClass() Class {
	ret := (Class)(unsafe.Pointer(C.CBCentral_Class()))
	return ret
}

func CBCentralLoad()  {
	C.CBCentral_Load()
}

func CBCentralResolveInstanceMethod(sel SEL) bool {
	ret := (bool)(C.CBCentral_ResolveInstanceMethod(unsafe.Pointer(sel)))
	return ret
}

func CBCentralIsSubclassOfClass(aClass Class) bool {
	ret := (bool)(C.CBCentral_IsSubclassOfClass(unsafe.Pointer(aClass)))
	return ret
}

func CBCentralSuperclass() Class {
	ret := (Class)(unsafe.Pointer(C.CBCentral_Superclass()))
	return ret
}

func CBCentralAlloc() *CBCentral {
	ret := &CBCentral{}
	ret.ptr = unsafe.Pointer(C.CBCentral_Alloc())
	if ret.ptr == nil { return ret }
	runtime.SetFinalizer(ret, func(o *CBCentral) {
		o.Release()
	})
	return ret
}

func (o *CBCentral) GC() {
	if o.ptr == nil { return }
	runtime.SetFinalizer(o, func(o *CBCentral) {
		o.Release()
	})
	runtime.KeepAlive(o)
}

func (o *CBCentral) WillChangeValueForKey(key *NSString)  {
	C.CBCentral_inst_WillChangeValueForKey(o.Ptr(), key.Ptr())
	runtime.KeepAlive(o)
}

func (o *CBCentral) WillChangeValueForKeyWithSetMutation(key *NSString, mutationKind NSKeyValueSetMutationKind, objects *NSSet)  {
	C.CBCentral_inst_WillChangeValueForKeyWithSetMutation(o.Ptr(), key.Ptr(), (C.NSKeyValueSetMutationKind)(mutationKind), objects.Ptr())
	runtime.KeepAlive(o)
}

func (o *CBCentral) WillChangeValueForKeyWithSetMutationUsingObjects(key *NSString, mutationKind NSKeyValueSetMutationKind, objects *NSSet)  {
	C.CBCentral_inst_WillChangeValueForKeyWithSetMutationUsingObjects(o.Ptr(), key.Ptr(), (C.NSKeyValueSetMutationKind)(mutationKind), objects.Ptr())
	runtime.KeepAlive(o)
}

func (o *CBCentral) AttributeKeys() *NSArray {
	ret := &NSArray{}
	ret.ptr = unsafe.Pointer(C.CBCentral_inst_AttributeKeys(o.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSArray)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *NSArray) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *CBCentral) RespondsToSelector(aSelector SEL) bool {
	ret := (bool)(C.CBCentral_inst_RespondsToSelector(o.Ptr(), unsafe.Pointer(aSelector)))
	runtime.KeepAlive(o)
	return ret
}

func (o *CBCentral) RetainCount() NSUInteger {
	ret := (NSUInteger)(C.CBCentral_inst_RetainCount(o.Ptr()))
	runtime.KeepAlive(o)
	return ret
}

func (o *CBCentral) ScriptingProperties() *NSDictionary {
	ret := &NSDictionary{}
	ret.ptr = unsafe.Pointer(C.CBCentral_inst_ScriptingProperties(o.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSDictionary)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *NSDictionary) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *CBCentral) ClassName() *NSString {
	ret := &NSString{}
	ret.ptr = unsafe.Pointer(C.CBCentral_inst_ClassName(o.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSString)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *NSString) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *CBCentral) IsProxy() bool {
	ret := (bool)(C.CBCentral_inst_IsProxy(o.Ptr()))
	runtime.KeepAlive(o)
	return ret
}

func (o *CBCentral) MutableSetValueForKeyPath(keyPath *NSString) *NSMutableSet {
	ret := &NSMutableSet{}
	ret.ptr = unsafe.Pointer(C.CBCentral_inst_MutableSetValueForKeyPath(o.Ptr(), keyPath.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSMutableSet)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *NSMutableSet) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *CBCentral) IsNotEqualTo(object NSObject) bool {
	ret := (bool)(C.CBCentral_inst_IsNotEqualTo(o.Ptr(), object.Ptr()))
	runtime.KeepAlive(o)
	return ret
}

func (o *CBCentral) ClassForCoder() Class {
	ret := (Class)(unsafe.Pointer(C.CBCentral_inst_ClassForCoder(o.Ptr())))
	runtime.KeepAlive(o)
	return ret
}

func (o *CBCentral) ForwardingTargetForSelector(aSelector SEL) *Id {
	ret := &Id{}
	ret.ptr = unsafe.Pointer(C.CBCentral_inst_ForwardingTargetForSelector(o.Ptr(), unsafe.Pointer(aSelector)))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *Id) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *CBCentral) ScriptingEndsWith(object NSObject) bool {
	ret := (bool)(C.CBCentral_inst_ScriptingEndsWith(o.Ptr(), object.Ptr()))
	runtime.KeepAlive(o)
	return ret
}

func (o *CBCentral) ValueForKeyPath(keyPath *NSString) *Id {
	ret := &Id{}
	ret.ptr = unsafe.Pointer(C.CBCentral_inst_ValueForKeyPath(o.Ptr(), keyPath.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *Id) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *CBCentral) AttemptRecoveryFromErrorOptionIndex(error *NSError, recoveryOptionIndex NSUInteger) bool {
	ret := (bool)(C.CBCentral_inst_AttemptRecoveryFromErrorOptionIndex(o.Ptr(), error.Ptr(), (C.NSUInteger)(recoveryOptionIndex)))
	runtime.KeepAlive(o)
	return ret
}

func (o *CBCentral) AttemptRecoveryFromErrorOptionIndexDelegate(error *NSError, recoveryOptionIndex NSUInteger, delegate NSObject, didRecoverSelector SEL, contextInfo unsafe.Pointer)  {
	C.CBCentral_inst_AttemptRecoveryFromErrorOptionIndexDelegate(o.Ptr(), error.Ptr(), (C.NSUInteger)(recoveryOptionIndex), delegate.Ptr(), unsafe.Pointer(didRecoverSelector), unsafe.Pointer(contextInfo))
	runtime.KeepAlive(o)
}

func (o *CBCentral) AttemptRecoveryFromErrorOptionIndexDelegateDidRecoverSelector(error *NSError, recoveryOptionIndex NSUInteger, delegate NSObject, didRecoverSelector SEL, contextInfo unsafe.Pointer)  {
	C.CBCentral_inst_AttemptRecoveryFromErrorOptionIndexDelegateDidRecoverSelector(o.Ptr(), error.Ptr(), (C.NSUInteger)(recoveryOptionIndex), delegate.Ptr(), unsafe.Pointer(didRecoverSelector), unsafe.Pointer(contextInfo))
	runtime.KeepAlive(o)
}

func (o *CBCentral) ToOneRelationshipKeys() *NSArray {
	ret := &NSArray{}
	ret.ptr = unsafe.Pointer(C.CBCentral_inst_ToOneRelationshipKeys(o.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSArray)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *NSArray) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *CBCentral) PerformSelector(aSelector SEL) *Id {
	ret := &Id{}
	ret.ptr = unsafe.Pointer(C.CBCentral_inst_PerformSelector(o.Ptr(), unsafe.Pointer(aSelector)))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *Id) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *CBCentral) PerformSelectorWithObject(aSelector SEL, object NSObject) *Id {
	ret := &Id{}
	ret.ptr = unsafe.Pointer(C.CBCentral_inst_PerformSelectorWithObject(o.Ptr(), unsafe.Pointer(aSelector), object.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *Id) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *CBCentral) PerformSelectorWithObjectWithObject(aSelector SEL, object1 NSObject, object2 NSObject) *Id {
	ret := &Id{}
	ret.ptr = unsafe.Pointer(C.CBCentral_inst_PerformSelectorWithObjectWithObject(o.Ptr(), unsafe.Pointer(aSelector), object1.Ptr(), object2.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *Id) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *CBCentral) PerformSelectorWithObjectAfterDelay(aSelector SEL, anArgument NSObject, delay NSTimeInterval)  {
	C.CBCentral_inst_PerformSelectorWithObjectAfterDelay(o.Ptr(), unsafe.Pointer(aSelector), anArgument.Ptr(), (C.NSTimeInterval)(delay))
	runtime.KeepAlive(o)
}

func (o *CBCentral) PerformSelectorOnThread(aSelector SEL, thr *NSThread, arg NSObject, wait BOOL)  {
	C.CBCentral_inst_PerformSelectorOnThread(o.Ptr(), unsafe.Pointer(aSelector), thr.Ptr(), arg.Ptr(), (C.BOOL)(wait))
	runtime.KeepAlive(o)
}

func (o *CBCentral) PerformSelectorWithObjectAfterDelayInModes(aSelector SEL, anArgument NSObject, delay NSTimeInterval, modes *NSArray)  {
	C.CBCentral_inst_PerformSelectorWithObjectAfterDelayInModes(o.Ptr(), unsafe.Pointer(aSelector), anArgument.Ptr(), (C.NSTimeInterval)(delay), modes.Ptr())
	runtime.KeepAlive(o)
}

func (o *CBCentral) PerformSelectorOnThreadWithObject(aSelector SEL, thr *NSThread, arg NSObject, wait BOOL)  {
	C.CBCentral_inst_PerformSelectorOnThreadWithObject(o.Ptr(), unsafe.Pointer(aSelector), thr.Ptr(), arg.Ptr(), (C.BOOL)(wait))
	runtime.KeepAlive(o)
}

func (o *CBCentral) PerformSelectorOnThreadWithObjectWaitUntilDone(aSelector SEL, thr *NSThread, arg NSObject, wait BOOL, array *NSArray)  {
	C.CBCentral_inst_PerformSelectorOnThreadWithObjectWaitUntilDone(o.Ptr(), unsafe.Pointer(aSelector), thr.Ptr(), arg.Ptr(), (C.BOOL)(wait), array.Ptr())
	runtime.KeepAlive(o)
}

func (o *CBCentral) PerformSelectorOnThreadWithObjectWaitUntilDoneModes(aSelector SEL, thr *NSThread, arg NSObject, wait BOOL, array *NSArray)  {
	C.CBCentral_inst_PerformSelectorOnThreadWithObjectWaitUntilDoneModes(o.Ptr(), unsafe.Pointer(aSelector), thr.Ptr(), arg.Ptr(), (C.BOOL)(wait), array.Ptr())
	runtime.KeepAlive(o)
}

func (o *CBCentral) IsGreaterThan(object NSObject) bool {
	ret := (bool)(C.CBCentral_inst_IsGreaterThan(o.Ptr(), object.Ptr()))
	runtime.KeepAlive(o)
	return ret
}

func (o *CBCentral) IndicesOfObjectsByEvaluatingObjectSpecifier(specifier *NSScriptObjectSpecifier) *NSArray {
	ret := &NSArray{}
	ret.ptr = unsafe.Pointer(C.CBCentral_inst_IndicesOfObjectsByEvaluatingObjectSpecifier(o.Ptr(), specifier.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSArray)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *NSArray) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *CBCentral) Dealloc()  {
	C.CBCentral_inst_Dealloc(o.Ptr())
	runtime.KeepAlive(o)
}

func (o *CBCentral) WillChangeValuesAtIndexes(changeKind NSKeyValueChange, indexes *NSIndexSet, key *NSString)  {
	C.CBCentral_inst_WillChangeValuesAtIndexes(o.Ptr(), (C.NSKeyValueChange)(changeKind), indexes.Ptr(), key.Ptr())
	runtime.KeepAlive(o)
}

func (o *CBCentral) WillChangeValuesAtIndexesForKey(changeKind NSKeyValueChange, indexes *NSIndexSet, key *NSString)  {
	C.CBCentral_inst_WillChangeValuesAtIndexesForKey(o.Ptr(), (C.NSKeyValueChange)(changeKind), indexes.Ptr(), key.Ptr())
	runtime.KeepAlive(o)
}

func (o *CBCentral) ToManyRelationshipKeys() *NSArray {
	ret := &NSArray{}
	ret.ptr = unsafe.Pointer(C.CBCentral_inst_ToManyRelationshipKeys(o.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSArray)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *NSArray) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *CBCentral) Autorelease() *CBCentral {
	ret := &CBCentral{}
	ret.ptr = unsafe.Pointer(C.CBCentral_inst_Autorelease(o.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*CBCentral)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *CBCentral) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *CBCentral) ObservationInfo() unsafe.Pointer {
	ret := (unsafe.Pointer)(unsafe.Pointer(C.CBCentral_inst_ObservationInfo(o.Ptr())))
	runtime.KeepAlive(o)
	return ret
}

func (o *CBCentral) IsLessThan(object NSObject) bool {
	ret := (bool)(C.CBCentral_inst_IsLessThan(o.Ptr(), object.Ptr()))
	runtime.KeepAlive(o)
	return ret
}

func (o *CBCentral) Retain() *CBCentral {
	ret := &CBCentral{}
	ret.ptr = unsafe.Pointer(C.CBCentral_inst_Retain(o.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*CBCentral)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *CBCentral) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *CBCentral) Copy() *Id {
	ret := &Id{}
	ret.ptr = unsafe.Pointer(C.CBCentral_inst_Copy(o.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	runtime.SetFinalizer(ret, func(o *Id) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *CBCentral) Self() *CBCentral {
	ret := &CBCentral{}
	ret.ptr = unsafe.Pointer(C.CBCentral_inst_Self(o.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*CBCentral)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *CBCentral) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *CBCentral) MethodSignatureForSelector(aSelector SEL) *NSMethodSignature {
	ret := &NSMethodSignature{}
	ret.ptr = unsafe.Pointer(C.CBCentral_inst_MethodSignatureForSelector(o.Ptr(), unsafe.Pointer(aSelector)))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSMethodSignature)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *NSMethodSignature) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *CBCentral) RemoveValueAtIndexFromPropertyWithKey(index NSUInteger, key *NSString)  {
	C.CBCentral_inst_RemoveValueAtIndexFromPropertyWithKey(o.Ptr(), (C.NSUInteger)(index), key.Ptr())
	runtime.KeepAlive(o)
}

func (o *CBCentral) MutableArrayValueForKeyPath(keyPath *NSString) *NSMutableArray {
	ret := &NSMutableArray{}
	ret.ptr = unsafe.Pointer(C.CBCentral_inst_MutableArrayValueForKeyPath(o.Ptr(), keyPath.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSMutableArray)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *NSMutableArray) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *CBCentral) GetClass() Class {
	ret := (Class)(unsafe.Pointer(C.CBCentral_inst_Class(o.Ptr())))
	runtime.KeepAlive(o)
	return ret
}

func (o *CBCentral) ClassForArchiver() Class {
	ret := (Class)(unsafe.Pointer(C.CBCentral_inst_ClassForArchiver(o.Ptr())))
	runtime.KeepAlive(o)
	return ret
}

func (o *CBCentral) MutableOrderedSetValueForKeyPath(keyPath *NSString) *NSMutableOrderedSet {
	ret := &NSMutableOrderedSet{}
	ret.ptr = unsafe.Pointer(C.CBCentral_inst_MutableOrderedSetValueForKeyPath(o.Ptr(), keyPath.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSMutableOrderedSet)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *NSMutableOrderedSet) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *CBCentral) ScriptingIsEqualTo(object NSObject) bool {
	ret := (bool)(C.CBCentral_inst_ScriptingIsEqualTo(o.Ptr(), object.Ptr()))
	runtime.KeepAlive(o)
	return ret
}

func (o *CBCentral) Identifier() *NSUUID {
	ret := &NSUUID{}
	ret.ptr = unsafe.Pointer(C.CBCentral_inst_Identifier(o.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSUUID)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *NSUUID) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *CBCentral) ObjectSpecifier() *NSScriptObjectSpecifier {
	ret := &NSScriptObjectSpecifier{}
	ret.ptr = unsafe.Pointer(C.CBCentral_inst_ObjectSpecifier(o.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSScriptObjectSpecifier)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *NSScriptObjectSpecifier) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *CBCentral) ValueAtIndexInPropertyWithKey(index NSUInteger, key *NSString) *Id {
	ret := &Id{}
	ret.ptr = unsafe.Pointer(C.CBCentral_inst_ValueAtIndexInPropertyWithKey(o.Ptr(), (C.NSUInteger)(index), key.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *Id) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *CBCentral) IsEqualTo(object NSObject) bool {
	ret := (bool)(C.CBCentral_inst_IsEqualTo(o.Ptr(), object.Ptr()))
	runtime.KeepAlive(o)
	return ret
}

func (o *CBCentral) ValueForUndefinedKey(key *NSString) *Id {
	ret := &Id{}
	ret.ptr = unsafe.Pointer(C.CBCentral_inst_ValueForUndefinedKey(o.Ptr(), key.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *Id) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *CBCentral) ScriptingContains(object NSObject) bool {
	ret := (bool)(C.CBCentral_inst_ScriptingContains(o.Ptr(), object.Ptr()))
	runtime.KeepAlive(o)
	return ret
}

func (o *CBCentral) IsMemberOfClass(aClass Class) bool {
	ret := (bool)(C.CBCentral_inst_IsMemberOfClass(o.Ptr(), unsafe.Pointer(aClass)))
	runtime.KeepAlive(o)
	return ret
}

func (o *CBCentral) ValueWithNameInPropertyWithKey(name *NSString, key *NSString) *Id {
	ret := &Id{}
	ret.ptr = unsafe.Pointer(C.CBCentral_inst_ValueWithNameInPropertyWithKey(o.Ptr(), name.Ptr(), key.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *Id) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *CBCentral) ReplaceValueAtIndexInPropertyWithKey(index NSUInteger, key *NSString, value NSObject)  {
	C.CBCentral_inst_ReplaceValueAtIndexInPropertyWithKey(o.Ptr(), (C.NSUInteger)(index), key.Ptr(), value.Ptr())
	runtime.KeepAlive(o)
}

func (o *CBCentral) ReplaceValueAtIndexInPropertyWithKeyWithValue(index NSUInteger, key *NSString, value NSObject)  {
	C.CBCentral_inst_ReplaceValueAtIndexInPropertyWithKeyWithValue(o.Ptr(), (C.NSUInteger)(index), key.Ptr(), value.Ptr())
	runtime.KeepAlive(o)
}

func (o *CBCentral) AwakeAfterUsingCoder(coder *NSCoder) *Id {
	ret := &Id{}
	ret.ptr = unsafe.Pointer(C.CBCentral_inst_AwakeAfterUsingCoder(o.Ptr(), coder.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *Id) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *CBCentral) IsKindOfClass(aClass Class) bool {
	ret := (bool)(C.CBCentral_inst_IsKindOfClass(o.Ptr(), unsafe.Pointer(aClass)))
	runtime.KeepAlive(o)
	return ret
}

func (o *CBCentral) CopyScriptingValueForKey(value NSObject, key *NSString, properties *NSDictionary) *Id {
	ret := &Id{}
	ret.ptr = unsafe.Pointer(C.CBCentral_inst_CopyScriptingValueForKey(o.Ptr(), value.Ptr(), key.Ptr(), properties.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *Id) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *CBCentral) CopyScriptingValueForKeyWithProperties(value NSObject, key *NSString, properties *NSDictionary) *Id {
	ret := &Id{}
	ret.ptr = unsafe.Pointer(C.CBCentral_inst_CopyScriptingValueForKeyWithProperties(o.Ptr(), value.Ptr(), key.Ptr(), properties.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *Id) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *CBCentral) DebugDescription() *NSString {
	ret := &NSString{}
	ret.ptr = unsafe.Pointer(C.CBCentral_inst_DebugDescription(o.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSString)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *NSString) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *CBCentral) Description() *NSString {
	ret := &NSString{}
	ret.ptr = unsafe.Pointer(C.CBCentral_inst_Description(o.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSString)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *NSString) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *CBCentral) SetValueForKey(value NSObject, key *NSString)  {
	C.CBCentral_inst_SetValueForKey(o.Ptr(), value.Ptr(), key.Ptr())
	runtime.KeepAlive(o)
}

func (o *CBCentral) SetValueForKeyPath(value NSObject, keyPath *NSString)  {
	C.CBCentral_inst_SetValueForKeyPath(o.Ptr(), value.Ptr(), keyPath.Ptr())
	runtime.KeepAlive(o)
}

func (o *CBCentral) SetValueForUndefinedKey(value NSObject, key *NSString)  {
	C.CBCentral_inst_SetValueForUndefinedKey(o.Ptr(), value.Ptr(), key.Ptr())
	runtime.KeepAlive(o)
}

func (o *CBCentral) AddObserverForKeyPath(observer NSObject, keyPath *NSString, options NSKeyValueObservingOptions, context unsafe.Pointer)  {
	C.CBCentral_inst_AddObserverForKeyPath(o.Ptr(), observer.Ptr(), keyPath.Ptr(), (C.NSKeyValueObservingOptions)(options), unsafe.Pointer(context))
	runtime.KeepAlive(o)
}

func (o *CBCentral) AddObserverForKeyPathOptions(observer NSObject, keyPath *NSString, options NSKeyValueObservingOptions, context unsafe.Pointer)  {
	C.CBCentral_inst_AddObserverForKeyPathOptions(o.Ptr(), observer.Ptr(), keyPath.Ptr(), (C.NSKeyValueObservingOptions)(options), unsafe.Pointer(context))
	runtime.KeepAlive(o)
}

func (o *CBCentral) IsGreaterThanOrEqualTo(object NSObject) bool {
	ret := (bool)(C.CBCentral_inst_IsGreaterThanOrEqualTo(o.Ptr(), object.Ptr()))
	runtime.KeepAlive(o)
	return ret
}

func (o *CBCentral) DoesContain(object NSObject) bool {
	ret := (bool)(C.CBCentral_inst_DoesContain(o.Ptr(), object.Ptr()))
	runtime.KeepAlive(o)
	return ret
}

func (o *CBCentral) ObserveValueForKeyPathOfObject(keyPath *NSString, object NSObject, change *NSDictionary, context unsafe.Pointer)  {
	C.CBCentral_inst_ObserveValueForKeyPathOfObject(o.Ptr(), keyPath.Ptr(), object.Ptr(), change.Ptr(), unsafe.Pointer(context))
	runtime.KeepAlive(o)
}

func (o *CBCentral) ObserveValueForKeyPathOfObjectChange(keyPath *NSString, object NSObject, change *NSDictionary, context unsafe.Pointer)  {
	C.CBCentral_inst_ObserveValueForKeyPathOfObjectChange(o.Ptr(), keyPath.Ptr(), object.Ptr(), change.Ptr(), unsafe.Pointer(context))
	runtime.KeepAlive(o)
}

func (o *CBCentral) ValueWithUniqueIDInPropertyWithKey(uniqueID NSObject, key *NSString) *Id {
	ret := &Id{}
	ret.ptr = unsafe.Pointer(C.CBCentral_inst_ValueWithUniqueIDInPropertyWithKey(o.Ptr(), uniqueID.Ptr(), key.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *Id) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *CBCentral) ConformsToProtocol(aProtocol Protocol) bool {
	ret := (bool)(C.CBCentral_inst_ConformsToProtocol(o.Ptr(), aProtocol.Ptr()))
	runtime.KeepAlive(o)
	return ret
}

func (o *CBCentral) ScriptingIsLessThanOrEqualTo(object NSObject) bool {
	ret := (bool)(C.CBCentral_inst_ScriptingIsLessThanOrEqualTo(o.Ptr(), object.Ptr()))
	runtime.KeepAlive(o)
	return ret
}

func (o *CBCentral) SetScriptingProperties(scriptingProperties *NSDictionary)  {
	C.CBCentral_inst_SetScriptingProperties(o.Ptr(), scriptingProperties.Ptr())
	runtime.KeepAlive(o)
}

func (o *CBCentral) SetNilValueForKey(key *NSString)  {
	C.CBCentral_inst_SetNilValueForKey(o.Ptr(), key.Ptr())
	runtime.KeepAlive(o)
}

func (o *CBCentral) ScriptingValueForSpecifier(objectSpecifier *NSScriptObjectSpecifier) *Id {
	ret := &Id{}
	ret.ptr = unsafe.Pointer(C.CBCentral_inst_ScriptingValueForSpecifier(o.Ptr(), objectSpecifier.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *Id) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *CBCentral) ValidateValueForKey(ioValue *[]*Id, inKey *NSString, outError *[]*NSError) bool {

	goSlice1 := make([]unsafe.Pointer,cap(*ioValue))
	for i := 0; i < len(*ioValue); i++ {
		goSlice1[i] = (*ioValue)[i].Ptr()
	}

	goSlice3 := make([]unsafe.Pointer,cap(*outError))
	for i := 0; i < len(*outError); i++ {
		goSlice3[i] = (*outError)[i].Ptr()
	}
	ret := (bool)(C.CBCentral_inst_ValidateValueForKey(o.Ptr(), (*unsafe.Pointer)(unsafe.Pointer(&goSlice1[0])), inKey.Ptr(), (*unsafe.Pointer)(unsafe.Pointer(&goSlice3[0]))))
	(*ioValue) = (*ioValue)[:cap(*ioValue)]
	for i := 0; i < len(*ioValue); i++ {
		if goSlice1[i] == nil {
			(*ioValue) = (*ioValue)[:i]
			break
		}
		if (*ioValue)[i] == nil {
			(*ioValue)[i] = &Id{}
			runtime.SetFinalizer((*ioValue)[i], func(o *Id) {
				o.Release()
			})
		}
		(*ioValue)[i].ptr = goSlice1[i]
	}
	(*outError) = (*outError)[:cap(*outError)]
	for i := 0; i < len(*outError); i++ {
		if goSlice3[i] == nil {
			(*outError) = (*outError)[:i]
			break
		}
		if (*outError)[i] == nil {
			(*outError)[i] = &NSError{}
			runtime.SetFinalizer((*outError)[i], func(o *NSError) {
				o.Release()
			})
		}
		(*outError)[i].ptr = goSlice3[i]
	}
	runtime.KeepAlive(o)
	return ret
}

func (o *CBCentral) ValidateValueForKeyPath(ioValue *[]*Id, inKeyPath *NSString, outError *[]*NSError) bool {

	goSlice1 := make([]unsafe.Pointer,cap(*ioValue))
	for i := 0; i < len(*ioValue); i++ {
		goSlice1[i] = (*ioValue)[i].Ptr()
	}

	goSlice3 := make([]unsafe.Pointer,cap(*outError))
	for i := 0; i < len(*outError); i++ {
		goSlice3[i] = (*outError)[i].Ptr()
	}
	ret := (bool)(C.CBCentral_inst_ValidateValueForKeyPath(o.Ptr(), (*unsafe.Pointer)(unsafe.Pointer(&goSlice1[0])), inKeyPath.Ptr(), (*unsafe.Pointer)(unsafe.Pointer(&goSlice3[0]))))
	(*ioValue) = (*ioValue)[:cap(*ioValue)]
	for i := 0; i < len(*ioValue); i++ {
		if goSlice1[i] == nil {
			(*ioValue) = (*ioValue)[:i]
			break
		}
		if (*ioValue)[i] == nil {
			(*ioValue)[i] = &Id{}
			runtime.SetFinalizer((*ioValue)[i], func(o *Id) {
				o.Release()
			})
		}
		(*ioValue)[i].ptr = goSlice1[i]
	}
	(*outError) = (*outError)[:cap(*outError)]
	for i := 0; i < len(*outError); i++ {
		if goSlice3[i] == nil {
			(*outError) = (*outError)[:i]
			break
		}
		if (*outError)[i] == nil {
			(*outError)[i] = &NSError{}
			runtime.SetFinalizer((*outError)[i], func(o *NSError) {
				o.Release()
			})
		}
		(*outError)[i].ptr = goSlice3[i]
	}
	runtime.KeepAlive(o)
	return ret
}

func (o *CBCentral) ValidateValueForKeyError(ioValue *[]*Id, inKey *NSString, outError *[]*NSError) bool {

	goSlice1 := make([]unsafe.Pointer,cap(*ioValue))
	for i := 0; i < len(*ioValue); i++ {
		goSlice1[i] = (*ioValue)[i].Ptr()
	}

	goSlice3 := make([]unsafe.Pointer,cap(*outError))
	for i := 0; i < len(*outError); i++ {
		goSlice3[i] = (*outError)[i].Ptr()
	}
	ret := (bool)(C.CBCentral_inst_ValidateValueForKeyError(o.Ptr(), (*unsafe.Pointer)(unsafe.Pointer(&goSlice1[0])), inKey.Ptr(), (*unsafe.Pointer)(unsafe.Pointer(&goSlice3[0]))))
	(*ioValue) = (*ioValue)[:cap(*ioValue)]
	for i := 0; i < len(*ioValue); i++ {
		if goSlice1[i] == nil {
			(*ioValue) = (*ioValue)[:i]
			break
		}
		if (*ioValue)[i] == nil {
			(*ioValue)[i] = &Id{}
			runtime.SetFinalizer((*ioValue)[i], func(o *Id) {
				o.Release()
			})
		}
		(*ioValue)[i].ptr = goSlice1[i]
	}
	(*outError) = (*outError)[:cap(*outError)]
	for i := 0; i < len(*outError); i++ {
		if goSlice3[i] == nil {
			(*outError) = (*outError)[:i]
			break
		}
		if (*outError)[i] == nil {
			(*outError)[i] = &NSError{}
			runtime.SetFinalizer((*outError)[i], func(o *NSError) {
				o.Release()
			})
		}
		(*outError)[i].ptr = goSlice3[i]
	}
	runtime.KeepAlive(o)
	return ret
}

func (o *CBCentral) ValidateValueForKeyPathError(ioValue *[]*Id, inKeyPath *NSString, outError *[]*NSError) bool {

	goSlice1 := make([]unsafe.Pointer,cap(*ioValue))
	for i := 0; i < len(*ioValue); i++ {
		goSlice1[i] = (*ioValue)[i].Ptr()
	}

	goSlice3 := make([]unsafe.Pointer,cap(*outError))
	for i := 0; i < len(*outError); i++ {
		goSlice3[i] = (*outError)[i].Ptr()
	}
	ret := (bool)(C.CBCentral_inst_ValidateValueForKeyPathError(o.Ptr(), (*unsafe.Pointer)(unsafe.Pointer(&goSlice1[0])), inKeyPath.Ptr(), (*unsafe.Pointer)(unsafe.Pointer(&goSlice3[0]))))
	(*ioValue) = (*ioValue)[:cap(*ioValue)]
	for i := 0; i < len(*ioValue); i++ {
		if goSlice1[i] == nil {
			(*ioValue) = (*ioValue)[:i]
			break
		}
		if (*ioValue)[i] == nil {
			(*ioValue)[i] = &Id{}
			runtime.SetFinalizer((*ioValue)[i], func(o *Id) {
				o.Release()
			})
		}
		(*ioValue)[i].ptr = goSlice1[i]
	}
	(*outError) = (*outError)[:cap(*outError)]
	for i := 0; i < len(*outError); i++ {
		if goSlice3[i] == nil {
			(*outError) = (*outError)[:i]
			break
		}
		if (*outError)[i] == nil {
			(*outError)[i] = &NSError{}
			runtime.SetFinalizer((*outError)[i], func(o *NSError) {
				o.Release()
			})
		}
		(*outError)[i].ptr = goSlice3[i]
	}
	runtime.KeepAlive(o)
	return ret
}

func (o *CBCentral) ClassDescription() *NSClassDescription {
	ret := &NSClassDescription{}
	ret.ptr = unsafe.Pointer(C.CBCentral_inst_ClassDescription(o.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSClassDescription)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *NSClassDescription) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *CBCentral) ClassForKeyedArchiver() Class {
	ret := (Class)(unsafe.Pointer(C.CBCentral_inst_ClassForKeyedArchiver(o.Ptr())))
	runtime.KeepAlive(o)
	return ret
}

func (o *CBCentral) MutableSetValueForKey(key *NSString) *NSMutableSet {
	ret := &NSMutableSet{}
	ret.ptr = unsafe.Pointer(C.CBCentral_inst_MutableSetValueForKey(o.Ptr(), key.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSMutableSet)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *NSMutableSet) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *CBCentral) NewScriptingObjectOfClassForValueForKey(objectClass Class, key *NSString, contentsValue NSObject, properties *NSDictionary) *Id {
	ret := &Id{}
	ret.ptr = unsafe.Pointer(C.CBCentral_inst_NewScriptingObjectOfClassForValueForKey(o.Ptr(), unsafe.Pointer(objectClass), key.Ptr(), contentsValue.Ptr(), properties.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *Id) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *CBCentral) NewScriptingObjectOfClassForValueForKeyWithContentsValue(objectClass Class, key *NSString, contentsValue NSObject, properties *NSDictionary) *Id {
	ret := &Id{}
	ret.ptr = unsafe.Pointer(C.CBCentral_inst_NewScriptingObjectOfClassForValueForKeyWithContentsValue(o.Ptr(), unsafe.Pointer(objectClass), key.Ptr(), contentsValue.Ptr(), properties.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *Id) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *CBCentral) MutableOrderedSetValueForKey(key *NSString) *NSMutableOrderedSet {
	ret := &NSMutableOrderedSet{}
	ret.ptr = unsafe.Pointer(C.CBCentral_inst_MutableOrderedSetValueForKey(o.Ptr(), key.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSMutableOrderedSet)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *NSMutableOrderedSet) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *CBCentral) IsLessThanOrEqualTo(object NSObject) bool {
	ret := (bool)(C.CBCentral_inst_IsLessThanOrEqualTo(o.Ptr(), object.Ptr()))
	runtime.KeepAlive(o)
	return ret
}

func (o *CBCentral) PerformSelectorOnMainThreadWithObject(aSelector SEL, arg NSObject, wait BOOL)  {
	C.CBCentral_inst_PerformSelectorOnMainThreadWithObject(o.Ptr(), unsafe.Pointer(aSelector), arg.Ptr(), (C.BOOL)(wait))
	runtime.KeepAlive(o)
}

func (o *CBCentral) PerformSelectorOnMainThreadWithObjectWaitUntilDone(aSelector SEL, arg NSObject, wait BOOL)  {
	C.CBCentral_inst_PerformSelectorOnMainThreadWithObjectWaitUntilDone(o.Ptr(), unsafe.Pointer(aSelector), arg.Ptr(), (C.BOOL)(wait))
	runtime.KeepAlive(o)
}

func (o *CBCentral) PerformSelectorOnMainThreadWithObjectWaitUntilDoneModes(aSelector SEL, arg NSObject, wait BOOL, array *NSArray)  {
	C.CBCentral_inst_PerformSelectorOnMainThreadWithObjectWaitUntilDoneModes(o.Ptr(), unsafe.Pointer(aSelector), arg.Ptr(), (C.BOOL)(wait), array.Ptr())
	runtime.KeepAlive(o)
}

func (o *CBCentral) Hash() NSUInteger {
	ret := (NSUInteger)(C.CBCentral_inst_Hash(o.Ptr()))
	runtime.KeepAlive(o)
	return ret
}

func (o *CBCentral) IsCaseInsensitiveLike(object *NSString) bool {
	ret := (bool)(C.CBCentral_inst_IsCaseInsensitiveLike(o.Ptr(), object.Ptr()))
	runtime.KeepAlive(o)
	return ret
}

func (o *CBCentral) ScriptingIsGreaterThanOrEqualTo(object NSObject) bool {
	ret := (bool)(C.CBCentral_inst_ScriptingIsGreaterThanOrEqualTo(o.Ptr(), object.Ptr()))
	runtime.KeepAlive(o)
	return ret
}

func (o *CBCentral) ScriptingIsGreaterThan(object NSObject) bool {
	ret := (bool)(C.CBCentral_inst_ScriptingIsGreaterThan(o.Ptr(), object.Ptr()))
	runtime.KeepAlive(o)
	return ret
}

func (o *CBCentral) ReplacementObjectForKeyedArchiver(archiver *NSKeyedArchiver) *Id {
	ret := &Id{}
	ret.ptr = unsafe.Pointer(C.CBCentral_inst_ReplacementObjectForKeyedArchiver(o.Ptr(), archiver.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *Id) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *CBCentral) SetObservationInfo(observationInfo unsafe.Pointer)  {
	C.CBCentral_inst_SetObservationInfo(o.Ptr(), unsafe.Pointer(observationInfo))
	runtime.KeepAlive(o)
}

func (o *CBCentral) DidChangeValuesAtIndexes(changeKind NSKeyValueChange, indexes *NSIndexSet, key *NSString)  {
	C.CBCentral_inst_DidChangeValuesAtIndexes(o.Ptr(), (C.NSKeyValueChange)(changeKind), indexes.Ptr(), key.Ptr())
	runtime.KeepAlive(o)
}

func (o *CBCentral) DidChangeValuesAtIndexesForKey(changeKind NSKeyValueChange, indexes *NSIndexSet, key *NSString)  {
	C.CBCentral_inst_DidChangeValuesAtIndexesForKey(o.Ptr(), (C.NSKeyValueChange)(changeKind), indexes.Ptr(), key.Ptr())
	runtime.KeepAlive(o)
}

func (o *CBCentral) MutableArrayValueForKey(key *NSString) *NSMutableArray {
	ret := &NSMutableArray{}
	ret.ptr = unsafe.Pointer(C.CBCentral_inst_MutableArrayValueForKey(o.Ptr(), key.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSMutableArray)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *NSMutableArray) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *CBCentral) RemoveObserverForKeyPath(observer NSObject, keyPath *NSString)  {
	C.CBCentral_inst_RemoveObserverForKeyPath(o.Ptr(), observer.Ptr(), keyPath.Ptr())
	runtime.KeepAlive(o)
}

func (o *CBCentral) RemoveObserverForKeyPathContext(observer NSObject, keyPath *NSString, context unsafe.Pointer)  {
	C.CBCentral_inst_RemoveObserverForKeyPathContext(o.Ptr(), observer.Ptr(), keyPath.Ptr(), unsafe.Pointer(context))
	runtime.KeepAlive(o)
}

func (o *CBCentral) InsertValueInPropertyWithKey(value NSObject, key *NSString)  {
	C.CBCentral_inst_InsertValueInPropertyWithKey(o.Ptr(), value.Ptr(), key.Ptr())
	runtime.KeepAlive(o)
}

func (o *CBCentral) InsertValueAtIndex(value NSObject, index NSUInteger, key *NSString)  {
	C.CBCentral_inst_InsertValueAtIndex(o.Ptr(), value.Ptr(), (C.NSUInteger)(index), key.Ptr())
	runtime.KeepAlive(o)
}

func (o *CBCentral) InsertValueAtIndexInPropertyWithKey(value NSObject, index NSUInteger, key *NSString)  {
	C.CBCentral_inst_InsertValueAtIndexInPropertyWithKey(o.Ptr(), value.Ptr(), (C.NSUInteger)(index), key.Ptr())
	runtime.KeepAlive(o)
}

func (o *CBCentral) DidChangeValueForKey(key *NSString)  {
	C.CBCentral_inst_DidChangeValueForKey(o.Ptr(), key.Ptr())
	runtime.KeepAlive(o)
}

func (o *CBCentral) DidChangeValueForKeyWithSetMutation(key *NSString, mutationKind NSKeyValueSetMutationKind, objects *NSSet)  {
	C.CBCentral_inst_DidChangeValueForKeyWithSetMutation(o.Ptr(), key.Ptr(), (C.NSKeyValueSetMutationKind)(mutationKind), objects.Ptr())
	runtime.KeepAlive(o)
}

func (o *CBCentral) DidChangeValueForKeyWithSetMutationUsingObjects(key *NSString, mutationKind NSKeyValueSetMutationKind, objects *NSSet)  {
	C.CBCentral_inst_DidChangeValueForKeyWithSetMutationUsingObjects(o.Ptr(), key.Ptr(), (C.NSKeyValueSetMutationKind)(mutationKind), objects.Ptr())
	runtime.KeepAlive(o)
}

func (o *CBCentral) Zone() *_NSZone {
	ret := (*_NSZone)(unsafe.Pointer(C.CBCentral_inst_Zone(o.Ptr())))
	runtime.KeepAlive(o)
	return ret
}

func (o *CBCentral) ScriptingBeginsWith(object NSObject) bool {
	ret := (bool)(C.CBCentral_inst_ScriptingBeginsWith(o.Ptr(), object.Ptr()))
	runtime.KeepAlive(o)
	return ret
}

func (o *CBCentral) ValueForKey(key *NSString) *Id {
	ret := &Id{}
	ret.ptr = unsafe.Pointer(C.CBCentral_inst_ValueForKey(o.Ptr(), key.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *Id) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *CBCentral) ForwardInvocation(anInvocation *NSInvocation)  {
	C.CBCentral_inst_ForwardInvocation(o.Ptr(), anInvocation.Ptr())
	runtime.KeepAlive(o)
}

func (o *CBCentral) PerformSelectorInBackgroundWithObject(aSelector SEL, arg NSObject)  {
	C.CBCentral_inst_PerformSelectorInBackgroundWithObject(o.Ptr(), unsafe.Pointer(aSelector), arg.Ptr())
	runtime.KeepAlive(o)
}

func (o *CBCentral) CoerceValueForKey(value NSObject, key *NSString) *Id {
	ret := &Id{}
	ret.ptr = unsafe.Pointer(C.CBCentral_inst_CoerceValueForKey(o.Ptr(), value.Ptr(), key.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *Id) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *CBCentral) DictionaryWithValuesForKeys(keys *NSArray) *NSDictionary {
	ret := &NSDictionary{}
	ret.ptr = unsafe.Pointer(C.CBCentral_inst_DictionaryWithValuesForKeys(o.Ptr(), keys.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSDictionary)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *NSDictionary) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *CBCentral) Superclass() Class {
	ret := (Class)(unsafe.Pointer(C.CBCentral_inst_Superclass(o.Ptr())))
	runtime.KeepAlive(o)
	return ret
}

func (o *CBCentral) ScriptingIsLessThan(object NSObject) bool {
	ret := (bool)(C.CBCentral_inst_ScriptingIsLessThan(o.Ptr(), object.Ptr()))
	runtime.KeepAlive(o)
	return ret
}

func (o *CBCentral) ClassCode() FourCharCode {
	ret := (FourCharCode)(C.CBCentral_inst_ClassCode(o.Ptr()))
	runtime.KeepAlive(o)
	return ret
}

func (o *CBCentral) AutoContentAccessingProxy() *Id {
	ret := &Id{}
	ret.ptr = unsafe.Pointer(C.CBCentral_inst_AutoContentAccessingProxy(o.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *Id) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *CBCentral) InverseForRelationshipKey(relationshipKey *NSString) *NSString {
	ret := &NSString{}
	ret.ptr = unsafe.Pointer(C.CBCentral_inst_InverseForRelationshipKey(o.Ptr(), relationshipKey.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSString)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *NSString) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *CBCentral) IsLike(object *NSString) bool {
	ret := (bool)(C.CBCentral_inst_IsLike(o.Ptr(), object.Ptr()))
	runtime.KeepAlive(o)
	return ret
}

func (o *CBCentral) IsEqual(object NSObject) bool {
	ret := (bool)(C.CBCentral_inst_IsEqual(o.Ptr(), object.Ptr()))
	runtime.KeepAlive(o)
	return ret
}

func (o *CBCentral) DoesNotRecognizeSelector(aSelector SEL)  {
	C.CBCentral_inst_DoesNotRecognizeSelector(o.Ptr(), unsafe.Pointer(aSelector))
	runtime.KeepAlive(o)
}

func (o *CBCentral) MutableCopy() *Id {
	ret := &Id{}
	ret.ptr = unsafe.Pointer(C.CBCentral_inst_MutableCopy(o.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	runtime.SetFinalizer(ret, func(o *Id) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *CBCentral) SetValuesForKeysWithDictionary(keyedValues *NSDictionary)  {
	C.CBCentral_inst_SetValuesForKeysWithDictionary(o.Ptr(), keyedValues.Ptr())
	runtime.KeepAlive(o)
}

func (o *CBCentral) Release()  {
	C.CBCentral_inst_Release(o.Ptr())
	runtime.KeepAlive(o)
}

func (o *CBCentral) MaximumUpdateValueLength() NSUInteger {
	ret := (NSUInteger)(C.CBCentral_inst_MaximumUpdateValueLength(o.Ptr()))
	runtime.KeepAlive(o)
	return ret
}

func (o *CBCentral) ReplacementObjectForCoder(coder *NSCoder) *Id {
	ret := &Id{}
	ret.ptr = unsafe.Pointer(C.CBCentral_inst_ReplacementObjectForCoder(o.Ptr(), coder.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *Id) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func NSDictionaryResolveClassMethod(sel SEL) bool {
	ret := (bool)(C.NSDictionary_ResolveClassMethod(unsafe.Pointer(sel)))
	return ret
}

func NSDictionaryKeyPathsForValuesAffectingValueForKey(key *NSString) *NSSet {
	ret := &NSSet{}
	ret.ptr = unsafe.Pointer(C.NSDictionary_KeyPathsForValuesAffectingValueForKey(key.Ptr()))
	if ret.ptr == nil { return ret }
	return ret
}

func NSDictionaryMutableCopyWithZone(zone *_NSZone) *Id {
	ret := &Id{}
	ret.ptr = unsafe.Pointer(C.NSDictionary_MutableCopyWithZone(unsafe.Pointer(zone)))
	if ret.ptr == nil { return ret }
	runtime.SetFinalizer(ret, func(o *Id) {
		o.Release()
	})
	return ret
}

func NSDictionaryResolveInstanceMethod(sel SEL) bool {
	ret := (bool)(C.NSDictionary_ResolveInstanceMethod(unsafe.Pointer(sel)))
	return ret
}

func NSDictionarySuperclass() Class {
	ret := (Class)(unsafe.Pointer(C.NSDictionary_Superclass()))
	return ret
}

func NSDictionaryHash() NSUInteger {
	ret := (NSUInteger)(C.NSDictionary_Hash())
	return ret
}

func NSDictionaryNew() *NSDictionary {
	ret := &NSDictionary{}
	ret.ptr = unsafe.Pointer(C.NSDictionary_New())
	if ret.ptr == nil { return ret }
	runtime.SetFinalizer(ret, func(o *NSDictionary) {
		o.Release()
	})
	return ret
}

func NSDictionaryAccessInstanceVariablesDirectly() bool {
	ret := (bool)(C.NSDictionary_AccessInstanceVariablesDirectly())
	return ret
}

func NSDictionaryAlloc() *NSDictionary {
	ret := &NSDictionary{}
	ret.ptr = unsafe.Pointer(C.NSDictionary_Alloc())
	if ret.ptr == nil { return ret }
	runtime.SetFinalizer(ret, func(o *NSDictionary) {
		o.Release()
	})
	return ret
}

func (o *NSDictionary) GC() {
	if o.ptr == nil { return }
	runtime.SetFinalizer(o, func(o *NSDictionary) {
		o.Release()
	})
	runtime.KeepAlive(o)
}

func NSDictionaryDebugDescription() *NSString {
	ret := &NSString{}
	ret.ptr = unsafe.Pointer(C.NSDictionary_DebugDescription())
	if ret.ptr == nil { return ret }
	return ret
}

func NSDictionaryInstancesRespondToSelector(aSelector SEL) bool {
	ret := (bool)(C.NSDictionary_InstancesRespondToSelector(unsafe.Pointer(aSelector)))
	return ret
}

func NSDictionaryWithDictionary(dict *NSDictionary) *NSDictionary {
	ret := &NSDictionary{}
	ret.ptr = unsafe.Pointer(C.NSDictionary_DictionaryWithDictionary(dict.Ptr()))
	if ret.ptr == nil { return ret }
	runtime.SetFinalizer(ret, func(o *NSDictionary) {
		o.Release()
	})
	return ret
}

func NSDictionaryIsSubclassOfClass(aClass Class) bool {
	ret := (bool)(C.NSDictionary_IsSubclassOfClass(unsafe.Pointer(aClass)))
	return ret
}

func NSDictionaryConformsToProtocol(protocol Protocol) bool {
	ret := (bool)(C.NSDictionary_ConformsToProtocol(protocol.Ptr()))
	return ret
}

func NSDictionaryClassForKeyedUnarchiver() Class {
	ret := (Class)(unsafe.Pointer(C.NSDictionary_ClassForKeyedUnarchiver()))
	return ret
}

func NSDictionarySupportsSecureCoding() bool {
	ret := (bool)(C.NSDictionary_SupportsSecureCoding())
	return ret
}

func NSDictionarySetVersion(aVersion NSInteger)  {
	C.NSDictionary_SetVersion((C.NSInteger)(aVersion))
}

func NSDictionaryInstanceMethodSignatureForSelector(aSelector SEL) *NSMethodSignature {
	ret := &NSMethodSignature{}
	ret.ptr = unsafe.Pointer(C.NSDictionary_InstanceMethodSignatureForSelector(unsafe.Pointer(aSelector)))
	if ret.ptr == nil { return ret }
	return ret
}

func NSDictionaryWithContentsOfURLError(url *NSURL, error *[]*NSError) *NSDictionary {

	goSlice1 := make([]unsafe.Pointer,cap(*error))
	for i := 0; i < len(*error); i++ {
		goSlice1[i] = (*error)[i].Ptr()
	}
	ret := &NSDictionary{}
	ret.ptr = unsafe.Pointer(C.NSDictionary_DictionaryWithContentsOfURLError(url.Ptr(), (*unsafe.Pointer)(unsafe.Pointer(&goSlice1[0]))))
	(*error) = (*error)[:cap(*error)]
	for i := 0; i < len(*error); i++ {
		if goSlice1[i] == nil {
			(*error) = (*error)[:i]
			break
		}
		if (*error)[i] == nil {
			(*error)[i] = &NSError{}
			runtime.SetFinalizer((*error)[i], func(o *NSError) {
				o.Release()
			})
		}
		(*error)[i].ptr = goSlice1[i]
	}
	if ret.ptr == nil { return ret }
	runtime.SetFinalizer(ret, func(o *NSDictionary) {
		o.Release()
	})
	return ret
}

func NSDictionaryAllocWithZone(zone *_NSZone) *NSDictionary {
	ret := &NSDictionary{}
	ret.ptr = unsafe.Pointer(C.NSDictionary_AllocWithZone(unsafe.Pointer(zone)))
	if ret.ptr == nil { return ret }
	runtime.SetFinalizer(ret, func(o *NSDictionary) {
		o.Release()
	})
	return ret
}

func NSDictionaryClassFallbacksForKeyedArchiver() *NSArray {
	ret := &NSArray{}
	ret.ptr = unsafe.Pointer(C.NSDictionary_ClassFallbacksForKeyedArchiver())
	if ret.ptr == nil { return ret }
	return ret
}

func NSDictionaryVersion() NSInteger {
	ret := (NSInteger)(C.NSDictionary_Version())
	return ret
}

func NSDictionaryWithObjectForKey(object NSObject, key NSObject) *NSDictionary {
	ret := &NSDictionary{}
	ret.ptr = unsafe.Pointer(C.NSDictionary_DictionaryWithObjectForKey(object.Ptr(), key.Ptr()))
	if ret.ptr == nil { return ret }
	runtime.SetFinalizer(ret, func(o *NSDictionary) {
		o.Release()
	})
	return ret
}

func NSDictionaryDescription() *NSString {
	ret := &NSString{}
	ret.ptr = unsafe.Pointer(C.NSDictionary_Description())
	if ret.ptr == nil { return ret }
	return ret
}

func NSDictionaryClass() Class {
	ret := (Class)(unsafe.Pointer(C.NSDictionary_Class()))
	return ret
}

func NSDictionaryAutomaticallyNotifiesObserversForKey(key *NSString) bool {
	ret := (bool)(C.NSDictionary_AutomaticallyNotifiesObserversForKey(key.Ptr()))
	return ret
}

func NSDictionaryCancelPreviousPerformRequestsWithTarget(aTarget NSObject)  {
	C.NSDictionary_CancelPreviousPerformRequestsWithTarget(aTarget.Ptr())
}

func NSDictionaryCancelPreviousPerformRequestsWithTargetSelector(aTarget NSObject, aSelector SEL, anArgument NSObject)  {
	C.NSDictionary_CancelPreviousPerformRequestsWithTargetSelector(aTarget.Ptr(), unsafe.Pointer(aSelector), anArgument.Ptr())
}

func NSDictionaryCancelPreviousPerformRequestsWithTargetSelectorObject(aTarget NSObject, aSelector SEL, anArgument NSObject)  {
	C.NSDictionary_CancelPreviousPerformRequestsWithTargetSelectorObject(aTarget.Ptr(), unsafe.Pointer(aSelector), anArgument.Ptr())
}

func NSDictionaryWithObjectsAndKeys(firstObject NSObject) *NSDictionary {
	ret := &NSDictionary{}
	ret.ptr = unsafe.Pointer(C.NSDictionary_DictionaryWithObjectsAndKeys(firstObject.Ptr()))
	if ret.ptr == nil { return ret }
	runtime.SetFinalizer(ret, func(o *NSDictionary) {
		o.Release()
	})
	return ret
}

func NSDictionarySharedKeySetForKeys(keys *NSArray) *Id {
	ret := &Id{}
	ret.ptr = unsafe.Pointer(C.NSDictionary_SharedKeySetForKeys(keys.Ptr()))
	if ret.ptr == nil { return ret }
	return ret
}

func NSDictionaryLoad()  {
	C.NSDictionary_Load()
}

func NSDictionaryCopyWithZone(zone *_NSZone) *Id {
	ret := &Id{}
	ret.ptr = unsafe.Pointer(C.NSDictionary_CopyWithZone(unsafe.Pointer(zone)))
	if ret.ptr == nil { return ret }
	runtime.SetFinalizer(ret, func(o *Id) {
		o.Release()
	})
	return ret
}

func NSDictionaryDictionary() *NSDictionary {
	ret := &NSDictionary{}
	ret.ptr = unsafe.Pointer(C.NSDictionary_Dictionary())
	if ret.ptr == nil { return ret }
	runtime.SetFinalizer(ret, func(o *NSDictionary) {
		o.Release()
	})
	return ret
}

func NSDictionaryWithObjectsForKeys(objects *NSArray, keys *NSArray) *NSDictionary {
	ret := &NSDictionary{}
	ret.ptr = unsafe.Pointer(C.NSDictionary_DictionaryWithObjectsForKeys(objects.Ptr(), keys.Ptr()))
	if ret.ptr == nil { return ret }
	runtime.SetFinalizer(ret, func(o *NSDictionary) {
		o.Release()
	})
	return ret
}

func NSDictionaryWithObjectsForKeysCount(objects *[]*Id, keys *[]*Id, cnt NSUInteger) *NSDictionary {

	goSlice0 := make([]unsafe.Pointer,cap(*objects))
	for i := 0; i < len(*objects); i++ {
		goSlice0[i] = (*objects)[i].Ptr()
	}

	goSlice1 := make([]unsafe.Pointer,cap(*keys))
	for i := 0; i < len(*keys); i++ {
		goSlice1[i] = (*keys)[i].Ptr()
	}
	ret := &NSDictionary{}
	ret.ptr = unsafe.Pointer(C.NSDictionary_DictionaryWithObjectsForKeysCount((*unsafe.Pointer)(unsafe.Pointer(&goSlice0[0])), (*unsafe.Pointer)(unsafe.Pointer(&goSlice1[0])), (C.NSUInteger)(cnt)))
	(*objects) = (*objects)[:cap(*objects)]
	for i := 0; i < len(*objects); i++ {
		if goSlice0[i] == nil {
			(*objects) = (*objects)[:i]
			break
		}
		if (*objects)[i] == nil {
			(*objects)[i] = &Id{}
			runtime.SetFinalizer((*objects)[i], func(o *Id) {
				o.Release()
			})
		}
		(*objects)[i].ptr = goSlice0[i]
	}
	(*keys) = (*keys)[:cap(*keys)]
	for i := 0; i < len(*keys); i++ {
		if goSlice1[i] == nil {
			(*keys) = (*keys)[:i]
			break
		}
		if (*keys)[i] == nil {
			(*keys)[i] = &Id{}
			runtime.SetFinalizer((*keys)[i], func(o *Id) {
				o.Release()
			})
		}
		(*keys)[i].ptr = goSlice1[i]
	}
	if ret.ptr == nil { return ret }
	runtime.SetFinalizer(ret, func(o *NSDictionary) {
		o.Release()
	})
	return ret
}

func (o *NSDictionary) ConformsToProtocol(aProtocol Protocol) bool {
	ret := (bool)(C.NSDictionary_inst_ConformsToProtocol(o.Ptr(), aProtocol.Ptr()))
	runtime.KeepAlive(o)
	return ret
}

func (o *NSDictionary) RemoveObserverForKeyPath(observer NSObject, keyPath *NSString)  {
	C.NSDictionary_inst_RemoveObserverForKeyPath(o.Ptr(), observer.Ptr(), keyPath.Ptr())
	runtime.KeepAlive(o)
}

func (o *NSDictionary) RemoveObserverForKeyPathContext(observer NSObject, keyPath *NSString, context unsafe.Pointer)  {
	C.NSDictionary_inst_RemoveObserverForKeyPathContext(o.Ptr(), observer.Ptr(), keyPath.Ptr(), unsafe.Pointer(context))
	runtime.KeepAlive(o)
}

func (o *NSDictionary) PerformSelectorInBackgroundWithObject(aSelector SEL, arg NSObject)  {
	C.NSDictionary_inst_PerformSelectorInBackgroundWithObject(o.Ptr(), unsafe.Pointer(aSelector), arg.Ptr())
	runtime.KeepAlive(o)
}

func (o *NSDictionary) IndicesOfObjectsByEvaluatingObjectSpecifier(specifier *NSScriptObjectSpecifier) *NSArray {
	ret := &NSArray{}
	ret.ptr = unsafe.Pointer(C.NSDictionary_inst_IndicesOfObjectsByEvaluatingObjectSpecifier(o.Ptr(), specifier.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSArray)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *NSArray) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *NSDictionary) MutableSetValueForKey(key *NSString) *NSMutableSet {
	ret := &NSMutableSet{}
	ret.ptr = unsafe.Pointer(C.NSDictionary_inst_MutableSetValueForKey(o.Ptr(), key.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSMutableSet)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *NSMutableSet) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *NSDictionary) CopyWithZone(zone *NSZone) *Id {
	ret := &Id{}
	ret.ptr = unsafe.Pointer(C.NSDictionary_inst_CopyWithZone(o.Ptr(), unsafe.Pointer(zone)))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *Id) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *NSDictionary) ObjectForKeyedSubscript(key NSObject) *Id {
	ret := &Id{}
	ret.ptr = unsafe.Pointer(C.NSDictionary_inst_ObjectForKeyedSubscript(o.Ptr(), key.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *Id) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *NSDictionary) ValueForUndefinedKey(key *NSString) *Id {
	ret := &Id{}
	ret.ptr = unsafe.Pointer(C.NSDictionary_inst_ValueForUndefinedKey(o.Ptr(), key.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *Id) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *NSDictionary) ValueWithUniqueIDInPropertyWithKey(uniqueID NSObject, key *NSString) *Id {
	ret := &Id{}
	ret.ptr = unsafe.Pointer(C.NSDictionary_inst_ValueWithUniqueIDInPropertyWithKey(o.Ptr(), uniqueID.Ptr(), key.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *Id) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *NSDictionary) ClassForCoder() Class {
	ret := (Class)(unsafe.Pointer(C.NSDictionary_inst_ClassForCoder(o.Ptr())))
	runtime.KeepAlive(o)
	return ret
}

func (o *NSDictionary) FileIsAppendOnly() bool {
	ret := (bool)(C.NSDictionary_inst_FileIsAppendOnly(o.Ptr()))
	runtime.KeepAlive(o)
	return ret
}

func (o *NSDictionary) ToManyRelationshipKeys() *NSArray {
	ret := &NSArray{}
	ret.ptr = unsafe.Pointer(C.NSDictionary_inst_ToManyRelationshipKeys(o.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSArray)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *NSArray) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *NSDictionary) AllKeysForObject(anObject NSObject) *NSArray {
	ret := &NSArray{}
	ret.ptr = unsafe.Pointer(C.NSDictionary_inst_AllKeysForObject(o.Ptr(), anObject.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSArray)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *NSArray) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *NSDictionary) Superclass() Class {
	ret := (Class)(unsafe.Pointer(C.NSDictionary_inst_Superclass(o.Ptr())))
	runtime.KeepAlive(o)
	return ret
}

func (o *NSDictionary) IsLessThanOrEqualTo(object NSObject) bool {
	ret := (bool)(C.NSDictionary_inst_IsLessThanOrEqualTo(o.Ptr(), object.Ptr()))
	runtime.KeepAlive(o)
	return ret
}

func (o *NSDictionary) FileSize() UnsignedLongLong {
	ret := (UnsignedLongLong)(C.NSDictionary_inst_FileSize(o.Ptr()))
	runtime.KeepAlive(o)
	return ret
}

func (o *NSDictionary) Dealloc()  {
	C.NSDictionary_inst_Dealloc(o.Ptr())
	runtime.KeepAlive(o)
}

func (o *NSDictionary) PerformSelector(aSelector SEL) *Id {
	ret := &Id{}
	ret.ptr = unsafe.Pointer(C.NSDictionary_inst_PerformSelector(o.Ptr(), unsafe.Pointer(aSelector)))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *Id) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *NSDictionary) PerformSelectorWithObject(aSelector SEL, object NSObject) *Id {
	ret := &Id{}
	ret.ptr = unsafe.Pointer(C.NSDictionary_inst_PerformSelectorWithObject(o.Ptr(), unsafe.Pointer(aSelector), object.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *Id) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *NSDictionary) PerformSelectorWithObjectWithObject(aSelector SEL, object1 NSObject, object2 NSObject) *Id {
	ret := &Id{}
	ret.ptr = unsafe.Pointer(C.NSDictionary_inst_PerformSelectorWithObjectWithObject(o.Ptr(), unsafe.Pointer(aSelector), object1.Ptr(), object2.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *Id) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *NSDictionary) PerformSelectorWithObjectAfterDelay(aSelector SEL, anArgument NSObject, delay NSTimeInterval)  {
	C.NSDictionary_inst_PerformSelectorWithObjectAfterDelay(o.Ptr(), unsafe.Pointer(aSelector), anArgument.Ptr(), (C.NSTimeInterval)(delay))
	runtime.KeepAlive(o)
}

func (o *NSDictionary) PerformSelectorOnThread(aSelector SEL, thr *NSThread, arg NSObject, wait BOOL)  {
	C.NSDictionary_inst_PerformSelectorOnThread(o.Ptr(), unsafe.Pointer(aSelector), thr.Ptr(), arg.Ptr(), (C.BOOL)(wait))
	runtime.KeepAlive(o)
}

func (o *NSDictionary) PerformSelectorWithObjectAfterDelayInModes(aSelector SEL, anArgument NSObject, delay NSTimeInterval, modes *NSArray)  {
	C.NSDictionary_inst_PerformSelectorWithObjectAfterDelayInModes(o.Ptr(), unsafe.Pointer(aSelector), anArgument.Ptr(), (C.NSTimeInterval)(delay), modes.Ptr())
	runtime.KeepAlive(o)
}

func (o *NSDictionary) PerformSelectorOnThreadWithObject(aSelector SEL, thr *NSThread, arg NSObject, wait BOOL)  {
	C.NSDictionary_inst_PerformSelectorOnThreadWithObject(o.Ptr(), unsafe.Pointer(aSelector), thr.Ptr(), arg.Ptr(), (C.BOOL)(wait))
	runtime.KeepAlive(o)
}

func (o *NSDictionary) PerformSelectorOnThreadWithObjectWaitUntilDone(aSelector SEL, thr *NSThread, arg NSObject, wait BOOL, array *NSArray)  {
	C.NSDictionary_inst_PerformSelectorOnThreadWithObjectWaitUntilDone(o.Ptr(), unsafe.Pointer(aSelector), thr.Ptr(), arg.Ptr(), (C.BOOL)(wait), array.Ptr())
	runtime.KeepAlive(o)
}

func (o *NSDictionary) PerformSelectorOnThreadWithObjectWaitUntilDoneModes(aSelector SEL, thr *NSThread, arg NSObject, wait BOOL, array *NSArray)  {
	C.NSDictionary_inst_PerformSelectorOnThreadWithObjectWaitUntilDoneModes(o.Ptr(), unsafe.Pointer(aSelector), thr.Ptr(), arg.Ptr(), (C.BOOL)(wait), array.Ptr())
	runtime.KeepAlive(o)
}

func (o *NSDictionary) AutoContentAccessingProxy() *Id {
	ret := &Id{}
	ret.ptr = unsafe.Pointer(C.NSDictionary_inst_AutoContentAccessingProxy(o.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *Id) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *NSDictionary) FileHFSCreatorCode() OSType {
	ret := (OSType)(C.NSDictionary_inst_FileHFSCreatorCode(o.Ptr()))
	runtime.KeepAlive(o)
	return ret
}

func (o *NSDictionary) Init() *NSDictionary {
	ret := &NSDictionary{}
	ret.ptr = unsafe.Pointer(C.NSDictionary_inst_Init(o.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSDictionary)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *NSDictionary) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *NSDictionary) Retain() *NSDictionary {
	ret := &NSDictionary{}
	ret.ptr = unsafe.Pointer(C.NSDictionary_inst_Retain(o.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSDictionary)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *NSDictionary) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *NSDictionary) IsEqualTo(object NSObject) bool {
	ret := (bool)(C.NSDictionary_inst_IsEqualTo(o.Ptr(), object.Ptr()))
	runtime.KeepAlive(o)
	return ret
}

func (o *NSDictionary) DoesContain(object NSObject) bool {
	ret := (bool)(C.NSDictionary_inst_DoesContain(o.Ptr(), object.Ptr()))
	runtime.KeepAlive(o)
	return ret
}

func (o *NSDictionary) MutableCopyWithZone(zone *NSZone) *Id {
	ret := &Id{}
	ret.ptr = unsafe.Pointer(C.NSDictionary_inst_MutableCopyWithZone(o.Ptr(), unsafe.Pointer(zone)))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *Id) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *NSDictionary) InitWithObjectsAndKeys(firstObject NSObject) *NSDictionary {
	ret := &NSDictionary{}
	ret.ptr = unsafe.Pointer(C.NSDictionary_inst_InitWithObjectsAndKeys(o.Ptr(), firstObject.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSDictionary)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *NSDictionary) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *NSDictionary) NewScriptingObjectOfClassForValueForKey(objectClass Class, key *NSString, contentsValue NSObject, properties *NSDictionary) *Id {
	ret := &Id{}
	ret.ptr = unsafe.Pointer(C.NSDictionary_inst_NewScriptingObjectOfClassForValueForKey(o.Ptr(), unsafe.Pointer(objectClass), key.Ptr(), contentsValue.Ptr(), properties.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *Id) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *NSDictionary) NewScriptingObjectOfClassForValueForKeyWithContentsValue(objectClass Class, key *NSString, contentsValue NSObject, properties *NSDictionary) *Id {
	ret := &Id{}
	ret.ptr = unsafe.Pointer(C.NSDictionary_inst_NewScriptingObjectOfClassForValueForKeyWithContentsValue(o.Ptr(), unsafe.Pointer(objectClass), key.Ptr(), contentsValue.Ptr(), properties.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *Id) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *NSDictionary) DoesNotRecognizeSelector(aSelector SEL)  {
	C.NSDictionary_inst_DoesNotRecognizeSelector(o.Ptr(), unsafe.Pointer(aSelector))
	runtime.KeepAlive(o)
}

func (o *NSDictionary) Zone() *_NSZone {
	ret := (*_NSZone)(unsafe.Pointer(C.NSDictionary_inst_Zone(o.Ptr())))
	runtime.KeepAlive(o)
	return ret
}

func (o *NSDictionary) ScriptingBeginsWith(object NSObject) bool {
	ret := (bool)(C.NSDictionary_inst_ScriptingBeginsWith(o.Ptr(), object.Ptr()))
	runtime.KeepAlive(o)
	return ret
}

func (o *NSDictionary) MethodSignatureForSelector(aSelector SEL) *NSMethodSignature {
	ret := &NSMethodSignature{}
	ret.ptr = unsafe.Pointer(C.NSDictionary_inst_MethodSignatureForSelector(o.Ptr(), unsafe.Pointer(aSelector)))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSMethodSignature)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *NSMethodSignature) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *NSDictionary) ScriptingProperties() *NSDictionary {
	ret := &NSDictionary{}
	ret.ptr = unsafe.Pointer(C.NSDictionary_inst_ScriptingProperties(o.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSDictionary)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *NSDictionary) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *NSDictionary) KeysSortedByValueUsingSelector(comparator SEL) *NSArray {
	ret := &NSArray{}
	ret.ptr = unsafe.Pointer(C.NSDictionary_inst_KeysSortedByValueUsingSelector(o.Ptr(), unsafe.Pointer(comparator)))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSArray)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *NSArray) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *NSDictionary) FileGroupOwnerAccountID() *NSNumber {
	ret := &NSNumber{}
	ret.ptr = unsafe.Pointer(C.NSDictionary_inst_FileGroupOwnerAccountID(o.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSNumber)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *NSNumber) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *NSDictionary) FileOwnerAccountID() *NSNumber {
	ret := &NSNumber{}
	ret.ptr = unsafe.Pointer(C.NSDictionary_inst_FileOwnerAccountID(o.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSNumber)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *NSNumber) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *NSDictionary) FileSystemFileNumber() NSUInteger {
	ret := (NSUInteger)(C.NSDictionary_inst_FileSystemFileNumber(o.Ptr()))
	runtime.KeepAlive(o)
	return ret
}

func (o *NSDictionary) IsMemberOfClass(aClass Class) bool {
	ret := (bool)(C.NSDictionary_inst_IsMemberOfClass(o.Ptr(), unsafe.Pointer(aClass)))
	runtime.KeepAlive(o)
	return ret
}

func (o *NSDictionary) AddObserverForKeyPath(observer NSObject, keyPath *NSString, options NSKeyValueObservingOptions, context unsafe.Pointer)  {
	C.NSDictionary_inst_AddObserverForKeyPath(o.Ptr(), observer.Ptr(), keyPath.Ptr(), (C.NSKeyValueObservingOptions)(options), unsafe.Pointer(context))
	runtime.KeepAlive(o)
}

func (o *NSDictionary) AddObserverForKeyPathOptions(observer NSObject, keyPath *NSString, options NSKeyValueObservingOptions, context unsafe.Pointer)  {
	C.NSDictionary_inst_AddObserverForKeyPathOptions(o.Ptr(), observer.Ptr(), keyPath.Ptr(), (C.NSKeyValueObservingOptions)(options), unsafe.Pointer(context))
	runtime.KeepAlive(o)
}

func (o *NSDictionary) ClassCode() FourCharCode {
	ret := (FourCharCode)(C.NSDictionary_inst_ClassCode(o.Ptr()))
	runtime.KeepAlive(o)
	return ret
}

func (o *NSDictionary) WillChangeValuesAtIndexes(changeKind NSKeyValueChange, indexes *NSIndexSet, key *NSString)  {
	C.NSDictionary_inst_WillChangeValuesAtIndexes(o.Ptr(), (C.NSKeyValueChange)(changeKind), indexes.Ptr(), key.Ptr())
	runtime.KeepAlive(o)
}

func (o *NSDictionary) WillChangeValuesAtIndexesForKey(changeKind NSKeyValueChange, indexes *NSIndexSet, key *NSString)  {
	C.NSDictionary_inst_WillChangeValuesAtIndexesForKey(o.Ptr(), (C.NSKeyValueChange)(changeKind), indexes.Ptr(), key.Ptr())
	runtime.KeepAlive(o)
}

func (o *NSDictionary) SetValuesForKeysWithDictionary(keyedValues *NSDictionary)  {
	C.NSDictionary_inst_SetValuesForKeysWithDictionary(o.Ptr(), keyedValues.Ptr())
	runtime.KeepAlive(o)
}

func (o *NSDictionary) ScriptingEndsWith(object NSObject) bool {
	ret := (bool)(C.NSDictionary_inst_ScriptingEndsWith(o.Ptr(), object.Ptr()))
	runtime.KeepAlive(o)
	return ret
}

func (o *NSDictionary) FileType() *NSString {
	ret := &NSString{}
	ret.ptr = unsafe.Pointer(C.NSDictionary_inst_FileType(o.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSString)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *NSString) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *NSDictionary) FileIsImmutable() bool {
	ret := (bool)(C.NSDictionary_inst_FileIsImmutable(o.Ptr()))
	runtime.KeepAlive(o)
	return ret
}

func (o *NSDictionary) ObjectSpecifier() *NSScriptObjectSpecifier {
	ret := &NSScriptObjectSpecifier{}
	ret.ptr = unsafe.Pointer(C.NSDictionary_inst_ObjectSpecifier(o.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSScriptObjectSpecifier)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *NSScriptObjectSpecifier) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *NSDictionary) ScriptingValueForSpecifier(objectSpecifier *NSScriptObjectSpecifier) *Id {
	ret := &Id{}
	ret.ptr = unsafe.Pointer(C.NSDictionary_inst_ScriptingValueForSpecifier(o.Ptr(), objectSpecifier.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *Id) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *NSDictionary) DebugDescription() *NSString {
	ret := &NSString{}
	ret.ptr = unsafe.Pointer(C.NSDictionary_inst_DebugDescription(o.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSString)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *NSString) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *NSDictionary) Hash() NSUInteger {
	ret := (NSUInteger)(C.NSDictionary_inst_Hash(o.Ptr()))
	runtime.KeepAlive(o)
	return ret
}

func (o *NSDictionary) WriteToURLError(url *NSURL, error *[]*NSError) bool {

	goSlice2 := make([]unsafe.Pointer,cap(*error))
	for i := 0; i < len(*error); i++ {
		goSlice2[i] = (*error)[i].Ptr()
	}
	ret := (bool)(C.NSDictionary_inst_WriteToURLError(o.Ptr(), url.Ptr(), (*unsafe.Pointer)(unsafe.Pointer(&goSlice2[0]))))
	(*error) = (*error)[:cap(*error)]
	for i := 0; i < len(*error); i++ {
		if goSlice2[i] == nil {
			(*error) = (*error)[:i]
			break
		}
		if (*error)[i] == nil {
			(*error)[i] = &NSError{}
			runtime.SetFinalizer((*error)[i], func(o *NSError) {
				o.Release()
			})
		}
		(*error)[i].ptr = goSlice2[i]
	}
	runtime.KeepAlive(o)
	return ret
}

func (o *NSDictionary) DescriptionInStringsFileFormat() *NSString {
	ret := &NSString{}
	ret.ptr = unsafe.Pointer(C.NSDictionary_inst_DescriptionInStringsFileFormat(o.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSString)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *NSString) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *NSDictionary) InitWithContentsOfURLError(url *NSURL, error *[]*NSError) *NSDictionary {

	goSlice2 := make([]unsafe.Pointer,cap(*error))
	for i := 0; i < len(*error); i++ {
		goSlice2[i] = (*error)[i].Ptr()
	}
	ret := &NSDictionary{}
	ret.ptr = unsafe.Pointer(C.NSDictionary_inst_InitWithContentsOfURLError(o.Ptr(), url.Ptr(), (*unsafe.Pointer)(unsafe.Pointer(&goSlice2[0]))))
	(*error) = (*error)[:cap(*error)]
	for i := 0; i < len(*error); i++ {
		if goSlice2[i] == nil {
			(*error) = (*error)[:i]
			break
		}
		if (*error)[i] == nil {
			(*error)[i] = &NSError{}
			runtime.SetFinalizer((*error)[i], func(o *NSError) {
				o.Release()
			})
		}
		(*error)[i].ptr = goSlice2[i]
	}
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSDictionary)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *NSDictionary) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *NSDictionary) AttributeKeys() *NSArray {
	ret := &NSArray{}
	ret.ptr = unsafe.Pointer(C.NSDictionary_inst_AttributeKeys(o.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSArray)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *NSArray) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *NSDictionary) Autorelease() *NSDictionary {
	ret := &NSDictionary{}
	ret.ptr = unsafe.Pointer(C.NSDictionary_inst_Autorelease(o.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSDictionary)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *NSDictionary) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *NSDictionary) AttemptRecoveryFromErrorOptionIndex(error *NSError, recoveryOptionIndex NSUInteger) bool {
	ret := (bool)(C.NSDictionary_inst_AttemptRecoveryFromErrorOptionIndex(o.Ptr(), error.Ptr(), (C.NSUInteger)(recoveryOptionIndex)))
	runtime.KeepAlive(o)
	return ret
}

func (o *NSDictionary) AttemptRecoveryFromErrorOptionIndexDelegate(error *NSError, recoveryOptionIndex NSUInteger, delegate NSObject, didRecoverSelector SEL, contextInfo unsafe.Pointer)  {
	C.NSDictionary_inst_AttemptRecoveryFromErrorOptionIndexDelegate(o.Ptr(), error.Ptr(), (C.NSUInteger)(recoveryOptionIndex), delegate.Ptr(), unsafe.Pointer(didRecoverSelector), unsafe.Pointer(contextInfo))
	runtime.KeepAlive(o)
}

func (o *NSDictionary) AttemptRecoveryFromErrorOptionIndexDelegateDidRecoverSelector(error *NSError, recoveryOptionIndex NSUInteger, delegate NSObject, didRecoverSelector SEL, contextInfo unsafe.Pointer)  {
	C.NSDictionary_inst_AttemptRecoveryFromErrorOptionIndexDelegateDidRecoverSelector(o.Ptr(), error.Ptr(), (C.NSUInteger)(recoveryOptionIndex), delegate.Ptr(), unsafe.Pointer(didRecoverSelector), unsafe.Pointer(contextInfo))
	runtime.KeepAlive(o)
}

func (o *NSDictionary) ValueAtIndexInPropertyWithKey(index NSUInteger, key *NSString) *Id {
	ret := &Id{}
	ret.ptr = unsafe.Pointer(C.NSDictionary_inst_ValueAtIndexInPropertyWithKey(o.Ptr(), (C.NSUInteger)(index), key.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *Id) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *NSDictionary) ScriptingContains(object NSObject) bool {
	ret := (bool)(C.NSDictionary_inst_ScriptingContains(o.Ptr(), object.Ptr()))
	runtime.KeepAlive(o)
	return ret
}

func (o *NSDictionary) IsCaseInsensitiveLike(object *NSString) bool {
	ret := (bool)(C.NSDictionary_inst_IsCaseInsensitiveLike(o.Ptr(), object.Ptr()))
	runtime.KeepAlive(o)
	return ret
}

func (o *NSDictionary) ObservationInfo() unsafe.Pointer {
	ret := (unsafe.Pointer)(unsafe.Pointer(C.NSDictionary_inst_ObservationInfo(o.Ptr())))
	runtime.KeepAlive(o)
	return ret
}

func (o *NSDictionary) CoerceValueForKey(value NSObject, key *NSString) *Id {
	ret := &Id{}
	ret.ptr = unsafe.Pointer(C.NSDictionary_inst_CoerceValueForKey(o.Ptr(), value.Ptr(), key.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *Id) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *NSDictionary) IsKindOfClass(aClass Class) bool {
	ret := (bool)(C.NSDictionary_inst_IsKindOfClass(o.Ptr(), unsafe.Pointer(aClass)))
	runtime.KeepAlive(o)
	return ret
}

func (o *NSDictionary) GetObjectsAndKeys(objects *[]*Id, keys *[]*Id, count NSUInteger)  {

	goSlice1 := make([]unsafe.Pointer,cap(*objects))
	for i := 0; i < len(*objects); i++ {
		goSlice1[i] = (*objects)[i].Ptr()
	}

	goSlice2 := make([]unsafe.Pointer,cap(*keys))
	for i := 0; i < len(*keys); i++ {
		goSlice2[i] = (*keys)[i].Ptr()
	}
	C.NSDictionary_inst_GetObjectsAndKeys(o.Ptr(), (*unsafe.Pointer)(unsafe.Pointer(&goSlice1[0])), (*unsafe.Pointer)(unsafe.Pointer(&goSlice2[0])), (C.NSUInteger)(count))
	(*objects) = (*objects)[:cap(*objects)]
	for i := 0; i < len(*objects); i++ {
		if goSlice1[i] == nil {
			(*objects) = (*objects)[:i]
			break
		}
		if (*objects)[i] == nil {
			(*objects)[i] = &Id{}
			runtime.SetFinalizer((*objects)[i], func(o *Id) {
				o.Release()
			})
		}
		(*objects)[i].ptr = goSlice1[i]
	}
	(*keys) = (*keys)[:cap(*keys)]
	for i := 0; i < len(*keys); i++ {
		if goSlice2[i] == nil {
			(*keys) = (*keys)[:i]
			break
		}
		if (*keys)[i] == nil {
			(*keys)[i] = &Id{}
			runtime.SetFinalizer((*keys)[i], func(o *Id) {
				o.Release()
			})
		}
		(*keys)[i].ptr = goSlice2[i]
	}
	runtime.KeepAlive(o)
}

func (o *NSDictionary) GetObjectsAndKeysCount(objects *[]*Id, keys *[]*Id, count NSUInteger)  {

	goSlice1 := make([]unsafe.Pointer,cap(*objects))
	for i := 0; i < len(*objects); i++ {
		goSlice1[i] = (*objects)[i].Ptr()
	}

	goSlice2 := make([]unsafe.Pointer,cap(*keys))
	for i := 0; i < len(*keys); i++ {
		goSlice2[i] = (*keys)[i].Ptr()
	}
	C.NSDictionary_inst_GetObjectsAndKeysCount(o.Ptr(), (*unsafe.Pointer)(unsafe.Pointer(&goSlice1[0])), (*unsafe.Pointer)(unsafe.Pointer(&goSlice2[0])), (C.NSUInteger)(count))
	(*objects) = (*objects)[:cap(*objects)]
	for i := 0; i < len(*objects); i++ {
		if goSlice1[i] == nil {
			(*objects) = (*objects)[:i]
			break
		}
		if (*objects)[i] == nil {
			(*objects)[i] = &Id{}
			runtime.SetFinalizer((*objects)[i], func(o *Id) {
				o.Release()
			})
		}
		(*objects)[i].ptr = goSlice1[i]
	}
	(*keys) = (*keys)[:cap(*keys)]
	for i := 0; i < len(*keys); i++ {
		if goSlice2[i] == nil {
			(*keys) = (*keys)[:i]
			break
		}
		if (*keys)[i] == nil {
			(*keys)[i] = &Id{}
			runtime.SetFinalizer((*keys)[i], func(o *Id) {
				o.Release()
			})
		}
		(*keys)[i].ptr = goSlice2[i]
	}
	runtime.KeepAlive(o)
}

func (o *NSDictionary) KeyEnumerator() *NSEnumerator {
	ret := &NSEnumerator{}
	ret.ptr = unsafe.Pointer(C.NSDictionary_inst_KeyEnumerator(o.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSEnumerator)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *NSEnumerator) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *NSDictionary) ObjectForKey(aKey NSObject) *Id {
	ret := &Id{}
	ret.ptr = unsafe.Pointer(C.NSDictionary_inst_ObjectForKey(o.Ptr(), aKey.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *Id) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *NSDictionary) MutableArrayValueForKeyPath(keyPath *NSString) *NSMutableArray {
	ret := &NSMutableArray{}
	ret.ptr = unsafe.Pointer(C.NSDictionary_inst_MutableArrayValueForKeyPath(o.Ptr(), keyPath.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSMutableArray)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *NSMutableArray) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *NSDictionary) MutableSetValueForKeyPath(keyPath *NSString) *NSMutableSet {
	ret := &NSMutableSet{}
	ret.ptr = unsafe.Pointer(C.NSDictionary_inst_MutableSetValueForKeyPath(o.Ptr(), keyPath.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSMutableSet)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *NSMutableSet) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *NSDictionary) MutableOrderedSetValueForKeyPath(keyPath *NSString) *NSMutableOrderedSet {
	ret := &NSMutableOrderedSet{}
	ret.ptr = unsafe.Pointer(C.NSDictionary_inst_MutableOrderedSetValueForKeyPath(o.Ptr(), keyPath.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSMutableOrderedSet)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *NSMutableOrderedSet) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *NSDictionary) IsLike(object *NSString) bool {
	ret := (bool)(C.NSDictionary_inst_IsLike(o.Ptr(), object.Ptr()))
	runtime.KeepAlive(o)
	return ret
}

func (o *NSDictionary) ValueForKeyPath(keyPath *NSString) *Id {
	ret := &Id{}
	ret.ptr = unsafe.Pointer(C.NSDictionary_inst_ValueForKeyPath(o.Ptr(), keyPath.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *Id) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *NSDictionary) IsEqual(object NSObject) bool {
	ret := (bool)(C.NSDictionary_inst_IsEqual(o.Ptr(), object.Ptr()))
	runtime.KeepAlive(o)
	return ret
}

func (o *NSDictionary) DidChangeValueForKey(key *NSString)  {
	C.NSDictionary_inst_DidChangeValueForKey(o.Ptr(), key.Ptr())
	runtime.KeepAlive(o)
}

func (o *NSDictionary) DidChangeValueForKeyWithSetMutation(key *NSString, mutationKind NSKeyValueSetMutationKind, objects *NSSet)  {
	C.NSDictionary_inst_DidChangeValueForKeyWithSetMutation(o.Ptr(), key.Ptr(), (C.NSKeyValueSetMutationKind)(mutationKind), objects.Ptr())
	runtime.KeepAlive(o)
}

func (o *NSDictionary) DidChangeValueForKeyWithSetMutationUsingObjects(key *NSString, mutationKind NSKeyValueSetMutationKind, objects *NSSet)  {
	C.NSDictionary_inst_DidChangeValueForKeyWithSetMutationUsingObjects(o.Ptr(), key.Ptr(), (C.NSKeyValueSetMutationKind)(mutationKind), objects.Ptr())
	runtime.KeepAlive(o)
}

func (o *NSDictionary) CopyScriptingValueForKey(value NSObject, key *NSString, properties *NSDictionary) *Id {
	ret := &Id{}
	ret.ptr = unsafe.Pointer(C.NSDictionary_inst_CopyScriptingValueForKey(o.Ptr(), value.Ptr(), key.Ptr(), properties.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *Id) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *NSDictionary) CopyScriptingValueForKeyWithProperties(value NSObject, key *NSString, properties *NSDictionary) *Id {
	ret := &Id{}
	ret.ptr = unsafe.Pointer(C.NSDictionary_inst_CopyScriptingValueForKeyWithProperties(o.Ptr(), value.Ptr(), key.Ptr(), properties.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *Id) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *NSDictionary) FileHFSTypeCode() OSType {
	ret := (OSType)(C.NSDictionary_inst_FileHFSTypeCode(o.Ptr()))
	runtime.KeepAlive(o)
	return ret
}

func (o *NSDictionary) ObjectsForKeysNotFoundMarker(keys *NSArray, marker NSObject) *NSArray {
	ret := &NSArray{}
	ret.ptr = unsafe.Pointer(C.NSDictionary_inst_ObjectsForKeysNotFoundMarker(o.Ptr(), keys.Ptr(), marker.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSArray)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *NSArray) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *NSDictionary) InitWithObjectsForKeys(objects *NSArray, keys *NSArray) *NSDictionary {
	ret := &NSDictionary{}
	ret.ptr = unsafe.Pointer(C.NSDictionary_inst_InitWithObjectsForKeys(o.Ptr(), objects.Ptr(), keys.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSDictionary)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *NSDictionary) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *NSDictionary) InitWithObjectsForKeysCount(objects *[]*Id, keys *[]*Id, cnt NSUInteger) *NSDictionary {

	goSlice1 := make([]unsafe.Pointer,cap(*objects))
	for i := 0; i < len(*objects); i++ {
		goSlice1[i] = (*objects)[i].Ptr()
	}

	goSlice2 := make([]unsafe.Pointer,cap(*keys))
	for i := 0; i < len(*keys); i++ {
		goSlice2[i] = (*keys)[i].Ptr()
	}
	ret := &NSDictionary{}
	ret.ptr = unsafe.Pointer(C.NSDictionary_inst_InitWithObjectsForKeysCount(o.Ptr(), (*unsafe.Pointer)(unsafe.Pointer(&goSlice1[0])), (*unsafe.Pointer)(unsafe.Pointer(&goSlice2[0])), (C.NSUInteger)(cnt)))
	(*objects) = (*objects)[:cap(*objects)]
	for i := 0; i < len(*objects); i++ {
		if goSlice1[i] == nil {
			(*objects) = (*objects)[:i]
			break
		}
		if (*objects)[i] == nil {
			(*objects)[i] = &Id{}
			runtime.SetFinalizer((*objects)[i], func(o *Id) {
				o.Release()
			})
		}
		(*objects)[i].ptr = goSlice1[i]
	}
	(*keys) = (*keys)[:cap(*keys)]
	for i := 0; i < len(*keys); i++ {
		if goSlice2[i] == nil {
			(*keys) = (*keys)[:i]
			break
		}
		if (*keys)[i] == nil {
			(*keys)[i] = &Id{}
			runtime.SetFinalizer((*keys)[i], func(o *Id) {
				o.Release()
			})
		}
		(*keys)[i].ptr = goSlice2[i]
	}
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSDictionary)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *NSDictionary) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *NSDictionary) ReplacementObjectForCoder(coder *NSCoder) *Id {
	ret := &Id{}
	ret.ptr = unsafe.Pointer(C.NSDictionary_inst_ReplacementObjectForCoder(o.Ptr(), coder.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *Id) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *NSDictionary) ValueForKey(key *NSString) *Id {
	ret := &Id{}
	ret.ptr = unsafe.Pointer(C.NSDictionary_inst_ValueForKey(o.Ptr(), key.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *Id) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *NSDictionary) Count() NSUInteger {
	ret := (NSUInteger)(C.NSDictionary_inst_Count(o.Ptr()))
	runtime.KeepAlive(o)
	return ret
}

func (o *NSDictionary) ScriptingIsLessThan(object NSObject) bool {
	ret := (bool)(C.NSDictionary_inst_ScriptingIsLessThan(o.Ptr(), object.Ptr()))
	runtime.KeepAlive(o)
	return ret
}

func (o *NSDictionary) Copy() *Id {
	ret := &Id{}
	ret.ptr = unsafe.Pointer(C.NSDictionary_inst_Copy(o.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	runtime.SetFinalizer(ret, func(o *Id) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *NSDictionary) RespondsToSelector(aSelector SEL) bool {
	ret := (bool)(C.NSDictionary_inst_RespondsToSelector(o.Ptr(), unsafe.Pointer(aSelector)))
	runtime.KeepAlive(o)
	return ret
}

func (o *NSDictionary) ClassName() *NSString {
	ret := &NSString{}
	ret.ptr = unsafe.Pointer(C.NSDictionary_inst_ClassName(o.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSString)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *NSString) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *NSDictionary) AllKeys() *NSArray {
	ret := &NSArray{}
	ret.ptr = unsafe.Pointer(C.NSDictionary_inst_AllKeys(o.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSArray)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *NSArray) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *NSDictionary) FileOwnerAccountName() *NSString {
	ret := &NSString{}
	ret.ptr = unsafe.Pointer(C.NSDictionary_inst_FileOwnerAccountName(o.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSString)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *NSString) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *NSDictionary) ReplaceValueAtIndexInPropertyWithKey(index NSUInteger, key *NSString, value NSObject)  {
	C.NSDictionary_inst_ReplaceValueAtIndexInPropertyWithKey(o.Ptr(), (C.NSUInteger)(index), key.Ptr(), value.Ptr())
	runtime.KeepAlive(o)
}

func (o *NSDictionary) ReplaceValueAtIndexInPropertyWithKeyWithValue(index NSUInteger, key *NSString, value NSObject)  {
	C.NSDictionary_inst_ReplaceValueAtIndexInPropertyWithKeyWithValue(o.Ptr(), (C.NSUInteger)(index), key.Ptr(), value.Ptr())
	runtime.KeepAlive(o)
}

func (o *NSDictionary) ForwardInvocation(anInvocation *NSInvocation)  {
	C.NSDictionary_inst_ForwardInvocation(o.Ptr(), anInvocation.Ptr())
	runtime.KeepAlive(o)
}

func (o *NSDictionary) IsNotEqualTo(object NSObject) bool {
	ret := (bool)(C.NSDictionary_inst_IsNotEqualTo(o.Ptr(), object.Ptr()))
	runtime.KeepAlive(o)
	return ret
}

func (o *NSDictionary) ObjectEnumerator() *NSEnumerator {
	ret := &NSEnumerator{}
	ret.ptr = unsafe.Pointer(C.NSDictionary_inst_ObjectEnumerator(o.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSEnumerator)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *NSEnumerator) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *NSDictionary) IsProxy() bool {
	ret := (bool)(C.NSDictionary_inst_IsProxy(o.Ptr()))
	runtime.KeepAlive(o)
	return ret
}

func (o *NSDictionary) RemoveValueAtIndexFromPropertyWithKey(index NSUInteger, key *NSString)  {
	C.NSDictionary_inst_RemoveValueAtIndexFromPropertyWithKey(o.Ptr(), (C.NSUInteger)(index), key.Ptr())
	runtime.KeepAlive(o)
}

func (o *NSDictionary) ClassDescription() *NSClassDescription {
	ret := &NSClassDescription{}
	ret.ptr = unsafe.Pointer(C.NSDictionary_inst_ClassDescription(o.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSClassDescription)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *NSClassDescription) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *NSDictionary) Release()  {
	C.NSDictionary_inst_Release(o.Ptr())
	runtime.KeepAlive(o)
}

func (o *NSDictionary) MutableOrderedSetValueForKey(key *NSString) *NSMutableOrderedSet {
	ret := &NSMutableOrderedSet{}
	ret.ptr = unsafe.Pointer(C.NSDictionary_inst_MutableOrderedSetValueForKey(o.Ptr(), key.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSMutableOrderedSet)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *NSMutableOrderedSet) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *NSDictionary) RetainCount() NSUInteger {
	ret := (NSUInteger)(C.NSDictionary_inst_RetainCount(o.Ptr()))
	runtime.KeepAlive(o)
	return ret
}

func (o *NSDictionary) SetObservationInfo(observationInfo unsafe.Pointer)  {
	C.NSDictionary_inst_SetObservationInfo(o.Ptr(), unsafe.Pointer(observationInfo))
	runtime.KeepAlive(o)
}

func (o *NSDictionary) ReplacementObjectForKeyedArchiver(archiver *NSKeyedArchiver) *Id {
	ret := &Id{}
	ret.ptr = unsafe.Pointer(C.NSDictionary_inst_ReplacementObjectForKeyedArchiver(o.Ptr(), archiver.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *Id) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *NSDictionary) DescriptionWithLocale(locale NSObject) *NSString {
	ret := &NSString{}
	ret.ptr = unsafe.Pointer(C.NSDictionary_inst_DescriptionWithLocale(o.Ptr(), locale.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSString)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *NSString) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *NSDictionary) DescriptionWithLocaleIndent(locale NSObject, level NSUInteger) *NSString {
	ret := &NSString{}
	ret.ptr = unsafe.Pointer(C.NSDictionary_inst_DescriptionWithLocaleIndent(o.Ptr(), locale.Ptr(), (C.NSUInteger)(level)))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSString)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *NSString) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *NSDictionary) FileSystemNumber() NSInteger {
	ret := (NSInteger)(C.NSDictionary_inst_FileSystemNumber(o.Ptr()))
	runtime.KeepAlive(o)
	return ret
}

func (o *NSDictionary) AwakeAfterUsingCoder(coder *NSCoder) *Id {
	ret := &Id{}
	ret.ptr = unsafe.Pointer(C.NSDictionary_inst_AwakeAfterUsingCoder(o.Ptr(), coder.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *Id) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *NSDictionary) ForwardingTargetForSelector(aSelector SEL) *Id {
	ret := &Id{}
	ret.ptr = unsafe.Pointer(C.NSDictionary_inst_ForwardingTargetForSelector(o.Ptr(), unsafe.Pointer(aSelector)))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *Id) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *NSDictionary) DidChangeValuesAtIndexes(changeKind NSKeyValueChange, indexes *NSIndexSet, key *NSString)  {
	C.NSDictionary_inst_DidChangeValuesAtIndexes(o.Ptr(), (C.NSKeyValueChange)(changeKind), indexes.Ptr(), key.Ptr())
	runtime.KeepAlive(o)
}

func (o *NSDictionary) DidChangeValuesAtIndexesForKey(changeKind NSKeyValueChange, indexes *NSIndexSet, key *NSString)  {
	C.NSDictionary_inst_DidChangeValuesAtIndexesForKey(o.Ptr(), (C.NSKeyValueChange)(changeKind), indexes.Ptr(), key.Ptr())
	runtime.KeepAlive(o)
}

func (o *NSDictionary) IsEqualToDictionary(otherDictionary *NSDictionary) bool {
	ret := (bool)(C.NSDictionary_inst_IsEqualToDictionary(o.Ptr(), otherDictionary.Ptr()))
	runtime.KeepAlive(o)
	return ret
}

func (o *NSDictionary) FileExtensionHidden() bool {
	ret := (bool)(C.NSDictionary_inst_FileExtensionHidden(o.Ptr()))
	runtime.KeepAlive(o)
	return ret
}

func (o *NSDictionary) SetNilValueForKey(key *NSString)  {
	C.NSDictionary_inst_SetNilValueForKey(o.Ptr(), key.Ptr())
	runtime.KeepAlive(o)
}

func (o *NSDictionary) MutableArrayValueForKey(key *NSString) *NSMutableArray {
	ret := &NSMutableArray{}
	ret.ptr = unsafe.Pointer(C.NSDictionary_inst_MutableArrayValueForKey(o.Ptr(), key.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSMutableArray)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *NSMutableArray) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *NSDictionary) InverseForRelationshipKey(relationshipKey *NSString) *NSString {
	ret := &NSString{}
	ret.ptr = unsafe.Pointer(C.NSDictionary_inst_InverseForRelationshipKey(o.Ptr(), relationshipKey.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSString)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *NSString) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *NSDictionary) MutableCopy() *Id {
	ret := &Id{}
	ret.ptr = unsafe.Pointer(C.NSDictionary_inst_MutableCopy(o.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	runtime.SetFinalizer(ret, func(o *Id) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *NSDictionary) AllValues() *NSArray {
	ret := &NSArray{}
	ret.ptr = unsafe.Pointer(C.NSDictionary_inst_AllValues(o.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSArray)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *NSArray) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *NSDictionary) Description() *NSString {
	ret := &NSString{}
	ret.ptr = unsafe.Pointer(C.NSDictionary_inst_Description(o.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSString)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *NSString) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *NSDictionary) ScriptingIsLessThanOrEqualTo(object NSObject) bool {
	ret := (bool)(C.NSDictionary_inst_ScriptingIsLessThanOrEqualTo(o.Ptr(), object.Ptr()))
	runtime.KeepAlive(o)
	return ret
}

func (o *NSDictionary) SetValueForKey(value NSObject, key *NSString)  {
	C.NSDictionary_inst_SetValueForKey(o.Ptr(), value.Ptr(), key.Ptr())
	runtime.KeepAlive(o)
}

func (o *NSDictionary) SetValueForKeyPath(value NSObject, keyPath *NSString)  {
	C.NSDictionary_inst_SetValueForKeyPath(o.Ptr(), value.Ptr(), keyPath.Ptr())
	runtime.KeepAlive(o)
}

func (o *NSDictionary) SetValueForUndefinedKey(value NSObject, key *NSString)  {
	C.NSDictionary_inst_SetValueForUndefinedKey(o.Ptr(), value.Ptr(), key.Ptr())
	runtime.KeepAlive(o)
}

func (o *NSDictionary) ClassForArchiver() Class {
	ret := (Class)(unsafe.Pointer(C.NSDictionary_inst_ClassForArchiver(o.Ptr())))
	runtime.KeepAlive(o)
	return ret
}

func (o *NSDictionary) ToOneRelationshipKeys() *NSArray {
	ret := &NSArray{}
	ret.ptr = unsafe.Pointer(C.NSDictionary_inst_ToOneRelationshipKeys(o.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSArray)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *NSArray) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *NSDictionary) ValidateValueForKey(ioValue *[]*Id, inKey *NSString, outError *[]*NSError) bool {

	goSlice1 := make([]unsafe.Pointer,cap(*ioValue))
	for i := 0; i < len(*ioValue); i++ {
		goSlice1[i] = (*ioValue)[i].Ptr()
	}

	goSlice3 := make([]unsafe.Pointer,cap(*outError))
	for i := 0; i < len(*outError); i++ {
		goSlice3[i] = (*outError)[i].Ptr()
	}
	ret := (bool)(C.NSDictionary_inst_ValidateValueForKey(o.Ptr(), (*unsafe.Pointer)(unsafe.Pointer(&goSlice1[0])), inKey.Ptr(), (*unsafe.Pointer)(unsafe.Pointer(&goSlice3[0]))))
	(*ioValue) = (*ioValue)[:cap(*ioValue)]
	for i := 0; i < len(*ioValue); i++ {
		if goSlice1[i] == nil {
			(*ioValue) = (*ioValue)[:i]
			break
		}
		if (*ioValue)[i] == nil {
			(*ioValue)[i] = &Id{}
			runtime.SetFinalizer((*ioValue)[i], func(o *Id) {
				o.Release()
			})
		}
		(*ioValue)[i].ptr = goSlice1[i]
	}
	(*outError) = (*outError)[:cap(*outError)]
	for i := 0; i < len(*outError); i++ {
		if goSlice3[i] == nil {
			(*outError) = (*outError)[:i]
			break
		}
		if (*outError)[i] == nil {
			(*outError)[i] = &NSError{}
			runtime.SetFinalizer((*outError)[i], func(o *NSError) {
				o.Release()
			})
		}
		(*outError)[i].ptr = goSlice3[i]
	}
	runtime.KeepAlive(o)
	return ret
}

func (o *NSDictionary) ValidateValueForKeyPath(ioValue *[]*Id, inKeyPath *NSString, outError *[]*NSError) bool {

	goSlice1 := make([]unsafe.Pointer,cap(*ioValue))
	for i := 0; i < len(*ioValue); i++ {
		goSlice1[i] = (*ioValue)[i].Ptr()
	}

	goSlice3 := make([]unsafe.Pointer,cap(*outError))
	for i := 0; i < len(*outError); i++ {
		goSlice3[i] = (*outError)[i].Ptr()
	}
	ret := (bool)(C.NSDictionary_inst_ValidateValueForKeyPath(o.Ptr(), (*unsafe.Pointer)(unsafe.Pointer(&goSlice1[0])), inKeyPath.Ptr(), (*unsafe.Pointer)(unsafe.Pointer(&goSlice3[0]))))
	(*ioValue) = (*ioValue)[:cap(*ioValue)]
	for i := 0; i < len(*ioValue); i++ {
		if goSlice1[i] == nil {
			(*ioValue) = (*ioValue)[:i]
			break
		}
		if (*ioValue)[i] == nil {
			(*ioValue)[i] = &Id{}
			runtime.SetFinalizer((*ioValue)[i], func(o *Id) {
				o.Release()
			})
		}
		(*ioValue)[i].ptr = goSlice1[i]
	}
	(*outError) = (*outError)[:cap(*outError)]
	for i := 0; i < len(*outError); i++ {
		if goSlice3[i] == nil {
			(*outError) = (*outError)[:i]
			break
		}
		if (*outError)[i] == nil {
			(*outError)[i] = &NSError{}
			runtime.SetFinalizer((*outError)[i], func(o *NSError) {
				o.Release()
			})
		}
		(*outError)[i].ptr = goSlice3[i]
	}
	runtime.KeepAlive(o)
	return ret
}

func (o *NSDictionary) ValidateValueForKeyError(ioValue *[]*Id, inKey *NSString, outError *[]*NSError) bool {

	goSlice1 := make([]unsafe.Pointer,cap(*ioValue))
	for i := 0; i < len(*ioValue); i++ {
		goSlice1[i] = (*ioValue)[i].Ptr()
	}

	goSlice3 := make([]unsafe.Pointer,cap(*outError))
	for i := 0; i < len(*outError); i++ {
		goSlice3[i] = (*outError)[i].Ptr()
	}
	ret := (bool)(C.NSDictionary_inst_ValidateValueForKeyError(o.Ptr(), (*unsafe.Pointer)(unsafe.Pointer(&goSlice1[0])), inKey.Ptr(), (*unsafe.Pointer)(unsafe.Pointer(&goSlice3[0]))))
	(*ioValue) = (*ioValue)[:cap(*ioValue)]
	for i := 0; i < len(*ioValue); i++ {
		if goSlice1[i] == nil {
			(*ioValue) = (*ioValue)[:i]
			break
		}
		if (*ioValue)[i] == nil {
			(*ioValue)[i] = &Id{}
			runtime.SetFinalizer((*ioValue)[i], func(o *Id) {
				o.Release()
			})
		}
		(*ioValue)[i].ptr = goSlice1[i]
	}
	(*outError) = (*outError)[:cap(*outError)]
	for i := 0; i < len(*outError); i++ {
		if goSlice3[i] == nil {
			(*outError) = (*outError)[:i]
			break
		}
		if (*outError)[i] == nil {
			(*outError)[i] = &NSError{}
			runtime.SetFinalizer((*outError)[i], func(o *NSError) {
				o.Release()
			})
		}
		(*outError)[i].ptr = goSlice3[i]
	}
	runtime.KeepAlive(o)
	return ret
}

func (o *NSDictionary) ValidateValueForKeyPathError(ioValue *[]*Id, inKeyPath *NSString, outError *[]*NSError) bool {

	goSlice1 := make([]unsafe.Pointer,cap(*ioValue))
	for i := 0; i < len(*ioValue); i++ {
		goSlice1[i] = (*ioValue)[i].Ptr()
	}

	goSlice3 := make([]unsafe.Pointer,cap(*outError))
	for i := 0; i < len(*outError); i++ {
		goSlice3[i] = (*outError)[i].Ptr()
	}
	ret := (bool)(C.NSDictionary_inst_ValidateValueForKeyPathError(o.Ptr(), (*unsafe.Pointer)(unsafe.Pointer(&goSlice1[0])), inKeyPath.Ptr(), (*unsafe.Pointer)(unsafe.Pointer(&goSlice3[0]))))
	(*ioValue) = (*ioValue)[:cap(*ioValue)]
	for i := 0; i < len(*ioValue); i++ {
		if goSlice1[i] == nil {
			(*ioValue) = (*ioValue)[:i]
			break
		}
		if (*ioValue)[i] == nil {
			(*ioValue)[i] = &Id{}
			runtime.SetFinalizer((*ioValue)[i], func(o *Id) {
				o.Release()
			})
		}
		(*ioValue)[i].ptr = goSlice1[i]
	}
	(*outError) = (*outError)[:cap(*outError)]
	for i := 0; i < len(*outError); i++ {
		if goSlice3[i] == nil {
			(*outError) = (*outError)[:i]
			break
		}
		if (*outError)[i] == nil {
			(*outError)[i] = &NSError{}
			runtime.SetFinalizer((*outError)[i], func(o *NSError) {
				o.Release()
			})
		}
		(*outError)[i].ptr = goSlice3[i]
	}
	runtime.KeepAlive(o)
	return ret
}

func (o *NSDictionary) Self() *NSDictionary {
	ret := &NSDictionary{}
	ret.ptr = unsafe.Pointer(C.NSDictionary_inst_Self(o.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSDictionary)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *NSDictionary) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *NSDictionary) ValueWithNameInPropertyWithKey(name *NSString, key *NSString) *Id {
	ret := &Id{}
	ret.ptr = unsafe.Pointer(C.NSDictionary_inst_ValueWithNameInPropertyWithKey(o.Ptr(), name.Ptr(), key.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*Id)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *Id) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *NSDictionary) InitWithDictionary(otherDictionary *NSDictionary) *NSDictionary {
	ret := &NSDictionary{}
	ret.ptr = unsafe.Pointer(C.NSDictionary_inst_InitWithDictionary(o.Ptr(), otherDictionary.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSDictionary)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *NSDictionary) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *NSDictionary) InitWithDictionaryCopyItems(otherDictionary *NSDictionary, flag BOOL) *NSDictionary {
	ret := &NSDictionary{}
	ret.ptr = unsafe.Pointer(C.NSDictionary_inst_InitWithDictionaryCopyItems(o.Ptr(), otherDictionary.Ptr(), (C.BOOL)(flag)))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSDictionary)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *NSDictionary) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *NSDictionary) InitWithCoder(coder *NSCoder) *NSDictionary {
	ret := &NSDictionary{}
	ret.ptr = unsafe.Pointer(C.NSDictionary_inst_InitWithCoder(o.Ptr(), coder.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSDictionary)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *NSDictionary) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *NSDictionary) ScriptingIsGreaterThanOrEqualTo(object NSObject) bool {
	ret := (bool)(C.NSDictionary_inst_ScriptingIsGreaterThanOrEqualTo(o.Ptr(), object.Ptr()))
	runtime.KeepAlive(o)
	return ret
}

func (o *NSDictionary) WillChangeValueForKey(key *NSString)  {
	C.NSDictionary_inst_WillChangeValueForKey(o.Ptr(), key.Ptr())
	runtime.KeepAlive(o)
}

func (o *NSDictionary) WillChangeValueForKeyWithSetMutation(key *NSString, mutationKind NSKeyValueSetMutationKind, objects *NSSet)  {
	C.NSDictionary_inst_WillChangeValueForKeyWithSetMutation(o.Ptr(), key.Ptr(), (C.NSKeyValueSetMutationKind)(mutationKind), objects.Ptr())
	runtime.KeepAlive(o)
}

func (o *NSDictionary) WillChangeValueForKeyWithSetMutationUsingObjects(key *NSString, mutationKind NSKeyValueSetMutationKind, objects *NSSet)  {
	C.NSDictionary_inst_WillChangeValueForKeyWithSetMutationUsingObjects(o.Ptr(), key.Ptr(), (C.NSKeyValueSetMutationKind)(mutationKind), objects.Ptr())
	runtime.KeepAlive(o)
}

func (o *NSDictionary) InsertValueInPropertyWithKey(value NSObject, key *NSString)  {
	C.NSDictionary_inst_InsertValueInPropertyWithKey(o.Ptr(), value.Ptr(), key.Ptr())
	runtime.KeepAlive(o)
}

func (o *NSDictionary) InsertValueAtIndex(value NSObject, index NSUInteger, key *NSString)  {
	C.NSDictionary_inst_InsertValueAtIndex(o.Ptr(), value.Ptr(), (C.NSUInteger)(index), key.Ptr())
	runtime.KeepAlive(o)
}

func (o *NSDictionary) InsertValueAtIndexInPropertyWithKey(value NSObject, index NSUInteger, key *NSString)  {
	C.NSDictionary_inst_InsertValueAtIndexInPropertyWithKey(o.Ptr(), value.Ptr(), (C.NSUInteger)(index), key.Ptr())
	runtime.KeepAlive(o)
}

func (o *NSDictionary) ObserveValueForKeyPathOfObject(keyPath *NSString, object NSObject, change *NSDictionary, context unsafe.Pointer)  {
	C.NSDictionary_inst_ObserveValueForKeyPathOfObject(o.Ptr(), keyPath.Ptr(), object.Ptr(), change.Ptr(), unsafe.Pointer(context))
	runtime.KeepAlive(o)
}

func (o *NSDictionary) ObserveValueForKeyPathOfObjectChange(keyPath *NSString, object NSObject, change *NSDictionary, context unsafe.Pointer)  {
	C.NSDictionary_inst_ObserveValueForKeyPathOfObjectChange(o.Ptr(), keyPath.Ptr(), object.Ptr(), change.Ptr(), unsafe.Pointer(context))
	runtime.KeepAlive(o)
}

func (o *NSDictionary) FileCreationDate() *NSDate {
	ret := &NSDate{}
	ret.ptr = unsafe.Pointer(C.NSDictionary_inst_FileCreationDate(o.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSDate)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *NSDate) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *NSDictionary) CountByEnumeratingWithStateObjects(state *NSFastEnumerationState, buffer *[]*Id, len_ NSUInteger) NSUInteger {

	goSlice2 := make([]unsafe.Pointer,cap(*buffer))
	for i := 0; i < len(*buffer); i++ {
		goSlice2[i] = (*buffer)[i].Ptr()
	}
	ret := (NSUInteger)(C.NSDictionary_inst_CountByEnumeratingWithStateObjects(o.Ptr(), unsafe.Pointer(state), (*unsafe.Pointer)(unsafe.Pointer(&goSlice2[0])), (C.NSUInteger)(len_)))
	(*buffer) = (*buffer)[:cap(*buffer)]
	for i := 0; i < len(*buffer); i++ {
		if goSlice2[i] == nil {
			(*buffer) = (*buffer)[:i]
			break
		}
		if (*buffer)[i] == nil {
			(*buffer)[i] = &Id{}
			runtime.SetFinalizer((*buffer)[i], func(o *Id) {
				o.Release()
			})
		}
		(*buffer)[i].ptr = goSlice2[i]
	}
	runtime.KeepAlive(o)
	return ret
}

func (o *NSDictionary) CountByEnumeratingWithStateObjectsCount(state *NSFastEnumerationState, buffer *[]*Id, len_ NSUInteger) NSUInteger {

	goSlice2 := make([]unsafe.Pointer,cap(*buffer))
	for i := 0; i < len(*buffer); i++ {
		goSlice2[i] = (*buffer)[i].Ptr()
	}
	ret := (NSUInteger)(C.NSDictionary_inst_CountByEnumeratingWithStateObjectsCount(o.Ptr(), unsafe.Pointer(state), (*unsafe.Pointer)(unsafe.Pointer(&goSlice2[0])), (C.NSUInteger)(len_)))
	(*buffer) = (*buffer)[:cap(*buffer)]
	for i := 0; i < len(*buffer); i++ {
		if goSlice2[i] == nil {
			(*buffer) = (*buffer)[:i]
			break
		}
		if (*buffer)[i] == nil {
			(*buffer)[i] = &Id{}
			runtime.SetFinalizer((*buffer)[i], func(o *Id) {
				o.Release()
			})
		}
		(*buffer)[i].ptr = goSlice2[i]
	}
	runtime.KeepAlive(o)
	return ret
}

func (o *NSDictionary) FileModificationDate() *NSDate {
	ret := &NSDate{}
	ret.ptr = unsafe.Pointer(C.NSDictionary_inst_FileModificationDate(o.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSDate)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *NSDate) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *NSDictionary) SetScriptingProperties(scriptingProperties *NSDictionary)  {
	C.NSDictionary_inst_SetScriptingProperties(o.Ptr(), scriptingProperties.Ptr())
	runtime.KeepAlive(o)
}

func (o *NSDictionary) ScriptingIsGreaterThan(object NSObject) bool {
	ret := (bool)(C.NSDictionary_inst_ScriptingIsGreaterThan(o.Ptr(), object.Ptr()))
	runtime.KeepAlive(o)
	return ret
}

func (o *NSDictionary) PerformSelectorOnMainThreadWithObject(aSelector SEL, arg NSObject, wait BOOL)  {
	C.NSDictionary_inst_PerformSelectorOnMainThreadWithObject(o.Ptr(), unsafe.Pointer(aSelector), arg.Ptr(), (C.BOOL)(wait))
	runtime.KeepAlive(o)
}

func (o *NSDictionary) PerformSelectorOnMainThreadWithObjectWaitUntilDone(aSelector SEL, arg NSObject, wait BOOL)  {
	C.NSDictionary_inst_PerformSelectorOnMainThreadWithObjectWaitUntilDone(o.Ptr(), unsafe.Pointer(aSelector), arg.Ptr(), (C.BOOL)(wait))
	runtime.KeepAlive(o)
}

func (o *NSDictionary) PerformSelectorOnMainThreadWithObjectWaitUntilDoneModes(aSelector SEL, arg NSObject, wait BOOL, array *NSArray)  {
	C.NSDictionary_inst_PerformSelectorOnMainThreadWithObjectWaitUntilDoneModes(o.Ptr(), unsafe.Pointer(aSelector), arg.Ptr(), (C.BOOL)(wait), array.Ptr())
	runtime.KeepAlive(o)
}

func (o *NSDictionary) ClassForKeyedArchiver() Class {
	ret := (Class)(unsafe.Pointer(C.NSDictionary_inst_ClassForKeyedArchiver(o.Ptr())))
	runtime.KeepAlive(o)
	return ret
}

func (o *NSDictionary) FilePosixPermissions() NSUInteger {
	ret := (NSUInteger)(C.NSDictionary_inst_FilePosixPermissions(o.Ptr()))
	runtime.KeepAlive(o)
	return ret
}

func (o *NSDictionary) IsGreaterThanOrEqualTo(object NSObject) bool {
	ret := (bool)(C.NSDictionary_inst_IsGreaterThanOrEqualTo(o.Ptr(), object.Ptr()))
	runtime.KeepAlive(o)
	return ret
}

func (o *NSDictionary) IsLessThan(object NSObject) bool {
	ret := (bool)(C.NSDictionary_inst_IsLessThan(o.Ptr(), object.Ptr()))
	runtime.KeepAlive(o)
	return ret
}

func (o *NSDictionary) FileGroupOwnerAccountName() *NSString {
	ret := &NSString{}
	ret.ptr = unsafe.Pointer(C.NSDictionary_inst_FileGroupOwnerAccountName(o.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSString)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *NSString) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func (o *NSDictionary) IsGreaterThan(object NSObject) bool {
	ret := (bool)(C.NSDictionary_inst_IsGreaterThan(o.Ptr(), object.Ptr()))
	runtime.KeepAlive(o)
	return ret
}

func (o *NSDictionary) GetClass() Class {
	ret := (Class)(unsafe.Pointer(C.NSDictionary_inst_Class(o.Ptr())))
	runtime.KeepAlive(o)
	return ret
}

func (o *NSDictionary) ScriptingIsEqualTo(object NSObject) bool {
	ret := (bool)(C.NSDictionary_inst_ScriptingIsEqualTo(o.Ptr(), object.Ptr()))
	runtime.KeepAlive(o)
	return ret
}

func (o *NSDictionary) DictionaryWithValuesForKeys(keys *NSArray) *NSDictionary {
	ret := &NSDictionary{}
	ret.ptr = unsafe.Pointer(C.NSDictionary_inst_DictionaryWithValuesForKeys(o.Ptr(), keys.Ptr()))
	if ret.ptr == nil { runtime.KeepAlive(o); return ret }
	if ret.ptr == o.ptr { runtime.KeepAlive(o); return (*NSDictionary)(unsafe.Pointer(o)) }
	runtime.SetFinalizer(ret, func(o *NSDictionary) {
		o.Release()
	})
	runtime.KeepAlive(o)
	return ret
}

func DispatchQueueCreate(label *Char, attr Dispatch_queue_attr_t) Dispatch_queue_t {
	ret := &Id{}
	ret.ptr = unsafe.Pointer(C.dispatch_queue_create((*C.char)(label), (C.dispatch_queue_attr_t)(attr.Ptr())))
	if ret.ptr == nil {
		log.Print("Queue is nil")
		return ret
	}
	return ret
}

func NSMakeRange(loc NSUInteger, len_ NSUInteger) NSRange {
	ret := (NSRange)(C.NSMakeRange((C.NSUInteger)(loc), (C.NSUInteger)(len_)))
	return ret
}

func CBDelegateAlloc() *CBDelegate {
	ret := &CBDelegate{}
	ret.ptr = unsafe.Pointer(C.CBDelegateAlloc())
	if ret.ptr == nil { return ret }
	runtime.SetFinalizer(ret,func(o *CBDelegate) {
		o.Release()
	})
	return ret
}

func (o *CBDelegate) GC() {
	if o.ptr == nil { return }
	runtime.SetFinalizer(o,func(o *CBDelegate) {
		o.Release()
	})
}

type CBDelegateDispatch struct {
	CentralManagerDidConnectPeripheral func(CBDelegate, *CBCentralManager, *CBPeripheral)
	CentralManagerDidDisconnectPeripheral func(CBDelegate, *CBCentralManager, *CBPeripheral, *NSError)
	CentralManagerDidDiscoverPeripheral func(CBDelegate, *CBCentralManager, *CBPeripheral, *NSDictionary, *NSNumber)
	CentralManagerDidUpdateState func(CBDelegate, *CBCentralManager)
	PeripheralDidDiscoverServices func(CBDelegate, *CBPeripheral, *NSError)
	PeripheralDidDiscoverCharacteristicsForService func(CBDelegate, *CBPeripheral, *CBService, *NSError)
	PeripheralDidUpdateValueForCharacteristic func(CBDelegate, *CBPeripheral, *CBCharacteristic, *NSError)
}
var CBDelegateLookup = map[unsafe.Pointer]CBDelegateDispatch{}
var CBDelegateMux sync.RWMutex

func (d CBDelegate) CentralManagerDidConnectPeripheralCallback(f func(CBDelegate, *CBCentralManager, *CBPeripheral)) {
	CBDelegateMux.Lock()
	dispatch := CBDelegateLookup[d.Ptr()]
	dispatch.CentralManagerDidConnectPeripheral = f
	CBDelegateLookup[d.Ptr()] = dispatch
	CBDelegateMux.Unlock()
}

func (d CBDelegate) CentralManagerDidDisconnectPeripheralCallback(f func(CBDelegate, *CBCentralManager, *CBPeripheral, *NSError)) {
	CBDelegateMux.Lock()
	dispatch := CBDelegateLookup[d.Ptr()]
	dispatch.CentralManagerDidDisconnectPeripheral = f
	CBDelegateLookup[d.Ptr()] = dispatch
	CBDelegateMux.Unlock()
}

func (d CBDelegate) CentralManagerDidDiscoverPeripheralCallback(f func(CBDelegate, *CBCentralManager, *CBPeripheral, *NSDictionary, *NSNumber)) {
	CBDelegateMux.Lock()
	dispatch := CBDelegateLookup[d.Ptr()]
	dispatch.CentralManagerDidDiscoverPeripheral = f
	CBDelegateLookup[d.Ptr()] = dispatch
	CBDelegateMux.Unlock()
}

func (d CBDelegate) CentralManagerDidUpdateStateCallback(f func(CBDelegate, *CBCentralManager)) {
	CBDelegateMux.Lock()
	dispatch := CBDelegateLookup[d.Ptr()]
	dispatch.CentralManagerDidUpdateState = f
	CBDelegateLookup[d.Ptr()] = dispatch
	CBDelegateMux.Unlock()
}

func (d CBDelegate) PeripheralDidDiscoverServicesCallback(f func(CBDelegate, *CBPeripheral, *NSError)) {
	CBDelegateMux.Lock()
	dispatch := CBDelegateLookup[d.Ptr()]
	dispatch.PeripheralDidDiscoverServices = f
	CBDelegateLookup[d.Ptr()] = dispatch
	CBDelegateMux.Unlock()
}

func (d CBDelegate) PeripheralDidDiscoverCharacteristicsForServiceCallback(f func(CBDelegate, *CBPeripheral, *CBService, *NSError)) {
	CBDelegateMux.Lock()
	dispatch := CBDelegateLookup[d.Ptr()]
	dispatch.PeripheralDidDiscoverCharacteristicsForService = f
	CBDelegateLookup[d.Ptr()] = dispatch
	CBDelegateMux.Unlock()
}

func (d CBDelegate) PeripheralDidUpdateValueForCharacteristicCallback(f func(CBDelegate, *CBPeripheral, *CBCharacteristic, *NSError)) {
	CBDelegateMux.Lock()
	dispatch := CBDelegateLookup[d.Ptr()]
	dispatch.PeripheralDidUpdateValueForCharacteristic = f
	CBDelegateLookup[d.Ptr()] = dispatch
	CBDelegateMux.Unlock()
}

func (o *CBDelegate) CentralManagerWillRestoreState(central *CBCentralManager, dict *NSDictionary)  {
	C.CBDelegate_inst_CentralManagerWillRestoreState(unsafe.Pointer(o), central.Ptr(), dict.Ptr())
	runtime.KeepAlive(o)
}

func (o *CBDelegate) CentralManagerDidFailToConnectPeripheral(central *CBCentralManager, peripheral *CBPeripheral, error *NSError)  {
	C.CBDelegate_inst_CentralManagerDidFailToConnectPeripheral(unsafe.Pointer(o), central.Ptr(), peripheral.Ptr(), error.Ptr())
	runtime.KeepAlive(o)
}

func (o *CBDelegate) PeripheralDidUpdateName(peripheral *CBPeripheral)  {
	C.CBDelegate_inst_PeripheralDidUpdateName(unsafe.Pointer(o), peripheral.Ptr())
	runtime.KeepAlive(o)
}

func (o *CBDelegate) PeripheralDidModifyServices(peripheral *CBPeripheral, invalidatedServices *NSArray)  {
	C.CBDelegate_inst_PeripheralDidModifyServices(unsafe.Pointer(o), peripheral.Ptr(), invalidatedServices.Ptr())
	runtime.KeepAlive(o)
}

func (o *CBDelegate) PeripheralDidReadRSSI(peripheral *CBPeripheral, RSSI *NSNumber, error *NSError)  {
	C.CBDelegate_inst_PeripheralDidReadRSSI(unsafe.Pointer(o), peripheral.Ptr(), RSSI.Ptr(), error.Ptr())
	runtime.KeepAlive(o)
}

func (o *CBDelegate) PeripheralDidDiscoverIncludedServicesForService(peripheral *CBPeripheral, service *CBService, error *NSError)  {
	C.CBDelegate_inst_PeripheralDidDiscoverIncludedServicesForService(unsafe.Pointer(o), peripheral.Ptr(), service.Ptr(), error.Ptr())
	runtime.KeepAlive(o)
}

func (o *CBDelegate) PeripheralDidWriteValueForCharacteristic(peripheral *CBPeripheral, characteristic *CBCharacteristic, error *NSError)  {
	C.CBDelegate_inst_PeripheralDidWriteValueForCharacteristic(unsafe.Pointer(o), peripheral.Ptr(), characteristic.Ptr(), error.Ptr())
	runtime.KeepAlive(o)
}

func (o *CBDelegate) PeripheralDidUpdateNotificationStateForCharacteristic(peripheral *CBPeripheral, characteristic *CBCharacteristic, error *NSError)  {
	C.CBDelegate_inst_PeripheralDidUpdateNotificationStateForCharacteristic(unsafe.Pointer(o), peripheral.Ptr(), characteristic.Ptr(), error.Ptr())
	runtime.KeepAlive(o)
}

func (o *CBDelegate) PeripheralDidDiscoverDescriptorsForCharacteristic(peripheral *CBPeripheral, characteristic *CBCharacteristic, error *NSError)  {
	C.CBDelegate_inst_PeripheralDidDiscoverDescriptorsForCharacteristic(unsafe.Pointer(o), peripheral.Ptr(), characteristic.Ptr(), error.Ptr())
	runtime.KeepAlive(o)
}

func (o *CBDelegate) PeripheralDidUpdateValueForDescriptor(peripheral *CBPeripheral, descriptor *CBDescriptor, error *NSError)  {
	C.CBDelegate_inst_PeripheralDidUpdateValueForDescriptor(unsafe.Pointer(o), peripheral.Ptr(), descriptor.Ptr(), error.Ptr())
	runtime.KeepAlive(o)
}

func (o *CBDelegate) PeripheralDidWriteValueForDescriptor(peripheral *CBPeripheral, descriptor *CBDescriptor, error *NSError)  {
	C.CBDelegate_inst_PeripheralDidWriteValueForDescriptor(unsafe.Pointer(o), peripheral.Ptr(), descriptor.Ptr(), error.Ptr())
	runtime.KeepAlive(o)
}

func (o *CBDelegate) PeripheralDidOpenL2CAPChannel(peripheral *CBPeripheral, channel *CBL2CAPChannel, error *NSError)  {
	C.CBDelegate_inst_PeripheralDidOpenL2CAPChannel(unsafe.Pointer(o), peripheral.Ptr(), channel.Ptr(), error.Ptr())
	runtime.KeepAlive(o)
}

func (o *CBDelegate) PeripheralIsReadyToSendWriteWithoutResponse(peripheral *CBPeripheral)  {
	C.CBDelegate_inst_PeripheralIsReadyToSendWriteWithoutResponse(unsafe.Pointer(o), peripheral.Ptr())
	runtime.KeepAlive(o)
}